?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 2.6.17.7
[linux/fpc-iii.git] / drivers / scsi / 3w-9xxx.c
blobcaeb6d246e578eb0732feb99def77729f1980877
1 /*
2 3w-9xxx.c -- 3ware 9000 Storage Controller device driver for Linux.
3
4 Written By: Adam Radford <linuxraid@amcc.com>
5 Modifications By: Tom Couch <linuxraid@amcc.com>
6
7 Copyright (C) 2004-2006 Applied Micro Circuits Corporation.
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; version 2 of the License.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 NO WARRANTY
19 THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
20 CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT
21 LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
22 MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
23 solely responsible for determining the appropriateness of using and
24 distributing the Program and assumes all risks associated with its
25 exercise of rights under this Agreement, including but not limited to
26 the risks and costs of program errors, damage to or loss of data,
27 programs or equipment, and unavailability or interruption of operations.
28
29 DISCLAIMER OF LIABILITY
30 NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
31 DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
32 DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND
33 ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
34 TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
35 USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
36 HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
37
38 You should have received a copy of the GNU General Public License
39 along with this program; if not, write to the Free Software
40 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
41
42 Bugs/Comments/Suggestions should be mailed to:
43 linuxraid@amcc.com
44
45 For more information, goto:
46 http://www.amcc.com
47
48 Note: This version of the driver does not contain a bundled firmware
49 image.
50
51 History
52 -------
53 2.26.02.000 - Driver cleanup for kernel submission.
54 2.26.02.001 - Replace schedule_timeout() calls with msleep().
55 2.26.02.002 - Add support for PAE mode.
56 Add lun support.
57 Fix twa_remove() to free irq handler/unregister_chrdev()
58 before shutting down card.
59 Change to new 'change_queue_depth' api.
60 Fix 'handled=1' ISR usage, remove bogus IRQ check.
61 Remove un-needed eh_abort handler.
62 Add support for embedded firmware error strings.
63 2.26.02.003 - Correctly handle single sgl's with use_sg=1.
64 2.26.02.004 - Add support for 9550SX controllers.
65 2.26.02.005 - Fix use_sg == 0 mapping on systems with 4GB or higher.
66 2.26.02.006 - Fix 9550SX pchip reset timeout.
67 Add big endian support.
68 2.26.02.007 - Disable local interrupts during kmap/unmap_atomic().
69 */
70
71 #include <linux/module.h>
72 #include <linux/reboot.h>
73 #include <linux/spinlock.h>
74 #include <linux/interrupt.h>
75 #include <linux/moduleparam.h>
76 #include <linux/errno.h>
77 #include <linux/types.h>
78 #include <linux/delay.h>
79 #include <linux/pci.h>
80 #include <linux/time.h>
81 #include <linux/mutex.h>
82 #include <asm/io.h>
83 #include <asm/irq.h>
84 #include <asm/uaccess.h>
85 #include <scsi/scsi.h>
86 #include <scsi/scsi_host.h>
87 #include <scsi/scsi_tcq.h>
88 #include <scsi/scsi_cmnd.h>
89 #include "3w-9xxx.h"
90
91 /* Globals */
92 #define TW_DRIVER_VERSION "2.26.02.007"
93 static TW_Device_Extension *twa_device_extension_list[TW_MAX_SLOT];
94 static unsigned int twa_device_extension_count;
95 static int twa_major = -1;
96 extern struct timezone sys_tz;
97
98 /* Module parameters */
99 MODULE_AUTHOR ("AMCC");
100 MODULE_DESCRIPTION ("3ware 9000 Storage Controller Linux Driver");
101 MODULE_LICENSE("GPL");
102 MODULE_VERSION(TW_DRIVER_VERSION);
103
104 /* Function prototypes */
105 static void twa_aen_queue_event(TW_Device_Extension *tw_dev, TW_Command_Apache_Header *header);
106 static int twa_aen_read_queue(TW_Device_Extension *tw_dev, int request_id);
107 static char *twa_aen_severity_lookup(unsigned char severity_code);
108 static void twa_aen_sync_time(TW_Device_Extension *tw_dev, int request_id);
109 static int twa_chrdev_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg);
110 static int twa_chrdev_open(struct inode *inode, struct file *file);
111 static int twa_fill_sense(TW_Device_Extension *tw_dev, int request_id, int copy_sense, int print_host);
112 static void twa_free_request_id(TW_Device_Extension *tw_dev,int request_id);
113 static void twa_get_request_id(TW_Device_Extension *tw_dev, int *request_id);
114 static int twa_initconnection(TW_Device_Extension *tw_dev, int message_credits,
115 u32 set_features, unsigned short current_fw_srl,
116 unsigned short current_fw_arch_id,
117 unsigned short current_fw_branch,
118 unsigned short current_fw_build,
119 unsigned short *fw_on_ctlr_srl,
120 unsigned short *fw_on_ctlr_arch_id,
121 unsigned short *fw_on_ctlr_branch,
122 unsigned short *fw_on_ctlr_build,
123 u32 *init_connect_result);
124 static void twa_load_sgl(TW_Command_Full *full_command_packet, int request_id, dma_addr_t dma_handle, int length);
125 static int twa_poll_response(TW_Device_Extension *tw_dev, int request_id, int seconds);
126 static int twa_poll_status_gone(TW_Device_Extension *tw_dev, u32 flag, int seconds);
127 static int twa_post_command_packet(TW_Device_Extension *tw_dev, int request_id, char internal);
128 static int twa_reset_device_extension(TW_Device_Extension *tw_dev, int ioctl_reset);
129 static int twa_reset_sequence(TW_Device_Extension *tw_dev, int soft_reset);
130 static int twa_scsiop_execute_scsi(TW_Device_Extension *tw_dev, int request_id, char *cdb, int use_sg, TW_SG_Entry *sglistarg);
131 static void twa_scsiop_execute_scsi_complete(TW_Device_Extension *tw_dev, int request_id);
132 static char *twa_string_lookup(twa_message_type *table, unsigned int aen_code);
133 static void twa_unmap_scsi_data(TW_Device_Extension *tw_dev, int request_id);
134
135 /* Functions */
136
137 /* Show some statistics about the card */
138 static ssize_t twa_show_stats(struct class_device *class_dev, char *buf)
139 {
140 struct Scsi_Host *host = class_to_shost(class_dev);
141 TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
142 unsigned long flags = 0;
143 ssize_t len;
144
145 spin_lock_irqsave(tw_dev->host->host_lock, flags);
146 len = snprintf(buf, PAGE_SIZE, "3w-9xxx Driver version: %s\n"
147 "Current commands posted: %4d\n"
148 "Max commands posted: %4d\n"
149 "Current pending commands: %4d\n"
150 "Max pending commands: %4d\n"
151 "Last sgl length: %4d\n"
152 "Max sgl length: %4d\n"
153 "Last sector count: %4d\n"
154 "Max sector count: %4d\n"
155 "SCSI Host Resets: %4d\n"
156 "AEN's: %4d\n",
157 TW_DRIVER_VERSION,
158 tw_dev->posted_request_count,
159 tw_dev->max_posted_request_count,
160 tw_dev->pending_request_count,
161 tw_dev->max_pending_request_count,
162 tw_dev->sgl_entries,
163 tw_dev->max_sgl_entries,
164 tw_dev->sector_count,
165 tw_dev->max_sector_count,
166 tw_dev->num_resets,
167 tw_dev->aen_count);
168 spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
169 return len;
170 } /* End twa_show_stats() */
171
172 /* This function will set a devices queue depth */
173 static int twa_change_queue_depth(struct scsi_device *sdev, int queue_depth)
174 {
175 if (queue_depth > TW_Q_LENGTH-2)
176 queue_depth = TW_Q_LENGTH-2;
177 scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG, queue_depth);
178 return queue_depth;
179 } /* End twa_change_queue_depth() */
180
181 /* Create sysfs 'stats' entry */
182 static struct class_device_attribute twa_host_stats_attr = {
183 .attr = {
184 .name = "stats",
185 .mode = S_IRUGO,
186 },
187 .show = twa_show_stats
188 };
189
190 /* Host attributes initializer */
191 static struct class_device_attribute *twa_host_attrs[] = {
192 &twa_host_stats_attr,
193 NULL,
194 };
195
196 /* File operations struct for character device */
197 static struct file_operations twa_fops = {
198 .owner = THIS_MODULE,
199 .ioctl = twa_chrdev_ioctl,
200 .open = twa_chrdev_open,
201 .release = NULL
202 };
203
204 /* This function will complete an aen request from the isr */
205 static int twa_aen_complete(TW_Device_Extension *tw_dev, int request_id)
206 {
207 TW_Command_Full *full_command_packet;
208 TW_Command *command_packet;
209 TW_Command_Apache_Header *header;
210 unsigned short aen;
211 int retval = 1;
212
213 header = (TW_Command_Apache_Header *)tw_dev->generic_buffer_virt[request_id];
214 tw_dev->posted_request_count--;
215 aen = le16_to_cpu(header->status_block.error);
216 full_command_packet = tw_dev->command_packet_virt[request_id];
217 command_packet = &full_command_packet->command.oldcommand;
218
219 /* First check for internal completion of set param for time sync */
220 if (TW_OP_OUT(command_packet->opcode__sgloffset) == TW_OP_SET_PARAM) {
221 /* Keep reading the queue in case there are more aen's */
222 if (twa_aen_read_queue(tw_dev, request_id))
223 goto out2;
224 else {
225 retval = 0;
226 goto out;
227 }
228 }
229
230 switch (aen) {
231 case TW_AEN_QUEUE_EMPTY:
232 /* Quit reading the queue if this is the last one */
233 break;
234 case TW_AEN_SYNC_TIME_WITH_HOST:
235 twa_aen_sync_time(tw_dev, request_id);
236 retval = 0;
237 goto out;
238 default:
239 twa_aen_queue_event(tw_dev, header);
240
241 /* If there are more aen's, keep reading the queue */
242 if (twa_aen_read_queue(tw_dev, request_id))
243 goto out2;
244 else {
245 retval = 0;
246 goto out;
247 }
248 }
249 retval = 0;
250 out2:
251 tw_dev->state[request_id] = TW_S_COMPLETED;
252 twa_free_request_id(tw_dev, request_id);
253 clear_bit(TW_IN_ATTENTION_LOOP, &tw_dev->flags);
254 out:
255 return retval;
256 } /* End twa_aen_complete() */
257
258 /* This function will drain aen queue */
259 static int twa_aen_drain_queue(TW_Device_Extension *tw_dev, int no_check_reset)
260 {
261 int request_id = 0;
262 char cdb[TW_MAX_CDB_LEN];
263 TW_SG_Entry sglist[1];
264 int finished = 0, count = 0;
265 TW_Command_Full *full_command_packet;
266 TW_Command_Apache_Header *header;
267 unsigned short aen;
268 int first_reset = 0, queue = 0, retval = 1;
269
270 if (no_check_reset)
271 first_reset = 0;
272 else
273 first_reset = 1;
274
275 full_command_packet = tw_dev->command_packet_virt[request_id];
276 memset(full_command_packet, 0, sizeof(TW_Command_Full));
277
278 /* Initialize cdb */
279 memset(&cdb, 0, TW_MAX_CDB_LEN);
280 cdb[0] = REQUEST_SENSE; /* opcode */
281 cdb[4] = TW_ALLOCATION_LENGTH; /* allocation length */
282
283 /* Initialize sglist */
284 memset(&sglist, 0, sizeof(TW_SG_Entry));
285 sglist[0].length = TW_SECTOR_SIZE;
286 sglist[0].address = tw_dev->generic_buffer_phys[request_id];
287
288 if (sglist[0].address & TW_ALIGNMENT_9000_SGL) {
289 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1, "Found unaligned address during AEN drain");
290 goto out;
291 }
292
293 /* Mark internal command */
294 tw_dev->srb[request_id] = NULL;
295
296 do {
297 /* Send command to the board */
298 if (twa_scsiop_execute_scsi(tw_dev, request_id, cdb, 1, sglist)) {
299 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x2, "Error posting request sense");
300 goto out;
301 }
302
303 /* Now poll for completion */
304 if (twa_poll_response(tw_dev, request_id, 30)) {
305 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x3, "No valid response while draining AEN queue");
306 tw_dev->posted_request_count--;
307 goto out;
308 }
309
310 tw_dev->posted_request_count--;
311 header = (TW_Command_Apache_Header *)tw_dev->generic_buffer_virt[request_id];
312 aen = le16_to_cpu(header->status_block.error);
313 queue = 0;
314 count++;
315
316 switch (aen) {
317 case TW_AEN_QUEUE_EMPTY:
318 if (first_reset != 1)
319 goto out;
320 else
321 finished = 1;
322 break;
323 case TW_AEN_SOFT_RESET:
324 if (first_reset == 0)
325 first_reset = 1;
326 else
327 queue = 1;
328 break;
329 case TW_AEN_SYNC_TIME_WITH_HOST:
330 break;
331 default:
332 queue = 1;
333 }
334
335 /* Now queue an event info */
336 if (queue)
337 twa_aen_queue_event(tw_dev, header);
338 } while ((finished == 0) && (count < TW_MAX_AEN_DRAIN));
339
340 if (count == TW_MAX_AEN_DRAIN)
341 goto out;
342
343 retval = 0;
344 out:
345 tw_dev->state[request_id] = TW_S_INITIAL;
346 return retval;
347 } /* End twa_aen_drain_queue() */
348
349 /* This function will queue an event */
350 static void twa_aen_queue_event(TW_Device_Extension *tw_dev, TW_Command_Apache_Header *header)
351 {
352 u32 local_time;
353 struct timeval time;
354 TW_Event *event;
355 unsigned short aen;
356 char host[16];
357 char *error_str;
358
359 tw_dev->aen_count++;
360
361 /* Fill out event info */
362 event = tw_dev->event_queue[tw_dev->error_index];
363
364 /* Check for clobber */
365 host[0] = '\0';
366 if (tw_dev->host) {
367 sprintf(host, " scsi%d:", tw_dev->host->host_no);
368 if (event->retrieved == TW_AEN_NOT_RETRIEVED)
369 tw_dev->aen_clobber = 1;
370 }
371
372 aen = le16_to_cpu(header->status_block.error);
373 memset(event, 0, sizeof(TW_Event));
374
375 event->severity = TW_SEV_OUT(header->status_block.severity__reserved);
376 do_gettimeofday(&time);
377 local_time = (u32)(time.tv_sec - (sys_tz.tz_minuteswest * 60));
378 event->time_stamp_sec = local_time;
379 event->aen_code = aen;
380 event->retrieved = TW_AEN_NOT_RETRIEVED;
381 event->sequence_id = tw_dev->error_sequence_id;
382 tw_dev->error_sequence_id++;
383
384 /* Check for embedded error string */
385 error_str = &(header->err_specific_desc[strlen(header->err_specific_desc)+1]);
386
387 header->err_specific_desc[sizeof(header->err_specific_desc) - 1] = '\0';
388 event->parameter_len = strlen(header->err_specific_desc);
389 memcpy(event->parameter_data, header->err_specific_desc, event->parameter_len + (error_str[0] == '\0' ? 0 : (1 + strlen(error_str))));
390 if (event->severity != TW_AEN_SEVERITY_DEBUG)
391 printk(KERN_WARNING "3w-9xxx:%s AEN: %s (0x%02X:0x%04X): %s:%s.\n",
392 host,
393 twa_aen_severity_lookup(TW_SEV_OUT(header->status_block.severity__reserved)),
394 TW_MESSAGE_SOURCE_CONTROLLER_EVENT, aen,
395 error_str[0] == '\0' ? twa_string_lookup(twa_aen_table, aen) : error_str,
396 header->err_specific_desc);
397 else
398 tw_dev->aen_count--;
399
400 if ((tw_dev->error_index + 1) == TW_Q_LENGTH)
401 tw_dev->event_queue_wrapped = 1;
402 tw_dev->error_index = (tw_dev->error_index + 1 ) % TW_Q_LENGTH;
403 } /* End twa_aen_queue_event() */
404
405 /* This function will read the aen queue from the isr */
406 static int twa_aen_read_queue(TW_Device_Extension *tw_dev, int request_id)
407 {
408 char cdb[TW_MAX_CDB_LEN];
409 TW_SG_Entry sglist[1];
410 TW_Command_Full *full_command_packet;
411 int retval = 1;
412
413 full_command_packet = tw_dev->command_packet_virt[request_id];
414 memset(full_command_packet, 0, sizeof(TW_Command_Full));
415
416 /* Initialize cdb */
417 memset(&cdb, 0, TW_MAX_CDB_LEN);
418 cdb[0] = REQUEST_SENSE; /* opcode */
419 cdb[4] = TW_ALLOCATION_LENGTH; /* allocation length */
420
421 /* Initialize sglist */
422 memset(&sglist, 0, sizeof(TW_SG_Entry));
423 sglist[0].length = TW_SECTOR_SIZE;
424 sglist[0].address = tw_dev->generic_buffer_phys[request_id];
425
426 /* Mark internal command */
427 tw_dev->srb[request_id] = NULL;
428
429 /* Now post the command packet */
430 if (twa_scsiop_execute_scsi(tw_dev, request_id, cdb, 1, sglist)) {
431 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x4, "Post failed while reading AEN queue");
432 goto out;
433 }
434 retval = 0;
435 out:
436 return retval;
437 } /* End twa_aen_read_queue() */
438
439 /* This function will look up an AEN severity string */
440 static char *twa_aen_severity_lookup(unsigned char severity_code)
441 {
442 char *retval = NULL;
443
444 if ((severity_code < (unsigned char) TW_AEN_SEVERITY_ERROR) ||
445 (severity_code > (unsigned char) TW_AEN_SEVERITY_DEBUG))
446 goto out;
447
448 retval = twa_aen_severity_table[severity_code];
449 out:
450 return retval;
451 } /* End twa_aen_severity_lookup() */
452
453 /* This function will sync firmware time with the host time */
454 static void twa_aen_sync_time(TW_Device_Extension *tw_dev, int request_id)
455 {
456 u32 schedulertime;
457 struct timeval utc;
458 TW_Command_Full *full_command_packet;
459 TW_Command *command_packet;
460 TW_Param_Apache *param;
461 u32 local_time;
462
463 /* Fill out the command packet */
464 full_command_packet = tw_dev->command_packet_virt[request_id];
465 memset(full_command_packet, 0, sizeof(TW_Command_Full));
466 command_packet = &full_command_packet->command.oldcommand;
467 command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_SET_PARAM);
468 command_packet->request_id = request_id;
469 command_packet->byte8_offset.param.sgl[0].address = TW_CPU_TO_SGL(tw_dev->generic_buffer_phys[request_id]);
470 command_packet->byte8_offset.param.sgl[0].length = cpu_to_le32(TW_SECTOR_SIZE);
471 command_packet->size = TW_COMMAND_SIZE;
472 command_packet->byte6_offset.parameter_count = cpu_to_le16(1);
473
474 /* Setup the param */
475 param = (TW_Param_Apache *)tw_dev->generic_buffer_virt[request_id];
476 memset(param, 0, TW_SECTOR_SIZE);
477 param->table_id = cpu_to_le16(TW_TIMEKEEP_TABLE | 0x8000); /* Controller time keep table */
478 param->parameter_id = cpu_to_le16(0x3); /* SchedulerTime */
479 param->parameter_size_bytes = cpu_to_le16(4);
480
481 /* Convert system time in UTC to local time seconds since last
482 Sunday 12:00AM */
483 do_gettimeofday(&utc);
484 local_time = (u32)(utc.tv_sec - (sys_tz.tz_minuteswest * 60));
485 schedulertime = local_time - (3 * 86400);
486 schedulertime = cpu_to_le32(schedulertime % 604800);
487
488 memcpy(param->data, &schedulertime, sizeof(u32));
489
490 /* Mark internal command */
491 tw_dev->srb[request_id] = NULL;
492
493 /* Now post the command */
494 twa_post_command_packet(tw_dev, request_id, 1);
495 } /* End twa_aen_sync_time() */
496
497 /* This function will allocate memory and check if it is correctly aligned */
498 static int twa_allocate_memory(TW_Device_Extension *tw_dev, int size, int which)
499 {
500 int i;
501 dma_addr_t dma_handle;
502 unsigned long *cpu_addr;
503 int retval = 1;
504
505 cpu_addr = pci_alloc_consistent(tw_dev->tw_pci_dev, size*TW_Q_LENGTH, &dma_handle);
506 if (!cpu_addr) {
507 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x5, "Memory allocation failed");
508 goto out;
509 }
510
511 if ((unsigned long)cpu_addr % (TW_ALIGNMENT_9000)) {
512 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x6, "Failed to allocate correctly aligned memory");
513 pci_free_consistent(tw_dev->tw_pci_dev, size*TW_Q_LENGTH, cpu_addr, dma_handle);
514 goto out;
515 }
516
517 memset(cpu_addr, 0, size*TW_Q_LENGTH);
518
519 for (i = 0; i < TW_Q_LENGTH; i++) {
520 switch(which) {
521 case 0:
522 tw_dev->command_packet_phys[i] = dma_handle+(i*size);
523 tw_dev->command_packet_virt[i] = (TW_Command_Full *)((unsigned char *)cpu_addr + (i*size));
524 break;
525 case 1:
526 tw_dev->generic_buffer_phys[i] = dma_handle+(i*size);
527 tw_dev->generic_buffer_virt[i] = (unsigned long *)((unsigned char *)cpu_addr + (i*size));
528 break;
529 }
530 }
531 retval = 0;
532 out:
533 return retval;
534 } /* End twa_allocate_memory() */
535
536 /* This function will check the status register for unexpected bits */
537 static int twa_check_bits(u32 status_reg_value)
538 {
539 int retval = 1;
540
541 if ((status_reg_value & TW_STATUS_EXPECTED_BITS) != TW_STATUS_EXPECTED_BITS)
542 goto out;
543 if ((status_reg_value & TW_STATUS_UNEXPECTED_BITS) != 0)
544 goto out;
545
546 retval = 0;
547 out:
548 return retval;
549 } /* End twa_check_bits() */
550
551 /* This function will check the srl and decide if we are compatible */
552 static int twa_check_srl(TW_Device_Extension *tw_dev, int *flashed)
553 {
554 int retval = 1;
555 unsigned short fw_on_ctlr_srl = 0, fw_on_ctlr_arch_id = 0;
556 unsigned short fw_on_ctlr_branch = 0, fw_on_ctlr_build = 0;
557 u32 init_connect_result = 0;
558
559 if (twa_initconnection(tw_dev, TW_INIT_MESSAGE_CREDITS,
560 TW_EXTENDED_INIT_CONNECT, TW_CURRENT_DRIVER_SRL,
561 TW_9000_ARCH_ID, TW_CURRENT_DRIVER_BRANCH,
562 TW_CURRENT_DRIVER_BUILD, &fw_on_ctlr_srl,
563 &fw_on_ctlr_arch_id, &fw_on_ctlr_branch,
564 &fw_on_ctlr_build, &init_connect_result)) {
565 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x7, "Initconnection failed while checking SRL");
566 goto out;
567 }
568
569 tw_dev->working_srl = fw_on_ctlr_srl;
570 tw_dev->working_branch = fw_on_ctlr_branch;
571 tw_dev->working_build = fw_on_ctlr_build;
572
573 /* Try base mode compatibility */
574 if (!(init_connect_result & TW_CTLR_FW_COMPATIBLE)) {
575 if (twa_initconnection(tw_dev, TW_INIT_MESSAGE_CREDITS,
576 TW_EXTENDED_INIT_CONNECT,
577 TW_BASE_FW_SRL, TW_9000_ARCH_ID,
578 TW_BASE_FW_BRANCH, TW_BASE_FW_BUILD,
579 &fw_on_ctlr_srl, &fw_on_ctlr_arch_id,
580 &fw_on_ctlr_branch, &fw_on_ctlr_build,
581 &init_connect_result)) {
582 TW_PRINTK(tw_dev->host, TW_DRIVER, 0xa, "Initconnection (base mode) failed while checking SRL");
583 goto out;
584 }
585 if (!(init_connect_result & TW_CTLR_FW_COMPATIBLE)) {
586 if (TW_CURRENT_DRIVER_SRL > fw_on_ctlr_srl) {
587 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x32, "Firmware and driver incompatibility: please upgrade firmware");
588 } else {
589 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x33, "Firmware and driver incompatibility: please upgrade driver");
590 }
591 goto out;
592 }
593 tw_dev->working_srl = TW_BASE_FW_SRL;
594 tw_dev->working_branch = TW_BASE_FW_BRANCH;
595 tw_dev->working_build = TW_BASE_FW_BUILD;
596 }
597 retval = 0;
598 out:
599 return retval;
600 } /* End twa_check_srl() */
601
602 /* This function handles ioctl for the character device */
603 static int twa_chrdev_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
604 {
605 long timeout;
606 unsigned long *cpu_addr, data_buffer_length_adjusted = 0, flags = 0;
607 dma_addr_t dma_handle;
608 int request_id = 0;
609 unsigned int sequence_id = 0;
610 unsigned char event_index, start_index;
611 TW_Ioctl_Driver_Command driver_command;
612 TW_Ioctl_Buf_Apache *tw_ioctl;
613 TW_Lock *tw_lock;
614 TW_Command_Full *full_command_packet;
615 TW_Compatibility_Info *tw_compat_info;
616 TW_Event *event;
617 struct timeval current_time;
618 u32 current_time_ms;
619 TW_Device_Extension *tw_dev = twa_device_extension_list[iminor(inode)];
620 int retval = TW_IOCTL_ERROR_OS_EFAULT;
621 void __user *argp = (void __user *)arg;
622
623 /* Only let one of these through at a time */
624 if (mutex_lock_interruptible(&tw_dev->ioctl_lock)) {
625 retval = TW_IOCTL_ERROR_OS_EINTR;
626 goto out;
627 }
628
629 /* First copy down the driver command */
630 if (copy_from_user(&driver_command, argp, sizeof(TW_Ioctl_Driver_Command)))
631 goto out2;
632
633 /* Check data buffer size */
634 if (driver_command.buffer_length > TW_MAX_SECTORS * 512) {
635 retval = TW_IOCTL_ERROR_OS_EINVAL;
636 goto out2;
637 }
638
639 /* Hardware can only do multiple of 512 byte transfers */
640 data_buffer_length_adjusted = (driver_command.buffer_length + 511) & ~511;
641
642 /* Now allocate ioctl buf memory */
643 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);
644 if (!cpu_addr) {
645 retval = TW_IOCTL_ERROR_OS_ENOMEM;
646 goto out2;
647 }
648
649 tw_ioctl = (TW_Ioctl_Buf_Apache *)cpu_addr;
650
651 /* Now copy down the entire ioctl */
652 if (copy_from_user(tw_ioctl, argp, driver_command.buffer_length + sizeof(TW_Ioctl_Buf_Apache) - 1))
653 goto out3;
654
655 /* See which ioctl we are doing */
656 switch (cmd) {
657 case TW_IOCTL_FIRMWARE_PASS_THROUGH:
658 spin_lock_irqsave(tw_dev->host->host_lock, flags);
659 twa_get_request_id(tw_dev, &request_id);
660
661 /* Flag internal command */
662 tw_dev->srb[request_id] = NULL;
663
664 /* Flag chrdev ioctl */
665 tw_dev->chrdev_request_id = request_id;
666
667 full_command_packet = &tw_ioctl->firmware_command;
668
669 /* Load request id and sglist for both command types */
670 twa_load_sgl(full_command_packet, request_id, dma_handle, data_buffer_length_adjusted);
671
672 memcpy(tw_dev->command_packet_virt[request_id], &(tw_ioctl->firmware_command), sizeof(TW_Command_Full));
673
674 /* Now post the command packet to the controller */
675 twa_post_command_packet(tw_dev, request_id, 1);
676 spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
677
678 timeout = TW_IOCTL_CHRDEV_TIMEOUT*HZ;
679
680 /* Now wait for command to complete */
681 timeout = wait_event_timeout(tw_dev->ioctl_wqueue, tw_dev->chrdev_request_id == TW_IOCTL_CHRDEV_FREE, timeout);
682
683 /* See if we reset while waiting for the ioctl to complete */
684 if (test_bit(TW_IN_RESET, &tw_dev->flags)) {
685 clear_bit(TW_IN_RESET, &tw_dev->flags);
686 retval = TW_IOCTL_ERROR_OS_ERESTARTSYS;
687 goto out3;
688 }
689
690 /* We timed out, and didn't get an interrupt */
691 if (tw_dev->chrdev_request_id != TW_IOCTL_CHRDEV_FREE) {
692 /* Now we need to reset the board */
693 printk(KERN_WARNING "3w-9xxx: scsi%d: WARNING: (0x%02X:0x%04X): Character ioctl (0x%x) timed out, resetting card.\n",
694 tw_dev->host->host_no, TW_DRIVER, 0xc,
695 cmd);
696 retval = TW_IOCTL_ERROR_OS_EIO;
697 spin_lock_irqsave(tw_dev->host->host_lock, flags);
698 tw_dev->state[request_id] = TW_S_COMPLETED;
699 twa_free_request_id(tw_dev, request_id);
700 tw_dev->posted_request_count--;
701 spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
702 twa_reset_device_extension(tw_dev, 1);
703 goto out3;
704 }
705
706 /* Now copy in the command packet response */
707 memcpy(&(tw_ioctl->firmware_command), tw_dev->command_packet_virt[request_id], sizeof(TW_Command_Full));
708
709 /* Now complete the io */
710 spin_lock_irqsave(tw_dev->host->host_lock, flags);
711 tw_dev->posted_request_count--;
712 tw_dev->state[request_id] = TW_S_COMPLETED;
713 twa_free_request_id(tw_dev, request_id);
714 spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
715 break;
716 case TW_IOCTL_GET_COMPATIBILITY_INFO:
717 tw_ioctl->driver_command.status = 0;
718 /* Copy compatiblity struct into ioctl data buffer */
719 tw_compat_info = (TW_Compatibility_Info *)tw_ioctl->data_buffer;
720 strncpy(tw_compat_info->driver_version, TW_DRIVER_VERSION, strlen(TW_DRIVER_VERSION));
721 tw_compat_info->working_srl = tw_dev->working_srl;
722 tw_compat_info->working_branch = tw_dev->working_branch;
723 tw_compat_info->working_build = tw_dev->working_build;
724 tw_compat_info->driver_srl_high = TW_CURRENT_DRIVER_SRL;
725 tw_compat_info->driver_branch_high = TW_CURRENT_DRIVER_BRANCH;
726 tw_compat_info->driver_build_high = TW_CURRENT_DRIVER_BUILD;
727 tw_compat_info->driver_srl_low = TW_BASE_FW_SRL;
728 tw_compat_info->driver_branch_low = TW_BASE_FW_BRANCH;
729 tw_compat_info->driver_build_low = TW_BASE_FW_BUILD;
730 break;
731 case TW_IOCTL_GET_LAST_EVENT:
732 if (tw_dev->event_queue_wrapped) {
733 if (tw_dev->aen_clobber) {
734 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_AEN_CLOBBER;
735 tw_dev->aen_clobber = 0;
736 } else
737 tw_ioctl->driver_command.status = 0;
738 } else {
739 if (!tw_dev->error_index) {
740 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS;
741 break;
742 }
743 tw_ioctl->driver_command.status = 0;
744 }
745 event_index = (tw_dev->error_index - 1 + TW_Q_LENGTH) % TW_Q_LENGTH;
746 memcpy(tw_ioctl->data_buffer, tw_dev->event_queue[event_index], sizeof(TW_Event));
747 tw_dev->event_queue[event_index]->retrieved = TW_AEN_RETRIEVED;
748 break;
749 case TW_IOCTL_GET_FIRST_EVENT:
750 if (tw_dev->event_queue_wrapped) {
751 if (tw_dev->aen_clobber) {
752 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_AEN_CLOBBER;
753 tw_dev->aen_clobber = 0;
754 } else
755 tw_ioctl->driver_command.status = 0;
756 event_index = tw_dev->error_index;
757 } else {
758 if (!tw_dev->error_index) {
759 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS;
760 break;
761 }
762 tw_ioctl->driver_command.status = 0;
763 event_index = 0;
764 }
765 memcpy(tw_ioctl->data_buffer, tw_dev->event_queue[event_index], sizeof(TW_Event));
766 tw_dev->event_queue[event_index]->retrieved = TW_AEN_RETRIEVED;
767 break;
768 case TW_IOCTL_GET_NEXT_EVENT:
769 event = (TW_Event *)tw_ioctl->data_buffer;
770 sequence_id = event->sequence_id;
771 tw_ioctl->driver_command.status = 0;
772
773 if (tw_dev->event_queue_wrapped) {
774 if (tw_dev->aen_clobber) {
775 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_AEN_CLOBBER;
776 tw_dev->aen_clobber = 0;
777 }
778 start_index = tw_dev->error_index;
779 } else {
780 if (!tw_dev->error_index) {
781 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS;
782 break;
783 }
784 start_index = 0;
785 }
786 event_index = (start_index + sequence_id - tw_dev->event_queue[start_index]->sequence_id + 1) % TW_Q_LENGTH;
787
788 if (!(tw_dev->event_queue[event_index]->sequence_id > sequence_id)) {
789 if (tw_ioctl->driver_command.status == TW_IOCTL_ERROR_STATUS_AEN_CLOBBER)
790 tw_dev->aen_clobber = 1;
791 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS;
792 break;
793 }
794 memcpy(tw_ioctl->data_buffer, tw_dev->event_queue[event_index], sizeof(TW_Event));
795 tw_dev->event_queue[event_index]->retrieved = TW_AEN_RETRIEVED;
796 break;
797 case TW_IOCTL_GET_PREVIOUS_EVENT:
798 event = (TW_Event *)tw_ioctl->data_buffer;
799 sequence_id = event->sequence_id;
800 tw_ioctl->driver_command.status = 0;
801
802 if (tw_dev->event_queue_wrapped) {
803 if (tw_dev->aen_clobber) {
804 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_AEN_CLOBBER;
805 tw_dev->aen_clobber = 0;
806 }
807 start_index = tw_dev->error_index;
808 } else {
809 if (!tw_dev->error_index) {
810 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS;
811 break;
812 }
813 start_index = 0;
814 }
815 event_index = (start_index + sequence_id - tw_dev->event_queue[start_index]->sequence_id - 1) % TW_Q_LENGTH;
816
817 if (!(tw_dev->event_queue[event_index]->sequence_id < sequence_id)) {
818 if (tw_ioctl->driver_command.status == TW_IOCTL_ERROR_STATUS_AEN_CLOBBER)
819 tw_dev->aen_clobber = 1;
820 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS;
821 break;
822 }
823 memcpy(tw_ioctl->data_buffer, tw_dev->event_queue[event_index], sizeof(TW_Event));
824 tw_dev->event_queue[event_index]->retrieved = TW_AEN_RETRIEVED;
825 break;
826 case TW_IOCTL_GET_LOCK:
827 tw_lock = (TW_Lock *)tw_ioctl->data_buffer;
828 do_gettimeofday(&current_time);
829 current_time_ms = (current_time.tv_sec * 1000) + (current_time.tv_usec / 1000);
830
831 if ((tw_lock->force_flag == 1) || (tw_dev->ioctl_sem_lock == 0) || (current_time_ms >= tw_dev->ioctl_msec)) {
832 tw_dev->ioctl_sem_lock = 1;
833 tw_dev->ioctl_msec = current_time_ms + tw_lock->timeout_msec;
834 tw_ioctl->driver_command.status = 0;
835 tw_lock->time_remaining_msec = tw_lock->timeout_msec;
836 } else {
837 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_LOCKED;
838 tw_lock->time_remaining_msec = tw_dev->ioctl_msec - current_time_ms;
839 }
840 break;
841 case TW_IOCTL_RELEASE_LOCK:
842 if (tw_dev->ioctl_sem_lock == 1) {
843 tw_dev->ioctl_sem_lock = 0;
844 tw_ioctl->driver_command.status = 0;
845 } else {
846 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NOT_LOCKED;
847 }
848 break;
849 default:
850 retval = TW_IOCTL_ERROR_OS_ENOTTY;
851 goto out3;
852 }
853
854 /* Now copy the entire response to userspace */
855 if (copy_to_user(argp, tw_ioctl, sizeof(TW_Ioctl_Buf_Apache) + driver_command.buffer_length - 1) == 0)
856 retval = 0;
857 out3:
858 /* Now free ioctl buf memory */
859 dma_free_coherent(&tw_dev->tw_pci_dev->dev, data_buffer_length_adjusted+sizeof(TW_Ioctl_Buf_Apache) - 1, cpu_addr, dma_handle);
860 out2:
861 mutex_unlock(&tw_dev->ioctl_lock);
862 out:
863 return retval;
864 } /* End twa_chrdev_ioctl() */
865
866 /* This function handles open for the character device */
867 static int twa_chrdev_open(struct inode *inode, struct file *file)
868 {
869 unsigned int minor_number;
870 int retval = TW_IOCTL_ERROR_OS_ENODEV;
871
872 minor_number = iminor(inode);
873 if (minor_number >= twa_device_extension_count)
874 goto out;
875 retval = 0;
876 out:
877 return retval;
878 } /* End twa_chrdev_open() */
879
880 /* This function will print readable messages from status register errors */
881 static int twa_decode_bits(TW_Device_Extension *tw_dev, u32 status_reg_value)
882 {
883 int retval = 1;
884
885 /* Check for various error conditions and handle them appropriately */
886 if (status_reg_value & TW_STATUS_PCI_PARITY_ERROR) {
887 TW_PRINTK(tw_dev->host, TW_DRIVER, 0xc, "PCI Parity Error: clearing");
888 writel(TW_CONTROL_CLEAR_PARITY_ERROR, TW_CONTROL_REG_ADDR(tw_dev));
889 }
890
891 if (status_reg_value & TW_STATUS_PCI_ABORT) {
892 TW_PRINTK(tw_dev->host, TW_DRIVER, 0xd, "PCI Abort: clearing");
893 writel(TW_CONTROL_CLEAR_PCI_ABORT, TW_CONTROL_REG_ADDR(tw_dev));
894 pci_write_config_word(tw_dev->tw_pci_dev, PCI_STATUS, TW_PCI_CLEAR_PCI_ABORT);
895 }
896
897 if (status_reg_value & TW_STATUS_QUEUE_ERROR) {
898 TW_PRINTK(tw_dev->host, TW_DRIVER, 0xe, "Controller Queue Error: clearing");
899 writel(TW_CONTROL_CLEAR_QUEUE_ERROR, TW_CONTROL_REG_ADDR(tw_dev));
900 }
901
902 if (status_reg_value & TW_STATUS_MICROCONTROLLER_ERROR) {
903 if (tw_dev->reset_print == 0) {
904 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x10, "Microcontroller Error: clearing");
905 tw_dev->reset_print = 1;
906 }
907 goto out;
908 }
909 retval = 0;
910 out:
911 return retval;
912 } /* End twa_decode_bits() */
913
914 /* This function will empty the response queue */
915 static int twa_empty_response_queue(TW_Device_Extension *tw_dev)
916 {
917 u32 status_reg_value, response_que_value;
918 int count = 0, retval = 1;
919
920 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
921
922 while (((status_reg_value & TW_STATUS_RESPONSE_QUEUE_EMPTY) == 0) && (count < TW_MAX_RESPONSE_DRAIN)) {
923 response_que_value = readl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev));
924 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
925 count++;
926 }
927 if (count == TW_MAX_RESPONSE_DRAIN)
928 goto out;
929
930 retval = 0;
931 out:
932 return retval;
933 } /* End twa_empty_response_queue() */
934
935 /* This function will clear the pchip/response queue on 9550SX */
936 static int twa_empty_response_queue_large(TW_Device_Extension *tw_dev)
937 {
938 u32 response_que_value = 0;
939 unsigned long before;
940 int retval = 1;
941
942 if (tw_dev->tw_pci_dev->device == PCI_DEVICE_ID_3WARE_9550SX) {
943 before = jiffies;
944 while ((response_que_value & TW_9550SX_DRAIN_COMPLETED) != TW_9550SX_DRAIN_COMPLETED) {
945 response_que_value = readl(TW_RESPONSE_QUEUE_REG_ADDR_LARGE(tw_dev));
946 if (time_after(jiffies, before + HZ * 30))
947 goto out;
948 }
949 /* P-chip settle time */
950 msleep(500);
951 retval = 0;
952 } else
953 retval = 0;
954 out:
955 return retval;
956 } /* End twa_empty_response_queue_large() */
957
958 /* This function passes sense keys from firmware to scsi layer */
959 static int twa_fill_sense(TW_Device_Extension *tw_dev, int request_id, int copy_sense, int print_host)
960 {
961 TW_Command_Full *full_command_packet;
962 unsigned short error;
963 int retval = 1;
964 char *error_str;
965
966 full_command_packet = tw_dev->command_packet_virt[request_id];
967
968 /* Check for embedded error string */
969 error_str = &(full_command_packet->header.err_specific_desc[strlen(full_command_packet->header.err_specific_desc) + 1]);
970
971 /* Don't print error for Logical unit not supported during rollcall */
972 error = le16_to_cpu(full_command_packet->header.status_block.error);
973 if ((error != TW_ERROR_LOGICAL_UNIT_NOT_SUPPORTED) && (error != TW_ERROR_UNIT_OFFLINE)) {
974 if (print_host)
975 printk(KERN_WARNING "3w-9xxx: scsi%d: ERROR: (0x%02X:0x%04X): %s:%s.\n",
976 tw_dev->host->host_no,
977 TW_MESSAGE_SOURCE_CONTROLLER_ERROR,
978 full_command_packet->header.status_block.error,
979 error_str[0] == '\0' ?
980 twa_string_lookup(twa_error_table,
981 full_command_packet->header.status_block.error) : error_str,
982 full_command_packet->header.err_specific_desc);
983 else
984 printk(KERN_WARNING "3w-9xxx: ERROR: (0x%02X:0x%04X): %s:%s.\n",
985 TW_MESSAGE_SOURCE_CONTROLLER_ERROR,
986 full_command_packet->header.status_block.error,
987 error_str[0] == '\0' ?
988 twa_string_lookup(twa_error_table,
989 full_command_packet->header.status_block.error) : error_str,
990 full_command_packet->header.err_specific_desc);
991 }
992
993 if (copy_sense) {
994 memcpy(tw_dev->srb[request_id]->sense_buffer, full_command_packet->header.sense_data, TW_SENSE_DATA_LENGTH);
995 tw_dev->srb[request_id]->result = (full_command_packet->command.newcommand.status << 1);
996 retval = TW_ISR_DONT_RESULT;
997 goto out;
998 }
999 retval = 0;
1000 out:
1001 return retval;
1002 } /* End twa_fill_sense() */
1003
1004 /* This function will free up device extension resources */
1005 static void twa_free_device_extension(TW_Device_Extension *tw_dev)
1006 {
1007 if (tw_dev->command_packet_virt[0])
1008 pci_free_consistent(tw_dev->tw_pci_dev,
1009 sizeof(TW_Command_Full)*TW_Q_LENGTH,
1010 tw_dev->command_packet_virt[0],
1011 tw_dev->command_packet_phys[0]);
1012
1013 if (tw_dev->generic_buffer_virt[0])
1014 pci_free_consistent(tw_dev->tw_pci_dev,
1015 TW_SECTOR_SIZE*TW_Q_LENGTH,
1016 tw_dev->generic_buffer_virt[0],
1017 tw_dev->generic_buffer_phys[0]);
1018
1019 kfree(tw_dev->event_queue[0]);
1020 } /* End twa_free_device_extension() */
1021
1022 /* This function will free a request id */
1023 static void twa_free_request_id(TW_Device_Extension *tw_dev, int request_id)
1024 {
1025 tw_dev->free_queue[tw_dev->free_tail] = request_id;
1026 tw_dev->state[request_id] = TW_S_FINISHED;
1027 tw_dev->free_tail = (tw_dev->free_tail + 1) % TW_Q_LENGTH;
1028 } /* End twa_free_request_id() */
1029
1030 /* This function will get parameter table entries from the firmware */
1031 static void *twa_get_param(TW_Device_Extension *tw_dev, int request_id, int table_id, int parameter_id, int parameter_size_bytes)
1032 {
1033 TW_Command_Full *full_command_packet;
1034 TW_Command *command_packet;
1035 TW_Param_Apache *param;
1036 unsigned long param_value;
1037 void *retval = NULL;
1038
1039 /* Setup the command packet */
1040 full_command_packet = tw_dev->command_packet_virt[request_id];
1041 memset(full_command_packet, 0, sizeof(TW_Command_Full));
1042 command_packet = &full_command_packet->command.oldcommand;
1043
1044 command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_GET_PARAM);
1045 command_packet->size = TW_COMMAND_SIZE;
1046 command_packet->request_id = request_id;
1047 command_packet->byte6_offset.block_count = cpu_to_le16(1);
1048
1049 /* Now setup the param */
1050 param = (TW_Param_Apache *)tw_dev->generic_buffer_virt[request_id];
1051 memset(param, 0, TW_SECTOR_SIZE);
1052 param->table_id = cpu_to_le16(table_id | 0x8000);
1053 param->parameter_id = cpu_to_le16(parameter_id);
1054 param->parameter_size_bytes = cpu_to_le16(parameter_size_bytes);
1055 param_value = tw_dev->generic_buffer_phys[request_id];
1056
1057 command_packet->byte8_offset.param.sgl[0].address = TW_CPU_TO_SGL(param_value);
1058 command_packet->byte8_offset.param.sgl[0].length = cpu_to_le32(TW_SECTOR_SIZE);
1059
1060 /* Post the command packet to the board */
1061 twa_post_command_packet(tw_dev, request_id, 1);
1062
1063 /* Poll for completion */
1064 if (twa_poll_response(tw_dev, request_id, 30))
1065 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x13, "No valid response during get param")
1066 else
1067 retval = (void *)&(param->data[0]);
1068
1069 tw_dev->posted_request_count--;
1070 tw_dev->state[request_id] = TW_S_INITIAL;
1071
1072 return retval;
1073 } /* End twa_get_param() */
1074
1075 /* This function will assign an available request id */
1076 static void twa_get_request_id(TW_Device_Extension *tw_dev, int *request_id)
1077 {
1078 *request_id = tw_dev->free_queue[tw_dev->free_head];
1079 tw_dev->free_head = (tw_dev->free_head + 1) % TW_Q_LENGTH;
1080 tw_dev->state[*request_id] = TW_S_STARTED;
1081 } /* End twa_get_request_id() */
1082
1083 /* This function will send an initconnection command to controller */
1084 static int twa_initconnection(TW_Device_Extension *tw_dev, int message_credits,
1085 u32 set_features, unsigned short current_fw_srl,
1086 unsigned short current_fw_arch_id,
1087 unsigned short current_fw_branch,
1088 unsigned short current_fw_build,
1089 unsigned short *fw_on_ctlr_srl,
1090 unsigned short *fw_on_ctlr_arch_id,
1091 unsigned short *fw_on_ctlr_branch,
1092 unsigned short *fw_on_ctlr_build,
1093 u32 *init_connect_result)
1094 {
1095 TW_Command_Full *full_command_packet;
1096 TW_Initconnect *tw_initconnect;
1097 int request_id = 0, retval = 1;
1098
1099 /* Initialize InitConnection command packet */
1100 full_command_packet = tw_dev->command_packet_virt[request_id];
1101 memset(full_command_packet, 0, sizeof(TW_Command_Full));
1102 full_command_packet->header.header_desc.size_header = 128;
1103
1104 tw_initconnect = (TW_Initconnect *)&full_command_packet->command.oldcommand;
1105 tw_initconnect->opcode__reserved = TW_OPRES_IN(0, TW_OP_INIT_CONNECTION);
1106 tw_initconnect->request_id = request_id;
1107 tw_initconnect->message_credits = cpu_to_le16(message_credits);
1108 tw_initconnect->features = set_features;
1109
1110 /* Turn on 64-bit sgl support if we need to */
1111 tw_initconnect->features |= sizeof(dma_addr_t) > 4 ? 1 : 0;
1112
1113 tw_initconnect->features = cpu_to_le32(tw_initconnect->features);
1114
1115 if (set_features & TW_EXTENDED_INIT_CONNECT) {
1116 tw_initconnect->size = TW_INIT_COMMAND_PACKET_SIZE_EXTENDED;
1117 tw_initconnect->fw_srl = cpu_to_le16(current_fw_srl);
1118 tw_initconnect->fw_arch_id = cpu_to_le16(current_fw_arch_id);
1119 tw_initconnect->fw_branch = cpu_to_le16(current_fw_branch);
1120 tw_initconnect->fw_build = cpu_to_le16(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 = le16_to_cpu(tw_initconnect->fw_srl);
1133 *fw_on_ctlr_arch_id = le16_to_cpu(tw_initconnect->fw_arch_id);
1134 *fw_on_ctlr_branch = le16_to_cpu(tw_initconnect->fw_branch);
1135 *fw_on_ctlr_build = le16_to_cpu(tw_initconnect->fw_build);
1136 *init_connect_result = le32_to_cpu(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 = TW_CPU_TO_SGL(dma_handle + sizeof(TW_Ioctl_Buf_Apache) - 1);
1361 newcommand->sg_list[0].length = cpu_to_le32(length);
1362 newcommand->sgl_entries__lunh =
1363 cpu_to_le16(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 = TW_CPU_TO_SGL(dma_handle + sizeof(TW_Ioctl_Buf_Apache) - 1);
1372 sgl->length = cpu_to_le32(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 dma_addr_t 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 dma_addr_t 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 cpu_to_le16(TW_REQ_LUN_IN(srb->device->lun, request_id));
1831 } else {
1832 command_packet->request_id__lunl =
1833 cpu_to_le16(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_CPU_TO_SGL(tw_dev->generic_buffer_phys[request_id]);
1844 command_packet->sg_list[0].length = cpu_to_le32(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 = TW_CPU_TO_SGL(buffaddr);
1853 command_packet->sg_list[0].length = cpu_to_le32(tw_dev->srb[request_id]->request_bufflen);
1854 }
1855 command_packet->sgl_entries__lunh = cpu_to_le16(TW_REQ_LUN_IN((srb->device->lun >> 4), 1));
1856
1857 if (command_packet->sg_list[0].address & TW_CPU_TO_SGL(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_CPU_TO_SGL(tw_dev->generic_buffer_phys[request_id]);
1872 command_packet->sg_list[0].length = cpu_to_le32(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 = TW_CPU_TO_SGL(sg_dma_address(&sglist[i]));
1880 command_packet->sg_list[i].length = cpu_to_le32(sg_dma_len(&sglist[i]));
1881 if (command_packet->sg_list[i].address & TW_CPU_TO_SGL(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 = cpu_to_le16(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 = TW_CPU_TO_SGL(sglistarg[i].address);
1893 command_packet->sg_list[i].length = cpu_to_le32(sglistarg[i].length);
1894 if (command_packet->sg_list[i].address & TW_CPU_TO_SGL(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 = cpu_to_le16(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;
1947 unsigned long flags = 0;
1948 local_irq_save(flags);
1949 buf = kmap_atomic(sg->page, KM_IRQ0) + sg->offset;
1950 memcpy(buf, tw_dev->generic_buffer_virt[request_id], sg->length);
1951 kunmap_atomic(buf - sg->offset, KM_IRQ0);
1952 local_irq_restore(flags);
1953 }
1954 }
1955 } /* End twa_scsiop_execute_scsi_complete() */
1956
1957 /* This function tells the controller to shut down */
1958 static void __twa_shutdown(TW_Device_Extension *tw_dev)
1959 {
1960 /* Disable interrupts */
1961 TW_DISABLE_INTERRUPTS(tw_dev);
1962
1963 printk(KERN_WARNING "3w-9xxx: Shutting down host %d.\n", tw_dev->host->host_no);
1964
1965 /* Tell the card we are shutting down */
1966 if (twa_initconnection(tw_dev, 1, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL)) {
1967 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x31, "Connection shutdown failed");
1968 } else {
1969 printk(KERN_WARNING "3w-9xxx: Shutdown complete.\n");
1970 }
1971
1972 /* Clear all interrupts just before exit */
1973 TW_CLEAR_ALL_INTERRUPTS(tw_dev);
1974 } /* End __twa_shutdown() */
1975
1976 /* Wrapper for __twa_shutdown */
1977 static void twa_shutdown(struct pci_dev *pdev)
1978 {
1979 struct Scsi_Host *host = pci_get_drvdata(pdev);
1980 TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
1981
1982 __twa_shutdown(tw_dev);
1983 } /* End twa_shutdown() */
1984
1985 /* This function will look up a string */
1986 static char *twa_string_lookup(twa_message_type *table, unsigned int code)
1987 {
1988 int index;
1989
1990 for (index = 0; ((code != table[index].code) &&
1991 (table[index].text != (char *)0)); index++);
1992 return(table[index].text);
1993 } /* End twa_string_lookup() */
1994
1995 /* This function will perform a pci-dma unmap */
1996 static void twa_unmap_scsi_data(TW_Device_Extension *tw_dev, int request_id)
1997 {
1998 struct scsi_cmnd *cmd = tw_dev->srb[request_id];
1999 struct pci_dev *pdev = tw_dev->tw_pci_dev;
2000
2001 switch(cmd->SCp.phase) {
2002 case TW_PHASE_SINGLE:
2003 pci_unmap_single(pdev, cmd->SCp.have_data_in, cmd->request_bufflen, DMA_BIDIRECTIONAL);
2004 break;
2005 case TW_PHASE_SGLIST:
2006 pci_unmap_sg(pdev, cmd->request_buffer, cmd->use_sg, DMA_BIDIRECTIONAL);
2007 break;
2008 }
2009 } /* End twa_unmap_scsi_data() */
2010
2011 /* scsi_host_template initializer */
2012 static struct scsi_host_template driver_template = {
2013 .module = THIS_MODULE,
2014 .name = "3ware 9000 Storage Controller",
2015 .queuecommand = twa_scsi_queue,
2016 .eh_host_reset_handler = twa_scsi_eh_reset,
2017 .bios_param = twa_scsi_biosparam,
2018 .change_queue_depth = twa_change_queue_depth,
2019 .can_queue = TW_Q_LENGTH-2,
2020 .this_id = -1,
2021 .sg_tablesize = TW_APACHE_MAX_SGL_LENGTH,
2022 .max_sectors = TW_MAX_SECTORS,
2023 .cmd_per_lun = TW_MAX_CMDS_PER_LUN,
2024 .use_clustering = ENABLE_CLUSTERING,
2025 .shost_attrs = twa_host_attrs,
2026 .emulated = 1
2027 };
2028
2029 /* This function will probe and initialize a card */
2030 static int __devinit twa_probe(struct pci_dev *pdev, const struct pci_device_id *dev_id)
2031 {
2032 struct Scsi_Host *host = NULL;
2033 TW_Device_Extension *tw_dev;
2034 u32 mem_addr;
2035 int retval = -ENODEV;
2036
2037 retval = pci_enable_device(pdev);
2038 if (retval) {
2039 TW_PRINTK(host, TW_DRIVER, 0x34, "Failed to enable pci device");
2040 goto out_disable_device;
2041 }
2042
2043 pci_set_master(pdev);
2044
2045 retval = pci_set_dma_mask(pdev, sizeof(dma_addr_t) > 4 ? DMA_64BIT_MASK : DMA_32BIT_MASK);
2046 if (retval) {
2047 TW_PRINTK(host, TW_DRIVER, 0x23, "Failed to set dma mask");
2048 goto out_disable_device;
2049 }
2050
2051 host = scsi_host_alloc(&driver_template, sizeof(TW_Device_Extension));
2052 if (!host) {
2053 TW_PRINTK(host, TW_DRIVER, 0x24, "Failed to allocate memory for device extension");
2054 retval = -ENOMEM;
2055 goto out_disable_device;
2056 }
2057 tw_dev = (TW_Device_Extension *)host->hostdata;
2058
2059 memset(tw_dev, 0, sizeof(TW_Device_Extension));
2060
2061 /* Save values to device extension */
2062 tw_dev->host = host;
2063 tw_dev->tw_pci_dev = pdev;
2064
2065 if (twa_initialize_device_extension(tw_dev)) {
2066 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x25, "Failed to initialize device extension");
2067 goto out_free_device_extension;
2068 }
2069
2070 /* Request IO regions */
2071 retval = pci_request_regions(pdev, "3w-9xxx");
2072 if (retval) {
2073 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x26, "Failed to get mem region");
2074 goto out_free_device_extension;
2075 }
2076
2077 if (pdev->device == PCI_DEVICE_ID_3WARE_9000)
2078 mem_addr = pci_resource_start(pdev, 1);
2079 else
2080 mem_addr = pci_resource_start(pdev, 2);
2081
2082 /* Save base address */
2083 tw_dev->base_addr = ioremap(mem_addr, PAGE_SIZE);
2084 if (!tw_dev->base_addr) {
2085 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x35, "Failed to ioremap");
2086 goto out_release_mem_region;
2087 }
2088
2089 /* Disable interrupts on the card */
2090 TW_DISABLE_INTERRUPTS(tw_dev);
2091
2092 /* Initialize the card */
2093 if (twa_reset_sequence(tw_dev, 0))
2094 goto out_release_mem_region;
2095
2096 /* Set host specific parameters */
2097 host->max_id = TW_MAX_UNITS;
2098 host->max_cmd_len = TW_MAX_CDB_LEN;
2099
2100 /* Channels aren't supported by adapter */
2101 host->max_lun = TW_MAX_LUNS(tw_dev->working_srl);
2102 host->max_channel = 0;
2103
2104 /* Register the card with the kernel SCSI layer */
2105 retval = scsi_add_host(host, &pdev->dev);
2106 if (retval) {
2107 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x27, "scsi add host failed");
2108 goto out_release_mem_region;
2109 }
2110
2111 pci_set_drvdata(pdev, host);
2112
2113 printk(KERN_WARNING "3w-9xxx: scsi%d: Found a 3ware 9000 Storage Controller at 0x%x, IRQ: %d.\n",
2114 host->host_no, mem_addr, pdev->irq);
2115 printk(KERN_WARNING "3w-9xxx: scsi%d: Firmware %s, BIOS %s, Ports: %d.\n",
2116 host->host_no,
2117 (char *)twa_get_param(tw_dev, 0, TW_VERSION_TABLE,
2118 TW_PARAM_FWVER, TW_PARAM_FWVER_LENGTH),
2119 (char *)twa_get_param(tw_dev, 1, TW_VERSION_TABLE,
2120 TW_PARAM_BIOSVER, TW_PARAM_BIOSVER_LENGTH),
2121 le32_to_cpu(*(int *)twa_get_param(tw_dev, 2, TW_INFORMATION_TABLE,
2122 TW_PARAM_PORTCOUNT, TW_PARAM_PORTCOUNT_LENGTH)));
2123
2124 /* Now setup the interrupt handler */
2125 retval = request_irq(pdev->irq, twa_interrupt, SA_SHIRQ, "3w-9xxx", tw_dev);
2126 if (retval) {
2127 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x30, "Error requesting IRQ");
2128 goto out_remove_host;
2129 }
2130
2131 twa_device_extension_list[twa_device_extension_count] = tw_dev;
2132 twa_device_extension_count++;
2133
2134 /* Re-enable interrupts on the card */
2135 TW_ENABLE_AND_CLEAR_INTERRUPTS(tw_dev);
2136
2137 /* Finally, scan the host */
2138 scsi_scan_host(host);
2139
2140 if (twa_major == -1) {
2141 if ((twa_major = register_chrdev (0, "twa", &twa_fops)) < 0)
2142 TW_PRINTK(host, TW_DRIVER, 0x29, "Failed to register character device");
2143 }
2144 return 0;
2145
2146 out_remove_host:
2147 scsi_remove_host(host);
2148 out_release_mem_region:
2149 pci_release_regions(pdev);
2150 out_free_device_extension:
2151 twa_free_device_extension(tw_dev);
2152 scsi_host_put(host);
2153 out_disable_device:
2154 pci_disable_device(pdev);
2155
2156 return retval;
2157 } /* End twa_probe() */
2158
2159 /* This function is called to remove a device */
2160 static void twa_remove(struct pci_dev *pdev)
2161 {
2162 struct Scsi_Host *host = pci_get_drvdata(pdev);
2163 TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
2164
2165 scsi_remove_host(tw_dev->host);
2166
2167 /* Unregister character device */
2168 if (twa_major >= 0) {
2169 unregister_chrdev(twa_major, "twa");
2170 twa_major = -1;
2171 }
2172
2173 /* Free up the IRQ */
2174 free_irq(tw_dev->tw_pci_dev->irq, tw_dev);
2175
2176 /* Shutdown the card */
2177 __twa_shutdown(tw_dev);
2178
2179 /* Free up the mem region */
2180 pci_release_regions(pdev);
2181
2182 /* Free up device extension resources */
2183 twa_free_device_extension(tw_dev);
2184
2185 scsi_host_put(tw_dev->host);
2186 pci_disable_device(pdev);
2187 twa_device_extension_count--;
2188 } /* End twa_remove() */
2189
2190 /* PCI Devices supported by this driver */
2191 static struct pci_device_id twa_pci_tbl[] __devinitdata = {
2192 { PCI_VENDOR_ID_3WARE, PCI_DEVICE_ID_3WARE_9000,
2193 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
2194 { PCI_VENDOR_ID_3WARE, PCI_DEVICE_ID_3WARE_9550SX,
2195 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
2196 { }
2197 };
2198 MODULE_DEVICE_TABLE(pci, twa_pci_tbl);
2199
2200 /* pci_driver initializer */
2201 static struct pci_driver twa_driver = {
2202 .name = "3w-9xxx",
2203 .id_table = twa_pci_tbl,
2204 .probe = twa_probe,
2205 .remove = twa_remove,
2206 .shutdown = twa_shutdown
2207 };
2208
2209 /* This function is called on driver initialization */
2210 static int __init twa_init(void)
2211 {
2212 printk(KERN_WARNING "3ware 9000 Storage Controller device driver for Linux v%s.\n", TW_DRIVER_VERSION);
2213
2214 return pci_module_init(&twa_driver);
2215 } /* End twa_init() */
2216
2217 /* This function is called on driver exit */
2218 static void __exit twa_exit(void)
2219 {
2220 pci_unregister_driver(&twa_driver);
2221 } /* End twa_exit() */
2222
2223 module_init(twa_init);
2224 module_exit(twa_exit);
2225
Linux with added FPC-III support