2 * Linux MegaRAID driver for SAS based RAID controllers
4 * Copyright (c) 2009-2011 LSI Corporation.
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version 2
9 * of the License, or (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 * FILE: megaraid_sas_fp.c
22 * Authors: LSI Corporation
27 * Send feedback to: <megaraidlinux@lsi.com>
29 * Mail to: LSI Corporation, 1621 Barber Lane, Milpitas, CA 95035
33 #include <linux/kernel.h>
34 #include <linux/types.h>
35 #include <linux/pci.h>
36 #include <linux/list.h>
37 #include <linux/moduleparam.h>
38 #include <linux/module.h>
39 #include <linux/spinlock.h>
40 #include <linux/interrupt.h>
41 #include <linux/delay.h>
42 #include <linux/uio.h>
43 #include <linux/uaccess.h>
45 #include <linux/compat.h>
46 #include <linux/blkdev.h>
47 #include <linux/poll.h>
49 #include <scsi/scsi.h>
50 #include <scsi/scsi_cmnd.h>
51 #include <scsi/scsi_device.h>
52 #include <scsi/scsi_host.h>
54 #include "megaraid_sas_fusion.h"
55 #include <asm/div64.h>
57 #define ABS_DIFF(a, b) (((a) > (b)) ? ((a) - (b)) : ((b) - (a)))
58 #define MR_LD_STATE_OPTIMAL 3
64 mr_update_load_balance_params(struct MR_FW_RAID_MAP_ALL
*map
,
65 struct LD_LOAD_BALANCE_INFO
*lbInfo
);
67 u32
mega_mod64(u64 dividend
, u32 divisor
)
73 printk(KERN_ERR
"megasas : DIVISOR is zero, in div fn\n");
75 remainder
= do_div(d
, divisor
);
80 * @param dividend : Dividend
81 * @param divisor : Divisor
85 u64
mega_div64_32(uint64_t dividend
, uint32_t divisor
)
91 printk(KERN_ERR
"megasas : DIVISOR is zero in mod fn\n");
94 remainder
= do_div(d
, divisor
);
99 struct MR_LD_RAID
*MR_LdRaidGet(u32 ld
, struct MR_FW_RAID_MAP_ALL
*map
)
101 return &map
->raidMap
.ldSpanMap
[ld
].ldRaid
;
104 static struct MR_SPAN_BLOCK_INFO
*MR_LdSpanInfoGet(u32 ld
,
105 struct MR_FW_RAID_MAP_ALL
108 return &map
->raidMap
.ldSpanMap
[ld
].spanBlock
[0];
111 static u8
MR_LdDataArmGet(u32 ld
, u32 armIdx
, struct MR_FW_RAID_MAP_ALL
*map
)
113 return map
->raidMap
.ldSpanMap
[ld
].dataArmMap
[armIdx
];
116 static u16
MR_ArPdGet(u32 ar
, u32 arm
, struct MR_FW_RAID_MAP_ALL
*map
)
118 return map
->raidMap
.arMapInfo
[ar
].pd
[arm
];
121 static u16
MR_LdSpanArrayGet(u32 ld
, u32 span
, struct MR_FW_RAID_MAP_ALL
*map
)
123 return map
->raidMap
.ldSpanMap
[ld
].spanBlock
[span
].span
.arrayRef
;
126 static u16
MR_PdDevHandleGet(u32 pd
, struct MR_FW_RAID_MAP_ALL
*map
)
128 return map
->raidMap
.devHndlInfo
[pd
].curDevHdl
;
131 u16
MR_GetLDTgtId(u32 ld
, struct MR_FW_RAID_MAP_ALL
*map
)
133 return map
->raidMap
.ldSpanMap
[ld
].ldRaid
.targetId
;
136 u16
MR_TargetIdToLdGet(u32 ldTgtId
, struct MR_FW_RAID_MAP_ALL
*map
)
138 return map
->raidMap
.ldTgtIdToLd
[ldTgtId
];
141 static struct MR_LD_SPAN
*MR_LdSpanPtrGet(u32 ld
, u32 span
,
142 struct MR_FW_RAID_MAP_ALL
*map
)
144 return &map
->raidMap
.ldSpanMap
[ld
].spanBlock
[span
].span
;
148 * This function will validate Map info data provided by FW
150 u8
MR_ValidateMapInfo(struct MR_FW_RAID_MAP_ALL
*map
,
151 struct LD_LOAD_BALANCE_INFO
*lbInfo
)
153 struct MR_FW_RAID_MAP
*pFwRaidMap
= &map
->raidMap
;
155 if (pFwRaidMap
->totalSize
!=
156 (sizeof(struct MR_FW_RAID_MAP
) -sizeof(struct MR_LD_SPAN_MAP
) +
157 (sizeof(struct MR_LD_SPAN_MAP
) *pFwRaidMap
->ldCount
))) {
158 printk(KERN_ERR
"megasas: map info structure size 0x%x is not matching with ld count\n",
159 (unsigned int)((sizeof(struct MR_FW_RAID_MAP
) -
160 sizeof(struct MR_LD_SPAN_MAP
)) +
161 (sizeof(struct MR_LD_SPAN_MAP
) *
162 pFwRaidMap
->ldCount
)));
163 printk(KERN_ERR
"megasas: span map %x, pFwRaidMap->totalSize "
164 ": %x\n", (unsigned int)sizeof(struct MR_LD_SPAN_MAP
),
165 pFwRaidMap
->totalSize
);
169 mr_update_load_balance_params(map
, lbInfo
);
174 u32
MR_GetSpanBlock(u32 ld
, u64 row
, u64
*span_blk
,
175 struct MR_FW_RAID_MAP_ALL
*map
, int *div_error
)
177 struct MR_SPAN_BLOCK_INFO
*pSpanBlock
= MR_LdSpanInfoGet(ld
, map
);
178 struct MR_QUAD_ELEMENT
*quad
;
179 struct MR_LD_RAID
*raid
= MR_LdRaidGet(ld
, map
);
182 for (span
= 0; span
< raid
->spanDepth
; span
++, pSpanBlock
++) {
184 for (j
= 0; j
< pSpanBlock
->block_span_info
.noElements
; j
++) {
185 quad
= &pSpanBlock
->block_span_info
.quad
[j
];
187 if (quad
->diff
== 0) {
191 if (quad
->logStart
<= row
&& row
<= quad
->logEnd
&&
192 (mega_mod64(row
-quad
->logStart
, quad
->diff
)) == 0) {
193 if (span_blk
!= NULL
) {
197 (row
-quad
->logStart
),
201 blk
= (blk
+ quad
->offsetInSpan
) <<
213 ******************************************************************************
215 * This routine calculates the arm, span and block for the specified stripe and
216 * reference in stripe.
220 * ld - Logical drive number
221 * stripRow - Stripe number
222 * stripRef - Reference in stripe
227 * block - Absolute Block number in the physical disk
229 u8
MR_GetPhyParams(u32 ld
, u64 stripRow
, u16 stripRef
, u64
*pdBlock
,
230 u16
*pDevHandle
, struct RAID_CONTEXT
*pRAID_Context
,
231 struct MR_FW_RAID_MAP_ALL
*map
)
233 struct MR_LD_RAID
*raid
= MR_LdRaidGet(ld
, map
);
240 row
= mega_div64_32(stripRow
, raid
->rowDataSize
);
242 if (raid
->level
== 6) {
243 /* logical arm within row */
244 u32 logArm
= mega_mod64(stripRow
, raid
->rowDataSize
);
245 u32 rowMod
, armQ
, arm
;
247 if (raid
->rowSize
== 0)
249 /* get logical row mod */
250 rowMod
= mega_mod64(row
, raid
->rowSize
);
251 armQ
= raid
->rowSize
-1-rowMod
; /* index of Q drive */
252 arm
= armQ
+1+logArm
; /* data always logically follows Q */
253 if (arm
>= raid
->rowSize
) /* handle wrap condition */
254 arm
-= raid
->rowSize
;
257 if (raid
->modFactor
== 0)
259 physArm
= MR_LdDataArmGet(ld
, mega_mod64(stripRow
,
264 if (raid
->spanDepth
== 1) {
266 *pdBlock
= row
<< raid
->stripeShift
;
268 span
= (u8
)MR_GetSpanBlock(ld
, row
, pdBlock
, map
, &error_code
);
273 /* Get the array on which this span is present */
274 arRef
= MR_LdSpanArrayGet(ld
, span
, map
);
275 pd
= MR_ArPdGet(arRef
, physArm
, map
); /* Get the pd */
277 if (pd
!= MR_PD_INVALID
)
278 /* Get dev handle from Pd. */
279 *pDevHandle
= MR_PdDevHandleGet(pd
, map
);
281 *pDevHandle
= MR_PD_INVALID
; /* set dev handle as invalid. */
282 if (raid
->level
>= 5)
283 pRAID_Context
->regLockFlags
= REGION_TYPE_EXCLUSIVE
;
284 else if (raid
->level
== 1) {
285 /* Get alternate Pd. */
286 pd
= MR_ArPdGet(arRef
, physArm
+ 1, map
);
287 if (pd
!= MR_PD_INVALID
)
288 /* Get dev handle from Pd */
289 *pDevHandle
= MR_PdDevHandleGet(pd
, map
);
294 *pdBlock
+= stripRef
+ MR_LdSpanPtrGet(ld
, span
, map
)->startBlk
;
295 pRAID_Context
->spanArm
= (span
<< RAID_CTX_SPANARM_SPAN_SHIFT
) |
301 ******************************************************************************
303 * MR_BuildRaidContext function
305 * This function will initiate command processing. The start/end row and strip
306 * information is calculated then the lock is acquired.
307 * This function will return 0 if region lock was acquired OR return num strips
310 MR_BuildRaidContext(struct IO_REQUEST_INFO
*io_info
,
311 struct RAID_CONTEXT
*pRAID_Context
,
312 struct MR_FW_RAID_MAP_ALL
*map
)
314 struct MR_LD_RAID
*raid
;
315 u32 ld
, stripSize
, stripe_mask
;
316 u64 endLba
, endStrip
, endRow
, start_row
, start_strip
;
319 u8 num_strips
, numRows
;
320 u16 ref_in_start_stripe
, ref_in_end_stripe
;
322 u32 numBlocks
, ldTgtId
;
326 ldStartBlock
= io_info
->ldStartBlock
;
327 numBlocks
= io_info
->numBlocks
;
328 ldTgtId
= io_info
->ldTgtId
;
329 isRead
= io_info
->isRead
;
331 ld
= MR_TargetIdToLdGet(ldTgtId
, map
);
332 raid
= MR_LdRaidGet(ld
, map
);
334 stripSize
= 1 << raid
->stripeShift
;
335 stripe_mask
= stripSize
-1;
337 * calculate starting row and stripe, and number of strips and rows
339 start_strip
= ldStartBlock
>> raid
->stripeShift
;
340 ref_in_start_stripe
= (u16
)(ldStartBlock
& stripe_mask
);
341 endLba
= ldStartBlock
+ numBlocks
- 1;
342 ref_in_end_stripe
= (u16
)(endLba
& stripe_mask
);
343 endStrip
= endLba
>> raid
->stripeShift
;
344 num_strips
= (u8
)(endStrip
- start_strip
+ 1); /* End strip */
345 if (raid
->rowDataSize
== 0)
347 start_row
= mega_div64_32(start_strip
, raid
->rowDataSize
);
348 endRow
= mega_div64_32(endStrip
, raid
->rowDataSize
);
349 numRows
= (u8
)(endRow
- start_row
+ 1);
352 * calculate region info.
355 /* assume region is at the start of the first row */
356 regStart
= start_row
<< raid
->stripeShift
;
357 /* assume this IO needs the full row - we'll adjust if not true */
360 /* If IO spans more than 1 strip, fp is not possible
361 FP is not possible for writes on non-0 raid levels
362 FP is not possible if LD is not capable */
363 if (num_strips
> 1 || (!isRead
&& raid
->level
!= 0) ||
364 !raid
->capability
.fpCapable
) {
365 io_info
->fpOkForIo
= FALSE
;
367 io_info
->fpOkForIo
= TRUE
;
371 /* single-strip IOs can always lock only the data needed */
372 if (num_strips
== 1) {
373 regStart
+= ref_in_start_stripe
;
376 /* multi-strip IOs always need to full stripe locked */
378 if (start_strip
== (start_row
+ 1) * raid
->rowDataSize
- 1) {
379 /* If the start strip is the last in the start row */
380 regStart
+= ref_in_start_stripe
;
381 regSize
= stripSize
- ref_in_start_stripe
;
382 /* initialize count to sectors from startref to end
387 /* Add complete rows in the middle of the transfer */
388 regSize
+= (numRows
-2) << raid
->stripeShift
;
390 /* if IO ends within first strip of last row */
391 if (endStrip
== endRow
*raid
->rowDataSize
)
392 regSize
+= ref_in_end_stripe
+1;
394 regSize
+= stripSize
;
397 pRAID_Context
->timeoutValue
= map
->raidMap
.fpPdIoTimeoutSec
;
398 pRAID_Context
->regLockFlags
= (isRead
) ? REGION_TYPE_SHARED_READ
:
399 raid
->regTypeReqOnWrite
;
400 pRAID_Context
->VirtualDiskTgtId
= raid
->targetId
;
401 pRAID_Context
->regLockRowLBA
= regStart
;
402 pRAID_Context
->regLockLength
= regSize
;
403 pRAID_Context
->configSeqNum
= raid
->seqNum
;
405 /*Get Phy Params only if FP capable, or else leave it to MR firmware
406 to do the calculation.*/
407 if (io_info
->fpOkForIo
) {
408 retval
= MR_GetPhyParams(ld
, start_strip
, ref_in_start_stripe
,
410 &io_info
->devHandle
, pRAID_Context
,
412 /* If IO on an invalid Pd, then FP i snot possible */
413 if (io_info
->devHandle
== MR_PD_INVALID
)
414 io_info
->fpOkForIo
= FALSE
;
418 for (stripIdx
= 0; stripIdx
< num_strips
; stripIdx
++) {
419 if (!MR_GetPhyParams(ld
, start_strip
+ stripIdx
,
431 mr_update_load_balance_params(struct MR_FW_RAID_MAP_ALL
*map
,
432 struct LD_LOAD_BALANCE_INFO
*lbInfo
)
436 struct MR_LD_RAID
*raid
;
438 for (ldCount
= 0; ldCount
< MAX_LOGICAL_DRIVES
; ldCount
++) {
439 ld
= MR_TargetIdToLdGet(ldCount
, map
);
440 if (ld
>= MAX_LOGICAL_DRIVES
) {
441 lbInfo
[ldCount
].loadBalanceFlag
= 0;
445 raid
= MR_LdRaidGet(ld
, map
);
447 /* Two drive Optimal RAID 1 */
448 if ((raid
->level
== 1) && (raid
->rowSize
== 2) &&
449 (raid
->spanDepth
== 1) && raid
->ldState
==
450 MR_LD_STATE_OPTIMAL
) {
453 lbInfo
[ldCount
].loadBalanceFlag
= 1;
455 /* Get the array on which this span is present */
456 arRef
= MR_LdSpanArrayGet(ld
, 0, map
);
459 pd
= MR_ArPdGet(arRef
, 0, map
);
460 /* Get dev handle from Pd */
461 lbInfo
[ldCount
].raid1DevHandle
[0] =
462 MR_PdDevHandleGet(pd
, map
);
464 pd
= MR_ArPdGet(arRef
, 1, map
);
466 /* Get the dev handle from Pd */
467 lbInfo
[ldCount
].raid1DevHandle
[1] =
468 MR_PdDevHandleGet(pd
, map
);
470 lbInfo
[ldCount
].loadBalanceFlag
= 0;
474 u8
megasas_get_best_arm(struct LD_LOAD_BALANCE_INFO
*lbInfo
, u8 arm
, u64 block
,
481 /* get the pending cmds for the data and mirror arms */
482 pend0
= atomic_read(&lbInfo
->scsi_pending_cmds
[0]);
483 pend1
= atomic_read(&lbInfo
->scsi_pending_cmds
[1]);
485 /* Determine the disk whose head is nearer to the req. block */
486 diff0
= ABS_DIFF(block
, lbInfo
->last_accessed_block
[0]);
487 diff1
= ABS_DIFF(block
, lbInfo
->last_accessed_block
[1]);
488 bestArm
= (diff0
<= diff1
? 0 : 1);
490 if ((bestArm
== arm
&& pend0
> pend1
+ 16) ||
491 (bestArm
!= arm
&& pend1
> pend0
+ 16))
494 /* Update the last accessed block on the correct pd */
495 lbInfo
->last_accessed_block
[bestArm
] = block
+ count
- 1;
500 u16
get_updated_dev_handle(struct LD_LOAD_BALANCE_INFO
*lbInfo
,
501 struct IO_REQUEST_INFO
*io_info
)
506 old_arm
= lbInfo
->raid1DevHandle
[0] == io_info
->devHandle
? 0 : 1;
508 /* get best new arm */
509 arm
= megasas_get_best_arm(lbInfo
, old_arm
, io_info
->ldStartBlock
,
511 devHandle
= lbInfo
->raid1DevHandle
[arm
];
512 atomic_inc(&lbInfo
->scsi_pending_cmds
[arm
]);