[PATCH 2.6.12-rc4-mm1 2/4] megaraid_sas: updating the driver

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



Patch 2 of 4:

Signed-off by: Sreenivas Bagalkote <sreenivas.bagalkote@xxxxxxxx>

diff -Naurp
linux-2.6.12-rc4-mm1.b/drivers/scsi/megaraid/Kconfig.megaraid_sas
linux-2.6.12-rc4-mm1.c/drivers/scsi/megaraid/Kconfig.megaraid_sas
--- linux-2.6.12-rc4-mm1.b/drivers/scsi/megaraid/Kconfig.megaraid_sas
2005-05-15 21:38:05.973172928 -0400
+++ linux-2.6.12-rc4-mm1.c/drivers/scsi/megaraid/Kconfig.megaraid_sas
1969-12-31 19:00:00.000000000 -0500
@@ -1,9 +0,0 @@
-config MEGARAID_SAS
-	tristate "LSI Logic MegaRAID SAS RAID module (New Driver)"
-	depends on PCI && SCSI
-	help
-	Module for LSI Logic's SAS based RAID controllers.
-	To compile this driver as a module, choose 'm' here.
-	Module will be called megaraid_sas
-
-
diff -Naurp linux-2.6.12-rc4-mm1.b/drivers/scsi/megaraid/megaraid_sas.c
linux-2.6.12-rc4-mm1.c/drivers/scsi/megaraid/megaraid_sas.c
--- linux-2.6.12-rc4-mm1.b/drivers/scsi/megaraid/megaraid_sas.c	2005-05-15
21:55:43.161455880 -0400
+++ linux-2.6.12-rc4-mm1.c/drivers/scsi/megaraid/megaraid_sas.c	1969-12-31
19:00:00.000000000 -0500
@@ -1,2746 +0,0 @@
-/*
- *
- *		Linux MegaRAID driver for SAS based RAID controllers
- *
- * Copyright (c) 2003-2005  LSI Logic Corporation.
- *
- *	   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 of the License, or (at your option) any later version.
- *
- * FILE		: megaraid_sas.c
- * Version	: v00.00.01.00
- *
- * Authors:
- * 	Sreenivas Bagalkote	<Sreenivas.Bagalkote@xxxxxxxx>
- *
- * List of supported controllers
- *
- * OEM	Product Name			VID	DID	SSVID	SSID
- * ---	------------			---	---	----	----
- */
-
-#include "megaraid_sas.h"
-
-static int	megasas_init			(void);
-static void	megasas_exit			(void);
-
-static int	megasas_probe_one		(struct pci_dev*,
-						const struct
pci_device_id*);
-static void	megasas_detach_one		(struct pci_dev*);
-static void	megasas_shutdown		(struct device*);
-static void	megasas_flush_cache		(struct megasas_instance*);
-static void	megasas_shutdown_controller	(struct megasas_instance*);
-
-static int	megasas_init_mfi		(struct megasas_instance*);
-static void	megasas_reset_mfi		(struct megasas_instance*);
-
-static int	megasas_transition_to_ready	(struct
megasas_register_set*);
-
-static int	megasas_alloc_cmds		(struct megasas_instance*);
-static void	megasas_free_cmds		(struct megasas_instance*);
-static int	megasas_create_frame_pool	(struct megasas_instance*);
-static void	megasas_teardown_frame_pool	(struct megasas_instance*);
-
-static int	megasas_start_aen		(struct megasas_instance*);
-static int	megasas_get_seq_num		(struct megasas_instance*,
-						struct
megasas_evt_log_info*);
-static int	megasas_register_aen		(struct megasas_instance*,
-						uint32_t, uint32_t);
-static void	megasas_service_aen		(struct megasas_instance*,
-						struct megasas_cmd*);
-
-static int	megasas_io_attach		(struct megasas_instance*);
-static void	megasas_io_detach		(struct megasas_instance*);
-
-static int	megasas_abort_handler		(struct scsi_cmnd*);
-static int	megasas_reset_handler		(struct scsi_cmnd*);
-static int	megasas_queue_command		(struct scsi_cmnd*,
-						void (*) (struct
scsi_cmnd*));
-
-static int	megasas_issue_polled		(struct megasas_instance*,
-						struct megasas_cmd*);
-static int	megasas_issue_blocked_cmd	(struct megasas_instance*,
-						struct megasas_cmd*);
-
-static int	megasas_sync_abort_cmd		(struct megasas_instance*,
-						struct megasas_cmd*);
-static void	megasas_complete_abort		(struct megasas_instance*,
-						struct megasas_cmd*);
-
-static struct megasas_cmd* megasas_build_cmd	(struct megasas_instance*,
-						struct scsi_cmnd*, int*);
-static int	megasas_build_dcdb		(struct megasas_instance*,
-						struct scsi_cmnd*,
-						struct megasas_cmd*);
-static int	megasas_build_ldio		(struct megasas_instance*,
-						struct scsi_cmnd*,
-						struct megasas_cmd*);
-
-static int	megasas_make_sgl32		(struct megasas_instance*,
-						struct scsi_cmnd*,
-						union megasas_sgl*);
-static int	megasas_make_sgl64		(struct megasas_instance*,
-						struct scsi_cmnd*,
-						union megasas_sgl*);
-
-static irqreturn_t megasas_isr			(int, void *, struct pt_regs
*);
-static void	megasas_complete_cmd		(struct megasas_instance*,
-						struct megasas_cmd*);
-static void	megasas_complete_int_cmd	(struct megasas_instance*,
-						struct megasas_cmd*);
-
-static int	megasas_mgmt_open		(struct inode*, struct
file*);
-static int	megasas_mgmt_release		(struct inode*, struct
file*);
-static int	megasas_mgmt_fasync		(int, struct file*, int);
-static int	megasas_mgmt_ioctl		(struct inode*, struct
file*,
-						unsigned int, unsigned
long);
-
-static int	megasas_mgmt_fw_ioctl		(struct megasas_instance*,
-						void __user*);
-static int	megasas_mgmt_fw_dcmd		(struct megasas_instance*,
-						struct iocpacket*, void
__user*,
-						struct megasas_cmd*);
-static int	megasas_mgmt_fw_smp		(struct megasas_instance*,
-						struct iocpacket*, void
__user*,
-						struct megasas_cmd*);
-
-static ssize_t	megasas_sysfs_show_app_hndl	(struct class_device*,
char*);
-
-static void	megasas_fill_drv_ver		(struct megasas_drv_ver*);
-static int	megasas_get_ctrl_info		(struct megasas_instance*,
-						struct megasas_ctrl_info* );
-
-MODULE_LICENSE		("GPL");
-MODULE_VERSION		(MEGASAS_VERSION);
-MODULE_AUTHOR		("LSI Logic Corporation");
-MODULE_DESCRIPTION	("LSI Logic MegaRAID SAS Driver");
-
-/*
- * PCI ID table for all supported controllers
- */
-static struct pci_device_id megasas_pci_table_g[] = {
-
-	{
-		PCI_VENDOR_ID_LSI_LOGIC,
-		PCI_DEVICE_LSI_1064,
-		PCI_SUBVENDOR_x0000,
-		PCI_SUBSYSTEM_x0000,
-	},
-	{
-		PCI_VENDOR_ID_LSI_LOGIC,
-		PCI_DEVICE_LSI_1064,
-		PCI_SUBVENDOR_x1000,
-		PCI_SUBSYSTEM_x0002,
-	},
-	{
-		PCI_VENDOR_ID_LSI_LOGIC,
-		PCI_DEVICE_LSI_1064,
-		PCI_SUBVENDOR_x1000,
-		PCI_SUBSYSTEM_x1001,
-	},
-	{
-		PCI_VENDOR_ID_DELL,
-		PCI_DEVICE_ID_PERC5,
-		PCI_VENDOR_ID_DELL,
-		PCI_SUBSYSTEM_PERC5H,
-	},
-	{
-		PCI_VENDOR_ID_DELL,
-		PCI_DEVICE_ID_PERC5,
-		PCI_VENDOR_ID_DELL,
-		PCI_SUBSYSTEM_PERC5L,
-	},
-	{
-		PCI_VENDOR_ID_DELL,
-		PCI_DEVICE_ID_PERC5,
-		PCI_VENDOR_ID_DELL,
-		PCI_SUBSYSTEM_PERC5I,
-	},
-	{
-		PCI_VENDOR_ID_LSI_LOGIC,
-		PCI_DEVICE_LSI_1064,
-		PCI_SUB_DEVICEID_FSC,
-		PCI_SUB_VENDORID_FSC,
-	},
-	{ 0 }	/* Terminating entry */
-};
-
-MODULE_DEVICE_TABLE(pci, megasas_pci_table_g);
-
-/*
- * PCI hotplug support registration structure
- */
-static struct pci_driver megasas_pci_driver = {
-
-	.name		= "megaraid_sas",
-	.id_table	= megasas_pci_table_g,
-	.probe		= megasas_probe_one,
-	.remove		= __devexit_p(megasas_detach_one),
-	.driver		= {
-				.shutdown = megasas_shutdown,
-			  }
-};
-
-/*
- * Sysfs attribute definition: Exports driver specific controller handle
- */
-CLASS_DEVICE_ATTR(megaraid_sas_app_hndl, S_IRUSR,
megasas_sysfs_show_app_hndl,
-
NULL);
-/*
- * Host template initializer for sysfs attributes
- */
-static struct class_device_attribute* megasas_shost_attrs[] = {
-	&class_device_attr_megaraid_sas_app_hndl,
-	NULL,
-};
-
-/*
- * Scsi host template for megaraid mfi driver
- */
-static struct scsi_host_template megasas_template_g = {
-
-	.module				= THIS_MODULE,
-	.name				= "LSI Logic SAS based MegaRAID
driver",
-	.proc_name			= "megaraid_sas",
-	.queuecommand			= megasas_queue_command,
-	.eh_abort_handler		= megasas_abort_handler,
-	.eh_device_reset_handler	= megasas_reset_handler,
-	.eh_bus_reset_handler		= megasas_reset_handler,
-	.eh_host_reset_handler		= megasas_reset_handler,
-	.use_clustering			= ENABLE_CLUSTERING,
-	.shost_attrs			= megasas_shost_attrs,
-};
-
-/*
- * File opereations structure for management interface
- */
-static struct file_operations megasas_mgmt_fops = {
-	.owner		= THIS_MODULE,
-	.open		= megasas_mgmt_open,
-	.release	= megasas_mgmt_release,
-	.fasync		= megasas_mgmt_fasync,
-	.ioctl		= megasas_mgmt_ioctl,
-};
-
-static	int				megasas_mgmt_majorno;
-static	struct megasas_mgmt_info	megasas_mgmt_info;
-static	struct fasync_struct*		megasas_async_queue;
-static	DECLARE_MUTEX			(megasas_async_queue_mutex);
-static	int				is_dma64;
-
-/**
- * megasas_get_cmd : Get a command from the free pool
- */
-static inline struct megasas_cmd*
-megasas_get_cmd( struct megasas_instance* instance )
-{
-	unsigned long		flags;
-	struct megasas_cmd*	cmd;
-
-	spin_lock_irqsave(&instance->cmd_pool_lock, flags);
-
-	if ( list_empty(&instance->cmd_pool)) {
-		spin_unlock_irqrestore(&instance->cmd_pool_lock, flags);
-		return NULL;
-	}
-
-	cmd = list_entry((&instance->cmd_pool)->next, struct megasas_cmd,
list);
-
-	list_del_init( &cmd->list );
-
-	spin_unlock_irqrestore( &instance->cmd_pool_lock, flags );
-
-	return cmd;
-}
-
-/**
- * megasas_return_cmd : Return a cmd to free command pool
- */
-static inline void
-megasas_return_cmd( struct megasas_instance* instance, struct megasas_cmd*
cmd )
-{
-	unsigned long flags;
-
-	spin_lock_irqsave( &instance->cmd_pool_lock, flags );
-
-	list_add( &cmd->list, &instance->cmd_pool );
-
-	spin_unlock_irqrestore( &instance->cmd_pool_lock, flags );
-}
-
-/**
- * megasas_make_sgl32	: return -1 or sge_count
- */
-static inline int
-megasas_make_sgl32( struct megasas_instance* instance, struct scsi_cmnd*
scp,
-						union megasas_sgl* mfi_sgl )
-{
-	int			i;
-	int			sge_count;
-	struct scatterlist*	os_sgl;
-	struct page*		page;
-	unsigned long		offset;
-
-	/*
-	 * Return 0 if there is no data transfer
-	 */
-	if (!scp->request_buffer || !scp->request_bufflen)
-		return 0;
-
-	if (!scp->use_sg) {
-		page	= virt_to_page( scp->request_buffer );
-		offset	= ((unsigned long)scp->request_buffer & ~PAGE_MASK);
-
-		mfi_sgl->sge32[0].phys_addr	=
pci_map_page(instance->pdev,
-							page, offset,
-
scp->request_bufflen,
-
scp->sc_data_direction);
-		mfi_sgl->sge32[0].length	= scp->request_bufflen;
-
-		return 1;
-	}
-
-	os_sgl		= (struct scatterlist*) scp->request_buffer;
-	sge_count	= pci_map_sg(instance->pdev, os_sgl, scp->use_sg,
-					scp->sc_data_direction );
-
-	for( i = 0; i < sge_count; i++, os_sgl++ ) {
-		mfi_sgl->sge32[i].length	= sg_dma_len( os_sgl );
-		mfi_sgl->sge32[i].phys_addr	= sg_dma_address( os_sgl );
-	}
-
-	return sge_count;
-}
-
-/**
- * megasas_make_sgl64	: return -1 or sge_count
- */
-static inline int
-megasas_make_sgl64( struct megasas_instance* instance, struct scsi_cmnd*
scp,
-						union megasas_sgl* mfi_sgl )
-{
-	int			i;
-	int			sge_count;
-	struct scatterlist*	os_sgl;
-	struct page*		page;
-	unsigned long		offset;
-
-	/*
-	 * Return 0 if there is no data transfer
-	 */
-	if (!scp->request_buffer || !scp->request_bufflen)
-		return 0;
-
-	if (!scp->use_sg) {
-		page	= virt_to_page( scp->request_buffer );
-		offset	= ((unsigned long)scp->request_buffer & ~PAGE_MASK);
-
-		mfi_sgl->sge64[0].phys_addr	=
pci_map_page(instance->pdev,
-							page, offset,
-
scp->request_bufflen,
-
scp->sc_data_direction);
-
-		mfi_sgl->sge64[0].length	= scp->request_bufflen;
-
-		return 1;
-	}
-
-	os_sgl		= (struct scatterlist*) scp->request_buffer;
-	sge_count	= pci_map_sg(instance->pdev, os_sgl, scp->use_sg,
-					scp->sc_data_direction );
-
-	for( i = 0; i < sge_count; i++, os_sgl++ ) {
-		mfi_sgl->sge64[i].length	= sg_dma_len( os_sgl );
-		mfi_sgl->sge64[i].phys_addr	= sg_dma_address( os_sgl );
-	}
-
-	return sge_count;
-}
-
-
-/**
- * megasas_init	: Driver load entry point
- */
-static int __init
-megasas_init( void )
-{
-	int rval;
-
-	/*
-	 * Announce driver version and other information
-	 */
-	printk( KERN_INFO "megasas: %s %s\n", MEGASAS_VERSION,
-					MEGASAS_EXT_VERSION);
-
-	/*
-	 * Initialize driver-wide structures
-	 */
-	memset( &megasas_mgmt_info, 0, sizeof(struct megasas_mgmt_info));
-
-	is_dma64 = (sizeof(dma_addr_t) == 8) ? 1 : 0;
-
-	/*
-	 * Register character device node
-	 */
-	rval =  register_chrdev(0, "megaraid_sas_ioctl",
&megasas_mgmt_fops);
-
-	if (rval < 0) {
-		printk( KERN_ERR "megasas: failed to open device node\n" );
-		return rval;
-	}
-
-	megasas_mgmt_majorno = rval;
-
-	/*
-	 * Register ourselves as PCI hotplug module
-	 */
-	rval = pci_module_init( &megasas_pci_driver );
-
-	if( rval )
-		printk(KERN_ERR "megasas: PCI hotplug regisration failed
\n");
-
-	return rval;
-}
-
-/**
- * megasas_exit : Driver unload entry point
- */
-static void __exit
-megasas_exit( void )
-{
-	pci_unregister_driver( &megasas_pci_driver );
-	unregister_chrdev( megasas_mgmt_majorno, "megaraid_sas_ioctl" );
-
-	printk( KERN_NOTICE "megasas: unloaded the driver\n" );
-
-	return;
-}
-
-/**
- * megasas_probe_one
- */
-static int __devinit
-megasas_probe_one( struct pci_dev *pdev, const struct pci_device_id *id )
-{
-	dma_addr_t			instance_h;
-	struct megasas_instance*	instance;
-
-	/*
-	 * Announce PCI information
-	 */
-	printk( KERN_INFO "megasas: probe new device "
-			"%#4.04x:%#4.04x:%#4.04x:%#4.04x: ",
-			pdev->vendor, pdev->device,
-			pdev->subsystem_vendor,	pdev->subsystem_device);
-
-	printk( KERN_INFO "megasas: bus %d:slot %d:func %d\n",
-		pdev->bus->number,
PCI_SLOT(pdev->devfn),PCI_FUNC(pdev->devfn));
-
-	/*
-	 * PCI prepping: enable device set bus mastering and dma mask
-	 */
-	if (pci_enable_device(pdev)) {
-		printk( KERN_ERR "megasas: pci_enable_device failed\n");
-		return -ENODEV;
-	}
-
-	pci_set_master(pdev);
-
-	/*
-	 * All our contollers are capable of performing 64-bit DMA
-	 */
-	if (is_dma64) {
-		if (pci_set_dma_mask( pdev, DMA_64BIT_MASK) != 0) {
-
-			printk( KERN_WARNING "megasas: failed to set 64 bit
\
-					dma mask; trying 32 bit mask\n" );
-
-			if (pci_set_dma_mask( pdev, DMA_32BIT_MASK ) != 0) {
-				printk( KERN_WARNING "megasas: failed to set
\
-							32 bit dma mask \n"
);
-
-				goto fail_set_dma_mask;
-			}
-		}
-	}
-	else {
-		if (pci_set_dma_mask( pdev, DMA_32BIT_MASK ) != 0) {
-
-			printk( KERN_WARNING "megasas: failed to set 32 bit
\
-								dma mask \n"
);
-			goto fail_set_dma_mask;
-		}
-	}
-
-	/*
-	 * We allocate DMA memory for instance soft state so that we can
-	 * can directly pass adp->{member variable} to FW to get FW data.
-	 * E.g, product information, configuration data etc.
-	 */
-	instance = pci_alloc_consistent( pdev, sizeof(struct
megasas_instance),
-								&instance_h
);
-
-	if (!instance) {
-		printk(KERN_WARNING "megasas: out of memory!\n" );
-		goto fail_alloc_instance;
-	}
-
-	memset( instance, 0, sizeof(struct megasas_instance) );
-
-	/*
-	 * Initialize locks and queues
-	 */
-	INIT_LIST_HEAD( &instance->cmd_pool );
-
-	init_waitqueue_head( &instance->int_cmd_wait_q );
-	init_waitqueue_head( &instance->abort_cmd_wait_q );
-
-	spin_lock_init( &instance->cmd_pool_lock );
-	spin_lock_init( &instance->lock );
-
-	instance->host_lock = &instance->lock;
-
-	/*
-	 * Initialize PCI related and misc parameters
-	 */
-	instance->phys_addr	= instance_h;
-	instance->pdev		= pdev;
-	instance->unique_id	= pdev->bus->number << 8 | pdev->devfn;
-	instance->init_id	= MEGADRV_DEFAULT_INIT_ID;
-	instance->aen_cmd	= NULL;
-
-	/*
-	 * Initialize MFI Firmware
-	 */
-	if (megasas_init_mfi( instance ))
-		goto fail_init_mfi;
-
-	/*
-	 * Register IRQ
-	 */
-	if (request_irq(pdev->irq, megasas_isr, SA_SHIRQ, "megasas",
-							instance)) {
-		printk( KERN_ERR "megasas: Failed to register IRQ\n" );
-		goto fail_irq;
-	}
-
-	MFI_ENABLE_INTR( instance->reg_set );
-
-	/*
-	 * Store instance in PCI softstate
-	 */
-	pci_set_drvdata( pdev, instance );
-
-	/*
-	 * Add this controller to megasas_mgmt_info structure so that it
-	 * can be exported to management applications
-	 */
-	megasas_mgmt_info.count++;
-	megasas_mgmt_info.instance[megasas_mgmt_info.max_index] = instance;
-	megasas_mgmt_info.max_index++;
-
-	/*
-	 * Initiate AEN
-	 */
-	if (megasas_start_aen(instance)) {
-		printk( KERN_WARNING "megasas: failed to initiate aen\n" );
-	}
-
-	/*
-	 * Register with SCSI mid-layer
-	 */
-	if (megasas_io_attach( instance ))
-		goto fail_io_attach;
-
-	return 0;
-
-fail_io_attach:
-	megasas_mgmt_info.count--;
-	megasas_mgmt_info.instance[megasas_mgmt_info.max_index] = NULL;
-	megasas_mgmt_info.max_index--;
-
-	pci_set_drvdata( pdev, NULL );
-	MFI_DISABLE_INTR(instance->reg_set);
-	free_irq( instance->pdev->irq, instance );
-
-	megasas_reset_mfi( instance );
-
-fail_irq:
-fail_init_mfi:
-	pci_free_consistent( pdev, sizeof(struct megasas_instance),
-						instance, instance_h );
-fail_alloc_instance:
-fail_set_dma_mask:
-	pci_disable_device( pdev );
-
-	return -ENODEV;
-}
-
-/**
- * megasas_detach_one
- */
-static void
-megasas_detach_one( struct pci_dev *pdev )
-{
-	int				i;
-	struct Scsi_Host*		host;
-	struct megasas_instance*	instance;
-	dma_addr_t			instance_h;
-
-	instance	= pci_get_drvdata( pdev );
-
-	if( !instance ) {
-		printk( KERN_ERR "megasas: Invalid detach\n" );
-		return;
-	}
-
-	host		= instance->host;
-	instance_h	= instance->phys_addr;
-
-	megasas_io_detach( instance );
-
-	megasas_flush_cache( instance );
-	megasas_shutdown_controller( instance );
-
-	/*
-	 * Take the instance off the instance array. Note that we will not
-	 * decrement the max_index. We let this array be sparse array
-	 */
-	for (i = 0; i < megasas_mgmt_info.max_index; i++ ) {
-		if (megasas_mgmt_info.instance[i] == instance) {
-			megasas_mgmt_info.count--;
-			megasas_mgmt_info.instance[i] = NULL;
-
-			break;
-		}
-	}
-
-	pci_set_drvdata( instance->pdev, NULL );
-
-	MFI_DISABLE_INTR(instance->reg_set);
-
-	free_irq( instance->pdev->irq, instance );
-
-	megasas_reset_mfi( instance );
-
-	pci_free_consistent( instance->pdev, sizeof(struct
megasas_instance),
-							instance, instance_h
);
-	scsi_host_put( host );
-
-	pci_set_drvdata( pdev, NULL );
-
-	pci_disable_device( pdev );
-
-	return;
-}
-
-/**
- * megasas_shutdown
- */
-static void
-megasas_shutdown( struct device* device )
-{
-	int				i;
-	struct megasas_instance*	instance;
-
-	printk( KERN_NOTICE "megasas: shutting down...\n" );
-
-	for( i = 0; i < megasas_mgmt_info.max_index; i++ ) {
-		instance = megasas_mgmt_info.instance[i];
-
-		if (instance)
-			megasas_shutdown_controller( instance );
-	}
-}
-
-/**
- * megasas_flush_cache
- */
-static void
-megasas_flush_cache( struct megasas_instance* instance )
-{
-	struct megasas_cmd*		cmd;
-	struct megasas_dcmd_frame*	dcmd;
-
-	if (!(cmd = megasas_get_cmd( instance )))
-		return;
-
-	dcmd = &cmd->frame->dcmd;
-
-	memset( dcmd->mbox, 0, 12 );
-
-	dcmd->cmd			= MFI_CMD_DCMD;
-	dcmd->cmd_status		= 0x0;
-	dcmd->sge_count			= 0;
-	dcmd->flags			= MFI_FRAME_DIR_NONE;
-	dcmd->timeout			= 0;
-	dcmd->data_xfer_len		= 0;
-	dcmd->opcode			= MR_DCMD_CTRL_CACHE_FLUSH;
-	dcmd->mbox[0]			= MR_FLUSH_CTRL_CACHE |
-						MR_FLUSH_DISK_CACHE;
-
-	megasas_issue_blocked_cmd( instance, cmd );
-
-	megasas_return_cmd( instance, cmd );
-
-	return;
-}
-
-/**
- * megasas_shutdown_controller
- */
-static void
-megasas_shutdown_controller( struct megasas_instance* instance )
-{
-	struct megasas_cmd*		cmd;
-	struct megasas_dcmd_frame*	dcmd;
-
-	if (!(cmd = megasas_get_cmd( instance )))
-		return;
-
-	dcmd = &cmd->frame->dcmd;
-
-	memset( dcmd->mbox, 0, 12 );
-
-	dcmd->cmd			= MFI_CMD_DCMD;
-	dcmd->cmd_status		= 0x0;
-	dcmd->sge_count			= 0;
-	dcmd->flags			= MFI_FRAME_DIR_NONE;
-	dcmd->timeout			= 0;
-	dcmd->data_xfer_len		= 0;
-	dcmd->opcode			= MR_DCMD_CTRL_SHUTDOWN;
-	dcmd->mbox[0]			= MR_ENABLE_DRIVE_SPINDOWN;
-
-	megasas_issue_blocked_cmd( instance, cmd );
-
-	megasas_return_cmd( instance, cmd );
-
-	return;
-}
-
-/**
- * megasas_init_mfi
- */
-static int
-megasas_init_mfi( struct megasas_instance* instance )
-{
-	uint32_t			context_sz;
-	uint32_t			reply_q_sz;
-	struct megasas_register_set*	reg_set;
-
-	struct megasas_cmd*		cmd;
-	struct megasas_ctrl_info	ctrl_info;
-
-	struct megasas_init_frame*	init_frame;
-	struct megasas_init_queue_info*	initq_info;
-	dma_addr_t			init_frame_h;
-	dma_addr_t			initq_info_h;
-	dma_addr_t			instance_h;
-
-	/*
-	 * Map the message registers
-	 */
-	instance->base_addr = pci_resource_start(instance->pdev, 0);
-
-	if (pci_request_regions(instance->pdev, "megasas: LSI Logic")) {
-		printk( KERN_ERR "megasas: mem region busy!\n");
-		return -EBUSY;
-	}
-
-	instance->reg_set = (struct megasas_register_set*) ioremap_nocache(
-						instance->base_addr, 8192);
-
-	if (!instance->reg_set) {
-		printk( KERN_ERR "megasas: failed to map io mem\n" );
-		goto fail_ioremap;
-	}
-
-	reg_set = instance->reg_set;
-
-	/*
-	 * We expect the FW state to be READY
-	 */
-	if (megasas_transition_to_ready(instance->reg_set))
-		goto fail_ready_state;
-
-	/*
-	 * Get various operational parameters from status register
-	 */
-	instance->max_num_sge	= MFI_MAX_SUPP_SGES(reg_set);
-	instance->max_fw_cmds	= MFI_MAX_SUPP_CMDS(reg_set);
-
-	/*
-	 * Create a pool of commands
-	 */
-	if (megasas_alloc_cmds(instance))
-		goto fail_alloc_cmds;
-
-	/*
-	 * Allocate memory for reply queue. Length of reply queue should
-	 * be one more than the maximum commands handled by the firmware.
-	 */
-	context_sz = sizeof(uint32_t);
-	reply_q_sz = context_sz * (instance->max_fw_cmds + 1);
-
-	instance->reply_queue = pci_alloc_consistent( instance->pdev,
-				reply_q_sz, &instance->reply_queue_phys_addr
);
-
-	if (!instance->reply_queue) {
-		printk( KERN_ERR "megasas: Out of DMA memory\n" );
-		goto fail_reply_queue;
-	}
-
-	/*
-	 * Prepare a init frame. Note the init frame points to queue info
-	 * structure. Each frame has SGL allocated after first 64 bytes. For
-	 * this frame - since we don't need any SGL - we use SGL's space as
-	 * queue info structure
-	 */
-	cmd = megasas_get_cmd( instance );
-
-	init_frame	= (struct megasas_init_frame*) cmd->frame;
-	initq_info	= (struct megasas_init_queue_info*)
-				((unsigned long)init_frame + 64);
-
-	instance_h	= instance->phys_addr;
-	init_frame_h	= cmd->frame_phys_addr;
-	initq_info_h	= init_frame_h + 64;
-
-	memset( init_frame, 0, MEGAMFI_FRAME_SIZE );
-	memset( initq_info, 0, sizeof(struct megasas_init_queue_info));
-
-	initq_info->init_flags = 0;
-
-	initq_info->reply_queue_entries	= instance->max_fw_cmds + 1;
-	initq_info->reply_queue_start_phys_addr_lo =
-
instance->reply_queue_phys_addr;
-	initq_info->reply_queue_start_phys_addr_hi = 0;
-
-	initq_info->producer_index_phys_addr_hi	= 0;
-	initq_info->producer_index_phys_addr_lo = instance_h + offsetof(
-							struct
megasas_instance,
-							producer);
-
-	initq_info->consumer_index_phys_addr_hi = 0;
-	initq_info->consumer_index_phys_addr_lo = instance_h + offsetof(
-							struct
megasas_instance,
-							consumer);
-
-	init_frame->cmd				= MFI_CMD_INIT;
-	init_frame->cmd_status			= 0xFF;
-	init_frame->flags			= 0;
-	init_frame->queue_info_new_phys_addr_lo	= initq_info_h;
-	init_frame->queue_info_new_phys_addr_hi	= 0;
-
-	init_frame->data_xfer_len = sizeof( struct megasas_init_queue_info);
-
-	/*
-	 * Issue the init frame in polled mode
-	 */
-	if (megasas_issue_polled(instance, cmd )) {
-		printk( KERN_ERR "megasas: failed to init firmware\n" );
-		goto fail_fw_init;
-	}
-
-	megasas_return_cmd( instance, cmd );
-
-	/*
-	 * Gather misc FW related information
-	 */
-	if (!megasas_get_ctrl_info( instance, &ctrl_info ))
-		instance->max_sectors_per_req = ctrl_info.max_request_size;
-	else
-		instance->max_sectors_per_req = instance->max_num_sge *
-						PAGE_SIZE / 512;
-
-	return 0;
-
-fail_fw_init:
-	megasas_return_cmd( instance, cmd );
-
-	pci_free_consistent( instance->pdev, reply_q_sz,
-				instance->reply_queue,
-				instance->reply_queue_phys_addr );
-fail_reply_queue:
-	megasas_free_cmds( instance );
-
-fail_alloc_cmds:
-fail_ready_state:
-	iounmap( instance->reg_set );
-
-fail_ioremap:
-	pci_release_regions( instance->pdev );
-
-	return -EINVAL;
-}
-
-/**
- * megasas_reset_mfi
- */
-static void
-megasas_reset_mfi( struct megasas_instance* instance )
-{
-	uint32_t reply_q_sz = sizeof(uint32_t) * instance->max_fw_cmds;
-
-	pci_free_consistent( instance->pdev, reply_q_sz,
-				instance->reply_queue,
-				instance->reply_queue_phys_addr );
-
-	megasas_free_cmds( instance );
-
-	iounmap( instance->reg_set );
-
-	pci_release_regions( instance->pdev );
-}
-
-/**
- * megasas_transition_to_ready	: Move the FW to READY state
- *
- * @reg_set			: MFI register set
- */
-static int
-megasas_transition_to_ready( struct megasas_register_set* reg_set )
-{
-	int		i;
-	uint8_t		max_wait;
-	uint32_t	fw_state;
-	uint32_t	cur_state;
-
-	fw_state = RD_OB_MSG_0(reg_set) & MFI_STATE_MASK;
-
-	while( fw_state != MFI_STATE_READY ) {
-
-		switch( fw_state ) {
-
-		case MFI_STATE_FAULT:
-
-			printk(KERN_WARNING "megasas: FW in FAULT
state!!\n");
-			return -ENODEV;
-
-		case MFI_STATE_WAIT_HANDSHAKE:
-			/*
-			 * Set the CLR bit in IMR0
-			 */
-			printk(KERN_INFO "megasas: FW waiting for
HANDSHAKE\n");
-			WR_IN_MSG_0( MFI_INIT_CLEAR_HANDSHAKE, reg_set );
-
-			max_wait	= 2;
-			cur_state	= MFI_STATE_WAIT_HANDSHAKE;
-			break;
-
-		case MFI_STATE_OPERATIONAL:
-			/*
-			 * Bring it to READY state; assuming max wait 2 secs
-			 */
-			MFI_DISABLE_INTR(reg_set);
-			printk(KERN_INFO "megasas: FW in OPERATIONAL
state\n");
-			WR_IN_DOORBELL( MFI_INIT_READY, reg_set );
-
-			max_wait	= 10;
-			cur_state	= MFI_STATE_OPERATIONAL;
-			break;
-
-		case MFI_STATE_UNDEFINED:
-			/*
-			 * This state should not last for more than 2
seconds
-			 */
-			printk(KERN_INFO "FW state undefined\n");
-			max_wait	= 2;
-			cur_state	= MFI_STATE_UNDEFINED;
-			break;
-
-		case MFI_STATE_BB_INIT:
-			max_wait	= 2;
-			cur_state	= MFI_STATE_BB_INIT;
-			break;
-
-		case MFI_STATE_FW_INIT:
-			max_wait	= 2;
-			cur_state	= MFI_STATE_FW_INIT;
-			break;
-
-		case MFI_STATE_DEVICE_SCAN:
-			max_wait	= 10;
-			cur_state	= MFI_STATE_DEVICE_SCAN;
-			break;
-
-		default:
-			printk(KERN_ERR "megasas: Unknown state 0x%x\n",
-								fw_state);
-			return -ENODEV;
-		}
-
-		/*
-		 * The cur_state should not last for more than max_wait secs
-		 */
-		for( i = 0; i < (max_wait * 1000); i++ ) {
-			fw_state = RD_OB_MSG_0(reg_set) & MFI_STATE_MASK;
-
-			if (fw_state == cur_state) {
-				msleep(1);
-			}
-			else
-				break;
-		}
-
-		/*
-		 * Return error if fw_state hasn't changed after max_wait
-		 */
-		if (fw_state == cur_state) {
-			printk(KERN_ERR "FW state hasn't changed in %d
secs\n",
-								max_wait);
-			return -ENODEV;
-		}
-	};
-
-	return 0;
-}
-
-/**
- * megasas_alloc_cmds
- */
-static int
-megasas_alloc_cmds( struct megasas_instance* instance )
-{
-	int			i;
-	uint32_t		max_cmd;
-	struct megasas_cmd*	cmd;
-
-	max_cmd = instance->max_fw_cmds;
-
-	/*
-	 * Alloc mem for all cmds in one chunk
-	 */
-	instance->cmd_list = kmalloc( sizeof(struct megasas_cmd) * max_cmd,
-								GFP_KERNEL);
-
-	if (!instance->cmd_list) {
-		printk( KERN_ERR "megasas: out of memory\n" );
-		return -ENOMEM;
-	}
-
-	memset( instance->cmd_list, 0, sizeof(struct megasas_cmd)*max_cmd );
-
-	/*
-	 * Slice cmd_list into individual cmds and add to cmd_pool
-	 */
-	for( i = 0, cmd = instance->cmd_list; i < max_cmd; i++, cmd++ ) {
-		cmd->index = i;
-		list_add_tail( &cmd->list, &instance->cmd_pool );
-	}
-
-	/*
-	 * Create a frame pool and assign one frame to each cmd
-	 */
-	if (megasas_create_frame_pool( instance )) {
-		printk(KERN_ERR "megasas: error creating DMA pool\n");
-		megasas_free_cmds( instance );
-	}
-
-	return 0;
-}
-
-/**
- * megasas_free_cmds
- */
-static void
-megasas_free_cmds( struct megasas_instance* instance )
-{
-	/* First free the MFI frame pool */
-	megasas_teardown_frame_pool( instance );
-
-	/* Free the cmd_list buffer itself */
-	if (instance->cmd_list ) {
-		kfree( instance->cmd_list );
-		instance->cmd_list = NULL;
-	}
-
-	INIT_LIST_HEAD( &instance->cmd_pool );
-}
-
-/**
- * megasas_create_frame_pool
- */
-static int
-megasas_create_frame_pool( struct megasas_instance* instance )
-{
-	int			i;
-	uint32_t		max_cmd;
-	uint32_t		sge_sz;
-	uint32_t		sgl_sz;
-	uint32_t		total_sz ;
-	uint32_t		frame_count;
-	struct megasas_cmd*	cmd;
-
-	max_cmd = instance->max_fw_cmds;
-
-	/*
-	 * Size of our frame is 64 bytes for MFI frame, followed by max SG
-	 * elements and finally SCSI_SENSE_BUFFERSIZE bytes for sense buffer
-	 */
-	sge_sz	= (is_dma64) ? sizeof(struct megasas_sge64) :
-				sizeof(struct megasas_sge32);
-
-	/*
-	 * Calculated the number of 64byte frames required for SGL
-	 */
-	sgl_sz		= sge_sz * instance->max_num_sge;
-	frame_count	= (sgl_sz + MEGAMFI_FRAME_SIZE -
1)/MEGAMFI_FRAME_SIZE;
-
-	/*
-	 * We need one extra frame for the MFI command
-	 */
-	frame_count++;
-
-	total_sz = MEGAMFI_FRAME_SIZE * frame_count;
-	/*
-	 * Use DMA pool facility provided by PCI layer
-	 */
-	instance->frame_dma_pool = pci_pool_create( "megasas frame pool",
-					instance->pdev, total_sz, 64, 0 );
-
-	instance->sense_dma_pool = pci_pool_create( "megasas sense pool",
-					instance->pdev, 128, 4, 0 );
-
-	if (!instance->frame_dma_pool || !instance->sense_dma_pool) {
-		printk( KERN_ERR "megasas: failed to setup DMA pool\n" );
-		return -ENOMEM;
-	}
-
-	/*
-	 * Allocate and attach a frame to each of the commands in cmd_list.
-	 * By making cmd->index as the context instead of the &cmd, we can
-	 * always use 32bit context regardless of the architecture
-	 */
-	for( i = 0, cmd = instance->cmd_list; i < max_cmd; i++, cmd++ ) {
-
-		cmd->frame = pci_pool_alloc( instance->frame_dma_pool,
-				GFP_KERNEL, &cmd->frame_phys_addr );
-
-		cmd->sense = pci_pool_alloc( instance->sense_dma_pool,
-				GFP_KERNEL, &cmd->sense_phys_addr );
-
-		if (!cmd->frame || !cmd->sense) {
-			printk(KERN_ERR "megasas: pci_pool_alloc failed
\n");
-			megasas_teardown_frame_pool( instance );
-			return -ENOMEM;
-		}
-
-		cmd->frame->io.context	= cmd->index;
-	}
-
-	return 0;
-}
-
-/**
- * megasas_teardown_frame_pool
- */
-static void
-megasas_teardown_frame_pool( struct megasas_instance* instance )
-{
-	int			i;
-	uint32_t		max_cmd = instance->max_fw_cmds;
-	struct megasas_cmd*	cmd;
-
-	if (!instance->frame_dma_pool)
-		return;
-
-	/*
-	 * Return all frames to pool
-	 */
-	for( i = 0, cmd = instance->cmd_list; i < max_cmd; i++, cmd++ ) {
-		if( cmd->frame)
-			pci_pool_free( instance->frame_dma_pool, cmd->frame,
-					cmd->frame_phys_addr );
-
-		if (cmd->sense)
-			pci_pool_free( instance->sense_dma_pool, cmd->frame,
-					cmd->sense_phys_addr );
-	}
-
-	/*
-	 * Now destroy the pool itself
-	 */
-	pci_pool_destroy( instance->frame_dma_pool );
-	pci_pool_destroy( instance->sense_dma_pool );
-
-	instance->frame_dma_pool = NULL;
-	instance->sense_dma_pool = NULL;
-}
-
-/**
- * megasas_start_aen
- */
-static int
-megasas_start_aen( struct megasas_instance* instance )
-{
-	int				ret;
-	struct megasas_evt_log_info	eli;
-	union megasas_evt_class_locale	class_locale;
-
-	/*
-	 * Get the latest sequence number from FW
-	 */
-	memset( &eli, 0, sizeof(struct megasas_evt_log_info) );
-
-	if (megasas_get_seq_num( instance, &eli )) {
-		printk( KERN_WARNING "megasas: failed to get seq num\n" );
-		return -1;
-	}
-
-	/*
-	 * Register AEN with FW for latest sequence number plus 1
-	 */
-	class_locale.members.reserved	= 0;
-	class_locale.members.locale	= MR_EVT_LOCALE_ALL;
-	class_locale.members.class	= MR_EVT_CLASS_DEBUG;
-
-	ret = megasas_register_aen( instance, eli.newest_seq_num + 1,
-						class_locale.word );
-	if (ret) {
-		printk( KERN_WARNING "megasas: aen registration failed\n" );
-		return -1;
-	}
-
-	return 0;
-}
-
-/**
- * megasas_get_seq_num
- */
-static int
-megasas_get_seq_num( struct megasas_instance* instance,
-			struct megasas_evt_log_info* eli)
-{
-	int				i;
-	int				ret = 0;
-	struct megasas_cmd*		cmd;
-	struct megasas_dcmd_frame*	dcmd;
-	struct megasas_evt_log_info*	el_info;
-	dma_addr_t			el_info_h;
-
-	cmd = megasas_get_cmd( instance );
-
-	if (!cmd) {
-		printk( KERN_ERR "megasas: failed to get a cmd\n" );
-		return -ENOMEM;
-	}
-
-	dcmd	= &cmd->frame->dcmd;
-	el_info	= pci_alloc_consistent( instance->pdev,
-				sizeof(struct megasas_evt_log_info),
-							&el_info_h );
-
-	if (!el_info) {
-		printk( KERN_ERR "megasas: cannot alloc mem for el_info\n"
);
-
-		megasas_return_cmd( instance, cmd );
-		return -ENOMEM;
-	}
-
-	memset( el_info, 0, sizeof(struct megasas_evt_log_info) );
-	for( i = 0; i < 12; i++ ) dcmd->mbox[i] = 0;
-
-	dcmd->cmd			= MFI_CMD_DCMD;
-	dcmd->cmd_status		= 0x0;
-	dcmd->sge_count			= 1;
-	dcmd->flags			= MFI_FRAME_DIR_READ;
-	dcmd->timeout			= 0;
-	dcmd->data_xfer_len		= sizeof(struct
megasas_evt_log_info);
-	dcmd->opcode			= MR_DCMD_CTRL_EVENT_GET_INFO;
-	dcmd->sgl.sge32[0].phys_addr	= el_info_h;
-	dcmd->sgl.sge32[0].length	= sizeof(struct
megasas_evt_log_info);
-
-	if (!megasas_issue_blocked_cmd( instance, cmd )) {
-		ret = 0;
-	}
-	else {
-		ret = -1;
-		printk( KERN_WARNING "megasas: failed to issue el_info\n" );
-	}
-
-	/*
-	 * Copy the data back into callers buffer
-	 */
-	if (!ret)
-		memcpy( eli, el_info, sizeof(struct megasas_evt_log_info) );
-
-	pci_free_consistent(instance->pdev, sizeof(struct
megasas_evt_log_info),
-							el_info, el_info_h);
-
-	megasas_return_cmd( instance, cmd );
-
-	return ret;
-}
-
-/**
- * megasas_register_aen
- */
-static int
-megasas_register_aen( struct megasas_instance* instance, uint32_t seq_num,
-							uint32_t locale )
-{
-	struct megasas_cmd*		cmd;
-	struct megasas_dcmd_frame*	dcmd;
-	struct megasas_evt_detail*	evt_detail;
-	dma_addr_t			evt_detail_h;
-	uint32_t*			mbox_word;
-
-	cmd = megasas_get_cmd( instance );
-
-	if (!cmd) {
-		printk( KERN_ERR "megasas: failed to get a cmd for aen\n" );
-		return -ENOMEM;
-	}
-
-	dcmd		= &cmd->frame->dcmd;
-	mbox_word	= (uint32_t*) dcmd->mbox;
-	evt_detail	= &instance->evt_detail;
-	evt_detail_h	= instance->phys_addr +
-				offsetof(struct megasas_instance,
evt_detail);
-
-	memset( evt_detail, 0, sizeof(struct megasas_evt_detail));
-
-	/*
-	 * Prepare DCMD for aen registration
-	 */
-	memset( dcmd->mbox, 0, 12 );
-
-	dcmd->cmd			= MFI_CMD_DCMD;
-	dcmd->cmd_status		= 0x0;
-	dcmd->sge_count			= 1;
-	dcmd->flags			= MFI_FRAME_DIR_READ;
-	dcmd->timeout			= 0;
-	dcmd->data_xfer_len		= sizeof(struct megasas_evt_detail);
-	dcmd->opcode			= MR_DCMD_CTRL_EVENT_WAIT;
-	mbox_word[0]			= seq_num;
-	mbox_word[1]			= locale;
-	dcmd->sgl.sge32[0].phys_addr	= (uint32_t)(evt_detail_h & 0xFFFF);
-	dcmd->sgl.sge32[0].length	= sizeof(struct megasas_evt_detail);
-
-	/*
-	 * Store reference to the cmd used to register for AEN. When an
-	 * application wants us to register for AEN, we have to abort this
-	 * cmd and re-register with a new EVENT LOCALE supplied by that app
-	 */
-	instance->aen_cmd = cmd;
-
-	/*
-	 * Issue the aen registration frame
-	 */
-	WR_IN_QPORT( (cmd->frame_phys_addr >> 3), instance->reg_set );
-
-	return 0;
-}
-
-/**
- * megasas_service_aen
- */
-static void
-megasas_service_aen(struct megasas_instance* instance, struct megasas_cmd*
cmd)
-{
-	/*
-	 * Don't signal app if it is just an aborted previously registered
aen
-	 */
-	if (!cmd->abort_aen)
-		kill_fasync( &megasas_async_queue, SIGIO, POLL_IN );
-	else
-		cmd->abort_aen = 0;
-
-	instance->aen_cmd = NULL;
-	megasas_return_cmd( instance, cmd );
-}
-
-/**
- * megasas_ioc_attach
- */
-static int
-megasas_io_attach( struct megasas_instance* instance )
-{
-	struct Scsi_Host* host;
-
-	host = scsi_host_alloc(&megasas_template_g, sizeof(void*));
-
-	if (!host) {
-		printk( KERN_ERR "megasas: scsi_host_alloc failed\n" );
-		return -ENODEV;
-	}
-
-	SCSIHOST2ADAP(host)	= (caddr_t) instance;
-	instance->host		= host;
-
-	/*
-	 * Export parameters required by SCSI mid-layer
-	 */
-	scsi_assign_lock( host, instance->host_lock );
-	scsi_set_device( host, &instance->pdev->dev );
-
-	host->irq		= instance->pdev->irq;
-	host->unique_id		= instance->unique_id;
-	host->can_queue		= instance->max_fw_cmds;
-	host->this_id		= instance->init_id;
-	host->sg_tablesize	= instance->max_num_sge;
-	host->max_sectors	= instance->max_sectors_per_req;
-	host->cmd_per_lun	= MEGADRV_MAX_CMD_PER_LUN;
-	host->max_channel	= MEGADRV_MAX_CHANNELS - 1;
-	host->max_id		= MEGADRV_MAX_DEV_PER_CHANNEL;
-	host->max_lun		= MEGADRV_MAX_LUN;
-
-	/*
-	 * Notify the mid-layer about the new controller
-	 */
-	if (scsi_add_host(host, &instance->pdev->dev)) {
-
-		printk( KERN_ERR "megasas: scsi_add_host failed\n" );
-		scsi_host_put( host );
-
-		return -ENODEV;
-	}
-
-	/*
-	 * Trigger SCSI to scan our drives
-	 */
-	scsi_scan_host( host );
-
-	return 0;
-}
-
-/**
- * megasas_io_detach
- */
-static void
-megasas_io_detach( struct megasas_instance* instance )
-{
-	if (instance->host)
-		scsi_remove_host( instance->host );
-}
-
-/**
- * megasas_abort_handler
- */
-static int
-megasas_abort_handler( struct scsi_cmnd* scmd )
-{
-	printk( KERN_NOTICE "megasas: ABORT -%ld cmd=%x <c=%d t=%d l=%d>\n",
-		scmd->serial_number, scmd->cmnd[0], SCP2CHANNEL(scmd),
-		SCP2TARGET(scmd), SCP2LUN(scmd));
-
-	return FAILED;
-}
-
-/**
- * megasas_reset_handler
- */
-static int
-megasas_reset_handler( struct scsi_cmnd* scmd )
-{
-	int				i;
-	uint32_t			wait_time = MEGADRV_RESET_WAIT_TIME;
-	uint32_t			outstanding;
-	struct megasas_instance*	instance = SCP2ADAPTER(scmd);
-
-	spin_unlock( instance->host_lock );
-
-	printk( KERN_NOTICE "megasas: RESET -%ld cmd=%x <c=%d t=%d l=%d>\n",
-		scmd->serial_number, scmd->cmnd[0], SCP2CHANNEL(scmd),
-		SCP2TARGET(scmd), SCP2LUN(scmd));
-
-
-	for( i = 0; i < wait_time; i++ ) {
-
-		outstanding = instance->producer - instance->consumer;
-
-		if (!outstanding)
-			break;
-
-		if (outstanding < 0)
-			outstanding = instance->max_fw_cmds + 1
-							-
instance->consumer;
-		if (!(i % MEGADRV_RESET_NOTICE_INTERVAL)) {
-			printk( KERN_NOTICE "megasas: [%2d]waiting for %d \
-				commands to complete\n", i, outstanding );
-		}
-
-		msleep(1000);
-	}
-
-	spin_lock( instance->host_lock );
-
-	if (outstanding) {
-		printk( KERN_CRIT "megasas: failed to do reset\n");
-		return FAILED;
-	}
-
-	printk( KERN_NOTICE "megasas: reset successful \n" );
-
-	return SUCCESS;
-}
-
-/**
- * megasas_queue_command
- */
-static int
-megasas_queue_command( struct scsi_cmnd* scmd, void (*done)(struct
scsi_cmnd*) )
-{
-	uint32_t			frame_count;
-	struct megasas_cmd*		cmd;
-	struct megasas_instance*	instance;
-	uint32_t			msg_frame;
-
-	instance	= SCP2ADAPTER(scmd);
-	scmd->scsi_done	= done;
-	scmd->result	= 0;
-
-	cmd = megasas_build_cmd( instance, scmd, &frame_count );
-
-	if (!cmd) {
-		done(scmd);
-		return 0;
-	}
-
-	cmd->scmd = scmd;
-
-	/*
-	 * Issue the command to the FW
-	 */
-	msg_frame = (cmd->frame_phys_addr >> 3) | (cmd->frame_count - 1);
-
-	WR_IN_QPORT( msg_frame, instance->reg_set );
-
-	return 0;
-}
-
-/**
- * megasas_issue_polled
- */
-static int
-megasas_issue_polled(struct megasas_instance* instance, struct megasas_cmd*
cmd)
-{
-	int		i;
-	uint32_t	msecs = MFI_POLL_TIMEOUT_SECS * 1000;
-
-	struct megasas_header* frame_hdr = (struct
megasas_header*)cmd->frame;
-
-	frame_hdr->cmd_status	= 0xFF;
-	frame_hdr->flags 	|= MFI_FRAME_DONT_POST_IN_REPLY_QUEUE;
-
-	/*
-	 * Issue the frame using inbound queue port
-	 */
-	WR_IN_QPORT( (cmd->frame_phys_addr >> 3), instance->reg_set );
-
-	/*
-	 * Wait for cmd_status to change
-	 */
-	for( i=0; i < msecs && (frame_hdr->cmd_status == 0xff); i++ ) {
-		rmb();
-		msleep(1);
-	}
-
-	if (frame_hdr->cmd_status == 0xff)
-		return -ETIME;
-
-	return 0;
-}
-
-/**
- * megasas_issue_blocked_cmd
- */
-static int
-megasas_issue_blocked_cmd( struct megasas_instance* instance,
-					struct megasas_cmd* cmd )
-{
-	uint32_t msg_frame;
-
-	cmd->cmd_status	= ENODATA;
-	msg_frame	= (cmd->frame_phys_addr >> 3);
-
-	WR_IN_QPORT( msg_frame, instance->reg_set );
-
-	wait_event( instance->int_cmd_wait_q, (cmd->cmd_status != ENODATA));
-
-	return 0;
-}
-
-/**
- * megasas_sync_abort_cmd
- */
-static int
-megasas_sync_abort_cmd( struct megasas_instance* instance,
-			struct megasas_cmd* cmd_to_abort )
-{
-	struct megasas_cmd*		cmd;
-	struct megasas_abort_frame*	abort_fr;
-
-	cmd = megasas_get_cmd( instance );
-
-	if (!cmd)
-		return -1;
-
-	abort_fr = &cmd->frame->abort;
-
-	/*
-	 * Prepare and issue the abort frame
-	 */
-	abort_fr->cmd				= MFI_CMD_ABORT;
-	abort_fr->cmd_status			= 0xFF;
-	abort_fr->flags				= 0;
-	abort_fr->abort_context			= cmd_to_abort->index;
-	abort_fr->abort_mfi_phys_addr_lo	=
cmd_to_abort->frame_phys_addr;
-	abort_fr->abort_mfi_phys_addr_hi	= 0;
-
-	WR_IN_QPORT( (cmd->frame_phys_addr >> 3), instance->reg_set );
-
-	/*
-	 * Wait for this cmd to complete
-	 */
-	cmd->sync_cmd = 1;
-	wait_event( instance->abort_cmd_wait_q, (cmd->cmd_status != 0xFF));
-
-	megasas_return_cmd( instance, cmd );
-
-	return 0;
-}
-
-/**
- * megasas_complete_abort
- */
-static void
-megasas_complete_abort( struct megasas_instance* instance,
-				struct megasas_cmd* cmd )
-{
-	if (cmd->sync_cmd) {
-		cmd->sync_cmd = 0;
-		wake_up( &instance->abort_cmd_wait_q );
-	}
-
-	return;
-}
-
-/**
- * megasas_build_cmd
- */
-static struct megasas_cmd*
-megasas_build_cmd( struct megasas_instance* instance, struct scsi_cmnd*
scp,
-							int* frame_count )
-{
-	uint32_t		logical_cmd;
-	struct megasas_cmd*	cmd;
-
-	/*
-	 * Find out if this is logical or physical drive command.
-	 */
-	logical_cmd	= MEGADRV_IS_LOGICAL(scp);
-
-	/*
-	 * Logical drive command
-	 */
-	if (logical_cmd) {
-
-		if (SCP2TARGET(scp) >= MEGADRV_MAX_LD) {
-			scp->result = DID_BAD_TARGET << 16;
-			return NULL;
-		}
-
-		switch(scp->cmnd[0]) {
-
-		case READ_10:
-		case WRITE_10:
-		case READ_12:
-		case WRITE_12:
-		case READ_6:
-		case WRITE_6:
-		case READ_16:
-		case WRITE_16:
-			/*
-			 * Fail for LUN > 0
-			 */
-			if (SCP2LUN(scp)) {
-				scp->result = DID_BAD_TARGET << 16;
-				return NULL;
-			}
-
-			if (!(cmd = megasas_get_cmd(instance))) {
-				scp->result = DID_ERROR << 16;
-				return NULL;
-			}
-
-			*frame_count = megasas_build_ldio(instance, scp,
cmd);
-
-			if (! (*frame_count) ) {
-				printk( "megasas: build_ldio error\n" );
-
-				megasas_return_cmd( instance, cmd );
-
-				return NULL;
-			}
-
-			return cmd;
-
-		case REPORT_LUNS:
-			scp->result	= DID_ERROR << 16;
-			return NULL;
-
-		default:
-			/*
-			 * Fail for LUN > 0
-			 */
-			if (SCP2LUN(scp)) {
-				scp->result = DID_BAD_TARGET << 16;
-				return NULL;
-			}
-
-			if (!(cmd = megasas_get_cmd( instance ))) {
-				scp->result = DID_ERROR << 16;
-				return NULL;
-			}
-
-			*frame_count = megasas_build_dcdb(instance, scp,
cmd);
-
-			if (! (*frame_count) ) {
-				printk( "megasas: build_dcdb error\n" );
-
-				megasas_return_cmd( instance, cmd );
-
-				return NULL;
-			}
-
-			return cmd;
-		}
-	}
-	else {
-		scp->result = DID_BAD_TARGET << 16;
-		return NULL;
-	}
-
-	return NULL;
-}
-
-/**
- * megasas_build_dcdb
- */
-static int
-megasas_build_dcdb( struct megasas_instance* instance, struct scsi_cmnd*
scp,
-						struct megasas_cmd* cmd )
-{
-	uint32_t			sge_sz;
-	int				sge_bytes;
-	uint32_t			is_logical;
-	uint32_t			device_id;
-	uint16_t			flags = 0;
-	struct megasas_pthru_frame*	pthru;
-
-	is_logical		= MEGADRV_IS_LOGICAL(scp);
-	device_id		= MEGADRV_DEV_INDEX(instance, scp);
-	pthru			= (struct megasas_pthru_frame_t*)
cmd->frame;
-
-	if (scp->sc_data_direction == PCI_DMA_TODEVICE )
-		flags = MFI_FRAME_DIR_WRITE;
-	else if( scp->sc_data_direction == PCI_DMA_FROMDEVICE )
-		flags = MFI_FRAME_DIR_READ;
-	else if( scp->sc_data_direction == PCI_DMA_NONE )
-		flags = MFI_FRAME_DIR_NONE;
-
-	/*
-	 * Prepare the DCDB frame
-	 */
-	pthru->cmd		= (is_logical) ? MFI_CMD_LD_SCSI_IO :
-							MFI_CMD_PD_SCSI_IO;
-	pthru->cmd_status	= 0x0;
-	pthru->scsi_status	= 0x0;
-	pthru->target_id	= device_id;
-	pthru->lun		= SCP2LUN(scp);
-	pthru->cdb_len		= scp->cmd_len;
-	pthru->timeout		= 0;
-	pthru->flags		= flags;
-	pthru->data_xfer_len	= scp->request_bufflen;
-
-	memcpy(pthru->cdb, scp->cmnd, scp->cmd_len);
-
-	/*
-	 * Construct SGL
-	 */
-	sge_sz 	= (is_dma64) ? sizeof(struct megasas_sge64) :
-				sizeof(struct megasas_sge32);
-
-	if (is_dma64) {
-		pthru->flags	|= MFI_FRAME_SGL64;
-		pthru->sge_count = megasas_make_sgl64( instance, scp,
-								&pthru->sgl
);
-	}
-	else
-		pthru->sge_count = megasas_make_sgl32( instance, scp,
-								&pthru->sgl
);
-
-	/*
-	 * Sense info specific
-	 */
-	pthru->sense_len		= SCSI_SENSE_BUFFERSIZE;
-	pthru->sense_buf_phys_addr_hi	= 0;
-	pthru->sense_buf_phys_addr_lo	= cmd->sense_phys_addr;
-
-	sge_bytes = sge_sz * pthru->sge_count;
-
-	cmd->frame_count = (sge_bytes / MEGAMFI_FRAME_SIZE) +
-				((sge_bytes % MEGAMFI_FRAME_SIZE) ? 1 : 0) +
1;
-
-	if (cmd->frame_count > 7)
-		cmd->frame_count = 8;
-
-	return cmd->frame_count;
-}
-
-/**
- * megasas_build_ldio
- */
-static int
-megasas_build_ldio( struct megasas_instance* instance, struct scsi_cmnd*
scp,
-						struct megasas_cmd* cmd )
-{
-	uint32_t			sge_sz;
-	int				sge_bytes;
-	uint32_t			device_id;
-	uint8_t				sc = scp->cmnd[0];
-	uint16_t			flags = 0;
-
-	struct megasas_io_frame*	ldio;
-
-	device_id		= MEGADRV_DEV_INDEX(instance, scp);
-	ldio			= (struct megasas_io_frame*) cmd->frame;
-
-	if (scp->sc_data_direction == PCI_DMA_TODEVICE )
-		flags = MFI_FRAME_DIR_WRITE;
-	else if( scp->sc_data_direction == PCI_DMA_FROMDEVICE )
-		flags = MFI_FRAME_DIR_READ;
-
-	/*
-	 * Preare the Logical IO frame: 2nd bit is zero for all read cmds
-	 */
-	ldio->cmd		= (sc &
0x02)?MFI_CMD_LD_WRITE:MFI_CMD_LD_READ;
-	ldio->cmd_status	= 0x0;
-	ldio->scsi_status	= 0x0;
-	ldio->target_id		= device_id;
-	ldio->timeout		= 0;
-	ldio->reserved_0	= 0;
-	ldio->pad_0		= 0;
-	ldio->flags		= flags;
-	ldio->start_lba_hi	= 0;
-	ldio->access_byte	= (scp->cmd_len != 6) ? scp->cmnd[1] : 0;
-
-	/*
-	 * 6-byte READ(0x08) or WRITE(0x0A) cdb
-	 */
-	if (scp->cmd_len == 6) {
-		ldio->lba_count		=	(uint32_t)scp->cmnd[4];
-		ldio->start_lba_lo	= 	((uint32_t)scp->cmnd[1] <<
16)|
-						((uint32_t)scp->cmnd[2] <<
8) |
-						(uint32_t)scp->cmnd[3];
-
-		ldio->start_lba_lo 	&=	0x1FFFFF;
-	}
-
-	/*
-	 * 10-byte READ(0x28) or WRITE(0x2A) cdb
-	 */
-	else if (scp->cmd_len == 10) {
-		ldio->lba_count		=	(uint32_t)scp->cmnd[8] |
-						((uint32_t)scp->cmnd[7] <<
8);
-		ldio->start_lba_lo	=	((uint32_t)scp->cmnd[2] <<
24)|
-						((uint32_t)scp->cmnd[3] <<
16)|
-						((uint32_t)scp->cmnd[4] <<
8)|
-						(uint32_t)scp->cmnd[5];
-	}
-
-	/*
-	 * 12-byte READ(0xA8) or WRITE(0xAA) cdb
-	 */
-	else if (scp->cmd_len == 12) {
-		ldio->lba_count		=	((uint32_t)scp->cmnd[6] <<
24)|
-						((uint32_t)scp->cmnd[7] <<
16)|
-						((uint32_t)scp->cmnd[8] <<
8) |
-						(uint32_t)scp->cmnd[9];
-
-		ldio->start_lba_lo	=	((uint32_t)scp->cmnd[2] <<
24)|
-						((uint32_t)scp->cmnd[3] <<
16)|
-						((uint32_t)scp->cmnd[4] <<
8) |
-						(uint32_t)scp->cmnd[5];
-	}
-
-	/*
-	 * 16-byte READ(0x88) or WRITE(0x8A) cdb
-	 */
-	else if (scp->cmd_len == 16) {
-		ldio->lba_count		=	((uint32_t)scp->cmnd[10] <<
24)|
-						((uint32_t)scp->cmnd[11] <<
16)|
-						((uint32_t)scp->cmnd[12] <<
8) |
-						(uint32_t)scp->cmnd[13];
-
-		ldio->start_lba_lo	=	((uint32_t)scp->cmnd[6] <<
24)|
-						((uint32_t)scp->cmnd[7] <<
16)|
-						((uint32_t)scp->cmnd[8] <<
8) |
-						(uint32_t)scp->cmnd[9];
-
-		ldio->start_lba_hi	=	((uint32_t)scp->cmnd[2] <<
24)|
-						((uint32_t)scp->cmnd[3] <<
16)|
-						((uint32_t)scp->cmnd[4] <<
8) |
-						(uint32_t)scp->cmnd[5];
-
-	}
-
-	/*
-	 * Construct SGL
-	 */
-	sge_sz 	= (is_dma64) ? sizeof(struct megasas_sge64) :
-					sizeof(struct megasas_sge32);
-
-	if (is_dma64) {
-		ldio->flags	|= MFI_FRAME_SGL64;
-		ldio->sge_count = megasas_make_sgl64( instance, scp,
-								&ldio->sgl
);
-	}
-	else
-		ldio->sge_count = megasas_make_sgl32( instance, scp,
-								&ldio->sgl
);
-
-	/*
-	 * Sense info specific
-	 */
-	ldio->sense_len			= SCSI_SENSE_BUFFERSIZE;
-	ldio->sense_buf_phys_addr_hi	= 0;
-	ldio->sense_buf_phys_addr_lo	= cmd->sense_phys_addr;
-
-	sge_bytes = sge_sz * ldio->sge_count;
-
-	cmd->frame_count = (sge_bytes / MEGAMFI_FRAME_SIZE) +
-				((sge_bytes % MEGAMFI_FRAME_SIZE) ? 1 : 0) +
1;
-
-	if (cmd->frame_count > 7)
-		cmd->frame_count = 8;
-
-	return cmd->frame_count;
-}
-
-/**
- * megasas_isr
- */
-static irqreturn_t
-megasas_isr(int irq, void *devp, struct pt_regs *regs)
-{
-	uint32_t				status;
-	int32_t					completed;
-	uint32_t				producer;
-	uint32_t				consumer;
-	uint32_t				context;
-
-	struct megasas_instance*		instance;
-	struct megasas_register_set*		reg_set;
-	struct megasas_cmd*			cmd;
-
-	instance	= (struct megasas_instance*) devp;
-	reg_set		= instance->reg_set;
-
-	/*
-	 * Check if it is our interrupt
-	 */
-	status = RD_OB_INTR_STATUS(reg_set);
-
-	if (! (status & MFI_OB_INTR_STATUS_MASK)) {
-		return IRQ_NONE;
-	}
-
-	/*
-	 * Clear the interrupt by writing back the same value
-	 */
-	WR_OB_INTR_STATUS(status, reg_set);
-
-	producer	= instance->producer;
-	consumer	= instance->consumer;
-	completed	= producer - consumer;
-
-	if (completed < 0) {
-		completed = instance->max_fw_cmds + 1 - consumer;
-	}
-
-	while( completed-- ) {
-		context = instance->reply_queue[consumer];
-
-		cmd = &(instance->cmd_list)[context];
-
-		megasas_complete_cmd( instance, cmd );
-
-		consumer++;
-		if (consumer > instance->max_fw_cmds + 1) {
-			consumer = 0;
-		}
-	}
-
-	wmb();
-	instance->consumer = producer;
-
-	return IRQ_HANDLED;
-}
-
-static inline void
-megasas_sync_buffers(struct megasas_instance* instance, struct megasas_cmd*
cmd)
-{
-	dma_addr_t	buf_h;
-	uint8_t		opcode;
-
-	if (cmd->scmd->use_sg) {
-		pci_unmap_sg( instance->pdev, cmd->scmd->request_buffer,
-			cmd->scmd->use_sg, cmd->scmd->sc_data_direction );
-		return;
-	}
-
-	if (!cmd->scmd->request_bufflen)
-		return;
-
-	opcode = cmd->frame->hdr.cmd;
-
-	if ((opcode == MFI_CMD_LD_READ) || (opcode == MFI_CMD_LD_WRITE)) {
-		if (is_dma64)
-			buf_h = cmd->frame->io.sgl.sge64[0].phys_addr;
-		else
-			buf_h = cmd->frame->io.sgl.sge32[0].phys_addr;
-	}
-	else {
-		if (is_dma64)
-			buf_h = cmd->frame->pthru.sgl.sge64[0].phys_addr;
-		else
-			buf_h = cmd->frame->pthru.sgl.sge32[0].phys_addr;
-	}
-
-	pci_unmap_page( instance->pdev, buf_h, cmd->scmd->request_bufflen,
-						cmd->scmd->sc_data_direction
);
-	return;
-}
-
-/**
- * megasas_complete_cmd
- */
-static void
-megasas_complete_cmd(struct megasas_instance* instance, struct megasas_cmd*
cmd)
-{
-	struct megasas_header* hdr = &cmd->frame->hdr;
-
-	switch( hdr->cmd ) {
-
-	case MFI_CMD_LD_READ:
-	case MFI_CMD_LD_WRITE:
-	case MFI_CMD_LD_SCSI_IO:
-	case MFI_CMD_PD_SCSI_IO:
-
-		switch (hdr->cmd_status) {
-
-		case MFI_STAT_OK:
-			cmd->scmd->result = DID_OK << 16;
-			break;
-
-		case MFI_STAT_SCSI_DONE_WITH_ERROR:
-			cmd->scmd->result = hdr->scsi_status << 1 |
-						hdr->cmd_status << 8;
-
-			if (hdr->scsi_status == CHECK_CONDITION) {
-				memset( cmd->scmd->sense_buffer, 0,
-
SCSI_SENSE_BUFFERSIZE );
-				memcpy( cmd->scmd->sense_buffer, cmd->sense,
-							hdr->sense_len );
-				cmd->scmd->result |= DRIVER_SENSE << 24 |
-								DID_OK <<
16;
-			}
-			else
-				cmd->scmd->result |= DID_ERROR << 16;
-
-			break;
-
-		case MFI_STAT_DEVICE_NOT_FOUND:
-			cmd->scmd->result = DID_BAD_TARGET << 16;
-			break;
-
-		default:
-			printk( KERN_NOTICE "megasas: unhandled status
%#x\n",
-							hdr->cmd_status);
-			cmd->scmd->result = DID_ERROR << 16;
-		}
-
-		spin_lock( instance->host_lock );
-		cmd->scmd->scsi_done( cmd->scmd );
-		spin_unlock( instance->host_lock );
-
-		megasas_return_cmd( instance, cmd );
-
-		megasas_sync_buffers( instance, cmd );
-		break;
-
-	case MFI_CMD_DCMD:
-
-		/*
-		 * See if got an event notification
-		 */
-		if (cmd->frame->dcmd.opcode == MR_DCMD_CTRL_EVENT_WAIT)
-			megasas_service_aen( instance, cmd );
-		else
-			megasas_complete_int_cmd( instance, cmd );
-
-		break;
-
-	case MFI_CMD_ABORT:
-		/*
-		 * Cmd issued to abort another cmd returned
-		 */
-		megasas_complete_abort( instance, cmd );
-		break;
-
-	default:
-		printk(KERN_ERR "megasas isr: unknown cmd 0x%x\n
completed!!\n",
hdr->cmd );
-		break;
-	}
-}
-
-/**
- * megasas_complete_int_cmd
- */
-static void
-megasas_complete_int_cmd(struct megasas_instance* instance,
-					struct megasas_cmd* cmd)
-{
-	cmd->cmd_status = cmd->frame->io.cmd_status;
-
-	if (cmd->cmd_status == ENODATA) {
-		cmd->cmd_status = 0;
-	}
-	wake_up( &instance->int_cmd_wait_q );
-}
-
-/**
- * megasas_mgmt_open
- */
-static int
-megasas_mgmt_open( struct inode* inode, struct file* filep )
-{
-	/*
-	 * Allow only those users with admin rights
-	 */
-	if (!capable(CAP_SYS_ADMIN))
-		return -EACCES;
-
-	return 0;
-}
-
-/**
- * megasas_mgmt_release
- */
-static int
-megasas_mgmt_release( struct inode* inode, struct file* filep )
-{
-	return 0;
-}
-
-/**
- * megasas_mgmt_fasync
- */
-static int
-megasas_mgmt_fasync( int fd, struct file* filep, int mode )
-{
-	int rc;
-
-	down( &megasas_async_queue_mutex );
-
-	rc = fasync_helper( fd, filep, mode, &megasas_async_queue );
-
-	up( &megasas_async_queue_mutex );
-
-	if (rc >0)
-		return 0;
-
-	printk( KERN_WARNING "megasas: fasync_helper failed %d\n", rc );
-
-	return rc;
-}
-
-/**
- * megasas_mgmt_ioctl
- */
-static int
-megasas_mgmt_ioctl( struct inode* inode, struct file* filep,
-			unsigned int cmd, unsigned long arg )
-{
-	int				i;
-	int				j;
-	int				rc;
-	uint8_t				fw_status;
-	struct iocpacket		uioc;
-	void __user*			argp;
-	void __user*			udata_addr;
-	uint8_t				user_64bit_sgl = 0;
-	uint32_t			opcode;
-	uint32_t			locale;
-	uint32_t			seq_num;
-	uint32_t*			mbox_word;
-	struct megasas_cmd*		old_cmd;
-
-	struct megasas_instance*		instance;
-	struct megasas_dcmd_frame*		kdcmd;
-	struct megasas_dcmd_frame __user*	udcmd;
-	struct megasas_drv_ver			dv;
-
-	argp = (void __user*) arg;
-
-	if (copy_from_user( &uioc, argp, sizeof(struct iocpacket))) {
-		printk( KERN_WARNING "megasas: copy_from_user failed\n" );
-		return -EINVAL;
-	}
-
-	if (strncmp(uioc.signature, IOC_SIGNATURE, strlen(IOC_SIGNATURE))
!=0){
-		printk( KERN_WARNING "megasas: invalid ioctl signature\n" );
-		return -EINVAL;
-	}
-
-	if (uioc.version != 0) {
-		printk( KERN_WARNING "megasas: invalid ioctl version %d\n",
-								uioc.version
);
-		return -EINVAL;
-	}
-
-	instance	= NULL;
-	kdcmd		= (struct megasas_dcmd_frame*) uioc.frame;
-	udcmd		= (struct megasas_dcmd_frame*)
-				(((struct iocpacket*)argp)->frame);
-
-	/*
-	 * Find out if user has used 32 or 64 bit SGL
-	 */
-	if (kdcmd->flags & MFI_FRAME_SGL64 )
-		user_64bit_sgl = 1;
-
-	if (!user_64bit_sgl)
-		udata_addr = (void __user *) kdcmd->sgl.sge32[0].phys_addr;
-	else
-		udata_addr = (void __user *) (unsigned long)
-
kdcmd->sgl.sge64[0].phys_addr;
-
-	i = ((uioc.controller_id & 0xF0) >> 4) - 1;
-
-	if (i < megasas_mgmt_info.max_index)
-		instance = megasas_mgmt_info.instance[i];
-	else
-		instance = NULL;
-
-	if ((uioc.control_code == MR_DRIVER_IOCTL_LINUX) ||
-		(uioc.control_code == MR_DRIVER_IOCTL_COMMON)) {
-		/*
-		 * If MR_DRIVER_IOCTL_LINUX or MR_DRIVER_IOCTL_COMMON
-		 * look at dcmd->opcode for the actual operation
-		 */
-		opcode = kdcmd->opcode;
-	}
-	else {
-		/* FW Command */
-		opcode = uioc.control_code;
-	}
-
-	switch (opcode) {
-
-	case MR_DRIVER_IOCTL_DRIVER_VERSION:
-
-		megasas_fill_drv_ver( &dv );
-
-		if (copy_to_user(udata_addr, &dv, sizeof(dv))) {
-			printk( KERN_WARNING "megasas: copy_to_user
failed\n" );
-			return -EFAULT;
-		}
-
-		rc		= 0;
-		fw_status	= MFI_STAT_OK;
-
-		if (copy_to_user( &udcmd->cmd_status, &fw_status,
-						sizeof(uint8_t))) {
-			rc = -EFAULT;
-			printk( KERN_WARNING "megasas: copy_to_user
failed\n" );
-		}
-
-		break;
-
-	case MR_LINUX_GET_ADAPTER_COUNT:
-
-		if (copy_to_user(udata_addr, &megasas_mgmt_info.count,
-							sizeof(uint16_t))) {
-			printk( KERN_WARNING "megasas: copy_to_user
failed\n" );
-			return -EFAULT;
-		}
-
-		rc		= 0;
-		fw_status	= MFI_STAT_OK;
-
-		if (copy_to_user( &udcmd->cmd_status, &fw_status,
-						sizeof(uint8_t))) {
-			rc = -EFAULT;
-			printk( KERN_WARNING "megasas: copy_to_user
failed\n" );
-		}
-
-		break;
-
-	case MR_LINUX_GET_ADAPTER_MAP:
-		/*
-		 * README: encrypting logic for adapter map
-		 * The adpater field size allows up to 16-bit adapter
number,
-		 * which translates into 65536 possible adapters, which
-		 * obviously is too much. So we reserve the lower 4-bits to
-		 * put the coding nibble (0xF) and add 1 to the adapter
-		 * number. Applications shall have (12-bits - 1) to provide
-		 * the adapter number. This still translates in 4095
possible
-		 * adapters, which should be  sufficient :-)
-		*/
-		memset(megasas_mgmt_info.map, 0,
-			sizeof(uint16_t) * MAX_MGMT_ADAPTERS);
-
-		j = 0;
-		for (i = 0; i < megasas_mgmt_info.max_index; i++) {
-			if (megasas_mgmt_info.instance[i]) {
-				megasas_mgmt_info.map[j++] =
-					((i + 1) << 4) | 0xF;
-			}
-		}
-
-		if ((j) && (copy_to_user(udata_addr, megasas_mgmt_info.map,
-				sizeof(uint16_t) * j))) {
-
-			printk(KERN_ERR "megasas:invalid uaddr for hba
map\n" );
-			return -EFAULT;
-		}
-
-		fw_status	= MFI_STAT_OK;
-		rc		= 0;
-
-		if (copy_to_user( &udcmd->cmd_status, &fw_status,
-						sizeof(uint8_t))) {
-			rc = -EFAULT;
-			printk( KERN_ERR "megasas: invalid uaddr\n" );
-		}
-
-		break;
-
-	case MR_LINUX_GET_AEN:
-
-		if (!instance) {
-			printk( KERN_WARNING "megasas: invalid instance \n"
);
-			return -ENODEV;
-		}
-
-		mbox_word	= (uint32_t*) kdcmd->mbox;
-		seq_num		= mbox_word[0];
-		locale		= mbox_word[1];
-		old_cmd		= instance->aen_cmd;
-
-		if (old_cmd) {
-			old_cmd->abort_aen = 1;
-			rc = megasas_sync_abort_cmd(instance, old_cmd);
-
-			if (rc) {
-				printk(KERN_WARNING "megasas: failed to
abort \
-								prev aen\n"
);
-				break;
-			}
-		}
-
-		rc = megasas_register_aen( instance, seq_num, locale );
-
-		break;
-
-	case IOC_CMD_FIRMWARE:
-
-		if (!instance) {
-			printk( KERN_WARNING "megasas: invalid instance \n"
);
-			return -ENODEV;
-		}
-
-		rc = megasas_mgmt_fw_ioctl( instance, argp );
-
-		break;
-
-	default:
-		printk( KERN_WARNING "megasas: unsupported ioctl %d\n",
-							uioc.control_code );
-		return -ENOTTY;
-	}
-
-	return rc;
-}
-
-/**
- * megasas_mgmt_fw_ioctl
- */
-static int
-megasas_mgmt_fw_ioctl( struct megasas_instance* instance, void __user* argp
)
-{
-	struct iocpacket		uioc;
-	struct megasas_header*		hdr;
-	struct megasas_cmd*		cmd;
-
-	if (copy_from_user(&uioc, argp, sizeof(struct iocpacket))) {
-		printk( KERN_ERR "megasas ioctl: copy_from_user failed\n" );
-		return -EFAULT;
-	}
-
-	cmd = megasas_get_cmd( instance );
-
-	if (!cmd) {
-		printk( KERN_WARNING "megasas: failed to get a cmd packet\n"
);
-		return -ENOMEM;
-	}
-
-	hdr = (struct megasas_header*) &uioc.frame;
-
-	switch( hdr->cmd ) {
-
-		case MFI_CMD_DCMD:
-			return megasas_mgmt_fw_dcmd(instance, &uioc, argp,
cmd);
-
-		case MFI_CMD_SMP:
-			return megasas_mgmt_fw_smp(instance, &uioc, argp,
cmd);
-
-		default:
-			printk( KERN_WARNING "megasas: invalid fw ioctl \n"
);
-			return -EINVAL;
-	}
-
-	megasas_return_cmd( instance, cmd );
-	return 0;
-}
-
-/**
- * megasas_mgmt_fw_dcmd
- */
-static int
-megasas_mgmt_fw_dcmd( struct megasas_instance* instance, struct iocpacket*
uioc,
-				void __user* argp, struct megasas_cmd* cmd )
-{
-	int					rc = 0;
-	void __user*				ubuff;
-	struct megasas_dcmd_frame*		kdcmd;
-	struct megasas_dcmd_frame __user*	udcmd;
-	struct megasas_dcmd_frame*		cmd_dcmd;
-	caddr_t					kbuff;
-	dma_addr_t				kbuff_h;
-	uint32_t				xferlen;
-	uint8_t					user_64bit_sgl = 0;
-
-	cmd_dcmd	= &cmd->frame->dcmd;
-	kdcmd 		= (struct megasas_dcmd_frame_t*) &uioc->frame;
-	udcmd		= (struct megasas_dcmd_frame_t*)
-				(((struct iocpacket*)argp)->frame);
-
-	if (kdcmd->flags & MFI_FRAME_SGL64 )
-		user_64bit_sgl = 1;
-
-	if (!user_64bit_sgl) {
-		xferlen	= kdcmd->sgl.sge32[0].length;
-		ubuff	= (void __user*) udcmd->sgl.sge32[0].phys_addr;
-	}
-	else {
-		xferlen	= kdcmd->sgl.sge64[0].length;
-		ubuff	= (void __user*) (ulong)
udcmd->sgl.sge64[0].phys_addr;
-	}
-
-	/*
-	 * Allocate internal buffer for data transfer
-	 */
-	if (xferlen)
-		kbuff = pci_alloc_consistent(instance->pdev, xferlen,
&kbuff_h);
-	else
-		kbuff = NULL;
-
-	if (xferlen && !kbuff) {
-		printk( KERN_ERR "megasas: memalloc failed for int buff \n"
);
-		return -ENOMEM;
-	}
-
-	if (xferlen && (kdcmd->flags & MFI_FRAME_DIR_WRITE)) {
-
-		if (copy_from_user(kbuff, ubuff, xferlen)) {
-			printk( KERN_ERR "megasas: cp_from_usr failed\n" );
-			return -EFAULT;
-		}
-	}
-
-	cmd_dcmd->cmd				= kdcmd->cmd;
-	cmd_dcmd->cmd_status			= kdcmd->cmd_status;
-	cmd_dcmd->sge_count			= kdcmd->sge_count;
-	cmd_dcmd->timeout			= kdcmd->timeout;
-	cmd_dcmd->data_xfer_len			= kdcmd->data_xfer_len;
-	cmd_dcmd->opcode			= kdcmd->opcode;
-
-	memcpy( cmd_dcmd->mbox, kdcmd->mbox, 12 );
-
-	if (!user_64bit_sgl) {
-		cmd_dcmd->flags			= kdcmd->flags;
-		cmd_dcmd->sgl.sge32[0].length	=
kdcmd->sgl.sge32[0].length;
-		cmd_dcmd->sgl.sge32[0].phys_addr= kbuff_h;
-	}
-	else {
-		cmd_dcmd->flags			= kdcmd->flags
|MFI_FRAME_SGL64;
-		cmd_dcmd->sgl.sge64[0].length	=
kdcmd->sgl.sge64[0].length;
-		cmd_dcmd->sgl.sge64[0].phys_addr= kbuff_h;
-	}
-
-	if (!megasas_issue_blocked_cmd( instance, cmd )) {
-
-		if (xferlen && (kdcmd->flags & MFI_FRAME_DIR_READ)) {
-
-			if (copy_to_user( ubuff, kbuff, xferlen)) {
-
-				printk(KERN_ERR "megasas: cp_to_usr
failed\n");
-				rc = -EFAULT;
-				goto exit_label;
-			}
-		}
-
-		if (copy_to_user( &udcmd->cmd_status, &cmd_dcmd->cmd_status,
-							sizeof(uint8_t))) {
-			printk(KERN_ERR "megasas: cp_to_usr failed\n");
-			rc = -EFAULT;
-			goto exit_label;
-		}
-	}
-	else {
-		printk( KERN_WARNING "megasas: fw_ioctl failed\n" );
-	}
-
-exit_label:
-	pci_free_consistent( instance->pdev, xferlen, kbuff, kbuff_h );
-	return rc;
-}
-
-/**
- * megasas_mgmt_fw_smp
- */
-static int
-megasas_mgmt_fw_smp( struct megasas_instance* instance, struct iocpacket*
uioc,
-				void __user* argp, struct megasas_cmd* cmd )
-{
-	int					rc = 0;
-	struct megasas_smp_frame*		ksmp;
-	struct megasas_smp_frame __user*	usmp;
-	struct megasas_smp_frame*		cmd_smp;
-
-	caddr_t				kreq;
-	caddr_t				kresp;
-	dma_addr_t			kreq_h;
-	dma_addr_t			kresp_h;
-	void __user*			ureq;
-	void __user*			uresp;
-	uint32_t			req_len;
-	uint32_t			resp_len;
-
-	uint8_t				user_64bit_sgl = 0;
-
-	cmd_smp		= &cmd->frame->smp;
-	ksmp 		= (struct megasas_smp_frame*) &uioc->frame;
-	usmp		= (struct megasas_smp_frame_t*)
-				(((struct iocpacket*)argp)->frame);
-
-	if (ksmp->flags & MFI_FRAME_SGL64 )
-		user_64bit_sgl = 1;
-
-	if (!user_64bit_sgl) {
-		req_len		= ksmp->request_sgl.sge32[0].length;
-		resp_len	= ksmp->response_sgl.sge32[0].length;
-
-		ureq	= (void __user*)
usmp->request_sgl.sge32[0].phys_addr;
-		uresp	= (void __user*)
usmp->response_sgl.sge32[0].phys_addr;
-	}
-	else {
-		req_len		= ksmp->request_sgl.sge64[0].length;
-		resp_len	= ksmp->response_sgl.sge64[0].length;
-
-		ureq	= (void __user*) (ulong)
-
usmp->request_sgl.sge64[0].phys_addr;
-		uresp	= (void __user*) (ulong)
-
usmp->response_sgl.sge64[0].phys_addr;
-	}
-
-	if (!req_len || !resp_len) {
-		printk( KERN_WARNING "megasas: invalid req/resp lenghth\n"
);
-		return -EINVAL;
-	}
-
-	/*
-	 * Allocate kernel buffers for SMP request and response
-	 */
-
-	kreq	= NULL;
-	kresp	= NULL;
-
-	if (!(kreq = pci_alloc_consistent(instance->pdev, req_len,
&kreq_h))){
-
-		printk( KERN_ERR "megasas: memalloc err for req\n" );
-		rc = -ENOMEM;
-		goto exit_label;
-	}
-
-	if(!(kresp = pci_alloc_consistent(instance->pdev, resp_len,
&kresp_h))){
-		printk( KERN_ERR "megasas: memalloc err for resp\n" );
-		rc = -ENOMEM;
-		goto exit_label;
-	}
-
-	if (copy_from_user(kreq, ureq, req_len)) {
-		printk( KERN_ERR "megasas: copy_from_user failed\n" );
-		rc = -EFAULT;
-		goto exit_label;
-	}
-
-	memcpy (cmd_smp, ksmp, MEGAMFI_FRAME_SIZE );
-	cmd_smp->context = cmd->index;
-
-	if (!user_64bit_sgl) {
-		cmd_smp->flags					=
ksmp->flags;
-		cmd_smp->request_sgl.sge32[0].length		= req_len;
-		cmd_smp->request_sgl.sge32[0].phys_addr		= kreq_h;
-		cmd_smp->response_sgl.sge32[0].length		= resp_len;
-		cmd_smp->response_sgl.sge32[0].phys_addr	= kresp_h;
-	}
-	else {
-		cmd_smp->flags					=
ksmp->flags |
-
MFI_FRAME_SGL64;
-		cmd_smp->request_sgl.sge64[0].length		= req_len;
-		cmd_smp->request_sgl.sge64[0].phys_addr		= kreq_h;
-		cmd_smp->response_sgl.sge64[0].length		= resp_len;
-		cmd_smp->response_sgl.sge64[0].phys_addr	= kresp_h;
-	}
-
-	if (!megasas_issue_blocked_cmd( instance, cmd )) {
-
-		if (copy_to_user( uresp, kresp, resp_len)) {
-			printk( KERN_ERR "megasas: copy_to_user failed\n" );
-			rc = -EFAULT;
-			goto exit_label;
-		}
-
-		if (copy_to_user( &usmp->cmd_status, &cmd_smp->cmd_status,
-							sizeof(uint8_t))) {
-			printk( KERN_ERR "megasas: copy_to_user failed\n" );
-			rc = -EFAULT;
-			goto exit_label;
-		}
-	}
-	else {
-		printk( KERN_WARNING "megasas: smp failed\n" );
-	}
-
-exit_label:
-
-	if (kreq)
-		pci_free_consistent(instance->pdev, req_len, kreq, kreq_h);
-	if (kresp)
-		pci_free_consistent(instance->pdev, resp_len, kresp,
kresp_h);
-
-	return rc;
-}
-
-/**
- * megasas_sysfs_show_app_hndl
- */
-static ssize_t
-megasas_sysfs_show_app_hndl( struct class_device* cdev, char* buf )
-{
-	int				i;
-	uint32_t			hndl = 0;
-	struct Scsi_Host*		shost;
-	struct megasas_instance*	instance;
-
-	shost		= class_to_shost( cdev );
-	instance	= (struct megasas_instance*)SCSIHOST2ADAP( shost );
-
-	for (i = 0; i < megasas_mgmt_info.max_index; i++ ) {
-
-		if (instance == megasas_mgmt_info.instance[i])
-			hndl = ((i + 1) << 4) | 0xF;
-	}
-
-	return snprintf( buf, 8, "%u\n", hndl );
-}
-
-/**
- * megasas_fill_drv_ver
- */
-static void
-megasas_fill_drv_ver( struct megasas_drv_ver* dv )
-{
-	memset( dv, 0, sizeof(struct megasas_drv_ver) );
-
-	memcpy(dv->signature,	"$LSI LOGIC$",	strlen("$LSI LOGIC$")	);
-	memcpy(dv->os_name,	"Linux",	strlen("Linux")		);
-	memcpy(dv->os_ver,	"Ver Indpndt",	strlen("ver indpndt")	);
-	memcpy(dv->drv_name,	"megaraid_sas",	strlen("megaraid_sas")	);
-	memcpy(dv->drv_ver,	MEGASAS_VERSION,strlen(MEGASAS_VERSION)	);
-	memcpy(dv->drv_rel_date,MEGASAS_RELDATE,strlen(MEGASAS_RELDATE)	);
-}
-
-/**
- * megasas_get_controller_info
- */
-static int
-megasas_get_ctrl_info( struct megasas_instance* instance,
-				struct megasas_ctrl_info* ctrl_info )
-{
-	int				i;
-	int				ret = 0;
-	struct megasas_cmd*		cmd;
-	struct megasas_dcmd_frame*	dcmd;
-	struct megasas_ctrl_info*	ci;
-	dma_addr_t			ci_h;
-
-	cmd = megasas_get_cmd( instance );
-
-	if (!cmd) {
-		printk( KERN_WARNING "Failed to get a cmd for ctrl info\n"
);
-		return -ENOMEM;
-	}
-
-	dcmd = &cmd->frame->dcmd;
-
-	ci = pci_alloc_consistent( instance->pdev,
-				sizeof(struct megasas_ctrl_info), &ci_h );
-
-	if (!ci) {
-		printk( KERN_WARNING "Failed to alloc mem for ctrl info\n"
);
-		megasas_return_cmd( instance, cmd );
-		return -ENOMEM;
-	}
-
-	memset( ci, 0, sizeof(struct megasas_ctrl_info));
-	for( i = 0; i < 12; i++ ) dcmd->mbox[i] = 0;
-
-	dcmd->cmd			= MFI_CMD_DCMD;
-	dcmd->cmd_status		= 0xFF;
-	dcmd->sge_count			= 1;
-	dcmd->flags			= MFI_FRAME_DIR_READ;
-	dcmd->timeout			= 0;
-	dcmd->data_xfer_len		= sizeof(struct megasas_ctrl_info);
-	dcmd->opcode			= MR_DCMD_CTRL_GET_INFO;
-	dcmd->sgl.sge32[0].phys_addr	= ci_h;
-	dcmd->sgl.sge32[0].length	= sizeof(struct megasas_ctrl_info);
-
-	if (!megasas_issue_polled( instance, cmd )) {
-		ret = 0;
-		memcpy( ctrl_info, ci, sizeof(struct megasas_ctrl_info));
-	}
-	else {
-		printk( KERN_WARNING "Ctrl info failed\n" );
-		ret = -1;
-	}
-
-	pci_free_consistent( instance->pdev, sizeof(struct
megasas_ctrl_info),
-								ci, ci_h );
-
-	megasas_return_cmd( instance, cmd );
-	return ret;
-}
-
-module_init( megasas_init );
-module_exit( megasas_exit );
-
-/* vim: set ts=8 sw=8 tw=78 ai si: */
-
: send the line "unsubscribe linux-scsi" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at  http://vger.kernel.org/majordomo-info.html

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[Index of Archives]     [SCSI Target Devel]     [Linux SCSI Target Infrastructure]     [Kernel Newbies]     [IDE]     [Security]     [Git]     [Netfilter]     [Bugtraq]     [Yosemite News]     [MIPS Linux]     [ARM Linux]     [Linux Security]     [Linux RAID]     [Linux ATA RAID]     [Linux IIO]     [Samba]     [Device Mapper]
  Powered by Linux