blob: cd4129ff7ae4cbb31d47fd87be6c5e2dab5685cf [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 Sorensena12e25bd2006-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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192/* Create sysfs 'stats' entry */
Tony Jonesee959b02008-02-22 00:13:36 +0100193static struct device_attribute twa_host_stats_attr = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194 .attr = {
195 .name = "stats",
196 .mode = S_IRUGO,
197 },
198 .show = twa_show_stats
199};
200
201/* Host attributes initializer */
Tony Jonesee959b02008-02-22 00:13:36 +0100202static struct device_attribute *twa_host_attrs[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203 &twa_host_stats_attr,
204 NULL,
205};
206
207/* File operations struct for character device */
Arjan van de Ven00977a52007-02-12 00:55:34 -0800208static const struct file_operations twa_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209 .owner = THIS_MODULE,
Arnd Bergmannf4927c42010-04-27 00:24:01 +0200210 .unlocked_ioctl = twa_chrdev_ioctl,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211 .open = twa_chrdev_open,
Arnd Bergmann6038f372010-08-15 18:52:59 +0200212 .release = NULL,
213 .llseek = noop_llseek,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214};
215
216/* This function will complete an aen request from the isr */
217static int twa_aen_complete(TW_Device_Extension *tw_dev, int request_id)
218{
219 TW_Command_Full *full_command_packet;
220 TW_Command *command_packet;
221 TW_Command_Apache_Header *header;
222 unsigned short aen;
223 int retval = 1;
224
225 header = (TW_Command_Apache_Header *)tw_dev->generic_buffer_virt[request_id];
226 tw_dev->posted_request_count--;
adam radford75913d92006-03-15 12:43:19 -0800227 aen = le16_to_cpu(header->status_block.error);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228 full_command_packet = tw_dev->command_packet_virt[request_id];
229 command_packet = &full_command_packet->command.oldcommand;
230
231 /* First check for internal completion of set param for time sync */
232 if (TW_OP_OUT(command_packet->opcode__sgloffset) == TW_OP_SET_PARAM) {
233 /* Keep reading the queue in case there are more aen's */
234 if (twa_aen_read_queue(tw_dev, request_id))
235 goto out2;
236 else {
237 retval = 0;
238 goto out;
239 }
240 }
241
242 switch (aen) {
243 case TW_AEN_QUEUE_EMPTY:
244 /* Quit reading the queue if this is the last one */
245 break;
246 case TW_AEN_SYNC_TIME_WITH_HOST:
247 twa_aen_sync_time(tw_dev, request_id);
248 retval = 0;
249 goto out;
250 default:
251 twa_aen_queue_event(tw_dev, header);
252
253 /* If there are more aen's, keep reading the queue */
254 if (twa_aen_read_queue(tw_dev, request_id))
255 goto out2;
256 else {
257 retval = 0;
258 goto out;
259 }
260 }
261 retval = 0;
262out2:
263 tw_dev->state[request_id] = TW_S_COMPLETED;
264 twa_free_request_id(tw_dev, request_id);
265 clear_bit(TW_IN_ATTENTION_LOOP, &tw_dev->flags);
266out:
267 return retval;
268} /* End twa_aen_complete() */
269
270/* This function will drain aen queue */
271static int twa_aen_drain_queue(TW_Device_Extension *tw_dev, int no_check_reset)
272{
273 int request_id = 0;
274 char cdb[TW_MAX_CDB_LEN];
275 TW_SG_Entry sglist[1];
276 int finished = 0, count = 0;
277 TW_Command_Full *full_command_packet;
278 TW_Command_Apache_Header *header;
279 unsigned short aen;
280 int first_reset = 0, queue = 0, retval = 1;
281
282 if (no_check_reset)
283 first_reset = 0;
284 else
285 first_reset = 1;
286
287 full_command_packet = tw_dev->command_packet_virt[request_id];
288 memset(full_command_packet, 0, sizeof(TW_Command_Full));
289
290 /* Initialize cdb */
291 memset(&cdb, 0, TW_MAX_CDB_LEN);
292 cdb[0] = REQUEST_SENSE; /* opcode */
293 cdb[4] = TW_ALLOCATION_LENGTH; /* allocation length */
294
295 /* Initialize sglist */
296 memset(&sglist, 0, sizeof(TW_SG_Entry));
297 sglist[0].length = TW_SECTOR_SIZE;
298 sglist[0].address = tw_dev->generic_buffer_phys[request_id];
299
300 if (sglist[0].address & TW_ALIGNMENT_9000_SGL) {
301 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1, "Found unaligned address during AEN drain");
302 goto out;
303 }
304
305 /* Mark internal command */
306 tw_dev->srb[request_id] = NULL;
307
308 do {
309 /* Send command to the board */
310 if (twa_scsiop_execute_scsi(tw_dev, request_id, cdb, 1, sglist)) {
311 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x2, "Error posting request sense");
312 goto out;
313 }
314
315 /* Now poll for completion */
316 if (twa_poll_response(tw_dev, request_id, 30)) {
317 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x3, "No valid response while draining AEN queue");
318 tw_dev->posted_request_count--;
319 goto out;
320 }
321
322 tw_dev->posted_request_count--;
323 header = (TW_Command_Apache_Header *)tw_dev->generic_buffer_virt[request_id];
adam radford75913d92006-03-15 12:43:19 -0800324 aen = le16_to_cpu(header->status_block.error);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325 queue = 0;
326 count++;
327
328 switch (aen) {
329 case TW_AEN_QUEUE_EMPTY:
330 if (first_reset != 1)
331 goto out;
332 else
333 finished = 1;
334 break;
335 case TW_AEN_SOFT_RESET:
336 if (first_reset == 0)
337 first_reset = 1;
338 else
339 queue = 1;
340 break;
341 case TW_AEN_SYNC_TIME_WITH_HOST:
342 break;
343 default:
344 queue = 1;
345 }
346
347 /* Now queue an event info */
348 if (queue)
349 twa_aen_queue_event(tw_dev, header);
350 } while ((finished == 0) && (count < TW_MAX_AEN_DRAIN));
351
352 if (count == TW_MAX_AEN_DRAIN)
353 goto out;
354
355 retval = 0;
356out:
357 tw_dev->state[request_id] = TW_S_INITIAL;
358 return retval;
359} /* End twa_aen_drain_queue() */
360
361/* This function will queue an event */
362static void twa_aen_queue_event(TW_Device_Extension *tw_dev, TW_Command_Apache_Header *header)
363{
364 u32 local_time;
365 struct timeval time;
366 TW_Event *event;
367 unsigned short aen;
368 char host[16];
369 char *error_str;
370
371 tw_dev->aen_count++;
372
373 /* Fill out event info */
374 event = tw_dev->event_queue[tw_dev->error_index];
375
376 /* Check for clobber */
377 host[0] = '\0';
378 if (tw_dev->host) {
379 sprintf(host, " scsi%d:", tw_dev->host->host_no);
380 if (event->retrieved == TW_AEN_NOT_RETRIEVED)
381 tw_dev->aen_clobber = 1;
382 }
383
adam radford75913d92006-03-15 12:43:19 -0800384 aen = le16_to_cpu(header->status_block.error);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385 memset(event, 0, sizeof(TW_Event));
386
387 event->severity = TW_SEV_OUT(header->status_block.severity__reserved);
388 do_gettimeofday(&time);
389 local_time = (u32)(time.tv_sec - (sys_tz.tz_minuteswest * 60));
390 event->time_stamp_sec = local_time;
391 event->aen_code = aen;
392 event->retrieved = TW_AEN_NOT_RETRIEVED;
393 event->sequence_id = tw_dev->error_sequence_id;
394 tw_dev->error_sequence_id++;
395
396 /* Check for embedded error string */
397 error_str = &(header->err_specific_desc[strlen(header->err_specific_desc)+1]);
398
399 header->err_specific_desc[sizeof(header->err_specific_desc) - 1] = '\0';
400 event->parameter_len = strlen(header->err_specific_desc);
adam radford75913d92006-03-15 12:43:19 -0800401 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 -0700402 if (event->severity != TW_AEN_SEVERITY_DEBUG)
403 printk(KERN_WARNING "3w-9xxx:%s AEN: %s (0x%02X:0x%04X): %s:%s.\n",
404 host,
405 twa_aen_severity_lookup(TW_SEV_OUT(header->status_block.severity__reserved)),
406 TW_MESSAGE_SOURCE_CONTROLLER_EVENT, aen,
407 error_str[0] == '\0' ? twa_string_lookup(twa_aen_table, aen) : error_str,
408 header->err_specific_desc);
409 else
410 tw_dev->aen_count--;
411
412 if ((tw_dev->error_index + 1) == TW_Q_LENGTH)
413 tw_dev->event_queue_wrapped = 1;
414 tw_dev->error_index = (tw_dev->error_index + 1 ) % TW_Q_LENGTH;
415} /* End twa_aen_queue_event() */
416
417/* This function will read the aen queue from the isr */
418static int twa_aen_read_queue(TW_Device_Extension *tw_dev, int request_id)
419{
420 char cdb[TW_MAX_CDB_LEN];
421 TW_SG_Entry sglist[1];
422 TW_Command_Full *full_command_packet;
423 int retval = 1;
424
425 full_command_packet = tw_dev->command_packet_virt[request_id];
426 memset(full_command_packet, 0, sizeof(TW_Command_Full));
427
428 /* Initialize cdb */
429 memset(&cdb, 0, TW_MAX_CDB_LEN);
430 cdb[0] = REQUEST_SENSE; /* opcode */
431 cdb[4] = TW_ALLOCATION_LENGTH; /* allocation length */
432
433 /* Initialize sglist */
434 memset(&sglist, 0, sizeof(TW_SG_Entry));
435 sglist[0].length = TW_SECTOR_SIZE;
436 sglist[0].address = tw_dev->generic_buffer_phys[request_id];
437
438 /* Mark internal command */
439 tw_dev->srb[request_id] = NULL;
440
441 /* Now post the command packet */
442 if (twa_scsiop_execute_scsi(tw_dev, request_id, cdb, 1, sglist)) {
443 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x4, "Post failed while reading AEN queue");
444 goto out;
445 }
446 retval = 0;
447out:
448 return retval;
449} /* End twa_aen_read_queue() */
450
451/* This function will look up an AEN severity string */
452static char *twa_aen_severity_lookup(unsigned char severity_code)
453{
454 char *retval = NULL;
455
456 if ((severity_code < (unsigned char) TW_AEN_SEVERITY_ERROR) ||
457 (severity_code > (unsigned char) TW_AEN_SEVERITY_DEBUG))
458 goto out;
459
460 retval = twa_aen_severity_table[severity_code];
461out:
462 return retval;
463} /* End twa_aen_severity_lookup() */
464
465/* This function will sync firmware time with the host time */
466static void twa_aen_sync_time(TW_Device_Extension *tw_dev, int request_id)
467{
468 u32 schedulertime;
469 struct timeval utc;
470 TW_Command_Full *full_command_packet;
471 TW_Command *command_packet;
472 TW_Param_Apache *param;
473 u32 local_time;
474
475 /* Fill out the command packet */
476 full_command_packet = tw_dev->command_packet_virt[request_id];
477 memset(full_command_packet, 0, sizeof(TW_Command_Full));
478 command_packet = &full_command_packet->command.oldcommand;
479 command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_SET_PARAM);
480 command_packet->request_id = request_id;
adam radford75913d92006-03-15 12:43:19 -0800481 command_packet->byte8_offset.param.sgl[0].address = TW_CPU_TO_SGL(tw_dev->generic_buffer_phys[request_id]);
482 command_packet->byte8_offset.param.sgl[0].length = cpu_to_le32(TW_SECTOR_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483 command_packet->size = TW_COMMAND_SIZE;
adam radford75913d92006-03-15 12:43:19 -0800484 command_packet->byte6_offset.parameter_count = cpu_to_le16(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485
486 /* Setup the param */
487 param = (TW_Param_Apache *)tw_dev->generic_buffer_virt[request_id];
488 memset(param, 0, TW_SECTOR_SIZE);
adam radford75913d92006-03-15 12:43:19 -0800489 param->table_id = cpu_to_le16(TW_TIMEKEEP_TABLE | 0x8000); /* Controller time keep table */
490 param->parameter_id = cpu_to_le16(0x3); /* SchedulerTime */
491 param->parameter_size_bytes = cpu_to_le16(4);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492
493 /* Convert system time in UTC to local time seconds since last
494 Sunday 12:00AM */
495 do_gettimeofday(&utc);
496 local_time = (u32)(utc.tv_sec - (sys_tz.tz_minuteswest * 60));
497 schedulertime = local_time - (3 * 86400);
adam radford75913d92006-03-15 12:43:19 -0800498 schedulertime = cpu_to_le32(schedulertime % 604800);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499
500 memcpy(param->data, &schedulertime, sizeof(u32));
501
502 /* Mark internal command */
503 tw_dev->srb[request_id] = NULL;
504
505 /* Now post the command */
506 twa_post_command_packet(tw_dev, request_id, 1);
507} /* End twa_aen_sync_time() */
508
509/* This function will allocate memory and check if it is correctly aligned */
510static int twa_allocate_memory(TW_Device_Extension *tw_dev, int size, int which)
511{
512 int i;
513 dma_addr_t dma_handle;
514 unsigned long *cpu_addr;
515 int retval = 1;
516
517 cpu_addr = pci_alloc_consistent(tw_dev->tw_pci_dev, size*TW_Q_LENGTH, &dma_handle);
518 if (!cpu_addr) {
519 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x5, "Memory allocation failed");
520 goto out;
521 }
522
523 if ((unsigned long)cpu_addr % (TW_ALIGNMENT_9000)) {
524 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x6, "Failed to allocate correctly aligned memory");
525 pci_free_consistent(tw_dev->tw_pci_dev, size*TW_Q_LENGTH, cpu_addr, dma_handle);
526 goto out;
527 }
528
529 memset(cpu_addr, 0, size*TW_Q_LENGTH);
530
531 for (i = 0; i < TW_Q_LENGTH; i++) {
532 switch(which) {
533 case 0:
534 tw_dev->command_packet_phys[i] = dma_handle+(i*size);
535 tw_dev->command_packet_virt[i] = (TW_Command_Full *)((unsigned char *)cpu_addr + (i*size));
536 break;
537 case 1:
538 tw_dev->generic_buffer_phys[i] = dma_handle+(i*size);
539 tw_dev->generic_buffer_virt[i] = (unsigned long *)((unsigned char *)cpu_addr + (i*size));
540 break;
541 }
542 }
543 retval = 0;
544out:
545 return retval;
546} /* End twa_allocate_memory() */
547
548/* This function will check the status register for unexpected bits */
549static int twa_check_bits(u32 status_reg_value)
550{
551 int retval = 1;
552
553 if ((status_reg_value & TW_STATUS_EXPECTED_BITS) != TW_STATUS_EXPECTED_BITS)
554 goto out;
555 if ((status_reg_value & TW_STATUS_UNEXPECTED_BITS) != 0)
556 goto out;
557
558 retval = 0;
559out:
560 return retval;
561} /* End twa_check_bits() */
562
563/* This function will check the srl and decide if we are compatible */
564static int twa_check_srl(TW_Device_Extension *tw_dev, int *flashed)
565{
566 int retval = 1;
567 unsigned short fw_on_ctlr_srl = 0, fw_on_ctlr_arch_id = 0;
568 unsigned short fw_on_ctlr_branch = 0, fw_on_ctlr_build = 0;
569 u32 init_connect_result = 0;
570
571 if (twa_initconnection(tw_dev, TW_INIT_MESSAGE_CREDITS,
572 TW_EXTENDED_INIT_CONNECT, TW_CURRENT_DRIVER_SRL,
573 TW_9000_ARCH_ID, TW_CURRENT_DRIVER_BRANCH,
574 TW_CURRENT_DRIVER_BUILD, &fw_on_ctlr_srl,
575 &fw_on_ctlr_arch_id, &fw_on_ctlr_branch,
576 &fw_on_ctlr_build, &init_connect_result)) {
577 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x7, "Initconnection failed while checking SRL");
578 goto out;
579 }
580
adam radford4039c302006-10-26 18:01:06 -0700581 tw_dev->tw_compat_info.working_srl = fw_on_ctlr_srl;
582 tw_dev->tw_compat_info.working_branch = fw_on_ctlr_branch;
583 tw_dev->tw_compat_info.working_build = fw_on_ctlr_build;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584
585 /* Try base mode compatibility */
586 if (!(init_connect_result & TW_CTLR_FW_COMPATIBLE)) {
587 if (twa_initconnection(tw_dev, TW_INIT_MESSAGE_CREDITS,
588 TW_EXTENDED_INIT_CONNECT,
589 TW_BASE_FW_SRL, TW_9000_ARCH_ID,
590 TW_BASE_FW_BRANCH, TW_BASE_FW_BUILD,
591 &fw_on_ctlr_srl, &fw_on_ctlr_arch_id,
592 &fw_on_ctlr_branch, &fw_on_ctlr_build,
593 &init_connect_result)) {
594 TW_PRINTK(tw_dev->host, TW_DRIVER, 0xa, "Initconnection (base mode) failed while checking SRL");
595 goto out;
596 }
597 if (!(init_connect_result & TW_CTLR_FW_COMPATIBLE)) {
598 if (TW_CURRENT_DRIVER_SRL > fw_on_ctlr_srl) {
599 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x32, "Firmware and driver incompatibility: please upgrade firmware");
600 } else {
601 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x33, "Firmware and driver incompatibility: please upgrade driver");
602 }
603 goto out;
604 }
adam radford4039c302006-10-26 18:01:06 -0700605 tw_dev->tw_compat_info.working_srl = TW_BASE_FW_SRL;
606 tw_dev->tw_compat_info.working_branch = TW_BASE_FW_BRANCH;
607 tw_dev->tw_compat_info.working_build = TW_BASE_FW_BUILD;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608 }
adam radford4039c302006-10-26 18:01:06 -0700609
610 /* Load rest of compatibility struct */
611 strncpy(tw_dev->tw_compat_info.driver_version, TW_DRIVER_VERSION, strlen(TW_DRIVER_VERSION));
612 tw_dev->tw_compat_info.driver_srl_high = TW_CURRENT_DRIVER_SRL;
613 tw_dev->tw_compat_info.driver_branch_high = TW_CURRENT_DRIVER_BRANCH;
614 tw_dev->tw_compat_info.driver_build_high = TW_CURRENT_DRIVER_BUILD;
615 tw_dev->tw_compat_info.driver_srl_low = TW_BASE_FW_SRL;
616 tw_dev->tw_compat_info.driver_branch_low = TW_BASE_FW_BRANCH;
617 tw_dev->tw_compat_info.driver_build_low = TW_BASE_FW_BUILD;
618 tw_dev->tw_compat_info.fw_on_ctlr_srl = fw_on_ctlr_srl;
619 tw_dev->tw_compat_info.fw_on_ctlr_branch = fw_on_ctlr_branch;
620 tw_dev->tw_compat_info.fw_on_ctlr_build = fw_on_ctlr_build;
621
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622 retval = 0;
623out:
624 return retval;
625} /* End twa_check_srl() */
626
627/* This function handles ioctl for the character device */
Arnd Bergmannf4927c42010-04-27 00:24:01 +0200628static long twa_chrdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629{
Al Viro496ad9a2013-01-23 17:07:38 -0500630 struct inode *inode = file_inode(file);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631 long timeout;
632 unsigned long *cpu_addr, data_buffer_length_adjusted = 0, flags = 0;
633 dma_addr_t dma_handle;
634 int request_id = 0;
635 unsigned int sequence_id = 0;
636 unsigned char event_index, start_index;
637 TW_Ioctl_Driver_Command driver_command;
638 TW_Ioctl_Buf_Apache *tw_ioctl;
639 TW_Lock *tw_lock;
640 TW_Command_Full *full_command_packet;
641 TW_Compatibility_Info *tw_compat_info;
642 TW_Event *event;
643 struct timeval current_time;
644 u32 current_time_ms;
645 TW_Device_Extension *tw_dev = twa_device_extension_list[iminor(inode)];
646 int retval = TW_IOCTL_ERROR_OS_EFAULT;
647 void __user *argp = (void __user *)arg;
648
Arnd Bergmannc45d15d2010-06-02 14:28:52 +0200649 mutex_lock(&twa_chrdev_mutex);
Arnd Bergmannf4927c42010-04-27 00:24:01 +0200650
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651 /* Only let one of these through at a time */
Jes Sorensena12e25bd2006-01-11 08:39:45 -0500652 if (mutex_lock_interruptible(&tw_dev->ioctl_lock)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653 retval = TW_IOCTL_ERROR_OS_EINTR;
654 goto out;
655 }
656
657 /* First copy down the driver command */
658 if (copy_from_user(&driver_command, argp, sizeof(TW_Ioctl_Driver_Command)))
659 goto out2;
660
661 /* Check data buffer size */
adam radford4039c302006-10-26 18:01:06 -0700662 if (driver_command.buffer_length > TW_MAX_SECTORS * 2048) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663 retval = TW_IOCTL_ERROR_OS_EINVAL;
664 goto out2;
665 }
666
667 /* Hardware can only do multiple of 512 byte transfers */
668 data_buffer_length_adjusted = (driver_command.buffer_length + 511) & ~511;
669
670 /* Now allocate ioctl buf memory */
671 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);
672 if (!cpu_addr) {
673 retval = TW_IOCTL_ERROR_OS_ENOMEM;
674 goto out2;
675 }
676
677 tw_ioctl = (TW_Ioctl_Buf_Apache *)cpu_addr;
678
679 /* Now copy down the entire ioctl */
680 if (copy_from_user(tw_ioctl, argp, driver_command.buffer_length + sizeof(TW_Ioctl_Buf_Apache) - 1))
681 goto out3;
682
683 /* See which ioctl we are doing */
684 switch (cmd) {
685 case TW_IOCTL_FIRMWARE_PASS_THROUGH:
686 spin_lock_irqsave(tw_dev->host->host_lock, flags);
687 twa_get_request_id(tw_dev, &request_id);
688
689 /* Flag internal command */
690 tw_dev->srb[request_id] = NULL;
691
692 /* Flag chrdev ioctl */
693 tw_dev->chrdev_request_id = request_id;
694
695 full_command_packet = &tw_ioctl->firmware_command;
696
697 /* Load request id and sglist for both command types */
adam radford0e78d152007-07-20 15:28:28 -0700698 twa_load_sgl(tw_dev, full_command_packet, request_id, dma_handle, data_buffer_length_adjusted);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699
700 memcpy(tw_dev->command_packet_virt[request_id], &(tw_ioctl->firmware_command), sizeof(TW_Command_Full));
701
702 /* Now post the command packet to the controller */
703 twa_post_command_packet(tw_dev, request_id, 1);
704 spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
705
706 timeout = TW_IOCTL_CHRDEV_TIMEOUT*HZ;
707
708 /* Now wait for command to complete */
709 timeout = wait_event_timeout(tw_dev->ioctl_wqueue, tw_dev->chrdev_request_id == TW_IOCTL_CHRDEV_FREE, timeout);
710
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711 /* We timed out, and didn't get an interrupt */
712 if (tw_dev->chrdev_request_id != TW_IOCTL_CHRDEV_FREE) {
713 /* Now we need to reset the board */
714 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 -0700715 tw_dev->host->host_no, TW_DRIVER, 0x37,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716 cmd);
717 retval = TW_IOCTL_ERROR_OS_EIO;
adam radford0e78d152007-07-20 15:28:28 -0700718 twa_reset_device_extension(tw_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719 goto out3;
720 }
721
722 /* Now copy in the command packet response */
723 memcpy(&(tw_ioctl->firmware_command), tw_dev->command_packet_virt[request_id], sizeof(TW_Command_Full));
724
725 /* Now complete the io */
726 spin_lock_irqsave(tw_dev->host->host_lock, flags);
727 tw_dev->posted_request_count--;
728 tw_dev->state[request_id] = TW_S_COMPLETED;
729 twa_free_request_id(tw_dev, request_id);
730 spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
731 break;
732 case TW_IOCTL_GET_COMPATIBILITY_INFO:
733 tw_ioctl->driver_command.status = 0;
Dirk Hohndel06fe9fb2009-09-28 21:43:57 -0400734 /* Copy compatibility struct into ioctl data buffer */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735 tw_compat_info = (TW_Compatibility_Info *)tw_ioctl->data_buffer;
adam radford4039c302006-10-26 18:01:06 -0700736 memcpy(tw_compat_info, &tw_dev->tw_compat_info, sizeof(TW_Compatibility_Info));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700737 break;
738 case TW_IOCTL_GET_LAST_EVENT:
739 if (tw_dev->event_queue_wrapped) {
740 if (tw_dev->aen_clobber) {
741 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_AEN_CLOBBER;
742 tw_dev->aen_clobber = 0;
743 } else
744 tw_ioctl->driver_command.status = 0;
745 } else {
746 if (!tw_dev->error_index) {
747 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS;
748 break;
749 }
750 tw_ioctl->driver_command.status = 0;
751 }
752 event_index = (tw_dev->error_index - 1 + TW_Q_LENGTH) % TW_Q_LENGTH;
753 memcpy(tw_ioctl->data_buffer, tw_dev->event_queue[event_index], sizeof(TW_Event));
754 tw_dev->event_queue[event_index]->retrieved = TW_AEN_RETRIEVED;
755 break;
756 case TW_IOCTL_GET_FIRST_EVENT:
757 if (tw_dev->event_queue_wrapped) {
758 if (tw_dev->aen_clobber) {
759 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_AEN_CLOBBER;
760 tw_dev->aen_clobber = 0;
761 } else
762 tw_ioctl->driver_command.status = 0;
763 event_index = tw_dev->error_index;
764 } else {
765 if (!tw_dev->error_index) {
766 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS;
767 break;
768 }
769 tw_ioctl->driver_command.status = 0;
770 event_index = 0;
771 }
772 memcpy(tw_ioctl->data_buffer, tw_dev->event_queue[event_index], sizeof(TW_Event));
773 tw_dev->event_queue[event_index]->retrieved = TW_AEN_RETRIEVED;
774 break;
775 case TW_IOCTL_GET_NEXT_EVENT:
776 event = (TW_Event *)tw_ioctl->data_buffer;
777 sequence_id = event->sequence_id;
778 tw_ioctl->driver_command.status = 0;
779
780 if (tw_dev->event_queue_wrapped) {
781 if (tw_dev->aen_clobber) {
782 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_AEN_CLOBBER;
783 tw_dev->aen_clobber = 0;
784 }
785 start_index = tw_dev->error_index;
786 } else {
787 if (!tw_dev->error_index) {
788 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS;
789 break;
790 }
791 start_index = 0;
792 }
793 event_index = (start_index + sequence_id - tw_dev->event_queue[start_index]->sequence_id + 1) % TW_Q_LENGTH;
794
795 if (!(tw_dev->event_queue[event_index]->sequence_id > sequence_id)) {
796 if (tw_ioctl->driver_command.status == TW_IOCTL_ERROR_STATUS_AEN_CLOBBER)
797 tw_dev->aen_clobber = 1;
798 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS;
799 break;
800 }
801 memcpy(tw_ioctl->data_buffer, tw_dev->event_queue[event_index], sizeof(TW_Event));
802 tw_dev->event_queue[event_index]->retrieved = TW_AEN_RETRIEVED;
803 break;
804 case TW_IOCTL_GET_PREVIOUS_EVENT:
805 event = (TW_Event *)tw_ioctl->data_buffer;
806 sequence_id = event->sequence_id;
807 tw_ioctl->driver_command.status = 0;
808
809 if (tw_dev->event_queue_wrapped) {
810 if (tw_dev->aen_clobber) {
811 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_AEN_CLOBBER;
812 tw_dev->aen_clobber = 0;
813 }
814 start_index = tw_dev->error_index;
815 } else {
816 if (!tw_dev->error_index) {
817 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS;
818 break;
819 }
820 start_index = 0;
821 }
822 event_index = (start_index + sequence_id - tw_dev->event_queue[start_index]->sequence_id - 1) % TW_Q_LENGTH;
823
824 if (!(tw_dev->event_queue[event_index]->sequence_id < sequence_id)) {
825 if (tw_ioctl->driver_command.status == TW_IOCTL_ERROR_STATUS_AEN_CLOBBER)
826 tw_dev->aen_clobber = 1;
827 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS;
828 break;
829 }
830 memcpy(tw_ioctl->data_buffer, tw_dev->event_queue[event_index], sizeof(TW_Event));
831 tw_dev->event_queue[event_index]->retrieved = TW_AEN_RETRIEVED;
832 break;
833 case TW_IOCTL_GET_LOCK:
834 tw_lock = (TW_Lock *)tw_ioctl->data_buffer;
835 do_gettimeofday(&current_time);
836 current_time_ms = (current_time.tv_sec * 1000) + (current_time.tv_usec / 1000);
837
838 if ((tw_lock->force_flag == 1) || (tw_dev->ioctl_sem_lock == 0) || (current_time_ms >= tw_dev->ioctl_msec)) {
839 tw_dev->ioctl_sem_lock = 1;
840 tw_dev->ioctl_msec = current_time_ms + tw_lock->timeout_msec;
841 tw_ioctl->driver_command.status = 0;
842 tw_lock->time_remaining_msec = tw_lock->timeout_msec;
843 } else {
844 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_LOCKED;
845 tw_lock->time_remaining_msec = tw_dev->ioctl_msec - current_time_ms;
846 }
847 break;
848 case TW_IOCTL_RELEASE_LOCK:
849 if (tw_dev->ioctl_sem_lock == 1) {
850 tw_dev->ioctl_sem_lock = 0;
851 tw_ioctl->driver_command.status = 0;
852 } else {
853 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NOT_LOCKED;
854 }
855 break;
856 default:
857 retval = TW_IOCTL_ERROR_OS_ENOTTY;
858 goto out3;
859 }
860
861 /* Now copy the entire response to userspace */
862 if (copy_to_user(argp, tw_ioctl, sizeof(TW_Ioctl_Buf_Apache) + driver_command.buffer_length - 1) == 0)
863 retval = 0;
864out3:
865 /* Now free ioctl buf memory */
866 dma_free_coherent(&tw_dev->tw_pci_dev->dev, data_buffer_length_adjusted+sizeof(TW_Ioctl_Buf_Apache) - 1, cpu_addr, dma_handle);
867out2:
Jes Sorensena12e25bd2006-01-11 08:39:45 -0500868 mutex_unlock(&tw_dev->ioctl_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700869out:
Arnd Bergmannc45d15d2010-06-02 14:28:52 +0200870 mutex_unlock(&twa_chrdev_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871 return retval;
872} /* End twa_chrdev_ioctl() */
873
874/* This function handles open for the character device */
Jonathan Corbetf2b98572008-05-18 15:32:43 -0600875/* NOTE that this function will race with remove. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700876static int twa_chrdev_open(struct inode *inode, struct file *file)
877{
878 unsigned int minor_number;
879 int retval = TW_IOCTL_ERROR_OS_ENODEV;
880
881 minor_number = iminor(inode);
882 if (minor_number >= twa_device_extension_count)
883 goto out;
884 retval = 0;
885out:
886 return retval;
887} /* End twa_chrdev_open() */
888
889/* This function will print readable messages from status register errors */
890static int twa_decode_bits(TW_Device_Extension *tw_dev, u32 status_reg_value)
891{
892 int retval = 1;
893
894 /* Check for various error conditions and handle them appropriately */
895 if (status_reg_value & TW_STATUS_PCI_PARITY_ERROR) {
896 TW_PRINTK(tw_dev->host, TW_DRIVER, 0xc, "PCI Parity Error: clearing");
897 writel(TW_CONTROL_CLEAR_PARITY_ERROR, TW_CONTROL_REG_ADDR(tw_dev));
898 }
899
900 if (status_reg_value & TW_STATUS_PCI_ABORT) {
901 TW_PRINTK(tw_dev->host, TW_DRIVER, 0xd, "PCI Abort: clearing");
902 writel(TW_CONTROL_CLEAR_PCI_ABORT, TW_CONTROL_REG_ADDR(tw_dev));
903 pci_write_config_word(tw_dev->tw_pci_dev, PCI_STATUS, TW_PCI_CLEAR_PCI_ABORT);
904 }
905
906 if (status_reg_value & TW_STATUS_QUEUE_ERROR) {
adam radford0e78d152007-07-20 15:28:28 -0700907 if (((tw_dev->tw_pci_dev->device != PCI_DEVICE_ID_3WARE_9650SE) &&
908 (tw_dev->tw_pci_dev->device != PCI_DEVICE_ID_3WARE_9690SA)) ||
909 (!test_bit(TW_IN_RESET, &tw_dev->flags)))
adam radford4039c302006-10-26 18:01:06 -0700910 TW_PRINTK(tw_dev->host, TW_DRIVER, 0xe, "Controller Queue Error: clearing");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700911 writel(TW_CONTROL_CLEAR_QUEUE_ERROR, TW_CONTROL_REG_ADDR(tw_dev));
912 }
913
Linus Torvalds1da177e2005-04-16 15:20:36 -0700914 if (status_reg_value & TW_STATUS_MICROCONTROLLER_ERROR) {
915 if (tw_dev->reset_print == 0) {
916 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x10, "Microcontroller Error: clearing");
917 tw_dev->reset_print = 1;
918 }
919 goto out;
920 }
921 retval = 0;
922out:
923 return retval;
924} /* End twa_decode_bits() */
925
926/* This function will empty the response queue */
927static int twa_empty_response_queue(TW_Device_Extension *tw_dev)
928{
929 u32 status_reg_value, response_que_value;
930 int count = 0, retval = 1;
931
932 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
933
934 while (((status_reg_value & TW_STATUS_RESPONSE_QUEUE_EMPTY) == 0) && (count < TW_MAX_RESPONSE_DRAIN)) {
935 response_que_value = readl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev));
936 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
937 count++;
938 }
939 if (count == TW_MAX_RESPONSE_DRAIN)
940 goto out;
941
942 retval = 0;
943out:
944 return retval;
945} /* End twa_empty_response_queue() */
946
adam radford49bfd8d2005-09-21 17:20:14 -0700947/* This function will clear the pchip/response queue on 9550SX */
948static int twa_empty_response_queue_large(TW_Device_Extension *tw_dev)
949{
adam radford75913d92006-03-15 12:43:19 -0800950 u32 response_que_value = 0;
951 unsigned long before;
952 int retval = 1;
adam radford49bfd8d2005-09-21 17:20:14 -0700953
adam radford0e78d152007-07-20 15:28:28 -0700954 if (tw_dev->tw_pci_dev->device != PCI_DEVICE_ID_3WARE_9000) {
adam radford75913d92006-03-15 12:43:19 -0800955 before = jiffies;
956 while ((response_que_value & TW_9550SX_DRAIN_COMPLETED) != TW_9550SX_DRAIN_COMPLETED) {
adam radford49bfd8d2005-09-21 17:20:14 -0700957 response_que_value = readl(TW_RESPONSE_QUEUE_REG_ADDR_LARGE(tw_dev));
adam radford4039c302006-10-26 18:01:06 -0700958 msleep(1);
adam radford75913d92006-03-15 12:43:19 -0800959 if (time_after(jiffies, before + HZ * 30))
adam radford49bfd8d2005-09-21 17:20:14 -0700960 goto out;
adam radford49bfd8d2005-09-21 17:20:14 -0700961 }
adam radford75913d92006-03-15 12:43:19 -0800962 /* P-chip settle time */
963 msleep(500);
adam radford49bfd8d2005-09-21 17:20:14 -0700964 retval = 0;
965 } else
966 retval = 0;
967out:
968 return retval;
969} /* End twa_empty_response_queue_large() */
970
Linus Torvalds1da177e2005-04-16 15:20:36 -0700971/* This function passes sense keys from firmware to scsi layer */
972static int twa_fill_sense(TW_Device_Extension *tw_dev, int request_id, int copy_sense, int print_host)
973{
974 TW_Command_Full *full_command_packet;
975 unsigned short error;
976 int retval = 1;
977 char *error_str;
978
979 full_command_packet = tw_dev->command_packet_virt[request_id];
980
981 /* Check for embedded error string */
982 error_str = &(full_command_packet->header.err_specific_desc[strlen(full_command_packet->header.err_specific_desc) + 1]);
983
984 /* Don't print error for Logical unit not supported during rollcall */
adam radford75913d92006-03-15 12:43:19 -0800985 error = le16_to_cpu(full_command_packet->header.status_block.error);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700986 if ((error != TW_ERROR_LOGICAL_UNIT_NOT_SUPPORTED) && (error != TW_ERROR_UNIT_OFFLINE)) {
987 if (print_host)
988 printk(KERN_WARNING "3w-9xxx: scsi%d: ERROR: (0x%02X:0x%04X): %s:%s.\n",
989 tw_dev->host->host_no,
990 TW_MESSAGE_SOURCE_CONTROLLER_ERROR,
991 full_command_packet->header.status_block.error,
992 error_str[0] == '\0' ?
993 twa_string_lookup(twa_error_table,
994 full_command_packet->header.status_block.error) : error_str,
995 full_command_packet->header.err_specific_desc);
996 else
997 printk(KERN_WARNING "3w-9xxx: ERROR: (0x%02X:0x%04X): %s:%s.\n",
998 TW_MESSAGE_SOURCE_CONTROLLER_ERROR,
999 full_command_packet->header.status_block.error,
1000 error_str[0] == '\0' ?
1001 twa_string_lookup(twa_error_table,
1002 full_command_packet->header.status_block.error) : error_str,
1003 full_command_packet->header.err_specific_desc);
1004 }
1005
1006 if (copy_sense) {
1007 memcpy(tw_dev->srb[request_id]->sense_buffer, full_command_packet->header.sense_data, TW_SENSE_DATA_LENGTH);
1008 tw_dev->srb[request_id]->result = (full_command_packet->command.newcommand.status << 1);
1009 retval = TW_ISR_DONT_RESULT;
1010 goto out;
1011 }
1012 retval = 0;
1013out:
1014 return retval;
1015} /* End twa_fill_sense() */
1016
1017/* This function will free up device extension resources */
1018static void twa_free_device_extension(TW_Device_Extension *tw_dev)
1019{
1020 if (tw_dev->command_packet_virt[0])
1021 pci_free_consistent(tw_dev->tw_pci_dev,
1022 sizeof(TW_Command_Full)*TW_Q_LENGTH,
1023 tw_dev->command_packet_virt[0],
1024 tw_dev->command_packet_phys[0]);
1025
1026 if (tw_dev->generic_buffer_virt[0])
1027 pci_free_consistent(tw_dev->tw_pci_dev,
1028 TW_SECTOR_SIZE*TW_Q_LENGTH,
1029 tw_dev->generic_buffer_virt[0],
1030 tw_dev->generic_buffer_phys[0]);
1031
Jesper Juhlc9475cb2005-11-07 01:01:26 -08001032 kfree(tw_dev->event_queue[0]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001033} /* End twa_free_device_extension() */
1034
1035/* This function will free a request id */
1036static void twa_free_request_id(TW_Device_Extension *tw_dev, int request_id)
1037{
1038 tw_dev->free_queue[tw_dev->free_tail] = request_id;
1039 tw_dev->state[request_id] = TW_S_FINISHED;
1040 tw_dev->free_tail = (tw_dev->free_tail + 1) % TW_Q_LENGTH;
1041} /* End twa_free_request_id() */
1042
Alexey Dobriyan7f927fc2006-03-28 01:56:53 -08001043/* This function will get parameter table entries from the firmware */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001044static void *twa_get_param(TW_Device_Extension *tw_dev, int request_id, int table_id, int parameter_id, int parameter_size_bytes)
1045{
1046 TW_Command_Full *full_command_packet;
1047 TW_Command *command_packet;
1048 TW_Param_Apache *param;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001049 void *retval = NULL;
1050
1051 /* Setup the command packet */
1052 full_command_packet = tw_dev->command_packet_virt[request_id];
1053 memset(full_command_packet, 0, sizeof(TW_Command_Full));
1054 command_packet = &full_command_packet->command.oldcommand;
1055
1056 command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_GET_PARAM);
1057 command_packet->size = TW_COMMAND_SIZE;
1058 command_packet->request_id = request_id;
adam radford75913d92006-03-15 12:43:19 -08001059 command_packet->byte6_offset.block_count = cpu_to_le16(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001060
1061 /* Now setup the param */
1062 param = (TW_Param_Apache *)tw_dev->generic_buffer_virt[request_id];
1063 memset(param, 0, TW_SECTOR_SIZE);
adam radford75913d92006-03-15 12:43:19 -08001064 param->table_id = cpu_to_le16(table_id | 0x8000);
1065 param->parameter_id = cpu_to_le16(parameter_id);
1066 param->parameter_size_bytes = cpu_to_le16(parameter_size_bytes);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001067
adam radford3dabec72008-07-22 16:47:40 -07001068 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 -08001069 command_packet->byte8_offset.param.sgl[0].length = cpu_to_le32(TW_SECTOR_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001070
1071 /* Post the command packet to the board */
1072 twa_post_command_packet(tw_dev, request_id, 1);
1073
1074 /* Poll for completion */
1075 if (twa_poll_response(tw_dev, request_id, 30))
1076 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x13, "No valid response during get param")
1077 else
1078 retval = (void *)&(param->data[0]);
1079
1080 tw_dev->posted_request_count--;
1081 tw_dev->state[request_id] = TW_S_INITIAL;
1082
1083 return retval;
1084} /* End twa_get_param() */
1085
1086/* This function will assign an available request id */
1087static void twa_get_request_id(TW_Device_Extension *tw_dev, int *request_id)
1088{
1089 *request_id = tw_dev->free_queue[tw_dev->free_head];
1090 tw_dev->free_head = (tw_dev->free_head + 1) % TW_Q_LENGTH;
1091 tw_dev->state[*request_id] = TW_S_STARTED;
1092} /* End twa_get_request_id() */
1093
1094/* This function will send an initconnection command to controller */
1095static int twa_initconnection(TW_Device_Extension *tw_dev, int message_credits,
1096 u32 set_features, unsigned short current_fw_srl,
1097 unsigned short current_fw_arch_id,
1098 unsigned short current_fw_branch,
1099 unsigned short current_fw_build,
1100 unsigned short *fw_on_ctlr_srl,
1101 unsigned short *fw_on_ctlr_arch_id,
1102 unsigned short *fw_on_ctlr_branch,
1103 unsigned short *fw_on_ctlr_build,
1104 u32 *init_connect_result)
1105{
1106 TW_Command_Full *full_command_packet;
1107 TW_Initconnect *tw_initconnect;
1108 int request_id = 0, retval = 1;
1109
1110 /* Initialize InitConnection command packet */
1111 full_command_packet = tw_dev->command_packet_virt[request_id];
1112 memset(full_command_packet, 0, sizeof(TW_Command_Full));
1113 full_command_packet->header.header_desc.size_header = 128;
1114
1115 tw_initconnect = (TW_Initconnect *)&full_command_packet->command.oldcommand;
1116 tw_initconnect->opcode__reserved = TW_OPRES_IN(0, TW_OP_INIT_CONNECTION);
1117 tw_initconnect->request_id = request_id;
adam radford75913d92006-03-15 12:43:19 -08001118 tw_initconnect->message_credits = cpu_to_le16(message_credits);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001119 tw_initconnect->features = set_features;
1120
1121 /* Turn on 64-bit sgl support if we need to */
1122 tw_initconnect->features |= sizeof(dma_addr_t) > 4 ? 1 : 0;
1123
adam radford75913d92006-03-15 12:43:19 -08001124 tw_initconnect->features = cpu_to_le32(tw_initconnect->features);
1125
Linus Torvalds1da177e2005-04-16 15:20:36 -07001126 if (set_features & TW_EXTENDED_INIT_CONNECT) {
1127 tw_initconnect->size = TW_INIT_COMMAND_PACKET_SIZE_EXTENDED;
adam radford75913d92006-03-15 12:43:19 -08001128 tw_initconnect->fw_srl = cpu_to_le16(current_fw_srl);
1129 tw_initconnect->fw_arch_id = cpu_to_le16(current_fw_arch_id);
1130 tw_initconnect->fw_branch = cpu_to_le16(current_fw_branch);
1131 tw_initconnect->fw_build = cpu_to_le16(current_fw_build);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001132 } else
1133 tw_initconnect->size = TW_INIT_COMMAND_PACKET_SIZE;
1134
1135 /* Send command packet to the board */
1136 twa_post_command_packet(tw_dev, request_id, 1);
1137
1138 /* Poll for completion */
1139 if (twa_poll_response(tw_dev, request_id, 30)) {
1140 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x15, "No valid response during init connection");
1141 } else {
1142 if (set_features & TW_EXTENDED_INIT_CONNECT) {
adam radford75913d92006-03-15 12:43:19 -08001143 *fw_on_ctlr_srl = le16_to_cpu(tw_initconnect->fw_srl);
1144 *fw_on_ctlr_arch_id = le16_to_cpu(tw_initconnect->fw_arch_id);
1145 *fw_on_ctlr_branch = le16_to_cpu(tw_initconnect->fw_branch);
1146 *fw_on_ctlr_build = le16_to_cpu(tw_initconnect->fw_build);
1147 *init_connect_result = le32_to_cpu(tw_initconnect->result);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001148 }
1149 retval = 0;
1150 }
1151
1152 tw_dev->posted_request_count--;
1153 tw_dev->state[request_id] = TW_S_INITIAL;
1154
1155 return retval;
1156} /* End twa_initconnection() */
1157
1158/* This function will initialize the fields of a device extension */
1159static int twa_initialize_device_extension(TW_Device_Extension *tw_dev)
1160{
1161 int i, retval = 1;
1162
1163 /* Initialize command packet buffers */
1164 if (twa_allocate_memory(tw_dev, sizeof(TW_Command_Full), 0)) {
1165 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x16, "Command packet memory allocation failed");
1166 goto out;
1167 }
1168
1169 /* Initialize generic buffer */
1170 if (twa_allocate_memory(tw_dev, TW_SECTOR_SIZE, 1)) {
1171 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x17, "Generic memory allocation failed");
1172 goto out;
1173 }
1174
1175 /* Allocate event info space */
Yoann Padioleaudd00cc42007-07-19 01:49:03 -07001176 tw_dev->event_queue[0] = kcalloc(TW_Q_LENGTH, sizeof(TW_Event), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001177 if (!tw_dev->event_queue[0]) {
1178 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x18, "Event info memory allocation failed");
1179 goto out;
1180 }
1181
Linus Torvalds1da177e2005-04-16 15:20:36 -07001182
1183 for (i = 0; i < TW_Q_LENGTH; i++) {
1184 tw_dev->event_queue[i] = (TW_Event *)((unsigned char *)tw_dev->event_queue[0] + (i * sizeof(TW_Event)));
1185 tw_dev->free_queue[i] = i;
1186 tw_dev->state[i] = TW_S_INITIAL;
1187 }
1188
1189 tw_dev->pending_head = TW_Q_START;
1190 tw_dev->pending_tail = TW_Q_START;
1191 tw_dev->free_head = TW_Q_START;
1192 tw_dev->free_tail = TW_Q_START;
1193 tw_dev->error_sequence_id = 1;
1194 tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE;
1195
Jes Sorensena12e25bd2006-01-11 08:39:45 -05001196 mutex_init(&tw_dev->ioctl_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001197 init_waitqueue_head(&tw_dev->ioctl_wqueue);
1198
1199 retval = 0;
1200out:
1201 return retval;
1202} /* End twa_initialize_device_extension() */
1203
1204/* This function is the interrupt service routine */
David Howells7d12e782006-10-05 14:55:46 +01001205static irqreturn_t twa_interrupt(int irq, void *dev_instance)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001206{
1207 int request_id, error = 0;
1208 u32 status_reg_value;
1209 TW_Response_Queue response_que;
1210 TW_Command_Full *full_command_packet;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001211 TW_Device_Extension *tw_dev = (TW_Device_Extension *)dev_instance;
1212 int handled = 0;
1213
1214 /* Get the per adapter lock */
1215 spin_lock(tw_dev->host->host_lock);
1216
1217 /* Read the registers */
1218 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
1219
1220 /* Check if this is our interrupt, otherwise bail */
1221 if (!(status_reg_value & TW_STATUS_VALID_INTERRUPT))
1222 goto twa_interrupt_bail;
1223
1224 handled = 1;
1225
adam radford4039c302006-10-26 18:01:06 -07001226 /* If we are resetting, bail */
1227 if (test_bit(TW_IN_RESET, &tw_dev->flags))
1228 goto twa_interrupt_bail;
1229
Linus Torvalds1da177e2005-04-16 15:20:36 -07001230 /* Check controller for errors */
1231 if (twa_check_bits(status_reg_value)) {
1232 if (twa_decode_bits(tw_dev, status_reg_value)) {
1233 TW_CLEAR_ALL_INTERRUPTS(tw_dev);
1234 goto twa_interrupt_bail;
1235 }
1236 }
1237
1238 /* Handle host interrupt */
1239 if (status_reg_value & TW_STATUS_HOST_INTERRUPT)
1240 TW_CLEAR_HOST_INTERRUPT(tw_dev);
1241
1242 /* Handle attention interrupt */
1243 if (status_reg_value & TW_STATUS_ATTENTION_INTERRUPT) {
1244 TW_CLEAR_ATTENTION_INTERRUPT(tw_dev);
1245 if (!(test_and_set_bit(TW_IN_ATTENTION_LOOP, &tw_dev->flags))) {
1246 twa_get_request_id(tw_dev, &request_id);
1247
1248 error = twa_aen_read_queue(tw_dev, request_id);
1249 if (error) {
1250 tw_dev->state[request_id] = TW_S_COMPLETED;
1251 twa_free_request_id(tw_dev, request_id);
1252 clear_bit(TW_IN_ATTENTION_LOOP, &tw_dev->flags);
1253 }
1254 }
1255 }
1256
1257 /* Handle command interrupt */
1258 if (status_reg_value & TW_STATUS_COMMAND_INTERRUPT) {
1259 TW_MASK_COMMAND_INTERRUPT(tw_dev);
1260 /* Drain as many pending commands as we can */
1261 while (tw_dev->pending_request_count > 0) {
1262 request_id = tw_dev->pending_queue[tw_dev->pending_head];
1263 if (tw_dev->state[request_id] != TW_S_PENDING) {
1264 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x19, "Found request id that wasn't pending");
1265 TW_CLEAR_ALL_INTERRUPTS(tw_dev);
1266 goto twa_interrupt_bail;
1267 }
1268 if (twa_post_command_packet(tw_dev, request_id, 1)==0) {
1269 tw_dev->pending_head = (tw_dev->pending_head + 1) % TW_Q_LENGTH;
1270 tw_dev->pending_request_count--;
1271 } else {
1272 /* If we get here, we will continue re-posting on the next command interrupt */
1273 break;
1274 }
1275 }
1276 }
1277
1278 /* Handle response interrupt */
1279 if (status_reg_value & TW_STATUS_RESPONSE_INTERRUPT) {
1280
1281 /* Drain the response queue from the board */
1282 while ((status_reg_value & TW_STATUS_RESPONSE_QUEUE_EMPTY) == 0) {
1283 /* Complete the response */
1284 response_que.value = readl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev));
1285 request_id = TW_RESID_OUT(response_que.response_id);
1286 full_command_packet = tw_dev->command_packet_virt[request_id];
1287 error = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001288 /* Check for command packet errors */
1289 if (full_command_packet->command.newcommand.status != 0) {
Harvey Harrison9bcf0912008-05-22 15:45:07 -07001290 if (tw_dev->srb[request_id] != NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001291 error = twa_fill_sense(tw_dev, request_id, 1, 1);
1292 } else {
1293 /* Skip ioctl error prints */
1294 if (request_id != tw_dev->chrdev_request_id) {
1295 error = twa_fill_sense(tw_dev, request_id, 0, 1);
1296 }
1297 }
1298 }
1299
1300 /* Check for correct state */
1301 if (tw_dev->state[request_id] != TW_S_POSTED) {
Harvey Harrison9bcf0912008-05-22 15:45:07 -07001302 if (tw_dev->srb[request_id] != NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001303 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1a, "Received a request id that wasn't posted");
1304 TW_CLEAR_ALL_INTERRUPTS(tw_dev);
1305 goto twa_interrupt_bail;
1306 }
1307 }
1308
1309 /* Check for internal command completion */
Harvey Harrison9bcf0912008-05-22 15:45:07 -07001310 if (tw_dev->srb[request_id] == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001311 if (request_id != tw_dev->chrdev_request_id) {
1312 if (twa_aen_complete(tw_dev, request_id))
1313 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1b, "Error completing AEN during attention interrupt");
1314 } else {
1315 tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE;
1316 wake_up(&tw_dev->ioctl_wqueue);
1317 }
1318 } else {
FUJITA Tomonori0debe012007-05-26 02:33:31 +09001319 struct scsi_cmnd *cmd;
1320
1321 cmd = tw_dev->srb[request_id];
1322
Linus Torvalds1da177e2005-04-16 15:20:36 -07001323 twa_scsiop_execute_scsi_complete(tw_dev, request_id);
1324 /* If no error command was a success */
1325 if (error == 0) {
FUJITA Tomonori0debe012007-05-26 02:33:31 +09001326 cmd->result = (DID_OK << 16);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001327 }
1328
1329 /* If error, command failed */
1330 if (error == 1) {
1331 /* Ask for a host reset */
FUJITA Tomonori0debe012007-05-26 02:33:31 +09001332 cmd->result = (DID_OK << 16) | (CHECK_CONDITION << 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001333 }
1334
1335 /* Report residual bytes for single sgl */
FUJITA Tomonori0debe012007-05-26 02:33:31 +09001336 if ((scsi_sg_count(cmd) <= 1) && (full_command_packet->command.newcommand.status == 0)) {
1337 if (full_command_packet->command.newcommand.sg_list[0].length < scsi_bufflen(tw_dev->srb[request_id]))
1338 scsi_set_resid(cmd, scsi_bufflen(cmd) - full_command_packet->command.newcommand.sg_list[0].length);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001339 }
1340
1341 /* Now complete the io */
1342 tw_dev->state[request_id] = TW_S_COMPLETED;
1343 twa_free_request_id(tw_dev, request_id);
1344 tw_dev->posted_request_count--;
1345 tw_dev->srb[request_id]->scsi_done(tw_dev->srb[request_id]);
1346 twa_unmap_scsi_data(tw_dev, request_id);
1347 }
1348
1349 /* Check for valid status after each drain */
1350 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
1351 if (twa_check_bits(status_reg_value)) {
1352 if (twa_decode_bits(tw_dev, status_reg_value)) {
1353 TW_CLEAR_ALL_INTERRUPTS(tw_dev);
1354 goto twa_interrupt_bail;
1355 }
1356 }
1357 }
1358 }
1359
1360twa_interrupt_bail:
1361 spin_unlock(tw_dev->host->host_lock);
1362 return IRQ_RETVAL(handled);
1363} /* End twa_interrupt() */
1364
1365/* This function will load the request id and various sgls for ioctls */
adam radford0e78d152007-07-20 15:28:28 -07001366static 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 -07001367{
1368 TW_Command *oldcommand;
1369 TW_Command_Apache *newcommand;
1370 TW_SG_Entry *sgl;
adam radford0e78d152007-07-20 15:28:28 -07001371 unsigned int pae = 0;
1372
1373 if ((sizeof(long) < 8) && (sizeof(dma_addr_t) > 4))
1374 pae = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001375
1376 if (TW_OP_OUT(full_command_packet->command.newcommand.opcode__reserved) == TW_OP_EXECUTE_SCSI) {
1377 newcommand = &full_command_packet->command.newcommand;
adam radford4039c302006-10-26 18:01:06 -07001378 newcommand->request_id__lunl =
1379 cpu_to_le16(TW_REQ_LUN_IN(TW_LUN_OUT(newcommand->request_id__lunl), request_id));
adam radford53ca3532009-12-10 11:53:31 -08001380 if (length) {
1381 newcommand->sg_list[0].address = TW_CPU_TO_SGL(dma_handle + sizeof(TW_Ioctl_Buf_Apache) - 1);
1382 newcommand->sg_list[0].length = cpu_to_le32(length);
1383 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001384 newcommand->sgl_entries__lunh =
adam radford53ca3532009-12-10 11:53:31 -08001385 cpu_to_le16(TW_REQ_LUN_IN(TW_LUN_OUT(newcommand->sgl_entries__lunh), length ? 1 : 0));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001386 } else {
1387 oldcommand = &full_command_packet->command.oldcommand;
1388 oldcommand->request_id = request_id;
1389
1390 if (TW_SGL_OUT(oldcommand->opcode__sgloffset)) {
1391 /* Load the sg list */
adam radford0e78d152007-07-20 15:28:28 -07001392 if (tw_dev->tw_pci_dev->device == PCI_DEVICE_ID_3WARE_9690SA)
1393 sgl = (TW_SG_Entry *)((u32 *)oldcommand+oldcommand->size - (sizeof(TW_SG_Entry)/4) + pae);
1394 else
1395 sgl = (TW_SG_Entry *)((u32 *)oldcommand+TW_SGL_OUT(oldcommand->opcode__sgloffset));
adam radford75913d92006-03-15 12:43:19 -08001396 sgl->address = TW_CPU_TO_SGL(dma_handle + sizeof(TW_Ioctl_Buf_Apache) - 1);
1397 sgl->length = cpu_to_le32(length);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001398
adam radford0e78d152007-07-20 15:28:28 -07001399 oldcommand->size += pae;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001400 }
1401 }
1402} /* End twa_load_sgl() */
1403
1404/* This function will perform a pci-dma mapping for a scatter gather list */
1405static int twa_map_scsi_sg_data(TW_Device_Extension *tw_dev, int request_id)
1406{
1407 int use_sg;
1408 struct scsi_cmnd *cmd = tw_dev->srb[request_id];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001409
FUJITA Tomonori0debe012007-05-26 02:33:31 +09001410 use_sg = scsi_dma_map(cmd);
1411 if (!use_sg)
1412 return 0;
1413 else if (use_sg < 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001414 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1c, "Failed to map scatter gather list");
FUJITA Tomonori0debe012007-05-26 02:33:31 +09001415 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001416 }
1417
1418 cmd->SCp.phase = TW_PHASE_SGLIST;
1419 cmd->SCp.have_data_in = use_sg;
FUJITA Tomonori0debe012007-05-26 02:33:31 +09001420
1421 return use_sg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001422} /* End twa_map_scsi_sg_data() */
1423
Linus Torvalds1da177e2005-04-16 15:20:36 -07001424/* This function will poll for a response interrupt of a request */
1425static int twa_poll_response(TW_Device_Extension *tw_dev, int request_id, int seconds)
1426{
1427 int retval = 1, found = 0, response_request_id;
1428 TW_Response_Queue response_queue;
1429 TW_Command_Full *full_command_packet = tw_dev->command_packet_virt[request_id];
1430
1431 if (twa_poll_status_gone(tw_dev, TW_STATUS_RESPONSE_QUEUE_EMPTY, seconds) == 0) {
1432 response_queue.value = readl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev));
1433 response_request_id = TW_RESID_OUT(response_queue.response_id);
1434 if (request_id != response_request_id) {
1435 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1e, "Found unexpected request id while polling for response");
1436 goto out;
1437 }
1438 if (TW_OP_OUT(full_command_packet->command.newcommand.opcode__reserved) == TW_OP_EXECUTE_SCSI) {
1439 if (full_command_packet->command.newcommand.status != 0) {
1440 /* bad response */
1441 twa_fill_sense(tw_dev, request_id, 0, 0);
1442 goto out;
1443 }
1444 found = 1;
1445 } else {
1446 if (full_command_packet->command.oldcommand.status != 0) {
1447 /* bad response */
1448 twa_fill_sense(tw_dev, request_id, 0, 0);
1449 goto out;
1450 }
1451 found = 1;
1452 }
1453 }
1454
1455 if (found)
1456 retval = 0;
1457out:
1458 return retval;
1459} /* End twa_poll_response() */
1460
1461/* This function will poll the status register for a flag */
1462static int twa_poll_status(TW_Device_Extension *tw_dev, u32 flag, int seconds)
1463{
1464 u32 status_reg_value;
1465 unsigned long before;
1466 int retval = 1;
1467
1468 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
1469 before = jiffies;
1470
1471 if (twa_check_bits(status_reg_value))
1472 twa_decode_bits(tw_dev, status_reg_value);
1473
1474 while ((status_reg_value & flag) != flag) {
1475 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
1476
1477 if (twa_check_bits(status_reg_value))
1478 twa_decode_bits(tw_dev, status_reg_value);
1479
1480 if (time_after(jiffies, before + HZ * seconds))
1481 goto out;
1482
1483 msleep(50);
1484 }
1485 retval = 0;
1486out:
1487 return retval;
1488} /* End twa_poll_status() */
1489
1490/* This function will poll the status register for disappearance of a flag */
1491static int twa_poll_status_gone(TW_Device_Extension *tw_dev, u32 flag, int seconds)
1492{
1493 u32 status_reg_value;
1494 unsigned long before;
1495 int retval = 1;
1496
1497 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
1498 before = jiffies;
1499
1500 if (twa_check_bits(status_reg_value))
1501 twa_decode_bits(tw_dev, status_reg_value);
1502
1503 while ((status_reg_value & flag) != 0) {
1504 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
1505 if (twa_check_bits(status_reg_value))
1506 twa_decode_bits(tw_dev, status_reg_value);
1507
1508 if (time_after(jiffies, before + HZ * seconds))
1509 goto out;
1510
1511 msleep(50);
1512 }
1513 retval = 0;
1514out:
1515 return retval;
1516} /* End twa_poll_status_gone() */
1517
1518/* This function will attempt to post a command packet to the board */
1519static int twa_post_command_packet(TW_Device_Extension *tw_dev, int request_id, char internal)
1520{
1521 u32 status_reg_value;
1522 dma_addr_t command_que_value;
1523 int retval = 1;
1524
1525 command_que_value = tw_dev->command_packet_phys[request_id];
adam radford4039c302006-10-26 18:01:06 -07001526
1527 /* For 9650SE write low 4 bytes first */
adam radford0e78d152007-07-20 15:28:28 -07001528 if ((tw_dev->tw_pci_dev->device == PCI_DEVICE_ID_3WARE_9650SE) ||
1529 (tw_dev->tw_pci_dev->device == PCI_DEVICE_ID_3WARE_9690SA)) {
adam radford4039c302006-10-26 18:01:06 -07001530 command_que_value += TW_COMMAND_OFFSET;
1531 writel((u32)command_que_value, TW_COMMAND_QUEUE_REG_ADDR_LARGE(tw_dev));
1532 }
1533
Linus Torvalds1da177e2005-04-16 15:20:36 -07001534 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
1535
1536 if (twa_check_bits(status_reg_value))
1537 twa_decode_bits(tw_dev, status_reg_value);
1538
1539 if (((tw_dev->pending_request_count > 0) && (tw_dev->state[request_id] != TW_S_PENDING)) || (status_reg_value & TW_STATUS_COMMAND_QUEUE_FULL)) {
1540
1541 /* Only pend internal driver commands */
1542 if (!internal) {
1543 retval = SCSI_MLQUEUE_HOST_BUSY;
1544 goto out;
1545 }
1546
1547 /* Couldn't post the command packet, so we do it later */
1548 if (tw_dev->state[request_id] != TW_S_PENDING) {
1549 tw_dev->state[request_id] = TW_S_PENDING;
1550 tw_dev->pending_request_count++;
1551 if (tw_dev->pending_request_count > tw_dev->max_pending_request_count) {
1552 tw_dev->max_pending_request_count = tw_dev->pending_request_count;
1553 }
1554 tw_dev->pending_queue[tw_dev->pending_tail] = request_id;
1555 tw_dev->pending_tail = (tw_dev->pending_tail + 1) % TW_Q_LENGTH;
1556 }
1557 TW_UNMASK_COMMAND_INTERRUPT(tw_dev);
1558 goto out;
1559 } else {
adam radford0e78d152007-07-20 15:28:28 -07001560 if ((tw_dev->tw_pci_dev->device == PCI_DEVICE_ID_3WARE_9650SE) ||
1561 (tw_dev->tw_pci_dev->device == PCI_DEVICE_ID_3WARE_9690SA)) {
adam radford4039c302006-10-26 18:01:06 -07001562 /* Now write upper 4 bytes */
1563 writel((u32)((u64)command_que_value >> 32), TW_COMMAND_QUEUE_REG_ADDR_LARGE(tw_dev) + 0x4);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001564 } else {
adam radford4039c302006-10-26 18:01:06 -07001565 if (sizeof(dma_addr_t) > 4) {
1566 command_que_value += TW_COMMAND_OFFSET;
1567 writel((u32)command_que_value, TW_COMMAND_QUEUE_REG_ADDR(tw_dev));
1568 writel((u32)((u64)command_que_value >> 32), TW_COMMAND_QUEUE_REG_ADDR(tw_dev) + 0x4);
1569 } else {
1570 writel(TW_COMMAND_OFFSET + command_que_value, TW_COMMAND_QUEUE_REG_ADDR(tw_dev));
1571 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001572 }
1573 tw_dev->state[request_id] = TW_S_POSTED;
1574 tw_dev->posted_request_count++;
1575 if (tw_dev->posted_request_count > tw_dev->max_posted_request_count) {
1576 tw_dev->max_posted_request_count = tw_dev->posted_request_count;
1577 }
1578 }
1579 retval = 0;
1580out:
1581 return retval;
1582} /* End twa_post_command_packet() */
1583
1584/* This function will reset a device extension */
adam radford0e78d152007-07-20 15:28:28 -07001585static int twa_reset_device_extension(TW_Device_Extension *tw_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001586{
1587 int i = 0;
1588 int retval = 1;
1589 unsigned long flags = 0;
1590
1591 set_bit(TW_IN_RESET, &tw_dev->flags);
1592 TW_DISABLE_INTERRUPTS(tw_dev);
1593 TW_MASK_COMMAND_INTERRUPT(tw_dev);
1594 spin_lock_irqsave(tw_dev->host->host_lock, flags);
1595
1596 /* Abort all requests that are in progress */
1597 for (i = 0; i < TW_Q_LENGTH; i++) {
1598 if ((tw_dev->state[i] != TW_S_FINISHED) &&
1599 (tw_dev->state[i] != TW_S_INITIAL) &&
1600 (tw_dev->state[i] != TW_S_COMPLETED)) {
1601 if (tw_dev->srb[i]) {
1602 tw_dev->srb[i]->result = (DID_RESET << 16);
1603 tw_dev->srb[i]->scsi_done(tw_dev->srb[i]);
1604 twa_unmap_scsi_data(tw_dev, i);
1605 }
1606 }
1607 }
1608
1609 /* Reset queues and counts */
1610 for (i = 0; i < TW_Q_LENGTH; i++) {
1611 tw_dev->free_queue[i] = i;
1612 tw_dev->state[i] = TW_S_INITIAL;
1613 }
1614 tw_dev->free_head = TW_Q_START;
1615 tw_dev->free_tail = TW_Q_START;
1616 tw_dev->posted_request_count = 0;
1617 tw_dev->pending_request_count = 0;
1618 tw_dev->pending_head = TW_Q_START;
1619 tw_dev->pending_tail = TW_Q_START;
1620 tw_dev->reset_print = 0;
1621
1622 spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
1623
1624 if (twa_reset_sequence(tw_dev, 1))
1625 goto out;
1626
1627 TW_ENABLE_AND_CLEAR_INTERRUPTS(tw_dev);
adam radford4039c302006-10-26 18:01:06 -07001628 clear_bit(TW_IN_RESET, &tw_dev->flags);
1629 tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001630
Linus Torvalds1da177e2005-04-16 15:20:36 -07001631 retval = 0;
1632out:
1633 return retval;
1634} /* End twa_reset_device_extension() */
1635
1636/* This function will reset a controller */
1637static int twa_reset_sequence(TW_Device_Extension *tw_dev, int soft_reset)
1638{
1639 int tries = 0, retval = 1, flashed = 0, do_soft_reset = soft_reset;
1640
1641 while (tries < TW_MAX_RESET_TRIES) {
adam radford49bfd8d2005-09-21 17:20:14 -07001642 if (do_soft_reset) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001643 TW_SOFT_RESET(tw_dev);
adam radford49bfd8d2005-09-21 17:20:14 -07001644 /* Clear pchip/response queue on 9550SX */
1645 if (twa_empty_response_queue_large(tw_dev)) {
1646 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x36, "Response queue (large) empty failed during reset sequence");
1647 do_soft_reset = 1;
1648 tries++;
1649 continue;
1650 }
1651 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001652
1653 /* Make sure controller is in a good state */
1654 if (twa_poll_status(tw_dev, TW_STATUS_MICROCONTROLLER_READY | (do_soft_reset == 1 ? TW_STATUS_ATTENTION_INTERRUPT : 0), 60)) {
1655 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1f, "Microcontroller not ready during reset sequence");
1656 do_soft_reset = 1;
1657 tries++;
1658 continue;
1659 }
1660
1661 /* Empty response queue */
1662 if (twa_empty_response_queue(tw_dev)) {
1663 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x20, "Response queue empty failed during reset sequence");
1664 do_soft_reset = 1;
1665 tries++;
1666 continue;
1667 }
1668
1669 flashed = 0;
1670
1671 /* Check for compatibility/flash */
1672 if (twa_check_srl(tw_dev, &flashed)) {
1673 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x21, "Compatibility check failed during reset sequence");
1674 do_soft_reset = 1;
1675 tries++;
1676 continue;
1677 } else {
1678 if (flashed) {
1679 tries++;
1680 continue;
1681 }
1682 }
1683
1684 /* Drain the AEN queue */
1685 if (twa_aen_drain_queue(tw_dev, soft_reset)) {
1686 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x22, "AEN drain failed during reset sequence");
1687 do_soft_reset = 1;
1688 tries++;
1689 continue;
1690 }
1691
1692 /* If we got here, controller is in a good state */
1693 retval = 0;
1694 goto out;
1695 }
1696out:
1697 return retval;
1698} /* End twa_reset_sequence() */
1699
1700/* This funciton returns unit geometry in cylinders/heads/sectors */
1701static int twa_scsi_biosparam(struct scsi_device *sdev, struct block_device *bdev, sector_t capacity, int geom[])
1702{
1703 int heads, sectors, cylinders;
1704 TW_Device_Extension *tw_dev;
1705
1706 tw_dev = (TW_Device_Extension *)sdev->host->hostdata;
1707
1708 if (capacity >= 0x200000) {
1709 heads = 255;
1710 sectors = 63;
1711 cylinders = sector_div(capacity, heads * sectors);
1712 } else {
1713 heads = 64;
1714 sectors = 32;
1715 cylinders = sector_div(capacity, heads * sectors);
1716 }
1717
1718 geom[0] = heads;
1719 geom[1] = sectors;
1720 geom[2] = cylinders;
1721
1722 return 0;
1723} /* End twa_scsi_biosparam() */
1724
1725/* This is the new scsi eh reset function */
1726static int twa_scsi_eh_reset(struct scsi_cmnd *SCpnt)
1727{
1728 TW_Device_Extension *tw_dev = NULL;
1729 int retval = FAILED;
1730
1731 tw_dev = (TW_Device_Extension *)SCpnt->device->host->hostdata;
1732
Linus Torvalds1da177e2005-04-16 15:20:36 -07001733 tw_dev->num_resets++;
1734
Jeff Garzik017560f2005-10-24 18:04:36 -04001735 sdev_printk(KERN_WARNING, SCpnt->device,
1736 "WARNING: (0x%02X:0x%04X): Command (0x%x) timed out, resetting card.\n",
1737 TW_DRIVER, 0x2c, SCpnt->cmnd[0]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001738
adam radford4039c302006-10-26 18:01:06 -07001739 /* Make sure we are not issuing an ioctl or resetting from ioctl */
1740 mutex_lock(&tw_dev->ioctl_lock);
1741
Linus Torvalds1da177e2005-04-16 15:20:36 -07001742 /* Now reset the card and some of the device extension data */
adam radford0e78d152007-07-20 15:28:28 -07001743 if (twa_reset_device_extension(tw_dev)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001744 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x2b, "Controller reset failed during scsi host reset");
1745 goto out;
1746 }
1747
1748 retval = SUCCESS;
1749out:
adam radford4039c302006-10-26 18:01:06 -07001750 mutex_unlock(&tw_dev->ioctl_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001751 return retval;
1752} /* End twa_scsi_eh_reset() */
1753
1754/* This is the main scsi queue function to handle scsi opcodes */
Jeff Garzikf2812332010-11-16 02:10:29 -05001755static int twa_scsi_queue_lck(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001756{
1757 int request_id, retval;
1758 TW_Device_Extension *tw_dev = (TW_Device_Extension *)SCpnt->device->host->hostdata;
1759
adam radford4039c302006-10-26 18:01:06 -07001760 /* If we are resetting due to timed out ioctl, report as busy */
1761 if (test_bit(TW_IN_RESET, &tw_dev->flags)) {
1762 retval = SCSI_MLQUEUE_HOST_BUSY;
1763 goto out;
1764 }
1765
Linus Torvalds1da177e2005-04-16 15:20:36 -07001766 /* Check if this FW supports luns */
adam radford4039c302006-10-26 18:01:06 -07001767 if ((SCpnt->device->lun != 0) && (tw_dev->tw_compat_info.working_srl < TW_FW_SRL_LUNS_SUPPORTED)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001768 SCpnt->result = (DID_BAD_TARGET << 16);
1769 done(SCpnt);
1770 retval = 0;
1771 goto out;
1772 }
1773
1774 /* Save done function into scsi_cmnd struct */
1775 SCpnt->scsi_done = done;
1776
1777 /* Get a free request id */
1778 twa_get_request_id(tw_dev, &request_id);
1779
1780 /* Save the scsi command for use by the ISR */
1781 tw_dev->srb[request_id] = SCpnt;
1782
1783 /* Initialize phase to zero */
1784 SCpnt->SCp.phase = TW_PHASE_INITIAL;
1785
1786 retval = twa_scsiop_execute_scsi(tw_dev, request_id, NULL, 0, NULL);
1787 switch (retval) {
1788 case SCSI_MLQUEUE_HOST_BUSY:
1789 twa_free_request_id(tw_dev, request_id);
James Bottomley96067722011-09-18 18:56:20 +04001790 twa_unmap_scsi_data(tw_dev, request_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001791 break;
1792 case 1:
1793 tw_dev->state[request_id] = TW_S_COMPLETED;
1794 twa_free_request_id(tw_dev, request_id);
James Bottomley96067722011-09-18 18:56:20 +04001795 twa_unmap_scsi_data(tw_dev, request_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001796 SCpnt->result = (DID_ERROR << 16);
1797 done(SCpnt);
1798 retval = 0;
1799 }
1800out:
1801 return retval;
1802} /* End twa_scsi_queue() */
1803
Jeff Garzikf2812332010-11-16 02:10:29 -05001804static DEF_SCSI_QCMD(twa_scsi_queue)
1805
Linus Torvalds1da177e2005-04-16 15:20:36 -07001806/* This function hands scsi cdb's to the firmware */
1807static int twa_scsiop_execute_scsi(TW_Device_Extension *tw_dev, int request_id, char *cdb, int use_sg, TW_SG_Entry *sglistarg)
1808{
1809 TW_Command_Full *full_command_packet;
1810 TW_Command_Apache *command_packet;
1811 u32 num_sectors = 0x0;
1812 int i, sg_count;
1813 struct scsi_cmnd *srb = NULL;
FUJITA Tomonori0debe012007-05-26 02:33:31 +09001814 struct scatterlist *sglist = NULL, *sg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001815 int retval = 1;
1816
1817 if (tw_dev->srb[request_id]) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001818 srb = tw_dev->srb[request_id];
FUJITA Tomonori0debe012007-05-26 02:33:31 +09001819 if (scsi_sglist(srb))
1820 sglist = scsi_sglist(srb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001821 }
1822
1823 /* Initialize command packet */
1824 full_command_packet = tw_dev->command_packet_virt[request_id];
1825 full_command_packet->header.header_desc.size_header = 128;
1826 full_command_packet->header.status_block.error = 0;
1827 full_command_packet->header.status_block.severity__reserved = 0;
1828
1829 command_packet = &full_command_packet->command.newcommand;
1830 command_packet->status = 0;
1831 command_packet->opcode__reserved = TW_OPRES_IN(0, TW_OP_EXECUTE_SCSI);
1832
1833 /* We forced 16 byte cdb use earlier */
1834 if (!cdb)
1835 memcpy(command_packet->cdb, srb->cmnd, TW_MAX_CDB_LEN);
1836 else
1837 memcpy(command_packet->cdb, cdb, TW_MAX_CDB_LEN);
1838
1839 if (srb) {
1840 command_packet->unit = srb->device->id;
1841 command_packet->request_id__lunl =
adam radford75913d92006-03-15 12:43:19 -08001842 cpu_to_le16(TW_REQ_LUN_IN(srb->device->lun, request_id));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001843 } else {
1844 command_packet->request_id__lunl =
adam radford75913d92006-03-15 12:43:19 -08001845 cpu_to_le16(TW_REQ_LUN_IN(0, request_id));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001846 command_packet->unit = 0;
1847 }
1848
1849 command_packet->sgl_offset = 16;
1850
1851 if (!sglistarg) {
1852 /* Map sglist from scsi layer to cmd packet */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001853
FUJITA Tomonori0debe012007-05-26 02:33:31 +09001854 if (scsi_sg_count(srb)) {
1855 if ((scsi_sg_count(srb) == 1) &&
1856 (scsi_bufflen(srb) < TW_MIN_SGL_LENGTH)) {
FUJITA Tomonori035f5e02008-03-09 13:44:37 +09001857 if (srb->sc_data_direction == DMA_TO_DEVICE ||
1858 srb->sc_data_direction == DMA_BIDIRECTIONAL)
1859 scsi_sg_copy_to_buffer(srb,
1860 tw_dev->generic_buffer_virt[request_id],
1861 TW_SECTOR_SIZE);
adam radford75913d92006-03-15 12:43:19 -08001862 command_packet->sg_list[0].address = TW_CPU_TO_SGL(tw_dev->generic_buffer_phys[request_id]);
1863 command_packet->sg_list[0].length = cpu_to_le32(TW_MIN_SGL_LENGTH);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001864 } else {
1865 sg_count = twa_map_scsi_sg_data(tw_dev, request_id);
1866 if (sg_count == 0)
1867 goto out;
1868
FUJITA Tomonori0debe012007-05-26 02:33:31 +09001869 scsi_for_each_sg(srb, sg, sg_count, i) {
1870 command_packet->sg_list[i].address = TW_CPU_TO_SGL(sg_dma_address(sg));
1871 command_packet->sg_list[i].length = cpu_to_le32(sg_dma_len(sg));
adam radford75913d92006-03-15 12:43:19 -08001872 if (command_packet->sg_list[i].address & TW_CPU_TO_SGL(TW_ALIGNMENT_9000_SGL)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001873 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x2e, "Found unaligned sgl address during execute scsi");
1874 goto out;
1875 }
1876 }
1877 }
FUJITA Tomonori0debe012007-05-26 02:33:31 +09001878 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 -07001879 }
1880 } else {
1881 /* Internal cdb post */
1882 for (i = 0; i < use_sg; i++) {
adam radford75913d92006-03-15 12:43:19 -08001883 command_packet->sg_list[i].address = TW_CPU_TO_SGL(sglistarg[i].address);
1884 command_packet->sg_list[i].length = cpu_to_le32(sglistarg[i].length);
1885 if (command_packet->sg_list[i].address & TW_CPU_TO_SGL(TW_ALIGNMENT_9000_SGL)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001886 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x2f, "Found unaligned sgl address during internal post");
1887 goto out;
1888 }
1889 }
adam radford75913d92006-03-15 12:43:19 -08001890 command_packet->sgl_entries__lunh = cpu_to_le16(TW_REQ_LUN_IN(0, use_sg));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001891 }
1892
1893 if (srb) {
1894 if (srb->cmnd[0] == READ_6 || srb->cmnd[0] == WRITE_6)
1895 num_sectors = (u32)srb->cmnd[4];
1896
1897 if (srb->cmnd[0] == READ_10 || srb->cmnd[0] == WRITE_10)
1898 num_sectors = (u32)srb->cmnd[8] | ((u32)srb->cmnd[7] << 8);
1899 }
1900
1901 /* Update sector statistic */
1902 tw_dev->sector_count = num_sectors;
1903 if (tw_dev->sector_count > tw_dev->max_sector_count)
1904 tw_dev->max_sector_count = tw_dev->sector_count;
1905
1906 /* Update SG statistics */
1907 if (srb) {
FUJITA Tomonori0debe012007-05-26 02:33:31 +09001908 tw_dev->sgl_entries = scsi_sg_count(tw_dev->srb[request_id]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001909 if (tw_dev->sgl_entries > tw_dev->max_sgl_entries)
1910 tw_dev->max_sgl_entries = tw_dev->sgl_entries;
1911 }
1912
1913 /* Now post the command to the board */
1914 if (srb) {
1915 retval = twa_post_command_packet(tw_dev, request_id, 0);
1916 } else {
1917 twa_post_command_packet(tw_dev, request_id, 1);
1918 retval = 0;
1919 }
1920out:
1921 return retval;
1922} /* End twa_scsiop_execute_scsi() */
1923
1924/* This function completes an execute scsi operation */
1925static void twa_scsiop_execute_scsi_complete(TW_Device_Extension *tw_dev, int request_id)
1926{
FUJITA Tomonori0debe012007-05-26 02:33:31 +09001927 struct scsi_cmnd *cmd = tw_dev->srb[request_id];
FUJITA Tomonori0debe012007-05-26 02:33:31 +09001928
1929 if (scsi_bufflen(cmd) < TW_MIN_SGL_LENGTH &&
1930 (cmd->sc_data_direction == DMA_FROM_DEVICE ||
1931 cmd->sc_data_direction == DMA_BIDIRECTIONAL)) {
FUJITA Tomonorib1192d52007-05-31 15:24:03 +09001932 if (scsi_sg_count(cmd) == 1) {
FUJITA Tomonori035f5e02008-03-09 13:44:37 +09001933 void *buf = tw_dev->generic_buffer_virt[request_id];
1934
FUJITA Tomonori035f5e02008-03-09 13:44:37 +09001935 scsi_sg_copy_from_buffer(cmd, buf, TW_SECTOR_SIZE);
adam radfordd327d082005-09-09 15:55:13 -07001936 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001937 }
1938} /* End twa_scsiop_execute_scsi_complete() */
1939
1940/* This function tells the controller to shut down */
1941static void __twa_shutdown(TW_Device_Extension *tw_dev)
1942{
1943 /* Disable interrupts */
1944 TW_DISABLE_INTERRUPTS(tw_dev);
1945
adam radford4039c302006-10-26 18:01:06 -07001946 /* Free up the IRQ */
1947 free_irq(tw_dev->tw_pci_dev->irq, tw_dev);
1948
Linus Torvalds1da177e2005-04-16 15:20:36 -07001949 printk(KERN_WARNING "3w-9xxx: Shutting down host %d.\n", tw_dev->host->host_no);
1950
1951 /* Tell the card we are shutting down */
1952 if (twa_initconnection(tw_dev, 1, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL)) {
1953 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x31, "Connection shutdown failed");
1954 } else {
1955 printk(KERN_WARNING "3w-9xxx: Shutdown complete.\n");
1956 }
1957
1958 /* Clear all interrupts just before exit */
1959 TW_CLEAR_ALL_INTERRUPTS(tw_dev);
1960} /* End __twa_shutdown() */
1961
1962/* Wrapper for __twa_shutdown */
Greg Kroah-Hartmand18c3db2005-06-23 17:35:56 -07001963static void twa_shutdown(struct pci_dev *pdev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001964{
Greg Kroah-Hartmand18c3db2005-06-23 17:35:56 -07001965 struct Scsi_Host *host = pci_get_drvdata(pdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001966 TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
1967
1968 __twa_shutdown(tw_dev);
1969} /* End twa_shutdown() */
1970
1971/* This function will look up a string */
1972static char *twa_string_lookup(twa_message_type *table, unsigned int code)
1973{
1974 int index;
1975
1976 for (index = 0; ((code != table[index].code) &&
1977 (table[index].text != (char *)0)); index++);
1978 return(table[index].text);
1979} /* End twa_string_lookup() */
1980
1981/* This function will perform a pci-dma unmap */
1982static void twa_unmap_scsi_data(TW_Device_Extension *tw_dev, int request_id)
1983{
1984 struct scsi_cmnd *cmd = tw_dev->srb[request_id];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001985
adam radford8454e982009-05-05 11:45:37 -07001986 if (cmd->SCp.phase == TW_PHASE_SGLIST)
1987 scsi_dma_unmap(cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001988} /* End twa_unmap_scsi_data() */
1989
adam radford4deedd82010-03-08 12:37:46 -08001990/* This function gets called when a disk is coming on-line */
1991static int twa_slave_configure(struct scsi_device *sdev)
1992{
1993 /* Force 60 second timeout */
1994 blk_queue_rq_timeout(sdev->request_queue, 60 * HZ);
1995
1996 return 0;
1997} /* End twa_slave_configure() */
1998
Linus Torvalds1da177e2005-04-16 15:20:36 -07001999/* scsi_host_template initializer */
2000static struct scsi_host_template driver_template = {
2001 .module = THIS_MODULE,
2002 .name = "3ware 9000 Storage Controller",
2003 .queuecommand = twa_scsi_queue,
2004 .eh_host_reset_handler = twa_scsi_eh_reset,
2005 .bios_param = twa_scsi_biosparam,
Christoph Hellwigdb5ed4d2014-11-13 15:08:42 +01002006 .change_queue_depth = scsi_change_queue_depth,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002007 .can_queue = TW_Q_LENGTH-2,
adam radford4deedd82010-03-08 12:37:46 -08002008 .slave_configure = twa_slave_configure,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002009 .this_id = -1,
2010 .sg_tablesize = TW_APACHE_MAX_SGL_LENGTH,
2011 .max_sectors = TW_MAX_SECTORS,
2012 .cmd_per_lun = TW_MAX_CMDS_PER_LUN,
2013 .use_clustering = ENABLE_CLUSTERING,
2014 .shost_attrs = twa_host_attrs,
Martin K. Petersen54b2b502013-10-23 06:25:40 -04002015 .emulated = 1,
2016 .no_write_same = 1,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002017};
2018
2019/* This function will probe and initialize a card */
Greg Kroah-Hartman6f039792012-12-21 13:08:55 -08002020static int twa_probe(struct pci_dev *pdev, const struct pci_device_id *dev_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002021{
2022 struct Scsi_Host *host = NULL;
2023 TW_Device_Extension *tw_dev;
adam radford3dabec72008-07-22 16:47:40 -07002024 unsigned long mem_addr, mem_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002025 int retval = -ENODEV;
2026
2027 retval = pci_enable_device(pdev);
2028 if (retval) {
2029 TW_PRINTK(host, TW_DRIVER, 0x34, "Failed to enable pci device");
2030 goto out_disable_device;
2031 }
2032
2033 pci_set_master(pdev);
Tony Battersby1e6c38c2007-11-09 13:04:35 -05002034 pci_try_set_mwi(pdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002035
Yang Hongyang6a355282009-04-06 19:01:13 -07002036 if (pci_set_dma_mask(pdev, DMA_BIT_MASK(64))
2037 || pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64)))
Yang Hongyang284901a2009-04-06 19:01:15 -07002038 if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32))
2039 || pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32))) {
adam radford0e78d152007-07-20 15:28:28 -07002040 TW_PRINTK(host, TW_DRIVER, 0x23, "Failed to set dma mask");
2041 retval = -ENODEV;
2042 goto out_disable_device;
2043 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002044
2045 host = scsi_host_alloc(&driver_template, sizeof(TW_Device_Extension));
2046 if (!host) {
2047 TW_PRINTK(host, TW_DRIVER, 0x24, "Failed to allocate memory for device extension");
2048 retval = -ENOMEM;
2049 goto out_disable_device;
2050 }
2051 tw_dev = (TW_Device_Extension *)host->hostdata;
2052
Linus Torvalds1da177e2005-04-16 15:20:36 -07002053 /* Save values to device extension */
2054 tw_dev->host = host;
2055 tw_dev->tw_pci_dev = pdev;
2056
2057 if (twa_initialize_device_extension(tw_dev)) {
2058 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x25, "Failed to initialize device extension");
2059 goto out_free_device_extension;
2060 }
2061
2062 /* Request IO regions */
2063 retval = pci_request_regions(pdev, "3w-9xxx");
2064 if (retval) {
2065 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x26, "Failed to get mem region");
2066 goto out_free_device_extension;
2067 }
2068
adam radford3dabec72008-07-22 16:47:40 -07002069 if (pdev->device == PCI_DEVICE_ID_3WARE_9000) {
adam radford49bfd8d2005-09-21 17:20:14 -07002070 mem_addr = pci_resource_start(pdev, 1);
adam radford3dabec72008-07-22 16:47:40 -07002071 mem_len = pci_resource_len(pdev, 1);
2072 } else {
adam radford49bfd8d2005-09-21 17:20:14 -07002073 mem_addr = pci_resource_start(pdev, 2);
adam radford3dabec72008-07-22 16:47:40 -07002074 mem_len = pci_resource_len(pdev, 2);
2075 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002076
2077 /* Save base address */
adam radford3dabec72008-07-22 16:47:40 -07002078 tw_dev->base_addr = ioremap(mem_addr, mem_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002079 if (!tw_dev->base_addr) {
2080 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x35, "Failed to ioremap");
2081 goto out_release_mem_region;
2082 }
2083
2084 /* Disable interrupts on the card */
2085 TW_DISABLE_INTERRUPTS(tw_dev);
2086
2087 /* Initialize the card */
2088 if (twa_reset_sequence(tw_dev, 0))
adam radford4039c302006-10-26 18:01:06 -07002089 goto out_iounmap;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002090
2091 /* Set host specific parameters */
adam radford0e78d152007-07-20 15:28:28 -07002092 if ((pdev->device == PCI_DEVICE_ID_3WARE_9650SE) ||
2093 (pdev->device == PCI_DEVICE_ID_3WARE_9690SA))
adam radford4039c302006-10-26 18:01:06 -07002094 host->max_id = TW_MAX_UNITS_9650SE;
2095 else
2096 host->max_id = TW_MAX_UNITS;
2097
Linus Torvalds1da177e2005-04-16 15:20:36 -07002098 host->max_cmd_len = TW_MAX_CDB_LEN;
2099
2100 /* Channels aren't supported by adapter */
adam radford4039c302006-10-26 18:01:06 -07002101 host->max_lun = TW_MAX_LUNS(tw_dev->tw_compat_info.working_srl);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002102 host->max_channel = 0;
2103
2104 /* Register the card with the kernel SCSI layer */
2105 retval = scsi_add_host(host, &pdev->dev);
2106 if (retval) {
2107 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x27, "scsi add host failed");
adam radford4039c302006-10-26 18:01:06 -07002108 goto out_iounmap;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002109 }
2110
2111 pci_set_drvdata(pdev, host);
2112
adam radford3dabec72008-07-22 16:47:40 -07002113 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 -07002114 host->host_no, mem_addr, pdev->irq);
2115 printk(KERN_WARNING "3w-9xxx: scsi%d: Firmware %s, BIOS %s, Ports: %d.\n",
2116 host->host_no,
2117 (char *)twa_get_param(tw_dev, 0, TW_VERSION_TABLE,
2118 TW_PARAM_FWVER, TW_PARAM_FWVER_LENGTH),
2119 (char *)twa_get_param(tw_dev, 1, TW_VERSION_TABLE,
2120 TW_PARAM_BIOSVER, TW_PARAM_BIOSVER_LENGTH),
adam radford75913d92006-03-15 12:43:19 -08002121 le32_to_cpu(*(int *)twa_get_param(tw_dev, 2, TW_INFORMATION_TABLE,
2122 TW_PARAM_PORTCOUNT, TW_PARAM_PORTCOUNT_LENGTH)));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002123
adam radford3dabec72008-07-22 16:47:40 -07002124 /* Try to enable MSI */
2125 if (use_msi && (pdev->device != PCI_DEVICE_ID_3WARE_9000) &&
2126 !pci_enable_msi(pdev))
2127 set_bit(TW_USING_MSI, &tw_dev->flags);
2128
Linus Torvalds1da177e2005-04-16 15:20:36 -07002129 /* Now setup the interrupt handler */
Thomas Gleixner1d6f3592006-07-01 19:29:42 -07002130 retval = request_irq(pdev->irq, twa_interrupt, IRQF_SHARED, "3w-9xxx", tw_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002131 if (retval) {
2132 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x30, "Error requesting IRQ");
2133 goto out_remove_host;
2134 }
2135
2136 twa_device_extension_list[twa_device_extension_count] = tw_dev;
2137 twa_device_extension_count++;
2138
2139 /* Re-enable interrupts on the card */
2140 TW_ENABLE_AND_CLEAR_INTERRUPTS(tw_dev);
2141
2142 /* Finally, scan the host */
2143 scsi_scan_host(host);
2144
2145 if (twa_major == -1) {
2146 if ((twa_major = register_chrdev (0, "twa", &twa_fops)) < 0)
2147 TW_PRINTK(host, TW_DRIVER, 0x29, "Failed to register character device");
2148 }
2149 return 0;
2150
2151out_remove_host:
adam radford3dabec72008-07-22 16:47:40 -07002152 if (test_bit(TW_USING_MSI, &tw_dev->flags))
2153 pci_disable_msi(pdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002154 scsi_remove_host(host);
adam radford4039c302006-10-26 18:01:06 -07002155out_iounmap:
2156 iounmap(tw_dev->base_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002157out_release_mem_region:
2158 pci_release_regions(pdev);
2159out_free_device_extension:
2160 twa_free_device_extension(tw_dev);
2161 scsi_host_put(host);
2162out_disable_device:
2163 pci_disable_device(pdev);
2164
2165 return retval;
2166} /* End twa_probe() */
2167
2168/* This function is called to remove a device */
2169static void twa_remove(struct pci_dev *pdev)
2170{
2171 struct Scsi_Host *host = pci_get_drvdata(pdev);
2172 TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
2173
2174 scsi_remove_host(tw_dev->host);
2175
2176 /* Unregister character device */
2177 if (twa_major >= 0) {
2178 unregister_chrdev(twa_major, "twa");
2179 twa_major = -1;
2180 }
2181
Linus Torvalds1da177e2005-04-16 15:20:36 -07002182 /* Shutdown the card */
2183 __twa_shutdown(tw_dev);
2184
adam radford3dabec72008-07-22 16:47:40 -07002185 /* Disable MSI if enabled */
2186 if (test_bit(TW_USING_MSI, &tw_dev->flags))
2187 pci_disable_msi(pdev);
2188
adam radford4039c302006-10-26 18:01:06 -07002189 /* Free IO remapping */
2190 iounmap(tw_dev->base_addr);
2191
Linus Torvalds1da177e2005-04-16 15:20:36 -07002192 /* Free up the mem region */
2193 pci_release_regions(pdev);
2194
2195 /* Free up device extension resources */
2196 twa_free_device_extension(tw_dev);
2197
2198 scsi_host_put(tw_dev->host);
2199 pci_disable_device(pdev);
2200 twa_device_extension_count--;
2201} /* End twa_remove() */
2202
adam radford7a252fe2009-03-09 12:15:01 -08002203#ifdef CONFIG_PM
2204/* This function is called on PCI suspend */
2205static int twa_suspend(struct pci_dev *pdev, pm_message_t state)
2206{
2207 struct Scsi_Host *host = pci_get_drvdata(pdev);
2208 TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
2209
2210 printk(KERN_WARNING "3w-9xxx: Suspending host %d.\n", tw_dev->host->host_no);
2211
2212 TW_DISABLE_INTERRUPTS(tw_dev);
2213 free_irq(tw_dev->tw_pci_dev->irq, tw_dev);
2214
2215 if (test_bit(TW_USING_MSI, &tw_dev->flags))
2216 pci_disable_msi(pdev);
2217
2218 /* Tell the card we are shutting down */
2219 if (twa_initconnection(tw_dev, 1, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL)) {
2220 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x38, "Connection shutdown failed during suspend");
2221 } else {
2222 printk(KERN_WARNING "3w-9xxx: Suspend complete.\n");
2223 }
2224 TW_CLEAR_ALL_INTERRUPTS(tw_dev);
2225
2226 pci_save_state(pdev);
2227 pci_disable_device(pdev);
2228 pci_set_power_state(pdev, pci_choose_state(pdev, state));
2229
2230 return 0;
2231} /* End twa_suspend() */
2232
2233/* This function is called on PCI resume */
2234static int twa_resume(struct pci_dev *pdev)
2235{
2236 int retval = 0;
2237 struct Scsi_Host *host = pci_get_drvdata(pdev);
2238 TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
2239
2240 printk(KERN_WARNING "3w-9xxx: Resuming host %d.\n", tw_dev->host->host_no);
2241 pci_set_power_state(pdev, PCI_D0);
2242 pci_enable_wake(pdev, PCI_D0, 0);
2243 pci_restore_state(pdev);
2244
2245 retval = pci_enable_device(pdev);
2246 if (retval) {
2247 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x39, "Enable device failed during resume");
2248 return retval;
2249 }
2250
2251 pci_set_master(pdev);
2252 pci_try_set_mwi(pdev);
2253
Yang Hongyange9304382009-04-13 14:40:14 -07002254 if (pci_set_dma_mask(pdev, DMA_BIT_MASK(64))
2255 || pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64)))
2256 if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32))
2257 || pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32))) {
adam radford7a252fe2009-03-09 12:15:01 -08002258 TW_PRINTK(host, TW_DRIVER, 0x40, "Failed to set dma mask during resume");
2259 retval = -ENODEV;
2260 goto out_disable_device;
2261 }
2262
2263 /* Initialize the card */
2264 if (twa_reset_sequence(tw_dev, 0)) {
2265 retval = -ENODEV;
2266 goto out_disable_device;
2267 }
2268
2269 /* Now setup the interrupt handler */
2270 retval = request_irq(pdev->irq, twa_interrupt, IRQF_SHARED, "3w-9xxx", tw_dev);
2271 if (retval) {
2272 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x42, "Error requesting IRQ during resume");
2273 retval = -ENODEV;
2274 goto out_disable_device;
2275 }
2276
2277 /* Now enable MSI if enabled */
2278 if (test_bit(TW_USING_MSI, &tw_dev->flags))
2279 pci_enable_msi(pdev);
2280
2281 /* Re-enable interrupts on the card */
2282 TW_ENABLE_AND_CLEAR_INTERRUPTS(tw_dev);
2283
2284 printk(KERN_WARNING "3w-9xxx: Resume complete.\n");
2285 return 0;
2286
2287out_disable_device:
2288 scsi_remove_host(host);
2289 pci_disable_device(pdev);
2290
2291 return retval;
2292} /* End twa_resume() */
2293#endif
2294
Linus Torvalds1da177e2005-04-16 15:20:36 -07002295/* PCI Devices supported by this driver */
Greg Kroah-Hartman6f039792012-12-21 13:08:55 -08002296static struct pci_device_id twa_pci_tbl[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002297 { PCI_VENDOR_ID_3WARE, PCI_DEVICE_ID_3WARE_9000,
2298 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
adam radford49bfd8d2005-09-21 17:20:14 -07002299 { PCI_VENDOR_ID_3WARE, PCI_DEVICE_ID_3WARE_9550SX,
2300 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
adam radford4039c302006-10-26 18:01:06 -07002301 { PCI_VENDOR_ID_3WARE, PCI_DEVICE_ID_3WARE_9650SE,
2302 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
adam radford0e78d152007-07-20 15:28:28 -07002303 { PCI_VENDOR_ID_3WARE, PCI_DEVICE_ID_3WARE_9690SA,
2304 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
Linus Torvalds1da177e2005-04-16 15:20:36 -07002305 { }
2306};
2307MODULE_DEVICE_TABLE(pci, twa_pci_tbl);
2308
2309/* pci_driver initializer */
2310static struct pci_driver twa_driver = {
2311 .name = "3w-9xxx",
2312 .id_table = twa_pci_tbl,
2313 .probe = twa_probe,
2314 .remove = twa_remove,
adam radford7a252fe2009-03-09 12:15:01 -08002315#ifdef CONFIG_PM
2316 .suspend = twa_suspend,
2317 .resume = twa_resume,
2318#endif
Greg Kroah-Hartmand18c3db2005-06-23 17:35:56 -07002319 .shutdown = twa_shutdown
Linus Torvalds1da177e2005-04-16 15:20:36 -07002320};
2321
2322/* This function is called on driver initialization */
2323static int __init twa_init(void)
2324{
2325 printk(KERN_WARNING "3ware 9000 Storage Controller device driver for Linux v%s.\n", TW_DRIVER_VERSION);
2326
Henrik Kretzschmardcbccbde2006-09-25 16:58:58 -07002327 return pci_register_driver(&twa_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002328} /* End twa_init() */
2329
2330/* This function is called on driver exit */
2331static void __exit twa_exit(void)
2332{
2333 pci_unregister_driver(&twa_driver);
2334} /* End twa_exit() */
2335
2336module_init(twa_init);
2337module_exit(twa_exit);
2338