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