1665484d8SDoug Ambrisko /* 2ecea5be4SKashyap D Desai * Copyright (c) 2015, AVAGO Tech. All rights reserved. Author: Marian Choy 38e727371SKashyap D Desai * Copyright (c) 2014, LSI Corp. All rights reserved. Author: Marian Choy 4ecea5be4SKashyap D Desai * Support: freebsdraid@avagotech.com 5665484d8SDoug Ambrisko * 6665484d8SDoug Ambrisko * Redistribution and use in source and binary forms, with or without 78e727371SKashyap D Desai * modification, are permitted provided that the following conditions are 88e727371SKashyap D Desai * met: 9665484d8SDoug Ambrisko * 108e727371SKashyap D Desai * 1. Redistributions of source code must retain the above copyright notice, 118e727371SKashyap D Desai * this list of conditions and the following disclaimer. 2. Redistributions 128e727371SKashyap D Desai * in binary form must reproduce the above copyright notice, this list of 138e727371SKashyap D Desai * conditions and the following disclaimer in the documentation and/or other 148e727371SKashyap D Desai * materials provided with the distribution. 3. Neither the name of the 158e727371SKashyap D Desai * <ORGANIZATION> nor the names of its contributors may be used to endorse or 168e727371SKashyap D Desai * promote products derived from this software without specific prior written 178e727371SKashyap D Desai * permission. 18665484d8SDoug Ambrisko * 198e727371SKashyap D Desai * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 208e727371SKashyap D Desai * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 218e727371SKashyap D Desai * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 228e727371SKashyap D Desai * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE 238e727371SKashyap D Desai * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 248e727371SKashyap D Desai * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 258e727371SKashyap D Desai * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 268e727371SKashyap D Desai * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 278e727371SKashyap D Desai * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 288e727371SKashyap D Desai * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29665484d8SDoug Ambrisko * POSSIBILITY OF SUCH DAMAGE. 30665484d8SDoug Ambrisko * 318e727371SKashyap D Desai * The views and conclusions contained in the software and documentation are 328e727371SKashyap D Desai * those of the authors and should not be interpreted as representing 33665484d8SDoug Ambrisko * official policies,either expressed or implied, of the FreeBSD Project. 34665484d8SDoug Ambrisko * 35ecea5be4SKashyap D Desai * Send feedback to: <megaraidfbsd@avagotech.com> Mail to: AVAGO TECHNOLOGIES, 1621 368e727371SKashyap D Desai * Barber Lane, Milpitas, CA 95035 ATTN: MegaRaid FreeBSD 37665484d8SDoug Ambrisko * 38665484d8SDoug Ambrisko */ 39665484d8SDoug Ambrisko 40665484d8SDoug Ambrisko #include <sys/cdefs.h> 41665484d8SDoug Ambrisko __FBSDID("$FreeBSD$"); 42665484d8SDoug Ambrisko 43665484d8SDoug Ambrisko #include <dev/mrsas/mrsas.h> 44665484d8SDoug Ambrisko 45665484d8SDoug Ambrisko #include <cam/cam.h> 46665484d8SDoug Ambrisko #include <cam/cam_ccb.h> 47665484d8SDoug Ambrisko #include <cam/cam_sim.h> 48665484d8SDoug Ambrisko #include <cam/cam_xpt_sim.h> 49665484d8SDoug Ambrisko #include <cam/cam_debug.h> 50665484d8SDoug Ambrisko #include <cam/cam_periph.h> 51665484d8SDoug Ambrisko #include <cam/cam_xpt_periph.h> 52665484d8SDoug Ambrisko 53665484d8SDoug Ambrisko 54665484d8SDoug Ambrisko /* 55665484d8SDoug Ambrisko * Function prototypes 56665484d8SDoug Ambrisko */ 57665484d8SDoug Ambrisko u_int8_t MR_ValidateMapInfo(struct mrsas_softc *sc); 58dbcc81dfSKashyap D Desai u_int8_t 59dbcc81dfSKashyap D Desai mrsas_get_best_arm_pd(struct mrsas_softc *sc, 6016dc2814SKashyap D Desai PLD_LOAD_BALANCE_INFO lbInfo, struct IO_REQUEST_INFO *io_info); 618e727371SKashyap D Desai u_int8_t 628e727371SKashyap D Desai MR_BuildRaidContext(struct mrsas_softc *sc, 63665484d8SDoug Ambrisko struct IO_REQUEST_INFO *io_info, 644799d485SKashyap D Desai RAID_CONTEXT * pRAID_Context, MR_DRV_RAID_MAP_ALL * map); 658e727371SKashyap D Desai u_int8_t 668e727371SKashyap D Desai MR_GetPhyParams(struct mrsas_softc *sc, u_int32_t ld, 67665484d8SDoug Ambrisko u_int64_t stripRow, u_int16_t stripRef, struct IO_REQUEST_INFO *io_info, 68665484d8SDoug Ambrisko RAID_CONTEXT * pRAID_Context, 694799d485SKashyap D Desai MR_DRV_RAID_MAP_ALL * map); 704ad83576SKashyap D Desai u_int8_t MR_TargetIdToLdGet(u_int32_t ldTgtId, MR_DRV_RAID_MAP_ALL *map); 714799d485SKashyap D Desai u_int32_t MR_LdBlockSizeGet(u_int32_t ldTgtId, MR_DRV_RAID_MAP_ALL * map); 724799d485SKashyap D Desai u_int16_t MR_GetLDTgtId(u_int32_t ld, MR_DRV_RAID_MAP_ALL * map); 73dbcc81dfSKashyap D Desai u_int16_t 74dbcc81dfSKashyap D Desai mrsas_get_updated_dev_handle(struct mrsas_softc *sc, 7516dc2814SKashyap D Desai PLD_LOAD_BALANCE_INFO lbInfo, struct IO_REQUEST_INFO *io_info); 76665484d8SDoug Ambrisko u_int32_t mega_mod64(u_int64_t dividend, u_int32_t divisor); 778e727371SKashyap D Desai u_int32_t 788e727371SKashyap D Desai MR_GetSpanBlock(u_int32_t ld, u_int64_t row, u_int64_t *span_blk, 794799d485SKashyap D Desai MR_DRV_RAID_MAP_ALL * map, int *div_error); 80665484d8SDoug Ambrisko u_int64_t mega_div64_32(u_int64_t dividend, u_int32_t divisor); 81dbcc81dfSKashyap D Desai void 82dbcc81dfSKashyap D Desai mrsas_update_load_balance_params(struct mrsas_softc *sc, 8316dc2814SKashyap D Desai MR_DRV_RAID_MAP_ALL * map, PLD_LOAD_BALANCE_INFO lbInfo); 848e727371SKashyap D Desai void 858e727371SKashyap D Desai mrsas_set_pd_lba(MRSAS_RAID_SCSI_IO_REQUEST * io_request, 86665484d8SDoug Ambrisko u_int8_t cdb_len, struct IO_REQUEST_INFO *io_info, union ccb *ccb, 874799d485SKashyap D Desai MR_DRV_RAID_MAP_ALL * local_map_ptr, u_int32_t ref_tag, 88665484d8SDoug Ambrisko u_int32_t ld_block_size); 898e727371SKashyap D Desai static u_int16_t 908e727371SKashyap D Desai MR_LdSpanArrayGet(u_int32_t ld, u_int32_t span, 914799d485SKashyap D Desai MR_DRV_RAID_MAP_ALL * map); 924799d485SKashyap D Desai static u_int16_t MR_PdDevHandleGet(u_int32_t pd, MR_DRV_RAID_MAP_ALL * map); 938e727371SKashyap D Desai static u_int16_t 948e727371SKashyap D Desai MR_ArPdGet(u_int32_t ar, u_int32_t arm, 954799d485SKashyap D Desai MR_DRV_RAID_MAP_ALL * map); 968e727371SKashyap D Desai static MR_LD_SPAN * 978e727371SKashyap D Desai MR_LdSpanPtrGet(u_int32_t ld, u_int32_t span, 984799d485SKashyap D Desai MR_DRV_RAID_MAP_ALL * map); 998e727371SKashyap D Desai static u_int8_t 1008e727371SKashyap D Desai MR_LdDataArmGet(u_int32_t ld, u_int32_t armIdx, 1014799d485SKashyap D Desai MR_DRV_RAID_MAP_ALL * map); 1028e727371SKashyap D Desai static MR_SPAN_BLOCK_INFO * 1038e727371SKashyap D Desai MR_LdSpanInfoGet(u_int32_t ld, 1044799d485SKashyap D Desai MR_DRV_RAID_MAP_ALL * map); 1054799d485SKashyap D Desai MR_LD_RAID *MR_LdRaidGet(u_int32_t ld, MR_DRV_RAID_MAP_ALL * map); 1064ad83576SKashyap D Desai static int MR_PopulateDrvRaidMap(struct mrsas_softc *sc); 1074799d485SKashyap D Desai 108665484d8SDoug Ambrisko 109665484d8SDoug Ambrisko /* 1108e727371SKashyap D Desai * Spanset related function prototypes Added for PRL11 configuration (Uneven 1118e727371SKashyap D Desai * span support) 112665484d8SDoug Ambrisko */ 1134799d485SKashyap D Desai void mr_update_span_set(MR_DRV_RAID_MAP_ALL * map, PLD_SPAN_INFO ldSpanInfo); 1148e727371SKashyap D Desai static u_int8_t 1158e727371SKashyap D Desai mr_spanset_get_phy_params(struct mrsas_softc *sc, u_int32_t ld, 116665484d8SDoug Ambrisko u_int64_t stripRow, u_int16_t stripRef, struct IO_REQUEST_INFO *io_info, 1174799d485SKashyap D Desai RAID_CONTEXT * pRAID_Context, MR_DRV_RAID_MAP_ALL * map); 1188e727371SKashyap D Desai static u_int64_t 1198e727371SKashyap D Desai get_row_from_strip(struct mrsas_softc *sc, u_int32_t ld, 1204799d485SKashyap D Desai u_int64_t strip, MR_DRV_RAID_MAP_ALL * map); 1218e727371SKashyap D Desai static u_int32_t 1228e727371SKashyap D Desai mr_spanset_get_span_block(struct mrsas_softc *sc, 123665484d8SDoug Ambrisko u_int32_t ld, u_int64_t row, u_int64_t *span_blk, 1244799d485SKashyap D Desai MR_DRV_RAID_MAP_ALL * map, int *div_error); 1258e727371SKashyap D Desai static u_int8_t 1268e727371SKashyap D Desai get_arm(struct mrsas_softc *sc, u_int32_t ld, u_int8_t span, 1274799d485SKashyap D Desai u_int64_t stripe, MR_DRV_RAID_MAP_ALL * map); 128665484d8SDoug Ambrisko 129665484d8SDoug Ambrisko 130665484d8SDoug Ambrisko /* 1318e727371SKashyap D Desai * Spanset related defines Added for PRL11 configuration(Uneven span support) 132665484d8SDoug Ambrisko */ 133665484d8SDoug Ambrisko #define SPAN_ROW_SIZE(map, ld, index_) MR_LdSpanPtrGet(ld, index_, map)->spanRowSize 1348e727371SKashyap D Desai #define SPAN_ROW_DATA_SIZE(map_, ld, index_) \ 1358e727371SKashyap D Desai MR_LdSpanPtrGet(ld, index_, map)->spanRowDataSize 136665484d8SDoug Ambrisko #define SPAN_INVALID 0xff 137665484d8SDoug Ambrisko #define SPAN_DEBUG 0 138665484d8SDoug Ambrisko 139665484d8SDoug Ambrisko /* 140665484d8SDoug Ambrisko * Related Defines 141665484d8SDoug Ambrisko */ 142665484d8SDoug Ambrisko 143665484d8SDoug Ambrisko typedef u_int64_t REGION_KEY; 144665484d8SDoug Ambrisko typedef u_int32_t REGION_LEN; 145665484d8SDoug Ambrisko 146665484d8SDoug Ambrisko #define MR_LD_STATE_OPTIMAL 3 147665484d8SDoug Ambrisko #define FALSE 0 148665484d8SDoug Ambrisko #define TRUE 1 149665484d8SDoug Ambrisko 15016dc2814SKashyap D Desai #define LB_PENDING_CMDS_DEFAULT 4 15116dc2814SKashyap D Desai 152665484d8SDoug Ambrisko 153665484d8SDoug Ambrisko /* 154665484d8SDoug Ambrisko * Related Macros 155665484d8SDoug Ambrisko */ 156665484d8SDoug Ambrisko 157665484d8SDoug Ambrisko #define ABS_DIFF(a,b) ( ((a) > (b)) ? ((a) - (b)) : ((b) - (a)) ) 158665484d8SDoug Ambrisko 159665484d8SDoug Ambrisko #define swap32(x) \ 160665484d8SDoug Ambrisko ((unsigned int)( \ 161665484d8SDoug Ambrisko (((unsigned int)(x) & (unsigned int)0x000000ffUL) << 24) | \ 162665484d8SDoug Ambrisko (((unsigned int)(x) & (unsigned int)0x0000ff00UL) << 8) | \ 163665484d8SDoug Ambrisko (((unsigned int)(x) & (unsigned int)0x00ff0000UL) >> 8) | \ 164665484d8SDoug Ambrisko (((unsigned int)(x) & (unsigned int)0xff000000UL) >> 24) )) 165665484d8SDoug Ambrisko 166665484d8SDoug Ambrisko 167665484d8SDoug Ambrisko /* 1688e727371SKashyap D Desai * In-line functions for mod and divide of 64-bit dividend and 32-bit 1698e727371SKashyap D Desai * divisor. Assumes a check for a divisor of zero is not possible. 170665484d8SDoug Ambrisko * 171665484d8SDoug Ambrisko * @param dividend: Dividend 172665484d8SDoug Ambrisko * @param divisor: Divisor 173665484d8SDoug Ambrisko * @return remainder 174665484d8SDoug Ambrisko */ 175665484d8SDoug Ambrisko 176665484d8SDoug Ambrisko #define mega_mod64(dividend, divisor) ({ \ 177665484d8SDoug Ambrisko int remainder; \ 178665484d8SDoug Ambrisko remainder = ((u_int64_t) (dividend)) % (u_int32_t) (divisor); \ 179665484d8SDoug Ambrisko remainder;}) 180665484d8SDoug Ambrisko 181665484d8SDoug Ambrisko #define mega_div64_32(dividend, divisor) ({ \ 182665484d8SDoug Ambrisko int quotient; \ 183665484d8SDoug Ambrisko quotient = ((u_int64_t) (dividend)) / (u_int32_t) (divisor); \ 184665484d8SDoug Ambrisko quotient;}) 185665484d8SDoug Ambrisko 186665484d8SDoug Ambrisko 187665484d8SDoug Ambrisko /* 188665484d8SDoug Ambrisko * Various RAID map access functions. These functions access the various 189665484d8SDoug Ambrisko * parts of the RAID map and returns the appropriate parameters. 190665484d8SDoug Ambrisko */ 191665484d8SDoug Ambrisko 1928e727371SKashyap D Desai MR_LD_RAID * 1938e727371SKashyap D Desai MR_LdRaidGet(u_int32_t ld, MR_DRV_RAID_MAP_ALL * map) 194665484d8SDoug Ambrisko { 195665484d8SDoug Ambrisko return (&map->raidMap.ldSpanMap[ld].ldRaid); 196665484d8SDoug Ambrisko } 197665484d8SDoug Ambrisko 1988e727371SKashyap D Desai u_int16_t 1998e727371SKashyap D Desai MR_GetLDTgtId(u_int32_t ld, MR_DRV_RAID_MAP_ALL * map) 200665484d8SDoug Ambrisko { 201665484d8SDoug Ambrisko return (map->raidMap.ldSpanMap[ld].ldRaid.targetId); 202665484d8SDoug Ambrisko } 203665484d8SDoug Ambrisko 2048e727371SKashyap D Desai static u_int16_t 2058e727371SKashyap D Desai MR_LdSpanArrayGet(u_int32_t ld, u_int32_t span, MR_DRV_RAID_MAP_ALL * map) 206665484d8SDoug Ambrisko { 207665484d8SDoug Ambrisko return map->raidMap.ldSpanMap[ld].spanBlock[span].span.arrayRef; 208665484d8SDoug Ambrisko } 209665484d8SDoug Ambrisko 2108e727371SKashyap D Desai static u_int8_t 2118e727371SKashyap D Desai MR_LdDataArmGet(u_int32_t ld, u_int32_t armIdx, MR_DRV_RAID_MAP_ALL * map) 212665484d8SDoug Ambrisko { 213665484d8SDoug Ambrisko return map->raidMap.ldSpanMap[ld].dataArmMap[armIdx]; 214665484d8SDoug Ambrisko } 215665484d8SDoug Ambrisko 2168e727371SKashyap D Desai static u_int16_t 2178e727371SKashyap D Desai MR_PdDevHandleGet(u_int32_t pd, MR_DRV_RAID_MAP_ALL * map) 218665484d8SDoug Ambrisko { 219665484d8SDoug Ambrisko return map->raidMap.devHndlInfo[pd].curDevHdl; 220665484d8SDoug Ambrisko } 221665484d8SDoug Ambrisko 2228e727371SKashyap D Desai static u_int16_t 2238e727371SKashyap D Desai MR_ArPdGet(u_int32_t ar, u_int32_t arm, MR_DRV_RAID_MAP_ALL * map) 224665484d8SDoug Ambrisko { 225665484d8SDoug Ambrisko return map->raidMap.arMapInfo[ar].pd[arm]; 226665484d8SDoug Ambrisko } 227665484d8SDoug Ambrisko 2288e727371SKashyap D Desai static MR_LD_SPAN * 2298e727371SKashyap D Desai MR_LdSpanPtrGet(u_int32_t ld, u_int32_t span, MR_DRV_RAID_MAP_ALL * map) 230665484d8SDoug Ambrisko { 231665484d8SDoug Ambrisko return &map->raidMap.ldSpanMap[ld].spanBlock[span].span; 232665484d8SDoug Ambrisko } 233665484d8SDoug Ambrisko 2348e727371SKashyap D Desai static MR_SPAN_BLOCK_INFO * 2358e727371SKashyap D Desai MR_LdSpanInfoGet(u_int32_t ld, MR_DRV_RAID_MAP_ALL * map) 236665484d8SDoug Ambrisko { 237665484d8SDoug Ambrisko return &map->raidMap.ldSpanMap[ld].spanBlock[0]; 238665484d8SDoug Ambrisko } 239665484d8SDoug Ambrisko 2404ad83576SKashyap D Desai u_int8_t 2418e727371SKashyap D Desai MR_TargetIdToLdGet(u_int32_t ldTgtId, MR_DRV_RAID_MAP_ALL * map) 242665484d8SDoug Ambrisko { 243665484d8SDoug Ambrisko return map->raidMap.ldTgtIdToLd[ldTgtId]; 244665484d8SDoug Ambrisko } 245665484d8SDoug Ambrisko 2468e727371SKashyap D Desai u_int32_t 2478e727371SKashyap D Desai MR_LdBlockSizeGet(u_int32_t ldTgtId, MR_DRV_RAID_MAP_ALL * map) 248665484d8SDoug Ambrisko { 249665484d8SDoug Ambrisko MR_LD_RAID *raid; 250665484d8SDoug Ambrisko u_int32_t ld, ldBlockSize = MRSAS_SCSIBLOCKSIZE; 251665484d8SDoug Ambrisko 252665484d8SDoug Ambrisko ld = MR_TargetIdToLdGet(ldTgtId, map); 253665484d8SDoug Ambrisko 254665484d8SDoug Ambrisko /* 255665484d8SDoug Ambrisko * Check if logical drive was removed. 256665484d8SDoug Ambrisko */ 257665484d8SDoug Ambrisko if (ld >= MAX_LOGICAL_DRIVES) 258665484d8SDoug Ambrisko return ldBlockSize; 259665484d8SDoug Ambrisko 260665484d8SDoug Ambrisko raid = MR_LdRaidGet(ld, map); 261665484d8SDoug Ambrisko ldBlockSize = raid->logicalBlockLength; 262665484d8SDoug Ambrisko if (!ldBlockSize) 263665484d8SDoug Ambrisko ldBlockSize = MRSAS_SCSIBLOCKSIZE; 264665484d8SDoug Ambrisko 265665484d8SDoug Ambrisko return ldBlockSize; 266665484d8SDoug Ambrisko } 267665484d8SDoug Ambrisko 2684799d485SKashyap D Desai /* 2694ad83576SKashyap D Desai * This function will Populate Driver Map using Dynamic firmware raid map 2704ad83576SKashyap D Desai */ 2714ad83576SKashyap D Desai static int 2724ad83576SKashyap D Desai MR_PopulateDrvRaidMapVentura(struct mrsas_softc *sc) 2734ad83576SKashyap D Desai { 2744ad83576SKashyap D Desai unsigned int i, j; 2754ad83576SKashyap D Desai u_int16_t ld_count; 2764ad83576SKashyap D Desai 2774ad83576SKashyap D Desai MR_FW_RAID_MAP_DYNAMIC *fw_map_dyn; 2784ad83576SKashyap D Desai MR_RAID_MAP_DESC_TABLE *desc_table; 2794ad83576SKashyap D Desai MR_DRV_RAID_MAP_ALL *drv_map = sc->ld_drv_map[(sc->map_id & 1)]; 2804ad83576SKashyap D Desai MR_DRV_RAID_MAP *pDrvRaidMap = &drv_map->raidMap; 2814ad83576SKashyap D Desai void *raid_map_data = NULL; 2824ad83576SKashyap D Desai 2834ad83576SKashyap D Desai fw_map_dyn = (MR_FW_RAID_MAP_DYNAMIC *) sc->raidmap_mem[(sc->map_id & 1)]; 2844ad83576SKashyap D Desai 2854ad83576SKashyap D Desai if (fw_map_dyn == NULL) { 2864ad83576SKashyap D Desai device_printf(sc->mrsas_dev, 2874ad83576SKashyap D Desai "from %s %d map0 %p map1 %p map size %d \n", __func__, __LINE__, 2884ad83576SKashyap D Desai sc->raidmap_mem[0], sc->raidmap_mem[1], sc->maxRaidMapSize); 2894ad83576SKashyap D Desai return 1; 2904ad83576SKashyap D Desai } 2914ad83576SKashyap D Desai #if VD_EXT_DEBUG 2924ad83576SKashyap D Desai device_printf(sc->mrsas_dev, 2934ad83576SKashyap D Desai " raidMapSize 0x%x, descTableOffset 0x%x, " 2944ad83576SKashyap D Desai " descTableSize 0x%x, descTableNumElements 0x%x \n", 2954ad83576SKashyap D Desai fw_map_dyn->raidMapSize, fw_map_dyn->descTableOffset, 2964ad83576SKashyap D Desai fw_map_dyn->descTableSize, fw_map_dyn->descTableNumElements); 2974ad83576SKashyap D Desai #endif 2984ad83576SKashyap D Desai desc_table = (MR_RAID_MAP_DESC_TABLE *) ((char *)fw_map_dyn + 2994ad83576SKashyap D Desai fw_map_dyn->descTableOffset); 3004ad83576SKashyap D Desai if (desc_table != fw_map_dyn->raidMapDescTable) { 3014ad83576SKashyap D Desai device_printf(sc->mrsas_dev, 3024ad83576SKashyap D Desai "offsets of desc table are not matching returning " 3034ad83576SKashyap D Desai " FW raid map has been changed: desc %p original %p\n", 3044ad83576SKashyap D Desai desc_table, fw_map_dyn->raidMapDescTable); 3054ad83576SKashyap D Desai } 3064ad83576SKashyap D Desai memset(drv_map, 0, sc->drv_map_sz); 3074ad83576SKashyap D Desai ld_count = fw_map_dyn->ldCount; 3084ad83576SKashyap D Desai pDrvRaidMap->ldCount = ld_count; 3094ad83576SKashyap D Desai pDrvRaidMap->fpPdIoTimeoutSec = fw_map_dyn->fpPdIoTimeoutSec; 3104ad83576SKashyap D Desai pDrvRaidMap->totalSize = sizeof(MR_DRV_RAID_MAP_ALL); 3114ad83576SKashyap D Desai /* point to actual data starting point */ 3124ad83576SKashyap D Desai raid_map_data = (char *)fw_map_dyn + 3134ad83576SKashyap D Desai fw_map_dyn->descTableOffset + fw_map_dyn->descTableSize; 3144ad83576SKashyap D Desai 3154ad83576SKashyap D Desai for (i = 0; i < fw_map_dyn->descTableNumElements; ++i) { 3164ad83576SKashyap D Desai if (!desc_table) { 3174ad83576SKashyap D Desai device_printf(sc->mrsas_dev, 3184ad83576SKashyap D Desai "desc table is null, coming out %p \n", desc_table); 3194ad83576SKashyap D Desai return 1; 3204ad83576SKashyap D Desai } 3214ad83576SKashyap D Desai #if VD_EXT_DEBUG 3224ad83576SKashyap D Desai device_printf(sc->mrsas_dev, "raid_map_data %p \n", raid_map_data); 3234ad83576SKashyap D Desai device_printf(sc->mrsas_dev, 3244ad83576SKashyap D Desai "desc table %p \n", desc_table); 3254ad83576SKashyap D Desai device_printf(sc->mrsas_dev, 3264ad83576SKashyap D Desai "raidmap type %d, raidmapOffset 0x%x, " 3274ad83576SKashyap D Desai " raid map number of elements 0%x, raidmapsize 0x%x\n", 3284ad83576SKashyap D Desai desc_table->raidMapDescType, desc_table->raidMapDescOffset, 3294ad83576SKashyap D Desai desc_table->raidMapDescElements, desc_table->raidMapDescBufferSize); 3304ad83576SKashyap D Desai #endif 3314ad83576SKashyap D Desai switch (desc_table->raidMapDescType) { 3324ad83576SKashyap D Desai case RAID_MAP_DESC_TYPE_DEVHDL_INFO: 3334ad83576SKashyap D Desai fw_map_dyn->RaidMapDescPtrs.ptrStruct.devHndlInfo = (MR_DEV_HANDLE_INFO *) 3344ad83576SKashyap D Desai ((char *)raid_map_data + desc_table->raidMapDescOffset); 3354ad83576SKashyap D Desai #if VD_EXT_DEBUG 3364ad83576SKashyap D Desai device_printf(sc->mrsas_dev, 3374ad83576SKashyap D Desai "devHndlInfo address %p\n", fw_map_dyn->RaidMapDescPtrs.ptrStruct.devHndlInfo); 3384ad83576SKashyap D Desai #endif 3394ad83576SKashyap D Desai memcpy(pDrvRaidMap->devHndlInfo, fw_map_dyn->RaidMapDescPtrs.ptrStruct.devHndlInfo, 3404ad83576SKashyap D Desai sizeof(MR_DEV_HANDLE_INFO) * desc_table->raidMapDescElements); 3414ad83576SKashyap D Desai break; 3424ad83576SKashyap D Desai case RAID_MAP_DESC_TYPE_TGTID_INFO: 3434ad83576SKashyap D Desai fw_map_dyn->RaidMapDescPtrs.ptrStruct.ldTgtIdToLd = (u_int16_t *) 3444ad83576SKashyap D Desai ((char *)raid_map_data + desc_table->raidMapDescOffset); 3454ad83576SKashyap D Desai #if VD_EXT_DEBUG 3464ad83576SKashyap D Desai device_printf(sc->mrsas_dev, 3474ad83576SKashyap D Desai "ldTgtIdToLd address %p\n", fw_map_dyn->RaidMapDescPtrs.ptrStruct.ldTgtIdToLd); 3484ad83576SKashyap D Desai #endif 3494ad83576SKashyap D Desai for (j = 0; j < desc_table->raidMapDescElements; j++) { 3504ad83576SKashyap D Desai pDrvRaidMap->ldTgtIdToLd[j] = fw_map_dyn->RaidMapDescPtrs.ptrStruct.ldTgtIdToLd[j]; 3514ad83576SKashyap D Desai #if VD_EXT_DEBUG 3524ad83576SKashyap D Desai device_printf(sc->mrsas_dev, 3534ad83576SKashyap D Desai " %d drv ldTgtIdToLd %d\n", j, pDrvRaidMap->ldTgtIdToLd[j]); 3544ad83576SKashyap D Desai #endif 3554ad83576SKashyap D Desai } 3564ad83576SKashyap D Desai break; 3574ad83576SKashyap D Desai case RAID_MAP_DESC_TYPE_ARRAY_INFO: 3584ad83576SKashyap D Desai fw_map_dyn->RaidMapDescPtrs.ptrStruct.arMapInfo = (MR_ARRAY_INFO *) ((char *)raid_map_data + 3594ad83576SKashyap D Desai desc_table->raidMapDescOffset); 3604ad83576SKashyap D Desai #if VD_EXT_DEBUG 3614ad83576SKashyap D Desai device_printf(sc->mrsas_dev, 3624ad83576SKashyap D Desai "arMapInfo address %p\n", fw_map_dyn->RaidMapDescPtrs.ptrStruct.arMapInfo); 3634ad83576SKashyap D Desai #endif 3644ad83576SKashyap D Desai memcpy(pDrvRaidMap->arMapInfo, fw_map_dyn->RaidMapDescPtrs.ptrStruct.arMapInfo, 3654ad83576SKashyap D Desai sizeof(MR_ARRAY_INFO) * desc_table->raidMapDescElements); 3664ad83576SKashyap D Desai break; 3674ad83576SKashyap D Desai case RAID_MAP_DESC_TYPE_SPAN_INFO: 3684ad83576SKashyap D Desai fw_map_dyn->RaidMapDescPtrs.ptrStruct.ldSpanMap = (MR_LD_SPAN_MAP *) ((char *)raid_map_data + 3694ad83576SKashyap D Desai desc_table->raidMapDescOffset); 3704ad83576SKashyap D Desai memcpy(pDrvRaidMap->ldSpanMap, fw_map_dyn->RaidMapDescPtrs.ptrStruct.ldSpanMap, 3714ad83576SKashyap D Desai sizeof(MR_LD_SPAN_MAP) * desc_table->raidMapDescElements); 3724ad83576SKashyap D Desai #if VD_EXT_DEBUG 3734ad83576SKashyap D Desai device_printf(sc->mrsas_dev, 3744ad83576SKashyap D Desai "ldSpanMap address %p\n", fw_map_dyn->RaidMapDescPtrs.ptrStruct.ldSpanMap); 3754ad83576SKashyap D Desai device_printf(sc->mrsas_dev, 3764ad83576SKashyap D Desai "MR_LD_SPAN_MAP size 0x%lx\n", sizeof(MR_LD_SPAN_MAP)); 3774ad83576SKashyap D Desai for (j = 0; j < ld_count; j++) { 3784ad83576SKashyap D Desai printf("mrsas(%d) : fw_map_dyn->ldSpanMap[%d].ldRaid.targetId 0x%x " 3794ad83576SKashyap D Desai "fw_map_dyn->ldSpanMap[%d].ldRaid.seqNum 0x%x size 0x%x\n", 3804ad83576SKashyap D Desai j, j, fw_map_dyn->RaidMapDescPtrs.ptrStruct.ldSpanMap[j].ldRaid.targetId, j, 3814ad83576SKashyap D Desai fw_map_dyn->RaidMapDescPtrs.ptrStruct.ldSpanMap[j].ldRaid.seqNum, 3824ad83576SKashyap D Desai (u_int32_t)fw_map_dyn->RaidMapDescPtrs.ptrStruct.ldSpanMap[j].ldRaid.rowSize); 3834ad83576SKashyap D Desai printf("mrsas(%d) : pDrvRaidMap->ldSpanMap[%d].ldRaid.targetId 0x%x " 3844ad83576SKashyap D Desai "pDrvRaidMap->ldSpanMap[%d].ldRaid.seqNum 0x%x size 0x%x\n", 3854ad83576SKashyap D Desai j, j, pDrvRaidMap->ldSpanMap[j].ldRaid.targetId, j, 3864ad83576SKashyap D Desai pDrvRaidMap->ldSpanMap[j].ldRaid.seqNum, 3874ad83576SKashyap D Desai (u_int32_t)pDrvRaidMap->ldSpanMap[j].ldRaid.rowSize); 3884ad83576SKashyap D Desai printf("mrsas : drv raid map all %p raid map %p LD RAID MAP %p/%p\n", 3894ad83576SKashyap D Desai drv_map, pDrvRaidMap, &fw_map_dyn->RaidMapDescPtrs.ptrStruct.ldSpanMap[j].ldRaid, 3904ad83576SKashyap D Desai &pDrvRaidMap->ldSpanMap[j].ldRaid); 3914ad83576SKashyap D Desai } 3924ad83576SKashyap D Desai #endif 3934ad83576SKashyap D Desai break; 3944ad83576SKashyap D Desai default: 3954ad83576SKashyap D Desai device_printf(sc->mrsas_dev, 3964ad83576SKashyap D Desai "wrong number of desctableElements %d\n", 3974ad83576SKashyap D Desai fw_map_dyn->descTableNumElements); 3984ad83576SKashyap D Desai } 3994ad83576SKashyap D Desai ++desc_table; 4004ad83576SKashyap D Desai } 4014ad83576SKashyap D Desai return 0; 4024ad83576SKashyap D Desai } 4034ad83576SKashyap D Desai 4044ad83576SKashyap D Desai /* 4054799d485SKashyap D Desai * This function will Populate Driver Map using firmware raid map 4064799d485SKashyap D Desai */ 4074ad83576SKashyap D Desai static int 4088e727371SKashyap D Desai MR_PopulateDrvRaidMap(struct mrsas_softc *sc) 4094799d485SKashyap D Desai { 4104799d485SKashyap D Desai MR_FW_RAID_MAP_ALL *fw_map_old = NULL; 4114ad83576SKashyap D Desai MR_FW_RAID_MAP_EXT *fw_map_ext; 4124799d485SKashyap D Desai MR_FW_RAID_MAP *pFwRaidMap = NULL; 4134799d485SKashyap D Desai unsigned int i; 4144ad83576SKashyap D Desai u_int16_t ld_count; 4154799d485SKashyap D Desai 4164799d485SKashyap D Desai MR_DRV_RAID_MAP_ALL *drv_map = sc->ld_drv_map[(sc->map_id & 1)]; 4174799d485SKashyap D Desai MR_DRV_RAID_MAP *pDrvRaidMap = &drv_map->raidMap; 4184799d485SKashyap D Desai 4194ad83576SKashyap D Desai if (sc->maxRaidMapSize) { 4204ad83576SKashyap D Desai return MR_PopulateDrvRaidMapVentura(sc); 4214ad83576SKashyap D Desai } else if (sc->max256vdSupport) { 4224ad83576SKashyap D Desai fw_map_ext = (MR_FW_RAID_MAP_EXT *) sc->raidmap_mem[(sc->map_id & 1)]; 4234ad83576SKashyap D Desai ld_count = (u_int16_t)(fw_map_ext->ldCount); 4244ad83576SKashyap D Desai if (ld_count > MAX_LOGICAL_DRIVES_EXT) { 4254ad83576SKashyap D Desai device_printf(sc->mrsas_dev, 4264ad83576SKashyap D Desai "mrsas: LD count exposed in RAID map in not valid\n"); 4274ad83576SKashyap D Desai return 1; 4284ad83576SKashyap D Desai } 4294ad83576SKashyap D Desai #if VD_EXT_DEBUG 4304ad83576SKashyap D Desai for (i = 0; i < ld_count; i++) { 4314ad83576SKashyap D Desai printf("mrsas : Index 0x%x Target Id 0x%x Seq Num 0x%x Size 0/%lx\n", 4324ad83576SKashyap D Desai i, fw_map_ext->ldSpanMap[i].ldRaid.targetId, 4334ad83576SKashyap D Desai fw_map_ext->ldSpanMap[i].ldRaid.seqNum, 4344ad83576SKashyap D Desai fw_map_ext->ldSpanMap[i].ldRaid.size); 4354ad83576SKashyap D Desai } 4364ad83576SKashyap D Desai #endif 4374ad83576SKashyap D Desai memset(drv_map, 0, sc->drv_map_sz); 4384ad83576SKashyap D Desai pDrvRaidMap->ldCount = ld_count; 4394ad83576SKashyap D Desai pDrvRaidMap->fpPdIoTimeoutSec = fw_map_ext->fpPdIoTimeoutSec; 4404ad83576SKashyap D Desai for (i = 0; i < (MAX_LOGICAL_DRIVES_EXT); i++) { 4414ad83576SKashyap D Desai pDrvRaidMap->ldTgtIdToLd[i] = (u_int16_t)fw_map_ext->ldTgtIdToLd[i]; 4424ad83576SKashyap D Desai } 4434ad83576SKashyap D Desai memcpy(pDrvRaidMap->ldSpanMap, fw_map_ext->ldSpanMap, sizeof(MR_LD_SPAN_MAP) * ld_count); 4444ad83576SKashyap D Desai #if VD_EXT_DEBUG 4454ad83576SKashyap D Desai for (i = 0; i < ld_count; i++) { 4464ad83576SKashyap D Desai printf("mrsas(%d) : fw_map_ext->ldSpanMap[%d].ldRaid.targetId 0x%x " 4474ad83576SKashyap D Desai "fw_map_ext->ldSpanMap[%d].ldRaid.seqNum 0x%x size 0x%x\n", 4484ad83576SKashyap D Desai i, i, fw_map_ext->ldSpanMap[i].ldRaid.targetId, i, 4494ad83576SKashyap D Desai fw_map_ext->ldSpanMap[i].ldRaid.seqNum, 4504ad83576SKashyap D Desai (u_int32_t)fw_map_ext->ldSpanMap[i].ldRaid.rowSize); 4514ad83576SKashyap D Desai printf("mrsas(%d) : pDrvRaidMap->ldSpanMap[%d].ldRaid.targetId 0x%x" 4524ad83576SKashyap D Desai "pDrvRaidMap->ldSpanMap[%d].ldRaid.seqNum 0x%x size 0x%x\n", i, i, 4534ad83576SKashyap D Desai pDrvRaidMap->ldSpanMap[i].ldRaid.targetId, i, 4544ad83576SKashyap D Desai pDrvRaidMap->ldSpanMap[i].ldRaid.seqNum, 4554ad83576SKashyap D Desai (u_int32_t)pDrvRaidMap->ldSpanMap[i].ldRaid.rowSize); 4564ad83576SKashyap D Desai printf("mrsas : drv raid map all %p raid map %p LD RAID MAP %p/%p\n", 4574ad83576SKashyap D Desai drv_map, pDrvRaidMap, &fw_map_ext->ldSpanMap[i].ldRaid, 4584ad83576SKashyap D Desai &pDrvRaidMap->ldSpanMap[i].ldRaid); 4594ad83576SKashyap D Desai } 4604ad83576SKashyap D Desai #endif 4614ad83576SKashyap D Desai memcpy(pDrvRaidMap->arMapInfo, fw_map_ext->arMapInfo, 4624ad83576SKashyap D Desai sizeof(MR_ARRAY_INFO) * MAX_API_ARRAYS_EXT); 4634ad83576SKashyap D Desai memcpy(pDrvRaidMap->devHndlInfo, fw_map_ext->devHndlInfo, 4644ad83576SKashyap D Desai sizeof(MR_DEV_HANDLE_INFO) * MAX_RAIDMAP_PHYSICAL_DEVICES); 4654ad83576SKashyap D Desai 4664799d485SKashyap D Desai pDrvRaidMap->totalSize = sizeof(MR_FW_RAID_MAP_EXT); 4674799d485SKashyap D Desai } else { 4684799d485SKashyap D Desai fw_map_old = (MR_FW_RAID_MAP_ALL *) sc->raidmap_mem[(sc->map_id & 1)]; 4694799d485SKashyap D Desai pFwRaidMap = &fw_map_old->raidMap; 4704799d485SKashyap D Desai 4714799d485SKashyap D Desai #if VD_EXT_DEBUG 4724799d485SKashyap D Desai for (i = 0; i < pFwRaidMap->ldCount; i++) { 4734799d485SKashyap D Desai device_printf(sc->mrsas_dev, 4744799d485SKashyap D Desai "Index 0x%x Target Id 0x%x Seq Num 0x%x Size 0/%lx\n", i, 4754799d485SKashyap D Desai fw_map_old->raidMap.ldSpanMap[i].ldRaid.targetId, 4764799d485SKashyap D Desai fw_map_old->raidMap.ldSpanMap[i].ldRaid.seqNum, 4774799d485SKashyap D Desai fw_map_old->raidMap.ldSpanMap[i].ldRaid.size); 4784799d485SKashyap D Desai } 4794799d485SKashyap D Desai #endif 4804799d485SKashyap D Desai 4814799d485SKashyap D Desai memset(drv_map, 0, sc->drv_map_sz); 4824799d485SKashyap D Desai pDrvRaidMap->totalSize = pFwRaidMap->totalSize; 4834799d485SKashyap D Desai pDrvRaidMap->ldCount = pFwRaidMap->ldCount; 4844799d485SKashyap D Desai pDrvRaidMap->fpPdIoTimeoutSec = 4854799d485SKashyap D Desai pFwRaidMap->fpPdIoTimeoutSec; 4864799d485SKashyap D Desai 4874799d485SKashyap D Desai for (i = 0; i < MAX_RAIDMAP_LOGICAL_DRIVES + MAX_RAIDMAP_VIEWS; i++) { 4884799d485SKashyap D Desai pDrvRaidMap->ldTgtIdToLd[i] = 4894799d485SKashyap D Desai (u_int8_t)pFwRaidMap->ldTgtIdToLd[i]; 4904799d485SKashyap D Desai } 4914799d485SKashyap D Desai 4924799d485SKashyap D Desai for (i = 0; i < pDrvRaidMap->ldCount; i++) { 4934799d485SKashyap D Desai pDrvRaidMap->ldSpanMap[i] = 4944799d485SKashyap D Desai pFwRaidMap->ldSpanMap[i]; 4954799d485SKashyap D Desai 4964799d485SKashyap D Desai #if VD_EXT_DEBUG 4974799d485SKashyap D Desai device_printf(sc->mrsas_dev, "pFwRaidMap->ldSpanMap[%d].ldRaid.targetId 0x%x " 4984799d485SKashyap D Desai "pFwRaidMap->ldSpanMap[%d].ldRaid.seqNum 0x%x size 0x%x\n", 4994799d485SKashyap D Desai i, i, pFwRaidMap->ldSpanMap[i].ldRaid.targetId, 5004799d485SKashyap D Desai pFwRaidMap->ldSpanMap[i].ldRaid.seqNum, 5014799d485SKashyap D Desai (u_int32_t)pFwRaidMap->ldSpanMap[i].ldRaid.rowSize); 5024799d485SKashyap D Desai device_printf(sc->mrsas_dev, "pDrvRaidMap->ldSpanMap[%d].ldRaid.targetId 0x%x" 5034799d485SKashyap D Desai "pDrvRaidMap->ldSpanMap[%d].ldRaid.seqNum 0x%x size 0x%x\n", i, i, 5044799d485SKashyap D Desai pDrvRaidMap->ldSpanMap[i].ldRaid.targetId, 5054799d485SKashyap D Desai pDrvRaidMap->ldSpanMap[i].ldRaid.seqNum, 5064799d485SKashyap D Desai (u_int32_t)pDrvRaidMap->ldSpanMap[i].ldRaid.rowSize); 5074799d485SKashyap D Desai device_printf(sc->mrsas_dev, "drv raid map all %p raid map %p LD RAID MAP %p/%p\n", 5084799d485SKashyap D Desai drv_map, pDrvRaidMap, 5094799d485SKashyap D Desai &pFwRaidMap->ldSpanMap[i].ldRaid, &pDrvRaidMap->ldSpanMap[i].ldRaid); 5104799d485SKashyap D Desai #endif 5114799d485SKashyap D Desai } 5124799d485SKashyap D Desai 5134799d485SKashyap D Desai memcpy(pDrvRaidMap->arMapInfo, pFwRaidMap->arMapInfo, 5144799d485SKashyap D Desai sizeof(MR_ARRAY_INFO) * MAX_RAIDMAP_ARRAYS); 5154799d485SKashyap D Desai memcpy(pDrvRaidMap->devHndlInfo, pFwRaidMap->devHndlInfo, 5164799d485SKashyap D Desai sizeof(MR_DEV_HANDLE_INFO) * 5174799d485SKashyap D Desai MAX_RAIDMAP_PHYSICAL_DEVICES); 5184799d485SKashyap D Desai } 5194ad83576SKashyap D Desai return 0; 5204799d485SKashyap D Desai } 5214799d485SKashyap D Desai 5228e727371SKashyap D Desai /* 523665484d8SDoug Ambrisko * MR_ValidateMapInfo: Validate RAID map 524665484d8SDoug Ambrisko * input: Adapter instance soft state 525665484d8SDoug Ambrisko * 526665484d8SDoug Ambrisko * This function checks and validates the loaded RAID map. It returns 0 if 527665484d8SDoug Ambrisko * successful, and 1 otherwise. 528665484d8SDoug Ambrisko */ 5298e727371SKashyap D Desai u_int8_t 5308e727371SKashyap D Desai MR_ValidateMapInfo(struct mrsas_softc *sc) 531665484d8SDoug Ambrisko { 532665484d8SDoug Ambrisko if (!sc) { 533665484d8SDoug Ambrisko return 1; 534665484d8SDoug Ambrisko } 5354ad83576SKashyap D Desai if (MR_PopulateDrvRaidMap(sc)) 5364ad83576SKashyap D Desai return 0; 5374799d485SKashyap D Desai 5384799d485SKashyap D Desai MR_DRV_RAID_MAP_ALL *drv_map = sc->ld_drv_map[(sc->map_id & 1)]; 5394799d485SKashyap D Desai MR_DRV_RAID_MAP *pDrvRaidMap = &drv_map->raidMap; 5404799d485SKashyap D Desai 5414799d485SKashyap D Desai u_int32_t expected_map_size; 5428e727371SKashyap D Desai 5434799d485SKashyap D Desai drv_map = sc->ld_drv_map[(sc->map_id & 1)]; 5444799d485SKashyap D Desai pDrvRaidMap = &drv_map->raidMap; 545665484d8SDoug Ambrisko PLD_SPAN_INFO ldSpanInfo = (PLD_SPAN_INFO) & sc->log_to_span; 546665484d8SDoug Ambrisko 5474ad83576SKashyap D Desai if (sc->maxRaidMapSize) 5484ad83576SKashyap D Desai expected_map_size = sizeof(MR_DRV_RAID_MAP_ALL); 5494ad83576SKashyap D Desai else if (sc->max256vdSupport) 5504799d485SKashyap D Desai expected_map_size = sizeof(MR_FW_RAID_MAP_EXT); 5514799d485SKashyap D Desai else 5524799d485SKashyap D Desai expected_map_size = 5534799d485SKashyap D Desai (sizeof(MR_FW_RAID_MAP) - sizeof(MR_LD_SPAN_MAP)) + 5544799d485SKashyap D Desai (sizeof(MR_LD_SPAN_MAP) * pDrvRaidMap->ldCount); 555665484d8SDoug Ambrisko 5564799d485SKashyap D Desai if (pDrvRaidMap->totalSize != expected_map_size) { 5574799d485SKashyap D Desai device_printf(sc->mrsas_dev, "map size %x not matching ld count\n", expected_map_size); 558665484d8SDoug Ambrisko device_printf(sc->mrsas_dev, "span map= %x\n", (unsigned int)sizeof(MR_LD_SPAN_MAP)); 5594799d485SKashyap D Desai device_printf(sc->mrsas_dev, "pDrvRaidMap->totalSize=%x\n", pDrvRaidMap->totalSize); 560665484d8SDoug Ambrisko return 1; 561665484d8SDoug Ambrisko } 562665484d8SDoug Ambrisko if (sc->UnevenSpanSupport) { 5634799d485SKashyap D Desai mr_update_span_set(drv_map, ldSpanInfo); 564665484d8SDoug Ambrisko } 56516dc2814SKashyap D Desai mrsas_update_load_balance_params(sc, drv_map, sc->load_balance_info); 566665484d8SDoug Ambrisko 567665484d8SDoug Ambrisko return 0; 568665484d8SDoug Ambrisko } 569665484d8SDoug Ambrisko 570665484d8SDoug Ambrisko /* 571665484d8SDoug Ambrisko * 572665484d8SDoug Ambrisko * Function to print info about span set created in driver from FW raid map 573665484d8SDoug Ambrisko * 5748e727371SKashyap D Desai * Inputs: map 5758e727371SKashyap D Desai * ldSpanInfo: ld map span info per HBA instance 576665484d8SDoug Ambrisko * 577665484d8SDoug Ambrisko * 5788e727371SKashyap D Desai */ 579665484d8SDoug Ambrisko #if SPAN_DEBUG 5808e727371SKashyap D Desai static int 5818e727371SKashyap D Desai getSpanInfo(MR_DRV_RAID_MAP_ALL * map, PLD_SPAN_INFO ldSpanInfo) 582665484d8SDoug Ambrisko { 583665484d8SDoug Ambrisko 584665484d8SDoug Ambrisko u_int8_t span; 585665484d8SDoug Ambrisko u_int32_t element; 586665484d8SDoug Ambrisko MR_LD_RAID *raid; 587665484d8SDoug Ambrisko LD_SPAN_SET *span_set; 588665484d8SDoug Ambrisko MR_QUAD_ELEMENT *quad; 589665484d8SDoug Ambrisko int ldCount; 590665484d8SDoug Ambrisko u_int16_t ld; 591665484d8SDoug Ambrisko 5928e727371SKashyap D Desai for (ldCount = 0; ldCount < MAX_LOGICAL_DRIVES; ldCount++) { 593665484d8SDoug Ambrisko ld = MR_TargetIdToLdGet(ldCount, map); 594665484d8SDoug Ambrisko if (ld >= MAX_LOGICAL_DRIVES) { 595665484d8SDoug Ambrisko continue; 596665484d8SDoug Ambrisko } 597665484d8SDoug Ambrisko raid = MR_LdRaidGet(ld, map); 598665484d8SDoug Ambrisko printf("LD %x: span_depth=%x\n", ld, raid->spanDepth); 599665484d8SDoug Ambrisko for (span = 0; span < raid->spanDepth; span++) 600665484d8SDoug Ambrisko printf("Span=%x, number of quads=%x\n", span, 601665484d8SDoug Ambrisko map->raidMap.ldSpanMap[ld].spanBlock[span]. 602665484d8SDoug Ambrisko block_span_info.noElements); 603665484d8SDoug Ambrisko for (element = 0; element < MAX_QUAD_DEPTH; element++) { 604665484d8SDoug Ambrisko span_set = &(ldSpanInfo[ld].span_set[element]); 6058e727371SKashyap D Desai if (span_set->span_row_data_width == 0) 6068e727371SKashyap D Desai break; 607665484d8SDoug Ambrisko 608665484d8SDoug Ambrisko printf("Span Set %x: width=%x, diff=%x\n", element, 609665484d8SDoug Ambrisko (unsigned int)span_set->span_row_data_width, 610665484d8SDoug Ambrisko (unsigned int)span_set->diff); 611665484d8SDoug Ambrisko printf("logical LBA start=0x%08lx, end=0x%08lx\n", 612665484d8SDoug Ambrisko (long unsigned int)span_set->log_start_lba, 613665484d8SDoug Ambrisko (long unsigned int)span_set->log_end_lba); 614665484d8SDoug Ambrisko printf("span row start=0x%08lx, end=0x%08lx\n", 615665484d8SDoug Ambrisko (long unsigned int)span_set->span_row_start, 616665484d8SDoug Ambrisko (long unsigned int)span_set->span_row_end); 617665484d8SDoug Ambrisko printf("data row start=0x%08lx, end=0x%08lx\n", 618665484d8SDoug Ambrisko (long unsigned int)span_set->data_row_start, 619665484d8SDoug Ambrisko (long unsigned int)span_set->data_row_end); 620665484d8SDoug Ambrisko printf("data strip start=0x%08lx, end=0x%08lx\n", 621665484d8SDoug Ambrisko (long unsigned int)span_set->data_strip_start, 622665484d8SDoug Ambrisko (long unsigned int)span_set->data_strip_end); 623665484d8SDoug Ambrisko 624665484d8SDoug Ambrisko for (span = 0; span < raid->spanDepth; span++) { 625665484d8SDoug Ambrisko if (map->raidMap.ldSpanMap[ld].spanBlock[span]. 626665484d8SDoug Ambrisko block_span_info.noElements >= element + 1) { 627665484d8SDoug Ambrisko quad = &map->raidMap.ldSpanMap[ld]. 628665484d8SDoug Ambrisko spanBlock[span].block_span_info. 629665484d8SDoug Ambrisko quad[element]; 630665484d8SDoug Ambrisko printf("Span=%x, Quad=%x, diff=%x\n", span, 631665484d8SDoug Ambrisko element, quad->diff); 632665484d8SDoug Ambrisko printf("offset_in_span=0x%08lx\n", 633665484d8SDoug Ambrisko (long unsigned int)quad->offsetInSpan); 634665484d8SDoug Ambrisko printf("logical start=0x%08lx, end=0x%08lx\n", 635665484d8SDoug Ambrisko (long unsigned int)quad->logStart, 636665484d8SDoug Ambrisko (long unsigned int)quad->logEnd); 637665484d8SDoug Ambrisko } 638665484d8SDoug Ambrisko } 639665484d8SDoug Ambrisko } 640665484d8SDoug Ambrisko } 641665484d8SDoug Ambrisko return 0; 642665484d8SDoug Ambrisko } 6438e727371SKashyap D Desai 644665484d8SDoug Ambrisko #endif 645665484d8SDoug Ambrisko /* 646665484d8SDoug Ambrisko * 647665484d8SDoug Ambrisko * This routine calculates the Span block for given row using spanset. 648665484d8SDoug Ambrisko * 6498e727371SKashyap D Desai * Inputs : HBA instance 6508e727371SKashyap D Desai * ld: Logical drive number 6518e727371SKashyap D Desai * row: Row number 6528e727371SKashyap D Desai * map: LD map 653665484d8SDoug Ambrisko * 6548e727371SKashyap D Desai * Outputs : span - Span number block 6558e727371SKashyap D Desai * - Absolute Block number in the physical disk 656665484d8SDoug Ambrisko * div_error - Devide error code. 657665484d8SDoug Ambrisko */ 658665484d8SDoug Ambrisko 6598e727371SKashyap D Desai u_int32_t 6608e727371SKashyap D Desai mr_spanset_get_span_block(struct mrsas_softc *sc, u_int32_t ld, u_int64_t row, 6614799d485SKashyap D Desai u_int64_t *span_blk, MR_DRV_RAID_MAP_ALL * map, int *div_error) 662665484d8SDoug Ambrisko { 663665484d8SDoug Ambrisko MR_LD_RAID *raid = MR_LdRaidGet(ld, map); 664665484d8SDoug Ambrisko LD_SPAN_SET *span_set; 665665484d8SDoug Ambrisko MR_QUAD_ELEMENT *quad; 666665484d8SDoug Ambrisko u_int32_t span, info; 667665484d8SDoug Ambrisko PLD_SPAN_INFO ldSpanInfo = sc->log_to_span; 668665484d8SDoug Ambrisko 669665484d8SDoug Ambrisko for (info = 0; info < MAX_QUAD_DEPTH; info++) { 670665484d8SDoug Ambrisko span_set = &(ldSpanInfo[ld].span_set[info]); 671665484d8SDoug Ambrisko 6728e727371SKashyap D Desai if (span_set->span_row_data_width == 0) 6738e727371SKashyap D Desai break; 6748e727371SKashyap D Desai if (row > span_set->data_row_end) 6758e727371SKashyap D Desai continue; 676665484d8SDoug Ambrisko 677665484d8SDoug Ambrisko for (span = 0; span < raid->spanDepth; span++) 678665484d8SDoug Ambrisko if (map->raidMap.ldSpanMap[ld].spanBlock[span]. 679665484d8SDoug Ambrisko block_span_info.noElements >= info + 1) { 680665484d8SDoug Ambrisko quad = &map->raidMap.ldSpanMap[ld]. 681665484d8SDoug Ambrisko spanBlock[span]. 682665484d8SDoug Ambrisko block_span_info.quad[info]; 683665484d8SDoug Ambrisko if (quad->diff == 0) { 684665484d8SDoug Ambrisko *div_error = 1; 685665484d8SDoug Ambrisko return span; 686665484d8SDoug Ambrisko } 687665484d8SDoug Ambrisko if (quad->logStart <= row && 688665484d8SDoug Ambrisko row <= quad->logEnd && 689665484d8SDoug Ambrisko (mega_mod64(row - quad->logStart, 690665484d8SDoug Ambrisko quad->diff)) == 0) { 691665484d8SDoug Ambrisko if (span_blk != NULL) { 692665484d8SDoug Ambrisko u_int64_t blk; 6938e727371SKashyap D Desai 694665484d8SDoug Ambrisko blk = mega_div64_32 695665484d8SDoug Ambrisko ((row - quad->logStart), 696665484d8SDoug Ambrisko quad->diff); 697665484d8SDoug Ambrisko blk = (blk + quad->offsetInSpan) 698665484d8SDoug Ambrisko << raid->stripeShift; 699665484d8SDoug Ambrisko *span_blk = blk; 700665484d8SDoug Ambrisko } 701665484d8SDoug Ambrisko return span; 702665484d8SDoug Ambrisko } 703665484d8SDoug Ambrisko } 704665484d8SDoug Ambrisko } 705665484d8SDoug Ambrisko return SPAN_INVALID; 706665484d8SDoug Ambrisko } 707665484d8SDoug Ambrisko 708665484d8SDoug Ambrisko /* 709665484d8SDoug Ambrisko * 710665484d8SDoug Ambrisko * This routine calculates the row for given strip using spanset. 711665484d8SDoug Ambrisko * 7128e727371SKashyap D Desai * Inputs : HBA instance 7138e727371SKashyap D Desai * ld: Logical drive number 7148e727371SKashyap D Desai * Strip: Strip 7158e727371SKashyap D Desai * map: LD map 716665484d8SDoug Ambrisko * 7178e727371SKashyap D Desai * Outputs : row - row associated with strip 718665484d8SDoug Ambrisko */ 719665484d8SDoug Ambrisko 7208e727371SKashyap D Desai static u_int64_t 7218e727371SKashyap D Desai get_row_from_strip(struct mrsas_softc *sc, 7224799d485SKashyap D Desai u_int32_t ld, u_int64_t strip, MR_DRV_RAID_MAP_ALL * map) 723665484d8SDoug Ambrisko { 724665484d8SDoug Ambrisko MR_LD_RAID *raid = MR_LdRaidGet(ld, map); 725665484d8SDoug Ambrisko LD_SPAN_SET *span_set; 726665484d8SDoug Ambrisko PLD_SPAN_INFO ldSpanInfo = sc->log_to_span; 727665484d8SDoug Ambrisko u_int32_t info, strip_offset, span, span_offset; 728665484d8SDoug Ambrisko u_int64_t span_set_Strip, span_set_Row; 729665484d8SDoug Ambrisko 730665484d8SDoug Ambrisko for (info = 0; info < MAX_QUAD_DEPTH; info++) { 731665484d8SDoug Ambrisko span_set = &(ldSpanInfo[ld].span_set[info]); 732665484d8SDoug Ambrisko 7338e727371SKashyap D Desai if (span_set->span_row_data_width == 0) 7348e727371SKashyap D Desai break; 7358e727371SKashyap D Desai if (strip > span_set->data_strip_end) 7368e727371SKashyap D Desai continue; 737665484d8SDoug Ambrisko 738665484d8SDoug Ambrisko span_set_Strip = strip - span_set->data_strip_start; 739665484d8SDoug Ambrisko strip_offset = mega_mod64(span_set_Strip, 740665484d8SDoug Ambrisko span_set->span_row_data_width); 741665484d8SDoug Ambrisko span_set_Row = mega_div64_32(span_set_Strip, 742665484d8SDoug Ambrisko span_set->span_row_data_width) * span_set->diff; 743665484d8SDoug Ambrisko for (span = 0, span_offset = 0; span < raid->spanDepth; span++) 744665484d8SDoug Ambrisko if (map->raidMap.ldSpanMap[ld].spanBlock[span]. 745665484d8SDoug Ambrisko block_span_info.noElements >= info + 1) { 746665484d8SDoug Ambrisko if (strip_offset >= 747665484d8SDoug Ambrisko span_set->strip_offset[span]) 748665484d8SDoug Ambrisko span_offset++; 749665484d8SDoug Ambrisko else 750665484d8SDoug Ambrisko break; 751665484d8SDoug Ambrisko } 752ecea5be4SKashyap D Desai mrsas_dprint(sc, MRSAS_PRL11, "AVAGO Debug : Strip 0x%llx, span_set_Strip 0x%llx, span_set_Row 0x%llx " 753665484d8SDoug Ambrisko "data width 0x%llx span offset 0x%llx\n", (unsigned long long)strip, 754665484d8SDoug Ambrisko (unsigned long long)span_set_Strip, 755665484d8SDoug Ambrisko (unsigned long long)span_set_Row, 756665484d8SDoug Ambrisko (unsigned long long)span_set->span_row_data_width, (unsigned long long)span_offset); 757ecea5be4SKashyap D Desai mrsas_dprint(sc, MRSAS_PRL11, "AVAGO Debug : For strip 0x%llx row is 0x%llx\n", (unsigned long long)strip, 758665484d8SDoug Ambrisko (unsigned long long)span_set->data_row_start + 759665484d8SDoug Ambrisko (unsigned long long)span_set_Row + (span_offset - 1)); 760665484d8SDoug Ambrisko return (span_set->data_row_start + span_set_Row + (span_offset - 1)); 761665484d8SDoug Ambrisko } 762665484d8SDoug Ambrisko return -1LLU; 763665484d8SDoug Ambrisko } 764665484d8SDoug Ambrisko 765665484d8SDoug Ambrisko 766665484d8SDoug Ambrisko /* 767665484d8SDoug Ambrisko * 768665484d8SDoug Ambrisko * This routine calculates the Start Strip for given row using spanset. 769665484d8SDoug Ambrisko * 7708e727371SKashyap D Desai * Inputs: HBA instance 7718e727371SKashyap D Desai * ld: Logical drive number 7728e727371SKashyap D Desai * row: Row number 7738e727371SKashyap D Desai * map: LD map 774665484d8SDoug Ambrisko * 7758e727371SKashyap D Desai * Outputs : Strip - Start strip associated with row 776665484d8SDoug Ambrisko */ 777665484d8SDoug Ambrisko 7788e727371SKashyap D Desai static u_int64_t 7798e727371SKashyap D Desai get_strip_from_row(struct mrsas_softc *sc, 7804799d485SKashyap D Desai u_int32_t ld, u_int64_t row, MR_DRV_RAID_MAP_ALL * map) 781665484d8SDoug Ambrisko { 782665484d8SDoug Ambrisko MR_LD_RAID *raid = MR_LdRaidGet(ld, map); 783665484d8SDoug Ambrisko LD_SPAN_SET *span_set; 784665484d8SDoug Ambrisko MR_QUAD_ELEMENT *quad; 785665484d8SDoug Ambrisko PLD_SPAN_INFO ldSpanInfo = sc->log_to_span; 786665484d8SDoug Ambrisko u_int32_t span, info; 787665484d8SDoug Ambrisko u_int64_t strip; 788665484d8SDoug Ambrisko 789665484d8SDoug Ambrisko for (info = 0; info < MAX_QUAD_DEPTH; info++) { 790665484d8SDoug Ambrisko span_set = &(ldSpanInfo[ld].span_set[info]); 791665484d8SDoug Ambrisko 7928e727371SKashyap D Desai if (span_set->span_row_data_width == 0) 7938e727371SKashyap D Desai break; 7948e727371SKashyap D Desai if (row > span_set->data_row_end) 7958e727371SKashyap D Desai continue; 796665484d8SDoug Ambrisko 797665484d8SDoug Ambrisko for (span = 0; span < raid->spanDepth; span++) 798665484d8SDoug Ambrisko if (map->raidMap.ldSpanMap[ld].spanBlock[span]. 799665484d8SDoug Ambrisko block_span_info.noElements >= info + 1) { 800665484d8SDoug Ambrisko quad = &map->raidMap.ldSpanMap[ld]. 801665484d8SDoug Ambrisko spanBlock[span].block_span_info.quad[info]; 802665484d8SDoug Ambrisko if (quad->logStart <= row && 803665484d8SDoug Ambrisko row <= quad->logEnd && 804665484d8SDoug Ambrisko mega_mod64((row - quad->logStart), 805665484d8SDoug Ambrisko quad->diff) == 0) { 806665484d8SDoug Ambrisko strip = mega_div64_32 807665484d8SDoug Ambrisko (((row - span_set->data_row_start) 808665484d8SDoug Ambrisko - quad->logStart), 809665484d8SDoug Ambrisko quad->diff); 810665484d8SDoug Ambrisko strip *= span_set->span_row_data_width; 811665484d8SDoug Ambrisko strip += span_set->data_strip_start; 812665484d8SDoug Ambrisko strip += span_set->strip_offset[span]; 813665484d8SDoug Ambrisko return strip; 814665484d8SDoug Ambrisko } 815665484d8SDoug Ambrisko } 816665484d8SDoug Ambrisko } 817ecea5be4SKashyap D Desai mrsas_dprint(sc, MRSAS_PRL11, "AVAGO Debug - get_strip_from_row: returns invalid " 818665484d8SDoug Ambrisko "strip for ld=%x, row=%lx\n", ld, (long unsigned int)row); 819665484d8SDoug Ambrisko return -1; 820665484d8SDoug Ambrisko } 821665484d8SDoug Ambrisko 822665484d8SDoug Ambrisko /* 823665484d8SDoug Ambrisko * ***************************************************************************** 824665484d8SDoug Ambrisko * 8258e727371SKashyap D Desai * 826665484d8SDoug Ambrisko * This routine calculates the Physical Arm for given strip using spanset. 827665484d8SDoug Ambrisko * 8288e727371SKashyap D Desai * Inputs : HBA instance 8298e727371SKashyap D Desai * Logical drive number 8308e727371SKashyap D Desai * Strip 8318e727371SKashyap D Desai * LD map 832665484d8SDoug Ambrisko * 8338e727371SKashyap D Desai * Outputs : Phys Arm - Phys Arm associated with strip 834665484d8SDoug Ambrisko */ 835665484d8SDoug Ambrisko 8368e727371SKashyap D Desai static u_int32_t 8378e727371SKashyap D Desai get_arm_from_strip(struct mrsas_softc *sc, 8384799d485SKashyap D Desai u_int32_t ld, u_int64_t strip, MR_DRV_RAID_MAP_ALL * map) 839665484d8SDoug Ambrisko { 840665484d8SDoug Ambrisko MR_LD_RAID *raid = MR_LdRaidGet(ld, map); 841665484d8SDoug Ambrisko LD_SPAN_SET *span_set; 842665484d8SDoug Ambrisko PLD_SPAN_INFO ldSpanInfo = sc->log_to_span; 843665484d8SDoug Ambrisko u_int32_t info, strip_offset, span, span_offset; 844665484d8SDoug Ambrisko 845665484d8SDoug Ambrisko for (info = 0; info < MAX_QUAD_DEPTH; info++) { 846665484d8SDoug Ambrisko span_set = &(ldSpanInfo[ld].span_set[info]); 847665484d8SDoug Ambrisko 8488e727371SKashyap D Desai if (span_set->span_row_data_width == 0) 8498e727371SKashyap D Desai break; 8508e727371SKashyap D Desai if (strip > span_set->data_strip_end) 8518e727371SKashyap D Desai continue; 852665484d8SDoug Ambrisko 853665484d8SDoug Ambrisko strip_offset = (u_int32_t)mega_mod64 854665484d8SDoug Ambrisko ((strip - span_set->data_strip_start), 855665484d8SDoug Ambrisko span_set->span_row_data_width); 856665484d8SDoug Ambrisko 857665484d8SDoug Ambrisko for (span = 0, span_offset = 0; span < raid->spanDepth; span++) 858665484d8SDoug Ambrisko if (map->raidMap.ldSpanMap[ld].spanBlock[span]. 859665484d8SDoug Ambrisko block_span_info.noElements >= info + 1) { 8608e727371SKashyap D Desai if (strip_offset >= span_set->strip_offset[span]) 8618e727371SKashyap D Desai span_offset = span_set->strip_offset[span]; 862665484d8SDoug Ambrisko else 863665484d8SDoug Ambrisko break; 864665484d8SDoug Ambrisko } 865ecea5be4SKashyap D Desai mrsas_dprint(sc, MRSAS_PRL11, "AVAGO PRL11: get_arm_from_strip: " 866665484d8SDoug Ambrisko "for ld=0x%x strip=0x%lx arm is 0x%x\n", ld, 867665484d8SDoug Ambrisko (long unsigned int)strip, (strip_offset - span_offset)); 868665484d8SDoug Ambrisko return (strip_offset - span_offset); 869665484d8SDoug Ambrisko } 870665484d8SDoug Ambrisko 871ecea5be4SKashyap D Desai mrsas_dprint(sc, MRSAS_PRL11, "AVAGO Debug: - get_arm_from_strip: returns invalid arm" 872665484d8SDoug Ambrisko " for ld=%x strip=%lx\n", ld, (long unsigned int)strip); 873665484d8SDoug Ambrisko 874665484d8SDoug Ambrisko return -1; 875665484d8SDoug Ambrisko } 876665484d8SDoug Ambrisko 877665484d8SDoug Ambrisko 878665484d8SDoug Ambrisko /* This Function will return Phys arm */ 8798e727371SKashyap D Desai u_int8_t 8808e727371SKashyap D Desai get_arm(struct mrsas_softc *sc, u_int32_t ld, u_int8_t span, u_int64_t stripe, 8814799d485SKashyap D Desai MR_DRV_RAID_MAP_ALL * map) 882665484d8SDoug Ambrisko { 883665484d8SDoug Ambrisko MR_LD_RAID *raid = MR_LdRaidGet(ld, map); 8848e727371SKashyap D Desai 885665484d8SDoug Ambrisko /* Need to check correct default value */ 886665484d8SDoug Ambrisko u_int32_t arm = 0; 887665484d8SDoug Ambrisko 888665484d8SDoug Ambrisko switch (raid->level) { 889665484d8SDoug Ambrisko case 0: 890665484d8SDoug Ambrisko case 5: 891665484d8SDoug Ambrisko case 6: 892665484d8SDoug Ambrisko arm = mega_mod64(stripe, SPAN_ROW_SIZE(map, ld, span)); 893665484d8SDoug Ambrisko break; 894665484d8SDoug Ambrisko case 1: 8958e727371SKashyap D Desai /* start with logical arm */ 896665484d8SDoug Ambrisko arm = get_arm_from_strip(sc, ld, stripe, map); 897665484d8SDoug Ambrisko arm *= 2; 898665484d8SDoug Ambrisko break; 899665484d8SDoug Ambrisko } 900665484d8SDoug Ambrisko 901665484d8SDoug Ambrisko return arm; 902665484d8SDoug Ambrisko } 903665484d8SDoug Ambrisko 904665484d8SDoug Ambrisko /* 905665484d8SDoug Ambrisko * 906665484d8SDoug Ambrisko * This routine calculates the arm, span and block for the specified stripe and 907665484d8SDoug Ambrisko * reference in stripe using spanset 908665484d8SDoug Ambrisko * 90916dc2814SKashyap D Desai * Inputs : 91016dc2814SKashyap D Desai * sc - HBA instance 91116dc2814SKashyap D Desai * ld - Logical drive number 9128e727371SKashyap D Desai * stripRow: Stripe number 9138e727371SKashyap D Desai * stripRef: Reference in stripe 914665484d8SDoug Ambrisko * 9158e727371SKashyap D Desai * Outputs : span - Span number block - Absolute Block 9168e727371SKashyap D Desai * number in the physical disk 917665484d8SDoug Ambrisko */ 9188e727371SKashyap D Desai static u_int8_t 9198e727371SKashyap D Desai mr_spanset_get_phy_params(struct mrsas_softc *sc, u_int32_t ld, u_int64_t stripRow, 920665484d8SDoug Ambrisko u_int16_t stripRef, struct IO_REQUEST_INFO *io_info, 9214799d485SKashyap D Desai RAID_CONTEXT * pRAID_Context, MR_DRV_RAID_MAP_ALL * map) 922665484d8SDoug Ambrisko { 923665484d8SDoug Ambrisko MR_LD_RAID *raid = MR_LdRaidGet(ld, map); 924665484d8SDoug Ambrisko u_int32_t pd, arRef; 925665484d8SDoug Ambrisko u_int8_t physArm, span; 926665484d8SDoug Ambrisko u_int64_t row; 927665484d8SDoug Ambrisko u_int8_t retval = TRUE; 928665484d8SDoug Ambrisko u_int64_t *pdBlock = &io_info->pdBlock; 929665484d8SDoug Ambrisko u_int16_t *pDevHandle = &io_info->devHandle; 930665484d8SDoug Ambrisko u_int32_t logArm, rowMod, armQ, arm; 931665484d8SDoug Ambrisko 9328e727371SKashyap D Desai /* Get row and span from io_info for Uneven Span IO. */ 933665484d8SDoug Ambrisko row = io_info->start_row; 934665484d8SDoug Ambrisko span = io_info->start_span; 935665484d8SDoug Ambrisko 936665484d8SDoug Ambrisko 937665484d8SDoug Ambrisko if (raid->level == 6) { 938665484d8SDoug Ambrisko logArm = get_arm_from_strip(sc, ld, stripRow, map); 939665484d8SDoug Ambrisko rowMod = mega_mod64(row, SPAN_ROW_SIZE(map, ld, span)); 940665484d8SDoug Ambrisko armQ = SPAN_ROW_SIZE(map, ld, span) - 1 - rowMod; 941665484d8SDoug Ambrisko arm = armQ + 1 + logArm; 942665484d8SDoug Ambrisko if (arm >= SPAN_ROW_SIZE(map, ld, span)) 943665484d8SDoug Ambrisko arm -= SPAN_ROW_SIZE(map, ld, span); 944665484d8SDoug Ambrisko physArm = (u_int8_t)arm; 945665484d8SDoug Ambrisko } else 9468e727371SKashyap D Desai /* Calculate the arm */ 947665484d8SDoug Ambrisko physArm = get_arm(sc, ld, span, stripRow, map); 948665484d8SDoug Ambrisko 949665484d8SDoug Ambrisko 950665484d8SDoug Ambrisko arRef = MR_LdSpanArrayGet(ld, span, map); 951665484d8SDoug Ambrisko pd = MR_ArPdGet(arRef, physArm, map); 952665484d8SDoug Ambrisko 953665484d8SDoug Ambrisko if (pd != MR_PD_INVALID) 954665484d8SDoug Ambrisko *pDevHandle = MR_PdDevHandleGet(pd, map); 955665484d8SDoug Ambrisko else { 956665484d8SDoug Ambrisko *pDevHandle = MR_PD_INVALID; 9577aade8bfSKashyap D Desai if ((raid->level >= 5) && ((sc->device_id == MRSAS_TBOLT) || 9587aade8bfSKashyap D Desai (sc->mrsas_gen3_ctrl && 959665484d8SDoug Ambrisko raid->regTypeReqOnRead != REGION_TYPE_UNUSED))) 960665484d8SDoug Ambrisko pRAID_Context->regLockFlags = REGION_TYPE_EXCLUSIVE; 961665484d8SDoug Ambrisko else if (raid->level == 1) { 962665484d8SDoug Ambrisko pd = MR_ArPdGet(arRef, physArm + 1, map); 963665484d8SDoug Ambrisko if (pd != MR_PD_INVALID) 964665484d8SDoug Ambrisko *pDevHandle = MR_PdDevHandleGet(pd, map); 965665484d8SDoug Ambrisko } 966665484d8SDoug Ambrisko } 967665484d8SDoug Ambrisko 968665484d8SDoug Ambrisko *pdBlock += stripRef + MR_LdSpanPtrGet(ld, span, map)->startBlk; 969*503c4f8dSKashyap D Desai if (sc->is_ventura) { 970*503c4f8dSKashyap D Desai ((RAID_CONTEXT_G35 *) pRAID_Context)->spanArm = 971*503c4f8dSKashyap D Desai (span << RAID_CTX_SPANARM_SPAN_SHIFT) | physArm; 972*503c4f8dSKashyap D Desai io_info->span_arm = (span << RAID_CTX_SPANARM_SPAN_SHIFT) | physArm; 973*503c4f8dSKashyap D Desai } else { 974665484d8SDoug Ambrisko pRAID_Context->spanArm = (span << RAID_CTX_SPANARM_SPAN_SHIFT) | physArm; 97516dc2814SKashyap D Desai io_info->span_arm = pRAID_Context->spanArm; 976*503c4f8dSKashyap D Desai } 977665484d8SDoug Ambrisko return retval; 978665484d8SDoug Ambrisko } 979665484d8SDoug Ambrisko 9808e727371SKashyap D Desai /* 981665484d8SDoug Ambrisko * MR_BuildRaidContext: Set up Fast path RAID context 982665484d8SDoug Ambrisko * 9838e727371SKashyap D Desai * This function will initiate command processing. The start/end row and strip 9848e727371SKashyap D Desai * information is calculated then the lock is acquired. This function will 9858e727371SKashyap D Desai * return 0 if region lock was acquired OR return num strips. 986665484d8SDoug Ambrisko */ 987665484d8SDoug Ambrisko u_int8_t 988665484d8SDoug Ambrisko MR_BuildRaidContext(struct mrsas_softc *sc, struct IO_REQUEST_INFO *io_info, 9894799d485SKashyap D Desai RAID_CONTEXT * pRAID_Context, MR_DRV_RAID_MAP_ALL * map) 990665484d8SDoug Ambrisko { 991665484d8SDoug Ambrisko MR_LD_RAID *raid; 992665484d8SDoug Ambrisko u_int32_t ld, stripSize, stripe_mask; 993665484d8SDoug Ambrisko u_int64_t endLba, endStrip, endRow, start_row, start_strip; 994665484d8SDoug Ambrisko REGION_KEY regStart; 995665484d8SDoug Ambrisko REGION_LEN regSize; 996665484d8SDoug Ambrisko u_int8_t num_strips, numRows; 997665484d8SDoug Ambrisko u_int16_t ref_in_start_stripe, ref_in_end_stripe; 998665484d8SDoug Ambrisko u_int64_t ldStartBlock; 999665484d8SDoug Ambrisko u_int32_t numBlocks, ldTgtId; 1000665484d8SDoug Ambrisko u_int8_t isRead, stripIdx; 1001665484d8SDoug Ambrisko u_int8_t retval = 0; 1002665484d8SDoug Ambrisko u_int8_t startlba_span = SPAN_INVALID; 1003665484d8SDoug Ambrisko u_int64_t *pdBlock = &io_info->pdBlock; 1004665484d8SDoug Ambrisko int error_code = 0; 1005665484d8SDoug Ambrisko 1006665484d8SDoug Ambrisko ldStartBlock = io_info->ldStartBlock; 1007665484d8SDoug Ambrisko numBlocks = io_info->numBlocks; 1008665484d8SDoug Ambrisko ldTgtId = io_info->ldTgtId; 1009665484d8SDoug Ambrisko isRead = io_info->isRead; 1010665484d8SDoug Ambrisko 1011665484d8SDoug Ambrisko io_info->IoforUnevenSpan = 0; 1012665484d8SDoug Ambrisko io_info->start_span = SPAN_INVALID; 1013665484d8SDoug Ambrisko 1014665484d8SDoug Ambrisko ld = MR_TargetIdToLdGet(ldTgtId, map); 1015665484d8SDoug Ambrisko raid = MR_LdRaidGet(ld, map); 1016665484d8SDoug Ambrisko 1017665484d8SDoug Ambrisko if (raid->rowDataSize == 0) { 1018665484d8SDoug Ambrisko if (MR_LdSpanPtrGet(ld, 0, map)->spanRowDataSize == 0) 1019665484d8SDoug Ambrisko return FALSE; 1020665484d8SDoug Ambrisko else if (sc->UnevenSpanSupport) { 1021665484d8SDoug Ambrisko io_info->IoforUnevenSpan = 1; 10228e727371SKashyap D Desai } else { 1023ecea5be4SKashyap D Desai mrsas_dprint(sc, MRSAS_PRL11, "AVAGO Debug: raid->rowDataSize is 0, but has SPAN[0] rowDataSize = 0x%0x," 1024665484d8SDoug Ambrisko " but there is _NO_ UnevenSpanSupport\n", 1025665484d8SDoug Ambrisko MR_LdSpanPtrGet(ld, 0, map)->spanRowDataSize); 1026665484d8SDoug Ambrisko return FALSE; 1027665484d8SDoug Ambrisko } 1028665484d8SDoug Ambrisko } 1029665484d8SDoug Ambrisko stripSize = 1 << raid->stripeShift; 1030665484d8SDoug Ambrisko stripe_mask = stripSize - 1; 1031665484d8SDoug Ambrisko /* 1032665484d8SDoug Ambrisko * calculate starting row and stripe, and number of strips and rows 1033665484d8SDoug Ambrisko */ 1034665484d8SDoug Ambrisko start_strip = ldStartBlock >> raid->stripeShift; 1035665484d8SDoug Ambrisko ref_in_start_stripe = (u_int16_t)(ldStartBlock & stripe_mask); 1036665484d8SDoug Ambrisko endLba = ldStartBlock + numBlocks - 1; 1037665484d8SDoug Ambrisko ref_in_end_stripe = (u_int16_t)(endLba & stripe_mask); 1038665484d8SDoug Ambrisko endStrip = endLba >> raid->stripeShift; 10398e727371SKashyap D Desai num_strips = (u_int8_t)(endStrip - start_strip + 1); /* End strip */ 1040665484d8SDoug Ambrisko if (io_info->IoforUnevenSpan) { 1041665484d8SDoug Ambrisko start_row = get_row_from_strip(sc, ld, start_strip, map); 1042665484d8SDoug Ambrisko endRow = get_row_from_strip(sc, ld, endStrip, map); 1043665484d8SDoug Ambrisko if (raid->spanDepth == 1) { 1044665484d8SDoug Ambrisko startlba_span = 0; 1045665484d8SDoug Ambrisko *pdBlock = start_row << raid->stripeShift; 1046665484d8SDoug Ambrisko } else { 1047665484d8SDoug Ambrisko startlba_span = (u_int8_t)mr_spanset_get_span_block(sc, ld, start_row, 1048665484d8SDoug Ambrisko pdBlock, map, &error_code); 1049665484d8SDoug Ambrisko if (error_code == 1) { 1050ecea5be4SKashyap D Desai mrsas_dprint(sc, MRSAS_PRL11, "AVAGO Debug: return from %s %d. Send IO w/o region lock.\n", 1051665484d8SDoug Ambrisko __func__, __LINE__); 1052665484d8SDoug Ambrisko return FALSE; 1053665484d8SDoug Ambrisko } 1054665484d8SDoug Ambrisko } 1055665484d8SDoug Ambrisko if (startlba_span == SPAN_INVALID) { 1056ecea5be4SKashyap D Desai mrsas_dprint(sc, MRSAS_PRL11, "AVAGO Debug: return from %s %d for row 0x%llx," 1057665484d8SDoug Ambrisko "start strip %llx endSrip %llx\n", __func__, 1058665484d8SDoug Ambrisko __LINE__, (unsigned long long)start_row, 1059665484d8SDoug Ambrisko (unsigned long long)start_strip, 1060665484d8SDoug Ambrisko (unsigned long long)endStrip); 1061665484d8SDoug Ambrisko return FALSE; 1062665484d8SDoug Ambrisko } 1063665484d8SDoug Ambrisko io_info->start_span = startlba_span; 1064665484d8SDoug Ambrisko io_info->start_row = start_row; 1065ecea5be4SKashyap D Desai mrsas_dprint(sc, MRSAS_PRL11, "AVAGO Debug: Check Span number from %s %d for row 0x%llx, " 1066665484d8SDoug Ambrisko " start strip 0x%llx endSrip 0x%llx span 0x%x\n", 1067665484d8SDoug Ambrisko __func__, __LINE__, (unsigned long long)start_row, 1068665484d8SDoug Ambrisko (unsigned long long)start_strip, 1069665484d8SDoug Ambrisko (unsigned long long)endStrip, startlba_span); 1070ecea5be4SKashyap D Desai mrsas_dprint(sc, MRSAS_PRL11, "AVAGO Debug : 1. start_row 0x%llx endRow 0x%llx Start span 0x%x\n", 1071665484d8SDoug Ambrisko (unsigned long long)start_row, (unsigned long long)endRow, startlba_span); 1072665484d8SDoug Ambrisko } else { 10738e727371SKashyap D Desai start_row = mega_div64_32(start_strip, raid->rowDataSize); 1074665484d8SDoug Ambrisko endRow = mega_div64_32(endStrip, raid->rowDataSize); 1075665484d8SDoug Ambrisko } 1076665484d8SDoug Ambrisko 10778e727371SKashyap D Desai numRows = (u_int8_t)(endRow - start_row + 1); /* get the row count */ 1078665484d8SDoug Ambrisko 1079665484d8SDoug Ambrisko /* 1080665484d8SDoug Ambrisko * Calculate region info. (Assume region at start of first row, and 1081665484d8SDoug Ambrisko * assume this IO needs the full row - will adjust if not true.) 1082665484d8SDoug Ambrisko */ 1083665484d8SDoug Ambrisko regStart = start_row << raid->stripeShift; 1084665484d8SDoug Ambrisko regSize = stripSize; 1085665484d8SDoug Ambrisko 1086665484d8SDoug Ambrisko /* Check if we can send this I/O via FastPath */ 1087665484d8SDoug Ambrisko if (raid->capability.fpCapable) { 1088665484d8SDoug Ambrisko if (isRead) 1089665484d8SDoug Ambrisko io_info->fpOkForIo = (raid->capability.fpReadCapable && 1090665484d8SDoug Ambrisko ((num_strips == 1) || 10918e727371SKashyap D Desai raid->capability.fpReadAcrossStripe)); 1092665484d8SDoug Ambrisko else 1093665484d8SDoug Ambrisko io_info->fpOkForIo = (raid->capability.fpWriteCapable && 1094665484d8SDoug Ambrisko ((num_strips == 1) || 10958e727371SKashyap D Desai raid->capability.fpWriteAcrossStripe)); 10968e727371SKashyap D Desai } else 1097665484d8SDoug Ambrisko io_info->fpOkForIo = FALSE; 1098665484d8SDoug Ambrisko 1099665484d8SDoug Ambrisko if (numRows == 1) { 1100665484d8SDoug Ambrisko if (num_strips == 1) { 1101665484d8SDoug Ambrisko regStart += ref_in_start_stripe; 1102665484d8SDoug Ambrisko regSize = numBlocks; 1103665484d8SDoug Ambrisko } 11048e727371SKashyap D Desai } else if (io_info->IoforUnevenSpan == 0) { 11058e727371SKashyap D Desai /* 11068e727371SKashyap D Desai * For Even span region lock optimization. If the start strip 11078e727371SKashyap D Desai * is the last in the start row 11088e727371SKashyap D Desai */ 1109665484d8SDoug Ambrisko if (start_strip == (start_row + 1) * raid->rowDataSize - 1) { 1110665484d8SDoug Ambrisko regStart += ref_in_start_stripe; 11118e727371SKashyap D Desai /* 11128e727371SKashyap D Desai * initialize count to sectors from startRef to end 11138e727371SKashyap D Desai * of strip 11148e727371SKashyap D Desai */ 1115665484d8SDoug Ambrisko regSize = stripSize - ref_in_start_stripe; 1116665484d8SDoug Ambrisko } 11178e727371SKashyap D Desai /* add complete rows in the middle of the transfer */ 1118665484d8SDoug Ambrisko if (numRows > 2) 1119665484d8SDoug Ambrisko regSize += (numRows - 2) << raid->stripeShift; 1120665484d8SDoug Ambrisko 11218e727371SKashyap D Desai /* if IO ends within first strip of last row */ 1122665484d8SDoug Ambrisko if (endStrip == endRow * raid->rowDataSize) 1123665484d8SDoug Ambrisko regSize += ref_in_end_stripe + 1; 1124665484d8SDoug Ambrisko else 1125665484d8SDoug Ambrisko regSize += stripSize; 1126665484d8SDoug Ambrisko } else { 1127665484d8SDoug Ambrisko if (start_strip == (get_strip_from_row(sc, ld, start_row, map) + 1128665484d8SDoug Ambrisko SPAN_ROW_DATA_SIZE(map, ld, startlba_span) - 1)) { 1129665484d8SDoug Ambrisko regStart += ref_in_start_stripe; 11308e727371SKashyap D Desai /* 11318e727371SKashyap D Desai * initialize count to sectors from startRef to end 11328e727371SKashyap D Desai * of strip 11338e727371SKashyap D Desai */ 1134665484d8SDoug Ambrisko regSize = stripSize - ref_in_start_stripe; 1135665484d8SDoug Ambrisko } 11368e727371SKashyap D Desai /* add complete rows in the middle of the transfer */ 1137665484d8SDoug Ambrisko if (numRows > 2) 1138665484d8SDoug Ambrisko regSize += (numRows - 2) << raid->stripeShift; 1139665484d8SDoug Ambrisko 11408e727371SKashyap D Desai /* if IO ends within first strip of last row */ 1141665484d8SDoug Ambrisko if (endStrip == get_strip_from_row(sc, ld, endRow, map)) 1142665484d8SDoug Ambrisko regSize += ref_in_end_stripe + 1; 1143665484d8SDoug Ambrisko else 1144665484d8SDoug Ambrisko regSize += stripSize; 1145665484d8SDoug Ambrisko } 1146665484d8SDoug Ambrisko pRAID_Context->timeoutValue = map->raidMap.fpPdIoTimeoutSec; 1147f9c63081SKashyap D Desai if (sc->mrsas_gen3_ctrl) 1148665484d8SDoug Ambrisko pRAID_Context->regLockFlags = (isRead) ? raid->regTypeReqOnRead : raid->regTypeReqOnWrite; 11497aade8bfSKashyap D Desai else if (sc->device_id == MRSAS_TBOLT) 1150665484d8SDoug Ambrisko pRAID_Context->regLockFlags = (isRead) ? REGION_TYPE_SHARED_READ : raid->regTypeReqOnWrite; 1151665484d8SDoug Ambrisko pRAID_Context->VirtualDiskTgtId = raid->targetId; 1152665484d8SDoug Ambrisko pRAID_Context->regLockRowLBA = regStart; 1153665484d8SDoug Ambrisko pRAID_Context->regLockLength = regSize; 1154665484d8SDoug Ambrisko pRAID_Context->configSeqNum = raid->seqNum; 1155665484d8SDoug Ambrisko 1156665484d8SDoug Ambrisko /* 1157665484d8SDoug Ambrisko * Get Phy Params only if FP capable, or else leave it to MR firmware 1158665484d8SDoug Ambrisko * to do the calculation. 1159665484d8SDoug Ambrisko */ 1160665484d8SDoug Ambrisko if (io_info->fpOkForIo) { 1161665484d8SDoug Ambrisko retval = io_info->IoforUnevenSpan ? 11628e727371SKashyap D Desai mr_spanset_get_phy_params(sc, ld, start_strip, 11638e727371SKashyap D Desai ref_in_start_stripe, io_info, pRAID_Context, map) : 1164665484d8SDoug Ambrisko MR_GetPhyParams(sc, ld, start_strip, 1165665484d8SDoug Ambrisko ref_in_start_stripe, io_info, pRAID_Context, map); 1166665484d8SDoug Ambrisko /* If IO on an invalid Pd, then FP is not possible */ 1167665484d8SDoug Ambrisko if (io_info->devHandle == MR_PD_INVALID) 1168665484d8SDoug Ambrisko io_info->fpOkForIo = FALSE; 1169*503c4f8dSKashyap D Desai /* 1170*503c4f8dSKashyap D Desai * if FP possible, set the SLUD bit in regLockFlags for 1171*503c4f8dSKashyap D Desai * ventura 1172*503c4f8dSKashyap D Desai */ 1173*503c4f8dSKashyap D Desai else if ((sc->is_ventura) && !isRead && 1174*503c4f8dSKashyap D Desai (raid->writeMode == MR_RL_WRITE_BACK_MODE) && (raid->level <= 1) && 1175*503c4f8dSKashyap D Desai raid->capability.fpCacheBypassCapable) { 1176*503c4f8dSKashyap D Desai ((RAID_CONTEXT_G35 *) pRAID_Context)->routingFlags.bits.sld = 1; 1177*503c4f8dSKashyap D Desai } 1178665484d8SDoug Ambrisko return retval; 11798e727371SKashyap D Desai } else if (isRead) { 1180665484d8SDoug Ambrisko for (stripIdx = 0; stripIdx < num_strips; stripIdx++) { 1181665484d8SDoug Ambrisko retval = io_info->IoforUnevenSpan ? 11828e727371SKashyap D Desai mr_spanset_get_phy_params(sc, ld, start_strip + stripIdx, 11838e727371SKashyap D Desai ref_in_start_stripe, io_info, pRAID_Context, map) : 11848e727371SKashyap D Desai MR_GetPhyParams(sc, ld, start_strip + stripIdx, 11858e727371SKashyap D Desai ref_in_start_stripe, io_info, pRAID_Context, map); 1186665484d8SDoug Ambrisko if (!retval) 1187665484d8SDoug Ambrisko return TRUE; 1188665484d8SDoug Ambrisko } 1189665484d8SDoug Ambrisko } 1190665484d8SDoug Ambrisko #if SPAN_DEBUG 11918e727371SKashyap D Desai /* Just for testing what arm we get for strip. */ 1192665484d8SDoug Ambrisko get_arm_from_strip(sc, ld, start_strip, map); 1193665484d8SDoug Ambrisko #endif 1194665484d8SDoug Ambrisko return TRUE; 1195665484d8SDoug Ambrisko } 1196665484d8SDoug Ambrisko 1197665484d8SDoug Ambrisko /* 1198665484d8SDoug Ambrisko * 11998e727371SKashyap D Desai * This routine pepare spanset info from Valid Raid map and store it into local 12008e727371SKashyap D Desai * copy of ldSpanInfo per instance data structure. 1201665484d8SDoug Ambrisko * 12028e727371SKashyap D Desai * Inputs : LD map 12038e727371SKashyap D Desai * ldSpanInfo per HBA instance 1204665484d8SDoug Ambrisko * 1205665484d8SDoug Ambrisko */ 12068e727371SKashyap D Desai void 12078e727371SKashyap D Desai mr_update_span_set(MR_DRV_RAID_MAP_ALL * map, PLD_SPAN_INFO ldSpanInfo) 1208665484d8SDoug Ambrisko { 1209665484d8SDoug Ambrisko u_int8_t span, count; 1210665484d8SDoug Ambrisko u_int32_t element, span_row_width; 1211665484d8SDoug Ambrisko u_int64_t span_row; 1212665484d8SDoug Ambrisko MR_LD_RAID *raid; 1213665484d8SDoug Ambrisko LD_SPAN_SET *span_set, *span_set_prev; 1214665484d8SDoug Ambrisko MR_QUAD_ELEMENT *quad; 1215665484d8SDoug Ambrisko int ldCount; 1216665484d8SDoug Ambrisko u_int16_t ld; 1217665484d8SDoug Ambrisko 12188e727371SKashyap D Desai for (ldCount = 0; ldCount < MAX_LOGICAL_DRIVES; ldCount++) { 1219665484d8SDoug Ambrisko ld = MR_TargetIdToLdGet(ldCount, map); 1220665484d8SDoug Ambrisko if (ld >= MAX_LOGICAL_DRIVES) 1221665484d8SDoug Ambrisko continue; 1222665484d8SDoug Ambrisko raid = MR_LdRaidGet(ld, map); 1223665484d8SDoug Ambrisko for (element = 0; element < MAX_QUAD_DEPTH; element++) { 1224665484d8SDoug Ambrisko for (span = 0; span < raid->spanDepth; span++) { 1225665484d8SDoug Ambrisko if (map->raidMap.ldSpanMap[ld].spanBlock[span]. 1226665484d8SDoug Ambrisko block_span_info.noElements < element + 1) 1227665484d8SDoug Ambrisko continue; 12288e727371SKashyap D Desai /* TO-DO */ 1229665484d8SDoug Ambrisko span_set = &(ldSpanInfo[ld].span_set[element]); 1230665484d8SDoug Ambrisko quad = &map->raidMap.ldSpanMap[ld]. 12318e727371SKashyap D Desai spanBlock[span].block_span_info.quad[element]; 1232665484d8SDoug Ambrisko 1233665484d8SDoug Ambrisko span_set->diff = quad->diff; 1234665484d8SDoug Ambrisko 1235665484d8SDoug Ambrisko for (count = 0, span_row_width = 0; 1236665484d8SDoug Ambrisko count < raid->spanDepth; count++) { 12378e727371SKashyap D Desai if (map->raidMap.ldSpanMap[ld].spanBlock[count]. 12388e727371SKashyap D Desai block_span_info.noElements >= element + 1) { 12398e727371SKashyap D Desai span_set->strip_offset[count] = span_row_width; 1240665484d8SDoug Ambrisko span_row_width += 12418e727371SKashyap D Desai MR_LdSpanPtrGet(ld, count, map)->spanRowDataSize; 1242665484d8SDoug Ambrisko #if SPAN_DEBUG 1243ecea5be4SKashyap D Desai printf("AVAGO Debug span %x rowDataSize %x\n", count, 12448e727371SKashyap D Desai MR_LdSpanPtrGet(ld, count, map)->spanRowDataSize); 1245665484d8SDoug Ambrisko #endif 1246665484d8SDoug Ambrisko } 1247665484d8SDoug Ambrisko } 1248665484d8SDoug Ambrisko 1249665484d8SDoug Ambrisko span_set->span_row_data_width = span_row_width; 1250665484d8SDoug Ambrisko span_row = mega_div64_32(((quad->logEnd - 1251665484d8SDoug Ambrisko quad->logStart) + quad->diff), quad->diff); 1252665484d8SDoug Ambrisko 1253665484d8SDoug Ambrisko if (element == 0) { 1254665484d8SDoug Ambrisko span_set->log_start_lba = 0; 1255665484d8SDoug Ambrisko span_set->log_end_lba = 1256665484d8SDoug Ambrisko ((span_row << raid->stripeShift) * span_row_width) - 1; 1257665484d8SDoug Ambrisko 1258665484d8SDoug Ambrisko span_set->span_row_start = 0; 1259665484d8SDoug Ambrisko span_set->span_row_end = span_row - 1; 1260665484d8SDoug Ambrisko 1261665484d8SDoug Ambrisko span_set->data_strip_start = 0; 12628e727371SKashyap D Desai span_set->data_strip_end = (span_row * span_row_width) - 1; 1263665484d8SDoug Ambrisko 1264665484d8SDoug Ambrisko span_set->data_row_start = 0; 12658e727371SKashyap D Desai span_set->data_row_end = (span_row * quad->diff) - 1; 1266665484d8SDoug Ambrisko } else { 12678e727371SKashyap D Desai span_set_prev = &(ldSpanInfo[ld].span_set[element - 1]); 12688e727371SKashyap D Desai span_set->log_start_lba = span_set_prev->log_end_lba + 1; 12698e727371SKashyap D Desai span_set->log_end_lba = span_set->log_start_lba + 1270665484d8SDoug Ambrisko ((span_row << raid->stripeShift) * span_row_width) - 1; 1271665484d8SDoug Ambrisko 12728e727371SKashyap D Desai span_set->span_row_start = span_set_prev->span_row_end + 1; 1273665484d8SDoug Ambrisko span_set->span_row_end = 1274665484d8SDoug Ambrisko span_set->span_row_start + span_row - 1; 1275665484d8SDoug Ambrisko 1276665484d8SDoug Ambrisko span_set->data_strip_start = 1277665484d8SDoug Ambrisko span_set_prev->data_strip_end + 1; 12788e727371SKashyap D Desai span_set->data_strip_end = span_set->data_strip_start + 1279665484d8SDoug Ambrisko (span_row * span_row_width) - 1; 1280665484d8SDoug Ambrisko 12818e727371SKashyap D Desai span_set->data_row_start = span_set_prev->data_row_end + 1; 12828e727371SKashyap D Desai span_set->data_row_end = span_set->data_row_start + 1283665484d8SDoug Ambrisko (span_row * quad->diff) - 1; 1284665484d8SDoug Ambrisko } 1285665484d8SDoug Ambrisko break; 1286665484d8SDoug Ambrisko } 12878e727371SKashyap D Desai if (span == raid->spanDepth) 12888e727371SKashyap D Desai break; /* no quads remain */ 1289665484d8SDoug Ambrisko } 1290665484d8SDoug Ambrisko } 1291665484d8SDoug Ambrisko #if SPAN_DEBUG 12928e727371SKashyap D Desai getSpanInfo(map, ldSpanInfo); /* to get span set info */ 1293665484d8SDoug Ambrisko #endif 1294665484d8SDoug Ambrisko } 1295665484d8SDoug Ambrisko 12968e727371SKashyap D Desai /* 1297665484d8SDoug Ambrisko * mrsas_update_load_balance_params: Update load balance parmas 129816dc2814SKashyap D Desai * Inputs: 129916dc2814SKashyap D Desai * sc - driver softc instance 130016dc2814SKashyap D Desai * drv_map - driver RAID map 130116dc2814SKashyap D Desai * lbInfo - Load balance info 1302665484d8SDoug Ambrisko * 13038e727371SKashyap D Desai * This function updates the load balance parameters for the LD config of a two 13048e727371SKashyap D Desai * drive optimal RAID-1. 1305665484d8SDoug Ambrisko */ 13068e727371SKashyap D Desai void 130716dc2814SKashyap D Desai mrsas_update_load_balance_params(struct mrsas_softc *sc, 130816dc2814SKashyap D Desai MR_DRV_RAID_MAP_ALL * drv_map, PLD_LOAD_BALANCE_INFO lbInfo) 1309665484d8SDoug Ambrisko { 1310665484d8SDoug Ambrisko int ldCount; 1311665484d8SDoug Ambrisko u_int16_t ld; 1312665484d8SDoug Ambrisko MR_LD_RAID *raid; 1313665484d8SDoug Ambrisko 131416dc2814SKashyap D Desai if (sc->lb_pending_cmds > 128 || sc->lb_pending_cmds < 1) 131516dc2814SKashyap D Desai sc->lb_pending_cmds = LB_PENDING_CMDS_DEFAULT; 131616dc2814SKashyap D Desai 131716dc2814SKashyap D Desai for (ldCount = 0; ldCount < MAX_LOGICAL_DRIVES_EXT; ldCount++) { 131816dc2814SKashyap D Desai ld = MR_TargetIdToLdGet(ldCount, drv_map); 131916dc2814SKashyap D Desai if (ld >= MAX_LOGICAL_DRIVES_EXT) { 1320665484d8SDoug Ambrisko lbInfo[ldCount].loadBalanceFlag = 0; 1321665484d8SDoug Ambrisko continue; 1322665484d8SDoug Ambrisko } 132316dc2814SKashyap D Desai raid = MR_LdRaidGet(ld, drv_map); 132416dc2814SKashyap D Desai if ((raid->level != 1) || 132516dc2814SKashyap D Desai (raid->ldState != MR_LD_STATE_OPTIMAL)) { 1326665484d8SDoug Ambrisko lbInfo[ldCount].loadBalanceFlag = 0; 132716dc2814SKashyap D Desai continue; 132816dc2814SKashyap D Desai } 132916dc2814SKashyap D Desai lbInfo[ldCount].loadBalanceFlag = 1; 1330665484d8SDoug Ambrisko } 1331665484d8SDoug Ambrisko } 1332665484d8SDoug Ambrisko 1333665484d8SDoug Ambrisko 13348e727371SKashyap D Desai /* 1335665484d8SDoug Ambrisko * mrsas_set_pd_lba: Sets PD LBA 1336665484d8SDoug Ambrisko * input: io_request pointer 1337665484d8SDoug Ambrisko * CDB length 1338665484d8SDoug Ambrisko * io_info pointer 1339665484d8SDoug Ambrisko * Pointer to CCB 1340665484d8SDoug Ambrisko * Local RAID map pointer 13418e727371SKashyap D Desai * Start block of IO Block Size 1342665484d8SDoug Ambrisko * 1343665484d8SDoug Ambrisko * Used to set the PD logical block address in CDB for FP IOs. 1344665484d8SDoug Ambrisko */ 13458e727371SKashyap D Desai void 13468e727371SKashyap D Desai mrsas_set_pd_lba(MRSAS_RAID_SCSI_IO_REQUEST * io_request, u_int8_t cdb_len, 1347665484d8SDoug Ambrisko struct IO_REQUEST_INFO *io_info, union ccb *ccb, 13484799d485SKashyap D Desai MR_DRV_RAID_MAP_ALL * local_map_ptr, u_int32_t ref_tag, 1349665484d8SDoug Ambrisko u_int32_t ld_block_size) 1350665484d8SDoug Ambrisko { 1351665484d8SDoug Ambrisko MR_LD_RAID *raid; 1352665484d8SDoug Ambrisko u_int32_t ld; 1353665484d8SDoug Ambrisko u_int64_t start_blk = io_info->pdBlock; 1354665484d8SDoug Ambrisko u_int8_t *cdb = io_request->CDB.CDB32; 1355665484d8SDoug Ambrisko u_int32_t num_blocks = io_info->numBlocks; 1356665484d8SDoug Ambrisko u_int8_t opcode = 0, flagvals = 0, groupnum = 0, control = 0; 1357665484d8SDoug Ambrisko struct ccb_hdr *ccb_h = &(ccb->ccb_h); 1358665484d8SDoug Ambrisko 1359665484d8SDoug Ambrisko /* Check if T10 PI (DIF) is enabled for this LD */ 1360665484d8SDoug Ambrisko ld = MR_TargetIdToLdGet(io_info->ldTgtId, local_map_ptr); 1361665484d8SDoug Ambrisko raid = MR_LdRaidGet(ld, local_map_ptr); 1362665484d8SDoug Ambrisko if (raid->capability.ldPiMode == MR_PROT_INFO_TYPE_CONTROLLER) { 1363665484d8SDoug Ambrisko memset(cdb, 0, sizeof(io_request->CDB.CDB32)); 1364665484d8SDoug Ambrisko cdb[0] = MRSAS_SCSI_VARIABLE_LENGTH_CMD; 1365665484d8SDoug Ambrisko cdb[7] = MRSAS_SCSI_ADDL_CDB_LEN; 1366665484d8SDoug Ambrisko 1367665484d8SDoug Ambrisko if (ccb_h->flags == CAM_DIR_OUT) 1368665484d8SDoug Ambrisko cdb[9] = MRSAS_SCSI_SERVICE_ACTION_READ32; 1369665484d8SDoug Ambrisko else 1370665484d8SDoug Ambrisko cdb[9] = MRSAS_SCSI_SERVICE_ACTION_WRITE32; 1371665484d8SDoug Ambrisko cdb[10] = MRSAS_RD_WR_PROTECT_CHECK_ALL; 1372665484d8SDoug Ambrisko 1373665484d8SDoug Ambrisko /* LBA */ 1374665484d8SDoug Ambrisko cdb[12] = (u_int8_t)((start_blk >> 56) & 0xff); 1375665484d8SDoug Ambrisko cdb[13] = (u_int8_t)((start_blk >> 48) & 0xff); 1376665484d8SDoug Ambrisko cdb[14] = (u_int8_t)((start_blk >> 40) & 0xff); 1377665484d8SDoug Ambrisko cdb[15] = (u_int8_t)((start_blk >> 32) & 0xff); 1378665484d8SDoug Ambrisko cdb[16] = (u_int8_t)((start_blk >> 24) & 0xff); 1379665484d8SDoug Ambrisko cdb[17] = (u_int8_t)((start_blk >> 16) & 0xff); 1380665484d8SDoug Ambrisko cdb[18] = (u_int8_t)((start_blk >> 8) & 0xff); 1381665484d8SDoug Ambrisko cdb[19] = (u_int8_t)(start_blk & 0xff); 1382665484d8SDoug Ambrisko 1383665484d8SDoug Ambrisko /* Logical block reference tag */ 1384665484d8SDoug Ambrisko io_request->CDB.EEDP32.PrimaryReferenceTag = swap32(ref_tag); 1385665484d8SDoug Ambrisko io_request->CDB.EEDP32.PrimaryApplicationTagMask = 0xffff; 1386665484d8SDoug Ambrisko io_request->IoFlags = 32; /* Specify 32-byte cdb */ 1387665484d8SDoug Ambrisko 1388665484d8SDoug Ambrisko /* Transfer length */ 1389665484d8SDoug Ambrisko cdb[28] = (u_int8_t)((num_blocks >> 24) & 0xff); 1390665484d8SDoug Ambrisko cdb[29] = (u_int8_t)((num_blocks >> 16) & 0xff); 1391665484d8SDoug Ambrisko cdb[30] = (u_int8_t)((num_blocks >> 8) & 0xff); 1392665484d8SDoug Ambrisko cdb[31] = (u_int8_t)(num_blocks & 0xff); 1393665484d8SDoug Ambrisko 1394665484d8SDoug Ambrisko /* set SCSI IO EEDP Flags */ 1395665484d8SDoug Ambrisko if (ccb_h->flags == CAM_DIR_OUT) { 1396665484d8SDoug Ambrisko io_request->EEDPFlags = 1397665484d8SDoug Ambrisko MPI2_SCSIIO_EEDPFLAGS_INC_PRI_REFTAG | 1398665484d8SDoug Ambrisko MPI2_SCSIIO_EEDPFLAGS_CHECK_REFTAG | 1399665484d8SDoug Ambrisko MPI2_SCSIIO_EEDPFLAGS_CHECK_REMOVE_OP | 1400665484d8SDoug Ambrisko MPI2_SCSIIO_EEDPFLAGS_CHECK_APPTAG | 1401665484d8SDoug Ambrisko MPI2_SCSIIO_EEDPFLAGS_CHECK_GUARD; 14028e727371SKashyap D Desai } else { 1403665484d8SDoug Ambrisko io_request->EEDPFlags = 1404665484d8SDoug Ambrisko MPI2_SCSIIO_EEDPFLAGS_INC_PRI_REFTAG | 1405665484d8SDoug Ambrisko MPI2_SCSIIO_EEDPFLAGS_INSERT_OP; 1406665484d8SDoug Ambrisko } 1407665484d8SDoug Ambrisko io_request->Control |= (0x4 << 26); 1408665484d8SDoug Ambrisko io_request->EEDPBlockSize = ld_block_size; 14098e727371SKashyap D Desai } else { 1410665484d8SDoug Ambrisko /* Some drives don't support 16/12 byte CDB's, convert to 10 */ 1411665484d8SDoug Ambrisko if (((cdb_len == 12) || (cdb_len == 16)) && 1412665484d8SDoug Ambrisko (start_blk <= 0xffffffff)) { 1413665484d8SDoug Ambrisko if (cdb_len == 16) { 1414665484d8SDoug Ambrisko opcode = cdb[0] == READ_16 ? READ_10 : WRITE_10; 1415665484d8SDoug Ambrisko flagvals = cdb[1]; 1416665484d8SDoug Ambrisko groupnum = cdb[14]; 1417665484d8SDoug Ambrisko control = cdb[15]; 14188e727371SKashyap D Desai } else { 1419665484d8SDoug Ambrisko opcode = cdb[0] == READ_12 ? READ_10 : WRITE_10; 1420665484d8SDoug Ambrisko flagvals = cdb[1]; 1421665484d8SDoug Ambrisko groupnum = cdb[10]; 1422665484d8SDoug Ambrisko control = cdb[11]; 1423665484d8SDoug Ambrisko } 1424665484d8SDoug Ambrisko 1425665484d8SDoug Ambrisko memset(cdb, 0, sizeof(io_request->CDB.CDB32)); 1426665484d8SDoug Ambrisko 1427665484d8SDoug Ambrisko cdb[0] = opcode; 1428665484d8SDoug Ambrisko cdb[1] = flagvals; 1429665484d8SDoug Ambrisko cdb[6] = groupnum; 1430665484d8SDoug Ambrisko cdb[9] = control; 1431665484d8SDoug Ambrisko 1432665484d8SDoug Ambrisko /* Transfer length */ 1433665484d8SDoug Ambrisko cdb[8] = (u_int8_t)(num_blocks & 0xff); 1434665484d8SDoug Ambrisko cdb[7] = (u_int8_t)((num_blocks >> 8) & 0xff); 1435665484d8SDoug Ambrisko 1436665484d8SDoug Ambrisko io_request->IoFlags = 10; /* Specify 10-byte cdb */ 1437665484d8SDoug Ambrisko cdb_len = 10; 1438665484d8SDoug Ambrisko } else if ((cdb_len < 16) && (start_blk > 0xffffffff)) { 1439665484d8SDoug Ambrisko /* Convert to 16 byte CDB for large LBA's */ 1440665484d8SDoug Ambrisko switch (cdb_len) { 1441665484d8SDoug Ambrisko case 6: 1442665484d8SDoug Ambrisko opcode = cdb[0] == READ_6 ? READ_16 : WRITE_16; 1443665484d8SDoug Ambrisko control = cdb[5]; 1444665484d8SDoug Ambrisko break; 1445665484d8SDoug Ambrisko case 10: 1446665484d8SDoug Ambrisko opcode = cdb[0] == READ_10 ? READ_16 : WRITE_16; 1447665484d8SDoug Ambrisko flagvals = cdb[1]; 1448665484d8SDoug Ambrisko groupnum = cdb[6]; 1449665484d8SDoug Ambrisko control = cdb[9]; 1450665484d8SDoug Ambrisko break; 1451665484d8SDoug Ambrisko case 12: 1452665484d8SDoug Ambrisko opcode = cdb[0] == READ_12 ? READ_16 : WRITE_16; 1453665484d8SDoug Ambrisko flagvals = cdb[1]; 1454665484d8SDoug Ambrisko groupnum = cdb[10]; 1455665484d8SDoug Ambrisko control = cdb[11]; 1456665484d8SDoug Ambrisko break; 1457665484d8SDoug Ambrisko } 1458665484d8SDoug Ambrisko 1459665484d8SDoug Ambrisko memset(cdb, 0, sizeof(io_request->CDB.CDB32)); 1460665484d8SDoug Ambrisko 1461665484d8SDoug Ambrisko cdb[0] = opcode; 1462665484d8SDoug Ambrisko cdb[1] = flagvals; 1463665484d8SDoug Ambrisko cdb[14] = groupnum; 1464665484d8SDoug Ambrisko cdb[15] = control; 1465665484d8SDoug Ambrisko 1466665484d8SDoug Ambrisko /* Transfer length */ 1467665484d8SDoug Ambrisko cdb[13] = (u_int8_t)(num_blocks & 0xff); 1468665484d8SDoug Ambrisko cdb[12] = (u_int8_t)((num_blocks >> 8) & 0xff); 1469665484d8SDoug Ambrisko cdb[11] = (u_int8_t)((num_blocks >> 16) & 0xff); 1470665484d8SDoug Ambrisko cdb[10] = (u_int8_t)((num_blocks >> 24) & 0xff); 1471665484d8SDoug Ambrisko 1472665484d8SDoug Ambrisko io_request->IoFlags = 16; /* Specify 16-byte cdb */ 1473665484d8SDoug Ambrisko cdb_len = 16; 1474665484d8SDoug Ambrisko } else if ((cdb_len == 6) && (start_blk > 0x1fffff)) { 1475665484d8SDoug Ambrisko /* convert to 10 byte CDB */ 1476665484d8SDoug Ambrisko opcode = cdb[0] == READ_6 ? READ_10 : WRITE_10; 1477665484d8SDoug Ambrisko control = cdb[5]; 1478665484d8SDoug Ambrisko 147902190a56SXin LI memset(cdb, 0, sizeof(io_request->CDB.CDB32)); 1480665484d8SDoug Ambrisko cdb[0] = opcode; 1481665484d8SDoug Ambrisko cdb[9] = control; 1482665484d8SDoug Ambrisko 1483665484d8SDoug Ambrisko /* Set transfer length */ 1484665484d8SDoug Ambrisko cdb[8] = (u_int8_t)(num_blocks & 0xff); 1485665484d8SDoug Ambrisko cdb[7] = (u_int8_t)((num_blocks >> 8) & 0xff); 1486665484d8SDoug Ambrisko 1487665484d8SDoug Ambrisko /* Specify 10-byte cdb */ 1488665484d8SDoug Ambrisko cdb_len = 10; 1489665484d8SDoug Ambrisko } 1490665484d8SDoug Ambrisko /* Fall through normal case, just load LBA here */ 1491665484d8SDoug Ambrisko u_int8_t val = cdb[1] & 0xE0; 1492dbcc81dfSKashyap D Desai 14938e727371SKashyap D Desai switch (cdb_len) { 14948e727371SKashyap D Desai case 6: 1495665484d8SDoug Ambrisko cdb[3] = (u_int8_t)(start_blk & 0xff); 1496665484d8SDoug Ambrisko cdb[2] = (u_int8_t)((start_blk >> 8) & 0xff); 1497665484d8SDoug Ambrisko cdb[1] = val | ((u_int8_t)(start_blk >> 16) & 0x1f); 1498665484d8SDoug Ambrisko break; 1499665484d8SDoug Ambrisko case 10: 1500665484d8SDoug Ambrisko cdb[5] = (u_int8_t)(start_blk & 0xff); 1501665484d8SDoug Ambrisko cdb[4] = (u_int8_t)((start_blk >> 8) & 0xff); 1502665484d8SDoug Ambrisko cdb[3] = (u_int8_t)((start_blk >> 16) & 0xff); 1503665484d8SDoug Ambrisko cdb[2] = (u_int8_t)((start_blk >> 24) & 0xff); 1504665484d8SDoug Ambrisko break; 1505665484d8SDoug Ambrisko case 16: 1506665484d8SDoug Ambrisko cdb[9] = (u_int8_t)(start_blk & 0xff); 1507665484d8SDoug Ambrisko cdb[8] = (u_int8_t)((start_blk >> 8) & 0xff); 1508665484d8SDoug Ambrisko cdb[7] = (u_int8_t)((start_blk >> 16) & 0xff); 1509665484d8SDoug Ambrisko cdb[6] = (u_int8_t)((start_blk >> 24) & 0xff); 1510665484d8SDoug Ambrisko cdb[5] = (u_int8_t)((start_blk >> 32) & 0xff); 1511665484d8SDoug Ambrisko cdb[4] = (u_int8_t)((start_blk >> 40) & 0xff); 1512665484d8SDoug Ambrisko cdb[3] = (u_int8_t)((start_blk >> 48) & 0xff); 1513665484d8SDoug Ambrisko cdb[2] = (u_int8_t)((start_blk >> 56) & 0xff); 1514665484d8SDoug Ambrisko break; 1515665484d8SDoug Ambrisko } 1516665484d8SDoug Ambrisko } 1517665484d8SDoug Ambrisko } 1518665484d8SDoug Ambrisko 15198e727371SKashyap D Desai /* 152016dc2814SKashyap D Desai * mrsas_get_best_arm_pd: Determine the best spindle arm 152116dc2814SKashyap D Desai * Inputs: 152216dc2814SKashyap D Desai * sc - HBA instance 152316dc2814SKashyap D Desai * lbInfo - Load balance info 152416dc2814SKashyap D Desai * io_info - IO request info 1525665484d8SDoug Ambrisko * 1526665484d8SDoug Ambrisko * This function determines and returns the best arm by looking at the 1527665484d8SDoug Ambrisko * parameters of the last PD access. 1528665484d8SDoug Ambrisko */ 1529dbcc81dfSKashyap D Desai u_int8_t 1530dbcc81dfSKashyap D Desai mrsas_get_best_arm_pd(struct mrsas_softc *sc, 153116dc2814SKashyap D Desai PLD_LOAD_BALANCE_INFO lbInfo, struct IO_REQUEST_INFO *io_info) 1532665484d8SDoug Ambrisko { 153316dc2814SKashyap D Desai MR_LD_RAID *raid; 153416dc2814SKashyap D Desai MR_DRV_RAID_MAP_ALL *drv_map; 153516dc2814SKashyap D Desai u_int16_t pend0, pend1, ld; 1536665484d8SDoug Ambrisko u_int64_t diff0, diff1; 153716dc2814SKashyap D Desai u_int8_t bestArm, pd0, pd1, span, arm; 153816dc2814SKashyap D Desai u_int32_t arRef, span_row_size; 153916dc2814SKashyap D Desai 154016dc2814SKashyap D Desai u_int64_t block = io_info->ldStartBlock; 154116dc2814SKashyap D Desai u_int32_t count = io_info->numBlocks; 154216dc2814SKashyap D Desai 154316dc2814SKashyap D Desai span = ((io_info->span_arm & RAID_CTX_SPANARM_SPAN_MASK) 154416dc2814SKashyap D Desai >> RAID_CTX_SPANARM_SPAN_SHIFT); 154516dc2814SKashyap D Desai arm = (io_info->span_arm & RAID_CTX_SPANARM_ARM_MASK); 154616dc2814SKashyap D Desai 154716dc2814SKashyap D Desai drv_map = sc->ld_drv_map[(sc->map_id & 1)]; 154816dc2814SKashyap D Desai ld = MR_TargetIdToLdGet(io_info->ldTgtId, drv_map); 154916dc2814SKashyap D Desai raid = MR_LdRaidGet(ld, drv_map); 155016dc2814SKashyap D Desai span_row_size = sc->UnevenSpanSupport ? 155116dc2814SKashyap D Desai SPAN_ROW_SIZE(drv_map, ld, span) : raid->rowSize; 155216dc2814SKashyap D Desai 155316dc2814SKashyap D Desai arRef = MR_LdSpanArrayGet(ld, span, drv_map); 155416dc2814SKashyap D Desai pd0 = MR_ArPdGet(arRef, arm, drv_map); 155516dc2814SKashyap D Desai pd1 = MR_ArPdGet(arRef, (arm + 1) >= span_row_size ? 155616dc2814SKashyap D Desai (arm + 1 - span_row_size) : arm + 1, drv_map); 1557665484d8SDoug Ambrisko 1558665484d8SDoug Ambrisko /* get the pending cmds for the data and mirror arms */ 155916dc2814SKashyap D Desai pend0 = mrsas_atomic_read(&lbInfo->scsi_pending_cmds[pd0]); 156016dc2814SKashyap D Desai pend1 = mrsas_atomic_read(&lbInfo->scsi_pending_cmds[pd1]); 1561665484d8SDoug Ambrisko 1562665484d8SDoug Ambrisko /* Determine the disk whose head is nearer to the req. block */ 156316dc2814SKashyap D Desai diff0 = ABS_DIFF(block, lbInfo->last_accessed_block[pd0]); 156416dc2814SKashyap D Desai diff1 = ABS_DIFF(block, lbInfo->last_accessed_block[pd1]); 156516dc2814SKashyap D Desai bestArm = (diff0 <= diff1 ? arm : arm ^ 1); 1566665484d8SDoug Ambrisko 156716dc2814SKashyap D Desai if ((bestArm == arm && pend0 > pend1 + sc->lb_pending_cmds) || 156816dc2814SKashyap D Desai (bestArm != arm && pend1 > pend0 + sc->lb_pending_cmds)) 1569665484d8SDoug Ambrisko bestArm ^= 1; 1570665484d8SDoug Ambrisko 1571665484d8SDoug Ambrisko /* Update the last accessed block on the correct pd */ 157216dc2814SKashyap D Desai lbInfo->last_accessed_block[bestArm == arm ? pd0 : pd1] = block + count - 1; 157316dc2814SKashyap D Desai io_info->span_arm = (span << RAID_CTX_SPANARM_SPAN_SHIFT) | bestArm; 157416dc2814SKashyap D Desai io_info->pd_after_lb = (bestArm == arm) ? pd0 : pd1; 157516dc2814SKashyap D Desai #if SPAN_DEBUG 157616dc2814SKashyap D Desai if (arm != bestArm) 1577ecea5be4SKashyap D Desai printf("AVAGO Debug R1 Load balance occur - span 0x%x arm 0x%x bestArm 0x%x " 157816dc2814SKashyap D Desai "io_info->span_arm 0x%x\n", 157916dc2814SKashyap D Desai span, arm, bestArm, io_info->span_arm); 158016dc2814SKashyap D Desai #endif 1581665484d8SDoug Ambrisko 158216dc2814SKashyap D Desai return io_info->pd_after_lb; 1583665484d8SDoug Ambrisko } 1584665484d8SDoug Ambrisko 15858e727371SKashyap D Desai /* 15868e727371SKashyap D Desai * mrsas_get_updated_dev_handle: Get the update dev handle 158716dc2814SKashyap D Desai * Inputs: 158816dc2814SKashyap D Desai * sc - Adapter instance soft state 158916dc2814SKashyap D Desai * lbInfo - Load balance info 159016dc2814SKashyap D Desai * io_info - io_info pointer 1591665484d8SDoug Ambrisko * 1592665484d8SDoug Ambrisko * This function determines and returns the updated dev handle. 1593665484d8SDoug Ambrisko */ 1594dbcc81dfSKashyap D Desai u_int16_t 1595dbcc81dfSKashyap D Desai mrsas_get_updated_dev_handle(struct mrsas_softc *sc, 159616dc2814SKashyap D Desai PLD_LOAD_BALANCE_INFO lbInfo, struct IO_REQUEST_INFO *io_info) 1597665484d8SDoug Ambrisko { 159816dc2814SKashyap D Desai u_int8_t arm_pd; 1599665484d8SDoug Ambrisko u_int16_t devHandle; 160016dc2814SKashyap D Desai MR_DRV_RAID_MAP_ALL *drv_map; 1601665484d8SDoug Ambrisko 160216dc2814SKashyap D Desai drv_map = sc->ld_drv_map[(sc->map_id & 1)]; 1603665484d8SDoug Ambrisko 1604665484d8SDoug Ambrisko /* get best new arm */ 160516dc2814SKashyap D Desai arm_pd = mrsas_get_best_arm_pd(sc, lbInfo, io_info); 160616dc2814SKashyap D Desai devHandle = MR_PdDevHandleGet(arm_pd, drv_map); 160716dc2814SKashyap D Desai mrsas_atomic_inc(&lbInfo->scsi_pending_cmds[arm_pd]); 1608665484d8SDoug Ambrisko 1609665484d8SDoug Ambrisko return devHandle; 1610665484d8SDoug Ambrisko } 1611665484d8SDoug Ambrisko 16128e727371SKashyap D Desai /* 16138e727371SKashyap D Desai * MR_GetPhyParams: Calculates arm, span, and block 16148e727371SKashyap D Desai * Inputs: Adapter soft state 1615665484d8SDoug Ambrisko * Logical drive number (LD) 1616665484d8SDoug Ambrisko * Stripe number(stripRow) 1617665484d8SDoug Ambrisko * Reference in stripe (stripRef) 1618665484d8SDoug Ambrisko * 16198e727371SKashyap D Desai * Outputs: Absolute Block number in the physical disk 16208e727371SKashyap D Desai * 16218e727371SKashyap D Desai * This routine calculates the arm, span and block for the specified stripe and 16228e727371SKashyap D Desai * reference in stripe. 1623665484d8SDoug Ambrisko */ 16248e727371SKashyap D Desai u_int8_t 16258e727371SKashyap D Desai MR_GetPhyParams(struct mrsas_softc *sc, u_int32_t ld, 1626665484d8SDoug Ambrisko u_int64_t stripRow, 1627665484d8SDoug Ambrisko u_int16_t stripRef, struct IO_REQUEST_INFO *io_info, 16284799d485SKashyap D Desai RAID_CONTEXT * pRAID_Context, MR_DRV_RAID_MAP_ALL * map) 1629665484d8SDoug Ambrisko { 1630665484d8SDoug Ambrisko MR_LD_RAID *raid = MR_LdRaidGet(ld, map); 1631665484d8SDoug Ambrisko u_int32_t pd, arRef; 1632665484d8SDoug Ambrisko u_int8_t physArm, span; 1633665484d8SDoug Ambrisko u_int64_t row; 1634665484d8SDoug Ambrisko u_int8_t retval = TRUE; 1635665484d8SDoug Ambrisko int error_code = 0; 1636665484d8SDoug Ambrisko u_int64_t *pdBlock = &io_info->pdBlock; 1637665484d8SDoug Ambrisko u_int16_t *pDevHandle = &io_info->devHandle; 1638665484d8SDoug Ambrisko u_int32_t rowMod, armQ, arm, logArm; 1639665484d8SDoug Ambrisko 1640665484d8SDoug Ambrisko row = mega_div64_32(stripRow, raid->rowDataSize); 1641665484d8SDoug Ambrisko 1642665484d8SDoug Ambrisko if (raid->level == 6) { 16438e727371SKashyap D Desai /* logical arm within row */ 16448e727371SKashyap D Desai logArm = mega_mod64(stripRow, raid->rowDataSize); 1645665484d8SDoug Ambrisko if (raid->rowSize == 0) 1646665484d8SDoug Ambrisko return FALSE; 16478e727371SKashyap D Desai rowMod = mega_mod64(row, raid->rowSize); /* get logical row mod */ 16488e727371SKashyap D Desai armQ = raid->rowSize - 1 - rowMod; /* index of Q drive */ 16498e727371SKashyap D Desai arm = armQ + 1 + logArm;/* data always logically follows Q */ 16508e727371SKashyap D Desai if (arm >= raid->rowSize) /* handle wrap condition */ 1651665484d8SDoug Ambrisko arm -= raid->rowSize; 1652665484d8SDoug Ambrisko physArm = (u_int8_t)arm; 16538e727371SKashyap D Desai } else { 1654665484d8SDoug Ambrisko if (raid->modFactor == 0) 1655665484d8SDoug Ambrisko return FALSE; 1656665484d8SDoug Ambrisko physArm = MR_LdDataArmGet(ld, mega_mod64(stripRow, raid->modFactor), map); 1657665484d8SDoug Ambrisko } 1658665484d8SDoug Ambrisko 1659665484d8SDoug Ambrisko if (raid->spanDepth == 1) { 1660665484d8SDoug Ambrisko span = 0; 1661665484d8SDoug Ambrisko *pdBlock = row << raid->stripeShift; 16628e727371SKashyap D Desai } else { 1663665484d8SDoug Ambrisko span = (u_int8_t)MR_GetSpanBlock(ld, row, pdBlock, map, &error_code); 1664665484d8SDoug Ambrisko if (error_code == 1) 1665665484d8SDoug Ambrisko return FALSE; 1666665484d8SDoug Ambrisko } 1667665484d8SDoug Ambrisko 1668665484d8SDoug Ambrisko /* Get the array on which this span is present */ 1669665484d8SDoug Ambrisko arRef = MR_LdSpanArrayGet(ld, span, map); 1670665484d8SDoug Ambrisko 16718e727371SKashyap D Desai pd = MR_ArPdGet(arRef, physArm, map); /* Get the Pd. */ 1672665484d8SDoug Ambrisko 1673665484d8SDoug Ambrisko if (pd != MR_PD_INVALID) 16748e727371SKashyap D Desai /* Get dev handle from Pd */ 16758e727371SKashyap D Desai *pDevHandle = MR_PdDevHandleGet(pd, map); 1676665484d8SDoug Ambrisko else { 16778e727371SKashyap D Desai *pDevHandle = MR_PD_INVALID; /* set dev handle as invalid. */ 16787aade8bfSKashyap D Desai if ((raid->level >= 5) && ((sc->device_id == MRSAS_TBOLT) || 16797aade8bfSKashyap D Desai (sc->mrsas_gen3_ctrl && 1680665484d8SDoug Ambrisko raid->regTypeReqOnRead != REGION_TYPE_UNUSED))) 1681665484d8SDoug Ambrisko pRAID_Context->regLockFlags = REGION_TYPE_EXCLUSIVE; 1682665484d8SDoug Ambrisko else if (raid->level == 1) { 16838e727371SKashyap D Desai /* Get Alternate Pd. */ 16848e727371SKashyap D Desai pd = MR_ArPdGet(arRef, physArm + 1, map); 1685665484d8SDoug Ambrisko if (pd != MR_PD_INVALID) 16868e727371SKashyap D Desai /* Get dev handle from Pd. */ 16878e727371SKashyap D Desai *pDevHandle = MR_PdDevHandleGet(pd, map); 1688665484d8SDoug Ambrisko } 1689665484d8SDoug Ambrisko } 1690665484d8SDoug Ambrisko 1691665484d8SDoug Ambrisko *pdBlock += stripRef + MR_LdSpanPtrGet(ld, span, map)->startBlk; 1692*503c4f8dSKashyap D Desai if (sc->is_ventura) { 1693*503c4f8dSKashyap D Desai ((RAID_CONTEXT_G35 *) pRAID_Context)->spanArm = 1694*503c4f8dSKashyap D Desai (span << RAID_CTX_SPANARM_SPAN_SHIFT) | physArm; 1695*503c4f8dSKashyap D Desai io_info->span_arm = (span << RAID_CTX_SPANARM_SPAN_SHIFT) | physArm; 1696*503c4f8dSKashyap D Desai } else { 1697665484d8SDoug Ambrisko pRAID_Context->spanArm = (span << RAID_CTX_SPANARM_SPAN_SHIFT) | physArm; 169816dc2814SKashyap D Desai io_info->span_arm = pRAID_Context->spanArm; 1699*503c4f8dSKashyap D Desai } 1700665484d8SDoug Ambrisko return retval; 1701665484d8SDoug Ambrisko } 1702665484d8SDoug Ambrisko 17038e727371SKashyap D Desai /* 17048e727371SKashyap D Desai * MR_GetSpanBlock: Calculates span block 1705665484d8SDoug Ambrisko * Inputs: LD 17068e727371SKashyap D Desai * row PD 17078e727371SKashyap D Desai * span block 1708665484d8SDoug Ambrisko * RAID map pointer 17098e727371SKashyap D Desai * 17108e727371SKashyap D Desai * Outputs: Span number Error code 1711665484d8SDoug Ambrisko * 1712665484d8SDoug Ambrisko * This routine calculates the span from the span block info. 1713665484d8SDoug Ambrisko */ 17148e727371SKashyap D Desai u_int32_t 17158e727371SKashyap D Desai MR_GetSpanBlock(u_int32_t ld, u_int64_t row, u_int64_t *span_blk, 17164799d485SKashyap D Desai MR_DRV_RAID_MAP_ALL * map, int *div_error) 1717665484d8SDoug Ambrisko { 1718665484d8SDoug Ambrisko MR_SPAN_BLOCK_INFO *pSpanBlock = MR_LdSpanInfoGet(ld, map); 1719665484d8SDoug Ambrisko MR_QUAD_ELEMENT *quad; 1720665484d8SDoug Ambrisko MR_LD_RAID *raid = MR_LdRaidGet(ld, map); 1721665484d8SDoug Ambrisko u_int32_t span, j; 1722665484d8SDoug Ambrisko u_int64_t blk, debugBlk; 1723665484d8SDoug Ambrisko 1724665484d8SDoug Ambrisko for (span = 0; span < raid->spanDepth; span++, pSpanBlock++) { 1725665484d8SDoug Ambrisko for (j = 0; j < pSpanBlock->block_span_info.noElements; j++) { 1726665484d8SDoug Ambrisko quad = &pSpanBlock->block_span_info.quad[j]; 1727665484d8SDoug Ambrisko if (quad->diff == 0) { 1728665484d8SDoug Ambrisko *div_error = 1; 1729665484d8SDoug Ambrisko return span; 1730665484d8SDoug Ambrisko } 1731665484d8SDoug Ambrisko if (quad->logStart <= row && row <= quad->logEnd && 1732665484d8SDoug Ambrisko (mega_mod64(row - quad->logStart, quad->diff)) == 0) { 1733665484d8SDoug Ambrisko if (span_blk != NULL) { 1734665484d8SDoug Ambrisko blk = mega_div64_32((row - quad->logStart), quad->diff); 1735665484d8SDoug Ambrisko debugBlk = blk; 1736665484d8SDoug Ambrisko blk = (blk + quad->offsetInSpan) << raid->stripeShift; 1737665484d8SDoug Ambrisko *span_blk = blk; 1738665484d8SDoug Ambrisko } 1739665484d8SDoug Ambrisko return span; 1740665484d8SDoug Ambrisko } 1741665484d8SDoug Ambrisko } 1742665484d8SDoug Ambrisko } 1743665484d8SDoug Ambrisko return span; 1744665484d8SDoug Ambrisko } 1745