eav.c (20590B)
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 * Ethernet AV related CLI commands 8 */ 9 10 #include <sal/core/libc.h> 11 #include <sal/types.h> 12 #include <sal/appl/sal.h> 13 #include <sal/appl/io.h> 14 #include <sal/core/libc.h> 15 #include <shared/bsl.h> 16 #include <soc/cm.h> 17 #include <soc/drv.h> 18 19 #include <bcm/types.h> 20 #include <bcm/rx.h> 21 #include <bcm_int/esw/rx.h> 22 #include <bcm/error.h> 23 #include <bcm/eav.h> 24 25 #include <appl/diag/shell.h> 26 #include <appl/diag/system.h> 27 28 29 /* 30 * Macro: 31 * EAV_GET_NUMB 32 * Purpose: 33 * Get a numerical value from stdin. 34 */ 35 #define EAV_GET_NUMB(numb, str, args) \ 36 if (((str) = ARG_GET(args)) == NULL) { \ 37 return CMD_USAGE; \ 38 } \ 39 (numb) = parse_integer(str); 40 41 /* 42 * Macro: 43 * EAV_GET_PORT 44 * Purpose: 45 * Get a numerical value from stdin. 46 */ 47 #define EAV_GET_PORT(_unit, _port, _str, _args) \ 48 if (((_str) = ARG_GET(_args)) == NULL) { \ 49 return CMD_USAGE; \ 50 } \ 51 if (parse_bcm_port((_unit), (_str), &(_port)) < 0) { \ 52 cli_out(\ 53 "ERROR: invalid port string: \"%s\"\n", (_str)); \ 54 return CMD_FAIL; \ 55 } 56 57 static bcm_mac_t eav_ts_mac = {0,0,0,0,0,0}; 58 static bcm_mac_t station_mac = {0,0x10,0x18,0x53,0x31,0x40}; 59 static bcm_pkt_t pkt; 60 61 /* 62 * Function: 63 * Purpose: 64 * Parmameters: 65 * Returns: 66 */ 67 STATIC int 68 eav_types(int unit) 69 { 70 cli_out("Control Type :\n"); 71 cli_out(" 0 : Time Reference. p0 : time reference value(read only).\n"); 72 cli_out(" 1 : Time Adjust. p0 : adjust mode.\n"); 73 cli_out(" p1 : Operation attributes).\n"); 74 cli_out("\n"); 75 cli_out("Stream Class Type :\n"); 76 cli_out(" 0 : Class A traffic stream\n"); 77 cli_out(" 1 : Class B traffic stream\n"); 78 cli_out("\n"); 79 80 return CMD_OK; 81 } 82 83 STATIC bcm_rx_t 84 eav_cb_handler(int unit, bcm_pkt_t *info, void *cookie) 85 { 86 bcm_rx_t rv = BCM_RX_NOT_HANDLED; 87 uint8 *pkt_data = BCM_PKT_DMAC(info); 88 89 /* Received Time Sync Packets */ 90 if (BCM_RX_REASON_GET(info->rx_reasons, bcmRxReasonTimeSync)) { 91 cli_out("[EAV watch] Time Sync packets from port %d, timestamp: 0x%08x\n", info->rx_port, info->rx_timestamp); 92 /* Check if DA is Time Sync MAC DA */ 93 if (sal_memcmp(eav_ts_mac, pkt_data, 6)) { 94 cli_out("[EAV watch] NOT matched MACDA.\n"); 95 } 96 rv = BCM_RX_HANDLED; 97 } else if (BCM_RX_REASON_GET(info->rx_reasons, bcmRxReasonEAVData)) { 98 cli_out("[EAV watch] EAV Data packets from port %d, priority %d.\n", 99 info->rx_port, info->prio_int); 100 rv = BCM_RX_HANDLED; 101 } 102 return rv; 103 } 104 105 /* 106 * Function: 107 * Purpose: 108 * Parmameters: 109 * Returns: 110 */ 111 STATIC int 112 eav_watch(int unit, args_t *args) 113 { 114 char* subcmd = NULL; 115 int rv; 116 117 if ((subcmd = ARG_GET(args)) == NULL) { 118 return CMD_USAGE; 119 } 120 121 if(!sal_strcasecmp(subcmd, "start")) { 122 /* Register to accept all cos */ 123 if ((rv = bcm_rx_start(unit, NULL)) < 0) { 124 cli_out("%s: bcm_rx_start failed: %s\n", 125 ARG_CMD(args), bcm_errmsg(rv)); 126 return CMD_FAIL; 127 } 128 if ((rv = bcm_rx_register(unit, "EAV", eav_cb_handler, 129 101, NULL, BCM_RCO_F_ALL_COS)) < 0) { 130 cli_out("%s: bcm_rx_register failed: %s\n", 131 ARG_CMD(args), bcm_errmsg(rv)); 132 return CMD_FAIL; 133 } 134 } 135 136 if(!sal_strcasecmp(subcmd, "stop")) { 137 if ((rv = bcm_rx_stop(unit, NULL)) < 0) { 138 cli_out("%s: bcm_rx_stop failed: %s\n", 139 ARG_CMD(args), bcm_errmsg(rv)); 140 return CMD_FAIL; 141 } 142 if ((rv = bcm_rx_unregister(unit, eav_cb_handler, 101)) < 0) { 143 cli_out("%s: bcm_rx_unregister failed: %s\n", 144 ARG_CMD(args), bcm_errmsg(rv)); 145 return CMD_FAIL; 146 } 147 } 148 149 return CMD_OK; 150 } 151 152 153 /* 154 * Function: 155 * Purpose: 156 * Parmameters: 157 * Returns: 158 */ 159 STATIC int 160 eav_init(int unit) 161 { 162 cli_out("Ethernet AV init.\n"); 163 164 /* 1. Perform Eav initialization*/ 165 bcm_eav_init(unit); 166 167 /* 2. Get the timesync MACDA and EtherType */ 168 bcm_eav_timesync_mac_get(unit, eav_ts_mac); 169 170 return CMD_OK; 171 } 172 173 /* 174 * Function: 175 * Purpose: 176 * Parmameters: 177 * Returns: 178 */ 179 STATIC int 180 eav_control_set(int unit, args_t *args) 181 { 182 char* subcmd = NULL; 183 uint32 control_type, param0, param1; 184 int rv = BCM_E_NONE; 185 186 EAV_GET_NUMB(control_type, subcmd, args); 187 EAV_GET_NUMB(param0, subcmd, args); 188 189 switch (control_type) { 190 case 1: 191 EAV_GET_NUMB(param1, subcmd, args); 192 rv = bcm_eav_control_set(unit, bcmEAVControlTimeAdjust, param0, param1); 193 break; 194 default: 195 return CMD_USAGE; 196 } 197 if (rv < 0) { 198 cli_out("eav control set : failed with control type = %d, parameter0 = %d\n", 199 control_type, param0); 200 return CMD_FAIL; 201 } 202 203 return CMD_OK; 204 } 205 206 /* 207 * Function: 208 * Purpose: 209 * Parmameters: 210 * Returns: 211 */ 212 STATIC int 213 eav_control_get(int unit, args_t *args) 214 { 215 char* subcmd = NULL; 216 uint32 control_type, param0, param1; 217 int rv = BCM_E_NONE; 218 219 EAV_GET_NUMB(control_type, subcmd, args); 220 221 switch (control_type) { 222 case 0: 223 rv = bcm_eav_control_get(unit, bcmEAVControlTimeBase, ¶m0, ¶m1); 224 if (rv == BCM_E_NONE) { 225 cli_out("Time Reference = 0x%x\n", param0); 226 } 227 break; 228 case 1: 229 rv = bcm_eav_control_get(unit, bcmEAVControlTimeAdjust, ¶m0, ¶m1); 230 if (rv == BCM_E_NONE) { 231 cli_out("Time Reference mode = 0x%x, Operation Attributes= 0x%x\n", 232 param0, param1); 233 } 234 break; 235 default: 236 return CMD_USAGE; 237 } 238 if (rv < 0) { 239 cli_out("eav control get : failed with control type = %d\n", 240 control_type); 241 return CMD_FAIL; 242 } 243 244 return CMD_OK; 245 } 246 247 248 /* 249 * Function: 250 * Purpose: 251 * Parmameters: 252 * Returns: 253 */ 254 STATIC int 255 eav_control(int unit, args_t *args) 256 { 257 char* subcmd = NULL; 258 259 if ((subcmd = ARG_GET(args)) == NULL) { 260 return CMD_USAGE; 261 } 262 263 if(!sal_strcasecmp(subcmd, "set")) { 264 return eav_control_set(unit, args); 265 } 266 267 if(!sal_strcasecmp(subcmd, "get")) { 268 return eav_control_get(unit, args); 269 } 270 271 return CMD_USAGE; 272 } 273 274 /* 275 * Function: 276 * Purpose: 277 * Parmameters: 278 * Returns: 279 */ 280 STATIC int 281 eav_mac_set(int unit, args_t *args) 282 { 283 char* subcmd = NULL; 284 int rv = BCM_E_NONE; 285 bcm_mac_t eav_mac; 286 287 if ((subcmd = ARG_GET(args)) == NULL) { 288 return CMD_USAGE; 289 } 290 291 if ((rv = parse_macaddr(subcmd, eav_mac)) < 0) { 292 cli_out("ERROR: invalid mac string: \"%s\" (error=%d)\n", subcmd, rv); 293 return CMD_FAIL; 294 } 295 296 rv = bcm_eav_timesync_mac_set(unit, eav_mac); 297 298 if (rv == BCM_E_NONE) { 299 sal_memcpy(eav_ts_mac, eav_mac, 6); 300 cli_out("Set Time Sync MACDA = %02x-%02x-", 301 eav_mac[0], eav_mac[1]); 302 cli_out("%02x-%02x-%02x-%02x\n", 303 eav_mac[2], eav_mac[3], 304 eav_mac[4], eav_mac[5]); 305 } else { 306 cli_out("Fail to set Time Sync MACDA!\n"); 307 return CMD_FAIL; 308 } 309 310 return CMD_OK; 311 } 312 313 /* 314 * Function: 315 * Purpose: 316 * Parmameters: 317 * Returns: 318 */ 319 STATIC int 320 eav_mac_get(int unit, args_t *args) 321 { 322 323 cli_out("Get Time Sync MACDA = %02x-%02x-%02x-", 324 eav_ts_mac[0], eav_ts_mac[1], eav_ts_mac[2]); 325 cli_out("%02x-%02x-%02x\n", 326 eav_ts_mac[3], eav_ts_mac[4], eav_ts_mac[5]); 327 328 return CMD_OK; 329 } 330 331 /* 332 * Function: 333 * Purpose: 334 * Parmameters: 335 * Returns: 336 */ 337 STATIC int 338 eav_mac(int unit, args_t *args) 339 { 340 char* subcmd = NULL; 341 342 if ((subcmd = ARG_GET(args)) == NULL) { 343 return CMD_USAGE; 344 } 345 346 if(!sal_strcasecmp(subcmd, "set")) { 347 return eav_mac_set(unit, args); 348 } 349 350 if(!sal_strcasecmp(subcmd, "get")) { 351 return eav_mac_get(unit, args); 352 } 353 354 return CMD_USAGE; 355 } 356 357 358 /* 359 * Function: 360 * Purpose: 361 * Parmameters: 362 * Returns: 363 */ 364 STATIC int 365 eav_port(int unit, args_t *args) 366 { 367 char* subcmd = NULL; 368 bcm_port_t data_port; 369 370 if ((subcmd = ARG_GET(args)) == NULL) { 371 return CMD_USAGE; 372 } 373 374 if(!sal_strcasecmp(subcmd, "enable")) { 375 EAV_GET_PORT(unit, data_port, subcmd, args); 376 bcm_eav_port_enable_set(unit, data_port, 1); 377 cli_out("Port %d is AV enabled\n", data_port); 378 } 379 380 if(!sal_strcasecmp(subcmd, "disable")) { 381 EAV_GET_PORT(unit, data_port, subcmd, args); 382 bcm_eav_port_enable_set(unit, data_port, 0); 383 cli_out("Port %d is AV disabled\n", data_port); 384 } 385 386 return CMD_OK; 387 } 388 /* 389 * Function: 390 * Purpose: 391 * Parmameters: 392 * Returns: 393 */ 394 STATIC int 395 eav_status(int unit, args_t *args) 396 { 397 bcm_port_config_t pcfg; 398 bcm_port_t port; 399 int enable; 400 uint32 temp, temp2; 401 int rv = BCM_E_NONE; 402 403 if (bcm_port_config_get(unit, &pcfg) != BCM_E_NONE) { 404 cli_out("%s: Error: bcm ports not initialized\n", ARG_CMD(args)); 405 return CMD_FAIL; 406 } 407 408 cli_out("Ethernet AV Status :\n"); 409 /* Per port AV enable */ 410 BCM_PBMP_ITER(pcfg.ge, port) { 411 bcm_eav_port_enable_get(unit, port, &enable); 412 if (enable) { 413 cli_out("Port %d is EAV enabled.\n", port); 414 /* Class A bandwidth */ 415 rv = bcm_eav_bandwidth_get(unit, port, bcmEAVCStreamClassA, &temp, &temp2); 416 if (rv == BCM_E_NONE) { 417 cli_out(" Class A bandwidth = %d bytes/sec burst = %d bytes\n", 418 temp, temp2); 419 } 420 421 /* Class B bandwidth */ 422 rv = bcm_eav_bandwidth_get(unit, port, bcmEAVCStreamClassB, &temp, &temp2); 423 if (rv == BCM_E_NONE) { 424 cli_out(" Class B bandwidth = %d bytes/sec burst = %d bytes\n", 425 temp, temp2); 426 } 427 } else { 428 cli_out("Port %d is EAV disabled.\n", port); 429 } 430 } 431 432 /* Time Adjust */ 433 rv = bcm_eav_control_get(unit, bcmEAVControlTimeAdjust, 434 &temp, &temp2); 435 if (rv == BCM_E_NONE) { 436 cli_out(" Time Reference mode = 0x%x, Attributes = 0x%x.\n", 437 temp, temp2); 438 } 439 440 cli_out("Time Sync MAC Address = %02x-%02x-%02x-", 441 eav_ts_mac[0], eav_ts_mac[1], eav_ts_mac[2]); 442 cli_out("%02x-%02x-%02x\n", 443 eav_ts_mac[3], eav_ts_mac[4], eav_ts_mac[5]); 444 445 return CMD_OK; 446 } 447 448 449 /* 450 * Function: 451 * Purpose: 452 * Read back the timestamp value of last egressed TS packets of the port. 453 * Parmameters: 454 * Returns: 455 */ 456 STATIC int 457 eav_timestamp(int unit, args_t *args) 458 { 459 char* subcmd = NULL; 460 bcm_port_t data_port; 461 uint32 timestamp; 462 int rv = BCM_E_NONE; 463 464 EAV_GET_PORT(unit, data_port, subcmd, args); 465 466 rv = bcm_eav_timestamp_get(unit, data_port, ×tamp); 467 468 if (rv == BCM_E_NONE) { 469 cli_out("Port %d Egress Time Stamp = 0x%x\n", 470 data_port, timestamp); 471 } else { 472 cli_out("Get Port %d Egress Time Stamp failed!\n", data_port); 473 } 474 475 return CMD_OK; 476 } 477 478 /* 479 * Function: 480 * Purpose: 481 * Transmit one Sync message Time-Sync packet with flag BCM_PKT_F_TIMESYNC 482 * enabled to check if egress timestamp could be genenrated. 483 * Parmameters: 484 * Returns: 485 */ 486 STATIC int 487 eav_tx(int unit, args_t *args) 488 { 489 char* subcmd = NULL; 490 bcm_port_t port; 491 enet_hdr_t *ep = NULL; 492 uint32 vlan = 0; 493 int rv = 0; 494 pbmp_t tx_pbmp, tx_upbmp; 495 496 EAV_GET_PORT(unit, port, subcmd, args); 497 EAV_GET_NUMB(vlan, subcmd, args); 498 499 _SHR_PBMP_PORT_SET(tx_pbmp, port); 500 _SHR_PBMP_CLEAR(tx_upbmp); 501 502 /* alloc packet body */ 503 pkt.alloc_ptr = (uint8 *)soc_cm_salloc(unit, 64, "TX"); 504 if (pkt.alloc_ptr == NULL) { 505 cli_out("WARNING: Could not alloc tx buffer. Memory error.\n"); 506 return CMD_FAIL; 507 } else { 508 pkt._pkt_data.data = pkt.alloc_ptr; 509 pkt.pkt_data = &pkt._pkt_data; 510 pkt.blk_count = 1; 511 pkt._pkt_data.len = 64; 512 } 513 /* packet re-init, assume MessageType zero, Sync message */ 514 sal_memset(pkt.pkt_data[0].data, 0, pkt.pkt_data[0].len); 515 ep = (enet_hdr_t *)(pkt.pkt_data[0].data); 516 /* setup the packet */ 517 pkt.flags &= ~BCM_TX_CRC_FLD; 518 pkt.flags |= BCM_TX_CRC_REGEN; 519 pkt.flags |= BCM_PKT_F_TIMESYNC; 520 521 /* always tagged with priority 5 */ 522 { 523 ep->en_tag_tpid = bcm_htons(0x8100); 524 ep->en_tag_ctrl = bcm_htons(VLAN_CTRL(5, 0, vlan)); 525 ep->en_tag_len = bcm_htons(0x88F7); 526 } 527 /* assign pbmp */ 528 sal_memcpy((uint8 *)&pkt.tx_pbmp, (uint8 *)&tx_pbmp, sizeof(bcm_pbmp_t)); 529 sal_memcpy((uint8 *)&pkt.tx_upbmp, (uint8 *)&tx_upbmp, sizeof(bcm_pbmp_t)); 530 /* assign mac addr */ 531 ENET_SET_MACADDR(ep->en_dhost, eav_ts_mac); 532 ENET_SET_MACADDR(ep->en_shost, station_mac); 533 534 if ((rv = bcm_tx(unit, &pkt, NULL)) != BCM_E_NONE) { 535 soc_cm_sfree(unit, pkt.alloc_ptr); 536 LOG_ERROR(BSL_LS_SOC_COMMON, 537 (BSL_META_U(unit, 538 "bcm_tx failed: Unit %d: %s\n"), 539 unit, bcm_errmsg(rv))); 540 } 541 542 return CMD_OK; 543 } 544 545 /* 546 * Function: 547 * Purpose: 548 * Parmameters: 549 * Returns: 550 */ 551 STATIC int 552 eav_srp_set(int unit, args_t *args) 553 { 554 char* subcmd = NULL; 555 uint32 param; 556 int rv = BCM_E_NONE; 557 558 bcm_mac_t srp_mac; 559 560 if ((subcmd = ARG_GET(args)) == NULL) { 561 return CMD_USAGE; 562 } 563 564 if ((rv = parse_macaddr(subcmd, srp_mac)) < 0) { 565 cli_out("ERROR: invalid mac string: \"%s\" (error=%d)\n", subcmd, rv); 566 return CMD_FAIL; 567 } 568 569 EAV_GET_NUMB(param, subcmd, args); 570 571 rv = bcm_eav_srp_mac_ethertype_set(unit, srp_mac, (uint16)param); 572 if (rv < 0) { 573 cli_out("bcm_eav_srp_mac_ethertype_set : failed with mac = %02x:%02x:%02x:%02x:%02x:%02x, parameter = 0x%x\n", 574 srp_mac[0], srp_mac[1], srp_mac[2], srp_mac[3], srp_mac[4], srp_mac[5], param); 575 return CMD_FAIL; 576 } 577 578 return CMD_OK; 579 } 580 581 /* 582 * Function: 583 * Purpose: 584 * Parmameters: 585 * Returns: 586 */ 587 STATIC int 588 eav_srp_get(int unit, args_t *args) 589 { 590 uint16 param; 591 int rv = BCM_E_NONE; 592 bcm_mac_t srp_mac; 593 594 rv = bcm_eav_srp_mac_ethertype_get(unit, srp_mac, ¶m); 595 if (rv < 0) { 596 cli_out("bcm_eav_srp_mac_ethertype_get : failed %s\n", bcm_errmsg(rv)); 597 return CMD_FAIL; 598 } 599 cli_out("SRP: MAC = %02x:%02x:%02x:%02x:%02x:%02x, Ethertype = 0x%x\n", 600 srp_mac[0], srp_mac[1], srp_mac[2], srp_mac[3], srp_mac[4], srp_mac[5], param); 601 return CMD_OK; 602 } 603 604 /* 605 * Function: 606 * Purpose: 607 * Parmameters: 608 * Returns: 609 */ 610 STATIC int 611 eav_srp(int unit, args_t *args) 612 { 613 char* subcmd = NULL; 614 615 if ((subcmd = ARG_GET(args)) == NULL) { 616 return CMD_USAGE; 617 } 618 619 if(!sal_strcasecmp(subcmd, "set")) { 620 return eav_srp_set(unit, args); 621 } 622 623 if(!sal_strcasecmp(subcmd, "get")) { 624 return eav_srp_get(unit, args); 625 } 626 627 return CMD_USAGE; 628 } 629 /* 630 * Function: 631 * Purpose: 632 * Parmameters: 633 * Returns: 634 */ 635 STATIC int 636 eav_pcp_set(int unit, args_t *args) 637 { 638 char* subcmd = NULL; 639 uint32 streamclass, pcp, remapped_pcp; 640 int rv = BCM_E_NONE; 641 642 EAV_GET_NUMB(streamclass, subcmd, args); 643 EAV_GET_NUMB(pcp, subcmd, args); 644 EAV_GET_NUMB(remapped_pcp, subcmd, args); 645 646 rv = bcm_eav_pcp_mapping_set(unit, (int)streamclass, (int)pcp, (int)remapped_pcp); 647 if (rv < 0) { 648 cli_out("bcm_eav_pcp_mapping_set : failed %s\n", bcm_errmsg(rv)); 649 return CMD_FAIL; 650 } 651 652 return CMD_OK; 653 } 654 655 /* 656 * Function: 657 * Purpose: 658 * Parmameters: 659 * Returns: 660 */ 661 STATIC int 662 eav_pcp_get(int unit, args_t *args) 663 { 664 char* subcmd = NULL; 665 uint32 streamclass; 666 int pcp, remapped_pcp; 667 int rv = BCM_E_NONE; 668 669 EAV_GET_NUMB(streamclass, subcmd, args); 670 rv = bcm_eav_pcp_mapping_get(unit, (int)streamclass, &pcp, &remapped_pcp); 671 if (rv < 0) { 672 cli_out("bcm_eav_pcp_mapping_get : failed %s\n", bcm_errmsg(rv)); 673 return CMD_FAIL; 674 } 675 676 cli_out("EAV Class %s: PCP = %d, Remapped PCP = %d\n", 677 (streamclass == 0)?"A":"B", pcp, remapped_pcp); 678 679 return CMD_OK; 680 } 681 682 /* 683 * Function: 684 * Purpose: 685 * Parmameters: 686 * Returns: 687 */ 688 STATIC int 689 eav_pcp(int unit, args_t *args) 690 { 691 char* subcmd = NULL; 692 693 if ((subcmd = ARG_GET(args)) == NULL) { 694 return CMD_USAGE; 695 } 696 697 if(!sal_strcasecmp(subcmd, "set")) { 698 return eav_pcp_set(unit, args); 699 } 700 701 if(!sal_strcasecmp(subcmd, "get")) { 702 return eav_pcp_get(unit, args); 703 } 704 705 return CMD_USAGE; 706 } 707 708 /* 709 * Function: 710 * Purpose: 711 * Parmameters: 712 * Returns: 713 */ 714 STATIC int 715 eav_bandwidth_set(int unit, args_t *args) 716 { 717 char* subcmd = NULL; 718 uint32 streamclass, bw, burst; 719 bcm_port_t data_port; 720 int rv = BCM_E_NONE; 721 722 EAV_GET_PORT(unit, data_port, subcmd, args); 723 EAV_GET_NUMB(streamclass, subcmd, args); 724 EAV_GET_NUMB(bw, subcmd, args); 725 EAV_GET_NUMB(burst, subcmd, args); 726 727 rv = bcm_eav_bandwidth_set(unit, data_port, (int)streamclass, bw, burst); 728 if (rv < 0) { 729 cli_out("bcm_eav_bandwidth_set : failed %s\n", bcm_errmsg(rv)); 730 return CMD_FAIL; 731 } 732 733 return CMD_OK; 734 } 735 736 /* 737 * Function: 738 * Purpose: 739 * Parmameters: 740 * Returns: 741 */ 742 STATIC int 743 eav_bandwidth_get(int unit, args_t *args) 744 { 745 char* subcmd = NULL; 746 uint32 streamclass, bw, burst; 747 bcm_port_t data_port; 748 int rv = BCM_E_NONE; 749 750 EAV_GET_PORT(unit, data_port, subcmd, args); 751 EAV_GET_NUMB(streamclass, subcmd, args); 752 753 rv = bcm_eav_bandwidth_get(unit, data_port, (int)streamclass, &bw, &burst); 754 if (rv < 0) { 755 cli_out("bcm_eav_bandwidth_get : failed %s\n", bcm_errmsg(rv)); 756 return CMD_FAIL; 757 } 758 759 cli_out("Port %d (Class %s): Bandwidth = %d bytes/sec, Burst = %d bytes\n", 760 data_port, (streamclass == 0)?"A":"B", bw, burst); 761 762 return CMD_OK; 763 } 764 765 /* 766 * Function: 767 * Purpose: 768 * Parmameters: 769 * Returns: 770 */ 771 STATIC int 772 eav_bandwidth(int unit, args_t *args) 773 { 774 char* subcmd = NULL; 775 776 if ((subcmd = ARG_GET(args)) == NULL) { 777 return CMD_USAGE; 778 } 779 780 if(!sal_strcasecmp(subcmd, "set")) { 781 return eav_bandwidth_set(unit, args); 782 } 783 784 if(!sal_strcasecmp(subcmd, "get")) { 785 return eav_bandwidth_get(unit, args); 786 } 787 788 return CMD_USAGE; 789 } 790 791 /* 792 * Function: 793 * cmd_esw_eav 794 * Purpose: 795 * Set/Display the Ethernet AV characteristics. 796 * Parameters: 797 * unit - SOC unit # 798 * args - pointer to command line arguments 799 * Returns: 800 * CMD_OK 801 */ 802 803 cmd_result_t 804 cmd_esw_eav(int unit, args_t *args) 805 { 806 char *subcmd = NULL; 807 808 if ((subcmd = ARG_GET(args)) == NULL) { 809 return CMD_USAGE; 810 } 811 812 if(!sal_strcasecmp(subcmd, "control")) { 813 return eav_control(unit, args); 814 } 815 816 if(!sal_strcasecmp(subcmd, "mac")) { 817 return eav_mac(unit, args); 818 } 819 820 if(!sal_strcasecmp(subcmd, "types")) { 821 return eav_types(unit); 822 } 823 824 if(!sal_strcasecmp(subcmd, "init")) { 825 return eav_init(unit); 826 } 827 828 if(!sal_strcasecmp(subcmd, "port")) { 829 return eav_port(unit, args); 830 } 831 832 if(!sal_strcasecmp(subcmd, "watch")) { 833 return eav_watch(unit, args); 834 } 835 836 if(!sal_strcasecmp(subcmd, "status")) { 837 return eav_status(unit, args); 838 } 839 840 if(!sal_strcasecmp(subcmd, "timestamp")) { 841 return eav_timestamp(unit, args); 842 } 843 844 if(!sal_strcasecmp(subcmd, "tx")) { 845 return eav_tx(unit, args); 846 } 847 848 if(!sal_strcasecmp(subcmd, "srp")) { 849 return eav_srp(unit, args); 850 } 851 852 if(!sal_strcasecmp(subcmd, "pcp")) { 853 return eav_pcp(unit, args); 854 } 855 856 if(!sal_strcasecmp(subcmd, "bandwidth")) { 857 return eav_bandwidth(unit, args); 858 } 859 860 return CMD_USAGE; 861 } 862 863