aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--drivers/scsi/megaraid/megaraid_sas.h2
-rw-r--r--drivers/scsi/megaraid/megaraid_sas_base.c15
-rw-r--r--drivers/scsi/megaraid/megaraid_sas_fp.c266
-rw-r--r--drivers/scsi/megaraid/megaraid_sas_fusion.c5
4 files changed, 2 insertions, 286 deletions
diff --git a/drivers/scsi/megaraid/megaraid_sas.h b/drivers/scsi/megaraid/megaraid_sas.h
index 42c0e1ff7177..dc331e8224da 100644
--- a/drivers/scsi/megaraid/megaraid_sas.h
+++ b/drivers/scsi/megaraid/megaraid_sas.h
@@ -1403,8 +1403,6 @@ struct megasas_ctrl_info {
1403 1403
1404#define MEGASAS_FW_BUSY 1 1404#define MEGASAS_FW_BUSY 1
1405 1405
1406#define VD_EXT_DEBUG 0
1407
1408/* Driver's internal Logging levels*/ 1406/* Driver's internal Logging levels*/
1409#define OCR_LOGS (1 << 0) 1407#define OCR_LOGS (1 << 0)
1410 1408
diff --git a/drivers/scsi/megaraid/megaraid_sas_base.c b/drivers/scsi/megaraid/megaraid_sas_base.c
index 0e7121d757c2..5e0dea14287f 100644
--- a/drivers/scsi/megaraid/megaraid_sas_base.c
+++ b/drivers/scsi/megaraid/megaraid_sas_base.c
@@ -4601,17 +4601,6 @@ static void megasas_update_ext_vd_details(struct megasas_instance *instance)
4601 } 4601 }
4602 /* irrespective of FW raid maps, driver raid map is constant */ 4602 /* irrespective of FW raid maps, driver raid map is constant */
4603 fusion->drv_map_sz = sizeof(struct MR_DRV_RAID_MAP_ALL); 4603 fusion->drv_map_sz = sizeof(struct MR_DRV_RAID_MAP_ALL);
4604
4605#if VD_EXT_DEBUG
4606 dev_info(&instance->pdev->dev, "instance->max_raid_mapsize 0x%x\n ",
4607 instance->max_raid_mapsize);
4608 dev_info(&instance->pdev->dev, "new_map_sz = 0x%x, old_map_sz = 0x%x\n",
4609 fusion->new_map_sz, fusion->old_map_sz);
4610 dev_info(&instance->pdev->dev, "ventura_map_sz = 0x%x, current_map_sz = 0x%x\n",
4611 ventura_map_sz, fusion->current_map_sz);
4612 dev_info(&instance->pdev->dev, "fusion->drv_map_sz =0x%x, size of driver raid map 0x%lx\n",
4613 fusion->drv_map_sz, sizeof(struct MR_DRV_RAID_MAP_ALL));
4614#endif
4615} 4604}
4616 4605
4617/** 4606/**
@@ -5215,10 +5204,6 @@ static int megasas_init_fw(struct megasas_instance *instance)
5215 if (instance->is_ventura) { 5204 if (instance->is_ventura) {
5216 scratch_pad_3 = 5205 scratch_pad_3 =
5217 readl(&instance->reg_set->outbound_scratch_pad_3); 5206 readl(&instance->reg_set->outbound_scratch_pad_3);
5218#if VD_EXT_DEBUG
5219 dev_info(&instance->pdev->dev, "scratch_pad3 0x%x\n",
5220 scratch_pad_3);
5221#endif
5222 instance->max_raid_mapsize = ((scratch_pad_3 >> 5207 instance->max_raid_mapsize = ((scratch_pad_3 >>
5223 MR_MAX_RAID_MAP_SIZE_OFFSET_SHIFT) & 5208 MR_MAX_RAID_MAP_SIZE_OFFSET_SHIFT) &
5224 MR_MAX_RAID_MAP_SIZE_MASK); 5209 MR_MAX_RAID_MAP_SIZE_MASK);
diff --git a/drivers/scsi/megaraid/megaraid_sas_fp.c b/drivers/scsi/megaraid/megaraid_sas_fp.c
index a5517e72ad2f..7dc7708a7957 100644
--- a/drivers/scsi/megaraid/megaraid_sas_fp.c
+++ b/drivers/scsi/megaraid/megaraid_sas_fp.c
@@ -77,7 +77,6 @@ MODULE_PARM_DESC(lb_pending_cmds, "Change raid-1 load balancing outstanding "
77#endif 77#endif
78#define TRUE 1 78#define TRUE 1
79 79
80#define SPAN_DEBUG 0
81#define SPAN_ROW_SIZE(map, ld, index_) (MR_LdSpanPtrGet(ld, index_, map)->spanRowSize) 80#define SPAN_ROW_SIZE(map, ld, index_) (MR_LdSpanPtrGet(ld, index_, map)->spanRowSize)
82#define SPAN_ROW_DATA_SIZE(map_, ld, index_) (MR_LdSpanPtrGet(ld, index_, map)->spanRowDataSize) 81#define SPAN_ROW_DATA_SIZE(map_, ld, index_) (MR_LdSpanPtrGet(ld, index_, map)->spanRowDataSize)
83#define SPAN_INVALID 0xff 82#define SPAN_INVALID 0xff
@@ -202,16 +201,6 @@ void MR_PopulateDrvRaidMap(struct megasas_instance *instance)
202 201
203 if (instance->max_raid_mapsize) { 202 if (instance->max_raid_mapsize) {
204 fw_map_dyn = fusion->ld_map[(instance->map_id & 1)]; 203 fw_map_dyn = fusion->ld_map[(instance->map_id & 1)];
205#if VD_EXT_DEBUG
206 dev_dbg(&instance->pdev->dev, "raidMapSize 0x%x fw_map_dyn->descTableOffset 0x%x\n",
207 le32_to_cpu(fw_map_dyn->raid_map_size),
208 le32_to_cpu(fw_map_dyn->desc_table_offset));
209 dev_dbg(&instance->pdev->dev, "descTableSize 0x%x descTableNumElements 0x%x\n",
210 le32_to_cpu(fw_map_dyn->desc_table_size),
211 le32_to_cpu(fw_map_dyn->desc_table_num_elements));
212 dev_dbg(&instance->pdev->dev, "drv map %p ldCount %d\n",
213 drv_map, le16_to_cpu(fw_map_dyn->ld_count));
214#endif
215 desc_table = 204 desc_table =
216 (struct MR_RAID_MAP_DESC_TABLE *)((void *)fw_map_dyn + le32_to_cpu(fw_map_dyn->desc_table_offset)); 205 (struct MR_RAID_MAP_DESC_TABLE *)((void *)fw_map_dyn + le32_to_cpu(fw_map_dyn->desc_table_offset));
217 if (desc_table != fw_map_dyn->raid_map_desc_table) 206 if (desc_table != fw_map_dyn->raid_map_desc_table)
@@ -230,25 +219,10 @@ void MR_PopulateDrvRaidMap(struct megasas_instance *instance)
230 le32_to_cpu(fw_map_dyn->desc_table_size); 219 le32_to_cpu(fw_map_dyn->desc_table_size);
231 220
232 for (i = 0; i < le32_to_cpu(fw_map_dyn->desc_table_num_elements); ++i) { 221 for (i = 0; i < le32_to_cpu(fw_map_dyn->desc_table_num_elements); ++i) {
233
234#if VD_EXT_DEBUG
235 dev_dbg(&instance->pdev->dev, "desc table %p\n",
236 desc_table);
237 dev_dbg(&instance->pdev->dev, "raidmap type %d, raidmapOffset 0x%x\n",
238 le32_to_cpu(desc_table->raid_map_desc_type),
239 le32_to_cpu(desc_table->raid_map_desc_offset));
240 dev_dbg(&instance->pdev->dev, "raid map number of elements 0%x, raidmapsize 0x%x\n",
241 le32_to_cpu(desc_table->raid_map_desc_elements),
242 le32_to_cpu(desc_table->raid_map_desc_buffer_size));
243#endif
244 switch (le32_to_cpu(desc_table->raid_map_desc_type)) { 222 switch (le32_to_cpu(desc_table->raid_map_desc_type)) {
245 case RAID_MAP_DESC_TYPE_DEVHDL_INFO: 223 case RAID_MAP_DESC_TYPE_DEVHDL_INFO:
246 fw_map_dyn->dev_hndl_info = 224 fw_map_dyn->dev_hndl_info =
247 (struct MR_DEV_HANDLE_INFO *)(raid_map_data + le32_to_cpu(desc_table->raid_map_desc_offset)); 225 (struct MR_DEV_HANDLE_INFO *)(raid_map_data + le32_to_cpu(desc_table->raid_map_desc_offset));
248#if VD_EXT_DEBUG
249 dev_dbg(&instance->pdev->dev, "devHndlInfo address %p\n",
250 fw_map_dyn->dev_hndl_info);
251#endif
252 memcpy(pDrvRaidMap->devHndlInfo, 226 memcpy(pDrvRaidMap->devHndlInfo,
253 fw_map_dyn->dev_hndl_info, 227 fw_map_dyn->dev_hndl_info,
254 sizeof(struct MR_DEV_HANDLE_INFO) * 228 sizeof(struct MR_DEV_HANDLE_INFO) *
@@ -258,28 +232,15 @@ void MR_PopulateDrvRaidMap(struct megasas_instance *instance)
258 fw_map_dyn->ld_tgt_id_to_ld = 232 fw_map_dyn->ld_tgt_id_to_ld =
259 (u16 *) (raid_map_data + 233 (u16 *) (raid_map_data +
260 le32_to_cpu(desc_table->raid_map_desc_offset)); 234 le32_to_cpu(desc_table->raid_map_desc_offset));
261#if VD_EXT_DEBUG
262 dev_dbg(&instance->pdev->dev, "ldTgtIdToLd address %p\n",
263 fw_map_dyn->ld_tgt_id_to_ld);
264#endif
265 for (j = 0; j < le32_to_cpu(desc_table->raid_map_desc_elements); j++) { 235 for (j = 0; j < le32_to_cpu(desc_table->raid_map_desc_elements); j++) {
266 pDrvRaidMap->ldTgtIdToLd[j] = 236 pDrvRaidMap->ldTgtIdToLd[j] =
267 le16_to_cpu(fw_map_dyn->ld_tgt_id_to_ld[j]); 237 le16_to_cpu(fw_map_dyn->ld_tgt_id_to_ld[j]);
268#if VD_EXT_DEBUG
269 dev_dbg(&instance->pdev->dev, " %d drv ldTgtIdToLd %d\n",
270 j, pDrvRaidMap->ldTgtIdToLd[j]);
271#endif
272 } 238 }
273 break; 239 break;
274 case RAID_MAP_DESC_TYPE_ARRAY_INFO: 240 case RAID_MAP_DESC_TYPE_ARRAY_INFO:
275 fw_map_dyn->ar_map_info = 241 fw_map_dyn->ar_map_info =
276 (struct MR_ARRAY_INFO *) 242 (struct MR_ARRAY_INFO *)
277 (raid_map_data + le32_to_cpu(desc_table->raid_map_desc_offset)); 243 (raid_map_data + le32_to_cpu(desc_table->raid_map_desc_offset));
278#if VD_EXT_DEBUG
279 dev_dbg(&instance->pdev->dev, "arMapInfo address %p\n",
280 fw_map_dyn->ar_map_info);
281#endif
282
283 memcpy(pDrvRaidMap->arMapInfo, 244 memcpy(pDrvRaidMap->arMapInfo,
284 fw_map_dyn->ar_map_info, 245 fw_map_dyn->ar_map_info,
285 sizeof(struct MR_ARRAY_INFO) * le32_to_cpu(desc_table->raid_map_desc_elements)); 246 sizeof(struct MR_ARRAY_INFO) * le32_to_cpu(desc_table->raid_map_desc_elements));
@@ -291,34 +252,6 @@ void MR_PopulateDrvRaidMap(struct megasas_instance *instance)
291 memcpy(pDrvRaidMap->ldSpanMap, 252 memcpy(pDrvRaidMap->ldSpanMap,
292 fw_map_dyn->ld_span_map, 253 fw_map_dyn->ld_span_map,
293 sizeof(struct MR_LD_SPAN_MAP) * le32_to_cpu(desc_table->raid_map_desc_elements)); 254 sizeof(struct MR_LD_SPAN_MAP) * le32_to_cpu(desc_table->raid_map_desc_elements));
294#if VD_EXT_DEBUG
295 dev_dbg(&instance->pdev->dev, "ldSpanMap address %p\n",
296 fw_map_dyn->ld_span_map);
297 dev_dbg(&instance->pdev->dev, "MR_LD_SPAN_MAP size 0x%lx\n",
298 sizeof(struct MR_LD_SPAN_MAP));
299 for (j = 0; j < ld_count; j++) {
300 dev_dbg(&instance->pdev->dev, "megaraid_sas(%d) : fw_map_dyn->ldSpanMap[%d].ldRaid.targetId 0x%x\n",
301 j, j, fw_map_dyn->ld_span_map[j].ldRaid.targetId);
302 dev_dbg(&instance->pdev->dev, "fw_map_dyn->ldSpanMap[%d].ldRaid.seqNum 0x%x\n",
303 j, fw_map_dyn->ld_span_map[j].ldRaid.seqNum);
304 dev_dbg(&instance->pdev->dev, "fw_map_dyn->ld_span_map[%d].ldRaid.rowSize 0x%x\n",
305 j, (u32)fw_map_dyn->ld_span_map[j].ldRaid.rowSize);
306
307 dev_dbg(&instance->pdev->dev, "megaraid_sas(%d) :pDrvRaidMap->ldSpanMap[%d].ldRaid.targetId 0x%x\n",
308 j, j, pDrvRaidMap->ldSpanMap[j].ldRaid.targetId);
309 dev_dbg(&instance->pdev->dev, "DrvRaidMap->ldSpanMap[%d].ldRaid.seqNum 0x%x\n",
310 j, pDrvRaidMap->ldSpanMap[j].ldRaid.seqNum);
311 dev_dbg(&instance->pdev->dev, "pDrvRaidMap->ldSpanMap[%d].ldRaid.rowSize 0x%x\n",
312 j, (u32)pDrvRaidMap->ldSpanMap[j].ldRaid.rowSize);
313
314 dev_dbg(&instance->pdev->dev, "megaraid_sas(%d) : drv raid map all %p\n",
315 instance->unique_id, drv_map);
316 dev_dbg(&instance->pdev->dev, "raid map %p LD RAID MAP %p/%p\n",
317 pDrvRaidMap,
318 &fw_map_dyn->ld_span_map[j].ldRaid,
319 &pDrvRaidMap->ldSpanMap[j].ldRaid);
320 }
321#endif
322 break; 255 break;
323 default: 256 default:
324 dev_dbg(&instance->pdev->dev, "wrong number of desctableElements %d\n", 257 dev_dbg(&instance->pdev->dev, "wrong number of desctableElements %d\n",
@@ -335,17 +268,6 @@ void MR_PopulateDrvRaidMap(struct megasas_instance *instance)
335 dev_dbg(&instance->pdev->dev, "megaraid_sas: LD count exposed in RAID map in not valid\n"); 268 dev_dbg(&instance->pdev->dev, "megaraid_sas: LD count exposed in RAID map in not valid\n");
336 return; 269 return;
337 } 270 }
338#if VD_EXT_DEBUG
339 for (i = 0; i < ld_count; i++) {
340 dev_dbg(&instance->pdev->dev, "megaraid_sas(%d) :Index 0x%x\n",
341 instance->unique_id, i);
342 dev_dbg(&instance->pdev->dev, "Target Id 0x%x\n",
343 fw_map_ext->ldSpanMap[i].ldRaid.targetId);
344 dev_dbg(&instance->pdev->dev, "Seq Num 0x%x Size 0/%llx\n",
345 fw_map_ext->ldSpanMap[i].ldRaid.seqNum,
346 fw_map_ext->ldSpanMap[i].ldRaid.size);
347 }
348#endif
349 271
350 pDrvRaidMap->ldCount = (__le16)cpu_to_le16(ld_count); 272 pDrvRaidMap->ldCount = (__le16)cpu_to_le16(ld_count);
351 pDrvRaidMap->fpPdIoTimeoutSec = fw_map_ext->fpPdIoTimeoutSec; 273 pDrvRaidMap->fpPdIoTimeoutSec = fw_map_ext->fpPdIoTimeoutSec;
@@ -354,29 +276,6 @@ void MR_PopulateDrvRaidMap(struct megasas_instance *instance)
354 (u16)fw_map_ext->ldTgtIdToLd[i]; 276 (u16)fw_map_ext->ldTgtIdToLd[i];
355 memcpy(pDrvRaidMap->ldSpanMap, fw_map_ext->ldSpanMap, 277 memcpy(pDrvRaidMap->ldSpanMap, fw_map_ext->ldSpanMap,
356 sizeof(struct MR_LD_SPAN_MAP) * ld_count); 278 sizeof(struct MR_LD_SPAN_MAP) * ld_count);
357#if VD_EXT_DEBUG
358 for (i = 0; i < ld_count; i++) {
359 dev_dbg(&instance->pdev->dev, "megaraid_sas(%d) : fw_map_ext->ldSpanMap[%d].ldRaid.targetId 0x%x\n",
360 i, i, fw_map_ext->ldSpanMap[i].ldRaid.targetId);
361 dev_dbg(&instance->pdev->dev, "fw_map_ext->ldSpanMap[%d].ldRaid.seqNum 0x%x\n",
362 i, fw_map_ext->ldSpanMap[i].ldRaid.seqNum);
363 dev_dbg(&instance->pdev->dev, "fw_map_ext->ldSpanMap[%d].ldRaid.rowSize 0x%x\n",
364 i, (u32)fw_map_ext->ldSpanMap[i].ldRaid.rowSize);
365
366 dev_dbg(&instance->pdev->dev, "megaraid_sas(%d) : pDrvRaidMap->ldSpanMap[%d].ldRaid.targetId 0x%x\n",
367 i, i, pDrvRaidMap->ldSpanMap[i].ldRaid.targetId);
368 dev_dbg(&instance->pdev->dev, "pDrvRaidMap->ldSpanMap[%d].ldRaid.seqNum 0x%x\n",
369 i, pDrvRaidMap->ldSpanMap[i].ldRaid.seqNum);
370 dev_dbg(&instance->pdev->dev, "pDrvRaidMap->ldSpanMap[%d].ldRaid.rowSize 0x%x\n",
371 i, (u32)pDrvRaidMap->ldSpanMap[i].ldRaid.rowSize);
372
373 dev_dbg(&instance->pdev->dev, "megaraid_sas(%d) : drv raid map all %p\n",
374 instance->unique_id, drv_map);
375 dev_dbg(&instance->pdev->dev, "raid map %p LD RAID MAP %p %p\n",
376 pDrvRaidMap, &fw_map_ext->ldSpanMap[i].ldRaid,
377 &pDrvRaidMap->ldSpanMap[i].ldRaid);
378 }
379#endif
380 memcpy(pDrvRaidMap->arMapInfo, fw_map_ext->arMapInfo, 279 memcpy(pDrvRaidMap->arMapInfo, fw_map_ext->arMapInfo,
381 sizeof(struct MR_ARRAY_INFO) * MAX_API_ARRAYS_EXT); 280 sizeof(struct MR_ARRAY_INFO) * MAX_API_ARRAYS_EXT);
382 memcpy(pDrvRaidMap->devHndlInfo, fw_map_ext->devHndlInfo, 281 memcpy(pDrvRaidMap->devHndlInfo, fw_map_ext->devHndlInfo,
@@ -393,18 +292,6 @@ void MR_PopulateDrvRaidMap(struct megasas_instance *instance)
393 fusion->ld_map[(instance->map_id & 1)]; 292 fusion->ld_map[(instance->map_id & 1)];
394 pFwRaidMap = &fw_map_old->raidMap; 293 pFwRaidMap = &fw_map_old->raidMap;
395 ld_count = (u16)le32_to_cpu(pFwRaidMap->ldCount); 294 ld_count = (u16)le32_to_cpu(pFwRaidMap->ldCount);
396
397#if VD_EXT_DEBUG
398 for (i = 0; i < ld_count; i++) {
399 dev_dbg(&instance->pdev->dev, "(%d) :Index 0x%x "
400 "Target Id 0x%x Seq Num 0x%x Size 0/%llx\n",
401 instance->unique_id, i,
402 fw_map_old->raidMap.ldSpanMap[i].ldRaid.targetId,
403 fw_map_old->raidMap.ldSpanMap[i].ldRaid.seqNum,
404 fw_map_old->raidMap.ldSpanMap[i].ldRaid.size);
405 }
406#endif
407
408 pDrvRaidMap->totalSize = pFwRaidMap->totalSize; 295 pDrvRaidMap->totalSize = pFwRaidMap->totalSize;
409 pDrvRaidMap->ldCount = (__le16)cpu_to_le16(ld_count); 296 pDrvRaidMap->ldCount = (__le16)cpu_to_le16(ld_count);
410 pDrvRaidMap->fpPdIoTimeoutSec = pFwRaidMap->fpPdIoTimeoutSec; 297 pDrvRaidMap->fpPdIoTimeoutSec = pFwRaidMap->fpPdIoTimeoutSec;
@@ -413,26 +300,6 @@ void MR_PopulateDrvRaidMap(struct megasas_instance *instance)
413 (u8)pFwRaidMap->ldTgtIdToLd[i]; 300 (u8)pFwRaidMap->ldTgtIdToLd[i];
414 for (i = 0; i < ld_count; i++) { 301 for (i = 0; i < ld_count; i++) {
415 pDrvRaidMap->ldSpanMap[i] = pFwRaidMap->ldSpanMap[i]; 302 pDrvRaidMap->ldSpanMap[i] = pFwRaidMap->ldSpanMap[i];
416#if VD_EXT_DEBUG
417 dev_dbg(&instance->pdev->dev,
418 "pFwRaidMap->ldSpanMap[%d].ldRaid.targetId 0x%x "
419 "pFwRaidMap->ldSpanMap[%d].ldRaid.seqNum 0x%x "
420 "size 0x%x\n", i, i,
421 pFwRaidMap->ldSpanMap[i].ldRaid.targetId,
422 pFwRaidMap->ldSpanMap[i].ldRaid.seqNum,
423 (u32)pFwRaidMap->ldSpanMap[i].ldRaid.rowSize);
424 dev_dbg(&instance->pdev->dev,
425 "pDrvRaidMap->ldSpanMap[%d].ldRaid.targetId 0x%x "
426 "pDrvRaidMap->ldSpanMap[%d].ldRaid.seqNum 0x%x "
427 "size 0x%x\n", i, i,
428 pDrvRaidMap->ldSpanMap[i].ldRaid.targetId,
429 pDrvRaidMap->ldSpanMap[i].ldRaid.seqNum,
430 (u32)pDrvRaidMap->ldSpanMap[i].ldRaid.rowSize);
431 dev_dbg(&instance->pdev->dev, "Driver raid map all %p "
432 "raid map %p LD RAID MAP %p/%p\n", drv_map,
433 pDrvRaidMap, &pFwRaidMap->ldSpanMap[i].ldRaid,
434 &pDrvRaidMap->ldSpanMap[i].ldRaid);
435#endif
436 } 303 }
437 memcpy(pDrvRaidMap->arMapInfo, pFwRaidMap->arMapInfo, 304 memcpy(pDrvRaidMap->arMapInfo, pFwRaidMap->arMapInfo,
438 sizeof(struct MR_ARRAY_INFO) * MAX_RAIDMAP_ARRAYS); 305 sizeof(struct MR_ARRAY_INFO) * MAX_RAIDMAP_ARRAYS);
@@ -548,91 +415,6 @@ u32 MR_GetSpanBlock(u32 ld, u64 row, u64 *span_blk,
548/* 415/*
549****************************************************************************** 416******************************************************************************
550* 417*
551* Function to print info about span set created in driver from FW raid map
552*
553* Inputs :
554* map - LD map
555* ldSpanInfo - ldSpanInfo per HBA instance
556*/
557#if SPAN_DEBUG
558static int getSpanInfo(struct MR_DRV_RAID_MAP_ALL *map,
559 PLD_SPAN_INFO ldSpanInfo)
560{
561
562 u8 span;
563 u32 element;
564 struct MR_LD_RAID *raid;
565 LD_SPAN_SET *span_set;
566 struct MR_QUAD_ELEMENT *quad;
567 int ldCount;
568 u16 ld;
569
570 for (ldCount = 0; ldCount < MAX_LOGICAL_DRIVES_EXT; ldCount++) {
571 ld = MR_TargetIdToLdGet(ldCount, map);
572 if (ld >= (MAX_LOGICAL_DRIVES_EXT - 1))
573 continue;
574 raid = MR_LdRaidGet(ld, map);
575 dev_dbg(&instance->pdev->dev, "LD %x: span_depth=%x\n",
576 ld, raid->spanDepth);
577 for (span = 0; span < raid->spanDepth; span++)
578 dev_dbg(&instance->pdev->dev, "Span=%x,"
579 " number of quads=%x\n", span,
580 le32_to_cpu(map->raidMap.ldSpanMap[ld].spanBlock[span].
581 block_span_info.noElements));
582 for (element = 0; element < MAX_QUAD_DEPTH; element++) {
583 span_set = &(ldSpanInfo[ld].span_set[element]);
584 if (span_set->span_row_data_width == 0)
585 break;
586
587 dev_dbg(&instance->pdev->dev, "Span Set %x:"
588 "width=%x, diff=%x\n", element,
589 (unsigned int)span_set->span_row_data_width,
590 (unsigned int)span_set->diff);
591 dev_dbg(&instance->pdev->dev, "logical LBA"
592 "start=0x%08lx, end=0x%08lx\n",
593 (long unsigned int)span_set->log_start_lba,
594 (long unsigned int)span_set->log_end_lba);
595 dev_dbg(&instance->pdev->dev, "span row start=0x%08lx,"
596 " end=0x%08lx\n",
597 (long unsigned int)span_set->span_row_start,
598 (long unsigned int)span_set->span_row_end);
599 dev_dbg(&instance->pdev->dev, "data row start=0x%08lx,"
600 " end=0x%08lx\n",
601 (long unsigned int)span_set->data_row_start,
602 (long unsigned int)span_set->data_row_end);
603 dev_dbg(&instance->pdev->dev, "data strip start=0x%08lx,"
604 " end=0x%08lx\n",
605 (long unsigned int)span_set->data_strip_start,
606 (long unsigned int)span_set->data_strip_end);
607
608 for (span = 0; span < raid->spanDepth; span++) {
609 if (le32_to_cpu(map->raidMap.ldSpanMap[ld].spanBlock[span].
610 block_span_info.noElements) >=
611 element + 1) {
612 quad = &map->raidMap.ldSpanMap[ld].
613 spanBlock[span].block_span_info.
614 quad[element];
615 dev_dbg(&instance->pdev->dev, "Span=%x,"
616 "Quad=%x, diff=%x\n", span,
617 element, le32_to_cpu(quad->diff));
618 dev_dbg(&instance->pdev->dev,
619 "offset_in_span=0x%08lx\n",
620 (long unsigned int)le64_to_cpu(quad->offsetInSpan));
621 dev_dbg(&instance->pdev->dev,
622 "logical start=0x%08lx, end=0x%08lx\n",
623 (long unsigned int)le64_to_cpu(quad->logStart),
624 (long unsigned int)le64_to_cpu(quad->logEnd));
625 }
626 }
627 }
628 }
629 return 0;
630}
631#endif
632
633/*
634******************************************************************************
635*
636* This routine calculates the Span block for given row using spanset. 418* This routine calculates the Span block for given row using spanset.
637* 419*
638* Inputs : 420* Inputs :
@@ -743,19 +525,7 @@ static u64 get_row_from_strip(struct megasas_instance *instance,
743 else 525 else
744 break; 526 break;
745 } 527 }
746#if SPAN_DEBUG 528
747 dev_info(&instance->pdev->dev, "Strip 0x%llx,"
748 "span_set_Strip 0x%llx, span_set_Row 0x%llx"
749 "data width 0x%llx span offset 0x%x\n", strip,
750 (unsigned long long)span_set_Strip,
751 (unsigned long long)span_set_Row,
752 (unsigned long long)span_set->span_row_data_width,
753 span_offset);
754 dev_info(&instance->pdev->dev, "For strip 0x%llx"
755 "row is 0x%llx\n", strip,
756 (unsigned long long) span_set->data_row_start +
757 (unsigned long long) span_set_Row + (span_offset - 1));
758#endif
759 retval = (span_set->data_row_start + span_set_Row + 529 retval = (span_set->data_row_start + span_set_Row +
760 (span_offset - 1)); 530 (span_offset - 1));
761 return retval; 531 return retval;
@@ -872,11 +642,7 @@ static u32 get_arm_from_strip(struct megasas_instance *instance,
872 else 642 else
873 break; 643 break;
874 } 644 }
875#if SPAN_DEBUG 645
876 dev_info(&instance->pdev->dev, "get_arm_from_strip:"
877 "for ld=0x%x strip=0x%lx arm is 0x%x\n", ld,
878 (long unsigned int)strip, (strip_offset - span_offset));
879#endif
880 retval = (strip_offset - span_offset); 646 retval = (strip_offset - span_offset);
881 return retval; 647 return retval;
882 } 648 }
@@ -1239,17 +1005,6 @@ MR_BuildRaidContext(struct megasas_instance *instance,
1239 } 1005 }
1240 io_info->start_span = startlba_span; 1006 io_info->start_span = startlba_span;
1241 io_info->start_row = start_row; 1007 io_info->start_row = start_row;
1242#if SPAN_DEBUG
1243 dev_dbg(&instance->pdev->dev, "Check Span number from %s %d"
1244 "for row 0x%llx, start strip 0x%llx end strip 0x%llx"
1245 " span 0x%x\n", __func__, __LINE__,
1246 (unsigned long long)start_row,
1247 (unsigned long long)start_strip,
1248 (unsigned long long)endStrip, startlba_span);
1249 dev_dbg(&instance->pdev->dev, "start_row 0x%llx endRow 0x%llx"
1250 "Start span 0x%x\n", (unsigned long long)start_row,
1251 (unsigned long long)endRow, startlba_span);
1252#endif
1253 } else { 1008 } else {
1254 start_row = mega_div64_32(start_strip, raid->rowDataSize); 1009 start_row = mega_div64_32(start_strip, raid->rowDataSize);
1255 endRow = mega_div64_32(endStrip, raid->rowDataSize); 1010 endRow = mega_div64_32(endStrip, raid->rowDataSize);
@@ -1383,12 +1138,6 @@ MR_BuildRaidContext(struct megasas_instance *instance,
1383 return TRUE; 1138 return TRUE;
1384 } 1139 }
1385 } 1140 }
1386
1387#if SPAN_DEBUG
1388 /* Just for testing what arm we get for strip.*/
1389 if (io_info->IoforUnevenSpan)
1390 get_arm_from_strip(instance, ld, start_strip, map);
1391#endif
1392 return TRUE; 1141 return TRUE;
1393} 1142}
1394 1143
@@ -1502,10 +1251,6 @@ void mr_update_span_set(struct MR_DRV_RAID_MAP_ALL *map,
1502 break; 1251 break;
1503 } 1252 }
1504 } 1253 }
1505#if SPAN_DEBUG
1506 getSpanInfo(map, ldSpanInfo);
1507#endif
1508
1509} 1254}
1510 1255
1511void mr_update_load_balance_params(struct MR_DRV_RAID_MAP_ALL *drv_map, 1256void mr_update_load_balance_params(struct MR_DRV_RAID_MAP_ALL *drv_map,
@@ -1594,13 +1339,6 @@ u8 megasas_get_best_arm_pd(struct megasas_instance *instance,
1594 } 1339 }
1595 1340
1596 lbInfo->last_accessed_block[io_info->pd_after_lb] = block + count - 1; 1341 lbInfo->last_accessed_block[io_info->pd_after_lb] = block + count - 1;
1597#if SPAN_DEBUG
1598 if (arm != bestArm)
1599 dev_dbg(&instance->pdev->dev, "LSI Debug R1 Load balance "
1600 "occur - span 0x%x arm 0x%x bestArm 0x%x "
1601 "io_info->span_arm 0x%x\n",
1602 span, arm, bestArm, io_info->span_arm);
1603#endif
1604 return io_info->pd_after_lb; 1342 return io_info->pd_after_lb;
1605} 1343}
1606 1344
diff --git a/drivers/scsi/megaraid/megaraid_sas_fusion.c b/drivers/scsi/megaraid/megaraid_sas_fusion.c
index 773ce340c7d3..c7f4cc7608d6 100644
--- a/drivers/scsi/megaraid/megaraid_sas_fusion.c
+++ b/drivers/scsi/megaraid/megaraid_sas_fusion.c
@@ -1062,11 +1062,6 @@ megasas_get_ld_map_info(struct megasas_instance *instance)
1062 1062
1063 memset(ci, 0, fusion->max_map_sz); 1063 memset(ci, 0, fusion->max_map_sz);
1064 memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE); 1064 memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
1065#if VD_EXT_DEBUG
1066 dev_dbg(&instance->pdev->dev,
1067 "%s sending MR_DCMD_LD_MAP_GET_INFO with size %d\n",
1068 __func__, cpu_to_le32(size_map_info));
1069#endif
1070 dcmd->cmd = MFI_CMD_DCMD; 1065 dcmd->cmd = MFI_CMD_DCMD;
1071 dcmd->cmd_status = 0xFF; 1066 dcmd->cmd_status = 0xFF;
1072 dcmd->sge_count = 1; 1067 dcmd->sge_count = 1;
generated by cgit v1.2.2 (git 2.25.0) at 2025-05-28 11:58:18 -0400