Commit 9c915a8c authored by Adam Radford's avatar Adam Radford Committed by James Bottomley
Browse files

[SCSI] megaraid_sas: Add 9565/9285 specific code 



This patch adds MegaRAID 9265/9285 (Device id 0x5b) specific code

Signed-off-by: default avatarAdam Radford <aradford@gmail.com>
Signed-off-by: default avatarJames Bottomley <James.Bottomley@suse.de>
parent cd50ba8e

drivers/scsi/megaraid/Makefile

+2 −1
Original line number Diff line number Diff line 
obj-$(CONFIG_MEGARAID_MM)	+= megaraid_mm.o

obj-$(CONFIG_MEGARAID_MAILBOX)	+= megaraid_mbox.o

obj-$(CONFIG_MEGARAID_SAS)	+= megaraid_sas.o

megaraid_sas-objs := megaraid_sas_base.o
 
megaraid_sas-objs := megaraid_sas_base.o megaraid_sas_fusion.o \

	megaraid_sas_fp.o

drivers/scsi/megaraid/megaraid_sas.h

+30 −8
Original line number Diff line number Diff line
@@ -33,9 +33,9 @@ 
/*

 * MegaRAID SAS Driver meta data

 */

#define MEGASAS_VERSION			"00.00.04.31-rc1"

#define MEGASAS_RELDATE			"May 3, 2010"

#define MEGASAS_EXT_VERSION		"Mon. May 3, 11:41:51 PST 2010"

#define MEGASAS_VERSION				"00.00.05.29-rc1"

#define MEGASAS_RELDATE				"Dec. 7, 2010"

#define MEGASAS_EXT_VERSION			"Tue. Dec. 7 17:00:00 PDT 2010"



