HWP hacks for unused variables.

Change-Id: Iaa5d80be87e3f5753750325479ecbf3c946f719a
Reviewed-on: http://gfw160.austin.ibm.com:8080/gerrit/4041
Reviewed-by: MIKE J. JONES <mjjones@us.ibm.com>
Tested-by: Jenkins Server
Reviewed-by: Brian H. Horton <brianh@linux.ibm.com>
Reviewed-by: Zane Shelley <zshelle@us.ibm.com>
Reviewed-by: A. Patrick Williams III <iawillia@us.ibm.com>

2 files changed, 371 insertions, 371 deletions

diff --git a/src/usr/hwpf/hwp/dram_training/mss_draminit_trainadv/mss_draminit_training_advanced.C b/src/usr/hwpf/hwp/dram_training/mss_draminit_trainadv/mss_draminit_training_advanced.C
index e8ca570f0..0a1a2f7f9 100644
--- a/src/usr/hwpf/hwp/dram_training/mss_draminit_trainadv/mss_draminit_training_advanced.C
+++ b/src/usr/hwpf/hwp/dram_training/mss_draminit_trainadv/mss_draminit_training_advanced.C
@@ -44,7 +44,7 @@
 // Version:|  Author: |  Date:  | Comment:
 //---------|----------|---------|-----------------------------------------------
 //  1.1    | sasethur |30-Sep-11| Initial draft.
-//  1.2    | sasethur |18-Nov-11| Changed function names 
+//  1.2    | sasethur |18-Nov-11| Changed function names
 //  1.3    | sasethur |01-Dec-11| Added details on Vref shmoo, reg addresses
 //  1.4    | sasethur |29-Jan-12| Updated wr&rd vref, removed ecmd workarounds
 //  1.5    | sasethur |13-Feb-12| Updated register naming conventions
@@ -62,10 +62,10 @@
 //  1.20   | bellows  |13-Nov-12| Updated for new SI attributes
 //  1.21   | sasethur |11-Nov-12| Updated for new SI attribute change, fw review comments
 //  1.22   | sasethur |07-Dec-12| Updated for FW review comments - multiple changes
-//  1.23   | sasethur |14-Dec-12| Updated for FW review comments 
-//  1.24   | sasethur |17-Jan-13| Updated for mss_mcbist_common.C include file 
-//  1.25   | abhijsau |31-Jan-13| removed  mss_mcbist_common.C include file , needs to be included while compiling 
-//  1.26   | abhijsau |06-Mar-13| fixed fw comment 
+//  1.23   | sasethur |14-Dec-12| Updated for FW review comments
+//  1.24   | sasethur |17-Jan-13| Updated for mss_mcbist_common.C include file
+//  1.25   | abhijsau |31-Jan-13| removed  mss_mcbist_common.C include file , needs to be included while compiling
+//  1.26   | abhijsau |06-Mar-13| fixed fw comment
 
 
 // This procedure Schmoo's DRV_IMP, SLEW, VREF (DDR, CEN), RCV_IMP based on attribute from effective config procedure
@@ -74,7 +74,7 @@
 // Internal Vref controlled by this function & external vref platform to provide function we return value
 
 // Not supported
-// DDR4, DIMM Types 
+// DDR4, DIMM Types
 //----------------------------------------------------------------------
 //  Includes - FAPI
 //----------------------------------------------------------------------
@@ -100,15 +100,15 @@ enum shmoo_param
 {
     PARAM_NONE = 0x00,
     DELAY_REG = 0x01,
-    DRV_IMP = 0x02, 
+    DRV_IMP = 0x02,
     SLEW_RATE = 0x04,
     WR_VREF = 0x08,
     RD_VREF = 0x10,
-    RCV_IMP = 0x20 
+    RCV_IMP = 0x20
 };
 
 
-extern "C" 
+extern "C"
 {
 
 using namespace fapi;
@@ -117,66 +117,66 @@ fapi::ReturnCode mss_draminit_training_advanced_cloned(const fapi::Target & i_ta
 			uint8_t i_pattern, uint8_t i_test_type);
 
 fapi::ReturnCode drv_imped_shmoo(const fapi::Target & i_target_mba, uint8_t i_port,
-			shmoo_type_t i_shmoo_type_valid, 
-			uint8_t i_pattern, uint8_t i_test_type);      
+			shmoo_type_t i_shmoo_type_valid,
+			uint8_t i_pattern, uint8_t i_test_type);
 
 fapi::ReturnCode slew_rate_shmoo(const fapi::Target & i_target_mba, uint8_t i_port,
-			shmoo_type_t i_shmoo_type_valid, 
+			shmoo_type_t i_shmoo_type_valid,
 			uint8_t i_pattern, uint8_t i_test_type);
 
 fapi::ReturnCode wr_vref_shmoo(const fapi::Target & i_target_mba, uint8_t i_port,
-			shmoo_type_t i_shmoo_type_valid, 
+			shmoo_type_t i_shmoo_type_valid,
 			uint8_t i_pattern, uint8_t i_test_type);
 
 fapi::ReturnCode rd_vref_shmoo(const fapi::Target & i_target_mba, uint8_t i_port,
-			shmoo_type_t i_shmoo_type_valid, 
+			shmoo_type_t i_shmoo_type_valid,
 			uint8_t i_pattern, uint8_t i_test_type);
 
 fapi::ReturnCode rcv_imp_shmoo(const fapi::Target & i_target_mba, uint8_t i_port,
-			shmoo_type_t i_shmoo_type_valid, 
+			shmoo_type_t i_shmoo_type_valid,
 			uint8_t i_pattern, uint8_t i_test_type);
 
 fapi::ReturnCode delay_shmoo(const fapi::Target & i_target_mba, uint8_t i_port,
-		    shmoo_type_t i_shmoo_type_valid, 
+		    shmoo_type_t i_shmoo_type_valid,
 		    uint32_t *o_left_margin, uint32_t *o_right_margin,
 			uint8_t i_pattern, uint8_t i_test_type);
 
