1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * Linux MegaRAID driver for SAS based RAID controllers
5 * Copyright (c) 2009-2013 LSI Corporation
6 * Copyright (c) 2013-2016 Avago Technologies
7 * Copyright (c) 2016-2018 Broadcom Inc.
9 * FILE: megaraid_sas_fp.c
11 * Authors: Broadcom Inc.
15 * Kashyap Desai <kashyap.desai@broadcom.com>
16 * Sumit Saxena <sumit.saxena@broadcom.com>
18 * Send feedback to: megaraidlinux.pdl@broadcom.com
21 #include <linux/kernel.h>
22 #include <linux/types.h>
23 #include <linux/pci.h>
24 #include <linux/list.h>
25 #include <linux/moduleparam.h>
26 #include <linux/module.h>
27 #include <linux/spinlock.h>
28 #include <linux/interrupt.h>
29 #include <linux/delay.h>
30 #include <linux/uio.h>
31 #include <linux/uaccess.h>
33 #include <linux/compat.h>
34 #include <linux/blkdev.h>
35 #include <linux/poll.h>
36 #include <linux/irq_poll.h>
38 #include <scsi/scsi.h>
39 #include <scsi/scsi_cmnd.h>
40 #include <scsi/scsi_device.h>
41 #include <scsi/scsi_host.h>
43 #include "megaraid_sas_fusion.h"
44 #include "megaraid_sas.h"
45 #include <asm/div64.h>
47 #define LB_PENDING_CMDS_DEFAULT 4
48 static unsigned int lb_pending_cmds
= LB_PENDING_CMDS_DEFAULT
;
49 module_param(lb_pending_cmds
, int, 0444);
50 MODULE_PARM_DESC(lb_pending_cmds
, "Change raid-1 load balancing outstanding "
51 "threshold. Valid Values are 1-128. Default: 4");
54 #define ABS_DIFF(a, b) (((a) > (b)) ? ((a) - (b)) : ((b) - (a)))
55 #define MR_LD_STATE_OPTIMAL 3
57 #define SPAN_ROW_SIZE(map, ld, index_) (MR_LdSpanPtrGet(ld, index_, map)->spanRowSize)
58 #define SPAN_ROW_DATA_SIZE(map_, ld, index_) (MR_LdSpanPtrGet(ld, index_, map)->spanRowDataSize)
59 #define SPAN_INVALID 0xff
62 static void mr_update_span_set(struct MR_DRV_RAID_MAP_ALL
*map
,
63 PLD_SPAN_INFO ldSpanInfo
);
64 static u8
mr_spanset_get_phy_params(struct megasas_instance
*instance
, u32 ld
,
65 u64 stripRow
, u16 stripRef
, struct IO_REQUEST_INFO
*io_info
,
66 struct RAID_CONTEXT
*pRAID_Context
, struct MR_DRV_RAID_MAP_ALL
*map
);
67 static u64
get_row_from_strip(struct megasas_instance
*instance
, u32 ld
,
68 u64 strip
, struct MR_DRV_RAID_MAP_ALL
*map
);
70 u32
mega_mod64(u64 dividend
, u32 divisor
)
76 printk(KERN_ERR
"megasas : DIVISOR is zero, in div fn\n");
78 remainder
= do_div(d
, divisor
);
83 * @param dividend : Dividend
84 * @param divisor : Divisor
88 u64
mega_div64_32(uint64_t dividend
, uint32_t divisor
)
94 printk(KERN_ERR
"megasas : DIVISOR is zero in mod fn\n");
97 remainder
= do_div(d
, divisor
);
102 struct MR_LD_RAID
*MR_LdRaidGet(u32 ld
, struct MR_DRV_RAID_MAP_ALL
*map
)
104 return &map
->raidMap
.ldSpanMap
[ld
].ldRaid
;
107 static struct MR_SPAN_BLOCK_INFO
*MR_LdSpanInfoGet(u32 ld
,
108 struct MR_DRV_RAID_MAP_ALL
111 return &map
->raidMap
.ldSpanMap
[ld
].spanBlock
[0];
114 static u8
MR_LdDataArmGet(u32 ld
, u32 armIdx
, struct MR_DRV_RAID_MAP_ALL
*map
)
116 return map
->raidMap
.ldSpanMap
[ld
].dataArmMap
[armIdx
];
119 u16
MR_ArPdGet(u32 ar
, u32 arm
, struct MR_DRV_RAID_MAP_ALL
*map
)
121 return le16_to_cpu(map
->raidMap
.arMapInfo
[ar
].pd
[arm
]);
124 u16
MR_LdSpanArrayGet(u32 ld
, u32 span
, struct MR_DRV_RAID_MAP_ALL
*map
)
126 return le16_to_cpu(map
->raidMap
.ldSpanMap
[ld
].spanBlock
[span
].span
.arrayRef
);
129 __le16
MR_PdDevHandleGet(u32 pd
, struct MR_DRV_RAID_MAP_ALL
*map
)
131 return map
->raidMap
.devHndlInfo
[pd
].curDevHdl
;
134 static u8
MR_PdInterfaceTypeGet(u32 pd
, struct MR_DRV_RAID_MAP_ALL
*map
)
136 return map
->raidMap
.devHndlInfo
[pd
].interfaceType
;
139 u16
MR_GetLDTgtId(u32 ld
, struct MR_DRV_RAID_MAP_ALL
*map
)
141 return le16_to_cpu(map
->raidMap
.ldSpanMap
[ld
].ldRaid
.targetId
);
144 u16
MR_TargetIdToLdGet(u32 ldTgtId
, struct MR_DRV_RAID_MAP_ALL
*map
)
146 return map
->raidMap
.ldTgtIdToLd
[ldTgtId
];
149 static struct MR_LD_SPAN
*MR_LdSpanPtrGet(u32 ld
, u32 span
,
150 struct MR_DRV_RAID_MAP_ALL
*map
)
152 return &map
->raidMap
.ldSpanMap
[ld
].spanBlock
[span
].span
;
156 * This function will Populate Driver Map using firmware raid map
158 static int MR_PopulateDrvRaidMap(struct megasas_instance
*instance
, u64 map_id
)
160 struct fusion_context
*fusion
= instance
->ctrl_context
;
161 struct MR_FW_RAID_MAP_ALL
*fw_map_old
= NULL
;
162 struct MR_FW_RAID_MAP
*pFwRaidMap
= NULL
;
165 struct MR_FW_RAID_MAP_DYNAMIC
*fw_map_dyn
;
166 struct MR_FW_RAID_MAP_EXT
*fw_map_ext
;
167 struct MR_RAID_MAP_DESC_TABLE
*desc_table
;
170 struct MR_DRV_RAID_MAP_ALL
*drv_map
=
171 fusion
->ld_drv_map
[(map_id
& 1)];
172 struct MR_DRV_RAID_MAP
*pDrvRaidMap
= &drv_map
->raidMap
;
173 void *raid_map_data
= NULL
;
175 memset(drv_map
, 0, fusion
->drv_map_sz
);
176 memset(pDrvRaidMap
->ldTgtIdToLd
,
177 0xff, (sizeof(u16
) * MAX_LOGICAL_DRIVES_DYN
));
179 if (instance
->max_raid_mapsize
) {
180 fw_map_dyn
= fusion
->ld_map
[(map_id
& 1)];
182 (struct MR_RAID_MAP_DESC_TABLE
*)((void *)fw_map_dyn
+ le32_to_cpu(fw_map_dyn
->desc_table_offset
));
183 if (desc_table
!= fw_map_dyn
->raid_map_desc_table
)
184 dev_dbg(&instance
->pdev
->dev
, "offsets of desc table are not matching desc %p original %p\n",
185 desc_table
, fw_map_dyn
->raid_map_desc_table
);
187 ld_count
= (u16
)le16_to_cpu(fw_map_dyn
->ld_count
);
188 pDrvRaidMap
->ldCount
= (__le16
)cpu_to_le16(ld_count
);
189 pDrvRaidMap
->fpPdIoTimeoutSec
=
190 fw_map_dyn
->fp_pd_io_timeout_sec
;
191 pDrvRaidMap
->totalSize
=
192 cpu_to_le32(sizeof(struct MR_DRV_RAID_MAP_ALL
));
193 /* point to actual data starting point*/
194 raid_map_data
= (void *)fw_map_dyn
+
195 le32_to_cpu(fw_map_dyn
->desc_table_offset
) +
196 le32_to_cpu(fw_map_dyn
->desc_table_size
);
198 for (i
= 0; i
< le32_to_cpu(fw_map_dyn
->desc_table_num_elements
); ++i
) {
199 switch (le32_to_cpu(desc_table
->raid_map_desc_type
)) {
200 case RAID_MAP_DESC_TYPE_DEVHDL_INFO
:
201 fw_map_dyn
->dev_hndl_info
=
202 (struct MR_DEV_HANDLE_INFO
*)(raid_map_data
+ le32_to_cpu(desc_table
->raid_map_desc_offset
));
203 memcpy(pDrvRaidMap
->devHndlInfo
,
204 fw_map_dyn
->dev_hndl_info
,
205 sizeof(struct MR_DEV_HANDLE_INFO
) *
206 le32_to_cpu(desc_table
->raid_map_desc_elements
));
208 case RAID_MAP_DESC_TYPE_TGTID_INFO
:
209 fw_map_dyn
->ld_tgt_id_to_ld
=
210 (u16
*)(raid_map_data
+
211 le32_to_cpu(desc_table
->raid_map_desc_offset
));
212 for (j
= 0; j
< le32_to_cpu(desc_table
->raid_map_desc_elements
); j
++) {
213 pDrvRaidMap
->ldTgtIdToLd
[j
] =
214 le16_to_cpu(fw_map_dyn
->ld_tgt_id_to_ld
[j
]);
217 case RAID_MAP_DESC_TYPE_ARRAY_INFO
:
218 fw_map_dyn
->ar_map_info
=
219 (struct MR_ARRAY_INFO
*)
220 (raid_map_data
+ le32_to_cpu(desc_table
->raid_map_desc_offset
));
221 memcpy(pDrvRaidMap
->arMapInfo
,
222 fw_map_dyn
->ar_map_info
,
223 sizeof(struct MR_ARRAY_INFO
) *
224 le32_to_cpu(desc_table
->raid_map_desc_elements
));
226 case RAID_MAP_DESC_TYPE_SPAN_INFO
:
227 fw_map_dyn
->ld_span_map
=
228 (struct MR_LD_SPAN_MAP
*)
230 le32_to_cpu(desc_table
->raid_map_desc_offset
));
231 memcpy(pDrvRaidMap
->ldSpanMap
,
232 fw_map_dyn
->ld_span_map
,
233 sizeof(struct MR_LD_SPAN_MAP
) *
234 le32_to_cpu(desc_table
->raid_map_desc_elements
));
237 dev_dbg(&instance
->pdev
->dev
, "wrong number of desctableElements %d\n",
238 fw_map_dyn
->desc_table_num_elements
);
243 } else if (instance
->supportmax256vd
) {
245 (struct MR_FW_RAID_MAP_EXT
*)fusion
->ld_map
[(map_id
& 1)];
246 ld_count
= (u16
)le16_to_cpu(fw_map_ext
->ldCount
);
247 if (ld_count
> MAX_LOGICAL_DRIVES_EXT
) {
248 dev_dbg(&instance
->pdev
->dev
, "megaraid_sas: LD count exposed in RAID map in not valid\n");
252 pDrvRaidMap
->ldCount
= (__le16
)cpu_to_le16(ld_count
);
253 pDrvRaidMap
->fpPdIoTimeoutSec
= fw_map_ext
->fpPdIoTimeoutSec
;
254 for (i
= 0; i
< (MAX_LOGICAL_DRIVES_EXT
); i
++)
255 pDrvRaidMap
->ldTgtIdToLd
[i
] =
256 (u16
)fw_map_ext
->ldTgtIdToLd
[i
];
257 memcpy(pDrvRaidMap
->ldSpanMap
, fw_map_ext
->ldSpanMap
,
258 sizeof(struct MR_LD_SPAN_MAP
) * ld_count
);
259 memcpy(pDrvRaidMap
->arMapInfo
, fw_map_ext
->arMapInfo
,
260 sizeof(struct MR_ARRAY_INFO
) * MAX_API_ARRAYS_EXT
);
261 memcpy(pDrvRaidMap
->devHndlInfo
, fw_map_ext
->devHndlInfo
,
262 sizeof(struct MR_DEV_HANDLE_INFO
) *
263 MAX_RAIDMAP_PHYSICAL_DEVICES
);
265 /* New Raid map will not set totalSize, so keep expected value
266 * for legacy code in ValidateMapInfo
268 pDrvRaidMap
->totalSize
=
269 cpu_to_le32(sizeof(struct MR_FW_RAID_MAP_EXT
));
271 fw_map_old
= (struct MR_FW_RAID_MAP_ALL
*)
272 fusion
->ld_map
[(map_id
& 1)];
273 pFwRaidMap
= &fw_map_old
->raidMap
;
274 ld_count
= (u16
)le32_to_cpu(pFwRaidMap
->ldCount
);
275 if (ld_count
> MAX_LOGICAL_DRIVES
) {
276 dev_dbg(&instance
->pdev
->dev
,
277 "LD count exposed in RAID map in not valid\n");
281 pDrvRaidMap
->totalSize
= pFwRaidMap
->totalSize
;
282 pDrvRaidMap
->ldCount
= (__le16
)cpu_to_le16(ld_count
);
283 pDrvRaidMap
->fpPdIoTimeoutSec
= pFwRaidMap
->fpPdIoTimeoutSec
;
284 for (i
= 0; i
< MAX_RAIDMAP_LOGICAL_DRIVES
+ MAX_RAIDMAP_VIEWS
; i
++)
285 pDrvRaidMap
->ldTgtIdToLd
[i
] =
286 (u8
)pFwRaidMap
->ldTgtIdToLd
[i
];
287 for (i
= 0; i
< ld_count
; i
++) {
288 pDrvRaidMap
->ldSpanMap
[i
] = pFwRaidMap
->ldSpanMap
[i
];
290 memcpy(pDrvRaidMap
->arMapInfo
, pFwRaidMap
->arMapInfo
,
291 sizeof(struct MR_ARRAY_INFO
) * MAX_RAIDMAP_ARRAYS
);
292 memcpy(pDrvRaidMap
->devHndlInfo
, pFwRaidMap
->devHndlInfo
,
293 sizeof(struct MR_DEV_HANDLE_INFO
) *
294 MAX_RAIDMAP_PHYSICAL_DEVICES
);
301 * This function will validate Map info data provided by FW
303 u8
MR_ValidateMapInfo(struct megasas_instance
*instance
, u64 map_id
)
305 struct fusion_context
*fusion
;
306 struct MR_DRV_RAID_MAP_ALL
*drv_map
;
307 struct MR_DRV_RAID_MAP
*pDrvRaidMap
;
308 struct LD_LOAD_BALANCE_INFO
*lbInfo
;
309 PLD_SPAN_INFO ldSpanInfo
;
310 struct MR_LD_RAID
*raid
;
315 if (MR_PopulateDrvRaidMap(instance
, map_id
))
318 fusion
= instance
->ctrl_context
;
319 drv_map
= fusion
->ld_drv_map
[(map_id
& 1)];
320 pDrvRaidMap
= &drv_map
->raidMap
;
322 lbInfo
= fusion
->load_balance_info
;
323 ldSpanInfo
= fusion
->log_to_span
;
325 if (instance
->max_raid_mapsize
)
326 expected_size
= sizeof(struct MR_DRV_RAID_MAP_ALL
);
327 else if (instance
->supportmax256vd
)
328 expected_size
= sizeof(struct MR_FW_RAID_MAP_EXT
);
331 (sizeof(struct MR_FW_RAID_MAP
) - sizeof(struct MR_LD_SPAN_MAP
) +
332 (sizeof(struct MR_LD_SPAN_MAP
) * le16_to_cpu(pDrvRaidMap
->ldCount
)));
334 if (le32_to_cpu(pDrvRaidMap
->totalSize
) != expected_size
) {
335 dev_dbg(&instance
->pdev
->dev
, "megasas: map info structure size 0x%x",
336 le32_to_cpu(pDrvRaidMap
->totalSize
));
337 dev_dbg(&instance
->pdev
->dev
, "is not matching expected size 0x%x\n",
338 (unsigned int)expected_size
);
339 dev_err(&instance
->pdev
->dev
, "megasas: span map %x, pDrvRaidMap->totalSize : %x\n",
340 (unsigned int)sizeof(struct MR_LD_SPAN_MAP
),
341 le32_to_cpu(pDrvRaidMap
->totalSize
));
345 if (instance
->UnevenSpanSupport
)
346 mr_update_span_set(drv_map
, ldSpanInfo
);
349 mr_update_load_balance_params(drv_map
, lbInfo
);
351 num_lds
= le16_to_cpu(drv_map
->raidMap
.ldCount
);
353 /*Convert Raid capability values to CPU arch */
354 for (i
= 0; (num_lds
> 0) && (i
< MAX_LOGICAL_DRIVES_EXT
); i
++) {
355 ld
= MR_TargetIdToLdGet(i
, drv_map
);
357 /* For non existing VDs, iterate to next VD*/
358 if (ld
>= (MAX_LOGICAL_DRIVES_EXT
- 1))
361 raid
= MR_LdRaidGet(ld
, drv_map
);
362 le32_to_cpus((u32
*)&raid
->capability
);
370 u32
MR_GetSpanBlock(u32 ld
, u64 row
, u64
*span_blk
,
371 struct MR_DRV_RAID_MAP_ALL
*map
)
373 struct MR_SPAN_BLOCK_INFO
*pSpanBlock
= MR_LdSpanInfoGet(ld
, map
);
374 struct MR_QUAD_ELEMENT
*quad
;
375 struct MR_LD_RAID
*raid
= MR_LdRaidGet(ld
, map
);
378 for (span
= 0; span
< raid
->spanDepth
; span
++, pSpanBlock
++) {
380 for (j
= 0; j
< le32_to_cpu(pSpanBlock
->block_span_info
.noElements
); j
++) {
381 quad
= &pSpanBlock
->block_span_info
.quad
[j
];
383 if (le32_to_cpu(quad
->diff
) == 0)
385 if (le64_to_cpu(quad
->logStart
) <= row
&& row
<=
386 le64_to_cpu(quad
->logEnd
) && (mega_mod64(row
- le64_to_cpu(quad
->logStart
),
387 le32_to_cpu(quad
->diff
))) == 0) {
388 if (span_blk
!= NULL
) {
390 blk
= mega_div64_32((row
-le64_to_cpu(quad
->logStart
)), le32_to_cpu(quad
->diff
));
393 blk
= (blk
+ le64_to_cpu(quad
->offsetInSpan
)) << raid
->stripeShift
;
404 ******************************************************************************
406 * This routine calculates the Span block for given row using spanset.
409 * instance - HBA instance
410 * ld - Logical drive number
417 * block - Absolute Block number in the physical disk
418 * div_error - Devide error code.
421 u32
mr_spanset_get_span_block(struct megasas_instance
*instance
,
422 u32 ld
, u64 row
, u64
*span_blk
, struct MR_DRV_RAID_MAP_ALL
*map
)
424 struct fusion_context
*fusion
= instance
->ctrl_context
;
425 struct MR_LD_RAID
*raid
= MR_LdRaidGet(ld
, map
);
426 LD_SPAN_SET
*span_set
;
427 struct MR_QUAD_ELEMENT
*quad
;
429 PLD_SPAN_INFO ldSpanInfo
= fusion
->log_to_span
;
431 for (info
= 0; info
< MAX_QUAD_DEPTH
; info
++) {
432 span_set
= &(ldSpanInfo
[ld
].span_set
[info
]);
434 if (span_set
->span_row_data_width
== 0)
437 if (row
> span_set
->data_row_end
)
440 for (span
= 0; span
< raid
->spanDepth
; span
++)
441 if (le32_to_cpu(map
->raidMap
.ldSpanMap
[ld
].spanBlock
[span
].
442 block_span_info
.noElements
) >= info
+1) {
443 quad
= &map
->raidMap
.ldSpanMap
[ld
].
445 block_span_info
.quad
[info
];
446 if (le32_to_cpu(quad
->diff
) == 0)
448 if (le64_to_cpu(quad
->logStart
) <= row
&&
449 row
<= le64_to_cpu(quad
->logEnd
) &&
450 (mega_mod64(row
- le64_to_cpu(quad
->logStart
),
451 le32_to_cpu(quad
->diff
))) == 0) {
452 if (span_blk
!= NULL
) {
455 ((row
- le64_to_cpu(quad
->logStart
)),
456 le32_to_cpu(quad
->diff
));
457 blk
= (blk
+ le64_to_cpu(quad
->offsetInSpan
))
458 << raid
->stripeShift
;
469 ******************************************************************************
471 * This routine calculates the row for given strip using spanset.
474 * instance - HBA instance
475 * ld - Logical drive number
481 * row - row associated with strip
484 static u64
get_row_from_strip(struct megasas_instance
*instance
,
485 u32 ld
, u64 strip
, struct MR_DRV_RAID_MAP_ALL
*map
)
487 struct fusion_context
*fusion
= instance
->ctrl_context
;
488 struct MR_LD_RAID
*raid
= MR_LdRaidGet(ld
, map
);
489 LD_SPAN_SET
*span_set
;
490 PLD_SPAN_INFO ldSpanInfo
= fusion
->log_to_span
;
491 u32 info
, strip_offset
, span
, span_offset
;
492 u64 span_set_Strip
, span_set_Row
, retval
;
494 for (info
= 0; info
< MAX_QUAD_DEPTH
; info
++) {
495 span_set
= &(ldSpanInfo
[ld
].span_set
[info
]);
497 if (span_set
->span_row_data_width
== 0)
499 if (strip
> span_set
->data_strip_end
)
502 span_set_Strip
= strip
- span_set
->data_strip_start
;
503 strip_offset
= mega_mod64(span_set_Strip
,
504 span_set
->span_row_data_width
);
505 span_set_Row
= mega_div64_32(span_set_Strip
,
506 span_set
->span_row_data_width
) * span_set
->diff
;
507 for (span
= 0, span_offset
= 0; span
< raid
->spanDepth
; span
++)
508 if (le32_to_cpu(map
->raidMap
.ldSpanMap
[ld
].spanBlock
[span
].
509 block_span_info
.noElements
) >= info
+1) {
511 span_set
->strip_offset
[span
])
517 retval
= (span_set
->data_row_start
+ span_set_Row
+
526 ******************************************************************************
528 * This routine calculates the Start Strip for given row using spanset.
531 * instance - HBA instance
532 * ld - Logical drive number
538 * Strip - Start strip associated with row
541 static u64
get_strip_from_row(struct megasas_instance
*instance
,
542 u32 ld
, u64 row
, struct MR_DRV_RAID_MAP_ALL
*map
)
544 struct fusion_context
*fusion
= instance
->ctrl_context
;
545 struct MR_LD_RAID
*raid
= MR_LdRaidGet(ld
, map
);
546 LD_SPAN_SET
*span_set
;
547 struct MR_QUAD_ELEMENT
*quad
;
548 PLD_SPAN_INFO ldSpanInfo
= fusion
->log_to_span
;
552 for (info
= 0; info
< MAX_QUAD_DEPTH
; info
++) {
553 span_set
= &(ldSpanInfo
[ld
].span_set
[info
]);
555 if (span_set
->span_row_data_width
== 0)
557 if (row
> span_set
->data_row_end
)
560 for (span
= 0; span
< raid
->spanDepth
; span
++)
561 if (le32_to_cpu(map
->raidMap
.ldSpanMap
[ld
].spanBlock
[span
].
562 block_span_info
.noElements
) >= info
+1) {
563 quad
= &map
->raidMap
.ldSpanMap
[ld
].
564 spanBlock
[span
].block_span_info
.quad
[info
];
565 if (le64_to_cpu(quad
->logStart
) <= row
&&
566 row
<= le64_to_cpu(quad
->logEnd
) &&
567 mega_mod64((row
- le64_to_cpu(quad
->logStart
)),
568 le32_to_cpu(quad
->diff
)) == 0) {
569 strip
= mega_div64_32
570 (((row
- span_set
->data_row_start
)
571 - le64_to_cpu(quad
->logStart
)),
572 le32_to_cpu(quad
->diff
));
573 strip
*= span_set
->span_row_data_width
;
574 strip
+= span_set
->data_strip_start
;
575 strip
+= span_set
->strip_offset
[span
];
580 dev_err(&instance
->pdev
->dev
, "get_strip_from_row"
581 "returns invalid strip for ld=%x, row=%lx\n",
582 ld
, (long unsigned int)row
);
587 ******************************************************************************
589 * This routine calculates the Physical Arm for given strip using spanset.
592 * instance - HBA instance
593 * ld - Logical drive number
599 * Phys Arm - Phys Arm associated with strip
602 static u32
get_arm_from_strip(struct megasas_instance
*instance
,
603 u32 ld
, u64 strip
, struct MR_DRV_RAID_MAP_ALL
*map
)
605 struct fusion_context
*fusion
= instance
->ctrl_context
;
606 struct MR_LD_RAID
*raid
= MR_LdRaidGet(ld
, map
);
607 LD_SPAN_SET
*span_set
;
608 PLD_SPAN_INFO ldSpanInfo
= fusion
->log_to_span
;
609 u32 info
, strip_offset
, span
, span_offset
, retval
;
611 for (info
= 0 ; info
< MAX_QUAD_DEPTH
; info
++) {
612 span_set
= &(ldSpanInfo
[ld
].span_set
[info
]);
614 if (span_set
->span_row_data_width
== 0)
616 if (strip
> span_set
->data_strip_end
)
619 strip_offset
= (uint
)mega_mod64
620 ((strip
- span_set
->data_strip_start
),
621 span_set
->span_row_data_width
);
623 for (span
= 0, span_offset
= 0; span
< raid
->spanDepth
; span
++)
624 if (le32_to_cpu(map
->raidMap
.ldSpanMap
[ld
].spanBlock
[span
].
625 block_span_info
.noElements
) >= info
+1) {
627 span_set
->strip_offset
[span
])
629 span_set
->strip_offset
[span
];
634 retval
= (strip_offset
- span_offset
);
638 dev_err(&instance
->pdev
->dev
, "get_arm_from_strip"
639 "returns invalid arm for ld=%x strip=%lx\n",
640 ld
, (long unsigned int)strip
);
645 /* This Function will return Phys arm */
646 u8
get_arm(struct megasas_instance
*instance
, u32 ld
, u8 span
, u64 stripe
,
647 struct MR_DRV_RAID_MAP_ALL
*map
)
649 struct MR_LD_RAID
*raid
= MR_LdRaidGet(ld
, map
);
650 /* Need to check correct default value */
653 switch (raid
->level
) {
657 arm
= mega_mod64(stripe
, SPAN_ROW_SIZE(map
, ld
, span
));
660 /* start with logical arm */
661 arm
= get_arm_from_strip(instance
, ld
, stripe
, map
);
672 ******************************************************************************
674 * This routine calculates the arm, span and block for the specified stripe and
675 * reference in stripe using spanset
679 * ld - Logical drive number
680 * stripRow - Stripe number
681 * stripRef - Reference in stripe
686 * block - Absolute Block number in the physical disk
688 static u8
mr_spanset_get_phy_params(struct megasas_instance
*instance
, u32 ld
,
689 u64 stripRow
, u16 stripRef
, struct IO_REQUEST_INFO
*io_info
,
690 struct RAID_CONTEXT
*pRAID_Context
,
691 struct MR_DRV_RAID_MAP_ALL
*map
)
693 struct MR_LD_RAID
*raid
= MR_LdRaidGet(ld
, map
);
694 u32 pd
, arRef
, r1_alt_pd
;
698 u64
*pdBlock
= &io_info
->pdBlock
;
699 __le16
*pDevHandle
= &io_info
->devHandle
;
700 u8
*pPdInterface
= &io_info
->pd_interface
;
701 u32 logArm
, rowMod
, armQ
, arm
;
702 struct fusion_context
*fusion
;
704 fusion
= instance
->ctrl_context
;
705 *pDevHandle
= cpu_to_le16(MR_DEVHANDLE_INVALID
);
707 /*Get row and span from io_info for Uneven Span IO.*/
708 row
= io_info
->start_row
;
709 span
= io_info
->start_span
;
712 if (raid
->level
== 6) {
713 logArm
= get_arm_from_strip(instance
, ld
, stripRow
, map
);
716 rowMod
= mega_mod64(row
, SPAN_ROW_SIZE(map
, ld
, span
));
717 armQ
= SPAN_ROW_SIZE(map
, ld
, span
) - 1 - rowMod
;
718 arm
= armQ
+ 1 + logArm
;
719 if (arm
>= SPAN_ROW_SIZE(map
, ld
, span
))
720 arm
-= SPAN_ROW_SIZE(map
, ld
, span
);
723 /* Calculate the arm */
724 physArm
= get_arm(instance
, ld
, span
, stripRow
, map
);
728 arRef
= MR_LdSpanArrayGet(ld
, span
, map
);
729 pd
= MR_ArPdGet(arRef
, physArm
, map
);
731 if (pd
!= MR_PD_INVALID
) {
732 *pDevHandle
= MR_PdDevHandleGet(pd
, map
);
733 *pPdInterface
= MR_PdInterfaceTypeGet(pd
, map
);
734 /* get second pd also for raid 1/10 fast path writes*/
735 if ((instance
->adapter_type
>= VENTURA_SERIES
) &&
736 (raid
->level
== 1) &&
738 r1_alt_pd
= MR_ArPdGet(arRef
, physArm
+ 1, map
);
739 if (r1_alt_pd
!= MR_PD_INVALID
)
740 io_info
->r1_alt_dev_handle
=
741 MR_PdDevHandleGet(r1_alt_pd
, map
);
744 if ((raid
->level
>= 5) &&
745 ((instance
->adapter_type
== THUNDERBOLT_SERIES
) ||
746 ((instance
->adapter_type
== INVADER_SERIES
) &&
747 (raid
->regTypeReqOnRead
!= REGION_TYPE_UNUSED
))))
748 pRAID_Context
->reg_lock_flags
= REGION_TYPE_EXCLUSIVE
;
749 else if (raid
->level
== 1) {
750 physArm
= physArm
+ 1;
751 pd
= MR_ArPdGet(arRef
, physArm
, map
);
752 if (pd
!= MR_PD_INVALID
) {
753 *pDevHandle
= MR_PdDevHandleGet(pd
, map
);
754 *pPdInterface
= MR_PdInterfaceTypeGet(pd
, map
);
759 *pdBlock
+= stripRef
+ le64_to_cpu(MR_LdSpanPtrGet(ld
, span
, map
)->startBlk
);
760 if (instance
->adapter_type
>= VENTURA_SERIES
) {
761 ((struct RAID_CONTEXT_G35
*)pRAID_Context
)->span_arm
=
762 (span
<< RAID_CTX_SPANARM_SPAN_SHIFT
) | physArm
;
764 (span
<< RAID_CTX_SPANARM_SPAN_SHIFT
) | physArm
;
766 pRAID_Context
->span_arm
=
767 (span
<< RAID_CTX_SPANARM_SPAN_SHIFT
) | physArm
;
768 io_info
->span_arm
= pRAID_Context
->span_arm
;
770 io_info
->pd_after_lb
= pd
;
775 ******************************************************************************
777 * This routine calculates the arm, span and block for the specified stripe and
778 * reference in stripe.
782 * ld - Logical drive number
783 * stripRow - Stripe number
784 * stripRef - Reference in stripe
789 * block - Absolute Block number in the physical disk
791 u8
MR_GetPhyParams(struct megasas_instance
*instance
, u32 ld
, u64 stripRow
,
792 u16 stripRef
, struct IO_REQUEST_INFO
*io_info
,
793 struct RAID_CONTEXT
*pRAID_Context
,
794 struct MR_DRV_RAID_MAP_ALL
*map
)
796 struct MR_LD_RAID
*raid
= MR_LdRaidGet(ld
, map
);
797 u32 pd
, arRef
, r1_alt_pd
;
801 u64
*pdBlock
= &io_info
->pdBlock
;
802 __le16
*pDevHandle
= &io_info
->devHandle
;
803 u8
*pPdInterface
= &io_info
->pd_interface
;
804 struct fusion_context
*fusion
;
806 fusion
= instance
->ctrl_context
;
807 *pDevHandle
= cpu_to_le16(MR_DEVHANDLE_INVALID
);
809 row
= mega_div64_32(stripRow
, raid
->rowDataSize
);
811 if (raid
->level
== 6) {
812 /* logical arm within row */
813 u32 logArm
= mega_mod64(stripRow
, raid
->rowDataSize
);
814 u32 rowMod
, armQ
, arm
;
816 if (raid
->rowSize
== 0)
818 /* get logical row mod */
819 rowMod
= mega_mod64(row
, raid
->rowSize
);
820 armQ
= raid
->rowSize
-1-rowMod
; /* index of Q drive */
821 arm
= armQ
+1+logArm
; /* data always logically follows Q */
822 if (arm
>= raid
->rowSize
) /* handle wrap condition */
823 arm
-= raid
->rowSize
;
826 if (raid
->modFactor
== 0)
828 physArm
= MR_LdDataArmGet(ld
, mega_mod64(stripRow
,
833 if (raid
->spanDepth
== 1) {
835 *pdBlock
= row
<< raid
->stripeShift
;
837 span
= (u8
)MR_GetSpanBlock(ld
, row
, pdBlock
, map
);
838 if (span
== SPAN_INVALID
)
842 /* Get the array on which this span is present */
843 arRef
= MR_LdSpanArrayGet(ld
, span
, map
);
844 pd
= MR_ArPdGet(arRef
, physArm
, map
); /* Get the pd */
846 if (pd
!= MR_PD_INVALID
) {
847 /* Get dev handle from Pd. */
848 *pDevHandle
= MR_PdDevHandleGet(pd
, map
);
849 *pPdInterface
= MR_PdInterfaceTypeGet(pd
, map
);
850 /* get second pd also for raid 1/10 fast path writes*/
851 if ((instance
->adapter_type
>= VENTURA_SERIES
) &&
852 (raid
->level
== 1) &&
854 r1_alt_pd
= MR_ArPdGet(arRef
, physArm
+ 1, map
);
855 if (r1_alt_pd
!= MR_PD_INVALID
)
856 io_info
->r1_alt_dev_handle
=
857 MR_PdDevHandleGet(r1_alt_pd
, map
);
860 if ((raid
->level
>= 5) &&
861 ((instance
->adapter_type
== THUNDERBOLT_SERIES
) ||
862 ((instance
->adapter_type
== INVADER_SERIES
) &&
863 (raid
->regTypeReqOnRead
!= REGION_TYPE_UNUSED
))))
864 pRAID_Context
->reg_lock_flags
= REGION_TYPE_EXCLUSIVE
;
865 else if (raid
->level
== 1) {
866 /* Get alternate Pd. */
867 physArm
= physArm
+ 1;
868 pd
= MR_ArPdGet(arRef
, physArm
, map
);
869 if (pd
!= MR_PD_INVALID
) {
870 /* Get dev handle from Pd */
871 *pDevHandle
= MR_PdDevHandleGet(pd
, map
);
872 *pPdInterface
= MR_PdInterfaceTypeGet(pd
, map
);
877 *pdBlock
+= stripRef
+ le64_to_cpu(MR_LdSpanPtrGet(ld
, span
, map
)->startBlk
);
878 if (instance
->adapter_type
>= VENTURA_SERIES
) {
879 ((struct RAID_CONTEXT_G35
*)pRAID_Context
)->span_arm
=
880 (span
<< RAID_CTX_SPANARM_SPAN_SHIFT
) | physArm
;
882 (span
<< RAID_CTX_SPANARM_SPAN_SHIFT
) | physArm
;
884 pRAID_Context
->span_arm
=
885 (span
<< RAID_CTX_SPANARM_SPAN_SHIFT
) | physArm
;
886 io_info
->span_arm
= pRAID_Context
->span_arm
;
888 io_info
->pd_after_lb
= pd
;
893 * mr_get_phy_params_r56_rmw - Calculate parameters for R56 CTIO write operation
894 * @instance: Adapter soft state
896 * @stripNo: Strip Number
897 * @io_info: IO info structure pointer
898 * pRAID_Context: RAID context pointer
899 * map: RAID map pointer
901 * This routine calculates the logical arm, data Arm, row number and parity arm
902 * for R56 CTIO write operation.
904 static void mr_get_phy_params_r56_rmw(struct megasas_instance
*instance
,
906 struct IO_REQUEST_INFO
*io_info
,
907 struct RAID_CONTEXT_G35
*pRAID_Context
,
908 struct MR_DRV_RAID_MAP_ALL
*map
)
910 struct MR_LD_RAID
*raid
= MR_LdRaidGet(ld
, map
);
911 u8 span
, dataArms
, arms
, dataArm
, logArm
;
912 s8 rightmostParityArm
, PParityArm
;
914 u64
*pdBlock
= &io_info
->pdBlock
;
916 dataArms
= raid
->rowDataSize
;
917 arms
= raid
->rowSize
;
919 rowNum
= mega_div64_32(stripNo
, dataArms
);
920 /* parity disk arm, first arm is 0 */
921 rightmostParityArm
= (arms
- 1) - mega_mod64(rowNum
, arms
);
923 /* logical arm within row */
924 logArm
= mega_mod64(stripNo
, dataArms
);
925 /* physical arm for data */
926 dataArm
= mega_mod64((rightmostParityArm
+ 1 + logArm
), arms
);
928 if (raid
->spanDepth
== 1) {
931 span
= (u8
)MR_GetSpanBlock(ld
, rowNum
, pdBlock
, map
);
932 if (span
== SPAN_INVALID
)
936 if (raid
->level
== 6) {
937 /* P Parity arm, note this can go negative adjust if negative */
938 PParityArm
= (arms
- 2) - mega_mod64(rowNum
, arms
);
943 /* rightmostParityArm is P-Parity for RAID 5 and Q-Parity for RAID */
944 pRAID_Context
->flow_specific
.r56_arm_map
= rightmostParityArm
;
945 pRAID_Context
->flow_specific
.r56_arm_map
|=
946 (u16
)(PParityArm
<< RAID_CTX_R56_P_ARM_SHIFT
);
948 pRAID_Context
->flow_specific
.r56_arm_map
|=
949 (u16
)(rightmostParityArm
<< RAID_CTX_R56_P_ARM_SHIFT
);
952 pRAID_Context
->reg_lock_row_lba
= cpu_to_le64(rowNum
);
953 pRAID_Context
->flow_specific
.r56_arm_map
|=
954 (u16
)(logArm
<< RAID_CTX_R56_LOG_ARM_SHIFT
);
955 cpu_to_le16s(&pRAID_Context
->flow_specific
.r56_arm_map
);
956 pRAID_Context
->span_arm
= (span
<< RAID_CTX_SPANARM_SPAN_SHIFT
) | dataArm
;
957 pRAID_Context
->raid_flags
= (MR_RAID_FLAGS_IO_SUB_TYPE_R56_DIV_OFFLOAD
<<
958 MR_RAID_CTX_RAID_FLAGS_IO_SUB_TYPE_SHIFT
);
964 ******************************************************************************
966 * MR_BuildRaidContext function
968 * This function will initiate command processing. The start/end row and strip
969 * information is calculated then the lock is acquired.
970 * This function will return 0 if region lock was acquired OR return num strips
973 MR_BuildRaidContext(struct megasas_instance
*instance
,
974 struct IO_REQUEST_INFO
*io_info
,
975 struct RAID_CONTEXT
*pRAID_Context
,
976 struct MR_DRV_RAID_MAP_ALL
*map
, u8
**raidLUN
)
978 struct fusion_context
*fusion
;
979 struct MR_LD_RAID
*raid
;
980 u32 stripSize
, stripe_mask
;
981 u64 endLba
, endStrip
, endRow
, start_row
, start_strip
;
984 u8 num_strips
, numRows
;
985 u16 ref_in_start_stripe
, ref_in_end_stripe
;
987 u32 numBlocks
, ldTgtId
;
990 u8 startlba_span
= SPAN_INVALID
;
991 u64
*pdBlock
= &io_info
->pdBlock
;
994 ldStartBlock
= io_info
->ldStartBlock
;
995 numBlocks
= io_info
->numBlocks
;
996 ldTgtId
= io_info
->ldTgtId
;
997 isRead
= io_info
->isRead
;
998 io_info
->IoforUnevenSpan
= 0;
999 io_info
->start_span
= SPAN_INVALID
;
1000 fusion
= instance
->ctrl_context
;
1002 ld
= MR_TargetIdToLdGet(ldTgtId
, map
);
1003 raid
= MR_LdRaidGet(ld
, map
);
1004 /*check read ahead bit*/
1005 io_info
->ra_capable
= raid
->capability
.ra_capable
;
1008 * if rowDataSize @RAID map and spanRowDataSize @SPAN INFO are zero
1011 if (raid
->rowDataSize
== 0) {
1012 if (MR_LdSpanPtrGet(ld
, 0, map
)->spanRowDataSize
== 0)
1014 else if (instance
->UnevenSpanSupport
) {
1015 io_info
->IoforUnevenSpan
= 1;
1017 dev_info(&instance
->pdev
->dev
,
1018 "raid->rowDataSize is 0, but has SPAN[0]"
1019 "rowDataSize = 0x%0x,"
1020 "but there is _NO_ UnevenSpanSupport\n",
1021 MR_LdSpanPtrGet(ld
, 0, map
)->spanRowDataSize
);
1026 stripSize
= 1 << raid
->stripeShift
;
1027 stripe_mask
= stripSize
-1;
1029 io_info
->data_arms
= raid
->rowDataSize
;
1032 * calculate starting row and stripe, and number of strips and rows
1034 start_strip
= ldStartBlock
>> raid
->stripeShift
;
1035 ref_in_start_stripe
= (u16
)(ldStartBlock
& stripe_mask
);
1036 endLba
= ldStartBlock
+ numBlocks
- 1;
1037 ref_in_end_stripe
= (u16
)(endLba
& stripe_mask
);
1038 endStrip
= endLba
>> raid
->stripeShift
;
1039 num_strips
= (u8
)(endStrip
- start_strip
+ 1); /* End strip */
1041 if (io_info
->IoforUnevenSpan
) {
1042 start_row
= get_row_from_strip(instance
, ld
, start_strip
, map
);
1043 endRow
= get_row_from_strip(instance
, ld
, endStrip
, map
);
1044 if (start_row
== -1ULL || endRow
== -1ULL) {
1045 dev_info(&instance
->pdev
->dev
, "return from %s %d."
1046 "Send IO w/o region lock.\n",
1047 __func__
, __LINE__
);
1051 if (raid
->spanDepth
== 1) {
1053 *pdBlock
= start_row
<< raid
->stripeShift
;
1055 startlba_span
= (u8
)mr_spanset_get_span_block(instance
,
1056 ld
, start_row
, pdBlock
, map
);
1057 if (startlba_span
== SPAN_INVALID
) {
1058 dev_info(&instance
->pdev
->dev
, "return from %s %d"
1059 "for row 0x%llx,start strip %llx"
1060 "endSrip %llx\n", __func__
, __LINE__
,
1061 (unsigned long long)start_row
,
1062 (unsigned long long)start_strip
,
1063 (unsigned long long)endStrip
);
1066 io_info
->start_span
= startlba_span
;
1067 io_info
->start_row
= start_row
;
1069 start_row
= mega_div64_32(start_strip
, raid
->rowDataSize
);
1070 endRow
= mega_div64_32(endStrip
, raid
->rowDataSize
);
1072 numRows
= (u8
)(endRow
- start_row
+ 1);
1075 * calculate region info.
1078 /* assume region is at the start of the first row */
1079 regStart
= start_row
<< raid
->stripeShift
;
1080 /* assume this IO needs the full row - we'll adjust if not true */
1081 regSize
= stripSize
;
1083 io_info
->do_fp_rlbypass
= raid
->capability
.fpBypassRegionLock
;
1085 /* Check if we can send this I/O via FastPath */
1086 if (raid
->capability
.fpCapable
) {
1088 io_info
->fpOkForIo
= (raid
->capability
.fpReadCapable
&&
1089 ((num_strips
== 1) ||
1091 fpReadAcrossStripe
));
1093 io_info
->fpOkForIo
= (raid
->capability
.fpWriteCapable
&&
1094 ((num_strips
== 1) ||
1096 fpWriteAcrossStripe
));
1098 io_info
->fpOkForIo
= false;
1101 /* single-strip IOs can always lock only the data needed */
1102 if (num_strips
== 1) {
1103 regStart
+= ref_in_start_stripe
;
1104 regSize
= numBlocks
;
1106 /* multi-strip IOs always need to full stripe locked */
1107 } else if (io_info
->IoforUnevenSpan
== 0) {
1109 * For Even span region lock optimization.
1110 * If the start strip is the last in the start row
1112 if (start_strip
== (start_row
+ 1) * raid
->rowDataSize
- 1) {
1113 regStart
+= ref_in_start_stripe
;
1114 /* initialize count to sectors from startref to end
1116 regSize
= stripSize
- ref_in_start_stripe
;
1119 /* add complete rows in the middle of the transfer */
1121 regSize
+= (numRows
-2) << raid
->stripeShift
;
1123 /* if IO ends within first strip of last row*/
1124 if (endStrip
== endRow
*raid
->rowDataSize
)
1125 regSize
+= ref_in_end_stripe
+1;
1127 regSize
+= stripSize
;
1130 * For Uneven span region lock optimization.
1131 * If the start strip is the last in the start row
1133 if (start_strip
== (get_strip_from_row(instance
, ld
, start_row
, map
) +
1134 SPAN_ROW_DATA_SIZE(map
, ld
, startlba_span
) - 1)) {
1135 regStart
+= ref_in_start_stripe
;
1136 /* initialize count to sectors from
1137 * startRef to end of strip
1139 regSize
= stripSize
- ref_in_start_stripe
;
1141 /* Add complete rows in the middle of the transfer*/
1144 /* Add complete rows in the middle of the transfer*/
1145 regSize
+= (numRows
-2) << raid
->stripeShift
;
1147 /* if IO ends within first strip of last row */
1148 if (endStrip
== get_strip_from_row(instance
, ld
, endRow
, map
))
1149 regSize
+= ref_in_end_stripe
+ 1;
1151 regSize
+= stripSize
;
1154 pRAID_Context
->timeout_value
=
1155 cpu_to_le16(raid
->fpIoTimeoutForLd
?
1156 raid
->fpIoTimeoutForLd
:
1157 map
->raidMap
.fpPdIoTimeoutSec
);
1158 if (instance
->adapter_type
== INVADER_SERIES
)
1159 pRAID_Context
->reg_lock_flags
= (isRead
) ?
1160 raid
->regTypeReqOnRead
: raid
->regTypeReqOnWrite
;
1161 else if (instance
->adapter_type
== THUNDERBOLT_SERIES
)
1162 pRAID_Context
->reg_lock_flags
= (isRead
) ?
1163 REGION_TYPE_SHARED_READ
: raid
->regTypeReqOnWrite
;
1164 pRAID_Context
->virtual_disk_tgt_id
= raid
->targetId
;
1165 pRAID_Context
->reg_lock_row_lba
= cpu_to_le64(regStart
);
1166 pRAID_Context
->reg_lock_length
= cpu_to_le32(regSize
);
1167 pRAID_Context
->config_seq_num
= raid
->seqNum
;
1168 /* save pointer to raid->LUN array */
1169 *raidLUN
= raid
->LUN
;
1171 /* Aero R5/6 Division Offload for WRITE */
1172 if (fusion
->r56_div_offload
&& (raid
->level
>= 5) && !isRead
) {
1173 mr_get_phy_params_r56_rmw(instance
, ld
, start_strip
, io_info
,
1174 (struct RAID_CONTEXT_G35
*)pRAID_Context
,
1179 /*Get Phy Params only if FP capable, or else leave it to MR firmware
1180 to do the calculation.*/
1181 if (io_info
->fpOkForIo
) {
1182 retval
= io_info
->IoforUnevenSpan
?
1183 mr_spanset_get_phy_params(instance
, ld
,
1184 start_strip
, ref_in_start_stripe
,
1185 io_info
, pRAID_Context
, map
) :
1186 MR_GetPhyParams(instance
, ld
, start_strip
,
1187 ref_in_start_stripe
, io_info
,
1188 pRAID_Context
, map
);
1189 /* If IO on an invalid Pd, then FP is not possible.*/
1190 if (io_info
->devHandle
== MR_DEVHANDLE_INVALID
)
1191 io_info
->fpOkForIo
= false;
1193 } else if (isRead
) {
1195 for (stripIdx
= 0; stripIdx
< num_strips
; stripIdx
++) {
1196 retval
= io_info
->IoforUnevenSpan
?
1197 mr_spanset_get_phy_params(instance
, ld
,
1198 start_strip
+ stripIdx
,
1199 ref_in_start_stripe
, io_info
,
1200 pRAID_Context
, map
) :
1201 MR_GetPhyParams(instance
, ld
,
1202 start_strip
+ stripIdx
, ref_in_start_stripe
,
1203 io_info
, pRAID_Context
, map
);
1212 ******************************************************************************
1214 * This routine pepare spanset info from Valid Raid map and store it into
1215 * local copy of ldSpanInfo per instance data structure.
1219 * ldSpanInfo - ldSpanInfo per HBA instance
1222 void mr_update_span_set(struct MR_DRV_RAID_MAP_ALL
*map
,
1223 PLD_SPAN_INFO ldSpanInfo
)
1226 u32 element
, span_row_width
;
1228 struct MR_LD_RAID
*raid
;
1229 LD_SPAN_SET
*span_set
, *span_set_prev
;
1230 struct MR_QUAD_ELEMENT
*quad
;
1235 for (ldCount
= 0; ldCount
< MAX_LOGICAL_DRIVES_EXT
; ldCount
++) {
1236 ld
= MR_TargetIdToLdGet(ldCount
, map
);
1237 if (ld
>= (MAX_LOGICAL_DRIVES_EXT
- 1))
1239 raid
= MR_LdRaidGet(ld
, map
);
1240 for (element
= 0; element
< MAX_QUAD_DEPTH
; element
++) {
1241 for (span
= 0; span
< raid
->spanDepth
; span
++) {
1242 if (le32_to_cpu(map
->raidMap
.ldSpanMap
[ld
].spanBlock
[span
].
1243 block_span_info
.noElements
) <
1246 span_set
= &(ldSpanInfo
[ld
].span_set
[element
]);
1247 quad
= &map
->raidMap
.ldSpanMap
[ld
].
1248 spanBlock
[span
].block_span_info
.
1251 span_set
->diff
= le32_to_cpu(quad
->diff
);
1253 for (count
= 0, span_row_width
= 0;
1254 count
< raid
->spanDepth
; count
++) {
1255 if (le32_to_cpu(map
->raidMap
.ldSpanMap
[ld
].
1258 noElements
) >= element
+ 1) {
1259 span_set
->strip_offset
[count
] =
1263 (ld
, count
, map
)->spanRowDataSize
;
1267 span_set
->span_row_data_width
= span_row_width
;
1268 span_row
= mega_div64_32(((le64_to_cpu(quad
->logEnd
) -
1269 le64_to_cpu(quad
->logStart
)) + le32_to_cpu(quad
->diff
)),
1270 le32_to_cpu(quad
->diff
));
1273 span_set
->log_start_lba
= 0;
1274 span_set
->log_end_lba
=
1275 ((span_row
<< raid
->stripeShift
)
1276 * span_row_width
) - 1;
1278 span_set
->span_row_start
= 0;
1279 span_set
->span_row_end
= span_row
- 1;
1281 span_set
->data_strip_start
= 0;
1282 span_set
->data_strip_end
=
1283 (span_row
* span_row_width
) - 1;
1285 span_set
->data_row_start
= 0;
1286 span_set
->data_row_end
=
1287 (span_row
* le32_to_cpu(quad
->diff
)) - 1;
1289 span_set_prev
= &(ldSpanInfo
[ld
].
1290 span_set
[element
- 1]);
1291 span_set
->log_start_lba
=
1292 span_set_prev
->log_end_lba
+ 1;
1293 span_set
->log_end_lba
=
1294 span_set
->log_start_lba
+
1295 ((span_row
<< raid
->stripeShift
)
1296 * span_row_width
) - 1;
1298 span_set
->span_row_start
=
1299 span_set_prev
->span_row_end
+ 1;
1300 span_set
->span_row_end
=
1301 span_set
->span_row_start
+ span_row
- 1;
1303 span_set
->data_strip_start
=
1304 span_set_prev
->data_strip_end
+ 1;
1305 span_set
->data_strip_end
=
1306 span_set
->data_strip_start
+
1307 (span_row
* span_row_width
) - 1;
1309 span_set
->data_row_start
=
1310 span_set_prev
->data_row_end
+ 1;
1311 span_set
->data_row_end
=
1312 span_set
->data_row_start
+
1313 (span_row
* le32_to_cpu(quad
->diff
)) - 1;
1317 if (span
== raid
->spanDepth
)
1323 void mr_update_load_balance_params(struct MR_DRV_RAID_MAP_ALL
*drv_map
,
1324 struct LD_LOAD_BALANCE_INFO
*lbInfo
)
1328 struct MR_LD_RAID
*raid
;
1330 if (lb_pending_cmds
> 128 || lb_pending_cmds
< 1)
1331 lb_pending_cmds
= LB_PENDING_CMDS_DEFAULT
;
1333 for (ldCount
= 0; ldCount
< MAX_LOGICAL_DRIVES_EXT
; ldCount
++) {
1334 ld
= MR_TargetIdToLdGet(ldCount
, drv_map
);
1335 if (ld
>= MAX_LOGICAL_DRIVES_EXT
- 1) {
1336 lbInfo
[ldCount
].loadBalanceFlag
= 0;
1340 raid
= MR_LdRaidGet(ld
, drv_map
);
1341 if ((raid
->level
!= 1) ||
1342 (raid
->ldState
!= MR_LD_STATE_OPTIMAL
)) {
1343 lbInfo
[ldCount
].loadBalanceFlag
= 0;
1346 lbInfo
[ldCount
].loadBalanceFlag
= 1;
1350 u8
megasas_get_best_arm_pd(struct megasas_instance
*instance
,
1351 struct LD_LOAD_BALANCE_INFO
*lbInfo
,
1352 struct IO_REQUEST_INFO
*io_info
,
1353 struct MR_DRV_RAID_MAP_ALL
*drv_map
)
1355 struct MR_LD_RAID
*raid
;
1357 u16 pend0
, pend1
, ld
;
1359 u8 bestArm
, pd0
, pd1
, span
, arm
;
1360 u32 arRef
, span_row_size
;
1362 u64 block
= io_info
->ldStartBlock
;
1363 u32 count
= io_info
->numBlocks
;
1365 span
= ((io_info
->span_arm
& RAID_CTX_SPANARM_SPAN_MASK
)
1366 >> RAID_CTX_SPANARM_SPAN_SHIFT
);
1367 arm
= (io_info
->span_arm
& RAID_CTX_SPANARM_ARM_MASK
);
1369 ld
= MR_TargetIdToLdGet(io_info
->ldTgtId
, drv_map
);
1370 raid
= MR_LdRaidGet(ld
, drv_map
);
1371 span_row_size
= instance
->UnevenSpanSupport
?
1372 SPAN_ROW_SIZE(drv_map
, ld
, span
) : raid
->rowSize
;
1374 arRef
= MR_LdSpanArrayGet(ld
, span
, drv_map
);
1375 pd0
= MR_ArPdGet(arRef
, arm
, drv_map
);
1376 pd1
= MR_ArPdGet(arRef
, (arm
+ 1) >= span_row_size
?
1377 (arm
+ 1 - span_row_size
) : arm
+ 1, drv_map
);
1379 /* Get PD1 Dev Handle */
1381 pd1_dev_handle
= MR_PdDevHandleGet(pd1
, drv_map
);
1383 if (pd1_dev_handle
== MR_DEVHANDLE_INVALID
) {
1386 /* get the pending cmds for the data and mirror arms */
1387 pend0
= atomic_read(&lbInfo
->scsi_pending_cmds
[pd0
]);
1388 pend1
= atomic_read(&lbInfo
->scsi_pending_cmds
[pd1
]);
1390 /* Determine the disk whose head is nearer to the req. block */
1391 diff0
= ABS_DIFF(block
, lbInfo
->last_accessed_block
[pd0
]);
1392 diff1
= ABS_DIFF(block
, lbInfo
->last_accessed_block
[pd1
]);
1393 bestArm
= (diff0
<= diff1
? arm
: arm
^ 1);
1395 /* Make balance count from 16 to 4 to
1396 * keep driver in sync with Firmware
1398 if ((bestArm
== arm
&& pend0
> pend1
+ lb_pending_cmds
) ||
1399 (bestArm
!= arm
&& pend1
> pend0
+ lb_pending_cmds
))
1402 /* Update the last accessed block on the correct pd */
1404 (span
<< RAID_CTX_SPANARM_SPAN_SHIFT
) | bestArm
;
1405 io_info
->pd_after_lb
= (bestArm
== arm
) ? pd0
: pd1
;
1408 lbInfo
->last_accessed_block
[io_info
->pd_after_lb
] = block
+ count
- 1;
1409 return io_info
->pd_after_lb
;
1412 __le16
get_updated_dev_handle(struct megasas_instance
*instance
,
1413 struct LD_LOAD_BALANCE_INFO
*lbInfo
,
1414 struct IO_REQUEST_INFO
*io_info
,
1415 struct MR_DRV_RAID_MAP_ALL
*drv_map
)
1420 /* get best new arm (PD ID) */
1421 arm_pd
= megasas_get_best_arm_pd(instance
, lbInfo
, io_info
, drv_map
);
1422 devHandle
= MR_PdDevHandleGet(arm_pd
, drv_map
);
1423 io_info
->pd_interface
= MR_PdInterfaceTypeGet(arm_pd
, drv_map
);
1424 atomic_inc(&lbInfo
->scsi_pending_cmds
[arm_pd
]);