flow_db.c (19911B)
1 2 /* 3 * 4 * This license is set out in https://raw.githubusercontent.com/Broadcom-Network-Switching-Software/OpenBCM/master/Legal/LICENSE file. 5 * 6 * Copyright 2007-2019 Broadcom Inc. All rights reserved. 7 * 8 * File: flow_db.c 9 * Purpose: Flex flow Database utilities 10 */ 11 12 13 #include <sal/core/libc.h> 14 #include <shared/bsl.h> 15 #include <soc/util.h> 16 #include <soc/mem.h> 17 #include <soc/debug.h> 18 #include <soc/error.h> 19 #include <soc/esw/flow_db.h> 20 #include <soc/esw/flow_db_core.h> 21 #include <soc/esw/flow_db_enum.h> 22 #include <soc/esw/cancun.h> 23 24 /* 25 * Function: 26 * soc_flow_db_flow_handle_get 27 * Purpose: 28 * Get the flow handle 29 * Parameters: 30 * unit - (IN) Unit. 31 * flow_name - (IN) Flow name. 32 * handle - (IN/OUT) Flow hanlde. 33 * Returns: 34 * SOC_E_NONE 35 * SOC_E_XXX 36 */ 37 int 38 soc_flow_db_flow_handle_get(int unit, 39 const char *flow_name, 40 uint32 *handle) 41 { 42 return _soc_flow_db_flow_handle_get(unit, 43 flow_name, handle); 44 } 45 46 /* 47 * Function: 48 * soc_flow_db_mem_view_flow_handle_valid 49 * Purpose: 50 * Verify the flow handle if valid 51 * Parameters: 52 * unit - (IN) Unit 53 * flow_handle - (IN) Flow handle. 54 * Returns: 55 * SOC_E_NONE 56 * SOC_E_XXX 57 */ 58 int 59 soc_flow_db_mem_view_flow_handle_valid(int unit, 60 uint32 flow_handle) 61 { 62 if ((SOC_FLOW_DB_FLOW_HANDLE_VALID(unit, flow_handle)) || 63 (flow_handle == SOC_FLOW_DB_FLOW_ID_LEGACY_VXLAN) || 64 (flow_handle == SOC_FLOW_DB_FLOW_ID_LEGACY_L2GRE)) { 65 return SOC_E_NONE; 66 } 67 return SOC_E_PARAM; 68 } 69 /* 70 * Function: 71 * soc_flow_db_flow_option_id_get 72 * Purpose: 73 * Get the Flow option ID. 74 * Parameters: 75 * unit - (IN) Unit 76 * flow_handle - (IN) Flow handle. 77 * flow_option_name - (IN) Flow option name. 78 * option_id - (IN/OUT) Flow Option ID. 79 * Returns: 80 * SOC_E_NONE 81 * SOC_E_XXX 82 */ 83 int 84 soc_flow_db_flow_option_id_get(int unit, 85 uint32 flow_handle, 86 const char *flow_option_name, 87 uint32 *option_id) 88 { 89 90 if (!SOC_FLOW_DB_FLOW_HANDLE_VALID(unit, flow_handle)) { 91 return SOC_E_PARAM; 92 } 93 94 return _soc_flow_db_flow_option_id_get(unit, 95 flow_handle, 96 flow_option_name, 97 option_id); 98 } 99 100 /* 101 * Function: 102 * soc_flow_db_ffo_to_mem_view_id_get 103 * Purpose: 104 * Given a flow,function,option ID's 105 * get the memory view ID. 106 * Parameters: 107 * unit - (IN) unit 108 * flow_handle - (IN) flow handle 109 * flow_option_id - (IN) flow option id. 110 * function_id - (IN) function id. 111 * mem_view_id - (IN/OUT) list of mem view ID. 112 * Returns: 113 * SOC_E_NONE 114 * SOC_E_XXX 115 */ 116 int 117 soc_flow_db_ffo_to_mem_view_id_get(int unit, 118 uint32 flow_handle, 119 uint32 flow_option_id, 120 uint32 function_id, 121 uint32 *mem_view_id) 122 { 123 uint32 option_id = 0; 124 125 if (!SOC_FLOW_DB_FLOW_HANDLE_VALID(unit, flow_handle)) { 126 return SOC_E_PARAM; 127 } 128 if (flow_option_id == SOC_FLOW_DB_FLOW_OP_MATCH_NONE) { 129 SOC_IF_ERROR_RETURN( 130 _soc_flow_db_flow_option_id_get( 131 unit, 132 flow_handle, 133 (char *)SOC_FLOW_DB_FLOW_OP_ANY, 134 &option_id)); 135 flow_option_id = option_id; 136 137 } 138 if (!SOC_FLOW_DB_FLOW_OPTION_ID_VALID(unit, flow_option_id)) { 139 return SOC_E_PARAM; 140 } 141 142 if (!SOC_FLOW_DB_FUNCTION_ID_VALID(unit, function_id)) { 143 return SOC_E_PARAM; 144 } 145 146 return _soc_flow_db_ffo_to_mem_view_id_get(unit, 147 flow_handle, 148 function_id, 149 flow_option_id, 150 mem_view_id); 151 } 152 153 /* 154 * Function: 155 * soc_flow_db_mem_to_view_id_get 156 * Purpose: 157 * Given a memory , key_type, data_type and control_field 158 * list, get the memory view id. 159 * 160 * Parameters: 161 * unit - (IN) unit 162 * mem - (IN) mem 163 * mem_type - (IN) memory type. 164 * key_type - (IN) key type for HASH/TCAM 165 * data_type - (IN) data type for indexed 166 * num_fields - (IN) num of control fields 167 * field_list - (IN) control field list 168 * mem_view_id - (IN/OUT) mem view ID. 169 * Returns: 170 * SOC_E_NONE 171 * SOC_E_XXX 172 */ 173 174 int 175 soc_flow_db_mem_to_view_id_get(int unit, 176 uint32 mem, 177 int key_type, 178 int data_type, 179 int num_fields, 180 soc_flow_db_ctrl_field_t *field_list, 181 uint32 *mem_view_id) 182 { 183 if ((num_fields) && (field_list == NULL)) { 184 return SOC_E_PARAM; 185 } 186 return _soc_flow_db_mem_to_view_id_get (unit, 187 mem, key_type, 188 data_type, 189 num_fields, 190 field_list, 191 mem_view_id); 192 } 193 /* 194 * Function: 195 * soc_flow_db_mem_view_field_list_get 196 * Purpose: 197 * Get the list of field IDs 198 * of specific type such as CONTROL/KEY/ 199 * for a given mem_view ID, field_type parameter is 200 * a classifier. 201 * 202 * Parameters 203 * unit - (IN) unit 204 * mem_view_id - (IN) Memory view ID. 205 * field_type - (IN) field type 206 * size - (IN) Max array size 207 * field_id - (IN/OUT) Field ID list 208 * field_count - (IN/OUT) field count 209 * Returns: 210 * SOC_E_NONE 211 * SOC_E_XXX 212 */ 213 int 214 soc_flow_db_mem_view_field_list_get(int unit, 215 uint32 mem_view_id, 216 int field_type, 217 int size, 218 uint32 *field_id, 219 uint32 *field_count) 220 { 221 if ((field_id == NULL) || (size == 0)) { 222 return SOC_E_PARAM; 223 } 224 return _soc_flow_db_mem_view_field_list_get( 225 unit, mem_view_id, field_type, 226 size, field_id, field_count); 227 } 228 229 /* 230 * Function: 231 * soc_flow_db_mem_view_field_info_get 232 * Purpose: 233 * Get a field information for a given mem_view ID and field ID. 234 * Parameters: 235 * unit - (IN) unit. 236 * view_id - (IN) Memory mem_view ID. 237 * field_id - (IN) Field ID. 238 * field_info - (OUT) Field information 239 * Returns: 240 * SOC_E_NONE 241 * SOC_E_XXX 242 */ 243 int 244 soc_flow_db_mem_view_field_info_get(int unit, 245 uint32 mem_view_id, 246 uint32 field_id, 247 soc_flow_db_mem_view_field_info_t *field_info) 248 { 249 if (!SOC_FLOW_DB_VIEW_IDX_VALID(unit, mem_view_id)) { 250 return SOC_E_PARAM; 251 } 252 253 return _soc_flow_db_mem_view_field_info_get( 254 unit, mem_view_id, field_id, 255 field_info); 256 } 257 258 /* 259 * Function: 260 * soc_flow_db_mem_view_split_field_info_get 261 * Purpose: 262 * Get a field information for a given mem_view ID and field ID. 263 * Parameters: 264 * unit - (IN) unit. 265 * view_id - (IN) Memory mem_view ID. 266 * field_id - (IN) Field ID. 267 * field_info - (OUT) Field information 268 * Returns: 269 * SOC_E_NONE 270 * SOC_E_XXX 271 */ 272 int 273 soc_flow_db_mem_view_split_field_info_get(int unit, 274 uint32 mem_view_id, 275 uint32 field_id, 276 soc_flow_db_mem_view_split_field_info_t *sf_info) 277 { 278 if (!SOC_FLOW_DB_VIEW_IDX_VALID(unit, mem_view_id)) { 279 return SOC_E_PARAM; 280 } 281 282 return _soc_flow_db_mem_view_split_field_info_get( 283 unit, mem_view_id, field_id, 284 sf_info); 285 } 286 /* 287 * Function: 288 * soc_flow_db_mem_view_info_get 289 * Purpose: 290 * Get a mem view information for a given memory view ID 291 * Parameters: 292 * mem_view_id - (IN) Physical table view ID. 293 * mem_view_info - (OUT) Physical table view information. 294 * Returns: 295 * SOC_E_NONE 296 * SOC_E_XXX 297 */ 298 int 299 soc_flow_db_mem_view_info_get(int unit, 300 int mem_view_id, 301 soc_flow_db_mem_view_info_t *mem_view_info) 302 { 303 304 if (!SOC_FLOW_DB_VIEW_IDX_VALID(unit, mem_view_id)) { 305 return SOC_E_PARAM; 306 } 307 308 return _soc_flow_db_mem_view_info_get(unit, 309 mem_view_id, 310 mem_view_info); 311 } 312 313 /* 314 * Function: 315 * soc_flow_db_mem_view_logical_field_id_get 316 * Purpose: 317 * Given flow handle and logical field name 318 * get the field ID 319 * Parameters: 320 * unit - (IN) unit. 321 * flow_handle - (IN) flow_handle. 322 * logical_field_name - (IN) logical field Name. 323 * field ID - (OUT) field ID. 324 * Returns: 325 * SOC_E_NONE 326 * SOC_E_XXX 327 */ 328 int 329 soc_flow_db_mem_view_logical_field_id_get(int unit, 330 uint32 flow_handle, 331 const char *logical_field_name, 332 uint32 *field_id) 333 { 334 if (!SOC_FLOW_DB_FLOW_HANDLE_VALID(unit, flow_handle)) { 335 return SOC_E_PARAM; 336 } 337 return _soc_flow_db_mem_view_logical_field_id_get(unit, flow_handle, 338 logical_field_name, 339 field_id); 340 } 341 342 /* 343 * Function: 344 * soc_flow_db_mem_view_field_is_valid 345 * Purpose: 346 * Check if field ID is valid for the view. 347 * Parameters: 348 * unit - (IN) unit. 349 * mem_view_id - (IN) View ID. 350 * field ID - (IN) field ID. 351 * Returns: 352 * TRUE/FALSE 353 */ 354 int 355 soc_flow_db_mem_view_field_is_valid(int unit, 356 uint32 mem_view_id, 357 uint32 field_id) 358 { 359 int rv; 360 361 rv = _soc_flow_db_mem_view_field_is_valid(unit, 362 mem_view_id, field_id); 363 if (rv) { 364 return TRUE; 365 } else { 366 return FALSE; 367 } 368 } 369 370 /* 371 * Function: 372 * soc_flow_db_mem_view_field_is_virtual 373 * Purpose: 374 * Check if field ID is a virtual field for the view. 375 * Parameters: 376 * unit - (IN) unit. 377 * mem_view_id - (IN) View ID. 378 * field ID - (IN) field ID. 379 * Returns: 380 * TRUE/FALSE 381 */ 382 int 383 soc_flow_db_mem_view_field_is_virtual(int unit, 384 uint32 mem_view_id, 385 uint32 field_id) 386 { 387 int rv; 388 389 rv = _soc_flow_db_mem_view_field_is_valid(unit, 390 mem_view_id, field_id); 391 if (rv == SOC_FLOW_DB_FIELD_VIRTUAL_VALID) { 392 return TRUE; 393 } else { 394 return FALSE; 395 } 396 } 397 398 /* 399 * Function: 400 * soc_flow_db_mem_view_is_valid 401 * Purpose: 402 * Check if view index is valid. 403 * Parameters: 404 * unit - (IN) unit. 405 * mem_view_id - (IN) View ID. 406 * Returns: 407 * TRUE/FALSE 408 */ 409 int 410 soc_flow_db_mem_view_is_valid(int unit, 411 uint32 mem_view_id) 412 { 413 return ((SOC_FLOW_DB_VIEW_IDX_VALID(unit, mem_view_id)) ? 414 TRUE : FALSE); 415 } 416 417 418 /* 419 * Function: 420 * soc_flow_db_mem_view_entry_init 421 * Purpose: 422 * Initialize the entry buffer. 423 * Parameters: 424 * unit - (IN) Unit 425 * mem_view_id - (IN) Memory view ID. 426 * entry_buf - (IN/OUT) View entry buffer 427 * Returns: 428 * SOC_E_NONE 429 * SOC_E_XXX 430 */ 431 int 432 soc_flow_db_mem_view_entry_init(int unit, 433 uint32 mem_view_id, 434 uint32 *entry_buf) 435 { 436 uint32 size = SOC_FLOW_DB_MAX_VIEW_FIELDS; 437 uint32 fields[SOC_FLOW_DB_MAX_VIEW_FIELDS]; 438 uint32 field_count = 0; 439 int i = 0; 440 soc_flow_db_mem_view_field_info_t field_info; 441 442 if (entry_buf == NULL) { 443 return SOC_E_PARAM; 444 } 445 446 if (!SOC_FLOW_DB_VIEW_IDX_VALID(unit, mem_view_id)) { 447 return SOC_E_PARAM; 448 } 449 450 /*Initialize the control fields with value */ 451 SOC_IF_ERROR_RETURN(soc_flow_db_mem_view_field_list_get( 452 unit, 453 mem_view_id, 454 SOC_FLOW_DB_FIELD_TYPE_CONTROL, 455 size, 456 fields, 457 &field_count)); 458 for (i = 0; i < field_count; i++) { 459 SOC_IF_ERROR_RETURN(soc_flow_db_mem_view_field_info_get( 460 unit, 461 mem_view_id, 462 fields[i], 463 &field_info)); 464 soc_mem_field32_set(unit, 465 mem_view_id, 466 entry_buf, 467 fields[i], 468 field_info.value); 469 470 } 471 /*Initialize the valid fields with value */ 472 SOC_IF_ERROR_RETURN(soc_flow_db_mem_view_field_list_get( 473 unit, 474 mem_view_id, 475 SOC_FLOW_DB_FIELD_TYPE_VALID, 476 size, 477 fields, 478 &field_count)); 479 for (i = 0; i < field_count; i++) { 480 SOC_IF_ERROR_RETURN(soc_flow_db_mem_view_field_info_get( 481 unit, 482 mem_view_id, 483 fields[i], 484 &field_info)); 485 soc_mem_field32_set(unit, 486 mem_view_id, 487 entry_buf, 488 fields[i], 489 field_info.value); 490 491 } 492 return SOC_E_NONE; 493 } 494 495 /* 496 * Function: 497 * soc_flow_db_mem_view_entry_is_valid 498 * Purpose: 499 * Check if flex view entry is valid 500 * Parameters: 501 * unit - (IN) Unit 502 * mem_view_id - (IN) Memory view ID. 503 * entry_buf - (IN/OUT) View entry buffer 504 * Returns: 505 * TRUE 506 * FALSE 507 */ 508 int 509 soc_flow_db_mem_view_entry_is_valid(int unit, 510 uint32 mem_view_id, 511 uint32 *entry_buf) 512 { 513 uint32 size = SOC_FLOW_DB_MAX_VIEW_FIELDS; 514 uint32 fields[SOC_FLOW_DB_MAX_VIEW_FIELDS]; 515 uint32 field_count = 0; 516 int i = 0; 517 soc_flow_db_mem_view_field_info_t field_info; 518 uint32 value = 0; 519 520 if (entry_buf == NULL) { 521 return SOC_E_PARAM; 522 } 523 524 if (!SOC_FLOW_DB_VIEW_IDX_VALID(unit, mem_view_id)) { 525 return SOC_E_PARAM; 526 } 527 528 /* Check the valid field values */ 529 SOC_IF_ERROR_RETURN(soc_flow_db_mem_view_field_list_get( 530 unit, 531 mem_view_id, 532 SOC_FLOW_DB_FIELD_TYPE_VALID, 533 size, 534 fields, 535 &field_count)); 536 for (i = 0; i < field_count; i++) { 537 SOC_IF_ERROR_RETURN(soc_flow_db_mem_view_field_info_get( 538 unit, 539 mem_view_id, 540 fields[i], 541 &field_info)); 542 value = soc_mem_field32_get(unit, 543 mem_view_id, 544 entry_buf, 545 fields[i]); 546 if (value != field_info.value) { 547 return FALSE; 548 } 549 550 } 551 return TRUE; 552 } 553 554 /* 555 * Function: 556 * soc_flow_db_mem_view_to_ffo_get 557 * Purpose: 558 * Given a memory view ID get the ffo tuple. 559 * Parameters: 560 * unit - (IN) unit 561 * mem_view_id - (IN) list of mem view ID. 562 * size - (IN) Max array size 563 * ffo - (IN/OUT) ffo tuple 564 * num_ffo_entries - (IN/OUT) num ffo tuples 565 * Returns: 566 * SOC_E_NONE 567 * SOC_E_XXX 568 */ 569 int 570 soc_flow_db_mem_view_to_ffo_get(int unit, 571 uint32 mem_view_id, 572 uint32 size, 573 soc_flow_db_ffo_t *ffo, 574 uint32 *num_ffo_entries) 575 { 576 if ((size == 0) || 577 (ffo == NULL) || 578 (num_ffo_entries == NULL)) { 579 return SOC_E_PARAM; 580 } 581 582 if (!SOC_FLOW_DB_VIEW_IDX_VALID(unit, mem_view_id)) { 583 return SOC_E_PARAM; 584 } 585 586 SOC_IF_ERROR_RETURN( 587 _soc_flow_db_mem_view_to_ffo_get(unit, mem_view_id, 588 size, ffo, num_ffo_entries)); 589 590 return SOC_E_NONE; 591 592 } 593 594 /* 595 * Function: 596 * soc_flow_db_mem_view_field_name_get 597 * Purpose: 598 * Get the fleld name for view ID and field ID. 599 * Parameters: 600 * unit - (IN) Unit. 601 * mem_view_id - (IN) View ID. 602 * field ID - (IN) field ID. 603 * field_name - (IN/OUT) Field name. 604 * Returns: 605 * SOC_E_NONE 606 * SOC_E_XXX 607 */ 608 int 609 soc_flow_db_mem_view_field_name_get(int unit, 610 uint32 mem_view_id, 611 uint32 field_id, 612 char **field_name) 613 { 614 615 if (!SOC_FLOW_DB_VIEW_IDX_VALID(unit, mem_view_id)) { 616 return SOC_E_PARAM; 617 } 618 619 return _soc_flow_db_mem_view_field_name_get( 620 unit, mem_view_id, field_id, 621 field_name); 622 623 } 624 625 /* 626 * Function: 627 * soc_flow_db_mem_view_mem_name_get 628 * Purpose: 629 * Get the memory name for view ID. 630 * Parameters: 631 * unit - (IN) Unit. 632 * mem_view_id - (IN) View ID. 633 * mem_name - (IN/OUT) Physical memory name. 634 * Returns: 635 * SOC_E_NONE 636 * SOC_E_XXX 637 */ 638 int 639 soc_flow_db_mem_view_mem_name_get(int unit, 640 uint32 mem_view_id, 641 char **mem_name) 642 { 643 644 if (!SOC_FLOW_DB_VIEW_IDX_VALID(unit, mem_view_id)) { 645 return SOC_E_PARAM; 646 } 647 648 return _soc_flow_db_mem_view_mem_name_get( 649 unit, mem_view_id, mem_name); 650 } 651 652 653 /* 654 * Function: 655 * soc_flow_db_mem_view_option_name_get 656 * Purpose: 657 * Get option name given flow handle and option ID. 658 * Parameters: 659 * unit - (IN) Unit. 660 * flow_handle - (IN) Flow handle. 661 * flow_option_id - (IN) Flow option ID. 662 * option_name - (IN/OUT) Flow option name. 663 * Returns: 664 * SOC_E_NONE 665 * SOC_E_XXX 666 */ 667 int 668 soc_flow_db_mem_view_option_name_get(int unit, 669 uint32 flow_handle, 670 uint32 flow_option_id, 671 char **option_name) 672 { 673 674 if (!SOC_FLOW_DB_FLOW_HANDLE_VALID(unit, flow_handle)) { 675 return SOC_E_PARAM; 676 } 677 678 if (!SOC_FLOW_DB_FLOW_OPTION_ID_VALID(unit, flow_option_id)) { 679 return SOC_E_PARAM; 680 } 681 682 return _soc_flow_db_mem_view_option_name_get(unit, 683 flow_handle, 684 flow_option_id, 685 option_name); 686 687 } 688