?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Add "no BKL needed" comments to several drivers
[linux-2.6/zen-sources.git] / drivers / scsi / 3w-9xxx.c
blob2239d16fb9b568225df0fa5e0e26eaec4a2be5f7
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 /* NOTE that this function will race with remove; adding BKL
866 will not help. */
867 static int twa_chrdev_open(struct inode *inode, struct file *file)
868 {
869 unsigned int minor_number;
870 int retval = TW_IOCTL_ERROR_OS_ENODEV;
871
872 minor_number = iminor(inode);
873 if (minor_number >= twa_device_extension_count)
874 goto out;
875 retval = 0;
876 out:
877 return retval;
878 } /* End twa_chrdev_open() */
879
880 /* This function will print readable messages from status register errors */
881 static int twa_decode_bits(TW_Device_Extension *tw_dev, u32 status_reg_value)
882 {
883 int retval = 1;
884
885 /* Check for various error conditions and handle them appropriately */
886 if (status_reg_value & TW_STATUS_PCI_PARITY_ERROR) {
887 TW_PRINTK(tw_dev->host, TW_DRIVER, 0xc, "PCI Parity Error: clearing");
888 writel(TW_CONTROL_CLEAR_PARITY_ERROR, TW_CONTROL_REG_ADDR(tw_dev));
889 }
890
891 if (status_reg_value & TW_STATUS_PCI_ABORT) {
892 TW_PRINTK(tw_dev->host, TW_DRIVER, 0xd, "PCI Abort: clearing");
893 writel(TW_CONTROL_CLEAR_PCI_ABORT, TW_CONTROL_REG_ADDR(tw_dev));
894 pci_write_config_word(tw_dev->tw_pci_dev, PCI_STATUS, TW_PCI_CLEAR_PCI_ABORT);
895 }
896
897 if (status_reg_value & TW_STATUS_QUEUE_ERROR) {
898 if (((tw_dev->tw_pci_dev->device != PCI_DEVICE_ID_3WARE_9650SE) &&
899 (tw_dev->tw_pci_dev->device != PCI_DEVICE_ID_3WARE_9690SA)) ||
900 (!test_bit(TW_IN_RESET, &tw_dev->flags)))
901 TW_PRINTK(tw_dev->host, TW_DRIVER, 0xe, "Controller Queue Error: clearing");
902 writel(TW_CONTROL_CLEAR_QUEUE_ERROR, TW_CONTROL_REG_ADDR(tw_dev));
903 }
904
905 if (status_reg_value & TW_STATUS_MICROCONTROLLER_ERROR) {
906 if (tw_dev->reset_print == 0) {
907 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x10, "Microcontroller Error: clearing");
908 tw_dev->reset_print = 1;
909 }
910 goto out;
911 }
912 retval = 0;
913 out:
914 return retval;
915 } /* End twa_decode_bits() */
916
917 /* This function will empty the response queue */
918 static int twa_empty_response_queue(TW_Device_Extension *tw_dev)
919 {
920 u32 status_reg_value, response_que_value;
921 int count = 0, retval = 1;
922
923 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
924
925 while (((status_reg_value & TW_STATUS_RESPONSE_QUEUE_EMPTY) == 0) && (count < TW_MAX_RESPONSE_DRAIN)) {
926 response_que_value = readl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev));
927 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
928 count++;
929 }
930 if (count == TW_MAX_RESPONSE_DRAIN)
931 goto out;
932
933 retval = 0;
934 out:
935 return retval;
936 } /* End twa_empty_response_queue() */
937
938 /* This function will clear the pchip/response queue on 9550SX */
939 static int twa_empty_response_queue_large(TW_Device_Extension *tw_dev)
940 {
941 u32 response_que_value = 0;
942 unsigned long before;
943 int retval = 1;
944
945 if (tw_dev->tw_pci_dev->device != PCI_DEVICE_ID_3WARE_9000) {
946 before = jiffies;
947 while ((response_que_value & TW_9550SX_DRAIN_COMPLETED) != TW_9550SX_DRAIN_COMPLETED) {
948 response_que_value = readl(TW_RESPONSE_QUEUE_REG_ADDR_LARGE(tw_dev));
949 msleep(1);
950 if (time_after(jiffies, before + HZ * 30))
951 goto out;
952 }
953 /* P-chip settle time */
954 msleep(500);
955 retval = 0;
956 } else
957 retval = 0;
958 out:
959 return retval;
960 } /* End twa_empty_response_queue_large() */
961
962 /* This function passes sense keys from firmware to scsi layer */
963 static int twa_fill_sense(TW_Device_Extension *tw_dev, int request_id, int copy_sense, int print_host)
964 {
965 TW_Command_Full *full_command_packet;
966 unsigned short error;
967 int retval = 1;
968 char *error_str;
969
970 full_command_packet = tw_dev->command_packet_virt[request_id];
971
972 /* Check for embedded error string */
973 error_str = &(full_command_packet->header.err_specific_desc[strlen(full_command_packet->header.err_specific_desc) + 1]);
974
975 /* Don't print error for Logical unit not supported during rollcall */
976 error = le16_to_cpu(full_command_packet->header.status_block.error);
977 if ((error != TW_ERROR_LOGICAL_UNIT_NOT_SUPPORTED) && (error != TW_ERROR_UNIT_OFFLINE)) {
978 if (print_host)
979 printk(KERN_WARNING "3w-9xxx: scsi%d: ERROR: (0x%02X:0x%04X): %s:%s.\n",
980 tw_dev->host->host_no,
981 TW_MESSAGE_SOURCE_CONTROLLER_ERROR,
982 full_command_packet->header.status_block.error,
983 error_str[0] == '\0' ?
984 twa_string_lookup(twa_error_table,
985 full_command_packet->header.status_block.error) : error_str,
986 full_command_packet->header.err_specific_desc);
987 else
988 printk(KERN_WARNING "3w-9xxx: ERROR: (0x%02X:0x%04X): %s:%s.\n",
989 TW_MESSAGE_SOURCE_CONTROLLER_ERROR,
990 full_command_packet->header.status_block.error,
991 error_str[0] == '\0' ?
992 twa_string_lookup(twa_error_table,
993 full_command_packet->header.status_block.error) : error_str,
994 full_command_packet->header.err_specific_desc);
995 }
996
997 if (copy_sense) {
998 memcpy(tw_dev->srb[request_id]->sense_buffer, full_command_packet->header.sense_data, TW_SENSE_DATA_LENGTH);
999 tw_dev->srb[request_id]->result = (full_command_packet->command.newcommand.status << 1);
1000 retval = TW_ISR_DONT_RESULT;
1001 goto out;
1002 }
1003 retval = 0;
1004 out:
1005 return retval;
1006 } /* End twa_fill_sense() */
1007
1008 /* This function will free up device extension resources */
1009 static void twa_free_device_extension(TW_Device_Extension *tw_dev)
1010 {
1011 if (tw_dev->command_packet_virt[0])
1012 pci_free_consistent(tw_dev->tw_pci_dev,
1013 sizeof(TW_Command_Full)*TW_Q_LENGTH,
1014 tw_dev->command_packet_virt[0],
1015 tw_dev->command_packet_phys[0]);
1016
1017 if (tw_dev->generic_buffer_virt[0])
1018 pci_free_consistent(tw_dev->tw_pci_dev,
1019 TW_SECTOR_SIZE*TW_Q_LENGTH,
1020 tw_dev->generic_buffer_virt[0],
1021 tw_dev->generic_buffer_phys[0]);
1022
1023 kfree(tw_dev->event_queue[0]);
1024 } /* End twa_free_device_extension() */
1025
1026 /* This function will free a request id */
1027 static void twa_free_request_id(TW_Device_Extension *tw_dev, int request_id)
1028 {
1029 tw_dev->free_queue[tw_dev->free_tail] = request_id;
1030 tw_dev->state[request_id] = TW_S_FINISHED;
1031 tw_dev->free_tail = (tw_dev->free_tail + 1) % TW_Q_LENGTH;
1032 } /* End twa_free_request_id() */
1033
1034 /* This function will get parameter table entries from the firmware */
1035 static void *twa_get_param(TW_Device_Extension *tw_dev, int request_id, int table_id, int parameter_id, int parameter_size_bytes)
1036 {
1037 TW_Command_Full *full_command_packet;
1038 TW_Command *command_packet;
1039 TW_Param_Apache *param;
1040 unsigned long param_value;
1041 void *retval = NULL;
1042
1043 /* Setup the command packet */
1044 full_command_packet = tw_dev->command_packet_virt[request_id];
1045 memset(full_command_packet, 0, sizeof(TW_Command_Full));
1046 command_packet = &full_command_packet->command.oldcommand;
1047
1048 command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_GET_PARAM);
1049 command_packet->size = TW_COMMAND_SIZE;
1050 command_packet->request_id = request_id;
1051 command_packet->byte6_offset.block_count = cpu_to_le16(1);
1052
1053 /* Now setup the param */
1054 param = (TW_Param_Apache *)tw_dev->generic_buffer_virt[request_id];
1055 memset(param, 0, TW_SECTOR_SIZE);
1056 param->table_id = cpu_to_le16(table_id | 0x8000);
1057 param->parameter_id = cpu_to_le16(parameter_id);
1058 param->parameter_size_bytes = cpu_to_le16(parameter_size_bytes);
1059 param_value = tw_dev->generic_buffer_phys[request_id];
1060
1061 command_packet->byte8_offset.param.sgl[0].address = TW_CPU_TO_SGL(param_value);
1062 command_packet->byte8_offset.param.sgl[0].length = cpu_to_le32(TW_SECTOR_SIZE);
1063
1064 /* Post the command packet to the board */
1065 twa_post_command_packet(tw_dev, request_id, 1);
1066
1067 /* Poll for completion */
1068 if (twa_poll_response(tw_dev, request_id, 30))
1069 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x13, "No valid response during get param")
1070 else
1071 retval = (void *)&(param->data[0]);
1072
1073 tw_dev->posted_request_count--;
1074 tw_dev->state[request_id] = TW_S_INITIAL;
1075
1076 return retval;
1077 } /* End twa_get_param() */
1078
1079 /* This function will assign an available request id */
1080 static void twa_get_request_id(TW_Device_Extension *tw_dev, int *request_id)
1081 {
1082 *request_id = tw_dev->free_queue[tw_dev->free_head];
1083 tw_dev->free_head = (tw_dev->free_head + 1) % TW_Q_LENGTH;
1084 tw_dev->state[*request_id] = TW_S_STARTED;
1085 } /* End twa_get_request_id() */
1086
1087 /* This function will send an initconnection command to controller */
1088 static int twa_initconnection(TW_Device_Extension *tw_dev, int message_credits,
1089 u32 set_features, unsigned short current_fw_srl,
1090 unsigned short current_fw_arch_id,
1091 unsigned short current_fw_branch,
1092 unsigned short current_fw_build,
1093 unsigned short *fw_on_ctlr_srl,
1094 unsigned short *fw_on_ctlr_arch_id,
1095 unsigned short *fw_on_ctlr_branch,
1096 unsigned short *fw_on_ctlr_build,
1097 u32 *init_connect_result)
1098 {
1099 TW_Command_Full *full_command_packet;
1100 TW_Initconnect *tw_initconnect;
1101 int request_id = 0, retval = 1;
1102
1103 /* Initialize InitConnection command packet */
1104 full_command_packet = tw_dev->command_packet_virt[request_id];
1105 memset(full_command_packet, 0, sizeof(TW_Command_Full));
1106 full_command_packet->header.header_desc.size_header = 128;
1107
1108 tw_initconnect = (TW_Initconnect *)&full_command_packet->command.oldcommand;
1109 tw_initconnect->opcode__reserved = TW_OPRES_IN(0, TW_OP_INIT_CONNECTION);
1110 tw_initconnect->request_id = request_id;
1111 tw_initconnect->message_credits = cpu_to_le16(message_credits);
1112 tw_initconnect->features = set_features;
1113
1114 /* Turn on 64-bit sgl support if we need to */
1115 tw_initconnect->features |= sizeof(dma_addr_t) > 4 ? 1 : 0;
1116
1117 tw_initconnect->features = cpu_to_le32(tw_initconnect->features);
1118
1119 if (set_features & TW_EXTENDED_INIT_CONNECT) {
1120 tw_initconnect->size = TW_INIT_COMMAND_PACKET_SIZE_EXTENDED;
1121 tw_initconnect->fw_srl = cpu_to_le16(current_fw_srl);
1122 tw_initconnect->fw_arch_id = cpu_to_le16(current_fw_arch_id);
1123 tw_initconnect->fw_branch = cpu_to_le16(current_fw_branch);
1124 tw_initconnect->fw_build = cpu_to_le16(current_fw_build);
1125 } else
1126 tw_initconnect->size = TW_INIT_COMMAND_PACKET_SIZE;
1127
1128 /* Send command packet to the board */
1129 twa_post_command_packet(tw_dev, request_id, 1);
1130
1131 /* Poll for completion */
1132 if (twa_poll_response(tw_dev, request_id, 30)) {
1133 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x15, "No valid response during init connection");
1134 } else {
1135 if (set_features & TW_EXTENDED_INIT_CONNECT) {
1136 *fw_on_ctlr_srl = le16_to_cpu(tw_initconnect->fw_srl);
1137 *fw_on_ctlr_arch_id = le16_to_cpu(tw_initconnect->fw_arch_id);
1138 *fw_on_ctlr_branch = le16_to_cpu(tw_initconnect->fw_branch);
1139 *fw_on_ctlr_build = le16_to_cpu(tw_initconnect->fw_build);
1140 *init_connect_result = le32_to_cpu(tw_initconnect->result);
1141 }
1142 retval = 0;
1143 }
1144
1145 tw_dev->posted_request_count--;
1146 tw_dev->state[request_id] = TW_S_INITIAL;
1147
1148 return retval;
1149 } /* End twa_initconnection() */
1150
1151 /* This function will initialize the fields of a device extension */
1152 static int twa_initialize_device_extension(TW_Device_Extension *tw_dev)
1153 {
1154 int i, retval = 1;
1155
1156 /* Initialize command packet buffers */
1157 if (twa_allocate_memory(tw_dev, sizeof(TW_Command_Full), 0)) {
1158 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x16, "Command packet memory allocation failed");
1159 goto out;
1160 }
1161
1162 /* Initialize generic buffer */
1163 if (twa_allocate_memory(tw_dev, TW_SECTOR_SIZE, 1)) {
1164 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x17, "Generic memory allocation failed");
1165 goto out;
1166 }
1167
1168 /* Allocate event info space */
1169 tw_dev->event_queue[0] = kcalloc(TW_Q_LENGTH, sizeof(TW_Event), GFP_KERNEL);
1170 if (!tw_dev->event_queue[0]) {
1171 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x18, "Event info memory allocation failed");
1172 goto out;
1173 }
1174
1175
1176 for (i = 0; i < TW_Q_LENGTH; i++) {
1177 tw_dev->event_queue[i] = (TW_Event *)((unsigned char *)tw_dev->event_queue[0] + (i * sizeof(TW_Event)));
1178 tw_dev->free_queue[i] = i;
1179 tw_dev->state[i] = TW_S_INITIAL;
1180 }
1181
1182 tw_dev->pending_head = TW_Q_START;
1183 tw_dev->pending_tail = TW_Q_START;
1184 tw_dev->free_head = TW_Q_START;
1185 tw_dev->free_tail = TW_Q_START;
1186 tw_dev->error_sequence_id = 1;
1187 tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE;
1188
1189 mutex_init(&tw_dev->ioctl_lock);
1190 init_waitqueue_head(&tw_dev->ioctl_wqueue);
1191
1192 retval = 0;
1193 out:
1194 return retval;
1195 } /* End twa_initialize_device_extension() */
1196
1197 /* This function is the interrupt service routine */
1198 static irqreturn_t twa_interrupt(int irq, void *dev_instance)
1199 {
1200 int request_id, error = 0;
1201 u32 status_reg_value;
1202 TW_Response_Queue response_que;
1203 TW_Command_Full *full_command_packet;
1204 TW_Device_Extension *tw_dev = (TW_Device_Extension *)dev_instance;
1205 int handled = 0;
1206
1207 /* Get the per adapter lock */
1208 spin_lock(tw_dev->host->host_lock);
1209
1210 /* Read the registers */
1211 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
1212
1213 /* Check if this is our interrupt, otherwise bail */
1214 if (!(status_reg_value & TW_STATUS_VALID_INTERRUPT))
1215 goto twa_interrupt_bail;
1216
1217 handled = 1;
1218
1219 /* If we are resetting, bail */
1220 if (test_bit(TW_IN_RESET, &tw_dev->flags))
1221 goto twa_interrupt_bail;
1222
1223 /* Check controller for errors */
1224 if (twa_check_bits(status_reg_value)) {
1225 if (twa_decode_bits(tw_dev, status_reg_value)) {
1226 TW_CLEAR_ALL_INTERRUPTS(tw_dev);
1227 goto twa_interrupt_bail;
1228 }
1229 }
1230
1231 /* Handle host interrupt */
1232 if (status_reg_value & TW_STATUS_HOST_INTERRUPT)
1233 TW_CLEAR_HOST_INTERRUPT(tw_dev);
1234
1235 /* Handle attention interrupt */
1236 if (status_reg_value & TW_STATUS_ATTENTION_INTERRUPT) {
1237 TW_CLEAR_ATTENTION_INTERRUPT(tw_dev);
1238 if (!(test_and_set_bit(TW_IN_ATTENTION_LOOP, &tw_dev->flags))) {
1239 twa_get_request_id(tw_dev, &request_id);
1240
1241 error = twa_aen_read_queue(tw_dev, request_id);
1242 if (error) {
1243 tw_dev->state[request_id] = TW_S_COMPLETED;
1244 twa_free_request_id(tw_dev, request_id);
1245 clear_bit(TW_IN_ATTENTION_LOOP, &tw_dev->flags);
1246 }
1247 }
1248 }
1249
1250 /* Handle command interrupt */
1251 if (status_reg_value & TW_STATUS_COMMAND_INTERRUPT) {
1252 TW_MASK_COMMAND_INTERRUPT(tw_dev);
1253 /* Drain as many pending commands as we can */
1254 while (tw_dev->pending_request_count > 0) {
1255 request_id = tw_dev->pending_queue[tw_dev->pending_head];
1256 if (tw_dev->state[request_id] != TW_S_PENDING) {
1257 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x19, "Found request id that wasn't pending");
1258 TW_CLEAR_ALL_INTERRUPTS(tw_dev);
1259 goto twa_interrupt_bail;
1260 }
1261 if (twa_post_command_packet(tw_dev, request_id, 1)==0) {
1262 tw_dev->pending_head = (tw_dev->pending_head + 1) % TW_Q_LENGTH;
1263 tw_dev->pending_request_count--;
1264 } else {
1265 /* If we get here, we will continue re-posting on the next command interrupt */
1266 break;
1267 }
1268 }
1269 }
1270
1271 /* Handle response interrupt */
1272 if (status_reg_value & TW_STATUS_RESPONSE_INTERRUPT) {
1273
1274 /* Drain the response queue from the board */
1275 while ((status_reg_value & TW_STATUS_RESPONSE_QUEUE_EMPTY) == 0) {
1276 /* Complete the response */
1277 response_que.value = readl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev));
1278 request_id = TW_RESID_OUT(response_que.response_id);
1279 full_command_packet = tw_dev->command_packet_virt[request_id];
1280 error = 0;
1281 /* Check for command packet errors */
1282 if (full_command_packet->command.newcommand.status != 0) {
1283 if (tw_dev->srb[request_id] != 0) {
1284 error = twa_fill_sense(tw_dev, request_id, 1, 1);
1285 } else {
1286 /* Skip ioctl error prints */
1287 if (request_id != tw_dev->chrdev_request_id) {
1288 error = twa_fill_sense(tw_dev, request_id, 0, 1);
1289 }
1290 }
1291 }
1292
1293 /* Check for correct state */
1294 if (tw_dev->state[request_id] != TW_S_POSTED) {
1295 if (tw_dev->srb[request_id] != 0) {
1296 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1a, "Received a request id that wasn't posted");
1297 TW_CLEAR_ALL_INTERRUPTS(tw_dev);
1298 goto twa_interrupt_bail;
1299 }
1300 }
1301
1302 /* Check for internal command completion */
1303 if (tw_dev->srb[request_id] == 0) {
1304 if (request_id != tw_dev->chrdev_request_id) {
1305 if (twa_aen_complete(tw_dev, request_id))
1306 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1b, "Error completing AEN during attention interrupt");
1307 } else {
1308 tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE;
1309 wake_up(&tw_dev->ioctl_wqueue);
1310 }
1311 } else {
1312 struct scsi_cmnd *cmd;
1313
1314 cmd = tw_dev->srb[request_id];
1315
1316 twa_scsiop_execute_scsi_complete(tw_dev, request_id);
1317 /* If no error command was a success */
1318 if (error == 0) {
1319 cmd->result = (DID_OK << 16);
1320 }
1321
1322 /* If error, command failed */
1323 if (error == 1) {
1324 /* Ask for a host reset */
1325 cmd->result = (DID_OK << 16) | (CHECK_CONDITION << 1);
1326 }
1327
1328 /* Report residual bytes for single sgl */
1329 if ((scsi_sg_count(cmd) <= 1) && (full_command_packet->command.newcommand.status == 0)) {
1330 if (full_command_packet->command.newcommand.sg_list[0].length < scsi_bufflen(tw_dev->srb[request_id]))
1331 scsi_set_resid(cmd, scsi_bufflen(cmd) - full_command_packet->command.newcommand.sg_list[0].length);
1332 }
1333
1334 /* Now complete the io */
1335 tw_dev->state[request_id] = TW_S_COMPLETED;
1336 twa_free_request_id(tw_dev, request_id);
1337 tw_dev->posted_request_count--;
1338 tw_dev->srb[request_id]->scsi_done(tw_dev->srb[request_id]);
1339 twa_unmap_scsi_data(tw_dev, request_id);
1340 }
1341
1342 /* Check for valid status after each drain */
1343 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
1344 if (twa_check_bits(status_reg_value)) {
1345 if (twa_decode_bits(tw_dev, status_reg_value)) {
1346 TW_CLEAR_ALL_INTERRUPTS(tw_dev);
1347 goto twa_interrupt_bail;
1348 }
1349 }
1350 }
1351 }
1352
1353 twa_interrupt_bail:
1354 spin_unlock(tw_dev->host->host_lock);
1355 return IRQ_RETVAL(handled);
1356 } /* End twa_interrupt() */
1357
1358 /* This function will load the request id and various sgls for ioctls */
1359 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)
1360 {
1361 TW_Command *oldcommand;
1362 TW_Command_Apache *newcommand;
1363 TW_SG_Entry *sgl;
1364 unsigned int pae = 0;
1365
1366 if ((sizeof(long) < 8) && (sizeof(dma_addr_t) > 4))
1367 pae = 1;
1368
1369 if (TW_OP_OUT(full_command_packet->command.newcommand.opcode__reserved) == TW_OP_EXECUTE_SCSI) {
1370 newcommand = &full_command_packet->command.newcommand;
1371 newcommand->request_id__lunl =
1372 cpu_to_le16(TW_REQ_LUN_IN(TW_LUN_OUT(newcommand->request_id__lunl), request_id));
1373 newcommand->sg_list[0].address = TW_CPU_TO_SGL(dma_handle + sizeof(TW_Ioctl_Buf_Apache) - 1);
1374 newcommand->sg_list[0].length = cpu_to_le32(length);
1375 newcommand->sgl_entries__lunh =
1376 cpu_to_le16(TW_REQ_LUN_IN(TW_LUN_OUT(newcommand->sgl_entries__lunh), 1));
1377 } else {
1378 oldcommand = &full_command_packet->command.oldcommand;
1379 oldcommand->request_id = request_id;
1380
1381 if (TW_SGL_OUT(oldcommand->opcode__sgloffset)) {
1382 /* Load the sg list */
1383 if (tw_dev->tw_pci_dev->device == PCI_DEVICE_ID_3WARE_9690SA)
1384 sgl = (TW_SG_Entry *)((u32 *)oldcommand+oldcommand->size - (sizeof(TW_SG_Entry)/4) + pae);
1385 else
1386 sgl = (TW_SG_Entry *)((u32 *)oldcommand+TW_SGL_OUT(oldcommand->opcode__sgloffset));
1387 sgl->address = TW_CPU_TO_SGL(dma_handle + sizeof(TW_Ioctl_Buf_Apache) - 1);
1388 sgl->length = cpu_to_le32(length);
1389
1390 oldcommand->size += pae;
1391 }
1392 }
1393 } /* End twa_load_sgl() */
1394
1395 /* This function will perform a pci-dma mapping for a scatter gather list */
1396 static int twa_map_scsi_sg_data(TW_Device_Extension *tw_dev, int request_id)
1397 {
1398 int use_sg;
1399 struct scsi_cmnd *cmd = tw_dev->srb[request_id];
1400
1401 use_sg = scsi_dma_map(cmd);
1402 if (!use_sg)
1403 return 0;
1404 else if (use_sg < 0) {
1405 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1c, "Failed to map scatter gather list");
1406 return 0;
1407 }
1408
1409 cmd->SCp.phase = TW_PHASE_SGLIST;
1410 cmd->SCp.have_data_in = use_sg;
1411
1412 return use_sg;
1413 } /* End twa_map_scsi_sg_data() */
1414
1415 /* This function will poll for a response interrupt of a request */
1416 static int twa_poll_response(TW_Device_Extension *tw_dev, int request_id, int seconds)
1417 {
1418 int retval = 1, found = 0, response_request_id;
1419 TW_Response_Queue response_queue;
1420 TW_Command_Full *full_command_packet = tw_dev->command_packet_virt[request_id];
1421
1422 if (twa_poll_status_gone(tw_dev, TW_STATUS_RESPONSE_QUEUE_EMPTY, seconds) == 0) {
1423 response_queue.value = readl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev));
1424 response_request_id = TW_RESID_OUT(response_queue.response_id);
1425 if (request_id != response_request_id) {
1426 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1e, "Found unexpected request id while polling for response");
1427 goto out;
1428 }
1429 if (TW_OP_OUT(full_command_packet->command.newcommand.opcode__reserved) == TW_OP_EXECUTE_SCSI) {
1430 if (full_command_packet->command.newcommand.status != 0) {
1431 /* bad response */
1432 twa_fill_sense(tw_dev, request_id, 0, 0);
1433 goto out;
1434 }
1435 found = 1;
1436 } else {
1437 if (full_command_packet->command.oldcommand.status != 0) {
1438 /* bad response */
1439 twa_fill_sense(tw_dev, request_id, 0, 0);
1440 goto out;
1441 }
1442 found = 1;
1443 }
1444 }
1445
1446 if (found)
1447 retval = 0;
1448 out:
1449 return retval;
1450 } /* End twa_poll_response() */
1451
1452 /* This function will poll the status register for a flag */
1453 static int twa_poll_status(TW_Device_Extension *tw_dev, u32 flag, int seconds)
1454 {
1455 u32 status_reg_value;
1456 unsigned long before;
1457 int retval = 1;
1458
1459 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
1460 before = jiffies;
1461
1462 if (twa_check_bits(status_reg_value))
1463 twa_decode_bits(tw_dev, status_reg_value);
1464
1465 while ((status_reg_value & flag) != flag) {
1466 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
1467
1468 if (twa_check_bits(status_reg_value))
1469 twa_decode_bits(tw_dev, status_reg_value);
1470
1471 if (time_after(jiffies, before + HZ * seconds))
1472 goto out;
1473
1474 msleep(50);
1475 }
1476 retval = 0;
1477 out:
1478 return retval;
1479 } /* End twa_poll_status() */
1480
1481 /* This function will poll the status register for disappearance of a flag */
1482 static int twa_poll_status_gone(TW_Device_Extension *tw_dev, u32 flag, int seconds)
1483 {
1484 u32 status_reg_value;
1485 unsigned long before;
1486 int retval = 1;
1487
1488 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
1489 before = jiffies;
1490
1491 if (twa_check_bits(status_reg_value))
1492 twa_decode_bits(tw_dev, status_reg_value);
1493
1494 while ((status_reg_value & flag) != 0) {
1495 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
1496 if (twa_check_bits(status_reg_value))
1497 twa_decode_bits(tw_dev, status_reg_value);
1498
1499 if (time_after(jiffies, before + HZ * seconds))
1500 goto out;
1501
1502 msleep(50);
1503 }
1504 retval = 0;
1505 out:
1506 return retval;
1507 } /* End twa_poll_status_gone() */
1508
1509 /* This function will attempt to post a command packet to the board */
1510 static int twa_post_command_packet(TW_Device_Extension *tw_dev, int request_id, char internal)
1511 {
1512 u32 status_reg_value;
1513 dma_addr_t command_que_value;
1514 int retval = 1;
1515
1516 command_que_value = tw_dev->command_packet_phys[request_id];
1517
1518 /* For 9650SE write low 4 bytes first */
1519 if ((tw_dev->tw_pci_dev->device == PCI_DEVICE_ID_3WARE_9650SE) ||
1520 (tw_dev->tw_pci_dev->device == PCI_DEVICE_ID_3WARE_9690SA)) {
1521 command_que_value += TW_COMMAND_OFFSET;
1522 writel((u32)command_que_value, TW_COMMAND_QUEUE_REG_ADDR_LARGE(tw_dev));
1523 }
1524
1525 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
1526
1527 if (twa_check_bits(status_reg_value))
1528 twa_decode_bits(tw_dev, status_reg_value);
1529
1530 if (((tw_dev->pending_request_count > 0) && (tw_dev->state[request_id] != TW_S_PENDING)) || (status_reg_value & TW_STATUS_COMMAND_QUEUE_FULL)) {
1531
1532 /* Only pend internal driver commands */
1533 if (!internal) {
1534 retval = SCSI_MLQUEUE_HOST_BUSY;
1535 goto out;
1536 }
1537
1538 /* Couldn't post the command packet, so we do it later */
1539 if (tw_dev->state[request_id] != TW_S_PENDING) {
1540 tw_dev->state[request_id] = TW_S_PENDING;
1541 tw_dev->pending_request_count++;
1542 if (tw_dev->pending_request_count > tw_dev->max_pending_request_count) {
1543 tw_dev->max_pending_request_count = tw_dev->pending_request_count;
1544 }
1545 tw_dev->pending_queue[tw_dev->pending_tail] = request_id;
1546 tw_dev->pending_tail = (tw_dev->pending_tail + 1) % TW_Q_LENGTH;
1547 }
1548 TW_UNMASK_COMMAND_INTERRUPT(tw_dev);
1549 goto out;
1550 } else {
1551 if ((tw_dev->tw_pci_dev->device == PCI_DEVICE_ID_3WARE_9650SE) ||
1552 (tw_dev->tw_pci_dev->device == PCI_DEVICE_ID_3WARE_9690SA)) {
1553 /* Now write upper 4 bytes */
1554 writel((u32)((u64)command_que_value >> 32), TW_COMMAND_QUEUE_REG_ADDR_LARGE(tw_dev) + 0x4);
1555 } else {
1556 if (sizeof(dma_addr_t) > 4) {
1557 command_que_value += TW_COMMAND_OFFSET;
1558 writel((u32)command_que_value, TW_COMMAND_QUEUE_REG_ADDR(tw_dev));
1559 writel((u32)((u64)command_que_value >> 32), TW_COMMAND_QUEUE_REG_ADDR(tw_dev) + 0x4);
1560 } else {
1561 writel(TW_COMMAND_OFFSET + command_que_value, TW_COMMAND_QUEUE_REG_ADDR(tw_dev));
1562 }
1563 }
1564 tw_dev->state[request_id] = TW_S_POSTED;
1565 tw_dev->posted_request_count++;
1566 if (tw_dev->posted_request_count > tw_dev->max_posted_request_count) {
1567 tw_dev->max_posted_request_count = tw_dev->posted_request_count;
1568 }
1569 }
1570 retval = 0;
1571 out:
1572 return retval;
1573 } /* End twa_post_command_packet() */
1574
1575 /* This function will reset a device extension */
1576 static int twa_reset_device_extension(TW_Device_Extension *tw_dev)
1577 {
1578 int i = 0;
1579 int retval = 1;
1580 unsigned long flags = 0;
1581
1582 set_bit(TW_IN_RESET, &tw_dev->flags);
1583 TW_DISABLE_INTERRUPTS(tw_dev);
1584 TW_MASK_COMMAND_INTERRUPT(tw_dev);
1585 spin_lock_irqsave(tw_dev->host->host_lock, flags);
1586
1587 /* Abort all requests that are in progress */
1588 for (i = 0; i < TW_Q_LENGTH; i++) {
1589 if ((tw_dev->state[i] != TW_S_FINISHED) &&
1590 (tw_dev->state[i] != TW_S_INITIAL) &&
1591 (tw_dev->state[i] != TW_S_COMPLETED)) {
1592 if (tw_dev->srb[i]) {
1593 tw_dev->srb[i]->result = (DID_RESET << 16);
1594 tw_dev->srb[i]->scsi_done(tw_dev->srb[i]);
1595 twa_unmap_scsi_data(tw_dev, i);
1596 }
1597 }
1598 }
1599
1600 /* Reset queues and counts */
1601 for (i = 0; i < TW_Q_LENGTH; i++) {
1602 tw_dev->free_queue[i] = i;
1603 tw_dev->state[i] = TW_S_INITIAL;
1604 }
1605 tw_dev->free_head = TW_Q_START;
1606 tw_dev->free_tail = TW_Q_START;
1607 tw_dev->posted_request_count = 0;
1608 tw_dev->pending_request_count = 0;
1609 tw_dev->pending_head = TW_Q_START;
1610 tw_dev->pending_tail = TW_Q_START;
1611 tw_dev->reset_print = 0;
1612
1613 spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
1614
1615 if (twa_reset_sequence(tw_dev, 1))
1616 goto out;
1617
1618 TW_ENABLE_AND_CLEAR_INTERRUPTS(tw_dev);
1619 clear_bit(TW_IN_RESET, &tw_dev->flags);
1620 tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE;
1621
1622 retval = 0;
1623 out:
1624 return retval;
1625 } /* End twa_reset_device_extension() */
1626
1627 /* This function will reset a controller */
1628 static int twa_reset_sequence(TW_Device_Extension *tw_dev, int soft_reset)
1629 {
1630 int tries = 0, retval = 1, flashed = 0, do_soft_reset = soft_reset;
1631
1632 while (tries < TW_MAX_RESET_TRIES) {
1633 if (do_soft_reset) {
1634 TW_SOFT_RESET(tw_dev);
1635 /* Clear pchip/response queue on 9550SX */
1636 if (twa_empty_response_queue_large(tw_dev)) {
1637 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x36, "Response queue (large) empty failed during reset sequence");
1638 do_soft_reset = 1;
1639 tries++;
1640 continue;
1641 }
1642 }
1643
1644 /* Make sure controller is in a good state */
1645 if (twa_poll_status(tw_dev, TW_STATUS_MICROCONTROLLER_READY | (do_soft_reset == 1 ? TW_STATUS_ATTENTION_INTERRUPT : 0), 60)) {
1646 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1f, "Microcontroller not ready during reset sequence");
1647 do_soft_reset = 1;
1648 tries++;
1649 continue;
1650 }
1651
1652 /* Empty response queue */
1653 if (twa_empty_response_queue(tw_dev)) {
1654 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x20, "Response queue empty failed during reset sequence");
1655 do_soft_reset = 1;
1656 tries++;
1657 continue;
1658 }
1659
1660 flashed = 0;
1661
1662 /* Check for compatibility/flash */
1663 if (twa_check_srl(tw_dev, &flashed)) {
1664 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x21, "Compatibility check failed during reset sequence");
1665 do_soft_reset = 1;
1666 tries++;
1667 continue;
1668 } else {
1669 if (flashed) {
1670 tries++;
1671 continue;
1672 }
1673 }
1674
1675 /* Drain the AEN queue */
1676 if (twa_aen_drain_queue(tw_dev, soft_reset)) {
1677 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x22, "AEN drain failed during reset sequence");
1678 do_soft_reset = 1;
1679 tries++;
1680 continue;
1681 }
1682
1683 /* If we got here, controller is in a good state */
1684 retval = 0;
1685 goto out;
1686 }
1687 out:
1688 return retval;
1689 } /* End twa_reset_sequence() */
1690
1691 /* This funciton returns unit geometry in cylinders/heads/sectors */
1692 static int twa_scsi_biosparam(struct scsi_device *sdev, struct block_device *bdev, sector_t capacity, int geom[])
1693 {
1694 int heads, sectors, cylinders;
1695 TW_Device_Extension *tw_dev;
1696
1697 tw_dev = (TW_Device_Extension *)sdev->host->hostdata;
1698
1699 if (capacity >= 0x200000) {
1700 heads = 255;
1701 sectors = 63;
1702 cylinders = sector_div(capacity, heads * sectors);
1703 } else {
1704 heads = 64;
1705 sectors = 32;
1706 cylinders = sector_div(capacity, heads * sectors);
1707 }
1708
1709 geom[0] = heads;
1710 geom[1] = sectors;
1711 geom[2] = cylinders;
1712
1713 return 0;
1714 } /* End twa_scsi_biosparam() */
1715
1716 /* This is the new scsi eh reset function */
1717 static int twa_scsi_eh_reset(struct scsi_cmnd *SCpnt)
1718 {
1719 TW_Device_Extension *tw_dev = NULL;
1720 int retval = FAILED;
1721
1722 tw_dev = (TW_Device_Extension *)SCpnt->device->host->hostdata;
1723
1724 tw_dev->num_resets++;
1725
1726 sdev_printk(KERN_WARNING, SCpnt->device,
1727 "WARNING: (0x%02X:0x%04X): Command (0x%x) timed out, resetting card.\n",
1728 TW_DRIVER, 0x2c, SCpnt->cmnd[0]);
1729
1730 /* Make sure we are not issuing an ioctl or resetting from ioctl */
1731 mutex_lock(&tw_dev->ioctl_lock);
1732
1733 /* Now reset the card and some of the device extension data */
1734 if (twa_reset_device_extension(tw_dev)) {
1735 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x2b, "Controller reset failed during scsi host reset");
1736 goto out;
1737 }
1738
1739 retval = SUCCESS;
1740 out:
1741 mutex_unlock(&tw_dev->ioctl_lock);
1742 return retval;
1743 } /* End twa_scsi_eh_reset() */
1744
1745 /* This is the main scsi queue function to handle scsi opcodes */
1746 static int twa_scsi_queue(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *))
1747 {
1748 int request_id, retval;
1749 TW_Device_Extension *tw_dev = (TW_Device_Extension *)SCpnt->device->host->hostdata;
1750
1751 /* If we are resetting due to timed out ioctl, report as busy */
1752 if (test_bit(TW_IN_RESET, &tw_dev->flags)) {
1753 retval = SCSI_MLQUEUE_HOST_BUSY;
1754 goto out;
1755 }
1756
1757 /* Check if this FW supports luns */
1758 if ((SCpnt->device->lun != 0) && (tw_dev->tw_compat_info.working_srl < TW_FW_SRL_LUNS_SUPPORTED)) {
1759 SCpnt->result = (DID_BAD_TARGET << 16);
1760 done(SCpnt);
1761 retval = 0;
1762 goto out;
1763 }
1764
1765 /* Save done function into scsi_cmnd struct */
1766 SCpnt->scsi_done = done;
1767
1768 /* Get a free request id */
1769 twa_get_request_id(tw_dev, &request_id);
1770
1771 /* Save the scsi command for use by the ISR */
1772 tw_dev->srb[request_id] = SCpnt;
1773
1774 /* Initialize phase to zero */
1775 SCpnt->SCp.phase = TW_PHASE_INITIAL;
1776
1777 retval = twa_scsiop_execute_scsi(tw_dev, request_id, NULL, 0, NULL);
1778 switch (retval) {
1779 case SCSI_MLQUEUE_HOST_BUSY:
1780 twa_free_request_id(tw_dev, request_id);
1781 break;
1782 case 1:
1783 tw_dev->state[request_id] = TW_S_COMPLETED;
1784 twa_free_request_id(tw_dev, request_id);
1785 SCpnt->result = (DID_ERROR << 16);
1786 done(SCpnt);
1787 retval = 0;
1788 }
1789 out:
1790 return retval;
1791 } /* End twa_scsi_queue() */
1792
1793 /* This function hands scsi cdb's to the firmware */
1794 static int twa_scsiop_execute_scsi(TW_Device_Extension *tw_dev, int request_id, char *cdb, int use_sg, TW_SG_Entry *sglistarg)
1795 {
1796 TW_Command_Full *full_command_packet;
1797 TW_Command_Apache *command_packet;
1798 u32 num_sectors = 0x0;
1799 int i, sg_count;
1800 struct scsi_cmnd *srb = NULL;
1801 struct scatterlist *sglist = NULL, *sg;
1802 int retval = 1;
1803
1804 if (tw_dev->srb[request_id]) {
1805 srb = tw_dev->srb[request_id];
1806 if (scsi_sglist(srb))
1807 sglist = scsi_sglist(srb);
1808 }
1809
1810 /* Initialize command packet */
1811 full_command_packet = tw_dev->command_packet_virt[request_id];
1812 full_command_packet->header.header_desc.size_header = 128;
1813 full_command_packet->header.status_block.error = 0;
1814 full_command_packet->header.status_block.severity__reserved = 0;
1815
1816 command_packet = &full_command_packet->command.newcommand;
1817 command_packet->status = 0;
1818 command_packet->opcode__reserved = TW_OPRES_IN(0, TW_OP_EXECUTE_SCSI);
1819
1820 /* We forced 16 byte cdb use earlier */
1821 if (!cdb)
1822 memcpy(command_packet->cdb, srb->cmnd, TW_MAX_CDB_LEN);
1823 else
1824 memcpy(command_packet->cdb, cdb, TW_MAX_CDB_LEN);
1825
1826 if (srb) {
1827 command_packet->unit = srb->device->id;
1828 command_packet->request_id__lunl =
1829 cpu_to_le16(TW_REQ_LUN_IN(srb->device->lun, request_id));
1830 } else {
1831 command_packet->request_id__lunl =
1832 cpu_to_le16(TW_REQ_LUN_IN(0, request_id));
1833 command_packet->unit = 0;
1834 }
1835
1836 command_packet->sgl_offset = 16;
1837
1838 if (!sglistarg) {
1839 /* Map sglist from scsi layer to cmd packet */
1840
1841 if (scsi_sg_count(srb)) {
1842 if ((scsi_sg_count(srb) == 1) &&
1843 (scsi_bufflen(srb) < TW_MIN_SGL_LENGTH)) {
1844 if (srb->sc_data_direction == DMA_TO_DEVICE ||
1845 srb->sc_data_direction == DMA_BIDIRECTIONAL)
1846 scsi_sg_copy_to_buffer(srb,
1847 tw_dev->generic_buffer_virt[request_id],
1848 TW_SECTOR_SIZE);
1849 command_packet->sg_list[0].address = TW_CPU_TO_SGL(tw_dev->generic_buffer_phys[request_id]);
1850 command_packet->sg_list[0].length = cpu_to_le32(TW_MIN_SGL_LENGTH);
1851 } else {
1852 sg_count = twa_map_scsi_sg_data(tw_dev, request_id);
1853 if (sg_count == 0)
1854 goto out;
1855
1856 scsi_for_each_sg(srb, sg, sg_count, i) {
1857 command_packet->sg_list[i].address = TW_CPU_TO_SGL(sg_dma_address(sg));
1858 command_packet->sg_list[i].length = cpu_to_le32(sg_dma_len(sg));
1859 if (command_packet->sg_list[i].address & TW_CPU_TO_SGL(TW_ALIGNMENT_9000_SGL)) {
1860 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x2e, "Found unaligned sgl address during execute scsi");
1861 goto out;
1862 }
1863 }
1864 }
1865 command_packet->sgl_entries__lunh = cpu_to_le16(TW_REQ_LUN_IN((srb->device->lun >> 4), scsi_sg_count(tw_dev->srb[request_id])));
1866 }
1867 } else {
1868 /* Internal cdb post */
1869 for (i = 0; i < use_sg; i++) {
1870 command_packet->sg_list[i].address = TW_CPU_TO_SGL(sglistarg[i].address);
1871 command_packet->sg_list[i].length = cpu_to_le32(sglistarg[i].length);
1872 if (command_packet->sg_list[i].address & TW_CPU_TO_SGL(TW_ALIGNMENT_9000_SGL)) {
1873 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x2f, "Found unaligned sgl address during internal post");
1874 goto out;
1875 }
1876 }
1877 command_packet->sgl_entries__lunh = cpu_to_le16(TW_REQ_LUN_IN(0, use_sg));
1878 }
1879
1880 if (srb) {
1881 if (srb->cmnd[0] == READ_6 || srb->cmnd[0] == WRITE_6)
1882 num_sectors = (u32)srb->cmnd[4];
1883
1884 if (srb->cmnd[0] == READ_10 || srb->cmnd[0] == WRITE_10)
1885 num_sectors = (u32)srb->cmnd[8] | ((u32)srb->cmnd[7] << 8);
1886 }
1887
1888 /* Update sector statistic */
1889 tw_dev->sector_count = num_sectors;
1890 if (tw_dev->sector_count > tw_dev->max_sector_count)
1891 tw_dev->max_sector_count = tw_dev->sector_count;
1892
1893 /* Update SG statistics */
1894 if (srb) {
1895 tw_dev->sgl_entries = scsi_sg_count(tw_dev->srb[request_id]);
1896 if (tw_dev->sgl_entries > tw_dev->max_sgl_entries)
1897 tw_dev->max_sgl_entries = tw_dev->sgl_entries;
1898 }
1899
1900 /* Now post the command to the board */
1901 if (srb) {
1902 retval = twa_post_command_packet(tw_dev, request_id, 0);
1903 } else {
1904 twa_post_command_packet(tw_dev, request_id, 1);
1905 retval = 0;
1906 }
1907 out:
1908 return retval;
1909 } /* End twa_scsiop_execute_scsi() */
1910
1911 /* This function completes an execute scsi operation */
1912 static void twa_scsiop_execute_scsi_complete(TW_Device_Extension *tw_dev, int request_id)
1913 {
1914 struct scsi_cmnd *cmd = tw_dev->srb[request_id];
1915
1916 if (scsi_bufflen(cmd) < TW_MIN_SGL_LENGTH &&
1917 (cmd->sc_data_direction == DMA_FROM_DEVICE ||
1918 cmd->sc_data_direction == DMA_BIDIRECTIONAL)) {
1919 if (scsi_sg_count(cmd) == 1) {
1920 unsigned long flags;
1921 void *buf = tw_dev->generic_buffer_virt[request_id];
1922
1923 local_irq_save(flags);
1924 scsi_sg_copy_from_buffer(cmd, buf, TW_SECTOR_SIZE);
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 /* Save values to device extension */
2032 tw_dev->host = host;
2033 tw_dev->tw_pci_dev = pdev;
2034
2035 if (twa_initialize_device_extension(tw_dev)) {
2036 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x25, "Failed to initialize device extension");
2037 goto out_free_device_extension;
2038 }
2039
2040 /* Request IO regions */
2041 retval = pci_request_regions(pdev, "3w-9xxx");
2042 if (retval) {
2043 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x26, "Failed to get mem region");
2044 goto out_free_device_extension;
2045 }
2046
2047 if (pdev->device == PCI_DEVICE_ID_3WARE_9000)
2048 mem_addr = pci_resource_start(pdev, 1);
2049 else
2050 mem_addr = pci_resource_start(pdev, 2);
2051
2052 /* Save base address */
2053 tw_dev->base_addr = ioremap(mem_addr, PAGE_SIZE);
2054 if (!tw_dev->base_addr) {
2055 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x35, "Failed to ioremap");
2056 goto out_release_mem_region;
2057 }
2058
2059 /* Disable interrupts on the card */
2060 TW_DISABLE_INTERRUPTS(tw_dev);
2061
2062 /* Initialize the card */
2063 if (twa_reset_sequence(tw_dev, 0))
2064 goto out_iounmap;
2065
2066 /* Set host specific parameters */
2067 if ((pdev->device == PCI_DEVICE_ID_3WARE_9650SE) ||
2068 (pdev->device == PCI_DEVICE_ID_3WARE_9690SA))
2069 host->max_id = TW_MAX_UNITS_9650SE;
2070 else
2071 host->max_id = TW_MAX_UNITS;
2072
2073 host->max_cmd_len = TW_MAX_CDB_LEN;
2074
2075 /* Channels aren't supported by adapter */
2076 host->max_lun = TW_MAX_LUNS(tw_dev->tw_compat_info.working_srl);
2077 host->max_channel = 0;
2078
2079 /* Register the card with the kernel SCSI layer */
2080 retval = scsi_add_host(host, &pdev->dev);
2081 if (retval) {
2082 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x27, "scsi add host failed");
2083 goto out_iounmap;
2084 }
2085
2086 pci_set_drvdata(pdev, host);
2087
2088 printk(KERN_WARNING "3w-9xxx: scsi%d: Found a 3ware 9000 Storage Controller at 0x%x, IRQ: %d.\n",
2089 host->host_no, mem_addr, pdev->irq);
2090 printk(KERN_WARNING "3w-9xxx: scsi%d: Firmware %s, BIOS %s, Ports: %d.\n",
2091 host->host_no,
2092 (char *)twa_get_param(tw_dev, 0, TW_VERSION_TABLE,
2093 TW_PARAM_FWVER, TW_PARAM_FWVER_LENGTH),
2094 (char *)twa_get_param(tw_dev, 1, TW_VERSION_TABLE,
2095 TW_PARAM_BIOSVER, TW_PARAM_BIOSVER_LENGTH),
2096 le32_to_cpu(*(int *)twa_get_param(tw_dev, 2, TW_INFORMATION_TABLE,
2097 TW_PARAM_PORTCOUNT, TW_PARAM_PORTCOUNT_LENGTH)));
2098
2099 /* Now setup the interrupt handler */
2100 retval = request_irq(pdev->irq, twa_interrupt, IRQF_SHARED, "3w-9xxx", tw_dev);
2101 if (retval) {
2102 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x30, "Error requesting IRQ");
2103 goto out_remove_host;
2104 }
2105
2106 twa_device_extension_list[twa_device_extension_count] = tw_dev;
2107 twa_device_extension_count++;
2108
2109 /* Re-enable interrupts on the card */
2110 TW_ENABLE_AND_CLEAR_INTERRUPTS(tw_dev);
2111
2112 /* Finally, scan the host */
2113 scsi_scan_host(host);
2114
2115 if (twa_major == -1) {
2116 if ((twa_major = register_chrdev (0, "twa", &twa_fops)) < 0)
2117 TW_PRINTK(host, TW_DRIVER, 0x29, "Failed to register character device");
2118 }
2119 return 0;
2120
2121 out_remove_host:
2122 scsi_remove_host(host);
2123 out_iounmap:
2124 iounmap(tw_dev->base_addr);
2125 out_release_mem_region:
2126 pci_release_regions(pdev);
2127 out_free_device_extension:
2128 twa_free_device_extension(tw_dev);
2129 scsi_host_put(host);
2130 out_disable_device:
2131 pci_disable_device(pdev);
2132
2133 return retval;
2134 } /* End twa_probe() */
2135
2136 /* This function is called to remove a device */
2137 static void twa_remove(struct pci_dev *pdev)
2138 {
2139 struct Scsi_Host *host = pci_get_drvdata(pdev);
2140 TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
2141
2142 scsi_remove_host(tw_dev->host);
2143
2144 /* Unregister character device */
2145 if (twa_major >= 0) {
2146 unregister_chrdev(twa_major, "twa");
2147 twa_major = -1;
2148 }
2149
2150 /* Shutdown the card */
2151 __twa_shutdown(tw_dev);
2152
2153 /* Free IO remapping */
2154 iounmap(tw_dev->base_addr);
2155
2156 /* Free up the mem region */
2157 pci_release_regions(pdev);
2158
2159 /* Free up device extension resources */
2160 twa_free_device_extension(tw_dev);
2161
2162 scsi_host_put(tw_dev->host);
2163 pci_disable_device(pdev);
2164 twa_device_extension_count--;
2165 } /* End twa_remove() */
2166
2167 /* PCI Devices supported by this driver */
2168 static struct pci_device_id twa_pci_tbl[] __devinitdata = {
2169 { PCI_VENDOR_ID_3WARE, PCI_DEVICE_ID_3WARE_9000,
2170 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
2171 { PCI_VENDOR_ID_3WARE, PCI_DEVICE_ID_3WARE_9550SX,
2172 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
2173 { PCI_VENDOR_ID_3WARE, PCI_DEVICE_ID_3WARE_9650SE,
2174 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
2175 { PCI_VENDOR_ID_3WARE, PCI_DEVICE_ID_3WARE_9690SA,
2176 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
2177 { }
2178 };
2179 MODULE_DEVICE_TABLE(pci, twa_pci_tbl);
2180
2181 /* pci_driver initializer */
2182 static struct pci_driver twa_driver = {
2183 .name = "3w-9xxx",
2184 .id_table = twa_pci_tbl,
2185 .probe = twa_probe,
2186 .remove = twa_remove,
2187 .shutdown = twa_shutdown
2188 };
2189
2190 /* This function is called on driver initialization */
2191 static int __init twa_init(void)
2192 {
2193 printk(KERN_WARNING "3ware 9000 Storage Controller device driver for Linux v%s.\n", TW_DRIVER_VERSION);
2194
2195 return pci_register_driver(&twa_driver);
2196 } /* End twa_init() */
2197
2198 /* This function is called on driver exit */
2199 static void __exit twa_exit(void)
2200 {
2201 pci_unregister_driver(&twa_driver);
2202 } /* End twa_exit() */
2203
2204 module_init(twa_init);
2205 module_exit(twa_exit);
2206
Stable & featurefull patchset based on Linus's git branch