field.c (280584B)
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 8 #include <bcm/types.h> 9 #include <sal/core/alloc.h> 10 11 #include <bcmx/field.h> 12 #include <bcmx/lport.h> 13 #include <bcmx/bcmx.h> 14 #include <bcmx/lplist.h> 15 16 #include "bcmx_int.h" 17 18 #define BCMX_FIELD_INIT_CHECK BCMX_READY_CHECK 19 20 #define BCMX_FIELD_ERROR_CHECK(_unit, _check, _rv) \ 21 BCMX_ERROR_CHECK(_unit, _check, _rv) 22 23 #define BCMX_FIELD_SET_ERROR_CHECK(_unit, _check, _rv) \ 24 BCMX_SET_ERROR_CHECK(_unit, _check, _rv) 25 26 #define BCMX_FIELD_DELETE_ERROR_CHECK(_unit, _check, _rv) \ 27 BCMX_DELETE_ERROR_CHECK(_unit, _check, _rv) 28 29 #define BCMX_FIELD_GET_IS_VALID(_unit, _rv) \ 30 BCMX_ERROR_IS_VALID(_unit, _rv) 31 32 static uint32 _bcmx_group_id; 33 static uint32 _bcmx_entry_id; 34 static uint32 _bcmx_range_id; 35 static uint32 _bcmx_stat_id; 36 37 /* 38 * BCMX uses a range of numbers starting at a high value for, 39 * Group Id, Entry Id, Range Id 40 */ 41 #define GROUP_ID_ALLOC (('X'<<24) + (++_bcmx_group_id)) 42 #define ENTRY_ID_ALLOC (('Y'<<24) + (++_bcmx_entry_id)) 43 #define RANGE_ID_ALLOC (('Z'<<24) + (++_bcmx_range_id)) 44 #define STAT_ID_ALLOC (( 1 <<16) + (++_bcmx_stat_id)) 45 46 47 /* 48 * Function: 49 * bcmx_field_init 50 * Purpose: 51 * Initialize field software subsystem 52 * Parameters: 53 * None 54 * Returns: 55 * BCM_E_EXISTS Field Processor previously initialized 56 * BCM_E_MEMORY Allocation failure 57 * BCM_E_XXX Error code 58 * BCM_E_NONE 59 */ 60 61 int 62 bcmx_field_init(void) 63 { 64 int rv = BCM_E_UNAVAIL, tmp_rv; 65 int i, bcm_unit; 66 67 BCMX_FIELD_INIT_CHECK; 68 69 _bcmx_group_id = 0; 70 _bcmx_entry_id = 0; 71 _bcmx_range_id = 0; 72 _bcmx_stat_id = 0; 73 74 BCMX_UNIT_ITER(bcm_unit, i) { 75 tmp_rv = bcm_field_init(bcm_unit); 76 BCM_IF_ERROR_RETURN(BCMX_FIELD_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 77 } 78 79 return rv; 80 } 81 82 83 /* 84 * Function: 85 * bcmx_field_control_set 86 * Purpose: 87 * Set control status. 88 * Parameters: 89 * control - Control element to set 90 * status - Status for field module 91 * Returns: 92 * BCM_E_INIT - BCM unit not initialized 93 * BCM_E_NONE - Success 94 */ 95 96 int 97 bcmx_field_control_set(bcm_field_control_t control, 98 uint32 state) 99 { 100 int rv = BCM_E_UNAVAIL, tmp_rv; 101 int i, bcm_unit; 102 103 BCMX_FIELD_INIT_CHECK; 104 105 BCMX_UNIT_ITER(bcm_unit, i) { 106 tmp_rv = bcm_field_control_set(bcm_unit, control, state); 107 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 108 } 109 110 return rv; 111 } 112 113 /* 114 * Function: 115 * bcmx_field_control_get 116 * Purpose: 117 * Get control status info. 118 * Parameters: 119 * control - Control element to get 120 * status - (OUT) Status of field element 121 * Returns: 122 * BCM_E_INIT - BCM unit not initialized 123 * BCM_E_PARAM - *state pointing to NULL 124 * BCM_E_NONE - Success 125 * Notes: 126 * Get value from first successful call 127 */ 128 129 int 130 bcmx_field_control_get(bcm_field_control_t control, 131 uint32 *state) 132 { 133 int rv; 134 int i, bcm_unit; 135 136 BCMX_FIELD_INIT_CHECK; 137 138 BCMX_PARAM_NULL_CHECK(state); 139 140 BCMX_UNIT_ITER(bcm_unit, i) { 141 rv = bcm_field_control_get(bcm_unit, control, state); 142 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 143 return rv; 144 } 145 } 146 147 return BCM_E_UNAVAIL; 148 } 149 150 /* 151 * Function: 152 * bcmx_field_group_traverse 153 * Purpose: 154 * Traverse all the fp groups in the system, calling a specified 155 * callback for each one 156 * Parameters: 157 * callback - (IN) A pointer to the callback function to call for each fp group 158 * user_data - (IN) Pointer to user data to supply in the callback 159 * Returns: 160 * BCM_E_xxx 161 * Notes: 162 */ 163 int 164 bcmx_field_group_traverse(bcm_field_group_traverse_cb callback, void *user_data) 165 { 166 int unit_cntr; /* Number of devices counter. */ 167 int bcm_unit; /* bcm device iterator. */ 168 int rv; /* Overall operation result. */ 169 170 BCMX_FIELD_INIT_CHECK; 171 172 BCMX_LOCAL_UNIT_ITER(bcm_unit, unit_cntr) { 173 rv = bcm_field_group_traverse (bcm_unit, callback, user_data); 174 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 175 return rv; 176 } 177 } 178 179 return BCM_E_UNAVAIL; 180 } 181 182 /* 183 * Function: 184 * bcmx_field_group_create 185 * Purpose: 186 * Create a field group based on the field group selector flags. 187 * Parameters: 188 * qset - Field qualifier set 189 * pri - Priority within allowable range 190 * or BCM_FIELD_GROUP_PRIO_ANY to automatically assign a 191 * priority; each priority value may be used only once 192 * group - (OUT) Field group ID 193 * Returns: 194 * BCM_E_RESOURCE No unused group/slices left OR qset doesn't work on 195 * hardware 196 * BCM_E_PARAM Priority out of range (0-15 for FB & ER) 197 * BCM_E_MEMORY Group memory allocation failure 198 * BCM_E_XXX Error code 199 * BCM_E_NONE 200 */ 201 202 int 203 bcmx_field_group_create(bcm_field_qset_t qset, 204 int pri, 205 bcm_field_group_t *group) 206 { 207 int rv = BCM_E_UNAVAIL, tmp_rv; 208 int i, bcm_unit; 209 bcm_field_group_t gid; 210 211 BCMX_FIELD_INIT_CHECK; 212 213 BCMX_PARAM_NULL_CHECK(group); 214 215 gid = GROUP_ID_ALLOC; 216 *group = gid; 217 218 BCMX_UNIT_ITER(bcm_unit, i) { 219 tmp_rv = bcm_field_group_create_id(bcm_unit, qset, pri, gid); 220 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 221 } 222 223 return rv; 224 } 225 226 /* 227 * Function: 228 * bcmx_field_group_create_id 229 * Purpose: 230 * Create a field group based on the field group selector flags 231 * with a requested ID. 232 * Parameters: 233 * qset - Field qualifier set 234 * pri - Priority within allowable range 235 * or BCM_FIELD_GROUP_PRIO_ANY to automatically assign a 236 * priority; each priority value may be used only once 237 * group - Requested field group ID 238 * Returns: 239 * BCM_E_RESOURCE No unused group/slices left 240 * BCM_E_PARAM Priority out of range (0-15 for FB & ER) 241 * BCM_E_MEMORY Group memory allocation failure 242 * BCM_E_XXX Error code 243 * BCM_E_NONE 244 */ 245 246 int 247 bcmx_field_group_create_id(bcm_field_qset_t qset, 248 int pri, 249 bcm_field_group_t group) 250 { 251 int rv = BCM_E_UNAVAIL, tmp_rv; 252 int i, bcm_unit; 253 254 BCMX_FIELD_INIT_CHECK; 255 256 BCMX_UNIT_ITER(bcm_unit, i) { 257 tmp_rv = bcm_field_group_create_id(bcm_unit, qset, pri, group); 258 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 259 } 260 261 return rv; 262 } 263 264 /* 265 * Function: 266 * bcmx_field_group_wlan_create_mode 267 * Purpose: 268 * Create a wlan field group based on the field group selector flags 269 * and the given group mode. 270 * Parameters: 271 * qset - Field qualifier set 272 * pri - Priority within allowable range 273 * or BCM_FIELD_GROUP_PRIO_ANY to automatically assign a 274 * priority; each priority value may be used only once 275 * mode - Group mode (single, double, triple or Auto-wide) 276 * group - (OUT) Field group ID 277 * Returns: 278 * BCM_E_RESOURCE No unused group/slices left OR qset doesn't work on 279 * hardware 280 * BCM_E_PARAM Priority out of range (0-15 for FB & ER) 281 * BCM_E_MEMORY Group memory allocation failure 282 * BCM_E_XXX Error code 283 * BCM_E_NONE 284 */ 285 286 int 287 bcmx_field_group_wlan_create_mode(bcm_field_qset_t qset, 288 int pri, 289 bcm_field_group_mode_t mode, 290 bcm_field_group_t *group) 291 { 292 int rv = BCM_E_UNAVAIL, tmp_rv; 293 int i, bcm_unit; 294 bcm_field_group_t gid; 295 296 BCMX_FIELD_INIT_CHECK; 297 298 BCMX_PARAM_NULL_CHECK(group); 299 300 gid = GROUP_ID_ALLOC; 301 *group = gid; 302 303 BCMX_UNIT_ITER(bcm_unit, i) { 304 tmp_rv = bcm_field_group_wlan_create_mode_id(bcm_unit, qset, 305 pri, mode, gid); 306 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 307 } 308 309 return rv; 310 } 311 312 /* 313 * Function: 314 * bcmx_field_group_wlan_create_mode_id 315 * Purpose: 316 * Create a wlan field group based on the field group selector flags, 317 * the given group mode, and the requested group ID. 318 * Parameters: 319 * qset - Field qualifier set 320 * pri - Priority within allowable range 321 * or BCM_FIELD_GROUP_PRIO_ANY to automatically assign a 322 * priority; each priority value may be used only once 323 * mode - Group mode (single, double, triple or Auto-wide) 324 * group - Requested field group ID 325 * Returns: 326 * BCM_E_RESOURCE No unused group/slices left 327 * BCM_E_PARAM Priority out of range (0-15 for FB & ER) 328 * BCM_E_MEMORY Group memory allocation failure 329 * BCM_E_XXX Error code 330 * BCM_E_NONE 331 */ 332 int 333 bcmx_field_group_wlan_create_mode_id(bcm_field_qset_t qset, 334 int pri, 335 bcm_field_group_mode_t mode, 336 bcm_field_group_t group) 337 { 338 int rv = BCM_E_UNAVAIL, tmp_rv; 339 int i, bcm_unit; 340 341 BCMX_FIELD_INIT_CHECK; 342 343 BCMX_UNIT_ITER(bcm_unit, i) { 344 tmp_rv = bcm_field_group_wlan_create_mode_id(bcm_unit, qset, 345 pri, mode, group); 346 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 347 } 348 349 return rv; 350 } 351 352 /* 353 * Function: 354 * bcmx_field_group_create_mode 355 * Purpose: 356 * Create a field group based on the field group selector flags 357 * and the given group mode. 358 * Parameters: 359 * qset - Field qualifier set 360 * pri - Priority within allowable range 361 * or BCM_FIELD_GROUP_PRIO_ANY to automatically assign a 362 * priority; each priority value may be used only once 363 * mode - Group mode (single, double, triple or Auto-wide) 364 * group - (OUT) Field group ID 365 * Returns: 366 * BCM_E_RESOURCE No unused group/slices left OR qset doesn't work on 367 * hardware 368 * BCM_E_PARAM Priority out of range (0-15 for FB & ER) 369 * BCM_E_MEMORY Group memory allocation failure 370 * BCM_E_XXX Error code 371 * BCM_E_NONE 372 */ 373 374 int 375 bcmx_field_group_create_mode(bcm_field_qset_t qset, 376 int pri, 377 bcm_field_group_mode_t mode, 378 bcm_field_group_t *group) 379 { 380 int rv = BCM_E_UNAVAIL, tmp_rv; 381 int i, bcm_unit; 382 bcm_field_group_t gid; 383 384 BCMX_FIELD_INIT_CHECK; 385 386 BCMX_PARAM_NULL_CHECK(group); 387 388 gid = GROUP_ID_ALLOC; 389 *group = gid; 390 391 BCMX_UNIT_ITER(bcm_unit, i) { 392 tmp_rv = bcm_field_group_create_mode_id(bcm_unit, qset, 393 pri, mode, gid); 394 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 395 } 396 397 return rv; 398 } 399 400 /* 401 * Function: 402 * bcmx_field_group_create_mode_id 403 * Purpose: 404 * Create a field group based on the field group selector flags, 405 * the given group mode, and the requested group ID. 406 * Parameters: 407 * qset - Field qualifier set 408 * pri - Priority within allowable range 409 * or BCM_FIELD_GROUP_PRIO_ANY to automatically assign a 410 * priority; each priority value may be used only once 411 * mode - Group mode (single, double, triple or Auto-wide) 412 * group - Requested field group ID 413 * Returns: 414 * BCM_E_RESOURCE No unused group/slices left 415 * BCM_E_PARAM Priority out of range (0-15 for FB & ER) 416 * BCM_E_MEMORY Group memory allocation failure 417 * BCM_E_XXX Error code 418 * BCM_E_NONE 419 */ 420 int 421 bcmx_field_group_create_mode_id(bcm_field_qset_t qset, 422 int pri, 423 bcm_field_group_mode_t mode, 424 bcm_field_group_t group) 425 { 426 int rv = BCM_E_UNAVAIL, tmp_rv; 427 int i, bcm_unit; 428 429 BCMX_FIELD_INIT_CHECK; 430 431 BCMX_UNIT_ITER(bcm_unit, i) { 432 tmp_rv = bcm_field_group_create_mode_id(bcm_unit, qset, 433 pri, mode, group); 434 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 435 } 436 437 return rv; 438 } 439 440 /* 441 * Function: 442 * bcmx_field_group_port_create_mode 443 * Purpose: 444 * Create a field group based on the field group selector flags, 445 * given group mode and the given logical port. 446 * Parameters: 447 * port - Logical port number where group is defined 448 * qset - Field qualifier set 449 * pri - Priority within allowable range 450 * or BCM_FIELD_GROUP_PRIO_ANY to automatically assign a 451 * priority; each priority value may be used only once 452 * mode - Group mode (single, double, triple or Auto-wide) 453 * group - (OUT) Field group ID 454 * Returns: 455 * BCM_E_RESOURCE No unused group/slices left OR qset doesn't work on 456 * hardware 457 * BCM_E_PARAM Priority out of range (0-15 for FB & ER) 458 * BCM_E_MEMORY Group memory allocation failure 459 * BCM_E_XXX Error code 460 * BCM_E_NONE 461 */ 462 463 int 464 bcmx_field_group_port_create_mode(bcmx_lport_t port, 465 bcm_field_qset_t qset, 466 int pri, 467 bcm_field_group_mode_t mode, 468 bcm_field_group_t *group) 469 { 470 BCMX_FIELD_INIT_CHECK; 471 472 BCMX_PARAM_NULL_CHECK(group); 473 474 *group = GROUP_ID_ALLOC; 475 476 return bcmx_field_group_port_create_mode_id(port, qset, pri, mode, *group); 477 } 478 479 /* 480 * Function: 481 * bcmx_field_group_port_create_mode_id 482 * Purpose: 483 * Create a field group based on the field group selector flags, 484 * given group mode, logical port, and requested group ID. 485 * Parameters: 486 * port - Logical port number where group is defined 487 * qset - Field qualifier set 488 * pri - Priority within allowable range 489 * or BCM_FIELD_GROUP_PRIO_ANY to automatically assign a 490 * priority; each priority value may be used only once 491 * mode - Group mode (single, double, triple or Auto-wide) 492 * group - Requested field group ID 493 * Returns: 494 * BCM_E_RESOURCE No unused group/slices left 495 * BCM_E_PARAM Priority out of range (0-15 for FB & ER) 496 * BCM_E_MEMORY Group memory allocation failure 497 * BCM_E_XXX Error code 498 * BCM_E_NONE 499 */ 500 501 int 502 bcmx_field_group_port_create_mode_id(bcmx_lport_t port, 503 bcm_field_qset_t qset, 504 int pri, 505 bcm_field_group_mode_t mode, 506 bcm_field_group_t group) 507 { 508 int rv = BCM_E_UNAVAIL, tmp_rv; 509 int bcm_unit; 510 bcm_port_t bcm_port; 511 bcm_pbmp_t pbmp; 512 int i, unit; 513 514 BCMX_FIELD_INIT_CHECK; 515 516 BCM_IF_ERROR_RETURN 517 (_bcmx_dest_to_unit_port(port, &bcm_unit, &bcm_port, 518 BCMX_DEST_CONVERT_DEFAULT)); 519 520 /* Create group in unit where given port resides */ 521 tmp_rv = bcm_field_group_port_create_mode_id(bcm_unit, bcm_port, qset, 522 pri, mode, group); 523 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 524 525 /* Create group with null ports on rest of units */ 526 BCM_PBMP_CLEAR(pbmp); 527 BCMX_UNIT_ITER(unit, i) { 528 if (unit == bcm_unit) { 529 continue; 530 } 531 tmp_rv = bcm_field_group_ports_create_mode_id(unit, pbmp, qset, 532 pri, mode, group); 533 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(unit, tmp_rv, &rv)); 534 } 535 536 return rv; 537 } 538 539 /* 540 * Function: 541 * bcmx_field_group_ports_create_mode 542 * Purpose: 543 * Create a field group based on the field group selector flags, 544 * given group mode and the given logical port list. 545 * Parameters: 546 * lplist - Logical port list for which the group is defined 547 * qset - Field qualifier set 548 * pri - Priority within allowable range 549 * or BCM_FIELD_GROUP_PRIO_ANY to automatically assign a 550 * priority; each priority value may be used only once 551 * mode - Group mode (single, double, triple or Auto-wide) 552 * group - (OUT) Field group ID 553 * Returns: 554 * BCM_E_RESOURCE No unused group/slices left OR qset doesn't work on 555 * hardware 556 * BCM_E_PARAM Priority out of range (0-15 for FB & ER) 557 * BCM_E_MEMORY Group memory allocation failure 558 * BCM_E_XXX Error code 559 * BCM_E_NONE 560 */ 561 562 int 563 bcmx_field_group_ports_create_mode(bcmx_lplist_t lplist, 564 bcm_field_qset_t qset, 565 int pri, 566 bcm_field_group_mode_t mode, 567 bcm_field_group_t *group) 568 { 569 int rv = BCM_E_UNAVAIL, tmp_rv; 570 int i, bcm_unit; 571 bcm_pbmp_t pbmp; 572 bcm_field_group_t gid; 573 574 BCMX_FIELD_INIT_CHECK; 575 576 if (bcmx_lplist_is_null(&lplist)) { 577 return BCM_E_PARAM; 578 } 579 580 BCMX_PARAM_NULL_CHECK(group); 581 582 gid = GROUP_ID_ALLOC; 583 *group = gid; 584 585 BCMX_UNIT_ITER(bcm_unit, i) { 586 BCMX_LPLIST_TO_PBMP(lplist, bcm_unit, pbmp); 587 tmp_rv = bcm_field_group_ports_create_mode_id(bcm_unit, pbmp, qset, 588 pri, mode, gid); 589 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 590 } 591 592 return rv; 593 } 594 595 /* 596 * Function: 597 * bcmx_field_group_ports_create_mode_id 598 * Purpose: 599 * Create a field group based on the field group selector flags, 600 * given group mode, logical port list, and requested group ID. 601 * Parameters: 602 * lplist - Logical port list for which the group is defined 603 * qset - Field qualifier set 604 * pri - Priority within allowable range 605 * or BCM_FIELD_GROUP_PRIO_ANY to automatically assign a 606 * priority; each priority value may be used only once 607 * mode - Group mode (single, double, triple or Auto-wide) 608 * group - Requested field group ID 609 * Returns: 610 * BCM_E_RESOURCE No unused group/slices left OR qset doesn't work on 611 * hardware 612 * BCM_E_PARAM Priority out of range (0-15 for FB & ER) 613 * BCM_E_MEMORY Group memory allocation failure 614 * BCM_E_XXX Error code 615 * BCM_E_NONE 616 */ 617 618 int 619 bcmx_field_group_ports_create_mode_id(bcmx_lplist_t lplist, 620 bcm_field_qset_t qset, 621 int pri, 622 bcm_field_group_mode_t mode, 623 bcm_field_group_t group) 624 { 625 int rv = BCM_E_UNAVAIL, tmp_rv; 626 int i, bcm_unit; 627 bcm_pbmp_t pbmp; 628 629 BCMX_FIELD_INIT_CHECK; 630 631 if (bcmx_lplist_is_null(&lplist)) { 632 return BCM_E_PARAM; 633 } 634 635 BCMX_UNIT_ITER(bcm_unit, i) { 636 BCMX_LPLIST_TO_PBMP(lplist, bcm_unit, pbmp); 637 tmp_rv = bcm_field_group_ports_create_mode_id(bcm_unit, pbmp, qset, 638 pri, mode, group); 639 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 640 } 641 642 return rv; 643 } 644 645 /* 646 * Function: 647 * bcmx_field_group_mode_get 648 * Purpose: 649 * Get the mode for the specified field group 650 * Parameters: 651 * group - Field group ID 652 * mode - (OUT) Field group mode 653 * Returns: 654 * BCM_E_NOT_FOUND Field Group ID not found 655 * BCM_E_PARAM mode is NULL 656 * BCM_E_XXX Error code 657 * BCM_E_NONE 658 * Notes: 659 * Get value from first successful call 660 */ 661 662 int 663 bcmx_field_group_mode_get(bcm_field_group_t group, 664 bcm_field_group_mode_t *mode) 665 { 666 int rv; 667 int i, bcm_unit; 668 669 BCMX_FIELD_INIT_CHECK; 670 671 BCMX_PARAM_NULL_CHECK(mode); 672 673 BCMX_UNIT_ITER(bcm_unit, i) { 674 rv = bcm_field_group_mode_get(bcm_unit, group, mode); 675 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 676 return rv; 677 } 678 } 679 680 return BCM_E_UNAVAIL; 681 } 682 683 /* 684 * Function: 685 * bcmx_field_group_set 686 * Purpose: 687 * Update a previously created field group based on the field 688 * group selector flags 689 * Parameters: 690 * group - Field group ID 691 * qset - Field qualifier set 692 * Returns: 693 * BCM_E_NOT_FOUND Group ID not found 694 * BCM_E_XXX Error code 695 * BCM_E_NONE 696 * Notes: 697 * If no entry exist that use this group then updates are always 698 * permitted. 699 * If entries exist that use this group then updates are permitted 700 * only if it can be satisfied with the current selection of 701 * (f0, f1, f2, f3) field selector encodings. 702 */ 703 704 int 705 bcmx_field_group_set(bcm_field_group_t group, 706 bcm_field_qset_t qset) 707 { 708 int rv = BCM_E_UNAVAIL, tmp_rv; 709 int i, bcm_unit; 710 711 BCMX_FIELD_INIT_CHECK; 712 713 BCMX_UNIT_ITER(bcm_unit, i) { 714 tmp_rv = bcm_field_group_set(bcm_unit, group, qset); 715 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 716 } 717 718 return rv; 719 } 720 721 /* 722 * Function: 723 * bcmx_field_group_get 724 * Purpose: 725 * Get the qualifier set for a previously created field group 726 * Parameters: 727 * group - Field group ID 728 * qset - (OUT) Field qualifier set 729 * Returns: 730 * BCM_E_NOT_FOUND Field Group ID not found 731 * BCM_E_PARAM qset is NULL 732 * BCM_E_NONE 733 * Notes: 734 * Get value from first successful call 735 */ 736 737 int 738 bcmx_field_group_get(bcm_field_group_t group, 739 bcm_field_qset_t *qset) 740 { 741 int rv; 742 int i, bcm_unit; 743 744 BCMX_FIELD_INIT_CHECK; 745 746 BCMX_PARAM_NULL_CHECK(qset); 747 748 BCMX_UNIT_ITER(bcm_unit, i) { 749 rv = bcm_field_group_get(bcm_unit, group, qset); 750 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 751 return rv; 752 } 753 } 754 755 return BCM_E_UNAVAIL; 756 } 757 758 /* 759 * Function: 760 * bcmx_field_group_destroy 761 * Purpose: 762 * Delete a field group 763 * Parameters: 764 * group - Field group ID 765 * Returns: 766 * BCM_E_FAIL Entries not destroyed yet 767 * BCM_E_NONE 768 * Notes: 769 * All entries that uses this group should have been destroyed 770 * before calling this routine. 771 * Operation will fail if entries exist that uses this template 772 */ 773 774 int 775 bcmx_field_group_destroy(bcm_field_group_t group) 776 { 777 int rv = BCM_E_UNAVAIL, tmp_rv; 778 int i, bcm_unit; 779 780 BCMX_FIELD_INIT_CHECK; 781 782 BCMX_UNIT_ITER(bcm_unit, i) { 783 tmp_rv = bcm_field_group_destroy(bcm_unit, group); 784 BCM_IF_ERROR_RETURN 785 (BCMX_FIELD_DELETE_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 786 } 787 788 return rv; 789 } 790 791 /* 792 * Function: 793 * bcmx_field_group_enable_set 794 * Purpose: 795 * Enable or disable packet lookup on the given group. 796 * Parameters: 797 * group - Field group ID 798 * enable - Packet lookup is enable(if !=0) or disable(if == 0) on group 799 * Returns: 800 * BCM_E_NOT_FOUND Field Group ID not found 801 * BCM_E_XXX Error code 802 * BCM_E_NONE 803 */ 804 805 int 806 bcmx_field_group_enable_set(bcm_field_group_t group, 807 int enable) 808 { 809 int rv = BCM_E_UNAVAIL, tmp_rv; 810 int i, bcm_unit; 811 812 BCMX_FIELD_INIT_CHECK; 813 814 BCMX_UNIT_ITER(bcm_unit, i) { 815 tmp_rv = bcm_field_group_enable_set(bcm_unit, group, enable); 816 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 817 } 818 819 return rv; 820 } 821 822 /* 823 * Function: 824 * bcmx_field_group_enable_get 825 * Purpose: 826 * Get the packet lookup enable/disable state on the given group. 827 * Parameters: 828 * group - Field group ID 829 * enable - (OUT) Packet lookup enable/disable state of group 830 * Returns: 831 * BCM_E_NOT_FOUND Field Group ID not found 832 * BCM_E_XXX Error code 833 * BCM_E_NONE 834 * Notes: 835 * Get value from first successful call 836 */ 837 838 int 839 bcmx_field_group_enable_get(bcm_field_group_t group, 840 int *enable) 841 { 842 int rv; 843 int i, bcm_unit; 844 845 BCMX_FIELD_INIT_CHECK; 846 847 BCMX_PARAM_NULL_CHECK(enable); 848 849 BCMX_UNIT_ITER(bcm_unit, i) { 850 rv = bcm_field_group_enable_get(bcm_unit, group, enable); 851 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 852 return rv; 853 } 854 } 855 856 return BCM_E_UNAVAIL; 857 } 858 859 /* 860 * Function: 861 * bcmx_field_group_install 862 * Purpose: 863 * Install all entries of a field group into the hardware tables. 864 * Parameters: 865 * group - Field group ID 866 * Returns: 867 * BCM_E_XXX Error code 868 * BCM_E_NONE 869 */ 870 871 int 872 bcmx_field_group_install(bcm_field_group_t group) 873 { 874 int rv = BCM_E_UNAVAIL, tmp_rv; 875 int i, bcm_unit; 876 877 BCMX_FIELD_INIT_CHECK; 878 879 BCMX_UNIT_ITER(bcm_unit, i) { 880 tmp_rv = bcm_field_group_install(bcm_unit, group); 881 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 882 } 883 884 return rv; 885 } 886 887 /* 888 * Function: 889 * bcmx_field_group_remove 890 * Purpose: 891 * Remove all entries of a field group from the hardware table. 892 * Parameters: 893 * group - Field group ID 894 * Returns: 895 * BCM_E_XXX 896 * BCM_E_NONE 897 * Notes: 898 * This does not destroy the group or its entries; it uninstalls them from 899 * the hardware tables. 900 * Destroy a group using bcmx_field_group_destroy() 901 */ 902 903 int 904 bcmx_field_group_remove(bcm_field_group_t group) 905 { 906 int rv = BCM_E_UNAVAIL, tmp_rv; 907 int i, bcm_unit; 908 909 BCMX_FIELD_INIT_CHECK; 910 911 BCMX_UNIT_ITER(bcm_unit, i) { 912 tmp_rv = bcm_field_group_remove(bcm_unit, group); 913 BCM_IF_ERROR_RETURN 914 (BCMX_FIELD_DELETE_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 915 } 916 917 return rv; 918 } 919 920 /* 921 * Function: 922 * bcmx_field_range_create 923 * Purpose: 924 * Allocate a port range checker 925 * Parameters: 926 * range - (OUT) Range ID 927 * flags - One or more of BCM_FIELD_RANGE_xxx flags 928 * min - Lower bounds of range to be checked 929 * max - Upper bounds of range to be checked 930 * Returns: 931 * BCM_E_XXX Error code 932 * BCM_E_NONE 933 */ 934 935 int 936 bcmx_field_range_create(bcm_field_range_t *range, 937 uint32 flags, 938 bcm_l4_port_t min, 939 bcm_l4_port_t max) 940 { 941 int rv = BCM_E_UNAVAIL, tmp_rv; 942 int i, bcm_unit; 943 bcm_field_range_t range_id; 944 945 BCMX_FIELD_INIT_CHECK; 946 947 BCMX_PARAM_NULL_CHECK(range); 948 949 range_id = RANGE_ID_ALLOC; 950 *range = range_id; 951 952 BCMX_UNIT_ITER(bcm_unit, i) { 953 tmp_rv = bcm_field_range_create_id(bcm_unit, range_id, 954 flags, min, max); 955 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 956 } 957 958 return rv; 959 } 960 961 /* 962 * Function: 963 * bcmx_field_range_create_id 964 * Purpose: 965 * Allocate a port range checker with requested ID. 966 * Parameters: 967 * range - Range check ID to use 968 * flags - One or more of BCM_FIELD_RANGE_xxx flags 969 * min - Lower bounds of range to be checked 970 * max - Upper bounds of range to be checked 971 * Returns: 972 * BCM_E_XXX Error code 973 * BCM_E_NONE 974 */ 975 976 int 977 bcmx_field_range_create_id(bcm_field_range_t range, 978 uint32 flags, 979 bcm_l4_port_t min, 980 bcm_l4_port_t max) 981 { 982 int rv = BCM_E_UNAVAIL, tmp_rv; 983 int i, bcm_unit; 984 985 BCMX_FIELD_INIT_CHECK; 986 987 BCMX_UNIT_ITER(bcm_unit, i) { 988 tmp_rv = bcm_field_range_create_id(bcm_unit, range, 989 flags, min, max); 990 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 991 } 992 993 return rv; 994 } 995 996 /* 997 * Function: bcmx_field_range_group_create 998 * 999 * Purpose: 1000 * Allocate an interface group range checker and set its parameters. 1001 * 1002 * Parameters: 1003 * range - (OUT) Range check ID, will not be zero 1004 * flags - One or more of BCM_FIELD_RANGE_* flags 1005 * min - Lower bounds of range to be checked, inclusive 1006 * max - Upper bounds of range to be checked, inclusive 1007 * group - L3 interface group number 1008 * 1009 * Returns: 1010 * BCM_E_XXX - Error code 1011 * BCM_E_NONE - Success 1012 */ 1013 int 1014 bcmx_field_range_group_create(bcm_field_range_t *range, 1015 uint32 flags, 1016 bcm_l4_port_t min, 1017 bcm_l4_port_t max, 1018 bcm_if_group_t group) 1019 { 1020 int rv = BCM_E_UNAVAIL, tmp_rv; 1021 int i, bcm_unit; 1022 1023 BCMX_FIELD_INIT_CHECK; 1024 1025 BCMX_PARAM_NULL_CHECK(range); 1026 1027 BCMX_UNIT_ITER(bcm_unit, i) { 1028 tmp_rv = bcm_field_range_group_create(bcm_unit, range, 1029 flags, min, max, group); 1030 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 1031 } 1032 1033 return rv; 1034 } 1035 1036 /* 1037 * Function: bcmx_field_range_group_create_id 1038 * 1039 * Purpose: 1040 * Allocate an interface group range checker with requested ID 1041 * and set its parameters. 1042 * 1043 * Parameters: 1044 * range - Range check ID to use 1045 * flags - One or more of BCM_FIELD_RANGE_* flags 1046 * min - Lower bounds of range to be checked, inclusive 1047 * max - Upper bounds of range to be checked, inclusive 1048 * group - L3 interface group number 1049 * 1050 * Returns: 1051 * BCM_E_XXX - Error code 1052 * BCM_E_NONE - Success 1053 */ 1054 int 1055 bcmx_field_range_group_create_id(bcm_field_range_t range, 1056 uint32 flags, 1057 bcm_l4_port_t min, 1058 bcm_l4_port_t max, 1059 bcm_if_group_t group) 1060 { 1061 int rv = BCM_E_UNAVAIL, tmp_rv; 1062 int i, bcm_unit; 1063 1064 BCMX_FIELD_INIT_CHECK; 1065 1066 BCMX_UNIT_ITER(bcm_unit, i) { 1067 tmp_rv = bcm_field_range_group_create_id(bcm_unit, range, 1068 flags, min, max, group); 1069 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 1070 } 1071 1072 return rv; 1073 } 1074 1075 /* 1076 * Function: 1077 * bcmx_field_range_get 1078 * Purpose: 1079 * Get the TCP/UDP port range check setup 1080 * Parameters: 1081 * range - Range ID 1082 * flags - (OUT) One or more of BCM_FIELD_RANGE_xxx flags 1083 * min - (OUT) Lower bounds of range to be checked 1084 * max - (OUT) Upper bounds of range to be checked 1085 * Returns: 1086 * BCM_E_XXX Error code 1087 * BCM_E_NONE 1088 * Notes: 1089 * Get value from first successful call 1090 */ 1091 int 1092 bcmx_field_range_get(bcm_field_range_t range, 1093 uint32 *flags, 1094 bcm_l4_port_t *min, 1095 bcm_l4_port_t *max) 1096 { 1097 int rv; 1098 int i, bcm_unit; 1099 1100 BCMX_FIELD_INIT_CHECK; 1101 1102 BCMX_PARAM_NULL_CHECK(flags); 1103 BCMX_PARAM_NULL_CHECK(min); 1104 BCMX_PARAM_NULL_CHECK(max); 1105 1106 BCMX_UNIT_ITER(bcm_unit, i) { 1107 rv = bcm_field_range_get(bcm_unit, range, flags, min, max); 1108 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 1109 return rv; 1110 } 1111 } 1112 1113 return BCM_E_UNAVAIL; 1114 } 1115 1116 /* 1117 * Function: 1118 * bcmx_field_range_destroy 1119 * Purpose: 1120 * Deallocate a range 1121 * Parameters: 1122 * range - Range ID 1123 * Returns: 1124 * BCM_E_XXX Error code 1125 * BCM_E_NONE 1126 * Notes: 1127 * Get value from first successful call 1128 */ 1129 int 1130 bcmx_field_range_destroy(bcm_field_range_t range) 1131 { 1132 int rv = BCM_E_UNAVAIL, tmp_rv; 1133 int i, bcm_unit; 1134 1135 BCMX_FIELD_INIT_CHECK; 1136 1137 BCMX_UNIT_ITER(bcm_unit, i) { 1138 tmp_rv = bcm_field_range_destroy(bcm_unit, range); 1139 BCM_IF_ERROR_RETURN 1140 (BCMX_FIELD_DELETE_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 1141 } 1142 1143 return rv; 1144 } 1145 1146 /* 1147 * Function: 1148 * bcmx_field_entry_create 1149 * Purpose: 1150 * Create a blank entry group based on a group. 1151 * Parameters: 1152 * group - Field group ID 1153 * entry - (OUT) New entry ID 1154 * Returns: 1155 * BCM_E_EXISTS Entry ID already in use 1156 * BCM_E_NOT_FOUND Group ID not found 1157 * BCM_E_MEMORY allocation failure 1158 * BCM_E_NONE 1159 */ 1160 1161 int 1162 bcmx_field_entry_create(bcm_field_group_t group, 1163 bcm_field_entry_t *entry) 1164 { 1165 int rv = BCM_E_UNAVAIL, tmp_rv; 1166 int i, bcm_unit; 1167 bcm_field_entry_t eid; 1168 1169 BCMX_FIELD_INIT_CHECK; 1170 1171 BCMX_PARAM_NULL_CHECK(entry); 1172 1173 eid = ENTRY_ID_ALLOC; 1174 *entry = eid; 1175 1176 BCMX_UNIT_ITER(bcm_unit, i) { 1177 tmp_rv = bcm_field_entry_create_id(bcm_unit, group, eid); 1178 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 1179 } 1180 1181 return rv; 1182 } 1183 1184 /* 1185 * Function: 1186 * bcmx_field_entry_create_id 1187 * Purpose: 1188 * Create a blank entry group with requested ID based on a group. 1189 * Parameters: 1190 * group - Field group ID 1191 * entry - Requested entry ID 1192 * Returns: 1193 * BCM_E_EXISTS Entry ID already in use 1194 * BCM_E_NOT_FOUND Group ID not found 1195 * BCM_E_MEMORY allocation failure 1196 * BCM_E_NONE 1197 */ 1198 1199 int 1200 bcmx_field_entry_create_id(bcm_field_group_t group, 1201 bcm_field_entry_t entry) 1202 { 1203 int rv = BCM_E_UNAVAIL, tmp_rv; 1204 int i, bcm_unit; 1205 1206 BCMX_FIELD_INIT_CHECK; 1207 1208 BCMX_UNIT_ITER(bcm_unit, i) { 1209 tmp_rv = bcm_field_entry_create_id(bcm_unit, group, entry); 1210 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 1211 } 1212 1213 return rv; 1214 } 1215 1216 /* 1217 * Function: 1218 * bcmx_field_entry_multi_get 1219 * Purpose: 1220 * Gets an array of a group's entry IDs 1221 * Parameters: 1222 * group - Field group ID. 1223 * entry_size - Maximum number of entries to return. Set to 0 1224 * to get the number of entries available. 1225 * entry_array - (OUT) Pointer to a buffer to fill with the array of 1226 * entry IDs. Ignored if entry_size is 0. 1227 * entry_count - (OUT) Returns the number of entries returned in the 1228 * array, or if entry_size was 0, the number of 1229 * entries available. 1230 * Returns: 1231 * BCM_E_INIT - Unit not initialized 1232 * BCM_E_NOT_FOUND - Group ID not found 1233 * BCM_E_NONE - Success 1234 * Notes: 1235 * Assumes homogeneuous systems and all devices in stack 1236 * has the same field groups/entries successfully installed. 1237 */ 1238 int 1239 bcmx_field_entry_multi_get(bcm_field_group_t group, 1240 int entry_size, 1241 bcm_field_entry_t *entry_array, 1242 int *entry_count) 1243 { 1244 int rv; 1245 int i, bcm_unit; 1246 1247 BCMX_FIELD_INIT_CHECK; 1248 1249 BCMX_PARAM_NULL_CHECK(entry_count); 1250 1251 /* 1252 * No need to gather entries from all units. BCMX assumes 1253 * that field groups/entries were created with BCMX APIs. 1254 */ 1255 BCMX_UNIT_ITER(bcm_unit, i) { 1256 rv = bcm_field_entry_multi_get(bcm_unit, group, entry_size, 1257 entry_array, entry_count); 1258 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 1259 return rv; 1260 } 1261 } 1262 1263 return BCM_E_UNAVAIL; 1264 } 1265 1266 /* 1267 * Function: 1268 * bcmx_field_entry_destroy 1269 * Purpose: 1270 * Destroy an entry 1271 * Parameters: 1272 * entry - Entry ID 1273 * Returns: 1274 * BCM_E_INTERNAL Null group found 1275 * BCM_E_XXX Error code 1276 * BCM_E_NONE 1277 */ 1278 1279 int 1280 bcmx_field_entry_destroy(bcm_field_entry_t entry) 1281 { 1282 int rv = BCM_E_UNAVAIL, tmp_rv; 1283 int i, bcm_unit; 1284 1285 BCMX_FIELD_INIT_CHECK; 1286 1287 BCMX_UNIT_ITER(bcm_unit, i) { 1288 tmp_rv = bcm_field_entry_destroy(bcm_unit, entry); 1289 BCM_IF_ERROR_RETURN 1290 (BCMX_FIELD_DELETE_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 1291 } 1292 1293 return rv; 1294 } 1295 1296 /* 1297 * Function: 1298 * bcmx_field_entry_destroy_all 1299 * Purpose: 1300 * Destroy all entries 1301 * Parameters: 1302 * None 1303 * Returns: 1304 * BCM_E_XXX Error code 1305 * BCM_E_NONE 1306 */ 1307 1308 int 1309 bcmx_field_entry_destroy_all(void) 1310 { 1311 int rv = BCM_E_UNAVAIL, tmp_rv; 1312 int i, bcm_unit; 1313 1314 BCMX_FIELD_INIT_CHECK; 1315 1316 BCMX_UNIT_ITER(bcm_unit, i) { 1317 tmp_rv = bcm_field_entry_destroy_all(bcm_unit); 1318 BCM_IF_ERROR_RETURN 1319 (BCMX_FIELD_DELETE_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 1320 } 1321 1322 return rv; 1323 } 1324 1325 /* 1326 * Function: 1327 * bcmx_field_entry_copy 1328 * Purpose: 1329 * Create a copy of an existing entry 1330 * Parameters: 1331 * src_entry - Entry to copy 1332 * dst_entry - (OUT) New entry 1333 * Returns: 1334 * BCM_E_NOT_FOUND Source entry not found 1335 * BCM_E_INTERNAL Newly created entry not found. 1336 * BCM_E_XXX Error code 1337 * BCM_E_NONE 1338 */ 1339 1340 int 1341 bcmx_field_entry_copy(bcm_field_entry_t src_entry, 1342 bcm_field_entry_t *dst_entry) 1343 { 1344 int rv = BCM_E_UNAVAIL, tmp_rv; 1345 int i, bcm_unit; 1346 bcm_field_entry_t eid; 1347 1348 BCMX_FIELD_INIT_CHECK; 1349 1350 BCMX_PARAM_NULL_CHECK(dst_entry); 1351 1352 eid = ENTRY_ID_ALLOC; 1353 *dst_entry = eid; 1354 1355 BCMX_UNIT_ITER(bcm_unit, i) { 1356 tmp_rv = bcm_field_entry_copy_id(bcm_unit, src_entry, eid); 1357 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 1358 } 1359 1360 return rv; 1361 } 1362 1363 /* 1364 * Function: 1365 * bcmx_field_entry_install 1366 * Purpose: 1367 * Install entry into the hardware tables 1368 * Parameters: 1369 * entry - Entry to install 1370 * Returns: 1371 * BCM_E_NOT_FOUND Entry ID not found 1372 * BCM_E_INTERNAL No group for entry ID 1373 * BCM_E_XXX Error code 1374 * BCM_E_NONE 1375 * Notes: 1376 * Qualifications should be made and actions should be added 1377 * prior to installing the entry. 1378 * The bcm_field_entry_t object is not consumed or destroyed. 1379 * It can be used to remove or update the entry. 1380 */ 1381 1382 int 1383 bcmx_field_entry_install(bcm_field_entry_t entry) 1384 { 1385 int rv = BCM_E_UNAVAIL, tmp_rv; 1386 int i, bcm_unit; 1387 1388 BCMX_FIELD_INIT_CHECK; 1389 1390 BCMX_UNIT_ITER(bcm_unit, i) { 1391 tmp_rv = bcm_field_entry_install(bcm_unit, entry); 1392 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 1393 } 1394 1395 return rv; 1396 } 1397 1398 /* 1399 * Function: 1400 * bcmx_field_entry_reinstall 1401 * Purpose: 1402 * Re-install entry into the hardware tables 1403 * Parameters: 1404 * entry - Entry to install 1405 * Returns: 1406 * BCM_E_NOT_FOUND Entry ID not found 1407 * BCM_E_INTERNAL No group for entry ID 1408 * BCM_E_XXX Error code 1409 * BCM_E_NONE 1410 * 1411 * Notes: 1412 * Reinstallation may only be used to change the actions for 1413 * an installed entry without having to remove and re-add the 1414 * entry. 1415 */ 1416 1417 int 1418 bcmx_field_entry_reinstall(bcm_field_entry_t entry) 1419 { 1420 int rv = BCM_E_UNAVAIL, tmp_rv; 1421 int i, bcm_unit; 1422 1423 BCMX_FIELD_INIT_CHECK; 1424 1425 BCMX_UNIT_ITER(bcm_unit, i) { 1426 tmp_rv = bcm_field_entry_reinstall(bcm_unit, entry); 1427 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 1428 } 1429 1430 return rv; 1431 } 1432 1433 /* 1434 * Function: 1435 * bcmx_field_entry_remove 1436 * Purpose: 1437 * Remove entry from the hardware tables 1438 * Parameters: 1439 * entry - Entry to remove 1440 * Returns: 1441 * BCM_E_XXX 1442 * BCM_E_NONE 1443 * Notes: 1444 * This does not destroy the entry; it uninstalls it from 1445 * the hardware tables. 1446 * Destroy a entry using bcmx_field_entry_destroy() 1447 */ 1448 1449 int 1450 bcmx_field_entry_remove(bcm_field_entry_t entry) 1451 { 1452 int rv = BCM_E_UNAVAIL, tmp_rv; 1453 int i, bcm_unit; 1454 1455 BCMX_FIELD_INIT_CHECK; 1456 1457 BCMX_UNIT_ITER(bcm_unit, i) { 1458 tmp_rv = bcm_field_entry_remove(bcm_unit, entry); 1459 BCM_IF_ERROR_RETURN 1460 (BCMX_FIELD_DELETE_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 1461 } 1462 1463 return rv; 1464 } 1465 1466 /* 1467 * Function: bcmx_field_entry_prio_get 1468 * 1469 * Purpose: 1470 * Gets the priority within the group of the entry. 1471 * 1472 * Parameters: 1473 * entry - Field entry to operate on 1474 * prio - (OUT) priority of entry 1475 * 1476 * Returns: 1477 * BCM_E_NONE - Success 1478 * BCM_E_PARAM - prio pointing to NULL 1479 * BCM_E_NOT_FOUND - Entry ID not found 1480 */ 1481 1482 int 1483 bcmx_field_entry_prio_get(bcm_field_entry_t entry, 1484 int *prio) 1485 { 1486 int rv; 1487 int i, bcm_unit; 1488 1489 BCMX_FIELD_INIT_CHECK; 1490 1491 BCMX_PARAM_NULL_CHECK(prio); 1492 1493 BCMX_UNIT_ITER(bcm_unit, i) { 1494 rv = bcm_field_entry_prio_get(bcm_unit, entry, prio); 1495 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 1496 return rv; 1497 } 1498 } 1499 1500 return BCM_E_UNAVAIL; 1501 } 1502 1503 /* 1504 * Function: bcmx_field_entry_prio_set 1505 * 1506 * Purpose: 1507 * Sets the priority for the given entry. 1508 * 1509 * Parameters: 1510 * entry - Field entry to operate on 1511 * prio - Priority of entry 1512 * 1513 * Returns: 1514 * BCM_E_NONE Success 1515 */ 1516 1517 int 1518 bcmx_field_entry_prio_set(bcm_field_entry_t entry, 1519 int prio) 1520 { 1521 int rv = BCM_E_UNAVAIL, tmp_rv; 1522 int i, bcm_unit; 1523 1524 BCMX_FIELD_INIT_CHECK; 1525 1526 BCMX_UNIT_ITER(bcm_unit, i) { 1527 tmp_rv = bcm_field_entry_prio_set(bcm_unit, entry, prio); 1528 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 1529 } 1530 1531 return rv; 1532 } 1533 1534 1535 /* 1536 * Function: 1537 * bcmx_field_entry_policer_attach 1538 */ 1539 int 1540 bcmx_field_entry_policer_attach(bcm_field_entry_t entry_id, int level, 1541 bcm_policer_t policer_id) 1542 { 1543 int rv = BCM_E_UNAVAIL, tmp_rv; 1544 int i, bcm_unit; 1545 1546 BCMX_FIELD_INIT_CHECK; 1547 1548 BCMX_UNIT_ITER(bcm_unit, i) { 1549 tmp_rv = bcm_field_entry_policer_attach(bcm_unit, entry_id, 1550 level, policer_id); 1551 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 1552 } 1553 1554 return rv; 1555 } 1556 1557 /* 1558 * Function: 1559 * bcmx_field_entry_policer_detach 1560 */ 1561 int 1562 bcmx_field_entry_policer_detach(bcm_field_entry_t entry_id, int level) 1563 { 1564 int rv = BCM_E_UNAVAIL, tmp_rv; 1565 int i, bcm_unit; 1566 1567 BCMX_FIELD_INIT_CHECK; 1568 1569 BCMX_UNIT_ITER(bcm_unit, i) { 1570 tmp_rv = bcm_field_entry_policer_detach(bcm_unit, entry_id, 1571 level); 1572 BCM_IF_ERROR_RETURN 1573 (BCMX_FIELD_DELETE_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 1574 } 1575 1576 return rv; 1577 } 1578 1579 /* 1580 * Function: 1581 * bcmx_field_entry_policer_detach_all 1582 */ 1583 int 1584 bcmx_field_entry_policer_detach_all(bcm_field_entry_t entry_id) 1585 { 1586 int rv = BCM_E_UNAVAIL, tmp_rv; 1587 int i, bcm_unit; 1588 1589 BCMX_FIELD_INIT_CHECK; 1590 1591 BCMX_UNIT_ITER(bcm_unit, i) { 1592 tmp_rv = bcm_field_entry_policer_detach_all(bcm_unit, entry_id); 1593 BCM_IF_ERROR_RETURN 1594 (BCMX_FIELD_DELETE_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 1595 } 1596 1597 return rv; 1598 } 1599 1600 /* 1601 * Function: 1602 * bcmx_field_entry_policer_get 1603 */ 1604 int 1605 bcmx_field_entry_policer_get(bcm_field_entry_t entry_id, int level, 1606 bcm_policer_t *policer_id) 1607 { 1608 int rv; 1609 int i, bcm_unit; 1610 1611 BCMX_FIELD_INIT_CHECK; 1612 1613 BCMX_PARAM_NULL_CHECK(policer_id); 1614 1615 BCMX_UNIT_ITER(bcm_unit, i) { 1616 rv = bcm_field_entry_policer_get(bcm_unit, entry_id, level, 1617 policer_id); 1618 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 1619 return rv; 1620 } 1621 } 1622 1623 return BCM_E_UNAVAIL; 1624 } 1625 1626 1627 /* 1628 * Function: 1629 * bcmx_field_resync 1630 * Purpose: 1631 * Invalidate HW FP entries that have not been replayed after warm boot. 1632 * Can be used in general to clear entries that are in HW but not in SW. 1633 * Parameters: 1634 * None 1635 * Returns: 1636 * BCM_E_INIT - Unit not initialized 1637 * BCM_E_XXX - Other errors 1638 * BCM_E_NONE - Success 1639 */ 1640 1641 int 1642 bcmx_field_resync(void) 1643 { 1644 int rv = BCM_E_UNAVAIL, tmp_rv; 1645 int i, bcm_unit; 1646 1647 BCMX_FIELD_INIT_CHECK; 1648 1649 BCMX_UNIT_ITER(bcm_unit, i) { 1650 tmp_rv = bcm_field_resync(bcm_unit); 1651 BCM_IF_ERROR_RETURN(BCMX_FIELD_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 1652 } 1653 1654 return rv; 1655 } 1656 1657 /* 1658 * Function: 1659 * bcmx_field_qualify_clear 1660 * Purpose: 1661 * Remove all field qualifications from a filter entry 1662 * Parameters: 1663 * entry - Field entry to operate on 1664 * Returns: 1665 * BCM_E_NOT_FOUND Entry ID not found 1666 * BCM_E_XXX Error code 1667 * BCM_E_NONE 1668 */ 1669 1670 int 1671 bcmx_field_qualify_clear(bcm_field_entry_t entry) 1672 { 1673 int rv = BCM_E_UNAVAIL, tmp_rv; 1674 int i, bcm_unit; 1675 1676 BCMX_FIELD_INIT_CHECK; 1677 1678 BCMX_UNIT_ITER(bcm_unit, i) { 1679 tmp_rv = bcm_field_qualify_clear(bcm_unit, entry); 1680 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 1681 } 1682 1683 return rv; 1684 } 1685 1686 /* 1687 * Function: 1688 * bcmx_field_qualify_InPort 1689 * Purpose: 1690 * Add single logical port qualification to a filter entry 1691 * Parameters: 1692 * entry - Field entry to operate on 1693 * port - Logical port 1694 * Returns: 1695 * BCM_E_NOT_FOUND Entry ID not found 1696 * BCM_E_INTERNAL No group exists for entry ID 1697 * BCM_E_XXX 1698 */ 1699 1700 int 1701 bcmx_field_qualify_InPort(bcm_field_entry_t entry, 1702 bcmx_lport_t port) 1703 { 1704 int rv = BCM_E_UNAVAIL, tmp_rv; 1705 int i, bcm_unit, unit; 1706 bcm_port_t data, in_port; 1707 bcm_port_t mask; 1708 1709 BCMX_FIELD_INIT_CHECK; 1710 1711 BCM_IF_ERROR_RETURN 1712 (_bcmx_dest_to_unit_port(port, &unit, &in_port, 1713 BCMX_DEST_CONVERT_DEFAULT)); 1714 1715 mask = BCM_FIELD_EXACT_MATCH_MASK; 1716 1717 /* 1718 * Set data to zero in devices that do not contain port 1719 * in order to override default value (which would match all ports) 1720 */ 1721 BCMX_UNIT_ITER(bcm_unit, i) { 1722 if (bcm_unit == unit) { 1723 data = in_port; 1724 } else { 1725 data = 0; 1726 } 1727 tmp_rv = bcm_field_qualify_InPort(bcm_unit, entry, data, mask); 1728 1729 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 1730 } 1731 1732 return rv; 1733 } 1734 1735 /* 1736 * Function: 1737 * bcmx_field_qualify_OutPort 1738 * Purpose: 1739 * Add single logical output port qualification to a filter entry 1740 * Parameters: 1741 * entry - Field entry to operate on 1742 * port - Logical port 1743 * Returns: 1744 * BCM_E_NOT_FOUND Entry ID not found 1745 * BCM_E_INTERNAL No group exists for entry ID 1746 * BCM_E_XXX 1747 */ 1748 1749 int 1750 bcmx_field_qualify_OutPort(bcm_field_entry_t entry, 1751 bcmx_lport_t port) 1752 { 1753 int rv = BCM_E_UNAVAIL, tmp_rv; 1754 int i, bcm_unit, unit; 1755 bcm_port_t data, out_port; 1756 bcm_port_t mask; 1757 1758 BCMX_FIELD_INIT_CHECK; 1759 1760 BCM_IF_ERROR_RETURN 1761 (_bcmx_dest_to_unit_port(port, &unit, &out_port, 1762 BCMX_DEST_CONVERT_DEFAULT)); 1763 1764 mask = BCM_FIELD_EXACT_MATCH_MASK; 1765 1766 1767 /* 1768 * Set data to zero in devices that do not contain port 1769 * in order to override default value (which would match all ports) 1770 */ 1771 BCMX_UNIT_ITER(bcm_unit, i) { 1772 if (bcm_unit == unit) { 1773 data = out_port; 1774 } else { 1775 data = 0; 1776 } 1777 tmp_rv = bcm_field_qualify_OutPort(bcm_unit, entry, data, mask); 1778 1779 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 1780 } 1781 1782 return rv; 1783 } 1784 1785 /* 1786 * Function: 1787 * bcmx_field_qualify_InPorts 1788 * Purpose: 1789 * Add the ingress ports qualification to a filter entry 1790 * Parameters: 1791 * entry - Field entry to operate on 1792 * lplist - Logical ingress port list 1793 * Returns: 1794 * BCM_E_NOT_FOUND Entry ID not found 1795 * BCM_E_INTERNAL No group exists for entry ID 1796 * BCM_E_XXX 1797 */ 1798 1799 int 1800 bcmx_field_qualify_InPorts(bcm_field_entry_t entry, 1801 bcmx_lplist_t lplist) 1802 { 1803 int rv = BCM_E_UNAVAIL, tmp_rv; 1804 int i, bcm_unit; 1805 bcm_pbmp_t data; 1806 bcm_pbmp_t mask; 1807 1808 BCMX_FIELD_INIT_CHECK; 1809 1810 BCM_PBMP_CLEAR(mask); 1811 BCM_PBMP_NEGATE(mask, mask); 1812 1813 BCMX_UNIT_ITER(bcm_unit, i) { 1814 BCMX_LPLIST_TO_PBMP(lplist, bcm_unit, data); 1815 tmp_rv = bcm_field_qualify_InPorts(bcm_unit, entry, data, mask); 1816 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 1817 } 1818 1819 return rv; 1820 } 1821 1822 /* 1823 * Function: 1824 * bcmx_field_qualify_OutPorts 1825 */ 1826 1827 int 1828 bcmx_field_qualify_OutPorts(bcm_field_entry_t entry, 1829 bcmx_lplist_t lplist) 1830 { 1831 int rv = BCM_E_UNAVAIL, tmp_rv; 1832 int i, bcm_unit; 1833 bcm_pbmp_t data; 1834 bcm_pbmp_t mask; 1835 1836 BCMX_FIELD_INIT_CHECK; 1837 1838 BCM_PBMP_CLEAR(mask); 1839 BCM_PBMP_NEGATE(mask, mask); 1840 1841 BCMX_UNIT_ITER(bcm_unit, i) { 1842 BCMX_LPLIST_TO_PBMP(lplist, bcm_unit, data); 1843 tmp_rv = bcm_field_qualify_OutPorts(bcm_unit, entry, data, mask); 1844 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 1845 } 1846 1847 return rv; 1848 } 1849 1850 /* 1851 * Function: 1852 * bcmx_field_qualify_Drop 1853 */ 1854 1855 int 1856 bcmx_field_qualify_Drop(bcm_field_entry_t entry, 1857 uint8 data, uint8 mask) 1858 { 1859 int rv = BCM_E_UNAVAIL, tmp_rv; 1860 int i, bcm_unit; 1861 1862 BCMX_FIELD_INIT_CHECK; 1863 1864 BCMX_UNIT_ITER(bcm_unit, i) { 1865 tmp_rv = bcm_field_qualify_Drop(bcm_unit, entry, data, mask); 1866 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 1867 } 1868 1869 return rv; 1870 } 1871 1872 /* 1873 * Function: 1874 * bcmx_field_qualify_SrcPort 1875 * Purpose: 1876 * Add the source logical port qualification to a filter entry 1877 * Parameters: 1878 * entry - Field entry to operate on 1879 * port - Source logical port 1880 * Returns: 1881 * BCM_E_NOT_FOUND Entry ID not found 1882 * BCM_E_INTERNAL No group exists for entry ID 1883 * BCM_E_XXX 1884 */ 1885 1886 int 1887 bcmx_field_qualify_SrcPort(bcm_field_entry_t entry, 1888 bcmx_lport_t port) 1889 { 1890 int rv = BCM_E_UNAVAIL, tmp_rv; 1891 int i, bcm_unit; 1892 bcm_module_t data_modid, mask_modid; 1893 bcm_port_t data_port, mask_port; 1894 1895 BCMX_FIELD_INIT_CHECK; 1896 1897 BCM_IF_ERROR_RETURN 1898 (_bcmx_dest_to_modid_port(port, 1899 &data_modid, &data_port, 1900 BCMX_DEST_CONVERT_DEFAULT)); 1901 1902 mask_modid = mask_port = BCM_FIELD_EXACT_MATCH_MASK; 1903 1904 BCMX_UNIT_ITER(bcm_unit, i) { 1905 tmp_rv = bcm_field_qualify_SrcPort(bcm_unit, entry, 1906 data_modid, mask_modid, 1907 data_port, mask_port); 1908 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 1909 } 1910 1911 return rv; 1912 } 1913 1914 /* 1915 * Function: 1916 * bcmx_field_qualify_SrcTrunk 1917 * Purpose: 1918 * Add the source trunk group ID qualification to a filter entry 1919 * Parameters: 1920 * entry - Field entry to operate on 1921 * tid - Source trunk group ID 1922 * Returns: 1923 * BCM_E_NOT_FOUND Entry ID not found 1924 * BCM_E_INTERNAL No group exists for entry ID 1925 * BCM_E_XXX 1926 */ 1927 1928 int 1929 bcmx_field_qualify_SrcTrunk(bcm_field_entry_t entry, 1930 bcm_trunk_t tid) 1931 { 1932 int rv = BCM_E_UNAVAIL, tmp_rv; 1933 int i, bcm_unit; 1934 bcm_port_t data; 1935 bcm_port_t mask; 1936 1937 BCMX_FIELD_INIT_CHECK; 1938 1939 data = tid; 1940 mask = BCM_FIELD_EXACT_MATCH_MASK; 1941 BCMX_UNIT_ITER(bcm_unit, i) { 1942 tmp_rv = bcm_field_qualify_SrcTrunk(bcm_unit, entry, data, mask); 1943 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 1944 } 1945 1946 return rv; 1947 } 1948 1949 /* 1950 * Function: 1951 * bcmx_field_qualify_DstPort 1952 * Purpose: 1953 * Add the destination logical port qualification to a filter entry 1954 * Parameters: 1955 * entry - Field entry to operate on 1956 * port - Destination logical port 1957 * Returns: 1958 * BCM_E_NOT_FOUND Entry ID not found 1959 * BCM_E_INTERNAL No group exists for entry ID 1960 * BCM_E_XXX 1961 */ 1962 1963 int 1964 bcmx_field_qualify_DstPort(bcm_field_entry_t entry, 1965 bcmx_lport_t port) 1966 { 1967 int rv = BCM_E_UNAVAIL, tmp_rv; 1968 int i, bcm_unit; 1969 bcm_module_t data_modid, mask_modid; 1970 bcm_port_t data_port, mask_port; 1971 1972 BCMX_FIELD_INIT_CHECK; 1973 1974 BCM_IF_ERROR_RETURN 1975 (_bcmx_dest_to_modid_port(port, 1976 &data_modid, &data_port, 1977 BCMX_DEST_CONVERT_DEFAULT)); 1978 1979 mask_modid = mask_port = BCM_FIELD_EXACT_MATCH_MASK; 1980 1981 BCMX_UNIT_ITER(bcm_unit, i) { 1982 tmp_rv = bcm_field_qualify_DstPort(bcm_unit, entry, 1983 data_modid, mask_modid, 1984 data_port, mask_port); 1985 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 1986 } 1987 1988 return rv; 1989 } 1990 1991 /* 1992 * Function: 1993 * bcmx_field_qualify_DstTrunk 1994 * Purpose: 1995 * Add the destination trunk group ID qualification to a filter entry 1996 * Parameters: 1997 * entry - Field entry to operate on 1998 * tid - Destination trunk group ID 1999 * Returns: 2000 * BCM_E_NOT_FOUND Entry ID not found 2001 * BCM_E_INTERNAL No group exists for entry ID 2002 * BCM_E_XXX 2003 */ 2004 2005 int 2006 bcmx_field_qualify_DstTrunk(bcm_field_entry_t entry, 2007 bcm_trunk_t tid) 2008 { 2009 int rv = BCM_E_UNAVAIL, tmp_rv; 2010 int i, bcm_unit; 2011 bcm_port_t data; 2012 bcm_port_t mask; 2013 2014 BCMX_FIELD_INIT_CHECK; 2015 2016 data = tid; 2017 mask = BCM_FIELD_EXACT_MATCH_MASK; 2018 BCMX_UNIT_ITER(bcm_unit, i) { 2019 tmp_rv = bcm_field_qualify_DstTrunk(bcm_unit, entry, data, mask); 2020 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 2021 } 2022 2023 return rv; 2024 } 2025 2026 /* 2027 * Function: 2028 * bcmx_field_qualify_XXX (class of routines) 2029 * Purpose: 2030 * Add a field qualification to a filter entry. 2031 * Parameters: 2032 * entry - Field entry to operate on 2033 * data - Data to qualify with (type varies) 2034 * mask - Mask to qualify with (type is same as for data) 2035 * Returns: 2036 * BCM_E_NOT_FOUND Entry ID not found. 2037 * BCM_E_INTERNAL No group exists for entry ID. 2038 * BCM_E_XXX 2039 */ 2040 2041 /* 2042 * Function: 2043 * bcmx_field_qualify_L4SrcPort 2044 */ 2045 2046 int 2047 bcmx_field_qualify_L4SrcPort(bcm_field_entry_t entry, 2048 bcm_l4_port_t data, bcm_l4_port_t mask) 2049 { 2050 int rv = BCM_E_UNAVAIL, tmp_rv; 2051 int i, bcm_unit; 2052 2053 BCMX_FIELD_INIT_CHECK; 2054 2055 BCMX_UNIT_ITER(bcm_unit, i) { 2056 tmp_rv = bcm_field_qualify_L4SrcPort(bcm_unit, entry, data, mask); 2057 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 2058 } 2059 2060 return rv; 2061 } 2062 2063 /* 2064 * Function: 2065 * bcmx_field_qualify_L4DstPort 2066 */ 2067 2068 int 2069 bcmx_field_qualify_L4DstPort(bcm_field_entry_t entry, 2070 bcm_l4_port_t data, bcm_l4_port_t mask) 2071 { 2072 int rv = BCM_E_UNAVAIL, tmp_rv; 2073 int i, bcm_unit; 2074 2075 BCMX_FIELD_INIT_CHECK; 2076 2077 BCMX_UNIT_ITER(bcm_unit, i) { 2078 tmp_rv = bcm_field_qualify_L4DstPort(bcm_unit, entry, data, mask); 2079 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 2080 } 2081 2082 return rv; 2083 } 2084 2085 /* 2086 * Function: 2087 * bcmx_field_qualify_OuterVlan 2088 */ 2089 2090 int 2091 bcmx_field_qualify_OuterVlan(bcm_field_entry_t entry, 2092 bcm_vlan_t data, bcm_vlan_t mask) 2093 { 2094 int rv = BCM_E_UNAVAIL, tmp_rv; 2095 int i, bcm_unit; 2096 2097 BCMX_FIELD_INIT_CHECK; 2098 2099 BCMX_UNIT_ITER(bcm_unit, i) { 2100 tmp_rv = bcm_field_qualify_OuterVlan(bcm_unit, entry, data, mask); 2101 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 2102 } 2103 2104 return rv; 2105 } 2106 2107 /* 2108 * Function: 2109 * bcmx_field_qualify_OuterVlanId 2110 */ 2111 2112 int 2113 bcmx_field_qualify_OuterVlanId(bcm_field_entry_t entry, 2114 bcm_vlan_t data, bcm_vlan_t mask) 2115 { 2116 int rv = BCM_E_UNAVAIL, tmp_rv; 2117 int i, bcm_unit; 2118 2119 BCMX_FIELD_INIT_CHECK; 2120 2121 BCMX_UNIT_ITER(bcm_unit, i) { 2122 tmp_rv = bcm_field_qualify_OuterVlanId(bcm_unit, entry, data, mask); 2123 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 2124 } 2125 2126 return rv; 2127 } 2128 2129 /* 2130 * Function: 2131 * bcmx_field_qualify_ForwardingVlanId 2132 */ 2133 2134 int 2135 bcmx_field_qualify_ForwardingVlanId(bcm_field_entry_t entry, 2136 bcm_vlan_t data, bcm_vlan_t mask) 2137 { 2138 int rv = BCM_E_UNAVAIL, tmp_rv; 2139 int i, bcm_unit; 2140 2141 BCMX_FIELD_INIT_CHECK; 2142 2143 BCMX_UNIT_ITER(bcm_unit, i) { 2144 tmp_rv = bcm_field_qualify_ForwardingVlanId(bcm_unit, entry, data, mask); 2145 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 2146 } 2147 2148 return rv; 2149 } 2150 2151 /* 2152 * Function: 2153 * bcmx_field_qualify_OuterVlanPri 2154 */ 2155 2156 int 2157 bcmx_field_qualify_OuterVlanPri(bcm_field_entry_t entry, 2158 uint8 data, uint8 mask) 2159 { 2160 int rv = BCM_E_UNAVAIL, tmp_rv; 2161 int i, bcm_unit; 2162 2163 BCMX_FIELD_INIT_CHECK; 2164 2165 BCMX_UNIT_ITER(bcm_unit, i) { 2166 tmp_rv = bcm_field_qualify_OuterVlanPri(bcm_unit, entry, data, mask); 2167 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 2168 } 2169 2170 return rv; 2171 } 2172 2173 /* 2174 * Function: 2175 * bcmx_field_qualify_OuterVlanCfi 2176 */ 2177 2178 int 2179 bcmx_field_qualify_OuterVlanCfi(bcm_field_entry_t entry, 2180 uint8 data, uint8 mask) 2181 { 2182 int rv = BCM_E_UNAVAIL, tmp_rv; 2183 int i, bcm_unit; 2184 2185 BCMX_FIELD_INIT_CHECK; 2186 2187 BCMX_UNIT_ITER(bcm_unit, i) { 2188 tmp_rv = bcm_field_qualify_OuterVlanCfi(bcm_unit, entry, data, mask); 2189 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 2190 } 2191 2192 return rv; 2193 } 2194 2195 /* 2196 * Function: 2197 * bcmx_field_qualify_InnerVlan 2198 */ 2199 2200 int 2201 bcmx_field_qualify_InnerVlan(bcm_field_entry_t entry, 2202 bcm_vlan_t data, bcm_vlan_t mask) 2203 { 2204 int rv = BCM_E_UNAVAIL, tmp_rv; 2205 int i, bcm_unit; 2206 2207 BCMX_FIELD_INIT_CHECK; 2208 2209 BCMX_UNIT_ITER(bcm_unit, i) { 2210 tmp_rv = bcm_field_qualify_InnerVlan(bcm_unit, entry, data, mask); 2211 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 2212 } 2213 2214 return rv; 2215 } 2216 2217 /* 2218 * Function: 2219 * bcmx_field_qualify_InnerVlanId 2220 */ 2221 2222 int 2223 bcmx_field_qualify_InnerVlanId(bcm_field_entry_t entry, 2224 bcm_vlan_t data, bcm_vlan_t mask) 2225 { 2226 int rv = BCM_E_UNAVAIL, tmp_rv; 2227 int i, bcm_unit; 2228 2229 BCMX_FIELD_INIT_CHECK; 2230 2231 BCMX_UNIT_ITER(bcm_unit, i) { 2232 tmp_rv = bcm_field_qualify_InnerVlanId(bcm_unit, entry, data, mask); 2233 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 2234 } 2235 2236 return rv; 2237 } 2238 2239 /* 2240 * Function: 2241 * bcmx_field_qualify_InnerVlanPri 2242 */ 2243 2244 int 2245 bcmx_field_qualify_InnerVlanPri(bcm_field_entry_t entry, 2246 uint8 data, uint8 mask) 2247 { 2248 int rv = BCM_E_UNAVAIL, tmp_rv; 2249 int i, bcm_unit; 2250 2251 BCMX_FIELD_INIT_CHECK; 2252 2253 BCMX_UNIT_ITER(bcm_unit, i) { 2254 tmp_rv = bcm_field_qualify_InnerVlanPri(bcm_unit, entry, data, mask); 2255 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 2256 } 2257 2258 return rv; 2259 } 2260 2261 /* 2262 * Function: 2263 * bcmx_field_qualify_InnerVlanCfi 2264 */ 2265 2266 int 2267 bcmx_field_qualify_InnerVlanCfi(bcm_field_entry_t entry, 2268 uint8 data, uint8 mask) 2269 { 2270 int rv = BCM_E_UNAVAIL, tmp_rv; 2271 int i, bcm_unit; 2272 2273 BCMX_FIELD_INIT_CHECK; 2274 2275 BCMX_UNIT_ITER(bcm_unit, i) { 2276 tmp_rv = bcm_field_qualify_InnerVlanCfi(bcm_unit, entry, data, mask); 2277 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 2278 } 2279 2280 return rv; 2281 } 2282 2283 /* 2284 * Function: 2285 * bcmx_field_qualify_EtherType 2286 */ 2287 2288 int 2289 bcmx_field_qualify_EtherType(bcm_field_entry_t entry, 2290 uint16 data, uint16 mask) 2291 { 2292 int rv = BCM_E_UNAVAIL, tmp_rv; 2293 int i, bcm_unit; 2294 2295 BCMX_FIELD_INIT_CHECK; 2296 2297 BCMX_UNIT_ITER(bcm_unit, i) { 2298 tmp_rv = bcm_field_qualify_EtherType(bcm_unit, entry, data, mask); 2299 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 2300 } 2301 2302 return rv; 2303 } 2304 2305 /* 2306 * Function: 2307 * bcmx_field_qualify_IpProtocol 2308 */ 2309 2310 int 2311 bcmx_field_qualify_IpProtocol(bcm_field_entry_t entry, 2312 uint8 data, uint8 mask) 2313 { 2314 int rv = BCM_E_UNAVAIL, tmp_rv; 2315 int i, bcm_unit; 2316 2317 BCMX_FIELD_INIT_CHECK; 2318 2319 BCMX_UNIT_ITER(bcm_unit, i) { 2320 tmp_rv = bcm_field_qualify_IpProtocol(bcm_unit, entry, data, mask); 2321 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 2322 } 2323 2324 return rv; 2325 } 2326 2327 /* 2328 * Function: 2329 * bcmx_field_qualify_IpInfo 2330 */ 2331 2332 int 2333 bcmx_field_qualify_IpInfo(bcm_field_entry_t entry, 2334 uint32 data, uint32 mask) 2335 { 2336 int rv = BCM_E_UNAVAIL, tmp_rv; 2337 int i, bcm_unit; 2338 2339 BCMX_FIELD_INIT_CHECK; 2340 2341 BCMX_UNIT_ITER(bcm_unit, i) { 2342 tmp_rv = bcm_field_qualify_IpInfo(bcm_unit, entry, data, mask); 2343 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 2344 } 2345 2346 return rv; 2347 } 2348 2349 /* 2350 * Function: 2351 * bcmx_field_qualify_PacketRes 2352 */ 2353 2354 int 2355 bcmx_field_qualify_PacketRes(bcm_field_entry_t entry, 2356 uint32 data, uint32 mask) 2357 { 2358 int rv = BCM_E_UNAVAIL, tmp_rv; 2359 int i, bcm_unit; 2360 2361 BCMX_FIELD_INIT_CHECK; 2362 2363 BCMX_UNIT_ITER(bcm_unit, i) { 2364 tmp_rv = bcm_field_qualify_PacketRes(bcm_unit, entry, data, mask); 2365 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 2366 } 2367 2368 return rv; 2369 } 2370 2371 /* 2372 * Function: 2373 * bcmx_field_qualify_SrcIp 2374 */ 2375 2376 int 2377 bcmx_field_qualify_SrcIp(bcm_field_entry_t entry, 2378 bcm_ip_t data, bcm_ip_t mask) 2379 { 2380 int rv = BCM_E_UNAVAIL, tmp_rv; 2381 int i, bcm_unit; 2382 2383 BCMX_FIELD_INIT_CHECK; 2384 2385 BCMX_UNIT_ITER(bcm_unit, i) { 2386 tmp_rv = bcm_field_qualify_SrcIp(bcm_unit, entry, data, mask); 2387 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 2388 } 2389 2390 return rv; 2391 } 2392 2393 /* 2394 * Function: 2395 * bcmx_field_qualify_DstIp 2396 */ 2397 2398 int 2399 bcmx_field_qualify_DstIp(bcm_field_entry_t entry, 2400 bcm_ip_t data, bcm_ip_t mask) 2401 { 2402 int rv = BCM_E_UNAVAIL, tmp_rv; 2403 int i, bcm_unit; 2404 2405 BCMX_FIELD_INIT_CHECK; 2406 2407 BCMX_UNIT_ITER(bcm_unit, i) { 2408 tmp_rv = bcm_field_qualify_DstIp(bcm_unit, entry, data, mask); 2409 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 2410 } 2411 2412 return rv; 2413 } 2414 2415 /* 2416 * Function: 2417 * bcmx_field_qualify_DSCP 2418 */ 2419 2420 int 2421 bcmx_field_qualify_DSCP(bcm_field_entry_t entry, 2422 uint8 data, uint8 mask) 2423 { 2424 int rv = BCM_E_UNAVAIL, tmp_rv; 2425 int i, bcm_unit; 2426 2427 BCMX_FIELD_INIT_CHECK; 2428 2429 BCMX_UNIT_ITER(bcm_unit, i) { 2430 tmp_rv = bcm_field_qualify_DSCP(bcm_unit, entry, data, mask); 2431 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 2432 } 2433 2434 return rv; 2435 } 2436 2437 /* 2438 * Function: 2439 * bcmx_field_qualify_Tos 2440 */ 2441 2442 int 2443 bcmx_field_qualify_Tos(bcm_field_entry_t entry, 2444 uint8 data, uint8 mask) 2445 { 2446 int rv = BCM_E_UNAVAIL, tmp_rv; 2447 int i, bcm_unit; 2448 2449 BCMX_FIELD_INIT_CHECK; 2450 2451 BCMX_UNIT_ITER(bcm_unit, i) { 2452 tmp_rv = bcm_field_qualify_Tos(bcm_unit, entry, data, mask); 2453 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 2454 } 2455 2456 return rv; 2457 } 2458 2459 /* 2460 * Function: 2461 * bcmx_field_qualify_IpFlags 2462 */ 2463 2464 int 2465 bcmx_field_qualify_IpFlags(bcm_field_entry_t entry, 2466 uint8 data, uint8 mask) 2467 { 2468 int rv = BCM_E_UNAVAIL, tmp_rv; 2469 int i, bcm_unit; 2470 2471 BCMX_FIELD_INIT_CHECK; 2472 2473 BCMX_UNIT_ITER(bcm_unit, i) { 2474 tmp_rv = bcm_field_qualify_IpFlags(bcm_unit, entry, data, mask); 2475 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 2476 } 2477 2478 return rv; 2479 } 2480 2481 /* 2482 * Function: 2483 * bcmx_field_qualify_TcpControl 2484 */ 2485 2486 int 2487 bcmx_field_qualify_TcpControl(bcm_field_entry_t entry, 2488 uint8 data, uint8 mask) 2489 { 2490 int rv = BCM_E_UNAVAIL, tmp_rv; 2491 int i, bcm_unit; 2492 2493 BCMX_FIELD_INIT_CHECK; 2494 2495 BCMX_UNIT_ITER(bcm_unit, i) { 2496 tmp_rv = bcm_field_qualify_TcpControl(bcm_unit, entry, data, mask); 2497 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 2498 } 2499 2500 return rv; 2501 } 2502 2503 /* 2504 * Function: 2505 * bcmx_field_qualify_Ttl 2506 */ 2507 2508 int 2509 bcmx_field_qualify_Ttl(bcm_field_entry_t entry, 2510 uint8 data, uint8 mask) 2511 { 2512 int rv = BCM_E_UNAVAIL, tmp_rv; 2513 int i, bcm_unit; 2514 2515 BCMX_FIELD_INIT_CHECK; 2516 2517 BCMX_UNIT_ITER(bcm_unit, i) { 2518 tmp_rv = bcm_field_qualify_Ttl(bcm_unit, entry, data, mask); 2519 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 2520 } 2521 2522 return rv; 2523 } 2524 2525 /* 2526 * Function: 2527 * bcmx_field_qualify_RangeCheck 2528 */ 2529 2530 int 2531 bcmx_field_qualify_RangeCheck(bcm_field_entry_t entry, 2532 int range, int result) 2533 { 2534 int rv = BCM_E_UNAVAIL, tmp_rv; 2535 int i, bcm_unit; 2536 2537 BCMX_FIELD_INIT_CHECK; 2538 2539 BCMX_UNIT_ITER(bcm_unit, i) { 2540 tmp_rv = bcm_field_qualify_RangeCheck(bcm_unit, entry, range, result); 2541 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 2542 } 2543 2544 return rv; 2545 } 2546 2547 /* 2548 * Function: 2549 * bcmx_field_qualify_SrcIp6 2550 */ 2551 2552 int 2553 bcmx_field_qualify_SrcIp6(bcm_field_entry_t entry, 2554 bcm_ip6_t data, bcm_ip6_t mask) 2555 { 2556 int rv = BCM_E_UNAVAIL, tmp_rv; 2557 int i, bcm_unit; 2558 2559 BCMX_FIELD_INIT_CHECK; 2560 2561 BCMX_UNIT_ITER(bcm_unit, i) { 2562 tmp_rv = bcm_field_qualify_SrcIp6(bcm_unit, entry, data, mask); 2563 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 2564 } 2565 2566 return rv; 2567 } 2568 2569 /* 2570 * Function: 2571 * bcmx_field_qualify_DstIp6 2572 */ 2573 2574 int 2575 bcmx_field_qualify_DstIp6(bcm_field_entry_t entry, 2576 bcm_ip6_t data, bcm_ip6_t mask) 2577 { 2578 int rv = BCM_E_UNAVAIL, tmp_rv; 2579 int i, bcm_unit; 2580 2581 BCMX_FIELD_INIT_CHECK; 2582 2583 BCMX_UNIT_ITER(bcm_unit, i) { 2584 tmp_rv = bcm_field_qualify_DstIp6(bcm_unit, entry, data, mask); 2585 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 2586 } 2587 2588 return rv; 2589 } 2590 2591 /* 2592 * Function: 2593 * bcmx_field_qualify_SrcIp6High 2594 */ 2595 2596 int 2597 bcmx_field_qualify_SrcIp6High(bcm_field_entry_t entry, 2598 bcm_ip6_t data, bcm_ip6_t mask) 2599 { 2600 int rv = BCM_E_UNAVAIL, tmp_rv; 2601 int i, bcm_unit; 2602 2603 BCMX_FIELD_INIT_CHECK; 2604 2605 BCMX_UNIT_ITER(bcm_unit, i) { 2606 tmp_rv = bcm_field_qualify_SrcIp6High(bcm_unit, entry, data, mask); 2607 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 2608 } 2609 2610 return rv; 2611 } 2612 2613 /* 2614 * Function: 2615 * bcmx_field_qualify_DstIp6High 2616 */ 2617 2618 int 2619 bcmx_field_qualify_DstIp6High(bcm_field_entry_t entry, 2620 bcm_ip6_t data, bcm_ip6_t mask) 2621 { 2622 int rv = BCM_E_UNAVAIL, tmp_rv; 2623 int i, bcm_unit; 2624 2625 BCMX_FIELD_INIT_CHECK; 2626 2627 BCMX_UNIT_ITER(bcm_unit, i) { 2628 tmp_rv = bcm_field_qualify_DstIp6High(bcm_unit, entry, data, mask); 2629 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 2630 } 2631 2632 return rv; 2633 } 2634 2635 /* 2636 * Function: 2637 * bcmx_field_qualify_DstIp6Low 2638 */ 2639 2640 int 2641 bcmx_field_qualify_DstIp6Low(bcm_field_entry_t entry, 2642 bcm_ip6_t data, bcm_ip6_t mask) 2643 { 2644 int rv = BCM_E_UNAVAIL, tmp_rv; 2645 int i, bcm_unit; 2646 2647 BCMX_FIELD_INIT_CHECK; 2648 2649 BCMX_UNIT_ITER(bcm_unit, i) { 2650 tmp_rv = bcm_field_qualify_DstIp6Low(bcm_unit, entry, data, mask); 2651 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 2652 } 2653 2654 return rv; 2655 } 2656 2657 /* 2658 * Function: 2659 * bcmx_field_qualify_SrcIp6Low 2660 */ 2661 2662 int 2663 bcmx_field_qualify_SrcIp6Low(bcm_field_entry_t entry, 2664 bcm_ip6_t data, bcm_ip6_t mask) 2665 { 2666 int rv = BCM_E_UNAVAIL, tmp_rv; 2667 int i, bcm_unit; 2668 2669 BCMX_FIELD_INIT_CHECK; 2670 2671 BCMX_UNIT_ITER(bcm_unit, i) { 2672 tmp_rv = bcm_field_qualify_SrcIp6Low(bcm_unit, entry, data, mask); 2673 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 2674 } 2675 2676 return rv; 2677 } 2678 2679 /* 2680 * Function: 2681 * bcmx_field_qualify_Ip6NextHeader 2682 */ 2683 2684 int 2685 bcmx_field_qualify_Ip6NextHeader(bcm_field_entry_t entry, 2686 uint8 data, uint8 mask) 2687 { 2688 int rv = BCM_E_UNAVAIL, tmp_rv; 2689 int i, bcm_unit; 2690 2691 BCMX_FIELD_INIT_CHECK; 2692 2693 BCMX_UNIT_ITER(bcm_unit, i) { 2694 tmp_rv = bcm_field_qualify_Ip6NextHeader(bcm_unit, entry, data, mask); 2695 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 2696 } 2697 2698 return rv; 2699 } 2700 2701 /* 2702 * Function: 2703 * bcmx_field_qualify_Ip6TrafficClass 2704 */ 2705 2706 int 2707 bcmx_field_qualify_Ip6TrafficClass(bcm_field_entry_t entry, 2708 uint8 data, uint8 mask) 2709 { 2710 int rv = BCM_E_UNAVAIL, tmp_rv; 2711 int i, bcm_unit; 2712 2713 BCMX_FIELD_INIT_CHECK; 2714 2715 BCMX_UNIT_ITER(bcm_unit, i) { 2716 tmp_rv = bcm_field_qualify_Ip6TrafficClass(bcm_unit, entry, data, mask); 2717 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 2718 } 2719 2720 return rv; 2721 } 2722 2723 /* 2724 * Function: 2725 * bcmx_field_qualify_Ip6FlowLabel 2726 */ 2727 2728 int 2729 bcmx_field_qualify_Ip6FlowLabel(bcm_field_entry_t entry, 2730 uint32 data, uint32 mask) 2731 { 2732 int rv = BCM_E_UNAVAIL, tmp_rv; 2733 int i, bcm_unit; 2734 2735 BCMX_FIELD_INIT_CHECK; 2736 2737 BCMX_UNIT_ITER(bcm_unit, i) { 2738 tmp_rv = bcm_field_qualify_Ip6FlowLabel(bcm_unit, entry, data, mask); 2739 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 2740 } 2741 2742 return rv; 2743 } 2744 2745 /* 2746 * Function: 2747 * bcmx_field_qualify_Ip6HopLimit 2748 */ 2749 2750 int 2751 bcmx_field_qualify_Ip6HopLimit(bcm_field_entry_t entry, 2752 uint8 data, uint8 mask) 2753 { 2754 int rv = BCM_E_UNAVAIL, tmp_rv; 2755 int i, bcm_unit; 2756 2757 BCMX_FIELD_INIT_CHECK; 2758 2759 BCMX_UNIT_ITER(bcm_unit, i) { 2760 tmp_rv = bcm_field_qualify_Ip6HopLimit(bcm_unit, entry, data, mask); 2761 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 2762 } 2763 2764 return rv; 2765 } 2766 2767 /* 2768 * Function: 2769 * bcmx_field_qualify_SrcMac 2770 */ 2771 2772 int 2773 bcmx_field_qualify_SrcMac(bcm_field_entry_t entry, 2774 bcm_mac_t data, bcm_mac_t mask) 2775 { 2776 int rv = BCM_E_UNAVAIL, tmp_rv; 2777 int i, bcm_unit; 2778 2779 BCMX_FIELD_INIT_CHECK; 2780 2781 BCMX_UNIT_ITER(bcm_unit, i) { 2782 tmp_rv = bcm_field_qualify_SrcMac(bcm_unit, entry, data, mask); 2783 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 2784 } 2785 2786 return rv; 2787 } 2788 2789 /* 2790 * Function: 2791 * bcmx_field_qualify_DstMac 2792 */ 2793 2794 int 2795 bcmx_field_qualify_DstMac(bcm_field_entry_t entry, 2796 bcm_mac_t data, bcm_mac_t mask) 2797 { 2798 int rv = BCM_E_UNAVAIL, tmp_rv; 2799 int i, bcm_unit; 2800 2801 BCMX_FIELD_INIT_CHECK; 2802 2803 BCMX_UNIT_ITER(bcm_unit, i) { 2804 tmp_rv = bcm_field_qualify_DstMac(bcm_unit, entry, data, mask); 2805 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 2806 } 2807 2808 return rv; 2809 } 2810 2811 /* 2812 * Function: 2813 * bcmx_field_qualify_DstClassL2 2814 */ 2815 int 2816 bcmx_field_qualify_DstClassL2(bcm_field_entry_t entry, 2817 uint32 data, uint32 mask) 2818 { 2819 int rv = BCM_E_UNAVAIL, tmp_rv; 2820 int i, bcm_unit; 2821 2822 BCMX_FIELD_INIT_CHECK; 2823 2824 BCMX_UNIT_ITER(bcm_unit, i) { 2825 tmp_rv = bcm_field_qualify_DstClassL2(bcm_unit, entry, data, mask); 2826 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 2827 } 2828 2829 return rv; 2830 } 2831 2832 2833 /* 2834 * Function: 2835 * bcmx_field_qualify_DstClassL3 2836 */ 2837 int 2838 bcmx_field_qualify_DstClassL3(bcm_field_entry_t entry, 2839 uint32 data, uint32 mask) 2840 { 2841 int rv = BCM_E_UNAVAIL, tmp_rv; 2842 int i, bcm_unit; 2843 2844 BCMX_FIELD_INIT_CHECK; 2845 2846 BCMX_UNIT_ITER(bcm_unit, i) { 2847 tmp_rv = bcm_field_qualify_DstClassL3(bcm_unit, entry, data, mask); 2848 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 2849 } 2850 2851 return rv; 2852 } 2853 2854 2855 /* 2856 * Function: 2857 * bcmx_field_qualify_DstClassField 2858 */ 2859 int 2860 bcmx_field_qualify_DstClassField(bcm_field_entry_t entry, 2861 uint32 data, uint32 mask) 2862 { 2863 int rv = BCM_E_UNAVAIL, tmp_rv; 2864 int i, bcm_unit; 2865 2866 BCMX_FIELD_INIT_CHECK; 2867 2868 BCMX_UNIT_ITER(bcm_unit, i) { 2869 tmp_rv = bcm_field_qualify_DstClassField(bcm_unit, entry, data, mask); 2870 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 2871 } 2872 2873 return rv; 2874 } 2875 2876 2877 /* 2878 * Function: 2879 * bcmx_field_qualify_SrcClassL2 2880 */ 2881 int 2882 bcmx_field_qualify_SrcClassL2(bcm_field_entry_t entry, 2883 uint32 data, uint32 mask) 2884 { 2885 int rv = BCM_E_UNAVAIL, tmp_rv; 2886 int i, bcm_unit; 2887 2888 BCMX_FIELD_INIT_CHECK; 2889 2890 BCMX_UNIT_ITER(bcm_unit, i) { 2891 tmp_rv = bcm_field_qualify_SrcClassL2(bcm_unit, entry, data, mask); 2892 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 2893 } 2894 2895 return rv; 2896 } 2897 2898 2899 /* 2900 * Function: 2901 * bcmx_field_qualify_SrcClassL3 2902 */ 2903 int 2904 bcmx_field_qualify_SrcClassL3(bcm_field_entry_t entry, 2905 uint32 data, uint32 mask) 2906 { 2907 int rv = BCM_E_UNAVAIL, tmp_rv; 2908 int i, bcm_unit; 2909 2910 BCMX_FIELD_INIT_CHECK; 2911 2912 BCMX_UNIT_ITER(bcm_unit, i) { 2913 tmp_rv = bcm_field_qualify_SrcClassL3(bcm_unit, entry, data, mask); 2914 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 2915 } 2916 2917 return rv; 2918 } 2919 2920 2921 /* 2922 * Function: 2923 * bcmx_field_qualify_SrcClassField 2924 */ 2925 int 2926 bcmx_field_qualify_SrcClassField(bcm_field_entry_t entry, 2927 uint32 data, uint32 mask) 2928 { 2929 int rv = BCM_E_UNAVAIL, tmp_rv; 2930 int i, bcm_unit; 2931 2932 BCMX_FIELD_INIT_CHECK; 2933 2934 BCMX_UNIT_ITER(bcm_unit, i) { 2935 tmp_rv = bcm_field_qualify_SrcClassField(bcm_unit, entry, data, mask); 2936 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 2937 } 2938 2939 return rv; 2940 } 2941 2942 /* 2943 * Function: 2944 * bcmx_field_qualify_IpType 2945 */ 2946 2947 int 2948 bcmx_field_qualify_IpType(bcm_field_entry_t entry, 2949 bcm_field_IpType_t type) 2950 { 2951 int rv = BCM_E_UNAVAIL, tmp_rv; 2952 int i, bcm_unit; 2953 2954 BCMX_FIELD_INIT_CHECK; 2955 2956 BCMX_UNIT_ITER(bcm_unit, i) { 2957 tmp_rv = bcm_field_qualify_IpType(bcm_unit, entry, type); 2958 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 2959 } 2960 2961 return rv; 2962 } 2963 2964 /* 2965 * Function: 2966 * bcmx_field_qualify_InnerIpType 2967 */ 2968 2969 int 2970 bcmx_field_qualify_InnerIpType(bcm_field_entry_t entry, 2971 bcm_field_IpType_t type) 2972 { 2973 int rv = BCM_E_UNAVAIL, tmp_rv; 2974 int i, bcm_unit; 2975 2976 BCMX_FIELD_INIT_CHECK; 2977 2978 BCMX_UNIT_ITER(bcm_unit, i) { 2979 tmp_rv = bcm_field_qualify_InnerIpType(bcm_unit, entry, type); 2980 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 2981 } 2982 2983 return rv; 2984 } 2985 2986 /* 2987 * Function: 2988 * bcmx_field_qualify_ForwardingType 2989 */ 2990 2991 int 2992 bcmx_field_qualify_ForwardingType(bcm_field_entry_t entry, 2993 bcm_field_ForwardingType_t type) 2994 { 2995 int rv = BCM_E_UNAVAIL, tmp_rv; 2996 int i, bcm_unit; 2997 2998 BCMX_FIELD_INIT_CHECK; 2999 3000 BCMX_UNIT_ITER(bcm_unit, i) { 3001 tmp_rv = bcm_field_qualify_ForwardingType(bcm_unit, entry, type); 3002 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 3003 } 3004 3005 return rv; 3006 } 3007 3008 /* 3009 * Function: 3010 * bcmx_field_qualify_L2Format 3011 */ 3012 3013 int 3014 bcmx_field_qualify_L2Format(bcm_field_entry_t entry, 3015 bcm_field_L2Format_t type) 3016 { 3017 int rv = BCM_E_UNAVAIL, tmp_rv; 3018 int i, bcm_unit; 3019 3020 BCMX_FIELD_INIT_CHECK; 3021 3022 BCMX_UNIT_ITER(bcm_unit, i) { 3023 tmp_rv = bcm_field_qualify_L2Format(bcm_unit, entry, type); 3024 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 3025 } 3026 3027 return rv; 3028 } 3029 3030 /* 3031 * Function: 3032 * bcmx_field_qualify_VlanFormat 3033 */ 3034 3035 int 3036 bcmx_field_qualify_VlanFormat(bcm_field_entry_t entry, 3037 uint8 data, uint8 mask) 3038 { 3039 int rv = BCM_E_UNAVAIL, tmp_rv; 3040 int i, bcm_unit; 3041 3042 BCMX_FIELD_INIT_CHECK; 3043 3044 BCMX_UNIT_ITER(bcm_unit, i) { 3045 tmp_rv = bcm_field_qualify_VlanFormat(bcm_unit, entry, data, mask); 3046 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 3047 } 3048 3049 return rv; 3050 } 3051 3052 /* 3053 * Function: 3054 * bcmx_field_qualify_TranslatedVlanFormat 3055 */ 3056 3057 int 3058 bcmx_field_qualify_TranslatedVlanFormat(bcm_field_entry_t entry, 3059 uint8 data, uint8 mask) 3060 { 3061 int rv = BCM_E_UNAVAIL, tmp_rv; 3062 int i, bcm_unit; 3063 3064 BCMX_FIELD_INIT_CHECK; 3065 3066 BCMX_UNIT_ITER(bcm_unit, i) { 3067 tmp_rv = bcm_field_qualify_TranslatedVlanFormat(bcm_unit, entry, data, mask); 3068 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 3069 } 3070 3071 return rv; 3072 } 3073 3074 /* 3075 * Function: 3076 * bcmx_field_qualify_MHOpcode 3077 */ 3078 3079 int 3080 bcmx_field_qualify_MHOpcode(bcm_field_entry_t entry, 3081 uint8 data, uint8 mask) 3082 { 3083 int rv = BCM_E_UNAVAIL, tmp_rv; 3084 int i, bcm_unit; 3085 3086 BCMX_FIELD_INIT_CHECK; 3087 3088 BCMX_UNIT_ITER(bcm_unit, i) { 3089 tmp_rv = bcm_field_qualify_MHOpcode(bcm_unit, entry, data, mask); 3090 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 3091 } 3092 3093 return rv; 3094 } 3095 3096 /* 3097 * Function: 3098 * bcmx_field_qualify_Decap 3099 */ 3100 3101 int 3102 bcmx_field_qualify_Decap(bcm_field_entry_t entry, 3103 bcm_field_decap_t decap) 3104 { 3105 int rv = BCM_E_UNAVAIL, tmp_rv; 3106 int i, bcm_unit; 3107 3108 BCMX_FIELD_INIT_CHECK; 3109 3110 BCMX_UNIT_ITER(bcm_unit, i) { 3111 tmp_rv = bcm_field_qualify_Decap(bcm_unit, entry, decap); 3112 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 3113 } 3114 3115 return rv; 3116 } 3117 3118 /* 3119 * Function: 3120 * bcmx_field_qualify_HiGig 3121 */ 3122 3123 int 3124 bcmx_field_qualify_HiGig(bcm_field_entry_t entry, 3125 uint8 data, uint8 mask) 3126 { 3127 int rv = BCM_E_UNAVAIL, tmp_rv; 3128 int i, bcm_unit; 3129 3130 BCMX_FIELD_INIT_CHECK; 3131 3132 BCMX_UNIT_ITER(bcm_unit, i) { 3133 tmp_rv = bcm_field_qualify_HiGig(bcm_unit, entry, data, mask); 3134 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 3135 } 3136 3137 return rv; 3138 } 3139 3140 /* 3141 * Function: 3142 * bcmx_field_qualify_DstHiGig 3143 * Purpose: 3144 * Qualify on packets destined to higig port. 3145 * Parameters: 3146 * entry - (IN) BCM field entry id. 3147 * data - (IN) Qualifier match data. 3148 * mask - (IN) Qualifier match mask. 3149 * Returns: 3150 * BCM_E_XXX 3151 * Notes: 3152 */ 3153 int 3154 bcmx_field_qualify_DstHiGig(bcm_field_entry_t entry, 3155 uint8 data, uint8 mask) 3156 { 3157 int rv = BCM_E_UNAVAIL, tmp_rv; 3158 int i, bcm_unit; 3159 3160 BCMX_FIELD_INIT_CHECK; 3161 3162 BCMX_UNIT_ITER(bcm_unit, i) { 3163 tmp_rv = bcm_field_qualify_DstHiGig(bcm_unit, entry, data, mask); 3164 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 3165 } 3166 3167 return rv; 3168 } 3169 3170 /* 3171 * Function: 3172 * bcmx_field_qualify_InterfaceClassL2 3173 */ 3174 int 3175 bcmx_field_qualify_InterfaceClassL2(bcm_field_entry_t entry, 3176 uint32 data, uint32 mask) 3177 { 3178 int rv = BCM_E_UNAVAIL, tmp_rv; 3179 int i, bcm_unit; 3180 3181 BCMX_FIELD_INIT_CHECK; 3182 3183 BCMX_UNIT_ITER(bcm_unit, i) { 3184 tmp_rv = bcm_field_qualify_InterfaceClassL2(bcm_unit, entry, data, mask); 3185 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 3186 } 3187 3188 return rv; 3189 } 3190 3191 /* 3192 * Function: 3193 * bcmx_field_qualify_InterfaceClassL3 3194 */ 3195 int 3196 bcmx_field_qualify_InterfaceClassL3(bcm_field_entry_t entry, 3197 uint32 data, uint32 mask) 3198 { 3199 int rv = BCM_E_UNAVAIL, tmp_rv; 3200 int i, bcm_unit; 3201 3202 BCMX_FIELD_INIT_CHECK; 3203 3204 BCMX_UNIT_ITER(bcm_unit, i) { 3205 tmp_rv = bcm_field_qualify_InterfaceClassL3(bcm_unit, entry, data, mask); 3206 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 3207 } 3208 3209 return rv; 3210 } 3211 3212 3213 /* 3214 * Function: 3215 * bcmx_field_qualify_InterfaceClassPort 3216 */ 3217 int 3218 bcmx_field_qualify_InterfaceClassPort(bcm_field_entry_t entry, 3219 uint32 data, uint32 mask) 3220 { 3221 int rv = BCM_E_UNAVAIL, tmp_rv; 3222 int i, bcm_unit; 3223 3224 BCMX_FIELD_INIT_CHECK; 3225 3226 BCMX_UNIT_ITER(bcm_unit, i) { 3227 tmp_rv = bcm_field_qualify_InterfaceClassPort(bcm_unit, entry, data, mask); 3228 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 3229 } 3230 3231 return rv; 3232 } 3233 3234 /* 3235 * Function: 3236 * bcmx_field_qualify_IpProtocolCommon 3237 */ 3238 int 3239 bcmx_field_qualify_IpProtocolCommon(bcm_field_entry_t entry, 3240 bcm_field_IpProtocolCommon_t protocol) 3241 { 3242 int rv = BCM_E_UNAVAIL, tmp_rv; 3243 int i, bcm_unit; 3244 3245 BCMX_FIELD_INIT_CHECK; 3246 3247 BCMX_UNIT_ITER(bcm_unit, i) { 3248 tmp_rv = bcm_field_qualify_IpProtocolCommon(bcm_unit, entry, 3249 protocol); 3250 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 3251 } 3252 3253 return rv; 3254 } 3255 3256 /* 3257 * Function: 3258 * bcmx_field_qualify_InnerIpProtocolCommon 3259 */ 3260 int 3261 bcmx_field_qualify_InnerIpProtocolCommon(bcm_field_entry_t entry, 3262 bcm_field_IpProtocolCommon_t protocol) 3263 { 3264 int rv = BCM_E_UNAVAIL, tmp_rv; 3265 int i, bcm_unit; 3266 3267 BCMX_FIELD_INIT_CHECK; 3268 3269 BCMX_UNIT_ITER(bcm_unit, i) { 3270 tmp_rv = bcm_field_qualify_InnerIpProtocolCommon(bcm_unit, entry, 3271 protocol); 3272 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 3273 } 3274 3275 return rv; 3276 } 3277 3278 /* 3279 * Function: 3280 * bcmx_field_qualify_Snap 3281 */ 3282 int 3283 bcmx_field_qualify_Snap(bcm_field_entry_t entry, 3284 bcm_field_snap_header_t data, 3285 bcm_field_snap_header_t mask) 3286 { 3287 int rv = BCM_E_UNAVAIL, tmp_rv; 3288 int i, bcm_unit; 3289 3290 BCMX_FIELD_INIT_CHECK; 3291 3292 BCMX_UNIT_ITER(bcm_unit, i) { 3293 tmp_rv = bcm_field_qualify_Snap(bcm_unit, entry, data, mask); 3294 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 3295 } 3296 3297 return rv; 3298 } 3299 3300 /* 3301 * Function: 3302 * bcmx_field_qualify_Llc 3303 */ 3304 int 3305 bcmx_field_qualify_Llc(bcm_field_entry_t entry, 3306 bcm_field_llc_header_t data, 3307 bcm_field_llc_header_t mask) 3308 { 3309 int rv = BCM_E_UNAVAIL, tmp_rv; 3310 int i, bcm_unit; 3311 3312 BCMX_FIELD_INIT_CHECK; 3313 3314 BCMX_UNIT_ITER(bcm_unit, i) { 3315 tmp_rv = bcm_field_qualify_Llc(bcm_unit, entry, data, mask); 3316 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 3317 } 3318 3319 return rv; 3320 } 3321 3322 /* 3323 * Function: 3324 * bcmx_field_qualify_InnerTpid 3325 */ 3326 int 3327 bcmx_field_qualify_InnerTpid(bcm_field_entry_t entry, 3328 uint16 tpid) 3329 { 3330 int rv = BCM_E_UNAVAIL, tmp_rv; 3331 int i, bcm_unit; 3332 3333 BCMX_FIELD_INIT_CHECK; 3334 3335 BCMX_UNIT_ITER(bcm_unit, i) { 3336 tmp_rv = bcm_field_qualify_InnerTpid(bcm_unit, entry, tpid); 3337 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 3338 } 3339 3340 return rv; 3341 } 3342 3343 /* 3344 * Function: 3345 * bcmx_field_qualify_OuterTpid 3346 */ 3347 int 3348 bcmx_field_qualify_OuterTpid(bcm_field_entry_t entry, 3349 uint16 tpid) 3350 { 3351 int rv = BCM_E_UNAVAIL, tmp_rv; 3352 int i, bcm_unit; 3353 3354 BCMX_FIELD_INIT_CHECK; 3355 3356 BCMX_UNIT_ITER(bcm_unit, i) { 3357 tmp_rv = bcm_field_qualify_OuterTpid(bcm_unit, entry, tpid); 3358 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 3359 } 3360 3361 return rv; 3362 } 3363 3364 /* 3365 * Function: 3366 * bcmx_field_qualify_L3Routable 3367 */ 3368 int 3369 bcmx_field_qualify_L3Routable(bcm_field_entry_t entry, 3370 uint8 data, uint8 mask) 3371 { 3372 int rv = BCM_E_UNAVAIL, tmp_rv; 3373 int i, bcm_unit; 3374 3375 BCMX_FIELD_INIT_CHECK; 3376 3377 BCMX_UNIT_ITER(bcm_unit, i) { 3378 tmp_rv = bcm_field_qualify_L3Routable(bcm_unit, entry, data, mask); 3379 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 3380 } 3381 3382 return rv; 3383 } 3384 3385 /* 3386 * Function: 3387 * bcmx_field_qualify_IpFrag 3388 */ 3389 int bcmx_field_qualify_IpFrag(bcm_field_entry_t entry, 3390 bcm_field_IpFrag_t frag_info) 3391 { 3392 int rv = BCM_E_UNAVAIL, tmp_rv; 3393 int i, bcm_unit; 3394 3395 BCMX_FIELD_INIT_CHECK; 3396 3397 BCMX_UNIT_ITER(bcm_unit, i) { 3398 tmp_rv = bcm_field_qualify_IpFrag(bcm_unit, entry, frag_info); 3399 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 3400 } 3401 3402 return rv; 3403 } 3404 3405 /* 3406 * Function: 3407 * bcmx_field_qualify_Vrf 3408 */ 3409 int 3410 bcmx_field_qualify_Vrf(bcm_field_entry_t entry, 3411 uint32 data, uint32 mask) 3412 { 3413 int rv = BCM_E_UNAVAIL, tmp_rv; 3414 int i, bcm_unit; 3415 3416 BCMX_FIELD_INIT_CHECK; 3417 3418 BCMX_UNIT_ITER(bcm_unit, i) { 3419 tmp_rv = bcm_field_qualify_Vrf(bcm_unit, entry, data, mask); 3420 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 3421 } 3422 3423 return rv; 3424 } 3425 3426 /* 3427 * Function: 3428 * bcmx_field_qualify_L3Ingress 3429 */ 3430 int 3431 bcmx_field_qualify_L3Ingress(bcm_field_entry_t entry, 3432 uint32 data, uint32 mask) 3433 { 3434 int rv = BCM_E_UNAVAIL, tmp_rv; 3435 int i, bcm_unit; 3436 3437 BCMX_FIELD_INIT_CHECK; 3438 3439 BCMX_UNIT_ITER(bcm_unit, i) { 3440 tmp_rv = bcm_field_qualify_L3Ingress(bcm_unit, entry, data, mask); 3441 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 3442 } 3443 3444 return rv; 3445 } 3446 3447 /* 3448 * Function: 3449 * bcmx_field_qualify_Vpn 3450 */ 3451 int 3452 bcmx_field_qualify_Vpn(bcm_field_entry_t entry, 3453 bcm_vpn_t data, bcm_vpn_t mask) 3454 { 3455 int rv = BCM_E_UNAVAIL, tmp_rv; 3456 int i, bcm_unit; 3457 3458 BCMX_FIELD_INIT_CHECK; 3459 3460 BCMX_UNIT_ITER(bcm_unit, i) { 3461 tmp_rv = bcm_field_qualify_Vpn(bcm_unit, entry, data, mask); 3462 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 3463 } 3464 3465 return rv; 3466 } 3467 3468 /* 3469 * Function: 3470 * bcmx_field_qualify_ExtensionHeaderType 3471 */ 3472 int 3473 bcmx_field_qualify_ExtensionHeaderType(bcm_field_entry_t entry, 3474 uint8 data, uint8 mask) 3475 { 3476 int rv = BCM_E_UNAVAIL, tmp_rv; 3477 int i, bcm_unit; 3478 3479 BCMX_FIELD_INIT_CHECK; 3480 3481 BCMX_UNIT_ITER(bcm_unit, i) { 3482 tmp_rv = bcm_field_qualify_ExtensionHeaderType(bcm_unit, entry, 3483 data, mask); 3484 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 3485 } 3486 3487 return rv; 3488 } 3489 3490 /* 3491 * Function: 3492 * bcmx_field_qualify_ExtensionHeaderSubCode 3493 */ 3494 int 3495 bcmx_field_qualify_ExtensionHeaderSubCode(bcm_field_entry_t entry, 3496 uint8 data, uint8 mask) 3497 { 3498 int rv = BCM_E_UNAVAIL, tmp_rv; 3499 int i, bcm_unit; 3500 3501 BCMX_FIELD_INIT_CHECK; 3502 3503 BCMX_UNIT_ITER(bcm_unit, i) { 3504 tmp_rv = bcm_field_qualify_ExtensionHeaderSubCode(bcm_unit, entry, 3505 data, mask); 3506 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 3507 } 3508 3509 return rv; 3510 } 3511 3512 /* 3513 * Function: 3514 * bcmx_field_qualify_ExtensionHeader2Type 3515 */ 3516 int 3517 bcmx_field_qualify_ExtensionHeader2Type(bcm_field_entry_t entry, 3518 uint8 data, uint8 mask) 3519 { 3520 int rv = BCM_E_UNAVAIL, tmp_rv; 3521 int i, bcm_unit; 3522 3523 BCMX_FIELD_INIT_CHECK; 3524 3525 BCMX_UNIT_ITER(bcm_unit, i) { 3526 tmp_rv = bcm_field_qualify_ExtensionHeader2Type(bcm_unit, entry, 3527 data, mask); 3528 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 3529 } 3530 3531 return rv; 3532 } 3533 3534 /* 3535 * Function: 3536 * bcmx_field_qualify_L4Ports 3537 */ 3538 int bcmx_field_qualify_L4Ports(bcm_field_entry_t entry, 3539 uint8 data, uint8 mask) 3540 { 3541 int rv = BCM_E_UNAVAIL, tmp_rv; 3542 int i, bcm_unit; 3543 3544 BCMX_FIELD_INIT_CHECK; 3545 3546 BCMX_UNIT_ITER(bcm_unit, i) { 3547 tmp_rv = bcm_field_qualify_L4Ports(bcm_unit, entry, data, mask); 3548 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 3549 } 3550 3551 return rv; 3552 } 3553 3554 /* 3555 * Function: 3556 * bcmx_field_qualify_MirrorCopy 3557 */ 3558 int 3559 bcmx_field_qualify_MirrorCopy(bcm_field_entry_t entry, 3560 uint8 data, uint8 mask) 3561 { 3562 int rv = BCM_E_UNAVAIL, tmp_rv; 3563 int i, bcm_unit; 3564 3565 BCMX_FIELD_INIT_CHECK; 3566 3567 BCMX_UNIT_ITER(bcm_unit, i) { 3568 tmp_rv = bcm_field_qualify_MirrorCopy(bcm_unit, entry, data, mask); 3569 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 3570 } 3571 3572 return rv; 3573 } 3574 3575 /* 3576 * Function: 3577 * bcmx_field_qualify_TunnelTerminated 3578 */ 3579 int 3580 bcmx_field_qualify_TunnelTerminated(bcm_field_entry_t entry, 3581 uint8 data, uint8 mask) 3582 { 3583 int rv = BCM_E_UNAVAIL, tmp_rv; 3584 int i, bcm_unit; 3585 3586 BCMX_FIELD_INIT_CHECK; 3587 3588 BCMX_UNIT_ITER(bcm_unit, i) { 3589 tmp_rv = bcm_field_qualify_TunnelTerminated(bcm_unit, entry, 3590 data, mask); 3591 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 3592 } 3593 3594 return rv; 3595 } 3596 3597 /* 3598 * Function: 3599 * bcmx_field_qualify_MplsTerminated 3600 */ 3601 int 3602 bcmx_field_qualify_MplsTerminated(bcm_field_entry_t entry, 3603 uint8 data, uint8 mask) 3604 { 3605 int rv = BCM_E_UNAVAIL, tmp_rv; 3606 int i, bcm_unit; 3607 3608 BCMX_FIELD_INIT_CHECK; 3609 3610 BCMX_UNIT_ITER(bcm_unit, i) { 3611 tmp_rv = bcm_field_qualify_MplsTerminated(bcm_unit, entry, 3612 data, mask); 3613 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 3614 } 3615 3616 return rv; 3617 } 3618 3619 /* 3620 * Function: 3621 * bcmx_field_qualify_InnerSrcIp 3622 */ 3623 int 3624 bcmx_field_qualify_InnerSrcIp(bcm_field_entry_t entry, 3625 bcm_ip_t data, bcm_ip_t mask) 3626 { 3627 int rv = BCM_E_UNAVAIL, tmp_rv; 3628 int i, bcm_unit; 3629 3630 BCMX_FIELD_INIT_CHECK; 3631 3632 BCMX_UNIT_ITER(bcm_unit, i) { 3633 tmp_rv = bcm_field_qualify_InnerSrcIp(bcm_unit, entry, data, mask); 3634 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 3635 } 3636 3637 return rv; 3638 } 3639 3640 /* 3641 * Function: 3642 * bcmx_field_qualify_InnerDstIp 3643 */ 3644 int 3645 bcmx_field_qualify_InnerDstIp(bcm_field_entry_t entry, 3646 bcm_ip_t data, bcm_ip_t mask) 3647 { 3648 int rv = BCM_E_UNAVAIL, tmp_rv; 3649 int i, bcm_unit; 3650 3651 BCMX_FIELD_INIT_CHECK; 3652 3653 BCMX_UNIT_ITER(bcm_unit, i) { 3654 tmp_rv = bcm_field_qualify_InnerDstIp(bcm_unit, entry, data, mask); 3655 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 3656 } 3657 3658 return rv; 3659 } 3660 3661 /* 3662 * Function: 3663 * bcmx_field_qualify_InnerSrcIp6 3664 */ 3665 int 3666 bcmx_field_qualify_InnerSrcIp6(bcm_field_entry_t entry, 3667 bcm_ip6_t data, bcm_ip6_t mask) 3668 { 3669 int rv = BCM_E_UNAVAIL, tmp_rv; 3670 int i, bcm_unit; 3671 3672 BCMX_FIELD_INIT_CHECK; 3673 3674 BCMX_UNIT_ITER(bcm_unit, i) { 3675 tmp_rv = bcm_field_qualify_InnerSrcIp6(bcm_unit, entry, data, mask); 3676 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 3677 } 3678 3679 return rv; 3680 } 3681 3682 /* 3683 * Function: 3684 * bcmx_field_qualify_InnerDstIp6 3685 */ 3686 int bcmx_field_qualify_InnerDstIp6(bcm_field_entry_t entry, 3687 bcm_ip6_t data, bcm_ip6_t mask) 3688 { 3689 int rv = BCM_E_UNAVAIL, tmp_rv; 3690 int i, bcm_unit; 3691 3692 BCMX_FIELD_INIT_CHECK; 3693 3694 BCMX_UNIT_ITER(bcm_unit, i) { 3695 tmp_rv = bcm_field_qualify_InnerDstIp6(bcm_unit, entry, data, mask); 3696 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 3697 } 3698 3699 return rv; 3700 } 3701 3702 /* 3703 * Function: 3704 * bcmx_field_qualify_InnerSrcIp6High 3705 */ 3706 int 3707 bcmx_field_qualify_InnerSrcIp6High(bcm_field_entry_t entry, 3708 bcm_ip6_t data, bcm_ip6_t mask) 3709 { 3710 int rv = BCM_E_UNAVAIL, tmp_rv; 3711 int i, bcm_unit; 3712 3713 BCMX_FIELD_INIT_CHECK; 3714 3715 BCMX_UNIT_ITER(bcm_unit, i) { 3716 tmp_rv = bcm_field_qualify_InnerSrcIp6High(bcm_unit, entry, 3717 data, mask); 3718 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 3719 } 3720 3721 return rv; 3722 } 3723 3724 /* 3725 * Function: 3726 * bcmx_field_qualify_InnerDstIp6High 3727 */ 3728 int 3729 bcmx_field_qualify_InnerDstIp6High(bcm_field_entry_t entry, 3730 bcm_ip6_t data, bcm_ip6_t mask) 3731 { 3732 int rv = BCM_E_UNAVAIL, tmp_rv; 3733 int i, bcm_unit; 3734 3735 BCMX_FIELD_INIT_CHECK; 3736 3737 BCMX_UNIT_ITER(bcm_unit, i) { 3738 tmp_rv = bcm_field_qualify_InnerDstIp6High(bcm_unit, entry, 3739 data, mask); 3740 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 3741 } 3742 3743 return rv; 3744 } 3745 3746 /* 3747 * Function: 3748 * bcmx_field_qualify_InnerTtl 3749 */ 3750 int 3751 bcmx_field_qualify_InnerTtl(bcm_field_entry_t entry, 3752 uint8 data, uint8 mask) 3753 { 3754 int rv = BCM_E_UNAVAIL, tmp_rv; 3755 int i, bcm_unit; 3756 3757 BCMX_FIELD_INIT_CHECK; 3758 3759 BCMX_UNIT_ITER(bcm_unit, i) { 3760 tmp_rv = bcm_field_qualify_InnerTtl(bcm_unit, entry, data, mask); 3761 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 3762 } 3763 3764 return rv; 3765 } 3766 3767 /* 3768 * Function: 3769 * bcmx_field_qualify_InnerTos 3770 */ 3771 int 3772 bcmx_field_qualify_InnerTos(bcm_field_entry_t entry, 3773 uint8 data, uint8 mask) 3774 { 3775 int rv = BCM_E_UNAVAIL, tmp_rv; 3776 int i, bcm_unit; 3777 3778 BCMX_FIELD_INIT_CHECK; 3779 3780 BCMX_UNIT_ITER(bcm_unit, i) { 3781 tmp_rv = bcm_field_qualify_InnerTos(bcm_unit, entry, data, mask); 3782 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 3783 } 3784 3785 return rv; 3786 } 3787 3788 /* 3789 * Function: 3790 * bcmx_field_qualify_InnerDSCP 3791 */ 3792 int 3793 bcmx_field_qualify_InnerDSCP(bcm_field_entry_t entry, 3794 uint8 data, uint8 mask) 3795 { 3796 int rv = BCM_E_UNAVAIL, tmp_rv; 3797 int i, bcm_unit; 3798 3799 BCMX_FIELD_INIT_CHECK; 3800 3801 BCMX_UNIT_ITER(bcm_unit, i) { 3802 tmp_rv = bcm_field_qualify_InnerDSCP(bcm_unit, entry, data, mask); 3803 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 3804 } 3805 3806 return rv; 3807 } 3808 3809 /* 3810 * Function: 3811 * bcmx_field_qualify_InnerIpProtocol 3812 */ 3813 int 3814 bcmx_field_qualify_InnerIpProtocol(bcm_field_entry_t entry, 3815 uint8 data, uint8 mask) 3816 { 3817 int rv = BCM_E_UNAVAIL, tmp_rv; 3818 int i, bcm_unit; 3819 3820 BCMX_FIELD_INIT_CHECK; 3821 3822 BCMX_UNIT_ITER(bcm_unit, i) { 3823 tmp_rv = bcm_field_qualify_InnerIpProtocol(bcm_unit, entry, 3824 data, mask); 3825 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 3826 } 3827 3828 return rv; 3829 } 3830 3831 /* 3832 * Function: 3833 * bcmx_field_qualify_InnerIpFrag 3834 */ 3835 int 3836 bcmx_field_qualify_InnerIpFrag(bcm_field_entry_t entry, 3837 bcm_field_IpFrag_t frag_info) 3838 { 3839 int rv = BCM_E_UNAVAIL, tmp_rv; 3840 int i, bcm_unit; 3841 3842 BCMX_FIELD_INIT_CHECK; 3843 3844 BCMX_UNIT_ITER(bcm_unit, i) { 3845 tmp_rv = bcm_field_qualify_InnerIpFrag(bcm_unit, entry, frag_info); 3846 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 3847 } 3848 3849 return rv; 3850 } 3851 3852 /* 3853 * Function: 3854 * bcmx_field_qualify_DosAttack 3855 */ 3856 int 3857 bcmx_field_qualify_DosAttack(bcm_field_entry_t entry, 3858 uint8 data, uint8 mask) 3859 { 3860 int rv = BCM_E_UNAVAIL, tmp_rv; 3861 int i, bcm_unit; 3862 3863 BCMX_FIELD_INIT_CHECK; 3864 3865 BCMX_UNIT_ITER(bcm_unit, i) { 3866 tmp_rv = bcm_field_qualify_DosAttack(bcm_unit, entry, data, mask); 3867 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 3868 } 3869 3870 return rv; 3871 } 3872 3873 /* 3874 * Function: 3875 * bcmx_field_qualify_IpmcStarGroupHit 3876 */ 3877 int 3878 bcmx_field_qualify_IpmcStarGroupHit(bcm_field_entry_t entry, 3879 uint8 data, uint8 mask) 3880 { 3881 int rv = BCM_E_UNAVAIL, tmp_rv; 3882 int i, bcm_unit; 3883 3884 BCMX_FIELD_INIT_CHECK; 3885 3886 BCMX_UNIT_ITER(bcm_unit, i) { 3887 tmp_rv = bcm_field_qualify_IpmcStarGroupHit(bcm_unit, entry, 3888 data, mask); 3889 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 3890 } 3891 3892 return rv; 3893 } 3894 3895 /* 3896 * Function: 3897 * bcmx_field_qualify_MyStationHit 3898 */ 3899 int 3900 bcmx_field_qualify_MyStationHit(bcm_field_entry_t entry, 3901 uint8 data, uint8 mask) 3902 { 3903 int rv = BCM_E_UNAVAIL, tmp_rv; 3904 int i, bcm_unit; 3905 3906 BCMX_FIELD_INIT_CHECK; 3907 3908 BCMX_UNIT_ITER(bcm_unit, i) { 3909 tmp_rv = bcm_field_qualify_MyStationHit(bcm_unit, entry, 3910 data, mask); 3911 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 3912 } 3913 3914 return rv; 3915 } 3916 3917 /* 3918 * Function: 3919 * bcmx_field_qualify_L2PayloadFirstEightBytes 3920 */ 3921 int 3922 bcmx_field_qualify_L2PayloadFirstEightBytes(bcm_field_entry_t entry, 3923 uint32 data1, uint32 data2, 3924 uint32 mask1, uint32 mask2) 3925 { 3926 int rv = BCM_E_UNAVAIL, tmp_rv; 3927 int i, bcm_unit; 3928 3929 BCMX_FIELD_INIT_CHECK; 3930 3931 BCMX_UNIT_ITER(bcm_unit, i) { 3932 tmp_rv = bcm_field_qualify_L2PayloadFirstEightBytes(bcm_unit, entry, 3933 data1, data2, 3934 mask1, mask2); 3935 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 3936 } 3937 3938 return rv; 3939 } 3940 3941 /* 3942 * Function: 3943 * bcmx_field_qualify_L3DestRouteHit 3944 */ 3945 int 3946 bcmx_field_qualify_L3DestRouteHit(bcm_field_entry_t entry, 3947 uint8 data, uint8 mask) 3948 { 3949 int rv = BCM_E_UNAVAIL, tmp_rv; 3950 int i, bcm_unit; 3951 3952 BCMX_FIELD_INIT_CHECK; 3953 3954 BCMX_UNIT_ITER(bcm_unit, i) { 3955 tmp_rv = bcm_field_qualify_L3DestRouteHit(bcm_unit, entry, 3956 data, mask); 3957 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 3958 } 3959 3960 return rv; 3961 } 3962 3963 /* 3964 * Function: 3965 * bcmx_field_qualify_L3DestHostHit 3966 */ 3967 int 3968 bcmx_field_qualify_L3DestHostHit(bcm_field_entry_t entry, 3969 uint8 data, uint8 mask) 3970 { 3971 int rv = BCM_E_UNAVAIL, tmp_rv; 3972 int i, bcm_unit; 3973 3974 BCMX_FIELD_INIT_CHECK; 3975 3976 BCMX_UNIT_ITER(bcm_unit, i) { 3977 tmp_rv = bcm_field_qualify_L3DestHostHit(bcm_unit, entry, 3978 data, mask); 3979 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 3980 } 3981 3982 return rv; 3983 } 3984 3985 /* 3986 * Function: 3987 * bcmx_field_qualify_L3SrcHostHit 3988 */ 3989 int 3990 bcmx_field_qualify_L3SrcHostHit(bcm_field_entry_t entry, 3991 uint8 data, uint8 mask) 3992 { 3993 int rv = BCM_E_UNAVAIL, tmp_rv; 3994 int i, bcm_unit; 3995 3996 BCMX_FIELD_INIT_CHECK; 3997 3998 BCMX_UNIT_ITER(bcm_unit, i) { 3999 tmp_rv = bcm_field_qualify_L3SrcHostHit(bcm_unit, entry, 4000 data, mask); 4001 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 4002 } 4003 4004 return rv; 4005 } 4006 4007 /* 4008 * Function: 4009 * bcmx_field_qualify_L2CacheHit 4010 */ 4011 int 4012 bcmx_field_qualify_L2CacheHit(bcm_field_entry_t entry, 4013 uint8 data, uint8 mask) 4014 { 4015 int rv = BCM_E_UNAVAIL, tmp_rv; 4016 int i, bcm_unit; 4017 4018 BCMX_FIELD_INIT_CHECK; 4019 4020 BCMX_UNIT_ITER(bcm_unit, i) { 4021 tmp_rv = bcm_field_qualify_L2CacheHit(bcm_unit, entry, data, mask); 4022 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 4023 } 4024 4025 return rv; 4026 } 4027 4028 /* 4029 * Function: 4030 * bcmx_field_qualify_L2StationMove 4031 */ 4032 int 4033 bcmx_field_qualify_L2StationMove(bcm_field_entry_t entry, 4034 uint8 data, uint8 mask) 4035 { 4036 int rv = BCM_E_UNAVAIL, tmp_rv; 4037 int i, bcm_unit; 4038 4039 BCMX_FIELD_INIT_CHECK; 4040 4041 BCMX_UNIT_ITER(bcm_unit, i) { 4042 tmp_rv = bcm_field_qualify_L2StationMove(bcm_unit, entry, data, mask); 4043 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 4044 } 4045 4046 return rv; 4047 } 4048 4049 /* 4050 * Function: 4051 * bcmx_field_qualify_L2DestHit 4052 */ 4053 int 4054 bcmx_field_qualify_L2DestHit(bcm_field_entry_t entry, 4055 uint8 data, uint8 mask) 4056 { 4057 int rv = BCM_E_UNAVAIL, tmp_rv; 4058 int i, bcm_unit; 4059 4060 BCMX_FIELD_INIT_CHECK; 4061 4062 BCMX_UNIT_ITER(bcm_unit, i) { 4063 tmp_rv = bcm_field_qualify_L2DestHit(bcm_unit, entry, data, mask); 4064 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 4065 } 4066 4067 return rv; 4068 } 4069 4070 /* 4071 * Function: 4072 * bcmx_field_qualify_L2SrcStatic 4073 */ 4074 int 4075 bcmx_field_qualify_L2SrcStatic(bcm_field_entry_t entry, 4076 uint8 data, uint8 mask) 4077 { 4078 int rv = BCM_E_UNAVAIL, tmp_rv; 4079 int i, bcm_unit; 4080 4081 BCMX_FIELD_INIT_CHECK; 4082 4083 BCMX_UNIT_ITER(bcm_unit, i) { 4084 tmp_rv = bcm_field_qualify_L2SrcStatic(bcm_unit, entry, data, mask); 4085 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 4086 } 4087 4088 return rv; 4089 } 4090 4091 /* 4092 * Function: 4093 * bcmx_field_qualify_L2SrcHit 4094 */ 4095 int 4096 bcmx_field_qualify_L2SrcHit(bcm_field_entry_t entry, 4097 uint8 data, uint8 mask) 4098 { 4099 int rv = BCM_E_UNAVAIL, tmp_rv; 4100 int i, bcm_unit; 4101 4102 BCMX_FIELD_INIT_CHECK; 4103 4104 BCMX_UNIT_ITER(bcm_unit, i) { 4105 tmp_rv = bcm_field_qualify_L2SrcHit(bcm_unit, entry, data, mask); 4106 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 4107 } 4108 4109 return rv; 4110 } 4111 4112 /* 4113 * Function: 4114 * bcmx_field_qualify_IngressStpState 4115 */ 4116 int 4117 bcmx_field_qualify_IngressStpState(bcm_field_entry_t entry, 4118 uint8 data, uint8 mask) 4119 { 4120 int rv = BCM_E_UNAVAIL, tmp_rv; 4121 int i, bcm_unit; 4122 4123 BCMX_FIELD_INIT_CHECK; 4124 4125 BCMX_UNIT_ITER(bcm_unit, i) { 4126 tmp_rv = bcm_field_qualify_IngressStpState(bcm_unit, entry, 4127 data, mask); 4128 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 4129 } 4130 4131 return rv; 4132 } 4133 4134 /* 4135 * Function: 4136 * bcmx_field_qualify_ForwardingVlanValid 4137 */ 4138 int 4139 bcmx_field_qualify_ForwardingVlanValid(bcm_field_entry_t entry, 4140 uint8 data, uint8 mask) 4141 { 4142 int rv = BCM_E_UNAVAIL, tmp_rv; 4143 int i, bcm_unit; 4144 4145 BCMX_FIELD_INIT_CHECK; 4146 4147 BCMX_UNIT_ITER(bcm_unit, i) { 4148 tmp_rv = bcm_field_qualify_ForwardingVlanValid(bcm_unit, entry, 4149 data, mask); 4150 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 4151 } 4152 4153 return rv; 4154 } 4155 4156 /* 4157 * Function: 4158 * bcmx_field_qualify_SrcVirtualPortValid 4159 */ 4160 int 4161 bcmx_field_qualify_SrcVirtualPortValid(bcm_field_entry_t entry, 4162 uint8 data, uint8 mask) 4163 { 4164 int rv = BCM_E_UNAVAIL, tmp_rv; 4165 int i, bcm_unit; 4166 4167 BCMX_FIELD_INIT_CHECK; 4168 4169 BCMX_UNIT_ITER(bcm_unit, i) { 4170 tmp_rv = bcm_field_qualify_SrcVirtualPortValid(bcm_unit, entry, 4171 data, mask); 4172 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 4173 } 4174 4175 return rv; 4176 } 4177 4178 /* 4179 * Function: 4180 * bcmx_field_qualify_VlanTranslationHit 4181 */ 4182 int 4183 bcmx_field_qualify_VlanTranslationHit(bcm_field_entry_t entry, 4184 uint8 data, uint8 mask) 4185 { 4186 int rv = BCM_E_UNAVAIL, tmp_rv; 4187 int i, bcm_unit; 4188 4189 BCMX_FIELD_INIT_CHECK; 4190 4191 BCMX_UNIT_ITER(bcm_unit, i) { 4192 tmp_rv = bcm_field_qualify_VlanTranslationHit(bcm_unit, entry, 4193 data, mask); 4194 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 4195 } 4196 4197 return rv; 4198 } 4199 4200 /* 4201 * Function: 4202 * bcmx_field_qualify_InnerIp6FlowLabel 4203 */ 4204 int 4205 bcmx_field_qualify_InnerIp6FlowLabel(bcm_field_entry_t entry, 4206 uint32 data, uint32 mask) 4207 { 4208 int rv = BCM_E_UNAVAIL, tmp_rv; 4209 int i, bcm_unit; 4210 4211 BCMX_FIELD_INIT_CHECK; 4212 4213 BCMX_UNIT_ITER(bcm_unit, i) { 4214 tmp_rv = bcm_field_qualify_InnerIp6FlowLabel(bcm_unit, entry, 4215 data, mask); 4216 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 4217 } 4218 4219 return rv; 4220 } 4221 4222 /* 4223 * Function: 4224 * bcmx_field_qualify_InnerL4DstPort 4225 */ 4226 int 4227 bcmx_field_qualify_InnerL4DstPort(bcm_field_entry_t entry, 4228 bcm_l4_port_t data, 4229 bcm_l4_port_t mask) 4230 { 4231 int rv = BCM_E_UNAVAIL, tmp_rv; 4232 int i, bcm_unit; 4233 4234 BCMX_FIELD_INIT_CHECK; 4235 4236 BCMX_UNIT_ITER(bcm_unit, i) { 4237 tmp_rv = bcm_field_qualify_InnerL4DstPort(bcm_unit, entry, 4238 data, mask); 4239 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 4240 } 4241 4242 return rv; 4243 } 4244 4245 /* 4246 * Function: 4247 * bcmx_field_qualify_InnerL4SrcPort 4248 */ 4249 int 4250 bcmx_field_qualify_InnerL4SrcPort(bcm_field_entry_t entry, 4251 bcm_l4_port_t data, 4252 bcm_l4_port_t mask) 4253 { 4254 int rv = BCM_E_UNAVAIL, tmp_rv; 4255 int i, bcm_unit; 4256 4257 BCMX_FIELD_INIT_CHECK; 4258 4259 BCMX_UNIT_ITER(bcm_unit, i) { 4260 tmp_rv = bcm_field_qualify_InnerL4SrcPort(bcm_unit, entry, 4261 data, mask); 4262 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 4263 } 4264 4265 return rv; 4266 } 4267 4268 /* 4269 * Function: 4270 * bcmx_field_qualify_Loopback 4271 * Purpose: 4272 * Add loopback field qualification to a field entry. 4273 * Parameters: 4274 * entry - (IN) Field entry id. 4275 * data - (IN) Data to qualify with. 4276 * mask - (IN) Mask to qualify with. 4277 * Returns: 4278 * BCM_E_XXX 4279 * Notes: 4280 */ 4281 int 4282 bcmx_field_qualify_Loopback(bcm_field_entry_t entry, 4283 uint8 data, 4284 uint8 mask) 4285 { 4286 int rv = BCM_E_UNAVAIL, tmp_rv; 4287 int i, bcm_unit; 4288 4289 BCMX_FIELD_INIT_CHECK; 4290 4291 BCMX_UNIT_ITER(bcm_unit, i) { 4292 tmp_rv = bcm_field_qualify_Loopback(bcm_unit, entry, 4293 data, mask); 4294 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 4295 } 4296 4297 return rv; 4298 } 4299 4300 /* 4301 * Function: 4302 * bcmx_field_qualify_LoopbackType 4303 * Purpose: 4304 * Add loopback type field qualification to a field entry. 4305 * Parameters: 4306 * entry - (IN) Field entry id. 4307 * loopback_type - (IN) Loopback type. 4308 * Returns: 4309 * BCM_E_XXX 4310 * Notes: 4311 */ 4312 int 4313 bcmx_field_qualify_LoopbackType(bcm_field_entry_t entry, 4314 bcm_field_LoopbackType_t loopback_type) 4315 { 4316 int rv = BCM_E_UNAVAIL, tmp_rv; 4317 int i, bcm_unit; 4318 4319 BCMX_FIELD_INIT_CHECK; 4320 4321 BCMX_UNIT_ITER(bcm_unit, i) { 4322 tmp_rv = bcm_field_qualify_LoopbackType(bcm_unit, entry, 4323 loopback_type); 4324 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 4325 } 4326 4327 return rv; 4328 } 4329 4330 4331 /* 4332 * Function: 4333 * bcmx_field_qualify_TunnelType 4334 * Purpose: 4335 * Add tunnel type field qualification to a field entry. 4336 * Parameters: 4337 * entry - (IN) Field entry id. 4338 * tunnel_type - (IN) Data to qualify with. 4339 * Returns: 4340 * BCM_E_XXX 4341 * Notes: 4342 */ 4343 int 4344 bcmx_field_qualify_TunnelType(bcm_field_entry_t entry, 4345 bcm_field_TunnelType_t tunnel_type) 4346 { 4347 int rv = BCM_E_UNAVAIL, tmp_rv; 4348 int i, bcm_unit; 4349 4350 BCMX_FIELD_INIT_CHECK; 4351 4352 BCMX_UNIT_ITER(bcm_unit, i) { 4353 tmp_rv = bcm_field_qualify_TunnelType(bcm_unit, entry, 4354 tunnel_type); 4355 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 4356 } 4357 4358 return rv; 4359 } 4360 4361 4362 /* 4363 * Function: 4364 * bcmx_field_qualify_DstL3Egress 4365 * Purpose: 4366 * Add a destination egress object field qualification to a field entry. 4367 * Parameters: 4368 * entry - (IN) Field Entry id. 4369 * if_id - (IN) Egress object id. 4370 * Returns: 4371 * BCM_E_XXX 4372 * Notes: 4373 */ 4374 int 4375 bcmx_field_qualify_DstL3Egress(bcm_field_entry_t entry, 4376 bcm_if_t if_id) 4377 { 4378 int rv = BCM_E_UNAVAIL, tmp_rv; 4379 int i, bcm_unit; 4380 4381 BCMX_FIELD_INIT_CHECK; 4382 4383 BCMX_UNIT_ITER(bcm_unit, i) { 4384 tmp_rv = bcm_field_qualify_DstL3Egress(bcm_unit, entry, 4385 if_id); 4386 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 4387 } 4388 return rv; 4389 } 4390 4391 4392 /* 4393 * Function: 4394 * bcmx_field_qualify_DstMulticastGroup 4395 * Purpose: 4396 * Add a destination multicast group field qualification to a field entry. 4397 * Parameters: 4398 * entry - (IN) Field Entry id. 4399 * group - (IN) Multicast group id. 4400 * Returns: 4401 * BCM_E_XXX 4402 * Notes: 4403 */ 4404 int 4405 bcmx_field_qualify_DstMulticastGroup(bcm_field_entry_t entry, 4406 bcm_multicast_t group) 4407 { 4408 int rv = BCM_E_UNAVAIL, tmp_rv; 4409 int i, bcm_unit; 4410 4411 BCMX_FIELD_INIT_CHECK; 4412 4413 BCMX_UNIT_ITER(bcm_unit, i) { 4414 tmp_rv = bcm_field_qualify_DstMulticastGroup(bcm_unit, entry, 4415 group); 4416 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 4417 } 4418 return rv; 4419 } 4420 4421 /* 4422 * Function: 4423 * bcmx_field_qualify_SrcMplsGport 4424 * Purpose: 4425 * Add source mpls port field qualification to a field entry. 4426 * Parameters: 4427 * entry - (IN) Field Entry id. 4428 * mpls_port_id - (IN) Mpls virtual port id. 4429 * Returns: 4430 * BCM_E_XXX 4431 * Notes: 4432 */ 4433 int 4434 bcmx_field_qualify_SrcMplsGport(bcm_field_entry_t entry, 4435 bcm_gport_t mpls_port_id) 4436 { 4437 int rv = BCM_E_UNAVAIL, tmp_rv; 4438 int i, bcm_unit; 4439 4440 BCMX_FIELD_INIT_CHECK; 4441 4442 BCMX_UNIT_ITER(bcm_unit, i) { 4443 tmp_rv = bcm_field_qualify_SrcMplsGport(bcm_unit, entry, 4444 mpls_port_id); 4445 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 4446 } 4447 return rv; 4448 } 4449 4450 4451 /* 4452 * Function: 4453 * bcmx_field_qualify_DstMplsGport 4454 * Purpose: 4455 * Add destination mpls port field qualification to a field entry. 4456 * Parameters: 4457 * entry - (IN) Field Entry id. 4458 * mpls_port_id - (IN) Mpls virtual port id. 4459 * Returns: 4460 * BCM_E_XXX 4461 * Notes: 4462 */ 4463 int 4464 bcmx_field_qualify_DstMplsGport(bcm_field_entry_t entry, 4465 bcm_gport_t mpls_port_id) 4466 { 4467 int rv = BCM_E_UNAVAIL, tmp_rv; 4468 int i, bcm_unit; 4469 4470 BCMX_FIELD_INIT_CHECK; 4471 4472 BCMX_UNIT_ITER(bcm_unit, i) { 4473 tmp_rv = bcm_field_qualify_DstMplsGport(bcm_unit, entry, 4474 mpls_port_id); 4475 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 4476 } 4477 return rv; 4478 } 4479 4480 4481 /* 4482 * Function: 4483 * bcmx_field_qualify_SrcMimGport 4484 * Purpose: 4485 * Add source mac in mac port field qualification to a field entry. 4486 * Parameters: 4487 * entry - (IN) Field Entry id. 4488 * mim_port_id - (IN) Mim virtual port id. 4489 * Returns: 4490 * BCM_E_XXX 4491 * Notes: 4492 */ 4493 int 4494 bcmx_field_qualify_SrcMimGport(bcm_field_entry_t entry, 4495 bcm_gport_t mim_port_id) 4496 { 4497 int rv = BCM_E_UNAVAIL, tmp_rv; 4498 int i, bcm_unit; 4499 4500 BCMX_FIELD_INIT_CHECK; 4501 4502 BCMX_UNIT_ITER(bcm_unit, i) { 4503 tmp_rv = bcm_field_qualify_SrcMimGport(bcm_unit, entry, 4504 mim_port_id); 4505 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 4506 } 4507 return rv; 4508 } 4509 4510 4511 /* 4512 * Function: 4513 * bcmx_field_qualify_DstMimGport 4514 * Purpose: 4515 * Add destination mac in mac port field qualification to a field entry. 4516 * Parameters: 4517 * entry - (IN) Field Entry id. 4518 * mim_port_id - (IN) Mim virtual port id. 4519 * Returns: 4520 * BCM_E_XXX 4521 * Notes: 4522 */ 4523 int 4524 bcmx_field_qualify_DstMimGport(bcm_field_entry_t entry, 4525 bcm_gport_t mim_port_id) 4526 { 4527 int rv = BCM_E_UNAVAIL, tmp_rv; 4528 int i, bcm_unit; 4529 4530 BCMX_FIELD_INIT_CHECK; 4531 4532 BCMX_UNIT_ITER(bcm_unit, i) { 4533 tmp_rv = bcm_field_qualify_DstMimGport(bcm_unit, entry, 4534 mim_port_id); 4535 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 4536 } 4537 return rv; 4538 } 4539 4540 4541 4542 /* 4543 * Function: 4544 * bcmx_field_qualify_SrcWlanGport 4545 * Purpose: 4546 * Add source wlan port field qualification to a field entry. 4547 * Parameters: 4548 * entry - (IN) Field Entry id. 4549 * wlan_port_id - (IN) Wlan virtual port id. 4550 * Returns: 4551 * BCM_E_XXX 4552 * Notes: 4553 */ 4554 int 4555 bcmx_field_qualify_SrcWlanGport(bcm_field_entry_t entry, 4556 bcm_gport_t wlan_port_id) 4557 { 4558 int rv = BCM_E_UNAVAIL, tmp_rv; 4559 int i, bcm_unit; 4560 4561 BCMX_FIELD_INIT_CHECK; 4562 4563 BCMX_UNIT_ITER(bcm_unit, i) { 4564 tmp_rv = bcm_field_qualify_SrcWlanGport(bcm_unit, entry, 4565 wlan_port_id); 4566 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 4567 } 4568 return rv; 4569 } 4570 4571 4572 4573 /* 4574 * Function: 4575 * bcmx_field_qualify_DstWlanGport 4576 * Purpose: 4577 * Add destination wlan port field qualification to a field entry. 4578 * Parameters: 4579 * entry - (IN) Field Entry id. 4580 * wlan_port_id - (IN) Wlan virtual port id. 4581 * Returns: 4582 * BCM_E_XXX 4583 * Notes: 4584 */ 4585 int 4586 bcmx_field_qualify_DstWlanGport(bcm_field_entry_t entry, 4587 bcm_gport_t wlan_port_id) 4588 { 4589 int rv = BCM_E_UNAVAIL, tmp_rv; 4590 int i, bcm_unit; 4591 4592 BCMX_FIELD_INIT_CHECK; 4593 4594 BCMX_UNIT_ITER(bcm_unit, i) { 4595 tmp_rv = bcm_field_qualify_DstWlanGport(bcm_unit, entry, 4596 wlan_port_id); 4597 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 4598 } 4599 return rv; 4600 } 4601 4602 /* 4603 * Function: 4604 * bcmx_field_qualify_SrcModPortGport 4605 * Purpose: 4606 * Add source mod/port field qualification to a field entry. 4607 * Parameters: 4608 * entry - (IN) Field Entry id. 4609 * data - (IN) Wlan virtual port id. 4610 * Returns: 4611 * BCM_E_XXX 4612 * Notes: 4613 */ 4614 int 4615 bcmx_field_qualify_SrcModPortGport(bcm_field_entry_t entry, 4616 bcm_gport_t data) 4617 { 4618 int rv = BCM_E_UNAVAIL, tmp_rv; 4619 int i, bcm_unit; 4620 4621 BCMX_FIELD_INIT_CHECK; 4622 4623 BCMX_UNIT_ITER(bcm_unit, i) { 4624 tmp_rv = bcm_field_qualify_SrcModPortGport(bcm_unit, entry, 4625 data); 4626 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 4627 } 4628 return rv; 4629 } 4630 4631 /* 4632 * Function: 4633 * bcmx_field_qualify_SrcModuleGport 4634 * Purpose: 4635 * Add source mod/port field qualification to a field entry. 4636 * Parameters: 4637 * entry - (IN) Field Entry id. 4638 * data - (IN) Wlan virtual port id. 4639 * Returns: 4640 * BCM_E_XXX 4641 * Notes: 4642 */ 4643 int 4644 bcmx_field_qualify_SrcModuleGport(bcm_field_entry_t entry, 4645 bcm_gport_t data) 4646 { 4647 int rv = BCM_E_UNAVAIL, tmp_rv; 4648 int i, bcm_unit; 4649 4650 BCMX_FIELD_INIT_CHECK; 4651 4652 BCMX_UNIT_ITER(bcm_unit, i) { 4653 tmp_rv = bcm_field_qualify_SrcModuleGport(bcm_unit, entry, 4654 data); 4655 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 4656 } 4657 return rv; 4658 } 4659 4660 /* 4661 * Function: 4662 * bcmx_field_qualify_Color 4663 * Purpose: 4664 * Set match criteria for bcmFieldQualifyColor 4665 * qualifier in the field entry. 4666 * Parameters: 4667 * entry - (IN) BCM field entry id. 4668 * color - (IN) Qualifier match color. 4669 * Returns: 4670 * BCM_E_XXX 4671 * Notes: 4672 */ 4673 int 4674 bcmx_field_qualify_Color(bcm_field_entry_t entry, uint8 color) 4675 { 4676 int rv = BCM_E_UNAVAIL, tmp_rv; 4677 int i, bcm_unit; 4678 4679 BCMX_FIELD_INIT_CHECK; 4680 4681 BCMX_UNIT_ITER(bcm_unit, i) { 4682 tmp_rv = bcm_field_qualify_Color(bcm_unit, entry, color); 4683 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 4684 } 4685 return rv; 4686 } 4687 4688 /* 4689 * Function: 4690 * bcmx_field_qualify_IntPriority 4691 * Purpose: 4692 * Set match criteria for bcmFieldQualifyColor 4693 * qualifier in the field entry. 4694 * Parameters: 4695 * entry - (IN) BCM field entry id. 4696 * data - (IN) Qualifier match data. 4697 * mask - (IN) Qualifier match mask. 4698 * Returns: 4699 * BCM_E_XXX 4700 * Notes: 4701 */ 4702 int 4703 bcmx_field_qualify_IntPriority(bcm_field_entry_t entry, 4704 uint8 data, uint8 mask) 4705 { 4706 int rv = BCM_E_UNAVAIL, tmp_rv; 4707 int i, bcm_unit; 4708 4709 BCMX_FIELD_INIT_CHECK; 4710 4711 BCMX_UNIT_ITER(bcm_unit, i) { 4712 tmp_rv = bcm_field_qualify_IntPriority(bcm_unit, entry, data, mask); 4713 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 4714 } 4715 return rv; 4716 } 4717 4718 /* 4719 * Function: 4720 * bcmx_field_qualify_FibreChanOuter 4721 * Purpose: 4722 * Add Fibre Channel outer header type field qualification to 4723 * field entry. 4724 * Parameters: 4725 * entry - (IN) BCM field entry id. 4726 * fibre_chan_type - (IN) Data to qualify with. 4727 * Returns: 4728 * BCM_E_XXX 4729 * Notes: 4730 */ 4731 int 4732 bcmx_field_qualify_FibreChanOuter(bcm_field_entry_t entry, 4733 bcm_field_FibreChan_t fibre_chan_type) 4734 { 4735 int rv = BCM_E_UNAVAIL, tmp_rv; 4736 int i, bcm_unit; 4737 4738 BCMX_FIELD_INIT_CHECK; 4739 4740 BCMX_UNIT_ITER(bcm_unit, i) { 4741 tmp_rv = bcm_field_qualify_FibreChanOuter(bcm_unit, entry, 4742 fibre_chan_type); 4743 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 4744 } 4745 return rv; 4746 } 4747 4748 /* 4749 * Function: 4750 * bcmx_field_qualify_FibreChanInner 4751 * Purpose: 4752 * Add Fibre Channel inner header type field qualification to 4753 * field entry. 4754 * Parameters: 4755 * entry - (IN) BCM field entry id. 4756 * fibre_chan_type - (IN) Data to qualify with. 4757 * Returns: 4758 * BCM_E_XXX 4759 * Notes: 4760 */ 4761 int 4762 bcmx_field_qualify_FibreChanInner(bcm_field_entry_t entry, 4763 bcm_field_FibreChan_t fibre_chan_type) 4764 { 4765 int rv = BCM_E_UNAVAIL, tmp_rv; 4766 int i, bcm_unit; 4767 4768 BCMX_FIELD_INIT_CHECK; 4769 4770 BCMX_UNIT_ITER(bcm_unit, i) { 4771 tmp_rv = bcm_field_qualify_FibreChanInner(bcm_unit, entry, 4772 fibre_chan_type); 4773 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 4774 } 4775 return rv; 4776 } 4777 4778 /* 4779 * Function: 4780 * bcmx_field_qualify_VnTag 4781 * Purpose: 4782 * Add NIV VN tag field qualification to field entry. 4783 * Parameters: 4784 * entry - (IN) BCM field entry id. 4785 * data - (IN) Qualifier match data. 4786 * mask - (IN) Qualifier match mask. 4787 * Returns: 4788 * BCM_E_XXX 4789 * Notes: 4790 */ 4791 int 4792 bcmx_field_qualify_VnTag(bcm_field_entry_t entry, uint32 data, uint32 mask) 4793 { 4794 int rv = BCM_E_UNAVAIL, tmp_rv; 4795 int i, bcm_unit; 4796 4797 BCMX_FIELD_INIT_CHECK; 4798 4799 BCMX_UNIT_ITER(bcm_unit, i) { 4800 tmp_rv = bcm_field_qualify_VnTag(bcm_unit, entry, data, mask); 4801 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 4802 } 4803 return rv; 4804 } 4805 4806 /* 4807 * Function: 4808 * bcmx_field_qualify_CnTag 4809 * Purpose: 4810 * Add QCN CN tag field qualification to field entry. 4811 * Parameters: 4812 * entry - (IN) BCM field entry id. 4813 * data - (IN) Qualifier match data. 4814 * mask - (IN) Qualifier match mask. 4815 * Returns: 4816 * BCM_E_XXX 4817 * Notes: 4818 */ 4819 int 4820 bcmx_field_qualify_CnTag(bcm_field_entry_t entry, uint32 data, uint32 mask) 4821 { 4822 int rv = BCM_E_UNAVAIL, tmp_rv; 4823 int i, bcm_unit; 4824 4825 BCMX_FIELD_INIT_CHECK; 4826 4827 BCMX_UNIT_ITER(bcm_unit, i) { 4828 tmp_rv = bcm_field_qualify_CnTag(bcm_unit, entry, data, mask); 4829 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 4830 } 4831 return rv; 4832 } 4833 4834 /* 4835 * Function: 4836 * bcmx_field_qualify_FabricQueueTag 4837 * Purpose: 4838 * Add Fabric Queue tag field qualification to field entry. 4839 * Parameters: 4840 * entry - (IN) BCM field entry id. 4841 * data - (IN) Qualifier match data. 4842 * mask - (IN) Qualifier match mask. 4843 * Returns: 4844 * BCM_E_XXX 4845 * Notes: 4846 */ 4847 int 4848 bcmx_field_qualify_FabricQueueTag(bcm_field_entry_t entry, 4849 uint32 data, uint32 mask) 4850 { 4851 int rv = BCM_E_UNAVAIL, tmp_rv; 4852 int i, bcm_unit; 4853 4854 BCMX_FIELD_INIT_CHECK; 4855 4856 BCMX_UNIT_ITER(bcm_unit, i) { 4857 tmp_rv = bcm_field_qualify_FabricQueueTag(bcm_unit, entry, data, mask); 4858 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 4859 } 4860 return rv; 4861 } 4862 4863 /* 4864 * Function: 4865 * bcmx_field_qualify_DstMultipath 4866 * Purpose: 4867 * Add a multipath egress object field qualification to a field entry. 4868 * Parameters: 4869 * entry - (IN) BCM field entry id. 4870 * mpintf - (IN) Multipath egress object id. 4871 * Returns: 4872 * BCM_E_XXX 4873 * Notes: 4874 */ 4875 int 4876 bcmx_field_qualify_DstMultipath(bcm_field_entry_t entry, bcm_if_t mpintf) 4877 { 4878 int rv = BCM_E_UNAVAIL, tmp_rv; 4879 int i, bcm_unit; 4880 4881 BCMX_FIELD_INIT_CHECK; 4882 4883 BCMX_UNIT_ITER(bcm_unit, i) { 4884 tmp_rv = bcm_field_qualify_DstMultipath(bcm_unit, entry, mpintf); 4885 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 4886 } 4887 4888 return rv; 4889 } 4890 4891 4892 /* 4893 * Function: 4894 * bcmx_field_action_add 4895 * Purpose: 4896 * Add action performed when entry rule is matched for a packet 4897 * Parameters: 4898 * entry - Entry ID 4899 * action - Action to perform (bcmFieldActionXXX) 4900 * param0 - Action parameter (use 0 if not required) 4901 * param1 - Action parameter (use 0 if not required) 4902 * Returns: 4903 * BCM_E_NOT_FOUND Entry ID not found 4904 * BCM_E_MEMORY Allocation failure 4905 * BCM_E_RESOURCE Counter not previously created for entry 4906 * BCM_E_PARAM param0 not an even index for counter 4907 * BCM_E_NONE 4908 * Notes: 4909 * For port related actions, param0 is a BCMX logical port or 4910 * other GPORT type. 4911 */ 4912 4913 int 4914 bcmx_field_action_add(bcm_field_entry_t entry, 4915 bcm_field_action_t action, 4916 uint32 param0, 4917 uint32 param1) 4918 { 4919 int rv = BCM_E_UNAVAIL, tmp_rv; 4920 int i, bcm_unit; 4921 4922 BCMX_FIELD_INIT_CHECK; 4923 4924 /* 4925 * For port related actions, param0 can be either: 4926 * - A BCMX lport, then translate to modid/port 4927 * - Another gport type, such as trunk 4928 */ 4929 if ((action == bcmFieldActionRedirectPort) || 4930 (action == bcmFieldActionRedirect) || 4931 (action == bcmFieldActionMirrorIngress) || 4932 (action == bcmFieldActionMirrorEgress)) { 4933 bcm_module_t modid; 4934 bcm_port_t modport; 4935 4936 /* 4937 * When param0 is a valid GPORT, but it is NOT of of MODPORT type, 4938 * the conversion to modid/port will fail. However, the GPORT 4939 * value may be a valid data for certain devices (such as ESW) 4940 * where a trunk (in gport format) is being passed in. 4941 * 4942 * NOTE that the BCM API expects the gport data in the 4943 * place where the 'port' parameter is normally passed in. 4944 * 4945 * This is a bit uggly, 4946 * but we must accomodate different architectures and 4947 * the partial support of gport formats. 4948 */ 4949 if (BCM_SUCCESS(_bcmx_dest_to_modid_port((bcmx_lport_t)param0, 4950 &modid, &modport, 4951 BCMX_DEST_CONVERT_DEFAULT))) { 4952 param0 = (uint32)modid; 4953 param1 = (uint32)modport; 4954 } else { 4955 /* Assign gport value to expected 'param1' in BCM */ 4956 param1 = param0; 4957 } 4958 } 4959 4960 BCMX_UNIT_ITER(bcm_unit, i) { 4961 tmp_rv = bcm_field_action_add(bcm_unit, entry, action, 4962 param0, param1); 4963 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 4964 } 4965 4966 return rv; 4967 } 4968 4969 4970 /* 4971 * Function: 4972 * bcmx_field_action_delete 4973 * Purpose: 4974 * Delete an action performed when entry rule is matched for a packet 4975 * Parameters: 4976 * entry - Entry ID 4977 * action - Action to perform (bcmFieldActionXXX) 4978 * param0 - Action parameter (use 0 if not required) 4979 * param1 - Action parameter (use 0 if not required) 4980 * Returns: 4981 * BCM_E_NOT_FOUND Entry ID not found 4982 * BCM_E_MEMORY Allocation failure 4983 * BCM_E_RESOURCE Counter not previously created for entry 4984 * BCM_E_PARAM param0 not an even index for counter 4985 * BCM_E_NONE 4986 * Notes: 4987 * For port related actions, param0 is a BCMX logical port or 4988 * other GPORT type. 4989 */ 4990 4991 int 4992 bcmx_field_action_delete(bcm_field_entry_t entry, 4993 bcm_field_action_t action, 4994 uint32 param0, 4995 uint32 param1) 4996 { 4997 int rv = BCM_E_UNAVAIL, tmp_rv; 4998 int i, bcm_unit; 4999 5000 BCMX_FIELD_INIT_CHECK; 5001 5002 /* 5003 * For port related actions, param0 can be either: 5004 * - A BCMX lport, then translate to modid/port 5005 * - Another gport type, such as trunk 5006 */ 5007 if ((action == bcmFieldActionRedirectPort) || 5008 (action == bcmFieldActionRedirect) || 5009 (action == bcmFieldActionMirrorIngress) || 5010 (action == bcmFieldActionMirrorEgress)) { 5011 int modid; 5012 bcm_port_t modport; 5013 5014 /* 5015 * When param0 is a valid GPORT, but it is NOT of of MODPORT type, 5016 * the conversion to modid/port will fail. However, the GPORT 5017 * value may be a valid data for certain devices (such as ESW) 5018 * where a trunk (in gport format) is being passed in. 5019 * 5020 * NOTE that the BCM API expects the gport data in the 5021 * place where the 'port' parameter is normally passed in. 5022 * 5023 * This is a bit uggly, 5024 * but we must accomodate different architectures and 5025 * the partial support of gport formats. 5026 */ 5027 if (BCM_SUCCESS(_bcmx_dest_to_modid_port((bcmx_lport_t)param0, 5028 &modid, &modport, 5029 BCMX_DEST_CONVERT_DEFAULT))) { 5030 param0 = (uint32)modid; 5031 param1 = (uint32)modport; 5032 } else { 5033 /* Assign gport value to expected argument 'param1' for BCM */ 5034 param1 = param0; 5035 } 5036 } 5037 5038 BCMX_UNIT_ITER(bcm_unit, i) { 5039 tmp_rv = bcm_field_action_delete(bcm_unit, entry, action, 5040 param0, param1); 5041 BCM_IF_ERROR_RETURN 5042 (BCMX_FIELD_DELETE_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 5043 } 5044 5045 return rv; 5046 } 5047 5048 /* 5049 * Function: 5050 * bcmx_field_action_mac_add 5051 * Purpose: 5052 * Add mac related actions to field entry. 5053 * Parameters: 5054 * entry - Entry ID 5055 * action - Action (bcmFieldActionSrcMacNew or 5056 * bcmFieldActionDstMacNew 5057 * mac - Mac address. 5058 * Returns: 5059 * BCM_E_NOT_FOUND Entry ID not found 5060 * BCM_E_MEMORY Allocation failure 5061 * BCM_E_RESOURCE 5062 * BCM_E_PARAM 5063 * BCM_E_NONE 5064 */ 5065 int 5066 bcmx_field_action_mac_add(bcm_field_entry_t entry, 5067 bcm_field_action_t action, 5068 bcm_mac_t mac) 5069 { 5070 int rv = BCM_E_UNAVAIL, tmp_rv; 5071 int i, bcm_unit; 5072 5073 BCMX_FIELD_INIT_CHECK; 5074 5075 BCMX_UNIT_ITER(bcm_unit, i) { 5076 tmp_rv = bcm_field_action_mac_add(bcm_unit, entry, action, mac); 5077 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 5078 } 5079 return rv; 5080 } 5081 5082 /* 5083 * Function: 5084 * bcmx_field_action_mac_get 5085 * Purpose: 5086 * Get field action SrcMacNew/DstMacNew parameters. 5087 * Parameters: 5088 * entry - Entry ID 5089 * action - Action (bcmFieldActionSrcMacNew or 5090 * bcmFieldActionDstMacNew 5091 * mac - (OUT) Mac address. 5092 * Returns: 5093 * BCM_E_INIT - BCM Unit not initialized 5094 * BCM_E_NOT_FOUND - Entry ID not found 5095 * BCM_E_NOT_FOUND - No matching Action for entry 5096 * BCM_E_PARAM - incorrect action OR pbmp is NULL 5097 * BCM_E_NONE - Success 5098 */ 5099 int 5100 bcmx_field_action_mac_get(bcm_field_entry_t entry, 5101 bcm_field_action_t action, 5102 bcm_mac_t *mac) 5103 { 5104 int rv; 5105 int i, bcm_unit; 5106 5107 BCMX_FIELD_INIT_CHECK; 5108 5109 BCMX_PARAM_NULL_CHECK(mac); 5110 5111 BCMX_UNIT_ITER(bcm_unit, i) { 5112 rv = bcm_field_action_mac_get(bcm_unit, entry, action, mac); 5113 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 5114 return rv; 5115 } 5116 } 5117 5118 return BCM_E_UNAVAIL; 5119 } 5120 5121 /* 5122 * Function: 5123 * bcmx_field_action_ports_add 5124 * Purpose: 5125 * Add PBMP related actions, when entry rule is matched for a packet 5126 * Parameters: 5127 * entry - Entry ID 5128 * action - Action to perform (bcmFieldActionRedirectPbmp or 5129 * bcmFieldActionEgressMask 5130 * lplist - Logical Port list 5131 * Returns: 5132 * BCM_E_NOT_FOUND Entry ID not found 5133 * BCM_E_MEMORY Allocation failure 5134 * BCM_E_RESOURCE 5135 * BCM_E_PARAM 5136 * BCM_E_NONE 5137 * Notes: 5138 * This API has limitations when dealing with remote ports 5139 * for certain topologies. 5140 * FP action is applied to ports from given list that are 5141 * local to the devices where packets are ingressing. 5142 */ 5143 int 5144 bcmx_field_action_ports_add(bcm_field_entry_t entry, 5145 bcm_field_action_t action, 5146 bcmx_lplist_t lplist) 5147 { 5148 int rv = BCM_E_UNAVAIL, tmp_rv; 5149 int i, bcm_unit; 5150 bcm_pbmp_t pbmp; 5151 5152 BCMX_FIELD_INIT_CHECK; 5153 5154 if (bcmx_lplist_is_null(&lplist)) { 5155 return BCM_E_PARAM; 5156 } 5157 5158 BCMX_UNIT_ITER(bcm_unit, i) { 5159 BCMX_LPLIST_TO_PBMP(lplist, bcm_unit, pbmp); 5160 tmp_rv = bcm_field_action_ports_add(bcm_unit, entry, action, pbmp); 5161 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 5162 } 5163 5164 return rv; 5165 } 5166 5167 /* 5168 * Function: 5169 * bcmx_field_action_ports_get 5170 * Purpose: 5171 * Get parameters associated with port list related entry actions 5172 * Parameters: 5173 * entry - Entry ID 5174 * action - Action (bcmFieldActionRedirectPbmp or 5175 * bcmFieldActionEgressMask 5176 * lplist - (OUT) Logical Port list 5177 * Returns: 5178 * BCM_E_INIT - BCM Unit not initialized 5179 * BCM_E_NOT_FOUND - Entry ID not found 5180 * BCM_E_NOT_FOUND - No matching Action for entry 5181 * BCM_E_PARAM - incorrect action OR pbmp is NULL 5182 * BCM_E_NONE - Success 5183 */ 5184 int 5185 bcmx_field_action_ports_get(bcm_field_entry_t entry, 5186 bcm_field_action_t action, 5187 bcmx_lplist_t *lplist) 5188 { 5189 int rv = BCM_E_UNAVAIL, tmp_rv; 5190 int i, bcm_unit; 5191 bcm_pbmp_t pbmp; 5192 5193 BCMX_FIELD_INIT_CHECK; 5194 5195 BCMX_PARAM_NULL_CHECK(lplist); 5196 5197 BCMX_UNIT_ITER(bcm_unit, i) { 5198 BCM_PBMP_CLEAR(pbmp); 5199 tmp_rv = bcm_field_action_ports_get(bcm_unit, entry, action, &pbmp); 5200 5201 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, tmp_rv)) { 5202 rv = tmp_rv; 5203 if (BCM_SUCCESS(tmp_rv)) { 5204 BCMX_LPLIST_PBMP_ADD(lplist, bcm_unit, pbmp); 5205 } else { 5206 break; 5207 } 5208 } 5209 } 5210 5211 return rv; 5212 } 5213 5214 5215 /* 5216 * Function: 5217 * bcmx_field_action_get 5218 * Purpose: 5219 * Get parameters associated with an entry action 5220 * Parameters: 5221 * entry - Entry ID 5222 * action - Action to perform (bcmFieldActionXXX) 5223 * param0 - (OUT) Action parameter 5224 * param1 - (OUT) Action parameter 5225 * Returns: 5226 * BCM_E_NOT_FOUND Entry ID or action not found 5227 * BCM_E_PARAM paramX is NULL 5228 * BCM_E_NONE 5229 * Notes: 5230 * Get value from first successful call. 5231 * For port related actions, param0 returns a BCMX logical port. 5232 */ 5233 5234 int 5235 bcmx_field_action_get(bcm_field_entry_t entry, 5236 bcm_field_action_t action, 5237 uint32 *param0, 5238 uint32 *param1) 5239 { 5240 int rv; 5241 int i, bcm_unit; 5242 5243 BCMX_FIELD_INIT_CHECK; 5244 5245 BCMX_PARAM_NULL_CHECK(param0); 5246 BCMX_PARAM_NULL_CHECK(param1); 5247 5248 BCMX_UNIT_ITER(bcm_unit, i) { 5249 rv = bcm_field_action_get(bcm_unit, entry, action, 5250 param0, param1); 5251 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 5252 if (BCM_SUCCESS(rv)) { 5253 /* 5254 * For port related actions, param0 returns an lport, 5255 * translate modid/port to lport 5256 */ 5257 if ((action == bcmFieldActionRedirectPort) || 5258 (action == bcmFieldActionRedirect) || 5259 (action == bcmFieldActionMirrorIngress) || 5260 (action == bcmFieldActionMirrorEgress)) { 5261 bcmx_lport_t port; 5262 5263 BCM_IF_ERROR_RETURN 5264 (_bcmx_dest_from_modid_port(&port, 5265 (bcm_module_t)(*param0), 5266 (bcm_port_t)(*param1), 5267 BCMX_DEST_CONVERT_DEFAULT)); 5268 *param0 = (uint32)port; 5269 *param1 = 0; 5270 } 5271 } 5272 return rv; 5273 } 5274 } 5275 5276 return BCM_E_UNAVAIL; 5277 } 5278 5279 /* 5280 * Function: 5281 * bcmx_field_action_remove 5282 * Purpose: 5283 * Remove an action performed when entry rule is matched for 5284 * a packet 5285 * Parameters: 5286 * entry - Entry ID 5287 * action - Action to remove (bcmFieldActionXXX) 5288 * Returns: 5289 * BCM_E_NOT_FOUND Entry ID or action not found 5290 * BCM_E_PARAM Action out of valid range 5291 * BCM_E_NONE 5292 */ 5293 5294 int 5295 bcmx_field_action_remove(bcm_field_entry_t entry, 5296 bcm_field_action_t action) 5297 { 5298 int rv = BCM_E_UNAVAIL, tmp_rv; 5299 int i, bcm_unit; 5300 5301 BCMX_FIELD_INIT_CHECK; 5302 5303 BCMX_UNIT_ITER(bcm_unit, i) { 5304 tmp_rv = bcm_field_action_remove(bcm_unit, entry, action); 5305 BCM_IF_ERROR_RETURN 5306 (BCMX_FIELD_DELETE_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 5307 } 5308 5309 return rv; 5310 } 5311 5312 /* 5313 * Function: 5314 * bcmx_field_action_remove_all 5315 * Purpose: 5316 * Remove all actions from an entry rule 5317 * Parameters: 5318 * entry - Entry ID 5319 * Returns: 5320 * BCM_E_NOT_FOUND Entry ID not found 5321 * BCM_E_NONE 5322 */ 5323 5324 int 5325 bcmx_field_action_remove_all(bcm_field_entry_t entry) 5326 { 5327 int rv = BCM_E_UNAVAIL, tmp_rv; 5328 int i, bcm_unit; 5329 5330 BCMX_FIELD_INIT_CHECK; 5331 5332 BCMX_UNIT_ITER(bcm_unit, i) { 5333 tmp_rv = bcm_field_action_remove_all(bcm_unit, entry); 5334 BCM_IF_ERROR_RETURN 5335 (BCMX_FIELD_DELETE_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 5336 } 5337 5338 return rv; 5339 } 5340 5341 5342 /* 5343 * Function: 5344 * bcmx_field_stat_create 5345 * Description: 5346 * Create statistics collection entity. 5347 * Parameters: 5348 * group - Field group id. 5349 * nstat - Number of elements in stat array. 5350 * stat_arr - Collected statistics descriptors array. 5351 * stat_id - (OUT) Statistics entity id. 5352 * Returns: 5353 * BCM_E_XXX 5354 */ 5355 int 5356 bcmx_field_stat_create(bcm_field_group_t group, int nstat, 5357 bcm_field_stat_t *stat_arr, int *stat_id) 5358 { 5359 int rv = BCM_E_UNAVAIL, tmp_rv; 5360 int i, bcm_unit; 5361 int id; 5362 5363 BCMX_FIELD_INIT_CHECK; 5364 5365 if (nstat != 0) { 5366 BCMX_PARAM_NULL_CHECK(stat_arr); 5367 } 5368 BCMX_PARAM_NULL_CHECK(stat_id); 5369 5370 id = STAT_ID_ALLOC; 5371 *stat_id = id; 5372 5373 BCMX_UNIT_ITER(bcm_unit, i) { 5374 tmp_rv = bcm_field_stat_create_id(bcm_unit, group, 5375 nstat, stat_arr, id); 5376 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 5377 } 5378 5379 return rv; 5380 } 5381 5382 /* 5383 * Function: 5384 * bcmx_field_stat_create_id 5385 * Description: 5386 * Create statistics collection entity with given id. 5387 * Parameters: 5388 * group - Field group id. 5389 * nstat - Number of elements in stat array. 5390 * stat_arr - Collected statistics descriptors array. 5391 * stat_id - Statistics entity id. 5392 * Returns: 5393 * BCM_E_XXX 5394 */ 5395 int 5396 bcmx_field_stat_create_id(bcm_field_group_t group, int nstat, 5397 bcm_field_stat_t *stat_arr, int stat_id) 5398 { 5399 int rv = BCM_E_UNAVAIL, tmp_rv; 5400 int i, bcm_unit; 5401 5402 BCMX_FIELD_INIT_CHECK; 5403 5404 if (nstat != 0) { 5405 BCMX_PARAM_NULL_CHECK(stat_arr); 5406 } 5407 5408 BCMX_UNIT_ITER(bcm_unit, i) { 5409 tmp_rv = bcm_field_stat_create_id(bcm_unit, group, 5410 nstat, stat_arr, stat_id); 5411 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 5412 } 5413 5414 return rv; 5415 } 5416 5417 /* 5418 * Function: 5419 * bcmx_field_stat_destroy 5420 * Description: 5421 * Destroy statistics collection entity. 5422 * Parameters: 5423 * stat_id - Statistics entity id. 5424 * Returns: 5425 * BCM_E_XXX 5426 */ 5427 int 5428 bcmx_field_stat_destroy(int stat_id) 5429 { 5430 int rv = BCM_E_UNAVAIL, tmp_rv; 5431 int i, bcm_unit; 5432 5433 BCMX_FIELD_INIT_CHECK; 5434 5435 BCMX_UNIT_ITER(bcm_unit, i) { 5436 tmp_rv = bcm_field_stat_destroy(bcm_unit, stat_id); 5437 BCM_IF_ERROR_RETURN 5438 (BCMX_FIELD_DELETE_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 5439 } 5440 5441 return rv; 5442 } 5443 5444 /* 5445 * Function: 5446 * bcmx_field_stat_size 5447 * Description: 5448 * Get number of different statistics associated with statistics 5449 * collection entity. 5450 * Parameters: 5451 * stat_id - Statistics entity id. 5452 * stat_size - (OUT) Number of collected statistics 5453 * Returns: 5454 * BCM_E_XXX 5455 */ 5456 int 5457 bcmx_field_stat_size(int stat_id, int *stat_size) 5458 { 5459 int rv; 5460 int i, bcm_unit; 5461 5462 BCMX_FIELD_INIT_CHECK; 5463 5464 BCMX_PARAM_NULL_CHECK(stat_size); 5465 5466 BCMX_UNIT_ITER(bcm_unit, i) { 5467 rv = bcm_field_stat_size(bcm_unit, stat_id, stat_size); 5468 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 5469 return rv; 5470 } 5471 } 5472 5473 return BCM_E_UNAVAIL; 5474 } 5475 5476 /* 5477 * Function: 5478 * bcmx_field_stat_config_get 5479 * Description: 5480 * Get enabled statistics for specific collection entity. 5481 * Parameters: 5482 * stat_id - Statistics entity id. 5483 * nstat - Number of elements in stat array. 5484 * stat_arr - (OUT) Collected statistics descriptors array. 5485 * Returns: 5486 * BCM_E_XXX 5487 */ 5488 int 5489 bcmx_field_stat_config_get(int stat_id, int nstat, bcm_field_stat_t *stat_arr) 5490 { 5491 int rv; 5492 int i, bcm_unit; 5493 5494 BCMX_FIELD_INIT_CHECK; 5495 5496 if (nstat != 0) { 5497 BCMX_PARAM_NULL_CHECK(stat_arr); 5498 } 5499 5500 BCMX_UNIT_ITER(bcm_unit, i) { 5501 rv = bcm_field_stat_config_get(bcm_unit, stat_id, nstat, stat_arr); 5502 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 5503 return rv; 5504 } 5505 } 5506 5507 return BCM_E_UNAVAIL; 5508 } 5509 5510 /* 5511 * Function: 5512 * bcmx_field_stat_set 5513 * Description: 5514 * Set 64 bit counter value for specific statistic type. 5515 * Parameters: 5516 * stat_id - Statistics entity id. 5517 * stat - Collected statistics descriptor. 5518 * value - Value to set. 5519 * Returns: 5520 * BCM_E_XXX 5521 */ 5522 int 5523 bcmx_field_stat_set(int stat_id, bcm_field_stat_t stat, uint64 value) 5524 { 5525 int rv = BCM_E_UNAVAIL, tmp_rv; 5526 int i, bcm_unit; 5527 5528 BCMX_FIELD_INIT_CHECK; 5529 5530 BCMX_UNIT_ITER(bcm_unit, i) { 5531 tmp_rv = bcm_field_stat_set(bcm_unit, stat_id, stat, value); 5532 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 5533 } 5534 5535 return rv; 5536 } 5537 5538 /* 5539 * Function: 5540 * bcmx_field_stat_set32 5541 * Description: 5542 * Set lower 32 bit counter value for specific statistic type. 5543 * Parameters: 5544 * stat_id - Statistics entity id. 5545 * stat - Collected statistics descriptor. 5546 * value - Value to set. 5547 * Returns: 5548 * BCM_E_XXX 5549 */ 5550 int 5551 bcmx_field_stat_set32(int stat_id, bcm_field_stat_t stat, uint32 value) 5552 { 5553 int rv = BCM_E_UNAVAIL, tmp_rv; 5554 int i, bcm_unit; 5555 5556 BCMX_FIELD_INIT_CHECK; 5557 5558 BCMX_UNIT_ITER(bcm_unit, i) { 5559 tmp_rv = bcm_field_stat_set32(bcm_unit, stat_id, stat, value); 5560 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 5561 } 5562 5563 return rv; 5564 } 5565 5566 /* 5567 * Function: 5568 * bcmx_field_stat_all_set 5569 * Description: 5570 * Set 64 bit counter values for all statistic types. 5571 * Parameters: 5572 * stat_id - Statistics entity id. 5573 * value - Value to set. 5574 * Returns: 5575 * BCM_E_XXX 5576 */ 5577 int 5578 bcmx_field_stat_all_set(int stat_id, uint64 value) 5579 { 5580 int rv = BCM_E_UNAVAIL, tmp_rv; 5581 int i, bcm_unit; 5582 5583 BCMX_FIELD_INIT_CHECK; 5584 5585 BCMX_UNIT_ITER(bcm_unit, i) { 5586 tmp_rv = bcm_field_stat_all_set(bcm_unit, stat_id, value); 5587 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 5588 } 5589 5590 return rv; 5591 } 5592 5593 /* 5594 * Function: 5595 * bcmx_field_stat_all_set32 5596 * Description: 5597 * Set lower 32 bit counter values for all statistic types. 5598 * Parameters: 5599 * stat_id - Statistics entity id. 5600 * value - Value to set. 5601 * Returns: 5602 * BCM_E_XXX 5603 */ 5604 int 5605 bcmx_field_stat_all_set32(int stat_id, uint32 value) 5606 { 5607 int rv = BCM_E_UNAVAIL, tmp_rv; 5608 int i, bcm_unit; 5609 5610 BCMX_FIELD_INIT_CHECK; 5611 5612 BCMX_UNIT_ITER(bcm_unit, i) { 5613 tmp_rv = bcm_field_stat_all_set32(bcm_unit, stat_id, value); 5614 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 5615 } 5616 5617 return rv; 5618 } 5619 5620 /* 5621 * Function: 5622 * bcmx_field_stat_get 5623 * Description: 5624 * Get 64 bit counter value for specific statistic type. 5625 * Parameters: 5626 * stat_id - Statistics entity id. 5627 * stat - Collected statistics descriptor. 5628 * value - (OUT) Collected counters value. 5629 * Returns: 5630 * BCM_E_XXX 5631 */ 5632 int 5633 bcmx_field_stat_get(int stat_id, bcm_field_stat_t stat, uint64 *value) 5634 { 5635 int rv = BCM_E_UNAVAIL, tmp_rv; 5636 int i, bcm_unit; 5637 uint64 tmp_val; 5638 5639 BCMX_FIELD_INIT_CHECK; 5640 5641 BCMX_PARAM_NULL_CHECK(value); 5642 5643 COMPILER_64_ZERO(*value); 5644 BCMX_UNIT_ITER(bcm_unit, i) { 5645 tmp_rv = bcm_field_stat_get(bcm_unit, stat_id, stat, &tmp_val); 5646 5647 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, tmp_rv)) { 5648 rv = tmp_rv; 5649 if (BCM_SUCCESS(tmp_rv)) { 5650 COMPILER_64_ADD_64(*value, tmp_val); 5651 } else { 5652 break; 5653 } 5654 } 5655 } 5656 5657 return rv; 5658 } 5659 5660 /* 5661 * Function: 5662 * bcmx_field_stat_get32 5663 * Description: 5664 * Get lower 32 bit counter value for specific statistic type. 5665 * Parameters: 5666 * stat_id - Statistics entity id. 5667 * stat - Collected statistics descriptor. 5668 * value - (OUT) Collected counters value. 5669 * Returns: 5670 * BCM_E_XXX 5671 */ 5672 int 5673 bcmx_field_stat_get32(int stat_id, bcm_field_stat_t stat, uint32 *value) 5674 { 5675 int rv = BCM_E_UNAVAIL, tmp_rv; 5676 int i, bcm_unit; 5677 uint32 tmp_val; 5678 5679 BCMX_FIELD_INIT_CHECK; 5680 5681 BCMX_PARAM_NULL_CHECK(value); 5682 5683 *value = 0; 5684 BCMX_UNIT_ITER(bcm_unit, i) { 5685 tmp_rv = bcm_field_stat_get32(bcm_unit, stat_id, stat, &tmp_val); 5686 5687 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, tmp_rv)) { 5688 rv = tmp_rv; 5689 if (BCM_SUCCESS(tmp_rv)) { 5690 *value += tmp_val; 5691 } else { 5692 break; 5693 } 5694 } 5695 } 5696 5697 return rv; 5698 } 5699 5700 /* 5701 * Function: 5702 * bcmx_field_stat_multi_get 5703 * Description: 5704 * Get 64 bit counter values for multiple statistic types. 5705 * Parameters: 5706 * stat_id - Statistics entity id. 5707 * nstat - Number of elements in stat array. 5708 * stat_arr - Collected statistics descriptors array. 5709 * value_arr - (OUT) Collected counters values. 5710 * Returns: 5711 * BCM_E_XXX 5712 */ 5713 int 5714 bcmx_field_stat_multi_get(int stat_id, int nstat, 5715 bcm_field_stat_t *stat_arr, uint64 *value_arr) 5716 { 5717 int rv = BCM_E_UNAVAIL, tmp_rv; 5718 int i, bcm_unit; 5719 int j; 5720 uint64 *tmp_value_arr; 5721 5722 BCMX_FIELD_INIT_CHECK; 5723 5724 BCMX_PARAM_NULL_CHECK(stat_arr); 5725 BCMX_PARAM_NULL_CHECK(value_arr); 5726 5727 tmp_value_arr = sal_alloc(sizeof(uint64) * nstat, "BCMX field stat"); 5728 if (tmp_value_arr == NULL) { 5729 return BCM_E_MEMORY; 5730 } 5731 5732 for (j = 0; j < nstat; j++) { 5733 COMPILER_64_ZERO(value_arr[j]); 5734 } 5735 5736 /* Gather statistic values from all units */ 5737 BCMX_UNIT_ITER(bcm_unit, i) { 5738 tmp_rv = bcm_field_stat_multi_get(bcm_unit, stat_id, nstat, 5739 stat_arr, tmp_value_arr); 5740 5741 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, tmp_rv)) { 5742 rv = tmp_rv; 5743 if (BCM_SUCCESS(tmp_rv)) { 5744 for (j = 0; j < nstat; j++) { 5745 COMPILER_64_ADD_64(value_arr[j], tmp_value_arr[j]); 5746 } 5747 } else { 5748 break; 5749 } 5750 } 5751 } 5752 5753 sal_free(tmp_value_arr); 5754 5755 return rv; 5756 } 5757 5758 /* 5759 * Function: 5760 * bcmx_field_stat_multi_get32 5761 * Description: 5762 * Get lower 32 bit counter values for multiple statistic types. 5763 * Parameters: 5764 * stat_id - Statistics entity id. 5765 * nstat - Number of elements in stat array. 5766 * stat_arr - Collected statistics descriptors array. 5767 * value_arr - (OUT) Collected counters values. 5768 * Returns: 5769 * BCM_E_XXX 5770 */ 5771 int 5772 bcmx_field_stat_multi_get32(int stat_id, int nstat, 5773 bcm_field_stat_t *stat_arr, uint32 *value_arr) 5774 { 5775 int rv = BCM_E_UNAVAIL, tmp_rv; 5776 int i, bcm_unit; 5777 int j; 5778 uint32 *tmp_value_arr; 5779 5780 BCMX_FIELD_INIT_CHECK; 5781 5782 BCMX_PARAM_NULL_CHECK(stat_arr); 5783 BCMX_PARAM_NULL_CHECK(value_arr); 5784 5785 tmp_value_arr = sal_alloc(sizeof(uint32) * nstat, "BCMX field stat"); 5786 if (tmp_value_arr == NULL) { 5787 return BCM_E_MEMORY; 5788 } 5789 5790 for (j = 0; j < nstat; j++) { 5791 value_arr[j] = 0; 5792 } 5793 5794 /* Gather statistic values from all units */ 5795 BCMX_UNIT_ITER(bcm_unit, i) { 5796 tmp_rv = bcm_field_stat_multi_get32(bcm_unit, stat_id, nstat, 5797 stat_arr, tmp_value_arr); 5798 5799 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, tmp_rv)) { 5800 rv = tmp_rv; 5801 if (BCM_SUCCESS(tmp_rv)) { 5802 for (j = 0; j < nstat; j++) { 5803 value_arr[j] += tmp_value_arr[j]; 5804 } 5805 } else { 5806 break; 5807 } 5808 } 5809 } 5810 5811 sal_free(tmp_value_arr); 5812 5813 return rv; 5814 } 5815 5816 /* 5817 * Function: 5818 * bcmx_field_entry_stat_attach 5819 * Description: 5820 * Attach statistics entity to Field Processor entry. 5821 * Parameters: 5822 * entry - Field entry id. 5823 * stat_id - Statistics entity id. 5824 * Returns: 5825 * BCM_E_XXX 5826 */ 5827 int 5828 bcmx_field_entry_stat_attach(bcm_field_entry_t entry, int stat_id) 5829 { 5830 int rv = BCM_E_UNAVAIL, tmp_rv; 5831 int i, bcm_unit; 5832 5833 BCMX_FIELD_INIT_CHECK; 5834 5835 BCMX_UNIT_ITER(bcm_unit, i) { 5836 tmp_rv = bcm_field_entry_stat_attach(bcm_unit, entry, stat_id); 5837 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 5838 } 5839 5840 return rv; 5841 } 5842 5843 /* 5844 * Function: 5845 * bcmx_field_entry_stat_detach 5846 * Description: 5847 * Detach statistics entity from Field Processor entry. 5848 * Parameters: 5849 * entry - Field entry id. 5850 * stat_id - Statistics entity id. 5851 * Returns: 5852 * BCM_E_XXX 5853 */ 5854 int 5855 bcmx_field_entry_stat_detach(bcm_field_entry_t entry, int stat_id) 5856 { 5857 int rv = BCM_E_UNAVAIL, tmp_rv; 5858 int i, bcm_unit; 5859 5860 BCMX_FIELD_INIT_CHECK; 5861 5862 BCMX_UNIT_ITER(bcm_unit, i) { 5863 tmp_rv = bcm_field_entry_stat_detach(bcm_unit, entry, stat_id); 5864 BCM_IF_ERROR_RETURN 5865 (BCMX_FIELD_DELETE_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 5866 } 5867 5868 return rv; 5869 } 5870 5871 /* 5872 * Function: 5873 * bcmx_field_entry_stat_get 5874 * Description: 5875 * Get statistics entity attached to Field Processor entry. 5876 * Parameters: 5877 * entry - Field entry id. 5878 * stat_id - (OUT) Statistics entity id. 5879 * Returns: 5880 * BCM_E_XXX 5881 */ 5882 int 5883 bcmx_field_entry_stat_get(bcm_field_entry_t entry, int *stat_id) 5884 { 5885 int rv; 5886 int i, bcm_unit; 5887 5888 BCMX_FIELD_INIT_CHECK; 5889 5890 BCMX_PARAM_NULL_CHECK(stat_id); 5891 5892 BCMX_UNIT_ITER(bcm_unit, i) { 5893 rv = bcm_field_entry_stat_get(bcm_unit, entry, stat_id); 5894 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 5895 return rv; 5896 } 5897 } 5898 5899 return BCM_E_UNAVAIL; 5900 } 5901 5902 /* 5903 * Function: 5904 * bcmx_field_group_compress 5905 * Description: 5906 * Compresses field group entries. 5907 * Parameters: 5908 * group - Field group ID 5909 * Returns: 5910 * BCM_E_XXX - some error 5911 * BCM_E_NONE 5912 */ 5913 5914 int 5915 bcmx_field_group_compress(bcm_field_group_t group) 5916 { 5917 int rv = BCM_E_UNAVAIL, tmp_rv; 5918 int i, bcm_unit; 5919 5920 BCMX_FIELD_INIT_CHECK; 5921 5922 BCMX_UNIT_ITER(bcm_unit, i) { 5923 tmp_rv = bcm_field_group_compress(bcm_unit, group); 5924 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 5925 } 5926 5927 return rv; 5928 } 5929 5930 5931 /* 5932 * Function: 5933 * bcmx_field_group_priority_set 5934 * Description: 5935 * Set the group priority. 5936 * Parameters: 5937 * group - Group ID 5938 * Returns: 5939 * BCM_E_XXX 5940 * BCM_E_NONE 5941 */ 5942 5943 int 5944 bcmx_field_group_priority_set(bcm_field_group_t group, int priority) 5945 { 5946 int rv = BCM_E_UNAVAIL, tmp_rv; 5947 int i, bcm_unit; 5948 5949 BCMX_FIELD_INIT_CHECK; 5950 5951 BCMX_UNIT_ITER(bcm_unit, i) { 5952 tmp_rv = bcm_field_group_priority_set(bcm_unit, group, priority); 5953 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 5954 } 5955 5956 return rv; 5957 } 5958 5959 /* 5960 * Function: 5961 * bcmx_field_group_priority_get 5962 * Description: 5963 * Get the group priority. 5964 * Parameters: 5965 * group - Group ID 5966 * Returns: 5967 * BCM_E_XXX 5968 * BCM_E_NONE 5969 * Notes: 5970 * Get value from first successful call 5971 */ 5972 5973 int 5974 bcmx_field_group_priority_get(bcm_field_group_t group, int *priority) 5975 { 5976 int rv; 5977 int i, bcm_unit; 5978 5979 BCMX_FIELD_INIT_CHECK; 5980 5981 BCMX_PARAM_NULL_CHECK(priority); 5982 5983 BCMX_UNIT_ITER(bcm_unit, i) { 5984 rv = bcm_field_group_priority_get(bcm_unit, group, priority); 5985 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 5986 return rv; 5987 } 5988 } 5989 5990 return BCM_E_UNAVAIL; 5991 } 5992 5993 void bcmx_field_data_qualifier_t_init(bcmx_field_data_qualifier_t *data_qual) 5994 { 5995 bcm_field_data_qualifier_t_init((bcm_field_data_qualifier_t *)data_qual); 5996 } 5997 5998 void bcmx_field_data_ethertype_t_init(bcmx_field_data_ethertype_t *etype) 5999 { 6000 bcm_field_data_ethertype_t_init((bcm_field_data_ethertype_t *)etype); 6001 } 6002 6003 6004 void bcmx_field_data_ip_protocol_t_init(bcmx_field_data_ip_protocol_t 6005 *ip_protocol) 6006 { 6007 bcm_field_data_ip_protocol_t_init 6008 ((bcm_field_data_ip_protocol_t *)ip_protocol); 6009 } 6010 6011 void bcmx_field_data_packet_format_t_init(bcmx_field_data_packet_format_t 6012 *packet_format) 6013 { 6014 bcm_field_data_packet_format_t_init 6015 ((bcm_field_data_packet_format_t *)packet_format); 6016 } 6017 6018 int bcmx_field_data_qualifier_create(bcmx_field_data_qualifier_t 6019 *data_qualifier) 6020 { 6021 int rv = BCM_E_UNAVAIL, tmp_rv; 6022 int i; 6023 int bcm_unit; 6024 uint32 flags_orig; 6025 6026 BCMX_FIELD_INIT_CHECK; 6027 6028 BCMX_PARAM_NULL_CHECK(data_qualifier); 6029 6030 /* Store original 'xxx_WITH_ID' flag bit */ 6031 flags_orig = data_qualifier->flags & BCM_FIELD_DATA_QUALIFIER_WITH_ID; 6032 6033 BCMX_UNIT_ITER(bcm_unit, i) { 6034 tmp_rv = bcm_field_data_qualifier_create(bcm_unit,data_qualifier); 6035 if (BCM_FAILURE(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv))) { 6036 break; 6037 } 6038 6039 /* 6040 * If qualifier id is not specified, use returned id from 6041 * first successful 'create' for remaining units. 6042 */ 6043 if (!(data_qualifier->flags & BCM_FIELD_DATA_QUALIFIER_WITH_ID)) { 6044 if (BCM_SUCCESS(tmp_rv)) { 6045 data_qualifier->flags |= BCM_FIELD_DATA_QUALIFIER_WITH_ID; 6046 } 6047 } 6048 } 6049 6050 /* Restore 'xxx_WITH_ID' flag bit */ 6051 data_qualifier->flags &= ~BCM_FIELD_DATA_QUALIFIER_WITH_ID; 6052 data_qualifier->flags |= flags_orig; 6053 6054 return rv; 6055 } 6056 6057 /* 6058 * Function: 6059 * bcmx_field_data_qualifier_multi_get 6060 * Purpose: 6061 * Return list of ids of defined data qualifiers. 6062 * Parameters: 6063 * qual_size - (IN) Size of given qualifier id array; if 0, indicates 6064 * return count of data qualifiers only. 6065 * qual_array - (OUT) Base of array where to store returned data qualifier 6066 * ids. 6067 * qual_count - (OUT) Number of qualifier ids stored in above array; if 6068 * qual_size was given as 0, then number of defined 6069 * qualifiers. 6070 * Returns: 6071 * BCM_E_XXX 6072 */ 6073 int 6074 bcmx_field_data_qualifier_multi_get(int qual_size, 6075 int *qual_array, int *qual_count) 6076 { 6077 int rv; 6078 int i, bcm_unit; 6079 6080 BCMX_FIELD_INIT_CHECK; 6081 6082 BCMX_PARAM_ARRAY_NULL_CHECK(qual_size, qual_array); 6083 BCMX_PARAM_NULL_CHECK(qual_count); 6084 6085 /* 6086 * No need to gather qualifier ids from all units. BCMX assumes 6087 * that field qualifier ids were created with BCMX APIs. 6088 */ 6089 BCMX_UNIT_ITER(bcm_unit, i) { 6090 rv = bcm_field_data_qualifier_multi_get(bcm_unit, qual_size, 6091 qual_array, qual_count); 6092 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 6093 return rv; 6094 } 6095 } 6096 6097 return BCM_E_UNAVAIL; 6098 } 6099 6100 /* 6101 * Function: 6102 * bcmx_field_data_qualifier_get 6103 * Purpose: 6104 * Return configuration of given data qualifier. 6105 * Parameters: 6106 * qual_id - (IN) Id of data qualifier. 6107 * qual - (OUT) Attributes of given data qualifier. 6108 * Returns: 6109 * BCM_E_XXX 6110 */ 6111 int 6112 bcmx_field_data_qualifier_get(int qual_id, 6113 bcmx_field_data_qualifier_t *qual) 6114 { 6115 int rv; 6116 int i, bcm_unit; 6117 6118 BCMX_FIELD_INIT_CHECK; 6119 6120 BCMX_PARAM_NULL_CHECK(qual); 6121 6122 BCMX_UNIT_ITER(bcm_unit, i) { 6123 rv = bcm_field_data_qualifier_get(bcm_unit, qual_id, 6124 (bcm_field_data_qualifier_t *)qual); 6125 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 6126 return rv; 6127 } 6128 } 6129 6130 return BCM_E_UNAVAIL; 6131 } 6132 6133 6134 int bcmx_field_data_qualifier_destroy(int qual_id) 6135 { 6136 int rv = BCM_E_UNAVAIL, tmp_rv; 6137 int i, bcm_unit; 6138 6139 BCMX_FIELD_INIT_CHECK; 6140 6141 BCMX_UNIT_ITER(bcm_unit, i) { 6142 tmp_rv = bcm_field_data_qualifier_destroy(bcm_unit, qual_id); 6143 BCM_IF_ERROR_RETURN 6144 (BCMX_FIELD_DELETE_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 6145 } 6146 6147 return rv; 6148 } 6149 6150 int bcmx_field_data_qualifier_destroy_all(void) 6151 { 6152 int rv = BCM_E_UNAVAIL, tmp_rv; 6153 int i, bcm_unit; 6154 6155 BCMX_FIELD_INIT_CHECK; 6156 6157 BCMX_UNIT_ITER(bcm_unit, i) { 6158 tmp_rv = bcm_field_data_qualifier_destroy_all(bcm_unit); 6159 BCM_IF_ERROR_RETURN 6160 (BCMX_FIELD_DELETE_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 6161 } 6162 6163 return rv; 6164 } 6165 6166 int bcmx_field_data_qualifier_ethertype_add(int qual_id, 6167 bcmx_field_data_ethertype_t *etype) 6168 { 6169 int rv = BCM_E_UNAVAIL, tmp_rv; 6170 int i, bcm_unit; 6171 6172 BCMX_FIELD_INIT_CHECK; 6173 6174 BCMX_PARAM_NULL_CHECK(etype); 6175 6176 BCMX_UNIT_ITER(bcm_unit, i) { 6177 tmp_rv = bcm_field_data_qualifier_ethertype_add 6178 (bcm_unit, qual_id, (bcm_field_data_ethertype_t *)etype); 6179 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 6180 } 6181 6182 return rv; 6183 } 6184 6185 int bcmx_field_data_qualifier_ethertype_delete(int qual_id, 6186 bcmx_field_data_ethertype_t 6187 *etype) 6188 { 6189 int rv = BCM_E_UNAVAIL, tmp_rv; 6190 int i, bcm_unit; 6191 6192 BCMX_FIELD_INIT_CHECK; 6193 6194 BCMX_PARAM_NULL_CHECK(etype); 6195 6196 BCMX_UNIT_ITER(bcm_unit, i) { 6197 tmp_rv = bcm_field_data_qualifier_ethertype_delete 6198 (bcm_unit, qual_id, (bcm_field_data_ethertype_t *)etype); 6199 BCM_IF_ERROR_RETURN 6200 (BCMX_FIELD_DELETE_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 6201 } 6202 6203 return rv; 6204 } 6205 6206 int bcmx_field_data_qualifier_ip_protocol_add(int qual_id, 6207 bcmx_field_data_ip_protocol_t 6208 *ip_protocol) 6209 { 6210 int rv = BCM_E_UNAVAIL, tmp_rv; 6211 int i, bcm_unit; 6212 6213 BCMX_FIELD_INIT_CHECK; 6214 6215 BCMX_PARAM_NULL_CHECK(ip_protocol); 6216 6217 BCMX_UNIT_ITER(bcm_unit, i) { 6218 tmp_rv = bcm_field_data_qualifier_ip_protocol_add 6219 (bcm_unit, qual_id, (bcm_field_data_ip_protocol_t *)ip_protocol); 6220 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 6221 } 6222 6223 return rv; 6224 } 6225 6226 int bcmx_field_data_qualifier_ip_protocol_delete(int qual_id, 6227 bcmx_field_data_ip_protocol_t 6228 *ip_protocol) 6229 { 6230 int rv = BCM_E_UNAVAIL, tmp_rv; 6231 int i, bcm_unit; 6232 6233 BCMX_FIELD_INIT_CHECK; 6234 6235 BCMX_PARAM_NULL_CHECK(ip_protocol); 6236 6237 BCMX_UNIT_ITER(bcm_unit, i) { 6238 tmp_rv = bcm_field_data_qualifier_ip_protocol_delete 6239 (bcm_unit, qual_id, (bcm_field_data_ip_protocol_t *)ip_protocol); 6240 BCM_IF_ERROR_RETURN 6241 (BCMX_FIELD_DELETE_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 6242 } 6243 6244 return rv; 6245 } 6246 6247 int bcmx_field_data_qualifier_packet_format_add(int qual_id, 6248 bcmx_field_data_packet_format_t 6249 *packet_format) 6250 { 6251 int rv = BCM_E_UNAVAIL, tmp_rv; 6252 int i, bcm_unit; 6253 6254 BCMX_FIELD_INIT_CHECK; 6255 6256 BCMX_PARAM_NULL_CHECK(packet_format); 6257 6258 BCMX_UNIT_ITER(bcm_unit, i) { 6259 tmp_rv = bcm_field_data_qualifier_packet_format_add 6260 (bcm_unit, qual_id, 6261 (bcm_field_data_packet_format_t *)packet_format); 6262 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 6263 } 6264 6265 return rv; 6266 } 6267 6268 int bcmx_field_data_qualifier_packet_format_delete(int qual_id, 6269 bcmx_field_data_packet_format_t *packet_format) 6270 { 6271 int rv = BCM_E_UNAVAIL, tmp_rv; 6272 int i, bcm_unit; 6273 6274 BCMX_FIELD_INIT_CHECK; 6275 6276 BCMX_PARAM_NULL_CHECK(packet_format); 6277 6278 BCMX_UNIT_ITER(bcm_unit, i) { 6279 tmp_rv = bcm_field_data_qualifier_packet_format_delete 6280 (bcm_unit, qual_id, 6281 (bcm_field_data_packet_format_t *)packet_format); 6282 BCM_IF_ERROR_RETURN 6283 (BCMX_FIELD_DELETE_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 6284 } 6285 6286 return rv; 6287 } 6288 6289 int bcmx_field_qset_data_qualifier_add(bcm_field_qset_t *qset, int qual_id) 6290 { 6291 int rv = BCM_E_UNAVAIL, tmp_rv; 6292 int i, bcm_unit; 6293 6294 BCMX_FIELD_INIT_CHECK; 6295 6296 BCMX_PARAM_NULL_CHECK(qset); 6297 6298 BCMX_UNIT_ITER(bcm_unit, i) { 6299 tmp_rv = bcm_field_qset_data_qualifier_add(bcm_unit, qset, qual_id); 6300 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 6301 } 6302 6303 return rv; 6304 } 6305 6306 int bcmx_field_qualify_data(bcm_field_entry_t eid, int qual_id, 6307 uint8 *data, uint8 *mask, uint16 length) 6308 { 6309 int rv = BCM_E_UNAVAIL, tmp_rv; 6310 int i, bcm_unit; 6311 6312 BCMX_FIELD_INIT_CHECK; 6313 6314 BCMX_PARAM_NULL_CHECK(data); 6315 BCMX_PARAM_NULL_CHECK(mask); 6316 6317 BCMX_UNIT_ITER(bcm_unit, i) { 6318 tmp_rv = bcm_field_qualify_data(bcm_unit, eid, qual_id, 6319 data, mask, length); 6320 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 6321 } 6322 6323 return rv; 6324 } 6325 6326 /* 6327 * Function: 6328 * bcmx_field_qset_data_qualifier_get 6329 */ 6330 int 6331 bcmx_field_qset_data_qualifier_get(bcm_field_qset_t *qset, 6332 int qual_max, int *qual_arr, 6333 int *qual_count) 6334 { 6335 int rv; 6336 int i, bcm_unit; 6337 6338 BCMX_FIELD_INIT_CHECK; 6339 6340 BCMX_PARAM_NULL_CHECK(qset); 6341 BCMX_PARAM_NULL_CHECK(qual_count); 6342 BCMX_PARAM_ARRAY_NULL_CHECK(qual_max, qual_arr); 6343 6344 BCMX_UNIT_ITER(bcm_unit, i) { 6345 rv = bcm_field_qset_data_qualifier_get(bcm_unit, *qset, 6346 qual_max, qual_arr, 6347 qual_count); 6348 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 6349 return rv; 6350 } 6351 } 6352 6353 return BCM_E_UNAVAIL; 6354 } 6355 6356 6357 /* 6358 * Function: 6359 * bcmx_field_qualify_LoopbackType_get 6360 * Purpose: 6361 * Get loopback type field qualification from a field entry. 6362 * Parameters: 6363 * entry - (IN) Field entry id. 6364 * loopback_type - (OUT) Loopback type. 6365 * Returns: 6366 * BCM_E_XXX 6367 * Notes: 6368 */ 6369 int 6370 bcmx_field_qualify_LoopbackType_get(bcm_field_entry_t entry, 6371 bcm_field_LoopbackType_t *loopback_type) 6372 { 6373 int rv; 6374 int i, bcm_unit; 6375 6376 BCMX_FIELD_INIT_CHECK; 6377 6378 BCMX_PARAM_NULL_CHECK(loopback_type); 6379 6380 BCMX_UNIT_ITER(bcm_unit, i) { 6381 rv = bcm_field_qualify_LoopbackType_get(bcm_unit, entry, loopback_type); 6382 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 6383 return rv; 6384 } 6385 } 6386 6387 return BCM_E_UNAVAIL; 6388 } 6389 6390 /* 6391 * Function: 6392 * bcmx_field_qualify_TunnelType_get 6393 * Purpose: 6394 * Get tunnel type field qualification from a field entry. 6395 * Parameters: 6396 * entry - (IN) Field entry id. 6397 * tunnel_type - (OUT) Tunnel type. 6398 * Returns: 6399 * BCM_E_XXX 6400 * Notes: 6401 */ 6402 int 6403 bcmx_field_qualify_TunnelType_get(bcm_field_entry_t entry, 6404 bcm_field_TunnelType_t *tunnel_type) 6405 { 6406 int rv; 6407 int i, bcm_unit; 6408 6409 BCMX_FIELD_INIT_CHECK; 6410 6411 BCMX_PARAM_NULL_CHECK(tunnel_type); 6412 6413 BCMX_UNIT_ITER(bcm_unit, i) { 6414 rv = bcm_field_qualify_TunnelType_get(bcm_unit, entry, tunnel_type); 6415 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 6416 return rv; 6417 } 6418 } 6419 6420 return BCM_E_UNAVAIL; 6421 } 6422 6423 /* 6424 * Function: 6425 * bcmx_field_qualify_DstL3Egress_get 6426 * Purpose: 6427 * Get match criteria for bcmFieldQualifyDstL3Egress 6428 * qualifier from the field entry. 6429 * Parameters: 6430 * entry - (IN) BCM field entry id. 6431 * if_id - (OUT) L3 forwarding object. 6432 * Returns: 6433 * BCM_E_XXX 6434 * Notes: 6435 */ 6436 int 6437 bcmx_field_qualify_DstL3Egress_get(bcm_field_entry_t entry, 6438 bcm_if_t *if_id) 6439 { 6440 int rv; 6441 int i, bcm_unit; 6442 6443 BCMX_FIELD_INIT_CHECK; 6444 6445 BCMX_PARAM_NULL_CHECK(if_id); 6446 6447 BCMX_UNIT_ITER(bcm_unit, i) { 6448 rv = bcm_field_qualify_DstL3Egress_get(bcm_unit, entry, if_id); 6449 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 6450 return rv; 6451 } 6452 } 6453 6454 return BCM_E_UNAVAIL; 6455 } 6456 6457 /* 6458 * Function: 6459 * bcmx_field_qualify_DstMulticastGroup_get 6460 * Purpose: 6461 * Get match criteria for bcmFieldQualifyDstMulticastGroup 6462 * qualifier from the field entry. 6463 * Parameters: 6464 * entry - (IN) BCM field entry id. 6465 * group - (OUT) Multicast group id. 6466 * Returns: 6467 * BCM_E_XXX 6468 * Notes: 6469 */ 6470 int 6471 bcmx_field_qualify_DstMulticastGroup_get(bcm_field_entry_t entry, 6472 bcm_multicast_t *group) 6473 { 6474 int rv; 6475 int i, bcm_unit; 6476 6477 BCMX_FIELD_INIT_CHECK; 6478 6479 BCMX_PARAM_NULL_CHECK(group); 6480 6481 BCMX_UNIT_ITER(bcm_unit, i) { 6482 rv = bcm_field_qualify_DstMulticastGroup_get(bcm_unit, entry, group); 6483 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 6484 return rv; 6485 } 6486 } 6487 6488 return BCM_E_UNAVAIL; 6489 } 6490 6491 /* 6492 * Function: 6493 * bcmx_field_qualify_Color_get 6494 * Purpose: 6495 * Get match criteria for bcmFieldQualifyColor 6496 * qualifier from the field entry. 6497 * Parameters: 6498 * entry - (IN) BCM field entry id. 6499 * color - (OUT) Qualifier match color. 6500 * Returns: 6501 * BCM_E_XXX 6502 * Notes: 6503 */ 6504 int 6505 bcmx_field_qualify_Color_get(bcm_field_entry_t entry, uint8 *color) 6506 { 6507 int rv; 6508 int i, bcm_unit; 6509 6510 BCMX_FIELD_INIT_CHECK; 6511 6512 BCMX_PARAM_NULL_CHECK(color); 6513 6514 BCMX_UNIT_ITER(bcm_unit, i) { 6515 rv = bcm_field_qualify_Color_get(bcm_unit, entry, color); 6516 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 6517 return rv; 6518 } 6519 } 6520 6521 return BCM_E_UNAVAIL; 6522 } 6523 6524 /* 6525 * Function: 6526 * bcmx_field_qualify_IntPriority_get 6527 * Purpose: 6528 * Get match criteria for bcmFieldQualifyIntPriority 6529 * qualifier from the field entry. 6530 * Parameters: 6531 * entry - (IN) BCM field entry id. 6532 * data - (OUT) Qualifier match data. 6533 * mask - (OUT) Qualifier match mask. 6534 * Returns: 6535 * BCM_E_XXX 6536 * Notes: 6537 */ 6538 int 6539 bcmx_field_qualify_IntPriority_get(bcm_field_entry_t entry, 6540 uint8 *data, uint8 *mask) 6541 { 6542 int rv; 6543 int i, bcm_unit; 6544 6545 BCMX_FIELD_INIT_CHECK; 6546 6547 BCMX_PARAM_NULL_CHECK(data); 6548 BCMX_PARAM_NULL_CHECK(mask); 6549 6550 BCMX_UNIT_ITER(bcm_unit, i) { 6551 rv = bcm_field_qualify_IntPriority_get(bcm_unit, entry, data, mask); 6552 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 6553 return rv; 6554 } 6555 } 6556 6557 return BCM_E_UNAVAIL; 6558 } 6559 6560 /* 6561 * Function: 6562 * bcmx_field_qualify_SrcModPortGport_get 6563 * Purpose: 6564 * Get match criteria for bcmFieldQualifySrcModPortGport 6565 * qualifier from the field entry. 6566 * Parameters: 6567 * entry - (IN) BCM field entry id. 6568 * data - (OUT) Mod/port gport id. 6569 * Returns: 6570 * BCM_E_XXX 6571 * Notes: 6572 */ 6573 int 6574 bcmx_field_qualify_SrcModPortGport_get(bcm_field_entry_t entry, 6575 bcm_gport_t *data) 6576 { 6577 int rv; 6578 int i, bcm_unit; 6579 6580 BCMX_FIELD_INIT_CHECK; 6581 6582 BCMX_PARAM_NULL_CHECK(data); 6583 6584 BCMX_UNIT_ITER(bcm_unit, i) { 6585 rv = bcm_field_qualify_SrcModPortGport_get(bcm_unit, entry, data); 6586 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 6587 return rv; 6588 } 6589 } 6590 6591 return BCM_E_UNAVAIL; 6592 } 6593 6594 /* 6595 * Function: 6596 * bcmx_field_qualify_SrcModuleGport_get 6597 * Purpose: 6598 * Get match criteria for bcmFieldQualifySrcModuleGport 6599 * qualifier from the field entry. 6600 * Parameters: 6601 * entry - (IN) BCM field entry id. 6602 * data - (OUT) Mod/port gport id. 6603 * Returns: 6604 * BCM_E_XXX 6605 * Notes: 6606 */ 6607 int 6608 bcmx_field_qualify_SrcModuleGport_get(bcm_field_entry_t entry, 6609 bcm_gport_t *data) 6610 { 6611 int rv; 6612 int i, bcm_unit; 6613 6614 BCMX_FIELD_INIT_CHECK; 6615 6616 BCMX_PARAM_NULL_CHECK(data); 6617 6618 BCMX_UNIT_ITER(bcm_unit, i) { 6619 rv = bcm_field_qualify_SrcModuleGport_get(bcm_unit, entry, data); 6620 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 6621 return rv; 6622 } 6623 } 6624 6625 return BCM_E_UNAVAIL; 6626 } 6627 6628 /* 6629 * Function: 6630 * bcmx_field_qualify_SrcMplsGport_get 6631 * Purpose: 6632 * Get match criteria for bcmFieldQualifySrcMplsGport 6633 * qualifier from the field entry. 6634 * Parameters: 6635 * entry - (IN) BCM field entry id. 6636 * mpls_port_id - (OUT) Mpls port id. 6637 * Returns: 6638 * BCM_E_XXX 6639 * Notes: 6640 */ 6641 int 6642 bcmx_field_qualify_SrcMplsGport_get(bcm_field_entry_t entry, 6643 bcm_gport_t *mpls_port_id) 6644 { 6645 int rv; 6646 int i, bcm_unit; 6647 6648 BCMX_FIELD_INIT_CHECK; 6649 6650 BCMX_PARAM_NULL_CHECK(mpls_port_id); 6651 6652 BCMX_UNIT_ITER(bcm_unit, i) { 6653 rv = bcm_field_qualify_SrcMplsGport_get(bcm_unit, entry, mpls_port_id); 6654 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 6655 return rv; 6656 } 6657 } 6658 6659 return BCM_E_UNAVAIL; 6660 } 6661 6662 6663 /* 6664 * Function: 6665 * bcmx_field_qualify_DstMplsGport_get 6666 * Purpose: 6667 * Get match criteria for bcmFieldQualifyDstMplsGport 6668 * qualifier from the field entry. 6669 * Parameters: 6670 * entry - (IN) BCM field entry id. 6671 * mpls_port_id - (OUT) Mpls port id. 6672 * Returns: 6673 * BCM_E_XXX 6674 * Notes: 6675 */ 6676 int 6677 bcmx_field_qualify_DstMplsGport_get(bcm_field_entry_t entry, 6678 bcm_gport_t *mpls_port_id) 6679 { 6680 int rv; 6681 int i, bcm_unit; 6682 6683 BCMX_FIELD_INIT_CHECK; 6684 6685 BCMX_PARAM_NULL_CHECK(mpls_port_id); 6686 6687 BCMX_UNIT_ITER(bcm_unit, i) { 6688 rv = bcm_field_qualify_DstMplsGport_get(bcm_unit, entry, mpls_port_id); 6689 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 6690 return rv; 6691 } 6692 } 6693 6694 return BCM_E_UNAVAIL; 6695 } 6696 6697 /* 6698 * Function: 6699 * bcmx_field_qualify_SrcMimGport_get 6700 * Purpose: 6701 * Get match criteria for bcmFieldQualifySrcMimGport 6702 * qualifier from the field entry. 6703 * Parameters: 6704 * entry - (IN) BCM field entry id. 6705 * mim_port_id - (OUT) Mim port id. 6706 * Returns: 6707 * BCM_E_XXX 6708 * Notes: 6709 */ 6710 int 6711 bcmx_field_qualify_SrcMimGport_get(bcm_field_entry_t entry, 6712 bcm_gport_t *mim_port_id) 6713 { 6714 int rv; 6715 int i, bcm_unit; 6716 6717 BCMX_FIELD_INIT_CHECK; 6718 6719 BCMX_PARAM_NULL_CHECK(mim_port_id); 6720 6721 BCMX_UNIT_ITER(bcm_unit, i) { 6722 rv = bcm_field_qualify_SrcMimGport_get(bcm_unit, entry, mim_port_id); 6723 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 6724 return rv; 6725 } 6726 } 6727 6728 return BCM_E_UNAVAIL; 6729 } 6730 6731 /* 6732 * Function: 6733 * bcmx_field_qualify_DstMimGport_get 6734 * Purpose: 6735 * Get match criteria for bcmFieldQualifyDstMimGport 6736 * qualifier from the field entry. 6737 * Parameters: 6738 * entry - (IN) BCM field entry id. 6739 * mim_port_id - (OUT) Mim port id. 6740 * Returns: 6741 * BCM_E_XXX 6742 * Notes: 6743 */ 6744 int 6745 bcmx_field_qualify_DstMimGport_get(bcm_field_entry_t entry, 6746 bcm_gport_t *mim_port_id) 6747 { 6748 int rv; 6749 int i, bcm_unit; 6750 6751 BCMX_FIELD_INIT_CHECK; 6752 6753 BCMX_PARAM_NULL_CHECK(mim_port_id); 6754 6755 BCMX_UNIT_ITER(bcm_unit, i) { 6756 rv = bcm_field_qualify_DstMimGport_get(bcm_unit, entry, mim_port_id); 6757 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 6758 return rv; 6759 } 6760 } 6761 6762 return BCM_E_UNAVAIL; 6763 } 6764 6765 /* 6766 * Function: 6767 * bcmx_field_qualify_SrcWlanGport_get 6768 * Purpose: 6769 * Get match criteria for bcmFieldQualifySrcWlanGport 6770 * qualifier from the field entry. 6771 * Parameters: 6772 * entry - (IN) BCM field entry id. 6773 * wlan_port_id - (OUT) Wlan port id. 6774 * Returns: 6775 * BCM_E_XXX 6776 * Notes: 6777 */ 6778 int 6779 bcmx_field_qualify_SrcWlanGport_get(bcm_field_entry_t entry, 6780 bcm_gport_t *wlan_port_id) 6781 { 6782 int rv; 6783 int i, bcm_unit; 6784 6785 BCMX_FIELD_INIT_CHECK; 6786 6787 BCMX_PARAM_NULL_CHECK(wlan_port_id); 6788 6789 BCMX_UNIT_ITER(bcm_unit, i) { 6790 rv = bcm_field_qualify_SrcWlanGport_get(bcm_unit, entry, wlan_port_id); 6791 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 6792 return rv; 6793 } 6794 } 6795 6796 return BCM_E_UNAVAIL; 6797 } 6798 6799 /* 6800 * Function: 6801 * bcmx_field_qualify_DstWlanGport_get 6802 * Purpose: 6803 * Get match criteria for bcmFieldQualifyDstWlanGport 6804 * qualifier from the field entry. 6805 * Parameters: 6806 * entry - (IN) BCM field entry id. 6807 * wlan_port_id - (OUT) Wlan port id. 6808 * Returns: 6809 * BCM_E_XXX 6810 * Notes: 6811 */ 6812 int 6813 bcmx_field_qualify_DstWlanGport_get(bcm_field_entry_t entry, 6814 bcm_gport_t *wlan_port_id) 6815 { 6816 int rv; 6817 int i, bcm_unit; 6818 6819 BCMX_FIELD_INIT_CHECK; 6820 6821 BCMX_PARAM_NULL_CHECK(wlan_port_id); 6822 6823 BCMX_UNIT_ITER(bcm_unit, i) { 6824 rv = bcm_field_qualify_DstWlanGport_get(bcm_unit, entry, wlan_port_id); 6825 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 6826 return rv; 6827 } 6828 } 6829 6830 return BCM_E_UNAVAIL; 6831 } 6832 6833 /* 6834 * Function: 6835 * bcmx_field_qualify_Loopback_get 6836 * Purpose: 6837 * Get loopback field qualification from a field entry. 6838 * Parameters: 6839 * entry - (IN) Field entry id. 6840 * data - (OUT) Data to qualify with. 6841 * mask - (OUT) Qualifier match mask. 6842 * Returns: 6843 * BCM_E_XXX 6844 * Notes: 6845 */ 6846 int 6847 bcmx_field_qualify_Loopback_get(bcm_field_entry_t entry, 6848 uint8 *data, 6849 uint8 *mask) 6850 { 6851 int rv; 6852 int i, bcm_unit; 6853 6854 BCMX_FIELD_INIT_CHECK; 6855 6856 BCMX_PARAM_NULL_CHECK(data); 6857 BCMX_PARAM_NULL_CHECK(mask); 6858 6859 BCMX_UNIT_ITER(bcm_unit, i) { 6860 rv = bcm_field_qualify_Loopback_get(bcm_unit, entry, data, mask); 6861 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 6862 return rv; 6863 } 6864 } 6865 6866 return BCM_E_UNAVAIL; 6867 } 6868 6869 /* 6870 * Function: 6871 * bcmx_field_qualify_InPort_get 6872 * Purpose: 6873 * Get match criteria for bcmFieldQualifyInPort 6874 * qualifier from the field entry. 6875 * Parameters: 6876 * entry - (IN) BCM field entry id. 6877 * data - (OUT) Qualifier match data. 6878 * mask - (OUT) Qualifier match mask. 6879 * Returns: 6880 * BCM_E_XXX 6881 * Notes: 6882 */ 6883 int 6884 bcmx_field_qualify_InPort_get(bcm_field_entry_t entry, 6885 bcm_port_t *data, 6886 bcm_port_t *mask) 6887 { 6888 int rv; 6889 int i, bcm_unit; 6890 6891 BCMX_FIELD_INIT_CHECK; 6892 6893 BCMX_PARAM_NULL_CHECK(data); 6894 BCMX_PARAM_NULL_CHECK(mask); 6895 6896 BCMX_UNIT_ITER(bcm_unit, i) { 6897 rv = bcm_field_qualify_InPort_get(bcm_unit, entry, data, mask); 6898 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 6899 return rv; 6900 } 6901 } 6902 6903 return BCM_E_UNAVAIL; 6904 } 6905 6906 /* 6907 * Function: 6908 * bcmx_field_qualify_OutPort_get 6909 * Purpose: 6910 * Get match criteria for bcmFieldQualifyOutPort 6911 * qualifier from the field entry. 6912 * Parameters: 6913 * entry - (IN) BCM field entry id. 6914 * data - (OUT) Qualifier match data. 6915 * mask - (OUT) Qualifier match mask. 6916 * Returns: 6917 * BCM_E_XXX 6918 * Notes: 6919 */ 6920 int 6921 bcmx_field_qualify_OutPort_get(bcm_field_entry_t entry, 6922 bcm_port_t *data, 6923 bcm_port_t *mask) 6924 { 6925 int rv; 6926 int i, bcm_unit; 6927 6928 BCMX_FIELD_INIT_CHECK; 6929 6930 BCMX_PARAM_NULL_CHECK(data); 6931 BCMX_PARAM_NULL_CHECK(mask); 6932 6933 BCMX_UNIT_ITER(bcm_unit, i) { 6934 rv = bcm_field_qualify_OutPort_get(bcm_unit, entry, data, mask); 6935 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 6936 return rv; 6937 } 6938 } 6939 6940 return BCM_E_UNAVAIL; 6941 } 6942 6943 /* 6944 * Function: 6945 * bcmx_field_qualify_InPorts_get 6946 * Purpose: 6947 * Get match criteria for bcmFieldQualifyInPorts 6948 * qualifier from the field entry. 6949 * Parameters: 6950 * entry - (IN) BCM field entry id. 6951 * data - (OUT) Qualifier match data. 6952 * mask - (OUT) Qualifier match mask. 6953 * Returns: 6954 * BCM_E_XXX 6955 * Notes: 6956 */ 6957 int 6958 bcmx_field_qualify_InPorts_get(bcm_field_entry_t entry, 6959 bcm_pbmp_t *data, 6960 bcm_pbmp_t *mask) 6961 { 6962 int rv; 6963 int i, bcm_unit; 6964 6965 BCMX_FIELD_INIT_CHECK; 6966 6967 BCMX_PARAM_NULL_CHECK(data); 6968 BCMX_PARAM_NULL_CHECK(mask); 6969 6970 BCMX_UNIT_ITER(bcm_unit, i) { 6971 rv = bcm_field_qualify_InPorts_get(bcm_unit, entry, data, mask); 6972 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 6973 return rv; 6974 } 6975 } 6976 6977 return BCM_E_UNAVAIL; 6978 } 6979 6980 /* 6981 * Function: 6982 * bcmx_field_qualify_OutPorts_get 6983 * Purpose: 6984 * Get match criteria for bcmFieldQualifyOutPorts 6985 * qualifier from the field entry. 6986 * Parameters: 6987 * entry - (IN) BCM field entry id. 6988 * data - (OUT) Qualifier match data. 6989 * mask - (OUT) Qualifier match mask. 6990 * Returns: 6991 * BCM_E_XXX 6992 * Notes: 6993 */ 6994 int 6995 bcmx_field_qualify_OutPorts_get(bcm_field_entry_t entry, 6996 bcm_pbmp_t *data, 6997 bcm_pbmp_t *mask) 6998 { 6999 int rv; 7000 int i, bcm_unit; 7001 7002 BCMX_FIELD_INIT_CHECK; 7003 7004 BCMX_PARAM_NULL_CHECK(data); 7005 BCMX_PARAM_NULL_CHECK(mask); 7006 7007 BCMX_UNIT_ITER(bcm_unit, i) { 7008 rv = bcm_field_qualify_OutPorts_get(bcm_unit, entry, data, mask); 7009 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 7010 return rv; 7011 } 7012 } 7013 7014 return BCM_E_UNAVAIL; 7015 } 7016 7017 /* 7018 * Function: 7019 * bcmx_field_qualify_Drop_get 7020 * Purpose: 7021 * Get match criteria for bcmFieldQualifyDrop 7022 * qualifier from the field entry. 7023 * Parameters: 7024 * entry - (IN) BCM field entry id. 7025 * data - (OUT) Qualifier match data. 7026 * mask - (OUT) Qualifier match mask. 7027 * Returns: 7028 * BCM_E_XXX 7029 * Notes: 7030 */ 7031 int 7032 bcmx_field_qualify_Drop_get(bcm_field_entry_t entry, 7033 uint8 *data, 7034 uint8 *mask) 7035 { 7036 int rv; 7037 int i, bcm_unit; 7038 7039 BCMX_FIELD_INIT_CHECK; 7040 7041 BCMX_PARAM_NULL_CHECK(data); 7042 BCMX_PARAM_NULL_CHECK(mask); 7043 7044 BCMX_UNIT_ITER(bcm_unit, i) { 7045 rv = bcm_field_qualify_Drop_get(bcm_unit, entry, data, mask); 7046 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 7047 return rv; 7048 } 7049 } 7050 7051 return BCM_E_UNAVAIL; 7052 } 7053 7054 /* 7055 * Function: 7056 * bcmx_field_qualify_SrcPort_get 7057 * Purpose: 7058 * Get match criteria for bcmFieldQualifySrcPort 7059 * qualifier from the field entry. 7060 * Parameters: 7061 * entry - (IN) BCM field entry id. 7062 * data_modid - (OUT) Qualifier module id. 7063 * mask_modid - (OUT) Qualifier module id mask. 7064 * data_port - (OUT) Qualifier port id. 7065 * mask_port - (OUT) Qualifier port id mask. 7066 * Returns: 7067 * BCM_E_XXX 7068 * Notes: 7069 */ 7070 int 7071 bcmx_field_qualify_SrcPort_get(bcm_field_entry_t entry, 7072 bcm_module_t *data_modid, 7073 bcm_module_t *mask_modid, 7074 bcm_port_t *data_port, 7075 bcm_port_t *mask_port) 7076 { 7077 int rv; 7078 int i, bcm_unit; 7079 7080 BCMX_FIELD_INIT_CHECK; 7081 7082 BCMX_PARAM_NULL_CHECK(data_modid); 7083 BCMX_PARAM_NULL_CHECK(mask_modid); 7084 BCMX_PARAM_NULL_CHECK(data_port); 7085 BCMX_PARAM_NULL_CHECK(mask_port); 7086 7087 BCMX_UNIT_ITER(bcm_unit, i) { 7088 rv = bcm_field_qualify_SrcPort_get(bcm_unit, entry, data_modid, mask_modid, data_port, mask_port); 7089 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 7090 return rv; 7091 } 7092 } 7093 7094 return BCM_E_UNAVAIL; 7095 } 7096 7097 /* 7098 * Function: 7099 * bcmx_field_qualify_SrcTrunk_get 7100 * Purpose: 7101 * Get match criteria for bcmFieldQualifySrcTrunk 7102 * qualifier from the field entry. 7103 * Parameters: 7104 * entry - (IN) BCM field entry id. 7105 * data - (OUT) Qualifier match data. 7106 * mask - (OUT) Qualifier match mask. 7107 * Returns: 7108 * BCM_E_XXX 7109 * Notes: 7110 */ 7111 int 7112 bcmx_field_qualify_SrcTrunk_get(bcm_field_entry_t entry, 7113 bcm_trunk_t *data, 7114 bcm_trunk_t *mask) 7115 { 7116 int rv; 7117 int i, bcm_unit; 7118 7119 BCMX_FIELD_INIT_CHECK; 7120 7121 BCMX_PARAM_NULL_CHECK(data); 7122 BCMX_PARAM_NULL_CHECK(mask); 7123 7124 BCMX_UNIT_ITER(bcm_unit, i) { 7125 rv = bcm_field_qualify_SrcTrunk_get(bcm_unit, entry, data, mask); 7126 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 7127 return rv; 7128 } 7129 } 7130 7131 return BCM_E_UNAVAIL; 7132 } 7133 7134 /* 7135 * Function: 7136 * bcmx_field_qualify_DstPort_get 7137 * Purpose: 7138 * Get match criteria for bcmFieldQualifyDstPort 7139 * qualifier from the field entry. 7140 * Parameters: 7141 * entry - (IN) BCM field entry id. 7142 * data_modid - (OUT) Qualifier module id. 7143 * mask_modid - (OUT) Qualifier module id mask. 7144 * data_port - (OUT) Qualifier port id. 7145 * mask_port - (OUT) Qualifier port id mask. 7146 * Returns: 7147 * BCM_E_XXX 7148 * Notes: 7149 */ 7150 int 7151 bcmx_field_qualify_DstPort_get(bcm_field_entry_t entry, 7152 bcm_module_t *data_modid, 7153 bcm_module_t *mask_modid, 7154 bcm_port_t *data_port, 7155 bcm_port_t *mask_port) 7156 { 7157 int rv; 7158 int i, bcm_unit; 7159 7160 BCMX_FIELD_INIT_CHECK; 7161 7162 BCMX_PARAM_NULL_CHECK(data_modid); 7163 BCMX_PARAM_NULL_CHECK(mask_modid); 7164 BCMX_PARAM_NULL_CHECK(data_port); 7165 BCMX_PARAM_NULL_CHECK(mask_port); 7166 7167 BCMX_UNIT_ITER(bcm_unit, i) { 7168 rv = bcm_field_qualify_DstPort_get(bcm_unit, entry, data_modid, mask_modid, data_port, mask_port); 7169 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 7170 return rv; 7171 } 7172 } 7173 7174 return BCM_E_UNAVAIL; 7175 } 7176 7177 /* 7178 * Function: 7179 * bcmx_field_qualify_DstTrunk_get 7180 * Purpose: 7181 * Get match criteria for bcmFieldQualifyDstTrunk 7182 * qualifier from the field entry. 7183 * Parameters: 7184 * entry - (IN) BCM field entry id. 7185 * data - (OUT) Qualifier match data. 7186 * mask - (OUT) Qualifier match mask. 7187 * Returns: 7188 * BCM_E_XXX 7189 * Notes: 7190 */ 7191 int 7192 bcmx_field_qualify_DstTrunk_get(bcm_field_entry_t entry, 7193 bcm_trunk_t *data, 7194 bcm_trunk_t *mask) 7195 { 7196 int rv; 7197 int i, bcm_unit; 7198 7199 BCMX_FIELD_INIT_CHECK; 7200 7201 BCMX_PARAM_NULL_CHECK(data); 7202 BCMX_PARAM_NULL_CHECK(mask); 7203 7204 BCMX_UNIT_ITER(bcm_unit, i) { 7205 rv = bcm_field_qualify_DstTrunk_get(bcm_unit, entry, data, mask); 7206 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 7207 return rv; 7208 } 7209 } 7210 7211 return BCM_E_UNAVAIL; 7212 } 7213 7214 /* 7215 * Function: 7216 * bcmx_field_qualify_InnerL4SrcPort_get 7217 * Purpose: 7218 * Get match criteria for bcmFieldQualifyInnerL4SrcPort 7219 * qualifier from the field entry. 7220 * Parameters: 7221 * entry - (IN) BCM field entry id. 7222 * data - (OUT) Qualifier match data. 7223 * mask - (OUT) Qualifier match mask. 7224 * Returns: 7225 * BCM_E_XXX 7226 * Notes: 7227 */ 7228 int 7229 bcmx_field_qualify_InnerL4SrcPort_get(bcm_field_entry_t entry, 7230 bcm_l4_port_t *data, 7231 bcm_l4_port_t *mask) 7232 { 7233 int rv; 7234 int i, bcm_unit; 7235 7236 BCMX_FIELD_INIT_CHECK; 7237 7238 BCMX_PARAM_NULL_CHECK(data); 7239 BCMX_PARAM_NULL_CHECK(mask); 7240 7241 BCMX_UNIT_ITER(bcm_unit, i) { 7242 rv = bcm_field_qualify_InnerL4SrcPort_get(bcm_unit, entry, data, mask); 7243 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 7244 return rv; 7245 } 7246 } 7247 7248 return BCM_E_UNAVAIL; 7249 } 7250 7251 /* 7252 * Function: 7253 * bcmx_field_qualify_InnerL4DstPort_get 7254 * Purpose: 7255 * Get match criteria for bcmFieldQualifyInnerL4DstPort 7256 * qualifier from the field entry. 7257 * Parameters: 7258 * entry - (IN) BCM field entry id. 7259 * data - (OUT) Qualifier match data. 7260 * mask - (OUT) Qualifier match mask. 7261 * Returns: 7262 * BCM_E_XXX 7263 * Notes: 7264 */ 7265 int 7266 bcmx_field_qualify_InnerL4DstPort_get(bcm_field_entry_t entry, 7267 bcm_l4_port_t *data, 7268 bcm_l4_port_t *mask) 7269 { 7270 int rv; 7271 int i, bcm_unit; 7272 7273 BCMX_FIELD_INIT_CHECK; 7274 7275 BCMX_PARAM_NULL_CHECK(data); 7276 BCMX_PARAM_NULL_CHECK(mask); 7277 7278 BCMX_UNIT_ITER(bcm_unit, i) { 7279 rv = bcm_field_qualify_InnerL4DstPort_get(bcm_unit, entry, data, mask); 7280 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 7281 return rv; 7282 } 7283 } 7284 7285 return BCM_E_UNAVAIL; 7286 } 7287 7288 /* 7289 * Function: 7290 * bcmx_field_qualify_L4SrcPort_get 7291 * Purpose: 7292 * Get match criteria for bcmFieldQualifyL4SrcPort 7293 * qualifier from the field entry. 7294 * Parameters: 7295 * entry - (IN) BCM field entry id. 7296 * data - (OUT) Qualifier match data. 7297 * mask - (OUT) Qualifier match mask. 7298 * Returns: 7299 * BCM_E_XXX 7300 * Notes: 7301 */ 7302 int 7303 bcmx_field_qualify_L4SrcPort_get(bcm_field_entry_t entry, 7304 bcm_l4_port_t *data, 7305 bcm_l4_port_t *mask) 7306 { 7307 int rv; 7308 int i, bcm_unit; 7309 7310 BCMX_FIELD_INIT_CHECK; 7311 7312 BCMX_PARAM_NULL_CHECK(data); 7313 BCMX_PARAM_NULL_CHECK(mask); 7314 7315 BCMX_UNIT_ITER(bcm_unit, i) { 7316 rv = bcm_field_qualify_L4SrcPort_get(bcm_unit, entry, data, mask); 7317 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 7318 return rv; 7319 } 7320 } 7321 7322 return BCM_E_UNAVAIL; 7323 } 7324 7325 /* 7326 * Function: 7327 * bcmx_field_qualify_L4DstPort_get 7328 * Purpose: 7329 * Get match criteria for bcmFieldQualifyL4DstPort 7330 * qualifier from the field entry. 7331 * Parameters: 7332 * entry - (IN) BCM field entry id. 7333 * data - (OUT) Qualifier match data. 7334 * mask - (OUT) Qualifier match mask. 7335 * Returns: 7336 * BCM_E_XXX 7337 * Notes: 7338 */ 7339 int 7340 bcmx_field_qualify_L4DstPort_get(bcm_field_entry_t entry, 7341 bcm_l4_port_t *data, 7342 bcm_l4_port_t *mask) 7343 { 7344 int rv; 7345 int i, bcm_unit; 7346 7347 BCMX_FIELD_INIT_CHECK; 7348 7349 BCMX_PARAM_NULL_CHECK(data); 7350 BCMX_PARAM_NULL_CHECK(mask); 7351 7352 BCMX_UNIT_ITER(bcm_unit, i) { 7353 rv = bcm_field_qualify_L4DstPort_get(bcm_unit, entry, data, mask); 7354 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 7355 return rv; 7356 } 7357 } 7358 7359 return BCM_E_UNAVAIL; 7360 } 7361 7362 /* 7363 * Function: 7364 * bcmx_field_qualify_OuterVlan_get 7365 * Purpose: 7366 * Get match criteria for bcmFieldQualifyOuterVlan 7367 * qualifier from the field entry. 7368 * Parameters: 7369 * entry - (IN) BCM field entry id. 7370 * data - (OUT) Qualifier match data. 7371 * mask - (OUT) Qualifier match mask. 7372 * Returns: 7373 * BCM_E_XXX 7374 * Notes: 7375 */ 7376 int 7377 bcmx_field_qualify_OuterVlan_get(bcm_field_entry_t entry, 7378 bcm_vlan_t *data, 7379 bcm_vlan_t *mask) 7380 { 7381 int rv; 7382 int i, bcm_unit; 7383 7384 BCMX_FIELD_INIT_CHECK; 7385 7386 BCMX_PARAM_NULL_CHECK(data); 7387 BCMX_PARAM_NULL_CHECK(mask); 7388 7389 BCMX_UNIT_ITER(bcm_unit, i) { 7390 rv = bcm_field_qualify_OuterVlan_get(bcm_unit, entry, data, mask); 7391 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 7392 return rv; 7393 } 7394 } 7395 7396 return BCM_E_UNAVAIL; 7397 } 7398 7399 /* 7400 * Function: 7401 * bcmx_field_qualify_OuterVlanId_get 7402 * Purpose: 7403 * Get match criteria for bcmFieldQualifyOuterVlanId 7404 * qualifier from the field entry. 7405 * Parameters: 7406 * entry - (IN) BCM field entry id. 7407 * data - (OUT) Qualifier match data. 7408 * mask - (OUT) Qualifier match mask. 7409 * Returns: 7410 * BCM_E_XXX 7411 * Notes: 7412 */ 7413 int 7414 bcmx_field_qualify_OuterVlanId_get(bcm_field_entry_t entry, 7415 bcm_vlan_t *data, 7416 bcm_vlan_t *mask) 7417 { 7418 int rv; 7419 int i, bcm_unit; 7420 7421 BCMX_FIELD_INIT_CHECK; 7422 7423 BCMX_PARAM_NULL_CHECK(data); 7424 BCMX_PARAM_NULL_CHECK(mask); 7425 7426 BCMX_UNIT_ITER(bcm_unit, i) { 7427 rv = bcm_field_qualify_OuterVlanId_get(bcm_unit, entry, data, mask); 7428 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 7429 return rv; 7430 } 7431 } 7432 7433 return BCM_E_UNAVAIL; 7434 } 7435 7436 /* 7437 * Function: 7438 * bcmx_field_qualify_ForwardingVlanId_get 7439 * Purpose: 7440 * Get match criteria for bcmFieldQualifyForwardingVlanId 7441 * qualifier from the field entry. 7442 * Parameters: 7443 * entry - (IN) BCM field entry id. 7444 * data - (OUT) Qualifier match data. 7445 * mask - (OUT) Qualifier match mask. 7446 * Returns: 7447 * BCM_E_XXX 7448 * Notes: 7449 */ 7450 int 7451 bcmx_field_qualify_ForwardingVlanId_get(bcm_field_entry_t entry, 7452 bcm_vlan_t *data, 7453 bcm_vlan_t *mask) 7454 { 7455 int rv; 7456 int i, bcm_unit; 7457 7458 BCMX_FIELD_INIT_CHECK; 7459 7460 BCMX_PARAM_NULL_CHECK(data); 7461 BCMX_PARAM_NULL_CHECK(mask); 7462 7463 BCMX_UNIT_ITER(bcm_unit, i) { 7464 rv = bcm_field_qualify_ForwardingVlanId_get(bcm_unit, entry, data, mask); 7465 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 7466 return rv; 7467 } 7468 } 7469 7470 return BCM_E_UNAVAIL; 7471 } 7472 7473 /* 7474 * Function: 7475 * bcmx_field_qualify_OuterVlanCfi_get 7476 * Purpose: 7477 * Get match criteria for bcmFieldQualifyOuterVlanCfi 7478 * qualifier from the field entry. 7479 * Parameters: 7480 * entry - (IN) BCM field entry id. 7481 * data - (OUT) Qualifier match data. 7482 * mask - (OUT) Qualifier match mask. 7483 * Returns: 7484 * BCM_E_XXX 7485 * Notes: 7486 */ 7487 int 7488 bcmx_field_qualify_OuterVlanCfi_get(bcm_field_entry_t entry, 7489 uint8 *data, uint8 *mask) 7490 { 7491 int rv; 7492 int i, bcm_unit; 7493 7494 BCMX_FIELD_INIT_CHECK; 7495 7496 BCMX_PARAM_NULL_CHECK(data); 7497 BCMX_PARAM_NULL_CHECK(mask); 7498 7499 BCMX_UNIT_ITER(bcm_unit, i) { 7500 rv = bcm_field_qualify_OuterVlanCfi_get(bcm_unit, entry, data, mask); 7501 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 7502 return rv; 7503 } 7504 } 7505 7506 return BCM_E_UNAVAIL; 7507 } 7508 7509 /* 7510 * Function: 7511 * bcmx_field_qualify_OuterVlanPri_get 7512 * Purpose: 7513 * Get match criteria for bcmFieldQualifyOuterVlanPri 7514 * qualifier from the field entry. 7515 * Parameters: 7516 * entry - (IN) BCM field entry id. 7517 * data - (OUT) Qualifier match data. 7518 * mask - (OUT) Qualifier match mask. 7519 * Returns: 7520 * BCM_E_XXX 7521 * Notes: 7522 */ 7523 int 7524 bcmx_field_qualify_OuterVlanPri_get(bcm_field_entry_t entry, 7525 uint8 *data, uint8 *mask) 7526 { 7527 int rv; 7528 int i, bcm_unit; 7529 7530 BCMX_FIELD_INIT_CHECK; 7531 7532 BCMX_PARAM_NULL_CHECK(data); 7533 BCMX_PARAM_NULL_CHECK(mask); 7534 7535 BCMX_UNIT_ITER(bcm_unit, i) { 7536 rv = bcm_field_qualify_OuterVlanPri_get(bcm_unit, entry, data, mask); 7537 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 7538 return rv; 7539 } 7540 } 7541 7542 return BCM_E_UNAVAIL; 7543 } 7544 7545 /* 7546 * Function: 7547 * bcmx_field_qualify_InnerVlan_get 7548 * Purpose: 7549 * Get match criteria for bcmFieldQualifyInnerVlan 7550 * qualifier from the field entry. 7551 * Parameters: 7552 * entry - (IN) BCM field entry id. 7553 * data - (OUT) Qualifier match data. 7554 * mask - (OUT) Qualifier match mask. 7555 * Returns: 7556 * BCM_E_XXX 7557 * Notes: 7558 */ 7559 int 7560 bcmx_field_qualify_InnerVlan_get(bcm_field_entry_t entry, 7561 bcm_vlan_t *data, 7562 bcm_vlan_t *mask) 7563 { 7564 int rv; 7565 int i, bcm_unit; 7566 7567 BCMX_FIELD_INIT_CHECK; 7568 7569 BCMX_PARAM_NULL_CHECK(data); 7570 BCMX_PARAM_NULL_CHECK(mask); 7571 7572 BCMX_UNIT_ITER(bcm_unit, i) { 7573 rv = bcm_field_qualify_InnerVlan_get(bcm_unit, entry, data, mask); 7574 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 7575 return rv; 7576 } 7577 } 7578 7579 return BCM_E_UNAVAIL; 7580 } 7581 7582 /* 7583 * Function: 7584 * bcmx_field_qualify_InnerVlanId_get 7585 * Purpose: 7586 * Get match criteria for bcmFieldQualifyInnerVlanId 7587 * qualifier from the field entry. 7588 * Parameters: 7589 * entry - (IN) BCM field entry id. 7590 * data - (OUT) Qualifier match data. 7591 * mask - (OUT) Qualifier match mask. 7592 * Returns: 7593 * BCM_E_XXX 7594 * Notes: 7595 */ 7596 int 7597 bcmx_field_qualify_InnerVlanId_get(bcm_field_entry_t entry, 7598 bcm_vlan_t *data, 7599 bcm_vlan_t *mask) 7600 { 7601 int rv; 7602 int i, bcm_unit; 7603 7604 BCMX_FIELD_INIT_CHECK; 7605 7606 BCMX_PARAM_NULL_CHECK(data); 7607 BCMX_PARAM_NULL_CHECK(mask); 7608 7609 BCMX_UNIT_ITER(bcm_unit, i) { 7610 rv = bcm_field_qualify_InnerVlanId_get(bcm_unit, entry, data, mask); 7611 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 7612 return rv; 7613 } 7614 } 7615 7616 return BCM_E_UNAVAIL; 7617 } 7618 7619 /* 7620 * Function: 7621 * bcmx_field_qualify_InnerVlanPri_get 7622 * Purpose: 7623 * Get match criteria for bcmFieldQualifyInnerVlanPri 7624 * qualifier from the field entry. 7625 * Parameters: 7626 * entry - (IN) BCM field entry id. 7627 * data - (OUT) Qualifier match data. 7628 * mask - (OUT) Qualifier match mask. 7629 * Returns: 7630 * BCM_E_XXX 7631 * Notes: 7632 */ 7633 int 7634 bcmx_field_qualify_InnerVlanPri_get(bcm_field_entry_t entry, 7635 uint8 *data, uint8 *mask) 7636 { 7637 int rv; 7638 int i, bcm_unit; 7639 7640 BCMX_FIELD_INIT_CHECK; 7641 7642 BCMX_PARAM_NULL_CHECK(data); 7643 BCMX_PARAM_NULL_CHECK(mask); 7644 7645 BCMX_UNIT_ITER(bcm_unit, i) { 7646 rv = bcm_field_qualify_InnerVlanPri_get(bcm_unit, entry, data, mask); 7647 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 7648 return rv; 7649 } 7650 } 7651 7652 return BCM_E_UNAVAIL; 7653 } 7654 7655 /* 7656 * Function: 7657 * bcmx_field_qualify_InnerVlanCfi_get 7658 * Purpose: 7659 * Get match criteria for bcmFieldQualifyInnerVlanCfi 7660 * qualifier from the field entry. 7661 * Parameters: 7662 * entry - (IN) BCM field entry id. 7663 * data - (OUT) Qualifier match data. 7664 * mask - (OUT) Qualifier match mask. 7665 * Returns: 7666 * BCM_E_XXX 7667 * Notes: 7668 */ 7669 int 7670 bcmx_field_qualify_InnerVlanCfi_get(bcm_field_entry_t entry, 7671 uint8 *data, uint8 *mask) 7672 { 7673 int rv; 7674 int i, bcm_unit; 7675 7676 BCMX_FIELD_INIT_CHECK; 7677 7678 BCMX_PARAM_NULL_CHECK(data); 7679 BCMX_PARAM_NULL_CHECK(mask); 7680 7681 BCMX_UNIT_ITER(bcm_unit, i) { 7682 rv = bcm_field_qualify_InnerVlanCfi_get(bcm_unit, entry, data, mask); 7683 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 7684 return rv; 7685 } 7686 } 7687 7688 return BCM_E_UNAVAIL; 7689 } 7690 7691 /* 7692 * Function: 7693 * bcmx_field_qualify_EtherType_get 7694 * Purpose: 7695 * Get match criteria for bcmFieldQualifyEtherType 7696 * qualifier from the field entry. 7697 * Parameters: 7698 * entry - (IN) BCM field entry id. 7699 * data - (OUT) Qualifier match data. 7700 * mask - (OUT) Qualifier match mask. 7701 * Returns: 7702 * BCM_E_XXX 7703 * Notes: 7704 */ 7705 int 7706 bcmx_field_qualify_EtherType_get(bcm_field_entry_t entry, 7707 uint16 *data, 7708 uint16 *mask) 7709 { 7710 int rv; 7711 int i, bcm_unit; 7712 7713 BCMX_FIELD_INIT_CHECK; 7714 7715 BCMX_PARAM_NULL_CHECK(data); 7716 BCMX_PARAM_NULL_CHECK(mask); 7717 7718 BCMX_UNIT_ITER(bcm_unit, i) { 7719 rv = bcm_field_qualify_EtherType_get(bcm_unit, entry, data, mask); 7720 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 7721 return rv; 7722 } 7723 } 7724 7725 return BCM_E_UNAVAIL; 7726 } 7727 7728 /* 7729 * Function: 7730 * bcmx_field_qualify_IpProtocol_get 7731 * Purpose: 7732 * Get match criteria for bcmFieldQualifyIpProtocol 7733 * qualifier from the field entry. 7734 * Parameters: 7735 * entry - (IN) BCM field entry id. 7736 * data - (OUT) Qualifier match data. 7737 * mask - (OUT) Qualifier match mask. 7738 * Returns: 7739 * BCM_E_XXX 7740 * Notes: 7741 */ 7742 int 7743 bcmx_field_qualify_IpProtocol_get(bcm_field_entry_t entry, 7744 uint8 *data, 7745 uint8 *mask) 7746 { 7747 int rv; 7748 int i, bcm_unit; 7749 7750 BCMX_FIELD_INIT_CHECK; 7751 7752 BCMX_PARAM_NULL_CHECK(data); 7753 BCMX_PARAM_NULL_CHECK(mask); 7754 7755 BCMX_UNIT_ITER(bcm_unit, i) { 7756 rv = bcm_field_qualify_IpProtocol_get(bcm_unit, entry, data, mask); 7757 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 7758 return rv; 7759 } 7760 } 7761 7762 return BCM_E_UNAVAIL; 7763 } 7764 7765 7766 /* 7767 * Function: 7768 * bcmx_field_qualify_IpInfo_get 7769 * Purpose: 7770 * Get match criteria for bcmFieldQualifyIpInfo 7771 * qualifier from the field entry. 7772 * Parameters: 7773 * entry - (IN) BCM field entry id. 7774 * data - (OUT) Qualifier match data. 7775 * mask - (OUT) Qualifier match mask. 7776 * Returns: 7777 * BCM_E_XXX 7778 * Notes: 7779 */ 7780 int 7781 bcmx_field_qualify_IpInfo_get(bcm_field_entry_t entry, 7782 uint32 *data, 7783 uint32 *mask) 7784 { 7785 int rv; 7786 int i, bcm_unit; 7787 7788 BCMX_FIELD_INIT_CHECK; 7789 7790 BCMX_PARAM_NULL_CHECK(data); 7791 BCMX_PARAM_NULL_CHECK(mask); 7792 7793 BCMX_UNIT_ITER(bcm_unit, i) { 7794 rv = bcm_field_qualify_IpInfo_get(bcm_unit, entry, data, mask); 7795 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 7796 return rv; 7797 } 7798 } 7799 7800 return BCM_E_UNAVAIL; 7801 } 7802 7803 /* 7804 * Function: 7805 * bcmx_field_qualify_PacketRes_get 7806 * Purpose: 7807 * Get match criteria for bcmFieldQualifyPacketRes 7808 * qualifier from the field entry. 7809 * Parameters: 7810 * entry - (IN) BCM field entry id. 7811 * data - (OUT) Qualifier match data. 7812 * mask - (OUT) Qualifier match mask. 7813 * Returns: 7814 * BCM_E_XXX 7815 * Notes: 7816 */ 7817 int 7818 bcmx_field_qualify_PacketRes_get(bcm_field_entry_t entry, 7819 uint32 *data, 7820 uint32 *mask) 7821 { 7822 int rv; 7823 int i, bcm_unit; 7824 7825 BCMX_FIELD_INIT_CHECK; 7826 7827 BCMX_PARAM_NULL_CHECK(data); 7828 BCMX_PARAM_NULL_CHECK(mask); 7829 7830 BCMX_UNIT_ITER(bcm_unit, i) { 7831 rv = bcm_field_qualify_PacketRes_get(bcm_unit, entry, data, mask); 7832 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 7833 return rv; 7834 } 7835 } 7836 7837 return BCM_E_UNAVAIL; 7838 } 7839 7840 /* 7841 * Function: 7842 * bcmx_field_qualify_SrcIp_get 7843 * Purpose: 7844 * Get match criteria for bcmFieldQualifySrcIp 7845 * qualifier from the field entry. 7846 * Parameters: 7847 * entry - (IN) BCM field entry id. 7848 * data - (OUT) Qualifier match data. 7849 * mask - (OUT) Qualifier match mask. 7850 * Returns: 7851 * BCM_E_XXX 7852 * Notes: 7853 */ 7854 int 7855 bcmx_field_qualify_SrcIp_get(bcm_field_entry_t entry, 7856 bcm_ip_t *data, 7857 bcm_ip_t *mask) 7858 { 7859 int rv; 7860 int i, bcm_unit; 7861 7862 BCMX_FIELD_INIT_CHECK; 7863 7864 BCMX_PARAM_NULL_CHECK(data); 7865 BCMX_PARAM_NULL_CHECK(mask); 7866 7867 BCMX_UNIT_ITER(bcm_unit, i) { 7868 rv = bcm_field_qualify_SrcIp_get(bcm_unit, entry, data, mask); 7869 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 7870 return rv; 7871 } 7872 } 7873 7874 return BCM_E_UNAVAIL; 7875 } 7876 7877 /* 7878 * Function: 7879 * bcmx_field_qualify_DstIp_get 7880 * Purpose: 7881 * Get match criteria for bcmFieldQualifyDstIp 7882 * qualifier from the field entry. 7883 * Parameters: 7884 * entry - (IN) BCM field entry id. 7885 * data - (OUT) Qualifier match data. 7886 * mask - (OUT) Qualifier match mask. 7887 * Returns: 7888 * BCM_E_XXX 7889 * Notes: 7890 */ 7891 int 7892 bcmx_field_qualify_DstIp_get(bcm_field_entry_t entry, 7893 bcm_ip_t *data, 7894 bcm_ip_t *mask) 7895 { 7896 int rv; 7897 int i, bcm_unit; 7898 7899 BCMX_FIELD_INIT_CHECK; 7900 7901 BCMX_PARAM_NULL_CHECK(data); 7902 BCMX_PARAM_NULL_CHECK(mask); 7903 7904 BCMX_UNIT_ITER(bcm_unit, i) { 7905 rv = bcm_field_qualify_DstIp_get(bcm_unit, entry, data, mask); 7906 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 7907 return rv; 7908 } 7909 } 7910 7911 return BCM_E_UNAVAIL; 7912 } 7913 7914 /* 7915 * Function: 7916 * bcmx_field_qualify_DSCP_get 7917 * Purpose: 7918 * Get match criteria for bcmFieldQualifyDSCP 7919 * qualifier from the field entry. 7920 * Parameters: 7921 * entry - (IN) BCM field entry id. 7922 * data - (OUT) Qualifier match data. 7923 * mask - (OUT) Qualifier match mask. 7924 * Returns: 7925 * BCM_E_XXX 7926 * Notes: 7927 */ 7928 int 7929 bcmx_field_qualify_DSCP_get(bcm_field_entry_t entry, 7930 uint8 *data, 7931 uint8 *mask) 7932 { 7933 int rv; 7934 int i, bcm_unit; 7935 7936 BCMX_FIELD_INIT_CHECK; 7937 7938 BCMX_PARAM_NULL_CHECK(data); 7939 BCMX_PARAM_NULL_CHECK(mask); 7940 7941 BCMX_UNIT_ITER(bcm_unit, i) { 7942 rv = bcm_field_qualify_DSCP_get(bcm_unit, entry, data, mask); 7943 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 7944 return rv; 7945 } 7946 } 7947 7948 return BCM_E_UNAVAIL; 7949 } 7950 7951 /* 7952 * Function: 7953 * bcmx_field_qualify_Tos_get 7954 * Purpose: 7955 * Get match criteria for bcmFieldQualifyTos 7956 * qualifier from the field entry. 7957 * Parameters: 7958 * entry - (IN) BCM field entry id. 7959 * data - (OUT) Qualifier match data. 7960 * mask - (OUT) Qualifier match mask. 7961 * Returns: 7962 * BCM_E_XXX 7963 * Notes: 7964 */ 7965 int 7966 bcmx_field_qualify_Tos_get(bcm_field_entry_t entry, uint8 *data, uint8 *mask) 7967 { 7968 int rv; 7969 int i, bcm_unit; 7970 7971 BCMX_FIELD_INIT_CHECK; 7972 7973 BCMX_PARAM_NULL_CHECK(data); 7974 BCMX_PARAM_NULL_CHECK(mask); 7975 7976 BCMX_UNIT_ITER(bcm_unit, i) { 7977 rv = bcm_field_qualify_Tos_get(bcm_unit, entry, data, mask); 7978 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 7979 return rv; 7980 } 7981 } 7982 7983 return BCM_E_UNAVAIL; 7984 } 7985 7986 /* 7987 * Function: 7988 * bcmx_field_qualify_IpFlags_get 7989 * Purpose: 7990 * Get match criteria for bcmFieldQualifyIpFlags 7991 * qualifier from the field entry. 7992 * Parameters: 7993 * entry - (IN) BCM field entry id. 7994 * data - (OUT) Qualifier match data. 7995 * mask - (OUT) Qualifier match mask. 7996 * Returns: 7997 * BCM_E_XXX 7998 * Notes: 7999 */ 8000 int 8001 bcmx_field_qualify_IpFlags_get(bcm_field_entry_t entry, 8002 uint8 *data, 8003 uint8 *mask) 8004 { 8005 int rv; 8006 int i, bcm_unit; 8007 8008 BCMX_FIELD_INIT_CHECK; 8009 8010 BCMX_PARAM_NULL_CHECK(data); 8011 BCMX_PARAM_NULL_CHECK(mask); 8012 8013 BCMX_UNIT_ITER(bcm_unit, i) { 8014 rv = bcm_field_qualify_IpFlags_get(bcm_unit, entry, data, mask); 8015 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 8016 return rv; 8017 } 8018 } 8019 8020 return BCM_E_UNAVAIL; 8021 } 8022 8023 /* 8024 * Function: 8025 * bcmx_field_qualify_TcpControl_get 8026 * Purpose: 8027 * Get match criteria for bcmFieldQualifyTcpControl 8028 * qualifier from the field entry. 8029 * Parameters: 8030 * entry - (IN) BCM field entry id. 8031 * data - (OUT) Qualifier match data. 8032 * mask - (OUT) Qualifier match mask. 8033 * Returns: 8034 * BCM_E_XXX 8035 * Notes: 8036 */ 8037 int 8038 bcmx_field_qualify_TcpControl_get(bcm_field_entry_t entry, 8039 uint8 *data, 8040 uint8 *mask) 8041 { 8042 int rv; 8043 int i, bcm_unit; 8044 8045 BCMX_FIELD_INIT_CHECK; 8046 8047 BCMX_PARAM_NULL_CHECK(data); 8048 BCMX_PARAM_NULL_CHECK(mask); 8049 8050 BCMX_UNIT_ITER(bcm_unit, i) { 8051 rv = bcm_field_qualify_TcpControl_get(bcm_unit, entry, data, mask); 8052 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 8053 return rv; 8054 } 8055 } 8056 8057 return BCM_E_UNAVAIL; 8058 } 8059 8060 /* 8061 * Function: 8062 * bcmx_field_qualify_TcpSequenceZero_get 8063 * Purpose: 8064 * Get match criteria for bcmFieldQualifyTcpSequenceZero 8065 * qualifier from the field entry. 8066 * Parameters: 8067 * entry - (IN) BCM field entry id. 8068 * flag - (OUT) Qualifier match flags. 8069 * Returns: 8070 * BCM_E_XXX 8071 * Notes: 8072 */ 8073 int 8074 bcmx_field_qualify_TcpSequenceZero_get(bcm_field_entry_t entry, 8075 uint32 *flag) 8076 { 8077 int rv; 8078 int i, bcm_unit; 8079 8080 BCMX_FIELD_INIT_CHECK; 8081 8082 BCMX_PARAM_NULL_CHECK(flag); 8083 8084 BCMX_UNIT_ITER(bcm_unit, i) { 8085 rv = bcm_field_qualify_TcpSequenceZero_get(bcm_unit, entry, flag); 8086 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 8087 return rv; 8088 } 8089 } 8090 8091 return BCM_E_UNAVAIL; 8092 } 8093 8094 /* 8095 * Function: 8096 * bcmx_field_qualify_TcpHeaderSize_get 8097 * Purpose: 8098 * Get match criteria for bcmFieldQualifyTcpHeaderSize 8099 * qualifier from the field entry. 8100 * Parameters: 8101 * entry - (IN) BCM field entry id. 8102 * data - (OUT) Qualifier match data. 8103 * mask - (OUT) Qualifier match mask. 8104 * Returns: 8105 * BCM_E_XXX 8106 * Notes: 8107 */ 8108 int 8109 bcmx_field_qualify_TcpHeaderSize_get(bcm_field_entry_t entry, 8110 uint8 *data, 8111 uint8 *mask) 8112 { 8113 int rv; 8114 int i, bcm_unit; 8115 8116 BCMX_FIELD_INIT_CHECK; 8117 8118 BCMX_PARAM_NULL_CHECK(data); 8119 BCMX_PARAM_NULL_CHECK(mask); 8120 8121 BCMX_UNIT_ITER(bcm_unit, i) { 8122 rv = bcm_field_qualify_TcpHeaderSize_get(bcm_unit, entry, data, mask); 8123 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 8124 return rv; 8125 } 8126 } 8127 8128 return BCM_E_UNAVAIL; 8129 } 8130 8131 /* 8132 * Function: 8133 * bcmx_field_qualify_Ttl_get 8134 * Purpose: 8135 * Get match criteria for bcmFieldQualifyTtl 8136 * qualifier from the field entry. 8137 * Parameters: 8138 * entry - (IN) BCM field entry id. 8139 * data - (OUT) Qualifier match data. 8140 * mask - (OUT) Qualifier match mask. 8141 * Returns: 8142 * BCM_E_XXX 8143 * Notes: 8144 */ 8145 int 8146 bcmx_field_qualify_Ttl_get(bcm_field_entry_t entry, 8147 uint8 *data, 8148 uint8 *mask) 8149 { 8150 int rv; 8151 int i, bcm_unit; 8152 8153 BCMX_FIELD_INIT_CHECK; 8154 8155 BCMX_PARAM_NULL_CHECK(data); 8156 BCMX_PARAM_NULL_CHECK(mask); 8157 8158 BCMX_UNIT_ITER(bcm_unit, i) { 8159 rv = bcm_field_qualify_Ttl_get(bcm_unit, entry, data, mask); 8160 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 8161 return rv; 8162 } 8163 } 8164 8165 return BCM_E_UNAVAIL; 8166 } 8167 8168 /* 8169 * Function: 8170 * bcmx_field_qualify_RangeCheck_get 8171 * Purpose: 8172 * Get match criteria for bcmFieldQualifyRangeCheck 8173 * qualifier from the field entry. 8174 * Parameters: 8175 * entry - (IN) BCM field entry id. 8176 * max_count - (IN) Max entries to fill. 8177 * range - (OUT) Range checkers array. 8178 * invert - (OUT) Range checkers invert array. 8179 * count - (OUT) Number of filled range checkers. 8180 * Returns: 8181 * BCM_E_XXX 8182 * Notes: 8183 */ 8184 int 8185 bcmx_field_qualify_RangeCheck_get(bcm_field_entry_t entry, 8186 int max_count, 8187 bcm_field_range_t *range, 8188 int *invert, 8189 int *count) 8190 { 8191 int rv; 8192 int i, bcm_unit; 8193 8194 BCMX_FIELD_INIT_CHECK; 8195 8196 BCMX_PARAM_NULL_CHECK(count); 8197 BCMX_PARAM_ARRAY_NULL_CHECK(max_count, range); 8198 BCMX_PARAM_ARRAY_NULL_CHECK(max_count, invert); 8199 8200 BCMX_UNIT_ITER(bcm_unit, i) { 8201 rv = bcm_field_qualify_RangeCheck_get(bcm_unit, entry, max_count, range, invert, count); 8202 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 8203 return rv; 8204 } 8205 } 8206 8207 return BCM_E_UNAVAIL; 8208 } 8209 8210 /* 8211 * Function: 8212 * bcmx_field_qualify_SrcIp6_get 8213 * Purpose: 8214 * Get match criteria for bcmFieldQualifySrcIp6 8215 * qualifier from the field entry. 8216 * Parameters: 8217 * entry - (IN) BCM field entry id. 8218 * data - (OUT) Qualifier match data. 8219 * mask - (OUT) Qualifier match mask. 8220 * Returns: 8221 * BCM_E_XXX 8222 * Notes: 8223 */ 8224 int 8225 bcmx_field_qualify_SrcIp6_get(bcm_field_entry_t entry, 8226 bcm_ip6_t *data, 8227 bcm_ip6_t *mask) 8228 { 8229 int rv; 8230 int i, bcm_unit; 8231 8232 BCMX_FIELD_INIT_CHECK; 8233 8234 BCMX_PARAM_NULL_CHECK(data); 8235 BCMX_PARAM_NULL_CHECK(mask); 8236 8237 BCMX_UNIT_ITER(bcm_unit, i) { 8238 rv = bcm_field_qualify_SrcIp6_get(bcm_unit, entry, data, mask); 8239 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 8240 return rv; 8241 } 8242 } 8243 8244 return BCM_E_UNAVAIL; 8245 } 8246 8247 /* 8248 * Function: 8249 * bcmx_field_qualify_DstIp6_get 8250 * Purpose: 8251 * Get match criteria for bcmFieldQualifyDstIp6 8252 * qualifier from the field entry. 8253 * Parameters: 8254 * entry - (IN) BCM field entry id. 8255 * data - (OUT) Qualifier match data. 8256 * mask - (OUT) Qualifier match mask. 8257 * Returns: 8258 * BCM_E_XXX 8259 * Notes: 8260 */ 8261 int 8262 bcmx_field_qualify_DstIp6_get(bcm_field_entry_t entry, 8263 bcm_ip6_t *data, 8264 bcm_ip6_t *mask) 8265 { 8266 int rv; 8267 int i, bcm_unit; 8268 8269 BCMX_FIELD_INIT_CHECK; 8270 8271 BCMX_PARAM_NULL_CHECK(data); 8272 BCMX_PARAM_NULL_CHECK(mask); 8273 8274 BCMX_UNIT_ITER(bcm_unit, i) { 8275 rv = bcm_field_qualify_DstIp6_get(bcm_unit, entry, data, mask); 8276 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 8277 return rv; 8278 } 8279 } 8280 8281 return BCM_E_UNAVAIL; 8282 } 8283 8284 /* 8285 * Function: 8286 * bcmx_field_qualify_SrcIp6High_get 8287 * Purpose: 8288 * Get match criteria for bcmFieldQualifySrcIp6High 8289 * qualifier from the field entry. 8290 * Parameters: 8291 * entry - (IN) BCM field entry id. 8292 * data - (OUT) Qualifier match data. 8293 * mask - (OUT) Qualifier match mask. 8294 * Returns: 8295 * BCM_E_XXX 8296 * Notes: 8297 */ 8298 int 8299 bcmx_field_qualify_SrcIp6High_get(bcm_field_entry_t entry, 8300 bcm_ip6_t *data, 8301 bcm_ip6_t *mask) 8302 { 8303 int rv; 8304 int i, bcm_unit; 8305 8306 BCMX_FIELD_INIT_CHECK; 8307 8308 BCMX_PARAM_NULL_CHECK(data); 8309 BCMX_PARAM_NULL_CHECK(mask); 8310 8311 BCMX_UNIT_ITER(bcm_unit, i) { 8312 rv = bcm_field_qualify_SrcIp6High_get(bcm_unit, entry, data, mask); 8313 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 8314 return rv; 8315 } 8316 } 8317 8318 return BCM_E_UNAVAIL; 8319 } 8320 8321 /* 8322 * Function: 8323 * bcmx_field_qualify_SrcIp6Low_get 8324 * Purpose: 8325 * Get match criteria for bcmFieldQualifySrcIp6Low 8326 * qualifier from the field entry. 8327 * Parameters: 8328 * entry - (IN) BCM field entry id. 8329 * data - (OUT) Qualifier match data. 8330 * mask - (OUT) Qualifier match mask. 8331 * Returns: 8332 * BCM_E_XXX 8333 * Notes: 8334 */ 8335 int 8336 bcmx_field_qualify_SrcIp6Low_get(bcm_field_entry_t entry, 8337 bcm_ip6_t *data, 8338 bcm_ip6_t *mask) 8339 { 8340 int rv; 8341 int i, bcm_unit; 8342 8343 BCMX_FIELD_INIT_CHECK; 8344 8345 BCMX_PARAM_NULL_CHECK(data); 8346 BCMX_PARAM_NULL_CHECK(mask); 8347 8348 BCMX_UNIT_ITER(bcm_unit, i) { 8349 rv = bcm_field_qualify_SrcIp6Low_get(bcm_unit, entry, data, mask); 8350 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 8351 return rv; 8352 } 8353 } 8354 8355 return BCM_E_UNAVAIL; 8356 } 8357 8358 /* 8359 * Function: 8360 * bcmx_field_qualify_DstIp6Low_get 8361 * Purpose: 8362 * Get match criteria for bcmFieldQualifyDstIp6Low 8363 * qualifier from the field entry. 8364 * Parameters: 8365 * entry - (IN) BCM field entry id. 8366 * data - (OUT) Qualifier match data. 8367 * mask - (OUT) Qualifier match mask. 8368 * Returns: 8369 * BCM_E_XXX 8370 * Notes: 8371 */ 8372 int 8373 bcmx_field_qualify_DstIp6Low_get(bcm_field_entry_t entry, 8374 bcm_ip6_t *data, 8375 bcm_ip6_t *mask) 8376 { 8377 int rv; 8378 int i, bcm_unit; 8379 8380 BCMX_FIELD_INIT_CHECK; 8381 8382 BCMX_PARAM_NULL_CHECK(data); 8383 BCMX_PARAM_NULL_CHECK(mask); 8384 8385 BCMX_UNIT_ITER(bcm_unit, i) { 8386 rv = bcm_field_qualify_DstIp6Low_get(bcm_unit, entry, data, mask); 8387 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 8388 return rv; 8389 } 8390 } 8391 8392 return BCM_E_UNAVAIL; 8393 } 8394 8395 /* 8396 * Function: 8397 * bcmx_field_qualify_DstIp6High_get 8398 * Purpose: 8399 * Get match criteria for bcmFieldQualifyDstIp6High 8400 * qualifier from the field entry. 8401 * Parameters: 8402 * entry - (IN) BCM field entry id. 8403 * data - (OUT) Qualifier match data. 8404 * mask - (OUT) Qualifier match mask. 8405 * Returns: 8406 * BCM_E_XXX 8407 * Notes: 8408 */ 8409 int 8410 bcmx_field_qualify_DstIp6High_get(bcm_field_entry_t entry, 8411 bcm_ip6_t *data, 8412 bcm_ip6_t *mask) 8413 { 8414 int rv; 8415 int i, bcm_unit; 8416 8417 BCMX_FIELD_INIT_CHECK; 8418 8419 BCMX_PARAM_NULL_CHECK(data); 8420 BCMX_PARAM_NULL_CHECK(mask); 8421 8422 BCMX_UNIT_ITER(bcm_unit, i) { 8423 rv = bcm_field_qualify_DstIp6High_get(bcm_unit, entry, data, mask); 8424 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 8425 return rv; 8426 } 8427 } 8428 8429 return BCM_E_UNAVAIL; 8430 } 8431 8432 /* 8433 * Function: 8434 * bcmx_field_qualify_Ip6NextHeader_get 8435 * Purpose: 8436 * Get match criteria for bcmFieldQualifyIp6NextHeader 8437 * qualifier from the field entry. 8438 * Parameters: 8439 * entry - (IN) BCM field entry id. 8440 * data - (OUT) Qualifier match data. 8441 * mask - (OUT) Qualifier match mask. 8442 * Returns: 8443 * BCM_E_XXX 8444 * Notes: 8445 */ 8446 int 8447 bcmx_field_qualify_Ip6NextHeader_get(bcm_field_entry_t entry, 8448 uint8 *data, 8449 uint8 *mask) 8450 { 8451 int rv; 8452 int i, bcm_unit; 8453 8454 BCMX_FIELD_INIT_CHECK; 8455 8456 BCMX_PARAM_NULL_CHECK(data); 8457 BCMX_PARAM_NULL_CHECK(mask); 8458 8459 BCMX_UNIT_ITER(bcm_unit, i) { 8460 rv = bcm_field_qualify_Ip6NextHeader_get(bcm_unit, entry, data, mask); 8461 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 8462 return rv; 8463 } 8464 } 8465 8466 return BCM_E_UNAVAIL; 8467 } 8468 8469 /* 8470 * Function: 8471 * bcmx_field_qualify_Ip6TrafficClass_get 8472 * Purpose: 8473 * Get match criteria for bcmFieldQualifyIp6TrafficClass 8474 * qualifier from the field entry. 8475 * Parameters: 8476 * entry - (IN) BCM field entry id. 8477 * data - (OUT) Qualifier match data. 8478 * mask - (OUT) Qualifier match mask. 8479 * Returns: 8480 * BCM_E_XXX 8481 * Notes: 8482 */ 8483 int 8484 bcmx_field_qualify_Ip6TrafficClass_get(bcm_field_entry_t entry, 8485 uint8 *data, 8486 uint8 *mask) 8487 { 8488 int rv; 8489 int i, bcm_unit; 8490 8491 BCMX_FIELD_INIT_CHECK; 8492 8493 BCMX_PARAM_NULL_CHECK(data); 8494 BCMX_PARAM_NULL_CHECK(mask); 8495 8496 BCMX_UNIT_ITER(bcm_unit, i) { 8497 rv = bcm_field_qualify_Ip6TrafficClass_get(bcm_unit, entry, data, mask); 8498 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 8499 return rv; 8500 } 8501 } 8502 8503 return BCM_E_UNAVAIL; 8504 } 8505 8506 /* 8507 * Function: 8508 * bcmx_field_qualify_InnerIp6FlowLabel_get 8509 * Purpose: 8510 * Get match criteria for bcmFieldQualifyInnerIp6FlowLabel 8511 * qualifier from the field entry. 8512 * Parameters: 8513 * entry - (IN) BCM field entry id. 8514 * data - (OUT) Qualifier match data. 8515 * mask - (OUT) Qualifier match mask. 8516 * Returns: 8517 * BCM_E_XXX 8518 * Notes: 8519 */ 8520 int 8521 bcmx_field_qualify_InnerIp6FlowLabel_get(bcm_field_entry_t entry, 8522 uint32 *data, 8523 uint32 *mask) 8524 { 8525 int rv; 8526 int i, bcm_unit; 8527 8528 BCMX_FIELD_INIT_CHECK; 8529 8530 BCMX_PARAM_NULL_CHECK(data); 8531 BCMX_PARAM_NULL_CHECK(mask); 8532 8533 BCMX_UNIT_ITER(bcm_unit, i) { 8534 rv = bcm_field_qualify_InnerIp6FlowLabel_get(bcm_unit, entry, data, mask); 8535 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 8536 return rv; 8537 } 8538 } 8539 8540 return BCM_E_UNAVAIL; 8541 } 8542 8543 /* 8544 * Function: 8545 * bcmx_field_qualify_Ip6FlowLabel_get 8546 * Purpose: 8547 * Get match criteria for bcmFieldQualifyIp6FlowLabel 8548 * qualifier from the field entry. 8549 * Parameters: 8550 * entry - (IN) BCM field entry id. 8551 * data - (OUT) Qualifier match data. 8552 * mask - (OUT) Qualifier match mask. 8553 * Returns: 8554 * BCM_E_XXX 8555 * Notes: 8556 */ 8557 int 8558 bcmx_field_qualify_Ip6FlowLabel_get(bcm_field_entry_t entry, 8559 uint32 *data, 8560 uint32 *mask) 8561 { 8562 int rv; 8563 int i, bcm_unit; 8564 8565 BCMX_FIELD_INIT_CHECK; 8566 8567 BCMX_PARAM_NULL_CHECK(data); 8568 BCMX_PARAM_NULL_CHECK(mask); 8569 8570 BCMX_UNIT_ITER(bcm_unit, i) { 8571 rv = bcm_field_qualify_Ip6FlowLabel_get(bcm_unit, entry, data, mask); 8572 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 8573 return rv; 8574 } 8575 } 8576 8577 return BCM_E_UNAVAIL; 8578 } 8579 8580 /* 8581 * Function: 8582 * bcmx_field_qualify_Ip6HopLimit_get 8583 * Purpose: 8584 * Get match criteria for bcmFieldQualifyIp6HopLimit 8585 * qualifier from the field entry. 8586 * Parameters: 8587 * entry - (IN) BCM field entry id. 8588 * data - (OUT) Qualifier match data. 8589 * mask - (OUT) Qualifier match mask. 8590 * Returns: 8591 * BCM_E_XXX 8592 * Notes: 8593 */ 8594 int 8595 bcmx_field_qualify_Ip6HopLimit_get(bcm_field_entry_t entry, 8596 uint8 *data, 8597 uint8 *mask) 8598 { 8599 int rv; 8600 int i, bcm_unit; 8601 8602 BCMX_FIELD_INIT_CHECK; 8603 8604 BCMX_PARAM_NULL_CHECK(data); 8605 BCMX_PARAM_NULL_CHECK(mask); 8606 8607 BCMX_UNIT_ITER(bcm_unit, i) { 8608 rv = bcm_field_qualify_Ip6HopLimit_get(bcm_unit, entry, data, mask); 8609 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 8610 return rv; 8611 } 8612 } 8613 8614 return BCM_E_UNAVAIL; 8615 } 8616 8617 /* 8618 * Function: 8619 * bcmx_field_qualify_SrcMac_get 8620 * Purpose: 8621 * Get match criteria for bcmFieldQualifySrcMac 8622 * qualifier from the field entry. 8623 * Parameters: 8624 * entry - (IN) BCM field entry id. 8625 * data - (OUT) Qualifier match data. 8626 * mask - (OUT) Qualifier match mask. 8627 * Returns: 8628 * BCM_E_XXX 8629 * Notes: 8630 */ 8631 int 8632 bcmx_field_qualify_SrcMac_get(bcm_field_entry_t entry, 8633 bcm_mac_t *data, 8634 bcm_mac_t *mask) 8635 { 8636 int rv; 8637 int i, bcm_unit; 8638 8639 BCMX_FIELD_INIT_CHECK; 8640 8641 BCMX_PARAM_NULL_CHECK(data); 8642 BCMX_PARAM_NULL_CHECK(mask); 8643 8644 BCMX_UNIT_ITER(bcm_unit, i) { 8645 rv = bcm_field_qualify_SrcMac_get(bcm_unit, entry, data, mask); 8646 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 8647 return rv; 8648 } 8649 } 8650 8651 return BCM_E_UNAVAIL; 8652 } 8653 8654 /* 8655 * Function: 8656 * bcmx_field_qualify_DstMac_get 8657 * Purpose: 8658 * Get match criteria for bcmFieldQualifyDstMac 8659 * qualifier from the field entry. 8660 * Parameters: 8661 * entry - (IN) BCM field entry id. 8662 * data - (OUT) Qualifier match data. 8663 * mask - (OUT) Qualifier match mask. 8664 * Returns: 8665 * BCM_E_XXX 8666 * Notes: 8667 */ 8668 int 8669 bcmx_field_qualify_DstMac_get(bcm_field_entry_t entry, 8670 bcm_mac_t *data, 8671 bcm_mac_t *mask) 8672 { 8673 int rv; 8674 int i, bcm_unit; 8675 8676 BCMX_FIELD_INIT_CHECK; 8677 8678 BCMX_PARAM_NULL_CHECK(data); 8679 BCMX_PARAM_NULL_CHECK(mask); 8680 8681 BCMX_UNIT_ITER(bcm_unit, i) { 8682 rv = bcm_field_qualify_DstMac_get(bcm_unit, entry, data, mask); 8683 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 8684 return rv; 8685 } 8686 } 8687 8688 return BCM_E_UNAVAIL; 8689 } 8690 8691 /* 8692 * Function: 8693 * bcmx_field_qualify_InnerIpType_get 8694 * Purpose: 8695 * Get match criteria for bcmFieldQualifyInnerIpType 8696 * qualifier from the field entry. 8697 * Parameters: 8698 * entry - (IN) BCM field entry id. 8699 * type - (OUT) Inner ip header ip type. 8700 * Returns: 8701 * BCM_E_XXX 8702 * Notes: 8703 */ 8704 int 8705 bcmx_field_qualify_InnerIpType_get(bcm_field_entry_t entry, 8706 bcm_field_IpType_t *type) 8707 { 8708 int rv; 8709 int i, bcm_unit; 8710 8711 BCMX_FIELD_INIT_CHECK; 8712 8713 BCMX_PARAM_NULL_CHECK(type); 8714 8715 BCMX_UNIT_ITER(bcm_unit, i) { 8716 rv = bcm_field_qualify_InnerIpType_get(bcm_unit, entry, type); 8717 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 8718 return rv; 8719 } 8720 } 8721 8722 return BCM_E_UNAVAIL; 8723 } 8724 8725 /* 8726 * Function: 8727 * bcmx_field_qualify_ForwardingType_get 8728 * Purpose: 8729 * Get match criteria for bcmFieldQualifyForwardingType 8730 * qualifier from the field entry. 8731 * Parameters: 8732 * entry - (IN) BCM field entry id. 8733 * type - (OUT) Qualifier match forwarding type. 8734 * Returns: 8735 * BCM_E_XXX 8736 * Notes: 8737 */ 8738 int 8739 bcmx_field_qualify_ForwardingType_get(bcm_field_entry_t entry, 8740 bcm_field_ForwardingType_t *type) 8741 { 8742 int rv; 8743 int i, bcm_unit; 8744 8745 BCMX_FIELD_INIT_CHECK; 8746 8747 BCMX_PARAM_NULL_CHECK(type); 8748 8749 BCMX_UNIT_ITER(bcm_unit, i) { 8750 rv = bcm_field_qualify_ForwardingType_get(bcm_unit, entry, type); 8751 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 8752 return rv; 8753 } 8754 } 8755 8756 return BCM_E_UNAVAIL; 8757 } 8758 8759 /* 8760 * Function: 8761 * bcmx_field_qualify_IpType_get 8762 * Purpose: 8763 * Get match criteria for bcmFieldQualifyIpType 8764 * qualifier from the field entry. 8765 * Parameters: 8766 * entry - (IN) BCM field entry id. 8767 * type - (OUT) Qualifier match ip type. 8768 * Returns: 8769 * BCM_E_XXX 8770 * Notes: 8771 */ 8772 int 8773 bcmx_field_qualify_IpType_get(bcm_field_entry_t entry, 8774 bcm_field_IpType_t *type) 8775 { 8776 int rv; 8777 int i, bcm_unit; 8778 8779 BCMX_FIELD_INIT_CHECK; 8780 8781 BCMX_PARAM_NULL_CHECK(type); 8782 8783 BCMX_UNIT_ITER(bcm_unit, i) { 8784 rv = bcm_field_qualify_IpType_get(bcm_unit, entry, type); 8785 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 8786 return rv; 8787 } 8788 } 8789 8790 return BCM_E_UNAVAIL; 8791 } 8792 8793 /* 8794 * Function: 8795 * bcmx_field_qualify_L2Format_get 8796 * Purpose: 8797 * Get match criteria for bcmFieldQualifyL2Format 8798 * qualifier from the field entry. 8799 * Parameters: 8800 * entry - (IN) BCM field entry id. 8801 * type - (OUT) Qualifier match l2 format. 8802 * Returns: 8803 * BCM_E_XXX 8804 * Notes: 8805 */ 8806 int 8807 bcmx_field_qualify_L2Format_get(bcm_field_entry_t entry, 8808 bcm_field_L2Format_t *type) 8809 { 8810 int rv; 8811 int i, bcm_unit; 8812 8813 BCMX_FIELD_INIT_CHECK; 8814 8815 BCMX_PARAM_NULL_CHECK(type); 8816 8817 BCMX_UNIT_ITER(bcm_unit, i) { 8818 rv = bcm_field_qualify_L2Format_get(bcm_unit, entry, type); 8819 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 8820 return rv; 8821 } 8822 } 8823 8824 return BCM_E_UNAVAIL; 8825 } 8826 8827 /* 8828 * Function: 8829 * bcmx_field_qualify_VlanFormat_get 8830 * Purpose: 8831 * Get match criteria for bcmFieldQualifyVlanFormat 8832 * qualifier from the field entry. 8833 * Parameters: 8834 * entry - (IN) BCM field entry id. 8835 * data - (OUT) Qualifier match data. 8836 * mask - (OUT) Qualifier match mask. 8837 * Returns: 8838 * BCM_E_XXX 8839 * Notes: 8840 */ 8841 int 8842 bcmx_field_qualify_VlanFormat_get(bcm_field_entry_t entry, 8843 uint8 *data, 8844 uint8 *mask) 8845 { 8846 int rv; 8847 int i, bcm_unit; 8848 8849 BCMX_FIELD_INIT_CHECK; 8850 8851 BCMX_PARAM_NULL_CHECK(data); 8852 BCMX_PARAM_NULL_CHECK(mask); 8853 8854 BCMX_UNIT_ITER(bcm_unit, i) { 8855 rv = bcm_field_qualify_VlanFormat_get(bcm_unit, entry, data, mask); 8856 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 8857 return rv; 8858 } 8859 } 8860 8861 return BCM_E_UNAVAIL; 8862 } 8863 8864 /* 8865 * Function: 8866 * bcmx_field_qualify_TranslatedVlanFormat_get 8867 * Purpose: 8868 * Get match criteria for bcmFieldQualifyTranslatedVlanFormat 8869 * qualifier from the field entry. 8870 * Parameters: 8871 * entry - (IN) BCM field entry id. 8872 * data - (OUT) Qualifier match data. 8873 * mask - (OUT) Qualifier match mask. 8874 * Returns: 8875 * BCM_E_XXX 8876 * Notes: 8877 */ 8878 int 8879 bcmx_field_qualify_TranslatedVlanFormat_get(bcm_field_entry_t entry, 8880 uint8 *data, uint8 *mask) 8881 { 8882 int rv; 8883 int i, bcm_unit; 8884 8885 BCMX_FIELD_INIT_CHECK; 8886 8887 BCMX_PARAM_NULL_CHECK(data); 8888 BCMX_PARAM_NULL_CHECK(mask); 8889 8890 BCMX_UNIT_ITER(bcm_unit, i) { 8891 rv = bcm_field_qualify_TranslatedVlanFormat_get(bcm_unit, entry, data, mask); 8892 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 8893 return rv; 8894 } 8895 } 8896 8897 return BCM_E_UNAVAIL; 8898 } 8899 8900 /* 8901 * Function: 8902 * bcmx_field_qualify_MHOpcode_get 8903 * Purpose: 8904 * Get match criteria for bcmFieldQualifyMHOpcode 8905 * qualifier from the field entry. 8906 * Parameters: 8907 * entry - (IN) BCM field entry id. 8908 * data - (OUT) Qualifier match data. 8909 * mask - (OUT) Qualifier match mask. 8910 * Returns: 8911 * BCM_E_XXX 8912 * Notes: 8913 */ 8914 int 8915 bcmx_field_qualify_MHOpcode_get(bcm_field_entry_t entry, 8916 uint8 *data, 8917 uint8 *mask) 8918 { 8919 int rv; 8920 int i, bcm_unit; 8921 8922 BCMX_FIELD_INIT_CHECK; 8923 8924 BCMX_PARAM_NULL_CHECK(data); 8925 BCMX_PARAM_NULL_CHECK(mask); 8926 8927 BCMX_UNIT_ITER(bcm_unit, i) { 8928 rv = bcm_field_qualify_MHOpcode_get(bcm_unit, entry, data, mask); 8929 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 8930 return rv; 8931 } 8932 } 8933 8934 return BCM_E_UNAVAIL; 8935 } 8936 8937 /* 8938 * Function: 8939 * bcmx_field_qualify_HiGig_get 8940 * Purpose: 8941 * Qualify on HiGig packets. 8942 * Parameters: 8943 * entry - (IN) BCM field entry id. 8944 * data - (OUT) Qualifier match data. 8945 * mask - (OUT) Qualifier match mask. 8946 * Returns: 8947 * BCM_E_XXX 8948 * Notes: 8949 */ 8950 int 8951 bcmx_field_qualify_HiGig_get(bcm_field_entry_t entry, 8952 uint8 *data, 8953 uint8 *mask) 8954 { 8955 int rv; 8956 int i, bcm_unit; 8957 8958 BCMX_FIELD_INIT_CHECK; 8959 8960 BCMX_PARAM_NULL_CHECK(data); 8961 BCMX_PARAM_NULL_CHECK(mask); 8962 8963 BCMX_UNIT_ITER(bcm_unit, i) { 8964 rv = bcm_field_qualify_HiGig_get(bcm_unit, entry, data, mask); 8965 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 8966 return rv; 8967 } 8968 } 8969 8970 return BCM_E_UNAVAIL; 8971 } 8972 8973 /* 8974 * Function: 8975 * bcmx_field_qualify_DstHiGig_get 8976 * Purpose: 8977 * Qualify on packets destined to higig port. 8978 * Parameters: 8979 * entry - (IN) BCM field entry id. 8980 * data - (OUT) Qualifier match data. 8981 * mask - (OUT) Qualifier match mask. 8982 * Returns: 8983 * BCM_E_XXX 8984 * Notes: 8985 */ 8986 int 8987 bcmx_field_qualify_DstHiGig_get(bcm_field_entry_t entry, 8988 uint8 *data, 8989 uint8 *mask) 8990 { 8991 int rv; 8992 int i, bcm_unit; 8993 8994 BCMX_FIELD_INIT_CHECK; 8995 8996 BCMX_PARAM_NULL_CHECK(data); 8997 BCMX_PARAM_NULL_CHECK(mask); 8998 8999 BCMX_UNIT_ITER(bcm_unit, i) { 9000 rv = bcm_field_qualify_DstHiGig_get(bcm_unit, entry, data, mask); 9001 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 9002 return rv; 9003 } 9004 } 9005 9006 return BCM_E_UNAVAIL; 9007 } 9008 9009 /* 9010 * Function: 9011 * bcmx_field_qualify_InterfaceClassPort_get 9012 * Purpose: 9013 * Get match criteria for bcmFieldQualifyInterfaceClassPort 9014 * qualifier from the field entry. 9015 * Parameters: 9016 * entry - (IN) BCM field entry id. 9017 * data - (OUT) Qualifier match data. 9018 * mask - (OUT) Qualifier match mask. 9019 * Returns: 9020 * BCM_E_XXX 9021 * Notes: 9022 */ 9023 int 9024 bcmx_field_qualify_InterfaceClassPort_get(bcm_field_entry_t entry, 9025 uint32 *data, 9026 uint32 *mask) 9027 { 9028 int rv; 9029 int i, bcm_unit; 9030 9031 BCMX_FIELD_INIT_CHECK; 9032 9033 BCMX_PARAM_NULL_CHECK(data); 9034 BCMX_PARAM_NULL_CHECK(mask); 9035 9036 BCMX_UNIT_ITER(bcm_unit, i) { 9037 rv = bcm_field_qualify_InterfaceClassPort_get(bcm_unit, entry, data, mask); 9038 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 9039 return rv; 9040 } 9041 } 9042 9043 return BCM_E_UNAVAIL; 9044 } 9045 9046 /* 9047 * Function: 9048 * bcmx_field_qualify_InterfaceClassL2_get 9049 * Purpose: 9050 * Get match criteria for bcmFieldQualifyInterfaceClassL2 9051 * qualifier from the field entry. 9052 * Parameters: 9053 * entry - (IN) BCM field entry id. 9054 * data - (OUT) Qualifier match data. 9055 * mask - (OUT) Qualifier match mask. 9056 * Returns: 9057 * BCM_E_XXX 9058 * Notes: 9059 */ 9060 int 9061 bcmx_field_qualify_InterfaceClassL2_get(bcm_field_entry_t entry, 9062 uint32 *data, 9063 uint32 *mask) 9064 { 9065 int rv; 9066 int i, bcm_unit; 9067 9068 BCMX_FIELD_INIT_CHECK; 9069 9070 BCMX_PARAM_NULL_CHECK(data); 9071 BCMX_PARAM_NULL_CHECK(mask); 9072 9073 BCMX_UNIT_ITER(bcm_unit, i) { 9074 rv = bcm_field_qualify_InterfaceClassL2_get(bcm_unit, entry, data, mask); 9075 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 9076 return rv; 9077 } 9078 } 9079 9080 return BCM_E_UNAVAIL; 9081 } 9082 9083 /* 9084 * Function: 9085 * bcmx_field_qualify_InterfaceClassL3_get 9086 * Purpose: 9087 * Get match criteria for bcmFieldQualifyInterfaceClassL3 9088 * qualifier from the field entry. 9089 * Parameters: 9090 * entry - (IN) BCM field entry id. 9091 * data - (OUT) Qualifier match data. 9092 * mask - (OUT) Qualifier match mask. 9093 * Returns: 9094 * BCM_E_XXX 9095 * Notes: 9096 */ 9097 int 9098 bcmx_field_qualify_InterfaceClassL3_get(bcm_field_entry_t entry, 9099 uint32 *data, 9100 uint32 *mask) 9101 { 9102 int rv; 9103 int i, bcm_unit; 9104 9105 BCMX_FIELD_INIT_CHECK; 9106 9107 BCMX_PARAM_NULL_CHECK(data); 9108 BCMX_PARAM_NULL_CHECK(mask); 9109 9110 BCMX_UNIT_ITER(bcm_unit, i) { 9111 rv = bcm_field_qualify_InterfaceClassL3_get(bcm_unit, entry, data, mask); 9112 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 9113 return rv; 9114 } 9115 } 9116 9117 return BCM_E_UNAVAIL; 9118 } 9119 9120 /* 9121 * Function: 9122 * bcmx_field_qualify_SrcClassL2_get 9123 * Purpose: 9124 * Get match criteria for bcmFieldQualifySrcClassL2 9125 * qualifier from the field entry. 9126 * Parameters: 9127 * entry - (IN) BCM field entry id. 9128 * data - (OUT) Qualifier match data. 9129 * mask - (OUT) Qualifier match mask. 9130 * Returns: 9131 * BCM_E_XXX 9132 * Notes: 9133 */ 9134 int 9135 bcmx_field_qualify_SrcClassL2_get(bcm_field_entry_t entry, 9136 uint32 *data, 9137 uint32 *mask) 9138 { 9139 int rv; 9140 int i, bcm_unit; 9141 9142 BCMX_FIELD_INIT_CHECK; 9143 9144 BCMX_PARAM_NULL_CHECK(data); 9145 BCMX_PARAM_NULL_CHECK(mask); 9146 9147 BCMX_UNIT_ITER(bcm_unit, i) { 9148 rv = bcm_field_qualify_SrcClassL2_get(bcm_unit, entry, data, mask); 9149 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 9150 return rv; 9151 } 9152 } 9153 9154 return BCM_E_UNAVAIL; 9155 } 9156 9157 /* 9158 * Function: 9159 * bcmx_field_qualify_SrcClassL3_get 9160 * Purpose: 9161 * Get match criteria for bcmFieldQualifySrcClassL3 9162 * qualifier from the field entry. 9163 * Parameters: 9164 * entry - (IN) BCM field entry id. 9165 * data - (OUT) Qualifier match data. 9166 * mask - (OUT) Qualifier match mask. 9167 * Returns: 9168 * BCM_E_XXX 9169 * Notes: 9170 */ 9171 int 9172 bcmx_field_qualify_SrcClassL3_get(bcm_field_entry_t entry, 9173 uint32 *data, 9174 uint32 *mask) 9175 { 9176 int rv; 9177 int i, bcm_unit; 9178 9179 BCMX_FIELD_INIT_CHECK; 9180 9181 BCMX_PARAM_NULL_CHECK(data); 9182 BCMX_PARAM_NULL_CHECK(mask); 9183 9184 BCMX_UNIT_ITER(bcm_unit, i) { 9185 rv = bcm_field_qualify_SrcClassL3_get(bcm_unit, entry, data, mask); 9186 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 9187 return rv; 9188 } 9189 } 9190 9191 return BCM_E_UNAVAIL; 9192 } 9193 9194 /* 9195 * Function: 9196 * bcmx_field_qualify_SrcClassField_get 9197 * Purpose: 9198 * Get match criteria for bcmFieldQualifySrcClassField 9199 * qualifier from the field entry. 9200 * Parameters: 9201 * entry - (IN) BCM field entry id. 9202 * data - (OUT) Qualifier match data. 9203 * mask - (OUT) Qualifier match mask. 9204 * Returns: 9205 * BCM_E_XXX 9206 * Notes: 9207 */ 9208 int 9209 bcmx_field_qualify_SrcClassField_get(bcm_field_entry_t entry, 9210 uint32 *data, 9211 uint32 *mask) 9212 { 9213 int rv; 9214 int i, bcm_unit; 9215 9216 BCMX_FIELD_INIT_CHECK; 9217 9218 BCMX_PARAM_NULL_CHECK(data); 9219 BCMX_PARAM_NULL_CHECK(mask); 9220 9221 BCMX_UNIT_ITER(bcm_unit, i) { 9222 rv = bcm_field_qualify_SrcClassField_get(bcm_unit, entry, data, mask); 9223 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 9224 return rv; 9225 } 9226 } 9227 9228 return BCM_E_UNAVAIL; 9229 } 9230 9231 /* 9232 * Function: 9233 * bcmx_field_qualify_DstClassL2_get 9234 * Purpose: 9235 * Get match criteria for bcmFieldQualifyDstClassL2 9236 * qualifier from the field entry. 9237 * Parameters: 9238 * entry - (IN) BCM field entry id. 9239 * data - (OUT) Qualifier match data. 9240 * mask - (OUT) Qualifier match mask. 9241 * Returns: 9242 * BCM_E_XXX 9243 * Notes: 9244 */ 9245 int 9246 bcmx_field_qualify_DstClassL2_get(bcm_field_entry_t entry, 9247 uint32 *data, 9248 uint32 *mask) 9249 { 9250 int rv; 9251 int i, bcm_unit; 9252 9253 BCMX_FIELD_INIT_CHECK; 9254 9255 BCMX_PARAM_NULL_CHECK(data); 9256 BCMX_PARAM_NULL_CHECK(mask); 9257 9258 BCMX_UNIT_ITER(bcm_unit, i) { 9259 rv = bcm_field_qualify_DstClassL2_get(bcm_unit, entry, data, mask); 9260 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 9261 return rv; 9262 } 9263 } 9264 9265 return BCM_E_UNAVAIL; 9266 } 9267 9268 /* 9269 * Function: 9270 * bcmx_field_qualify_DstClassL3_get 9271 * Purpose: 9272 * Get match criteria for bcmFieldQualifyDstClassL3 9273 * qualifier from the field entry. 9274 * Parameters: 9275 * entry - (IN) BCM field entry id. 9276 * data - (OUT) Qualifier match data. 9277 * mask - (OUT) Qualifier match mask. 9278 * Returns: 9279 * BCM_E_XXX 9280 * Notes: 9281 */ 9282 int 9283 bcmx_field_qualify_DstClassL3_get(bcm_field_entry_t entry, 9284 uint32 *data, 9285 uint32 *mask) 9286 { 9287 int rv; 9288 int i, bcm_unit; 9289 9290 BCMX_FIELD_INIT_CHECK; 9291 9292 BCMX_PARAM_NULL_CHECK(data); 9293 BCMX_PARAM_NULL_CHECK(mask); 9294 9295 BCMX_UNIT_ITER(bcm_unit, i) { 9296 rv = bcm_field_qualify_DstClassL3_get(bcm_unit, entry, data, mask); 9297 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 9298 return rv; 9299 } 9300 } 9301 9302 return BCM_E_UNAVAIL; 9303 } 9304 9305 /* 9306 * Function: 9307 * bcmx_field_qualify_DstClassField_get 9308 * Purpose: 9309 * Get match criteria for bcmFieldQualifyDstClassField 9310 * qualifier from the field entry. 9311 * Parameters: 9312 * entry - (IN) BCM field entry id. 9313 * data - (OUT) Qualifier match data. 9314 * mask - (OUT) Qualifier match mask. 9315 * Returns: 9316 * BCM_E_XXX 9317 * Notes: 9318 */ 9319 int 9320 bcmx_field_qualify_DstClassField_get(bcm_field_entry_t entry, 9321 uint32 *data, 9322 uint32 *mask) 9323 { 9324 int rv; 9325 int i, bcm_unit; 9326 9327 BCMX_FIELD_INIT_CHECK; 9328 9329 BCMX_PARAM_NULL_CHECK(data); 9330 BCMX_PARAM_NULL_CHECK(mask); 9331 9332 BCMX_UNIT_ITER(bcm_unit, i) { 9333 rv = bcm_field_qualify_DstClassField_get(bcm_unit, entry, data, mask); 9334 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 9335 return rv; 9336 } 9337 } 9338 9339 return BCM_E_UNAVAIL; 9340 } 9341 9342 /* 9343 * Function: 9344 * bcmx_field_qualify_IpProtocolCommon_get 9345 * Purpose: 9346 * Get match criteria for bcmFieldQualifyIpProtocolCommon 9347 * qualifier from the field entry. 9348 * Parameters: 9349 * entry - (IN) BCM field entry id. 9350 * protocol - (OUT) Qualifier protocol encoding. 9351 * Returns: 9352 * BCM_E_XXX 9353 * Notes: 9354 */ 9355 int 9356 bcmx_field_qualify_IpProtocolCommon_get(bcm_field_entry_t entry, 9357 bcm_field_IpProtocolCommon_t *protocol) 9358 { 9359 int rv; 9360 int i, bcm_unit; 9361 9362 BCMX_FIELD_INIT_CHECK; 9363 9364 BCMX_PARAM_NULL_CHECK(protocol); 9365 9366 BCMX_UNIT_ITER(bcm_unit, i) { 9367 rv = bcm_field_qualify_IpProtocolCommon_get(bcm_unit, entry, protocol); 9368 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 9369 return rv; 9370 } 9371 } 9372 9373 return BCM_E_UNAVAIL; 9374 } 9375 9376 /* 9377 * Function: 9378 * bcmx_field_qualify_InnerIpProtocolCommon_get 9379 * Purpose: 9380 * Get match criteria for bcmFieldQualifyInnerIpProtocolCommon 9381 * qualifier from the field entry. 9382 * Parameters: 9383 * entry - (IN) BCM field entry id. 9384 * protocol - (OUT) Qualifier inner ip protocol encodnig. 9385 * Returns: 9386 * BCM_E_XXX 9387 * Notes: 9388 */ 9389 int 9390 bcmx_field_qualify_InnerIpProtocolCommon_get(bcm_field_entry_t entry, 9391 bcm_field_IpProtocolCommon_t *protocol) 9392 { 9393 int rv; 9394 int i, bcm_unit; 9395 9396 BCMX_FIELD_INIT_CHECK; 9397 9398 BCMX_PARAM_NULL_CHECK(protocol); 9399 9400 BCMX_UNIT_ITER(bcm_unit, i) { 9401 rv = bcm_field_qualify_InnerIpProtocolCommon_get(bcm_unit, entry, protocol); 9402 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 9403 return rv; 9404 } 9405 } 9406 9407 return BCM_E_UNAVAIL; 9408 } 9409 9410 /* 9411 * Function: 9412 * bcmx_field_qualify_Snap_get 9413 * Purpose: 9414 * Get match criteria for bcmFieldQualifySnap 9415 * qualifier from the field entry. 9416 * Parameters: 9417 * entry - (IN) BCM field entry id. 9418 * data - (OUT) Qualifier match data. 9419 * mask - (OUT) Qualifier match mask. 9420 * Returns: 9421 * BCM_E_XXX 9422 * Notes: 9423 */ 9424 int 9425 bcmx_field_qualify_Snap_get(bcm_field_entry_t entry, 9426 bcm_field_snap_header_t *data, 9427 bcm_field_snap_header_t *mask) 9428 { 9429 int rv; 9430 int i, bcm_unit; 9431 9432 BCMX_FIELD_INIT_CHECK; 9433 9434 BCMX_PARAM_NULL_CHECK(data); 9435 BCMX_PARAM_NULL_CHECK(mask); 9436 9437 BCMX_UNIT_ITER(bcm_unit, i) { 9438 rv = bcm_field_qualify_Snap_get(bcm_unit, entry, data, mask); 9439 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 9440 return rv; 9441 } 9442 } 9443 9444 return BCM_E_UNAVAIL; 9445 } 9446 9447 /* 9448 * Function: 9449 * bcmx_field_qualify_Llc_get 9450 * Purpose: 9451 * Get match criteria for bcmFieldQualifyLlc 9452 * qualifier from the field entry. 9453 * Parameters: 9454 * entry - (IN) BCM field entry id. 9455 * data - (OUT) Qualifier match data. 9456 * mask - (OUT) Qualifier match mask. 9457 * Returns: 9458 * BCM_E_XXX 9459 * Notes: 9460 */ 9461 int 9462 bcmx_field_qualify_Llc_get(bcm_field_entry_t entry, 9463 bcm_field_llc_header_t *data, 9464 bcm_field_llc_header_t *mask) 9465 { 9466 int rv; 9467 int i, bcm_unit; 9468 9469 BCMX_FIELD_INIT_CHECK; 9470 9471 BCMX_PARAM_NULL_CHECK(data); 9472 BCMX_PARAM_NULL_CHECK(mask); 9473 9474 BCMX_UNIT_ITER(bcm_unit, i) { 9475 rv = bcm_field_qualify_Llc_get(bcm_unit, entry, data, mask); 9476 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 9477 return rv; 9478 } 9479 } 9480 9481 return BCM_E_UNAVAIL; 9482 } 9483 9484 /* 9485 * Function: 9486 * bcmx_field_qualify_InnerTpid_get 9487 * Purpose: 9488 * Get match criteria for bcmFieldQualifyInnerTpid 9489 * qualifier from the field entry. 9490 * Parameters: 9491 * entry - (IN) BCM field entry id. 9492 * tpid - (OUT) Qualifier tpid. 9493 * Returns: 9494 * BCM_E_XXX 9495 * Notes: 9496 */ 9497 int 9498 bcmx_field_qualify_InnerTpid_get(bcm_field_entry_t entry, 9499 uint16 *tpid) 9500 { 9501 int rv; 9502 int i, bcm_unit; 9503 9504 BCMX_FIELD_INIT_CHECK; 9505 9506 BCMX_PARAM_NULL_CHECK(tpid); 9507 9508 BCMX_UNIT_ITER(bcm_unit, i) { 9509 rv = bcm_field_qualify_InnerTpid_get(bcm_unit, entry, tpid); 9510 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 9511 return rv; 9512 } 9513 } 9514 9515 return BCM_E_UNAVAIL; 9516 } 9517 9518 /* 9519 * Function: 9520 * bcmx_field_qualify_OuterTpid_get 9521 * Purpose: 9522 * Get match criteria for bcmFieldQualifyOuterTpid 9523 * qualifier from the field entry. 9524 * Parameters: 9525 * entry - (IN) BCM field entry id. 9526 * tpid - (OUT) Qualifier tpid. 9527 * Returns: 9528 * BCM_E_XXX 9529 * Notes: 9530 */ 9531 int 9532 bcmx_field_qualify_OuterTpid_get(bcm_field_entry_t entry, 9533 uint16 *tpid) 9534 { 9535 int rv; 9536 int i, bcm_unit; 9537 9538 BCMX_FIELD_INIT_CHECK; 9539 9540 BCMX_PARAM_NULL_CHECK(tpid); 9541 9542 BCMX_UNIT_ITER(bcm_unit, i) { 9543 rv = bcm_field_qualify_OuterTpid_get(bcm_unit, entry, tpid); 9544 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 9545 return rv; 9546 } 9547 } 9548 9549 return BCM_E_UNAVAIL; 9550 } 9551 9552 /* 9553 * Function: 9554 * bcmx_field_qualify_L3Routable_get 9555 * Purpose: 9556 * Get match criteria for bcmFieldQualifyL3Routable 9557 * qualifier from the field entry. 9558 * Parameters: 9559 * entry - (IN) BCM field entry id. 9560 * data - (OUT) Qualifier match data. 9561 * mask - (OUT) Qualifier match mask. 9562 * Returns: 9563 * BCM_E_XXX 9564 * Notes: 9565 */ 9566 int 9567 bcmx_field_qualify_L3Routable_get(bcm_field_entry_t entry, 9568 uint8 *data, 9569 uint8 *mask) 9570 { 9571 int rv; 9572 int i, bcm_unit; 9573 9574 BCMX_FIELD_INIT_CHECK; 9575 9576 BCMX_PARAM_NULL_CHECK(data); 9577 BCMX_PARAM_NULL_CHECK(mask); 9578 9579 BCMX_UNIT_ITER(bcm_unit, i) { 9580 rv = bcm_field_qualify_L3Routable_get(bcm_unit, entry, data, mask); 9581 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 9582 return rv; 9583 } 9584 } 9585 9586 return BCM_E_UNAVAIL; 9587 } 9588 9589 /* 9590 * Function: 9591 * bcmx_field_qualify_IpFrag_get 9592 * Purpose: 9593 * Get match criteria for bcmFieldQualifyIpFrag 9594 * qualifier from the field entry. 9595 * Parameters: 9596 * entry - (IN) BCM field entry id. 9597 * frag_info - (OUT) Qualifier ip framentation encoding. 9598 * Returns: 9599 * BCM_E_XXX 9600 * Notes: 9601 */ 9602 int 9603 bcmx_field_qualify_IpFrag_get(bcm_field_entry_t entry, 9604 bcm_field_IpFrag_t *frag_info) 9605 { 9606 int rv; 9607 int i, bcm_unit; 9608 9609 BCMX_FIELD_INIT_CHECK; 9610 9611 BCMX_PARAM_NULL_CHECK(frag_info); 9612 9613 BCMX_UNIT_ITER(bcm_unit, i) { 9614 rv = bcm_field_qualify_IpFrag_get(bcm_unit, entry, frag_info); 9615 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 9616 return rv; 9617 } 9618 } 9619 9620 return BCM_E_UNAVAIL; 9621 } 9622 9623 /* 9624 * Function: 9625 * bcmx_field_qualify_Vrf_get 9626 * Purpose: 9627 * Get match criteria for bcmFieldQualifyVrf 9628 * qualifier from the field entry. 9629 * Parameters: 9630 * entry - (IN) BCM field entry id. 9631 * data - (OUT) Qualifier match data. 9632 * mask - (OUT) Qualifier match mask. 9633 * Returns: 9634 * BCM_E_XXX 9635 * Notes: 9636 */ 9637 int 9638 bcmx_field_qualify_Vrf_get(bcm_field_entry_t entry, 9639 uint32 *data, 9640 uint32 *mask) 9641 { 9642 int rv; 9643 int i, bcm_unit; 9644 9645 BCMX_FIELD_INIT_CHECK; 9646 9647 BCMX_PARAM_NULL_CHECK(data); 9648 BCMX_PARAM_NULL_CHECK(mask); 9649 9650 BCMX_UNIT_ITER(bcm_unit, i) { 9651 rv = bcm_field_qualify_Vrf_get(bcm_unit, entry, data, mask); 9652 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 9653 return rv; 9654 } 9655 } 9656 9657 return BCM_E_UNAVAIL; 9658 } 9659 9660 9661 /* 9662 * Function: 9663 * bcmx_field_qualify_L3Ingress_get 9664 * Purpose: 9665 * Get match criteria for bcmFieldQualifyL3Ingress 9666 * qualifier from the field entry. 9667 * Parameters: 9668 * entry - (IN) BCM field entry id. 9669 * data - (OUT) Qualifier match data. 9670 * mask - (OUT) Qualifier match mask. 9671 * Returns: 9672 * BCM_E_XXX 9673 * Notes: 9674 */ 9675 int 9676 bcmx_field_qualify_L3Ingress_get(bcm_field_entry_t entry, 9677 uint32 *data, 9678 uint32 *mask) 9679 { 9680 int rv; 9681 int i, bcm_unit; 9682 9683 BCMX_FIELD_INIT_CHECK; 9684 9685 BCMX_PARAM_NULL_CHECK(data); 9686 BCMX_PARAM_NULL_CHECK(mask); 9687 9688 BCMX_UNIT_ITER(bcm_unit, i) { 9689 rv = bcm_field_qualify_L3Ingress_get(bcm_unit, entry, data, mask); 9690 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 9691 return rv; 9692 } 9693 } 9694 9695 return BCM_E_UNAVAIL; 9696 } 9697 9698 9699 /* 9700 * Function: 9701 * bcmx_field_qualify_Vpn_get 9702 * Purpose: 9703 * Get match criteria for bcmFieldQualifyVpn 9704 * qualifier from the field entry. 9705 * Parameters: 9706 * entry - (IN) BCM field entry id. 9707 * data - (OUT) Qualifier match data. 9708 * mask - (OUT) Qualifier match mask. 9709 * Returns: 9710 * BCM_E_XXX 9711 * Notes: 9712 */ 9713 int 9714 bcmx_field_qualify_Vpn_get(bcm_field_entry_t entry, 9715 bcm_vpn_t *data, 9716 bcm_vpn_t *mask) 9717 { 9718 int rv; 9719 int i, bcm_unit; 9720 9721 BCMX_FIELD_INIT_CHECK; 9722 9723 BCMX_PARAM_NULL_CHECK(data); 9724 BCMX_PARAM_NULL_CHECK(mask); 9725 9726 BCMX_UNIT_ITER(bcm_unit, i) { 9727 rv = bcm_field_qualify_Vpn_get(bcm_unit, entry, data, mask); 9728 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 9729 return rv; 9730 } 9731 } 9732 9733 return BCM_E_UNAVAIL; 9734 } 9735 9736 /* 9737 * Function: 9738 * bcmx_field_qualify_ExtensionHeaderType_get 9739 * Purpose: 9740 * Get match criteria for bcmFieldQualifyExtensionHeaderType 9741 * qualifier from the field entry. 9742 * Parameters: 9743 * entry - (IN) BCM field entry id. 9744 * data - (OUT) Qualifier match data. 9745 * mask - (OUT) Qualifier match mask. 9746 * Returns: 9747 * BCM_E_XXX 9748 * Notes: 9749 */ 9750 int 9751 bcmx_field_qualify_ExtensionHeaderType_get(bcm_field_entry_t entry, 9752 uint8 *data, 9753 uint8 *mask) 9754 { 9755 int rv; 9756 int i, bcm_unit; 9757 9758 BCMX_FIELD_INIT_CHECK; 9759 9760 BCMX_PARAM_NULL_CHECK(data); 9761 BCMX_PARAM_NULL_CHECK(mask); 9762 9763 BCMX_UNIT_ITER(bcm_unit, i) { 9764 rv = bcm_field_qualify_ExtensionHeaderType_get(bcm_unit, entry, data, mask); 9765 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 9766 return rv; 9767 } 9768 } 9769 9770 return BCM_E_UNAVAIL; 9771 } 9772 9773 /* 9774 * Function: 9775 * bcmx_field_qualify_ExtensionHeaderSubCode_get 9776 * Purpose: 9777 * Get match criteria for bcmFieldQualifyExtensionHeaderSubCode 9778 * qualifier from the field entry. 9779 * Parameters: 9780 * entry - (IN) BCM field entry id. 9781 * data - (OUT) Qualifier match data. 9782 * mask - (OUT) Qualifier match mask. 9783 * Returns: 9784 * BCM_E_XXX 9785 * Notes: 9786 */ 9787 int 9788 bcmx_field_qualify_ExtensionHeaderSubCode_get(bcm_field_entry_t entry, 9789 uint8 *data, 9790 uint8 *mask) 9791 { 9792 int rv; 9793 int i, bcm_unit; 9794 9795 BCMX_FIELD_INIT_CHECK; 9796 9797 BCMX_PARAM_NULL_CHECK(data); 9798 BCMX_PARAM_NULL_CHECK(mask); 9799 9800 BCMX_UNIT_ITER(bcm_unit, i) { 9801 rv = bcm_field_qualify_ExtensionHeaderSubCode_get(bcm_unit, entry, data, mask); 9802 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 9803 return rv; 9804 } 9805 } 9806 9807 return BCM_E_UNAVAIL; 9808 } 9809 9810 /* 9811 * Function: 9812 * bcmx_field_qualify_ExtensionHeader2Type_get 9813 * Purpose: 9814 * Get match criteria for bcmFieldQualifyExtensionHeader2Type 9815 * qualifier from the field entry. 9816 * Parameters: 9817 * entry - (IN) BCM field entry id. 9818 * data - (OUT) Qualifier match data. 9819 * mask - (OUT) Qualifier match mask. 9820 * Returns: 9821 * BCM_E_XXX 9822 * Notes: 9823 */ 9824 int 9825 bcmx_field_qualify_ExtensionHeader2Type_get(bcm_field_entry_t entry, 9826 uint8 *data, uint8 *mask) 9827 { 9828 int rv; 9829 int i, bcm_unit; 9830 9831 BCMX_FIELD_INIT_CHECK; 9832 9833 BCMX_PARAM_NULL_CHECK(data); 9834 BCMX_PARAM_NULL_CHECK(mask); 9835 9836 BCMX_UNIT_ITER(bcm_unit, i) { 9837 rv = bcm_field_qualify_ExtensionHeader2Type_get(bcm_unit, entry, 9838 data, mask); 9839 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 9840 return rv; 9841 } 9842 } 9843 9844 return BCM_E_UNAVAIL; 9845 } 9846 9847 /* 9848 * Function: 9849 * bcmx_field_qualify_L4Ports_get 9850 * Purpose: 9851 * Get match criteria for bcmFieldQualifyL4Ports 9852 * qualifier from the field entry. 9853 * Parameters: 9854 * entry - (IN) BCM field entry id. 9855 * data - (OUT) Qualifier match data. 9856 * mask - (OUT) Qualifier match mask. 9857 * Returns: 9858 * BCM_E_XXX 9859 * Notes: 9860 */ 9861 int 9862 bcmx_field_qualify_L4Ports_get(bcm_field_entry_t entry, 9863 uint8 *data, 9864 uint8 *mask) 9865 { 9866 int rv; 9867 int i, bcm_unit; 9868 9869 BCMX_FIELD_INIT_CHECK; 9870 9871 BCMX_PARAM_NULL_CHECK(data); 9872 BCMX_PARAM_NULL_CHECK(mask); 9873 9874 BCMX_UNIT_ITER(bcm_unit, i) { 9875 rv = bcm_field_qualify_L4Ports_get(bcm_unit, entry, data, mask); 9876 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 9877 return rv; 9878 } 9879 } 9880 9881 return BCM_E_UNAVAIL; 9882 } 9883 9884 /* 9885 * Function: 9886 * bcmx_field_qualify_MirrorCopy_get 9887 * Purpose: 9888 * Get match criteria for bcmFieldQualifyMirrorCopy 9889 * qualifier from the field entry. 9890 * Parameters: 9891 * entry - (IN) BCM field entry id. 9892 * data - (OUT) Qualifier match data. 9893 * mask - (OUT) Qualifier match mask. 9894 * Returns: 9895 * BCM_E_XXX 9896 * Notes: 9897 */ 9898 int 9899 bcmx_field_qualify_MirrorCopy_get(bcm_field_entry_t entry, 9900 uint8 *data, 9901 uint8 *mask) 9902 { 9903 int rv; 9904 int i, bcm_unit; 9905 9906 BCMX_FIELD_INIT_CHECK; 9907 9908 BCMX_PARAM_NULL_CHECK(data); 9909 BCMX_PARAM_NULL_CHECK(mask); 9910 9911 BCMX_UNIT_ITER(bcm_unit, i) { 9912 rv = bcm_field_qualify_MirrorCopy_get(bcm_unit, entry, data, mask); 9913 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 9914 return rv; 9915 } 9916 } 9917 9918 return BCM_E_UNAVAIL; 9919 } 9920 9921 /* 9922 * Function: 9923 * bcmx_field_qualify_TunnelTerminated_get 9924 * Purpose: 9925 * Get match criteria for bcmFieldQualifyTunnelTerminated 9926 * qualifier from the field entry. 9927 * Parameters: 9928 * entry - (IN) BCM field entry id. 9929 * data - (OUT) Qualifier match data. 9930 * mask - (OUT) Qualifier match mask. 9931 * Returns: 9932 * BCM_E_XXX 9933 * Notes: 9934 */ 9935 int 9936 bcmx_field_qualify_TunnelTerminated_get(bcm_field_entry_t entry, 9937 uint8 *data, 9938 uint8 *mask) 9939 { 9940 int rv; 9941 int i, bcm_unit; 9942 9943 BCMX_FIELD_INIT_CHECK; 9944 9945 BCMX_PARAM_NULL_CHECK(data); 9946 BCMX_PARAM_NULL_CHECK(mask); 9947 9948 BCMX_UNIT_ITER(bcm_unit, i) { 9949 rv = bcm_field_qualify_TunnelTerminated_get(bcm_unit, entry, data, mask); 9950 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 9951 return rv; 9952 } 9953 } 9954 9955 return BCM_E_UNAVAIL; 9956 } 9957 9958 /* 9959 * Function: 9960 * bcmx_field_qualify_MplsTerminated_get 9961 * Purpose: 9962 * Get match criteria for bcmFieldQualifyMplsTerminated 9963 * qualifier from the field entry. 9964 * Parameters: 9965 * entry - (IN) BCM field entry id. 9966 * data - (OUT) Qualifier match data. 9967 * mask - (OUT) Qualifier match mask. 9968 * Returns: 9969 * BCM_E_XXX 9970 * Notes: 9971 */ 9972 int 9973 bcmx_field_qualify_MplsTerminated_get(bcm_field_entry_t entry, 9974 uint8 *data, 9975 uint8 *mask) 9976 { 9977 int rv; 9978 int i, bcm_unit; 9979 9980 BCMX_FIELD_INIT_CHECK; 9981 9982 BCMX_PARAM_NULL_CHECK(data); 9983 BCMX_PARAM_NULL_CHECK(mask); 9984 9985 BCMX_UNIT_ITER(bcm_unit, i) { 9986 rv = bcm_field_qualify_MplsTerminated_get(bcm_unit, entry, data, mask); 9987 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 9988 return rv; 9989 } 9990 } 9991 9992 return BCM_E_UNAVAIL; 9993 } 9994 9995 /* 9996 * Function: 9997 * bcmx_field_qualify_InnerSrcIp_get 9998 * Purpose: 9999 * Get match criteria for bcmFieldQualifyInnerSrcIp 10000 * qualifier from the field entry. 10001 * Parameters: 10002 * entry - (IN) BCM field entry id. 10003 * data - (OUT) Qualifier match data. 10004 * mask - (OUT) Qualifier match mask. 10005 * Returns: 10006 * BCM_E_XXX 10007 * Notes: 10008 */ 10009 int 10010 bcmx_field_qualify_InnerSrcIp_get(bcm_field_entry_t entry, 10011 bcm_ip_t *data, 10012 bcm_ip_t *mask) 10013 { 10014 int rv; 10015 int i, bcm_unit; 10016 10017 BCMX_FIELD_INIT_CHECK; 10018 10019 BCMX_PARAM_NULL_CHECK(data); 10020 BCMX_PARAM_NULL_CHECK(mask); 10021 10022 BCMX_UNIT_ITER(bcm_unit, i) { 10023 rv = bcm_field_qualify_InnerSrcIp_get(bcm_unit, entry, data, mask); 10024 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 10025 return rv; 10026 } 10027 } 10028 10029 return BCM_E_UNAVAIL; 10030 } 10031 10032 /* 10033 * Function: 10034 * bcmx_field_qualify_InnerDstIp_get 10035 * Purpose: 10036 * Get match criteria for bcmFieldQualifyInnerDstIp 10037 * qualifier from the field entry. 10038 * Parameters: 10039 * entry - (IN) BCM field entry id. 10040 * data - (OUT) Qualifier match data. 10041 * mask - (OUT) Qualifier match mask. 10042 * Returns: 10043 * BCM_E_XXX 10044 * Notes: 10045 */ 10046 int 10047 bcmx_field_qualify_InnerDstIp_get(bcm_field_entry_t entry, 10048 bcm_ip_t *data, 10049 bcm_ip_t *mask) 10050 { 10051 int rv; 10052 int i, bcm_unit; 10053 10054 BCMX_FIELD_INIT_CHECK; 10055 10056 BCMX_PARAM_NULL_CHECK(data); 10057 BCMX_PARAM_NULL_CHECK(mask); 10058 10059 BCMX_UNIT_ITER(bcm_unit, i) { 10060 rv = bcm_field_qualify_InnerDstIp_get(bcm_unit, entry, data, mask); 10061 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 10062 return rv; 10063 } 10064 } 10065 10066 return BCM_E_UNAVAIL; 10067 } 10068 10069 /* 10070 * Function: 10071 * bcmx_field_qualify_InnerSrcIp6_get 10072 * Purpose: 10073 * Get match criteria for bcmFieldQualifyInnerSrcIp6 10074 * qualifier from the field entry. 10075 * Parameters: 10076 * entry - (IN) BCM field entry id. 10077 * data - (OUT) Qualifier match data. 10078 * mask - (OUT) Qualifier match mask. 10079 * Returns: 10080 * BCM_E_XXX 10081 * Notes: 10082 */ 10083 int 10084 bcmx_field_qualify_InnerSrcIp6_get(bcm_field_entry_t entry, 10085 bcm_ip6_t *data, 10086 bcm_ip6_t *mask) 10087 { 10088 int rv; 10089 int i, bcm_unit; 10090 10091 BCMX_FIELD_INIT_CHECK; 10092 10093 BCMX_PARAM_NULL_CHECK(data); 10094 BCMX_PARAM_NULL_CHECK(mask); 10095 10096 BCMX_UNIT_ITER(bcm_unit, i) { 10097 rv = bcm_field_qualify_InnerSrcIp6_get(bcm_unit, entry, data, mask); 10098 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 10099 return rv; 10100 } 10101 } 10102 10103 return BCM_E_UNAVAIL; 10104 } 10105 10106 /* 10107 * Function: 10108 * bcmx_field_qualify_InnerDstIp6_get 10109 * Purpose: 10110 * Get match criteria for bcmFieldQualifyInnerDstIp6 10111 * qualifier from the field entry. 10112 * Parameters: 10113 * entry - (IN) BCM field entry id. 10114 * data - (OUT) Qualifier match data. 10115 * mask - (OUT) Qualifier match mask. 10116 * Returns: 10117 * BCM_E_XXX 10118 * Notes: 10119 */ 10120 int 10121 bcmx_field_qualify_InnerDstIp6_get(bcm_field_entry_t entry, 10122 bcm_ip6_t *data, 10123 bcm_ip6_t *mask) 10124 { 10125 int rv; 10126 int i, bcm_unit; 10127 10128 BCMX_FIELD_INIT_CHECK; 10129 10130 BCMX_PARAM_NULL_CHECK(data); 10131 BCMX_PARAM_NULL_CHECK(mask); 10132 10133 BCMX_UNIT_ITER(bcm_unit, i) { 10134 rv = bcm_field_qualify_InnerDstIp6_get(bcm_unit, entry, data, mask); 10135 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 10136 return rv; 10137 } 10138 } 10139 10140 return BCM_E_UNAVAIL; 10141 } 10142 10143 /* 10144 * Function: 10145 * bcmx_field_qualify_InnerSrcIp6High_get 10146 * Purpose: 10147 * Get match criteria for bcmFieldQualifyInnerSrcIp6High 10148 * qualifier from the field entry. 10149 * Parameters: 10150 * entry - (IN) BCM field entry id. 10151 * data - (OUT) Qualifier match data. 10152 * mask - (OUT) Qualifier match mask. 10153 * Returns: 10154 * BCM_E_XXX 10155 * Notes: 10156 */ 10157 int 10158 bcmx_field_qualify_InnerSrcIp6High_get(bcm_field_entry_t entry, 10159 bcm_ip6_t *data, 10160 bcm_ip6_t *mask) 10161 { 10162 int rv; 10163 int i, bcm_unit; 10164 10165 BCMX_FIELD_INIT_CHECK; 10166 10167 BCMX_PARAM_NULL_CHECK(data); 10168 BCMX_PARAM_NULL_CHECK(mask); 10169 10170 BCMX_UNIT_ITER(bcm_unit, i) { 10171 rv = bcm_field_qualify_InnerSrcIp6High_get(bcm_unit, entry, data, mask); 10172 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 10173 return rv; 10174 } 10175 } 10176 10177 return BCM_E_UNAVAIL; 10178 } 10179 10180 /* 10181 * Function: 10182 * bcmx_field_qualify_InnerDstIp6High_get 10183 * Purpose: 10184 * Get match criteria for bcmFieldQualifyInnerDstIp6High 10185 * qualifier from the field entry. 10186 * Parameters: 10187 * entry - (IN) BCM field entry id. 10188 * data - (OUT) Qualifier match data. 10189 * mask - (OUT) Qualifier match mask. 10190 * Returns: 10191 * BCM_E_XXX 10192 * Notes: 10193 */ 10194 int 10195 bcmx_field_qualify_InnerDstIp6High_get(bcm_field_entry_t entry, 10196 bcm_ip6_t *data, 10197 bcm_ip6_t *mask) 10198 { 10199 int rv; 10200 int i, bcm_unit; 10201 10202 BCMX_FIELD_INIT_CHECK; 10203 10204 BCMX_PARAM_NULL_CHECK(data); 10205 BCMX_PARAM_NULL_CHECK(mask); 10206 10207 BCMX_UNIT_ITER(bcm_unit, i) { 10208 rv = bcm_field_qualify_InnerDstIp6High_get(bcm_unit, entry, data, mask); 10209 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 10210 return rv; 10211 } 10212 } 10213 10214 return BCM_E_UNAVAIL; 10215 } 10216 10217 /* 10218 * Function: 10219 * bcmx_field_qualify_InnerTtl_get 10220 * Purpose: 10221 * Get match criteria for bcmFieldQualifyInnerTtl 10222 * qualifier from the field entry. 10223 * Parameters: 10224 * entry - (IN) BCM field entry id. 10225 * data - (OUT) Qualifier match data. 10226 * mask - (OUT) Qualifier match mask. 10227 * Returns: 10228 * BCM_E_XXX 10229 * Notes: 10230 */ 10231 int 10232 bcmx_field_qualify_InnerTtl_get(bcm_field_entry_t entry, 10233 uint8 *data, 10234 uint8 *mask) 10235 { 10236 int rv; 10237 int i, bcm_unit; 10238 10239 BCMX_FIELD_INIT_CHECK; 10240 10241 BCMX_PARAM_NULL_CHECK(data); 10242 BCMX_PARAM_NULL_CHECK(mask); 10243 10244 BCMX_UNIT_ITER(bcm_unit, i) { 10245 rv = bcm_field_qualify_InnerTtl_get(bcm_unit, entry, data, mask); 10246 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 10247 return rv; 10248 } 10249 } 10250 10251 return BCM_E_UNAVAIL; 10252 } 10253 10254 /* 10255 * Function: 10256 * bcmx_field_qualify_InnerTos_get 10257 * Purpose: 10258 * Get match criteria for bcmFieldQualifyInnerDSCP 10259 * qualifier from the field entry. 10260 * Parameters: 10261 * entry - (IN) BCM field entry id. 10262 * data - (OUT) Qualifier match data. 10263 * mask - (OUT) Qualifier match mask. 10264 * Returns: 10265 * BCM_E_XXX 10266 * Notes: 10267 */ 10268 int 10269 bcmx_field_qualify_InnerTos_get(bcm_field_entry_t entry, 10270 uint8 *data, 10271 uint8 *mask) 10272 { 10273 int rv; 10274 int i, bcm_unit; 10275 10276 BCMX_FIELD_INIT_CHECK; 10277 10278 BCMX_PARAM_NULL_CHECK(data); 10279 BCMX_PARAM_NULL_CHECK(mask); 10280 10281 BCMX_UNIT_ITER(bcm_unit, i) { 10282 rv = bcm_field_qualify_InnerTos_get(bcm_unit, entry, data, mask); 10283 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 10284 return rv; 10285 } 10286 } 10287 10288 return BCM_E_UNAVAIL; 10289 } 10290 10291 /* 10292 * Function: 10293 * bcmx_field_qualify_InnerDSCP_get 10294 * Purpose: 10295 * Get match criteria for bcmFieldQualifyInnerDSCP 10296 * qualifier from the field entry. 10297 * Parameters: 10298 * entry - (IN) BCM field entry id. 10299 * data - (OUT) Qualifier match data. 10300 * mask - (OUT) Qualifier match mask. 10301 * Returns: 10302 * BCM_E_XXX 10303 * Notes: 10304 */ 10305 int 10306 bcmx_field_qualify_InnerDSCP_get(bcm_field_entry_t entry, 10307 uint8 *data, 10308 uint8 *mask) 10309 { 10310 int rv; 10311 int i, bcm_unit; 10312 10313 BCMX_FIELD_INIT_CHECK; 10314 10315 BCMX_PARAM_NULL_CHECK(data); 10316 BCMX_PARAM_NULL_CHECK(mask); 10317 10318 BCMX_UNIT_ITER(bcm_unit, i) { 10319 rv = bcm_field_qualify_InnerDSCP_get(bcm_unit, entry, data, mask); 10320 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 10321 return rv; 10322 } 10323 } 10324 10325 return BCM_E_UNAVAIL; 10326 } 10327 10328 /* 10329 * Function: 10330 * bcmx_field_qualify_InnerIpProtocol_get 10331 * Purpose: 10332 * Get match criteria for bcmFieldQualifyInnerIpProtocol 10333 * qualifier from the field entry. 10334 * Parameters: 10335 * entry - (IN) BCM field entry id. 10336 * data - (OUT) Qualifier match data. 10337 * mask - (OUT) Qualifier match mask. 10338 * Returns: 10339 * BCM_E_XXX 10340 * Notes: 10341 */ 10342 int 10343 bcmx_field_qualify_InnerIpProtocol_get(bcm_field_entry_t entry, 10344 uint8 *data, 10345 uint8 *mask) 10346 { 10347 int rv; 10348 int i, bcm_unit; 10349 10350 BCMX_FIELD_INIT_CHECK; 10351 10352 BCMX_PARAM_NULL_CHECK(data); 10353 BCMX_PARAM_NULL_CHECK(mask); 10354 10355 BCMX_UNIT_ITER(bcm_unit, i) { 10356 rv = bcm_field_qualify_InnerIpProtocol_get(bcm_unit, entry, data, mask); 10357 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 10358 return rv; 10359 } 10360 } 10361 10362 return BCM_E_UNAVAIL; 10363 } 10364 10365 /* 10366 * Function: 10367 * bcmx_field_qualify_InnerIpFrag_get 10368 * Purpose: 10369 * Get match criteria for bcmFieldQualifyInnerIpFrag 10370 * qualifier from the field entry. 10371 * Parameters: 10372 * entry - (IN) BCM field entry id. 10373 * frag_info - (OUT) Inner ip header fragmentation info. 10374 * Returns: 10375 * BCM_E_XXX 10376 * Notes: 10377 */ 10378 int 10379 bcmx_field_qualify_InnerIpFrag_get(bcm_field_entry_t entry, 10380 bcm_field_IpFrag_t *frag_info) 10381 { 10382 int rv; 10383 int i, bcm_unit; 10384 10385 BCMX_FIELD_INIT_CHECK; 10386 10387 BCMX_PARAM_NULL_CHECK(frag_info); 10388 10389 BCMX_UNIT_ITER(bcm_unit, i) { 10390 rv = bcm_field_qualify_InnerIpFrag_get(bcm_unit, entry, frag_info); 10391 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 10392 return rv; 10393 } 10394 } 10395 10396 return BCM_E_UNAVAIL; 10397 } 10398 10399 /* 10400 * Function: 10401 * bcmx_field_qualify_DosAttack_get 10402 * Purpose: 10403 * Get match criteria for bcmFieldQualifyDosAttack 10404 * qualifier from the field entry. 10405 * Parameters: 10406 * entry - (IN) BCM field entry id. 10407 * data - (OUT) Qualifier match data. 10408 * mask - (OUT) Qualifier match mask. 10409 * Returns: 10410 * BCM_E_XXX 10411 * Notes: 10412 */ 10413 int 10414 bcmx_field_qualify_DosAttack_get(bcm_field_entry_t entry, 10415 uint8 *data, 10416 uint8 *mask) 10417 { 10418 int rv; 10419 int i, bcm_unit; 10420 10421 BCMX_FIELD_INIT_CHECK; 10422 10423 BCMX_PARAM_NULL_CHECK(data); 10424 BCMX_PARAM_NULL_CHECK(mask); 10425 10426 BCMX_UNIT_ITER(bcm_unit, i) { 10427 rv = bcm_field_qualify_DosAttack_get(bcm_unit, entry, data, mask); 10428 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 10429 return rv; 10430 } 10431 } 10432 10433 return BCM_E_UNAVAIL; 10434 } 10435 10436 /* 10437 * Function: 10438 * bcmx_field_qualify_IpmcStarGroupHit_get 10439 * Purpose: 10440 * Get match criteria for bcmFieldQualifyIpmcStarGroupHit 10441 * qualifier from the field entry. 10442 * Parameters: 10443 * entry - (IN) BCM field entry id. 10444 * data - (OUT) Qualifier match data. 10445 * mask - (OUT) Qualifier match mask. 10446 * Returns: 10447 * BCM_E_XXX 10448 * Notes: 10449 */ 10450 int 10451 bcmx_field_qualify_IpmcStarGroupHit_get(bcm_field_entry_t entry, 10452 uint8 *data, 10453 uint8 *mask) 10454 { 10455 int rv; 10456 int i, bcm_unit; 10457 10458 BCMX_FIELD_INIT_CHECK; 10459 10460 BCMX_PARAM_NULL_CHECK(data); 10461 BCMX_PARAM_NULL_CHECK(mask); 10462 10463 BCMX_UNIT_ITER(bcm_unit, i) { 10464 rv = bcm_field_qualify_IpmcStarGroupHit_get(bcm_unit, entry, data, mask); 10465 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 10466 return rv; 10467 } 10468 } 10469 10470 return BCM_E_UNAVAIL; 10471 } 10472 10473 /* 10474 * Function: 10475 * bcmx_field_qualify_MyStationHit_get 10476 * Purpose: 10477 * Get match criteria for bcmFieldQualifyMyStationHit 10478 * qualifier from the field entry. 10479 * Parameters: 10480 * entry - (IN) BCM field entry id. 10481 * data - (OUT) Qualifier match data. 10482 * mask - (OUT) Qualifier match mask. 10483 * Returns: 10484 * BCM_E_XXX 10485 * Notes: 10486 */ 10487 int 10488 bcmx_field_qualify_MyStationHit_get(bcm_field_entry_t entry, 10489 uint8 *data, uint8 *mask) 10490 { 10491 int rv; 10492 int i, bcm_unit; 10493 10494 BCMX_FIELD_INIT_CHECK; 10495 10496 BCMX_PARAM_NULL_CHECK(data); 10497 BCMX_PARAM_NULL_CHECK(mask); 10498 10499 BCMX_UNIT_ITER(bcm_unit, i) { 10500 rv = bcm_field_qualify_MyStationHit_get(bcm_unit, entry, data, mask); 10501 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 10502 return rv; 10503 } 10504 } 10505 10506 return BCM_E_UNAVAIL; 10507 } 10508 10509 /* 10510 * Function: 10511 * bcmx_field_qualify_L2PayloadFirstEightBytes_get 10512 * Purpose: 10513 * Get match criteria for bcmFieldQualifyL2PayloadFirstEightBytes 10514 * qualifier from the field entry. 10515 * Parameters: 10516 * entry - (IN) BCM field entry id. 10517 * data1 - (OUT) Qualifier first four bytes of match data. 10518 * data2 - (OUT) Qualifier last four bytes of match data. 10519 * mask1 - (OUT) Qualifier first four bytes of match mask. 10520 * mask2 - (OUT) Qualifier last four bytes of match mask. 10521 * Returns: 10522 * BCM_E_XXX 10523 * Notes: 10524 */ 10525 int 10526 bcmx_field_qualify_L2PayloadFirstEightBytes_get(bcm_field_entry_t entry, 10527 uint32 *data1, uint32 *data2, 10528 uint32 *mask1, uint32 *mask2) 10529 { 10530 int rv; 10531 int i, bcm_unit; 10532 10533 BCMX_FIELD_INIT_CHECK; 10534 10535 BCMX_PARAM_NULL_CHECK(data1); 10536 BCMX_PARAM_NULL_CHECK(data2); 10537 BCMX_PARAM_NULL_CHECK(mask1); 10538 BCMX_PARAM_NULL_CHECK(mask2); 10539 10540 BCMX_UNIT_ITER(bcm_unit, i) { 10541 rv = bcm_field_qualify_L2PayloadFirstEightBytes_get(bcm_unit, entry, 10542 data1, data2, 10543 mask1, mask2); 10544 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 10545 return rv; 10546 } 10547 } 10548 10549 return BCM_E_UNAVAIL; 10550 } 10551 10552 /* 10553 * Function: 10554 * bcmx_field_qualify_L3DestRouteHit_get 10555 * Purpose: 10556 * Get match criteria for bcmFieldQualifyL3DestRouteHit 10557 * qualifier from the field entry. 10558 * Parameters: 10559 * entry - (IN) BCM field entry id. 10560 * data - (OUT) Qualifier match data. 10561 * mask - (OUT) Qualifier match mask. 10562 * Returns: 10563 * BCM_E_XXX 10564 * Notes: 10565 */ 10566 int 10567 bcmx_field_qualify_L3DestRouteHit_get(bcm_field_entry_t entry, 10568 uint8 *data, 10569 uint8 *mask) 10570 { 10571 int rv; 10572 int i, bcm_unit; 10573 10574 BCMX_FIELD_INIT_CHECK; 10575 10576 BCMX_PARAM_NULL_CHECK(data); 10577 BCMX_PARAM_NULL_CHECK(mask); 10578 10579 BCMX_UNIT_ITER(bcm_unit, i) { 10580 rv = bcm_field_qualify_L3DestRouteHit_get(bcm_unit, entry, data, mask); 10581 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 10582 return rv; 10583 } 10584 } 10585 10586 return BCM_E_UNAVAIL; 10587 } 10588 10589 /* 10590 * Function: 10591 * bcmx_field_qualify_L3DestHostHit_get 10592 * Purpose: 10593 * Get match criteria for bcmFieldQualifyL3DestHostHit 10594 * qualifier from the field entry. 10595 * Parameters: 10596 * entry - (IN) BCM field entry id. 10597 * data - (OUT) Qualifier match data. 10598 * mask - (OUT) Qualifier match mask. 10599 * Returns: 10600 * BCM_E_XXX 10601 * Notes: 10602 */ 10603 int 10604 bcmx_field_qualify_L3DestHostHit_get(bcm_field_entry_t entry, 10605 uint8 *data, 10606 uint8 *mask) 10607 { 10608 int rv; 10609 int i, bcm_unit; 10610 10611 BCMX_FIELD_INIT_CHECK; 10612 10613 BCMX_PARAM_NULL_CHECK(data); 10614 BCMX_PARAM_NULL_CHECK(mask); 10615 10616 BCMX_UNIT_ITER(bcm_unit, i) { 10617 rv = bcm_field_qualify_L3DestHostHit_get(bcm_unit, entry, data, mask); 10618 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 10619 return rv; 10620 } 10621 } 10622 10623 return BCM_E_UNAVAIL; 10624 } 10625 10626 /* 10627 * Function: 10628 * bcmx_field_qualify_L3SrcHostHit_get 10629 * Purpose: 10630 * Get match criteria for bcmFieldQualifyL3SrcHostHit 10631 * qualifier from the field entry. 10632 * Parameters: 10633 * entry - (IN) BCM field entry id. 10634 * data - (OUT) Qualifier match data. 10635 * mask - (OUT) Qualifier match mask. 10636 * Returns: 10637 * BCM_E_XXX 10638 * Notes: 10639 */ 10640 int 10641 bcmx_field_qualify_L3SrcHostHit_get(bcm_field_entry_t entry, 10642 uint8 *data, 10643 uint8 *mask) 10644 { 10645 int rv; 10646 int i, bcm_unit; 10647 10648 BCMX_FIELD_INIT_CHECK; 10649 10650 BCMX_PARAM_NULL_CHECK(data); 10651 BCMX_PARAM_NULL_CHECK(mask); 10652 10653 BCMX_UNIT_ITER(bcm_unit, i) { 10654 rv = bcm_field_qualify_L3SrcHostHit_get(bcm_unit, entry, data, mask); 10655 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 10656 return rv; 10657 } 10658 } 10659 10660 return BCM_E_UNAVAIL; 10661 } 10662 10663 /* 10664 * Function: 10665 * bcmx_field_qualify_L2CacheHit_get 10666 * Purpose: 10667 * Get match criteria for bcmFieldQualifyL2CacheHit 10668 * qualifier from the field entry. 10669 * Parameters: 10670 * entry - (IN) BCM field entry id. 10671 * data - (OUT) Qualifier match data. 10672 * mask - (OUT) Qualifier match mask. 10673 * Returns: 10674 * BCM_E_XXX 10675 * Notes: 10676 */ 10677 int 10678 bcmx_field_qualify_L2CacheHit_get(bcm_field_entry_t entry, 10679 uint8 *data, 10680 uint8 *mask) 10681 { 10682 int rv; 10683 int i, bcm_unit; 10684 10685 BCMX_FIELD_INIT_CHECK; 10686 10687 BCMX_PARAM_NULL_CHECK(data); 10688 BCMX_PARAM_NULL_CHECK(mask); 10689 10690 BCMX_UNIT_ITER(bcm_unit, i) { 10691 rv = bcm_field_qualify_L2CacheHit_get(bcm_unit, entry, data, mask); 10692 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 10693 return rv; 10694 } 10695 } 10696 10697 return BCM_E_UNAVAIL; 10698 } 10699 10700 /* 10701 * Function: 10702 * bcmx_field_qualify_L2StationMove_get 10703 * Purpose: 10704 * Get match criteria for bcmFieldQualifyL2StationMove 10705 * qualifier from the field entry. 10706 * Parameters: 10707 * entry - (IN) BCM field entry id. 10708 * data - (OUT) Qualifier match data. 10709 * mask - (OUT) Qualifier match mask. 10710 * Returns: 10711 * BCM_E_XXX 10712 * Notes: 10713 */ 10714 int 10715 bcmx_field_qualify_L2StationMove_get(bcm_field_entry_t entry, 10716 uint8 *data, 10717 uint8 *mask) 10718 { 10719 int rv; 10720 int i, bcm_unit; 10721 10722 BCMX_FIELD_INIT_CHECK; 10723 10724 BCMX_PARAM_NULL_CHECK(data); 10725 BCMX_PARAM_NULL_CHECK(mask); 10726 10727 BCMX_UNIT_ITER(bcm_unit, i) { 10728 rv = bcm_field_qualify_L2StationMove_get(bcm_unit, entry, data, mask); 10729 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 10730 return rv; 10731 } 10732 } 10733 10734 return BCM_E_UNAVAIL; 10735 } 10736 10737 /* 10738 * Function: 10739 * bcmx_field_qualify_L2DestHit_get 10740 * Purpose: 10741 * Get match criteria for bcmFieldQualifyL2DestHit 10742 * qualifier from the field entry. 10743 * Parameters: 10744 * entry - (IN) BCM field entry id. 10745 * data - (OUT) Qualifier match data. 10746 * mask - (OUT) Qualifier match mask. 10747 * Returns: 10748 * BCM_E_XXX 10749 * Notes: 10750 */ 10751 int 10752 bcmx_field_qualify_L2DestHit_get(bcm_field_entry_t entry, 10753 uint8 *data, 10754 uint8 *mask) 10755 { 10756 int rv; 10757 int i, bcm_unit; 10758 10759 BCMX_FIELD_INIT_CHECK; 10760 10761 BCMX_PARAM_NULL_CHECK(data); 10762 BCMX_PARAM_NULL_CHECK(mask); 10763 10764 BCMX_UNIT_ITER(bcm_unit, i) { 10765 rv = bcm_field_qualify_L2DestHit_get(bcm_unit, entry, data, mask); 10766 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 10767 return rv; 10768 } 10769 } 10770 10771 return BCM_E_UNAVAIL; 10772 } 10773 10774 /* 10775 * Function: 10776 * bcmx_field_qualify_L2SrcStatic_get 10777 * Purpose: 10778 * Get match criteria for bcmFieldQualifyL2SrcStatic 10779 * qualifier from the field entry. 10780 * Parameters: 10781 * entry - (IN) BCM field entry id. 10782 * data - (OUT) Qualifier match data. 10783 * mask - (OUT) Qualifier match mask. 10784 * Returns: 10785 * BCM_E_XXX 10786 * Notes: 10787 */ 10788 int 10789 bcmx_field_qualify_L2SrcStatic_get(bcm_field_entry_t entry, 10790 uint8 *data, 10791 uint8 *mask) 10792 { 10793 int rv; 10794 int i, bcm_unit; 10795 10796 BCMX_FIELD_INIT_CHECK; 10797 10798 BCMX_PARAM_NULL_CHECK(data); 10799 BCMX_PARAM_NULL_CHECK(mask); 10800 10801 BCMX_UNIT_ITER(bcm_unit, i) { 10802 rv = bcm_field_qualify_L2SrcStatic_get(bcm_unit, entry, data, mask); 10803 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 10804 return rv; 10805 } 10806 } 10807 10808 return BCM_E_UNAVAIL; 10809 } 10810 10811 /* 10812 * Function: 10813 * bcmx_field_qualify_L2SrcHit_get 10814 * Purpose: 10815 * Get match criteria for bcmFieldQualifyL2SrcHit 10816 * qualifier from the field entry. 10817 * Parameters: 10818 * entry - (IN) BCM field entry id. 10819 * data - (OUT) Qualifier match data. 10820 * mask - (OUT) Qualifier match mask. 10821 * Returns: 10822 * BCM_E_XXX 10823 * Notes: 10824 */ 10825 int 10826 bcmx_field_qualify_L2SrcHit_get(bcm_field_entry_t entry, 10827 uint8 *data, 10828 uint8 *mask) 10829 { 10830 int rv; 10831 int i, bcm_unit; 10832 10833 BCMX_FIELD_INIT_CHECK; 10834 10835 BCMX_PARAM_NULL_CHECK(data); 10836 BCMX_PARAM_NULL_CHECK(mask); 10837 10838 BCMX_UNIT_ITER(bcm_unit, i) { 10839 rv = bcm_field_qualify_L2SrcHit_get(bcm_unit, entry, data, mask); 10840 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 10841 return rv; 10842 } 10843 } 10844 10845 return BCM_E_UNAVAIL; 10846 } 10847 10848 /* 10849 * Function: 10850 * bcmx_field_qualify_IngressStpState_get 10851 * Purpose: 10852 * Get match criteria for bcmFieldQualifyIngressStpState 10853 * qualifier from the field entry. 10854 * Parameters: 10855 * entry - (IN) BCM field entry id. 10856 * data - (OUT) Qualifier match data. 10857 * mask - (OUT) Qualifier match mask. 10858 * Returns: 10859 * BCM_E_XXX 10860 * Notes: 10861 */ 10862 int 10863 bcmx_field_qualify_IngressStpState_get(bcm_field_entry_t entry, 10864 uint8 *data, 10865 uint8 *mask) 10866 { 10867 int rv; 10868 int i, bcm_unit; 10869 10870 BCMX_FIELD_INIT_CHECK; 10871 10872 BCMX_PARAM_NULL_CHECK(data); 10873 BCMX_PARAM_NULL_CHECK(mask); 10874 10875 BCMX_UNIT_ITER(bcm_unit, i) { 10876 rv = bcm_field_qualify_IngressStpState_get(bcm_unit, entry, data, mask); 10877 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 10878 return rv; 10879 } 10880 } 10881 10882 return BCM_E_UNAVAIL; 10883 } 10884 10885 /* 10886 * Function: 10887 * bcmx_field_qualify_ForwardingVlanValid_get 10888 * Purpose: 10889 * Get match criteria for bcmFieldQualifyForwardingVlanValid 10890 * qualifier from the field entry. 10891 * Parameters: 10892 * entry - (IN) BCM field entry id. 10893 * data - (OUT) Qualifier match data. 10894 * mask - (OUT) Qualifier match mask. 10895 * Returns: 10896 * BCM_E_XXX 10897 * Notes: 10898 */ 10899 int 10900 bcmx_field_qualify_ForwardingVlanValid_get(bcm_field_entry_t entry, 10901 uint8 *data, 10902 uint8 *mask) 10903 { 10904 int rv; 10905 int i, bcm_unit; 10906 10907 BCMX_FIELD_INIT_CHECK; 10908 10909 BCMX_PARAM_NULL_CHECK(data); 10910 BCMX_PARAM_NULL_CHECK(mask); 10911 10912 BCMX_UNIT_ITER(bcm_unit, i) { 10913 rv = bcm_field_qualify_ForwardingVlanValid_get(bcm_unit, entry, 10914 data, mask); 10915 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 10916 return rv; 10917 } 10918 } 10919 10920 return BCM_E_UNAVAIL; 10921 } 10922 10923 /* 10924 * Function: 10925 * bcmx_field_qualify_SrcVirtualPortValid_get 10926 * Purpose: 10927 * Get match criteria for bcmFieldQualifySrcVirtualPortValid 10928 * qualifier from the field entry. 10929 * Parameters: 10930 * entry - (IN) BCM field entry id. 10931 * data - (OUT) Qualifier match data. 10932 * mask - (OUT) Qualifier match mask. 10933 * Returns: 10934 * BCM_E_XXX 10935 * Notes: 10936 */ 10937 int 10938 bcmx_field_qualify_SrcVirtualPortValid_get(bcm_field_entry_t entry, 10939 uint8 *data, uint8 *mask) 10940 { 10941 int rv; 10942 int i, bcm_unit; 10943 10944 BCMX_FIELD_INIT_CHECK; 10945 10946 BCMX_PARAM_NULL_CHECK(data); 10947 BCMX_PARAM_NULL_CHECK(mask); 10948 10949 BCMX_UNIT_ITER(bcm_unit, i) { 10950 rv = bcm_field_qualify_SrcVirtualPortValid_get(bcm_unit, entry, 10951 data, mask); 10952 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 10953 return rv; 10954 } 10955 } 10956 10957 return BCM_E_UNAVAIL; 10958 } 10959 10960 /* 10961 * Function: 10962 * bcmx_field_qualify_VlanTranslationHit_get 10963 * Purpose: 10964 * Get match criteria for bcmFieldQualifyVlanTranslationHit 10965 * qualifier from the field entry. 10966 * Parameters: 10967 * entry - (IN) BCM field entry id. 10968 * data - (OUT) Qualifier match data. 10969 * mask - (OUT) Qualifier match mask. 10970 * Returns: 10971 * BCM_E_XXX 10972 * Notes: 10973 */ 10974 int 10975 bcmx_field_qualify_VlanTranslationHit_get(bcm_field_entry_t entry, 10976 uint8 *data, 10977 uint8 *mask) 10978 { 10979 int rv; 10980 int i, bcm_unit; 10981 10982 BCMX_FIELD_INIT_CHECK; 10983 10984 BCMX_PARAM_NULL_CHECK(data); 10985 BCMX_PARAM_NULL_CHECK(mask); 10986 10987 BCMX_UNIT_ITER(bcm_unit, i) { 10988 rv = bcm_field_qualify_VlanTranslationHit_get(bcm_unit, entry, 10989 data, mask); 10990 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 10991 return rv; 10992 } 10993 } 10994 10995 return BCM_E_UNAVAIL; 10996 } 10997 10998 /* 10999 * Function: 11000 * bcmx_field_qualify_IcmpTypeCode_get 11001 * Purpose: 11002 * Get match criteria for bcmFieldQualifyIcmpTypeCode 11003 * qualifier from the field entry. 11004 * Parameters: 11005 * entry - (IN) BCM field entry id. 11006 * data - (OUT) Qualifier match data. 11007 * mask - (OUT) Qualifier match mask. 11008 * Returns: 11009 * BCM_E_XXX 11010 * Notes: 11011 */ 11012 int 11013 bcmx_field_qualify_IcmpTypeCode_get(bcm_field_entry_t entry, 11014 uint16 *data, 11015 uint16 *mask) 11016 { 11017 int rv; 11018 int i, bcm_unit; 11019 11020 BCMX_FIELD_INIT_CHECK; 11021 11022 BCMX_PARAM_NULL_CHECK(data); 11023 BCMX_PARAM_NULL_CHECK(mask); 11024 11025 BCMX_UNIT_ITER(bcm_unit, i) { 11026 rv = bcm_field_qualify_IcmpTypeCode_get(bcm_unit, entry, data, mask); 11027 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 11028 return rv; 11029 } 11030 } 11031 11032 return BCM_E_UNAVAIL; 11033 } 11034 11035 /* 11036 * Function: 11037 * bcmx_field_qualify_FibreChanOuter_get 11038 * Purpose: 11039 * Get Fibre Channel outer header type field qualification from 11040 * field entry. 11041 * Parameters: 11042 * entry - (IN) BCM field entry id. 11043 * fibre_chan_type - (OUT) Fibre Channel header type. 11044 * Returns: 11045 * BCM_E_XXX 11046 * Notes: 11047 */ 11048 int 11049 bcmx_field_qualify_FibreChanOuter_get(bcm_field_entry_t entry, 11050 bcm_field_FibreChan_t *fibre_chan_type) 11051 { 11052 int rv; 11053 int i, bcm_unit; 11054 11055 BCMX_FIELD_INIT_CHECK; 11056 11057 BCMX_PARAM_NULL_CHECK(fibre_chan_type); 11058 11059 BCMX_UNIT_ITER(bcm_unit, i) { 11060 rv = bcm_field_qualify_FibreChanOuter_get(bcm_unit, entry, 11061 fibre_chan_type); 11062 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 11063 return rv; 11064 } 11065 } 11066 11067 return BCM_E_UNAVAIL; 11068 } 11069 11070 /* 11071 * Function: 11072 * bcmx_field_qualify_FibreChanInner_get 11073 * Purpose: 11074 * Get Fibre Channel inner header type field qualification from 11075 * field entry. 11076 * Parameters: 11077 * entry - (IN) BCM field entry id. 11078 * fibre_chan_type - (OUT) Fibre Channel header type. 11079 * Returns: 11080 * BCM_E_XXX 11081 * Notes: 11082 */ 11083 int 11084 bcmx_field_qualify_FibreChanInner_get(bcm_field_entry_t entry, 11085 bcm_field_FibreChan_t *fibre_chan_type) 11086 { 11087 int rv; 11088 int i, bcm_unit; 11089 11090 BCMX_FIELD_INIT_CHECK; 11091 11092 BCMX_PARAM_NULL_CHECK(fibre_chan_type); 11093 11094 BCMX_UNIT_ITER(bcm_unit, i) { 11095 rv = bcm_field_qualify_FibreChanInner_get(bcm_unit, entry, 11096 fibre_chan_type); 11097 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 11098 return rv; 11099 } 11100 } 11101 11102 return BCM_E_UNAVAIL; 11103 } 11104 11105 /* 11106 * Function: 11107 * bcmx_field_qualify_VnTag_get 11108 * Purpose: 11109 * Get match criteria for bcmFieldQualifyVnTag 11110 * qualifier from the field entry. 11111 * Parameters: 11112 * entry - (IN) BCM field entry id. 11113 * data - (OUT) Qualifier match data. 11114 * mask - (OUT) Qualifier match mask. 11115 * Returns: 11116 * BCM_E_XXX 11117 * Notes: 11118 */ 11119 int 11120 bcmx_field_qualify_VnTag_get(bcm_field_entry_t entry, 11121 uint32 *data, uint32 *mask) 11122 { 11123 int rv; 11124 int i, bcm_unit; 11125 11126 BCMX_FIELD_INIT_CHECK; 11127 11128 BCMX_PARAM_NULL_CHECK(data); 11129 BCMX_PARAM_NULL_CHECK(mask); 11130 11131 BCMX_UNIT_ITER(bcm_unit, i) { 11132 rv = bcm_field_qualify_VnTag_get(bcm_unit, entry, data, mask); 11133 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 11134 return rv; 11135 } 11136 } 11137 11138 return BCM_E_UNAVAIL; 11139 } 11140 11141 /* 11142 * Function: 11143 * bcmx_field_qualify_CnTag_get 11144 * Purpose: 11145 * Get match criteria for bcmFieldQualifyCnTag 11146 * qualifier from the field entry. 11147 * Parameters: 11148 * entry - (IN) BCM field entry id. 11149 * data - (OUT) Qualifier match data. 11150 * mask - (OUT) Qualifier match mask. 11151 * Returns: 11152 * BCM_E_XXX 11153 * Notes: 11154 */ 11155 int 11156 bcmx_field_qualify_CnTag_get(bcm_field_entry_t entry, 11157 uint32 *data, uint32 *mask) 11158 { 11159 int rv; 11160 int i, bcm_unit; 11161 11162 BCMX_FIELD_INIT_CHECK; 11163 11164 BCMX_PARAM_NULL_CHECK(data); 11165 BCMX_PARAM_NULL_CHECK(mask); 11166 11167 BCMX_UNIT_ITER(bcm_unit, i) { 11168 rv = bcm_field_qualify_CnTag_get(bcm_unit, entry, data, mask); 11169 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 11170 return rv; 11171 } 11172 } 11173 11174 return BCM_E_UNAVAIL; 11175 } 11176 11177 /* 11178 * Function: 11179 * bcmx_field_qualify_FabricQueueTag_get 11180 * Purpose: 11181 * Get match criteria for bcmFieldQualifyFabricQueueTag 11182 * qualifier from the field entry. 11183 * Parameters: 11184 * entry - (IN) BCM field entry id. 11185 * data - (OUT) Qualifier match data. 11186 * mask - (OUT) Qualifier match mask. 11187 * Returns: 11188 * BCM_E_XXX 11189 * Notes: 11190 */ 11191 int 11192 bcmx_field_qualify_FabricQueueTag_get(bcm_field_entry_t entry, 11193 uint32 *data, uint32 *mask) 11194 11195 { 11196 int rv; 11197 int i, bcm_unit; 11198 11199 BCMX_FIELD_INIT_CHECK; 11200 11201 BCMX_PARAM_NULL_CHECK(data); 11202 BCMX_PARAM_NULL_CHECK(mask); 11203 11204 BCMX_UNIT_ITER(bcm_unit, i) { 11205 rv = bcm_field_qualify_FabricQueueTag_get(bcm_unit, entry, data, mask); 11206 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 11207 return rv; 11208 } 11209 } 11210 11211 return BCM_E_UNAVAIL; 11212 } 11213 11214 /* 11215 * Function: 11216 * bcmx_field_qualify_DstMultipath_get 11217 * Purpose: 11218 * Get match criteria for bcmFieldQualifyDstMultipath 11219 * qualifier from the field entry. 11220 * Parameters: 11221 * entry - (IN) BCM field entry id. 11222 * mpintf - (OUT) Multipath egress object id. 11223 * Returns: 11224 * BCM_E_XXX 11225 * Notes: 11226 */ 11227 int 11228 bcmx_field_qualify_DstMultipath_get(bcm_field_entry_t entry, bcm_if_t *mpintf) 11229 11230 { 11231 int rv; 11232 int i, bcm_unit; 11233 11234 BCMX_FIELD_INIT_CHECK; 11235 11236 BCMX_PARAM_NULL_CHECK(mpintf); 11237 11238 BCMX_UNIT_ITER(bcm_unit, i) { 11239 rv = bcm_field_qualify_DstMultipath_get(bcm_unit, entry, mpintf); 11240 if (BCMX_FIELD_GET_IS_VALID(bcm_unit, rv)) { 11241 return rv; 11242 } 11243 } 11244 11245 return BCM_E_UNAVAIL; 11246 } 11247 11248 11249 /* 11250 * Function: 11251 * bcmx_field_qualifier_delete 11252 * Purpose: 11253 * Remove match criteria from a field processor entry. 11254 * Parameters: 11255 * entry - (IN) BCM field entry id. 11256 * qual_id - (IN) BCM field qualifier id. 11257 * Returns: 11258 * BCM_E_XXX 11259 * Notes: 11260 */ 11261 int 11262 bcmx_field_qualifier_delete(bcm_field_entry_t entry, 11263 bcm_field_qualify_t qual_id) 11264 { 11265 int rv = BCM_E_UNAVAIL, tmp_rv; 11266 int i, bcm_unit; 11267 11268 BCMX_FIELD_INIT_CHECK; 11269 11270 BCMX_UNIT_ITER(bcm_unit, i) { 11271 tmp_rv = bcm_field_qualifier_delete(bcm_unit, entry, qual_id); 11272 BCM_IF_ERROR_RETURN 11273 (BCMX_FIELD_DELETE_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 11274 } 11275 return rv; 11276 } 11277 11278 /* 11279 * Function: 11280 * bcmx_field_qualify_TcpSequenceZero 11281 * Purpose: 11282 * Set match criteria for bcmFieldQualifyTcpSequenceZero 11283 * qualifier to the field entry. 11284 * Parameters: 11285 * entry - (IN) BCM field entry id. 11286 * flag - (IN) Flag. 11287 * Returns: 11288 * BCM_E_XXX 11289 * Notes: 11290 */ 11291 int 11292 bcmx_field_qualify_TcpSequenceZero(bcm_field_entry_t entry, 11293 uint32 flag) 11294 { 11295 int rv = BCM_E_UNAVAIL, tmp_rv; 11296 int i, bcm_unit; 11297 11298 BCMX_FIELD_INIT_CHECK; 11299 11300 BCMX_UNIT_ITER(bcm_unit, i) { 11301 tmp_rv = bcm_field_qualify_TcpSequenceZero(bcm_unit, entry, flag); 11302 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 11303 } 11304 return rv; 11305 } 11306 11307 /* 11308 * Function: 11309 * bcmx_field_qualify_TcpHeaderSize 11310 * Purpose: 11311 * Set match criteria for bcmFieldQualifyTcpHeaderSize 11312 * qualifier to the field entry. 11313 * Parameters: 11314 * entry - (IN) BCM field entry id. 11315 * data - (IN) Qualifier match data. 11316 * mask - (IN) Qualifier match data mask. 11317 * Returns: 11318 * BCM_E_XXX 11319 * Notes: 11320 */ 11321 int 11322 bcmx_field_qualify_TcpHeaderSize(bcm_field_entry_t entry, 11323 uint8 data, uint8 mask) 11324 { 11325 int rv = BCM_E_UNAVAIL, tmp_rv; 11326 int i, bcm_unit; 11327 11328 BCMX_FIELD_INIT_CHECK; 11329 11330 BCMX_UNIT_ITER(bcm_unit, i) { 11331 tmp_rv = bcm_field_qualify_TcpHeaderSize(bcm_unit, entry, data, mask); 11332 BCM_IF_ERROR_RETURN(BCMX_FIELD_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 11333 } 11334 return rv; 11335 }