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