PageRenderTime 101ms CodeModel.GetById 16ms app.highlight 71ms RepoModel.GetById 1ms app.codeStats 1ms

/drivers/scsi/3w-9xxx.c

http://github.com/mirrors/linux
C | 2329 lines | 1721 code | 328 blank | 280 comment | 331 complexity | 1ec78623aa72c07ff5d392728782460e MD5 | raw file

Large files files are truncated, but you can click here to view the full file

   1/*
   2   3w-9xxx.c -- 3ware 9000 Storage Controller device driver for Linux.
   3
   4   Written By: Adam Radford <aradford@gmail.com>
   5   Modifications By: Tom Couch
   6
   7   Copyright (C) 2004-2009 Applied Micro Circuits Corporation.
   8   Copyright (C) 2010 LSI Corporation.
   9
  10   This program is free software; you can redistribute it and/or modify
  11   it under the terms of the GNU General Public License as published by
  12   the Free Software Foundation; version 2 of the License.
  13
  14   This program is distributed in the hope that it will be useful,
  15   but WITHOUT ANY WARRANTY; without even the implied warranty of
  16   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17   GNU General Public License for more details.
  18
  19   NO WARRANTY
  20   THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
  21   CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT
  22   LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
  23   MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
  24   solely responsible for determining the appropriateness of using and
  25   distributing the Program and assumes all risks associated with its
  26   exercise of rights under this Agreement, including but not limited to
  27   the risks and costs of program errors, damage to or loss of data,
  28   programs or equipment, and unavailability or interruption of operations.
  29
  30   DISCLAIMER OF LIABILITY
  31   NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
  32   DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  33   DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND
  34   ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
  35   TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  36   USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
  37   HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
  38
  39   You should have received a copy of the GNU General Public License
  40   along with this program; if not, write to the Free Software
  41   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  42
  43   Bugs/Comments/Suggestions should be mailed to:
  44   aradford@gmail.com
  45
  46   Note: This version of the driver does not contain a bundled firmware
  47         image.
  48
  49   History
  50   -------
  51   2.26.02.000 - Driver cleanup for kernel submission.
  52   2.26.02.001 - Replace schedule_timeout() calls with msleep().
  53   2.26.02.002 - Add support for PAE mode.
  54                 Add lun support.
  55                 Fix twa_remove() to free irq handler/unregister_chrdev()
  56                 before shutting down card.
  57                 Change to new 'change_queue_depth' api.
  58                 Fix 'handled=1' ISR usage, remove bogus IRQ check.
  59                 Remove un-needed eh_abort handler.
  60                 Add support for embedded firmware error strings.
  61   2.26.02.003 - Correctly handle single sgl's with use_sg=1.
  62   2.26.02.004 - Add support for 9550SX controllers.
  63   2.26.02.005 - Fix use_sg == 0 mapping on systems with 4GB or higher.
  64   2.26.02.006 - Fix 9550SX pchip reset timeout.
  65                 Add big endian support.
  66   2.26.02.007 - Disable local interrupts during kmap/unmap_atomic().
  67   2.26.02.008 - Free irq handler in __twa_shutdown().
  68                 Serialize reset code.
  69                 Add support for 9650SE controllers.
  70   2.26.02.009 - Fix dma mask setting to fallback to 32-bit if 64-bit fails.
  71   2.26.02.010 - Add support for 9690SA controllers.
  72   2.26.02.011 - Increase max AENs drained to 256.
  73                 Add MSI support and "use_msi" module parameter.
  74                 Fix bug in twa_get_param() on 4GB+.
  75                 Use pci_resource_len() for ioremap().
  76   2.26.02.012 - Add power management support.
  77   2.26.02.013 - Fix bug in twa_load_sgl().
  78   2.26.02.014 - Force 60 second timeout default.
  79*/
  80
  81#include <linux/module.h>
  82#include <linux/reboot.h>
  83#include <linux/spinlock.h>
  84#include <linux/interrupt.h>
  85#include <linux/moduleparam.h>
  86#include <linux/errno.h>
  87#include <linux/types.h>
  88#include <linux/delay.h>
  89#include <linux/pci.h>
  90#include <linux/time.h>
  91#include <linux/mutex.h>
  92#include <linux/slab.h>
  93#include <asm/io.h>
  94#include <asm/irq.h>
  95#include <linux/uaccess.h>
  96#include <scsi/scsi.h>
  97#include <scsi/scsi_host.h>
  98#include <scsi/scsi_tcq.h>
  99#include <scsi/scsi_cmnd.h>
 100#include "3w-9xxx.h"
 101
 102/* Globals */
 103#define TW_DRIVER_VERSION "2.26.02.014"
 104static DEFINE_MUTEX(twa_chrdev_mutex);
 105static TW_Device_Extension *twa_device_extension_list[TW_MAX_SLOT];
 106static unsigned int twa_device_extension_count;
 107static int twa_major = -1;
 108extern struct timezone sys_tz;
 109
 110/* Module parameters */
 111MODULE_AUTHOR ("LSI");
 112MODULE_DESCRIPTION ("3ware 9000 Storage Controller Linux Driver");
 113MODULE_LICENSE("GPL");
 114MODULE_VERSION(TW_DRIVER_VERSION);
 115
 116static int use_msi = 0;
 117module_param(use_msi, int, S_IRUGO);
 118MODULE_PARM_DESC(use_msi, "Use Message Signaled Interrupts.  Default: 0");
 119
 120/* Function prototypes */
 121static void twa_aen_queue_event(TW_Device_Extension *tw_dev, TW_Command_Apache_Header *header);
 122static int twa_aen_read_queue(TW_Device_Extension *tw_dev, int request_id);
 123static char *twa_aen_severity_lookup(unsigned char severity_code);
 124static void twa_aen_sync_time(TW_Device_Extension *tw_dev, int request_id);
 125static long twa_chrdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
 126static int twa_chrdev_open(struct inode *inode, struct file *file);
 127static int twa_fill_sense(TW_Device_Extension *tw_dev, int request_id, int copy_sense, int print_host);
 128static void twa_free_request_id(TW_Device_Extension *tw_dev,int request_id);
 129static void twa_get_request_id(TW_Device_Extension *tw_dev, int *request_id);
 130static int twa_initconnection(TW_Device_Extension *tw_dev, int message_credits,
 131 			      u32 set_features, unsigned short current_fw_srl, 
 132			      unsigned short current_fw_arch_id, 
 133			      unsigned short current_fw_branch, 
 134			      unsigned short current_fw_build, 
 135			      unsigned short *fw_on_ctlr_srl, 
 136			      unsigned short *fw_on_ctlr_arch_id, 
 137			      unsigned short *fw_on_ctlr_branch, 
 138			      unsigned short *fw_on_ctlr_build, 
 139			      u32 *init_connect_result);
 140static 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);
 141static int twa_poll_response(TW_Device_Extension *tw_dev, int request_id, int seconds);
 142static int twa_poll_status_gone(TW_Device_Extension *tw_dev, u32 flag, int seconds);
 143static int twa_post_command_packet(TW_Device_Extension *tw_dev, int request_id, char internal);
 144static int twa_reset_device_extension(TW_Device_Extension *tw_dev);
 145static int twa_reset_sequence(TW_Device_Extension *tw_dev, int soft_reset);
 146static int twa_scsiop_execute_scsi(TW_Device_Extension *tw_dev, int request_id,
 147				   unsigned char *cdb, int use_sg,
 148				   TW_SG_Entry *sglistarg);
 149static void twa_scsiop_execute_scsi_complete(TW_Device_Extension *tw_dev, int request_id);
 150static char *twa_string_lookup(twa_message_type *table, unsigned int aen_code);
 151
 152/* Functions */
 153
 154/* Show some statistics about the card */
 155static ssize_t twa_show_stats(struct device *dev,
 156			      struct device_attribute *attr, char *buf)
 157{
 158	struct Scsi_Host *host = class_to_shost(dev);
 159	TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
 160	unsigned long flags = 0;
 161	ssize_t len;
 162
 163	spin_lock_irqsave(tw_dev->host->host_lock, flags);
 164	len = snprintf(buf, PAGE_SIZE, "3w-9xxx Driver version: %s\n"
 165		       "Current commands posted:   %4d\n"
 166		       "Max commands posted:       %4d\n"
 167		       "Current pending commands:  %4d\n"
 168		       "Max pending commands:      %4d\n"
 169		       "Last sgl length:           %4d\n"
 170		       "Max sgl length:            %4d\n"
 171		       "Last sector count:         %4d\n"
 172		       "Max sector count:          %4d\n"
 173		       "SCSI Host Resets:          %4d\n"
 174		       "AEN's:                     %4d\n", 
 175		       TW_DRIVER_VERSION,
 176		       tw_dev->posted_request_count,
 177		       tw_dev->max_posted_request_count,
 178		       tw_dev->pending_request_count,
 179		       tw_dev->max_pending_request_count,
 180		       tw_dev->sgl_entries,
 181		       tw_dev->max_sgl_entries,
 182		       tw_dev->sector_count,
 183		       tw_dev->max_sector_count,
 184		       tw_dev->num_resets,
 185		       tw_dev->aen_count);
 186	spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
 187	return len;
 188} /* End twa_show_stats() */
 189
 190/* Create sysfs 'stats' entry */
 191static struct device_attribute twa_host_stats_attr = {
 192	.attr = {
 193		.name = 	"stats",
 194		.mode =		S_IRUGO,
 195	},
 196	.show = twa_show_stats
 197};
 198
 199/* Host attributes initializer */
 200static struct device_attribute *twa_host_attrs[] = {
 201	&twa_host_stats_attr,
 202	NULL,
 203};
 204
 205/* File operations struct for character device */
 206static const struct file_operations twa_fops = {
 207	.owner		= THIS_MODULE,
 208	.unlocked_ioctl	= twa_chrdev_ioctl,
 209	.open		= twa_chrdev_open,
 210	.release	= NULL,
 211	.llseek		= noop_llseek,
 212};
 213
 214/*
 215 * The controllers use an inline buffer instead of a mapped SGL for small,
 216 * single entry buffers.  Note that we treat a zero-length transfer like
 217 * a mapped SGL.
 218 */
 219static bool twa_command_mapped(struct scsi_cmnd *cmd)
 220{
 221	return scsi_sg_count(cmd) != 1 ||
 222		scsi_bufflen(cmd) >= TW_MIN_SGL_LENGTH;
 223}
 224
 225/* This function will complete an aen request from the isr */
 226static int twa_aen_complete(TW_Device_Extension *tw_dev, int request_id)
 227{
 228	TW_Command_Full *full_command_packet;
 229	TW_Command *command_packet;
 230	TW_Command_Apache_Header *header;
 231	unsigned short aen;
 232	int retval = 1;
 233
 234	header = (TW_Command_Apache_Header *)tw_dev->generic_buffer_virt[request_id];
 235	tw_dev->posted_request_count--;
 236	aen = le16_to_cpu(header->status_block.error);
 237	full_command_packet = tw_dev->command_packet_virt[request_id];
 238	command_packet = &full_command_packet->command.oldcommand;
 239
 240	/* First check for internal completion of set param for time sync */
 241	if (TW_OP_OUT(command_packet->opcode__sgloffset) == TW_OP_SET_PARAM) {
 242		/* Keep reading the queue in case there are more aen's */
 243		if (twa_aen_read_queue(tw_dev, request_id))
 244			goto out2;
 245	        else {
 246			retval = 0;
 247			goto out;
 248		}
 249	}
 250
 251	switch (aen) {
 252	case TW_AEN_QUEUE_EMPTY:
 253		/* Quit reading the queue if this is the last one */
 254		break;
 255	case TW_AEN_SYNC_TIME_WITH_HOST:
 256		twa_aen_sync_time(tw_dev, request_id);
 257		retval = 0;
 258		goto out;
 259	default:
 260		twa_aen_queue_event(tw_dev, header);
 261
 262		/* If there are more aen's, keep reading the queue */
 263		if (twa_aen_read_queue(tw_dev, request_id))
 264			goto out2;
 265		else {
 266			retval = 0;
 267			goto out;
 268		}
 269	}
 270	retval = 0;
 271out2:
 272	tw_dev->state[request_id] = TW_S_COMPLETED;
 273	twa_free_request_id(tw_dev, request_id);
 274	clear_bit(TW_IN_ATTENTION_LOOP, &tw_dev->flags);
 275out:
 276	return retval;
 277} /* End twa_aen_complete() */
 278
 279/* This function will drain aen queue */
 280static int twa_aen_drain_queue(TW_Device_Extension *tw_dev, int no_check_reset)
 281{
 282	int request_id = 0;
 283	unsigned char cdb[TW_MAX_CDB_LEN];
 284	TW_SG_Entry sglist[1];
 285	int finished = 0, count = 0;
 286	TW_Command_Full *full_command_packet;
 287	TW_Command_Apache_Header *header;
 288	unsigned short aen;
 289	int first_reset = 0, queue = 0, retval = 1;
 290
 291	if (no_check_reset)
 292		first_reset = 0;
 293	else
 294		first_reset = 1;
 295
 296	full_command_packet = tw_dev->command_packet_virt[request_id];
 297	memset(full_command_packet, 0, sizeof(TW_Command_Full));
 298
 299	/* Initialize cdb */
 300	memset(&cdb, 0, TW_MAX_CDB_LEN);
 301	cdb[0] = REQUEST_SENSE; /* opcode */
 302	cdb[4] = TW_ALLOCATION_LENGTH; /* allocation length */
 303
 304	/* Initialize sglist */
 305	memset(&sglist, 0, sizeof(TW_SG_Entry));
 306	sglist[0].length = TW_SECTOR_SIZE;
 307	sglist[0].address = tw_dev->generic_buffer_phys[request_id];
 308
 309	if (sglist[0].address & TW_ALIGNMENT_9000_SGL) {
 310		TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1, "Found unaligned address during AEN drain");
 311		goto out;
 312	}
 313
 314	/* Mark internal command */
 315	tw_dev->srb[request_id] = NULL;
 316
 317	do {
 318		/* Send command to the board */
 319		if (twa_scsiop_execute_scsi(tw_dev, request_id, cdb, 1, sglist)) {
 320			TW_PRINTK(tw_dev->host, TW_DRIVER, 0x2, "Error posting request sense");
 321			goto out;
 322		}
 323
 324		/* Now poll for completion */
 325		if (twa_poll_response(tw_dev, request_id, 30)) {
 326			TW_PRINTK(tw_dev->host, TW_DRIVER, 0x3, "No valid response while draining AEN queue");
 327			tw_dev->posted_request_count--;
 328			goto out;
 329		}
 330
 331		tw_dev->posted_request_count--;
 332		header = (TW_Command_Apache_Header *)tw_dev->generic_buffer_virt[request_id];
 333		aen = le16_to_cpu(header->status_block.error);
 334		queue = 0;
 335		count++;
 336
 337		switch (aen) {
 338		case TW_AEN_QUEUE_EMPTY:
 339			if (first_reset != 1)
 340				goto out;
 341			else
 342				finished = 1;
 343			break;
 344		case TW_AEN_SOFT_RESET:
 345			if (first_reset == 0)
 346				first_reset = 1;
 347			else
 348				queue = 1;
 349			break;
 350		case TW_AEN_SYNC_TIME_WITH_HOST:
 351			break;
 352		default:
 353			queue = 1;
 354		}
 355
 356		/* Now queue an event info */
 357		if (queue)
 358			twa_aen_queue_event(tw_dev, header);
 359	} while ((finished == 0) && (count < TW_MAX_AEN_DRAIN));
 360
 361	if (count == TW_MAX_AEN_DRAIN)
 362		goto out;
 363
 364	retval = 0;
 365out:
 366	tw_dev->state[request_id] = TW_S_INITIAL;
 367	return retval;
 368} /* End twa_aen_drain_queue() */
 369
 370/* This function will queue an event */
 371static void twa_aen_queue_event(TW_Device_Extension *tw_dev, TW_Command_Apache_Header *header)
 372{
 373	u32 local_time;
 374	TW_Event *event;
 375	unsigned short aen;
 376	char host[16];
 377	char *error_str;
 378
 379	tw_dev->aen_count++;
 380
 381	/* Fill out event info */
 382	event = tw_dev->event_queue[tw_dev->error_index];
 383
 384	/* Check for clobber */
 385	host[0] = '\0';
 386	if (tw_dev->host) {
 387		sprintf(host, " scsi%d:", tw_dev->host->host_no);
 388		if (event->retrieved == TW_AEN_NOT_RETRIEVED)
 389			tw_dev->aen_clobber = 1;
 390	}
 391
 392	aen = le16_to_cpu(header->status_block.error);
 393	memset(event, 0, sizeof(TW_Event));
 394
 395	event->severity = TW_SEV_OUT(header->status_block.severity__reserved);
 396	/* event->time_stamp_sec overflows in y2106 */
 397	local_time = (u32)(ktime_get_real_seconds() - (sys_tz.tz_minuteswest * 60));
 398	event->time_stamp_sec = local_time;
 399	event->aen_code = aen;
 400	event->retrieved = TW_AEN_NOT_RETRIEVED;
 401	event->sequence_id = tw_dev->error_sequence_id;
 402	tw_dev->error_sequence_id++;
 403
 404	/* Check for embedded error string */
 405	error_str = &(header->err_specific_desc[strlen(header->err_specific_desc)+1]);
 406
 407	header->err_specific_desc[sizeof(header->err_specific_desc) - 1] = '\0';
 408	event->parameter_len = strlen(header->err_specific_desc);
 409	memcpy(event->parameter_data, header->err_specific_desc, event->parameter_len + (error_str[0] == '\0' ? 0 : (1 + strlen(error_str))));
 410	if (event->severity != TW_AEN_SEVERITY_DEBUG)
 411		printk(KERN_WARNING "3w-9xxx:%s AEN: %s (0x%02X:0x%04X): %s:%s.\n",
 412		       host,
 413		       twa_aen_severity_lookup(TW_SEV_OUT(header->status_block.severity__reserved)),
 414		       TW_MESSAGE_SOURCE_CONTROLLER_EVENT, aen,
 415		       error_str[0] == '\0' ? twa_string_lookup(twa_aen_table, aen) : error_str,
 416		       header->err_specific_desc);
 417	else
 418		tw_dev->aen_count--;
 419
 420	if ((tw_dev->error_index + 1) == TW_Q_LENGTH)
 421		tw_dev->event_queue_wrapped = 1;
 422	tw_dev->error_index = (tw_dev->error_index + 1 ) % TW_Q_LENGTH;
 423} /* End twa_aen_queue_event() */
 424
 425/* This function will read the aen queue from the isr */
 426static int twa_aen_read_queue(TW_Device_Extension *tw_dev, int request_id)
 427{
 428	unsigned char cdb[TW_MAX_CDB_LEN];
 429	TW_SG_Entry sglist[1];
 430	TW_Command_Full *full_command_packet;
 431	int retval = 1;
 432
 433	full_command_packet = tw_dev->command_packet_virt[request_id];
 434	memset(full_command_packet, 0, sizeof(TW_Command_Full));
 435
 436	/* Initialize cdb */
 437	memset(&cdb, 0, TW_MAX_CDB_LEN);
 438	cdb[0] = REQUEST_SENSE; /* opcode */
 439	cdb[4] = TW_ALLOCATION_LENGTH; /* allocation length */
 440
 441	/* Initialize sglist */
 442	memset(&sglist, 0, sizeof(TW_SG_Entry));
 443	sglist[0].length = TW_SECTOR_SIZE;
 444	sglist[0].address = tw_dev->generic_buffer_phys[request_id];
 445
 446	/* Mark internal command */
 447	tw_dev->srb[request_id] = NULL;
 448
 449	/* Now post the command packet */
 450	if (twa_scsiop_execute_scsi(tw_dev, request_id, cdb, 1, sglist)) {
 451		TW_PRINTK(tw_dev->host, TW_DRIVER, 0x4, "Post failed while reading AEN queue");
 452		goto out;
 453	}
 454	retval = 0;
 455out:
 456	return retval;
 457} /* End twa_aen_read_queue() */
 458
 459/* This function will look up an AEN severity string */
 460static char *twa_aen_severity_lookup(unsigned char severity_code)
 461{
 462	char *retval = NULL;
 463
 464	if ((severity_code < (unsigned char) TW_AEN_SEVERITY_ERROR) ||
 465	    (severity_code > (unsigned char) TW_AEN_SEVERITY_DEBUG))
 466		goto out;
 467
 468	retval = twa_aen_severity_table[severity_code];
 469out:
 470	return retval;
 471} /* End twa_aen_severity_lookup() */
 472
 473/* This function will sync firmware time with the host time */
 474static void twa_aen_sync_time(TW_Device_Extension *tw_dev, int request_id)
 475{
 476	u32 schedulertime;
 477	TW_Command_Full *full_command_packet;
 478	TW_Command *command_packet;
 479	TW_Param_Apache *param;
 480	time64_t local_time;
 481
 482	/* Fill out the command packet */
 483	full_command_packet = tw_dev->command_packet_virt[request_id];
 484	memset(full_command_packet, 0, sizeof(TW_Command_Full));
 485	command_packet = &full_command_packet->command.oldcommand;
 486	command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_SET_PARAM);
 487	command_packet->request_id = request_id;
 488	command_packet->byte8_offset.param.sgl[0].address = TW_CPU_TO_SGL(tw_dev->generic_buffer_phys[request_id]);
 489	command_packet->byte8_offset.param.sgl[0].length = cpu_to_le32(TW_SECTOR_SIZE);
 490	command_packet->size = TW_COMMAND_SIZE;
 491	command_packet->byte6_offset.parameter_count = cpu_to_le16(1);
 492
 493	/* Setup the param */
 494	param = (TW_Param_Apache *)tw_dev->generic_buffer_virt[request_id];
 495	memset(param, 0, TW_SECTOR_SIZE);
 496	param->table_id = cpu_to_le16(TW_TIMEKEEP_TABLE | 0x8000); /* Controller time keep table */
 497	param->parameter_id = cpu_to_le16(0x3); /* SchedulerTime */
 498	param->parameter_size_bytes = cpu_to_le16(4);
 499
 500	/* Convert system time in UTC to local time seconds since last 
 501           Sunday 12:00AM */
 502	local_time = (ktime_get_real_seconds() - (sys_tz.tz_minuteswest * 60));
 503	div_u64_rem(local_time - (3 * 86400), 604800, &schedulertime);
 504	schedulertime = cpu_to_le32(schedulertime % 604800);
 505
 506	memcpy(param->data, &schedulertime, sizeof(u32));
 507
 508	/* Mark internal command */
 509	tw_dev->srb[request_id] = NULL;
 510
 511	/* Now post the command */
 512	twa_post_command_packet(tw_dev, request_id, 1);
 513} /* End twa_aen_sync_time() */
 514
 515/* This function will allocate memory and check if it is correctly aligned */
 516static int twa_allocate_memory(TW_Device_Extension *tw_dev, int size, int which)
 517{
 518	int i;
 519	dma_addr_t dma_handle;
 520	unsigned long *cpu_addr;
 521	int retval = 1;
 522
 523	cpu_addr = dma_alloc_coherent(&tw_dev->tw_pci_dev->dev,
 524			size * TW_Q_LENGTH, &dma_handle, GFP_KERNEL);
 525	if (!cpu_addr) {
 526		TW_PRINTK(tw_dev->host, TW_DRIVER, 0x5, "Memory allocation failed");
 527		goto out;
 528	}
 529
 530	if ((unsigned long)cpu_addr % (TW_ALIGNMENT_9000)) {
 531		TW_PRINTK(tw_dev->host, TW_DRIVER, 0x6, "Failed to allocate correctly aligned memory");
 532		dma_free_coherent(&tw_dev->tw_pci_dev->dev, size * TW_Q_LENGTH,
 533				cpu_addr, dma_handle);
 534		goto out;
 535	}
 536
 537	memset(cpu_addr, 0, size*TW_Q_LENGTH);
 538
 539	for (i = 0; i < TW_Q_LENGTH; i++) {
 540		switch(which) {
 541		case 0:
 542			tw_dev->command_packet_phys[i] = dma_handle+(i*size);
 543			tw_dev->command_packet_virt[i] = (TW_Command_Full *)((unsigned char *)cpu_addr + (i*size));
 544			break;
 545		case 1:
 546			tw_dev->generic_buffer_phys[i] = dma_handle+(i*size);
 547			tw_dev->generic_buffer_virt[i] = (unsigned long *)((unsigned char *)cpu_addr + (i*size));
 548			break;
 549		}
 550	}
 551	retval = 0;
 552out:
 553	return retval;
 554} /* End twa_allocate_memory() */
 555
 556/* This function will check the status register for unexpected bits */
 557static int twa_check_bits(u32 status_reg_value)
 558{
 559	int retval = 1;
 560
 561	if ((status_reg_value & TW_STATUS_EXPECTED_BITS) != TW_STATUS_EXPECTED_BITS)
 562		goto out;
 563	if ((status_reg_value & TW_STATUS_UNEXPECTED_BITS) != 0)
 564		goto out;
 565
 566	retval = 0;
 567out:
 568	return retval;
 569} /* End twa_check_bits() */
 570
 571/* This function will check the srl and decide if we are compatible  */
 572static int twa_check_srl(TW_Device_Extension *tw_dev, int *flashed)
 573{
 574	int retval = 1;
 575	unsigned short fw_on_ctlr_srl = 0, fw_on_ctlr_arch_id = 0;
 576	unsigned short fw_on_ctlr_branch = 0, fw_on_ctlr_build = 0;
 577	u32 init_connect_result = 0;
 578
 579	if (twa_initconnection(tw_dev, TW_INIT_MESSAGE_CREDITS,
 580			       TW_EXTENDED_INIT_CONNECT, TW_CURRENT_DRIVER_SRL,
 581			       TW_9000_ARCH_ID, TW_CURRENT_DRIVER_BRANCH,
 582			       TW_CURRENT_DRIVER_BUILD, &fw_on_ctlr_srl,
 583			       &fw_on_ctlr_arch_id, &fw_on_ctlr_branch,
 584			       &fw_on_ctlr_build, &init_connect_result)) {
 585		TW_PRINTK(tw_dev->host, TW_DRIVER, 0x7, "Initconnection failed while checking SRL");
 586		goto out;
 587	}
 588
 589	tw_dev->tw_compat_info.working_srl = fw_on_ctlr_srl;
 590	tw_dev->tw_compat_info.working_branch = fw_on_ctlr_branch;
 591	tw_dev->tw_compat_info.working_build = fw_on_ctlr_build;
 592
 593	/* Try base mode compatibility */
 594	if (!(init_connect_result & TW_CTLR_FW_COMPATIBLE)) {
 595		if (twa_initconnection(tw_dev, TW_INIT_MESSAGE_CREDITS,
 596				       TW_EXTENDED_INIT_CONNECT,
 597				       TW_BASE_FW_SRL, TW_9000_ARCH_ID,
 598				       TW_BASE_FW_BRANCH, TW_BASE_FW_BUILD,
 599				       &fw_on_ctlr_srl, &fw_on_ctlr_arch_id,
 600				       &fw_on_ctlr_branch, &fw_on_ctlr_build,
 601				       &init_connect_result)) {
 602			TW_PRINTK(tw_dev->host, TW_DRIVER, 0xa, "Initconnection (base mode) failed while checking SRL");
 603			goto out;
 604		}
 605		if (!(init_connect_result & TW_CTLR_FW_COMPATIBLE)) {
 606			if (TW_CURRENT_DRIVER_SRL > fw_on_ctlr_srl) {
 607				TW_PRINTK(tw_dev->host, TW_DRIVER, 0x32, "Firmware and driver incompatibility: please upgrade firmware");
 608			} else {
 609				TW_PRINTK(tw_dev->host, TW_DRIVER, 0x33, "Firmware and driver incompatibility: please upgrade driver");
 610			}
 611			goto out;
 612		}
 613		tw_dev->tw_compat_info.working_srl = TW_BASE_FW_SRL;
 614		tw_dev->tw_compat_info.working_branch = TW_BASE_FW_BRANCH;
 615		tw_dev->tw_compat_info.working_build = TW_BASE_FW_BUILD;
 616	}
 617
 618	/* Load rest of compatibility struct */
 619	strlcpy(tw_dev->tw_compat_info.driver_version, TW_DRIVER_VERSION,
 620		sizeof(tw_dev->tw_compat_info.driver_version));
 621	tw_dev->tw_compat_info.driver_srl_high = TW_CURRENT_DRIVER_SRL;
 622	tw_dev->tw_compat_info.driver_branch_high = TW_CURRENT_DRIVER_BRANCH;
 623	tw_dev->tw_compat_info.driver_build_high = TW_CURRENT_DRIVER_BUILD;
 624	tw_dev->tw_compat_info.driver_srl_low = TW_BASE_FW_SRL;
 625	tw_dev->tw_compat_info.driver_branch_low = TW_BASE_FW_BRANCH;
 626	tw_dev->tw_compat_info.driver_build_low = TW_BASE_FW_BUILD;
 627	tw_dev->tw_compat_info.fw_on_ctlr_srl = fw_on_ctlr_srl;
 628	tw_dev->tw_compat_info.fw_on_ctlr_branch = fw_on_ctlr_branch;
 629	tw_dev->tw_compat_info.fw_on_ctlr_build = fw_on_ctlr_build;
 630
 631	retval = 0;
 632out:
 633	return retval;
 634} /* End twa_check_srl() */
 635
 636/* This function handles ioctl for the character device */
 637static long twa_chrdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 638{
 639	struct inode *inode = file_inode(file);
 640	long timeout;
 641	unsigned long *cpu_addr, data_buffer_length_adjusted = 0, flags = 0;
 642	dma_addr_t dma_handle;
 643	int request_id = 0;
 644	unsigned int sequence_id = 0;
 645	unsigned char event_index, start_index;
 646	TW_Ioctl_Driver_Command driver_command;
 647	TW_Ioctl_Buf_Apache *tw_ioctl;
 648	TW_Lock *tw_lock;
 649	TW_Command_Full *full_command_packet;
 650	TW_Compatibility_Info *tw_compat_info;
 651	TW_Event *event;
 652	ktime_t current_time;
 653	TW_Device_Extension *tw_dev = twa_device_extension_list[iminor(inode)];
 654	int retval = TW_IOCTL_ERROR_OS_EFAULT;
 655	void __user *argp = (void __user *)arg;
 656
 657	mutex_lock(&twa_chrdev_mutex);
 658
 659	/* Only let one of these through at a time */
 660	if (mutex_lock_interruptible(&tw_dev->ioctl_lock)) {
 661		retval = TW_IOCTL_ERROR_OS_EINTR;
 662		goto out;
 663	}
 664
 665	/* First copy down the driver command */
 666	if (copy_from_user(&driver_command, argp, sizeof(TW_Ioctl_Driver_Command)))
 667		goto out2;
 668
 669	/* Check data buffer size */
 670	if (driver_command.buffer_length > TW_MAX_SECTORS * 2048) {
 671		retval = TW_IOCTL_ERROR_OS_EINVAL;
 672		goto out2;
 673	}
 674
 675	/* Hardware can only do multiple of 512 byte transfers */
 676	data_buffer_length_adjusted = (driver_command.buffer_length + 511) & ~511;
 677
 678	/* Now allocate ioctl buf memory */
 679	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);
 680	if (!cpu_addr) {
 681		retval = TW_IOCTL_ERROR_OS_ENOMEM;
 682		goto out2;
 683	}
 684
 685	tw_ioctl = (TW_Ioctl_Buf_Apache *)cpu_addr;
 686
 687	/* Now copy down the entire ioctl */
 688	if (copy_from_user(tw_ioctl, argp, driver_command.buffer_length + sizeof(TW_Ioctl_Buf_Apache) - 1))
 689		goto out3;
 690
 691	/* See which ioctl we are doing */
 692	switch (cmd) {
 693	case TW_IOCTL_FIRMWARE_PASS_THROUGH:
 694		spin_lock_irqsave(tw_dev->host->host_lock, flags);
 695		twa_get_request_id(tw_dev, &request_id);
 696
 697		/* Flag internal command */
 698		tw_dev->srb[request_id] = NULL;
 699
 700		/* Flag chrdev ioctl */
 701		tw_dev->chrdev_request_id = request_id;
 702
 703		full_command_packet = &tw_ioctl->firmware_command;
 704
 705		/* Load request id and sglist for both command types */
 706		twa_load_sgl(tw_dev, full_command_packet, request_id, dma_handle, data_buffer_length_adjusted);
 707
 708		memcpy(tw_dev->command_packet_virt[request_id], &(tw_ioctl->firmware_command), sizeof(TW_Command_Full));
 709
 710		/* Now post the command packet to the controller */
 711		twa_post_command_packet(tw_dev, request_id, 1);
 712		spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
 713
 714		timeout = TW_IOCTL_CHRDEV_TIMEOUT*HZ;
 715
 716		/* Now wait for command to complete */
 717		timeout = wait_event_timeout(tw_dev->ioctl_wqueue, tw_dev->chrdev_request_id == TW_IOCTL_CHRDEV_FREE, timeout);
 718
 719		/* We timed out, and didn't get an interrupt */
 720		if (tw_dev->chrdev_request_id != TW_IOCTL_CHRDEV_FREE) {
 721			/* Now we need to reset the board */
 722			printk(KERN_WARNING "3w-9xxx: scsi%d: WARNING: (0x%02X:0x%04X): Character ioctl (0x%x) timed out, resetting card.\n",
 723			       tw_dev->host->host_no, TW_DRIVER, 0x37,
 724			       cmd);
 725			retval = TW_IOCTL_ERROR_OS_EIO;
 726			twa_reset_device_extension(tw_dev);
 727			goto out3;
 728		}
 729
 730		/* Now copy in the command packet response */
 731		memcpy(&(tw_ioctl->firmware_command), tw_dev->command_packet_virt[request_id], sizeof(TW_Command_Full));
 732		
 733		/* Now complete the io */
 734		spin_lock_irqsave(tw_dev->host->host_lock, flags);
 735		tw_dev->posted_request_count--;
 736		tw_dev->state[request_id] = TW_S_COMPLETED;
 737		twa_free_request_id(tw_dev, request_id);
 738		spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
 739		break;
 740	case TW_IOCTL_GET_COMPATIBILITY_INFO:
 741		tw_ioctl->driver_command.status = 0;
 742		/* Copy compatibility struct into ioctl data buffer */
 743		tw_compat_info = (TW_Compatibility_Info *)tw_ioctl->data_buffer;
 744		memcpy(tw_compat_info, &tw_dev->tw_compat_info, sizeof(TW_Compatibility_Info));
 745		break;
 746	case TW_IOCTL_GET_LAST_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		} else {
 754			if (!tw_dev->error_index) {
 755				tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS;
 756				break;
 757			}
 758			tw_ioctl->driver_command.status = 0;
 759		}
 760		event_index = (tw_dev->error_index - 1 + TW_Q_LENGTH) % TW_Q_LENGTH;
 761		memcpy(tw_ioctl->data_buffer, tw_dev->event_queue[event_index], sizeof(TW_Event));
 762		tw_dev->event_queue[event_index]->retrieved = TW_AEN_RETRIEVED;
 763		break;
 764	case TW_IOCTL_GET_FIRST_EVENT:
 765		if (tw_dev->event_queue_wrapped) {
 766			if (tw_dev->aen_clobber) {
 767				tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_AEN_CLOBBER;
 768				tw_dev->aen_clobber = 0;
 769			} else 
 770				tw_ioctl->driver_command.status = 0;
 771			event_index = tw_dev->error_index;
 772		} else {
 773			if (!tw_dev->error_index) {
 774				tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS;
 775				break;
 776			}
 777			tw_ioctl->driver_command.status = 0;
 778			event_index = 0;
 779		}
 780		memcpy(tw_ioctl->data_buffer, tw_dev->event_queue[event_index], sizeof(TW_Event));
 781		tw_dev->event_queue[event_index]->retrieved = TW_AEN_RETRIEVED;
 782		break;
 783	case TW_IOCTL_GET_NEXT_EVENT:
 784		event = (TW_Event *)tw_ioctl->data_buffer;
 785		sequence_id = event->sequence_id;
 786		tw_ioctl->driver_command.status = 0;
 787
 788		if (tw_dev->event_queue_wrapped) {
 789			if (tw_dev->aen_clobber) {
 790				tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_AEN_CLOBBER;
 791				tw_dev->aen_clobber = 0;
 792			}
 793			start_index = tw_dev->error_index;
 794		} else {
 795			if (!tw_dev->error_index) {
 796				tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS;
 797				break;
 798			}
 799			start_index = 0;
 800		}
 801		event_index = (start_index + sequence_id - tw_dev->event_queue[start_index]->sequence_id + 1) % TW_Q_LENGTH;
 802
 803		if (!(tw_dev->event_queue[event_index]->sequence_id > sequence_id)) {
 804			if (tw_ioctl->driver_command.status == TW_IOCTL_ERROR_STATUS_AEN_CLOBBER)
 805				tw_dev->aen_clobber = 1;
 806			tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS;
 807			break;
 808		}
 809		memcpy(tw_ioctl->data_buffer, tw_dev->event_queue[event_index], sizeof(TW_Event));
 810		tw_dev->event_queue[event_index]->retrieved = TW_AEN_RETRIEVED;
 811		break;
 812	case TW_IOCTL_GET_PREVIOUS_EVENT:
 813		event = (TW_Event *)tw_ioctl->data_buffer;
 814		sequence_id = event->sequence_id;
 815		tw_ioctl->driver_command.status = 0;
 816
 817		if (tw_dev->event_queue_wrapped) {
 818			if (tw_dev->aen_clobber) {
 819				tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_AEN_CLOBBER;
 820				tw_dev->aen_clobber = 0;
 821			}
 822			start_index = tw_dev->error_index;
 823		} else {
 824			if (!tw_dev->error_index) {
 825				tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS;
 826				break;
 827			}
 828			start_index = 0;
 829		}
 830		event_index = (start_index + sequence_id - tw_dev->event_queue[start_index]->sequence_id - 1) % TW_Q_LENGTH;
 831
 832		if (!(tw_dev->event_queue[event_index]->sequence_id < sequence_id)) {
 833			if (tw_ioctl->driver_command.status == TW_IOCTL_ERROR_STATUS_AEN_CLOBBER)
 834				tw_dev->aen_clobber = 1;
 835			tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS;
 836			break;
 837		}
 838		memcpy(tw_ioctl->data_buffer, tw_dev->event_queue[event_index], sizeof(TW_Event));
 839		tw_dev->event_queue[event_index]->retrieved = TW_AEN_RETRIEVED;
 840		break;
 841	case TW_IOCTL_GET_LOCK:
 842		tw_lock = (TW_Lock *)tw_ioctl->data_buffer;
 843		current_time = ktime_get();
 844
 845		if ((tw_lock->force_flag == 1) || (tw_dev->ioctl_sem_lock == 0) ||
 846		    ktime_after(current_time, tw_dev->ioctl_time)) {
 847			tw_dev->ioctl_sem_lock = 1;
 848			tw_dev->ioctl_time = ktime_add_ms(current_time, tw_lock->timeout_msec);
 849			tw_ioctl->driver_command.status = 0;
 850			tw_lock->time_remaining_msec = tw_lock->timeout_msec;
 851		} else {
 852			tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_LOCKED;
 853			tw_lock->time_remaining_msec = ktime_ms_delta(tw_dev->ioctl_time, current_time);
 854		}
 855		break;
 856	case TW_IOCTL_RELEASE_LOCK:
 857		if (tw_dev->ioctl_sem_lock == 1) {
 858			tw_dev->ioctl_sem_lock = 0;
 859			tw_ioctl->driver_command.status = 0;
 860		} else {
 861			tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NOT_LOCKED;
 862		}
 863		break;
 864	default:
 865		retval = TW_IOCTL_ERROR_OS_ENOTTY;
 866		goto out3;
 867	}
 868
 869	/* Now copy the entire response to userspace */
 870	if (copy_to_user(argp, tw_ioctl, sizeof(TW_Ioctl_Buf_Apache) + driver_command.buffer_length - 1) == 0)
 871		retval = 0;
 872out3:
 873	/* Now free ioctl buf memory */
 874	dma_free_coherent(&tw_dev->tw_pci_dev->dev, data_buffer_length_adjusted+sizeof(TW_Ioctl_Buf_Apache) - 1, cpu_addr, dma_handle);
 875out2:
 876	mutex_unlock(&tw_dev->ioctl_lock);
 877out:
 878	mutex_unlock(&twa_chrdev_mutex);
 879	return retval;
 880} /* End twa_chrdev_ioctl() */
 881
 882/* This function handles open for the character device */
 883/* NOTE that this function will race with remove. */
 884static int twa_chrdev_open(struct inode *inode, struct file *file)
 885{
 886	unsigned int minor_number;
 887	int retval = TW_IOCTL_ERROR_OS_ENODEV;
 888
 889	if (!capable(CAP_SYS_ADMIN)) {
 890		retval = -EACCES;
 891		goto out;
 892	}
 893
 894	minor_number = iminor(inode);
 895	if (minor_number >= twa_device_extension_count)
 896		goto out;
 897	retval = 0;
 898out:
 899	return retval;
 900} /* End twa_chrdev_open() */
 901
 902/* This function will print readable messages from status register errors */
 903static int twa_decode_bits(TW_Device_Extension *tw_dev, u32 status_reg_value)
 904{
 905	int retval = 1;
 906
 907	/* Check for various error conditions and handle them appropriately */
 908	if (status_reg_value & TW_STATUS_PCI_PARITY_ERROR) {
 909		TW_PRINTK(tw_dev->host, TW_DRIVER, 0xc, "PCI Parity Error: clearing");
 910		writel(TW_CONTROL_CLEAR_PARITY_ERROR, TW_CONTROL_REG_ADDR(tw_dev));
 911	}
 912
 913	if (status_reg_value & TW_STATUS_PCI_ABORT) {
 914		TW_PRINTK(tw_dev->host, TW_DRIVER, 0xd, "PCI Abort: clearing");
 915		writel(TW_CONTROL_CLEAR_PCI_ABORT, TW_CONTROL_REG_ADDR(tw_dev));
 916		pci_write_config_word(tw_dev->tw_pci_dev, PCI_STATUS, TW_PCI_CLEAR_PCI_ABORT);
 917	}
 918
 919	if (status_reg_value & TW_STATUS_QUEUE_ERROR) {
 920		if (((tw_dev->tw_pci_dev->device != PCI_DEVICE_ID_3WARE_9650SE) &&
 921		     (tw_dev->tw_pci_dev->device != PCI_DEVICE_ID_3WARE_9690SA)) ||
 922		    (!test_bit(TW_IN_RESET, &tw_dev->flags)))
 923			TW_PRINTK(tw_dev->host, TW_DRIVER, 0xe, "Controller Queue Error: clearing");
 924		writel(TW_CONTROL_CLEAR_QUEUE_ERROR, TW_CONTROL_REG_ADDR(tw_dev));
 925	}
 926
 927	if (status_reg_value & TW_STATUS_MICROCONTROLLER_ERROR) {
 928		if (tw_dev->reset_print == 0) {
 929			TW_PRINTK(tw_dev->host, TW_DRIVER, 0x10, "Microcontroller Error: clearing");
 930			tw_dev->reset_print = 1;
 931		}
 932		goto out;
 933	}
 934	retval = 0;
 935out:
 936	return retval;
 937} /* End twa_decode_bits() */
 938
 939/* This function will empty the response queue */
 940static int twa_empty_response_queue(TW_Device_Extension *tw_dev)
 941{
 942	u32 status_reg_value, response_que_value;
 943	int count = 0, retval = 1;
 944
 945	status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
 946
 947	while (((status_reg_value & TW_STATUS_RESPONSE_QUEUE_EMPTY) == 0) && (count < TW_MAX_RESPONSE_DRAIN)) {
 948		response_que_value = readl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev));
 949		status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
 950		count++;
 951	}
 952	if (count == TW_MAX_RESPONSE_DRAIN)
 953		goto out;
 954
 955	retval = 0;
 956out:
 957	return retval;
 958} /* End twa_empty_response_queue() */
 959
 960/* This function will clear the pchip/response queue on 9550SX */
 961static int twa_empty_response_queue_large(TW_Device_Extension *tw_dev)
 962{
 963	u32 response_que_value = 0;
 964	unsigned long before;
 965	int retval = 1;
 966
 967	if (tw_dev->tw_pci_dev->device != PCI_DEVICE_ID_3WARE_9000) {
 968		before = jiffies;
 969		while ((response_que_value & TW_9550SX_DRAIN_COMPLETED) != TW_9550SX_DRAIN_COMPLETED) {
 970			response_que_value = readl(TW_RESPONSE_QUEUE_REG_ADDR_LARGE(tw_dev));
 971			msleep(1);
 972			if (time_after(jiffies, before + HZ * 30))
 973				goto out;
 974		}
 975		/* P-chip settle time */
 976		msleep(500);
 977		retval = 0;
 978	} else
 979		retval = 0;
 980out:
 981	return retval;
 982} /* End twa_empty_response_queue_large() */
 983
 984/* This function passes sense keys from firmware to scsi layer */
 985static int twa_fill_sense(TW_Device_Extension *tw_dev, int request_id, int copy_sense, int print_host)
 986{
 987	TW_Command_Full *full_command_packet;
 988	unsigned short error;
 989	int retval = 1;
 990	char *error_str;
 991
 992	full_command_packet = tw_dev->command_packet_virt[request_id];
 993
 994	/* Check for embedded error string */
 995	error_str = &(full_command_packet->header.err_specific_desc[strlen(full_command_packet->header.err_specific_desc) + 1]);
 996
 997	/* Don't print error for Logical unit not supported during rollcall */
 998	error = le16_to_cpu(full_command_packet->header.status_block.error);
 999	if ((error != TW_ERROR_LOGICAL_UNIT_NOT_SUPPORTED) && (error != TW_ERROR_UNIT_OFFLINE)) {
1000		if (print_host)
1001			printk(KERN_WARNING "3w-9xxx: scsi%d: ERROR: (0x%02X:0x%04X): %s:%s.\n",
1002			       tw_dev->host->host_no,
1003			       TW_MESSAGE_SOURCE_CONTROLLER_ERROR,
1004			       full_command_packet->header.status_block.error,
1005			       error_str[0] == '\0' ?
1006			       twa_string_lookup(twa_error_table,
1007						 full_command_packet->header.status_block.error) : error_str,
1008			       full_command_packet->header.err_specific_desc);
1009		else
1010			printk(KERN_WARNING "3w-9xxx: ERROR: (0x%02X:0x%04X): %s:%s.\n",
1011			       TW_MESSAGE_SOURCE_CONTROLLER_ERROR,
1012			       full_command_packet->header.status_block.error,
1013			       error_str[0] == '\0' ?
1014			       twa_string_lookup(twa_error_table,
1015						 full_command_packet->header.status_block.error) : error_str,
1016			       full_command_packet->header.err_specific_desc);
1017	}
1018
1019	if (copy_sense) {
1020		memcpy(tw_dev->srb[request_id]->sense_buffer, full_command_packet->header.sense_data, TW_SENSE_DATA_LENGTH);
1021		tw_dev->srb[request_id]->result = (full_command_packet->command.newcommand.status << 1);
1022		retval = TW_ISR_DONT_RESULT;
1023		goto out;
1024	}
1025	retval = 0;
1026out:
1027	return retval;
1028} /* End twa_fill_sense() */
1029
1030/* This function will free up device extension resources */
1031static void twa_free_device_extension(TW_Device_Extension *tw_dev)
1032{
1033	if (tw_dev->command_packet_virt[0])
1034		dma_free_coherent(&tw_dev->tw_pci_dev->dev,
1035				sizeof(TW_Command_Full) * TW_Q_LENGTH,
1036				tw_dev->command_packet_virt[0],
1037				tw_dev->command_packet_phys[0]);
1038
1039	if (tw_dev->generic_buffer_virt[0])
1040		dma_free_coherent(&tw_dev->tw_pci_dev->dev,
1041				TW_SECTOR_SIZE * TW_Q_LENGTH,
1042				tw_dev->generic_buffer_virt[0],
1043				tw_dev->generic_buffer_phys[0]);
1044
1045	kfree(tw_dev->event_queue[0]);
1046} /* End twa_free_device_extension() */
1047
1048/* This function will free a request id */
1049static void twa_free_request_id(TW_Device_Extension *tw_dev, int request_id)
1050{
1051	tw_dev->free_queue[tw_dev->free_tail] = request_id;
1052	tw_dev->state[request_id] = TW_S_FINISHED;
1053	tw_dev->free_tail = (tw_dev->free_tail + 1) % TW_Q_LENGTH;
1054} /* End twa_free_request_id() */
1055
1056/* This function will get parameter table entries from the firmware */
1057static void *twa_get_param(TW_Device_Extension *tw_dev, int request_id, int table_id, int parameter_id, int parameter_size_bytes)
1058{
1059	TW_Command_Full *full_command_packet;
1060	TW_Command *command_packet;
1061	TW_Param_Apache *param;
1062	void *retval = NULL;
1063
1064	/* Setup the command packet */
1065	full_command_packet = tw_dev->command_packet_virt[request_id];
1066	memset(full_command_packet, 0, sizeof(TW_Command_Full));
1067	command_packet = &full_command_packet->command.oldcommand;
1068
1069	command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_GET_PARAM);
1070	command_packet->size              = TW_COMMAND_SIZE;
1071	command_packet->request_id        = request_id;
1072	command_packet->byte6_offset.block_count = cpu_to_le16(1);
1073
1074	/* Now setup the param */
1075	param = (TW_Param_Apache *)tw_dev->generic_buffer_virt[request_id];
1076	memset(param, 0, TW_SECTOR_SIZE);
1077	param->table_id = cpu_to_le16(table_id | 0x8000);
1078	param->parameter_id = cpu_to_le16(parameter_id);
1079	param->parameter_size_bytes = cpu_to_le16(parameter_size_bytes);
1080
1081	command_packet->byte8_offset.param.sgl[0].address = TW_CPU_TO_SGL(tw_dev->generic_buffer_phys[request_id]);
1082	command_packet->byte8_offset.param.sgl[0].length = cpu_to_le32(TW_SECTOR_SIZE);
1083
1084	/* Post the command packet to the board */
1085	twa_post_command_packet(tw_dev, request_id, 1);
1086
1087	/* Poll for completion */
1088	if (twa_poll_response(tw_dev, request_id, 30))
1089		TW_PRINTK(tw_dev->host, TW_DRIVER, 0x13, "No valid response during get param")
1090	else
1091		retval = (void *)&(param->data[0]);
1092
1093	tw_dev->posted_request_count--;
1094	tw_dev->state[request_id] = TW_S_INITIAL;
1095
1096	return retval;
1097} /* End twa_get_param() */
1098
1099/* This function will assign an available request id */
1100static void twa_get_request_id(TW_Device_Extension *tw_dev, int *request_id)
1101{
1102	*request_id = tw_dev->free_queue[tw_dev->free_head];
1103	tw_dev->free_head = (tw_dev->free_head + 1) % TW_Q_LENGTH;
1104	tw_dev->state[*request_id] = TW_S_STARTED;
1105} /* End twa_get_request_id() */
1106
1107/* This function will send an initconnection command to controller */
1108static int twa_initconnection(TW_Device_Extension *tw_dev, int message_credits,
1109 			      u32 set_features, unsigned short current_fw_srl, 
1110			      unsigned short current_fw_arch_id, 
1111			      unsigned short current_fw_branch, 
1112			      unsigned short current_fw_build, 
1113			      unsigned short *fw_on_ctlr_srl, 
1114			      unsigned short *fw_on_ctlr_arch_id, 
1115			      unsigned short *fw_on_ctlr_branch, 
1116			      unsigned short *fw_on_ctlr_build, 
1117			      u32 *init_connect_result)
1118{
1119	TW_Command_Full *full_command_packet;
1120	TW_Initconnect *tw_initconnect;
1121	int request_id = 0, retval = 1;
1122
1123	/* Initialize InitConnection command packet */
1124	full_command_packet = tw_dev->command_packet_virt[request_id];
1125	memset(full_command_packet, 0, sizeof(TW_Command_Full));
1126	full_command_packet->header.header_desc.size_header = 128;
1127	
1128	tw_initconnect = (TW_Initconnect *)&full_command_packet->command.oldcommand;
1129	tw_initconnect->opcode__reserved = TW_OPRES_IN(0, TW_OP_INIT_CONNECTION);
1130	tw_initconnect->request_id = request_id;
1131	tw_initconnect->message_credits = cpu_to_le16(message_credits);
1132	tw_initconnect->features = set_features;
1133
1134	/* Turn on 64-bit sgl support if we need to */
1135	tw_initconnect->features |= sizeof(dma_addr_t) > 4 ? 1 : 0;
1136
1137	tw_initconnect->features = cpu_to_le32(tw_initconnect->features);
1138
1139	if (set_features & TW_EXTENDED_INIT_CONNECT) {
1140		tw_initconnect->size = TW_INIT_COMMAND_PACKET_SIZE_EXTENDED;
1141		tw_initconnect->fw_srl = cpu_to_le16(current_fw_srl);
1142		tw_initconnect->fw_arch_id = cpu_to_le16(current_fw_arch_id);
1143		tw_initconnect->fw_branch = cpu_to_le16(current_fw_branch);
1144		tw_initconnect->fw_build = cpu_to_le16(current_fw_build);
1145	} else 
1146		tw_initconnect->size = TW_INIT_COMMAND_PACKET_SIZE;
1147
1148	/* Send command packet to the board */
1149	twa_post_command_packet(tw_dev, request_id, 1);
1150
1151	/* Poll for completion */
1152	if (twa_poll_response(tw_dev, request_id, 30)) {
1153		TW_PRINTK(tw_dev->host, TW_DRIVER, 0x15, "No valid response during init connection");
1154	} else {
1155		if (set_features & TW_EXTENDED_INIT_CONNECT) {
1156			*fw_on_ctlr_srl = le16_to_cpu(tw_initconnect->fw_srl);
1157			*fw_on_ctlr_arch_id = le16_to_cpu(tw_initconnect->fw_arch_id);
1158			*fw_on_ctlr_branch = le16_to_cpu(tw_initconnect->fw_branch);
1159			*fw_on_ctlr_build = le16_to_cpu(tw_initconnect->fw_build);
1160			*init_connect_result = le32_to_cpu(tw_initconnect->result);
1161		}
1162		retval = 0;
1163	}
1164
1165	tw_dev->posted_request_count--;
1166	tw_dev->state[request_id] = TW_S_INITIAL;
1167
1168	return retval;
1169} /* End twa_initconnection() */
1170
1171/* This function will initialize the fields of a device extension */
1172static int twa_initialize_device_extension(TW_Device_Extension *tw_dev)
1173{
1174	int i, retval = 1;
1175
1176	/* Initialize command packet buffers */
1177	if (twa_allocate_memory(tw_dev, sizeof(TW_Command_Full), 0)) {
1178		TW_PRINTK(tw_dev->host, TW_DRIVER, 0x16, "Command packet memory allocation failed");
1179		goto out;
1180	}
1181
1182	/* Initialize generic buffer */
1183	if (twa_allocate_memory(tw_dev, TW_SECTOR_SIZE, 1)) {
1184		TW_PRINTK(tw_dev->host, TW_DRIVER, 0x17, "Generic memory allocation failed");
1185		goto out;
1186	}
1187
1188	/* Allocate event info space */
1189	tw_dev->event_queue[0] = kcalloc(TW_Q_LENGTH, sizeof(TW_Event), GFP_KERNEL);
1190	if (!tw_dev->event_queue[0]) {
1191		TW_PRINTK(tw_dev->host, TW_DRIVER, 0x18, "Event info memory allocation failed");
1192		goto out;
1193	}
1194
1195
1196	for (i = 0; i < TW_Q_LENGTH; i++) {
1197		tw_dev->event_queue[i] = (TW_Event *)((unsigned char *)tw_dev->event_queue[0] + (i * sizeof(TW_Event)));
1198		tw_dev->free_queue[i] = i;
1199		tw_dev->state[i] = TW_S_INITIAL;
1200	}
1201
1202	tw_dev->pending_head = TW_Q_START;
1203	tw_dev->pending_tail = TW_Q_START;
1204	tw_dev->free_head = TW_Q_START;
1205	tw_dev->free_tail = TW_Q_START;
1206	tw_dev->error_sequence_id = 1;
1207	tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE;
1208
1209	mutex_init(&tw_dev->ioctl_lock);
1210	init_waitqueue_head(&tw_dev->ioctl_wqueue);
1211
1212	retval = 0;
1213out:
1214	return retval;
1215} /* End twa_initialize_device_extension() */
1216
1217/* This function is the interrupt service routine */
1218static irqreturn_t twa_interrupt(int irq, void *dev_instance)
1219{
1220	int request_id, error = 0;
1221	u32 status_reg_value;
1222	TW_Response_Queue response_que;
1223	TW_Command_Full *full_command_packet;
1224	TW_Device_Extension *tw_dev = (TW_Device_Extension *)dev_instance;
1225	int handled = 0;
1226
1227	/* Get the per adapter lock */
1228	spin_lock(tw_dev->host->host_lock);
1229
1230	/* Read the registers */
1231	status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
1232
1233	/* Check if this is our interrupt, otherwise bail */
1234	if (!(status_reg_value & TW_STATUS_VALID_INTERRUPT))
1235		goto twa_interrupt_bail;
1236
1237	handled = 1;
1238
1239	/* If we are resetting, bail */
1240	if (test_bit(TW_IN_RESET, &tw_dev->flags))
1241		goto twa_interrupt_bail;
1242
1243	/* Check controller for errors */
1244	if (twa_check_bits(status_reg_value)) {
1245		if (twa_decode_bits(tw_dev, status_reg_value)) {
1246			TW_CLEAR_ALL_INTERRUPTS(tw_dev);
1247			goto twa_interrupt_bail;
1248		}
1249	}
1250
1251	/* Handle host interrupt */
1252	if (status_reg_value & TW_STATUS_HOST_INTERRUPT)
1253		TW_CLEAR_HOST_INTERRUPT(tw_dev);
1254
1255	/* Handle attention interrupt */
1256	if (status_reg_value & TW_STATUS_ATTENTION_INTERRUPT) {
1257		TW_CLEAR_ATTENTION_INTERRUPT(tw_dev);
1258		if (!(test_and_set_bit(TW_IN_ATTENTION_LOOP, &tw_dev->flags))) {
1259			twa_get_request_id(tw_dev, &request_id);
1260
1261			error = twa_aen_read_queue(tw_dev, request_id);
1262			if (error) {
1263				tw_dev->state[request_id] = TW_S_COMPLETED;
1264				twa_free_request_id(tw_dev, request_id);
1265				clear_bit(TW_IN_ATTENTION_LOOP, &tw_dev->flags);
1266			}
1267		}
1268	}
1269
1270	/* Handle command interrupt */
1271	if (status_reg_value & TW_STATUS_COMMAND_INTERRUPT) {
1272		TW_MASK_COMMAND_INTERRUPT(tw_dev);
1273		/* Drain as many pending commands as we can */
1274		while (tw_dev->pending_request_count > 0) {
1275			request_id = tw_dev->pending_queue[tw_dev->pending_head];
1276			if (tw_dev->state[request_id] != TW_S_PENDING) {
1277				TW_PRINTK(tw_dev->host, TW_DRIVER, 0x19, "Found request id that wasn't pending");
1278				TW_CLEAR_ALL_INTERRUPTS(tw_dev);
1279				goto twa_interrupt_bail;
1280			}
1281			if (twa_post_command_packet(tw_dev, request_id, 1)==0) {
1282				tw_dev->pending_head = (tw_dev->pending_head + 1) % TW_Q_LENGTH;
1283				tw_dev->pending_request_count--;
1284			} else {
1285				/* If we get here, we will continue re-posting on the next command interrupt */
1286				break;
1287			}
1288		}
1289	}
1290
1291	/* Handle response interrupt */
1292	if (status_reg_value & TW_STATUS_RESPONSE_INTERRUPT) {
1293
1294		/* Drain the response queue from the board */
1295		while ((status_reg_value & TW_STATUS_RESPONSE_QUEUE_EMPTY) == 0) {
1296			/* Complete the response */
1297			response_que.value = readl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev));
1298			request_id = TW_RESID_OUT(response_que.response_id);
1299			full_command_packet = tw_dev->command_packet_virt[request_id];
1300			error = 0;
1301			/* Check for command packet errors */
1302			if (full_command_packet->command.newcommand.status != 0) {
1303				if (tw_dev->srb[request_id] != NULL) {
1304					error = twa_fill_sense(tw_dev, request_id, 1, 1);
1305				} else {
1306					/* Skip ioctl error prints */
1307					if (request_id != tw_dev->chrdev_request_id) {
1308						error = twa_fill_sense(tw_dev, request_id, 0, 1);
1309					}
1310				}
1311			}
1312
1313			/* Check for correct state */
1314			if (tw_dev->state[request_id] != TW_S_POSTED) {
1315				if (tw_dev->srb[request_id] != NULL) {
1316					TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1a, "Received a request id that wasn't posted");
1317					TW_CLEAR_ALL_INTERRUPTS(tw_dev);
1318					goto twa_interrupt_bail;
1319				}
1320			}
1321
1322			/* Check for internal command completion */
1323			if (tw_dev->srb[request_id] == NULL) {
1324				if (request_id != tw_dev->chrdev_request_id) {
1325					if (twa_aen_complete(tw_dev, request_id))
1326						TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1b, "Error completing AEN during attention interrupt");
1327				} else {
1328					tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE;
1329					wake_up(&tw_dev->ioctl_wqueue);
1330				}
1331			} else {
1332				struct scsi_cmnd *cmd;
1333
1334				cmd = tw_dev->srb[request_id];
1335
1336				twa_scsiop_execute_scsi_complete(tw_dev, request_id);
1337				/* If no error command was a success */
1338				if (error == 0) {
1339					cmd->result = (DID_OK << 16);
1340				}
1341
1342				/* If error, command failed */
1343				if (error == 1) {
1344					/* Ask for a host reset */
1345					cmd->result = (DID_OK << 16) | (CHECK_CONDITION << 1);
1346				}
1347
1348				/* Report residual bytes for single sgl */
1349				if ((scsi_sg_count(cmd) <= 1) && (full_command_packet->command.newcommand.status == 0)) {
1350					if (full_command_packet->command.newcommand.sg_list[0].length < scsi_bufflen(tw_dev->srb[request_id]))
1351						scsi_set_resid(cmd, scsi_bufflen(cmd) - full_command_packet->command.newcommand.sg_list[0].length);
1352				}
1353
1354				/* Now complete the io */
1355				if (twa_command_mapped(cmd))
1356					scsi_dma_unmap(cmd);
1357				cmd->scsi_done(cmd);
1358				tw_dev->state[request_id] = TW_S_COMPLETED;
1359				twa_free_request_id(tw_dev, request_id);
1360				tw_dev->posted_request_count--;
1361			}
1362
1363			/* Check for valid status after each drain */
1364			status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
1365			if (twa_check_bits(status_reg_value)) {
1366				if (twa_decode_bits(tw_dev, status_reg_value)) {
1367					TW_CLEAR_ALL_INTERRUPTS(tw_dev);
1368					goto twa_interrupt_bail;
1369				}
1370			}
1371		}
1372	}
1373
1374twa_interrupt_bail:
1375	spin_unlock(tw_dev->host->host_lock);
1376	return IRQ_RETVAL(handled);
1377} /* End twa_interrupt() */
1378
1379/* This function will load the request id and various sgls for ioctls */
1380static void twa_load_sgl(TW_Device_Extension *tw_dev, TW_Command_Full *full_command_packet, int request_id, dma_addr_t dma_handle, int length)
1381{
1382	TW_Command *oldcommand;
1383	TW_Command_Apache *newcommand;
1384	TW_SG_Entry *sgl;
1385	unsigned int pae = 0;
1386
1387	if ((sizeof(long) < 8) && (sizeof(dma_addr_t) > 4))
1388		pae = 1;
1389
1390	if (TW_OP_OUT(full_command_packet->command.newcommand.opcode__reserved) == TW_OP_EXECUTE_SCSI) {
1391		newcommand = &full_command_packet->command.newcommand;
1392		newcommand->request_id__lunl =
1393			cpu_to_le16(TW_REQ_LUN_IN(TW_LUN_OUT(newcommand->request_id__lunl), request_id));
1394		if (length) {
1395			newcommand->sg_list[0].address = TW_CPU_TO_SGL(dma_handle + sizeof(TW_Ioctl_Buf_Apache) - 1);
1396			newcommand->sg_list[0].length = cpu_to_le32(length);
1397		}
1398		newcommand->sgl_entries__lunh =
1399			cpu_to_le16(TW_REQ_LUN_IN(TW_LUN_OUT(newcommand->sgl_entries__lunh), length ? 1 : 0));
1400	} else {
1401		oldcommand = &full_command_packet->command.oldcommand;
1402		oldcommand->request_id = request_id;
1403
1404		if (TW_SGL_OUT(oldcommand->opcode__sgloffset)) {
1405			/* Load the sg list */
1406			if (tw_dev->tw_pci_dev->device == PCI_DEVICE_ID_3WARE_9690SA)
1407				sgl = (TW_SG_Entry *)((u32 *)oldcommand+oldcommand->size - (sizeof(TW_SG_Entry)/4) + pae);
1408			else
1409				sgl = (TW_SG_Entry *)((u32 *)oldcommand+TW_SGL_OUT(oldcommand->opcode__sgloffset));
1410			sgl->address = TW_CPU_TO_SGL(dma_handle + sizeof(TW_Ioctl_Buf_Apache) - 1);
1411			sgl->length = cpu_to_le32(length);
1412
1413			oldcommand->size += pae;
1414		}
1415	}
1416} /* End twa_load_sg…

Large files files are truncated, but you can click here to view the full file