xref: /freebsd/sys/dev/mrsas/mrsas_fp.c (revision 503c4f8d7f544999106d8e5b1e505eace3ea0879)
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