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