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