Print this page
5719 Add support for LSI Fury adapters
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/uts/common/io/mr_sas/ld_pd_map.c
+++ new/usr/src/uts/common/io/mr_sas/ld_pd_map.c
1 1 /*
2 2 * **********************************************************************
3 3 *
4 4 * ld_pd_map.c
5 5 *
6 6 * Solaris MegaRAID device driver for SAS2.0 controllers
7 7 * Copyright (c) 2008-2012, LSI Logic Corporation.
8 8 * All rights reserved.
9 9 *
10 10 * Version:
11 11 * Author:
12 12 * Swaminathan K S
13 13 * Arun Chandrashekhar
|
↓ open down ↓ |
13 lines elided |
↑ open up ↑ |
14 14 * Manju R
15 15 * Rasheed
16 16 * Shakeel Bukhari
17 17 *
18 18 *
19 19 * This module contains functions for device drivers
20 20 * to get pd-ld mapping information.
21 21 *
22 22 * **********************************************************************
23 23 */
24 +/*
25 + * Copyright 2015 Garrett D'Amore <garrett@damore.org>
26 + */
24 27
25 28 #include <sys/scsi/scsi.h>
26 29 #include "mr_sas.h"
27 30 #include "ld_pd_map.h"
28 31
29 32 /*
30 33 * This function will check if FAST IO is possible on this logical drive
31 34 * by checking the EVENT information available in the driver
32 35 */
33 36 #define MR_LD_STATE_OPTIMAL 3
34 37 #define ABS_DIFF(a, b) (((a) > (b)) ? ((a) - (b)) : ((b) - (a)))
35 38
36 39 static void mr_update_load_balance_params(MR_FW_RAID_MAP_ALL *,
37 40 PLD_LOAD_BALANCE_INFO);
38 41
39 42 #define FALSE 0
40 43 #define TRUE 1
41 44
42 45 typedef U64 REGION_KEY;
43 46 typedef U32 REGION_LEN;
44 47 extern int debug_level_g;
45 48
46 49
47 50 MR_LD_RAID
48 51 *MR_LdRaidGet(U32 ld, MR_FW_RAID_MAP_ALL *map)
49 52 {
50 53 return (&map->raidMap.ldSpanMap[ld].ldRaid);
51 54 }
52 55
53 56 U16
54 57 MR_GetLDTgtId(U32 ld, MR_FW_RAID_MAP_ALL *map)
55 58 {
56 59 return (map->raidMap.ldSpanMap[ld].ldRaid.targetId);
57 60 }
58 61
59 62
60 63 static MR_SPAN_BLOCK_INFO *
61 64 MR_LdSpanInfoGet(U32 ld, MR_FW_RAID_MAP_ALL *map)
62 65 {
63 66 return (&map->raidMap.ldSpanMap[ld].spanBlock[0]);
64 67 }
65 68
66 69 static U8
67 70 MR_LdDataArmGet(U32 ld, U32 armIdx, MR_FW_RAID_MAP_ALL *map)
68 71 {
69 72 return (map->raidMap.ldSpanMap[ld].dataArmMap[armIdx]);
70 73 }
71 74
72 75 static U16
73 76 MR_ArPdGet(U32 ar, U32 arm, MR_FW_RAID_MAP_ALL *map)
74 77 {
75 78 return (map->raidMap.arMapInfo[ar].pd[arm]);
76 79 }
77 80
78 81 static U16
79 82 MR_LdSpanArrayGet(U32 ld, U32 span, MR_FW_RAID_MAP_ALL *map)
80 83 {
81 84 return (map->raidMap.ldSpanMap[ld].spanBlock[span].span.arrayRef);
82 85 }
83 86
84 87 static U16
85 88 MR_PdDevHandleGet(U32 pd, MR_FW_RAID_MAP_ALL *map)
86 89 {
87 90 return (map->raidMap.devHndlInfo[pd].curDevHdl);
88 91 }
89 92
90 93 U16
91 94 MR_TargetIdToLdGet(U32 ldTgtId, MR_FW_RAID_MAP_ALL *map)
92 95 {
93 96 return (map->raidMap.ldTgtIdToLd[ldTgtId]);
94 97 }
95 98
96 99 U16
97 100 MR_CheckDIF(U32 ldTgtId, MR_FW_RAID_MAP_ALL *map)
98 101 {
99 102 MR_LD_RAID *raid;
100 103 U32 ld;
101 104
102 105 ld = MR_TargetIdToLdGet(ldTgtId, map);
103 106
104 107 if (ld >= MAX_LOGICAL_DRIVES) {
105 108 return (FALSE);
106 109 }
107 110
108 111 raid = MR_LdRaidGet(ld, map);
109 112
110 113 return (raid->capability.ldPiMode == 0x8);
111 114 }
112 115
113 116 static MR_LD_SPAN *
114 117 MR_LdSpanPtrGet(U32 ld, U32 span, MR_FW_RAID_MAP_ALL *map)
115 118 {
116 119 return (&map->raidMap.ldSpanMap[ld].spanBlock[span].span);
117 120 }
118 121
119 122 /*
120 123 * This function will validate Map info data provided by FW
121 124 */
122 125 U8
123 126 MR_ValidateMapInfo(MR_FW_RAID_MAP_ALL *map, PLD_LOAD_BALANCE_INFO lbInfo)
124 127 {
125 128 MR_FW_RAID_MAP *pFwRaidMap = &map->raidMap;
126 129 U32 fwsize = sizeof (MR_FW_RAID_MAP) - sizeof (MR_LD_SPAN_MAP) +
127 130 (sizeof (MR_LD_SPAN_MAP) * pFwRaidMap->ldCount);
128 131
129 132 if (pFwRaidMap->totalSize != fwsize) {
130 133
131 134 con_log(CL_ANN1, (CE_NOTE,
132 135 "map info structure size 0x%x is "
133 136 "not matching with ld count\n", fwsize));
134 137 /* sizeof (foo) returns size_t, which is *LONG*. */
135 138 con_log(CL_ANN1, (CE_NOTE, "span map 0x%x total size 0x%x\n",\
136 139 (int)sizeof (MR_LD_SPAN_MAP), pFwRaidMap->totalSize));
137 140
138 141 return (0);
139 142 }
140 143
141 144 mr_update_load_balance_params(map, lbInfo);
142 145
143 146 return (1);
144 147 }
145 148
146 149 U32
147 150 MR_GetSpanBlock(U32 ld, U64 row, U64 *span_blk, MR_FW_RAID_MAP_ALL *map,
148 151 int *div_error)
149 152 {
150 153 MR_SPAN_BLOCK_INFO *pSpanBlock = MR_LdSpanInfoGet(ld, map);
151 154 MR_QUAD_ELEMENT *qe;
152 155 MR_LD_RAID *raid = MR_LdRaidGet(ld, map);
153 156 U32 span, j;
154 157
155 158 for (span = 0; span < raid->spanDepth; span++, pSpanBlock++) {
156 159 for (j = 0; j < pSpanBlock->block_span_info.noElements; j++) {
157 160 qe = &pSpanBlock->block_span_info.quads[j];
158 161 if (qe->diff == 0) {
159 162 *div_error = 1;
160 163 return (span);
161 164 }
162 165 if (qe->logStart <= row && row <= qe->logEnd &&
163 166 (((row - qe->logStart) % qe->diff)) == 0) {
164 167 if (span_blk != NULL) {
165 168 U64 blk;
166 169 blk = ((row - qe->logStart) /
167 170 (qe->diff));
168 171
169 172 blk = (blk + qe->offsetInSpan) <<
170 173 raid->stripeShift;
171 174 *span_blk = blk;
172 175 }
173 176 return (span);
174 177 }
175 178 }
176 179 }
177 180 return (span);
178 181 }
179 182
180 183
181 184 /*
182 185 * *************************************************************
183 186 *
184 187 * This routine calculates the arm, span and block for
185 188 * the specified stripe and reference in stripe.
186 189 *
187 190 * Inputs :
188 191 *
189 192 * ld - Logical drive number
190 193 * stripRow - Stripe number
191 194 * stripRef - Reference in stripe
192 195 *
193 196 * Outputs :
194 197 *
195 198 * span - Span number
196 199 * block - Absolute Block number in the physical disk
197 200 */
198 201 U8
199 202 MR_GetPhyParams(struct mrsas_instance *instance, U32 ld, U64 stripRow,
200 203 U16 stripRef, U64 *pdBlock, U16 *pDevHandle,
201 204 MPI2_SCSI_IO_VENDOR_UNIQUE *pRAID_Context, MR_FW_RAID_MAP_ALL *map)
|
↓ open down ↓ |
168 lines elided |
↑ open up ↑ |
202 205 {
203 206 MR_LD_RAID *raid = MR_LdRaidGet(ld, map);
204 207 U32 pd, arRef;
205 208 U8 physArm, span;
206 209 U64 row;
207 210 int error_code = 0;
208 211 U8 retval = TRUE;
209 212 U32 rowMod;
210 213 U32 armQ;
211 214 U32 arm;
215 + U16 devid = instance->device_id;
212 216
213 217 ASSERT(raid->rowDataSize != 0);
214 218
215 219 row = (stripRow / raid->rowDataSize);
216 220
217 221 if (raid->level == 6) {
218 222 U32 logArm = (stripRow % (raid->rowDataSize));
219 223
220 224 if (raid->rowSize == 0) {
221 225 return (FALSE);
222 226 }
223 227 rowMod = (row % (raid->rowSize));
224 228 armQ = raid->rowSize-1-rowMod;
225 229 arm = armQ + 1 + logArm;
226 230 if (arm >= raid->rowSize)
227 231 arm -= raid->rowSize;
228 232 physArm = (U8)arm;
229 233 } else {
230 234 if (raid->modFactor == 0)
231 235 return (FALSE);
232 236 physArm = MR_LdDataArmGet(ld,
233 237 (stripRow % (raid->modFactor)), map);
234 238 }
235 239 if (raid->spanDepth == 1) {
236 240 span = 0;
237 241 *pdBlock = row << raid->stripeShift;
238 242 } else
239 243 span = (U8)MR_GetSpanBlock(ld, row, pdBlock, map, &error_code);
240 244
241 245 if (error_code == 1)
242 246 return (FALSE);
243 247
|
↓ open down ↓ |
22 lines elided |
↑ open up ↑ |
244 248 /* Get the array on which this span is present. */
245 249 arRef = MR_LdSpanArrayGet(ld, span, map);
246 250 /* Get the Pd. */
247 251 pd = MR_ArPdGet(arRef, physArm, map);
248 252 /* Get dev handle from Pd. */
249 253 if (pd != MR_PD_INVALID) {
250 254 *pDevHandle = MR_PdDevHandleGet(pd, map);
251 255 } else {
252 256 *pDevHandle = MR_PD_INVALID; /* set dev handle as invalid. */
253 257 if ((raid->level >= 5) &&
254 - ((instance->device_id != PCI_DEVICE_ID_LSI_INVADER) ||
255 - (instance->device_id == PCI_DEVICE_ID_LSI_INVADER &&
258 + ((devid != PCI_DEVICE_ID_LSI_INVADER) ||
259 + ((devid == PCI_DEVICE_ID_LSI_INVADER ||
260 + (devid == PCI_DEVICE_ID_LSI_FURY)) &&
256 261 raid->regTypeReqOnRead != REGION_TYPE_UNUSED))) {
257 262 pRAID_Context->regLockFlags = REGION_TYPE_EXCLUSIVE;
258 263 } else if (raid->level == 1) {
259 264 /* Get Alternate Pd. */
260 265 pd = MR_ArPdGet(arRef, physArm + 1, map);
261 266 /* Get dev handle from Pd. */
262 267 if (pd != MR_PD_INVALID)
263 268 *pDevHandle = MR_PdDevHandleGet(pd, map);
264 269 }
265 270 }
266 271
267 272 *pdBlock += stripRef + MR_LdSpanPtrGet(ld, span, map)->startBlk;
268 273
269 274 pRAID_Context->spanArm = (span << RAID_CTX_SPANARM_SPAN_SHIFT) |
270 275 physArm;
271 276
272 277 return (retval);
273 278 }
274 279
275 280
276 281
277 282 /*
278 283 * ***********************************************************************
279 284 *
280 285 * MR_BuildRaidContext function
281 286 *
282 287 * This function will initiate command processing. The start/end row and strip
283 288 * information is calculated then the lock is acquired.
284 289 * This function will return 0 if region lock
285 290 * was acquired OR return num strips ???
286 291 */
287 292
288 293 U8
289 294 MR_BuildRaidContext(struct mrsas_instance *instance,
290 295 struct IO_REQUEST_INFO *io_info, MPI2_SCSI_IO_VENDOR_UNIQUE *pRAID_Context,
291 296 MR_FW_RAID_MAP_ALL *map)
292 297 {
293 298 MR_LD_RAID *raid;
294 299 U32 ld, stripSize, stripe_mask;
295 300 U64 endLba, endStrip, endRow;
296 301 U64 start_row, start_strip;
297 302 REGION_KEY regStart;
298 303 REGION_LEN regSize;
299 304 U8 num_strips, numRows;
300 305 U16 ref_in_start_stripe;
301 306 U16 ref_in_end_stripe;
302 307
303 308 U64 ldStartBlock;
304 309 U32 numBlocks, ldTgtId;
305 310 U8 isRead;
306 311 U8 retval = 0;
307 312
308 313 ldStartBlock = io_info->ldStartBlock;
309 314 numBlocks = io_info->numBlocks;
310 315 ldTgtId = io_info->ldTgtId;
311 316 isRead = io_info->isRead;
312 317
313 318 if (map == NULL) {
314 319 io_info->fpOkForIo = FALSE;
315 320 return (FALSE);
316 321 }
317 322
318 323 ld = MR_TargetIdToLdGet(ldTgtId, map);
319 324
320 325 if (ld >= MAX_LOGICAL_DRIVES) {
321 326 io_info->fpOkForIo = FALSE;
322 327 return (FALSE);
323 328 }
324 329
325 330 raid = MR_LdRaidGet(ld, map);
326 331
327 332 stripSize = 1 << raid->stripeShift;
328 333 stripe_mask = stripSize-1;
329 334 /*
330 335 * calculate starting row and stripe, and number of strips and rows
331 336 */
332 337 start_strip = ldStartBlock >> raid->stripeShift;
333 338 ref_in_start_stripe = (U16)(ldStartBlock & stripe_mask);
334 339 endLba = ldStartBlock + numBlocks - 1;
335 340 ref_in_end_stripe = (U16)(endLba & stripe_mask);
336 341 endStrip = endLba >> raid->stripeShift;
337 342 num_strips = (U8)(endStrip - start_strip + 1);
338 343 /* Check to make sure is not dividing by zero */
339 344 if (raid->rowDataSize == 0)
340 345 return (FALSE);
341 346 start_row = (start_strip / raid->rowDataSize);
342 347 endRow = (endStrip / raid->rowDataSize);
343 348 /* get the row count */
344 349 numRows = (U8)(endRow - start_row + 1);
345 350
346 351 /*
347 352 * calculate region info.
348 353 */
349 354 regStart = start_row << raid->stripeShift;
350 355 regSize = stripSize;
351 356
352 357 /* Check if we can send this I/O via FastPath */
353 358 if (raid->capability.fpCapable) {
354 359 if (isRead) {
355 360 io_info->fpOkForIo = (raid->capability.fpReadCapable &&
356 361 ((num_strips == 1) ||
357 362 raid->capability.fpReadAcrossStripe));
358 363 } else {
359 364 io_info->fpOkForIo =
360 365 (raid->capability.fpWriteCapable &&
361 366 ((num_strips == 1) ||
362 367 raid->capability.fpWriteAcrossStripe));
363 368 }
364 369 } else
365 370 io_info->fpOkForIo = FALSE;
366 371
367 372
368 373 /*
369 374 * Check for DIF support
370 375 */
371 376 if (!raid->capability.ldPiMode) {
372 377 io_info->ldPI = FALSE;
373 378 } else {
374 379 io_info->ldPI = TRUE;
375 380 }
376 381
377 382 if (numRows == 1) {
378 383 if (num_strips == 1) {
379 384 regStart += ref_in_start_stripe;
380 385 regSize = numBlocks;
381 386 }
382 387 } else {
383 388 if (start_strip == (start_row + 1) * raid->rowDataSize - 1) {
384 389 regStart += ref_in_start_stripe;
385 390 regSize = stripSize - ref_in_start_stripe;
386 391 }
387 392
388 393 if (numRows > 2) {
389 394 regSize += (numRows - 2) << raid->stripeShift;
390 395 }
|
↓ open down ↓ |
125 lines elided |
↑ open up ↑ |
391 396
392 397 if (endStrip == endRow * raid->rowDataSize) {
393 398 regSize += ref_in_end_stripe + 1;
394 399 } else {
395 400 regSize += stripSize;
396 401 }
397 402 }
398 403
399 404 pRAID_Context->timeoutValue = map->raidMap.fpPdIoTimeoutSec;
400 405
401 - if (instance->device_id == PCI_DEVICE_ID_LSI_INVADER) {
406 + if ((instance->device_id == PCI_DEVICE_ID_LSI_INVADER) ||
407 + (instance->device_id == PCI_DEVICE_ID_LSI_FURY)) {
402 408 pRAID_Context->regLockFlags = (isRead) ?
403 409 raid->regTypeReqOnRead : raid->regTypeReqOnWrite;
404 410 } else {
405 411 pRAID_Context->regLockFlags = (isRead) ?
406 412 REGION_TYPE_SHARED_READ : raid->regTypeReqOnWrite;
407 413 }
408 414
409 415 pRAID_Context->ldTargetId = raid->targetId;
410 416 pRAID_Context->regLockRowLBA = regStart;
411 417 pRAID_Context->regLockLength = regSize;
412 418 pRAID_Context->configSeqNum = raid->seqNum;
413 419
414 420 /*
415 421 * Get Phy Params only if FP capable,
416 422 * or else leave it to MR firmware to do the calculation.
417 423 */
418 424 if (io_info->fpOkForIo) {
419 425 /* if fast path possible then get the physical parameters */
420 426 retval = MR_GetPhyParams(instance, ld, start_strip,
421 427 ref_in_start_stripe, &io_info->pdBlock,
422 428 &io_info->devHandle, pRAID_Context, map);
423 429
424 430 /* If IO on an invalid Pd, then FP is not possible. */
425 431 if (io_info->devHandle == MR_PD_INVALID)
426 432 io_info->fpOkForIo = FALSE;
427 433
428 434 return (retval);
429 435
430 436 } else if (isRead) {
431 437 uint_t stripIdx;
432 438
433 439 for (stripIdx = 0; stripIdx < num_strips; stripIdx++) {
434 440 if (!MR_GetPhyParams(instance, ld,
435 441 start_strip + stripIdx, ref_in_start_stripe,
436 442 &io_info->pdBlock, &io_info->devHandle,
437 443 pRAID_Context, map)) {
438 444 return (TRUE);
439 445 }
440 446 }
441 447 }
442 448 return (TRUE);
443 449 }
444 450
445 451
446 452 void
447 453 mr_update_load_balance_params(MR_FW_RAID_MAP_ALL *map,
448 454 PLD_LOAD_BALANCE_INFO lbInfo)
449 455 {
450 456 int ldCount;
451 457 U16 ld;
452 458 MR_LD_RAID *raid;
453 459
454 460 for (ldCount = 0; ldCount < MAX_LOGICAL_DRIVES; ldCount++) {
455 461 ld = MR_TargetIdToLdGet(ldCount, map);
456 462
457 463 if (ld >= MAX_LOGICAL_DRIVES) {
458 464 con_log(CL_ANN1,
459 465 (CE_NOTE, "mrsas: ld=%d Invalid ld \n", ld));
460 466 continue;
461 467 }
462 468
463 469 raid = MR_LdRaidGet(ld, map);
464 470
465 471 /* Two drive Optimal RAID 1 */
466 472 if ((raid->level == 1) && (raid->rowSize == 2) &&
467 473 (raid->spanDepth == 1) &&
468 474 raid->ldState == MR_LD_STATE_OPTIMAL) {
469 475 U32 pd, arRef;
470 476
471 477 lbInfo[ldCount].loadBalanceFlag = 1;
472 478
473 479 /* Get the array on which this span is present. */
474 480 arRef = MR_LdSpanArrayGet(ld, 0, map);
475 481
476 482 pd = MR_ArPdGet(arRef, 0, map); /* Get the Pd. */
477 483 /* Get dev handle from Pd. */
478 484 lbInfo[ldCount].raid1DevHandle[0] =
479 485 MR_PdDevHandleGet(pd, map);
480 486
481 487 pd = MR_ArPdGet(arRef, 1, map); /* Get the Pd. */
482 488 /* Get dev handle from Pd. */
483 489 lbInfo[ldCount].raid1DevHandle[1] =
484 490 MR_PdDevHandleGet(pd, map);
485 491 con_log(CL_ANN1, (CE_NOTE,
486 492 "mrsas: ld=%d load balancing enabled \n", ldCount));
487 493 } else {
488 494 lbInfo[ldCount].loadBalanceFlag = 0;
489 495 }
490 496 }
491 497 }
492 498
493 499
494 500 U8
495 501 megasas_get_best_arm(PLD_LOAD_BALANCE_INFO lbInfo, U8 arm, U64 block,
496 502 U32 count)
497 503 {
498 504 U16 pend0, pend1;
499 505 U64 diff0, diff1;
500 506 U8 bestArm;
501 507
502 508 /* get the pending cmds for the data and mirror arms */
503 509 pend0 = lbInfo->scsi_pending_cmds[0];
504 510 pend1 = lbInfo->scsi_pending_cmds[1];
505 511
506 512 /* Determine the disk whose head is nearer to the req. block */
507 513 diff0 = ABS_DIFF(block, lbInfo->last_accessed_block[0]);
508 514 diff1 = ABS_DIFF(block, lbInfo->last_accessed_block[1]);
509 515 bestArm = (diff0 <= diff1 ? 0 : 1);
510 516
511 517 if ((bestArm == arm && pend0 > pend1 + 16) ||
512 518 (bestArm != arm && pend1 > pend0 + 16)) {
513 519 bestArm ^= 1;
514 520 }
515 521
516 522 /* Update the last accessed block on the correct pd */
517 523 lbInfo->last_accessed_block[bestArm] = block + count - 1;
518 524 return (bestArm);
519 525 }
520 526
521 527 U16
522 528 get_updated_dev_handle(PLD_LOAD_BALANCE_INFO lbInfo,
523 529 struct IO_REQUEST_INFO *io_info)
524 530 {
525 531 U8 arm, old_arm;
526 532 U16 devHandle;
527 533
528 534 old_arm = lbInfo->raid1DevHandle[0] == io_info->devHandle ? 0 : 1;
529 535
530 536 /* get best new arm */
531 537 arm = megasas_get_best_arm(lbInfo, old_arm, io_info->ldStartBlock,
532 538 io_info->numBlocks);
533 539
534 540 devHandle = lbInfo->raid1DevHandle[arm];
535 541
536 542 lbInfo->scsi_pending_cmds[arm]++;
537 543
538 544 return (devHandle);
539 545 }
|
↓ open down ↓ |
128 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX