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