path: root/openvz-sources/022.076/5103_linux-2.6.8.1-aacraid-1.1.5.patch

--- linux-2.6.8.1-t043-libata-update/drivers/scsi/aacraid/aachba.c	2005-09-26 13:33:12.000000000 +0400
+++ aacraid-drv/drivers/scsi/aacraid/aachba.c	2005-04-27 15:51:56.000000000 +0400
@@ -32,16 +32,47 @@
 #include <linux/slab.h>
 #include <linux/completion.h>
 #include <linux/blkdev.h>
+#include <linux/version.h> /* For the following test */
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
+#include <linux/dma-mapping.h>
+#endif
 #include <asm/semaphore.h>
 #include <asm/uaccess.h>
 
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
+#include <linux/module.h>
+#define MAJOR_NR SCSI_DISK0_MAJOR	/* For DEVICE_NR() */
+#include <linux/blk.h>	/* for DEVICE_NR & io_request_lock definition */
+#include "scsi.h"
+#include "hosts.h"
+#include "sd.h"
+#else
+#include <linux/moduleparam.h>
 #include <scsi/scsi.h>
 #include <scsi/scsi_cmnd.h>
 #include <scsi/scsi_device.h>
 #include <scsi/scsi_host.h>
+#include <scsi/scsi_eh.h>
+#include <scsi/scsi_tcq.h>
+#endif
 
 #include "aacraid.h"
 
+/**
+ * 	locking primitives
+ *
+ */
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
+#define aac_spin_lock_irqsave(host_lock, cpu_flags)		spin_lock_irqsave(host_lock, cpu_flags)
+#define aac_spin_lock_irq(host_lock)				spin_lock_irq(host_lock)
+#define aac_spin_unlock_irqrestore(host_lock, cpu_flags)	spin_unlock_irqrestore(host_lock, cpu_flags)
+#define aac_spin_unlock_irq(host_lock)				spin_unlock_irq(host_lock)
+#else
+#define aac_spin_lock_irqsave(host_lock, cpu_flags)		spin_lock_irqsave(&io_request_lock, cpu_flags)
+#define aac_spin_lock_irq(host_lock)				spin_lock_irq(&io_request_lock)
+#define aac_spin_unlock_irqrestore(host_lock, cpu_flags)	spin_unlock_irqrestore(&io_request_lock, cpu_flags)
+#define aac_spin_unlock_irq(host_lock)				spin_unlock_irq(&io_request_lock)
+#endif
 /* values for inqd_pdt: Peripheral device type in plain English */
 #define	INQD_PDT_DA	0x00	/* Direct-access (DISK) device */
 #define	INQD_PDT_PROC	0x03	/* Processor device */
@@ -53,10 +84,6 @@
 #define	INQD_PDT_DMASK	0x1F	/* Peripheral Device Type Mask */
 #define	INQD_PDT_QMASK	0xE0	/* Peripheral Device Qualifer Mask */
 
-#define MAX_FIB_DATA (sizeof(struct hw_fib) - sizeof(FIB_HEADER))
-
-#define MAX_DRIVER_SG_SEGMENT_COUNT 17
-
 /*
  *	Sense codes
  */
@@ -114,6 +141,19 @@
 #define BYTE2(x) (unsigned char)((x) >> 16)
 #define BYTE3(x) (unsigned char)((x) >> 24)
 
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
+/* compatibility */
+#ifndef SAM_STAT_CHECK_CONDITION
+# define SAM_STAT_CHECK_CONDITION	(CHECK_CONDITION << 1)
+#endif
+#ifndef SAM_STAT_GOOD
+# define SAM_STAT_GOOD			(GOOD << 1)
+#endif
+#ifndef SAM_STAT_TASK_SET_FULL
+# define SAM_STAT_TASK_SET_FULL		(QUEUE_FULL << 1)
+#endif
+
+#endif
 /*------------------------------------------------------------------------------
  *              S T R U C T S / T Y P E D E F S
  *----------------------------------------------------------------------------*/
@@ -131,54 +171,217 @@ struct inquiry_data {
 	u8 inqd_prl[4];	/* Product Revision Level */
 };
 
-struct sense_data {
-	u8 error_code;		/* 70h (current errors), 71h(deferred errors) */
-	u8 valid:1;		/* A valid bit of one indicates that the information  */
-				/* field contains valid information as defined in the
-				 * SCSI-2 Standard.
-				 */
-	u8 segment_number;	/* Only used for COPY, COMPARE, or COPY AND VERIFY Commands */
-	u8 sense_key:4;		/* Sense Key */
-	u8 reserved:1;
-	u8 ILI:1;		/* Incorrect Length Indicator */
-	u8 EOM:1;		/* End Of Medium - reserved for random access devices */
-	u8 filemark:1;		/* Filemark - reserved for random access devices */
-
-	u8 information[4];	/* for direct-access devices, contains the unsigned 
-				 * logical block address or residue associated with 
-				 * the sense key 
-				 */
-	u8 add_sense_len;	/* number of additional sense bytes to follow this field */
-	u8 cmnd_info[4];	/* not used */
-	u8 ASC;			/* Additional Sense Code */
-	u8 ASCQ;		/* Additional Sense Code Qualifier */
-	u8 FRUC;		/* Field Replaceable Unit Code - not used */
-	u8 bit_ptr:3;		/* indicates which byte of the CDB or parameter data
-				 * was in error
-				 */
-	u8 BPV:1;		/* bit pointer valid (BPV): 1- indicates that 
-				 * the bit_ptr field has valid value
-				 */
-	u8 reserved2:2;
-	u8 CD:1;		/* command data bit: 1- illegal parameter in CDB.
-				 * 0- illegal parameter in data.
-				 */
-	u8 SKSV:1;
-	u8 field_ptr[2];	/* byte of the CDB or parameter data in error */
-};
-
 /*
  *              M O D U L E   G L O B A L S
  */
  
-static struct sense_data sense_data[MAXIMUM_NUM_CONTAINERS];
 static unsigned long aac_build_sg(struct scsi_cmnd* scsicmd, struct sgmap* sgmap);
 static unsigned long aac_build_sg64(struct scsi_cmnd* scsicmd, struct sgmap64* psg);
+static unsigned long aac_build_sgraw(struct scsi_cmnd* scsicmd, struct sgmapraw* psg);
 static int aac_send_srb_fib(struct scsi_cmnd* scsicmd);
 #ifdef AAC_DETAILED_STATUS_INFO
 static char *aac_get_status_string(u32 status);
 #endif
 
+/*
+ *	Non dasd selection is handled entirely in aachba now
+ */	
+ 
+static int nondasd = -1;
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
+module_param(nondasd, int, S_IRUGO|S_IWUSR);
+#else
+MODULE_PARM(nondasd, "i");
+#endif
+MODULE_PARM_DESC(nondasd, "Control scanning of hba for nondasd devices. 0=off, 1=on");
+
+static int dacmode = -1;
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
+module_param(dacmode, int, S_IRUGO|S_IWUSR);
+#else
+MODULE_PARM(dacmode, "i");
+#endif
+MODULE_PARM_DESC(dacmode, "Control whether dma addressing is using 64 bit DAC. 0=off, 1=on");
+
+#if (defined(__arm__) || defined(CONFIG_EXTERNAL))
+static int commit = 1;
+#else
+static int commit = -1;
+#endif
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
+module_param(commit, int, S_IRUGO|S_IWUSR);
+#else
+MODULE_PARM(commit, "i");
+#endif
+MODULE_PARM_DESC(commit, "Control whether a COMMIT_CONFIG is issued to the adapter for foreign arrays.\nThis is typically needed in systems that do not have a BIOS. 0=off, 1=on");
+
+#if (defined(__arm__) || defined(CONFIG_EXTERNAL) || (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)) || defined(__VMKERNEL_MODULE__))
+static int coalescethreshold = 0;
+#else
+static int coalescethreshold = 16; /* 8KB coalesce knee */
+#endif
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
+module_param(coalescethreshold, int, S_IRUGO|S_IWUSR);
+#else
+MODULE_PARM(coalescethreshold, "i");
+#endif
+MODULE_PARM_DESC(coalescethreshold, "Control the maximum block size of sequential requests that are fed back to the\nscsi_merge layer for coalescing. 0=off, 16 block (8KB) default.");
+
+int numacb = -1;
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
+module_param(numacb, int, S_IRUGO|S_IWUSR);
+#else
+MODULE_PARM(numacb, "i");
+#endif
+MODULE_PARM_DESC(numacb, "Request a limit to the number of adapter control blocks (FIB) allocated. Valid\nvalues are 512 and down. Default is to use suggestion from Firmware.");
+
+int acbsize = -1;
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
+module_param(acbsize, int, S_IRUGO|S_IWUSR);
+#else
+MODULE_PARM(acbsize, "i");
+#endif
+MODULE_PARM_DESC(acbsize, "Request a specific adapter control block (FIB) size. Valid values are 512,\n2048, 4096 and 8192. Default is to use suggestion from Firmware.");
+#if (defined(AAC_EXTENDED_TIMEOUT))
+
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
+int extendedtimeout = -1;
+module_param(extendedtimeout, int, S_IRUGO|S_IWUSR);
+#else
+static int extendedtimeout = -1;
+MODULE_PARM(extendedtimeout, "i");
+#endif
+MODULE_PARM_DESC(extendedtimeout, "Request a specific timeout to override I/O requests issed to the adapter.");
+#endif
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
+static char aacraid[256];
+module_param_string(aacraid, aacraid, sizeof(aacraid), 0);
+#else
+static char * aacraid = NULL;
+MODULE_PARM(aacraid, "s");
+#endif
+MODULE_PARM_DESC(aacraid, "set the various published parameters of the aacraid driver with a syntax of aacraid=parm:value[,parm:value]...");
+
+static int aacraid_setup(char *str)
+{
+	int i;
+	char *key;
+	char *value;
+	struct {
+		char * option_name;
+		int * option_flag;
+		int option_value;
+	} options[] = {
+		{ "nondasd", &nondasd, 1 },
+		{ "dacmode", &dacmode, 1 },
+		{ "commit", &commit, 1 },
+		{ "coalescethreshold", &coalescethreshold, 16 },
+		{ "acbsize", &acbsize, 8192 },
+#if (defined(AAC_EXTENDED_TIMEOUT))
+		{ "extendedtimeout", &extendedtimeout, AAC_EXTENDED_TIMEOUT },
+#endif
+	};
+
+#if 0
+printk (KERN_INFO "aacraid_setup(\"%s\")\n", (str) ? str : "<null>");
+#endif
+	if (str) while ((key = strsep(&str, ",."))) {
+		if (!*key)
+			continue;
+		value = strchr(key, ':');
+		if (value)
+			*value++ = '\0';
+		for (i = 0; i < (sizeof (options) / sizeof (options[0])); i++) {
+			if (strnicmp (key, options[i].option_name,
+			     strlen(options[i].option_name)) == 0) {
+				*options[i].option_flag
+				  = (value)
+				    ? simple_strtoul(value, NULL, 0)
+				    : options[i].option_value;
+				break;
+			}
+		}
+	}
+
+	return (1);
+}
+
+__setup("aacraid=", aacraid_setup);
+
+/**
+ *	aac_get_config_status	-	check the adapter configuration
+ *	@common: adapter to query
+ *
+ *	Query config status, and commit the configuration if needed.
+ */
+int aac_get_config_status(struct aac_dev *dev)
+{
+	int status = 0;
+	struct fib * fibptr;
+
+	if (!(fibptr = fib_alloc(dev)))
+		return -ENOMEM;
+
+	fib_init(fibptr);
+	{
+		struct aac_get_config_status *dinfo;
+		dinfo = (struct aac_get_config_status *) fib_data(fibptr);
+
+		dinfo->command = cpu_to_le32(VM_ContainerConfig);
+		dinfo->type = cpu_to_le32(CT_GET_CONFIG_STATUS);
+		dinfo->count = cpu_to_le32(sizeof(((struct aac_get_config_status_resp *)NULL)->data));
+	}
+
+	status = fib_send(ContainerCommand,
+			    fibptr,
+			    sizeof (struct aac_get_config_status),
+			    FsaNormal,
+			    1, 1,
+			    NULL, NULL);
+	if (status < 0 ) {
+		printk(KERN_WARNING "aac_get_config_status: SendFIB failed.\n");
+	} else {
+		struct aac_get_config_status_resp *reply
+		  = (struct aac_get_config_status_resp *) fib_data(fibptr);
+		dprintk((KERN_WARNING
+		  "aac_get_config_status: response=%d status=%d action=%d\n",
+		  le32_to_cpu(reply->response),
+		  le32_to_cpu(reply->status),
+		  le32_to_cpu(reply->data.action)));
+		if ((le32_to_cpu(reply->response) != ST_OK) ||
+		     (le32_to_cpu(reply->status) != CT_OK) ||
+		     (le32_to_cpu(reply->data.action) > CFACT_PAUSE)) {
+			printk(KERN_WARNING "aac_get_config_status: Will not issue the Commit Configuration\n");
+			status = -EINVAL;
+		}
+	}
+	fib_complete(fibptr);
+	/* Send a CT_COMMIT_CONFIG to enable discovery of devices */
+	if (status >= 0) {
+		if (commit == 1) {
+			struct aac_commit_config * dinfo;
+			fib_init(fibptr);
+			dinfo = (struct aac_commit_config *) fib_data(fibptr);
+	
+			dinfo->command = cpu_to_le32(VM_ContainerConfig);
+			dinfo->type = cpu_to_le32(CT_COMMIT_CONFIG);
+	
+			status = fib_send(ContainerCommand,
+				    fibptr,
+				    sizeof (struct aac_commit_config),
+				    FsaNormal,
+				    1, 1,
+				    NULL, NULL);
+			fib_complete(fibptr);
+		} else if (commit == 0) {
+			printk(KERN_WARNING
+			  "aac_get_config_status: Foreign device configurations are being ignored\n");
+		}
+	}
+	fib_free(fibptr);
+	return status;
+}
+
 /**
  *	aac_get_containers	-	list containers
  *	@common: adapter to probe
@@ -187,21 +390,60 @@ static char *aac_get_status_string(u32 s
  */
 int aac_get_containers(struct aac_dev *dev)
 {
-	struct fsa_scsi_hba *fsa_dev_ptr;
+	struct fsa_dev_info *fsa_dev_ptr;
 	u32 index; 
 	int status = 0;
-	struct aac_query_mount *dinfo;
-	struct aac_mount *dresp;
 	struct fib * fibptr;
 	unsigned instance;
 
-	fsa_dev_ptr = &(dev->fsa_dev);
 	instance = dev->scsi_host_ptr->unique_id;
 
 	if (!(fibptr = fib_alloc(dev)))
 		return -ENOMEM;
 
-	for (index = 0; index < MAXIMUM_NUM_CONTAINERS; index++) {
+	{
+		struct aac_get_container_count *dinfo;
+		struct aac_get_container_count_resp *dresp;
+		int maximum_num_containers = MAXIMUM_NUM_CONTAINERS;
+
+		fib_init(fibptr);
+		dinfo = (struct aac_get_container_count *) fib_data(fibptr);
+	
+		dinfo->command = cpu_to_le32(VM_ContainerConfig);
+		dinfo->type = cpu_to_le32(CT_GET_CONTAINER_COUNT);
+	
+		status = fib_send(ContainerCommand,
+			    fibptr,
+			    sizeof (struct aac_get_container_count),
+			    FsaNormal,
+			    1, 1,
+			    NULL, NULL);
+		if (status >= 0) {
+			dresp = (struct aac_get_container_count_resp *) fib_data(fibptr);
+			maximum_num_containers = le32_to_cpu(dresp->ContainerSwitchEntries);
+			fib_complete(fibptr);
+		}
+
+		if (maximum_num_containers < MAXIMUM_NUM_CONTAINERS)
+			maximum_num_containers = MAXIMUM_NUM_CONTAINERS;
+		fsa_dev_ptr = (struct fsa_dev_info *) kmalloc(
+		  sizeof(*fsa_dev_ptr) * maximum_num_containers, GFP_KERNEL);
+		if (!fsa_dev_ptr) {
+			fib_free(fibptr);
+			return -ENOMEM;
+		}
+		memset(fsa_dev_ptr, 0, sizeof(*fsa_dev_ptr) * maximum_num_containers);
+
+		dev->fsa_dev = fsa_dev_ptr;
+		dev->maximum_num_containers = maximum_num_containers;
+	}
+
+	for (index = 0; index < dev->maximum_num_containers; index++) {
+		struct aac_query_mount *dinfo;
+		struct aac_mount *dresp;
+
+		fsa_dev_ptr[index].devname[0] = '\0';
+
 		fib_init(fibptr);
 		dinfo = (struct aac_query_mount *) fib_data(fibptr);
 
@@ -221,14 +463,69 @@ int aac_get_containers(struct aac_dev *d
 		}
 		dresp = (struct aac_mount *)fib_data(fibptr);
 
+#if (defined(AAC_DEBUG_INSTRUMENT_2TB))
+		printk(KERN_INFO "dresp->mnt[0].vol=%d "
+		  "dresp->mnt[0].capacity=%u"
+		  "={%02x %02x %02x %02x}\n",
+		  le32_to_cpu(dresp->mnt[0].vol),
+		  le32_to_cpu(dresp->mnt[0].capacity),
+		  ((u8 *)&dresp->mnt[0].capacity)[0],
+		  ((u8 *)&dresp->mnt[0].capacity)[1],
+		  ((u8 *)&dresp->mnt[0].capacity)[2],
+		  ((u8 *)&dresp->mnt[0].capacity)[3]);
+#endif
+		if ((le32_to_cpu(dresp->status) == ST_OK) &&
+		    (le32_to_cpu(dresp->mnt[0].vol) == CT_NONE)) {
+			dinfo->command = cpu_to_le32(VM_NameServe64);
+			dinfo->count = cpu_to_le32(index);
+			dinfo->type = cpu_to_le32(FT_FILESYS);
+
+			if (fib_send(ContainerCommand,
+				    fibptr,
+				    sizeof(struct aac_query_mount),
+				    FsaNormal,
+				    1, 1,
+				    NULL, NULL) < 0)
+				continue;
+#if (defined(AAC_DEBUG_INSTRUMENT_2TB))
+			printk(KERN_INFO "dresp->mnt[0].capacity64=%llu"
+			  "={%02x %02x %02x %02x %02x %02x %02x %02x}\n",
+			  ((u64)le32_to_cpu(dresp->mnt[0].capacity)) +
+			    (((u64)le32_to_cpu(dresp->mnt[0].capacityhigh)) << 32),
+			  ((u8 *)&dresp->mnt[0].capacity)[0],
+			  ((u8 *)&dresp->mnt[0].capacity)[1],
+			  ((u8 *)&dresp->mnt[0].capacity)[2],
+			  ((u8 *)&dresp->mnt[0].capacity)[3],
+			  ((u8 *)&dresp->mnt[0].capacityhigh)[0],
+			  ((u8 *)&dresp->mnt[0].capacityhigh)[1],
+			  ((u8 *)&dresp->mnt[0].capacityhigh)[2],
+			  ((u8 *)&dresp->mnt[0].capacityhigh)[3]);
+#endif
+		} else
+			dresp->mnt[0].capacityhigh = 0;
+
+		dprintk ((KERN_DEBUG
+		  "VM_NameServe cid=%d status=%d vol=%d state=%d cap=%llu\n",
+		  (int)index, (int)le32_to_cpu(dresp->status),
+		  (int)le32_to_cpu(dresp->mnt[0].vol),
+		  (int)le32_to_cpu(dresp->mnt[0].state),
+		  ((u64)le32_to_cpu(dresp->mnt[0].capacity)) +
+		    (((u64)le32_to_cpu(dresp->mnt[0].capacityhigh)) << 32)));
 		if ((le32_to_cpu(dresp->status) == ST_OK) &&
 		    (le32_to_cpu(dresp->mnt[0].vol) != CT_NONE) &&
 		    (le32_to_cpu(dresp->mnt[0].state) != FSCS_HIDDEN)) {
-			fsa_dev_ptr->valid[index] = 1;
-			fsa_dev_ptr->type[index] = le32_to_cpu(dresp->mnt[0].vol);
-			fsa_dev_ptr->size[index] = le32_to_cpu(dresp->mnt[0].capacity);
+			fsa_dev_ptr[index].valid = 1;
+			fsa_dev_ptr[index].type = le32_to_cpu(dresp->mnt[0].vol);
+			fsa_dev_ptr[index].size
+			  = ((u64)le32_to_cpu(dresp->mnt[0].capacity)) +
+			    (((u64)le32_to_cpu(dresp->mnt[0].capacityhigh)) << 32);
 			if (le32_to_cpu(dresp->mnt[0].state) & FSCS_READONLY)
-				    fsa_dev_ptr->ro[index] = 1;
+				    fsa_dev_ptr[index].ro = 1;
+#if (defined(AAC_DEBUG_INSTRUMENT_2TB))
+			printk(KERN_INFO "Valid type=%u size=%llu ro=%d\n",
+			  fsa_dev_ptr[index].type, fsa_dev_ptr[index].size,
+			  fsa_dev_ptr[index].ro);
+#endif
 		}
 		fib_complete(fibptr);
 		/*
@@ -242,25 +539,190 @@ int aac_get_containers(struct aac_dev *d
 	return status;
 }
 
+static void aac_io_done(struct scsi_cmnd * scsicmd)
+{
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,4,0)) /* suppress unused variable warning */
+	unsigned long cpu_flags;
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)) /* suppress unused variable warning */
+	struct Scsi_Host *host = scsicmd->device->host;
+#endif
+#endif
+
+	if (scsicmd->scsi_done == (void (*)(struct scsi_cmnd*))NULL) {
+		printk(KERN_WARNING "aac_io_done: scsi_done NULL\n");
+		return;
+	}
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,4,0))
+	aac_spin_lock_irqsave(host->host_lock, cpu_flags);
+#endif
+	scsicmd->scsi_done(scsicmd);
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,4,0))
+	aac_spin_unlock_irqrestore(host->host_lock, cpu_flags);
+#endif
+#if (defined(AAC_DEBUG_INSTRUMENT_TIMING))
+	{
+		u64 lba;
+		u32 count = 0;
+		struct timeval now;
+		do_gettimeofday(&now);
+		if ((scsicmd->cmnd[0] == WRITE_6)	/* 6 byte command */
+		 || (scsicmd->cmnd[0] == READ_6)) {
+			lba = ((scsicmd->cmnd[1] & 0x1F) << 16)
+			    | (scsicmd->cmnd[2] << 8) | scsicmd->cmnd[3];
+			count = scsicmd->cmnd[4];
+			if (count == 0)
+				count = 256;
+#if (defined(WRITE_16))
+		} else if ((scsicmd->cmnd[0] == WRITE_16) /* 16 byte command */
+		 || (scsicmd->cmnd[0] == READ_16)) {
+			lba = ((u64)scsicmd->cmnd[2] << 56)
+			    | ((u64)scsicmd->cmnd[3] << 48)
+			    | ((u64)scsicmd->cmnd[4] << 40)
+			    | ((u64)scsicmd->cmnd[9] << 32)
+			    | ((u64)scsicmd->cmnd[6] << 24)
+			    | (scsicmd->cmnd[7] << 16)
+			    | (scsicmd->cmnd[8] << 8) | scsicmd->cmnd[9];
+			count = (scsicmd->cmnd[10] << 24)
+			      | (scsicmd->cmnd[11] << 16)
+			      | (scsicmd->cmnd[12] << 8) | scsicmd->cmnd[13];
+#endif
+		} else if ((scsicmd->cmnd[0] == WRITE_12) /* 12 byte command */
+		 || (scsicmd->cmnd[0] == READ_12)) {
+			lba = ((u64)scsicmd->cmnd[2] << 24)
+			    | (scsicmd->cmnd[3] << 16)
+			    | (scsicmd->cmnd[4] << 8) | scsicmd->cmnd[5];
+			count = (scsicmd->cmnd[6] << 24)
+			      | (scsicmd->cmnd[7] << 16)
+			      | (scsicmd->cmnd[8] << 8) | scsicmd->cmnd[9];
+		} else if ((scsicmd->cmnd[0] == WRITE_10) /* 10 byte command */
+		 || (scsicmd->cmnd[0] == READ_10)) {
+			lba = ((u64)scsicmd->cmnd[2] << 24)
+			    | (scsicmd->cmnd[3] << 16)
+			    | (scsicmd->cmnd[4] << 8) | scsicmd->cmnd[5];
+			count = (scsicmd->cmnd[7] << 8) | scsicmd->cmnd[8];
+		} else
+			lba = (u64)(long)scsicmd;
+		printk(((count)
+		  ? KERN_DEBUG "%lu.%06lu d%lu %llu[%u]\n"
+		  : KERN_DEBUG "%lu.%06lu d%lu 0x%llx\n"),
+		  now.tv_sec % 100, now.tv_usec,
+		  ((struct aac_dev *)scsicmd->device->host->hostdata)->queues->queue[AdapNormCmdQueue].numpending,
+		  lba, count);
+	}
+#endif
+}
+#if (defined(AAC_DEBUG_INSTRUMENT_TIMING))
+
+static inline void __aac_io_done(struct scsi_cmnd * scsicmd)
+{
+	struct timeval now;
+	scsicmd->scsi_done(scsicmd);
+	do_gettimeofday(&now);
+	printk(KERN_DEBUG "%lu.%06lu d%lu %p\n",
+	  now.tv_sec % 100, now.tv_usec,
+	  ((struct aac_dev *)scsicmd->device->host->hostdata)->queues->queue[AdapNormCmdQueue].numpending,
+	  scsicmd);
+}
+#endif
+
+static void get_container_name_callback(void *context, struct fib * fibptr)
+{
+	struct aac_get_name_resp * get_name_reply;
+	struct scsi_cmnd * scsicmd;
+
+	scsicmd = (struct scsi_cmnd *) context;
+
+	dprintk((KERN_DEBUG "get_container_name_callback[cpu %d]: t = %ld.\n", smp_processor_id(), jiffies));
+	if (fibptr == NULL)
+		BUG();
+
+	get_name_reply = (struct aac_get_name_resp *) fib_data(fibptr);
+	/* Failure is irrelevant, using default value instead */
+	if ((le32_to_cpu(get_name_reply->status) == CT_OK)
+	 && (get_name_reply->data[0] != '\0')) {
+		int    count;
+		char * dp;
+		char * sp = get_name_reply->data;
+		sp[sizeof(((struct aac_get_name_resp *)NULL)->data)-1] = '\0';
+		while (*sp == ' ')
+			++sp;
+		count = sizeof(((struct inquiry_data *)NULL)->inqd_pid);
+		dp = ((struct inquiry_data *)scsicmd->request_buffer)->inqd_pid;
+		if (*sp) do {
+			*dp++ = (*sp) ? *sp++ : ' ';
+		} while (--count > 0);
+	}
+	scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD;
+
+	fib_complete(fibptr);
+	fib_free(fibptr);
+	aac_io_done(scsicmd);
+}
+
+/**
+ *	aac_get_container_name	-	get container name, none blocking.
+ */
+static int aac_get_container_name(struct scsi_cmnd * scsicmd, int cid)
+{
+	int status;
+	struct aac_get_name *dinfo;
+	struct fib * cmd_fibcontext;
+	struct aac_dev * dev;
+
+	dev = (struct aac_dev *)scsicmd->device->host->hostdata;
+
+	if (!(cmd_fibcontext = fib_alloc(dev)))
+		return -ENOMEM;
+
+	fib_init(cmd_fibcontext);
+	dinfo = (struct aac_get_name *) fib_data(cmd_fibcontext);
+
+	dinfo->command = cpu_to_le32(VM_ContainerConfig);
+	dinfo->type = cpu_to_le32(CT_READ_NAME);
+	dinfo->cid = cpu_to_le32(cid);
+	dinfo->count = cpu_to_le32(sizeof(((struct aac_get_name_resp *)NULL)->data));
+
+	status = fib_send(ContainerCommand, 
+		  cmd_fibcontext, 
+		  sizeof (struct aac_get_name),
+		  FsaNormal, 
+		  0, 1, 
+		  (fib_callback) get_container_name_callback, 
+		  (void *) scsicmd);
+	
+	/*
+	 *	Check that the command queued to the controller
+	 */
+	if (status == -EINPROGRESS) 
+		return 0;
+		
+	printk(KERN_WARNING "aac_get_container_name: fib_send failed with status: %d.\n", status);
+	scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_TASK_SET_FULL;
+	aac_io_done(scsicmd);
+	fib_complete(cmd_fibcontext);
+	fib_free(cmd_fibcontext);
+	return 0;
+}
+
 /**
  *	probe_container		-	query a logical volume
  *	@dev: device to query
  *	@cid: container identifier
  *
  *	Queries the controller about the given volume. The volume information
- *	is updated in the struct fsa_scsi_hba structure rather than returned.
+ *	is updated in the struct fsa_dev_info structure rather than returned.
  */
  
-static int probe_container(struct aac_dev *dev, int cid)
+int probe_container(struct aac_dev *dev, int cid)
 {
-	struct fsa_scsi_hba *fsa_dev_ptr;
+	struct fsa_dev_info *fsa_dev_ptr;
 	int status;
 	struct aac_query_mount *dinfo;
 	struct aac_mount *dresp;
 	struct fib * fibptr;
 	unsigned instance;
 
-	fsa_dev_ptr = &(dev->fsa_dev);
+	fsa_dev_ptr = dev->fsa_dev;
 	instance = dev->scsi_host_ptr->unique_id;
 
 	if (!(fibptr = fib_alloc(dev)))
@@ -281,20 +743,38 @@ static int probe_container(struct aac_de
 			    1, 1,
 			    NULL, NULL);
 	if (status < 0) {
-		printk(KERN_WARNING "aacraid: probe_containers query failed.\n");
+		printk(KERN_WARNING "aacraid: probe_container query failed.\n");
 		goto error;
 	}
 
 	dresp = (struct aac_mount *) fib_data(fibptr);
 
 	if ((le32_to_cpu(dresp->status) == ST_OK) &&
+	    (le32_to_cpu(dresp->mnt[0].vol) == CT_NONE)) {
+		dinfo->command = cpu_to_le32(VM_NameServe64);
+		dinfo->count = cpu_to_le32(cid);
+		dinfo->type = cpu_to_le32(FT_FILESYS);
+
+		if (fib_send(ContainerCommand,
+			    fibptr,
+			    sizeof(struct aac_query_mount),
+			    FsaNormal,
+			    1, 1,
+			    NULL, NULL) < 0)
+			goto error;
+	} else
+		dresp->mnt[0].capacityhigh = 0;
+
+	if ((le32_to_cpu(dresp->status) == ST_OK) &&
 	    (le32_to_cpu(dresp->mnt[0].vol) != CT_NONE) &&
 	    (le32_to_cpu(dresp->mnt[0].state) != FSCS_HIDDEN)) {
-		fsa_dev_ptr->valid[cid] = 1;
-		fsa_dev_ptr->type[cid] = le32_to_cpu(dresp->mnt[0].vol);
-		fsa_dev_ptr->size[cid] = le32_to_cpu(dresp->mnt[0].capacity);
+		fsa_dev_ptr[cid].valid = 1;
+		fsa_dev_ptr[cid].type = le32_to_cpu(dresp->mnt[0].vol);
+		fsa_dev_ptr[cid].size
+		  = ((u64)le32_to_cpu(dresp->mnt[0].capacity)) +
+		    (((u64)le32_to_cpu(dresp->mnt[0].capacityhigh)) << 32);
 		if (le32_to_cpu(dresp->mnt[0].state) & FSCS_READONLY)
-			fsa_dev_ptr->ro[cid] = 1;
+			fsa_dev_ptr[cid].ro = 1;
 	}
 
 error:
@@ -343,6 +823,11 @@ static char *container_types[] = {
         "V-MIRRORS",          
         "PSEUDO R4",          
 	"RAID50",
+	"RAID5D",
+	"RAID5D0",
+	"RAID1E",
+	"RAID6",
+	"RAID60",
         "Unknown"
 };
 
@@ -353,35 +838,63 @@ static char *container_types[] = {
  * Arguments: [1] pointer to void [1] int
  *
  * Purpose: Sets SCSI inquiry data strings for vendor, product
- * and revision level. Allows strings to be set in platform dependent
- * files instead of in OS dependent driver source.
+ * and revision level. Allows strings to be set in platform dependant
+ * files instead of in OS dependant driver source.
  */
 
-static void setinqstr(int devtype, void *data, int tindex)
+static void setinqstr(struct aac_dev *dev, void *data, int tindex)
 {
 	struct scsi_inq *str;
-	char *findit;
-	struct aac_driver_ident *mp;
 
-	mp = aac_get_driver_ident(devtype);
-   
 	str = (struct scsi_inq *)(data); /* cast data to scsi inq block */
+	memset(str, ' ', sizeof(*str));
 
-	inqstrcpy (mp->vname, str->vid); 
-	inqstrcpy (mp->model, str->pid); /* last six chars reserved for vol type */
-
-	findit = str->pid;
+	if (dev->supplement_adapter_info.AdapterTypeText[0]) {
+		char * cp = dev->supplement_adapter_info.AdapterTypeText;
+		int c = sizeof(str->vid);
+		while (*cp && *cp != ' ' && --c)
+			++cp;
+		c = *cp;
+		*cp = '\0';
+		inqstrcpy (dev->supplement_adapter_info.AdapterTypeText,
+		  str->vid); 
+		*cp = c;
+		while (*cp && *cp != ' ')
+			++cp;
+		while (*cp == ' ')
+			++cp;
+		/* last six chars reserved for vol type */
+		c = 0;
+		if (strlen(cp) > sizeof(str->pid)) {
+			c = cp[sizeof(str->pid)];
+			cp[sizeof(str->pid)] = '\0';
+		}
+		inqstrcpy (cp, str->pid);
+		if (c)
+			cp[sizeof(str->pid)] = c;
+	} else {
+		struct aac_driver_ident *mp = aac_get_driver_ident(dev->cardtype);
+   
+		inqstrcpy (mp->vname, str->vid); 
+		/* last six chars reserved for vol type */
+		inqstrcpy (mp->model, str->pid);
+	}
 
-	for ( ; *findit != ' '; findit++); /* walk till we find a space then incr by 1 */
-		findit++;
-	
 	if (tindex < (sizeof(container_types)/sizeof(char *))){
-		inqstrcpy (container_types[tindex], findit);
+		char *findit = str->pid;
+
+		for ( ; *findit != ' '; findit++); /* walk till we find a space */
+		/* RAID is superfluous in the context of a RAID device */
+		if (memcmp(findit-4, "RAID", 4) == 0)
+			*(findit -= 4) = ' ';
+		if (((findit - str->pid) + strlen(container_types[tindex]))
+		 < (sizeof(str->pid) + sizeof(str->prl)))
+			inqstrcpy (container_types[tindex], findit + 1);
 	}
 	inqstrcpy ("V1.0", str->prl);
 }
 
-void set_sense(u8 *sense_buf, u8 sense_key, u8 sense_code,
+static void set_sense(u8 *sense_buf, u8 sense_key, u8 sense_code,
 		    u8 a_sense_code, u8 incorrect_length,
 		    u8 bit_pointer, u16 field_pointer,
 		    u32 residue)
@@ -421,69 +934,213 @@ void set_sense(u8 *sense_buf, u8 sense_k
 	}
 }
 
-static void aac_io_done(struct scsi_cmnd * scsicmd)
-{
-	unsigned long cpu_flags;
-	struct Scsi_Host *host = scsicmd->device->host;
-	spin_lock_irqsave(host->host_lock, cpu_flags);
-	scsicmd->scsi_done(scsicmd);
-	spin_unlock_irqrestore(host->host_lock, cpu_flags);
-}
-
-static void __aac_io_done(struct scsi_cmnd * scsicmd)
-{
-	scsicmd->scsi_done(scsicmd);
-}
-
 int aac_get_adapter_info(struct aac_dev* dev)
 {
 	struct fib* fibptr;
-	struct aac_adapter_info* info;
 	int rcode;
 	u32 tmp;
+
 	if (!(fibptr = fib_alloc(dev)))
 		return -ENOMEM;
 
-	fib_init(fibptr);
-	info = (struct aac_adapter_info*) fib_data(fibptr);
+	{
+		struct aac_adapter_info * info;
 
-	memset(info,0,sizeof(struct aac_adapter_info));
+		fib_init(fibptr);
+
+		info = (struct aac_adapter_info *) fib_data(fibptr);
+
+		memset(info,0,sizeof(*info));
 
-	rcode = fib_send(RequestAdapterInfo,
+		rcode = fib_send(RequestAdapterInfo,
 			fibptr, 
-			sizeof(struct aac_adapter_info),
+			sizeof(*info),
 			FsaNormal, 
-			1, 1, 
+			-1, 1, /* First `interrupt' command uses special wait */
 			NULL, 
 			NULL);
 
-	memcpy(&dev->adapter_info, info, sizeof(struct aac_adapter_info));
+		if (rcode < 0) {
+			fib_complete(fibptr);
+			fib_free(fibptr);
+			return rcode;
+		}
+		memcpy(&dev->adapter_info, info, sizeof(*info));
+	}
 
-	tmp = dev->adapter_info.kernelrev;
-	printk(KERN_INFO"%s%d: kernel %d.%d.%d build %d\n", 
-			dev->name, dev->id,
-			tmp>>24,(tmp>>16)&0xff,(tmp>>8)&0xff,
-			dev->adapter_info.kernelbuild);
-	tmp = dev->adapter_info.monitorrev;
-	printk(KERN_INFO"%s%d: monitor %d.%d.%d build %d\n", 
+	if (dev->adapter_info.options & le32_to_cpu(AAC_OPT_SUPPLEMENT_ADAPTER_INFO)) {
+		struct aac_supplement_adapter_info * info;
+
+		fib_init(fibptr);
+
+		info = (struct aac_supplement_adapter_info *) fib_data(fibptr);
+
+		memset(info,0,sizeof(*info));
+
+		rcode = fib_send(RequestSupplementAdapterInfo,
+			fibptr,
+			sizeof(*info),
+			FsaNormal,
+			1, 1,
+			NULL,
+			NULL);
+
+		if (rcode >= 0)
+			memcpy(&dev->supplement_adapter_info, info, sizeof(*info));
+	}
+
+#if (defined(CODE_STREAM_IDENTIFIER))
+	if (dev->supplement_adapter_info.FeatureBits & le32_to_cpu(AAC_FEATURE_FALCON)) {
+		char * info;
+
+		fib_init(fibptr);
+
+		info = (char *) fib_data(fibptr);
+
+		memset(info,0,MAX_CODE_STREAM_IDENTIFIER_LENGTH);
+
+		rcode = fib_send(RequestCompatibilityId,
+			fibptr,
+			MAX_CODE_STREAM_IDENTIFIER_LENGTH,
+			FsaNormal,
+			1, 1,
+			NULL,
+			NULL);
+
+		if (rcode >= 0)
+			memcpy(dev->code_stream_identifier, info,
+			  MAX_CODE_STREAM_IDENTIFIER_LENGTH);
+
+		if (dev->code_stream_identifier[0]
+		 && strncmp(CODE_STREAM_IDENTIFIER,
+		  dev->code_stream_identifier,
+		  MAX_CODE_STREAM_IDENTIFIER_LENGTH)) {
+			extern unsigned long aac_driver_version;
+			printk(KERN_INFO
+			  "%s%d: Warning ! ! ! Compatibility Mismatch\n",
+			  dev->name, dev->id);
+			tmp = le32_to_cpu(dev->adapter_info.kernelrev);
+			printk(KERN_INFO
+			  "%s%d: Firmware=%d.%d-%d[%d],"
+			  " Device Driver=%d.%d-%d"
+#if (defined(AAC_DRIVER_BUILD))
+			  "[%d]"
+#else
+			  " " __DATE__ " " __TIME__
+#endif
+			  "\n",
+			  dev->name, dev->id,
+			  tmp>>24,(tmp>>16)&0xff,tmp&0xff,
+			  le32_to_cpu(dev->adapter_info.kernelbuild),
+			  (int)aac_driver_version >> 24,
+			  (int)(aac_driver_version >> 16) & 0xFF,
+			  (int)aac_driver_version & 0xFF
+#if (defined(AAC_DRIVER_BUILD))
+			  , AAC_DRIVER_BUILD
+#endif
+			);
+			printk(KERN_INFO
+			  "%s%d: These should be a tested set to avoid possible compatibility problems.\n",
+			  dev->name, dev->id);
+		}
+	}
+#endif
+
+	/* GetBusInfo */
+	{
+		struct aac_bus_info * command;
+		struct aac_bus_info_response * info;
+
+		fib_init(fibptr);
+
+		info = (struct aac_bus_info_response *) fib_data(fibptr);
+
+		memset(info,0,sizeof(*info));
+
+		command = (struct aac_bus_info *) info;
+
+		command->Command = cpu_to_le32(VM_Ioctl);
+		command->ObjType = cpu_to_le32(FT_DRIVE);
+		command->MethodId = cpu_to_le32(1);
+		command->CtlCmd = cpu_to_le32(GetBusInfo);
+
+		rcode = fib_send(ContainerCommand,
+				    fibptr,
+				    sizeof (*info),
+				    FsaNormal,
+				    1, 1,
+				    NULL, NULL);
+
+		if ((rcode >= 0 ) && (le32_to_cpu(info->Status) == ST_OK)) {
+			dev->maximum_num_physicals = le32_to_cpu(info->TargetsPerBus);
+			dev->maximum_num_channels = le32_to_cpu(info->BusCount);
+		}
+	}
+
+	tmp = le32_to_cpu(dev->adapter_info.kernelrev);
+	printk(KERN_INFO "%s%d: kernel %d.%d-%d[%d] %.*s\n", 
+			dev->name, 
+			dev->id,
+			tmp>>24,
+			(tmp>>16)&0xff,
+			tmp&0xff,
+			le32_to_cpu(dev->adapter_info.kernelbuild),
+			(int)sizeof(dev->supplement_adapter_info.BuildDate),
+			dev->supplement_adapter_info.BuildDate);
+	tmp = le32_to_cpu(dev->adapter_info.monitorrev);
+	printk(KERN_INFO "%s%d: monitor %d.%d-%d[%d]\n", 
 			dev->name, dev->id,
-			tmp>>24,(tmp>>16)&0xff,(tmp>>8)&0xff,
-			dev->adapter_info.monitorbuild);
-	tmp = dev->adapter_info.biosrev;
-	printk(KERN_INFO"%s%d: bios %d.%d.%d build %d\n", 
+			tmp>>24,(tmp>>16)&0xff,tmp&0xff,
+			le32_to_cpu(dev->adapter_info.monitorbuild));
+	tmp = le32_to_cpu(dev->adapter_info.biosrev);
+	printk(KERN_INFO "%s%d: bios %d.%d-%d[%d]\n", 
 			dev->name, dev->id,
-			tmp>>24,(tmp>>16)&0xff,(tmp>>8)&0xff,
-			dev->adapter_info.biosbuild);
-	printk(KERN_INFO"%s%d: serial %x%x\n",
+			tmp>>24,(tmp>>16)&0xff,tmp&0xff,
+			le32_to_cpu(dev->adapter_info.biosbuild));
+	if (le32_to_cpu(dev->adapter_info.serial[0]) != 0xBAD0)
+		printk(KERN_INFO "%s%d: serial %x\n",
 			dev->name, dev->id,
-			dev->adapter_info.serial[0],
-			dev->adapter_info.serial[1]);
+			le32_to_cpu(dev->adapter_info.serial[0]));
+	aacraid_setup(aacraid);
+#if 0
+#if (defined(AAC_EXTENDED_TIMEOUT))
+	printk(KERN_INFO "nondasd=%d dacmode=%d commit=%d "
+	  "coalescethreshold=%d acbsize=%d extendedtimeout=%d\n",
+	  nondasd, dacmode, commit, coalescethreshold, acbsize,
+	  extendedtimeout);
+#else
+	printk(KERN_INFO "nondasd=%d dacmode=%d commit=%d "
+	  "coalescethreshold=%d acbsize=%d\n",
+	  nondasd, dacmode, commit, coalescethreshold, acbsize);
+#endif
+#endif
 
 	dev->nondasd_support = 0;
+	dev->raid_scsi_mode = 0;
 	if(dev->adapter_info.options & AAC_OPT_NONDASD){
-//		dev->nondasd_support = 1;
-// dmb - temporarily disable nondasd
+		dev->nondasd_support = 1;
 	}
+
+	/*
+	 * If the firmware supports ROMB RAID/SCSI mode and we are currently
+	 * in RAID/SCSI mode, set the flag. For now if in this mode we will
+	 * force nondasd support on. If we decide to allow the non-dasd flag
+	 * additional changes changes will have to be made to support
+	 * RAID/SCSI.  the function aac_scsi_cmd in this module will have to be
+	 * changed to support the new dev->raid_scsi_mode flag instead of
+	 * leaching off of the dev->nondasd_support flag. Also in linit.c the
+	 * function aac_detect will have to be modified where it sets up the
+	 * max number of channels based on the aac->nondasd_support flag only.
+	 */
+	if ((dev->adapter_info.options & AAC_OPT_SCSI_MANAGED) &&
+	    (dev->adapter_info.options & AAC_OPT_RAID_SCSI_MODE)) {
+		dev->nondasd_support = 1;
+		dev->raid_scsi_mode = 1;
+	}
+	if (dev->raid_scsi_mode != 0)
+		printk(KERN_INFO "%s%d: ROMB RAID/SCSI mode enabled\n",
+				dev->name, dev->id);
+		
 	if(nondasd != -1) {  
 		dev->nondasd_support = (nondasd!=0);
 	}
@@ -491,18 +1148,72 @@ int aac_get_adapter_info(struct aac_dev*
 		printk(KERN_INFO "%s%d: Non-DASD support enabled.\n",dev->name, dev->id);
 	}
 
-	dev->pae_support = 0;
-	if( (sizeof(dma_addr_t) > 4) && (dev->adapter_info.options & AAC_OPT_SGMAP_HOST64)){
-		printk(KERN_INFO "%s%d: 64bit support enabled.\n", dev->name, dev->id);
-		dev->pae_support = 1;
+	dev->dac_support = 0;
+	/*
+	 *	Only enable DAC mode if the dma_addr_t is larger than 32
+	 * bit addressing, and we have more than 32 bit addressing worth of
+	 * memory and if the controller supports 64 bit scatter gather elements.
+	 */
+	if( (sizeof(dma_addr_t) > 4) && (num_physpages > (0xFFFFFFFFULL >> PAGE_SHIFT)) && (dev->adapter_info.options & AAC_OPT_SGMAP_HOST64)){
+		dev->dac_support = 1;
 	}
 
-	if(paemode != -1){
-		dev->pae_support = (paemode!=0);
-	}
-	if(dev->pae_support != 0) {
-		printk(KERN_INFO"%s%d: 64 Bit PAE enabled\n", dev->name, dev->id);
-		pci_set_dma_mask(dev->pdev, (dma_addr_t)0xFFFFFFFFFFFFFFFFULL);
+	if(dacmode != -1) {
+		dev->dac_support = (dacmode!=0);
+	}
+	if(dev->dac_support != 0) {
+		if (!pci_set_dma_mask(dev->pdev, DMA_64BIT_MASK) &&
+			!pci_set_consistent_dma_mask(dev->pdev, DMA_64BIT_MASK)) {
+			printk(KERN_INFO"%s%d: 64 Bit DAC enabled\n",
+				dev->name, dev->id);
+		} else if (!pci_set_dma_mask(dev->pdev, DMA_32BIT_MASK) &&
+			!pci_set_consistent_dma_mask(dev->pdev, DMA_32BIT_MASK)) {
+			printk(KERN_INFO"%s%d: DMA mask set failed, 64 Bit DAC disabled\n",
+				dev->name, dev->id);
+			dev->dac_support = 0;
+		} else {
+			printk(KERN_WARNING"%s%d: No suitable DMA available.\n",
+				dev->name, dev->id);
+			rcode = -ENOMEM;
+		}
+	}
+	/* 57 scatter gather elements */
+	if (!(dev->raw_io_interface)) {
+		dev->scsi_host_ptr->sg_tablesize = (dev->max_fib_size
+			- sizeof(struct aac_fibhdr)
+			- sizeof(struct aac_write) + sizeof(struct sgmap))
+				/ sizeof(struct sgmap);
+		if( (sizeof(dma_addr_t) > 4) && (num_physpages >= (0xFFFFFFFFULL >> PAGE_SHIFT)) && (dev->adapter_info.options & AAC_OPT_SGMAP_HOST64) && (dev->dac_support) ){
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,18)) && (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)) && (!defined(__arm__)) && defined(CONFIG_HIGHMEM) && ((LINUX_VERSION_CODE != KERNEL_VERSION(2,4,19)) || defined(CONFIG_HIGHIO))
+			dev->scsi_host_ptr->highmem_io = 1;
+#endif
+			/* 38 scatter gather elements */
+			dev->scsi_host_ptr->sg_tablesize
+				= (dev->max_fib_size
+				- sizeof(struct aac_fibhdr)
+				- sizeof(struct aac_write64)
+				+ sizeof(struct sgmap64))
+					/ sizeof(struct sgmap64);
+		}
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,18)) && (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)) && (!defined(__arm__)) && defined(CONFIG_HIGHMEM) && ((LINUX_VERSION_CODE != KERNEL_VERSION(2,4,19)) || defined(CONFIG_HIGHIO))
+		else {
+			dev->scsi_host_ptr->highmem_io = 0;
+		}
+#endif
+		dev->scsi_host_ptr->max_sectors = AAC_MAX_32BIT_SGBCOUNT;
+		if(!(dev->adapter_info.options & AAC_OPT_NEW_COMM)) {
+			/*
+			 * Worst case size that could cause sg overflow when
+			 * we break up SG elements that are larger than 64KB.
+			 * Would be nice if we could tell the SCSI layer what
+			 * the maximum SG element size can be. Worst case is
+			 * (sg_tablesize-1) 4KB elements with one 64KB
+			 * element.
+			 *	32bit -> 468 or 238KB	64bit -> 424 or 212KB
+			 */
+			dev->scsi_host_ptr->max_sectors
+			  = (dev->scsi_host_ptr->sg_tablesize * 8) + 112;
+		}
 	}
 
 	fib_complete(fibptr);
@@ -512,12 +1223,11 @@ int aac_get_adapter_info(struct aac_dev*
 }
 
 
-static void read_callback(void *context, struct fib * fibptr)
+static void io_callback(void *context, struct fib * fibptr)
 {
 	struct aac_dev *dev;
 	struct aac_read_reply *readreply;
 	struct scsi_cmnd *scsicmd;
-	u32 lba;
 	u32 cid;
 
 	scsicmd = (struct scsi_cmnd *) context;
@@ -525,8 +1235,36 @@ static void read_callback(void *context,
 	dev = (struct aac_dev *)scsicmd->device->host->hostdata;
 	cid = ID_LUN_TO_CONTAINER(scsicmd->device->id, scsicmd->device->lun);
 
-	lba = ((scsicmd->cmnd[1] & 0x1F) << 16) | (scsicmd->cmnd[2] << 8) | scsicmd->cmnd[3];
-	dprintk((KERN_DEBUG "read_callback[cpu %d]: lba = %u, t = %ld.\n", smp_processor_id(), lba, jiffies));
+	if (nblank(dprintk(x))) {
+		u64 lba;
+		if ((scsicmd->cmnd[0] == WRITE_6)	/* 6 byte command */
+		 || (scsicmd->cmnd[0] == READ_6))
+			lba = ((scsicmd->cmnd[1] & 0x1F) << 16)
+			    | (scsicmd->cmnd[2] << 8) | scsicmd->cmnd[3];
+#if (defined(WRITE_16))
+		else if ((scsicmd->cmnd[0] == WRITE_16)	/* 16 byte command */
+		 || (scsicmd->cmnd[0] == READ_16))
+			lba = ((u64)scsicmd->cmnd[2] << 56)
+			    | ((u64)scsicmd->cmnd[3] << 48)
+			    | ((u64)scsicmd->cmnd[4] << 40)
+			    | ((u64)scsicmd->cmnd[9] << 32)
+			    | ((u64)scsicmd->cmnd[6] << 24)
+			    | (scsicmd->cmnd[7] << 16)
+			    | (scsicmd->cmnd[8] << 8) | scsicmd->cmnd[9];
+#endif
+		else if ((scsicmd->cmnd[0] == WRITE_12)	/* 12 byte command */
+		 || (scsicmd->cmnd[0] == READ_12))
+			lba = ((u64)scsicmd->cmnd[2] << 24)
+			    | (scsicmd->cmnd[3] << 16)
+			    | (scsicmd->cmnd[4] << 8) | scsicmd->cmnd[5];
+		else
+			lba = ((u64)scsicmd->cmnd[2] << 24)
+			    | (scsicmd->cmnd[3] << 16)
+			    | (scsicmd->cmnd[4] << 8) | scsicmd->cmnd[5];
+		printk(KERN_DEBUG
+		  "io_callback[cpu %d]: lba = %llu, t = %ld.\n",
+		  smp_processor_id(), (unsigned long long)lba, jiffies);
+	}
 
 	if (fibptr == NULL)
 		BUG();
@@ -537,77 +1275,106 @@ static void read_callback(void *context,
 			scsicmd->use_sg,
 			scsicmd->sc_data_direction);
 	else if(scsicmd->request_bufflen)
-		pci_unmap_single(dev->pdev, (dma_addr_t)(ulong)scsicmd->SCp.ptr,
+		pci_unmap_single(dev->pdev, scsicmd->SCp.dma_handle,
 				 scsicmd->request_bufflen,
 				 scsicmd->sc_data_direction);
 	readreply = (struct aac_read_reply *)fib_data(fibptr);
 	if (le32_to_cpu(readreply->status) == ST_OK)
 		scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD;
 	else {
-		printk(KERN_WARNING "read_callback: read failed, status = %d\n", readreply->status);
+#ifdef AAC_DETAILED_STATUS_INFO
+		printk(KERN_WARNING "io_callback: io failed, status = %d\n",
+		  le32_to_cpu(readreply->status));
+#endif
 		scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_CHECK_CONDITION;
-		set_sense((u8 *) &sense_data[cid],
+		set_sense((u8 *) &dev->fsa_dev[cid].sense_data,
 				    HARDWARE_ERROR,
 				    SENCODE_INTERNAL_TARGET_FAILURE,
 				    ASENCODE_INTERNAL_TARGET_FAILURE, 0, 0,
 				    0, 0);
-		memcpy(scsicmd->sense_buffer, &sense_data[cid], sizeof(struct sense_data));
+		memcpy(scsicmd->sense_buffer, &dev->fsa_dev[cid].sense_data,
+		  (sizeof(dev->fsa_dev[cid].sense_data) > sizeof(scsicmd->sense_buffer))
+		    ? sizeof(scsicmd->sense_buffer)
+		    : sizeof(dev->fsa_dev[cid].sense_data));
 	}
 	fib_complete(fibptr);
 	fib_free(fibptr);
 
 	aac_io_done(scsicmd);
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
+	if (scsicmd->device->device_blocked) {
+		struct scsi_cmnd * cmd;
+		cid = 0;
+
+		for (cmd = scsicmd->device->device_queue; cmd; cmd = cmd->next)
+			if (cmd->serial_number)
+				++cid;
+		if (cid < scsicmd->device->queue_depth)
+			scsicmd->device->device_blocked = 0;
+	}
+#endif
 }
 
-static void write_callback(void *context, struct fib * fibptr)
+static inline void aac_select_queue_depth(
+	struct scsi_cmnd * scsicmd,
+	int cid,
+	u64 lba,
+	u32 count)
 {
+	struct scsi_device *device = scsicmd->device;
 	struct aac_dev *dev;
-	struct aac_write_reply *writereply;
-	struct scsi_cmnd *scsicmd;
-	u32 lba;
-	u32 cid;
-
-	scsicmd = (struct scsi_cmnd *) context;
-	dev = (struct aac_dev *)scsicmd->device->host->hostdata;
-	cid = ID_LUN_TO_CONTAINER(scsicmd->device->id, scsicmd->device->lun);
-
-	lba = ((scsicmd->cmnd[1] & 0x1F) << 16) | (scsicmd->cmnd[2] << 8) | scsicmd->cmnd[3];
-	dprintk((KERN_DEBUG "write_callback[cpu %d]: lba = %u, t = %ld.\n", smp_processor_id(), lba, jiffies));
-	if (fibptr == NULL)
-		BUG();
+	unsigned depth;
 
-	if(scsicmd->use_sg)
-		pci_unmap_sg(dev->pdev, 
-			(struct scatterlist *)scsicmd->buffer,
-			scsicmd->use_sg,
-			scsicmd->sc_data_direction);
-	else if(scsicmd->request_bufflen)
-		pci_unmap_single(dev->pdev, (dma_addr_t)(ulong)scsicmd->SCp.ptr,
-				 scsicmd->request_bufflen,
-				 scsicmd->sc_data_direction);
-
-	writereply = (struct aac_write_reply *) fib_data(fibptr);
-	if (le32_to_cpu(writereply->status) == ST_OK)
-		scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD;
-	else {
-		printk(KERN_WARNING "write_callback: write failed, status = %d\n", writereply->status);
-		scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_CHECK_CONDITION;
-		set_sense((u8 *) &sense_data[cid],
-				    HARDWARE_ERROR,
-				    SENCODE_INTERNAL_TARGET_FAILURE,
-				    ASENCODE_INTERNAL_TARGET_FAILURE, 0, 0,
-				    0, 0);
-		memcpy(scsicmd->sense_buffer, &sense_data[cid], sizeof(struct sense_data));
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
+	if (!device->tagged_supported)
+		return;
+#endif
+	dev = (struct aac_dev *)device->host->hostdata;
+	if (dev->fsa_dev[cid].queue_depth <= 2)
+		dev->fsa_dev[cid].queue_depth = device->queue_depth;
+	if (lba == dev->fsa_dev[cid].last) {
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
+		struct scsi_cmnd * cmd;
+#endif
+		/*
+		 * If larger than coalescethreshold in size, coalescing has
+		 * less effect on overall performance.  Also, if we are
+		 * coalescing right now, leave it alone if above the threshold.
+		 */
+		if (count > coalescethreshold)
+			return;
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
+		depth = 0;
+
+		for (cmd = device->device_queue; cmd; cmd = cmd->next)
+			if ((cmd->serial_number)
+			 && (cmd != scsicmd)
+			 && (++depth > 1)) {
+				device->device_blocked = 1;
+				break;
+			}
+#endif
+		depth = 2;
+	} else {
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
+		device->device_blocked = 0;
+#endif
+		depth = dev->fsa_dev[cid].queue_depth;
 	}
-
-	fib_complete(fibptr);
-	fib_free(fibptr);
-	aac_io_done(scsicmd);
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
+	scsi_adjust_queue_depth(device, MSG_ORDERED_TAG, depth);
+#else
+	device->queue_depth = depth;
+#endif
+	dprintk((KERN_DEBUG "l=%llu %llu[%u] q=%u %lu\n",
+	  dev->fsa_dev[cid].last, lba, count, device->queue_depth,
+	  dev->queues->queue[AdapNormCmdQueue].numpending));
+	dev->fsa_dev[cid].last = lba + count;
 }
 
-int aac_read(struct scsi_cmnd * scsicmd, int cid)
+static int aac_read(struct scsi_cmnd * scsicmd, int cid)
 {
-	u32 lba;
+	u64 lba;
 	u32 count;
 	int status;
 
@@ -619,6 +1386,15 @@ int aac_read(struct scsi_cmnd * scsicmd,
 	/*
 	 *	Get block address and transfer length
 	 */
+#if (defined(AAC_DEBUG_INSTRUMENT_IO))
+	printk(KERN_DEBUG "aac_read: %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x\n",
+	  scsicmd->cmnd[0],  scsicmd->cmnd[1],  scsicmd->cmnd[2],
+	  scsicmd->cmnd[3],  scsicmd->cmnd[4],  scsicmd->cmnd[5],
+	  scsicmd->cmnd[6],  scsicmd->cmnd[7],  scsicmd->cmnd[8],
+	  scsicmd->cmnd[9],  scsicmd->cmnd[10], scsicmd->cmnd[11],
+	  scsicmd->cmnd[12], scsicmd->cmnd[13], scsicmd->cmnd[14],
+	  scsicmd->cmnd[15]);
+#endif
 	if (scsicmd->cmnd[0] == READ_6)	/* 6 byte command */
 	{
 		dprintk((KERN_DEBUG "aachba: received a read(6) command on id %d.\n", cid));
@@ -628,36 +1404,110 @@ int aac_read(struct scsi_cmnd * scsicmd,
 
 		if (count == 0)
 			count = 256;
+#if (defined(READ_16))
+	} else if (scsicmd->cmnd[0] == READ_16) { /* 16 byte command */
+		dprintk((KERN_DEBUG "aachba: received a read(16) command on id %d.\n", cid));
+
+		lba = ((u64)scsicmd->cmnd[2] << 56)
+		    | ((u64)scsicmd->cmnd[3] << 48)
+		    | ((u64)scsicmd->cmnd[4] << 40)
+		    | ((u64)scsicmd->cmnd[9] << 32)
+		    | ((u64)scsicmd->cmnd[6] << 24) | (scsicmd->cmnd[7] << 16)
+		    | (scsicmd->cmnd[8] << 8) | scsicmd->cmnd[9];
+		count = (scsicmd->cmnd[10] << 24) | (scsicmd->cmnd[11] << 16)
+		      | (scsicmd->cmnd[12] << 8) | scsicmd->cmnd[13];
+#endif
+	} else if (scsicmd->cmnd[0] == READ_12) { /* 12 byte command */
+		dprintk((KERN_DEBUG "aachba: received a read(12) command on id %d.\n", cid));
+
+		lba = ((u64)scsicmd->cmnd[2] << 24) | (scsicmd->cmnd[3] << 16)
+		    | (scsicmd->cmnd[4] << 8) | scsicmd->cmnd[5];
+		count = (scsicmd->cmnd[6] << 24) | (scsicmd->cmnd[7] << 16)
+		      | (scsicmd->cmnd[8] << 8) | scsicmd->cmnd[9];
 	} else {
 		dprintk((KERN_DEBUG "aachba: received a read(10) command on id %d.\n", cid));
 
-		lba = (scsicmd->cmnd[2] << 24) | (scsicmd->cmnd[3] << 16) | (scsicmd->cmnd[4] << 8) | scsicmd->cmnd[5];
+		lba = ((u64)scsicmd->cmnd[2] << 24) | (scsicmd->cmnd[3] << 16) | (scsicmd->cmnd[4] << 8) | scsicmd->cmnd[5];
 		count = (scsicmd->cmnd[7] << 8) | scsicmd->cmnd[8];
 	}
-	dprintk((KERN_DEBUG "aac_read[cpu %d]: lba = %u, t = %ld.\n", smp_processor_id(), lba, jiffies));
+	dprintk((KERN_DEBUG "aac_read[cpu %d]: lba = %llu, t = %ld.\n",
+	  smp_processor_id(), (unsigned long long)lba, jiffies));
+	if ((!(dev->raw_io_interface) || !(dev->raw_io_64))
+	 && (lba & 0xffffffff00000000LL)) {
+		dprintk((KERN_DEBUG "aac_read: Illegal lba\n"));
+		scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_CHECK_CONDITION;
+		set_sense((u8 *) &dev->fsa_dev[cid].sense_data,
+			    HARDWARE_ERROR,
+			    SENCODE_INTERNAL_TARGET_FAILURE,
+			    ASENCODE_INTERNAL_TARGET_FAILURE, 0, 0,
+			    0, 0);
+		memcpy(scsicmd->sense_buffer, &dev->fsa_dev[cid].sense_data,
+		  (sizeof(dev->fsa_dev[cid].sense_data) > sizeof(scsicmd->sense_buffer))
+		    ? sizeof(scsicmd->sense_buffer)
+		    : sizeof(dev->fsa_dev[cid].sense_data));
+#if (defined(AAC_DEBUG_INSTRUMENT_TIMING))
+		__aac_io_done(scsicmd);
+#else
+		scsicmd->scsi_done(scsicmd);
+#endif
+		return 0;
+	}
+	/*
+	 *	Are we in a sequential mode?
+	 */
+	aac_select_queue_depth(scsicmd, cid, lba, count);
 	/*
 	 *	Alocate and initialize a Fib
 	 */
 	if (!(cmd_fibcontext = fib_alloc(dev))) {
-		return -1;
+		scsicmd->result = DID_ERROR << 16;
+		aac_io_done(scsicmd);
+		return 0;
 	}
 
 	fib_init(cmd_fibcontext);
 
-	if(dev->pae_support == 1){
+	if (dev->raw_io_interface) {
+		struct aac_raw_io *readcmd;
+		readcmd = (struct aac_raw_io *) fib_data(cmd_fibcontext);
+		readcmd->block[0] = cpu_to_le32((u32)(lba&0xffffffff));
+		readcmd->block[1] = cpu_to_le32((u32)((lba&0xffffffff00000000LL)>>32));
+		readcmd->count = cpu_to_le32(count<<9);
+		readcmd->cid = cpu_to_le16(cid);
+		readcmd->flags = cpu_to_le16(1);
+		readcmd->bpTotal = 0;
+		readcmd->bpComplete = 0;
+		
+		aac_build_sgraw(scsicmd, &readcmd->sg);
+		fibsize = sizeof(struct aac_raw_io) + ((le32_to_cpu(readcmd->sg.count) - 1) * sizeof (struct sgentryraw));
+		if (fibsize > (dev->max_fib_size - sizeof(struct aac_fibhdr)))
+			BUG();
+		/*
+		 *	Now send the Fib to the adapter
+		 */
+		status = fib_send(ContainerRawIo,
+			  cmd_fibcontext, 
+			  fibsize, 
+			  FsaNormal, 
+			  0, 1, 
+			  (fib_callback) io_callback, 
+			  (void *) scsicmd);
+	} else if (dev->dac_support == 1) {
 		struct aac_read64 *readcmd;
 		readcmd = (struct aac_read64 *) fib_data(cmd_fibcontext);
 		readcmd->command = cpu_to_le32(VM_CtHostRead64);
 		readcmd->cid = cpu_to_le16(cid);
 		readcmd->sector_count = cpu_to_le16(count);
-		readcmd->block = cpu_to_le32(lba);
-		readcmd->pad   = cpu_to_le16(0);
-		readcmd->flags = cpu_to_le16(0); 
+		readcmd->block = cpu_to_le32((u32)(lba&0xffffffff));
+		readcmd->pad   = 0;
+		readcmd->flags = 0; 
 
 		aac_build_sg64(scsicmd, &readcmd->sg);
-		if(readcmd->sg.count > MAX_DRIVER_SG_SEGMENT_COUNT)
-			BUG();
-		fibsize = sizeof(struct aac_read64) + ((readcmd->sg.count - 1) * sizeof (struct sgentry64));
+		fibsize = sizeof(struct aac_read64) + 
+			((le32_to_cpu(readcmd->sg.count) - 1) * 
+			 sizeof (struct sgentry64));
+		BUG_ON (fibsize > (sizeof(struct hw_fib) - 
+					sizeof(struct aac_fibhdr)));
 		/*
 		 *	Now send the Fib to the adapter
 		 */
@@ -666,23 +1516,22 @@ int aac_read(struct scsi_cmnd * scsicmd,
 			  fibsize, 
 			  FsaNormal, 
 			  0, 1, 
-			  (fib_callback) read_callback, 
+			  (fib_callback) io_callback, 
 			  (void *) scsicmd);
 	} else {
 		struct aac_read *readcmd;
 		readcmd = (struct aac_read *) fib_data(cmd_fibcontext);
 		readcmd->command = cpu_to_le32(VM_CtBlockRead);
 		readcmd->cid = cpu_to_le32(cid);
-		readcmd->block = cpu_to_le32(lba);
+		readcmd->block = cpu_to_le32((u32)(lba&0xffffffff));
 		readcmd->count = cpu_to_le32(count * 512);
 
-		if (count * 512 > (64 * 1024))
-			BUG();
-
 		aac_build_sg(scsicmd, &readcmd->sg);
-		if(readcmd->sg.count > MAX_DRIVER_SG_SEGMENT_COUNT)
-			BUG();
-		fibsize = sizeof(struct aac_read) + ((readcmd->sg.count - 1) * sizeof (struct sgentry));
+		fibsize = sizeof(struct aac_read) + 
+			((le32_to_cpu(readcmd->sg.count) - 1) * 
+			 sizeof (struct sgentry));
+		BUG_ON (fibsize > (dev->max_fib_size -
+					sizeof(struct aac_fibhdr)));
 		/*
 		 *	Now send the Fib to the adapter
 		 */
@@ -691,7 +1540,7 @@ int aac_read(struct scsi_cmnd * scsicmd,
 			  fibsize, 
 			  FsaNormal, 
 			  0, 1, 
-			  (fib_callback) read_callback, 
+			  (fib_callback) io_callback, 
 			  (void *) scsicmd);
 	}
 
@@ -701,10 +1550,7 @@ int aac_read(struct scsi_cmnd * scsicmd,
 	 *	Check that the command queued to the controller
 	 */
 	if (status == -EINPROGRESS) 
-	{
-		dprintk("read queued.\n");
 		return 0;
-	}
 		
 	printk(KERN_WARNING "aac_read: fib_send failed with status: %d.\n", status);
 	/*
@@ -714,12 +1560,12 @@ int aac_read(struct scsi_cmnd * scsicmd,
 	aac_io_done(scsicmd);
 	fib_complete(cmd_fibcontext);
 	fib_free(cmd_fibcontext);
-	return -1;
+	return 0;
 }
 
 static int aac_write(struct scsi_cmnd * scsicmd, int cid)
 {
-	u32 lba;
+	u64 lba;
 	u32 count;
 	int status;
 	u16 fibsize;
@@ -730,42 +1576,123 @@ static int aac_write(struct scsi_cmnd * 
 	/*
 	 *	Get block address and transfer length
 	 */
+#if (defined(AAC_DEBUG_INSTRUMENT_IO))
+	printk(KERN_DEBUG "aac_write: %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x\n",
+	  scsicmd->cmnd[0],  scsicmd->cmnd[1],  scsicmd->cmnd[2],
+	  scsicmd->cmnd[3],  scsicmd->cmnd[4],  scsicmd->cmnd[5],
+	  scsicmd->cmnd[6],  scsicmd->cmnd[7],  scsicmd->cmnd[8],
+	  scsicmd->cmnd[9],  scsicmd->cmnd[10], scsicmd->cmnd[11],
+	  scsicmd->cmnd[12], scsicmd->cmnd[13], scsicmd->cmnd[14],
+	  scsicmd->cmnd[15]);
+#endif
 	if (scsicmd->cmnd[0] == WRITE_6)	/* 6 byte command */
 	{
 		lba = ((scsicmd->cmnd[1] & 0x1F) << 16) | (scsicmd->cmnd[2] << 8) | scsicmd->cmnd[3];
 		count = scsicmd->cmnd[4];
 		if (count == 0)
 			count = 256;
+#if (defined(WRITE_16))
+	} else if (scsicmd->cmnd[0] == WRITE_16) { /* 16 byte command */
+		dprintk((KERN_DEBUG "aachba: received a write(16) command on id %d.\n", cid));
+
+		lba = ((u64)scsicmd->cmnd[2] << 56)
+		    | ((u64)scsicmd->cmnd[3] << 48)
+		    | ((u64)scsicmd->cmnd[4] << 40)
+		    | ((u64)scsicmd->cmnd[9] << 32)
+		    | ((u64)scsicmd->cmnd[6] << 24) | (scsicmd->cmnd[7] << 16)
+		    | (scsicmd->cmnd[8] << 8) | scsicmd->cmnd[9];
+		count = (scsicmd->cmnd[10] << 24) | (scsicmd->cmnd[11] << 16)
+		      | (scsicmd->cmnd[12] << 8) | scsicmd->cmnd[13];
+#endif
+	} else if (scsicmd->cmnd[0] == WRITE_12) { /* 12 byte command */
+		dprintk((KERN_DEBUG "aachba: received a write(12) command on id %d.\n", cid));
+
+		lba = ((u64)scsicmd->cmnd[2] << 24) | (scsicmd->cmnd[3] << 16)
+		    | (scsicmd->cmnd[4] << 8) | scsicmd->cmnd[5];
+		count = (scsicmd->cmnd[6] << 24) | (scsicmd->cmnd[7] << 16)
+		      | (scsicmd->cmnd[8] << 8) | scsicmd->cmnd[9];
 	} else {
 		dprintk((KERN_DEBUG "aachba: received a write(10) command on id %d.\n", cid));
-		lba = (scsicmd->cmnd[2] << 24) | (scsicmd->cmnd[3] << 16) | (scsicmd->cmnd[4] << 8) | scsicmd->cmnd[5];
+		lba = ((u64)scsicmd->cmnd[2] << 24) | (scsicmd->cmnd[3] << 16) | (scsicmd->cmnd[4] << 8) | scsicmd->cmnd[5];
 		count = (scsicmd->cmnd[7] << 8) | scsicmd->cmnd[8];
 	}
-	dprintk((KERN_DEBUG "aac_write[cpu %d]: lba = %u, t = %ld.\n", smp_processor_id(), lba, jiffies));
+	dprintk((KERN_DEBUG "aac_write[cpu %d]: lba = %llu, t = %ld.\n",
+	  smp_processor_id(), (unsigned long long)lba, jiffies));
+	if ((!(dev->raw_io_interface) || !(dev->raw_io_64))
+	 && (lba & 0xffffffff00000000LL)) {
+		dprintk((KERN_DEBUG "aac_write: Illegal lba\n"));
+		scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_CHECK_CONDITION;
+		set_sense((u8 *) &dev->fsa_dev[cid].sense_data,
+			    HARDWARE_ERROR,
+			    SENCODE_INTERNAL_TARGET_FAILURE,
+			    ASENCODE_INTERNAL_TARGET_FAILURE, 0, 0,
+			    0, 0);
+		memcpy(scsicmd->sense_buffer, &dev->fsa_dev[cid].sense_data,
+		  (sizeof(dev->fsa_dev[cid].sense_data) > sizeof(scsicmd->sense_buffer))
+		    ? sizeof(scsicmd->sense_buffer)
+		    : sizeof(dev->fsa_dev[cid].sense_data));
+#if (defined(AAC_DEBUG_INSTRUMENT_TIMING))
+		__aac_io_done(scsicmd);
+#else
+		scsicmd->scsi_done(scsicmd);
+#endif
+		return 0;
+	}
+	/*
+	 *	Are we in a sequential mode?
+	 */
+	aac_select_queue_depth(scsicmd, cid, lba, count);
 	/*
 	 *	Allocate and initialize a Fib then setup a BlockWrite command
 	 */
 	if (!(cmd_fibcontext = fib_alloc(dev))) {
 		scsicmd->result = DID_ERROR << 16;
 		aac_io_done(scsicmd);
-		return -1;
+		return 0;
 	}
 	fib_init(cmd_fibcontext);
 
-	if(dev->pae_support == 1){
+	if (dev->raw_io_interface) {
+		struct aac_raw_io *writecmd;
+		writecmd = (struct aac_raw_io *) fib_data(cmd_fibcontext);
+		writecmd->block[0] = cpu_to_le32((u32)(lba&0xffffffff));
+		writecmd->block[1] = cpu_to_le32((u32)((lba&0xffffffff00000000LL)>>32));
+		writecmd->count = cpu_to_le32(count<<9);
+		writecmd->cid = cpu_to_le16(cid);
+		writecmd->flags = 0; 
+		writecmd->bpTotal = 0;
+		writecmd->bpComplete = 0;
+		
+		aac_build_sgraw(scsicmd, &writecmd->sg);
+		fibsize = sizeof(struct aac_raw_io) + ((le32_to_cpu(writecmd->sg.count) - 1) * sizeof (struct sgentryraw));
+		if (fibsize > (dev->max_fib_size - sizeof(struct aac_fibhdr)))
+			BUG();
+		/*
+		 *	Now send the Fib to the adapter
+		 */
+		status = fib_send(ContainerRawIo,
+			  cmd_fibcontext, 
+			  fibsize, 
+			  FsaNormal, 
+			  0, 1, 
+			  (fib_callback) io_callback, 
+			  (void *) scsicmd);
+	} else if (dev->dac_support == 1) {
 		struct aac_write64 *writecmd;
 		writecmd = (struct aac_write64 *) fib_data(cmd_fibcontext);
 		writecmd->command = cpu_to_le32(VM_CtHostWrite64);
 		writecmd->cid = cpu_to_le16(cid);
 		writecmd->sector_count = cpu_to_le16(count); 
-		writecmd->block = cpu_to_le32(lba);
-		writecmd->pad	= cpu_to_le16(0);
-		writecmd->flags	= cpu_to_le16(0);
+		writecmd->block = cpu_to_le32((u32)(lba&0xffffffff));
+		writecmd->pad	= 0;
+		writecmd->flags	= 0;
 
 		aac_build_sg64(scsicmd, &writecmd->sg);
-		if(writecmd->sg.count > MAX_DRIVER_SG_SEGMENT_COUNT)
-			BUG();
-		fibsize = sizeof(struct aac_write64) + ((writecmd->sg.count - 1) * sizeof (struct sgentry64));
+		fibsize = sizeof(struct aac_write64) + 
+			((le32_to_cpu(writecmd->sg.count) - 1) * 
+			 sizeof (struct sgentry64));
+		BUG_ON (fibsize > (dev->max_fib_size -
+					sizeof(struct aac_fibhdr)));
 		/*
 		 *	Now send the Fib to the adapter
 		 */
@@ -774,26 +1701,24 @@ static int aac_write(struct scsi_cmnd * 
 			  fibsize, 
 			  FsaNormal, 
 			  0, 1, 
-			  (fib_callback) write_callback, 
+			  (fib_callback) io_callback, 
 			  (void *) scsicmd);
 	} else {
 		struct aac_write *writecmd;
 		writecmd = (struct aac_write *) fib_data(cmd_fibcontext);
 		writecmd->command = cpu_to_le32(VM_CtBlockWrite);
 		writecmd->cid = cpu_to_le32(cid);
-		writecmd->block = cpu_to_le32(lba);
+		writecmd->block = cpu_to_le32((u32)(lba&0xffffffff));
 		writecmd->count = cpu_to_le32(count * 512);
 		writecmd->sg.count = cpu_to_le32(1);
 		/* ->stable is not used - it did mean which type of write */
 
-		if (count * 512 > (64 * 1024)) {
-			BUG();
-		}
-
 		aac_build_sg(scsicmd, &writecmd->sg);
-		if(writecmd->sg.count > MAX_DRIVER_SG_SEGMENT_COUNT)
-			BUG();
-		fibsize = sizeof(struct aac_write) + ((writecmd->sg.count - 1) * sizeof (struct sgentry));
+		fibsize = sizeof(struct aac_write) + 
+			((le32_to_cpu(writecmd->sg.count) - 1) * 
+			 sizeof (struct sgentry));
+		BUG_ON (fibsize > (dev->max_fib_size -
+					sizeof(struct aac_fibhdr)));
 		/*
 		 *	Now send the Fib to the adapter
 		 */
@@ -802,7 +1727,7 @@ static int aac_write(struct scsi_cmnd * 
 			  fibsize, 
 			  FsaNormal, 
 			  0, 1, 
-			  (fib_callback) write_callback, 
+			  (fib_callback) io_callback, 
 			  (void *) scsicmd);
 	}
 
@@ -811,7 +1736,6 @@ static int aac_write(struct scsi_cmnd * 
 	 */
 	if (status == -EINPROGRESS)
 	{
-		dprintk("write queued.\n");
 		return 0;
 	}
 
@@ -824,9 +1748,164 @@ static int aac_write(struct scsi_cmnd * 
 
 	fib_complete(cmd_fibcontext);
 	fib_free(cmd_fibcontext);
-	return -1;
+	return 0;
+}
+
+static void synchronize_callback(void *context, struct fib *fibptr)
+{
+	struct aac_synchronize_reply *synchronizereply;
+	struct scsi_cmnd *cmd;
+
+	cmd = context;
+
+	dprintk((KERN_DEBUG "synchronize_callback[cpu %d]: t = %ld.\n", 
+				smp_processor_id(), jiffies));
+	BUG_ON(fibptr == NULL);
+
+
+	synchronizereply = fib_data(fibptr);
+	if (le32_to_cpu(synchronizereply->status) == CT_OK)
+		cmd->result = DID_OK << 16 | 
+			COMMAND_COMPLETE << 8 | SAM_STAT_GOOD;
+	else {
+		struct scsi_device *sdev = cmd->device;
+		struct aac_dev *dev = (struct aac_dev *)sdev->host->hostdata;
+		u32 cid = ID_LUN_TO_CONTAINER(sdev->id, sdev->lun);
+		printk(KERN_WARNING 
+		     "synchronize_callback: synchronize failed, status = %d\n",
+		     le32_to_cpu(synchronizereply->status));
+		cmd->result = DID_OK << 16 | 
+			COMMAND_COMPLETE << 8 | SAM_STAT_CHECK_CONDITION;
+		set_sense((u8 *)&dev->fsa_dev[cid].sense_data,
+				    HARDWARE_ERROR,
+				    SENCODE_INTERNAL_TARGET_FAILURE,
+				    ASENCODE_INTERNAL_TARGET_FAILURE, 0, 0,
+				    0, 0);
+		memcpy(cmd->sense_buffer, &dev->fsa_dev[cid].sense_data,
+		  min(sizeof(dev->fsa_dev[cid].sense_data), 
+			  sizeof(cmd->sense_buffer)));
+	}
+
+	fib_complete(fibptr);
+	fib_free(fibptr);
+	aac_io_done(cmd);
+}
+
+static int aac_synchronize(struct scsi_cmnd *scsicmd, int cid)
+{
+	int status;
+	struct fib *cmd_fibcontext;
+	struct aac_synchronize *synchronizecmd;
+	struct scsi_cmnd *cmd;
+	struct scsi_device *sdev = scsicmd->device;
+	int active = 0;
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
+	unsigned long flags;
+
+	/*
+	 * Wait for all commands to complete to this specific
+	 * target (block).
+	 */
+	spin_lock_irqsave(&sdev->list_lock, flags);
+	list_for_each_entry(cmd, &sdev->cmd_list, list)
+		if (cmd != scsicmd && cmd->serial_number != 0) {
+			++active;
+			break;
+		}
+
+	spin_unlock_irqrestore(&sdev->list_lock, flags);
+#else
+
+	/*
+	 * Wait for all commands to complete to this specific
+	 * target (block).
+	 */
+	for(cmd = sdev->device_queue; cmd; cmd = cmd->next)
+		if ((cmd != scsicmd) && (cmd->serial_number != 0)) {
+			++active;
+			break;
+		}
+#endif
+
+	/*
+	 *	Yield the processor (requeue for later)
+	 */
+	if (active)
+		return SCSI_MLQUEUE_DEVICE_BUSY;
+
+#if (defined(AAC_DEBUG_INSTRUMENT_IO))
+	printk(KERN_DEBUG "aac_synchronize[cpu %d]: t = %ld.\n",
+	  smp_processor_id(), jiffies);
+#endif
+	/*
+	 *	Allocate and initialize a Fib
+	 */
+	if (!(cmd_fibcontext = 
+	    fib_alloc((struct aac_dev *)scsicmd->device->host->hostdata))) 
+		return SCSI_MLQUEUE_HOST_BUSY;
+
+	fib_init(cmd_fibcontext);
+
+	synchronizecmd = fib_data(cmd_fibcontext);
+	synchronizecmd->command = cpu_to_le32(VM_ContainerConfig);
+	synchronizecmd->type = cpu_to_le32(CT_FLUSH_CACHE);
+	synchronizecmd->cid = cpu_to_le32(cid);
+	synchronizecmd->count = 
+	     cpu_to_le32(sizeof(((struct aac_synchronize_reply *)NULL)->data));
+
+	/*
+	 *	Now send the Fib to the adapter
+	 */
+	status = fib_send(ContainerCommand,
+		  cmd_fibcontext,
+		  sizeof(struct aac_synchronize),
+		  FsaNormal,
+		  0, 1,
+		  (fib_callback)synchronize_callback,
+		  (void *)scsicmd);
+
+	/*
+	 *	Check that the command queued to the controller
+	 */
+	if (status == -EINPROGRESS)
+		return 0;
+
+	printk(KERN_WARNING 
+		"aac_synchronize: fib_send failed with status: %d.\n", status);
+	fib_complete(cmd_fibcontext);
+	fib_free(cmd_fibcontext);
+	return SCSI_MLQUEUE_HOST_BUSY;
+}
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
+
+static inline void get_sd_devname(int disknum, char *buffer)
+{
+	if (disknum < 0) {
+		buffer[0] = '\0';
+		return;
+	}
+
+	buffer[0] = 's';
+	buffer[1] = 'd';
+	if (disknum < 26) {
+		buffer[2] = 'a' + disknum;
+		buffer[3] = '\0';
+	} else {
+		/*
+		 * For larger numbers of disks, we need to go to a new
+		 * naming scheme.
+		 */
+		buffer[2] = 'a' - 1 + (disknum / 26);
+		buffer[3] = 'a' + (disknum % 26);
+		buffer[4] = '\0';
+	}
 }
 
+# define strlcpy(s1,s2,n) strncpy(s1,s2,n);s1[n-1]='\0'
+# ifndef min
+#  define min(a,b) (((a)<(b))?(a):(b))
+# endif
+#endif
 
 /**
  *	aac_scsi_cmd()		-	Process SCSI command
@@ -839,12 +1918,20 @@ static int aac_write(struct scsi_cmnd * 
 int aac_scsi_cmd(struct scsi_cmnd * scsicmd)
 {
 	u32 cid = 0;
-	int ret;
 	struct Scsi_Host *host = scsicmd->device->host;
 	struct aac_dev *dev = (struct aac_dev *)host->hostdata;
-	struct fsa_scsi_hba *fsa_dev_ptr = &dev->fsa_dev;
-	int cardtype = dev->cardtype;
+	struct fsa_dev_info *fsa_dev_ptr = dev->fsa_dev;
 	
+#	if (defined(AAC_DEBUG_INSTRUMENT_2TB))
+		printk(KERN_NOTICE "scsicmd->cmnd={%02x %02x %02x %02x %02x "
+		  "%02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x}\n",
+		  scsicmd->cmnd[0], scsicmd->cmnd[1], scsicmd->cmnd[2],
+		  scsicmd->cmnd[3], scsicmd->cmnd[4], scsicmd->cmnd[5],
+		  scsicmd->cmnd[6], scsicmd->cmnd[7], scsicmd->cmnd[8],
+		  scsicmd->cmnd[9], scsicmd->cmnd[10], scsicmd->cmnd[11],
+		  scsicmd->cmnd[12], scsicmd->cmnd[13], scsicmd->cmnd[14],
+		  scsicmd->cmnd[15]);
+#	endif
 	/*
 	 *	If the bus, id or lun is out of range, return fail
 	 *	Test does not apply to ID 16, the pseudo id for the controller
@@ -852,9 +1939,19 @@ int aac_scsi_cmd(struct scsi_cmnd * scsi
 	 */
 	if (scsicmd->device->id != host->this_id) {
 		if ((scsicmd->device->channel == 0) ){
-			if( (scsicmd->device->id >= MAXIMUM_NUM_CONTAINERS) || (scsicmd->device->lun != 0)){ 
+			if( (scsicmd->device->id >= dev->maximum_num_containers) || (scsicmd->device->lun != 0)){ 
+#				if (defined(AAC_DEBUG_INSTRUMENT_2TB))
+					printk(KERN_INFO
+					  "scsicmd(0:%d:%d:0) No Connect\n",
+					  scsicmd->device->channel,
+					  scsicmd->device->id);
+#				endif
 				scsicmd->result = DID_NO_CONNECT << 16;
+#if (defined(AAC_DEBUG_INSTRUMENT_TIMING))
 				__aac_io_done(scsicmd);
+#else
+				scsicmd->scsi_done(scsicmd);
+#endif
 				return 0;
 			}
 			cid = ID_LUN_TO_CONTAINER(scsicmd->device->id, scsicmd->device->lun);
@@ -863,38 +1960,127 @@ int aac_scsi_cmd(struct scsi_cmnd * scsi
 			 *	If the target container doesn't exist, it may have
 			 *	been newly created
 			 */
-			if (fsa_dev_ptr->valid[cid] == 0) {
+#if (!defined(__arm__) && !defined(CONFIG_EXTERNAL))
+			if ((fsa_dev_ptr[cid].valid & 1) == 0) {
+#endif
 				switch (scsicmd->cmnd[0]) {
+#if (defined(SERVICE_ACTION_IN))
+				case SERVICE_ACTION_IN:
+					if (!(dev->raw_io_interface)
+					 || !(dev->raw_io_64)
+					 || ((scsicmd->cmnd[1] & 0x1f) != SAI_READ_CAPACITY_16))
+						break;
+#endif
 				case INQUIRY:
 				case READ_CAPACITY:
 				case TEST_UNIT_READY:
-					spin_unlock_irq(host->host_lock);
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,4,19))
+# if (MAX_NESTED == 1)
+					if (fsa_dev_ptr[cid].nested)
+						return -1;
+					fsa_dev_ptr[cid].nested = 1;
+# else
+					if (fsa_dev_ptr[cid].nested >= MAX_NESTED)
+						return -1;
+					++(fsa_dev_ptr[cid].nested);
+# endif
+#endif
+					aac_spin_unlock_irq(host->host_lock);
 					probe_container(dev, cid);
-					spin_lock_irq(host->host_lock);
-					if (fsa_dev_ptr->valid[cid] == 0) {
+					if ((fsa_dev_ptr[cid].valid & 1) == 0)
+						fsa_dev_ptr[cid].valid = 0;
+					aac_spin_lock_irq(host->host_lock);
+					if (fsa_dev_ptr[cid].valid == 0) {
+#						if (defined(AAC_DEBUG_INSTRUMENT_2TB))
+							printk(KERN_INFO
+							  "scsicmd(0:%d:%d:0) "
+							  "Invalid\n",
+							  scsicmd->device->channel,
+							  scsicmd->device->id);
+#						endif
 						scsicmd->result = DID_NO_CONNECT << 16;
+#if (defined(AAC_DEBUG_INSTRUMENT_TIMING))
 						__aac_io_done(scsicmd);
+#else
+						scsicmd->scsi_done(scsicmd);
+#endif
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,4,19))
+# if (MAX_NESTED == 1)
+						fsa_dev_ptr[cid].nested = 0;
+# else
+						if (fsa_dev_ptr[cid].nested != 0)
+							--(fsa_dev_ptr[cid].nested);
+# endif
+#endif
 						return 0;
 					}
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,4,19))
+# if (MAX_NESTED == 1)
+					fsa_dev_ptr[cid].nested = 0;
+# else
+					if (fsa_dev_ptr[cid].nested != 0)
+						--(fsa_dev_ptr[cid].nested);
+# endif
+#endif
 				default:
 					break;
 				}
+#if (!defined(__arm__) && !defined(CONFIG_EXTERNAL))
 			}
+#endif
 			/*
 			 *	If the target container still doesn't exist, 
 			 *	return failure
 			 */
-			if (fsa_dev_ptr->valid[cid] == 0) {
+			if (fsa_dev_ptr[cid].valid == 0) {
+#				if (defined(AAC_DEBUG_INSTRUMENT_2TB))
+					printk(KERN_INFO
+					  "scsicmd(0:%d:%d:0) Does not exist\n",
+					  scsicmd->device->channel,
+					  scsicmd->device->id);
+#				endif
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,4,19))
+# if (MAX_NESTED == 1)
+				if (fsa_dev_ptr[cid].nested)
+					return -1;
+				fsa_dev_ptr[cid].nested = 1;
+# else
+				if (fsa_dev_ptr[cid].nested >= MAX_NESTED)
+					return -1;
+				++(fsa_dev_ptr[cid].nested);
+# endif
+#endif
 				scsicmd->result = DID_BAD_TARGET << 16;
+#if (defined(AAC_DEBUG_INSTRUMENT_TIMING))
 				__aac_io_done(scsicmd);
+#else
+				scsicmd->scsi_done(scsicmd);
+#endif
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,4,19))
+# if (MAX_NESTED == 1)
+				fsa_dev_ptr[cid].nested = 0;
+# else
+				if (fsa_dev_ptr[cid].nested != 0)
+					--(fsa_dev_ptr[cid].nested);
+# endif
+#endif
 				return 0;
 			}
 		} else {  /* check for physical non-dasd devices */
+#			if (defined(AAC_DEBUG_INSTRUMENT_2TB))
+				printk(KERN_INFO "scsicmd(0:%d:%d:0) Phys\n",
+				  scsicmd->device->channel,
+				  scsicmd->device->id);
+#			endif
 			if(dev->nondasd_support == 1){
 				return aac_send_srb_fib(scsicmd);
 			} else {
 				scsicmd->result = DID_NO_CONNECT << 16;
+#if (defined(AAC_DEBUG_INSTRUMENT_TIMING))
 				__aac_io_done(scsicmd);
+#else
+				scsicmd->scsi_done(scsicmd);
+#endif
 				return 0;
 			}
 		}
@@ -907,17 +2093,27 @@ int aac_scsi_cmd(struct scsi_cmnd * scsi
 	{
 		dprintk((KERN_WARNING "Only INQUIRY & TUR command supported for controller, rcvd = 0x%x.\n", scsicmd->cmnd[0]));
 		scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_CHECK_CONDITION;
-		set_sense((u8 *) &sense_data[cid],
+		set_sense((u8 *) &dev->fsa_dev[cid].sense_data,
 			    ILLEGAL_REQUEST,
 			    SENCODE_INVALID_COMMAND,
 			    ASENCODE_INVALID_COMMAND, 0, 0, 0, 0);
+		memcpy(scsicmd->sense_buffer, &dev->fsa_dev[cid].sense_data,
+		  (sizeof(dev->fsa_dev[cid].sense_data) > sizeof(scsicmd->sense_buffer))
+		    ? sizeof(scsicmd->sense_buffer)
+		    : sizeof(dev->fsa_dev[cid].sense_data));
+#if (defined(AAC_DEBUG_INSTRUMENT_TIMING))
 		__aac_io_done(scsicmd);
-		memcpy(scsicmd->sense_buffer, &sense_data[cid], sizeof(struct sense_data));
+#else
+		scsicmd->scsi_done(scsicmd);
+#endif
 		return 0;
 	}
 
 
 	/* Handle commands here that don't really require going out to the adapter */
+#	if (defined(AAC_DEBUG_INSTRUMENT_2TB))
+		printk(KERN_NOTICE "cmnd[0]=%02x\n", scsicmd->cmnd[0]);
+#	endif
 	switch (scsicmd->cmnd[0]) {
 	case INQUIRY:
 	{
@@ -928,7 +2124,6 @@ int aac_scsi_cmd(struct scsi_cmnd * scsi
 		memset(inq_data_ptr, 0, sizeof (struct inquiry_data));
 
 		inq_data_ptr->inqd_ver = 2;	/* claim compliance to SCSI-2 */
-		inq_data_ptr->inqd_dtq = 0x80;	/* set RMB bit to one indicating that the medium is removable */
 		inq_data_ptr->inqd_rdf = 2;	/* A response data format value of two indicates that the data shall be in the format specified in SCSI-2 */
 		inq_data_ptr->inqd_len = 31;
 		/*Format for "pad2" is  RelAdr | WBus32 | WBus16 |  Sync  | Linked |Reserved| CmdQue | SftRe */
@@ -937,22 +2132,88 @@ int aac_scsi_cmd(struct scsi_cmnd * scsi
 		 *	Set the Vendor, Product, and Revision Level
 		 *	see: <vendor>.c i.e. aac.c
 		 */
-		setinqstr(cardtype, (void *) (inq_data_ptr->inqd_vid), fsa_dev_ptr->type[cid]);
-		if (scsicmd->device->id == host->this_id)
+		if (scsicmd->device->id == host->this_id) {
+			setinqstr(dev, (void *) (inq_data_ptr->inqd_vid), (sizeof(container_types)/sizeof(char *)));
 			inq_data_ptr->inqd_pdt = INQD_PDT_PROC;	/* Processor device */
-		else
-			inq_data_ptr->inqd_pdt = INQD_PDT_DA;	/* Direct/random access device */
+			scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD;
+#if (defined(AAC_DEBUG_INSTRUMENT_TIMING))
+			__aac_io_done(scsicmd);
+#else
+			scsicmd->scsi_done(scsicmd);
+#endif
+			return 0;
+		}
+		setinqstr(dev, (void *) (inq_data_ptr->inqd_vid), fsa_dev_ptr[cid].type);
+		inq_data_ptr->inqd_pdt = INQD_PDT_DA;	/* Direct/random access device */
+		return aac_get_container_name(scsicmd, cid);
+	}
+#if (defined(SERVICE_ACTION_IN))
+	case SERVICE_ACTION_IN:
+#if (defined(AAC_DEBUG_INSTRUMENT_2TB))
+		printk(KERN_NOTICE
+		  "SERVICE_ACTION_IN, raw_io_interface=%d raw_io_64=%d\n",
+		  dev->raw_io_interface, dev->raw_io_64);
+#endif
+		if (!(dev->raw_io_interface)
+		 || !(dev->raw_io_64)
+		 || ((scsicmd->cmnd[1] & 0x1f) != SAI_READ_CAPACITY_16))
+			break;
+	{
+		u64 capacity;
+		char *cp;
+
+		dprintk((KERN_DEBUG "READ CAPACITY_16 command.\n"));
+		capacity = fsa_dev_ptr[cid].size - 1;
+		cp = scsicmd->request_buffer;
+		if (scsicmd->cmnd[13] > 12) {
+			memset(cp, 0, scsicmd->cmnd[13] - 12);
+			cp += scsicmd->cmnd[13] - 12;
+		}
+		cp[0] = (capacity >> 56) & 0xff;
+		cp[1] = (capacity >> 48) & 0xff;
+		cp[2] = (capacity >> 40) & 0xff;
+		cp[3] = (capacity >> 32) & 0xff;
+		cp[4] = (capacity >> 24) & 0xff;
+		cp[5] = (capacity >> 16) & 0xff;
+		cp[6] = (capacity >> 8) & 0xff;
+		cp[7] = (capacity >> 0) & 0xff;
+		cp[8] = 0;
+		cp[9] = 0;
+		cp[10] = 2;
+		cp[11] = 0;
+#if (defined(AAC_DEBUG_INSTRUMENT_2TB))
+		printk(KERN_INFO "SAI_READ_CAPACITY_16(%d): "
+		  "%02x %02x %02x %02x %02x %02x %02x %02x "
+		  "%02x %02x %02x %02x\n",
+		  scsicmd->cmnd[13],
+		  cp[0] & 0xff, cp[1] & 0xff, cp[2] & 0xff, cp[3] & 0xff,
+		  cp[4] & 0xff, cp[5] & 0xff, cp[6] & 0xff, cp[7] & 0xff,
+		  cp[8] & 0xff, cp[9] & 0xff, cp[10] & 0xff, cp[11] & 0xff);
+#endif
+
+		/* Do not cache partition table for arrays */
+		scsicmd->device->removable = 1;
+
 		scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD;
+#if (defined(AAC_DEBUG_INSTRUMENT_TIMING))
 		__aac_io_done(scsicmd);
+#else
+		scsicmd->scsi_done(scsicmd);
+#endif
+
 		return 0;
 	}
+#endif
 	case READ_CAPACITY:
 	{
-		int capacity;
+		u32 capacity;
 		char *cp;
 
 		dprintk((KERN_DEBUG "READ CAPACITY command.\n"));
-		capacity = fsa_dev_ptr->size[cid] - 1;
+		if (fsa_dev_ptr[cid].size <= 0x100000000ULL)
+			capacity = fsa_dev_ptr[cid].size - 1;
+		else
+			capacity = (u32)-1;
 		cp = scsicmd->request_buffer;
 		cp[0] = (capacity >> 24) & 0xff;
 		cp[1] = (capacity >> 16) & 0xff;
@@ -962,9 +2223,22 @@ int aac_scsi_cmd(struct scsi_cmnd * scsi
 		cp[5] = 0;
 		cp[6] = 2;
 		cp[7] = 0;
+#if (defined(AAC_DEBUG_INSTRUMENT_2TB))
+		printk(KERN_INFO "READ_CAPACITY: "
+		  "%02x %02x %02x %02x %02x %02x %02x %02x\n",
+		  cp[0] & 0xff, cp[1] & 0xff, cp[2] & 0xff, cp[3] & 0xff,
+		  cp[4] & 0xff, cp[5] & 0xff, cp[6] & 0xff, cp[7] & 0xff);
+#endif
+
+		/* Do not cache partition table for arrays */
+		scsicmd->device->removable = 1;
 
 		scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD;
+#if (defined(AAC_DEBUG_INSTRUMENT_TIMING))
 		__aac_io_done(scsicmd);
+#else
+		scsicmd->scsi_done(scsicmd);
+#endif
 
 		return 0;
 	}
@@ -981,7 +2255,11 @@ int aac_scsi_cmd(struct scsi_cmnd * scsi
 		mode_buf[3] = 0;	/* Block descriptor length */
 
 		scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD;
+#if (defined(AAC_DEBUG_INSTRUMENT_TIMING))
 		__aac_io_done(scsicmd);
+#else
+		scsicmd->scsi_done(scsicmd);
+#endif
 
 		return 0;
 	}
@@ -1001,27 +2279,39 @@ int aac_scsi_cmd(struct scsi_cmnd * scsi
 		mode_buf[7] = 0;	/* Block descriptor length (LSB) */
 
 		scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD;
+#if (defined(AAC_DEBUG_INSTRUMENT_TIMING))
 		__aac_io_done(scsicmd);
+#else
+		scsicmd->scsi_done(scsicmd);
+#endif
 
 		return 0;
 	}
 	case REQUEST_SENSE:
 		dprintk((KERN_DEBUG "REQUEST SENSE command.\n"));
-		memcpy(scsicmd->sense_buffer, &sense_data[cid], sizeof (struct sense_data));
-		memset(&sense_data[cid], 0, sizeof (struct sense_data));
+		memcpy(scsicmd->sense_buffer, &dev->fsa_dev[cid].sense_data, sizeof (struct sense_data));
+		memset(&dev->fsa_dev[cid].sense_data, 0, sizeof (struct sense_data));
 		scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD;
+#if (defined(AAC_DEBUG_INSTRUMENT_TIMING))
 		__aac_io_done(scsicmd);
+#else
+		scsicmd->scsi_done(scsicmd);
+#endif
 		return 0;
 
 	case ALLOW_MEDIUM_REMOVAL:
 		dprintk((KERN_DEBUG "LOCK command.\n"));
 		if (scsicmd->cmnd[4])
-			fsa_dev_ptr->locked[cid] = 1;
+			fsa_dev_ptr[cid].locked = 1;
 		else
-			fsa_dev_ptr->locked[cid] = 0;
+			fsa_dev_ptr[cid].locked = 0;
 
 		scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD;
+#if (defined(AAC_DEBUG_INSTRUMENT_TIMING))
 		__aac_io_done(scsicmd);
+#else
+		scsicmd->scsi_done(scsicmd);
+#endif
 		return 0;
 	/*
 	 *	These commands are all No-Ops
@@ -1034,7 +2324,11 @@ int aac_scsi_cmd(struct scsi_cmnd * scsi
 	case SEEK_10:
 	case START_STOP:
 		scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_GOOD;
+#if (defined(AAC_DEBUG_INSTRUMENT_TIMING))
 		__aac_io_done(scsicmd);
+#else
+		scsicmd->scsi_done(scsicmd);
+#endif
 		return 0;
 	}
 
@@ -1042,57 +2336,136 @@ int aac_scsi_cmd(struct scsi_cmnd * scsi
 	{
 		case READ_6:
 		case READ_10:
+		case READ_12:
+#if (defined(READ_16))
+		case READ_16:
+#endif
 			/*
 			 *	Hack to keep track of ordinal number of the device that
 			 *	corresponds to a container. Needed to convert
 			 *	containers to /dev/sd device names
 			 */
+#if ((LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)) && defined(AAC_EXTENDED_TIMEOUT))
+			if ((scsicmd->eh_state != SCSI_STATE_QUEUED)
+			 && (extendedtimeout > 0)) {
+				mod_timer(&scsicmd->eh_timeout, jiffies + (extendedtimeout * HZ));
+			}
+#endif
 			 
-			spin_unlock_irq(host->host_lock);
-			if  (scsicmd->request->rq_disk)
-				memcpy(fsa_dev_ptr->devname[cid],
-					scsicmd->request->rq_disk->disk_name,
-					8);
-
-			ret = aac_read(scsicmd, cid);
-			spin_lock_irq(host->host_lock);
-			return ret;
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
+#if (defined(AAC_DEBUG_INSTRUMENT_IOCTL))
+			if(fsa_dev_ptr[cid].devname[0]=='\0') {
+				printk(KERN_INFO
+				  "rq_disk=%p disk_name=\"%s\"\n",
+				  scsicmd->request->rq_disk,
+				  scsicmd->request->rq_disk
+				    ? scsicmd->request->rq_disk->disk_name
+				    : "Aiiiii");
+			}
+#endif
+			if (scsicmd->request->rq_disk)
+				strlcpy(fsa_dev_ptr[cid].devname,
+				  scsicmd->request->rq_disk->disk_name,
+				  min(
+				    sizeof(fsa_dev_ptr[cid].devname),
+				    sizeof(scsicmd->request->rq_disk->disk_name) + 1));
+#else
+			get_sd_devname(DEVICE_NR(scsicmd->request.rq_dev), fsa_dev_ptr[cid].devname);
+#endif
+
+			return aac_read(scsicmd, cid);
 
 		case WRITE_6:
 		case WRITE_10:
-			spin_unlock_irq(host->host_lock);
-			ret = aac_write(scsicmd, cid);
-			spin_lock_irq(host->host_lock);
-			return ret;
+		case WRITE_12:
+#if (defined(WRITE_16))
+		case WRITE_16:
+#endif
+#if ((LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)) && defined(AAC_EXTENDED_TIMEOUT))
+			if ((scsicmd->eh_state != SCSI_STATE_QUEUED)
+			 && (extendedtimeout > 0)) {
+				mod_timer(&scsicmd->eh_timeout, jiffies + (extendedtimeout * HZ));
+			}
+#endif
+			return aac_write(scsicmd, cid);
+
+		case SYNCHRONIZE_CACHE:
+			/* Issue FIB to tell Firmware to flush it's cache */
+			return aac_synchronize(scsicmd, cid);
+			
 		default:
 			/*
 			 *	Unhandled commands
 			 */
-			printk(KERN_WARNING "Unhandled SCSI Command: 0x%x.\n", scsicmd->cmnd[0]);
+			dprintk((KERN_WARNING "Unhandled SCSI Command: 0x%x.\n", scsicmd->cmnd[0]));
 			scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_CHECK_CONDITION;
-			set_sense((u8 *) &sense_data[cid],
+			set_sense((u8 *) &dev->fsa_dev[cid].sense_data,
 				ILLEGAL_REQUEST, SENCODE_INVALID_COMMAND,
-			ASENCODE_INVALID_COMMAND, 0, 0, 0, 0);
-			memcpy(scsicmd->sense_buffer, &sense_data[cid],
-				sizeof(struct sense_data));
+				ASENCODE_INVALID_COMMAND, 0, 0, 0, 0);
+			memcpy(scsicmd->sense_buffer, &dev->fsa_dev[cid].sense_data,
+			  (sizeof(dev->fsa_dev[cid].sense_data) > sizeof(scsicmd->sense_buffer))
+			    ? sizeof(scsicmd->sense_buffer)
+			    : sizeof(dev->fsa_dev[cid].sense_data));
+#if (defined(AAC_DEBUG_INSTRUMENT_TIMING))
 			__aac_io_done(scsicmd);
+#else
+			scsicmd->scsi_done(scsicmd);
+#endif
 			return 0;
 	}
 }
 
+static int busy_disk(struct aac_dev * dev, int cid)
+{
+	if ((dev != (struct aac_dev *)NULL)
+	 && (dev->scsi_host_ptr != (struct Scsi_Host *)NULL)) {
+		struct scsi_device *device;
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0))
+		shost_for_each_device(device, dev->scsi_host_ptr)
+#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
+		list_for_each_entry(device, &dev->scsi_host_ptr->my_devices, siblings)
+#else
+		for (device = dev->scsi_host_ptr->host_queue;
+		  device != (struct scsi_device *)NULL;
+		  device = device->next)
+#endif
+		{
+			if ((device->channel == CONTAINER_TO_CHANNEL(cid))
+			 && (device->id == CONTAINER_TO_ID(cid))
+			 && (device->lun == CONTAINER_TO_LUN(cid))
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)) && (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0))
+			 && (atomic_read(&device->access_count)
+			  || test_bit(SHOST_RECOVERY, &dev->scsi_host_ptr->shost_state))) {
+#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0))
+			&& (device->device_busy
+			  || test_bit(SHOST_RECOVERY, &dev->scsi_host_ptr->shost_state))) {
+#else
+			&& (device->access_count
+			  || dev->scsi_host_ptr->in_recovery)) {
+#endif
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0))
+				scsi_device_put(device);
+#endif
+				return 1;
+			}
+		}
+	}
+	return 0;
+}
+
 static int query_disk(struct aac_dev *dev, void __user *arg)
 {
 	struct aac_query_disk qd;
-	struct fsa_scsi_hba *fsa_dev_ptr;
+	struct fsa_dev_info *fsa_dev_ptr;
 
-	fsa_dev_ptr = &(dev->fsa_dev);
+	fsa_dev_ptr = dev->fsa_dev;
 	if (copy_from_user(&qd, arg, sizeof (struct aac_query_disk)))
 		return -EFAULT;
 	if (qd.cnum == -1)
 		qd.cnum = ID_LUN_TO_CONTAINER(qd.id, qd.lun);
 	else if ((qd.bus == -1) && (qd.id == -1) && (qd.lun == -1)) 
 	{
-		if (qd.cnum < 0 || qd.cnum >= MAXIMUM_NUM_CONTAINERS)
+		if (qd.cnum < 0 || qd.cnum >= dev->maximum_num_containers)
 			return -EINVAL;
 		qd.instance = dev->scsi_host_ptr->host_no;
 		qd.bus = 0;
@@ -1101,16 +2474,17 @@ static int query_disk(struct aac_dev *de
 	}
 	else return -EINVAL;
 
-	qd.valid = fsa_dev_ptr->valid[qd.cnum];
-	qd.locked = fsa_dev_ptr->locked[qd.cnum];
-	qd.deleted = fsa_dev_ptr->deleted[qd.cnum];
+	qd.valid = fsa_dev_ptr[qd.cnum].valid != 0;
+	qd.locked = fsa_dev_ptr[qd.cnum].locked || busy_disk(dev, qd.cnum);
+	qd.deleted = fsa_dev_ptr[qd.cnum].deleted;
 
-	if (fsa_dev_ptr->devname[qd.cnum][0] == '\0')
+	if (fsa_dev_ptr[qd.cnum].devname[0] == '\0')
 		qd.unmapped = 1;
 	else
 		qd.unmapped = 0;
 
-	strlcpy(qd.name, fsa_dev_ptr->devname[qd.cnum], sizeof(qd.name));
+	strlcpy(qd.name, fsa_dev_ptr[qd.cnum].devname,
+	  min(sizeof(qd.name), sizeof(fsa_dev_ptr[qd.cnum].devname) + 1));
 
 	if (copy_to_user(arg, &qd, sizeof (struct aac_query_disk)))
 		return -EFAULT;
@@ -1120,65 +2494,125 @@ static int query_disk(struct aac_dev *de
 static int force_delete_disk(struct aac_dev *dev, void __user *arg)
 {
 	struct aac_delete_disk dd;
-	struct fsa_scsi_hba *fsa_dev_ptr;
+	struct fsa_dev_info *fsa_dev_ptr;
 
-	fsa_dev_ptr = &(dev->fsa_dev);
+	fsa_dev_ptr = dev->fsa_dev;
 
 	if (copy_from_user(&dd, arg, sizeof (struct aac_delete_disk)))
 		return -EFAULT;
 
-	if (dd.cnum >= MAXIMUM_NUM_CONTAINERS)
+	if (dd.cnum >= dev->maximum_num_containers)
 		return -EINVAL;
 	/*
 	 *	Mark this container as being deleted.
 	 */
-	fsa_dev_ptr->deleted[dd.cnum] = 1;
+	fsa_dev_ptr[dd.cnum].deleted = 1;
 	/*
 	 *	Mark the container as no longer valid
 	 */
-	fsa_dev_ptr->valid[dd.cnum] = 0;
+	fsa_dev_ptr[dd.cnum].valid = 0;
 	return 0;
 }
 
 static int delete_disk(struct aac_dev *dev, void __user *arg)
 {
 	struct aac_delete_disk dd;
-	struct fsa_scsi_hba *fsa_dev_ptr;
+	struct fsa_dev_info *fsa_dev_ptr;
 
-	fsa_dev_ptr = &(dev->fsa_dev);
+	fsa_dev_ptr = dev->fsa_dev;
 
 	if (copy_from_user(&dd, arg, sizeof (struct aac_delete_disk)))
 		return -EFAULT;
 
-	if (dd.cnum >= MAXIMUM_NUM_CONTAINERS)
+	if (dd.cnum >= dev->maximum_num_containers)
 		return -EINVAL;
 	/*
 	 *	If the container is locked, it can not be deleted by the API.
 	 */
-	if (fsa_dev_ptr->locked[dd.cnum])
+	if (fsa_dev_ptr[dd.cnum].locked || busy_disk(dev, dd.cnum))
 		return -EBUSY;
 	else {
 		/*
 		 *	Mark the container as no longer being valid.
 		 */
-		fsa_dev_ptr->valid[dd.cnum] = 0;
-		fsa_dev_ptr->devname[dd.cnum][0] = '\0';
+		fsa_dev_ptr[dd.cnum].valid = 0;
+		fsa_dev_ptr[dd.cnum].devname[0] = '\0';
+		return 0;
+	}
+}
+
+#if (defined(FSACTL_REGISTER_FIB_SEND))
+static int aac_register_fib_send(struct aac_dev *dev, void *arg)
+{
+	fib_send_t callback;
+
+	if (arg == NULL) {
+		return -EINVAL;
+	}
+	callback = *((fib_send_t *)arg);
+	*((fib_send_t *)arg) = aac_fib_send;
+	if (callback == (fib_send_t)NULL) {
+		fib_send = aac_fib_send;
 		return 0;
 	}
+	if (fib_send != aac_fib_send) {
+		return -EBUSY;
+	}
+	fib_send = callback;
+	return 0;
 }
 
+#endif
 int aac_dev_ioctl(struct aac_dev *dev, int cmd, void __user *arg)
 {
+#if (defined(AAC_DEBUG_INSTRUMENT_IOCTL))
+	int retval;
+	if (cmd != FSACTL_GET_NEXT_ADAPTER_FIB)
+		printk("aac_dev_ioctl(%p,%x,%p)\n", dev, cmd, arg);
+#endif
 	switch (cmd) {
 	case FSACTL_QUERY_DISK:
+#if (defined(AAC_DEBUG_INSTRUMENT_IOCTL))
+		retval = query_disk(dev, arg);
+		printk("aac_dev_ioctl returns %d\n", retval);
+		return retval;
+#endif
 		return query_disk(dev, arg);
 	case FSACTL_DELETE_DISK:
+#if (defined(AAC_DEBUG_INSTRUMENT_IOCTL))
+		retval = delete_disk(dev, arg);
+		printk("aac_dev_ioctl returns %d\n", retval);
+		return retval;
+#endif
 		return delete_disk(dev, arg);
 	case FSACTL_FORCE_DELETE_DISK:
+#if (defined(AAC_DEBUG_INSTRUMENT_IOCTL))
+		retval = force_delete_disk(dev, arg);
+		printk("aac_dev_ioctl returns %d\n", retval);
+		return retval;
+#endif
 		return force_delete_disk(dev, arg);
 	case FSACTL_GET_CONTAINERS:
+#if (defined(AAC_DEBUG_INSTRUMENT_IOCTL))
+		retval = aac_get_containers(dev);
+		printk("aac_dev_ioctl returns %d\n", retval);
+		return retval;
+#endif
 		return aac_get_containers(dev);
+#if (defined(FSACTL_REGISTER_FIB_SEND))
+	case FSACTL_REGISTER_FIB_SEND:
+#if (defined(AAC_DEBUG_INSTRUMENT_IOCTL))
+		retval = aac_register_fib_send(dev, arg);
+		printk("aac_dev_ioctl returns %d\n", retval);
+		return retval;
+#endif
+		return aac_register_fib_send(dev, arg);
+#endif
 	default:
+#if (defined(AAC_DEBUG_INSTRUMENT_IOCTL))
+		printk("aac_dev_ioctl returns -ENOTTY\n");
+	case FSACTL_GET_NEXT_ADAPTER_FIB:
+#endif
 		return -ENOTTY;
 	}
 }
@@ -1212,7 +2646,8 @@ static void aac_srb_callback(void *conte
 	 *	Calculate resid for sg 
 	 */
 	 
-	scsicmd->resid = scsicmd->request_bufflen - srbreply->data_xfer_length;
+	scsicmd->resid = scsicmd->request_bufflen - 
+		le32_to_cpu(srbreply->data_xfer_length);
 
 	if(scsicmd->use_sg)
 		pci_unmap_sg(dev->pdev, 
@@ -1220,7 +2655,7 @@ static void aac_srb_callback(void *conte
 			scsicmd->use_sg,
 			scsicmd->sc_data_direction);
 	else if(scsicmd->request_bufflen)
-		pci_unmap_single(dev->pdev, (ulong)scsicmd->SCp.ptr, scsicmd->request_bufflen,
+		pci_unmap_single(dev->pdev, scsicmd->SCp.dma_handle, scsicmd->request_bufflen,
 			scsicmd->sc_data_direction);
 
 	/*
@@ -1230,8 +2665,10 @@ static void aac_srb_callback(void *conte
 	if (le32_to_cpu(srbreply->status) != ST_OK){
 		int len;
 		printk(KERN_WARNING "aac_srb_callback: srb failed, status = %d\n", le32_to_cpu(srbreply->status));
-		len = (srbreply->sense_data_size > sizeof(scsicmd->sense_buffer))?
-				sizeof(scsicmd->sense_buffer):srbreply->sense_data_size;
+		len = (le32_to_cpu(srbreply->sense_data_size) > 
+				sizeof(scsicmd->sense_buffer)) ?
+				sizeof(scsicmd->sense_buffer) : 
+				le32_to_cpu(srbreply->sense_data_size);
 		scsicmd->result = DID_ERROR << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_CHECK_CONDITION;
 		memcpy(scsicmd->sense_buffer, srbreply->sense_data, len);
 	}
@@ -1255,8 +2692,17 @@ static void aac_srb_callback(void *conte
 			if( b==TYPE_TAPE || b==TYPE_WORM || b==TYPE_ROM || b==TYPE_MOD|| b==TYPE_MEDIUM_CHANGER 
 					|| (b==TYPE_DISK && (b1&0x80)) ){
 				scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8;
+			/*
+			 * We will allow disk devices if in RAID/SCSI mode and
+			 * the channel is 2
+			 */
+			} else if ((dev->raid_scsi_mode) &&
+					(scsicmd->device->channel == 2)) {
+				scsicmd->result = DID_OK << 16 | 
+						COMMAND_COMPLETE << 8;
 			} else {
-				scsicmd->result = DID_NO_CONNECT << 16 | COMMAND_COMPLETE << 8;
+				scsicmd->result = DID_NO_CONNECT << 16 | 
+						COMMAND_COMPLETE << 8;
 			}
 		} else {
 			scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8;
@@ -1270,6 +2716,12 @@ static void aac_srb_callback(void *conte
 		case  WRITE_10:
 		case  READ_12:
 		case  WRITE_12:
+#if (defined(READ_16))
+		case  READ_16:
+#endif
+#if (defined(WRITE_16))
+		case  WRITE_16:
+#endif
 			if(le32_to_cpu(srbreply->data_xfer_length) < scsicmd->underflow ) {
 				printk(KERN_WARNING"aacraid: SCSI CMD underflow\n");
 			} else {
@@ -1288,8 +2740,17 @@ static void aac_srb_callback(void *conte
 			if( b==TYPE_TAPE || b==TYPE_WORM || b==TYPE_ROM || b==TYPE_MOD|| b==TYPE_MEDIUM_CHANGER
 					|| (b==TYPE_DISK && (b1&0x80)) ){
 				scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8;
+			/*
+			 * We will allow disk devices if in RAID/SCSI mode and
+			 * the channel is 2
+			 */
+			} else if ((dev->raid_scsi_mode) &&
+					(scsicmd->device->channel == 2)) {
+				scsicmd->result = DID_OK << 16 | 
+						COMMAND_COMPLETE << 8;
 			} else {
-				scsicmd->result = DID_NO_CONNECT << 16 | COMMAND_COMPLETE << 8;
+				scsicmd->result = DID_NO_CONNECT << 16 | 
+						COMMAND_COMPLETE << 8;
 			}
 			break;
 		}
@@ -1348,7 +2809,12 @@ static void aac_srb_callback(void *conte
 	case SRB_STATUS_DOMAIN_VALIDATION_FAIL:
 	default:
 #ifdef AAC_DETAILED_STATUS_INFO
-		printk("aacraid: SRB ERROR(%u) %s scsi cmd 0x%x - scsi status 0x%x\n",le32_to_cpu(srbreply->srb_status&0x3f),aac_get_status_string(le32_to_cpu(srbreply->srb_status)), scsicmd->cmnd[0], le32_to_cpu(srbreply->scsi_status) );
+		printk("aacraid: SRB ERROR(%u) %s scsi cmd 0x%x - scsi status 0x%x\n",
+			le32_to_cpu(srbreply->srb_status) & 0x3F,
+			aac_get_status_string(
+				le32_to_cpu(srbreply->srb_status) & 0x3F), 
+			scsicmd->cmnd[0], 
+			le32_to_cpu(srbreply->scsi_status));
 #endif
 		scsicmd->result = DID_ERROR << 16 | COMMAND_COMPLETE << 8;
 		break;
@@ -1356,9 +2822,14 @@ static void aac_srb_callback(void *conte
 	if (le32_to_cpu(srbreply->scsi_status) == 0x02 ){  // Check Condition
 		int len;
 		scsicmd->result |= SAM_STAT_CHECK_CONDITION;
-		len = (srbreply->sense_data_size > sizeof(scsicmd->sense_buffer))?
-				sizeof(scsicmd->sense_buffer):srbreply->sense_data_size;
-		dprintk((KERN_WARNING "aac_srb_callback: check condition, status = %d len=%d\n", le32_to_cpu(srbreply->status), len));
+		len = (le32_to_cpu(srbreply->sense_data_size) > 
+				sizeof(scsicmd->sense_buffer)) ?
+				sizeof(scsicmd->sense_buffer) :
+				le32_to_cpu(srbreply->sense_data_size);
+#ifdef AAC_DETAILED_STATUS_INFO
+		printk(KERN_WARNING "aac_srb_callback: check condition, status = %d len=%d\n",
+					le32_to_cpu(srbreply->status), len);
+#endif
 		memcpy(scsicmd->sense_buffer, srbreply->sense_data, len);
 		
 	}
@@ -1391,13 +2862,18 @@ static int aac_send_srb_fib(struct scsi_
 	u32 flag;
 	u32 timeout;
 
-	if( scsicmd->device->id > 15 || scsicmd->device->lun > 7) {
+	dev = (struct aac_dev *)scsicmd->device->host->hostdata;
+	if ((scsicmd->device->id >= dev->maximum_num_physicals)
+	 || (scsicmd->device->lun > 7)) {
 		scsicmd->result = DID_NO_CONNECT << 16;
+#if (defined(AAC_DEBUG_INSTRUMENT_TIMING))
 		__aac_io_done(scsicmd);
+#else
+		scsicmd->scsi_done(scsicmd);
+#endif
 		return 0;
 	}
 
-	dev = (struct aac_dev *)scsicmd->device->host->hostdata;
 	switch(scsicmd->sc_data_direction){
 	case DMA_TO_DEVICE:
 		flag = SRB_DataOut;
@@ -1434,10 +2910,10 @@ static int aac_send_srb_fib(struct scsi_
 		timeout = 1;
 	}
 	srbcmd->timeout  = cpu_to_le32(timeout);  // timeout in seconds
-	srbcmd->retry_limit =cpu_to_le32(0); // Obsolete parameter
+	srbcmd->retry_limit = 0; /* Obsolete parameter */
 	srbcmd->cdb_size = cpu_to_le32(scsicmd->cmd_len);
 	
-	if( dev->pae_support ==1 ) {
+	if( dev->dac_support == 1 ) {
 		aac_build_sg64(scsicmd, (struct sgmap64*) &srbcmd->sg);
 		srbcmd->count = cpu_to_le32(scsicmd->request_bufflen);
 
@@ -1446,13 +2922,19 @@ static int aac_send_srb_fib(struct scsi_
 		/*
 		 *	Build Scatter/Gather list
 		 */
-		fibsize = sizeof (struct aac_srb) + (((srbcmd->sg.count & 0xff) - 1) * sizeof (struct sgentry64));
+		fibsize = sizeof (struct aac_srb) - sizeof (struct sgentry) +
+			((le32_to_cpu(srbcmd->sg.count) & 0xff) * 
+			 sizeof (struct sgentry64));
+		BUG_ON (fibsize > (dev->max_fib_size -
+					sizeof(struct aac_fibhdr)));
 
 		/*
 		 *	Now send the Fib to the adapter
 		 */
-		status = fib_send(ScsiPortCommand64, cmd_fibcontext, fibsize, FsaNormal, 0, 1,
-				  (fib_callback) aac_srb_callback, (void *) scsicmd);
+		status = fib_send(ScsiPortCommand64, cmd_fibcontext, 
+				fibsize, FsaNormal, 0, 1,
+				  (fib_callback) aac_srb_callback, 
+				  (void *) scsicmd);
 	} else {
 		aac_build_sg(scsicmd, (struct sgmap*)&srbcmd->sg);
 		srbcmd->count = cpu_to_le32(scsicmd->request_bufflen);
@@ -1462,7 +2944,11 @@ static int aac_send_srb_fib(struct scsi_
 		/*
 		 *	Build Scatter/Gather list
 		 */
-		fibsize = sizeof (struct aac_srb) + (((srbcmd->sg.count & 0xff) - 1) * sizeof (struct sgentry));
+		fibsize = sizeof (struct aac_srb) + 
+			(((le32_to_cpu(srbcmd->sg.count) & 0xff) - 1) * 
+			 sizeof (struct sgentry));
+		BUG_ON (fibsize > (dev->max_fib_size -
+					sizeof(struct aac_fibhdr)));
 
 		/*
 		 *	Now send the Fib to the adapter
@@ -1478,43 +2964,198 @@ static int aac_send_srb_fib(struct scsi_
 	}
 
 	printk(KERN_WARNING "aac_srb: fib_send failed with status: %d\n", status);
+	scsicmd->result = DID_OK << 16 | COMMAND_COMPLETE << 8 | SAM_STAT_TASK_SET_FULL;
+	aac_io_done(scsicmd);
 	fib_complete(cmd_fibcontext);
 	fib_free(cmd_fibcontext);
 
-	return -1;
+	return 0;
 }
 
 static unsigned long aac_build_sg(struct scsi_cmnd* scsicmd, struct sgmap* psg)
 {
-	struct aac_dev *dev;
+	struct Scsi_Host *host = scsicmd->device->host;
+	struct aac_dev *dev = (struct aac_dev *)host->hostdata;
 	unsigned long byte_count = 0;
 
-	dev = (struct aac_dev *)scsicmd->device->host->hostdata;
 	// Get rid of old data
-	psg->count = cpu_to_le32(0);
-	psg->sg[0].addr = cpu_to_le32(0);
-	psg->sg[0].count = cpu_to_le32(0);  
+	psg->count = 0;
+	psg->sg[0].addr = 0;
+	psg->sg[0].count = 0;  
 	if (scsicmd->use_sg) {
 		struct scatterlist *sg;
 		int i;
-		int sg_count;
+		int sg_count, sg_count_hold;
 		sg = (struct scatterlist *) scsicmd->request_buffer;
 
-		sg_count = pci_map_sg(dev->pdev, sg, scsicmd->use_sg,
-			scsicmd->sc_data_direction);
+		sg_count_hold = sg_count = pci_map_sg(dev->pdev, sg,
+			scsicmd->use_sg, scsicmd->sc_data_direction);
+
+		for (i = 0; i < sg_count; i++) {
+			int count = sg_dma_len(sg);
+			u32 addr = sg_dma_address(sg);
+			if (host->max_sectors < AAC_MAX_32BIT_SGBCOUNT)
+			while (count > 65536) {
+				psg->sg[i].addr = cpu_to_le32(addr);
+				psg->sg[i].count = cpu_to_le32(65536);
+				++i;
+				if (++sg_count > host->sg_tablesize) {
+#if (defined(AAC_DEBUG_INSTRUMENT_SG))
+					printk(KERN_INFO
+					  "SG List[%d] too large based on original[%d]:\n",
+					  sg_count, sg_count_hold);
+					sg = (struct scatterlist *) scsicmd->request_buffer;
+					for (i = 0; i < sg_count_hold; i++) {
+						printk(KERN_INFO "0x%llx[%d] ",
+						  (u64)(sg_dma_address(sg)),
+						  (int)(sg_dma_len(sg)));
+						++sg;
+					}
+					printk(KERN_INFO "...\n");
+#endif
+					BUG();
+				}
+				byte_count += 65536;
+				addr += 65536;
+				count -= 65536;
+			}
+
+			psg->sg[i].addr = cpu_to_le32(addr);
+			psg->sg[i].count = cpu_to_le32(count);
+			byte_count += count;
+			sg++;
+		}
 		psg->count = cpu_to_le32(sg_count);
+		/* hba wants the size to be exact */
+		if(byte_count > scsicmd->request_bufflen){
+			u32 temp = le32_to_cpu(psg->sg[i-1].count) -
+				(byte_count - scsicmd->request_bufflen);
+			psg->sg[i-1].count = cpu_to_le32(temp);
+			byte_count = scsicmd->request_bufflen;
+		}
+		/* Check for command underflow */
+		if(scsicmd->underflow && (byte_count < scsicmd->underflow)){
+			printk(KERN_WARNING"aacraid: cmd len %08lX cmd underflow %08X\n",
+					byte_count, scsicmd->underflow);
+		}
+	}
+	else if(scsicmd->request_bufflen) {
+		int i, count;
+		u32 addr;
+		scsicmd->SCp.dma_handle = pci_map_single(dev->pdev,
+				scsicmd->request_buffer,
+				scsicmd->request_bufflen,
+				scsicmd->sc_data_direction);
+		addr = scsicmd->SCp.dma_handle;
+		count = scsicmd->request_bufflen;  
+		i = 0;
+		if (host->max_sectors < AAC_MAX_32BIT_SGBCOUNT)
+		while (count > 65536) {
+			psg->sg[i].addr = cpu_to_le32(addr);
+			psg->sg[i].count = cpu_to_le32(65536);
+			if (++i >= host->sg_tablesize) {
+#if (defined(AAC_DEBUG_INSTRUMENT_SG))
+				printk(KERN_INFO
+				  "SG List[%d] too large based on original single element %d in size\n",
+				  i, scsicmd->request_bufflen);
+#endif
+				BUG();
+			}
+			addr += 65536;
+			count -= 65536;
+		}
+		psg->count = cpu_to_le32(1+i);
+		psg->sg[i].addr = cpu_to_le32(addr);
+		psg->sg[i].count = cpu_to_le32(count);
+		byte_count = scsicmd->request_bufflen;
+	}
+#if (defined(AAC_DEBUG_INSTRUMENT_SG))
+{
+	int i, sg_count = le32_to_cpu(psg->count);
+	printk("aac_build_sg:");
+	for (i = 0; i < sg_count; i++) {
+		int count = le32_to_cpu(psg->sg[i].count);
+		u32 addr = le32_to_cpu(psg->sg[i].addr);
+		printk(" %x[%d]", addr, count);
+	}
+	printk ("\n");
+}
+#endif
+#if (defined(AAC_DEBUG_INSTRUMENT_AAC_CONFIG))
+	if (le32_to_cpu(psg->count) > aac_config.peak_sg) {
+		aac_config.peak_sg = le32_to_cpu(psg->count);
+		printk ("peak_sg=%u\n", aac_config.peak_sg);
+	}
+	if (byte_count > aac_config.peak_size) {
+		aac_config.peak_size = byte_count;
+		printk ("peak_size=%u\n", aac_config.peak_size);
+	}
+#endif
+	return byte_count;
+}
+
+
+static unsigned long aac_build_sg64(struct scsi_cmnd* scsicmd, struct sgmap64* psg)
+{
+	struct Scsi_Host *host = scsicmd->device->host;
+	struct aac_dev *dev = (struct aac_dev *)host->hostdata;
+	unsigned long byte_count = 0;
+
+	// Get rid of old data
+	psg->count = 0;
+	psg->sg[0].addr[0] = 0;
+	psg->sg[0].addr[1] = 0;
+	psg->sg[0].count = 0;
+	if (scsicmd->use_sg) {
+		struct scatterlist *sg;
+		int i;
+		int sg_count, sg_count_hold;
+		sg = (struct scatterlist *) scsicmd->request_buffer;
 
-		byte_count = 0;
+		sg_count_hold = sg_count = pci_map_sg(dev->pdev, sg,
+			scsicmd->use_sg, scsicmd->sc_data_direction);
 
 		for (i = 0; i < sg_count; i++) {
-			psg->sg[i].addr = cpu_to_le32(sg_dma_address(sg));
-			psg->sg[i].count = cpu_to_le32(sg_dma_len(sg));
-			byte_count += sg_dma_len(sg);
+			int count = sg_dma_len(sg);
+			u64 addr = sg_dma_address(sg);
+			if (host->max_sectors < AAC_MAX_32BIT_SGBCOUNT)
+			while (count > 65536) {
+				psg->sg[i].addr[1] = cpu_to_le32((u32)(addr>>32));
+				psg->sg[i].addr[0] = cpu_to_le32((u32)(addr & 0xffffffff));
+				psg->sg[i].count = cpu_to_le32(65536);
+				++i;
+				if (++sg_count > host->sg_tablesize) {
+#if (defined(AAC_DEBUG_INSTRUMENT_SG))
+					printk(KERN_INFO
+					  "SG List[%d] too large based on original[%d]:\n",
+					  sg_count, sg_count_hold);
+					sg = (struct scatterlist *) scsicmd->request_buffer;
+					for (i = 0; i < sg_count_hold; i++) {
+						printk(KERN_INFO "0x%llx[%d] ",
+						  (u64)sg_dma_address(sg),
+						  (int)sg_dma_len(sg));
+						++sg;
+					}
+					printk(KERN_INFO "...\n");
+#endif
+					BUG();
+				}
+				byte_count += 65536;
+				addr += 65536;
+				count -= 65536;
+			}
+			psg->sg[i].addr[0] = cpu_to_le32(addr & 0xffffffff);
+			psg->sg[i].addr[1] = cpu_to_le32(addr>>32);
+			psg->sg[i].count = cpu_to_le32(count);
+			byte_count += count;
 			sg++;
 		}
+		psg->count = cpu_to_le32(sg_count);
 		/* hba wants the size to be exact */
 		if(byte_count > scsicmd->request_bufflen){
-			psg->sg[i-1].count -= (byte_count - scsicmd->request_bufflen);
+			u32 temp = le32_to_cpu(psg->sg[i-1].count) -
+				 (byte_count - scsicmd->request_bufflen);
+			psg->sg[i-1].count = cpu_to_le32(temp);
 			byte_count = scsicmd->request_bufflen;
 		}
 		/* Check for command underflow */
@@ -1524,33 +3165,81 @@ static unsigned long aac_build_sg(struct
 		}
 	}
 	else if(scsicmd->request_bufflen) {
-		dma_addr_t addr; 
-		addr = pci_map_single(dev->pdev,
+		int i, count;
+		u64 addr;
+		scsicmd->SCp.dma_handle = pci_map_single(dev->pdev,
 				scsicmd->request_buffer,
 				scsicmd->request_bufflen,
 				scsicmd->sc_data_direction);
-		psg->count = cpu_to_le32(1);
-		psg->sg[0].addr = cpu_to_le32(addr);
-		psg->sg[0].count = cpu_to_le32(scsicmd->request_bufflen);  
-		scsicmd->SCp.ptr = (char *)(ulong)addr;
+		addr = scsicmd->SCp.dma_handle;
+		count = scsicmd->request_bufflen;  
+		i = 0;
+		if (host->max_sectors < AAC_MAX_32BIT_SGBCOUNT)
+		while (count > 65536) {
+			psg->sg[i].addr[1] = cpu_to_le32((u32)(addr>>32));
+			psg->sg[i].addr[0] = cpu_to_le32((u32)(addr & 0xffffffff));
+			psg->sg[i].count = cpu_to_le32(65536);
+			if (++i >= host->sg_tablesize) {
+#if (defined(AAC_DEBUG_INSTRUMENT_SG))
+				printk(KERN_INFO
+				  "SG List[%d] too large based on original single element %d in size\n",
+				  i, scsicmd->request_bufflen);
+#endif
+				BUG();
+			}
+			addr += 65536;
+			count -= 65536;
+		}
+		psg->count = cpu_to_le32(1+i);
+		psg->sg[i].addr[0] = cpu_to_le32(addr & 0xffffffff);
+		psg->sg[i].addr[1] = cpu_to_le32(addr>>32);
+		psg->sg[i].count = cpu_to_le32(count);
 		byte_count = scsicmd->request_bufflen;
 	}
+#if (defined(AAC_DEBUG_INSTRUMENT_SG))
+{
+	int i, sg_count = le32_to_cpu(psg->count);
+	printk("aac_build_sg64:");
+	for (i = 0; i < sg_count; i++) {
+		int count = le32_to_cpu(psg->sg[i].count);
+		u32 addr0 = le32_to_cpu(psg->sg[i].addr[0]);
+		u32 addr1 = le32_to_cpu(psg->sg[i].addr[1]);
+		if (addr1 == 0)
+			printk(" %x[%d]", addr0, count);
+		else
+			printk(" %x%08x[%d]", addr1, addr0, count);
+	}
+	printk ("\n");
+}
+#endif
+#if (defined(AAC_DEBUG_INSTRUMENT_AAC_CONFIG))
+	if (le32_to_cpu(psg->count) > aac_config.peak_sg) {
+		aac_config.peak_sg = le32_to_cpu(psg->count);
+		printk ("peak_sg=%u\n", aac_config.peak_sg);
+	}
+	if (byte_count > aac_config.peak_size) {
+		aac_config.peak_size = byte_count;
+		printk ("peak_size=%u\n", aac_config.peak_size);
+	}
+#endif
 	return byte_count;
 }
 
 
-static unsigned long aac_build_sg64(struct scsi_cmnd* scsicmd, struct sgmap64* psg)
+static unsigned long aac_build_sgraw(struct scsi_cmnd* scsicmd, struct sgmapraw* psg)
 {
-	struct aac_dev *dev;
+	struct Scsi_Host *host = scsicmd->device->host;
+	struct aac_dev *dev = (struct aac_dev *)host->hostdata;
 	unsigned long byte_count = 0;
-	u64 le_addr;
 
-	dev = (struct aac_dev *)scsicmd->device->host->hostdata;
 	// Get rid of old data
-	psg->count = cpu_to_le32(0);
-	psg->sg[0].addr[0] = cpu_to_le32(0);
-	psg->sg[0].addr[1] = cpu_to_le32(0);
-	psg->sg[0].count = cpu_to_le32(0);  
+	psg->count = 0;
+	psg->sg[0].next = 0;
+	psg->sg[0].prev = 0;
+	psg->sg[0].addr[0] = 0;
+	psg->sg[0].addr[1] = 0;
+	psg->sg[0].count = 0;
+	psg->sg[0].flags = 0;
 	if (scsicmd->use_sg) {
 		struct scatterlist *sg;
 		int i;
@@ -1559,18 +3248,20 @@ static unsigned long aac_build_sg64(stru
 
 		sg_count = pci_map_sg(dev->pdev, sg, scsicmd->use_sg,
 			scsicmd->sc_data_direction);
-		psg->count = cpu_to_le32(sg_count);
-
-		byte_count = 0;
 
 		for (i = 0; i < sg_count; i++) {
-			le_addr = cpu_to_le64(sg_dma_address(sg));
-			psg->sg[i].addr[1] = (u32)(le_addr>>32);
-			psg->sg[i].addr[0] = (u32)(le_addr & 0xffffffff);
-			psg->sg[i].count = cpu_to_le32(sg_dma_len(sg));
-			byte_count += sg_dma_len(sg);
+			int count = sg_dma_len(sg);
+			u64 addr = sg_dma_address(sg);
+			psg->sg[i].next = 0;
+			psg->sg[i].prev = 0;
+			psg->sg[i].addr[1] = cpu_to_le32((u32)(addr>>32));
+			psg->sg[i].addr[0] = cpu_to_le32((u32)(addr & 0xffffffff));
+			psg->sg[i].count = cpu_to_le32(count);
+			psg->sg[i].flags = 0;
+			byte_count += count;
 			sg++;
 		}
+		psg->count = cpu_to_le32(sg_count);
 		/* hba wants the size to be exact */
 		if(byte_count > scsicmd->request_bufflen){
 			psg->sg[i-1].count -= (byte_count - scsicmd->request_bufflen);
@@ -1583,19 +3274,33 @@ static unsigned long aac_build_sg64(stru
 		}
 	}
 	else if(scsicmd->request_bufflen) {
-		dma_addr_t addr; 
-		addr = pci_map_single(dev->pdev,
+		int count;
+		u64 addr;
+		scsicmd->SCp.dma_handle = pci_map_single(dev->pdev,
 				scsicmd->request_buffer,
 				scsicmd->request_bufflen,
 				scsicmd->sc_data_direction);
+		addr = scsicmd->SCp.dma_handle;
+		count = scsicmd->request_bufflen;
 		psg->count = cpu_to_le32(1);
-		le_addr = cpu_to_le64(addr);
-		psg->sg[0].addr[1] = (u32)(le_addr>>32);
-		psg->sg[0].addr[0] = (u32)(le_addr & 0xffffffff);
-		psg->sg[0].count = cpu_to_le32(scsicmd->request_bufflen);  
-		scsicmd->SCp.ptr = (char *)(ulong)addr;
+		psg->sg[0].next = 0;
+		psg->sg[0].prev = 0;
+		psg->sg[0].addr[1] = cpu_to_le32((u32)(addr>>32));
+		psg->sg[0].addr[0] = cpu_to_le32((u32)(addr & 0xffffffff));
+		psg->sg[0].count = cpu_to_le32(count);
+		psg->sg[0].flags = 0;
 		byte_count = scsicmd->request_bufflen;
 	}
+#if (defined(AAC_DEBUG_INSTRUMENT_AAC_CONFIG))
+	if (le32_to_cpu(psg->count) > aac_config.peak_sg) {
+		aac_config.peak_sg = le32_to_cpu(psg->count);
+		printk ("peak_sg=%u\n", aac_config.peak_sg);
+	}
+	if (byte_count > aac_config.peak_size) {
+		aac_config.peak_size = byte_count;
+		printk ("peak_size=%u\n", aac_config.peak_size);
+	}
+#endif
 	return byte_count;
 }
 
--- linux-2.6.8.1-t043-libata-update/drivers/scsi/aacraid/sa.c	2005-09-26 13:33:12.000000000 +0400
+++ aacraid-drv/drivers/scsi/aacraid/sa.c	2005-04-27 16:49:12.000000000 +0400
@@ -40,9 +40,22 @@
 #include <linux/completion.h>
 #include <linux/time.h>
 #include <linux/interrupt.h>
+#include <linux/version.h>	/* Needed for the following */
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,4,23))
+#if (!defined(IRQ_NONE))
+  typedef void irqreturn_t;
+# define IRQ_HANDLED
+# define IRQ_NONE
+#endif
+#endif
 #include <asm/semaphore.h>
 
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0))
+#include "scsi.h"
+#include "hosts.h"
+#else
 #include <scsi/scsi_host.h>
+#endif
 
 #include "aacraid.h"
 
@@ -62,15 +75,15 @@ static irqreturn_t aac_sa_intr(int irq, 
 
 	if (intstat & mask) {
 		if (intstat & PrintfReady) {
-			aac_printf(dev, le32_to_cpu(sa_readl(dev, Mailbox5)));
+			aac_printf(dev, sa_readl(dev, Mailbox5));
 			sa_writew(dev, DoorbellClrReg_p, PrintfReady); /* clear PrintfReady */
 			sa_writew(dev, DoorbellReg_s, PrintfDone);
 		} else if (intstat & DOORBELL_1) {	// dev -> Host Normal Command Ready
-			aac_command_normal(&dev->queues->queue[HostNormCmdQueue]);
 			sa_writew(dev, DoorbellClrReg_p, DOORBELL_1);
+			aac_command_normal(&dev->queues->queue[HostNormCmdQueue]);
 		} else if (intstat & DOORBELL_2) {	// dev -> Host Normal Response Ready
-			aac_response_normal(&dev->queues->queue[HostNormRespQueue]);
 			sa_writew(dev, DoorbellClrReg_p, DOORBELL_2);
+			aac_response_normal(&dev->queues->queue[HostNormRespQueue]);
 		} else if (intstat & DOORBELL_3) {	// dev -> Host Normal Command Not Full
 			sa_writew(dev, DoorbellClrReg_p, DOORBELL_3);
 		} else if (intstat & DOORBELL_4) {	// dev -> Host Normal Response Not Full
@@ -82,65 +95,13 @@ static irqreturn_t aac_sa_intr(int irq, 
 }
 
 /**
- *	aac_sa_enable_interrupt	-	enable an interrupt event
- *	@dev: Which adapter to enable.
- *	@event: Which adapter event.
- *
- *	This routine will enable the corresponding adapter event to cause an interrupt on 
- * 	the host.
- */
- 
-void aac_sa_enable_interrupt(struct aac_dev *dev, u32 event)
-{
-	switch (event) {
-
-	case HostNormCmdQue:
-		sa_writew(dev, SaDbCSR.PRICLEARIRQMASK, DOORBELL_1);
-		break;
-
-	case HostNormRespQue:
-		sa_writew(dev, SaDbCSR.PRICLEARIRQMASK, DOORBELL_2);
-		break;
-
-	case AdapNormCmdNotFull:
-		sa_writew(dev, SaDbCSR.PRICLEARIRQMASK, DOORBELL_3);
-		break;
-
-	case AdapNormRespNotFull:
-		sa_writew(dev, SaDbCSR.PRICLEARIRQMASK, DOORBELL_4);
-		break;
-	}
-}
-
-/**
- *	aac_sa_disable_interrupt	-	disable an interrupt event
+ *	aac_sa_disable_interrupt	-	disable interrupt
  *	@dev: Which adapter to enable.
- *	@event: Which adapter event.
- *
- *	This routine will enable the corresponding adapter event to cause an interrupt on 
- * 	the host.
  */
 
-void aac_sa_disable_interrupt (struct aac_dev *dev, u32 event)
+void aac_sa_disable_interrupt (struct aac_dev *dev)
 {
-	switch (event) {
-
-	case HostNormCmdQue:
-		sa_writew(dev, SaDbCSR.PRISETIRQMASK, DOORBELL_1);
-		break;
-
-	case HostNormRespQue:
-		sa_writew(dev, SaDbCSR.PRISETIRQMASK, DOORBELL_2);
-		break;
-
-	case AdapNormCmdNotFull:
-		sa_writew(dev, SaDbCSR.PRISETIRQMASK, DOORBELL_3);
-		break;
-
-	case AdapNormRespNotFull:
-		sa_writew(dev, SaDbCSR.PRISETIRQMASK, DOORBELL_4);
-		break;
-	}
+	sa_writew(dev, SaDbCSR.PRISETIRQMASK, cpu_to_le16(0xffff));
 }
 
 /**
@@ -151,7 +112,7 @@ void aac_sa_disable_interrupt (struct aa
  *	Notify the adapter of an event
  */
  
-void aac_sa_notify_adapter(struct aac_dev *dev, u32 event)
+static void aac_sa_notify_adapter(struct aac_dev *dev, u32 event)
 {
 	switch (event) {
 
@@ -168,7 +129,8 @@ void aac_sa_notify_adapter(struct aac_de
 		sa_writew(dev, DoorbellReg_s,DOORBELL_3);
 		break;
 	case HostShutdown:
-		//sa_sync_cmd(dev, HOST_CRASHING, 0, &ret);
+		//sa_sync_cmd(dev, HOST_CRASHING, 0, 0, 0, 0, 0, 0,
+		//  NULL, NULL, NULL, NULL, NULL);
 		break;
 	case FastIo:
 		sa_writew(dev, DoorbellReg_s,DOORBELL_6);
@@ -190,25 +152,31 @@ void aac_sa_notify_adapter(struct aac_de
  *	@p1: first parameter
  *	@ret: adapter status
  *
- *	This routine will send a synchronous comamnd to the adapter and wait 
+ *	This routine will send a synchronous command to the adapter and wait 
  *	for its	completion.
  */
 
-static int sa_sync_cmd(struct aac_dev *dev, u32 command, u32 p1, u32 *ret)
+static int sa_sync_cmd(struct aac_dev *dev, u32 command,
+	u32 p1, u32 p2, u32 p3, u32 p4, u32 p5, u32 p6,
+	u32 *ret, u32 * r1, u32 * r2, u32 * r3, u32 * r4)
 {
 	unsigned long start;
  	int ok;
 	/*
 	 *	Write the Command into Mailbox 0
 	 */
-	sa_writel(dev, Mailbox0, cpu_to_le32(command));
+	sa_writel(dev, Mailbox0, command);
 	/*
 	 *	Write the parameters into Mailboxes 1 - 4
 	 */
-	sa_writel(dev, Mailbox1, cpu_to_le32(p1));
-	sa_writel(dev, Mailbox2, 0);
-	sa_writel(dev, Mailbox3, 0);
-	sa_writel(dev, Mailbox4, 0);
+	sa_writel(dev, Mailbox1, p1);
+	sa_writel(dev, Mailbox2, p2);
+	sa_writel(dev, Mailbox3, p3);
+	sa_writel(dev, Mailbox4, p4);
+#if (defined(AAC_LM_SENSOR))
+	sa_writel(dev, Mailbox5, p5);
+	sa_writel(dev, Mailbox6, p6);
+#endif
 	/*
 	 *	Clear the synch command doorbell to start on a clean slate.
 	 */
@@ -248,7 +216,16 @@ static int sa_sync_cmd(struct aac_dev *d
 	/*
 	 *	Pull the synch status from Mailbox 0.
 	 */
-	*ret = le32_to_cpu(sa_readl(dev, Mailbox0));
+	if (ret)
+		*ret = sa_readl(dev, Mailbox0);
+	if (r1)
+		*r1 = sa_readl(dev, Mailbox1);
+	if (r2)
+		*r2 = sa_readl(dev, Mailbox2);
+	if (r3)
+		*r3 = sa_readl(dev, Mailbox3);
+	if (r4)
+		*r4 = sa_readl(dev, Mailbox4);
 	return 0;
 }
 
@@ -261,8 +238,8 @@ static int sa_sync_cmd(struct aac_dev *d
  
 static void aac_sa_interrupt_adapter (struct aac_dev *dev)
 {
-	u32 ret;
-	sa_sync_cmd(dev, BREAKPOINT_REQUEST, 0, &ret);
+	sa_sync_cmd(dev, BREAKPOINT_REQUEST, 0, 0, 0, 0, 0, 0,
+	  NULL, NULL, NULL, NULL, NULL);
 }
 
 /**
@@ -274,30 +251,15 @@ static void aac_sa_interrupt_adapter (st
 
 static void aac_sa_start_adapter(struct aac_dev *dev)
 {
-	u32 ret;
 	struct aac_init *init;
 	/*
 	 * Fill in the remaining pieces of the init.
 	 */
 	init = dev->init;
-	init->HostElapsedSeconds = cpu_to_le32(jiffies/HZ);
-
-	dprintk(("INIT\n"));
-	/*
-	 * Tell the adapter we are back and up and running so it will scan its command
-	 * queues and enable our interrupts
-	 */
-	dev->irq_mask =	(PrintfReady | DOORBELL_1 | DOORBELL_2 | DOORBELL_3 | DOORBELL_4);
-	/*
-	 *	First clear out all interrupts.  Then enable the one's that 
-	 *	we can handle.
-	 */
-	dprintk(("MASK\n"));
-	sa_writew(dev, SaDbCSR.PRISETIRQMASK, cpu_to_le16(0xffff));
-	sa_writew(dev, SaDbCSR.PRICLEARIRQMASK, (PrintfReady | DOORBELL_1 | DOORBELL_2 | DOORBELL_3 | DOORBELL_4));
-	dprintk(("SYNCCMD\n"));
+	init->HostElapsedSeconds = cpu_to_le32(get_seconds());
 	/* We can only use a 32 bit address here */
-	sa_sync_cmd(dev, INIT_STRUCT_BASE_ADDRESS, (u32)(ulong)dev->init_pa, &ret);
+	sa_sync_cmd(dev, INIT_STRUCT_BASE_ADDRESS, (u32)(ulong)dev->init_pa,
+	  0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL);
 }
 
 /**
@@ -348,21 +310,10 @@ int aac_sa_init(struct aac_dev *dev)
 	int instance;
 	const char *name;
 
-	dprintk(("PREINST\n"));
 	instance = dev->id;
 	name     = dev->name;
 
 	/*
-	 *	Map in the registers from the adapter.
-	 */
-	dprintk(("PREMAP\n"));
-
-	if((dev->regs.sa = (struct sa_registers *)ioremap((unsigned long)dev->scsi_host_ptr->base, 8192))==NULL)
-	{	
-		printk(KERN_WARNING "aacraid: unable to map ARM.\n" );
-		goto error_iounmap;
-	}
-	/*
 	 *	Check to see if the board failed any self tests.
 	 */
 	if (sa_readl(dev, Mailbox7) & SELF_TEST_FAILED) {
@@ -382,15 +333,15 @@ int aac_sa_init(struct aac_dev *dev)
 	 */
 	while (!(sa_readl(dev, Mailbox7) & KERNEL_UP_AND_RUNNING)) {
 		if (time_after(jiffies, start+180*HZ)) {
-			status = sa_readl(dev, Mailbox7) >> 16;
-			printk(KERN_WARNING "%s%d: adapter kernel failed to start, init status = %d.\n", name, instance, le32_to_cpu(status));
+			status = sa_readl(dev, Mailbox7);
+			printk(KERN_WARNING "%s%d: adapter kernel failed to start, init status = %lx.\n", 
+					name, instance, status);
 			goto error_iounmap;
 		}
 		set_current_state(TASK_UNINTERRUPTIBLE);
 		schedule_timeout(1);
 	}
 
-	dprintk(("ATIRQ\n"));
 	if (request_irq(dev->scsi_host_ptr->irq, aac_sa_intr, SA_SHIRQ|SA_INTERRUPT, "aacraid", (void *)dev ) < 0) {
 		printk(KERN_WARNING "%s%d: Interrupt unavailable.\n", name, instance);
 		goto error_iounmap;
@@ -401,18 +352,24 @@ int aac_sa_init(struct aac_dev *dev)
 	 */
 
 	dev->a_ops.adapter_interrupt = aac_sa_interrupt_adapter;
-	dev->a_ops.adapter_enable_int = aac_sa_enable_interrupt;
 	dev->a_ops.adapter_disable_int = aac_sa_disable_interrupt;
 	dev->a_ops.adapter_notify = aac_sa_notify_adapter;
 	dev->a_ops.adapter_sync_cmd = sa_sync_cmd;
 	dev->a_ops.adapter_check_health = aac_sa_check_health;
+#if (defined(SCSI_HAS_DUMP))
+	dev->a_ops.adapter_intr = aac_sa_intr;
+#endif
 
-	dprintk(("FUNCDONE\n"));
+	/*
+	 *	First clear out all interrupts.  Then enable the one's that 
+	 *	we can handle.
+	 */
+	sa_writew(dev, SaDbCSR.PRISETIRQMASK, cpu_to_le16(0xffff));
+	sa_writew(dev, SaDbCSR.PRICLEARIRQMASK, (PrintfReady | DOORBELL_1 | DOORBELL_2 | DOORBELL_3 | DOORBELL_4));
 
 	if(aac_init_adapter(dev) == NULL)
 		goto error_irq;
 
-	dprintk(("NEWADAPTDONE\n"));
 	/*
 	 *	Start any kernel threads needed
 	 */
@@ -426,9 +383,7 @@ int aac_sa_init(struct aac_dev *dev)
 	 *	Tell the adapter that all is configure, and it can start 
 	 *	accepting requests
 	 */
-	dprintk(("STARTING\n"));
 	aac_sa_start_adapter(dev);
-	dprintk(("STARTED\n"));
 	return 0;
 
 
@@ -436,10 +391,10 @@ error_kfree:
 	kfree(dev->queues);
 
 error_irq:
+	sa_writew(dev, SaDbCSR.PRISETIRQMASK, cpu_to_le16(0xffff));
 	free_irq(dev->scsi_host_ptr->irq, (void *)dev);
 
 error_iounmap:
-	iounmap(dev->regs.sa);
 
 	return -1;
 }
--- linux-2.6.8.1-t043-libata-update/drivers/scsi/aacraid/fwdebug.h	1970-01-01 03:00:00.000000000 +0300
+++ aacraid-drv/drivers/scsi/aacraid/fwdebug.h	2004-09-30 21:31:02.000000000 +0400
@@ -0,0 +1,51 @@
+/*
+ *	Adaptec AAC series RAID controller driver
+ *
+ * Copyright (c) 2004 Adaptec, Inc. (aacraid@adaptec.com)
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+
+#ifndef PRINT_BUFFER_SIZE
+
+#define PRINT_BUFFER_SIZE     512       /* Debugging print buffer size */
+
+#define HBA_FLAGS_DBG_FLAGS_MASK         0x0000ffff  /* Mask for debug flags */
+#define HBA_FLAGS_DBG_KERNEL_PRINT_B     0x00000001  /* Kernel Debugger Print */
+#define HBA_FLAGS_DBG_FW_PRINT_B         0x00000002  /* Firmware Debugger Print */
+#define HBA_FLAGS_DBG_FUNCTION_ENTRY_B   0x00000004  /* Function Entry Point */
+#define HBA_FLAGS_DBG_FUNCTION_EXIT_B    0x00000008  /* Function Exit */
+#define HBA_FLAGS_DBG_ERROR_B            0x00000010  /* Error Conditions */
+#define HBA_FLAGS_DBG_INIT_B             0x00000020  /* Init Prints */
+#define HBA_FLAGS_DBG_OS_COMMANDS_B      0x00000040  /* OS Command Info */
+#define HBA_FLAGS_DBG_SCAN_B             0x00000080  /* Device Scan */
+#define HBA_FLAGS_DBG_COALESCE_B         0x00000100  /* Coalescing Queueing flags */
+#define HBA_FLAGS_DBG_IOCTL_COMMANDS_B   0x00000200  /* IOCTL Command Info */
+#define HBA_FLAGS_DBG_SYNC_COMMANDS_B    0x00000400  /* SYNC Command Info */
+#define HBA_FLAGS_DBG_COMM_B             0x00000800  /* Comm Info */
+#define HBA_FLAGS_DBG_CSMI_COMMANDS_B    0x00001000  /* CSMI Command Info */
+#define HBA_FLAGS_DBG_AIF_B              0x00001000  /* Aif Info */
+
+#define FW_DEBUG_STR_LENGTH_OFFSET       0x00
+#define FW_DEBUG_FLAGS_OFFSET            0x04
+#define FW_DEBUG_BLED_OFFSET             0x08
+#define FW_DEBUG_FLAGS_NO_HEADERS_B      0x01 
+
+int aac_get_fw_debug_buffer(struct aac_dev *);
+void aac_fw_printf(struct aac_dev *, unsigned long, const char *, ...);
+void aac_fw_print_mem(struct aac_dev *, unsigned long, u8 *, int);
+
+#endif
--- linux-2.6.8.1-t043-libata-update/drivers/scsi/aacraid/comminit.c	2005-09-26 13:33:12.000000000 +0400
+++ aacraid-drv/drivers/scsi/aacraid/comminit.c	2005-04-27 16:42:06.000000000 +0400
@@ -41,22 +41,43 @@
 #include <linux/mm.h>
 #include <asm/semaphore.h>
 
+#include <linux/version.h>	/* Needed for the following */
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
+#include <scsi/scsi.h>
+#include <scsi/scsi_host.h>
+#else
+#include "scsi.h"
+#include "hosts.h"
+#endif
+
 #include "aacraid.h"
 
-struct aac_common aac_config;
+struct aac_common aac_config = {
+	.irq_mod = 1
+};
 
 static int aac_alloc_comm(struct aac_dev *dev, void **commaddr, unsigned long commsize, unsigned long commalign)
 {
 	unsigned char *base;
 	unsigned long size, align;
-	unsigned long fibsize = 4096;
-	unsigned long printfbufsiz = 256;
+	const unsigned long fibsize = 4096;
+	const unsigned long printfbufsiz = 256;
 	struct aac_init *init;
 	dma_addr_t phys;
 
 	size = fibsize + sizeof(struct aac_init) + commsize + commalign + printfbufsiz;
 
- 
+#if 0 && (defined(CONFIG_X86) || defined(CONFIG_X86_64))
+	base = kmalloc(size, GFP_ATOMIC|GFP_KERNEL);
+	if (base) {
+		phys = pci_map_single(dev->pdev, base, size, DMA_BIDIRECTIONAL);
+		if (phys > (0x80000000UL - size)) {
+			kfree(base);
+			base = NULL;
+		}
+	}
+	if (base == NULL)
+#endif
 	base = pci_alloc_consistent(dev->pdev, size, &phys);
 
 	if(base == NULL)
@@ -74,6 +95,8 @@ static int aac_alloc_comm(struct aac_dev
 	init = dev->init;
 
 	init->InitStructRevision = cpu_to_le32(ADAPTER_INIT_STRUCT_REVISION);
+	if (dev->max_fib_size != sizeof(struct hw_fib))
+		init->InitStructRevision = cpu_to_le32(ADAPTER_INIT_STRUCT_REVISION_4);
 	init->MiniPortRevision = cpu_to_le32(Sa_MINIPORT_REVISION);
 	init->fsrev = cpu_to_le32(dev->fsrev);
 
@@ -83,7 +106,7 @@ static int aac_alloc_comm(struct aac_dev
 	 */
 	dev->aif_base_va = (struct hw_fib *)base;
 	
-	init->AdapterFibsVirtualAddress = cpu_to_le32(0);
+	init->AdapterFibsVirtualAddress = 0;
 	init->AdapterFibsPhysicalAddress = cpu_to_le32((u32)phys);
 	init->AdapterFibsSize = cpu_to_le32(fibsize);
 	init->AdapterFibAlign = cpu_to_le32(sizeof(struct hw_fib));
@@ -110,6 +133,14 @@ static int aac_alloc_comm(struct aac_dev
 		init->HostPhysMemPages = cpu_to_le32(AAC_MAX_HOSTPHYSMEMPAGES);
 	}
 
+	init->InitFlags = 0;
+	if (dev->new_comm_interface) {
+		init->InitFlags = cpu_to_le32(INITFLAGS_NEW_COMM_SUPPORTED);
+		dprintk((KERN_WARNING"aacraid: New Comm Interface enabled\n"));
+	}
+	init->MaxIoCommands = cpu_to_le32(dev->scsi_host_ptr->can_queue + AAC_NUM_MGT_FIB);
+	init->MaxIoSize = cpu_to_le32(dev->scsi_host_ptr->max_sectors << 9);
+	init->MaxFibSize = cpu_to_le32(dev->max_fib_size);
 
 	/*
 	 * Increment the base address by the amount already used
@@ -152,8 +183,8 @@ static void aac_queue_init(struct aac_de
 	init_waitqueue_head(&q->qfull);
 	spin_lock_init(&q->lockdata);
 	q->lock = &q->lockdata;
-	q->headers.producer = mem;
-	q->headers.consumer = mem+1;
+	q->headers.producer = (__le32 *)mem;
+	q->headers.consumer = (__le32 *)(mem+1);
 	*(q->headers.producer) = cpu_to_le32(qsize);
 	*(q->headers.consumer) = cpu_to_le32(qsize);
 	q->entries = qsize;
@@ -173,6 +204,8 @@ int aac_send_shutdown(struct aac_dev * d
 	int status;
 
 	fibctx = fib_alloc(dev);
+	if (!fibctx)
+		return -ENOMEM;
 	fib_init(fibctx);
 
 	cmd = (struct aac_close *) fib_data(fibctx);
@@ -184,7 +217,7 @@ int aac_send_shutdown(struct aac_dev * d
 			  fibctx,
 			  sizeof(struct aac_close),
 			  FsaNormal,
-			  1, 1,
+			  -2 /* Timeout silently */, 1,
 			  NULL, NULL);
 
 	if (status == 0)
@@ -204,7 +237,7 @@ int aac_send_shutdown(struct aac_dev * d
  *		0 - If there were errors initing. This is a fatal error.
  */
  
-int aac_comm_init(struct aac_dev * dev)
+static int aac_comm_init(struct aac_dev * dev)
 {
 	unsigned long hdrsize = (sizeof(u32) * NUMBER_OF_COMM_QUEUES) * 2;
 	unsigned long queuesize = sizeof(struct aac_entry) * TOTAL_QUEUE_ENTRIES;
@@ -293,6 +326,113 @@ int aac_comm_init(struct aac_dev * dev)
 
 struct aac_dev *aac_init_adapter(struct aac_dev *dev)
 {
+	u32 status[5];
+	struct Scsi_Host * host = dev->scsi_host_ptr;
+
+	/*
+	 *	Check the preferred comm settings, defaults from template.
+	 */
+	dev->max_fib_size = sizeof(struct hw_fib);
+	dev->sg_tablesize = host->sg_tablesize = (dev->max_fib_size
+		- sizeof(struct aac_fibhdr)
+		- sizeof(struct aac_write) + sizeof(struct sgmap))
+			/ sizeof(struct sgmap);
+	dev->new_comm_interface = 0;
+	dev->raw_io_64 = 0;
+	if ((!aac_adapter_sync_cmd(dev, GET_ADAPTER_PROPERTIES,
+	  0, 0, 0, 0, 0, 0,
+	  status+0, status+1, status+2, NULL, NULL))
+	 && (status[0] == 0x00000001)) {
+		if (status[1] & AAC_OPT_NEW_COMM_64)
+			dev->raw_io_64 = 1;
+		if (status[1] & AAC_OPT_NEW_COMM)
+			dev->new_comm_interface = dev->a_ops.adapter_send != 0;
+		if (dev->new_comm_interface
+		 && (status[2] > AAC_MIN_FOOTPRINT_SIZE)) {
+			iounmap((void * )dev->regs.sa);
+			dev->base_size = status[2];
+			dprintk((KERN_DEBUG "ioremap(%lx,%d)\n",
+			  dev->scsi_host_ptr->base, status[2]));
+			if ((dev->regs.sa = (struct sa_registers *)ioremap(
+			  (unsigned long)dev->scsi_host_ptr->base, status[2]))
+			  == NULL) {
+				/* remap failed, go back ... */
+				dev->new_comm_interface = 0;
+				if ((dev->regs.sa
+				  = (struct sa_registers *)ioremap(
+				    (unsigned long)dev->scsi_host_ptr->base,
+				    AAC_MIN_FOOTPRINT_SIZE)) == NULL) {	
+					printk(KERN_WARNING
+					  "aacraid: unable to map adapter.\n");
+					return NULL;
+				}
+			}
+		}
+	}
+	if ((!aac_adapter_sync_cmd(dev, GET_COMM_PREFERRED_SETTINGS,
+	  0, 0, 0, 0, 0, 0,
+	  status+0, status+1, status+2, status+3, status+4))
+	 && (status[0] == 0x00000001)) {
+		extern int acbsize;
+		/*
+		 *	status[1] >> 16		maximum command size in KB
+		 *	status[1] & 0xFFFF	maximum FIB size
+		 *	status[2] >> 16		maximum SG elements to driver
+		 *	status[2] & 0xFFFF	maximum SG elements from driver
+		 *	status[3] & 0xFFFF	maximum number FIBs outstanding
+		 */
+		host->max_sectors = (status[1] >> 16) << 1;
+		dev->max_fib_size = status[1] & 0xFFFF;
+		host->sg_tablesize = status[2] >> 16;
+		dev->sg_tablesize = status[2] & 0xFFFF;
+		host->can_queue = (status[3] & 0xFFFF) - AAC_NUM_MGT_FIB;
+		/*
+		 *	NOTE:
+		 *	All these overrides are based on a fixed internal
+		 *	knowledge and understanding of existing adapters,
+		 *	acbsize should be set with caution.
+		 */
+		if (acbsize == 512) {
+			host->max_sectors = AAC_MAX_32BIT_SGBCOUNT;
+			dev->max_fib_size = 512;
+			dev->sg_tablesize = host->sg_tablesize
+			  = (512 - sizeof(struct aac_fibhdr)
+			    - sizeof(struct aac_write) + sizeof(struct sgmap))
+			     / sizeof(struct sgmap);
+			host->can_queue = AAC_NUM_IO_FIB;
+		} else if (acbsize == 2048) {
+			host->max_sectors = 512;
+			dev->max_fib_size = 2048;
+			host->sg_tablesize = 65;
+			dev->sg_tablesize = 81;
+			host->can_queue = 512 - AAC_NUM_MGT_FIB;
+		} else if (acbsize == 4096) {
+			host->max_sectors = 1024;
+			dev->max_fib_size = 4096;
+			host->sg_tablesize = 129;
+			dev->sg_tablesize = 166;
+			host->can_queue = 256 - AAC_NUM_MGT_FIB;
+		} else if (acbsize == 8192) {
+			host->max_sectors = 2048;
+			dev->max_fib_size = 8192;
+			host->sg_tablesize = 257;
+			dev->sg_tablesize = 337;
+			host->can_queue = 128 - AAC_NUM_MGT_FIB;
+		} else if (acbsize > 0) {
+			printk("Illegal acbsize=%d ignored\n", acbsize);
+		}
+	}
+	{
+		extern int numacb;
+
+		if (numacb > 0) {
+			if (numacb < host->can_queue)
+				host->can_queue = numacb;
+			else
+				printk("numacb=%d ignored\n", numacb);
+		}
+	}
+
 	/*
 	 *	Ok now init the communication subsystem
 	 */
--- linux-2.6.8.1-t043-libata-update/drivers/scsi/aacraid/aacraid.h	2005-09-26 13:33:12.000000000 +0400
+++ aacraid-drv/drivers/scsi/aacraid/aacraid.h	2005-05-13 19:59:51.000000000 +0400
@@ -1,20 +1,66 @@
+#define CODE_STREAM_IDENTIFIER "This is the code stream identifier"
+#define AAC_DRIVER_BRANCH "dkms"
+//#define dprintk(x) printk x
 #if (!defined(dprintk))
 # define dprintk(x)
 #endif
+//#define fwprintf(x) aac_fw_printf x
+#if (!defined(fwprintf))
+# define fwprintf(x)
+#endif
+//#define AAC_DETAILED_STATUS_INFO
+//#define AAC_DEBUG_INSTRUMENT_TIMING
+//#define AAC_DEBUG_INSTRUMENT_AIF
+//#define AAC_DEBUG_INSTRUMENT_IOCTL
+//#define AAC_DEBUG_INSTRUMENT_AAC_CONFIG
+//#define AAC_DEBUG_INSTRUMENT_RESET
+//#define AAC_DEBUG_INSTRUMENT_FIB
+//#define AAC_DEBUG_INSTRUMENT_2TB
+//#define AAC_DEBUG_INSTRUMENT_SENDFIB
+//#define AAC_DEBUG_INSTRUMENT_IO
+
+/* eg: if (nblank(dprintk(x))) */
+#define _nblank(x) #x
+#define nblank(x) _nblank(x)[0]
+
+#include "compat.h"
+#if (defined(SCSI_HAS_DUMP))
+#include <linux/interrupt.h>
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,4,23))
+#if (!defined(IRQ_NONE))
+  typedef void irqreturn_t;
+# define IRQ_HANDLED
+# define IRQ_NONE
+#endif
+#endif
+#endif
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,9))
+#define AAC_CSMI
+#endif
 
 /*------------------------------------------------------------------------------
  *              D E F I N E S
  *----------------------------------------------------------------------------*/
 
+//#define AAC_EXTENDED_TIMEOUT	120
+
+#ifndef AAC_DRIVER_BUILD
+# define AAC_DRIVER_BUILD 2400
+#endif
 #define MAXIMUM_NUM_CONTAINERS	32
-#define MAXIMUM_NUM_ADAPTERS	8
 
-#define AAC_NUM_FIB		(256 + 64)
-#define AAC_NUM_IO_FIB		100
+#define AAC_NUM_MGT_FIB		8
+#define AAC_NUM_IO_FIB		(512-AAC_NUM_MGT_FIB)
+#define AAC_NUM_FIB		(AAC_NUM_IO_FIB+AAC_NUM_MGT_FIB)
 
 #define AAC_MAX_LUN		(8)
 
 #define AAC_MAX_HOSTPHYSMEMPAGES (0xfffff)
+/*
+ *  max_sectors is an unsigned short, otherwise limit is 0x100000000 / 512
+ * Linux has starvation problems if we permit larger than 4MB I/O ...
+ */
+#define AAC_MAX_32BIT_SGBCOUNT	((unsigned short)8192)
 
 /*
  * These macros convert from physical channels to virtual channels
@@ -28,10 +74,10 @@
 #define aac_phys_to_logical(x)  (x+1)
 #define aac_logical_to_phys(x)  (x?x-1:0)
 
-#define AAC_DETAILED_STATUS_INFO
-
-extern int nondasd;
-extern int paemode;
+/* #define AAC_DETAILED_STATUS_INFO */
+#if (defined(__arm__))
+#define AAC_LM_SENSOR
+#endif
 
 struct diskparm
 {
@@ -60,6 +106,7 @@ struct diskparm
 #define		CT_VOLUME_OF_MIRRORS	12	/* volume of mirror */
 #define		CT_PSEUDO_RAID		13	/* really raid4 */
 #define		CT_LAST_VOLUME_TYPE	14
+#define 	CT_OK        		218
 
 /*
  *	Types of objects addressable in some fashion by the client.
@@ -92,15 +139,41 @@ struct diskparm
  *	on 64 bit systems not all cards support the 64 bit version
  */
 struct sgentry {
+	__le32	addr;	/* 32-bit address. */
+	__le32	count;	/* Length. */
+};
+
+struct user_sgentry {
 	u32	addr;	/* 32-bit address. */
 	u32	count;	/* Length. */
 };
 
 struct sgentry64 {
+	__le32	addr[2];	/* 64-bit addr. 2 pieces for data alignment */
+	__le32	count;	/* Length. */
+};
+
+struct user_sgentry64 {
 	u32	addr[2];	/* 64-bit addr. 2 pieces for data alignment */
 	u32	count;	/* Length. */
 };
 
+struct sgentryraw {
+	__le32		next;	/* reserved for F/W use */
+	__le32		prev;	/* reserved for F/W use */
+	__le32		addr[2];
+	__le32		count;
+	__le32		flags;	/* reserved for F/W use */
+};
+
+struct user_sgentryraw {
+	u32		next;	/* reserved for F/W use */
+	u32		prev;	/* reserved for F/W use */
+	u32		addr[2];
+	u32		count;
+	u32		flags;	/* reserved for F/W use */
+};
+
 /*
  *	SGMAP
  *
@@ -109,15 +182,35 @@ struct sgentry64 {
  */
 
 struct sgmap {
-	u32		count;
+	__le32		count;
 	struct sgentry	sg[1]; 
 };
 
-struct sgmap64 {
+struct user_sgmap {
 	u32		count;
+	struct user_sgentry	sg[1]; 
+};
+
+struct sgmap64 {
+	__le32		count;
 	struct sgentry64 sg[1];
 };
 
+struct user_sgmap64 {
+	u32		count;
+	struct user_sgentry64 sg[1];
+};
+
+struct sgmapraw {
+	__le32		  count;
+	struct sgentryraw sg[1];
+};
+
+struct user_sgmapraw {
+	u32		  count;
+	struct user_sgentryraw sg[1];
+};
+
 struct creation_info
 {
 	u8 		buildnum;		/* e.g., 588 */
@@ -126,14 +219,14 @@ struct creation_info
 						 * 	 2 = API
 						 */
 	u8	 	year;		 	/* e.g., 1997 = 97 */
-	u32		date;			/*
+	__le32		date;			/*
 						 * unsigned 	Month		:4;	// 1 - 12
 						 * unsigned 	Day		:6;	// 1 - 32
 						 * unsigned 	Hour		:6;	// 0 - 23
 						 * unsigned 	Minute		:6;	// 0 - 60
 						 * unsigned 	Second		:6;	// 0 - 60
 						 */
-	u32		serial[2];			/* e.g., 0x1DEADB0BFAFAF001 */
+	__le32		serial[2];			/* e.g., 0x1DEADB0BFAFAF001 */
 };
 
 
@@ -178,8 +271,8 @@ struct creation_info
  */
 
 struct aac_entry {
-	u32 size;          /* Size in bytes of Fib which this QE points to */
-	u32 addr; /* Receiver address of the FIB */
+	__le32 size;          /* Size in bytes of Fib which this QE points to */
+	__le32 addr; /* Receiver address of the FIB */
 };
 
 /*
@@ -188,9 +281,10 @@ struct aac_entry {
  */
  
 struct aac_qhdr {
-	u64 header_addr;		/* Address to hand the adapter to access to this queue head */
-	u32 *producer;			/* The producer index for this queue (host address) */
-	u32 *consumer;			/* The consumer index for this queue (host address) */
+	__le64 header_addr;/* Address to hand the adapter to access
+			to this queue head */
+	__le32 *producer; /* The producer index for this queue (host address) */
+	__le32 *consumer; /* The consumer index for this queue (host address) */
 };
 
 /*
@@ -264,29 +358,30 @@ enum aac_queue_types {
  */
 
 struct aac_fibhdr {
-	u32 XferState;			// Current transfer state for this CCB
-	u16 Command;			// Routing information for the destination
-	u8 StructType;			// Type FIB
-	u8 Flags;			// Flags for FIB
-	u16 Size;			// Size of this FIB in bytes
-	u16 SenderSize;			// Size of the FIB in the sender (for response sizing)
-	u32 SenderFibAddress;		// Host defined data in the FIB
-	u32 ReceiverFibAddress;		// Logical address of this FIB for the adapter
-	u32 SenderData;			// Place holder for the sender to store data
+	__le32 XferState;	  /* Current transfer state for this CCB */
+	__le16 Command;		  /* Routing information for the destination */
+	u8 StructType;		  /* Type FIB */
+	u8 Flags;		  /* Flags for FIB */
+	__le16 Size;		  /* Size of this FIB in bytes */
+	__le16 SenderSize;	  /* Size of the FIB in the sender
+				  (for response sizing) */
+	__le32 SenderFibAddress;  /* Host defined data in the FIB */
+	__le32 ReceiverFibAddress;/* Logical address of this FIB for
+				the adapter */
+	__le32 SenderData;	  /* Place holder for the sender to store data */
 	union {
 		struct {
-		    u32 _ReceiverTimeStart; 	// Timestamp for receipt of fib
-		    u32 _ReceiverTimeDone;	// Timestamp for completion of fib
+		    __le32 _ReceiverTimeStart; 	/* Timestamp for
+					receipt of fib */
+		    __le32 _ReceiverTimeDone;	/* Timestamp for
+					completion of fib */
 		} _s;
 	} _u;
 };
 
-#define FIB_DATA_SIZE_IN_BYTES (512 - sizeof(struct aac_fibhdr))
-
-
 struct hw_fib {
 	struct aac_fibhdr header;
-	u8 data[FIB_DATA_SIZE_IN_BYTES];		// Command specific data
+	u8 data[512-sizeof(struct aac_fibhdr)];	// Command specific data
 };
 
 /*
@@ -330,6 +425,7 @@ struct hw_fib {
  */
 #define		ContainerCommand		500
 #define		ContainerCommand64		501
+#define		ContainerRawIo			502
 /*
  *	Cluster Commands
  */
@@ -348,11 +444,14 @@ struct hw_fib {
 #define		RequestAdapterInfo		703
 #define		IsAdapterPaused			704
 #define		SendHostTime			705
-#define		LastMiscCommand			706
+#define		RequestSupplementAdapterInfo	706
+#define		LastMiscCommand			707
+
+#define		RequestCompatibilityId		802
 
-//
-// Commands that will target the failover level on the FSA adapter
-//
+/*
+ * Commands that will target the failover level on the FSA adapter
+ */
 
 enum fib_xfer_state {
 	HostOwned 			= (1<<0),
@@ -385,49 +484,61 @@ enum fib_xfer_state {
  */
 
 #define ADAPTER_INIT_STRUCT_REVISION		3
+#define ADAPTER_INIT_STRUCT_REVISION_4		4 // rocket science
 
 struct aac_init
 {
-	u32	InitStructRevision;
-	u32	MiniPortRevision;
-	u32	fsrev;
-	u32	CommHeaderAddress;
-	u32	FastIoCommAreaAddress;
-	u32	AdapterFibsPhysicalAddress;
-	u32	AdapterFibsVirtualAddress;
-	u32	AdapterFibsSize;
-	u32	AdapterFibAlign;
-	u32	printfbuf;
-	u32	printfbufsiz;
-	u32	HostPhysMemPages;		// number of 4k pages of host physical memory
-	u32	HostElapsedSeconds;		// number of seconds since 1970.
+	__le32	InitStructRevision;
+	__le32	MiniPortRevision;
+	__le32	fsrev;
+	__le32	CommHeaderAddress;
+	__le32	FastIoCommAreaAddress;
+	__le32	AdapterFibsPhysicalAddress;
+	__le32	AdapterFibsVirtualAddress;
+	__le32	AdapterFibsSize;
+	__le32	AdapterFibAlign;
+	__le32	printfbuf;
+	__le32	printfbufsiz;
+	__le32	HostPhysMemPages;	/* number of 4k pages of host
+				physical memory */
+	__le32	HostElapsedSeconds;	/* number of seconds since 1970. */
+	/* ADAPTER_INIT_STRUCT_REVISION_4 begins here */
+	__le32	InitFlags;		/* flags for supported features */
+#	define INITFLAGS_NEW_COMM_SUPPORTED	0x00000001
+	__le32	MaxIoCommands;		/* max outstanding commands */
+	__le32	MaxIoSize;		/* largest I/O command */
+	__le32	MaxFibSize;		/* largest FIB to adapter */
 };
 
 enum aac_log_level {
-	LOG_INIT			= 10,
-	LOG_INFORMATIONAL		= 20,
-	LOG_WARNING			= 30,
-	LOG_LOW_ERROR			= 40,
-	LOG_MEDIUM_ERROR		= 50,
-	LOG_HIGH_ERROR			= 60,
-	LOG_PANIC			= 70,
-	LOG_DEBUG			= 80,
-	LOG_WINDBG_PRINT		= 90
+	LOG_AAC_INIT			= 10,
+	LOG_AAC_INFORMATIONAL		= 20,
+	LOG_AAC_WARNING			= 30,
+	LOG_AAC_LOW_ERROR		= 40,
+	LOG_AAC_MEDIUM_ERROR		= 50,
+	LOG_AAC_HIGH_ERROR		= 60,
+	LOG_AAC_PANIC			= 70,
+	LOG_AAC_DEBUG			= 80,
+	LOG_AAC_WINDBG_PRINT		= 90
 };
 
 #define FSAFS_NTC_GET_ADAPTER_FIB_CONTEXT	0x030b
 #define FSAFS_NTC_FIB_CONTEXT			0x030c
 
 struct aac_dev;
+struct fib;
 
 struct adapter_ops
 {
 	void (*adapter_interrupt)(struct aac_dev *dev);
 	void (*adapter_notify)(struct aac_dev *dev, u32 event);
-	void (*adapter_enable_int)(struct aac_dev *dev, u32 event);
-	void (*adapter_disable_int)(struct aac_dev *dev, u32 event);
-	int  (*adapter_sync_cmd)(struct aac_dev *dev, u32 command, u32 p1, u32 *status);
+	void (*adapter_disable_int)(struct aac_dev *dev);
+	int  (*adapter_sync_cmd)(struct aac_dev *dev, u32 command, u32 p1, u32 p2, u32 p3, u32 p4, u32 p5, u32 p6, u32 *status, u32 *r1, u32 *r2, u32 *r3, u32 *r4);
 	int  (*adapter_check_health)(struct aac_dev *dev);
+	int  (*adapter_send)(struct fib * fib);
+#if (defined(SCSI_HAS_DUMP))
+	irqreturn_t (*adapter_intr)(int irq, void *dev_id, struct pt_regs *regs);
+#endif
 };
 
 /*
@@ -449,7 +560,24 @@ struct aac_driver_ident
  * dma mask such that fib memory will be allocated where the
  * adapter firmware can get to it.
  */
-#define AAC_QUIRK_31BIT	1
+#define AAC_QUIRK_31BIT	0x0001
+
+/*
+ * Some adapter firmware, when the raid card's cache is turned off, can not
+ * split up scatter gathers in order to deal with the limits of the
+ * underlying CHIM. This limit is 34 scatter gather elements.
+ */
+#define AAC_QUIRK_34SG	0x0002
+
+/*
+ * This adapter is a slave (no Firmware)
+ */
+#define AAC_QUIRK_SLAVE 0x0004
+
+/*
+ * This adapter is a master.
+ */
+#define AAC_QUIRK_MASTER 0x0008
 
 /*
  *	The adapter interface specs all queues to be located in the same
@@ -471,8 +599,6 @@ struct aac_queue {
                   /* This is only valid for adapter to host command queues. */ 
 	spinlock_t	 	*lock;		/* Spinlock for this queue must take this lock before accessing the lock */
 	spinlock_t		lockdata;	/* Actual lock (used only on one side of the lock) */
-	unsigned long		SavedIrql;     	/* Previous IRQL when the spin lock is taken */
-	u32			padding;	/* Padding - FIXME - can remove I believe */
 	struct list_head 	cmdq;	   	/* A queue of FIBs which need to be prcessed by the FS thread. This is */
                                 		/* only valid for command queues which receive entries from the adapter. */
 	struct list_head	pendingq;	/* A queue of outstanding fib's to the adapter. */
@@ -495,40 +621,32 @@ struct aac_queue_block
  */
  
 struct sa_drawbridge_CSR {
-						//	 Offset |	Name
-	u32	reserved[10];			//	00h-27h |   Reserved
-	u8	LUT_Offset;			//	28h	|	Looup Table Offset
-	u8	reserved1[3];			// 	29h-2bh	|	Reserved
-	u32	LUT_Data;			//	2ch	|	Looup Table Data	
-	u32	reserved2[26];			//	30h-97h	|	Reserved
-	u16	PRICLEARIRQ;			//	98h	|	Primary Clear Irq
-	u16	SECCLEARIRQ;			//	9ah	|	Secondary Clear Irq
-	u16	PRISETIRQ;			//	9ch	|	Primary Set Irq
-	u16	SECSETIRQ;			//	9eh	|	Secondary Set Irq
-	u16	PRICLEARIRQMASK;		//	a0h	|	Primary Clear Irq Mask
-	u16	SECCLEARIRQMASK;		//	a2h	|	Secondary Clear Irq Mask
-	u16	PRISETIRQMASK;			//	a4h	|	Primary Set Irq Mask
-	u16	SECSETIRQMASK;			//	a6h	|	Secondary Set Irq Mask
-	u32	MAILBOX0;			//	a8h	|	Scratchpad 0
-	u32	MAILBOX1;			//	ach	|	Scratchpad 1
-	u32	MAILBOX2;			//	b0h	|	Scratchpad 2
-	u32	MAILBOX3;			//	b4h	|	Scratchpad 3
-	u32	MAILBOX4;			//	b8h	|	Scratchpad 4
-	u32	MAILBOX5;			//	bch	|	Scratchpad 5
-	u32	MAILBOX6;			//	c0h	|	Scratchpad 6
-	u32	MAILBOX7;			//	c4h	|	Scratchpad 7
-
-	u32	ROM_Setup_Data;			//	c8h | 	Rom Setup and Data
-	u32	ROM_Control_Addr;		//	cch | 	Rom Control and Address
-
-	u32	reserved3[12];			//	d0h-ffh	| 	reserved
-	u32	LUT[64];			// 100h-1ffh|	Lookup Table Entries
-
-	//
-	//  TO DO
-	//	need to add DMA, I2O, UART, etc registers form 80h to 364h
-	//
-
+				/*	Offset 	|  Name */
+	__le32	reserved[10];	/*	00h-27h |  Reserved */
+	u8	LUT_Offset;	/*	28h	|  Lookup Table Offset */
+	u8	reserved1[3];	/* 	29h-2bh	|  Reserved */
+	__le32	LUT_Data;	/*	2ch	|  Looup Table Data */
+	__le32	reserved2[26];	/*	30h-97h	|  Reserved */
+	__le16	PRICLEARIRQ;	/*	98h	|  Primary Clear Irq */
+	__le16	SECCLEARIRQ;	/*	9ah	|  Secondary Clear Irq */
+	__le16	PRISETIRQ;	/*	9ch	|  Primary Set Irq */
+	__le16	SECSETIRQ;	/*	9eh	|  Secondary Set Irq */
+	__le16	PRICLEARIRQMASK;/*	a0h	|  Primary Clear Irq Mask */
+	__le16	SECCLEARIRQMASK;/*	a2h	|  Secondary Clear Irq Mask */
+	__le16	PRISETIRQMASK;	/*	a4h	|  Primary Set Irq Mask */
+	__le16	SECSETIRQMASK;	/*	a6h	|  Secondary Set Irq Mask */
+	__le32	MAILBOX0;	/*	a8h	|  Scratchpad 0 */
+	__le32	MAILBOX1;	/*	ach	|  Scratchpad 1 */
+	__le32	MAILBOX2;	/*	b0h	|  Scratchpad 2 */
+	__le32	MAILBOX3;	/*	b4h	|  Scratchpad 3 */
+	__le32	MAILBOX4;	/*	b8h	|  Scratchpad 4 */
+	__le32	MAILBOX5;	/*	bch	|  Scratchpad 5 */
+	__le32	MAILBOX6;	/*	c0h	|  Scratchpad 6 */
+	__le32	MAILBOX7;	/*	c4h	|  Scratchpad 7 */
+	__le32	ROM_Setup_Data;	/*	c8h 	|  Rom Setup and Data */
+	__le32	ROM_Control_Addr;/*	cch 	|  Rom Control and Address */
+	__le32	reserved3[12];	/*	d0h-ffh	|  reserved */
+	__le32	LUT[64];	/*    100h-1ffh	|  Lookup Table Entries */
 };
 
 #define Mailbox0	SaDbCSR.MAILBOX0
@@ -537,6 +655,9 @@ struct sa_drawbridge_CSR {
 #define Mailbox3	SaDbCSR.MAILBOX3
 #define Mailbox4	SaDbCSR.MAILBOX4
 #define Mailbox5	SaDbCSR.MAILBOX5
+#if (defined(AAC_LM_SENSOR))
+#define Mailbox6	SaDbCSR.MAILBOX6
+#endif
 #define Mailbox7	SaDbCSR.MAILBOX7
 	
 #define DoorbellReg_p SaDbCSR.PRISETIRQ
@@ -544,13 +665,13 @@ struct sa_drawbridge_CSR {
 #define DoorbellClrReg_p SaDbCSR.PRICLEARIRQ
 
 
-#define	DOORBELL_0	cpu_to_le16(0x0001)
-#define DOORBELL_1	cpu_to_le16(0x0002)
-#define DOORBELL_2	cpu_to_le16(0x0004)
-#define DOORBELL_3	cpu_to_le16(0x0008)
-#define DOORBELL_4	cpu_to_le16(0x0010)
-#define DOORBELL_5	cpu_to_le16(0x0020)
-#define DOORBELL_6	cpu_to_le16(0x0040)
+#define	DOORBELL_0	0x0001
+#define DOORBELL_1	0x0002
+#define DOORBELL_2	0x0004
+#define DOORBELL_3	0x0008
+#define DOORBELL_4	0x0010
+#define DOORBELL_5	0x0020
+#define DOORBELL_6	0x0040
 
 	
 #define PrintfReady	DOORBELL_5
@@ -573,25 +694,33 @@ struct sa_registers {
  */
 
 struct rx_mu_registers {
-						//	 Local	|   PCI*	|	Name
-						//			|		|
-	u32	ARSR;				//	1300h	|	00h	|	APIC Register Select Register
-	u32	reserved0;			//	1304h	|	04h	|	Reserved
-	u32	AWR;				//	1308h	|	08h	|	APIC Window Register
-	u32	reserved1;			//	130Ch	|	0Ch	|	Reserved
-	u32	IMRx[2];			//	1310h	|	10h	|	Inbound Message Registers
-	u32	OMRx[2];			//	1318h	|	18h	|	Outbound Message Registers
-	u32	IDR;				//	1320h	|	20h	|	Inbound Doorbell Register
-	u32	IISR;				//	1324h	|	24h	|	Inbound Interrupt Status Register
-	u32	IIMR;				//	1328h	|	28h	|	Inbound Interrupt Mask Register
-	u32	ODR;				//	132Ch	|	2Ch	|	Outbound Doorbell Register
-	u32	OISR;				//	1330h	|	30h	|	Outbound Interrupt Status Register
-	u32	OIMR;				//	1334h	|	34h	|	Outbound Interrupt Mask Register
-						// * Must access through ATU Inbound Translation Window
+			    /*	Local  | PCI*| Name */
+	__le32	ARSR;	    /*	1300h  | 00h | APIC Register Select Register */
+	__le32	reserved0;  /*	1304h  | 04h | Reserved */
+	__le32	AWR;	    /*	1308h  | 08h | APIC Window Register */
+	__le32	reserved1;  /*	130Ch  | 0Ch | Reserved */
+	__le32	IMRx[2];    /*	1310h  | 10h | Inbound Message Registers */
+	__le32	OMRx[2];    /*	1318h  | 18h | Outbound Message Registers */
+	__le32	IDR;	    /*	1320h  | 20h | Inbound Doorbell Register */
+	__le32	IISR;	    /*	1324h  | 24h | Inbound Interrupt 
+						Status Register */
+	__le32	IIMR;	    /*	1328h  | 28h | Inbound Interrupt 
+					 	Mask Register */
+	__le32	ODR;	    /*	132Ch  | 2Ch | Outbound Doorbell Register */
+	__le32	OISR;	    /*	1330h  | 30h | Outbound Interrupt 
+						Status Register */
+	__le32	OIMR;	    /*	1334h  | 34h | Outbound Interrupt 
+						Mask Register */
+	__le32	reserved2;  /*	1338h  | 38h | Reserved */
+	__le32	reserved3;  /*	133Ch  | 3Ch | Reserved */
+	__le32	InboundQueue;/*	1340h  | 40h | Inbound Queue Port relative to firmware */
+	__le32	OutboundQueue;/*1344h  | 44h | Outbound Queue Port relative to firmware */
+			    /* * Must access through ATU Inbound 
+			     	 Translation Window */
 };
 
 struct rx_inbound {
-	u32	Mailbox[8];
+	__le32	Mailbox[8];
 };
 
 #define	InboundMailbox0		IndexRegs.Mailbox[0]
@@ -599,30 +728,31 @@ struct rx_inbound {
 #define	InboundMailbox2		IndexRegs.Mailbox[2]
 #define	InboundMailbox3		IndexRegs.Mailbox[3]
 #define	InboundMailbox4		IndexRegs.Mailbox[4]
+#if (defined(AAC_LM_SENSOR))
 #define	InboundMailbox5		IndexRegs.Mailbox[5]
 #define	InboundMailbox6		IndexRegs.Mailbox[6]
-#define	InboundMailbox7		IndexRegs.Mailbox[7]
+#endif
 
-#define	INBOUNDDOORBELL_0	cpu_to_le32(0x00000001)
-#define INBOUNDDOORBELL_1	cpu_to_le32(0x00000002)
-#define INBOUNDDOORBELL_2	cpu_to_le32(0x00000004)
-#define INBOUNDDOORBELL_3	cpu_to_le32(0x00000008)
-#define INBOUNDDOORBELL_4	cpu_to_le32(0x00000010)
-#define INBOUNDDOORBELL_5	cpu_to_le32(0x00000020)
-#define INBOUNDDOORBELL_6	cpu_to_le32(0x00000040)
-
-#define	OUTBOUNDDOORBELL_0	cpu_to_le32(0x00000001)
-#define OUTBOUNDDOORBELL_1	cpu_to_le32(0x00000002)
-#define OUTBOUNDDOORBELL_2	cpu_to_le32(0x00000004)
-#define OUTBOUNDDOORBELL_3	cpu_to_le32(0x00000008)
-#define OUTBOUNDDOORBELL_4	cpu_to_le32(0x00000010)
+#define	INBOUNDDOORBELL_0	0x00000001
+#define INBOUNDDOORBELL_1	0x00000002
+#define INBOUNDDOORBELL_2	0x00000004
+#define INBOUNDDOORBELL_3	0x00000008
+#define INBOUNDDOORBELL_4	0x00000010
+#define INBOUNDDOORBELL_5	0x00000020
+#define INBOUNDDOORBELL_6	0x00000040
+
+#define	OUTBOUNDDOORBELL_0	0x00000001
+#define OUTBOUNDDOORBELL_1	0x00000002
+#define OUTBOUNDDOORBELL_2	0x00000004
+#define OUTBOUNDDOORBELL_3	0x00000008
+#define OUTBOUNDDOORBELL_4	0x00000010
 
 #define InboundDoorbellReg	MUnit.IDR
 #define OutboundDoorbellReg	MUnit.ODR
 
 struct rx_registers {
-	struct rx_mu_registers		MUnit;		// 1300h - 1334h
-	u32				reserved1[6];	// 1338h - 134ch
+	struct rx_mu_registers		MUnit;		/* 1300h - 1344h */
+	__le32				reserved1[2];	/* 1348h - 134ch */
 	struct rx_inbound		IndexRegs;
 };
 
@@ -639,8 +769,8 @@ struct rx_registers {
 #define rkt_inbound rx_inbound
 
 struct rkt_registers {
-	struct rkt_mu_registers		MUnit;		 /* 1300h - 1334h */
-	u32				reserved1[1010]; /* 1338h - 22fch */
+	struct rkt_mu_registers		MUnit;		 /* 1300h - 1344h */
+	__le32				reserved1[1006]; /* 1348h - 22fch */
 	struct rkt_inbound		IndexRegs;	 /* 2300h - */
 };
 
@@ -649,8 +779,6 @@ struct rkt_registers {
 #define rkt_writeb(AEP, CSR, value)	writeb(value, &((AEP)->regs.rkt->CSR))
 #define rkt_writel(AEP, CSR, value)	writel(value, &((AEP)->regs.rkt->CSR))
 
-struct fib;
-
 typedef void (*fib_callback)(void *ctxt, struct fib *fibctx);
 
 struct aac_fib_context {
@@ -665,14 +793,65 @@ struct aac_fib_context {
 	struct list_head	fib_list;	// this holds fibs and their attachd hw_fibs
 };
 
-struct fsa_scsi_hba {
-	u32		size[MAXIMUM_NUM_CONTAINERS];
-	u32		type[MAXIMUM_NUM_CONTAINERS];
-	u8		valid[MAXIMUM_NUM_CONTAINERS];
-	u8		ro[MAXIMUM_NUM_CONTAINERS];
-	u8		locked[MAXIMUM_NUM_CONTAINERS];
-	u8		deleted[MAXIMUM_NUM_CONTAINERS];
-	char		devname[MAXIMUM_NUM_CONTAINERS][8];
+struct sense_data {
+	u8 error_code;		/* 70h (current errors), 71h(deferred errors) */
+	u8 valid:1;		/* A valid bit of one indicates that the information  */
+				/* field contains valid information as defined in the
+				 * SCSI-2 Standard.
+				 */
+	u8 segment_number;	/* Only used for COPY, COMPARE, or COPY AND VERIFY Commands */
+	u8 sense_key:4;		/* Sense Key */
+	u8 reserved:1;
+	u8 ILI:1;		/* Incorrect Length Indicator */
+	u8 EOM:1;		/* End Of Medium - reserved for random access devices */
+	u8 filemark:1;		/* Filemark - reserved for random access devices */
+
+	u8 information[4];	/* for direct-access devices, contains the unsigned 
+				 * logical block address or residue associated with 
+				 * the sense key 
+				 */
+	u8 add_sense_len;	/* number of additional sense bytes to follow this field */
+	u8 cmnd_info[4];	/* not used */
+	u8 ASC;			/* Additional Sense Code */
+	u8 ASCQ;		/* Additional Sense Code Qualifier */
+	u8 FRUC;		/* Field Replaceable Unit Code - not used */
+	u8 bit_ptr:3;		/* indicates which byte of the CDB or parameter data
+				 * was in error
+				 */
+	u8 BPV:1;		/* bit pointer valid (BPV): 1- indicates that 
+				 * the bit_ptr field has valid value
+				 */
+	u8 reserved2:2;
+	u8 CD:1;		/* command data bit: 1- illegal parameter in CDB.
+				 * 0- illegal parameter in data.
+				 */
+	u8 SKSV:1;
+	u8 field_ptr[2];	/* byte of the CDB or parameter data in error */
+};
+
+struct fsa_dev_info {
+	u64		last;
+	u64		size;
+	u32		type;
+	u32		ConfigWaitingOn;
+	u16		queue_depth;
+	u8		ConfigNeeded;
+	u8		valid;
+	u8		ro;
+	u8		locked;
+	u8		deleted;
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,4,19))
+#	define MAX_NESTED AAC_NUM_MGT_FIB
+//#	undef MAX_NESTED
+//#	define MAX_NESTED 1
+#	if (MAX_NESTED >= 256)
+		u16	nested;
+#	else
+		u8	nested;
+#	endif
+#endif
+	char		devname[8];
+	struct sense_data sense_data;
 };
 
 struct fib {
@@ -707,6 +886,12 @@ struct fib {
 	void 			*data;
 	struct hw_fib		*hw_fib;		/* Actual shared object */
 	dma_addr_t		hw_fib_pa;		/* physical address of hw_fib*/
+#if (defined(AAC_DEBUG_INSTRUMENT_TIMING))
+	unsigned long		DriverTimeStartS;
+	unsigned long		DriverTimeStartuS;
+	unsigned long		DriverTimeDoneS;
+	unsigned long		DriverTimeDoneuS;
+#endif
 };
 
 /*
@@ -717,27 +902,68 @@ struct fib {
  
 struct aac_adapter_info
 {
-	u32	platform;
-	u32	cpu;
-	u32	subcpu;
-	u32	clock;
-	u32	execmem;
-	u32	buffermem;
-	u32	totalmem;
-	u32	kernelrev;
-	u32	kernelbuild;
-	u32	monitorrev;
-	u32	monitorbuild;
-	u32	hwrev;
-	u32	hwbuild;
-	u32	biosrev;
-	u32	biosbuild;
-	u32	cluster;
-	u32	clusterchannelmask; 
-	u32	serial[2];
-	u32	battery;
-	u32	options;
-	u32	OEM;
+	__le32	platform;
+	__le32	cpu;
+	__le32	subcpu;
+	__le32	clock;
+	__le32	execmem;
+	__le32	buffermem;
+	__le32	totalmem;
+	__le32	kernelrev;
+	__le32	kernelbuild;
+	__le32	monitorrev;
+	__le32	monitorbuild;
+	__le32	hwrev;
+	__le32	hwbuild;
+	__le32	biosrev;
+	__le32	biosbuild;
+	__le32	cluster;
+	__le32	clusterchannelmask; 
+	__le32	serial[2];
+	__le32	battery;
+	__le32	options;
+	__le32	OEM;
+};
+
+struct aac_supplement_adapter_info
+{
+	u8	AdapterTypeText[17+1];
+	u8	Pad[2];
+	u32	FlashMemoryByteSize;
+	u32	FlashImageId;
+	u32	MaxNumberPorts;
+	u32	Version;
+	u32	FeatureBits;
+	u8	SlotNumber;
+	u8	ReservedPad0[0];
+	u8	BuildDate[12];
+	u32	CurrentNumberPorts;
+	u32	ReservedGrowth[24];
+};
+#define AAC_FEATURE_FALCON	0x00000010
+#define AAC_SIS_VERSION_V3	3
+#define AAC_SIS_SLOT_UNKNOWN	0xFF
+
+#define GetBusInfo 0x00000009
+struct aac_bus_info {
+	u32	Command;	/* VM_Ioctl */
+	u32	ObjType;	/* FT_DRIVE */
+	u32	MethodId;	/* 1 = SCSI Layer */
+	u32	ObjectId;	/* Handle */
+	u32	CtlCmd;		/* GetBusInfo */
+};
+
+struct aac_bus_info_response {
+	u32	Status;		/* ST_OK */
+	u32	ObjType;
+	u32	MethodId;	/* unused */
+	u32	ObjectId;	/* unused */
+	u32	CtlCmd;		/* unused */
+	u32	ProbeComplete;
+	u32	BusCount;
+	u32	TargetsPerBus;
+	u8	InitiatorBusId[10];
+	u8	BusValid[10];
 };
 
 /*
@@ -771,14 +997,24 @@ struct aac_adapter_info
 #define AAC_OPT_SGMAP_HOST64		cpu_to_le32(1<<10)
 #define AAC_OPT_ALARM			cpu_to_le32(1<<11)
 #define AAC_OPT_NONDASD			cpu_to_le32(1<<12)
+#define AAC_OPT_SCSI_MANAGED    	cpu_to_le32(1<<13)
+#define AAC_OPT_RAID_SCSI_MODE		cpu_to_le32(1<<14)
+#define AAC_OPT_SUPPLEMENT_ADAPTER_INFO	cpu_to_le32(1<<16)
+#define AAC_OPT_NEW_COMM		cpu_to_le32(1<<17)
+#define AAC_OPT_NEW_COMM_64		cpu_to_le32(1<<18)
 
 struct aac_dev
 {
-	struct aac_dev		*next;
+	struct list_head	entry;
 	const char		*name;
 	int			id;
 
-	u16			irq_mask;
+	/*
+	 *	negotiated FIB settings
+	 */
+	unsigned		max_fib_size;
+	unsigned		sg_tablesize;
+
 	/*
 	 *	Map for 128 fib objects (64k)
 	 */	
@@ -807,28 +1043,43 @@ struct aac_dev
 	struct adapter_ops	a_ops;
 	unsigned long		fsrev;		/* Main driver's revision number */
 	
+	unsigned		base_size;	/* Size of mapped in region */
 	struct aac_init		*init;		/* Holds initialization info to communicate with adapter */
 	dma_addr_t		init_pa; 	/* Holds physical address of the init struct */
 	
 	struct pci_dev		*pdev;		/* Our PCI interface */
 	void *			printfbuf;	/* pointer to buffer used for printf's from the adapter */
+	u32			DebugFlags;	/* Debug print flags bitmap */
+	u8 *			FwDebugBuffer_P;/* Addr FW Debug Buffer */
+	u32 *			FwDebugFlags_P;	/* Addr FW Debug Flags */
+	u32			FwDebugFlags;	/* FW Debug Flags */
+	u32 *			FwDebugStrLength_P;/* Addr FW Debug String Length */
+	u8 *			FwDebugBLEDflag_P;/* Addr FW Debug BLED */
+	u8 *			FwDebugBLEDvalue_P;/* Addr FW Debug BLED */
+	u32			FwDebugBufferSize;/* FW Debug Buffer Size in Bytes */
 	void *			comm_addr;	/* Base address of Comm area */
 	dma_addr_t		comm_phys;	/* Physical Address of Comm area */
 	size_t			comm_size;
 
 	struct Scsi_Host	*scsi_host_ptr;
-	struct fsa_scsi_hba	fsa_dev;
+	int			maximum_num_containers;
+	int			maximum_num_physicals;
+	int			maximum_num_channels;
+	struct fsa_dev_info	*fsa_dev;
 	pid_t			thread_pid;
 	int			cardtype;
 	
 	/*
 	 *	The following is the device specific extension.
 	 */
+#if (!defined(AAC_MIN_FOOTPRINT_SIZE))
+#	define AAC_MIN_FOOTPRINT_SIZE 8192
+#endif
 	union
 	{
-		struct sa_registers *sa;
-		struct rx_registers *rx;
-		struct rkt_registers *rkt;
+		struct sa_registers __iomem *sa;
+		struct rx_registers __iomem *rx;
+		struct rkt_registers __iomem *rkt;
 	} regs;
 	u32			OIMR; /* Mask Register Cache */
 	/*
@@ -837,34 +1088,50 @@ struct aac_dev
 	u32			aif_thread;
 	struct completion	aif_completion;
 	struct aac_adapter_info adapter_info;
+	struct aac_supplement_adapter_info supplement_adapter_info;
+#if (defined(CODE_STREAM_IDENTIFIER))
+# if (!defined(MAX_CODE_STREAM_IDENTIFIER_LENGTH))
+#  define MAX_CODE_STREAM_IDENTIFIER_LENGTH 64
+# endif
+	char			code_stream_identifier[MAX_CODE_STREAM_IDENTIFIER_LENGTH];
+#endif
 	/* These are in adapter info but they are in the io flow so
 	 * lets break them out so we don't have to do an AND to check them
 	 */
 	u8			nondasd_support; 
-	u8			pae_support;
+	u8			dac_support;
+	u8			raid_scsi_mode;
+	u8			new_comm_interface;
+	/* macro side-effects BEWARE */
+#	define			raw_io_interface \
+	  init->InitStructRevision==cpu_to_le32(ADAPTER_INIT_STRUCT_REVISION_4)
+#	define			printf_enabled \
+	  scsi_host_ptr->sg_tablesize<=34
+	u8			raw_io_64;
 };
 
-#define AllocateAndMapFibSpace(dev, MapFibContext) \
-	(dev)->a_ops.AllocateAndMapFibSpace(dev, MapFibContext)
-
-#define UnmapAndFreeFibSpace(dev, MapFibContext) \
-	(dev)->a_ops.UnmapAndFreeFibSpace(dev, MapFibContext)
-
 #define aac_adapter_interrupt(dev) \
 	(dev)->a_ops.adapter_interrupt(dev)
 
 #define aac_adapter_notify(dev, event) \
 	(dev)->a_ops.adapter_notify(dev, event)
 
-#define aac_adapter_enable_int(dev, event) \
-	(dev)->a_ops.adapter_enable_int(dev, event)
+#define aac_adapter_disable_int(dev) \
+	(dev)->a_ops.adapter_disable_int(dev)
 
-#define aac_adapter_disable_int(dev, event) \
-	dev->a_ops.adapter_disable_int(dev, event)
+#define aac_adapter_sync_cmd(dev, command, p1, p2, p3, p4, p5, p6, status, r1, r2, r3, r4) \
+	(dev)->a_ops.adapter_sync_cmd(dev, command, p1, p2, p3, p4, p5, p6, status, r1, r2, r3, r4)
 
 #define aac_adapter_check_health(dev) \
 	(dev)->a_ops.adapter_check_health(dev)
 
+#define aac_adapter_send(fib) \
+	((fib)->dev)->a_ops.adapter_send(fib)
+#if (defined(SCSI_HAS_DUMP))
+
+#define aac_adapter_intr(dev) \
+	(dev)->a_ops.adapter_intr(dev->scsi_host_ptr->irq, (void *)dev, (struct pt_regs *)NULL)
+#endif
 
 #define FIB_CONTEXT_FLAG_TIMED_OUT		(0x00000001)
 
@@ -974,59 +1241,113 @@ struct aac_dev
 
 struct aac_read
 {
-	u32	 	command;
-	u32 		cid;
-	u32 		block;
-	u32 		count;
+	__le32	 	command;
+	__le32 		cid;
+	__le32 		block;
+	__le32 		count;
 	struct sgmap	sg;	// Must be last in struct because it is variable
 };
 
 struct aac_read64
 {
-	u32	 	command;
-	u16 		cid;
-	u16 		sector_count;
-	u32 		block;
-	u16		pad;
-	u16		flags;
+	__le32	 	command;
+	__le16 		cid;
+	__le16 		sector_count;
+	__le32 		block;
+	__le16		pad;
+	__le16		flags;
 	struct sgmap64	sg;	// Must be last in struct because it is variable
 };
 
 struct aac_read_reply
 {
-	u32	 	status;
-	u32 		count;
+	__le32	 	status;
+	__le32 		count;
 };
 
 struct aac_write
 {
-	u32		command;
-	u32 		cid;
-	u32 		block;
-	u32 		count;
-	u32	 	stable;	// Not used
+	__le32		command;
+	__le32 		cid;
+	__le32 		block;
+	__le32 		count;
+	__le32	 	stable;	// Not used
 	struct sgmap	sg;	// Must be last in struct because it is variable
 };
 
 struct aac_write64
 {
-	u32	 	command;
-	u16 		cid;
-	u16 		sector_count;
-	u32 		block;
-	u16		pad;
-	u16		flags;
+	__le32	 	command;
+	__le16 		cid;
+	__le16 		sector_count;
+	__le32 		block;
+	__le16		pad;
+	__le16		flags;
 	struct sgmap64	sg;	// Must be last in struct because it is variable
 };
 struct aac_write_reply
 {
-	u32		status;
-	u32 		count;
-	u32		committed;
+	__le32		status;
+	__le32 		count;
+	__le32		committed;
+};
+
+struct aac_raw_io
+{
+	__le32		block[2];
+	__le32		count;
+	__le16		cid;
+	__le16		flags;		/* 00 W, 01 R */
+	__le16		bpTotal;	/* reserved for F/W use */
+	__le16		bpComplete;	/* reserved for F/W use */
+	struct sgmapraw	sg;
+};
+
+#define CT_FLUSH_CACHE 129
+struct aac_synchronize {
+	__le32		command;	/* VM_ContainerConfig */
+	__le32		type;		/* CT_FLUSH_CACHE */
+	__le32		cid;
+	__le32		parm1;
+	__le32		parm2;
+	__le32		parm3;
+	__le32		parm4;
+	__le32		count;	/* sizeof(((struct aac_synchronize_reply *)NULL)->data) */
+};
+
+struct aac_synchronize_reply {
+	__le32		dummy0;
+	__le32		dummy1;
+	__le32		status;	/* CT_OK */
+	__le32		parm1;
+	__le32		parm2;
+	__le32		parm3;
+	__le32		parm4;
+	__le32		parm5;
+	u8		data[16];
 };
 
 struct aac_srb
 {
+	__le32		function;
+	__le32		channel;
+	__le32		id;
+	__le32		lun;
+	__le32		timeout;
+	__le32		flags;
+	__le32		count;		// Data xfer size
+	__le32		retry_limit;
+	__le32		cdb_size;
+	u8		cdb[16];
+	struct	sgmap	sg;
+};
+
+/*
+ * This and associated data structs are used by the
+ * ioctl caller and are in cpu order.
+ */
+struct user_aac_srb
+{
 	u32		function;
 	u32		channel;
 	u32		id;
@@ -1037,20 +1358,18 @@ struct aac_srb
 	u32		retry_limit;
 	u32		cdb_size;
 	u8		cdb[16];
-	struct	sgmap	sg;
+	struct	user_sgmap	sg;
 };
 
-
-
 #define		AAC_SENSE_BUFFERSIZE	 30
 
 struct aac_srb_reply
 {
-	u32		status;
-	u32		srb_status;
-	u32		scsi_status;
-	u32		data_xfer_length;
-	u32		sense_data_size;
+	__le32		status;
+	__le32		srb_status;
+	__le32		scsi_status;
+	__le32		data_xfer_length;
+	__le32		sense_data_size;
 	u8		sense_data[AAC_SENSE_BUFFERSIZE]; // Can this be SCSI_SENSE_BUFFERSIZE
 };
 /*
@@ -1145,8 +1464,10 @@ struct aac_srb_reply
 #define		VM_CtBlockVerify64	18
 #define		VM_CtHostRead64		19
 #define		VM_CtHostWrite64	20
+#define		VM_DrvErrTblLog		21
+#define		VM_NameServe64		22
 
-#define		MAX_VMCOMMAND_NUM	21	/* used for sizing stats array - leave last */
+#define		MAX_VMCOMMAND_NUM	23	/* used for sizing stats array - leave last */
 
 /*
  *	Descriptive information (eg, vital stats)
@@ -1157,14 +1478,14 @@ struct aac_srb_reply
  */
 
 struct aac_fsinfo {
-	u32  fsTotalSize;	/* Consumed by fs, incl. metadata */
-	u32  fsBlockSize;
-	u32  fsFragSize;
-	u32  fsMaxExtendSize;
-	u32  fsSpaceUnits;
-	u32  fsMaxNumFiles;
-	u32  fsNumFreeFiles;
-	u32  fsInodeDensity;
+	__le32  fsTotalSize;	/* Consumed by fs, incl. metadata */
+	__le32  fsBlockSize;
+	__le32  fsFragSize;
+	__le32  fsMaxExtendSize;
+	__le32  fsSpaceUnits;
+	__le32  fsMaxNumFiles;
+	__le32  fsNumFreeFiles;
+	__le32  fsInodeDensity;
 };	/* valid iff ObjType == FT_FILESYS && !(ContentState & FSCS_NOTCLEAN) */
 
 union aac_contentinfo {
@@ -1172,20 +1493,90 @@ union aac_contentinfo {
 };
 
 /*
+ *	Query for Container Configuration Status
+ */
+
+#define CT_GET_CONFIG_STATUS 147
+struct aac_get_config_status {
+	__le32		command;	/* VM_ContainerConfig */
+	__le32		type;		/* CT_GET_CONFIG_STATUS */
+	__le32		parm1;
+	__le32		parm2;
+	__le32		parm3;
+	__le32		parm4;
+	__le32		parm5;
+	__le32		count;	/* sizeof(((struct aac_get_config_status_resp *)NULL)->data) */
+};
+
+#define CFACT_CONTINUE 0
+#define CFACT_PAUSE    1
+#define CFACT_ABORT    2
+struct aac_get_config_status_resp {
+	__le32		response; /* ST_OK */
+	__le32		dummy0;
+	__le32		status;	/* CT_OK */
+	__le32		parm1;
+	__le32		parm2;
+	__le32		parm3;
+	__le32		parm4;
+	__le32		parm5;
+	struct {
+		__le32	action; /* CFACT_CONTINUE, CFACT_PAUSE or CFACT_ABORT */
+		__le16	flags;
+		__le16	count;
+	}		data;
+};
+
+/*
+ *	Accept the configuration as-is
+ */
+
+#define CT_COMMIT_CONFIG 152
+
+struct aac_commit_config {
+	__le32		command;	/* VM_ContainerConfig */
+	__le32		type;		/* CT_COMMIT_CONFIG */
+};
+
+/*
+ *	Query for Container Configuration Status
+ */
+
+#define CT_GET_CONTAINER_COUNT 4
+struct aac_get_container_count {
+	__le32		command;	/* VM_ContainerConfig */
+	__le32		type;		/* CT_GET_CONTAINER_COUNT */
+};
+
+struct aac_get_container_count_resp {
+	__le32		response; /* ST_OK */
+	__le32		dummy0;
+	__le32		MaxContainers;
+	__le32		ContainerSwitchEntries;
+	__le32		MaxPartitions;
+};
+
+
+/*
  *	Query for "mountable" objects, ie, objects that are typically
  *	associated with a drive letter on the client (host) side.
  */
 
 struct aac_mntent {
-	u32    			oid;
-	u8			name[16];	// if applicable
-	struct creation_info	create_info;	// if applicable
-	u32			capacity;
-	u32			vol;    	// substrate structure
-	u32			obj;	        // FT_FILESYS, FT_DATABASE, etc.
-	u32			state;		// unready for mounting, readonly, etc.
-	union aac_contentinfo	fileinfo;	// Info specific to content manager (eg, filesystem)
-	u32			altoid;		// != oid <==> snapshot or broken mirror exists
+	__le32    		oid;
+	u8			name[16];	/* if applicable */
+	struct creation_info	create_info;	/* if applicable */
+	__le32			capacity;
+	__le32			vol;    	/* substrate structure */
+	__le32			obj;	        /* FT_FILESYS,
+					FT_DATABASE, etc. */
+	__le32			state;		/* unready for mounting,
+					readonly, etc. */
+	union aac_contentinfo	fileinfo;	/* Info specific to content
+					manager (eg, filesystem) */
+	__le32			altoid;		/* != oid <==> snapshot or
+					broken mirror exists */
+	__le32			capacityhigh;
 };
 
 #define FSCS_NOTCLEAN	0x0001  /* fsck is neccessary before mounting */
@@ -1193,25 +1584,49 @@ struct aac_mntent {
 #define FSCS_HIDDEN	0x0004	/* should be ignored - set during a clear */
 
 struct aac_query_mount {
-	u32		command;
-	u32		type;
-	u32		count;
+	__le32		command;
+	__le32		type;
+	__le32		count;
 };
 
 struct aac_mount {
-	u32		status;
-	u32	   	type;           /* should be same as that requested */
-	u32		count;
+	__le32		status;
+	__le32	   	type;           /* should be same as that requested */
+	__le32		count;
 	struct aac_mntent mnt[1];
 };
 
+#define CT_READ_NAME 130
+struct aac_get_name {
+	__le32		command;	/* VM_ContainerConfig */
+	__le32		type;		/* CT_READ_NAME */
+	__le32		cid;
+	__le32		parm1;
+	__le32		parm2;
+	__le32		parm3;
+	__le32		parm4;
+	__le32		count;	/* sizeof(((struct aac_get_name_resp *)NULL)->data) */
+};
+
+struct aac_get_name_resp {
+	__le32		dummy0;
+	__le32		dummy1;
+	__le32		status;	/* CT_OK */
+	__le32		parm1;
+	__le32		parm2;
+	__le32		parm3;
+	__le32		parm4;
+	__le32		parm5;
+	u8		data[16];
+};
+
 /*
  * The following command is sent to shut down each container.
  */
 
 struct aac_close {
-	u32	command;
-	u32	cid;
+	__le32	command;
+	__le32	cid;
 };
 
 struct aac_query_disk
@@ -1246,6 +1661,17 @@ struct revision
 	u32 version;
 	u32 build;
 };
+
+#if (defined(CODE_STREAM_IDENTIFIER))
+#define VERSION_MATCH_SUCCESS		1
+#define VERSION_MATCH_FAILED		2
+#define VERSION_MATCH_UNSUPPORTED	3
+struct VersionMatch {
+	u32 status;
+	char driver[MAX_CODE_STREAM_IDENTIFIER_LENGTH];
+	char firmware[MAX_CODE_STREAM_IDENTIFIER_LENGTH];
+};
+#endif
 	
 /*
  * 	Ugly - non Linux like ioctl coding for back compat.
@@ -1277,7 +1703,10 @@ struct revision
 #define FSACTL_MINIPORT_REV_CHECK               CTL_CODE(2107, METHOD_BUFFERED)
 #define FSACTL_GET_PCI_INFO               	CTL_CODE(2119, METHOD_BUFFERED)
 #define FSACTL_FORCE_DELETE_DISK		CTL_CODE(2120, METHOD_NEITHER)
+#define FSACTL_REGISTER_FIB_SEND		CTL_CODE(2136, METHOD_BUFFERED)
 #define FSACTL_GET_CONTAINERS			2131
+#define FSACTL_GET_VERSION_MATCHING		CTL_CODE(2137, METHOD_BUFFERED)
+#define FSACTL_SEND_LARGE_FIB			CTL_CODE(2138, METHOD_BUFFERED)
 
 
 struct aac_common
@@ -1290,6 +1719,13 @@ struct aac_common
 	u32 peak_fibs;
 	u32 zero_fibs;
 	u32 fib_timeouts;
+#if (defined(AAC_DEBUG_INSTRUMENT_AAC_CONFIG))
+	u32 peak_size;
+	u32 peak_sg;
+#endif
+#if (defined(AAC_DEBUG_INSTRUMENT_TIMING))
+	u32 peak_duration;
+#endif
 	/*
 	 *	Statistical counters in debug mode
 	 */
@@ -1324,15 +1760,19 @@ extern struct aac_common aac_config;
  *	Monitor/Kernel API
  */
 
-#define	BREAKPOINT_REQUEST		cpu_to_le32(0x00000004)
-#define	INIT_STRUCT_BASE_ADDRESS	cpu_to_le32(0x00000005)
-#define READ_PERMANENT_PARAMETERS	cpu_to_le32(0x0000000a)
-#define WRITE_PERMANENT_PARAMETERS	cpu_to_le32(0x0000000b)
-#define HOST_CRASHING			cpu_to_le32(0x0000000d)
-#define	SEND_SYNCHRONOUS_FIB		cpu_to_le32(0x0000000c)
-#define	COMMAND_POST_RESULTS		cpu_to_le32(0x00000014)
-#define GET_ADAPTER_PROPERTIES		cpu_to_le32(0x00000019)
-#define RE_INIT_ADAPTER			cpu_to_le32(0x000000ee)
+#define	BREAKPOINT_REQUEST		0x00000004
+#define	INIT_STRUCT_BASE_ADDRESS	0x00000005
+#define READ_PERMANENT_PARAMETERS	0x0000000a
+#define WRITE_PERMANENT_PARAMETERS	0x0000000b
+#define HOST_CRASHING			0x0000000d
+#define	SEND_SYNCHRONOUS_FIB		0x0000000c
+#define COMMAND_POST_RESULTS		0x00000014
+#define GET_ADAPTER_PROPERTIES		0x00000019
+#define GET_DRIVER_BUFFER_PROPERTIES	0x00000023
+#define RCV_TEMP_READINGS		0x00000025
+#define GET_COMM_PREFERRED_SETTINGS	0x00000026
+#define IOP_RESET			0x00001000
+#define RE_INIT_ADAPTER			0x000000ee
 
 /*
  *	Adapter Status Register
@@ -1355,22 +1795,22 @@ extern struct aac_common aac_config;
  *	Phases are bit oriented.  It is NOT valid  to have multiple bits set						
  */					
 
-#define	SELF_TEST_FAILED		(cpu_to_le32(0x00000004))
-#define MONITOR_PANIC			(cpu_to_le32(0x00000020))
-#define	KERNEL_UP_AND_RUNNING		(cpu_to_le32(0x00000080))
-#define	KERNEL_PANIC			(cpu_to_le32(0x00000100))
+#define	SELF_TEST_FAILED		0x00000004
+#define	MONITOR_PANIC			0x00000020
+#define	KERNEL_UP_AND_RUNNING		0x00000080
+#define	KERNEL_PANIC			0x00000100
 
 /*
  *	Doorbell bit defines
  */
 
-#define DoorBellSyncCmdAvailable	cpu_to_le32(1<<0)	// Host -> Adapter
-#define DoorBellPrintfDone		cpu_to_le32(1<<5)	// Host -> Adapter
-#define DoorBellAdapterNormCmdReady	cpu_to_le32(1<<1)	// Adapter -> Host
-#define DoorBellAdapterNormRespReady	cpu_to_le32(1<<2)	// Adapter -> Host
-#define DoorBellAdapterNormCmdNotFull	cpu_to_le32(1<<3)	// Adapter -> Host
-#define DoorBellAdapterNormRespNotFull	cpu_to_le32(1<<4)	// Adapter -> Host
-#define DoorBellPrintfReady		cpu_to_le32(1<<5)	// Adapter -> Host
+#define DoorBellSyncCmdAvailable	(1<<0)	/* Host -> Adapter */
+#define DoorBellPrintfDone		(1<<5)	/* Host -> Adapter */
+#define DoorBellAdapterNormCmdReady	(1<<1)	/* Adapter -> Host */
+#define DoorBellAdapterNormRespReady	(1<<2)	/* Adapter -> Host */
+#define DoorBellAdapterNormCmdNotFull	(1<<3)	/* Adapter -> Host */
+#define DoorBellAdapterNormRespNotFull	(1<<4)	/* Adapter -> Host */
+#define DoorBellPrintfReady		(1<<5)	/* Adapter -> Host */
 
 /*
  *	For FIB communication, we need all of the following things
@@ -1413,8 +1853,8 @@ extern struct aac_common aac_config;
  */
 
 struct aac_aifcmd {
-	u32 command;		/* Tell host what type of notify this is */
-	u32 seqnum;		/* To allow ordering of reports (if necessary) */
+	__le32 command;		/* Tell host what type of notify this is */
+	__le32 seqnum;		/* To allow ordering of reports (if necessary) */
 	u8 data[1];		/* Undefined length (from kernel viewpoint) */
 };
 
@@ -1423,9 +1863,17 @@ struct aac_aifcmd {
  *  	accounting for the fact capacity could be a 64 bit value
  *
  */
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
+typedef unsigned long sector_t;
+
+#endif
 static inline u32 cap_to_cyls(sector_t capacity, u32 divisor)
 {
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
 	sector_div(capacity, divisor);
+#else
+	capacity /= divisor;
+#endif
 	return (u32)capacity;
 }
 
@@ -1437,27 +1885,44 @@ int fib_setup(struct aac_dev *dev);
 void fib_map_free(struct aac_dev *dev);
 void fib_free(struct fib * context);
 void fib_init(struct fib * context);
-void fib_dealloc(struct fib * context);
 void aac_printf(struct aac_dev *dev, u32 val);
-int fib_send(u16 command, struct fib * context, unsigned long size, int priority, int wait, int reply, fib_callback callback, void *ctxt);
+#if (defined(FSACTL_REGISTER_FIB_SEND))
+typedef int (*fib_send_t)(u16 command, struct fib * context, unsigned long size, int priority, int wait, int reply, fib_callback callback, void *ctxt);
+extern fib_send_t fib_send;
+#else
+#define aac_fib_send fib_send
+#endif
+int aac_fib_send(u16 command, struct fib * context, unsigned long size, int priority, int wait, int reply, fib_callback callback, void *ctxt);
 int aac_consumer_get(struct aac_dev * dev, struct aac_queue * q, struct aac_entry **entry);
-int aac_consumer_avail(struct aac_dev * dev, struct aac_queue * q);
 void aac_consumer_free(struct aac_dev * dev, struct aac_queue * q, u32 qnum);
 int fib_complete(struct fib * context);
 #define fib_data(fibctx) ((void *)(fibctx)->hw_fib->data)
 struct aac_dev *aac_init_adapter(struct aac_dev *dev);
+int aac_get_config_status(struct aac_dev *dev);
 int aac_get_containers(struct aac_dev *dev);
 int aac_scsi_cmd(struct scsi_cmnd *cmd);
 int aac_dev_ioctl(struct aac_dev *dev, int cmd, void __user *arg);
+#if (defined(AAC_CSMI))
+int aac_csmi_ioctl(struct aac_dev *dev, int cmd, void __user *arg);
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,11))
+#if ((LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)) ? defined(__x86_64__) : defined(CONFIG_COMPAT))
+void aac_csmi_register_ioctl32_conversion(void);
+void aac_csmi_unregister_ioctl32_conversion(void);
+#endif
+#endif
+#endif
 int aac_do_ioctl(struct aac_dev * dev, int cmd, void __user *arg);
 int aac_rx_init(struct aac_dev *dev);
 int aac_rkt_init(struct aac_dev *dev);
 int aac_sa_init(struct aac_dev *dev);
 unsigned int aac_response_normal(struct aac_queue * q);
 unsigned int aac_command_normal(struct aac_queue * q);
+unsigned int aac_intr_normal(struct aac_dev * dev, u32 Index);
 int aac_command_thread(struct aac_dev * dev);
 int aac_close_fib_context(struct aac_dev * dev, struct aac_fib_context *fibctx);
+int aac_atoi(char ** str);
 int fib_adapter_complete(struct fib * fibptr, unsigned short size);
 struct aac_driver_ident* aac_get_driver_ident(int devtype);
+int probe_container(struct aac_dev *dev, int cid);
 int aac_get_adapter_info(struct aac_dev* dev);
 int aac_send_shutdown(struct aac_dev *dev);
--- linux-2.6.8.1-t043-libata-update/drivers/scsi/aacraid/fwdebug.c	1970-01-01 03:00:00.000000000 +0300
+++ aacraid-drv/drivers/scsi/aacraid/fwdebug.c	2005-01-13 17:19:21.000000000 +0300
@@ -0,0 +1,343 @@
+/*
+ *	Adaptec AAC series RAID controller driver
+ *
+ * Copyright (c) 2004 Adaptec, Inc. (aacraid@adaptec.com)
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <stdarg.h>
+#include <linux/types.h>
+#include <linux/wait.h>
+#include <linux/spinlock.h>
+#include <asm/semaphore.h>
+#include <linux/kernel.h>
+#include <linux/blkdev.h>
+#include <linux/completion.h>
+#include <linux/string.h>
+#include <linux/sched.h>
+#include <linux/version.h>
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
+#include <scsi/scsi.h>
+#include <scsi/scsi_cmnd.h>
+#include <scsi/scsi_host.h>
+#else
+#include "scsi.h"
+#include "hosts.h"
+#endif
+#include "aacraid.h"
+#include "fwdebug.h"
+
+/*
+ * Debug flags to be put into the HBA flags field when initialized
+ */
+const unsigned long aac_debug_flags = /* Variable to setup with above flags. */
+/*			HBA_FLAGS_DBG_KERNEL_PRINT_B |		*/
+			HBA_FLAGS_DBG_FW_PRINT_B |
+			HBA_FLAGS_DBG_FUNCTION_ENTRY_B |
+			HBA_FLAGS_DBG_FUNCTION_EXIT_B |
+			HBA_FLAGS_DBG_ERROR_B |
+/*			HBA_FLAGS_DBG_INIT_B |			*/
+/*			HBA_FLAGS_DBG_OS_COMMANDS_B |		*/
+/*			HBA_FLAGS_DBG_SCAN_B |			*/
+/*			HBA_FLAGS_DBG_COALESCE_B |		*/
+/*			HBA_FLAGS_DBG_IOCTL_COMMANDS_B |	*/
+/*			HBA_FLAGS_DBG_SYNC_COMMANDS_B |		*/
+/*			HBA_FLAGS_DBG_COMM_B |			*/
+/*			HBA_FLAGS_DBG_AIF_B |			*/
+/*			HBA_FLAGS_DBG_CSMI_COMMANDS_B | 	*/
+/*			HBA_FLAGS_DBG_FLAGS_MASK | 		*/
+0;
+
+int aac_get_fw_debug_buffer(struct aac_dev * dev)
+{
+if (nblank(fwprintf(x))) {
+	u32 MonDriverBufferPhysAddrLow = 0;
+	u32 MonDriverBufferPhysAddrHigh = 0;
+	u32 MonDriverBufferSize = 0;
+	u32 MonDriverHeaderSize = 0;
+	u32 ReturnStatus = 0;
+
+	/*
+	 * Initialize the firmware print buffer fields
+	 */
+	dev->FwDebugBuffer_P = NULL;
+	dev->FwDebugFlags_P = NULL;
+	dev->FwDebugStrLength_P = NULL;
+	dev->FwDebugBLEDvalue_P = NULL;
+	dev->FwDebugBLEDflag_P = NULL;
+	dev->FwDebugBufferSize = 0;
+	dev->FwDebugFlags = 0;
+	dev->DebugFlags = 0;
+
+	/*
+	 * Get the firmware print buffer parameters from the firmware
+	 * If the command was successful map in the address.
+	 */
+	if (!aac_adapter_sync_cmd(dev, GET_DRIVER_BUFFER_PROPERTIES,
+	  0, 0, 0, 0, 0, 0,
+	  &ReturnStatus,
+	  &MonDriverBufferPhysAddrLow,
+	  &MonDriverBufferPhysAddrHigh,
+	  &MonDriverBufferSize,
+	  &MonDriverHeaderSize) && MonDriverBufferSize) {
+		unsigned long Offset = MonDriverBufferPhysAddrLow
+		                     - (dev->scsi_host_ptr->base & 0xffffffff);
+
+		/*
+		 * See if the address is already mapped in and if so set it up
+		 * from the base address
+		 */
+		if (((u32)(((u64)dev->scsi_host_ptr->base) >> 32)
+		  == MonDriverBufferPhysAddrHigh)
+		 && ((Offset + MonDriverBufferSize) < dev->base_size))
+			dev->FwDebugBuffer_P
+			  = ((unsigned char *)dev->regs.sa + Offset);
+
+		/*
+		 * If mapping went well, Set up the debug buffer fields in the
+		 * HBA structure from the data returned
+		 */
+		if (dev->FwDebugBuffer_P != NULL) {
+			dev->FwDebugFlags_P
+			  = (u32 *)(dev->FwDebugBuffer_P
+			  + FW_DEBUG_FLAGS_OFFSET);
+			dev->FwDebugStrLength_P
+			  = (u32 *)(dev->FwDebugBuffer_P
+			  + FW_DEBUG_STR_LENGTH_OFFSET);
+			dev->FwDebugBLEDvalue_P
+			  = dev->FwDebugBuffer_P
+			  + FW_DEBUG_BLED_OFFSET;
+			dev->FwDebugBLEDflag_P
+			  = dev->FwDebugBLEDvalue_P + 1;
+			dev->FwDebugBufferSize = MonDriverBufferSize;
+			dev->FwDebugBuffer_P += MonDriverHeaderSize;
+			dev->FwDebugFlags = 0;
+			dev->DebugFlags = aac_debug_flags;
+			return 1;
+		}
+	}
+
+	/*
+	 * The GET_DRIVER_BUFFER_PROPERTIES command failed
+	 */
+}
+	return 0;
+}
+
+#define PRINT_TIMEOUT (HZ/4) /* 1/4 second */
+
+void aac_fw_printf(struct aac_dev * dev, unsigned long PrintFlags, const char * fmt, ...)
+{
+if (nblank(fwprintf(x))) {
+	va_list args;
+	u32 Count;
+	unsigned long next_jiffies;
+	char PrintBuffer_P[PRINT_BUFFER_SIZE];
+
+	if ((((PrintFlags
+	  & ~(HBA_FLAGS_DBG_KERNEL_PRINT_B|HBA_FLAGS_DBG_FW_PRINT_B)) != 0)
+	  && (dev != NULL)
+	  && ((dev->DebugFlags & PrintFlags) == 0))
+	 || ((dev != NULL) && (dev->DebugFlags
+	   & (HBA_FLAGS_DBG_KERNEL_PRINT_B|HBA_FLAGS_DBG_FW_PRINT_B)) == 0))
+		return;
+	/*
+	 * Set up parameters and call sprintf function to format the data
+	 */
+	va_start(args, fmt);
+	vsprintf(PrintBuffer_P, fmt, args);
+	va_end(args);
+
+	/*
+	 * Make sure the HBA structure has been passed in for this section
+	 */
+	if ((dev != NULL) && (dev->FwDebugBufferSize)) {
+		/*
+		 * If we are set up for a Firmware print
+		 */
+		if ((dev->DebugFlags & HBA_FLAGS_DBG_FW_PRINT_B)
+		 && ((PrintFlags
+		  & (HBA_FLAGS_DBG_KERNEL_PRINT_B|HBA_FLAGS_DBG_FW_PRINT_B))
+		  != HBA_FLAGS_DBG_KERNEL_PRINT_B)) {
+			/*
+			 * Make sure the string size is within boundaries
+			 */
+			Count = strlen(PrintBuffer_P);
+			if (Count > dev->FwDebugBufferSize)
+				Count = (u16)dev->FwDebugBufferSize;
+
+			/*
+			 * Wait for no more than PRINT_TIMEOUT for the previous
+			 * message length to clear (the handshake).
+			 */
+			next_jiffies = jiffies + PRINT_TIMEOUT;
+			while ((next_jiffies - jiffies) >= 0) {
+				if (!(*dev->FwDebugStrLength_P))
+					break;
+				schedule();
+			}
+
+			/*
+			 * If the Length is clear, copy over the message, the
+			 * flags, and the length. Make sure the length is the
+			 * last because that is the signal for the Firmware to
+			 * pick it up.
+			 */
+			if (!(*dev->FwDebugStrLength_P)) {
+				memcpy(dev->FwDebugBuffer_P,
+				  PrintBuffer_P, Count);
+				*dev->FwDebugFlags_P = cpu_to_le32(dev->FwDebugFlags);
+				*dev->FwDebugStrLength_P = cpu_to_le32(Count);
+			} else
+				dev->DebugFlags &= ~HBA_FLAGS_DBG_FW_PRINT_B;
+		}
+
+		/*
+		 * If the Kernel Debug Print flag is set, send it off to the
+		 * Kernel debugger
+		 */
+		if ((dev->DebugFlags & HBA_FLAGS_DBG_KERNEL_PRINT_B)
+		 && ((PrintFlags
+		  & (HBA_FLAGS_DBG_KERNEL_PRINT_B|HBA_FLAGS_DBG_FW_PRINT_B))
+		  != HBA_FLAGS_DBG_FW_PRINT_B)) {
+			if (dev->FwDebugFlags & FW_DEBUG_FLAGS_NO_HEADERS_B)
+				printk ("%s", PrintBuffer_P);
+			else
+				printk (KERN_INFO "%s: %s\n",
+				  dev->scsi_host_ptr->hostt->proc_name,
+				  PrintBuffer_P);
+		}
+	}
+
+	/*
+	 * No HBA structure passed in so it has to be for the Kernel Debugger
+	 */
+	else if ((PrintFlags
+	  & (HBA_FLAGS_DBG_KERNEL_PRINT_B|HBA_FLAGS_DBG_FW_PRINT_B))
+	  != HBA_FLAGS_DBG_FW_PRINT_B) {
+		if ((dev != NULL)
+		 && (dev->FwDebugFlags & FW_DEBUG_FLAGS_NO_HEADERS_B))
+			printk ("%s", PrintBuffer_P);
+		else if (dev != NULL)
+			printk (KERN_INFO "%s: %s\n",
+			  dev->scsi_host_ptr->hostt->proc_name,
+			  PrintBuffer_P);
+		else
+			printk(KERN_INFO "%s\n", PrintBuffer_P);
+	}
+}
+}
+
+void aac_fw_print_mem(struct aac_dev * dev, unsigned long PrintFlags, u8 * Addr, int Count)
+{
+if (nblank(fwprintf(x))) {
+	int Offset, i;
+	u32 DebugFlags = 0;
+	char Buffer[100];
+	char * LineBuffer_P;
+
+	/*
+	 * If we have an HBA structure, save off the flags and set the no
+	 * headers flag so we don't have garbage between our lines of data
+	 */
+	if (dev != NULL) {
+		DebugFlags = dev->FwDebugFlags;
+		dev->FwDebugFlags |= FW_DEBUG_FLAGS_NO_HEADERS_B;
+	}
+
+	Offset = 0;
+
+	/*
+	 * Loop through all the data
+	 */
+	while (Offset < Count) {
+		/*
+		 * We will format each line into a buffer and then print out
+		 * the entire line so set the pointer to the beginning of the
+		 * buffer
+		 */
+		LineBuffer_P = Buffer;
+
+		/*
+		 * Set up the address in HEX
+		 */
+		sprintf(LineBuffer_P, "\n%04x  ", Offset);
+		LineBuffer_P += 6;
+
+		/*
+		 * Set up 16 bytes in HEX format
+		 */
+		for (i = 0; i < 16; ++i) {
+			/*
+			 * If we are past the count of data bytes to output,
+			 * pad with blanks
+			 */
+			sprintf (LineBuffer_P,
+			  (((Offset + i) >= Count) ? "   " : "%02x "),
+			  Addr[Offset + i]);
+			LineBuffer_P += 3;
+
+			/*
+			 * At the mid point we will put in a divider
+			 */
+			if (i == 7) {
+				sprintf (LineBuffer_P, "- ");
+				LineBuffer_P += 2;
+			}
+		}
+		/*
+		 * Now do the same 16 bytes at the end of the line in ASCII
+		 * format
+		 */
+		sprintf (LineBuffer_P, "  ");
+		LineBuffer_P += 2;
+		for (i = 0; i < 16; ++i) {
+			/*
+			 * If all data processed, OUT-O-HERE
+			 */
+			if ((Offset + i) >= Count)
+				break;
+
+			/*
+			 * If this is a printable ASCII character, convert it
+			 */
+			sprintf (LineBuffer_P,
+			  (((Addr[Offset + i] > 0x1F)
+			   && (Addr[Offset + i] < 0x7F))
+				? "%c"
+				: "."), Addr[Offset + i]);
+
+			++LineBuffer_P;
+		}
+		/*
+		 * The line is now formatted, so print it out
+		 */
+		aac_fw_printf(dev, PrintFlags, "%s", Buffer);
+
+		/*
+		 * Bump the offset by 16 for the next line
+		 */
+		Offset += 16;
+
+	}
+
+	/*
+	 * Restore the saved off flags
+	 */
+	if (dev != NULL)
+		dev->FwDebugFlags = DebugFlags;
+}
+}
--- linux-2.6.8.1-t043-libata-update/drivers/scsi/aacraid/csmi.h	1970-01-01 03:00:00.000000000 +0300
+++ aacraid-drv/drivers/scsi/aacraid/csmi.h	2004-12-17 15:54:52.000000000 +0300
@@ -0,0 +1,402 @@
+/*
+ *	Adaptec AAC series RAID controller driver
+ *	(c) Copyright 2004 Adaptec, Inc
+ *
+ * Copyright (c) 2004 Adaptec, Inc. (aacraid@adaptec.com)
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Module Name:
+ *   csmi.h
+ *
+ * Abstract: All CSMI IOCTL definitions are here
+ */
+
+/*
+ *	This file is based on the following CSMI revision
+ */
+#define	CSMI_MAJOR_REVISION	0
+#define	CSMI_MINOR_REVISION	82
+
+/*
+ *	IoctlHeader.ReturnCode
+ */
+#define	CSMI_SAS_STATUS_SUCCESS			0
+#define	CSMI_SAS_STATUS_FAILED			1
+#define	CSMI_SAS_STATUS_BAD_CNTL_CODE		2
+#define	CSMI_SAS_STATUS_INVALID_PARAMETER	3
+#define CSMI_SAS_PHY_INFO_NOT_CHANGEABLE	2000
+#define CSMI_SAS_NO_SATA_DEVICE			2009
+
+/*
+ *	Status.uStatus
+ */
+#define	CSMI_SAS_CNTLR_STATUS_GOOD	1
+#define	CSMI_SAS_CNTLR_STATUS_FAILED	2
+#define CSMI_SAS_CNTLR_STATUS_OFFLINE	3
+
+/*
+ *	Status.uOfflineReason
+ */
+#define CSMI_SAS_OFFLINE_REASON_NO_REASON	0
+
+/*
+ *	IoctlHeader.ControlCode
+ */
+#define CSMI_SAS_RAID_SET_OUT_OF_RANGE	1000
+
+/*
+ *	Parameters.uFlags
+ */
+#define	CSMI_SAS_STP_READ		0x00000001
+#define	CSMI_SAS_STP_DMA		0x00000020
+#define	CSMI_SAS_STP_DMA_QUEUED		0x00000080
+#define	CSMI_SAS_STP_RESET_DEVICE	0x00000200	
+
+/*
+ *	Status.bConnectionStatus
+ */
+#define	CSMI_SAS_OPEN_ACCEPT		0
+
+/*
+ *	Configuration.bIoBusType
+ */
+#define	CSMI_SAS_BUS_TYPE_PCI		3
+
+/*
+ *	Configuration.bControllerClass
+ */
+#define	CSMI_SAS_CNTLR_CLASS_HBA	5
+
+/*
+ *	Configuration.uControllerFlags
+ */
+#define	CSMI_SAS_CNTLR_SAS_HBA		0x00000001
+#define	CSMI_SAS_CNTLR_SAS_RAID		0x00000002
+#define	CSMI_SAS_CNTLR_SATA_HBA		0x00000004
+#define	CSMI_SAS_CNTLR_SATA_RAID	0x00000008
+
+/*
+ *	Configuration.usSlotNumber
+ */
+#define SLOT_NUMBER_UNKNOWN		0xFFFF
+
+/*
+ *	CSMI ioctl commands
+ */
+/* #define CSMI_ALL_SIGNATURE		"CSMIALL" */
+#define	CC_CSMI_SAS_GET_DRIVER_INFO	0xCC770001
+#define	CC_CSMI_SAS_GET_CNTLR_CONFIG	0xCC770002
+#define	CC_CSMI_SAS_GET_CNTLR_STATUS	0xCC770003
+#define	CC_CSMI_SAS_FIRMWARE_DOWNLOAD	0xCC770004
+
+/* #define CSMI_RAID_SIGNATURE		"CSMIARY" */
+#define	CC_CSMI_SAS_GET_RAID_INFO	0xCC77000A
+#define	CC_CSMI_SAS_GET_RAID_CONFIG	0xCC77000B
+
+/* #define CSMI_SAS_SIGNATURE		"CSMISAS" */
+#define	CC_CSMI_SAS_GET_PHY_INFO	0xCC770014
+#define	CC_CSMI_SAS_SET_PHY_INFO	0xCC770015
+#define	CC_CSMI_SAS_GET_LINK_ERRORS	0xCC770016
+#define	CC_CSMI_SAS_SSP_PASSTHRU	0xCC770017
+#define	CC_CSMI_SAS_SMP_PASSTHRU	0xCC770018
+#define	CC_CSMI_SAS_STP_PASSTHRU	0xCC770019
+#define CC_CSMI_SAS_GET_SATA_SIGNATURE	0xCC770020
+#define	CC_CSMI_SAS_GET_SCSI_ADDRESS	0xCC770021
+#define	CC_CSMI_SAS_GET_DEVICE_ADDRESS	0xCC770022
+#define	CC_CSMI_SAS_TASK_MANAGEMENT	0xCC770023
+#define	CC_CSMI_SAS_GET_CONNECTOR_INFO	0xCC770024
+
+/* #define CSMI_PHY_SIGNATURE		"CSMIPHY" */
+#define CC_CSMI_SAS_PHY_CONTROL		0xCC77003C
+
+typedef struct {
+	u32	IOControllerNumber;
+	u32	Length;
+	u32	ReturnCode;
+	u32	Timeout;
+	u16	Direction;
+#if (defined(CSMI_8_BYTE_ALIGNED))
+	u16	Reserved[3];
+#endif
+} IOCTL_HEADER;
+typedef IOCTL_HEADER *PIOCTL_HEADER;
+
+/* CC_CSMI_SAS_GET_DRIVER_INFO */
+
+typedef struct {
+	u8	szName[81];
+	u8	szDescription[81];
+	u16	usMajorRevision;
+	u16	usMinorRevision;
+	u16	usBuildRevision;
+	u16	usReleaseRevision;
+	u16	usCSMIMajorRevision;
+	u16	usCSMIMinorRevision;
+#if (defined(CSMI_8_BYTE_ALIGNED))
+	u16	usReserved;
+#endif
+} CSMI_SAS_DRIVER_INFO;
+
+typedef struct {
+	IOCTL_HEADER	IoctlHeader;
+	CSMI_SAS_DRIVER_INFO	Information;
+} CSMI_SAS_DRIVER_INFO_BUFFER;
+typedef CSMI_SAS_DRIVER_INFO_BUFFER * PCSMI_SAS_DRIVER_INFO_BUFFER;
+
+/* CC_CSMI_SAS_GET_CNTLR_CONFIG */
+
+typedef struct {
+	u8	bBusNumber;
+	u8	bDeviceNumber;
+	u8	bFunctionNumber;
+	u8	bReserved;
+} CSMI_SAS_PCI_BUS_ADDRESS;
+
+typedef union {
+	CSMI_SAS_PCI_BUS_ADDRESS	PciAddress;
+	u8	bReserved[32];
+} CSMI_SAS_IO_BUS_ADDRESS;
+
+typedef struct {
+	u32	uBaseIoAddress;
+#if (defined(CSMI_8_BYTE_ALIGNED))
+	u32	uReserved;
+#endif
+	struct {
+		u32	uLowPart;
+		u32	uHighPart;
+	} BaseMemoryAddress;
+	u32	uBoardID;
+	u16	usSlotNumber;
+	u8	bControllerClass;
+	u8	bIoBusType;
+	CSMI_SAS_IO_BUS_ADDRESS	BusAddress;
+	u8	szSerialNumber[81];
+#if (defined(CSMI_8_BYTE_ALIGNED))
+	u8	bReserve;
+#endif
+	u16	usMajorRevision;
+	u16	usMinorRevision;
+	u16	usBuildRevision;
+	u16	usReleaseRevision;
+	u16	usBIOSMajorRevision;
+	u16	usBIOSMinorRevision;
+	u16	usBIOSBuildRevision;
+	u16	usBIOSReleaseRevision;
+#if (defined(CSMI_8_BYTE_ALIGNED))
+	u16	usReserved;
+#endif
+	u32	uControllerFlags;
+	u16	usRromMajorRevision;
+	u16	usRromMinorRevision;
+	u16	usRromBuildRevision;
+	u16	usRromReleaseRevision;
+	u16	usRromBIOSMajorRevision;
+	u16	usRromBIOSMinorRevision;
+	u16	usRromBIOSBuildRevision;
+	u16	usRromBIOSReleaseRevision;
+	u8	bReserved[7];
+#if (defined(CSMI_8_BYTE_ALIGNED))
+	u8	bReserved1;
+#endif
+} CSMI_SAS_CNTLR_CONFIG;
+
+typedef struct {
+	IOCTL_HEADER	IoctlHeader;
+	CSMI_SAS_CNTLR_CONFIG	Configuration;
+} CSMI_SAS_CNTLR_CONFIG_BUFFER;
+typedef CSMI_SAS_CNTLR_CONFIG_BUFFER * PCSMI_SAS_CNTLR_CONFIG_BUFFER;
+
+/* CC_CSMI_SAS_GET_CNTLR_STATUS */
+
+typedef struct {
+	u32	uStatus;
+	u32	uOfflineReason;
+	u8	bReserved[28];
+#if (defined(CSMI_8_BYTE_ALIGNED))
+	u8	bReserved[4];
+#endif
+} CSMI_SAS_CNTLR_STATUS;
+
+typedef struct {
+	IOCTL_HEADER	IoctlHeader;
+	CSMI_SAS_CNTLR_STATUS	Status;
+} CSMI_SAS_CNTLR_STATUS_BUFFER;
+typedef CSMI_SAS_CNTLR_STATUS_BUFFER * PCSMI_SAS_CNTLR_STATUS_BUFFER;
+
+/* CC_CSMI_SAS_GET_SATA_SIGNATURE */
+
+typedef struct {
+	u8	pPhyIdentifier;
+	u8	bReserved[3];
+	u8	bSignatureFIS[20];
+} CSMI_SAS_SATA_SIGNATURE;
+
+typedef struct {
+	IOCTL_HEADER IoctlHeader;
+	CSMI_SAS_SATA_SIGNATURE Signature;
+} CSMI_SAS_SATA_SIGNATURE_BUFFER;
+typedef CSMI_SAS_SATA_SIGNATURE_BUFFER * PCSMI_SAS_SATA_SIGNATURE_BUFFER;
+
+/* CC_CSMI_SAS_GET_RAID_INFO */
+
+typedef struct {
+	u32	uNumRaidSets;
+	u32	uMaxDrivesPerSet;
+	u8	bReserved[92];
+#if (defined(CSMI_8_BYTE_ALIGNED))
+	u8	bReserved1[4];
+#endif
+} CSMI_SAS_RAID_INFO;
+
+typedef struct {
+	IOCTL_HEADER	IoctlHeader;
+	CSMI_SAS_RAID_INFO	Information;
+} CSMI_SAS_RAID_INFO_BUFFER;
+typedef CSMI_SAS_RAID_INFO_BUFFER * PCSMI_SAS_RAID_INFO_BUFFER;
+
+/* CC_CSMI_SAS_GET_RAID_CONFIG */
+
+typedef struct {
+	u8	bModel[40];
+	u8	bFirmware[8];
+	u8	bSerialNumber[40];
+	u8	bSASAddress[8];
+	u8	bSASLun[8];
+	u8	bDriveStatus;
+	u8	bDriveUsage;
+	u8	bReserved[30];
+} CSMI_SAS_RAID_DRIVES;
+
+typedef struct {
+	u32	uRaidSetIndex;
+	u32	uCapacity;
+	u32	uStripeSize;
+	u8	bRaidType;
+	u8	bStatus;
+	u8	bInformation;
+	u8	bDriveCount;
+	u8	bReserved[20];
+#if (defined(CSMI_8_BYTE_ALIGNED))
+	u8	bReserved1[4];
+#endif
+	CSMI_SAS_RAID_DRIVES	Drives[1];
+} CSMI_SAS_RAID_CONFIG;
+
+typedef struct {
+	IOCTL_HEADER IoctlHeader;
+	CSMI_SAS_RAID_CONFIG Configuration;
+} CSMI_SAS_RAID_CONFIG_BUFFER;
+typedef CSMI_SAS_RAID_CONFIG_BUFFER * PCSMI_SAS_RAID_CONFIG_BUFFER;
+
+/* CC_CSMI_SAS_GET_PHY_INFO */
+
+typedef struct {
+	u8	bDeviceType;
+	u8	bRestricted;
+	u8	bInitiatorPortProtocol;
+	u8	bTargetPortProtocol;
+	u8	bRestricted2[8];
+	u8	bSASAddress[8];
+	u8	bPhyIdentifier;
+	u8	bSignalClass;
+	u8	bReserved[6];
+#if (defined(CSMI_8_BYTE_ALIGNED))
+	u8	bReserved1[4];
+#endif
+} CSMI_SAS_IDENTIFY;
+
+typedef struct {
+	CSMI_SAS_IDENTIFY	Identify;
+	u8	bPortIdentifier;
+	u8	bNegotiatedLinkRate;
+	u8	bMinimumLinkRate;
+	u8	bMaximumLinkRate;
+	u8	bPhyChangeCount;
+	u8	bAutoDiscover;
+	u8	bReserved[2];
+	CSMI_SAS_IDENTIFY	Attached;
+} CSMI_SAS_PHY_ENTITY;
+
+typedef struct {
+	u8	bNumberofPhys;
+	u8	bReserved[3];
+#if (defined(CSMI_8_BYTE_ALIGNED))
+	u8	bReserved1[4];
+#endif
+	CSMI_SAS_PHY_ENTITY Phy[32];
+} CSMI_SAS_PHY_INFO;
+
+typedef struct {
+	IOCTL_HEADER IoctlHeader;
+	CSMI_SAS_PHY_INFO Information;
+} CSMI_SAS_PHY_INFO_BUFFER;
+typedef CSMI_SAS_PHY_INFO_BUFFER * PCSMI_SAS_PHY_INFO_BUFFER;
+
+/* CC_CSMI_SAS_SET_PHY_INFO */
+
+typedef struct {
+	u8	bPhyIdentifier;
+	u8	bNegotiatedLinkRate;
+	u8	bProgrammedMinimumLinkRate;
+	u8	bProgrammedMaximumLinkRate;
+	u8	bSignalClass;
+	u8	bReserved[3];
+} CSMI_SAS_SET_PHY_INFO;
+
+typedef struct {
+	IOCTL_HEADER IoctlHeader;
+	CSMI_SAS_SET_PHY_INFO Information;
+} CSMI_SAS_SET_PHY_INFO_BUFFER;
+typedef CSMI_SAS_SET_PHY_INFO_BUFFER * PCSMI_SAS_SET_PHY_INFO_BUFFER;
+
+/* CC_CSMI_SAS_STP_PASSTHRU */
+
+typedef struct {
+	u8	bPhyIdentifier;
+	u8	bPortIdentifier;
+	u8	bConnectionRate;
+	u8	bReserved;
+	u8	bDestinationSASAddress[8];
+	u8	bReserved2[4];
+	u8	bCommandFIS[20];
+	u32	uFlags;
+	u32	uDataLength;
+#if (defined(CSMI_8_BYTE_ALIGNED))
+	u32	uReserved;
+#endif
+} CSMI_SAS_STP_PASSTHRU;
+
+typedef struct {
+	u8	bConnectionStatus;
+	u8	bReserved[3];
+	u8	bStatusFIS[20];
+	u32	uSCR[16];
+	u32	uDataBytes;
+#if (defined(CSMI_8_BYTE_ALIGNED))
+	u32	uReserved;
+#endif
+} CSMI_SAS_STP_PASSTHRU_STATUS;
+
+typedef struct {
+	IOCTL_HEADER	IoctlHeader;
+	CSMI_SAS_STP_PASSTHRU	Parameters;
+	CSMI_SAS_STP_PASSTHRU_STATUS	Status;
+	u8	bDataBuffer[1];
+} CSMI_SAS_STP_PASSTHRU_BUFFER;
+typedef CSMI_SAS_STP_PASSTHRU_BUFFER * PCSMI_SAS_STP_PASSTHRU_BUFFER;
+
+int aac_csmi_ioctl(struct aac_dev *, int, void __user *);
--- linux-2.6.8.1-t043-libata-update/drivers/scsi/aacraid/dpcsup.c	2005-09-26 13:33:12.000000000 +0400
+++ aacraid-drv/drivers/scsi/aacraid/dpcsup.c	2005-04-27 16:46:03.000000000 +0400
@@ -39,6 +39,7 @@
 #include <linux/completion.h>
 #include <linux/blkdev.h>
 #include <asm/semaphore.h>
+#include <linux/version.h>
 
 #include "aacraid.h"
 
@@ -73,7 +74,7 @@ unsigned int aac_response_normal(struct 
 		int fast;
 		u32 index = le32_to_cpu(entry->addr);
 		fast = index & 0x01;
-		fib = &dev->fibs[index >> 1];
+		fib = &dev->fibs[index >> 2];
 		hwfib = fib->hw_fib;
 		
 		aac_consumer_free(dev, q, HostNormRespQueue);
@@ -99,7 +100,7 @@ unsigned int aac_response_normal(struct 
 			/*
 			 *	Doctor the fib
 			 */
-			*(u32 *)hwfib->data = cpu_to_le32(ST_OK);
+			*(__le32 *)hwfib->data = cpu_to_le32(ST_OK);
 			hwfib->header.XferState |= cpu_to_le32(AdapterProcessed);
 		}
 
@@ -134,8 +135,12 @@ unsigned int aac_response_normal(struct 
 		spin_lock_irqsave(q->lock, flags);
 	}
 
-	if (consumed > aac_config.peak_fibs)
+	if (consumed > aac_config.peak_fibs) {
 		aac_config.peak_fibs = consumed;
+#if (defined(AAC_DEBUG_INSTRUMENT_AAC_CONFIG))
+		printk("peak_fibs=%d\n", aac_config.peak_fibs);
+#endif
+	}
 	if (consumed == 0) 
 		aac_config.zero_fibs++;
 
@@ -174,17 +179,27 @@ unsigned int aac_command_normal(struct a
 		u32 index;
 		struct fib *fib = &fibctx;
 		
-		index = le32_to_cpu(entry->addr) / sizeof(struct hw_fib);
-		hw_fib = &dev->aif_base_va[index];
-		
 		/*
-		 *	Allocate a FIB at all costs. For non queued stuff
+		 *	Allocate a FIB. For non queued stuff
 		 *	we can just use the stack so we are happy. We need
 		 *	a fib object in order to manage the linked lists
 		 */
-		if (dev->aif_thread)
-			if((fib = kmalloc(sizeof(struct fib), GFP_ATOMIC)) == NULL)
+		if (dev->aif_thread) {
+			/* Limit the number we retreive from fib pool */
+			struct list_head * each;
+			int i = (le32_to_cpu(dev->init->AdapterFibsSize) / sizeof(struct hw_fib)) - 1;
+			list_for_each(each, &(q->cmdq))
+				if (--i <= 0)
+					break;
+			if ((i <= 0) || (!(fib = kmalloc(sizeof(struct fib),GFP_ATOMIC))))
 				fib = &fibctx;
+		}
+		index = le32_to_cpu(entry->addr) / sizeof(struct hw_fib);
+#if 0
+		printk(KERN_INFO "index=%d or %d\n", index,
+		  le32_to_cpu(entry->addr / sizeof(struct hw_fib)));
+#endif
+		hw_fib = &dev->aif_base_va[index];
 		
 		memset(fib, 0, sizeof(struct fib));
 		INIT_LIST_HEAD(&fib->fiblink);
@@ -205,7 +220,7 @@ unsigned int aac_command_normal(struct a
 			/*
 			 *	Set the status of this FIB
 			 */
-			*(u32 *)hw_fib->data = cpu_to_le32(ST_OK);
+			*(__le32 *)hw_fib->data = cpu_to_le32(ST_OK);
 			fib_adapter_complete(fib, sizeof(u32));
 			spin_lock_irqsave(q->lock, flags);
 		}		
@@ -213,3 +228,139 @@ unsigned int aac_command_normal(struct a
 	spin_unlock_irqrestore(q->lock, flags);
 	return 0;
 }
+
+
+/**
+ *	aac_intr_normal	-	Handle command replies
+ *	@dev: Device
+ *	@index: completion reference
+ *
+ *	This DPC routine will be run when the adapter interrupts us to let us
+ *	know there is a response on our normal priority queue. We will pull off
+ *	all QE there are and wake up all the waiters before exiting.
+ */
+
+unsigned int aac_intr_normal(struct aac_dev * dev, u32 Index)
+{
+	u32 index = le32_to_cpu(Index);
+
+	dprintk((KERN_INFO "aac_intr_normal(%p,%x)\n", dev, Index));
+	if ((index & 0x00000002L)) {
+		struct hw_fib * hw_fib;
+		struct fib * fib;
+		struct aac_queue *q = &dev->queues->queue[HostNormCmdQueue];
+		unsigned long flags;
+
+		if (index == 0xFFFFFFFEL) /* Special Case */
+			return 0;	  /* Do nothing */
+		/*
+		 *	Allocate a FIB. For non queued stuff we can just use
+		 * the stack so we are happy. We need a fib object in order to
+		 * manage the linked lists.
+		 */
+		if ((!dev->aif_thread)
+		 || (!(fib = kmalloc(sizeof(struct fib),GFP_ATOMIC))))
+			return 1;
+		if (!(hw_fib = kmalloc(sizeof(struct hw_fib),GFP_ATOMIC))) {
+			kfree (fib);
+			return 1;
+		}
+		memset(hw_fib, 0, sizeof(struct hw_fib));
+		memcpy(hw_fib, (struct hw_fib *)(((char *)(dev->regs.sa)) + (index & ~0x00000002L)), sizeof(struct hw_fib));
+		memset(fib, 0, sizeof(struct fib));
+		INIT_LIST_HEAD(&fib->fiblink);
+		fib->type = FSAFS_NTC_FIB_CONTEXT;
+		fib->size = sizeof(struct fib);
+		fib->hw_fib = hw_fib;
+		fib->data = hw_fib->data;
+		fib->dev = dev;
+	
+		spin_lock_irqsave(q->lock, flags);
+		list_add_tail(&fib->fiblink, &q->cmdq);
+	        wake_up_interruptible(&q->cmdready);
+		spin_unlock_irqrestore(q->lock, flags);
+		return 1;
+	} else {
+		int fast = index & 0x01;
+		struct fib * fib = &dev->fibs[index >> 2];
+		struct hw_fib * hwfib = fib->hw_fib;
+
+		/*
+		 *	Remove this fib from the Outstanding I/O queue.
+		 *	But only if it has not already been timed out.
+		 *
+		 *	If the fib has been timed out already, then just 
+		 *	continue. The caller has already been notified that
+		 *	the fib timed out.
+		 */
+		if ((fib->flags & FIB_CONTEXT_FLAG_TIMED_OUT)) {
+			printk(KERN_WARNING "aacraid: FIB timeout (%x).\n", fib->flags);
+			printk(KERN_DEBUG"aacraid: hwfib=%p index=%i fib=%p\n",hwfib, hwfib->header.SenderData,fib);
+			return 0;
+		}
+
+#if 0
+		if (fib->queue.prev == NULL)
+			printk(KERN_WARNING
+			  "aacraid: empty fib %d list prev\n", index >> 1);
+#if (defined(LIST_POISON2))
+		else if (fib->queue.prev == LIST_POISON2)
+			printk(KERN_WARNING
+			  "aacraid: poison fib %d list prev\n", index >> 1);
+#endif
+		if (fib->queue.next == NULL)
+			printk(KERN_WARNING
+			  "aacraid: empty fib %d list next\n", index >> 1);
+#if (defined(LIST_POISON1))
+		else if (fib->queue.next == LIST_POISON1)
+			printk(KERN_WARNING
+			  "aacraid: poison fib %d list next\n", index >> 1);
+#endif
+		else if ((fib->queue.prev != NULL)
+#if (defined(LIST_POISON2))
+		 && (fib->queue.prev != LIST_POISON2)
+#endif
+		)
+#endif
+		list_del(&fib->queue);
+		dev->queues->queue[AdapNormCmdQueue].numpending--;
+
+		if (fast) {
+			/*
+			 *	Doctor the fib
+			 */
+			*(__le32 *)hwfib->data = cpu_to_le32(ST_OK);
+			hwfib->header.XferState |= cpu_to_le32(AdapterProcessed);
+		}
+
+		FIB_COUNTER_INCREMENT(aac_config.FibRecved);
+
+		if (hwfib->header.Command == cpu_to_le16(NuFileSystem))
+		{
+			u32 *pstatus = (u32 *)hwfib->data;
+			if (*pstatus & cpu_to_le32(0xffff0000))
+				*pstatus = cpu_to_le32(ST_OK);
+		}
+		if (hwfib->header.XferState & cpu_to_le32(NoResponseExpected | Async)) 
+		{
+	        	if (hwfib->header.XferState & cpu_to_le32(NoResponseExpected))
+				FIB_COUNTER_INCREMENT(aac_config.NoResponseRecved);
+			else 
+				FIB_COUNTER_INCREMENT(aac_config.AsyncRecved);
+			/*
+			 *	NOTE:  we cannot touch the fib after this
+			 *	    call, because it may have been deallocated.
+			 */
+			fib->callback(fib->callback_data, fib);
+		} else {
+			unsigned long flagv;
+	  		dprintk((KERN_INFO "event_wait up\n"));
+			spin_lock_irqsave(&fib->event_lock, flagv);
+			fib->done = 1;
+			up(&fib->event_wait);
+			spin_unlock_irqrestore(&fib->event_lock, flagv);
+			FIB_COUNTER_INCREMENT(aac_config.NormalRecved);
+		}
+		return 0;
+	}
+}
--- linux-2.6.8.1-t043-libata-update/drivers/scsi/aacraid/Makefile	2005-09-26 13:33:12.000000000 +0400
+++ aacraid-drv/drivers/scsi/aacraid/Makefile	2005-04-21 15:27:23.000000000 +0400
@@ -1,8 +1,114 @@
 # Adaptec aacraid
 
+AAC_FLAGS := $(shell if [ ! -d ${TOPDIR}/drivers/scsi/aacraid ] ; then \
+	echo --error_Please_build_this_driver_in_the_Linux_Kernel_tree ; \
+fi)
+AAC_FLAGS += $(shell if [ -s ${TOPDIR}/drivers/scsi/hosts.h ] ; then \
+	if grep vary_io ${TOPDIR}/drivers/scsi/hosts.h >/dev/null 2>/dev/null ; then \
+		echo -DSCSI_HAS_VARY_IO ; \
+	fi ; \
+fi)
+AAC_FLAGS += $(shell if [ -s ${TOPDIR}/include/linux/delay.h ] ; then \
+	if grep ssleep ${TOPDIR}/include/linux/delay.h >/dev/null 2>/dev/null ; then \
+		echo -DSCSI_HAS_SSLEEP ; \
+	fi ; \
+fi)
+AAC_FLAGS += $(shell if [ -s ${TOPDIR}/include/scsi/scsi_device.h ] ; then \
+	if grep scsi_device_online ${TOPDIR}/include/scsi/scsi_device.h >/dev/null 2>/dev/null ; then \
+		echo -DSCSI_HAS_SCSI_DEVICE_ONLINE ; \
+	fi ; \
+fi)
+AAC_FLAGS += $(shell if [ -s ${TOPDIR}/include/scsi/scsi_host.h ] ; then \
+	if grep dump_poll ${TOPDIR}/include/scsi/scsi_host.h >/dev/null 2>/dev/null ; then \
+		echo -DSCSI_HAS_DUMP ; \
+	fi ; \
+fi)
+AAC_FLAGS += $(shell if [ -s ${TOPDIR}/include/scsi/scsi_host.h ] ; then \
+	if grep dump_sanity_check ${TOPDIR}/include/scsi/scsi_host.h >/dev/null 2>/dev/null ; then \
+		echo -DSCSI_HAS_DUMP_SANITY_CHECK ; \
+	fi ; \
+fi)
+AAC_FLAGS += $(shell if [ -s ${TOPDIR}/include/linux/types.h ] ; then \
+	if grep __bitwise ${TOPDIR}/include/linux/types.h >/dev/null 2>/dev/null ; then \
+		echo -DHAS_BITWISE_TYPE ; \
+	fi ; \
+fi)
+
+ifeq (${VERSION},2) # 2.x.x
+
+ifeq (${PATCHLEVEL},2) # 2.2.x
+
+CFILES_DRIVER=linit.c aachba.c commctrl.c comminit.c commsup.c \
+	dpcsup.c rx.c sa.c rkt.c fwdebug.c csmi.c
+
+IFILES_DRIVER=aacraid.h compat.h
+
+ALL_SOURCE=${CFILES_DRIVER} ${IFILES_DRIVER} 
+
+TARGET_OFILES=${CFILES_DRIVER:.c=.o}
+
+ifndef GCCVERSION
+GCCVERSION=2.96
+endif
+
+GCCMACHINE:=$(shell ls -d /usr/lib/gcc-lib/*/${GCCVERSION} | sed -n 1s@/${GCCVERSION}@@p)
+
+INCS=-I. -I.. -I../../../include -I/usr/src/linux/include -I/usr/src/linux/drivers/scsi 
+INCS=-nostdinc -I${GCCMACHINE}/${GCCVERSION}/include -I. -I..
+
+WARNINGS= -w -Wall -Wno-unused -Wno-switch -Wno-missing-prototypes -Wno-implicit
+
+COMMON_FLAGS=\
+	-D__KERNEL__=1 -DUNIX -DCVLOCK_USE_SPINLOCK -DLINUX \
+	-Wall -Wstrict-prototypes \
+	${INCS} \
+	${WARNINGS} \
+	-O2 -fomit-frame-pointer
+
+AACFLAGS=${COMMON_FLAGS} ${CFLAGS} ${EXTRA_FLAGS} ${AAC_FLAGS}
+COMPILE.c=${CC} ${AACFLAGS} ${TARGET_ARCH} -c
+
+.SUFFIXES:
+.SUFFIXES: .c .o .h .a
+
+all: source ${TARGET_OFILES} aacraid.o
+
+modules: all
+
+source: ${ALL_SOURCE}
+
+clean:
+	rm *.o
+
+aacraid.o: source ${TARGET_OFILES}
+	ld -r -o $@ $(TARGET_OFILES)
+	cp -r aacraid.o ../
+
+endif # 2.2.x
+
+ifeq (${PATCHLEVEL},4) # 2.4.x
+
+EXTRA_CFLAGS	+= -I$(TOPDIR)/drivers/scsi ${EXTRA_FLAGS} ${AAC_FLAGS}
+
+O_TARGET	:= aacraid.o
+obj-m		:= $(O_TARGET)
+
+obj-y		:= linit.o aachba.o commctrl.o comminit.o commsup.o \
+		   dpcsup.o rx.o sa.o rkt.o fwdebug.o csmi.o
+
+include $(TOPDIR)/Rules.make
+
+endif # 2.4.x
+
+ifeq (${PATCHLEVEL},6) # 2.6.x
+
 obj-$(CONFIG_SCSI_AACRAID) := aacraid.o
 
 aacraid-objs	:= linit.o aachba.o commctrl.o comminit.o commsup.o \
-		   dpcsup.o rx.o sa.o rkt.o
+		   dpcsup.o rx.o sa.o rkt.o fwdebug.o csmi.o
+
+EXTRA_CFLAGS	:= -Idrivers/scsi ${EXTRA_FLAGS} ${AAC_FLAGS}
+
+endif # 2.6.x
 
-EXTRA_CFLAGS	:= -Idrivers/scsi
+endif # 2.x.x
--- linux-2.6.8.1-t043-libata-update/drivers/scsi/aacraid/rkt.c	2005-09-26 13:33:12.000000000 +0400
+++ aacraid-drv/drivers/scsi/aacraid/rkt.c	2005-04-27 16:47:24.000000000 +0400
@@ -40,111 +40,91 @@
 #include <linux/completion.h>
 #include <linux/time.h>
 #include <linux/interrupt.h>
+#include <linux/version.h>	/* Needed for the following */
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,4,23))
+#if (!defined(IRQ_NONE))
+  typedef void irqreturn_t;
+# define IRQ_HANDLED
+# define IRQ_NONE
+#endif
+#endif
 #include <asm/semaphore.h>
 
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0))
+#include "scsi.h"
+#include "hosts.h"
+#else
 #include <scsi/scsi_host.h>
+#endif
 
 #include "aacraid.h"
 
 static irqreturn_t aac_rkt_intr(int irq, void *dev_id, struct pt_regs *regs)
 {
 	struct aac_dev *dev = dev_id;
-	unsigned long bellbits;
-	u8 intstat, mask;
-	intstat = rkt_readb(dev, MUnit.OISR);
-	/*
-	 *	Read mask and invert because drawbridge is reversed.
-	 *	This allows us to only service interrupts that have 
-	 *	been enabled.
-	 */
-	mask = ~(dev->OIMR);
-	/* Check to see if this is our interrupt.  If it isn't just return */
-	if (intstat & mask) 
-	{
-		bellbits = rkt_readl(dev, OutboundDoorbellReg);
-		if (bellbits & DoorBellPrintfReady) {
-			aac_printf(dev, le32_to_cpu(rkt_readl (dev, IndexRegs.Mailbox[5])));
-			rkt_writel(dev, MUnit.ODR,DoorBellPrintfReady);
-			rkt_writel(dev, InboundDoorbellReg,DoorBellPrintfDone);
-		}
-		else if (bellbits & DoorBellAdapterNormCmdReady) {
-			rkt_writel(dev, MUnit.ODR, DoorBellAdapterNormCmdReady);
-			aac_command_normal(&dev->queues->queue[HostNormCmdQueue]);
-		}
-		else if (bellbits & DoorBellAdapterNormRespReady) {
-			aac_response_normal(&dev->queues->queue[HostNormRespQueue]);
-			rkt_writel(dev, MUnit.ODR,DoorBellAdapterNormRespReady);
-		}
-		else if (bellbits & DoorBellAdapterNormCmdNotFull) {
-			rkt_writel(dev, MUnit.ODR, DoorBellAdapterNormCmdNotFull);
+
+	if (dev->new_comm_interface) {
+		u32 Index = rkt_readl(dev, MUnit.OutboundQueue);
+		if (Index == 0xFFFFFFFFL)
+			Index = rkt_readl(dev, MUnit.OutboundQueue);
+		if (Index != 0xFFFFFFFFL) {
+			do {
+				if (aac_intr_normal(dev, Index)) {
+					rkt_writel(dev, MUnit.OutboundQueue, Index);
+					rkt_writel(dev, MUnit.ODR, DoorBellAdapterNormRespReady);
+				}
+				Index = rkt_readl(dev, MUnit.OutboundQueue);
+			} while (Index != 0xFFFFFFFFL);
+			return IRQ_HANDLED;
 		}
-		else if (bellbits & DoorBellAdapterNormRespNotFull) {
-			rkt_writel(dev, MUnit.ODR, DoorBellAdapterNormCmdNotFull);
-			rkt_writel(dev, MUnit.ODR, DoorBellAdapterNormRespNotFull);
+	} else {
+		unsigned long bellbits;
+		u8 intstat;
+		intstat = rkt_readb(dev, MUnit.OISR);
+		/*
+		 *	Read mask and invert because drawbridge is reversed.
+		 *	This allows us to only service interrupts that have 
+		 *	been enabled.
+		 *	Check to see if this is our interrupt.  If it isn't just return
+		 */
+		if (intstat & ~(dev->OIMR))
+		{
+			bellbits = rkt_readl(dev, OutboundDoorbellReg);
+			if (bellbits & DoorBellPrintfReady) {
+				aac_printf(dev, rkt_readl (dev, IndexRegs.Mailbox[5]));
+				rkt_writel(dev, MUnit.ODR,DoorBellPrintfReady);
+				rkt_writel(dev, InboundDoorbellReg,DoorBellPrintfDone);
+			}
+			else if (bellbits & DoorBellAdapterNormCmdReady) {
+				rkt_writel(dev, MUnit.ODR, DoorBellAdapterNormCmdReady);
+				aac_command_normal(&dev->queues->queue[HostNormCmdQueue]);
+//				rkt_writel(dev, MUnit.ODR, DoorBellAdapterNormCmdReady);
+			}
+			else if (bellbits & DoorBellAdapterNormRespReady) {
+				rkt_writel(dev, MUnit.ODR,DoorBellAdapterNormRespReady);
+				aac_response_normal(&dev->queues->queue[HostNormRespQueue]);
+			}
+			else if (bellbits & DoorBellAdapterNormCmdNotFull) {
+				rkt_writel(dev, MUnit.ODR, DoorBellAdapterNormCmdNotFull);
+			}
+			else if (bellbits & DoorBellAdapterNormRespNotFull) {
+				rkt_writel(dev, MUnit.ODR, DoorBellAdapterNormCmdNotFull);
+				rkt_writel(dev, MUnit.ODR, DoorBellAdapterNormRespNotFull);
+			}
+			return IRQ_HANDLED;
 		}
-		return IRQ_HANDLED;
 	}
 	return IRQ_NONE;
 }
 
 /**
- *	aac_rkt_enable_interrupt	-	Enable event reporting
+ *	aac_rkt_disable_interrupt	-	Disable interrupts
  *	@dev: Adapter
- *	@event: Event to enable
- *
- *	Enable event reporting from the i960 for a given event.
  */
- 
-static void aac_rkt_enable_interrupt(struct aac_dev * dev, u32 event)
-{
-	switch (event) {
-
-	case HostNormCmdQue:
-		dev->irq_mask &= ~(OUTBOUNDDOORBELL_1);
-		break;
-
-	case HostNormRespQue:
-		dev->irq_mask &= ~(OUTBOUNDDOORBELL_2);
-		break;
 
-	case AdapNormCmdNotFull:
-		dev->irq_mask &= ~(OUTBOUNDDOORBELL_3);
-		break;
-
-	case AdapNormRespNotFull:
-		dev->irq_mask &= ~(OUTBOUNDDOORBELL_4);
-		break;
-	}
-}
-
-/**
- *	aac_rkt_disable_interrupt	-	Disable event reporting
- *	@dev: Adapter
- *	@event: Event to enable
- *
- *	Disable event reporting from the i960 for a given event.
- */
-
-static void aac_rkt_disable_interrupt(struct aac_dev *dev, u32 event)
+static void aac_rkt_disable_interrupt(struct aac_dev *dev)
 {
-	switch (event) {
-
-	case HostNormCmdQue:
-		dev->irq_mask |= (OUTBOUNDDOORBELL_1);
-		break;
-
-	case HostNormRespQue:
-		dev->irq_mask |= (OUTBOUNDDOORBELL_2);
-		break;
-
-	case AdapNormCmdNotFull:
-		dev->irq_mask |= (OUTBOUNDDOORBELL_3);
-		break;
-
-	case AdapNormRespNotFull:
-		dev->irq_mask |= (OUTBOUNDDOORBELL_4);
-		break;
-	}
+	rkt_writeb(dev, MUnit.OIMR, dev->OIMR = 0xff);
 }
 
 /**
@@ -154,25 +134,31 @@ static void aac_rkt_disable_interrupt(st
  *	@p1: first parameter
  *	@ret: adapter status
  *
- *	This routine will send a synchronous comamnd to the adapter and wait 
+ *	This routine will send a synchronous command to the adapter and wait 
  *	for its	completion.
  */
 
-static int rkt_sync_cmd(struct aac_dev *dev, u32 command, u32 p1, u32 *status)
+static int rkt_sync_cmd(struct aac_dev *dev, u32 command,
+	u32 p1, u32 p2, u32 p3, u32 p4, u32 p5, u32 p6,
+	u32 *status, u32 *r1, u32 *r2, u32 *r3, u32 *r4)
 {
 	unsigned long start;
 	int ok;
 	/*
 	 *	Write the command into Mailbox 0
 	 */
-	rkt_writel(dev, InboundMailbox0, cpu_to_le32(command));
+	rkt_writel(dev, InboundMailbox0, command);
 	/*
-	 *	Write the parameters into Mailboxes 1 - 4
+	 *	Write the parameters into Mailboxes 1 - 6
 	 */
-	rkt_writel(dev, InboundMailbox1, cpu_to_le32(p1));
-	rkt_writel(dev, InboundMailbox2, 0);
-	rkt_writel(dev, InboundMailbox3, 0);
-	rkt_writel(dev, InboundMailbox4, 0);
+	rkt_writel(dev, InboundMailbox1, p1);
+	rkt_writel(dev, InboundMailbox2, p2);
+	rkt_writel(dev, InboundMailbox3, p3);
+	rkt_writel(dev, InboundMailbox4, p4);
+#if (defined(AAC_LM_SENSOR))
+	rkt_writel(dev, InboundMailbox5, p5);
+	rkt_writel(dev, InboundMailbox6, p6);
+#endif
 	/*
 	 *	Clear the synch command doorbell to start on a clean slate.
 	 */
@@ -180,7 +166,7 @@ static int rkt_sync_cmd(struct aac_dev *
 	/*
 	 *	Disable doorbell interrupts
 	 */
-	rkt_writeb(dev, MUnit.OIMR, dev->OIMR |= 0x04);
+	rkt_writeb(dev, MUnit.OIMR, dev->OIMR = 0xff);
 	/*
 	 *	Force the completion of the mask register write before issuing
 	 *	the interrupt.
@@ -221,13 +207,25 @@ static int rkt_sync_cmd(struct aac_dev *
 		/*
 		 *	Restore interrupt mask even though we timed out
 		 */
-		rkt_writeb(dev, MUnit.OIMR, dev->OIMR &= 0xfb);
+		if (dev->new_comm_interface)
+			rkt_writeb(dev, MUnit.OIMR, dev->OIMR = 0xf7);
+		else
+			rkt_writeb(dev, MUnit.OIMR, dev->OIMR = 0xfb);
 		return -ETIMEDOUT;
 	}
 	/*
 	 *	Pull the synch status from Mailbox 0.
 	 */
-	*status = le32_to_cpu(rkt_readl(dev, IndexRegs.Mailbox[0]));
+	if (status)
+		*status = rkt_readl(dev, IndexRegs.Mailbox[0]);
+	if (r1)
+		*r1 = rkt_readl(dev, IndexRegs.Mailbox[1]);
+	if (r2)
+		*r2 = rkt_readl(dev, IndexRegs.Mailbox[2]);
+	if (r3)
+		*r3 = rkt_readl(dev, IndexRegs.Mailbox[3]);
+	if (r4)
+		*r4 = rkt_readl(dev, IndexRegs.Mailbox[4]);
 	/*
 	 *	Clear the synch command doorbell.
 	 */
@@ -235,7 +233,10 @@ static int rkt_sync_cmd(struct aac_dev *
 	/*
 	 *	Restore interrupt mask
 	 */
-	rkt_writeb(dev, MUnit.OIMR, dev->OIMR &= 0xfb);
+	if (dev->new_comm_interface)
+		rkt_writeb(dev, MUnit.OIMR, dev->OIMR = 0xf7);
+	else
+		rkt_writeb(dev, MUnit.OIMR, dev->OIMR = 0xfb);
 	return 0;
 
 }
@@ -249,8 +250,8 @@ static int rkt_sync_cmd(struct aac_dev *
 
 static void aac_rkt_interrupt_adapter(struct aac_dev *dev)
 {
-	u32 ret;
-	rkt_sync_cmd(dev, BREAKPOINT_REQUEST, 0, &ret);
+	rkt_sync_cmd(dev, BREAKPOINT_REQUEST, 0, 0, 0, 0, 0, 0,
+	  NULL, NULL, NULL, NULL, NULL);
 }
 
 /**
@@ -279,7 +280,8 @@ static void aac_rkt_notify_adapter(struc
 		rkt_writel(dev, MUnit.IDR,INBOUNDDOORBELL_3);
 		break;
 	case HostShutdown:
-//		rkt_sync_cmd(dev, HOST_CRASHING, 0, 0, 0, 0, &ret);
+//		rkt_sync_cmd(dev, HOST_CRASHING, 0, 0, 0, 0, 0, 0,
+//		  NULL, NULL, NULL, NULL, NULL);
 		break;
 	case FastIo:
 		rkt_writel(dev, MUnit.IDR,INBOUNDDOORBELL_6);
@@ -302,27 +304,13 @@ static void aac_rkt_notify_adapter(struc
 
 static void aac_rkt_start_adapter(struct aac_dev *dev)
 {
-	u32 status;
 	struct aac_init *init;
 
 	init = dev->init;
 	init->HostElapsedSeconds = cpu_to_le32(get_seconds());
-	/*
-	 *	Tell the adapter we are back and up and running so it will scan
-	 *	its command queues and enable our interrupts
-	 */
-	dev->irq_mask = (DoorBellPrintfReady | OUTBOUNDDOORBELL_1 | OUTBOUNDDOORBELL_2 | OUTBOUNDDOORBELL_3 | OUTBOUNDDOORBELL_4);
-	/*
-	 *	First clear out all interrupts.  Then enable the one's that we
-	 *	can handle.
-	 */
-	rkt_writeb(dev, MUnit.OIMR, 0xff);
-	rkt_writel(dev, MUnit.ODR, 0xffffffff);
-//	rkt_writeb(dev, MUnit.OIMR, ~(u8)OUTBOUND_DOORBELL_INTERRUPT_MASK);
-	rkt_writeb(dev, MUnit.OIMR, dev->OIMR = 0xfb);
-
 	// We can only use a 32 bit address here
-	rkt_sync_cmd(dev, INIT_STRUCT_BASE_ADDRESS, (u32)(ulong)dev->init_pa, &status);
+	rkt_sync_cmd(dev, INIT_STRUCT_BASE_ADDRESS, (u32)(ulong)dev->init_pa,
+	  0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL);
 }
 
 /**
@@ -334,7 +322,7 @@ static void aac_rkt_start_adapter(struct
  */
 static int aac_rkt_check_health(struct aac_dev *dev)
 {
-	long status = rkt_readl(dev, IndexRegs.Mailbox[7]);
+	u32 status = rkt_readl(dev, MUnit.OMRx[0]);
 
 	/*
 	 *	Check to see if the board failed any self tests.
@@ -344,34 +332,43 @@ static int aac_rkt_check_health(struct a
 	/*
 	 *	Check to see if the board panic'd.
 	 */
-	if (status & KERNEL_PANIC)
-	{
-		char * buffer = kmalloc(512, GFP_KERNEL|__GFP_DMA);
+	if (status & KERNEL_PANIC) {
+		char * buffer;
 		struct POSTSTATUS {
-			u32 Post_Command;
-			u32 Post_Address;
-		} * post = kmalloc(sizeof(struct POSTSTATUS), GFP_KERNEL);
-		dma_addr_t paddr = pci_map_single(dev->pdev, post, sizeof(struct POSTSTATUS), 2);
-		dma_addr_t baddr = pci_map_single(dev->pdev, buffer, 512, 1);
-		u32 status = -1;
-		int ret = -2;
-		
-		memset(buffer, 0, 512);
-		post->Post_Command = cpu_to_le32(COMMAND_POST_RESULTS);
-		post->Post_Address = cpu_to_le32(baddr);
-		rkt_writel(dev, MUnit.IMRx[0], cpu_to_le32(paddr));
-		rkt_sync_cmd(dev, COMMAND_POST_RESULTS, baddr, &status);
-		pci_unmap_single(dev->pdev, paddr, sizeof(struct POSTSTATUS),2);
-		kfree(post);
-		if ((buffer[0] == '0') && (buffer[1] == 'x')) {
-			ret = (buffer[2] <= '9') ? (buffer[2] - '0') : (buffer[2] - 'A' + 10);
-			ret <<= 4;
-			ret += (buffer[3] <= '9') ? (buffer[3] - '0') : (buffer[3] - 'A' + 10);
+			__le32 Post_Command;
+			__le32 Post_Address;
+		} * post;
+		dma_addr_t paddr, baddr;
+		int ret;
+
+		if ((status & 0xFF000000L) == 0xBC000000L)
+			return (status >> 16) & 0xFF;
+		buffer = pci_alloc_consistent(dev->pdev, 512, &baddr);
+		ret = -2;
+		if (buffer == NULL)
+			return ret;
+		post = pci_alloc_consistent(dev->pdev,
+		  sizeof(struct POSTSTATUS), &paddr);
+		if (post == NULL) {
+			pci_free_consistent(dev->pdev, 512, buffer, baddr);
+			return ret;
 		}
-		pci_unmap_single(dev->pdev, baddr, 512, 1);
-		kfree(buffer);
-		return ret;
-	}
+                memset(buffer, 0, 512);
+		post->Post_Command = cpu_to_le32(COMMAND_POST_RESULTS);
+                post->Post_Address = cpu_to_le32(baddr);
+                rkt_writel(dev, MUnit.IMRx[0], paddr);
+                rkt_sync_cmd(dev, COMMAND_POST_RESULTS, baddr, 0, 0, 0, 0, 0,
+		  NULL, NULL, NULL, NULL, NULL);
+		pci_free_consistent(dev->pdev, sizeof(struct POSTSTATUS),
+		  post, paddr);
+                if ((buffer[0] == '0') && (buffer[1] == 'x')) {
+                        ret = (buffer[2] <= '9') ? (buffer[2] - '0') : (buffer[2] - 'A' + 10);
+                        ret <<= 4;
+                        ret += (buffer[3] <= '9') ? (buffer[3] - '0') : (buffer[3] - 'A' + 10);
+                }
+		pci_free_consistent(dev->pdev, 512, buffer, baddr);
+                return ret;
+        }
 	/*
 	 *	Wait for the adapter to be up and running.
 	 */
@@ -384,6 +381,39 @@ static int aac_rkt_check_health(struct a
 }
 
 /**
+ *	aac_rkt_send
+ *	@fib: fib to issue
+ *
+ *	Will send a fib, returning 0 if successful.
+ */
+static int aac_rkt_send(struct fib * fib)
+{
+	u64 addr = fib->hw_fib_pa;
+	struct aac_dev *dev = fib->dev;
+	u32 * device = (u32 *)(dev->regs.rkt);
+	u32 Index;
+
+	dprintk((KERN_DEBUG "%p->aac_rkt_send(%p->%llx)\n", dev, fib, addr));
+	Index = rkt_readl(dev, MUnit.InboundQueue);
+	if (Index == 0xFFFFFFFFL)
+		Index = rkt_readl(dev, MUnit.InboundQueue);
+	dprintk((KERN_DEBUG "Index = 0x%x\n", Index));
+	if (Index == 0xFFFFFFFFL)
+		return Index;
+	device += Index / sizeof(u32);
+	dprintk((KERN_DEBUG "entry = %x %x %u\n", (u32)(addr & 0xffffffff),
+	  (u32)(addr >> 32), (u32)le16_to_cpu(fib->hw_fib->header.Size)));
+	writel((u32)(addr & 0xffffffff), device);
+	++device;
+	writel((u32)(addr >> 32), device);
+	++device;
+	writel(le16_to_cpu(fib->hw_fib->header.Size), device);
+	rkt_writel(dev, MUnit.InboundQueue, Index);
+	dprintk((KERN_DEBUG "aac_rkt_send - return 0\n"));
+	return 0;
+}
+
+/**
  *	aac_rkt_init	-	initialize an i960 based AAC card
  *	@dev: device to configure
  *
@@ -403,14 +433,6 @@ int aac_rkt_init(struct aac_dev *dev)
 	name     = dev->name;
 
 	/*
-	 *	Map in the registers from the adapter.
-	 */
-	if((dev->regs.rkt = (struct rkt_registers *)ioremap((unsigned long)dev->scsi_host_ptr->base, 8192))==NULL)
-	{	
-		printk(KERN_WARNING "aacraid: unable to map i960.\n" );
-		goto error_iounmap;
-	}
-	/*
 	 *	Check to see if the board failed any self tests.
 	 */
 	if (rkt_readl(dev, MUnit.OMRx[0]) & SELF_TEST_FAILED) {
@@ -435,12 +457,13 @@ int aac_rkt_init(struct aac_dev *dev)
 	/*
 	 *	Wait for the adapter to be up and running. Wait up to 3 minutes
 	 */
-	while (!(rkt_readl(dev, MUnit.OMRx[0]) & KERNEL_UP_AND_RUNNING))
+	while (!(rkt_readl(dev, MUnit.OMRx[0]) & KERNEL_UP_AND_RUNNING)) 
 	{
 		if(time_after(jiffies, start+180*HZ))
 		{
-			status = rkt_readl(dev, IndexRegs.Mailbox[7]) >> 16;
-			printk(KERN_ERR "%s%d: adapter kernel failed to start, init status = %ld.\n", dev->name, instance, status);
+			status = rkt_readl(dev, MUnit.OMRx[0]);
+			printk(KERN_ERR "%s%d: adapter kernel failed to start, init status = %lx.\n", 
+					dev->name, instance, status);
 			goto error_iounmap;
 		}
 		set_current_state(TASK_UNINTERRUPTIBLE);
@@ -455,14 +478,43 @@ int aac_rkt_init(struct aac_dev *dev)
 	 *	Fill in the function dispatch table.
 	 */
 	dev->a_ops.adapter_interrupt = aac_rkt_interrupt_adapter;
-	dev->a_ops.adapter_enable_int = aac_rkt_enable_interrupt;
 	dev->a_ops.adapter_disable_int = aac_rkt_disable_interrupt;
 	dev->a_ops.adapter_notify = aac_rkt_notify_adapter;
 	dev->a_ops.adapter_sync_cmd = rkt_sync_cmd;
 	dev->a_ops.adapter_check_health = aac_rkt_check_health;
+	dev->a_ops.adapter_send = aac_rkt_send;
+#if (defined(SCSI_HAS_DUMP))
+	dev->a_ops.adapter_intr = aac_rkt_intr;
+#endif
+
+	/*
+	 *	First clear out all interrupts.  Then enable the one's that we
+	 *	can handle.
+	 */
+	rkt_writeb(dev, MUnit.OIMR, 0xff);
+	rkt_writel(dev, MUnit.ODR, 0xffffffff);
+	rkt_writeb(dev, MUnit.OIMR, dev->OIMR = 0xfb);
 
 	if (aac_init_adapter(dev) == NULL)
 		goto error_irq;
+	if (dev->new_comm_interface) {
+		/*
+		 * FIB Setup has already been done, but we can minimize the
+		 * damage by at least ensuring the OS never issues more
+		 * commands than we can handle. The Rocket adapters currently
+		 * can only handle 246 commands and 8 AIFs at the same time,
+		 * and in fact do notify us accordingly if we negotiate the
+		 * FIB size. The problem that causes us to add this check is
+		 * to ensure that we do not overdo it with the adapter when a
+		 * hard coded FIB override is being utilized. This special
+		 * case warrants this half baked, but convenient, check here.
+		 */
+		if (dev->scsi_host_ptr->can_queue > (246 - AAC_NUM_MGT_FIB)) {
+			dev->init->MaxIoCommands = cpu_to_le32(246);
+			dev->scsi_host_ptr->can_queue = 246 - AAC_NUM_MGT_FIB;
+		}
+		rkt_writeb(dev, MUnit.OIMR, dev->OIMR = 0xf7);
+	}
 	/*
 	 *	Start any kernel threads needed
 	 */
@@ -483,10 +535,10 @@ error_kfree:
 	kfree(dev->queues);
 
 error_irq:
+	rkt_writeb(dev, MUnit.OIMR, dev->OIMR = 0xff);
 	free_irq(dev->scsi_host_ptr->irq, (void *)dev);
 
 error_iounmap:
-	iounmap(dev->regs.rkt);
 
 	return -1;
 }
--- linux-2.6.8.1-t043-libata-update/drivers/scsi/aacraid/dkms.conf	1970-01-01 03:00:00.000000000 +0300
+++ aacraid-drv/drivers/scsi/aacraid/dkms.conf	2005-05-13 19:59:51.000000000 +0400
@@ -0,0 +1,11 @@
+PACKAGE_VERSION="1.1.5.2400"
+
+# Items below here should not have to change with each driver version
+PACKAGE_NAME="aacraid"
+MAKE[0]="make -C ${kernel_source_dir} SUBDIRS=${dkms_tree}/${PACKAGE_NAME}/${PACKAGE_VERSION}/build modules"
+CLEAN="make -C ${kernel_source_dir} SUBDIRS=${dkms_tree}/${PACKAGE_NAME}/${PACKAGE_VERSION}/build clean"
+BUILT_MODULE_NAME[0]="aacraid"
+DEST_MODULE_LOCATION[0]="/kernel/drivers/scsi/aacraid/"
+REMAKE_INITRD="yes"
+MODULES_CONF_ALIAS_TYPE="scsi_hostadapter"
+MODULES_CONF_OBSOLETES_ONLY[0]="aacraid"
--- linux-2.6.8.1-t043-libata-update/drivers/scsi/aacraid/README	2005-09-26 13:33:12.000000000 +0400
+++ aacraid-drv/drivers/scsi/aacraid/README	2005-04-21 00:11:43.000000000 +0400
@@ -10,14 +10,24 @@ the original).
 
 Supported Cards/Chipsets
 -------------------------
-	AAR-2410SA SATA
+	Adaptec 2020S
+	Adaptec 2025S
 	Adaptec 2120S
+	Adaptec 2130S
 	Adaptec 2200S
 	Adaptec 2230S
+	Adaptec 2240S
+	Adaptec 2410SA
+	Adaptec 2610SA
+	Adaptec 2810SA
+	Adaptec 21610SA
 	Adaptec 3230S
 	Adaptec 3240S
+	Adaptec 4000SAS
+	Adaptec 4005SAS
+	Adaptec 4800SAS
+	Adaptec 4805SAS
 	Adaptec 5400S
-	ASR-2020S PCI-X
 	Dell PERC 2 Quad Channel
 	Dell PERC 2/Si
 	Dell PERC 3/Si
@@ -26,6 +36,13 @@ Supported Cards/Chipsets
 	HP NetRAID-4M
 	Legend S220
 	Legend S230
+	IBM ServeRAID 8i
+	ICP 9014R0
+	ICP 9024R0
+	ICP 9047MA
+	ICP 9087MA
+	ICP 9085LI
+	ICP 5085AU
 
 People
 -------------------------
@@ -33,7 +50,7 @@ Alan Cox <alan@redhat.com>
 Christoph Hellwig <hch@infradead.org>	(updates for new-style PCI probing and SCSI host registration,
 					 small cleanups/fixes)
 Matt Domsch <matt_domsch@dell.com>	(revision ioctl, adapter messages)
-Deanna Bonds <deanna_bonds@adaptec.com> (non-DASD support, PAE fibs and 64 bit, added new adaptec controllers
+Deanna Bonds                            (non-DASD support, PAE fibs and 64 bit, added new adaptec controllers
 					 added new ioctls, changed scsi interface to use new error handler,
 					 increased the number of fibs and outstanding commands to a container)
 
@@ -49,7 +66,6 @@ Adaptec Unix OEM Product Group
 Mailing List
 -------------------------
 linux-scsi@vger.kernel.org (Interested parties troll here)
-http://mbserver.adaptec.com/ (Currently more Community Support than Devel Support)
 Also note this is very different to Brian's original driver
 so don't expect him to support it.
 Adaptec does support this driver.  Contact either tech support or Mark Salyzyn.
--- linux-2.6.8.1-t043-libata-update/drivers/scsi/aacraid/linit.c	2005-09-26 13:33:12.000000000 +0400
+++ aacraid-drv/drivers/scsi/aacraid/linit.c	2005-05-04 21:02:24.000000000 +0400
@@ -27,25 +27,59 @@
  * Abstract: Linux Driver entry module for Adaptec RAID Array Controller
  */
 
-#define AAC_DRIVER_VERSION		"1.1.2-lk2"
-#define AAC_DRIVER_BUILD_DATE		__DATE__
+#define AAC_DRIVER_VERSION		"1.1-5"
+#define AAC_DRIVER_BUILD_DATE		__DATE__ " " __TIME__
 #define AAC_DRIVERNAME			"aacraid"
 
+#if (defined(AAC_DRIVER_BUILD))
+#define _str(x) #x
+#define str(x) _str(x)
+#if (defined(AAC_DRIVER_BRANCH))
+#define AAC_DRIVER_FULL_VERSION	AAC_DRIVER_VERSION "[" str(AAC_DRIVER_BUILD) "]" AAC_DRIVER_BRANCH
+#else
+#define AAC_DRIVER_FULL_VERSION	AAC_DRIVER_VERSION "[" str(AAC_DRIVER_BUILD) "]"
+#endif
+#else
+#if (defined(AAC_DRIVER_BRANCH))
+#define AAC_DRIVER_FULL_VERSION	AAC_DRIVER_VERSION AAC_DRIVER_BRANCH " " AAC_DRIVER_BUILD_DATE
+#else
+#define AAC_DRIVER_FULL_VERSION	AAC_DRIVER_VERSION " " AAC_DRIVER_BUILD_DATE
+#endif
+#endif
+
+#include <linux/version.h> /* for the following test */
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,3))
 #include <linux/compat.h>
+#endif
 #include <linux/blkdev.h>
 #include <linux/completion.h>
 #include <linux/init.h>
 #include <linux/interrupt.h>
 #include <linux/kernel.h>
 #include <linux/module.h>
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,3))
 #include <linux/moduleparam.h>
+#else
+#include <linux/config.h>
+#include <linux/types.h>
+#include <linux/sched.h>
+#endif
 #include <linux/pci.h>
 #include <linux/slab.h>
 #include <linux/spinlock.h>
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,3))
 #include <linux/syscalls.h>
 #include <linux/ioctl32.h>
+#endif
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,9)) || defined(SCSI_HAS_SSLEEP)
+#include <linux/delay.h>
+#endif
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
+#include <linux/dma-mapping.h>
+#endif
 #include <asm/semaphore.h>
 
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
 #include <scsi/scsi.h>
 #include <scsi/scsi_cmnd.h>
 #include <scsi/scsi_device.h>
@@ -53,28 +87,49 @@
 #include <scsi/scsi_tcq.h>
 #include <scsi/scsicam.h>
 #include <scsi/scsi_eh.h>
+#else
+#include "scsi.h"
+#include "hosts.h"
+#include "sd.h"
+#include <linux/blk.h>	/* for io_request_lock definition */
+#endif
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,11))
+#if ((LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)) ? defined(__x86_64__) : defined(CONFIG_COMPAT))
+#if ((KERNEL_VERSION(2,4,19) <= LINUX_VERSION_CODE) && (LINUX_VERSION_CODE <= KERNEL_VERSION(2,4,21)))
+# include <asm-x86_64/ioctl32.h>
+#elif (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
+# include <asm/ioctl32.h>
+#elif (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,3))
+# include <linux/ioctl32.h>
+#endif
+  /* Cast the function, since sys_ioctl does not match */
+# define aac_ioctl32(x,y) register_ioctl32_conversion((x), \
+    (int(*)(unsigned int,unsigned int,unsigned long,struct file*))(y))
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
+# include <asm/uaccess.h>
+#endif
+#endif
+#endif
+#include <linux/reboot.h>
 
 #include "aacraid.h"
+#include "fwdebug.h"
 
 
 MODULE_AUTHOR("Red Hat Inc and Adaptec");
 MODULE_DESCRIPTION("Dell PERC2, 2/Si, 3/Si, 3/Di, "
 		   "Adaptec Advanced Raid Products, "
 		   "and HP NetRAID-4M SCSI driver");
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,4,7))
 MODULE_LICENSE("GPL");
+#endif
+#if ((LINUX_VERSION_CODE > KERNEL_VERSION(2,6,3)) || defined(MODULE_VERSION))
+MODULE_VERSION(AAC_DRIVER_FULL_VERSION);
+#endif
 
-
-int nondasd = -1;
-module_param(nondasd, int, S_IRUGO|S_IWUSR);
-MODULE_PARM_DESC(nondasd, "Control scanning of hba for nondasd devices. 0=off, 1=on");
-
-int paemode = -1;
-module_param(paemode, int, S_IRUGO|S_IWUSR);
-MODULE_PARM_DESC(paemode, "Control whether dma addressing is using PAE. 0=off, 1=on");
-
-struct aac_dev *aac_devices[MAXIMUM_NUM_ADAPTERS];
-static unsigned aac_count;
+LIST_HEAD(aac_devices);
 static int aac_cfg_major = -1;
+char aac_driver_version[] = AAC_DRIVER_FULL_VERSION;
 
 /*
  * Because of the way Linux names scsi devices, the order in this table has
@@ -83,44 +138,69 @@ static int aac_cfg_major = -1;
  * Note: The last field is used to index into aac_drivers below.
  */
 static struct pci_device_id aac_pci_tbl[] = {
-	{ 0x1028, 0x0001, 0x1028, 0x0001, 0, 0, 0 }, /* PERC 2/Si */
-	{ 0x1028, 0x0002, 0x1028, 0x0002, 0, 0, 1 }, /* PERC 3/Di */
-	{ 0x1028, 0x0003, 0x1028, 0x0003, 0, 0, 2 }, /* PERC 3/Si */
-	{ 0x1028, 0x0004, 0x1028, 0x00d0, 0, 0, 3 }, /* PERC 3/Si */
-	{ 0x1028, 0x0002, 0x1028, 0x00d1, 0, 0, 4 }, /* PERC 3/Di */
-	{ 0x1028, 0x0002, 0x1028, 0x00d9, 0, 0, 5 }, /* PERC 3/Di */
-	{ 0x1028, 0x000a, 0x1028, 0x0106, 0, 0, 6 }, /* PERC 3/Di */
-	{ 0x1028, 0x000a, 0x1028, 0x011b, 0, 0, 7 }, /* PERC 3/Di */
-	{ 0x1028, 0x000a, 0x1028, 0x0121, 0, 0, 8 }, /* PERC 3/Di */
-	{ 0x9005, 0x0283, 0x9005, 0x0283, 0, 0, 9 }, /* catapult*/
-	{ 0x9005, 0x0284, 0x9005, 0x0284, 0, 0, 10 }, /* tomcat*/
-	{ 0x9005, 0x0285, 0x9005, 0x0286, 0, 0, 11 }, /* Adaptec 2120S (Crusader)*/
-	{ 0x9005, 0x0285, 0x9005, 0x0285, 0, 0, 12 }, /* Adaptec 2200S (Vulcan)*/
-	{ 0x9005, 0x0285, 0x9005, 0x0287, 0, 0, 13 }, /* Adaptec 2200S (Vulcan-2m)*/
-	{ 0x9005, 0x0285, 0x17aa, 0x0286, 0, 0, 14 }, /* Legend S220*/
-	{ 0x9005, 0x0285, 0x17aa, 0x0287, 0, 0, 15 }, /* Legend S230*/
-
-	{ 0x9005, 0x0285, 0x9005, 0x0288, 0, 0, 16 }, /* Adaptec 3230S (Harrier)*/
-	{ 0x9005, 0x0285, 0x9005, 0x0289, 0, 0, 17 }, /* Adaptec 3240S (Tornado)*/
-	{ 0x9005, 0x0285, 0x9005, 0x028a, 0, 0, 18 }, /* ASR-2020 ZCR PCI-X U320 */
-	{ 0x9005, 0x0285, 0x9005, 0x028b, 0, 0, 19 }, /* ASR-2025 ZCR DIMM U320 */
-	{ 0x9005, 0x0285, 0x9005, 0x0290, 0, 0, 20 }, /* AAR-2410SA PCI SATA 4ch (Jaguar II)*/
-
-	{ 0x9005, 0x0285, 0x1028, 0x0287, 0, 0, 21 }, /* Perc 320/DC*/
-	{ 0x1011, 0x0046, 0x9005, 0x0365, 0, 0, 22 }, /* Adaptec 5400S (Mustang)*/
-	{ 0x1011, 0x0046, 0x9005, 0x0364, 0, 0, 23 }, /* Adaptec 5400S (Mustang)*/
-	{ 0x1011, 0x0046, 0x9005, 0x1364, 0, 0, 24 }, /* Dell PERC2 "Quad Channel" */
-	{ 0x1011, 0x0046, 0x103c, 0x10c2, 0, 0, 25 }, /* HP NetRAID-4M */
-
-	{ 0x9005, 0x0285, 0x1028, 0x0291, 0, 0, 26 }, /* CERC SATA RAID 2 PCI SATA 6ch (DellCorsair) */
-	{ 0x9005, 0x0285, 0x9005, 0x0292, 0, 0, 27 }, /* AAR-2810SA PCI SATA 8ch (Corsair-8) */
-	{ 0x9005, 0x0285, 0x9005, 0x0293, 0, 0, 28 }, /* AAR-21610SA PCI SATA 16ch (Corsair-16) */
-	{ 0x9005, 0x0285, 0x9005, 0x0294, 0, 0, 29 }, /* ESD SO-DIMM PCI-X SATA ZCR (Prowler) */
-	{ 0x9005, 0x0285, 0x0E11, 0x0295, 0, 0, 30 }, /* SATA 6Ch (Bearcat) */
-
-	{ 0x9005, 0x0286, 0x9005, 0x028c, 0, 0, 31 }, /* ASR-2230S + ASR-2230SLP PCI-X (Lancer) */
-	{ 0x9005, 0x0285, 0x9005, 0x028e, 0, 0, 32 }, /* ASR-2020SA      (ZCR PCI-X SATA) */
-	{ 0x9005, 0x0285, 0x9005, 0x028f, 0, 0, 33 }, /* ASR-2025SA      (ZCR DIMM SATA) */
+	{ 0x1028, 0x0001, 0x1028, 0x0001, 0, 0, 0 }, /* PERC 2/Si (Iguana/PERC2Si) */
+	{ 0x1028, 0x0002, 0x1028, 0x0002, 0, 0, 1 }, /* PERC 3/Di (Opal/PERC3Di) */
+	{ 0x1028, 0x0003, 0x1028, 0x0003, 0, 0, 2 }, /* PERC 3/Si (SlimFast/PERC3Si */
+	{ 0x1028, 0x0004, 0x1028, 0x00d0, 0, 0, 3 }, /* PERC 3/Di (Iguana FlipChip/PERC3DiF */
+	{ 0x1028, 0x0002, 0x1028, 0x00d1, 0, 0, 4 }, /* PERC 3/Di (Viper/PERC3DiV) */
+	{ 0x1028, 0x0002, 0x1028, 0x00d9, 0, 0, 5 }, /* PERC 3/Di (Lexus/PERC3DiL) */
+	{ 0x1028, 0x000a, 0x1028, 0x0106, 0, 0, 6 }, /* PERC 3/Di (Jaguar/PERC3DiJ) */
+	{ 0x1028, 0x000a, 0x1028, 0x011b, 0, 0, 7 }, /* PERC 3/Di (Dagger/PERC3DiD) */
+	{ 0x1028, 0x000a, 0x1028, 0x0121, 0, 0, 8 }, /* PERC 3/Di (Boxster/PERC3DiB) */
+	{ 0x9005, 0x0283, 0x9005, 0x0283, 0, 0, 9 }, /* catapult */
+	{ 0x9005, 0x0284, 0x9005, 0x0284, 0, 0, 10 }, /* tomcat */
+	{ 0x9005, 0x0285, 0x9005, 0x0286, 0, 0, 11 }, /* Adaptec 2120S (Crusader) */
+	{ 0x9005, 0x0285, 0x9005, 0x0285, 0, 0, 12 }, /* Adaptec 2200S (Vulcan) */
+	{ 0x9005, 0x0285, 0x9005, 0x0287, 0, 0, 13 }, /* Adaptec 2200S (Vulcan-2m) */
+	{ 0x9005, 0x0285, 0x17aa, 0x0286, 0, 0, 14 }, /* Legend S220 (Legend Crusader) */
+	{ 0x9005, 0x0285, 0x17aa, 0x0287, 0, 0, 15 }, /* Legend S230 (Legend Vulcan) */
+
+	{ 0x9005, 0x0285, 0x9005, 0x0288, 0, 0, 16 }, /* Adaptec 3230S (Harrier) */
+	{ 0x9005, 0x0285, 0x9005, 0x0289, 0, 0, 17 }, /* Adaptec 3240S (Tornado) */
+	{ 0x9005, 0x0285, 0x9005, 0x028a, 0, 0, 18 }, /* ASR-2020ZCR SCSI PCI-X ZCR (Skyhawk) */
+	{ 0x9005, 0x0285, 0x9005, 0x028b, 0, 0, 19 }, /* ASR-2025ZCR SCSI SO-DIMM PCI-X ZCR (Terminator) */
+	{ 0x9005, 0x0286, 0x9005, 0x028c, 0, 0, 20 }, /* ASR-2230S + ASR-2230SLP PCI-X (Lancer) */
+	{ 0x9005, 0x0286, 0x9005, 0x028d, 0, 0, 21 }, /* ASR-2130S (Lancer) */
+	{ 0x9005, 0x0286, 0x9005, 0x029b, 0, 0, 22 }, /* AAR-2820SA (Intruder) */
+	{ 0x9005, 0x0286, 0x9005, 0x029c, 0, 0, 23 }, /* AAR-2620SA (Intruder) */
+	{ 0x9005, 0x0286, 0x9005, 0x029d, 0, 0, 24 }, /* AAR-2420SA (Intruder) */
+	{ 0x9005, 0x0286, 0x9005, 0x029e, 0, 0, 25 }, /* ICP9024R0 (Lancer) */
+	{ 0x9005, 0x0286, 0x9005, 0x029f, 0, 0, 26 }, /* ICP9014R0 (Lancer) */
+	{ 0x9005, 0x0286, 0x9005, 0x02a0, 0, 0, 27 }, /* ICP9047MA (Lancer) */
+	{ 0x9005, 0x0286, 0x9005, 0x02a1, 0, 0, 28 }, /* ICP9087MA (Lancer) */
+	{ 0x9005, 0x0286, 0x9005, 0x02a3, 0, 0, 29 }, /* ICP5085AU (Hurricane) */
+	{ 0x9005, 0x0285, 0x9005, 0x02a4, 0, 0, 30 }, /* ICP9085LI (Marauder-X) */
+	{ 0x9005, 0x0285, 0x9005, 0x02a5, 0, 0, 31 }, /* ICP5085BR (Marauder-E) */
+	{ 0x9005, 0x0287, 0x9005, 0x0800, 0, 0, 32 }, /* Themisto Jupiter Platform */
+	{ 0x9005, 0x0200, 0x9005, 0x0200, 0, 0, 32 }, /* Themisto Jupiter Platform */
+	{ 0x9005, 0x0286, 0x9005, 0x0800, 0, 0, 33 }, /* Callisto Jupiter Platform */
+	{ 0x9005, 0x0285, 0x9005, 0x028e, 0, 0, 34 }, /* ASR-2020SA SATA PCI-X ZCR (Skyhawk) */
+	{ 0x9005, 0x0285, 0x9005, 0x028f, 0, 0, 35 }, /* ASR-2025SA SATA SO-DIMM PCI-X ZCR (Terminator) */
+	{ 0x9005, 0x0285, 0x9005, 0x0290, 0, 0, 36 }, /* AAR-2410SA PCI SATA 4ch (Jaguar II) */
+	{ 0x9005, 0x0285, 0x1028, 0x0291, 0, 0, 37 }, /* CERC SATA RAID 2 PCI SATA 6ch (DellCorsair) */
+	{ 0x9005, 0x0285, 0x9005, 0x0292, 0, 0, 38 }, /* AAR-2810SA PCI SATA 8ch (Corsair-8) */
+	{ 0x9005, 0x0285, 0x9005, 0x0293, 0, 0, 39 }, /* AAR-21610SA PCI SATA 16ch (Corsair-16) */
+	{ 0x9005, 0x0285, 0x9005, 0x0294, 0, 0, 40 }, /* ESD SO-DIMM PCI-X SATA ZCR (Prowler) */
+	{ 0x9005, 0x0285, 0x103C, 0x3227, 0, 0, 41 }, /* AAR-2610SA PCI SATA 6ch */
+	{ 0x9005, 0x0285, 0x9005, 0x0296, 0, 0, 42 }, /* ASR-2240S (SabreExpress) */
+	{ 0x9005, 0x0285, 0x9005, 0x0297, 0, 0, 43 }, /* ASR-4005SAS */
+	{ 0x9005, 0x0285, 0x1014, 0x02F2, 0, 0, 44 }, /* IBM 8i (AvonPark) */
+	{ 0x9005, 0x0285, 0x1014, 0x0312, 0, 0, 44 }, /* IBM 8i (AvonPark Lite) */
+	{ 0x9005, 0x0285, 0x9005, 0x0298, 0, 0, 45 }, /* ASR-4000SAS (BlackBird) */
+	{ 0x9005, 0x0285, 0x9005, 0x0299, 0, 0, 46 }, /* ASR-4800SAS (Marauder-X) */
+	{ 0x9005, 0x0285, 0x9005, 0x029a, 0, 0, 47 }, /* ASR-4805SAS (Marauder-E) */
+	{ 0x9005, 0x0286, 0x9005, 0x02a2, 0, 0, 48 }, /* ASR-4810SAS (Hurricane */
+
+	{ 0x9005, 0x0285, 0x1028, 0x0287, 0, 0, 49 }, /* Perc 320/DC*/
+	{ 0x1011, 0x0046, 0x9005, 0x0365, 0, 0, 50 }, /* Adaptec 5400S (Mustang)*/
+	{ 0x1011, 0x0046, 0x9005, 0x0364, 0, 0, 51 }, /* Adaptec 5400S (Mustang)*/
+	{ 0x1011, 0x0046, 0x9005, 0x1364, 0, 0, 52 }, /* Dell PERC2/QC */
+	{ 0x1011, 0x0046, 0x103c, 0x10c2, 0, 0, 53 }, /* HP NetRAID-4M */
+
+	{ 0x9005, 0x0285, 0x1028, PCI_ANY_ID, 0, 0, 54 }, /* Dell Catchall */
+	{ 0x9005, 0x0285, 0x17aa, PCI_ANY_ID, 0, 0, 55 }, /* Legend Catchall */
+	{ 0x9005, 0x0285, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 56 }, /* Adaptec Catch All */
+	{ 0x9005, 0x0286, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 57 }, /* Adaptec Rocket Catch All */
 	{ 0,}
 };
 MODULE_DEVICE_TABLE(pci, aac_pci_tbl);
@@ -131,53 +211,91 @@ MODULE_DEVICE_TABLE(pci, aac_pci_tbl);
  * for the card.  At that time we can remove the channels from here
  */
 static struct aac_driver_ident aac_drivers[] = {
-	{ aac_rx_init, "percraid", "DELL    ", "PERCRAID        ", 2, AAC_QUIRK_31BIT }, /* PERC 2/Si */
-	{ aac_rx_init, "percraid", "DELL    ", "PERCRAID        ", 2, AAC_QUIRK_31BIT }, /* PERC 3/Di */
-	{ aac_rx_init, "percraid", "DELL    ", "PERCRAID        ", 2, AAC_QUIRK_31BIT }, /* PERC 3/Si */
-	{ aac_rx_init, "percraid", "DELL    ", "PERCRAID        ", 2, AAC_QUIRK_31BIT }, /* PERC 3/Si */
-	{ aac_rx_init, "percraid", "DELL    ", "PERCRAID        ", 2, AAC_QUIRK_31BIT }, /* PERC 3/Di */
-	{ aac_rx_init, "percraid", "DELL    ", "PERCRAID        ", 2, AAC_QUIRK_31BIT }, /* PERC 3/Di */
-	{ aac_rx_init, "percraid", "DELL    ", "PERCRAID        ", 2, AAC_QUIRK_31BIT }, /* PERC 3/Di */
-	{ aac_rx_init, "percraid", "DELL    ", "PERCRAID        ", 2, AAC_QUIRK_31BIT }, /* PERC 3/Di */
-	{ aac_rx_init, "percraid", "DELL    ", "PERCRAID        ", 2, AAC_QUIRK_31BIT }, /* PERC 3/Di */
-	{ aac_rx_init, "aacraid",  "ADAPTEC ", "catapult        ", 2, AAC_QUIRK_31BIT }, /* catapult*/
-	{ aac_rx_init, "aacraid",  "ADAPTEC ", "tomcat          ", 2, AAC_QUIRK_31BIT }, /* tomcat*/
-	{ aac_rx_init, "aacraid",  "ADAPTEC ", "Adaptec 2120S   ", 1, AAC_QUIRK_31BIT }, /* Adaptec 2120S (Crusader)*/
-	{ aac_rx_init, "aacraid",  "ADAPTEC ", "Adaptec 2200S   ", 2, AAC_QUIRK_31BIT }, /* Adaptec 2200S (Vulcan)*/
-	{ aac_rx_init, "aacraid",  "ADAPTEC ", "Adaptec 2200S   ", 2, AAC_QUIRK_31BIT }, /* Adaptec 2200S (Vulcan-2m)*/
-	{ aac_rx_init, "aacraid",  "Legend  ", "Legend S220     ", 1, AAC_QUIRK_31BIT }, /* Legend S220*/
-	{ aac_rx_init, "aacraid",  "Legend  ", "Legend S230     ", 2, AAC_QUIRK_31BIT }, /* Legend S230*/
-
-	{ aac_rx_init, "aacraid",  "ADAPTEC ", "Adaptec 3230S   ", 2 }, /* Adaptec 3230S (Harrier)*/
-	{ aac_rx_init, "aacraid",  "ADAPTEC ", "Adaptec 3240S   ", 2 }, /* Adaptec 3240S (Tornado)*/
-	{ aac_rx_init, "aacraid",  "ADAPTEC ", "ASR-2020ZCR     ", 2 }, /* ASR-2020 ZCR PCI-X U320 */
-	{ aac_rx_init, "aacraid",  "ADAPTEC ", "ASR-2025ZCR     ", 2 }, /* ASR-2025 ZCR DIMM U320 */
-	{ aac_rx_init, "aacraid",  "ADAPTEC ", "AAR-2410SA SATA ", 2 }, /* AAR-2410SA PCI SATA 4ch (Jaguar II)*/
-
-	{ aac_rx_init, "percraid", "DELL    ", "PERC 320/DC     ", 2, AAC_QUIRK_31BIT }, /* Perc 320/DC*/
-	{ aac_sa_init, "aacraid",  "ADAPTEC ", "Adaptec 5400S   ", 4 }, /* Adaptec 5400S (Mustang)*/
-	{ aac_sa_init, "aacraid",  "ADAPTEC ", "AAC-364         ", 4 }, /* Adaptec 5400S (Mustang)*/
-	{ aac_sa_init, "percraid", "DELL    ", "PERCRAID        ", 4, AAC_QUIRK_31BIT }, /* Dell PERC2 "Quad Channel" */
-	{ aac_sa_init, "hpnraid",  "HP      ", "NetRAID         ", 4 },  /* HP NetRAID-4M */
-
+	{ aac_rx_init, "percraid", "DELL    ", "PERCRAID        ", 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG }, /* PERC 2/Si (Iguana/PERC2Si) */
+	{ aac_rx_init, "percraid", "DELL    ", "PERCRAID        ", 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG }, /* PERC 3/Di (Opal/PERC3Di) */
+	{ aac_rx_init, "percraid", "DELL    ", "PERCRAID        ", 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG }, /* PERC 3/Si (SlimFast/PERC3Si */
+	{ aac_rx_init, "percraid", "DELL    ", "PERCRAID        ", 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG }, /* PERC 3/Di (Iguana FlipChip/PERC3DiF */
+	{ aac_rx_init, "percraid", "DELL    ", "PERCRAID        ", 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG }, /* PERC 3/Di (Viper/PERC3DiV) */
+	{ aac_rx_init, "percraid", "DELL    ", "PERCRAID        ", 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG }, /* PERC 3/Di (Lexus/PERC3DiL) */
+	{ aac_rx_init, "percraid", "DELL    ", "PERCRAID        ", 1, AAC_QUIRK_31BIT | AAC_QUIRK_34SG }, /* PERC 3/Di (Jaguar/PERC3DiJ) */
+	{ aac_rx_init, "percraid", "DELL    ", "PERCRAID        ", 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG }, /* PERC 3/Di (Dagger/PERC3DiD) */
+	{ aac_rx_init, "percraid", "DELL    ", "PERCRAID        ", 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG }, /* PERC 3/Di (Boxster/PERC3DiB) */
+	{ aac_rx_init, "aacraid",  "ADAPTEC ", "catapult        ", 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG }, /* catapult */
+	{ aac_rx_init, "aacraid",  "ADAPTEC ", "tomcat          ", 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG }, /* tomcat */
+	{ aac_rx_init, "aacraid",  "ADAPTEC ", "Adaptec 2120S   ", 1, AAC_QUIRK_31BIT | AAC_QUIRK_34SG }, /* Adaptec 2120S (Crusader) */
+	{ aac_rx_init, "aacraid",  "ADAPTEC ", "Adaptec 2200S   ", 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG }, /* Adaptec 2200S (Vulcan) */
+	{ aac_rx_init, "aacraid",  "ADAPTEC ", "Adaptec 2200S   ", 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG }, /* Adaptec 2200S (Vulcan-2m) */
+	{ aac_rx_init, "aacraid",  "Legend  ", "Legend S220     ", 1, AAC_QUIRK_31BIT | AAC_QUIRK_34SG }, /* Legend S220 (Legend Crusader) */
+	{ aac_rx_init, "aacraid",  "Legend  ", "Legend S230     ", 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG }, /* Legend S230 (Legend Vulcan) */
+
+	{ aac_rx_init, "aacraid",  "ADAPTEC ", "Adaptec 3230S   ", 2 }, /* Adaptec 3230S (Harrier) */
+	{ aac_rx_init, "aacraid",  "ADAPTEC ", "Adaptec 3240S   ", 2 }, /* Adaptec 3240S (Tornado) */
+	{ aac_rx_init, "aacraid",  "ADAPTEC ", "ASR-2020ZCR     ", 2 }, /* ASR-2020ZCR SCSI PCI-X ZCR (Skyhawk) */
+	{ aac_rx_init, "aacraid",  "ADAPTEC ", "ASR-2025ZCR     ", 2 }, /* ASR-2025ZCR SCSI SO-DIMM PCI-X ZCR (Terminator) */
+	{ aac_rkt_init, "aacraid",  "ADAPTEC ", "ASR-2230S PCI-X ", 2 }, /* ASR-2230S + ASR-2230SLP PCI-X (Lancer) */
+	{ aac_rkt_init, "aacraid",  "ADAPTEC ", "ASR-2130S PCI-X ", 1 }, /* ASR-2130S (Lancer) */
+	{ aac_rkt_init, "aacraid",  "ADAPTEC ", "AAR-2820SA      ", 1 }, /* AAR-2820SA (Intruder) */
+	{ aac_rkt_init, "aacraid",  "ADAPTEC ", "AAR-2620SA      ", 1 }, /* AAR-2620SA (Intruder) */
+	{ aac_rkt_init, "aacraid",  "ADAPTEC ", "AAR-2420SA      ", 1 }, /* AAR-2420SA (Intruder) */
+	{ aac_rkt_init, "aacraid",  "ICP     ", "ICP9024R0       ", 2 }, /* ICP9024R0 (Lancer) */
+	{ aac_rkt_init, "aacraid",  "ICP     ", "ICP9014R0       ", 1 }, /* ICP9014R0 (Lancer) */
+	{ aac_rkt_init, "aacraid",  "ICP     ", "ICP9047MA       ", 1 }, /* ICP9047MA (Lancer) */
+	{ aac_rkt_init, "aacraid",  "ICP     ", "ICP9087MA       ", 1 }, /* ICP9087MA (Lancer) */
+	{ aac_rkt_init, "aacraid",  "ICP     ", "ICP5085AU       ", 1 }, /* ICP5085AU (Hurricane) */
+	{ aac_rkt_init, "aacraid",  "ICP     ", "ICP9085LI       ", 1 }, /* ICP9085LI (Marauder-X) */
+	{ aac_rkt_init, "aacraid",  "ICP     ", "ICP5085BR       ", 1 }, /* ICP5085BR (Marauder-E) */
+	{ NULL        , "aacraid",  "ADAPTEC ", "Themisto        ", 0, AAC_QUIRK_SLAVE }, /* Jupiter Platform */
+	{ aac_rkt_init, "aacraid",  "ADAPTEC ", "Callisto        ", 2, AAC_QUIRK_MASTER }, /* Jupiter Platform */
+	{ aac_rx_init, "aacraid",  "ADAPTEC ", "ASR-2020SA       ", 1 }, /* ASR-2020SA SATA PCI-X ZCR (Skyhawk) */
+	{ aac_rx_init, "aacraid",  "ADAPTEC ", "ASR-2025SA       ", 1 }, /* ASR-2025SA SATA SO-DIMM PCI-X ZCR (Terminator) */
+	{ aac_rx_init, "aacraid",  "ADAPTEC ", "AAR-2410SA SATA ", 1 }, /* AAR-2410SA PCI SATA 4ch (Jaguar II) */
 	{ aac_rx_init, "aacraid",  "DELL    ", "CERC SR2        ", 1 }, /* CERC SATA RAID 2 PCI SATA 6ch (DellCorsair) */
 	{ aac_rx_init, "aacraid",  "ADAPTEC ", "AAR-2810SA SATA ", 1 }, /* AAR-2810SA PCI SATA 8ch (Corsair-8) */
 	{ aac_rx_init, "aacraid",  "ADAPTEC ", "AAR-21610SA SATA", 1 }, /* AAR-21610SA PCI SATA 16ch (Corsair-16) */
-	{ aac_rx_init, "aacraid",  "ADAPTEC ", "SO-DIMM SATA ZCR", 1 }, /* ESD SO-DIMM PCI-X SATA ZCR (Prowler) */
-	{ aac_rx_init, "aacraid",  "ADAPTEC ", "SATA 6Channel   ", 1 }, /* SATA 6Ch (Bearcat) */
-
-	{ aac_rkt_init,"aacraid",  "ADAPTEC ", "ASR-2230S PCI-X ", 2 }, /* ASR-2230S + ASR-2230SLP PCI-X (Lancer) */
-	{ aac_rx_init, "aacraid",  "ADAPTEC ", "ASR-2020SA      ", 1 }, /* ASR-2020SA      (ZCR PCI-X SATA) */
-	{ aac_rx_init, "aacraid",  "ADAPTEC ", "ASR-2025SA      ", 1 }, /* ASR-2025SA      (ZCR DIMM SATA) */
+	{ aac_rx_init, "aacraid",  "ADAPTEC ", "ASR-2026ZCR     ", 1 }, /* ESD SO-DIMM PCI-X SATA ZCR (Prowler) */
+	{ aac_rx_init, "aacraid",  "ADAPTEC ", "AAR-2610SA      ", 1 }, /* SATA 6Ch (Bearcat) */
+	{ aac_rx_init, "aacraid",  "ADAPTEC ", "ASR-2240S       ", 1 }, /* ASR-2240S (SabreExpress) */
+	{ aac_rx_init, "aacraid",  "ADAPTEC ", "ASR-4005SAS     ", 1 }, /* ASR-4005SAS */
+	{ aac_rx_init, "ServeRAID","IBM     ", "ServeRAID 8i    ", 1 }, /* IBM 8i (AvonPark) */
+	{ aac_rx_init, "aacraid",  "ADAPTEC ", "ASR-4000SAS     ", 1 }, /* ASR-4000SAS (BlackBird & AvonPark) */
+	{ aac_rx_init, "aacraid",  "ADAPTEC ", "ASR-4800SAS     ", 1 }, /* ASR-4800SAS (Marauder-X) */
+	{ aac_rx_init, "aacraid",  "ADAPTEC ", "ASR-4805SAS     ", 1 }, /* ASR-4805SAS (Marauder-E) */
+	{ aac_rx_init, "aacraid",  "ADAPTEC ", "ASR-4810SAS     ", 1 }, /* ASR-4810SAS (Hurricane) */
+
+	{ aac_rx_init, "percraid", "DELL    ", "PERC 320/DC     ", 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG }, /* Perc 320/DC*/
+	{ aac_sa_init, "aacraid",  "ADAPTEC ", "Adaptec 5400S   ", 4, AAC_QUIRK_34SG }, /* Adaptec 5400S (Mustang)*/
+	{ aac_sa_init, "aacraid",  "ADAPTEC ", "AAC-364         ", 4, AAC_QUIRK_34SG }, /* Adaptec 5400S (Mustang)*/
+	{ aac_sa_init, "percraid", "DELL    ", "PERCRAID        ", 4, AAC_QUIRK_31BIT | AAC_QUIRK_34SG }, /* Dell PERC2/QC */
+	{ aac_sa_init, "hpnraid",  "HP      ", "NetRAID         ", 4, AAC_QUIRK_34SG }, /* HP NetRAID-4M */
+
+	{ aac_rx_init, "aacraid",  "DELL    ", "RAID            ", 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG }, /* Dell Catchall */
+	{ aac_rx_init, "aacraid",  "Legend  ", "RAID            ", 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG }, /* Legend Catchall */
+	{ aac_rx_init, "aacraid",  "ADAPTEC ", "RAID            ", 2, AAC_QUIRK_31BIT | AAC_QUIRK_34SG }, /* Adaptec Catch All */
+	{ aac_rkt_init, "aacraid", "ADAPTEC ", "RAID            ", 2 } /* Adaptec Rocket Catch All */
 };
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,11))
 
-#ifdef CONFIG_COMPAT
+#if ((LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)) ? defined(__x86_64__) : defined(CONFIG_COMPAT))
 /* 
  * Promote 32 bit apps that call get_next_adapter_fib_ioctl to 64 bit version 
  */
 static int aac_get_next_adapter_fib_ioctl(unsigned int fd, unsigned int cmd, 
 		unsigned long arg, struct file *file)
 {
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
+	struct fib_ioctl f;
+	mm_segment_t fs;
+	int retval;
+
+	memset (&f, 0, sizeof(f));
+	if (copy_from_user(&f, (void __user *)arg, sizeof(f) - sizeof(u32)))
+		return -EFAULT;
+	fs = get_fs();
+	set_fs(get_ds());
+	retval = sys_ioctl(fd, cmd, (unsigned long)&f);
+	set_fs(fs);
+	return retval;
+#else
 	struct fib_ioctl __user *f;
 
 	f = compat_alloc_user_space(sizeof(*f));
@@ -185,13 +303,48 @@ static int aac_get_next_adapter_fib_ioct
 		return -EFAULT;
 
 	clear_user(f, sizeof(*f));
-	if (copy_in_user(f, (void __user *)arg, sizeof(struct fib_ioctl) - sizeof(u32)))
+	if (copy_in_user(f, (void __user *)arg, sizeof(*f) - sizeof(u32)))
 		return -EFAULT;
 
 	return sys_ioctl(fd, cmd, (unsigned long)f);
+#endif
 }
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
+#define sys_ioctl NULL	/* register_ioctl32_conversion defaults to this when NULL passed in as a handler */
+#endif
+#endif
+
+#endif
+#if (LINUX_VERSION_CODE <= KERNEL_VERSION(2,5,0))
+static struct Scsi_Host * aac_dummy;
+
+/**
+ *	aac_detect	-	Probe for aacraid cards
+ *	@template: SCSI driver template
+ *
+ *	This is but a stub to convince the 2.4 scsi layer to scan targets,
+ *	the pci scan has already picked up the adapters.
+ */
+static int aac_detect(Scsi_Host_Template *template)
+{
+#if 0
+printk(KERN_INFO "aac_detect(%p)\n", template);
 #endif
+	/* By changing the host list we trick a scan */
+	if (aac_dummy) {
+#if 0
+printk(KERN_INFO "scsi_host_put(%p)\n", aac_dummy);
+#endif
+		scsi_host_put(aac_dummy);
+		aac_dummy = NULL;
+	}
+#if 0
+printk(KERN_INFO "aac_detect()=%d\n", !list_empty(&aac_devices));
+#endif
+	return !list_empty(&aac_devices);
+}
 
+#endif
 
 /**
  *	aac_queuecommand	-	queue a SCSI command
@@ -205,6 +358,55 @@ static int aac_get_next_adapter_fib_ioct
 
 static int aac_queuecommand(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *))
 {
+#if (defined(AAC_DEBUG_INSTRUMENT_TIMING))
+	u64 lba;
+	u32 count = 0;
+	struct timeval now;
+	do_gettimeofday(&now);
+	if ((cmd->cmnd[0] == WRITE_6)	/* 6 byte command */
+	 || (cmd->cmnd[0] == READ_6)) {
+		lba = ((cmd->cmnd[1] & 0x1F) << 16)
+		    | (cmd->cmnd[2] << 8) | cmd->cmnd[3];
+		count = cmd->cmnd[4];
+		if (count == 0)
+			count = 256;
+#if (defined(WRITE_16))
+	} else if ((cmd->cmnd[0] == WRITE_16) /* 16 byte command */
+	 || (cmd->cmnd[0] == READ_16)) {
+		lba = ((u64)cmd->cmnd[2] << 56)
+		    | ((u64)cmd->cmnd[3] << 48)
+		    | ((u64)cmd->cmnd[4] << 40)
+		    | ((u64)cmd->cmnd[9] << 32)
+		    | (cmd->cmnd[6] << 24)
+		    | (cmd->cmnd[7] << 16)
+		    | (cmd->cmnd[8] << 8) | cmd->cmnd[9];
+		count = (cmd->cmnd[10] << 24)
+		      | (cmd->cmnd[11] << 16)
+		      | (cmd->cmnd[12] << 8) | cmd->cmnd[13];
+#endif
+	} else if ((cmd->cmnd[0] == WRITE_12) /* 12 byte command */
+	 || (cmd->cmnd[0] == READ_12)) {
+		lba = (cmd->cmnd[2] << 24)
+		    | (cmd->cmnd[3] << 16)
+		    | (cmd->cmnd[4] << 8) | cmd->cmnd[5];
+		count = (cmd->cmnd[6] << 24)
+		      | (cmd->cmnd[7] << 16)
+		      | (cmd->cmnd[8] << 8) | cmd->cmnd[9];
+	} else if ((cmd->cmnd[0] == WRITE_10) /* 10 byte command */
+	 || (cmd->cmnd[0] == READ_10)) {
+		lba = (cmd->cmnd[2] << 24)
+		    | (cmd->cmnd[3] << 16)
+		    | (cmd->cmnd[4] << 8) | cmd->cmnd[5];
+		count = (cmd->cmnd[7] << 8) | cmd->cmnd[8];
+	} else
+		lba = (u64)(long)cmd;
+	printk(((count)
+	  ? KERN_DEBUG "%lu.%06lu q%lu %llu[%u]\n"
+	  : KERN_DEBUG "%lu.%06lu q%lu 0x%llx\n"),
+ 	  now.tv_sec % 100, now.tv_usec,
+	  ((struct aac_dev *)cmd->device->host->hostdata)->queues->queue[AdapNormCmdQueue].numpending,
+	  lba, count);
+#endif
 	cmd->scsi_done = done;
 	return (aac_scsi_cmd(cmd) ? FAILED : 0);
 } 
@@ -216,9 +418,21 @@ static int aac_queuecommand(struct scsi_
  *	Returns a static string describing the device in question
  */
 
-const char *aac_info(struct Scsi_Host *shost)
+static const char *aac_info(struct Scsi_Host *shost)
 {
+#if (LINUX_VERSION_CODE <= KERNEL_VERSION(2,5,0))
+	struct aac_dev *dev;
+	if (shost == aac_dummy)
+		return shost->hostt->name;
+	dev = (struct aac_dev *)shost->hostdata;
+	if (!dev
+	 || (dev->cardtype >= (sizeof(aac_drivers)/sizeof(aac_drivers[0]))))
+		return shost->hostt->name;
+	if (dev->scsi_host_ptr != shost)
+		return shost->hostt->name;
+#else
 	struct aac_dev *dev = (struct aac_dev *)shost->hostdata;
+#endif
 	return aac_drivers[dev->cardtype].name;
 }
 
@@ -236,6 +450,10 @@ struct aac_driver_ident* aac_get_driver_
 
 /**
  *	aac_biosparm	-	return BIOS parameters for disk
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
+ *	@disk: SCSI disk object to process
+ *	@device: kdev_t of the disk in question
+#endif
  *	@sdev: The scsi device corresponding to the disk
  *	@bdev: the block device corresponding to the disk
  *	@capacity: the sector capacity of the disk
@@ -256,11 +474,21 @@ struct aac_driver_ident* aac_get_driver_
  *	be displayed.
  */
  
-static int aac_biosparm(struct scsi_device *sdev, struct block_device *bdev,
-			sector_t capacity, int *geom)
+static int aac_biosparm(
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
+	struct scsi_device *sdev, struct block_device *bdev, sector_t capacity,
+#else
+	Scsi_Disk *disk, kdev_t dev,
+#endif
+	int *geom)
 {
 	struct diskparm *param = (struct diskparm *)geom;
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
 	unsigned char *buf;
+#else
+	struct buffer_head * buf;
+	sector_t capacity = disk->capacity;
+#endif
 
 	dprintk((KERN_DEBUG "aac_biosparm.\n"));
 
@@ -288,9 +516,20 @@ static int aac_biosparm(struct scsi_devi
 	 *	entry whose end_head matches one of the standard geometry 
 	 *	translations ( 64/32, 128/32, 255/63 ).
 	 */
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
 	buf = scsi_bios_ptable(bdev);
-	if(*(unsigned short *)(buf + 0x40) == cpu_to_le16(0xaa55)) {
+#else
+	buf = bread(MKDEV(MAJOR(dev), MINOR(dev)&~0xf), 0, block_size(dev));
+	if(buf == NULL)
+		return 0;
+#endif
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
+	if(*(__le16 *)(buf + 0x40) == cpu_to_le16(0xaa55)) {
 		struct partition *first = (struct partition * )buf;
+#else
+	if(*(unsigned short *)(buf->b_data + 0x1fe) == cpu_to_le16(0xaa55)) {
+		struct partition *first = (struct partition * )(buf->b_data + 0x1be);
+#endif
 		struct partition *entry = first;
 		int saved_cylinders = param->cylinders;
 		int num;
@@ -333,12 +572,17 @@ static int aac_biosparm(struct scsi_devi
 					param->heads, param->sectors));
 		}
 	}
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
 	kfree(buf);
+#else
+	brelse(buf);
+#endif
 	return 0;
 }
 
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
 /**
- *	aac_queuedepth		-	compute queue depths
+ *	aac_slave_configure		-	compute queue depths
  *	@sdev:	SCSI device we are considering
  *
  *	Selects queue depths for each target device based on the host adapter's
@@ -348,16 +592,107 @@ static int aac_biosparm(struct scsi_devi
 
 static int aac_slave_configure(struct scsi_device *sdev)
 {
-	if (sdev->tagged_supported)
-		scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG, 128);
-	else
+	if (sdev->tagged_supported) {
+		struct scsi_device * dev;
+		struct Scsi_Host * host = sdev->host;
+		unsigned num_lsu = 0;
+		unsigned num_one = 0;
+		unsigned depth;
+
+		__shost_for_each_device(dev, host) {
+			if (dev->tagged_supported && (dev->type == 0))
+				++num_lsu;
+			else
+				++num_one;
+		}
+		if (num_lsu == 0)
+			++num_lsu;
+		depth = (host->can_queue - num_one) / num_lsu;
+		if (depth > 256)
+			depth = 256;
+		else if (depth < 2)
+			depth = 2;
+		scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG, depth);
+	} else
 		scsi_adjust_queue_depth(sdev, 0, 1);
+#if ((LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)) && defined(AAC_EXTENDED_TIMEOUT))
+	{
+		extern int extendedtimeout;
+
+		if (extendedtimeout != -1)
+			sdev->timeout = extendedtimeout * HZ;
+	}
+#endif
 	return 0;
 }
+#else
+/**
+ *	aac_queuedepth		-	compute queue depths
+ *	@host:	SCSI host in question
+ *	@dev:	SCSI device we are considering
+ *
+ *	Selects queue depths for each target device based on the host adapter's
+ *	total capacity and the queue depth supported by the target device.
+ *	A queue depth of one automatically disables tagged queueing.
+ */
+
+static void aac_queuedepth(struct Scsi_Host * host, struct scsi_device * dev )
+{
+	struct scsi_device * dptr;
+	unsigned num = 0;
+	unsigned depth;
+
+#if 0
+printk(KERN_INFO "aac_queuedepth(%p,%p)\n", host, dev);
+#endif
+	for(dptr = dev; dptr != NULL; dptr = dptr->next)
+		if((dptr->host == host) && (dptr->type == 0))
+			++num;
+
+	dprintk((KERN_DEBUG "can_queue=%d num=%d\n", host->can_queue, num));
+#if 0
+printk(KERN_INFO "can_queue=%d num=%d\n", host->can_queue, num);
+#endif
+	if (num == 0)
+		++num;
+	depth = host->can_queue / num;
+	if (depth > 255)
+		depth = 255;
+	else if (depth < 2)
+		depth = 2;
+	dprintk((KERN_DEBUG "aac_queuedepth.\n"));
+	dprintk((KERN_DEBUG "Device #   Q Depth   Online\n"));
+	dprintk((KERN_DEBUG "---------------------------\n"));
+#if 0
+printk(KERN_INFO "aac_queuedepth.\n");
+printk(KERN_INFO "Device #   Q Depth   Online\n");
+printk(KERN_INFO "---------------------------\n");
+#endif
+	for(dptr = dev; dptr != NULL; dptr = dptr->next)
+	{
+		if(dptr->host == host)
+		{
+			dptr->queue_depth = depth;
+			dprintk((KERN_DEBUG "  %2d         %d        %d\n", 
+				dptr->id, dptr->queue_depth, scsi_device_online(dptr)));
+#if 0
+printk(KERN_INFO "  %2d         %d        %d\n", dptr->id, dptr->queue_depth, scsi_device_online(dptr));
+#endif
+		}
+	}
+}
+#endif
 
 static int aac_ioctl(struct scsi_device *sdev, int cmd, void __user * arg)
 {
 	struct aac_dev *dev = (struct aac_dev *)sdev->host->hostdata;
+#if (defined(AAC_DEBUG_INSTRUMENT_IOCTL))
+	int retval;
+	printk("aac_ioctl(%p, %x, %p)\n", sdev, cmd, arg);
+	retval = aac_do_ioctl(dev, cmd, arg);
+	printk("aac_ioctl returns %d\n", retval);
+	return retval;
+#endif
 	return aac_do_ioctl(dev, cmd, arg);
 }
 
@@ -369,28 +704,255 @@ static int aac_eh_abort(struct scsi_cmnd
 	return FAILED;
 }
 
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
+/**
+ *	aac_eh_device_reset	-	Reset command handling
+ *	@cmd:	SCSI command block causing the reset
+ *
+ *	Issue a reset of a SCSI device. We are ourselves not truely a SCSI
+ *	controller and our firmware will do the work for us anyway. Thus this
+ *	is a no-op. We just return FAILED.
+ */
+
+static int aac_eh_device_reset(struct scsi_cmnd *cmd)
+{
+	return FAILED;
+}
+
+/**
+ *	aac_eh_bus_reset	-	Reset command handling
+ *	@scsi_cmd:	SCSI command block causing the reset
+ *
+ *	Issue a reset of a SCSI bus. We are ourselves not truely a SCSI
+ *	controller and our firmware will do the work for us anyway. Thus this
+ *	is a no-op. We just return FAILED.
+ */
+
+static int aac_eh_bus_reset(struct scsi_cmnd* cmd)
+{
+	return FAILED;
+}
+
+#endif
 /*
  *	aac_eh_reset	- Reset command handling
  *	@scsi_cmd:	SCSI command block causing the reset
  *
  */
+#if (defined(__arm__))
+//DEBUG
+#define AAC_DEBUG_INSTRUMENT_RESET
+#endif
+#if (defined(AAC_DEBUG_INSTRUMENT_RESET))
+# undef dprintk
+# define dprintk(x)	printk x
+#endif
 static int aac_eh_reset(struct scsi_cmnd* cmd)
 {
+#if (!defined(AAC_DEBUG_INSTRUMENT_RESET) && defined(__arm__))
+//	return FAILED;
+	return SUCCESS; /* Cause an immediate retry of the command with a ten second delay after successful tur */
+#else
 	struct scsi_device * dev = cmd->device;
 	struct Scsi_Host * host = dev->host;
 	struct scsi_cmnd * command;
 	int count;
 	struct aac_dev * aac;
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
 	unsigned long flags;
+#endif
 
 	printk(KERN_ERR "%s: Host adapter reset request. SCSI hang ?\n", 
 					AAC_DRIVERNAME);
+	aac = (struct aac_dev *)host->hostdata;
+	fwprintf((aac, HBA_FLAGS_DBG_FW_PRINT_B, "SCSI hang ?"));
+	if (nblank(dprintk(x))) {
+		int active = 0;
+		unsigned long DebugFlags = aac->FwDebugFlags;
 
+		active = active;
+		dprintk((KERN_ERR
+		  "%s: Outstanding commands on (%d,%d,%d,%d):\n",
+		  AAC_DRIVERNAME,
+		  host->host_no, dev->channel, dev->id, dev->lun));
+		aac->FwDebugFlags |= FW_DEBUG_FLAGS_NO_HEADERS_B;
+		fwprintf((aac, HBA_FLAGS_DBG_FW_PRINT_B,
+		  "%s: Outstanding commands on (%d,%d,%d,%d):\n",
+		  AAC_DRIVERNAME,
+		  host->host_no, dev->channel, dev->id, dev->lun));
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
+		spin_lock_irqsave(&dev->list_lock, flags);
+		list_for_each_entry(command, &dev->cmd_list, list)
+#else
+		for(command = dev->device_queue; command; command = command->next)
+#endif
+		{
+			if ((command->state != SCSI_STATE_FINISHED)
+			 && (command->state != 0))
+			dprintk((KERN_ERR
+			  "%4d %c%c %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x\n",
+			  active++,
+			  (command->serial_number) ? 'A' : 'C',
+			  (cmd == command) ? '*' : ' ',
+			  command->cmnd[0], command->cmnd[1], command->cmnd[2],
+			  command->cmnd[3], command->cmnd[4], command->cmnd[5],
+			  command->cmnd[6], command->cmnd[7], command->cmnd[8],
+			  command->cmnd[9]));
+			fwprintf((aac, HBA_FLAGS_DBG_FW_PRINT_B,
+			  "%4d %c%c %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x\n",
+			  active++,
+			  (command->serial_number) ? 'A' : 'C',
+			  (cmd == command) ? '*' : ' ',
+			  command->cmnd[0], command->cmnd[1], command->cmnd[2],
+			  command->cmnd[3], command->cmnd[4], command->cmnd[5],
+			  command->cmnd[6], command->cmnd[7], command->cmnd[8],
+			  command->cmnd[9]));
+		}
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
+		spin_unlock_irqrestore(&dev->list_lock, flags);
+#endif
+		aac->FwDebugFlags = DebugFlags;
+	}
 
-	aac = (struct aac_dev *)host->hostdata;
-	if (aac_adapter_check_health(aac)) {
-		printk(KERN_ERR "%s: Host adapter appears dead\n", 
-				AAC_DRIVERNAME);
+	if ((count = aac_adapter_check_health(aac))) {
+		/* Fake up an AIF:
+		 *	aac_aifcmd.command = AifCmdEventNotify = 1
+		 *	aac_aifcmd.seqnum = 0xFFFFFFFF
+		 *	aac_aifcmd.data[0] = AifEnExpEvent = 23
+		 *	aac_aifcmd.data[1] = AifExeFirmwarePanic = 3
+		 *	aac.aifcmd.data[2] = AifHighPriority = 3
+		 *	aac.aifcmd.data[3] = count
+		 */
+		struct list_head *entry;
+		u32 time_now = jiffies/HZ;
+		unsigned long flagv;
+			
+		spin_lock_irqsave(&aac->fib_lock, flagv);
+		entry = aac->fib_list.next;
+
+		/*
+		 * For each Context that is on the 
+		 * fibctxList, make a copy of the
+		 * fib, and then set the event to wake up the
+		 * thread that is waiting for it.
+		 */
+		while (entry != &aac->fib_list) {
+			/*
+			 * Extract the fibctx
+			 */
+			struct aac_fib_context *fibctx = list_entry(entry, struct aac_fib_context, next);
+			struct hw_fib * hw_fib;
+			struct fib * fib;
+			/*
+			 * Check if the queue is getting
+			 * backlogged
+			 */
+			if (fibctx->count > 20) {
+				/*
+				 * It's *not* jiffies folks,
+				 * but jiffies / HZ, so do not
+				 * panic ...
+				 */
+				u32 time_last = fibctx->jiffies;
+				/*
+				 * Has it been > 2 minutes 
+				 * since the last read off
+				 * the queue?
+				 */
+				if ((time_now - time_last) > 120) {
+					entry = entry->next;
+					aac_close_fib_context(aac, fibctx);
+					continue;
+				}
+			}
+			/*
+			 * Warning: no sleep allowed while
+			 * holding spinlock
+			 */
+			hw_fib = kmalloc(sizeof(struct hw_fib), GFP_ATOMIC);
+			fib = kmalloc(sizeof(struct fib), GFP_ATOMIC);
+			if (fib && hw_fib) {
+				struct aac_aifcmd * aif;
+				memset(hw_fib, 0, sizeof(struct hw_fib));
+				memset(fib, 0, sizeof(struct fib));
+				fib->hw_fib = hw_fib;
+				fib->dev = aac;
+				fib_init(fib);
+				fib->type = FSAFS_NTC_FIB_CONTEXT;
+				fib->size = sizeof (struct fib);
+				fib->data = hw_fib->data;
+				aif = (struct aac_aifcmd *)hw_fib->data;
+				aif->command = AifCmdEventNotify;
+			 	aif->seqnum = 0xFFFFFFFF;
+			 	aif->data[0] = AifEnExpEvent;
+				aif->data[1] = AifExeFirmwarePanic;
+			 	aif->data[2] = AifHighPriority;
+				aif->data[3] = count;
+
+				/*
+				 * Put the FIB onto the
+				 * fibctx's fibs
+				 */
+				list_add_tail(&fib->fiblink, &fibctx->fib_list);
+				fibctx->count++;
+				/* 
+				 * Set the event to wake up the
+				 * thread that will waiting.
+				 */
+				up(&fibctx->wait_sem);
+			} else {
+				printk(KERN_WARNING "aifd: didn't allocate NewFib.\n");
+				if(fib)
+					kfree(fib);
+				if(hw_fib)
+					kfree(hw_fib);
+			}
+			entry = entry->next;
+		}
+		spin_unlock_irqrestore(&aac->fib_lock, flagv);
+
+		printk(((count < 0)
+		    ? KERN_ERR "%s: Host adapter appears dead %d\n"
+		    : KERN_ERR "%s: Host adapter BLINK LED 0x%x\n"),
+		  AAC_DRIVERNAME, count);
+
+		/*
+		 *	If a positive health, means in a known DEAD PANIC
+		 * state and the adapter could be reset to `try again'.
+		 */
+#if 0
+		if ((count > 0)
+		 && (!aac_adapter_sync_cmd(dev, IOP_RESET, 0, 0, 0, 0, 0, 0,
+		  &time_now, NULL, NULL, NULL, NULL))
+		 && (time_now == 0x00000001)) {
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
+			__shost_for_each_device(dev, host) {
+				spin_lock_irqsave(&dev->list_lock, flags);
+				list_for_each_entry(command, &dev->cmd_list, list) {
+					if (command->serial_number) {
+						command->result
+						  = DID_RESET << 16
+						  | COMMAND_COMPLETE << 8;
+						command->scsi_done(command);
+					}
+				}
+				spin_unlock_irqrestore(&dev->list_lock, flags);
+			}
+#else
+			for (dev = host->host_queue; dev != (struct scsi_device *)NULL; dev = dev->next) {
+				for(command = dev->device_queue; command; command = command->next) {
+					if (command->serial_number) {
+						command->result
+						  = DID_RESET << 16
+						  | COMMAND_COMPLETE << 8;
+						command->scsi_done(command);
+					}
+				}
+			}
+#endif
+			return SUCCESS;
+		}
+#endif
 		return -ENODEV;
 	}
 	/*
@@ -399,6 +961,7 @@ static int aac_eh_reset(struct scsi_cmnd
 	 */
 	for (count = 60; count; --count) {
 		int active = 0;
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
 		__shost_for_each_device(dev, host) {
 			spin_lock_irqsave(&dev->list_lock, flags);
 			list_for_each_entry(command, &dev->cmd_list, list) {
@@ -408,20 +971,510 @@ static int aac_eh_reset(struct scsi_cmnd
 				}
 			}
 			spin_unlock_irqrestore(&dev->list_lock, flags);
+			if (active)
+				break;
 
-			/*
-			 * We can exit If all the commands are complete
-			 */
-			if (active == 0)
-				return SUCCESS;
 		}
+#else
+		for (dev = host->host_queue; dev != (struct scsi_device *)NULL; dev = dev->next) {
+			for(command = dev->device_queue; command; command = command->next) {
+				if (command->serial_number) {
+					++active;
+					break;
+				}
+			}
+		}
+#endif
+		/*
+		 * We can exit If all the commands are complete
+		 */
+		if (active == 0)
+			return SUCCESS;
+#if (defined(SCSI_HAS_HOST_LOCK) || (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)))
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,21)) && ((LINUX_VERSION_CODE > KERNEL_VERSION(2,4,21)) || !defined(CONFIG_CFGNAME))
 		spin_unlock_irq(host->host_lock);
-		scsi_sleep(HZ);
+#else
+		spin_unlock_irq(host->lock);
+#endif
+#else
+		spin_unlock_irq(&io_request_lock);
+#endif
+		ssleep(1);
+#if (defined(SCSI_HAS_HOST_LOCK) || (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)))
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,21)) && ((LINUX_VERSION_CODE > KERNEL_VERSION(2,4,21)) || !defined(CONFIG_CFGNAME))
 		spin_lock_irq(host->host_lock);
+#else
+		spin_lock_irq(host->lock);
+#endif
+#else
+		spin_lock_irq(&io_request_lock);
+#endif
 	}
 	printk(KERN_ERR "%s: SCSI bus appears hung\n", AAC_DRIVERNAME);
-	return -ETIMEDOUT;
+	fwprintf((aac, HBA_FLAGS_DBG_FW_PRINT_B, "SCSI bus appears hung"));
+//	return -ETIMEDOUT;
+	return SUCCESS; /* Cause an immediate retry of the command with a ten second delay after successful tur */
+#endif
+}
+#if (defined(AAC_DEBUG_INSTRUMENT_RESET))
+/* We are making an assumption that dprintk was turned off */
+# undef dprintk
+# define dprintk(x)
+#endif
+#if (defined(SCSI_HAS_DUMP))
+#if (defined(SCSI_HAS_DUMP_SANITY_CHECK))
+static int aac_sanity_check(struct scsi_device * sdev)
+{
+	return 0;
+}
+
+#endif
+static void aac_poll(struct scsi_device * sdev)
+{
+	struct Scsi_Host * shost = sdev->host;
+	struct aac_dev *dev = (struct aac_dev *)shost->hostdata;
+	unsigned long flags;
+
+#if (defined(SCSI_HAS_HOST_LOCK) || (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)))
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,21)) && ((LINUX_VERSION_CODE > KERNEL_VERSION(2,4,21)) || !defined(CONFIG_CFGNAME))
+	spin_lock_irqsave(shost->host_lock, flags);
+#else
+	spin_lock_irqsave(shost->lock, flags);
+#endif
+#else
+	spin_lock_irqsave(&io_request_lock, flags);
+#endif
+	aac_adapter_intr(dev);
+#if (defined(SCSI_HAS_HOST_LOCK) || (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)))
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,21)) && ((LINUX_VERSION_CODE > KERNEL_VERSION(2,4,21)) || !defined(CONFIG_CFGNAME))
+	spin_unlock_irqrestore(shost->host_lock, flags);
+#else
+	spin_unlock_irqrestore(shost->lock, flags);
+#endif
+#else
+	spin_unlock_irqrestore(&io_request_lock, flags);
+#endif
+}
+#endif
+
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
+#define shost_to_class(shost) &shost->shost_classdev
+#else
+#define class_device Scsi_Host
+#define shost_to_class(shost) shost
+#define class_to_shost(class_dev) class_dev
+#endif
+
+static ssize_t aac_show_host_version(struct class_device *class_dev, char *buf)
+{
+	int len;
+
+	len = snprintf(buf, PAGE_SIZE, "Adaptec Raid Controller %s\n",
+	  aac_driver_version);
+	return len;
+}
+
+static ssize_t aac_show_model(struct class_device *class_dev, char *buf)
+{
+	struct aac_dev *dev = (struct aac_dev*)class_to_shost(class_dev)->hostdata;
+	int len;
+
+	if (dev->supplement_adapter_info.AdapterTypeText[0]) {
+		char * cp = dev->supplement_adapter_info.AdapterTypeText;
+		char * endp;
+		while (*cp && *cp != ' ')
+			++cp;
+		endp = cp;
+		while (*cp == ' ')
+			++cp;
+		len = snprintf(buf, PAGE_SIZE, "Vendor: %.*s Model: %s\n",
+		  (int)(endp - (char *)dev->supplement_adapter_info.AdapterTypeText),
+		  dev->supplement_adapter_info.AdapterTypeText, cp);
+	} else
+		len = snprintf(buf, PAGE_SIZE, "Vendor: %s Model: %s\n",
+		  aac_drivers[dev->cardtype].vname,
+		  aac_drivers[dev->cardtype].model);
+	return len;
+}
+
+static ssize_t aac_show_flags(struct class_device *class_dev, char *buf)
+{
+	int len = 0;
+
+	if (nblank(dprintk(x)))
+		len = snprintf(buf, PAGE_SIZE, "dprintk\n");
+#	if (defined(AAC_DETAILED_STATUS_INFO))
+		len += snprintf(buf + len, PAGE_SIZE - len,
+		  "AAC_DETAILED_STATUS_INFO\n");
+#	endif
+#	if (defined(AAC_DEBUG_INSTRUMENT_AAC_CONFIG))
+		len += snprintf(buf + len, PAGE_SIZE- len,
+		  "AAC_DEBUG_INSTRUMENT_AAC_CONFIG\n");
+#	endif
+#	if (defined(AAC_DEBUG_INSTRUMENT_AIF))
+		len += snprintf(buf + len, PAGE_SIZE - len,
+		  "AAC_DEBUG_INSTRUMENT_AIF\n");
+#	endif
+#	if (defined(AAC_DEBUG_INSTRUMENT_IOCTL))
+		len += snprintf(buf + len, PAGE_SIZE - len,
+		  "AAC_DEBUG_INSTRUMENT_IOCTL\n");
+#	endif
+#	if (defined(AAC_DEBUG_INSTRUMENT_TIMING))
+		len += snprintf(buf + len, PAGE_SIZE - len,
+		  "AAC_DEBUG_INSTRUMENT_TIMING\n");
+#	endif
+#	if (defined(AAC_DEBUG_INSTRUMENT_RESET))
+		len += snprintf(buf + len, PAGE_SIZE - len,
+		  "AAC_DEBUG_INSTRUMENT_RESET\n");
+#	endif
+#	if (defined(AAC_DEBUG_INSTRUMENT_FIB))
+		len += snprintf(buf + len, PAGE_SIZE - len,
+		  "AAC_DEBUG_INSTRUMENT_FIB\n");
+#	endif
+#	if (defined(AAC_DEBUG_INSTRUMENT_2TB))
+		len += snprintf(buf + len, PAGE_SIZE - len,
+		  "AAC_DEBUG_INSTRUMENT_2TB\n");
+#	endif
+#	if (defined(AAC_DEBUG_INSTRUMENT_IOCTL_SENDFIB))
+		len += snprintf(buf + len, PAGE_SIZE - len,
+		  "AAC_DEBUG_INSTRUMENT_IOCTL_SENDFIB\n");
+#	endif
+#	if (defined(AAC_DEBUG_INSTRUMENT_IO))
+		len += snprintf(buf + len, PAGE_SIZE - len,
+		  "AAC_DEBUG_INSTRUMENT_IO\n");
+#	endif
+#if (defined(SERVICE_ACTION_IN) && defined(SAI_READ_CAPACITY_16))
+	{
+		struct aac_dev *dev = (struct aac_dev*)class_to_shost(class_dev)->hostdata;
+		if (dev->raw_io_interface && dev->raw_io_64)
+			len += snprintf(buf + len, PAGE_SIZE - len,
+			  "SAI_READ_CAPACITY_16\n");
+	}
+#endif
+	return len;
+}
+
+static ssize_t aac_show_kernel_version(struct class_device *class_dev, char *buf)
+{
+	struct aac_dev *dev = (struct aac_dev*)class_to_shost(class_dev)->hostdata;
+	int len, tmp;
+
+	tmp = le32_to_cpu(dev->adapter_info.kernelrev);
+	len = snprintf(buf, PAGE_SIZE, "kernel: %d.%d-%d[%d]\n", 
+	  tmp >> 24, (tmp >> 16) & 0xff, tmp & 0xff,
+	  le32_to_cpu(dev->adapter_info.kernelbuild));
+	return len;
+}
+
+static ssize_t aac_show_monitor_version(struct class_device *class_dev, char *buf)
+{
+	struct aac_dev *dev = (struct aac_dev*)class_to_shost(class_dev)->hostdata;
+	int len, tmp;
+
+	tmp = le32_to_cpu(dev->adapter_info.monitorrev);
+	len = snprintf(buf, PAGE_SIZE, "monitor: %d.%d-%d[%d]\n", 
+	  tmp >> 24, (tmp >> 16) & 0xff, tmp & 0xff,
+	  le32_to_cpu(dev->adapter_info.monitorbuild));
+	return len;
+}
+
+static ssize_t aac_show_bios_version(struct class_device *class_dev, char *buf)
+{
+	struct aac_dev *dev = (struct aac_dev*)class_to_shost(class_dev)->hostdata;
+	int len, tmp;
+
+	tmp = le32_to_cpu(dev->adapter_info.biosrev);
+	len = snprintf(buf, PAGE_SIZE, "bios: %d.%d-%d[%d]\n", 
+	  tmp >> 24, (tmp >> 16) & 0xff, tmp & 0xff,
+	  le32_to_cpu(dev->adapter_info.biosbuild));
+	return len;
+}
+
+static ssize_t aac_show_serial_number(struct class_device *class_dev, char *buf)
+{
+	struct aac_dev *dev = (struct aac_dev*)class_to_shost(class_dev)->hostdata;
+	int len = 0;
+
+	if (le32_to_cpu(dev->adapter_info.serial[0]) != 0xBAD0)
+		len = snprintf(buf, PAGE_SIZE, "serial: %x\n",
+		  le32_to_cpu(dev->adapter_info.serial[0]));
+	return len;
+}
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
+
+static struct class_device_attribute aac_host_version = {
+	.attr = {
+		.name = "aac_version",
+		.mode = S_IRUGO,
+	},
+	.show = aac_show_host_version,
+};
+static struct class_device_attribute aac_model = {
+	.attr = {
+		.name = "aac_model",
+		.mode = S_IRUGO,
+	},
+	.show = aac_show_model,
+};
+static struct class_device_attribute aac_flags = {
+	.attr = {
+		.name = "aac_flags",
+		.mode = S_IRUGO,
+	},
+	.show = aac_show_flags,
+};
+static struct class_device_attribute aac_kernel_version = {
+	.attr = {
+		.name = "aac_kernel_version",
+		.mode = S_IRUGO,
+	},
+	.show = aac_show_kernel_version,
+};
+static struct class_device_attribute aac_monitor_version = {
+	.attr = {
+		.name = "aac_monitor_version",
+		.mode = S_IRUGO,
+	},
+	.show = aac_show_monitor_version,
+};
+static struct class_device_attribute aac_bios_version = {
+	.attr = {
+		.name = "aac_bios_version",
+		.mode = S_IRUGO,
+	},
+	.show = aac_show_bios_version,
+};
+static struct class_device_attribute aac_serial_number = {
+	.attr = {
+		.name = "aac_serial_number",
+		.mode = S_IRUGO,
+	},
+	.show = aac_show_serial_number,
+};
+
+static struct class_device_attribute *aac_attrs[] = {
+	&aac_host_version,
+	&aac_model,
+	&aac_flags,
+	&aac_kernel_version,
+	&aac_monitor_version,
+	&aac_bios_version,
+	&aac_serial_number,
+	NULL
+};
+#endif
+#if ((LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)) || defined(CONFIG_SCSI_PROC_FS))
+
+/**
+ *	aac_procinfo	-	Implement /proc/scsi/<drivername>/<n>
+ *	@proc_buffer: memory buffer for I/O
+ *	@start_ptr: pointer to first valid data
+ *	@offset: offset into file
+ *	@bytes_available: space left
+ *	@host_no: scsi host ident
+ *	@write: direction of I/O
+ *
+ *	Used to export driver statistics and other infos to the world outside 
+ *	the kernel using the proc file system. Also provides an interface to
+ *	feed the driver with information.
+ *
+ *		For reads
+ *			- if offset > 0 return 0
+ *			- if offset == 0 write data to proc_buffer and set the start_ptr to
+ *			beginning of proc_buffer, return the number of characters written.
+ *		For writes
+ *			- writes currently not supported, return 0
+ *
+ *	Bugs:	Only offset zero is handled
+ */
+
+static int aac_procinfo(
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
+	struct Scsi_Host * shost,
+#endif
+	char *proc_buffer, char **start_ptr,off_t offset,
+	int bytes_available,
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
+	int host_no,
+#endif
+	int write)
+{
+	struct aac_dev * dev = (struct aac_dev *)NULL;
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
+	struct Scsi_Host * shost = (struct Scsi_Host *)NULL;
+#endif
+	char *buf;
+	int len;
+	int total_len = 0;
+
+#if (defined(AAC_LM_SENSOR))
+	if(offset > 0)
+#else
+	if(write || offset > 0)
+#endif
+		return 0;
+	*start_ptr = proc_buffer;
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
+	dev = (struct aac_dev *)shost->hostdata;
+#else
+	list_for_each_entry(dev, &aac_devices, entry) {
+		shost = dev->scsi_host_ptr;
+		if (shost->host_no == host_no)
+			break;
+	}
+#endif
+	if (dev == (struct aac_dev *)NULL)
+		return 0;
+	if (!write) {
+		buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
+		if (!buf)
+			return 0;
+		len = aac_show_host_version(shost_to_class(shost), buf);
+		total_len += len;
+		memcpy(proc_buffer, buf, len);
+		proc_buffer += len;
+		len = aac_show_model(shost_to_class(shost), buf);
+		total_len += len;
+		if (total_len > bytes_available) {
+			kfree(buf);
+			return 0;
+		}
+		memcpy(proc_buffer, buf, len);
+		proc_buffer += len;
+		len = aac_show_flags(shost_to_class(shost), buf);
+		if (len) {
+			static char flags_equal[] = "flags=";
+			char *cp;
+			total_len += len + sizeof(flags_equal) - 1;
+			if (total_len > bytes_available) {
+				kfree(buf);
+				return 0;
+			}
+			memcpy(proc_buffer, flags_equal, sizeof(flags_equal) - 1);
+			cp = proc_buffer + (sizeof(flags_equal) - 1);
+			memcpy(cp, buf, len);
+			proc_buffer += len + sizeof(flags_equal) - 1;
+			while (--len > 0) {
+				if (*cp == '\n')
+					*cp = '+';
+				++cp;
+			}
+		}
+		len = aac_show_kernel_version(shost_to_class(shost), buf);
+		total_len += len;
+		if (total_len > bytes_available) {
+			kfree(buf);
+			return 0;
+		}
+		memcpy(proc_buffer, buf, len);
+		proc_buffer += len;
+		len = aac_show_monitor_version(shost_to_class(shost), buf);
+		total_len += len;
+		if (total_len > bytes_available) {
+			kfree(buf);
+			return 0;
+		}
+		memcpy(proc_buffer, buf, len);
+		proc_buffer += len;
+		len = aac_show_bios_version(shost_to_class(shost), buf);
+		total_len += len;
+		if (total_len > bytes_available) {
+			kfree(buf);
+			return 0;
+		}
+		memcpy(proc_buffer, buf, len);
+		proc_buffer += len;
+		len = aac_show_serial_number(shost_to_class(shost), buf);
+		total_len += len;
+		if (total_len > bytes_available) {
+			kfree(buf);
+			return 0;
+		}
+		memcpy(proc_buffer, buf, len);
+		kfree(buf);
+		return total_len;
+	}
+#if (defined(AAC_LM_SENSOR))
+	{
+		int ret, tmp, index;
+		s32 temp[5];
+		static char temperature[] = "temperature=";
+		if (strnicmp (proc_buffer, temperature, sizeof(temperature) - 1))
+			return bytes_available;
+		for (index = 0;
+		  index < (sizeof(temp)/sizeof(temp[0]));
+		  ++index)
+			temp[index] = 0x80000000;
+		ret = sizeof(temperature) - 1;
+		for (index = 0;
+		  index < (sizeof(temp)/sizeof(temp[0]));
+		  ++index) {
+			int sign, mult, c;
+			if (ret >= bytes_available)
+				break;
+			c = proc_buffer[ret];
+			if (c == '\n') {
+				++ret;
+				break;
+			}
+			if (c == ',') {
+				++ret;
+				continue;
+			}
+			sign = 1;
+			mult = 0;
+			tmp = 0;
+			if (c == '-') {
+				sign = -1;
+				++ret;
+			}
+			for (;
+			  (ret < bytes_available) && ((c = proc_buffer[ret]));
+			  ++ret) {
+				if (('0' <= c) && (c <= '9')) {
+					tmp *= 10;
+					tmp += c - '0';
+					mult *= 10;
+				} else if ((c == '.') && (mult == 0))
+					mult = 1;
+				else
+					break;
+			}
+			if ((ret < bytes_available)
+			 && ((c == ',') || (c == '\n')))
+				++ret;
+			if (!mult)
+				mult = 1;
+			if (sign < 0)
+				tmp = -tmp;
+			temp[index] = ((tmp << 8) + (mult >> 1)) / mult;
+			if (c == '\n')
+				break;
+		}
+		ret = index;
+		if (nblank(dprintk(x))) {
+			for (index = 0; index < ret; ++index) {
+				int sign;
+				tmp = temp[index];
+				sign = tmp < 0;
+				if (sign)
+					tmp = -tmp;
+				dprintk((KERN_DEBUG "%s%s%d.%08doC",
+				  (index ? "," : ""),
+				  (sign ? "-" : ""),
+				  tmp >> 8, (tmp % 256) * 390625));
+			}
+		}
+		/* Send temperature message to Firmware */
+		(void)aac_adapter_sync_cmd(dev, RCV_TEMP_READINGS,
+		  ret, temp[0], temp[1], temp[2], temp[3], temp[4],
+		  NULL, NULL, NULL, NULL, NULL);
+		return bytes_available;
+	}
+#endif
+	return 0;
 }
+#endif
 
 /**
  *	aac_cfg_open		-	open a configuration file
@@ -437,14 +1490,37 @@ static int aac_eh_reset(struct scsi_cmnd
 
 static int aac_cfg_open(struct inode *inode, struct file *file)
 {
-	unsigned minor = iminor(inode);
+	struct aac_dev *aac;
+	unsigned minor_number = iminor(inode);
+	int err = -ENODEV;
 
-	if (minor >= aac_count)
-		return -ENODEV;
-	file->private_data = aac_devices[minor];
+	list_for_each_entry(aac, &aac_devices, entry) {
+		if (aac->id == minor_number) {
+			file->private_data = aac;
+			err = 0;
+			break;
+		}
+	}
+
+	return err;
+}
+
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
+/**
+ *	aac_cfg_release		-	close down an AAC config device
+ *	@inode: inode of configuration file
+ *	@file: file handle of configuration file
+ *	
+ *	Called when the last close of the configuration file handle
+ *	is performed.
+ */
+ 
+static int aac_cfg_release(struct inode * inode, struct file * file )
+{
 	return 0;
 }
 
+#endif
 /**
  *	aac_cfg_ioctl		-	AAC configuration request
  *	@inode: inode of device
@@ -462,28 +1538,138 @@ static int aac_cfg_open(struct inode *in
 static int aac_cfg_ioctl(struct inode *inode,  struct file *file,
 		unsigned int cmd, unsigned long arg)
 {
+#if ((LINUX_VERSION_CODE < KERNEL_VERSION(2,4,4)) && defined(__VMKERNEL_MODULE__))
+	list_for_each_entry(aac, &aac_devices, entry) {
+		if (aac->id == iminor(inode);
+			file->private_data = aac;
+			break;
+		}
+	}
+	if (file->private_data == NULL)
+		return -ENODEV;
+#endif
+#if (defined(AAC_DEBUG_INSTRUMENT_IOCTL))
+	int retval;
+	if (cmd != FSACTL_GET_NEXT_ADAPTER_FIB)
+		printk("aac_cfg_ioctl(%p,%p,%x,%lx)\n", inode, file, cmd, arg);
+	retval = aac_do_ioctl(file->private_data, cmd, (void __user *)arg);
+	if (cmd != FSACTL_GET_NEXT_ADAPTER_FIB)
+		printk("aac_cfg_ioctl returns %d\n", retval);
+	return retval;
+#else
 	return aac_do_ioctl(file->private_data, cmd, (void __user *)arg);
+#endif
+}
+
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,11))
+#ifdef CONFIG_COMPAT
+static long aac_compat_do_ioctl(struct aac_dev *dev, unsigned cmd, unsigned long arg)
+{
+	long ret;
+	lock_kernel();
+	switch (cmd) { 
+	case FSACTL_MINIPORT_REV_CHECK:
+	case FSACTL_SENDFIB:
+	case FSACTL_OPEN_GET_ADAPTER_FIB:
+	case FSACTL_CLOSE_GET_ADAPTER_FIB:
+	case FSACTL_SEND_RAW_SRB:
+	case FSACTL_GET_PCI_INFO:
+	case FSACTL_QUERY_DISK:
+	case FSACTL_DELETE_DISK:
+	case FSACTL_FORCE_DELETE_DISK:
+	case FSACTL_GET_CONTAINERS: 
+	case FSACTL_GET_VERSION_MATCHING:
+	case FSACTL_SEND_LARGE_FIB:
+#if (defined(FSACTL_REGISTER_FIB_SEND))
+	case FSACTL_REGISTER_FIB_SEND:
+#endif
+		ret = aac_do_ioctl(dev, cmd, (void __user *)arg);
+		break;
+
+	case FSACTL_GET_NEXT_ADAPTER_FIB: {
+		struct fib_ioctl __user *f;
+		
+		f = compat_alloc_user_space(sizeof(*f));
+		ret = 0;
+		if (clear_user(f, sizeof(*f) != sizeof(*f)))
+			ret = -EFAULT;
+		if (copy_in_user(f, (void __user *)arg, sizeof(struct fib_ioctl) - sizeof(u32)))
+			ret = -EFAULT;
+		if (!ret)
+			ret = aac_do_ioctl(dev, cmd, (void __user *)arg);
+		break;
+	}
+
+	default:
+#if (defined(AAC_CSMI))
+		ret = aac_csmi_ioctl(dev, cmd, (void __user *)arg);
+		if (ret == -ENOTTY)
+#endif
+		ret = -ENOIOCTLCMD; 
+		break;
+	} 
+	unlock_kernel();
+	return ret;
+}
+
+static int aac_compat_ioctl(struct scsi_device *sdev, int cmd, void __user *arg)
+{
+	struct aac_dev *dev = (struct aac_dev *)sdev->host->hostdata;
+	return aac_compat_do_ioctl(dev, cmd, (unsigned long)arg);
+}
+
+static long aac_compat_cfg_ioctl(struct file *file, unsigned cmd, unsigned long arg)
+{
+	return aac_compat_do_ioctl((struct aac_dev *)file->private_data, cmd, arg);
 }
+#endif
+#endif
 
 static struct file_operations aac_cfg_fops = {
 	.owner		= THIS_MODULE,
 	.ioctl		= aac_cfg_ioctl,
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,11))
+#ifdef CONFIG_COMPAT
+	.compat_ioctl   = aac_compat_cfg_ioctl,
+#endif
+#endif
 	.open		= aac_cfg_open,
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
+	.release	= aac_cfg_release
+#endif
 };
 
 static struct scsi_host_template aac_driver_template = {
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
+	.detect				= aac_detect,
+#endif
 	.module				= THIS_MODULE,
 	.name           		= "AAC",
-	.proc_name			= "aacraid",
+	.proc_name			= AAC_DRIVERNAME,
 	.info           		= aac_info,
 	.ioctl          		= aac_ioctl,
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,11))
+#ifdef CONFIG_COMPAT
+	.compat_ioctl			= aac_compat_ioctl,
+#endif
+#endif
 	.queuecommand   		= aac_queuecommand,
 	.bios_param     		= aac_biosparm,	
+#if ((LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)) || defined(CONFIG_SCSI_PROC_FS))
+	.proc_info      		= aac_procinfo,
+#endif
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
+	.shost_attrs			= aac_attrs,
 	.slave_configure		= aac_slave_configure,
+#endif
 	.eh_abort_handler		= aac_eh_abort,
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
+	.eh_device_reset_handler	= aac_eh_device_reset,
+	.eh_bus_reset_handler		= aac_eh_bus_reset,
+#endif
 	.eh_host_reset_handler		= aac_eh_reset,
 	.can_queue      		= AAC_NUM_IO_FIB,	
-	.this_id        		= 16,
+	.this_id        		= MAXIMUM_NUM_CONTAINERS,
 	.sg_tablesize   		= 16,
 	.max_sectors    		= 128,
 #if (AAC_NUM_IO_FIB > 256)
@@ -491,7 +1677,19 @@ static struct scsi_host_template aac_dri
 #else		
 	.cmd_per_lun    		= AAC_NUM_IO_FIB, 
 #endif	
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
+	.use_new_eh_code		= 1, 
+#endif
 	.use_clustering			= ENABLE_CLUSTERING,
+#if (defined(SCSI_HAS_VARY_IO))
+	.vary_io			= 1,
+#endif
+#if (defined(SCSI_HAS_DUMP))
+#if (defined(SCSI_HAS_DUMP_SANITY_CHECK))
+	.dump_sanity_check		= aac_sanity_check,
+#endif
+	.dump_poll			= aac_poll,
+#endif
 };
 
 
@@ -500,16 +1698,88 @@ static int __devinit aac_probe_one(struc
 {
 	unsigned index = id->driver_data;
 	struct Scsi_Host *shost;
-	struct fsa_scsi_hba *fsa_dev_ptr;
 	struct aac_dev *aac;
-	int container;
+	struct list_head *insert = &aac_devices;
 	int error = -ENODEV;
+	int unique_id = 0;
+	static struct pci_dev * slave = NULL;
+	static int nslave = 0;
+
+	if (aac_drivers[index].quirks & AAC_QUIRK_SLAVE) {
+		/* detect adjoining slaves */
+		if (slave) {
+			if ((pci_resource_start(pdev, 0)
+			  + pci_resource_len(pdev, 0))
+			  == pci_resource_start(slave, 0))
+				slave = pdev;
+			else if ((pci_resource_start(slave, 0)
+			  + (pci_resource_len(slave, 0) * nslave))
+			  != pci_resource_start(pdev, 0)) {
+				printk(KERN_WARNING
+				  "%s: multiple sets of slave controllers discovered\n",
+				  AAC_DRIVERNAME);
+				nslave = 0;
+				slave = pdev;
+			}
+		} else
+			slave = pdev;
+		if (pci_resource_start(slave,0)) {
+			error = pci_enable_device(pdev);
+			if (error) {
+				printk(KERN_WARNING
+				  "%s: failed to enable slave\n",
+				  AAC_DRIVERNAME);
+				nslave = 0;
+				slave = NULL;
+				return error;
+			}
+			++nslave;
+			pci_set_master(pdev);
+		} else {
+			printk(KERN_WARNING
+			  "%s: slave BAR0 is not set\n", AAC_DRIVERNAME);
+			nslave = 0;
+			slave = NULL;
+			return error;
+		}
+		return 1;
+	}
+	list_for_each_entry(aac, &aac_devices, entry) {
+		if (aac->id > unique_id)
+			break;
+		insert = &aac->entry;
+		unique_id++;
+	}
 
-	if (pci_enable_device(pdev))
+	error = pci_enable_device(pdev);
+	if (error)
 		goto out;
 
-	if (pci_set_dma_mask(pdev, 0xFFFFFFFFULL) || 
-			pci_set_consistent_dma_mask(pdev, 0xFFFFFFFFULL))
+	if ((aac_drivers[index].quirks & AAC_QUIRK_MASTER) && (slave)) {
+		unsigned long base = pci_resource_start(pdev, 0);
+		struct master_registers {
+			u32 x[51];
+			u32	E_CONFIG1;
+			u32 y[3];
+			u32	E_CONFIG2;
+		} __iomem * map = ioremap(base, AAC_MIN_FOOTPRINT_SIZE);
+		if (!map) {
+			printk(KERN_WARNING
+			  "%s: unable to map master adapter to configure slaves.\n",
+			  AAC_DRIVERNAME);
+		} else {
+			((struct master_registers *)map)->E_CONFIG2
+			  = cpu_to_le32(pci_resource_start(slave, 0));
+			((struct master_registers *)map)->E_CONFIG1
+			  = cpu_to_le32(0x5A000000 + nslave);
+			iounmap(map);
+		}
+		nslave = 0;
+		slave = NULL;
+	}
+
+	if (pci_set_dma_mask(pdev, DMA_32BIT_MASK) || 
+			pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK))
 		goto out;
 	/*
 	 * If the quirk31 bit is set, the adapter needs adapter
@@ -522,16 +1792,32 @@ static int __devinit aac_probe_one(struc
 	
 	pci_set_master(pdev);
 
-	/* Increment the host adapter count */
-	aac_count++;
-
 	shost = scsi_host_alloc(&aac_driver_template, sizeof(struct aac_dev));
+#if 0
+printk(KERN_INFO "scsi_host_alloc(%p,%d)=%p\n", &aac_driver_template, sizeof(struct aac_dev), shost);
+#endif
 	if (!shost)
 		goto out_disable_pdev;
 
 	shost->irq = pdev->irq;
 	shost->base = pci_resource_start(pdev, 0);
-	shost->unique_id = aac_count - 1;
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
+	scsi_set_pci_device(shost, pdev);
+#elif (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,9))
+	scsi_set_device(shost, &pdev->dev);
+#endif
+	shost->unique_id = unique_id;
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
+	/*
+	 *	This function is called after the device list
+	 *	has been built to find the tagged queueing
+	 *	depth supported for each device.
+	 */
+	shost->select_queue_depths = aac_queuedepth;
+#endif
+#if (defined(SERVICE_ACTION_IN))
+	shost->max_cmd_len = 16;
+#endif
 
 	aac = (struct aac_dev *)shost->hostdata;
 	aac->scsi_host_ptr = shost;	
@@ -539,19 +1825,28 @@ static int __devinit aac_probe_one(struc
 	aac->name = aac_driver_template.name;
 	aac->id = shost->unique_id;
 	aac->cardtype =  index;
+	INIT_LIST_HEAD(&aac->entry);
 
-	aac->fibs = kmalloc(sizeof(struct fib) * AAC_NUM_FIB, GFP_KERNEL);
+	aac->fibs = kmalloc(sizeof(struct fib) * (shost->can_queue + AAC_NUM_MGT_FIB), GFP_KERNEL);
 	if (!aac->fibs)
 		goto out_free_host;
 	spin_lock_init(&aac->fib_lock);
 
-	/* Initialize the ordinal number of the device to -1 */
-	fsa_dev_ptr = &aac->fsa_dev;
-	for (container = 0; container < MAXIMUM_NUM_CONTAINERS; container++)
-		fsa_dev_ptr->devname[container][0] = '\0';
-
-	if ((*aac_drivers[index].init)(aac))
+	/*
+	 *	Map in the registers from the adapter.
+	 */
+	aac->base_size = AAC_MIN_FOOTPRINT_SIZE;
+	if ((aac->regs.sa = ioremap(
+	  (unsigned long)aac->scsi_host_ptr->base, AAC_MIN_FOOTPRINT_SIZE))
+	  == NULL) {	
+		printk(KERN_WARNING "%s: unable to map adapter.\n",
+		  AAC_DRIVERNAME);
 		goto out_free_fibs;
+	}
+	if ((*aac_drivers[index].init)(aac))
+		goto out_unmap;
+
+	aac_get_fw_debug_buffer(aac);
 
 	/*
 	 * If we had set a smaller DMA mask earlier, set it to 4gig
@@ -559,10 +1854,23 @@ static int __devinit aac_probe_one(struc
 	 * address space.
 	 */
 	if (aac_drivers[index].quirks & AAC_QUIRK_31BIT)
-		if (pci_set_dma_mask(pdev, 0xFFFFFFFFULL))
-			goto out_free_fibs;
+		if (pci_set_dma_mask(pdev, DMA_32BIT_MASK))
+			goto out_deinit;
+
+	aac->maximum_num_channels = aac_drivers[index].channels;
+	error = aac_get_adapter_info(aac);
+	if (error < 0)
+		goto out_deinit;
 
-	aac_get_adapter_info(aac);
+	/*
+	 * Lets override negotiations and drop the maximum SG limit to 34
+	 */
+	if ((aac_drivers[index].quirks & AAC_QUIRK_34SG)
+	 && (aac->scsi_host_ptr->sg_tablesize > 34)) {
+		aac->scsi_host_ptr->sg_tablesize = 34;
+		aac->scsi_host_ptr->max_sectors
+		  = (aac->scsi_host_ptr->sg_tablesize * 8) + 112;
+	}
 
 	/*
 	 * max channel will be the physical channels plus 1 virtual channel
@@ -570,25 +1878,36 @@ static int __devinit aac_probe_one(struc
 	 * physical channels are address by their actual physical number+1
 	 */
 	if (aac->nondasd_support == 1)
-		shost->max_channel = aac_drivers[index].channels+1;
+		shost->max_channel = aac->maximum_num_channels+1;
 	else
 		shost->max_channel = 1;
 
+	aac_get_config_status(aac);
 	aac_get_containers(aac);
-	aac_devices[aac_count-1] = aac;
+	list_add(&aac->entry, insert);
+
+	shost->max_id = aac->maximum_num_containers;
+	if (shost->max_id < aac->maximum_num_physicals)
+		shost->max_id = aac->maximum_num_physicals;
+	if (shost->max_id < MAXIMUM_NUM_CONTAINERS)
+		shost->max_id = MAXIMUM_NUM_CONTAINERS;
+	else
+		shost->this_id = shost->max_id;
 
 	/*
 	 * dmb - we may need to move the setting of these parms somewhere else once
 	 * we get a fib that can report the actual numbers
 	 */
-	shost->max_id = MAXIMUM_NUM_CONTAINERS;
 	shost->max_lun = AAC_MAX_LUN;
 
+	pci_set_drvdata(pdev, shost);
+
 	error = scsi_add_host(shost, &pdev->dev);
 	if (error)
 		goto out_deinit;
-
-	pci_set_drvdata(pdev, shost);
+	fwprintf((aac, HBA_FLAGS_DBG_FW_PRINT_B,
+	  "Linux %s driver (%s)",
+	  AAC_DRIVERNAME, aac_driver_version));
 	scsi_scan_host(shost);
 
 	return 0;
@@ -598,18 +1917,20 @@ static int __devinit aac_probe_one(struc
 	wait_for_completion(&aac->aif_completion);
 
 	aac_send_shutdown(aac);
+	aac_adapter_disable_int(aac);
 	fib_map_free(aac);
 	pci_free_consistent(aac->pdev, aac->comm_size, aac->comm_addr, aac->comm_phys);
 	kfree(aac->queues);
 	free_irq(pdev->irq, aac);
-	iounmap((void * )aac->regs.sa);
+ out_unmap:
+	iounmap(aac->regs.sa);
  out_free_fibs:
 	kfree(aac->fibs);
+	kfree(aac->fsa_dev);
  out_free_host:
 	scsi_host_put(shost);
  out_disable_pdev:
 	pci_disable_device(pdev);
-	aac_count--;
  out:
 	return error;
 }
@@ -625,28 +1946,21 @@ static void __devexit aac_remove_one(str
 	wait_for_completion(&aac->aif_completion);
 
 	aac_send_shutdown(aac);
+	aac_adapter_disable_int(aac);
 	fib_map_free(aac);
 	pci_free_consistent(aac->pdev, aac->comm_size, aac->comm_addr,
 			aac->comm_phys);
 	kfree(aac->queues);
 
 	free_irq(pdev->irq, aac);
-	iounmap((void * )aac->regs.sa);
+	iounmap(aac->regs.sa);
 	
 	kfree(aac->fibs);
+	kfree(aac->fsa_dev);
 	
+	list_del(&aac->entry);
 	scsi_host_put(shost);
 	pci_disable_device(pdev);
-
-	/*
-	 * We don't decrement aac_count here because adapters can be unplugged
-	 * in a different order than they were detected.  If we're ever going
-	 * to overflow MAXIMUM_NUM_ADAPTERS we'll have to consider using a
-	 * bintmap of free aac_devices slots.
-	 */
-#if 0
-	aac_count--;
-#endif
 }
 
 static struct pci_driver aac_pci_driver = {
@@ -656,15 +1970,35 @@ static struct pci_driver aac_pci_driver 
 	.remove		= __devexit_p(aac_remove_one),
 };
 
+static int aac_reboot_event(struct notifier_block * n, ulong code, void *p)
+{
+	if ((code == SYS_RESTART)
+	 || (code == SYS_HALT)
+	 || (code == SYS_POWER_OFF)) {
+		struct aac_dev *aac;
+
+		list_for_each_entry(aac, &aac_devices, entry)
+			aac_send_shutdown(aac);
+	}
+	return NOTIFY_DONE;
+}
+
+static struct notifier_block aac_reboot_notifier =
+{
+	aac_reboot_event,
+	NULL,
+	0
+};
+
 static int __init aac_init(void)
 {
 	int error;
 	
-	printk(KERN_INFO "Red Hat/Adaptec aacraid driver (%s %s)\n",
-			AAC_DRIVER_VERSION, AAC_DRIVER_BUILD_DATE);
+	printk(KERN_INFO "Adaptec %s driver (%s)\n",
+	  AAC_DRIVERNAME, aac_driver_version);
 
-	error = pci_module_init(&aac_pci_driver);
-	if (error)
+	error = pci_register_driver(&aac_pci_driver);
+	if (error < 0)
 		return error;
 
 	aac_cfg_major = register_chrdev( 0, "aac", &aac_cfg_fops);
@@ -672,27 +2006,57 @@ static int __init aac_init(void)
 		printk(KERN_WARNING
 		       "aacraid: unable to register \"aac\" device.\n");
 	}
-#ifdef CONFIG_COMPAT
-	register_ioctl32_conversion(FSACTL_MINIPORT_REV_CHECK, NULL);
-	register_ioctl32_conversion(FSACTL_SENDFIB, NULL);
-	register_ioctl32_conversion(FSACTL_OPEN_GET_ADAPTER_FIB, NULL);
-	register_ioctl32_conversion(FSACTL_GET_NEXT_ADAPTER_FIB, 
-		aac_get_next_adapter_fib_ioctl);
-	register_ioctl32_conversion(FSACTL_CLOSE_GET_ADAPTER_FIB, NULL);
-	register_ioctl32_conversion(FSACTL_SEND_RAW_SRB, NULL);
-	register_ioctl32_conversion(FSACTL_GET_PCI_INFO, NULL);
-	register_ioctl32_conversion(FSACTL_QUERY_DISK, NULL);
-	register_ioctl32_conversion(FSACTL_DELETE_DISK, NULL);
-	register_ioctl32_conversion(FSACTL_FORCE_DELETE_DISK, NULL);
-	register_ioctl32_conversion(FSACTL_GET_CONTAINERS, NULL);
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,11))
+#if ((LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)) ? defined(__x86_64__) : defined(CONFIG_COMPAT))
+	aac_ioctl32(FSACTL_MINIPORT_REV_CHECK, sys_ioctl);
+	aac_ioctl32(FSACTL_SENDFIB, sys_ioctl);
+	aac_ioctl32(FSACTL_OPEN_GET_ADAPTER_FIB, sys_ioctl);
+	aac_ioctl32(FSACTL_GET_NEXT_ADAPTER_FIB,
+	  aac_get_next_adapter_fib_ioctl);
+	aac_ioctl32(FSACTL_CLOSE_GET_ADAPTER_FIB, sys_ioctl);
+	aac_ioctl32(FSACTL_SEND_RAW_SRB, sys_ioctl);
+	aac_ioctl32(FSACTL_GET_PCI_INFO, sys_ioctl);
+	aac_ioctl32(FSACTL_QUERY_DISK, sys_ioctl);
+	aac_ioctl32(FSACTL_DELETE_DISK, sys_ioctl);
+	aac_ioctl32(FSACTL_FORCE_DELETE_DISK, sys_ioctl);
+	aac_ioctl32(FSACTL_GET_CONTAINERS, sys_ioctl);
+#if (defined(FSACTL_REGISTER_FIB_SEND))
+	aac_ioctl32(FSACTL_REGISTER_FIB_SEND, sys_ioctl);
+#endif
+	aac_ioctl32(FSACTL_GET_VERSION_MATCHING, sys_ioctl);
+	aac_ioctl32(FSACTL_SEND_LARGE_FIB, sys_ioctl);
+#if (defined(AAC_CSMI))
+	aac_csmi_register_ioctl32_conversion();
+#endif
+#endif
+#endif
+#if 0
+printk(KERN_INFO "list_empty(&aac_devices)=%d\n", list_empty(&aac_devices));
+#endif
+	if (!list_empty(&aac_devices)) {
+		register_reboot_notifier(&aac_reboot_notifier);
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
+		/* Trigger a target scan in the 2.4 tree */
+		if (!aac_dummy) {
+			aac_dummy = scsi_host_alloc(&aac_driver_template,0);
+#if 0
+printk(KERN_INFO "scsi_host_alloc(%p,0)=%p\n", &aac_driver_template, aac_dummy);
+#endif
+		}
+#if 0
+printk(KERN_INFO "scsi_register_module(MODULE_SCSI_HA,%p)\n", &aac_driver_template);
+#endif
+		scsi_register_module(MODULE_SCSI_HA,&aac_driver_template);
 #endif
+	}
 
 	return 0;
 }
 
 static void __exit aac_exit(void)
 {
-#ifdef CONFIG_COMPAT
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,11))
+#if ((LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)) ? defined(__x86_64__) : defined(CONFIG_COMPAT))
 	unregister_ioctl32_conversion(FSACTL_MINIPORT_REV_CHECK);
 	unregister_ioctl32_conversion(FSACTL_SENDFIB);
 	unregister_ioctl32_conversion(FSACTL_OPEN_GET_ADAPTER_FIB);
@@ -704,10 +2068,23 @@ static void __exit aac_exit(void)
 	unregister_ioctl32_conversion(FSACTL_DELETE_DISK);
 	unregister_ioctl32_conversion(FSACTL_FORCE_DELETE_DISK);
 	unregister_ioctl32_conversion(FSACTL_GET_CONTAINERS);
+#if (defined(FSACTL_REGISTER_FIB_SEND))
+	unregister_ioctl32_conversion(FSACTL_REGISTER_FIB_SEND);
+#endif
+	unregister_ioctl32_conversion(FSACTL_GET_VERSION_MATCHING);
+	unregister_ioctl32_conversion(FSACTL_SEND_LARGE_FIB);
+#if (defined(AAC_CSMI))
+	aac_csmi_unregister_ioctl32_conversion();
+#endif
+#endif
 #endif
 	unregister_chrdev(aac_cfg_major, "aac");
+	unregister_reboot_notifier(&aac_reboot_notifier);
 	pci_unregister_driver(&aac_pci_driver);
 }
 
 module_init(aac_init);
 module_exit(aac_exit);
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
+EXPORT_NO_SYMBOLS;
+#endif
--- linux-2.6.8.1-t043-libata-update/drivers/scsi/aacraid/TODO	2005-09-26 13:33:12.000000000 +0400
+++ aacraid-drv/drivers/scsi/aacraid/TODO	2005-03-03 19:08:40.000000000 +0300
@@ -1,6 +1,3 @@
 o	Testing
 o	More testing
-o	Feature request: display the firmware/bios/etc revisions in the
-	/proc info
-o	Drop irq_mask, basically unused
 o	I/O size increase
--- linux-2.6.8.1-t043-libata-update/drivers/scsi/aacraid/commctrl.c	2005-09-26 13:33:12.000000000 +0400
+++ aacraid-drv/drivers/scsi/aacraid/commctrl.c	2005-05-02 22:56:44.000000000 +0400
@@ -36,12 +36,23 @@
 #include <linux/spinlock.h>
 #include <linux/slab.h>
 #include <linux/completion.h>
+#include <linux/version.h> /* for the following test */
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
 #include <linux/dma-mapping.h>
+#endif
 #include <linux/blkdev.h>
 #include <asm/semaphore.h>
 #include <asm/uaccess.h>
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,0))
+#include <scsi/scsi.h>
+#else
+#include "scsi.h"
+#endif
 
 #include "aacraid.h"
+#if (defined(AAC_CSMI))
+# include "csmi.h"
+#endif
 
 /**
  *	ioctl_send_fib	-	send a FIB from userspace
@@ -51,15 +62,45 @@
  *	This routine sends a fib to the adapter on behalf of a user level
  *	program.
  */
+#if (defined(AAC_DEBUG_INSTRUMENT_IOCTL_SENDFIB))
+static char * aac_debug_timestamp(void)
+{
+	unsigned long seconds = get_seconds();
+	static char buffer[80];
+	sprintf(buffer, "%02u:%02u:%02u: ",
+	  (int)((seconds / 3600) % 24),
+	  (int)((seconds / 60) % 60),
+	  (int)(seconds % 60));
+	return buffer;
+}
+# define AAC_DEBUG_PREAMBLE	"%s"
+# define AAC_DEBUG_POSTAMBLE	,aac_debug_timestamp()
+#else
+# define AAC_DEBUG_PREAMBLE	KERN_INFO
+# define AAC_DEBUG_POSTAMBLE
+#endif
  
 static int ioctl_send_fib(struct aac_dev * dev, void __user *arg)
 {
 	struct hw_fib * kfib;
 	struct fib *fibptr;
-
+	struct hw_fib * hw_fib = (struct hw_fib *)0;
+	dma_addr_t hw_fib_pa = (dma_addr_t)0LL;
+	unsigned size;
+	int retval;
+
+#if (defined(AAC_DEBUG_INSTRUMENT_IOCTL) || defined(AAC_DEBUG_INSTRUMENT_IOCTL_SENDFIB))
+	printk(AAC_DEBUG_PREAMBLE "ioctl_send_fib(%p,%p)\n" AAC_DEBUG_POSTAMBLE,
+	  dev, arg);
+#endif
 	fibptr = fib_alloc(dev);
-	if(fibptr == NULL)
+	if(fibptr == NULL) {
+#if (defined(AAC_DEBUG_INSTRUMENT_IOCTL) || defined(AAC_DEBUG_INSTRUMENT_IOCTL_SENDFIB))
+		printk(AAC_DEBUG_PREAMBLE "ioctl_send_fib returns -ENOMEM\n"
+		  AAC_DEBUG_POSTAMBLE);
+#endif
 		return -ENOMEM;
+	}
 		
 	kfib = fibptr->hw_fib;
 	/*
@@ -67,6 +108,10 @@ static int ioctl_send_fib(struct aac_dev
 	 */
 	if (copy_from_user((void *)kfib, arg, sizeof(struct aac_fibhdr))) {
 		fib_free(fibptr);
+#if (defined(AAC_DEBUG_INSTRUMENT_IOCTL) || defined(AAC_DEBUG_INSTRUMENT_IOCTL_SENDFIB))
+		printk(AAC_DEBUG_PREAMBLE "ioctl_send_fib returns -EFAULT\n"
+		  AAC_DEBUG_POSTAMBLE);
+#endif
 		return -EFAULT;
 	}
 	/*
@@ -74,17 +119,24 @@ static int ioctl_send_fib(struct aac_dev
 	 *	will not overrun the buffer when we copy the memory. Return
 	 *	an error if we would.
 	 */
-	if(le32_to_cpu(kfib->header.Size) > sizeof(struct hw_fib) - sizeof(struct aac_fibhdr)) {
-		fib_free(fibptr);
-		return -EINVAL;
+	size = le16_to_cpu(kfib->header.Size) + sizeof(struct aac_fibhdr);
+	if (size < le16_to_cpu(kfib->header.SenderSize))
+		size = le16_to_cpu(kfib->header.SenderSize);
+	if (size > dev->max_fib_size) {
+		/* Highjack the hw_fib */
+		hw_fib = fibptr->hw_fib;
+		hw_fib_pa = fibptr->hw_fib_pa;
+		fibptr->hw_fib = kfib = pci_alloc_consistent(dev->pdev, size, &fibptr->hw_fib_pa);
+		memset(((char *)kfib) + dev->max_fib_size, 0, size - dev->max_fib_size);
+		memcpy(kfib, hw_fib, dev->max_fib_size);
 	}
 
-	if (copy_from_user((void *) kfib, arg, le32_to_cpu(kfib->header.Size) + sizeof(struct aac_fibhdr))) {
-		fib_free(fibptr);
-		return -EFAULT;
+	if (copy_from_user(kfib, arg, size)) {
+		retval = -EFAULT;
+		goto cleanup;
 	}
 
-	if (kfib->header.Command == cpu_to_le32(TakeABreakPt)) {
+	if (kfib->header.Command == cpu_to_le16(TakeABreakPt)) {
 		aac_adapter_interrupt(dev);
 		/*
 		 * Since we didn't really send a fib, zero out the state to allow 
@@ -92,16 +144,43 @@ static int ioctl_send_fib(struct aac_dev
 		 */
 		kfib->header.XferState = 0;
 	} else {
-		int retval = fib_send(kfib->header.Command, fibptr,
-				le32_to_cpu(kfib->header.Size) , FsaNormal,
+#		if (defined(AAC_DEBUG_INSTRUMENT_IOCTL) || defined(AAC_DEBUG_INSTRUMENT_IOCTL_SENDFIB))
+			{
+				u8 * fib = (u8 *)kfib;
+				unsigned len = le16_to_cpu(kfib->header.Size);
+				char buffer[80];
+				char * cp = buffer;
+
+				strcpy(cp, "FIB=");
+				cp += 4;
+				while (len > 0) {
+					if (cp >= &buffer[sizeof(buffer)-4]) {
+						printk (AAC_DEBUG_PREAMBLE
+						  "%s\n" AAC_DEBUG_POSTAMBLE,
+						  buffer);
+						strcpy(cp = buffer, "    ");
+						cp += 4;
+					}
+					sprintf (cp, "%02x ", *(fib++));
+					cp += strlen(cp);
+					--len;
+				}
+				if (cp > &buffer[4])
+					printk (AAC_DEBUG_PREAMBLE "%s\n"
+					  AAC_DEBUG_POSTAMBLE, buffer);
+			}
+			printk(AAC_DEBUG_PREAMBLE "fib_send(%x,,%d,...)\n"
+			  AAC_DEBUG_POSTAMBLE, kfib->header.Command,
+			  le16_to_cpu(kfib->header.Size));
+#		endif
+		retval = fib_send(le16_to_cpu(kfib->header.Command), fibptr,
+				le16_to_cpu(kfib->header.Size) , FsaNormal,
 				1, 1, NULL, NULL);
-		if (retval) {
-			fib_free(fibptr);
-			return retval;
-		}
+		if (retval)
+			goto cleanup;
 		if (fib_complete(fibptr) != 0) {
-			fib_free(fibptr);
-			return -EINVAL;
+			retval = -EINVAL;
+			goto cleanup;
 		}
 	}
 	/*
@@ -112,12 +191,21 @@ static int ioctl_send_fib(struct aac_dev
 	 *	was already included by the adapter.)
 	 */
 
-	if (copy_to_user(arg, (void *)kfib, kfib->header.Size)) {
-		fib_free(fibptr);
-		return -EFAULT;
+	retval = 0;
+	if (copy_to_user(arg, (void *)kfib, size))
+		retval = -EFAULT;
+cleanup:
+	if (hw_fib) {
+		pci_free_consistent(dev->pdev, size, kfib, fibptr->hw_fib_pa);
+		fibptr->hw_fib_pa = hw_fib_pa;
+		fibptr->hw_fib = hw_fib;
 	}
 	fib_free(fibptr);
-	return 0;
+#if (defined(AAC_DEBUG_INSTRUMENT_IOCTL) || defined(AAC_DEBUG_INSTRUMENT_IOCTL_SENDFIB))
+	printk(AAC_DEBUG_PREAMBLE "ioctl_send_fib returns %d\n"
+	  AAC_DEBUG_POSTAMBLE, retval);
+#endif
+	return retval;
 }
 
 /**
@@ -269,7 +357,6 @@ return_fib:
 		kfree(fib->hw_fib);
 		kfree(fib);
 		status = 0;
-		fibctx->jiffies = jiffies/HZ;
 	} else {
 		spin_unlock_irqrestore(&dev->fib_lock, flags);
 		if (f.wait) {
@@ -284,6 +371,7 @@ return_fib:
 			status = -EAGAIN;
 		}	
 	}
+	fibctx->jiffies = jiffies/HZ;
 	return status;
 }
 
@@ -306,8 +394,10 @@ int aac_close_fib_context(struct aac_dev
 		/*
 		 *	Free the space occupied by this copy of the fib.
 		 */
+		spin_unlock_irq(&dev->fib_lock);
 		kfree(fib->hw_fib);
 		kfree(fib);
+		spin_lock_irq(&dev->fib_lock);
 	}
 	/*
 	 *	Remove the Context from the AdapterFibContext List
@@ -320,7 +410,9 @@ int aac_close_fib_context(struct aac_dev
 	/*
 	 *	Free the space occupied by the Context
 	 */
+	spin_unlock_irq(&dev->fib_lock);
 	kfree(fibctx);
+	spin_lock_irq(&dev->fib_lock);
 	return 0;
 }
 
@@ -374,6 +466,15 @@ static int close_getadapter_fib(struct a
 	return status;
 }
 
+int aac_atoi(char ** str)
+{
+	int c, result = 0;
+
+	while (('0' <= (c = *((*str)++))) && (c <= '9'))
+		result = (result * 10) + (c - '0');
+	return result;
+}
+
 /**
  *	check_revision	-	close down user fib context
  *	@dev: adapter
@@ -387,28 +488,71 @@ static int close_getadapter_fib(struct a
 static int check_revision(struct aac_dev *dev, void __user *arg)
 {
 	struct revision response;
+	extern char aac_driver_version[];
+	char * driver_version = aac_driver_version;
+	u32 version;
 
 	response.compat = 1;
-	response.version = dev->adapter_info.kernelrev;
-	response.build = dev->adapter_info.kernelbuild;
+	version = (aac_atoi(&driver_version) << 24) | 0x00000400;
+	version += aac_atoi(&driver_version) << 16;
+	version += aac_atoi(&driver_version);
+	response.version = cpu_to_le32(version);
+#	if (defined(AAC_DRIVER_BUILD))
+		response.build = cpu_to_le32(AAC_DRIVER_BUILD);
+#	else
+		response.build = cpu_to_le32(9999);
+#	endif
 
 	if (copy_to_user(arg, &response, sizeof(response)))
 		return -EFAULT;
 	return 0;
 }
 
+#if (defined(CODE_STREAM_IDENTIFIER))
+/**
+ *	check_code_stream	-	close down user fib context
+ *	@dev: adapter
+ *	@arg: ioctl arguments
+ *
+ *	This routine returns the driver code stream identifier
+ */
+
+static int check_code_stream_identifier(struct aac_dev *dev, void __user *arg)
+{
+	struct VersionMatch response;
+
+	memset (&response, 0, sizeof(response));
+	strncpy (response.driver, CODE_STREAM_IDENTIFIER,
+	  MAX_CODE_STREAM_IDENTIFIER_LENGTH);
+	strncpy (response.firmware, dev->code_stream_identifier,
+	  MAX_CODE_STREAM_IDENTIFIER_LENGTH);
+	if (response.firmware[0] == '\0')
+		response.status = VERSION_MATCH_UNSUPPORTED;
+	else if (strncmp(response.driver, response.firmware,
+	  MAX_CODE_STREAM_IDENTIFIER_LENGTH))
+		response.status = VERSION_MATCH_FAILED;
+	else
+		response.status = VERSION_MATCH_SUCCESS;
+
+	if (copy_to_user(arg, &response, sizeof(response)))
+		return -EFAULT;
+	return 0;
+}
+#endif
+
 /**
  *
  * aac_send_raw_scb
  *
  */
 
-int aac_send_raw_srb(struct aac_dev* dev, void __user * arg)
+static int aac_send_raw_srb(struct aac_dev* dev, void __user * arg)
 {
 	struct fib* srbfib;
 	int status;
-	struct aac_srb *srbcmd;
-	struct aac_srb __user *user_srb = arg;
+	struct aac_srb *srbcmd = NULL;
+	struct user_aac_srb *user_srbcmd = NULL;
+	struct user_aac_srb __user *user_srb = arg;
 	struct aac_srb_reply __user *user_reply;
 	struct aac_srb_reply* reply;
 	u32 fibsize = 0;
@@ -424,7 +568,7 @@ int aac_send_raw_srb(struct aac_dev* dev
 
 
 	if (!capable(CAP_SYS_ADMIN)){
-		printk(KERN_DEBUG"aacraid: No permission to send raw srb\n"); 
+		dprintk((KERN_DEBUG"aacraid: No permission to send raw srb\n")); 
 		return -EPERM;
 	}
 	/*
@@ -437,37 +581,68 @@ int aac_send_raw_srb(struct aac_dev* dev
 
 	srbcmd = (struct aac_srb*) fib_data(srbfib);
 
+	memset(sg_list, 0, sizeof(sg_list)); /* cleanup may take issue */
 	if(copy_from_user(&fibsize, &user_srb->count,sizeof(u32))){
-		printk(KERN_DEBUG"aacraid: Could not copy data size from user\n"); 
+		dprintk((KERN_DEBUG"aacraid: Could not copy data size from user\n")); 
 		rcode = -EFAULT;
 		goto cleanup;
 	}
 
-	if (fibsize > FIB_DATA_SIZE_IN_BYTES) {
+	if (fibsize > (dev->max_fib_size - sizeof(struct aac_fibhdr))) {
 		rcode = -EINVAL;
 		goto cleanup;
 	}
 
-	if(copy_from_user(srbcmd, user_srb,fibsize)){
-		printk(KERN_DEBUG"aacraid: Could not copy srb from user\n"); 
+	user_srbcmd = kmalloc(GFP_KERNEL, fibsize);
+	if (!user_srbcmd) {
+		dprintk((KERN_DEBUG"aacraid: Could not make a copy of the srb\n"));
+		rcode = -ENOMEM;
+		goto cleanup;
+	}
+	if(copy_from_user(user_srbcmd, user_srb,fibsize)){
+		dprintk((KERN_DEBUG"aacraid: Could not copy srb from user\n")); 
 		rcode = -EFAULT;
 		goto cleanup;
 	}
+#	if (defined(AAC_DEBUG_INSTRUMENT_IOCTL))
+		{
+			u8 * srb = (u8 *)srbcmd;
+			unsigned len = fibsize;
+			char buffer[80];
+			char * cp = buffer;
+
+			strcpy(cp, "SRB=");
+			cp += 4;
+			while (len > 0) {
+				if (cp >= &buffer[sizeof(buffer)-4]) {
+					printk (KERN_INFO "%s\n", buffer);
+					strcpy(cp = buffer, "    ");
+					cp += 4;
+				}
+				sprintf (cp, "%02x ", *(srb++));
+				cp += strlen(cp);
+				--len;
+			}
+			if (cp > &buffer[4])
+				printk (KERN_INFO "%s\n", buffer);
+		}
+#	endif
 
 	user_reply = arg+fibsize;
 
-	flags = srbcmd->flags;
+	flags = user_srbcmd->flags; /* from user in cpu order */
 	// Fix up srb for endian and force some values
+
 	srbcmd->function = cpu_to_le32(SRBF_ExecuteScsi);	// Force this
-	srbcmd->channel  = cpu_to_le32(srbcmd->channel);
-	srbcmd->id	 = cpu_to_le32(srbcmd->id);
-	srbcmd->lun      = cpu_to_le32(srbcmd->lun);
-	srbcmd->flags    = cpu_to_le32(srbcmd->flags);
-	srbcmd->timeout  = cpu_to_le32(srbcmd->timeout);
+	srbcmd->channel  = cpu_to_le32(user_srbcmd->channel);
+	srbcmd->id	 = cpu_to_le32(user_srbcmd->id);
+	srbcmd->lun      = cpu_to_le32(user_srbcmd->lun);
+	srbcmd->flags    = cpu_to_le32(flags);
+	srbcmd->timeout  = cpu_to_le32(user_srbcmd->timeout);
 	srbcmd->retry_limit =cpu_to_le32(0); // Obsolete parameter
-	srbcmd->cdb_size = cpu_to_le32(srbcmd->cdb_size);
+	srbcmd->cdb_size = cpu_to_le32(user_srbcmd->cdb_size);
 	
-	switch (srbcmd->flags & (SRB_DataIn | SRB_DataOut)) {
+	switch (flags & (SRB_DataIn | SRB_DataOut)) {
 	case SRB_DataOut:
 		data_dir = DMA_TO_DEVICE;
 		break;
@@ -480,116 +655,200 @@ int aac_send_raw_srb(struct aac_dev* dev
 	default:
 		data_dir = DMA_NONE;
 	}
-	if (dev->pae_support == 1) {
-		struct sgmap64* psg = (struct sgmap64*)&srbcmd->sg;
+	if (le32_to_cpu(srbcmd->sg.count) > (sizeof(sg_list)/sizeof(sg_list[0]))) {
+		dprintk((KERN_DEBUG"aacraid: too many sg entries %d\n",
+		  le32_to_cpu(srbcmd->sg.count)));
+		rcode = -EINVAL;
+		goto cleanup;
+	}
+	if (dev->dac_support == 1) {
+		struct user_sgmap64* upsg = (struct user_sgmap64*)&user_srbcmd->sg;
+		struct sgmap64* psg = (struct sgmap64*)&user_srbcmd->sg;
+		struct user_sgmap* usg;
 		byte_count = 0;
 
 		/*
 		 * This should also catch if user used the 32 bit sgmap
 		 */
 		actual_fibsize = sizeof(struct aac_srb) - 
-			sizeof(struct sgentry) + ((srbcmd->sg.count & 0xff) * 
-			 	sizeof(struct sgentry64));
+			sizeof(struct sgentry) +
+			((upsg->count & 0xff) * 
+		 	sizeof(struct sgentry));
 		if(actual_fibsize != fibsize){ // User made a mistake - should not continue
-			printk(KERN_DEBUG"aacraid: Bad Size specified in Raw SRB command\n");
+			dprintk((KERN_DEBUG"aacraid: Bad Size specified in Raw SRB command\n"));
 			rcode = -EINVAL;
 			goto cleanup;
 		}
-		if ((data_dir == DMA_NONE) && psg->count) { 
-			printk(KERN_DEBUG"aacraid: SG with no direction specified in Raw SRB command\n");
+		usg = kmalloc(actual_fibsize - sizeof(struct aac_srb)
+		  + sizeof(struct sgmap), GFP_KERNEL);
+		if (!usg) {
+			dprintk((KERN_DEBUG"aacraid: Allocation error in Raw SRB command\n"));
+			rcode = -ENOMEM;
+			goto cleanup;
+		}
+		memcpy (usg, upsg, actual_fibsize - sizeof(struct aac_srb)
+		  + sizeof(struct sgmap));
+		actual_fibsize = sizeof(struct aac_srb) - 
+			sizeof(struct sgentry) + ((usg->count & 0xff) * 
+			 	sizeof(struct sgentry64));
+		if ((data_dir == DMA_NONE) && upsg->count) {
+			kfree (usg);
+			dprintk((KERN_DEBUG"aacraid: SG with no direction specified in Raw SRB command\n"));
 			rcode = -EINVAL;
 			goto cleanup;
 		}
 
-		for (i = 0; i < psg->count; i++) {
-			dma_addr_t addr; 
-			u64 le_addr;
+		for (i = 0; i < usg->count; i++) {
+			u64 addr;
 			void* p;
-			p = kmalloc(psg->sg[i].count,GFP_KERNEL|__GFP_DMA);
+			/* Does this really need to be GFP_DMA? */
+			p = kmalloc(usg->sg[i].count,GFP_KERNEL|__GFP_DMA);
 			if(p == 0) {
-				printk(KERN_DEBUG"aacraid: Could not allocate SG buffer - size = %d buffer number %d of %d\n",
-				psg->sg[i].count,i,psg->count);
+				kfree (usg);
+				dprintk((KERN_DEBUG"aacraid: Could not allocate SG buffer - size = %d buffer number %d of %d\n",
+				  usg->sg[i].count,i,usg->count));
 				rcode = -ENOMEM;
 				goto cleanup;
 			}
-			sg_user[i] = (void __user *)psg->sg[i].addr;
+			sg_user[i] = (void __user *)usg->sg[i].addr;
 			sg_list[i] = p; // save so we can clean up later
 			sg_indx = i;
 
 			if( flags & SRB_DataOut ){
-				if(copy_from_user(p,sg_user[i],psg->sg[i].count)){
-					printk(KERN_DEBUG"aacraid: Could not copy sg data from user\n"); 
+				if(copy_from_user(p,sg_user[i],upsg->sg[i].count)){
+					kfree (usg);
+					dprintk((KERN_DEBUG"aacraid: Could not copy sg data from user\n")); 
 					rcode = -EFAULT;
 					goto cleanup;
 				}
 			}
-			addr = pci_map_single(dev->pdev, p, psg->sg[i].count, data_dir);
+			addr = pci_map_single(dev->pdev, p, usg->sg[i].count, data_dir);
 
-			le_addr = cpu_to_le64(addr);
-			psg->sg[i].addr[1] = (u32)(le_addr>>32);
-			psg->sg[i].addr[0] = (u32)(le_addr & 0xffffffff);
-			psg->sg[i].count = cpu_to_le32(psg->sg[i].count);  
-			byte_count += psg->sg[i].count;
+			psg->sg[i].addr[0] = cpu_to_le32(addr & 0xffffffff);
+			psg->sg[i].addr[1] = cpu_to_le32(addr>>32);
+			psg->sg[i].count = cpu_to_le32(usg->sg[i].count);  
+			byte_count += usg->sg[i].count;
 		}
+		kfree (usg);
 
 		srbcmd->count = cpu_to_le32(byte_count);
+		psg->count = cpu_to_le32(sg_indx+1);
+#		if (defined(AAC_DEBUG_INSTRUMENT_IOCTL))
+			{
+				u8 * srb = (u8 *)srbfib->hw_fib;
+				unsigned len = actual_fibsize;
+				char buffer[80];
+				char * cp = buffer;
+
+				strcpy(cp, "FIB=");
+				cp += 4;
+				while (len > 0) {
+					if (cp >= &buffer[sizeof(buffer)-4]) {
+						printk (KERN_INFO "%s\n", buffer);
+						strcpy(cp = buffer, "    ");
+						cp += 4;
+					}
+					sprintf (cp, "%02x ", *(srb++));
+					cp += strlen(cp);
+					--len;
+				}
+				if (cp > &buffer[4])
+					printk (KERN_INFO "%s\n", buffer);
+			}
+			printk(KERN_INFO
+			  "fib_send(ScsiPortCommand64,,%d,...)\n",
+			  actual_fibsize);
+#		endif
 		status = fib_send(ScsiPortCommand64, srbfib, actual_fibsize, FsaNormal, 1, 1,NULL,NULL);
 	} else {
+		struct user_sgmap* upsg = &user_srbcmd->sg;
 		struct sgmap* psg = &srbcmd->sg;
 		byte_count = 0;
 
-		actual_fibsize = sizeof (struct aac_srb) + (((srbcmd->sg.count & 0xff) - 1) * sizeof (struct sgentry));
+		actual_fibsize = sizeof (struct aac_srb) + (((le32_to_cpu(srbcmd->sg.count) & 0xff) - 1) * sizeof (struct sgentry));
 		if(actual_fibsize != fibsize){ // User made a mistake - should not continue
-			printk(KERN_DEBUG"aacraid: Bad Size specified in Raw SRB command\n");
+			dprintk((KERN_DEBUG"aacraid: Bad Size specified in Raw SRB command\n"));
 			rcode = -EINVAL;
 			goto cleanup;
 		}
-		if ((data_dir == DMA_NONE) && psg->count) {
-			printk(KERN_DEBUG"aacraid: SG with no direction specified in Raw SRB command\n");
+		if ((data_dir == DMA_NONE) && upsg->count) {
+			dprintk((KERN_DEBUG"aacraid: SG with no direction specified in Raw SRB command\n"));
 			rcode = -EINVAL;
 			goto cleanup;
 		}
-		for (i = 0; i < psg->count; i++) {
+		for (i = 0; i < upsg->count; i++) {
 			dma_addr_t addr; 
 			void* p;
-			p = kmalloc(psg->sg[i].count,GFP_KERNEL);
+			p = kmalloc(upsg->sg[i].count,GFP_KERNEL);
 			if(p == 0) {
-				printk(KERN_DEBUG"aacraid: Could not allocate SG buffer - size = %d buffer number %d of %d\n",
-				psg->sg[i].count,i,psg->count);
+				dprintk((KERN_DEBUG"aacraid: Could not allocate SG buffer - size = %d buffer number %d of %d\n",
+				  upsg->sg[i].count,i,upsg->count));
 				rcode = -ENOMEM;
 				goto cleanup;
 			}
-			sg_user[i] = (void __user *)(psg->sg[i].addr);
+			sg_user[i] = (void __user *)upsg->sg[i].addr;
 			sg_list[i] = p; // save so we can clean up later
 			sg_indx = i;
 
 			if( flags & SRB_DataOut ){
-				if(copy_from_user(p,sg_user[i],psg->sg[i].count)){
-					printk(KERN_DEBUG"aacraid: Could not copy sg data from user\n"); 
+				if(copy_from_user(p, sg_user[i],
+						upsg->sg[i].count)) {
+					dprintk((KERN_DEBUG"aacraid: Could not copy sg data from user\n")); 
 					rcode = -EFAULT;
 					goto cleanup;
 				}
 			}
-			addr = pci_map_single(dev->pdev, p, psg->sg[i].count, data_dir);
+			addr = pci_map_single(dev->pdev, p,
+				upsg->sg[i].count, data_dir);
 
 			psg->sg[i].addr = cpu_to_le32(addr);
-			psg->sg[i].count = cpu_to_le32(psg->sg[i].count);  
-			byte_count += psg->sg[i].count;
+			psg->sg[i].count = cpu_to_le32(upsg->sg[i].count);  
+			byte_count += upsg->sg[i].count;
 		}
 		srbcmd->count = cpu_to_le32(byte_count);
+		psg->count = cpu_to_le32(sg_indx+1);
+#		if (defined(AAC_DEBUG_INSTRUMENT_IOCTL))
+			{
+				u8 * srb = (u8 *)srbfib->hw_fib;
+				unsigned len = actual_fibsize;
+				char buffer[80];
+				char * cp = buffer;
+
+				strcpy(cp, "FIB=");
+				cp += 4;
+				while (len > 0) {
+					if (cp >= &buffer[sizeof(buffer)-4]) {
+						printk (KERN_INFO "%s\n", buffer);
+						strcpy(cp = buffer, "    ");
+						cp += 4;
+					}
+					sprintf (cp, "%02x ", *(srb++));
+					cp += strlen(cp);
+					--len;
+				}
+				if (cp > &buffer[4])
+					printk (KERN_INFO "%s\n", buffer);
+			}
+			printk(KERN_INFO
+			  "fib_send(ScsiPortCommand,,%d,...)\n",
+			  actual_fibsize);
+#		endif
 		status = fib_send(ScsiPortCommand, srbfib, actual_fibsize, FsaNormal, 1, 1, NULL, NULL);
 	}
 
 	if (status != 0){
-		printk(KERN_DEBUG"aacraid: Could not send raw srb fib to hba\n"); 
+		dprintk((KERN_DEBUG"aacraid: Could not send raw srb fib to hba\n")); 
 		rcode = -1;
 		goto cleanup;
 	}
 
 	if( flags & SRB_DataIn ) {
 		for(i = 0 ; i <= sg_indx; i++){
-			if(copy_to_user(sg_user[i],sg_list[i],le32_to_cpu(srbcmd->sg.sg[i].count))){
-				printk(KERN_DEBUG"aacraid: Could not copy sg data to user\n"); 
+			byte_count = le32_to_cpu((dev->dac_support == 1)
+			      ? ((struct sgmap64*)&srbcmd->sg)->sg[i].count
+			      : srbcmd->sg.sg[i].count);
+			if(copy_to_user(sg_user[i],sg_list[i],byte_count)){
+				dprintk((KERN_DEBUG"aacraid: Could not copy sg data to user\n")); 
 				rcode = -EFAULT;
 				goto cleanup;
 
@@ -599,12 +858,13 @@ int aac_send_raw_srb(struct aac_dev* dev
 
 	reply = (struct aac_srb_reply *) fib_data(srbfib);
 	if(copy_to_user(user_reply,reply,sizeof(struct aac_srb_reply))){
-		printk(KERN_DEBUG"aacraid: Could not copy reply to user\n"); 
+		dprintk((KERN_DEBUG"aacraid: Could not copy reply to user\n")); 
 		rcode = -EFAULT;
 		goto cleanup;
 	}
 
 cleanup:
+	kfree(user_srbcmd);
 	for(i=0; i <= sg_indx; i++){
 		kfree(sg_list[i]);
 	}
@@ -621,7 +881,7 @@ struct aac_pci_info {
 };
 
 
-int aac_get_pci_info(struct aac_dev* dev, void __user *arg)
+static int aac_get_pci_info(struct aac_dev* dev, void __user *arg)
 {
         struct aac_pci_info pci_info;
 
@@ -629,29 +889,52 @@ int aac_get_pci_info(struct aac_dev* dev
 	pci_info.slot = PCI_SLOT(dev->pdev->devfn);
 
        if (copy_to_user(arg, &pci_info, sizeof(struct aac_pci_info))) {
-		printk(KERN_DEBUG "aacraid: Could not copy pci info\n");
+               dprintk((KERN_DEBUG "aacraid: Could not copy pci info\n"));
                return -EFAULT;
 	}
         return 0;
- }
+}
  
 
 int aac_do_ioctl(struct aac_dev * dev, int cmd, void __user *arg)
 {
 	int status;
 	
+#if (defined(AAC_DEBUG_INSTRUMENT_IOCTL))
+	if (cmd != FSACTL_GET_NEXT_ADAPTER_FIB)
+		printk("aac_do_ioctl(%p,%x,%p)\n", dev, cmd, arg);
+#endif
 	/*
 	 *	HBA gets first crack
 	 */
 	 
 	status = aac_dev_ioctl(dev, cmd, arg);
-	if(status != -ENOTTY)
+	if(status != -ENOTTY) {
+#if (defined(AAC_DEBUG_INSTRUMENT_IOCTL))
+		printk("aac_do_ioctl returns %d\n", status);
+#endif
 		return status;
+	}
+
+#if (defined(AAC_CSMI))
+	/*
+	 *	HP gets second crack
+	 */
+	 
+	status = aac_csmi_ioctl(dev, cmd, arg);
+	if (status != -ENOTTY) {
+#if (defined(AAC_DEBUG_INSTRUMENT_IOCTL))
+		printk("aac_do_ioctl returns %d\n", status);
+#endif
+		return status;
+	}
 
+#endif
 	switch (cmd) {
 	case FSACTL_MINIPORT_REV_CHECK:
 		status = check_revision(dev, arg);
 		break;
+	case FSACTL_SEND_LARGE_FIB:
 	case FSACTL_SENDFIB:
 		status = ioctl_send_fib(dev, arg);
 		break;
@@ -670,10 +953,19 @@ int aac_do_ioctl(struct aac_dev * dev, i
 	case FSACTL_GET_PCI_INFO:
 		status = aac_get_pci_info(dev,arg);
 		break;
+#if (defined(CODE_STREAM_IDENTIFIER))
+	case FSACTL_GET_VERSION_MATCHING:
+		status = check_code_stream_identifier(dev,arg);
+		break;
+#endif
 	default:
 		status = -ENOTTY;
 	  	break;	
 	}
+#if (defined(AAC_DEBUG_INSTRUMENT_IOCTL))
+	if (cmd != FSACTL_GET_NEXT_ADAPTER_FIB)
+		printk("aac_do_ioctl returns %d\n", status);
+#endif
 	return status;
 }
 
--- linux-2.6.8.1-t043-libata-update/drivers/scsi/aacraid/compat.h	1970-01-01 03:00:00.000000000 +0300
+++ aacraid-drv/drivers/scsi/aacraid/compat.h	2005-05-12 18:45:40.000000000 +0400
@@ -0,0 +1,223 @@
+/*
+ *	Adaptec AAC series RAID controller driver
+ *	(c) Copyright 2001 Red Hat Inc.	<alan@redhat.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+/*
+ * This file is for backwards compatibility with older kernel versions
+ */
+#include <linux/version.h>
+
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,9)) && (!defined(SCSI_HAS_SSLEEP))
+#define ssleep(x) scsi_sleep((x)*HZ)
+#endif
+#ifndef BUG_ON
+#ifndef unlikely
+#ifndef __builtin_expect
+#define __builtin_expect(x, expected_value) (x)
+#endif
+#define unlikely(x) __builtin_expect((x),0)
+#endif
+#define BUG_ON(condition) do { if (unlikely((condition)!=0)) BUG(); } while (0)
+#endif
+#ifndef min
+#define min(a,b) (((a)<(b))?(a):(b))
+#endif
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,4,0))
+ typedef unsigned long dma_addr_t;
+#include <linux/kcomp.h>
+#define PCI_ANY_ID (~0)
+#define SCSI_DATA_UNKNOWN	0
+#define SCSI_DATA_WRITE		1
+#define SCSI_DATA_READ		2
+#define SCSI_DATA_NONE		3
+ /* Sigh ... a *lot* more needs to be done for this Grandpa */
+#endif
+
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
+#include <linux/time.h>
+static inline unsigned long get_seconds(void)
+{
+	struct timeval now;
+	do_gettimeofday(&now);
+	return now.tv_sec;
+}
+#define scsi_host_template SHT
+#define DMA_BIDIRECTIONAL	SCSI_DATA_UNKNOWN
+#define DMA_TO_DEVICE		SCSI_DATA_WRITE
+#define DMA_FROM_DEVICE		SCSI_DATA_READ
+#define DMA_NONE		SCSI_DATA_NONE
+#define iminor(x) MINOR(x->i_rdev)
+#define scsi_host_alloc(t,s) scsi_register(t,s)
+#define scsi_host_put(s) scsi_unregister(s)
+#ifndef pci_set_consistent_dma_mask
+#define pci_set_consistent_dma_mask(d,m) 0
+#endif
+#ifndef scsi_scan_host
+#define scsi_scan_host(s)
+#endif
+#define scsi_add_host(s,d) 0
+#if ((LINUX_VERSION_CODE < KERNEL_VERSION(2,4,20)) && !defined(list_for_each_entry))
+#if (!defined(_LINUX_PREFETCH_H))
+static inline void prefetch(const void *x) {;}
+#endif
+#define list_for_each_entry(pos, head, member)                          \
+        for (pos = list_entry((head)->next, typeof(*pos), member),      \
+                     prefetch(pos->member.next);                        \
+             &pos->member != (head);                                    \
+             pos = list_entry(pos->member.next, typeof(*pos), member),  \
+                     prefetch(pos->member.next))
+#endif
+#if (defined(MODULE))
+# define scsi_remove_host(s) \
+	list_for_each_entry(aac, &aac_devices, entry) { \
+		if (aac != (struct aac_dev *)s->hostdata) \
+			break; \
+	} \
+	if (list_empty(&aac_devices) \
+	 || (aac == (struct aac_dev *)s->hostdata)) scsi_unregister_module(MODULE_SCSI_HA,s->hostt)
+#else
+# define scsi_remove_host(s)
+#endif
+#if (!defined(__devexit_p))
+# if (defined(MODULE))
+#  define __devexit_p(x) x
+# else
+#  define __devexit_p(x) NULL
+# endif
+#endif
+#define __user
+#endif
+#if ((LINUX_VERSION_CODE < KERNEL_VERSION(2,6,6)) && (!defined(SCSI_HAS_SCSI_DEVICE_ONLINE)))
+#define scsi_device_online(d) ((d)->online)
+#endif
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,9))
+#define __iomem
+#endif
+#if ((LINUX_VERSION_CODE < KERNEL_VERSION(2,6,9)) && !defined(HAS_BITWISE_TYPE))
+typedef u64 __le64;
+typedef u32 __le32;
+typedef u16 __le16;
+#endif
+
+#ifndef DMA_64BIT_MASK
+#define DMA_64BIT_MASK ((dma_addr_t)0xffffffffffffffffULL)
+#endif
+#ifndef DMA_32BIT_MASK
+#define DMA_32BIT_MASK ((dma_addr_t)0xffffffffULL)
+#endif
+
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,4,18)) && (LINUX_VERSION_CODE != KERNEL_VERSION(2,4,9)) && (LINUX_VERSION_CODE != KERNEL_VERSION(2,4,13))
+# define dma_handle ptr
+#endif
+
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,4,11))
+#include <linux/blk.h>
+
+static inline unsigned int block_size(kdev_t dev)
+{
+	int retval = BLOCK_SIZE;
+	int major = MAJOR(dev);
+
+	if (blksize_size[major]) {
+		int minor = MINOR(dev);
+		if (blksize_size[major][minor])
+			retval = blksize_size[major][minor];
+	}
+	return retval;
+}
+#endif
+
+#if (LINUX_VERSION_CODE <= KERNEL_VERSION(2,4,7))
+
+#ifndef COMPLETION_INITIALIZER
+
+#include <linux/wait.h>
+
+struct completion {
+	unsigned int done;
+	wait_queue_head_t wait;
+};
+#define COMPLETION_INITIALIZER(work) \
+	{ 0, __WAIT_QUEUE_HEAD_INITIALIZER((work).wait) }
+
+#define DECLARE_COMPLETION(work) \
+	struct completion work = COMPLETION_INITIALIZER(work)
+#define INIT_COMPLETION(x)	((x).done = 0)
+
+static inline void init_completion(struct completion *x)
+{
+	x->done = 0;
+	init_waitqueue_head(&x->wait);
+}
+#endif
+
+#ifndef complete_and_exit
+static inline void complete_and_exit(struct completion *comp, long code)
+{
+	/*
+	if (comp)
+		complete(comp);
+
+	do_exit(code);
+	*/
+}
+#endif
+
+#endif
+
+#if (LINUX_VERSION_CODE <= KERNEL_VERSION(2,4,2))
+
+static inline void scsi_set_pci_device(struct Scsi_Host *SHpnt,
+                                       struct pci_dev *pdev)
+{
+//	SHpnt->pci_dev = pdev;
+}
+
+static inline void wait_for_completion(struct completion *x)
+{
+	spin_lock_irq(&x->wait.lock);
+	if (!x->done) {
+		DECLARE_WAITQUEUE(wait, current);
+
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0))
+		wait.flags |= WQ_FLAG_EXCLUSIVE;
+#endif
+		__add_wait_queue_tail(&x->wait, &wait);
+		do {
+			__set_current_state(TASK_UNINTERRUPTIBLE);
+			spin_unlock_irq(&x->wait.lock);
+			schedule();
+			spin_lock_irq(&x->wait.lock);
+		} while (!x->done);
+		__remove_wait_queue(&x->wait, &wait);
+	}
+	x->done--;
+	spin_unlock_irq(&x->wait.lock);
+}
+
+static inline int pci_set_dma_mask(struct pci_dev *dev, dma_addr_t mask)
+{
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0))
+    dev->dma_mask = mask;
+#endif
+
+    return 0;
+}
+
+#endif
+    
--- linux-2.6.8.1-t043-libata-update/drivers/scsi/aacraid/commsup.c	2005-09-26 13:33:12.000000000 +0400
+++ aacraid-drv/drivers/scsi/aacraid/commsup.c	2005-04-27 16:44:54.000000000 +0400
@@ -25,7 +25,7 @@
  *  commsup.c
  *
  * Abstract: Contain all routines that are required for FSA host/adapter
- *    commuication.
+ *    communication.
  *
  */
 
@@ -36,8 +36,20 @@
 #include <linux/pci.h>
 #include <linux/spinlock.h>
 #include <linux/slab.h>
+#include <linux/delay.h>
 #include <linux/completion.h>
 #include <linux/blkdev.h>
+#include <linux/version.h>	/* Needed for the following */
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
+#include <asm/uaccess.h>
+#include "scsi.h"
+#include "hosts.h"
+#else
+#include <scsi/scsi.h>
+#include <scsi/scsi_host.h>
+#include <scsi/scsi_device.h>
+#include <scsi/scsi_driver.h>
+#endif
 #include <asm/semaphore.h>
 
 #include "aacraid.h"
@@ -52,7 +64,31 @@
  
 static int fib_map_alloc(struct aac_dev *dev)
 {
-	if((dev->hw_fib_va = pci_alloc_consistent(dev->pdev, sizeof(struct hw_fib) * AAC_NUM_FIB, &dev->hw_fib_pa))==NULL)
+	dprintk((KERN_INFO
+	  "allocate hardware fibs pci_alloc_consistent(%p, %d * (%d + %d), %p)\n",
+	  dev->pdev, dev->max_fib_size, dev->scsi_host_ptr->can_queue,
+	  AAC_NUM_MGT_FIB, &dev->hw_fib_pa));
+#if 0 && (defined(CONFIG_X86) || defined(CONFIG_X86_64))
+	/* Bug in pci_alloc_consistent dealing with respecting dma map */
+	dev->hw_fib_va = kmalloc(
+	  dev->max_fib_size * (dev->scsi_host_ptr->can_queue + AAC_NUM_MGT_FIB),
+	  GFP_ATOMIC|GFP_KERNEL);
+	if (dev->hw_fib_va) {
+		dev->hw_fib_pa = pci_map_single(dev->pdev, dev->hw_fib_va,
+		  dev->max_fib_size * (dev->scsi_host_ptr->can_queue + AAC_NUM_MGT_FIB),
+		  DMA_BIDIRECTIONAL);
+		if (dev->hw_fib_pa > (0x80000000UL
+		  - (dev->max_fib_size
+		   * (dev->scsi_host_ptr->can_queue + AAC_NUM_MGT_FIB)))) {
+			kfree(dev->hw_fib_va);
+			dev->hw_fib_va = NULL;
+		}
+	}
+	if (dev->hw_fib_va == NULL)
+#endif
+	if((dev->hw_fib_va = pci_alloc_consistent(dev->pdev, dev->max_fib_size
+	  * (dev->scsi_host_ptr->can_queue + AAC_NUM_MGT_FIB),
+	  &dev->hw_fib_pa))==NULL)
 		return -ENOMEM;
 	return 0;
 }
@@ -67,7 +103,7 @@ static int fib_map_alloc(struct aac_dev 
 
 void fib_map_free(struct aac_dev *dev)
 {
-	pci_free_consistent(dev->pdev, sizeof(struct hw_fib) * AAC_NUM_FIB, dev->hw_fib_va, dev->hw_fib_pa);
+	pci_free_consistent(dev->pdev, dev->max_fib_size * (dev->scsi_host_ptr->can_queue + AAC_NUM_MGT_FIB), dev->hw_fib_va, dev->hw_fib_pa);
 }
 
 /**
@@ -84,17 +120,22 @@ int fib_setup(struct aac_dev * dev)
 	struct hw_fib *hw_fib_va;
 	dma_addr_t hw_fib_pa;
 	int i;
-	
-	if(fib_map_alloc(dev)<0)
+
+	while (((i = fib_map_alloc(dev)) == -ENOMEM)
+	 && (dev->scsi_host_ptr->can_queue > (64 - AAC_NUM_MGT_FIB))) {
+		dev->init->MaxIoCommands = cpu_to_le32((dev->scsi_host_ptr->can_queue + AAC_NUM_MGT_FIB) >> 1);
+		dev->scsi_host_ptr->can_queue = le32_to_cpu(dev->init->MaxIoCommands) - AAC_NUM_MGT_FIB;
+	}
+	if (i<0)
 		return -ENOMEM;
 		
 	hw_fib_va = dev->hw_fib_va;
 	hw_fib_pa = dev->hw_fib_pa;
-	memset(hw_fib_va, 0, sizeof(struct hw_fib) * AAC_NUM_FIB);
+	memset(hw_fib_va, 0, dev->max_fib_size * (dev->scsi_host_ptr->can_queue + AAC_NUM_MGT_FIB));
 	/*
 	 *	Initialise the fibs
 	 */
-	for (i = 0, fibptr = &dev->fibs[i]; i < AAC_NUM_FIB; i++, fibptr++) 
+	for (i = 0, fibptr = &dev->fibs[i]; i < (dev->scsi_host_ptr->can_queue + AAC_NUM_MGT_FIB); i++, fibptr++) 
 	{
 		fibptr->dev = dev;
 		fibptr->hw_fib = hw_fib_va;
@@ -103,15 +144,15 @@ int fib_setup(struct aac_dev * dev)
 		init_MUTEX_LOCKED(&fibptr->event_wait);
 		spin_lock_init(&fibptr->event_lock);
 		hw_fib_va->header.XferState = cpu_to_le32(0xffffffff);
-		hw_fib_va->header.SenderSize = cpu_to_le16(sizeof(struct hw_fib));
+		hw_fib_va->header.SenderSize = cpu_to_le16(dev->max_fib_size);
 		fibptr->hw_fib_pa = hw_fib_pa;
-		hw_fib_va = (struct hw_fib *)((unsigned char *)hw_fib_va + sizeof(struct hw_fib));
-		hw_fib_pa = hw_fib_pa + sizeof(struct hw_fib); 
+		hw_fib_va = (struct hw_fib *)((unsigned char *)hw_fib_va + dev->max_fib_size);
+		hw_fib_pa = hw_fib_pa + dev->max_fib_size;
 	}
 	/*
 	 *	Add the fib chain to the free list
 	 */
-	dev->fibs[AAC_NUM_FIB-1].next = NULL;
+	dev->fibs[dev->scsi_host_ptr->can_queue + AAC_NUM_MGT_FIB - 1].next = NULL;
 	/*
 	 *	Enable this to debug out of queue space
 	 */
@@ -124,7 +165,7 @@ int fib_setup(struct aac_dev * dev)
  *	@dev: Adapter to allocate the fib for
  *
  *	Allocate a fib from the adapter fib pool. If the pool is empty we
- *	wait for fibs to become free.
+ *	return NULL.
  */
  
 struct fib * fib_alloc(struct aac_dev *dev)
@@ -133,10 +174,10 @@ struct fib * fib_alloc(struct aac_dev *d
 	unsigned long flags;
 	spin_lock_irqsave(&dev->fib_lock, flags);
 	fibptr = dev->free_fib;	
-	/* Cannot sleep here or you get hangs. Instead we did the
-	   maths at compile time. */
-	if(!fibptr)
-		BUG();
+	if(!fibptr){
+		spin_unlock_irqrestore(&dev->fib_lock, flags);
+		return fibptr;
+	}
 	dev->free_fib = fibptr->next;
 	spin_unlock_irqrestore(&dev->fib_lock, flags);
 	/*
@@ -148,9 +189,19 @@ struct fib * fib_alloc(struct aac_dev *d
 	 *	Null out fields that depend on being zero at the start of
 	 *	each I/O
 	 */
-	fibptr->hw_fib->header.XferState = cpu_to_le32(0);
+	fibptr->hw_fib->header.XferState = 0;
 	fibptr->callback = NULL;
 	fibptr->callback_data = NULL;
+#if (defined(AAC_DEBUG_INSTRUMENT_TIMING))
+	{
+		struct timeval now;
+		do_gettimeofday(&now);
+		fibptr->DriverTimeStartS = now.tv_sec;
+		fibptr->DriverTimeStartuS = now.tv_usec;
+	}
+	fibptr->DriverTimeDoneS = 0;
+	fibptr->DriverTimeDoneuS = 0;
+#endif
 
 	return fibptr;
 }
@@ -167,6 +218,18 @@ void fib_free(struct fib * fibptr)
 {
 	unsigned long flags;
 
+#if (defined(AAC_DEBUG_INSTRUMENT_TIMING))
+	struct timeval now;
+	do_gettimeofday(&now);
+	fibptr->DriverTimeDoneS = now.tv_sec;
+	fibptr->DriverTimeDoneuS = now.tv_usec;
+	flags = (fibptr->DriverTimeDoneS - fibptr->DriverTimeStartS) * 1000000L
+	      + fibptr->DriverTimeDoneuS - fibptr->DriverTimeStartuS;
+	if (flags > aac_config.peak_duration) {
+		aac_config.peak_duration = flags;
+		printk(KERN_INFO "peak_duration %lduseconds\n", flags);
+	}
+#endif
 	spin_lock_irqsave(&fibptr->dev->fib_lock, flags);
 	if (fibptr->flags & FIB_CONTEXT_FLAG_TIMED_OUT) {
 		aac_config.fib_timeouts++;
@@ -175,7 +238,8 @@ void fib_free(struct fib * fibptr)
 	} else {
 		if (fibptr->hw_fib->header.XferState != 0) {
 			printk(KERN_WARNING "fib_free, XferState != 0, fibptr = 0x%p, XferState = 0x%x\n", 
-				 (void*)fibptr, fibptr->hw_fib->header.XferState);
+				 (void*)fibptr, 
+				 le32_to_cpu(fibptr->hw_fib->header.XferState));
 		}
 		fibptr->next = fibptr->dev->free_fib;
 		fibptr->dev->free_fib = fibptr;
@@ -195,11 +259,11 @@ void fib_init(struct fib *fibptr)
 	struct hw_fib *hw_fib = fibptr->hw_fib;
 
 	hw_fib->header.StructType = FIB_MAGIC;
-	hw_fib->header.Size = cpu_to_le16(sizeof(struct hw_fib));
-        hw_fib->header.XferState = cpu_to_le32(HostOwned | FibInitialized | FibEmpty | FastResponseCapable);
-	hw_fib->header.SenderFibAddress = cpu_to_le32(fibptr->hw_fib_pa);
+	hw_fib->header.Size = cpu_to_le16(fibptr->dev->max_fib_size);
+	hw_fib->header.XferState = cpu_to_le32(HostOwned | FibInitialized | FibEmpty | FastResponseCapable);
+	hw_fib->header.SenderFibAddress = 0; /* Filled in later if needed */
 	hw_fib->header.ReceiverFibAddress = cpu_to_le32(fibptr->hw_fib_pa);
-	hw_fib->header.SenderSize = cpu_to_le16(sizeof(struct hw_fib));
+	hw_fib->header.SenderSize = cpu_to_le16(fibptr->dev->max_fib_size);
 }
 
 /**
@@ -210,12 +274,12 @@ void fib_init(struct fib *fibptr)
  *	caller.
  */
  
-void fib_dealloc(struct fib * fibptr)
+static void fib_dealloc(struct fib * fibptr)
 {
 	struct hw_fib *hw_fib = fibptr->hw_fib;
 	if(hw_fib->header.StructType != FIB_MAGIC) 
 		BUG();
-	hw_fib->header.XferState = cpu_to_le32(0);        
+	hw_fib->header.XferState = 0;        
 }
 
 /*
@@ -241,6 +305,7 @@ void fib_dealloc(struct fib * fibptr)
 static int aac_get_entry (struct aac_dev * dev, u32 qid, struct aac_entry **entry, u32 * index, unsigned long *nonotify)
 {
 	struct aac_queue * q;
+	unsigned long idx;
 
 	/*
 	 *	All of the queues wrap when they reach the end, so we check
@@ -250,10 +315,23 @@ static int aac_get_entry (struct aac_dev
 	 */
 
 	q = &dev->queues->queue[qid];
-	
-	*index = le32_to_cpu(*(q->headers.producer));
-	if ((*index - 2) == le32_to_cpu(*(q->headers.consumer)))
+
+	idx = *index = le32_to_cpu(*(q->headers.producer));
+	/* Interrupt Moderation, only interrupt for first two entries */
+	if (idx != le32_to_cpu(*(q->headers.consumer))) {
+		if (--idx == 0) {
+			if (qid == AdapHighCmdQueue)
+				idx = ADAP_HIGH_CMD_ENTRIES;
+			else if (qid == AdapNormCmdQueue)
+				idx = ADAP_NORM_CMD_ENTRIES;
+			else if (qid == AdapHighRespQueue) 
+	        		idx = ADAP_HIGH_RESP_ENTRIES;
+			else if (qid == AdapNormRespQueue) 
+				idx = ADAP_NORM_RESP_ENTRIES;
+		}
+		if (idx != le32_to_cpu(*(q->headers.consumer)))
 			*nonotify = 1; 
+	}
 
 	if (qid == AdapHighCmdQueue) {
 	        if (*index >= ADAP_HIGH_CMD_ENTRIES)
@@ -278,7 +356,7 @@ static int aac_get_entry (struct aac_dev
 	}
 
         if ((*index + 1) == le32_to_cpu(*(q->headers.consumer))) { /* Queue is full */
-		printk(KERN_WARNING "Queue %d full, %d outstanding.\n",
+		printk(KERN_WARNING "Queue %d full, %u outstanding.\n",
 				qid, q->numpending);
 		return 0;
 	} else {
@@ -307,10 +385,7 @@ static int aac_queue_get(struct aac_dev 
 {
 	struct aac_entry * entry = NULL;
 	int map = 0;
-	struct aac_queue * q = &dev->queues->queue[qid];
 		
-	spin_lock_irqsave(q->lock, q->SavedIrql);
-	    
 	if (qid == AdapHighCmdQueue || qid == AdapNormCmdQueue) 
 	{
 		/*  if no entries wait for some if caller wants to */
@@ -344,43 +419,7 @@ static int aac_queue_get(struct aac_dev 
 	 *	in the queue entry.
 	 */
 	if (map)
-		entry->addr = fibptr->hw_fib_pa;
-	return 0;
-}
-
-
-/**
- *	aac_insert_entry	-	insert a queue entry
- *	@dev: Adapter
- *	@index: Index of entry to insert
- *	@qid: Queue number
- *	@nonotify: Suppress adapter notification
- *
- *	Gets the next free QE off the requested priorty adapter command
- *	queue and associates the Fib with the QE. The QE represented by
- *	index is ready to insert on the queue when this routine returns
- *	success.
- */
- 
-static int aac_insert_entry(struct aac_dev * dev, u32 index, u32 qid, unsigned long nonotify) 
-{
-	struct aac_queue * q = &dev->queues->queue[qid];
-
-	if(q == NULL)
-		BUG();
-	*(q->headers.producer) = cpu_to_le32(index + 1);
-	spin_unlock_irqrestore(q->lock, q->SavedIrql);
-
-	if (qid == AdapHighCmdQueue ||
-	    qid == AdapNormCmdQueue ||
-	    qid == AdapHighRespQueue ||
-	    qid == AdapNormRespQueue)
-	{
-		if (!nonotify)
-			aac_adapter_notify(dev, qid);
-	}
-	else
-		printk("Suprise insert!\n");
+		entry->addr = cpu_to_le32(fibptr->hw_fib_pa);
 	return 0;
 }
 
@@ -408,23 +447,28 @@ static int aac_insert_entry(struct aac_d
  *	an event to wait on must be supplied. This event will be set when a
  *	response FIB is received from the adapter.
  */
- 
-int fib_send(u16 command, struct fib * fibptr, unsigned long size,  int priority, int wait, int reply, fib_callback callback, void * callback_data)
+#if (defined(FSACTL_REGISTER_FIB_SEND))
+fib_send_t fib_send = aac_fib_send;
+#endif
+
+int aac_fib_send(u16 command, struct fib * fibptr, unsigned long size,
+		int priority, int wait, int reply, fib_callback callback,
+		void * callback_data)
 {
-	u32 index;
 	u32 qid;
 	struct aac_dev * dev = fibptr->dev;
-	unsigned long nointr = 0;
 	struct hw_fib * hw_fib = fibptr->hw_fib;
 	struct aac_queue * q;
 	unsigned long flags = 0;
-	if (!(le32_to_cpu(hw_fib->header.XferState) & HostOwned))
+	unsigned long qflags;
+
+	if (!(hw_fib->header.XferState & cpu_to_le32(HostOwned)))
 		return -EBUSY;
 	/*
 	 *	There are 5 cases with the wait and reponse requested flags. 
 	 *	The only invalid cases are if the caller requests to wait and
 	 *	does not request a response and if the caller does not want a
-	 *	response and the Fibis not allocated from pool. If a response
+	 *	response and the Fib is not allocated from pool. If a response
 	 *	is not requesed the Fib will just be deallocaed by the DPC
 	 *	routine when the response comes back from the adapter. No
 	 *	further processing will be done besides deleting the Fib. We 
@@ -447,7 +491,7 @@ int fib_send(u16 command, struct fib * f
 	 *	Map the fib into 32bits by using the fib number
 	 */
 
-	hw_fib->header.SenderFibAddress = cpu_to_le32(((u32)(fibptr-dev->fibs)) << 1);
+	hw_fib->header.SenderFibAddress = cpu_to_le32(((u32)(fibptr - dev->fibs)) << 2);
 	hw_fib->header.SenderData = (u32)(fibptr - dev->fibs);
 	/*
 	 *	Set FIB state to indicate where it came from and if we want a
@@ -477,19 +521,7 @@ int fib_send(u16 command, struct fib * f
 		hw_fib->header.XferState |= cpu_to_le32(NormalPriority);
 		qid = AdapNormCmdQueue;
 	}
-	q = &dev->queues->queue[qid];
 
-	if(wait)
-		spin_lock_irqsave(&fibptr->event_lock, flags);
-	if(aac_queue_get( dev, &index, qid, hw_fib, 1, fibptr, &nointr)<0)
-		return -EWOULDBLOCK;
-	dprintk((KERN_DEBUG "fib_send: inserting a queue entry at index %d.\n",index));
-	dprintk((KERN_DEBUG "Fib contents:.\n"));
-	dprintk((KERN_DEBUG "  Command =               %d.\n", hw_fib->header.Command));
-	dprintk((KERN_DEBUG "  XferState  =            %x.\n", hw_fib->header.XferState));
-	dprintk((KERN_DEBUG "  hw_fib va being sent=%p\n",fibptr->hw_fib));
-	dprintk((KERN_DEBUG "  hw_fib pa being sent=%lx\n",(ulong)fibptr->hw_fib_pa));
-	dprintk((KERN_DEBUG "  fib being sent=%p\n",fibptr));
 	/*
 	 *	Fill in the Callback and CallbackContext if we are not
 	 *	going to wait.
@@ -498,22 +530,114 @@ int fib_send(u16 command, struct fib * f
 		fibptr->callback = callback;
 		fibptr->callback_data = callback_data;
 	}
-	FIB_COUNTER_INCREMENT(aac_config.FibsSent);
-	list_add_tail(&fibptr->queue, &q->pendingq);
-	q->numpending++;
 
 	fibptr->done = 0;
 	fibptr->flags = 0;
 
-	if(aac_insert_entry(dev, index, qid, (nointr & aac_config.irq_mod)) < 0)
-		return -EWOULDBLOCK;
+#	if (defined(AAC_DEBUG_INSTRUMENT_FIB))
+		printk(KERN_INFO "Fib content %p[%d] P=%llx:\n",
+		  hw_fib, le16_to_cpu(hw_fib->header.Size), fibptr->hw_fib_pa);
+		{
+			int size = le16_to_cpu(hw_fib->header.Size)
+					/ sizeof(u32);
+			char buffer[80];
+			u32 * up = (u32 *)hw_fib;
+
+			while (size > 0) {
+				sprintf (buffer,
+				  "  %08x %08x %08x %08x %08x %08x %08x %08x\n",
+				  up[0], up[1], up[2], up[3], up[4], up[5],
+				  up[6], up[7]);
+				up += 8;
+				size -= 8;
+				if (size < 0) {
+					buffer[73+(size*9)] = '\n';
+					buffer[74+(size*9)] = '\0';
+				}
+				printk(KERN_INFO "%s", buffer);
+			}
+		}
+#	endif
+
+	FIB_COUNTER_INCREMENT(aac_config.FibsSent);
+
+	dprintk((KERN_DEBUG "Fib contents:.\n"));
+	dprintk((KERN_DEBUG "  Command =               %d.\n", le32_to_cpu(hw_fib->header.Command)));
+	dprintk((KERN_DEBUG "  SubCommand =            %d.\n", le32_to_cpu(((struct aac_query_mount *)fib_data(fibptr))->command)));
+	dprintk((KERN_DEBUG "  XferState  =            %x.\n", le32_to_cpu(hw_fib->header.XferState)));
+	dprintk((KERN_DEBUG "  hw_fib va being sent=%p\n",fibptr->hw_fib));
+	dprintk((KERN_DEBUG "  hw_fib pa being sent=%lx\n",(ulong)fibptr->hw_fib_pa));
+	dprintk((KERN_DEBUG "  fib being sent=%p\n",fibptr));
+
+	q = &dev->queues->queue[qid];
+
+	if(wait)
+		spin_lock_irqsave(&fibptr->event_lock, flags);
+	spin_lock_irqsave(q->lock, qflags);
+	if (dev->new_comm_interface) {
+		unsigned long count = 10000000L; /* 50 seconds */
+		list_add_tail(&fibptr->queue, &q->pendingq);
+		q->numpending++;
+		spin_unlock_irqrestore(q->lock, qflags);
+		while (aac_adapter_send(fibptr) != 0) {
+			if (--count == 0) {
+				if (wait)
+					spin_unlock_irqrestore(&fibptr->event_lock, flags);
+				spin_lock_irqsave(q->lock, qflags);
+				q->numpending--;
+				list_del(&fibptr->queue);
+				spin_unlock_irqrestore(q->lock, qflags);
+				return -ETIMEDOUT;
+			}
+			udelay(5);
+		}
+	} else {
+		u32 index;
+		unsigned long nointr = 0;
+		aac_queue_get( dev, &index, qid, hw_fib, 1, fibptr, &nointr);
+
+		list_add_tail(&fibptr->queue, &q->pendingq);
+		q->numpending++;
+		*(q->headers.producer) = cpu_to_le32(index + 1);
+		spin_unlock_irqrestore(q->lock, qflags);
+		dprintk((KERN_DEBUG "fib_send: inserting a queue entry at index %d.\n",index));
+		if (!(nointr & aac_config.irq_mod))
+			aac_adapter_notify(dev, qid);
+	}
+
 	/*
 	 *	If the caller wanted us to wait for response wait now. 
 	 */
     
 	if (wait) {
 		spin_unlock_irqrestore(&fibptr->event_lock, flags);
-		down(&fibptr->event_wait);
+		/* Only set for first known interruptable command */
+		if (wait < 0) {
+			/*
+			 * *VERY* Dangerous to time out a command, the
+			 * assumption is made that we have no hope of
+			 * functioning because an interrupt routing or other
+			 * hardware failure has occurred.
+			 */
+			unsigned long count = 36000000L; /* 3 minutes */
+			while (down_trylock(&fibptr->event_wait)) {
+				if (--count == 0) {
+					spin_lock_irqsave(q->lock, qflags);
+					q->numpending--;
+					list_del(&fibptr->queue);
+					spin_unlock_irqrestore(q->lock, qflags);
+					if (wait == -1) {
+	        				printk(KERN_ERR "aacraid: fib_send: first asynchronous command timed out.\n"
+						  "Usually a result of a PCI interrupt routing problem;\n"
+						  "update mother board BIOS or consider utilizing one of\n"
+						  "the SAFE mode kernel options (acpi, apic etc)\n");
+					}
+					return -ETIMEDOUT;
+				}
+				udelay(5);
+			}
+		} else
+			down(&fibptr->event_wait);
 		if(fibptr->done == 0)
 			BUG();
 			
@@ -566,12 +690,6 @@ int aac_consumer_get(struct aac_dev * de
 	return(status);
 }
 
-int aac_consumer_avail(struct aac_dev *dev, struct aac_queue * q)
-{
-	return (le32_to_cpu(*q->headers.producer) != le32_to_cpu(*q->headers.consumer));
-}
-
-
 /**
  *	aac_consumer_free	-	free consumer entry
  *	@dev: Adapter
@@ -631,13 +749,22 @@ int fib_adapter_complete(struct fib * fi
 {
 	struct hw_fib * hw_fib = fibptr->hw_fib;
 	struct aac_dev * dev = fibptr->dev;
+	struct aac_queue * q;
 	unsigned long nointr = 0;
-	if (le32_to_cpu(hw_fib->header.XferState) == 0)
+	unsigned long qflags;
+	u32 qid;
+
+	if (hw_fib->header.XferState == 0) {
+		if (dev->new_comm_interface)
+			kfree (hw_fib);
         	return 0;
+	}
 	/*
 	 *	If we plan to do anything check the structure type first.
 	 */ 
 	if ( hw_fib->header.StructType != FIB_MAGIC ) {
+		if (dev->new_comm_interface)
+			kfree (hw_fib);
         	return -EINVAL;
 	}
 	/*
@@ -648,37 +775,31 @@ int fib_adapter_complete(struct fib * fi
 	 *	send the completed cdb to the adapter.
 	 */
 	if (hw_fib->header.XferState & cpu_to_le32(SentFromAdapter)) {
-	        hw_fib->header.XferState |= cpu_to_le32(HostProcessed);
-	        if (hw_fib->header.XferState & cpu_to_le32(HighPriority)) {
-        		u32 index;
-       			if (size) 
-			{
-				size += sizeof(struct aac_fibhdr);
-				if (size > le16_to_cpu(hw_fib->header.SenderSize))
-					return -EMSGSIZE;
-				hw_fib->header.Size = cpu_to_le16(size);
-			}
-			if(aac_queue_get(dev, &index, AdapHighRespQueue, hw_fib, 1, NULL, &nointr) < 0) {
-				return -EWOULDBLOCK;
-			}
-			if (aac_insert_entry(dev, index, AdapHighRespQueue,  (nointr & (int)aac_config.irq_mod)) != 0) {
-			}
-		}
-		else if (hw_fib->header.XferState & NormalPriority) 
-		{
-			u32 index;
-
+		if (dev->new_comm_interface) {
+			kfree (hw_fib);
+		} else {
+	       		u32 index;
+		        hw_fib->header.XferState |= cpu_to_le32(HostProcessed);
+		        if (hw_fib->header.XferState & cpu_to_le32(HighPriority))
+				qid = AdapHighRespQueue;
+			else if (hw_fib->header.XferState &
+					cpu_to_le32(NormalPriority))
+				qid = AdapNormRespQueue;
+			else
+				return 0;
 			if (size) {
 				size += sizeof(struct aac_fibhdr);
 				if (size > le16_to_cpu(hw_fib->header.SenderSize)) 
 					return -EMSGSIZE;
 				hw_fib->header.Size = cpu_to_le16(size);
 			}
-			if (aac_queue_get(dev, &index, AdapNormRespQueue, hw_fib, 1, NULL, &nointr) < 0) 
-				return -EWOULDBLOCK;
-			if (aac_insert_entry(dev, index, AdapNormRespQueue, (nointr & (int)aac_config.irq_mod)) != 0) 
-			{
-			}
+			q = &dev->queues->queue[qid];
+			spin_lock_irqsave(q->lock, qflags);
+			aac_queue_get(dev, &index, qid, hw_fib, 1, NULL, &nointr);
+			*(q->headers.producer) = cpu_to_le32(index + 1);
+			spin_unlock_irqrestore(q->lock, qflags);
+			if (!(nointr & (int)aac_config.irq_mod))
+				aac_adapter_notify(dev, qid);
 		}
 	}
 	else 
@@ -704,7 +825,7 @@ int fib_complete(struct fib * fibptr)
 	 *	Check for a fib which has already been completed
 	 */
 
-	if (hw_fib->header.XferState == cpu_to_le32(0))
+	if (hw_fib->header.XferState == 0)
         	return 0;
 	/*
 	 *	If we plan to do anything check the structure type first.
@@ -749,22 +870,27 @@ int fib_complete(struct fib * fibptr)
 
 void aac_printf(struct aac_dev *dev, u32 val)
 {
-	int length = val & 0xffff;
-	int level = (val >> 16) & 0xffff;
 	char *cp = dev->printfbuf;
-	
-	/*
-	 *	The size of the printfbuf is set in port.c
-	 *	There is no variable or define for it
-	 */
-	if (length > 255)
-		length = 255;
-	if (cp[length] != 0)
-		cp[length] = 0;
-	if (level == LOG_HIGH_ERROR)
-		printk(KERN_WARNING "aacraid:%s", cp);
-	else
-		printk(KERN_INFO "aacraid:%s", cp);
+#if (!defined(AAC_PRINTF_ENABLED))
+	if (dev->printf_enabled)
+#endif
+	{
+		int length = val & 0xffff;
+		int level = (val >> 16) & 0xffff;
+		
+		/*
+		 *	The size of the printfbuf is set in port.c
+		 *	There is no variable or define for it
+		 */
+		if (length > 255)
+			length = 255;
+		if (cp[length] != 0)
+			cp[length] = 0;
+		if (level == LOG_AAC_HIGH_ERROR)
+			printk(KERN_WARNING "aacraid:%s", cp);
+		else
+			printk(KERN_INFO "aacraid:%s", cp);
+	}
 	memset(cp, 0,  256);
 }
 
@@ -781,13 +907,395 @@ void aac_printf(struct aac_dev *dev, u32
 static void aac_handle_aif(struct aac_dev * dev, struct fib * fibptr)
 {
 	struct hw_fib * hw_fib = fibptr->hw_fib;
+	struct aac_aifcmd * aifcmd = (struct aac_aifcmd *)hw_fib->data;
+	int busy;
+	u32 container;
+	struct scsi_device *device;
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
+	struct scsi_driver * drv;
+#endif
+	enum {
+		NOTHING,
+		DELETE,
+		ADD,
+		CHANGE
+	} DeviceConfigNeeded;
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
+	extern struct proc_dir_entry * proc_scsi;
+#endif
+
+	/* Sniff for container changes */
+	dprintk ((KERN_INFO "aac_handle_aif: Aif command=%x type=%x\n",
+	  le32_to_cpu(aifcmd->command), le32_to_cpu(*(u32 *)aifcmd->data)));
+#if (defined(AAC_DEBUG_INSTRUMENT_AIF))
+	printk ("aac_handle_aif: Aif command=%x type=%x\n",
+	  le32_to_cpu(aifcmd->command), le32_to_cpu(*(u32 *)aifcmd->data));
+#endif
+
+	if (!dev)
+		return;
+	container = (u32)-1;
+
+	/*
+	 *	We have set this up to try and minimize the number of
+	 * re-configures that take place. As a result of this when
+	 * certain AIF's come in we will set a flag waiting for another
+	 * type of AIF before setting the re-config flag.
+	 */
+	switch (le32_to_cpu(aifcmd->command)) {
+	case AifCmdDriverNotify:
+		switch (le32_to_cpu(((u32 *)aifcmd->data)[0])) {
+		/*
+		 *	Morph or Expand complete
+		 */
+		case AifDenMorphComplete:
+		case AifDenVolumeExtendComplete:
+			container = le32_to_cpu(((u32 *)aifcmd->data)[1]);
+			if (container >= dev->maximum_num_containers)
+				break;
+			dprintk ((KERN_INFO "container=%d(%d,%d,%d,%d)\n",
+			  container,
+			  (dev && dev->scsi_host_ptr)
+			    ? dev->scsi_host_ptr->host_no
+			    : -1,
+			  CONTAINER_TO_CHANNEL(container),
+			  CONTAINER_TO_ID(container),
+			  CONTAINER_TO_LUN(container)));
+
+			/*
+			 *	Find the Scsi_Device associated with the SCSI
+			 * address. Make sure we have the right array, and if
+			 * so set the flag to initiate a new re-config once we
+			 * see an AifEnConfigChange AIF come through.
+			 */
+
+			if ((dev != (struct aac_dev *)NULL)
+			 && (dev->scsi_host_ptr != (struct Scsi_Host *)NULL)) {
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0))
+				shost_for_each_device(device, dev->scsi_host_ptr)
+#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
+				list_for_each_entry(device,
+					&dev->scsi_host_ptr->my_devices, siblings)
+#else
+				for (device = dev->scsi_host_ptr->host_queue;
+				  device != (struct scsi_device *)NULL;
+				  device = device->next)
+#endif
+				{
+					if ((device->channel == CONTAINER_TO_CHANNEL(container))
+					 && (device->id == CONTAINER_TO_ID(container))
+					 && (device->lun == CONTAINER_TO_LUN(container))) {
+
+						dev->fsa_dev[container].ConfigNeeded = CHANGE;
+						dev->fsa_dev[container].ConfigWaitingOn = AifEnConfigChange;
+						break;
+					}
+				}
+			}
+		}
+
+		/*
+		 *	If we are waiting on something and this happens to be
+		 * that thing then set the re-configure flag.
+		 */
+		if (container != (u32)-1) {
+			if (container >= dev->maximum_num_containers)
+				break;
+			if (dev->fsa_dev[container].ConfigWaitingOn == le32_to_cpu(*(u32 *)aifcmd->data))
+				dev->fsa_dev[container].ConfigWaitingOn = 0;
+		} else for (container = 0; container < dev->maximum_num_containers; ++container) {
+			if (dev->fsa_dev[container].ConfigWaitingOn == le32_to_cpu(*(u32 *)aifcmd->data))
+				dev->fsa_dev[container].ConfigWaitingOn = 0;
+		}
+		break;
+
+	case AifCmdEventNotify:
+		switch (le32_to_cpu(((u32 *)aifcmd->data)[0])) {
+		/*
+		 *	Add an Array.
+		 */
+		case AifEnAddContainer:
+			container = le32_to_cpu(((u32 *)aifcmd->data)[1]);
+			if (container >= dev->maximum_num_containers)
+				break;
+			dev->fsa_dev[container].ConfigNeeded = ADD;
+			dev->fsa_dev[container].ConfigWaitingOn = AifEnConfigChange;
+			break;
+
+		/*
+		 *	Delete an Array.
+		 */
+		case AifEnDeleteContainer:
+			container = le32_to_cpu(((u32 *)aifcmd->data)[1]);
+			if (container >= dev->maximum_num_containers)
+				break;
+			dev->fsa_dev[container].ConfigNeeded = DELETE;
+			dev->fsa_dev[container].ConfigWaitingOn = AifEnConfigChange;
+			break;
+
+		/*
+		 *	Container change detected. If we currently are not
+		 * waiting on something else, setup to wait on a Config Change.
+		 */
+		case AifEnContainerChange:
+			container = le32_to_cpu(((u32 *)aifcmd->data)[1]);
+			if (container >= dev->maximum_num_containers)
+				break;
+			if (dev->fsa_dev[container].ConfigWaitingOn) {
+				break;
+			}
+			dev->fsa_dev[container].ConfigNeeded = CHANGE;
+			dev->fsa_dev[container].ConfigWaitingOn = AifEnConfigChange;
+			break;
+
+		case AifEnConfigChange:
+			break;
+
+		}
+
+		/*
+		 *	If we are waiting on something and this happens to be
+		 * that thing then set the re-configure flag.
+		 */
+		if (container != (u32)-1) {
+			if (container >= dev->maximum_num_containers)
+				break;
+			if (dev->fsa_dev[container].ConfigWaitingOn == le32_to_cpu(*(u32 *)aifcmd->data))
+				dev->fsa_dev[container].ConfigWaitingOn = 0;
+		} else for (container = 0; container < dev->maximum_num_containers; ++container) {
+			if (dev->fsa_dev[container].ConfigWaitingOn == le32_to_cpu(*(u32 *)aifcmd->data))
+				dev->fsa_dev[container].ConfigWaitingOn = 0;
+		}
+		break;
+
+	case AifCmdJobProgress:
+		/*
+		 *	These are job progress AIF's. When a Clear is being
+		 * done on a container it is initially created then hidden from
+		 * the OS. When the clear completes we don't get a config
+		 * change so we monitor the job status complete on a clear then
+		 * wait for a container change.
+		 */
+
+		if ((((u32 *)aifcmd->data)[1] == cpu_to_le32(AifJobCtrZero))
+		 && ((((u32 *)aifcmd->data)[6] == ((u32 *)aifcmd->data)[5])
+		  || (((u32 *)aifcmd->data)[4] == cpu_to_le32(AifJobStsSuccess)))) {
+			for (container = 0; container < dev->maximum_num_containers; ++container) {
+				/* Stomp on all config sequencing for all containers? */
+				dev->fsa_dev[container].ConfigWaitingOn = AifEnContainerChange;
+				dev->fsa_dev[container].ConfigNeeded = ADD;
+			}
+		}
+		break;
+	}
+
+	DeviceConfigNeeded = NOTHING;
+	for (container = 0; container < dev->maximum_num_containers; ++container) {
+		if ((dev->fsa_dev[container].ConfigWaitingOn == 0)
+		 && (dev->fsa_dev[container].ConfigNeeded != NOTHING)) {
+			DeviceConfigNeeded = dev->fsa_dev[container].ConfigNeeded;
+			dev->fsa_dev[container].ConfigNeeded = NOTHING;
+			break;
+		}
+	}
+	if (DeviceConfigNeeded == NOTHING)
+		return;
+
 	/*
-	 * Set the status of this FIB to be Invalid parameter.
-	 *
-	 *	*(u32 *)fib->data = ST_INVAL;
+	 *	If we decided that a re-configuration needs to be done,
+	 * schedule it here on the way out the door, please close the door
+	 * behind you.
 	 */
-	*(u32 *)hw_fib->data = cpu_to_le32(ST_OK);
-	fib_adapter_complete(fibptr, sizeof(u32));
+
+	busy = 0;
+
+	dprintk ((KERN_INFO "container=%d(%d,%d,%d,%d)\n",
+	  container,
+	  (dev && dev->scsi_host_ptr)
+	    ? dev->scsi_host_ptr->host_no
+	    : -1,
+	  CONTAINER_TO_CHANNEL(container),
+	  CONTAINER_TO_ID(container),
+	  CONTAINER_TO_LUN(container)));
+
+	/*
+	 *	Find the Scsi_Device associated with the SCSI address,
+	 * and mark it as changed, invalidating the cache. This deals
+	 * with changes to existing device IDs.
+	 */
+
+	if (!dev || !dev->scsi_host_ptr) {
+		return;
+	}
+	/*
+	 * force reload of disk info via probe_container
+	 */
+	if ((DeviceConfigNeeded == CHANGE)
+	 && (dev->fsa_dev[container].valid == 1))
+		dev->fsa_dev[container].valid = 2;
+	if ((DeviceConfigNeeded == CHANGE)
+	 || (DeviceConfigNeeded == ADD))
+		probe_container(dev, container);
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0))
+	shost_for_each_device(device, dev->scsi_host_ptr)
+#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
+	list_for_each_entry(device, &dev->scsi_host_ptr->my_devices, siblings)
+#else
+	for (device = dev->scsi_host_ptr->host_queue;
+	  device != (struct scsi_device *)NULL;
+	  device = device->next)
+#endif
+	{
+		dprintk((KERN_INFO "aifd: device (%d,%d,%d,%d)?\n",
+		  dev->scsi_host_ptr->host_no,
+		  device->channel,
+		  device->id,
+		  device->lun));
+		if ((device->channel == CONTAINER_TO_CHANNEL(container))
+		 && (device->id == CONTAINER_TO_ID(container))
+		 && (device->lun == CONTAINER_TO_LUN(container))) {
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)) && (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0))
+			busy |= atomic_read(&device->access_count) || test_bit(SHOST_RECOVERY, &dev->scsi_host_ptr->shost_state);
+#elif (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0))
+			busy |= device->device_busy || test_bit(SHOST_RECOVERY, &dev->scsi_host_ptr->shost_state);
+#else
+			busy |= device->access_count || dev->scsi_host_ptr->in_recovery;
+#endif
+			dprintk((KERN_INFO " %s %s\n",
+			  ((busy) ? "BUSY" : "AVAILABLE"),
+			  (DeviceConfigNeeded == NOTHING)
+			   ? "NOTHING"
+			   : (DeviceConfigNeeded == DELETE)
+			     ? "DELETE"
+			     : (DeviceConfigNeeded == ADD)
+			       ? "ADD"
+			       : (DeviceConfigNeeded == CHANGE)
+			         ? "CHANGE"
+				 : "UNKNOWN"));
+			if (busy == 0) {
+				device->removable = 1;
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
+				switch (DeviceConfigNeeded) {
+				case ADD:
+					/* No need to call scsi_scan_single_target */
+					DeviceConfigNeeded = CHANGE;
+#if ((LINUX_VERSION_CODE > KERNEL_VERSION(2,6,3)) || !defined(MODULE))
+					scsi_add_device(dev->scsi_host_ptr,
+					  device->channel, device->id, device->lun);
+					break;
+#endif
+				case DELETE:
+#if ((LINUX_VERSION_CODE > KERNEL_VERSION(2,6,3)) || !defined(MODULE))
+					scsi_remove_device(device);
+					break;
+#endif
+				case CHANGE:
+#if ((LINUX_VERSION_CODE > KERNEL_VERSION(2,6,10)) || !defined(MODULE))
+					scsi_rescan_device(&device->sdev_gendev);
+#else
+					/* scsi_rescan_device code fragment */
+					if (!device->sdev_gendev.driver)
+						break;
+					drv = to_scsi_driver(
+						device->sdev_gendev.driver);
+					if (!try_module_get(drv->owner))
+						break;
+					if(drv->rescan)
+						drv->rescan(&device->sdev_gendev);
+					module_put(drv->owner);
+#endif
+
+				default:
+					break;
+				}
+#endif
+			}
+		}
+	}
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,0))
+	if (DeviceConfigNeeded == ADD) {
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,10))
+		scsi_scan_single_target(dev->scsi_host_ptr,
+		  CONTAINER_TO_CHANNEL(container),
+		  CONTAINER_TO_ID(container));
+#elif (!defined(MODULE))
+		scsi_scan_host_selected(dev->scsi_host_ptr,
+		  CONTAINER_TO_CHANNEL(container),
+		  CONTAINER_TO_ID(container),
+		  CONTAINER_TO_LUN(container), 0);
+#endif
+	}
+#endif
+	dprintk (("busy=%d\n", busy));
+
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
+	/*
+	 * if (busy == 0) {
+	 *	scan_scsis(dev->scsi_host_ptr, 1,
+	 *	  CONTAINER_TO_CHANNEL(container),
+	 *	  CONTAINER_TO_ID(container),
+	 *	  CONTAINER_TO_LUN(container));
+	 * }
+	 * is not exported as accessible, so we need to go around it
+	 * another way. So, we look for the "proc/scsi/scsi" entry in
+	 * the proc filesystem (using proc_scsi as a shortcut) and send
+	 * it a message. This deals with new devices that have
+	 * appeared. If the device has gone offline, scan_scsis will
+	 * also discover this, but we do not want the device to
+	 * go away. We need to check the access_count for the
+	 * device since we are not wanting the devices to go away.
+	 */
+	if (busy) {
+		dev->fsa_dev[container].ConfigWaitingOn = 0;
+		dev->fsa_dev[container].ConfigNeeded = DeviceConfigNeeded;
+		return;
+	}
+	if (proc_scsi != (struct proc_dir_entry *)NULL) {
+		struct proc_dir_entry * entry;
+
+		dprintk((KERN_INFO "proc_scsi=%p ", proc_scsi));
+		for (entry = proc_scsi->subdir;
+		  entry != (struct proc_dir_entry *)NULL;
+		  entry = entry->next) {
+			dprintk(("\"%.*s\"[%d]=%x ", entry->namelen,
+			  entry->name, entry->namelen, entry->low_ino));
+			if ((entry->low_ino != 0)
+			 && (entry->namelen == 4)
+			 && (memcmp ("scsi", entry->name, 4) == 0)) {
+				dprintk(("%p->write_proc=%p ", entry, entry->write_proc));
+				if (entry->write_proc != (int (*)(struct file *, const char *, unsigned long, void *))NULL) {
+					char buffer[80];
+					int length;
+					mm_segment_t fs;
+
+					sprintf (buffer,
+					  "scsi %s-single-device %d %d %d %d\n",
+					  ((DeviceConfigNeeded == DELETE)
+					   ? "remove"
+					   : "add"),
+					  dev->scsi_host_ptr->host_no,
+					  CONTAINER_TO_CHANNEL(container),
+					  CONTAINER_TO_ID(container),
+					  CONTAINER_TO_LUN(container));
+					length = strlen (buffer);
+					dprintk((KERN_INFO
+					  "echo %.*s > /proc/scsi/scsi\n",
+					  length-1,
+					  buffer));
+//printk("echo %.*s > /proc/scsi/scsi\n", length-1, buffer);
+					fs = get_fs();
+					set_fs(get_ds());
+					length = entry->write_proc(
+					  NULL, buffer, length, NULL);
+					set_fs(fs);
+					dprintk((KERN_INFO
+					  "returns %d\n", length));
+				}
+				break;
+			}
+		}
+	}
+#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)) */
 }
 
 /**
@@ -804,10 +1312,12 @@ int aac_command_thread(struct aac_dev * 
 {
 	struct hw_fib *hw_fib, *hw_newfib;
 	struct fib *fib, *newfib;
-	struct aac_queue_block *queues = dev->queues;
+	struct aac_queue *q = &dev->queues->queue[HostNormCmdQueue];
 	struct aac_fib_context *fibctx;
 	unsigned long flags;
 	DECLARE_WAITQUEUE(wait, current);
+	unsigned long next_jiffies = jiffies + HZ;
+	long difference;
 
 	/*
 	 *	We can only have one thread per adapter for AIF's.
@@ -818,27 +1328,33 @@ int aac_command_thread(struct aac_dev * 
 	 *	Set up the name that will appear in 'ps'
 	 *	stored in  task_struct.comm[16].
 	 */
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
 	daemonize("aacraid");
 	allow_signal(SIGKILL);
+#else
+	sprintf(current->comm, "aacraid");
+	daemonize();
+#endif
 	/*
 	 *	Let the DPC know it has a place to send the AIF's to.
 	 */
 	dev->aif_thread = 1;
-	add_wait_queue(&queues->queue[HostNormCmdQueue].cmdready, &wait);
+	add_wait_queue(&q->cmdready, &wait);
 	set_current_state(TASK_INTERRUPTIBLE);
+	dprintk ((KERN_INFO "aac_command_thread start\n"));
 	while(1) 
 	{
-		spin_lock_irqsave(queues->queue[HostNormCmdQueue].lock, flags);
-		while(!list_empty(&(queues->queue[HostNormCmdQueue].cmdq))) {
+		spin_lock_irqsave(q->lock, flags);
+		while(!list_empty(&(q->cmdq))) {
 			struct list_head *entry;
 			struct aac_aifcmd * aifcmd;
 
 			set_current_state(TASK_RUNNING);
-		
-			entry = queues->queue[HostNormCmdQueue].cmdq.next;
+	
+			entry = q->cmdq.next;
 			list_del(entry);
-			
-			spin_unlock_irqrestore(queues->queue[HostNormCmdQueue].lock, flags);
+		
+			spin_unlock_irqrestore(q->lock, flags);
 			fib = list_entry(entry, struct fib, fiblink);
 			/*
 			 *	We will process the FIB here or pass it to a 
@@ -860,7 +1376,7 @@ int aac_command_thread(struct aac_dev * 
 			if (aifcmd->command == cpu_to_le32(AifCmdDriverNotify)) {
 				/* Handle Driver Notify Events */
 				aac_handle_aif(dev, fib);
-				*(u32 *)hw_fib->data = cpu_to_le32(ST_OK);
+				*(__le32 *)hw_fib->data = cpu_to_le32(ST_OK);
 				fib_adapter_complete(fib, sizeof(u32));
 			} else {
 				struct list_head *entry;
@@ -869,13 +1385,60 @@ int aac_command_thread(struct aac_dev * 
 				   
 				u32 time_now, time_last;
 				unsigned long flagv;
-				
+				unsigned num;
+				struct hw_fib ** hw_fib_pool, ** hw_fib_p;
+				struct fib ** fib_pool, ** fib_p;
+			
 				/* Sniff events */
-				if (aifcmd->command == cpu_to_le32(AifCmdEventNotify))
+				if ((aifcmd->command == cpu_to_le32(AifCmdEventNotify))
+				 || (aifcmd->command == cpu_to_le32(AifCmdJobProgress))) {
 					aac_handle_aif(dev, fib);
+				}
 				
 				time_now = jiffies/HZ;
 
+				/*
+				 * Warning: no sleep allowed while
+				 * holding spinlock. We take the estimate
+				 * and pre-allocate a set of fibs outside the
+				 * lock.
+				 */
+				num = le32_to_cpu(dev->init->AdapterFibsSize)
+				    / sizeof(struct hw_fib); /* some extra */
+				spin_lock_irqsave(&dev->fib_lock, flagv);
+				entry = dev->fib_list.next;
+				while (entry != &dev->fib_list) {
+					entry = entry->next;
+					++num;
+				}
+				spin_unlock_irqrestore(&dev->fib_lock, flagv);
+				hw_fib_pool = NULL;
+				fib_pool = NULL;
+				if (num
+				 && ((hw_fib_pool = kmalloc(sizeof(struct hw_fib *) * num, GFP_ATOMIC|GFP_KERNEL)))
+				 && ((fib_pool = kmalloc(sizeof(struct fib *) * num, GFP_ATOMIC|GFP_KERNEL)))) {
+					hw_fib_p = hw_fib_pool;
+					fib_p = fib_pool;
+					while (hw_fib_p < &hw_fib_pool[num]) {
+						if (!(*(hw_fib_p++) = kmalloc(sizeof(struct hw_fib), GFP_ATOMIC|GFP_KERNEL))) {
+							--hw_fib_p;
+							break;
+						}
+						if (!(*(fib_p++) = kmalloc(sizeof(struct fib), GFP_ATOMIC|GFP_KERNEL))) { 
+							kfree(*(--hw_fib_p));
+							break;
+						}
+					}
+					if ((num = hw_fib_p - hw_fib_pool) == 0) {
+						kfree(fib_pool);
+						fib_pool = NULL;
+						kfree(hw_fib_pool);
+						hw_fib_pool = NULL;
+					}
+				} else if (hw_fib_pool) {
+					kfree(hw_fib_pool);
+					hw_fib_pool = NULL;
+				}
 				spin_lock_irqsave(&dev->fib_lock, flagv);
 				entry = dev->fib_list.next;
 				/*
@@ -884,6 +1447,8 @@ int aac_command_thread(struct aac_dev * 
 				 * fib, and then set the event to wake up the
 				 * thread that is waiting for it.
 				 */
+				hw_fib_p = hw_fib_pool;
+				fib_p = fib_pool;
 				while (entry != &dev->fib_list) {
 					/*
 					 * Extract the fibctx
@@ -916,9 +1481,11 @@ int aac_command_thread(struct aac_dev * 
 					 * Warning: no sleep allowed while
 					 * holding spinlock
 					 */
-					hw_newfib = kmalloc(sizeof(struct hw_fib), GFP_ATOMIC);
-					newfib = kmalloc(sizeof(struct fib), GFP_ATOMIC);
-					if (newfib && hw_newfib) {
+					if (hw_fib_p < &hw_fib_pool[num]) {
+						hw_newfib = *hw_fib_p;
+						*(hw_fib_p++) = NULL;
+						newfib = *fib_p;
+						*(fib_p++) = NULL;
 						/*
 						 * Make the copy of the FIB
 						 */
@@ -933,39 +1500,91 @@ int aac_command_thread(struct aac_dev * 
 						fibctx->count++;
 						/* 
 						 * Set the event to wake up the
-						 * thread that will waiting.
+						 * thread that is waiting.
 						 */
 						up(&fibctx->wait_sem);
 					} else {
 						printk(KERN_WARNING "aifd: didn't allocate NewFib.\n");
-						if(newfib)
-							kfree(newfib);
-						if(hw_newfib)
-							kfree(hw_newfib);
 					}
 					entry = entry->next;
 				}
 				/*
 				 *	Set the status of this FIB
 				 */
-				*(u32 *)hw_fib->data = cpu_to_le32(ST_OK);
+				*(__le32 *)hw_fib->data = cpu_to_le32(ST_OK);
 				fib_adapter_complete(fib, sizeof(u32));
 				spin_unlock_irqrestore(&dev->fib_lock, flagv);
+				/* Free up the remaining resources */
+				hw_fib_p = hw_fib_pool;
+				fib_p = fib_pool;
+				while (hw_fib_p < &hw_fib_pool[num]) {
+					if (*hw_fib_p)
+						kfree(*hw_fib_p);
+					if (*fib_p)
+						kfree(*fib_p);
+					++fib_p;
+					++hw_fib_p;
+				}
+				if (hw_fib_pool)
+					kfree(hw_fib_pool);
+				if (fib_pool)
+					kfree(fib_pool);
 			}
-			spin_lock_irqsave(queues->queue[HostNormCmdQueue].lock, flags);
 			kfree(fib);
+			spin_lock_irqsave(q->lock, flags);
 		}
 		/*
 		 *	There are no more AIF's
 		 */
-		spin_unlock_irqrestore(queues->queue[HostNormCmdQueue].lock, flags);
-		schedule();
+		spin_unlock_irqrestore(q->lock, flags);
+
+		difference = next_jiffies - jiffies;
+		if (difference <= 0) {
+			struct timeval now;
+
+			do_gettimeofday(&now);
+
+			/* Synchronize our watches */
+			if (((1000000 - (1000000 / HZ)) > now.tv_usec)
+			 && (now.tv_usec > (1000000 / HZ)))
+				difference = (((1000000 - now.tv_usec) * HZ)
+				  + 500000) / 1000000;
+			else {
+				struct fib *fibptr;
+
+				if ((fibptr = fib_alloc(dev))) {
+					u32 * info;
+
+					fib_init(fibptr);
+
+					info = (u32 *) fib_data(fibptr);
+					if (now.tv_usec > 500000)
+						++now.tv_sec;
+
+					*info = cpu_to_le32(now.tv_sec);
+
+					(void)fib_send(SendHostTime,
+						fibptr,
+						sizeof(*info),
+						FsaNormal,
+						1, 1,
+						NULL,
+						NULL);
+					fib_complete(fibptr);
+					fib_free(fibptr);
+				}
+				difference = 30 * 60 * HZ;
+			}
+			next_jiffies = jiffies + difference;
+		}
+		schedule_timeout(difference);
 
 		if(signal_pending(current))
 			break;
 		set_current_state(TASK_INTERRUPTIBLE);
 	}
-	remove_wait_queue(&queues->queue[HostNormCmdQueue].cmdready, &wait);
+	remove_wait_queue(&q->cmdready, &wait);
 	dev->aif_thread = 0;
 	complete_and_exit(&dev->aif_completion, 0);
+	return 0;
 }
--- linux-2.6.8.1-t043-libata-update/drivers/scsi/aacraid/CHANGELOG	1970-01-01 03:00:00.000000000 +0300
+++ aacraid-drv/drivers/scsi/aacraid/CHANGELOG	2005-05-12 22:42:21.000000000 +0400
@@ -0,0 +1,2019 @@
+Version: 0.9.10
+
+Version: 1.1.2
+
+2003-05-15	Mark_Salyzyn@adaptec.com
+
+Differences between 2.4.21-rc2-ac2 kernel and our 1.1.2 versioned driver,
+changes as performed by Deanna Bonds, Bob Pasteur and Mark Salyzyn.
+
+aachba.c:
+	- If the state of a logical unit is hidden, then do not report. This
+	  state is typically entered when a device is being cleared.
+	- Added support for the Tallahassee project, where one channel is
+	  dedicated to SCSI, and the other channel is dedicated to RAID.
+	- Resolved some issues surrounding PAE support and IA64.
+	- If the driver is a not a boot disk driver, then set the Removable
+	  bit on the inquiry strings returned by the logical units to ensure
+	  that any changes in the arrays will be acquired when the device is
+	  re-attached.
+	- mask the SRB status with 0x3F to deal with misbehaving devices.
+	- Do not report DISKs to inquiry requests on the SCSI bus except if
+	  the channel is designated as a SCSI only bus.
+	- Propagate check conditions to the SCSI command result.
+	- Add support for programmable timeouts to propagate down toe the
+	  requests.
+	- If we have pae mode enabled, right after we get the adapter
+	  information and determine the pae mode capability, we enable the
+	  system to issue 64 bit requests.
+aacraid.h:
+	- Had to drop from 512 commands to 100 commands because some versions
+	  of the firmware would starve commands causing a timeout reaction
+	  which lead to lost commands.
+	- Added a global control variable for nondasd and paemode support.
+	- Dealt with some 64 bit / 32 bit issues in list_head structures and
+	  helper Macros, replacing them with our own more sensitive variants.
+	- Differentiated virtual and physical references to the shared fib
+	  allocations.
+	- information structure not synchronized to firmware, needed to add
+	  a clusterchannelmask.
+	- Added definitions in support of the new configuration information
+	  page bits in support of Tallahassee.
+	- Changed to an allocated fib pool, rather than an array in the hba
+	  structure as this affected the SCSI memory pool.
+	- Added some AIF definitions to permit us to sniff for container
+	  changes to permit a rescan to pick up new information or targets.
+commctrl.c:
+	- The fib reference was changed to a physical and a virtual address,
+	  absorb the name changes.
+	- The list_head structure handlers have been replaced with our own,
+	  absorb the name changes.
+	- The fib address reported in an AIF is a physical (32 bit) reference,
+	  and not a virtual (possibly 64 bit) reference.
+	- added the ioctl handling for sending a raw srb (FSACTL_SEND_RAW_SRB).
+comminit.c:
+	- Deal with IA64 issues.
+	- Change to using the physical address (32 bit) for the AIF references.
+	- The list_head structure handlers have been replaced with our own,
+	  absorb the name changes.
+	- Observed a memory leak, free up the queue resources should we fail
+	  to initialize the adapter.
+commsup.c:
+	- The fib reference was changed to a physical and a virtual address,
+	  absorb the name changes.
+	- Instead of panicking the kernel when a fib allocation was available,
+	  sleep until it is available.
+	- Submitted fib pointers are physical (32 bit) rather than virtual
+	  (possibly 64 bit) values.
+	- producer and consumer indexes should be converted over to local
+	  cpu endian before comparison.
+	- aac_handle_aif now sniffs AIF events and takes plug and play action
+	  for container changes.
+	- The aif thread is set up to be a kernel thread, and not a user
+	  thread. This permits us the ability to make plug and play calls
+	  without prejudice.
+	- Added instrumentation to the aif thread to confirm the plug and
+	  play activity and as an aid to several other debug sessions.
+	- Do not age an aif context based on the last received aif, but rather
+	  the last poll.
+dpcsup.c:
+	- The fib reference was changed to a physical and a virtual address,
+	  absorb the name changes.
+	- Submitted fib pointers are physical (32 bit) rather than virtual
+	  (possibly 64 bit) values.
+linit.c:
+	- Added paemode control.
+	- Added various upcoming board products, and documented better the
+	  existing board product ids. This includes SATA RAID products.
+	- needed to take the io_request_lock during portions of initialization.
+	- allocate the fib resource separately, rather than part of adapter
+	  structure to aid in the precious SCSI resources.
+	- cleanup of none dasd support options.
+	- Added more details about the build date of the driver to the proc
+	  information.
+	- dropped a change that permitted 64 bit DMA resources to be generated
+	  instead of through a 32 bit bounce buffer. (it was moved to aachba.c
+	  where it can be turned on after we determine the adapter's
+	  capabilities).
+	- max_id, max_lun and max_channel parameters are set after the
+	  adapter information has been picked up (the number of channels is
+	  based on the product id table now).
+sa.c:
+	- Context of timeout handling was incorrect, only noticed in IA64
+	  bit machines (due to lack of BIOS initialization).
+
+Differences that need further investigation and could be viewed as regressions
+and added after submission:
+
+rx.c:
+	- Dropped detection of failure to generate kernel command thread.
+sa.c:
+	- Dropped detection of failure to generate kernel command thread.
+
+Version: 1.1.3
+
+2003-07-01	Mark_Salyzyn@adaptec.com
+
+aachba.c:
+	- Added aac_get_container_name to permit override of array inquiry
+	  string with the set name.
+
+2003-07-08	Mark_Salyzyn@adaptec.com
+
+aachba.c:
+	- Return 0 (success) for unsupported commands, the check condition
+	  should perform the necessary action of error handling.
+
+2003-07-10	Mark_Salyzyn@adaptec.com
+
+aachba.c:
+	- The pass-through SCSI SCB command in PAE mode was getting the fib
+	  size count wrong, by using the 32 bit command, then doing an (n-1)
+	  times the size of the 64 bit scatter gather. Resolution was to
+	  subtract the 32 bit scatter gather, then do an n times the 64 scatter
+	  gather size.
+	- Only go into PAE mode if more than 4MB of memory in the system.
+
+2003-07-10	Mark_Salyzyn@adaptec.com
+
+linit.c:
+	- Added `Family' product codes and reordered the product discovery code
+	  to produce devices in PCI order rather than in product order.
+	  Dell, Legend and Adaptec Families were produced with the assumption
+	  of 2 available busses.
+
+2003-07-24	Mark_Salyzyn@adaptec.com
+
+linit.c:
+	- Added Bearcat (6 ch SATA) and a commented entry for Lancer where
+	  future workarounds may be necessary due to hardware constraints.
+	- Set highmem_io (for kernels of 2.4.18 and above).
+
+aachba.c:
+	- Set highmem_io (for kernels of 2.4.18 and above; and when the
+	  adapter is guaranteed to handle the possible address ranges it
+	  will be provided).
+
+Version: 1.1.4:
+
+2003-07-28	Mark_Salyzyn@adaptec.com
+
+aacraid.h+common/include/fsaioctl.h+aachba.c
+	- Added the FSACTL_REGISTER_FIB_SEND function to the ioctl. This ioctl
+	  is *not* a user accessible ioctl, meant only for driver use to permit
+	  stacking a filter driver just ahead of the hardware layer. The call
+	  to register is:
+
+		typedef void (*fib_callback)(void *ctxt, struct fib *fibctx);
+		typedef struct {
+			int (*fib_send)(u16 command,
+					struct fib * context,
+					unsigned long fib_size,
+					int priority,
+					int wait,
+					int reply
+					fib_callback callback,
+					void * ctxt);
+		} fib_send_t;
+		. . .
+		fib_send_t original;
+		int dummy_fib_send (u16 command,
+				    struct fib * context,
+				    unsigned long fib_size,
+				    int priority,
+				    int wait,
+				    int reply
+				    fib_callback callback,
+				    void * ctxt)
+		{
+			return (*original->fib_send)(command, context, fib_size, priority, wait, reply, callback, ctxt);
+		}
+		. . .
+		Scsi_Host_Template * host;
+		Scsi_Device * adapter;
+		original->fib_send = dummy_fib_send;
+		host->ioctl(adapter, FSACTL_REGISTER_FIB_SEND, &original);
+
+	  Return value from the ioctl include ENOTTY (not supported), EINVAL
+	  (invalid argument pointer) and EBUSY (another function already
+	  registered) and the original fib_send function is returned in the
+	  ioctl argument structure. A NULL value for the fib_send member of the
+	  structure deregisters the filter driver. The fib_callback function is
+	  issued at interrupt priority and should follow all the constraints of
+	  interrupt operation. It is the responsibility of the registered
+	  fib_send function to ensure that the original fib_callback function
+	  is called with the ctxt value when completing the command (this
+	  subtlety is lost in the above dummy function).
+
+2003-07-28	Mark_Salyzyn@adaptec.com
+
+linit.c:
+	- Added Kernel, Firmware and BIOS revision and build number to proc
+	  information.
+	- Added board serial number to proc information.
+
+aachba.c:
+	- Do not set removable bit in the inquiry command, the aif delivery
+	  of array status change will handle the reasons for the removable
+	  bit (capacity change and differences in the partition table). Some
+	  customers take issue with the fact our arrays appear as removable.
+
+commctrl.c:
+	- Reported driver version and build number instead of Firmware version
+	  and build number for the Miniport Version Check ioctl. ADPmp57715
+
+2003-08-06	Mark_Salyzyn@adaptec.com and a cast of thousands
+
+all files:
+	- Added appropriate ifdefs, or merged in additions, in support of the
+	  2.6.0-test2 kernels as follows:
+
+Makefile:
+	- Added ifdefs for 2.4 and 2.6 kernels so we can use a common Makefile
+	  for both kernel build environments.
+
+aachba.c:
+	- use linux/blkdev.h in 2.5+ kernels.
+	- define aac_spin_* macros to differentiate between lock requirements
+	  in 2.5+ and 2.4 kernels.
+	- Use the SCSI layers definitions of the SCSI commands, rather than
+	  our own internal SS_* manifests.
+	- Define SCSICMD_TO_* macros to acquire the SCSI target host, channel,
+	  id and lun.
+	- Use the 2.6 SAM_* status codes for return, the 2.4 system will
+	  redefine the SAM_* codes to 2.4 variants.
+	- Change to devname instead of devno when referencing devices to
+	  simplify conversions.
+	- MAXIMUM_NUM_CONTAINERS references were +/- 1 in comparisons, made
+	  this value a `number' rather than a mix of `number' and `limit'.
+	- Resolved `Cast of pointer from integer of different size' by
+	  (void *)(ulong)dma_addr_t.
+	- Change to `id' rather than `target' to match SCSI subsystem
+	  references name for consistency.
+
+aacraid.h:
+	- MAXIMUM_NUM_CONTAINERS references were +/- 1 in comparisons, made
+	  this value a `number' rather than a mix of `number' and `limit'.
+	- Removed AAC_MAX_TARGET, as it is no longer used.
+	- Added CONTAINER_TO_* macros to simplify references.
+	- Change to `id' rather than `target' to match SCSI subsystem
+	  references name for consistency.
+	- Change to devname instead of devno when referencing devices.
+	- Use cap_to_cyls inline to handle 64 bit calculation correctly.
+
+commctrl.c:
+	- use linux/blkdev.h in 2.5+ kernels.
+	- Change to `id' rather than `target' to match SCSI subsystem
+	  references name for consistency.
+
+comminit.c:
+	- use linux/blkdev.h in 2.5+ kernels.
+
+commsup.c:
+	- use linux/blkdev.h in 2.5+ kernels.
+	- Moved CONTAINER_TO_* macros to aacraid.h to simplify references.
+	- Device Discovery loops are different for 2.4 and 2.5+ kernels,
+	  use list_for_each_entry siblings instead of host_queue loop.
+	- daemonize adds the process name as a parameter, and requires
+	  SIGKILL to be enabled to permit kernel shutdown in 2.5+ kernels.
+
+dpcsup.c:
+	- use linux/blkdev.h in 2.5+ kernels.
+
+linit.c:
+	- use linux/blkdev.h in 2.5+ kernels.
+	- added aacids to provide a table hint for installers.
+	- changed over to utilize ANSI structure initialization.
+	- aac_biosparm and aac_procinfo change parameters in 2.5+ kernels.
+	- aac_slave_configure replaces aac_queuedepth in 2.5+ kernels.
+	- detect no longer needs to unlock io_request_lock to do it's duty
+	  in 2.5+ kernels.
+	- use SCSI_set_device in 2.5+ kernels rather than scsi_set_pci_device.
+	- Change to devname instead of devno when referencing devices to
+	  simplify conversions.
+	- Use MAXIMUM_NUM_CONTAINERS rather than AAC_MAX_TARGET
+	- Use cap_to_cyls inline to handle 64 bit calculation correctly in
+	  aac_biosparm.
+	- Use minor in 2.5+ kernels instead of MINOR macro.
+
+rx.c:
+	- use linux/blkdev.h in 2.5+ kernels.
+	- interrupts now return irqreturn_t.
+
+sa.c:
+	- use linux/blkdev.h in 2.5+ kernels.
+	- interrupts now return irqreturn_t.
+
+2003-08-15	Mark_Salyzyn@adaptec.com
+
+install.sh:
+	- increased range of kernel version reports in the magic file to 30.
+
+2003-08-19	Mark_Salyzyn@adaptec.com & ijohns@elipsan.com
+
+aachba.c:
+	- status_byte in the result is shifted down by one.
+	- set_sense spoof was not immediately followed by a copy of the check
+	  condition results into the SCSI command.
+
+2003-08-20	Mark_Salyzyn@adaptec.com, Scott_Long@adaptec.com & Alan Cox
+
+commctrl.c:
+	- The raw SCSI SCB ioctl command in PAE mode was getting the fib
+	  size count wrong, by using the 32 bit command, then doing an (n-1)
+	  times the size of the 64 bit scatter gather. Resolution was to
+	  subtract the 32 bit scatter gather, then do an n times the 64 scatter
+	  gather size.
+
+aacraid.h:
+	- Added definition of CT_FLUSH_CACHE command and structures.
+	- Added AAC_QUIRK_31BIT for ROMB based adapters.
+
+linit.c:
+	- Added AAC_QUIRK_31BIT for ROMB based adapters.
+	- Check return from scsi_register.
+
+aachba.c:
+	- Added support for issuing CT_FLUSH_CACHE command when the SCSI
+	  SYNCHRONIZE command is issued to a container.
+	- Restored mask after adding AAC_QUIRK_31BIT for ROMB based adapters.
+
+2003-08-21	Mark_Salyzyn@adaptec.com
+
+aachba.c:
+	- Changed aac_get_container_name to be a none-blocking function,
+	  completing the incoming scsicmd with the adapter response.
+
+2003-08-26	Mark_Salyzyn@adaptec.com
+
+commsup.c + aacraid.h:
+	- Altered handling of AIF messages from Firmware to differentiate
+	  events in a finer grained manner.
+
+2003-08-29	Mark_Salyzyn@adaptec.com
+
+aachba.c + aacraid.h
+	- Driver too noisy, undefined AAC_DETAILD_STATUS_INFO and incorporated
+	  check condition report into the AAC_DETAILED_STATUS_INFO ifdef.
+
+2003-09-03	Mark_Salyzyn@adaptec.com
+
+aachba.c:
+	- Check if the device is in use and report that as a locked device
+	  to both the FSACTL_QUERY_DISK and FSACTL_DELETE_ARRAY ioctls.
+	- unlock/lock around probe_container as this is a blocking function.
+	  This change addresses a deadlock issue that surfaced in SMP only
+	  environments.
+
+Version: 1.1.4-2172
+
+2003-09-04	Mark_Salyzyn@adaptec.com
+
+commsup.c:
+	- References to the Status Job update structure were at incorrect
+	  offsets causing incorrect operation during an Array Clear with
+	  regards to plug and play actions.
+
+Version: 1.1.4-2177
+
+2003-09-05	Mark_Salyzyn@adaptec.com
+
+aachba.c:
+	- Cleanup request from the SCSI list maintainers.
+	- Dropped use of SCSICMD_TO_CHANNEL & friends since
+	  scsicmd->device->channel is available in all versions of the
+	  operating system.
+	- Removed deprecated code and/or comments related to deprecation.
+	- include <linux/blkdev.h> works in all versions of the operating
+	  system.
+
+2003-09-09	Mark_Salyzyn@adaptec.com
+
+aacraid.h:
+	- NUM_FIBs should be 64 larger (AIFS) larger than the NUM_IO_FIBS.
+
+commsup.c:
+	- efficiency improved if we hold on to the aac_queue variable, aims
+	  towards better code compliance and consistency.
+
+2003-09-15	Mark_Salyzyn@adaptec.com
+
+rkt.c:
+	- Copy if rx.c with rx = rkt
+
+aacraid.h:
+	- Added definition for rkt interface structures, copy of rx, but a
+	  larger reserved region.
+
+linit.c:
+	- Added product code for ROC (Lancer/Rocket) U320 two channel, use rkt
+	  interface.
+
+2003-09-16	Mark_Salyzyn@adaptec.com
+
+linit.c:
+	- Show Adapter vendor and model in proc information.
+
+Version: 1.1.4-2185
+
+2003-09-16	Mark_Salyzyn@adaptec.com
+
+aacraid.h:
+	- Added definition of nblank() to assist us in determining if
+	  dprintk(x) is defined as a blank definition to enable us to ifdef
+	  debug code that ends up calling only dprintk functions.
+
+commsup.c:
+	- Ignore events that refer to containers > MAXIMUM_NUM_CONTAINERS
+	- include <linux/blkdev.h> works in all versions of the operating
+	  system.
+
+linit.c:
+	- print more details about outstanding commands when a SCSI hang
+	  occurs (first use of nblank() macro just defined in aacraid.h)
+
+2003-09-19	Mark_Salyzyn@adaptec.com & Mark Haverkamp <markh@osdi.org>
+
+commsup.c & aachba.c:
+	- valid flag has added support for a value of 2, which means target
+	  is still valid, but needs a probe_container.
+
+commsup.c:
+	- fib_alloc should not go to sleep, but return NULL if there are no
+	  available entries in the pool.
+
+dpcsup.c:
+	- print a message if the fib kmalloc fails when forwarding AIFs
+
+comminit.c:
+	- check fib_alloc return, and report -ENOMEM should the pool be
+	  empty.
+
+aachba.c:
+	- Check value of scsicmd->scsi_done in aac_io_done as we can get
+	  errant firmware which returns commands twice (no released firmware
+	  does this, this is a driver hardening issue only).
+	- When a fib_alloc fails, return -1 to SCSI layer. Formerly, we would
+	  send the command with DID_ERROR.
+
+Version: 1.1.4-2192
+
+2003-09-25	Mark_Salyzyn@adaptec.com
+
+linit.c:
+	- Moved debug variables into block to reduce impact on none-debug
+	  environments.
+
+dpcsup.c + commsup.c:
+	- Use the fib pool instead of a kmalloc to allocate a fib for the
+	  processing of an AIF.
+
+install.sh:
+	- Install driver into any forgotten /lib/modules directories.
+
+2003-09-26	Mark_Salyzyn@adaptec.com
+
+commctrl.c + aacraid.h:
+	- AMD-64 and IA-64 management applications will fail, need to change
+	  fibctx to a 32 bit unique value.
+
+Version: 1.1.4-2194
+
+2003-09-29	Mark_Salyzyn@adaptec.com & Mark Haverkamp <markh@osdi.org>
+
+aachba.c:
+	- use linux/blkdev.h for all variants on Linux.
+	- hold on to the host pointer in aac_io_done, because it's reference
+	  in the device and scsicmd can go away after scsi_done is called.
+	- check return value of pci_set_dma_mask.
+
+commctrl.c:
+	- use linux/blkdev.h for all variants on Linux.
+
+comminit.c:
+	- use linux/blkdev.h for all variants on Linux.
+
+commsup.c:
+	- use linux/blkdev.h for all variants on Linux.
+	- drop linux/smp_lock.h include as it was added in a debug test from
+	  some time ago.
+	- Added current 2.6 kernel support routines for rescanning.
+
+dpcsup.c:
+	- use linux/blkdev.h for all variants on Linux.
+
+linit.c:
+	- use linux/blkdev.h for all variants on Linux.
+	- check return value of pci_set_dma_mask.
+	- template->present is no longer relevant in 2.6 based kernels.
+
+rx.c:
+	- use linux/blkdev.h for all variants on Linux.
+
+sa.c:
+	- use linux/blkdev.h for all variants on Linux.
+
+rkt.c:
+	- use linux/blkdev.h for all variants on Linux.
+
+2003-10-01	Mark_Salyzyn@adaptec.com
+
+commsup.c:
+	- needed a fib_dealloc call ahead of the fib_free call added when
+	  we moved over to the fib pool to handle the AIFs.
+
+dpcsup.c:
+	- need to use the `local' fibctx so that the AIF command can be
+	  acknowledged.
+
+commctrl.c:
+	- return error status from the send_fib function in ioctl_send_fib.
+
+2003-10-07	Mark_Salyzyn@adaptec.com
+
+aachba.c + linit.c:
+	- serial number contains the cookie (fafa0001) that is at index 1
+	  of the serial number element. Only show the serial number which
+	  is at index 0.
+
+linit.c:
+	- Added registration to receive 32 bit ioctls.
+
+commsup.c + dpcsup.c + aacraid.h:
+	- Dropped code to acquire AIF's from the general FIB pool, it was a
+	  fool's errand. However, we kept the code that limits the AIF's
+	  received and allocated to the AdapterFibsSize / sizeof(hw_fib).
+	  The `last' AIF hw_fib is used to quickly acknowledge the entries,
+	  and drop the results on the floor.
+
+rx.c + rkt.c:
+	- Cache the OIMR data in dev->OIMR, it looks remarkably like irq_mask,
+	  which is really unused, but we can clean that up later.
+
+2003-10-08	Matthew Wilcox <willy@debian.org>
+
+aachba.c:
+	- Use SCp.dma_handle instead of SCp.ptr for holding on to the physical
+	  address of the allocated pci_map_single as part of the request.
+
+compat.h:
+	- define dma_handle to be ptr (in support of SCp.dma_handle change
+	  above) for kernels that do not define this member.
+
+2003-10-08	Christoph Hellwig <hch@infradead.org>
+
+aachba.c:
+	- drop use of scsi_to_pci_dma_dir() as it is a pass-through in all
+	  versions of the kernel.
+
+2003-10-09	Mark_Salyzyn@adaptec.com
+
+linit.c:
+	- When an Adapter Reset is requested, wait up to 60 seconds for all
+	  outstanding commands to complete and report SUCCESS.
+
+Version: 1.1.4-2221
+
+2003-10-09	Mark_Salyzyn@adaptec.com
+
+linit.c:
+	- Waited for *all* commands to complete for *all* devices on the
+	  controller when an Adapter Reset is requested.
+
+Version: 1.1.4-2222
+
+2003-10-10	Mark_Salyzyn@adaptec.com
+
+aacraid.h + rx.c + rkt.c + sa.c + linit.c:
+	- Added a aac_adapter_check_health, make sure the adapter is healthy
+	  when performing and Adapter Reset request, report error codes.
+
+aachba.c:
+	- revert to use of scsi_to_pci_dma_dir() as it is not a pass-through in
+	  all versions of the kernel.
+
+linit.c:
+	- SCSI_HAS_HOST_LOCK means that we should be working with releasing
+	  host->lock or host->host_lock instead of io_request_lock surrounding
+	  scsi_sleep.
+
+aacraid.h:
+	- Added definition for AAC_MAX_HOSTPHYSMEMPAGES
+
+comminit.c:
+	- Utilized AAC_MAX_HOSTPHYSMEMPAGES to limit the number of open DMA
+	  4096 byte PAGES of memory requested by the operating system.
+
+2003-10-16	Mark_Salyzyn@adaptec.com
+
+install.sh:
+	- Added support for x86_64 installs
+
+aachba.c:
+	- used SENSE KEYS from scsi.h rather than our own definitions.
+
+2003-10-20	Xose Vazquez Perez <xose@wanadoo.es>
+
+linit.c:
+	- Added pci_ids for 0x10110046/0x90050365
+
+Version: 1.1.4-2265
+
+2003-10-23	Mark_Salyzyn@adaptec.com
+
+linit.c:
+	- no need to set template->present as this is done by the SCSI layer.
+
+2003-10-24	Mark_Salyzyn@adaptec.com
+
+install.sh
+	- Added support for SuSE kernel determination for finer selection
+	  of modules
+	- If the kernel is compiled for athlon, use that instead of
+	  /proc/cpuinfo
+	- if /proc/cpuinfo is not present, don't show any errors during
+	  install
+
+2003-10-28	Mark_Salyzyn@adaptec.com
+
+install.sh
+	- The entire class of SuSE OS releases (sles7, sles8, suse7, suse8,
+	  suse8.1, suse8.2, ul1, ul1-sp2a) place the driver module results into
+	  /lib/modules/[kernel]/kernel/drivers/scsi/aacraid/aacraid.o. The
+	  package places updates in ...//scsi/aacraid.o (note, one directory
+	  up). The module selected for use in the mkinitrd is fed via a `find'
+	  command which reports files in raw directory order which in the
+	  reiser file system would be in the .../scsi directory, but for EXT2
+	  since the file was added later, would prefer the previously placed
+	  product in ../scsi/aacraid/aacraid.o. The fix is to have the driver
+	  disk post-install remove the older .../scsi/aacraid directory.
+
+2003-10-30	Mark_Salyzyn@adaptec.com
+
+install.sh
+	- For the installations to `extra' /lib/modules directories beyond
+	  the boot set, take the processor clue from the postscript (-athlon,
+	  -x86_64 or -ia64) rather than from /proc/cpuinfo.
+
+Version: 1.1.4-2282
+Version: 1.1.4-2292 (Debug)
+
+2003-10-31	Mark_Salyzyn@adaptec.com
+
+aacraid.h + aachba.c:
+	- Added a nested count to the fsa_scsi_dev structure since some kernels
+	  before 2.4.19 have troubles overflowing their stack when a device
+	  goes offline. The issue is that the SCSI done call nests into sending
+	  another queued command, which in turn spoofs a response back
+	  indicating failure which in turn calls SCSI done. We limit the
+	  nesting to 64 commands before we respond with a busy instead.
+
+Version: 1.1.4-2296 (Debug)
+
+linit.c & .version:
+	- Versioning is defined by the structure:
+	    struct {
+		unsigned char dash; // Dash version number
+		unsigned char type; // Type, 1=Devo, 2=Alpha, 3=Beta, 4=Release
+		unsigned char minor;// Minor version minor
+		unsigned char major;// Major version number
+	    }
+	  Adjusted version data to match this definition for generation and
+	  support.
+
+Version: 1.1.4-2299
+Version: 1.1.4-2301
+Version: 1.1.4-2302
+Version: 1.1.4-2303
+
+linit.c & aacraid.h:
+	- Allow 64 bit apps to call GET_NEXT_ADAPTER_FIB ioctl directly,
+	  promoting 32 bit apps when they call.
+
+aachba.c & aacraid.h:
+	- Set MAX_NESTED to 1, and improve code to reflect this simplicity.
+
+install.sh:
+	- Handle name change of products from *-athlon-athlon to *-athlon.
+	- Warn the user if the initrd shrinks too much
+
+Version: 1.1.4-2308
+
+install.sh:
+	- Add support for identifying 2.4.19-340 kernels.
+
+2003-12-12	Mark Haverkamp <markh@osdl.org>
+
+linit.c:
+	- updated aac_eh_reset to use __shost_for_each_device now that the
+	  device element is now private and we're supposed to use the helper
+	  function for access.
+
+Version: 1.1.4-2309
+Version: 1.1.4-2310 (debug)
+
+2003-12-18	Mark Salyzyn <Mark_Salyzyn@adaptec.com>
+
+linit.c:
+	- suppress unused variable warning in debug code.
+	- cast sys_ioctl when registering as it does not match prototype
+	  argument for ioctl32 registration.
+
+Version: 1.1.4-2311
+
+2003-12-22	Mark Haverkamp <markh@osdl.org>
+
+aachba.c:
+	- change from pae to dac as this is the more public understanding of
+	  the 64 bit support concepts.
+aacraid.h:
+	- Remove padding and SavedIrql
+commsup.c + aachba.c:
+	- use atomic_read when accessing access_count member of device
+	  structure.
+linit.c & aacraid.h
+	- iminor takes the inode, not the inode->i_rdev member.
+
+Version: 1.1.4-2313
+
+aachba.c + commsup.c:
+	- use device_busy, shost_status, in_recovery instead of just
+	  access_count. Adjust for each OS release variant.
+
+Version: 1.1.4-2314
+
+2003-12-22: Ken Beaty <ken@nova.org>
+
+aachba.c + commsup.c:
+	- Adjusted ifdefs for kernel version to make more sense.
+
+2004-01-24: Mark Salyzyn <Mark_Salyzyn@adaptec.com>
+
+install.sh:
+	- Altered script to discover prebuilt binaries from the classic
+	  Adaptec rpm package, the Red Hat install disk format, or the
+	  SuSE install disk format.
+
+2004-02-09: Christoph Hellwig <hch@lst.de>
+
+aachba.c:
+	- Remove fsa_dev structure since fsa_dev is always available.
+
+Version: 1.1.4-2324
+
+2004-02-10: Submit to scsi list for inclusion
+
+2004-02-17: Herve MORILLON <hmorillon@doremilabs.fr> + Mark_Salyzyn@adaptec.com
+
+rx.c + rkt.c:
+	- hit doorbell before processing host_command_normal
+
+aachba.c:
+	- Permit requests larger than 64KB
+
+aacraid.h:
+	- Permit 512 outstanding requests
+
+Version: 1.1.5-2326
+
+linit.c + build:
+	- Added support for vary_io, unfortunately the build system also needed
+	  to be adjusted to generate the SCSI_HAS_VARY_IO if the member is
+	  seen in the drivers/scsi/hosts.h file.
+
+build + install.sh:
+	- Added support for 2.4.19-189, 2.4.19-191 and 2.4.19-201 SuSE Kernels
+
+Version: 1.1.5-2327
+
+rkt.c + rx.c:
+	- Added support to issue the Temperature sync command. Since the
+	  cost of the sync command should not increase, the decision was
+	  made to support a `varargs' approach to dealing with the additional
+	  temperature elements *only* for this command.
+
+linit.c:
+	- Added a proc write that accepts the string "Temperature=[0-9.],..."
+	  to send the off-board temperature value to the Firmware so that it
+	  may be integrated into the Enclosure Data.
+	- Added SkyHawk SATA cards to device list. 2020S changes now to 
+	  2020ZCR, and we add 2020SA.
+
+aachba.c:
+	- PERCRAID RAID-5 is superfluous, changed to to PERC RAID-5.
+
+Version: 1.1.5-2328
+
+linit.c + aacraid.h:
+	- Migrate towards using CONFIG_COMPAT instead of __x86_64__
+
+rx.c + rkt.c:
+	- Added support to pick up an Adapter Blink code. ADPmp64499.
+
+linit.c:
+	- Report the Adapter Blink code to the console log. ADPmp64499.
+
+build:
+	- Correctly built the x86_64 SLES8 and ul1 driver disk. Side effects
+	  discovered also fix problems with ia32 SLES8 install. ADPmp64499.
+
+Version: 1.1.5-2329
+
+linit.c + aacraid.h:
+	- Report an AifExeFirmwarePanic AIF message to applications when the
+	  adapter is in a blinkled state.
+
+aachba.c + commsup.c: Brad House <brad@mainstreetsoftworks.com>
+	- use shost_for_each_device instead of list_for_each_entry.
+
+linit.c + aachba.c:
+	- xscale (arm) systems can not have highmem_io set as virtual/phys
+	  handling does not recognize the page/offset addressing.
+
+rkt.c + rx.c:
+	- The Mailbox[7] in none BBS systems is not active until shortly
+	  before the Firmware kernel is booted. The Outbound Message register
+	  is always active and contains the same bringup conditions. We must
+	  look at the OMR during the *_init wait.
+
+Version: 1.1.5-2330
+
+rkt.c + rx.c + sa.c:
+	- Set the time by using get_seconds (epoch January 1 1970) instead
+	  of jiffies/HZ (epoch machine startup). get_seconds is provided
+	  for kernels < 2.6.
+
+Version: 1.1.5-2331
+
+rkt.c:
+	- Mailbox[7] becomes momentarily inaccessible right after PATUWAIT
+	  on the Callisto, lets loop on OMR only. Do not know if this
+	  problem exists on other systems.
+
+Version: 1.1.5-2332
+
+aachba.c + linit.c:
+	- Issue CT_COMMIT_CONFIG before issuign the VM_NameServe. This is
+	  for systems that do not have a BIOS to perform this step.
+
+Version: 1.1.5-2333
+
+aacraid.h:
+	- SAS requires the ability to handle as many as 32 Adapters in a
+	  system, increased the manifest that limits the number of Adapters.
+	- Testing has shown that allowing 33MB I/O can starve a machine, so
+	  we are limiting the maximum I/O size to 4MB (to match other drivers
+	  that permit large I/O).
+
+linit.c:
+	- Make sure that the driver does not register more than
+	  AAC_MAXIMUM_ADAPTERS instances.
+	- Set the queue depth to each device as divided up from AAC_MAX_IO_FIB
+
+commctrl.c: Chris Wright <chrisw@osdl.org>
+	- aac_send_raw_srb added check for bounding of fibsize value.
+
+all: Mark Haverkamp <markh@osdl.org> & Mark Salyzyn <Mark_Salyzyn@adaptec.com>
+	- merge 2.6 driver changes into tree to synchronize.
+
+Version: 1.1.5-2334
+
+aacraid.h+linit.c+commctrl.c+comminit.c:
+	- Added sg_tablesize and max_fib_size to adapter structure and
+	  negotiate these plus Scsi_Host sg_tablesize, can_queue and
+	  max_sectors based on the adapter capabilities.
+
+aachba.c:
+	- Added aac_raw_io command
+	- Recognize that read_callback is identical to write_callback, which
+	  is in turn identical to raw_io's need for a callback. Renamed to
+	  one callback function io_callback.
+
+rx.c+rkt.c+sa.c:
+	- Moved initialization around to permit New Command Interface probes
+	- dropped irq_mask and associated functions.
+	- moved acknowledgement of F/W commands *before* processing so that
+	  we get re-interrupted if a new command is added to the produced
+	  index while we are processing.
+
+linit.c+aachba.c:
+	- Do not print `bad0' for the serial number
+
+linit.c:
+	- this_id = 32, because it gets in the way of Container 16 being
+	  processed.
+
+aachba.c:
+	- scsi_add_timer call issued just before completion routine called
+	  since error recovery handler is there *just* to detect card
+	  failure and not to affect command processing.
+
+build:
+	- Added 2.4.19.SuSE-343 kernel in support of ul1-sles8-ia32 install,
+	  which adds yet another installation floppy to the list.
+
+Version: 1.1.5-2335
+
+linit.c+all:
+	- Revert temporarily to 1.1.4-2177, Changed ASR-2020S to ASR-2020ZCR,
+	  and ASR-2020S Terminator to ASR-2025ZCR.
+
+Version: 1.1.4-2336
+
+linit.c+all:
+	- Revert temporarily to 1.1.4-2322, Changed ASR-2020S to ASR-2020ZCR,
+	  and ASR-2020S Terminator to ASR-2025ZCR.
+
+Version: 1.1.4-2337
+
+all:
+	- Revert back to 1.1.5 code base.
+
+commsup.c:
+	- Fix Irq Moderation code. A Misnomer, since this is really a PCI
+	  utilization moderation, interrupts are not recurring on F/W.
+
+comminit.c:
+	- Turn on Irq Moderation feature (Tentatively 30% reduction in Host
+	  CPU utilization)
+
+Version: 1.1.5-2337
+
+aacraid.h+commsup.c+dpcsup.c+comminit.c+rx.c:
+	- Added support for the new comm interface.
+
+linit.c:
+	- Added debug information to proc output
+
+Version: 1.1.5-2338
+
+commsup.c: Mark Haverkamp <markh@osdl.org>
+	- Added scsi/scsi_device.h, scsi/scsi_driver.h to include file set
+	- set removable to a value of 1, not to TRUE.
+
+aachba.c: Mark_Salyzyn@adaptec.com
+	- Switch to using max_fib_size rather than FIB_DATA_SIZE_IN_BYTES,
+	  this permits SAS management applications to send ioctl FIBs larger
+	  than 512 bytes in size to adapters that accept larger FIBs.
+	- Added support for SAI_READ_CAPACITY_16, READ_12, WRITE_12, READ_16
+	  and WRITE_16 commands.
+	- Played `tricks' with device_blocked and queue_depth fields in the
+	  scsi_device structure to meter the outstanding commands down when
+	  large sequential activity is detected.
+
+aacraid.h: Mark_Salyzyn@adaptec.com
+	- Remove unused definition of FIB_DATA_SIZE_IN_BYTES.
+
+linit.c:
+	- Setting the maximum number of I/O requests/device to a maximum of
+	  256 would act in the SCSI layer as only allocating to permit 1 I/O
+	  for each device.
+
+Version: 1.1.5-2339
+
+build: Mark_Salyzyn@adaptec.com
+	- Added support for 2.6.4-52 SuSE 9.1 Pro install
+	- Added support for multiple architectures for 2.4.21-15.EL RHEL3 QU2
+	  install.
+
+aacraid.h+aachba.c+linit.c: Mark Haverkamp <markh@osdl.org>
+	- Define 2131 as FSACTL_GET_CONTAINERS
+
+commctrl.c: Adam Manthei <amanthei@redhat.com>, Mark_Salyzyn@adaptec.com
+	- change all printk() to dprintk(()) as this is a user initiated
+	  call for aac_send_rw_srb & aac_get_pci_info.
+
+rx.c+rkt.c: Adam Manthei <amanthei@redhat.com>, Mark_Salyzyn@adaptec.com
+	- use pci_alloc_consistent/pci_free_consistent instead of an
+	  unchecked combination of kmalloc(,_GFP_DMA)/pci_map_single/
+	  pci_unmap_single/kfree.
+
+Version: 1.1.5-2340
+
+linit.c+commctrl.c: Mark Haverkamp <markh@osdl.org>
+	- adjust to reflect linux-scsi submission results
+
+aachba.c: Mark_Salyzyn@adaptec.com
+	- remove print for unhandled commands into a debug print. The
+	  unhandled commands are reported to the caller as unhandled, let
+	  the caller deal with this.
+
+rx.c+rkt.c+sa.c: maximilian attems <janitor@sternwelten.at>
+	- upon failure of the init routine, make sure that the registered
+	  interupt handler is deregistered.
+
+commsup.c:
+	- fib_adapter_complete is supposed to free the hw_fib and that is it,
+	  it tried to talk to hardware and caused a lockup.
+
+Version: 1.1.5-2341
+
+build:
+	- use aacraid.ko for 2.6 releases
+
+Version: 1.1.5-2342
+
+aachba.c: Mark_Salyzyn@adaptec.com
+	- added support for a module parameter 'commit=1' to enable COMMIT
+	  CONFIG to be issued to the adapter.
+	- added support for a module parameter 'coalescethreshold=16' which
+	  sets the maximum block size to consider for pushing back to the
+	  scsi_merge layer.
+	- added support for a module parameter 'acbsize=8192' which sets the
+	  suggested fib size to override the suggestion from Firmare.
+	- dropped call to scsi_add_timer, as it causes a panic. It was placed
+	  in the source to resolve a command completion race condition.
+
+Version: 1.1.5-2343
+
+install.sh: Mark_Salyzyn@adaptec.com
+	- globbing issue caused more whiny complaints about a missing
+	  installation into the initrd.
+	- fixed some issued surrounding using the script for SuSE module
+	  update.
+
+linit.c: Mark_Salyzyn@adaptec.com
+	- if the driver does not discover any targets, report failure.
+	- drop kernel_version hack to support build
+
+build: Mark_Salyzyn@adaptec.com
+	- Use vermagic instead of kernel_version to pick up matching kernel.
+	- when innoculating 2.6 tree builds, one needs a *full* compile in
+	  order to generate the struct_module member.
+	- use module.ko for 2.6 kernels.
+
+Version: 1.1.5-2344
+
+build: Mark_Salyzyn@adaptec.com
+	- floppy linux/suse/${ARCH}-${VERS}/modules/${PRODUCT}.o needs to be
+	  a ${PRODUCT}.ko in the 2.6 based installations.
+	- Placed module in both scsi and scsi/${PRODUCT} directories as it
+	  appears that the post-install is not functioning properly.
+
+aachba.c: Mark_Salyzyn@adaptec.com
+	- Checked if the lba exceeds 32 bit block address for systems that
+	  can not support it. raw_io_64 enables 64 bit block addresses.
+	- Redid math for u64 >> 32 as it appears the xscale 64 bit library
+	  is flawed.
+
+Version: 1.1.5-2345
+
+aachba.c: Mark_Salyzyn@adaptec.com
+	- Overrides to force 8KB fibs needs to be reverted to defaults.
+
+Version: 1.1.5-2346
+
+build: Mark_Salyzyn@adaptec.com
+	- Added 2.4.21-15.0.2.EL kernel
+	- Added 2.6.5-7.97 kernel to the build
+
+rx.c+rkt.c: Mark_Salyzyn@adaptec.com
+	- Mailbox7 continues to be a consternation regarding reliable
+	  adapter recovery scenarios; switched to using OMRx[0].
+
+Version: 1.1.5-2347
+
+aachba.c: Mark_Salyzyn@adaptec.com
+	- (u64)=((u8)<<24) does not give expected results, sign extension
+	  occurs. Replace with (u64)=((u64)(u8)<<24)
+
+Version: 1.1.5-2348
+
+install.sh: Mark_Salyzyn@adaptec.com
+	- initrd is blocked from incorporating our product if there is
+	  something in /lib/modules/${OS}-${CONFIG}/update/${PRODUCT}.o,
+	  so remove the file.
+
+Version: 1.1.5-2349
+
+aachba.c+aacraid.h:
+	- define commit_config FIB command
+	- define get_container_count FIB command.
+
+aachba.c+aacraid.h+commsup.c+linit.c
+	- fsa_dev becomes a dynamic structure to accommodate a variable
+	  maximum_num_containers.
+
+build:
+	- Added 2.4.21-231 kernel to build system.
+
+linit.c:
+	- Turned on debug printing of scsi timeouts for xscale only.
+
+Version: 1.1.5-2350
+
+rkt.c:
+	- Limit can_queue to 246 for rocket
+
+build:
+	- Added 2.4.19-306 kernel to build system.
+
+aachba.c:
+	- Removed an innocuous (obnoxious?) DEBUG printk
+
+2004-07-15: Mark Salyzyn <Mark_Salyzyn@adaptec.com>
+
+Version: 1.1.5-2351
+
+build:
+	- Added 2.4.9-31 to the build system
+
+modules.conf:
+	- Added 2.4.9-e.41, 2.4.9-e.43, 2.4.21-17.EL & 2.4.21-15.0.3.EL kernels
+
+build:
+	- Dropped 2.4.21-231 from build
+
+2004-07-16: Mark Salyzyn <Mark_Salyzyn@adaptec.com>
+
+Version: 1.1.5-2352
+
+build:
+	- Added 2.6.3-7mdk to the build system
+
+2004-07-20: Mark Salyzyn <Mark_Salyzyn@adaptec.com>
+
+Version: 1.1.5-2353 (7t Build w/o SLES9, SuSE9.1 & SuSE9 errata 231)
+Version: 1.1.5-2354 (7t Build w/o SLES9 & SuSE9 errata 231)
+Version: 1.1.5-2355 (BigQual refresh)
+
+install.sh:
+	- If missing, add a reference to the module to the kernel's module.dep
+	  file (affects drivers that are *not* shipped with the OS; HostRAID
+	  and some dpt_i2o)
+
+aachba.c:
+	- for __arm__ build, the default FIB size is selected by F/W and not
+	  overridden to 8192 bytes.
+
+Version: 1.1.5-2356 (Jupiter)
+
+aacraid.h+comminit.c+rkt.c+commsup.c+linit.c: Ken Sandars <Ken_Sandars@adaptec.com> + Mark Salyzyn
+	- Added AAC_NUM_MGT_FIB, and ensured can_queue represents the
+	  maximum number of io commands allowed and not be confused as the
+	  maximum number of FIB commands permitted into the Adapter. Thus
+	  host->can_queue is the maximum number of I/O commands, AAC_NUM_MGT_FIB
+	  is the maximum number of ioctl commands (set to 8 rather than legacy
+	  of 64) and init->MaxIoCommands sent back to the adapter is the total
+	  number of FIBs.
+
+Version: 1.1.5-2357 (Jupiter+BigQual)
+
+commctrl.c: Mark Salyzyn
+	- Added support for issuing FIBs that are larger than the negotiated
+	  size for the management interface.
+
+linit.c: Mark Salyzyn
+	- Added ASR-2240S, ASR-4005SAS, ASR-4000SAS, ASR-4800SAS, ASR-4805SAS
+	  and AAR-2610SA to the product list.
+
+install.sh: Mark Salyzyn
+	- Fixed problems with using the RH & SuSE modules disk as an update
+	  media, most of which was the selection of the extraction name from
+	  the modules.cgz file or acquiring the appropriate update.tar.gz file.
+
+build: Mark Salyzyn
+	- set 700 for update.sh in the modules disks to recognize at least
+	  that the RH modules disk works as an update media.
+
+aachba.c: Mark Salyzyn
+	- Dropped to 8K for the coalesce threshold for xscale builds.
+
+Version: 1.1.5-2358 (BigQual+7t)
+
+aachba.c+commctrl.c+aacraid.h+comminit.c+commsup.c+dpcsup.c+linit.c:
+	- Merged 2.6.8-rc2-bk9 differences into the driver (COSMETIC)
+
+compat.h
+	- Added definition for __user for kernels less than 2.5 (COSMETIC)
+
+linit.c:
+	- The aac_get_next_adapter_fib_ioctl for 64 bit implementations under
+	  2.6 maladdressed the transfer.
+
+Version: 1.1.5-2359 (BigQual+SPOCK+7t)
+
+commctrl.c:
+	- Added support for CODE_STREAM_IDENTIFIER, accessed via a new
+	  ioctl FSACTL_GET_VERSION_MATCHING
+	- Added support for FSACTL_SEND_LARGE_FIB
+
+aacraid.h:
+	- Added definition for struct VersionMatch
+	- Added definition for FSACTL_GET_VERSION_MATCHING
+	- Added definition for FSACTL_SEND_LARGE_FIB
+
+install.sh:
+	- if the modules.dep file does not exist, then ensure no complaints
+	  are made about mv not being able to access the file.
+	- If an entry is missing in modules.dep, construct it correctly.
+
+aachba.c:
+	- Remove any leading spaces from the Container Name. Ensure that
+	  if there is no container name remaining, to leave the existing
+	  one alone.
+
+build:
+	- Added support for 2.4.18-e.43
+	- Added support for 2.4.18-e.47
+	- Added support for 2.4.9-e.48
+	- Added support for 2.4.9-e.49 (RHAS 2.1 QU5)
+	- Added support for 2.4.21-15.0.4.EL
+
+rx.c+rkt.c:
+	- When responding to AIFs, use DoorBellAdapterNormRespReady instead of
+	  DoorBellAdapterNormCmdReady. The code appeared to work without
+	  undue side effects because Firmware would clear off the queues
+	  when new AIFs are delivered.
+
+commsup.c:
+	- If busy, defer scan action to next AIF. Half hearted attempt to
+	  improve the reliability of this unsupported feature.
+
+aacraid.h+linit.c+comminit.c+rx.c+rkt.c+sa.c:
+	- Remove references to Mailbox7 accesses for synchronous commands.
+
+aacraid.h+aachba.c:
+	- Turned on support for Compatibility ID testing. Only enabled if
+	  the build environment defines CODE_STREAM_IDENTIFIER.
+	- Fortify the adapter information to include supplemental information
+	  as well as the GetBusInfo in support of SAS programatic limits.
+
+linit.c+aachba.c:
+	- Use the newly acquired supplement information vendor and product
+	  fields to override the cardtype selection.
+
+Version: 1.1.5-2360
+Version: 1.1.5-2361 (Branch off 1.1.5-2340 in RHEL3 QU3 with aac_info fix in 1.1.5-2364)
+
+linit.c:
+	- register a reboot notifier to flush adapter
+	- faked AIF needs to call fib_init() later (ADPmp70525)
+
+commctrl.c:
+	- Since kfree has the possibility of switching in some esoteric
+	  variants of the kernel, and since the BKL is held during ioctl
+	  calls, we are unlocking the fib lock around these system calls.
+
+Version: 1.1.5-2362
+
+build:
+	- Added support for 2.4.21-17.EL (RHEL3 QU3 beta)
+	- Added support for 2.4.21-20.EL (RHEL3 QU3)
+	- Added support for 2.6.7-1.451.2.3 (RHEL4 alpha 4)
+
+linit.c:
+	- ASR4000 series entries were flawed in the indexes. Added an
+	  additional 8i entry.
+
+Version: 1.1.5-2363
+
+linit.c:
+	- aac_info is flawed and causes periodic panics in certain systems.
+
+build:
+	- Allow the build system to operate as background build
+	- em64t/ia32e binaries did not show in the rpm
+
+Version: 1.1.5-2364 [BigQual, Pratt, Jupiter Dual & 7t]
+
+linit.c:
+	- AAR-2610SA has had a subproduct change from 0x103C/0x0295 to
+	  0x103C/0x3227.
+	- Some adapters have internal limits of 34 SG elements as a result
+	  of a bug of not splitting requests up when cache is disabled when
+	  sending them to the CHIM. Created a quirk for the adapters that
+	  have this limit.
+
+Version: 1.1.5-2365
+
+aachba.c:
+	- Neglected to add maximum_num_physical check to the srb handler.
+	- leading space on inquiry code was flawed as a result of a typographic
+	  error (replace ! with *)
+
+linit.c:
+	- ASR-4005SAS for IBM is designated as an 8i (ADPmp71521)
+	- Added check for late completion of command during timeout
+	- called aac_get_fw_debug_buffer() after init
+
+fwdebug.c+fwdebug.h
+	- Added firmware debug print handlers
+
+build:
+	- RH floppy disk was limited to 864KB, let it open up to 1.4MB. The
+	  risk is that 864KB was about all the ramdisk could handle when
+	  extracting, so we will no longer get a report of disk overrun as
+	  a warning to existing OS releases. We do not know what will overload
+	  the ramdisk during install. (ADPmp72476)
+	- Product ID list for aacraid is broken in the build due to changes
+	  resulting from incorporating the 2.6 tree.
+	- em32t binaries did not show in the rpm fix broke SuSE releases that
+	  utilize the 2.4.19 kernel (ADPmp73104)
+
+commsup.c:
+	- Added support for sending the time every 30 minutes.
+
+Version: 1.1.5-2366
+
+commctrl.c:
+	- Fixed 64 bit version of the SCB ioctl call as it was not translating
+	  the 32 bit scatter-gather correctly for scatter gather elements
+	  beyond the first one. Do not believe this issue presented a problem
+	  for any Adaptec management products due to their needs as they
+	  limited their SG to only one entry.
+
+build:
+	- Added 2.4.19-238
+	- Added 2.4.19-241
+	- Added 2.4.19-248
+	- Added 2.4.19-251
+
+Version: 1.1.5-2367
+
+linit.c:
+	- Added Themisto discovery to driver
+	- Added AAC_QUIRK_MASTER and AAC_QUIRK_SLAVE to deal with controller
+	  pairs.
+	- Changed Prowler "ESD SO-DIMM PCI-X SATA ZCR" to "ASR-2026ZCR".
+	- Return FAILED when hba_reset completed, the ten second bus settling
+	  delay is counter productive.
+
+aacraid.h+linit.c: Christoph Hellwig <hch@lst.de>
+	- drop casting surrounding iomap and ioremap and use the __iomem
+	  type enhancement.
+
+csmi.c+csmi.h:
+	- Added CSMI ioctl support.
+
+install.sh:
+	- log both successful and failed installations and limit complaints
+	  about installation to a minimum by not repeating similar failure
+	  messages.
+
+aachba.c:
+	- vtune reports that 2% of the time dealing with read calls was
+	  devoted to get_sd_devname(). Optimized codepath.
+
+Version: 1.1.5-2368
+
+build:
+	- Added 2.4.27 debian smp kernel to build
+	- Added 2.6.7-1.451.2.3 RHEL4 alpha 4 to the build
+	- Added 2.6.8-1.602 RHEL4 beta 1 to the build
+	- Added 2.6.5-7.109.5 SuSE 9.1 errata to the build
+
+csmi.h:
+	- Changed from CSMI_8_BYTE_ALLIGNED to CSMI_8_BYTE_ALIGNED
+
+csmi.c:
+	- failure on return from copy_to_user is ignored, but (void) is
+	  not the way to ignore it based on compiler warnings.
+	- scb size is set to 16 always.
+	- scb flags is set to 0 always.
+
+linit.c+compat.h:
+	- scsi_sleep() renamed to ssleep() in 2.6.9 kernel
+
+commctrl.c:
+	- 32 bit application issuing a raw srb in a 64 bit address space
+	  is not handled correctly for the fibsize calculation.
+	- Limit the number of scatter gather entries to 32, and zero
+	  out the references to those sg entries.
+
+Version: 1.1.5-2369
+
+compat.h:
+	- 2.6.8-1.602 RHEL4 beta 1 kernel looks more like 2.6.9, so needed to
+	  define scsi_sleep for kernels 2.6.8 and up rather than 2.6.9 and up.
+
+linit.c: Chris Trown <ctrown@uoregon.edu>
+	- Added an include for linux/delay.h to pick up the definition of
+	  ssleep().
+	- Added `other' Themisto ID to list.
+
+csmi.h:
+	- bumped to 0.83 version
+
+csmi.c:
+	- Acquired slot number from Supplementary Adapter Info SlotNumber
+	  field
+	- Added support to determine the actual bus type (SAS, SATA, Other).
+
+build:
+	- Added support for 2.4.21-22.EL (RHEL3 errata)
+	- Added support for 2.6.5-7.111 (SLES9 NLD)
+	- Added support for 2.4.21-243 (SuSE 9.x errata)
+
+aachba.c:
+	- valid must clear if VM_Nameserve fails on scan
+	- setinqstr has the possibility of overflowing the inquiry structure,
+	  the results are a damaged stack.
+
+commsup.c:
+	- do a probe_container before issuing scan as the adapter can take
+	  some time to write DDF data (not SCSI).
+
+aacraid.h:
+	- added definition of probe_container.
+
+Version: 1.1.5-2370
+
+aacraid.h+commsup.c+aachba.c+commctrl.c+comminit.c+linit.c+sa.c: Adrian Bunk <bunk@stusta.de>
+	- Make some needlessly global code static
+
+linit.c:
+	- Added Intruder (AAR-2420SA, AAR-2620SA & AAR-2820SA)
+
+aachba.c+commsup.c:
+	- Enable a 50 second timeout on the first asynchronous command to
+	  permit the driver to error out and report the hardware failure.
+
+linit.c:
+	- Fixed a comment completion problem for Intruder additions.
+
+build:
+	- Added support for 2.6.8-24 (SuSE 9.2)
+
+Version: 1.1.5-2371
+
+aachba.c: Jens Axboe
+	- Use a busy status return with scsi_done rather than -1 to
+	  signal OS to try again later for aac_read and aac_write to
+	  meet with acceptable coding standards.
+
+aachba.c+linit.c: Mark Salyzyn & Christoph Hellwig <hch@infradead.org>
+	- Moved AAC_EXTENDED_TIMEOUT to set sdev->timeout instead of
+	  inline for every command in the 2.6 variant.
+
+linit.c:
+	- There is a subsystem device id clash between SATAHAWK and INTRUDER
+	  and is giving the BIOS group some grief. Therefore the subsystem
+	  device ID for intruder is changed to 029B, 029C and 029D for 8, 6,
+	  and 4 port versions respectively.
+	- Added FSACTL_GET_VERSION_MATCHING and FSACTL_SEND_LARGE_FIB ioctls to
+	  list of supported 32 bit ioctl calls.
+
+build:
+	- enhanced README.txt to also provide a brief description of the
+	  binary file.
+	- Added support for a RHEL3 i686 ISO image as well.
+	- Added support for 2.6.5-7.109.12 (SLES9/SuSE9.1 SP1 B2 i386)
+	- Added support for 2.6.5-7.109.13 (SLES9/SuSE9.1 SP1 B2 x86_64)
+	- Added support for 2.6.5-7.115 (SLES9/SuSE9.1 SP1 B3)
+	- Added support for 2.6.5-1.358 (RH FC2)
+	- Added support for 2.6.9-1.667 (RH FC3)
+	- Added support for 2.4.21-260 (SuSE 9 errata)
+	- Added support for 2.4.21-261 (SuSE 8 errata)
+
+csmi.c:
+	- return code for CSMIGetSATASignature is under the control of the
+	  firmware and should not be blindly set to SUCCESS if the command
+	  succeeded.
+
+
+Version: 1.1.5-2372
+
+build:
+	- Added support for 2.6.9-1.648_EL (RHEL4 beta 2)
+
+linit.c:
+	- trim space from Model
+
+install.sh:
+	- Add /etc/modprobe.conf as another modules configuration file.
+	- If the module in the initrd does not match, but has the same
+	  `size' values, then report a `possibly stripped' warning message.
+
+Version: 1.1.5-2373
+
+build:
+	- Use "Avon Park SIT" for this build for the version identifier
+
+commsup.c:
+	- enable scsi-scan-single (ADPmp75534 & ADPmp69336)
+
+Version: 1.1.5-2374
+
+build:
+	- Added support for 2.6.5-7.111.5 (SLES9 NLD errata)
+	- Added support for 2.6.5-7.128 (SLES9 SP1 B4)
+	- Added support for 2.6.5-7.134 (SLES9 SP1 RC)
+	- Added support for 2.6.9-1.906_EL (RHEL4 RC)
+
+commsup.c:
+	- disable scsi-scan-single for 2.6 kernels, proc_scsi no longer
+	  exported
+
+install.sh
+	- Missed a double quote in the scripting to reduce size sensitivity.
+
+Version: 1.1.5-2375 (Avon Park SIT)
+
+csmi.c:
+	- Paramters.uFlags is a bit field, not a state.
+	- cdbLength needs to be hard coded to 14 from 16 (beware, 2TB warning).
+	- Set the srbFlags based on data direction or if there is any data to
+	  send at all (HOST_FLAGS_DATA_IN/DATA_OUT/NO_DATA_TRANSFER).
+
+csmi.h:
+	- Added definition for HOST_FLAGS_DATA_IN/DATA_OUT/NO_DATA_TRANSFER.
+
+Version: 1.1.5-2376 (This is a code stream identifier)
+
+linit.c:
+	- Added ICP Lancer products ICP9024R0 and ICP9014R0.
+	- Added include of asm/ioctl32.h
+	- Report ServeRAID for driver name if IBM 8i.
+
+aacraid.h
+	- Added definition for IOP_RESET synchronous command
+
+rkt.c+rx.c+linit.c+aacraid.h+commsup.c+aachba.c+csmi.c+comminit.c+commctrl.c+compat.h
+	- Merged code and style changes in 2.6.10-rc3-bk14 into codebase.
+
+aachba.c:
+	- set the scsi device as removeable during the Read Capacity call.
+	  (ADPmp76369)
+
+pci.ids:
+	- Submitted patch to pci-ids@ucw.cz to update the vital product list
+	  to match the products in the linit.c file (ADPmp77082)
+
+build:
+	- Added support for 2.4.21-20.0.1.EL (RHEL3 errata)
+	- Added support for 2.4.21-27.EL (RHEL3 QU4)
+	- Added support for 2.4.21-27.0.1.EL (RHEL3 errata)
+
+Version: 1.1.5-2377 (Avon Park SIT)
+
+linit.c:
+	- Dropped the maximum number of commands down to 16 per target if on
+	  an x86_64 machine with more than 4GB of memory when built in the
+	  2.4.* environment.
+
+Version: 1.1.5-2378 (CERC Test)
+
+linit.c:
+	- Dropped the maximum number of commands down to 10 per target for
+	  this test.
+
+Version: 1.1.5-2379 (CERC Test)
+
+build:
+	- Added support for 2.6.9-5.EL (RHEL4 RC)
+	- Added support for 2.6.5-7.139 (SLES9 SP1)
+	- Added support for 2.4.9-e.57 (RHAS QU6)
+	- Added support for 2.4.9-e.59 (RHAS QU6 errata 59)
+
+commsup.c:
+	- Added kernel ifdef's to handle scsi_add_target and
+	  scsi_remove_target calls.
+
+aachba.c+aacraid.h:
+	- Added AAC_DEBUG_INSTRUMENT_DAC_CERC to disable 64 bit scatter gather
+	  for only the CERC SR2 product.
+
+Version: 1.1.5-2380 (This is a code stream identifier)
+
+aachba.c+comminit.c:
+	- Added numacb insmod parameter.
+
+aachba.c+aacraid.h
+	- Remove AAC_DEBUG_INSTRUMENT_DAC_CERC code.
+
+build:
+	- Error in incorporating the RHAS2.1 QU6 kernel (2.4.9-e.57) on to the
+	  driver disk (ADPmp78010)
+	- Same problem with RHEL4 RC (2.6.9-5.EL) (ADPmp69861)
+
+Version: 1.1.5-2381 (This is a code stream identifier)
+
+build:
+	- Added support for 2.4.21-273 (SLES 8 errata 273)
+	- Added support for 2.6.5-7.111.30 (SLES 9 errata 30)
+	- Added support for 2.6.8-24.11 (SuSE 9.2 errata 11)
+	- Added support for 2.4.19.SuSE-256 (SLES8 x86_64 errata 256)
+	- Added support for 2.4.21-9.EL (RHEL3 QU1)
+	- Added support for 2.6.8.1-12mdk (Mandrake 10.1)
+	- Added support for 2.6.9-1.11_FC2 (FC2)
+	- Added support for 2.6.10-1.9_FC2 (FC2)
+	- Updated dkms to v2.0.5
+
+commsup.c+aacraid.h
+	- Changed Plug-n-Play state machine to be per-array rather than
+	  per-adapter (ADPmp77096)
+
+Version: 1.1.5-2382 (This is a code stream identifier)
+
+build:
+	- Added support for 2.4.21-276 (SLES8/UL1 SP4 B2)
+	- Added support for 2.6.10-1.8_FC2 (FC2)
+	- Added support for 2.6.10-1.12_FC2 (FC2)
+	- Added support for 2.6.9-1.681_FC3-2.6 (FC3)
+	- Added support for 2.6.9-1.724_FC3-2.6 (FC3)
+	- Added support for 2.6.10-1.737_FC3-2.6 (FC3)
+	- Added support for 2.6.10-1.741_FC3-2.6 (FC3)
+	- Added support for 2.6.10-1.760_FC3-2.6 (FC3)
+
+linit.c:
+	- vmware specifically utilizes the file->private_data. They will be
+	  correcting the problem in future releases thus the fix will work
+	  in both environments being obnoxious^H^H^H^H^H^H^H^H^Hinnocuous in
+	  the later releases.
+
+aachba.c:
+	- vmware has problems with the coalescing code.
+
+commctrl.c:
+	- used sizeof(struct sgmap *) instead of sizeof(struct sgmap) and
+	  misrepresented the size of the srb command truncating the scatter
+	  gather size from the incoming data in 64 bit architectures with
+	  more than 4G of memory populated in the system. (ADPmp78515,
+	  ADPmp78128, ADPmp76236 & ADPmp78228)
+
+Version: 1.1.5-2383 (Avon Park SIT)
+
+Makefile:
+	- Self detect the various SCSI_HAS_* flags rather than depending on
+	  the build system to generate them.
+
+aacraid.h+aachba.c
+	- Added VM_NameServe64
+	- Added capacity64 field to end of the mnt information.
+	- Do not respond to SERVICE_ACTION_IN when card not capable of 64 bit
+	  lba.
+
+commctrl.c:
+	- The srbcmd in 64 bit environments with more than 4GB of memory
+	  are utilizing the sgentry64 elements for the scatter gather, thus
+	  the counts were not parsed correctly when copying the data back
+	  to the user. (ADPmp78846)
+
+build:
+	- Removed support for linux-2.4.21-1.1931.2.349.2.2.ent.RH
+	- Removed support for linux-2.4.21-1.1931.2.393.ent.RH
+	- Removed support for linux-2.4.21-1.1931.2.399.ent.RH
+	- Removed support for debug configurations
+	- Split AS2.1 summit/enterprise from up/smp
+	- pcitable for aacraid driver disk is missing " after the ICP cards
+
+Version: 1.1.5-2384 (Avon Park SIT)
+
+aacraid.h+rkt.c+rx.c+sa.c:
+	- use aac_io_cpu_to_le* and aac_io_le*_to_cpu to deal with perceived
+	  discrepancies in write* and read* io handlers.
+
+commsup.c+commctrl.c:
+	- header.Size and header.SenderSize is a 16 bit field, erroneously
+	  handled by 32 bit swap handlers.
+
+commsup.c+comminit.c+commctrl.c+aachba.c+dpcsup.c:
+	- missing swap handlers for various packets.
+
+aachba.c:
+	- When 'first' command times out, return error immediately, do not
+	  fall through.
+
+csmi.c+aachba.c+linit.c:
+	- monitor/kernel/build information from adapter needs to be swapped
+	  in BE architectures.
+
+aachba.c:
+	- Revert 64 bit LBA code
+
+Version: 1.1.5-2385 (Avon Park SIT)
+Version: 1.1.5-2386 (Avon Park SIT, revert to 1.1.5-2383, plus one managment change)
+
+aachba.c+linit.c+compat.h: Tobias Klauser <tklauser@nuerscht.ch>
+	- Use the DMA_{64,32}BIT_MASK constants
+
+linit.c:
+	- scsi_host_alloc calls scsi_register which prints a report in some
+	  versions of the 2.4 kernel. The aac_info function is not ready to
+	  be called at that time as the hostdata has not been set up, so we
+	  report a 'default' name of "AAC" (ADPmp78060).
+
+aacraid.h+aachba.c:
+	- Adding any u64 to a structure will cause, in some cases of the
+	  compiler, 8 byte alignment constraints which can reshape the
+	  structure at each element even before the u64 definition. Changed to
+	  using a pair of u32's for capacity64 element in the mount structure.
+	  (ADPmp79142)
+
+Version: 1.1.5-2387 (This is a code stream identifier)
+
+build:
+	- Added support for 2.4.21-277 (SLES8/UL1 SP4 RC1)
+
+aacraid.h+rx.c+rkt.c+sa.c+linit.c+Makefile:
+	- Added support for dump_poll. Currently RHEL4 and RHFC support this
+	  new interface. (ADPmp79442)
+
+Version: 1.1.5-2388 (This is a code stream identifier)
+
+compat.h+aachba.c+aacraid.h+commctrl.c+comminit.c+commsup.c+dpcsup.c+linit.c:
+	- Merged code and style changes in 2.6.11-rc5-bk3 into codebase.
+
+linit.c:
+	- Added support for shost_attrs & sysfs.
+
+linit.c+csmi.c:
+	- Dropped reference to Red Hat in printouts (ADPmp79559 & ADPmp79382)
+
+build:
+	- Strip kernel environment check for sourceball that is part of the
+	  DKMS packaging, broke DKMS build environment (ADPmp79708)
+
+Version: 1.1.5-2389 (This is a code stream identifier)
+
+build:
+	- Switch from 3.3 compiler to 3.4 for RHEL4 ia64 and FC3 all archs
+	  & all errata.
+	- Added support for 2.4.18-19.7.x (RH7.3 errata 19)
+
+linit.c: Domen Puncer <domen@coderock.org>
+	- Change from pci_module_init to pci_register_driver.
+
+linit.c:
+	- Loop for determining unique_id failed and generates a pattern of
+	  0, 1, 0, 0, ... (ADPmp79694)
+	- Added ICP9047MA and ICP9087MA to product probe. Added AvonPark Lite.
+
+linit.c+aachba.c:
+	- An SG list of 1K,4K,...,4K,64K+4K-1K got produced, the math for the
+	  maximum I/O should be (sg_tablesize * 8) + 112 instead.
+
+rkt.c+rx.c:
+	- Adapter Panic handler has AAC_IO_USES_CPU_ORDER misspelled.
+
+commsup.c:
+	- time stamp is an u32, not an unsigned long.
+
+csmi.c:
+	- Send LoopCount rather than bufferOffset to param[4] of GetRAIDConfig
+	  command. (ADPmp77631, ADPmp79282)
+
+Version: 1.1.5-2390 (This is a code stream identifier)
+
+build:
+	- Added support for 2.4.21-278 (SLES8/UL1 SP4 RC3)
+	- Removed support for 2.4.21-276
+	- Removed support for 2.4.21-277
+	- Removed support for 2.4.18-24.7.x (RH7.3 errata 24)
+	- Removed support for 2.4.18-26.7.x (RH7.3 errata 26)
+	- Removed support for 2.6.10-1.741_FC3-2.6 (FC3 errata 741)
+	- Dropped all the sles9-sp1 betas from the packaging.
+	- strip date stamps, then join.file the patches before commiting them
+	  to the archive.
+
+modules.equiv
+	- Declared 2.4.21-277 to be identical to 2.4.21-278
+	- Declared 2.4.18-24.7 to be identical to 2.4.18-19.7
+	- Declared 2.4.18-26.7 to be identical to 2.4.18-19.7
+	- Declared 2.6.10-1.737_FC3-2.6 to be identical to 2.6.10-1.741_FC3-2.6
+
+linit.c:
+	- return code from pci_register_driver() is not of the same form
+	  as pci_module_init. Only negative return values should be reported
+	  as an error.
+
+install.sh:
+	- Added /etc/grub.conf to list of grub files
+	- redirect error on boot configuration file awk script for cases when
+	  boot configuration file is not found.
+
+Version: 1.1.5-2391 (This is a code stream identifier)
+Version: 1.1.5-2392 (Branch off 1.1.5-2372 with pci_unregister_driver if aac_count drops to zero).
+
+build:
+	- Added support for 2.6.10-1.14_FC2-2.6 (RH FC2 Errata 14)
+	- Added support for 2.6.10-1.770_FC2 (RH FC2 Errata 770)
+	- Added support for 2.6.10-1.766_FC3-2.6 (RH FC3 Errata 766)
+	- Added support for 2.6.10-1.770_FC3-2.6 (RH FC3 Errata 770)
+	- Removed support for 2.6.10-1.9_FC2 (FC2) and placed in
+	  module.equiv
+	- Removed support for 2.4.18-e.47 (RHAS 2.1 IA64) and placed in
+	  module.equiv
+	- Added support for 2.4.18-e.52 (RHAS 2.1 IA64) in module.equiv
+	- Added support for 2.4.18-e.54 (RHAS 2.1 IA64) in module.equiv
+	- Generate dkms package with build number, but add a Branch Type
+	  of "dkms" into the version information reported by the driver.
+	- Generate source package with a Branch Type of "custom" into the
+	  version information reported by the driver.
+	- build rpm packages as 'noarch' and not as default of the build
+	  system 'i386'.
+
+csmi.c:
+	- uMaxDrivesPerSet needs to be acquired from the Firmware,
+	  rather than using the driver physical limits (ADPmp80188)
+
+aachba.c:
+	- Added some new container types (RAID5D, RAID5D0, RAID1E, RAID6
+	  and RAID60) to default array naming list.
+	- Changed over to new format of VM_NameServe64 (changed before
+	  customer release of Firmware that utilized interim format).
+
+linit.c:
+	- Added Hurricane ASR-4810SAS
+	- Added sensitivity to AAC_DRIVER_BRANCH in order to propogate
+	  driver source with keys as to their history.
+
+linit.c: (Mark Haverkamp <markh@osdl.org>
+	- Restructured sys handler to match standards expectations.
+	  ADPmp80589
+
+install.sh:
+	- Do not compare result in initrd to any backup orig drivers
+	  that may have been left in the /lib/modules tree.
+	- Added support for elilo.efi
+
+commsup.c+comminit.c:
+	- pci_alloc_consistent acquired GFP_DMA arena pool. This has
+	  been shown as a problem on 2.4 based kernels on em64t machines
+	  with > 4GB of memory which typically exhaust the DMA pool. So,
+	  prior to making the call, we will acquire GFP_ATOMIC
+	  memory first and check if it is 31BIT limited, and instead use
+	  that memory rather than resorting to the precious DMA pool. The
+	  other workarounds are to limit the memory to 4GB, set the
+	  memsize to 4GB, or to tell the SW IOMMU to reduce it's memory
+	  requirements (swiotlb=12288).
+
+Version: 1.1.5-2393 (This is a code stream identifier)
+
+linit.c+commctrl.c:
+	- Added AAC_DEBUG_INSTRUMENT_IOCTL_SENDFIB
+
+linit.c: Ming Zhang <mingz@ele.uri.edu> & Mark Salyzyn
+	- Set max_cmd_len to 16 to permit SAI_READ_CAPACITY_16 call to
+	  get through the scsi layer to the driver.
+
+linit.c:
+	- Added calls to csmi_register_ioctl32_conversion() and
+	  csmi_unregister_ioctl32_conversion()
+
+csmi.c:
+	- Added csmi_register_ioctl32_conversion(void) and
+	  csmi_unregister_ioctl32_conversion(void)
+
+install.sh:
+	- notice that we are doing an ELILO configuration on ia64
+
+aachba.c:
+	- Removed sundry debugging prints
+
+build:
+	- Added MODULES_CONF_OBSOLETES_ONLY[0]="${PRODUCT}" to dkms.conf
+	- Added support for 2.6.5-7.147 (SLES9 SP1 errata 147) to
+	  modules.equiv
+	- Added support for 2.6.5-7.151 (SUSE9.1 SP1 errata 151) to
+	  module.equiv
+	- Added support for 2.4.21-278-x86_64 (SLES8 SP4 64 bit)
+
+Makefile:
+	- Use TOPDIR instead of AAC_ROOT
+
+Version: 1.1.5-2394 (This is a code stream identifier)
+
+build:
+	- Added support for 2.4.20-133 (SuSE 8.2 errata 133)
+	- Added support for 2.4.21-286 (SuSE 9.0 errata 286) to modules.conf
+	- Added support for 2.6.8-24.14 (SuSE 9.2 errata 14)
+	- Added support for 2.6.9-5.0.3.EL (RHEL4 errata 3)
+	- Added support for 2.6.9-6.37.EL-2.6 (RHEL4 U1 beta)
+	- Added support for 2.6.10-1.771_FC2 (FC2 errata 771)
+	- Added support for 2.6.11-1.14_FC3 (FC3 errata 773)
+	- Added support for 2.4.21-31.EL (RHEL3 QU5 beta)
+
+aachba.c+linit.c: Tobias Klauser <tklauser@nuerscht.ch> & Domen Puncer <domen@coderock.org>
+	- added include for linux/dma-mapping.h
+
+linit.c: Konstantin Khorenko <khorenko@sw.ru>
+	- aac_info and aac_detect need to be active on in-kernel
+	  versions of the driver.
+
+linit.c:
+	- aac_show_flags is a newline separated list
+	- Added SAI_READ_CAPACITY_16 to list of possible flags in
+	  aac_show_flags
+	- aac_get_adapter_info status needs to be placed in the 'error'
+	  variable to unload correctly and deinit rather than unmap
+	  (ADPmp83209).
+
+commsup.c:
+	- allocate 8 more NewFibs than noticed to deal with high AIF
+	  traffic.
+	- Added support for wait=-2 to do a 'silent' timeout of a
+	  command.
+	- Increased the timeout for wait<0 to 3 minutes from 50 seconds
+	  due to paranoia (ADPmp83209)
+
+comminit.c:
+	- issue the adapter shutdown with a wait=-2 value (ADPmp78635)
+
+aacraid.h+rx.c+rkt.c+sa.c+linit.c:
+	- Added a disable_interrupt method to prevent future adapter
+	  interrupts when shut down. Call this method before free_irq(),
+	  preferably before dealocating structures. (ADPmp83209)
+
+commsup.c+comminit.c:
+	- revert out the GFP_KERNEL kmalloc call to see if it reports an
+	  address <2GB instead of using pci_alloc_consistent. Fix this
+	  another day. (ADPmp83209)
+
+Version: 1.1.5-2395 (This is a code stream identifier)
+
+build:
+	- Added support for 2.6.5-7.162 (SLES9 sp2 beta1)
+
+aachba.c+linit.c+aacraid.h+commsup.c+comminit.c+dpcsup.c:
+	- Merge differences in the 2.6.12-rc2 kernel.org branch of the
+	  driver.
+
+linit.c:
+	- Added ICP9085LI & ICP5085AU
+	- Modified support for ASR4810SAS
+
+aacraid.h+commsup.c:
+	- If ROMB heritage adapter, enable printf
+
+Version: 1.1.5-2396 (Avon Park SIT)
+
+build:
+	- Added support for 2.6.11.4-20a (SUSE 9.3)
+	- Added support for 2.6.9-5.0.3.EL-2.6 (CentOS4) to driver disks
+	- Added support for 2.6.9-5.0.5.EL (RHEL4 Errata 5) to
+	  modules.equiv
+	- Added support for 2.4.21-27.0.2.EL-2.4 (CentOS3) to driver
+	  disks
+
+linit.c+aacraid.h:
+	- Merge differences in the 2.6.12-rc2 kernel.org branch of the
+	  driver.
+
+linit.c:
+	- str() did not do the right thing, needed to nest macros.
+
+aachba.c+aacraid.h+commctrl.c+comminit.c+commsup.c+dpcsup.c+linit.c: Mark Haverkamp <markh@osdl.org>
+	- Remove sparce warnings
+
+readme.txt(dkms):
+	- Added strings for 'ips' driver
+	- Added documentation on how to make a 'suse' driver disk
+
+Version: 1.1.5-2397 (This is a code stream identifier)
+
+build:
+	- sort distributions when code has to cut the products into
+	  pieces.
+
+commctrl.c:
+	- byte_count is converted from le32 to cpu, then again when used
+	  in the following line. Dropped the second le32_to_cpu call. No
+	  side effects in an LE machine.
+
+linit.c:
+	- MODULE_VERSION limited to 2.6.4 and higher
+
+Version: 1.1.5-2398 (Avon Park SIT)
+Version: 1.1.5-2399 (This is a code stream identifier)
+
+build:
+	- Added linked equivalent entries for multi-OS driver disk
+	  images in driverdisks tarball
+	- dkms package versioning is ${VERSION}.${REVISION}.${BUILD} as
+	  required by DKMS and changed the tarball package name to
+	  ${VERSION}.${REVISION}-${BUILD} to match the other build
+	  product names. Adjusted dkms documentation to match.
+	- Added support for 2.4.21-27.0.4.EL-2.4 (RHEL3 QU4 Errata 4) to
+	  modules.equiv
+
+install.sh
+	- RHEL3, RHEL4, FC2 and FC3 all can add a -2.4 or -2.6 into the
+	  kernel name that does not match the /lib/modules/kernel names.
+
+Version: 1.1.2-2400 - 1.1.2-lk2 + LARGE_FIB patch
+Version: 1.1.5-2400 (Enzo)
+
+build:
+	- Added support for 2.6.5-7.104 (SLES9 errata) to module.equiv
+	- Added support for 2.6.5-7.108 (SLES9 errata)
+	- Added support for 2.4.21-169 (SLES8 errata)
+	- Added support for 2.4.21-190 (SLES8 errata) to module.equiv
+	- Added support for 2.4.21-192 (SuSE 9 errata) to module.equiv
+	- Added support for 2.4.21-196 (SLES8 errata) to module.equiv
+	- Added support for 2.4.21-198 (SLES8 errata) to module.equiv
+	- Added support for 2.4.21-199 (SuSE 9 errata)
+	- Added support for 2.4.21-202 (SuSE 9 errata) to module.equiv
+	- Added support for 2.4.21-207 (SLES8 errata) to module.equiv
+	- Added support for 2.4.21-215 (SLES8 errata) to module.equiv
+	- Added support for 2.4.21-226 (SuSE 9 errata) to module.equiv
+	- Added support for 2.4.21-238 (SuSE 9 errata) to module.equiv
+	- Added support for 2.4.21-280 (SLES8 errata) to module.equiv
+	- Added support for 2.6.8-24.3 (SuSE 9.2 errata 3)
+	- Added support for 2.4.9-e.62 (RHAS2.1 QU7)
+	- Switched support for 2.4.19-340 to module.equiv
+	- 2.6.5-7.162 had the wrong .config entries, CONFIG_RELEASE="0"
+	  instead of "7.162"
+
+Version: 1.1.5-2400 (This is a code stream identifier)
--- linux-2.6.8.1-t043-libata-update/drivers/scsi/aacraid/csmi.c	1970-01-01 03:00:00.000000000 +0300
+++ aacraid-drv/drivers/scsi/aacraid/csmi.c	2005-04-20 23:18:38.000000000 +0400
@@ -0,0 +1,1679 @@
+/*
+ *	Adaptec AAC series RAID controller driver
+ *	(c) Copyright 2004 Adaptec, Inc
+ *
+ * Copyright (c) 2004 Adaptec, Inc. (aacraid@adaptec.com)
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; see the file COPYING.  If not, write to
+ * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Module Name:
+ *   csmi.c
+ *
+ * Abstract: All CSMI IOCTL processing is handled here.
+ */
+
+/*
+ * Include Files
+ */
+
+#include <linux/types.h>
+#include <linux/wait.h>
+#include <linux/spinlock.h>
+#include <asm/semaphore.h>
+#include <linux/kernel.h>
+#include <linux/blkdev.h>
+#include <linux/completion.h>
+#include <linux/string.h>
+#include <linux/sched.h>
+#include <linux/pci.h>
+#include <asm/uaccess.h> /* For copy_from_user()/copy_to_user() definitions */
+#include <linux/slab.h> /* For kmalloc()/kfree() definitions */
+#include "aacraid.h"
+#include "fwdebug.h"
+#include <linux/version.h> /* For the following test */
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
+# include "scsi.h"
+# include "hosts.h"
+#else
+# include <scsi/scsi.h>
+# include <scsi/scsi_host.h>
+# include <linux/pci.h>
+# include <linux/dma-mapping.h>
+#endif
+#if ((LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)) ? defined(__x86_64__) : defined(CONFIG_COMPAT))
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,3))
+#include <linux/syscalls.h>
+#include <linux/ioctl32.h>
+#endif
+#if ((KERNEL_VERSION(2,4,19) <= LINUX_VERSION_CODE) && (LINUX_VERSION_CODE <= KERNEL_VERSION(2,4,21)))
+# include <asm-x86_64/ioctl32.h>
+#elif (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
+# include <asm/ioctl32.h>
+#elif (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,3))
+# include <linux/ioctl32.h>
+#endif
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
+# include <asm/uaccess.h>
+#endif
+#endif
+
+#if (defined(AAC_CSMI))
+
+#include "csmi.h"
+
+
+/*
+ * Routine Description:
+ *	This routine will verify that the *ppHeader is big enough
+ *	for the expected CSMI IOCTL buffer.
+ * Return Value:
+ *	ppHeader
+ *	0 - Success ppHeader set up with successful completion code
+ *	!0 - CSMI_SAS_STATUS_INVALID_PARAMETER as the ReturnCode.
+ */
+static int
+aac_VerifyCSMIBuffer(
+	struct aac_dev ** pDev,
+	void __user * arg,
+	unsigned long csmiBufferSizeToVerify,
+	PIOCTL_HEADER * ppHeader)
+{
+	u32 Length;
+	int Rtnval;
+	struct aac_dev * dev = *pDev;
+	extern struct list_head aac_devices; /* in linit.c */
+
+	fwprintf((dev, HBA_FLAGS_DBG_FUNCTION_ENTRY_B,
+	  "aac_VerifyCSMIBuffer: Enter"));
+
+	*ppHeader = (PIOCTL_HEADER)NULL;
+
+	if (copy_from_user((void *)&Length,
+	  (void __user *)&((PIOCTL_HEADER)arg)->Length, sizeof(u32))) {
+		fwprintf((dev, HBA_FLAGS_DBG_ERROR_B,
+		  "aac_VerifyCSMIBuffer: Acquire Length Failure"));
+		Length = CSMI_SAS_STATUS_INVALID_PARAMETER;
+		/* Will msot probably fail */
+		Rtnval = copy_to_user(
+		  (void __user *)&((PIOCTL_HEADER)arg)->ReturnCode,
+		  (void *)&Length, sizeof(u32));
+		Rtnval = -EFAULT;
+	} else if ((Length < sizeof(IOCTL_HEADER))
+	 || (Length < csmiBufferSizeToVerify)
+	 || (csmiBufferSizeToVerify < sizeof(IOCTL_HEADER))) {
+		fwprintf((dev, HBA_FLAGS_DBG_ERROR_B,
+		  "aac_VerifyCSMIBuffer:"
+		  " sizeof(IOCTL_HEADER)=%u, Length=%u, MinPacketLength=%u",
+		  sizeof(IOCTL_HEADER), Length, csmiBufferSizeToVerify));
+		Length = CSMI_SAS_STATUS_INVALID_PARAMETER;
+		if (copy_to_user(
+		  (void __user *)&((PIOCTL_HEADER)arg)->ReturnCode,
+		  (void *)&Length, sizeof(u32)))
+			Rtnval = -EFAULT;
+		else
+			Rtnval = -EINVAL;
+	} else if (!(*ppHeader = kmalloc(Length, GFP_KERNEL))) {
+		fwprintf((dev, HBA_FLAGS_DBG_ERROR_B,
+		  "aac_VerifyCSMIBuffer: Acquire Memory %u Failure",
+		  Length));
+		Length = CSMI_SAS_STATUS_INVALID_PARAMETER;
+		if (copy_to_user(
+		  (void __user *)&((PIOCTL_HEADER)arg)->ReturnCode,
+		  (void *)&Length, sizeof(u32)))
+			Rtnval = -EFAULT;
+		else
+			Rtnval = -ENOMEM;
+	} else if (copy_from_user((void *)*ppHeader, arg, Length)) {
+		fwprintf((dev, HBA_FLAGS_DBG_ERROR_B,
+		  "aac_VerifyCSMIBuffer: Acquire Content Failure"));
+		kfree(*ppHeader);
+		*ppHeader = NULL;
+		Length = CSMI_SAS_STATUS_INVALID_PARAMETER;
+		/* Will most probably fail */
+		Rtnval = copy_to_user(
+		  (void __user *)&((PIOCTL_HEADER)arg)->ReturnCode,
+		  (void *)&Length, sizeof(u32));
+		Rtnval = -EFAULT;
+	} else {
+		list_for_each_entry(dev, &aac_devices, entry)
+			if (dev->id == (*ppHeader)->IOControllerNumber)
+				break;
+		if (dev == (struct aac_dev *)NULL) {
+			dev = *pDev; /* Return to original host */
+			fwprintf((dev, HBA_FLAGS_DBG_ERROR_B,
+			  "aac_VerifyCSMIBuffer: Acquire %d Indexed Controller Failure",
+			  (*ppHeader)->IOControllerNumber));
+			kfree(*ppHeader);
+			*ppHeader = NULL;
+			Length = CSMI_SAS_STATUS_INVALID_PARAMETER;
+			if (copy_to_user(
+			  (void __user *)&((PIOCTL_HEADER)arg)->ReturnCode,
+			  (void *)&Length, sizeof(u32)))
+				Rtnval = -EFAULT;
+			else
+				Rtnval = -EINVAL;
+		} else {
+			(*ppHeader)->ReturnCode = CSMI_SAS_STATUS_SUCCESS;
+			*pDev = dev;
+			Rtnval = 0;
+		}
+	}
+
+	fwprintf((dev, HBA_FLAGS_DBG_FUNCTION_EXIT_B,
+	  "aac_VerifyCSMIBuffer: Exit, ReturnValue=%d",Rtnval));
+
+	return Rtnval;
+
+}
+
+
+/*
+ * Routine Description:
+ *	This routine will close the *ppHeader.
+ * Return Value:
+ *	0 - Success
+ *	!0 - Failure
+ */
+static inline int
+aac_CloseCSMIBuffer(
+	struct aac_dev * dev,
+	void __user * arg,
+	PIOCTL_HEADER pHeader)
+{
+	int Rtnval = 0;
+
+	fwprintf((dev, HBA_FLAGS_DBG_FUNCTION_ENTRY_B,
+	  "aac_CloseCSMIBuffer: Enter"));
+
+	if (pHeader) {
+		if (copy_to_user(arg, (void *)pHeader, pHeader->Length))
+			Rtnval = -EFAULT;
+		kfree (pHeader);
+	}
+
+	fwprintf((dev, HBA_FLAGS_DBG_FUNCTION_EXIT_B,
+	  "aac_CloseCSMIBuffer: Exit, ReturnValue=%d",Rtnval));
+
+	return Rtnval;
+
+}
+
+typedef struct aac_bus_info DIOCTL;
+typedef DIOCTL * PDIOCTL;
+/* IOCTL Functions */
+#define CsmiGetPhyInfo		0x0070
+#define CsmiSataSignature	0x0071
+
+typedef struct {
+	u32	Status;		/* ST_OK */
+	u32	ObjType;	
+	u32	MethodId;	/* unused */
+	u32	ObjectId;	/* unused */
+	u32	CtlCmd;		/* unused */
+} DIOCTLRESPONSE;
+typedef DIOCTLRESPONSE * PDIOCTLRESPONSE;
+
+#define EnhancedGetBusInfo	0x0000000C
+#define SCSI_MAX_PORTS	10
+#define CSS_BUS_TYPE_SATA 11
+#define CSS_BUS_TYPE_SAS	12
+typedef struct aac_enhanced_bus_info_response {
+	struct aac_bus_info_response BusInfo;
+	/* Enhancements */
+	u32	Version;
+	u32	BusType[SCSI_MAX_PORTS];
+	u8	NumPortsMapped[SCSI_MAX_PORTS];
+	u8	ReservedPad0[2];
+	u32	Reserved[17];
+} ENHANCED_GBI_CSS;
+
+/*
+ * Routine Description:
+ *	This routine is called to request the version information for the
+ *	hardware, firmware, and boot BIOS associated with a storage controller.
+ *
+ * Return Value:
+ *	Status value, to be returned by aac_HandleCSMI, and returned to
+ *	--> Must set CSMI status value in pHeader->ReturnCode.
+ */
+int
+aac_CSMIGetControllerConfig(
+	struct aac_dev * dev,
+	void __user * arg)
+{
+	int Rtnval;
+	PCSMI_SAS_CNTLR_CONFIG_BUFFER pControllerConfigBuffer;
+	PDIOCTL pIoctlInfo;
+	ENHANCED_GBI_CSS * EnhancedBusInfo;
+	struct fib * fibptr;
+	int status;
+
+	fwprintf((dev,
+	  HBA_FLAGS_DBG_FUNCTION_ENTRY_B | HBA_FLAGS_DBG_CSMI_COMMANDS_B,
+	  "aac_CSMIGetControllerConfig: Enter"));
+
+	/*
+	 * Verify buffer size. If buffer is too small, the error status will
+	 * be set for pHeader->ReturnCode in aac_VerifyCSMIBuffer.
+	 */
+	if ((Rtnval = aac_VerifyCSMIBuffer(&dev, arg,
+	  sizeof(CSMI_SAS_CNTLR_CONFIG_BUFFER),
+	  (PIOCTL_HEADER *)&pControllerConfigBuffer))) {
+		fwprintf((dev,
+		  HBA_FLAGS_DBG_FUNCTION_EXIT_B | HBA_FLAGS_DBG_CSMI_COMMANDS_B,
+		  "aac_CSMISTPPassThru: Exit, ReturnValue = %d",
+		  Rtnval));
+		return Rtnval;
+	}
+
+	pControllerConfigBuffer->Configuration.uBaseIoAddress = 0;
+	pControllerConfigBuffer->Configuration.BaseMemoryAddress.uHighPart
+	  = ((u64)dev->scsi_host_ptr->base) >> 32;
+	pControllerConfigBuffer->Configuration.BaseMemoryAddress.uLowPart
+	  = dev->scsi_host_ptr->base & 0xffffffff;
+	pControllerConfigBuffer->Configuration.uBoardID
+	  = (dev->pdev->subsystem_device << 16)
+	  + dev->pdev->subsystem_vendor;
+	/*
+	 * Slot number can be pulled from
+	 * dev->supplement_adapter_info->SlotNumber in later versions of
+	 * the firmware else we could choose to take Linux PCI device slot
+	 * number PCI_SLOT(dev->pdev->devfn) instead?
+	 */
+	if ((dev->supplement_adapter_info.Version < AAC_SIS_VERSION_V3)
+	 || (dev->supplement_adapter_info.SlotNumber == AAC_SIS_SLOT_UNKNOWN)) {
+		pControllerConfigBuffer->Configuration.usSlotNumber
+		  = SLOT_NUMBER_UNKNOWN;
+	} else {
+		pControllerConfigBuffer->Configuration.usSlotNumber
+		 = dev->supplement_adapter_info.SlotNumber;
+	}
+	pControllerConfigBuffer->Configuration.bControllerClass
+	  = CSMI_SAS_CNTLR_CLASS_HBA;
+	pControllerConfigBuffer->Configuration.bIoBusType
+	  = CSMI_SAS_BUS_TYPE_PCI;
+	pControllerConfigBuffer->Configuration.BusAddress.PciAddress.bBusNumber
+	  = dev->pdev->bus->number;
+	pControllerConfigBuffer->Configuration.BusAddress.PciAddress.bDeviceNumber
+	  = PCI_SLOT(dev->pdev->devfn);
+	pControllerConfigBuffer->Configuration.BusAddress.PciAddress.bFunctionNumber
+	  = PCI_FUNC(dev->pdev->devfn);
+	pControllerConfigBuffer->Configuration.szSerialNumber[0] = '\0';
+	if (dev->adapter_info.serial[0] != 0xBAD0)
+		sprintf(pControllerConfigBuffer->Configuration.szSerialNumber,
+		  "%x", dev->adapter_info.serial[0]);
+	/* Get Bus Type */
+	fibptr = fib_alloc(dev);
+	if (fibptr == NULL) {
+		pControllerConfigBuffer->Configuration.uControllerFlags
+		  = CSMI_SAS_CNTLR_SATA_RAID;
+	} else {
+		fib_init(fibptr);
+
+		pIoctlInfo = (PDIOCTL) fib_data(fibptr);
+		pIoctlInfo->Command = cpu_to_le32(VM_Ioctl);
+		pIoctlInfo->ObjType = cpu_to_le32(FT_DRIVE);
+		pIoctlInfo->MethodId = cpu_to_le32(1);
+		pIoctlInfo->ObjectId = 0;
+		pIoctlInfo->CtlCmd = cpu_to_le32(EnhancedGetBusInfo);
+
+		status = fib_send(ContainerCommand, fibptr,
+		  sizeof(*EnhancedBusInfo),
+		  FsaNormal, 1, 1, NULL, NULL);
+	
+		fib_complete(fibptr);
+	
+		EnhancedBusInfo = (struct aac_enhanced_bus_info_response *) pIoctlInfo;
+	
+		if (status < 0) {
+			pControllerConfigBuffer->Configuration.uControllerFlags
+			  = CSMI_SAS_CNTLR_SATA_RAID;
+		} else switch (EnhancedBusInfo->BusType[0]) {
+		case CSS_BUS_TYPE_SATA:
+			pControllerConfigBuffer->Configuration.uControllerFlags
+			  = CSMI_SAS_CNTLR_SATA_RAID;
+			break;
+		case CSS_BUS_TYPE_SAS:
+			pControllerConfigBuffer->Configuration.uControllerFlags
+			  = CSMI_SAS_CNTLR_SAS_RAID;
+			break;
+		default:
+			pControllerConfigBuffer->Configuration.uControllerFlags
+			  = 0;
+			break;
+		}
+		fib_free(fibptr);
+	}
+
+	pControllerConfigBuffer->Configuration.usBIOSBuildRevision
+	  = cpu_to_le16(le32_to_cpu(dev->adapter_info.biosbuild));
+	pControllerConfigBuffer->Configuration.usBIOSMajorRevision
+	  = cpu_to_le16(le32_to_cpu(dev->adapter_info.biosrev) >> 24);
+	pControllerConfigBuffer->Configuration.usBIOSMinorRevision
+	  = cpu_to_le16((le32_to_cpu(dev->adapter_info.biosrev) >> 16) & 0xff);
+	pControllerConfigBuffer->Configuration.usBIOSReleaseRevision
+	  = cpu_to_le16(le32_to_cpu(dev->adapter_info.biosrev) & 0xff);
+	pControllerConfigBuffer->Configuration.usBuildRevision
+	  = cpu_to_le16(le32_to_cpu(dev->adapter_info.kernelbuild));
+	pControllerConfigBuffer->Configuration.usMajorRevision
+	  = cpu_to_le16(le32_to_cpu(dev->adapter_info.kernelrev) >> 24);
+	pControllerConfigBuffer->Configuration.usMinorRevision
+	  = cpu_to_le16((le32_to_cpu(dev->adapter_info.kernelrev) >> 16) & 0xff);
+	pControllerConfigBuffer->Configuration.usReleaseRevision
+	  = cpu_to_le16(le32_to_cpu(dev->adapter_info.kernelrev) & 0xff);
+	pControllerConfigBuffer->Configuration.usRromBIOSBuildRevision = 0;
+	pControllerConfigBuffer->Configuration.usRromBIOSMajorRevision = 0;
+	pControllerConfigBuffer->Configuration.usRromBIOSMinorRevision = 0;
+	pControllerConfigBuffer->Configuration.usRromBIOSReleaseRevision = 0;
+	pControllerConfigBuffer->Configuration.usRromBuildRevision = 0;
+	pControllerConfigBuffer->Configuration.usRromMajorRevision = 0;
+	pControllerConfigBuffer->Configuration.usRromMinorRevision = 0;
+	pControllerConfigBuffer->Configuration.usRromReleaseRevision = 0;
+
+	Rtnval = aac_CloseCSMIBuffer(dev, arg,
+	  (PIOCTL_HEADER)pControllerConfigBuffer);
+
+	fwprintf((dev,
+	  HBA_FLAGS_DBG_FUNCTION_EXIT_B | HBA_FLAGS_DBG_CSMI_COMMANDS_B,
+	  "aac_CSMIGetControllerConfig: Exit, ReturnValue=%d, ReturnCode=%x",
+	  Rtnval, pControllerConfigBuffer->IoctlHeader.ReturnCode));
+
+	return Rtnval;
+
+}
+
+
+/*
+ * Routine Description:
+ *	This routine is called to request the current status of the controller.
+ *
+ * Return Value:
+ *	Status value, to be returned by aac_HandleCSMI, and returned to the OS.
+ *	--> Must set CSMI status value in pHeader->ReturnCode.
+ */
+int
+aac_CSMIGetControllerStatus(
+	struct aac_dev * dev,
+	void __user * arg)
+{
+	int Rtnval;
+	PCSMI_SAS_CNTLR_STATUS_BUFFER pStatusBuffer;
+
+	fwprintf((dev,
+	  HBA_FLAGS_DBG_FUNCTION_ENTRY_B | HBA_FLAGS_DBG_CSMI_COMMANDS_B,
+	  "aac_CSMIGetControllerStatus: Enter"));
+
+	/*
+	 * Verify buffer size. If buffer is too small, the error status will
+	 * be set for pHeader->ReturnCode in aac_VerifyCSMIBuffer.
+	 */
+	if ((Rtnval = aac_VerifyCSMIBuffer(&dev, arg,
+	  sizeof(CSMI_SAS_CNTLR_STATUS_BUFFER),
+	  (PIOCTL_HEADER *)&pStatusBuffer))) {
+		fwprintf((dev,
+		  HBA_FLAGS_DBG_FUNCTION_EXIT_B | HBA_FLAGS_DBG_CSMI_COMMANDS_B,
+		  "aac_CSMIGetControllerStatus: Exit, ReturnValue=%d",
+		  Rtnval));
+		return Rtnval;
+	}
+
+	/*
+	 * Determine and set adapter state
+	 */
+	switch (aac_adapter_check_health(dev)) {
+	case 0:
+		pStatusBuffer->Status.uStatus = CSMI_SAS_CNTLR_STATUS_GOOD;
+		break;
+	case -1:
+	case -2:
+	case -3:
+		pStatusBuffer->Status.uStatus = CSMI_SAS_CNTLR_STATUS_FAILED;
+		break;
+	default:
+		pStatusBuffer->Status.uStatus = CSMI_SAS_CNTLR_STATUS_OFFLINE;
+		pStatusBuffer->Status.uOfflineReason
+		  = CSMI_SAS_OFFLINE_REASON_NO_REASON;
+	}
+
+	Rtnval = aac_CloseCSMIBuffer(dev, arg, (PIOCTL_HEADER)pStatusBuffer);
+
+	fwprintf((dev,
+	  HBA_FLAGS_DBG_FUNCTION_EXIT_B | HBA_FLAGS_DBG_CSMI_COMMANDS_B,
+	  "aac_CSMIGetControllerStatus: Exit, ReturnValue=%d, ReturnCode=%x",
+	  Rtnval, pStatusBuffer->IoctlHeader.ReturnCode));
+
+	return Rtnval;
+
+}
+
+
+/*
+ * Routine Description:
+ *	This routine is called to request information for a specified RAID set
+ *	on a controller that supports RAID.
+ * Return Value:
+ *	Status value, to be returned by aac_HandleCSMI, and returned to the OS
+ *	--> Must set CSMI status value in pHeader->ReturnCode.
+ */
+int
+aac_CSMIGetRAIDConfig(
+	struct aac_dev * dev,
+	void __user * arg)
+{
+	int Rtnval;
+	PCSMI_SAS_RAID_CONFIG_BUFFER pRaidConfigBuffer;
+	typedef struct {
+		u32	command;
+		u32	type;
+		u32	cid;
+		u32	parm1;
+		u32	parm2;
+		u32	uid;
+		u32	offset;
+		u32	parm5;
+	} CONTAINER;
+	CONTAINER * ct;
+#	define CT_PACKET_SIZE (sizeof(((struct hw_fib *)NULL)->data)-(sizeof(u32)*12))
+#	define CT_CONTINUE_DATA		83
+#	define CT_STOP_DATA		84
+#	define CT_GET_RAID_CONFIG	215
+	typedef struct {
+		u32	response;
+		u32	type;
+		u32	status;
+		u32	count;
+		u32	parm2;
+		u32	uid;
+		u32	parm4;
+		u32	parm5;
+		u32	data[1];
+	} CONTAINERRESPONSE;
+	CONTAINERRESPONSE * ctr;
+#	define CT_CONTINUATION_ERROR 199
+	u16 bufferOffset = 0;
+	u16 LoopCount = 0;
+	unsigned long uniqueID = 0, sizeLeft = 0;
+	unsigned char *DestinationBuffer;
+	struct fib * fibptr;
+	int status;
+
+	fwprintf((dev,
+	  HBA_FLAGS_DBG_FUNCTION_ENTRY_B | HBA_FLAGS_DBG_CSMI_COMMANDS_B,
+	  "aac_CSMIGetRAIDConfig: Enter"));
+
+	/*
+	 * Verify buffer size. If buffer is too small, the error status will
+	 * be set for pHeader->ReturnCode in aac_VerifyCSMIBuffer.
+	 */
+	if ((Rtnval = aac_VerifyCSMIBuffer(&dev, arg,
+	  sizeof(CSMI_SAS_RAID_CONFIG_BUFFER),
+	  (PIOCTL_HEADER *)&pRaidConfigBuffer))) {
+		fwprintf((dev,
+		  HBA_FLAGS_DBG_FUNCTION_EXIT_B | HBA_FLAGS_DBG_CSMI_COMMANDS_B,
+		  "aac_CSMIGetRAIDConfig: Exit, ReturnValue = %d",
+		  Rtnval));
+		return Rtnval;
+	}
+
+	/*
+	 * Make sure the requested container number exists
+	 */
+	if ((pRaidConfigBuffer->Configuration.uRaidSetIndex == 0)
+	 || (pRaidConfigBuffer->Configuration.uRaidSetIndex
+	  > dev->maximum_num_containers)
+	 || (!dev->
+	  fsa_dev[pRaidConfigBuffer->Configuration.uRaidSetIndex-1].valid)) {
+		fwprintf((dev, HBA_FLAGS_DBG_ERROR_B,
+		  ((pRaidConfigBuffer->Configuration.uRaidSetIndex
+		    >= dev->maximum_num_containers)
+		      ? "aac_CSMIGetRAIDConfig: RaidIndex=%d > Maximum=%d"
+		      : "aac_CSMIGetRAIDConfig: RaidIndex=%d invalid"),
+		  pRaidConfigBuffer->Configuration.uRaidSetIndex,
+		  dev->maximum_num_containers));
+
+		/*
+		 * Indicate the RaidSetIndex is invalid
+		 */
+		pRaidConfigBuffer->IoctlHeader.ReturnCode
+		  = CSMI_SAS_RAID_SET_OUT_OF_RANGE;
+		Rtnval = aac_CloseCSMIBuffer(dev, arg,
+		  (PIOCTL_HEADER)pRaidConfigBuffer);
+
+		fwprintf((dev,
+		  HBA_FLAGS_DBG_FUNCTION_EXIT_B | HBA_FLAGS_DBG_CSMI_COMMANDS_B,
+		  "aac_CSMIGetRAIDConfig: Exit, ReturnValue=%d,"
+		  " ReturnCode=CSMI_SAS_RAID_SET_OUT_OF_RANGE",
+		  Rtnval));
+		return Rtnval;
+	}
+
+	fibptr = fib_alloc(dev);
+	if (fibptr == NULL) {
+		pRaidConfigBuffer->IoctlHeader.ReturnCode
+		  = CSMI_SAS_STATUS_FAILED;
+		Rtnval = aac_CloseCSMIBuffer(dev, arg,
+		  (PIOCTL_HEADER)pRaidConfigBuffer);
+		fwprintf((dev,
+		  HBA_FLAGS_DBG_FUNCTION_EXIT_B | HBA_FLAGS_DBG_CSMI_COMMANDS_B,
+		  "aac_CSMIGetRAIDConfig: Exit, ReturnValue=%d,"
+		  " ReturnCode=CSMI_SAS_STATUS_FAILED",
+		  Rtnval));
+		return Rtnval;
+	}
+	fib_init (fibptr);
+	fibptr->hw_fib->header.SenderSize = cpu_to_le16(sizeof(struct hw_fib));
+
+	/*
+	 * Setup and send CT_GET_RAID_CONFIG command to FW to
+	 * fill in IOCTL buffer
+	 */
+	ct = (CONTAINER *) fib_data(fibptr);
+	ct->command = cpu_to_le32(VM_ContainerConfig);
+	ct->type = cpu_to_le32(CT_GET_RAID_CONFIG);
+ 	/* Container number */
+	ct->cid = cpu_to_le32(pRaidConfigBuffer->Configuration.uRaidSetIndex-1);
+
+	status = fib_send(ContainerCommand, fibptr, sizeof(CONTAINER),
+	  FsaNormal, 1, 1, NULL, NULL);
+	fib_complete(fibptr);
+
+	if (status < 0) {
+		fib_free(fibptr);
+		pRaidConfigBuffer->IoctlHeader.ReturnCode
+		  = CSMI_SAS_STATUS_FAILED;
+		Rtnval = aac_CloseCSMIBuffer(dev, arg,
+		  (PIOCTL_HEADER)pRaidConfigBuffer);
+		fwprintf((dev,
+		  HBA_FLAGS_DBG_FUNCTION_EXIT_B | HBA_FLAGS_DBG_CSMI_COMMANDS_B,
+		  "aac_CSMIGetRAIDConfig: Exit, ReturnValue=%d,"
+		  " ReturnCode=CSMI_SAS_STATUS_FAILED",
+		  Rtnval));
+		return Rtnval;
+	}
+
+	ctr = (CONTAINERRESPONSE *) ct;
+	/*
+	 * Check for error conditions
+	 */
+	if (ctr->status == cpu_to_le32(CT_CONTINUATION_ERROR)) {
+		fib_free(fibptr);
+		/*
+		 * Indicate failure for this IOCTL
+		 */
+		pRaidConfigBuffer->IoctlHeader.ReturnCode
+		  = CSMI_SAS_STATUS_FAILED;
+		Rtnval = aac_CloseCSMIBuffer(dev, arg,
+		  (PIOCTL_HEADER)pRaidConfigBuffer);
+		fwprintf((dev,
+		  HBA_FLAGS_DBG_FUNCTION_EXIT_B | HBA_FLAGS_DBG_CSMI_COMMANDS_B,
+		  "aac_CSMIGetRAIDConfig: Exit, ReturnValue=%d,"
+		  " ReturnCode=CSMI_SAS_STATUS_FAILED",
+		  Rtnval));
+		return Rtnval;
+	}
+
+	/*
+	 * Grab the total size of data to be returned so we can loop through
+	 * and get it all
+	 */
+	sizeLeft = le32_to_cpu(ctr->count);
+
+	/*
+	 * Get Unique ID for this continuation session
+	 */
+	uniqueID = ctr->uid;
+
+	/*
+	 * If there is more data, continue looping until we're done
+	 */
+	DestinationBuffer = (unsigned char *)(&pRaidConfigBuffer->Configuration);
+
+	while (sizeLeft) {
+		fib_init (fibptr);
+		fibptr->hw_fib->header.SenderSize
+		  = cpu_to_le16(sizeof(struct hw_fib));
+
+		ct->command = cpu_to_le32(VM_ContainerConfig);
+		ct->type = cpu_to_le32(CT_CONTINUE_DATA);
+		ct->uid = uniqueID;
+		ct->offset = cpu_to_le32(LoopCount);
+
+		status = fib_send(ContainerCommand, fibptr, sizeof(CONTAINER),
+		  FsaNormal, 1, 1, NULL, NULL);
+		fib_complete(fibptr);
+
+		if (status < 0) {
+			/*
+			 * Indicate failure for this IOCTL
+			 */
+			pRaidConfigBuffer->IoctlHeader.ReturnCode
+			  = CSMI_SAS_STATUS_FAILED;
+			break;
+		}
+
+		/*
+		 * Check for error conditions
+		 */
+		if (ctr->status == cpu_to_le32(CT_CONTINUATION_ERROR)) {
+			/*
+			 * Indicate failure for this IOCTL
+			 */
+			pRaidConfigBuffer->IoctlHeader.ReturnCode
+			  = CSMI_SAS_STATUS_FAILED;
+			break;
+		}
+
+		/*
+		 * No error so copy the remaining data
+		 */
+		/*
+		 * Move the full packet size and update for the next loop
+		 */
+		if (sizeLeft >= CT_PACKET_SIZE) {
+			memcpy(DestinationBuffer, ctr->data, CT_PACKET_SIZE);
+
+			/*
+			 * Set current offset in buffer, so we can continue
+			 * copying data.
+			 */
+			bufferOffset += CT_PACKET_SIZE;
+			DestinationBuffer += CT_PACKET_SIZE;
+			sizeLeft -= CT_PACKET_SIZE;
+			++LoopCount;
+		}
+
+		/*
+		 * last transfer; is less than CT_PACKET_SIZE, so just use
+		 * sizeLeft
+		 */
+		else {
+			memcpy(DestinationBuffer, ctr->data, sizeLeft);
+			sizeLeft = 0;
+		}
+	}
+
+	/*
+	 * At this point, we have copied back
+	 * all of the data. Send a STOP command
+	 * to finish things off.
+	 */
+	fib_init (fibptr);
+
+	ct->command = cpu_to_le32(VM_ContainerConfig);
+	ct->type = cpu_to_le32(CT_STOP_DATA);
+	ct->uid = uniqueID;
+
+	fib_send(ContainerCommand, fibptr, sizeof(CONTAINER),
+	  FsaNormal, 1, 1, NULL, NULL);
+	fib_complete(fibptr);
+	fib_free(fibptr);
+
+	Rtnval = aac_CloseCSMIBuffer(dev, arg, (PIOCTL_HEADER)pRaidConfigBuffer);
+	fwprintf((dev,
+	  HBA_FLAGS_DBG_FUNCTION_EXIT_B | HBA_FLAGS_DBG_CSMI_COMMANDS_B,
+	  "aac_CSMIGetRAIDConfig: Exit, ReturnValue=%d, ReturnCode=%x",
+	  Rtnval, pRaidConfigBuffer->IoctlHeader.ReturnCode));
+
+	return Rtnval;
+
+}
+
+
+/*
+ * Routine Description:
+ *	This routine is called to request information on the number of RAID
+ *	volumes and number of physical drives on a controller.
+ * Return Value:
+ *	Status value, to be returned by aac_HandleCSMI, and returned to the OS.
+ *	--> Must set CSMI status value in pHeader->ReturnCode.
+ */
+int
+aac_CSMIGetRAIDInfo(
+	struct aac_dev * dev,
+	void __user * arg)
+{
+	int Rtnval;
+	PCSMI_SAS_RAID_INFO_BUFFER pRaidInfoBuffer;
+	u16 NumRaidSets = 0;
+	int lcv;
+	PDIOCTL pIoctlInfo;
+	ENHANCED_GBI_CSS * EnhancedBusInfo;
+	struct fib * fibptr;
+	int status;
+
+	fwprintf((dev,
+	  HBA_FLAGS_DBG_FUNCTION_ENTRY_B | HBA_FLAGS_DBG_CSMI_COMMANDS_B,
+	  "aac_CSMIGetRAIDInfo: Enter"));
+
+	/*
+	 * Verify buffer size. If buffer is too small, the error status will
+	 * be set for pHeader->ReturnCode in aac_VerifyCSMIBuffer.
+	 */
+	if ((Rtnval = aac_VerifyCSMIBuffer(&dev, arg,
+	  sizeof(CSMI_SAS_RAID_INFO_BUFFER),
+	  (PIOCTL_HEADER *)&pRaidInfoBuffer))) {
+		fwprintf((dev,
+		  HBA_FLAGS_DBG_FUNCTION_EXIT_B | HBA_FLAGS_DBG_CSMI_COMMANDS_B,
+		  "aac_CSMIGetRAIDInfo: Exit, ReturnValue=%d",
+		  Rtnval));
+		return Rtnval;
+	}
+
+	/*
+	 * Traverse the container list and count all containers
+	 */
+	for (lcv = 0; lcv < dev->maximum_num_containers; lcv++)
+		if (dev->fsa_dev[lcv].valid)
+			NumRaidSets++;
+	pRaidInfoBuffer->Information.uNumRaidSets = NumRaidSets;
+
+	/*
+	 * Find the absolute maximum number of physical drives that can make
+	 * up a container. It's pretty ambiquous so we'll default it to the
+	 * Falcon maximum number of drives supported and then try to figure
+	 * out from firmware the max number of drives we can attach to this
+	 * controller.
+	 */
+	pRaidInfoBuffer->Information.uMaxDrivesPerSet = 128;
+	fibptr = fib_alloc(dev);
+	if (fibptr) {
+		fib_init(fibptr);
+
+		pIoctlInfo = (PDIOCTL) fib_data(fibptr);
+		pIoctlInfo->Command = cpu_to_le32(VM_Ioctl);
+		pIoctlInfo->ObjType = cpu_to_le32(FT_DRIVE);
+		pIoctlInfo->MethodId = cpu_to_le32(1);
+		pIoctlInfo->ObjectId = 0;
+		pIoctlInfo->CtlCmd = cpu_to_le32(EnhancedGetBusInfo);
+
+		status = fib_send(ContainerCommand, fibptr,
+		  sizeof(*EnhancedBusInfo),
+		  FsaNormal, 1, 1, NULL, NULL);
+	
+		fib_complete(fibptr);
+	
+		EnhancedBusInfo = (struct aac_enhanced_bus_info_response *) pIoctlInfo;
+	
+		if (status >= 0) switch (EnhancedBusInfo->BusType[0]) {
+		case CSS_BUS_TYPE_SATA:
+			pRaidInfoBuffer->Information.uMaxDrivesPerSet
+			  = dev->supplement_adapter_info.MaxNumberPorts;
+			break;
+		case CSS_BUS_TYPE_SAS:
+			pRaidInfoBuffer->Information.uMaxDrivesPerSet = 128;
+			break;
+		default:
+			pRaidInfoBuffer->Information.uMaxDrivesPerSet
+			  = dev->maximum_num_physicals
+			  * dev->maximum_num_channels;
+			break;
+		}
+		fib_free(fibptr);
+	}
+
+	Rtnval = aac_CloseCSMIBuffer(dev, arg, (PIOCTL_HEADER)pRaidInfoBuffer);
+
+	fwprintf((dev,
+	  HBA_FLAGS_DBG_FUNCTION_EXIT_B | HBA_FLAGS_DBG_CSMI_COMMANDS_B,
+	  "aac_CSMIGetRAIDInfo: Exit, ReturnValue=%d, ReturnCode=%x",
+	  Rtnval, pRaidInfoBuffer->IoctlHeader.ReturnCode));
+
+	return Rtnval;
+}
+
+
+/*
+ * Routine Description:
+ *	This routine is called to request information about physical
+ *	characteristics and interconnect to the SATA or SAS domain.
+ * Return Value:
+ *	Status value, to be returned by aac_HandleCSMI, and returned to the OS.
+ *	--> Must set CSMI status value in pHeader->ReturnCode.
+ */
+int
+aac_CSMIGetPhyInfo(
+	struct aac_dev * dev,
+	void __user * arg)
+{
+	int Rtnval;
+	PCSMI_SAS_PHY_INFO_BUFFER pPhyInfoBuffer;
+	PDIOCTL pIoctlInfo;
+	PDIOCTLRESPONSE pIoctlResp;
+	struct fib * fibptr;
+	int status;
+	u32 Length;
+
+	fwprintf((dev,
+	  HBA_FLAGS_DBG_FUNCTION_ENTRY_B | HBA_FLAGS_DBG_CSMI_COMMANDS_B,
+	  "aac_CSMIGetPhyInfo: Enter scsi%d",
+	  dev->scsi_host_ptr->host_no));
+
+#if 0
+	/* Command can not be issued to the adapter */
+	if (!(dev->supplement_adapter_info.FeatureBits
+	 & le32_to_cpu(AAC_FEATURE_FALCON))) {
+		Rtnval = -ENOENT;
+		fwprintf((dev,
+		  HBA_FLAGS_DBG_FUNCTION_EXIT_B | HBA_FLAGS_DBG_CSMI_COMMANDS_B,
+		  "aac_CSMIGetPhyInfo: Exit, ReturnValue=-ENOENT",
+		  Rtnval));
+		return Rtnval;
+	}
+#endif
+	/*
+	 * Verify buffer size. If buffer is too small, the error status will
+	 * be set for pHeader->ReturnCode in aac_VerifyCSMIBuffer.
+	 */
+	if ((Rtnval = aac_VerifyCSMIBuffer(&dev, arg,
+	  sizeof(CSMI_SAS_PHY_INFO_BUFFER),
+	  (PIOCTL_HEADER *)&pPhyInfoBuffer))) {
+		fwprintf((dev,
+		  HBA_FLAGS_DBG_FUNCTION_EXIT_B | HBA_FLAGS_DBG_CSMI_COMMANDS_B,
+		  "aac_CSMIGetPhyInfo: Exit, ReturnValue=%d",
+		  Rtnval));
+		return Rtnval;
+	}
+
+	/* TODO : Figure out the correct size to send or do a continue fib */
+
+	fibptr = fib_alloc(dev);
+	if (fibptr == NULL) {
+		pPhyInfoBuffer->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
+		Rtnval = aac_CloseCSMIBuffer(dev, arg,
+		  (PIOCTL_HEADER)pPhyInfoBuffer);
+		fwprintf((dev,
+		  HBA_FLAGS_DBG_FUNCTION_EXIT_B | HBA_FLAGS_DBG_CSMI_COMMANDS_B,
+		  "aac_CSMIGetPhyInfo: Exit, ReturnValue=%d,"
+		  " ReturnCode=CSMI_SAS_STATUS_FAILED",
+		  Rtnval));
+		return Rtnval;
+	}
+	fib_init(fibptr);
+	fibptr->hw_fib->header.SenderSize = cpu_to_le16(sizeof(struct hw_fib));
+
+	pIoctlInfo = (PDIOCTL) fib_data(fibptr);
+	pIoctlInfo->Command = cpu_to_le32(VM_Ioctl);
+	pIoctlInfo->ObjType = cpu_to_le32(FT_DRIVE);
+	pIoctlInfo->MethodId = cpu_to_le32(1);
+	pIoctlInfo->ObjectId = 0;
+	pIoctlInfo->CtlCmd = cpu_to_le32(CsmiGetPhyInfo);
+	Length = pPhyInfoBuffer->IoctlHeader.Length;
+	/* Issue a Larger FIB? */
+	if (Length > (sizeof(struct hw_fib) - sizeof(struct aac_fibhdr)
+					- sizeof(*pIoctlInfo))) {
+		Length = sizeof(struct hw_fib) - sizeof(struct aac_fibhdr)
+		       - sizeof(*pIoctlInfo);
+		pPhyInfoBuffer->IoctlHeader.Length = Length;
+	}
+	memcpy(((char *)pIoctlInfo) + sizeof(*pIoctlInfo),
+	  pPhyInfoBuffer, Length);
+
+	status = fib_send(ContainerCommand, fibptr,
+	  Length + sizeof(*pIoctlInfo),
+	  FsaNormal, 1, 1, NULL, NULL);
+
+	fib_complete(fibptr);
+
+	if (status < 0) {
+		fib_free(fibptr);
+		pPhyInfoBuffer->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_FAILED;
+		Rtnval = aac_CloseCSMIBuffer(dev, arg,
+		  (PIOCTL_HEADER)pPhyInfoBuffer);
+		fwprintf((dev,
+		  HBA_FLAGS_DBG_FUNCTION_EXIT_B | HBA_FLAGS_DBG_CSMI_COMMANDS_B,
+		  "aac_CSMIGetPhyInfo: Exit, ReturnValue=%d,"
+		  " ReturnCode=CSMI_SAS_STATUS_FAILED",
+		  Rtnval));
+		return Rtnval;
+	}
+
+	pIoctlResp = (PDIOCTLRESPONSE) pIoctlInfo;
+
+	/*
+	 * Copy back the filled out buffer to complete the
+	 * request
+	 */
+	memcpy(pPhyInfoBuffer, ((char *)pIoctlResp) + sizeof(*pIoctlResp),
+	  Length);
+
+	fib_free(fibptr);
+
+	Rtnval = aac_CloseCSMIBuffer(dev, arg, (PIOCTL_HEADER)pPhyInfoBuffer);
+
+	fwprintf((dev,
+	  HBA_FLAGS_DBG_FUNCTION_EXIT_B | HBA_FLAGS_DBG_CSMI_COMMANDS_B,
+	  "aac_CSMIGetPhyInfo: Exit, Rtnval, ReturnCode=%x",
+	  Rtnval, pPhyInfoBuffer->IoctlHeader.ReturnCode));
+
+	return Rtnval;
+
+}
+
+
+/*
+ * Routine Description:
+ *	This routine is called to obtain the initial SATA signature (the
+ *	initial Register Device to the Host FIS) from a directly attached SATA
+ *	device.
+ * Return Value:
+ *	Status value, to be returned by aac_HandleCSMI, and returned to the OS.
+ *	--> Must set CSMI status value in pHeader->ReturnCode.
+ */
+int
+aac_CSMIGetSATASignature(
+	struct aac_dev * dev,
+	void __user * arg)
+{
+	int Rtnval;
+	PCSMI_SAS_SATA_SIGNATURE_BUFFER pSataSignatureBuffer;
+	PDIOCTL pIoctlInfo;
+	PDIOCTLRESPONSE pIoctlResp;
+	struct fib * fibptr;
+	int status;
+
+	fwprintf((dev,
+	  HBA_FLAGS_DBG_FUNCTION_ENTRY_B | HBA_FLAGS_DBG_CSMI_COMMANDS_B,
+	  "aac_CSMIGetSATASignature: Enter scsi%d",
+	  dev->scsi_host_ptr->host_no));
+
+	/*
+	 * Verify buffer size. If buffer is too small, the error status will
+	 * be set for pHeader->ReturnCode in aac_VerifyCSMIBuffer.
+	 */
+	if ((Rtnval = aac_VerifyCSMIBuffer(&dev, arg,
+	  sizeof(CSMI_SAS_SATA_SIGNATURE_BUFFER),
+	  (PIOCTL_HEADER *)&pSataSignatureBuffer))) {
+		fwprintf((dev,
+		  HBA_FLAGS_DBG_FUNCTION_EXIT_B | HBA_FLAGS_DBG_CSMI_COMMANDS_B,
+		  "aac_CSMIGetSATASignature: Exit, ReturnValue=%d",
+		  Rtnval));
+		return Rtnval;
+	}
+
+	pSataSignatureBuffer->IoctlHeader.ReturnCode = CSMI_SAS_NO_SATA_DEVICE;
+
+	fibptr = fib_alloc(dev);
+	if (fibptr == NULL) {
+		pSataSignatureBuffer->IoctlHeader.ReturnCode
+		  = CSMI_SAS_STATUS_FAILED;
+		Rtnval = aac_CloseCSMIBuffer(dev, arg,
+		  (PIOCTL_HEADER)pSataSignatureBuffer);
+		fwprintf((dev,
+		  HBA_FLAGS_DBG_FUNCTION_EXIT_B | HBA_FLAGS_DBG_CSMI_COMMANDS_B,
+		  "aac_CSMIGetSATASignature: Exit, ReturnValue=%d,"
+		  " ReturnCode=CSMI_SAS_STATUS_FAILED",
+		  Rtnval));
+		return Rtnval;
+	}
+	fib_init(fibptr);
+
+	pIoctlInfo = (PDIOCTL) fib_data(fibptr);
+	pIoctlInfo->Command = cpu_to_le32(VM_Ioctl);
+	pIoctlInfo->ObjType = cpu_to_le32(FT_DRIVE);
+	pIoctlInfo->MethodId = cpu_to_le32(1);
+	pIoctlInfo->ObjectId = 0;
+	pIoctlInfo->CtlCmd = cpu_to_le32(CsmiSataSignature);
+	memcpy(((char *)pIoctlInfo) + sizeof(*pIoctlInfo),
+	  pSataSignatureBuffer,sizeof(CSMI_SAS_SATA_SIGNATURE_BUFFER));
+
+	status = fib_send(ContainerCommand, fibptr, sizeof(*pIoctlInfo)
+	  - sizeof(u32) + sizeof(CSMI_SAS_SATA_SIGNATURE_BUFFER), FsaNormal,
+	  1, 1, NULL, NULL);
+
+	fib_complete(fibptr);
+
+	if (status < 0) {
+		fib_free(fibptr);
+		pSataSignatureBuffer->IoctlHeader.ReturnCode
+		  = CSMI_SAS_STATUS_FAILED;
+		Rtnval = aac_CloseCSMIBuffer(dev, arg,
+		  (PIOCTL_HEADER)pSataSignatureBuffer);
+		fwprintf((dev,
+		  HBA_FLAGS_DBG_FUNCTION_EXIT_B | HBA_FLAGS_DBG_CSMI_COMMANDS_B,
+		  "aac_CSMIGetSATASignature: Exit, ReturnValue=%d,"
+		  " ReturnCode=CSMI_SAS_STATUS_FAILED",
+		  Rtnval));
+		return Rtnval;
+	}
+
+	pIoctlResp = (PDIOCTLRESPONSE) pIoctlInfo;
+
+	/*
+	 * Copy back the filled out buffer to complete the
+	 * request
+	 */
+	memcpy(pSataSignatureBuffer,
+	  ((char *)pIoctlResp) + sizeof(*pIoctlResp),
+	  sizeof(CSMI_SAS_SATA_SIGNATURE_BUFFER));
+
+	fib_free(fibptr);
+
+	/*
+	 * Indicate success for this IOCTL
+	 *	pSataSignatureBuffer->IoctlHeader.ReturnCode
+	 *		= CSMI_SAS_STATUS_SUCCESS;
+	 * is set by the Firmware Response.
+	 */
+	Rtnval = aac_CloseCSMIBuffer(dev, arg,
+	  (PIOCTL_HEADER)pSataSignatureBuffer);
+
+	fwprintf((dev,
+	  HBA_FLAGS_DBG_FUNCTION_EXIT_B | HBA_FLAGS_DBG_CSMI_COMMANDS_B,
+	  "aac_CSMIGetSATASignature: Exit, ReturnValue=%d,"
+	  " ReturnCode=CSMI_SAS_STATUS_SUCCESS",
+	  Rtnval));
+
+	return Rtnval;
+
+}
+
+
+/*
+ * Routine Description:
+ *	This routine is called to return the driver information.
+ * Return Value:
+ *	Status value, to be returned by aac_HandleCSMI, and returned to the OS.
+ *	--> Must set CSMI status value in pHeader->ReturnCode.
+ */
+int
+aac_CSMIGetDriverInfo(
+	struct aac_dev * dev,
+	void __user * arg)
+{
+	int Rtnval;
+	PCSMI_SAS_DRIVER_INFO_BUFFER pDriverInfoBuffer;
+	extern char aac_driver_version[];
+	char * driver_version = aac_driver_version;
+
+	fwprintf((dev,
+	  HBA_FLAGS_DBG_FUNCTION_ENTRY_B | HBA_FLAGS_DBG_CSMI_COMMANDS_B,
+	  "aac_CSMIGetDriverInfo: Enter"));
+
+	/*
+	 * Verify buffer size. If buffer is too small, the error status will
+	 * be set for pHeader->ReturnCode in aac_VerifyCSMIBuffer.
+	 */
+	if ((Rtnval = aac_VerifyCSMIBuffer(&dev, arg,
+	  sizeof(CSMI_SAS_DRIVER_INFO_BUFFER),
+	  (PIOCTL_HEADER *)&pDriverInfoBuffer))) {
+		fwprintf((dev,
+		  HBA_FLAGS_DBG_FUNCTION_EXIT_B | HBA_FLAGS_DBG_CSMI_COMMANDS_B,
+		  "aac_CSMIGetDriverInfo: Exit, ReturnValue=%d",
+		  Rtnval));
+		return Rtnval;
+	}
+
+	/*
+	 * Fill in the information member of the pDriverInfoBuffer
+	 * structure.
+	 */
+
+	/*
+	 * Driver name
+	 */
+	strncpy(pDriverInfoBuffer->Information.szName,
+	  (dev->scsi_host_ptr->hostt->info
+	    ? dev->scsi_host_ptr->hostt->info(dev->scsi_host_ptr)
+	    : dev->scsi_host_ptr->hostt->name),
+	  sizeof(pDriverInfoBuffer->Information.szName));
+
+	/*
+	 * Driver Description
+	 */
+	sprintf(pDriverInfoBuffer->Information.szDescription,
+	  "Adaptec %s driver",
+	  dev->scsi_host_ptr->hostt->name);
+
+	/*
+	 * Set version number information
+	 */
+	pDriverInfoBuffer->Information.usMajorRevision
+	  = cpu_to_le16(aac_atoi(&driver_version));
+	pDriverInfoBuffer->Information.usMinorRevision
+	  = cpu_to_le16(aac_atoi(&driver_version));
+#if (defined(AAC_DRIVER_BUILD))
+	pDriverInfoBuffer->Information.usBuildRevision = cpu_to_le16(AAC_DRIVER_BUILD);
+#else
+	pDriverInfoBuffer->Information.usBuildRevision = cpu_to_le16(9999);
+#endif
+	pDriverInfoBuffer->Information.usReleaseRevision
+	  = cpu_to_le16(aac_atoi(&driver_version));
+	pDriverInfoBuffer->Information.usCSMIMajorRevision
+	  = cpu_to_le16(CSMI_MAJOR_REVISION);
+	pDriverInfoBuffer->Information.usCSMIMinorRevision
+	  = cpu_to_le16(CSMI_MINOR_REVISION);
+
+	Rtnval = aac_CloseCSMIBuffer(dev, arg, (PIOCTL_HEADER)pDriverInfoBuffer);
+	fwprintf((dev,
+	  HBA_FLAGS_DBG_FUNCTION_EXIT_B | HBA_FLAGS_DBG_CSMI_COMMANDS_B,
+	  "aac_CSMIGetDriverInfo: Exit, ReturnValue=%d, ReturnCode=%x",
+	  Rtnval, pDriverInfoBuffer->IoctlHeader.ReturnCode));
+
+	return Rtnval;
+
+}
+
+
+
+/*
+ * Routine Description:
+ *	This routine is called to change the physical characteristics of a phy.
+ *	We currently do not support this functionality, and are not required to
+ *	in order to support CSMI.
+ * Return Value:
+ *	Status value, to be returned by aac_HandleCSMI, and returned to the OS.
+ *	--> Must set CSMI status value in pHeader->ReturnCode.
+ */
+int
+aac_CSMISetPhyInfo(
+	struct aac_dev * dev,
+	void __user * arg)
+{
+	int Rtnval;
+	u32 ReturnCode;
+
+	fwprintf((dev,
+	  HBA_FLAGS_DBG_FUNCTION_ENTRY_B | HBA_FLAGS_DBG_CSMI_COMMANDS_B,
+	  "aac_CSMISetPhyInfo: Enter scsi%d",
+	  dev->scsi_host_ptr->host_no));
+
+	ReturnCode = CSMI_SAS_PHY_INFO_NOT_CHANGEABLE;
+	Rtnval = 0;
+	if (copy_to_user((void __user *)&((PIOCTL_HEADER)arg)->ReturnCode,
+	  (void *)&ReturnCode, sizeof(u32)))
+		Rtnval = -EFAULT;
+
+	fwprintf((dev,
+	  HBA_FLAGS_DBG_FUNCTION_EXIT_B | HBA_FLAGS_DBG_CSMI_COMMANDS_B,
+	  "aac_CSMISetPhyInfo: Exit, ReturnValue=%d,"
+	  " ReturnCode=CSMI_SAS_PHY_INFO_NOT_CHANGEABLE",
+	  Rtnval));
+
+	return Rtnval;
+
+}
+
+
+/*
+ * Routine Description:
+ *	This routine is called to send generic STP or SATA commands to a
+ *	specific SAS address.
+ * Return Value:
+ *	Status value, to be returned by aac_HandleCSMI, and returned to the OS.
+ *	--> Must set CSMI status value in pHeader->ReturnCode.
+ */
+int
+aac_CSMISTPPassThru(
+	struct aac_dev * dev,
+	void __user * arg)
+{
+	int Rtnval;
+	PCSMI_SAS_STP_PASSTHRU_BUFFER pPassThruBuffer;
+	unsigned bytesLeft = 0;
+	u8 * pDataPointer = NULL;
+	/* function */
+#	define SATAPASSTHROUGH_REGISTER		0x00000000
+#	define SATAPASSTHROUGH_SOFTRESET	0x00000001
+	typedef struct {
+		u32	function;
+		u32	bus;
+		u32	targetId;
+		u32	lun;
+		u32	timeOutValue;
+		u32	srbFlags;
+#			define	HOSTSRB_FLAGS_NO_DATA_TRANSFER	0x00000000
+#			define	HOSTSRB_FLAGS_DATA_IN		0x00000040
+#			define	HOSTSRB_FLAGS_DATA_OUT		0x00000080
+		u32	dataTransferLength;
+		u32	retryLimit;
+		u32	cdbLength;
+		u8	command;
+		u8	features;
+		u8	sectorNumber;
+		u8	cylinderLow;
+		u8	cylinderHigh;
+		u8	deviceHead;
+		u8	sectorNumber_Exp;
+		u8	cylinderLow_Exp;
+		u8	cylinderHigh_Exp;
+		u8	features_Exp;
+		u8	sectorCount;
+		u8	sectorCount_Exp;
+		u8	reserved;
+		u8	control;
+		u8	reserved1[2];
+		u32	reserved2[4];
+		struct sgmap64	sgMap;
+	} HOST_SATA_REQUEST_BLOCK;
+	typedef HOST_SATA_REQUEST_BLOCK * PHOST_SATA_REQUEST_BLOCK;
+	PHOST_SATA_REQUEST_BLOCK pSataRequest;
+	typedef struct {
+		u32	status;
+		u32	srbStatus;
+		u32	scsiStatus;
+		u32	dataTransferLength;
+		u32	senseInfoBufferLength;
+		u8	statusReg;
+		u8	error;
+		u8	sectorNumber;
+		u8	cylinderLow;
+		u8	cylinderHigh;
+		u8	deviceHead;
+		u8	sectorNumber_Exp;
+		u8	cylinderLow_Exp;
+		u8	cylinderHigh_Exp;
+		u8	deviceRegister_Exp;
+		u8	features;
+		u8	featuers_Exp;
+		u8	reserved1[4];
+	} HOST_SATA_REQUEST_BLOCK_RESULT;
+	typedef HOST_SATA_REQUEST_BLOCK_RESULT * PHOST_SATA_REQUEST_BLOCK_RESULT;
+	PHOST_SATA_REQUEST_BLOCK_RESULT pSataResponse;
+	struct sgmap64 * pSgMap;
+	struct fib * fibptr;
+	int status;
+	dma_addr_t addr;
+	void * p = NULL;
+#	define SataPortCommandU64	602
+
+	fwprintf((dev,
+	  HBA_FLAGS_DBG_FUNCTION_ENTRY_B | HBA_FLAGS_DBG_CSMI_COMMANDS_B,
+	  "aac_CSMISTPPassThru: Enter scsi%d",
+	  dev->scsi_host_ptr->host_no));
+
+	/*
+	 * Verify buffer size. If buffer is too small, the error status will
+	 * be set for pHeader->ReturnCode in aac_VerifyCSMIBuffer.
+	 */
+	if ((Rtnval = aac_VerifyCSMIBuffer(&dev, arg,
+	  sizeof(CSMI_SAS_STP_PASSTHRU_BUFFER),
+	  (PIOCTL_HEADER *)&pPassThruBuffer))) {
+		fwprintf((dev,
+		  HBA_FLAGS_DBG_FUNCTION_EXIT_B | HBA_FLAGS_DBG_CSMI_COMMANDS_B,
+		  "aac_CSMISTPPassThru: Exit, ReturnValue=%d",
+		  Rtnval));
+		return Rtnval;
+	}
+	/*
+	 * Weed out the flags we don't support
+	 */
+	if ((pPassThruBuffer->Parameters.uFlags & CSMI_SAS_STP_DMA)
+	 || (pPassThruBuffer->Parameters.uFlags & CSMI_SAS_STP_DMA_QUEUED)) {
+		/*
+		 * Indicate failure for this IOCTL
+		 */
+		pPassThruBuffer->IoctlHeader.ReturnCode
+		  = CSMI_SAS_STATUS_FAILED;
+		Rtnval = aac_CloseCSMIBuffer(dev, arg,
+		  (PIOCTL_HEADER)pPassThruBuffer);
+		fwprintf((dev,
+		  HBA_FLAGS_DBG_FUNCTION_EXIT_B | HBA_FLAGS_DBG_CSMI_COMMANDS_B,
+		  "aac_CSMISTPPassThru: Exit, ReturnValue=%d,"
+		  " ReturnCode=CSMI_SAS_STATUS_FAILED",
+		  Rtnval));
+		return Rtnval;
+	}
+
+	fibptr = fib_alloc(dev);
+	if (fibptr == NULL) {
+		pPassThruBuffer->IoctlHeader.ReturnCode
+		  = CSMI_SAS_STATUS_FAILED;
+		Rtnval = aac_CloseCSMIBuffer(dev, arg,
+		  (PIOCTL_HEADER)pPassThruBuffer);
+		fwprintf((dev,
+		  HBA_FLAGS_DBG_FUNCTION_EXIT_B | HBA_FLAGS_DBG_CSMI_COMMANDS_B,
+		  "aac_CSMISTPPassThru: Exit, ReturnValue=%d,"
+		  " ReturnCode=CSMI_SAS_STATUS_FAILED",
+		  Rtnval));
+		return Rtnval;
+	}
+	fib_init(fibptr);
+
+	pSataRequest = (PHOST_SATA_REQUEST_BLOCK) fib_data(fibptr);
+	pSgMap = &pSataRequest->sgMap;
+	pSataResponse = (PHOST_SATA_REQUEST_BLOCK_RESULT) pSataRequest;
+
+	/*
+	 * Setup HOST_SATA_REQUEST_BLOCK structure
+	 */
+	memset(pSataRequest,0,sizeof(*pSataRequest));
+	memset(pSataResponse,0,sizeof(HOST_SATA_REQUEST_BLOCK_RESULT));
+	if (pPassThruBuffer->Parameters.uFlags & CSMI_SAS_STP_RESET_DEVICE)
+		pSataRequest->function = SATAPASSTHROUGH_SOFTRESET;
+	else
+		pSataRequest->function = SATAPASSTHROUGH_REGISTER;
+
+	/*
+	 * Pull relevant data from header.
+	 */
+	if (pPassThruBuffer->Parameters.uFlags & CSMI_SAS_STP_READ)
+		pSataRequest->srbFlags = HOSTSRB_FLAGS_DATA_IN;
+	else
+		pSataRequest->srbFlags = HOSTSRB_FLAGS_DATA_OUT;
+	pSataRequest->timeOutValue = pPassThruBuffer->IoctlHeader.Timeout;
+
+	/*
+	 * Obsolete parameter - adapter firmware ignores this
+	 */
+	pSataRequest->retryLimit = 0;
+	pSataRequest->cdbLength = 14;
+
+	/*
+	 * Fill in remaining data from IOCTL Parameters
+	 */
+	/* Someday will be: SAS_ADDR_TO_BUS((*((u64*)pPassThruBuffer->Parameters.bDestinationSASAddress))); */
+	pSataRequest->bus = 0;
+	/* Someday will be: SAS_ADDR_TO_TARGET((*((u64*)pPassThruBuffer->Parameters.bDestinationSASAddress))); */
+	pSataRequest->targetId = pPassThruBuffer->Parameters.bPhyIdentifier;
+	/* Someday will be: SAS_ADDR_TO_LUN((*((u64*)pPassThruBuffer->Parameters.bDestinationSASAddress))); */
+	pSataRequest->lun = 0;
+	pSataRequest->dataTransferLength
+	  = pPassThruBuffer->Parameters.uDataLength;
+
+	/*
+	 * SATA Task Set Register Listing
+	 */
+	pSataRequest->command = pPassThruBuffer->Parameters.bCommandFIS[2];
+	pSataRequest->features = pPassThruBuffer->Parameters.bCommandFIS[3];
+	pSataRequest->sectorNumber = pPassThruBuffer->Parameters.bCommandFIS[4];
+	pSataRequest->cylinderLow = pPassThruBuffer->Parameters.bCommandFIS[5];
+	pSataRequest->cylinderHigh = pPassThruBuffer->Parameters.bCommandFIS[6];
+	pSataRequest->deviceHead = pPassThruBuffer->Parameters.bCommandFIS[7];
+	pSataRequest->sectorNumber_Exp
+	  = pPassThruBuffer->Parameters.bCommandFIS[8];
+	pSataRequest->cylinderLow_Exp
+	  = pPassThruBuffer->Parameters.bCommandFIS[9];
+	pSataRequest->cylinderHigh_Exp
+	  = pPassThruBuffer->Parameters.bCommandFIS[10];
+	pSataRequest->features_Exp
+	  = pPassThruBuffer->Parameters.bCommandFIS[11];
+	pSataRequest->sectorCount
+	  = pPassThruBuffer->Parameters.bCommandFIS[12];
+	pSataRequest->sectorCount_Exp
+	  = pPassThruBuffer->Parameters.bCommandFIS[13];
+	pSataRequest->control = pPassThruBuffer->Parameters.bCommandFIS[15];
+
+	/*
+	 * Build SGMAP
+	 */
+	if (pPassThruBuffer->Parameters.uDataLength) {
+
+		pDataPointer = &pPassThruBuffer->bDataBuffer[0];
+		bytesLeft = pPassThruBuffer->Parameters.uDataLength;
+
+		/*
+		 * Get physical address and length of
+		 * contiguous physical buffer
+		 */
+		p = pci_alloc_consistent(dev->pdev, bytesLeft, &addr);
+		if(p == 0) {
+			fib_free(fibptr);
+			pPassThruBuffer->IoctlHeader.ReturnCode
+			  = CSMI_SAS_STATUS_FAILED;
+			Rtnval = aac_CloseCSMIBuffer(dev, arg,
+			  (PIOCTL_HEADER)pPassThruBuffer);
+			fwprintf((dev, HBA_FLAGS_DBG_FUNCTION_EXIT_B
+			   | HBA_FLAGS_DBG_CSMI_COMMANDS_B,
+			  "aac_CSMISTPPassThru: Exit, ReturnValue=%d,"
+			  " ReturnCode=CSMI_SAS_STATUS_FAILED",
+			  Rtnval));
+			return Rtnval;
+		}
+		memcpy(p, pDataPointer, bytesLeft);
+
+		pSgMap->sg[0].addr[1] = cpu_to_le32((u32)((u64)addr>>32));
+		pSgMap->sg[0].addr[0] = cpu_to_le32((u32)(addr & 0xffffffff));
+
+		/*
+		 * Store the length for this entry
+		 */
+		pSgMap->sg[0].count = bytesLeft;
+
+		/*
+		 * Store final count of entries
+		 */
+		pSgMap->count = 1;
+
+	} else
+		pSataRequest->srbFlags = HOSTSRB_FLAGS_NO_DATA_TRANSFER;
+
+	/*
+	 * Send FIB
+	 */
+	status = fib_send(SataPortCommandU64, fibptr, sizeof(*pSataRequest),
+	  FsaNormal, 1, 1, NULL, NULL);
+
+	fib_complete(fibptr);
+
+	if (status < 0) {
+		if (pPassThruBuffer->Parameters.uDataLength)
+			pci_free_consistent(dev->pdev, bytesLeft,p, addr);
+		fib_free(fibptr);
+		pPassThruBuffer->IoctlHeader.ReturnCode
+		  = CSMI_SAS_STATUS_FAILED;
+		Rtnval = aac_CloseCSMIBuffer(dev, arg,
+		  (PIOCTL_HEADER)pPassThruBuffer);
+		fwprintf((dev,
+		  HBA_FLAGS_DBG_FUNCTION_EXIT_B | HBA_FLAGS_DBG_CSMI_COMMANDS_B,
+		  "aac_CSMIGetSATASignature: Exit, ReturnValue=%d,"
+		  " ReturnCode=CSMI_SAS_STATUS_FAILED",
+		  Rtnval));
+		return Rtnval;
+	}
+
+	if (pPassThruBuffer->Parameters.uDataLength) {
+		memcpy(pDataPointer, p, bytesLeft);
+		pci_free_consistent(dev->pdev, bytesLeft,p, addr);
+	}
+
+	/*
+	 * pull response data and respond to IOCTL
+	 */
+
+	/*
+	 * Return relevant data
+	 */
+	pPassThruBuffer->Status.bConnectionStatus = CSMI_SAS_OPEN_ACCEPT;
+	pPassThruBuffer->Status.bStatusFIS[2] = pSataResponse->statusReg;
+
+	/*
+	 * pPassThruBuffer->Status.uSCR = ??;
+	 */
+	pPassThruBuffer->Status.uDataBytes = pSataResponse->dataTransferLength;
+
+	fib_free(fibptr);
+
+	/*
+	 * Indicate success for this IOCTL
+	 */
+	pPassThruBuffer->IoctlHeader.ReturnCode = CSMI_SAS_STATUS_SUCCESS;
+	Rtnval = aac_CloseCSMIBuffer(dev, arg, (PIOCTL_HEADER)pPassThruBuffer);
+
+	fwprintf((dev,
+	  HBA_FLAGS_DBG_FUNCTION_EXIT_B | HBA_FLAGS_DBG_CSMI_COMMANDS_B,
+	  "aac_CSMISTPPassThru: Exit, ReturnValue=%d,"
+	  " ReturnCode=CSMI_SAS_STATUS_SUCCESS",
+	  Rtnval));
+
+	return Rtnval;
+
+}
+
+
+/*
+ *
+ * Routine Description:
+ *
+ *   This routine is the main entry point for all CSMI function calls.
+ *
+ */
+int aac_csmi_ioctl(
+	struct aac_dev * dev,
+	int cmd,
+	void __user * arg)
+{
+	int returnStatus = -ENOTTY;
+
+	fwprintf((dev,
+	  HBA_FLAGS_DBG_FUNCTION_ENTRY_B | HBA_FLAGS_DBG_CSMI_COMMANDS_B,
+	  "aac_HandleCSMI: Enter, (scsi%d) ControlCode = %x",
+	  dev->scsi_host_ptr->host_no, cmd));
+
+	/*
+	 * Handle the supported CSMI commands
+	 */
+	switch (cmd) {
+	case CC_CSMI_SAS_GET_DRIVER_INFO:
+		returnStatus = aac_CSMIGetDriverInfo(dev, arg);
+		break;
+
+	case CC_CSMI_SAS_GET_CNTLR_CONFIG:
+		returnStatus = aac_CSMIGetControllerConfig(dev, arg);
+		break;
+
+	case CC_CSMI_SAS_GET_CNTLR_STATUS:
+		returnStatus = aac_CSMIGetControllerStatus(dev, arg);
+		break;
+
+	case CC_CSMI_SAS_GET_RAID_INFO:
+		returnStatus = aac_CSMIGetRAIDInfo(dev, arg);
+		break;
+
+	case CC_CSMI_SAS_GET_PHY_INFO:
+		returnStatus = aac_CSMIGetPhyInfo(dev, arg);
+		break;
+
+	case CC_CSMI_SAS_SET_PHY_INFO:
+		returnStatus = aac_CSMISetPhyInfo(dev, arg);
+		break;
+
+	case CC_CSMI_SAS_GET_SATA_SIGNATURE:
+		returnStatus = aac_CSMIGetSATASignature(dev, arg);
+		break;
+
+	case CC_CSMI_SAS_GET_RAID_CONFIG:
+		returnStatus = aac_CSMIGetRAIDConfig(dev, arg);
+		break;
+
+	case CC_CSMI_SAS_STP_PASSTHRU:
+		returnStatus = aac_CSMISTPPassThru(dev, arg);
+		break;
+
+	/*
+	 * Unsupported CSMI control code
+	 */
+	case CC_CSMI_SAS_FIRMWARE_DOWNLOAD:
+	case CC_CSMI_SAS_GET_SCSI_ADDRESS:
+	case CC_CSMI_SAS_GET_DEVICE_ADDRESS:
+	case CC_CSMI_SAS_SMP_PASSTHRU:
+	case CC_CSMI_SAS_SSP_PASSTHRU:
+	case CC_CSMI_SAS_GET_LINK_ERRORS:
+	case CC_CSMI_SAS_TASK_MANAGEMENT:
+	case CC_CSMI_SAS_GET_CONNECTOR_INFO:
+	case CC_CSMI_SAS_PHY_CONTROL:
+	{
+		PIOCTL_HEADER pHeader;
+
+		/*
+		 * Verify buffer size. If buffer is too small, the error
+		 * status will be set for pHeader->ReturnCode in
+		 * aac_VerifyCSMIBuffer.
+		 */
+		if (!(returnStatus = aac_VerifyCSMIBuffer(&dev, arg,
+		  sizeof(PIOCTL_HEADER), &pHeader))) {
+			pHeader->ReturnCode = CSMI_SAS_STATUS_BAD_CNTL_CODE;
+			if (!(returnStatus = aac_CloseCSMIBuffer(dev, arg,
+			  pHeader)))
+				returnStatus = -EINVAL;
+		}
+		fwprintf((dev, HBA_FLAGS_DBG_CSMI_COMMANDS_B,
+		  "aac_HandleCSMI: Unsupported ControlCode=%x",
+		  cmd));
+		break;
+	}
+	}
+
+	fwprintf((dev,
+	  HBA_FLAGS_DBG_FUNCTION_EXIT_B | HBA_FLAGS_DBG_CSMI_COMMANDS_B,
+	  "aac_HandleCSMI: Exit, ReturnCode=%d", returnStatus));
+
+	return(returnStatus);
+}
+
+#if ((LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)) ? defined(__x86_64__) : defined(CONFIG_COMPAT))
+void aac_csmi_register_ioctl32_conversion(void)
+{
+	register_ioctl32_conversion(CC_CSMI_SAS_GET_DRIVER_INFO,
+	  (int(*)(unsigned int,unsigned int,unsigned long,struct file*))sys_ioctl);
+	register_ioctl32_conversion(CC_CSMI_SAS_GET_CNTLR_CONFIG,
+	  (int(*)(unsigned int,unsigned int,unsigned long,struct file*))sys_ioctl);
+	register_ioctl32_conversion(CC_CSMI_SAS_GET_CNTLR_STATUS,
+	  (int(*)(unsigned int,unsigned int,unsigned long,struct file*))sys_ioctl);
+	register_ioctl32_conversion(CC_CSMI_SAS_GET_RAID_INFO,
+	  (int(*)(unsigned int,unsigned int,unsigned long,struct file*))sys_ioctl);
+	register_ioctl32_conversion(CC_CSMI_SAS_GET_PHY_INFO,
+	  (int(*)(unsigned int,unsigned int,unsigned long,struct file*))sys_ioctl);
+	register_ioctl32_conversion(CC_CSMI_SAS_SET_PHY_INFO,
+	  (int(*)(unsigned int,unsigned int,unsigned long,struct file*))sys_ioctl);
+	register_ioctl32_conversion(CC_CSMI_SAS_GET_SATA_SIGNATURE,
+	  (int(*)(unsigned int,unsigned int,unsigned long,struct file*))sys_ioctl);
+	register_ioctl32_conversion(CC_CSMI_SAS_GET_RAID_CONFIG,
+	  (int(*)(unsigned int,unsigned int,unsigned long,struct file*))sys_ioctl);
+	register_ioctl32_conversion(CC_CSMI_SAS_STP_PASSTHRU,
+	  (int(*)(unsigned int,unsigned int,unsigned long,struct file*))sys_ioctl);
+	register_ioctl32_conversion(CC_CSMI_SAS_FIRMWARE_DOWNLOAD,
+	  (int(*)(unsigned int,unsigned int,unsigned long,struct file*))sys_ioctl);
+	register_ioctl32_conversion(CC_CSMI_SAS_GET_SCSI_ADDRESS,
+	  (int(*)(unsigned int,unsigned int,unsigned long,struct file*))sys_ioctl);
+	register_ioctl32_conversion(CC_CSMI_SAS_GET_DEVICE_ADDRESS,
+	  (int(*)(unsigned int,unsigned int,unsigned long,struct file*))sys_ioctl);
+	register_ioctl32_conversion(CC_CSMI_SAS_SMP_PASSTHRU,
+	  (int(*)(unsigned int,unsigned int,unsigned long,struct file*))sys_ioctl);
+	register_ioctl32_conversion(CC_CSMI_SAS_SSP_PASSTHRU,
+	  (int(*)(unsigned int,unsigned int,unsigned long,struct file*))sys_ioctl);
+	register_ioctl32_conversion(CC_CSMI_SAS_GET_LINK_ERRORS,
+	  (int(*)(unsigned int,unsigned int,unsigned long,struct file*))sys_ioctl);
+	register_ioctl32_conversion(CC_CSMI_SAS_TASK_MANAGEMENT,
+	  (int(*)(unsigned int,unsigned int,unsigned long,struct file*))sys_ioctl);
+	register_ioctl32_conversion(CC_CSMI_SAS_GET_CONNECTOR_INFO,
+	  (int(*)(unsigned int,unsigned int,unsigned long,struct file*))sys_ioctl);
+	register_ioctl32_conversion(CC_CSMI_SAS_PHY_CONTROL,
+	  (int(*)(unsigned int,unsigned int,unsigned long,struct file*))sys_ioctl);
+}
+
+void aac_csmi_unregister_ioctl32_conversion(void)
+{
+	unregister_ioctl32_conversion(CC_CSMI_SAS_GET_DRIVER_INFO);
+	unregister_ioctl32_conversion(CC_CSMI_SAS_GET_CNTLR_CONFIG);
+	unregister_ioctl32_conversion(CC_CSMI_SAS_GET_CNTLR_STATUS);
+	unregister_ioctl32_conversion(CC_CSMI_SAS_GET_RAID_INFO);
+	unregister_ioctl32_conversion(CC_CSMI_SAS_GET_PHY_INFO);
+	unregister_ioctl32_conversion(CC_CSMI_SAS_SET_PHY_INFO);
+	unregister_ioctl32_conversion(CC_CSMI_SAS_GET_SATA_SIGNATURE);
+	unregister_ioctl32_conversion(CC_CSMI_SAS_GET_RAID_CONFIG);
+	unregister_ioctl32_conversion(CC_CSMI_SAS_STP_PASSTHRU);
+	unregister_ioctl32_conversion(CC_CSMI_SAS_FIRMWARE_DOWNLOAD);
+	unregister_ioctl32_conversion(CC_CSMI_SAS_GET_SCSI_ADDRESS);
+	unregister_ioctl32_conversion(CC_CSMI_SAS_GET_DEVICE_ADDRESS);
+	unregister_ioctl32_conversion(CC_CSMI_SAS_SMP_PASSTHRU);
+	unregister_ioctl32_conversion(CC_CSMI_SAS_SSP_PASSTHRU);
+	unregister_ioctl32_conversion(CC_CSMI_SAS_GET_LINK_ERRORS);
+	unregister_ioctl32_conversion(CC_CSMI_SAS_TASK_MANAGEMENT);
+	unregister_ioctl32_conversion(CC_CSMI_SAS_GET_CONNECTOR_INFO);
+	unregister_ioctl32_conversion(CC_CSMI_SAS_PHY_CONTROL);
+}
+#endif
+
+#endif
--- linux-2.6.8.1-t043-libata-update/drivers/scsi/aacraid/rx.c	2005-09-26 13:33:12.000000000 +0400
+++ aacraid-drv/drivers/scsi/aacraid/rx.c	2005-04-27 16:47:35.000000000 +0400
@@ -40,111 +40,91 @@
 #include <linux/completion.h>
 #include <linux/time.h>
 #include <linux/interrupt.h>
+#include <linux/version.h>	/* Needed for the following */
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,4,23))
+#if (!defined(IRQ_NONE))
+  typedef void irqreturn_t;
+# define IRQ_HANDLED
+# define IRQ_NONE
+#endif
+#endif
 #include <asm/semaphore.h>
 
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0))
+#include "scsi.h"
+#include "hosts.h"
+#else
 #include <scsi/scsi_host.h>
+#endif
 
 #include "aacraid.h"
 
 static irqreturn_t aac_rx_intr(int irq, void *dev_id, struct pt_regs *regs)
 {
 	struct aac_dev *dev = dev_id;
-	unsigned long bellbits;
-	u8 intstat, mask;
-	intstat = rx_readb(dev, MUnit.OISR);
-	/*
-	 *	Read mask and invert because drawbridge is reversed.
-	 *	This allows us to only service interrupts that have 
-	 *	been enabled.
-	 */
-	mask = ~(dev->OIMR);
-	/* Check to see if this is our interrupt.  If it isn't just return */
-	if (intstat & mask) 
-	{
-		bellbits = rx_readl(dev, OutboundDoorbellReg);
-		if (bellbits & DoorBellPrintfReady) {
-			aac_printf(dev, le32_to_cpu(rx_readl (dev, IndexRegs.Mailbox[5])));
-			rx_writel(dev, MUnit.ODR,DoorBellPrintfReady);
-			rx_writel(dev, InboundDoorbellReg,DoorBellPrintfDone);
-		}
-		else if (bellbits & DoorBellAdapterNormCmdReady) {
-			rx_writel(dev, MUnit.ODR, DoorBellAdapterNormCmdReady);
-			aac_command_normal(&dev->queues->queue[HostNormCmdQueue]);
-		}
-		else if (bellbits & DoorBellAdapterNormRespReady) {
-			aac_response_normal(&dev->queues->queue[HostNormRespQueue]);
-			rx_writel(dev, MUnit.ODR,DoorBellAdapterNormRespReady);
-		}
-		else if (bellbits & DoorBellAdapterNormCmdNotFull) {
-			rx_writel(dev, MUnit.ODR, DoorBellAdapterNormCmdNotFull);
+
+	dprintk((KERN_DEBUG "aac_rx_intr(%d,%p,%p)\n", irq, dev_id, regs));
+	if (dev->new_comm_interface) {
+		u32 Index = rx_readl(dev, MUnit.OutboundQueue);
+		if (Index == 0xFFFFFFFFL)
+			Index = rx_readl(dev, MUnit.OutboundQueue);
+		if (Index != 0xFFFFFFFFL) {
+			do {
+				if (aac_intr_normal(dev, Index)) {
+					rx_writel(dev, MUnit.OutboundQueue, Index);
+					rx_writel(dev, MUnit.ODR, DoorBellAdapterNormRespReady);
+				}
+				Index = rx_readl(dev, MUnit.OutboundQueue);
+			} while (Index != 0xFFFFFFFFL);
+			return IRQ_HANDLED;
 		}
-		else if (bellbits & DoorBellAdapterNormRespNotFull) {
-			rx_writel(dev, MUnit.ODR, DoorBellAdapterNormCmdNotFull);
-			rx_writel(dev, MUnit.ODR, DoorBellAdapterNormRespNotFull);
+	} else {
+		unsigned long bellbits;
+		u8 intstat;
+		intstat = rx_readb(dev, MUnit.OISR);
+		/*
+		 *	Read mask and invert because drawbridge is reversed.
+		 *	This allows us to only service interrupts that have 
+		 *	been enabled.
+		 *	Check to see if this is our interrupt.  If it isn't just return
+		 */
+		if (intstat & ~(dev->OIMR)) 
+		{
+			bellbits = rx_readl(dev, OutboundDoorbellReg);
+			if (bellbits & DoorBellPrintfReady) {
+				aac_printf(dev, rx_readl (dev, IndexRegs.Mailbox[5]));
+				rx_writel(dev, MUnit.ODR,DoorBellPrintfReady);
+				rx_writel(dev, InboundDoorbellReg,DoorBellPrintfDone);
+			}
+			else if (bellbits & DoorBellAdapterNormCmdReady) {
+				rx_writel(dev, MUnit.ODR, DoorBellAdapterNormCmdReady);
+				aac_command_normal(&dev->queues->queue[HostNormCmdQueue]);
+			}
+			else if (bellbits & DoorBellAdapterNormRespReady) {
+				rx_writel(dev, MUnit.ODR,DoorBellAdapterNormRespReady);
+				aac_response_normal(&dev->queues->queue[HostNormRespQueue]);
+			}
+			else if (bellbits & DoorBellAdapterNormCmdNotFull) {
+				rx_writel(dev, MUnit.ODR, DoorBellAdapterNormCmdNotFull);
+			}
+			else if (bellbits & DoorBellAdapterNormRespNotFull) {
+				rx_writel(dev, MUnit.ODR, DoorBellAdapterNormCmdNotFull);
+				rx_writel(dev, MUnit.ODR, DoorBellAdapterNormRespNotFull);
+			}
+			return IRQ_HANDLED;
 		}
-		return IRQ_HANDLED;
 	}
 	return IRQ_NONE;
 }
 
 /**
- *	aac_rx_enable_interrupt	-	Enable event reporting
- *	@dev: Adapter
- *	@event: Event to enable
- *
- *	Enable event reporting from the i960 for a given event.
- */
- 
-static void aac_rx_enable_interrupt(struct aac_dev * dev, u32 event)
-{
-	switch (event) {
-
-	case HostNormCmdQue:
-		dev->irq_mask &= ~(OUTBOUNDDOORBELL_1);
-		break;
-
-	case HostNormRespQue:
-		dev->irq_mask &= ~(OUTBOUNDDOORBELL_2);
-		break;
-
-	case AdapNormCmdNotFull:
-		dev->irq_mask &= ~(OUTBOUNDDOORBELL_3);
-		break;
-
-	case AdapNormRespNotFull:
-		dev->irq_mask &= ~(OUTBOUNDDOORBELL_4);
-		break;
-	}
-}
-
-/**
- *	aac_rx_disable_interrupt	-	Disable event reporting
+ *	aac_rx_disable_interrupt	-	Disable interrupts
  *	@dev: Adapter
- *	@event: Event to enable
- *
- *	Disable event reporting from the i960 for a given event.
  */
 
-static void aac_rx_disable_interrupt(struct aac_dev *dev, u32 event)
+static void aac_rx_disable_interrupt(struct aac_dev *dev)
 {
-	switch (event) {
-
-	case HostNormCmdQue:
-		dev->irq_mask |= (OUTBOUNDDOORBELL_1);
-		break;
-
-	case HostNormRespQue:
-		dev->irq_mask |= (OUTBOUNDDOORBELL_2);
-		break;
-
-	case AdapNormCmdNotFull:
-		dev->irq_mask |= (OUTBOUNDDOORBELL_3);
-		break;
-
-	case AdapNormRespNotFull:
-		dev->irq_mask |= (OUTBOUNDDOORBELL_4);
-		break;
-	}
+	rx_writeb(dev, MUnit.OIMR, dev->OIMR = 0xff);
 }
 
 /**
@@ -154,25 +134,31 @@ static void aac_rx_disable_interrupt(str
  *	@p1: first parameter
  *	@ret: adapter status
  *
- *	This routine will send a synchronous comamnd to the adapter and wait 
+ *	This routine will send a synchronous command to the adapter and wait 
  *	for its	completion.
  */
 
-static int rx_sync_cmd(struct aac_dev *dev, u32 command, u32 p1, u32 *status)
+static int rx_sync_cmd(struct aac_dev *dev, u32 command,
+	u32 p1, u32 p2, u32 p3, u32 p4, u32 p5, u32 p6,
+	u32 *status, u32 * r1, u32 * r2, u32 * r3, u32 * r4)
 {
 	unsigned long start;
 	int ok;
 	/*
 	 *	Write the command into Mailbox 0
 	 */
-	rx_writel(dev, InboundMailbox0, cpu_to_le32(command));
+	rx_writel(dev, InboundMailbox0, command);
 	/*
-	 *	Write the parameters into Mailboxes 1 - 4
+	 *	Write the parameters into Mailboxes 1 - 6
 	 */
-	rx_writel(dev, InboundMailbox1, cpu_to_le32(p1));
-	rx_writel(dev, InboundMailbox2, 0);
-	rx_writel(dev, InboundMailbox3, 0);
-	rx_writel(dev, InboundMailbox4, 0);
+	rx_writel(dev, InboundMailbox1, p1);
+	rx_writel(dev, InboundMailbox2, p2);
+	rx_writel(dev, InboundMailbox3, p3);
+	rx_writel(dev, InboundMailbox4, p4);
+#if (defined(AAC_LM_SENSOR))
+	rx_writel(dev, InboundMailbox5, p5);
+	rx_writel(dev, InboundMailbox6, p6);
+#endif
 	/*
 	 *	Clear the synch command doorbell to start on a clean slate.
 	 */
@@ -180,7 +166,7 @@ static int rx_sync_cmd(struct aac_dev *d
 	/*
 	 *	Disable doorbell interrupts
 	 */
-	rx_writeb(dev, MUnit.OIMR, dev->OIMR |= 0x04);
+	rx_writeb(dev, MUnit.OIMR, dev->OIMR = 0xff);
 	/*
 	 *	Force the completion of the mask register write before issuing
 	 *	the interrupt.
@@ -221,13 +207,25 @@ static int rx_sync_cmd(struct aac_dev *d
 		/*
 		 *	Restore interrupt mask even though we timed out
 		 */
-		rx_writeb(dev, MUnit.OIMR, dev->OIMR &= 0xfb);
+		if (dev->new_comm_interface)
+			rx_writeb(dev, MUnit.OIMR, dev->OIMR = 0xf7);
+		else
+			rx_writeb(dev, MUnit.OIMR, dev->OIMR = 0xfb);
 		return -ETIMEDOUT;
 	}
 	/*
 	 *	Pull the synch status from Mailbox 0.
 	 */
-	*status = le32_to_cpu(rx_readl(dev, IndexRegs.Mailbox[0]));
+	if (status)
+		*status = rx_readl(dev, IndexRegs.Mailbox[0]);
+	if (r1)
+		*r1 = rx_readl(dev, IndexRegs.Mailbox[1]);
+	if (r2)
+		*r2 = rx_readl(dev, IndexRegs.Mailbox[2]);
+	if (r3)
+		*r3 = rx_readl(dev, IndexRegs.Mailbox[3]);
+	if (r4)
+		*r4 = rx_readl(dev, IndexRegs.Mailbox[4]);
 	/*
 	 *	Clear the synch command doorbell.
 	 */
@@ -235,7 +233,10 @@ static int rx_sync_cmd(struct aac_dev *d
 	/*
 	 *	Restore interrupt mask
 	 */
-	rx_writeb(dev, MUnit.OIMR, dev->OIMR &= 0xfb);
+	if (dev->new_comm_interface)
+		rx_writeb(dev, MUnit.OIMR, dev->OIMR = 0xf7);
+	else
+		rx_writeb(dev, MUnit.OIMR, dev->OIMR = 0xfb);
 	return 0;
 
 }
@@ -249,8 +250,7 @@ static int rx_sync_cmd(struct aac_dev *d
 
 static void aac_rx_interrupt_adapter(struct aac_dev *dev)
 {
-	u32 ret;
-	rx_sync_cmd(dev, BREAKPOINT_REQUEST, 0, &ret);
+	rx_sync_cmd(dev, BREAKPOINT_REQUEST, 0, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL);
 }
 
 /**
@@ -279,7 +279,8 @@ static void aac_rx_notify_adapter(struct
 		rx_writel(dev, MUnit.IDR,INBOUNDDOORBELL_3);
 		break;
 	case HostShutdown:
-//		rx_sync_cmd(dev, HOST_CRASHING, 0, 0, 0, 0, &ret);
+//		rx_sync_cmd(dev, HOST_CRASHING, 0, 0, 0, 0, 0, 0,
+//		  NULL, NULL, NULL, NULL, NULL);
 		break;
 	case FastIo:
 		rx_writel(dev, MUnit.IDR,INBOUNDDOORBELL_6);
@@ -302,27 +303,13 @@ static void aac_rx_notify_adapter(struct
 
 static void aac_rx_start_adapter(struct aac_dev *dev)
 {
-	u32 status;
 	struct aac_init *init;
 
 	init = dev->init;
 	init->HostElapsedSeconds = cpu_to_le32(get_seconds());
-	/*
-	 *	Tell the adapter we are back and up and running so it will scan
-	 *	its command queues and enable our interrupts
-	 */
-	dev->irq_mask = (DoorBellPrintfReady | OUTBOUNDDOORBELL_1 | OUTBOUNDDOORBELL_2 | OUTBOUNDDOORBELL_3 | OUTBOUNDDOORBELL_4);
-	/*
-	 *	First clear out all interrupts.  Then enable the one's that we
-	 *	can handle.
-	 */
-	rx_writeb(dev, MUnit.OIMR, 0xff);
-	rx_writel(dev, MUnit.ODR, 0xffffffff);
-//	rx_writeb(dev, MUnit.OIMR, ~(u8)OUTBOUND_DOORBELL_INTERRUPT_MASK);
-	rx_writeb(dev, MUnit.OIMR, dev->OIMR = 0xfb);
-
 	// We can only use a 32 bit address here
-	rx_sync_cmd(dev, INIT_STRUCT_BASE_ADDRESS, (u32)(ulong)dev->init_pa, &status);
+	rx_sync_cmd(dev, INIT_STRUCT_BASE_ADDRESS, (u32)(ulong)dev->init_pa,
+	  0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL);
 }
 
 /**
@@ -334,7 +321,7 @@ static void aac_rx_start_adapter(struct 
  */
 static int aac_rx_check_health(struct aac_dev *dev)
 {
-	long status = rx_readl(dev, IndexRegs.Mailbox[7]);
+	u32 status = rx_readl(dev, MUnit.OMRx[0]);
 
 	/*
 	 *	Check to see if the board failed any self tests.
@@ -345,29 +332,40 @@ static int aac_rx_check_health(struct aa
 	 *	Check to see if the board panic'd.
 	 */
 	if (status & KERNEL_PANIC) {
-		char * buffer = kmalloc(512, GFP_KERNEL);
+		char * buffer;
 		struct POSTSTATUS {
-			u32 Post_Command;
-			u32 Post_Address;
-		} * post = kmalloc(sizeof(struct POSTSTATUS), GFP_KERNEL);
-		dma_addr_t paddr = pci_map_single(dev->pdev, post, sizeof(struct POSTSTATUS), 2);
-		dma_addr_t baddr = pci_map_single(dev->pdev, buffer, 512, 1);
-		u32 status = -1;
-		int ret = -2;
+			__le32 Post_Command;
+			__le32 Post_Address;
+		} * post;
+		dma_addr_t paddr, baddr;
+		int ret;
+
+		if ((status & 0xFF000000L) == 0xBC000000L)
+			return (status >> 16) & 0xFF;
+		buffer = pci_alloc_consistent(dev->pdev, 512, &baddr);
+		ret = -2;
+		if (buffer == NULL)
+			return ret;
+		post = pci_alloc_consistent(dev->pdev,
+		  sizeof(struct POSTSTATUS), &paddr);
+		if (post == NULL) {
+			pci_free_consistent(dev->pdev, 512, buffer, baddr);
+			return ret;
+		}
 		memset(buffer, 0, 512);
 		post->Post_Command = cpu_to_le32(COMMAND_POST_RESULTS);
 		post->Post_Address = cpu_to_le32(baddr);
-		rx_writel(dev, MUnit.IMRx[0], cpu_to_le32(paddr));
-		rx_sync_cmd(dev, COMMAND_POST_RESULTS, baddr, &status);
-		pci_unmap_single(dev->pdev, paddr, sizeof(struct POSTSTATUS), 2);
-		kfree(post);
+		rx_writel(dev, MUnit.IMRx[0], paddr);
+		rx_sync_cmd(dev, COMMAND_POST_RESULTS, baddr, 0, 0, 0, 0, 0,
+		  NULL, NULL, NULL, NULL, NULL);
+		pci_free_consistent(dev->pdev, sizeof(struct POSTSTATUS),
+		  post, paddr);
 		if ((buffer[0] == '0') && (buffer[1] == 'x')) {
 			ret = (buffer[2] <= '9') ? (buffer[2] - '0') : (buffer[2] - 'A' + 10);
 			ret <<= 4;
 			ret += (buffer[3] <= '9') ? (buffer[3] - '0') : (buffer[3] - 'A' + 10);
 		}
-		pci_unmap_single(dev->pdev, baddr, 512, 1);
-		kfree(buffer);
+		pci_free_consistent(dev->pdev, 512, buffer, baddr);
 		return ret;
 	}
 	/*
@@ -379,7 +377,40 @@ static int aac_rx_check_health(struct aa
 	 *	Everything is OK
 	 */
 	return 0;
-} /* aac_rx_check_health */
+}
+
+/**
+ *	aac_rx_send
+ *	@fib: fib to issue
+ *
+ *	Will send a fib, returning 0 if successful.
+ */
+static int aac_rx_send(struct fib * fib)
+{
+	u64 addr = fib->hw_fib_pa;
+	struct aac_dev *dev = fib->dev;
+	u32 * device = (u32 *)(dev->regs.rx);
+	u32 Index;
+
+	dprintk((KERN_DEBUG "%p->aac_rx_send(%p->%llx)\n", dev, fib, addr));
+	Index = rx_readl(dev, MUnit.InboundQueue);
+	if (Index == 0xFFFFFFFFL)
+		Index = rx_readl(dev, MUnit.InboundQueue);
+	dprintk((KERN_DEBUG "Index = 0x%x\n", Index));
+	if (Index == 0xFFFFFFFFL)
+		return Index;
+	device += Index / sizeof(u32);
+	dprintk((KERN_DEBUG "entry = %x %x %u\n", (u32)(addr & 0xffffffff),
+	  (u32)(addr >> 32), (u32)le16_to_cpu(fib->hw_fib->header.Size)));
+	writel((u32)(addr & 0xffffffff), device);
+	++device;
+	writel((u32)(addr >> 32), device);
+	++device;
+	writel(le16_to_cpu(fib->hw_fib->header.Size), device);
+	rx_writel(dev, MUnit.InboundQueue, Index);
+	dprintk((KERN_DEBUG "aac_rx_send - return 0\n"));
+	return 0;
+}
 
 /**
  *	aac_rx_init	-	initialize an i960 based AAC card
@@ -401,14 +432,6 @@ int aac_rx_init(struct aac_dev *dev)
 	name     = dev->name;
 
 	/*
-	 *	Map in the registers from the adapter.
-	 */
-	if((dev->regs.rx = (struct rx_registers *)ioremap((unsigned long)dev->scsi_host_ptr->base, 8192))==NULL)
-	{	
-		printk(KERN_WARNING "aacraid: unable to map i960.\n" );
-		return -1;
-	}
-	/*
 	 *	Check to see if the board failed any self tests.
 	 */
 	if (rx_readl(dev, MUnit.OMRx[0]) & SELF_TEST_FAILED) {
@@ -438,8 +461,9 @@ int aac_rx_init(struct aac_dev *dev)
 	{
 		if(time_after(jiffies, start+180*HZ))
 		{
-			status = rx_readl(dev, IndexRegs.Mailbox[7]) >> 16;
-			printk(KERN_ERR "%s%d: adapter kernel failed to start, init status = %ld.\n", dev->name, instance, status);
+			status = rx_readl(dev, IndexRegs.Mailbox[7]);
+			printk(KERN_ERR "%s%d: adapter kernel failed to start, init status = %lx.\n", 
+					dev->name, instance, status);
 			goto error_iounmap;
 		}
 		set_current_state(TASK_UNINTERRUPTIBLE);
@@ -454,14 +478,28 @@ int aac_rx_init(struct aac_dev *dev)
 	 *	Fill in the function dispatch table.
 	 */
 	dev->a_ops.adapter_interrupt = aac_rx_interrupt_adapter;
-	dev->a_ops.adapter_enable_int = aac_rx_enable_interrupt;
 	dev->a_ops.adapter_disable_int = aac_rx_disable_interrupt;
 	dev->a_ops.adapter_notify = aac_rx_notify_adapter;
 	dev->a_ops.adapter_sync_cmd = rx_sync_cmd;
 	dev->a_ops.adapter_check_health = aac_rx_check_health;
+	dev->a_ops.adapter_send = aac_rx_send;
+#if (defined(SCSI_HAS_DUMP))
+	dev->a_ops.adapter_intr = aac_rx_intr;
+#endif
+
+	/*
+	 *	First clear out all interrupts.  Then enable the one's that we
+	 *	can handle.
+	 */
+	rx_writeb(dev, MUnit.OIMR, 0xff);
+	rx_writel(dev, MUnit.ODR, 0xffffffff);
+	rx_writeb(dev, MUnit.OIMR, dev->OIMR = 0xfb);
 
 	if (aac_init_adapter(dev) == NULL)
 		goto error_irq;
+	if (dev->new_comm_interface)
+		rx_writeb(dev, MUnit.OIMR, dev->OIMR = 0xf7);
+
 	/*
 	 *	Start any kernel threads needed
 	 */
@@ -482,10 +520,10 @@ error_kfree:
 	kfree(dev->queues);
 
 error_irq:
+	rx_writeb(dev, MUnit.OIMR, dev->OIMR = 0xff);
 	free_irq(dev->scsi_host_ptr->irq, (void *)dev);
 
 error_iounmap:
-	iounmap(dev->regs.rx);
 
 	return -1;
 }