drivers/scsi/megaraid/megaraid_sas_fp.c

   1 /*
   2  *  Linux MegaRAID driver for SAS based RAID controllers
   3  *
   4  *  Copyright (c) 2009-2011  LSI Corporation.
   5  *
   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.
  10  *
  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.
  15  *
  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
  19  *
  20  *  FILE: megaraid_sas_fp.c
  21  *
  22  *  Authors: LSI Corporation
  23  *           Sumant Patro
  24  *           Varad Talamacki
  25  *           Manoj Jose
  26  *
  27  *  Send feedback to: <megaraidlinux@lsi.com>
  28  *
  29  *  Mail to: LSI Corporation, 1621 Barber Lane, Milpitas, CA 95035
  30  *     ATTN: Linuxraid
  31  */
  32
  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>
  44 #include <linux/fs.h>
  45 #include <linux/compat.h>
  46 #include <linux/blkdev.h>
  47 #include <linux/poll.h>
  48
  49 #include <scsi/scsi.h>
  50 #include <scsi/scsi_cmnd.h>
  51 #include <scsi/scsi_device.h>
  52 #include <scsi/scsi_host.h>
  53
  54 #include "megaraid_sas_fusion.h"
  55 #include <asm/div64.h>
  56
  57 #define ABS_DIFF(a, b)   (((a) > (b)) ? ((a) - (b)) : ((b) - (a)))
  58 #define MR_LD_STATE_OPTIMAL 3
  59 #define FALSE 0
  60 #define TRUE 1
  61
  62 /* Prototypes */
  63 void
  64 mr_update_load_balance_params(struct MR_FW_RAID_MAP_ALL *map,
  65                               struct LD_LOAD_BALANCE_INFO *lbInfo);
  66
  67 u32 mega_mod64(u64 dividend, u32 divisor)
  68 {
  69         u64 d;
  70         u32 remainder;
  71
  72         if (!divisor)
  73                 printk(KERN_ERR "megasas : DIVISOR is zero, in div fn\n");
  74         d = dividend;
  75         remainder = do_div(d, divisor);
  76         return remainder;
  77 }
  78
  79 /**
  80  * @param dividend    : Dividend
  81  * @param divisor    : Divisor
  82  *
  83  * @return quotient
  84  **/
  85 u64 mega_div64_32(uint64_t dividend, uint32_t divisor)
  86 {
  87         u32 remainder;
  88         u64 d;
  89
  90         if (!divisor)
  91                 printk(KERN_ERR "megasas : DIVISOR is zero in mod fn\n");
  92
  93         d = dividend;
  94         remainder = do_div(d, divisor);
  95
  96         return d;
  97 }
  98
  99 struct MR_LD_RAID *MR_LdRaidGet(u32 ld, struct MR_FW_RAID_MAP_ALL *map)
 100 {
 101         return &map->raidMap.ldSpanMap[ld].ldRaid;
 102 }
 103
 104 static struct MR_SPAN_BLOCK_INFO *MR_LdSpanInfoGet(u32 ld,
 105                                                    struct MR_FW_RAID_MAP_ALL
 106                                                    *map)
 107 {
 108         return &map->raidMap.ldSpanMap[ld].spanBlock[0];
 109 }
 110
 111 static u8 MR_LdDataArmGet(u32 ld, u32 armIdx, struct MR_FW_RAID_MAP_ALL *map)
 112 {
 113         return map->raidMap.ldSpanMap[ld].dataArmMap[armIdx];
 114 }
 115
 116 static u16 MR_ArPdGet(u32 ar, u32 arm, struct MR_FW_RAID_MAP_ALL *map)
 117 {
 118         return map->raidMap.arMapInfo[ar].pd[arm];
 119 }
 120
 121 static u16 MR_LdSpanArrayGet(u32 ld, u32 span, struct MR_FW_RAID_MAP_ALL *map)
 122 {
 123         return map->raidMap.ldSpanMap[ld].spanBlock[span].span.arrayRef;
 124 }
 125
 126 static u16 MR_PdDevHandleGet(u32 pd, struct MR_FW_RAID_MAP_ALL *map)
 127 {
 128         return map->raidMap.devHndlInfo[pd].curDevHdl;
 129 }
 130
 131 u16 MR_GetLDTgtId(u32 ld, struct MR_FW_RAID_MAP_ALL *map)
 132 {
 133         return map->raidMap.ldSpanMap[ld].ldRaid.targetId;
 134 }
 135
 136 u16 MR_TargetIdToLdGet(u32 ldTgtId, struct MR_FW_RAID_MAP_ALL *map)
 137 {
 138         return map->raidMap.ldTgtIdToLd[ldTgtId];
 139 }
 140
 141 static struct MR_LD_SPAN *MR_LdSpanPtrGet(u32 ld, u32 span,
 142                                           struct MR_FW_RAID_MAP_ALL *map)
 143 {
 144         return &map->raidMap.ldSpanMap[ld].spanBlock[span].span;
 145 }
 146
 147 /*
 148  * This function will validate Map info data provided by FW
 149  */
 150 u8 MR_ValidateMapInfo(struct MR_FW_RAID_MAP_ALL *map,
 151                       struct LD_LOAD_BALANCE_INFO *lbInfo)
 152 {
 153         struct MR_FW_RAID_MAP *pFwRaidMap = &map->raidMap;
 154
 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);
 166                 return 0;
 167         }
 168
 169         mr_update_load_balance_params(map, lbInfo);
 170
 171         return 1;
 172 }
 173
 174 u32 MR_GetSpanBlock(u32 ld, u64 row, u64 *span_blk,
 175                     struct MR_FW_RAID_MAP_ALL *map, int *div_error)
 176 {
 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);
 180         u32                span, j;
 181
 182         for (span = 0; span < raid->spanDepth; span++, pSpanBlock++) {
 183
 184                 for (j = 0; j < pSpanBlock->block_span_info.noElements; j++) {
 185                         quad = &pSpanBlock->block_span_info.quad[j];
 186
 187                         if (quad->diff == 0) {
 188                                 *div_error = 1;
 189                                 return span;
 190                         }
 191                         if (quad->logStart <= row  &&  row <= quad->logEnd  &&
 192                             (mega_mod64(row-quad->logStart, quad->diff)) == 0) {
 193                                 if (span_blk != NULL) {
 194                                         u64  blk, debugBlk;
 195                                         blk =
 196                                                 mega_div64_32(
 197                                                         (row-quad->logStart),
 198                                                         quad->diff);
 199                                         debugBlk = blk;
 200
 201                                         blk = (blk + quad->offsetInSpan) <<
 202                                                 raid->stripeShift;
 203                                         *span_blk = blk;
 204                                 }
 205                                 return span;
 206                         }
 207                 }
 208         }
 209         return span;
 210 }
 211
 212 /*
 213 ******************************************************************************
 214 *
 215 * This routine calculates the arm, span and block for the specified stripe and
 216 * reference in stripe.
 217 *
 218 * Inputs :
 219 *
 220 *    ld   - Logical drive number
 221 *    stripRow        - Stripe number
 222 *    stripRef    - Reference in stripe
 223 *
 224 * Outputs :
 225 *
 226 *    span          - Span number
 227 *    block         - Absolute Block number in the physical disk
 228 */
 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)
 232 {
 233         struct MR_LD_RAID  *raid = MR_LdRaidGet(ld, map);
 234         u32         pd, arRef;
 235         u8          physArm, span;
 236         u64         row;
 237         u8          retval = TRUE;
 238         int         error_code = 0;
 239
 240         row =  mega_div64_32(stripRow, raid->rowDataSize);
 241
 242         if (raid->level == 6) {
 243                 /* logical arm within row */
 244                 u32 logArm =  mega_mod64(stripRow, raid->rowDataSize);
 245                 u32 rowMod, armQ, arm;
 246
 247                 if (raid->rowSize == 0)
 248                         return FALSE;
 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;
 255                 physArm = (u8)arm;
 256         } else  {
 257                 if (raid->modFactor == 0)
 258                         return FALSE;
 259                 physArm = MR_LdDataArmGet(ld,  mega_mod64(stripRow,
 260                                                           raid->modFactor),
 261                                           map);
 262         }
 263
 264         if (raid->spanDepth == 1) {
 265                 span = 0;
 266                 *pdBlock = row << raid->stripeShift;
 267         } else {
 268                 span = (u8)MR_GetSpanBlock(ld, row, pdBlock, map, &error_code);
 269                 if (error_code == 1)
 270                         return FALSE;
 271         }
 272
 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 */
 276
 277         if (pd != MR_PD_INVALID)
 278                 /* Get dev handle from Pd. */
 279                 *pDevHandle = MR_PdDevHandleGet(pd, map);
 280         else {
 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);
 290                 }
 291         }
 292
 293         *pdBlock += stripRef + MR_LdSpanPtrGet(ld, span, map)->startBlk;
 294         pRAID_Context->spanArm = (span << RAID_CTX_SPANARM_SPAN_SHIFT) |
 295                 physArm;
 296         return retval;
 297 }
 298
 299 /*
 300 ******************************************************************************
 301 *
 302 * MR_BuildRaidContext function
 303 *
 304 * This function will initiate command processing.  The start/end row and strip
 305 * information is calculated then the lock is acquired.
 306 * This function will return 0 if region lock was acquired OR return num strips
 307 */
 308 u8
 309 MR_BuildRaidContext(struct IO_REQUEST_INFO *io_info,
 310                     struct RAID_CONTEXT *pRAID_Context,
 311                     struct MR_FW_RAID_MAP_ALL *map)
 312 {
 313         struct MR_LD_RAID  *raid;
 314         u32         ld, stripSize, stripe_mask;
 315         u64         endLba, endStrip, endRow, start_row, start_strip;
 316         u64         regStart;
 317         u32         regSize;
 318         u8          num_strips, numRows;
 319         u16         ref_in_start_stripe, ref_in_end_stripe;
 320         u64         ldStartBlock;
 321         u32         numBlocks, ldTgtId;
 322         u8          isRead;
 323         u8          retval = 0;
 324
 325         ldStartBlock = io_info->ldStartBlock;
 326         numBlocks = io_info->numBlocks;
 327         ldTgtId = io_info->ldTgtId;
 328         isRead = io_info->isRead;
 329
 330         ld = MR_TargetIdToLdGet(ldTgtId, map);
 331         raid = MR_LdRaidGet(ld, map);
 332
 333         stripSize = 1 << raid->stripeShift;
 334         stripe_mask = stripSize-1;
 335         /*
 336          * calculate starting row and stripe, and number of strips and rows
 337          */
 338         start_strip         = ldStartBlock >> raid->stripeShift;
 339         ref_in_start_stripe = (u16)(ldStartBlock & stripe_mask);
 340         endLba              = ldStartBlock + numBlocks - 1;
 341         ref_in_end_stripe   = (u16)(endLba & stripe_mask);
 342         endStrip            = endLba >> raid->stripeShift;
 343         num_strips          = (u8)(endStrip - start_strip + 1); /* End strip */
 344         if (raid->rowDataSize == 0)
 345                 return FALSE;
 346         start_row           =  mega_div64_32(start_strip, raid->rowDataSize);
 347         endRow              =  mega_div64_32(endStrip, raid->rowDataSize);
 348         numRows             = (u8)(endRow - start_row + 1);
 349
 350         /*
 351          * calculate region info.
 352          */
 353
 354         /* assume region is at the start of the first row */
 355         regStart            = start_row << raid->stripeShift;
 356         /* assume this IO needs the full row - we'll adjust if not true */
 357         regSize             = stripSize;
 358
 359         /* If IO spans more than 1 strip, fp is not possible
 360            FP is not possible for writes on non-0 raid levels
 361            FP is not possible if LD is not capable */
 362         if (num_strips > 1 || (!isRead && raid->level != 0) ||
 363             !raid->capability.fpCapable) {
 364                 io_info->fpOkForIo = FALSE;
 365         } else {
 366                 io_info->fpOkForIo = TRUE;
 367         }
 368
 369         if (numRows == 1) {
 370                 /* single-strip IOs can always lock only the data needed */
 371                 if (num_strips == 1) {
 372                         regStart += ref_in_start_stripe;
 373                         regSize = numBlocks;
 374                 }
 375                 /* multi-strip IOs always need to full stripe locked */
 376         } else {
 377                 if (start_strip == (start_row + 1) * raid->rowDataSize - 1) {
 378                         /* If the start strip is the last in the start row */
 379                         regStart += ref_in_start_stripe;
 380                         regSize = stripSize - ref_in_start_stripe;
 381                         /* initialize count to sectors from startref to end
 382                            of strip */
 383                 }
 384
 385                 if (numRows > 2)
 386                         /* Add complete rows in the middle of the transfer */
 387                         regSize += (numRows-2) << raid->stripeShift;
 388
 389                 /* if IO ends within first strip of last row */
 390                 if (endStrip == endRow*raid->rowDataSize)
 391                         regSize += ref_in_end_stripe+1;
 392                 else
 393                         regSize += stripSize;
 394         }
 395
 396         pRAID_Context->timeoutValue     = map->raidMap.fpPdIoTimeoutSec;
 397         pRAID_Context->regLockFlags     = (isRead) ? REGION_TYPE_SHARED_READ :
 398                 raid->regTypeReqOnWrite;
 399         pRAID_Context->VirtualDiskTgtId = raid->targetId;
 400         pRAID_Context->regLockRowLBA    = regStart;
 401         pRAID_Context->regLockLength    = regSize;
 402         pRAID_Context->configSeqNum     = raid->seqNum;
 403
 404         /*Get Phy Params only if FP capable, or else leave it to MR firmware
 405           to do the calculation.*/
 406         if (io_info->fpOkForIo) {
 407                 retval = MR_GetPhyParams(ld, start_strip, ref_in_start_stripe,
 408                                          &io_info->pdBlock,
 409                                          &io_info->devHandle, pRAID_Context,
 410                                          map);
 411                 /* If IO on an invalid Pd, then FP i snot possible */
 412                 if (io_info->devHandle == MR_PD_INVALID)
 413                         io_info->fpOkForIo = FALSE;
 414                 return retval;
 415         } else if (isRead) {
 416                 uint stripIdx;
 417                 for (stripIdx = 0; stripIdx < num_strips; stripIdx++) {
 418                         if (!MR_GetPhyParams(ld, start_strip + stripIdx,
 419                                              ref_in_start_stripe,
 420                                              &io_info->pdBlock,
 421                                              &io_info->devHandle,
 422                                              pRAID_Context, map))
 423                                 return TRUE;
 424                 }
 425         }
 426         return TRUE;
 427 }
 428
 429 void
 430 mr_update_load_balance_params(struct MR_FW_RAID_MAP_ALL *map,
 431                               struct LD_LOAD_BALANCE_INFO *lbInfo)
 432 {
 433         int ldCount;
 434         u16 ld;
 435         struct MR_LD_RAID *raid;
 436
 437         for (ldCount = 0; ldCount < MAX_LOGICAL_DRIVES; ldCount++) {
 438                 ld = MR_TargetIdToLdGet(ldCount, map);
 439                 if (ld >= MAX_LOGICAL_DRIVES) {
 440                         lbInfo[ldCount].loadBalanceFlag = 0;
 441                         continue;
 442                 }
 443
 444                 raid = MR_LdRaidGet(ld, map);
 445
 446                 /* Two drive Optimal RAID 1 */
 447                 if ((raid->level == 1)  &&  (raid->rowSize == 2) &&
 448                     (raid->spanDepth == 1) && raid->ldState ==
 449                     MR_LD_STATE_OPTIMAL) {
 450                         u32 pd, arRef;
 451
 452                         lbInfo[ldCount].loadBalanceFlag = 1;
 453
 454                         /* Get the array on which this span is present */
 455                         arRef = MR_LdSpanArrayGet(ld, 0, map);
 456
 457                         /* Get the Pd */
 458                         pd = MR_ArPdGet(arRef, 0, map);
 459                         /* Get dev handle from Pd */
 460                         lbInfo[ldCount].raid1DevHandle[0] =
 461                                 MR_PdDevHandleGet(pd, map);
 462                         /* Get the Pd */
 463                         pd = MR_ArPdGet(arRef, 1, map);
 464
 465                         /* Get the dev handle from Pd */
 466                         lbInfo[ldCount].raid1DevHandle[1] =
 467                                 MR_PdDevHandleGet(pd, map);
 468                 } else
 469                         lbInfo[ldCount].loadBalanceFlag = 0;
 470         }
 471 }
 472
 473 u8 megasas_get_best_arm(struct LD_LOAD_BALANCE_INFO *lbInfo, u8 arm, u64 block,
 474                         u32 count)
 475 {
 476         u16     pend0, pend1;
 477         u64     diff0, diff1;
 478         u8      bestArm;
 479
 480         /* get the pending cmds for the data and mirror arms */
 481         pend0 = atomic_read(&lbInfo->scsi_pending_cmds[0]);
 482         pend1 = atomic_read(&lbInfo->scsi_pending_cmds[1]);
 483
 484         /* Determine the disk whose head is nearer to the req. block */
 485         diff0 = ABS_DIFF(block, lbInfo->last_accessed_block[0]);
 486         diff1 = ABS_DIFF(block, lbInfo->last_accessed_block[1]);
 487         bestArm = (diff0 <= diff1 ? 0 : 1);
 488
 489         if ((bestArm == arm && pend0 > pend1 + 16)  ||
 490             (bestArm != arm && pend1 > pend0 + 16))
 491                 bestArm ^= 1;
 492
 493         /* Update the last accessed block on the correct pd */
 494         lbInfo->last_accessed_block[bestArm] = block + count - 1;
 495
 496         return bestArm;
 497 }
 498
 499 u16 get_updated_dev_handle(struct LD_LOAD_BALANCE_INFO *lbInfo,
 500                            struct IO_REQUEST_INFO *io_info)
 501 {
 502         u8 arm, old_arm;
 503         u16 devHandle;
 504
 505         old_arm = lbInfo->raid1DevHandle[0] == io_info->devHandle ? 0 : 1;
 506
 507         /* get best new arm */
 508         arm  = megasas_get_best_arm(lbInfo, old_arm, io_info->ldStartBlock,
 509                                     io_info->numBlocks);
 510         devHandle = lbInfo->raid1DevHandle[arm];
 511         atomic_inc(&lbInfo->scsi_pending_cmds[arm]);
 512
 513         return devHandle;
 514 }