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