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