xref: /openbmc/linux/drivers/scsi/3w-9xxx.c (revision e2f1cf25)
1 /*
2    3w-9xxx.c -- 3ware 9000 Storage Controller device driver for Linux.
3 
4    Written By: Adam Radford <linuxraid@lsi.com>
5    Modifications By: Tom Couch <linuxraid@lsi.com>
6 
7    Copyright (C) 2004-2009 Applied Micro Circuits Corporation.
8    Copyright (C) 2010 LSI Corporation.
9 
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.
13 
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.
18 
19    NO WARRANTY
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.
29 
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
38 
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
42 
43    Bugs/Comments/Suggestions should be mailed to:
44    linuxraid@lsi.com
45 
46    For more information, goto:
47    http://www.lsi.com
48 
49    Note: This version of the driver does not contain a bundled firmware
50          image.
51 
52    History
53    -------
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.
57                  Add lun support.
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().
71                  Serialize reset code.
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.
82 */
83 
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/slab.h>
96 #include <asm/io.h>
97 #include <asm/irq.h>
98 #include <asm/uaccess.h>
99 #include <scsi/scsi.h>
100 #include <scsi/scsi_host.h>
101 #include <scsi/scsi_tcq.h>
102 #include <scsi/scsi_cmnd.h>
103 #include "3w-9xxx.h"
104 
105 /* Globals */
106 #define TW_DRIVER_VERSION "2.26.02.014"
107 static DEFINE_MUTEX(twa_chrdev_mutex);
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;
112 
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);
118 
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");
122 
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 long twa_chrdev_ioctl(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 
153 /* Functions */
154 
155 /* Show some statistics about the card */
156 static ssize_t twa_show_stats(struct device *dev,
157 			      struct device_attribute *attr, char *buf)
158 {
159 	struct Scsi_Host *host = class_to_shost(dev);
160 	TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
161 	unsigned long flags = 0;
162 	ssize_t len;
163 
164 	spin_lock_irqsave(tw_dev->host->host_lock, flags);
165 	len = snprintf(buf, PAGE_SIZE, "3w-9xxx Driver version: %s\n"
166 		       "Current commands posted:   %4d\n"
167 		       "Max commands posted:       %4d\n"
168 		       "Current pending commands:  %4d\n"
169 		       "Max pending commands:      %4d\n"
170 		       "Last sgl length:           %4d\n"
171 		       "Max sgl length:            %4d\n"
172 		       "Last sector count:         %4d\n"
173 		       "Max sector count:          %4d\n"
174 		       "SCSI Host Resets:          %4d\n"
175 		       "AEN's:                     %4d\n",
176 		       TW_DRIVER_VERSION,
177 		       tw_dev->posted_request_count,
178 		       tw_dev->max_posted_request_count,
179 		       tw_dev->pending_request_count,
180 		       tw_dev->max_pending_request_count,
181 		       tw_dev->sgl_entries,
182 		       tw_dev->max_sgl_entries,
183 		       tw_dev->sector_count,
184 		       tw_dev->max_sector_count,
185 		       tw_dev->num_resets,
186 		       tw_dev->aen_count);
187 	spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
188 	return len;
189 } /* End twa_show_stats() */
190 
191 /* Create sysfs 'stats' entry */
192 static struct device_attribute twa_host_stats_attr = {
193 	.attr = {
194 		.name = 	"stats",
195 		.mode =		S_IRUGO,
196 	},
197 	.show = twa_show_stats
198 };
199 
200 /* Host attributes initializer */
201 static struct device_attribute *twa_host_attrs[] = {
202 	&twa_host_stats_attr,
203 	NULL,
204 };
205 
206 /* File operations struct for character device */
207 static const struct file_operations twa_fops = {
208 	.owner		= THIS_MODULE,
209 	.unlocked_ioctl	= twa_chrdev_ioctl,
210 	.open		= twa_chrdev_open,
211 	.release	= NULL,
212 	.llseek		= noop_llseek,
213 };
214 
215 /* This function will complete an aen request from the isr */
216 static int twa_aen_complete(TW_Device_Extension *tw_dev, int request_id)
217 {
218 	TW_Command_Full *full_command_packet;
219 	TW_Command *command_packet;
220 	TW_Command_Apache_Header *header;
221 	unsigned short aen;
222 	int retval = 1;
223 
224 	header = (TW_Command_Apache_Header *)tw_dev->generic_buffer_virt[request_id];
225 	tw_dev->posted_request_count--;
226 	aen = le16_to_cpu(header->status_block.error);
227 	full_command_packet = tw_dev->command_packet_virt[request_id];
228 	command_packet = &full_command_packet->command.oldcommand;
229 
230 	/* First check for internal completion of set param for time sync */
231 	if (TW_OP_OUT(command_packet->opcode__sgloffset) == TW_OP_SET_PARAM) {
232 		/* Keep reading the queue in case there are more aen's */
233 		if (twa_aen_read_queue(tw_dev, request_id))
234 			goto out2;
235 	        else {
236 			retval = 0;
237 			goto out;
238 		}
239 	}
240 
241 	switch (aen) {
242 	case TW_AEN_QUEUE_EMPTY:
243 		/* Quit reading the queue if this is the last one */
244 		break;
245 	case TW_AEN_SYNC_TIME_WITH_HOST:
246 		twa_aen_sync_time(tw_dev, request_id);
247 		retval = 0;
248 		goto out;
249 	default:
250 		twa_aen_queue_event(tw_dev, header);
251 
252 		/* If there are more aen's, keep reading the queue */
253 		if (twa_aen_read_queue(tw_dev, request_id))
254 			goto out2;
255 		else {
256 			retval = 0;
257 			goto out;
258 		}
259 	}
260 	retval = 0;
261 out2:
262 	tw_dev->state[request_id] = TW_S_COMPLETED;
263 	twa_free_request_id(tw_dev, request_id);
264 	clear_bit(TW_IN_ATTENTION_LOOP, &tw_dev->flags);
265 out:
266 	return retval;
267 } /* End twa_aen_complete() */
268 
269 /* This function will drain aen queue */
270 static int twa_aen_drain_queue(TW_Device_Extension *tw_dev, int no_check_reset)
271 {
272 	int request_id = 0;
273 	char cdb[TW_MAX_CDB_LEN];
274 	TW_SG_Entry sglist[1];
275 	int finished = 0, count = 0;
276 	TW_Command_Full *full_command_packet;
277 	TW_Command_Apache_Header *header;
278 	unsigned short aen;
279 	int first_reset = 0, queue = 0, retval = 1;
280 
281 	if (no_check_reset)
282 		first_reset = 0;
283 	else
284 		first_reset = 1;
285 
286 	full_command_packet = tw_dev->command_packet_virt[request_id];
287 	memset(full_command_packet, 0, sizeof(TW_Command_Full));
288 
289 	/* Initialize cdb */
290 	memset(&cdb, 0, TW_MAX_CDB_LEN);
291 	cdb[0] = REQUEST_SENSE; /* opcode */
292 	cdb[4] = TW_ALLOCATION_LENGTH; /* allocation length */
293 
294 	/* Initialize sglist */
295 	memset(&sglist, 0, sizeof(TW_SG_Entry));
296 	sglist[0].length = TW_SECTOR_SIZE;
297 	sglist[0].address = tw_dev->generic_buffer_phys[request_id];
298 
299 	if (sglist[0].address & TW_ALIGNMENT_9000_SGL) {
300 		TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1, "Found unaligned address during AEN drain");
301 		goto out;
302 	}
303 
304 	/* Mark internal command */
305 	tw_dev->srb[request_id] = NULL;
306 
307 	do {
308 		/* Send command to the board */
309 		if (twa_scsiop_execute_scsi(tw_dev, request_id, cdb, 1, sglist)) {
310 			TW_PRINTK(tw_dev->host, TW_DRIVER, 0x2, "Error posting request sense");
311 			goto out;
312 		}
313 
314 		/* Now poll for completion */
315 		if (twa_poll_response(tw_dev, request_id, 30)) {
316 			TW_PRINTK(tw_dev->host, TW_DRIVER, 0x3, "No valid response while draining AEN queue");
317 			tw_dev->posted_request_count--;
318 			goto out;
319 		}
320 
321 		tw_dev->posted_request_count--;
322 		header = (TW_Command_Apache_Header *)tw_dev->generic_buffer_virt[request_id];
323 		aen = le16_to_cpu(header->status_block.error);
324 		queue = 0;
325 		count++;
326 
327 		switch (aen) {
328 		case TW_AEN_QUEUE_EMPTY:
329 			if (first_reset != 1)
330 				goto out;
331 			else
332 				finished = 1;
333 			break;
334 		case TW_AEN_SOFT_RESET:
335 			if (first_reset == 0)
336 				first_reset = 1;
337 			else
338 				queue = 1;
339 			break;
340 		case TW_AEN_SYNC_TIME_WITH_HOST:
341 			break;
342 		default:
343 			queue = 1;
344 		}
345 
346 		/* Now queue an event info */
347 		if (queue)
348 			twa_aen_queue_event(tw_dev, header);
349 	} while ((finished == 0) && (count < TW_MAX_AEN_DRAIN));
350 
351 	if (count == TW_MAX_AEN_DRAIN)
352 		goto out;
353 
354 	retval = 0;
355 out:
356 	tw_dev->state[request_id] = TW_S_INITIAL;
357 	return retval;
358 } /* End twa_aen_drain_queue() */
359 
360 /* This function will queue an event */
361 static void twa_aen_queue_event(TW_Device_Extension *tw_dev, TW_Command_Apache_Header *header)
362 {
363 	u32 local_time;
364 	struct timeval time;
365 	TW_Event *event;
366 	unsigned short aen;
367 	char host[16];
368 	char *error_str;
369 
370 	tw_dev->aen_count++;
371 
372 	/* Fill out event info */
373 	event = tw_dev->event_queue[tw_dev->error_index];
374 
375 	/* Check for clobber */
376 	host[0] = '\0';
377 	if (tw_dev->host) {
378 		sprintf(host, " scsi%d:", tw_dev->host->host_no);
379 		if (event->retrieved == TW_AEN_NOT_RETRIEVED)
380 			tw_dev->aen_clobber = 1;
381 	}
382 
383 	aen = le16_to_cpu(header->status_block.error);
384 	memset(event, 0, sizeof(TW_Event));
385 
386 	event->severity = TW_SEV_OUT(header->status_block.severity__reserved);
387 	do_gettimeofday(&time);
388 	local_time = (u32)(time.tv_sec - (sys_tz.tz_minuteswest * 60));
389 	event->time_stamp_sec = local_time;
390 	event->aen_code = aen;
391 	event->retrieved = TW_AEN_NOT_RETRIEVED;
392 	event->sequence_id = tw_dev->error_sequence_id;
393 	tw_dev->error_sequence_id++;
394 
395 	/* Check for embedded error string */
396 	error_str = &(header->err_specific_desc[strlen(header->err_specific_desc)+1]);
397 
398 	header->err_specific_desc[sizeof(header->err_specific_desc) - 1] = '\0';
399 	event->parameter_len = strlen(header->err_specific_desc);
400 	memcpy(event->parameter_data, header->err_specific_desc, event->parameter_len + (error_str[0] == '\0' ? 0 : (1 + strlen(error_str))));
401 	if (event->severity != TW_AEN_SEVERITY_DEBUG)
402 		printk(KERN_WARNING "3w-9xxx:%s AEN: %s (0x%02X:0x%04X): %s:%s.\n",
403 		       host,
404 		       twa_aen_severity_lookup(TW_SEV_OUT(header->status_block.severity__reserved)),
405 		       TW_MESSAGE_SOURCE_CONTROLLER_EVENT, aen,
406 		       error_str[0] == '\0' ? twa_string_lookup(twa_aen_table, aen) : error_str,
407 		       header->err_specific_desc);
408 	else
409 		tw_dev->aen_count--;
410 
411 	if ((tw_dev->error_index + 1) == TW_Q_LENGTH)
412 		tw_dev->event_queue_wrapped = 1;
413 	tw_dev->error_index = (tw_dev->error_index + 1 ) % TW_Q_LENGTH;
414 } /* End twa_aen_queue_event() */
415 
416 /* This function will read the aen queue from the isr */
417 static int twa_aen_read_queue(TW_Device_Extension *tw_dev, int request_id)
418 {
419 	char cdb[TW_MAX_CDB_LEN];
420 	TW_SG_Entry sglist[1];
421 	TW_Command_Full *full_command_packet;
422 	int retval = 1;
423 
424 	full_command_packet = tw_dev->command_packet_virt[request_id];
425 	memset(full_command_packet, 0, sizeof(TW_Command_Full));
426 
427 	/* Initialize cdb */
428 	memset(&cdb, 0, TW_MAX_CDB_LEN);
429 	cdb[0] = REQUEST_SENSE; /* opcode */
430 	cdb[4] = TW_ALLOCATION_LENGTH; /* allocation length */
431 
432 	/* Initialize sglist */
433 	memset(&sglist, 0, sizeof(TW_SG_Entry));
434 	sglist[0].length = TW_SECTOR_SIZE;
435 	sglist[0].address = tw_dev->generic_buffer_phys[request_id];
436 
437 	/* Mark internal command */
438 	tw_dev->srb[request_id] = NULL;
439 
440 	/* Now post the command packet */
441 	if (twa_scsiop_execute_scsi(tw_dev, request_id, cdb, 1, sglist)) {
442 		TW_PRINTK(tw_dev->host, TW_DRIVER, 0x4, "Post failed while reading AEN queue");
443 		goto out;
444 	}
445 	retval = 0;
446 out:
447 	return retval;
448 } /* End twa_aen_read_queue() */
449 
450 /* This function will look up an AEN severity string */
451 static char *twa_aen_severity_lookup(unsigned char severity_code)
452 {
453 	char *retval = NULL;
454 
455 	if ((severity_code < (unsigned char) TW_AEN_SEVERITY_ERROR) ||
456 	    (severity_code > (unsigned char) TW_AEN_SEVERITY_DEBUG))
457 		goto out;
458 
459 	retval = twa_aen_severity_table[severity_code];
460 out:
461 	return retval;
462 } /* End twa_aen_severity_lookup() */
463 
464 /* This function will sync firmware time with the host time */
465 static void twa_aen_sync_time(TW_Device_Extension *tw_dev, int request_id)
466 {
467 	u32 schedulertime;
468 	struct timeval utc;
469 	TW_Command_Full *full_command_packet;
470 	TW_Command *command_packet;
471 	TW_Param_Apache *param;
472 	u32 local_time;
473 
474 	/* Fill out the command packet */
475 	full_command_packet = tw_dev->command_packet_virt[request_id];
476 	memset(full_command_packet, 0, sizeof(TW_Command_Full));
477 	command_packet = &full_command_packet->command.oldcommand;
478 	command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_SET_PARAM);
479 	command_packet->request_id = request_id;
480 	command_packet->byte8_offset.param.sgl[0].address = TW_CPU_TO_SGL(tw_dev->generic_buffer_phys[request_id]);
481 	command_packet->byte8_offset.param.sgl[0].length = cpu_to_le32(TW_SECTOR_SIZE);
482 	command_packet->size = TW_COMMAND_SIZE;
483 	command_packet->byte6_offset.parameter_count = cpu_to_le16(1);
484 
485 	/* Setup the param */
486 	param = (TW_Param_Apache *)tw_dev->generic_buffer_virt[request_id];
487 	memset(param, 0, TW_SECTOR_SIZE);
488 	param->table_id = cpu_to_le16(TW_TIMEKEEP_TABLE | 0x8000); /* Controller time keep table */
489 	param->parameter_id = cpu_to_le16(0x3); /* SchedulerTime */
490 	param->parameter_size_bytes = cpu_to_le16(4);
491 
492 	/* Convert system time in UTC to local time seconds since last
493            Sunday 12:00AM */
494 	do_gettimeofday(&utc);
495 	local_time = (u32)(utc.tv_sec - (sys_tz.tz_minuteswest * 60));
496 	schedulertime = local_time - (3 * 86400);
497 	schedulertime = cpu_to_le32(schedulertime % 604800);
498 
499 	memcpy(param->data, &schedulertime, sizeof(u32));
500 
501 	/* Mark internal command */
502 	tw_dev->srb[request_id] = NULL;
503 
504 	/* Now post the command */
505 	twa_post_command_packet(tw_dev, request_id, 1);
506 } /* End twa_aen_sync_time() */
507 
508 /* This function will allocate memory and check if it is correctly aligned */
509 static int twa_allocate_memory(TW_Device_Extension *tw_dev, int size, int which)
510 {
511 	int i;
512 	dma_addr_t dma_handle;
513 	unsigned long *cpu_addr;
514 	int retval = 1;
515 
516 	cpu_addr = pci_alloc_consistent(tw_dev->tw_pci_dev, size*TW_Q_LENGTH, &dma_handle);
517 	if (!cpu_addr) {
518 		TW_PRINTK(tw_dev->host, TW_DRIVER, 0x5, "Memory allocation failed");
519 		goto out;
520 	}
521 
522 	if ((unsigned long)cpu_addr % (TW_ALIGNMENT_9000)) {
523 		TW_PRINTK(tw_dev->host, TW_DRIVER, 0x6, "Failed to allocate correctly aligned memory");
524 		pci_free_consistent(tw_dev->tw_pci_dev, size*TW_Q_LENGTH, cpu_addr, dma_handle);
525 		goto out;
526 	}
527 
528 	memset(cpu_addr, 0, size*TW_Q_LENGTH);
529 
530 	for (i = 0; i < TW_Q_LENGTH; i++) {
531 		switch(which) {
532 		case 0:
533 			tw_dev->command_packet_phys[i] = dma_handle+(i*size);
534 			tw_dev->command_packet_virt[i] = (TW_Command_Full *)((unsigned char *)cpu_addr + (i*size));
535 			break;
536 		case 1:
537 			tw_dev->generic_buffer_phys[i] = dma_handle+(i*size);
538 			tw_dev->generic_buffer_virt[i] = (unsigned long *)((unsigned char *)cpu_addr + (i*size));
539 			break;
540 		}
541 	}
542 	retval = 0;
543 out:
544 	return retval;
545 } /* End twa_allocate_memory() */
546 
547 /* This function will check the status register for unexpected bits */
548 static int twa_check_bits(u32 status_reg_value)
549 {
550 	int retval = 1;
551 
552 	if ((status_reg_value & TW_STATUS_EXPECTED_BITS) != TW_STATUS_EXPECTED_BITS)
553 		goto out;
554 	if ((status_reg_value & TW_STATUS_UNEXPECTED_BITS) != 0)
555 		goto out;
556 
557 	retval = 0;
558 out:
559 	return retval;
560 } /* End twa_check_bits() */
561 
562 /* This function will check the srl and decide if we are compatible  */
563 static int twa_check_srl(TW_Device_Extension *tw_dev, int *flashed)
564 {
565 	int retval = 1;
566 	unsigned short fw_on_ctlr_srl = 0, fw_on_ctlr_arch_id = 0;
567 	unsigned short fw_on_ctlr_branch = 0, fw_on_ctlr_build = 0;
568 	u32 init_connect_result = 0;
569 
570 	if (twa_initconnection(tw_dev, TW_INIT_MESSAGE_CREDITS,
571 			       TW_EXTENDED_INIT_CONNECT, TW_CURRENT_DRIVER_SRL,
572 			       TW_9000_ARCH_ID, TW_CURRENT_DRIVER_BRANCH,
573 			       TW_CURRENT_DRIVER_BUILD, &fw_on_ctlr_srl,
574 			       &fw_on_ctlr_arch_id, &fw_on_ctlr_branch,
575 			       &fw_on_ctlr_build, &init_connect_result)) {
576 		TW_PRINTK(tw_dev->host, TW_DRIVER, 0x7, "Initconnection failed while checking SRL");
577 		goto out;
578 	}
579 
580 	tw_dev->tw_compat_info.working_srl = fw_on_ctlr_srl;
581 	tw_dev->tw_compat_info.working_branch = fw_on_ctlr_branch;
582 	tw_dev->tw_compat_info.working_build = fw_on_ctlr_build;
583 
584 	/* Try base mode compatibility */
585 	if (!(init_connect_result & TW_CTLR_FW_COMPATIBLE)) {
586 		if (twa_initconnection(tw_dev, TW_INIT_MESSAGE_CREDITS,
587 				       TW_EXTENDED_INIT_CONNECT,
588 				       TW_BASE_FW_SRL, TW_9000_ARCH_ID,
589 				       TW_BASE_FW_BRANCH, TW_BASE_FW_BUILD,
590 				       &fw_on_ctlr_srl, &fw_on_ctlr_arch_id,
591 				       &fw_on_ctlr_branch, &fw_on_ctlr_build,
592 				       &init_connect_result)) {
593 			TW_PRINTK(tw_dev->host, TW_DRIVER, 0xa, "Initconnection (base mode) failed while checking SRL");
594 			goto out;
595 		}
596 		if (!(init_connect_result & TW_CTLR_FW_COMPATIBLE)) {
597 			if (TW_CURRENT_DRIVER_SRL > fw_on_ctlr_srl) {
598 				TW_PRINTK(tw_dev->host, TW_DRIVER, 0x32, "Firmware and driver incompatibility: please upgrade firmware");
599 			} else {
600 				TW_PRINTK(tw_dev->host, TW_DRIVER, 0x33, "Firmware and driver incompatibility: please upgrade driver");
601 			}
602 			goto out;
603 		}
604 		tw_dev->tw_compat_info.working_srl = TW_BASE_FW_SRL;
605 		tw_dev->tw_compat_info.working_branch = TW_BASE_FW_BRANCH;
606 		tw_dev->tw_compat_info.working_build = TW_BASE_FW_BUILD;
607 	}
608 
609 	/* Load rest of compatibility struct */
610 	strlcpy(tw_dev->tw_compat_info.driver_version, TW_DRIVER_VERSION,
611 		sizeof(tw_dev->tw_compat_info.driver_version));
612 	tw_dev->tw_compat_info.driver_srl_high = TW_CURRENT_DRIVER_SRL;
613 	tw_dev->tw_compat_info.driver_branch_high = TW_CURRENT_DRIVER_BRANCH;
614 	tw_dev->tw_compat_info.driver_build_high = TW_CURRENT_DRIVER_BUILD;
615 	tw_dev->tw_compat_info.driver_srl_low = TW_BASE_FW_SRL;
616 	tw_dev->tw_compat_info.driver_branch_low = TW_BASE_FW_BRANCH;
617 	tw_dev->tw_compat_info.driver_build_low = TW_BASE_FW_BUILD;
618 	tw_dev->tw_compat_info.fw_on_ctlr_srl = fw_on_ctlr_srl;
619 	tw_dev->tw_compat_info.fw_on_ctlr_branch = fw_on_ctlr_branch;
620 	tw_dev->tw_compat_info.fw_on_ctlr_build = fw_on_ctlr_build;
621 
622 	retval = 0;
623 out:
624 	return retval;
625 } /* End twa_check_srl() */
626 
627 /* This function handles ioctl for the character device */
628 static long twa_chrdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
629 {
630 	struct inode *inode = file_inode(file);
631 	long timeout;
632 	unsigned long *cpu_addr, data_buffer_length_adjusted = 0, flags = 0;
633 	dma_addr_t dma_handle;
634 	int request_id = 0;
635 	unsigned int sequence_id = 0;
636 	unsigned char event_index, start_index;
637 	TW_Ioctl_Driver_Command driver_command;
638 	TW_Ioctl_Buf_Apache *tw_ioctl;
639 	TW_Lock *tw_lock;
640 	TW_Command_Full *full_command_packet;
641 	TW_Compatibility_Info *tw_compat_info;
642 	TW_Event *event;
643 	struct timeval current_time;
644 	u32 current_time_ms;
645 	TW_Device_Extension *tw_dev = twa_device_extension_list[iminor(inode)];
646 	int retval = TW_IOCTL_ERROR_OS_EFAULT;
647 	void __user *argp = (void __user *)arg;
648 
649 	mutex_lock(&twa_chrdev_mutex);
650 
651 	/* Only let one of these through at a time */
652 	if (mutex_lock_interruptible(&tw_dev->ioctl_lock)) {
653 		retval = TW_IOCTL_ERROR_OS_EINTR;
654 		goto out;
655 	}
656 
657 	/* First copy down the driver command */
658 	if (copy_from_user(&driver_command, argp, sizeof(TW_Ioctl_Driver_Command)))
659 		goto out2;
660 
661 	/* Check data buffer size */
662 	if (driver_command.buffer_length > TW_MAX_SECTORS * 2048) {
663 		retval = TW_IOCTL_ERROR_OS_EINVAL;
664 		goto out2;
665 	}
666 
667 	/* Hardware can only do multiple of 512 byte transfers */
668 	data_buffer_length_adjusted = (driver_command.buffer_length + 511) & ~511;
669 
670 	/* Now allocate ioctl buf memory */
671 	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);
672 	if (!cpu_addr) {
673 		retval = TW_IOCTL_ERROR_OS_ENOMEM;
674 		goto out2;
675 	}
676 
677 	tw_ioctl = (TW_Ioctl_Buf_Apache *)cpu_addr;
678 
679 	/* Now copy down the entire ioctl */
680 	if (copy_from_user(tw_ioctl, argp, driver_command.buffer_length + sizeof(TW_Ioctl_Buf_Apache) - 1))
681 		goto out3;
682 
683 	/* See which ioctl we are doing */
684 	switch (cmd) {
685 	case TW_IOCTL_FIRMWARE_PASS_THROUGH:
686 		spin_lock_irqsave(tw_dev->host->host_lock, flags);
687 		twa_get_request_id(tw_dev, &request_id);
688 
689 		/* Flag internal command */
690 		tw_dev->srb[request_id] = NULL;
691 
692 		/* Flag chrdev ioctl */
693 		tw_dev->chrdev_request_id = request_id;
694 
695 		full_command_packet = &tw_ioctl->firmware_command;
696 
697 		/* Load request id and sglist for both command types */
698 		twa_load_sgl(tw_dev, full_command_packet, request_id, dma_handle, data_buffer_length_adjusted);
699 
700 		memcpy(tw_dev->command_packet_virt[request_id], &(tw_ioctl->firmware_command), sizeof(TW_Command_Full));
701 
702 		/* Now post the command packet to the controller */
703 		twa_post_command_packet(tw_dev, request_id, 1);
704 		spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
705 
706 		timeout = TW_IOCTL_CHRDEV_TIMEOUT*HZ;
707 
708 		/* Now wait for command to complete */
709 		timeout = wait_event_timeout(tw_dev->ioctl_wqueue, tw_dev->chrdev_request_id == TW_IOCTL_CHRDEV_FREE, timeout);
710 
711 		/* We timed out, and didn't get an interrupt */
712 		if (tw_dev->chrdev_request_id != TW_IOCTL_CHRDEV_FREE) {
713 			/* Now we need to reset the board */
714 			printk(KERN_WARNING "3w-9xxx: scsi%d: WARNING: (0x%02X:0x%04X): Character ioctl (0x%x) timed out, resetting card.\n",
715 			       tw_dev->host->host_no, TW_DRIVER, 0x37,
716 			       cmd);
717 			retval = TW_IOCTL_ERROR_OS_EIO;
718 			twa_reset_device_extension(tw_dev);
719 			goto out3;
720 		}
721 
722 		/* Now copy in the command packet response */
723 		memcpy(&(tw_ioctl->firmware_command), tw_dev->command_packet_virt[request_id], sizeof(TW_Command_Full));
724 
725 		/* Now complete the io */
726 		spin_lock_irqsave(tw_dev->host->host_lock, flags);
727 		tw_dev->posted_request_count--;
728 		tw_dev->state[request_id] = TW_S_COMPLETED;
729 		twa_free_request_id(tw_dev, request_id);
730 		spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
731 		break;
732 	case TW_IOCTL_GET_COMPATIBILITY_INFO:
733 		tw_ioctl->driver_command.status = 0;
734 		/* Copy compatibility struct into ioctl data buffer */
735 		tw_compat_info = (TW_Compatibility_Info *)tw_ioctl->data_buffer;
736 		memcpy(tw_compat_info, &tw_dev->tw_compat_info, sizeof(TW_Compatibility_Info));
737 		break;
738 	case TW_IOCTL_GET_LAST_EVENT:
739 		if (tw_dev->event_queue_wrapped) {
740 			if (tw_dev->aen_clobber) {
741 				tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_AEN_CLOBBER;
742 				tw_dev->aen_clobber = 0;
743 			} else
744 				tw_ioctl->driver_command.status = 0;
745 		} else {
746 			if (!tw_dev->error_index) {
747 				tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS;
748 				break;
749 			}
750 			tw_ioctl->driver_command.status = 0;
751 		}
752 		event_index = (tw_dev->error_index - 1 + TW_Q_LENGTH) % TW_Q_LENGTH;
753 		memcpy(tw_ioctl->data_buffer, tw_dev->event_queue[event_index], sizeof(TW_Event));
754 		tw_dev->event_queue[event_index]->retrieved = TW_AEN_RETRIEVED;
755 		break;
756 	case TW_IOCTL_GET_FIRST_EVENT:
757 		if (tw_dev->event_queue_wrapped) {
758 			if (tw_dev->aen_clobber) {
759 				tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_AEN_CLOBBER;
760 				tw_dev->aen_clobber = 0;
761 			} else
762 				tw_ioctl->driver_command.status = 0;
763 			event_index = tw_dev->error_index;
764 		} else {
765 			if (!tw_dev->error_index) {
766 				tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS;
767 				break;
768 			}
769 			tw_ioctl->driver_command.status = 0;
770 			event_index = 0;
771 		}
772 		memcpy(tw_ioctl->data_buffer, tw_dev->event_queue[event_index], sizeof(TW_Event));
773 		tw_dev->event_queue[event_index]->retrieved = TW_AEN_RETRIEVED;
774 		break;
775 	case TW_IOCTL_GET_NEXT_EVENT:
776 		event = (TW_Event *)tw_ioctl->data_buffer;
777 		sequence_id = event->sequence_id;
778 		tw_ioctl->driver_command.status = 0;
779 
780 		if (tw_dev->event_queue_wrapped) {
781 			if (tw_dev->aen_clobber) {
782 				tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_AEN_CLOBBER;
783 				tw_dev->aen_clobber = 0;
784 			}
785 			start_index = tw_dev->error_index;
786 		} else {
787 			if (!tw_dev->error_index) {
788 				tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS;
789 				break;
790 			}
791 			start_index = 0;
792 		}
793 		event_index = (start_index + sequence_id - tw_dev->event_queue[start_index]->sequence_id + 1) % TW_Q_LENGTH;
794 
795 		if (!(tw_dev->event_queue[event_index]->sequence_id > sequence_id)) {
796 			if (tw_ioctl->driver_command.status == TW_IOCTL_ERROR_STATUS_AEN_CLOBBER)
797 				tw_dev->aen_clobber = 1;
798 			tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS;
799 			break;
800 		}
801 		memcpy(tw_ioctl->data_buffer, tw_dev->event_queue[event_index], sizeof(TW_Event));
802 		tw_dev->event_queue[event_index]->retrieved = TW_AEN_RETRIEVED;
803 		break;
804 	case TW_IOCTL_GET_PREVIOUS_EVENT:
805 		event = (TW_Event *)tw_ioctl->data_buffer;
806 		sequence_id = event->sequence_id;
807 		tw_ioctl->driver_command.status = 0;
808 
809 		if (tw_dev->event_queue_wrapped) {
810 			if (tw_dev->aen_clobber) {
811 				tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_AEN_CLOBBER;
812 				tw_dev->aen_clobber = 0;
813 			}
814 			start_index = tw_dev->error_index;
815 		} else {
816 			if (!tw_dev->error_index) {
817 				tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS;
818 				break;
819 			}
820 			start_index = 0;
821 		}
822 		event_index = (start_index + sequence_id - tw_dev->event_queue[start_index]->sequence_id - 1) % TW_Q_LENGTH;
823 
824 		if (!(tw_dev->event_queue[event_index]->sequence_id < sequence_id)) {
825 			if (tw_ioctl->driver_command.status == TW_IOCTL_ERROR_STATUS_AEN_CLOBBER)
826 				tw_dev->aen_clobber = 1;
827 			tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS;
828 			break;
829 		}
830 		memcpy(tw_ioctl->data_buffer, tw_dev->event_queue[event_index], sizeof(TW_Event));
831 		tw_dev->event_queue[event_index]->retrieved = TW_AEN_RETRIEVED;
832 		break;
833 	case TW_IOCTL_GET_LOCK:
834 		tw_lock = (TW_Lock *)tw_ioctl->data_buffer;
835 		do_gettimeofday(&current_time);
836 		current_time_ms = (current_time.tv_sec * 1000) + (current_time.tv_usec / 1000);
837 
838 		if ((tw_lock->force_flag == 1) || (tw_dev->ioctl_sem_lock == 0) || (current_time_ms >= tw_dev->ioctl_msec)) {
839 			tw_dev->ioctl_sem_lock = 1;
840 			tw_dev->ioctl_msec = current_time_ms + tw_lock->timeout_msec;
841 			tw_ioctl->driver_command.status = 0;
842 			tw_lock->time_remaining_msec = tw_lock->timeout_msec;
843 		} else {
844 			tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_LOCKED;
845 			tw_lock->time_remaining_msec = tw_dev->ioctl_msec - current_time_ms;
846 		}
847 		break;
848 	case TW_IOCTL_RELEASE_LOCK:
849 		if (tw_dev->ioctl_sem_lock == 1) {
850 			tw_dev->ioctl_sem_lock = 0;
851 			tw_ioctl->driver_command.status = 0;
852 		} else {
853 			tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NOT_LOCKED;
854 		}
855 		break;
856 	default:
857 		retval = TW_IOCTL_ERROR_OS_ENOTTY;
858 		goto out3;
859 	}
860 
861 	/* Now copy the entire response to userspace */
862 	if (copy_to_user(argp, tw_ioctl, sizeof(TW_Ioctl_Buf_Apache) + driver_command.buffer_length - 1) == 0)
863 		retval = 0;
864 out3:
865 	/* Now free ioctl buf memory */
866 	dma_free_coherent(&tw_dev->tw_pci_dev->dev, data_buffer_length_adjusted+sizeof(TW_Ioctl_Buf_Apache) - 1, cpu_addr, dma_handle);
867 out2:
868 	mutex_unlock(&tw_dev->ioctl_lock);
869 out:
870 	mutex_unlock(&twa_chrdev_mutex);
871 	return retval;
872 } /* End twa_chrdev_ioctl() */
873 
874 /* This function handles open for the character device */
875 /* NOTE that this function will race with remove. */
876 static int twa_chrdev_open(struct inode *inode, struct file *file)
877 {
878 	unsigned int minor_number;
879 	int retval = TW_IOCTL_ERROR_OS_ENODEV;
880 
881 	minor_number = iminor(inode);
882 	if (minor_number >= twa_device_extension_count)
883 		goto out;
884 	retval = 0;
885 out:
886 	return retval;
887 } /* End twa_chrdev_open() */
888 
889 /* This function will print readable messages from status register errors */
890 static int twa_decode_bits(TW_Device_Extension *tw_dev, u32 status_reg_value)
891 {
892 	int retval = 1;
893 
894 	/* Check for various error conditions and handle them appropriately */
895 	if (status_reg_value & TW_STATUS_PCI_PARITY_ERROR) {
896 		TW_PRINTK(tw_dev->host, TW_DRIVER, 0xc, "PCI Parity Error: clearing");
897 		writel(TW_CONTROL_CLEAR_PARITY_ERROR, TW_CONTROL_REG_ADDR(tw_dev));
898 	}
899 
900 	if (status_reg_value & TW_STATUS_PCI_ABORT) {
901 		TW_PRINTK(tw_dev->host, TW_DRIVER, 0xd, "PCI Abort: clearing");
902 		writel(TW_CONTROL_CLEAR_PCI_ABORT, TW_CONTROL_REG_ADDR(tw_dev));
903 		pci_write_config_word(tw_dev->tw_pci_dev, PCI_STATUS, TW_PCI_CLEAR_PCI_ABORT);
904 	}
905 
906 	if (status_reg_value & TW_STATUS_QUEUE_ERROR) {
907 		if (((tw_dev->tw_pci_dev->device != PCI_DEVICE_ID_3WARE_9650SE) &&
908 		     (tw_dev->tw_pci_dev->device != PCI_DEVICE_ID_3WARE_9690SA)) ||
909 		    (!test_bit(TW_IN_RESET, &tw_dev->flags)))
910 			TW_PRINTK(tw_dev->host, TW_DRIVER, 0xe, "Controller Queue Error: clearing");
911 		writel(TW_CONTROL_CLEAR_QUEUE_ERROR, TW_CONTROL_REG_ADDR(tw_dev));
912 	}
913 
914 	if (status_reg_value & TW_STATUS_MICROCONTROLLER_ERROR) {
915 		if (tw_dev->reset_print == 0) {
916 			TW_PRINTK(tw_dev->host, TW_DRIVER, 0x10, "Microcontroller Error: clearing");
917 			tw_dev->reset_print = 1;
918 		}
919 		goto out;
920 	}
921 	retval = 0;
922 out:
923 	return retval;
924 } /* End twa_decode_bits() */
925 
926 /* This function will empty the response queue */
927 static int twa_empty_response_queue(TW_Device_Extension *tw_dev)
928 {
929 	u32 status_reg_value, response_que_value;
930 	int count = 0, retval = 1;
931 
932 	status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
933 
934 	while (((status_reg_value & TW_STATUS_RESPONSE_QUEUE_EMPTY) == 0) && (count < TW_MAX_RESPONSE_DRAIN)) {
935 		response_que_value = readl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev));
936 		status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
937 		count++;
938 	}
939 	if (count == TW_MAX_RESPONSE_DRAIN)
940 		goto out;
941 
942 	retval = 0;
943 out:
944 	return retval;
945 } /* End twa_empty_response_queue() */
946 
947 /* This function will clear the pchip/response queue on 9550SX */
948 static int twa_empty_response_queue_large(TW_Device_Extension *tw_dev)
949 {
950 	u32 response_que_value = 0;
951 	unsigned long before;
952 	int retval = 1;
953 
954 	if (tw_dev->tw_pci_dev->device != PCI_DEVICE_ID_3WARE_9000) {
955 		before = jiffies;
956 		while ((response_que_value & TW_9550SX_DRAIN_COMPLETED) != TW_9550SX_DRAIN_COMPLETED) {
957 			response_que_value = readl(TW_RESPONSE_QUEUE_REG_ADDR_LARGE(tw_dev));
958 			msleep(1);
959 			if (time_after(jiffies, before + HZ * 30))
960 				goto out;
961 		}
962 		/* P-chip settle time */
963 		msleep(500);
964 		retval = 0;
965 	} else
966 		retval = 0;
967 out:
968 	return retval;
969 } /* End twa_empty_response_queue_large() */
970 
971 /* This function passes sense keys from firmware to scsi layer */
972 static int twa_fill_sense(TW_Device_Extension *tw_dev, int request_id, int copy_sense, int print_host)
973 {
974 	TW_Command_Full *full_command_packet;
975 	unsigned short error;
976 	int retval = 1;
977 	char *error_str;
978 
979 	full_command_packet = tw_dev->command_packet_virt[request_id];
980 
981 	/* Check for embedded error string */
982 	error_str = &(full_command_packet->header.err_specific_desc[strlen(full_command_packet->header.err_specific_desc) + 1]);
983 
984 	/* Don't print error for Logical unit not supported during rollcall */
985 	error = le16_to_cpu(full_command_packet->header.status_block.error);
986 	if ((error != TW_ERROR_LOGICAL_UNIT_NOT_SUPPORTED) && (error != TW_ERROR_UNIT_OFFLINE)) {
987 		if (print_host)
988 			printk(KERN_WARNING "3w-9xxx: scsi%d: ERROR: (0x%02X:0x%04X): %s:%s.\n",
989 			       tw_dev->host->host_no,
990 			       TW_MESSAGE_SOURCE_CONTROLLER_ERROR,
991 			       full_command_packet->header.status_block.error,
992 			       error_str[0] == '\0' ?
993 			       twa_string_lookup(twa_error_table,
994 						 full_command_packet->header.status_block.error) : error_str,
995 			       full_command_packet->header.err_specific_desc);
996 		else
997 			printk(KERN_WARNING "3w-9xxx: ERROR: (0x%02X:0x%04X): %s:%s.\n",
998 			       TW_MESSAGE_SOURCE_CONTROLLER_ERROR,
999 			       full_command_packet->header.status_block.error,
1000 			       error_str[0] == '\0' ?
1001 			       twa_string_lookup(twa_error_table,
1002 						 full_command_packet->header.status_block.error) : error_str,
1003 			       full_command_packet->header.err_specific_desc);
1004 	}
1005 
1006 	if (copy_sense) {
1007 		memcpy(tw_dev->srb[request_id]->sense_buffer, full_command_packet->header.sense_data, TW_SENSE_DATA_LENGTH);
1008 		tw_dev->srb[request_id]->result = (full_command_packet->command.newcommand.status << 1);
1009 		retval = TW_ISR_DONT_RESULT;
1010 		goto out;
1011 	}
1012 	retval = 0;
1013 out:
1014 	return retval;
1015 } /* End twa_fill_sense() */
1016 
1017 /* This function will free up device extension resources */
1018 static void twa_free_device_extension(TW_Device_Extension *tw_dev)
1019 {
1020 	if (tw_dev->command_packet_virt[0])
1021 		pci_free_consistent(tw_dev->tw_pci_dev,
1022 				    sizeof(TW_Command_Full)*TW_Q_LENGTH,
1023 				    tw_dev->command_packet_virt[0],
1024 				    tw_dev->command_packet_phys[0]);
1025 
1026 	if (tw_dev->generic_buffer_virt[0])
1027 		pci_free_consistent(tw_dev->tw_pci_dev,
1028 				    TW_SECTOR_SIZE*TW_Q_LENGTH,
1029 				    tw_dev->generic_buffer_virt[0],
1030 				    tw_dev->generic_buffer_phys[0]);
1031 
1032 	kfree(tw_dev->event_queue[0]);
1033 } /* End twa_free_device_extension() */
1034 
1035 /* This function will free a request id */
1036 static void twa_free_request_id(TW_Device_Extension *tw_dev, int request_id)
1037 {
1038 	tw_dev->free_queue[tw_dev->free_tail] = request_id;
1039 	tw_dev->state[request_id] = TW_S_FINISHED;
1040 	tw_dev->free_tail = (tw_dev->free_tail + 1) % TW_Q_LENGTH;
1041 } /* End twa_free_request_id() */
1042 
1043 /* This function will get parameter table entries from the firmware */
1044 static void *twa_get_param(TW_Device_Extension *tw_dev, int request_id, int table_id, int parameter_id, int parameter_size_bytes)
1045 {
1046 	TW_Command_Full *full_command_packet;
1047 	TW_Command *command_packet;
1048 	TW_Param_Apache *param;
1049 	void *retval = NULL;
1050 
1051 	/* Setup the command packet */
1052 	full_command_packet = tw_dev->command_packet_virt[request_id];
1053 	memset(full_command_packet, 0, sizeof(TW_Command_Full));
1054 	command_packet = &full_command_packet->command.oldcommand;
1055 
1056 	command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_GET_PARAM);
1057 	command_packet->size              = TW_COMMAND_SIZE;
1058 	command_packet->request_id        = request_id;
1059 	command_packet->byte6_offset.block_count = cpu_to_le16(1);
1060 
1061 	/* Now setup the param */
1062 	param = (TW_Param_Apache *)tw_dev->generic_buffer_virt[request_id];
1063 	memset(param, 0, TW_SECTOR_SIZE);
1064 	param->table_id = cpu_to_le16(table_id | 0x8000);
1065 	param->parameter_id = cpu_to_le16(parameter_id);
1066 	param->parameter_size_bytes = cpu_to_le16(parameter_size_bytes);
1067 
1068 	command_packet->byte8_offset.param.sgl[0].address = TW_CPU_TO_SGL(tw_dev->generic_buffer_phys[request_id]);
1069 	command_packet->byte8_offset.param.sgl[0].length = cpu_to_le32(TW_SECTOR_SIZE);
1070 
1071 	/* Post the command packet to the board */
1072 	twa_post_command_packet(tw_dev, request_id, 1);
1073 
1074 	/* Poll for completion */
1075 	if (twa_poll_response(tw_dev, request_id, 30))
1076 		TW_PRINTK(tw_dev->host, TW_DRIVER, 0x13, "No valid response during get param")
1077 	else
1078 		retval = (void *)&(param->data[0]);
1079 
1080 	tw_dev->posted_request_count--;
1081 	tw_dev->state[request_id] = TW_S_INITIAL;
1082 
1083 	return retval;
1084 } /* End twa_get_param() */
1085 
1086 /* This function will assign an available request id */
1087 static void twa_get_request_id(TW_Device_Extension *tw_dev, int *request_id)
1088 {
1089 	*request_id = tw_dev->free_queue[tw_dev->free_head];
1090 	tw_dev->free_head = (tw_dev->free_head + 1) % TW_Q_LENGTH;
1091 	tw_dev->state[*request_id] = TW_S_STARTED;
1092 } /* End twa_get_request_id() */
1093 
1094 /* This function will send an initconnection command to controller */
1095 static int twa_initconnection(TW_Device_Extension *tw_dev, int message_credits,
1096  			      u32 set_features, unsigned short current_fw_srl,
1097 			      unsigned short current_fw_arch_id,
1098 			      unsigned short current_fw_branch,
1099 			      unsigned short current_fw_build,
1100 			      unsigned short *fw_on_ctlr_srl,
1101 			      unsigned short *fw_on_ctlr_arch_id,
1102 			      unsigned short *fw_on_ctlr_branch,
1103 			      unsigned short *fw_on_ctlr_build,
1104 			      u32 *init_connect_result)
1105 {
1106 	TW_Command_Full *full_command_packet;
1107 	TW_Initconnect *tw_initconnect;
1108 	int request_id = 0, retval = 1;
1109 
1110 	/* Initialize InitConnection command packet */
1111 	full_command_packet = tw_dev->command_packet_virt[request_id];
1112 	memset(full_command_packet, 0, sizeof(TW_Command_Full));
1113 	full_command_packet->header.header_desc.size_header = 128;
1114 
1115 	tw_initconnect = (TW_Initconnect *)&full_command_packet->command.oldcommand;
1116 	tw_initconnect->opcode__reserved = TW_OPRES_IN(0, TW_OP_INIT_CONNECTION);
1117 	tw_initconnect->request_id = request_id;
1118 	tw_initconnect->message_credits = cpu_to_le16(message_credits);
1119 	tw_initconnect->features = set_features;
1120 
1121 	/* Turn on 64-bit sgl support if we need to */
1122 	tw_initconnect->features |= sizeof(dma_addr_t) > 4 ? 1 : 0;
1123 
1124 	tw_initconnect->features = cpu_to_le32(tw_initconnect->features);
1125 
1126 	if (set_features & TW_EXTENDED_INIT_CONNECT) {
1127 		tw_initconnect->size = TW_INIT_COMMAND_PACKET_SIZE_EXTENDED;
1128 		tw_initconnect->fw_srl = cpu_to_le16(current_fw_srl);
1129 		tw_initconnect->fw_arch_id = cpu_to_le16(current_fw_arch_id);
1130 		tw_initconnect->fw_branch = cpu_to_le16(current_fw_branch);
1131 		tw_initconnect->fw_build = cpu_to_le16(current_fw_build);
1132 	} else
1133 		tw_initconnect->size = TW_INIT_COMMAND_PACKET_SIZE;
1134 
1135 	/* Send command packet to the board */
1136 	twa_post_command_packet(tw_dev, request_id, 1);
1137 
1138 	/* Poll for completion */
1139 	if (twa_poll_response(tw_dev, request_id, 30)) {
1140 		TW_PRINTK(tw_dev->host, TW_DRIVER, 0x15, "No valid response during init connection");
1141 	} else {
1142 		if (set_features & TW_EXTENDED_INIT_CONNECT) {
1143 			*fw_on_ctlr_srl = le16_to_cpu(tw_initconnect->fw_srl);
1144 			*fw_on_ctlr_arch_id = le16_to_cpu(tw_initconnect->fw_arch_id);
1145 			*fw_on_ctlr_branch = le16_to_cpu(tw_initconnect->fw_branch);
1146 			*fw_on_ctlr_build = le16_to_cpu(tw_initconnect->fw_build);
1147 			*init_connect_result = le32_to_cpu(tw_initconnect->result);
1148 		}
1149 		retval = 0;
1150 	}
1151 
1152 	tw_dev->posted_request_count--;
1153 	tw_dev->state[request_id] = TW_S_INITIAL;
1154 
1155 	return retval;
1156 } /* End twa_initconnection() */
1157 
1158 /* This function will initialize the fields of a device extension */
1159 static int twa_initialize_device_extension(TW_Device_Extension *tw_dev)
1160 {
1161 	int i, retval = 1;
1162 
1163 	/* Initialize command packet buffers */
1164 	if (twa_allocate_memory(tw_dev, sizeof(TW_Command_Full), 0)) {
1165 		TW_PRINTK(tw_dev->host, TW_DRIVER, 0x16, "Command packet memory allocation failed");
1166 		goto out;
1167 	}
1168 
1169 	/* Initialize generic buffer */
1170 	if (twa_allocate_memory(tw_dev, TW_SECTOR_SIZE, 1)) {
1171 		TW_PRINTK(tw_dev->host, TW_DRIVER, 0x17, "Generic memory allocation failed");
1172 		goto out;
1173 	}
1174 
1175 	/* Allocate event info space */
1176 	tw_dev->event_queue[0] = kcalloc(TW_Q_LENGTH, sizeof(TW_Event), GFP_KERNEL);
1177 	if (!tw_dev->event_queue[0]) {
1178 		TW_PRINTK(tw_dev->host, TW_DRIVER, 0x18, "Event info memory allocation failed");
1179 		goto out;
1180 	}
1181 
1182 
1183 	for (i = 0; i < TW_Q_LENGTH; i++) {
1184 		tw_dev->event_queue[i] = (TW_Event *)((unsigned char *)tw_dev->event_queue[0] + (i * sizeof(TW_Event)));
1185 		tw_dev->free_queue[i] = i;
1186 		tw_dev->state[i] = TW_S_INITIAL;
1187 	}
1188 
1189 	tw_dev->pending_head = TW_Q_START;
1190 	tw_dev->pending_tail = TW_Q_START;
1191 	tw_dev->free_head = TW_Q_START;
1192 	tw_dev->free_tail = TW_Q_START;
1193 	tw_dev->error_sequence_id = 1;
1194 	tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE;
1195 
1196 	mutex_init(&tw_dev->ioctl_lock);
1197 	init_waitqueue_head(&tw_dev->ioctl_wqueue);
1198 
1199 	retval = 0;
1200 out:
1201 	return retval;
1202 } /* End twa_initialize_device_extension() */
1203 
1204 /* This function is the interrupt service routine */
1205 static irqreturn_t twa_interrupt(int irq, void *dev_instance)
1206 {
1207 	int request_id, error = 0;
1208 	u32 status_reg_value;
1209 	TW_Response_Queue response_que;
1210 	TW_Command_Full *full_command_packet;
1211 	TW_Device_Extension *tw_dev = (TW_Device_Extension *)dev_instance;
1212 	int handled = 0;
1213 
1214 	/* Get the per adapter lock */
1215 	spin_lock(tw_dev->host->host_lock);
1216 
1217 	/* Read the registers */
1218 	status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
1219 
1220 	/* Check if this is our interrupt, otherwise bail */
1221 	if (!(status_reg_value & TW_STATUS_VALID_INTERRUPT))
1222 		goto twa_interrupt_bail;
1223 
1224 	handled = 1;
1225 
1226 	/* If we are resetting, bail */
1227 	if (test_bit(TW_IN_RESET, &tw_dev->flags))
1228 		goto twa_interrupt_bail;
1229 
1230 	/* Check controller for errors */
1231 	if (twa_check_bits(status_reg_value)) {
1232 		if (twa_decode_bits(tw_dev, status_reg_value)) {
1233 			TW_CLEAR_ALL_INTERRUPTS(tw_dev);
1234 			goto twa_interrupt_bail;
1235 		}
1236 	}
1237 
1238 	/* Handle host interrupt */
1239 	if (status_reg_value & TW_STATUS_HOST_INTERRUPT)
1240 		TW_CLEAR_HOST_INTERRUPT(tw_dev);
1241 
1242 	/* Handle attention interrupt */
1243 	if (status_reg_value & TW_STATUS_ATTENTION_INTERRUPT) {
1244 		TW_CLEAR_ATTENTION_INTERRUPT(tw_dev);
1245 		if (!(test_and_set_bit(TW_IN_ATTENTION_LOOP, &tw_dev->flags))) {
1246 			twa_get_request_id(tw_dev, &request_id);
1247 
1248 			error = twa_aen_read_queue(tw_dev, request_id);
1249 			if (error) {
1250 				tw_dev->state[request_id] = TW_S_COMPLETED;
1251 				twa_free_request_id(tw_dev, request_id);
1252 				clear_bit(TW_IN_ATTENTION_LOOP, &tw_dev->flags);
1253 			}
1254 		}
1255 	}
1256 
1257 	/* Handle command interrupt */
1258 	if (status_reg_value & TW_STATUS_COMMAND_INTERRUPT) {
1259 		TW_MASK_COMMAND_INTERRUPT(tw_dev);
1260 		/* Drain as many pending commands as we can */
1261 		while (tw_dev->pending_request_count > 0) {
1262 			request_id = tw_dev->pending_queue[tw_dev->pending_head];
1263 			if (tw_dev->state[request_id] != TW_S_PENDING) {
1264 				TW_PRINTK(tw_dev->host, TW_DRIVER, 0x19, "Found request id that wasn't pending");
1265 				TW_CLEAR_ALL_INTERRUPTS(tw_dev);
1266 				goto twa_interrupt_bail;
1267 			}
1268 			if (twa_post_command_packet(tw_dev, request_id, 1)==0) {
1269 				tw_dev->pending_head = (tw_dev->pending_head + 1) % TW_Q_LENGTH;
1270 				tw_dev->pending_request_count--;
1271 			} else {
1272 				/* If we get here, we will continue re-posting on the next command interrupt */
1273 				break;
1274 			}
1275 		}
1276 	}
1277 
1278 	/* Handle response interrupt */
1279 	if (status_reg_value & TW_STATUS_RESPONSE_INTERRUPT) {
1280 
1281 		/* Drain the response queue from the board */
1282 		while ((status_reg_value & TW_STATUS_RESPONSE_QUEUE_EMPTY) == 0) {
1283 			/* Complete the response */
1284 			response_que.value = readl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev));
1285 			request_id = TW_RESID_OUT(response_que.response_id);
1286 			full_command_packet = tw_dev->command_packet_virt[request_id];
1287 			error = 0;
1288 			/* Check for command packet errors */
1289 			if (full_command_packet->command.newcommand.status != 0) {
1290 				if (tw_dev->srb[request_id] != NULL) {
1291 					error = twa_fill_sense(tw_dev, request_id, 1, 1);
1292 				} else {
1293 					/* Skip ioctl error prints */
1294 					if (request_id != tw_dev->chrdev_request_id) {
1295 						error = twa_fill_sense(tw_dev, request_id, 0, 1);
1296 					}
1297 				}
1298 			}
1299 
1300 			/* Check for correct state */
1301 			if (tw_dev->state[request_id] != TW_S_POSTED) {
1302 				if (tw_dev->srb[request_id] != NULL) {
1303 					TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1a, "Received a request id that wasn't posted");
1304 					TW_CLEAR_ALL_INTERRUPTS(tw_dev);
1305 					goto twa_interrupt_bail;
1306 				}
1307 			}
1308 
1309 			/* Check for internal command completion */
1310 			if (tw_dev->srb[request_id] == NULL) {
1311 				if (request_id != tw_dev->chrdev_request_id) {
1312 					if (twa_aen_complete(tw_dev, request_id))
1313 						TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1b, "Error completing AEN during attention interrupt");
1314 				} else {
1315 					tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE;
1316 					wake_up(&tw_dev->ioctl_wqueue);
1317 				}
1318 			} else {
1319 				struct scsi_cmnd *cmd;
1320 
1321 				cmd = tw_dev->srb[request_id];
1322 
1323 				twa_scsiop_execute_scsi_complete(tw_dev, request_id);
1324 				/* If no error command was a success */
1325 				if (error == 0) {
1326 					cmd->result = (DID_OK << 16);
1327 				}
1328 
1329 				/* If error, command failed */
1330 				if (error == 1) {
1331 					/* Ask for a host reset */
1332 					cmd->result = (DID_OK << 16) | (CHECK_CONDITION << 1);
1333 				}
1334 
1335 				/* Report residual bytes for single sgl */
1336 				if ((scsi_sg_count(cmd) <= 1) && (full_command_packet->command.newcommand.status == 0)) {
1337 					if (full_command_packet->command.newcommand.sg_list[0].length < scsi_bufflen(tw_dev->srb[request_id]))
1338 						scsi_set_resid(cmd, scsi_bufflen(cmd) - full_command_packet->command.newcommand.sg_list[0].length);
1339 				}
1340 
1341 				/* Now complete the io */
1342 				scsi_dma_unmap(cmd);
1343 				cmd->scsi_done(cmd);
1344 				tw_dev->state[request_id] = TW_S_COMPLETED;
1345 				twa_free_request_id(tw_dev, request_id);
1346 				tw_dev->posted_request_count--;
1347 			}
1348 
1349 			/* Check for valid status after each drain */
1350 			status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
1351 			if (twa_check_bits(status_reg_value)) {
1352 				if (twa_decode_bits(tw_dev, status_reg_value)) {
1353 					TW_CLEAR_ALL_INTERRUPTS(tw_dev);
1354 					goto twa_interrupt_bail;
1355 				}
1356 			}
1357 		}
1358 	}
1359 
1360 twa_interrupt_bail:
1361 	spin_unlock(tw_dev->host->host_lock);
1362 	return IRQ_RETVAL(handled);
1363 } /* End twa_interrupt() */
1364 
1365 /* This function will load the request id and various sgls for ioctls */
1366 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)
1367 {
1368 	TW_Command *oldcommand;
1369 	TW_Command_Apache *newcommand;
1370 	TW_SG_Entry *sgl;
1371 	unsigned int pae = 0;
1372 
1373 	if ((sizeof(long) < 8) && (sizeof(dma_addr_t) > 4))
1374 		pae = 1;
1375 
1376 	if (TW_OP_OUT(full_command_packet->command.newcommand.opcode__reserved) == TW_OP_EXECUTE_SCSI) {
1377 		newcommand = &full_command_packet->command.newcommand;
1378 		newcommand->request_id__lunl =
1379 			cpu_to_le16(TW_REQ_LUN_IN(TW_LUN_OUT(newcommand->request_id__lunl), request_id));
1380 		if (length) {
1381 			newcommand->sg_list[0].address = TW_CPU_TO_SGL(dma_handle + sizeof(TW_Ioctl_Buf_Apache) - 1);
1382 			newcommand->sg_list[0].length = cpu_to_le32(length);
1383 		}
1384 		newcommand->sgl_entries__lunh =
1385 			cpu_to_le16(TW_REQ_LUN_IN(TW_LUN_OUT(newcommand->sgl_entries__lunh), length ? 1 : 0));
1386 	} else {
1387 		oldcommand = &full_command_packet->command.oldcommand;
1388 		oldcommand->request_id = request_id;
1389 
1390 		if (TW_SGL_OUT(oldcommand->opcode__sgloffset)) {
1391 			/* Load the sg list */
1392 			if (tw_dev->tw_pci_dev->device == PCI_DEVICE_ID_3WARE_9690SA)
1393 				sgl = (TW_SG_Entry *)((u32 *)oldcommand+oldcommand->size - (sizeof(TW_SG_Entry)/4) + pae);
1394 			else
1395 				sgl = (TW_SG_Entry *)((u32 *)oldcommand+TW_SGL_OUT(oldcommand->opcode__sgloffset));
1396 			sgl->address = TW_CPU_TO_SGL(dma_handle + sizeof(TW_Ioctl_Buf_Apache) - 1);
1397 			sgl->length = cpu_to_le32(length);
1398 
1399 			oldcommand->size += pae;
1400 		}
1401 	}
1402 } /* End twa_load_sgl() */
1403 
1404 /* This function will poll for a response interrupt of a request */
1405 static int twa_poll_response(TW_Device_Extension *tw_dev, int request_id, int seconds)
1406 {
1407 	int retval = 1, found = 0, response_request_id;
1408 	TW_Response_Queue response_queue;
1409 	TW_Command_Full *full_command_packet = tw_dev->command_packet_virt[request_id];
1410 
1411 	if (twa_poll_status_gone(tw_dev, TW_STATUS_RESPONSE_QUEUE_EMPTY, seconds) == 0) {
1412 		response_queue.value = readl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev));
1413 		response_request_id = TW_RESID_OUT(response_queue.response_id);
1414 		if (request_id != response_request_id) {
1415 			TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1e, "Found unexpected request id while polling for response");
1416 			goto out;
1417 		}
1418 		if (TW_OP_OUT(full_command_packet->command.newcommand.opcode__reserved) == TW_OP_EXECUTE_SCSI) {
1419 			if (full_command_packet->command.newcommand.status != 0) {
1420 				/* bad response */
1421 				twa_fill_sense(tw_dev, request_id, 0, 0);
1422 				goto out;
1423 			}
1424 			found = 1;
1425 		} else {
1426 			if (full_command_packet->command.oldcommand.status != 0) {
1427 				/* bad response */
1428 				twa_fill_sense(tw_dev, request_id, 0, 0);
1429 				goto out;
1430 			}
1431 			found = 1;
1432 		}
1433 	}
1434 
1435 	if (found)
1436 		retval = 0;
1437 out:
1438 	return retval;
1439 } /* End twa_poll_response() */
1440 
1441 /* This function will poll the status register for a flag */
1442 static int twa_poll_status(TW_Device_Extension *tw_dev, u32 flag, int seconds)
1443 {
1444 	u32 status_reg_value;
1445 	unsigned long before;
1446 	int retval = 1;
1447 
1448 	status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
1449 	before = jiffies;
1450 
1451 	if (twa_check_bits(status_reg_value))
1452 		twa_decode_bits(tw_dev, status_reg_value);
1453 
1454 	while ((status_reg_value & flag) != flag) {
1455 		status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
1456 
1457 		if (twa_check_bits(status_reg_value))
1458 			twa_decode_bits(tw_dev, status_reg_value);
1459 
1460 		if (time_after(jiffies, before + HZ * seconds))
1461 			goto out;
1462 
1463 		msleep(50);
1464 	}
1465 	retval = 0;
1466 out:
1467 	return retval;
1468 } /* End twa_poll_status() */
1469 
1470 /* This function will poll the status register for disappearance of a flag */
1471 static int twa_poll_status_gone(TW_Device_Extension *tw_dev, u32 flag, int seconds)
1472 {
1473 	u32 status_reg_value;
1474 	unsigned long before;
1475 	int retval = 1;
1476 
1477 	status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
1478 	before = jiffies;
1479 
1480 	if (twa_check_bits(status_reg_value))
1481 		twa_decode_bits(tw_dev, status_reg_value);
1482 
1483 	while ((status_reg_value & flag) != 0) {
1484 		status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
1485 		if (twa_check_bits(status_reg_value))
1486 			twa_decode_bits(tw_dev, status_reg_value);
1487 
1488 		if (time_after(jiffies, before + HZ * seconds))
1489 			goto out;
1490 
1491 		msleep(50);
1492 	}
1493 	retval = 0;
1494 out:
1495 	return retval;
1496 } /* End twa_poll_status_gone() */
1497 
1498 /* This function will attempt to post a command packet to the board */
1499 static int twa_post_command_packet(TW_Device_Extension *tw_dev, int request_id, char internal)
1500 {
1501 	u32 status_reg_value;
1502 	dma_addr_t command_que_value;
1503 	int retval = 1;
1504 
1505 	command_que_value = tw_dev->command_packet_phys[request_id];
1506 
1507 	/* For 9650SE write low 4 bytes first */
1508 	if ((tw_dev->tw_pci_dev->device == PCI_DEVICE_ID_3WARE_9650SE) ||
1509 	    (tw_dev->tw_pci_dev->device == PCI_DEVICE_ID_3WARE_9690SA)) {
1510 		command_que_value += TW_COMMAND_OFFSET;
1511 		writel((u32)command_que_value, TW_COMMAND_QUEUE_REG_ADDR_LARGE(tw_dev));
1512 	}
1513 
1514 	status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
1515 
1516 	if (twa_check_bits(status_reg_value))
1517 		twa_decode_bits(tw_dev, status_reg_value);
1518 
1519 	if (((tw_dev->pending_request_count > 0) && (tw_dev->state[request_id] != TW_S_PENDING)) || (status_reg_value & TW_STATUS_COMMAND_QUEUE_FULL)) {
1520 
1521 		/* Only pend internal driver commands */
1522 		if (!internal) {
1523 			retval = SCSI_MLQUEUE_HOST_BUSY;
1524 			goto out;
1525 		}
1526 
1527 		/* Couldn't post the command packet, so we do it later */
1528 		if (tw_dev->state[request_id] != TW_S_PENDING) {
1529 			tw_dev->state[request_id] = TW_S_PENDING;
1530 			tw_dev->pending_request_count++;
1531 			if (tw_dev->pending_request_count > tw_dev->max_pending_request_count) {
1532 				tw_dev->max_pending_request_count = tw_dev->pending_request_count;
1533 			}
1534 			tw_dev->pending_queue[tw_dev->pending_tail] = request_id;
1535 			tw_dev->pending_tail = (tw_dev->pending_tail + 1) % TW_Q_LENGTH;
1536 		}
1537 		TW_UNMASK_COMMAND_INTERRUPT(tw_dev);
1538 		goto out;
1539 	} else {
1540 		if ((tw_dev->tw_pci_dev->device == PCI_DEVICE_ID_3WARE_9650SE) ||
1541 		    (tw_dev->tw_pci_dev->device == PCI_DEVICE_ID_3WARE_9690SA)) {
1542 			/* Now write upper 4 bytes */
1543 			writel((u32)((u64)command_que_value >> 32), TW_COMMAND_QUEUE_REG_ADDR_LARGE(tw_dev) + 0x4);
1544 		} else {
1545 			if (sizeof(dma_addr_t) > 4) {
1546 				command_que_value += TW_COMMAND_OFFSET;
1547 				writel((u32)command_que_value, TW_COMMAND_QUEUE_REG_ADDR(tw_dev));
1548 				writel((u32)((u64)command_que_value >> 32), TW_COMMAND_QUEUE_REG_ADDR(tw_dev) + 0x4);
1549 			} else {
1550 				writel(TW_COMMAND_OFFSET + command_que_value, TW_COMMAND_QUEUE_REG_ADDR(tw_dev));
1551 			}
1552 		}
1553 		tw_dev->state[request_id] = TW_S_POSTED;
1554 		tw_dev->posted_request_count++;
1555 		if (tw_dev->posted_request_count > tw_dev->max_posted_request_count) {
1556 			tw_dev->max_posted_request_count = tw_dev->posted_request_count;
1557 		}
1558 	}
1559 	retval = 0;
1560 out:
1561 	return retval;
1562 } /* End twa_post_command_packet() */
1563 
1564 /* This function will reset a device extension */
1565 static int twa_reset_device_extension(TW_Device_Extension *tw_dev)
1566 {
1567 	int i = 0;
1568 	int retval = 1;
1569 	unsigned long flags = 0;
1570 
1571 	set_bit(TW_IN_RESET, &tw_dev->flags);
1572 	TW_DISABLE_INTERRUPTS(tw_dev);
1573 	TW_MASK_COMMAND_INTERRUPT(tw_dev);
1574 	spin_lock_irqsave(tw_dev->host->host_lock, flags);
1575 
1576 	/* Abort all requests that are in progress */
1577 	for (i = 0; i < TW_Q_LENGTH; i++) {
1578 		if ((tw_dev->state[i] != TW_S_FINISHED) &&
1579 		    (tw_dev->state[i] != TW_S_INITIAL) &&
1580 		    (tw_dev->state[i] != TW_S_COMPLETED)) {
1581 			if (tw_dev->srb[i]) {
1582 				struct scsi_cmnd *cmd = tw_dev->srb[i];
1583 
1584 				cmd->result = (DID_RESET << 16);
1585 				scsi_dma_unmap(cmd);
1586 				cmd->scsi_done(cmd);
1587 			}
1588 		}
1589 	}
1590 
1591 	/* Reset queues and counts */
1592 	for (i = 0; i < TW_Q_LENGTH; i++) {
1593 		tw_dev->free_queue[i] = i;
1594 		tw_dev->state[i] = TW_S_INITIAL;
1595 	}
1596 	tw_dev->free_head = TW_Q_START;
1597 	tw_dev->free_tail = TW_Q_START;
1598 	tw_dev->posted_request_count = 0;
1599 	tw_dev->pending_request_count = 0;
1600 	tw_dev->pending_head = TW_Q_START;
1601 	tw_dev->pending_tail = TW_Q_START;
1602 	tw_dev->reset_print = 0;
1603 
1604 	spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
1605 
1606 	if (twa_reset_sequence(tw_dev, 1))
1607 		goto out;
1608 
1609 	TW_ENABLE_AND_CLEAR_INTERRUPTS(tw_dev);
1610 	clear_bit(TW_IN_RESET, &tw_dev->flags);
1611 	tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE;
1612 
1613 	retval = 0;
1614 out:
1615 	return retval;
1616 } /* End twa_reset_device_extension() */
1617 
1618 /* This function will reset a controller */
1619 static int twa_reset_sequence(TW_Device_Extension *tw_dev, int soft_reset)
1620 {
1621 	int tries = 0, retval = 1, flashed = 0, do_soft_reset = soft_reset;
1622 
1623 	while (tries < TW_MAX_RESET_TRIES) {
1624 		if (do_soft_reset) {
1625 			TW_SOFT_RESET(tw_dev);
1626 			/* Clear pchip/response queue on 9550SX */
1627 			if (twa_empty_response_queue_large(tw_dev)) {
1628 				TW_PRINTK(tw_dev->host, TW_DRIVER, 0x36, "Response queue (large) empty failed during reset sequence");
1629 				do_soft_reset = 1;
1630 				tries++;
1631 				continue;
1632 			}
1633 		}
1634 
1635 		/* Make sure controller is in a good state */
1636 		if (twa_poll_status(tw_dev, TW_STATUS_MICROCONTROLLER_READY | (do_soft_reset == 1 ? TW_STATUS_ATTENTION_INTERRUPT : 0), 60)) {
1637 			TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1f, "Microcontroller not ready during reset sequence");
1638 			do_soft_reset = 1;
1639 			tries++;
1640 			continue;
1641 		}
1642 
1643 		/* Empty response queue */
1644 		if (twa_empty_response_queue(tw_dev)) {
1645 			TW_PRINTK(tw_dev->host, TW_DRIVER, 0x20, "Response queue empty failed during reset sequence");
1646 			do_soft_reset = 1;
1647 			tries++;
1648 			continue;
1649 		}
1650 
1651 		flashed = 0;
1652 
1653 		/* Check for compatibility/flash */
1654 		if (twa_check_srl(tw_dev, &flashed)) {
1655 			TW_PRINTK(tw_dev->host, TW_DRIVER, 0x21, "Compatibility check failed during reset sequence");
1656 			do_soft_reset = 1;
1657 			tries++;
1658 			continue;
1659 		} else {
1660 			if (flashed) {
1661 				tries++;
1662 				continue;
1663 			}
1664 		}
1665 
1666 		/* Drain the AEN queue */
1667 		if (twa_aen_drain_queue(tw_dev, soft_reset)) {
1668 			TW_PRINTK(tw_dev->host, TW_DRIVER, 0x22, "AEN drain failed during reset sequence");
1669 			do_soft_reset = 1;
1670 			tries++;
1671 			continue;
1672 		}
1673 
1674 		/* If we got here, controller is in a good state */
1675 		retval = 0;
1676 		goto out;
1677 	}
1678 out:
1679 	return retval;
1680 } /* End twa_reset_sequence() */
1681 
1682 /* This funciton returns unit geometry in cylinders/heads/sectors */
1683 static int twa_scsi_biosparam(struct scsi_device *sdev, struct block_device *bdev, sector_t capacity, int geom[])
1684 {
1685 	int heads, sectors, cylinders;
1686 	TW_Device_Extension *tw_dev;
1687 
1688 	tw_dev = (TW_Device_Extension *)sdev->host->hostdata;
1689 
1690 	if (capacity >= 0x200000) {
1691 		heads = 255;
1692 		sectors = 63;
1693 		cylinders = sector_div(capacity, heads * sectors);
1694 	} else {
1695 		heads = 64;
1696 		sectors = 32;
1697 		cylinders = sector_div(capacity, heads * sectors);
1698 	}
1699 
1700 	geom[0] = heads;
1701 	geom[1] = sectors;
1702 	geom[2] = cylinders;
1703 
1704 	return 0;
1705 } /* End twa_scsi_biosparam() */
1706 
1707 /* This is the new scsi eh reset function */
1708 static int twa_scsi_eh_reset(struct scsi_cmnd *SCpnt)
1709 {
1710 	TW_Device_Extension *tw_dev = NULL;
1711 	int retval = FAILED;
1712 
1713 	tw_dev = (TW_Device_Extension *)SCpnt->device->host->hostdata;
1714 
1715 	tw_dev->num_resets++;
1716 
1717 	sdev_printk(KERN_WARNING, SCpnt->device,
1718 		"WARNING: (0x%02X:0x%04X): Command (0x%x) timed out, resetting card.\n",
1719 		TW_DRIVER, 0x2c, SCpnt->cmnd[0]);
1720 
1721 	/* Make sure we are not issuing an ioctl or resetting from ioctl */
1722 	mutex_lock(&tw_dev->ioctl_lock);
1723 
1724 	/* Now reset the card and some of the device extension data */
1725 	if (twa_reset_device_extension(tw_dev)) {
1726 		TW_PRINTK(tw_dev->host, TW_DRIVER, 0x2b, "Controller reset failed during scsi host reset");
1727 		goto out;
1728 	}
1729 
1730 	retval = SUCCESS;
1731 out:
1732 	mutex_unlock(&tw_dev->ioctl_lock);
1733 	return retval;
1734 } /* End twa_scsi_eh_reset() */
1735 
1736 /* This is the main scsi queue function to handle scsi opcodes */
1737 static int twa_scsi_queue_lck(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *))
1738 {
1739 	int request_id, retval;
1740 	TW_Device_Extension *tw_dev = (TW_Device_Extension *)SCpnt->device->host->hostdata;
1741 
1742 	/* If we are resetting due to timed out ioctl, report as busy */
1743 	if (test_bit(TW_IN_RESET, &tw_dev->flags)) {
1744 		retval = SCSI_MLQUEUE_HOST_BUSY;
1745 		goto out;
1746 	}
1747 
1748 	/* Check if this FW supports luns */
1749 	if ((SCpnt->device->lun != 0) && (tw_dev->tw_compat_info.working_srl < TW_FW_SRL_LUNS_SUPPORTED)) {
1750 		SCpnt->result = (DID_BAD_TARGET << 16);
1751 		done(SCpnt);
1752 		retval = 0;
1753 		goto out;
1754 	}
1755 
1756 	/* Save done function into scsi_cmnd struct */
1757 	SCpnt->scsi_done = done;
1758 
1759 	/* Get a free request id */
1760 	twa_get_request_id(tw_dev, &request_id);
1761 
1762 	/* Save the scsi command for use by the ISR */
1763 	tw_dev->srb[request_id] = SCpnt;
1764 
1765 	retval = twa_scsiop_execute_scsi(tw_dev, request_id, NULL, 0, NULL);
1766 	switch (retval) {
1767 	case SCSI_MLQUEUE_HOST_BUSY:
1768 		scsi_dma_unmap(SCpnt);
1769 		twa_free_request_id(tw_dev, request_id);
1770 		break;
1771 	case 1:
1772 		SCpnt->result = (DID_ERROR << 16);
1773 		scsi_dma_unmap(SCpnt);
1774 		done(SCpnt);
1775 		tw_dev->state[request_id] = TW_S_COMPLETED;
1776 		twa_free_request_id(tw_dev, request_id);
1777 		retval = 0;
1778 	}
1779 out:
1780 	return retval;
1781 } /* End twa_scsi_queue() */
1782 
1783 static DEF_SCSI_QCMD(twa_scsi_queue)
1784 
1785 /* This function hands scsi cdb's to the firmware */
1786 static int twa_scsiop_execute_scsi(TW_Device_Extension *tw_dev, int request_id, char *cdb, int use_sg, TW_SG_Entry *sglistarg)
1787 {
1788 	TW_Command_Full *full_command_packet;
1789 	TW_Command_Apache *command_packet;
1790 	u32 num_sectors = 0x0;
1791 	int i, sg_count;
1792 	struct scsi_cmnd *srb = NULL;
1793 	struct scatterlist *sglist = NULL, *sg;
1794 	int retval = 1;
1795 
1796 	if (tw_dev->srb[request_id]) {
1797 		srb = tw_dev->srb[request_id];
1798 		if (scsi_sglist(srb))
1799 			sglist = scsi_sglist(srb);
1800 	}
1801 
1802 	/* Initialize command packet */
1803 	full_command_packet = tw_dev->command_packet_virt[request_id];
1804 	full_command_packet->header.header_desc.size_header = 128;
1805 	full_command_packet->header.status_block.error = 0;
1806 	full_command_packet->header.status_block.severity__reserved = 0;
1807 
1808 	command_packet = &full_command_packet->command.newcommand;
1809 	command_packet->status = 0;
1810 	command_packet->opcode__reserved = TW_OPRES_IN(0, TW_OP_EXECUTE_SCSI);
1811 
1812 	/* We forced 16 byte cdb use earlier */
1813 	if (!cdb)
1814 		memcpy(command_packet->cdb, srb->cmnd, TW_MAX_CDB_LEN);
1815 	else
1816 		memcpy(command_packet->cdb, cdb, TW_MAX_CDB_LEN);
1817 
1818 	if (srb) {
1819 		command_packet->unit = srb->device->id;
1820 		command_packet->request_id__lunl =
1821 			cpu_to_le16(TW_REQ_LUN_IN(srb->device->lun, request_id));
1822 	} else {
1823 		command_packet->request_id__lunl =
1824 			cpu_to_le16(TW_REQ_LUN_IN(0, request_id));
1825 		command_packet->unit = 0;
1826 	}
1827 
1828 	command_packet->sgl_offset = 16;
1829 
1830 	if (!sglistarg) {
1831 		/* Map sglist from scsi layer to cmd packet */
1832 
1833 		if (scsi_sg_count(srb)) {
1834 			if ((scsi_sg_count(srb) == 1) &&
1835 			    (scsi_bufflen(srb) < TW_MIN_SGL_LENGTH)) {
1836 				if (srb->sc_data_direction == DMA_TO_DEVICE ||
1837 				    srb->sc_data_direction == DMA_BIDIRECTIONAL)
1838 					scsi_sg_copy_to_buffer(srb,
1839 							       tw_dev->generic_buffer_virt[request_id],
1840 							       TW_SECTOR_SIZE);
1841 				command_packet->sg_list[0].address = TW_CPU_TO_SGL(tw_dev->generic_buffer_phys[request_id]);
1842 				command_packet->sg_list[0].length = cpu_to_le32(TW_MIN_SGL_LENGTH);
1843 			} else {
1844 				sg_count = scsi_dma_map(srb);
1845 				if (sg_count < 0)
1846 					goto out;
1847 
1848 				scsi_for_each_sg(srb, sg, sg_count, i) {
1849 					command_packet->sg_list[i].address = TW_CPU_TO_SGL(sg_dma_address(sg));
1850 					command_packet->sg_list[i].length = cpu_to_le32(sg_dma_len(sg));
1851 					if (command_packet->sg_list[i].address & TW_CPU_TO_SGL(TW_ALIGNMENT_9000_SGL)) {
1852 						TW_PRINTK(tw_dev->host, TW_DRIVER, 0x2e, "Found unaligned sgl address during execute scsi");
1853 						goto out;
1854 					}
1855 				}
1856 			}
1857 			command_packet->sgl_entries__lunh = cpu_to_le16(TW_REQ_LUN_IN((srb->device->lun >> 4), scsi_sg_count(tw_dev->srb[request_id])));
1858 		}
1859 	} else {
1860 		/* Internal cdb post */
1861 		for (i = 0; i < use_sg; i++) {
1862 			command_packet->sg_list[i].address = TW_CPU_TO_SGL(sglistarg[i].address);
1863 			command_packet->sg_list[i].length = cpu_to_le32(sglistarg[i].length);
1864 			if (command_packet->sg_list[i].address & TW_CPU_TO_SGL(TW_ALIGNMENT_9000_SGL)) {
1865 				TW_PRINTK(tw_dev->host, TW_DRIVER, 0x2f, "Found unaligned sgl address during internal post");
1866 				goto out;
1867 			}
1868 		}
1869 		command_packet->sgl_entries__lunh = cpu_to_le16(TW_REQ_LUN_IN(0, use_sg));
1870 	}
1871 
1872 	if (srb) {
1873 		if (srb->cmnd[0] == READ_6 || srb->cmnd[0] == WRITE_6)
1874 			num_sectors = (u32)srb->cmnd[4];
1875 
1876 		if (srb->cmnd[0] == READ_10 || srb->cmnd[0] == WRITE_10)
1877 			num_sectors = (u32)srb->cmnd[8] | ((u32)srb->cmnd[7] << 8);
1878 	}
1879 
1880 	/* Update sector statistic */
1881 	tw_dev->sector_count = num_sectors;
1882 	if (tw_dev->sector_count > tw_dev->max_sector_count)
1883 		tw_dev->max_sector_count = tw_dev->sector_count;
1884 
1885 	/* Update SG statistics */
1886 	if (srb) {
1887 		tw_dev->sgl_entries = scsi_sg_count(tw_dev->srb[request_id]);
1888 		if (tw_dev->sgl_entries > tw_dev->max_sgl_entries)
1889 			tw_dev->max_sgl_entries = tw_dev->sgl_entries;
1890 	}
1891 
1892 	/* Now post the command to the board */
1893 	if (srb) {
1894 		retval = twa_post_command_packet(tw_dev, request_id, 0);
1895 	} else {
1896 		twa_post_command_packet(tw_dev, request_id, 1);
1897 		retval = 0;
1898 	}
1899 out:
1900 	return retval;
1901 } /* End twa_scsiop_execute_scsi() */
1902 
1903 /* This function completes an execute scsi operation */
1904 static void twa_scsiop_execute_scsi_complete(TW_Device_Extension *tw_dev, int request_id)
1905 {
1906 	struct scsi_cmnd *cmd = tw_dev->srb[request_id];
1907 
1908 	if (scsi_bufflen(cmd) < TW_MIN_SGL_LENGTH &&
1909 	    (cmd->sc_data_direction == DMA_FROM_DEVICE ||
1910 	     cmd->sc_data_direction == DMA_BIDIRECTIONAL)) {
1911 		if (scsi_sg_count(cmd) == 1) {
1912 			void *buf = tw_dev->generic_buffer_virt[request_id];
1913 
1914 			scsi_sg_copy_from_buffer(cmd, buf, TW_SECTOR_SIZE);
1915 		}
1916 	}
1917 } /* End twa_scsiop_execute_scsi_complete() */
1918 
1919 /* This function tells the controller to shut down */
1920 static void __twa_shutdown(TW_Device_Extension *tw_dev)
1921 {
1922 	/* Disable interrupts */
1923 	TW_DISABLE_INTERRUPTS(tw_dev);
1924 
1925 	/* Free up the IRQ */
1926 	free_irq(tw_dev->tw_pci_dev->irq, tw_dev);
1927 
1928 	printk(KERN_WARNING "3w-9xxx: Shutting down host %d.\n", tw_dev->host->host_no);
1929 
1930 	/* Tell the card we are shutting down */
1931 	if (twa_initconnection(tw_dev, 1, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL)) {
1932 		TW_PRINTK(tw_dev->host, TW_DRIVER, 0x31, "Connection shutdown failed");
1933 	} else {
1934 		printk(KERN_WARNING "3w-9xxx: Shutdown complete.\n");
1935 	}
1936 
1937 	/* Clear all interrupts just before exit */
1938 	TW_CLEAR_ALL_INTERRUPTS(tw_dev);
1939 } /* End __twa_shutdown() */
1940 
1941 /* Wrapper for __twa_shutdown */
1942 static void twa_shutdown(struct pci_dev *pdev)
1943 {
1944 	struct Scsi_Host *host = pci_get_drvdata(pdev);
1945 	TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
1946 
1947 	__twa_shutdown(tw_dev);
1948 } /* End twa_shutdown() */
1949 
1950 /* This function will look up a string */
1951 static char *twa_string_lookup(twa_message_type *table, unsigned int code)
1952 {
1953 	int index;
1954 
1955 	for (index = 0; ((code != table[index].code) &&
1956 		      (table[index].text != (char *)0)); index++);
1957 	return(table[index].text);
1958 } /* End twa_string_lookup() */
1959 
1960 /* This function gets called when a disk is coming on-line */
1961 static int twa_slave_configure(struct scsi_device *sdev)
1962 {
1963 	/* Force 60 second timeout */
1964 	blk_queue_rq_timeout(sdev->request_queue, 60 * HZ);
1965 
1966 	return 0;
1967 } /* End twa_slave_configure() */
1968 
1969 /* scsi_host_template initializer */
1970 static struct scsi_host_template driver_template = {
1971 	.module			= THIS_MODULE,
1972 	.name			= "3ware 9000 Storage Controller",
1973 	.queuecommand		= twa_scsi_queue,
1974 	.eh_host_reset_handler	= twa_scsi_eh_reset,
1975 	.bios_param		= twa_scsi_biosparam,
1976 	.change_queue_depth	= scsi_change_queue_depth,
1977 	.can_queue		= TW_Q_LENGTH-2,
1978 	.slave_configure	= twa_slave_configure,
1979 	.this_id		= -1,
1980 	.sg_tablesize		= TW_APACHE_MAX_SGL_LENGTH,
1981 	.max_sectors		= TW_MAX_SECTORS,
1982 	.cmd_per_lun		= TW_MAX_CMDS_PER_LUN,
1983 	.use_clustering		= ENABLE_CLUSTERING,
1984 	.shost_attrs		= twa_host_attrs,
1985 	.emulated		= 1,
1986 	.no_write_same		= 1,
1987 };
1988 
1989 /* This function will probe and initialize a card */
1990 static int twa_probe(struct pci_dev *pdev, const struct pci_device_id *dev_id)
1991 {
1992 	struct Scsi_Host *host = NULL;
1993 	TW_Device_Extension *tw_dev;
1994 	unsigned long mem_addr, mem_len;
1995 	int retval = -ENODEV;
1996 
1997 	retval = pci_enable_device(pdev);
1998 	if (retval) {
1999 		TW_PRINTK(host, TW_DRIVER, 0x34, "Failed to enable pci device");
2000 		goto out_disable_device;
2001 	}
2002 
2003 	pci_set_master(pdev);
2004 	pci_try_set_mwi(pdev);
2005 
2006 	if (pci_set_dma_mask(pdev, DMA_BIT_MASK(64))
2007 	    || pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64)))
2008 		if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32))
2009 		    || pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32))) {
2010 			TW_PRINTK(host, TW_DRIVER, 0x23, "Failed to set dma mask");
2011 			retval = -ENODEV;
2012 			goto out_disable_device;
2013 		}
2014 
2015 	host = scsi_host_alloc(&driver_template, sizeof(TW_Device_Extension));
2016 	if (!host) {
2017 		TW_PRINTK(host, TW_DRIVER, 0x24, "Failed to allocate memory for device extension");
2018 		retval = -ENOMEM;
2019 		goto out_disable_device;
2020 	}
2021 	tw_dev = (TW_Device_Extension *)host->hostdata;
2022 
2023 	/* Save values to device extension */
2024 	tw_dev->host = host;
2025 	tw_dev->tw_pci_dev = pdev;
2026 
2027 	if (twa_initialize_device_extension(tw_dev)) {
2028 		TW_PRINTK(tw_dev->host, TW_DRIVER, 0x25, "Failed to initialize device extension");
2029 		goto out_free_device_extension;
2030 	}
2031 
2032 	/* Request IO regions */
2033 	retval = pci_request_regions(pdev, "3w-9xxx");
2034 	if (retval) {
2035 		TW_PRINTK(tw_dev->host, TW_DRIVER, 0x26, "Failed to get mem region");
2036 		goto out_free_device_extension;
2037 	}
2038 
2039 	if (pdev->device == PCI_DEVICE_ID_3WARE_9000) {
2040 		mem_addr = pci_resource_start(pdev, 1);
2041 		mem_len = pci_resource_len(pdev, 1);
2042 	} else {
2043 		mem_addr = pci_resource_start(pdev, 2);
2044 		mem_len = pci_resource_len(pdev, 2);
2045 	}
2046 
2047 	/* Save base address */
2048 	tw_dev->base_addr = ioremap(mem_addr, mem_len);
2049 	if (!tw_dev->base_addr) {
2050 		TW_PRINTK(tw_dev->host, TW_DRIVER, 0x35, "Failed to ioremap");
2051 		goto out_release_mem_region;
2052 	}
2053 
2054 	/* Disable interrupts on the card */
2055 	TW_DISABLE_INTERRUPTS(tw_dev);
2056 
2057 	/* Initialize the card */
2058 	if (twa_reset_sequence(tw_dev, 0))
2059 		goto out_iounmap;
2060 
2061 	/* Set host specific parameters */
2062 	if ((pdev->device == PCI_DEVICE_ID_3WARE_9650SE) ||
2063 	    (pdev->device == PCI_DEVICE_ID_3WARE_9690SA))
2064 		host->max_id = TW_MAX_UNITS_9650SE;
2065 	else
2066 		host->max_id = TW_MAX_UNITS;
2067 
2068 	host->max_cmd_len = TW_MAX_CDB_LEN;
2069 
2070 	/* Channels aren't supported by adapter */
2071 	host->max_lun = TW_MAX_LUNS(tw_dev->tw_compat_info.working_srl);
2072 	host->max_channel = 0;
2073 
2074 	/* Register the card with the kernel SCSI layer */
2075 	retval = scsi_add_host(host, &pdev->dev);
2076 	if (retval) {
2077 		TW_PRINTK(tw_dev->host, TW_DRIVER, 0x27, "scsi add host failed");
2078 		goto out_iounmap;
2079 	}
2080 
2081 	pci_set_drvdata(pdev, host);
2082 
2083 	printk(KERN_WARNING "3w-9xxx: scsi%d: Found a 3ware 9000 Storage Controller at 0x%lx, IRQ: %d.\n",
2084 	       host->host_no, mem_addr, pdev->irq);
2085 	printk(KERN_WARNING "3w-9xxx: scsi%d: Firmware %s, BIOS %s, Ports: %d.\n",
2086 	       host->host_no,
2087 	       (char *)twa_get_param(tw_dev, 0, TW_VERSION_TABLE,
2088 				     TW_PARAM_FWVER, TW_PARAM_FWVER_LENGTH),
2089 	       (char *)twa_get_param(tw_dev, 1, TW_VERSION_TABLE,
2090 				     TW_PARAM_BIOSVER, TW_PARAM_BIOSVER_LENGTH),
2091 	       le32_to_cpu(*(int *)twa_get_param(tw_dev, 2, TW_INFORMATION_TABLE,
2092 				     TW_PARAM_PORTCOUNT, TW_PARAM_PORTCOUNT_LENGTH)));
2093 
2094 	/* Try to enable MSI */
2095 	if (use_msi && (pdev->device != PCI_DEVICE_ID_3WARE_9000) &&
2096 	    !pci_enable_msi(pdev))
2097 		set_bit(TW_USING_MSI, &tw_dev->flags);
2098 
2099 	/* Now setup the interrupt handler */
2100 	retval = request_irq(pdev->irq, twa_interrupt, IRQF_SHARED, "3w-9xxx", tw_dev);
2101 	if (retval) {
2102 		TW_PRINTK(tw_dev->host, TW_DRIVER, 0x30, "Error requesting IRQ");
2103 		goto out_remove_host;
2104 	}
2105 
2106 	twa_device_extension_list[twa_device_extension_count] = tw_dev;
2107 	twa_device_extension_count++;
2108 
2109 	/* Re-enable interrupts on the card */
2110 	TW_ENABLE_AND_CLEAR_INTERRUPTS(tw_dev);
2111 
2112 	/* Finally, scan the host */
2113 	scsi_scan_host(host);
2114 
2115 	if (twa_major == -1) {
2116 		if ((twa_major = register_chrdev (0, "twa", &twa_fops)) < 0)
2117 			TW_PRINTK(host, TW_DRIVER, 0x29, "Failed to register character device");
2118 	}
2119 	return 0;
2120 
2121 out_remove_host:
2122 	if (test_bit(TW_USING_MSI, &tw_dev->flags))
2123 		pci_disable_msi(pdev);
2124 	scsi_remove_host(host);
2125 out_iounmap:
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);
2132 out_disable_device:
2133 	pci_disable_device(pdev);
2134 
2135 	return retval;
2136 } /* End twa_probe() */
2137 
2138 /* This function is called to remove a device */
2139 static void twa_remove(struct pci_dev *pdev)
2140 {
2141 	struct Scsi_Host *host = pci_get_drvdata(pdev);
2142 	TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
2143 
2144 	scsi_remove_host(tw_dev->host);
2145 
2146 	/* Unregister character device */
2147 	if (twa_major >= 0) {
2148 		unregister_chrdev(twa_major, "twa");
2149 		twa_major = -1;
2150 	}
2151 
2152 	/* Shutdown the card */
2153 	__twa_shutdown(tw_dev);
2154 
2155 	/* Disable MSI if enabled */
2156 	if (test_bit(TW_USING_MSI, &tw_dev->flags))
2157 		pci_disable_msi(pdev);
2158 
2159 	/* Free IO remapping */
2160 	iounmap(tw_dev->base_addr);
2161 
2162 	/* Free up the mem region */
2163 	pci_release_regions(pdev);
2164 
2165 	/* Free up device extension resources */
2166 	twa_free_device_extension(tw_dev);
2167 
2168 	scsi_host_put(tw_dev->host);
2169 	pci_disable_device(pdev);
2170 	twa_device_extension_count--;
2171 } /* End twa_remove() */
2172 
2173 #ifdef CONFIG_PM
2174 /* This function is called on PCI suspend */
2175 static int twa_suspend(struct pci_dev *pdev, pm_message_t state)
2176 {
2177 	struct Scsi_Host *host = pci_get_drvdata(pdev);
2178 	TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
2179 
2180 	printk(KERN_WARNING "3w-9xxx: Suspending host %d.\n", tw_dev->host->host_no);
2181 
2182 	TW_DISABLE_INTERRUPTS(tw_dev);
2183 	free_irq(tw_dev->tw_pci_dev->irq, tw_dev);
2184 
2185 	if (test_bit(TW_USING_MSI, &tw_dev->flags))
2186 		pci_disable_msi(pdev);
2187 
2188 	/* Tell the card we are shutting down */
2189 	if (twa_initconnection(tw_dev, 1, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL)) {
2190 		TW_PRINTK(tw_dev->host, TW_DRIVER, 0x38, "Connection shutdown failed during suspend");
2191 	} else {
2192 		printk(KERN_WARNING "3w-9xxx: Suspend complete.\n");
2193 	}
2194 	TW_CLEAR_ALL_INTERRUPTS(tw_dev);
2195 
2196 	pci_save_state(pdev);
2197 	pci_disable_device(pdev);
2198 	pci_set_power_state(pdev, pci_choose_state(pdev, state));
2199 
2200 	return 0;
2201 } /* End twa_suspend() */
2202 
2203 /* This function is called on PCI resume */
2204 static int twa_resume(struct pci_dev *pdev)
2205 {
2206 	int retval = 0;
2207 	struct Scsi_Host *host = pci_get_drvdata(pdev);
2208 	TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
2209 
2210 	printk(KERN_WARNING "3w-9xxx: Resuming host %d.\n", tw_dev->host->host_no);
2211 	pci_set_power_state(pdev, PCI_D0);
2212 	pci_enable_wake(pdev, PCI_D0, 0);
2213 	pci_restore_state(pdev);
2214 
2215 	retval = pci_enable_device(pdev);
2216 	if (retval) {
2217 		TW_PRINTK(tw_dev->host, TW_DRIVER, 0x39, "Enable device failed during resume");
2218 		return retval;
2219 	}
2220 
2221 	pci_set_master(pdev);
2222 	pci_try_set_mwi(pdev);
2223 
2224 	if (pci_set_dma_mask(pdev, DMA_BIT_MASK(64))
2225 	    || pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64)))
2226 		if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32))
2227 		    || pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32))) {
2228 			TW_PRINTK(host, TW_DRIVER, 0x40, "Failed to set dma mask during resume");
2229 			retval = -ENODEV;
2230 			goto out_disable_device;
2231 		}
2232 
2233 	/* Initialize the card */
2234 	if (twa_reset_sequence(tw_dev, 0)) {
2235 		retval = -ENODEV;
2236 		goto out_disable_device;
2237 	}
2238 
2239 	/* Now setup the interrupt handler */
2240 	retval = request_irq(pdev->irq, twa_interrupt, IRQF_SHARED, "3w-9xxx", tw_dev);
2241 	if (retval) {
2242 		TW_PRINTK(tw_dev->host, TW_DRIVER, 0x42, "Error requesting IRQ during resume");
2243 		retval = -ENODEV;
2244 		goto out_disable_device;
2245 	}
2246 
2247 	/* Now enable MSI if enabled */
2248 	if (test_bit(TW_USING_MSI, &tw_dev->flags))
2249 		pci_enable_msi(pdev);
2250 
2251 	/* Re-enable interrupts on the card */
2252 	TW_ENABLE_AND_CLEAR_INTERRUPTS(tw_dev);
2253 
2254 	printk(KERN_WARNING "3w-9xxx: Resume complete.\n");
2255 	return 0;
2256 
2257 out_disable_device:
2258 	scsi_remove_host(host);
2259 	pci_disable_device(pdev);
2260 
2261 	return retval;
2262 } /* End twa_resume() */
2263 #endif
2264 
2265 /* PCI Devices supported by this driver */
2266 static struct pci_device_id twa_pci_tbl[] = {
2267 	{ PCI_VENDOR_ID_3WARE, PCI_DEVICE_ID_3WARE_9000,
2268 	  PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
2269 	{ PCI_VENDOR_ID_3WARE, PCI_DEVICE_ID_3WARE_9550SX,
2270 	  PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
2271 	{ PCI_VENDOR_ID_3WARE, PCI_DEVICE_ID_3WARE_9650SE,
2272 	  PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
2273 	{ PCI_VENDOR_ID_3WARE, PCI_DEVICE_ID_3WARE_9690SA,
2274 	  PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
2275 	{ }
2276 };
2277 MODULE_DEVICE_TABLE(pci, twa_pci_tbl);
2278 
2279 /* pci_driver initializer */
2280 static struct pci_driver twa_driver = {
2281 	.name		= "3w-9xxx",
2282 	.id_table	= twa_pci_tbl,
2283 	.probe		= twa_probe,
2284 	.remove		= twa_remove,
2285 #ifdef CONFIG_PM
2286 	.suspend	= twa_suspend,
2287 	.resume		= twa_resume,
2288 #endif
2289 	.shutdown	= twa_shutdown
2290 };
2291 
2292 /* This function is called on driver initialization */
2293 static int __init twa_init(void)
2294 {
2295 	printk(KERN_WARNING "3ware 9000 Storage Controller device driver for Linux v%s.\n", TW_DRIVER_VERSION);
2296 
2297 	return pci_register_driver(&twa_driver);
2298 } /* End twa_init() */
2299 
2300 /* This function is called on driver exit */
2301 static void __exit twa_exit(void)
2302 {
2303 	pci_unregister_driver(&twa_driver);
2304 } /* End twa_exit() */
2305 
2306 module_init(twa_init);
2307 module_exit(twa_exit);
2308 
2309