schanfifo_test.c (43267B)
1 /* 2 * 3 * This license is set out in https://raw.githubusercontent.com/Broadcom-Network-Switching-Software/OpenBCM/master/Legal/LICENSE file. 4 * 5 * Copyright 2007-2019 Broadcom Inc. All rights reserved. 6 * 7 * SCHAN FIFO tests 8 * 9 * Test Limitations 10 * MemTableID: 0->L3_DEFIP (default), 1->L3_DEFIP_ALPM_RAW, 2->L3_TUNNEL. 11 * NumRead: Number of read operations (200 by default). 12 * NumWrite: Number of write operations (200 by default). 13 * NumRun: Number of total run times of the test (1 by default) 14 */ 15 16 #include <shared/bsl.h> 17 18 #include <sal/core/libc.h> 19 #include <stdarg.h> 20 21 #include <sal/types.h> 22 #include <soc/mem.h> 23 #include <soc/register.h> 24 #include <soc/cm.h> 25 26 #include <sal/appl/pci.h> 27 #include <sal/appl/sal.h> 28 #include <sal/core/boot.h> 29 #include <sal/core/time.h> 30 31 #include <soc/l2x.h> 32 #include <soc/l3x.h> 33 #include <soc/phyctrl.h> 34 #include <soc/phy.h> 35 #include <soc/error.h> 36 #include <soc/cmicx.h> 37 #include <soc/soc_schan_fifo.h> 38 39 #include <bcm/error.h> 40 #include <bcm/link.h> 41 42 #include <bcm_int/esw/mbcm.h> 43 44 #include <appl/diag/system.h> 45 #include <appl/diag/parse.h> 46 #include <appl/diag/test.h> 47 #include <appl/diag/progress.h> 48 49 #include "testlist.h" 50 51 #define SCHANFIFO_SOC_CMD_BUFF_DEPTH 352 52 53 #define MAX_NUM_OF_ASYNC_TRANSACTIONS 20 54 55 #define ASYNC_EN_PARAM_DEFAULT 0 56 #define MEM_TABLE_ID_PARAM_DEFAULT 0 57 #define NUM_READ_PARAM_DEFAULT 300 58 #define NUM_WRITE_PARAM_DEFAULT 300 59 #define NUM_RUN_PARAM_DEFAULT 1 60 61 /* Decimal point formatting */ 62 #define INT_FRAC_2PT(x) (x) / 100, (x) % 100 63 64 typedef struct benchmark_s { 65 uint32 param_testMask; 66 uint32 param_asyncEn; 67 uint32 param_memTableID; 68 uint32 param_numRead; 69 uint32 param_numWrite; 70 uint32 param_numRun; 71 uint32 param_debug; 72 int test_fail; 73 soc_reg_t test_reg; 74 soc_mem_t test_mem; 75 int testNum; 76 int sizeMem; 77 char *bufMem; 78 int sizeDMA; 79 char *bufDMA; 80 char *testName; 81 sal_usecs_t stime, etime; 82 sal_usecs_t time_drv; 83 uint32 dataSize; 84 uint32 dataWidth; 85 char *dataUnit; 86 uint32 *schanfifoCmdBuff; 87 schan_fifo_cmd_t *schanfifoCmd; 88 schan_fifo_resp_t schanfifoResp; 89 soc_schan_fifo_msg_t schanfifoMsg; 90 uint32 async_en; 91 volatile uint32 async_msg_send_cnt; 92 volatile uint32 async_msg_done_cnt; 93 volatile sal_usecs_t async_stime[MAX_NUM_OF_ASYNC_TRANSACTIONS]; 94 volatile sal_usecs_t async_etime[MAX_NUM_OF_ASYNC_TRANSACTIONS]; 95 } benchmark_t; 96 97 #define BENCH_BUFMEM_SIZE 0x100000 98 #define BENCH_BUFDMA_SIZE 0x200000 99 100 void 101 schanfifo_async_wait_for_done(int unit, benchmark_t *b) 102 { 103 int timeout = 5000; 104 while (timeout-- && b->async_msg_send_cnt > b->async_msg_done_cnt) { 105 sal_usleep(1000); 106 } 107 LOG_INFO(BSL_LS_APPL_TESTS, (BSL_META_U(unit, 108 "[async_wait] async_msg_send_cnt %0d " 109 "async_msg_done_cnt %0d (timeout %0d)\n"), 110 b->async_msg_send_cnt, b->async_msg_done_cnt, timeout)); 111 } 112 113 int 114 schanfifo_test_cleanup(int unit, void *pa) 115 { 116 int rv = BCM_E_NONE; 117 benchmark_t *b = (benchmark_t *) pa; 118 119 if (b) { 120 if (b->bufMem) 121 sal_free(b->bufMem); 122 if (b->bufDMA) 123 soc_cm_sfree(unit, b->bufDMA); 124 if (b->schanfifoCmdBuff) { 125 sal_dma_free(b->schanfifoCmdBuff); 126 } 127 128 sal_free(b); 129 } 130 131 return rv; 132 } 133 134 int 135 schanfifo_test_init(int unit, args_t *a, void **pa) 136 { 137 benchmark_t *b = 0; 138 int rv = BCM_E_NONE; 139 parse_table_t pt; 140 int i; 141 142 const char schanfifo_test_usage[] = 143 "Configuration parameters passed from CLI:\n" 144 #ifdef BCM_SOC_ASYNC_SUPPORT 145 "AsyncEn : 0->Synchronous (default), 1->Asynchronous \n" 146 #endif 147 "MemTableID: Memory table selectin\n" 148 " 0->L3_DEFIPm.\n" 149 " 1->L3_DEFIP_ALPM_RAWm.\n" 150 " 2->L3_TUNNELm.\n" 151 " 3->L3_DEFIP_ALPM_IPV6_128m.\n" 152 " 4->L3_DEFIP_ALPM_IPV4m.\n" 153 "NumRead : Number of read operations (200 by default).\n" 154 "NumWrite : Number of write operations (200 by default).\n" 155 "NumRun : Number of total run times of the test(1 by default).\n"; 156 157 *pa = NULL; 158 159 /* benchmark_t */ 160 if ((b = sal_alloc(sizeof(benchmark_t), "benchmark")) == 0) { 161 cli_out("Failed to allocate mem for benchmark\n"); 162 rv = BCM_E_FAIL; 163 goto done; 164 } 165 memset(b, 0, sizeof(*b)); 166 *pa = (void *) b; 167 b->test_fail = 0; 168 b->testNum = 0; 169 b->sizeMem = BENCH_BUFMEM_SIZE; 170 b->sizeDMA = BENCH_BUFDMA_SIZE; 171 b->async_msg_send_cnt = 0; 172 b->async_msg_done_cnt = 0; 173 b->async_en = 0; 174 for (i = 0; i < MAX_NUM_OF_ASYNC_TRANSACTIONS; i++) { 175 b->async_stime[i] = 0; 176 b->async_etime[i] = 0; 177 } 178 179 if ((b->bufMem = sal_alloc(b->sizeMem, "bufMem")) == 0) { 180 cli_out("Failed to allocate mem for bufMem\n"); 181 rv = BCM_E_FAIL; 182 goto done; 183 } 184 185 if ((b->bufDMA = soc_cm_salloc(unit, b->sizeDMA, "bufDMA")) == 0) { 186 cli_out("Failed to allocate mem for bufDMA\n"); 187 rv = BCM_E_FAIL; 188 goto done; 189 } 190 /* schan_fifo_cmd_t */ 191 b->schanfifoCmdBuff = sal_dma_alloc(SCHANFIFO_SOC_CMD_BUFF_DEPTH * 192 sizeof(uint32), "schanfifoCmdBuff"); 193 if (b->schanfifoCmdBuff == 0) { 194 cli_out("Failed to allocate mem for schanfifoCmdBuff\n"); 195 rv = BCM_E_FAIL; 196 goto done; 197 } 198 b->schanfifoCmd = (schan_fifo_cmd_t *) b->schanfifoCmdBuff; 199 200 /* soc_schan_fifo_msg_t */ 201 b->schanfifoMsg.num = 0; 202 b->schanfifoMsg.interval = -1; 203 b->schanfifoMsg.size = 0; 204 b->schanfifoMsg.cmd = b->schanfifoCmd; 205 206 /* CLI parameters */ 207 b->param_testMask = ~0; 208 b->param_asyncEn = ASYNC_EN_PARAM_DEFAULT; 209 b->param_memTableID = MEM_TABLE_ID_PARAM_DEFAULT; 210 b->param_numRead = NUM_READ_PARAM_DEFAULT; 211 b->param_numWrite = NUM_WRITE_PARAM_DEFAULT; 212 b->param_numRun = NUM_RUN_PARAM_DEFAULT; 213 b->param_debug = 0; 214 215 parse_table_init(unit, &pt); 216 parse_table_add(&pt, "TestMask", PQ_HEX|PQ_DFL, 0, 217 &b->param_testMask, NULL); 218 #ifdef BCM_SOC_ASYNC_SUPPORT 219 parse_table_add(&pt, "AsyncEn", PQ_BOOL|PQ_DFL, 0, 220 &b->param_asyncEn, NULL); 221 #endif 222 parse_table_add(&pt, "MemTableID", PQ_HEX|PQ_DFL, 0, 223 &b->param_memTableID, NULL); 224 parse_table_add(&pt, "NumRead", PQ_HEX|PQ_DFL, 0, 225 &b->param_numRead, NULL); 226 parse_table_add(&pt, "NumWrite", PQ_HEX|PQ_DFL, 0, 227 &b->param_numWrite, NULL); 228 parse_table_add(&pt, "NumRun", PQ_HEX|PQ_DFL, 0, 229 &b->param_numRun, NULL); 230 parse_table_add(&pt, "Debug", PQ_INT|PQ_DFL, 0, 231 &b->param_debug, NULL); 232 233 if (parse_arg_eq(a, &pt) < 0 || ARG_CNT(a) != 0) { 234 test_msg("%s", schanfifo_test_usage); 235 test_error(unit, 236 "%s: Invalid option: %s\n", 237 ARG_CMD(a), 238 ARG_CUR(a) ? ARG_CUR(a) : "*"); 239 parse_arg_eq_done(&pt); 240 rv = BCM_E_FAIL; 241 goto done; 242 } else { 243 cli_out("\n ------------- PRINTING TEST PARAMS ------------------"); 244 cli_out("\nparam_testMask = %0d", b->param_testMask); 245 cli_out("\nparam_asyncEn = %0d", b->param_asyncEn); 246 cli_out("\nparam_memTableID = %0d", b->param_memTableID); 247 cli_out("\nparam_numRead = %0d", b->param_numRead); 248 cli_out("\nparam_numWrite = %0d", b->param_numWrite); 249 cli_out("\nparam_numRun = %0d", b->param_numRun); 250 cli_out("\nparam_debug = %0d", b->param_debug); 251 cli_out("\n -----------------------------------------------------\n"); 252 #if defined(BCM_TRIDENT3_SUPPORT) || defined(BCM_TOMAHAWK3_SUPPORT) 253 /* reg */ 254 b->test_reg = ECMP_CONFIGr; /* EGR_CONFIGr; */ 255 if(!SOC_REG_IS_VALID(unit, b->test_reg)) { 256 cli_out("Invalid reg %s\n", SOC_REG_NAME(unit, b->test_reg)); 257 rv = BCM_E_FAIL; 258 } else { 259 cli_out("\nName of test reg: %s\n", SOC_REG_NAME(unit, 260 b->test_reg)); 261 } 262 /* mem */ 263 #ifdef BCM_TOMAHAWK3_SUPPORT 264 if (SOC_IS_TOMAHAWK3(unit)) { 265 switch (b->param_memTableID) { 266 case 0: b->test_mem = L3_DEFIP_ALPM_LEVEL3m; break; 267 case 1: b->test_mem = L3_DEFIP_ALPM_LEVEL2m; break; 268 case 2: b->test_mem = L3_DEFIP_LEVEL1m; break; 269 case 3: b->test_mem = L3_DEFIP_PAIR_LEVEL1m; break; 270 case 4: b->test_mem = L3_DEFIP_ALPM_LEVEL3_HIT_ONLYm; break; 271 case 5: b->test_mem = L3_DEFIP_ALPM_LEVEL2_HIT_ONLYm; break; 272 case 6: b->test_mem = L3_DEFIP_ALPM_LEVEL3m; break; 273 default:b->test_mem = L3_DEFIP_ALPM_LEVEL3m; break; 274 } 275 } else 276 #endif 277 switch (b->param_memTableID) { 278 case 0: b->test_mem = L3_DEFIPm; break; 279 case 1: b->test_mem = L3_DEFIP_ALPM_RAWm; break; 280 case 2: b->test_mem = L3_TUNNELm; break; 281 case 3: b->test_mem = L3_DEFIP_ALPM_IPV6_128m; break; 282 case 4: b->test_mem = L3_DEFIP_ALPM_IPV4m; break; 283 case 5: b->test_mem = L2_ENTRY_ECCm; break; 284 case 6: b->test_mem = INITIAL_ING_L3_NEXT_HOPm;break; 285 default:b->test_mem = L3_DEFIPm; break; 286 } 287 if(!SOC_MEM_IS_VALID(unit, b->test_mem)) { 288 cli_out("Invalid mem %s\n", SOC_MEM_NAME(unit, b->test_mem)); 289 rv = BCM_E_FAIL; 290 } else if (!SOC_MEM_IS_ENABLED(unit, b->test_mem)) { 291 cli_out("Cannot test mem %s: No entries.\n", 292 SOC_MEM_NAME(unit, b->test_mem)); 293 rv = BCM_E_FAIL; 294 } else { 295 cli_out("\nName of test mem: %s\n", 296 SOC_MEM_NAME(unit, b->test_mem)); 297 } 298 #endif 299 /* numRun */ 300 if (b->param_numRun < 1) { 301 b->param_numRun = 1; 302 } 303 304 parse_arg_eq_done(&pt); 305 } 306 307 done: 308 if (BCM_FAILURE(rv)) { 309 /* benchmark_done(unit, *pa); */ 310 if (b) { 311 b->test_fail = 1; 312 } 313 } 314 315 return rv; 316 } 317 318 static int 319 benchmark_begin(int unit, 320 benchmark_t *b, 321 char *testName, 322 char *dataUnit, 323 uint32 dataSize, 324 uint32 dataWidth) 325 { 326 assert(b->testName == 0); 327 328 if ((b->param_testMask & (1U << b->testNum)) == 0) { 329 return 0; 330 } 331 332 b->testName = testName; 333 b->dataUnit = dataUnit; 334 b->dataWidth = dataWidth; 335 b->dataSize = dataSize; 336 b->stime = sal_time_usecs(); 337 b->time_drv = 0; 338 b->async_msg_send_cnt = 0; 339 b->async_msg_done_cnt = 0; 340 341 return 1; 342 } 343 344 static void 345 benchmark_end(int unit, benchmark_t *b) 346 { 347 if (b->testName) { 348 uint32 per_sec, usec_per, kb_per_sec; 349 sal_usecs_t td = 0; 350 char plus = ' ', lessthan = ' '; 351 int i; 352 sal_usecs_t async_stime, async_etime; 353 uint32 async_cnt = 0; 354 355 if (b->async_en == 1) { 356 /* wait for async callback done */ 357 schanfifo_async_wait_for_done(unit, b); 358 LOG_INFO(BSL_LS_APPL_TESTS, (BSL_META_U(unit, 359 "[benchmark_end] async_msg_send_cnt %0d\n"), 360 b->async_msg_send_cnt)); 361 LOG_INFO(BSL_LS_APPL_TESTS, (BSL_META_U(unit, 362 "[benchmark_end] async_msg_done_cnt %0d\n"), 363 b->async_msg_done_cnt)); 364 /* print verbose info of api time cost */ 365 for (i = 0; i < MAX_NUM_OF_ASYNC_TRANSACTIONS; i++) { 366 if (b->async_stime[i] > 0 && b->async_etime[i] > 0) { 367 td = SAL_USECS_SUB(b->async_etime[i], b->async_stime[i]); 368 LOG_INFO(BSL_LS_APPL_TESTS, (BSL_META_U(unit, 369 "[benchmark_end] msg %2d, stime %0d, " 370 "etime %0d, driver_time %8d\n"), 371 i, (int) b->async_stime[i], 372 (int) b->async_etime[i], (int)td)); 373 } 374 } 375 376 /* recalculate driver time */ 377 async_cnt = (b->async_msg_done_cnt > 0) ? (b->async_msg_done_cnt) : 1; 378 async_stime = b->async_stime[0]; 379 async_etime = b->async_etime[async_cnt - 1]; 380 td = SAL_USECS_SUB(async_etime, async_stime); 381 b->time_drv = td; 382 LOG_INFO(BSL_LS_APPL_TESTS, (BSL_META_U(unit, 383 "[benchmark_end] stime[%d] %0d, etime[%d] %0d, " 384 "driver_time %8d, data Size = %u\n"), 385 0, (int)async_stime, 386 async_cnt-1, async_etime, (int)td, b->dataSize * b->dataWidth)); 387 388 td = b->time_drv; 389 } else { 390 b->etime = sal_time_usecs(); 391 td = SAL_USECS_SUB(b->etime, b->stime); 392 LOG_INFO(BSL_LS_APPL_TESTS, (BSL_META_U(unit, 393 "[benchmark_end] stime-%d, etime-%d," 394 "driver_time %8d, data Size = %u\n"), 395 (int)b->stime, b->etime, (int)td, b->dataSize * b->dataWidth)); 396 } 397 398 if (td == 0) { 399 td = 1; /* Non-zero value */ 400 plus = '+'; 401 lessthan = '<'; 402 } 403 LOG_INFO(BSL_LS_APPL_TESTS, 404 (BSL_META_U(unit, "driver_time_ratio %d%s\n"), 405 (int) (b->time_drv*100/td), "%")); 406 per_sec = _shr_div_exp10(b->dataSize, td, 8); 407 usec_per = b->dataSize ? _shr_div_exp10(td, b->dataSize, 2) : 0; 408 kb_per_sec = _shr_div_exp10(b->dataSize * b->dataWidth, td, 8); 409 410 cli_out("%2d) %-28s%7d.%02d%c %5s/sec ; %c%7d.%02d usec/%-5s ; %7d.%02d byte/sec\n", 411 b->testNum, 412 b->testName, 413 INT_FRAC_2PT(per_sec), 414 plus, 415 b->dataUnit, 416 lessthan, 417 INT_FRAC_2PT(usec_per), 418 b->dataUnit, 419 INT_FRAC_2PT(kb_per_sec)); 420 421 b->testName = 0; 422 } 423 424 b->testNum++; 425 } 426 427 int 428 schan_fifo_flush(int unit, benchmark_t *b) 429 { 430 int rv = BCM_E_NONE; 431 sal_usecs_t stime, etime; 432 433 if (b->schanfifoMsg.num > 0) { 434 LOG_INFO(BSL_LS_APPL_TESTS, 435 (BSL_META_U(unit, 436 "schan_fifo_flush: Calling " 437 "soc_schan_fifo_msg_send with %0d commands\n\n"), 438 b->schanfifoMsg.num)); 439 stime = sal_time_usecs(); 440 rv = soc_schan_fifo_msg_send(unit, &b->schanfifoMsg, NULL, NULL); 441 etime = sal_time_usecs(); 442 b->time_drv = SAL_USECS_ADD(b->time_drv, SAL_USECS_SUB(etime, stime)); 443 if (BCM_FAILURE(rv)) { 444 sal_printf("soc_schan_fifo_msg_send: %s\n", bcm_errmsg(rv)); 445 } 446 b->schanfifoMsg.num = 0; 447 b->schanfifoMsg.size = 0; 448 } 449 450 return rv; 451 } 452 453 int 454 schan_fifo_reg32_get(int unit, soc_reg_t reg, int port, int index, uint32 *data, benchmark_t *b) 455 { 456 int rv = BCM_E_NONE; 457 #if defined(BCM_TRIDENT3_SUPPORT) || defined(BCM_TOMAHAWK3_SUPPORT) 458 schan_fifo_cmd_t *schan_fifo_cmd; 459 uint32 addr; 460 int block = 0; 461 int numword = 2; 462 uint8 acc_type; 463 int data_byte_len = 4; 464 465 if (b->schanfifoMsg.size + numword < SCHANFIFO_SOC_CMD_BUFF_DEPTH) { 466 schan_fifo_cmd = (schan_fifo_cmd_t *) &b->schanfifoCmdBuff[b->schanfifoMsg.num * numword]; 467 addr = soc_reg_addr_get(unit, reg, port, index, 468 SOC_REG_ADDR_OPTION_NONE, &block, &acc_type); 469 soc_schan_header_cmd_set(unit, &schan_fifo_cmd->header, READ_REGISTER_CMD_MSG, 470 block, 0, acc_type, data_byte_len, 0, 0); 471 schan_fifo_cmd->address = addr; 472 b->schanfifoMsg.num++; 473 b->schanfifoMsg.size += numword; 474 475 LOG_INFO(BSL_LS_APPL_TESTS, 476 (BSL_META_U(unit, "add cmd fifo_reg32_get, msg_num %d, " 477 "msg_size %d, num_words %d, " 478 "cmdBuff_size %d\n"), 479 b->schanfifoMsg.num, (int) b->schanfifoMsg.size, 480 numword, b->schanfifoMsg.num * numword)); 481 } else { 482 rv = schan_fifo_flush(unit, b); 483 } 484 #else 485 rv = soc_reg32_get(unit, reg, port, index, data); 486 #endif /* BCM_TRIDENT3_SUPPORT || BCM_TOMAHAWK3_SUPPORT */ 487 return rv; 488 } 489 490 int 491 schan_fifo_reg32_set(int unit, soc_reg_t reg, int port, int index, uint32 data, benchmark_t *b) 492 { 493 int rv = BCM_E_NONE; 494 #if defined(BCM_TRIDENT3_SUPPORT) || defined(BCM_TOMAHAWK3_SUPPORT) 495 schan_fifo_cmd_t *schan_fifo_cmd; 496 uint32 addr; 497 int block = 0; 498 int numword = 3; 499 uint8 acc_type; 500 int data_byte_len = 4; /* sizeof(uint32) */ 501 502 if (b->schanfifoMsg.size + numword < SCHANFIFO_SOC_CMD_BUFF_DEPTH) { 503 schan_fifo_cmd = (schan_fifo_cmd_t *) &b->schanfifoCmdBuff[b->schanfifoMsg.num * numword]; 504 addr = soc_reg_addr_get(unit, reg, port, index, 505 SOC_REG_ADDR_OPTION_WRITE, &block, &acc_type); 506 soc_schan_header_cmd_set(unit, &schan_fifo_cmd->header, WRITE_REGISTER_CMD_MSG, 507 block, 0, acc_type, data_byte_len, 0, 0); 508 schan_fifo_cmd->address = addr; 509 schan_fifo_cmd->data[0] = data; 510 b->schanfifoMsg.num++; 511 b->schanfifoMsg.size += numword; 512 513 LOG_INFO(BSL_LS_APPL_TESTS, 514 (BSL_META_U(unit, "add cmd fifo_reg32_set, msg_num %d, " 515 "msg_size %d, num_words %d, " 516 "cmdBuff_size %d\n"), 517 b->schanfifoMsg.num, (int) b->schanfifoMsg.size, 518 numword, b->schanfifoMsg.num * numword)); 519 } else { 520 rv = schan_fifo_flush(unit, b); 521 } 522 #else 523 rv = soc_reg32_set(unit, reg, port, index, data); 524 #endif /* BCM_TRIDENT3_SUPPORT || BCM_TOMAHAWK3_SUPPORT */ 525 return rv; 526 } 527 528 int 529 schan_fifo_mem_read(int unit, soc_mem_t mem, int copyno, int index, void *entry_data, benchmark_t *b) 530 { 531 int rv = BCM_E_NONE; 532 #if defined(BCM_TRIDENT3_SUPPORT) || defined(BCM_TOMAHAWK3_SUPPORT) 533 schan_fifo_cmd_t *schan_fifo_cmd; 534 int numword = 2; 535 int dst_blk, src_blk, acc_type; 536 uint32 addr; 537 uint8 at; 538 539 if (b->schanfifoMsg.size + numword < SCHANFIFO_SOC_CMD_BUFF_DEPTH) { 540 schan_fifo_cmd = (schan_fifo_cmd_t *) &b->schanfifoCmdBuff[b->schanfifoMsg.num * numword]; 541 addr = soc_mem_addr_get(unit, mem, 0, copyno, index, &at); 542 dst_blk = SOC_BLOCK2SCH(unit, copyno); 543 src_blk = SOC_BLOCK2SCH(unit, CMIC_BLOCK(unit)); 544 acc_type = SOC_MEM_ACC_TYPE(unit, mem); 545 soc_schan_header_cmd_set(unit, &schan_fifo_cmd->header, READ_MEMORY_CMD_MSG, 546 dst_blk, src_blk, acc_type, 4, 0, 0); 547 schan_fifo_cmd->address = addr; 548 b->schanfifoMsg.num++; 549 b->schanfifoMsg.size += numword; 550 551 LOG_INFO(BSL_LS_APPL_TESTS, 552 (BSL_META_U(unit, "add cmd fifo_mem_read, msg_num %d, " 553 "msg_size %d, num_words %d, " 554 "cmdBuff_size %d\n"), 555 b->schanfifoMsg.num, (int) b->schanfifoMsg.size, 556 numword, b->schanfifoMsg.num * numword)); 557 } else { 558 rv = schan_fifo_flush(unit, b); 559 } 560 #else 561 rv = soc_mem_read(unit, mem, copyno, index, entry_data); 562 #endif /* BCM_TRIDENT3_SUPPORT || BCM_TOMAHAWK3_SUPPORT */ 563 return rv; 564 } 565 566 int 567 schan_fifo_mem_write(int unit, soc_mem_t mem, int copyno, int index, void *entry_data, benchmark_t *b) 568 { 569 int rv = BCM_E_NONE; 570 #if defined(BCM_TRIDENT3_SUPPORT) || defined(BCM_TOMAHAWK3_SUPPORT) 571 schan_msg_t schan_msg; 572 int dst_blk, src_blk, acc_type; 573 int cmd_dw = 2; 574 int entry_dw; 575 int data_byte_len; 576 uint32 maddr; 577 uint8 at; 578 579 entry_dw = soc_mem_entry_words(unit, mem); 580 data_byte_len = entry_dw * sizeof (uint32); 581 582 if (b->schanfifoMsg.size + cmd_dw + entry_dw < SCHANFIFO_SOC_CMD_BUFF_DEPTH) { 583 schan_msg_clear(&schan_msg); 584 maddr = soc_mem_addr_get(unit, mem, 0, copyno, index, &at); 585 schan_msg.readcmd.address = maddr; 586 dst_blk = SOC_BLOCK2SCH(unit, copyno); 587 src_blk = SOC_BLOCK2SCH(unit, CMIC_BLOCK(unit)); 588 acc_type = SOC_MEM_ACC_TYPE(unit, mem); 589 soc_schan_header_cmd_set(unit, &schan_msg.header, WRITE_MEMORY_CMD_MSG, 590 dst_blk, src_blk, acc_type, data_byte_len, 0, 0); 591 592 sal_memcpy(&b->schanfifoCmdBuff[b->schanfifoMsg.num * (cmd_dw + entry_dw)], 593 &schan_msg, sizeof(uint32) * cmd_dw); 594 sal_memcpy(schan_msg.writecmd.data, entry_data, entry_dw * sizeof(uint32)); 595 b->schanfifoMsg.num++; 596 b->schanfifoMsg.size += cmd_dw + entry_dw; 597 598 LOG_INFO(BSL_LS_APPL_TESTS, 599 (BSL_META_U(unit, "add cmd fifo_mem_write, msg_num %d, " 600 "msg_size %d, num_words %d, " 601 "cmdBuff_size %d\n"), 602 b->schanfifoMsg.num, (int) b->schanfifoMsg.size, 603 cmd_dw + entry_dw, b->schanfifoMsg.num * (cmd_dw + entry_dw))); 604 } else { 605 rv = schan_fifo_flush(unit, b); 606 } 607 608 #else 609 rv = soc_mem_write(unit, mem, copyno, index, entry_data); 610 #endif /* BCM_TRIDENT3_SUPPORT || BCM_TOMAHAWK3_SUPPORT */ 611 612 return rv; 613 } 614 615 static void 616 schanfifo_async_cb(int unit, void *data, void *cookie, int status) 617 { 618 soc_schan_fifo_msg_t *msg = (soc_schan_fifo_msg_t *) data; 619 benchmark_t *b = (benchmark_t*) cookie; 620 int done_cnt = 0; 621 622 if (b != NULL) { 623 done_cnt = b->async_msg_done_cnt; 624 if (done_cnt < MAX_NUM_OF_ASYNC_TRANSACTIONS) { 625 b->async_etime[done_cnt] = sal_time_usecs(); 626 } 627 628 b->async_msg_done_cnt++; 629 LOG_INFO(BSL_LS_APPL_TESTS, (BSL_META_U(unit, 630 "[callback] async_msg_done_cnt %0d\n"), 631 b->async_msg_done_cnt)); 632 } 633 634 if (SOC_SUCCESS(status)) { 635 LOG_INFO(BSL_LS_APPL_TESTS, (BSL_META_U(unit, 636 "SUCCESS: %s:unit= %d, msg_num= %d\n "), 637 __func__, unit, msg->num)); 638 } else { 639 LOG_ERROR(BSL_LS_APPL_TESTS, (BSL_META_U(unit, 640 "FAILURE: %s:unit= %d, msg_num= %d\n"), 641 __func__, unit, msg->num)); 642 } 643 644 (void) soc_schan_fifo_control(unit, CTL_FIFO_RESP_FREE, msg->resp); 645 sal_dma_free(msg->cmd); 646 sal_free(msg); 647 } 648 649 int 650 schanfifo_reg_send(int unit, soc_reg_t reg, int op_code, uint32 op_num, 651 int port, int async_en, benchmark_t *b) 652 { 653 int rv = BCM_E_NONE; 654 uint32 cmd_num_limit = 176; /* CMIC_SCHAN_FIFO_CMD_SIZE_MAX; */ 655 uint32 cmd_num_max; 656 char *str_op; 657 int block = 0; 658 int index = 0; 659 uint8 acc_type; 660 int entry_dw = 0; 661 int cmd_dw = 2; 662 int dw_per_msg; 663 int data_bytes = 4; 664 uint32 addr; 665 uint32 data = 0x123; 666 int try; 667 uint32 *cmdBuff = NULL; 668 soc_schan_fifo_msg_t *msg; 669 schan_fifo_alloc_t resp_alloc; 670 schan_fifo_cmd_t *cmd_ptr; 671 sal_usecs_t stime, etime; 672 int send_cnt; 673 674 /* op code */ 675 op_code = (op_code == WRITE_REGISTER_CMD_MSG) ? op_code : 676 READ_REGISTER_CMD_MSG; 677 if (op_code == READ_REGISTER_CMD_MSG) { 678 str_op = (async_en == 0) ? "SYNC_READ" : "ASYNC_READ"; 679 } else { 680 str_op = (async_en == 0) ? "SYNC_WRITE" : "ASYNC_WRITE"; 681 } 682 683 cmd_num_max = (op_num < cmd_num_limit) ? op_num : cmd_num_limit; 684 685 /* malloc: cmd buff */ 686 cmdBuff = sal_dma_alloc(sizeof(uint32) * SCHANFIFO_SOC_CMD_BUFF_DEPTH, 687 "SCHANFIFO CMD BUFF"); 688 if (cmdBuff == NULL) { 689 return SOC_E_MEMORY; 690 } 691 692 /* malloc: msg */ 693 msg = sal_alloc(sizeof(soc_schan_fifo_msg_t), "SCHANFIFO MSG"); 694 if (msg == NULL) { 695 /* cmdBuff */ 696 sal_dma_free(cmdBuff); 697 return SOC_E_MEMORY; 698 } 699 msg->num = 0; 700 msg->interval = -1; 701 msg->size = 0; 702 msg->cmd = (schan_fifo_cmd_t *) cmdBuff; 703 msg->resp = NULL; 704 705 /* malloc: resp */ 706 if (op_code == READ_REGISTER_CMD_MSG) { 707 resp_alloc.num = cmd_num_max; 708 rv = soc_schan_fifo_control(unit, CTL_FIFO_RESP_ALLOC, &resp_alloc); 709 if (rv != SOC_E_NONE) { 710 return rv; 711 } 712 msg->resp = resp_alloc.resp; 713 } 714 715 /* get reg info */ 716 addr = soc_reg_addr_get(unit, reg, port, index, 717 SOC_REG_ADDR_OPTION_NONE, &block, &acc_type); 718 719 if (op_code == WRITE_REGISTER_CMD_MSG) { 720 entry_dw = 1; 721 } 722 dw_per_msg = cmd_dw + entry_dw; 723 724 /* fill cmd buff */ 725 while ((msg->num < cmd_num_max) && 726 (msg->size + dw_per_msg) <= SCHANFIFO_SOC_CMD_BUFF_DEPTH) { 727 cmd_ptr = (schan_fifo_cmd_t *) &cmdBuff[msg->size]; 728 soc_schan_header_cmd_set(unit, &cmd_ptr->header, op_code, 729 block, 0, acc_type, data_bytes, 0, 0); 730 cmd_ptr->address = addr; 731 cmd_ptr->data[0] = data; 732 msg->num++; 733 msg->size += dw_per_msg; 734 LOG_INFO(BSL_LS_APPL_TESTS, (BSL_META_U(unit, 735 "add schanfifo cmd, msg_num %0d, " 736 "msg_size %0d, num_words %0d\n"), 737 msg->num, (int) msg->size, dw_per_msg)); 738 } 739 740 /* kick off msg */ 741 stime = sal_time_usecs(); 742 if (async_en) { 743 send_cnt = b->async_msg_send_cnt; 744 if (send_cnt < MAX_NUM_OF_ASYNC_TRANSACTIONS) { 745 b->async_stime[send_cnt] = stime; 746 } 747 } 748 if (async_en == 0) { /* sync mode */ 749 rv = soc_schan_fifo_msg_send(unit, msg, NULL, NULL); 750 } else { /* async mode */ 751 try = 5; 752 while(try--) { 753 rv = soc_schan_fifo_msg_send(unit, msg, (void *) b, 754 schanfifo_async_cb); 755 if (SOC_SUCCESS(rv)) { 756 break; 757 } 758 /* queue is full, let wait before try again */ 759 sal_usleep(200); 760 } 761 } 762 etime = sal_time_usecs(); 763 b->time_drv = SAL_USECS_ADD(b->time_drv, SAL_USECS_SUB(etime, stime)); 764 765 if (SOC_FAILURE(rv)) { 766 cli_out("[%s] soc_schan_fifo_msg_send failed = %d\n", str_op, rv); 767 } 768 if (SOC_SUCCESS(rv) && async_en == 1) { 769 b->async_msg_send_cnt++; 770 LOG_INFO(BSL_LS_APPL_TESTS, (BSL_META_U(unit, 771 "[async] async_msg_send_cnt %0d\n"), 772 b->async_msg_send_cnt)); 773 } 774 775 /* free allocated memory */ 776 if (SOC_FAILURE(rv) || async_en == 0) { 777 /* cmdBuff */ 778 sal_dma_free(msg->cmd); 779 /* resp_alloc->resp */ 780 (void) soc_schan_fifo_control(unit, CTL_FIFO_RESP_FREE, msg->resp); 781 /* msg */ 782 sal_free(msg); 783 } 784 785 return rv; 786 } 787 int 788 schanfifo_reg_send_wrapper(int unit, soc_reg_t reg, int op_code, uint32 op_num, 789 int port, int async_en, benchmark_t *b) 790 { 791 int rv = BCM_E_NONE; 792 int dw_per_msg; 793 int entry_dw = 0; 794 int cmd_dw = 2; 795 int op_num_curr, op_num_unassigned, op_num_assigned, 796 cmd_num_increment; 797 798 /* op_num_increment */ 799 if (op_code == WRITE_MEMORY_CMD_MSG) { 800 entry_dw = 1; 801 } 802 dw_per_msg = cmd_dw + entry_dw; 803 /* cmd_num_limit 176 */ 804 cmd_num_increment = SCHANFIFO_SOC_CMD_BUFF_DEPTH / dw_per_msg; 805 806 op_num_unassigned = op_num; 807 op_num_assigned = 0; 808 while (op_num_unassigned > 0) { 809 op_num_curr = (op_num_unassigned > cmd_num_increment) ? 810 cmd_num_increment : op_num_unassigned; 811 op_num_unassigned -= op_num_curr; 812 op_num_assigned += op_num_curr; 813 LOG_INFO(BSL_LS_APPL_TESTS, (BSL_META_U(unit, 814 "op_num_curr = %0d, op_num_unassigned = %0d, " 815 "op_num_assigned = %0d\n"), 816 op_num_curr, op_num_unassigned, op_num_assigned)); 817 rv = schanfifo_reg_send(unit, reg, op_code, op_num, port, async_en, b); 818 if (BCM_FAILURE(rv)) 819 break; 820 } 821 822 return rv; 823 } 824 825 int 826 schanfifo_mem_send(int unit, soc_mem_t mem, int op_code, uint32 op_num, 827 int async_en, benchmark_t *b) 828 { 829 int rv = BCM_E_NONE; 830 uint32 cmd_num_limit = 176; /* CMIC_SCHAN_FIFO_CMD_SIZE_MAX; */ 831 uint32 cmd_num_max; 832 char *str_op; 833 uint32 entry[SOC_MAX_MEM_WORDS]; 834 soc_block_t block; 835 int index = 0; 836 int dst_blk, src_blk, acc_type; 837 int entry_dw = 0; 838 int cmd_dw = 2; 839 int dw_per_msg; 840 int data_bytes = 4; 841 uint32 addr; 842 uint8 at; 843 int try; 844 uint32 *cmdBuff = NULL; 845 soc_schan_fifo_msg_t *msg; 846 schan_fifo_alloc_t resp_alloc; 847 schan_fifo_cmd_t *cmd_ptr; 848 sal_usecs_t stime, etime; 849 int send_cnt = 0; 850 851 /* op code */ 852 op_code = (op_code == WRITE_MEMORY_CMD_MSG) ? op_code : 853 READ_MEMORY_CMD_MSG; 854 if (op_code == READ_MEMORY_CMD_MSG) { 855 str_op = (async_en == 0) ? "SYNC_READ" : "ASYNC_READ"; 856 } else { 857 str_op = (async_en == 0) ? "SYNC_WRITE" : "ASYNC_WRITE"; 858 } 859 860 cmd_num_max = (op_num < cmd_num_limit) ? op_num : cmd_num_limit; 861 sal_memset(entry, 0, sizeof(uint32) * SOC_MAX_MEM_WORDS); 862 863 /* malloc: cmd buff */ 864 cmdBuff = sal_dma_alloc(sizeof(uint32) * SCHANFIFO_SOC_CMD_BUFF_DEPTH, 865 "SCHANFIFO CMD BUFF"); 866 if (cmdBuff == NULL) { 867 return SOC_E_MEMORY; 868 } 869 870 /* malloc: msg */ 871 msg = sal_alloc(sizeof(soc_schan_fifo_msg_t), "SCHANFIFO MSG"); 872 if (msg == NULL) { 873 /* cmdBuff */ 874 sal_dma_free(cmdBuff); 875 return SOC_E_MEMORY; 876 } 877 msg->num = 0; 878 msg->interval = -1; 879 msg->size = 0; 880 msg->cmd = (schan_fifo_cmd_t *) cmdBuff; 881 msg->resp = NULL; 882 883 /* malloc: resp */ 884 if (op_code == READ_MEMORY_CMD_MSG) { 885 resp_alloc.num = cmd_num_max; 886 rv = soc_schan_fifo_control(unit, CTL_FIFO_RESP_ALLOC, &resp_alloc); 887 if (rv != SOC_E_NONE) { 888 return rv; 889 } 890 msg->resp = resp_alloc.resp; 891 } 892 893 /* get memory info */ 894 block = SOC_MEM_BLOCK_ANY(unit, mem); 895 addr = soc_mem_addr_get(unit, mem, 0, block, index, &at); 896 dst_blk = SOC_BLOCK2SCH(unit, block); 897 src_blk = SOC_BLOCK2SCH(unit, CMIC_BLOCK(unit)); 898 acc_type = SOC_MEM_ACC_TYPE(unit, mem); 899 900 if (op_code == WRITE_MEMORY_CMD_MSG) { 901 entry_dw = soc_mem_entry_words(unit, mem); 902 data_bytes = entry_dw * sizeof(uint32); 903 } 904 dw_per_msg = cmd_dw + entry_dw; 905 906 /* fill cmd buff */ 907 while ((msg->num < cmd_num_max) && 908 (msg->size + dw_per_msg) <= SCHANFIFO_SOC_CMD_BUFF_DEPTH) { 909 cmd_ptr = (schan_fifo_cmd_t *) &cmdBuff[msg->size]; 910 soc_schan_header_cmd_set(unit, &cmd_ptr->header, op_code, dst_blk, 911 src_blk, acc_type, data_bytes, 0, 0); 912 cmd_ptr->address = addr; 913 msg->num++; 914 msg->size += dw_per_msg; 915 LOG_INFO(BSL_LS_APPL_TESTS, (BSL_META_U(unit, 916 "add schanfifo cmd, msg_num %0d, " 917 "msg_size %0d, num_words %0d\n"), 918 msg->num, (int) msg->size, dw_per_msg)); 919 } 920 921 /* kick off msg */ 922 stime = sal_time_usecs(); 923 if (async_en) { 924 send_cnt = b->async_msg_send_cnt; 925 if (send_cnt < MAX_NUM_OF_ASYNC_TRANSACTIONS) { 926 b->async_stime[send_cnt] = stime; 927 /* cli_out("debug: async_stime[%d] %0d\n", send_cnt, b->async_stime[send_cnt]); */ 928 } 929 } 930 931 if (async_en == 0) { /* sync mode */ 932 rv = soc_schan_fifo_msg_send(unit, msg, NULL, NULL); 933 } else { /* async mode */ 934 try = 5; 935 while(try--) { 936 rv = soc_schan_fifo_msg_send(unit, msg, (void *) b, 937 schanfifo_async_cb); 938 if (SOC_SUCCESS(rv)) { 939 break; 940 } 941 /* queue is full, let wait before try again */ 942 sal_usleep(200); 943 } 944 } 945 etime = sal_time_usecs(); 946 b->time_drv = SAL_USECS_ADD(b->time_drv, SAL_USECS_SUB(etime, stime)); 947 948 if (SOC_FAILURE(rv)) { 949 cli_out("[%s] soc_schan_fifo_msg_send failed = %d\n", str_op, rv); 950 } 951 if (SOC_SUCCESS(rv) && async_en == 1) { 952 b->async_msg_send_cnt++; 953 LOG_INFO(BSL_LS_APPL_TESTS, (BSL_META_U(unit, 954 "[async] b->async_msg_send_cnt %0d\n"), 955 b->async_msg_send_cnt)); 956 /* cli_out("[async] b->async_msg_send_cnt %0d\n", b->async_msg_send_cnt); */ 957 } 958 959 /* free allocated memory */ 960 if (SOC_FAILURE(rv) || async_en == 0) { 961 /* cmdBuff */ 962 sal_dma_free(msg->cmd); 963 /* resp_alloc->resp */ 964 (void) soc_schan_fifo_control(unit, CTL_FIFO_RESP_FREE, msg->resp); 965 /* msg */ 966 sal_free(msg); 967 } 968 969 return rv; 970 } 971 972 int 973 schanfifo_mem_send_wrapper(int unit, soc_mem_t mem, int op_code, 974 uint32 op_num, int async_en, benchmark_t *b) 975 { 976 int rv = BCM_E_NONE; 977 int dw_per_msg; 978 int entry_dw = 0; 979 int cmd_dw = 2; 980 int op_num_curr, op_num_unassigned, op_num_assigned, 981 cmd_num_increment; 982 uint32 cmd_num_limit = 176; /* CMIC_SCHAN_FIFO_CMD_SIZE_MAX; */ 983 984 /* op_num_increment */ 985 if (op_code == WRITE_MEMORY_CMD_MSG) { 986 entry_dw = soc_mem_entry_words(unit, mem); 987 } 988 dw_per_msg = cmd_dw + entry_dw; 989 cmd_num_increment = SCHANFIFO_SOC_CMD_BUFF_DEPTH / dw_per_msg; 990 if (cmd_num_increment > cmd_num_limit) { 991 cmd_num_increment = cmd_num_limit; 992 } 993 994 op_num_unassigned = op_num; 995 op_num_assigned = 0; 996 while (op_num_unassigned > 0) { 997 op_num_curr = (op_num_unassigned > cmd_num_increment) ? 998 cmd_num_increment : op_num_unassigned; 999 op_num_unassigned -= op_num_curr; 1000 op_num_assigned += op_num_curr; 1001 LOG_INFO(BSL_LS_APPL_TESTS, (BSL_META_U(unit, 1002 "op_num_curr = %0d, op_num_unassigned = %0d, " 1003 "op_num_assigned = %0d\n"), 1004 op_num_curr, op_num_unassigned, op_num_assigned)); 1005 rv = schanfifo_mem_send(unit, mem, op_code, op_num_curr, async_en, b); 1006 if (BCM_FAILURE(rv)) 1007 break; 1008 } 1009 1010 return rv; 1011 } 1012 1013 int 1014 schanfifo_test(int unit, args_t *a, void *pa) 1015 { 1016 int rv = BCM_E_NONE; 1017 soc_mem_t mem; 1018 soc_reg_t reg; 1019 int iter_cmic_read; 1020 int iter_cmic_write; 1021 int repeat_num; 1022 int num_byte; 1023 int quickturn, i, j; 1024 uint32 rval = 0; 1025 uint32 entry[SOC_MAX_MEM_WORDS]; 1026 int port = 0, phy_port = 0; 1027 int blk = 0; 1028 int entry_idx = 0; 1029 benchmark_t *b = (benchmark_t *) pa; 1030 1031 if (b == NULL || b->test_fail == 1) { 1032 goto test_done; 1033 } 1034 1035 quickturn = (SAL_BOOT_QUICKTURN != 0); 1036 1037 if (quickturn) { 1038 iter_cmic_read = b->param_numRead; 1039 iter_cmic_write = b->param_numWrite; 1040 } else if (NULL != SOC_CONTROL(unit)->soc_rcpu_schan_op){ 1041 iter_cmic_read = 5000; 1042 iter_cmic_write = 5000; 1043 } else { 1044 iter_cmic_read = 5000; 1045 iter_cmic_write = 5000; 1046 } 1047 repeat_num = b->param_numRun; 1048 cli_out ("\ntotal_num_of_read = %0d", iter_cmic_read * repeat_num); 1049 cli_out ("\ntotal_num_of_write = %0d\n", iter_cmic_write * repeat_num); 1050 1051 reg = b->test_reg; 1052 mem = b->test_mem; 1053 1054 SOC_MEM_TEST_SKIP_CACHE_SET(unit, TRUE); 1055 1056 if (SOC_IS_ESW(unit)) { 1057 /* find an appropriate port/block */ 1058 if (SOC_PORT_NUM(unit, fe) > 0) { 1059 port = SOC_PORT(unit, fe, 0); 1060 } else if (SOC_PORT_NUM(unit, ge) > 0) { 1061 port = SOC_PORT(unit, ge, 0); 1062 } else if (SOC_PORT_NUM(unit, xe) > 0) { 1063 port = SOC_PORT(unit, xe, 0); 1064 } else { 1065 port = SOC_PORT(unit, hg, 0); 1066 } 1067 if (soc_feature(unit, soc_feature_logical_port_num)) { 1068 phy_port = SOC_INFO(unit).port_l2p_mapping[port]; 1069 } else { 1070 phy_port = port; 1071 } 1072 blk = SOC_PORT_BLOCK(unit, phy_port); 1073 } 1074 1075 num_byte = sizeof(uint32); 1076 if (b->param_asyncEn == 0) { 1077 if (benchmark_begin(unit, b, "read soc reg", "read", 1078 iter_cmic_read*repeat_num, num_byte)) { 1079 for (j = 0; j < repeat_num; j++) { 1080 for (i = 0; i < iter_cmic_read; i++) { 1081 /* coverity[unchecked_value] */ 1082 rv = soc_reg32_get(unit, reg, port, 0, &rval); 1083 if (BCM_FAILURE(rv)) 1084 goto test_done; 1085 } 1086 } 1087 } 1088 benchmark_end(unit, b); 1089 1090 if (benchmark_begin(unit, b, "write soc reg", "write", 1091 iter_cmic_write*repeat_num, num_byte)) { 1092 for (j = 0; j < repeat_num; j++) { 1093 for (i = 0; i < iter_cmic_write; i++) { 1094 rv = soc_reg32_set(unit, reg, port, 0, rval); 1095 if (BCM_FAILURE(rv)) 1096 goto test_done; 1097 } 1098 } 1099 } 1100 benchmark_end(unit, b); 1101 1102 if (benchmark_begin(unit, b, "schan fifo read soc reg", "read", 1103 iter_cmic_read*repeat_num, num_byte)) { 1104 for (j = 0; j < repeat_num; j++) { 1105 for (i = 0; i < iter_cmic_read; i++) { 1106 /* coverity[unchecked_value] */ 1107 rv = schan_fifo_reg32_get(unit, reg, port, 0, &rval, b); 1108 if (BCM_FAILURE(rv)) 1109 goto test_done; 1110 } 1111 rv = schan_fifo_flush(unit, b); 1112 if (BCM_FAILURE(rv)) 1113 goto test_done; 1114 } 1115 } 1116 benchmark_end(unit, b); 1117 1118 if (benchmark_begin(unit, b, "schan fifo write soc reg", "write", 1119 iter_cmic_write*repeat_num, num_byte)) { 1120 for (j = 0; j < repeat_num; j++) { 1121 for (i = 0; i < iter_cmic_write; i++) { 1122 rv = schan_fifo_reg32_set(unit, reg, port, 0, rval, b); 1123 if (BCM_FAILURE(rv)) 1124 goto test_done; 1125 } 1126 rv = schan_fifo_flush(unit, b); 1127 if (BCM_FAILURE(rv)) 1128 goto test_done; 1129 } 1130 } 1131 benchmark_end(unit, b); 1132 1133 blk = SOC_MEM_BLOCK_ANY(unit, mem); 1134 num_byte = soc_mem_entry_words(unit, mem) * sizeof(uint32); 1135 if (benchmark_begin(unit, b, "read soc memory", "read", 1136 iter_cmic_read*repeat_num, num_byte)) { 1137 for (j = 0; j < repeat_num; j++) { 1138 for (i = 0; i < iter_cmic_read; i++) { 1139 /* coverity[unchecked_value] */ 1140 rv = soc_mem_read(unit, mem, blk, entry_idx, entry); 1141 if (BCM_FAILURE(rv)) 1142 goto test_done; 1143 } 1144 } 1145 } 1146 benchmark_end(unit, b); 1147 1148 if (benchmark_begin(unit, b, "write soc memory", "write", 1149 iter_cmic_write*repeat_num, num_byte)) { 1150 for (j = 0; j < repeat_num; j++) { 1151 for (i = 0; i < iter_cmic_write; i++) { 1152 /* coverity[unchecked_value] */ 1153 rv = soc_mem_write(unit, mem, blk, entry_idx, entry); 1154 if (BCM_FAILURE(rv)) 1155 goto test_done; 1156 } 1157 } 1158 } 1159 benchmark_end(unit, b); 1160 1161 if (benchmark_begin(unit, b, "schan fifo read soc memory", "read", 1162 iter_cmic_read*repeat_num, num_byte)) { 1163 for (j = 0; j < repeat_num; j++) { 1164 for (i = 0; i < iter_cmic_read; i++) { 1165 /* coverity[unchecked_value] */ 1166 rv = schan_fifo_mem_read(unit, mem, blk, entry_idx, entry, b); 1167 if (BCM_FAILURE(rv)) 1168 goto test_done; 1169 } 1170 rv = schan_fifo_flush(unit, b); 1171 if (BCM_FAILURE(rv)) 1172 goto test_done; 1173 } 1174 } 1175 benchmark_end(unit, b); 1176 1177 if (benchmark_begin(unit, b, "schan fifo write soc memory", "write", 1178 iter_cmic_write*repeat_num, num_byte)) { 1179 for (j = 0; j < repeat_num; j++) { 1180 for (i = 0; i < iter_cmic_write; i++) { 1181 /* coverity[unchecked_value] */ 1182 rv = schan_fifo_mem_write(unit, mem, blk, entry_idx, entry, b); 1183 if (BCM_FAILURE(rv)) 1184 goto test_done; 1185 } 1186 rv = schan_fifo_flush(unit, b); 1187 if (BCM_FAILURE(rv)) 1188 goto test_done; 1189 } 1190 } 1191 benchmark_end(unit, b); 1192 } 1193 #ifdef BCM_SOC_ASYNC_SUPPORT 1194 if (b->param_asyncEn == 1) { 1195 uint32 async_en = 1; 1196 int op_num_total = iter_cmic_read * repeat_num; 1197 int op_code; 1198 1199 b->async_en = async_en; 1200 /* async mode: reg read */ 1201 if (benchmark_begin(unit, b, "[ASYNC] schan fifo read soc reg", "read", 1202 op_num_total, num_byte)) { 1203 op_code = READ_REGISTER_CMD_MSG; 1204 rv = schanfifo_reg_send_wrapper(unit, reg, op_code, op_num_total, 1205 port, async_en, b); 1206 if (BCM_FAILURE(rv)) 1207 goto test_done; 1208 } 1209 benchmark_end(unit, b); 1210 1211 /* async mode: reg write */ 1212 if (benchmark_begin(unit, b, "[ASYNC] schan fifo write soc reg", "write", 1213 op_num_total, num_byte)) { 1214 op_code = WRITE_REGISTER_CMD_MSG; 1215 rv = schanfifo_reg_send_wrapper(unit, reg, op_code, op_num_total, 1216 port, async_en, b); 1217 if (BCM_FAILURE(rv)) 1218 goto test_done; 1219 } 1220 benchmark_end(unit, b); 1221 1222 /* async mode: mem read */ 1223 num_byte = soc_mem_entry_words(unit, mem) * sizeof(uint32); 1224 if (benchmark_begin(unit, b, "[ASYNC] schan fifo read soc memory", "read", 1225 op_num_total, num_byte)) { 1226 op_code = READ_MEMORY_CMD_MSG; 1227 rv = schanfifo_mem_send_wrapper(unit, mem, op_code, op_num_total, 1228 async_en, b); 1229 if (BCM_FAILURE(rv)) 1230 goto test_done; 1231 } 1232 benchmark_end(unit, b); 1233 1234 /* async mode: mem write */ 1235 num_byte = soc_mem_entry_words(unit, mem) * sizeof(uint32); 1236 if (benchmark_begin(unit, b, "[ASYNC] schan fifo write soc memory", "write", 1237 op_num_total, num_byte)) { 1238 op_code = WRITE_MEMORY_CMD_MSG; 1239 rv = schanfifo_mem_send_wrapper(unit, mem, op_code, op_num_total, 1240 async_en, b); 1241 if (BCM_FAILURE(rv)) 1242 goto test_done; 1243 } 1244 benchmark_end(unit, b); 1245 } 1246 #endif 1247 test_done: 1248 SOC_MEM_TEST_SKIP_CACHE_SET(unit, FALSE); 1249 1250 if (BCM_FAILURE(rv)) { 1251 test_error(unit, "SCHAN FIFO Test Failed!\n"); 1252 } 1253 1254 return rv; 1255 }