sat.c (116918B)
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 * Utility routines for managing Higig headers 8 */ 9 10 #include <shared/bsl.h> 11 #include <shared/bitop.h> 12 #include <assert.h> 13 #include <sal/types.h> 14 #include <soc/drv.h> 15 #include <soc/types.h> 16 #include <soc/debug.h> 17 #include <soc/error.h> 18 #include <sal/limits.h> 19 #include <soc/shared/sat.h> 20 #include <appl/diag/system.h> 21 #include <soc/scache.h> 22 #if defined(BCM_DPP_SUPPORT) 23 #include <soc/dpp/ARAD/arad_chip_defines.h> 24 #endif 25 26 #ifdef CRASH_RECOVERY_SUPPORT 27 #include <soc/hwstate/hw_log.h> 28 #endif 29 30 #ifdef BCM_SAT_SUPPORT 31 32 #ifdef BCM_WARM_BOOT_SUPPORT 33 #define SOC_SAT_WB_VERSION_1_0 SOC_SCACHE_VERSION(1,0) 34 #define SOC_SAT_WB_CURRENT_VERSION SOC_SAT_WB_VERSION_1_0 35 #endif /* BCM_WARM_BOOT_SUPPORT */ 36 37 #ifdef BCM_SAT_GTF_STAT_FIX 38 typedef struct _soc_sat_data_s { 39 uint64 gtf_stat_value[16]; 40 } _soc_sat_data_t; 41 #endif 42 43 #ifdef BCM_SAT_GTF_STAT_FIX 44 _soc_sat_data_t soc_sat_data[BCM_UNITS_MAX]; 45 #endif 46 47 static soc_sat_handler_t _soc_sat_handler[BCM_UNITS_MAX]; 48 49 typedef struct _soc_sat_gtf_pkt_hdr_tbl_info_s { 50 uint32 pkt_hdr_lsb[SOC_SAT_PKT_HERDER_LSB_FIELD_SIZE]; 51 uint32 pkt_hdr_msb[SOC_SAT_PKT_HERDER_MSB_FIELD_SIZE]; 52 uint32 pkt_hdr_len; 53 }_soc_sat_gtf_pkt_hdr_tbl_info_t; 54 55 typedef struct _soc_sat_gtf_stamp_field_tbl_info_s { 56 uint32 stamp_2_ena; 57 uint32 stamp_2_offset; 58 uint32 stamp_2_shift; 59 uint32 stamp_2_value; 60 uint32 counter_8_ena; 61 uint32 counter_8_offset; 62 uint32 counter_8_shift; 63 uint32 counter_8_mask; 64 uint32 counter_8_inc_step; 65 uint32 counter_8_period; 66 uint32 counter_16_ena; 67 uint32 counter_16_offset; 68 uint32 counter_16_shift; 69 uint32 counter_16_mask; 70 uint32 counter_16_inc_step; 71 uint32 counter_16_period; 72 }_soc_sat_gtf_stamp_field_tbl_info_t; 73 74 STATIC int soc_sat_dynamic_memory_access_set(int unit, uint32 enable) 75 { 76 int 77 rv; 78 uint32 access_enable; 79 80 rv = SOC_E_NONE; 81 access_enable = (enable ? 1:0); 82 83 rv = soc_reg_field32_modify(unit, OAMP_ENABLE_DYNAMIC_MEMORY_ACCESSr, REG_PORT_ANY, ENABLE_DYNAMIC_MEMORY_ACCESSf, access_enable); 84 if (SOC_FAILURE(rv)) { 85 LOG_ERROR(BSL_LS_SOC_SAT, 86 (BSL_META_U(unit, 87 "%s\n"), soc_errmsg(rv))); 88 } 89 90 return rv; 91 } 92 /***************************************************** 93 *NAME 94 * soc_msb_bit_on 95 *TYPE: 96 * PROC 97 *DATE: 98 * 13-Nov-02 99 *FUNCTION: 100 * Given number - x. 101 * Return the msb bit number that is on. 102 *CALLING SEQUENCE: 103 * soc_msb_bit_on(x) 104 *INPUT: 105 * SOC_SAND_DIRECT: 106 * const uint32 x - 107 * Number to evaluate 108 * SOC_SAND_INDIRECT: 109 * None. 110 *OUTPUT: 111 * SOC_SAND_DIRECT: 112 * uint32 - 113 * the bit number 114 * SOC_SAND_INDIRECT: 115 * NON 116 *REMARKS: 117 * soc_msb_bit_on(0) = 0 -- definition 118 * soc_msb_bit_on(1) = 0 119 * soc_msb_bit_on(2) = 1 120 * soc_msb_bit_on(3) = 1 121 * soc_msb_bit_on(4) = 2 122 * soc_msb_bit_on(5) = 2 123 * soc_msb_bit_on(0xFF121212) = 31 124 *SEE ALSO: 125 */ 126 uint32 127 soc_msb_bit_on( 128 SOC_SAND_IN uint32 x_in 129 ) 130 { 131 uint32 132 n, 133 x; 134 int 135 i; 136 x = x_in; 137 138 if (x == 0) 139 { 140 return(0); 141 } 142 143 n = 0; 144 for (i=16 ; i>0 ; i>>=1) 145 { 146 if (x & ((~((uint32)0))<<i)) 147 { 148 n += i; 149 x >>= i; 150 } 151 } 152 return n; 153 } 154 155 /***************************************************** 156 *NAME 157 * soc_break_to_mnt_exp_round_down 158 *TYPE: 159 * PROC 160 *DATE: 161 * 13-Nov-02 162 *FUNCTION: 163 * Given: 1. Number - x, . 164 * 2. Number of mantissa bits - mnt_nof_bits 165 * 3. Number of exponent bits - exp_nof_bits 166 * Return mantissa (mnt) and exponent (exp). 167 * Such that, y = (mnt+mnt_inc)<<exp - is the closest smaller equal number than x. 168 *CALLING SEQUENCE: 169 * soc_break_to_mnt_exp_round_down(x, mnt_nof_bits, exp_nof_bits, mnt_inc, mnt, exp) 170 *INPUT: 171 * SOC_SAND_DIRECT: 172 * const uint32 x - 173 * Number to break 174 * const uint32 mnt_nof_bits - 175 * Size in bits of mantissa. 176 * Range 1:10 177 * const uint32 exp_nof_bits - 178 * Size in bits of exponent 179 * Range 1:10 180 * const uint32 mnt_inc - 181 * A number added to the mantissa for the calculation 182 * Range 0:1 183 * uint32* mnt - 184 * Buffer to load mantissa result 185 * uint32* exp - 186 * Buffer to load exponent result 187 * SOC_SAND_INDIRECT: 188 * None. 189 *OUTPUT: 190 * SOC_SAND_DIRECT: 191 * SOC_SAND_RET - 192 * 193 * SOC_SAND_INDIRECT: 194 * mnt, exp. 195 *REMARKS: 196 * 1. the mantissa and exponnent number of bits 197 * ranges from 1 to 10 each. This range may 198 * be enlarge with some minor code changes 199 * (if needed at all) 200 *SEE ALSO: 201 */ 202 int 203 soc_break_to_mnt_exp_round_down( 204 SOC_SAND_IN uint32 x, 205 SOC_SAND_IN uint32 mnt_nof_bits, 206 SOC_SAND_IN uint32 exp_nof_bits, 207 SOC_SAND_IN uint32 mnt_inc, 208 SOC_SAND_OUT uint32* mnt, 209 SOC_SAND_OUT uint32* exp 210 ) 211 { 212 uint32 213 y; 214 uint32 215 mnt_max, 216 exp_max, 217 msb_bit_on; 218 int 219 msb_bit_diff; 220 int 221 rv ; 222 223 rv = SOC_E_NONE; 224 225 /* 226 * Inputs checking 227 */ 228 if ( (mnt == NULL) || 229 (exp == NULL) || 230 (mnt_nof_bits > 16) || 231 (exp_nof_bits > 10) || 232 (mnt_nof_bits==0) || 233 (exp_nof_bits==0) || 234 (mnt_inc > 1) 235 ) 236 { 237 /* 238 * Invalid Inputs 239 */ 240 rv = SOC_E_PARAM ; 241 goto exit ; 242 } 243 244 mnt_max = (0x1<<mnt_nof_bits)-1 ; 245 exp_max = (0x1<<exp_nof_bits)-1 ; 246 msb_bit_on = 0 ; 247 msb_bit_diff = 0 ; 248 249 if(exp_max>= (sizeof(uint32)*8-1)) 250 { 251 /* 252 * Case we got exp_max>=31, 253 * make it only 30. 254 */ 255 exp_max = sizeof(uint32)*8-2; 256 } 257 258 259 *mnt = 0; 260 *exp = 0; 261 262 if (x <= mnt_inc) 263 { /* 264 * x is too small 265 * Put the smallest number it represent 266 * Actually we should have returned ERR for (x < mnt_inc), because 267 * there is no solution that gives a smaller equal number than x, 268 * but for backwards compitability we'll return the smallest solution here 269 * as well. 270 */ 271 goto exit ; 272 } 273 y = ((1 /* mnt_max+mnt_inc */)<<exp_max)*mnt_max; 274 if (x > y) 275 { /* 276 * x is too big for our represantation 277 * Put the biggest number it can 278 */ 279 *mnt = mnt_max; 280 *exp = exp_max; 281 goto exit ; 282 } 283 284 msb_bit_on = soc_msb_bit_on(x) ; 285 286 msb_bit_diff = (msb_bit_on+1) - mnt_nof_bits; 287 if (msb_bit_diff<=0) 288 { 289 msb_bit_diff = 0 ; 290 } 291 292 *mnt = mnt_max << msb_bit_diff ; 293 *mnt &= x ; 294 295 /* decrease mnt_inc .. because the reverse calculation is (mnt+mnt_inc)<<exp */ 296 if ((*mnt) >= mnt_inc) 297 { 298 (*mnt) -= mnt_inc; 299 } 300 else 301 { 302 if ( (*exp) > 0) 303 { 304 (*exp) -- ; 305 } 306 else 307 { 308 /* The function does not reach here.*/ 309 *exp = 0 ; 310 } 311 } 312 *mnt >>= msb_bit_diff; 313 *exp = msb_bit_diff ; 314 exit: 315 return rv ; 316 } 317 318 /***************************************************** 319 *NAME 320 * soc_break_to_mnt_exp_round_up 321 *TYPE: 322 * PROC 323 *DATE: 324 * 13-Nov-02 325 *FUNCTION: 326 * Get a number, x. 327 * Return mantissa (mnt) and exponent (exp). 328 * Such that, y = (mnt+mnt_inc)<<exp is the closest bigger equal number than x. 329 *CALLING SEQUENCE: 330 * soc_break_to_mnt_exp_round_up(x, mnt_nof_bits, exp_nof_bits, mnt_inc, mnt, exp) 331 *INPUT: 332 * SOC_SAND_DIRECT: 333 * const uint32 x - 334 * Number to dis-assemble 335 * const uint32 mnt_nof_bits - 336 * Size in bits of mantissa. 337 * const uint32 exp_nof_bits - 338 * Size in bits of exponent 339 * const uint32 mnt_inc - 340 * A number added to the mantissa for the calculation 341 * Range 0:1 342 * uint32* mnt - 343 * Buffer to load mantissa result 344 * uint32* exp - 345 * Buffer to load exponent result 346 * SOC_SAND_INDIRECT: 347 * None. 348 *OUTPUT: 349 * SOC_SAND_DIRECT: 350 * uint32 - 351 * 352 * SOC_SAND_INDIRECT: 353 * mnt, exp. 354 *REMARKS: 355 * None. 356 *SEE ALSO: 357 */ 358 int 359 soc_break_to_mnt_exp_round_up( 360 SOC_SAND_IN uint32 x, 361 SOC_SAND_IN uint32 mnt_nof_bits, 362 SOC_SAND_IN uint32 exp_nof_bits, 363 SOC_SAND_IN uint32 mnt_inc, 364 SOC_SAND_OUT uint32* mnt, 365 SOC_SAND_OUT uint32* exp 366 ) 367 { 368 uint32 369 mnt_max, 370 exp_max ; 371 uint32 372 num ; 373 int 374 rv ; 375 376 mnt_max = (0x1<<mnt_nof_bits)-1, 377 exp_max = (0x1<<exp_nof_bits)-1 ; 378 rv = SOC_E_NONE; 379 380 /* 381 * soc_break_to_mnt_exp_round_down() is checking the valifdity of the inputs. 382 */ 383 rv = soc_break_to_mnt_exp_round_down(x, mnt_nof_bits, exp_nof_bits, mnt_inc, mnt, exp); 384 if (rv != SOC_E_NONE) 385 { 386 goto exit ; 387 } 388 if(exp_max>= (sizeof(uint32)*8-1)) 389 { 390 exp_max = sizeof(uint32)*8-2; 391 } 392 393 num = (*mnt + mnt_inc) << (*exp); 394 if (num<x) 395 { 396 /* Round it up.*/ 397 (*mnt) ++; 398 if (*mnt>mnt_max) 399 { 400 *mnt = *mnt/2; 401 (*exp) ++; 402 if ((*exp)> exp_max) 403 { 404 *exp = exp_max ; 405 *mnt = mnt_max ; 406 } 407 } 408 } 409 410 exit: 411 return rv ; 412 } 413 414 STATIC soc_error_t 415 soc_sat_packet_config_exp_payload_uint8_to_long( 416 SOC_SAND_IN uint8 exp_payload_u8[SOC_SAT_PAYLOAD_MAX_PATTERN_NOF_U8], 417 SOC_SAND_IN uint8 num_of_bytes, 418 SOC_SAND_IN uint32 is_reverse, 419 SOC_SAND_OUT uint32 exp_payload_long[SOC_SAT_PAYLOAD_MAX_PATTERN_NOF_U32] 420 ) 421 { 422 uint32 423 tmp; 424 uint32 425 char_indx, 426 long_indx, 427 write_to; 428 uint32 429 first_word = 0, 430 second_word = 1, 431 last_word = 0; 432 433 if (num_of_bytes > SOC_SAT_PAYLOAD_MAX_PATTERN_NOF_U8) { 434 return SOC_E_PARAM; 435 } 436 437 last_word = (num_of_bytes > (SOC_SAT_PAYLOAD_MAX_PATTERN_NOF_U8/2)) ? second_word : first_word; 438 write_to = (is_reverse ? (sizeof(uint32) - 1): 0); 439 exp_payload_long[first_word] = 0; 440 exp_payload_long[second_word] = 0; 441 long_indx = (is_reverse ? last_word: first_word); 442 443 for (char_indx = 0; char_indx < num_of_bytes; ++char_indx) 444 { 445 if (char_indx == sizeof(uint32)) { 446 long_indx = (is_reverse ? 0: 1); 447 write_to = (is_reverse ? (sizeof(uint32) - 1) : 0); 448 } 449 450 tmp = exp_payload_u8[char_indx]; 451 exp_payload_long[long_indx] |= (tmp << (SAL_CHAR_BIT * write_to)); 452 write_to = is_reverse ? (write_to-1) : (write_to+1); 453 } 454 455 return SOC_E_NONE; 456 } 457 458 STATIC int 459 _soc_sat_gtf_construct_packet_header( 460 SOC_SAND_IN int unit, 461 SOC_SAND_IN bcm_pkt_t *pkt_hdr, 462 SOC_SAND_OUT _soc_sat_gtf_pkt_hdr_tbl_info_t *pkt_hdr_tbl_info 463 ) 464 { 465 uint32 pkt_data = 0; 466 uint32 pkt_hdr_lsb_bits = 0, pkt_hdr_msb_bits = 0, msb_bits_remainder = 0, lsb_bits_remainder = 0; 467 uint32 bytes_copy, bytes_copied; 468 uint32 offset = 0; 469 int i = 0; 470 int rv = SOC_E_NONE; 471 472 if (pkt_hdr == NULL) { 473 LOG_ERROR(BSL_LS_SOC_SAT, 474 (BSL_META_U(unit, 475 "Parameter pkt_hdr is NULL\n"))); 476 rv = SOC_E_PARAM; 477 goto exit; 478 } 479 480 if (pkt_hdr_tbl_info == NULL) { 481 LOG_ERROR(BSL_LS_SOC_SAT, 482 (BSL_META_U(unit, 483 "Parameter pkt_hdr_tbl_info is NULL\n"))); 484 rv = SOC_E_PARAM; 485 goto exit; 486 } 487 488 if (SOC_IS_QAX(unit)) { 489 pkt_hdr_lsb_bits = soc_mem_field_length(unit, OAMP_SAT_TX_EVC_PRM_ENTRY_1m, PKT_HEADER_LSBf); 490 pkt_hdr_msb_bits = soc_mem_field_length(unit, OAMP_SAT_TX_EVC_PRM_ENTRY_2m, PKT_HEADER_MSBf); 491 }else { 492 pkt_hdr_lsb_bits = soc_mem_field_length(unit, OAMP_SAT_TX_EVC_PARAMS_ENTRY_1m, PKT_HEADER_LSBf); 493 pkt_hdr_msb_bits = soc_mem_field_length(unit, OAMP_SAT_TX_EVC_PARAMS_ENTRY_2m, PKT_HEADER_MSBf); 494 } 495 496 offset = pkt_hdr_msb_bits - 8; 497 bytes_copy = pkt_hdr_msb_bits/8; 498 499 for (i = 0 ; (i < bytes_copy) && (i < pkt_hdr->pkt_data[0].len); i++){ 500 pkt_data = pkt_hdr->pkt_data[0].data[i]; 501 SHR_BITCOPY_RANGE(pkt_hdr_tbl_info->pkt_hdr_msb, offset, &pkt_data, 0, 8); 502 offset -= 8; 503 } 504 bytes_copied = i; 505 506 if (bytes_copied < pkt_hdr->pkt_data[0].len) { 507 msb_bits_remainder = pkt_hdr_msb_bits%8; 508 lsb_bits_remainder = 8 - msb_bits_remainder; 509 if (msb_bits_remainder != 0) { 510 offset = 0; 511 pkt_data = pkt_hdr->pkt_data[0].data[bytes_copied]; 512 SHR_BITCOPY_RANGE(pkt_hdr_tbl_info->pkt_hdr_msb, offset, &pkt_data, (8 - msb_bits_remainder), msb_bits_remainder); 513 514 offset = pkt_hdr_lsb_bits - lsb_bits_remainder; 515 SHR_BITCOPY_RANGE(pkt_hdr_tbl_info->pkt_hdr_lsb, offset, &pkt_data, 0, lsb_bits_remainder); 516 517 bytes_copied += 1; 518 } 519 } 520 521 if (bytes_copied < pkt_hdr->pkt_data[0].len) { 522 offset = pkt_hdr_lsb_bits - lsb_bits_remainder - 8; 523 bytes_copy = (pkt_hdr_lsb_bits - lsb_bits_remainder)/8; 524 for (i = 0 ; i < bytes_copy; i++){ 525 pkt_data = pkt_hdr->pkt_data[0].data[bytes_copied + i]; 526 SHR_BITCOPY_RANGE(pkt_hdr_tbl_info->pkt_hdr_lsb, offset, &pkt_data, 0, 8); 527 offset -= 8; 528 } 529 bytes_copied += i; 530 } 531 532 pkt_hdr_tbl_info->pkt_hdr_len = pkt_hdr->pkt_data[0].len; 533 534 exit: 535 return rv; 536 } 537 538 STATIC int 539 _soc_sat_gtf_construct_stamp_field( 540 SOC_SAND_IN int unit, 541 SOC_SAND_IN soc_sat_gtf_packet_edit_t *pkt_edit, 542 SOC_SAND_OUT _soc_sat_gtf_stamp_field_tbl_info_t *stamp_field_info 543 ) 544 { 545 int rv = SOC_E_NONE; 546 const uint32 field_2_cnt_8_mask[7] = {0xff, 0xe0, 0xc0, 0xff, 0xff, 0xff, 0xff}; 547 const uint32 field_2_cnt_16_mask[7] = {0xffff, 0xe000, 0xc000, 0xffff, 0xffff, 0xfff0, 0xfff0}; 548 const soc_sat_stamp_t *tmp_stamp; 549 int i = 0; 550 int tmp_stamp_offset_bits = 0; 551 552 if (pkt_edit == NULL) { 553 LOG_ERROR(BSL_LS_SOC_SAT, 554 (BSL_META_U(unit, 555 "Parameter pkt_edit is NULL\n"))); 556 rv = SOC_E_PARAM; 557 goto exit; 558 } 559 560 if (stamp_field_info == NULL) { 561 LOG_ERROR(BSL_LS_SOC_SAT, 562 (BSL_META_U(unit, 563 "Parameter stamp_field_info is NULL\n"))); 564 rv = SOC_E_PARAM; 565 goto exit; 566 } 567 568 for (i = 0; i < pkt_edit->number_of_stamps; i++) { 569 tmp_stamp = &(pkt_edit->stamps[i]); 570 571 if (tmp_stamp->stamp_type == socSatStampConstant2Bit) { 572 tmp_stamp_offset_bits = tmp_stamp->offset; 573 stamp_field_info->stamp_2_ena = 1; 574 if (tmp_stamp_offset_bits%8 == 7) { 575 stamp_field_info->stamp_2_offset = tmp_stamp_offset_bits/8 + 1; 576 stamp_field_info->stamp_2_shift = 7; 577 } 578 else { 579 stamp_field_info->stamp_2_offset = tmp_stamp_offset_bits/8; 580 stamp_field_info->stamp_2_shift = 8 - 2 - tmp_stamp_offset_bits%8; 581 } 582 stamp_field_info->stamp_2_value = tmp_stamp->value; 583 } 584 else if (tmp_stamp->stamp_type == socSatStampCounter8Bit) { 585 tmp_stamp_offset_bits = tmp_stamp->offset; 586 stamp_field_info->counter_8_ena = 1; 587 stamp_field_info->counter_8_offset = (tmp_stamp_offset_bits/8) + ((tmp_stamp_offset_bits%8)?1:0); 588 stamp_field_info->counter_8_shift = (8 - (tmp_stamp_offset_bits%8))%8; 589 stamp_field_info->counter_8_mask = field_2_cnt_8_mask[tmp_stamp->field_type]; 590 stamp_field_info->counter_8_inc_step = tmp_stamp->inc_step; 591 stamp_field_info->counter_8_period = tmp_stamp->inc_period_packets; 592 } 593 else if (tmp_stamp->stamp_type == socSatStampCounter16Bit) { 594 tmp_stamp_offset_bits = tmp_stamp->offset; 595 stamp_field_info->counter_16_ena = 1; 596 stamp_field_info->counter_16_offset = (tmp_stamp_offset_bits/8) + ((tmp_stamp_offset_bits%8)?1:0); 597 stamp_field_info->counter_16_shift = (8 - (tmp_stamp_offset_bits%8))%8; 598 stamp_field_info->counter_16_mask = field_2_cnt_16_mask[tmp_stamp->field_type]; 599 stamp_field_info->counter_16_inc_step = tmp_stamp->inc_step; 600 stamp_field_info->counter_16_period = tmp_stamp->inc_period_packets; 601 } 602 } 603 604 exit: 605 return rv; 606 } 607 608 STATIC int 609 _soc_sat_clock_per_cycle_set( 610 SOC_SAND_IN int unit, 611 SOC_SAND_IN uint32 clock_per_cycle) 612 { 613 int rv = SOC_E_NONE; 614 uint64 field64; 615 616 rv = READ_OAMP_SAT_GEN_CONFIGr(unit, &field64); 617 if (SOC_FAILURE(rv)) { 618 LOG_ERROR(BSL_LS_SOC_SAT, 619 (BSL_META_U(unit, 620 "Fail(%s) in read OAMP_SAT_GEN_CONFIGr\n"), soc_errmsg(rv))); 621 return rv; 622 } 623 624 soc_reg64_field32_set(unit,OAMP_SAT_GEN_CONFIGr, &field64, RATE_NUM_CLKS_CYCLEf, clock_per_cycle); 625 626 rv = WRITE_OAMP_SAT_GEN_CONFIGr(unit, field64); 627 if (SOC_FAILURE(rv)) { 628 LOG_ERROR(BSL_LS_SOC_SAT, 629 (BSL_META_U(unit, 630 "Fail(%s) in write OAMP_SAT_GEN_CONFIGr\n"), soc_errmsg(rv))); 631 return rv; 632 } 633 634 return rv; 635 } 636 637 STATIC int 638 _soc_sat_gtf_rate_to_internal_rate_convert( 639 SOC_SAND_IN int unit, 640 SOC_SAND_IN uint32 rate, 641 SOC_SAND_IN uint32 flags, 642 SOC_SAND_IN uint32 mnt_nof_bits, 643 SOC_SAND_IN uint32 exp_nof_bits, 644 SOC_SAND_IN uint32 pps_granularity, 645 SOC_SAND_OUT uint32 *rate_mnt_val, 646 SOC_SAND_OUT uint32 *rate_exp_val 647 ) 648 { 649 int rv = SOC_E_NONE; 650 uint32 fld_val = 0; 651 uint64 field64; 652 653 uint32 bytes_per_cycle = 0; 654 uint32 cycles_per_sec = 0; 655 uint32 clocks_per_sec = 0; 656 uint32 clocks_per_cycle = 0; 657 uint32 freq_hz = 0; 658 int granularity = 1000; /* 1 kbits per sec */ 659 660 if (rate_mnt_val == NULL) { 661 LOG_ERROR(BSL_LS_SOC_SAT, 662 (BSL_META_U(unit, 663 "Parameter rate_mnt_val is NULL\n"))); 664 rv = SOC_E_PARAM; 665 return rv; 666 } 667 668 if (rate_exp_val == NULL) { 669 LOG_ERROR(BSL_LS_SOC_SAT, 670 (BSL_META_U(unit, 671 "Parameter rate_exp_val is NULL\n"))); 672 rv = SOC_E_PARAM; 673 return rv; 674 } 675 676 if(SOC_IS_QAX(unit) && (flags & SOC_SAT_GTF_RATE_WITH_GRANULARITY) && (pps_granularity == 0)){ 677 LOG_ERROR(BSL_LS_SOC_SAT, 678 (BSL_META_U(unit, 679 "Parameter granularity can't be zero \n"))); 680 rv = SOC_E_PARAM; 681 return rv; 682 } 683 684 /* 1. caculate cycle per sec */ 685 rv = soc_reg_above_64_field64_read(unit, OAMP_TIMER_CONFIGr, REG_PORT_ANY, 0, NUM_CLOCKS_SECf, &field64); 686 if (SOC_FAILURE(rv)) { 687 LOG_ERROR(BSL_LS_SOC_SAT, 688 (BSL_META_U(unit, 689 "Fail(%s) in read OAMP_TIMER_CONFIGr\n"), soc_errmsg(rv))); 690 return rv; 691 } 692 fld_val = COMPILER_64_LO(field64); 693 clocks_per_sec = fld_val; 694 695 rv = soc_reg_above_64_field64_read(unit, OAMP_SAT_GEN_CONFIGr, REG_PORT_ANY, 0, RATE_NUM_CLKS_CYCLEf, &field64); 696 if (SOC_FAILURE(rv)) { 697 LOG_ERROR(BSL_LS_SOC_SAT, 698 (BSL_META_U(unit, 699 "Fail(%s) in read OAMP_SAT_GEN_CONFIGr\n"), soc_errmsg(rv))); 700 return rv; 701 } 702 fld_val = COMPILER_64_LO(field64); 703 clocks_per_cycle = fld_val; 704 705 if (SOC_IS_QAX(unit) && (flags & SOC_SAT_GTF_RATE_IN_PACKETS)) { 706 clocks_per_cycle = clocks_per_sec; 707 708 if (SOC_IS_QAX(unit) && (flags & SOC_SAT_GTF_RATE_WITH_GRANULARITY)) { 709 clocks_per_cycle = clocks_per_sec/pps_granularity; 710 bytes_per_cycle = rate /pps_granularity; 711 } 712 else{ 713 bytes_per_cycle = rate; 714 } 715 rv = _soc_sat_clock_per_cycle_set(unit,clocks_per_cycle); 716 if (SOC_FAILURE(rv)) { 717 LOG_ERROR(BSL_LS_SOC_SAT, 718 (BSL_META_U(unit, 719 "Fail(%s) in _soc_sat_clock_per_cycle_set\n"), soc_errmsg(rv))); 720 } 721 }else { 722 /* Time tickets */ 723 freq_hz = SOC_INFO(unit).frequency * 1000000; 724 #if defined(BCM_DPP_SUPPORT) 725 if (SOC_IS_JERICHO(unit)) { 726 freq_hz = arad_chip_kilo_ticks_per_sec_get(unit)*1000; 727 granularity = 64000; /* 64kbits per sec */ 728 } 729 #endif 730 rv = _soc_sat_clock_per_cycle_set(unit,(freq_hz/granularity)*8); /* 1kbits per sec(125 cycles per sec) */ 731 if (SOC_FAILURE(rv)) { 732 LOG_ERROR(BSL_LS_SOC_SAT, 733 (BSL_META_U(unit, 734 "Fail(%s) in _soc_sat_clock_per_cycle_set\n"), soc_errmsg(rv))); 735 } 736 cycles_per_sec = clocks_per_sec/clocks_per_cycle; 737 /* 2. caculate bytes per cycle, given rate(Units: kbps) */ 738 bytes_per_cycle = rate * 125 / cycles_per_sec; 739 } 740 741 /* 3. caculate interval value for bytes per cycle */ 742 rv = soc_break_to_mnt_exp_round_up( 743 bytes_per_cycle, 744 mnt_nof_bits, 745 exp_nof_bits, 746 0, 747 rate_mnt_val, 748 rate_exp_val 749 ); 750 if (SOC_FAILURE(rv)) { 751 LOG_ERROR(BSL_LS_SOC_SAT, 752 (BSL_META_U(unit, 753 "Fail(%s) in soc_break_to_mnt_exp_round_up\n"), soc_errmsg(rv))); 754 } 755 756 return rv; 757 } 758 759 STATIC int 760 _soc_sat_gtf_rate_from_internal_rate_convert( 761 SOC_SAND_IN int unit, 762 SOC_SAND_IN uint32 rate_mnt_val, 763 SOC_SAND_IN uint32 rate_exp_val, 764 SOC_SAND_IN uint32 flags, 765 SOC_SAND_OUT uint32 *rate 766 ) 767 { 768 int rv = SOC_E_NONE; 769 uint32 fld_val = 0; 770 uint64 field64; 771 772 uint32 bytes_per_cycle = 0; 773 uint32 cycles_per_sec = 0; 774 uint32 clocks_per_sec = 0; 775 uint32 clocks_per_cycle = 0; 776 777 if (rate == NULL) { 778 LOG_ERROR(BSL_LS_SOC_SAT, 779 (BSL_META_U(unit, 780 "Parameter rate is NULL\n"))); 781 rv = SOC_E_PARAM; 782 return rv; 783 } 784 785 /* 1. caculate cycle per sec */ 786 rv = soc_reg_above_64_field64_read(unit, OAMP_TIMER_CONFIGr, REG_PORT_ANY, 0, NUM_CLOCKS_SECf, &field64); 787 if (SOC_FAILURE(rv)) { 788 LOG_ERROR(BSL_LS_SOC_SAT, 789 (BSL_META_U(unit, 790 "Fail(%s) in read OAMP_TIMER_CONFIGr\n"), soc_errmsg(rv))); 791 return rv; 792 } 793 fld_val = COMPILER_64_LO(field64); 794 clocks_per_sec = fld_val; 795 796 rv = soc_reg_above_64_field64_read(unit, OAMP_SAT_GEN_CONFIGr, REG_PORT_ANY, 0, RATE_NUM_CLKS_CYCLEf, &field64); 797 if (SOC_FAILURE(rv)) { 798 LOG_ERROR(BSL_LS_SOC_SAT, 799 (BSL_META_U(unit, 800 "Fail(%s) in read OAMP_SAT_GEN_CONFIGr\n"), soc_errmsg(rv))); 801 return rv; 802 } 803 fld_val = COMPILER_64_LO(field64); 804 clocks_per_cycle = fld_val; 805 806 cycles_per_sec = clocks_per_sec/clocks_per_cycle; 807 808 /* 2. caculate bytes per cycle, given rate(Units: kbps) */ 809 bytes_per_cycle = (rate_mnt_val) * (1<<(rate_exp_val)); 810 811 if ((SOC_IS_QAX(unit)) && flags) { 812 *rate = bytes_per_cycle; 813 }else { 814 /* 3. get rate(Units: kbps) by bytes_per_cycle and cycles_per_sec */ 815 *rate = (bytes_per_cycle * cycles_per_sec) / 125; 816 } 817 818 return rv; 819 } 820 821 soc_error_t soc_sat_general_cfg_init ( 822 SOC_SAND_IN int unit, 823 SOC_SAND_IN soc_sat_init_t *sat_init 824 ) 825 { 826 int rv = SOC_E_NONE; 827 uint64 data; 828 uint32 flow_id_mapping_data = 0; 829 uint32 entry_offset = 0; 830 #ifdef BCM_SAT_GTF_STAT_FIX 831 int i; 832 #endif 833 834 #ifdef BCM_SAT_GTF_STAT_FIX 835 for (i = 0; i < 16; i++) { 836 COMPILER_64_ZERO(soc_sat_data[unit].gtf_stat_value[i]); 837 } 838 #endif 839 840 rv = READ_OAMP_SAT_GEN_CONFIGr(unit, &data); 841 if (SOC_FAILURE(rv)) { 842 LOG_ERROR(BSL_LS_SOC_SAT, 843 (BSL_META_U(unit, 844 "Fail(%s) in read OAMP_SAT_GEN_CONFIGr\n"), soc_errmsg(rv))); 845 return rv; 846 } 847 848 /* 1. number of clocks between pulses for leaky buckets */ 849 soc_reg64_field32_set(unit,OAMP_SAT_GEN_CONFIGr, &data, RATE_NUM_CLKS_CYCLEf, sat_init->rate_num_clks_cycle); 850 851 /* 2. mode of cmic tod IF*/ 852 if (!SOC_IS_QAX(unit)) { 853 soc_reg64_field32_set(unit,OAMP_SAT_GEN_CONFIGr, &data, CMIC_TOD_MODEf, sat_init->cmic_tod_mode); 854 } 855 856 rv = WRITE_OAMP_SAT_GEN_CONFIGr(unit, data); 857 if (SOC_FAILURE(rv)) { 858 LOG_ERROR(BSL_LS_SOC_SAT, 859 (BSL_META_U(unit, 860 "Fail(%s) in write OAMP_SAT_GEN_CONFIGr\n"), soc_errmsg(rv))); 861 return rv; 862 } 863 864 rv = READ_OAMP_TIMER_CONFIGr(unit, &data); 865 if (SOC_FAILURE(rv)) { 866 LOG_ERROR(BSL_LS_SOC_SAT, 867 (BSL_META_U(unit, 868 "Fail(%s) in read OAMP_TIMER_CONFIGr\n"), soc_errmsg(rv))); 869 return rv; 870 } 871 872 /*3. Default value of OAMP_SAT_RX_FLOW_ID table is random, have to add codes to initialize it */ 873 for (entry_offset = 0; entry_offset < soc_mem_index_max(unit, OAMP_SAT_RX_FLOW_IDm); entry_offset++) { 874 rv = WRITE_OAMP_SAT_RX_FLOW_IDm(unit, MEM_BLOCK_ALL, entry_offset, &flow_id_mapping_data); 875 if (SOC_FAILURE(rv)) { 876 LOG_ERROR(BSL_LS_SOC_SAT, 877 (BSL_META_U(unit, 878 "%s\n"), soc_errmsg(rv))); 879 return rv; 880 } 881 } 882 883 /* 4. number of system clock cycles in one second */ 884 soc_reg64_field32_set(unit,OAMP_TIMER_CONFIGr, &data, NUM_CLOCKS_SECf, sat_init->num_clks_sec); 885 #ifdef BCM_SABER2_SUPPORT 886 if(SOC_IS_SABER2(unit)) { 887 uint32 clk_scan; 888 /* 889 Number of system clock cycles in one MEP scan (1.66 ms), 890 Optimize calculation to avoid floating point arithmetic 891 */ 892 clk_scan = (sat_init->num_clks_sec/SOC_SAT_100K_NUM) * SOC_SAT_MEP_100K_SCAN_IN_SEC; 893 soc_reg64_field32_set(unit,OAMP_TIMER_CONFIGr, &data, NUM_CLOCKS_SCANf, clk_scan); 894 } 895 #endif 896 rv = WRITE_OAMP_TIMER_CONFIGr(unit, data); 897 if (SOC_FAILURE(rv)) { 898 LOG_ERROR(BSL_LS_SOC_SAT, 899 (BSL_META_U(unit, 900 "Fail(%s) in write OAMP_TIMER_CONFIGr\n"), soc_errmsg(rv))); 901 } 902 903 return rv; 904 } 905 906 soc_error_t soc_sat_config_set ( 907 SOC_SAND_IN int unit, 908 SOC_SAND_IN soc_sat_config_t* conf 909 ) 910 { 911 uint64 reg_val; 912 uint32 field = 0; 913 int rv = SOC_E_NONE; 914 915 COMPILER_64_ZERO(reg_val); 916 rv = READ_OAMP_SAT_GEN_CONFIGr(unit, ®_val); 917 if (SOC_FAILURE(rv)) { 918 LOG_ERROR(BSL_LS_SOC_SAT, 919 (BSL_META_U(unit, 920 "Fail(%s) in read OAMP_SAT_GEN_CONFIGr\n"), soc_errmsg(rv))); 921 return rv; 922 } 923 field = (conf->timestamp_format == socSATTimestampFormatNTP ? 1 : 0); 924 soc_reg64_field32_set(unit, OAMP_SAT_GEN_CONFIGr, ®_val, USE_NTP_TODf, field); 925 field = (conf->config_flags & SOC_SAT_CONFIG_CRC_REVERSED_DATA ? 1 : 0); 926 soc_reg64_field32_set(unit, OAMP_SAT_GEN_CONFIGr, ®_val, REV_CRC_DATAf, field); 927 field = (conf->config_flags & SOC_SAT_CONFIG_CRC_INVERT ? 1 : 0); 928 soc_reg64_field32_set(unit, OAMP_SAT_GEN_CONFIGr, ®_val, INV_CRC_RESf, field); 929 field = (conf->config_flags & SOC_SAT_CONFIG_CRC_HIGH_RESET ? 1 : 0); 930 soc_reg64_field32_set(unit, OAMP_SAT_GEN_CONFIGr, ®_val, RST_CRC_F_1Z0f, field); 931 field = (conf->config_flags & SOC_SAT_CONFIG_PRBS_USE_NXOR ? 1 : 0); 932 soc_reg64_field32_set(unit, OAMP_SAT_GEN_CONFIGr, ®_val, SAT_PRBS_USE_NXORf, field); 933 if (!SOC_IS_QAX(unit)) { 934 field = (conf->timestamp_format == socSATTimestampFormatNTP ? 2 : 1); 935 soc_reg64_field32_set(unit, OAMP_SAT_GEN_CONFIGr, ®_val, CMIC_TOD_MODEf, field); 936 } 937 rv = WRITE_OAMP_SAT_GEN_CONFIGr(unit, reg_val); 938 if (SOC_FAILURE(rv)) { 939 LOG_ERROR(BSL_LS_SOC_SAT, 940 (BSL_META_U(unit, 941 "Fail(%s) in write OAMP_SAT_GEN_CONFIGr\n"), soc_errmsg(rv))); 942 } 943 944 return rv; 945 } 946 947 soc_error_t soc_sat_config_get ( 948 SOC_SAND_IN int unit, 949 SOC_SAND_OUT soc_sat_config_t* conf 950 ) 951 { 952 int rv = SOC_E_NONE; 953 uint64 reg_val; 954 uint32 field = 0; 955 956 COMPILER_64_ZERO(reg_val); 957 rv = READ_OAMP_SAT_GEN_CONFIGr(unit, ®_val); 958 if (SOC_FAILURE(rv)) { 959 LOG_ERROR(BSL_LS_SOC_SAT, 960 (BSL_META_U(unit, 961 "Fail(%s) in read OAMP_SAT_GEN_CONFIGr\n"), soc_errmsg(rv))); 962 return rv; 963 } 964 field = soc_reg64_field32_get(unit, OAMP_SAT_GEN_CONFIGr, reg_val, USE_NTP_TODf); 965 conf->timestamp_format = (field ? socSATTimestampFormatNTP : socSATTimestampFormatIEEE1588v1); 966 967 field = soc_reg64_field32_get(unit, OAMP_SAT_GEN_CONFIGr, reg_val, REV_CRC_DATAf); 968 if (field) { 969 conf->config_flags |= SOC_SAT_CONFIG_CRC_REVERSED_DATA; 970 } 971 field = soc_reg64_field32_get(unit, OAMP_SAT_GEN_CONFIGr, reg_val, INV_CRC_RESf); 972 if (field) { 973 conf->config_flags |= SOC_SAT_CONFIG_CRC_INVERT; 974 } 975 field = soc_reg64_field32_get(unit, OAMP_SAT_GEN_CONFIGr, reg_val, RST_CRC_F_1Z0f); 976 if (field) { 977 conf->config_flags |= SOC_SAT_CONFIG_CRC_HIGH_RESET; 978 } 979 field = soc_reg64_field32_get(unit, OAMP_SAT_GEN_CONFIGr, reg_val, SAT_PRBS_USE_NXORf); 980 if (field) { 981 conf->config_flags |= SOC_SAT_CONFIG_PRBS_USE_NXOR; 982 } 983 984 return rv; 985 } 986 987 soc_error_t soc_sat_gtf_packet_gen_set ( 988 SOC_SAND_IN int unit, 989 SOC_SAND_IN soc_sat_gtf_t gtf_id, 990 SOC_SAND_IN int priority, 991 SOC_SAND_IN int enable 992 ) 993 { 994 int rv = SOC_E_NONE; 995 soc_reg_above_64_val_t data; 996 int index; 997 int pri = 0, start_pri = 0, stop_pri = 0; 998 #ifdef BCM_SAT_GTF_STAT_FIX 999 uint32 stat_val; 1000 #endif 1001 uint32 rate_pattern_mode = 0; 1002 1003 SOC_REG_ABOVE_64_CLEAR(data); 1004 1005 if (priority == SOC_SAT_GTF_OBJ_COMMON) { 1006 start_pri = SOC_SAT_GTF_OBJ_CIR; 1007 stop_pri = SOC_SAT_GTF_OBJ_EIR + 1; 1008 } 1009 else { 1010 start_pri = priority; 1011 stop_pri = start_pri + 1; 1012 } 1013 1014 /* set packet gen for specified generator */ 1015 for (pri = start_pri; pri < stop_pri; pri++) { 1016 index = SAT_TX_PER_GENERATOR_INDX(gtf_id, pri); 1017 1018 rv = READ_OAMP_SAT_GEN_RATE_CONTROLr(unit, index, data); 1019 if (SOC_FAILURE(rv)) { 1020 LOG_ERROR(BSL_LS_SOC_SAT, 1021 (BSL_META_U(unit, 1022 "Fail(%s) in read OAMP_SAT_GEN_RATE_CONTROLr\n"), soc_errmsg(rv))); 1023 return rv; 1024 } 1025 rate_pattern_mode = soc_reg_above_64_field32_get(unit, OAMP_SAT_GEN_RATE_CONTROLr, data, BURST_MODE__Nf); 1026 1027 /*Combined mode*/ 1028 if (( rate_pattern_mode == 1)&&( enable == 1)) { 1029 /* Ratepattern mode need to reset the ITER CNT*/ 1030 soc_reg_above_64_field32_set(unit, OAMP_SAT_GEN_RATE_CONTROLr, data, STOP_ITER_CNT_RST__Nf, 1); 1031 rv = WRITE_OAMP_SAT_GEN_RATE_CONTROLr(unit, index, data); 1032 if (SOC_FAILURE(rv)) { 1033 LOG_ERROR(BSL_LS_SOC_SAT, 1034 (BSL_META_U(unit,"Fail(%s) in write OAMP_SAT_GEN_RATE_CONTROLr\n"), soc_errmsg(rv))); 1035 return rv; 1036 } 1037 1038 rv = READ_OAMP_SAT_GEN_RATE_CONTROLr(unit, index, data); 1039 if (SOC_FAILURE(rv)) { 1040 LOG_ERROR(BSL_LS_SOC_SAT, 1041 (BSL_META_U(unit, 1042 "Fail(%s) in read OAMP_SAT_GEN_RATE_CONTROLr\n"), soc_errmsg(rv))); 1043 return rv; 1044 } 1045 soc_reg_above_64_field32_set(unit, OAMP_SAT_GEN_RATE_CONTROLr, data, STOP_ITER_CNT_RST__Nf, 0); 1046 rv = WRITE_OAMP_SAT_GEN_RATE_CONTROLr(unit, index, data); 1047 if (SOC_FAILURE(rv)) { 1048 LOG_ERROR(BSL_LS_SOC_SAT, 1049 (BSL_META_U(unit,"Fail(%s) in write OAMP_SAT_GEN_RATE_CONTROLr\n"), soc_errmsg(rv))); 1050 return rv; 1051 } 1052 } 1053 1054 #ifdef BCM_SAT_GTF_STAT_FIX 1055 if (!SOC_IS_QAX(unit)) { 1056 stat_val = soc_reg_above_64_field32_get(unit, OAMP_SAT_GEN_RATE_CONTROLr, data, PACKET_COUNT__Nf); 1057 COMPILER_64_ADD_32(soc_sat_data[unit].gtf_stat_value[index], stat_val); 1058 } 1059 #endif 1060 soc_reg_above_64_field32_set(unit, OAMP_SAT_GEN_RATE_CONTROLr, data, PKT_GEN_EN__Nf, enable); 1061 rv = WRITE_OAMP_SAT_GEN_RATE_CONTROLr(unit, index, data); 1062 if (SOC_FAILURE(rv)) { 1063 LOG_ERROR(BSL_LS_SOC_SAT, 1064 (BSL_META_U(unit, 1065 "Fail(%s) in write OAMP_SAT_GEN_RATE_CONTROLr\n"), soc_errmsg(rv))); 1066 return rv; 1067 } 1068 } 1069 1070 return rv; 1071 } 1072 1073 soc_error_t soc_sat_gtf_packet_gen_get ( 1074 SOC_SAND_IN int unit, 1075 SOC_SAND_IN soc_sat_gtf_t gtf_id, 1076 SOC_SAND_IN int priority, 1077 SOC_SAND_OUT int *enable 1078 ) 1079 { 1080 int rv = SOC_E_NONE; 1081 soc_reg_above_64_val_t data; 1082 int index; 1083 #ifdef BCM_SAT_GTF_STAT_FIX 1084 uint32 stat_val; 1085 #endif 1086 1087 SOC_REG_ABOVE_64_CLEAR(data); 1088 1089 if (priority == SOC_SAT_GTF_OBJ_COMMON) { 1090 rv = SOC_E_PARAM; 1091 LOG_ERROR(BSL_LS_SOC_SAT, 1092 (BSL_META_U(unit, 1093 "Fail(%s): priority for soc_sat_gtf_packet_gen_get should be one of %d and %d \n"), soc_errmsg(rv), SOC_SAT_GTF_OBJ_CIR, SOC_SAT_GTF_OBJ_EIR)); 1094 return rv; 1095 } 1096 1097 /* get packet gen from specified generator */ 1098 index = SAT_TX_PER_GENERATOR_INDX(gtf_id, priority); 1099 1100 rv = READ_OAMP_SAT_GEN_RATE_CONTROLr(unit, index, data); 1101 if (SOC_FAILURE(rv)) { 1102 LOG_ERROR(BSL_LS_SOC_SAT, 1103 (BSL_META_U(unit, 1104 "Fail(%s) in read OAMP_SAT_GEN_RATE_CONTROLr\n"), soc_errmsg(rv))); 1105 return rv; 1106 } 1107 #ifdef BCM_SAT_GTF_STAT_FIX 1108 if (!SOC_IS_QAX(unit)) { 1109 stat_val = soc_reg_above_64_field32_get(unit, OAMP_SAT_GEN_RATE_CONTROLr, data, PACKET_COUNT__Nf); 1110 COMPILER_64_ADD_32(soc_sat_data[unit].gtf_stat_value[index], stat_val); 1111 } 1112 #endif 1113 (*enable) = soc_reg_above_64_field32_get(unit,OAMP_SAT_GEN_RATE_CONTROLr, data, PKT_GEN_EN__Nf); 1114 1115 return rv; 1116 } 1117 1118 soc_error_t soc_sat_gtf_packet_config ( 1119 SOC_SAND_IN int unit, 1120 SOC_SAND_IN soc_sat_gtf_t gtf_id, 1121 SOC_SAND_IN soc_sat_gtf_packet_config_t *config 1122 ) 1123 { 1124 int rv = SOC_E_NONE; 1125 soc_reg_above_64_val_t tx_evc_params_entry_1_data, tx_evc_params_entry_2_data; 1126 soc_reg_above_64_val_t evc_rate_control_data; 1127 uint32 field_data; 1128 soc_field_t pkt_length_fields[SOC_SAT_GTF_PACKET_LENGTH_NUM_OF_PATTERNS] = { 1129 PKT_LENGTH_0f, 1130 PKT_LENGTH_1f, 1131 PKT_LENGTH_2f, 1132 PKT_LENGTH_3f, 1133 PKT_LENGTH_4f, 1134 PKT_LENGTH_5f, 1135 PKT_LENGTH_6f, 1136 PKT_LENGTH_7f}; 1137 _soc_sat_gtf_pkt_hdr_tbl_info_t pkt_hdr_tbl_info; 1138 uint32 payload_rpt_pattern[SOC_SAT_PAYLOAD_MAX_PATTERN_NOF_U32] = {0}; 1139 uint32 payload_type; 1140 uint32 length_pattern[SOC_SAT_PKT_LENGTH_PATTERN_FIELD_SIZE] = {0}; 1141 _soc_sat_gtf_stamp_field_tbl_info_t stamp_field_info[SOC_SAT_GTF_NUM_OF_PRIORITIES]; 1142 uint32 sequence_ena[SOC_SAT_GTF_NUM_OF_PRIORITIES] = {0}, sequence_offset[SOC_SAT_GTF_NUM_OF_PRIORITIES] = {0}, sequence_period[SOC_SAT_GTF_NUM_OF_PRIORITIES] = {0}; 1143 uint32 pkt_add_crc[SOC_SAT_GTF_NUM_OF_PRIORITIES] = {0}, crc_offset[SOC_SAT_GTF_NUM_OF_PRIORITIES] = {0}; 1144 uint32 pkt_add_tlv = 0; 1145 uint32 offset = 0; 1146 int i = 0; 1147 int priority = 0; 1148 soc_mem_t sat_tx_evc_prm1_mem; 1149 soc_mem_t sat_tx_evc_prm2_mem; 1150 1151 /* 1.1 prepare packet header */ 1152 sal_memset(&pkt_hdr_tbl_info, 0, sizeof(pkt_hdr_tbl_info)); 1153 rv = _soc_sat_gtf_construct_packet_header(unit, &(config->header_info), &pkt_hdr_tbl_info); 1154 if (SOC_FAILURE(rv)) { 1155 LOG_ERROR(BSL_LS_SOC_SAT, 1156 (BSL_META_U(unit, 1157 "Fail(%s) in _soc_sat_gtf_construct_packet_header\n"), soc_errmsg(rv))); 1158 return rv; 1159 } 1160 1161 /* 1.2 prepare payload */ 1162 if (config->payload.payload_type == socSatPayloadConstant8Bytes) { 1163 rv = soc_sat_packet_config_exp_payload_uint8_to_long(config->payload.payload_pattern, SOC_SAT_PAYLOAD_MAX_PATTERN_NOF_U8, 0, payload_rpt_pattern); 1164 if (SOC_FAILURE(rv)) { 1165 LOG_ERROR(BSL_LS_SOC_SAT, 1166 (BSL_META_U(unit, 1167 "Fail(%s) in soc_sat_packet_config_exp_payload_uint8_to_long\n"), soc_errmsg(rv))); 1168 return rv; 1169 } 1170 payload_type = 0; 1171 } 1172 else if (config->payload.payload_type == socSatPayloadConstant4Bytes) { 1173 rv = soc_sat_packet_config_exp_payload_uint8_to_long(config->payload.payload_pattern, SOC_SAT_PAYLOAD_MAX_PATTERN_NOF_U8/2, 0, payload_rpt_pattern); 1174 if (SOC_FAILURE(rv)) { 1175 LOG_ERROR(BSL_LS_SOC_SAT, 1176 (BSL_META_U(unit, 1177 "Fail(%s) in soc_sat_packet_config_exp_payload_uint8_to_long\n"), soc_errmsg(rv))); 1178 return rv; 1179 } 1180 payload_type = 1; 1181 } 1182 else if (config->payload.payload_type == socSatPayloadPRBS) { 1183 payload_type = 2; 1184 } 1185 else { 1186 LOG_ERROR(BSL_LS_SOC_SAT, 1187 (BSL_META_U(unit, 1188 "Invalid payload type(%d)\n"), config->payload.payload_type)); 1189 return SOC_E_PARAM; 1190 } 1191 for (priority = 0; priority < SOC_SAT_GTF_NUM_OF_PRIORITIES; priority++) { 1192 /* 1.3 prepare stamp */ 1193 sal_memset(&(stamp_field_info[priority]), 0, sizeof(stamp_field_info[priority])); 1194 rv = _soc_sat_gtf_construct_stamp_field(unit, &(config->packet_edit[priority]), &(stamp_field_info[priority])); 1195 if (SOC_FAILURE(rv)) { 1196 LOG_ERROR(BSL_LS_SOC_SAT, 1197 (BSL_META_U(unit, 1198 "Fail(%s) in _soc_sat_gtf_construct_stamp_field\n"), soc_errmsg(rv))); 1199 return rv; 1200 } 1201 1202 /* 1.4 prepare sequence */ 1203 if (config->offsets.seq_number_offset != SOC_SAT_GTF_SEQ_NUM_DISABLE) { 1204 sequence_ena[priority] = 1; 1205 sequence_offset[priority] = config->offsets.seq_number_offset; 1206 sequence_period[priority] = config->packet_edit[priority].number_of_ctfs - 1; 1207 } 1208 else { 1209 sequence_ena[priority] = 0; 1210 } 1211 1212 /* 1.5 prepare tlv and crc */ 1213 if (config->packet_edit[priority].flags & SOC_SAT_GTF_PACKET_EDIT_ADD_END_TLV) { 1214 pkt_add_tlv = 1; 1215 } 1216 else { 1217 pkt_add_tlv = 0; 1218 } 1219 1220 if (config->packet_edit[priority].flags & SOC_SAT_GTF_PACKET_EDIT_ADD_CRC) { 1221 pkt_add_crc[priority] = 1; 1222 crc_offset[priority] = config->offsets.crc_byte_offset; 1223 } 1224 else { 1225 pkt_add_crc[priority] = 0; 1226 } 1227 } 1228 1229 /* 2.1 set header and payload info */ 1230 1231 /* For writing on dynamic tables (in the OAMP), have to enable dynamic memory access */ 1232 rv = soc_sat_dynamic_memory_access_set(unit, 1); 1233 if (SOC_FAILURE(rv)) { 1234 LOG_ERROR(BSL_LS_SOC_SAT, 1235 (BSL_META_U(unit, 1236 "Fail(%s) in soc_sat_dynamic_memory_access_set\n"), soc_errmsg(rv))); 1237 return rv; 1238 } 1239 1240 sat_tx_evc_prm1_mem = SOC_IS_QAX(unit) ? OAMP_SAT_TX_EVC_PRM_ENTRY_1m : OAMP_SAT_TX_EVC_PARAMS_ENTRY_1m; 1241 sat_tx_evc_prm2_mem = SOC_IS_QAX(unit) ? OAMP_SAT_TX_EVC_PRM_ENTRY_2m : OAMP_SAT_TX_EVC_PARAMS_ENTRY_2m; 1242 /* Per evc parameters, two memory entries are needed: odd entries */ 1243 rv = soc_mem_read(unit, sat_tx_evc_prm1_mem, MEM_BLOCK_ANY, SAT_TX_EVC_PARAMS_ENTRY_1_TBL_INDX(gtf_id), tx_evc_params_entry_1_data); 1244 if (SOC_FAILURE(rv)) { 1245 LOG_ERROR(BSL_LS_SOC_SAT, 1246 (BSL_META_U(unit, 1247 "Fail(%s) in read sat_tx_evc_prm1_mem\n"), soc_errmsg(rv))); 1248 goto exit; 1249 } 1250 /* PKT_HEADER_LSBf */ 1251 soc_mem_field_set(unit, sat_tx_evc_prm1_mem, tx_evc_params_entry_1_data, PKT_HEADER_LSBf, pkt_hdr_tbl_info.pkt_hdr_lsb); 1252 rv = soc_mem_write(unit, sat_tx_evc_prm1_mem, MEM_BLOCK_ANY, SAT_TX_EVC_PARAMS_ENTRY_1_TBL_INDX(gtf_id), tx_evc_params_entry_1_data); 1253 if (SOC_FAILURE(rv)) { 1254 LOG_ERROR(BSL_LS_SOC_SAT, 1255 (BSL_META_U(unit, 1256 "Fail(%s) in write sat_tx_evc_prm1_mem\n"), soc_errmsg(rv))); 1257 goto exit; 1258 } 1259 1260 1261 /* Per evc parameters, two memory entries are needed: odd entries */ 1262 rv = soc_mem_read(unit, sat_tx_evc_prm2_mem, MEM_BLOCK_ANY, SAT_TX_EVC_PARAMS_ENTRY_2_TBL_INDX(gtf_id), tx_evc_params_entry_2_data); 1263 if (SOC_FAILURE(rv)) { 1264 LOG_ERROR(BSL_LS_SOC_SAT, 1265 (BSL_META_U(unit, 1266 "Fail(%s) in read sat_tx_evc_prm2_mem\n"), soc_errmsg(rv))); 1267 goto exit; 1268 } 1269 1270 soc_mem_field_set(unit, sat_tx_evc_prm2_mem, tx_evc_params_entry_2_data, PKT_HEADER_MSBf, pkt_hdr_tbl_info.pkt_hdr_msb); 1271 soc_mem_field_set(unit, sat_tx_evc_prm2_mem, tx_evc_params_entry_2_data, PKT_HEADER_LENGTHf, &(pkt_hdr_tbl_info.pkt_hdr_len)); 1272 soc_mem_field_set(unit, sat_tx_evc_prm2_mem, tx_evc_params_entry_2_data, RPT_PATTERNf, payload_rpt_pattern); 1273 soc_mem_field_set(unit, sat_tx_evc_prm2_mem, tx_evc_params_entry_2_data, PAYLOAD_TYPEf, &payload_type); 1274 1275 rv = soc_mem_write(unit, sat_tx_evc_prm2_mem, MEM_BLOCK_ANY, SAT_TX_EVC_PARAMS_ENTRY_2_TBL_INDX(gtf_id), tx_evc_params_entry_2_data); 1276 if (SOC_FAILURE(rv)) { 1277 LOG_ERROR(BSL_LS_SOC_SAT, 1278 (BSL_META_U(unit, 1279 "Fail(%s) in write sat_tx_evc_prm2_mem\n"), soc_errmsg(rv))); 1280 goto exit; 1281 } 1282 1283 /* 2.2 set length, pattern, stamp, sequence, tlv and crc */ 1284 if (SOC_IS_QAX(unit)) { 1285 soc_reg_above_64_val_t tx_gen_prm_entry1_data; 1286 soc_reg_above_64_val_t tx_gen_prm_entry2_data; 1287 for (priority = 0; priority < SOC_SAT_GTF_NUM_OF_PRIORITIES; priority++) { 1288 rv = READ_OAMP_SAT_TX_GEN_PRM_ENTRY_1m(unit, MEM_BLOCK_ANY, SAT_TX_GEN_PRM_ENTRY_1_TBL_INDX(gtf_id, priority), tx_gen_prm_entry1_data); 1289 if (SOC_FAILURE(rv)) { 1290 LOG_ERROR(BSL_LS_SOC_SAT, 1291 (BSL_META_U(unit, 1292 "Fail(%s) in read OAMP_SAT_TX_GEN_PRM_ENTRY_1m\n"), soc_errmsg(rv))); 1293 goto exit; 1294 } 1295 1296 rv = READ_OAMP_SAT_TX_GEN_PRM_ENTRY_2m(unit, MEM_BLOCK_ANY, SAT_TX_GEN_PRM_ENTRY_2_TBL_INDX(gtf_id, priority), tx_gen_prm_entry2_data); 1297 if (SOC_FAILURE(rv)) { 1298 LOG_ERROR(BSL_LS_SOC_SAT, 1299 (BSL_META_U(unit, 1300 "Fail(%s) in read OAMP_SAT_TX_GEN_PRM_ENTRY_2m\n"), soc_errmsg(rv))); 1301 goto exit; 1302 } 1303 1304 /* PKT_LENGTH_XXXf */ 1305 for (i = 0; i < SOC_SAT_GTF_PACKET_LENGTH_NUM_OF_PATTERNS; i++) { 1306 field_data = config->packet_edit[priority].packet_length[i]; 1307 soc_mem_field_set(unit, OAMP_SAT_TX_GEN_PRM_ENTRY_1m, tx_gen_prm_entry1_data, pkt_length_fields[i], &field_data); 1308 } 1309 soc_mem_field_set(unit, OAMP_SAT_TX_GEN_PRM_ENTRY_2m, tx_gen_prm_entry2_data, PKT_LENGTH_NEXTf, (uint32*)&(config->packet_edit[priority].packet_length[0])); 1310 1311 /* LENGTH_PATTERNf */ 1312 offset = 0; 1313 for (i = 0; i < config->packet_edit[priority].pattern_length; i++) { 1314 SHR_BITCOPY_RANGE(length_pattern, offset, &(config->packet_edit[priority].packet_length_pattern[i]), 0, 3); 1315 offset += 3; 1316 } 1317 soc_mem_field_set(unit, OAMP_SAT_TX_GEN_PRM_ENTRY_1m, tx_gen_prm_entry1_data, LENGTH_PATTERNf, length_pattern); 1318 field_data = config->packet_edit[priority].pattern_length - 1; 1319 soc_mem_field_set(unit, OAMP_SAT_TX_GEN_PRM_ENTRY_1m, tx_gen_prm_entry1_data, LENGTH_PATTERN_SIZEf, &field_data); 1320 1321 /* STMP_2_BIT_XXXf */ 1322 soc_mem_field_set(unit, OAMP_SAT_TX_GEN_PRM_ENTRY_1m, tx_gen_prm_entry1_data, STMP_2_BIT_ENABLEf, &(stamp_field_info[priority].stamp_2_ena)); 1323 if (stamp_field_info[priority].stamp_2_ena != 0) { 1324 soc_mem_field_set(unit, OAMP_SAT_TX_GEN_PRM_ENTRY_1m, tx_gen_prm_entry1_data, STMP_2_BIT_OFFSETf, &(stamp_field_info[priority].stamp_2_offset)); 1325 soc_mem_field_set(unit, OAMP_SAT_TX_GEN_PRM_ENTRY_1m, tx_gen_prm_entry1_data, STMP_2_BIT_SHIFTf, &(stamp_field_info[priority].stamp_2_shift)); 1326 soc_mem_field_set(unit, OAMP_SAT_TX_GEN_PRM_ENTRY_1m, tx_gen_prm_entry1_data, STMP_2_BIT_VALUEf, &(stamp_field_info[priority].stamp_2_value)); 1327 } 1328 /* CNTR_8_BIT_XXXf */ 1329 soc_mem_field_set(unit, OAMP_SAT_TX_GEN_PRM_ENTRY_1m, tx_gen_prm_entry1_data, CNTR_8_BIT_ENABLEf, &(stamp_field_info[priority].counter_8_ena)); 1330 if (stamp_field_info[priority].counter_8_ena != 0) { 1331 soc_mem_field_set(unit, OAMP_SAT_TX_GEN_PRM_ENTRY_1m, tx_gen_prm_entry1_data, CNTR_8_BIT_OFFSETf, &(stamp_field_info[priority].counter_8_offset)); 1332 soc_mem_field_set(unit, OAMP_SAT_TX_GEN_PRM_ENTRY_1m, tx_gen_prm_entry1_data, CNTR_8_BIT_SHIFTf, &(stamp_field_info[priority].counter_8_shift)); 1333 soc_mem_field_set(unit, OAMP_SAT_TX_GEN_PRM_ENTRY_1m, tx_gen_prm_entry1_data, CNTR_8_BIT_MASKf, &(stamp_field_info[priority].counter_8_mask)); 1334 soc_mem_field_set(unit, OAMP_SAT_TX_GEN_PRM_ENTRY_1m, tx_gen_prm_entry1_data, CNTR_8_BIT_INC_STEPf, &(stamp_field_info[priority].counter_8_inc_step)); 1335 soc_mem_field_set(unit, OAMP_SAT_TX_GEN_PRM_ENTRY_1m, tx_gen_prm_entry1_data, CNTR_8_BIT_PERIODf, &(stamp_field_info[priority].counter_8_period)); 1336 field_data = 0x0; 1337 soc_mem_field32_set(unit, OAMP_SAT_TX_GEN_PRM_ENTRY_2m, tx_gen_prm_entry2_data, CNTR_8_BIT_NEXT_VALUEf, field_data); 1338 } 1339 /* CNTR_16_BIT_XXXf */ 1340 soc_mem_field_set(unit, OAMP_SAT_TX_GEN_PRM_ENTRY_1m, tx_gen_prm_entry1_data, CNTR_16_BIT_ENABLEf, &(stamp_field_info[priority].counter_16_ena)); 1341 if (stamp_field_info[priority].counter_16_ena != 0) { 1342 soc_mem_field_set(unit, OAMP_SAT_TX_GEN_PRM_ENTRY_1m, tx_gen_prm_entry1_data, CNTR_16_BIT_OFFSETf, &(stamp_field_info[priority].counter_16_offset)); 1343 soc_mem_field_set(unit, OAMP_SAT_TX_GEN_PRM_ENTRY_1m, tx_gen_prm_entry1_data, CNTR_16_BIT_SHIFTf, &(stamp_field_info[priority].counter_16_shift)); 1344 soc_mem_field_set(unit, OAMP_SAT_TX_GEN_PRM_ENTRY_1m, tx_gen_prm_entry1_data, CNTR_16_BIT_MASKf, &(stamp_field_info[priority].counter_16_mask)); 1345 soc_mem_field_set(unit, OAMP_SAT_TX_GEN_PRM_ENTRY_1m, tx_gen_prm_entry1_data, CNTR_16_BIT_INC_STEPf, &(stamp_field_info[priority].counter_16_inc_step)); 1346 soc_mem_field_set(unit, OAMP_SAT_TX_GEN_PRM_ENTRY_1m, tx_gen_prm_entry1_data, CNTR_16_BIT_PERIODf, &(stamp_field_info[priority].counter_16_period)); 1347 field_data = 0x0; 1348 soc_mem_field32_set(unit, OAMP_SAT_TX_GEN_PRM_ENTRY_2m, tx_gen_prm_entry2_data, CNTR_16_BIT_NEXT_VALUEf, field_data); 1349 } 1350 /* SEQ_NUM_XXXf */ 1351 soc_mem_field_set(unit, OAMP_SAT_TX_GEN_PRM_ENTRY_1m, tx_gen_prm_entry1_data, SEQ_NUM_ENABLEf, &(sequence_ena[priority])); 1352 if (sequence_ena[priority] == 1) { 1353 soc_mem_field_set(unit, OAMP_SAT_TX_GEN_PRM_ENTRY_1m, tx_gen_prm_entry1_data, SEQ_NUM_PERIODf, &(sequence_period[priority])); 1354 soc_mem_field_set(unit, OAMP_SAT_TX_GEN_PRM_ENTRY_1m, tx_gen_prm_entry1_data, SEQ_NUM_OFFSETf, &(sequence_offset[priority])); 1355 field_data = 0; 1356 soc_mem_field32_set(unit, OAMP_SAT_TX_GEN_PRM_ENTRY_2m, tx_gen_prm_entry2_data, SEQ_NUM_NXT_VALUEf, field_data); 1357 } 1358 1359 soc_mem_field_set(unit, OAMP_SAT_TX_GEN_PRM_ENTRY_1m, tx_gen_prm_entry1_data, ADD_END_TLVf, &pkt_add_tlv); 1360 soc_mem_field_set(unit, OAMP_SAT_TX_GEN_PRM_ENTRY_1m, tx_gen_prm_entry1_data, CRC_32_ENABLEf, &(pkt_add_crc[priority])); 1361 if (pkt_add_crc[priority] == 1) { 1362 soc_mem_field_set(unit, OAMP_SAT_TX_GEN_PRM_ENTRY_1m, tx_gen_prm_entry1_data, CRC_32_OFFSETf, &(crc_offset[priority])); 1363 } 1364 1365 /* set sat packet as non-TDM packet && set src channel to 0 */ 1366 field_data = 0; 1367 soc_mem_field32_set(unit, OAMP_SAT_TX_GEN_PRM_ENTRY_2m, tx_gen_prm_entry2_data, CHAN_NUMf, field_data); 1368 1369 rv = WRITE_OAMP_SAT_TX_GEN_PRM_ENTRY_1m(unit, MEM_BLOCK_ANY, SAT_TX_GEN_PRM_ENTRY_1_TBL_INDX(gtf_id, priority), tx_gen_prm_entry1_data); 1370 if (SOC_FAILURE(rv)) { 1371 LOG_ERROR(BSL_LS_SOC_SAT, 1372 (BSL_META_U(unit, 1373 "Fail(%s) in write OAMP_SAT_TX_GEN_PRM_ENTRY_1m\n"), soc_errmsg(rv))); 1374 goto exit; 1375 } 1376 1377 rv = WRITE_OAMP_SAT_TX_GEN_PRM_ENTRY_2m(unit, MEM_BLOCK_ANY, SAT_TX_GEN_PRM_ENTRY_2_TBL_INDX(gtf_id, priority), tx_gen_prm_entry2_data); 1378 if (SOC_FAILURE(rv)) { 1379 LOG_ERROR(BSL_LS_SOC_SAT, 1380 (BSL_META_U(unit, 1381 "Fail(%s) in write OAMP_SAT_TX_GEN_PRM_ENTRY_2m\n"), soc_errmsg(rv))); 1382 goto exit; 1383 } 1384 } 1385 }else { 1386 soc_reg_above_64_val_t tx_gen_params_data; 1387 for (priority = 0; priority < SOC_SAT_GTF_NUM_OF_PRIORITIES; priority++) { 1388 rv = READ_OAMP_SAT_TX_GEN_PARAMSm(unit, MEM_BLOCK_ANY, SAT_TX_GEN_PARAMS_TBL_INDX(gtf_id, priority), tx_gen_params_data); 1389 if (SOC_FAILURE(rv)) { 1390 LOG_ERROR(BSL_LS_SOC_SAT, 1391 (BSL_META_U(unit, 1392 "Fail(%s) in read OAMP_SAT_TX_GEN_PARAMSm\n"), soc_errmsg(rv))); 1393 goto exit; 1394 } 1395 1396 /* PKT_LENGTH_XXXf */ 1397 for (i = 0; i < SOC_SAT_GTF_PACKET_LENGTH_NUM_OF_PATTERNS; i++) { 1398 field_data = config->packet_edit[priority].packet_length[i]; 1399 soc_mem_field_set(unit, OAMP_SAT_TX_GEN_PARAMSm, tx_gen_params_data, pkt_length_fields[i], &field_data); 1400 } 1401 soc_mem_field_set(unit, OAMP_SAT_TX_GEN_PARAMSm, tx_gen_params_data, PKT_LENGTH_NEXTf, (uint32*)&(config->packet_edit[priority].packet_length[0])); 1402 1403 /* LENGTH_PATTERNf */ 1404 offset = 0; 1405 for (i = 0; i < config->packet_edit[priority].pattern_length; i++) { 1406 SHR_BITCOPY_RANGE(length_pattern, offset, &(config->packet_edit[priority].packet_length_pattern[i]), 0, 3); 1407 offset += 3; 1408 } 1409 soc_mem_field_set(unit, OAMP_SAT_TX_GEN_PARAMSm, tx_gen_params_data, LENGTH_PATTERNf, length_pattern); 1410 field_data = config->packet_edit[priority].pattern_length - 1; 1411 soc_mem_field_set(unit, OAMP_SAT_TX_GEN_PARAMSm, tx_gen_params_data, LENGTH_PATTERN_SIZEf, &field_data); 1412 1413 /* STMP_2_BIT_XXXf */ 1414 soc_mem_field_set(unit, OAMP_SAT_TX_GEN_PARAMSm, tx_gen_params_data, STMP_2_BIT_ENABLEf, &(stamp_field_info[priority].stamp_2_ena)); 1415 if (stamp_field_info[priority].stamp_2_ena != 0) { 1416 soc_mem_field_set(unit, OAMP_SAT_TX_GEN_PARAMSm, tx_gen_params_data, STMP_2_BIT_OFFSETf, &(stamp_field_info[priority].stamp_2_offset)); 1417 soc_mem_field_set(unit, OAMP_SAT_TX_GEN_PARAMSm, tx_gen_params_data, STMP_2_BIT_SHIFTf, &(stamp_field_info[priority].stamp_2_shift)); 1418 soc_mem_field_set(unit, OAMP_SAT_TX_GEN_PARAMSm, tx_gen_params_data, STMP_2_BIT_VALUEf, &(stamp_field_info[priority].stamp_2_value)); 1419 } 1420 /* CNTR_8_BIT_XXXf */ 1421 soc_mem_field_set(unit, OAMP_SAT_TX_GEN_PARAMSm, tx_gen_params_data, CNTR_8_BIT_ENABLEf, &(stamp_field_info[priority].counter_8_ena)); 1422 if (stamp_field_info[priority].counter_8_ena != 0) { 1423 soc_mem_field_set(unit, OAMP_SAT_TX_GEN_PARAMSm, tx_gen_params_data, CNTR_8_BIT_OFFSETf, &(stamp_field_info[priority].counter_8_offset)); 1424 soc_mem_field_set(unit, OAMP_SAT_TX_GEN_PARAMSm, tx_gen_params_data, CNTR_8_BIT_SHIFTf, &(stamp_field_info[priority].counter_8_shift)); 1425 soc_mem_field_set(unit, OAMP_SAT_TX_GEN_PARAMSm, tx_gen_params_data, CNTR_8_BIT_MASKf, &(stamp_field_info[priority].counter_8_mask)); 1426 soc_mem_field_set(unit, OAMP_SAT_TX_GEN_PARAMSm, tx_gen_params_data, CNTR_8_BIT_INC_STEPf, &(stamp_field_info[priority].counter_8_inc_step)); 1427 soc_mem_field_set(unit, OAMP_SAT_TX_GEN_PARAMSm, tx_gen_params_data, CNTR_8_BIT_PERIODf, &(stamp_field_info[priority].counter_8_period)); 1428 field_data = 0x0; 1429 soc_mem_field32_set(unit, OAMP_SAT_TX_GEN_PARAMSm, tx_gen_params_data, CNTR_8_BIT_NEXT_VALUEf, field_data); 1430 } 1431 /* CNTR_16_BIT_XXXf */ 1432 soc_mem_field_set(unit, OAMP_SAT_TX_GEN_PARAMSm, tx_gen_params_data, CNTR_16_BIT_ENABLEf, &(stamp_field_info[priority].counter_16_ena)); 1433 if (stamp_field_info[priority].counter_16_ena != 0) { 1434 soc_mem_field_set(unit, OAMP_SAT_TX_GEN_PARAMSm, tx_gen_params_data, CNTR_16_BIT_OFFSETf, &(stamp_field_info[priority].counter_16_offset)); 1435 soc_mem_field_set(unit, OAMP_SAT_TX_GEN_PARAMSm, tx_gen_params_data, CNTR_16_BIT_SHIFTf, &(stamp_field_info[priority].counter_16_shift)); 1436 soc_mem_field_set(unit, OAMP_SAT_TX_GEN_PARAMSm, tx_gen_params_data, CNTR_16_BIT_MASKf, &(stamp_field_info[priority].counter_16_mask)); 1437 soc_mem_field_set(unit, OAMP_SAT_TX_GEN_PARAMSm, tx_gen_params_data, CNTR_16_BIT_INC_STEPf, &(stamp_field_info[priority].counter_16_inc_step)); 1438 soc_mem_field_set(unit, OAMP_SAT_TX_GEN_PARAMSm, tx_gen_params_data, CNTR_16_BIT_PERIODf, &(stamp_field_info[priority].counter_16_period)); 1439 field_data = 0x0; 1440 soc_mem_field32_set(unit, OAMP_SAT_TX_GEN_PARAMSm, tx_gen_params_data, CNTR_16_BIT_NEXT_VALUEf, field_data); 1441 } 1442 /* SEQ_NUM_XXXf */ 1443 soc_mem_field_set(unit, OAMP_SAT_TX_GEN_PARAMSm, tx_gen_params_data, SEQ_NUM_ENABLEf, &(sequence_ena[priority])); 1444 if (sequence_ena[priority] == 1) { 1445 soc_mem_field_set(unit, OAMP_SAT_TX_GEN_PARAMSm, tx_gen_params_data, SEQ_NUM_PERIODf, &(sequence_period[priority])); 1446 soc_mem_field_set(unit, OAMP_SAT_TX_GEN_PARAMSm, tx_gen_params_data, SEQ_NUM_OFFSETf, &(sequence_offset[priority])); 1447 field_data = 0; 1448 soc_mem_field32_set(unit, OAMP_SAT_TX_GEN_PARAMSm, tx_gen_params_data, SEQ_NUM_NXT_VALUEf, field_data); 1449 } 1450 1451 soc_mem_field_set(unit, OAMP_SAT_TX_GEN_PARAMSm, tx_gen_params_data, ADD_END_TLVf, &pkt_add_tlv); 1452 soc_mem_field_set(unit, OAMP_SAT_TX_GEN_PARAMSm, tx_gen_params_data, CRC_32_ENABLEf, &(pkt_add_crc[priority])); 1453 if (pkt_add_crc[priority] == 1) { 1454 soc_mem_field_set(unit, OAMP_SAT_TX_GEN_PARAMSm, tx_gen_params_data, CRC_32_OFFSETf, &(crc_offset[priority])); 1455 } 1456 1457 rv = WRITE_OAMP_SAT_TX_GEN_PARAMSm(unit, MEM_BLOCK_ANY, SAT_TX_GEN_PARAMS_TBL_INDX(gtf_id, priority), tx_gen_params_data); 1458 if (SOC_FAILURE(rv)) { 1459 LOG_ERROR(BSL_LS_SOC_SAT, 1460 (BSL_META_U(unit, 1461 "Fail(%s) in write OAMP_SAT_TX_GEN_PARAMSm\n"), soc_errmsg(rv))); 1462 goto exit; 1463 } 1464 } 1465 } 1466 /* 2.3 set packet_context_id */ 1467 if (SOC_IS_JERICHO(unit) && !SOC_IS_QAX(unit) ) { 1468 rv = soc_reg_above_64_get(unit, OAMP_SAT_EVC_RATE_CONTROLr, REG_PORT_ANY, SAT_TX_PER_EVC_INDX(gtf_id), evc_rate_control_data); 1469 if (SOC_FAILURE(rv)) { 1470 LOG_ERROR(BSL_LS_SOC_SAT, 1471 (BSL_META_U(unit, 1472 "Fail(%s) in read OAMP_SAT_EVC_RATE_CONTROLr\n"), soc_errmsg(rv))); 1473 goto exit; 1474 } 1475 soc_reg_above_64_field32_set(unit, OAMP_SAT_EVC_RATE_CONTROLr, evc_rate_control_data, PIPE_ID_EVC__Nf, config->packet_context_id); 1476 rv = soc_reg_above_64_set(unit, OAMP_SAT_EVC_RATE_CONTROLr, REG_PORT_ANY, SAT_TX_PER_EVC_INDX(gtf_id), evc_rate_control_data); 1477 if (SOC_FAILURE(rv)) { 1478 LOG_ERROR(BSL_LS_SOC_SAT, 1479 (BSL_META_U(unit, 1480 "Fail(%s) in write OAMP_SAT_EVC_RATE_CONTROLr\n"), soc_errmsg(rv))); 1481 goto exit; 1482 } 1483 } 1484 1485 exit: 1486 /* After done, disable dynamic memory access */ 1487 soc_sat_dynamic_memory_access_set(unit, 0); 1488 return rv; 1489 } 1490 1491 soc_error_t soc_sat_gtf_bandwidth_set ( 1492 SOC_SAND_IN int unit, 1493 SOC_SAND_IN soc_sat_gtf_t gtf_id, 1494 SOC_SAND_IN int priority, 1495 SOC_SAND_IN soc_sat_gtf_bandwidth_t *bw 1496 ) 1497 { 1498 int rv = SOC_E_NONE; 1499 soc_reg_above_64_val_t data; 1500 int index; 1501 uint32 mnt_nof_bits = 0, exp_nof_bits = 0; 1502 uint32 rate_mnt_val = 0, rate_exp_val = 0; 1503 uint32 burst_mnt_val = 0, burst_exp_val = 0; 1504 #ifdef BCM_SAT_GTF_STAT_FIX 1505 uint32 stat_val; 1506 #endif 1507 1508 /* 1. caculate bytes per cycle for rate */ 1509 mnt_nof_bits = soc_reg_field_length(unit, OAMP_SAT_GEN_RATE_CONTROLr, BYTES_PER_CYCLE_MNT__Nf); 1510 exp_nof_bits = soc_reg_field_length(unit, OAMP_SAT_GEN_RATE_CONTROLr, BYTES_PER_CYCLE_EXP__Nf); 1511 rv = _soc_sat_gtf_rate_to_internal_rate_convert(unit, 1512 bw->rate, 1513 bw->flags, 1514 mnt_nof_bits, 1515 exp_nof_bits, 1516 bw->granularity, 1517 &rate_mnt_val, 1518 &rate_exp_val); 1519 if (SOC_FAILURE(rv)) { 1520 LOG_ERROR(BSL_LS_SOC_SAT, 1521 (BSL_META_U(unit, 1522 "Fail(%s) in _soc_sat_gtf_rate_to_internal_rate_convert\n"), soc_errmsg(rv))); 1523 return rv; 1524 } 1525 1526 /* 2. caculate max credits for max_burst */ 1527 mnt_nof_bits = soc_reg_field_length(unit, OAMP_SAT_GEN_RATE_CONTROLr, MAX_CREDITS_MNT__Nf); 1528 exp_nof_bits = soc_reg_field_length(unit, OAMP_SAT_GEN_RATE_CONTROLr, MAX_CREDITS_EXP__Nf); 1529 1530 if (SOC_IS_QAX(unit) && (bw->flags & SOC_SAT_GTF_RATE_IN_PACKETS)) { 1531 rv = soc_break_to_mnt_exp_round_up( 1532 bw->max_burst, 1533 mnt_nof_bits, 1534 exp_nof_bits, 1535 0, 1536 &burst_mnt_val, 1537 &burst_exp_val 1538 ); 1539 }else { 1540 rv = soc_break_to_mnt_exp_round_up( 1541 bw->max_burst* 125, 1542 mnt_nof_bits, 1543 exp_nof_bits, 1544 0, 1545 &burst_mnt_val, 1546 &burst_exp_val 1547 ); 1548 } 1549 if (SOC_FAILURE(rv)) { 1550 LOG_ERROR(BSL_LS_SOC_SAT, 1551 (BSL_META_U(unit, 1552 "Fail(%s) in soc_break_to_mnt_exp_round_up\n"), soc_errmsg(rv))); 1553 return rv; 1554 } 1555 1556 if ((priority == SOC_SAT_GTF_OBJ_COMMON)) { 1557 SOC_REG_ABOVE_64_CLEAR(data); 1558 1559 index = SAT_TX_PER_EVC_INDX(gtf_id); 1560 1561 rv = READ_OAMP_SAT_EVC_RATE_CONTROLr(unit, index, data); 1562 if (SOC_FAILURE(rv)) { 1563 LOG_ERROR(BSL_LS_SOC_SAT, 1564 (BSL_META_U(unit, 1565 "Fail(%s) in read OAMP_SAT_EVC_RATE_CONTROLr\n"), soc_errmsg(rv))); 1566 return rv; 1567 } 1568 1569 soc_reg_above_64_field32_set(unit, OAMP_SAT_EVC_RATE_CONTROLr, data, BYTES_PER_CYCLE_EVC_MNT__Nf, rate_mnt_val); 1570 soc_reg_above_64_field32_set(unit, OAMP_SAT_EVC_RATE_CONTROLr, data, BYTES_PER_CYCLE_EVC_EXP__Nf, rate_exp_val); 1571 soc_reg_above_64_field32_set(unit, OAMP_SAT_EVC_RATE_CONTROLr, data, MAX_CREDITS_EVC_MNT__Nf, burst_mnt_val); 1572 soc_reg_above_64_field32_set(unit, OAMP_SAT_EVC_RATE_CONTROLr, data, MAX_CREDITS_EVC_EXP__Nf, burst_exp_val); 1573 if (SOC_IS_QAX(unit)) { 1574 soc_reg_above_64_field32_set(unit, OAMP_SAT_EVC_RATE_CONTROLr, data, CRDT_PER_PKT_EVC__Nf, (bw->flags & SOC_SAT_GTF_RATE_IN_PACKETS) ? 1 : 0); 1575 } 1576 1577 rv = WRITE_OAMP_SAT_EVC_RATE_CONTROLr(unit, index, data); 1578 if (SOC_FAILURE(rv)) { 1579 LOG_ERROR(BSL_LS_SOC_SAT, 1580 (BSL_META_U(unit, 1581 "Fail(%s) in write OAMP_SAT_EVC_RATE_CONTROLr\n"), soc_errmsg(rv))); 1582 return rv; 1583 } 1584 } 1585 else { 1586 SOC_REG_ABOVE_64_CLEAR(data); 1587 1588 index = SAT_TX_PER_GENERATOR_INDX(gtf_id, priority); 1589 1590 rv = READ_OAMP_SAT_GEN_RATE_CONTROLr(unit, index, data); 1591 if (SOC_FAILURE(rv)) { 1592 LOG_ERROR(BSL_LS_SOC_SAT, 1593 (BSL_META_U(unit, 1594 "Fail(%s) in read OAMP_SAT_GEN_RATE_CONTROLr\n"), soc_errmsg(rv))); 1595 return rv; 1596 } 1597 #ifdef BCM_SAT_GTF_STAT_FIX 1598 if (!SOC_IS_QAX(unit)) { 1599 stat_val = soc_reg_above_64_field32_get(unit, OAMP_SAT_GEN_RATE_CONTROLr, data, PACKET_COUNT__Nf); 1600 COMPILER_64_ADD_32(soc_sat_data[unit].gtf_stat_value[index], stat_val); 1601 } 1602 #endif 1603 1604 soc_reg_above_64_field32_set(unit, OAMP_SAT_GEN_RATE_CONTROLr, data, BYTES_PER_CYCLE_MNT__Nf, rate_mnt_val); 1605 soc_reg_above_64_field32_set(unit, OAMP_SAT_GEN_RATE_CONTROLr, data, BYTES_PER_CYCLE_EXP__Nf, rate_exp_val); 1606 soc_reg_above_64_field32_set(unit, OAMP_SAT_GEN_RATE_CONTROLr, data, MAX_CREDITS_MNT__Nf, burst_mnt_val); 1607 soc_reg_above_64_field32_set(unit, OAMP_SAT_GEN_RATE_CONTROLr, data, MAX_CREDITS_EXP__Nf, burst_exp_val); 1608 if (SOC_IS_QAX(unit)) { 1609 soc_reg_above_64_field32_set(unit, OAMP_SAT_GEN_RATE_CONTROLr, data, CRDT_PER_PKT__Nf, (bw->flags & SOC_SAT_GTF_RATE_IN_PACKETS) ? 1 : 0); 1610 } 1611 1612 rv = WRITE_OAMP_SAT_GEN_RATE_CONTROLr(unit, index, data); 1613 if (SOC_FAILURE(rv)) { 1614 LOG_ERROR(BSL_LS_SOC_SAT, 1615 (BSL_META_U(unit, 1616 "Fail(%s) in write OAMP_SAT_GEN_RATE_CONTROLr\n"), soc_errmsg(rv))); 1617 return rv; 1618 } 1619 } 1620 1621 return rv; 1622 } 1623 1624 soc_error_t soc_sat_gtf_bandwidth_get ( 1625 SOC_SAND_IN int unit, 1626 SOC_SAND_IN soc_sat_gtf_t gtf_id, 1627 SOC_SAND_IN int priority, 1628 SOC_SAND_OUT soc_sat_gtf_bandwidth_t *bw 1629 ) 1630 { 1631 int rv = SOC_E_NONE; 1632 soc_reg_above_64_val_t data; 1633 int index; 1634 uint32 rate_mnt_val = 0, rate_exp_val = 0; 1635 uint32 burst_mnt_val = 0, burst_exp_val = 0; 1636 uint32 crdt_per_pkt = 0; 1637 #ifdef BCM_SAT_GTF_STAT_FIX 1638 uint32 stat_val; 1639 #endif 1640 1641 if ((priority == SOC_SAT_GTF_OBJ_COMMON)) { 1642 SOC_REG_ABOVE_64_CLEAR(data); 1643 1644 index = SAT_TX_PER_EVC_INDX(gtf_id); 1645 1646 rv = READ_OAMP_SAT_EVC_RATE_CONTROLr(unit, index, data); 1647 if (SOC_FAILURE(rv)) { 1648 LOG_ERROR(BSL_LS_SOC_SAT, 1649 (BSL_META_U(unit, 1650 "Fail(%s) in read OAMP_SAT_EVC_RATE_CONTROLr\n"), soc_errmsg(rv))); 1651 return rv; 1652 } 1653 1654 rate_mnt_val = soc_reg_above_64_field32_get(unit, OAMP_SAT_EVC_RATE_CONTROLr, data, BYTES_PER_CYCLE_EVC_MNT__Nf); 1655 rate_exp_val = soc_reg_above_64_field32_get(unit, OAMP_SAT_EVC_RATE_CONTROLr, data, BYTES_PER_CYCLE_EVC_EXP__Nf); 1656 burst_mnt_val = soc_reg_above_64_field32_get(unit, OAMP_SAT_EVC_RATE_CONTROLr, data, MAX_CREDITS_EVC_MNT__Nf); 1657 burst_exp_val = soc_reg_above_64_field32_get(unit, OAMP_SAT_EVC_RATE_CONTROLr, data, MAX_CREDITS_EVC_EXP__Nf); 1658 1659 if (SOC_IS_QAX(unit)) { 1660 crdt_per_pkt = soc_reg_above_64_field32_get(unit, OAMP_SAT_EVC_RATE_CONTROLr, data, CRDT_PER_PKT_EVC__Nf); 1661 bw->flags = crdt_per_pkt; 1662 } 1663 } 1664 else { 1665 SOC_REG_ABOVE_64_CLEAR(data); 1666 1667 index = SAT_TX_PER_GENERATOR_INDX(gtf_id, priority); 1668 1669 rv = READ_OAMP_SAT_GEN_RATE_CONTROLr(unit, index, data); 1670 if (SOC_FAILURE(rv)) { 1671 LOG_ERROR(BSL_LS_SOC_SAT, 1672 (BSL_META_U(unit, 1673 "Fail(%s) in read OAMP_SAT_GEN_RATE_CONTROLr\n"), soc_errmsg(rv))); 1674 return rv; 1675 } 1676 #ifdef BCM_SAT_GTF_STAT_FIX 1677 if (!SOC_IS_QAX(unit)) { 1678 stat_val = soc_reg_above_64_field32_get(unit, OAMP_SAT_GEN_RATE_CONTROLr, data, PACKET_COUNT__Nf); 1679 COMPILER_64_ADD_32(soc_sat_data[unit].gtf_stat_value[index], stat_val); 1680 } 1681 #endif 1682 rate_mnt_val = soc_reg_above_64_field32_get(unit, OAMP_SAT_GEN_RATE_CONTROLr, data, BYTES_PER_CYCLE_MNT__Nf); 1683 rate_exp_val = soc_reg_above_64_field32_get(unit, OAMP_SAT_GEN_RATE_CONTROLr, data, BYTES_PER_CYCLE_EXP__Nf); 1684 burst_mnt_val = soc_reg_above_64_field32_get(unit, OAMP_SAT_GEN_RATE_CONTROLr, data, MAX_CREDITS_MNT__Nf); 1685 burst_exp_val = soc_reg_above_64_field32_get(unit, OAMP_SAT_GEN_RATE_CONTROLr, data, MAX_CREDITS_EXP__Nf); 1686 1687 if (SOC_IS_QAX(unit)) { 1688 crdt_per_pkt = soc_reg_above_64_field32_get(unit, OAMP_SAT_GEN_RATE_CONTROLr, data, CRDT_PER_PKT__Nf); 1689 bw->flags = crdt_per_pkt; 1690 } 1691 } 1692 1693 rv = _soc_sat_gtf_rate_from_internal_rate_convert(unit, rate_mnt_val, rate_exp_val, crdt_per_pkt, &(bw->rate)); 1694 if (SOC_FAILURE(rv)) { 1695 LOG_ERROR(BSL_LS_SOC_SAT, 1696 (BSL_META_U(unit, 1697 "Fail(%s) in _soc_sat_gtf_rate_from_internal_rate_convert\n"), soc_errmsg(rv))); 1698 return rv; 1699 } 1700 1701 if ((SOC_IS_QAX(unit)) && crdt_per_pkt) { 1702 bw->max_burst = (burst_mnt_val) * (1<<(burst_exp_val)); 1703 }else { 1704 bw->max_burst = (burst_mnt_val) * (1<<(burst_exp_val)) / 125; 1705 } 1706 1707 return rv; 1708 } 1709 1710 soc_error_t soc_sat_gtf_rate_pattern_set ( 1711 SOC_SAND_IN int unit, 1712 SOC_SAND_IN soc_sat_gtf_t gtf_id, 1713 SOC_SAND_IN int priority, 1714 SOC_SAND_IN soc_sat_gtf_rate_pattern_t *config 1715 ) 1716 { 1717 int rv = SOC_E_NONE; 1718 soc_reg_above_64_val_t data; 1719 int index; 1720 uint32 mnt_nof_bits = 0, exp_nof_bits = 0; 1721 uint32 high_mnt_val = 0, high_exp_val = 0, low_mnt_val = 0, low_exp_val = 0; 1722 #ifdef BCM_SAT_GTF_STAT_FIX 1723 uint32 stat_val; 1724 #endif 1725 uint32 field_data = 0; 1726 uint32 pkt_mode = 0; 1727 1728 SOC_REG_ABOVE_64_CLEAR(data); 1729 1730 index = SAT_TX_PER_GENERATOR_INDX(gtf_id, priority); 1731 1732 if (SOC_IS_QAX(unit)) { 1733 rv = READ_OAMP_SAT_GEN_RATE_CONTROLr(unit, index, data); 1734 if (SOC_FAILURE(rv)) { 1735 LOG_ERROR(BSL_LS_SOC_SAT, 1736 (BSL_META_U(unit, 1737 "Fail(%s) in read OAMP_SAT_GEN_RATE_CONTROLr\n"), soc_errmsg(rv))); 1738 return rv; 1739 } 1740 pkt_mode = soc_reg_above_64_field32_get(unit, OAMP_SAT_GEN_RATE_CONTROLr, data, CRDT_PER_PKT__Nf); 1741 SOC_REG_ABOVE_64_CLEAR(data); 1742 } 1743 1744 rv = READ_OAMP_SAT_GEN_RATE_CONTROLr(unit, index, data); 1745 if (SOC_FAILURE(rv)) { 1746 LOG_ERROR(BSL_LS_SOC_SAT, 1747 (BSL_META_U(unit, 1748 "Fail(%s) in read OAMP_SAT_GEN_RATE_CONTROLr\n"), soc_errmsg(rv))); 1749 return rv; 1750 } 1751 #ifdef BCM_SAT_GTF_STAT_FIX 1752 if (!SOC_IS_QAX(unit)) { 1753 stat_val = soc_reg_above_64_field32_get(unit, OAMP_SAT_GEN_RATE_CONTROLr, data, PACKET_COUNT__Nf); 1754 COMPILER_64_ADD_32(soc_sat_data[unit].gtf_stat_value[index], stat_val); 1755 } 1756 #endif 1757 1758 1759 /* 1. calculate hardware values for high threshold */ 1760 mnt_nof_bits = soc_reg_field_length(unit, OAMP_SAT_GEN_RATE_CONTROLr, THRESHOLD_UPPER_MNT__Nf); 1761 exp_nof_bits = soc_reg_field_length(unit, OAMP_SAT_GEN_RATE_CONTROLr, THRESHOLD_UPPER_EXP__Nf); 1762 rv = soc_break_to_mnt_exp_round_up( 1763 pkt_mode ? config->high_threshold : (config->high_threshold* 125), 1764 mnt_nof_bits, 1765 exp_nof_bits, 1766 0, 1767 &high_mnt_val, 1768 &high_exp_val 1769 ); 1770 if (SOC_FAILURE(rv)) { 1771 LOG_ERROR(BSL_LS_SOC_SAT, 1772 (BSL_META_U(unit, 1773 "Fail(%s) in soc_break_to_mnt_exp_round_up\n"), soc_errmsg(rv))); 1774 return rv; 1775 } 1776 rv = soc_break_to_mnt_exp_round_up( 1777 pkt_mode ? config->low_threshold : (config->low_threshold* 125), 1778 mnt_nof_bits, 1779 exp_nof_bits, 1780 0, 1781 &low_mnt_val, 1782 &low_exp_val 1783 ); 1784 if (SOC_FAILURE(rv)) { 1785 LOG_ERROR(BSL_LS_SOC_SAT, 1786 (BSL_META_U(unit, 1787 "Fail(%s) in soc_break_to_mnt_exp_round_up\n"), soc_errmsg(rv))); 1788 return rv; 1789 } 1790 1791 if ((config->rate_pattern_mode == socSatGtfRatePatternContinues) || (config->rate_pattern_mode == socSatGtfRatePatternSimpleBurst)) { 1792 field_data = 0; 1793 } 1794 else if (config->rate_pattern_mode == socSatGtfRatePatternCombined) { 1795 field_data = 1; 1796 } 1797 else if (config->rate_pattern_mode == socSatGtfRatePatternInterval) { 1798 field_data = 3; 1799 } 1800 else { 1801 rv = SOC_E_PARAM; 1802 LOG_ERROR(BSL_LS_SOC_SAT, 1803 (BSL_META_U(unit, 1804 "Fail(%s) rate_pattern_mode(%d) is not supported\n"), 1805 soc_errmsg(rv), config->rate_pattern_mode)); 1806 1807 return rv; 1808 } 1809 1810 soc_reg_above_64_field32_set(unit, OAMP_SAT_GEN_RATE_CONTROLr, data, BURST_MODE__Nf, field_data); 1811 soc_reg_above_64_field32_set(unit, OAMP_SAT_GEN_RATE_CONTROLr, data, THRESHOLD_UPPER_MNT__Nf, high_mnt_val); 1812 soc_reg_above_64_field32_set(unit, OAMP_SAT_GEN_RATE_CONTROLr, data, THRESHOLD_UPPER_EXP__Nf, high_exp_val); 1813 soc_reg_above_64_field32_set(unit, OAMP_SAT_GEN_RATE_CONTROLr, data, THRESHOLD_LOWER_MNT__Nf, low_mnt_val); 1814 soc_reg_above_64_field32_set(unit, OAMP_SAT_GEN_RATE_CONTROLr, data, THRESHOLD_LOWER_EXP__Nf, low_exp_val); 1815 1816 soc_reg_above_64_field32_set(unit, OAMP_SAT_GEN_RATE_CONTROLr, data, STOP_ITER_CNT__Nf, config->stop_iter_count); 1817 soc_reg_above_64_field32_set(unit, OAMP_SAT_GEN_RATE_CONTROLr, data, STOP_BURST_CNT__Nf, config->stop_burst_count); 1818 soc_reg_above_64_field32_set(unit, OAMP_SAT_GEN_RATE_CONTROLr, data, STOP_INTERVAL_CNT_CFG__Nf, config->stop_interval_count); 1819 soc_reg_above_64_field32_set(unit, OAMP_SAT_GEN_RATE_CONTROLr, data, BURST_PKT_WEIGHT__Nf, config->burst_packet_weight); 1820 soc_reg_above_64_field32_set(unit, OAMP_SAT_GEN_RATE_CONTROLr, data, INTERVAL_PKT_WEIGHT__Nf, config->interval_packet_weight); 1821 1822 if (config->flags & SOC_SAT_GTF_RATE_PATTERN_STOP_INTERVAL_EQ_BURST) { 1823 soc_reg_above_64_field32_set(unit, OAMP_SAT_GEN_RATE_CONTROLr, data, SET_INTRVAL_CNT_TO_CFG__Nf, 0x1); 1824 } 1825 else { 1826 soc_reg_above_64_field32_set(unit, OAMP_SAT_GEN_RATE_CONTROLr, data, SET_INTRVAL_CNT_TO_CFG__Nf, 0); 1827 } 1828 1829 rv = WRITE_OAMP_SAT_GEN_RATE_CONTROLr(unit, index, data); 1830 if (SOC_FAILURE(rv)) { 1831 LOG_ERROR(BSL_LS_SOC_SAT, 1832 (BSL_META_U(unit, 1833 "Fail(%s) in write OAMP_SAT_GEN_RATE_CONTROLr\n"), soc_errmsg(rv))); 1834 } 1835 1836 return rv; 1837 } 1838 1839 soc_error_t soc_sat_gtf_rate_pattern_get ( 1840 SOC_SAND_IN int unit, 1841 SOC_SAND_IN soc_sat_gtf_t gtf_id, 1842 SOC_SAND_IN int priority, 1843 SOC_SAND_OUT soc_sat_gtf_rate_pattern_t *config 1844 ) 1845 { 1846 int rv = SOC_E_NONE; 1847 soc_reg_above_64_val_t data; 1848 int index; 1849 uint32 high_mnt_val = 0, high_exp_val = 0, low_mnt_val = 0, low_exp_val = 0; 1850 uint32 interval_cnt_to_cfg; 1851 uint32 rate_pattern_mode = 0; 1852 #ifdef BCM_SAT_GTF_STAT_FIX 1853 uint32 stat_val; 1854 #endif 1855 1856 SOC_REG_ABOVE_64_CLEAR(data); 1857 1858 index = SAT_TX_PER_GENERATOR_INDX(gtf_id, priority); 1859 1860 rv = READ_OAMP_SAT_GEN_RATE_CONTROLr(unit, index, data); 1861 if (SOC_FAILURE(rv)) { 1862 LOG_ERROR(BSL_LS_SOC_SAT, 1863 (BSL_META_U(unit, 1864 "Fail(%s) in read OAMP_SAT_GEN_RATE_CONTROLr\n"), soc_errmsg(rv))); 1865 return rv; 1866 } 1867 #ifdef BCM_SAT_GTF_STAT_FIX 1868 if (!SOC_IS_QAX(unit)) { 1869 stat_val = soc_reg_above_64_field32_get(unit, OAMP_SAT_GEN_RATE_CONTROLr, data, PACKET_COUNT__Nf); 1870 COMPILER_64_ADD_32(soc_sat_data[unit].gtf_stat_value[index], stat_val); 1871 } 1872 #endif 1873 1874 rate_pattern_mode = soc_reg_above_64_field32_get(unit, OAMP_SAT_GEN_RATE_CONTROLr, data, BURST_MODE__Nf); 1875 1876 high_mnt_val = soc_reg_above_64_field32_get(unit, OAMP_SAT_GEN_RATE_CONTROLr, data, THRESHOLD_UPPER_MNT__Nf); 1877 high_exp_val = soc_reg_above_64_field32_get(unit, OAMP_SAT_GEN_RATE_CONTROLr, data, THRESHOLD_UPPER_EXP__Nf); 1878 low_mnt_val = soc_reg_above_64_field32_get(unit, OAMP_SAT_GEN_RATE_CONTROLr, data, THRESHOLD_LOWER_MNT__Nf); 1879 low_exp_val = soc_reg_above_64_field32_get(unit, OAMP_SAT_GEN_RATE_CONTROLr, data, THRESHOLD_LOWER_EXP__Nf); 1880 1881 config->stop_iter_count = soc_reg_above_64_field32_get(unit, OAMP_SAT_GEN_RATE_CONTROLr, data, STOP_ITER_CNT__Nf); 1882 config->stop_burst_count = soc_reg_above_64_field32_get(unit, OAMP_SAT_GEN_RATE_CONTROLr, data, STOP_BURST_CNT__Nf); 1883 config->stop_interval_count = soc_reg_above_64_field32_get(unit, OAMP_SAT_GEN_RATE_CONTROLr, data, STOP_INTERVAL_CNT_CFG__Nf); 1884 config->burst_packet_weight = soc_reg_above_64_field32_get(unit, OAMP_SAT_GEN_RATE_CONTROLr, data, BURST_PKT_WEIGHT__Nf); 1885 config->interval_packet_weight = soc_reg_above_64_field32_get(unit, OAMP_SAT_GEN_RATE_CONTROLr, data, INTERVAL_PKT_WEIGHT__Nf); 1886 1887 interval_cnt_to_cfg = soc_reg_above_64_field32_get(unit, OAMP_SAT_GEN_RATE_CONTROLr, data, SET_INTRVAL_CNT_TO_CFG__Nf); 1888 if (interval_cnt_to_cfg == 0x1) { 1889 config->flags |= SOC_SAT_GTF_RATE_PATTERN_STOP_INTERVAL_EQ_BURST; 1890 } 1891 1892 config->high_threshold = (high_mnt_val) * (1<<(high_exp_val)) / 125; 1893 config->low_threshold = (low_mnt_val) * (1<<(low_exp_val)) / 125; 1894 1895 if (rate_pattern_mode == 0) { 1896 config->rate_pattern_mode = (config->high_threshold == config->low_threshold) ? 1897 socSatGtfRatePatternContinues : socSatGtfRatePatternSimpleBurst; 1898 } 1899 else if (rate_pattern_mode == 1) { 1900 config->rate_pattern_mode = socSatGtfRatePatternCombined; 1901 } 1902 else if (rate_pattern_mode == 3) { 1903 config->rate_pattern_mode = socSatGtfRatePatternInterval; 1904 } 1905 else { 1906 rv = SOC_E_PARAM; 1907 LOG_ERROR(BSL_LS_SOC_SAT, 1908 (BSL_META_U(unit, 1909 "Fail(%s) in parsing rate_pattern_mode(%d)\n"), soc_errmsg(rv), rate_pattern_mode)); 1910 } 1911 1912 return rv; 1913 } 1914 1915 soc_error_t soc_sat_gtf_stat_get ( 1916 SOC_SAND_IN int unit, 1917 SOC_SAND_IN soc_sat_gtf_t gtf_id, 1918 SOC_SAND_IN int priority, 1919 SOC_SAND_IN uint32 flags, 1920 SOC_SAND_IN soc_sat_gtf_stat_counter_t type, 1921 SOC_SAND_OUT uint64* value 1922 ) 1923 { 1924 int rv = SOC_E_NONE; 1925 soc_reg_above_64_val_t data; 1926 int index; 1927 uint32 stat_val = 0; 1928 1929 if (type == socSatGtfStatPacketCount) { 1930 SOC_REG_ABOVE_64_CLEAR(data); 1931 index = SAT_TX_PER_GENERATOR_INDX(gtf_id, priority); 1932 1933 if (!SOC_IS_QAX(unit)) { 1934 rv = soc_reg_above_64_get(unit, OAMP_SAT_GEN_RATE_CONTROLr, REG_PORT_ANY, index, data); 1935 if (SOC_FAILURE(rv)) { 1936 LOG_ERROR(BSL_LS_SOC_SAT, 1937 (BSL_META_U(unit, 1938 "Fail(%s) in read OAMP_SAT_GEN_RATE_CONTROLr\n"), soc_errmsg(rv))); 1939 return rv; 1940 } 1941 1942 stat_val = soc_reg_above_64_field32_get(unit, OAMP_SAT_GEN_RATE_CONTROLr, data, PACKET_COUNT__Nf); 1943 }else { 1944 rv = soc_reg_above_64_get(unit, OAMP_SAT_TX_GEN_CNTRr, REG_PORT_ANY, index, data); 1945 if (SOC_FAILURE(rv)) { 1946 LOG_ERROR(BSL_LS_SOC_SAT, 1947 (BSL_META_U(unit, 1948 "Fail(%s) in read OAMP_SAT_TX_GEN_CNTRr\n"), soc_errmsg(rv))); 1949 return rv; 1950 } 1951 1952 stat_val = soc_reg_above_64_field32_get(unit, OAMP_SAT_TX_GEN_CNTRr, data, SAT_TX_GEN_PKT_CNTR__Nf); 1953 } 1954 1955 COMPILER_64_ZERO(*value); 1956 COMPILER_64_ADD_32(*value, stat_val); 1957 #ifdef BCM_SAT_GTF_STAT_FIX 1958 if (!SOC_IS_QAX(unit)) { 1959 COMPILER_64_ADD_64(*value, soc_sat_data[unit].gtf_stat_value[index]); 1960 1961 COMPILER_64_ZERO(soc_sat_data[unit].gtf_stat_value[index]); 1962 } 1963 #endif 1964 } 1965 1966 return rv; 1967 } 1968 1969 /* CTF functions */ 1970 soc_error_t soc_sat_ctf_packet_config ( 1971 SOC_SAND_IN int unit, 1972 SOC_SAND_IN soc_sat_ctf_t ctf_id, 1973 SOC_SAND_IN soc_sat_ctf_packet_info_t *packet_info 1974 ) 1975 { 1976 int rv = SOC_E_NONE; 1977 uint32 offset = 0, field = 0; 1978 uint32 exp_rpt_pattern[SOC_SAT_PAYLOAD_MAX_PATTERN_NOF_U32] = {0}; 1979 soc_reg_above_64_val_t 1980 reg_above64_val; 1981 1982 /* For writing on dynamic tables (in the OAMP), have to enable dynamic memory access */ 1983 rv = soc_sat_dynamic_memory_access_set(unit, 1); 1984 if (SOC_FAILURE(rv)) { 1985 LOG_ERROR(BSL_LS_SOC_SAT, 1986 (BSL_META_U(unit, 1987 "%s\n"), soc_errmsg(rv))); 1988 return rv; 1989 } 1990 1991 SOC_REG_ABOVE_64_CLEAR(reg_above64_val); 1992 rv = READ_OAMP_SAT_RX_FLOW_PARAMSm(unit, MEM_BLOCK_ANY, ctf_id, reg_above64_val); 1993 if (SOC_FAILURE(rv)) { 1994 LOG_ERROR(BSL_LS_SOC_SAT, 1995 (BSL_META_U(unit, 1996 "%s\n"), soc_errmsg(rv))); 1997 goto exit; 1998 } 1999 2000 /* PAYLOAD_OFFSETf */ 2001 offset = 0; 2002 field = packet_info->offsets.payload_offset; 2003 SHR_BITCOPY_RANGE(reg_above64_val, offset, &field, 0, 16); 2004 /* CRC_OFFSETf */ 2005 offset = SOC_SAT_CRC_OFFSET; 2006 field = (packet_info->flags & SOC_SAT_CTF_PACKET_INFO_ADD_CRC) ? packet_info->offsets.crc_byte_offset : 0; 2007 SHR_BITCOPY_RANGE(reg_above64_val, offset, &field, 0, 16); 2008 /* SEQ_NUM_OFFSETf */ 2009 field = packet_info->offsets.seq_number_offset; 2010 offset = SOC_SAT_SEQ_NUM_OFFSET; 2011 SHR_BITCOPY_RANGE(reg_above64_val, offset, &field, 0, 16); 2012 /* EXP_RPT_PATTERNf */ 2013 if (packet_info->payload.payload_type == socSatPayloadConstant4Bytes) { 2014 rv = soc_sat_packet_config_exp_payload_uint8_to_long(packet_info->payload.payload_pattern, SOC_SAT_PAYLOAD_MAX_PATTERN_NOF_U8/2, 1, exp_rpt_pattern); 2015 if (SOC_FAILURE(rv)) { 2016 LOG_ERROR(BSL_LS_SOC_SAT, 2017 (BSL_META_U(unit, 2018 "Fail(%s) in soc_sat_packet_config_exp_payload_uint8_to_long\n"), soc_errmsg(rv))); 2019 goto exit; 2020 } 2021 } 2022 else if (packet_info->payload.payload_type == socSatPayloadConstant8Bytes) { 2023 rv = soc_sat_packet_config_exp_payload_uint8_to_long(packet_info->payload.payload_pattern, SOC_SAT_PAYLOAD_MAX_PATTERN_NOF_U8, 1, exp_rpt_pattern); 2024 if (SOC_FAILURE(rv)) { 2025 LOG_ERROR(BSL_LS_SOC_SAT, 2026 (BSL_META_U(unit, 2027 "Fail(%s) in soc_sat_packet_config_exp_payload_uint8_to_long\n"), soc_errmsg(rv))); 2028 goto exit; 2029 } 2030 } 2031 offset = SOC_SAT_EXP_RPT_PATTERN_OFFSET; 2032 SHR_BITCOPY_RANGE(reg_above64_val, offset, exp_rpt_pattern, 0, 64); 2033 2034 /* ADD_END_TLVf */ 2035 field = (packet_info->flags & SOC_SAT_CTF_PACKET_INFO_ADD_END_TLV) ? 1:0; 2036 offset = SOC_SAT_ADD_END_TLV_OFFSET; 2037 SHR_BITCOPY_RANGE(reg_above64_val, offset, &field, 0, 1); 2038 2039 /* ADD_CRCf */ 2040 field = (packet_info->flags & SOC_SAT_CTF_PACKET_INFO_ADD_CRC) ? 1:0; 2041 offset = SOC_SAT_ADD_CRC_OFFSET; 2042 SHR_BITCOPY_RANGE(reg_above64_val, offset, &field, 0, 1); 2043 2044 /* TIME_STAMP_OFFSETf */ 2045 offset = SOC_SAT_TIME_STAMP_OFFSET; 2046 field = packet_info->offsets.timestamp_offset; 2047 SHR_BITCOPY_RANGE(reg_above64_val, offset, &field, 0, 16); 2048 2049 if (packet_info->payload.payload_type == socSatPayloadConstant4Bytes) { 2050 /* USE_RPT_PTRN_PAYLOADf */ 2051 offset = SOC_SAT_USE_RPT_PTRN_PAYLOAD_OFFSET; 2052 field = 1; 2053 SHR_BITCOPY_RANGE(reg_above64_val, offset, &field, 0, 1); 2054 /* USE_4_BYTE_PATTERNf */ 2055 offset = SOC_SAT_USE_4_BYTE_PATTERN_OFFSET; 2056 field = 1; 2057 SHR_BITCOPY_RANGE(reg_above64_val, offset, &field, 0, 1); 2058 /* USE_PRBS_PAYLOADf */ 2059 offset = SOC_SAT_USE_PRBS_PAYLOAD_OFFSET; 2060 field = 0; 2061 SHR_BITCOPY_RANGE(reg_above64_val, offset, &field, 0, 1); 2062 } 2063 else if (packet_info->payload.payload_type == socSatPayloadPRBS) { 2064 /* USE_RPT_PTRN_PAYLOADf */ 2065 offset = SOC_SAT_USE_RPT_PTRN_PAYLOAD_OFFSET; 2066 field = 0; 2067 SHR_BITCOPY_RANGE(reg_above64_val, offset, &field, 0, 1); 2068 /* USE_4_BYTE_PATTERNf */ 2069 offset = SOC_SAT_USE_4_BYTE_PATTERN_OFFSET; 2070 field = 0; 2071 SHR_BITCOPY_RANGE(reg_above64_val, offset, &field, 0, 1); 2072 /* USE_PRBS_PAYLOADf */ 2073 offset = SOC_SAT_USE_PRBS_PAYLOAD_OFFSET; 2074 field = 1; 2075 SHR_BITCOPY_RANGE(reg_above64_val, offset, &field, 0, 1); 2076 } 2077 else if (packet_info->payload.payload_type == socSatPayloadConstant8Bytes) { 2078 /* USE_RPT_PTRN_PAYLOADf */ 2079 offset = SOC_SAT_USE_RPT_PTRN_PAYLOAD_OFFSET; 2080 field = 1; 2081 SHR_BITCOPY_RANGE(reg_above64_val, offset, &field, 0, 1); 2082 /* USE_4_BYTE_PATTERNf */ 2083 offset = SOC_SAT_USE_4_BYTE_PATTERN_OFFSET; 2084 field = 0; 2085 SHR_BITCOPY_RANGE(reg_above64_val, offset, &field, 0, 1); 2086 /* USE_PRBS_PAYLOADf */ 2087 offset = SOC_SAT_USE_PRBS_PAYLOAD_OFFSET; 2088 field = 0; 2089 SHR_BITCOPY_RANGE(reg_above64_val, offset, &field, 0, 1); 2090 } 2091 /* Reset ExpSeqNumber as 0 */ 2092 offset = 224; 2093 field = 0; 2094 SHR_BITCOPY_RANGE(reg_above64_val, offset, &field, 0, 32); 2095 2096 rv = WRITE_OAMP_SAT_RX_FLOW_PARAMSm(unit, MEM_BLOCK_ALL, ctf_id, reg_above64_val); 2097 if (SOC_FAILURE(rv)) { 2098 LOG_ERROR(BSL_LS_SOC_SAT, 2099 (BSL_META_U(unit, 2100 "%s\n"), soc_errmsg(rv))); 2101 goto exit; 2102 } 2103 2104 exit: 2105 /* After done, disable dynamic memory access */ 2106 soc_sat_dynamic_memory_access_set(unit, 0); 2107 return rv; 2108 } 2109 2110 soc_error_t soc_sat_ctf_identifier_map ( 2111 SOC_SAND_IN int unit, 2112 SOC_SAND_IN soc_sat_ctf_identifier_t *identifier, 2113 SOC_SAND_IN soc_sat_ctf_t ctf_id 2114 ) 2115 { 2116 int rv = SOC_E_NONE; 2117 int index = 0; 2118 uint32 data = 0; 2119 uint8 identifier_valid = 0; 2120 uint32 valid_fld = 1; 2121 2122 index = SAT_CTF_IDENTIFIER_TO_INDEX(identifier->session_id, 2123 identifier->trap_id, 2124 identifier->color, 2125 identifier->tc); 2126 2127 rv = READ_OAMP_SAT_RX_FLOW_IDm(unit, MEM_BLOCK_ANY, index, &data); 2128 if (SOC_FAILURE(rv)) { 2129 LOG_ERROR(BSL_LS_SOC_SAT, 2130 (BSL_META_U(unit, 2131 "%s\n"), soc_errmsg(rv))); 2132 return rv; 2133 } 2134 identifier_valid = soc_mem_field32_get(unit, OAMP_SAT_RX_FLOW_IDm, &data, FLOW_VALIDf); 2135 if (identifier_valid) { 2136 return SOC_E_EXISTS; 2137 } 2138 soc_mem_field32_set(unit, OAMP_SAT_RX_FLOW_IDm, &data, FLOW_IDf, ctf_id); 2139 soc_mem_field32_set(unit, OAMP_SAT_RX_FLOW_IDm, &data, FLOW_VALIDf, valid_fld); 2140 2141 rv = WRITE_OAMP_SAT_RX_FLOW_IDm(unit, MEM_BLOCK_ALL, index, &data); 2142 if (SOC_FAILURE(rv)) { 2143 LOG_ERROR(BSL_LS_SOC_SAT, 2144 (BSL_META_U(unit, 2145 "%s\n"), soc_errmsg(rv))); 2146 } 2147 2148 return rv; 2149 } 2150 2151 soc_error_t soc_sat_ctf_identifier_unmap ( 2152 SOC_SAND_IN int unit, 2153 SOC_SAND_IN soc_sat_ctf_identifier_t *identifier 2154 ) 2155 { 2156 int rv = SOC_E_NONE; 2157 int index = 0; 2158 uint32 data = 0; 2159 uint32 valid_fld = 0; 2160 uint32 flow_id = 0; 2161 2162 index = SAT_CTF_IDENTIFIER_TO_INDEX(identifier->session_id, 2163 identifier->trap_id, 2164 identifier->color, 2165 identifier->tc); 2166 2167 rv = READ_OAMP_SAT_RX_FLOW_IDm(unit, MEM_BLOCK_ANY, index, &data); 2168 if (SOC_FAILURE(rv)) { 2169 LOG_ERROR(BSL_LS_SOC_SAT, 2170 (BSL_META_U(unit, 2171 "%s\n"), soc_errmsg(rv))); 2172 return rv; 2173 } 2174 2175 soc_mem_field32_set(unit, OAMP_SAT_RX_FLOW_IDm, &data, FLOW_IDf, flow_id); 2176 soc_mem_field32_set(unit, OAMP_SAT_RX_FLOW_IDm, &data, FLOW_VALIDf, valid_fld); 2177 2178 rv = WRITE_OAMP_SAT_RX_FLOW_IDm(unit, MEM_BLOCK_ALL, index, &data); 2179 if (SOC_FAILURE(rv)) { 2180 LOG_ERROR(BSL_LS_SOC_SAT, 2181 (BSL_META_U(unit, 2182 "%s\n"), soc_errmsg(rv))); 2183 } 2184 2185 return rv; 2186 } 2187 2188 soc_error_t soc_sat_ctf_trap_set ( 2189 SOC_SAND_IN int unit, 2190 SOC_SAND_IN uint32 trap_id_cnt, 2191 SOC_SAND_IN uint32* trap_id 2192 ) 2193 { 2194 int rv = SOC_E_NONE; 2195 soc_reg_above_64_val_t 2196 reg_above64_val, fld_above64_val; 2197 2198 SOC_REG_ABOVE_64_CLEAR(reg_above64_val); 2199 SOC_REG_ABOVE_64_CLEAR(fld_above64_val); 2200 if (trap_id_cnt != SOC_SAT_CTF_TRAP_ID_MAX_NUM) { 2201 LOG_ERROR(BSL_LS_SOC_SAT, 2202 (BSL_META_U(unit, 2203 "%s\n"), soc_errmsg(rv))); 2204 return SOC_E_PARAM; 2205 } 2206 2207 rv = READ_OAMP_SAT_RX_CONFIGr(unit, reg_above64_val); 2208 if (SOC_FAILURE(rv)) { 2209 LOG_ERROR(BSL_LS_SOC_SAT, 2210 (BSL_META_U(unit, 2211 "%s\n"), soc_errmsg(rv))); 2212 return rv; 2213 } 2214 fld_above64_val[0] = trap_id[0]; 2215 soc_reg_above_64_field_set(unit, OAMP_SAT_RX_CONFIGr, reg_above64_val, RX_TRAP_CODE_0f, fld_above64_val); 2216 fld_above64_val[0] = trap_id[1]; 2217 soc_reg_above_64_field_set(unit, OAMP_SAT_RX_CONFIGr, reg_above64_val, RX_TRAP_CODE_1f, fld_above64_val); 2218 fld_above64_val[0] = trap_id[2]; 2219 soc_reg_above_64_field_set(unit, OAMP_SAT_RX_CONFIGr, reg_above64_val, RX_TRAP_CODE_2f, fld_above64_val); 2220 rv = WRITE_OAMP_SAT_RX_CONFIGr(unit, reg_above64_val); 2221 if (SOC_FAILURE(rv)) { 2222 LOG_ERROR(BSL_LS_SOC_SAT, 2223 (BSL_META_U(unit, 2224 "%s\n"), soc_errmsg(rv))); 2225 } 2226 2227 return rv; 2228 } 2229 2230 soc_error_t soc_sat_ctf_bin_limit_set ( 2231 SOC_SAND_IN int unit, 2232 SOC_SAND_IN int bins_count, 2233 SOC_SAND_IN soc_sat_ctf_bin_limit_t* bins 2234 ) 2235 { 2236 int rv = SOC_E_NONE; 2237 soc_reg_above_64_val_t 2238 reg_above64_val, fld_above64_val; 2239 int idx = 0; 2240 2241 SOC_REG_ABOVE_64_CLEAR(reg_above64_val); 2242 SOC_REG_ABOVE_64_CLEAR(fld_above64_val); 2243 2244 rv = READ_OAMP_SAT_RX_CONFIGr(unit, reg_above64_val); 2245 if (SOC_FAILURE(rv)) { 2246 LOG_ERROR(BSL_LS_SOC_SAT, 2247 (BSL_META_U(unit, 2248 "%s\n"), soc_errmsg(rv))); 2249 return rv; 2250 } 2251 for (idx = 0; idx < bins_count; idx++) { 2252 fld_above64_val[0] = bins[idx].bin_limit; 2253 switch(idx){ 2254 case socSATRxFLVBinLimit0: 2255 soc_reg_above_64_field_set(unit, OAMP_SAT_RX_CONFIGr, reg_above64_val, RX_FLV_BIN_LIMIT_0f, fld_above64_val); 2256 break; 2257 case socSATRxFLVBinLimit1: 2258 soc_reg_above_64_field_set(unit, OAMP_SAT_RX_CONFIGr, reg_above64_val, RX_FLV_BIN_LIMIT_1f, fld_above64_val); 2259 break; 2260 case socSATRxFLVBinLimit2: 2261 soc_reg_above_64_field_set(unit, OAMP_SAT_RX_CONFIGr, reg_above64_val, RX_FLV_BIN_LIMIT_2f, fld_above64_val); 2262 break; 2263 case socSATRxFLVBinLimit3: 2264 soc_reg_above_64_field_set(unit, OAMP_SAT_RX_CONFIGr, reg_above64_val, RX_FLV_BIN_LIMIT_3f, fld_above64_val); 2265 break; 2266 case socSATRxFLVBinLimit4: 2267 soc_reg_above_64_field_set(unit, OAMP_SAT_RX_CONFIGr, reg_above64_val, RX_FLV_BIN_LIMIT_4f, fld_above64_val); 2268 break; 2269 case socSATRxFLVBinLimit5: 2270 soc_reg_above_64_field_set(unit, OAMP_SAT_RX_CONFIGr, reg_above64_val, RX_FLV_BIN_LIMIT_5f, fld_above64_val); 2271 break; 2272 case socSATRxFLVBinLimit6: 2273 soc_reg_above_64_field_set(unit, OAMP_SAT_RX_CONFIGr, reg_above64_val, RX_FLV_BIN_LIMIT_6f, fld_above64_val); 2274 break; 2275 case socSATRxFLVBinLimit7: 2276 soc_reg_above_64_field_set(unit, OAMP_SAT_RX_CONFIGr, reg_above64_val, RX_FLV_BIN_LIMIT_7f, fld_above64_val); 2277 break; 2278 case socSATRxFLVBinLimit8: 2279 soc_reg_above_64_field_set(unit, OAMP_SAT_RX_CONFIGr, reg_above64_val, RX_FLV_BIN_LIMIT_8f, fld_above64_val); 2280 break; 2281 default: 2282 LOG_ERROR(BSL_LS_SOC_SAT, 2283 (BSL_META_U(unit, 2284 "%s\n"), soc_errmsg(rv))); 2285 return SOC_E_PARAM; 2286 } 2287 } 2288 rv = WRITE_OAMP_SAT_RX_CONFIGr(unit, reg_above64_val); 2289 if (SOC_FAILURE(rv)) { 2290 LOG_ERROR(BSL_LS_SOC_SAT, 2291 (BSL_META_U(unit, 2292 "%s\n"), soc_errmsg(rv))); 2293 } 2294 2295 return rv; 2296 } 2297 2298 soc_error_t soc_sat_ctf_bin_limit_get ( 2299 SOC_SAND_IN int unit, 2300 SOC_SAND_IN int max_bins_count, 2301 SOC_SAND_OUT int * bins_count, 2302 SOC_SAND_OUT soc_sat_ctf_bin_limit_t* bins 2303 ) 2304 { 2305 int rv = SOC_E_NONE; 2306 soc_reg_above_64_val_t 2307 reg_above64_val, fld_above64_val; 2308 int idx = 0; 2309 2310 SOC_REG_ABOVE_64_CLEAR(reg_above64_val); 2311 SOC_REG_ABOVE_64_CLEAR(fld_above64_val); 2312 *bins_count = 0; 2313 2314 rv = READ_OAMP_SAT_RX_CONFIGr(unit, reg_above64_val); 2315 if (SOC_FAILURE(rv)) { 2316 LOG_ERROR(BSL_LS_SOC_SAT, 2317 (BSL_META_U(unit, 2318 "%s\n"), soc_errmsg(rv))); 2319 return rv; 2320 } 2321 for (idx = 0; idx < max_bins_count; idx++) { 2322 switch(idx){ 2323 case socSATRxFLVBinLimit0: 2324 soc_reg_above_64_field_get(unit, OAMP_SAT_RX_CONFIGr, reg_above64_val, RX_FLV_BIN_LIMIT_0f, fld_above64_val); 2325 break; 2326 case socSATRxFLVBinLimit1: 2327 soc_reg_above_64_field_get(unit, OAMP_SAT_RX_CONFIGr, reg_above64_val, RX_FLV_BIN_LIMIT_1f, fld_above64_val); 2328 break; 2329 case socSATRxFLVBinLimit2: 2330 soc_reg_above_64_field_get(unit, OAMP_SAT_RX_CONFIGr, reg_above64_val, RX_FLV_BIN_LIMIT_2f, fld_above64_val); 2331 break; 2332 case socSATRxFLVBinLimit3: 2333 soc_reg_above_64_field_get(unit, OAMP_SAT_RX_CONFIGr, reg_above64_val, RX_FLV_BIN_LIMIT_3f, fld_above64_val); 2334 break; 2335 case socSATRxFLVBinLimit4: 2336 soc_reg_above_64_field_get(unit, OAMP_SAT_RX_CONFIGr, reg_above64_val, RX_FLV_BIN_LIMIT_4f, fld_above64_val); 2337 break; 2338 case socSATRxFLVBinLimit5: 2339 soc_reg_above_64_field_get(unit, OAMP_SAT_RX_CONFIGr, reg_above64_val, RX_FLV_BIN_LIMIT_5f, fld_above64_val); 2340 break; 2341 case socSATRxFLVBinLimit6: 2342 soc_reg_above_64_field_get(unit, OAMP_SAT_RX_CONFIGr, reg_above64_val, RX_FLV_BIN_LIMIT_6f, fld_above64_val); 2343 break; 2344 case socSATRxFLVBinLimit7: 2345 soc_reg_above_64_field_get(unit, OAMP_SAT_RX_CONFIGr, reg_above64_val, RX_FLV_BIN_LIMIT_7f, fld_above64_val); 2346 break; 2347 case socSATRxFLVBinLimit8: 2348 soc_reg_above_64_field_get(unit, OAMP_SAT_RX_CONFIGr, reg_above64_val, RX_FLV_BIN_LIMIT_8f, fld_above64_val); 2349 break; 2350 default: 2351 LOG_ERROR(BSL_LS_SOC_SAT, 2352 (BSL_META_U(unit, 2353 "%s\n"), soc_errmsg(rv))); 2354 return SOC_E_PARAM; 2355 } 2356 if (fld_above64_val[0] == 0){ 2357 break; 2358 } 2359 bins[idx].bin_select = idx; 2360 bins[idx].bin_limit = fld_above64_val[0]; 2361 (*bins_count)++; 2362 } 2363 2364 return rv; 2365 } 2366 2367 soc_error_t soc_sat_ctf_stat_config_set ( 2368 SOC_SAND_IN int unit, 2369 SOC_SAND_IN soc_sat_ctf_t ctf_id, 2370 SOC_SAND_IN soc_sat_ctf_stat_config_t *stat 2371 ) 2372 { 2373 int rv = SOC_E_NONE; 2374 uint32 2375 data[SOC_SAT_CTF_RX_FLOW_PARAMS_ENTRY_SIZE]; 2376 uint64 reg_val; 2377 2378 COMPILER_64_ZERO(reg_val); 2379 /* For writing on dynamic tables (in the OAMP), have to enable dynamic memory access */ 2380 rv = soc_sat_dynamic_memory_access_set(unit, 1); 2381 if (SOC_FAILURE(rv)) { 2382 LOG_ERROR(BSL_LS_SOC_SAT, 2383 (BSL_META_U(unit, 2384 "%s\n"), soc_errmsg(rv))); 2385 return rv; 2386 } 2387 2388 sal_memset(data, 0, sizeof(data)); 2389 rv = READ_OAMP_SAT_RX_FLOW_PARAMSm(unit, MEM_BLOCK_ANY, ctf_id, data); 2390 if (SOC_FAILURE(rv)) { 2391 LOG_ERROR(BSL_LS_SOC_SAT, 2392 (BSL_META_U(unit, 2393 "%s\n"), soc_errmsg(rv))); 2394 goto exit; 2395 } 2396 soc_mem_field32_set(unit, OAMP_SAT_RX_FLOW_PARAMSm, &data, CALC_EQUAL_FDV_BINSf, (stat->use_global_bin_config ? 0 : 1)); 2397 soc_mem_field32_set(unit, OAMP_SAT_RX_FLOW_PARAMSm, &data, FDV_BIN_MIN_DELAYf, stat->bin_min_delay); 2398 soc_mem_field32_set(unit, OAMP_SAT_RX_FLOW_PARAMSm, &data, FDV_BIN_STEPf, stat->bin_step); 2399 rv = WRITE_OAMP_SAT_RX_FLOW_PARAMSm(unit, MEM_BLOCK_ALL, ctf_id, data); 2400 if (SOC_FAILURE(rv)) { 2401 LOG_ERROR(BSL_LS_SOC_SAT, 2402 (BSL_META_U(unit, 2403 "%s\n"), soc_errmsg(rv))); 2404 goto exit; 2405 } 2406 2407 rv = READ_OAMP_SAT_RX_STATr(unit, ®_val); 2408 if (SOC_FAILURE(rv)) { 2409 LOG_ERROR(BSL_LS_SOC_SAT, 2410 (BSL_META_U(unit, 2411 "%s\n"), soc_errmsg(rv))); 2412 goto exit; 2413 } 2414 soc_reg64_field32_set(unit, OAMP_SAT_RX_STATr, ®_val, RX_STATS_FLOW_IDf, ctf_id); 2415 soc_reg64_field32_set(unit, OAMP_SAT_RX_STATr, ®_val, RX_STATS_UPDT_CNTR_ALWSf, stat->update_counters_in_unvavail_state); 2416 rv = WRITE_OAMP_SAT_RX_STATr(unit, reg_val); 2417 if (SOC_FAILURE(rv)) { 2418 LOG_ERROR(BSL_LS_SOC_SAT, 2419 (BSL_META_U(unit, 2420 "%s\n"), soc_errmsg(rv))); 2421 goto exit; 2422 } 2423 2424 soc_reg64_field32_set(unit, OAMP_SAT_RX_STATr, ®_val, RX_STATS_RST_STATE_MCHNf, 1); 2425 rv = WRITE_OAMP_SAT_RX_STATr(unit, reg_val); 2426 if (SOC_FAILURE(rv)) { 2427 LOG_ERROR(BSL_LS_SOC_SAT, 2428 (BSL_META_U(unit, 2429 "%s\n"), soc_errmsg(rv))); 2430 goto exit; 2431 } 2432 sal_udelay(1000); 2433 soc_reg64_field32_set(unit, OAMP_SAT_RX_STATr, ®_val, RX_STATS_RST_STATE_MCHNf, 0); 2434 rv = WRITE_OAMP_SAT_RX_STATr(unit, reg_val); 2435 if (SOC_FAILURE(rv)) { 2436 LOG_ERROR(BSL_LS_SOC_SAT, 2437 (BSL_META_U(unit, 2438 "%s\n"), soc_errmsg(rv))); 2439 goto exit; 2440 } 2441 2442 exit: 2443 /* After done, disable dynamic memory access */ 2444 soc_sat_dynamic_memory_access_set(unit, 0); 2445 return rv; 2446 } 2447 2448 soc_error_t soc_sat_ctf_stat_get ( 2449 SOC_SAND_IN int unit, 2450 SOC_SAND_IN soc_sat_ctf_t ctf_id, 2451 SOC_SAND_IN uint32 flags, 2452 SOC_SAND_OUT soc_sat_ctf_stat_t* stat 2453 ) 2454 { 2455 int rv = SOC_E_NONE; 2456 uint64 reg_val; 2457 uint32 field = 0; 2458 soc_reg_above_64_val_t 2459 reg_above64_val_3, reg_above64_val_4; 2460 int offset_base = 0; 2461 int len = 0; 2462 uint32 fld_64[2]; 2463 uint32 bin_delay_counters_5_3lsbs = 0; 2464 uint32 bin_delay_counters_5_low = 0; 2465 uint32 bin_delay_counters_5_high = 0; 2466 uint32 2467 data[SOC_SAT_CTF_RX_FLOW_PARAMS_ENTRY_SIZE]; 2468 2469 sal_memset(data, 0, sizeof(data)); 2470 2471 COMPILER_64_ZERO(reg_val); 2472 SOC_REG_ABOVE_64_CLEAR(reg_above64_val_3); 2473 SOC_REG_ABOVE_64_CLEAR(reg_above64_val_4); 2474 rv = READ_OAMP_SAT_RX_STATr(unit, ®_val); 2475 if (SOC_FAILURE(rv)) { 2476 LOG_ERROR(BSL_LS_SOC_SAT, 2477 (BSL_META_U(unit, 2478 "%s\n"), soc_errmsg(rv))); 2479 return rv; 2480 } 2481 field = (flags & SOC_SAT_CTF_STAT_DO_NOT_CLR_ON_READ ? 0 : 1); 2482 soc_reg64_field32_set(unit, OAMP_SAT_RX_STATr, ®_val, RX_STATS_CLR_ON_RDf, field); 2483 soc_reg64_field32_set(unit, OAMP_SAT_RX_STATr, ®_val, RX_STATS_FLOW_IDf, ctf_id); 2484 2485 #ifdef CRASH_RECOVERY_SUPPORT 2486 soc_hw_set_immediate_hw_access(unit); 2487 #endif 2488 rv = WRITE_OAMP_SAT_RX_STATr(unit, reg_val); 2489 #ifdef CRASH_RECOVERY_SUPPORT 2490 soc_hw_restore_immediate_hw_access(unit); 2491 #endif 2492 2493 if (SOC_FAILURE(rv)) { 2494 LOG_ERROR(BSL_LS_SOC_SAT, 2495 (BSL_META_U(unit, 2496 "%s\n"), soc_errmsg(rv))); 2497 return rv; 2498 } 2499 2500 rv = READ_OAMP_RX_STATS_DATA_3r(unit, reg_above64_val_3); 2501 if (SOC_FAILURE(rv)) { 2502 LOG_ERROR(BSL_LS_SOC_SAT, 2503 (BSL_META_U(unit, 2504 "%s\n"), soc_errmsg(rv))); 2505 return rv; 2506 } 2507 rv = READ_OAMP_RX_STATS_DATA_4r(unit, reg_above64_val_4); 2508 if (SOC_FAILURE(rv)) { 2509 LOG_ERROR(BSL_LS_SOC_SAT, 2510 (BSL_META_U(unit, 2511 "%s\n"), soc_errmsg(rv))); 2512 return rv; 2513 } 2514 2515 /* 2516 * Accumulated_statistics[999:0] -- RxStatsData_3 bits[639:80], RxStatsData_4 bits[439:0] 2517 */ 2518 /* received_packet_cnt FlowStatAccumEntry1 RcvdPktCntrAccum bits[83:42] */ 2519 offset_base = (80+42); 2520 len = 42; 2521 fld_64[0] = fld_64[1] = 0; 2522 SHR_BITCOPY_RANGE(fld_64, 0, reg_above64_val_3, offset_base, len); 2523 COMPILER_64_SET(stat->received_packet_cnt, fld_64[1], fld_64[0]); 2524 /* out_of_order_packet_cnt FlowStatAccumEntry1 OooPktCntrAccum bits[125:84] */ 2525 offset_base += len; 2526 len = 42; 2527 fld_64[0] = fld_64[1] = 0; 2528 SHR_BITCOPY_RANGE(fld_64, 0, reg_above64_val_3, offset_base, len); 2529 COMPILER_64_SET(stat->out_of_order_packet_cnt, fld_64[1], fld_64[0]); 2530 /* err_packet_cnt FlowStatAccumEntry1 ErrPktCntrAccum bits[167:126] */ 2531 offset_base += len; 2532 len = 42; 2533 fld_64[0] = fld_64[1] = 0; 2534 SHR_BITCOPY_RANGE(fld_64, 0, reg_above64_val_3, offset_base, len); 2535 COMPILER_64_SET(stat->err_packet_cnt, fld_64[1], fld_64[0]); 2536 /* received_octet_cnt FlowStatAccumEntry1 RcvdOctetCntrAccum bits[216:168] */ 2537 offset_base += len; 2538 len = 49; 2539 fld_64[0] = fld_64[1] = 0; 2540 SHR_BITCOPY_RANGE(fld_64, 0, reg_above64_val_3, offset_base, len); 2541 COMPILER_64_SET(stat->received_octet_cnt, fld_64[1], fld_64[0]); 2542 /* out_of_order_octet_cnt FlowStatAccumEntry1 OooOctetCntrAccumLsb bits[249:217] 2543 * FlowStatAccumEntry2 OooOctetCntrAccumMsb bits[15:0] 2544 */ 2545 offset_base += len; 2546 len = 49; 2547 fld_64[0] = fld_64[1] = 0; 2548 SHR_BITCOPY_RANGE(fld_64, 0, reg_above64_val_3, offset_base, len); 2549 COMPILER_64_SET(stat->out_of_order_octet_cnt, fld_64[1], fld_64[0]); 2550 /* err_octet_cnt FlowStatAccumEntry2 ErrOctetCntrAccum bits[64:16] */ 2551 offset_base += len; 2552 len = 49; 2553 fld_64[0] = fld_64[1] = 0; 2554 SHR_BITCOPY_RANGE(fld_64, 0, reg_above64_val_3, offset_base, len); 2555 COMPILER_64_SET(stat->err_octet_cnt, fld_64[1], fld_64[0]); 2556 /* uint64 last_packet_delay FlowStatAccumEntry2 LastPktDelayAccum bits[96:65] */ 2557 offset_base += len; 2558 len = 32; 2559 fld_64[0] = fld_64[1] = 0; 2560 SHR_BITCOPY_RANGE(fld_64, 0, reg_above64_val_3, offset_base, len); 2561 COMPILER_64_SET(stat->last_packet_delay, fld_64[1], fld_64[0]); 2562 /* bin_delay_counters[0] FlowStatAccumEntry2 FdvBin0PktCntrAccum bits[138:97] */ 2563 offset_base += len; 2564 len = 42; 2565 fld_64[0] = fld_64[1] = 0; 2566 SHR_BITCOPY_RANGE(fld_64, 0, reg_above64_val_3, offset_base, len); 2567 COMPILER_64_SET(stat->bin_delay_counters[0], fld_64[1], fld_64[0]); 2568 /* bin_delay_counters[1] FlowStatAccumEntry2 FdvBin1PktCntrAccum bits[180:139] */ 2569 offset_base += len; 2570 len = 42; 2571 fld_64[0] = fld_64[1] = 0; 2572 SHR_BITCOPY_RANGE(fld_64, 0, reg_above64_val_3, offset_base, len); 2573 COMPILER_64_SET(stat->bin_delay_counters[1], fld_64[1], fld_64[0]); 2574 /* bin_delay_counters[2] FlowStatAccumEntry2 FdvBin2PktCntrAccum bits[222:181] */ 2575 offset_base += len; 2576 len = 42; 2577 fld_64[0] = fld_64[1] = 0; 2578 SHR_BITCOPY_RANGE(fld_64, 0, reg_above64_val_3, offset_base, len); 2579 COMPILER_64_SET(stat->bin_delay_counters[2], fld_64[1], fld_64[0]); 2580 /* bin_delay_counters[3] FlowStatAccumEntry2 FdvBin3PktCntrAccumLsb bits[249:223] 2581 * FlowStatAccumEntry3 FdvBin3PktCntrAccumMsb bits[14:0] 2582 */ 2583 offset_base += len; 2584 len = 42; 2585 fld_64[0] = fld_64[1] = 0; 2586 SHR_BITCOPY_RANGE(fld_64, 0, reg_above64_val_3, offset_base, len); 2587 COMPILER_64_SET(stat->bin_delay_counters[3], fld_64[1], fld_64[0]); 2588 /* bin_delay_counters[4] FlowStatAccumEntry3 FdvBin4PktCntrAccum bits[56:15] */ 2589 offset_base += len; 2590 len = 42; 2591 fld_64[0] = fld_64[1] = 0; 2592 SHR_BITCOPY_RANGE(fld_64, 0, reg_above64_val_3, offset_base, len); 2593 COMPILER_64_SET(stat->bin_delay_counters[4], fld_64[1], fld_64[0]); 2594 2595 /* OAMP_RX_STATS_DATA_3 and OAMP_RX_STATS_DATA_4 2596 * uint64 bin_delay_counters[5] FlowStatAccumEntry3 FdvBin5PktCntrAccum bits[98:57] 2597 */ 2598 offset_base += len; 2599 /* Get bits[59:57] from OAMP_RX_STATS_DATA_3 */ 2600 len = 3; 2601 fld_64[0] = fld_64[1] = 0; 2602 SHR_BITCOPY_RANGE(&bin_delay_counters_5_3lsbs, 0, reg_above64_val_3, offset_base, len); 2603 offset_base = 0; 2604 len = 39; 2605 SHR_BITCOPY_RANGE(fld_64, 0, reg_above64_val_4, offset_base, len); 2606 bin_delay_counters_5_low = (((fld_64[0] & 0x1FFFFFFF) << 3) | bin_delay_counters_5_3lsbs); 2607 bin_delay_counters_5_high = (((fld_64[1] & 0x7F) << 3) | (fld_64[0] >> 29)); 2608 COMPILER_64_SET(stat->bin_delay_counters[5], bin_delay_counters_5_high, bin_delay_counters_5_low); 2609 /* bin_delay_counters[6] FlowStatAccumEntry3 FdvBin6PktCntrAccum bits[140:99] */ 2610 offset_base += len; 2611 len = 42; 2612 fld_64[0] = fld_64[1] = 0; 2613 SHR_BITCOPY_RANGE(fld_64, 0, reg_above64_val_4, offset_base, len); 2614 COMPILER_64_SET(stat->bin_delay_counters[6], fld_64[1], fld_64[0]); 2615 /* bin_delay_counters[7] FlowStatAccumEntry3 FdvBin7PktCntrAccum bits[182:141] */ 2616 offset_base += len; 2617 len = 42; 2618 fld_64[0] = fld_64[1] = 0; 2619 SHR_BITCOPY_RANGE(fld_64, 0, reg_above64_val_4, offset_base, len); 2620 COMPILER_64_SET(stat->bin_delay_counters[7], fld_64[1], fld_64[0]); 2621 /* bin_delay_counters[8] FlowStatAccumEntry3 FdvBin8PktCntrAccum bits[224:183] 2622 */ 2623 offset_base += len; 2624 len = 42; 2625 fld_64[0] = fld_64[1] = 0; 2626 SHR_BITCOPY_RANGE(fld_64, 0, reg_above64_val_4, offset_base, len); 2627 COMPILER_64_SET(stat->bin_delay_counters[8], fld_64[1], fld_64[0]); 2628 /* bin_delay_counters[9] FlowStatAccumEntry3 FdvBin9PktCntrAccumLsb bits[249:225] 2629 * FlowStatAccumEntry4 FdvBin9PktCntrAccumMsb bits[16:0] 2630 */ 2631 offset_base += len; 2632 len = 42; 2633 fld_64[0] = fld_64[1] = 0; 2634 SHR_BITCOPY_RANGE(fld_64, 0, reg_above64_val_4, offset_base, len); 2635 COMPILER_64_SET(stat->bin_delay_counters[9], fld_64[1], fld_64[0]); 2636 /* accumulated_delay_count FlowStatAccumEntry4 AccumDelayCntrAccum bits[80:17] */ 2637 offset_base += len; 2638 len = 64; 2639 fld_64[0] = fld_64[1] = 0; 2640 SHR_BITCOPY_RANGE(fld_64, 0, reg_above64_val_4, offset_base, len); 2641 COMPILER_64_SET(stat->accumulated_delay_count, fld_64[1], fld_64[0]); 2642 /* max_packet_delay FlowStatAccumEntry4 MaxPktDelayAccum bits [112:81] */ 2643 offset_base += len; 2644 len = 32; 2645 fld_64[0] = fld_64[1] = 0; 2646 SHR_BITCOPY_RANGE(fld_64, 0, reg_above64_val_4, offset_base, len); 2647 COMPILER_64_SET(stat->max_packet_delay, fld_64[1], fld_64[0]); 2648 /* min_packet_delay FlowStatAccumEntry4 MinPktDelayAccum bits [144:113] */ 2649 offset_base += len; 2650 len = 32; 2651 fld_64[0] = fld_64[1] = 0; 2652 SHR_BITCOPY_RANGE(fld_64, 0, reg_above64_val_4, offset_base, len); 2653 COMPILER_64_SET(stat->min_packet_delay, fld_64[1], fld_64[0]); 2654 /* time_of_day_stamp FlowStatAccumEntry4 TodStampAccum bits [208:145] */ 2655 offset_base += len; 2656 len = 64; 2657 fld_64[0] = fld_64[1] = 0; 2658 SHR_BITCOPY_RANGE(fld_64, 0, reg_above64_val_4, offset_base, len); 2659 COMPILER_64_SET(stat->time_of_day_stamp, fld_64[1], fld_64[0]); 2660 /* sec_in_avail_state_counter FlowStatAccumEntry4 SecInAvailStateCntr bits[226:209] */ 2661 offset_base += len; 2662 len = 16; 2663 fld_64[0] = fld_64[1] = 0; 2664 SHR_BITCOPY_RANGE(fld_64, 0, reg_above64_val_4, offset_base, len); 2665 COMPILER_64_SET(stat->sec_in_avail_state_counter, fld_64[1], fld_64[0]); 2666 2667 /* last_packet_seq_number */ 2668 rv = READ_OAMP_SAT_RX_FLOW_PARAMSm(unit, MEM_BLOCK_ANY, ctf_id, data); 2669 if (SOC_FAILURE(rv)) { 2670 LOG_ERROR(BSL_LS_SOC_SAT, 2671 (BSL_META_U(unit, 2672 "%s\n"), soc_errmsg(rv))); 2673 return rv; 2674 } 2675 2676 /* Expected sequence number always increase 1 based on received packet. 2677 * So last packet sequence number will be expected sequence number -1. 2678 */ 2679 fld_64[0] = fld_64[1] = 0; 2680 fld_64[0] = soc_mem_field32_get(unit, OAMP_SAT_RX_FLOW_PARAMSm, &data, EXP_SEQ_NUMBERf); 2681 fld_64[0]--; 2682 COMPILER_64_SET(stat->last_packet_seq_number, fld_64[1], fld_64[0]); 2683 2684 return rv; 2685 } 2686 2687 soc_error_t soc_sat_ctf_availability_config_set ( 2688 SOC_SAND_IN int unit, 2689 SOC_SAND_IN soc_sat_ctf_t ctf_id, 2690 SOC_SAND_IN soc_sat_ctf_availability_config_t *config 2691 ) 2692 { 2693 int rv = SOC_E_NONE; 2694 uint64 reg_val; 2695 2696 COMPILER_64_ZERO(reg_val); 2697 rv = READ_OAMP_SAT_RX_STATr(unit, ®_val); 2698 if (SOC_FAILURE(rv)) { 2699 LOG_ERROR(BSL_LS_SOC_SAT, 2700 (BSL_META_U(unit, 2701 "%s\n"), soc_errmsg(rv))); 2702 return rv; 2703 } 2704 soc_reg64_field32_set(unit, OAMP_SAT_RX_STATr, ®_val, RX_STATS_FLOW_IDf, ctf_id); 2705 soc_reg64_field32_set(unit, OAMP_SAT_RX_STATr, ®_val, RX_STATS_NEW_NUM_SLTSf, config->switch_state_num_of_slots); 2706 soc_reg64_field32_set(unit, OAMP_SAT_RX_STATr, ®_val, RX_STATS_NEW_THRSHf , config->switch_state_threshold_per_slot); 2707 rv = WRITE_OAMP_SAT_RX_STATr(unit, reg_val); 2708 if (SOC_FAILURE(rv)) { 2709 LOG_ERROR(BSL_LS_SOC_SAT, 2710 (BSL_META_U(unit, 2711 "%s\n"), soc_errmsg(rv))); 2712 } 2713 2714 soc_reg64_field32_set(unit, OAMP_SAT_RX_STATr, ®_val, RX_STATS_RST_STATE_MCHNf, 1); 2715 rv = WRITE_OAMP_SAT_RX_STATr(unit, reg_val); 2716 if (SOC_FAILURE(rv)) { 2717 LOG_ERROR(BSL_LS_SOC_SAT, 2718 (BSL_META_U(unit, 2719 "%s\n"), soc_errmsg(rv))); 2720 } 2721 sal_udelay(1000); 2722 soc_reg64_field32_set(unit, OAMP_SAT_RX_STATr, ®_val, RX_STATS_RST_STATE_MCHNf, 0); 2723 rv = WRITE_OAMP_SAT_RX_STATr(unit, reg_val); 2724 if (SOC_FAILURE(rv)) { 2725 LOG_ERROR(BSL_LS_SOC_SAT, 2726 (BSL_META_U(unit, 2727 "%s\n"), soc_errmsg(rv))); 2728 } 2729 2730 return rv; 2731 } 2732 2733 soc_error_t soc_sat_ctf_trap_data_to_session_map ( 2734 SOC_SAND_IN int unit, 2735 SOC_SAND_IN uint32 trap_data, 2736 SOC_SAND_IN uint32 trap_data_mask, 2737 SOC_SAND_IN uint32 entry_idx, 2738 SOC_SAND_IN uint32 session_id 2739 ) 2740 { 2741 int rv = SOC_E_NONE; 2742 uint64 data; /* Entry include 33 bits - Key bits[13:0], Mask bits[27:14] Dat bits[31:28] Valid[32] */ 2743 int valid_fld = 1; 2744 2745 COMPILER_64_ZERO(data); 2746 rv = READ_OAMP_RX_OAM_ID_TCAMm(unit, MEM_BLOCK_ANY, entry_idx, &data); 2747 if (SOC_FAILURE(rv)) { 2748 LOG_ERROR(BSL_LS_SOC_SAT, 2749 (BSL_META_U(unit, 2750 "%s\n"), soc_errmsg(rv))); 2751 return rv; 2752 } 2753 2754 soc_mem_field32_set(unit, OAMP_RX_OAM_ID_TCAMm, &data, KEYf, trap_data); 2755 soc_mem_field32_set(unit, OAMP_RX_OAM_ID_TCAMm, &data, MASKf, trap_data_mask); 2756 soc_mem_field32_set(unit, OAMP_RX_OAM_ID_TCAMm, &data, DATf, session_id); 2757 soc_mem_field32_set(unit, OAMP_RX_OAM_ID_TCAMm, &data, VALIDf, valid_fld); 2758 2759 2760 if (SOC_IS_QUX(unit)) { 2761 rv = soc_sat_dynamic_memory_access_set(unit, 1); 2762 if (SOC_FAILURE(rv)) { 2763 LOG_ERROR(BSL_LS_SOC_SAT, 2764 (BSL_META_U(unit, 2765 "Fail(%s) in soc_sat_dynamic_memory_access_set\n"), soc_errmsg(rv))); 2766 return rv; 2767 } 2768 } 2769 2770 rv = WRITE_OAMP_RX_OAM_ID_TCAMm(unit, MEM_BLOCK_ALL, entry_idx, &data); 2771 if (SOC_FAILURE(rv)) { 2772 LOG_ERROR(BSL_LS_SOC_SAT, 2773 (BSL_META_U(unit, 2774 "%s\n"), soc_errmsg(rv))); 2775 } 2776 2777 if (SOC_IS_QUX(unit)) { 2778 rv = soc_sat_dynamic_memory_access_set(unit, 0); 2779 if (SOC_FAILURE(rv)) { 2780 LOG_ERROR(BSL_LS_SOC_SAT, 2781 (BSL_META_U(unit, 2782 "Fail(%s) in soc_sat_dynamic_memory_access_set\n"), soc_errmsg(rv))); 2783 return rv; 2784 } 2785 } 2786 2787 return rv; 2788 } 2789 2790 soc_error_t soc_sat_ctf_trap_data_to_session_unmap ( 2791 SOC_SAND_IN int unit, 2792 SOC_SAND_IN uint32 entry_idx 2793 ) 2794 { 2795 int rv = SOC_E_NONE; 2796 uint64 data;/* Entry include 33 bits - Key bits[13:0], Mask bits[27:14] Dat bits[31:28] Valid[32] */ 2797 int valid_fld = 0; 2798 uint32 zero = 0; 2799 2800 COMPILER_64_ZERO(data); 2801 rv = READ_OAMP_RX_OAM_ID_TCAMm(unit, MEM_BLOCK_ANY, entry_idx, &data); 2802 if (SOC_FAILURE(rv)) { 2803 LOG_ERROR(BSL_LS_SOC_SAT, 2804 (BSL_META_U(unit, 2805 "%s\n"), soc_errmsg(rv))); 2806 return rv; 2807 } 2808 2809 soc_mem_field32_set(unit, OAMP_RX_OAM_ID_TCAMm, &data, KEYf, zero); 2810 soc_mem_field32_set(unit, OAMP_RX_OAM_ID_TCAMm, &data, MASKf, zero); 2811 soc_mem_field32_set(unit, OAMP_RX_OAM_ID_TCAMm, &data, DATf, zero); 2812 soc_mem_field32_set(unit, OAMP_RX_OAM_ID_TCAMm, &data, VALIDf, valid_fld); 2813 2814 if (SOC_IS_QUX(unit)) { 2815 rv = soc_sat_dynamic_memory_access_set(unit, 1); 2816 if (SOC_FAILURE(rv)) { 2817 LOG_ERROR(BSL_LS_SOC_SAT, 2818 (BSL_META_U(unit, 2819 "Fail(%s) in soc_sat_dynamic_memory_access_set\n"), soc_errmsg(rv))); 2820 return rv; 2821 } 2822 } 2823 2824 rv = WRITE_OAMP_RX_OAM_ID_TCAMm(unit, MEM_BLOCK_ALL, entry_idx, &data); 2825 if (SOC_FAILURE(rv)) { 2826 LOG_ERROR(BSL_LS_SOC_SAT, 2827 (BSL_META_U(unit, 2828 "%s\n"), soc_errmsg(rv))); 2829 } 2830 2831 if (SOC_IS_QUX(unit)) { 2832 rv = soc_sat_dynamic_memory_access_set(unit, 0); 2833 if (SOC_FAILURE(rv)) { 2834 LOG_ERROR(BSL_LS_SOC_SAT, 2835 (BSL_META_U(unit, 2836 "Fail(%s) in soc_sat_dynamic_memory_access_set\n"), soc_errmsg(rv))); 2837 return rv; 2838 } 2839 } 2840 2841 return rv; 2842 } 2843 2844 soc_error_t soc_sat_ctf_reports_config_set ( 2845 SOC_SAND_IN int unit, 2846 SOC_SAND_IN soc_sat_ctf_t ctf_id, 2847 SOC_SAND_IN soc_sat_ctf_report_config_t *reports 2848 ) 2849 { 2850 int rv = SOC_E_NONE; 2851 uint32 field = 0; 2852 uint32 2853 data[SOC_SAT_CTF_RX_FLOW_PARAMS_ENTRY_SIZE]; 2854 2855 /* For writing on dynamic tables (in the OAMP), have to enable dynamic memory access */ 2856 rv = soc_sat_dynamic_memory_access_set(unit, 1); 2857 if (SOC_FAILURE(rv)) { 2858 LOG_ERROR(BSL_LS_SOC_SAT, 2859 (BSL_META_U(unit, 2860 "%s\n"), soc_errmsg(rv))); 2861 return rv; 2862 } 2863 2864 sal_memset(data, 0, sizeof(data)); 2865 rv = READ_OAMP_SAT_RX_FLOW_PARAMSm(unit, MEM_BLOCK_ANY, ctf_id, data); 2866 if (SOC_FAILURE(rv)) { 2867 LOG_ERROR(BSL_LS_SOC_SAT, 2868 (BSL_META_U(unit, 2869 "%s\n"), soc_errmsg(rv))); 2870 goto exit; 2871 } 2872 /* TIME_STAMP_OFFSETf */ 2873 if (reports->report_sampling_percent == 0){ 2874 /* never report */ 2875 field = 255; 2876 } 2877 else if (reports->report_sampling_percent == SOC_SAT_CTF_REPORT_SAMPLING_PER_MAX) { 2878 /* always report */ 2879 field = 0; 2880 } 2881 else { 2882 field = (reports->report_sampling_percent*255/100); 2883 } 2884 2885 soc_mem_field32_set(unit, OAMP_SAT_RX_FLOW_PARAMSm, &data, RPRT_LFSR_THREHOLDf, field); 2886 if (reports->flags & SOC_SAT_CTF_REPORT_ADD_SEQ_NUM) { 2887 field = 1; 2888 } else { 2889 field = 0; 2890 } 2891 soc_mem_field32_set(unit, OAMP_SAT_RX_FLOW_PARAMSm, &data, RPRT_PKT_SEQ_NUMf, field); 2892 if (reports->flags & SOC_SAT_CTF_REPORT_ADD_DELAY) { 2893 field = 1; 2894 } else { 2895 field = 0; 2896 } 2897 soc_mem_field32_set(unit, OAMP_SAT_RX_FLOW_PARAMSm, &data, RPRT_PKT_DELAYf, field); 2898 2899 rv = WRITE_OAMP_SAT_RX_FLOW_PARAMSm(unit, MEM_BLOCK_ALL, ctf_id, data); 2900 if (SOC_FAILURE(rv)) { 2901 LOG_ERROR(BSL_LS_SOC_SAT, 2902 (BSL_META_U(unit, 2903 "%s\n"), soc_errmsg(rv))); 2904 goto exit; 2905 } 2906 exit: 2907 /* After done, disable dynamic memory access */ 2908 soc_sat_dynamic_memory_access_set(unit, 0); 2909 return rv; 2910 } 2911 2912 soc_error_t soc_sat_oamp_stat_event_control( 2913 SOC_SAND_IN int unit, 2914 SOC_SAND_IN int enable) 2915 { 2916 uint32 state, rval; 2917 2918 if (enable) { 2919 state = 1; 2920 } else { 2921 state = 0; 2922 } 2923 2924 SOC_IF_ERROR_RETURN(READ_OAMP_INTERRUPT_MASK_REGISTERr(unit, &rval)); 2925 soc_reg_field_set(unit, OAMP_INTERRUPT_MASK_REGISTERr, &rval, 2926 STAT_PENDING_EVENT_MASKf, state); 2927 SOC_IF_ERROR_RETURN(WRITE_OAMP_INTERRUPT_MASK_REGISTERr(unit, rval)); 2928 2929 return SOC_E_NONE; 2930 } 2931 2932 soc_error_t soc_sat_oamp_stat_event_clear( 2933 SOC_SAND_IN int unit) 2934 { 2935 uint32 rval; 2936 2937 SOC_IF_ERROR_RETURN(READ_OAMP_INTERRUPT_REGISTERr(unit, &rval)); 2938 soc_reg_field_set(unit, OAMP_INTERRUPT_REGISTERr, &rval, 2939 STAT_PENDING_EVENTf, 1); 2940 SOC_IF_ERROR_RETURN(WRITE_OAMP_INTERRUPT_REGISTERr(unit, rval)); 2941 2942 return SOC_E_NONE; 2943 } 2944 2945 soc_error_t soc_common_sat_handler_register( 2946 int unit, 2947 soc_sat_handler_t handler) 2948 { 2949 int rv = SOC_E_NONE; 2950 2951 _soc_sat_handler[unit] = handler; 2952 2953 return rv; 2954 } 2955 2956 soc_error_t soc_common_sat_handler_get( 2957 int unit, 2958 soc_sat_handler_t *handler) 2959 { 2960 int rv = SOC_E_NONE; 2961 2962 *handler = _soc_sat_handler[unit]; 2963 2964 return rv; 2965 } 2966 2967 int soc_sat_session_inuse( 2968 SOC_SAND_IN int unit, 2969 SOC_SAND_IN int session_id) 2970 { 2971 int rv = SOC_E_NONE; 2972 int idx; 2973 uint64 data; 2974 uint8 valid_fld = 0; 2975 uint32 session; 2976 2977 COMPILER_64_ZERO(data); 2978 for (idx = 0; idx < 16; idx++) { 2979 rv = READ_OAMP_RX_OAM_ID_TCAMm(unit, MEM_BLOCK_ANY, idx, &data); 2980 if (SOC_FAILURE(rv)) { 2981 LOG_ERROR(BSL_LS_SOC_SAT, 2982 (BSL_META_U(unit, 2983 "soc_common_sat_session_inuse: %s\n"), soc_errmsg(rv))); 2984 return TRUE; 2985 } 2986 2987 valid_fld = soc_mem_field32_get(unit, OAMP_RX_OAM_ID_TCAMm, &data, VALIDf); 2988 session = soc_mem_field32_get(unit, OAMP_RX_OAM_ID_TCAMm, &data, DATf); 2989 2990 if (valid_fld && (session_id == session)) { 2991 return TRUE; 2992 } 2993 } 2994 2995 return FALSE; 2996 } 2997 2998 #ifdef BCM_WARM_BOOT_SUPPORT 2999 int 3000 soc_sat_wb_init(int unit) 3001 { 3002 _soc_sat_data_t *psat_data; 3003 int rv = BCM_E_NONE; 3004 uint32 size; 3005 uint32 scache_handle; 3006 uint8 *scache_ptr = NULL; 3007 uint16 default_ver = SOC_SAT_WB_CURRENT_VERSION; 3008 uint16 recovered_ver = SOC_SAT_WB_CURRENT_VERSION; 3009 int stable_size; 3010 int create; 3011 3012 if (SOC_IS_QAX(unit)) { 3013 return rv; 3014 } 3015 psat_data = &(soc_sat_data[unit]); 3016 3017 /* check to see if an scache table has been configured */ 3018 rv = soc_stable_size_get(unit, &stable_size); 3019 if (SOC_FAILURE(rv) || stable_size <= 0) { 3020 return rv; 3021 } 3022 3023 SOC_SCACHE_HANDLE_SET(scache_handle, unit, SOC_SCACHE_SOC_SAT_HANDLE, 0); 3024 create = (SOC_WARM_BOOT(unit) ? FALSE : TRUE); 3025 size = (SOC_WARM_BOOT(unit) ? 0 : sizeof(_soc_sat_data_t)); 3026 3027 /* on cold boot, setup scache */ 3028 rv = soc_versioned_scache_ptr_get(unit, scache_handle, 3029 create, 3030 &size, &scache_ptr, 3031 default_ver, &recovered_ver); 3032 if (BCM_FAILURE(rv) && (rv != SOC_E_NOT_FOUND)) { 3033 LOG_ERROR(BSL_LS_SOC_SAT, 3034 (BSL_META_U(unit, 3035 "Error(%s) reading scache. scache_ptr:%p and len:%d\n"), 3036 soc_errmsg(rv), scache_ptr, size)); 3037 /* If warmboot initialization fails, skip using warmboot for sat */ 3038 rv = SOC_E_NOT_FOUND; 3039 return rv; 3040 } 3041 3042 LOG_VERBOSE(BSL_LS_SOC_SAT, 3043 (BSL_META_U(unit, 3044 "SAT: allocating 0x%x (%d) bytes of scache:"), 3045 size, size)); 3046 3047 if (SOC_WARM_BOOT(unit)) { 3048 soc_scache_handle_used_set(unit, scache_handle, size); 3049 /* if supporting warmboot, use scache */ 3050 if (scache_ptr) { 3051 sal_memcpy(psat_data, scache_ptr, sizeof(_soc_sat_data_t)); 3052 } 3053 } 3054 3055 return BCM_E_NONE; 3056 } 3057 3058 int 3059 soc_sat_wb_sync(int unit, int sync) 3060 { 3061 int rv = BCM_E_NONE; 3062 uint8 *scache_ptr = NULL; 3063 uint32 scache_len = 0; 3064 soc_scache_handle_t scache_handle; 3065 uint16 default_ver = SOC_SAT_WB_CURRENT_VERSION; 3066 uint16 recovered_ver = SOC_SAT_WB_CURRENT_VERSION; 3067 _soc_sat_data_t *psat_data; 3068 int stable_size; 3069 3070 if (SOC_IS_QAX(unit)) { 3071 return rv; 3072 } 3073 3074 psat_data = &(soc_sat_data[unit]); 3075 3076 if (SOC_WARM_BOOT(unit)) { 3077 LOG_ERROR(BSL_LS_SOC_SAT, 3078 (BSL_META_U(unit, 3079 "Cannot write to SCACHE during WarmBoot\n"))); 3080 return SOC_E_INTERNAL; 3081 } 3082 /* check to see if an scache table has been configured */ 3083 rv = soc_stable_size_get(unit, &stable_size); 3084 if (SOC_FAILURE(rv) || stable_size <= 0) { 3085 return rv; 3086 } 3087 3088 SOC_SCACHE_HANDLE_SET(scache_handle, unit, SOC_SCACHE_SOC_SAT_HANDLE, 0); 3089 3090 rv = soc_versioned_scache_ptr_get(unit, scache_handle, 3091 FALSE, &scache_len, &scache_ptr, 3092 default_ver, &recovered_ver); 3093 if (SOC_FAILURE(rv) && (rv != SOC_E_NOT_FOUND)) { 3094 LOG_ERROR(BSL_LS_SOC_SAT, 3095 (BSL_META_U(unit, 3096 "Error(%s) reading scache. scache_ptr:%p and len:%d\n"), 3097 soc_errmsg(rv), scache_ptr, scache_len)); 3098 return rv; 3099 } 3100 3101 sal_memcpy(scache_ptr, psat_data, sizeof(_soc_sat_data_t)); 3102 3103 rv = soc_scache_handle_used_set(unit, scache_handle, sizeof(_soc_sat_data_t)); 3104 3105 if (sync) { 3106 rv = soc_scache_commit(unit); 3107 if (rv != SOC_E_NONE) { 3108 LOG_ERROR(BSL_LS_SOC_SAT, 3109 (BSL_META_U(unit, 3110 "Error(%s) sync'ing scache to Persistent memory. \n"), 3111 soc_errmsg(rv))); 3112 return rv; 3113 } 3114 } 3115 3116 return BCM_E_NONE; 3117 } 3118 3119 int soc_sat_wb_deinit(int unit) 3120 { 3121 int rv = SOC_E_NONE; 3122 _soc_sat_data_t *psat_data; 3123 3124 if (SOC_IS_QAX(unit)) { 3125 return rv; 3126 } 3127 3128 psat_data = &(soc_sat_data[unit]); 3129 sal_memset(psat_data, 0, sizeof(_soc_sat_data_t)); 3130 3131 return rv; 3132 } 3133 #endif /* BCM_WARM_BOOT_SUPPORT */ 3134 3135 3136 #endif /* BCM_SAT_SUPPORT */