ft_alu.h (21929B)
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 * File: ft_group.h 8 * Purpose: Function declarations for flowtracker group. 9 */ 10 11 #ifndef _BCM_INT_FT_ALU_H_ 12 #define _BCM_INT_FT_ALU_H_ 13 14 #include <shared/bsl.h> 15 #include <sal/core/boot.h> 16 #include <soc/helix5.h> 17 #include <soc/bradley.h> 18 #include <soc/drv.h> 19 #include <bcm/error.h> 20 #include <soc/debug.h> 21 #include <soc/mem.h> 22 #include <soc/mspi.h> 23 #include <bcm_int/esw/trx.h> 24 #include <bcm/flowtracker.h> 25 #include <bcm_int/esw/flowtracker/ft_field.h> 26 27 28 #include <soc/defs.h> 29 30 #if defined(BCM_FLOWTRACKER_SUPPORT) 31 32 33 #define BCMI_FT_SESSION_DATA_SINGLE_LEN 256 34 35 36 /************************************************************************/ 37 38 /* Groups internal Declarations. */ 39 40 /* These are 1-bit attributes of packet/objects of flow. */ 41 typedef enum bcm_flowtracker_flowchecker_attr_e { 42 bcmFlowtrackerFlowCheckerAttrTcpFlagUrg = 0, 43 bcmFlowtrackerFlowCheckerAttrTcpFlagAck = 1, 44 bcmFlowtrackerFlowCheckerAttrTcpFlagPsh = 2, 45 bcmFlowtrackerFlowCheckerAttrTcpFlagRst = 3, 46 bcmFlowtrackerFlowCheckerAttrTcpFlagSyn = 4, 47 bcmFlowtrackerFlowCheckerAttrTcpFlagFin = 5, 48 bcmFlowtrackerFlowCheckerAttrCount = 6 49 } bcm_flowtracker_flowchecker_attr_t; 50 51 typedef enum bcmi_flowtracker_check_set_e { 52 bcmFlowtrackerFlowCheckTsSet=0, 53 bcmFlowtrackerFlowCheckTsReset = 1 54 } bcmi_flowtracker_check_set_t; 55 56 typedef struct bcmi_flowtracker_flowchecker_info_s { 57 58 uint32 flags; 59 60 /* Primary check of this flowchecker. */ 61 bcm_flowtracker_check_info_t check1; 62 63 /* Second check of this flowchecker. */ 64 bcm_flowtracker_check_info_t check2; 65 66 /* Action to be performed for this flowchecker. */ 67 bcm_flowtracker_check_action_info_t action_info; 68 69 /* Export action information for this flowchecker. */ 70 bcm_flowtracker_check_export_info_t export_info; 71 72 } bcmi_flowtracker_flowchecker_info_t; 73 74 75 76 typedef struct bcmi_ft_flowchecker_list_s { 77 bcm_flowtracker_check_t flowchecker_id; 78 struct bcmi_ft_flowchecker_list_s *next; 79 } bcmi_ft_flowchecker_list_t; 80 81 82 typedef struct bcmi_ft_alu_key_s { 83 int location; 84 int is_alu; 85 int length; 86 } bcmi_ft_alu_key_t; 87 88 typedef enum bcmi_ft_alu_load_type_e { 89 bcmiFtAluLoadTypeLoad8=0, 90 bcmiFtAluLoadTypeLoad16=1, 91 bcmiFtAluLoadTypeAlu16=2, 92 bcmiFtAluLoadTypeAlu32=3, 93 bcmiFtAluLoadTypeNone=4 94 } bcmi_ft_alu_load_type_t; 95 96 extern uint8 alu_type_str[5][50]; 97 98 /* ALU/LOAD internal flags. */ 99 /* Next element is attached to this. */ 100 #define BCMI_FT_ALU_LOAD_NEXT_ATTACH (1 << 0) 101 102 /* Below is the information that FTFP will send to Group. */ 103 typedef struct bcmi_ft_group_alu_info_s { 104 105 /* Flags. */ 106 uint32 flags; 107 108 /* Check 1 data.*/ 109 bcmi_ft_alu_key_t key1; 110 /* Element type. */ 111 bcm_flowtracker_tracking_param_type_t element_type1; 112 113 114 /* Check 2 data.*/ 115 bcmi_ft_alu_key_t key2; 116 /* Element type. */ 117 bcm_flowtracker_tracking_param_type_t element_type2; 118 119 /* action data.*/ 120 bcmi_ft_alu_key_t action_key; 121 /* Element type. */ 122 bcm_flowtracker_tracking_param_type_t action_element_type; 123 124 /* id of this flowchecker. */ 125 bcm_flowtracker_check_t flowchecker_id; 126 127 /* These are needed for warmboot and may be for SER. */ 128 int alu_load_index; 129 bcmi_ft_alu_load_type_t alu_load_type; 130 131 } bcmi_ft_group_alu_info_t; 132 133 134 typedef struct bcmi_ft_element_alu_info_s { 135 bcm_flowtracker_tracking_param_type_t element; 136 137 bcm_flowtracker_check_operation_t operation; 138 bcm_flowtracker_check_action_t action; 139 } bcmi_ft_element_alu_info_t; 140 141 /* Below is the information what will be stored in hash table. */ 142 typedef struct bcmi_ft_alu_hash_info_s { 143 int alu_load_index; 144 bcmi_ft_alu_load_type_t alu_load_type; 145 146 bcmi_ft_alu_key_t key; 147 148 uint16 param; 149 150 /* Update parameters. */ 151 int update_location; 152 153 /* id of this flowchecker. */ 154 bcmi_ft_flowchecker_list_t *head; 155 156 /* Group direction. */ 157 bcm_flowtracker_direction_t direction; 158 159 } bcmi_ft_alu_hash_info_t; 160 161 162 163 typedef struct bcmi_ft_alu_entry_list_s { 164 bcmi_ft_alu_hash_info_t alu_info; 165 struct bcmi_ft_alu_entry_list_s *link; 166 } bcmi_ft_alu_entry_list_t; 167 168 typedef struct bcmi_ft_alu_table_hash_s { 169 bcmi_ft_alu_entry_list_t *head_link; 170 } bcmi_ft_alu_table_hash_t; 171 172 /* Hash table defines. */ 173 #define BCMI_FT_ALU_HASH_BUCKETS 1024 174 #define BCMI_FT_ALU_HASH_KEY_LEN_IN_WORDS 7 175 176 177 178 /* Total ALU memories and their data sizes. */ 179 #define TOTAL_GROUP_ALU32_MEM 12 180 #define TOTAL_GROUP_ALU16_MEM 8 181 #define TOTAL_GROUP_LOAD16_MEM 1 182 #define TOTAL_GROUP_LOAD8_MEM 1 183 #define TOTAL_GROUP_LOAD16_DATA_NUM 16 184 #define TOTAL_GROUP_LOAD8_DATA_NUM 8 185 186 187 typedef struct bcmi_ft_flowchecker_s { 188 int bcmi_flowchecker_id; 189 bcm_flowtracker_check_t flow_checker; 190 struct bcmi_ft_flowchecker_s *next; 191 } bcmi_ft_flowchecker_t; 192 193 194 #define BCMI_FT_ALU_LOAD_MEMS 4 195 196 197 typedef struct alu_load_info_s { 198 soc_mem_t mem; 199 int mem_size; 200 int pdd_bit; 201 } alu_load_info_t; 202 203 typedef struct bcmi_ft_group_pdd_bus_info_s { 204 int param_id; 205 int end; 206 int start; 207 int length; 208 } bcmi_ft_group_pdd_bus_info_t; 209 210 typedef struct alu_load_index_info_s { 211 int total_mem_count; 212 int total_idx_per_memory; 213 SHR_BITDCL *index_bitmap; 214 /* refcounts for all the indexes on this memory. */ 215 uint32 *idx_refcount; 216 alu_load_info_t *alu_load_info; 217 bcmi_ft_group_pdd_bus_info_t *pdd_bus_info; 218 uint32 *group_fid_info; 219 } alu_load_index_info_t; 220 221 222 223 /* Chip Debug structure. */ 224 typedef struct bcmi_ft_chip_debug_param_s { 225 bcm_flowtracker_tracking_param_type_t param; 226 bcmi_ft_alu_load_type_t alu_type; 227 int mem_id; 228 uint32 count; 229 /* int count_installed;*/ 230 } bcmi_ft_chip_debug_param_t; 231 232 typedef struct bcmi_ft_chip_debug_s { 233 int chip_debug_enable; 234 int num_debug_info; 235 int alu32_mem_used[TOTAL_GROUP_ALU32_MEM]; 236 int alu16_mem_used[TOTAL_GROUP_ALU16_MEM]; 237 int alu32_ref_count[TOTAL_GROUP_ALU32_MEM]; 238 int alu16_ref_count[TOTAL_GROUP_ALU16_MEM]; 239 240 /* 241 int alu32_mem_used[TOTAL_GROUP_ALU32_MEM]; 242 int alu16_mem_used[TOTAL_GROUP_ALU16_MEM]; 243 */ 244 245 bcmi_ft_chip_debug_param_t *param_info; 246 } bcmi_ft_chip_debug_t; 247 248 249 250 extern bcmi_ft_chip_debug_t chip_debug_info[BCM_MAX_NUM_UNITS]; 251 252 extern uint32 bcmi_dg_alu32_counters[TOTAL_GROUP_ALU32_MEM]; 253 extern uint32 bcmi_dg_alu16_counters[TOTAL_GROUP_ALU16_MEM]; 254 255 #define BCMI_FT_CHIP_DEBUG_INFO(unit) \ 256 (chip_debug_info[unit]) 257 258 #define BCMI_FT_CHIP_DEBUG_ENABLE(unit) \ 259 ((chip_debug_info[unit]).chip_debug_enable) 260 261 #define BCMI_FT_CHIP_DEBUG_PARAM_INFO(unit) \ 262 (chip_debug_info[unit].param_info) 263 264 #define BCMI_FT_CHIP_DEBUG_PARAM(unit, id) \ 265 (chip_debug_info[unit].param_info[id]) 266 267 268 /* There are 4 different types of memories. */ 269 extern alu_load_index_info_t 270 alu_load_index_info[BCM_MAX_NUM_UNITS][BCMI_FT_ALU_LOAD_MEMS]; 271 272 273 #define BCMI_FT_ALU_INFO(unit, type) \ 274 (alu_load_index_info[unit][type]) 275 276 #define BCMI_FT_ALU_LOAD_MEM_INFO(unit, type) \ 277 ((alu_load_index_info[unit][type]).alu_load_info) 278 279 #define BCMI_FT_GROUP_FID_INFO(unit, type) \ 280 ((alu_load_index_info[unit][type]).group_fid_info) 281 282 #define BCMI_FT_PDD_INFO(_u, type) \ 283 (alu_load_index_info[_u][type].pdd_bus_info) 284 285 #define BCMI_FT_ALU_LOAD_MEM_COUNT(unit, type) \ 286 ((alu_load_index_info[unit][type]).total_mem_count) 287 288 #define BCMI_FT_ALU_LOAD_REFCOUNT_INCR(_u, type, idx) \ 289 ((alu_load_index_info[_u][type].idx_refcount[idx])++) 290 291 #define BCMI_FT_ALU_LOAD_REFCOUNT_DEC(_u, type, idx) \ 292 ((alu_load_index_info[_u][type].idx_refcount[idx])--) 293 294 #define BCMI_FT_ALU_LOAD_REFCOUNT(_u, type, idx) \ 295 (alu_load_index_info[_u][type].idx_refcount[idx]) 296 297 #define BCMI_FT_ALU_LOAD_REFCOUNT_INFO(_u, type, idx) \ 298 (alu_load_index_info[_u][type].idx_refcount) 299 300 #define BCMI_FT_ALU_LOAD_BITMAP(_u, type) \ 301 (alu_load_index_info[_u][type].index_bitmap) 302 303 #define BCMI_FT_ALU_LOAD_MEM_SIZE(_u, type, idx) \ 304 (((alu_load_index_info[_u][type]).alu_load_info[idx]).mem_size) 305 306 307 /* Flowtracker Software State. */ 308 typedef struct bcmi_ft_flowchecker_sw_info_s { 309 bcmi_flowtracker_flowchecker_info_t **bcmi_sw_info; 310 SHR_BITDCL *ft_flowchecker_bitmap; 311 uint32 *fc_idx_refcount; 312 struct bcmi_ft_flowchecker_sw_info_s *next; 313 } bcmi_ft_flowchecker_sw_state_t; 314 315 316 extern bcmi_ft_flowchecker_sw_state_t 317 bcmi_ft_flowchecker_state[BCM_MAX_NUM_UNITS]; 318 319 #define BCMI_FT_FLOWCHECKER_BITMAP(unit) \ 320 (bcmi_ft_flowchecker_state[unit].ft_flowchecker_bitmap) 321 322 #define BCMI_FT_FLOWCHECKER_STATE(unit) \ 323 (bcmi_ft_flowchecker_state[unit].bcmi_sw_info) 324 325 #define BCMI_FT_FLOWCHECKER_INFO(unit, index) \ 326 (bcmi_ft_flowchecker_state[unit].bcmi_sw_info[index]) 327 328 #define BCMI_FT_FLOWCHECKER_REFCOUNT(unit, index) \ 329 (bcmi_ft_flowchecker_state[unit].fc_idx_refcount[index]) 330 331 #define BCMI_FT_FLOWCHECKER_REFCOUNT_DEC(unit, index) \ 332 ((bcmi_ft_flowchecker_state[unit].fc_idx_refcount[index])--) 333 334 #define BCMI_FT_FLOWCHECKER_REFCOUNT_INC(unit, index) \ 335 ((bcmi_ft_flowchecker_state[unit].fc_idx_refcount[index])++) 336 337 /* Internal Functions. */ 338 int bcmi_ft_flowchecker_alu32_entry_install( 339 int unit, 340 bcmi_ft_group_alu_info_t info, 341 soc_mem_t mem, int index); 342 343 int bcmi_ft_flowchecker_alu_base_control_set( 344 int unit, 345 bcm_flowtracker_group_t id, 346 bcmi_ft_group_alu_info_t *info, 347 uint32 *alu_fmt); 348 349 int bcmi_ft_flowchecker_alu16_entry_install( 350 int unit, 351 bcmi_ft_group_alu_info_t info, 352 soc_mem_t mem, int index); 353 354 int 355 bcmi_ft_flowchecker_alu32_entry_uninstall( 356 int unit, 357 bcmi_ft_group_alu_info_t info, 358 soc_mem_t mem, int index); 359 360 361 int 362 bcmi_ft_flowchecker_alu16_entry_uninstall( 363 int unit, 364 bcmi_ft_group_alu_info_t info, 365 soc_mem_t mem, int index); 366 367 int 368 bcmi_ft_group_alu_load_configure( 369 int unit, bcm_flowtracker_group_t id, 370 bcmi_ft_group_alu_info_t *temp, 371 bcmi_ft_alu_load_type_t alu_load_type, 372 int index); 373 374 int 375 bcmi_ft_alu_entry_match( 376 int unit, 377 bcm_flowtracker_group_t id, 378 bcmi_ft_group_alu_info_t *temp, 379 bcmi_ft_alu_hash_info_t *alu_info, 380 int *load8_indexes, int *index); 381 382 int 383 bcmi_ft_load8_entry_match( 384 int unit, 385 bcm_flowtracker_group_t id, 386 bcmi_ft_group_alu_info_t *temp, 387 bcmi_ft_alu_hash_info_t *alu_info, 388 int *load8_indexes, int *index); 389 390 int 391 bcmi_ft_load16_entry_match( 392 int unit, 393 bcm_flowtracker_group_t id, 394 bcmi_ft_group_alu_info_t *temp, 395 bcmi_ft_alu_hash_info_t *alu_info, 396 int *load16_indexes, int *index); 397 398 /* Function pointer for the ALU/Load match routine. */ 399 typedef int(*bcm_flowtracker_alu_load_entry_match)( 400 int unit, 401 bcm_flowtracker_group_t id, 402 bcmi_ft_group_alu_info_t *temp, 403 bcmi_ft_alu_hash_info_t *alu_info, 404 int *load16_indexes, int *index); 405 406 407 /* Vector definitions for various ALU/LOAD methods. */ 408 409 typedef struct bcmi_ft_alu_load_method_s { 410 /* Lets start with ALU/LOAD matching. */ 411 int (*alu_load_match)(int unit, 412 bcm_flowtracker_group_t id, 413 bcmi_ft_group_alu_info_t *temp, 414 bcmi_ft_alu_hash_info_t *alu_info, 415 int *load16_indexes, int *index); 416 417 int (*alu_load_install)( 418 int unit, 419 bcm_flowtracker_group_t id, 420 bcmi_ft_group_alu_info_t *info, 421 int *indexes); 422 423 int (*alu_load_uninstall)( 424 int unit, 425 bcm_flowtracker_group_t id, 426 bcmi_ft_group_alu_info_t *info, 427 int *indexes); 428 429 430 } bcmi_ft_alu_load_method_t; 431 432 433 extern bcmi_ft_alu_load_method_t *alu_load_methods[BCMI_FT_ALU_LOAD_MEMS]; 434 435 /* ALU/LOAD match methods. */ 436 437 #define bcmi_ft_method_match(type) \ 438 (alu_load_methods[type]->alu_load_match) 439 440 #define BCMI_FT_METHOD_MATCH_CHECK(type) \ 441 do { \ 442 if (!bcmi_ft_method_match(type)) { \ 443 rv = BCM_E_UNAVAIL; \ 444 } \ 445 } while(0); 446 447 #define BCMI_FT_METHOD_MATCH_EXEC(type) \ 448 (*(bcmi_ft_method_match(type))) 449 450 451 /* ALU/LOAD Install methods. */ 452 453 #define bcmi_ft_method_install(type) \ 454 (alu_load_methods[type]->alu_load_install) 455 456 #define BCMI_FT_METHOD_INSTALL_CHECK(type) \ 457 do { \ 458 if (!bcmi_ft_method_install(type)) { \ 459 rv = BCM_E_UNAVAIL; \ 460 } \ 461 } while(0); 462 463 #define BCMI_FT_METHOD_INSTALL_EXEC(type) \ 464 (*(bcmi_ft_method_install(type))) 465 466 /* ALU/LOAD uninstall methods. */ 467 468 #define bcmi_ft_method_uninstall(type) \ 469 (alu_load_methods[type]->alu_load_uninstall) 470 471 #define BCMI_FT_METHOD_UNINSTALL_CHECK(type) \ 472 do { \ 473 if (!bcmi_ft_method_uninstall(type)) { \ 474 rv = BCM_E_UNAVAIL; \ 475 } \ 476 } while(0); 477 478 #define BCMI_FT_METHOD_UNINSTALL_EXEC(type) \ 479 (*(bcmi_ft_method_uninstall(type))) 480 481 482 int 483 bcmi_ft_load16_entry_write( 484 int unit, bcm_flowtracker_group_t id, 485 bcmi_ft_group_alu_info_t *temp, 486 int *load16_indexes, int index); 487 488 int 489 bcmi_ft_load8_entry_write( 490 int unit, bcm_flowtracker_group_t id, 491 bcmi_ft_group_alu_info_t *temp, 492 int *load8_indexes, int index); 493 494 int 495 bcmi_ft_load16_entry_install( 496 int unit, bcm_flowtracker_group_t id, 497 bcmi_ft_group_alu_info_t *info, 498 int *indexes); 499 500 int 501 bcmi_ft_load8_entry_install( 502 int unit, bcm_flowtracker_group_t id, 503 bcmi_ft_group_alu_info_t *info, 504 int *indexes); 505 506 int 507 bcmi_ft_alu_hw_operation_get( 508 int unit, 509 bcm_flowtracker_check_operation_t operation, 510 int *check_0_operation, 511 int *check_1_operation); 512 513 void 514 bcmi_ft_alu_load_mem_index_get( 515 int unit, 516 int index, bcmi_ft_alu_load_type_t type, 517 int *new_index, soc_mem_t *mem, int *bit); 518 519 int 520 bcmi_ft_alu_check16_mapping_get( 521 int unit, 522 bcm_flowtracker_group_t id, 523 bcm_flowtracker_check_t *check_map); 524 525 void 526 bcmi_ft_check_action_shift_bits_get( 527 int unit, 528 bcm_flowtracker_check_action_t action, 529 bcmi_ft_group_alu_info_t *info, 530 int *shift_bits); 531 532 extern int 533 bcmi_ft_alu_load_init(int unit); 534 535 extern int 536 bcmi_ft_alu_hash_init(int unit); 537 538 extern void 539 bcmi_ft_alu_hash_cleanup(int unit); 540 541 extern void 542 bcmi_ft_alu_load_cleanup(int unit); 543 544 545 /* Internal function headers. */ 546 547 548 /* Functions for Hash Insert/Remove. */ 549 int 550 bcmi_ft_alu_hash_insert( 551 int unit, 552 bcm_flowtracker_group_t id, 553 bcmi_ft_alu_load_type_t alu_load_type, 554 bcmi_ft_group_alu_info_t *group_alu_info, 555 int *load_indexes, 556 int *alu_load_index); 557 558 559 int 560 bcmi_ft_alu_hash_remove( 561 int unit, bcm_flowtracker_group_t id, 562 bcmi_ft_alu_load_type_t alu_load_type, 563 bcmi_ft_group_alu_info_t *group_alu_info, 564 int *load_indexes, 565 int *alu_load_index); 566 567 int 568 bcmi_ft_alu_hash_mem_index_get ( 569 int unit, bcm_flowtracker_group_t id, 570 bcmi_ft_alu_load_type_t alu_load_type, 571 bcmi_ft_group_alu_info_t *group_alu_info, 572 int *load_indexes, 573 int *alu_load_index); 574 575 /* Utility Functions. */ 576 int 577 bcmi_ft_alu_check_free_index( 578 int unit, 579 bcm_flowtracker_group_t id, 580 bcmi_ft_alu_load_type_t alu_load_type, 581 int index); 582 583 int 584 bcmi_ft_alu_get_free_index( 585 int unit, 586 bcm_flowtracker_group_t id, 587 bcmi_ft_alu_load_type_t alu_load_type, 588 int *index); 589 590 int 591 bcmi_ft_alu_load_values_normalize( 592 int unit, 593 bcmi_ft_group_alu_info_t *info, 594 int *length, 595 int *alu); 596 597 int 598 bcmi_ft_alu_load_type_get( 599 int unit, 600 int alu, 601 int length, 602 bcmi_ft_alu_load_type_t *type); 603 604 605 extern int 606 bcmi_ft_alu_load_compare( 607 int unit, bcm_flowtracker_group_t id, 608 bcmi_ft_group_alu_info_t *group_alu_info, 609 bcmi_ft_alu_load_type_t alu_load_type, 610 bcmi_ft_alu_hash_info_t *alu_info, 611 int *indexes); 612 613 614 int 615 bcmi_ft_alu_hw_operation_get( 616 int unit, 617 bcm_flowtracker_check_operation_t operation, 618 int *check_0_operation, 619 int *check_1_operation); 620 621 int 622 bcmi_ft_alu_hw_action_get( 623 int unit, 624 bcm_flowtracker_tracking_param_type_t param, 625 bcm_flowtracker_check_action_t action, 626 int * hw_action); 627 628 int 629 bcmi_ft_load16_entry_clear(int unit, int index); 630 631 632 int 633 bcmi_ft_load16_entry_uninstall( 634 int unit, 635 bcm_flowtracker_group_t id, 636 bcmi_ft_group_alu_info_t *info, 637 int *indexes); 638 639 int 640 bcmi_ft_load8_entry_uninstall( 641 int unit, 642 bcm_flowtracker_group_t id, 643 bcmi_ft_group_alu_info_t *info, 644 int *indexes); 645 646 int 647 bcmi_ft_alu32_entry_uninstall( 648 int unit, bcm_flowtracker_group_t id, 649 bcmi_ft_group_alu_info_t *info, 650 int *indexes); 651 652 int 653 bcmi_ft_alu16_entry_uninstall( 654 int unit, bcm_flowtracker_group_t id, 655 bcmi_ft_group_alu_info_t *info, 656 int *indexes); 657 658 int bcmi_ft_alu32_entry_install( 659 int unit, bcm_flowtracker_group_t id, 660 bcmi_ft_group_alu_info_t *info, 661 int *indexes); 662 663 int bcmi_ft_alu16_entry_install( 664 int unit, bcm_flowtracker_group_t id, 665 bcmi_ft_group_alu_info_t *info, 666 int *indexes); 667 668 669 extern int 670 bcmi_ft_check_compare( 671 int unit, 672 bcm_flowtracker_check_t check_id1, 673 bcm_flowtracker_check_t check_id2); 674 675 extern int 676 bcmi_ft_group_alu_load_index_match( 677 int unit, 678 bcm_flowtracker_group_t id, 679 bcmi_ft_alu_load_type_t alu_load_type, 680 bcmi_ft_alu_hash_info_t *alu_info); 681 682 int 683 bcmi_ft_group_alu_load_trigger_set( 684 int unit, 685 bcm_flowtracker_group_t id, 686 bcm_flowtracker_direction_t direction); 687 688 689 /* Chip Debug methods. */ 690 691 692 int bcmi_ft_chip_debug_info_set( 693 int unit, 694 int num_info, 695 bcm_flowtracker_chip_debug_info_t *info); 696 697 int bcmi_ft_chip_debug_info_get( 698 int unit, 699 int max_size, 700 bcm_flowtracker_chip_debug_info_t *info, 701 int *num_debug_info); 702 703 int 704 bcmi_ft_tracking_param_in_Debug_mode( 705 int unit, 706 bcm_flowtracker_group_t id, 707 bcmi_ft_group_alu_info_t *group_alu_info, 708 bcmi_ft_alu_load_type_t alu_load_type); 709 710 int 711 bcmi_ft_chip_debug_alu_index_get( 712 int unit, 713 bcm_flowtracker_group_t id, 714 bcmi_ft_group_alu_info_t *group_alu_info, 715 bcmi_ft_alu_load_type_t alu_load_type, 716 int *index); 717 718 void 719 bcmi_ft_chip_debug_free_alu_index ( 720 int unit, 721 bcmi_ft_group_alu_info_t *group_alu_info, 722 bcmi_ft_alu_load_type_t alu_load_type); 723 724 725 726 727 int 728 bcmi_ft_chip_debug_counter_get( 729 int unit, 730 int mem_idx, 731 bcmi_ft_alu_load_type_t alu_load_type, 732 uint32 *count); 733 734 735 int 736 bcmi_ft_chip_debug_data_sanity( 737 int unit, 738 int num_info, 739 bcm_flowtracker_chip_debug_info_t *info); 740 741 /* Get the matching data from valid pdd entry. */ 742 int 743 bcmi_ft_group_alu_load_index_match_data_get( 744 int unit, 745 bcm_flowtracker_group_t id, 746 bcmi_ft_alu_load_type_t alu_load_type, 747 int iter, 748 bcmi_ft_group_alu_info_t **temp); 749 int 750 bcmi_ft_group_alu_load_pdd_status_get( 751 int unit, 752 bcm_flowtracker_group_t id, 753 bcmi_ft_alu_load_type_t alu_load_type, 754 int iter); 755 756 int 757 bcmi_ft_flowchecker_list_add( 758 int unit, 759 bcmi_ft_flowchecker_list_t **head, 760 bcm_flowtracker_check_t flowchecker_id); 761 762 763 int 764 bcmi_ft_flowchecker_list_delete( 765 int unit, 766 bcmi_ft_flowchecker_list_t **head, 767 bcm_flowtracker_check_t flowchecker_id); 768 769 int 770 bcmi_ft_flowchecker_list_length_get( 771 int unit, 772 bcmi_ft_flowchecker_list_t **head); 773 774 int 775 bcmi_ft_flowchecker_opr_is_dual( 776 int unit, 777 bcm_flowtracker_check_operation_t operation); 778 779 780 int 781 bcmi_ft_check_list_compare( 782 int unit, 783 bcmi_ft_flowchecker_list_t **head, 784 bcm_flowtracker_check_t check_id); 785 786 787 void 788 bcmi_ft_chip_debug_use_mem_update( 789 int unit, 790 bcmi_ft_alu_load_type_t alu_load_type, 791 int mem_idx, 792 int val); 793 794 int 795 bcmi_ft_chip_debug_mem_check( 796 int unit, 797 bcmi_ft_alu_load_type_t alu_load_type, 798 int mem_idx); 799 800 801 int 802 bcmi_ft_group_clear( 803 int unit, 804 bcm_flowtracker_group_t id); 805 806 int 807 bcmi_ft_tracking_param_is_timestamp( 808 int unit, 809 bcm_flowtracker_tracking_param_type_t t_param); 810 811 extern int 812 bcmi_ft_alu_load_hash_dump( 813 int unit); 814 815 #endif /* BCM_FLOWTRACKER_SUPPORT */ 816 817 #endif /* _BCM_INT_FT_ALU_H_ */ 818