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