/*

 * Device IDs
@@ -47,6 +47,7 @@ 
#define	PCI_DEVICE_ID_LSI_SAS0079GEN2		0x0079

#define	PCI_DEVICE_ID_LSI_SAS0073SKINNY		0x0073

#define	PCI_DEVICE_ID_LSI_SAS0071SKINNY		0x0071

#define	PCI_DEVICE_ID_LSI_FUSION		0x005b



/*

 * =====================================
@@ -436,7 +437,6 @@ struct megasas_ctrl_prop { 
	* Add properties that can be controlled by

	* a bit in the following structure.

	*/



	struct {

		u32     copyBackDisabled            : 1;

		u32     SMARTerEnabled              : 1;
@@ -716,6 +716,7 @@ struct megasas_ctrl_info { 
#define MEGASAS_DEFAULT_INIT_ID			-1

#define MEGASAS_MAX_LUN				8

#define MEGASAS_MAX_LD				64

#define MEGASAS_DEFAULT_CMD_PER_LUN		128

#define MEGASAS_MAX_PD                          (MEGASAS_MAX_PD_CHANNELS * \

						MEGASAS_MAX_DEV_PER_CHANNEL)

#define MEGASAS_MAX_LD_IDS			(MEGASAS_MAX_LD_CHANNELS * \
@@ -784,7 +785,10 @@ struct megasas_ctrl_info { 
*/

 

struct megasas_register_set {

	u32 	reserved_0[4];			/*0000h*/

	u32	doorbell;                       /*0000h*/

	u32	fusion_seq_offset;		/*0004h*/

	u32	fusion_host_diag;		/*0008h*/

	u32	reserved_01;			/*000Ch*/



	u32 	inbound_msg_0;			/*0010h*/

	u32 	inbound_msg_1;			/*0014h*/
@@ -804,15 +808,18 @@ struct megasas_register_set { 
	u32 	inbound_queue_port;		/*0040h*/

	u32 	outbound_queue_port;		/*0044h*/



	u32 	reserved_2[22];			/*0048h*/

	u32	reserved_2[9];			/*0048h*/

	u32	reply_post_host_index;		/*006Ch*/

	u32	reserved_2_2[12];		/*0070h*/



	u32 	outbound_doorbell_clear;	/*00A0h*/



	u32 	reserved_3[3];			/*00A4h*/



	u32 	outbound_scratch_pad ;		/*00B0h*/

	u32	outbound_scratch_pad_2;         /*00B4h*/



	u32 	reserved_4[3];			/*00B4h*/

	u32	reserved_4[2];			/*00B8h*/



	u32 	inbound_low_queue_port ;	/*00C0h*/
@@ -1287,6 +1294,9 @@ struct megasas_instance { 


	u16 max_num_sge;

	u16 max_fw_cmds;

	/* For Fusion its num IOCTL cmds, for others MFI based its

	   max_fw_cmds */

	u16 max_mfi_cmds;

	u32 max_sectors_per_req;

	struct megasas_aen_event *ev;
@@ -1336,9 +1346,15 @@ struct megasas_instance { 
	struct timer_list io_completion_timer;

	struct list_head internal_reset_pending_q;



	/* Ptr to hba specfic information */

	void *ctrl_context;

	u8	msi_flag;

	struct msix_entry msixentry;

	u64 map_id;

	struct megasas_cmd *map_update_cmd;

	unsigned long bar;

	long reset_flags;

	struct mutex reset_mutex;

};



enum {
@@ -1397,8 +1413,14 @@ struct megasas_cmd { 
	struct list_head list;

	struct scsi_cmnd *scmd;

	struct megasas_instance *instance;

	union {

		struct {

			u16 smid;

			u16 resvd;

		} context;

		u32 frame_count;

	};

};



#define MAX_MGMT_ADAPTERS		1024

#define MAX_IOCTL_SGE			16

drivers/scsi/megaraid/megaraid_sas_base.c

+260 −102
Original line number Diff line number Diff line
@@ -53,6 +53,7 @@ 
#include <scsi/scsi_cmnd.h>

#include <scsi/scsi_device.h>

#include <scsi/scsi_host.h>

#include "megaraid_sas_fusion.h"

#include "megaraid_sas.h"



/*
@@ -81,7 +82,7 @@ MODULE_VERSION(MEGASAS_VERSION); 
MODULE_AUTHOR("megaraidlinux@lsi.com");

MODULE_DESCRIPTION("LSI MegaRAID SAS Driver");



static int megasas_transition_to_ready(struct megasas_instance *instance);

int megasas_transition_to_ready(struct megasas_instance *instance);

static int megasas_get_pd_list(struct megasas_instance *instance);

static int megasas_issue_init_mfi(struct megasas_instance *instance);

static int megasas_register_aen(struct megasas_instance *instance,
@@ -109,6 +110,8 @@ static struct pci_device_id megasas_pci_table[] = { 
	/* xscale IOP, vega */

	{PCI_DEVICE(PCI_VENDOR_ID_DELL, PCI_DEVICE_ID_DELL_PERC5)},

	/* xscale IOP */

	{PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_FUSION)},

	/* Fusion */

	{}

};
@@ -122,15 +125,16 @@ static DEFINE_MUTEX(megasas_async_queue_mutex); 
static int megasas_poll_wait_aen;

static DECLARE_WAIT_QUEUE_HEAD(megasas_poll_wait);

static u32 support_poll_for_event;

static u32 megasas_dbg_lvl;

u32 megasas_dbg_lvl;

static u32 support_device_change;



/* define lock for aen poll */

spinlock_t poll_aen_lock;



static void

void

megasas_complete_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd,

		     u8 alt_status);



static irqreturn_t megasas_isr(int irq, void *devp);

static u32

megasas_init_adapter_mfi(struct megasas_instance *instance);
@@ -138,6 +142,23 @@ u32 
megasas_build_and_issue_cmd(struct megasas_instance *instance,

			    struct scsi_cmnd *scmd);

static void megasas_complete_cmd_dpc(unsigned long instance_addr);

void

megasas_release_fusion(struct megasas_instance *instance);

int

megasas_ioc_init_fusion(struct megasas_instance *instance);

void

megasas_free_cmds_fusion(struct megasas_instance *instance);

u8

megasas_get_map_info(struct megasas_instance *instance);

int

megasas_sync_map_info(struct megasas_instance *instance);

int

wait_and_poll(struct megasas_instance *instance, struct megasas_cmd *cmd);

void megasas_reset_reply_desc(struct megasas_instance *instance);

u8 MR_ValidateMapInfo(struct MR_FW_RAID_MAP_ALL *map,

		      struct LD_LOAD_BALANCE_INFO *lbInfo);

int megasas_reset_fusion(struct Scsi_Host *shost);

void megasas_fusion_ocr_wq(struct work_struct *work);



void

megasas_issue_dcmd(struct megasas_instance *instance, struct megasas_cmd *cmd)
@@ -152,7 +173,7 @@ megasas_issue_dcmd(struct megasas_instance *instance, struct megasas_cmd *cmd) 
 *

 * Returns a free command from the pool

 */

static struct megasas_cmd *megasas_get_cmd(struct megasas_instance

struct megasas_cmd *megasas_get_cmd(struct megasas_instance

						  *instance)

{

	unsigned long flags;
@@ -177,7 +198,7 @@ static struct megasas_cmd *megasas_get_cmd(struct megasas_instance 
 * @instance:		Adapter soft state

 * @cmd:		Command packet to be returned to free command pool

 */

static inline void

inline void

megasas_return_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd)

{

	unsigned long flags;
@@ -185,6 +206,7 @@ megasas_return_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd) 
	spin_lock_irqsave(&instance->cmd_pool_lock, flags);



	cmd->scmd = NULL;

	cmd->frame_count = 0;

	list_add_tail(&cmd->list, &instance->cmd_pool);



	spin_unlock_irqrestore(&instance->cmd_pool_lock, flags);
@@ -796,6 +818,11 @@ static struct megasas_instance_template megasas_instance_template_gen2 = { 
*       specific to gen2 (deviceid : 0x78, 0x79) controllers

*/



/*

 * Template added for TB (Fusion)

 */

extern struct megasas_instance_template megasas_instance_template_fusion;



/**

 * megasas_issue_polled -	Issues a polling command

 * @instance:			Adapter soft state
@@ -803,11 +830,9 @@ static struct megasas_instance_template megasas_instance_template_gen2 = { 
 *

 * For polling, MFI requires the cmd_status to be set to 0xFF before posting.

 */

static int

int

megasas_issue_polled(struct megasas_instance *instance, struct megasas_cmd *cmd)

{

	int i;

	u32 msecs = MFI_POLL_TIMEOUT_SECS * 1000;



	struct megasas_header *frame_hdr = &cmd->frame->hdr;
@@ -817,21 +842,12 @@ megasas_issue_polled(struct megasas_instance *instance, struct megasas_cmd *cmd) 
	/*

	 * Issue the frame using inbound queue port

	 */

	instance->instancet->fire_cmd(instance,

			cmd->frame_phys_addr, 0, instance->reg_set);

	instance->instancet->issue_dcmd(instance, cmd);



	/*

	 * 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;

	return wait_and_poll(instance, cmd);

}



/**
@@ -849,8 +865,7 @@ megasas_issue_blocked_cmd(struct megasas_instance *instance, 
{

	cmd->cmd_status = ENODATA;



	instance->instancet->fire_cmd(instance,

			cmd->frame_phys_addr, 0, instance->reg_set);

	instance->instancet->issue_dcmd(instance, cmd);



	wait_event(instance->int_cmd_wait_q, cmd->cmd_status != ENODATA);
@@ -894,8 +909,7 @@ megasas_issue_blocked_abort_cmd(struct megasas_instance *instance, 
	cmd->sync_cmd = 1;

	cmd->cmd_status = 0xFF;



	instance->instancet->fire_cmd(instance,

			cmd->frame_phys_addr, 0, instance->reg_set);

	instance->instancet->issue_dcmd(instance, cmd);



	/*

	 * Wait for this cmd to complete
@@ -1291,7 +1305,7 @@ megasas_build_ldio(struct megasas_instance *instance, struct scsi_cmnd *scp, 
 * Called by megasas_queue_command to find out if the command to be queued

 * is a logical drive command

 */

static inline int megasas_is_ldio(struct scsi_cmnd *cmd)

inline int megasas_is_ldio(struct scsi_cmnd *cmd)

{

	if (!MEGASAS_IS_LOGICAL(cmd))

		return 0;
@@ -1551,15 +1565,44 @@ static int megasas_slave_alloc(struct scsi_device *sdev) 
	return 0;

}



static void megaraid_sas_kill_hba(struct megasas_instance *instance)

void megaraid_sas_kill_hba(struct megasas_instance *instance)

{

	if ((instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||

		(instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0071SKINNY)) {

		writel(MFI_STOP_ADP,

			&instance->reg_set->reserved_0[0]);

	    (instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0071SKINNY) ||

	    (instance->pdev->device == PCI_DEVICE_ID_LSI_FUSION)) {

		writel(MFI_STOP_ADP, &instance->reg_set->doorbell);

	} else {

		writel(MFI_STOP_ADP,

			&instance->reg_set->inbound_doorbell);

		writel(MFI_STOP_ADP, &instance->reg_set->inbound_doorbell);

	}

}



 /**

  * megasas_check_and_restore_queue_depth - Check if queue depth needs to be

  *					restored to max value

  * @instance:			Adapter soft state

  *

  */

void

megasas_check_and_restore_queue_depth(struct megasas_instance *instance)

{

	unsigned long flags;

	if (instance->flag & MEGASAS_FW_BUSY

		&& time_after(jiffies, instance->last_time + 5 * HZ)

		&& atomic_read(&instance->fw_outstanding) < 17) {



		spin_lock_irqsave(instance->host->host_lock, flags);

		instance->flag &= ~MEGASAS_FW_BUSY;

		if ((instance->pdev->device ==

			PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||

			(instance->pdev->device ==

			PCI_DEVICE_ID_LSI_SAS0071SKINNY)) {

			instance->host->can_queue =

				instance->max_fw_cmds - MEGASAS_SKINNY_INT_CMDS;

		} else

			instance->host->can_queue =

				instance->max_fw_cmds - MEGASAS_INT_CMDS;



		spin_unlock_irqrestore(instance->host->host_lock, flags);

	}

}
@@ -1613,24 +1656,7 @@ static void megasas_complete_cmd_dpc(unsigned long instance_addr) 
	/*

	 * Check if we can restore can_queue

	 */

	if (instance->flag & MEGASAS_FW_BUSY

		&& time_after(jiffies, instance->last_time + 5 * HZ)

		&& atomic_read(&instance->fw_outstanding) < 17) {



		spin_lock_irqsave(instance->host->host_lock, flags);

		instance->flag &= ~MEGASAS_FW_BUSY;

		if ((instance->pdev->device ==

			PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||

			(instance->pdev->device ==

			PCI_DEVICE_ID_LSI_SAS0071SKINNY)) {

			instance->host->can_queue =

				instance->max_fw_cmds - MEGASAS_SKINNY_INT_CMDS;

		} else

			instance->host->can_queue =

				instance->max_fw_cmds - MEGASAS_INT_CMDS;



		spin_unlock_irqrestore(instance->host->host_lock, flags);

	}

	megasas_check_and_restore_queue_depth(instance);

}



static void
@@ -1808,7 +1834,7 @@ static int megasas_wait_for_outstanding(struct megasas_instance *instance) 
			(instance->pdev->device ==

			PCI_DEVICE_ID_LSI_SAS0071SKINNY)) {

			writel(MFI_STOP_ADP,

				&instance->reg_set->reserved_0[0]);

				&instance->reg_set->doorbell);

		} else {

			writel(MFI_STOP_ADP,

				&instance->reg_set->inbound_doorbell);
@@ -1912,10 +1938,15 @@ static int megasas_reset_device(struct scsi_cmnd *scmd) 
static int megasas_reset_bus_host(struct scsi_cmnd *scmd)

{

	int ret;

	struct megasas_instance *instance;

	instance = (struct megasas_instance *)scmd->device->host->hostdata;



	/*

	 * First wait for all commands to complete

	 */

	if (instance->pdev->device == PCI_DEVICE_ID_LSI_FUSION)

		ret = megasas_reset_fusion(scmd->device->host);

	else

		ret = megasas_generic_reset(scmd);



	return ret;
@@ -2086,13 +2117,14 @@ megasas_complete_abort(struct megasas_instance *instance, 
 * 				an alternate status (as in the case of aborted

 * 				commands)

 */

static void

void

megasas_complete_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd,

		     u8 alt_status)

{

	int exception = 0;

	struct megasas_header *hdr = &cmd->frame->hdr;

	unsigned long flags;

	struct fusion_context *fusion = instance->ctrl_context;



	/* flag for the retry reset */

	cmd->retry_for_fw_reset = 0;
@@ -2185,6 +2217,37 @@ megasas_complete_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd, 
	case MFI_CMD_SMP:

	case MFI_CMD_STP:

	case MFI_CMD_DCMD:

		/* Check for LD map update */

		if ((cmd->frame->dcmd.opcode == MR_DCMD_LD_MAP_GET_INFO) &&

		    (cmd->frame->dcmd.mbox.b[1] == 1)) {

			spin_lock_irqsave(instance->host->host_lock, flags);

			if (cmd->frame->hdr.cmd_status != 0) {

				if (cmd->frame->hdr.cmd_status !=

				    MFI_STAT_NOT_FOUND)

					printk(KERN_WARNING "megasas: map sync"

					       "failed, status = 0x%x.\n",

					       cmd->frame->hdr.cmd_status);

				else {

					megasas_return_cmd(instance, cmd);

					spin_unlock_irqrestore(

						instance->host->host_lock,

						flags);

					break;

				}

			} else

				instance->map_id++;

			megasas_return_cmd(instance, cmd);

			if (MR_ValidateMapInfo(

				    fusion->ld_map[(instance->map_id & 1)],

				    fusion->load_balance_info))

				fusion->fast_path_io = 1;

			else

				fusion->fast_path_io = 0;

			megasas_sync_map_info(instance);

			spin_unlock_irqrestore(instance->host->host_lock,

					       flags);

			break;

		}

		if (cmd->frame->dcmd.opcode == MR_DCMD_CTRL_EVENT_GET_INFO ||

			cmd->frame->dcmd.opcode == MR_DCMD_CTRL_EVENT_GET) {

			spin_lock_irqsave(&poll_aen_lock, flags);
@@ -2523,7 +2586,7 @@ static irqreturn_t megasas_isr(int irq, void *devp) 
 * states, driver must take steps to bring it to ready state. Otherwise, it

 * has to wait for the ready state.

 */

static int

int

megasas_transition_to_ready(struct megasas_instance* instance)

{

	int i;
@@ -2557,11 +2620,12 @@ megasas_transition_to_ready(struct megasas_instance* instance) 
			if ((instance->pdev->device ==

				PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||

				(instance->pdev->device ==

				PCI_DEVICE_ID_LSI_SAS0071SKINNY)) {



				 PCI_DEVICE_ID_LSI_SAS0071SKINNY) ||

				(instance->pdev->device ==

				 PCI_DEVICE_ID_LSI_FUSION)) {

				writel(

				  MFI_INIT_CLEAR_HANDSHAKE|MFI_INIT_HOTPLUG,

				  &instance->reg_set->reserved_0[0]);

				  &instance->reg_set->doorbell);

			} else {

				writel(

				    MFI_INIT_CLEAR_HANDSHAKE|MFI_INIT_HOTPLUG,
@@ -2576,9 +2640,11 @@ megasas_transition_to_ready(struct megasas_instance* instance) 
			if ((instance->pdev->device ==

			     PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||

				(instance->pdev->device ==

				PCI_DEVICE_ID_LSI_SAS0071SKINNY)) {

				 PCI_DEVICE_ID_LSI_SAS0071SKINNY) ||

			    (instance->pdev->device ==

			     PCI_DEVICE_ID_LSI_FUSION)) {

				writel(MFI_INIT_HOTPLUG,

				&instance->reg_set->reserved_0[0]);

				       &instance->reg_set->doorbell);

			} else

				writel(MFI_INIT_HOTPLUG,

					&instance->reg_set->inbound_doorbell);
@@ -2595,9 +2661,23 @@ megasas_transition_to_ready(struct megasas_instance* instance) 
			if ((instance->pdev->device ==

				PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||

				(instance->pdev->device ==

				PCI_DEVICE_ID_LSI_SAS0071SKINNY)) {

				PCI_DEVICE_ID_LSI_SAS0071SKINNY)  ||

				(instance->pdev->device

					== PCI_DEVICE_ID_LSI_FUSION)) {

				writel(MFI_RESET_FLAGS,

					&instance->reg_set->reserved_0[0]);

					&instance->reg_set->doorbell);

				if (instance->pdev->device ==

				    PCI_DEVICE_ID_LSI_FUSION) {

					for (i = 0; i < (10 * 1000); i += 20) {

						if (readl(

							    &instance->

							    reg_set->

							    doorbell) & 1)

							msleep(20);

						else

							break;

					}

				}

			} else

				writel(MFI_RESET_FLAGS,

					&instance->reg_set->inbound_doorbell);
@@ -2681,7 +2761,7 @@ megasas_transition_to_ready(struct megasas_instance* instance) 
static void megasas_teardown_frame_pool(struct megasas_instance *instance)

{

	int i;

	u32 max_cmd = instance->max_fw_cmds;

	u32 max_cmd = instance->max_mfi_cmds;

	struct megasas_cmd *cmd;



	if (!instance->frame_dma_pool)
@@ -2732,7 +2812,7 @@ static int megasas_create_frame_pool(struct megasas_instance *instance) 
	u32 frame_count;

	struct megasas_cmd *cmd;



	max_cmd = instance->max_fw_cmds;

	max_cmd = instance->max_mfi_cmds;



	/*

	 * Size of our frame is 64 bytes for MFI frame, followed by max SG
@@ -2819,14 +2899,15 @@ static int megasas_create_frame_pool(struct megasas_instance *instance) 
 * megasas_free_cmds -	Free all the cmds in the free cmd pool

 * @instance:		Adapter soft state

 */

static void megasas_free_cmds(struct megasas_instance *instance)

void megasas_free_cmds(struct megasas_instance *instance)

{

	int i;

	/* First free the MFI frame pool */

	megasas_teardown_frame_pool(instance);



	/* Free all the commands in the cmd_list */

	for (i = 0; i < instance->max_fw_cmds; i++)

	for (i = 0; i < instance->max_mfi_cmds; i++)



		kfree(instance->cmd_list[i]);



	/* Free the cmd_list buffer itself */
@@ -2854,14 +2935,14 @@ static void megasas_free_cmds(struct megasas_instance *instance) 
 * This array is used only to look up the megasas_cmd given the context. The

 * free commands themselves are maintained in a linked list called cmd_pool.

 */

static int megasas_alloc_cmds(struct megasas_instance *instance)

int megasas_alloc_cmds(struct megasas_instance *instance)

{

	int i;

	int j;

	u32 max_cmd;

	struct megasas_cmd *cmd;



	max_cmd = instance->max_fw_cmds;

	max_cmd = instance->max_mfi_cmds;



	/*

	 * instance->cmd_list is an array of struct megasas_cmd pointers.
@@ -2875,6 +2956,7 @@ static int megasas_alloc_cmds(struct megasas_instance *instance) 
		return -ENOMEM;

	}



	memset(instance->cmd_list, 0, sizeof(struct megasas_cmd *) *max_cmd);



	for (i = 0; i < max_cmd; i++) {

		instance->cmd_list[i] = kmalloc(sizeof(struct megasas_cmd),
@@ -3288,6 +3370,7 @@ megasas_init_adapter_mfi(struct megasas_instance *instance) 
	 * does not exceed max cmds that the FW can support

	 */

	instance->max_fw_cmds = instance->max_fw_cmds-1;

	instance->max_mfi_cmds = instance->max_fw_cmds;

	instance->max_num_sge = (instance->instancet->read_fw_status_reg(reg_set) & 0xFF0000) >>

					0x10;

	/*
@@ -3381,6 +3464,9 @@ static int megasas_init_fw(struct megasas_instance *instance) 
	reg_set = instance->reg_set;



	switch (instance->pdev->device) {

	case PCI_DEVICE_ID_LSI_FUSION:

		instance->instancet = &megasas_instance_template_fusion;

		break;

	case PCI_DEVICE_ID_LSI_SAS1078R:

	case PCI_DEVICE_ID_LSI_SAS1078DE:

		instance->instancet = &megasas_instance_template_ppc;
@@ -3482,8 +3568,9 @@ static int megasas_init_fw(struct megasas_instance *instance) 
 */

static void megasas_release_mfi(struct megasas_instance *instance)

{

	u32 reply_q_sz = sizeof(u32) * (instance->max_fw_cmds + 1);

	u32 reply_q_sz = sizeof(u32) *(instance->max_mfi_cmds + 1);



	if (instance->reply_queue)

		pci_free_consistent(instance->pdev, reply_q_sz,

			    instance->reply_queue, instance->reply_queue_h);
@@ -3678,8 +3765,7 @@ megasas_register_aen(struct megasas_instance *instance, u32 seq_num, 
	/*

	 * Issue the aen registration frame

	 */

	instance->instancet->fire_cmd(instance,

			cmd->frame_phys_addr, 0, instance->reg_set);

	instance->instancet->issue_dcmd(instance, cmd);



	return 0;

}
@@ -3756,12 +3842,18 @@ static int megasas_io_attach(struct megasas_instance *instance) 
	}



	host->max_sectors = instance->max_sectors_per_req;

	host->cmd_per_lun = 128;

	host->cmd_per_lun = MEGASAS_DEFAULT_CMD_PER_LUN;

	host->max_channel = MEGASAS_MAX_CHANNELS - 1;

	host->max_id = MEGASAS_MAX_DEV_PER_CHANNEL;

	host->max_lun = MEGASAS_MAX_LUN;

	host->max_cmd_len = 16;



	/* Fusion only supports host reset */

	if (instance->pdev->device == PCI_DEVICE_ID_LSI_FUSION) {

		host->hostt->eh_device_reset_handler = NULL;

		host->hostt->eh_bus_reset_handler = NULL;

	}



	/*

	 * Notify the mid-layer about the new controller

	 */
@@ -3846,20 +3938,45 @@ megasas_probe_one(struct pci_dev *pdev, const struct pci_device_id *id) 
	instance = (struct megasas_instance *)host->hostdata;

	memset(instance, 0, sizeof(*instance));

	atomic_set( &instance->fw_reset_no_pci_access, 0 );

	instance->pdev = pdev;



	instance->producer = pci_alloc_consistent(pdev, sizeof(u32),

	switch (instance->pdev->device) {

	case PCI_DEVICE_ID_LSI_FUSION:

	{

		struct fusion_context *fusion;



		instance->ctrl_context =

			kzalloc(sizeof(struct fusion_context), GFP_KERNEL);

		if (!instance->ctrl_context) {

			printk(KERN_DEBUG "megasas: Failed to allocate "

			       "memory for Fusion context info\n");

			goto fail_alloc_dma_buf;

		}

		fusion = instance->ctrl_context;

		INIT_LIST_HEAD(&fusion->cmd_pool);

		spin_lock_init(&fusion->cmd_pool_lock);

	}

	break;

	default: /* For all other supported controllers */



		instance->producer =

			pci_alloc_consistent(pdev, sizeof(u32),

					     &instance->producer_h);

	instance->consumer = pci_alloc_consistent(pdev, sizeof(u32),

		instance->consumer =

			pci_alloc_consistent(pdev, sizeof(u32),

					     &instance->consumer_h);



		if (!instance->producer || !instance->consumer) {

		printk(KERN_DEBUG "megasas: Failed to allocate memory for "

		       "producer, consumer\n");

			printk(KERN_DEBUG "megasas: Failed to allocate"

			       "memory for producer, consumer\n");

			goto fail_alloc_dma_buf;

		}



		*instance->producer = 0;

		*instance->consumer = 0;

		break;

	}



	megasas_poll_wait_aen = 0;

	instance->flag_ieee = 0;

	instance->ev = NULL;
@@ -3895,11 +4012,11 @@ megasas_probe_one(struct pci_dev *pdev, const struct pci_device_id *id) 
	spin_lock_init(&poll_aen_lock);



	mutex_init(&instance->aen_mutex);

	mutex_init(&instance->reset_mutex);



	/*

	 * Initialize PCI related and misc parameters

	 */

	instance->pdev = pdev;

	instance->host = host;

	instance->unique_id = pdev->bus->number << 8 | pdev->devfn;

	instance->init_id = MEGASAS_DEFAULT_INIT_ID;
@@ -3917,6 +4034,9 @@ megasas_probe_one(struct pci_dev *pdev, const struct pci_device_id *id) 
	instance->last_time = 0;

	instance->disableOnlineCtrlReset = 1;



	if (instance->pdev->device == PCI_DEVICE_ID_LSI_FUSION)

		INIT_WORK(&instance->work_init, megasas_fusion_ocr_wq);

	else

		INIT_WORK(&instance->work_init, process_fw_state_change_wq);



	/*
@@ -4000,6 +4120,8 @@ megasas_probe_one(struct pci_dev *pdev, const struct pci_device_id *id) 
		pci_free_consistent(pdev, sizeof(u32), instance->producer,

				    instance->producer_h);

		megasas_release_mfi(instance);

	} else {

		megasas_release_fusion(instance);

	}

	if (instance->consumer)

		pci_free_consistent(pdev, sizeof(u32), instance->consumer,
@@ -4072,7 +4194,9 @@ static void megasas_shutdown_controller(struct megasas_instance *instance, 


	if (instance->aen_cmd)

		megasas_issue_blocked_abort_cmd(instance, instance->aen_cmd);



	if (instance->map_update_cmd)

		megasas_issue_blocked_abort_cmd(instance,

						instance->map_update_cmd);

	dcmd = &cmd->frame->dcmd;



	memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
@@ -4177,9 +4301,6 @@ megasas_resume(struct pci_dev *pdev) 
	 * Initialize MFI Firmware

	 */



	*instance->producer = 0;

	*instance->consumer = 0;



	atomic_set(&instance->fw_outstanding, 0);



	/*
@@ -4188,10 +4309,28 @@ megasas_resume(struct pci_dev *pdev) 
	if (megasas_transition_to_ready(instance))

		goto fail_ready_state;



	switch (instance->pdev->device) {

	case PCI_DEVICE_ID_LSI_FUSION:

	{

		megasas_reset_reply_desc(instance);

		if (megasas_ioc_init_fusion(instance)) {

			megasas_free_cmds(instance);

			megasas_free_cmds_fusion(instance);

			goto fail_init_mfi;

		}

		if (!megasas_get_map_info(instance))

			megasas_sync_map_info(instance);

	}

	break;

	default:

		*instance->producer = 0;

		*instance->consumer = 0;

		if (megasas_issue_init_mfi(instance))

			goto fail_init_mfi;

		break;

	}



	tasklet_init(&instance->isr_tasklet, megasas_complete_cmd_dpc,

	tasklet_init(&instance->isr_tasklet, instance->instancet->tasklet,

		     (unsigned long)instance);



	/* Now re-enable MSI-X */
@@ -4261,10 +4400,12 @@ static void __devexit megasas_detach_one(struct pci_dev *pdev) 
	int i;

	struct Scsi_Host *host;

	struct megasas_instance *instance;

	struct fusion_context *fusion;



	instance = pci_get_drvdata(pdev);

	instance->unload = 1;

	host = instance->host;

	fusion = instance->ctrl_context;



	if (poll_mode_io)

		del_timer_sync(&instance->io_completion_timer);
@@ -4306,16 +4447,32 @@ static void __devexit megasas_detach_one(struct pci_dev *pdev) 
	if (instance->msi_flag)

		pci_disable_msix(instance->pdev);



	switch (instance->pdev->device) {

	case PCI_DEVICE_ID_LSI_FUSION:

		megasas_release_fusion(instance);

		for (i = 0; i < 2 ; i++)

			if (fusion->ld_map[i])

				dma_free_coherent(&instance->pdev->dev,

						  fusion->map_sz,

						  fusion->ld_map[i],

						  fusion->

						  ld_map_phys[i]);

		kfree(instance->ctrl_context);

		break;

	default:

		megasas_release_mfi(instance);



	pci_free_consistent(pdev, sizeof(struct megasas_evt_detail),

			    instance->evt_detail, instance->evt_detail_h);



	pci_free_consistent(pdev, sizeof(u32), instance->producer,

		pci_free_consistent(pdev,

				    sizeof(struct megasas_evt_detail),

				    instance->evt_detail,

				    instance->evt_detail_h);

		pci_free_consistent(pdev, sizeof(u32),

				    instance->producer,

				    instance->producer_h);



	pci_free_consistent(pdev, sizeof(u32), instance->consumer,

		pci_free_consistent(pdev, sizeof(u32),

				    instance->consumer,

				    instance->consumer_h);

		break;

	}



	scsi_host_put(host);
@@ -5079,6 +5236,7 @@ megasas_aen_polling(struct work_struct *work) 
			break;

		case MR_EVT_CTRL_HOST_BUS_SCAN_REQUESTED:

		case MR_EVT_FOREIGN_CFG_IMPORTED:

		case MR_EVT_LD_STATE_CHANGE:

			doscan = 1;

			break;

		default:

drivers/scsi/megaraid/megaraid_sas_fp.c

0 → 100644
+516 −0

File added.

Preview size limit exceeded, changes collapsed.

drivers/scsi/megaraid/megaraid_sas_fusion.c

0 → 100644
+2248 −0

File added.

Preview size limit exceeded, changes collapsed.