Re: [PATCH V4 06/11] megaraid_sas: Dynamic Raid Map Changes for SAS3.5 Generic Megaraid Controllers

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

 



On 20.12.2016 02:51, Sasikumar PC wrote:
> Hi Tomas,
>
> Please see my response inline
>
> Thanks
> sasi
>
> -----Original Message-----
> From: Sasikumar PC [mailto:sasikumar.pc@xxxxxxxxxxxx]
> Sent: Wednesday, December 14, 2016 4:49 PM
> To: 'Tomas Henzl'; 'jejb@xxxxxxxxxx'; 'hch@xxxxxxxxxxxxx'
> Cc: 'linux-scsi@xxxxxxxxxxxxxxx'; Sathya Prakash Veerichetty;
> 'linux-kernel@xxxxxxxxxxxxxxx'; Christopher Owens; Kiran Kumar Kasturi
> Subject: RE: [PATCH V4 06/11] megaraid_sas: Dynamic Raid Map Changes for
> SAS3.5 Generic Megaraid Controllers
>
> Hi Tomas,
>
> Please see my response inline
>
> Thanks
> sasi
>
> -----Original Message-----
> From: Tomas Henzl [mailto:thenzl@xxxxxxxxxx]
> Sent: Friday, December 09, 2016 7:55 AM
> To: Sasikumar Chandrasekaran; jejb@xxxxxxxxxx; hch@xxxxxxxxxxxxx
> Cc: linux-scsi@xxxxxxxxxxxxxxx; Sathya.Prakash@xxxxxxxxxxxx;
> linux-kernel@xxxxxxxxxxxxxxx; christopher.owens@xxxxxxxxxxxx;
> kiran-kumar.kasturi@xxxxxxxxxxxx
> Subject: Re: [PATCH V4 06/11] megaraid_sas: Dynamic Raid Map Changes for
> SAS3.5 Generic Megaraid Controllers
>
> On 7.12.2016 00:00, Sasikumar Chandrasekaran wrote:
>> SAS3.5 Generic Megaraid Controllers FW will support new dynamic RaidMap
> to have different
>> sizes for different number of supported VDs.
>>
>> This patch is depending on patch 5
>>
>> Signed-off-by: Sasikumar Chandrasekaran <sasikumar.pc@xxxxxxxxxxxx>
>> ---
>>  drivers/scsi/megaraid/megaraid_sas.h        |   7 +
>>  drivers/scsi/megaraid/megaraid_sas_base.c   |  61 ++++--
>>  drivers/scsi/megaraid/megaraid_sas_fp.c     | 303
> ++++++++++++++++++++++++----
>>  drivers/scsi/megaraid/megaraid_sas_fusion.c | 223 ++++++++++++++++----
>>  drivers/scsi/megaraid/megaraid_sas_fusion.h | 240
> ++++++++++++++++++----
>>  5 files changed, 699 insertions(+), 135 deletions(-)
>>
>> diff --git a/drivers/scsi/megaraid/megaraid_sas.h
> b/drivers/scsi/megaraid/megaraid_sas.h
>> index f4d6a94..3e087ab 100644
>> --- a/drivers/scsi/megaraid/megaraid_sas.h
>> +++ b/drivers/scsi/megaraid/megaraid_sas.h
>> @@ -1434,6 +1434,12 @@ enum FW_BOOT_CONTEXT {
>>  #define MR_MAX_REPLY_QUEUES_EXT_OFFSET_SHIFT    14
>>  #define MR_MAX_MSIX_REG_ARRAY                   16
>>  #define MR_RDPQ_MODE_OFFSET			0X00800000
>> +
>> +#define MR_MAX_RAID_MAP_SIZE_OFFSET_SHIFT	16
>> +#define MR_MAX_RAID_MAP_SIZE_MASK		0x1FF
>> +#define MR_MIN_MAP_SIZE				0x10000
>> +/* 64k */
>> +
>>  #define MR_CAN_HANDLE_SYNC_CACHE_OFFSET		0X01000000
>>
>>  /*
>> @@ -2152,6 +2158,7 @@ struct megasas_instance {
>>  	bool fw_sync_cache_support;
>>  	bool is_ventura;
>>  	bool msix_combined;
>> +	u16 max_raid_mapsize;
>>  };
>>  struct MR_LD_VF_MAP {
>>  	u32 size;
>> diff --git a/drivers/scsi/megaraid/megaraid_sas_base.c
> b/drivers/scsi/megaraid/megaraid_sas_base.c
>> index c52f7be..3f06b57 100644
>> --- a/drivers/scsi/megaraid/megaraid_sas_base.c
>> +++ b/drivers/scsi/megaraid/megaraid_sas_base.c
>> @@ -4424,8 +4424,7 @@ int megasas_alloc_cmds(struct megasas_instance
> *instance)
>>  static void megasas_update_ext_vd_details(struct megasas_instance
> *instance)
>>  {
>>  	struct fusion_context *fusion;
>> -	u32 old_map_sz;
>> -	u32 new_map_sz;
>> +	u32 ventura_map_sz = 0;
>>
>>  	fusion = instance->ctrl_context;
>>  	/* For MFI based controllers return dummy success */
>> @@ -4455,21 +4454,39 @@ static void megasas_update_ext_vd_details(struct
> megasas_instance *instance)
>>  		instance->supportmax256vd ? "Extended VD(240 VD)firmware"
> :
>>  		"Legacy(64 VD) firmware");
>>
>> -	old_map_sz = sizeof(struct MR_FW_RAID_MAP) +
>> -				(sizeof(struct MR_LD_SPAN_MAP) *
>> -				(instance->fw_supported_vd_count - 1));
>> -	new_map_sz = sizeof(struct MR_FW_RAID_MAP_EXT);
>> -	fusion->drv_map_sz = sizeof(struct MR_DRV_RAID_MAP) +
>> -				(sizeof(struct MR_LD_SPAN_MAP) *
>> -				(instance->drv_supported_vd_count - 1));
>> -
>> -	fusion->max_map_sz = max(old_map_sz, new_map_sz);
>> +	if (instance->max_raid_mapsize) {
>> +		ventura_map_sz = instance->max_raid_mapsize *
>> +						MR_MIN_MAP_SIZE; /* 64k */
>> +		fusion->current_map_sz = ventura_map_sz;
>> +		fusion->max_map_sz = ventura_map_sz;
>> +	} else {
>> +		fusion->old_map_sz =  sizeof(struct MR_FW_RAID_MAP) +
>> +					(sizeof(struct MR_LD_SPAN_MAP) *
>> +					(instance->fw_supported_vd_count -
> 1));
>> +		fusion->new_map_sz =  sizeof(struct MR_FW_RAID_MAP_EXT);
>>
>> +		fusion->max_map_sz =
>> +			max(fusion->old_map_sz, fusion->new_map_sz);
>>
>> -	if (instance->supportmax256vd)
>> -		fusion->current_map_sz = new_map_sz;
>> -	else
>> -		fusion->current_map_sz = old_map_sz;
>> +		if (instance->supportmax256vd)
>> +			fusion->current_map_sz = fusion->new_map_sz;
>> +		else
>> +			fusion->current_map_sz = fusion->old_map_sz;
>> +	}
>> +	/* irrespective of FW raid maps, driver raid map is constant */
>> +	fusion->drv_map_sz = sizeof(struct MR_DRV_RAID_MAP_ALL);
>> +#if VD_EXT_DEBUG
>> +	dev_info(&instance->pdev->dev, "instance->max_raid_mapsize 0x%x \n
> ",
>> +			instance->max_raid_mapsize);
>> +	dev_info(&instance->pdev->dev,
>> +	"new_map_sz = 0x%x, old_map_sz = 0x%x, "
>> +	"ventura_map_sz = 0x%x, current_map_sz = 0x%x "
>> +	"fusion->drv_map_sz =0x%x, size of driver raid map 0x%lx\n",
>> +	fusion->new_map_sz, fusion->old_map_sz,
>> +	ventura_map_sz, fusion->current_map_sz,
>> +	fusion->drv_map_sz,
>> +	sizeof(struct MR_DRV_RAID_MAP_ALL));
>> +#endif
>>  }
>>
>>  /**
>> @@ -5010,7 +5027,7 @@ static int megasas_init_fw(struct megasas_instance
> *instance)
>>  {
>>  	u32 max_sectors_1;
>>  	u32 max_sectors_2;
>> -	u32 tmp_sectors, msix_enable, scratch_pad_2;
>> +	u32 tmp_sectors, msix_enable, scratch_pad_2, scratch_pad_3;
>>  	resource_size_t base_addr;
>>  	struct megasas_register_set __iomem *reg_set;
>>  	struct megasas_ctrl_info *ctrl_info = NULL;
>> @@ -5086,7 +5103,17 @@ static int megasas_init_fw(struct
> megasas_instance *instance)
>>  			goto fail_ready_state;
>>  	}
>>
>> -
>> +	if (instance->is_ventura) {
>> +		scratch_pad_3 =
>> +			readl(&instance->reg_set->outbound_scratch_pad_3);
>> +#if VD_EXT_DEBUG
>> +		dev_info(&instance->pdev->dev, "scratch_pad3 0x%x\n",
>> +			scratch_pad_3);
>> +#endif
>> +		instance->max_raid_mapsize = ((scratch_pad_3 >>
>> +			MR_MAX_RAID_MAP_SIZE_OFFSET_SHIFT) &
>> +			MR_MAX_RAID_MAP_SIZE_MASK);
>> +	}
>>
>>  	/* Check if MSI-X is supported while in ready state */
>>  	msix_enable = (instance->instancet->read_fw_status_reg(reg_set) &
>> diff --git a/drivers/scsi/megaraid/megaraid_sas_fp.c
> b/drivers/scsi/megaraid/megaraid_sas_fp.c
>> index eb9ff44..a6957a3 100644
>> --- a/drivers/scsi/megaraid/megaraid_sas_fp.c
>> +++ b/drivers/scsi/megaraid/megaraid_sas_fp.c
>> @@ -179,18 +179,204 @@ void MR_PopulateDrvRaidMap(struct
> megasas_instance *instance)
>>  	struct fusion_context *fusion = instance->ctrl_context;
>>  	struct MR_FW_RAID_MAP_ALL     *fw_map_old    = NULL;
>>  	struct MR_FW_RAID_MAP         *pFwRaidMap    = NULL;
>> -	int i;
>> +	int i, j;
>>  	u16 ld_count;
>> +	struct MR_FW_RAID_MAP_DYNAMIC *fw_map_dyn;
>> +	struct MR_FW_RAID_MAP_EXT *fw_map_ext;
>> +	struct MR_RAID_MAP_DESC_TABLE *desc_table;
>>
>>
>>  	struct MR_DRV_RAID_MAP_ALL *drv_map =
>>  			fusion->ld_drv_map[(instance->map_id & 1)];
>>  	struct MR_DRV_RAID_MAP *pDrvRaidMap = &drv_map->raidMap;
>> +	void *raid_map_data = NULL;
>> +
>> +	memset(drv_map, 0, fusion->drv_map_sz);
>> +	memset(pDrvRaidMap->ldTgtIdToLd,
>> +		0xff, (sizeof(u16) * MAX_LOGICAL_DRIVES_DYN));
>> +
>> +	if (instance->max_raid_mapsize) {
>> +		fw_map_dyn = fusion->ld_map[(instance->map_id & 1)];
>> +#if VD_EXT_DEBUG
>> +		dev_dbg(&instance->pdev->dev,
>> +		" raidMapSize 0x%x fw_map_dyn->descTableOffset 0x%x, "
>> +		" descTableSize 0x%x descTableNumElements 0x%x\n",
>> +		le32_to_cpu(fw_map_dyn->raid_map_size),
>> +		le32_to_cpu(fw_map_dyn->desc_table_offset),
>> +		le32_to_cpu(fw_map_dyn->desc_table_size),
>> +		le32_to_cpu(fw_map_dyn->desc_table_num_elements));
>> +		dev_dbg(&instance->pdev->dev,
>> +		"drv map %p ldCount %d\n", drv_map, fw_map_dyn->ld_count);
>> +#endif
>> +		desc_table =
>> +		(struct MR_RAID_MAP_DESC_TABLE *)((void *)fw_map_dyn +
>> +		le32_to_cpu(fw_map_dyn->desc_table_offset));
>> +		if (desc_table != fw_map_dyn->raid_map_desc_table) {
>> +			dev_err(&instance->pdev->dev,
>> +			"offsets of desc table are not matching returning
> "
>> +			" FW raid map has been changed: desc %p original
> %p\n",
>> +			desc_table, fw_map_dyn->raid_map_desc_table);
>> +		}
>> +		ld_count = (u16)le16_to_cpu(fw_map_dyn->ld_count);
>> +		pDrvRaidMap->ldCount = (__le16)cpu_to_le16(ld_count);
>> +		pDrvRaidMap->fpPdIoTimeoutSec =
> fw_map_dyn->fp_pd_io_timeout_sec;
>> +		pDrvRaidMap->totalSize = sizeof(struct
> MR_DRV_RAID_MAP_ALL);
>> +		/* point to actual data starting point*/
>> +		raid_map_data = (void *)fw_map_dyn +
>> +			le32_to_cpu(fw_map_dyn->desc_table_offset) +
>> +			le32_to_cpu(fw_map_dyn->desc_table_size);
>> +
>> +		for (i = 0; i <
> le32_to_cpu(fw_map_dyn->desc_table_num_elements); ++i) {
>> +			if (!desc_table) {
>> +				dev_err(&instance->pdev->dev,
>> +				"desc table is null, coming out %p \n",
> desc_table);
>> +				return;
>> +			}
> Is it possible that desc_table ever happens to NULL? It looks
> like a test something else was intended here ?
>
> It is a defensive check. yes can never be true and can be removed

Thanks, does it mean that you are going to post a v6 with this part removed or that 
you'd post an additional patch that removes the test?

> Sasi
>
>
> Also all the VD_EXT_DEBUG macros make with bad indentation added
> make the code hard to read. Please fix it later in a follow up patch.
>
>
> Sasi - This shall be fixed in V5 patch
>
>> +#if VD_EXT_DEBUG
>> +			dev_err(&instance->pdev->dev,
>> +				"desc table %p \n", desc_table);
>> +			dev_err(&instance->pdev->dev,
>> +			"raidmap type %d, raidmapOffset 0x%x, "
>> +			" raid map number of elements 0%x, raidmapsize
> 0x%x\n",
>> +			desc_table->raid_map_desc_type,
>> +			desc_table->raid_map_desc_offset,
>> +			desc_table->raid_map_desc_elements,
>> +			desc_table->raid_map_desc_buffer_size);
>> +#endif
>> +			switch
> (le32_to_cpu(desc_table->raid_map_desc_type)) {
>> +			case RAID_MAP_DESC_TYPE_DEVHDL_INFO:
>> +				fw_map_dyn->dev_hndl_info = (struct
> MR_DEV_HANDLE_INFO *)
>> +				(raid_map_data +
>> +
> le32_to_cpu(desc_table->raid_map_desc_offset));
>> +#if VD_EXT_DEBUG
>> +				dev_err(&instance->pdev->dev,
>> +				"devHndlInfo  address %p\n",
>> +				 fw_map_dyn->dev_hndl_info);
>> +#endif
>> +				memcpy(pDrvRaidMap->devHndlInfo,
> fw_map_dyn->dev_hndl_info,
>> +					sizeof(struct MR_DEV_HANDLE_INFO)
> *
>> +
> le32_to_cpu(desc_table->raid_map_desc_elements));
>> +			break;
>> +			case RAID_MAP_DESC_TYPE_TGTID_INFO:
>> +					fw_map_dyn->ld_tgt_id_to_ld = (u16
> *) (raid_map_data +
>> +
> le32_to_cpu(desc_table->raid_map_desc_offset));
>> +#if VD_EXT_DEBUG
>> +			dev_err(&instance->pdev->dev,
>> +				"ldTgtIdToLd  address %p\n",
>> +					fw_map_dyn->ld_tgt_id_to_ld);
>> +#endif
>> +			for (j = 0; j <
> le32_to_cpu(desc_table->raid_map_desc_elements); j++) {
>> +				pDrvRaidMap->ldTgtIdToLd[j] =
>> +					fw_map_dyn->ld_tgt_id_to_ld[j];
>> +#if VD_EXT_DEBUG
>> +				dev_err(&instance->pdev->dev,
>> +					" %d drv ldTgtIdToLd %d\n",
>> +						j,
> pDrvRaidMap->ldTgtIdToLd[j]);
>> +#endif
>> +			}
>> +			break;
>> +			case RAID_MAP_DESC_TYPE_ARRAY_INFO:
>> +				fw_map_dyn->ar_map_info = (struct
> MR_ARRAY_INFO *)
>> +				(raid_map_data +
> le32_to_cpu(desc_table->raid_map_desc_offset));
>> +#if VD_EXT_DEBUG
>> +				dev_err(&instance->pdev->dev,
>> +					"arMapInfo  address %p\n",
>> +					 fw_map_dyn->ar_map_info);
>> +#endif
>> +
>> +				memcpy(pDrvRaidMap->arMapInfo,
>> +				fw_map_dyn->ar_map_info,
>> +				sizeof(struct MR_ARRAY_INFO) *
>> +
> le32_to_cpu(desc_table->raid_map_desc_elements));
>> +			break;
>> +			case RAID_MAP_DESC_TYPE_SPAN_INFO:
>> +				fw_map_dyn->ld_span_map = (struct
> MR_LD_SPAN_MAP *)
>> +				(raid_map_data +
> le32_to_cpu(desc_table->raid_map_desc_offset));
>> +				memcpy(pDrvRaidMap->ldSpanMap,
>> +				fw_map_dyn->ld_span_map,
>> +				sizeof(struct MR_LD_SPAN_MAP) *
>> +
> le32_to_cpu(desc_table->raid_map_desc_elements));
>> +#if VD_EXT_DEBUG
>> +				dev_err(&instance->pdev->dev,
>> +					"ldSpanMap  address %p\n",
>> +						fw_map_dyn->ld_span_map);
>> +				dev_err(&instance->pdev->dev,
>> +				"MR_LD_SPAN_MAP size 0x%lx\n",
> sizeof(struct MR_LD_SPAN_MAP));
>> +				for (j = 0; j < ld_count; j++) {
>> +					printk(KERN_DEBUG
> "megaraid_sas(%d) : fw_map_dyn->ldSpanMap[%d].ldRaid.targetId 0x%x
> fw_map_dyn->ldSpanMap[%d].ldRaid.seqNum 0x%x size 0x%x\n",
>> +					j, j,
> fw_map_dyn->ld_span_map[j].ldRaid.targetId, j,
>> +
> fw_map_dyn->ld_span_map[j].ldRaid.seqNum,
>> +
> (u32)fw_map_dyn->ld_span_map[j].ldRaid.rowSize);
>> +					printk(KERN_DEBUG
> "megaraid_sas(%d) :pDrvRaidMap->ldSpanMap[%d].ldRaid.targetId 0x%x
> pDrvRaidMap->ldSpanMap[%d].ldRaid.seqNum 0x%x size 0x%x\n",
>> +					j, j,
> pDrvRaidMap->ldSpanMap[j].ldRaid.targetId, j,
>> +
> pDrvRaidMap->ldSpanMap[j].ldRaid.seqNum,
>> +
> (u32)pDrvRaidMap->ldSpanMap[j].ldRaid.rowSize);
>> +					printk(KERN_DEBUG
> "megaraid_sas(%d) : drv raid map all %p raid map %p LD RAID MAP %p/%p\n",
>> +					instance->unique_id, drv_map,
> pDrvRaidMap,
>> +
> &fw_map_dyn->ld_span_map[j].ldRaid,
>> +
> &pDrvRaidMap->ldSpanMap[j].ldRaid);
>> +				}
>> +#endif
>> +			break;
>> +			default:
>> +				dev_err(&instance->pdev->dev,
>> +					"wrong number of desctableElements
> %d\n",
>> +
> fw_map_dyn->desc_table_num_elements);
>> +			}
>> +			++desc_table;
>> +		}
>> +
>> +	} else if (instance->supportmax256vd) {
>> +		fw_map_ext =
>> +		(struct MR_FW_RAID_MAP_EXT *)
> fusion->ld_map[(instance->map_id & 1)];
>> +		ld_count = (u16)le16_to_cpu(fw_map_ext->ldCount);
>> +		if (ld_count > MAX_LOGICAL_DRIVES_EXT) {
>> +			printk(KERN_DEBUG "megaraid_sas: LD count exposed
> in RAID map in not valid\n");
>> +			return;
>> +		}
>> +#if VD_EXT_DEBUG
>> +		for (i = 0; i < ld_count; i++) {
>> +			printk(KERN_DEBUG "megaraid_sas(%d) :Index 0x%x
> Target Id 0x%x Seq Num 0x%x Size 0/%llx\n",
>> +				instance->unique_id,
>> +				i,
> fw_map_ext->ldSpanMap[i].ldRaid.targetId,
>> +				fw_map_ext->ldSpanMap[i].ldRaid.seqNum,
>> +				fw_map_ext->ldSpanMap[i].ldRaid.size);
>> +		}
>> +#endif
>> +
>> +		pDrvRaidMap->ldCount = (__le16)cpu_to_le16(ld_count);
>> +		pDrvRaidMap->fpPdIoTimeoutSec =
>> +
> fw_map_ext->fpPdIoTimeoutSec;
>> +		for (i = 0; i < (MAX_LOGICAL_DRIVES_EXT); i++)
>> +			pDrvRaidMap->ldTgtIdToLd[i] =
>> +			(u16)fw_map_ext->ldTgtIdToLd[i];
>> +		memcpy(pDrvRaidMap->ldSpanMap,
>> +				fw_map_ext->ldSpanMap,
>> +				sizeof(struct MR_LD_SPAN_MAP) *
>> +				ld_count);
>> +#if VD_EXT_DEBUG
>> +		for (i = 0; i < ld_count; i++) {
>> +			printk(KERN_DEBUG "megaraid_sas(%d) :
> fw_map_ext->ldSpanMap[%d].ldRaid.targetId 0x%x
> fw_map_ext->ldSpanMap[%d].ldRaid.seqNum 0x%x size 0x%x\n",
>> +			i, i, fw_map_ext->ldSpanMap[i].ldRaid.targetId, i,
>> +			fw_map_ext->ldSpanMap[i].ldRaid.seqNum,
>> +			(u32)fw_map_ext->ldSpanMap[i].ldRaid.rowSize);
>> +			printk(KERN_DEBUG "megaraid_sas(%d) :
> pDrvRaidMap->ldSpanMap[%d].ldRaid.targetId 0x%x"
>> +			"pDrvRaidMap->ldSpanMap[%d].ldRaid.seqNum 0x%x
> size 0x%x\n",
>> +			i, i, pDrvRaidMap->ldSpanMap[i].ldRaid.targetId,
> i,
>> +			pDrvRaidMap->ldSpanMap[i].ldRaid.seqNum,
>> +			(u32)pDrvRaidMap->ldSpanMap[i].ldRaid.rowSize);
>> +			printk(KERN_DEBUG "megaraid_sas(%d) : drv raid map
> all %p raid map %p LD RAID MAP %p %p\n",
>> +			instance->unique_id, drv_map, pDrvRaidMap,
>> +			&fw_map_ext->ldSpanMap[i].ldRaid,
>> +				&pDrvRaidMap->ldSpanMap[i].ldRaid);
>> +		}
>> +#endif
>> +		memcpy(pDrvRaidMap->arMapInfo, fw_map_ext->arMapInfo,
>> +			sizeof(struct MR_ARRAY_INFO) *
> MAX_API_ARRAYS_EXT);
>> +		memcpy(pDrvRaidMap->devHndlInfo, fw_map_ext->devHndlInfo,
>> +			sizeof(struct MR_DEV_HANDLE_INFO) *
>> +					MAX_RAIDMAP_PHYSICAL_DEVICES);
>>
>> -	if (instance->supportmax256vd) {
>> -		memcpy(fusion->ld_drv_map[instance->map_id & 1],
>> -			fusion->ld_map[instance->map_id & 1],
>> -			fusion->current_map_sz);
>>  		/* New Raid map will not set totalSize, so keep expected
> value
>>  		 * for legacy code in ValidateMapInfo
>>  		 */
>> @@ -213,16 +399,12 @@ void MR_PopulateDrvRaidMap(struct megasas_instance
> *instance)
>>  		}
>>  #endif
>>
>> -		memset(drv_map, 0, fusion->drv_map_sz);
>>  		pDrvRaidMap->totalSize = pFwRaidMap->totalSize;
>>  		pDrvRaidMap->ldCount = (__le16)cpu_to_le16(ld_count);
>>  		pDrvRaidMap->fpPdIoTimeoutSec =
> pFwRaidMap->fpPdIoTimeoutSec;
>>  		for (i = 0; i < MAX_RAIDMAP_LOGICAL_DRIVES +
> MAX_RAIDMAP_VIEWS; i++)
>>  			pDrvRaidMap->ldTgtIdToLd[i] =
>>  				(u8)pFwRaidMap->ldTgtIdToLd[i];
>> -		for (i = (MAX_RAIDMAP_LOGICAL_DRIVES + MAX_RAIDMAP_VIEWS);
>> -			i < MAX_LOGICAL_DRIVES_EXT; i++)
>> -			pDrvRaidMap->ldTgtIdToLd[i] = 0xff;
>>  		for (i = 0; i < ld_count; i++) {
>>  			pDrvRaidMap->ldSpanMap[i] =
> pFwRaidMap->ldSpanMap[i];
>>  #if VD_EXT_DEBUG
>> @@ -279,7 +461,9 @@ u8 MR_ValidateMapInfo(struct megasas_instance
> *instance)
>>  	lbInfo = fusion->load_balance_info;
>>  	ldSpanInfo = fusion->log_to_span;
>>
>> -	if (instance->supportmax256vd)
>> +	if (instance->max_raid_mapsize)
>> +		expected_size = sizeof(struct MR_DRV_RAID_MAP_ALL);
>> +	else if (instance->supportmax256vd)
>>  		expected_size = sizeof(struct MR_FW_RAID_MAP_EXT);
>>  	else
>>  		expected_size =
>> @@ -287,8 +471,10 @@ u8 MR_ValidateMapInfo(struct megasas_instance
> *instance)
>>  			(sizeof(struct MR_LD_SPAN_MAP) *
> le16_to_cpu(pDrvRaidMap->ldCount)));
>>  	if (le32_to_cpu(pDrvRaidMap->totalSize) != expected_size) {
>> -		dev_err(&instance->pdev->dev, "map info structure size
> 0x%x is not matching with ld count\n",
>> -		       (unsigned int) expected_size);
>> +		dev_err(&instance->pdev->dev, "megasas: map info
> structure"
>> +		" size 0x%x is not matching expected size 0x%x\n",
>> +			le32_to_cpu(pDrvRaidMap->totalSize),
>> +			(unsigned int) expected_size);
>>  		dev_err(&instance->pdev->dev, "megasas: span map %x,
> pDrvRaidMap->totalSize : %x\n",
>>  			(unsigned int)sizeof(struct MR_LD_SPAN_MAP),
>>  			le32_to_cpu(pDrvRaidMap->totalSize));
>> @@ -787,7 +973,7 @@ static u8 mr_spanset_get_phy_params(struct
> megasas_instance *instance, u32 ld,
>>  			((fusion->adapter_type == THUNDERBOLT_SERIES)  ||
>>  			((fusion->adapter_type == INVADER_SERIES) &&
>>  			(raid->regTypeReqOnRead != REGION_TYPE_UNUSED))))
>> -			pRAID_Context->regLockFlags =
> REGION_TYPE_EXCLUSIVE;
>> +			pRAID_Context->reg_lock_flags =
> REGION_TYPE_EXCLUSIVE;
>>  		else if (raid->level == 1) {
>>  			physArm = physArm + 1;
>>  			pd = MR_ArPdGet(arRef, physArm, map);
>> @@ -797,9 +983,16 @@ static u8 mr_spanset_get_phy_params(struct
> megasas_instance *instance, u32 ld,
>>  	}
>>
>>  	*pdBlock += stripRef + le64_to_cpu(MR_LdSpanPtrGet(ld, span,
> map)->startBlk);
>> -	pRAID_Context->spanArm = (span << RAID_CTX_SPANARM_SPAN_SHIFT) |
>> -					physArm;
>> -	io_info->span_arm = pRAID_Context->spanArm;
>> +	if (instance->is_ventura) {
>> +		((struct RAID_CONTEXT_G35 *) pRAID_Context)->span_arm =
>> +			(span << RAID_CTX_SPANARM_SPAN_SHIFT) | physArm;
>> +		io_info->span_arm =
>> +			(span << RAID_CTX_SPANARM_SPAN_SHIFT) | physArm;
>> +	} else {
>> +		pRAID_Context->span_arm =
>> +			(span << RAID_CTX_SPANARM_SPAN_SHIFT) | physArm;
>> +		io_info->span_arm = pRAID_Context->span_arm;
>> +	}
>>  	return retval;
>>  }
>>
>> @@ -891,7 +1084,7 @@ u8 MR_GetPhyParams(struct megasas_instance
> *instance, u32 ld, u64 stripRow,
>>  			((fusion->adapter_type == THUNDERBOLT_SERIES)  ||
>>  			((fusion->adapter_type == INVADER_SERIES) &&
>>  			(raid->regTypeReqOnRead != REGION_TYPE_UNUSED))))
>> -			pRAID_Context->regLockFlags =
> REGION_TYPE_EXCLUSIVE;
>> +			pRAID_Context->reg_lock_flags =
> REGION_TYPE_EXCLUSIVE;
>>  		else if (raid->level == 1) {
>>  			/* Get alternate Pd. */
>>  			physArm = physArm + 1;
>> @@ -903,9 +1096,16 @@ u8 MR_GetPhyParams(struct megasas_instance
> *instance, u32 ld, u64 stripRow,
>>  	}
>>
>>  	*pdBlock += stripRef + le64_to_cpu(MR_LdSpanPtrGet(ld, span,
> map)->startBlk);
>> -	pRAID_Context->spanArm = (span << RAID_CTX_SPANARM_SPAN_SHIFT) |
>> -		physArm;
>> -	io_info->span_arm = pRAID_Context->spanArm;
>> +	if (instance->is_ventura) {
>> +		((struct RAID_CONTEXT_G35 *) pRAID_Context)->span_arm =
>> +				(span << RAID_CTX_SPANARM_SPAN_SHIFT) |
> physArm;
>> +		io_info->span_arm =
>> +				(span << RAID_CTX_SPANARM_SPAN_SHIFT) |
> physArm;
>> +	} else {
>> +		pRAID_Context->span_arm =
>> +			(span << RAID_CTX_SPANARM_SPAN_SHIFT) | physArm;
>> +		io_info->span_arm = pRAID_Context->span_arm;
>> +	}
>>  	return retval;
>>  }
>>
>> @@ -1109,20 +1309,20 @@ u8 MR_GetPhyParams(struct megasas_instance
> *instance, u32 ld, u64 stripRow,
>>  			regSize += stripSize;
>>  	}
>>
>> -	pRAID_Context->timeoutValue =
>> +	pRAID_Context->timeout_value =
>>  		cpu_to_le16(raid->fpIoTimeoutForLd ?
>>  			    raid->fpIoTimeoutForLd :
>>  			    map->raidMap.fpPdIoTimeoutSec);
>>  	if (fusion->adapter_type == INVADER_SERIES)
>> -		pRAID_Context->regLockFlags = (isRead) ?
>> +		pRAID_Context->reg_lock_flags = (isRead) ?
>>  			raid->regTypeReqOnRead : raid->regTypeReqOnWrite;
>> -	else
>> -		pRAID_Context->regLockFlags = (isRead) ?
>> +	else if (!instance->is_ventura)
>> +		pRAID_Context->reg_lock_flags = (isRead) ?
>>  			REGION_TYPE_SHARED_READ : raid->regTypeReqOnWrite;
>> -	pRAID_Context->VirtualDiskTgtId = raid->targetId;
>> -	pRAID_Context->regLockRowLBA    = cpu_to_le64(regStart);
>> -	pRAID_Context->regLockLength    = cpu_to_le32(regSize);
>> -	pRAID_Context->configSeqNum	= raid->seqNum;
>> +	pRAID_Context->virtual_disk_tgt_id = raid->targetId;
>> +	pRAID_Context->reg_lock_row_lba    = cpu_to_le64(regStart);
>> +	pRAID_Context->reg_lock_length    = cpu_to_le32(regSize);
>> +	pRAID_Context->config_seq_num	= raid->seqNum;
>>  	/* save pointer to raid->LUN array */
>>  	*raidLUN = raid->LUN;
>>
>> @@ -1140,6 +1340,14 @@ u8 MR_GetPhyParams(struct megasas_instance
> *instance, u32 ld, u64 stripRow,
>>  		/* If IO on an invalid Pd, then FP is not possible.*/
>>  		if (io_info->devHandle == cpu_to_le16(MR_PD_INVALID))
>>  			io_info->fpOkForIo = FALSE;
>> +		/* if FP possible, set the SLUD bit in
>> +		*  regLockFlags for ventura
>> +		*/
>> +		else if ((instance->is_ventura) && !isRead &&
>> +				(raid->writeMode == MR_RL_WRITE_BACK_MODE)
> &&
>> +				raid->capability.fp_cache_bypass_capable)
>> +				((struct RAID_CONTEXT_G35 *)
> pRAID_Context)->routing_flags.bits.sld
>> +					= 1;
>>  		/* set raid 1/10 fast path write capable bit in io_info */
>>  		if (io_info->fpOkForIo &&
>>  		    (io_info->r1_alt_dev_handle != MR_PD_INVALID) &&
>> @@ -1319,6 +1527,7 @@ u8 megasas_get_best_arm_pd(struct megasas_instance
> *instance,
>>  	struct fusion_context *fusion;
>>  	struct MR_LD_RAID  *raid;
>>  	struct MR_DRV_RAID_MAP_ALL *drv_map;
>> +	u16	pd1_dev_handle;
>>  	u16     pend0, pend1, ld;
>>  	u64     diff0, diff1;
>>  	u8      bestArm, pd0, pd1, span, arm;
>> @@ -1344,23 +1553,37 @@ u8 megasas_get_best_arm_pd(struct
> megasas_instance *instance,
>>  	pd1 = MR_ArPdGet(arRef, (arm + 1) >= span_row_size ?
>>  		(arm + 1 - span_row_size) : arm + 1, drv_map);
>>
>> -	/* get the pending cmds for the data and mirror arms */
>> -	pend0 = atomic_read(&lbInfo->scsi_pending_cmds[pd0]);
>> -	pend1 = atomic_read(&lbInfo->scsi_pending_cmds[pd1]);
>> +	/* Get PD1 Dev Handle */
>>
>> -	/* Determine the disk whose head is nearer to the req. block */
>> -	diff0 = ABS_DIFF(block, lbInfo->last_accessed_block[pd0]);
>> -	diff1 = ABS_DIFF(block, lbInfo->last_accessed_block[pd1]);
>> -	bestArm = (diff0 <= diff1 ? arm : arm ^ 1);
>> +	pd1_dev_handle = MR_PdDevHandleGet(pd1, drv_map);
>>
>> -	if ((bestArm == arm && pend0 > pend1 + lb_pending_cmds)  ||
>> +	if (pd1_dev_handle == MR_PD_INVALID) {
>> +		bestArm = arm;
>> +	} else {
>> +		/* get the pending cmds for the data and mirror arms */
>> +		pend0 = atomic_read(&lbInfo->scsi_pending_cmds[pd0]);
>> +		pend1 = atomic_read(&lbInfo->scsi_pending_cmds[pd1]);
>> +
>> +		/* Determine the disk whose head is nearer to the req.
> block */
>> +		diff0 = ABS_DIFF(block, lbInfo->last_accessed_block[pd0]);
>> +		diff1 = ABS_DIFF(block, lbInfo->last_accessed_block[pd1]);
>> +		/*bestArm = diff0<=diff1 ? arm : arm ^ 1;*/
>> +		bestArm = (diff0 <= diff1 ? arm : arm ^ 1);
> The above comment is useless and the parentheses not needed,
> again please clean it up in a next series.
> Sasi - This shall be fixed in V5 patch
>
> tomash
>
>> +
>> +		/* Make balance count from 16 to 4 to
>> +		*  keep driver in sync with Firmware
>> +		*/
>> +		if ((bestArm == arm && pend0 > pend1 + lb_pending_cmds)
> ||
>>  			(bestArm != arm && pend1 > pend0 +
> lb_pending_cmds))
>> -		bestArm ^= 1;
>> +			bestArm ^= 1;
>> +
>> +		/* Update the last accessed block on the correct pd */
>> +		io_info->span_arm =
>> +			(span << RAID_CTX_SPANARM_SPAN_SHIFT) | bestArm;
>> +		io_info->pd_after_lb = (bestArm == arm) ? pd0 : pd1;
>> +	}
>>
>> -	/* Update the last accessed block on the correct pd */
>> -	io_info->pd_after_lb = (bestArm == arm) ? pd0 : pd1;
>>  	lbInfo->last_accessed_block[io_info->pd_after_lb] = block + count
> - 1;
>> -	io_info->span_arm = (span << RAID_CTX_SPANARM_SPAN_SHIFT) |
> bestArm;
>>  #if SPAN_DEBUG
>>  	if (arm != bestArm)
>>  		dev_dbg(&instance->pdev->dev, "LSI Debug R1 Load balance "
>> diff --git a/drivers/scsi/megaraid/megaraid_sas_fusion.c
> b/drivers/scsi/megaraid/megaraid_sas_fusion.c
>> index 2fcd5cd..58f86aa 100644
>> --- a/drivers/scsi/megaraid/megaraid_sas_fusion.c
>> +++ b/drivers/scsi/megaraid/megaraid_sas_fusion.c
>> @@ -1834,7 +1834,7 @@ static void megasas_stream_detect(struct
> megasas_instance *instance,
>>  			  struct megasas_cmd_fusion *cmd)
>>  {
>>  	u8 fp_possible;
>> -	u32 start_lba_lo, start_lba_hi, device_id, datalength = 0;
>> +	u32 start_lba_lo, start_lba_hi, device_id, datalength = 0, ld;
>>  	struct MPI2_RAID_SCSI_IO_REQUEST *io_request;
>>  	union MEGASAS_REQUEST_DESCRIPTOR_UNION *req_desc;
>>  	struct IO_REQUEST_INFO io_info;
>> @@ -1842,16 +1842,18 @@ static void megasas_stream_detect(struct
> megasas_instance *instance,
>>  	struct MR_DRV_RAID_MAP_ALL *local_map_ptr;
>>  	u8 *raidLUN;
>>  	unsigned long spinlock_flags;
>> +	union RAID_CONTEXT_UNION *praid_context;
>> +	struct MR_LD_RAID *raid;
>>
>>  	device_id = MEGASAS_DEV_INDEX(scp);
>>
>>  	fusion = instance->ctrl_context;
>>
>>  	io_request = cmd->io_request;
>> -	io_request->RaidContext.raid_context.VirtualDiskTgtId =
>> +	io_request->RaidContext.raid_context.virtual_disk_tgt_id =
>>  		cpu_to_le16(device_id);
>>  	io_request->RaidContext.raid_context.status = 0;
>> -	io_request->RaidContext.raid_context.exStatus = 0;
>> +	io_request->RaidContext.raid_context.ex_status = 0;
>>
>>  	req_desc = (union MEGASAS_REQUEST_DESCRIPTOR_UNION
> *)cmd->request_desc;
>> @@ -1920,10 +1922,12 @@ static void megasas_stream_detect(struct
> megasas_instance *instance,
>>  		io_info.isRead = 1;
>>
>>  	local_map_ptr = fusion->ld_drv_map[(instance->map_id & 1)];
>> +	ld = MR_TargetIdToLdGet(device_id, local_map_ptr);
>> +	raid = MR_LdRaidGet(ld, local_map_ptr);
>>
>>  	if ((MR_TargetIdToLdGet(device_id, local_map_ptr) >=
>>  		instance->fw_supported_vd_count) ||
> (!fusion->fast_path_io)) {
>> -		io_request->RaidContext.raid_context.regLockFlags  = 0;
>> +		io_request->RaidContext.raid_context.reg_lock_flags  = 0;
>>  		fp_possible = 0;
>>  	} else {
>>  		if (MR_BuildRaidContext(instance, &io_info,
>> @@ -1950,6 +1954,8 @@ static void megasas_stream_detect(struct
> megasas_instance *instance,
>>  			fp_possible = false;
>>  	}
>>
>> +	praid_context = &io_request->RaidContext;
>> +
>>  	if (fp_possible) {
>>  		megasas_set_pd_lba(io_request, scp->cmd_len, &io_info,
> scp,
>>  				   local_map_ptr, start_lba_lo);
>> @@ -1958,18 +1964,26 @@ static void megasas_stream_detect(struct
> megasas_instance *instance,
>>  			(MPI2_REQ_DESCRIPT_FLAGS_FP_IO
>>  			 << MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);
>>  		if (fusion->adapter_type == INVADER_SERIES) {
>> -			if
> (io_request->RaidContext.raid_context.regLockFlags ==
>> +			if
> (io_request->RaidContext.raid_context.reg_lock_flags ==
>>  			    REGION_TYPE_UNUSED)
>>  				cmd->request_desc->SCSIIO.RequestFlags =
>>
> (MEGASAS_REQ_DESCRIPT_FLAGS_NO_LOCK <<
> MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);
>> -			io_request->RaidContext.raid_context.Type
>> +			io_request->RaidContext.raid_context.type
>>  				= MPI2_TYPE_CUDA;
>>  			io_request->RaidContext.raid_context.nseg = 0x1;
>>  			io_request->IoFlags |=
> cpu_to_le16(MPI25_SAS_DEVICE0_FLAGS_ENABLED_FAST_PATH);
>> -			io_request->RaidContext.raid_context.regLockFlags
> |=
>> +
> io_request->RaidContext.raid_context.reg_lock_flags |=
>>  			  (MR_RL_FLAGS_GRANT_DESTINATION_CUDA |
>>  			   MR_RL_FLAGS_SEQ_NUM_ENABLE);
>> +		} else if (instance->is_ventura) {
>> +			io_request->RaidContext.raid_context_g35.type
>> +				= MPI2_TYPE_CUDA;
>> +			io_request->RaidContext.raid_context_g35.nseg =
> 0x1;
>> +
> io_request->RaidContext.raid_context_g35.routing_flags.bits.sqn
>> +				= 1;
>> +			io_request->IoFlags |=
>> +
> cpu_to_le16(MPI25_SAS_DEVICE0_FLAGS_ENABLED_FAST_PATH);
>>  		}
>>  		if ((fusion->load_balance_info[device_id].loadBalanceFlag)
> &&
>>  		    (io_info.isRead)) {
>> @@ -1979,6 +1993,13 @@ static void megasas_stream_detect(struct
> megasas_instance *instance,
>>  					&io_info);
>>  			scp->SCp.Status |= MEGASAS_LOAD_BALANCE_FLAG;
>>  			cmd->pd_r1_lb = io_info.pd_after_lb;
>> +			if (instance->is_ventura)
>> +
> io_request->RaidContext.raid_context_g35.span_arm
>> +					= io_info.span_arm;
>> +			else
>> +
> io_request->RaidContext.raid_context.span_arm
>> +					= io_info.span_arm;
>> +
>>  		} else
>>  			scp->SCp.Status &= ~MEGASAS_LOAD_BALANCE_FLAG;
>>
>> @@ -1997,28 +2018,98 @@ static void megasas_stream_detect(struct
> megasas_instance *instance,
>>  		io_request->DevHandle = io_info.devHandle;
>>  		/* populate the LUN field */
>>  		memcpy(io_request->LUN, raidLUN, 8);
>> +		if (instance->is_ventura) {
>> +			if (io_info.isRead) {
>> +				if ((raid->cpuAffinity.pdRead.cpu0) &&
>> +					(raid->cpuAffinity.pdRead.cpu1))
>> +
> praid_context->raid_context_g35.routing_flags.bits.cpu_sel
>> +					= MR_RAID_CTX_CPUSEL_FCFS;
>> +				else if (raid->cpuAffinity.pdRead.cpu1)
>> +
> praid_context->raid_context_g35.routing_flags.bits.cpu_sel
>> +					= MR_RAID_CTX_CPUSEL_1;
>> +				else
>> +
> praid_context->raid_context_g35.routing_flags.bits.cpu_sel
>> +					= MR_RAID_CTX_CPUSEL_0;
>> +			} else {
>> +			if ((raid->cpuAffinity.pdWrite.cpu0)
>> +			&& (raid->cpuAffinity.pdWrite.cpu1))
>> +
> praid_context->raid_context_g35.routing_flags.bits.cpu_sel
>> +					= MR_RAID_CTX_CPUSEL_FCFS;
>> +				else if (raid->cpuAffinity.pdWrite.cpu1)
>> +
> praid_context->raid_context_g35.routing_flags.bits.cpu_sel
>> +					= MR_RAID_CTX_CPUSEL_1;
>> +				else
>> +
> praid_context->raid_context_g35.routing_flags.bits.cpu_sel
>> +					= MR_RAID_CTX_CPUSEL_0;
>> +				if
> (praid_context->raid_context_g35.routing_flags.bits.sld) {
>> +
> praid_context->raid_context_g35.raid_flags
>> +					=
> (MR_RAID_FLAGS_IO_SUB_TYPE_CACHE_BYPASS
>> +					<<
> MR_RAID_CTX_RAID_FLAGS_IO_SUB_TYPE_SHIFT);
>> +				}
>> +			}
>> +		}
>>  	} else {
>> -		io_request->RaidContext.raid_context.timeoutValue =
>> +		io_request->RaidContext.raid_context.timeout_value =
>>
> cpu_to_le16(local_map_ptr->raidMap.fpPdIoTimeoutSec);
>>  		cmd->request_desc->SCSIIO.RequestFlags =
>>  			(MEGASAS_REQ_DESCRIPT_FLAGS_LD_IO
>>  			 << MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);
>>  		if (fusion->adapter_type == INVADER_SERIES) {
>>  			if (io_info.do_fp_rlbypass ||
>> -			(io_request->RaidContext.raid_context.regLockFlags
>> +
> (io_request->RaidContext.raid_context.reg_lock_flags
>>  					== REGION_TYPE_UNUSED))
>>  				cmd->request_desc->SCSIIO.RequestFlags =
>>
> (MEGASAS_REQ_DESCRIPT_FLAGS_NO_LOCK <<
> MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);
>> -			io_request->RaidContext.raid_context.Type
>> +			io_request->RaidContext.raid_context.type
>>  				= MPI2_TYPE_CUDA;
>> -			io_request->RaidContext.raid_context.regLockFlags
> |=
>> +
> io_request->RaidContext.raid_context.reg_lock_flags |=
>>  				(MR_RL_FLAGS_GRANT_DESTINATION_CPU0 |
>>  				 MR_RL_FLAGS_SEQ_NUM_ENABLE);
>>  			io_request->RaidContext.raid_context.nseg = 0x1;
>> +		} else if (instance->is_ventura) {
>> +			io_request->RaidContext.raid_context_g35.type
>> +			= MPI2_TYPE_CUDA;
>> +
> io_request->RaidContext.raid_context_g35.routing_flags.bits.sqn
>> +			= 1;
>> +			io_request->RaidContext.raid_context_g35.nseg =
> 0x1;
>>  		}
>>  		io_request->Function =
> MEGASAS_MPI2_FUNCTION_LD_IO_REQUEST;
>>  		io_request->DevHandle = cpu_to_le16(device_id);
>> +
>> +		if (instance->is_ventura) {
>> +			if (io_info.isRead) {
>> +				if ((raid->cpuAffinity.ldRead.cpu0)
>> +				&& (raid->cpuAffinity.ldRead.cpu1))
>> +
> praid_context->raid_context_g35.routing_flags.bits.cpu_sel
>> +					= MR_RAID_CTX_CPUSEL_FCFS;
>> +				else if (raid->cpuAffinity.ldRead.cpu1)
>> +
> praid_context->raid_context_g35.routing_flags.bits.cpu_sel
>> +						= MR_RAID_CTX_CPUSEL_1;
>> +				else
>> +
> praid_context->raid_context_g35.routing_flags.bits.cpu_sel
>> +						= MR_RAID_CTX_CPUSEL_0;
>> +			} else {
>> +				if ((raid->cpuAffinity.ldWrite.cpu0) &&
>> +					(raid->cpuAffinity.ldWrite.cpu1))
>> +
> praid_context->raid_context_g35.routing_flags.bits.cpu_sel
>> +							=
> MR_RAID_CTX_CPUSEL_FCFS;
>> +				else if (raid->cpuAffinity.ldWrite.cpu1)
>> +
> praid_context->raid_context_g35.routing_flags.bits.cpu_sel
>> +						= MR_RAID_CTX_CPUSEL_1;
>> +				else
>> +
> praid_context->raid_context_g35.routing_flags.bits.cpu_sel
>> +					= MR_RAID_CTX_CPUSEL_0;
>> +
>> +				if
> (io_request->RaidContext.raid_context_g35.stream_detected
>> +				&& (raid->level == 5)
>> +				&& (raid->writeMode ==
> MR_RL_WRITE_THROUGH_MODE)) {
>> +					if
> (praid_context->raid_context_g35.routing_flags.bits.cpu_sel ==
> MR_RAID_CTX_CPUSEL_FCFS)
>> +
> praid_context->raid_context_g35.routing_flags.bits.cpu_sel
>> +							=
> MR_RAID_CTX_CPUSEL_0;
>> +				}
>> +			}
>> +		}
>>  	} /* Not FP */
>>  }
>>
>> @@ -2053,9 +2144,9 @@ static void megasas_build_ld_nonrw_fusion(struct
> megasas_instance *instance,
>>  	/* get RAID_Context pointer */
>>  	pRAID_Context = &io_request->RaidContext.raid_context;
>>  	/* Check with FW team */
>> -	pRAID_Context->VirtualDiskTgtId = cpu_to_le16(device_id);
>> -	pRAID_Context->regLockRowLBA    = 0;
>> -	pRAID_Context->regLockLength    = 0;
>> +	pRAID_Context->virtual_disk_tgt_id = cpu_to_le16(device_id);
>> +	pRAID_Context->reg_lock_row_lba    = 0;
>> +	pRAID_Context->reg_lock_length    = 0;
>>
>>  	if (fusion->fast_path_io && (
>>  		device_id < instance->fw_supported_vd_count)) {
>> @@ -2074,7 +2165,7 @@ static void megasas_build_ld_nonrw_fusion(struct
> megasas_instance *instance,
>>  		io_request->Function  =
> MEGASAS_MPI2_FUNCTION_LD_IO_REQUEST;
>>  		io_request->DevHandle = cpu_to_le16(device_id);
>>  		io_request->LUN[1] = scmd->device->lun;
>> -		pRAID_Context->timeoutValue =
>> +		pRAID_Context->timeout_value =
>>  			cpu_to_le16 (scmd->request->timeout / HZ);
>>  		cmd->request_desc->SCSIIO.RequestFlags =
>>  			(MPI2_REQ_DESCRIPT_FLAGS_SCSI_IO <<
>> @@ -2082,9 +2173,10 @@ static void megasas_build_ld_nonrw_fusion(struct
> megasas_instance *instance,
>>  	} else {
>>
>>  		/* set RAID context values */
>> -		pRAID_Context->configSeqNum = raid->seqNum;
>> -		pRAID_Context->regLockFlags = REGION_TYPE_SHARED_READ;
>> -		pRAID_Context->timeoutValue =
> cpu_to_le16(raid->fpIoTimeoutForLd);
>> +		pRAID_Context->config_seq_num = raid->seqNum;
>> +		if (!instance->is_ventura)
>> +			pRAID_Context->reg_lock_flags =
> REGION_TYPE_SHARED_READ;
>> +		pRAID_Context->timeout_value =
> cpu_to_le16(raid->fpIoTimeoutForLd);
>>  		/* get the DevHandle for the PD (since this is
>>  		   fpNonRWCapable, this is a single disk RAID0) */
>> @@ -2139,12 +2231,12 @@ static void megasas_build_ld_nonrw_fusion(struct
> megasas_instance *instance,
>>  	io_request = cmd->io_request;
>>  	/* get RAID_Context pointer */
>>  	pRAID_Context = &io_request->RaidContext.raid_context;
>> -	pRAID_Context->regLockFlags = 0;
>> -	pRAID_Context->regLockRowLBA = 0;
>> -	pRAID_Context->regLockLength = 0;
>> +	pRAID_Context->reg_lock_flags = 0;
>> +	pRAID_Context->reg_lock_row_lba = 0;
>> +	pRAID_Context->reg_lock_length = 0;
>>  	io_request->DataLength = cpu_to_le32(scsi_bufflen(scmd));
>>  	io_request->LUN[1] = scmd->device->lun;
>> -	pRAID_Context->RAIDFlags = MR_RAID_FLAGS_IO_SUB_TYPE_SYSTEM_PD
>> +	pRAID_Context->raid_flags = MR_RAID_FLAGS_IO_SUB_TYPE_SYSTEM_PD
>>  		<< MR_RAID_CTX_RAID_FLAGS_IO_SUB_TYPE_SHIFT;
>>
>>  	/* If FW supports PD sequence number */
>> @@ -2153,24 +2245,28 @@ static void megasas_build_ld_nonrw_fusion(struct
> megasas_instance *instance,
>>  		/* TgtId must be incremented by 255 as jbod seq number is
> index
>>  		 * below raid map
>>  		 */
>> -		pRAID_Context->VirtualDiskTgtId =
>> +		pRAID_Context->virtual_disk_tgt_id =
>>  			cpu_to_le16(device_id + (MAX_PHYSICAL_DEVICES -
> 1));
>> -		pRAID_Context->configSeqNum =
> pd_sync->seq[pd_index].seqNum;
>> +		pRAID_Context->config_seq_num =
> pd_sync->seq[pd_index].seqNum;
>>  		io_request->DevHandle = pd_sync->seq[pd_index].devHandle;
>> -		pRAID_Context->regLockFlags |=
>> +		if (instance->is_ventura)
>> +
> io_request->RaidContext.raid_context_g35.routing_flags.bits.sqn
>> +			= 1;
>> +		else
>> +		pRAID_Context->reg_lock_flags |=
>>
> (MR_RL_FLAGS_SEQ_NUM_ENABLE|MR_RL_FLAGS_GRANT_DESTINATION_CUDA);
>> -		pRAID_Context->Type = MPI2_TYPE_CUDA;
>> +		pRAID_Context->type = MPI2_TYPE_CUDA;
>>  		pRAID_Context->nseg = 0x1;
>>  	} else if (fusion->fast_path_io) {
>> -		pRAID_Context->VirtualDiskTgtId = cpu_to_le16(device_id);
>> -		pRAID_Context->configSeqNum = 0;
>> +		pRAID_Context->virtual_disk_tgt_id =
> cpu_to_le16(device_id);
>> +		pRAID_Context->config_seq_num = 0;
>>  		local_map_ptr = fusion->ld_drv_map[(instance->map_id &
> 1)];
>>  		io_request->DevHandle =
>>
> local_map_ptr->raidMap.devHndlInfo[device_id].curDevHdl;
>>  	} else {
>>  		/* Want to send all IO via FW path */
>> -		pRAID_Context->VirtualDiskTgtId = cpu_to_le16(device_id);
>> -		pRAID_Context->configSeqNum = 0;
>> +		pRAID_Context->virtual_disk_tgt_id =
> cpu_to_le16(device_id);
>> +		pRAID_Context->config_seq_num = 0;
>>  		io_request->DevHandle = cpu_to_le16(0xFFFF);
>>  	}
>>
>> @@ -2186,14 +2282,14 @@ static void megasas_build_ld_nonrw_fusion(struct
> megasas_instance *instance,
>>  		cmd->request_desc->SCSIIO.RequestFlags =
>>  			(MPI2_REQ_DESCRIPT_FLAGS_SCSI_IO <<
>>  				MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);
>> -		pRAID_Context->timeoutValue =
> cpu_to_le16(os_timeout_value);
>> -		pRAID_Context->VirtualDiskTgtId = cpu_to_le16(device_id);
>> +		pRAID_Context->timeout_value =
> cpu_to_le16(os_timeout_value);
>> +		pRAID_Context->virtual_disk_tgt_id =
> cpu_to_le16(device_id);
>>  	} else {
>>  		/* system pd Fast Path */
>>  		io_request->Function = MPI2_FUNCTION_SCSI_IO_REQUEST;
>>  		timeout_limit = (scmd->device->type == TYPE_DISK) ?
>>  				255 : 0xFFFF;
>> -		pRAID_Context->timeoutValue =
>> +		pRAID_Context->timeout_value =
>>  			cpu_to_le16((os_timeout_value > timeout_limit) ?
>>  			timeout_limit : os_timeout_value);
>>  		if (fusion->adapter_type == INVADER_SERIES)
>> @@ -2232,8 +2328,8 @@ static void megasas_build_ld_nonrw_fusion(struct
> megasas_instance *instance,
>>  	io_request->Control = 0;
>>  	io_request->EEDPBlockSize = 0;
>>  	io_request->ChainOffset = 0;
>> -	io_request->RaidContext.raid_context.RAIDFlags = 0;
>> -	io_request->RaidContext.raid_context.Type = 0;
>> +	io_request->RaidContext.raid_context.raid_flags = 0;
>> +	io_request->RaidContext.raid_context.type = 0;
>>  	io_request->RaidContext.raid_context.nseg = 0;
>>
>>  	memcpy(io_request->CDB.CDB32, scp->cmnd, scp->cmd_len);
>> @@ -2278,11 +2374,16 @@ static void megasas_build_ld_nonrw_fusion(struct
> megasas_instance *instance,
>>  		return 1;
>>  	}
>>
>> -	/* numSGE store lower 8 bit of sge_count.
>> -	 * numSGEExt store higher 8 bit of sge_count
>> -	 */
>> -	io_request->RaidContext.raid_context.numSGE = sge_count;
>> -	io_request->RaidContext.raid_context.numSGEExt = (u8)(sge_count >>
> 8);
>> +	if (instance->is_ventura)
>> +		io_request->RaidContext.raid_context_g35.num_sge =
> sge_count;
>> +	else {
>> +		/* numSGE store lower 8 bit of sge_count.
>> +		 * numSGEExt store higher 8 bit of sge_count
>> +		 */
>> +		io_request->RaidContext.raid_context.num_sge = sge_count;
>> +		io_request->RaidContext.raid_context.num_sge_ext =
>> +			(u8)(sge_count >> 8);
>> +	}
>>
>>  	io_request->SGLFlags =
> cpu_to_le16(MPI2_SGE_FLAGS_64_BIT_ADDRESSING);
>> @@ -2331,6 +2432,10 @@ void megasas_fpio_to_ldio(struct megasas_instance
> *instance,
>>  	struct megasas_cmd_fusion *cmd, struct scsi_cmnd *scmd)
>>  {
>>  	struct fusion_context *fusion;
>> +	union RAID_CONTEXT_UNION *praid_context;
>> +	struct MR_LD_RAID *raid;
>> +	struct MR_DRV_RAID_MAP_ALL *local_map_ptr;
>> +	u32 device_id, ld;
>>  	fusion = instance->ctrl_context;
>>
>>  	cmd->request_desc->SCSIIO.RequestFlags =
>> @@ -2354,6 +2459,35 @@ void megasas_fpio_to_ldio(struct megasas_instance
> *instance,
>>  	cmd->io_request->Control = 0;
>>  	cmd->io_request->EEDPBlockSize = 0;
>>  	cmd->is_raid_1_fp_write = 0;
>> +
>> +	device_id = MEGASAS_DEV_INDEX(cmd->scmd);
>> +	local_map_ptr = fusion->ld_drv_map[(instance->map_id & 1)];
>> +	ld = MR_TargetIdToLdGet(device_id, local_map_ptr);
>> +	raid = MR_LdRaidGet(ld, local_map_ptr);
>> +	praid_context = &cmd->io_request->RaidContext;
>> +	if (cmd->scmd->sc_data_direction == PCI_DMA_FROMDEVICE) {
>> +		if ((raid->cpuAffinity.ldRead.cpu0)
>> +		&& (raid->cpuAffinity.ldRead.cpu1))
>> +
> praid_context->raid_context_g35.routing_flags.bits.cpu_sel
>> +			= MR_RAID_CTX_CPUSEL_FCFS;
>> +		else if (raid->cpuAffinity.ldRead.cpu1)
>> +
> praid_context->raid_context_g35.routing_flags.bits.cpu_sel
>> +			= MR_RAID_CTX_CPUSEL_1;
>> +		else
>> +
> praid_context->raid_context_g35.routing_flags.bits.cpu_sel
>> +			= MR_RAID_CTX_CPUSEL_0;
>> +	} else {
>> +	if ((raid->cpuAffinity.ldWrite.cpu0)
>> +		&& (raid->cpuAffinity.ldWrite.cpu1))
>> +		praid_context->raid_context_g35.routing_flags.bits.cpu_sel
>> +			= MR_RAID_CTX_CPUSEL_FCFS;
>> +	else if (raid->cpuAffinity.ldWrite.cpu1)
>> +		praid_context->raid_context_g35.routing_flags.bits.cpu_sel
>> +			= MR_RAID_CTX_CPUSEL_1;
>> +	else
>> +		praid_context->raid_context_g35.routing_flags.bits.cpu_sel
>> +		= MR_RAID_CTX_CPUSEL_0;
>> +	}
>>  }
>>  /*megasas_prepate_secondRaid1_IO
>>   * It prepares the raid 1 second IO
>> @@ -2491,6 +2625,7 @@ void megasas_prepare_secondRaid1_IO(struct
> megasas_instance *instance,
>>  	*	corresponds to single R1/10 LD are always same
>>  	*
>>  	*/
>> +
>>  	/*	driver side count always should be less than max_fw_cmds
>>  	*	to get new command
>>  	*/
>> @@ -2588,7 +2723,7 @@ void megasas_prepare_secondRaid1_IO(struct
> megasas_instance *instance,
>>  		scmd_local = cmd_fusion->scmd;
>>  		status = scsi_io_req->RaidContext.raid_context.status;
>> -		extStatus =
> scsi_io_req->RaidContext.raid_context.exStatus;
>> +		extStatus =
> scsi_io_req->RaidContext.raid_context.ex_status;
>>  		sense = cmd_fusion->sense;
>>  		data_length = scsi_io_req->DataLength;
>>
>> @@ -2656,13 +2791,13 @@ void megasas_prepare_secondRaid1_IO(struct
> megasas_instance *instance,
>>  					status =
>>
> r1_cmd->io_request->RaidContext.raid_context.status;
>>  					extStatus =
>> -
> r1_cmd->io_request->RaidContext.raid_context.exStatus;
>> +
> r1_cmd->io_request->RaidContext.raid_context.ex_status;
>>  					data_length =
>>
> r1_cmd->io_request->DataLength;
>>  					sense = r1_cmd->sense;
>>  				}
>>
> r1_cmd->io_request->RaidContext.raid_context.status = 0;
>> -
> r1_cmd->io_request->RaidContext.raid_context.exStatus = 0;
>> +
> r1_cmd->io_request->RaidContext.raid_context.ex_status = 0;
>>  				cmd_fusion->is_raid_1_fp_write = 0;
>>  				r1_cmd->is_raid_1_fp_write = 0;
>>  				r1_cmd->cmd_completed = false;
>> @@ -2674,7 +2809,7 @@ void megasas_prepare_secondRaid1_IO(struct
> megasas_instance *instance,
>>  					extStatus, data_length, sense);
>>
> scsi_io_req->RaidContext.raid_context.status
>>  				= 0;
>> -
> scsi_io_req->RaidContext.raid_context.exStatus
>> +
> scsi_io_req->RaidContext.raid_context.ex_status
>>  				= 0;
>>  				megasas_return_cmd_fusion(instance,
> cmd_fusion);
>>  				scsi_dma_unmap(scmd_local);
>> diff --git a/drivers/scsi/megaraid/megaraid_sas_fusion.h
> b/drivers/scsi/megaraid/megaraid_sas_fusion.h
>> index 5590c1d..cb42655 100644
>> --- a/drivers/scsi/megaraid/megaraid_sas_fusion.h
>> +++ b/drivers/scsi/megaraid/megaraid_sas_fusion.h
>> @@ -59,6 +59,8 @@
>>  #define	MR_RL_FLAGS_GRANT_DESTINATION_CPU1	    0x10
>>  #define	MR_RL_FLAGS_GRANT_DESTINATION_CUDA	    0x80
>>  #define MR_RL_FLAGS_SEQ_NUM_ENABLE		    0x8
>> +#define MR_RL_WRITE_THROUGH_MODE		    0x00
>> +#define MR_RL_WRITE_BACK_MODE			    0x01
>>
>>  /* T10 PI defines */
>>  #define MR_PROT_INFO_TYPE_CONTROLLER                0x8
>> @@ -81,6 +83,11 @@
>>  enum MR_RAID_FLAGS_IO_SUB_TYPE {
>>  	MR_RAID_FLAGS_IO_SUB_TYPE_NONE = 0,
>>  	MR_RAID_FLAGS_IO_SUB_TYPE_SYSTEM_PD = 1,
>> +	MR_RAID_FLAGS_IO_SUB_TYPE_RMW_DATA     = 2,
>> +	MR_RAID_FLAGS_IO_SUB_TYPE_RMW_P        = 3,
>> +	MR_RAID_FLAGS_IO_SUB_TYPE_RMW_Q        = 4,
>> +	MR_RAID_FLAGS_IO_SUB_TYPE_CACHE_BYPASS = 6,
>> +	MR_RAID_FLAGS_IO_SUB_TYPE_LDIO_BW_LIMIT = 7
>>  };
>>
>>  /*
>> @@ -109,29 +116,29 @@ enum MR_FUSION_ADAPTER_TYPE {
>>
>>  struct RAID_CONTEXT {
>>  #if   defined(__BIG_ENDIAN_BITFIELD)
>> -	u8	nseg:4;
>> -	u8	Type:4;
>> +	u8 nseg:4;
>> +	u8 type:4;
>>  #else
>> -	u8	Type:4;
>> -	u8	nseg:4;
>> +	u8 type:4;
>> +	u8 nseg:4;
>>  #endif
>> -	u8	resvd0;
>> -	__le16	timeoutValue;
>> -	u8      regLockFlags;
>> -	u8      resvd1;
>> -	__le16	VirtualDiskTgtId;
>> -	__le64	regLockRowLBA;
>> -	__le32	regLockLength;
>> -	__le16	nextLMId;
>> -	u8      exStatus;
>> -	u8      status;
>> -	u8      RAIDFlags;
>> -	u8      numSGE;
>> -	__le16	configSeqNum;
>> -	u8      spanArm;
>> -	u8      priority;
>> -	u8	numSGEExt;
>> -	u8      resvd2;
>> +	u8 resvd0;
>> +	__le16 timeout_value;
>> +	u8 reg_lock_flags;
>> +	u8 resvd1;
>> +	__le16 virtual_disk_tgt_id;
>> +	__le64 reg_lock_row_lba;
>> +	__le32 reg_lock_length;
>> +	__le16 next_lmid;
>> +	u8 ex_status;
>> +	u8 status;
>> +	u8 raid_flags;
>> +	u8 num_sge;
>> +	__le16 config_seq_num;
>> +	u8 span_arm;
>> +	u8 priority;
>> +	u8 num_sge_ext;
>> +	u8 resvd2;
>>  };
>>
>>  /*
>> @@ -187,7 +194,7 @@ struct RAID_CONTEXT_G35 {
>>  	} smid;
>>  	u8 ex_status;       /* 0x16 : OUT */
>>  	u8 status;          /* 0x17 status */
>> -	u8 RAIDFlags;		/* 0x18 resvd[7:6], ioSubType[5:4],
>> +	u8 raid_flags;		/* 0x18 resvd[7:6], ioSubType[5:4],
>>  						* resvd[3:1],
> preferredCpu[0]
>>  						*/
>>  	u8 span_arm;            /* 0x1C span[7:5], arm[4:0] */
>> @@ -672,14 +679,17 @@ struct MPI2_IOC_INIT_REQUEST {
>>  #define MAX_RAIDMAP_ROW_SIZE (MAX_ROW_SIZE)
>>  #define MAX_LOGICAL_DRIVES 64
>>  #define MAX_LOGICAL_DRIVES_EXT 256
>> +#define MAX_LOGICAL_DRIVES_DYN 512
>>  #define MAX_RAIDMAP_LOGICAL_DRIVES (MAX_LOGICAL_DRIVES)
>>  #define MAX_RAIDMAP_VIEWS (MAX_LOGICAL_DRIVES)
>>  #define MAX_ARRAYS 128
>>  #define MAX_RAIDMAP_ARRAYS (MAX_ARRAYS)
>>  #define MAX_ARRAYS_EXT	256
>>  #define MAX_API_ARRAYS_EXT (MAX_ARRAYS_EXT)
>> +#define MAX_API_ARRAYS_DYN 512
>>  #define MAX_PHYSICAL_DEVICES 256
>>  #define MAX_RAIDMAP_PHYSICAL_DEVICES (MAX_PHYSICAL_DEVICES)
>> +#define MAX_RAIDMAP_PHYSICAL_DEVICES_DYN 512
>>  #define MR_DCMD_LD_MAP_GET_INFO             0x0300e101
>>  #define MR_DCMD_SYSTEM_PD_MAP_GET_INFO      0x0200e102
>>  #define MR_DCMD_CTRL_SHARED_HOST_MEM_ALLOC  0x010e8485   /* SR-IOV HB
> alloc*/
>> @@ -726,12 +736,56 @@ struct MR_SPAN_BLOCK_INFO {
>>  	struct MR_SPAN_INFO block_span_info;
>>  };
>>
>> +#define MR_RAID_CTX_CPUSEL_0		0
>> +#define MR_RAID_CTX_CPUSEL_1		1
>> +#define MR_RAID_CTX_CPUSEL_2		2
>> +#define MR_RAID_CTX_CPUSEL_3		3
>> +#define MR_RAID_CTX_CPUSEL_FCFS		0xF
>> +
>> +struct MR_CPU_AFFINITY_MASK {
>> +	union {
>> +		struct {
>> +#ifndef MFI_BIG_ENDIAN
>> +		u8 hw_path:1;
>> +		u8 cpu0:1;
>> +		u8 cpu1:1;
>> +		u8 cpu2:1;
>> +		u8 cpu3:1;
>> +		u8 reserved:3;
>> +#else
>> +		u8 reserved:3;
>> +		u8 cpu3:1;
>> +		u8 cpu2:1;
>> +		u8 cpu1:1;
>> +		u8 cpu0:1;
>> +		u8 hw_path:1;
>> +#endif
>> +		};
>> +		u8 core_mask;
>> +	};
>> +};
>> +
>> +struct MR_IO_AFFINITY {
>> +	union {
>> +		struct {
>> +			struct MR_CPU_AFFINITY_MASK pdRead;
>> +			struct MR_CPU_AFFINITY_MASK pdWrite;
>> +			struct MR_CPU_AFFINITY_MASK ldRead;
>> +			struct MR_CPU_AFFINITY_MASK ldWrite;
>> +			};
>> +		u32 word;
>> +		};
>> +	u8 maxCores;    /* Total cores + HW Path in ROC */
>> +	u8 reserved[3];
>> +};
>> +
>>  struct MR_LD_RAID {
>>  	struct {
>>  #if   defined(__BIG_ENDIAN_BITFIELD)
>> -		u32     reserved4:3;
>> -		u32     fp_cache_bypass_capable:1;
>> -		u32     fp_rmw_capable:1;
>> +		u32 reserved4:2;
>> +		u32 fp_cache_bypass_capable:1;
>> +		u32 fp_rmw_capable:1;
>> +		u32 disable_coalescing:1;
>>  		u32     fpBypassRegionLock:1;
>>  		u32     tmCapable:1;
>>  		u32	fpNonRWCapable:1;
>> @@ -759,9 +813,10 @@ struct MR_LD_RAID {
>>  		u32	fpNonRWCapable:1;
>>  		u32     tmCapable:1;
>>  		u32     fpBypassRegionLock:1;
>> -		u32     fp_rmw_capable:1;
>> -		u32     fp_cache_bypass_capable:1;
>> -		u32     reserved4:3;
>> +		u32 disable_coalescing:1;
>> +		u32 fp_rmw_capable:1;
>> +		u32 fp_cache_bypass_capable:1;
>> +		u32 reserved4:2;
>>  #endif
>>  	} capability;
>>  	__le32     reserved6;
>> @@ -788,7 +843,36 @@ struct MR_LD_RAID {
>>
>>  	u8	LUN[8]; /* 0x24 8 byte LUN field used for SCSI IO's */
>>  	u8	fpIoTimeoutForLd;/*0x2C timeout value used by driver in FP
> IO*/
>> -	u8      reserved3[0x80-0x2D]; /* 0x2D */
>> +	/* Ox2D This LD accept priority boost of this type */
>> +	u8 ld_accept_priority_type;
>> +	u8 reserved2[2];	        /* 0x2E - 0x2F */
>> +	/* 0x30 - 0x33, Logical block size for the LD */
>> +	u32 logical_block_length;
>> +	struct {
>> +#ifndef MFI_BIG_ENDIAN
>> +	/* 0x34, P_I_EXPONENT from READ CAPACITY 16 */
>> +	u32 ld_pi_exp:4;
>> +	/* 0x34, LOGICAL BLOCKS PER PHYSICAL
>> +	*  BLOCK EXPONENT from READ CAPACITY 16
>> +	*/
>> +	u32 ld_logical_block_exp:4;
>> +	u32 reserved1:24;           /* 0x34 */
>> +#else
>> +	u32 reserved1:24;           /* 0x34 */
>> +	/* 0x34, LOGICAL BLOCKS PER PHYSICAL
>> +	*  BLOCK EXPONENT from READ CAPACITY 16
>> +	*/
>> +	u32 ld_logical_block_exp:4;
>> +	/* 0x34, P_I_EXPONENT from READ CAPACITY 16 */
>> +	u32 ld_pi_exp:4;
>> +#endif
>> +	};                               /* 0x34 - 0x37 */
>> +	 /* 0x38 - 0x3f, This will determine which
>> +	 *  core will process LD IO and PD IO.
>> +	 */
>> +	struct MR_IO_AFFINITY cpuAffinity;
>> +     /* Bit definiations are specified by MR_IO_AFFINITY */
>> +	u8 reserved3[0x80-0x40];    /* 0x40 - 0x7f */
>>  };
>>
>>  struct MR_LD_SPAN_MAP {
>> @@ -846,6 +930,91 @@ struct MR_LD_TARGET_SYNC {
>>  	__le16 seqNum;
>>  };
>>
>> +/*
>> +* RAID Map descriptor Types.
>> +* Each element should uniquely idetify one data structure in the RAID
> map
>> +*/
>> +enum MR_RAID_MAP_DESC_TYPE {
>> +	/* MR_DEV_HANDLE_INFO data */
>> +	RAID_MAP_DESC_TYPE_DEVHDL_INFO    = 0x0,
>> +	/* target to Ld num Index map */
>> +	RAID_MAP_DESC_TYPE_TGTID_INFO     = 0x1,
>> +	/* MR_ARRAY_INFO data */
>> +	RAID_MAP_DESC_TYPE_ARRAY_INFO     = 0x2,
>> +	/* MR_LD_SPAN_MAP data */
>> +	RAID_MAP_DESC_TYPE_SPAN_INFO      = 0x3,
>> +	RAID_MAP_DESC_TYPE_COUNT,
>> +};
>> +
>> +/*
>> +* This table defines the offset, size and num elements  of each
> descriptor
>> +* type in the RAID Map buffer
>> +*/
>> +struct MR_RAID_MAP_DESC_TABLE {
>> +	/* Raid map descriptor type */
>> +	u32 raid_map_desc_type;
>> +	/* Offset into the RAID map buffer where
>> +	*  descriptor data is saved
>> +	*/
>> +	u32 raid_map_desc_offset;
>> +	/* total size of the
>> +	* descriptor buffer
>> +	*/
>> +	u32 raid_map_desc_buffer_size;
>> +	/* Number of elements contained in the
>> +	*  descriptor buffer
>> +	*/
>> +	u32 raid_map_desc_elements;
>> +};
>> +
>> +/*
>> +* Dynamic Raid Map Structure.
>> +*/
>> +struct MR_FW_RAID_MAP_DYNAMIC {
>> +	u32 raid_map_size;   /* total size of RAID Map structure */
>> +	u32 desc_table_offset;/* Offset of desc table into RAID map*/
>> +	u32 desc_table_size;  /* Total Size of desc table */
>> +	/* Total Number of elements in the desc table */
>> +	u32 desc_table_num_elements;
>> +	u64	reserved1;
>> +	u32	reserved2[3];	/*future use */
>> +	/* timeout value used by driver in FP IOs */
>> +	u8 fp_pd_io_timeout_sec;
>> +	u8 reserved3[3];
>> +	/* when this seqNum increments, driver needs to
>> +	*  release RMW buffers asap
>> +	*/
>> +	u32 rmw_fp_seq_num;
>> +	u16 ld_count;	/* count of lds. */
>> +	u16 ar_count;   /* count of arrays */
>> +	u16 span_count; /* count of spans */
>> +	u16 reserved4[3];
>> +/*
>> +* The below structure of pointers is only to be used by the driver.
>> +* This is added in the ,API to reduce the amount of code changes
>> +* needed in the driver to support dynamic RAID map Firmware should
>> +* not update these pointers while preparing the raid map
>> +*/
>> +	union {
>> +		struct {
>> +			struct MR_DEV_HANDLE_INFO  *dev_hndl_info;
>> +			u16 *ld_tgt_id_to_ld;
>> +			struct MR_ARRAY_INFO *ar_map_info;
>> +			struct MR_LD_SPAN_MAP *ld_span_map;
>> +			};
>> +		u64 ptr_structure_size[RAID_MAP_DESC_TYPE_COUNT];
>> +		};
>> +/*
>> +* RAID Map descriptor table defines the layout of data in the RAID Map.
>> +* The size of the descriptor table itself could change.
>> +*/
>> +	/* Variable Size descriptor Table. */
>> +	struct MR_RAID_MAP_DESC_TABLE
>> +			raid_map_desc_table[RAID_MAP_DESC_TYPE_COUNT];
>> +	/* Variable Size buffer containing all data */
>> +	u32 raid_map_desc_data[1];
>> +}; /* Dynamicaly sized RAID MAp structure */
>> +
>>  #define IEEE_SGE_FLAGS_ADDR_MASK            (0x03)
>>  #define IEEE_SGE_FLAGS_SYSTEM_ADDR          (0x00)
>>  #define IEEE_SGE_FLAGS_IOCDDR_ADDR          (0x01)
>> @@ -955,9 +1124,10 @@ struct MR_DRV_RAID_MAP {
>>  	__le16                 spanCount;
>>  	__le16                 reserve3;
>>
>> -	struct MR_DEV_HANDLE_INFO
> devHndlInfo[MAX_RAIDMAP_PHYSICAL_DEVICES];
>> -	u8                  ldTgtIdToLd[MAX_LOGICAL_DRIVES_EXT];
>> -	struct MR_ARRAY_INFO       arMapInfo[MAX_API_ARRAYS_EXT];
>> +	struct MR_DEV_HANDLE_INFO
>> +		devHndlInfo[MAX_RAIDMAP_PHYSICAL_DEVICES_DYN];
>> +	u16 ldTgtIdToLd[MAX_LOGICAL_DRIVES_DYN];
>> +	struct MR_ARRAY_INFO arMapInfo[MAX_API_ARRAYS_DYN];
>>  	struct MR_LD_SPAN_MAP      ldSpanMap[1];
>>
>>  };
>> @@ -969,7 +1139,7 @@ struct MR_DRV_RAID_MAP {
>>  struct MR_DRV_RAID_MAP_ALL {
>>
>>  	struct MR_DRV_RAID_MAP raidMap;
>> -	struct MR_LD_SPAN_MAP      ldSpanMap[MAX_LOGICAL_DRIVES_EXT - 1];
>> +	struct MR_LD_SPAN_MAP ldSpanMap[MAX_LOGICAL_DRIVES_DYN - 1];
>>  } __packed;
>>
>>
>> @@ -1088,7 +1258,7 @@ struct fusion_context {
>>  	u8	chain_offset_io_request;
>>  	u8	chain_offset_mfi_pthru;
>>
>> -	struct MR_FW_RAID_MAP_ALL *ld_map[2];
>> +	struct MR_FW_RAID_MAP_DYNAMIC *ld_map[2];
>>  	dma_addr_t ld_map_phys[2];
>>
>>  	/*Non dma-able memory. Driver local copy.*/
>> @@ -1096,6 +1266,8 @@ struct fusion_context {
>>
>>  	u32 max_map_sz;
>>  	u32 current_map_sz;
>> +	u32 old_map_sz;
>> +	u32 new_map_sz;
>>  	u32 drv_map_sz;
>>  	u32 drv_map_pages;
>>  	struct MR_PD_CFG_SEQ_NUM_SYNC	*pd_seq_sync[JBOD_MAPS_COUNT];
> --
> To unsubscribe from this list: 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


--
To unsubscribe from this list: 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