trill.c (13316B)
1 /* 2 * 3 * This license is set out in https://raw.githubusercontent.com/Broadcom-Network-Switching-Software/OpenBCM/master/Legal/LICENSE file. 4 * 5 * Copyright 2007-2019 Broadcom Inc. All rights reserved. 6 * 7 * File: bcmx/trill.c 8 * Purpose: BCMX Trill APIs 9 */ 10 11 #ifdef INCLUDE_L3 12 13 #include <sal/core/libc.h> 14 15 #include <bcm/types.h> 16 17 #include <bcmx/lport.h> 18 #include <bcmx/trill.h> 19 20 #include "bcmx_int.h" 21 22 #define BCMX_TRILL_INIT_CHECK BCMX_READY_CHECK 23 24 #define BCMX_TRILL_ERROR_CHECK(_unit, _check, _rv) \ 25 BCMX_ERROR_CHECK(_unit, _check, _rv) 26 27 #define BCMX_TRILL_SET_ERROR_CHECK(_unit, _check, _rv) \ 28 BCMX_SET_ERROR_CHECK(_unit, _check, _rv) 29 30 #define BCMX_TRILL_DELETE_ERROR_CHECK(_unit, _check, _rv) \ 31 BCMX_DELETE_ERROR_CHECK(_unit, _check, _rv) 32 33 #define BCMX_TRILL_GET_IS_VALID(_unit, _rv) \ 34 BCMX_ERROR_IS_VALID(_unit, _rv) 35 36 #define BCMX_TRILL_ERROR_IS_VALID(_unit, _rv) \ 37 BCMX_ERROR_IS_VALID(_unit, _rv) 38 39 40 #define BCMX_TRILL_PORT_T_PTR_TO_BCM(_trill_port) \ 41 ((bcm_trill_port_t *)(_trill_port)) 42 43 44 /* 45 * Function: 46 * bcmx_trill_port_t_init 47 * Purpose: 48 * Trill port structure initializer. 49 * Parameters: 50 * trill_port - (IN/OUT) TRILL port structure to initialize 51 * Returns: 52 * BCM_E_XXX 53 */ 54 void 55 bcmx_trill_port_t_init(bcmx_trill_port_t *trill_port) 56 { 57 if (trill_port != NULL) { 58 sal_memset(trill_port, 0, sizeof(*trill_port)); 59 } 60 } 61 62 /* 63 * Function: 64 * bcmx_trill_multicast_entry_t_init 65 * Purpose: 66 * Trill Multicast entry structure initializer. 67 * Parameters: 68 * trill_mc_entry - (IN/OUT) TRILL Multicast entry structure to initialize 69 * Returns: 70 * BCM_E_XXX 71 */ 72 void 73 bcmx_trill_multicast_entry_t_init(bcmx_trill_multicast_entry_t *trill_mc_entry) 74 { 75 if (trill_mc_entry != NULL) { 76 sal_memset(trill_mc_entry, 0, sizeof(*trill_mc_entry)); 77 } 78 } 79 80 /* 81 * Function: 82 * bcmx_trill_init 83 * Purpose: 84 * Initialize the TRILL module. 85 * Parameters: 86 * None 87 * Returns: 88 * BCM_E_XXX 89 */ 90 int 91 bcmx_trill_init(void) 92 { 93 int rv = BCM_E_UNAVAIL, tmp_rv; 94 int i, bcm_unit; 95 96 BCMX_TRILL_INIT_CHECK; 97 98 BCMX_UNIT_ITER(bcm_unit, i) { 99 tmp_rv = bcm_trill_init(bcm_unit); 100 BCM_IF_ERROR_RETURN(BCMX_TRILL_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 101 } 102 103 return rv; 104 } 105 106 /* 107 * Function: 108 * bcmx_trill_cleanup 109 * Purpose: 110 * Detach the TRILL module, clear all HW states. 111 * Parameters: 112 * None 113 * Returns: 114 * BCM_E_XXX 115 */ 116 int 117 bcmx_trill_cleanup(void) 118 { 119 int rv = BCM_E_UNAVAIL, tmp_rv; 120 int i, bcm_unit; 121 122 BCMX_TRILL_INIT_CHECK; 123 124 BCMX_UNIT_ITER(bcm_unit, i) { 125 tmp_rv = bcm_trill_cleanup(bcm_unit); 126 BCM_IF_ERROR_RETURN(BCMX_TRILL_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 127 } 128 129 return rv; 130 } 131 132 /* 133 * Function: 134 * bcmx_trill_port_add 135 * Purpose: 136 * Add TRILL port to TRILL Cloud. 137 * Parameters: 138 * trill_port - (IN/OUT) TRILL port information 139 * Returns: 140 * BCM_E_XXX 141 */ 142 int 143 bcmx_trill_port_add(bcmx_trill_port_t *trill_port) 144 { 145 int rv = BCM_E_UNAVAIL, tmp_rv; 146 int i, bcm_unit; 147 uint32 flags_orig; 148 149 BCMX_TRILL_INIT_CHECK; 150 151 BCMX_PARAM_NULL_CHECK(trill_port); 152 153 /* Store original 'xxx_WITH_ID' flag bit */ 154 flags_orig = trill_port->flags & BCM_TRILL_PORT_WITH_ID; 155 156 BCMX_UNIT_ITER(bcm_unit, i) { 157 tmp_rv = bcm_trill_port_add(bcm_unit, 158 BCMX_TRILL_PORT_T_PTR_TO_BCM(trill_port)); 159 if (BCM_FAILURE(BCMX_TRILL_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv))) { 160 break; 161 } 162 163 /* 164 * Use the ID from first successful 'create' if TRILL port ID 165 * is not specified. 166 */ 167 if (!(trill_port->flags & BCM_TRILL_PORT_WITH_ID)) { 168 if (BCM_SUCCESS(tmp_rv)) { 169 trill_port->flags |= BCM_TRILL_PORT_WITH_ID; 170 } 171 } 172 } 173 174 /* Restore 'xxx_WITH_ID' flag bit */ 175 trill_port->flags &= ~BCM_TRILL_PORT_WITH_ID; 176 trill_port->flags |= flags_orig; 177 178 179 return rv; 180 } 181 182 /* 183 * Function: 184 * bcmx_trill_port_delete 185 * Purpose: 186 * Delete TRILL port from TRILL Cloud. 187 * Parameters: 188 * trill_port_id - TRILL port ID 189 * Returns: 190 * BCM_E_XXX 191 */ 192 int 193 bcmx_trill_port_delete(bcm_gport_t trill_port_id) 194 { 195 int rv = BCM_E_UNAVAIL, tmp_rv; 196 int i, bcm_unit; 197 198 BCMX_TRILL_INIT_CHECK; 199 200 BCMX_UNIT_ITER(bcm_unit, i) { 201 tmp_rv = bcm_trill_port_delete(bcm_unit, trill_port_id); 202 BCM_IF_ERROR_RETURN 203 (BCMX_TRILL_DELETE_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 204 } 205 206 return rv; 207 } 208 209 /* 210 * Function: 211 * bcmx_trill_port_delete_all 212 * Purpose: 213 * Delete all TRILL ports from TRILL Cloud. 214 * Parameters: 215 * None 216 * Returns: 217 * BCM_E_XXX 218 */ 219 int 220 bcmx_trill_port_delete_all(void) 221 { 222 int rv = BCM_E_UNAVAIL, tmp_rv; 223 int i, bcm_unit; 224 225 BCMX_TRILL_INIT_CHECK; 226 227 BCMX_UNIT_ITER(bcm_unit, i) { 228 tmp_rv = bcm_trill_port_delete_all(bcm_unit); 229 BCM_IF_ERROR_RETURN 230 (BCMX_TRILL_DELETE_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 231 } 232 233 return rv; 234 } 235 236 /* 237 * Function: 238 * bcmx_trill_port_get 239 * Purpose: 240 * Get TRILL port information for given ID. 241 * Parameters: 242 * trill_port - (IN/OUT) TRILL port configuration info 243 * Returns: 244 * BCM_E_XXX 245 */ 246 int 247 bcmx_trill_port_get(bcmx_trill_port_t *trill_port) 248 { 249 int rv; 250 int i, bcm_unit; 251 252 BCMX_TRILL_INIT_CHECK; 253 254 BCMX_PARAM_NULL_CHECK(trill_port); 255 256 BCMX_UNIT_ITER(bcm_unit, i) { 257 rv = bcm_trill_port_get(bcm_unit, 258 BCMX_TRILL_PORT_T_PTR_TO_BCM(trill_port)); 259 if (BCMX_TRILL_GET_IS_VALID(bcm_unit, rv)) { 260 return rv; 261 } 262 } 263 264 return BCM_E_UNAVAIL; 265 } 266 267 /* 268 * Function: 269 * bcmx_trill_port_get_all 270 * Purpose: 271 * Get all TRILL ports from TRILL Cloud. 272 * Parameters: 273 * port_max - Maximum number of TRILL ports in array 274 * port_array - (OUT) Array of TRILL ports 275 * port_count - (OUT) Number of TRILL ports returned in array 276 * Returns: 277 * BCM_E_XXX 278 */ 279 int 280 bcmx_trill_port_get_all(int port_max, 281 bcmx_trill_port_t *port_array, int *port_count) 282 { 283 int rv; 284 int i, bcm_unit; 285 286 BCMX_TRILL_INIT_CHECK; 287 288 BCMX_PARAM_ARRAY_NULL_CHECK(port_max, port_array); 289 BCMX_PARAM_NULL_CHECK(port_count); 290 291 BCMX_UNIT_ITER(bcm_unit, i) { 292 rv = bcm_trill_port_get_all(bcm_unit, port_max, 293 BCMX_TRILL_PORT_T_PTR_TO_BCM(port_array), 294 port_count); 295 if (BCMX_TRILL_GET_IS_VALID(bcm_unit, rv)) { 296 return rv; 297 } 298 } 299 300 return BCM_E_UNAVAIL; 301 } 302 303 /* 304 * Function: 305 * bcmx_trill_multicast_entry_add 306 * Purpose: 307 * Add TRILL multicast entry. 308 * Parameters: 309 * trill_mc_entry - Trill Multicast Entry 310 * Returns: 311 * BCM_E_XXX 312 */ 313 int 314 bcmx_trill_multicast_entry_add(bcm_trill_multicast_entry_t *trill_mc_entry) 315 { 316 int rv = BCM_E_UNAVAIL, tmp_rv; 317 int i, bcm_unit; 318 319 BCMX_TRILL_INIT_CHECK; 320 321 BCMX_UNIT_ITER(bcm_unit, i) { 322 tmp_rv = bcm_trill_multicast_entry_add(bcm_unit, trill_mc_entry); 323 BCM_IF_ERROR_RETURN(BCMX_TRILL_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 324 } 325 326 return rv; 327 } 328 329 /* 330 * Function: 331 * bcmx_trill_multicast_delete 332 * Purpose: 333 * Delete TRILL multicast entry. 334 * Parameters: 335 * trill_mc_entry - Trill Multicast Entry 336 * Returns: 337 * BCM_E_XXX 338 */ 339 int 340 bcmx_trill_multicast_entry_delete(bcm_trill_multicast_entry_t *trill_mc_entry) 341 { 342 int rv = BCM_E_UNAVAIL, tmp_rv; 343 int i, bcm_unit; 344 345 BCMX_TRILL_INIT_CHECK; 346 347 BCMX_UNIT_ITER(bcm_unit, i) { 348 tmp_rv = bcm_trill_multicast_entry_delete(bcm_unit, trill_mc_entry); 349 BCM_IF_ERROR_RETURN 350 (BCMX_TRILL_DELETE_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 351 } 352 353 return rv; 354 } 355 356 /* 357 * Function: 358 * bcmx_trill_multicast_entry_get 359 * Purpose: 360 * Get TRILL multicast entry. 361 * Parameters: 362 * trill_mc_entry - Trill Multicast Entry 363 * Returns: 364 * BCM_E_XXX 365 */ 366 int 367 bcmx_trill_multicast_entry_get(bcm_trill_multicast_entry_t *trill_mc_entry) 368 { 369 int rv = BCM_E_UNAVAIL, tmp_rv; 370 int i, bcm_unit; 371 372 BCMX_TRILL_INIT_CHECK; 373 374 BCMX_UNIT_ITER(bcm_unit, i) { 375 tmp_rv = bcm_trill_multicast_entry_get(bcm_unit, trill_mc_entry); 376 BCM_IF_ERROR_RETURN 377 (BCMX_TRILL_DELETE_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 378 } 379 380 return rv; 381 } 382 383 /* 384 * Function: 385 * bcmx_trill_multicast_delete 386 * Purpose: 387 * Delete all TRILL multicast entries with given root name. 388 * Parameters: 389 * root_name - TRILL Root_RBridge 390 * Returns: 391 * BCM_E_XXX 392 */ 393 int 394 bcmx_trill_multicast_delete_all(bcm_trill_name_t root_name) 395 { 396 int rv = BCM_E_UNAVAIL, tmp_rv; 397 int i, bcm_unit; 398 399 BCMX_TRILL_INIT_CHECK; 400 401 BCMX_UNIT_ITER(bcm_unit, i) { 402 tmp_rv = bcm_trill_multicast_delete_all(bcm_unit, root_name); 403 BCM_IF_ERROR_RETURN 404 (BCMX_TRILL_DELETE_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 405 } 406 407 return rv; 408 } 409 410 /* 411 * Function: 412 * bcmx_trill_multicast_source_add 413 * Purpose: 414 * Add TRILL multicast RPF entry. 415 * Parameters: 416 * root_name - Trill Root_RBridge 417 * source_name - Source Rbridge 418 * port - Ingress port 419 * Returns: 420 * BCM_E_XXX 421 */ 422 int 423 bcmx_trill_multicast_source_add(bcm_trill_name_t root_name, 424 bcm_trill_name_t source_rbridge_name, 425 bcm_gport_t port, 426 bcm_if_t encap_intf) 427 { 428 int rv = BCM_E_UNAVAIL, tmp_rv; 429 int i, bcm_unit; 430 431 BCMX_TRILL_INIT_CHECK; 432 433 BCMX_UNIT_ITER(bcm_unit, i) { 434 tmp_rv = bcm_trill_multicast_source_add(bcm_unit, root_name, 435 source_rbridge_name, port, encap_intf); 436 BCM_IF_ERROR_RETURN(BCMX_TRILL_SET_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 437 } 438 439 return rv; 440 } 441 442 /* 443 * Function: 444 * bcmx_trill_multicast_source_delete 445 * Purpose: 446 * Delete TRILL multicast RPF entry. 447 * Parameters: 448 * root_name - Trill Root_RBridge 449 * source_name - Source Rbridge 450 * port - Ingress port 451 * Returns: 452 * BCM_E_XXX 453 */ 454 int 455 bcmx_trill_multicast_source_delete(bcm_trill_name_t root_name, 456 bcm_trill_name_t source_rbridge_name, 457 bcm_gport_t port, 458 bcm_if_t encap_intf) 459 { 460 int rv = BCM_E_UNAVAIL, tmp_rv; 461 int i, bcm_unit; 462 463 BCMX_TRILL_INIT_CHECK; 464 465 BCMX_UNIT_ITER(bcm_unit, i) { 466 tmp_rv = bcm_trill_multicast_source_delete(bcm_unit, root_name, 467 source_rbridge_name, port, encap_intf); 468 BCM_IF_ERROR_RETURN 469 (BCMX_TRILL_DELETE_ERROR_CHECK(bcm_unit, tmp_rv, &rv)); 470 } 471 472 return rv; 473 } 474 475 /* 476 * Function: 477 * bcmx_trill_multicast_source_get. 478 * Purpose: 479 * Get TRILL multicast RPF entry. 480 * Parameters: 481 * root_name - Trill Root_RBridge 482 * source_name - Source Rbridge 483 * port - (OUT) Ingress port 484 * Returns: 485 * BCM_E_XXX 486 */ 487 int 488 bcmx_trill_multicast_source_get(bcm_trill_name_t root_name, 489 bcm_trill_name_t source_rbridge_name, 490 bcm_gport_t *port) 491 { 492 int rv; 493 int i, bcm_unit; 494 495 BCMX_TRILL_INIT_CHECK; 496 497 BCMX_PARAM_NULL_CHECK(port); 498 499 BCMX_UNIT_ITER(bcm_unit, i) { 500 rv = bcm_trill_multicast_source_get(bcm_unit, root_name, 501 source_rbridge_name, port); 502 if (BCMX_TRILL_GET_IS_VALID(bcm_unit, rv)) { 503 return rv; 504 } 505 } 506 507 return BCM_E_UNAVAIL; 508 } 509 510 /* 511 * Function: 512 * bcmx_trill_stat_get/get32 513 * Purpose: 514 * Get TRILL Stats. 515 * Parameters: 516 * port - Port 517 * stat - Specify the Stat type 518 * val - (OUT) 64-bit/32-bit Stats value 519 * Returns: 520 * BCM_E_XXX 521 */ 522 int 523 bcmx_trill_stat_get(bcm_gport_t port, bcm_trill_stat_t stat, uint64 *val) 524 { 525 int bcm_unit; 526 bcm_port_t bcm_port; 527 528 BCMX_TRILL_INIT_CHECK; 529 530 BCMX_PARAM_NULL_CHECK(val); 531 532 BCM_IF_ERROR_RETURN 533 (_bcmx_dest_to_unit_port(port, &bcm_unit, &bcm_port, 534 BCMX_DEST_CONVERT_DEFAULT)); 535 536 return bcm_trill_stat_get(bcm_unit, bcm_port, stat, val); 537 } 538 539 int 540 bcmx_trill_stat_get32(bcm_gport_t port, bcm_trill_stat_t stat, uint32 *val) 541 { 542 int bcm_unit; 543 bcm_port_t bcm_port; 544 545 BCMX_TRILL_INIT_CHECK; 546 547 BCMX_PARAM_NULL_CHECK(val); 548 549 BCM_IF_ERROR_RETURN 550 (_bcmx_dest_to_unit_port(port, &bcm_unit, &bcm_port, 551 BCMX_DEST_CONVERT_DEFAULT)); 552 553 return bcm_trill_stat_get32(bcm_unit, bcm_port, stat, val); 554 } 555 556 /* 557 * Function: 558 * bcmx_trill_stat_clear 559 * Purpose: 560 * Clear TRILL Stats. 561 * Parameters: 562 * port - Port 563 * stat - Specify the Stat type 564 * Returns: 565 * BCM_E_XXX 566 */ 567 int 568 bcmx_trill_stat_clear(bcm_gport_t port, bcm_trill_stat_t stat) 569 { 570 int bcm_unit; 571 bcm_port_t bcm_port; 572 573 BCMX_TRILL_INIT_CHECK; 574 575 BCM_IF_ERROR_RETURN 576 (_bcmx_dest_to_unit_port(port, &bcm_unit, &bcm_port, 577 BCMX_DEST_CONVERT_DEFAULT)); 578 579 return bcm_trill_stat_clear(bcm_unit, bcm_port, stat); 580 } 581 582 #endif /* INCLUDE_L3 */