-void find_best_margin(shmoo_param i_shmoo_param_valid,uint32_t i_left[], 
-			uint32_t i_right[], const uint8_t i_max, 
+void find_best_margin(shmoo_param i_shmoo_param_valid,uint32_t i_left[],
+			uint32_t i_right[], const uint8_t i_max,
 			uint32_t i_param_nom, uint8_t& o_index);
 
 //-----------------------------------------------------------------------------------
 //Function name: mss_draminit_training_advanced()
 //Description: This function varies driver impedance, receiver impedance, slew, wr & rd vref
 //based on attribute definition and runs either mcbist/delay shmoo based on attribute
-//Also calls unmask function mss_unmask_draminit_training_advanced_errors() 
-//Input : const fapi::Target MBA, i_pattern = pattern selection during mcbist @ lab, 
-//	l_test type  = test type selection during mcbist @ lab 
+//Also calls unmask function mss_unmask_draminit_training_advanced_errors()
+//Input : const fapi::Target MBA, i_pattern = pattern selection during mcbist @ lab,
+//	l_test type  = test type selection during mcbist @ lab
 //	Default vlaues are Zero
 //-----------------------------------------------------------------------------------
 
-fapi::ReturnCode mss_draminit_training_advanced(const fapi::Target & i_target_mba, 
-					uint8_t i_pattern, 
+fapi::ReturnCode mss_draminit_training_advanced(const fapi::Target & i_target_mba,
+					uint8_t i_pattern,
 					uint8_t i_test_type)
 {
     // const fapi::Target is centaur.mba
-    
+
     fapi::ReturnCode rc;
-    FAPI_INF(" pattern bit is %d and test_type_bit is %d",i_pattern,i_test_type);   
-    
+    FAPI_INF(" pattern bit is %d and test_type_bit is %d",i_pattern,i_test_type);
+
     rc = mss_draminit_training_advanced_cloned(i_target_mba,i_pattern,i_test_type);
-    if (rc) 
+    if (rc)
     {
 	FAPI_ERR("Advanced DRAM Init training procedure is Failed rc = 0x%08X (creator = %d)", uint32_t(rc), rc.getCreator());
     }
-    
+
     // If mss_unmask_draminit_training_advanced_errors gets it's own bad rc,
     // it will commit the passed in rc (if non-zero), and return it's own bad rc.
-    // Else if mss_unmask_draminit_training_advanced_errors runs clean, 
+    // Else if mss_unmask_draminit_training_advanced_errors runs clean,
     // it will just return the passed in rc.
-    
+
     rc = mss_unmask_draminit_training_advanced_errors(i_target_mba, rc);
-    if (rc) 
+    if (rc)
     {
 	FAPI_ERR("Unmask Function is Failed rc = 0x%08X (creator = %d)", uint32_t(rc), rc.getCreator());
 	return rc;
@@ -200,42 +200,42 @@ fapi::ReturnCode mss_draminit_training_advanced_cloned(const fapi::Target & i_ta
 {
     //const fapi::Target is centaur.mba
     fapi::ReturnCode rc;
-    char procedure_name[32]; 
+    char procedure_name[32];
     sprintf(procedure_name, "mss_draminit_training_advanced");
     FAPI_INF("+++++++ Executing %s +++++++", procedure_name);
-	
+
     // Define attribute variables
     uint32_t l_attr_mss_freq_u32 = 0;
-    uint32_t l_attr_mss_volt_u32 = 0;  
+    uint32_t l_attr_mss_volt_u32 = 0;
     uint8_t l_num_drops_per_port_u8 = 2;
     uint8_t l_num_ranks_per_dimm_u8array[MAX_PORT][MAX_DIMM] = {{0}};
-    uint8_t l_actual_dimm_size_u8 = 0;
+    uint8_t __attribute__((unused) l_actual_dimm_size_u8 = 0; // HACK
     uint8_t l_port = 0;
     uint8_t l_dimm_type_u8 = 0; //default is set to CDIMM
-    uint32_t l_left_margin=0;  
-    uint32_t l_right_margin=0;   
-     
+    uint32_t l_left_margin=0;
+    uint32_t l_right_margin=0;
+
     // Define local variables
     uint8_t l_shmoo_type_valid_t=0;
     uint8_t l_shmoo_param_valid_t=0;
-        	
+
     //const fapi::Target is centaur
     fapi::Target l_target_centaur;
-    rc = fapiGetParentChip(i_target_mba, l_target_centaur); 
+    rc = fapiGetParentChip(i_target_mba, l_target_centaur);
     if(rc) return rc;
-    rc = FAPI_ATTR_GET(ATTR_MSS_FREQ, &l_target_centaur, l_attr_mss_freq_u32); 
+    rc = FAPI_ATTR_GET(ATTR_MSS_FREQ, &l_target_centaur, l_attr_mss_freq_u32);
     if(rc) return rc;
-    rc = FAPI_ATTR_GET(ATTR_MSS_VOLT, &l_target_centaur, l_attr_mss_volt_u32); 
+    rc = FAPI_ATTR_GET(ATTR_MSS_VOLT, &l_target_centaur, l_attr_mss_volt_u32);
     if(rc) return rc;
-    
-    //const fapi::Target is centaur.mba   
-    rc = FAPI_ATTR_GET(ATTR_EFF_DIMM_TYPE, &i_target_mba, l_dimm_type_u8); 
+
+    //const fapi::Target is centaur.mba
+    rc = FAPI_ATTR_GET(ATTR_EFF_DIMM_TYPE, &i_target_mba, l_dimm_type_u8);
     if(rc) return rc;
-    rc = FAPI_ATTR_GET(ATTR_EFF_NUM_DROPS_PER_PORT, &i_target_mba, l_num_drops_per_port_u8); 
+    rc = FAPI_ATTR_GET(ATTR_EFF_NUM_DROPS_PER_PORT, &i_target_mba, l_num_drops_per_port_u8);
     if(rc) return rc;
-    rc = FAPI_ATTR_GET(ATTR_EFF_NUM_RANKS_PER_DIMM, &i_target_mba, l_num_ranks_per_dimm_u8array); 
+    rc = FAPI_ATTR_GET(ATTR_EFF_NUM_RANKS_PER_DIMM, &i_target_mba, l_num_ranks_per_dimm_u8array);
     if(rc) return rc;
-    
+
     FAPI_INF("+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++");
     FAPI_INF("freq = %d on %s.", l_attr_mss_freq_u32, l_target_centaur.toEcmdString());
     FAPI_INF("volt = %d on %s.", l_attr_mss_volt_u32, l_target_centaur.toEcmdString());
@@ -244,49 +244,49 @@ fapi::ReturnCode mss_draminit_training_advanced_cloned(const fapi::Target & i_ta
     FAPI_INF("num_ranks_per_dimm = [%02d][%02d][%02d][%02d] on %s.", l_num_ranks_per_dimm_u8array[0][0],l_num_ranks_per_dimm_u8array[0][1], l_num_ranks_per_dimm_u8array[1][0],l_num_ranks_per_dimm_u8array[1][1], i_target_mba.toEcmdString());
     FAPI_INF("+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++");
 
-    if ( l_num_drops_per_port_u8 == fapi::ENUM_ATTR_EFF_NUM_DROPS_PER_PORT_DUAL ) 
+    if ( l_num_drops_per_port_u8 == fapi::ENUM_ATTR_EFF_NUM_DROPS_PER_PORT_DUAL )
     {
        l_actual_dimm_size_u8 = 2;
     }
-    else 
+    else
     {
        l_actual_dimm_size_u8 = 1;
     }
-       
-    rc = FAPI_ATTR_GET(ATTR_EFF_SCHMOO_TEST_VALID, &i_target_mba, l_shmoo_type_valid_t);  
-    if(rc) return rc; 
-    rc = FAPI_ATTR_GET(ATTR_EFF_SCHMOO_PARAM_VALID, &i_target_mba, l_shmoo_param_valid_t); 
+
+    rc = FAPI_ATTR_GET(ATTR_EFF_SCHMOO_TEST_VALID, &i_target_mba, l_shmoo_type_valid_t);
     if(rc) return rc;
-   
+    rc = FAPI_ATTR_GET(ATTR_EFF_SCHMOO_PARAM_VALID, &i_target_mba, l_shmoo_param_valid_t);
+    if(rc) return rc;
+
     shmoo_type_t l_shmoo_type_valid;
     shmoo_param l_shmoo_param_valid;
 
     l_shmoo_type_valid=(shmoo_type_t)l_shmoo_type_valid_t;
     l_shmoo_param_valid=(shmoo_param)l_shmoo_param_valid_t;
-    
+
     FAPI_INF("+++++++++++++++++++++++++ Read Schmoo Attributes ++++++++++++++++++++++++++");
     FAPI_INF("Schmoo param valid = 0x%x on %s", l_shmoo_param_valid, i_target_mba.toEcmdString());
     FAPI_INF("Schmoo test valid = 0x%x on %s", l_shmoo_type_valid, i_target_mba.toEcmdString());
     FAPI_INF("+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++");
 
-    //Check for Shmoo Parameter, if anyof them is enabled then go into the loop else the procedure exit 
+    //Check for Shmoo Parameter, if anyof them is enabled then go into the loop else the procedure exit
 
-    for ( l_port = 0; l_port < MAX_PORT; l_port += 1 ) 
+    for ( l_port = 0; l_port < MAX_PORT; l_port += 1 )
     {
     	    if (( l_num_ranks_per_dimm_u8array[l_port][0] > 0 ) || (l_num_ranks_per_dimm_u8array[l_port][1] > 0))
             {
-    		if((l_shmoo_param_valid != PARAM_NONE) || (l_shmoo_type_valid != TEST_NONE)) 
+    		if((l_shmoo_param_valid != PARAM_NONE) || (l_shmoo_type_valid != TEST_NONE))
     		{
     		    if((l_shmoo_param_valid & DRV_IMP) != 0)
-    		    { 
-    			rc = drv_imped_shmoo(i_target_mba, l_port, l_shmoo_type_valid, i_pattern,i_test_type); 
+    		    {
+    			rc = drv_imped_shmoo(i_target_mba, l_port, l_shmoo_type_valid, i_pattern,i_test_type);
     			if (rc)
     			{
     			    FAPI_ERR("Driver Impedance Schmoo function is Failed rc = 0x%08X (creator = %d)", uint32_t(rc), rc.getCreator());
     			    return rc;
     			}
     		    }
-    		    if((l_shmoo_param_valid & SLEW_RATE) !=0) 
+    		    if((l_shmoo_param_valid & SLEW_RATE) !=0)
         	    {
     			rc = slew_rate_shmoo(i_target_mba, l_port, l_shmoo_type_valid, i_pattern,i_test_type);
     			if (rc)
@@ -295,7 +295,7 @@ fapi::ReturnCode mss_draminit_training_advanced_cloned(const fapi::Target & i_ta
     			    return rc;
     			}
     		    }
-    		    if((l_shmoo_param_valid & WR_VREF) != 0) 
+    		    if((l_shmoo_param_valid & WR_VREF) != 0)
    		    {
     			rc = wr_vref_shmoo(i_target_mba, l_port, l_shmoo_type_valid, i_pattern,i_test_type);
     			if (rc)
@@ -314,7 +314,7 @@ fapi::ReturnCode mss_draminit_training_advanced_cloned(const fapi::Target & i_ta
     			}
 		    }
     		    if ((l_shmoo_param_valid & RCV_IMP) !=0)
-    		    {	
+    		    {
     			rc = rcv_imp_shmoo(i_target_mba, l_port, l_shmoo_type_valid, i_pattern,i_test_type);
     			if (rc)
     			{
@@ -324,7 +324,7 @@ fapi::ReturnCode mss_draminit_training_advanced_cloned(const fapi::Target & i_ta
     		    }
     		    if (((l_shmoo_param_valid & DELAY_REG) != 0) || (l_shmoo_type_valid != TEST_NONE))
     		    {
-    			rc = delay_shmoo(i_target_mba, l_port, l_shmoo_type_valid, &l_left_margin, &l_right_margin,i_pattern,i_test_type); 
+    			rc = delay_shmoo(i_target_mba, l_port, l_shmoo_type_valid, &l_left_margin, &l_right_margin,i_pattern,i_test_type);
     			if (rc)
     			{
     			    FAPI_ERR("Delay Schmoo Function is Failed rc = 0x%08X (creator = %d)", uint32_t(rc), rc.getCreator());
@@ -332,7 +332,7 @@ fapi::ReturnCode mss_draminit_training_advanced_cloned(const fapi::Target & i_ta
     			}
     		    }
 		}
-	}	
+	}
     }
 return rc;
 }
@@ -366,7 +366,7 @@ fapi::ReturnCode drv_imped_shmoo(const fapi::Target & i_target_mba,
     uint8_t l_slew_rate_dq_dqs_schmoo[MAX_PORT] = {0};
     uint32_t l_drv_imp_dq_dqs_schmoo[MAX_PORT] = {0};
     uint8_t l_drv_imp_dq_dqs_nom_fc = 0;
-    //Temporary 
+    //Temporary
     i_shmoo_type_valid = WR_EYE;  //Hard coded, since no other schmoo is applicable for this parameter
     uint32_t l_left_margin_drv_imp_array[MAX_DRV_IMP] = {0};
     uint32_t l_right_margin_drv_imp_array[MAX_DRV_IMP] = {0};
@@ -374,44 +374,44 @@ fapi::ReturnCode drv_imped_shmoo(const fapi::Target & i_target_mba,
     uint32_t l_right_margin = 0;
     uint8_t count = 0;
     uint8_t l_slew_type = 0; // Hard coded since this procedure will touch only DQ_DQS and not address
-       	
-    rc = FAPI_ATTR_GET(ATTR_EFF_CEN_DRV_IMP_DQ_DQS, &i_target_mba, l_drv_imp_dq_dqs_nom); 
+
+    rc = FAPI_ATTR_GET(ATTR_EFF_CEN_DRV_IMP_DQ_DQS, &i_target_mba, l_drv_imp_dq_dqs_nom);
     if (rc) return rc;
-    rc = FAPI_ATTR_GET(ATTR_EFF_CEN_SLEW_RATE_DQ_DQS, &i_target_mba, l_slew_rate_dq_dqs); 
+    rc = FAPI_ATTR_GET(ATTR_EFF_CEN_SLEW_RATE_DQ_DQS, &i_target_mba, l_slew_rate_dq_dqs);
     if (rc) return rc;
     rc = FAPI_ATTR_GET(ATTR_EFF_CEN_DRV_IMP_DQ_DQS_SCHMOO, &i_target_mba, l_drv_imp_dq_dqs_schmoo);
     if (rc) return rc;
     rc = FAPI_ATTR_GET(ATTR_EFF_CEN_SLEW_RATE_DQ_DQS_SCHMOO, &i_target_mba, l_slew_rate_dq_dqs_schmoo);
     if (rc) return rc;
-	
+
     FAPI_INF("+++++++++++++++++Read DRIVER IMP Attributes values++++++++++++++++");
     FAPI_INF("CEN_DRV_IMP_DQ_DQS[%d]  = [%02d] Ohms, on %s", i_port, l_drv_imp_dq_dqs_nom[i_port], i_target_mba.toEcmdString());
     FAPI_INF("CEN_DRV_IMP_DQ_DQS_SCHMOO[0]  = [0x%x], CEN_DRV_IMP_DQ_DQS_SCHMOO[1]  = [0x%x] on %s", l_drv_imp_dq_dqs_schmoo[0],l_drv_imp_dq_dqs_schmoo[1], i_target_mba.toEcmdString());
     FAPI_INF("CEN_SLEW_RATE_DQ_DQS[0] = [%02d]V/ns , CEN_SLEW_RATE_DQ_DQS[1] = [%02d]V/ns on %s", l_slew_rate_dq_dqs[0],l_slew_rate_dq_dqs[1], i_target_mba.toEcmdString());
     FAPI_INF("CEN_SLEW_RATE_DQ_DQS_SCHMOO[0] = [0x%x], CEN_SLEW_RATE_DQ_DQS_SCHMOO[1] = [0x%x] on %s", l_slew_rate_dq_dqs_schmoo[0],l_slew_rate_dq_dqs_schmoo[1], i_target_mba.toEcmdString());
     FAPI_INF("++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++");
-    
+
     if(l_drv_imp_dq_dqs_schmoo[i_port] == 0) //Check for any of the bits enabled in the shmoo
     {
 	FAPI_INF("DRIVER IMP Shmoo set to FAST Mode and won't do anything");
     }
     else
-    {   
-	for(index = 0; index< MAX_DRV_IMP; index+=1)   
+    {
+	for(index = 0; index< MAX_DRV_IMP; index+=1)
 	{
-            if (l_drv_imp_dq_dqs_schmoo[i_port] & MASK) 
+            if (l_drv_imp_dq_dqs_schmoo[i_port] & MASK)
 	    {
 	        l_drv_imp_dq_dqs[i_port] = drv_imp_array[index];
 		FAPI_INF("Current Driver Impedance Value = %d Ohms", drv_imp_array[index]);
 		FAPI_INF("Configuring Driver Impedance Registers:");
-		rc = config_drv_imp(i_target_mba, i_port, l_drv_imp_dq_dqs[i_port]); 
+		rc = config_drv_imp(i_target_mba, i_port, l_drv_imp_dq_dqs[i_port]);
 		if (rc) return rc;
 		FAPI_INF("Configuring Slew Rate Registers:");
-	        rc = config_slew_rate(i_target_mba, i_port, l_slew_type, l_drv_imp_dq_dqs[i_port], l_slew_rate_dq_dqs[i_port]); 
+	        rc = config_slew_rate(i_target_mba, i_port, l_slew_type, l_drv_imp_dq_dqs[i_port], l_slew_rate_dq_dqs[i_port]);
 		if (rc) return rc;
 		FAPI_INF("Calling Shmoo for finding Timing Margin:");
-		rc = delay_shmoo(i_target_mba, i_port, i_shmoo_type_valid, 
-				 &l_left_margin, &l_right_margin, i_pattern, i_test_type);  
+		rc = delay_shmoo(i_target_mba, i_port, i_shmoo_type_valid,
+				 &l_left_margin, &l_right_margin, i_pattern, i_test_type);
 		if (rc) return rc;
 		l_left_margin_drv_imp_array[index]= l_left_margin;
 	        l_right_margin_drv_imp_array[index]= l_right_margin;
@@ -426,7 +426,7 @@ fapi::ReturnCode drv_imped_shmoo(const fapi::Target & i_target_mba,
         l_drv_imp_dq_dqs_nom_fc = l_drv_imp_dq_dqs_nom[i_port];
 	find_best_margin(DRV_IMP, l_left_margin_drv_imp_array,
 			      l_right_margin_drv_imp_array, MAX_DRV_IMP, l_drv_imp_dq_dqs_nom_fc, count);
-	
+
 	if (count >= MAX_DRV_IMP)
         {
                 FAPI_ERR("Driver Imp new input(%d) out of bounds, (>= %d)",
@@ -436,7 +436,7 @@ fapi::ReturnCode drv_imped_shmoo(const fapi::Target & i_target_mba,
         }
 	else
 	{
-	   
+
 	   if(i_port == 0)
 	   {
 	   l_drv_imp_dq_dqs_new[0] = drv_imp_array[count];
@@ -447,28 +447,28 @@ fapi::ReturnCode drv_imped_shmoo(const fapi::Target & i_target_mba,
 	   l_drv_imp_dq_dqs_new[1] = drv_imp_array[count];
 	   l_drv_imp_dq_dqs_new[0] = l_drv_imp_dq_dqs_nom[0];
 	   }
- 
+
 	   if (l_drv_imp_dq_dqs_new[i_port] != l_drv_imp_dq_dqs_nom[i_port])
 	   {
 	        FAPI_INF("Better Margin found on %d Ohms on %s", l_drv_imp_dq_dqs_new[i_port], i_target_mba.toEcmdString());
-	        rc = FAPI_ATTR_SET(ATTR_EFF_CEN_DRV_IMP_DQ_DQS, &i_target_mba, l_drv_imp_dq_dqs_new); 
+	        rc = FAPI_ATTR_SET(ATTR_EFF_CEN_DRV_IMP_DQ_DQS, &i_target_mba, l_drv_imp_dq_dqs_new);
 	        if (rc) return rc;
 	        FAPI_INF("Configuring New Driver Impedance Value to Registers:");
 	        rc = config_drv_imp(i_target_mba, i_port, l_drv_imp_dq_dqs_new[i_port]);
 	        if (rc) return rc;
-	        rc = config_slew_rate(i_target_mba, i_port, l_slew_type, l_drv_imp_dq_dqs_new[i_port], l_slew_rate_dq_dqs[i_port]); 
+	        rc = config_slew_rate(i_target_mba, i_port, l_slew_type, l_drv_imp_dq_dqs_new[i_port], l_slew_rate_dq_dqs[i_port]);
 		if (rc) return rc;
 	    }
 	    else
 	    {
-	        FAPI_INF("Nominal value will not be changed - Restoring the original values!");	
+	        FAPI_INF("Nominal value will not be changed - Restoring the original values!");
 	        rc = config_drv_imp(i_target_mba, i_port, l_drv_imp_dq_dqs_nom[i_port]);
 	        if (rc) return rc;
-	        rc = config_slew_rate(i_target_mba, i_port, l_slew_type, l_drv_imp_dq_dqs_nom[i_port], l_slew_rate_dq_dqs[i_port]); 
+	        rc = config_slew_rate(i_target_mba, i_port, l_slew_type, l_drv_imp_dq_dqs_nom[i_port], l_slew_rate_dq_dqs[i_port]);
 		if (rc) return rc;
-	    } 
+	    }
 	}
-	
+
 	FAPI_INF("++++ Driver impedance shmoo function executed successfully ++++");
     }
 return rc;
@@ -500,7 +500,7 @@ fapi::ReturnCode slew_rate_shmoo(const fapi::Target & i_target_mba,
     uint32_t l_slew_rate_dq_dqs_schmoo[MAX_PORT] = {0};
     uint8_t l_drv_imp_dq_dqs_nom[MAX_PORT] = {0};
     i_shmoo_type_valid = WR_EYE; // Hard coded - Other shmoo type is not valid - Temporary
-    
+
     uint8_t index = 0;
     uint8_t count = 0;
     uint32_t l_left_margin_slew_array[MAX_NUM_SLEW_RATES] = {0};
@@ -508,21 +508,21 @@ fapi::ReturnCode slew_rate_shmoo(const fapi::Target & i_target_mba,
     uint32_t l_left_margin = 0;
     uint32_t l_right_margin = 0;
     uint8_t l_slew_type = 0; // Hard coded since this procedure will touch only DQ_DQS and not address
-    		
+
     //Read Attributes - DRV IMP, SLEW, SLEW RATES values to be Schmoo'ed
-    rc = FAPI_ATTR_GET(ATTR_EFF_CEN_DRV_IMP_DQ_DQS, &i_target_mba, l_drv_imp_dq_dqs_nom); 
+    rc = FAPI_ATTR_GET(ATTR_EFF_CEN_DRV_IMP_DQ_DQS, &i_target_mba, l_drv_imp_dq_dqs_nom);
     if (rc) return rc;
-    rc = FAPI_ATTR_GET(ATTR_EFF_CEN_SLEW_RATE_DQ_DQS, &i_target_mba, l_slew_rate_dq_dqs_nom); 
+    rc = FAPI_ATTR_GET(ATTR_EFF_CEN_SLEW_RATE_DQ_DQS, &i_target_mba, l_slew_rate_dq_dqs_nom);
     if (rc) return rc;
     rc = FAPI_ATTR_GET(ATTR_EFF_CEN_DRV_IMP_DQ_DQS_SCHMOO, &i_target_mba, l_slew_rate_dq_dqs_schmoo);
     if (rc) return rc;
-	
+
     FAPI_INF("+++++++++++++++++Read Slew Shmoo Attributes values+++++++++++++++");
     FAPI_INF("CEN_DRV_IMP_DQ_DQS[0]  = [%02d] Ohms, CEN_DRV_IMP_DQ_DQS[1]  = [%02d] Ohms on %s", l_drv_imp_dq_dqs_nom[0],l_drv_imp_dq_dqs_nom[1], i_target_mba.toEcmdString());
     FAPI_INF("CEN_SLEW_RATE_DQ_DQS[0] = [%02d]V/ns , CEN_SLEW_RATE_DQ_DQS[1] = [%02d]V/ns on %s", l_slew_rate_dq_dqs_nom[0],l_slew_rate_dq_dqs_nom[1], i_target_mba.toEcmdString());
     FAPI_INF("CEN_SLEW_RATE_DQ_DQS_SCHMOO[0] = [0x%x], CEN_SLEW_RATE_DQ_DQS_SCHMOO[1] = [0x%x] on %s", l_slew_rate_dq_dqs_schmoo[0],l_slew_rate_dq_dqs_schmoo[1], i_target_mba.toEcmdString());
     FAPI_INF("+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++");
-    
+
     if(l_slew_rate_dq_dqs_schmoo == 0) //Check for any of the bits enabled in the shmoo
     {
 	FAPI_INF("Slew Rate Shmoo set to FAST Mode and won't do anything");
@@ -531,16 +531,16 @@ fapi::ReturnCode slew_rate_shmoo(const fapi::Target & i_target_mba,
     {
 	for(index = 0; index < MAX_NUM_SLEW_RATES; index+=1)
 	{
-            if (l_slew_rate_dq_dqs_schmoo[i_port] & MASK )   
+            if (l_slew_rate_dq_dqs_schmoo[i_port] & MASK )
 	    {
 		l_slew_rate_dq_dqs[i_port] = slew_rate_array[index];
 		FAPI_INF("Current Slew rate value is %d V/ns", slew_rate_array[index]);
 		FAPI_INF("Configuring Slew registers:");
-		rc = config_slew_rate(i_target_mba, i_port, l_slew_type, l_drv_imp_dq_dqs_nom[i_port], l_slew_rate_dq_dqs[i_port]); 
+		rc = config_slew_rate(i_target_mba, i_port, l_slew_type, l_drv_imp_dq_dqs_nom[i_port], l_slew_rate_dq_dqs[i_port]);
                 if (rc) return rc;
 		FAPI_INF("Calling Shmoo for finding Timing Margin:");
-		rc = delay_shmoo(i_target_mba, i_port, i_shmoo_type_valid, 
-				 &l_left_margin, &l_right_margin, i_pattern, i_test_type);  
+		rc = delay_shmoo(i_target_mba, i_port, i_shmoo_type_valid,
+				 &l_left_margin, &l_right_margin, i_pattern, i_test_type);
                 if (rc) return rc;
 		l_left_margin_slew_array[index]= l_left_margin;
 		l_right_margin_slew_array[index]= l_right_margin;
@@ -564,38 +564,38 @@ fapi::ReturnCode slew_rate_shmoo(const fapi::Target & i_target_mba,
         }
 	else
 	{
-	   
+
 	   if(i_port == 0)
 	   {
 	       l_slew_rate_dq_dqs_new[0] = slew_rate_array[count];
-	       l_slew_rate_dq_dqs_new[1] = l_slew_rate_dq_dqs_nom[1]; 
+	       l_slew_rate_dq_dqs_new[1] = l_slew_rate_dq_dqs_nom[1];
 	   }
 	   else
 	   {
 	       l_slew_rate_dq_dqs_new[1] = slew_rate_array[count];
-	       l_slew_rate_dq_dqs_new[0] = l_slew_rate_dq_dqs_nom[0];  
+	       l_slew_rate_dq_dqs_new[0] = l_slew_rate_dq_dqs_nom[0];
 	   }
- 
-				  
-	
+
+
+
 	    if (l_slew_rate_dq_dqs_new[i_port] != l_slew_rate_dq_dqs_nom[i_port])
 	    {
 	        FAPI_INF("Better Margin found on Slew Rate: %d V/ns on %s", l_slew_rate_dq_dqs_new[i_port], i_target_mba.toEcmdString());
-	        rc = FAPI_ATTR_SET(ATTR_EFF_CEN_SLEW_RATE_DQ_DQS, &i_target_mba, l_slew_rate_dq_dqs_new); 
+	        rc = FAPI_ATTR_SET(ATTR_EFF_CEN_SLEW_RATE_DQ_DQS, &i_target_mba, l_slew_rate_dq_dqs_new);
 	        if (rc) return rc;
 	        FAPI_INF("Configuring New Slew Rate Value to Registers:");
-	        rc = config_slew_rate(i_target_mba, i_port, l_slew_type, l_drv_imp_dq_dqs_nom[i_port], l_slew_rate_dq_dqs_new[i_port]); 
+	        rc = config_slew_rate(i_target_mba, i_port, l_slew_type, l_drv_imp_dq_dqs_nom[i_port], l_slew_rate_dq_dqs_new[i_port]);
 	        if (rc) return rc;
 	    }
 	    else
 	    {
-	        FAPI_INF("Nominal value will not be changed!");	
+	        FAPI_INF("Nominal value will not be changed!");
 	        FAPI_INF("Slew Rate: %d V/ns on %s", l_slew_rate_dq_dqs_nom[i_port], i_target_mba.toEcmdString());
 	    }
 	}
 	FAPI_INF("++++ Slew Rate shmoo function executed successfully ++++");
     }
-return rc;	
+return rc;
 }
 
 //----------------------------------------------------------------------------------------------
@@ -620,19 +620,19 @@ fapi::ReturnCode wr_vref_shmoo(const fapi::Target & i_target_mba,
     uint32_t l_wr_dram_vref[MAX_PORT] = {0};
     uint32_t l_wr_dram_vref_nom[MAX_PORT] = {0};
     uint32_t l_wr_dram_vref_new[MAX_PORT] = {0};
-    uint32_t l_wr_dram_vref_schmoo[MAX_PORT] = {0}; 
+    uint32_t l_wr_dram_vref_schmoo[MAX_PORT] = {0};
     uint32_t l_wr_dram_vref_nom_fc = 0;
     i_shmoo_type_valid = WR_EYE; // Hard coded - Temporary
-    
+
     uint8_t index = 0;
     uint8_t count = 0;
     uint32_t l_left_margin = 0;
     uint32_t l_right_margin = 0;
     uint32_t l_left_margin_wr_vref_array[MAX_WR_VREF]= {0};
     uint32_t l_right_margin_wr_vref_array[MAX_WR_VREF]= {0};
-                          
+
     //Read the write vref attributes
-    rc = FAPI_ATTR_GET(ATTR_EFF_DRAM_WR_VREF, &i_target_mba, l_wr_dram_vref_nom); 
+    rc = FAPI_ATTR_GET(ATTR_EFF_DRAM_WR_VREF, &i_target_mba, l_wr_dram_vref_nom);
     if (rc) return rc;
     rc = FAPI_ATTR_GET(ATTR_EFF_DRAM_WR_VREF_SCHMOO, &i_target_mba, l_wr_dram_vref_schmoo);
     if (rc) return rc;
@@ -640,8 +640,8 @@ fapi::ReturnCode wr_vref_shmoo(const fapi::Target & i_target_mba,
     FAPI_INF("DRAM_WR_VREF[0]  = %d , DRAM_WR_VREF[0]  = %d on %s", l_wr_dram_vref_nom[0], l_wr_dram_vref_nom[1],i_target_mba.toEcmdString());
     FAPI_INF("DRAM_WR_VREF_SCHMOO[0] = [%x],DRAM_WR_VREF_SCHMOO[0] = [%x] on %s", l_wr_dram_vref_schmoo[0], l_wr_dram_vref_schmoo[1],i_target_mba.toEcmdString());
     FAPI_INF("+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++");
-    
-    
+
+
     if(l_wr_dram_vref_schmoo[i_port] == 0)
     {
 	FAPI_INF("FAST Shmoo Mode: This function will not change any Write DRAM VREF settings");
@@ -650,15 +650,15 @@ fapi::ReturnCode wr_vref_shmoo(const fapi::Target & i_target_mba,
     {
 	for(index = 0; index < MAX_WR_VREF; index+=1)
 	{
-            if (l_wr_dram_vref_schmoo[i_port] & MASK) 
+            if (l_wr_dram_vref_schmoo[i_port] & MASK)
 	    {
         	FAPI_INF("Current Vref value is %dmV", wr_vref_array[index]);
 		l_wr_dram_vref[i_port] = wr_vref_array[index];
-		rc = config_wr_dram_vref(i_target_mba, i_port, l_wr_dram_vref[i_port]); 
+		rc = config_wr_dram_vref(i_target_mba, i_port, l_wr_dram_vref[i_port]);
                 if (rc) return rc;
 		FAPI_INF(" Calling Shmoo for finding Timing Margin:");
-		rc = delay_shmoo(i_target_mba, i_port, i_shmoo_type_valid, 
-	 			 &l_left_margin, &l_right_margin, i_pattern, i_test_type);  
+		rc = delay_shmoo(i_target_mba, i_port, i_shmoo_type_valid,
+	 			 &l_left_margin, &l_right_margin, i_pattern, i_test_type);
                 if (rc) return rc;
 		l_left_margin_wr_vref_array[index]= l_left_margin;
 	        l_right_margin_wr_vref_array[index]= l_right_margin;
@@ -683,7 +683,7 @@ fapi::ReturnCode wr_vref_shmoo(const fapi::Target & i_target_mba,
         }
 	else
 	{
-	   
+
 	    if(i_port == 0)
 	    {
 	        l_wr_dram_vref_new[0] = wr_vref_array_fitness[count];
@@ -694,21 +694,21 @@ fapi::ReturnCode wr_vref_shmoo(const fapi::Target & i_target_mba,
 	        l_wr_dram_vref_new[1] = wr_vref_array_fitness[count];
                 l_wr_dram_vref_new[0] = l_wr_dram_vref_nom[0];
 	    }
- 
+
   	    if(l_wr_dram_vref_new[i_port] != l_wr_dram_vref_nom[i_port])
 	    {
 	        FAPI_INF("Best Margin Found on Vref : %d , %d mV on %s", count, wr_vref_array_fitness[count], i_target_mba.toEcmdString());
-	        rc = FAPI_ATTR_SET(ATTR_EFF_DRAM_WR_VREF, &i_target_mba, l_wr_dram_vref_new); 
+	        rc = FAPI_ATTR_SET(ATTR_EFF_DRAM_WR_VREF, &i_target_mba, l_wr_dram_vref_new);
 	        if (rc) return rc;
 	        FAPI_INF("Configuring New Vref Value to registers:");
-	        rc = config_wr_dram_vref(i_target_mba, i_port, l_wr_dram_vref_new[i_port]); 
-                if (rc) return rc;	    
+	        rc = config_wr_dram_vref(i_target_mba, i_port, l_wr_dram_vref_new[i_port]);
+                if (rc) return rc;
 	    }
 	    else
 	    {
-	        FAPI_INF("Nominal value will not be changed!- Restoring the original values!");	
-	        rc = config_wr_dram_vref(i_target_mba, i_port, l_wr_dram_vref_nom[i_port]); 
-                if (rc) return rc;	    
+	        FAPI_INF("Nominal value will not be changed!- Restoring the original values!");
+	        rc = config_wr_dram_vref(i_target_mba, i_port, l_wr_dram_vref_nom[i_port]);
+                if (rc) return rc;
 	    }
         }
     FAPI_INF("++++ Write Vref Shmoo function executed successfully ++++");
@@ -719,21 +719,21 @@ fapi::ReturnCode wr_vref_shmoo(const fapi::Target & i_target_mba,
 
 
 //----------------------------------------------------------------------------------------------
-// Function name: rd_vref_shmoo()                                                               
-// Description: This function varies the Centaur IO vref in 16 steps 
-// 		Calls write eye shmoo function                 
+// Function name: rd_vref_shmoo()
+// Description: This function varies the Centaur IO vref in 16 steps
+// 		Calls write eye shmoo function
 // Input param: const fapi::Target MBA, port = 0,1
 // 	Shmoo type: MCBIST, WR_EYE, RD_EYE, WR_DQS, RD_DQS
 // 	Shmoo param: PARAM_NONE, DRV_IMP, SLEW_RATE, WR_VREF, RD_VREF, RCV_IMP
 // 	Shmoo Mode: FEW_ADDR, QUARTER_ADDR, HALF_ADDR, FULL_ADDR
 // 	i_pattern, i_test_type : Default = 0, mcbist lab function would use this arg
 //----------------------------------------------------------------------------------------------
-       
+
 fapi::ReturnCode rd_vref_shmoo(const fapi::Target & i_target_mba,
 			 uint8_t i_port,
 			 shmoo_type_t i_shmoo_type_valid,
 			 uint8_t i_pattern,
-			 uint8_t i_test_type) 
+			 uint8_t i_test_type)
 {
     fapi::ReturnCode rc;
     uint32_t l_rd_cen_vref[MAX_PORT] = {0};
@@ -744,23 +744,23 @@ fapi::ReturnCode rd_vref_shmoo(const fapi::Target & i_target_mba,
     uint8_t index  = 0;
     uint8_t count  = 0;
     i_shmoo_type_valid = RD_EYE; // Hard coded - Temporary
-    
+
     uint32_t l_left_margin = 0;
     uint32_t l_right_margin = 0;
     uint32_t l_left_margin_rd_vref_array[MAX_RD_VREF] = {0};
     uint32_t l_right_margin_rd_vref_array[MAX_RD_VREF] = {0};
-    
-    	
+
+
     rc = FAPI_ATTR_GET(ATTR_EFF_CEN_RD_VREF, &i_target_mba, l_rd_cen_vref_nom);
     if (rc) return rc;
     rc = FAPI_ATTR_GET(ATTR_EFF_CEN_RD_VREF_SCHMOO, &i_target_mba, l_rd_cen_vref_schmoo);
     if (rc) return rc;
-    
+
     FAPI_INF("+++++++++++++++++CENTAUR VREF Read Shmoo Attributes values+++++++++++++++");
     FAPI_INF("CEN_RD_VREF[0]  = %d CEN_RD_VREF[1]  = %d on %s", l_rd_cen_vref_nom[0],l_rd_cen_vref_nom[1], i_target_mba.toEcmdString());
     FAPI_INF("CEN_RD_VREF_SCHMOO[0] = [%d], CEN_RD_VREF_SCHMOO[1] = [%d] on %s", l_rd_cen_vref_schmoo[0], l_rd_cen_vref_schmoo[1],i_target_mba.toEcmdString());
     FAPI_INF("++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++");
-    
+
     if(l_rd_cen_vref_schmoo[i_port] == 0)
     {
 	FAPI_INF("FAST Shmoo Mode: This function will not change any Write DRAM VREF settings");
@@ -800,7 +800,7 @@ fapi::ReturnCode rd_vref_shmoo(const fapi::Target & i_target_mba,
         }
 	else
 	{
-	   
+
 	    if(i_port == 0)
 	    {
 	        l_rd_cen_vref_new[0] = rd_cen_vref_array_fitness[count];
@@ -811,20 +811,20 @@ fapi::ReturnCode rd_vref_shmoo(const fapi::Target & i_target_mba,
 	        l_rd_cen_vref_new[1] = rd_cen_vref_array_fitness[count];
                 l_rd_cen_vref_new[0] = l_rd_cen_vref_nom[0];
 	    }
- 
+
 	    if(l_rd_cen_vref_new[i_port] != l_rd_cen_vref_nom[i_port])
 	    {
 	        FAPI_INF("Best Margin Found on Vref : %dmv , %dmV on %s", l_rd_cen_vref_new[i_port], rd_cen_vref_array_fitness[count], i_target_mba.toEcmdString());
-	        rc = FAPI_ATTR_SET(ATTR_EFF_CEN_RD_VREF, &i_target_mba, l_rd_cen_vref_new); 
+	        rc = FAPI_ATTR_SET(ATTR_EFF_CEN_RD_VREF, &i_target_mba, l_rd_cen_vref_new);
 	        if (rc) return rc;
 	        FAPI_INF("Configuring New Read Vref Value to Registers:");
-	        rc = config_rd_cen_vref(i_target_mba, i_port, l_rd_cen_vref_new[i_port]); 
+	        rc = config_rd_cen_vref(i_target_mba, i_port, l_rd_cen_vref_new[i_port]);
                 if (rc) return rc;
 	    }
 	    else
 	    {
-	        FAPI_INF("Nominal value will not be changed!- Restoring the original values!");	
-	        rc = config_rd_cen_vref(i_target_mba, i_port, l_rd_cen_vref_nom[i_port]); 
+	        FAPI_INF("Nominal value will not be changed!- Restoring the original values!");
+	        rc = config_rd_cen_vref(i_target_mba, i_port, l_rd_cen_vref_nom[i_port]);
                 if (rc) return rc;
 	    }
 	}
@@ -857,18 +857,18 @@ fapi::ReturnCode rcv_imp_shmoo(const fapi::Target & i_target_mba,
     uint8_t index = 0;
     uint8_t count  = 0;
     i_shmoo_type_valid = RD_EYE;   //Hard coded since no other shmoo is applicable - Temporary
-    
+
     uint32_t l_left_margin = 0;
     uint32_t l_right_margin = 0;
     uint32_t l_left_margin_rcv_imp_array[MAX_RCV_IMP] = {0};
     uint32_t l_right_margin_rcv_imp_array[MAX_RCV_IMP] = {0};
-       
-		
+
+
     rc = FAPI_ATTR_GET(ATTR_EFF_CEN_RCV_IMP_DQ_DQS, &i_target_mba, l_rcv_imp_dq_dqs_nom);
     if (rc) return rc;
     rc = FAPI_ATTR_GET(ATTR_EFF_CEN_RCV_IMP_DQ_DQS_SCHMOO, &i_target_mba, l_rcv_imp_dq_dqs_schmoo);
     if (rc) return rc;
-    
+
     FAPI_INF("+++++++++++++++++RECIVER IMP Read Shmoo Attributes values+++++++++++++++");
     FAPI_INF("CEN_RCV_IMP_DQ_DQS[0]  = %d , CEN_RCV_IMP_DQ_DQS[1]  = %d on %s", l_rcv_imp_dq_dqs_nom[0],l_rcv_imp_dq_dqs_nom[1], i_target_mba.toEcmdString());
     FAPI_INF("CEN_RCV_IMP_DQ_DQS_SCHMOO[0] = [%d], CEN_RCV_IMP_DQ_DQS_SCHMOO[1] = [%d], on %s", l_rcv_imp_dq_dqs_schmoo[0],l_rcv_imp_dq_dqs_schmoo[1], i_target_mba.toEcmdString());
@@ -889,7 +889,7 @@ fapi::ReturnCode rcv_imp_shmoo(const fapi::Target & i_target_mba,
 		FAPI_INF("Configuring Receiver impedance registers:");
   	        rc = config_rcv_imp(i_target_mba, i_port, l_rcv_imp_dq_dqs[i_port]); if (rc) return rc;
 		FAPI_INF("Calling Shmoo function to find out timing margin:");
-	        rc = delay_shmoo(i_target_mba, i_port, i_shmoo_type_valid, 
+	        rc = delay_shmoo(i_target_mba, i_port, i_shmoo_type_valid,
 			     &l_left_margin, &l_right_margin, i_pattern, i_test_type);
 	        if (rc) return rc;
 		l_left_margin_rcv_imp_array[index]= l_left_margin;
@@ -914,7 +914,7 @@ fapi::ReturnCode rcv_imp_shmoo(const fapi::Target & i_target_mba,
         }
 	else
 	{
-	   
+
 	    if(i_port == 0)
 	    {
 	        l_rcv_imp_dq_dqs_new[0] = rcv_imp_array[count];
@@ -925,25 +925,25 @@ fapi::ReturnCode rcv_imp_shmoo(const fapi::Target & i_target_mba,
 	        l_rcv_imp_dq_dqs_new[1] = rcv_imp_array[count];
 	        l_rcv_imp_dq_dqs_new[0] = l_rcv_imp_dq_dqs_nom[0];
 	    }
- 
+
 	    if (l_rcv_imp_dq_dqs_new[i_port] != l_rcv_imp_dq_dqs_nom[i_port])
 	    {
 	        FAPI_INF("Better Margin found on %d on %s", l_rcv_imp_dq_dqs_new[i_port], i_target_mba.toEcmdString());
-	        rc = FAPI_ATTR_SET(ATTR_EFF_CEN_RCV_IMP_DQ_DQS, &i_target_mba, l_rcv_imp_dq_dqs_new); 
+	        rc = FAPI_ATTR_SET(ATTR_EFF_CEN_RCV_IMP_DQ_DQS, &i_target_mba, l_rcv_imp_dq_dqs_new);
 	        if (rc) return rc;
 	        rc = config_rcv_imp(i_target_mba, i_port, l_rcv_imp_dq_dqs_new[i_port]);
 	        if (rc) return rc;
 	    }
 	    else
 	    {
-	        FAPI_INF("Nominal value will not be changed!- Restoring the original values!");	
+	        FAPI_INF("Nominal value will not be changed!- Restoring the original values!");
 	        rc = config_rcv_imp(i_target_mba, i_port, l_rcv_imp_dq_dqs_nom[i_port]);
                 if (rc) return rc;
 	    }
 	}
     FAPI_INF("++++ Receiver Impdeance Shmoo function executed successfully ++++");
     }
-return rc;  
+return rc;
 }
 
 //------------------------------------------------------------------------------
@@ -953,7 +953,7 @@ return rc;
 // Shmoo type: MCBIST, WR_EYE, RD_EYE, WR_DQS, RD_DQS
 // Shmoo Mode: FEW_ADDR, QUARTER_ADDR, HALF_ADDR, FULL_ADDR
 // i_pattern, i_test_type : Default = 0, mcbist lab function would use this arg
-// Output param: l_left_margin = Left Margin(Setup time), 
+// Output param: l_left_margin = Left Margin(Setup time),
 // l_right_margin = Right Margin (Hold time) in ps
 //------------------------------------------------------------------------------
 
@@ -1001,12 +1001,12 @@ void find_best_margin(shmoo_param i_shmoo_param_valid,
     uint32_t left_margin_nom = 0;
     uint32_t right_margin_nom = 0;
     uint32_t diff_margin_nom = 0;
-    uint32_t total_margin = 0;
+    uint32_t __attribute__((unused)) total_margin = 0; // HACK
     uint32_t diff_margin = 0;
     uint8_t index = 0;
     uint8_t index2 = 0;
-   
-     
+
+
     for(index = 0; index < i_max; index+=1) //send max from top function
     {
 	if(i_shmoo_param_valid & DRV_IMP)
@@ -1032,7 +1032,7 @@ void find_best_margin(shmoo_param i_shmoo_param_valid,
 	    }
         }
         else if(i_shmoo_param_valid & WR_VREF)
-        {   
+        {
 	    if (wr_vref_array_fitness[index] == i_param_nom)
 	    {
         	left_margin_nom = i_left[index];
@@ -1043,7 +1043,7 @@ void find_best_margin(shmoo_param i_shmoo_param_valid,
 	    }
 	}
         else if(i_shmoo_param_valid & RD_VREF)
-        {	    
+        {
 	    if (rd_cen_vref_array_fitness[index] == i_param_nom)
 	    {
         	left_margin_nom = i_left[index];
@@ -1054,17 +1054,17 @@ void find_best_margin(shmoo_param i_shmoo_param_valid,
 	    }
         }
         else if(i_shmoo_param_valid & RCV_IMP)
-        {	    
+        {
 	    if (rcv_imp_array[index] == i_param_nom)
 	    {
         	left_margin_nom = i_left[index];
 	        right_margin_nom = i_right[index];
 	        diff_margin_nom = (i_left[index] >= i_right[index]) ? (i_left[index] - i_right[index]) : (i_right[index] - i_left[index]);
 	        FAPI_INF("Receiver Impedance value (NOM): %d Ohms  Setup Margin: %d Hold Margin: %d", i_param_nom, i_left[index], i_right[index]);
-		    break;	        
+		    break;
 	    }
         }
-	    
+
     }
     for(index2 = 0; index2 < i_max; index2+=1)
     {
diff --git a/src/usr/hwpf/hwp/dram_training/mss_draminit_trainadv/mss_generic_shmoo.C b/src/usr/hwpf/hwp/dram_training/mss_draminit_trainadv/mss_generic_shmoo.C
index c576bec61..ddbb0108f 100644
--- a/src/usr/hwpf/hwp/dram_training/mss_draminit_trainadv/mss_generic_shmoo.C
+++ b/src/usr/hwpf/hwp/dram_training/mss_draminit_trainadv/mss_generic_shmoo.C
@@ -27,7 +27,7 @@
 // *!                   *** IBM Confidential ***
 // *!***************************************************************************
 // *! FILENAME             : mss_generic_shmoo.C
-// *! TITLE                : MSS Generic Shmoo Implementation 
+// *! TITLE                : MSS Generic Shmoo Implementation
 // *! DESCRIPTION          : Memory Subsystem Generic Shmoo -- abstraction for HB
 // *! CONTEXT              : To make all shmoos share a common abstraction layer
 // *!
@@ -39,19 +39,19 @@
 //------------------------------------------------------------------------------
 // Version:|Author: | Date:   | Comment:
 // --------|--------|---------|--------------------------------------------------
-//   1.26  |abhijit	|01/21/13 | fixed fw comments  
-//   1.25  |abhijit	|01/21/13 | fixed the constructor definition 
+//   1.26  |abhijit	|01/21/13 | fixed fw comments
+//   1.25  |abhijit	|01/21/13 | fixed the constructor definition
 //   1.21  |sasethur|01/17/13 | Updated for sanity mcbist function
 //   1.20  |abhijit |01/11/13 | Updated for change in setup_mcbist function
 //   1.19  |aditya  |01/07/13 | Updated for change in setup_mcbist function
-//   1.18  |sasethur|14-DEC-12| Updated for change in access delay function 
-//   1.16  |sasethur|14-DEC-12| Updated for Warning 
-//   1.15  |abhijit |13-DEC-12| Updated for FW review comments 
+//   1.18  |sasethur|14-DEC-12| Updated for change in access delay function
+//   1.16  |sasethur|14-DEC-12| Updated for Warning
+//   1.15  |abhijit |13-DEC-12| Updated for FW review comments
 //   1.14  |abhijit |06-DEC-12| Fixed more FW review comments
 //   1.12  |abhijit |15-Nov-12| Fixed FW review comments
 //   1.11  |abhijit |29-Oct-12| added change for ISDIMM checker DQS.
-//   1.9   |abhijit |22-Oct-12| added Write and read DQS.  
-//   1.8   |abhijit |15-Oct-12|Updated multiple changes 
+//   1.9   |abhijit |22-Oct-12| added Write and read DQS.
+//   1.8   |abhijit |15-Oct-12|Updated multiple changes
 //   1.0   |varkeykv|27-Sep-11|Initial check in
 //------------------------------------------------------------------------------
 #include <fapi.H>
@@ -66,11 +66,11 @@ extern "C"
 {
 using namespace fapi;
 
-// START IMPLEMENTATION OF generic_shmoo CLASS METHODS 
+// START IMPLEMENTATION OF generic_shmoo CLASS METHODS
 //! shmoo_mask - What shmoos do you want to run ... encoded as Hex 0x2,0x4,0x8,0x16
 /*------------------------------------------------------------------------------
  * constructor: generic_shmoo
- * Description  :Constructor used to initialize variables and do the initial settings 
+ * Description  :Constructor used to initialize variables and do the initial settings
  *
  * Parameters: i_target: mba;		iv_port: 0, 1
  * ---------------------------------------------------------------------------*/
@@ -79,40 +79,40 @@ generic_shmoo:: generic_shmoo(uint8_t prt,shmoo_type_t shmoo_mask,shmoo_algorith
     //this->shmoo_mask=shmoo_mask; //! Sets what Shmoos the caller wants to run
     this->algorithm=shmoo_algorithm ;
     this->iv_port=prt ;
-    
-    
+
+
     iv_MAX_RANKS=8;
     iv_MAX_BYTES=10;
     iv_DQS_ON=0;
     iv_pattern=0;
     iv_test_type=0;
     iv_dmm_type=0;
-    
+
     for(int i=0;i<iv_MAX_RANKS;++i)
     {
         valid_rank[i]=0;
     }
-    
+
     FAPI_DBG("mss_generic_shmoo : constructor running for shmoo type %d",shmoo_mask);
     iv_shmoo_type = 0;
 	SHMOO[iv_shmoo_type].static_knob.min_val=0;
-    SHMOO[iv_shmoo_type].static_knob.max_val=512; 
-	
-	
+    SHMOO[iv_shmoo_type].static_knob.max_val=512;
+
+
 	if(shmoo_mask & TEST_NONE)
     {
         FAPI_DBG("mss_generic_shmoo : WR_EYE selected %d",shmoo_mask);
         iv_shmoo_type = 0;
         SHMOO[0].static_knob.min_val=0;
-        SHMOO[0].static_knob.max_val=512;   
+        SHMOO[0].static_knob.max_val=512;
     }
-    
+
     if(shmoo_mask & WR_EYE)
     {
         FAPI_DBG("mss_generic_shmoo : WR_EYE selected %d",shmoo_mask);
         iv_shmoo_type = 0;
         SHMOO[0].static_knob.min_val=0;
-        SHMOO[0].static_knob.max_val=512;   
+        SHMOO[0].static_knob.max_val=512;
     }
     if(shmoo_mask & RD_EYE)
     {
@@ -121,7 +121,7 @@ generic_shmoo:: generic_shmoo(uint8_t prt,shmoo_type_t shmoo_mask,shmoo_algorith
         SHMOO[2].static_knob.min_val=0;
         SHMOO[2].static_knob.max_val=128;
     }
-	
+
      if(shmoo_mask & WRT_DQS) //preet
     {
         FAPI_DBG("mss_generic_shmoo : WRT_DQS selected %d",shmoo_mask);
@@ -130,17 +130,17 @@ generic_shmoo:: generic_shmoo(uint8_t prt,shmoo_type_t shmoo_mask,shmoo_algorith
         SHMOO[1].static_knob.min_val=0;
         SHMOO[1].static_knob.max_val=512;
     }
-	
+
     if(shmoo_mask & RD_GATE) //preet
     {
         FAPI_DBG("mss_generic_shmoo : RD_EYE selected %d",shmoo_mask);
-        
+
         iv_shmoo_type = 3;
 	iv_DQS_ON = 1;
         SHMOO[3].static_knob.min_val=0;
         SHMOO[3].static_knob.max_val=128;
     }
-	
+
     for(int j=0;j<iv_MAX_RANKS;++j)
     {
         init_multi_array(SHMOO[iv_shmoo_type].MBA.P[iv_port].S[j].K.nom_val,0);
@@ -150,7 +150,7 @@ generic_shmoo:: generic_shmoo(uint8_t prt,shmoo_type_t shmoo_mask,shmoo_algorith
         init_multi_array(SHMOO[iv_shmoo_type].MBA.P[iv_port].S[j].K.right_margin_val,0);
         init_multi_array(SHMOO[iv_shmoo_type].MBA.P[iv_port].S[j].K.left_margin_val,0);
     }
-	
+
 	if(iv_DQS_ON == 1)
 	{
 		for(int j=0;j<iv_MAX_RANKS;++j) //initialize values for DQS
@@ -172,7 +172,7 @@ generic_shmoo:: generic_shmoo(uint8_t prt,shmoo_type_t shmoo_mask,shmoo_algorith
  * Parameters: i_target: mba;		iv_port: 0, 1
  * ---------------------------------------------------------------------------*/
 fapi::ReturnCode generic_shmoo::run(const fapi::Target & i_target,uint32_t *o_right_min_margin,uint32_t *o_left_min_margin,uint8_t i_pattern,uint8_t i_test_type){
-    fapi::ReturnCode rc;  
+    fapi::ReturnCode rc;
     uint8_t num_ranks_per_dimm[2][2];
     uint8_t l_attr_eff_dimm_type_u8=0;
 	uint8_t l_attr_schmoo_test_type_u8=0;
@@ -180,14 +180,14 @@ fapi::ReturnCode generic_shmoo::run(const fapi::Target & i_target,uint32_t *o_ri
     uint16_t l_sp_mask=0x00ff;
     ecmdDataBufferBase l_data_buffer1_64(64);
     uint32_t rc_num = 0;
-    
+
     rc = FAPI_ATTR_GET(ATTR_EFF_NUM_RANKS_PER_DIMM, &i_target, num_ranks_per_dimm); if(rc) return rc;
-    rc = FAPI_ATTR_GET(ATTR_EFF_DIMM_TYPE, &i_target, l_attr_eff_dimm_type_u8); if(rc) return rc; 
-    rc = FAPI_ATTR_GET(ATTR_EFF_SCHMOO_TEST_VALID, &i_target, l_attr_schmoo_test_type_u8); if(rc) return rc; 
+    rc = FAPI_ATTR_GET(ATTR_EFF_DIMM_TYPE, &i_target, l_attr_eff_dimm_type_u8); if(rc) return rc;
+    rc = FAPI_ATTR_GET(ATTR_EFF_SCHMOO_TEST_VALID, &i_target, l_attr_schmoo_test_type_u8); if(rc) return rc;
     iv_MAX_RANKS=num_ranks_per_dimm[iv_port][0]+num_ranks_per_dimm[iv_port][1];
     iv_pattern=i_pattern;
     iv_test_type=i_test_type;
-    
+
     if ( l_attr_eff_dimm_type_u8 == 0 )
     {
 	iv_MAX_BYTES=8;
@@ -199,26 +199,26 @@ fapi::ReturnCode generic_shmoo::run(const fapi::Target & i_target,uint32_t *o_ri
 	    rc_num = rc_num | l_data_buffer1_64.insertFromRight(l_sp_mask,0,16);
 	    if(rc_num)
 	    {
-		FAPI_ERR( "mss_generic_shmoo: Error in run !");       
-		rc.setEcmdError(rc_num); 
+		FAPI_ERR( "mss_generic_shmoo: Error in run !");
+		rc.setEcmdError(rc_num);
 		return rc;
-	    } 
+	    }
 	}
 	else
 	{
 	    rc_num = rc_num | l_data_buffer1_64.insertFromRight(l_sp_mask,16,16);
 	    if(rc_num)
 	    {
-		FAPI_ERR( "mss_generic_shmoo:");       
-		rc.setEcmdError(rc_num); 
+		FAPI_ERR( "mss_generic_shmoo:");
+		rc.setEcmdError(rc_num);
 		return rc;
-	    } 
+	    }
 	}
 	rc = fapiPutScom(i_target,MBS_MCBIST01_MCBCMABQ_0x02011674,l_data_buffer1_64); if(rc) return rc;
 	iv_dmm_type=1;
 	iv_MAX_BYTES=9;
     }
-    rc = mss_getrankpair(i_target,iv_port,0,&rank_pair,valid_rank);if(rc) return rc; 
+    rc = mss_getrankpair(i_target,iv_port,0,&rank_pair,valid_rank);if(rc) return rc;
     FAPI_DBG("mss_generic_shmoo : run() for shmoo type %d",shmoo_mask);
      // Check if all bytes/bits are in a pass condition initially .Otherwise quit
     if(l_attr_schmoo_test_type_u8 == 0){
@@ -226,19 +226,19 @@ fapi::ReturnCode generic_shmoo::run(const fapi::Target & i_target,uint32_t *o_ri
 	return rc;
 	}
 	if(l_attr_schmoo_test_type_u8 == 1){
-	rc=sanity_check(i_target); // Run MCBIST only when ATTR_EFF_SCHMOO_TEST_VALID is mcbist only 
+	rc=sanity_check(i_target); // Run MCBIST only when ATTR_EFF_SCHMOO_TEST_VALID is mcbist only
 
     if(!rc.ok())
     {
     FAPI_ERR("generic_shmoo::run MSS Generic Shmoo failed initial Sanity Check. Memory not in an all pass Condition");
-    return rc; 
+    return rc;
     }
 	}else{
-	// rc=sanity_check(i_target); // Run MCBIST by  default before for every schmoo to check if memory is in good condition. 
+	// rc=sanity_check(i_target); // Run MCBIST by  default before for every schmoo to check if memory is in good condition.
     // if(!rc.ok())
     // {
     // FAPI_ERR("generic_shmoo::run MSS Generic Shmoo failed initial Sanity Check. Memory not in an all pass Condition");
-    // return rc; 
+    // return rc;
     // }
     // If memory is OK then we continue to gather nominals and config values
     //  Now Read nominal values for all knobs configured
@@ -248,7 +248,7 @@ fapi::ReturnCode generic_shmoo::run(const fapi::Target & i_target,uint32_t *o_ri
     rc=find_bound(i_target,RIGHT);if(rc) return rc;
     //Find LEFT BOUND OR HOLD BOUND
     rc=find_bound(i_target,LEFT);if(rc) return rc;
-    //Find the margins in Ps i.e setup margin ,hold margin,Eye width 
+    //Find the margins in Ps i.e setup margin ,hold margin,Eye width
     rc=get_margin(i_target);if(rc) return rc;
     //It is used to find the lowest of setup and hold margin
     rc=get_min_margin(i_target,o_right_min_margin,o_left_min_margin);if(rc) return rc;
@@ -261,7 +261,7 @@ fapi::ReturnCode generic_shmoo::run(const fapi::Target & i_target,uint32_t *o_ri
  * Function: sanity_check
  * Description  : do intial mcbist check in nominal and report spd if any bad bit found
  *
- * Parameters: i_target: mba;	
+ * Parameters: i_target: mba;
  * ---------------------------------------------------------------------------*/
 fapi::ReturnCode generic_shmoo::sanity_check(const fapi::Target & i_target){
     fapi:: ReturnCode rc;
@@ -271,24 +271,24 @@ fapi::ReturnCode generic_shmoo::sanity_check(const fapi::Target & i_target){
     uint8_t l_rank_valid = 0;
     uint8_t l_byte = 0;
     uint8_t l_nibble = 0;
-    uint8_t l_socket =0;
+    uint8_t __attribute__((unused)) l_socket =0; // HACK
 	uint32_t rc_num = 0;
-    uint8_t l_dqBitmap[DIMM_DQ_RANK_BITMAP_SIZE];
+    uint8_t __attribute__((unused)) l_dqBitmap[DIMM_DQ_RANK_BITMAP_SIZE]; // HACK
 	uint64_t l_original_start_address1 = 0x0000000000000000;
     uint64_t l_original_end_address1 = 0x0000000000000000;
     uint64_t l_original_start_address2 = 0x0000000000000000;
     uint64_t l_original_end_address2 = 0x0000000000000000;
-	uint64_t l_start =0x0000000000000000ull; 
-    uint64_t l_end = 0x0000000000000000ull; 
+	uint64_t l_start =0x0000000000000000ull;
+    uint64_t l_end = 0x0000000000000000ull;
 	uint64_t l_time = 0x0000000000000000ull;
-    ecmdDataBufferBase l_data_bufferx1_64(64); 
+    ecmdDataBufferBase l_data_bufferx1_64(64);
     ecmdDataBufferBase l_data_bufferx2_64(64);
-    ecmdDataBufferBase l_data_bufferx3_64(64); 
+    ecmdDataBufferBase l_data_bufferx3_64(64);
     ecmdDataBufferBase l_data_bufferx4_64(64);
-    
+
 	rc = fapiGetScom(i_target,MBA01_MCBIST_MCBSSARA0Q_0x030106d0,l_data_bufferx1_64); if(rc) return rc;
 	rc = fapiGetScom(i_target,MBA01_MCBIST_MCBSEARA0Q_0x030106d2,l_data_bufferx2_64); if(rc) return rc;
-	rc = fapiGetScom(i_target,MBA01_MCBIST_MCBSSARA1Q_0x030106d1,l_data_bufferx3_64); if(rc) return rc;    
+	rc = fapiGetScom(i_target,MBA01_MCBIST_MCBSSARA1Q_0x030106d1,l_data_bufferx3_64); if(rc) return rc;
 	rc = fapiGetScom(i_target,MBA01_MCBIST_MCBSEARA1Q_0x030106d3,l_data_bufferx4_64); if(rc) return rc;
 	l_original_start_address1 = l_data_bufferx1_64.getDoubleWord (0);
         l_original_end_address1 = l_data_bufferx2_64.getDoubleWord (0);
@@ -297,17 +297,17 @@ fapi::ReturnCode generic_shmoo::sanity_check(const fapi::Target & i_target){
     for(l_rank = 0; l_rank < iv_MAX_RANKS; l_rank++)
     {
 	l_rank_valid=valid_rank[l_rank];
-	
+
 	if(l_rank_valid<MAX_RANK_DIMM)
-	{   
+	{
 	    l_socket=0;
 	}
 	else
 	{
 	l_socket=1;
-	}	
+	}
 	FAPI_INF("  entering set_up mcbist now and rank %d",l_rank_valid);
-	
+
 	rc = setup_mcbist(i_target, iv_port, MCBIST_2D_CUP_PAT8, CENSHMOO, UNMASK_ALL, 0,iv_pattern,iv_test_type,l_rank_valid,0,l_start,l_end);if(rc) return rc;  //send shmoo mode to vary the address range
 
 	FAPI_INF("  starting  mcbist now");
@@ -329,10 +329,10 @@ fapi::ReturnCode generic_shmoo::sanity_check(const fapi::Target & i_target){
 		    else
 		    {
 			l_dqBitmap[l_byte] = 0x0f;
-		    }	
+		    }
 		    //rc = dimmSetBadDqBitmap(i_target,iv_port,l_socket, l_rank_valid, l_dqBitmap);if(rc) return rc;
 		}
-	    }    
+	    }
         }
 		rc_num  =  l_data_bufferx1_64.setDoubleWord(0,l_original_start_address1);if (rc_num){FAPI_ERR( "Error in function  sanity_check:");rc.setEcmdError(rc_num);return rc;}
 	    rc_num  =  l_data_bufferx2_64.setDoubleWord(0,l_original_end_address1);if (rc_num){FAPI_ERR( "Error in function  sanity_check:");rc.setEcmdError(rc_num);return rc;}
@@ -342,13 +342,13 @@ fapi::ReturnCode generic_shmoo::sanity_check(const fapi::Target & i_target){
         rc = fapiPutScom(i_target,MBA01_MCBIST_MCBSEARA0Q_0x030106d2,l_data_bufferx2_64);  if(rc) return rc;
         rc = fapiPutScom(i_target,MBA01_MCBIST_MCBSSARA1Q_0x030106d1,l_data_bufferx3_64); if(rc) return rc;
         rc = fapiPutScom(i_target,MBA01_MCBIST_MCBSEARA1Q_0x030106d3,l_data_bufferx4_64); if(rc) return rc;
-    
+
     }
-    
+
     if(l_mcb_status)
     {
         FAPI_ERR("generic_shmoo:sanity_check failed !! MCBIST failed on intial run , memory is not in good state aborting shmoo");
-		 FAPI_SET_HWP_ERROR(rc,RC_MSS_MCBIST_ERROR);		
+		 FAPI_SET_HWP_ERROR(rc,RC_MSS_MCBIST_ERROR);
         return rc;
     }
 
@@ -358,12 +358,12 @@ fapi::ReturnCode generic_shmoo::sanity_check(const fapi::Target & i_target){
  * Function: do_mcbist_test
  * Description  : do mcbist check for error on particular nibble
  *
- * Parameters: i_target: mba,iv_port 0/1 , rank 0-7 , byte 0-7, nibble 0/1, pass;	
+ * Parameters: i_target: mba,iv_port 0/1 , rank 0-7 , byte 0-7, nibble 0/1, pass;
  * ---------------------------------------------------------------------------*/
 fapi::ReturnCode generic_shmoo::do_mcbist_test(const fapi::Target & i_target,uint8_t i_rank,uint8_t i_byte,uint8_t i_nibble,uint8_t &pass)
 {
     mcbist_mode=QUARTER_SLOW;
-    uint8_t l_socket=0;
+    uint8_t __attribute__((unused)) l_socket=0; // HACK
     uint8_t l_mcb_status=0;
     input_type l_input_type_e =  ISDIMM_DQ;
     uint8_t i_input_index_u8=0;
@@ -374,54 +374,54 @@ fapi::ReturnCode generic_shmoo::do_mcbist_test(const fapi::Target & i_target,uin
     uint64_t l_original_end_address1 = 0x0000000000000000;
     uint64_t l_original_start_address2 = 0x0000000000000000;
     uint64_t l_original_end_address2 = 0x0000000000000000;
-    ecmdDataBufferBase l_data_bufferx1_64(64); 
+    ecmdDataBufferBase l_data_bufferx1_64(64);
     ecmdDataBufferBase l_data_bufferx2_64(64);
-    ecmdDataBufferBase l_data_bufferx3_64(64); 
+    ecmdDataBufferBase l_data_bufferx3_64(64);
     ecmdDataBufferBase l_data_bufferx4_64(64);
-	uint64_t l_start =0x0000000000000000ull; 
-    uint64_t l_end = 0x0000000000000000ull; 
+	uint64_t l_start =0x0000000000000000ull;
+    uint64_t l_end = 0x0000000000000000ull;
 	uint64_t l_time = 0x0000000000000000ull;
 	rc = fapiGetScom(i_target,MBA01_MCBIST_MCBSSARA0Q_0x030106d0,l_data_bufferx1_64); if(rc) return rc;
 	rc = fapiGetScom(i_target,MBA01_MCBIST_MCBSEARA0Q_0x030106d2,l_data_bufferx2_64); if(rc) return rc;
-	rc = fapiGetScom(i_target,MBA01_MCBIST_MCBSSARA1Q_0x030106d1,l_data_bufferx3_64); if(rc) return rc;    
+	rc = fapiGetScom(i_target,MBA01_MCBIST_MCBSSARA1Q_0x030106d1,l_data_bufferx3_64); if(rc) return rc;
 	rc = fapiGetScom(i_target,MBA01_MCBIST_MCBSEARA1Q_0x030106d3,l_data_bufferx4_64); if(rc) return rc;
 	l_original_start_address1 = l_data_bufferx1_64.getDoubleWord (0);
     l_original_end_address1 = l_data_bufferx2_64.getDoubleWord (0);
     l_original_start_address2 = l_data_bufferx3_64.getDoubleWord (0);
     l_original_end_address2 = l_data_bufferx4_64.getDoubleWord (0);
-	
+
     if(i_rank<4)
-    {   
+    {
 	l_socket=0;
     }
     else
     {
 	l_socket=1;
-    }	
-    
-	
-    
+    }
+
+
+
    rc = setup_mcbist(i_target, iv_port, ABLE_FIVE, CENSHMOO, UNMASK_ALL, 0,iv_pattern,iv_test_type,i_rank,0,l_start,l_end);if(rc) return rc;  //send shmoo mode to vary the address range
-   
+
    rc = start_mcb(i_target);
     if(rc)
     {
-        FAPI_ERR("generic_shmoo::do_mcbist_test: Start MCBIST failed !!");  
-				
+        FAPI_ERR("generic_shmoo::do_mcbist_test: Start MCBIST failed !!");
+
         return rc;
     }
     rc=poll_mcb(i_target,false,&l_mcb_status,l_time);
     if(rc)
     {
-        FAPI_ERR("generic_shmoo::do_mcbist_test: POLL MCBIST failed !!");  
-			
+        FAPI_ERR("generic_shmoo::do_mcbist_test: POLL MCBIST failed !!");
+
         return rc;
     }
     rc=mcb_error_map(i_target,mcbist_error_map,iv_port,i_rank);
     if(rc)
     {
-        FAPI_ERR("generic_shmoo::do_mcbist_test: mcb_error_map failed!!"); 
-			
+        FAPI_ERR("generic_shmoo::do_mcbist_test: mcb_error_map failed!!");
+
         return rc;
     }
     rc_num  =  l_data_bufferx1_64.setDoubleWord(0,l_original_start_address1);if (rc_num){FAPI_ERR( "Error in function  do_mcbist_test:");rc.setEcmdError(rc_num);return rc;}
@@ -432,7 +432,7 @@ fapi::ReturnCode generic_shmoo::do_mcbist_test(const fapi::Target & i_target,uin
     rc = fapiPutScom(i_target,MBA01_MCBIST_MCBSEARA0Q_0x030106d2,l_data_bufferx2_64);  if(rc) return rc;
     rc = fapiPutScom(i_target,MBA01_MCBIST_MCBSSARA1Q_0x030106d1,l_data_bufferx3_64); if(rc) return rc;
     rc = fapiPutScom(i_target,MBA01_MCBIST_MCBSEARA1Q_0x030106d3,l_data_bufferx4_64); if(rc) return rc;
-	
+
     if(iv_dmm_type==1)
     {
 	i_input_index_u8=8*i_byte+4*i_nibble;
@@ -440,12 +440,12 @@ fapi::ReturnCode generic_shmoo::do_mcbist_test(const fapi::Target & i_target,uin
 	i_byte=l_val/8;
 	i_nibble=l_val%4;
 	check_error_map(i_rank,i_byte,i_nibble,pass);
-    
+
     }
     else
     {
 	check_error_map(i_rank,i_byte,i_nibble,pass);
-	
+
     }
     return rc;
 }
@@ -453,11 +453,11 @@ fapi::ReturnCode generic_shmoo::do_mcbist_test(const fapi::Target & i_target,uin
  * Function: check_error_map
  * Description  : used by do_mcbist_test  to check the error map for particular nibble
  *
- * Parameters: iv_port 0/1 , rank 0-7 , byte 0-7, nibble 0/1, pass;	
+ * Parameters: iv_port 0/1 , rank 0-7 , byte 0-7, nibble 0/1, pass;
  * ---------------------------------------------------------------------------*/
 void  generic_shmoo::check_error_map(uint8_t i_rank,uint8_t i_byte,uint8_t i_nibble,uint8_t &pass)
 {
-    
+
     if( mcbist_error_map [iv_port][i_rank][i_byte][i_nibble] == 1){
         pass=0;
        // FAPI_INF("We are in error1");
@@ -467,7 +467,7 @@ void  generic_shmoo::check_error_map(uint8_t i_rank,uint8_t i_byte,uint8_t i_nib
         pass=1;
         //FAPI_INF("We are in error2");
     }
-    
+
 }
 /*------------------------------------------------------------------------------
  * Function: init_multi_array
@@ -477,22 +477,22 @@ void  generic_shmoo::check_error_map(uint8_t i_rank,uint8_t i_byte,uint8_t i_nib
  * ---------------------------------------------------------------------------*/
 void  generic_shmoo::init_multi_array(uint32_t (&array)[MAX_DQ][MAX_RPS],uint32_t init_val)
 {
-    
+
     uint8_t l_byte,l_nibble,l_bit,l_rp;
     uint8_t l_dq=0;
     for (l_rp=0;l_rp<MAX_RPS;++l_rp)
     {// Byte loop
-		
+
         for(l_byte=0;l_byte<iv_MAX_BYTES;++l_byte)
         {   //Nibble loop
             for(l_nibble=0;l_nibble< MAX_NIBBLES;++l_nibble)
-            { 
+            {
 		//Bit loop
                 for(l_bit=0;l_bit<MAX_BITS;++l_bit)
-                {  
+                {
 		    l_dq=8*l_byte+4*l_nibble+l_bit;
 		    array[l_dq][l_rp]=init_val;
-		}	
+		}
             }
         }
     }
@@ -511,17 +511,17 @@ fapi::ReturnCode generic_shmoo::init_multi_array_dqs(uint32_t (&array)[MAX_DQ][M
     uint8_t l_dq=0;
     for (l_rp=0;l_rp<MAX_RPS;++l_rp)
     {// Byte loop
-		
+
         for(l_byte=0;l_byte<iv_MAX_BYTES;++l_byte)
         {   //Nibble loop
             for(l_nibble=0;l_nibble< MAX_NIBBLES;++l_nibble)
-            { 
+            {
 		//Bit loop
                 for(l_bit=0;l_bit<MAX_BITS;++l_bit)
-                {  
+                {
 		    l_dq=8*l_byte+4*l_nibble+l_bit;
 		    array[l_dq][l_rp]=init_val;
-		}	
+		}
             }
         }
     }
@@ -529,65 +529,65 @@ return rc;
 }
 /*------------------------------------------------------------------------------
  * Function: get_all_noms
- * Description  : This function gets the nominal values for each DQ 
+ * Description  : This function gets the nominal values for each DQ
  *
- * Parameters: Target:MBA 
+ * Parameters: Target:MBA
  * ---------------------------------------------------------------------------*/
 fapi::ReturnCode generic_shmoo::get_all_noms(const fapi::Target & i_target)
 {
     fapi::ReturnCode rc;
-    
+
     uint8_t l_rnk,l_byte,l_nibble,l_bit;
     uint8_t i_rnk=0;
     uint8_t i_rp=0;
     uint32_t val=0;
     uint8_t l_dq=0;
-             
+
     input_type_t l_input_type_e = WR_DQ;
     access_type_t l_access_type_e = READ ;
     FAPI_DBG("mss_generic_shmoo : get_all_noms : Reading in all nominal values");
-    
-    
+
+
              if(iv_shmoo_type == 1)
-            {   
+            {
 		l_input_type_e = WR_DQS;
-                
+
             }
             else if(iv_shmoo_type == 2)
-            {   
-		
+            {
+
 		l_input_type_e = RD_DQ;
-                
+
             }
             else if(iv_shmoo_type == 3)
-            {   
-		
+            {
+
 		l_input_type_e = RD_DQS;
-                   
+
             }
-            
-	   
+
+
     for (l_rnk=0;l_rnk<iv_MAX_RANKS;++l_rnk)
     {// Byte loop
 		i_rnk=valid_rank[l_rnk];
-		    rc = mss_getrankpair(i_target,iv_port,i_rnk,&i_rp,valid_rank);if(rc) return rc; 
+		    rc = mss_getrankpair(i_target,iv_port,i_rnk,&i_rp,valid_rank);if(rc) return rc;
         for(l_byte=0;l_byte<iv_MAX_BYTES;++l_byte)
         {   //Nibble loop
             for(l_nibble=0;l_nibble< MAX_NIBBLES;++l_nibble)
-            { 
+            {
 		//Bit loop
                 for(l_bit=0;l_bit<MAX_BITS;++l_bit)
-                {  
+                {
 		    l_dq=8*l_byte+4*l_nibble+l_bit;
-		    
-		    rc=mss_access_delay_reg(i_target,l_access_type_e,iv_port,i_rnk,l_input_type_e,l_dq,0,val);if(rc) return rc; 
+
+		    rc=mss_access_delay_reg(i_target,l_access_type_e,iv_port,i_rnk,l_input_type_e,l_dq,0,val);if(rc) return rc;
 		    SHMOO[iv_shmoo_type].MBA.P[iv_port].S[i_rnk].K.nom_val[l_dq][i_rp]=val;
 		    FAPI_INF("Nominal  Value for rank=%d  and rank pair=%d and dq=%d is  %d",i_rnk,i_rp,l_dq,val);
-                    
+
 		}
 	    }
 	}
-    }	
+    }
     return rc;
 }
 
@@ -598,7 +598,7 @@ fapi::ReturnCode generic_shmoo::get_all_noms(const fapi::Target & i_target)
  * Parameters: Target:MBA,bound:RIGHT/LEFT,scenario:type of schmoo,iv_port:0/1,rank:0-7,byte:0-7,nibble:0/1,bit:0-3,pass,
  * ---------------------------------------------------------------------------*/
 fapi::ReturnCode generic_shmoo::knob_update(const fapi::Target & i_target,bound_t bound,uint8_t scenario,uint8_t rank,uint8_t byte,uint8_t nibble,uint8_t bit,uint8_t pass,bool &flag)
-{	
+{
     fapi::ReturnCode rc;
     ecmdDataBufferBase data_buffer_64(64);
     ecmdDataBufferBase data_buffer_64_1(64);
@@ -621,21 +621,21 @@ fapi::ReturnCode generic_shmoo::knob_update(const fapi::Target & i_target,bound_
     uint8_t l_dq=0;
     access_type_t l_access_type_e = WRITE;
 
-    
-    
+
+
     l_dq=8*byte+4*nibble+bit;
-	
-    rc = mss_getrankpair(i_target,iv_port,rank,&l_rp,valid_rank);if(rc) return rc; 
-	
-	
+
+    rc = mss_getrankpair(i_target,iv_port,rank,&l_rp,valid_rank);if(rc) return rc;
+
+
     if(scenario == 2) {
 	l_input_type_e = RD_DQ;
 	}
-	
-    
+
+
     if(bound==LEFT)
     {
-        
+
 	if(algorithm==SEQ_LIN)
         {
 	    l_min_value=SHMOO[scenario].static_knob.min_val;
@@ -645,7 +645,7 @@ fapi::ReturnCode generic_shmoo::knob_update(const fapi::Target & i_target,bound_
 		rc=mss_access_delay_reg(i_target,l_access_type_e,iv_port,rank,l_input_type_e,l_dq,1,l_current_val);if(rc) return rc;
 		rc=do_mcbist_test(i_target,rank,byte,nibble,pass);
 		if(rc)
-		{   
+		{
 		    FAPI_ERR("generic_shmoo::find_bound do_mcbist_test failed");
 		    return rc;
 		}
@@ -654,7 +654,7 @@ fapi::ReturnCode generic_shmoo::knob_update(const fapi::Target & i_target,bound_
 	    {
 		pass=1;
 		for(l_current_val=l_current_val+10;((l_current_val>l_min_value)&&(pass==1));l_current_val--)
-		{ 
+		{
 		    rc=mss_access_delay_reg(i_target,l_access_type_e,iv_port,rank,l_input_type_e,l_dq,0,l_current_val);if(rc) return rc;
 		    rc = fapiGetScom(i_target,MBA01_MBA_PMU0Q_0x03010437,data_buffer_64); if(rc) return rc;
 		    l_rd_cnt_A = data_buffer_64.getDoubleWord(0);
@@ -714,23 +714,23 @@ fapi::ReturnCode generic_shmoo::knob_update(const fapi::Target & i_target,bound_
 				    {
 					pass=1;
 				    }
-				}	
+				}
 			}while(l_delta<read_counter_threshold);
 			if(!pass)
 			{
 			    SHMOO[scenario].MBA.P[iv_port].S[rank].K.lb_regval[l_dq][l_rp]=l_current_val;
 			}
-		}	
+		}
 	    }
-	    
+
 		SHMOO[scenario].MBA.P[iv_port].S[rank].K.lb_regval[l_dq][l_rp]=l_current_val+l_left_del;
-	    
-	    
+
+
 	    l_current_val=SHMOO[scenario].MBA.P[iv_port].S[rank].K.nom_val[l_dq][l_rp];
 		FAPI_INF("  the restoring nominal value for rank=%d dq=%d and rp=%d is %d",rank,l_dq,l_rp,l_current_val);
 	    rc=mss_access_delay_reg(i_target,l_access_type_e,iv_port,rank,l_input_type_e,l_dq,0,l_current_val);if(rc) return rc;
 	}
-    }	
+    }
     if(bound==RIGHT)
     {
         if(algorithm==SEQ_LIN)
@@ -742,12 +742,12 @@ fapi::ReturnCode generic_shmoo::knob_update(const fapi::Target & i_target,bound_
 		rc=mss_access_delay_reg(i_target,l_access_type_e,iv_port,rank,l_input_type_e,l_dq,1,l_current_val);if(rc) return rc;
 		rc=do_mcbist_test(i_target,rank,byte,nibble,pass);
 		if(rc)
-		{   
+		{
 		    FAPI_ERR("generic_shmoo::find_bound do_mcbist_test failed");
 		    return rc;
 		}
 	    }
-	    
+
 	    if(flag)
 	    {
 		pass=1;
@@ -812,7 +812,7 @@ fapi::ReturnCode generic_shmoo::knob_update(const fapi::Target & i_target,bound_
 			    {
 				pass=1;
 			    }
-			}	
+			}
 		    }while(l_delta<read_counter_threshold);
 		    if(!pass)
 		    {
@@ -824,17 +824,17 @@ fapi::ReturnCode generic_shmoo::knob_update(const fapi::Target & i_target,bound_
 		    }
 		}
 	    }
-	    
+
 		SHMOO[scenario].MBA.P[iv_port].S[rank].K.rb_regval[l_dq][l_rp]=l_current_val-l_right_del;
-	    
+
 	    FAPI_INF(" the right bound  for dq=%d is %d ",l_dq,SHMOO[scenario].MBA.P[iv_port].S[rank].K.rb_regval[l_dq][l_rp]);
 	    l_current_val=SHMOO[scenario].MBA.P[iv_port].S[rank].K.nom_val[l_dq][l_rp];
 		FAPI_INF("  the restoring nominal value for rank=%d dq=%d and rp=%d is %d",rank,l_dq,l_rp,l_current_val);
 	    rc=mss_access_delay_reg(i_target,l_access_type_e,iv_port,rank,l_input_type_e,l_dq,0,l_current_val);if(rc) return rc;
-	    
+
 	}
     }
-    return rc;	
+    return rc;
 }
 /*------------------------------------------------------------------------------
  * Function: knob_update_dqs
@@ -851,38 +851,38 @@ fapi::ReturnCode generic_shmoo::knob_update_dqs(const fapi::Target & i_target,bo
     data_buffer_64_1.flushTo0();
     uint32_t l_current_val=0;
     uint32_t l_max_value=0;
-    uint32_t l_min_value=0;
-    
+    uint32_t __attribute__((unused)) l_min_value=0; // HACK
+
     uint8_t  l_rp=0;
     input_type_t l_input_type_e = WR_DQS;
     uint8_t l_dq=0;
     access_type_t l_access_type_e = WRITE;
-	
-    if(scenario == 1) 
+
+    if(scenario == 1)
     {
 	l_input_type_e = WR_DQS;
     }
-    else if(scenario == 3) 
+    else if(scenario == 3)
     {
 	l_input_type_e = RD_DQS;
     }
-	
+
     if(bound==LEFT)
     {
-        
+
         if(algorithm==SEQ_LIN)
         {
 	    l_min_value=SHMOO[scenario].static_knob.min_val;
 	    FAPI_INF("  curr val in left above  = %d and pass=%d ",l_current_val,pass);
 	    for(l_current_val=SHMOO[scenario].MBA.P[iv_port].S[rank].K.nom_val[l_dq][l_rp];((l_current_val >= 20)&&(pass==1));l_current_val-=20)
 	    {
-		    //use saurabh function for writing here 
+		    //use saurabh function for writing here
 		    FAPI_INF("  curr val in left = %d and pass=%d ",l_current_val,pass);
 		    rc=mss_access_delay_reg(i_target,l_access_type_e,iv_port,0,l_input_type_e,l_dq,0,l_current_val);if(rc) return rc;
-		    
+
 		    rc=do_mcbist_test(i_target,rank,byte,nibble,pass);
 		    if(rc)
-		    {   
+		    {
 			FAPI_ERR("generic_shmoo::find_bound do_mcbist_test failed");
 			return rc;
 		    }
@@ -894,25 +894,25 @@ fapi::ReturnCode generic_shmoo::knob_update_dqs(const fapi::Target & i_target,bo
 	    FAPI_INF("  left  bound = %d  ",SHMOO[scenario].MBA.P[iv_port].S[rank].K.rb_regval[l_dq][l_rp]);
 	    l_current_val=SHMOO[scenario].MBA.P[iv_port].S[rank].K.nom_val[l_dq][l_rp];
 	    rc=mss_access_delay_reg(i_target,l_access_type_e,iv_port,0,l_input_type_e,l_dq,0,l_current_val);if(rc) return rc;
-	    
+
 	}
     }
-	
+
     else if(bound==RIGHT)
     {
-         
+
         if(algorithm==SEQ_LIN)
          {
 	    l_max_value=SHMOO[scenario].static_knob.max_val;
 	    for(l_current_val=SHMOO[scenario].MBA.P[iv_port].S[rank].K.nom_val[l_dq][l_rp];((l_current_val<l_max_value)&&(pass==1));l_current_val+=100)
 	    {
-		    //use saurabh function for writing here 
+		    //use saurabh function for writing here
 		    FAPI_INF("  curr val  = %d ",l_current_val);
 		    rc=mss_access_delay_reg(i_target,l_access_type_e,iv_port,0,l_input_type_e,l_dq,0,l_current_val);if(rc) return rc;
-		    
+
 		    rc=do_mcbist_test(i_target,rank,byte,nibble,pass);
 		    if(rc)
-		    {   
+		    {
 			FAPI_ERR("generic_shmoo::find_bound do_mcbist_test failed");
 		    return rc;
 		    }
@@ -922,11 +922,11 @@ fapi::ReturnCode generic_shmoo::knob_update_dqs(const fapi::Target & i_target,bo
 		SHMOO[scenario].MBA.P[iv_port].S[rank].K.rb_regval[l_dq][l_rp]=l_current_val;
 	    }
 	    l_current_val=SHMOO[scenario].MBA.P[iv_port].S[rank].K.nom_val[l_dq][l_rp];
-		
+
 	    rc=mss_access_delay_reg(i_target,l_access_type_e,iv_port,0,l_input_type_e,l_dq,0,l_current_val);if(rc) return rc;
 	    FAPI_INF("  right bound = %d  ",SHMOO[scenario].MBA.P[iv_port].S[rank].K.rb_regval[l_dq][l_rp]);
         }
-	    
+
     }
     return rc;
 }
@@ -940,34 +940,34 @@ fapi::ReturnCode generic_shmoo::knob_update_dqs(const fapi::Target & i_target,bo
 fapi::ReturnCode generic_shmoo::find_bound(const fapi::Target & i_target,bound_t bound){
     uint8_t l_rnk,l_byte,l_nibble,l_bit;
     fapi::ReturnCode rc;
-    
+
     uint8_t i_rank=0;
     bool flag=false;
-    
-    
-    
+
+
+
     FAPI_INF("generic_shmoo::find_bound running find_bound function ");
-    
-        
+
+
         for (l_rnk=0;l_rnk<iv_MAX_RANKS;++l_rnk)
         {// Byte loop
 			i_rank=valid_rank[l_rnk];
             for(l_byte=0;l_byte<iv_MAX_BYTES;++l_byte)
             {   //Nibble loop
-		
+
                 for(l_nibble=0;l_nibble< MAX_NIBBLES;++l_nibble)
                 {
-                    
+
 		    //Bit loop
                     for(l_bit=0;l_bit< MAX_BITS;++l_bit)
                     {
 			// preetham function here
-			
-			
+
+
 			if(iv_DQS_ON==1)
 			rc=knob_update_dqs(i_target,bound,iv_shmoo_type,i_rank,l_byte,l_nibble,l_bit,1);if(rc) return rc;
 			else
-			rc=knob_update(i_target,bound,iv_shmoo_type,i_rank,l_byte,l_nibble,l_bit,1,flag); if(rc) return rc;   
+			rc=knob_update(i_target,bound,iv_shmoo_type,i_rank,l_byte,l_nibble,l_bit,1,flag); if(rc) return rc;
                     }
                 }
             }
@@ -977,14 +977,14 @@ fapi::ReturnCode generic_shmoo::find_bound(const fapi::Target & i_target,bound_t
 //#ifdef char
 /*------------------------------------------------------------------------------
  * Function: print_report
- * Description  : This function is used to print the information needed such as freq,voltage etc, and also the right,left and total margin 
+ * Description  : This function is used to print the information needed such as freq,voltage etc, and also the right,left and total margin
  *
  * Parameters: Target:MBA
  * ---------------------------------------------------------------------------*/
 fapi::ReturnCode generic_shmoo::print_report(const fapi::Target & i_target)
 {
     fapi::ReturnCode rc;
-    
+
     uint8_t l_rnk,l_byte,l_nibble,l_bit;
     uint8_t l_dq=0;
     uint8_t l_rp=0;
@@ -996,48 +996,48 @@ fapi::ReturnCode generic_shmoo::print_report(const fapi::Target & i_target)
     uint8_t l_attr_eff_num_drops_per_port_u8 = 0;
     uint8_t l_attr_eff_dram_width_u8 = 0;
     fapi::Target l_target_centaur;
-    
-    
+
+
     rc = fapiGetParentChip(i_target, l_target_centaur); if(rc) return rc;
-   
+
     rc = FAPI_ATTR_GET(ATTR_MSS_FREQ, &l_target_centaur, l_attr_mss_freq_u32); if(rc) return rc;
     rc = FAPI_ATTR_GET(ATTR_MSS_VOLT, &l_target_centaur, l_attr_mss_volt_u32); if(rc) return rc;
     rc = FAPI_ATTR_GET(ATTR_EFF_DIMM_TYPE, &i_target, l_attr_eff_dimm_type_u8); if(rc) return rc;
     rc = FAPI_ATTR_GET(ATTR_EFF_NUM_DROPS_PER_PORT, &i_target, l_attr_eff_num_drops_per_port_u8); if(rc) return rc;
     rc = FAPI_ATTR_GET(ATTR_EFF_DRAM_WIDTH, &i_target, l_attr_eff_dram_width_u8); if(rc) return rc;
     rc = FAPI_ATTR_GET(ATTR_CHIP_UNIT_POS, &i_target, l_mbapos);if(rc) return rc;
-   
+
     FAPI_INF("      freq = %d on %s.", l_attr_mss_freq_u32, l_target_centaur.toEcmdString());
     FAPI_INF("volt = %d on %s.", l_attr_mss_volt_u32, l_target_centaur.toEcmdString());
     FAPI_INF("dimm_type = %d on %s.", l_attr_eff_dimm_type_u8, i_target.toEcmdString());
     if ( l_attr_eff_dimm_type_u8 == fapi::ENUM_ATTR_EFF_DIMM_TYPE_CDIMM )
     {
-	FAPI_INF("It is a CDIMM"); 
+	FAPI_INF("It is a CDIMM");
     }
     else
     {
-	FAPI_INF("It is an ISDIMM"); 
+	FAPI_INF("It is an ISDIMM");
     }
     FAPI_INF("num_drops_per_port = %d on %s.", l_attr_eff_num_drops_per_port_u8, i_target.toEcmdString());
     FAPI_INF("num_ranks  = %d on %s.", iv_MAX_RANKS,i_target.toEcmdString());
     FAPI_INF("dram_width = %d on %s. \n\n", l_attr_eff_dram_width_u8, i_target.toEcmdString());
     FAPI_INF("+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++");
     FAPI_INF("Schmoo  POS\tPort\tRank\tByte\tnibble\tbit\tNominal\t\tSetup_Limit\tHold_Limit\tWrD_Setup(ps)\tWrD_Hold(ps)\tEye_Width(ps)\tBitRate  ");
-    
-    
-        
+
+
+
 	    for (l_rnk=0;l_rnk<iv_MAX_RANKS;++l_rnk)
 	    {// Byte loop
 					    i_rank=valid_rank[l_rnk];
 			    rc = mss_getrankpair(i_target,iv_port,i_rank,&l_rp,valid_rank);if(rc) return rc;
 		for(l_byte=0;l_byte<iv_MAX_BYTES;++l_byte)
 		{
-		    
+
 		    //Nibble loop
 		    for(l_nibble=0;l_nibble< MAX_NIBBLES;++l_nibble)
 		    {
 			for(l_bit=0;l_bit< MAX_BITS;++l_bit)
-			{	
+			{
 			    l_dq=8*l_byte+4*l_nibble+l_bit;
 
 			    if(iv_shmoo_type==0)
@@ -1048,19 +1048,19 @@ fapi::ReturnCode generic_shmoo::print_report(const fapi::Target & i_target)
 			    {
 				FAPI_INF("RD_EYE\t%d\t%d\t%d\t%d\t%d\t%d\t%d\t%d\t%d\t%d\t%d\t%d\t%d\n ",iv_port,l_mbapos,i_rank,l_byte,l_nibble,l_bit,SHMOO[iv_shmoo_type].MBA.P[iv_port].S[i_rank].K.nom_val[l_dq][l_rp],SHMOO[iv_shmoo_type].MBA.P[iv_port].S[i_rank].K.rb_regval[l_dq][l_rp],SHMOO[iv_shmoo_type].MBA.P[iv_port].S[i_rank].K.lb_regval[l_dq][l_rp],SHMOO[iv_shmoo_type].MBA.P[iv_port].S[i_rank].K.right_margin_val[l_dq][l_rp],SHMOO[iv_shmoo_type].MBA.P[iv_port].S[i_rank].K.left_margin_val[l_dq][l_rp],SHMOO[iv_shmoo_type].MBA.P[iv_port].S[i_rank].K.total_margin[l_dq][l_rp],l_attr_mss_freq_u32);
 			    }
-			    
+
 			}
 		    }
 		}
 	    }
-	
-    
+
+
     return rc;
  }
 //#endif
 /*------------------------------------------------------------------------------
  * Function: get_margin
- * Description  : This function is used to get margin for setup,hold and total eye width in Ps by using frequency  
+ * Description  : This function is used to get margin for setup,hold and total eye width in Ps by using frequency
  *
  * Parameters: Target:MBA
  * ---------------------------------------------------------------------------*/
@@ -1076,26 +1076,26 @@ fapi::ReturnCode generic_shmoo::get_margin(const fapi::Target & i_target)
     uint8_t i_rank=0;
     uint64_t l_factor=0;
 	uint64_t l_factor_ps=1000000000;
-    
+
 	//FAPI_INF("   the factor is % llu ",l_cyc);
-    
+
     fapi::Target l_target_centaur;
     rc = fapiGetParentChip(i_target, l_target_centaur); if(rc) return rc;
     rc = FAPI_ATTR_GET(ATTR_MSS_FREQ, &l_target_centaur, l_attr_mss_freq_margin_u32); if(rc) return rc;
     l_freq=l_attr_mss_freq_margin_u32/2;
-    l_cyc=l_cyc/l_freq;// converting to zepto to get more accurate data  
+    l_cyc=l_cyc/l_freq;// converting to zepto to get more accurate data
     l_factor=l_cyc/128;
 	//FAPI_INF("l_factor is % llu ",l_factor);
-    
-    
-        	
+
+
+
 	    for (l_rnk=0;l_rnk<iv_MAX_RANKS;++l_rnk)
 	    {// Byte loop
 		i_rank=valid_rank[l_rnk];
-		rc = mss_getrankpair(i_target,iv_port,i_rank,&l_rp,valid_rank);if(rc) return rc; 
+		rc = mss_getrankpair(i_target,iv_port,i_rank,&l_rp,valid_rank);if(rc) return rc;
 		for(l_byte=0;l_byte<iv_MAX_BYTES;++l_byte)
 		{
-		    
+
 		    //Nibble loop
 		    for(l_nibble=0;l_nibble< MAX_NIBBLES;++l_nibble)
 		    {
@@ -1110,16 +1110,16 @@ fapi::ReturnCode generic_shmoo::get_margin(const fapi::Target & i_target)
                     }
                 }
 	    }
-         
-     
+
+
     return rc;
  }
 
 /*------------------------------------------------------------------------------
  * Function: get_min_margin
- * Description  : This function is used to get the minimum margin of all the schmoo margins  
+ * Description  : This function is used to get the minimum margin of all the schmoo margins
  *
- * Parameters: Target:MBA,right minimum margin , left minimum margin, pass fail 
+ * Parameters: Target:MBA,right minimum margin , left minimum margin, pass fail
  * ---------------------------------------------------------------------------*/
 fapi::ReturnCode generic_shmoo::get_min_margin(const fapi::Target & i_target,uint32_t *o_right_min_margin,uint32_t *o_left_min_margin)
 {
@@ -1130,19 +1130,19 @@ fapi::ReturnCode generic_shmoo::get_min_margin(const fapi::Target & i_target,uin
     uint8_t l_dq=0;
     uint8_t l_rp=0;
 
-    
-    
-        
+
+
+
 	    for (l_rnk=0;l_rnk<iv_MAX_RANKS;++l_rnk)
 	    {// Byte loop
 		for(l_byte=0;l_byte<iv_MAX_BYTES;++l_byte)
 		{
-		    
+
 		    //Nibble loop
 		    for(l_nibble=0;l_nibble< MAX_NIBBLES;++l_nibble)
 		    {
 			for(l_bit=0;l_bit< MAX_BITS;++l_bit)
-			{	
+			{
 			    l_dq=8*l_byte+4*l_nibble+l_bit;
 			    if(SHMOO[iv_shmoo_type].MBA.P[iv_port].S[l_rnk].K.right_margin_val[l_dq][l_rp]<l_temp_right)
 			    {
@@ -1156,12 +1156,12 @@ fapi::ReturnCode generic_shmoo::get_min_margin(const fapi::Target & i_target,uin
                     }
                 }
 	    }
-        
-     
-    // hacked for now till schmoo is running 
+
+
+    // hacked for now till schmoo is running
     *o_right_min_margin=l_temp_right;
     *o_left_min_margin=l_temp_left;
     return rc;
  }
- 
+
 }//Extern C