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