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