?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
manual update from upstream:
[linux-2.6/libata-dev.git] / drivers / scsi / 3w-9xxx.c
bloba748fbfb66927dc9c54903abcec1d7a585a5b240
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 <asm/io.h>
77 #include <asm/irq.h>
78 #include <asm/uaccess.h>
79 #include <scsi/scsi.h>
80 #include <scsi/scsi_host.h>
81 #include <scsi/scsi_tcq.h>
82 #include <scsi/scsi_cmnd.h>
83 #include "3w-9xxx.h"
84
85 /* Globals */
86 #define TW_DRIVER_VERSION "2.26.02.004"
87 static TW_Device_Extension *twa_device_extension_list[TW_MAX_SLOT];
88 static unsigned int twa_device_extension_count;
89 static int twa_major = -1;
90 extern struct timezone sys_tz;
91
92 /* Module parameters */
93 MODULE_AUTHOR ("AMCC");
94 MODULE_DESCRIPTION ("3ware 9000 Storage Controller Linux Driver");
95 MODULE_LICENSE("GPL");
96 MODULE_VERSION(TW_DRIVER_VERSION);
97
98 /* Function prototypes */
99 static void twa_aen_queue_event(TW_Device_Extension *tw_dev, TW_Command_Apache_Header *header);
100 static int twa_aen_read_queue(TW_Device_Extension *tw_dev, int request_id);
101 static char *twa_aen_severity_lookup(unsigned char severity_code);
102 static void twa_aen_sync_time(TW_Device_Extension *tw_dev, int request_id);
103 static int twa_chrdev_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg);
104 static int twa_chrdev_open(struct inode *inode, struct file *file);
105 static int twa_fill_sense(TW_Device_Extension *tw_dev, int request_id, int copy_sense, int print_host);
106 static void twa_free_request_id(TW_Device_Extension *tw_dev,int request_id);
107 static void twa_get_request_id(TW_Device_Extension *tw_dev, int *request_id);
108 static int twa_initconnection(TW_Device_Extension *tw_dev, int message_credits,
109 u32 set_features, unsigned short current_fw_srl,
110 unsigned short current_fw_arch_id,
111 unsigned short current_fw_branch,
112 unsigned short current_fw_build,
113 unsigned short *fw_on_ctlr_srl,
114 unsigned short *fw_on_ctlr_arch_id,
115 unsigned short *fw_on_ctlr_branch,
116 unsigned short *fw_on_ctlr_build,
117 u32 *init_connect_result);
118 static void twa_load_sgl(TW_Command_Full *full_command_packet, int request_id, dma_addr_t dma_handle, int length);
119 static int twa_poll_response(TW_Device_Extension *tw_dev, int request_id, int seconds);
120 static int twa_poll_status_gone(TW_Device_Extension *tw_dev, u32 flag, int seconds);
121 static int twa_post_command_packet(TW_Device_Extension *tw_dev, int request_id, char internal);
122 static int twa_reset_device_extension(TW_Device_Extension *tw_dev, int ioctl_reset);
123 static int twa_reset_sequence(TW_Device_Extension *tw_dev, int soft_reset);
124 static int twa_scsiop_execute_scsi(TW_Device_Extension *tw_dev, int request_id, char *cdb, int use_sg, TW_SG_Entry *sglistarg);
125 static void twa_scsiop_execute_scsi_complete(TW_Device_Extension *tw_dev, int request_id);
126 static char *twa_string_lookup(twa_message_type *table, unsigned int aen_code);
127 static void twa_unmap_scsi_data(TW_Device_Extension *tw_dev, int request_id);
128
129 /* Functions */
130
131 /* Show some statistics about the card */
132 static ssize_t twa_show_stats(struct class_device *class_dev, char *buf)
133 {
134 struct Scsi_Host *host = class_to_shost(class_dev);
135 TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
136 unsigned long flags = 0;
137 ssize_t len;
138
139 spin_lock_irqsave(tw_dev->host->host_lock, flags);
140 len = snprintf(buf, PAGE_SIZE, "3w-9xxx Driver version: %s\n"
141 "Current commands posted: %4d\n"
142 "Max commands posted: %4d\n"
143 "Current pending commands: %4d\n"
144 "Max pending commands: %4d\n"
145 "Last sgl length: %4d\n"
146 "Max sgl length: %4d\n"
147 "Last sector count: %4d\n"
148 "Max sector count: %4d\n"
149 "SCSI Host Resets: %4d\n"
150 "AEN's: %4d\n",
151 TW_DRIVER_VERSION,
152 tw_dev->posted_request_count,
153 tw_dev->max_posted_request_count,
154 tw_dev->pending_request_count,
155 tw_dev->max_pending_request_count,
156 tw_dev->sgl_entries,
157 tw_dev->max_sgl_entries,
158 tw_dev->sector_count,
159 tw_dev->max_sector_count,
160 tw_dev->num_resets,
161 tw_dev->aen_count);
162 spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
163 return len;
164 } /* End twa_show_stats() */
165
166 /* This function will set a devices queue depth */
167 static int twa_change_queue_depth(struct scsi_device *sdev, int queue_depth)
168 {
169 if (queue_depth > TW_Q_LENGTH-2)
170 queue_depth = TW_Q_LENGTH-2;
171 scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG, queue_depth);
172 return queue_depth;
173 } /* End twa_change_queue_depth() */
174
175 /* Create sysfs 'stats' entry */
176 static struct class_device_attribute twa_host_stats_attr = {
177 .attr = {
178 .name = "stats",
179 .mode = S_IRUGO,
180 },
181 .show = twa_show_stats
182 };
183
184 /* Host attributes initializer */
185 static struct class_device_attribute *twa_host_attrs[] = {
186 &twa_host_stats_attr,
187 NULL,
188 };
189
190 /* File operations struct for character device */
191 static struct file_operations twa_fops = {
192 .owner = THIS_MODULE,
193 .ioctl = twa_chrdev_ioctl,
194 .open = twa_chrdev_open,
195 .release = NULL
196 };
197
198 /* This function will complete an aen request from the isr */
199 static int twa_aen_complete(TW_Device_Extension *tw_dev, int request_id)
200 {
201 TW_Command_Full *full_command_packet;
202 TW_Command *command_packet;
203 TW_Command_Apache_Header *header;
204 unsigned short aen;
205 int retval = 1;
206
207 header = (TW_Command_Apache_Header *)tw_dev->generic_buffer_virt[request_id];
208 tw_dev->posted_request_count--;
209 aen = header->status_block.error;
210 full_command_packet = tw_dev->command_packet_virt[request_id];
211 command_packet = &full_command_packet->command.oldcommand;
212
213 /* First check for internal completion of set param for time sync */
214 if (TW_OP_OUT(command_packet->opcode__sgloffset) == TW_OP_SET_PARAM) {
215 /* Keep reading the queue in case there are more aen's */
216 if (twa_aen_read_queue(tw_dev, request_id))
217 goto out2;
218 else {
219 retval = 0;
220 goto out;
221 }
222 }
223
224 switch (aen) {
225 case TW_AEN_QUEUE_EMPTY:
226 /* Quit reading the queue if this is the last one */
227 break;
228 case TW_AEN_SYNC_TIME_WITH_HOST:
229 twa_aen_sync_time(tw_dev, request_id);
230 retval = 0;
231 goto out;
232 default:
233 twa_aen_queue_event(tw_dev, header);
234
235 /* If there are more aen's, keep reading the queue */
236 if (twa_aen_read_queue(tw_dev, request_id))
237 goto out2;
238 else {
239 retval = 0;
240 goto out;
241 }
242 }
243 retval = 0;
244 out2:
245 tw_dev->state[request_id] = TW_S_COMPLETED;
246 twa_free_request_id(tw_dev, request_id);
247 clear_bit(TW_IN_ATTENTION_LOOP, &tw_dev->flags);
248 out:
249 return retval;
250 } /* End twa_aen_complete() */
251
252 /* This function will drain aen queue */
253 static int twa_aen_drain_queue(TW_Device_Extension *tw_dev, int no_check_reset)
254 {
255 int request_id = 0;
256 char cdb[TW_MAX_CDB_LEN];
257 TW_SG_Entry sglist[1];
258 int finished = 0, count = 0;
259 TW_Command_Full *full_command_packet;
260 TW_Command_Apache_Header *header;
261 unsigned short aen;
262 int first_reset = 0, queue = 0, retval = 1;
263
264 if (no_check_reset)
265 first_reset = 0;
266 else
267 first_reset = 1;
268
269 full_command_packet = tw_dev->command_packet_virt[request_id];
270 memset(full_command_packet, 0, sizeof(TW_Command_Full));
271
272 /* Initialize cdb */
273 memset(&cdb, 0, TW_MAX_CDB_LEN);
274 cdb[0] = REQUEST_SENSE; /* opcode */
275 cdb[4] = TW_ALLOCATION_LENGTH; /* allocation length */
276
277 /* Initialize sglist */
278 memset(&sglist, 0, sizeof(TW_SG_Entry));
279 sglist[0].length = TW_SECTOR_SIZE;
280 sglist[0].address = tw_dev->generic_buffer_phys[request_id];
281
282 if (sglist[0].address & TW_ALIGNMENT_9000_SGL) {
283 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1, "Found unaligned address during AEN drain");
284 goto out;
285 }
286
287 /* Mark internal command */
288 tw_dev->srb[request_id] = NULL;
289
290 do {
291 /* Send command to the board */
292 if (twa_scsiop_execute_scsi(tw_dev, request_id, cdb, 1, sglist)) {
293 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x2, "Error posting request sense");
294 goto out;
295 }
296
297 /* Now poll for completion */
298 if (twa_poll_response(tw_dev, request_id, 30)) {
299 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x3, "No valid response while draining AEN queue");
300 tw_dev->posted_request_count--;
301 goto out;
302 }
303
304 tw_dev->posted_request_count--;
305 header = (TW_Command_Apache_Header *)tw_dev->generic_buffer_virt[request_id];
306 aen = header->status_block.error;
307 queue = 0;
308 count++;
309
310 switch (aen) {
311 case TW_AEN_QUEUE_EMPTY:
312 if (first_reset != 1)
313 goto out;
314 else
315 finished = 1;
316 break;
317 case TW_AEN_SOFT_RESET:
318 if (first_reset == 0)
319 first_reset = 1;
320 else
321 queue = 1;
322 break;
323 case TW_AEN_SYNC_TIME_WITH_HOST:
324 break;
325 default:
326 queue = 1;
327 }
328
329 /* Now queue an event info */
330 if (queue)
331 twa_aen_queue_event(tw_dev, header);
332 } while ((finished == 0) && (count < TW_MAX_AEN_DRAIN));
333
334 if (count == TW_MAX_AEN_DRAIN)
335 goto out;
336
337 retval = 0;
338 out:
339 tw_dev->state[request_id] = TW_S_INITIAL;
340 return retval;
341 } /* End twa_aen_drain_queue() */
342
343 /* This function will queue an event */
344 static void twa_aen_queue_event(TW_Device_Extension *tw_dev, TW_Command_Apache_Header *header)
345 {
346 u32 local_time;
347 struct timeval time;
348 TW_Event *event;
349 unsigned short aen;
350 char host[16];
351 char *error_str;
352
353 tw_dev->aen_count++;
354
355 /* Fill out event info */
356 event = tw_dev->event_queue[tw_dev->error_index];
357
358 /* Check for clobber */
359 host[0] = '\0';
360 if (tw_dev->host) {
361 sprintf(host, " scsi%d:", tw_dev->host->host_no);
362 if (event->retrieved == TW_AEN_NOT_RETRIEVED)
363 tw_dev->aen_clobber = 1;
364 }
365
366 aen = header->status_block.error;
367 memset(event, 0, sizeof(TW_Event));
368
369 event->severity = TW_SEV_OUT(header->status_block.severity__reserved);
370 do_gettimeofday(&time);
371 local_time = (u32)(time.tv_sec - (sys_tz.tz_minuteswest * 60));
372 event->time_stamp_sec = local_time;
373 event->aen_code = aen;
374 event->retrieved = TW_AEN_NOT_RETRIEVED;
375 event->sequence_id = tw_dev->error_sequence_id;
376 tw_dev->error_sequence_id++;
377
378 /* Check for embedded error string */
379 error_str = &(header->err_specific_desc[strlen(header->err_specific_desc)+1]);
380
381 header->err_specific_desc[sizeof(header->err_specific_desc) - 1] = '\0';
382 event->parameter_len = strlen(header->err_specific_desc);
383 memcpy(event->parameter_data, header->err_specific_desc, event->parameter_len);
384 if (event->severity != TW_AEN_SEVERITY_DEBUG)
385 printk(KERN_WARNING "3w-9xxx:%s AEN: %s (0x%02X:0x%04X): %s:%s.\n",
386 host,
387 twa_aen_severity_lookup(TW_SEV_OUT(header->status_block.severity__reserved)),
388 TW_MESSAGE_SOURCE_CONTROLLER_EVENT, aen,
389 error_str[0] == '\0' ? twa_string_lookup(twa_aen_table, aen) : error_str,
390 header->err_specific_desc);
391 else
392 tw_dev->aen_count--;
393
394 if ((tw_dev->error_index + 1) == TW_Q_LENGTH)
395 tw_dev->event_queue_wrapped = 1;
396 tw_dev->error_index = (tw_dev->error_index + 1 ) % TW_Q_LENGTH;
397 } /* End twa_aen_queue_event() */
398
399 /* This function will read the aen queue from the isr */
400 static int twa_aen_read_queue(TW_Device_Extension *tw_dev, int request_id)
401 {
402 char cdb[TW_MAX_CDB_LEN];
403 TW_SG_Entry sglist[1];
404 TW_Command_Full *full_command_packet;
405 int retval = 1;
406
407 full_command_packet = tw_dev->command_packet_virt[request_id];
408 memset(full_command_packet, 0, sizeof(TW_Command_Full));
409
410 /* Initialize cdb */
411 memset(&cdb, 0, TW_MAX_CDB_LEN);
412 cdb[0] = REQUEST_SENSE; /* opcode */
413 cdb[4] = TW_ALLOCATION_LENGTH; /* allocation length */
414
415 /* Initialize sglist */
416 memset(&sglist, 0, sizeof(TW_SG_Entry));
417 sglist[0].length = TW_SECTOR_SIZE;
418 sglist[0].address = tw_dev->generic_buffer_phys[request_id];
419
420 /* Mark internal command */
421 tw_dev->srb[request_id] = NULL;
422
423 /* Now post the command packet */
424 if (twa_scsiop_execute_scsi(tw_dev, request_id, cdb, 1, sglist)) {
425 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x4, "Post failed while reading AEN queue");
426 goto out;
427 }
428 retval = 0;
429 out:
430 return retval;
431 } /* End twa_aen_read_queue() */
432
433 /* This function will look up an AEN severity string */
434 static char *twa_aen_severity_lookup(unsigned char severity_code)
435 {
436 char *retval = NULL;
437
438 if ((severity_code < (unsigned char) TW_AEN_SEVERITY_ERROR) ||
439 (severity_code > (unsigned char) TW_AEN_SEVERITY_DEBUG))
440 goto out;
441
442 retval = twa_aen_severity_table[severity_code];
443 out:
444 return retval;
445 } /* End twa_aen_severity_lookup() */
446
447 /* This function will sync firmware time with the host time */
448 static void twa_aen_sync_time(TW_Device_Extension *tw_dev, int request_id)
449 {
450 u32 schedulertime;
451 struct timeval utc;
452 TW_Command_Full *full_command_packet;
453 TW_Command *command_packet;
454 TW_Param_Apache *param;
455 u32 local_time;
456
457 /* Fill out the command packet */
458 full_command_packet = tw_dev->command_packet_virt[request_id];
459 memset(full_command_packet, 0, sizeof(TW_Command_Full));
460 command_packet = &full_command_packet->command.oldcommand;
461 command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_SET_PARAM);
462 command_packet->request_id = request_id;
463 command_packet->byte8_offset.param.sgl[0].address = tw_dev->generic_buffer_phys[request_id];
464 command_packet->byte8_offset.param.sgl[0].length = TW_SECTOR_SIZE;
465 command_packet->size = TW_COMMAND_SIZE;
466 command_packet->byte6_offset.parameter_count = 1;
467
468 /* Setup the param */
469 param = (TW_Param_Apache *)tw_dev->generic_buffer_virt[request_id];
470 memset(param, 0, TW_SECTOR_SIZE);
471 param->table_id = TW_TIMEKEEP_TABLE | 0x8000; /* Controller time keep table */
472 param->parameter_id = 0x3; /* SchedulerTime */
473 param->parameter_size_bytes = 4;
474
475 /* Convert system time in UTC to local time seconds since last
476 Sunday 12:00AM */
477 do_gettimeofday(&utc);
478 local_time = (u32)(utc.tv_sec - (sys_tz.tz_minuteswest * 60));
479 schedulertime = local_time - (3 * 86400);
480 schedulertime = schedulertime % 604800;
481
482 memcpy(param->data, &schedulertime, sizeof(u32));
483
484 /* Mark internal command */
485 tw_dev->srb[request_id] = NULL;
486
487 /* Now post the command */
488 twa_post_command_packet(tw_dev, request_id, 1);
489 } /* End twa_aen_sync_time() */
490
491 /* This function will allocate memory and check if it is correctly aligned */
492 static int twa_allocate_memory(TW_Device_Extension *tw_dev, int size, int which)
493 {
494 int i;
495 dma_addr_t dma_handle;
496 unsigned long *cpu_addr;
497 int retval = 1;
498
499 cpu_addr = pci_alloc_consistent(tw_dev->tw_pci_dev, size*TW_Q_LENGTH, &dma_handle);
500 if (!cpu_addr) {
501 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x5, "Memory allocation failed");
502 goto out;
503 }
504
505 if ((unsigned long)cpu_addr % (TW_ALIGNMENT_9000)) {
506 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x6, "Failed to allocate correctly aligned memory");
507 pci_free_consistent(tw_dev->tw_pci_dev, size*TW_Q_LENGTH, cpu_addr, dma_handle);
508 goto out;
509 }
510
511 memset(cpu_addr, 0, size*TW_Q_LENGTH);
512
513 for (i = 0; i < TW_Q_LENGTH; i++) {
514 switch(which) {
515 case 0:
516 tw_dev->command_packet_phys[i] = dma_handle+(i*size);
517 tw_dev->command_packet_virt[i] = (TW_Command_Full *)((unsigned char *)cpu_addr + (i*size));
518 break;
519 case 1:
520 tw_dev->generic_buffer_phys[i] = dma_handle+(i*size);
521 tw_dev->generic_buffer_virt[i] = (unsigned long *)((unsigned char *)cpu_addr + (i*size));
522 break;
523 }
524 }
525 retval = 0;
526 out:
527 return retval;
528 } /* End twa_allocate_memory() */
529
530 /* This function will check the status register for unexpected bits */
531 static int twa_check_bits(u32 status_reg_value)
532 {
533 int retval = 1;
534
535 if ((status_reg_value & TW_STATUS_EXPECTED_BITS) != TW_STATUS_EXPECTED_BITS)
536 goto out;
537 if ((status_reg_value & TW_STATUS_UNEXPECTED_BITS) != 0)
538 goto out;
539
540 retval = 0;
541 out:
542 return retval;
543 } /* End twa_check_bits() */
544
545 /* This function will check the srl and decide if we are compatible */
546 static int twa_check_srl(TW_Device_Extension *tw_dev, int *flashed)
547 {
548 int retval = 1;
549 unsigned short fw_on_ctlr_srl = 0, fw_on_ctlr_arch_id = 0;
550 unsigned short fw_on_ctlr_branch = 0, fw_on_ctlr_build = 0;
551 u32 init_connect_result = 0;
552
553 if (twa_initconnection(tw_dev, TW_INIT_MESSAGE_CREDITS,
554 TW_EXTENDED_INIT_CONNECT, TW_CURRENT_DRIVER_SRL,
555 TW_9000_ARCH_ID, TW_CURRENT_DRIVER_BRANCH,
556 TW_CURRENT_DRIVER_BUILD, &fw_on_ctlr_srl,
557 &fw_on_ctlr_arch_id, &fw_on_ctlr_branch,
558 &fw_on_ctlr_build, &init_connect_result)) {
559 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x7, "Initconnection failed while checking SRL");
560 goto out;
561 }
562
563 tw_dev->working_srl = fw_on_ctlr_srl;
564 tw_dev->working_branch = fw_on_ctlr_branch;
565 tw_dev->working_build = fw_on_ctlr_build;
566
567 /* Try base mode compatibility */
568 if (!(init_connect_result & TW_CTLR_FW_COMPATIBLE)) {
569 if (twa_initconnection(tw_dev, TW_INIT_MESSAGE_CREDITS,
570 TW_EXTENDED_INIT_CONNECT,
571 TW_BASE_FW_SRL, TW_9000_ARCH_ID,
572 TW_BASE_FW_BRANCH, TW_BASE_FW_BUILD,
573 &fw_on_ctlr_srl, &fw_on_ctlr_arch_id,
574 &fw_on_ctlr_branch, &fw_on_ctlr_build,
575 &init_connect_result)) {
576 TW_PRINTK(tw_dev->host, TW_DRIVER, 0xa, "Initconnection (base mode) failed while checking SRL");
577 goto out;
578 }
579 if (!(init_connect_result & TW_CTLR_FW_COMPATIBLE)) {
580 if (TW_CURRENT_DRIVER_SRL > fw_on_ctlr_srl) {
581 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x32, "Firmware and driver incompatibility: please upgrade firmware");
582 } else {
583 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x33, "Firmware and driver incompatibility: please upgrade driver");
584 }
585 goto out;
586 }
587 tw_dev->working_srl = TW_BASE_FW_SRL;
588 tw_dev->working_branch = TW_BASE_FW_BRANCH;
589 tw_dev->working_build = TW_BASE_FW_BUILD;
590 }
591 retval = 0;
592 out:
593 return retval;
594 } /* End twa_check_srl() */
595
596 /* This function handles ioctl for the character device */
597 static int twa_chrdev_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
598 {
599 long timeout;
600 unsigned long *cpu_addr, data_buffer_length_adjusted = 0, flags = 0;
601 dma_addr_t dma_handle;
602 int request_id = 0;
603 unsigned int sequence_id = 0;
604 unsigned char event_index, start_index;
605 TW_Ioctl_Driver_Command driver_command;
606 TW_Ioctl_Buf_Apache *tw_ioctl;
607 TW_Lock *tw_lock;
608 TW_Command_Full *full_command_packet;
609 TW_Compatibility_Info *tw_compat_info;
610 TW_Event *event;
611 struct timeval current_time;
612 u32 current_time_ms;
613 TW_Device_Extension *tw_dev = twa_device_extension_list[iminor(inode)];
614 int retval = TW_IOCTL_ERROR_OS_EFAULT;
615 void __user *argp = (void __user *)arg;
616
617 /* Only let one of these through at a time */
618 if (down_interruptible(&tw_dev->ioctl_sem)) {
619 retval = TW_IOCTL_ERROR_OS_EINTR;
620 goto out;
621 }
622
623 /* First copy down the driver command */
624 if (copy_from_user(&driver_command, argp, sizeof(TW_Ioctl_Driver_Command)))
625 goto out2;
626
627 /* Check data buffer size */
628 if (driver_command.buffer_length > TW_MAX_SECTORS * 512) {
629 retval = TW_IOCTL_ERROR_OS_EINVAL;
630 goto out2;
631 }
632
633 /* Hardware can only do multiple of 512 byte transfers */
634 data_buffer_length_adjusted = (driver_command.buffer_length + 511) & ~511;
635
636 /* Now allocate ioctl buf memory */
637 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);
638 if (!cpu_addr) {
639 retval = TW_IOCTL_ERROR_OS_ENOMEM;
640 goto out2;
641 }
642
643 tw_ioctl = (TW_Ioctl_Buf_Apache *)cpu_addr;
644
645 /* Now copy down the entire ioctl */
646 if (copy_from_user(tw_ioctl, argp, driver_command.buffer_length + sizeof(TW_Ioctl_Buf_Apache) - 1))
647 goto out3;
648
649 /* See which ioctl we are doing */
650 switch (cmd) {
651 case TW_IOCTL_FIRMWARE_PASS_THROUGH:
652 spin_lock_irqsave(tw_dev->host->host_lock, flags);
653 twa_get_request_id(tw_dev, &request_id);
654
655 /* Flag internal command */
656 tw_dev->srb[request_id] = NULL;
657
658 /* Flag chrdev ioctl */
659 tw_dev->chrdev_request_id = request_id;
660
661 full_command_packet = &tw_ioctl->firmware_command;
662
663 /* Load request id and sglist for both command types */
664 twa_load_sgl(full_command_packet, request_id, dma_handle, data_buffer_length_adjusted);
665
666 memcpy(tw_dev->command_packet_virt[request_id], &(tw_ioctl->firmware_command), sizeof(TW_Command_Full));
667
668 /* Now post the command packet to the controller */
669 twa_post_command_packet(tw_dev, request_id, 1);
670 spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
671
672 timeout = TW_IOCTL_CHRDEV_TIMEOUT*HZ;
673
674 /* Now wait for command to complete */
675 timeout = wait_event_timeout(tw_dev->ioctl_wqueue, tw_dev->chrdev_request_id == TW_IOCTL_CHRDEV_FREE, timeout);
676
677 /* See if we reset while waiting for the ioctl to complete */
678 if (test_bit(TW_IN_RESET, &tw_dev->flags)) {
679 clear_bit(TW_IN_RESET, &tw_dev->flags);
680 retval = TW_IOCTL_ERROR_OS_ERESTARTSYS;
681 goto out3;
682 }
683
684 /* We timed out, and didn't get an interrupt */
685 if (tw_dev->chrdev_request_id != TW_IOCTL_CHRDEV_FREE) {
686 /* Now we need to reset the board */
687 printk(KERN_WARNING "3w-9xxx: scsi%d: WARNING: (0x%02X:0x%04X): Character ioctl (0x%x) timed out, resetting card.\n",
688 tw_dev->host->host_no, TW_DRIVER, 0xc,
689 cmd);
690 retval = TW_IOCTL_ERROR_OS_EIO;
691 spin_lock_irqsave(tw_dev->host->host_lock, flags);
692 tw_dev->state[request_id] = TW_S_COMPLETED;
693 twa_free_request_id(tw_dev, request_id);
694 tw_dev->posted_request_count--;
695 spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
696 twa_reset_device_extension(tw_dev, 1);
697 goto out3;
698 }
699
700 /* Now copy in the command packet response */
701 memcpy(&(tw_ioctl->firmware_command), tw_dev->command_packet_virt[request_id], sizeof(TW_Command_Full));
702
703 /* Now complete the io */
704 spin_lock_irqsave(tw_dev->host->host_lock, flags);
705 tw_dev->posted_request_count--;
706 tw_dev->state[request_id] = TW_S_COMPLETED;
707 twa_free_request_id(tw_dev, request_id);
708 spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
709 break;
710 case TW_IOCTL_GET_COMPATIBILITY_INFO:
711 tw_ioctl->driver_command.status = 0;
712 /* Copy compatiblity struct into ioctl data buffer */
713 tw_compat_info = (TW_Compatibility_Info *)tw_ioctl->data_buffer;
714 strncpy(tw_compat_info->driver_version, TW_DRIVER_VERSION, strlen(TW_DRIVER_VERSION));
715 tw_compat_info->working_srl = tw_dev->working_srl;
716 tw_compat_info->working_branch = tw_dev->working_branch;
717 tw_compat_info->working_build = tw_dev->working_build;
718 tw_compat_info->driver_srl_high = TW_CURRENT_DRIVER_SRL;
719 tw_compat_info->driver_branch_high = TW_CURRENT_DRIVER_BRANCH;
720 tw_compat_info->driver_build_high = TW_CURRENT_DRIVER_BUILD;
721 tw_compat_info->driver_srl_low = TW_BASE_FW_SRL;
722 tw_compat_info->driver_branch_low = TW_BASE_FW_BRANCH;
723 tw_compat_info->driver_build_low = TW_BASE_FW_BUILD;
724 break;
725 case TW_IOCTL_GET_LAST_EVENT:
726 if (tw_dev->event_queue_wrapped) {
727 if (tw_dev->aen_clobber) {
728 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_AEN_CLOBBER;
729 tw_dev->aen_clobber = 0;
730 } else
731 tw_ioctl->driver_command.status = 0;
732 } else {
733 if (!tw_dev->error_index) {
734 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS;
735 break;
736 }
737 tw_ioctl->driver_command.status = 0;
738 }
739 event_index = (tw_dev->error_index - 1 + TW_Q_LENGTH) % TW_Q_LENGTH;
740 memcpy(tw_ioctl->data_buffer, tw_dev->event_queue[event_index], sizeof(TW_Event));
741 tw_dev->event_queue[event_index]->retrieved = TW_AEN_RETRIEVED;
742 break;
743 case TW_IOCTL_GET_FIRST_EVENT:
744 if (tw_dev->event_queue_wrapped) {
745 if (tw_dev->aen_clobber) {
746 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_AEN_CLOBBER;
747 tw_dev->aen_clobber = 0;
748 } else
749 tw_ioctl->driver_command.status = 0;
750 event_index = tw_dev->error_index;
751 } else {
752 if (!tw_dev->error_index) {
753 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS;
754 break;
755 }
756 tw_ioctl->driver_command.status = 0;
757 event_index = 0;
758 }
759 memcpy(tw_ioctl->data_buffer, tw_dev->event_queue[event_index], sizeof(TW_Event));
760 tw_dev->event_queue[event_index]->retrieved = TW_AEN_RETRIEVED;
761 break;
762 case TW_IOCTL_GET_NEXT_EVENT:
763 event = (TW_Event *)tw_ioctl->data_buffer;
764 sequence_id = event->sequence_id;
765 tw_ioctl->driver_command.status = 0;
766
767 if (tw_dev->event_queue_wrapped) {
768 if (tw_dev->aen_clobber) {
769 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_AEN_CLOBBER;
770 tw_dev->aen_clobber = 0;
771 }
772 start_index = tw_dev->error_index;
773 } else {
774 if (!tw_dev->error_index) {
775 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS;
776 break;
777 }
778 start_index = 0;
779 }
780 event_index = (start_index + sequence_id - tw_dev->event_queue[start_index]->sequence_id + 1) % TW_Q_LENGTH;
781
782 if (!(tw_dev->event_queue[event_index]->sequence_id > sequence_id)) {
783 if (tw_ioctl->driver_command.status == TW_IOCTL_ERROR_STATUS_AEN_CLOBBER)
784 tw_dev->aen_clobber = 1;
785 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS;
786 break;
787 }
788 memcpy(tw_ioctl->data_buffer, tw_dev->event_queue[event_index], sizeof(TW_Event));
789 tw_dev->event_queue[event_index]->retrieved = TW_AEN_RETRIEVED;
790 break;
791 case TW_IOCTL_GET_PREVIOUS_EVENT:
792 event = (TW_Event *)tw_ioctl->data_buffer;
793 sequence_id = event->sequence_id;
794 tw_ioctl->driver_command.status = 0;
795
796 if (tw_dev->event_queue_wrapped) {
797 if (tw_dev->aen_clobber) {
798 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_AEN_CLOBBER;
799 tw_dev->aen_clobber = 0;
800 }
801 start_index = tw_dev->error_index;
802 } else {
803 if (!tw_dev->error_index) {
804 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS;
805 break;
806 }
807 start_index = 0;
808 }
809 event_index = (start_index + sequence_id - tw_dev->event_queue[start_index]->sequence_id - 1) % TW_Q_LENGTH;
810
811 if (!(tw_dev->event_queue[event_index]->sequence_id < sequence_id)) {
812 if (tw_ioctl->driver_command.status == TW_IOCTL_ERROR_STATUS_AEN_CLOBBER)
813 tw_dev->aen_clobber = 1;
814 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS;
815 break;
816 }
817 memcpy(tw_ioctl->data_buffer, tw_dev->event_queue[event_index], sizeof(TW_Event));
818 tw_dev->event_queue[event_index]->retrieved = TW_AEN_RETRIEVED;
819 break;
820 case TW_IOCTL_GET_LOCK:
821 tw_lock = (TW_Lock *)tw_ioctl->data_buffer;
822 do_gettimeofday(&current_time);
823 current_time_ms = (current_time.tv_sec * 1000) + (current_time.tv_usec / 1000);
824
825 if ((tw_lock->force_flag == 1) || (tw_dev->ioctl_sem_lock == 0) || (current_time_ms >= tw_dev->ioctl_msec)) {
826 tw_dev->ioctl_sem_lock = 1;
827 tw_dev->ioctl_msec = current_time_ms + tw_lock->timeout_msec;
828 tw_ioctl->driver_command.status = 0;
829 tw_lock->time_remaining_msec = tw_lock->timeout_msec;
830 } else {
831 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_LOCKED;
832 tw_lock->time_remaining_msec = tw_dev->ioctl_msec - current_time_ms;
833 }
834 break;
835 case TW_IOCTL_RELEASE_LOCK:
836 if (tw_dev->ioctl_sem_lock == 1) {
837 tw_dev->ioctl_sem_lock = 0;
838 tw_ioctl->driver_command.status = 0;
839 } else {
840 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NOT_LOCKED;
841 }
842 break;
843 default:
844 retval = TW_IOCTL_ERROR_OS_ENOTTY;
845 goto out3;
846 }
847
848 /* Now copy the entire response to userspace */
849 if (copy_to_user(argp, tw_ioctl, sizeof(TW_Ioctl_Buf_Apache) + driver_command.buffer_length - 1) == 0)
850 retval = 0;
851 out3:
852 /* Now free ioctl buf memory */
853 dma_free_coherent(&tw_dev->tw_pci_dev->dev, data_buffer_length_adjusted+sizeof(TW_Ioctl_Buf_Apache) - 1, cpu_addr, dma_handle);
854 out2:
855 up(&tw_dev->ioctl_sem);
856 out:
857 return retval;
858 } /* End twa_chrdev_ioctl() */
859
860 /* This function handles open for the character device */
861 static int twa_chrdev_open(struct inode *inode, struct file *file)
862 {
863 unsigned int minor_number;
864 int retval = TW_IOCTL_ERROR_OS_ENODEV;
865
866 minor_number = iminor(inode);
867 if (minor_number >= twa_device_extension_count)
868 goto out;
869 retval = 0;
870 out:
871 return retval;
872 } /* End twa_chrdev_open() */
873
874 /* This function will print readable messages from status register errors */
875 static int twa_decode_bits(TW_Device_Extension *tw_dev, u32 status_reg_value)
876 {
877 int retval = 1;
878
879 /* Check for various error conditions and handle them appropriately */
880 if (status_reg_value & TW_STATUS_PCI_PARITY_ERROR) {
881 TW_PRINTK(tw_dev->host, TW_DRIVER, 0xc, "PCI Parity Error: clearing");
882 writel(TW_CONTROL_CLEAR_PARITY_ERROR, TW_CONTROL_REG_ADDR(tw_dev));
883 }
884
885 if (status_reg_value & TW_STATUS_PCI_ABORT) {
886 TW_PRINTK(tw_dev->host, TW_DRIVER, 0xd, "PCI Abort: clearing");
887 writel(TW_CONTROL_CLEAR_PCI_ABORT, TW_CONTROL_REG_ADDR(tw_dev));
888 pci_write_config_word(tw_dev->tw_pci_dev, PCI_STATUS, TW_PCI_CLEAR_PCI_ABORT);
889 }
890
891 if (status_reg_value & TW_STATUS_QUEUE_ERROR) {
892 TW_PRINTK(tw_dev->host, TW_DRIVER, 0xe, "Controller Queue Error: clearing");
893 writel(TW_CONTROL_CLEAR_QUEUE_ERROR, TW_CONTROL_REG_ADDR(tw_dev));
894 }
895
896 if (status_reg_value & TW_STATUS_MICROCONTROLLER_ERROR) {
897 if (tw_dev->reset_print == 0) {
898 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x10, "Microcontroller Error: clearing");
899 tw_dev->reset_print = 1;
900 }
901 goto out;
902 }
903 retval = 0;
904 out:
905 return retval;
906 } /* End twa_decode_bits() */
907
908 /* This function will empty the response queue */
909 static int twa_empty_response_queue(TW_Device_Extension *tw_dev)
910 {
911 u32 status_reg_value, response_que_value;
912 int count = 0, retval = 1;
913
914 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
915
916 while (((status_reg_value & TW_STATUS_RESPONSE_QUEUE_EMPTY) == 0) && (count < TW_MAX_RESPONSE_DRAIN)) {
917 response_que_value = readl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev));
918 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
919 count++;
920 }
921 if (count == TW_MAX_RESPONSE_DRAIN)
922 goto out;
923
924 retval = 0;
925 out:
926 return retval;
927 } /* End twa_empty_response_queue() */
928
929 /* This function will clear the pchip/response queue on 9550SX */
930 static int twa_empty_response_queue_large(TW_Device_Extension *tw_dev)
931 {
932 u32 status_reg_value, response_que_value;
933 int count = 0, retval = 1;
934
935 if (tw_dev->tw_pci_dev->device == PCI_DEVICE_ID_3WARE_9550SX) {
936 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
937
938 while (((status_reg_value & TW_STATUS_RESPONSE_QUEUE_EMPTY) == 0) && (count < TW_MAX_RESPONSE_DRAIN)) {
939 response_que_value = readl(TW_RESPONSE_QUEUE_REG_ADDR_LARGE(tw_dev));
940 if ((response_que_value & TW_9550SX_DRAIN_COMPLETED) == TW_9550SX_DRAIN_COMPLETED) {
941 /* P-chip settle time */
942 msleep(500);
943 retval = 0;
944 goto out;
945 }
946 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
947 count++;
948 }
949 if (count == TW_MAX_RESPONSE_DRAIN)
950 goto out;
951
952 retval = 0;
953 } else
954 retval = 0;
955 out:
956 return retval;
957 } /* End twa_empty_response_queue_large() */
958
959 /* This function passes sense keys from firmware to scsi layer */
960 static int twa_fill_sense(TW_Device_Extension *tw_dev, int request_id, int copy_sense, int print_host)
961 {
962 TW_Command_Full *full_command_packet;
963 unsigned short error;
964 int retval = 1;
965 char *error_str;
966
967 full_command_packet = tw_dev->command_packet_virt[request_id];
968
969 /* Check for embedded error string */
970 error_str = &(full_command_packet->header.err_specific_desc[strlen(full_command_packet->header.err_specific_desc) + 1]);
971
972 /* Don't print error for Logical unit not supported during rollcall */
973 error = full_command_packet->header.status_block.error;
974 if ((error != TW_ERROR_LOGICAL_UNIT_NOT_SUPPORTED) && (error != TW_ERROR_UNIT_OFFLINE)) {
975 if (print_host)
976 printk(KERN_WARNING "3w-9xxx: scsi%d: ERROR: (0x%02X:0x%04X): %s:%s.\n",
977 tw_dev->host->host_no,
978 TW_MESSAGE_SOURCE_CONTROLLER_ERROR,
979 full_command_packet->header.status_block.error,
980 error_str[0] == '\0' ?
981 twa_string_lookup(twa_error_table,
982 full_command_packet->header.status_block.error) : error_str,
983 full_command_packet->header.err_specific_desc);
984 else
985 printk(KERN_WARNING "3w-9xxx: ERROR: (0x%02X:0x%04X): %s:%s.\n",
986 TW_MESSAGE_SOURCE_CONTROLLER_ERROR,
987 full_command_packet->header.status_block.error,
988 error_str[0] == '\0' ?
989 twa_string_lookup(twa_error_table,
990 full_command_packet->header.status_block.error) : error_str,
991 full_command_packet->header.err_specific_desc);
992 }
993
994 if (copy_sense) {
995 memcpy(tw_dev->srb[request_id]->sense_buffer, full_command_packet->header.sense_data, TW_SENSE_DATA_LENGTH);
996 tw_dev->srb[request_id]->result = (full_command_packet->command.newcommand.status << 1);
997 retval = TW_ISR_DONT_RESULT;
998 goto out;
999 }
1000 retval = 0;
1001 out:
1002 return retval;
1003 } /* End twa_fill_sense() */
1004
1005 /* This function will free up device extension resources */
1006 static void twa_free_device_extension(TW_Device_Extension *tw_dev)
1007 {
1008 if (tw_dev->command_packet_virt[0])
1009 pci_free_consistent(tw_dev->tw_pci_dev,
1010 sizeof(TW_Command_Full)*TW_Q_LENGTH,
1011 tw_dev->command_packet_virt[0],
1012 tw_dev->command_packet_phys[0]);
1013
1014 if (tw_dev->generic_buffer_virt[0])
1015 pci_free_consistent(tw_dev->tw_pci_dev,
1016 TW_SECTOR_SIZE*TW_Q_LENGTH,
1017 tw_dev->generic_buffer_virt[0],
1018 tw_dev->generic_buffer_phys[0]);
1019
1020 if (tw_dev->event_queue[0])
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 init_MUTEX(&tw_dev->ioctl_sem);
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 printk(KERN_WARNING "3w-9xxx: scsi%d: WARNING: (0x%02X:0x%04X): Unit #%d: Command (0x%x) timed out, resetting card.\n", tw_dev->host->host_no, TW_DRIVER, 0x2c, SCpnt->device->id, SCpnt->cmnd[0]);
1736
1737 /* Now reset the card and some of the device extension data */
1738 if (twa_reset_device_extension(tw_dev, 0)) {
1739 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x2b, "Controller reset failed during scsi host reset");
1740 goto out;
1741 }
1742
1743 retval = SUCCESS;
1744 out:
1745 return retval;
1746 } /* End twa_scsi_eh_reset() */
1747
1748 /* This is the main scsi queue function to handle scsi opcodes */
1749 static int twa_scsi_queue(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *))
1750 {
1751 int request_id, retval;
1752 TW_Device_Extension *tw_dev = (TW_Device_Extension *)SCpnt->device->host->hostdata;
1753
1754 /* Check if this FW supports luns */
1755 if ((SCpnt->device->lun != 0) && (tw_dev->working_srl < TW_FW_SRL_LUNS_SUPPORTED)) {
1756 SCpnt->result = (DID_BAD_TARGET << 16);
1757 done(SCpnt);
1758 retval = 0;
1759 goto out;
1760 }
1761
1762 /* Save done function into scsi_cmnd struct */
1763 SCpnt->scsi_done = done;
1764
1765 /* Get a free request id */
1766 twa_get_request_id(tw_dev, &request_id);
1767
1768 /* Save the scsi command for use by the ISR */
1769 tw_dev->srb[request_id] = SCpnt;
1770
1771 /* Initialize phase to zero */
1772 SCpnt->SCp.phase = TW_PHASE_INITIAL;
1773
1774 retval = twa_scsiop_execute_scsi(tw_dev, request_id, NULL, 0, NULL);
1775 switch (retval) {
1776 case SCSI_MLQUEUE_HOST_BUSY:
1777 twa_free_request_id(tw_dev, request_id);
1778 break;
1779 case 1:
1780 tw_dev->state[request_id] = TW_S_COMPLETED;
1781 twa_free_request_id(tw_dev, request_id);
1782 SCpnt->result = (DID_ERROR << 16);
1783 done(SCpnt);
1784 retval = 0;
1785 }
1786 out:
1787 return retval;
1788 } /* End twa_scsi_queue() */
1789
1790 /* This function hands scsi cdb's to the firmware */
1791 static int twa_scsiop_execute_scsi(TW_Device_Extension *tw_dev, int request_id, char *cdb, int use_sg, TW_SG_Entry *sglistarg)
1792 {
1793 TW_Command_Full *full_command_packet;
1794 TW_Command_Apache *command_packet;
1795 u32 num_sectors = 0x0;
1796 int i, sg_count;
1797 struct scsi_cmnd *srb = NULL;
1798 struct scatterlist *sglist = NULL;
1799 u32 buffaddr = 0x0;
1800 int retval = 1;
1801
1802 if (tw_dev->srb[request_id]) {
1803 if (tw_dev->srb[request_id]->request_buffer) {
1804 sglist = (struct scatterlist *)tw_dev->srb[request_id]->request_buffer;
1805 }
1806 srb = tw_dev->srb[request_id];
1807 }
1808
1809 /* Initialize command packet */
1810 full_command_packet = tw_dev->command_packet_virt[request_id];
1811 full_command_packet->header.header_desc.size_header = 128;
1812 full_command_packet->header.status_block.error = 0;
1813 full_command_packet->header.status_block.severity__reserved = 0;
1814
1815 command_packet = &full_command_packet->command.newcommand;
1816 command_packet->status = 0;
1817 command_packet->opcode__reserved = TW_OPRES_IN(0, TW_OP_EXECUTE_SCSI);
1818
1819 /* We forced 16 byte cdb use earlier */
1820 if (!cdb)
1821 memcpy(command_packet->cdb, srb->cmnd, TW_MAX_CDB_LEN);
1822 else
1823 memcpy(command_packet->cdb, cdb, TW_MAX_CDB_LEN);
1824
1825 if (srb) {
1826 command_packet->unit = srb->device->id;
1827 command_packet->request_id__lunl =
1828 TW_REQ_LUN_IN(srb->device->lun, request_id);
1829 } else {
1830 command_packet->request_id__lunl =
1831 TW_REQ_LUN_IN(0, request_id);
1832 command_packet->unit = 0;
1833 }
1834
1835 command_packet->sgl_offset = 16;
1836
1837 if (!sglistarg) {
1838 /* Map sglist from scsi layer to cmd packet */
1839 if (tw_dev->srb[request_id]->use_sg == 0) {
1840 if (tw_dev->srb[request_id]->request_bufflen < TW_MIN_SGL_LENGTH) {
1841 command_packet->sg_list[0].address = tw_dev->generic_buffer_phys[request_id];
1842 command_packet->sg_list[0].length = TW_MIN_SGL_LENGTH;
1843 if (tw_dev->srb[request_id]->sc_data_direction == DMA_TO_DEVICE || tw_dev->srb[request_id]->sc_data_direction == DMA_BIDIRECTIONAL)
1844 memcpy(tw_dev->generic_buffer_virt[request_id], tw_dev->srb[request_id]->request_buffer, tw_dev->srb[request_id]->request_bufflen);
1845 } else {
1846 buffaddr = twa_map_scsi_single_data(tw_dev, request_id);
1847 if (buffaddr == 0)
1848 goto out;
1849
1850 command_packet->sg_list[0].address = buffaddr;
1851 command_packet->sg_list[0].length = tw_dev->srb[request_id]->request_bufflen;
1852 }
1853 command_packet->sgl_entries__lunh = TW_REQ_LUN_IN((srb->device->lun >> 4), 1);
1854
1855 if (command_packet->sg_list[0].address & TW_ALIGNMENT_9000_SGL) {
1856 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x2d, "Found unaligned address during execute scsi");
1857 goto out;
1858 }
1859 }
1860
1861 if (tw_dev->srb[request_id]->use_sg > 0) {
1862 if ((tw_dev->srb[request_id]->use_sg == 1) && (tw_dev->srb[request_id]->request_bufflen < TW_MIN_SGL_LENGTH)) {
1863 if (tw_dev->srb[request_id]->sc_data_direction == DMA_TO_DEVICE || tw_dev->srb[request_id]->sc_data_direction == DMA_BIDIRECTIONAL) {
1864 struct scatterlist *sg = (struct scatterlist *)tw_dev->srb[request_id]->request_buffer;
1865 char *buf = kmap_atomic(sg->page, KM_IRQ0) + sg->offset;
1866 memcpy(tw_dev->generic_buffer_virt[request_id], buf, sg->length);
1867 kunmap_atomic(buf - sg->offset, KM_IRQ0);
1868 }
1869 command_packet->sg_list[0].address = tw_dev->generic_buffer_phys[request_id];
1870 command_packet->sg_list[0].length = TW_MIN_SGL_LENGTH;
1871 } else {
1872 sg_count = twa_map_scsi_sg_data(tw_dev, request_id);
1873 if (sg_count == 0)
1874 goto out;
1875
1876 for (i = 0; i < sg_count; i++) {
1877 command_packet->sg_list[i].address = sg_dma_address(&sglist[i]);
1878 command_packet->sg_list[i].length = sg_dma_len(&sglist[i]);
1879 if (command_packet->sg_list[i].address & TW_ALIGNMENT_9000_SGL) {
1880 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x2e, "Found unaligned sgl address during execute scsi");
1881 goto out;
1882 }
1883 }
1884 }
1885 command_packet->sgl_entries__lunh = TW_REQ_LUN_IN((srb->device->lun >> 4), tw_dev->srb[request_id]->use_sg);
1886 }
1887 } else {
1888 /* Internal cdb post */
1889 for (i = 0; i < use_sg; i++) {
1890 command_packet->sg_list[i].address = sglistarg[i].address;
1891 command_packet->sg_list[i].length = sglistarg[i].length;
1892 if (command_packet->sg_list[i].address & TW_ALIGNMENT_9000_SGL) {
1893 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x2f, "Found unaligned sgl address during internal post");
1894 goto out;
1895 }
1896 }
1897 command_packet->sgl_entries__lunh = TW_REQ_LUN_IN(0, use_sg);
1898 }
1899
1900 if (srb) {
1901 if (srb->cmnd[0] == READ_6 || srb->cmnd[0] == WRITE_6)
1902 num_sectors = (u32)srb->cmnd[4];
1903
1904 if (srb->cmnd[0] == READ_10 || srb->cmnd[0] == WRITE_10)
1905 num_sectors = (u32)srb->cmnd[8] | ((u32)srb->cmnd[7] << 8);
1906 }
1907
1908 /* Update sector statistic */
1909 tw_dev->sector_count = num_sectors;
1910 if (tw_dev->sector_count > tw_dev->max_sector_count)
1911 tw_dev->max_sector_count = tw_dev->sector_count;
1912
1913 /* Update SG statistics */
1914 if (srb) {
1915 tw_dev->sgl_entries = tw_dev->srb[request_id]->use_sg;
1916 if (tw_dev->sgl_entries > tw_dev->max_sgl_entries)
1917 tw_dev->max_sgl_entries = tw_dev->sgl_entries;
1918 }
1919
1920 /* Now post the command to the board */
1921 if (srb) {
1922 retval = twa_post_command_packet(tw_dev, request_id, 0);
1923 } else {
1924 twa_post_command_packet(tw_dev, request_id, 1);
1925 retval = 0;
1926 }
1927 out:
1928 return retval;
1929 } /* End twa_scsiop_execute_scsi() */
1930
1931 /* This function completes an execute scsi operation */
1932 static void twa_scsiop_execute_scsi_complete(TW_Device_Extension *tw_dev, int request_id)
1933 {
1934 if (tw_dev->srb[request_id]->request_bufflen < TW_MIN_SGL_LENGTH &&
1935 (tw_dev->srb[request_id]->sc_data_direction == DMA_FROM_DEVICE ||
1936 tw_dev->srb[request_id]->sc_data_direction == DMA_BIDIRECTIONAL)) {
1937 if (tw_dev->srb[request_id]->use_sg == 0) {
1938 memcpy(tw_dev->srb[request_id]->request_buffer,
1939 tw_dev->generic_buffer_virt[request_id],
1940 tw_dev->srb[request_id]->request_bufflen);
1941 }
1942 if (tw_dev->srb[request_id]->use_sg == 1) {
1943 struct scatterlist *sg = (struct scatterlist *)tw_dev->srb[request_id]->request_buffer;
1944 char *buf = kmap_atomic(sg->page, KM_IRQ0) + sg->offset;
1945 memcpy(buf, tw_dev->generic_buffer_virt[request_id], sg->length);
1946 kunmap_atomic(buf - sg->offset, KM_IRQ0);
1947 }
1948 }
1949 } /* End twa_scsiop_execute_scsi_complete() */
1950
1951 /* This function tells the controller to shut down */
1952 static void __twa_shutdown(TW_Device_Extension *tw_dev)
1953 {
1954 /* Disable interrupts */
1955 TW_DISABLE_INTERRUPTS(tw_dev);
1956
1957 printk(KERN_WARNING "3w-9xxx: Shutting down host %d.\n", tw_dev->host->host_no);
1958
1959 /* Tell the card we are shutting down */
1960 if (twa_initconnection(tw_dev, 1, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL)) {
1961 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x31, "Connection shutdown failed");
1962 } else {
1963 printk(KERN_WARNING "3w-9xxx: Shutdown complete.\n");
1964 }
1965
1966 /* Clear all interrupts just before exit */
1967 TW_CLEAR_ALL_INTERRUPTS(tw_dev);
1968 } /* End __twa_shutdown() */
1969
1970 /* Wrapper for __twa_shutdown */
1971 static void twa_shutdown(struct pci_dev *pdev)
1972 {
1973 struct Scsi_Host *host = pci_get_drvdata(pdev);
1974 TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
1975
1976 __twa_shutdown(tw_dev);
1977 } /* End twa_shutdown() */
1978
1979 /* This function will look up a string */
1980 static char *twa_string_lookup(twa_message_type *table, unsigned int code)
1981 {
1982 int index;
1983
1984 for (index = 0; ((code != table[index].code) &&
1985 (table[index].text != (char *)0)); index++);
1986 return(table[index].text);
1987 } /* End twa_string_lookup() */
1988
1989 /* This function will perform a pci-dma unmap */
1990 static void twa_unmap_scsi_data(TW_Device_Extension *tw_dev, int request_id)
1991 {
1992 struct scsi_cmnd *cmd = tw_dev->srb[request_id];
1993 struct pci_dev *pdev = tw_dev->tw_pci_dev;
1994
1995 switch(cmd->SCp.phase) {
1996 case TW_PHASE_SINGLE:
1997 pci_unmap_single(pdev, cmd->SCp.have_data_in, cmd->request_bufflen, DMA_BIDIRECTIONAL);
1998 break;
1999 case TW_PHASE_SGLIST:
2000 pci_unmap_sg(pdev, cmd->request_buffer, cmd->use_sg, DMA_BIDIRECTIONAL);
2001 break;
2002 }
2003 } /* End twa_unmap_scsi_data() */
2004
2005 /* scsi_host_template initializer */
2006 static struct scsi_host_template driver_template = {
2007 .module = THIS_MODULE,
2008 .name = "3ware 9000 Storage Controller",
2009 .queuecommand = twa_scsi_queue,
2010 .eh_host_reset_handler = twa_scsi_eh_reset,
2011 .bios_param = twa_scsi_biosparam,
2012 .change_queue_depth = twa_change_queue_depth,
2013 .can_queue = TW_Q_LENGTH-2,
2014 .this_id = -1,
2015 .sg_tablesize = TW_APACHE_MAX_SGL_LENGTH,
2016 .max_sectors = TW_MAX_SECTORS,
2017 .cmd_per_lun = TW_MAX_CMDS_PER_LUN,
2018 .use_clustering = ENABLE_CLUSTERING,
2019 .shost_attrs = twa_host_attrs,
2020 .emulated = 1
2021 };
2022
2023 /* This function will probe and initialize a card */
2024 static int __devinit twa_probe(struct pci_dev *pdev, const struct pci_device_id *dev_id)
2025 {
2026 struct Scsi_Host *host = NULL;
2027 TW_Device_Extension *tw_dev;
2028 u32 mem_addr;
2029 int retval = -ENODEV;
2030
2031 retval = pci_enable_device(pdev);
2032 if (retval) {
2033 TW_PRINTK(host, TW_DRIVER, 0x34, "Failed to enable pci device");
2034 goto out_disable_device;
2035 }
2036
2037 pci_set_master(pdev);
2038
2039 retval = pci_set_dma_mask(pdev, sizeof(dma_addr_t) > 4 ? DMA_64BIT_MASK : DMA_32BIT_MASK);
2040 if (retval) {
2041 TW_PRINTK(host, TW_DRIVER, 0x23, "Failed to set dma mask");
2042 goto out_disable_device;
2043 }
2044
2045 host = scsi_host_alloc(&driver_template, sizeof(TW_Device_Extension));
2046 if (!host) {
2047 TW_PRINTK(host, TW_DRIVER, 0x24, "Failed to allocate memory for device extension");
2048 retval = -ENOMEM;
2049 goto out_disable_device;
2050 }
2051 tw_dev = (TW_Device_Extension *)host->hostdata;
2052
2053 memset(tw_dev, 0, sizeof(TW_Device_Extension));
2054
2055 /* Save values to device extension */
2056 tw_dev->host = host;
2057 tw_dev->tw_pci_dev = pdev;
2058
2059 if (twa_initialize_device_extension(tw_dev)) {
2060 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x25, "Failed to initialize device extension");
2061 goto out_free_device_extension;
2062 }
2063
2064 /* Request IO regions */
2065 retval = pci_request_regions(pdev, "3w-9xxx");
2066 if (retval) {
2067 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x26, "Failed to get mem region");
2068 goto out_free_device_extension;
2069 }
2070
2071 if (pdev->device == PCI_DEVICE_ID_3WARE_9000)
2072 mem_addr = pci_resource_start(pdev, 1);
2073 else
2074 mem_addr = pci_resource_start(pdev, 2);
2075
2076 /* Save base address */
2077 tw_dev->base_addr = ioremap(mem_addr, PAGE_SIZE);
2078 if (!tw_dev->base_addr) {
2079 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x35, "Failed to ioremap");
2080 goto out_release_mem_region;
2081 }
2082
2083 /* Disable interrupts on the card */
2084 TW_DISABLE_INTERRUPTS(tw_dev);
2085
2086 /* Initialize the card */
2087 if (twa_reset_sequence(tw_dev, 0))
2088 goto out_release_mem_region;
2089
2090 /* Set host specific parameters */
2091 host->max_id = TW_MAX_UNITS;
2092 host->max_cmd_len = TW_MAX_CDB_LEN;
2093
2094 /* Channels aren't supported by adapter */
2095 host->max_lun = TW_MAX_LUNS(tw_dev->working_srl);
2096 host->max_channel = 0;
2097
2098 /* Register the card with the kernel SCSI layer */
2099 retval = scsi_add_host(host, &pdev->dev);
2100 if (retval) {
2101 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x27, "scsi add host failed");
2102 goto out_release_mem_region;
2103 }
2104
2105 pci_set_drvdata(pdev, host);
2106
2107 printk(KERN_WARNING "3w-9xxx: scsi%d: Found a 3ware 9000 Storage Controller at 0x%x, IRQ: %d.\n",
2108 host->host_no, mem_addr, pdev->irq);
2109 printk(KERN_WARNING "3w-9xxx: scsi%d: Firmware %s, BIOS %s, Ports: %d.\n",
2110 host->host_no,
2111 (char *)twa_get_param(tw_dev, 0, TW_VERSION_TABLE,
2112 TW_PARAM_FWVER, TW_PARAM_FWVER_LENGTH),
2113 (char *)twa_get_param(tw_dev, 1, TW_VERSION_TABLE,
2114 TW_PARAM_BIOSVER, TW_PARAM_BIOSVER_LENGTH),
2115 *(int *)twa_get_param(tw_dev, 2, TW_INFORMATION_TABLE,
2116 TW_PARAM_PORTCOUNT, TW_PARAM_PORTCOUNT_LENGTH));
2117
2118 /* Now setup the interrupt handler */
2119 retval = request_irq(pdev->irq, twa_interrupt, SA_SHIRQ, "3w-9xxx", tw_dev);
2120 if (retval) {
2121 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x30, "Error requesting IRQ");
2122 goto out_remove_host;
2123 }
2124
2125 twa_device_extension_list[twa_device_extension_count] = tw_dev;
2126 twa_device_extension_count++;
2127
2128 /* Re-enable interrupts on the card */
2129 TW_ENABLE_AND_CLEAR_INTERRUPTS(tw_dev);
2130
2131 /* Finally, scan the host */
2132 scsi_scan_host(host);
2133
2134 if (twa_major == -1) {
2135 if ((twa_major = register_chrdev (0, "twa", &twa_fops)) < 0)
2136 TW_PRINTK(host, TW_DRIVER, 0x29, "Failed to register character device");
2137 }
2138 return 0;
2139
2140 out_remove_host:
2141 scsi_remove_host(host);
2142 out_release_mem_region:
2143 pci_release_regions(pdev);
2144 out_free_device_extension:
2145 twa_free_device_extension(tw_dev);
2146 scsi_host_put(host);
2147 out_disable_device:
2148 pci_disable_device(pdev);
2149
2150 return retval;
2151 } /* End twa_probe() */
2152
2153 /* This function is called to remove a device */
2154 static void twa_remove(struct pci_dev *pdev)
2155 {
2156 struct Scsi_Host *host = pci_get_drvdata(pdev);
2157 TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
2158
2159 scsi_remove_host(tw_dev->host);
2160
2161 /* Unregister character device */
2162 if (twa_major >= 0) {
2163 unregister_chrdev(twa_major, "twa");
2164 twa_major = -1;
2165 }
2166
2167 /* Free up the IRQ */
2168 free_irq(tw_dev->tw_pci_dev->irq, tw_dev);
2169
2170 /* Shutdown the card */
2171 __twa_shutdown(tw_dev);
2172
2173 /* Free up the mem region */
2174 pci_release_regions(pdev);
2175
2176 /* Free up device extension resources */
2177 twa_free_device_extension(tw_dev);
2178
2179 scsi_host_put(tw_dev->host);
2180 pci_disable_device(pdev);
2181 twa_device_extension_count--;
2182 } /* End twa_remove() */
2183
2184 /* PCI Devices supported by this driver */
2185 static struct pci_device_id twa_pci_tbl[] __devinitdata = {
2186 { PCI_VENDOR_ID_3WARE, PCI_DEVICE_ID_3WARE_9000,
2187 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
2188 { PCI_VENDOR_ID_3WARE, PCI_DEVICE_ID_3WARE_9550SX,
2189 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
2190 { }
2191 };
2192 MODULE_DEVICE_TABLE(pci, twa_pci_tbl);
2193
2194 /* pci_driver initializer */
2195 static struct pci_driver twa_driver = {
2196 .name = "3w-9xxx",
2197 .id_table = twa_pci_tbl,
2198 .probe = twa_probe,
2199 .remove = twa_remove,
2200 .shutdown = twa_shutdown
2201 };
2202
2203 /* This function is called on driver initialization */
2204 static int __init twa_init(void)
2205 {
2206 printk(KERN_WARNING "3ware 9000 Storage Controller device driver for Linux v%s.\n", TW_DRIVER_VERSION);
2207
2208 return pci_module_init(&twa_driver);
2209 } /* End twa_init() */
2210
2211 /* This function is called on driver exit */
2212 static void __exit twa_exit(void)
2213 {
2214 pci_unregister_driver(&twa_driver);
2215 } /* End twa_exit() */
2216
2217 module_init(twa_init);
2218 module_exit(twa_exit);
2219
Linux 2.6 libata-dev (mirror)