stk.c (20656B)
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 * Stacking CLI commands 8 */ 9 10 #include <appl/diag/shell.h> 11 #include <appl/diag/system.h> 12 #include <appl/diag/parse.h> 13 #include <appl/diag/dport.h> 14 #include <shared/bsl.h> 15 #include <bcm/vlan.h> 16 #include <bcm/stack.h> 17 #include <bcm/error.h> 18 19 STATIC void 20 _report_flags(int unit, int port, uint32 flags) { 21 if (port > 0) { 22 cli_out("Stack flags for unit %d, port %d: (0x%x)\n", unit, 23 port, flags); 24 } else { 25 cli_out("Stack flags for unit %d: (0x%x)\n", unit, flags); 26 } 27 if (flags & (BCM_STK_CAPABLE | BCM_STK_ENABLE | BCM_STK_INACTIVE | 28 BCM_STK_SIMPLEX | BCM_STK_DUPLEX)) { 29 cli_out(" %s%s%s%s%s\n", 30 flags & BCM_STK_CAPABLE ? "capable " : "", 31 flags & BCM_STK_ENABLE ? "enable " : "", 32 flags & BCM_STK_INACTIVE ? "inactive " : "", 33 flags & BCM_STK_SIMPLEX ? "simplex " : "", 34 flags & BCM_STK_DUPLEX ? "duplex " : ""); 35 } 36 if (flags & (BCM_STK_NONE | BCM_STK_SL | BCM_STK_HG | 37 BCM_STK_INTERNAL | BCM_STK_NO_LINK)) { 38 cli_out(" %s%s%s%s%s\n", 39 flags & BCM_STK_NONE ? "none " : "", 40 flags & BCM_STK_SL ? "sl " : "", 41 flags & BCM_STK_HG ? "hg " : "", 42 flags & BCM_STK_INTERNAL ? "internal " : "", 43 flags & BCM_STK_NO_LINK ? "no_link " : ""); 44 } 45 } 46 47 char cmd_stk_mode_usage[] = 48 "\nSTACKMode [Unit=<n>] [SL=<T|F>] [HG=<T|F>] [NONE=<T|F>]\n" 49 " Set/get stack mode. Without SL/HG/NONE, gets the current mode.\n" 50 " With SL or HG or NONE, sets the current mode.\n" 51 " Note: Only SL=T is really supported currently\n"; 52 53 cmd_result_t 54 cmd_stk_mode(int unit, args_t *args) 55 { 56 parse_table_t pt; 57 int rv; 58 int stk_unit = unit; 59 int none = -1, 60 sl = -1, 61 hg = -1; 62 uint32 flags = 0; 63 64 parse_table_init(unit, &pt); 65 parse_table_add(&pt, "Unit", PQ_DFL|PQ_INT, 66 INT_TO_PTR(unit), &stk_unit, 0); 67 parse_table_add(&pt, "SL", PQ_DFL|PQ_BOOL, 0, &sl, 0); 68 parse_table_add(&pt, "HG", PQ_DFL|PQ_BOOL, 0, &hg, 0); 69 parse_table_add(&pt, "NONE", PQ_DFL|PQ_BOOL, 0, &none, 0); 70 if (parse_arg_eq(args, &pt) < 0) { 71 parse_arg_eq_done(&pt); 72 return CMD_USAGE; 73 } 74 parse_arg_eq_done(&pt); 75 if ((none < 0) && (sl < 0) && (hg < 0)) { /* Get */ 76 rv = bcm_stk_mode_get(stk_unit, &flags); 77 if (rv < 0) { 78 cli_out("ERROR: bcm_stk_mode_get returns %s\n", bcm_errmsg(rv)); 79 return CMD_FAIL; 80 } 81 _report_flags(stk_unit, -1, flags); 82 } else { 83 flags |= (none > 0) ? BCM_STK_NONE : 0; 84 flags |= (sl > 0) ? BCM_STK_SL : 0; 85 flags |= (hg > 0) ? BCM_STK_HG : 0; 86 87 rv = bcm_stk_mode_set(stk_unit, flags); 88 if (rv < 0) { 89 cli_out("ERROR: bcm_stk_mode_set returns: %s\n", bcm_errmsg(rv)); 90 cli_out(" Unit %d. Flags: 0x%x\n", stk_unit, flags); 91 return CMD_FAIL; 92 } 93 } 94 95 return CMD_OK; 96 } 97 98 /* Expose bcm_stk_port_set/get */ 99 100 char cmd_stk_port_set_usage[] = 101 "\nStackPortSet Port=<n> [Unit=<n>] [Capable=<T|F>] [Enable=<T|F>]\n" 102 " [Inactive=<T|F>] [Simplex=<T|F>] [Duplex=<T|F>] [Internal=<T|F>]\n" 103 " Add a stack port to the system with the indicated flags\n"; 104 105 cmd_result_t 106 cmd_stk_port_set(int unit, args_t *args) 107 { 108 parse_table_t pt; 109 int rv; 110 int stk_unit = unit; 111 int stk_port = -1; /* This is intentionally a port */ 112 int capable = 0, 113 enable = 1, 114 inactive = 0, 115 simplex = 0, 116 internal = 0, 117 duplex = 0; 118 uint32 flags = 0; 119 120 parse_table_init(unit, &pt); 121 parse_table_add(&pt, "Unit", PQ_DFL|PQ_INT, 122 INT_TO_PTR(unit), &stk_unit, 0); 123 parse_table_add(&pt, "Port", PQ_DFL|PQ_PORT, 0, &stk_port, 0); 124 parse_table_add(&pt, "Capable", PQ_DFL|PQ_BOOL, 0, &capable, 0); 125 parse_table_add(&pt, "Enable", PQ_DFL|PQ_BOOL, INT_TO_PTR(1), &enable, 0); 126 parse_table_add(&pt, "Inactive", PQ_DFL|PQ_BOOL, 0, &inactive, 0); 127 parse_table_add(&pt, "Simplex", PQ_DFL|PQ_BOOL, 0, &simplex, 0); 128 parse_table_add(&pt, "Duplex", PQ_DFL|PQ_BOOL, 0, &duplex, 0); 129 parse_table_add(&pt, "Internal", PQ_DFL|PQ_BOOL, 0, &internal, 0); 130 if (parse_arg_eq(args, &pt) < 0) { 131 parse_arg_eq_done(&pt); 132 return CMD_USAGE; 133 } 134 parse_arg_eq_done(&pt); 135 if (stk_port < 0) { 136 cli_out("ERROR: Must specify port number > 0\n"); 137 return CMD_USAGE; 138 } 139 140 flags |= capable ? BCM_STK_CAPABLE : 0; 141 flags |= enable ? BCM_STK_ENABLE : 0; 142 flags |= inactive ? BCM_STK_INACTIVE : 0; 143 flags |= simplex ? BCM_STK_SIMPLEX : 0; 144 flags |= duplex ? BCM_STK_DUPLEX : 0; 145 flags |= internal ? BCM_STK_INTERNAL : 0; 146 147 rv = bcm_stk_port_set(stk_unit, stk_port, flags); 148 if (rv < 0) { 149 cli_out("ERROR: stk_port_set unit %d port %d flags 0x%x: %s\n", 150 stk_unit, stk_port, flags, bcm_errmsg(rv)); 151 return CMD_FAIL; 152 } 153 154 return CMD_OK; 155 } 156 157 char cmd_stk_port_get_usage[] = 158 "\nStackPortGet [Port=<n>] [Unit=<n>]\n" 159 " Get stack port information. If no port is specified, get all\n" 160 " information for the current or specified device\n" 161 " If unit < 0 is specified, get all info for all local devices.\n"; 162 163 cmd_result_t 164 cmd_stk_port_get(int unit, args_t *args) 165 { 166 parse_table_t pt; 167 int rv; 168 int stk_unit = unit; 169 int stk_port = -1; /* This is intentionally a port */ 170 int dport; 171 uint32 flags = 0; 172 bcm_pbmp_t stk_pbmp, inactive_pbmp; 173 int i, start_unit, end_unit; 174 175 parse_table_init(unit, &pt); 176 parse_table_add(&pt, "Unit", PQ_DFL|PQ_INT, 177 INT_TO_PTR(unit), &stk_unit, 0); 178 parse_table_add(&pt, "Port", PQ_DFL|PQ_PORT, 0, &stk_port, 0); 179 if (parse_arg_eq(args, &pt) < 0) { 180 parse_arg_eq_done(&pt); 181 return CMD_USAGE; 182 } 183 parse_arg_eq_done(&pt); 184 185 if (stk_port >= 0) { 186 if (stk_unit < 0) { 187 cli_out("ERROR: Can't specify port with unit < 0\n"); 188 return CMD_FAIL; 189 } 190 191 rv = bcm_stk_port_get(stk_unit, stk_port, &flags); 192 if (rv < 0) { 193 cli_out("ERROR: stk_port_get unit %d port %d flags 0x%x: %s\n", 194 stk_unit, stk_port, flags, bcm_errmsg(rv)); 195 return CMD_FAIL; 196 } 197 _report_flags(stk_unit, stk_port, flags); 198 return CMD_OK; 199 } 200 201 if (unit >= 0) { 202 start_unit = unit; 203 end_unit = unit + 1; 204 } else { 205 start_unit = 0; 206 end_unit = soc_ndev; 207 } 208 209 for (i = start_unit; i < end_unit; i++) { 210 rv = bcm_stk_pbmp_get(i, &stk_pbmp, &inactive_pbmp); 211 if (rv < 0) { 212 cli_out("ERROR: stk_pbmp_get unit %d: %s\n", i, bcm_errmsg(rv)); 213 return CMD_FAIL; 214 } 215 /* coverity[overrun-local] */ 216 DPORT_BCM_PBMP_ITER(unit, stk_pbmp, dport, stk_port) { 217 rv = bcm_stk_port_get(i, stk_port, &flags); 218 if (rv < 0) { 219 cli_out("ERROR: stk_port_get unit %d port %d flags 0x%x: %s\n", 220 i, stk_port, flags, bcm_errmsg(rv)); 221 return CMD_FAIL; 222 } 223 _report_flags(i, stk_port, flags); 224 } 225 } 226 227 return CMD_OK; 228 } 229 230 #ifdef BCM_XGS_SUPPORT 231 char modmap_cmd_usage[] = 232 "Usages:\n\t" 233 #ifdef COMPILER_STRING_CONST_LIMIT 234 "modmap <option> [args...]\n" 235 #else 236 "modmap enable [PortBitMap = <pbmp>]\n\t" 237 " - Enable MODID remapping\n\t" 238 "modmap disable [PortBitMap = <pbmp>]\n\t" 239 " - Disable MODID remapping\n\t" 240 "modmap lmod set [Port = <val>] [FMod = <val>] [LMod = <val>]\n\t" 241 " - Set mapping between fabric module id and local module id\n\t" 242 "modmap lmod get [Port = <val>]\n\t" 243 " - Get mapping between fabric module id and local module id\n\t" 244 "modmap smod set [PortBitMap = <pbmp>] [FMod = <val>] [SMod = <val>]\n\t" 245 " [SPort = <val>] [NPorts = <val>]\n\t" 246 " - Set mapping between fabric module id and switch module id\n\t" 247 "modmap smod get [PortBitMap = <pbmp>] [FMod = <val>]\n\t" 248 " - Get mapping between fabric module id and switch module id\n\t" 249 "modmap group set [PortBitMap = <pbmp>] [Group = <val>]\n\t" 250 " - Set the group membership of ports\n\t" 251 "modmap group show\n\t" 252 " - Display the group membership of all ports\n\t" 253 "modmap show\n\t" 254 " - Show MODID mapping states\n" 255 #endif 256 ; 257 258 cmd_result_t 259 cmd_modmap(int unit, args_t *a) 260 { 261 char *subcmd; 262 parse_table_t pt; 263 cmd_result_t retCode; 264 int r, mode; 265 soc_port_t port, dport; 266 bcm_pbmp_t pbmp; 267 bcm_port_config_t pcfg; 268 int arg_fmod = 0, arg_lmod = 0, arg_port = 0; 269 int arg_smod = 0, arg_sport = 0, arg_group = 0; 270 uint32 arg_nports = 0; 271 int fmod, lmod, smod, sport, group; 272 uint32 nports; 273 274 if (!sh_check_attached(ARG_CMD(a), unit)) { 275 return CMD_FAIL; 276 } 277 278 if (bcm_port_config_get(unit, &pcfg) != BCM_E_NONE) { 279 cli_out("%s: Error: bcm ports not initialized\n", ARG_CMD(a)); 280 return CMD_FAIL; 281 } 282 283 if ((subcmd = ARG_GET(a)) == NULL) { 284 return CMD_USAGE; 285 } 286 287 BCM_PBMP_CLEAR(pbmp); 288 289 if (sal_strcasecmp(subcmd, "enable") == 0) { 290 parse_table_init(unit, &pt); 291 parse_table_add(&pt, "PortBitMap", PQ_DFL|PQ_PBMP|PQ_BCM, 292 (void *)(0), &pbmp, NULL); 293 if (!parseEndOk(a, &pt, &retCode)) { 294 return retCode; 295 } 296 297 BCM_PBMP_AND(pbmp, pcfg.stack_ext); 298 /* coverity[overrun-local] */ 299 DPORT_BCM_PBMP_ITER(unit, pbmp, dport, port) { 300 r = bcm_stk_modmap_enable_set(unit, port, 1); 301 302 if (r < 0) { 303 cli_out("ERROR: %s %s port %s failed: %s\n", 304 ARG_CMD(a), subcmd, BCM_PORT_NAME(unit, port), 305 bcm_errmsg(r)); 306 return CMD_FAIL; 307 } 308 cli_out("port %s modid mapping enabled.\n", 309 BCM_PORT_NAME(unit, port)); 310 } 311 return CMD_OK; 312 } 313 314 if (sal_strcasecmp(subcmd, "disable") == 0) { 315 parse_table_init(unit, &pt); 316 parse_table_add(&pt, "PortBitMap", PQ_DFL|PQ_PBMP|PQ_BCM, 317 (void *)(0), &pbmp, NULL); 318 if (!parseEndOk(a, &pt, &retCode)) { 319 return retCode; 320 } 321 322 BCM_PBMP_AND(pbmp, pcfg.stack_ext); 323 DPORT_BCM_PBMP_ITER(unit, pbmp, dport, port) { 324 r = bcm_stk_modmap_enable_set(unit, port, 0); 325 326 if (r < 0) { 327 cli_out("ERROR: %s %s port %s failed: %s\n", 328 ARG_CMD(a), subcmd, BCM_PORT_NAME(unit, port), 329 bcm_errmsg(r)); 330 return CMD_FAIL; 331 } 332 cli_out("port %s modid mapping disabled.\n", 333 BCM_PORT_NAME(unit, port)); 334 } 335 return CMD_OK; 336 } 337 338 if (sal_strcasecmp(subcmd, "lmod") == 0) { 339 if ((subcmd = ARG_GET(a)) == NULL) 340 return CMD_USAGE; 341 342 if (sal_strcasecmp(subcmd, "set") == 0) { 343 parse_table_init(unit, &pt); 344 parse_table_add(&pt, "Port", PQ_DFL|PQ_PORT|PQ_BCM, 345 0, (void *)&arg_port, 0); 346 parse_table_add(&pt, "FModule", PQ_DFL|PQ_INT, 347 0, &arg_fmod, NULL); 348 parse_table_add(&pt, "LModule", PQ_DFL|PQ_INT, 349 0, &arg_lmod, NULL); 350 if (!parseEndOk(a, &pt, &retCode)) 351 return retCode; 352 353 r = bcm_stk_fmod_lmod_mapping_set(unit, arg_port, 354 arg_fmod, arg_lmod); 355 356 if (r < 0) { 357 cli_out("ERROR: %s %s port %s failed: %s\n", 358 ARG_CMD(a), subcmd, 359 BCM_PORT_NAME(unit, arg_port), bcm_errmsg(r)); 360 return CMD_FAIL; 361 } 362 cli_out("port %s assigns fmod=%d and lmod=%d.\n", 363 BCM_PORT_NAME(unit, arg_port), arg_fmod, arg_lmod); 364 return CMD_OK; 365 } 366 367 if (sal_strcasecmp(subcmd, "get") == 0) { 368 parse_table_init(unit, &pt); 369 parse_table_add(&pt, "Port", PQ_DFL|PQ_PORT|PQ_BCM, 370 0, (void *)&arg_port, 0); 371 if (!parseEndOk(a, &pt, &retCode)) 372 return retCode; 373 374 r = bcm_stk_fmod_lmod_mapping_get(unit, arg_port, &fmod, &lmod); 375 376 if (r < 0) { 377 cli_out("ERROR: %s %s port %s failed: %s\n", 378 ARG_CMD(a), subcmd, 379 BCM_PORT_NAME(unit, arg_port), bcm_errmsg(r)); 380 return CMD_FAIL; 381 } 382 cli_out("port %s has fmod=%d maps to lmod=%d.\n", 383 BCM_PORT_NAME(unit, arg_port), fmod, lmod); 384 return CMD_OK; 385 } 386 } 387 388 if (sal_strcasecmp(subcmd, "smod") == 0) { 389 if ((subcmd = ARG_GET(a)) == NULL) 390 return CMD_USAGE; 391 392 if (sal_strcasecmp(subcmd, "set") == 0) { 393 parse_table_init(unit, &pt); 394 parse_table_add(&pt, "PortBitMap", PQ_DFL|PQ_PBMP|PQ_BCM, 395 (void *)(0), &pbmp, NULL); 396 parse_table_add(&pt, "FModule", PQ_DFL|PQ_INT, 397 0, &arg_fmod, NULL); 398 parse_table_add(&pt, "SModule", PQ_DFL|PQ_INT, 399 0, &arg_smod, NULL); 400 parse_table_add(&pt, "SPort", PQ_DFL|PQ_INT, 401 0, &arg_sport, NULL); 402 parse_table_add(&pt, "NPorts", PQ_DFL|PQ_INT, 403 0, &arg_nports, NULL); 404 if (!parseEndOk(a, &pt, &retCode)) 405 return retCode; 406 407 BCM_PBMP_AND(pbmp, pcfg.stack_ext); 408 DPORT_BCM_PBMP_ITER(unit, pbmp, dport, port) { 409 r = bcm_stk_fmod_smod_mapping_set(unit, port, 410 arg_fmod, arg_smod, 411 arg_sport, arg_nports); 412 if (r < 0) { 413 cli_out("ERROR: %s %s failed: %s\n", 414 ARG_CMD(a), subcmd, bcm_errmsg(r)); 415 return CMD_FAIL; 416 } 417 if (arg_nports != 0) { 418 cli_out("port %s: fmod=%d maps smod=%d " 419 "with %d ports (base_port=%d)\n", 420 BCM_PORT_NAME(unit, port), 421 arg_fmod, arg_smod, arg_nports, arg_sport); 422 } else { 423 cli_out("port %s: fmod=%d maps smod=%d deleted\n", 424 BCM_PORT_NAME(unit, port), 425 arg_fmod, arg_smod); 426 } 427 } 428 return CMD_OK; 429 } 430 431 if (sal_strcasecmp(subcmd, "get") == 0) { 432 parse_table_init(unit, &pt); 433 parse_table_add(&pt, "PortBitMap", PQ_DFL|PQ_PBMP|PQ_BCM, 434 (void *)(0), &pbmp, NULL); 435 parse_table_add(&pt, "FModule", PQ_DFL|PQ_INT, 436 0, &arg_fmod, NULL); 437 if (!parseEndOk(a, &pt, &retCode)) 438 return retCode; 439 440 BCM_PBMP_AND(pbmp, pcfg.stack_ext); 441 DPORT_BCM_PBMP_ITER(unit, pbmp, dport, port) { 442 r = bcm_stk_fmod_smod_mapping_get(unit, port, arg_fmod, 443 &smod, &sport, &nports); 444 if (r < 0) { 445 cli_out("ERROR: %s %s failed: %s\n", 446 ARG_CMD(a), subcmd, bcm_errmsg(r)); 447 return CMD_FAIL; 448 } 449 cli_out("port %s: fmod=%d maps smod=%d " 450 "with %d ports (base_port=%d)\n", 451 BCM_PORT_NAME(unit, port), 452 arg_fmod, smod, nports, sport); 453 } 454 return CMD_OK; 455 } 456 } 457 458 if (sal_strcasecmp(subcmd, "group") == 0) { 459 if ((subcmd = ARG_GET(a)) == NULL) 460 return CMD_USAGE; 461 462 if (sal_strcasecmp(subcmd, "set") == 0) { 463 parse_table_init(unit, &pt); 464 parse_table_add(&pt, "PortBitMap", PQ_DFL|PQ_PBMP|PQ_BCM, 465 (void *)(0), &pbmp, NULL); 466 parse_table_add(&pt, "Group", PQ_DFL|PQ_INT, 467 0, &arg_group, NULL); 468 if (!parseEndOk(a, &pt, &retCode)) 469 return retCode; 470 471 /* Parameter limit check */ 472 r = bcm_stk_port_modmap_group_max_get(unit, &group); 473 if (r < 0) { 474 cli_out("ERROR: %s %s failed: %s\n", 475 ARG_CMD(a), subcmd, bcm_errmsg(r)); 476 return CMD_FAIL; 477 } 478 479 if (arg_group > group) { 480 cli_out("ERROR: Modmap group %d exceeds maximum of %d\n", 481 arg_group, group); 482 return CMD_FAIL; 483 } 484 485 BCM_PBMP_AND(pbmp, pcfg.stack_ext); 486 DPORT_BCM_PBMP_ITER(unit, pbmp, dport, port) { 487 r = bcm_stk_port_modmap_group_set(unit, port, arg_group); 488 if (r < 0) { 489 cli_out("ERROR: %s %s failed: %s\n", 490 ARG_CMD(a), subcmd, bcm_errmsg(r)); 491 return CMD_FAIL; 492 } 493 cli_out("port %s set to modmap group %d\n", 494 BCM_PORT_NAME(unit, port), arg_group); 495 } 496 return CMD_OK; 497 } 498 499 if (sal_strcasecmp(subcmd, "show") == 0) { 500 pbmp_t pbmp_g0, pbmp_g1; 501 char bufp[FORMAT_PBMP_MAX]; 502 503 BCM_PBMP_CLEAR(pbmp_g0); 504 BCM_PBMP_CLEAR(pbmp_g1); 505 506 BCM_PBMP_ASSIGN(pbmp, pcfg.stack_ext); 507 DPORT_BCM_PBMP_ITER(unit, pbmp, dport, port) { 508 r = bcm_stk_port_modmap_group_get(unit, port, &group); 509 if (r < 0) { 510 cli_out("ERROR: %s %s failed: %s\n", 511 ARG_CMD(a), subcmd, bcm_errmsg(r)); 512 return CMD_FAIL; 513 } 514 515 if (group == 1) { 516 /* coverity[overrun-local] */ 517 BCM_PBMP_PORT_ADD(pbmp_g1, port); 518 } else if (group == 0) { 519 /* coverity[overrun-local] */ 520 BCM_PBMP_PORT_ADD(pbmp_g0, port); 521 } else { 522 /* Shouldn't be here */ 523 cli_out("ERROR: Inconsistent modmap group\n"); 524 return CMD_FAIL; 525 } 526 } 527 format_bcm_pbmp(unit, bufp, sizeof(bufp), pbmp_g0); 528 cli_out("Modmap group 0: %s\n", bufp); 529 format_bcm_pbmp(unit, bufp, sizeof(bufp), pbmp_g1); 530 cli_out("Modmap group 1: %s\n", bufp); 531 return CMD_OK; 532 } 533 } 534 535 if (sal_strcasecmp(subcmd, "show") == 0) { 536 BCM_PBMP_ITER(pcfg.stack_ext, port) { 537 r = bcm_stk_modmap_enable_get(unit, port, &mode); 538 539 if (r < 0) { 540 cli_out("ERROR: %s %s port %s failed: %s\n", 541 ARG_CMD(a), subcmd, BCM_PORT_NAME(unit, port), 542 bcm_errmsg(r)); 543 return CMD_FAIL; 544 } 545 cli_out("port %s modid mapping %s.\n", 546 BCM_PORT_NAME(unit, port), (mode ? "enable" : "disable")); 547 548 if (mode) { 549 r = bcm_stk_fmod_lmod_mapping_get(unit, port, &fmod, &lmod); 550 if (r < 0) { 551 cli_out("ERROR: %s %s port %s failed: %s\n", 552 ARG_CMD(a), subcmd, BCM_PORT_NAME(unit, port), 553 bcm_errmsg(r)); 554 return CMD_FAIL; 555 } 556 cli_out(" fmod=%d maps lmod=%d\n", fmod, lmod); 557 558 r = bcm_stk_fmod_smod_mapping_get(unit, port, fmod, 559 &smod, &sport, &nports); 560 if (r < 0) { 561 cli_out("ERROR: %s %s failed: %s\n", 562 ARG_CMD(a), subcmd, bcm_errmsg(r)); 563 return CMD_FAIL; 564 } 565 cli_out(" fmod=%d maps smod=%d " 566 "with %d ports (base_port=%d)\n", 567 fmod, smod, nports, sport); 568 } 569 } 570 return CMD_OK; 571 } 572 573 return CMD_USAGE; 574 } 575 #endif /* BCM_XGS_SUPPORT */