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