blob: b7bd5b0cc7aa450e23ebe7f8b0ddc10814b82f05 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 3w-9xxx.c -- 3ware 9000 Storage Controller device driver for Linux.
3
adam radford4deedd82010-03-08 12:37:46 -08004 Written By: Adam Radford <linuxraid@lsi.com>
5 Modifications By: Tom Couch <linuxraid@lsi.com>
Linus Torvalds1da177e2005-04-16 15:20:36 -07006
adam radford7a252fe2009-03-09 12:15:01 -08007 Copyright (C) 2004-2009 Applied Micro Circuits Corporation.
adam radford4deedd82010-03-08 12:37:46 -08008 Copyright (C) 2010 LSI Corporation.
Linus Torvalds1da177e2005-04-16 15:20:36 -07009
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:
adam radford4deedd82010-03-08 12:37:46 -080044 linuxraid@lsi.com
Linus Torvalds1da177e2005-04-16 15:20:36 -070045
46 For more information, goto:
adam radford4deedd82010-03-08 12:37:46 -080047 http://www.lsi.com
Linus Torvalds1da177e2005-04-16 15:20:36 -070048
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.
adam radfordd327d082005-09-09 15:55:13 -070064 2.26.02.003 - Correctly handle single sgl's with use_sg=1.
adam radford49bfd8d2005-09-21 17:20:14 -070065 2.26.02.004 - Add support for 9550SX controllers.
adam radford62288f12006-02-05 14:51:43 -080066 2.26.02.005 - Fix use_sg == 0 mapping on systems with 4GB or higher.
adam radford75913d92006-03-15 12:43:19 -080067 2.26.02.006 - Fix 9550SX pchip reset timeout.
68 Add big endian support.
adam radford1e08dcb2006-04-11 11:25:09 -070069 2.26.02.007 - Disable local interrupts during kmap/unmap_atomic().
adam radford4039c302006-10-26 18:01:06 -070070 2.26.02.008 - Free irq handler in __twa_shutdown().
71 Serialize reset code.
72 Add support for 9650SE controllers.
adam radford0e78d152007-07-20 15:28:28 -070073 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.
adam radford3dabec72008-07-22 16:47:40 -070075 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().
adam radford7a252fe2009-03-09 12:15:01 -080079 2.26.02.012 - Add power management support.
adam radford53ca3532009-12-10 11:53:31 -080080 2.26.02.013 - Fix bug in twa_load_sgl().
adam radford4deedd82010-03-08 12:37:46 -080081 2.26.02.014 - Force 60 second timeout default.
Linus Torvalds1da177e2005-04-16 15:20:36 -070082*/
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>
Jes Sorensena12e25b2006-01-11 08:39:45 -050094#include <linux/mutex.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090095#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070096#include <asm/io.h>
97#include <asm/irq.h>
98#include <asm/uaccess.h>
99#include <scsi/scsi.h>
100#include <scsi/scsi_host.h>
101#include <scsi/scsi_tcq.h>
102#include <scsi/scsi_cmnd.h>
103#include "3w-9xxx.h"
104
105/* Globals */
adam radford4deedd82010-03-08 12:37:46 -0800106#define TW_DRIVER_VERSION "2.26.02.014"
Arnd Bergmannc45d15d2010-06-02 14:28:52 +0200107static DEFINE_MUTEX(twa_chrdev_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108static TW_Device_Extension *twa_device_extension_list[TW_MAX_SLOT];
109static unsigned int twa_device_extension_count;
110static int twa_major = -1;
111extern struct timezone sys_tz;
112
113/* Module parameters */
adam radford4deedd82010-03-08 12:37:46 -0800114MODULE_AUTHOR ("LSI");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115MODULE_DESCRIPTION ("3ware 9000 Storage Controller Linux Driver");
116MODULE_LICENSE("GPL");
117MODULE_VERSION(TW_DRIVER_VERSION);
118
adam radford3dabec72008-07-22 16:47:40 -0700119static int use_msi = 0;
120module_param(use_msi, int, S_IRUGO);
121MODULE_PARM_DESC(use_msi, "Use Message Signaled Interrupts. Default: 0");
122
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123/* Function prototypes */
124static void twa_aen_queue_event(TW_Device_Extension *tw_dev, TW_Command_Apache_Header *header);
125static int twa_aen_read_queue(TW_Device_Extension *tw_dev, int request_id);
126static char *twa_aen_severity_lookup(unsigned char severity_code);
127static void twa_aen_sync_time(TW_Device_Extension *tw_dev, int request_id);
Arnd Bergmannf4927c42010-04-27 00:24:01 +0200128static long twa_chrdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129static int twa_chrdev_open(struct inode *inode, struct file *file);
130static int twa_fill_sense(TW_Device_Extension *tw_dev, int request_id, int copy_sense, int print_host);
131static void twa_free_request_id(TW_Device_Extension *tw_dev,int request_id);
132static void twa_get_request_id(TW_Device_Extension *tw_dev, int *request_id);
133static 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);
adam radford0e78d152007-07-20 15:28:28 -0700143static 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144static int twa_poll_response(TW_Device_Extension *tw_dev, int request_id, int seconds);
145static int twa_poll_status_gone(TW_Device_Extension *tw_dev, u32 flag, int seconds);
146static int twa_post_command_packet(TW_Device_Extension *tw_dev, int request_id, char internal);
adam radford0e78d152007-07-20 15:28:28 -0700147static int twa_reset_device_extension(TW_Device_Extension *tw_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148static int twa_reset_sequence(TW_Device_Extension *tw_dev, int soft_reset);
149static int twa_scsiop_execute_scsi(TW_Device_Extension *tw_dev, int request_id, char *cdb, int use_sg, TW_SG_Entry *sglistarg);
150static void twa_scsiop_execute_scsi_complete(TW_Device_Extension *tw_dev, int request_id);
151static char *twa_string_lookup(twa_message_type *table, unsigned int aen_code);
152static void twa_unmap_scsi_data(TW_Device_Extension *tw_dev, int request_id);
153
154/* Functions */
155
156/* Show some statistics about the card */
Tony Jonesee959b02008-02-22 00:13:36 +0100157static ssize_t twa_show_stats(struct device *dev,
158 struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159{
Tony Jonesee959b02008-02-22 00:13:36 +0100160 struct Scsi_Host *host = class_to_shost(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161 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 */
Mike Christiee881a172009-10-15 17:46:39 -0700193static int twa_change_queue_depth(struct scsi_device *sdev, int queue_depth,
194 int reason)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195{
Mike Christiee881a172009-10-15 17:46:39 -0700196 if (reason != SCSI_QDEPTH_DEFAULT)
197 return -EOPNOTSUPP;
198
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199 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 */
Tony Jonesee959b02008-02-22 00:13:36 +0100206static struct device_attribute twa_host_stats_attr = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207 .attr = {
208 .name = "stats",
209 .mode = S_IRUGO,
210 },
211 .show = twa_show_stats
212};
213
214/* Host attributes initializer */
Tony Jonesee959b02008-02-22 00:13:36 +0100215static struct device_attribute *twa_host_attrs[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216 &twa_host_stats_attr,
217 NULL,
218};
219
220/* File operations struct for character device */
Arjan van de Ven00977a52007-02-12 00:55:34 -0800221static const struct file_operations twa_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222 .owner = THIS_MODULE,
Arnd Bergmannf4927c42010-04-27 00:24:01 +0200223 .unlocked_ioctl = twa_chrdev_ioctl,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224 .open = twa_chrdev_open,
Arnd Bergmann6038f372010-08-15 18:52:59 +0200225 .release = NULL,
226 .llseek = noop_llseek,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227};
228
229/* This function will complete an aen request from the isr */
230static 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--;
adam radford75913d92006-03-15 12:43:19 -0800240 aen = le16_to_cpu(header->status_block.error);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241 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;
275out2:
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);
279out:
280 return retval;
281} /* End twa_aen_complete() */
282
283/* This function will drain aen queue */
284static 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];
adam radford75913d92006-03-15 12:43:19 -0800337 aen = le16_to_cpu(header->status_block.error);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338 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;
369out:
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 */
375static 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
adam radford75913d92006-03-15 12:43:19 -0800397 aen = le16_to_cpu(header->status_block.error);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398 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);
adam radford75913d92006-03-15 12:43:19 -0800414 memcpy(event->parameter_data, header->err_specific_desc, event->parameter_len + (error_str[0] == '\0' ? 0 : (1 + strlen(error_str))));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415 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 */
431static 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;
460out:
461 return retval;
462} /* End twa_aen_read_queue() */
463
464/* This function will look up an AEN severity string */
465static 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];
474out:
475 return retval;
476} /* End twa_aen_severity_lookup() */
477
478/* This function will sync firmware time with the host time */
479static 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;
adam radford75913d92006-03-15 12:43:19 -0800494 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496 command_packet->size = TW_COMMAND_SIZE;
adam radford75913d92006-03-15 12:43:19 -0800497 command_packet->byte6_offset.parameter_count = cpu_to_le16(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498
499 /* Setup the param */
500 param = (TW_Param_Apache *)tw_dev->generic_buffer_virt[request_id];
501 memset(param, 0, TW_SECTOR_SIZE);
adam radford75913d92006-03-15 12:43:19 -0800502 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505
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);
adam radford75913d92006-03-15 12:43:19 -0800511 schedulertime = cpu_to_le32(schedulertime % 604800);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512
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 */
523static 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;
557out:
558 return retval;
559} /* End twa_allocate_memory() */
560
561/* This function will check the status register for unexpected bits */
562static 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;
572out:
573 return retval;
574} /* End twa_check_bits() */
575
576/* This function will check the srl and decide if we are compatible */
577static 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
adam radford4039c302006-10-26 18:01:06 -0700594 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597
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 }
adam radford4039c302006-10-26 18:01:06 -0700618 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621 }
adam radford4039c302006-10-26 18:01:06 -0700622
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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635 retval = 0;
636out:
637 return retval;
638} /* End twa_check_srl() */
639
640/* This function handles ioctl for the character device */
Arnd Bergmannf4927c42010-04-27 00:24:01 +0200641static long twa_chrdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642{
Arnd Bergmannf4927c42010-04-27 00:24:01 +0200643 struct inode *inode = file->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700644 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
Arnd Bergmannc45d15d2010-06-02 14:28:52 +0200662 mutex_lock(&twa_chrdev_mutex);
Arnd Bergmannf4927c42010-04-27 00:24:01 +0200663
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664 /* Only let one of these through at a time */
Jes Sorensena12e25b2006-01-11 08:39:45 -0500665 if (mutex_lock_interruptible(&tw_dev->ioctl_lock)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700666 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 */
adam radford4039c302006-10-26 18:01:06 -0700675 if (driver_command.buffer_length > TW_MAX_SECTORS * 2048) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700676 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 */
adam radford0e78d152007-07-20 15:28:28 -0700711 twa_load_sgl(tw_dev, full_command_packet, request_id, dma_handle, data_buffer_length_adjusted);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712
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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724 /* 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",
adam radford0e78d152007-07-20 15:28:28 -0700728 tw_dev->host->host_no, TW_DRIVER, 0x37,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700729 cmd);
730 retval = TW_IOCTL_ERROR_OS_EIO;
adam radford0e78d152007-07-20 15:28:28 -0700731 twa_reset_device_extension(tw_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732 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;
Dirk Hohndel06fe9fb2009-09-28 21:43:57 -0400747 /* Copy compatibility struct into ioctl data buffer */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748 tw_compat_info = (TW_Compatibility_Info *)tw_ioctl->data_buffer;
adam radford4039c302006-10-26 18:01:06 -0700749 memcpy(tw_compat_info, &tw_dev->tw_compat_info, sizeof(TW_Compatibility_Info));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750 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;
877out3:
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);
880out2:
Jes Sorensena12e25b2006-01-11 08:39:45 -0500881 mutex_unlock(&tw_dev->ioctl_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700882out:
Arnd Bergmannc45d15d2010-06-02 14:28:52 +0200883 mutex_unlock(&twa_chrdev_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700884 return retval;
885} /* End twa_chrdev_ioctl() */
886
887/* This function handles open for the character device */
Jonathan Corbetf2b98572008-05-18 15:32:43 -0600888/* NOTE that this function will race with remove. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700889static 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 minor_number = iminor(inode);
895 if (minor_number >= twa_device_extension_count)
896 goto out;
897 retval = 0;
898out:
899 return retval;
900} /* End twa_chrdev_open() */
901
902/* This function will print readable messages from status register errors */
903static int twa_decode_bits(TW_Device_Extension *tw_dev, u32 status_reg_value)
904{
905 int retval = 1;
906
907 /* Check for various error conditions and handle them appropriately */
908 if (status_reg_value & TW_STATUS_PCI_PARITY_ERROR) {
909 TW_PRINTK(tw_dev->host, TW_DRIVER, 0xc, "PCI Parity Error: clearing");
910 writel(TW_CONTROL_CLEAR_PARITY_ERROR, TW_CONTROL_REG_ADDR(tw_dev));
911 }
912
913 if (status_reg_value & TW_STATUS_PCI_ABORT) {
914 TW_PRINTK(tw_dev->host, TW_DRIVER, 0xd, "PCI Abort: clearing");
915 writel(TW_CONTROL_CLEAR_PCI_ABORT, TW_CONTROL_REG_ADDR(tw_dev));
916 pci_write_config_word(tw_dev->tw_pci_dev, PCI_STATUS, TW_PCI_CLEAR_PCI_ABORT);
917 }
918
919 if (status_reg_value & TW_STATUS_QUEUE_ERROR) {
adam radford0e78d152007-07-20 15:28:28 -0700920 if (((tw_dev->tw_pci_dev->device != PCI_DEVICE_ID_3WARE_9650SE) &&
921 (tw_dev->tw_pci_dev->device != PCI_DEVICE_ID_3WARE_9690SA)) ||
922 (!test_bit(TW_IN_RESET, &tw_dev->flags)))
adam radford4039c302006-10-26 18:01:06 -0700923 TW_PRINTK(tw_dev->host, TW_DRIVER, 0xe, "Controller Queue Error: clearing");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700924 writel(TW_CONTROL_CLEAR_QUEUE_ERROR, TW_CONTROL_REG_ADDR(tw_dev));
925 }
926
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927 if (status_reg_value & TW_STATUS_MICROCONTROLLER_ERROR) {
928 if (tw_dev->reset_print == 0) {
929 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x10, "Microcontroller Error: clearing");
930 tw_dev->reset_print = 1;
931 }
932 goto out;
933 }
934 retval = 0;
935out:
936 return retval;
937} /* End twa_decode_bits() */
938
939/* This function will empty the response queue */
940static int twa_empty_response_queue(TW_Device_Extension *tw_dev)
941{
942 u32 status_reg_value, response_que_value;
943 int count = 0, retval = 1;
944
945 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
946
947 while (((status_reg_value & TW_STATUS_RESPONSE_QUEUE_EMPTY) == 0) && (count < TW_MAX_RESPONSE_DRAIN)) {
948 response_que_value = readl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev));
949 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
950 count++;
951 }
952 if (count == TW_MAX_RESPONSE_DRAIN)
953 goto out;
954
955 retval = 0;
956out:
957 return retval;
958} /* End twa_empty_response_queue() */
959
adam radford49bfd8d2005-09-21 17:20:14 -0700960/* This function will clear the pchip/response queue on 9550SX */
961static int twa_empty_response_queue_large(TW_Device_Extension *tw_dev)
962{
adam radford75913d92006-03-15 12:43:19 -0800963 u32 response_que_value = 0;
964 unsigned long before;
965 int retval = 1;
adam radford49bfd8d2005-09-21 17:20:14 -0700966
adam radford0e78d152007-07-20 15:28:28 -0700967 if (tw_dev->tw_pci_dev->device != PCI_DEVICE_ID_3WARE_9000) {
adam radford75913d92006-03-15 12:43:19 -0800968 before = jiffies;
969 while ((response_que_value & TW_9550SX_DRAIN_COMPLETED) != TW_9550SX_DRAIN_COMPLETED) {
adam radford49bfd8d2005-09-21 17:20:14 -0700970 response_que_value = readl(TW_RESPONSE_QUEUE_REG_ADDR_LARGE(tw_dev));
adam radford4039c302006-10-26 18:01:06 -0700971 msleep(1);
adam radford75913d92006-03-15 12:43:19 -0800972 if (time_after(jiffies, before + HZ * 30))
adam radford49bfd8d2005-09-21 17:20:14 -0700973 goto out;
adam radford49bfd8d2005-09-21 17:20:14 -0700974 }
adam radford75913d92006-03-15 12:43:19 -0800975 /* P-chip settle time */
976 msleep(500);
adam radford49bfd8d2005-09-21 17:20:14 -0700977 retval = 0;
978 } else
979 retval = 0;
980out:
981 return retval;
982} /* End twa_empty_response_queue_large() */
983
Linus Torvalds1da177e2005-04-16 15:20:36 -0700984/* This function passes sense keys from firmware to scsi layer */
985static int twa_fill_sense(TW_Device_Extension *tw_dev, int request_id, int copy_sense, int print_host)
986{
987 TW_Command_Full *full_command_packet;
988 unsigned short error;
989 int retval = 1;
990 char *error_str;
991
992 full_command_packet = tw_dev->command_packet_virt[request_id];
993
994 /* Check for embedded error string */
995 error_str = &(full_command_packet->header.err_specific_desc[strlen(full_command_packet->header.err_specific_desc) + 1]);
996
997 /* Don't print error for Logical unit not supported during rollcall */
adam radford75913d92006-03-15 12:43:19 -0800998 error = le16_to_cpu(full_command_packet->header.status_block.error);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700999 if ((error != TW_ERROR_LOGICAL_UNIT_NOT_SUPPORTED) && (error != TW_ERROR_UNIT_OFFLINE)) {
1000 if (print_host)
1001 printk(KERN_WARNING "3w-9xxx: scsi%d: ERROR: (0x%02X:0x%04X): %s:%s.\n",
1002 tw_dev->host->host_no,
1003 TW_MESSAGE_SOURCE_CONTROLLER_ERROR,
1004 full_command_packet->header.status_block.error,
1005 error_str[0] == '\0' ?
1006 twa_string_lookup(twa_error_table,
1007 full_command_packet->header.status_block.error) : error_str,
1008 full_command_packet->header.err_specific_desc);
1009 else
1010 printk(KERN_WARNING "3w-9xxx: ERROR: (0x%02X:0x%04X): %s:%s.\n",
1011 TW_MESSAGE_SOURCE_CONTROLLER_ERROR,
1012 full_command_packet->header.status_block.error,
1013 error_str[0] == '\0' ?
1014 twa_string_lookup(twa_error_table,
1015 full_command_packet->header.status_block.error) : error_str,
1016 full_command_packet->header.err_specific_desc);
1017 }
1018
1019 if (copy_sense) {
1020 memcpy(tw_dev->srb[request_id]->sense_buffer, full_command_packet->header.sense_data, TW_SENSE_DATA_LENGTH);
1021 tw_dev->srb[request_id]->result = (full_command_packet->command.newcommand.status << 1);
1022 retval = TW_ISR_DONT_RESULT;
1023 goto out;
1024 }
1025 retval = 0;
1026out:
1027 return retval;
1028} /* End twa_fill_sense() */
1029
1030/* This function will free up device extension resources */
1031static void twa_free_device_extension(TW_Device_Extension *tw_dev)
1032{
1033 if (tw_dev->command_packet_virt[0])
1034 pci_free_consistent(tw_dev->tw_pci_dev,
1035 sizeof(TW_Command_Full)*TW_Q_LENGTH,
1036 tw_dev->command_packet_virt[0],
1037 tw_dev->command_packet_phys[0]);
1038
1039 if (tw_dev->generic_buffer_virt[0])
1040 pci_free_consistent(tw_dev->tw_pci_dev,
1041 TW_SECTOR_SIZE*TW_Q_LENGTH,
1042 tw_dev->generic_buffer_virt[0],
1043 tw_dev->generic_buffer_phys[0]);
1044
Jesper Juhlc9475cb2005-11-07 01:01:26 -08001045 kfree(tw_dev->event_queue[0]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001046} /* End twa_free_device_extension() */
1047
1048/* This function will free a request id */
1049static void twa_free_request_id(TW_Device_Extension *tw_dev, int request_id)
1050{
1051 tw_dev->free_queue[tw_dev->free_tail] = request_id;
1052 tw_dev->state[request_id] = TW_S_FINISHED;
1053 tw_dev->free_tail = (tw_dev->free_tail + 1) % TW_Q_LENGTH;
1054} /* End twa_free_request_id() */
1055
Alexey Dobriyan7f927fc2006-03-28 01:56:53 -08001056/* This function will get parameter table entries from the firmware */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001057static void *twa_get_param(TW_Device_Extension *tw_dev, int request_id, int table_id, int parameter_id, int parameter_size_bytes)
1058{
1059 TW_Command_Full *full_command_packet;
1060 TW_Command *command_packet;
1061 TW_Param_Apache *param;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001062 void *retval = NULL;
1063
1064 /* Setup the command packet */
1065 full_command_packet = tw_dev->command_packet_virt[request_id];
1066 memset(full_command_packet, 0, sizeof(TW_Command_Full));
1067 command_packet = &full_command_packet->command.oldcommand;
1068
1069 command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_GET_PARAM);
1070 command_packet->size = TW_COMMAND_SIZE;
1071 command_packet->request_id = request_id;
adam radford75913d92006-03-15 12:43:19 -08001072 command_packet->byte6_offset.block_count = cpu_to_le16(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001073
1074 /* Now setup the param */
1075 param = (TW_Param_Apache *)tw_dev->generic_buffer_virt[request_id];
1076 memset(param, 0, TW_SECTOR_SIZE);
adam radford75913d92006-03-15 12:43:19 -08001077 param->table_id = cpu_to_le16(table_id | 0x8000);
1078 param->parameter_id = cpu_to_le16(parameter_id);
1079 param->parameter_size_bytes = cpu_to_le16(parameter_size_bytes);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001080
adam radford3dabec72008-07-22 16:47:40 -07001081 command_packet->byte8_offset.param.sgl[0].address = TW_CPU_TO_SGL(tw_dev->generic_buffer_phys[request_id]);
adam radford75913d92006-03-15 12:43:19 -08001082 command_packet->byte8_offset.param.sgl[0].length = cpu_to_le32(TW_SECTOR_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001083
1084 /* Post the command packet to the board */
1085 twa_post_command_packet(tw_dev, request_id, 1);
1086
1087 /* Poll for completion */
1088 if (twa_poll_response(tw_dev, request_id, 30))
1089 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x13, "No valid response during get param")
1090 else
1091 retval = (void *)&(param->data[0]);
1092
1093 tw_dev->posted_request_count--;
1094 tw_dev->state[request_id] = TW_S_INITIAL;
1095
1096 return retval;
1097} /* End twa_get_param() */
1098
1099/* This function will assign an available request id */
1100static void twa_get_request_id(TW_Device_Extension *tw_dev, int *request_id)
1101{
1102 *request_id = tw_dev->free_queue[tw_dev->free_head];
1103 tw_dev->free_head = (tw_dev->free_head + 1) % TW_Q_LENGTH;
1104 tw_dev->state[*request_id] = TW_S_STARTED;
1105} /* End twa_get_request_id() */
1106
1107/* This function will send an initconnection command to controller */
1108static int twa_initconnection(TW_Device_Extension *tw_dev, int message_credits,
1109 u32 set_features, unsigned short current_fw_srl,
1110 unsigned short current_fw_arch_id,
1111 unsigned short current_fw_branch,
1112 unsigned short current_fw_build,
1113 unsigned short *fw_on_ctlr_srl,
1114 unsigned short *fw_on_ctlr_arch_id,
1115 unsigned short *fw_on_ctlr_branch,
1116 unsigned short *fw_on_ctlr_build,
1117 u32 *init_connect_result)
1118{
1119 TW_Command_Full *full_command_packet;
1120 TW_Initconnect *tw_initconnect;
1121 int request_id = 0, retval = 1;
1122
1123 /* Initialize InitConnection command packet */
1124 full_command_packet = tw_dev->command_packet_virt[request_id];
1125 memset(full_command_packet, 0, sizeof(TW_Command_Full));
1126 full_command_packet->header.header_desc.size_header = 128;
1127
1128 tw_initconnect = (TW_Initconnect *)&full_command_packet->command.oldcommand;
1129 tw_initconnect->opcode__reserved = TW_OPRES_IN(0, TW_OP_INIT_CONNECTION);
1130 tw_initconnect->request_id = request_id;
adam radford75913d92006-03-15 12:43:19 -08001131 tw_initconnect->message_credits = cpu_to_le16(message_credits);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001132 tw_initconnect->features = set_features;
1133
1134 /* Turn on 64-bit sgl support if we need to */
1135 tw_initconnect->features |= sizeof(dma_addr_t) > 4 ? 1 : 0;
1136
adam radford75913d92006-03-15 12:43:19 -08001137 tw_initconnect->features = cpu_to_le32(tw_initconnect->features);
1138
Linus Torvalds1da177e2005-04-16 15:20:36 -07001139 if (set_features & TW_EXTENDED_INIT_CONNECT) {
1140 tw_initconnect->size = TW_INIT_COMMAND_PACKET_SIZE_EXTENDED;
adam radford75913d92006-03-15 12:43:19 -08001141 tw_initconnect->fw_srl = cpu_to_le16(current_fw_srl);
1142 tw_initconnect->fw_arch_id = cpu_to_le16(current_fw_arch_id);
1143 tw_initconnect->fw_branch = cpu_to_le16(current_fw_branch);
1144 tw_initconnect->fw_build = cpu_to_le16(current_fw_build);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001145 } else
1146 tw_initconnect->size = TW_INIT_COMMAND_PACKET_SIZE;
1147
1148 /* Send command packet to the board */
1149 twa_post_command_packet(tw_dev, request_id, 1);
1150
1151 /* Poll for completion */
1152 if (twa_poll_response(tw_dev, request_id, 30)) {
1153 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x15, "No valid response during init connection");
1154 } else {
1155 if (set_features & TW_EXTENDED_INIT_CONNECT) {
adam radford75913d92006-03-15 12:43:19 -08001156 *fw_on_ctlr_srl = le16_to_cpu(tw_initconnect->fw_srl);
1157 *fw_on_ctlr_arch_id = le16_to_cpu(tw_initconnect->fw_arch_id);
1158 *fw_on_ctlr_branch = le16_to_cpu(tw_initconnect->fw_branch);
1159 *fw_on_ctlr_build = le16_to_cpu(tw_initconnect->fw_build);
1160 *init_connect_result = le32_to_cpu(tw_initconnect->result);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001161 }
1162 retval = 0;
1163 }
1164
1165 tw_dev->posted_request_count--;
1166 tw_dev->state[request_id] = TW_S_INITIAL;
1167
1168 return retval;
1169} /* End twa_initconnection() */
1170
1171/* This function will initialize the fields of a device extension */
1172static int twa_initialize_device_extension(TW_Device_Extension *tw_dev)
1173{
1174 int i, retval = 1;
1175
1176 /* Initialize command packet buffers */
1177 if (twa_allocate_memory(tw_dev, sizeof(TW_Command_Full), 0)) {
1178 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x16, "Command packet memory allocation failed");
1179 goto out;
1180 }
1181
1182 /* Initialize generic buffer */
1183 if (twa_allocate_memory(tw_dev, TW_SECTOR_SIZE, 1)) {
1184 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x17, "Generic memory allocation failed");
1185 goto out;
1186 }
1187
1188 /* Allocate event info space */
Yoann Padioleaudd00cc42007-07-19 01:49:03 -07001189 tw_dev->event_queue[0] = kcalloc(TW_Q_LENGTH, sizeof(TW_Event), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001190 if (!tw_dev->event_queue[0]) {
1191 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x18, "Event info memory allocation failed");
1192 goto out;
1193 }
1194
Linus Torvalds1da177e2005-04-16 15:20:36 -07001195
1196 for (i = 0; i < TW_Q_LENGTH; i++) {
1197 tw_dev->event_queue[i] = (TW_Event *)((unsigned char *)tw_dev->event_queue[0] + (i * sizeof(TW_Event)));
1198 tw_dev->free_queue[i] = i;
1199 tw_dev->state[i] = TW_S_INITIAL;
1200 }
1201
1202 tw_dev->pending_head = TW_Q_START;
1203 tw_dev->pending_tail = TW_Q_START;
1204 tw_dev->free_head = TW_Q_START;
1205 tw_dev->free_tail = TW_Q_START;
1206 tw_dev->error_sequence_id = 1;
1207 tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE;
1208
Jes Sorensena12e25b2006-01-11 08:39:45 -05001209 mutex_init(&tw_dev->ioctl_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001210 init_waitqueue_head(&tw_dev->ioctl_wqueue);
1211
1212 retval = 0;
1213out:
1214 return retval;
1215} /* End twa_initialize_device_extension() */
1216
1217/* This function is the interrupt service routine */
David Howells7d12e782006-10-05 14:55:46 +01001218static irqreturn_t twa_interrupt(int irq, void *dev_instance)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001219{
1220 int request_id, error = 0;
1221 u32 status_reg_value;
1222 TW_Response_Queue response_que;
1223 TW_Command_Full *full_command_packet;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001224 TW_Device_Extension *tw_dev = (TW_Device_Extension *)dev_instance;
1225 int handled = 0;
1226
1227 /* Get the per adapter lock */
1228 spin_lock(tw_dev->host->host_lock);
1229
1230 /* Read the registers */
1231 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
1232
1233 /* Check if this is our interrupt, otherwise bail */
1234 if (!(status_reg_value & TW_STATUS_VALID_INTERRUPT))
1235 goto twa_interrupt_bail;
1236
1237 handled = 1;
1238
adam radford4039c302006-10-26 18:01:06 -07001239 /* If we are resetting, bail */
1240 if (test_bit(TW_IN_RESET, &tw_dev->flags))
1241 goto twa_interrupt_bail;
1242
Linus Torvalds1da177e2005-04-16 15:20:36 -07001243 /* Check controller for errors */
1244 if (twa_check_bits(status_reg_value)) {
1245 if (twa_decode_bits(tw_dev, status_reg_value)) {
1246 TW_CLEAR_ALL_INTERRUPTS(tw_dev);
1247 goto twa_interrupt_bail;
1248 }
1249 }
1250
1251 /* Handle host interrupt */
1252 if (status_reg_value & TW_STATUS_HOST_INTERRUPT)
1253 TW_CLEAR_HOST_INTERRUPT(tw_dev);
1254
1255 /* Handle attention interrupt */
1256 if (status_reg_value & TW_STATUS_ATTENTION_INTERRUPT) {
1257 TW_CLEAR_ATTENTION_INTERRUPT(tw_dev);
1258 if (!(test_and_set_bit(TW_IN_ATTENTION_LOOP, &tw_dev->flags))) {
1259 twa_get_request_id(tw_dev, &request_id);
1260
1261 error = twa_aen_read_queue(tw_dev, request_id);
1262 if (error) {
1263 tw_dev->state[request_id] = TW_S_COMPLETED;
1264 twa_free_request_id(tw_dev, request_id);
1265 clear_bit(TW_IN_ATTENTION_LOOP, &tw_dev->flags);
1266 }
1267 }
1268 }
1269
1270 /* Handle command interrupt */
1271 if (status_reg_value & TW_STATUS_COMMAND_INTERRUPT) {
1272 TW_MASK_COMMAND_INTERRUPT(tw_dev);
1273 /* Drain as many pending commands as we can */
1274 while (tw_dev->pending_request_count > 0) {
1275 request_id = tw_dev->pending_queue[tw_dev->pending_head];
1276 if (tw_dev->state[request_id] != TW_S_PENDING) {
1277 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x19, "Found request id that wasn't pending");
1278 TW_CLEAR_ALL_INTERRUPTS(tw_dev);
1279 goto twa_interrupt_bail;
1280 }
1281 if (twa_post_command_packet(tw_dev, request_id, 1)==0) {
1282 tw_dev->pending_head = (tw_dev->pending_head + 1) % TW_Q_LENGTH;
1283 tw_dev->pending_request_count--;
1284 } else {
1285 /* If we get here, we will continue re-posting on the next command interrupt */
1286 break;
1287 }
1288 }
1289 }
1290
1291 /* Handle response interrupt */
1292 if (status_reg_value & TW_STATUS_RESPONSE_INTERRUPT) {
1293
1294 /* Drain the response queue from the board */
1295 while ((status_reg_value & TW_STATUS_RESPONSE_QUEUE_EMPTY) == 0) {
1296 /* Complete the response */
1297 response_que.value = readl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev));
1298 request_id = TW_RESID_OUT(response_que.response_id);
1299 full_command_packet = tw_dev->command_packet_virt[request_id];
1300 error = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001301 /* Check for command packet errors */
1302 if (full_command_packet->command.newcommand.status != 0) {
Harvey Harrison9bcf0912008-05-22 15:45:07 -07001303 if (tw_dev->srb[request_id] != NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001304 error = twa_fill_sense(tw_dev, request_id, 1, 1);
1305 } else {
1306 /* Skip ioctl error prints */
1307 if (request_id != tw_dev->chrdev_request_id) {
1308 error = twa_fill_sense(tw_dev, request_id, 0, 1);
1309 }
1310 }
1311 }
1312
1313 /* Check for correct state */
1314 if (tw_dev->state[request_id] != TW_S_POSTED) {
Harvey Harrison9bcf0912008-05-22 15:45:07 -07001315 if (tw_dev->srb[request_id] != NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001316 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1a, "Received a request id that wasn't posted");
1317 TW_CLEAR_ALL_INTERRUPTS(tw_dev);
1318 goto twa_interrupt_bail;
1319 }
1320 }
1321
1322 /* Check for internal command completion */
Harvey Harrison9bcf0912008-05-22 15:45:07 -07001323 if (tw_dev->srb[request_id] == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001324 if (request_id != tw_dev->chrdev_request_id) {
1325 if (twa_aen_complete(tw_dev, request_id))
1326 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1b, "Error completing AEN during attention interrupt");
1327 } else {
1328 tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE;
1329 wake_up(&tw_dev->ioctl_wqueue);
1330 }
1331 } else {
FUJITA Tomonori0debe012007-05-26 02:33:31 +09001332 struct scsi_cmnd *cmd;
1333
1334 cmd = tw_dev->srb[request_id];
1335
Linus Torvalds1da177e2005-04-16 15:20:36 -07001336 twa_scsiop_execute_scsi_complete(tw_dev, request_id);
1337 /* If no error command was a success */
1338 if (error == 0) {
FUJITA Tomonori0debe012007-05-26 02:33:31 +09001339 cmd->result = (DID_OK << 16);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001340 }
1341
1342 /* If error, command failed */
1343 if (error == 1) {
1344 /* Ask for a host reset */
FUJITA Tomonori0debe012007-05-26 02:33:31 +09001345 cmd->result = (DID_OK << 16) | (CHECK_CONDITION << 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001346 }
1347
1348 /* Report residual bytes for single sgl */
FUJITA Tomonori0debe012007-05-26 02:33:31 +09001349 if ((scsi_sg_count(cmd) <= 1) && (full_command_packet->command.newcommand.status == 0)) {
1350 if (full_command_packet->command.newcommand.sg_list[0].length < scsi_bufflen(tw_dev->srb[request_id]))
1351 scsi_set_resid(cmd, scsi_bufflen(cmd) - full_command_packet->command.newcommand.sg_list[0].length);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001352 }
1353
1354 /* Now complete the io */
1355 tw_dev->state[request_id] = TW_S_COMPLETED;
1356 twa_free_request_id(tw_dev, request_id);
1357 tw_dev->posted_request_count--;
1358 tw_dev->srb[request_id]->scsi_done(tw_dev->srb[request_id]);
1359 twa_unmap_scsi_data(tw_dev, request_id);
1360 }
1361
1362 /* Check for valid status after each drain */
1363 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
1364 if (twa_check_bits(status_reg_value)) {
1365 if (twa_decode_bits(tw_dev, status_reg_value)) {
1366 TW_CLEAR_ALL_INTERRUPTS(tw_dev);
1367 goto twa_interrupt_bail;
1368 }
1369 }
1370 }
1371 }
1372
1373twa_interrupt_bail:
1374 spin_unlock(tw_dev->host->host_lock);
1375 return IRQ_RETVAL(handled);
1376} /* End twa_interrupt() */
1377
1378/* This function will load the request id and various sgls for ioctls */
adam radford0e78d152007-07-20 15:28:28 -07001379static 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)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001380{
1381 TW_Command *oldcommand;
1382 TW_Command_Apache *newcommand;
1383 TW_SG_Entry *sgl;
adam radford0e78d152007-07-20 15:28:28 -07001384 unsigned int pae = 0;
1385
1386 if ((sizeof(long) < 8) && (sizeof(dma_addr_t) > 4))
1387 pae = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001388
1389 if (TW_OP_OUT(full_command_packet->command.newcommand.opcode__reserved) == TW_OP_EXECUTE_SCSI) {
1390 newcommand = &full_command_packet->command.newcommand;
adam radford4039c302006-10-26 18:01:06 -07001391 newcommand->request_id__lunl =
1392 cpu_to_le16(TW_REQ_LUN_IN(TW_LUN_OUT(newcommand->request_id__lunl), request_id));
adam radford53ca3532009-12-10 11:53:31 -08001393 if (length) {
1394 newcommand->sg_list[0].address = TW_CPU_TO_SGL(dma_handle + sizeof(TW_Ioctl_Buf_Apache) - 1);
1395 newcommand->sg_list[0].length = cpu_to_le32(length);
1396 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001397 newcommand->sgl_entries__lunh =
adam radford53ca3532009-12-10 11:53:31 -08001398 cpu_to_le16(TW_REQ_LUN_IN(TW_LUN_OUT(newcommand->sgl_entries__lunh), length ? 1 : 0));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001399 } else {
1400 oldcommand = &full_command_packet->command.oldcommand;
1401 oldcommand->request_id = request_id;
1402
1403 if (TW_SGL_OUT(oldcommand->opcode__sgloffset)) {
1404 /* Load the sg list */
adam radford0e78d152007-07-20 15:28:28 -07001405 if (tw_dev->tw_pci_dev->device == PCI_DEVICE_ID_3WARE_9690SA)
1406 sgl = (TW_SG_Entry *)((u32 *)oldcommand+oldcommand->size - (sizeof(TW_SG_Entry)/4) + pae);
1407 else
1408 sgl = (TW_SG_Entry *)((u32 *)oldcommand+TW_SGL_OUT(oldcommand->opcode__sgloffset));
adam radford75913d92006-03-15 12:43:19 -08001409 sgl->address = TW_CPU_TO_SGL(dma_handle + sizeof(TW_Ioctl_Buf_Apache) - 1);
1410 sgl->length = cpu_to_le32(length);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001411
adam radford0e78d152007-07-20 15:28:28 -07001412 oldcommand->size += pae;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001413 }
1414 }
1415} /* End twa_load_sgl() */
1416
1417/* This function will perform a pci-dma mapping for a scatter gather list */
1418static int twa_map_scsi_sg_data(TW_Device_Extension *tw_dev, int request_id)
1419{
1420 int use_sg;
1421 struct scsi_cmnd *cmd = tw_dev->srb[request_id];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001422
FUJITA Tomonori0debe012007-05-26 02:33:31 +09001423 use_sg = scsi_dma_map(cmd);
1424 if (!use_sg)
1425 return 0;
1426 else if (use_sg < 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001427 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1c, "Failed to map scatter gather list");
FUJITA Tomonori0debe012007-05-26 02:33:31 +09001428 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001429 }
1430
1431 cmd->SCp.phase = TW_PHASE_SGLIST;
1432 cmd->SCp.have_data_in = use_sg;
FUJITA Tomonori0debe012007-05-26 02:33:31 +09001433
1434 return use_sg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001435} /* End twa_map_scsi_sg_data() */
1436
Linus Torvalds1da177e2005-04-16 15:20:36 -07001437/* This function will poll for a response interrupt of a request */
1438static int twa_poll_response(TW_Device_Extension *tw_dev, int request_id, int seconds)
1439{
1440 int retval = 1, found = 0, response_request_id;
1441 TW_Response_Queue response_queue;
1442 TW_Command_Full *full_command_packet = tw_dev->command_packet_virt[request_id];
1443
1444 if (twa_poll_status_gone(tw_dev, TW_STATUS_RESPONSE_QUEUE_EMPTY, seconds) == 0) {
1445 response_queue.value = readl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev));
1446 response_request_id = TW_RESID_OUT(response_queue.response_id);
1447 if (request_id != response_request_id) {
1448 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1e, "Found unexpected request id while polling for response");
1449 goto out;
1450 }
1451 if (TW_OP_OUT(full_command_packet->command.newcommand.opcode__reserved) == TW_OP_EXECUTE_SCSI) {
1452 if (full_command_packet->command.newcommand.status != 0) {
1453 /* bad response */
1454 twa_fill_sense(tw_dev, request_id, 0, 0);
1455 goto out;
1456 }
1457 found = 1;
1458 } else {
1459 if (full_command_packet->command.oldcommand.status != 0) {
1460 /* bad response */
1461 twa_fill_sense(tw_dev, request_id, 0, 0);
1462 goto out;
1463 }
1464 found = 1;
1465 }
1466 }
1467
1468 if (found)
1469 retval = 0;
1470out:
1471 return retval;
1472} /* End twa_poll_response() */
1473
1474/* This function will poll the status register for a flag */
1475static int twa_poll_status(TW_Device_Extension *tw_dev, u32 flag, int seconds)
1476{
1477 u32 status_reg_value;
1478 unsigned long before;
1479 int retval = 1;
1480
1481 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
1482 before = jiffies;
1483
1484 if (twa_check_bits(status_reg_value))
1485 twa_decode_bits(tw_dev, status_reg_value);
1486
1487 while ((status_reg_value & flag) != flag) {
1488 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
1489
1490 if (twa_check_bits(status_reg_value))
1491 twa_decode_bits(tw_dev, status_reg_value);
1492
1493 if (time_after(jiffies, before + HZ * seconds))
1494 goto out;
1495
1496 msleep(50);
1497 }
1498 retval = 0;
1499out:
1500 return retval;
1501} /* End twa_poll_status() */
1502
1503/* This function will poll the status register for disappearance of a flag */
1504static int twa_poll_status_gone(TW_Device_Extension *tw_dev, u32 flag, int seconds)
1505{
1506 u32 status_reg_value;
1507 unsigned long before;
1508 int retval = 1;
1509
1510 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
1511 before = jiffies;
1512
1513 if (twa_check_bits(status_reg_value))
1514 twa_decode_bits(tw_dev, status_reg_value);
1515
1516 while ((status_reg_value & flag) != 0) {
1517 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
1518 if (twa_check_bits(status_reg_value))
1519 twa_decode_bits(tw_dev, status_reg_value);
1520
1521 if (time_after(jiffies, before + HZ * seconds))
1522 goto out;
1523
1524 msleep(50);
1525 }
1526 retval = 0;
1527out:
1528 return retval;
1529} /* End twa_poll_status_gone() */
1530
1531/* This function will attempt to post a command packet to the board */
1532static int twa_post_command_packet(TW_Device_Extension *tw_dev, int request_id, char internal)
1533{
1534 u32 status_reg_value;
1535 dma_addr_t command_que_value;
1536 int retval = 1;
1537
1538 command_que_value = tw_dev->command_packet_phys[request_id];
adam radford4039c302006-10-26 18:01:06 -07001539
1540 /* For 9650SE write low 4 bytes first */
adam radford0e78d152007-07-20 15:28:28 -07001541 if ((tw_dev->tw_pci_dev->device == PCI_DEVICE_ID_3WARE_9650SE) ||
1542 (tw_dev->tw_pci_dev->device == PCI_DEVICE_ID_3WARE_9690SA)) {
adam radford4039c302006-10-26 18:01:06 -07001543 command_que_value += TW_COMMAND_OFFSET;
1544 writel((u32)command_que_value, TW_COMMAND_QUEUE_REG_ADDR_LARGE(tw_dev));
1545 }
1546
Linus Torvalds1da177e2005-04-16 15:20:36 -07001547 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
1548
1549 if (twa_check_bits(status_reg_value))
1550 twa_decode_bits(tw_dev, status_reg_value);
1551
1552 if (((tw_dev->pending_request_count > 0) && (tw_dev->state[request_id] != TW_S_PENDING)) || (status_reg_value & TW_STATUS_COMMAND_QUEUE_FULL)) {
1553
1554 /* Only pend internal driver commands */
1555 if (!internal) {
1556 retval = SCSI_MLQUEUE_HOST_BUSY;
1557 goto out;
1558 }
1559
1560 /* Couldn't post the command packet, so we do it later */
1561 if (tw_dev->state[request_id] != TW_S_PENDING) {
1562 tw_dev->state[request_id] = TW_S_PENDING;
1563 tw_dev->pending_request_count++;
1564 if (tw_dev->pending_request_count > tw_dev->max_pending_request_count) {
1565 tw_dev->max_pending_request_count = tw_dev->pending_request_count;
1566 }
1567 tw_dev->pending_queue[tw_dev->pending_tail] = request_id;
1568 tw_dev->pending_tail = (tw_dev->pending_tail + 1) % TW_Q_LENGTH;
1569 }
1570 TW_UNMASK_COMMAND_INTERRUPT(tw_dev);
1571 goto out;
1572 } else {
adam radford0e78d152007-07-20 15:28:28 -07001573 if ((tw_dev->tw_pci_dev->device == PCI_DEVICE_ID_3WARE_9650SE) ||
1574 (tw_dev->tw_pci_dev->device == PCI_DEVICE_ID_3WARE_9690SA)) {
adam radford4039c302006-10-26 18:01:06 -07001575 /* Now write upper 4 bytes */
1576 writel((u32)((u64)command_que_value >> 32), TW_COMMAND_QUEUE_REG_ADDR_LARGE(tw_dev) + 0x4);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001577 } else {
adam radford4039c302006-10-26 18:01:06 -07001578 if (sizeof(dma_addr_t) > 4) {
1579 command_que_value += TW_COMMAND_OFFSET;
1580 writel((u32)command_que_value, TW_COMMAND_QUEUE_REG_ADDR(tw_dev));
1581 writel((u32)((u64)command_que_value >> 32), TW_COMMAND_QUEUE_REG_ADDR(tw_dev) + 0x4);
1582 } else {
1583 writel(TW_COMMAND_OFFSET + command_que_value, TW_COMMAND_QUEUE_REG_ADDR(tw_dev));
1584 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001585 }
1586 tw_dev->state[request_id] = TW_S_POSTED;
1587 tw_dev->posted_request_count++;
1588 if (tw_dev->posted_request_count > tw_dev->max_posted_request_count) {
1589 tw_dev->max_posted_request_count = tw_dev->posted_request_count;
1590 }
1591 }
1592 retval = 0;
1593out:
1594 return retval;
1595} /* End twa_post_command_packet() */
1596
1597/* This function will reset a device extension */
adam radford0e78d152007-07-20 15:28:28 -07001598static int twa_reset_device_extension(TW_Device_Extension *tw_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001599{
1600 int i = 0;
1601 int retval = 1;
1602 unsigned long flags = 0;
1603
1604 set_bit(TW_IN_RESET, &tw_dev->flags);
1605 TW_DISABLE_INTERRUPTS(tw_dev);
1606 TW_MASK_COMMAND_INTERRUPT(tw_dev);
1607 spin_lock_irqsave(tw_dev->host->host_lock, flags);
1608
1609 /* Abort all requests that are in progress */
1610 for (i = 0; i < TW_Q_LENGTH; i++) {
1611 if ((tw_dev->state[i] != TW_S_FINISHED) &&
1612 (tw_dev->state[i] != TW_S_INITIAL) &&
1613 (tw_dev->state[i] != TW_S_COMPLETED)) {
1614 if (tw_dev->srb[i]) {
1615 tw_dev->srb[i]->result = (DID_RESET << 16);
1616 tw_dev->srb[i]->scsi_done(tw_dev->srb[i]);
1617 twa_unmap_scsi_data(tw_dev, i);
1618 }
1619 }
1620 }
1621
1622 /* Reset queues and counts */
1623 for (i = 0; i < TW_Q_LENGTH; i++) {
1624 tw_dev->free_queue[i] = i;
1625 tw_dev->state[i] = TW_S_INITIAL;
1626 }
1627 tw_dev->free_head = TW_Q_START;
1628 tw_dev->free_tail = TW_Q_START;
1629 tw_dev->posted_request_count = 0;
1630 tw_dev->pending_request_count = 0;
1631 tw_dev->pending_head = TW_Q_START;
1632 tw_dev->pending_tail = TW_Q_START;
1633 tw_dev->reset_print = 0;
1634
1635 spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
1636
1637 if (twa_reset_sequence(tw_dev, 1))
1638 goto out;
1639
1640 TW_ENABLE_AND_CLEAR_INTERRUPTS(tw_dev);
adam radford4039c302006-10-26 18:01:06 -07001641 clear_bit(TW_IN_RESET, &tw_dev->flags);
1642 tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001643
Linus Torvalds1da177e2005-04-16 15:20:36 -07001644 retval = 0;
1645out:
1646 return retval;
1647} /* End twa_reset_device_extension() */
1648
1649/* This function will reset a controller */
1650static int twa_reset_sequence(TW_Device_Extension *tw_dev, int soft_reset)
1651{
1652 int tries = 0, retval = 1, flashed = 0, do_soft_reset = soft_reset;
1653
1654 while (tries < TW_MAX_RESET_TRIES) {
adam radford49bfd8d2005-09-21 17:20:14 -07001655 if (do_soft_reset) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001656 TW_SOFT_RESET(tw_dev);
adam radford49bfd8d2005-09-21 17:20:14 -07001657 /* Clear pchip/response queue on 9550SX */
1658 if (twa_empty_response_queue_large(tw_dev)) {
1659 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x36, "Response queue (large) empty failed during reset sequence");
1660 do_soft_reset = 1;
1661 tries++;
1662 continue;
1663 }
1664 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001665
1666 /* Make sure controller is in a good state */
1667 if (twa_poll_status(tw_dev, TW_STATUS_MICROCONTROLLER_READY | (do_soft_reset == 1 ? TW_STATUS_ATTENTION_INTERRUPT : 0), 60)) {
1668 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1f, "Microcontroller not ready during reset sequence");
1669 do_soft_reset = 1;
1670 tries++;
1671 continue;
1672 }
1673
1674 /* Empty response queue */
1675 if (twa_empty_response_queue(tw_dev)) {
1676 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x20, "Response queue empty failed during reset sequence");
1677 do_soft_reset = 1;
1678 tries++;
1679 continue;
1680 }
1681
1682 flashed = 0;
1683
1684 /* Check for compatibility/flash */
1685 if (twa_check_srl(tw_dev, &flashed)) {
1686 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x21, "Compatibility check failed during reset sequence");
1687 do_soft_reset = 1;
1688 tries++;
1689 continue;
1690 } else {
1691 if (flashed) {
1692 tries++;
1693 continue;
1694 }
1695 }
1696
1697 /* Drain the AEN queue */
1698 if (twa_aen_drain_queue(tw_dev, soft_reset)) {
1699 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x22, "AEN drain failed during reset sequence");
1700 do_soft_reset = 1;
1701 tries++;
1702 continue;
1703 }
1704
1705 /* If we got here, controller is in a good state */
1706 retval = 0;
1707 goto out;
1708 }
1709out:
1710 return retval;
1711} /* End twa_reset_sequence() */
1712
1713/* This funciton returns unit geometry in cylinders/heads/sectors */
1714static int twa_scsi_biosparam(struct scsi_device *sdev, struct block_device *bdev, sector_t capacity, int geom[])
1715{
1716 int heads, sectors, cylinders;
1717 TW_Device_Extension *tw_dev;
1718
1719 tw_dev = (TW_Device_Extension *)sdev->host->hostdata;
1720
1721 if (capacity >= 0x200000) {
1722 heads = 255;
1723 sectors = 63;
1724 cylinders = sector_div(capacity, heads * sectors);
1725 } else {
1726 heads = 64;
1727 sectors = 32;
1728 cylinders = sector_div(capacity, heads * sectors);
1729 }
1730
1731 geom[0] = heads;
1732 geom[1] = sectors;
1733 geom[2] = cylinders;
1734
1735 return 0;
1736} /* End twa_scsi_biosparam() */
1737
1738/* This is the new scsi eh reset function */
1739static int twa_scsi_eh_reset(struct scsi_cmnd *SCpnt)
1740{
1741 TW_Device_Extension *tw_dev = NULL;
1742 int retval = FAILED;
1743
1744 tw_dev = (TW_Device_Extension *)SCpnt->device->host->hostdata;
1745
Linus Torvalds1da177e2005-04-16 15:20:36 -07001746 tw_dev->num_resets++;
1747
Jeff Garzik017560f2005-10-24 18:04:36 -04001748 sdev_printk(KERN_WARNING, SCpnt->device,
1749 "WARNING: (0x%02X:0x%04X): Command (0x%x) timed out, resetting card.\n",
1750 TW_DRIVER, 0x2c, SCpnt->cmnd[0]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001751
adam radford4039c302006-10-26 18:01:06 -07001752 /* Make sure we are not issuing an ioctl or resetting from ioctl */
1753 mutex_lock(&tw_dev->ioctl_lock);
1754
Linus Torvalds1da177e2005-04-16 15:20:36 -07001755 /* Now reset the card and some of the device extension data */
adam radford0e78d152007-07-20 15:28:28 -07001756 if (twa_reset_device_extension(tw_dev)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001757 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x2b, "Controller reset failed during scsi host reset");
1758 goto out;
1759 }
1760
1761 retval = SUCCESS;
1762out:
adam radford4039c302006-10-26 18:01:06 -07001763 mutex_unlock(&tw_dev->ioctl_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001764 return retval;
1765} /* End twa_scsi_eh_reset() */
1766
1767/* This is the main scsi queue function to handle scsi opcodes */
Jeff Garzikf2812332010-11-16 02:10:29 -05001768static int twa_scsi_queue_lck(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001769{
1770 int request_id, retval;
1771 TW_Device_Extension *tw_dev = (TW_Device_Extension *)SCpnt->device->host->hostdata;
1772
adam radford4039c302006-10-26 18:01:06 -07001773 /* If we are resetting due to timed out ioctl, report as busy */
1774 if (test_bit(TW_IN_RESET, &tw_dev->flags)) {
1775 retval = SCSI_MLQUEUE_HOST_BUSY;
1776 goto out;
1777 }
1778
Linus Torvalds1da177e2005-04-16 15:20:36 -07001779 /* Check if this FW supports luns */
adam radford4039c302006-10-26 18:01:06 -07001780 if ((SCpnt->device->lun != 0) && (tw_dev->tw_compat_info.working_srl < TW_FW_SRL_LUNS_SUPPORTED)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001781 SCpnt->result = (DID_BAD_TARGET << 16);
1782 done(SCpnt);
1783 retval = 0;
1784 goto out;
1785 }
1786
1787 /* Save done function into scsi_cmnd struct */
1788 SCpnt->scsi_done = done;
1789
1790 /* Get a free request id */
1791 twa_get_request_id(tw_dev, &request_id);
1792
1793 /* Save the scsi command for use by the ISR */
1794 tw_dev->srb[request_id] = SCpnt;
1795
1796 /* Initialize phase to zero */
1797 SCpnt->SCp.phase = TW_PHASE_INITIAL;
1798
1799 retval = twa_scsiop_execute_scsi(tw_dev, request_id, NULL, 0, NULL);
1800 switch (retval) {
1801 case SCSI_MLQUEUE_HOST_BUSY:
1802 twa_free_request_id(tw_dev, request_id);
1803 break;
1804 case 1:
1805 tw_dev->state[request_id] = TW_S_COMPLETED;
1806 twa_free_request_id(tw_dev, request_id);
1807 SCpnt->result = (DID_ERROR << 16);
1808 done(SCpnt);
1809 retval = 0;
1810 }
1811out:
1812 return retval;
1813} /* End twa_scsi_queue() */
1814
Jeff Garzikf2812332010-11-16 02:10:29 -05001815static DEF_SCSI_QCMD(twa_scsi_queue)
1816
Linus Torvalds1da177e2005-04-16 15:20:36 -07001817/* This function hands scsi cdb's to the firmware */
1818static int twa_scsiop_execute_scsi(TW_Device_Extension *tw_dev, int request_id, char *cdb, int use_sg, TW_SG_Entry *sglistarg)
1819{
1820 TW_Command_Full *full_command_packet;
1821 TW_Command_Apache *command_packet;
1822 u32 num_sectors = 0x0;
1823 int i, sg_count;
1824 struct scsi_cmnd *srb = NULL;
FUJITA Tomonori0debe012007-05-26 02:33:31 +09001825 struct scatterlist *sglist = NULL, *sg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001826 int retval = 1;
1827
1828 if (tw_dev->srb[request_id]) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001829 srb = tw_dev->srb[request_id];
FUJITA Tomonori0debe012007-05-26 02:33:31 +09001830 if (scsi_sglist(srb))
1831 sglist = scsi_sglist(srb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001832 }
1833
1834 /* Initialize command packet */
1835 full_command_packet = tw_dev->command_packet_virt[request_id];
1836 full_command_packet->header.header_desc.size_header = 128;
1837 full_command_packet->header.status_block.error = 0;
1838 full_command_packet->header.status_block.severity__reserved = 0;
1839
1840 command_packet = &full_command_packet->command.newcommand;
1841 command_packet->status = 0;
1842 command_packet->opcode__reserved = TW_OPRES_IN(0, TW_OP_EXECUTE_SCSI);
1843
1844 /* We forced 16 byte cdb use earlier */
1845 if (!cdb)
1846 memcpy(command_packet->cdb, srb->cmnd, TW_MAX_CDB_LEN);
1847 else
1848 memcpy(command_packet->cdb, cdb, TW_MAX_CDB_LEN);
1849
1850 if (srb) {
1851 command_packet->unit = srb->device->id;
1852 command_packet->request_id__lunl =
adam radford75913d92006-03-15 12:43:19 -08001853 cpu_to_le16(TW_REQ_LUN_IN(srb->device->lun, request_id));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001854 } else {
1855 command_packet->request_id__lunl =
adam radford75913d92006-03-15 12:43:19 -08001856 cpu_to_le16(TW_REQ_LUN_IN(0, request_id));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001857 command_packet->unit = 0;
1858 }
1859
1860 command_packet->sgl_offset = 16;
1861
1862 if (!sglistarg) {
1863 /* Map sglist from scsi layer to cmd packet */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001864
FUJITA Tomonori0debe012007-05-26 02:33:31 +09001865 if (scsi_sg_count(srb)) {
1866 if ((scsi_sg_count(srb) == 1) &&
1867 (scsi_bufflen(srb) < TW_MIN_SGL_LENGTH)) {
FUJITA Tomonori035f5e02008-03-09 13:44:37 +09001868 if (srb->sc_data_direction == DMA_TO_DEVICE ||
1869 srb->sc_data_direction == DMA_BIDIRECTIONAL)
1870 scsi_sg_copy_to_buffer(srb,
1871 tw_dev->generic_buffer_virt[request_id],
1872 TW_SECTOR_SIZE);
adam radford75913d92006-03-15 12:43:19 -08001873 command_packet->sg_list[0].address = TW_CPU_TO_SGL(tw_dev->generic_buffer_phys[request_id]);
1874 command_packet->sg_list[0].length = cpu_to_le32(TW_MIN_SGL_LENGTH);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001875 } else {
1876 sg_count = twa_map_scsi_sg_data(tw_dev, request_id);
1877 if (sg_count == 0)
1878 goto out;
1879
FUJITA Tomonori0debe012007-05-26 02:33:31 +09001880 scsi_for_each_sg(srb, sg, sg_count, i) {
1881 command_packet->sg_list[i].address = TW_CPU_TO_SGL(sg_dma_address(sg));
1882 command_packet->sg_list[i].length = cpu_to_le32(sg_dma_len(sg));
adam radford75913d92006-03-15 12:43:19 -08001883 if (command_packet->sg_list[i].address & TW_CPU_TO_SGL(TW_ALIGNMENT_9000_SGL)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001884 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x2e, "Found unaligned sgl address during execute scsi");
1885 goto out;
1886 }
1887 }
1888 }
FUJITA Tomonori0debe012007-05-26 02:33:31 +09001889 command_packet->sgl_entries__lunh = cpu_to_le16(TW_REQ_LUN_IN((srb->device->lun >> 4), scsi_sg_count(tw_dev->srb[request_id])));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001890 }
1891 } else {
1892 /* Internal cdb post */
1893 for (i = 0; i < use_sg; i++) {
adam radford75913d92006-03-15 12:43:19 -08001894 command_packet->sg_list[i].address = TW_CPU_TO_SGL(sglistarg[i].address);
1895 command_packet->sg_list[i].length = cpu_to_le32(sglistarg[i].length);
1896 if (command_packet->sg_list[i].address & TW_CPU_TO_SGL(TW_ALIGNMENT_9000_SGL)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001897 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x2f, "Found unaligned sgl address during internal post");
1898 goto out;
1899 }
1900 }
adam radford75913d92006-03-15 12:43:19 -08001901 command_packet->sgl_entries__lunh = cpu_to_le16(TW_REQ_LUN_IN(0, use_sg));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001902 }
1903
1904 if (srb) {
1905 if (srb->cmnd[0] == READ_6 || srb->cmnd[0] == WRITE_6)
1906 num_sectors = (u32)srb->cmnd[4];
1907
1908 if (srb->cmnd[0] == READ_10 || srb->cmnd[0] == WRITE_10)
1909 num_sectors = (u32)srb->cmnd[8] | ((u32)srb->cmnd[7] << 8);
1910 }
1911
1912 /* Update sector statistic */
1913 tw_dev->sector_count = num_sectors;
1914 if (tw_dev->sector_count > tw_dev->max_sector_count)
1915 tw_dev->max_sector_count = tw_dev->sector_count;
1916
1917 /* Update SG statistics */
1918 if (srb) {
FUJITA Tomonori0debe012007-05-26 02:33:31 +09001919 tw_dev->sgl_entries = scsi_sg_count(tw_dev->srb[request_id]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001920 if (tw_dev->sgl_entries > tw_dev->max_sgl_entries)
1921 tw_dev->max_sgl_entries = tw_dev->sgl_entries;
1922 }
1923
1924 /* Now post the command to the board */
1925 if (srb) {
1926 retval = twa_post_command_packet(tw_dev, request_id, 0);
1927 } else {
1928 twa_post_command_packet(tw_dev, request_id, 1);
1929 retval = 0;
1930 }
1931out:
1932 return retval;
1933} /* End twa_scsiop_execute_scsi() */
1934
1935/* This function completes an execute scsi operation */
1936static void twa_scsiop_execute_scsi_complete(TW_Device_Extension *tw_dev, int request_id)
1937{
FUJITA Tomonori0debe012007-05-26 02:33:31 +09001938 struct scsi_cmnd *cmd = tw_dev->srb[request_id];
FUJITA Tomonori0debe012007-05-26 02:33:31 +09001939
1940 if (scsi_bufflen(cmd) < TW_MIN_SGL_LENGTH &&
1941 (cmd->sc_data_direction == DMA_FROM_DEVICE ||
1942 cmd->sc_data_direction == DMA_BIDIRECTIONAL)) {
FUJITA Tomonorib1192d52007-05-31 15:24:03 +09001943 if (scsi_sg_count(cmd) == 1) {
FUJITA Tomonori035f5e02008-03-09 13:44:37 +09001944 void *buf = tw_dev->generic_buffer_virt[request_id];
1945
FUJITA Tomonori035f5e02008-03-09 13:44:37 +09001946 scsi_sg_copy_from_buffer(cmd, buf, TW_SECTOR_SIZE);
adam radfordd327d082005-09-09 15:55:13 -07001947 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001948 }
1949} /* End twa_scsiop_execute_scsi_complete() */
1950
1951/* This function tells the controller to shut down */
1952static void __twa_shutdown(TW_Device_Extension *tw_dev)
1953{
1954 /* Disable interrupts */
1955 TW_DISABLE_INTERRUPTS(tw_dev);
1956
adam radford4039c302006-10-26 18:01:06 -07001957 /* Free up the IRQ */
1958 free_irq(tw_dev->tw_pci_dev->irq, tw_dev);
1959
Linus Torvalds1da177e2005-04-16 15:20:36 -07001960 printk(KERN_WARNING "3w-9xxx: Shutting down host %d.\n", tw_dev->host->host_no);
1961
1962 /* Tell the card we are shutting down */
1963 if (twa_initconnection(tw_dev, 1, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL)) {
1964 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x31, "Connection shutdown failed");
1965 } else {
1966 printk(KERN_WARNING "3w-9xxx: Shutdown complete.\n");
1967 }
1968
1969 /* Clear all interrupts just before exit */
1970 TW_CLEAR_ALL_INTERRUPTS(tw_dev);
1971} /* End __twa_shutdown() */
1972
1973/* Wrapper for __twa_shutdown */
Greg Kroah-Hartmand18c3db2005-06-23 17:35:56 -07001974static void twa_shutdown(struct pci_dev *pdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001975{
Greg Kroah-Hartmand18c3db2005-06-23 17:35:56 -07001976 struct Scsi_Host *host = pci_get_drvdata(pdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001977 TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
1978
1979 __twa_shutdown(tw_dev);
1980} /* End twa_shutdown() */
1981
1982/* This function will look up a string */
1983static char *twa_string_lookup(twa_message_type *table, unsigned int code)
1984{
1985 int index;
1986
1987 for (index = 0; ((code != table[index].code) &&
1988 (table[index].text != (char *)0)); index++);
1989 return(table[index].text);
1990} /* End twa_string_lookup() */
1991
1992/* This function will perform a pci-dma unmap */
1993static void twa_unmap_scsi_data(TW_Device_Extension *tw_dev, int request_id)
1994{
1995 struct scsi_cmnd *cmd = tw_dev->srb[request_id];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001996
adam radford8454e982009-05-05 11:45:37 -07001997 if (cmd->SCp.phase == TW_PHASE_SGLIST)
1998 scsi_dma_unmap(cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001999} /* End twa_unmap_scsi_data() */
2000
adam radford4deedd82010-03-08 12:37:46 -08002001/* This function gets called when a disk is coming on-line */
2002static int twa_slave_configure(struct scsi_device *sdev)
2003{
2004 /* Force 60 second timeout */
2005 blk_queue_rq_timeout(sdev->request_queue, 60 * HZ);
2006
2007 return 0;
2008} /* End twa_slave_configure() */
2009
Linus Torvalds1da177e2005-04-16 15:20:36 -07002010/* scsi_host_template initializer */
2011static struct scsi_host_template driver_template = {
2012 .module = THIS_MODULE,
2013 .name = "3ware 9000 Storage Controller",
2014 .queuecommand = twa_scsi_queue,
2015 .eh_host_reset_handler = twa_scsi_eh_reset,
2016 .bios_param = twa_scsi_biosparam,
2017 .change_queue_depth = twa_change_queue_depth,
2018 .can_queue = TW_Q_LENGTH-2,
adam radford4deedd82010-03-08 12:37:46 -08002019 .slave_configure = twa_slave_configure,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002020 .this_id = -1,
2021 .sg_tablesize = TW_APACHE_MAX_SGL_LENGTH,
2022 .max_sectors = TW_MAX_SECTORS,
2023 .cmd_per_lun = TW_MAX_CMDS_PER_LUN,
2024 .use_clustering = ENABLE_CLUSTERING,
2025 .shost_attrs = twa_host_attrs,
2026 .emulated = 1
2027};
2028
2029/* This function will probe and initialize a card */
2030static int __devinit twa_probe(struct pci_dev *pdev, const struct pci_device_id *dev_id)
2031{
2032 struct Scsi_Host *host = NULL;
2033 TW_Device_Extension *tw_dev;
adam radford3dabec72008-07-22 16:47:40 -07002034 unsigned long mem_addr, mem_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002035 int retval = -ENODEV;
2036
2037 retval = pci_enable_device(pdev);
2038 if (retval) {
2039 TW_PRINTK(host, TW_DRIVER, 0x34, "Failed to enable pci device");
2040 goto out_disable_device;
2041 }
2042
2043 pci_set_master(pdev);
Tony Battersby1e6c38c2007-11-09 13:04:35 -05002044 pci_try_set_mwi(pdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002045
Yang Hongyang6a355282009-04-06 19:01:13 -07002046 if (pci_set_dma_mask(pdev, DMA_BIT_MASK(64))
2047 || pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64)))
Yang Hongyang284901a2009-04-06 19:01:15 -07002048 if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32))
2049 || pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32))) {
adam radford0e78d152007-07-20 15:28:28 -07002050 TW_PRINTK(host, TW_DRIVER, 0x23, "Failed to set dma mask");
2051 retval = -ENODEV;
2052 goto out_disable_device;
2053 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002054
2055 host = scsi_host_alloc(&driver_template, sizeof(TW_Device_Extension));
2056 if (!host) {
2057 TW_PRINTK(host, TW_DRIVER, 0x24, "Failed to allocate memory for device extension");
2058 retval = -ENOMEM;
2059 goto out_disable_device;
2060 }
2061 tw_dev = (TW_Device_Extension *)host->hostdata;
2062
Linus Torvalds1da177e2005-04-16 15:20:36 -07002063 /* Save values to device extension */
2064 tw_dev->host = host;
2065 tw_dev->tw_pci_dev = pdev;
2066
2067 if (twa_initialize_device_extension(tw_dev)) {
2068 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x25, "Failed to initialize device extension");
2069 goto out_free_device_extension;
2070 }
2071
2072 /* Request IO regions */
2073 retval = pci_request_regions(pdev, "3w-9xxx");
2074 if (retval) {
2075 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x26, "Failed to get mem region");
2076 goto out_free_device_extension;
2077 }
2078
adam radford3dabec72008-07-22 16:47:40 -07002079 if (pdev->device == PCI_DEVICE_ID_3WARE_9000) {
adam radford49bfd8d2005-09-21 17:20:14 -07002080 mem_addr = pci_resource_start(pdev, 1);
adam radford3dabec72008-07-22 16:47:40 -07002081 mem_len = pci_resource_len(pdev, 1);
2082 } else {
adam radford49bfd8d2005-09-21 17:20:14 -07002083 mem_addr = pci_resource_start(pdev, 2);
adam radford3dabec72008-07-22 16:47:40 -07002084 mem_len = pci_resource_len(pdev, 2);
2085 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002086
2087 /* Save base address */
adam radford3dabec72008-07-22 16:47:40 -07002088 tw_dev->base_addr = ioremap(mem_addr, mem_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002089 if (!tw_dev->base_addr) {
2090 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x35, "Failed to ioremap");
2091 goto out_release_mem_region;
2092 }
2093
2094 /* Disable interrupts on the card */
2095 TW_DISABLE_INTERRUPTS(tw_dev);
2096
2097 /* Initialize the card */
2098 if (twa_reset_sequence(tw_dev, 0))
adam radford4039c302006-10-26 18:01:06 -07002099 goto out_iounmap;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002100
2101 /* Set host specific parameters */
adam radford0e78d152007-07-20 15:28:28 -07002102 if ((pdev->device == PCI_DEVICE_ID_3WARE_9650SE) ||
2103 (pdev->device == PCI_DEVICE_ID_3WARE_9690SA))
adam radford4039c302006-10-26 18:01:06 -07002104 host->max_id = TW_MAX_UNITS_9650SE;
2105 else
2106 host->max_id = TW_MAX_UNITS;
2107
Linus Torvalds1da177e2005-04-16 15:20:36 -07002108 host->max_cmd_len = TW_MAX_CDB_LEN;
2109
2110 /* Channels aren't supported by adapter */
adam radford4039c302006-10-26 18:01:06 -07002111 host->max_lun = TW_MAX_LUNS(tw_dev->tw_compat_info.working_srl);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002112 host->max_channel = 0;
2113
2114 /* Register the card with the kernel SCSI layer */
2115 retval = scsi_add_host(host, &pdev->dev);
2116 if (retval) {
2117 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x27, "scsi add host failed");
adam radford4039c302006-10-26 18:01:06 -07002118 goto out_iounmap;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002119 }
2120
2121 pci_set_drvdata(pdev, host);
2122
adam radford3dabec72008-07-22 16:47:40 -07002123 printk(KERN_WARNING "3w-9xxx: scsi%d: Found a 3ware 9000 Storage Controller at 0x%lx, IRQ: %d.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002124 host->host_no, mem_addr, pdev->irq);
2125 printk(KERN_WARNING "3w-9xxx: scsi%d: Firmware %s, BIOS %s, Ports: %d.\n",
2126 host->host_no,
2127 (char *)twa_get_param(tw_dev, 0, TW_VERSION_TABLE,
2128 TW_PARAM_FWVER, TW_PARAM_FWVER_LENGTH),
2129 (char *)twa_get_param(tw_dev, 1, TW_VERSION_TABLE,
2130 TW_PARAM_BIOSVER, TW_PARAM_BIOSVER_LENGTH),
adam radford75913d92006-03-15 12:43:19 -08002131 le32_to_cpu(*(int *)twa_get_param(tw_dev, 2, TW_INFORMATION_TABLE,
2132 TW_PARAM_PORTCOUNT, TW_PARAM_PORTCOUNT_LENGTH)));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002133
adam radford3dabec72008-07-22 16:47:40 -07002134 /* Try to enable MSI */
2135 if (use_msi && (pdev->device != PCI_DEVICE_ID_3WARE_9000) &&
2136 !pci_enable_msi(pdev))
2137 set_bit(TW_USING_MSI, &tw_dev->flags);
2138
Linus Torvalds1da177e2005-04-16 15:20:36 -07002139 /* Now setup the interrupt handler */
Thomas Gleixner1d6f3592006-07-01 19:29:42 -07002140 retval = request_irq(pdev->irq, twa_interrupt, IRQF_SHARED, "3w-9xxx", tw_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002141 if (retval) {
2142 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x30, "Error requesting IRQ");
2143 goto out_remove_host;
2144 }
2145
2146 twa_device_extension_list[twa_device_extension_count] = tw_dev;
2147 twa_device_extension_count++;
2148
2149 /* Re-enable interrupts on the card */
2150 TW_ENABLE_AND_CLEAR_INTERRUPTS(tw_dev);
2151
2152 /* Finally, scan the host */
2153 scsi_scan_host(host);
2154
2155 if (twa_major == -1) {
2156 if ((twa_major = register_chrdev (0, "twa", &twa_fops)) < 0)
2157 TW_PRINTK(host, TW_DRIVER, 0x29, "Failed to register character device");
2158 }
2159 return 0;
2160
2161out_remove_host:
adam radford3dabec72008-07-22 16:47:40 -07002162 if (test_bit(TW_USING_MSI, &tw_dev->flags))
2163 pci_disable_msi(pdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002164 scsi_remove_host(host);
adam radford4039c302006-10-26 18:01:06 -07002165out_iounmap:
2166 iounmap(tw_dev->base_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002167out_release_mem_region:
2168 pci_release_regions(pdev);
2169out_free_device_extension:
2170 twa_free_device_extension(tw_dev);
2171 scsi_host_put(host);
2172out_disable_device:
2173 pci_disable_device(pdev);
2174
2175 return retval;
2176} /* End twa_probe() */
2177
2178/* This function is called to remove a device */
2179static void twa_remove(struct pci_dev *pdev)
2180{
2181 struct Scsi_Host *host = pci_get_drvdata(pdev);
2182 TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
2183
2184 scsi_remove_host(tw_dev->host);
2185
2186 /* Unregister character device */
2187 if (twa_major >= 0) {
2188 unregister_chrdev(twa_major, "twa");
2189 twa_major = -1;
2190 }
2191
Linus Torvalds1da177e2005-04-16 15:20:36 -07002192 /* Shutdown the card */
2193 __twa_shutdown(tw_dev);
2194
adam radford3dabec72008-07-22 16:47:40 -07002195 /* Disable MSI if enabled */
2196 if (test_bit(TW_USING_MSI, &tw_dev->flags))
2197 pci_disable_msi(pdev);
2198
adam radford4039c302006-10-26 18:01:06 -07002199 /* Free IO remapping */
2200 iounmap(tw_dev->base_addr);
2201
Linus Torvalds1da177e2005-04-16 15:20:36 -07002202 /* Free up the mem region */
2203 pci_release_regions(pdev);
2204
2205 /* Free up device extension resources */
2206 twa_free_device_extension(tw_dev);
2207
2208 scsi_host_put(tw_dev->host);
2209 pci_disable_device(pdev);
2210 twa_device_extension_count--;
2211} /* End twa_remove() */
2212
adam radford7a252fe2009-03-09 12:15:01 -08002213#ifdef CONFIG_PM
2214/* This function is called on PCI suspend */
2215static int twa_suspend(struct pci_dev *pdev, pm_message_t state)
2216{
2217 struct Scsi_Host *host = pci_get_drvdata(pdev);
2218 TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
2219
2220 printk(KERN_WARNING "3w-9xxx: Suspending host %d.\n", tw_dev->host->host_no);
2221
2222 TW_DISABLE_INTERRUPTS(tw_dev);
2223 free_irq(tw_dev->tw_pci_dev->irq, tw_dev);
2224
2225 if (test_bit(TW_USING_MSI, &tw_dev->flags))
2226 pci_disable_msi(pdev);
2227
2228 /* Tell the card we are shutting down */
2229 if (twa_initconnection(tw_dev, 1, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL)) {
2230 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x38, "Connection shutdown failed during suspend");
2231 } else {
2232 printk(KERN_WARNING "3w-9xxx: Suspend complete.\n");
2233 }
2234 TW_CLEAR_ALL_INTERRUPTS(tw_dev);
2235
2236 pci_save_state(pdev);
2237 pci_disable_device(pdev);
2238 pci_set_power_state(pdev, pci_choose_state(pdev, state));
2239
2240 return 0;
2241} /* End twa_suspend() */
2242
2243/* This function is called on PCI resume */
2244static int twa_resume(struct pci_dev *pdev)
2245{
2246 int retval = 0;
2247 struct Scsi_Host *host = pci_get_drvdata(pdev);
2248 TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
2249
2250 printk(KERN_WARNING "3w-9xxx: Resuming host %d.\n", tw_dev->host->host_no);
2251 pci_set_power_state(pdev, PCI_D0);
2252 pci_enable_wake(pdev, PCI_D0, 0);
2253 pci_restore_state(pdev);
2254
2255 retval = pci_enable_device(pdev);
2256 if (retval) {
2257 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x39, "Enable device failed during resume");
2258 return retval;
2259 }
2260
2261 pci_set_master(pdev);
2262 pci_try_set_mwi(pdev);
2263
Yang Hongyange9304382009-04-13 14:40:14 -07002264 if (pci_set_dma_mask(pdev, DMA_BIT_MASK(64))
2265 || pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64)))
2266 if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32))
2267 || pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32))) {
adam radford7a252fe2009-03-09 12:15:01 -08002268 TW_PRINTK(host, TW_DRIVER, 0x40, "Failed to set dma mask during resume");
2269 retval = -ENODEV;
2270 goto out_disable_device;
2271 }
2272
2273 /* Initialize the card */
2274 if (twa_reset_sequence(tw_dev, 0)) {
2275 retval = -ENODEV;
2276 goto out_disable_device;
2277 }
2278
2279 /* Now setup the interrupt handler */
2280 retval = request_irq(pdev->irq, twa_interrupt, IRQF_SHARED, "3w-9xxx", tw_dev);
2281 if (retval) {
2282 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x42, "Error requesting IRQ during resume");
2283 retval = -ENODEV;
2284 goto out_disable_device;
2285 }
2286
2287 /* Now enable MSI if enabled */
2288 if (test_bit(TW_USING_MSI, &tw_dev->flags))
2289 pci_enable_msi(pdev);
2290
2291 /* Re-enable interrupts on the card */
2292 TW_ENABLE_AND_CLEAR_INTERRUPTS(tw_dev);
2293
2294 printk(KERN_WARNING "3w-9xxx: Resume complete.\n");
2295 return 0;
2296
2297out_disable_device:
2298 scsi_remove_host(host);
2299 pci_disable_device(pdev);
2300
2301 return retval;
2302} /* End twa_resume() */
2303#endif
2304
Linus Torvalds1da177e2005-04-16 15:20:36 -07002305/* PCI Devices supported by this driver */
2306static struct pci_device_id twa_pci_tbl[] __devinitdata = {
2307 { PCI_VENDOR_ID_3WARE, PCI_DEVICE_ID_3WARE_9000,
2308 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
adam radford49bfd8d2005-09-21 17:20:14 -07002309 { PCI_VENDOR_ID_3WARE, PCI_DEVICE_ID_3WARE_9550SX,
2310 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
adam radford4039c302006-10-26 18:01:06 -07002311 { PCI_VENDOR_ID_3WARE, PCI_DEVICE_ID_3WARE_9650SE,
2312 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
adam radford0e78d152007-07-20 15:28:28 -07002313 { PCI_VENDOR_ID_3WARE, PCI_DEVICE_ID_3WARE_9690SA,
2314 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
Linus Torvalds1da177e2005-04-16 15:20:36 -07002315 { }
2316};
2317MODULE_DEVICE_TABLE(pci, twa_pci_tbl);
2318
2319/* pci_driver initializer */
2320static struct pci_driver twa_driver = {
2321 .name = "3w-9xxx",
2322 .id_table = twa_pci_tbl,
2323 .probe = twa_probe,
2324 .remove = twa_remove,
adam radford7a252fe2009-03-09 12:15:01 -08002325#ifdef CONFIG_PM
2326 .suspend = twa_suspend,
2327 .resume = twa_resume,
2328#endif
Greg Kroah-Hartmand18c3db2005-06-23 17:35:56 -07002329 .shutdown = twa_shutdown
Linus Torvalds1da177e2005-04-16 15:20:36 -07002330};
2331
2332/* This function is called on driver initialization */
2333static int __init twa_init(void)
2334{
2335 printk(KERN_WARNING "3ware 9000 Storage Controller device driver for Linux v%s.\n", TW_DRIVER_VERSION);
2336
Henrik Kretzschmardcbccbde2006-09-25 16:58:58 -07002337 return pci_register_driver(&twa_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002338} /* End twa_init() */
2339
2340/* This function is called on driver exit */
2341static void __exit twa_exit(void)
2342{
2343 pci_unregister_driver(&twa_driver);
2344} /* End twa_exit() */
2345
2346module_init(twa_init);
2347module_exit(twa_exit);
2348