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