l2gre.c (56243B)
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 * ESW L2GRE API 8 */ 9 10 #ifdef INCLUDE_L3 11 12 #include <soc/drv.h> 13 #include <soc/mem.h> 14 #include <soc/util.h> 15 #include <soc/debug.h> 16 #include <bcm/types.h> 17 #include <bcm/error.h> 18 #include <bcm_int/esw/mbcm.h> 19 #include <bcm_int/esw_dispatch.h> 20 #if defined(BCM_TRIUMPH3_SUPPORT) 21 #include <bcm_int/esw/triumph3.h> 22 #endif 23 #if defined(BCM_TRIDENT2_SUPPORT) 24 #include <bcm_int/esw/trident2.h> 25 #endif 26 #include <bcm_int/esw/l2gre.h> 27 #include <bcm_int/esw/vpn.h> 28 #include <bcm_int/esw/virtual.h> 29 30 /* 31 * Function: 32 * bcm_esw_l2gre_init 33 * Purpose: 34 * Init L2GRE module 35 * Parameters: 36 * IN : unit 37 * Returns: 38 * BCM_E_XXX 39 */ 40 41 int 42 bcm_esw_l2gre_init(int unit) 43 { 44 #ifdef BCM_TRIUMPH3_SUPPORT 45 if (soc_feature(unit, soc_feature_l2gre)) { 46 return bcm_tr3_l2gre_init(unit); 47 } 48 #endif /* BCM_TRIUMPH3_SUPPORT */ 49 return BCM_E_UNAVAIL; 50 } 51 52 53 /* Function: 54 * bcm_l2gre_cleanup 55 * Purpose: 56 * Detach the L2GRE module, clear all HW states 57 * Parameters: 58 * unit - Device Number 59 * Returns: 60 * BCM_E_XXXX 61 */ 62 63 int 64 bcm_esw_l2gre_cleanup(int unit) 65 { 66 #ifdef BCM_TRIUMPH3_SUPPORT 67 if (soc_feature(unit, soc_feature_l2gre)) { 68 return bcm_tr3_l2gre_cleanup(unit); 69 } 70 #endif /* BCM_TRIUMPH3_SUPPORT */ 71 return BCM_E_UNAVAIL; 72 } 73 74 /* Function: 75 * bcm_esw_l2gre_vpn_create 76 * Purpose: 77 * Createl L2-VPN instance 78 * Parameters: 79 * unit - Device Number 80 * info - L2GRE VPN Config 81 * Returns: 82 * BCM_E_XXXX 83 */ 84 85 int 86 bcm_esw_l2gre_vpn_create( int unit, bcm_l2gre_vpn_config_t *info) 87 { 88 int rv = BCM_E_UNAVAIL; 89 #if defined(BCM_TRIUMPH3_SUPPORT) 90 if (soc_feature(unit, soc_feature_l2gre)) { 91 if (info == NULL) { 92 return BCM_E_PARAM; 93 } 94 rv = bcm_tr3_l2gre_lock(unit); 95 if ( rv == BCM_E_NONE ) { 96 soc_mem_lock(unit, VFIm); 97 rv = bcm_tr3_l2gre_vpn_create(unit, info); 98 soc_mem_unlock(unit, VFIm); 99 bcm_tr3_l2gre_unlock (unit); 100 } 101 102 } 103 #endif 104 return rv; 105 } 106 107 /* Function: 108 * bcm_esw_l2gre_vpn_create 109 * Purpose: 110 * Delete L2-VPN instance 111 * Parameters: 112 * unit - Device Number 113 * l2vpn - L2GRE Vpn 114 * Returns: 115 * BCM_E_XXXX 116 */ 117 118 int 119 bcm_esw_l2gre_vpn_destroy(int unit, bcm_vpn_t l2vpn) 120 { 121 int rv = BCM_E_UNAVAIL; 122 #if defined(BCM_TRIUMPH3_SUPPORT) 123 if (soc_feature(unit, soc_feature_l2gre)) { 124 rv = bcm_tr3_l2gre_lock(unit); 125 if ( rv == BCM_E_NONE ) { 126 rv = bcm_tr3_l2gre_vpn_destroy(unit, l2vpn); 127 bcm_tr3_l2gre_unlock (unit); 128 } 129 } 130 #endif 131 return rv; 132 } 133 134 /* Function: 135 * bcm_l2gre_cleanup 136 * Purpose: 137 * Delete all L2-VPN instances 138 * Parameters: 139 * unit - Device Number 140 * Returns: 141 * BCM_E_XXXX 142 */ 143 144 int 145 bcm_esw_l2gre_vpn_destroy_all(int unit) 146 { 147 int rv = BCM_E_UNAVAIL; 148 #if defined(BCM_TRIUMPH3_SUPPORT) 149 if (soc_feature(unit, soc_feature_l2gre)) { 150 rv = bcm_tr3_l2gre_lock(unit); 151 if ( rv == BCM_E_NONE ) { 152 rv = bcm_tr3_l2gre_vpn_destroy_all(unit); 153 bcm_tr3_l2gre_unlock (unit); 154 } 155 } 156 #endif 157 return rv; 158 } 159 160 /* 161 * Function: 162 * bcm_l2gre_vpn_traverse 163 * Purpose: 164 * L2GRE VPN Traverse 165 * Parameters: 166 * unit - (IN) Device Number 167 * cb - (IN) User callback function, called once per entry 168 * user_data - (IN/OUT) Cookie 169 * Returns: 170 * BCM_E_XXXX 171 */ 172 int 173 bcm_esw_l2gre_vpn_traverse(int unit, bcm_l2gre_vpn_traverse_cb cb, 174 void *user_data) 175 { 176 int rv = BCM_E_UNAVAIL; 177 #if defined(BCM_TRIUMPH3_SUPPORT) 178 if (soc_feature(unit, soc_feature_l2gre)) { 179 rv = bcm_tr3_l2gre_lock(unit); 180 if ( rv == BCM_E_NONE ) { 181 rv = bcm_tr3_l2gre_vpn_traverse(unit, cb, user_data); 182 bcm_tr3_l2gre_unlock (unit); 183 } 184 } 185 #endif 186 return rv; 187 } 188 189 190 /* Function: 191 * bcm_l2gre_vpn_get 192 * Purpose: 193 * Get L2-VPN instance 194 * Parameters: 195 * unit - Device Number 196 * l2vpn - L2GRE Vpn 197 * info - L2GRE VPN Config 198 * Returns: 199 * BCM_E_XXXX 200 */ 201 202 int 203 bcm_esw_l2gre_vpn_get( int unit, bcm_vpn_t l2vpn, bcm_l2gre_vpn_config_t *info) 204 { 205 int rv = BCM_E_UNAVAIL; 206 #if defined(BCM_TRIUMPH3_SUPPORT) 207 if (soc_feature(unit, soc_feature_l2gre)) { 208 if (info == NULL) { 209 return BCM_E_PARAM; 210 } 211 rv = bcm_tr3_l2gre_lock(unit); 212 if ( rv == BCM_E_NONE ) { 213 rv = bcm_tr3_l2gre_vpn_get(unit, l2vpn, info); 214 bcm_tr3_l2gre_unlock (unit); 215 } 216 } 217 #endif 218 return rv; 219 } 220 221 /* Function: 222 * bcm_esw_l2gre_port_add 223 * Purpose: 224 * Add Access/Network L2GRE port 225 * Parameters: 226 * unit - Device Number 227 * l2vpn - L2GRE Vpn 228 * l2gre_port - L2GRE Gport 229 * Returns: 230 * BCM_E_XXXX 231 */ 232 233 int 234 bcm_esw_l2gre_port_add(int unit, bcm_vpn_t l2vpn, bcm_l2gre_port_t *l2gre_port) 235 { 236 int rv = BCM_E_UNAVAIL; 237 #if defined(BCM_TRIUMPH3_SUPPORT) 238 if (soc_feature(unit, soc_feature_l2gre)) { 239 if (l2gre_port == NULL) { 240 return BCM_E_PARAM; 241 } 242 rv = bcm_tr3_l2gre_lock(unit); 243 if ( rv == BCM_E_NONE ) { 244 rv = bcm_tr3_l2gre_port_add(unit, l2vpn, l2gre_port); 245 bcm_tr3_l2gre_unlock (unit); 246 } 247 } 248 #endif 249 return rv; 250 } 251 252 /* Function: 253 * bcm_esw_l2gre_port_delete 254 * Purpose: 255 * Delete Access/Network L2GRE port 256 * Parameters: 257 * unit - Device Number 258 * l2vpn - L2GRE Vpn 259 * l2gre_port_id - L2GRE Gport Id 260 * Returns: 261 * BCM_E_XXXX 262 */ 263 264 int 265 bcm_esw_l2gre_port_delete( int unit, bcm_vpn_t l2vpn, bcm_gport_t l2gre_port_id) 266 { 267 int rv = BCM_E_UNAVAIL; 268 #if defined(BCM_TRIUMPH3_SUPPORT) 269 if (soc_feature(unit, soc_feature_l2gre)) { 270 rv = bcm_tr3_l2gre_lock(unit); 271 if ( rv == BCM_E_NONE ) { 272 rv = bcm_tr3_l2gre_port_delete(unit, l2vpn, l2gre_port_id); 273 bcm_tr3_l2gre_unlock (unit); 274 } 275 } 276 #endif 277 return rv; 278 } 279 280 /* Function: 281 * bcm_esw_l2gre_port_delete_all 282 * Purpose: 283 * Delete all Access/Network L2GRE ports 284 * Parameters: 285 * unit - Device Number 286 * l2vpn - L2GRE Vpn 287 * Returns: 288 * BCM_E_XXXX 289 */ 290 291 int 292 bcm_esw_l2gre_port_delete_all(int unit, bcm_vpn_t l2vpn) 293 { 294 int rv = BCM_E_UNAVAIL; 295 #if defined(BCM_TRIUMPH3_SUPPORT) 296 if (soc_feature(unit, soc_feature_l2gre)) { 297 rv = bcm_tr3_l2gre_lock(unit); 298 if ( rv == BCM_E_NONE ) { 299 rv = bcm_tr3_l2gre_port_delete_all(unit, l2vpn); 300 bcm_tr3_l2gre_unlock (unit); 301 } 302 } 303 #endif 304 return rv; 305 } 306 307 /* Function: 308 * bcm_esw_l2gre_port_get 309 * Purpose: 310 * Get Access/Network L2GRE port info 311 * Parameters: 312 * unit - Device Number 313 * l2vpn - L2GRE Vpn 314 * l2gre_port - L2GRE Gport 315 * Returns: 316 * BCM_E_XXXX 317 */ 318 319 int 320 bcm_esw_l2gre_port_get(int unit, bcm_vpn_t l2vpn, bcm_l2gre_port_t *l2gre_port) 321 { 322 int rv = BCM_E_UNAVAIL; 323 #if defined(BCM_TRIUMPH3_SUPPORT) 324 if (soc_feature(unit, soc_feature_l2gre)) { 325 if (l2gre_port == NULL) { 326 return BCM_E_PARAM; 327 } 328 rv = bcm_tr3_l2gre_lock(unit); 329 if ( rv == BCM_E_NONE ) { 330 rv = bcm_tr3_l2gre_port_get(unit, l2vpn, l2gre_port); 331 bcm_tr3_l2gre_unlock (unit); 332 } 333 } 334 #endif 335 return rv; 336 } 337 338 /* Function: 339 * bcm_esw_l2gre_port_get_all 340 * Purpose: 341 * Get all Access/Network L2GRE port info 342 * Parameters: 343 * unit - (IN) Device Number 344 * l2vpn - L2GRE Vpn 345 * port_max - (IN) Maximum number of L2GRE ports in array 346 * port_array - (OUT) Array of L2GRE ports 347 * port_count - (OUT) Number of L2GRE ports returned in array 348 * Returns: 349 * BCM_E_XXXX 350 */ 351 352 int 353 bcm_esw_l2gre_port_get_all( 354 int unit, 355 bcm_vpn_t l2vpn, 356 int port_max, 357 bcm_l2gre_port_t *port_array, 358 int *port_count) 359 { 360 int rv = BCM_E_UNAVAIL; 361 #if defined(BCM_TRIUMPH3_SUPPORT) 362 if (soc_feature(unit, soc_feature_l2gre)) { 363 if (port_count == NULL) { 364 return BCM_E_PARAM; 365 } 366 rv = bcm_tr3_l2gre_lock(unit); 367 if ( rv == BCM_E_NONE ) { 368 rv = bcm_tr3_l2gre_port_get_all(unit, l2vpn, port_max, port_array, port_count); 369 bcm_tr3_l2gre_unlock (unit); 370 } 371 } 372 #endif 373 return rv; 374 } 375 376 /* Function: 377 * bcm_esw_l2gre_tunnel_initiator_create 378 * Purpose: 379 * Create L2GRE Tunnel Initiator 380 * Parameters: 381 * unit - Device Number 382 * info - L2GRE Tunnel Initiator info 383 * Returns: 384 * BCM_E_XXXX 385 */ 386 387 int 388 bcm_esw_l2gre_tunnel_initiator_create(int unit, bcm_tunnel_initiator_t *info) 389 { 390 int rv = BCM_E_UNAVAIL; 391 #if defined(BCM_TRIUMPH3_SUPPORT) 392 if (soc_feature(unit, soc_feature_l2gre)) { 393 if (info == NULL) { 394 return BCM_E_PARAM; 395 } 396 rv = bcm_tr3_l2gre_lock(unit); 397 if ( rv == BCM_E_NONE ) { 398 rv = bcm_tr3_l2gre_tunnel_initiator_create(unit, info); 399 bcm_tr3_l2gre_unlock (unit); 400 } 401 } 402 #endif 403 return rv; 404 } 405 406 407 /* Function: 408 * bcm_esw_l2gre_tunnel_initiator_destroy 409 * Purpose: 410 * Delete L2GRE Tunnel Initiator 411 * Parameters: 412 * unit - Device Number 413 * l2gre_tunnel_id - L2GRE Tunnel Initiator Id 414 * Returns: 415 * BCM_E_XXXX 416 */ 417 418 int 419 bcm_esw_l2gre_tunnel_initiator_destroy(int unit, bcm_gport_t l2gre_tunnel_id) 420 { 421 int rv = BCM_E_UNAVAIL; 422 #if defined(BCM_TRIUMPH3_SUPPORT) 423 if (soc_feature(unit, soc_feature_l2gre)) { 424 rv = bcm_tr3_l2gre_lock(unit); 425 if ( rv == BCM_E_NONE ) { 426 rv = bcm_tr3_l2gre_tunnel_initiator_destroy(unit, l2gre_tunnel_id); 427 bcm_tr3_l2gre_unlock (unit); 428 } 429 } 430 #endif 431 return rv; 432 } 433 434 /* Function: 435 * bcm_esw_l2gre_tunnel_initiator_destroy_all 436 * Purpose: 437 * Delete all L2GRE Tunnel Initiators 438 * Parameters: 439 * unit - Device Number 440 * Returns: 441 * BCM_E_XXXX 442 */ 443 444 int 445 bcm_esw_l2gre_tunnel_initiator_destroy_all(int unit) 446 { 447 int rv = BCM_E_UNAVAIL; 448 #if defined(BCM_TRIUMPH3_SUPPORT) 449 if (soc_feature(unit, soc_feature_l2gre)) { 450 rv = bcm_tr3_l2gre_lock(unit); 451 if ( rv == BCM_E_NONE ) { 452 rv = bcm_tr3_l2gre_tunnel_initiator_destroy_all(unit); 453 bcm_tr3_l2gre_unlock (unit); 454 } 455 } 456 #endif 457 return rv; 458 } 459 460 /* Function: 461 * bcm_esw_l2gre_tunnel_initiator_get 462 * Purpose: 463 * Get L2GRE Tunnel Initiator Info 464 * Parameters: 465 * unit - Device Number 466 * info - L2GRE Tunnel Initiator info 467 * Returns: 468 * BCM_E_XXXX 469 */ 470 471 int 472 bcm_esw_l2gre_tunnel_initiator_get(int unit, bcm_tunnel_initiator_t *info) 473 { 474 int rv = BCM_E_UNAVAIL; 475 #if defined(BCM_TRIUMPH3_SUPPORT) 476 if (soc_feature(unit, soc_feature_l2gre)) { 477 if (info == NULL) { 478 return BCM_E_PARAM; 479 } 480 rv = bcm_tr3_l2gre_lock(unit); 481 if ( rv == BCM_E_NONE ) { 482 rv = bcm_tr3_l2gre_tunnel_initiator_get(unit, info); 483 bcm_tr3_l2gre_unlock (unit); 484 } 485 } 486 #endif 487 return rv; 488 } 489 490 /* 491 * Function: 492 * bcm_esw_l2gre_tunnel_initiator_traverse 493 * Purpose: 494 * L2GRE Tunnel Initiator Traverse 495 * Parameters: 496 * unit - Device Number 497 * cb - User callback function, called once per entry 498 * user_data - Cookie 499 * Returns: 500 * BCM_E_XXXX 501 */ 502 503 int 504 bcm_esw_l2gre_tunnel_initiator_traverse(int unit, bcm_tunnel_initiator_traverse_cb cb, void *user_data) 505 { 506 int rv = BCM_E_UNAVAIL; 507 #if defined(BCM_TRIUMPH3_SUPPORT) 508 if (soc_feature(unit, soc_feature_l2gre)) { 509 rv = bcm_tr3_l2gre_lock(unit); 510 if ( rv == BCM_E_NONE ) { 511 rv = bcm_tr3_l2gre_tunnel_initiator_traverse(unit, cb, user_data); 512 bcm_tr3_l2gre_unlock (unit); 513 } 514 } 515 #endif 516 return rv; 517 } 518 519 /* Function: 520 * bcm_esw_l2gre_tunnel_terminator_create 521 * Purpose: 522 * Create L2GRE Tunnel terminator 523 * Parameters: 524 * unit - Device Number 525 * info - L2GRE Tunnel terminator info 526 * Returns: 527 * BCM_E_XXXX 528 */ 529 530 int 531 bcm_esw_l2gre_tunnel_terminator_create(int unit, bcm_tunnel_terminator_t *info) 532 { 533 int rv = BCM_E_UNAVAIL; 534 #if defined(BCM_TRIUMPH3_SUPPORT) 535 if (soc_feature(unit, soc_feature_l2gre)) { 536 if (info == NULL) { 537 return BCM_E_PARAM; 538 } 539 rv = bcm_tr3_l2gre_lock(unit); 540 if ( rv == BCM_E_NONE ) { 541 rv = bcm_tr3_l2gre_tunnel_terminator_create(unit, info); 542 bcm_tr3_l2gre_unlock (unit); 543 } 544 } 545 #endif 546 return rv; 547 } 548 549 /* Function: 550 * bcm_esw_l2gre_tunnel_terminator_update 551 * Purpose: 552 * Update L2GRE Tunnel terminator 553 * Parameters: 554 * unit - Device Number 555 * info - L2GRE Tunnel terminator info 556 * Returns: 557 * BCM_E_XXXX 558 */ 559 560 int 561 bcm_esw_l2gre_tunnel_terminator_update(int unit, bcm_tunnel_terminator_t *info) 562 { 563 int rv = BCM_E_UNAVAIL; 564 #if defined(BCM_TRIUMPH3_SUPPORT) 565 if (soc_feature(unit, soc_feature_l2gre)) { 566 if (info == NULL) { 567 return BCM_E_PARAM; 568 } 569 rv = bcm_tr3_l2gre_lock(unit); 570 if ( rv == BCM_E_NONE ) { 571 rv = bcm_tr3_l2gre_tunnel_terminator_update(unit, info); 572 bcm_tr3_l2gre_unlock (unit); 573 } 574 } 575 #endif 576 return rv; 577 } 578 579 /* Function: 580 * bcm_esw_l2gre_tunnel_terminator_destroy 581 * Purpose: 582 * Destroy L2GRE Tunnel terminator 583 * Parameters: 584 * unit - Device Number 585 * l2gre_tunnel_id - L2GRE Tunnel Initiator Id 586 * Returns: 587 * BCM_E_XXXX 588 */ 589 590 int 591 bcm_esw_l2gre_tunnel_terminator_destroy(int unit, bcm_gport_t l2gre_tunnel_id) 592 { 593 int rv = BCM_E_UNAVAIL; 594 #if defined(BCM_TRIUMPH3_SUPPORT) 595 if (soc_feature(unit, soc_feature_l2gre)) { 596 rv = bcm_tr3_l2gre_lock(unit); 597 if ( rv == BCM_E_NONE ) { 598 rv = bcm_tr3_l2gre_tunnel_terminator_destroy(unit, l2gre_tunnel_id); 599 bcm_tr3_l2gre_unlock (unit); 600 } 601 } 602 #endif 603 return rv; 604 } 605 606 607 /* Function: 608 * bcm_esw_l2gre_tunnel_terminator_destroy_all 609 * Purpose: 610 * Destroy all L2GRE Tunnel terminators 611 * Parameters: 612 * unit - Device Number 613 * Returns: 614 * BCM_E_XXXX 615 */ 616 617 int 618 bcm_esw_l2gre_tunnel_terminator_destroy_all(int unit) 619 { 620 int rv = BCM_E_UNAVAIL; 621 #if defined(BCM_TRIUMPH3_SUPPORT) 622 if (soc_feature(unit, soc_feature_l2gre)) { 623 rv = bcm_tr3_l2gre_lock(unit); 624 if ( rv == BCM_E_NONE ) { 625 rv = bcm_tr3_l2gre_tunnel_terminator_destroy_all(unit); 626 bcm_tr3_l2gre_unlock (unit); 627 } 628 } 629 #endif 630 return rv; 631 } 632 633 634 /* Function: 635 * bcm_esw_l2gre_tunnel_terminator_get 636 * Purpose: 637 * Get L2GRE Tunnel terminator Info 638 * Parameters: 639 * unit - Device Number 640 * info - L2GRE Tunnel terminator info 641 * Returns: 642 * BCM_E_XXXX 643 */ 644 645 int 646 bcm_esw_l2gre_tunnel_terminator_get( int unit, bcm_tunnel_terminator_t *info) 647 { 648 int rv = BCM_E_UNAVAIL; 649 #if defined(BCM_TRIUMPH3_SUPPORT) 650 if (soc_feature(unit, soc_feature_l2gre)) { 651 if (info == NULL) { 652 return BCM_E_PARAM; 653 } 654 rv = bcm_tr3_l2gre_lock(unit); 655 if ( rv == BCM_E_NONE ) { 656 rv = bcm_tr3_l2gre_tunnel_terminator_get(unit, info); 657 bcm_tr3_l2gre_unlock (unit); 658 } 659 } 660 #endif 661 return rv; 662 } 663 664 /* 665 * Function: 666 * bcm_esw_l2gre_tunnel_terminator_traverse 667 * Purpose: 668 * L2GRE Tunnel Terminator Traverse 669 * Parameters: 670 * unit - Device Number 671 * cb - User callback function, called once per entry 672 * user_data - Cookie 673 * Returns: 674 * BCM_E_XXXX 675 */ 676 677 int 678 bcm_esw_l2gre_tunnel_terminator_traverse(int unit, bcm_tunnel_terminator_traverse_cb cb, void *user_data) 679 { 680 int rv = BCM_E_UNAVAIL; 681 #if defined(BCM_TRIUMPH3_SUPPORT) 682 if (soc_feature(unit, soc_feature_l2gre)) { 683 rv = bcm_tr3_l2gre_lock(unit); 684 if ( rv == BCM_E_NONE ) { 685 rv = bcm_tr3_l2gre_tunnel_terminator_traverse(unit, cb, user_data); 686 bcm_tr3_l2gre_unlock (unit); 687 } 688 } 689 #endif 690 return rv; 691 } 692 693 /* Function: 694 * _bcm_esw_l2gre_match_add 695 */ 696 697 int 698 _bcm_esw_l2gre_match_add(int unit, bcm_l2gre_port_t *l2gre_port, int vp, bcm_vpn_t vpn) 699 { 700 int rv = BCM_E_UNAVAIL; 701 702 #ifdef BCM_TOMAHAWK_SUPPORT 703 if (SOC_IS_TOMAHAWKX(unit)) { 704 rv = bcm_td2_l2gre_match_add(unit, l2gre_port, vp, vpn); 705 return rv; 706 } 707 #endif 708 709 #ifdef BCM_TRIDENT2_SUPPORT 710 if (soc_feature(unit, soc_feature_td2_l2gre)) { 711 rv = bcm_td2_l2gre_match_add(unit, l2gre_port, vp, vpn); 712 return rv; 713 } 714 #endif 715 716 #ifdef BCM_TRIUMPH3_SUPPORT 717 if (SOC_IS_TRIUMPH3(unit)) { 718 rv = bcm_tr3_l2gre_match_add(unit, l2gre_port, vp, vpn); 719 return rv; 720 } 721 #endif 722 return rv; 723 724 } 725 726 /* Function: 727 * bcm_esw_l2gre_match_delete 728 */ 729 730 int 731 _bcm_esw_l2gre_match_delete(int unit, int vp) 732 { 733 int rv = BCM_E_UNAVAIL; 734 735 #ifdef BCM_TOMAHAWK_SUPPORT 736 if (SOC_IS_TOMAHAWKX(unit)) { 737 rv = bcm_td2_l2gre_match_delete(unit, vp, NULL); 738 return rv; 739 } 740 #endif 741 742 #ifdef BCM_TRIDENT2_SUPPORT 743 if (soc_feature(unit, soc_feature_td2_l2gre)) { 744 rv = bcm_td2_l2gre_match_delete(unit, vp, NULL); 745 return rv; 746 } 747 #endif 748 749 #ifdef BCM_TRIUMPH3_SUPPORT 750 if (SOC_IS_TRIUMPH3(unit)) { 751 rv = bcm_tr3_l2gre_match_delete(unit, vp); 752 return rv; 753 } 754 #endif 755 return rv; 756 757 } 758 759 /* Function: 760 * _bcm_esw_l2gre_match_get 761 */ 762 763 int 764 _bcm_esw_l2gre_match_get(int unit, bcm_l2gre_port_t *l2gre_port, int vp) 765 { 766 int rv = BCM_E_UNAVAIL; 767 768 #ifdef BCM_TOMAHAWK_SUPPORT 769 if (SOC_IS_TOMAHAWKX(unit)) { 770 rv = bcm_td2_l2gre_match_get(unit, l2gre_port, vp); 771 return rv; 772 } 773 #endif 774 775 #ifdef BCM_TRIDENT2_SUPPORT 776 if (soc_feature(unit, soc_feature_td2_l2gre)) { 777 rv = bcm_td2_l2gre_match_get(unit, l2gre_port, vp); 778 return rv; 779 } 780 #endif 781 782 #ifdef BCM_TRIUMPH3_SUPPORT 783 if (SOC_IS_TRIUMPH3(unit)) { 784 rv = bcm_tr3_l2gre_match_get(unit, l2gre_port, vp); 785 return rv; 786 } 787 #endif 788 return rv; 789 790 } 791 792 /* Function: 793 * bcm_esw_l2gre_eline_vp_configure 794 */ 795 796 int 797 _bcm_esw_l2gre_eline_vp_configure (int unit, int vfi_index, int active_vp, 798 source_vp_entry_t *svp, int tpid_enable, bcm_l2gre_port_t *l2gre_port) 799 { 800 int rv = BCM_E_UNAVAIL; 801 802 #ifdef BCM_TOMAHAWK_SUPPORT 803 if (SOC_IS_TOMAHAWKX(unit)) { 804 rv = _bcm_td2_l2gre_eline_vp_configure(unit, vfi_index, active_vp, svp, 805 tpid_enable, l2gre_port); 806 return rv; 807 } 808 #endif 809 810 #ifdef BCM_TRIDENT2_SUPPORT 811 if (soc_feature(unit, soc_feature_td2_l2gre)) { 812 rv = _bcm_td2_l2gre_eline_vp_configure(unit, vfi_index, active_vp, svp, 813 tpid_enable, l2gre_port); 814 return rv; 815 } 816 #endif 817 818 #ifdef BCM_TRIUMPH3_SUPPORT 819 if (SOC_IS_TRIUMPH3(unit)) { 820 rv = _bcm_tr3_l2gre_eline_vp_configure (unit, vfi_index, active_vp, svp, 821 tpid_enable, l2gre_port); 822 return rv; 823 } 824 #endif 825 return rv; 826 827 } 828 829 830 /* Function: 831 * bcm_esw_l2gre_elan_vp_configure 832 */ 833 834 int 835 _bcm_esw_l2gre_elan_vp_configure (int unit, int vfi_index, int active_vp, 836 source_vp_entry_t *svp, int tpid_enable, bcm_l2gre_port_t *l2gre_port) 837 { 838 int rv = BCM_E_UNAVAIL; 839 840 #ifdef BCM_TOMAHAWK_SUPPORT 841 if (SOC_IS_TOMAHAWKX(unit)) { 842 rv = _bcm_td2_l2gre_elan_vp_configure(unit, vfi_index, active_vp, svp, 843 tpid_enable, l2gre_port); 844 return rv; 845 } 846 #endif 847 848 #ifdef BCM_TRIDENT2_SUPPORT 849 if (soc_feature(unit, soc_feature_td2_l2gre)) { 850 rv = _bcm_td2_l2gre_elan_vp_configure(unit, vfi_index, active_vp, svp, 851 tpid_enable, l2gre_port); 852 return rv; 853 } 854 #endif 855 856 #ifdef BCM_TRIUMPH3_SUPPORT 857 if (SOC_IS_TRIUMPH3(unit)) { 858 rv = _bcm_tr3_l2gre_elan_vp_configure (unit, vfi_index, active_vp, svp, 859 tpid_enable, l2gre_port); 860 return rv; 861 } 862 #endif 863 return rv; 864 865 } 866 867 /* 868 * Function: 869 * _bcm_esw_l2gre_trunk_member_add 870 * Purpose: 871 * Set l2GRE state for trunk members being added to a trunk group. 872 * Parameters: 873 * unit - (IN) Device Number 874 * trunk_id - (IN) Trunk Group ID 875 * trunk_member_count - (IN) Count of Trunk members to be added 876 * trunk_member_array - (IN) Trunk member ports to be added 877 * Returns: 878 * BCM_E_XXX 879 */ 880 int 881 _bcm_esw_l2gre_trunk_member_add(int unit, bcm_trunk_t trunk_id, 882 int trunk_member_count, bcm_port_t *trunk_member_array) 883 { 884 int rv = BCM_E_UNAVAIL; 885 #ifdef BCM_TRIUMPH3_SUPPORT 886 if (soc_feature(unit, soc_feature_l2gre)) { 887 rv = bcm_tr3_l2gre_trunk_member_add(unit, trunk_id, 888 trunk_member_count, trunk_member_array); 889 } 890 #endif 891 return rv; 892 } 893 894 /* 895 * Function: 896 * _bcm_esw_l2gre_trunk_member_delete 897 * Purpose: 898 * Clear L2GRE state for trunk members leaving a trunk group. 899 * Parameters: 900 * unit - (IN) Device Number 901 * trunk_id - (IN) Trunk Group ID 902 * trunk_member_count - (IN) Count of Trunk members to be deleted 903 * trunk_member_array - (IN) Trunk member ports to be deleted 904 * Returns: 905 * BCM_E_XXX 906 */ 907 int 908 _bcm_esw_l2gre_trunk_member_delete(int unit, bcm_trunk_t trunk_id, 909 int trunk_member_count, bcm_port_t *trunk_member_array) 910 { 911 int rv = BCM_E_UNAVAIL; 912 #ifdef BCM_TRIUMPH3_SUPPORT 913 if (soc_feature(unit, soc_feature_l2gre)) { 914 rv = bcm_tr3_l2gre_trunk_member_delete(unit, trunk_id, 915 trunk_member_count, trunk_member_array); 916 } 917 #endif 918 return rv; 919 } 920 921 922 #if defined(BCM_TRIDENT2_SUPPORT) || defined(BCM_TRIUMPH3_SUPPORT) 923 /* 924 * Function: 925 * _bcm_esw_l2gre_stat_get_table_info 926 * Description: 927 * Provides relevant flex table information(table-name,index with 928 * direction) for given ingress interface. 929 * 930 * Parameters: 931 * unit - (IN) unit number 932 * port - (IN) L2gre gport 933 * vpn - (IN) vpn (VFI) 934 * num_of_tables - (OUT) Number of flex counter tables 935 * table_info - (OUT) Flex counter tables information 936 * 937 * Return Value: 938 * BCM_E_XXX 939 * Notes: 940 */ 941 static 942 bcm_error_t _bcm_esw_l2gre_stat_get_table_info( 943 int unit, 944 bcm_gport_t port, 945 bcm_vpn_t vpn, 946 uint32 *num_of_tables, 947 bcm_stat_flex_table_info_t *table_info) 948 { 949 int vp = -1; 950 int vfi = -1; 951 int vp_vfi = -1; 952 int vp_type = -1; 953 954 if (!soc_feature(unit,soc_feature_advanced_flex_counter)) { 955 return BCM_E_UNAVAIL; 956 } 957 958 /* Parameter validation checks */ 959 if (!SOC_UNIT_VALID(unit)) { 960 return BCM_E_UNIT; 961 } 962 963 if ( !(_BCM_L2GRE_VPN_INVALID == vpn) && 964 (_BCM_VPN_IS_L2GRE_ELINE(vpn) || _BCM_VPN_IS_L2GRE_ELAN(vpn))) { 965 /* Get VFI */ 966 _BCM_L2GRE_VPN_GET(vfi, _BCM_VPN_TYPE_VFI, vpn); 967 if (!_bcm_vfi_used_get(unit, vfi, _bcmVfiTypeL2Gre)) { 968 return BCM_E_NOT_FOUND; 969 } 970 } 971 972 if (!(BCM_GPORT_INVALID == port) && BCM_GPORT_IS_L2GRE_PORT(port)) { 973 egr_dvp_attribute_entry_t egr_dvp_attribute; 974 source_vp_entry_t svp; 975 976 /* Ingress L2gre VP */ 977 vp = BCM_GPORT_L2GRE_PORT_ID_GET(port); 978 if (!_bcm_vp_used_get(unit, vp, _bcmVpTypeL2Gre)) { 979 return BCM_E_NOT_FOUND; 980 } 981 sal_memset(&svp, 0, sizeof(source_vp_entry_t)); 982 BCM_IF_ERROR_RETURN ( 983 READ_SOURCE_VPm(unit, MEM_BLOCK_ANY, vp, &svp)); 984 985 /* For VP-VFI attach flex counters for the associated VP */ 986 if (soc_SOURCE_VPm_field32_get(unit, &svp, ENTRY_TYPEf) == 0x1) { 987 table_info[*num_of_tables].table=SOURCE_VPm; 988 table_info[*num_of_tables].index=vp; 989 table_info[*num_of_tables].direction=bcmStatFlexDirectionIngress; 990 (*num_of_tables)++; 991 992 if (soc_SOURCE_VPm_field32_get(unit, &svp, VFIf) == vfi) { 993 vp_vfi = vfi; 994 } 995 } 996 997 sal_memset(&egr_dvp_attribute, 0, sizeof(egr_dvp_attribute_entry_t)); 998 BCM_IF_ERROR_RETURN( 999 soc_mem_read(unit, EGR_DVP_ATTRIBUTEm, MEM_BLOCK_ANY, 1000 vp, &egr_dvp_attribute)); 1001 #if defined(BCM_TRIDENT3_SUPPORT) 1002 if (SOC_MEM_FIELD_VALID(unit, EGR_DVP_ATTRIBUTEm, DATA_TYPEf)) { 1003 vp_type = soc_mem_field32_get(unit, EGR_DVP_ATTRIBUTEm, 1004 &egr_dvp_attribute, DATA_TYPEf); 1005 } else 1006 #endif 1007 { 1008 vp_type = soc_mem_field32_get(unit, EGR_DVP_ATTRIBUTEm, 1009 &egr_dvp_attribute, VP_TYPEf); 1010 } 1011 if (vp_type == 3) { /* l2gre vp type */ 1012 /* Egress L2gre (DVP) */ 1013 #if defined(BCM_TRIDENT3_SUPPORT) 1014 if (SOC_IS_TRIDENT3X(unit)) { 1015 table_info[*num_of_tables].table = EGR_DVP_ATTRIBUTEm; 1016 } else 1017 #endif 1018 { 1019 table_info[*num_of_tables].table=EGR_DVP_ATTRIBUTE_1m; 1020 } 1021 table_info[*num_of_tables].index=vp; 1022 table_info[*num_of_tables].direction=bcmStatFlexDirectionEgress; 1023 (*num_of_tables)++; 1024 } 1025 } 1026 1027 if ((vp_vfi == -1) && (vfi != -1)) { 1028 table_info[*num_of_tables].table=VFIm; 1029 table_info[*num_of_tables].index=vfi; 1030 table_info[*num_of_tables].direction=bcmStatFlexDirectionIngress; 1031 (*num_of_tables)++; 1032 } 1033 1034 if ((vp_type != 3) && (vfi != -1)){ 1035 /* Egress L2gre VPN */ 1036 table_info[*num_of_tables].table = EGR_VFIm; 1037 table_info[*num_of_tables].index = vfi; 1038 table_info[*num_of_tables].direction = bcmStatFlexDirectionEgress; 1039 (*num_of_tables)++; 1040 } 1041 1042 if (*num_of_tables == 0) { 1043 return BCM_E_PARAM; 1044 } 1045 1046 return BCM_E_NONE; 1047 } 1048 #endif /* BCM_TRIDENT2_SUPPORT */ 1049 1050 /* 1051 * Function: 1052 * bcm_esw_l2gre_stat_attach 1053 * Description: 1054 * Attach counters entries to the given L2gre port and vpn. 1055 * Allocate flex counter and assign counter index and offset for the index 1056 * pointed by L2gre vpn(VFI) and port(tunnel) 1057 * 1058 * Parameters: 1059 * unit - (IN) unit number 1060 * port - (IN) L2gre gport 1061 * vpn - (IN) vpn (VFI) 1062 * stat_counter_id - (IN) Stat Counter ID. 1063 * 1064 * Return Value: 1065 * BCM_E_XXX 1066 * Notes: 1067 */ 1068 1069 bcm_error_t bcm_esw_l2gre_stat_attach ( 1070 int unit, 1071 bcm_gport_t port, 1072 bcm_vpn_t vpn, 1073 uint32 stat_counter_id) 1074 { 1075 #if defined(BCM_TRIDENT2_SUPPORT) || defined(BCM_TRIUMPH3_SUPPORT) 1076 int rv = BCM_E_NONE; 1077 int counter_flag = 0; 1078 soc_mem_t table = 0; 1079 bcm_stat_flex_direction_t direction = bcmStatFlexDirectionIngress; 1080 uint32 pool_number = 0; 1081 uint32 base_index = 0; 1082 bcm_stat_flex_mode_t offset_mode = 0; 1083 bcm_stat_object_t object = bcmStatObjectIngPort; 1084 bcm_stat_group_mode_t group_mode = bcmStatGroupModeSingle; 1085 uint32 count = 0; 1086 uint32 actual_num_tables = 0; 1087 uint32 num_of_tables = 0; 1088 bcm_stat_flex_table_info_t table_info[BCM_STAT_L2GRE_FLEX_COUNTER_MAX_TABLES]; 1089 1090 if (!soc_feature(unit,soc_feature_advanced_flex_counter)) { 1091 return BCM_E_UNAVAIL; 1092 } 1093 1094 /* Parameter validation checks */ 1095 if (!SOC_UNIT_VALID(unit)) { 1096 return BCM_E_UNIT; 1097 } 1098 1099 /* Get pool, base index group mode and offset modes from stat counter id */ 1100 _bcm_esw_stat_get_counter_id_info( 1101 unit, 1102 stat_counter_id, 1103 &group_mode, &object, &offset_mode, &pool_number, &base_index); 1104 1105 /* Validate object and group mode */ 1106 BCM_IF_ERROR_RETURN(_bcm_esw_stat_validate_object(unit, object, &direction)); 1107 BCM_IF_ERROR_RETURN(_bcm_esw_stat_validate_group(unit, group_mode)); 1108 1109 /* Get Table index to attach flexible counter */ 1110 BCM_IF_ERROR_RETURN(_bcm_esw_stat_flex_get_table_info( 1111 unit, object, 1, &actual_num_tables, &table, &direction)); 1112 BCM_IF_ERROR_RETURN(_bcm_esw_l2gre_stat_get_table_info( 1113 unit, port, vpn, &num_of_tables, &table_info[0])); 1114 1115 for (count = 0; count < num_of_tables; count++) { 1116 if ((table_info[count].direction == direction)) { 1117 if (direction == bcmStatFlexDirectionIngress) { 1118 counter_flag = 1; 1119 rv = _bcm_esw_stat_flex_attach_ingress_table_counters( 1120 unit, 1121 table_info[count].table, 1122 table_info[count].index, 1123 offset_mode, 1124 base_index, 1125 pool_number); 1126 if(BCM_FAILURE(rv)) { 1127 break; 1128 } 1129 } else { 1130 counter_flag = 1; 1131 rv = _bcm_esw_stat_flex_attach_egress_table_counters( 1132 unit, 1133 table_info[count].table, 1134 table_info[count].index, 1135 0, 1136 offset_mode, 1137 base_index, 1138 pool_number); 1139 1140 if(BCM_FAILURE(rv)) { 1141 break; 1142 } 1143 } 1144 } 1145 } 1146 1147 if (counter_flag == 0) { 1148 rv = BCM_E_NOT_FOUND; 1149 } 1150 return rv; 1151 #else 1152 return BCM_E_UNAVAIL; 1153 #endif /* BCM_TRIDENT2_SUPPORT */ 1154 } 1155 1156 1157 /* 1158 * Function: 1159 * bcm_esw_l2gre_stat_detach 1160 * Description: 1161 * Detach counter entries to the given L2gre port and vpn. 1162 * 1163 * Parameters: 1164 * unit - (IN) unit number 1165 * port - (IN) L2gre gport 1166 * vpn - (IN) vpn (VFI) 1167 * 1168 * Return Value: 1169 * BCM_E_XXX 1170 * Notes: 1171 */ 1172 bcm_error_t bcm_esw_l2gre_stat_detach ( 1173 int unit, 1174 bcm_gport_t port, 1175 bcm_vpn_t vpn) 1176 { 1177 1178 #if defined(BCM_TRIDENT2_SUPPORT) || defined(BCM_TRIUMPH3_SUPPORT) 1179 uint32 count = 0; 1180 uint32 num_of_tables = 0; 1181 bcm_stat_flex_table_info_t table_info[BCM_STAT_L2GRE_FLEX_COUNTER_MAX_TABLES]; 1182 bcm_error_t rv = BCM_E_NONE; 1183 bcm_error_t err_code[BCM_STAT_FLEX_COUNTER_MAX_DIRECTION] = {BCM_E_NONE}; 1184 1185 if (!soc_feature(unit,soc_feature_advanced_flex_counter)) { 1186 return BCM_E_UNAVAIL; 1187 } 1188 1189 /* Parameter validation checks */ 1190 if (!SOC_UNIT_VALID(unit)) { 1191 return BCM_E_UNIT; 1192 } 1193 1194 1195 /* Get the table index to be detached */ 1196 BCM_IF_ERROR_RETURN(_bcm_esw_l2gre_stat_get_table_info( 1197 unit, port, vpn, &num_of_tables, &table_info[0])); 1198 1199 for (count = 0; count < num_of_tables; count++) { 1200 if (table_info[count].direction == bcmStatFlexDirectionIngress) { 1201 rv = _bcm_esw_stat_flex_detach_ingress_table_counters( 1202 unit, table_info[count].table, table_info[count].index); 1203 if (BCM_E_NONE != rv && 1204 BCM_E_NONE == err_code[bcmStatFlexDirectionIngress]) { 1205 err_code[bcmStatFlexDirectionIngress] = rv; 1206 } 1207 } else if (table_info[count].direction == bcmStatFlexDirectionEgress) { 1208 rv = _bcm_esw_stat_flex_detach_egress_table_counters( 1209 unit, 0, table_info[count].table, 1210 table_info[count].index); 1211 if (BCM_E_NONE != rv && 1212 BCM_E_NONE == err_code[bcmStatFlexDirectionEgress]) { 1213 err_code[bcmStatFlexDirectionEgress] = rv; 1214 } 1215 } 1216 } 1217 1218 BCM_STAT_FLEX_DETACH_RETURN(err_code) 1219 #else 1220 return BCM_E_UNAVAIL; 1221 #endif /* BCM_TRIDENT2_SUPPORT */ 1222 } 1223 1224 /* 1225 * Function: 1226 * _bcm_esw_l2gre_stat_counter_get 1227 * 1228 * Description: 1229 * Get L2gre counter value for specified L2gre port and vpn 1230 * if sync_mode is set, sync the sw accumulated count 1231 * with hw count value first, else return sw count. 1232 * 1233 * Parameters: 1234 * unit - (IN) unit number 1235 * sync_mode - (IN) hwcount is to be synced to sw count 1236 * port - (IN) L2gre gport 1237 * vpn - (IN) vpn (VFI) 1238 * stat - (IN) L2gre counter stat types 1239 * num_entries - (IN) Number of counter Entries 1240 * counter_indexes - (IN) Pointer to Counter Offset indexes entries 1241 * counter_values - (OUT) Pointer to counter values 1242 * 1243 * Return Value: 1244 * BCM_E_XXX 1245 * Notes: 1246 */ 1247 bcm_error_t _bcm_esw_l2gre_stat_counter_get( 1248 int unit, 1249 int sync_mode, 1250 bcm_gport_t port, 1251 bcm_vpn_t vpn, 1252 bcm_l2gre_stat_t stat, 1253 uint32 num_entries, 1254 uint32 *counter_indexes, 1255 bcm_stat_value_t *counter_values) 1256 { 1257 1258 #if defined(BCM_TRIDENT2_SUPPORT) || defined(BCM_TRIUMPH3_SUPPORT) 1259 uint32 table_count = 0; 1260 uint32 index_count = 0; 1261 uint32 num_of_tables = 0; 1262 bcm_stat_flex_direction_t direction = bcmStatFlexDirectionIngress; 1263 uint32 byte_flag = 0; 1264 bcm_stat_flex_table_info_t table_info[BCM_STAT_L2GRE_FLEX_COUNTER_MAX_TABLES]; 1265 1266 if (!soc_feature(unit,soc_feature_advanced_flex_counter)) { 1267 return BCM_E_UNAVAIL; 1268 } 1269 1270 /* Parameter validation checks */ 1271 if (!SOC_UNIT_VALID(unit)) { 1272 return BCM_E_UNIT; 1273 } 1274 1275 /* Get the flex counter direction - ingress/egress */ 1276 if ((stat == bcmL2greOutPackets) || 1277 (stat == bcmL2greOutBytes)) { 1278 direction = bcmStatFlexDirectionEgress; 1279 } else { 1280 direction = bcmStatFlexDirectionIngress; 1281 } 1282 if ((stat == bcmL2greOutPackets) || 1283 (stat == bcmL2greInPackets)) { 1284 byte_flag=0; 1285 } else { 1286 byte_flag=1; 1287 } 1288 1289 /* Get Table index to read the flex counter */ 1290 BCM_IF_ERROR_RETURN(_bcm_esw_l2gre_stat_get_table_info( 1291 unit, port, vpn, &num_of_tables, &table_info[0])); 1292 1293 /* Get the flex counter for the attached table index */ 1294 for (table_count = 0; table_count < num_of_tables ; table_count++) { 1295 if (table_info[table_count].direction == direction) { 1296 for (index_count = 0; index_count < num_entries ; index_count++) { 1297 BCM_IF_ERROR_RETURN(_bcm_esw_stat_counter_get( 1298 unit, sync_mode, 1299 table_info[table_count].index, 1300 table_info[table_count].table, 1301 0, 1302 byte_flag, 1303 counter_indexes[index_count], 1304 &counter_values[index_count])); 1305 } 1306 } 1307 } 1308 1309 return BCM_E_NONE; 1310 #else 1311 return BCM_E_UNAVAIL; 1312 #endif /* BCM_TRIDENT2_SUPPORT */ 1313 1314 } 1315 1316 1317 1318 /* 1319 * Function: 1320 * bcm_esw_l2gre_stat_counter_get 1321 * 1322 * Description: 1323 * Get L2gre counter value for specified L2gre port and vpn 1324 * 1325 * Parameters: 1326 * unit - (IN) unit number 1327 * port - (IN) L2gre gport 1328 * vpn - (IN) vpn (VFI) 1329 * stat - (IN) L2gre counter stat types 1330 * num_entries - (IN) Number of counter Entries 1331 * counter_indexes - (IN) Pointer to Counter Offset indexes entries 1332 * counter_values - (OUT) Pointer to counter values 1333 * 1334 * Return Value: 1335 * BCM_E_XXX 1336 * Notes: 1337 */ 1338 int bcm_esw_l2gre_stat_counter_get( 1339 int unit, 1340 bcm_gport_t port, 1341 bcm_vpn_t vpn, 1342 bcm_l2gre_stat_t stat, 1343 uint32 num_entries, 1344 uint32 *counter_indexes, 1345 bcm_stat_value_t *counter_values) 1346 { 1347 1348 return _bcm_esw_l2gre_stat_counter_get(unit, 0, port, 1349 vpn, stat, 1350 num_entries, 1351 counter_indexes, 1352 counter_values); 1353 1354 } 1355 1356 1357 1358 /* 1359 * Function: 1360 * bcm_esw_l2gre_stat_counter_sync_get 1361 * 1362 * Description: 1363 * Get L2gre counter value for specified L2gre port and vpn 1364 * sw accumulated counters synced with hw count. 1365 * 1366 * Parameters: 1367 * unit - (IN) unit number 1368 * port - (IN) L2gre gport 1369 * vpn - (IN) vpn (VFI) 1370 * stat - (IN) L2gre counter stat types 1371 * num_entries - (IN) Number of counter Entries 1372 * counter_indexes - (IN) Pointer to Counter Offset indexes entries 1373 * counter_values - (OUT) Pointer to counter values 1374 * 1375 * Return Value: 1376 * BCM_E_XXX 1377 * Notes: 1378 */ 1379 int bcm_esw_l2gre_stat_counter_sync_get( 1380 int unit, 1381 bcm_gport_t port, 1382 bcm_vpn_t vpn, 1383 bcm_l2gre_stat_t stat, 1384 uint32 num_entries, 1385 uint32 *counter_indexes, 1386 bcm_stat_value_t *counter_values) 1387 { 1388 1389 return _bcm_esw_l2gre_stat_counter_get(unit, 1, port, 1390 vpn, stat, 1391 num_entries, 1392 counter_indexes, 1393 counter_values); 1394 1395 } 1396 /* 1397 * Function: 1398 * bcm_esw_l2gre_stat_counter_set 1399 * 1400 * Description: 1401 * Set L2gre counter value for specified L2gre port and vpn 1402 * 1403 * Parameters: 1404 * unit - (IN) unit number 1405 * port - (IN) L2gre gport 1406 * vpn - (IN) vpn (VFI) 1407 * stat - (IN) L2gre counter stat types 1408 * num_entries - (IN) Number of counter Entries 1409 * counter_indexes - (IN) Pointer to Counter offset indexes 1410 * counter_values - (IN) Pointer to counter values 1411 * 1412 * Return Value: 1413 * BCM_E_XXX 1414 * Notes: 1415 */ 1416 bcm_error_t bcm_esw_l2gre_stat_counter_set( 1417 int unit, 1418 bcm_gport_t port, 1419 bcm_vpn_t vpn, 1420 bcm_l2gre_stat_t stat, 1421 uint32 num_entries, 1422 uint32 *counter_indexes, 1423 bcm_stat_value_t *counter_values) 1424 { 1425 #if defined(BCM_TRIDENT2_SUPPORT) || defined(BCM_TRIUMPH3_SUPPORT) 1426 uint32 table_count=0; 1427 uint32 index_count=0; 1428 uint32 num_of_tables=0; 1429 bcm_stat_flex_direction_t direction=bcmStatFlexDirectionIngress; 1430 uint32 byte_flag=0; 1431 bcm_stat_flex_table_info_t table_info[BCM_STAT_L2GRE_FLEX_COUNTER_MAX_TABLES]; 1432 1433 if (!soc_feature(unit,soc_feature_advanced_flex_counter)) { 1434 return BCM_E_UNAVAIL; 1435 } 1436 1437 /* Parameter validation checks */ 1438 if (!SOC_UNIT_VALID(unit)) { 1439 return BCM_E_UNIT; 1440 } 1441 1442 /* Get the flex counter direction - ingress/egress */ 1443 if ((stat == bcmL2greOutPackets) || 1444 (stat == bcmL2greOutBytes)) { 1445 direction = bcmStatFlexDirectionEgress; 1446 } else { 1447 direction = bcmStatFlexDirectionIngress; 1448 } 1449 if (stat == bcmL2greOutPackets || stat == bcmL2greInPackets) { 1450 byte_flag=0; 1451 } else { 1452 byte_flag=1; 1453 } 1454 1455 /* Get Table index to read the flex counter */ 1456 BCM_IF_ERROR_RETURN(_bcm_esw_l2gre_stat_get_table_info( 1457 unit, port, vpn, &num_of_tables, &table_info[0])); 1458 1459 /* Get the flex counter for the attached table index */ 1460 for (table_count = 0; table_count < num_of_tables ; table_count++) { 1461 if (table_info[table_count].direction == direction) { 1462 for (index_count = 0; index_count < num_entries; index_count++) { 1463 BCM_IF_ERROR_RETURN(_bcm_esw_stat_counter_set( 1464 unit, 1465 table_info[table_count].index, 1466 table_info[table_count].table, 1467 0, 1468 byte_flag, 1469 counter_indexes[index_count], 1470 &counter_values[index_count])); 1471 } 1472 } 1473 } 1474 return BCM_E_NONE; 1475 #else 1476 return BCM_E_UNAVAIL; 1477 #endif /* BCM_TRIDENT2_SUPPORT */ 1478 } 1479 1480 /* 1481 * Function: 1482 * bcm_esw_l2gre_stat_multi_get 1483 * 1484 * Description: 1485 * Get Multiple L2gre counter value for specified L2gre port and vpn for multiple stat 1486 * types 1487 * 1488 * Parameters: 1489 * unit - (IN) unit number 1490 * port - (IN) L2gre gport 1491 * vpn - (IN) vpn (VFI) 1492 * nstat - (IN) Number of elements in stat array 1493 * stat_arr - (IN) Collected statistics descriptors array 1494 * value_arr - (OUT) Collected counters values 1495 * 1496 * Return Value: 1497 * BCM_E_XXX 1498 * Notes: 1499 */ 1500 bcm_error_t bcm_esw_l2gre_stat_multi_get( 1501 int unit, 1502 bcm_gport_t port, 1503 bcm_vpn_t vpn, 1504 int nstat, 1505 bcm_l2gre_stat_t *stat_arr, 1506 uint64 *value_arr) 1507 { 1508 #if defined(BCM_TRIDENT2_SUPPORT) || defined(BCM_TRIUMPH3_SUPPORT) 1509 int rv = BCM_E_NONE; 1510 int idx; 1511 uint32 counter_indexes = 0; 1512 bcm_stat_value_t counter_values = {0}; 1513 1514 if (!soc_feature(unit,soc_feature_advanced_flex_counter)) { 1515 return BCM_E_UNAVAIL; 1516 } 1517 1518 /* Parameter validation checks */ 1519 if (!SOC_UNIT_VALID(unit)) { 1520 return BCM_E_UNIT; 1521 } 1522 1523 /* Iterate of all stats array to retrieve flex counter values */ 1524 for (idx = 0; idx < nstat ;idx++) { 1525 BCM_IF_ERROR_RETURN(bcm_esw_l2gre_stat_counter_get( 1526 unit, port, vpn, stat_arr[idx], 1527 1, &counter_indexes, &counter_values)); 1528 if ((stat_arr[idx] == bcmL2greOutPackets) || 1529 (stat_arr[idx] == bcmL2greInPackets)) { 1530 COMPILER_64_SET(value_arr[idx], 1531 COMPILER_64_HI(counter_values.packets64), 1532 COMPILER_64_LO(counter_values.packets64)); 1533 } else { 1534 COMPILER_64_SET(value_arr[idx], 1535 COMPILER_64_HI(counter_values.bytes), 1536 COMPILER_64_LO(counter_values.bytes)); 1537 } 1538 } 1539 return rv; 1540 #else 1541 return BCM_E_UNAVAIL; 1542 #endif /* BCM_TRIDENT2_SUPPORT */ 1543 1544 } 1545 1546 /* 1547 * Function: 1548 * bcm_esw_l2gre_stat_multi_get32 1549 * 1550 * Description: 1551 * Get 32bit L2gre counter value for specified L2gre port and vpn for multiple stat 1552 * types 1553 * 1554 * Parameters: 1555 * unit - (IN) unit number 1556 * port - (IN) L2gre gport 1557 * vpn - (IN) vpn (VFI) 1558 * nstat - (IN) Number of elements in stat array 1559 * stat_arr - (IN) Collected statistics descriptors array 1560 * value_arr - (OUT) Collected counters values 1561 * 1562 * Return Value: 1563 * BCM_E_XXX 1564 * Notes: 1565 */ 1566 bcm_error_t bcm_esw_l2gre_stat_multi_get32( 1567 int unit, 1568 bcm_gport_t port, 1569 bcm_vpn_t vpn, 1570 int nstat, 1571 bcm_l2gre_stat_t *stat_arr, 1572 uint32 *value_arr) 1573 { 1574 #if defined(BCM_TRIDENT2_SUPPORT) || defined(BCM_TRIUMPH3_SUPPORT) 1575 int rv = BCM_E_NONE; 1576 int idx; 1577 uint32 counter_indexes = 0; 1578 bcm_stat_value_t counter_values = {0}; 1579 1580 if (!soc_feature(unit,soc_feature_advanced_flex_counter)) { 1581 return BCM_E_UNAVAIL; 1582 } 1583 1584 /* Parameter validation checks */ 1585 if (!SOC_UNIT_VALID(unit)) { 1586 return BCM_E_UNIT; 1587 } 1588 1589 /* Iterate of all stats array to retrieve flex counter values */ 1590 for (idx = 0; idx < nstat ;idx++) { 1591 BCM_IF_ERROR_RETURN(bcm_esw_l2gre_stat_counter_get( 1592 unit, port, vpn, stat_arr[idx], 1593 1, &counter_indexes, &counter_values)); 1594 if ((stat_arr[idx] == bcmL2greOutPackets) || 1595 (stat_arr[idx] == bcmL2greInPackets)) { 1596 value_arr[idx] = counter_values.packets; 1597 } else { 1598 value_arr[idx] = COMPILER_64_LO(counter_values.bytes); 1599 } 1600 } 1601 return rv; 1602 #else 1603 return BCM_E_UNAVAIL; 1604 #endif /* BCM_TRIDENT2_SUPPORT */ 1605 } 1606 1607 /* 1608 * Function: 1609 * bcm_esw_l2gre_stat_multi_set 1610 * 1611 * Description: 1612 * Set L2gre counter value for specified L2gre port and vpn for multiple stat 1613 * types 1614 * 1615 * Parameters: 1616 * unit - (IN) unit number 1617 * port - (IN) L2gre gport 1618 * vpn - (IN) vpn (VFI) 1619 * stat - (IN) L2gre counter stat types 1620 * num_entries - (IN) Number of counter Entries 1621 * counter_indexes - (IN) Pointer to Counter Offset indexes entries 1622 * counter_values - (OUT) Pointer to counter values 1623 * 1624 * Return Value: 1625 * BCM_E_XXX 1626 * Notes: 1627 */ 1628 bcm_error_t bcm_esw_l2gre_stat_multi_set( 1629 int unit, 1630 bcm_gport_t port, 1631 bcm_vpn_t vpn, 1632 int nstat, 1633 bcm_l2gre_stat_t *stat_arr, 1634 uint64 *value_arr) 1635 { 1636 #if defined(BCM_TRIDENT2_SUPPORT) || defined(BCM_TRIUMPH3_SUPPORT) 1637 int rv = BCM_E_NONE; 1638 int idx; 1639 uint32 counter_indexes = 0; 1640 bcm_stat_value_t counter_values = {0}; 1641 1642 if (!soc_feature(unit,soc_feature_advanced_flex_counter)) { 1643 return BCM_E_UNAVAIL; 1644 } 1645 1646 /* Parameter validation checks */ 1647 if (!SOC_UNIT_VALID(unit)) { 1648 return BCM_E_UNIT; 1649 } 1650 1651 /* Iterate f all stats array to retrieve flex counter values */ 1652 for (idx = 0; idx < nstat ;idx++) { 1653 if ((stat_arr[idx] == bcmL2greOutPackets) || 1654 (stat_arr[idx] == bcmL2greInPackets)) { 1655 counter_values.packets = COMPILER_64_LO(value_arr[idx]); 1656 } else { 1657 COMPILER_64_SET(counter_values.bytes, 1658 COMPILER_64_HI(value_arr[idx]), 1659 COMPILER_64_LO(value_arr[idx])); 1660 } 1661 BCM_IF_ERROR_RETURN(bcm_esw_l2gre_stat_counter_set( 1662 unit, port, vpn, stat_arr[idx], 1663 1, &counter_indexes, &counter_values)); 1664 } 1665 return rv; 1666 #else 1667 return BCM_E_UNAVAIL; 1668 #endif /* BCM_TRIDENT2_SUPPORT */ 1669 } 1670 1671 /* 1672 * Function: 1673 * bcm_esw_l2gre_stat_multi_set32 1674 * 1675 * Description: 1676 * Set 32bit L2gre counter value for specified L2gre port and vpn for multiple stat 1677 * types 1678 * 1679 * Parameters: 1680 * unit - (IN) unit number 1681 * port - (IN) L2gre gport 1682 * vpn - (IN) vpn (VFI) 1683 * stat - (IN) L2gre counter stat types 1684 * num_entries - (IN) Number of counter Entries 1685 * counter_indexes - (IN) Pointer to Counter Offset indexes entries 1686 * counter_values - (OUT) Pointer to counter values 1687 * 1688 * Return Value: 1689 * BCM_E_XXX 1690 * Notes: 1691 */ 1692 1693 bcm_error_t bcm_esw_l2gre_stat_multi_set32( 1694 int unit, 1695 bcm_gport_t port, 1696 bcm_vpn_t vpn, 1697 int nstat, 1698 bcm_l2gre_stat_t *stat_arr, 1699 uint32 *value_arr) 1700 { 1701 #if defined(BCM_TRIDENT2_SUPPORT) || defined(BCM_TRIUMPH3_SUPPORT) 1702 int rv = BCM_E_NONE; 1703 int idx; 1704 uint32 counter_indexes = 0; 1705 bcm_stat_value_t counter_values = {0}; 1706 1707 if (!soc_feature(unit,soc_feature_advanced_flex_counter)) { 1708 return BCM_E_UNAVAIL; 1709 } 1710 1711 /* Parameter validation checks */ 1712 if (!SOC_UNIT_VALID(unit)) { 1713 return BCM_E_UNIT; 1714 } 1715 1716 /* Iterate of all stats array to retrieve flex counter values */ 1717 for (idx = 0; idx < nstat ;idx++) { 1718 if ((stat_arr[idx] == bcmL2greOutPackets) || 1719 (stat_arr[idx] == bcmL2greInPackets)) { 1720 counter_values.packets = value_arr[idx]; 1721 } else { 1722 COMPILER_64_SET(counter_values.bytes,0,value_arr[idx]); 1723 } 1724 BCM_IF_ERROR_RETURN(bcm_esw_l2gre_stat_counter_set( 1725 unit, port, vpn, stat_arr[idx], 1726 1, &counter_indexes, &counter_values)); 1727 } 1728 return rv; 1729 #else 1730 return BCM_E_UNAVAIL; 1731 #endif /* BCM_TRIDENT2_SUPPORT */ 1732 } 1733 1734 /* 1735 * Function: 1736 * bcm_esw_l2gre_stat_id_get 1737 * 1738 * Description: 1739 * Get Stat Counter if associated with given L2gre port and vpn 1740 * 1741 * Parameters: 1742 * unit - (IN) bcm device 1743 * port - (IN) L2gre gport 1744 * vpn - (IN) vpn (VFI) 1745 * stat - (IN) L2gre counter stat types 1746 * stat_counter_id - (IN) Stat Counter ID. 1747 * 1748 * Returns: 1749 * BCM_E_NONE - Success 1750 * BCM_E_XXX 1751 * Notes: 1752 */ 1753 1754 bcm_error_t bcm_esw_l2gre_stat_id_get( 1755 int unit, 1756 bcm_gport_t port, 1757 bcm_vpn_t vpn, 1758 bcm_l2gre_stat_t stat, 1759 uint32 *stat_counter_id) 1760 { 1761 #if defined(BCM_TRIDENT2_SUPPORT) || defined(BCM_TRIUMPH3_SUPPORT) 1762 bcm_stat_flex_direction_t direction = bcmStatFlexDirectionIngress; 1763 uint32 num_of_tables = 0; 1764 bcm_stat_flex_table_info_t table_info[BCM_STAT_L2GRE_FLEX_COUNTER_MAX_TABLES]; 1765 uint32 index = 0; 1766 uint32 num_stat_counter_ids = 0; 1767 1768 if (!soc_feature(unit,soc_feature_advanced_flex_counter)) { 1769 return BCM_E_UNAVAIL; 1770 } 1771 1772 /* Parameter validation checks */ 1773 if (!SOC_UNIT_VALID(unit)) { 1774 return BCM_E_UNIT; 1775 } 1776 1777 if ((stat == bcmL2greOutPackets) || 1778 (stat == bcmL2greOutBytes)) { 1779 direction = bcmStatFlexDirectionEgress; 1780 } else { 1781 direction = bcmStatFlexDirectionIngress; 1782 } 1783 1784 /* Get Tables, for which flex counter are attached */ 1785 BCM_IF_ERROR_RETURN(_bcm_esw_l2gre_stat_get_table_info( 1786 unit, port, vpn, &num_of_tables, &table_info[0])); 1787 1788 /* Retrieve stat counter id */ 1789 for (index = 0; index < num_of_tables ; index++) { 1790 if (table_info[index].direction == direction) 1791 return _bcm_esw_stat_flex_get_counter_id( 1792 unit, 1, &table_info[index], 1793 &num_stat_counter_ids, stat_counter_id); 1794 } 1795 return BCM_E_NOT_FOUND; 1796 #else 1797 return BCM_E_UNAVAIL; 1798 #endif /* BCM_TRIDENT2_SUPPORT */ 1799 } 1800 1801 #ifdef BCM_WARM_BOOT_SUPPORT 1802 /* 1803 * Function: 1804 * _bcm_esw_l2gre_sync 1805 * 1806 * Purpose: 1807 * Record L2GRE module persistent info for Level 2 Warm Boot 1808 * 1809 * Warm Boot Version Map: 1810 * WB_VERSION_1_0 1811 * 1812 * Parameters: 1813 * unit - (IN) Device Unit Number. 1814 * 1815 * Returns: 1816 * BCM_E_XXX 1817 */ 1818 int 1819 _bcm_esw_l2gre_sync(int unit) 1820 { 1821 #ifdef BCM_TRIUMPH3_SUPPORT 1822 if (soc_feature(unit, soc_feature_l2gre)) { 1823 return _bcm_tr3_l2gre_sync(unit); 1824 } 1825 #endif /* BCM_TRIUMPH3_SUPPORT */ 1826 1827 return BCM_E_NONE; 1828 } 1829 #endif /* BCM_WARM_BOOT_SUPPORT */ 1830 #ifdef BCM_WARM_BOOT_SUPPORT_SW_DUMP 1831 /* 1832 * Function: 1833 * _bcm_l2gre_sw_dump 1834 * Purpose: 1835 * Displays L2GRE information maintained by software. 1836 * Parameters: 1837 * unit - Device unit number 1838 * Returns: 1839 * None 1840 */ 1841 void 1842 _bcm_l2gre_sw_dump(int unit) 1843 { 1844 #ifdef BCM_TRIUMPH3_SUPPORT 1845 if (soc_feature(unit, soc_feature_l2gre)) { 1846 _bcm_tr3_l2gre_sw_dump(unit); 1847 } 1848 #endif /* BCM_TRIUMPH3_SUPPORT */ 1849 return; 1850 } 1851 #endif 1852 1853 /* 1854 * Function: 1855 * _bcm_esw_l2gre_port_source_vp_lag_set 1856 * Purpose: 1857 * Set source VP LAG for a L2GRE virtual port. 1858 * Parameters: 1859 * unit - (IN) SOC unit number. 1860 * gport - (IN) L2GRE virtual port GPORT ID. 1861 * vp_lag_vp - (IN) VP representing the VP LAG. 1862 * Returns: 1863 * BCM_X_XXX 1864 */ 1865 int 1866 _bcm_esw_l2gre_port_source_vp_lag_set( 1867 int unit, bcm_gport_t gport, int vp_lag_vp) 1868 { 1869 int rv = BCM_E_UNAVAIL; 1870 1871 #if defined(BCM_TRIDENT2_SUPPORT) 1872 if (soc_feature(unit, soc_feature_td2_l2gre) && 1873 soc_feature(unit, soc_feature_vp_lag)) { 1874 rv = bcm_tr3_l2gre_lock(unit); 1875 if ( rv == BCM_E_NONE ) { 1876 rv = bcm_td2_l2gre_port_source_vp_lag_set(unit, gport, vp_lag_vp); 1877 bcm_tr3_l2gre_unlock(unit); 1878 } 1879 } 1880 #endif /* BCM_TRIDENT2_SUPPORT */ 1881 1882 return rv; 1883 } 1884 1885 /* 1886 * Function: 1887 * _bcm_esw_l2gre_port_source_vp_lag_clear 1888 * Purpose: 1889 * Clear source VP LAG for a L2GRE virtual port. 1890 * Parameters: 1891 * unit - (IN) SOC unit number. 1892 * gport - (IN) L2GRE virtual port GPORT ID. 1893 * vp_lag_vp - (IN) VP representing the VP LAG. 1894 * Returns: 1895 * BCM_X_XXX 1896 */ 1897 int 1898 _bcm_esw_l2gre_port_source_vp_lag_clear( 1899 int unit, bcm_gport_t gport, int vp_lag_vp) 1900 { 1901 int rv = BCM_E_UNAVAIL; 1902 1903 #if defined(BCM_TRIDENT2_SUPPORT) 1904 if (soc_feature(unit, soc_feature_td2_l2gre) && 1905 soc_feature(unit, soc_feature_vp_lag)) { 1906 rv = bcm_tr3_l2gre_lock(unit); 1907 if ( rv == BCM_E_NONE ) { 1908 rv = bcm_td2_l2gre_port_source_vp_lag_clear(unit, gport, vp_lag_vp); 1909 bcm_tr3_l2gre_unlock(unit); 1910 } 1911 } 1912 #endif /* BCM_TRIDENT2_SUPPORT */ 1913 1914 return rv; 1915 } 1916 1917 /* 1918 * Function: 1919 * _bcm_esw_l2gre_port_source_vp_lag_get 1920 * Purpose: 1921 * Get source VP LAG for a L2GRE virtual port. 1922 * Parameters: 1923 * unit - (IN) SOC unit number. 1924 * gport - (IN) L2GRE virtual port GPORT ID. 1925 * vp_lag_vp - (OUT) VP representing the VP LAG. 1926 * Returns: 1927 * BCM_X_XXX 1928 */ 1929 int 1930 _bcm_esw_l2gre_port_source_vp_lag_get( 1931 int unit, bcm_gport_t gport, int *vp_lag_vp) 1932 { 1933 int rv = BCM_E_UNAVAIL; 1934 1935 #if defined(BCM_TRIDENT2_SUPPORT) 1936 if (soc_feature(unit, soc_feature_td2_l2gre) && 1937 soc_feature(unit, soc_feature_vp_lag)) { 1938 rv = bcm_tr3_l2gre_lock(unit); 1939 if ( rv == BCM_E_NONE ) { 1940 rv = bcm_td2_l2gre_port_source_vp_lag_get(unit, gport, vp_lag_vp); 1941 bcm_tr3_l2gre_unlock(unit); 1942 } 1943 } 1944 #endif /* BCM_TRIDENT2_SUPPORT */ 1945 1946 return rv; 1947 } 1948 #else /* INCLUDE_L3 */ 1949 int bcm_esw_l2gre_not_empty; 1950 #endif /* INCLUDE_L3 */