serdes_dss_ber_k2e.js

   1 /**
   2  * @file serdes_dss.js
   3  *
   4  * @brief
   5  *  Java Script file for DSS synchronization of DIAGNOSTIC SERDES test.
   6
   7     Example DSS script which runs a K2E SERDES TX FIR settings sweep with BER scan
   8     on two devices.
   9
  10     Example assumes a board scenario where two devices Lane0 and Lane1 Serdes lanes
  11     are hooked up to each other as in the below diagram:
  12
  13     Device0 TX0 ----> Device1 RX0
  14     Device0 TX1 ----> Device1 RX1
  15
  16     Device1 TX0 ----> Device0 RX0
  17     Device1 TX1 ----> Device0 RX1
  18
  19     Each TX -> RX channel is assumed to be electrical backplane or backplane + cable.
  20     No active, intermediary, devices (switches, or re-timers) are assumed in the channel.
  21
  22     DSS script loads binaries onto two SoC. Each binary is then synchronized at key
  23     steps such that the RX error count of a given TX setting set can be measured.
  24
  25     Run on a dual K2E platform being controlled by a single CCS emulation session
  26     Tested out on the 6630K2E dual VDB setup
  27
  28 Prerequisite: serdes_dss_ber_k2e.bat invokes this .js file. Please use serdes_dss_ber_k2e.bat to run BER test
  29  *
  30  *  \par
  31  *  ============================================================================
  32  *  @n   (C) Copyright 2015, Texas Instruments, Inc.
  33  *
  34  *  Redistribution and use in source and binary forms, with or without
  35  *  modification, are permitted provided that the following conditions
  36  *  are met:
  37  *
  38  *    Redistributions of source code must retain the above copyright
  39  *    notice, this list of conditions and the following disclaimer.
  40  *
  41  *    Redistributions in binary form must reproduce the above copyright
  42  *    notice, this list of conditions and the following disclaimer in the
  43  *    documentation and/or other materials provided with the
  44  *    distribution.
  45  *
  46  *    Neither the name of Texas Instruments Incorporated nor the names of
  47  *    its contributors may be used to endorse or promote products derived
  48  *    from this software without specific prior written permission.
  49  *
  50  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  51  *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  52  *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  53  *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  54  *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  55  *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  56  *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  57  *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  58  *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  59  *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  60  *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  61  *
  62 */
  63
  64 importPackage(Packages.com.ti.debug.engine.scripting)
  65 importPackage(Packages.com.ti.ccstudio.scripting.environment)
  66 importPackage(Packages.java.lang)
  67 importPackage(java.awt)
  68 importPackage(java.io)
  69 importPackage(java.net)
  70 importPackage(java.util)
  71
  72 /* Major variables that will need to be modified to match a given CCS/DSS environment on the host PC */
  73 /* serdes_dss_ber_k2e.bat will set the %PDK_INSTALL_PATH% environment variable */
  74 var CFG_LOADER_BASE   = java.lang.System.getenv("PDK_INSTALL_PATH");
  75 var pathLog       = CFG_LOADER_BASE + "/ti/diag/serdes_diag/serdes_log_path.xml";
  76 var pathXSL       = CFG_LOADER_BASE + "/ti/diag/serdes_diag/serdes_xsl_path.xsl";
  77 /* Point to the Dual Board Target Configuration File that  you have created.
  78    Instructions on how to create Dual Board Target Config are shown in Section 9 of serdes_diag\docs\Serdes_Diag_User_Guide.pdf*/
  79 var pathCCXML         = "C:/K2E_EVM2EVM.ccxml";
  80 /* Point to the executables to run on Board 0 and Board 1 respectively */
  81 var pathDSP0          = CFG_LOADER_BASE + "/MyExampleProjects/serdes_diag_ber_K2EC66ExampleProject/Debug/serdes_diag_ber_K2EC66ExampleProject.out";
  82 var pathDSP1          = CFG_LOADER_BASE + "/MyExampleProjects/serdes_diag_ber_K2EC66ExampleProject/Debug/serdes_diag_ber_K2EC66ExampleProject.out";
  83
  84
  85
  86 /* DSP core synchronization variables */
  87 var dss_lock_key        = 0xDEADBEEF;
  88 var dss_unlock_key  = 0xBEEFFACE;
  89
  90 var dss_stall_flag_set      = 0xCAFECAFE;
  91 var dss_stall_flag_clear    = 0xCAFEDEAD;
  92 var dss_stall_flag_device0  = 0xCAFEDEAD; /* assume an unstalled device */
  93 var dss_stall_flag_device1  = 0xCAFEDEAD; /*assume an unstalled device */
  94
  95 var dss_test_complete_flag_set      = 0xA5A5A5A5;
  96
  97 var dss_test_complete_flag_device0  = 0xDEADBEEF;   //assume an unfinished test cycle */
  98 var dss_test_complete_flag_device1  = 0xDEADBEEF;   //assume an unfinished test cycle */
  99
 100 /* CCSv7 naming convention */
 101 var sessionName0        = "Texas Instruments XDS2xx USB Onboard Debug Probe_0/C66xx_0";
 102 var sessionName1        = "Texas Instruments XDS2xx USB Onboard Debug Probe_1/C66xx_0";
 103
 104 /* For CCSv5, note that the emulator naming convention will be different */
 105 /* var sessionName0        = "Texas Instruments XDS2xx USB Onboard Emulator_0/C66xx_0"; */
 106 /* var sessionName1        = "Texas Instruments XDS2xx USB Onboard Emulator_1/C66xx_0"; */
 107
 108 function MemRead(activeDS, addr, wordCnt)
 109 {
 110     var result;
 111     var successful = 0;
 112
 113    if (!activeDS.target.isHalted()){
 114         /* This command halts the target in order to allow memory reads */
 115        activeDS.target.halt();
 116    }
 117
 118     while (! successful) {
 119        try {
 120          result = activeDS.memory.readData(0, addr, 32, wordCnt);
 121          successful = 1;
 122        }
 123        catch(err)
 124        {
 125          print ("Memory read failed! Sleep and retry.\n");
 126          java.lang.Thread.sleep(1000);
 127        }
 128     }
 129
 130     activeDS.target.runAsynch();
 131     return result;
 132 }
 133
 134
 135 function MemWrite(activeDS, dst, src, wordCnt)
 136 {
 137     var successful = 0;
 138
 139     if (!activeDS.target.isHalted()){
 140         /* This command halts the target in order to allow memory writes */
 141         activeDS.target.halt();
 142     }
 143
 144     while (! successful) {
 145        try {
 146          activeDS.memory.writeData(0, dst, src, wordCnt);
 147          successful = 1;
 148        }
 149        catch(err)
 150        {
 151          print ("Memory write failed! Sleep and retry.n");
 152          java.lang.Thread.sleep(1000);
 153        }
 154     }
 155     activeDS.target.runAsynch();
 156 }
 157
 158
 159
 160 function Synchronized_BER_Test(script)
 161 {
 162     script.traceWrite("DSS: Serdes BER testing...");
 163
 164     /* Setup emulation session, load .out files and start execution of each DSP */
 165     script.traceWrite("DSS: Loading DSP program to 1st Keystone2 DSP core...");
 166     session0.memory.loadProgram(pathDSP0);
 167     script.traceWrite("DSS: Done!");
 168
 169     script.traceWrite("DSS: Loading DSP program to 2nd Keystone2 DSP core...");
 170     session1.memory.loadProgram(pathDSP1);
 171     script.traceWrite("DSS: Done!");
 172
 173
 174     var dss_test_complete_flag_addr     = session1.symbol.getAddress("serdes_diag_dss_test_complete_flag");
 175
 176     var dss_stall_key0_addr             = session0.symbol.getAddress("serdes_diag_dss_stall_key0");
 177     var dss_stall_key1_addr             = session1.symbol.getAddress("serdes_diag_dss_stall_key1");
 178     var dss_stall_key2_addr             = session1.symbol.getAddress("serdes_diag_dss_stall_key2");
 179
 180     var dss_stall_flag0_addr_device0        = session0.symbol.getAddress("serdes_diag_dss_stall_flag0");
 181     var dss_stall_flag0_addr_device1        = session1.symbol.getAddress("serdes_diag_dss_stall_flag0");
 182
 183     var dss_stall_flag1_addr            = session1.symbol.getAddress("serdes_diag_dss_stall_flag1");
 184     var dss_stall_flag2_addr            = session1.symbol.getAddress("serdes_diag_dss_stall_flag2");
 185
 186     var dss_device_num_0_addr           = session1.symbol.getAddress("diag_serdes_device_num");
 187     var dss_device_num_1_addr           = session1.symbol.getAddress("diag_serdes_device_num");
 188
 189     session0.memory.writeWord(0,dss_device_num_0_addr, 0);
 190     session1.memory.writeWord(0,dss_device_num_1_addr, 1);
 191
 192     session0.breakpoint.removeAll();
 193     script.traceWrite("DSS: Removed all breakpoints on 1st Keystone2 DSPs...");
 194
 195     session1.breakpoint.removeAll();
 196     script.traceWrite("DSS: Removed all breakpoints on 2nd Keystone2 DSPs...");
 197
 198     script.traceWrite("DSS: Executing program on 2nd Keystone2 DSPs...");
 199     session1.target.runAsynch();
 200
 201     script.traceWrite("DSS: Executing program on 1st Keystone2 DSPs...");
 202     session0.target.runAsynch();
 203
 204     script.traceWrite("DSS: Execution started...");
 205
 206     java.lang.Thread.sleep(1000);
 207
 208     /*
 209     Start polling for the dss_stall_flag_set from both devices
 210     Start polling for the dss_test_complete_flag_set from both devices
 211
 212     If test is complete, we are done with test loop
 213     If stall is detected on both devices, devices are synchronized and should be unlocked to run
 214
 215     */
 216
 217
 218     while( (dss_test_complete_flag_device0 != dss_test_complete_flag_set) && (dss_test_complete_flag_device1 != dss_test_complete_flag_set) ){
 219
 220         /* poll for the stall flag0 being set on both devices */
 221         dss_stall_flag0_device0 = session0.memory.readWord(0,dss_stall_flag0_addr_device0);
 222         dss_stall_flag0_device1 = session1.memory.readWord(0,dss_stall_flag0_addr_device1);
 223
 224         //script.traceWrite("dss_stall_flag_device0: " + dss_stall_flag_device0);
 225         //script.traceWrite("dss_stall_flag_device1: " + dss_stall_flag_device1);
 226
 227         if( (dss_stall_flag0_device0 == dss_stall_flag_set) && (dss_stall_flag0_device1 == dss_stall_flag_set) ){ /*stalled at flag0 */
 228             /* set the unlock key0 on both devices since they are both stalled waiting for the DSS to unlock */
 229             java.lang.Thread.sleep(1000);
 230
 231             server.simultaneous.halt(); /* Halt all CPUs */
 232
 233             session0.memory.writeWord(0,dss_stall_key0_addr, dss_unlock_key);
 234             session1.memory.writeWord(0,dss_stall_key0_addr, dss_unlock_key);
 235
 236             dss_stall_flag_device0  = dss_stall_flag_clear; /*clear flag for next iteration */
 237             dss_stall_flag_device1  = dss_stall_flag_clear; /*clear flag for next iteration */
 238
 239             server.simultaneous.runAsynch(); /* Run all CPUs */
 240         }
 241
 242         /* poll for the stall flag1 being set on both devices */
 243         dss_stall_flag1_device0 = session0.memory.readWord(0,dss_stall_flag1_addr);
 244         dss_stall_flag1_device1 = session1.memory.readWord(0,dss_stall_flag1_addr);
 245
 246         //script.traceWrite("dss_stall_flag_device0: " + dss_stall_flag_device0);
 247         //script.traceWrite("dss_stall_flag_device1: " + dss_stall_flag_device1);
 248
 249         if( (dss_stall_flag1_device0 == dss_stall_flag_set) && (dss_stall_flag1_device1 == dss_stall_flag_set) ){ /*stalled at flag1 */
 250             /* set the unlock key1 on both devices since they are both stalled waiting for the DSS to unlock */
 251             java.lang.Thread.sleep(1000);
 252
 253             server.simultaneous.halt(); /* Halt all CPUs */
 254
 255             session0.memory.writeWord(0,dss_stall_key1_addr, dss_unlock_key);
 256             session1.memory.writeWord(0,dss_stall_key1_addr, dss_unlock_key);
 257
 258             dss_stall_flag_device0  = dss_stall_flag_clear; /*clear flag for next iteration */
 259             dss_stall_flag_device1  = dss_stall_flag_clear; /*clear flag for next iteration */
 260
 261             server.simultaneous.runAsynch(); /* Run all CPUs */
 262         }
 263
 264
 265         /* poll for the stall flag2 being set on both devices */
 266         dss_stall_flag2_device0 = session0.memory.readWord(0,dss_stall_flag2_addr);
 267         dss_stall_flag2_device1 = session1.memory.readWord(0,dss_stall_flag2_addr);
 268         //script.traceWrite("dss_stall_flag_device0: " + dss_stall_flag_device0);
 269         //script.traceWrite("dss_stall_flag_device1: " + dss_stall_flag_device1);
 270         if( (dss_stall_flag2_device0 == dss_stall_flag_set) && (dss_stall_flag2_device1 == dss_stall_flag_set) ){ //stalled at flag2
 271         /* set the unlock key2 on both devices since they are both stalled waiting for the DSS to unlock */
 272             java.lang.Thread.sleep(1000);
 273
 274             server.simultaneous.halt(); /* Halt all CPUs */
 275
 276             session0.memory.writeWord(0,dss_stall_key2_addr, dss_unlock_key);
 277             session1.memory.writeWord(0,dss_stall_key2_addr, dss_unlock_key);
 278
 279             dss_stall_flag_device0  = dss_stall_flag_clear; //clear flag for next iteration
 280             dss_stall_flag_device1  = dss_stall_flag_clear; //clear flag for next iteration
 281
 282             server.simultaneous.runAsynch(); /* Run all CPUs */
 283         }
 284
 285         /* poll for the test complete flag being set on both devices */
 286         dss_test_complete_flag_device0 = session0.memory.readWord(0,dss_test_complete_flag_addr);
 287         dss_test_complete_flag_device1 = session1.memory.readWord(0,dss_test_complete_flag_addr);
 288
 289         script.traceWrite("dss_test_complete_flag_device0: 0x" + dss_test_complete_flag_device0.toString(16).toUpperCase());
 290         script.traceWrite("dss_test_complete_flag_device1: 0x" + dss_test_complete_flag_device1.toString(16).toUpperCase());
 291
 292         java.lang.Thread.sleep(1000);
 293     }
 294 }
 295
 296 var script  = ScriptingEnvironment.instance();
 297 script.traceBegin(pathLog, pathXSL);
 298 script.traceWrite("Serdes Diag Test Started");
 299
 300 var server = script.getServer("DebugServer.1")
 301 server.setConfig(pathCCXML);
 302 script.traceWrite("DebugServer configured");
 303
 304 script.traceWrite("Opening debug sessions for DSP cores...");
 305 var session0 = server.openSession(sessionName0);
 306 var session1 = server.openSession(sessionName1);
 307 script.traceWrite("DebugSession opened");
 308
 309 script.traceWrite("Connecting to DSP cores...");
 310 session0.target.connect();
 311 session1.target.connect();
 312 script.traceWrite("Target connected!");
 313
 314 script.traceWrite("Resetting target DSP cores!");
 315 session0.target.reset();
 316 session1.target.reset();
 317
 318 java.lang.Thread.sleep(2000);
 319
 320 /* As shown below, the PLL can be programmed to run at higher speeds by enabling the corresponding EVM GEL files */
 321 session0.expression.evaluate("GEL_LoadGel(\"C:/ti/ccsv7/ccs_base/emulation/boards/evmk2e/gel/evmk2e.gel\")");
 322 session1.expression.evaluate("GEL_LoadGel(\"C:/ti/ccsv7/ccs_base/emulation/boards/evmk2e/gel/evmk2e.gel\")");
 323
 324 //script.traceWrite("Executing GEL functions...");
 325 session0.expression.evaluate("CORE_PLL_INIT_100MHZ_to_1GHz()");
 326 session1.expression.evaluate("CORE_PLL_INIT_100MHZ_to_1GHz()");
 327
 328
 329 Synchronized_BER_Test(script);
 330
 331 script.traceWrite("Serdes Diag Test Complete");
 332 script.traceEnd();
 333 quit();