field.c (351773B)
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 * Field Processor 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 <shared/bsl.h> 15 #include <soc/debug.h> 16 17 #include <appl/diag/shell.h> 18 #include <appl/diag/system.h> 19 #include <appl/diag/parse.h> 20 #include <appl/diag/diag.h> 21 #include <appl/diag/dport.h> 22 23 #include <bcm/init.h> 24 #include <bcm/field.h> 25 #include <bcm/error.h> 26 #include <bcm/stack.h> 27 28 #include <bcm_int/esw/field.h> 29 #if defined(BCM_TOMAHAWK_SUPPORT) 30 #include <bcm_int/esw/tomahawk.h> 31 #endif 32 33 #ifdef BCM_FIELD_SUPPORT 34 35 /* 36 * Macro: 37 * FP_CHECK_RETURN 38 * Purpose: 39 * Check the return value from an API call. Output either a failed 40 * message or okay along with the function name. 41 */ 42 #define FP_CHECK_RETURN(unit, retval, funct_name) \ 43 if (BCM_FAILURE(retval)) { \ 44 cli_out("FP(unit %d) Error: %s() failed: %s\n", (unit), \ 45 (funct_name), bcm_errmsg(retval)); \ 46 return CMD_FAIL; \ 47 } else { \ 48 LOG_VERBOSE(BSL_LS_APPL_SHELL, \ 49 (BSL_META_U(unit, \ 50 "FP(unit %d) verb: %s() success \n"), \ 51 (unit), (funct_name))); \ 52 } 53 54 /* 55 * Macro: 56 * FP_GET_NUMB 57 * Purpose: 58 * Get a numerical value from stdin. 59 */ 60 #define FP_GET_NUMB(numb, str, args) \ 61 if (((str) = ARG_GET(args)) == NULL) { \ 62 return CMD_USAGE; \ 63 } \ 64 (numb) = parse_integer(str); 65 66 /* 67 * Macro: 68 * FP_GET_MAC 69 * Purpose: 70 * Get a mac address from stdin. 71 */ 72 #define FP_GET_MAC(_mac, _str, _args) \ 73 if (((_str) = ARG_GET(_args)) == NULL) { \ 74 return CMD_FAIL; \ 75 } \ 76 if(parse_macaddr((_str), (_mac))) { \ 77 return CMD_FAIL; \ 78 } 79 80 /* 81 * Macro: 82 * FP_GET_PORT 83 * Purpose: 84 * Get a numerical value from stdin. 85 */ 86 #define FP_GET_PORT(_unit, _port, _str, _args) do { \ 87 if (((_str) = ARG_GET(_args)) == NULL) { \ 88 return CMD_USAGE; \ 89 } \ 90 if (parse_bcm_port((_unit), (_str), &(_port)) < 0) { \ 91 LOG_ERROR(BSL_LS_APPL_SHELL, \ 92 (BSL_META_U(unit, \ 93 "FP(unit %d) Error: invalid port string: \"%s\"\n"), \ 94 (_unit), (_str))); \ 95 return CMD_FAIL; \ 96 } \ 97 } while (0) 98 99 100 /* 101 * Marker for last element in qualification table 102 */ 103 #define FP_TABLE_END_STR "tbl_end" 104 105 #define FP_STAT_STR_SZ 256 106 #define FP_LINE_SZ 72 107 /* 108 * local function prototypes 109 */ 110 111 STATIC char *_fp_qual_stage_name(bcm_field_stage_t stage); 112 STATIC char *_fp_qual_IpType_name(bcm_field_IpType_t type); 113 STATIC char *_fp_qual_L2Format_name(bcm_field_L2Format_t type); 114 STATIC char * _fp_qual_IpProtocolCommon_name 115 (bcm_field_IpProtocolCommon_t type); 116 STATIC char *_fp_control_name(bcm_field_control_t control); 117 118 STATIC int fp_action(int unit, args_t *args); 119 STATIC int fp_action_ports(int unit, args_t *args); 120 STATIC int fp_action_mac(int unit, args_t *args); 121 STATIC int fp_action_add(int unit, args_t *args); 122 STATIC int fp_action_ports_add(int unit, args_t *args); 123 STATIC int fp_action_mac_add(int unit, args_t *args); 124 STATIC int fp_lookup_color(char *qual_str); 125 STATIC int fp_action_get(int unit, args_t *args); 126 STATIC int fp_action_ports_get(int unit, args_t *args); 127 STATIC int fp_action_mac_get(int unit, args_t *args); 128 STATIC int fp_action_remove(int unit, args_t *args); 129 130 STATIC int fp_action_supported(int unit, int fp_stage, int action); 131 STATIC int fp_oam_action(int unit, args_t *args); 132 STATIC int fp_oam_action_add(int unit, args_t *args); 133 STATIC int fp_oam_action_get(int unit, args_t *args); 134 STATIC int fp_oam_action_get_all(int unit, args_t *args); 135 STATIC int fp_oam_action_delete(int unit, args_t *args); 136 STATIC int fp_oam_action_delete_all(int unit, args_t *args); 137 138 STATIC int fp_control(int unit, args_t *args); 139 140 STATIC int fp_entry(int unit, args_t *args); 141 STATIC int fp_entry_create(int unit, args_t *args); 142 STATIC int fp_entry_copy(int unit, args_t *args); 143 STATIC int fp_entry_destroy(int unit, args_t *args); 144 STATIC int fp_entry_install(int unit, args_t *args); 145 STATIC int fp_entry_reinstall(int unit, args_t *args); 146 STATIC int fp_entry_remove(int unit, args_t *args); 147 STATIC int fp_entry_enable(int unit, args_t *args); 148 STATIC int fp_entry_disable(int unit, args_t *args); 149 STATIC int fp_entry_prio(int unit, args_t *args); 150 STATIC int fp_entry_oper(int unit, args_t *args); 151 152 STATIC int fp_group(int unit, args_t *args, bcm_field_qset_t *qset); 153 STATIC int fp_group_create(int unit, args_t *args, 154 bcm_field_qset_t *qset); 155 156 STATIC int fp_group_get(int unit, args_t *args); 157 STATIC int fp_group_destroy(int unit, args_t *args); 158 STATIC int fp_group_set(int unit, args_t *args, bcm_field_qset_t *qset); 159 STATIC int fp_group_status_get(int unit, args_t *args); 160 STATIC int fp_group_mode_get(int unit, args_t *args); 161 162 STATIC int fp_list(int unit, args_t *args); 163 STATIC int fp_list_actions(int unit, args_t *args); 164 STATIC int fp_list_quals(int unit, args_t *args); 165 STATIC void fp_print_options(const char *options[], const int offset); 166 STATIC int fp_list_udf_flags(int unit); 167 168 STATIC int fp_range(int unit, args_t *args); 169 STATIC int fp_range_create(int unit, args_t *args); 170 STATIC int fp_range_group_create(int unit, args_t *args); 171 STATIC int fp_range_get(int unit, args_t *args); 172 STATIC int fp_range_destroy(int unit, args_t *args); 173 STATIC int fp_group_lookup(int unit, args_t *args); 174 STATIC int fp_group_compress(int unit, args_t *args); 175 STATIC int fp_group_enable_set(int unit, bcm_field_group_t gid, int enable); 176 177 STATIC int fp_policer(int unit, args_t *args); 178 STATIC int fp_policer_create(int unit, args_t *args); 179 STATIC int fp_policer_destroy(int unit, args_t *args); 180 STATIC int fp_policer_set(int unit, args_t *args); 181 STATIC int fp_policer_attach(int unit, args_t *args); 182 STATIC int fp_policer_detach(int unit, args_t *args); 183 184 STATIC int fp_stat(int unit, args_t *args); 185 STATIC int fp_stat_create(int unit, args_t *args); 186 STATIC int fp_stat_destroy(int unit, args_t *args); 187 STATIC int fp_stat_attach(int unit, args_t *args); 188 STATIC int fp_stat_detach(int unit, args_t *args); 189 190 STATIC int fp_data(int unit, args_t *args); 191 STATIC int fp_data_create(int unit, args_t *args); 192 STATIC int fp_data_destroy(int unit, args_t *args); 193 STATIC int fp_data_packet_format_add_delete(int unit, args_t *args, int op); 194 STATIC int fp_data_ethertype_add_delete(int unit, args_t *args, int op); 195 STATIC int fp_data_ipproto_add_delete(int unit, args_t *args, int op); 196 STATIC int fp_qual_data(int unit, bcm_field_entry_t eid, args_t *args); 197 198 STATIC int fp_qset(int unit, args_t *args, bcm_field_qset_t *qset); 199 STATIC int fp_qset_add(int unit, args_t *args, bcm_field_qset_t *qset); 200 STATIC int fp_qset_set(int unit, args_t *args, bcm_field_qset_t *qset); 201 STATIC int fp_qset_show(bcm_field_qset_t *qset); 202 203 STATIC int fp_aset(int unit, args_t *args, bcm_field_aset_t *aset); 204 STATIC int fp_aset_add(int unit, args_t *args, bcm_field_aset_t *aset); 205 STATIC int fp_aset_delete(int unit, args_t *args); 206 STATIC int fp_aset_clear(int unit, args_t *args); 207 STATIC int fp_aset_show(int unit, args_t *args); 208 /* Lookup functions given string equivalent for type. */ 209 STATIC void fp_lookup_control(const char *control_str, 210 bcm_field_control_t *control); 211 212 STATIC bcm_field_IpType_t fp_lookup_IpType(const char *type_str); 213 STATIC bcm_field_L2Format_t fp_lookup_L2Format(const char *type_str); 214 STATIC bcm_field_IpProtocolCommon_t fp_lookup_IpProtocolCommon(const char 215 *type_str); 216 STATIC bcm_field_stage_t fp_lookup_stage(const char *stage_str); 217 218 /* Qualify related functions */ 219 STATIC int fp_qual(int unit, args_t *args); 220 STATIC int fp_qual_InPorts(int unit, bcm_field_entry_t eid, bcm_field_qualify_t qual, args_t *args); 221 STATIC int fp_qual_OutPorts(int unit, bcm_field_entry_t eid, args_t *args); 222 223 /* bcm_field_qualify_XXX exercise functions. */ 224 STATIC int fp_qual_port(int unit, bcm_field_entry_t eid, args_t *args, 225 int func(int, bcm_field_entry_t, bcm_port_t, bcm_port_t), 226 char *qual_str); 227 STATIC int fp_qual_modport(int unit, bcm_field_entry_t eid, args_t *args, 228 int func(int, bcm_field_entry_t, bcm_module_t, bcm_module_t, 229 bcm_port_t, bcm_port_t), 230 char *qual_str); 231 232 STATIC int fp_qual_modport_help(const char *prefix, const char *qual_str, 233 int width_col1); 234 STATIC int fp_qual_trunk(int unit, bcm_field_entry_t eid, args_t *args, 235 int func(int, bcm_field_entry_t, bcm_trunk_t, bcm_trunk_t), 236 char *qual_str); 237 STATIC int fp_qual_l4port(int unit, bcm_field_entry_t eid, args_t *args, 238 int func(int, bcm_field_entry_t, bcm_l4_port_t, bcm_l4_port_t), 239 char *qual_str); 240 STATIC int fp_qual_rangecheck(int unit, bcm_field_entry_t eid, args_t *args, 241 int func(int, bcm_field_entry_t, bcm_field_range_t, int), 242 char *qual_str); 243 STATIC int fp_qual_vlan(int unit, bcm_field_entry_t eid, args_t *args, 244 int func(int, bcm_field_entry_t, bcm_vlan_t, bcm_vlan_t), 245 char *qual_str); 246 STATIC int fp_qual_ip(int unit, bcm_field_entry_t eid, args_t *args, 247 int func(int, bcm_field_entry_t, bcm_ip_t, bcm_ip_t), 248 char *qual_str); 249 STATIC int fp_qual_tpid(int unit, bcm_field_entry_t eid, args_t *args, 250 int func(int, bcm_field_entry_t, uint16), 251 char *qual_str); 252 STATIC int fp_qual_ip6(int unit, bcm_field_entry_t eid, args_t *args, 253 int func(int, bcm_field_entry_t, bcm_ip6_t, bcm_ip6_t), 254 char *qual_str); 255 STATIC int fp_qual_mac(int unit, bcm_field_entry_t eid, args_t *args, 256 int func(int, bcm_field_entry_t, bcm_mac_t, bcm_mac_t), 257 char *qual_str); 258 STATIC int fp_qual_mac_help(const char *prefix, const char *qual_str, 259 int width_col1); 260 STATIC int fp_qual_SrcLookupClass(int unit, bcm_field_entry_t eid, args_t *args, 261 int func(int, bcm_field_entry_t, uint32, uint32), 262 char *qual_str); 263 STATIC int fp_qual_DstLookupClass(int unit, bcm_field_entry_t eid, args_t *args, 264 int func(int, bcm_field_entry_t, uint32, uint32), 265 char *qual_str); 266 STATIC int fp_qual_8(int unit, bcm_field_entry_t eid, args_t *args, 267 int func(int, bcm_field_entry_t, uint8, uint8), 268 char *qual_str); 269 STATIC int fp_qual_16(int unit, bcm_field_entry_t eid, args_t *args, 270 int func(int, bcm_field_entry_t, uint16, uint16), 271 char *qual_str); 272 STATIC int fp_qual_32(int unit, bcm_field_entry_t eid, args_t *args, 273 int func(int, bcm_field_entry_t, uint32, uint32), 274 char *qual_str); 275 STATIC int fp_qual_Decap(int unit, bcm_field_entry_t eid, args_t *args); 276 STATIC int fp_qual_IpInfo(int unit, bcm_field_entry_t eid, args_t *args); 277 STATIC int fp_qual_IpInfo_help(const char *prefix, int width_col1); 278 STATIC int fp_qual_PacketRes(int unit, bcm_field_entry_t eid, args_t *args); 279 STATIC int fp_qual_PacketRes_help(const char *prefix, int width_col1); 280 STATIC int fp_qual_IpFrag(int unit, bcm_field_entry_t eid, args_t *args); 281 STATIC int fp_qual_IpFrag_help(const char *prefix, int width_col1); 282 STATIC int fp_qual_Color(int unit, bcm_field_entry_t eid, args_t *args); 283 STATIC int fp_qual_Color_help(const char *prefix, int width_col1); 284 STATIC int fp_qual_IpProtocolCommon_help(const char *prefix, int width_col1); 285 STATIC int fp_qual_IpType(int unit, bcm_field_entry_t eid, args_t *args); 286 STATIC int fp_qual_InnerIpType(int unit, bcm_field_entry_t eid, args_t *args); 287 STATIC int fp_qual_L2Format(int unit, bcm_field_entry_t eid, args_t *args); 288 STATIC int fp_qual_InterfaceClass(int unit, bcm_field_entry_t eid, args_t *args, 289 int func(int, bcm_field_entry_t, uint32, uint32), 290 char *qual_str); 291 STATIC int fp_qual_Gport(int unit, bcm_field_entry_t eid, args_t *args, 292 int func(int, bcm_field_entry_t, int), 293 char *qual_str); 294 STATIC int fp_qual_Gports(int unit, bcm_field_entry_t eid, args_t *args, 295 int func(int, bcm_field_entry_t, int,int ), 296 char *qual_str); 297 STATIC int fp_qual_LoopbackType(int unit, bcm_field_entry_t eid, args_t *args); 298 STATIC int fp_qual_LoopbackType_help(const char *prefix, int width_col1); 299 STATIC int fp_qual_TunnelType(int unit, bcm_field_entry_t eid, args_t *args); 300 STATIC int fp_qual_TunnelType_help(const char *prefix, int width_col1); 301 302 STATIC int fp_qual_supported(int unit, int fp_stage, int qual); 303 304 STATIC int fp_qual_IpProtocolCommon(int unit, bcm_field_entry_t eid, args_t 305 *args); 306 STATIC int fp_qual_ForwardingType(int unit, bcm_field_entry_t eid, args_t *args); 307 STATIC int fp_qual_ForwardingType_help(const char *prefix, int width_col1); 308 STATIC int fp_qual_MplsOam_Control_pktType (int unit, bcm_field_entry_t eid, 309 args_t *args); 310 STATIC int fp_qual_oam_type (int unit, bcm_field_entry_t eid, args_t *args); 311 STATIC int fp_qual_StpState(int unit, bcm_field_entry_t eid, args_t *args); 312 STATIC int fp_qual_StpState_help(const char *prefix, int width_col1); 313 STATIC int fp_qual_OamDrop(int unit, bcm_field_entry_t eid, args_t *args, 314 int func(int, bcm_field_entry_t, bcm_field_oam_drop_mep_type_t), 315 char *qual_str); 316 STATIC int fp_qual_OamEgressEtherType(int unit, bcm_field_entry_t eid, args_t *args); 317 STATIC int fp_qual_OamEgressMulticastMacHit(int unit, bcm_field_entry_t eid, args_t *args); 318 STATIC int fp_qual_RoeFrameType(int unit, bcm_field_entry_t eid, args_t *args); 319 STATIC int fp_qual_RoeFrameType_help(const char *prefix, int width_col1); 320 321 STATIC bcm_field_stat_t LastCreatedStatID = -1; 322 323 const char *l2_text[] = {"Ethernet2", "Snap", "LLC", "Other", NULL}; 324 const char *vlan_text[] = {"NOtag", "ONEtag", "TWOtag", NULL}; 325 const char *ip_text[] = {"IP4HdrOnly", "IP6HdrOnly", "IP6Fragment", 326 "IP4OverIP4", "IP6OverIP4", "IP4OverIP6", 327 "IP6OverIP6", "GreIP4OverIP4", "GreIP6OverIP4", 328 "GreIP4OverIP6", "GreIP6OverIP6", "OneMplsLabel", 329 "TwoMplsLabels", "IP6FragmentOverIP4", "IPNotUsed", NULL}; 330 const char *ing_span_text[] = {"DISabled", "BLocK", "LeaRN", "ForWarD", NULL}; 331 const char *packet_res_text[] = {"Unknown", "Control", "Bpdu", "L2BC", 332 "L2Uc", "L2UnKnown", "L3McUnknown", "L3McKnown", "L2McKnown", "L2McUnknown", 333 "L3UcKnown", "L3UcUnknown", "MplsKnown", "MplsL3Known", "MplsL2Known", 334 "MplsUnknown", "MimKnown", "MimUnknown", "TrillKnown", "TrillUnknown", 335 "NivKnown", "NivUnknown", "Oam", "Bfd", "Icnm", "IEEE1588", 336 "L2GreKnown", "VxlanKnown", "FCoEKnown", "FCoEUnknown", NULL}; 337 const char *ipfrag_text[] = {"IpFragNon", "IpFragFirst", "IpFragNonOrFirst", 338 "IpFragNotFirst", "IpFragAny", NULL}; 339 const char *color_text[] = {"green", "yellow", "red", NULL}; 340 const char *loopbacktype_text[] = { 341 "Any", "Mirror", "Wlan", "Mim", "Redirect", NULL}; 342 const char *tunneltype_text[] = { 343 "Any", "Ip", "Mpls", "Mim", "WtpToAc", "AcToAc", "AutoMulticast", NULL}; 344 const char *policermode_text[] = {"SrTcm", "Committed", "Invalid", "TrTcm", 345 "TrTcmDs", "Green", "PassThrough", "SrTcmModified", "CoupledTrTcmDs", 346 "Invalid", "Invalid", "Invalid", "SrTcmTsn", NULL}; 347 const char *stattype_text[] = {"Bytes", "Packets", "GreenBytes", 348 "GreenPackets", "YellowBytes", "YellowPackets", "RedBytes", 349 "RedPackets", "NotGreenBytes", "NotGreenPackets", "NotYellowBytes", 350 "NotYellowPackets", "NotRedBytes", "NotRedPackets", "Invalid", NULL}; 351 const char *offsetbase_text[] = {"PacketStart", "OuterL3Header", "InnerL3Header", 352 "OuterL4Header", "InnerL4Header", "HigigHeader", "Higig2Header", NULL}; 353 const char *data_vlan_text[] = {"Any", "NoTag", "SingleTagged", 354 "DoubleTagged", NULL }; 355 const char *data_l2_text[] = {"Any", "Ethernet2", "Snap", "Llc", NULL}; 356 const char *data_ip_text[] = {"Any", "None", "Ip4", "Ip6", NULL}; 357 const char *data_tunnel_text[] = {"Any", "None", "IpInIp", "Gre", "Mpls", NULL}; 358 const char *data_mpls_text[] = {"Any", "OneLabel", "TwoLabels", NULL}; 359 const char *ip_protocol_common[] = {"Tcp", "Udp", "Igmp", "Icmp", "Ip6Icmp", 360 "Ip6HopByHop", "IpInIp", "TcpUdp", NULL}; 361 const char *forwarding_type_text[] = {"Any", "L2", "L3", "L2Shared", 362 "L2Independent", "L2Vpn", "L2VpnDirect", 363 "L3Direct", "Ip4Ucast", "Ip4Mcast", 364 "Ip6Ucast", "Ip6Mcast", "Mpls", "Trill", 365 "RxReason", "TrafficManagement", "Snoop", 366 "L2VpnExtended", "Ip4UcastRpf", 367 "Ip6UcastRpf", "MplsLabel1", "MplsLabel2", 368 "MplsLabel3", "FCoE", "L2SharedVpn", "PortDirect", 369 "SvpDirect", "VlanDirect", 370 "Invalid", NULL}; 371 const char *data_higig_text[] = {"Any", "Higig", "NoHigig", NULL}; 372 const char *data_vntag_text[] = {"Any", "Vntag", "NoVntag", NULL}; 373 const char *data_cntag_text[] = {"Any", "Cntag", "NoCntag", NULL}; 374 const char *data_etag_text[] = {"Any", "Etag", "NoEtag", NULL}; 375 const char *data_icnm_text[] = {"Any" "Icnm", "NoIcnm", NULL}; 376 const char *data_stp_text[] = {"Disable", "Block", "Learn", "Forward", "DisableBlock", 377 "DisableLearn", "BlockForward", "LearnForward", NULL}; 378 const char *data_roe_type_text[] = {"None", "Roe", "Custom", NULL}; 379 380 /* 381 * Function: 382 * if_field_proc 383 * Purpose: 384 * Manage Field Processor (FP) 385 * Parameters: 386 * unit - SOC unit # 387 * args - pointer to command line arguments 388 * Returns: 389 * CMD_OK 390 */ 391 392 cmd_result_t 393 if_esw_field_proc(int unit, args_t *args) 394 { 395 int retval = CMD_OK; 396 char* subcmd = NULL; 397 static bcm_field_qset_t qset; 398 bcm_field_aset_t aset; 399 #ifdef BROADCOM_DEBUG 400 bcm_field_group_t gid; 401 bcm_field_entry_t eid = 0; 402 #endif /* BROADCOM_DEBUG */ 403 404 if ((subcmd = ARG_GET(args)) == NULL) { 405 return CMD_USAGE; 406 } 407 408 /* BCM.0> fp qual ... */ 409 if(!sal_strcasecmp(subcmd, "qual")) { 410 return fp_qual(unit, args); 411 } 412 413 /* BCM.0> fp qset ... */ 414 if(!sal_strcasecmp(subcmd, "qset")) { 415 return fp_qset(unit, args, &qset); 416 } 417 418 /* BCM.0> fp action ... */ 419 if(!sal_strcasecmp(subcmd, "action")) { 420 return fp_action(unit, args); 421 } 422 423 /* BCM.0> fp control ... */ 424 if(!sal_strcasecmp(subcmd, "control")) { 425 return fp_control(unit, args); 426 } 427 428 /* BCM.0> fp detach */ 429 if(!sal_strcasecmp(subcmd, "detach")) { 430 retval = bcm_field_detach(unit); 431 FP_CHECK_RETURN(unit, retval, "bcm_field_detach"); 432 return CMD_OK; 433 } 434 435 /* BCM.0> fp entry ... */ 436 if(!sal_strcasecmp(subcmd, "entry")) { 437 return fp_entry(unit, args); 438 } 439 440 /* BCM.0> fp group ... */ 441 if(!sal_strcasecmp(subcmd, "group")) { 442 return fp_group(unit, args, &qset); 443 } 444 445 /* BCM.0> fp list ... */ 446 if(!sal_strcasecmp(subcmd, "list")) { 447 return fp_list(unit, args); 448 } 449 450 /* BCM.0> fp init */ 451 if(!sal_strcasecmp(subcmd, "init")) { 452 retval = bcm_field_init(unit); 453 FP_CHECK_RETURN(unit, retval, "bcm_field_init"); 454 BCM_FIELD_QSET_INIT(qset); 455 return CMD_OK; 456 } 457 458 /* BCM.0> fp install - deprecated, use fp entry install */ 459 if(!sal_strcasecmp(subcmd, "install")) { 460 return fp_entry_install(unit, args); 461 } 462 463 /* BCM.0> fp range ... */ 464 if(!sal_strcasecmp(subcmd, "range")) { 465 return fp_range(unit, args); 466 } 467 468 /* BCM.0> fp resync */ 469 if(!sal_strcasecmp(subcmd, "resync")) { 470 retval = bcm_field_resync(unit); 471 FP_CHECK_RETURN(unit, retval, "bcm_field_resync"); 472 return CMD_OK; 473 } 474 475 /* BCM.0> fp policer ... */ 476 if(!sal_strcasecmp(subcmd, "policer")) { 477 return fp_policer(unit, args); 478 } 479 480 /* BCM.0> fp stat ... */ 481 if(!sal_strcasecmp(subcmd, "stat")) { 482 return fp_stat(unit, args); 483 } 484 485 /* BCM.0> fp data ... */ 486 if(!sal_strcasecmp(subcmd, "data")) { 487 return fp_data(unit, args); 488 } 489 490 /* BCM.0> fp aset ... */ 491 if(!sal_strcasecmp(subcmd, "aset")) { 492 return fp_aset(unit, args, &aset); 493 } 494 495 #ifdef BROADCOM_DEBUG 496 /* BCM.0> fp show ...*/ 497 if(!sal_strcasecmp(subcmd, "show")) { 498 if ((subcmd = ARG_GET(args)) != NULL) { 499 /* BCM.0> fp show entry ...*/ 500 if(!sal_strcasecmp(subcmd, "entry")) { 501 if ((subcmd = ARG_GET(args)) == NULL) { 502 return CMD_USAGE; 503 } else { 504 /* BCM.0> fp show entry 'eid' */ 505 eid = parse_integer(subcmd); 506 bcm_field_entry_dump(unit, eid); 507 return CMD_OK; 508 } 509 } 510 /* BCM.0> fp show group ...*/ 511 if(!sal_strcasecmp(subcmd, "group")) { 512 FP_GET_NUMB(gid, subcmd, args); 513 514 /* BCM.0> fp show group <id> brief */ 515 if (((subcmd = ARG_GET(args)) != NULL) && 516 (!sal_strcasecmp(subcmd, "brief"))) { 517 _field_group_dump_brief(unit, gid); 518 } else { 519 bcm_field_group_dump(unit, gid); 520 } 521 return CMD_OK; 522 } 523 /* BCM.0> fp show brief */ 524 if(!sal_strcasecmp(subcmd, "brief")) { 525 _field_dump_brief(unit, "FP"); 526 return CMD_OK; 527 } 528 /* BCM.0> fp show qset */ 529 if(!sal_strcasecmp(subcmd, "qset")) { 530 fp_qset_show(&qset); 531 return CMD_OK; 532 } 533 534 /* BCM.0> fp show wbcachesize */ 535 if(!sal_strcasecmp(subcmd, "wbcachesize")) { 536 if (SOC_IS_TOMAHAWKX(unit)) { 537 _field_calc_cache_size(unit); 538 } else { 539 LOG_CLI((BSL_META("Command not supported" 540 " for this device \n"))); 541 } 542 return CMD_OK; 543 } 544 545 /* BCM.0> fp show class ... */ 546 if(!sal_strcasecmp(subcmd, "class")) { 547 if ((subcmd = ARG_GET(args)) != NULL) { 548 /* BCM.0> fp show class brief */ 549 if (!sal_strcasecmp(subcmd, "brief")) { 550 _field_dump_class(unit, "CLASS", 0); 551 } 552 /* BCM.0> fp show class entry ... */ 553 if (!sal_strcasecmp(subcmd, "entry")) { 554 if((subcmd = ARG_GET(args)) == NULL) { 555 return CMD_USAGE; 556 } else { 557 /* BCM.0> fp show class entry 'eid' */ 558 eid = parse_integer(subcmd); 559 bcm_field_entry_dump(unit, eid); 560 return CMD_OK; 561 } 562 } 563 /* BCM.0> fp show class group ... */ 564 if (!sal_strcasecmp(subcmd, "group")) { 565 if((subcmd = ARG_GET(args)) == NULL) { 566 return CMD_USAGE; 567 } else { 568 gid = parse_integer(subcmd); 569 if (((subcmd = ARG_GET(args)) != NULL) && 570 (!sal_strcasecmp(subcmd, "brief"))) { 571 /* BCM.0> fp show group <id> brief */ 572 _field_group_dump_brief(unit, gid); 573 } else { 574 /* BCM.0> fp show class group 'gid' */ 575 bcm_field_group_dump(unit, gid); 576 } 577 return CMD_OK; 578 } 579 } 580 } else { 581 /* BCM.0> fp show class */ 582 _field_dump_class(unit, "CLASS", -1); 583 } 584 return CMD_OK; 585 } 586 /* BCM.0> fp show presel */ 587 if(!sal_strcasecmp(subcmd, "presel")) { 588 if ((subcmd = ARG_GET(args)) == NULL) { 589 _bcm_field_presel_dump(unit, -1, -1); 590 } else { 591 /* BCM.0> fp show presel 'id' */ 592 eid = parse_integer(subcmd); 593 _bcm_field_presel_dump(unit, eid, -1); 594 } 595 return CMD_OK; 596 } 597 return CMD_NFND; 598 } else { 599 /* BCM.0> fp show */ 600 bcm_field_show(unit, "FP"); 601 return CMD_OK; 602 } 603 } 604 #endif /* BROADCOM_DEBUG */ 605 return CMD_USAGE; 606 } 607 608 /* 609 * Function: 610 * _fp_qual_stage_name 611 * Purpose: 612 * Translate a stage qualifier enum value to a text string. 613 * Parameters: 614 * Enum value from bcm_field_stage_e. (ex.bcmFieldStageIngressEarly) 615 * Returns: 616 * Text name of indicated stage qualifier enum value. 617 */ 618 STATIC char * 619 _fp_qual_stage_name(bcm_field_stage_t stage) 620 { 621 /* Text names of the enumerated qualifier stage values. */ 622 /* All these are prefixed with "bcmFieldStage" */ 623 char *stage_text[] = BCM_FIELD_STAGE_STRINGS; 624 625 assert(COUNTOF(stage_text) == bcmFieldStageCount); 626 627 return (stage >= bcmFieldStageCount ? "??" : stage_text[stage]); 628 } 629 630 /* 631 * Function: 632 * _fp_qual_IpType_name 633 * Purpose: 634 * Translate IpType enum value to a text string. 635 * Parameters: 636 * Enum value from bcm_field_IpType_e. (ex.bcmFieldIpTypeNonIp) 637 * Returns: 638 * Text name of indicated IpType qualifier enum value. 639 */ 640 STATIC char * 641 _fp_qual_IpType_name(bcm_field_IpType_t type) 642 { 643 /* Text names of the enumerated qualifier IpType values. */ 644 /* All these are prefixed with "bcmFieldIpType" */ 645 char *IpType_text[bcmFieldIpTypeCount] = BCM_FIELD_IPTYPE_STRINGS; 646 647 assert(COUNTOF(IpType_text) == bcmFieldIpTypeCount); 648 649 return (type >= bcmFieldIpTypeCount ? "??" : IpType_text[type]); 650 } 651 652 /* 653 * Function: 654 * _fp_qual_L2Format_name 655 * Purpose: 656 * Translate L2Format enum value to a text string. 657 * Parameters: 658 * Enum value from bcm_field_L2Format_e. (ex.bcmFieldL2FormatSnap) 659 * Returns: 660 * Text name of indicated L2Format qualifier enum value. 661 */ 662 STATIC char * 663 _fp_qual_L2Format_name(bcm_field_L2Format_t type) 664 { 665 /* Text names of the enumerated qualifier L2Format values. */ 666 /* All these are prefixed with "bcmFieldL2Format" */ 667 char *L2Format_text[bcmFieldL2FormatCount] = BCM_FIELD_L2FORMAT_STRINGS; 668 669 assert(COUNTOF(L2Format_text) == bcmFieldL2FormatCount); 670 671 return (type >= bcmFieldL2FormatCount ? "??" : L2Format_text[type]); 672 } 673 674 /* 675 * Function: 676 * _fp_qual_IpProtocolCommon_name 677 * Purpose: 678 * Translate IpProtocolCommon enum value to a text string. 679 * Parameters: 680 * Enum value from bcm_field_IpProtocolCommon_e. 681 * (ex.bcmFieldIpProtocolCommonTcp) 682 * Returns: 683 * Text name of indicated IpProtocolCommon qualifier enum value. 684 */ 685 STATIC char * 686 _fp_qual_IpProtocolCommon_name(bcm_field_IpProtocolCommon_t type) 687 { 688 /* Text names of the enumerated qualifier IpProtocolCommon values. */ 689 /* All these are prefixed with "bcmFieldIpProtocolCommon" */ 690 char *IpProtocolCommon_text[bcmFieldIpProtocolCommonCount] = 691 BCM_FIELD_IPPROTOCOLCOMMON_STRINGS; 692 693 assert(COUNTOF(IpProtocolCommon_text) == bcmFieldIpProtocolCommonCount); 694 695 return (type >= bcmFieldIpProtocolCommonCount ? "??" : IpProtocolCommon_text[type]); 696 } 697 698 /* 699 * Function: 700 * _fp_control_name 701 * Purpose: 702 * Return text name of indicated control enum value. 703 */ 704 STATIC char * 705 _fp_control_name(bcm_field_control_t control) 706 { 707 /* Text names of Controls. These are used for debugging output and CLIs. 708 * Note that the order needs to match the bcm_field_control_t enum order. 709 */ 710 char *control_text[] = BCM_FIELD_CONTROL_STRINGS; 711 assert(COUNTOF(control_text) == bcmFieldControlCount); 712 713 return (control >= bcmFieldControlCount ? "??" : control_text[control]); 714 } 715 716 /* 717 * Function: 718 * Purpose: 719 * Parmameters: 720 * Returns: 721 */ 722 STATIC int 723 fp_action(int unit, args_t *args) 724 { 725 char* subcmd = NULL; 726 727 if ((subcmd = ARG_GET(args)) == NULL) { 728 return CMD_USAGE; 729 } 730 /* BCM.0> fp action ports ... */ 731 if(!sal_strcasecmp(subcmd, "ports")) { 732 return fp_action_ports(unit, args); 733 } 734 /* BCM.0> fp action mac ... */ 735 if(!sal_strcasecmp(subcmd, "mac")) { 736 return fp_action_mac(unit, args); 737 } 738 739 /* BCM.0> fp action oam_stat... */ 740 if(!sal_strcasecmp(subcmd, "oam_stat")) { 741 return fp_oam_action(unit, args); 742 } 743 744 /* BCM.0> fp action add ... */ 745 if(!sal_strcasecmp(subcmd, "add")) { 746 return fp_action_add(unit, args); 747 } 748 /* BCM.0> fp action get ... */ 749 if(!sal_strcasecmp(subcmd, "get")) { 750 return fp_action_get(unit, args); 751 } 752 /* BCM.0> fp action remove... */ 753 if(!sal_strcasecmp(subcmd, "remove")) { 754 return fp_action_remove(unit, args); 755 } 756 757 return CMD_USAGE; 758 } 759 760 STATIC int 761 fp_oam_action(int unit, args_t *args) 762 { 763 char *subcmd = NULL; 764 765 /* Read string after fp oam action */ 766 if ((subcmd = ARG_GET(args)) == NULL) { 767 return CMD_USAGE; 768 } 769 770 /* BCM.0> fp oam stat action add ...*/ 771 if(!sal_strcasecmp(subcmd, "add")) { 772 return fp_oam_action_add(unit, args); 773 } 774 775 /* BCM.0> fp oam stat action get ...*/ 776 if(!sal_strcasecmp(subcmd, "get")) { 777 return fp_oam_action_get(unit, args); 778 } 779 780 /* BCM.0> fp oam stat action delete ...*/ 781 if(!sal_strcasecmp(subcmd, "delete")) { 782 return fp_oam_action_delete(unit, args); 783 } 784 785 return CMD_USAGE; 786 } 787 788 /* 789 * Function: 790 * fp_oam_action_add 791 * Purpose: 792 * Fp oam action add 793 * Parameters: 794 * unit - BCM unit number 795 * args - command line arguments 796 * Returns: 797 */ 798 STATIC int 799 fp_oam_action_add (int unit, args_t *args) 800 { 801 parse_table_t pt; 802 int stat_obj = -1; 803 int stat_mode = -1; 804 int stat_action = -1; 805 cmd_result_t retval; 806 bcm_field_entry_t eid; 807 char *subcmd = NULL; 808 bcm_field_oam_stat_action_t oam_stat_action; 809 810 /* Read string after fp oam action */ 811 FP_GET_NUMB(eid, subcmd, args); 812 813 /* BCM.0> fp action oam_stat add stat_object=<StatObj> 814 * stat_mode=<mode_id> stat_action=<action>*/ 815 parse_table_init(unit, &pt); 816 parse_table_add(&pt, "object", PQ_DFL|PQ_INT, 0, &stat_obj, NULL); 817 parse_table_add(&pt, "mode", PQ_DFL | PQ_INT, 0, &stat_mode, NULL); 818 parse_table_add(&pt, "action", PQ_DFL|PQ_INT, 0, &stat_action, NULL); 819 if (!parseEndOk(args, &pt, &retval)) { 820 return retval; 821 } 822 823 oam_stat_action.stat_object = stat_obj; 824 oam_stat_action.stat_mode_id = stat_mode; 825 oam_stat_action.action = stat_action; 826 827 #ifdef BROADCOM_DEBUG 828 LOG_VERBOSE(BSL_LS_APPL_SHELL, 829 (BSL_META_U(unit, 830 "FP(unit %d) verb: action oam_stat add eid=%d, " 831 "stat_obj = %d stat_mode = %d stat_action = %d\n"), 832 unit, eid, stat_obj, stat_mode, stat_action)); 833 #endif 834 retval = bcm_field_oam_stat_action_add (unit, eid, &oam_stat_action); 835 FP_CHECK_RETURN(unit, retval, "bcm_field_oam_stat_action_add"); 836 837 return CMD_OK; 838 } 839 840 /* 841 * Function: 842 * fp_oam_action_get 843 * Purpose: 844 * Fp oam action get/get all 845 * Parameters: 846 * unit - BCM unit number 847 * args - command line arguments 848 * Returns: 849 */ 850 STATIC int 851 fp_oam_action_get (int unit, args_t *args) 852 { 853 parse_table_t pt; 854 int stat_obj = -1; 855 int stat_mode = -1; 856 int stat_action = -1; 857 cmd_result_t retval; 858 bcm_field_entry_t eid; 859 char *subcmd = NULL; 860 bcm_field_oam_stat_action_t oam_stat_action; 861 char *actionname[] = BCM_FIELD_STAT_ACTION; /* Stat action String */ 862 char *objectname[] = BCM_STAT_OBJECT; /* Stat Object String */ 863 864 if ((subcmd = ARG_CUR(args)) == NULL) { 865 return CMD_USAGE; 866 } 867 868 if(!sal_strcasecmp(subcmd, "all")) { 869 return fp_oam_action_get_all (unit, args); 870 } 871 872 /* Read string after fp oam action */ 873 FP_GET_NUMB(eid, subcmd, args); 874 875 /* BCM.0> fp action oam_stat add stat_object=<StatObj> 876 * stat_mode=<mode_id> stat_action=<action>*/ 877 parse_table_init(unit, &pt); 878 parse_table_add(&pt, "object", PQ_DFL|PQ_INT, 0, &stat_obj, NULL); 879 parse_table_add(&pt, "mode", PQ_DFL | PQ_INT, 0, &stat_mode, NULL); 880 parse_table_add(&pt, "action", PQ_DFL|PQ_INT, 0, &stat_action, NULL); 881 if (!parseEndOk(args, &pt, &retval)) { 882 return retval; 883 } 884 885 886 oam_stat_action.stat_object = stat_obj; 887 oam_stat_action.stat_mode_id = stat_mode; 888 oam_stat_action.action = stat_action; 889 890 #ifdef BROADCOM_DEBUG 891 LOG_VERBOSE(BSL_LS_APPL_SHELL, 892 (BSL_META_U(unit, 893 "FP(unit %d) verb: action oam_stat get eid=%d, " 894 "stat_obj = %d stat_mode= %d\n"), 895 unit, eid, stat_obj, stat_mode)); 896 #endif 897 898 retval = bcm_field_oam_stat_action_get (unit, eid, &oam_stat_action); 899 FP_CHECK_RETURN(unit, retval, "bcm_field_oam_stat_action_get"); 900 cli_out ("FP action oam_stat get:\r\n"); 901 cli_out ("-----------------------\r\n"); 902 cli_out (" Object: %s,Mode: %d,Action: %s\r\n", 903 objectname[oam_stat_action.stat_object], 904 oam_stat_action.stat_mode_id, 905 actionname[oam_stat_action.action]); 906 907 return CMD_OK; 908 } 909 910 /* 911 * Function: 912 * fp_oam_action_get_all 913 * Purpose: 914 * Fp oam action get all 915 * Parameters: 916 * unit - BCM unit number 917 * args - command line arguments 918 * Returns: 919 */ 920 STATIC int 921 fp_oam_action_get_all (int unit, args_t *args) 922 { 923 cmd_result_t retval; 924 bcm_field_entry_t eid; 925 char *subcmd = NULL; 926 bcm_field_oam_stat_action_t oam_stat_action[3]; 927 int stat_action_cnt = 0; 928 int stat_action_max = 3; 929 int cnt = 0; 930 char *actionname[] = BCM_FIELD_STAT_ACTION; /* Stat action String */ 931 char *objectname[] = BCM_STAT_OBJECT; /* Stat Object String */ 932 933 934 if ((subcmd = ARG_GET(args)) == NULL) { 935 return CMD_USAGE; 936 } 937 938 /* Read string after fp oam action */ 939 FP_GET_NUMB(eid, subcmd, args); 940 941 retval = bcm_field_oam_stat_action_get_all(unit, eid, 942 stat_action_max,oam_stat_action,&stat_action_cnt); 943 FP_CHECK_RETURN(unit, retval, "bcm_field_oam_stat_action_get"); 944 945 cli_out ("FP action oam_stat get all:\r\n"); 946 cli_out ("---------------------------\r\n"); 947 for (cnt = 0; cnt < stat_action_cnt; cnt++) { 948 cli_out (" Object: %s,Mode: %d,Action: %s\r\n", 949 objectname[oam_stat_action[cnt].stat_object], 950 oam_stat_action[cnt].stat_mode_id, 951 actionname[oam_stat_action[cnt].action]); 952 } 953 954 return CMD_OK; 955 } 956 957 /* 958 * Function: 959 * fp_oam_action_delete 960 * Purpose: 961 * Fp oam action delete/ delete all 962 * Parameters: 963 * unit - BCM unit number 964 * args - command line arguments 965 * Returns: 966 */ 967 STATIC int 968 fp_oam_action_delete (int unit, args_t *args) 969 { 970 parse_table_t pt; 971 int stat_obj = -1; 972 int stat_mode = -1; 973 int stat_action = -1; 974 cmd_result_t retval; 975 bcm_field_entry_t eid; 976 char *subcmd = NULL; 977 bcm_field_oam_stat_action_t oam_stat_action; 978 979 980 if ((subcmd = ARG_CUR(args)) == NULL) { 981 return CMD_USAGE; 982 } 983 984 if(!sal_strcasecmp(subcmd, "all")) { 985 subcmd = ARG_GET(args); 986 return fp_oam_action_delete_all (unit, args); 987 } 988 989 /* Read string after fp oam action */ 990 FP_GET_NUMB(eid, subcmd, args); 991 992 /* BCM.0> fp action oam_stat add stat_object=<StatObj> 993 * stat_mode=<mode_id> stat_action=<action>*/ 994 parse_table_init(unit, &pt); 995 parse_table_add(&pt, "object", PQ_DFL|PQ_INT, 0, &stat_obj, NULL); 996 parse_table_add(&pt, "mode", PQ_DFL | PQ_INT, 0, &stat_mode, NULL); 997 parse_table_add(&pt, "action", PQ_DFL|PQ_INT, 0, &stat_action, NULL); 998 if (!parseEndOk(args, &pt, &retval)) { 999 return retval; 1000 } 1001 1002 oam_stat_action.stat_object = stat_obj; 1003 oam_stat_action.stat_mode_id = stat_mode; 1004 oam_stat_action.action = stat_action; 1005 1006 #ifdef BROADCOM_DEBUG 1007 LOG_VERBOSE(BSL_LS_APPL_SHELL, 1008 (BSL_META_U(unit, 1009 "FP(unit %d) verb: action oam_stat delete eid=%d, " 1010 "stat_obj = %d stat_mode= %d\n"), 1011 unit, eid, stat_obj, stat_mode)); 1012 #endif 1013 1014 retval = bcm_field_oam_stat_action_delete (unit, eid, &oam_stat_action); 1015 FP_CHECK_RETURN(unit, retval, "bcm_field_oam_stat_action_delete"); 1016 1017 return CMD_OK; 1018 } 1019 1020 /* 1021 * Function: 1022 * fp_oam_action_delete_all 1023 * Purpose: 1024 * Fp oam action delete all 1025 * Parameters: 1026 * unit - BCM unit number 1027 * args - command line arguments 1028 * Returns: 1029 */ 1030 STATIC int 1031 fp_oam_action_delete_all (int unit, args_t *args) 1032 { 1033 bcm_field_entry_t eid; 1034 int retval; 1035 char* subcmd = NULL; 1036 1037 /* Read string after fp oam action */ 1038 FP_GET_NUMB(eid, subcmd, args); 1039 1040 if ((retval = bcm_field_oam_stat_action_delete_all(unit,eid)) != BCM_E_NONE) { 1041 cli_out("ERROR: bcm_field_oam_stat_action_delete_all(unit=%d)" 1042 " Entry=%d failed.(%s) \n", unit, eid, bcm_errmsg(retval)); 1043 return CMD_FAIL; 1044 } 1045 1046 return CMD_OK; 1047 } 1048 1049 1050 /* 1051 * Function: 1052 * fp_action_ports 1053 * Purpose: 1054 * FP action which takes pbmp as argument 1055 * Parmameters: 1056 * unit - BCM unit number 1057 * args - command line arguments 1058 * Returns: 1059 */ 1060 STATIC int 1061 fp_action_ports(int unit, args_t *args) 1062 { 1063 char* subcmd = NULL; 1064 1065 if ((subcmd = ARG_GET(args)) == NULL) { 1066 return CMD_USAGE; 1067 } 1068 /* BCM.0> fp action ports add ... */ 1069 if(!sal_strcasecmp(subcmd, "add")) { 1070 return fp_action_ports_add(unit, args); 1071 } 1072 /* BCM.0> fp action ports get ... */ 1073 if(!sal_strcasecmp(subcmd, "get")) { 1074 return fp_action_ports_get(unit, args); 1075 } 1076 1077 return CMD_USAGE; 1078 } 1079 1080 /* 1081 * Function: 1082 * fp_action_mac 1083 * Purpose: 1084 * FP action which takes bcm_mac_t as argument 1085 * Parmameters: 1086 * unit - BCM unit number 1087 * args - command line arguments 1088 * Returns: 1089 */ 1090 STATIC int 1091 fp_action_mac(int unit, args_t *args) 1092 { 1093 char* subcmd = NULL; 1094 1095 if ((subcmd = ARG_GET(args)) == NULL) { 1096 return CMD_USAGE; 1097 } 1098 /* BCM.0> fp action mac add ... */ 1099 if(!sal_strcasecmp(subcmd, "add")) { 1100 return fp_action_mac_add(unit, args); 1101 } 1102 /* BCM.0> fp action ports get ... */ 1103 if(!sal_strcasecmp(subcmd, "get")) { 1104 return fp_action_mac_get(unit, args); 1105 } 1106 return CMD_USAGE; 1107 } 1108 1109 /* 1110 * Function: 1111 * fp_action_add 1112 * Purpose: 1113 * Add an action to an entry. Can take action either in the form 1114 * of a string or digit corresponding to action order in 1115 * bcm_field_action_t enum. 1116 * Parmameters: 1117 * unit - BCM unit number 1118 * args - command line arguments 1119 * Returns: 1120 */ 1121 STATIC int 1122 fp_action_add(int unit, args_t *args) 1123 { 1124 char *subcmd = NULL; 1125 bcm_field_entry_t eid; 1126 bcm_field_action_t action; 1127 int retval; 1128 int p0 = 0, p1 = 0; 1129 int port; 1130 int my_modid = 0; 1131 bcm_pbmp_t pbmp; 1132 #ifdef BROADCOM_DEBUG 1133 char buf[BCM_FIELD_ACTION_WIDTH_MAX]; 1134 #endif /* BROADCOM_DEBUG */ 1135 1136 FP_GET_NUMB(eid, subcmd, args); 1137 if ((subcmd = ARG_GET(args)) == NULL) { 1138 return CMD_USAGE; 1139 } 1140 1141 if (isint(subcmd)) { 1142 action = parse_integer(subcmd); 1143 } else { 1144 action = parse_field_action(subcmd); 1145 if (action == bcmFieldActionCount) { 1146 fp_list_actions(unit, args); 1147 LOG_ERROR(BSL_LS_APPL_SHELL, 1148 (BSL_META_U(unit, 1149 "FP(unit %d) Error: Unknown action: %s\n"), unit, subcmd)); 1150 return CMD_FAIL; 1151 } 1152 } 1153 1154 /* Read the action parameters (p0 and p1).*/ 1155 switch (action) { 1156 case bcmFieldActionOffloadRedirect: 1157 case bcmFieldActionMirrorIngress: 1158 case bcmFieldActionMirrorEgress: 1159 FP_GET_NUMB(p0, subcmd, args); 1160 if ((subcmd = ARG_GET(args)) == NULL) { 1161 return CMD_USAGE; 1162 } 1163 1164 if (parse_bcm_port(unit, subcmd, &port) < 0) 1165 { 1166 LOG_ERROR(BSL_LS_APPL_SHELL, 1167 (BSL_META_U(unit, 1168 "FP(unit %d) Error: invalid port string: \"%s\"\n"), 1169 unit, subcmd)); 1170 1171 return CMD_FAIL; 1172 } 1173 1174 /* 1175 * Check if modid passed is local modid. 1176 */ 1177 if (BCM_FAILURE(bcm_stk_my_modid_get(unit, &my_modid))) { 1178 LOG_ERROR(BSL_LS_APPL_SHELL, 1179 (BSL_META_U(unit, 1180 "FP(unit %d) Error: Failed to retrieve modid info\"%s\"\n"), 1181 unit, subcmd)); 1182 return CMD_FAIL; 1183 } 1184 1185 if (!BCM_GPORT_IS_SET(port) && (my_modid == p0)) { 1186 /* 1187 * Construct GPORT value for the port. 1188 */ 1189 if (BCM_FAILURE(bcm_port_gport_get(unit, port, &p1))) 1190 { 1191 LOG_ERROR(BSL_LS_APPL_SHELL, 1192 (BSL_META_U(unit, 1193 "FP(unit %d) Error: Failed to convert port \"%s\" " 1194 "(physical port %d) to GPORT.\n"), unit, subcmd, port)); 1195 1196 return CMD_FAIL; 1197 } 1198 } else { 1199 /* 1200 * Already have gport or modid is not local modid 1201 * Do not construct GPORT. 1202 */ 1203 p1 = port; 1204 } 1205 break; 1206 case bcmFieldActionRedirectPbmp: 1207 case bcmFieldActionEgressMask: 1208 case bcmFieldActionEgressPortsAdd: 1209 case bcmFieldActionRedirectBcastPbmp: 1210 if (SOC_PORT_ADDR_MAX(unit) > 31) { 1211 1212 LOG_ERROR(BSL_LS_APPL_SHELL, 1213 (BSL_META_U(unit, 1214 "FP(unit %d) Error: Use \"fp action ports add\"" 1215 " command.\n"), unit)); 1216 return CMD_FAIL; 1217 1218 } else { 1219 1220 if ((subcmd = ARG_GET(args)) == NULL) { 1221 return CMD_USAGE; 1222 } 1223 1224 if (BCM_FAILURE(parse_bcm_pbmp(unit, subcmd, &pbmp))) { 1225 LOG_ERROR(BSL_LS_APPL_SHELL, 1226 (BSL_META_U(unit, 1227 "FP(unit %d) Error: Unrecognized port bitmap:" 1228 " \"%s\"\n"), unit, subcmd)); 1229 return CMD_FAIL; 1230 } 1231 1232 p0 = SOC_PBMP_WORD_GET(pbmp, 0); 1233 } 1234 break; 1235 case bcmFieldActionDropPrecedence: 1236 case bcmFieldActionYpDropPrecedence: 1237 case bcmFieldActionRpDropPrecedence: 1238 case bcmFieldActionGpDropPrecedence: 1239 if ((subcmd = ARG_GET(args)) == NULL) { 1240 return CMD_USAGE; 1241 } 1242 p0 = fp_lookup_color(subcmd); 1243 break; 1244 case bcmFieldActionTimeStampToCpu: 1245 case bcmFieldActionRpTimeStampToCpu: 1246 case bcmFieldActionYpTimeStampToCpu: 1247 case bcmFieldActionGpTimeStampToCpu: 1248 case bcmFieldActionCopyToCpu: 1249 case bcmFieldActionRpCopyToCpu: 1250 case bcmFieldActionYpCopyToCpu: 1251 case bcmFieldActionGpCopyToCpu: 1252 case bcmFieldActionRedirect: 1253 case bcmFieldActionPfcTx: 1254 FP_GET_NUMB(p0, subcmd, args); 1255 FP_GET_NUMB(p1, subcmd, args); 1256 break; 1257 case bcmFieldActionTosNew: 1258 case bcmFieldActionDscpNew: 1259 case bcmFieldActionRpDscpNew: 1260 case bcmFieldActionYpDscpNew: 1261 case bcmFieldActionGpDscpNew: 1262 case bcmFieldActionGpTosPrecedenceNew: 1263 case bcmFieldActionEcnNew: 1264 case bcmFieldActionRpEcnNew: 1265 case bcmFieldActionYpEcnNew: 1266 case bcmFieldActionGpEcnNew: 1267 case bcmFieldActionRedirectTrunk: 1268 case bcmFieldActionL3ChangeVlan: 1269 case bcmFieldActionL3ChangeMacDa: 1270 case bcmFieldActionL3Switch: 1271 case bcmFieldActionMultipathHash: 1272 case bcmFieldActionAddClassTag: 1273 case bcmFieldActionCosQNew: 1274 case bcmFieldActionUcastCosQNew: 1275 case bcmFieldActionMcastCosQNew: 1276 case bcmFieldActionRpCosQNew: 1277 case bcmFieldActionYpCosQNew: 1278 case bcmFieldActionGpCosQNew: 1279 case bcmFieldActionCosQCpuNew: 1280 case bcmFieldActionServicePoolIdNew: 1281 case bcmFieldActionVlanCosQNew: 1282 case bcmFieldActionRpVlanCosQNew: 1283 case bcmFieldActionYpVlanCosQNew: 1284 case bcmFieldActionGpVlanCosQNew: 1285 case bcmFieldActionPrioPktNew: 1286 case bcmFieldActionRpPrioPktNew: 1287 case bcmFieldActionYpPrioPktNew: 1288 case bcmFieldActionGpPrioPktNew: 1289 case bcmFieldActionPrioIntNew: 1290 case bcmFieldActionRpPrioIntNew: 1291 case bcmFieldActionYpPrioIntNew: 1292 case bcmFieldActionGpPrioIntNew: 1293 case bcmFieldActionPrioPktAndIntNew: 1294 case bcmFieldActionRpPrioPktAndIntNew: 1295 case bcmFieldActionYpPrioPktAndIntNew: 1296 case bcmFieldActionGpPrioPktAndIntNew: 1297 case bcmFieldActionRpOuterVlanCfiNew: 1298 case bcmFieldActionYpOuterVlanCfiNew: 1299 case bcmFieldActionGpOuterVlanCfiNew: 1300 case bcmFieldActionOuterVlanCfiNew: 1301 case bcmFieldActionRpInnerVlanCfiNew: 1302 case bcmFieldActionYpInnerVlanCfiNew: 1303 case bcmFieldActionGpInnerVlanCfiNew: 1304 case bcmFieldActionInnerVlanCfiNew: 1305 case bcmFieldActionRpOuterVlanPrioNew: 1306 case bcmFieldActionYpOuterVlanPrioNew: 1307 case bcmFieldActionGpOuterVlanPrioNew: 1308 case bcmFieldActionOuterVlanPrioNew: 1309 case bcmFieldActionRpInnerVlanPrioNew: 1310 case bcmFieldActionYpInnerVlanPrioNew: 1311 case bcmFieldActionGpInnerVlanPrioNew: 1312 case bcmFieldActionInnerVlanPrioNew: 1313 case bcmFieldActionOuterTpidNew: 1314 case bcmFieldActionOuterVlanNew: 1315 case bcmFieldActionInnerVlanNew: 1316 case bcmFieldActionOuterVlanLookup: 1317 case bcmFieldActionOuterVlanAdd: 1318 case bcmFieldActionInnerVlanAdd: 1319 case bcmFieldActionClassDestSet: 1320 case bcmFieldActionClassSourceSet: 1321 case bcmFieldActionVrfSet: 1322 case bcmFieldActionColorIndependent: 1323 case bcmFieldActionRedirectIpmc: 1324 case bcmFieldActionRedirectMcast: 1325 case bcmFieldActionIncomingMplsPortSet: 1326 case bcmFieldActionOamUpMep: 1327 case bcmFieldActionOamTx: 1328 case bcmFieldActionOamLmepMdl: 1329 case bcmFieldActionOamServicePriMappingPtr: 1330 case bcmFieldActionOamLmBasePtr: 1331 case bcmFieldActionOamDmEnable: 1332 case bcmFieldActionOamLmEnable: 1333 case bcmFieldActionOamLmDmSampleEnable: 1334 case bcmFieldActionOamLmepEnable: 1335 case bcmFieldActionOamDmTimeFormat: 1336 case bcmFieldActionOamTagStatusCheck: 1337 case bcmFieldActionOamPbbteLookupEnable: 1338 case bcmFieldActionGpMcastCosQNew: 1339 case bcmFieldActionYpMcastCosQNew: 1340 case bcmFieldActionRpMcastCosQNew: 1341 case bcmFieldActionGpUcastCosQNew: 1342 case bcmFieldActionYpUcastCosQNew: 1343 case bcmFieldActionRpUcastCosQNew: 1344 case bcmFieldActionEgressClassSelect: 1345 case bcmFieldActionNewClassId: 1346 case bcmFieldActionHiGigClassSelect: 1347 case bcmFieldActionIngressGportSet: 1348 case bcmFieldActionVpnSet: 1349 case bcmFieldActionNatCancel: 1350 case bcmFieldActionNat: 1351 case bcmFieldActionNatEgressOverride: 1352 case bcmFieldActionFibreChanSrcBindEnable: 1353 case bcmFieldActionFibreChanFpmaPrefixCheckEnable: 1354 case bcmFieldActionFibreChanZoneCheckEnable: 1355 case bcmFieldActionFibreChanVsanId: 1356 case bcmFieldActionFibreChanZoneCheckActionCancel: 1357 case bcmFieldActionFibreChanIntVsanPri: 1358 case bcmFieldActionHashSelect0: 1359 case bcmFieldActionHashSelect1: 1360 case bcmFieldActionUnmodifiedPacketRedirectPort: 1361 case bcmFieldActionEtagNew: 1362 case bcmFieldActionPfcClassNew: 1363 case bcmFieldActionRpIntCongestionNotificationNew: 1364 case bcmFieldActionYpIntCongestionNotificationNew: 1365 case bcmFieldActionGpIntCongestionNotificationNew: 1366 case bcmFieldActionRpHGCongestionClassNew: 1367 case bcmFieldActionYpHGCongestionClassNew: 1368 case bcmFieldActionGpHGCongestionClassNew: 1369 case bcmFieldActionL3IngressSet: 1370 case bcmFieldActionVxlanHeaderBits8_31_Set: 1371 case bcmFieldActionVxlanHeaderBits56_63_Set: 1372 case bcmFieldActionVxlanHeaderFlags: 1373 case bcmFieldActionDscpMapNew: 1374 case bcmFieldActionChangeL2Fields: 1375 case bcmFieldActionStrength: 1376 case bcmFieldActionRedirectBufferPriority: 1377 case bcmFieldActionRedirectPrioIntNew: 1378 case bcmFieldActionRpRedirectPrioIntNew: 1379 case bcmFieldActionYpRedirectPrioIntNew: 1380 case bcmFieldActionGpRedirectPrioIntNew: 1381 case bcmFieldActionOamStatObjectSessionId: 1382 case bcmFieldActionOamLmCounterPoolId: 1383 case bcmFieldActionL3IngressStrengthSet: 1384 FP_GET_NUMB(p0, subcmd, args); 1385 break; 1386 case bcmFieldActionOamOlpHeaderAdd: 1387 if ((subcmd = ARG_GET(args)) == NULL) { 1388 return CMD_USAGE; 1389 } 1390 p0 = parse_field_olp_hdr_type(subcmd); 1391 break; 1392 case bcmFieldActionFabricQueue: 1393 case bcmFieldActionPortPrioIntCosQNew: 1394 case bcmFieldActionRpPortPrioIntCosQNew: 1395 case bcmFieldActionYpPortPrioIntCosQNew: 1396 case bcmFieldActionGpPortPrioIntCosQNew: 1397 case bcmFieldActionServicePoolIdPrecedenceNew: 1398 FP_GET_NUMB(p0, subcmd, args); 1399 FP_GET_NUMB(p1, subcmd, args); 1400 break; 1401 case bcmFieldActionSrcMacNew: 1402 case bcmFieldActionDstMacNew: 1403 case bcmFieldActionReplaceDstMac: 1404 case bcmFieldActionReplaceSrcMac: 1405 LOG_ERROR(BSL_LS_APPL_SHELL, \ 1406 (BSL_META_U(unit, \ 1407 "FP(unit %d) Error: Use \"fp action mac add\" \ 1408 command."), unit)); 1409 return CMD_FAIL; 1410 1411 case bcmFieldActionIngSampleEnable: 1412 case bcmFieldActionEgrSampleEnable: 1413 case bcmFieldActionRecoverableDropCancel: 1414 case bcmFieldActionEgressPbmpNullCopyToCpu: 1415 break; 1416 case bcmFieldActionRedirDropPrecedence: 1417 case bcmFieldActionYpRedirDropPrecedence: 1418 case bcmFieldActionRpRedirDropPrecedence: 1419 case bcmFieldActionGpRedirDropPrecedence: 1420 if ((subcmd = ARG_GET(args)) == NULL) { 1421 return CMD_USAGE; 1422 } 1423 p0 = fp_lookup_color(subcmd); 1424 break; 1425 case bcmFieldActionRedirectEgrNextHop: 1426 case bcmFieldActionSwitchEncap: 1427 FP_GET_NUMB(p0, subcmd, args); 1428 /* p1 is optional. */ 1429 if ((subcmd = ARG_GET(args)) != NULL) { 1430 p1 = parse_integer(subcmd); 1431 } 1432 break; 1433 case bcmFieldActionUcastQueueNew: 1434 case bcmFieldActionRpUcastQueueNew: 1435 case bcmFieldActionYpUcastQueueNew: 1436 case bcmFieldActionGpUcastQueueNew: 1437 FP_GET_NUMB(p0, subcmd, args); 1438 break; 1439 case bcmFieldActionIntCosUcastQueueNew: 1440 case bcmFieldActionRpIntCosUcastQueueNew: 1441 case bcmFieldActionYpIntCosUcastQueueNew: 1442 case bcmFieldActionGpIntCosUcastQueueNew: 1443 FP_GET_NUMB(p0, subcmd, args); 1444 FP_GET_NUMB(p1, subcmd, args); 1445 break; 1446 1447 case bcmFieldActionServicePrioIntCosQNew: 1448 case bcmFieldActionRpServicePrioIntCosQNew: 1449 case bcmFieldActionYpServicePrioIntCosQNew: 1450 case bcmFieldActionGpServicePrioIntCosQNew: 1451 case bcmFieldActionReplaceInnerVlanPriority: 1452 case bcmFieldActionReplaceOuterVlanPriority: 1453 FP_GET_NUMB(p0, subcmd, args); 1454 FP_GET_NUMB(p1, subcmd, args); 1455 break; 1456 case bcmFieldActionReplaceInnerVlan: 1457 case bcmFieldActionReplaceOuterVlan: 1458 case bcmFieldActionUseTunnelPayload: 1459 FP_GET_NUMB(p0, subcmd, args); 1460 break; 1461 case bcmFieldActionMplsLabel1ExpNew: 1462 case bcmFieldActionDgmThreshold: 1463 case bcmFieldActionDgmCost: 1464 case bcmFieldActionDgmBias: 1465 case bcmFieldActionMplsLookupEnable: 1466 case bcmFieldActionTerminationAllowed: 1467 case bcmFieldActionFlowtrackerGroupId: 1468 case bcmFieldActionFlowtrackerEnable: 1469 case bcmFieldActionFlowtrackerNewLearnEnable: 1470 case bcmFieldActionDlbEcmpMonitorEnable: 1471 FP_GET_NUMB(p0, subcmd, args); 1472 break; 1473 case bcmFieldActionRoeFrameTypeSet: 1474 if ((subcmd = ARG_GET(args)) == NULL) { 1475 return CMD_USAGE; 1476 } 1477 p0 = parse_field_roe_frame_type(subcmd); 1478 break; 1479 default: 1480 /* Use defaults of p0 and p1 for other actions */ 1481 break; 1482 } 1483 #ifdef BROADCOM_DEBUG 1484 LOG_VERBOSE(BSL_LS_APPL_SHELL, 1485 (BSL_META_U(unit, 1486 "FP(unit %d) verb: action add eid=%d, action=%s, p0=0x%x, p1=0x%x\n"), 1487 unit, eid, format_field_action(buf, action, 1), p0, p1)); 1488 #endif 1489 retval = bcm_field_action_add(unit, eid, action, p0, p1); 1490 FP_CHECK_RETURN(unit, retval, "bcm_field_action_add"); 1491 1492 return CMD_OK; 1493 } 1494 1495 /* 1496 * Function: 1497 * fp_action_ports_add 1498 * Purpose: 1499 * FP action add which takes pbmp as argument 1500 * Parmameters: 1501 * unit - BCM unit number 1502 * args - command line arguments 1503 * Returns: 1504 */ 1505 STATIC int 1506 fp_action_ports_add(int unit, args_t *args) 1507 { 1508 char *subcmd = NULL; 1509 bcm_field_entry_t eid; 1510 bcm_field_action_t action; 1511 int retval; 1512 bcm_pbmp_t pbmp; 1513 #ifdef BROADCOM_DEBUG 1514 char buf[BCM_FIELD_ACTION_WIDTH_MAX]; 1515 char buf_pbmp[SOC_PBMP_FMT_LEN]; 1516 #endif /* BROADCOM_DEBUG */ 1517 1518 FP_GET_NUMB(eid, subcmd, args); 1519 if ((subcmd = ARG_GET(args)) == NULL) { 1520 return CMD_USAGE; 1521 } 1522 1523 if (isint(subcmd)) { 1524 action = parse_integer(subcmd); 1525 } else { 1526 action = parse_field_action(subcmd); 1527 if (action == bcmFieldActionCount) { 1528 LOG_ERROR(BSL_LS_APPL_SHELL, 1529 (BSL_META_U(unit, 1530 "FP(unit %d) Error: Unknown action: %s\n"), unit, subcmd)); 1531 return CMD_FAIL; 1532 } 1533 } 1534 1535 if ((action != bcmFieldActionRedirectPbmp) && 1536 (action != bcmFieldActionEgressPortsAdd) && 1537 (action != bcmFieldActionEgressMask) && 1538 (action != bcmFieldActionRedirectBcastPbmp)) { 1539 LOG_ERROR(BSL_LS_APPL_SHELL, 1540 (BSL_META_U(unit, 1541 "FP(unit %d) Error: Unrecognized action\n"), unit)); 1542 return CMD_FAIL; 1543 } 1544 1545 /* Read the action parameters pbmp.*/ 1546 if ((subcmd = ARG_GET(args)) == NULL) { 1547 return CMD_USAGE; 1548 } else if (parse_bcm_pbmp(unit, subcmd, &pbmp) < 0) { 1549 LOG_ERROR(BSL_LS_APPL_SHELL, 1550 (BSL_META_U(unit, 1551 "FP(unit %d) Error: %s Error: unrecognized port bitmap: %s\n"), 1552 unit, ARG_CMD(args), subcmd)); 1553 return CMD_FAIL; 1554 } 1555 #ifdef BROADCOM_DEBUG 1556 LOG_VERBOSE(BSL_LS_APPL_SHELL, 1557 (BSL_META_U(unit, 1558 "FP(unit %d) verb: action ports add eid=%d, action=%s, pbmp=%s\n"), 1559 unit, eid, format_field_action(buf, action, 1), 1560 format_pbmp(unit, buf_pbmp, sizeof(buf_pbmp), pbmp))); 1561 #endif 1562 retval = bcm_field_action_ports_add(unit, eid, action, pbmp); 1563 FP_CHECK_RETURN(unit, retval, "bcm_field_action_ports_add"); 1564 1565 return CMD_OK; 1566 } 1567 1568 /* 1569 * Function: 1570 * fp_action_mac_add 1571 * Purpose: 1572 * FP action add which takes bcm_mac_t as argument 1573 * Parmameters: 1574 * unit - BCM unit number 1575 * args - command line arguments 1576 * Returns: 1577 */ 1578 STATIC int 1579 fp_action_mac_add(int unit, args_t *args) 1580 { 1581 char *subcmd = NULL; 1582 bcm_field_entry_t eid; 1583 bcm_field_action_t action; 1584 int retval; 1585 bcm_mac_t mac; 1586 1587 FP_GET_NUMB(eid, subcmd, args); 1588 if ((subcmd = ARG_GET(args)) == NULL) { 1589 return CMD_USAGE; 1590 } 1591 1592 if (isint(subcmd)) { 1593 action = parse_integer(subcmd); 1594 } else { 1595 action = parse_field_action(subcmd); 1596 if (action == bcmFieldActionCount) { 1597 LOG_ERROR(BSL_LS_APPL_SHELL, 1598 (BSL_META_U(unit, 1599 "FP(unit %d) Error: Unknown action: %s\n"), unit, subcmd)); 1600 return CMD_FAIL; 1601 } 1602 } 1603 1604 if ((action != bcmFieldActionSrcMacNew) && 1605 (action != bcmFieldActionDstMacNew) && 1606 (action != bcmFieldActionReplaceSrcMac) && 1607 (action != bcmFieldActionReplaceDstMac)) { 1608 LOG_ERROR(BSL_LS_APPL_SHELL, 1609 (BSL_META_U(unit, 1610 "FP(unit %d) Error: Unrecognized action\n"), unit)); 1611 return CMD_FAIL; 1612 } 1613 1614 /* parse mac address. */ 1615 FP_GET_MAC(mac, subcmd, args); 1616 1617 retval = bcm_field_action_mac_add(unit, eid, action, mac); 1618 FP_CHECK_RETURN(unit, retval, "bcm_field_action_ports_add"); 1619 1620 return CMD_OK; 1621 } 1622 1623 /* 1624 * Function: 1625 * Purpose: 1626 * Parmameters: 1627 * Returns: 1628 */ 1629 STATIC int 1630 fp_lookup_color(char *qual_str) { 1631 assert(qual_str != NULL); 1632 1633 if (isint(qual_str)) { 1634 return parse_integer(qual_str); 1635 } else if (!sal_strcasecmp(qual_str, "preserve")) { 1636 return BCM_FIELD_COLOR_PRESERVE; 1637 } else if (!sal_strcasecmp(qual_str, "green")) { 1638 return BCM_FIELD_COLOR_GREEN; 1639 } else if (!sal_strcasecmp(qual_str, "yellow")) { 1640 return BCM_FIELD_COLOR_YELLOW; 1641 } else if (!sal_strcasecmp(qual_str, "red")) { 1642 return BCM_FIELD_COLOR_RED; 1643 } 1644 1645 return -1; 1646 } 1647 1648 /* 1649 * Function: 1650 * Purpose: 1651 * Parmameters: 1652 * Returns: 1653 */ 1654 STATIC int 1655 fp_action_get(int unit, args_t *args) 1656 { 1657 char* subcmd = NULL; 1658 bcm_field_entry_t eid; 1659 int retval; 1660 bcm_field_action_t action; 1661 uint32 p0 = 0, p1 = 0; 1662 char buf[BCM_FIELD_ACTION_WIDTH_MAX]; 1663 1664 FP_GET_NUMB(eid, subcmd, args); 1665 if ((subcmd = ARG_GET(args)) == NULL) { 1666 return CMD_USAGE; 1667 } 1668 1669 if (isint(subcmd)) { 1670 action = parse_integer(subcmd); 1671 } else { 1672 action = parse_field_action(subcmd); 1673 if (action == bcmFieldActionCount) { 1674 LOG_ERROR(BSL_LS_APPL_SHELL, 1675 (BSL_META_U(unit, 1676 "FP(unit %d) Error: Unknown action: %s\n"), unit, subcmd)); 1677 return CMD_FAIL; 1678 } 1679 } 1680 1681 retval = bcm_field_action_get(unit, eid, action, &p0, &p1); 1682 FP_CHECK_RETURN(unit, retval, "bcm_field_action_get"); 1683 cli_out("FP action get: action=%s, p0=%d, p1=%d\n", 1684 format_field_action(buf, action, 1), p0, p1); 1685 1686 return CMD_OK; 1687 } 1688 1689 /* 1690 * Function: 1691 * fp_action_ports_get 1692 * Purpose: 1693 * FP action get which takes pbmp as argument 1694 * Parmameters: 1695 * unit - BCM unit number 1696 * args - command line arguments 1697 * Returns: 1698 */ 1699 STATIC int 1700 fp_action_ports_get(int unit, args_t *args) 1701 { 1702 char* subcmd = NULL; 1703 bcm_field_entry_t eid; 1704 int retval; 1705 bcm_field_action_t action; 1706 bcm_pbmp_t pbmp; 1707 char buf[BCM_FIELD_ACTION_WIDTH_MAX]; 1708 char buf_pbmp[SOC_PBMP_FMT_LEN]; 1709 1710 FP_GET_NUMB(eid, subcmd, args); 1711 if ((subcmd = ARG_GET(args)) == NULL) { 1712 return CMD_USAGE; 1713 } 1714 1715 if (isint(subcmd)) { 1716 action = parse_integer(subcmd); 1717 } else { 1718 action = parse_field_action(subcmd); 1719 if (action == bcmFieldActionCount) { 1720 LOG_ERROR(BSL_LS_APPL_SHELL, 1721 (BSL_META_U(unit, 1722 "FP(unit %d) Error: Unknown action: %s\n"), unit, subcmd)); 1723 return CMD_FAIL; 1724 } 1725 } 1726 1727 if ((action != bcmFieldActionRedirectPbmp) && 1728 (action != bcmFieldActionEgressPortsAdd) && 1729 (action != bcmFieldActionEgressMask)) { 1730 LOG_ERROR(BSL_LS_APPL_SHELL, 1731 (BSL_META_U(unit, 1732 "FP(unit %d) Error: Unrecognized action\n"), unit)); 1733 return CMD_FAIL; 1734 } 1735 1736 retval = bcm_field_action_ports_get(unit, eid, action, &pbmp); 1737 FP_CHECK_RETURN(unit, retval, "bcm_field_action_ports_get"); 1738 cli_out("FP action ports get: action=%s, pbmp=%s\n", 1739 format_field_action(buf, action, 1), 1740 SOC_PBMP_FMT(pbmp, buf_pbmp)); 1741 1742 return CMD_OK; 1743 } 1744 1745 /* 1746 * Function: 1747 * fp_action_mac_get 1748 * Purpose: 1749 * FP action get which takes pbmp as argument 1750 * Parmameters: 1751 * unit - BCM unit number 1752 * args - command line arguments 1753 * Returns: 1754 */ 1755 STATIC int 1756 fp_action_mac_get(int unit, args_t *args) 1757 { 1758 char* subcmd = NULL; 1759 char mac_str[SAL_MACADDR_STR_LEN]; 1760 char buf[BCM_FIELD_ACTION_WIDTH_MAX]; 1761 bcm_field_entry_t eid; 1762 int retval; 1763 bcm_field_action_t action; 1764 bcm_mac_t mac; 1765 1766 FP_GET_NUMB(eid, subcmd, args); 1767 if ((subcmd = ARG_GET(args)) == NULL) { 1768 return CMD_USAGE; 1769 } 1770 1771 if (isint(subcmd)) { 1772 action = parse_integer(subcmd); 1773 } else { 1774 action = parse_field_action(subcmd); 1775 if (action == bcmFieldActionCount) { 1776 LOG_ERROR(BSL_LS_APPL_SHELL, 1777 (BSL_META_U(unit, 1778 "FP(unit %d) Error: Unknown action: %s\n"), unit, subcmd)); 1779 return CMD_FAIL; 1780 } 1781 } 1782 1783 if ((action != bcmFieldActionSrcMacNew) && 1784 (action != bcmFieldActionDstMacNew) && 1785 (action != bcmFieldActionReplaceSrcMac) & 1786 (action != bcmFieldActionReplaceDstMac)) { 1787 LOG_ERROR(BSL_LS_APPL_SHELL, 1788 (BSL_META_U(unit, 1789 "FP(unit %d) Error: Unrecognized action: %s\n"), unit, subcmd)); 1790 return CMD_FAIL; 1791 } 1792 1793 retval = bcm_field_action_mac_get(unit, eid, action, &mac); 1794 FP_CHECK_RETURN(unit, retval, "bcm_field_action_mac_get"); 1795 format_macaddr(mac_str, mac); 1796 cli_out("FP action mac get: action=%s, mac=%s\n", 1797 format_field_action(buf, action, 1), mac_str); 1798 return CMD_OK; 1799 } 1800 1801 /* 1802 * Function: 1803 * Purpose: 1804 * Parmameters: 1805 * Returns: 1806 */ 1807 STATIC int 1808 fp_action_remove(int unit, args_t *args) 1809 { 1810 char* subcmd = NULL; 1811 bcm_field_entry_t eid; 1812 int retval; 1813 bcm_field_action_t action; 1814 1815 1816 FP_GET_NUMB(eid, subcmd, args); 1817 1818 if ((subcmd = ARG_GET(args)) == NULL) { 1819 retval = bcm_field_action_remove_all(unit, eid); 1820 FP_CHECK_RETURN(unit, retval, "bcm_field_action_remove_all"); 1821 } else { 1822 if (isint(subcmd)) { 1823 action = parse_integer(subcmd); 1824 } else { 1825 action = parse_field_action(subcmd); 1826 if (action == bcmFieldActionCount) { 1827 LOG_ERROR(BSL_LS_APPL_SHELL, 1828 (BSL_META_U(unit, 1829 "FP(unit %d) Error: Unrecognized action: %s\n"), unit, subcmd)); 1830 return CMD_FAIL; 1831 } 1832 } 1833 retval = bcm_field_action_remove(unit, eid, action); 1834 FP_CHECK_RETURN(unit, retval, "bcm_field_action_remove"); 1835 } 1836 1837 return CMD_OK; 1838 } 1839 1840 /* 1841 * Function: 1842 * fp_control 1843 * Purpose: 1844 * Set/Get field control values. 1845 * Parmameters: 1846 * Returns: 1847 */ 1848 STATIC int 1849 fp_control(int unit, args_t *args) 1850 { 1851 char* subcmd = NULL; 1852 bcm_field_control_t element; 1853 uint32 status = 0; 1854 int retval = 0; 1855 1856 if ((subcmd = ARG_GET(args)) == NULL) { 1857 return CMD_USAGE; 1858 } 1859 1860 if (isint(subcmd)) { 1861 element = parse_integer(subcmd); 1862 } else { 1863 fp_lookup_control(subcmd, &element); 1864 if (element == bcmFieldControlCount) { 1865 LOG_ERROR(BSL_LS_APPL_SHELL, 1866 (BSL_META_U(unit, 1867 "FP(unit %d) Error: Unknown FP control: %s\n"), unit, subcmd)); 1868 return CMD_FAIL; 1869 } 1870 } 1871 1872 if ((subcmd = ARG_GET(args)) == NULL) { 1873 /* BCM.0> fp control <control_number>*/ 1874 LOG_VERBOSE(BSL_LS_APPL_SHELL, 1875 (BSL_META_U(unit, 1876 "FP(unit %d) verb: bcm_field_control_get(element=%s)\n"), 1877 unit, _fp_control_name(element))); 1878 retval = bcm_field_control_get(unit, element, &status); 1879 FP_CHECK_RETURN(unit, retval, "bcm_field_control_get"); 1880 cli_out("FP element=%s: status=%d\n", _fp_control_name(element), status); 1881 } else { 1882 /* BCM.0> fp control <control_number> <status>*/ 1883 if (element == bcmFieldControlStage && !isint(subcmd)) { 1884 status = fp_lookup_stage(subcmd); 1885 if (status == bcmFieldStageCount) { 1886 LOG_ERROR(BSL_LS_APPL_SHELL, 1887 (BSL_META_U(unit, 1888 "FP(unit %d) Error: Unknown stage: %s\n"), unit, subcmd)); 1889 return CMD_FAIL; 1890 } 1891 } else { 1892 status = parse_integer(subcmd); 1893 } 1894 LOG_VERBOSE(BSL_LS_APPL_SHELL, 1895 (BSL_META_U(unit, 1896 "FP(unit %d) verb: bcm_field_control_set(element=%s, status=%d)\n"), 1897 unit, _fp_control_name(element), status)); 1898 retval = bcm_field_control_set(unit, element, status); 1899 FP_CHECK_RETURN(unit, retval, "bcm_field_control_set"); 1900 } 1901 return CMD_OK; 1902 } 1903 1904 /* 1905 * Function: 1906 * Purpose: 1907 * Parmameters: 1908 * Returns: 1909 */ 1910 STATIC int 1911 fp_entry(int unit, args_t *args) 1912 { 1913 char* subcmd = NULL; 1914 1915 if ((subcmd = ARG_GET(args)) == NULL) { 1916 return CMD_USAGE; 1917 } 1918 1919 /* BCM.0> fp entry create ... */ 1920 if(!sal_strcasecmp(subcmd, "create")) { 1921 return fp_entry_create(unit, args); 1922 } 1923 /* BCM.0> fp entry copy ... */ 1924 if(!sal_strcasecmp(subcmd, "copy")) { 1925 return fp_entry_copy(unit, args); 1926 } 1927 /* BCM.0> fp entry destroy ... */ 1928 if(!sal_strcasecmp(subcmd, "destroy")) { 1929 return fp_entry_destroy(unit, args); 1930 } 1931 /* BCM.0> fp entry install ... */ 1932 if(!sal_strcasecmp(subcmd, "install")) { 1933 return fp_entry_install(unit, args); 1934 } 1935 /* BCM.0> fp entry reinstall ... */ 1936 if(!sal_strcasecmp(subcmd, "reinstall")) { 1937 return fp_entry_reinstall(unit, args); 1938 } 1939 /* BCM.0> fp entry remove ... */ 1940 if(!sal_strcasecmp(subcmd, "remove")) { 1941 return fp_entry_remove(unit, args); 1942 } 1943 /* BCM.0> fp entry enable ... */ 1944 if(!sal_strcasecmp(subcmd, "enable")) { 1945 return fp_entry_enable(unit, args); 1946 } 1947 /* BCM.0> fp entry disable ... */ 1948 if(!sal_strcasecmp(subcmd, "disable")) { 1949 return fp_entry_disable(unit, args); 1950 } 1951 /* BCM.0> fp entry prio ... */ 1952 if(!sal_strcasecmp(subcmd, "prio")) { 1953 return fp_entry_prio(unit, args); 1954 } 1955 1956 /* BCM.0> fp entry oper ... */ 1957 if(!sal_strcasecmp(subcmd, "oper")) { 1958 return fp_entry_oper(unit, args); 1959 } 1960 return CMD_USAGE; 1961 } 1962 1963 /* 1964 * Function: 1965 * Purpose: 1966 * Parmameters: 1967 * Returns: 1968 */ 1969 STATIC int 1970 fp_entry_create(int unit, args_t *args) 1971 { 1972 int retval = CMD_OK; 1973 char* subcmd = NULL; 1974 bcm_field_group_t gid; 1975 bcm_field_entry_t eid; 1976 1977 FP_GET_NUMB(gid, subcmd, args); 1978 1979 if ((subcmd = ARG_GET(args)) == NULL) { 1980 /* BCM.0> fp entry create 'gid' */ 1981 LOG_VERBOSE(BSL_LS_APPL_SHELL, 1982 (BSL_META_U(unit, 1983 "FP(unit %d) verb: _entry_create gid=%d\n"), unit, gid)); 1984 retval = bcm_field_entry_create(unit, gid, &eid); 1985 FP_CHECK_RETURN(unit, retval, "bcm_field_entry_create"); 1986 } else { 1987 /* BCM.0> fp entry create 'gid' 'eid' */ 1988 eid = parse_integer(subcmd); 1989 LOG_VERBOSE(BSL_LS_APPL_SHELL, 1990 (BSL_META_U(unit, 1991 "FP(unit %d) verb: _entry_create gid=%d, eid=%d\n"), unit, gid, eid)); 1992 retval = bcm_field_entry_create_id(unit, gid, eid); 1993 FP_CHECK_RETURN(unit, retval, "bcm_field_entry_create_id"); 1994 } 1995 return CMD_OK; 1996 } 1997 1998 /* 1999 * Function: 2000 * Purpose: 2001 * Parmameters: 2002 * Returns: 2003 */ 2004 STATIC int 2005 fp_entry_copy(int unit, args_t *args) 2006 { 2007 int retval = CMD_OK; 2008 char* subcmd = NULL; 2009 bcm_field_entry_t src_eid, dst_eid = -111; 2010 2011 FP_GET_NUMB(src_eid, subcmd, args); 2012 subcmd = ARG_GET(args); 2013 2014 if (subcmd ) { 2015 /* BCM.0> fp entry copy 'src_eid' 'dst_eid' */ 2016 dst_eid = parse_integer(subcmd); 2017 LOG_VERBOSE(BSL_LS_APPL_SHELL, 2018 (BSL_META_U(unit, 2019 "FP(unit %d) verb: bcm_field_entry_copy_id(src_eid=%d, dst_eid=%d)\n"), 2020 unit, src_eid, dst_eid)); 2021 retval = bcm_field_entry_copy_id(unit, src_eid, dst_eid); 2022 FP_CHECK_RETURN(unit, retval, "bcm_field_entry_copy_id"); 2023 } else { 2024 /* BCM.0> fp entry copy 'src_eid' */ 2025 LOG_VERBOSE(BSL_LS_APPL_SHELL, 2026 (BSL_META_U(unit, 2027 "FP(unit %d) verb: bcm_field_entry_copy(src_eid=%d)\n"), unit, src_eid)); 2028 retval = bcm_field_entry_copy(unit, src_eid, &dst_eid); 2029 FP_CHECK_RETURN(unit, retval, "bcm_field_entry_copy"); 2030 } 2031 return CMD_OK; 2032 } 2033 2034 /* 2035 * Function: 2036 * fp_entry_oper 2037 * Purpose: 2038 * Perform entry backup, restore and backup copy free operations 2039 * Parmameters: 2040 * unit - (IN) BCM device number. 2041 * args - (IN) Command arguments 2042 * Returns: 2043 * CMD_XXX 2044 */ 2045 STATIC int 2046 fp_entry_oper(int unit, args_t *args) 2047 { 2048 int retval = CMD_OK; 2049 char* subcmd = NULL; 2050 bcm_field_entry_oper_t entry_oper; 2051 2052 bcm_field_entry_oper_t_init(&entry_oper); 2053 2054 FP_GET_NUMB(entry_oper.entry_id, subcmd, args); 2055 if ((subcmd = ARG_GET(args)) == NULL) { 2056 return CMD_USAGE; 2057 } 2058 2059 if(!sal_strcasecmp(subcmd, "backup")) { 2060 entry_oper.flags = BCM_FIELD_ENTRY_OPER_BACKUP; 2061 } else if(!sal_strcasecmp(subcmd, "restore")) { 2062 entry_oper.flags = BCM_FIELD_ENTRY_OPER_RESTORE; 2063 } else if(!sal_strcasecmp(subcmd, "cleanup")) { 2064 entry_oper.flags = BCM_FIELD_ENTRY_OPER_CLEANUP; 2065 } else { 2066 return CMD_USAGE; 2067 } 2068 2069 LOG_VERBOSE(BSL_LS_APPL_SHELL, 2070 (BSL_META_U(unit, 2071 "FP(unit %d) verb: bcm_field_entry_operation(eid=%d, oper=0x%x)\n"), 2072 unit, entry_oper.entry_id, entry_oper.flags)); 2073 2074 retval = bcm_field_entry_operation(unit, &entry_oper); 2075 FP_CHECK_RETURN(unit, retval, "bcm_field_entry_operation"); 2076 2077 return CMD_OK; 2078 } 2079 2080 /* 2081 * Function: 2082 * Purpose: 2083 * Parmameters: 2084 * Returns: 2085 */ 2086 STATIC int 2087 fp_entry_destroy(int unit, args_t *args) 2088 { 2089 int retval = CMD_OK; 2090 char* subcmd = NULL; 2091 bcm_field_entry_t eid; 2092 2093 if ((subcmd = ARG_GET(args)) == NULL) { 2094 LOG_VERBOSE(BSL_LS_APPL_SHELL, 2095 (BSL_META_U(unit, 2096 "FP(unit %d) verb: bcm_field_entry_destroy_all()\n"), unit)); 2097 retval = bcm_field_entry_destroy_all(unit); 2098 FP_CHECK_RETURN(unit, retval, "bcm_field_entry_destroy_all"); 2099 return CMD_OK; 2100 } else { 2101 eid = parse_integer(subcmd); 2102 LOG_VERBOSE(BSL_LS_APPL_SHELL, 2103 (BSL_META_U(unit, 2104 "FP(unit %d) verb: bcm_field_entry_destroy(eid=%d)\n"), unit, eid)); 2105 retval = bcm_field_entry_destroy(unit, eid); 2106 FP_CHECK_RETURN(unit, retval, "bcm_field_entry_destroy"); 2107 return CMD_OK; 2108 } 2109 return CMD_USAGE; 2110 } 2111 2112 /* 2113 * Function: 2114 * Purpose: 2115 * Parmameters: 2116 * Returns: 2117 */ 2118 STATIC int 2119 fp_entry_install(int unit, args_t *args) 2120 { 2121 int retval = CMD_OK; 2122 char* subcmd = NULL; 2123 bcm_field_entry_t eid; 2124 2125 /* BCM.0> fp detach 'eid' */ 2126 FP_GET_NUMB(eid, subcmd, args); 2127 2128 retval = bcm_field_entry_install(unit, eid); 2129 FP_CHECK_RETURN(unit, retval, "bcm_field_entry_install"); 2130 2131 return CMD_OK; 2132 } 2133 2134 /* 2135 * Function: 2136 * fp_entry_reinstall 2137 * Purpose: 2138 * Parmameters: 2139 * Returns: 2140 * CMD_OK 2141 */ 2142 STATIC int 2143 fp_entry_reinstall(int unit, args_t *args) 2144 { 2145 int retval = CMD_OK; 2146 char* subcmd = NULL; 2147 bcm_field_entry_t eid; 2148 2149 FP_GET_NUMB(eid, subcmd, args); 2150 2151 LOG_VERBOSE(BSL_LS_APPL_SHELL, 2152 (BSL_META_U(unit, 2153 "FP(unit %d) verb: _entry_reinstall eid=%d\n"), unit, eid)); 2154 retval = bcm_field_entry_reinstall(unit, eid); 2155 FP_CHECK_RETURN(unit, retval, "bcm_field_entry_reinstall"); 2156 return CMD_OK; 2157 } 2158 2159 /* 2160 * Function: 2161 * fp_entry_remove 2162 * Purpose: 2163 * Parmameters: 2164 * Returns: 2165 * CMD_OK 2166 */ 2167 STATIC int 2168 fp_entry_remove(int unit, args_t *args) 2169 { 2170 int retval = CMD_OK; 2171 char* subcmd = NULL; 2172 bcm_field_entry_t eid; 2173 2174 FP_GET_NUMB(eid, subcmd, args); 2175 2176 LOG_VERBOSE(BSL_LS_APPL_SHELL, 2177 (BSL_META_U(unit, 2178 "FP(unit %d) verb: _entry_remove eid=%d\n"), unit, eid)); 2179 retval = bcm_field_entry_remove(unit, eid); 2180 FP_CHECK_RETURN(unit, retval, "bcm_field_entry_remove"); 2181 return CMD_OK; 2182 } 2183 2184 /* 2185 * Function: 2186 * fp_entry_enable 2187 * Purpose: 2188 * To enable an entry in hardware. 2189 * Parmameters: 2190 * Returns: 2191 * CMD_OK 2192 */ 2193 STATIC int 2194 fp_entry_enable(int unit, args_t *args) 2195 { 2196 int retval = CMD_OK; 2197 char* subcmd = NULL; 2198 bcm_field_entry_t eid; 2199 2200 FP_GET_NUMB(eid, subcmd, args); 2201 2202 LOG_VERBOSE(BSL_LS_APPL_SHELL, 2203 (BSL_META_U(unit, 2204 "FP(unit %d) verb: _entry_enable_set eid=%d, en=T\n"), unit, eid)); 2205 retval = bcm_field_entry_enable_set(unit, eid, 1); 2206 FP_CHECK_RETURN(unit, retval, "bcm_field_entry_enable_set"); 2207 return CMD_OK; 2208 } 2209 2210 /* 2211 * Function: 2212 * fp_entry_disable 2213 * Purpose: 2214 * To disable an entry in hardware. 2215 * Parmameters: 2216 * Returns: 2217 * CMD_OK 2218 */ 2219 STATIC int 2220 fp_entry_disable(int unit, args_t *args) 2221 { 2222 int retval = CMD_OK; 2223 char* subcmd = NULL; 2224 bcm_field_entry_t eid; 2225 2226 FP_GET_NUMB(eid, subcmd, args); 2227 2228 LOG_VERBOSE(BSL_LS_APPL_SHELL, 2229 (BSL_META_U(unit, 2230 "FP(unit %d) verb: _entry_enable_set eid=%d, en=F\n"), unit, eid)); 2231 retval = bcm_field_entry_enable_set(unit, eid, 0); 2232 FP_CHECK_RETURN(unit, retval, "bcm_field_entry_enable_set"); 2233 return CMD_OK; 2234 } 2235 2236 /* 2237 * Function: 2238 * fp_entry_prio 2239 * Purpose: 2240 * CLI interface to bcm_field_entry_prio_get/set() 2241 * Parmameters: 2242 * Returns: 2243 * CMD_OK 2244 */ 2245 STATIC int 2246 fp_entry_prio(int unit, args_t *args) 2247 { 2248 int retval = CMD_OK; 2249 int prio; 2250 char* subcmd = NULL; 2251 bcm_field_entry_t eid; 2252 2253 FP_GET_NUMB(eid, subcmd, args); 2254 2255 /* BCM.0> fp entry prio <eid> */ 2256 if ((subcmd = ARG_GET(args)) == NULL) { 2257 LOG_VERBOSE(BSL_LS_APPL_SHELL, 2258 (BSL_META_U(unit, 2259 "FP(unit %d) verb: bcm_field_entry_prio_get(eid=%d)\n"), unit, eid)); 2260 retval = bcm_field_entry_prio_get(unit, eid, &prio); 2261 FP_CHECK_RETURN(unit, retval, "bcm_field_entry_prio_get"); 2262 cli_out("FP entry=%d: prio=%d\n", eid, prio); 2263 } else { 2264 /* BCM.0> fp entry prio <eid> [prio] */ 2265 if (isint(subcmd)) { 2266 prio = parse_integer(subcmd); 2267 } else { 2268 if(!sal_strcasecmp(subcmd, "highest")) { 2269 prio = BCM_FIELD_ENTRY_PRIO_HIGHEST; 2270 } else if(!sal_strcasecmp(subcmd, "lowest")) { 2271 prio = BCM_FIELD_ENTRY_PRIO_LOWEST; 2272 } else if(!sal_strcasecmp(subcmd, "dontcare")) { 2273 prio = BCM_FIELD_ENTRY_PRIO_DONT_CARE; 2274 } else if(!sal_strcasecmp(subcmd, "default")) { 2275 prio = BCM_FIELD_ENTRY_PRIO_DEFAULT; 2276 } else { 2277 return CMD_USAGE; 2278 } 2279 } 2280 2281 LOG_VERBOSE(BSL_LS_APPL_SHELL, 2282 (BSL_META_U(unit, 2283 "FP(unit %d) verb: bcm_field_entry_prio_set(eid=%d, prio=%d)\n"), 2284 unit, eid, prio)); 2285 retval = bcm_field_entry_prio_set(unit, eid, prio); 2286 FP_CHECK_RETURN(unit, retval, "bcm_field_entry_prio_set"); 2287 } 2288 2289 return CMD_OK; 2290 } 2291 2292 /* 2293 * Function: 2294 * Purpose: 2295 * Parmameters: 2296 * Returns: 2297 */ 2298 STATIC int 2299 fp_group(int unit, args_t *args, bcm_field_qset_t *qset) 2300 { 2301 char* subcmd = NULL; 2302 2303 if ((subcmd = ARG_GET(args)) == NULL) { 2304 return CMD_USAGE; 2305 } 2306 /* BCM.0> fp group create ... */ 2307 if(!sal_strcasecmp(subcmd, "create")) { 2308 return fp_group_create(unit, args, qset); 2309 } 2310 /* BCM.0> fp group destroy ... */ 2311 if(!sal_strcasecmp(subcmd, "destroy")) { 2312 return fp_group_destroy(unit, args); 2313 } 2314 2315 /* BCM.0> fp group get ... */ 2316 if(!sal_strcasecmp(subcmd, "get")) { 2317 return fp_group_get(unit, args); 2318 } 2319 2320 /* BCM.0> fp group set ... */ 2321 if(!sal_strcasecmp(subcmd, "set")) { 2322 return fp_group_set(unit, args, qset); 2323 } 2324 2325 /* BCM.0> fp group status ... */ 2326 if(!sal_strcasecmp(subcmd, "status")) { 2327 return fp_group_status_get(unit, args); 2328 } 2329 2330 /* BCM.0> fp group mode ... */ 2331 if(!sal_strcasecmp(subcmd, "mode")) { 2332 return fp_group_mode_get(unit, args); 2333 } 2334 2335 /* BCM.0> fp group lookup ... */ 2336 if(!sal_strcasecmp(subcmd, "lookup")) { 2337 return fp_group_lookup(unit, args); 2338 } 2339 2340 /* BCM.0> fp group compress ... */ 2341 if(!sal_strcasecmp(subcmd, "compress")) { 2342 return fp_group_compress(unit, args); 2343 } 2344 2345 return CMD_USAGE; 2346 } 2347 2348 /* 2349 * Function: 2350 * Purpose: 2351 * Parmameters: 2352 * Returns: 2353 */ 2354 STATIC int 2355 fp_group_create(int unit, args_t *args, bcm_field_qset_t *qset) 2356 { 2357 int retval = CMD_OK; 2358 char* subcmd = NULL; 2359 #ifdef BROADCOM_DEBUG 2360 char buf[FORMAT_PBMP_MAX]; 2361 #endif /* BROADCOM_DEBUG */ 2362 int pri; 2363 bcm_field_group_t gid; 2364 bcm_field_group_mode_t mode; 2365 bcm_pbmp_t pbmp; 2366 bcm_port_t port, dport; 2367 int count; 2368 bcm_field_group_config_t group_config; 2369 bcm_port_config_t pc; 2370 2371 FP_GET_NUMB(pri, subcmd, args); 2372 2373 if ((subcmd = ARG_GET(args)) == NULL) { 2374 /* BCM.0> fp group create 'prio' */ 2375 LOG_VERBOSE(BSL_LS_APPL_SHELL, 2376 (BSL_META_U(unit, 2377 "FP(unit %d) verb: _group_create pri=%d\n"), unit, pri)); 2378 retval = bcm_field_group_create(unit, *qset, pri, &gid); 2379 FP_CHECK_RETURN(unit, retval, "bcm_field_group_create"); 2380 } else { 2381 gid = parse_integer(subcmd); 2382 if ((subcmd = ARG_GET(args)) == NULL) { 2383 /* BCM.0> fp group create 'prio' 'gid' */ 2384 LOG_VERBOSE(BSL_LS_APPL_SHELL, 2385 (BSL_META_U(unit, 2386 "FP(unit %d) verb: _group_create_id pri=%d gid=%d\n"), 2387 unit, pri, gid)); 2388 retval = bcm_field_group_create_id(unit, *qset, pri, gid); 2389 FP_CHECK_RETURN(unit, retval, "bcm_field_group_create_id"); 2390 } else { 2391 /* BCM.0> fp group create 'prio' 'gid' 'mode' */ 2392 if (isint(subcmd)) { 2393 mode = parse_integer(subcmd); 2394 } else { 2395 mode = parse_field_group_mode(subcmd); 2396 if (mode == bcmFieldGroupModeCount) { 2397 LOG_ERROR(BSL_LS_APPL_SHELL, 2398 (BSL_META_U(unit, 2399 "FP(unit %d) Error: Unknown mode: %s\n"), unit, subcmd)); 2400 return CMD_FAIL; 2401 } 2402 } 2403 /* BCM.0> fp group create 'prio' 'gid' 'mode' 'pipe/pbmp' */ 2404 if ((subcmd = ARG_GET(args)) == NULL) { 2405 LOG_VERBOSE(BSL_LS_APPL_SHELL, 2406 (BSL_META_U(unit, 2407 "FP(unit %d) verb: _group_create_id pri=%d gid=%d, mode=%d\n"), 2408 unit, pri, gid, mode)); 2409 retval = bcm_field_group_create_mode_id(unit, *qset, pri, mode, 2410 gid); 2411 FP_CHECK_RETURN(unit, retval, "bcm_field_group_create_mode_id"); 2412 } 2413 else { 2414 bcm_field_group_config_t_init(&group_config); 2415 /* checking for pipe0/1/2/3 */ 2416 if ((0 == sal_strncasecmp(subcmd, "pipe", 4)) && 2417 soc_feature(unit, soc_feature_field_multi_pipe_support)) { 2418 bcm_port_config_t_init(&pc); 2419 if (bcm_port_config_get(unit, &pc) != BCM_E_NONE) { 2420 LOG_ERROR(BSL_LS_APPL_SHELL, 2421 (BSL_META_U(unit, 2422 "FP(unit %d) Error: %s: Error: bcm ports not initialized\n"), unit, 2423 ARG_CMD(args))); 2424 return CMD_FAIL; 2425 } 2426 /*set the config ports pipe number */ 2427 if (0 == sal_strncasecmp(&subcmd[5], "\0", 1)) { 2428 if (0 == sal_strncasecmp(&subcmd[4], "0", 1)) { 2429 group_config.ports = pc.per_pipe[0]; 2430 } else if (0 == sal_strncasecmp(&subcmd[4], "1", 1)) { 2431 group_config.ports = pc.per_pipe[1]; 2432 } else if (0 == sal_strncasecmp(&subcmd[4], "2", 1)) { 2433 group_config.ports = pc.per_pipe[2]; 2434 } else if (0 == sal_strncasecmp(&subcmd[4], "3", 1)) { 2435 group_config.ports = pc.per_pipe[3]; 2436 } else { 2437 LOG_ERROR(BSL_LS_APPL_SHELL, 2438 (BSL_META_U(unit, 2439 "FP(unit %d) Error: pipe0/1/2/3/are only valid.\n"), unit)); 2440 return CMD_FAIL; 2441 } 2442 } else { 2443 LOG_ERROR(BSL_LS_APPL_SHELL, 2444 (BSL_META_U(unit, 2445 "FP(unit %d) Error: pipe0/1/2/3/are only valid.\n"), unit)); 2446 return CMD_FAIL; 2447 } 2448 } 2449 else { 2450 /* pbmp validation */ 2451 if (BCM_FAILURE(parse_bcm_pbmp(unit, subcmd, &pbmp))) { 2452 LOG_ERROR(BSL_LS_APPL_SHELL, 2453 (BSL_META_U(unit, 2454 "FP(unit %d) Error: Unrecognized port bitmap: %s\n"), unit, subcmd)); 2455 return CMD_FAIL; 2456 } 2457 BCM_PBMP_COUNT(pbmp, count); 2458 if ((subcmd = ARG_GET(args)) == NULL) { 2459 if (count == 1) { 2460 DPORT_BCM_PBMP_ITER(unit, pbmp, dport, port) { 2461 #ifdef BROADCOM_DEBUG 2462 LOG_VERBOSE(BSL_LS_APPL_SHELL, 2463 (BSL_META_U(unit, 2464 "FP(unit %d) verb: _group_port_create_id " 2465 "pri=%d gid=%d, mode=%d port=%s\n"), unit, 2466 pri, gid, mode, 2467 format_pbmp(unit, buf, sizeof(buf), pbmp))); 2468 #endif 2469 retval = bcm_field_group_port_create_mode_id(unit, 2470 port, *qset, pri, mode, gid); 2471 FP_CHECK_RETURN(unit, retval, 2472 "bcm_field_group_ports_create_mode_id"); 2473 return CMD_OK; 2474 } 2475 } 2476 else { 2477 #ifdef BROADCOM_DEBUG 2478 LOG_VERBOSE(BSL_LS_APPL_SHELL, 2479 (BSL_META_U(unit, 2480 "FP(unit %d) verb: _group_ports_create_mode_id " 2481 "pri=%d gid=%d, mode=%d pbmp=%s\n"), unit, pri, 2482 gid, mode, 2483 format_pbmp(unit, buf,sizeof(buf), pbmp))); 2484 #endif 2485 retval = bcm_field_group_ports_create_mode_id(unit, 2486 pbmp, *qset, pri, mode, gid); 2487 FP_CHECK_RETURN(unit, retval, 2488 "bcm_field_group_ports_create_mode_id"); 2489 return CMD_OK; 2490 } 2491 } 2492 else { 2493 /* BCM.0> fp group create 'prio' 'gid' 'mode' 'pbmp' 'size' */ 2494 /* Size is also present. use config create function */ 2495 /* Set group pbmp value*/ 2496 SOC_PBMP_ASSIGN(group_config.ports, pbmp); 2497 /* Size checks */ 2498 if (0 == sal_strncasecmp(subcmd, "small", 5)) { 2499 group_config.flags |= BCM_FIELD_GROUP_CREATE_SMALL; 2500 } else if (0 == sal_strncasecmp(subcmd, "large", 5)) { 2501 group_config.flags |= BCM_FIELD_GROUP_CREATE_LARGE; 2502 } else { 2503 LOG_ERROR(BSL_LS_APPL_SHELL, 2504 (BSL_META_U(unit, 2505 "FP(unit %d) Error: Unknown size: %s." 2506 " size = [large | small]\n"), unit, subcmd)); 2507 return CMD_FAIL; 2508 } 2509 #ifdef BROADCOM_DEBUG 2510 LOG_VERBOSE(BSL_LS_APPL_SHELL, 2511 (BSL_META_U(unit, 2512 "FP(unit %d) verb: _group_config_create pri=%d " 2513 "gid=%d, mode=%d pbmp=%s size=%s\n"), unit, pri, 2514 gid, mode, 2515 format_pbmp(unit, buf,sizeof(buf), pbmp), 2516 (group_config.flags & BCM_FIELD_GROUP_CREATE_LARGE) 2517 ? "large" : "small")); 2518 #endif 2519 } 2520 } 2521 2522 /* Set group Qset value */ 2523 group_config.qset = *qset; 2524 2525 /* Set group priority value */ 2526 group_config.priority = pri; 2527 2528 /* Set group gid value and flag bit */ 2529 group_config.flags |= BCM_FIELD_GROUP_CREATE_WITH_ID; 2530 group_config.group = gid; 2531 2532 /* Set group mode value and flag bit */ 2533 group_config.flags |= BCM_FIELD_GROUP_CREATE_WITH_MODE; 2534 group_config.mode = mode; 2535 2536 /* Set group pbmp value and flag bit */ 2537 group_config.flags |= BCM_FIELD_GROUP_CREATE_WITH_PORT; 2538 2539 retval = bcm_field_group_config_create(unit, &group_config); 2540 FP_CHECK_RETURN(unit, retval, 2541 "bcm_field_group_config_create"); 2542 } 2543 } 2544 } 2545 return CMD_OK; 2546 } 2547 2548 /* 2549 * Function: 2550 * Purpose: 2551 * Parmameters: 2552 * Returns: 2553 */ 2554 STATIC int 2555 fp_group_destroy(int unit, args_t *args) 2556 { 2557 int retval = CMD_OK; 2558 char* subcmd = NULL; 2559 bcm_field_group_t gid; 2560 2561 FP_GET_NUMB(gid, subcmd, args); 2562 2563 /* BCM.0> fp group destroy 'gid' */ 2564 LOG_VERBOSE(BSL_LS_APPL_SHELL, 2565 (BSL_META_U(unit, 2566 "FP(unit %d) verb:_group_destroy gid=%d\n"), unit, gid)); 2567 retval = bcm_field_group_destroy(unit, gid); 2568 FP_CHECK_RETURN(unit, retval, "bcm_field_group_destroy"); 2569 2570 return CMD_OK; 2571 } 2572 2573 /* 2574 * Function: 2575 * Purpose: 2576 * Parmameters: 2577 * Returns: 2578 */ 2579 STATIC int 2580 fp_group_get(int unit, args_t *args) 2581 { 2582 int retval = CMD_OK; 2583 char* subcmd = NULL; 2584 bcm_field_group_t gid; 2585 bcm_field_qset_t qset; 2586 2587 FP_GET_NUMB(gid, subcmd, args); 2588 2589 /* BCM.0> fp group create 'prio' */ 2590 LOG_VERBOSE(BSL_LS_APPL_SHELL, 2591 (BSL_META_U(unit, 2592 "FP(unit %d) verb: _group_get gid=%d\n"), unit, gid)); 2593 retval = bcm_field_group_get(unit, gid, &qset); 2594 FP_CHECK_RETURN(unit, retval, "bcm_field_group_get"); 2595 fp_qset_show(&qset); 2596 return CMD_OK; 2597 } 2598 2599 /* 2600 * Function: 2601 * Purpose: 2602 * Parmameters: 2603 * Returns: 2604 */ 2605 STATIC int 2606 fp_range(int unit, args_t *args) 2607 { 2608 char* subcmd = NULL; 2609 2610 if ((subcmd = ARG_GET(args)) == NULL) { 2611 return CMD_USAGE; 2612 } 2613 /* BCM.0> fp range group create ... */ 2614 if(!sal_strcasecmp(subcmd, "group")) { 2615 if ((subcmd = ARG_GET(args)) == NULL) { 2616 return CMD_USAGE; 2617 } 2618 if(!sal_strcasecmp(subcmd, "create")) { 2619 return fp_range_group_create(unit, args); 2620 } 2621 } 2622 /* BCM.0> fp range create ... */ 2623 if(!sal_strcasecmp(subcmd, "create")) { 2624 return fp_range_create(unit, args); 2625 } 2626 /* BCM.0> fp range get ... */ 2627 if(!sal_strcasecmp(subcmd, "get")) { 2628 return fp_range_get(unit, args); 2629 } 2630 /* BCM.0> fp range destroy ... */ 2631 if(!sal_strcasecmp(subcmd, "destroy")) { 2632 return fp_range_destroy(unit, args); 2633 } 2634 return CMD_USAGE; 2635 } 2636 2637 /* 2638 * Function: 2639 * FP CLI function to create an FP range 2640 * Purpose: 2641 * Parmameters: 2642 * Returns: 2643 */ 2644 STATIC int 2645 fp_range_create(int unit, args_t *args) 2646 { 2647 int retval = CMD_OK; 2648 char* subcmd = NULL; 2649 bcm_field_range_t rid; 2650 bcm_l4_port_t min, max; 2651 uint32 flags; 2652 uint32 param[4]; 2653 2654 FP_GET_NUMB(param[0], subcmd, args); 2655 FP_GET_NUMB(param[1], subcmd, args); 2656 FP_GET_NUMB(param[2], subcmd, args); 2657 2658 if ((subcmd = ARG_GET(args)) == NULL) { 2659 /* BCM.0> fp range create 'flags' 'min' 'max' */ 2660 flags = param[0]; 2661 min = param[1]; 2662 max = param[2]; 2663 LOG_VERBOSE(BSL_LS_APPL_SHELL, 2664 (BSL_META_U(unit, 2665 "FP(unit %d) verb:_range_create flags=0x%x, min=%d, max=%d \n"), 2666 unit, flags, min, max)); 2667 retval = bcm_field_range_create(unit, &rid, flags, min, max); 2668 FP_CHECK_RETURN(unit, retval, "bcm_field_range_create"); 2669 } else { 2670 /* BCM.0> fp range create 'rid' 'flags' 'min' 'max' */ 2671 rid = param[0]; 2672 flags = param[1]; 2673 min = param[2]; 2674 max = parse_integer(subcmd); 2675 LOG_VERBOSE(BSL_LS_APPL_SHELL, 2676 (BSL_META_U(unit, 2677 "FP(unit %d) verb:_range_create_id rid=%d, flags=0x%x, min=%d, max=%d \n"), 2678 unit, rid, flags, min, max)); 2679 retval = bcm_field_range_create_id(unit, rid, flags, min, max); 2680 FP_CHECK_RETURN(unit, retval, "bcm_field_range_create_id"); 2681 } 2682 2683 return CMD_OK; 2684 } 2685 2686 /* 2687 * Function: 2688 * FP CLI function to create an FP range group 2689 * Purpose: 2690 * Parmameters: 2691 * Returns: 2692 */ 2693 STATIC int 2694 fp_range_group_create(int unit, args_t *args) 2695 { 2696 int retval = CMD_OK; 2697 char* subcmd = NULL; 2698 bcm_field_range_t rid; 2699 bcm_l4_port_t min, max; 2700 uint32 flags; 2701 bcm_if_group_t group; 2702 uint32 param[5]; 2703 2704 FP_GET_NUMB(param[0], subcmd, args); 2705 FP_GET_NUMB(param[1], subcmd, args); 2706 FP_GET_NUMB(param[2], subcmd, args); 2707 FP_GET_NUMB(param[3], subcmd, args); 2708 2709 if ((subcmd = ARG_GET(args)) == NULL) { 2710 /* BCM.0> fp range group create 'flags' 'min' 'max' */ 2711 flags = param[0]; 2712 min = param[1]; 2713 max = param[2]; 2714 group = param[3]; 2715 LOG_VERBOSE(BSL_LS_APPL_SHELL, 2716 (BSL_META_U(unit, 2717 "FP(unit %d) verb:_range_group_create flags=0x%x, min=%d, max=%d group=%d\n"), 2718 unit, flags, min, max, group)); 2719 retval = bcm_field_range_group_create(unit, &rid, flags, min, max, group); 2720 FP_CHECK_RETURN(unit, retval, "bcm_field_range_group_create"); 2721 } else { 2722 /* BCM.0> fp range group create 'rid' 'flags' 'min' 'max' */ 2723 rid = param[0]; 2724 flags = param[1]; 2725 min = param[2]; 2726 max = param[3]; 2727 group = parse_integer(subcmd); 2728 LOG_VERBOSE(BSL_LS_APPL_SHELL, 2729 (BSL_META_U(unit, 2730 "FP(unit %d) verb:_range_group_create_id rid=%d, flags=0x%x, min=%d, max=%d group=%d\n"), 2731 unit, rid, flags, min, max, group)); 2732 retval = bcm_field_range_group_create_id(unit, rid, flags, min, max, group); 2733 FP_CHECK_RETURN(unit, retval, "bcm_field_range_group_create_id"); 2734 } 2735 cli_out("RID %d created!\n", rid) ; 2736 2737 return CMD_OK; 2738 } 2739 2740 /* 2741 * Function: 2742 * Purpose: 2743 * Parmameters: 2744 * Returns: 2745 */ 2746 STATIC int 2747 fp_range_get(int unit, args_t *args) 2748 { 2749 int retval = CMD_OK; 2750 char* subcmd = NULL; 2751 int rid; 2752 bcm_l4_port_t min, max; 2753 uint32 flags; 2754 2755 FP_GET_NUMB(rid, subcmd, args); 2756 2757 /* BCM.0> fp range get 'rid' */ 2758 LOG_VERBOSE(BSL_LS_APPL_SHELL, 2759 (BSL_META_U(unit, 2760 "FP(unit %d) verb:fp_range_get 'rid=%d'\n"), unit, rid)); 2761 retval = bcm_field_range_get(unit, rid, &flags, &min, &max); 2762 FP_CHECK_RETURN(unit, retval, "bcm_field_range_get"); 2763 cli_out("FP range get: rid=%d, min=%d max=%d ", rid, min, max); 2764 cli_out("flags=0x%x%s%s%s%s\n", 2765 flags, 2766 flags & BCM_FIELD_RANGE_SRCPORT ? " SRCPORT" : "", 2767 flags & BCM_FIELD_RANGE_DSTPORT ? " DSTPORT" : "", 2768 flags & BCM_FIELD_RANGE_OUTER_VLAN? " OUTERVLAN" : "", 2769 flags & BCM_FIELD_RANGE_PACKET_LENGTH? " PACKET LEN" : ""); 2770 2771 return CMD_OK; 2772 } 2773 2774 /* 2775 * Function: 2776 * Purpose: 2777 * Parmameters: 2778 * Returns: 2779 */ 2780 STATIC int 2781 fp_range_destroy(int unit, args_t *args) 2782 { 2783 int retval = CMD_OK; 2784 char* subcmd = NULL; 2785 int rid; 2786 2787 FP_GET_NUMB(rid, subcmd, args); 2788 2789 /* BCM.0> fp range destroy 'rid' */ 2790 LOG_VERBOSE(BSL_LS_APPL_SHELL, 2791 (BSL_META_U(unit, 2792 "FP(unit %d) verb:fp_range_destroy 'rid=%d'\n"), unit, rid)); 2793 retval = bcm_field_range_destroy(unit, rid); 2794 FP_CHECK_RETURN(unit, retval, "bcm_field_range_destroy"); 2795 2796 return CMD_OK; 2797 } 2798 2799 /* 2800 * Function: 2801 * Purpose: 2802 * Parmameters: 2803 * Returns: 2804 */ 2805 STATIC int 2806 fp_group_set(int unit, args_t *args, bcm_field_qset_t *qset) 2807 { 2808 int retval = CMD_OK; 2809 char* subcmd = NULL; 2810 bcm_field_group_t gid; 2811 2812 FP_GET_NUMB(gid, subcmd, args); 2813 2814 /* BCM.0> fp group set 'gid' */ 2815 retval = bcm_field_group_set(unit, gid, *qset); 2816 FP_CHECK_RETURN(unit, retval, "bcm_field_group_set"); 2817 2818 return CMD_OK; 2819 } 2820 2821 /* 2822 * Function: 2823 * Purpose: 2824 * Parmameters: 2825 * Returns: 2826 */ 2827 STATIC int 2828 fp_group_status_get(int unit, args_t *args) 2829 { 2830 int retval = CMD_OK; 2831 char* subcmd = NULL; 2832 bcm_field_group_t gid; 2833 bcm_field_group_status_t gstat; 2834 2835 FP_GET_NUMB(gid, subcmd, args); 2836 2837 /* BCM.0> fp group status 'gid' */ 2838 LOG_VERBOSE(BSL_LS_APPL_SHELL, 2839 (BSL_META_U(unit, 2840 "FP(unit %d) verb:_group_status_get gid=%d\n"), unit, gid)); 2841 retval = bcm_field_group_status_get(unit, gid, &gstat); 2842 FP_CHECK_RETURN(unit, retval, "bcm_field_group_status_get"); 2843 2844 cli_out("group_status={\t"); 2845 cli_out("prio_min=%d, \t", gstat.prio_min); 2846 cli_out("prio_max=%d, \t", gstat.prio_max); 2847 cli_out("entries_total=%d,\t", gstat.entries_total); 2848 cli_out("entries_free=%d,\n\t\t", gstat.entries_free); 2849 cli_out("counters_total=%d,\t", gstat.counters_total); 2850 cli_out("counters_free=%d,\t", gstat.counters_free); 2851 cli_out("meters_total=%d,\t", gstat.meters_total); 2852 cli_out("meters_free=%d", gstat.meters_free); 2853 cli_out("}\n"); 2854 2855 return CMD_OK; 2856 } 2857 2858 /* 2859 * Function: 2860 * Purpose: 2861 * Parmameters: 2862 * Returns: 2863 */ 2864 STATIC int 2865 fp_group_mode_get(int unit, args_t *args) 2866 { 2867 int retval = CMD_OK; 2868 char* subcmd = NULL; 2869 bcm_field_group_t gid; 2870 bcm_field_group_mode_t mode; 2871 char buf[BCM_FIELD_GROUP_MODE_WIDTH_MAX]; 2872 2873 FP_GET_NUMB(gid, subcmd, args); 2874 2875 /* BCM.0> fp group mode 'gid' */ 2876 LOG_VERBOSE(BSL_LS_APPL_SHELL, 2877 (BSL_META_U(unit, 2878 "FP(unit %d) verb:bcm_field_group_mode_get gid=%d\n"), unit, gid)); 2879 retval = bcm_field_group_mode_get(unit, gid, &mode); 2880 FP_CHECK_RETURN(unit, retval, "bcm_field_group_mode_get"); 2881 cli_out("group mode=%s\n", format_field_group_mode(buf, mode, 1)); 2882 2883 return CMD_OK; 2884 } 2885 2886 /* 2887 * Function: 2888 * Purpose: 2889 * Parmameters: 2890 * Returns: 2891 */ 2892 STATIC int 2893 fp_list(int unit, args_t *args) { 2894 char* subcmd = NULL; 2895 2896 if ((subcmd = ARG_GET(args)) == NULL) { 2897 return CMD_USAGE; 2898 } 2899 2900 /* BCM.0> fp list actions */ 2901 if(!sal_strcasecmp(subcmd, "actions")) { 2902 return fp_list_actions(unit, args); 2903 } 2904 /* BCM.0> fp list qualifiers */ 2905 if(!sal_strcasecmp(subcmd, "qualifiers") || 2906 !sal_strcasecmp(subcmd, "quals")) { 2907 return fp_list_quals(unit, args); 2908 } 2909 2910 /* BCM.0> fp list user */ 2911 if(!sal_strcasecmp(subcmd, "user") || 2912 !sal_strcasecmp(subcmd, "users")) { 2913 return fp_list_udf_flags(unit); 2914 } 2915 2916 return CMD_USAGE; 2917 } 2918 2919 typedef struct fp_list_actions_s { 2920 char* action_0; 2921 char* action_1; 2922 } fp_list_actions_t; 2923 2924 /* 2925 * Function: 2926 * fp_list_actions 2927 * Purpose: 2928 * Display a list of Field actions 2929 * Parmameters: 2930 * Returns: 2931 */ 2932 STATIC int 2933 fp_list_actions(int unit, args_t *args) 2934 { 2935 bcm_field_action_t action; 2936 char buf[BCM_FIELD_ACTION_WIDTH_MAX]; 2937 fp_list_actions_t *fp_action_table; 2938 char *drop_str = "{preserve | green | yellow | red}"; 2939 int width_col1 = 35, width_col2 = 35, width_col3= 20; 2940 2941 int fp_stage = 0; 2942 char * stage_s; 2943 2944 if ((stage_s = ARG_GET(args)) != NULL) { 2945 if(!sal_strcasecmp(stage_s, "lookup") || 2946 !sal_strcasecmp(stage_s, "vfp")) { 2947 fp_stage = _BCM_FIELD_STAGE_LOOKUP; 2948 } else if(!sal_strcasecmp(stage_s, "ingress") || 2949 !sal_strcasecmp(stage_s, "ifp")) { 2950 fp_stage = _BCM_FIELD_STAGE_INGRESS; 2951 } else if(!sal_strcasecmp(stage_s, "egress") || 2952 !sal_strcasecmp(stage_s, "efp")) { 2953 fp_stage = _BCM_FIELD_STAGE_EGRESS; 2954 } else if(!sal_strcasecmp(stage_s, "external") || 2955 !sal_strcasecmp(stage_s, "ext")) { 2956 fp_stage = _BCM_FIELD_STAGE_EXTERNAL; 2957 } else if(!sal_strcasecmp(stage_s, "exactmatch") || 2958 !sal_strcasecmp(stage_s, "exa")) { 2959 fp_stage = _BCM_FIELD_STAGE_EXACTMATCH; 2960 } else if(!sal_strcasecmp(stage_s, "class") || 2961 !sal_strcasecmp(stage_s, "cla")) { 2962 fp_stage = _BCM_FIELD_STAGE_CLASS; 2963 } else if(!sal_strcasecmp(stage_s, "flowtracker") || 2964 !sal_strcasecmp(stage_s, "flo")) { 2965 fp_stage = _BCM_FIELD_STAGE_FLOWTRACKER; 2966 } else { 2967 stage_s = "All"; 2968 fp_stage = -1; 2969 } 2970 } else { 2971 stage_s = "All"; 2972 fp_stage = -1; 2973 } 2974 2975 fp_action_table = sal_alloc(sizeof(fp_list_actions_t) * bcmFieldActionCount, 2976 "fp actions table"); 2977 if (NULL == fp_action_table) { 2978 return CMD_FAIL; 2979 } 2980 2981 /* Fill the table with default values for param0 & param1. */ 2982 for (action = 0; action < bcmFieldActionCount; action++) { 2983 fp_action_table[action].action_0= "n/a"; 2984 fp_action_table[action].action_1 = "n/a"; 2985 } 2986 2987 fp_action_table[bcmFieldActionCosQNew].action_0 = "New CosQ Value"; 2988 fp_action_table[bcmFieldActionRpCosQNew].action_0 = "New CosQ Value"; 2989 fp_action_table[bcmFieldActionYpCosQNew].action_0 = "New CosQ Value"; 2990 fp_action_table[bcmFieldActionGpCosQNew].action_0 = "New CosQ Value"; 2991 fp_action_table[bcmFieldActionCosQCpuNew].action_0 = "New CPU CosQ Value"; 2992 fp_action_table[bcmFieldActionServicePoolIdNew].action_0 = "New Service Id Value"; 2993 fp_action_table[bcmFieldActionVlanCosQNew].action_0 = "New VLAN CosQ Value"; 2994 fp_action_table[bcmFieldActionRpVlanCosQNew].action_0 = "New VLAN CosQ Value"; 2995 fp_action_table[bcmFieldActionYpVlanCosQNew].action_0 = "New VLAN CosQ Value"; 2996 fp_action_table[bcmFieldActionGpVlanCosQNew].action_0 = "New VLAN CosQ Value"; 2997 fp_action_table[bcmFieldActionPrioPktAndIntNew].action_0 = "New Priority"; 2998 fp_action_table[bcmFieldActionRpPrioPktAndIntNew].action_0 = "New Priority"; 2999 fp_action_table[bcmFieldActionYpPrioPktAndIntNew].action_0 = "New Priority"; 3000 fp_action_table[bcmFieldActionGpPrioPktAndIntNew].action_0 = "New Priority"; 3001 fp_action_table[bcmFieldActionPrioPktNew].action_0 = "New Priority"; 3002 fp_action_table[bcmFieldActionRpPrioPktNew].action_0 = "New Priority"; 3003 fp_action_table[bcmFieldActionYpPrioPktNew].action_0 = "New Priority"; 3004 fp_action_table[bcmFieldActionGpPrioPktNew].action_0 = "New Priority"; 3005 fp_action_table[bcmFieldActionPrioIntNew].action_0 = "New Priority"; 3006 fp_action_table[bcmFieldActionRpPrioIntNew].action_0 = "New Priority"; 3007 fp_action_table[bcmFieldActionYpPrioIntNew].action_0 = "New Priority"; 3008 fp_action_table[bcmFieldActionGpPrioIntNew].action_0 = "New Priority"; 3009 fp_action_table[bcmFieldActionTosNew].action_0 = "New TOS value"; 3010 fp_action_table[bcmFieldActionCopyToCpu].action_0 = "non-zero -> matched rule"; 3011 fp_action_table[bcmFieldActionCopyToCpu].action_1 = "matched rule ID (0-127)"; 3012 fp_action_table[bcmFieldActionRpCopyToCpu].action_0 = "non-zero -> matched rule"; 3013 fp_action_table[bcmFieldActionRpCopyToCpu].action_1 = "matched rule ID (0-127)"; 3014 fp_action_table[bcmFieldActionYpCopyToCpu].action_0 = "non-zero -> matched rule"; 3015 fp_action_table[bcmFieldActionYpCopyToCpu].action_1 = "matched rule ID (0-127)"; 3016 fp_action_table[bcmFieldActionGpCopyToCpu].action_0 = "non-zero -> matched rule"; 3017 fp_action_table[bcmFieldActionGpCopyToCpu].action_1 = "matched rule ID (0-127)"; 3018 fp_action_table[bcmFieldActionTimeStampToCpu].action_0 = "non-zero -> matched rule"; 3019 fp_action_table[bcmFieldActionTimeStampToCpu].action_1 = "matched rule ID (0-127)"; 3020 fp_action_table[bcmFieldActionRpTimeStampToCpu].action_0 = "non-zero -> matched rule"; 3021 fp_action_table[bcmFieldActionRpTimeStampToCpu].action_1 = "matched rule ID (0-127)"; 3022 fp_action_table[bcmFieldActionYpTimeStampToCpu].action_0 = "non-zero -> matched rule"; 3023 fp_action_table[bcmFieldActionYpTimeStampToCpu].action_1 = "matched rule ID (0-127)"; 3024 fp_action_table[bcmFieldActionGpTimeStampToCpu].action_0 = "non-zero -> matched rule"; 3025 fp_action_table[bcmFieldActionGpTimeStampToCpu].action_1 = "matched rule ID (0-127)"; 3026 fp_action_table[bcmFieldActionRedirect].action_0 = "Dest. Modid"; 3027 fp_action_table[bcmFieldActionRedirect].action_1 = "Dest. port"; 3028 fp_action_table[bcmFieldActionOffloadRedirect].action_0 = "Dest. Modid"; 3029 fp_action_table[bcmFieldActionOffloadRedirect].action_1 = "Dest. port"; 3030 fp_action_table[bcmFieldActionRedirectTrunk].action_0 = "Dest. Trunk ID"; 3031 fp_action_table[bcmFieldActionRedirectIpmc].action_0 = "Dest. multicast index"; 3032 fp_action_table[bcmFieldActionRedirectMcast].action_0 = "Dest. multicast index"; 3033 fp_action_table[bcmFieldActionRedirectPbmp].action_0 = "Dest. port bitmap"; 3034 fp_action_table[bcmFieldActionRedirectEgrNextHop].action_0 = "Egress Object Id"; 3035 fp_action_table[bcmFieldActionEgressMask].action_0 = "Dest. port bitmap mask"; 3036 fp_action_table[bcmFieldActionEgressPortsAdd].action_0 = "Dest. port bitmap"; 3037 fp_action_table[bcmFieldActionIncomingMplsPortSet].action_0 = "Incoming MPLS port"; 3038 fp_action_table[bcmFieldActionMirrorIngress].action_0 = "Dest. Modid"; 3039 fp_action_table[bcmFieldActionMirrorIngress].action_1 = "Dest. port/TGID"; 3040 fp_action_table[bcmFieldActionMirrorEgress].action_0 = "Dest. Modid"; 3041 fp_action_table[bcmFieldActionMirrorEgress].action_1 = "Dest. port/TGID"; 3042 fp_action_table[bcmFieldActionL3ChangeVlan].action_0 = "Egress Object Id"; 3043 fp_action_table[bcmFieldActionL3ChangeMacDa].action_0 = "Egress Object Id"; 3044 fp_action_table[bcmFieldActionL3Switch].action_0 = "Egress Object Id"; 3045 fp_action_table[bcmFieldActionMultipathHash].action_0 = "BCM_FIELD_MULTIPATH_HASH_XXX"; 3046 fp_action_table[bcmFieldActionAddClassTag].action_0 = "New HG header Classification Tag Value"; 3047 fp_action_table[bcmFieldActionFabricQueue].action_0 = "Encoded fabric queue number and queue type BCM_FABRIC_QUEUE_XXX"; 3048 fp_action_table[bcmFieldActionDropPrecedence].action_0 = drop_str; 3049 fp_action_table[bcmFieldActionYpDropPrecedence].action_0 = drop_str; 3050 fp_action_table[bcmFieldActionRpDropPrecedence].action_0 = drop_str; 3051 fp_action_table[bcmFieldActionGpDropPrecedence].action_0 = drop_str; 3052 fp_action_table[bcmFieldActionDscpNew].action_0 = "New DSCP value"; 3053 fp_action_table[bcmFieldActionRpDscpNew].action_0 = "New DSCP value"; 3054 fp_action_table[bcmFieldActionYpDscpNew].action_0 = "New DSCP value"; 3055 fp_action_table[bcmFieldActionGpDscpNew].action_0 = "New DSCP value"; 3056 fp_action_table[bcmFieldActionGpTosPrecedenceNew].action_0 = "New tos precedence"; 3057 fp_action_table[bcmFieldActionEcnNew].action_0 = "New ECN value"; 3058 fp_action_table[bcmFieldActionRpEcnNew].action_0 = "New ECN value"; 3059 fp_action_table[bcmFieldActionYpEcnNew].action_0 = "New ECN value"; 3060 fp_action_table[bcmFieldActionGpEcnNew].action_0 = "New ECN value"; 3061 fp_action_table[bcmFieldActionRpOuterVlanPrioNew].action_0 = "New dot1P priority"; 3062 fp_action_table[bcmFieldActionYpOuterVlanPrioNew].action_0 = "New dot1P priority"; 3063 fp_action_table[bcmFieldActionGpOuterVlanPrioNew].action_0 = "New dot1P priority"; 3064 fp_action_table[bcmFieldActionOuterVlanPrioNew].action_0 = "New dot1P priority"; 3065 fp_action_table[bcmFieldActionRpInnerVlanPrioNew].action_0 = "New dot1P priority"; 3066 fp_action_table[bcmFieldActionYpInnerVlanPrioNew].action_0 = "New dot1P priority"; 3067 fp_action_table[bcmFieldActionGpInnerVlanPrioNew].action_0 = "New dot1P priority"; 3068 fp_action_table[bcmFieldActionInnerVlanPrioNew].action_0 = "New dot1P priority"; 3069 fp_action_table[bcmFieldActionRpOuterVlanCfiNew].action_0 = "New dot1P cfi"; 3070 fp_action_table[bcmFieldActionYpOuterVlanCfiNew].action_0 = "New dot1P cfi"; 3071 fp_action_table[bcmFieldActionGpOuterVlanCfiNew].action_0 = "New dot1P cfi"; 3072 fp_action_table[bcmFieldActionOuterVlanCfiNew].action_0 = "New dot1P cfi"; 3073 fp_action_table[bcmFieldActionRpInnerVlanCfiNew].action_0 = "New dot1P cfi"; 3074 fp_action_table[bcmFieldActionYpInnerVlanCfiNew].action_0 = "New dot1P cfi"; 3075 fp_action_table[bcmFieldActionGpInnerVlanCfiNew].action_0 = "New dot1P cfi"; 3076 fp_action_table[bcmFieldActionInnerVlanCfiNew].action_0 = "New dot1P cfi"; 3077 fp_action_table[bcmFieldActionOuterTpidNew].action_0 = "New tpid value"; 3078 fp_action_table[bcmFieldActionVlanAdd].action_0 = "New vlan id"; 3079 fp_action_table[bcmFieldActionOuterVlanNew].action_0 = "New vlan id"; 3080 fp_action_table[bcmFieldActionInnerVlanNew].action_0 = "New vlan id"; 3081 fp_action_table[bcmFieldActionOuterVlanLookup].action_0 = "Lookup vlan id"; 3082 fp_action_table[bcmFieldActionOuterVlanAdd].action_0 = "New vlan id"; 3083 fp_action_table[bcmFieldActionInnerVlanAdd].action_0 = "New vlan id"; 3084 fp_action_table[bcmFieldActionVrfSet].action_0 = "New vrf id"; 3085 fp_action_table[bcmFieldActionClassDestSet].action_0 = "New class id"; 3086 fp_action_table[bcmFieldActionClassSourceSet].action_0 = "New class id"; 3087 fp_action_table[bcmFieldActionColorIndependent].action_0 = "0(Green)/1(Any Color)"; 3088 fp_action_table[bcmFieldActionMcastCosQNew].action_0 = "New Cos Value"; 3089 fp_action_table[bcmFieldActionGpMcastCosQNew].action_0 = "New Cos Value"; 3090 fp_action_table[bcmFieldActionYpMcastCosQNew].action_0 = "New Cos Value"; 3091 fp_action_table[bcmFieldActionRpMcastCosQNew].action_0 = "New Cos Value"; 3092 fp_action_table[bcmFieldActionUcastCosQNew].action_0 = "New Cos Value"; 3093 fp_action_table[bcmFieldActionGpUcastCosQNew].action_0 = "New Cos Value"; 3094 fp_action_table[bcmFieldActionYpUcastCosQNew].action_0 = "New Cos Value"; 3095 fp_action_table[bcmFieldActionRpUcastCosQNew].action_0 = "New Cos Value"; 3096 fp_action_table[bcmFieldActionEgressClassSelect].action_0 = "Efp Class source select <0x0-0xb>"; 3097 fp_action_table[bcmFieldActionNewClassId].action_0 = "New ClassId Value"; 3098 fp_action_table[bcmFieldActionHiGigClassSelect].action_0 = "Higig Class source select <0x0-0x4>"; 3099 fp_action_table[bcmFieldActionIngressGportSet].action_0 = "Incoming Gport"; 3100 fp_action_table[bcmFieldActionNatCancel].action_0 = "Do Not Perform NAT"; 3101 fp_action_table[bcmFieldActionNat].action_0 = "Perform NAT"; 3102 fp_action_table[bcmFieldActionNatEgressOverride].action_0 = "Override NAT egress Edit info"; 3103 fp_action_table[bcmFieldActionPortPrioIntCosQNew].action_0 = "CosQ classifier ID"; 3104 fp_action_table[bcmFieldActionPortPrioIntCosQNew].action_1 = "Queue Offset"; 3105 fp_action_table[bcmFieldActionRpPortPrioIntCosQNew].action_0 = "CosQ classifier ID"; 3106 fp_action_table[bcmFieldActionRpPortPrioIntCosQNew].action_1 = "Queue Offset"; 3107 fp_action_table[bcmFieldActionYpPortPrioIntCosQNew].action_0 = "CosQ classifier ID"; 3108 fp_action_table[bcmFieldActionYpPortPrioIntCosQNew].action_1 = "Queue Offset"; 3109 fp_action_table[bcmFieldActionGpPortPrioIntCosQNew].action_0 = "CosQ classifier ID"; 3110 fp_action_table[bcmFieldActionGpPortPrioIntCosQNew].action_1 = "Queue Offset"; 3111 fp_action_table[bcmFieldActionHashSelect0].action_0 = "Hash selection 0 bitmap"; 3112 fp_action_table[bcmFieldActionHashSelect1].action_0 = "Hash selection 1 bitmap"; 3113 fp_action_table[bcmFieldActionUnmodifiedPacketRedirectPort].action_0 = "Dest. Gport"; 3114 fp_action_table[bcmFieldActionEtagNew].action_0 = "New ETag Value"; 3115 fp_action_table[bcmFieldActionPfcClassNew].action_0 = "New PFC Class Value"; 3116 fp_action_table[bcmFieldActionRpIntCongestionNotificationNew].action_0 = "New int_CN Value"; 3117 fp_action_table[bcmFieldActionYpIntCongestionNotificationNew].action_0 = "New int_CN Value"; 3118 fp_action_table[bcmFieldActionGpIntCongestionNotificationNew].action_0 = "New int_CN Value"; 3119 fp_action_table[bcmFieldActionRpHGCongestionClassNew].action_0 = "New Congestion_Class Value"; 3120 fp_action_table[bcmFieldActionYpHGCongestionClassNew].action_0 = "New Congestion_Class Value"; 3121 fp_action_table[bcmFieldActionGpHGCongestionClassNew].action_0 = "New Congestion_Class Value"; 3122 fp_action_table[bcmFieldActionRedirDropPrecedence].action_0 = drop_str; 3123 fp_action_table[bcmFieldActionYpRedirDropPrecedence].action_0 = drop_str; 3124 fp_action_table[bcmFieldActionRpRedirDropPrecedence].action_0 = drop_str; 3125 fp_action_table[bcmFieldActionGpRedirDropPrecedence].action_0 = drop_str; 3126 fp_action_table[bcmFieldActionVxlanHeaderBits8_31_Set].action_0 = "Vxlan Header Reserved_1 field"; 3127 fp_action_table[bcmFieldActionVxlanHeaderBits56_63_Set].action_0 = "Vxlan Header Reserved_2 field"; 3128 fp_action_table[bcmFieldActionVxlanHeaderFlags].action_0 = "Vxlan Header Flags field"; 3129 fp_action_table[bcmFieldActionVpnSet].action_0 = "New VPN Value"; 3130 fp_action_table[bcmFieldActionOamOlpHeaderAdd].action_0 = "Oam Olp Header Type"; 3131 fp_action_table[bcmFieldActionOamDmTimeFormat].action_0 = "Oam TimeStamp Format"; 3132 fp_action_table[bcmFieldActionDscpMapNew].action_0 = "Qos Map Id"; 3133 fp_action_table[bcmFieldActionChangeL2Fields].action_0 = "IFP Egress next hop index"; 3134 fp_action_table[bcmFieldActionPfcTx].action_0 = "Local port number"; 3135 fp_action_table[bcmFieldActionPfcTx].action_1 = "Enable vector"; 3136 fp_action_table[bcmFieldActionUcastQueueNew].action_0 = "Queue Number"; 3137 fp_action_table[bcmFieldActionRpUcastQueueNew].action_0 = "Queue Number"; 3138 fp_action_table[bcmFieldActionYpUcastQueueNew].action_0 = "Queue Number"; 3139 fp_action_table[bcmFieldActionGpUcastQueueNew].action_0 = "Queue Number"; 3140 fp_action_table[bcmFieldActionIntCosUcastQueueNew].action_0 = "Queue Number"; 3141 fp_action_table[bcmFieldActionIntCosUcastQueueNew].action_1 = "IFP Cos"; 3142 fp_action_table[bcmFieldActionRpIntCosUcastQueueNew].action_0 = "Queue Number"; 3143 fp_action_table[bcmFieldActionRpIntCosUcastQueueNew].action_1 = "IFP Cos"; 3144 fp_action_table[bcmFieldActionYpIntCosUcastQueueNew].action_0 = "Queue Number"; 3145 fp_action_table[bcmFieldActionYpIntCosUcastQueueNew].action_1 = "IFP Cos"; 3146 fp_action_table[bcmFieldActionGpIntCosUcastQueueNew].action_0 = "Queue Number"; 3147 fp_action_table[bcmFieldActionGpIntCosUcastQueueNew].action_1 = "IFP Cos"; 3148 fp_action_table[bcmFieldActionServicePrioIntCosQNew].action_0 = "CosQ classifier ID"; 3149 fp_action_table[bcmFieldActionServicePrioIntCosQNew].action_1 = "Queue Number"; 3150 fp_action_table[bcmFieldActionRpServicePrioIntCosQNew].action_0 = "CosQ classifier ID"; 3151 fp_action_table[bcmFieldActionRpServicePrioIntCosQNew].action_1 = "Queue Number"; 3152 fp_action_table[bcmFieldActionYpServicePrioIntCosQNew].action_0 = "CosQ classifier ID"; 3153 fp_action_table[bcmFieldActionYpServicePrioIntCosQNew].action_1 = "Queue Number"; 3154 fp_action_table[bcmFieldActionGpServicePrioIntCosQNew].action_0 = "CosQ classifier ID"; 3155 fp_action_table[bcmFieldActionGpServicePrioIntCosQNew].action_1 = "Queue Number"; 3156 fp_action_table[bcmFieldActionSwitchEncap].action_0 = "Switch Encap Id"; 3157 fp_action_table[bcmFieldActionStrength].action_0 = "Redirect or CopyToCpu Strength"; 3158 fp_action_table[bcmFieldActionRedirectBufferPriority].action_0 = "Redirect or CopyToCpu Buffer Priority"; 3159 fp_action_table[bcmFieldActionRedirectPrioIntNew].action_0 = "Internal priority for Redirected packets"; 3160 fp_action_table[bcmFieldActionRpRedirectPrioIntNew].action_0 = "Internal priority for Redirected red packets"; 3161 fp_action_table[bcmFieldActionYpRedirectPrioIntNew].action_0 = "Internal priority for Redirected yellow packets"; 3162 fp_action_table[bcmFieldActionGpRedirectPrioIntNew].action_0 = "Internal priority for Redirected green packets"; 3163 fp_action_table[bcmFieldActionOamStatObjectSessionId].action_0 = "Stat Object Value"; 3164 fp_action_table[bcmFieldActionOamLmCounterPoolId].action_0 = "OAM LM Counter Pool ID"; 3165 fp_action_table[bcmFieldActionServicePoolIdPrecedenceNew].action_0 = "SPID"; 3166 fp_action_table[bcmFieldActionServicePoolIdPrecedenceNew].action_1 = "SPAP (color)"; 3167 fp_action_table[bcmFieldActionUseTunnelPayload].action_0 = "Enable vector"; 3168 fp_action_table[bcmFieldActionMplsLabel1ExpNew].action_0 = "EXP field in forwarding label of MPLS packets"; 3169 fp_action_table[bcmFieldActionDgmThreshold].action_0 = "Threshold value in DGM"; 3170 fp_action_table[bcmFieldActionDgmBias].action_0 = "Bias value in DGM"; 3171 fp_action_table[bcmFieldActionDgmCost].action_0 = "Cost value in DGM"; 3172 fp_action_table[bcmFieldActionTerminationAllowed].action_0 = "MPLS/IPV4/IPV6/ARP Termination Allowed controls"; 3173 fp_action_table[bcmFieldActionMplsLookupEnable].action_0 = "MPLS enable/disable"; 3174 fp_action_table[bcmFieldActionRoeFrameTypeSet].action_0 = "Roe Frame type"; 3175 fp_action_table[bcmFieldActionFlowtrackerGroupId].action_0 = "Flowtracker Group Id"; 3176 fp_action_table[bcmFieldActionDlbEcmpMonitorEnable].action_0 = "Enable/Disable Flags"; 3177 width_col2 = sal_strlen(drop_str) + 2; 3178 3179 3180 cli_out("------------------------ FP STAGE: %s ----------------------\n", stage_s); 3181 3182 cli_out("%-*s %-*s %-*s\n", width_col1, "ACTION", width_col2, "PARAM0", 3183 width_col3, "PARAM1"); 3184 for (action = 0; action < bcmFieldActionCount; action++) { 3185 if (action == bcmFieldActionUpdateCounter || 3186 action == bcmFieldActionMeterConfig) { 3187 continue; 3188 } 3189 3190 if(!fp_action_supported(unit, fp_stage, action)) { 3191 continue; 3192 } 3193 3194 cli_out("%-*s %-*s %-*s\n", 3195 width_col1, format_field_action(buf, action, 1), 3196 width_col2, fp_action_table[action].action_0, 3197 width_col3, fp_action_table[action].action_1); 3198 } 3199 3200 if (fp_action_table != NULL) { 3201 sal_free(fp_action_table); 3202 } 3203 3204 return CMD_OK; 3205 } 3206 3207 STATIC int 3208 fp_qual_supported(int unit, int fp_stage, int qual) 3209 { 3210 bcm_field_qset_t qs; 3211 _field_stage_t * stage; 3212 int rv; 3213 3214 /* if asked for ALL qualifiers, just return true */ 3215 if(fp_stage == -1) { 3216 return TRUE; 3217 } 3218 3219 if(fp_stage == _BCM_FIELD_STAGE_EXTERNAL && 3220 !soc_feature(unit, soc_feature_esm_support)) { 3221 return FALSE; 3222 } 3223 3224 if((fp_stage == _BCM_FIELD_STAGE_LOOKUP || 3225 fp_stage == _BCM_FIELD_STAGE_EGRESS) && 3226 !soc_feature(unit, soc_feature_field_multi_stage)) { 3227 return FALSE; 3228 } 3229 BCM_FIELD_QSET_INIT(qs); 3230 BCM_FIELD_QSET_ADD(qs, qual); 3231 #if defined(BCM_TOMAHAWK_SUPPORT) 3232 if(fp_stage == _BCM_FIELD_STAGE_CLASS) { 3233 if(_bcm_field_th_class_qual_support_check(unit, qual)) { 3234 return TRUE; 3235 } 3236 else { 3237 return FALSE; 3238 } 3239 } 3240 #endif 3241 if(fp_stage != -1) { 3242 rv = _field_stage_control_get(unit, fp_stage, &stage); 3243 if(BCM_SUCCESS(rv)) { 3244 if (_field_qset_is_subset(&qs, 3245 &stage->_field_supported_qset)) { 3246 return TRUE; 3247 } 3248 } 3249 } 3250 return FALSE; 3251 } 3252 3253 STATIC int 3254 fp_action_supported(int unit, int fp_stage, int action) 3255 { 3256 _field_entry_t f_ent; 3257 _field_group_t f_group; 3258 _field_control_t *fc; 3259 int action_support = FALSE; 3260 3261 /* if asked for ALL qualifiers, just return true */ 3262 if(fp_stage == -1) { 3263 return TRUE; 3264 } 3265 3266 if(fp_stage == _BCM_FIELD_STAGE_EXTERNAL && 3267 !soc_feature(unit, soc_feature_esm_support)) { 3268 return FALSE; 3269 } 3270 3271 f_group.stage_id = fp_stage; 3272 f_ent.group = &f_group; 3273 3274 BCM_IF_ERROR_RETURN(_field_control_get(unit, &fc)); 3275 3276 if(fc->functions.fp_action_support_check(unit, &f_ent, 3277 action, &action_support) != BCM_E_NONE) { 3278 return FALSE; 3279 } 3280 3281 return action_support; 3282 } 3283 3284 3285 /* 3286 * Function: 3287 * fp_list_quals 3288 * Purpose: 3289 * Display a list of Field qualifiers 3290 * Parmameters: 3291 * Returns: 3292 */ 3293 STATIC int 3294 fp_list_quals(int unit, args_t *args) 3295 { 3296 bcm_field_qualify_t qual; 3297 char buf[BCM_FIELD_QUALIFY_WIDTH_MAX]; 3298 int width_col1 = 20, width_col2 = 40, width_col3= 20; 3299 int fp_stage = 0; 3300 char * stage_s; 3301 char ***param_table = sal_alloc(bcmFieldQualifyCount * sizeof(param_table), 3302 "Qualifier Space"); 3303 3304 /* Use heap memory than stack to reduce Stack_use */ 3305 for (qual = 0; qual < bcmFieldQualifyCount; qual++) { 3306 param_table[qual] = sal_alloc(2 * sizeof(char *), "Qual Desc/Mask"); 3307 } 3308 3309 if ((stage_s = ARG_GET(args)) != NULL) { 3310 if(!sal_strcasecmp(stage_s, "lookup") || 3311 !sal_strcasecmp(stage_s, "vfp")) { 3312 fp_stage = _BCM_FIELD_STAGE_LOOKUP; 3313 } else if(!sal_strcasecmp(stage_s, "ingress") || 3314 !sal_strcasecmp(stage_s, "ifp")) { 3315 fp_stage = _BCM_FIELD_STAGE_INGRESS; 3316 } else if(!sal_strcasecmp(stage_s, "egress") || 3317 !sal_strcasecmp(stage_s, "efp")) { 3318 fp_stage = _BCM_FIELD_STAGE_EGRESS; 3319 } else if(!sal_strcasecmp(stage_s, "external") || 3320 !sal_strcasecmp(stage_s, "ext")) { 3321 fp_stage = _BCM_FIELD_STAGE_EXTERNAL; 3322 } else if(!sal_strcasecmp(stage_s, "exactmatch") || 3323 !sal_strcasecmp(stage_s, "exa")) { 3324 fp_stage = _BCM_FIELD_STAGE_EXACTMATCH; 3325 } else if(!sal_strcasecmp(stage_s, "class") || 3326 !sal_strcasecmp(stage_s, "cla")) { 3327 fp_stage = _BCM_FIELD_STAGE_CLASS; 3328 } else if(!sal_strcasecmp(stage_s, "flowtracker") || 3329 !sal_strcasecmp(stage_s, "flo")) { 3330 fp_stage = _BCM_FIELD_STAGE_FLOWTRACKER; 3331 } else { 3332 stage_s = "All"; 3333 fp_stage = -1; 3334 } 3335 } else { 3336 stage_s = "All"; 3337 fp_stage = -1; 3338 } 3339 3340 /* Fill the table with default values for param0 & param1. */ 3341 for (qual = 0; qual < bcmFieldQualifyCount; qual++) { 3342 param_table[qual][0] = "n/a"; 3343 param_table[qual][1] = "n/a"; 3344 } 3345 3346 param_table[bcmFieldQualifySrcIp6][0] = "Source IPv6 Address"; 3347 param_table[bcmFieldQualifySrcIp6][1] = "IPv6 Address mask"; 3348 param_table[bcmFieldQualifyDstIp6][0] = "Destination IPv6 Address"; 3349 param_table[bcmFieldQualifyDstIp6][1] = "IPv6 Address mask"; 3350 param_table[bcmFieldQualifySrcIp6High][0] = "Top 64-bits of Source IPv6 Address"; 3351 param_table[bcmFieldQualifySrcIp6High][1] = "64-bits of IPv6 Address mask"; 3352 param_table[bcmFieldQualifyDstIp6High][0] = "Top 64-bits of Destination IPv6 Address"; 3353 param_table[bcmFieldQualifyDstIp6High][1] = "64-bits of IPv6 Address mask"; 3354 param_table[bcmFieldQualifySrcIp6Low][0] = "Lower 64-bits of Source IPv6 Address"; 3355 param_table[bcmFieldQualifySrcIp6Low][1] = "64-bits of IPv6 Address mask"; 3356 param_table[bcmFieldQualifyDstIp6Low][0] = "Lower 64-bits of Destination IPv6 Address"; 3357 param_table[bcmFieldQualifyDstIp6Low][1] = "64-bits of IPv6 Address mask"; 3358 param_table[bcmFieldQualifySrcIp][0] = "Source IPv4 Address"; 3359 param_table[bcmFieldQualifySrcIp][1] = "IPv4 Address mask"; 3360 param_table[bcmFieldQualifyDstIp][0] = "Destination IPv4 Address"; 3361 param_table[bcmFieldQualifyDstIp][1] = "IPv4 Address"; 3362 param_table[bcmFieldQualifyInPort][0] = "Single Input Port"; 3363 param_table[bcmFieldQualifyInPort][1] = "Port Mask"; 3364 param_table[bcmFieldQualifyOutPort][0] = "Single Output Port"; 3365 param_table[bcmFieldQualifyOutPort][1] = "Port Mask"; 3366 param_table[bcmFieldQualifyInPorts][0] = "Input Port Bitmap"; 3367 param_table[bcmFieldQualifyInPorts][1] = "Port Bitmap Mask"; 3368 param_table[bcmFieldQualifyOutPorts][0] = "Output Port Bitmap"; 3369 param_table[bcmFieldQualifyOutPorts][1] = "Port Bitmap Mask"; 3370 param_table[bcmFieldQualifyDrop][0] = "0 or 1"; 3371 param_table[bcmFieldQualifyDrop][1] = "0 or 1"; 3372 param_table[bcmFieldQualifyLoopback][0] = "0 or 1"; 3373 param_table[bcmFieldQualifyLoopback][1] = "0 or 1"; 3374 param_table[bcmFieldQualifyIp6FlowLabel][0] = "20-bit IPv6 Flow Label"; 3375 param_table[bcmFieldQualifyIp6FlowLabel][1] = "20-bit mask"; 3376 param_table[bcmFieldQualifyIp6HopLimit][0] = "8-bit IPv6 Hop Limit"; 3377 param_table[bcmFieldQualifyIp6HopLimit][1] = "8-bit mask"; 3378 param_table[bcmFieldQualifyOuterVlan][0] = "Outer VLAN tag"; 3379 param_table[bcmFieldQualifyOuterVlan][1] = "16-bit mask"; 3380 param_table[bcmFieldQualifyOuterVlanPri][0] = "Outer VLAN priority"; 3381 param_table[bcmFieldQualifyOuterVlanPri][1] = "3-bit mask"; 3382 param_table[bcmFieldQualifyOuterVlanCfi][0] = "Outer VLAN CFI"; 3383 param_table[bcmFieldQualifyOuterVlanCfi][1] = "1-bit mask"; 3384 param_table[bcmFieldQualifyOuterVlanId][0] = "Outer VLAN id"; 3385 param_table[bcmFieldQualifyOuterVlanId][1] = "12-bit mask"; 3386 param_table[bcmFieldQualifyInnerVlan][0] = "Inner VLAN tag"; 3387 param_table[bcmFieldQualifyInnerVlan][1] = "16-bit mask"; 3388 param_table[bcmFieldQualifyInnerVlanPri][0] = "Inner VLAN priority"; 3389 param_table[bcmFieldQualifyInnerVlanPri][1] = "3-bit mask"; 3390 param_table[bcmFieldQualifyInnerVlanCfi][0] = "Inner VLAN CFI"; 3391 param_table[bcmFieldQualifyInnerVlanCfi][1] = "1-bit mask"; 3392 param_table[bcmFieldQualifyInnerVlanId][0] = "Inner VLAN id"; 3393 param_table[bcmFieldQualifyInnerVlanId][1] = "12-bit mask"; 3394 param_table[bcmFieldQualifyRangeCheck][0] = "Range ID"; 3395 param_table[bcmFieldQualifyRangeCheck][1] = "Normal=0, Invert=1"; 3396 param_table[bcmFieldQualifyL4SrcPort][0] = "TCP/UDP Source port"; 3397 param_table[bcmFieldQualifyL4SrcPort][1] = "16-bit mask"; 3398 param_table[bcmFieldQualifyL4DstPort][0] = "TCP/UDP Destination port"; 3399 param_table[bcmFieldQualifyL4DstPort][1] = "16-bit mask"; 3400 param_table[bcmFieldQualifyEtherType][0] = "Ethernet Type"; 3401 param_table[bcmFieldQualifyEtherType][1] = "16-bit mask"; 3402 param_table[bcmFieldQualifyL4Ports][0] = "L4 ports valid bit"; 3403 param_table[bcmFieldQualifyL4Ports][1] = "L4 ports valid bit mask"; 3404 param_table[bcmFieldQualifyMirrorCopy][0] = "Mirrored only"; 3405 param_table[bcmFieldQualifyMirrorCopy][1] = "Mirrored only mask"; 3406 param_table[bcmFieldQualifyTunnelTerminated][0]= "Tunnel terminated"; 3407 param_table[bcmFieldQualifyTunnelTerminated][1]= "Tunnel terminated mask"; 3408 param_table[bcmFieldQualifyMplsTerminated][0] = "Mpls terminated"; 3409 param_table[bcmFieldQualifyMplsTerminated][1] = "Mpls terminated mask"; 3410 param_table[bcmFieldQualifyIpProtocol][0] = "IP protocol field"; 3411 param_table[bcmFieldQualifyIpProtocol][1] = "8-bit mask"; 3412 param_table[bcmFieldQualifyDSCP][0] = "Differential Code Point"; 3413 param_table[bcmFieldQualifyDSCP][1] = "8-bit mask"; 3414 param_table[bcmFieldQualifyVlanFormat][0] = "Vlan tag format"; 3415 param_table[bcmFieldQualifyVlanFormat][1] = "8-bit mask"; 3416 param_table[bcmFieldQualifyTranslatedVlanFormat][0] = "Vlan tag format"; 3417 param_table[bcmFieldQualifyTranslatedVlanFormat][1] = "8-bit mask"; 3418 param_table[bcmFieldQualifyIntPriority][0] = "Internal priority"; 3419 param_table[bcmFieldQualifyIntPriority][1] = "8-bit mask"; 3420 param_table[bcmFieldQualifyTtl][0] = "Time to live"; 3421 param_table[bcmFieldQualifyTtl][1] = "8-bit mask"; 3422 param_table[bcmFieldQualifyIp6NextHeader][0] = "IPv6 Next Header"; 3423 param_table[bcmFieldQualifyIp6NextHeader][1] = "8-bit mask"; 3424 param_table[bcmFieldQualifyIp6TrafficClass][0] = "IPv6 Next Header"; 3425 param_table[bcmFieldQualifyIp6TrafficClass][1] = "8-bit mask"; 3426 param_table[bcmFieldQualifyIp6HopLimit][0] = "IPv6 Hop Limit"; 3427 param_table[bcmFieldQualifyIp6HopLimit][1] = "8-bit mask"; 3428 param_table[bcmFieldQualifySrcTrunk][0] = "Source Trunk Group ID"; 3429 param_table[bcmFieldQualifySrcTrunk][1] = "8-bit mask"; 3430 param_table[bcmFieldQualifyDstTrunk][0] = "Destination Trunk Group ID"; 3431 param_table[bcmFieldQualifyDstTrunk][1] = "8-bit mask"; 3432 param_table[bcmFieldQualifyTcpControl][0] = "TCP control flags"; 3433 param_table[bcmFieldQualifyTcpControl][1] = "8-bit mask"; 3434 param_table[bcmFieldQualifySrcClassL2][0] = "Source L2 class"; 3435 param_table[bcmFieldQualifySrcClassL2][1] = "Source L2 class mask"; 3436 param_table[bcmFieldQualifySrcClassL3][0] = "Source L3 class"; 3437 param_table[bcmFieldQualifySrcClassL3][1] = "Source L3 class mask"; 3438 param_table[bcmFieldQualifySrcClassField][0] = "Source Field class"; 3439 param_table[bcmFieldQualifySrcClassField][1] = "Source Field class mask"; 3440 param_table[bcmFieldQualifyDstClassL2][0] = "Destination L2 class"; 3441 param_table[bcmFieldQualifyDstClassL2][1] = "Destination L2 class mask"; 3442 param_table[bcmFieldQualifyDstClassL3][0] = "Destination L3 class"; 3443 param_table[bcmFieldQualifyDstClassL3][1] = "Destination L3 class mask"; 3444 param_table[bcmFieldQualifyDstClassField][0] = "Destination Field class"; 3445 param_table[bcmFieldQualifyDstClassField][1] = "Destination Field class mask"; 3446 param_table[bcmFieldQualifyMHOpcode][0] = "Module Header opcodes"; 3447 param_table[bcmFieldQualifyMHOpcode][1] = "3-bit mask"; 3448 param_table[bcmFieldQualifyIpFlags][0] = "IPv4 Flags"; 3449 param_table[bcmFieldQualifyIpFlags][1] = "3-bit mask"; 3450 param_table[bcmFieldQualifyIpType][0] = "bcm_field_IpType_t"; 3451 param_table[bcmFieldQualifyInnerIpType][0] = "bcm_field_IpType_t"; 3452 param_table[bcmFieldQualifyL2Format][0] = "bcm_field_L2Format_t"; 3453 param_table[bcmFieldQualifyDecap][0] = "bcm_field_decap_t"; 3454 param_table[bcmFieldQualifyHiGig][0] = "HiGig=1, non-HiGig=0"; 3455 param_table[bcmFieldQualifyHiGig][1] = "1/0"; 3456 param_table[bcmFieldQualifyDstHiGig][0] = "HiGig=1, non-HiGig=0"; 3457 param_table[bcmFieldQualifyDstHiGig][1] = "1/0"; 3458 param_table[bcmFieldQualifyInnerTpid][0] = "Inner vlan tag tpid"; 3459 param_table[bcmFieldQualifyOuterTpid][0] = "Outer vlan tag tpid"; 3460 param_table[bcmFieldQualifyStage][0] = "bcm_field_stage_t"; 3461 param_table[bcmFieldQualifyStageIngress][0] = "Ingress FP pipeline stage"; 3462 param_table[bcmFieldQualifyStageLookup][0] = "Lookup FP pipeline stage"; 3463 param_table[bcmFieldQualifyStageEgress][0] = "Egress FP pipeline stage"; 3464 param_table[bcmFieldQualifyTcpSequenceZero][0] = "1 if TCP Sequence#==0, 0 if !="; 3465 param_table[bcmFieldQualifyTcpSequenceZero][0] = "1 if TCP Sequence#==0, 0 if !="; 3466 param_table[bcmFieldQualifyDstL3Egress][0] = "Destination L3 Egress id."; 3467 param_table[bcmFieldQualifyDstMplsGport][0] = "Destination mpls gport."; 3468 param_table[bcmFieldQualifyDstMimGport][0] = "Destination mim gport."; 3469 param_table[bcmFieldQualifyDstWlanGport][0] = "Destination wlan gport."; 3470 param_table[bcmFieldQualifyDstMulticastGroup][0] = 3471 "Destination multicast group."; 3472 param_table[bcmFieldQualifySrcMplsGport][0] = "Source mpls gport."; 3473 param_table[bcmFieldQualifySrcMimGport][0] = "Source mim gport."; 3474 param_table[bcmFieldQualifySrcWlanGport][0] = "Source wlan gport."; 3475 param_table[bcmFieldQualifySrcModPortGport][0] = "Source mod port gport."; 3476 param_table[bcmFieldQualifySrcTrunkMemberGport][0] = "Source Trunk Member mod port gport."; 3477 param_table[bcmFieldQualifyInterfaceClassL2][0] = "Interface Class L2."; 3478 param_table[bcmFieldQualifyInterfaceClassL2][1] = "Interface Class L2."; 3479 param_table[bcmFieldQualifyInterfaceClassL3][0] = "Interface Class L3."; 3480 param_table[bcmFieldQualifyInterfaceClassL3][1] = "Interface Class L3."; 3481 param_table[bcmFieldQualifyInterfaceClassPort][0] = "Interface Class Port."; 3482 param_table[bcmFieldQualifyInterfaceClassPort][1] = "Interface Class Port."; 3483 param_table[bcmFieldQualifyInterfaceClassVPort][0] = "Interface Class Virtual Port."; 3484 param_table[bcmFieldQualifyInterfaceClassVPort][1] = "Interface Class Virtual Port."; 3485 param_table[bcmFieldQualifyTcpHeaderSize][0] = "TCP Size"; 3486 param_table[bcmFieldQualifyTcpHeaderSize][1] = "8-bit mask"; 3487 param_table[bcmFieldQualifyVrf][0] = "VRF id"; 3488 param_table[bcmFieldQualifyVrf][1] = "VRF id mask"; 3489 param_table[bcmFieldQualifyL3Ingress][0] = "L3 ingress interface"; 3490 param_table[bcmFieldQualifyL3Ingress][1] = "L3 ingress interface mask"; 3491 param_table[bcmFieldQualifyExtensionHeaderType][0] = "Next Header In Ext Hdr"; 3492 param_table[bcmFieldQualifyExtensionHeaderType][1] = "Next Header byte mask"; 3493 param_table[bcmFieldQualifyExtensionHeader2Type][0] = "Next Header in Second Ext Hdr"; 3494 param_table[bcmFieldQualifyExtensionHeader2Type][1] = "Next Header in second Ext Hdr byte mask"; 3495 param_table[bcmFieldQualifyExtensionHeaderSubCode][0] = "Next Header Sub Code"; 3496 param_table[bcmFieldQualifyExtensionHeaderSubCode][1] = "Next Header Sub Code mask"; 3497 param_table[bcmFieldQualifyL3Routable][0] = "1 should be L3 routed 0 otherwise"; 3498 param_table[bcmFieldQualifyL3Routable][1] = "Routed mask"; 3499 param_table[bcmFieldQualifyDosAttack][0] = "1 DOS attac 0 otherwise"; 3500 param_table[bcmFieldQualifyDosAttack][1] = "Dos attack mask"; 3501 param_table[bcmFieldQualifyIpmcStarGroupHit][0] = "1 Star, G hit 0 otherwise"; 3502 param_table[bcmFieldQualifyIpmcStarGroupHit][1] = "Star, G entry hit mask"; 3503 param_table[bcmFieldQualifyMyStationHit][0] = "1 My Station table hit, 0 otherwise"; 3504 param_table[bcmFieldQualifyMyStationHit][1] = "My Station table hit mask"; 3505 param_table[bcmFieldQualifyL3DestRouteHit][0] = "1 L3 dest route table hit, 0 otherwise"; 3506 param_table[bcmFieldQualifyL3DestRouteHit][1] = "L3 dest route table hit mask"; 3507 param_table[bcmFieldQualifyL3DestHostHit][0] = "1 L3 dest host table hit, 0 otherwise"; 3508 param_table[bcmFieldQualifyL3DestHostHit][1] = "L3 dest host table hit mask"; 3509 param_table[bcmFieldQualifyL3SrcHostHit][0] = "1 L3 source host table hit , 0 otherwise"; 3510 param_table[bcmFieldQualifyL3SrcHostHit][1] = "L3 source host table hit mask"; 3511 param_table[bcmFieldQualifyL2CacheHit][0] = "1 L2 dest cache hit, 0 otherwise"; 3512 param_table[bcmFieldQualifyL2CacheHit][1] = "L2 dest cache hit mask"; 3513 param_table[bcmFieldQualifyL2StationMove][0] = "1 L2 src station move, 0 otherwise"; 3514 param_table[bcmFieldQualifyL2StationMove][1] = "L2 src station move mask"; 3515 param_table[bcmFieldQualifyL2SrcHit][0] = "1 L2 src lookup success, 0 otherwise"; 3516 param_table[bcmFieldQualifyL2SrcHit][1] = "L2 src lookup mask"; 3517 param_table[bcmFieldQualifyL2DestHit][0] = "1 L2 dest lookup success, 0 otherwise"; 3518 param_table[bcmFieldQualifyL2DestHit][1] = "L2 dest lookup mask"; 3519 param_table[bcmFieldQualifyL2SrcStatic][0] = "1 L2 src static, 0 otherwise"; 3520 param_table[bcmFieldQualifyL2SrcStatic][1] = "L2 src static mask"; 3521 param_table[bcmFieldQualifyIngressStpState][0] = "BCM_STG_STP_XXX"; 3522 param_table[bcmFieldQualifyIngressStpState][1] = "STG Stp state mask"; 3523 param_table[bcmFieldQualifyForwardingVlanValid][0] = "Forwarding vlan id valid."; 3524 param_table[bcmFieldQualifyForwardingVlanValid][1] = "Forwarding vlan id valid mask"; 3525 param_table[bcmFieldQualifyVlanTranslationHit][0] = "Vlan Translation table hit."; 3526 param_table[bcmFieldQualifyVlanTranslationHit][1] = "Vlan Translation table hit mask"; 3527 param_table[bcmFieldQualifyVnTag][0] = "VNTAG data"; 3528 param_table[bcmFieldQualifyVnTag][1] = "VNTAG mask"; 3529 param_table[bcmFieldQualifyCnTag][0] = "CNTAG data"; 3530 param_table[bcmFieldQualifyCnTag][1] = "CNTAG mask"; 3531 param_table[bcmFieldQualifyFabricQueueTag][0] = "Fabric queue tag data"; 3532 param_table[bcmFieldQualifyFabricQueueTag][1] = "Fabric queue tag mask"; 3533 param_table[bcmFieldQualifyDstL3EgressNextHops][0] = "NextHops data"; 3534 param_table[bcmFieldQualifyDstL3EgressNextHops][1] = "NextHops mask"; 3535 param_table[bcmFieldQualifyCpuQueue][0] = "CPU CosQ data"; 3536 param_table[bcmFieldQualifyCpuQueue][1] = "6-bit mask"; 3537 param_table[bcmFieldQualifySrcGport][0] 3538 = "Src (mod/port)/MPLS/MiM/WLAN/Niv/Vlan gport"; 3539 param_table[bcmFieldQualifyInnerSrcIp][0] = "Source IPv4 Address"; 3540 param_table[bcmFieldQualifyInnerSrcIp][1] = "IPv4 Address mask"; 3541 param_table[bcmFieldQualifyInnerDstIp][0] = "Destination IPv4 Address"; 3542 param_table[bcmFieldQualifyInnerDstIp][1] = "IPv4 Address mask"; 3543 param_table[bcmFieldQualifyMplsOuterLabelPop][0] = "MPLS outer label popped data (1bit)"; 3544 param_table[bcmFieldQualifyMplsOuterLabelPop][1] = "MPLS outer label popped mask"; 3545 param_table[bcmFieldQualifyMplsStationHitTunnelUnterminated][0] = "MPLS Station hit unterminated data (1bit)"; 3546 param_table[bcmFieldQualifyMplsStationHitTunnelUnterminated][1] = "MPLS Station hit unterminated mask"; 3547 param_table[bcmFieldQualifyIngressClassField][0] = "Class Id value"; 3548 param_table[bcmFieldQualifyIngressClassField][1] = "Mask for Class Id value"; 3549 param_table[bcmFieldQualifyIngressInterfaceClassPort][0] = "Class Id value"; 3550 param_table[bcmFieldQualifyIngressInterfaceClassPort][1] = "Mask for Class Id value"; 3551 param_table[bcmFieldQualifyVxlanNetworkId][0] = "Vxlan Network Id"; 3552 param_table[bcmFieldQualifyVxlanNetworkId][1] = "Mask for Vxlan Network Id"; 3553 param_table[bcmFieldQualifyVxlanFlags][0] = "Vxlan Header Flags"; 3554 param_table[bcmFieldQualifyVxlanFlags][1] = "Mask for Vxlan Header Flags"; 3555 param_table[bcmFieldQualifyNatNeeded][0] = "Packets for NAT to happen"; 3556 param_table[bcmFieldQualifyNatNeeded][1] = "Mask for Nat Needed value"; 3557 param_table[bcmFieldQualifyNatDstRealmId][0] = "NAT Dest Realm Id"; 3558 param_table[bcmFieldQualifyNatDstRealmId][1] = "Mask for Nat Dest Realm Id"; 3559 param_table[bcmFieldQualifyNatSrcRealmId][0] = "NAT Src Realm Id"; 3560 param_table[bcmFieldQualifyNatSrcRealmId][1] = "Mask for Nat Src Realm Id"; 3561 param_table[bcmFieldQualifyIcmpError][0] = "Packets with Icmp Error"; 3562 param_table[bcmFieldQualifyIcmpError][1] = "Mask for Icmp Error value"; 3563 param_table[bcmFieldQualifyIcmpTypeCode][0] = "ICMP Type value"; 3564 param_table[bcmFieldQualifyIcmpTypeCode][1] = "Mask for Icmp Type"; 3565 param_table[bcmFieldQualifyVnTag][0] = "VN-Tag"; 3566 param_table[bcmFieldQualifyVnTag][1] = "VN-Tag mask"; 3567 param_table[bcmFieldQualifyCnTag][0] = "CN-Tag"; 3568 param_table[bcmFieldQualifyCnTag][1] = "CN-Tag mask"; 3569 param_table[bcmFieldQualifyForwardingVlanId][0] = "VLAN id"; 3570 param_table[bcmFieldQualifyForwardingVlanId][1] = "12-bit mask"; 3571 param_table[bcmFieldQualifyVpn][0] = "VPN data"; 3572 param_table[bcmFieldQualifyVpn][1] = "VPN Mask"; 3573 param_table[bcmFieldQualifyEgressClass][0] = "Class Id"; 3574 param_table[bcmFieldQualifyEgressClass][1] = "Class Id mask"; 3575 param_table[bcmFieldQualifyEgressClassL3Interface][0] = "Class Id"; 3576 param_table[bcmFieldQualifyEgressClassL3Interface][1] = "Class Id mask"; 3577 param_table[bcmFieldQualifyEgressClassTrill][0] = "Class Id"; 3578 param_table[bcmFieldQualifyEgressClassTrill][1] = "Class Id mask"; 3579 param_table[bcmFieldQualifyEgressClassL2Gre][0] = "Class Id"; 3580 param_table[bcmFieldQualifyEgressClassL2Gre][1] = "Class Id mask"; 3581 param_table[bcmFieldQualifyEgressClassWlan][0] = "Class Id"; 3582 param_table[bcmFieldQualifyEgressClassWlan][1] = "Class Id mask"; 3583 param_table[bcmFieldQualifyForwardingType][0] = "bcm_field_ForwardingType_t"; 3584 param_table[bcmFieldQualifyFibreChanRCtl][0] = "FibreChan RCtl"; 3585 param_table[bcmFieldQualifyFibreChanRCtl][1] = "Mask for FibreChan RCtl"; 3586 param_table[bcmFieldQualifyFibreChanFCtl][0] = "FibreChan FCtl"; 3587 param_table[bcmFieldQualifyFibreChanFCtl][1] = "Mask for FibreChan FCtl"; 3588 param_table[bcmFieldQualifyFibreChanCSCtl][0] = "FibreChan CSCtl"; 3589 param_table[bcmFieldQualifyFibreChanCSCtl][1] = "Mask for FibreChan CSCtl"; 3590 param_table[bcmFieldQualifyFibreChanDFCtl][0] = "FibreChan DFCtl"; 3591 param_table[bcmFieldQualifyFibreChanDFCtl][1] = "Mask for FibreChan DFCtl"; 3592 param_table[bcmFieldQualifyFibreChanType][0] = "FibreChan Type"; 3593 param_table[bcmFieldQualifyFibreChanType][1] = "Mask for FibreChan Type"; 3594 param_table[bcmFieldQualifyFibreChanSrcId][0] = "FibreChan SrcId"; 3595 param_table[bcmFieldQualifyFibreChanSrcId][1] = "Mask for FibreChan SrcId"; 3596 param_table[bcmFieldQualifyFibreChanDstId][0] = "FibreChan DstId"; 3597 param_table[bcmFieldQualifyFibreChanDstId][1] = "Mask for FibreChan DstId"; 3598 param_table[bcmFieldQualifyFibreChanZoneCheck][0] = "FibreChan Zone Check"; 3599 param_table[bcmFieldQualifyFibreChanZoneCheck][1] = "Mask for FibreChan Zone Check"; 3600 param_table[bcmFieldQualifyFibreChanSrcFpmaCheck][0] = "FibreChan Src Fpma Check"; 3601 param_table[bcmFieldQualifyFibreChanSrcFpmaCheck][1] = "Mask for FibreChan Src Fpma Check"; 3602 param_table[bcmFieldQualifyFibreChanSrcBindCheck][0] = "FibreChan Src Bind Check"; 3603 param_table[bcmFieldQualifyFibreChanSrcBindCheck][1] = "Mask for FibreChan Src Bind Check"; 3604 param_table[bcmFieldQualifyFibreChanVFTVersion][0] = "FibreChan VFT Version"; 3605 param_table[bcmFieldQualifyFibreChanVFTVersion][1] = "Mask for FibreChan VFT Version"; 3606 param_table[bcmFieldQualifyFibreChanVFTPri][0] = "FibreChan VFT Pri"; 3607 param_table[bcmFieldQualifyFibreChanVFTPri][1] = "Mask for FibreChan VFT Pri"; 3608 param_table[bcmFieldQualifyFibreChanVFTFabricId][0] = "FibreChan VFT Fabric Id"; 3609 param_table[bcmFieldQualifyFibreChanVFTFabricId][1] = "Mask for FibreChan VFT Fabric Id"; 3610 param_table[bcmFieldQualifyFibreChanVFTHopCount][0] = "FibreChan VFT Hop Count"; 3611 param_table[bcmFieldQualifyFibreChanVFTHopCount][1] = "Mask for FibreChan VFT Hop Count"; 3612 param_table[bcmFieldQualifyFibreChanVFTVsanId][0] = "FibreChan VFT Vsan Id"; 3613 param_table[bcmFieldQualifyFibreChanVFTVsanId][1] = "Mask for FibreChan VFT Vsan Id"; 3614 param_table[bcmFieldQualifyFibreChanVFTVsanPri][0] = "FibreChan VFT Vsan Pri"; 3615 param_table[bcmFieldQualifyFibreChanVFTVsanPri][1] = "Mask for FibreChan VFT Vsan Pri"; 3616 param_table[bcmFieldQualifyFibreChanVFTValid][0] = "FibreChan VFT Valid"; 3617 param_table[bcmFieldQualifyFibreChanVFTValid][1] = "Mask for FibreChan VFT Valid"; 3618 param_table[bcmFieldQualifyFcoeSOF][0] = "FibreChan Fcoe SOF"; 3619 param_table[bcmFieldQualifyFcoeSOF][1] = "Mask for FibreChan Fcoe SOF"; 3620 param_table[bcmFieldQualifyFcoeVersionIsZero][0] = "FibreChan Fcoe Version is Zero"; 3621 param_table[bcmFieldQualifyFcoeVersionIsZero][1] = "Mask for FibreChan Fcoe Version is Zero"; 3622 param_table[bcmFieldQualifySubportPktTag][0] = "SubportPktTag"; 3623 param_table[bcmFieldQualifySubportPktTag][1] = "SubportPktTag mask"; 3624 param_table[bcmFieldQualifySrcVxlanGport][0] = "Source vxlan gport"; 3625 param_table[bcmFieldQualifyDstVxlanGport][0] = "Destination vxlan gport"; 3626 param_table[bcmFieldQualifyOamMdl][0] = "OAM MDL Value"; 3627 param_table[bcmFieldQualifyOamMdl][1] = "OAM MDL Mask"; 3628 param_table[bcmFieldQualifyIntCongestionNotification][0] = "Int_cn value"; 3629 param_table[bcmFieldQualifyIntCongestionNotification][1] = "Int_cn mask"; 3630 param_table[bcmFieldQualifySrcNivGport][0] = "Source niv gport"; 3631 param_table[bcmFieldQualifyDstNivGport][0] = "Destination niv gport"; 3632 param_table[bcmFieldQualifyDstGport][0] = "Dst gport"; 3633 param_table[bcmFieldQualifySrcVlanGport][0] = "Source vlan gport"; 3634 param_table[bcmFieldQualifyDstVlanGport][0] = "Destination vlan gport"; 3635 param_table[bcmFieldQualifySrcVlanGports][0] = "Source Vlan gport"; 3636 param_table[bcmFieldQualifySrcVlanGports][1] = "Source Vlan gport mask"; 3637 param_table[bcmFieldQualifyDstVlanGports][0] = "Destination vlan gport"; 3638 param_table[bcmFieldQualifyDstVlanGports][1] = "Destination vlan gport mask"; 3639 param_table[bcmFieldQualifySrcVxlanGports][0] = "Source Vxlan gport"; 3640 param_table[bcmFieldQualifySrcVxlanGports][1] = "Source Vxlan gport mask"; 3641 param_table[bcmFieldQualifyDstVxlanGports][0] = "Destination Vxlan gport"; 3642 param_table[bcmFieldQualifyDstVxlanGports][1] = "Destination Vxlan gport mask"; 3643 param_table[bcmFieldQualifySrcWlanGports][0] = "Source Wlan gport"; 3644 param_table[bcmFieldQualifySrcWlanGports][1] = "Source Wlan gport mask"; 3645 param_table[bcmFieldQualifyDstWlanGports][0] = "Destination Wlan gport"; 3646 param_table[bcmFieldQualifyDstWlanGports][1] = "Destination Wlan gport mask"; 3647 param_table[bcmFieldQualifySrcMplsGports][0] = "Source Mpls gport"; 3648 param_table[bcmFieldQualifySrcMplsGports][1] = "Source Mpls gport mask"; 3649 param_table[bcmFieldQualifyDstMplsGports][0] = "Destination Mpls gport"; 3650 param_table[bcmFieldQualifyDstMplsGports][1] = "Destination Mpls gport mask"; 3651 param_table[bcmFieldQualifySrcGports][0] = "Source gport"; 3652 param_table[bcmFieldQualifySrcGports][1] = "Source gport mask"; 3653 param_table[bcmFieldQualifyDstGports][0] = "Destination gport"; 3654 param_table[bcmFieldQualifyDstGports][1] = "Destination gport mask"; 3655 param_table[bcmFieldQualifySrcMimGports][0] = "Source Mim gport"; 3656 param_table[bcmFieldQualifySrcMimGports][1] = "Source Mim gport mask"; 3657 param_table[bcmFieldQualifyDstMimGports][0] = "Destination Mim gport"; 3658 param_table[bcmFieldQualifyDstMimGports][1] = "Destination Mim gport mask"; 3659 param_table[bcmFieldQualifySrcNivGports][0] = "Source Niv gport"; 3660 param_table[bcmFieldQualifySrcNivGports][1] = "Source Niv gport mask"; 3661 param_table[bcmFieldQualifyDstNivGports][0] = "Destination Niv gport"; 3662 param_table[bcmFieldQualifyDstNivGports][1] = "Destination Niv gport mask"; 3663 param_table[bcmFieldQualifySrcModPortGports][0] = "Source ModPort gport"; 3664 param_table[bcmFieldQualifySrcModPortGports][1] = "Source ModPort gport mask"; 3665 param_table[bcmFieldQualifyDstMulticastGroups][0] = "Destination multicast group"; 3666 param_table[bcmFieldQualifyDstMulticastGroups][1] = "Destination multicast group mask."; 3667 param_table[bcmFieldQualifyIngressInterfaceClassVPort][0] = "Class Id value"; 3668 param_table[bcmFieldQualifyIngressInterfaceClassVPort][1] = "Mask for Class Id value"; 3669 param_table[bcmFieldQualifyDstMultipath][0] = "Destination Multipath ID"; 3670 param_table[bcmFieldQualifySrcVirtualPortValid][0] = "Source Virtual Port Valid Bit Value."; 3671 param_table[bcmFieldQualifySrcVirtualPortValid][1] = "Source Virtual Port Valid Bit Mask."; 3672 param_table[bcmFieldQualifyDestVirtualPortValid][0] = "Destination Virtual Port Valid Bit Value."; 3673 param_table[bcmFieldQualifyDestVirtualPortValid][1] = "Destination Virtual Port Valid Bit Mask."; 3674 param_table[bcmFieldQualifyVxlanHeaderBits8_31][0] = "Vxlan Header Reserved_1 field"; 3675 param_table[bcmFieldQualifyVxlanHeaderBits8_31][1] = "Vxlan Header Reserved_1 field mask"; 3676 param_table[bcmFieldQualifyVxlanHeaderBits56_63][0] = "Vxlan Header Reserved_2 field"; 3677 param_table[bcmFieldQualifyVxlanHeaderBits56_63][1] = "Vxlan Header Reserved_2 field mask"; 3678 param_table[bcmFieldQualifyOamType][0] = "OAM type Ethernet/Mpls"; 3679 param_table[bcmFieldQualifyEthernetOamHeaderBits0_31][0] = "OAM Header First 4 Bytes"; 3680 param_table[bcmFieldQualifyEthernetOamHeaderBits0_31][1] = "OAM Header First 4 Bytes Mask"; 3681 param_table[bcmFieldQualifyEthernetOamHeaderBits32_63][0] = "OAM Header Second 4 Bytes"; 3682 param_table[bcmFieldQualifyEthernetOamHeaderBits32_63][1] = "OAM Header Second 4 Bytes Mask"; 3683 param_table[bcmFieldQualifyEthernetOamDstClassL2][0] = "Destination L2 class"; 3684 param_table[bcmFieldQualifyEthernetOamDstClassL2][1] = "Destination L2 class Mask"; 3685 param_table[bcmFieldQualifyEthernetOamTxPktUPMEP][0] = " OAM UP-MEP Tx Packet"; 3686 param_table[bcmFieldQualifyEthernetOamTxPktUPMEP][1] = "OAM UP-MEP Tx Packet mask"; 3687 param_table[bcmFieldQualifyEthernetOamInterfaceClassPort][0] = "ClassId"; 3688 param_table[bcmFieldQualifyEthernetOamInterfaceClassPort][1] = "ClassId mask"; 3689 param_table[bcmFieldQualifyEthernetOamClassVlanTranslateKeyFirst][0] = "ClassId"; 3690 param_table[bcmFieldQualifyEthernetOamClassVlanTranslateKeyFirst][1] = "ClassId mask"; 3691 param_table[bcmFieldQualifyEthernetOamClassVlanTranslateKeySecond][0] = "ClassId"; 3692 param_table[bcmFieldQualifyEthernetOamClassVlanTranslateKeySecond][1] = "ClassId mask"; 3693 param_table[bcmFieldQualifyEthernetOamInterfaceClassNiv][0] = "ClassId"; 3694 param_table[bcmFieldQualifyEthernetOamInterfaceClassNiv][1] = "ClassId mask"; 3695 param_table[bcmFieldQualifyEthernetOamInterfaceClassMim][0] = "ClassId"; 3696 param_table[bcmFieldQualifyEthernetOamInterfaceClassMim][1] = "ClassId mask"; 3697 param_table[bcmFieldQualifyEthernetOamInterfaceClassVxlan][0] = "ClassId"; 3698 param_table[bcmFieldQualifyEthernetOamInterfaceClassVxlan][1] = "ClassId mask"; 3699 param_table[bcmFieldQualifyEthernetOamInterfaceClassVlan][0] = "ClassId"; 3700 param_table[bcmFieldQualifyEthernetOamInterfaceClassVlan][1] = "ClassId mask"; 3701 param_table[bcmFieldQualifyEthernetOamInterfaceClassMpls][0] = "ClassId"; 3702 param_table[bcmFieldQualifyEthernetOamInterfaceClassMpls][1] = "ClassId mask"; 3703 param_table[bcmFieldQualifyEthernetOamClassVpn][0] = "ClassId"; 3704 param_table[bcmFieldQualifyEthernetOamClassVpn][1] = "ClassId mask"; 3705 param_table[bcmFieldQualifyMplsOamHeaderBits0_31][0] = "OAM Header First 4 Bytes"; 3706 param_table[bcmFieldQualifyMplsOamHeaderBits0_31][1] = "OAM Header First 4 Bytes Mask"; 3707 param_table[bcmFieldQualifyMplsOamHeaderBits32_63][0] = "OAM Header Second 4 Bytes"; 3708 param_table[bcmFieldQualifyMplsOamHeaderBits32_63][1] = "OAM Header Second 4 Bytes Mask"; 3709 param_table[bcmFieldQualifyMplsOamGALLabelOnly][0] = "GAL Label Only"; 3710 param_table[bcmFieldQualifyMplsOamGALLabelOnly][1] = "GAL Label Only Mask"; 3711 param_table[bcmFieldQualifyMplsOamGALExposed][0] = "GAL exposed"; 3712 param_table[bcmFieldQualifyMplsOamGALExposed][1] = "GAL exposed Mask"; 3713 param_table[bcmFieldQualifyMplsOamUpperLabelDataDrop][0] = "Upper Label Data Drop"; 3714 param_table[bcmFieldQualifyMplsOamUpperLabelDataDrop][1] = "Upper Label Data Drop Mask"; 3715 param_table[bcmFieldQualifyMplsOamACH][0] = "ACH Header"; 3716 param_table[bcmFieldQualifyMplsOamACH][1] = "ACH Header Mask"; 3717 param_table[bcmFieldQualifyMplsOamControlPktType][0] = "Control packet type"; 3718 param_table[bcmFieldQualifyMplsOamControlPktType][1] = "Control packet type Mask"; 3719 param_table[bcmFieldQualifyMplsOamClassMplsSwitchLabel][0] = "ClassId"; 3720 param_table[bcmFieldQualifyMplsOamClassMplsSwitchLabel][1] = "ClassId Mask"; 3721 param_table[bcmFieldQualifyOamHeaderBits0_31][0] = "OAM Header First 4 Bytes"; 3722 param_table[bcmFieldQualifyOamHeaderBits0_31][1] = "OAM Header First 4 Bytes Mask"; 3723 param_table[bcmFieldQualifyOamHeaderBits32_63][0] = "OAM Header Second 4 Bytes"; 3724 param_table[bcmFieldQualifyOamHeaderBits32_63][1] = "OAM Header Second 4 Bytes Mask"; 3725 param_table[bcmFieldQualifyOamEgressClassVxlt][0] = "ClassId"; 3726 param_table[bcmFieldQualifyOamEgressClassVxlt][1] = "ClassId mask"; 3727 param_table[bcmFieldQualifyOamEgressClassPort][0] = "ClassId"; 3728 param_table[bcmFieldQualifyOamEgressClassPort][1] = "ClassId mask"; 3729 param_table[bcmFieldQualifyIpFragNonOrFirst][0] = "IpFragNonOrFirst bit"; 3730 param_table[bcmFieldQualifyIpFragNonOrFirst][1] = "IpFragNonOrFirst bit mask"; 3731 param_table[bcmFieldQualifyPacketLength][0] = "Total Packeth Length"; 3732 param_table[bcmFieldQualifyPacketLength][1] = "Total Packeth Length mask"; 3733 param_table[bcmFieldQualifyGroupClass][0] = "Group ClassId"; 3734 param_table[bcmFieldQualifyGroupClass][1] = "Group ClassId mask"; 3735 param_table[bcmFieldQualifyUdfClass][0] = "UDF ClassId"; 3736 param_table[bcmFieldQualifyUdfClass][1] = "UDF ClassId mask"; 3737 param_table[bcmFieldQualifyInterfaceLookupClassPort][0] = "ClassId"; 3738 param_table[bcmFieldQualifyInterfaceLookupClassPort][1] = "ClassId mask"; 3739 param_table[bcmFieldQualifyCustomHeaderPkt][0] = "Custom Header Packet"; 3740 param_table[bcmFieldQualifyCustomHeaderPkt][1] = "Custom Header Packet Mask"; 3741 param_table[bcmFieldQualifyCustomHeaderData][0] = "Custom Header Data"; 3742 param_table[bcmFieldQualifyCustomHeaderData][1] = "Custom Header Data Mask"; 3743 param_table[bcmFieldQualifyMimlPkt][0]= "Mac-in-Mac Lite(MiML) Packet"; 3744 param_table[bcmFieldQualifyMimlPkt][1]= "Mac-in-Mac Lite(MiML) Packet mask"; 3745 param_table[bcmFieldQualifyMimlVlan][0] = "Mac-in-Mac Lite(MiML) VLAN tag"; 3746 param_table[bcmFieldQualifyMimlVlan][1] = "16-bit mask"; 3747 param_table[bcmFieldQualifyMimlVlanPri][0] = "Mac-in-Mac Lite(MiML) VLAN priority"; 3748 param_table[bcmFieldQualifyMimlVlanPri][1] = "3-bit mask"; 3749 param_table[bcmFieldQualifyMimlVlanCfi][0] = "Mac-in-Mac Lite(MiML) VLAN CFI"; 3750 param_table[bcmFieldQualifyMimlVlanCfi][1] = "1-bit mask"; 3751 param_table[bcmFieldQualifyMimlVlanId][0] = "Mac-in-Mac Lite(MiML) VLAN id"; 3752 param_table[bcmFieldQualifyMimlVlanId][1] = "12-bit mask"; 3753 param_table[bcmFieldQualifyMimlInnerTag][0] = "Mac-in-Mac Lite(MiML) Inner Tag"; 3754 param_table[bcmFieldQualifyMimlInnerTag][1] = "Mac-in-Mac Lite(MiML) Inner Tag mask"; 3755 param_table[bcmFieldQualifyCapwapHdrType][0] = "TYPE field in CAPWAP header"; 3756 param_table[bcmFieldQualifyCapwapHdrType][1] = "TYPE field in CAPWAP header mask"; 3757 param_table[bcmFieldQualifyCapwapHdrRid][0] = "RID field in CAPWAP header"; 3758 param_table[bcmFieldQualifyCapwapHdrRid][1] = "RID field in CAPWAP header mask"; 3759 param_table[bcmFieldQualifyCapwapPayloadSOF][0] = "CAPWAP payload SOF"; 3760 param_table[bcmFieldQualifyCapwapPayloadSOF][1] = "1-bit mask"; 3761 param_table[bcmFieldQualifyCapwapPayloadEtherType][0] = "CAPWAP payload Ethertype"; 3762 param_table[bcmFieldQualifyCapwapPayloadEtherType][1] = "CAPWAP payload Ethertype mask"; 3763 param_table[bcmFieldQualifyCapwapPayloadOuterVlan][0] = "CAPWAP payload outer VLAN tag"; 3764 param_table[bcmFieldQualifyCapwapPayloadOuterVlan][1] = "16-bit mask"; 3765 param_table[bcmFieldQualifyCapwapPayloadOuterVlanId][0] = "CAPWAP payload outer VLAN id"; 3766 param_table[bcmFieldQualifyCapwapPayloadOuterVlanId][1] = "12-bit mask"; 3767 param_table[bcmFieldQualifyCapwapPayloadOuterVlanPri][0] = "CAPWAP payload outer VLAN priority"; 3768 param_table[bcmFieldQualifyCapwapPayloadOuterVlanPri][1] = "3-bit mask"; 3769 param_table[bcmFieldQualifyCapwapPayloadOuterVlanCfi][0] = "CAPWAP payload outer VLAN CFI"; 3770 param_table[bcmFieldQualifyCapwapPayloadOuterVlanCfi][1] = "1-bit mask"; 3771 param_table[bcmFieldQualifyCapwapPayloadInnerVlan][0] = "CAPWAP payload inner VLAN tag"; 3772 param_table[bcmFieldQualifyCapwapPayloadInnerVlan][1] = "16-bit mask"; 3773 param_table[bcmFieldQualifyCapwapPayloadInnerVlanId][0] = "CAPWAP payload inner VLAN id"; 3774 param_table[bcmFieldQualifyCapwapPayloadInnerVlanId][1] = "12-bit mask"; 3775 param_table[bcmFieldQualifyCapwapPayloadInnerVlanPri][0] = "CAPWAP payload inner VLAN priority"; 3776 param_table[bcmFieldQualifyCapwapPayloadInnerVlanPri][1] = "3-bit mask"; 3777 param_table[bcmFieldQualifyCapwapPayloadInnerVlanCfi][0] = "CAPWAP payload inner VLAN CFI"; 3778 param_table[bcmFieldQualifyCapwapPayloadInnerVlanCfi][1] = "1-bit mask"; 3779 param_table[bcmFieldQualifyCapwapPayloadVlanFormat][0] = "CAPWAP payload VLAN tag format"; 3780 param_table[bcmFieldQualifyCapwapPayloadVlanFormat][1] = "8-bit mask"; 3781 param_table[bcmFieldQualifyCapwapPayloadSip][0] = "CAPWAP payload source IP addr"; 3782 param_table[bcmFieldQualifyCapwapPayloadSip][1] = "CAPWAP payload source IP addr mask"; 3783 param_table[bcmFieldQualifyCapwapPayloadDip][0] = "CAPWAP payload dest IP addr"; 3784 param_table[bcmFieldQualifyCapwapPayloadDip][1] = "CAPWAP payload dest IP addr mask"; 3785 param_table[bcmFieldQualifyCapwapPayloadSip6][0] = "CAPWAP payload source IP6 addr"; 3786 param_table[bcmFieldQualifyCapwapPayloadSip6][1] = "CAPWAP payload source IP6 addr mask"; 3787 param_table[bcmFieldQualifyCapwapPayloadDip6][0] = "CAPWAP payload dest IP6 addr"; 3788 param_table[bcmFieldQualifyCapwapPayloadDip6][1] = "CAPWAP payload dest IP6 addr mask"; 3789 param_table[bcmFieldQualifyCapwapPayloadIpProtocol][0] = "CAPWAP payload IP protocol"; 3790 param_table[bcmFieldQualifyCapwapPayloadIpProtocol][1] = "CAPWAP payload IP protocol mask"; 3791 param_table[bcmFieldQualifyCapwapPayloadTos][0] = "CAPWAP payload Type-of-Service value"; 3792 param_table[bcmFieldQualifyCapwapPayloadTos][1] = "CAPWAP payload Type-of-Service mask"; 3793 param_table[bcmFieldQualifyCapwapPayloadL4DstPort][0] = "CAPWAP payload UDP/TCP dest port"; 3794 param_table[bcmFieldQualifyCapwapPayloadL4DstPort][1] = "CAPWAP payload UDP/TCP dest port mask"; 3795 param_table[bcmFieldQualifyCapwapPayloadL4SrcPort][0] = "CAPWAP payload UDP/TCP source port"; 3796 param_table[bcmFieldQualifyCapwapPayloadL4SrcPort][1] = "CAPWAP payload UDP/TCP source port mask"; 3797 param_table[bcmFieldQualifyCapwapPayloadL3HdrParseable][0] = "CAPWAP payload IP header can be parsed"; 3798 param_table[bcmFieldQualifyCapwapPayloadL3HdrParseable][1] = "1-bit mask"; 3799 param_table[bcmFieldQualifyCapwapPayloadL4HdrParseable][0] = "CAPWAP payload TCP/UDP header can be parsed"; 3800 param_table[bcmFieldQualifyCapwapPayloadL4HdrParseable][1] = "1-bit mask"; 3801 param_table[bcmFieldQualifyInterfaceIngressKeySelectClassPort][0] = "ClassId"; 3802 param_table[bcmFieldQualifyInterfaceIngressKeySelectClassPort][1] = "ClassId mask"; 3803 param_table[bcmFieldQualifyITag][0] = "Service Instance Tag in Mac-in-Mac"; 3804 param_table[bcmFieldQualifyITag][1] = "Service Instance Tag mask"; 3805 param_table[bcmFieldQualifyBfdYourDiscriminator][0] = "BFD Your Discriminator"; 3806 param_table[bcmFieldQualifyBfdYourDiscriminator][1] = "BFD Your Discriminator mask"; 3807 param_table[bcmFieldQualifyCpuVisibilityPacket][0] = "Cpu Visiblity Packet Flag"; 3808 param_table[bcmFieldQualifyCpuVisibilityPacket][1] = "Cpu Visiblity Packet Flag mask"; 3809 param_table[bcmFieldQualifyDstL2MulticastGroup][0] = "Destination L2 multicast group"; 3810 param_table[bcmFieldQualifyDstL2MulticastGroup][1] = "Destination L2 multicast group mask"; 3811 param_table[bcmFieldQualifyDstL3MulticastGroup][0] = "Destination L3 multicast group"; 3812 param_table[bcmFieldQualifyDstL3MulticastGroup][1] = "Destination L3 multicast group mask"; 3813 param_table[bcmFieldQualifyISid][0] = "Service Instance Id in Mac-in-Mac"; 3814 param_table[bcmFieldQualifyISid][1] = "Service Instance Id mask"; 3815 param_table[bcmFieldQualifyDownMepSatTerminated][0] = "1-bit data"; 3816 param_table[bcmFieldQualifyDownMepSatTerminated][1] = "1-bit mask"; 3817 param_table[bcmFieldQualifyDevicePortBitmap][0] = "Input Device Port Bitmap"; 3818 param_table[bcmFieldQualifyDevicePortBitmap][1] = "Device Port Bitmap Mask"; 3819 param_table[bcmFieldQualifySystemPortBitmap][0] = "System Port Bitmap"; 3820 param_table[bcmFieldQualifySystemPortBitmap][1] = "System Port Bitmap Mask"; 3821 param_table[bcmFieldQualifySourceGportBitmap][0] = "Source GPORT Bitmap"; 3822 param_table[bcmFieldQualifySourceGportBitmap][1] = "Source GPORT Bitmap Mask"; 3823 param_table[bcmFieldQualifyTosLower4Bits][0] = "Lower 4Bits Tos value"; 3824 param_table[bcmFieldQualifyTosLower4Bits][1] = "Lower 4Bits Tos Mask"; 3825 param_table[bcmFieldQualifyOamEgressClass2Vxlt][0] = "Class Id"; 3826 param_table[bcmFieldQualifyOamEgressClass2Vxlt][1] = "Class Id Mask"; 3827 param_table[bcmFieldQualifyOamEgressVxltFirstHit][0] = "1-bit data"; 3828 param_table[bcmFieldQualifyOamEgressVxltFirstHit][1] = "1-bit mask"; 3829 param_table[bcmFieldQualifyOamEgressVxltSecondHit][0] = "1-bit data"; 3830 param_table[bcmFieldQualifyOamEgressVxltSecondHit][1] = "1-bit mask"; 3831 param_table[bcmFieldQualifyOamDownMEPLoopbackPacket][0] = "1-bit data"; 3832 param_table[bcmFieldQualifyOamDownMEPLoopbackPacket][1] = "1-bit mask"; 3833 param_table[bcmFieldQualifyOamEgressPortUnicastDstMacHit][0] = "1-bit data"; 3834 param_table[bcmFieldQualifyOamEgressPortUnicastDstMacHit][1] = "1-bit mask"; 3835 param_table[bcmFieldQualifyTrunkMemberSourceModuleId][0] = "Module ID"; 3836 param_table[bcmFieldQualifyTrunkMemberSourceModuleId][1] = "Module ID mask"; 3837 param_table[bcmFieldQualifyEgressClassVxlan][0] = "Class Id"; 3838 param_table[bcmFieldQualifyEgressClassVxlan][1] = "Class Id mask"; 3839 param_table[bcmFieldQualifyOamEgressClassSrcMac][0] = "Class Id"; 3840 param_table[bcmFieldQualifyOamEgressClassSrcMac][1] = "Class Id Mask"; 3841 param_table[bcmFieldQualifyIngressDropEthernetOamControl][0] = "bcm_field_oam_drop_mep_type_t"; 3842 param_table[bcmFieldQualifyIngressDropEthernetOamData][0] = "bcm_field_oam_drop_mep_type_t"; 3843 param_table[bcmFieldQualifyIngressDropMplsOamControl][0] = "bcm_field_oam_drop_mep_type_t"; 3844 param_table[bcmFieldQualifyIngressDropMplsOamData][0] = "bcm_field_oam_drop_mep_type_t"; 3845 param_table[bcmFieldQualifyOamEgressEtherType][0] = "Oam EtherType value"; 3846 param_table[bcmFieldQualifyOamEgressMulticastMacHit][0] = "BCM_FIELD_OAM_MULTICAST_MAC_XXX Flag value"; 3847 param_table[bcmFieldQualifyMyStation2Hit][0] = "1 My Station table 2 hit, 0 otherwise"; 3848 param_table[bcmFieldQualifyMyStation2Hit][1] = "My Station table 2 hit mask"; 3849 param_table[bcmFieldQualifyPreemptablePacket][0]= "Preemptable Packet status"; 3850 param_table[bcmFieldQualifyPreemptablePacket][1]= "1-bit mask"; 3851 param_table[bcmFieldQualifyVxlanClassValid][0]= "VXLAN Class Id valid status"; 3852 param_table[bcmFieldQualifyVxlanClassValid][1]= "1-bit mask"; 3853 param_table[bcmFieldQualifyVxlanPacket][0]= "VXLAN Packet"; 3854 param_table[bcmFieldQualifyVxlanPacket][1]= "1-bit mask"; 3855 param_table[bcmFieldQualifyVxlanVnidVlanTranslateHit][0]= "VN_ID lookup hit status"; 3856 param_table[bcmFieldQualifyVxlanVnidVlanTranslateHit][1]= "1-bit mask"; 3857 param_table[bcmFieldQualifyVxlanPayloadVlanFormat][0]= "VXLAN payload VLAN tag format"; 3858 param_table[bcmFieldQualifyVxlanPayloadVlanFormat][1]= "8-bit mask"; 3859 param_table[bcmFieldQualifyTunnelPayloadEtherType][0]= "VXLAN payload Ethertype"; 3860 param_table[bcmFieldQualifyTunnelPayloadEtherType][1]= "VXLAN payload Ethertype mask"; 3861 param_table[bcmFieldQualifyTunnelPayloadOuterVlan][0]= "VXLAN payload outer VLAN tag"; 3862 param_table[bcmFieldQualifyTunnelPayloadOuterVlan][1]= "16-bit mask"; 3863 param_table[bcmFieldQualifyTunnelPayloadOuterVlanId][0]= "VXLAN payload outer VLAN id"; 3864 param_table[bcmFieldQualifyTunnelPayloadOuterVlanId][1]= "12-bit mask"; 3865 param_table[bcmFieldQualifyTunnelPayloadOuterVlanPri][0]= "VXLAN payload outer VLAN priority"; 3866 param_table[bcmFieldQualifyTunnelPayloadOuterVlanPri][1]= "3-bit mask"; 3867 param_table[bcmFieldQualifyTunnelPayloadOuterVlanCfi][0]= "VXLAN payload outer VLAN CFI"; 3868 param_table[bcmFieldQualifyTunnelPayloadOuterVlanCfi][1]= "1-bit mask"; 3869 param_table[bcmFieldQualifyTunnelPayloadSip][0]= "VXLAN payload source IP addr"; 3870 param_table[bcmFieldQualifyTunnelPayloadSip][1]= "VXLAN payload source IP addr mask"; 3871 param_table[bcmFieldQualifyTunnelPayloadDip][0]= "VXLAN payload dest IP addr"; 3872 param_table[bcmFieldQualifyTunnelPayloadDip][1]= "VXLAN payload dest IP addr mask"; 3873 param_table[bcmFieldQualifyTunnelPayloadSip6][0]= "VXLAN payload source IP6 addr"; 3874 param_table[bcmFieldQualifyTunnelPayloadSip6][1]= "VXLAN payload source IP6 addr mask"; 3875 param_table[bcmFieldQualifyTunnelPayloadDip6][0]= "VXLAN payload dest IP6 addr"; 3876 param_table[bcmFieldQualifyTunnelPayloadDip6][1]= "VXLAN payload dest IP6 addr mask"; 3877 param_table[bcmFieldQualifyTunnelPayloadIpProtocol][0]= "VXLAN payload IP protocol"; 3878 param_table[bcmFieldQualifyTunnelPayloadIpProtocol][1]= "VXLAN payload IP protocol mask"; 3879 param_table[bcmFieldQualifyTunnelPayloadL4DstPort][0]= "VXLAN payload UDP/TCP dest port"; 3880 param_table[bcmFieldQualifyTunnelPayloadL4DstPort][1]= "VXLAN payload UDP/TCP dest port mask"; 3881 param_table[bcmFieldQualifyTunnelPayloadL4SrcPort][0]= "VXLAN payload UDP/TCP source port"; 3882 param_table[bcmFieldQualifyTunnelPayloadL4SrcPort][1]= "VXLAN payload UDP/TCP source port mask"; 3883 param_table[bcmFieldQualifyMplsForwardingLabelExp][0] = "Exp of MPLS fowarding label"; 3884 param_table[bcmFieldQualifyMplsForwardingLabelExp][1] = "Exp mask of MPLS fowarding label"; 3885 param_table[bcmFieldQualifyRoeFrameType][0] = "bcm_field_roe_frame_type_t"; 3886 param_table[bcmFieldQualifyOpaqueTagType][0] = "Opaque tag type Data"; 3887 param_table[bcmFieldQualifyOpaqueTagType][1] = "Opaque tag type Mask"; 3888 param_table[bcmFieldQualifyOpaqueTagHigh][0] = "Opaque tag higher 32 bits Data"; 3889 param_table[bcmFieldQualifyOpaqueTagHigh][1] = "Opaque tag higher 32 bits Mask"; 3890 param_table[bcmFieldQualifyOpaqueTagLow][0] = "Opaque tag lower 32 bits Data"; 3891 param_table[bcmFieldQualifyOpaqueTagLow][1] = "Opaque tag lower 32 bits Mask"; 3892 3893 cli_out("------------------------ FP STAGE: %s ----------------------\n", stage_s); 3894 3895 cli_out("%-*s %-*s %-*s\n", width_col1, "QUALIFIER", width_col2, "DATA", 3896 width_col3, "MASK"); 3897 /* Print the normal 2 parameter qualifiers. */ 3898 for (qual = 0; qual < bcmFieldQualifyCount; qual++) { 3899 if(!fp_qual_supported(unit, fp_stage, qual)){ 3900 continue; 3901 } 3902 3903 if (qual == bcmFieldQualifySrcPort || 3904 qual == bcmFieldQualifyDstPort || 3905 qual == bcmFieldQualifySrcMac || 3906 qual == bcmFieldQualifyDstMac || 3907 qual == bcmFieldQualifyPacketRes || 3908 qual == bcmFieldQualifyStpState || 3909 qual == bcmFieldQualifyIpFrag || 3910 qual == bcmFieldQualifyLoopbackType || 3911 qual == bcmFieldQualifyTunnelType || 3912 qual == bcmFieldQualifyLookupStatus || 3913 qual == bcmFieldQualifyDstModid || 3914 qual == bcmFieldQualifyDstPortTgid || 3915 qual == bcmFieldQualifyPacketFormat || 3916 qual == bcmFieldQualifySrcModid || 3917 qual == bcmFieldQualifySrcPortTgid || 3918 qual == bcmFieldQualifyIpInfo || 3919 qual == bcmFieldQualifyIpProtocolCommon || 3920 qual == bcmFieldQualifyRoeFrameType || 3921 qual == bcmFieldQualifyMimlSrcMac || 3922 qual == bcmFieldQualifyMimlDstMac || 3923 qual == bcmFieldQualifyCapwapPayloadSrcMac || 3924 qual == bcmFieldQualifyCapwapPayloadDstMac || 3925 qual == bcmFieldQualifyTunnelPayloadSrcMac || 3926 qual == bcmFieldQualifyTunnelPayloadDstMac) { 3927 continue; 3928 } 3929 cli_out("%-*s %-*s %-*s\n", 3930 width_col1, format_field_qualifier(buf, qual, 1), 3931 width_col2, param_table[qual][0], 3932 width_col3, param_table[qual][1]); 3933 } 3934 3935 /* Print the qualifiers that use parse tables. */ 3936 if(fp_qual_supported(unit, fp_stage, bcmFieldQualifySrcMac)) { 3937 fp_qual_mac_help("", "SrcMac", width_col1); 3938 } 3939 3940 if(fp_qual_supported(unit, fp_stage, bcmFieldQualifyDstMac)) { 3941 fp_qual_mac_help("", "DstMac", width_col1); 3942 } 3943 3944 if(fp_qual_supported(unit, fp_stage, bcmFieldQualifyPacketRes)) { 3945 fp_qual_PacketRes_help("", width_col1); 3946 } 3947 3948 if(fp_qual_supported(unit, fp_stage, bcmFieldQualifyIpFrag)) { 3949 fp_qual_IpFrag_help("", width_col1); 3950 } 3951 3952 if(fp_qual_supported(unit, fp_stage, bcmFieldQualifyLoopbackType)) { 3953 fp_qual_LoopbackType_help("", width_col1); 3954 } 3955 3956 if(fp_qual_supported(unit, fp_stage, bcmFieldQualifyTunnelType)) { 3957 fp_qual_TunnelType_help("", width_col1); 3958 } 3959 3960 if(fp_qual_supported(unit, fp_stage, bcmFieldQualifySrcPort)) { 3961 fp_qual_modport_help("", "SrcPort", width_col1); 3962 } 3963 3964 if(fp_qual_supported(unit, fp_stage, bcmFieldQualifyDstPort)) { 3965 fp_qual_modport_help("", "DstPort", width_col1); 3966 } 3967 3968 if(fp_qual_supported(unit, fp_stage, bcmFieldQualifyIpInfo)) { 3969 fp_qual_IpInfo_help("", width_col1); 3970 } 3971 3972 if(fp_qual_supported(unit, fp_stage, bcmFieldQualifyColor)) { 3973 fp_qual_Color_help("", width_col1); 3974 } 3975 3976 if (fp_qual_supported(unit, fp_stage, bcmFieldQualifyIpProtocolCommon)) { 3977 fp_qual_IpProtocolCommon_help("", width_col1); 3978 } 3979 3980 if (fp_qual_supported(unit, fp_stage, bcmFieldQualifyForwardingType)) { 3981 fp_qual_ForwardingType_help("", width_col1); 3982 } 3983 3984 if(fp_qual_supported(unit, fp_stage, bcmFieldQualifyMimlSrcMac)) { 3985 fp_qual_mac_help("", "MimlSrcMac", width_col1); 3986 } 3987 3988 if(fp_qual_supported(unit, fp_stage, bcmFieldQualifyMimlDstMac)) { 3989 fp_qual_mac_help("", "MimlDstMac", width_col1); 3990 } 3991 3992 if(fp_qual_supported(unit, fp_stage, bcmFieldQualifyCapwapPayloadSrcMac)) { 3993 fp_qual_mac_help("", "CapwapPayloadSrcMac", width_col1); 3994 } 3995 3996 if(fp_qual_supported(unit, fp_stage, bcmFieldQualifyCapwapPayloadDstMac)) { 3997 fp_qual_mac_help("", "CapwapPayloadDstMac", width_col1); 3998 } 3999 4000 if (fp_qual_supported(unit, fp_stage, bcmFieldQualifyTunnelPayloadSrcMac)) { 4001 fp_qual_mac_help("", "TunnelPayloadSrcMac", width_col1); 4002 } 4003 4004 if (fp_qual_supported(unit, fp_stage, bcmFieldQualifyTunnelPayloadDstMac)) { 4005 fp_qual_mac_help("", "TunnelPayloadDstMac", width_col1); 4006 } 4007 4008 if(fp_qual_supported(unit, fp_stage, bcmFieldQualifyStpState)) { 4009 fp_qual_StpState_help("", width_col1); 4010 } 4011 4012 if(fp_qual_supported(unit, fp_stage, bcmFieldQualifyRoeFrameType)) { 4013 fp_qual_RoeFrameType_help("", width_col1); 4014 } 4015 4016 for (qual = 0; qual < bcmFieldQualifyCount; qual++) { 4017 sal_free(param_table[qual]); 4018 } 4019 sal_free(param_table); 4020 return CMD_OK; 4021 } 4022 4023 /* 4024 * Function: 4025 * fp_print_options 4026 * Purpose: 4027 * Print an array of options bracketed by <>. 4028 * Parmameters: 4029 * options - NULL terminated array of pointers to strings. 4030 * Returns: 4031 * Nothing 4032 */ 4033 STATIC void 4034 fp_print_options(const char *options[], const int offset) 4035 { 4036 int idx; 4037 int char_count = offset; 4038 4039 for (idx = 0; options[idx] != NULL; idx++) { 4040 char_count += (idx == 0) ? sal_strlen("<") : strlen(" | "); 4041 char_count += sal_strlen( options[idx]); 4042 cli_out("%s%s", idx == 0 ? "<" : " | ", options[idx]); 4043 if (char_count >= FP_LINE_SZ) { 4044 cli_out("\n%-*s", offset, ""); 4045 char_count -= FP_LINE_SZ; 4046 } 4047 } 4048 4049 cli_out(">"); 4050 4051 return; 4052 } 4053 4054 /* 4055 * Function: 4056 * fp_list_udf_flags 4057 * Purpose: 4058 * Display a list of Field qualifiers 4059 * Parmameters: 4060 * Returns: 4061 */ 4062 STATIC int 4063 fp_list_udf_flags(int unit) 4064 { 4065 cli_out("User-Defined Field Flags:\n"); 4066 cli_out("\tL2="); 4067 fp_print_options(l2_text, sal_strlen("\tL2=")); 4068 cli_out("\n\tVLan="); 4069 fp_print_options(vlan_text, sal_strlen("\tVLan=")); 4070 cli_out("\n\tIP="); 4071 fp_print_options(ip_text, sal_strlen("\tIP=")); 4072 cli_out("\n\tAdjustIpOptions=<True/False>"); 4073 cli_out("\n\tHigig=<True/False>"); 4074 cli_out("\n\tHigig2=<True/False>"); 4075 cli_out("\n"); 4076 4077 return CMD_OK; 4078 } 4079 4080 /* 4081 * Function: 4082 * fp_group_compress 4083 * Purpose: 4084 * Free unused resources occupied by a field group. 4085 * Parmameters: 4086 * Returns: 4087 */ 4088 STATIC int 4089 fp_group_compress(int unit, args_t *args) 4090 { 4091 char* subcmd = NULL; 4092 int retval = CMD_OK; 4093 bcm_field_group_t gid; 4094 4095 FP_GET_NUMB(gid, subcmd, args); 4096 4097 /* BCM.0> fp group compress 'gid' */ 4098 LOG_VERBOSE(BSL_LS_APPL_SHELL, 4099 (BSL_META_U(unit, 4100 "FP(unit %d) verb:bcm_field_group_compress(gid=%d)\n"), unit, gid)); 4101 4102 retval = bcm_field_group_compress(unit, gid); 4103 FP_CHECK_RETURN(unit, retval, "bcm_field_group_compress"); 4104 return CMD_OK; 4105 } 4106 /* 4107 * Function: 4108 * fp_group_lookup 4109 * Purpose: 4110 * Test getting/setting the FP group packet lookup enable/disable APIs. 4111 * Parmameters: 4112 * Returns: 4113 */ 4114 STATIC int 4115 fp_group_lookup(int unit, args_t *args) 4116 { 4117 char* subcmd = NULL; 4118 int retval = CMD_OK; 4119 bcm_field_group_t gid; 4120 int enable; 4121 4122 FP_GET_NUMB(gid, subcmd, args); 4123 4124 if ((subcmd = ARG_GET(args)) == NULL) { 4125 /* BCM.0> fp group lookup 'gid' */ 4126 LOG_VERBOSE(BSL_LS_APPL_SHELL, 4127 (BSL_META_U(unit, 4128 "FP(unit %d) verb:bcm_field_group_enable_get(gid=%d)\n"), unit, gid)); 4129 retval = bcm_field_group_enable_get(unit, gid, &enable); 4130 FP_CHECK_RETURN(unit, retval, "bcm_field_group_enable_get"); 4131 if (enable) { 4132 cli_out("GID %d: lookup=Enabled\n", gid); 4133 } else { 4134 cli_out("GID %d: lookup=Disabled\n", gid); 4135 } 4136 4137 return CMD_OK; 4138 } 4139 4140 /* BCM.0> fp group lookup 'gid' enable */ 4141 if(!sal_strcasecmp(subcmd, "enable")) { 4142 return fp_group_enable_set(unit, gid, 1); 4143 } 4144 4145 /* BCM.0> fp group lookup 'gid' disable */ 4146 if(!sal_strcasecmp(subcmd, "disable")) { 4147 return fp_group_enable_set(unit, gid, 0); 4148 } 4149 return CMD_USAGE; 4150 } 4151 4152 /* 4153 * Function: 4154 * Purpose: 4155 * Parmameters: 4156 * Returns: 4157 */ 4158 STATIC int 4159 fp_group_enable_set(int unit, bcm_field_group_t gid, int enable) 4160 { 4161 int retval = CMD_OK; 4162 4163 /* BCM.0> fp group enable/disable 'gid' */ 4164 LOG_VERBOSE(BSL_LS_APPL_SHELL, 4165 (BSL_META_U(unit, 4166 "FP(unit %d) verb:bcm_field_group_enable_set(gid=%d, enable=%d)\n"), unit, gid, enable)); 4167 retval = bcm_field_group_enable_set(unit, gid, enable); 4168 FP_CHECK_RETURN(unit, retval, "bcm_field_group_enable_set"); 4169 4170 return CMD_OK; 4171 } 4172 4173 /* 4174 * Function: 4175 * fp_qset 4176 * Purpose: 4177 * Parmameters: 4178 * Returns: 4179 */ 4180 STATIC int 4181 fp_qset(int unit, args_t *args, bcm_field_qset_t *qset) 4182 { 4183 char* subcmd = NULL; 4184 4185 if ((subcmd = ARG_GET(args)) == NULL) { 4186 return CMD_USAGE; 4187 } 4188 4189 /* BCM.0> fp qset clear */ 4190 if(!sal_strcasecmp(subcmd, "clear")) { 4191 BCM_FIELD_QSET_INIT(*qset); 4192 return CMD_OK; 4193 } 4194 /* BCM.0> fp qset add ...*/ 4195 if(!sal_strcasecmp(subcmd, "add")) { 4196 return fp_qset_add(unit, args, qset); 4197 } 4198 /* BCM.0> fp qset set ...*/ 4199 if(!sal_strcasecmp(subcmd, "set")) { 4200 return fp_qset_set(unit, args, qset); 4201 } 4202 /* BCM.0> fp qset show */ 4203 if(!sal_strcasecmp(subcmd, "show")) { 4204 return fp_qset_show(qset); 4205 } 4206 4207 return CMD_USAGE; 4208 } 4209 4210 /* 4211 * Function: 4212 * Purpose: 4213 * Parmameters: 4214 * Returns: 4215 */ 4216 STATIC int 4217 fp_qset_set(int unit, args_t *args, bcm_field_qset_t *qset) 4218 { 4219 char *qual_str = NULL; 4220 char *buf; 4221 4222 if ((qual_str = ARG_GET(args)) == NULL) { 4223 return CMD_USAGE; 4224 } 4225 4226 BCM_FIELD_QSET_INIT(*qset); 4227 buf = (char *) sal_alloc((BCM_FIELD_QSET_WIDTH_MAX * sizeof(char)), 4228 "qset string"); 4229 if (NULL == buf) { 4230 return (BCM_E_MEMORY); 4231 } 4232 4233 if (parse_field_qset(qual_str, qset) == 0) { 4234 sal_free(buf); 4235 return CMD_FAIL; 4236 } 4237 cli_out("fp_qset_set(%s) okay\n", format_field_qset(buf, *qset, " ")); 4238 sal_free(buf); 4239 return CMD_OK; 4240 } 4241 4242 /* 4243 * Function: 4244 * Purpose: 4245 * Parmameters: 4246 * Returns: 4247 */ 4248 STATIC int 4249 fp_qset_add(int unit, args_t *args, bcm_field_qset_t *qset) 4250 { 4251 char *qual_str = NULL; 4252 char buf[BCM_FIELD_QUALIFY_WIDTH_MAX]; 4253 bcm_field_qualify_t qual; 4254 int dq_id; 4255 char *subcmd = NULL; 4256 int retval; 4257 4258 if ((qual_str = ARG_GET(args)) == NULL) { 4259 return CMD_USAGE; 4260 } 4261 4262 /* 4263 * Argument exception: "Data " does not correspond directly to 4264 * any bcmFieldQualify* enum. 4265 */ 4266 if(!sal_strcasecmp(qual_str, "Data")) { 4267 FP_GET_NUMB(dq_id, subcmd, args); 4268 LOG_VERBOSE(BSL_LS_APPL_SHELL, 4269 (BSL_META_U(unit, 4270 "FP(unit %d) verb:fp_qset_add: data qualifier=%d\n"), unit, dq_id)); 4271 retval = bcm_field_qset_data_qualifier_add(unit, qset, dq_id); 4272 FP_CHECK_RETURN(unit, retval, "bcm_field_qset_data_qualifier_add"); 4273 return CMD_OK; 4274 } 4275 4276 4277 if (isint(qual_str)) { 4278 qual = parse_integer(qual_str); 4279 } else { 4280 qual = parse_field_qualifier(qual_str); 4281 4282 if (qual == bcmFieldQualifyCount) { 4283 LOG_ERROR(BSL_LS_APPL_SHELL, 4284 (BSL_META_U(unit, 4285 "FP(unit %d) Error: Unknown qualifier: %s\n"), unit, qual_str)); 4286 return CMD_FAIL; 4287 } 4288 } 4289 4290 BCM_FIELD_QSET_ADD(*qset, qual); 4291 cli_out("BCM_FIELD_QSET_ADD(%s) okay\n", 4292 format_field_qualifier(buf, qual, 1)); 4293 return CMD_OK; 4294 } 4295 4296 /* 4297 * Function: 4298 * Purpose: 4299 * Parmameters: 4300 * Returns: 4301 */ 4302 STATIC int 4303 fp_qset_show(bcm_field_qset_t *qset) 4304 { 4305 #ifdef BROADCOM_DEBUG 4306 _field_qset_dump("qset=", *qset, "\n"); 4307 #endif /* BROADCOM_DEBUG */ 4308 4309 return CMD_OK; 4310 } 4311 4312 /* 4313 * Function: 4314 * fp_aset 4315 * Purpose: 4316 * Parmameters: 4317 * Returns: 4318 */ 4319 STATIC int 4320 fp_aset(int unit, args_t *args, bcm_field_aset_t *aset) 4321 { 4322 char* subcmd = NULL; 4323 4324 if ((subcmd = ARG_GET(args)) == NULL) { 4325 return CMD_USAGE; 4326 } 4327 4328 /* BCM.0> fp aset add ...*/ 4329 if(!sal_strcasecmp(subcmd, "add")) { 4330 return fp_aset_add(unit, args, aset); 4331 } 4332 /* BCM.0> fp aset delete...*/ 4333 if(!sal_strcasecmp(subcmd, "delete")) { 4334 return fp_aset_delete(unit, args); 4335 } 4336 /* BCM.0> fp aset show ...*/ 4337 if(!sal_strcasecmp(subcmd, "show")) { 4338 return fp_aset_show(unit, args); 4339 } 4340 /* BCM.0> fp aset clear ...*/ 4341 if(!sal_strcasecmp(subcmd, "clear")) { 4342 return fp_aset_clear(unit, args); 4343 } 4344 return CMD_USAGE; 4345 } 4346 4347 /* 4348 * Function: 4349 * Purpose: 4350 * Parmameters: 4351 * Returns: 4352 */ 4353 STATIC int 4354 fp_aset_add(int unit, args_t *args, bcm_field_aset_t *aset) 4355 { 4356 char *subcmd = NULL; 4357 char *action_str = NULL; 4358 bcm_field_group_t gid; 4359 char *buf; 4360 int retval; 4361 4362 FP_GET_NUMB(gid, subcmd, args); 4363 4364 if ((action_str = ARG_GET(args)) == NULL) { 4365 return CMD_USAGE; 4366 } 4367 4368 BCM_FIELD_ASET_INIT(*aset); 4369 buf = (char *) sal_alloc((BCM_FIELD_ASET_WIDTH_MAX * sizeof(char)), 4370 "aset string"); 4371 if (NULL == buf) { 4372 return (BCM_E_MEMORY); 4373 } 4374 4375 bcm_field_group_action_get(unit, gid, aset); 4376 4377 if (parse_field_aset(action_str, aset, 1) == 0) { 4378 sal_free(buf); 4379 return CMD_FAIL; 4380 } 4381 4382 if ((retval = bcm_field_group_action_set(unit, gid, *aset)) < 0) { 4383 sal_free(buf); 4384 } 4385 FP_CHECK_RETURN(unit, retval, "bcm_field_group_action_set"); 4386 cli_out("fp_aset_add(%s) okay\n", format_field_aset(buf, *aset, " ")); 4387 sal_free(buf); 4388 return CMD_OK; 4389 } 4390 4391 /* 4392 * Function: 4393 * Purpose: 4394 * Parmameters: 4395 * Returns: 4396 */ 4397 STATIC int 4398 fp_aset_delete(int unit, args_t *args) 4399 { 4400 char *subcmd = NULL; 4401 char *action_str = NULL; 4402 bcm_field_group_t gid; 4403 bcm_field_aset_t aset; 4404 int retval; 4405 4406 FP_GET_NUMB(gid, subcmd, args); 4407 4408 if ((action_str = ARG_GET(args)) == NULL) { 4409 return CMD_USAGE; 4410 } 4411 BCM_FIELD_ASET_INIT(aset); 4412 4413 bcm_field_group_action_get(unit, gid, &aset); 4414 if (parse_field_aset(action_str, &aset, 0) == 0) { 4415 return CMD_FAIL; 4416 } 4417 retval = bcm_field_group_action_set(unit, gid, aset); 4418 FP_CHECK_RETURN(unit, retval, "bcm_field_group_action_set"); 4419 return CMD_OK; 4420 } 4421 4422 /* 4423 * Function: 4424 * Purpose: 4425 * Parmameters: 4426 * Returns: 4427 */ 4428 STATIC int 4429 fp_aset_clear(int unit, args_t *args) 4430 { 4431 char *subcmd = NULL; 4432 char *action_str = NULL; 4433 bcm_field_group_t gid; 4434 bcm_field_aset_t aset; 4435 int retval; 4436 4437 FP_GET_NUMB(gid, subcmd, args); 4438 4439 if ((action_str = ARG_GET(args)) != NULL) { 4440 return CMD_USAGE; 4441 } 4442 BCM_FIELD_ASET_INIT(aset); 4443 retval = bcm_field_group_action_set(unit, gid, aset); 4444 FP_CHECK_RETURN(unit, retval, "bcm_field_group_action_set"); 4445 return CMD_OK; 4446 } 4447 4448 /* 4449 * Function: 4450 * Purpose: 4451 * Parmameters: 4452 * Returns: 4453 */ 4454 STATIC int 4455 fp_aset_show(int unit, args_t *args) 4456 { 4457 char *subcmd = NULL; 4458 char *action_str = NULL; 4459 bcm_field_group_t gid; 4460 #if defined(BCM_TOMAHAWK_SUPPORT) 4461 _bcm_field_aset_t _aset; 4462 #else 4463 bcm_field_aset_t _aset; 4464 #endif 4465 bcm_field_aset_t aset; 4466 4467 FP_GET_NUMB(gid, subcmd, args); 4468 4469 if ((action_str = ARG_GET(args)) != NULL) { 4470 return CMD_USAGE; 4471 } 4472 4473 BCM_FIELD_ASET_INIT(aset); 4474 bcm_field_group_action_get(unit, gid, &aset); 4475 4476 sal_memcpy(&_aset, &aset, sizeof(bcm_field_aset_t)); 4477 #ifdef BROADCOM_DEBUG 4478 cli_out("Gid %d. ", gid); 4479 _field_aset_dump("aset=", _aset, "\n"); 4480 #endif /* BROADCOM_DEBUG */ 4481 return CMD_OK; 4482 } 4483 4484 /* 4485 * Function: 4486 * fp_lookup_control 4487 * Purpose: 4488 * Lookup a control from a user string. 4489 * Parmameters: 4490 * Returns: 4491 */ 4492 STATIC void 4493 fp_lookup_control(const char *control_str, bcm_field_control_t *control) 4494 { 4495 char tbl_str[FP_STAT_STR_SZ]; 4496 char lng_str[FP_STAT_STR_SZ]; 4497 4498 assert(control_str != NULL); 4499 assert(sal_strlen(control_str) < FP_STAT_STR_SZ - 1); 4500 assert(control != NULL); 4501 4502 for (*control = 0; *control < bcmFieldControlCount; (*control)++) { 4503 sal_memset(tbl_str, 0, sizeof(char) * FP_STAT_STR_SZ); 4504 sal_memset(lng_str, 0, sizeof(char) * FP_STAT_STR_SZ); 4505 /* Test for the suffix only */ 4506 strncpy(tbl_str, _fp_control_name(*control), FP_STAT_STR_SZ - 1); 4507 if (!sal_strcasecmp(tbl_str, control_str)) { 4508 break; 4509 } 4510 /* Test for whole name of the control */ 4511 sal_strcpy(lng_str, "bcmFieldControl"); 4512 strncat(lng_str, tbl_str, 4513 FP_STAT_STR_SZ - 1 - sal_strlen("bcmFieldControl")); 4514 if (!sal_strcasecmp(lng_str, control_str)) { 4515 break; 4516 } 4517 } 4518 4519 /* If not found, result is bcmFieldActionCount */ 4520 } 4521 4522 /* 4523 * Function: 4524 * fp_lookup_L2Format 4525 * Purpose: 4526 * Lookup a field L2Format value from a user string. 4527 * Parmameters: 4528 * type_str - search string 4529 * Returns: 4530 * corresponding L2Format value 4531 */ 4532 STATIC bcm_field_L2Format_t 4533 fp_lookup_L2Format(const char *type_str) 4534 { 4535 char tbl_str[FP_STAT_STR_SZ]; 4536 char lng_str[FP_STAT_STR_SZ]; 4537 const char *prefix = "bcmFieldL2Format"; 4538 bcm_field_L2Format_t type; 4539 4540 assert(type_str != NULL); 4541 assert(sal_strlen(type_str) < FP_STAT_STR_SZ - 1); 4542 4543 for (type = 0; type < bcmFieldL2FormatCount; (type)++) { 4544 /* Test for the suffix only */ 4545 sal_memset(tbl_str, 0, sizeof(char) * FP_STAT_STR_SZ); 4546 strncpy(tbl_str, _fp_qual_L2Format_name(type), FP_STAT_STR_SZ - 1); 4547 if (!sal_strcasecmp(tbl_str, type_str)) { 4548 break; 4549 } 4550 /* Test for whole name of the L2Format*/ 4551 sal_memset(lng_str, 0, sizeof(char) * FP_STAT_STR_SZ); 4552 strncpy(lng_str, prefix, sal_strlen(prefix)); 4553 strncat(lng_str, tbl_str, FP_STAT_STR_SZ - 1 - sal_strlen(prefix)); 4554 if (!sal_strcasecmp(lng_str, type_str)) { 4555 break; 4556 } 4557 } 4558 4559 /* If not found, result is bcmFieldL2FormatCount */ 4560 return type; 4561 } 4562 4563 /* 4564 * Function: 4565 * fp_lookup_IpType 4566 * Purpose: 4567 * Lookup a field IpType value from a user string. 4568 * Parmameters: 4569 * type_str - search string 4570 * Returns: 4571 * corresponding IpType value 4572 */ 4573 STATIC bcm_field_IpType_t 4574 fp_lookup_IpType(const char *type_str) 4575 { 4576 char tbl_str[FP_STAT_STR_SZ]; 4577 char lng_str[FP_STAT_STR_SZ]; 4578 const char *prefix = "bcmFieldIpType"; 4579 bcm_field_IpType_t type; 4580 4581 assert(type_str != NULL); 4582 assert(sal_strlen(type_str) < FP_STAT_STR_SZ - 1); 4583 4584 for (type = 0; type < bcmFieldIpTypeCount; (type)++) { 4585 /* Test for the suffix only */ 4586 sal_memset(tbl_str, 0, sizeof(char) * FP_STAT_STR_SZ); 4587 strncpy(tbl_str, _fp_qual_IpType_name(type), FP_STAT_STR_SZ - 1); 4588 if (!sal_strcasecmp(tbl_str, type_str)) { 4589 break; 4590 } 4591 /* Test for whole name of the IpType*/ 4592 sal_memset(lng_str, 0, sizeof(char) * FP_STAT_STR_SZ); 4593 strncpy(lng_str, prefix, sal_strlen(prefix)); 4594 strncat(lng_str, tbl_str, FP_STAT_STR_SZ - 1 - sal_strlen(prefix)); 4595 if (!sal_strcasecmp(lng_str, type_str)) { 4596 break; 4597 } 4598 } 4599 4600 /* If not found, result is bcmFieldIpTypeCount */ 4601 return type; 4602 } 4603 4604 /* 4605 * Function: 4606 * fp_lookup_IpProtocolCommon 4607 * Purpose: 4608 * Lookup a field IpProtocolCommon value from a user string. 4609 * Parmameters: 4610 * type_str - search string 4611 * Returns: 4612 * corresponding IpProtocolCommon value 4613 */ 4614 STATIC bcm_field_IpProtocolCommon_t 4615 fp_lookup_IpProtocolCommon(const char *type_str) 4616 { 4617 char tbl_str[FP_STAT_STR_SZ]; 4618 char lng_str[FP_STAT_STR_SZ]; 4619 const char *prefix = "bcmFieldIpProtocolCommon"; 4620 bcm_field_IpProtocolCommon_t type; 4621 4622 assert(type_str != NULL); 4623 assert(strlen(type_str) < FP_STAT_STR_SZ - 1); 4624 4625 for (type = 0; type < bcmFieldIpProtocolCommonCount; (type)++) { 4626 /* Test for the suffix only */ 4627 sal_memset(tbl_str, 0, sizeof(char) * FP_STAT_STR_SZ); 4628 sal_strncpy(tbl_str, _fp_qual_IpProtocolCommon_name(type), 4629 FP_STAT_STR_SZ - 1); 4630 if (!sal_strcasecmp(tbl_str, type_str)) { 4631 break; 4632 } 4633 /* Test for whole name of the IpProtocolCommon*/ 4634 sal_memset(lng_str, 0, sizeof(char) * FP_STAT_STR_SZ); 4635 sal_strncpy(lng_str, prefix, sal_strlen(prefix)); 4636 strncat(lng_str, tbl_str, FP_STAT_STR_SZ - 1 - sal_strlen(prefix)); 4637 if (!sal_strcasecmp(lng_str, type_str)) { 4638 break; 4639 } 4640 } 4641 4642 /* If not found, result is bcmFieldIpProtocolCommonCount */ 4643 return type; 4644 } 4645 4646 /* 4647 * Function: 4648 * fp_lookup_stage 4649 * Purpose: 4650 * Lookup a field stage value from a user string. 4651 * Parmameters: 4652 * stage_str - search string 4653 * stage - (OUT) corresponding stage value 4654 * Returns: 4655 */ 4656 STATIC bcm_field_stage_t 4657 fp_lookup_stage(const char *stage_str) 4658 { 4659 char tbl_str[FP_STAT_STR_SZ]; 4660 char lng_str[FP_STAT_STR_SZ]; 4661 bcm_field_stage_t stage; 4662 4663 assert(stage_str != NULL); 4664 assert(sal_strlen(stage_str) < FP_STAT_STR_SZ - 1); 4665 4666 for (stage = 0; stage < bcmFieldStageCount; stage++) { 4667 sal_memset(tbl_str, 0, sizeof(char) * FP_STAT_STR_SZ); 4668 sal_memset(lng_str, 0, sizeof(char) * FP_STAT_STR_SZ); 4669 /* Test for the suffix only */ 4670 strncpy(tbl_str, _fp_qual_stage_name(stage), FP_STAT_STR_SZ - 1); 4671 if (!sal_strcasecmp(tbl_str, stage_str)) { 4672 break; 4673 } 4674 /* Test for whole name of the Stage */ 4675 sal_strcpy(lng_str, "bcmFieldStage"); 4676 strncat(lng_str, tbl_str, 4677 FP_STAT_STR_SZ - 1 - sal_strlen("bcmFieldStage")); 4678 if (!sal_strcasecmp(lng_str, stage_str)) { 4679 break; 4680 } 4681 } 4682 4683 /* If not found, result is bcmFieldStageCount */ 4684 return stage; 4685 } 4686 4687 /* 4688 * Function: 4689 * Purpose: 4690 * Parmameters: 4691 * Returns: 4692 */ 4693 STATIC int 4694 fp_qual(int unit, args_t *args) 4695 { 4696 char *subcmd = NULL; 4697 char *qual_str = NULL; 4698 bcm_field_entry_t eid; 4699 int rv = CMD_OK; 4700 4701 FP_GET_NUMB(eid, subcmd, args); 4702 /* > fp qual 'eid' ...*/ 4703 4704 if ((qual_str = ARG_GET(args)) == NULL) { 4705 return CMD_USAGE; 4706 } 4707 4708 /* 4709 * Argument exception: "clear" does not correspond directly to 4710 * any bcmFieldQualify* enum. 4711 */ 4712 if(!sal_strcasecmp(qual_str, "clear")) { 4713 /* BCM.0> fp qual 'eid' clear */ 4714 LOG_VERBOSE(BSL_LS_APPL_SHELL, 4715 (BSL_META_U(unit, 4716 "FP(unit %d) verb:fp_qual_clear 'eid=%d'\n"), unit, eid)); 4717 rv = bcm_field_qualify_clear(unit, eid); 4718 FP_CHECK_RETURN(unit, rv, "bcm_field_qualify_clear"); 4719 4720 return rv; 4721 } 4722 4723 /* 4724 * Argument exception: "delete" does not correspond directly to 4725 * any bcmFieldQualify* enum. 4726 */ 4727 if(!sal_strcasecmp(qual_str, "delete")) { 4728 if ((qual_str = ARG_GET(args)) == NULL) { 4729 return CMD_USAGE; 4730 } 4731 /* BCM.0> fp qual 'eid' delete 'qual_name' */ 4732 LOG_VERBOSE(BSL_LS_APPL_SHELL, 4733 (BSL_META_U(unit, 4734 "FP(unit %d) verb:fp_qual_delete 'eid=%d qual=%s'\n"), unit, eid, qual_str)); 4735 rv = bcm_field_qualifier_delete(unit, eid, 4736 parse_field_qualifier(qual_str)); 4737 FP_CHECK_RETURN(unit, rv, "bcm_field_qualifier_delete"); 4738 4739 return rv; 4740 } 4741 4742 /* 4743 * Argument exception: "Data" does not correspond directly to 4744 * any bcmFieldQualify* enum. 4745 */ 4746 if(!sal_strcasecmp(qual_str, "Data")) { 4747 return fp_qual_data(unit, eid, args); 4748 } 4749 4750 subcmd = ARG_GET(args); 4751 if (subcmd != NULL) { 4752 if ((!sal_strcasecmp(subcmd, "show")) || 4753 (!sal_strcasecmp(subcmd, "?"))) { 4754 switch (parse_field_qualifier(qual_str)) { 4755 case bcmFieldQualifyIpInfo: 4756 return fp_qual_IpInfo_help("fp qual <eid> ", 0); 4757 break; 4758 case bcmFieldQualifyPacketRes: 4759 return fp_qual_PacketRes_help("fp qual <eid> ", 0); 4760 break; 4761 case bcmFieldQualifyIpFrag: 4762 return fp_qual_IpFrag_help("fp qual <eid> ", 0); 4763 break; 4764 case bcmFieldQualifyLoopbackType: 4765 return fp_qual_LoopbackType_help("fp qual <eid> ", 0); 4766 break; 4767 case bcmFieldQualifyTunnelType: 4768 return fp_qual_TunnelType_help("fp qual <eid> ", 0); 4769 break; 4770 case bcmFieldQualifySrcPort: 4771 return fp_qual_modport_help("fp qual <eid> ", "SrcPort", 0); 4772 break; 4773 case bcmFieldQualifyDstPort: 4774 return fp_qual_modport_help("fp qual <eid> ", "DstPort", 0); 4775 break; 4776 case bcmFieldQualifySrcMac: 4777 return fp_qual_mac_help("fp qual <eid> ", "SrcMac", 0); 4778 break; 4779 case bcmFieldQualifyDstMac: 4780 return fp_qual_mac_help("fp qual <eid> ", "DstMac", 0); 4781 break; 4782 case bcmFieldQualifyForwardingType: 4783 return fp_qual_ForwardingType_help("fp qual <eid> ", 0); 4784 break; 4785 case bcmFieldQualifyMimlSrcMac: 4786 return fp_qual_mac_help("fp qual <eid> ", "MimlSrcMac", 0); 4787 break; 4788 case bcmFieldQualifyMimlDstMac: 4789 return fp_qual_mac_help("fp qual <eid> ", "MimlDstMac", 0); 4790 break; 4791 case bcmFieldQualifyCapwapPayloadSrcMac: 4792 return fp_qual_mac_help("fp qual <eid> ", "CapwapPayloadSrcMac", 0); 4793 break; 4794 case bcmFieldQualifyCapwapPayloadDstMac: 4795 return fp_qual_mac_help("fp qual <eid> ", "CapwapPayloadDstMac", 0); 4796 break; 4797 case bcmFieldQualifyTunnelPayloadSrcMac: 4798 return fp_qual_mac_help("fp qual <eid> ", "TunnelPayloadSrcMac", 0); 4799 break; 4800 case bcmFieldQualifyTunnelPayloadDstMac: 4801 return fp_qual_mac_help("fp qual <eid> ", "TunnelPayloadDstMac", 0); 4802 break; 4803 case bcmFieldQualifyStpState: 4804 return fp_qual_StpState_help("fp qual <eid> ", 0); 4805 break; 4806 case bcmFieldQualifyRoeFrameType: 4807 return fp_qual_RoeFrameType_help("fp qual <eid> ", 0); 4808 break; 4809 default: 4810 return fp_list_quals(unit, args); 4811 } 4812 } else { 4813 ARG_PREV(args); 4814 } 4815 } 4816 4817 /* > fp qual 'eid' bcmFieldQualifyXXX ...*/ 4818 switch (parse_field_qualifier(qual_str)) { 4819 case bcmFieldQualifyInPort: 4820 rv = fp_qual_port(unit, eid, args, bcm_field_qualify_InPort, 4821 "InPort"); 4822 break; 4823 case bcmFieldQualifyOutPort: 4824 rv = fp_qual_port(unit, eid, args, bcm_field_qualify_OutPort, 4825 "OutPort"); 4826 break; 4827 case bcmFieldQualifyInPorts: 4828 rv = fp_qual_InPorts(unit, eid, bcmFieldQualifyInPorts, args); 4829 break; 4830 case bcmFieldQualifyDevicePortBitmap: 4831 rv = fp_qual_InPorts(unit, eid, bcmFieldQualifyDevicePortBitmap, args); 4832 break; 4833 case bcmFieldQualifySystemPortBitmap: 4834 rv = fp_qual_InPorts(unit, eid, bcmFieldQualifySystemPortBitmap, args); 4835 break; 4836 case bcmFieldQualifySourceGportBitmap: 4837 rv = fp_qual_InPorts(unit, eid, bcmFieldQualifySourceGportBitmap, args); 4838 break; 4839 case bcmFieldQualifyOutPorts: 4840 rv = fp_qual_OutPorts(unit, eid, args); 4841 break; 4842 case bcmFieldQualifyDrop: 4843 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_Drop, 4844 "Drop"); 4845 break; 4846 case bcmFieldQualifyLoopback: 4847 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_Loopback, 4848 "Loopback"); 4849 break; 4850 case bcmFieldQualifySrcPort: 4851 rv = fp_qual_modport(unit, eid, args, bcm_field_qualify_SrcPort, 4852 "SrcPort"); 4853 break; 4854 case bcmFieldQualifySrcTrunk: 4855 rv = fp_qual_trunk(unit, eid, args, bcm_field_qualify_SrcTrunk, 4856 "SrcTrunk"); 4857 break; 4858 case bcmFieldQualifyDstPort: 4859 rv = fp_qual_modport(unit, eid, args, bcm_field_qualify_DstPort, 4860 "DstPort"); 4861 break; 4862 case bcmFieldQualifyDstTrunk: 4863 rv = fp_qual_trunk(unit, eid, args, bcm_field_qualify_DstTrunk, 4864 "DstTrunk"); 4865 break; 4866 case bcmFieldQualifyL4SrcPort: 4867 rv = fp_qual_l4port(unit, eid, args, bcm_field_qualify_L4SrcPort, 4868 "L4SrcPort"); 4869 break; 4870 case bcmFieldQualifyL4DstPort: 4871 rv = fp_qual_l4port(unit, eid, args, bcm_field_qualify_L4DstPort, 4872 "L4DstPort"); 4873 break; 4874 case bcmFieldQualifyOuterVlan: 4875 rv = fp_qual_vlan(unit, eid, args, bcm_field_qualify_OuterVlan, 4876 "OuterVlan"); 4877 break; 4878 case bcmFieldQualifyOuterVlanId: 4879 rv = fp_qual_16(unit, eid, args, bcm_field_qualify_OuterVlanId, 4880 "OuterVlanId"); 4881 break; 4882 case bcmFieldQualifyOuterVlanPri: 4883 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_OuterVlanPri, 4884 "OuterVlanPri"); 4885 break; 4886 case bcmFieldQualifyOuterVlanCfi: 4887 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_OuterVlanCfi, 4888 "OuterVlanCfi"); 4889 break; 4890 case bcmFieldQualifyInnerVlan: 4891 rv = fp_qual_vlan(unit, eid, args, bcm_field_qualify_InnerVlan, 4892 "InnerVlan"); 4893 break; 4894 case bcmFieldQualifyInnerVlanId: 4895 rv = fp_qual_16(unit, eid, args, bcm_field_qualify_InnerVlanId, 4896 "InnerVlanId"); 4897 break; 4898 case bcmFieldQualifyInnerVlanPri: 4899 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_InnerVlanPri, 4900 "InnerVlanPri"); 4901 break; 4902 case bcmFieldQualifyInnerVlanCfi: 4903 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_InnerVlanCfi, 4904 "InnerVlanCfi"); 4905 break; 4906 case bcmFieldQualifyEtherType: 4907 rv = fp_qual_16(unit, eid, args, bcm_field_qualify_EtherType, 4908 "EtherType"); 4909 break; 4910 case bcmFieldQualifyOuterTpid: 4911 rv = fp_qual_tpid(unit, eid, args, bcm_field_qualify_OuterTpid, 4912 "OuterTpid"); 4913 break; 4914 case bcmFieldQualifyInnerTpid: 4915 rv = fp_qual_tpid(unit, eid, args, bcm_field_qualify_InnerTpid, 4916 "InnerTpid"); 4917 break; 4918 case bcmFieldQualifyVrf: 4919 rv = fp_qual_32(unit, eid, args, bcm_field_qualify_Vrf, 4920 "Vrf"); 4921 break; 4922 case bcmFieldQualifyL3Ingress: 4923 rv = fp_qual_32(unit, eid, args, bcm_field_qualify_L3Ingress, 4924 "L3Ingress"); 4925 break; 4926 case bcmFieldQualifyL4Ports: 4927 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_L4Ports, 4928 "L4Ports"); 4929 break; 4930 case bcmFieldQualifyMirrorCopy: 4931 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_MirrorCopy, 4932 "MirrorCopy"); 4933 break; 4934 case bcmFieldQualifyTunnelTerminated: 4935 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_TunnelTerminated, 4936 "TunnelTerminated"); 4937 break; 4938 case bcmFieldQualifyMplsTerminated: 4939 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_MplsTerminated, 4940 "TunnelTerminated"); 4941 break; 4942 case bcmFieldQualifyIpProtocol: 4943 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_IpProtocol, 4944 "IpProtocol"); 4945 break; 4946 case bcmFieldQualifyIpInfo: 4947 rv = fp_qual_IpInfo(unit, eid, args); 4948 break; 4949 case bcmFieldQualifyPacketRes: 4950 rv = fp_qual_PacketRes(unit, eid, args); 4951 break; 4952 case bcmFieldQualifyIpFrag: 4953 rv = fp_qual_IpFrag(unit, eid, args); 4954 break; 4955 case bcmFieldQualifySrcIp: 4956 rv = fp_qual_ip(unit, eid, args, bcm_field_qualify_SrcIp, 4957 "SrcIp"); 4958 break; 4959 case bcmFieldQualifyDstIp: 4960 rv = fp_qual_ip(unit, eid, args, bcm_field_qualify_DstIp, 4961 "DstIp"); 4962 break; 4963 case bcmFieldQualifyDSCP: 4964 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_DSCP, 4965 "DSCP"); 4966 break; 4967 case bcmFieldQualifyVlanFormat: 4968 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_VlanFormat, 4969 "VlanFormat"); 4970 break; 4971 case bcmFieldQualifyTranslatedVlanFormat: 4972 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_TranslatedVlanFormat, 4973 "TranslatedVlanFormat"); 4974 break; 4975 case bcmFieldQualifyIntPriority: 4976 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_IntPriority, 4977 "IntPriority"); 4978 break; 4979 case bcmFieldQualifyColor: 4980 rv = fp_qual_Color(unit, eid, args); 4981 break; 4982 case bcmFieldQualifyIpFlags: 4983 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_IpFlags, 4984 "IpFlags"); 4985 break; 4986 case bcmFieldQualifyTcpHeaderSize: 4987 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_TcpHeaderSize, 4988 "TcpHeaderSize"); 4989 break; 4990 case bcmFieldQualifyExtensionHeaderType: 4991 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_ExtensionHeaderType, 4992 "ExtensionHeaderType"); 4993 break; 4994 case bcmFieldQualifyExtensionHeader2Type: 4995 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_ExtensionHeader2Type, 4996 "ExtensionHeader2Type"); 4997 break; 4998 case bcmFieldQualifyExtensionHeaderSubCode: 4999 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_ExtensionHeaderSubCode, 5000 "ExtensionHeaderSubCode"); 5001 break; 5002 case bcmFieldQualifyL3Routable: 5003 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_L3Routable, 5004 "L3Routable"); 5005 break; 5006 case bcmFieldQualifyDosAttack: 5007 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_DosAttack, 5008 "DosAttack"); 5009 break; 5010 case bcmFieldQualifyIpmcStarGroupHit: 5011 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_IpmcStarGroupHit, 5012 "IpmcStarGroupHit"); 5013 break; 5014 case bcmFieldQualifyMyStationHit: 5015 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_MyStationHit, 5016 "MyStationHit"); 5017 break; 5018 case bcmFieldQualifyL3DestRouteHit: 5019 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_L3DestRouteHit, 5020 "L3DestRouteHit"); 5021 break; 5022 case bcmFieldQualifyL3DestHostHit: 5023 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_L3DestHostHit, 5024 "L3DestHostHit"); 5025 break; 5026 case bcmFieldQualifyL3SrcHostHit: 5027 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_L3SrcHostHit, 5028 "L3SrcHostHit"); 5029 break; 5030 case bcmFieldQualifyL2DestHit: 5031 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_L2DestHit, 5032 "L2DestHit"); 5033 break; 5034 case bcmFieldQualifyL2SrcHit: 5035 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_L2SrcHit, 5036 "L2SrcHit"); 5037 break; 5038 case bcmFieldQualifyL2StationMove: 5039 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_L2StationMove, 5040 "L2StationMove"); 5041 break; 5042 case bcmFieldQualifyL2CacheHit: 5043 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_L2CacheHit, 5044 "L2CacheHit"); 5045 break; 5046 case bcmFieldQualifyL2SrcStatic: 5047 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_L2SrcStatic, 5048 "L2SrcStatic"); 5049 break; 5050 case bcmFieldQualifyVlanTranslationHit: 5051 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_VlanTranslationHit, 5052 "VlanTranslationHit"); 5053 break; 5054 case bcmFieldQualifyIngressStpState: 5055 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_IngressStpState, 5056 "IngressStpState"); 5057 break; 5058 case bcmFieldQualifyForwardingVlanValid: 5059 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_ForwardingVlanValid, 5060 "ForwardingVlanValid"); 5061 break; 5062 case bcmFieldQualifyTcpControl: 5063 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_TcpControl, 5064 "TcpControl"); 5065 break; 5066 case bcmFieldQualifyTtl: 5067 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_Ttl, 5068 "TTL"); 5069 break; 5070 case bcmFieldQualifyRangeCheck: 5071 rv = fp_qual_rangecheck(unit, eid, args, bcm_field_qualify_RangeCheck, 5072 "RangeCheck"); 5073 break; 5074 case bcmFieldQualifySrcIp6: 5075 rv = fp_qual_ip6(unit, eid, args, bcm_field_qualify_SrcIp6, 5076 "SrcIp6"); 5077 break; 5078 case bcmFieldQualifySrcIp6High: 5079 rv = fp_qual_ip6(unit, eid, args, bcm_field_qualify_SrcIp6High, 5080 "SrcIp6High"); 5081 break; 5082 case bcmFieldQualifySrcIp6Low: 5083 rv = fp_qual_ip6(unit, eid, args, bcm_field_qualify_SrcIp6Low, 5084 "SrcIp6Low"); 5085 break; 5086 case bcmFieldQualifyDstIp6: 5087 rv = fp_qual_ip6(unit, eid, args, bcm_field_qualify_DstIp6, "DstIp6"); 5088 break; 5089 case bcmFieldQualifyDstIp6High: 5090 rv = fp_qual_ip6(unit, eid, args, bcm_field_qualify_DstIp6High, 5091 "DstIp6High"); 5092 break; 5093 case bcmFieldQualifyDstIp6Low: 5094 rv = fp_qual_ip6(unit, eid, args, bcm_field_qualify_DstIp6Low, 5095 "DstIp6Low"); 5096 break; 5097 case bcmFieldQualifyIp6FlowLabel: 5098 rv = fp_qual_32(unit, eid, args, bcm_field_qualify_Ip6FlowLabel, 5099 "Ip6FlowLabel"); 5100 break; 5101 case bcmFieldQualifySrcMac: 5102 rv = fp_qual_mac(unit, eid, args, bcm_field_qualify_SrcMac, "SrcMac"); 5103 break; 5104 case bcmFieldQualifyDstMac: 5105 rv = fp_qual_mac(unit, eid, args, bcm_field_qualify_DstMac, "DstMac"); 5106 break; 5107 case bcmFieldQualifySrcClassL2: 5108 rv = fp_qual_SrcLookupClass(unit, eid, args, 5109 bcm_field_qualify_SrcClassL2, 5110 "SrcClassL2"); 5111 break; 5112 case bcmFieldQualifySrcClassL3: 5113 rv = fp_qual_SrcLookupClass(unit, eid, args, 5114 bcm_field_qualify_SrcClassL3, 5115 "SrcClassL3"); 5116 break; 5117 case bcmFieldQualifySrcClassField: 5118 rv = fp_qual_SrcLookupClass(unit, eid, args, 5119 bcm_field_qualify_SrcClassField, 5120 "SrcClassField"); 5121 break; 5122 case bcmFieldQualifyDstClassL2: 5123 rv = fp_qual_DstLookupClass(unit, eid, args, 5124 bcm_field_qualify_DstClassL2, 5125 "DstClassL2"); 5126 break; 5127 case bcmFieldQualifyDstClassL3: 5128 rv = fp_qual_DstLookupClass(unit, eid, args, 5129 bcm_field_qualify_DstClassL3, 5130 "DstClassL3"); 5131 break; 5132 case bcmFieldQualifyDstClassField: 5133 rv = fp_qual_DstLookupClass(unit, eid, args, 5134 bcm_field_qualify_DstClassField, 5135 "DstClassField"); 5136 break; 5137 case bcmFieldQualifyIpType: 5138 rv = fp_qual_IpType(unit, eid, args); 5139 break; 5140 case bcmFieldQualifyInnerIpType: 5141 rv = fp_qual_InnerIpType(unit, eid, args); 5142 break; 5143 case bcmFieldQualifyL2Format: 5144 rv = fp_qual_L2Format(unit, eid, args); 5145 break; 5146 case bcmFieldQualifyMHOpcode: 5147 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_MHOpcode, 5148 "MHOpcode"); 5149 break; 5150 case bcmFieldQualifyDecap: 5151 rv = fp_qual_Decap(unit, eid, args); 5152 break; 5153 case bcmFieldQualifyHiGig: 5154 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_HiGig, "HiGig"); 5155 break; 5156 case bcmFieldQualifyDstHiGig: 5157 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_DstHiGig, "DstHiGig"); 5158 break; 5159 case bcmFieldQualifySrcMplsGport: 5160 rv = fp_qual_Gport(unit, eid, args, 5161 bcm_field_qualify_SrcMplsGport, "SrcMplsGport"); 5162 break; 5163 case bcmFieldQualifyDstMplsGport: 5164 rv = fp_qual_Gport(unit, eid, args, 5165 bcm_field_qualify_DstMplsGport, "DstMplsGport"); 5166 break; 5167 case bcmFieldQualifySrcMimGport: 5168 rv = fp_qual_Gport(unit, eid, args, 5169 bcm_field_qualify_SrcMimGport, "SrcMimGport"); 5170 break; 5171 case bcmFieldQualifyDstMimGport: 5172 rv = fp_qual_Gport(unit, eid, args, 5173 bcm_field_qualify_DstMimGport, "DstMimGport"); 5174 break; 5175 case bcmFieldQualifySrcWlanGport: 5176 rv = fp_qual_Gport(unit, eid, args, 5177 bcm_field_qualify_SrcWlanGport, "SrcWlanGport"); 5178 break; 5179 case bcmFieldQualifyDstWlanGport: 5180 rv = fp_qual_Gport(unit, eid, args, 5181 bcm_field_qualify_DstWlanGport, "DstWlanGport"); 5182 break; 5183 case bcmFieldQualifyDstL3Egress: 5184 rv = fp_qual_Gport(unit, eid, args, 5185 bcm_field_qualify_DstL3Egress, "DstL3Egress"); 5186 break; 5187 case bcmFieldQualifyDstMulticastGroup: 5188 rv = fp_qual_Gport(unit, eid, args, 5189 bcm_field_qualify_DstMulticastGroup, 5190 "DstMulticastGroup"); 5191 break; 5192 case bcmFieldQualifyLoopbackType: 5193 rv = fp_qual_LoopbackType(unit, eid, args); 5194 break; 5195 5196 case bcmFieldQualifyTunnelType: 5197 rv = fp_qual_TunnelType(unit, eid, args); 5198 break; 5199 5200 case bcmFieldQualifyInterfaceClassL2: 5201 rv = fp_qual_InterfaceClass(unit, eid, args, 5202 bcm_field_qualify_InterfaceClassL2, 5203 "InterfaceClassL2"); 5204 break; 5205 case bcmFieldQualifyInterfaceClassL3: 5206 rv = fp_qual_InterfaceClass(unit, eid, args, 5207 bcm_field_qualify_InterfaceClassL3, 5208 "InterfaceClassL3"); 5209 break; 5210 case bcmFieldQualifyInterfaceClassPort: 5211 rv = fp_qual_InterfaceClass(unit, eid, args, 5212 bcm_field_qualify_InterfaceClassPort, 5213 "InterfaceClassPort"); 5214 break; 5215 case bcmFieldQualifyInterfaceClassVPort: 5216 rv = fp_qual_InterfaceClass(unit, eid, args, 5217 bcm_field_qualify_InterfaceClassVPort, 5218 "InterfaceClassVPort"); 5219 break; 5220 case bcmFieldQualifyDstL3EgressNextHops: 5221 rv = fp_qual_32(unit, eid, args, 5222 bcm_field_qualify_DstL3EgressNextHops, 5223 "DstL3EgressNextHops"); 5224 break; 5225 case bcmFieldQualifyVnTag: 5226 rv = fp_qual_32(unit, 5227 eid, 5228 args, 5229 bcm_field_qualify_VnTag, 5230 "VnTag" 5231 ); 5232 break; 5233 case bcmFieldQualifySubportPktTag: 5234 rv = fp_qual_16(unit, 5235 eid, 5236 args, 5237 bcm_field_qualify_SubportPktTag, 5238 "SubportPktTag" 5239 ); 5240 break; 5241 case bcmFieldQualifyCnTag: 5242 rv = fp_qual_32(unit, 5243 eid, 5244 args, 5245 bcm_field_qualify_CnTag, 5246 "CnTag" 5247 ); 5248 break; 5249 case bcmFieldQualifyFabricQueueTag: 5250 rv = fp_qual_32(unit, 5251 eid, 5252 args, 5253 bcm_field_qualify_FabricQueueTag, 5254 "FabricQueueTag" 5255 ); 5256 break; 5257 case bcmFieldQualifyRecoverableDrop: 5258 rv = fp_qual_8(unit, 5259 eid, 5260 args, 5261 bcm_field_qualify_RecoverableDrop, 5262 "RecoverableDrop" 5263 ); 5264 break; 5265 case bcmFieldQualifyRepCopy: 5266 rv = fp_qual_8(unit, 5267 eid, 5268 args, 5269 bcm_field_qualify_RepCopy, 5270 "RepCopy" 5271 ); 5272 break; 5273 case bcmFieldQualifyIpTunnelHit: 5274 rv = fp_qual_8(unit, 5275 eid, 5276 args, 5277 bcm_field_qualify_IpTunnelHit, 5278 "IpTunnelHit" 5279 ); 5280 break; 5281 case bcmFieldQualifyMplsLabel1Hit: 5282 rv = fp_qual_8(unit, 5283 eid, 5284 args, 5285 bcm_field_qualify_MplsLabel1Hit, 5286 "MplsLabel1Hit" 5287 ); 5288 break; 5289 case bcmFieldQualifyTrillEgressRbridgeHit: 5290 rv = fp_qual_8(unit, 5291 eid, 5292 args, 5293 bcm_field_qualify_TrillEgressRbridgeHit, 5294 "TrillEgressRbridgeHit" 5295 ); 5296 break; 5297 case bcmFieldQualifyL2GreSrcIpHit: 5298 rv = fp_qual_8(unit, 5299 eid, 5300 args, 5301 bcm_field_qualify_L2GreSrcIpHit, 5302 "L2GreSrcIpHit" 5303 ); 5304 break; 5305 case bcmFieldQualifyMimSrcGportHit: 5306 rv = fp_qual_8(unit, 5307 eid, 5308 args, 5309 bcm_field_qualify_MimSrcGportHit, 5310 "MimSrcGportHit" 5311 ); 5312 break; 5313 case bcmFieldQualifyMplsLabel2Hit: 5314 rv = fp_qual_8(unit, 5315 eid, 5316 args, 5317 bcm_field_qualify_MplsLabel2Hit, 5318 "MplsLabel2Hit" 5319 ); 5320 break; 5321 case bcmFieldQualifyTrillIngressRbridgeHit: 5322 rv = fp_qual_8(unit, 5323 eid, 5324 args, 5325 bcm_field_qualify_TrillIngressRbridgeHit, 5326 "TrillIngressRbridgeHit" 5327 ); 5328 break; 5329 case bcmFieldQualifyL2GreVfiHit: 5330 rv = fp_qual_8(unit, 5331 eid, 5332 args, 5333 bcm_field_qualify_L2GreVfiHit, 5334 "L2GreVfiHit" 5335 ); 5336 break; 5337 case bcmFieldQualifyMimVfiHit: 5338 rv = fp_qual_8(unit, 5339 eid, 5340 args, 5341 bcm_field_qualify_MimVfiHit, 5342 "MimVfiHit" 5343 ); 5344 break; 5345 case bcmFieldQualifyGenericAssociatedChannelLabelValid: 5346 rv = fp_qual_8(unit, 5347 eid, 5348 args, 5349 bcm_field_qualify_GenericAssociatedChannelLabelValid, 5350 "GenericAssociatedChannelLabelValid" 5351 ); 5352 break; 5353 case bcmFieldQualifyRouterAlertLabelValid: 5354 rv = fp_qual_8(unit, 5355 eid, 5356 args, 5357 bcm_field_qualify_RouterAlertLabelValid, 5358 "RouterAlertLabelValid" 5359 ); 5360 break; 5361 case bcmFieldQualifyDstIpLocal: 5362 rv = fp_qual_8(unit, 5363 eid, 5364 args, 5365 bcm_field_qualify_DstIpLocal, 5366 "DstIpLocal" 5367 ); 5368 break; 5369 case bcmFieldQualifyIpAddrsNormalized: 5370 rv = fp_qual_8(unit, 5371 eid, 5372 args, 5373 bcm_field_qualify_IpAddrsNormalized, 5374 "IpAddrsNormalized" 5375 ); 5376 break; 5377 case bcmFieldQualifyMacAddrsNormalized: 5378 rv = fp_qual_8(unit, 5379 eid, 5380 args, 5381 bcm_field_qualify_MacAddrsNormalized, 5382 "MacAddrsNormalized" 5383 ); 5384 break; 5385 case bcmFieldQualifyMplsForwardingLabel: 5386 rv = fp_qual_32(unit, 5387 eid, 5388 args, 5389 bcm_field_qualify_MplsForwardingLabel, 5390 "MplsForwardingLabel" 5391 ); 5392 break; 5393 case bcmFieldQualifyMplsForwardingLabelTtl: 5394 rv = fp_qual_8(unit, 5395 eid, 5396 args, 5397 bcm_field_qualify_MplsForwardingLabelTtl, 5398 "MplsForwardingLabelTtl" 5399 ); 5400 break; 5401 case bcmFieldQualifyMplsForwardingLabelBos: 5402 rv = fp_qual_8(unit, 5403 eid, 5404 args, 5405 bcm_field_qualify_MplsForwardingLabelBos, 5406 "MplsForwardingLabelBos" 5407 ); 5408 break; 5409 case bcmFieldQualifyMplsForwardingLabelExp: 5410 rv = fp_qual_8(unit, 5411 eid, 5412 args, 5413 bcm_field_qualify_MplsForwardingLabelExp, 5414 "MplsForwardingLabelExp" 5415 ); 5416 break; 5417 case bcmFieldQualifyMplsForwardingLabelId: 5418 rv = fp_qual_32(unit, 5419 eid, 5420 args, 5421 bcm_field_qualify_MplsForwardingLabelId, 5422 "MplsForwardingLabelId" 5423 ); 5424 break; 5425 case bcmFieldQualifyMplsControlWord: 5426 rv = fp_qual_32(unit, 5427 eid, 5428 args, 5429 bcm_field_qualify_MplsControlWord, 5430 "MplsControlWord" 5431 ); 5432 break; 5433 case bcmFieldQualifyRtag7AHashUpper: 5434 rv = fp_qual_16(unit, 5435 eid, 5436 args, 5437 bcm_field_qualify_Rtag7AHashUpper, 5438 "Rtag7AHashUpper" 5439 ); 5440 break; 5441 case bcmFieldQualifyRtag7AHashLower: 5442 rv = fp_qual_16(unit, 5443 eid, 5444 args, 5445 bcm_field_qualify_Rtag7AHashLower, 5446 "Rtag7AHashLower" 5447 ); 5448 break; 5449 case bcmFieldQualifyRtag7BHashUpper: 5450 rv = fp_qual_16(unit, 5451 eid, 5452 args, 5453 bcm_field_qualify_Rtag7BHashUpper, 5454 "Rtag7BHashUpper" 5455 ); 5456 break; 5457 case bcmFieldQualifyRtag7BHashLower: 5458 rv = fp_qual_16(unit, 5459 eid, 5460 args, 5461 bcm_field_qualify_Rtag7BHashLower, 5462 "Rtag7BHashLower" 5463 ); 5464 break; 5465 case bcmFieldQualifyMplsForwardingLabelAction: 5466 rv = fp_qual_8(unit, 5467 eid, 5468 args, 5469 bcm_field_qualify_MplsForwardingLabelAction, 5470 "MplsForwardingLabelAction" 5471 ); 5472 break; 5473 case bcmFieldQualifyMplsControlWordValid: 5474 rv = fp_qual_8(unit, 5475 eid, 5476 args, 5477 bcm_field_qualify_MplsControlWordValid, 5478 "MplsControlWordValid" 5479 ); 5480 break; 5481 case bcmFieldQualifyEgressClass: 5482 rv = fp_qual_16(unit, 5483 eid, 5484 args, 5485 bcm_field_qualify_EgressClass, 5486 "EgressClass" 5487 ); 5488 break; 5489 case bcmFieldQualifyEgressClassL3Interface: 5490 rv = fp_qual_16(unit, 5491 eid, 5492 args, 5493 bcm_field_qualify_EgressClassL3Interface, 5494 "EgressClassL3Interface" 5495 ); 5496 break; 5497 case bcmFieldQualifyEgressClassTrill: 5498 rv = fp_qual_16(unit, 5499 eid, 5500 args, 5501 bcm_field_qualify_EgressClassTrill, 5502 "EgressClassTrill" 5503 ); 5504 break; 5505 case bcmFieldQualifyEgressClassWlan: 5506 rv = fp_qual_16(unit, 5507 eid, 5508 args, 5509 bcm_field_qualify_EgressClassWlan, 5510 "EgressClassWlan" 5511 ); 5512 break; 5513 case bcmFieldQualifyEgressClassL2Gre: 5514 rv = fp_qual_16(unit, 5515 eid, 5516 args, 5517 bcm_field_qualify_EgressClassL2Gre, 5518 "EgressClassL2Gre" 5519 ); 5520 break; 5521 case bcmFieldQualifyEgressClassVxlan: 5522 rv = fp_qual_16(unit, 5523 eid, 5524 args, 5525 bcm_field_qualify_EgressClassVxlan, 5526 "EgressClassVxlan" 5527 ); 5528 break; 5529 case bcmFieldQualifyEgressClassTunnel: 5530 rv = fp_qual_16(unit, 5531 eid, 5532 args, 5533 bcm_field_qualify_EgressClassTunnel, 5534 "EgressClassTunnel" 5535 ); 5536 break; 5537 case bcmFieldQualifyEgressClassL3InterfaceTunnel: 5538 rv = fp_qual_16(unit, 5539 eid, 5540 args, 5541 bcm_field_qualify_EgressClassL3InterfaceTunnel, 5542 "EgressClassL3InterfaceTunnel" 5543 ); 5544 break; 5545 case bcmFieldQualifyCpuQueue: 5546 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_CpuQueue, 5547 "CpuQueue"); 5548 break; 5549 case bcmFieldQualifyIpProtocolCommon: 5550 rv = fp_qual_IpProtocolCommon(unit, eid, args); 5551 break; 5552 case bcmFieldQualifySrcGport: 5553 rv = fp_qual_Gport(unit, eid, args, 5554 bcm_field_qualify_SrcGport, "SrcGport"); 5555 break; 5556 case bcmFieldQualifySrcTrunkMemberGport: 5557 rv = fp_qual_Gport(unit, eid, args, 5558 bcm_field_qualify_SrcTrunkMemberGport, 5559 "SrcTrunkMemberGport"); 5560 break; 5561 case bcmFieldQualifyInnerSrcIp: 5562 rv = fp_qual_ip(unit, eid, args, bcm_field_qualify_InnerSrcIp, 5563 "InnerSrcIp"); 5564 break; 5565 case bcmFieldQualifyInnerDstIp: 5566 rv = fp_qual_ip(unit, eid, args, bcm_field_qualify_InnerDstIp, 5567 "InnerDstIp"); 5568 break; 5569 5570 case bcmFieldQualifyMplsOuterLabelPop: 5571 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_MplsOuterLabelPop, 5572 "MplsOuterLabelPop"); 5573 break; 5574 case bcmFieldQualifyMplsStationHitTunnelUnterminated: 5575 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_MplsStationHitTunnelUnterminated, 5576 "MplsStationHitTunnelUnterminated"); 5577 break; 5578 case bcmFieldQualifyIngressClassField: 5579 rv = fp_qual_32(unit, eid, args, bcm_field_qualify_IngressClassField, 5580 "IngressClassField"); 5581 break; 5582 case bcmFieldQualifyIngressInterfaceClassPort: 5583 rv = fp_qual_32(unit, eid, args, 5584 bcm_field_qualify_IngressInterfaceClassPort, 5585 "IngressInterfaceClassPort"); 5586 break; 5587 case bcmFieldQualifyVxlanNetworkId: 5588 rv = fp_qual_32(unit, eid, args, 5589 bcm_field_qualify_VxlanNetworkId, 5590 "VxlanNetworkId"); 5591 break; 5592 case bcmFieldQualifyVxlanFlags: 5593 rv = fp_qual_8(unit, eid, args, 5594 bcm_field_qualify_VxlanFlags, 5595 "VxlanFlags"); 5596 break; 5597 case bcmFieldQualifyNatNeeded: 5598 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_NatNeeded, 5599 "NatNeeded"); 5600 break; 5601 case bcmFieldQualifyNatDstRealmId: 5602 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_NatDstRealmId, 5603 "NatDstRealmId"); 5604 break; 5605 case bcmFieldQualifyNatSrcRealmId: 5606 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_NatSrcRealmId, 5607 "NatSrcRealmId"); 5608 break; 5609 case bcmFieldQualifyIcmpError: 5610 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_IcmpError, 5611 "IcmpError"); 5612 break; 5613 case bcmFieldQualifyIcmpTypeCode: 5614 rv = fp_qual_16(unit, eid, args, bcm_field_qualify_IcmpTypeCode, 5615 "IcmpTypeCode"); 5616 break; 5617 case bcmFieldQualifyForwardingType: 5618 rv = fp_qual_ForwardingType(unit, eid, args); 5619 break; 5620 case bcmFieldQualifyForwardingVlanId: 5621 rv = fp_qual_16(unit, eid, args, bcm_field_qualify_ForwardingVlanId, 5622 "ForwardingVlanId"); 5623 break; 5624 case bcmFieldQualifyFibreChanRCtl: 5625 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_FibreChanRCtl, 5626 "FibreChanRCtl"); 5627 break; 5628 case bcmFieldQualifyFibreChanFCtl: 5629 rv = fp_qual_32(unit, eid, args, bcm_field_qualify_FibreChanFCtl, 5630 "FibreChanFCtl"); 5631 break; 5632 case bcmFieldQualifyFibreChanCSCtl: 5633 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_FibreChanCSCtl, 5634 "FibreChanCSCtl"); 5635 break; 5636 case bcmFieldQualifyFibreChanDFCtl: 5637 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_FibreChanDFCtl, 5638 "FibreChanDFCtl"); 5639 break; 5640 case bcmFieldQualifyFibreChanType: 5641 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_FibreChanType, 5642 "FibreChanType"); 5643 break; 5644 case bcmFieldQualifyFibreChanSrcId: 5645 rv = fp_qual_32(unit, eid, args, bcm_field_qualify_FibreChanSrcId, 5646 "FibreChanSrcId"); 5647 break; 5648 case bcmFieldQualifyFibreChanDstId: 5649 rv = fp_qual_32(unit, eid, args, bcm_field_qualify_FibreChanDstId, 5650 "FibreChanDstId"); 5651 break; 5652 case bcmFieldQualifyFibreChanZoneCheck: 5653 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_FibreChanZoneCheck, 5654 "FibreChanZoneCheck"); 5655 break; 5656 case bcmFieldQualifyFibreChanSrcFpmaCheck: 5657 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_FibreChanSrcFpmaCheck, 5658 "FibreChanSrcFpmaCheck"); 5659 break; 5660 case bcmFieldQualifyFibreChanSrcBindCheck: 5661 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_FibreChanSrcBindCheck, 5662 "FibreChanSrcBindCheck"); 5663 break; 5664 case bcmFieldQualifyFibreChanVFTVersion: 5665 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_FibreChanVFTVersion, 5666 "FibreChanVFTVersion"); 5667 break; 5668 case bcmFieldQualifyFibreChanVFTPri: 5669 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_FibreChanVFTPri, 5670 "FibreChanVFTPri"); 5671 break; 5672 case bcmFieldQualifyFibreChanVFTFabricId: 5673 rv = fp_qual_16(unit, eid, args, bcm_field_qualify_FibreChanVFTFabricId, 5674 "FibreChanVFTFabricId"); 5675 break; 5676 case bcmFieldQualifyFibreChanVFTHopCount: 5677 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_FibreChanVFTHopCount, 5678 "FibreChanVFTHopCount"); 5679 break; 5680 case bcmFieldQualifyFibreChanVFTVsanId: 5681 rv = fp_qual_16(unit, eid, args, bcm_field_qualify_FibreChanVFTVsanId, 5682 "FibreChanVFTVsanId"); 5683 break; 5684 case bcmFieldQualifyFibreChanVFTVsanPri: 5685 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_FibreChanVFTVsanPri, 5686 "FibreChanVFTVsanPri"); 5687 break; 5688 case bcmFieldQualifyFibreChanVFTValid: 5689 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_FibreChanVFTValid, 5690 "FibreChanVFTValid"); 5691 break; 5692 case bcmFieldQualifyFcoeSOF: 5693 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_FcoeSOF, 5694 "FcoeSOF"); 5695 break; 5696 case bcmFieldQualifyFcoeVersionIsZero: 5697 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_FcoeVersionIsZero, 5698 "FcoeVersionIsZero"); 5699 break; 5700 case bcmFieldQualifySrcVxlanGport: 5701 rv = fp_qual_Gport(unit, eid, args, 5702 bcm_field_qualify_SrcVxlanGport, "SrcVxlanGport"); 5703 break; 5704 case bcmFieldQualifyDstVxlanGport: 5705 rv = fp_qual_Gport(unit, eid, args, 5706 bcm_field_qualify_DstVxlanGport, "DstVxlanGport"); 5707 break; 5708 case bcmFieldQualifySrcVlanGport: 5709 rv = fp_qual_Gport(unit, eid, args, 5710 bcm_field_qualify_SrcVlanGport, "SrcVlanGport"); 5711 break; 5712 case bcmFieldQualifyDstVlanGport: 5713 rv = fp_qual_Gport(unit, eid, args, 5714 bcm_field_qualify_DstVlanGport, "DstVlanGport"); 5715 break; 5716 case bcmFieldQualifyOamMdl: 5717 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_OamMdl, 5718 "OamMdl"); 5719 break; 5720 case bcmFieldQualifyIntCongestionNotification: 5721 rv = fp_qual_8(unit, 5722 eid, 5723 args, 5724 bcm_field_qualify_IntCongestionNotification, 5725 "IntCongestionNotification" 5726 ); 5727 break; 5728 case bcmFieldQualifySrcNivGport: 5729 rv = fp_qual_Gport(unit, eid, args, 5730 bcm_field_qualify_SrcNivGport, "SrcNivGport"); 5731 break; 5732 case bcmFieldQualifyDstNivGport: 5733 rv = fp_qual_Gport(unit, eid, args, 5734 bcm_field_qualify_DstNivGport, "DstNivGport"); 5735 break; 5736 case bcmFieldQualifyDstGport: 5737 rv = fp_qual_Gport(unit, eid, args, 5738 bcm_field_qualify_DstGport, "DstGport"); 5739 break; 5740 case bcmFieldQualifyIngressInterfaceClassVPort: 5741 rv = fp_qual_32(unit, eid, args, 5742 bcm_field_qualify_IngressInterfaceClassVPort, 5743 "IngressInterfaceClassVPort"); 5744 break; 5745 case bcmFieldQualifySrcVlanGports: 5746 rv = fp_qual_Gports(unit, eid, args, 5747 bcm_field_qualify_SrcVlanGports, "SrcVlanGports"); 5748 break; 5749 case bcmFieldQualifyDstVlanGports: 5750 rv = fp_qual_Gports(unit, eid, args, 5751 bcm_field_qualify_DstVlanGports, "DstVlanGports"); 5752 break; 5753 case bcmFieldQualifySrcVxlanGports: 5754 rv = fp_qual_Gports(unit, eid, args, 5755 bcm_field_qualify_SrcVxlanGports, "SrcVxlanGports"); 5756 break; 5757 case bcmFieldQualifyDstVxlanGports: 5758 rv = fp_qual_Gports(unit, eid, args, 5759 bcm_field_qualify_DstVxlanGports, "DstVxlanGports"); 5760 break; 5761 case bcmFieldQualifySrcWlanGports: 5762 rv = fp_qual_Gports(unit, eid, args, 5763 bcm_field_qualify_SrcWlanGports, "SrcWlanGports"); 5764 break; 5765 case bcmFieldQualifyDstWlanGports: 5766 rv = fp_qual_Gports(unit, eid, args, 5767 bcm_field_qualify_DstWlanGports, "DstWlanGports"); 5768 break; 5769 case bcmFieldQualifySrcMplsGports: 5770 rv = fp_qual_Gports(unit, eid, args, 5771 bcm_field_qualify_SrcMplsGports, "SrcMplsGports"); 5772 break; 5773 case bcmFieldQualifyDstMplsGports: 5774 rv = fp_qual_Gports(unit, eid, args, 5775 bcm_field_qualify_DstMplsGports, "DstMplsGports"); 5776 break; 5777 case bcmFieldQualifySrcGports: 5778 rv = fp_qual_Gports(unit, eid, args, 5779 bcm_field_qualify_SrcGports, "SrcGports"); 5780 break; 5781 case bcmFieldQualifyDstGports: 5782 rv = fp_qual_Gports(unit, eid, args, 5783 bcm_field_qualify_DstGports, "DstGports"); 5784 break; 5785 case bcmFieldQualifySrcMimGports: 5786 rv = fp_qual_Gports(unit, eid, args, 5787 bcm_field_qualify_SrcMimGports, "SrcMimGports"); 5788 break; 5789 case bcmFieldQualifyDstMimGports: 5790 rv = fp_qual_Gports(unit, eid, args, 5791 bcm_field_qualify_DstMimGports, "DstMimGports"); 5792 break; 5793 case bcmFieldQualifySrcNivGports: 5794 rv = fp_qual_Gports(unit, eid, args, 5795 bcm_field_qualify_SrcNivGports, "SrcNivGports"); 5796 break; 5797 case bcmFieldQualifyDstNivGports: 5798 rv = fp_qual_Gports(unit, eid, args, 5799 bcm_field_qualify_DstNivGports, "DstNivGports"); 5800 break; 5801 case bcmFieldQualifySrcModPortGports: 5802 rv = fp_qual_Gports(unit, eid, args, 5803 bcm_field_qualify_SrcModPortGports, "SrcModPortGports"); 5804 break; 5805 case bcmFieldQualifyDstMulticastGroups: 5806 rv = fp_qual_Gports(unit, eid, args, 5807 bcm_field_qualify_DstMulticastGroups, "DstMulticastGroups"); 5808 break; 5809 case bcmFieldQualifyDstMultipath: 5810 rv = fp_qual_Gport(unit, eid, args, 5811 bcm_field_qualify_DstMultipath, "DstMultipath"); 5812 break; 5813 case bcmFieldQualifySrcVirtualPortValid: 5814 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_SrcVirtualPortValid, 5815 "SrcVirtualPortValid"); 5816 break; 5817 case bcmFieldQualifyDestVirtualPortValid: 5818 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_DestVirtualPortValid, 5819 "DestVirtualPortValid"); 5820 break; 5821 case bcmFieldQualifyCustomHeaderPkt: 5822 rv = fp_qual_8(unit, eid, args, 5823 bcm_field_qualify_CustomHeaderPkt, 5824 "CustomHeaderPkt"); 5825 break; 5826 case bcmFieldQualifyCustomHeaderData: 5827 rv = fp_qual_32(unit, eid, args, 5828 bcm_field_qualify_CustomHeaderData, 5829 "CustomHeaderData"); 5830 break; 5831 case bcmFieldQualifyVxlanHeaderBits8_31: 5832 rv = fp_qual_32(unit, eid, args, 5833 bcm_field_qualify_VxlanHeaderBits8_31, 5834 "VxlanHeaderBits8_31"); 5835 break; 5836 case bcmFieldQualifyVxlanHeaderBits56_63: 5837 rv = fp_qual_8(unit, eid, args, 5838 bcm_field_qualify_VxlanHeaderBits56_63, 5839 "VxlanHeaderBits56_63"); 5840 break; 5841 case bcmFieldQualifyEthernetOamHeaderBits0_31: 5842 rv = fp_qual_32(unit, eid, args, 5843 bcm_field_qualify_EthernetOamHeaderBits0_31, 5844 "EthernetOamHeaderBits0_31"); 5845 break; 5846 case bcmFieldQualifyEthernetOamHeaderBits32_63: 5847 rv = fp_qual_32(unit, eid, args, 5848 bcm_field_qualify_EthernetOamHeaderBits32_63, 5849 "EthernetOamHeaderBits32_63"); 5850 break; 5851 case bcmFieldQualifyEthernetOamDstClassL2: 5852 rv = fp_qual_8 (unit, eid, args, 5853 bcm_field_qualify_EthernetOamDstClassL2, 5854 "EthernetOamDstClassL2"); 5855 break; 5856 case bcmFieldQualifyEthernetOamTxPktUPMEP: 5857 rv = fp_qual_8 (unit, eid, args, 5858 bcm_field_qualify_EthernetOamTxPktUPMEP, 5859 "EthernetOamTxPktUPMEP"); 5860 break; 5861 case bcmFieldQualifyEthernetOamInterfaceClassPort: 5862 rv = fp_qual_8 (unit, eid, args, 5863 bcm_field_qualify_EthernetOamInterfaceClassPort, 5864 "EthernetOamInterfaceClassPort"); 5865 break; 5866 case bcmFieldQualifyEthernetOamClassVlanTranslateKeyFirst: 5867 rv = fp_qual_8 (unit, eid, args, 5868 bcm_field_qualify_EthernetOamClassVlanTranslateKeyFirst, 5869 "EthernetOamClassVlanTranslateKeyFirst"); 5870 break; 5871 case bcmFieldQualifyEthernetOamClassVlanTranslateKeySecond: 5872 rv = fp_qual_8 (unit, eid, args, 5873 bcm_field_qualify_EthernetOamClassVlanTranslateKeySecond, 5874 "EthernetOamClassVlanTranslateKeySecond"); 5875 break; 5876 case bcmFieldQualifyEthernetOamInterfaceClassNiv: 5877 rv = fp_qual_8 (unit, eid, args, 5878 bcm_field_qualify_EthernetOamInterfaceClassNiv, 5879 "EthernetOamInterfaceClassNiv"); 5880 break; 5881 case bcmFieldQualifyEthernetOamInterfaceClassMim: 5882 rv = fp_qual_8 (unit, eid, args, 5883 bcm_field_qualify_EthernetOamInterfaceClassMim, 5884 "EthernetOamInterfaceClassMim"); 5885 break; 5886 case bcmFieldQualifyEthernetOamInterfaceClassVxlan: 5887 rv = fp_qual_8 (unit, eid, args, 5888 bcm_field_qualify_EthernetOamInterfaceClassVxlan, 5889 "EthernetOamInterfaceClassVxlan"); 5890 break; 5891 case bcmFieldQualifyEthernetOamInterfaceClassVlan: 5892 rv = fp_qual_8 (unit, eid, args, 5893 bcm_field_qualify_EthernetOamInterfaceClassVlan, 5894 "EthernetOamInterfaceClassVlan"); 5895 break; 5896 case bcmFieldQualifyEthernetOamInterfaceClassMpls: 5897 rv = fp_qual_8 (unit, eid, args, 5898 bcm_field_qualify_EthernetOamInterfaceClassMpls, 5899 "EthernetOamInterfaceClassMpls"); 5900 break; 5901 case bcmFieldQualifyEthernetOamClassVpn: 5902 rv = fp_qual_8 (unit, eid, args, 5903 bcm_field_qualify_EthernetOamClassVpn, 5904 "EthernetOamClassVpn"); 5905 break; 5906 case bcmFieldQualifyMplsOamHeaderBits0_31: 5907 rv = fp_qual_32(unit, eid, args, 5908 bcm_field_qualify_MplsOamHeaderBits0_31, 5909 "MplsOamHeaderBits0_31"); 5910 break; 5911 case bcmFieldQualifyMplsOamHeaderBits32_63: 5912 rv = fp_qual_32(unit, eid, args, 5913 bcm_field_qualify_MplsOamHeaderBits32_63, 5914 "MplsOamHeaderBits32_63"); 5915 break; 5916 case bcmFieldQualifyMplsOamGALLabelOnly: 5917 rv = fp_qual_8 (unit, eid, args, 5918 bcm_field_qualify_MplsOamGALLabelOnly, 5919 "MplsOamGALLabelOnly"); 5920 break; 5921 case bcmFieldQualifyMplsOamGALExposed: 5922 rv = fp_qual_8 (unit, eid, args, 5923 bcm_field_qualify_MplsOamGALExposed, 5924 "MplsOamGALExposed"); 5925 break; 5926 case bcmFieldQualifyMplsOamUpperLabelDataDrop: 5927 rv = fp_qual_8 (unit, eid, args, 5928 bcm_field_qualify_MplsOamUpperLabelDataDrop, 5929 "MplsOamUpperLabelDataDrop"); 5930 break; 5931 case bcmFieldQualifyMplsOamACH: 5932 rv = fp_qual_32(unit, eid, args, 5933 bcm_field_qualify_MplsOamACH, 5934 "MplsOamACH"); 5935 break; 5936 case bcmFieldQualifyMplsOamControlPktType: 5937 rv = fp_qual_MplsOam_Control_pktType (unit, eid, args); 5938 break; 5939 case bcmFieldQualifyMplsOamClassMplsSwitchLabel: 5940 rv = fp_qual_16 (unit, eid, args, 5941 bcm_field_qualify_MplsOamClassMplsSwitchLabel, 5942 "MplsOamClassMplsSwitchLabel"); 5943 break; 5944 case bcmFieldQualifyOamHeaderBits0_31: 5945 rv = fp_qual_32(unit, eid, args, 5946 bcm_field_qualify_OamHeaderBits0_31, 5947 "OamHeaderBits0_31"); 5948 break; 5949 case bcmFieldQualifyOamHeaderBits32_63: 5950 rv = fp_qual_32(unit, eid, args, 5951 bcm_field_qualify_OamHeaderBits32_63, 5952 "OamHeaderBits32_63"); 5953 break; 5954 case bcmFieldQualifyOamEgressClassVxlt: 5955 rv = fp_qual_16 (unit, eid, args, 5956 bcm_field_qualify_OamEgressClassVxlt, 5957 "OamEgressClassVxlt"); 5958 break; 5959 case bcmFieldQualifyOamEgressClassPort: 5960 rv = fp_qual_16 (unit, eid, args, 5961 bcm_field_qualify_OamEgressClassPort, 5962 "OamEgressClassPort"); 5963 break; 5964 case bcmFieldQualifyOamType: 5965 rv = fp_qual_oam_type (unit, eid, args); 5966 break; 5967 case bcmFieldQualifyIpFragNonOrFirst: 5968 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_IpFragNonOrFirst, 5969 "IpFragNonOrFirst"); 5970 break; 5971 case bcmFieldQualifyPacketLength: 5972 rv = fp_qual_16(unit, eid, args, bcm_field_qualify_PacketLength, 5973 "PacketLength"); 5974 break; 5975 case bcmFieldQualifyGroupClass: 5976 rv = fp_qual_32(unit, eid, args, bcm_field_qualify_GroupClass, 5977 "GroupClass"); 5978 break; 5979 case bcmFieldQualifyUdfClass: 5980 rv = fp_qual_32(unit, eid, args, bcm_field_qualify_UdfClass, 5981 "UdfClass"); 5982 break; 5983 case bcmFieldQualifyInterfaceLookupClassPort: 5984 rv = fp_qual_32(unit, eid, args, bcm_field_qualify_InterfaceLookupClassPort, 5985 "InterfaceLookupClassPort"); 5986 break; 5987 case bcmFieldQualifyMimlPkt: 5988 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_MimlPkt, 5989 "MimlPkt"); 5990 break; 5991 case bcmFieldQualifyMimlSrcMac: 5992 rv = fp_qual_mac(unit, eid, args, bcm_field_qualify_MimlSrcMac, "MimlSrcMac"); 5993 break; 5994 case bcmFieldQualifyMimlDstMac: 5995 rv = fp_qual_mac(unit, eid, args, bcm_field_qualify_MimlDstMac, "MimlDstMac"); 5996 break; 5997 case bcmFieldQualifyMimlVlan: 5998 rv = fp_qual_vlan(unit, eid, args, bcm_field_qualify_MimlVlan, 5999 "MimlVlan"); 6000 break; 6001 case bcmFieldQualifyMimlVlanId: 6002 rv = fp_qual_16(unit, eid, args, bcm_field_qualify_MimlVlanId, 6003 "MimlVlanId"); 6004 break; 6005 case bcmFieldQualifyMimlVlanPri: 6006 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_MimlVlanPri, 6007 "MimlVlanPri"); 6008 break; 6009 case bcmFieldQualifyMimlVlanCfi: 6010 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_MimlVlanCfi, 6011 "MimlVlanCfi"); 6012 break; 6013 case bcmFieldQualifyMimlInnerTag: 6014 rv = fp_qual_32(unit, eid, args, bcm_field_qualify_MimlInnerTag, 6015 "MimlInnerTag"); 6016 break; 6017 case bcmFieldQualifyCapwapHdrType: 6018 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_CapwapHdrType, 6019 "CapwapHdrType"); 6020 break; 6021 case bcmFieldQualifyCapwapHdrRid: 6022 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_CapwapHdrRid, 6023 "CapwapHdrRid"); 6024 break; 6025 case bcmFieldQualifyCapwapPayloadSOF: 6026 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_CapwapPayloadSOF, 6027 "CapwapPayloadSOF"); 6028 break; 6029 case bcmFieldQualifyCapwapPayloadSrcMac: 6030 rv = fp_qual_mac(unit, eid, args, bcm_field_qualify_CapwapPayloadSrcMac, 6031 "CapwapPayloadSrcMac"); 6032 break; 6033 case bcmFieldQualifyCapwapPayloadDstMac: 6034 rv = fp_qual_mac(unit, eid, args, bcm_field_qualify_CapwapPayloadDstMac, 6035 "CapwapPayloadDstMac"); 6036 break; 6037 case bcmFieldQualifyCapwapPayloadEtherType: 6038 rv = fp_qual_16(unit, eid, args, 6039 bcm_field_qualify_CapwapPayloadEtherType, 6040 "CapwapPayloadEtherType"); 6041 break; 6042 case bcmFieldQualifyCapwapPayloadOuterVlan: 6043 rv = fp_qual_vlan(unit, eid, args, 6044 bcm_field_qualify_CapwapPayloadOuterVlan, 6045 "CapwapPayloadOuterVlan"); 6046 break; 6047 case bcmFieldQualifyCapwapPayloadOuterVlanId: 6048 rv = fp_qual_16(unit, eid, args, 6049 bcm_field_qualify_CapwapPayloadOuterVlanId, 6050 "CapwapPayloadOuterVlanId"); 6051 break; 6052 case bcmFieldQualifyCapwapPayloadOuterVlanPri: 6053 rv = fp_qual_8(unit, eid, args, 6054 bcm_field_qualify_CapwapPayloadOuterVlanPri, 6055 "CapwapPayloadOuterVlanPri"); 6056 break; 6057 case bcmFieldQualifyCapwapPayloadOuterVlanCfi: 6058 rv = fp_qual_8(unit, eid, args, 6059 bcm_field_qualify_CapwapPayloadOuterVlanCfi, 6060 "CapwapPayloadOuterVlanCfi"); 6061 break; 6062 case bcmFieldQualifyCapwapPayloadInnerVlan: 6063 rv = fp_qual_vlan(unit, eid, args, 6064 bcm_field_qualify_CapwapPayloadInnerVlan, 6065 "CapwapPayloadInnerVlan"); 6066 break; 6067 case bcmFieldQualifyCapwapPayloadInnerVlanId: 6068 rv = fp_qual_16(unit, eid, args, 6069 bcm_field_qualify_CapwapPayloadInnerVlanId, 6070 "CapwapPayloadInnerVlanId"); 6071 break; 6072 case bcmFieldQualifyCapwapPayloadInnerVlanPri: 6073 rv = fp_qual_8(unit, eid, args, 6074 bcm_field_qualify_CapwapPayloadInnerVlanPri, 6075 "CapwapPayloadInnerVlanPri"); 6076 break; 6077 case bcmFieldQualifyCapwapPayloadInnerVlanCfi: 6078 rv = fp_qual_8(unit, eid, args, 6079 bcm_field_qualify_CapwapPayloadInnerVlanCfi, 6080 "CapwapPayloadInnerVlanCfi"); 6081 break; 6082 case bcmFieldQualifyCapwapPayloadVlanFormat: 6083 rv = fp_qual_8(unit, eid, args, 6084 bcm_field_qualify_CapwapPayloadVlanFormat, 6085 "CapwapPayloadVlanFormat"); 6086 break; 6087 case bcmFieldQualifyCapwapPayloadSip: 6088 rv = fp_qual_ip(unit, eid, args, bcm_field_qualify_CapwapPayloadSip, 6089 "CapwapPayloadSip"); 6090 break; 6091 case bcmFieldQualifyCapwapPayloadDip: 6092 rv = fp_qual_ip(unit, eid, args, bcm_field_qualify_CapwapPayloadDip, 6093 "CapwapPayloadDip"); 6094 break; 6095 case bcmFieldQualifyCapwapPayloadSip6: 6096 rv = fp_qual_ip6(unit, eid, args, bcm_field_qualify_CapwapPayloadSip6, 6097 "CapwapPayloadSip6"); 6098 break; 6099 case bcmFieldQualifyCapwapPayloadDip6: 6100 rv = fp_qual_ip6(unit, eid, args, bcm_field_qualify_CapwapPayloadDip6, 6101 "CapwapPayloadDip6"); 6102 break; 6103 case bcmFieldQualifyCapwapPayloadIpProtocol: 6104 rv = fp_qual_8(unit, eid, args, 6105 bcm_field_qualify_CapwapPayloadIpProtocol, 6106 "CapwapPayloadIpProtocol"); 6107 break; 6108 case bcmFieldQualifyCapwapPayloadTos: 6109 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_CapwapPayloadTos, 6110 "CapwapPayloadTos"); 6111 break; 6112 case bcmFieldQualifyCapwapPayloadL4SrcPort: 6113 rv = fp_qual_l4port(unit, eid, args, 6114 bcm_field_qualify_CapwapPayloadL4SrcPort, 6115 "CapwapPayloadL4SrcPort"); 6116 break; 6117 case bcmFieldQualifyCapwapPayloadL4DstPort: 6118 rv = fp_qual_l4port(unit, eid, args, 6119 bcm_field_qualify_CapwapPayloadL4DstPort, 6120 "CapwapPayloadL4DstPort"); 6121 break; 6122 case bcmFieldQualifyCapwapPayloadL3HdrParseable: 6123 rv = fp_qual_8(unit, eid, args, 6124 bcm_field_qualify_CapwapPayloadL3HdrParseable, 6125 "CapwapPayloadL3HdrParseable"); 6126 break; 6127 case bcmFieldQualifyCapwapPayloadL4HdrParseable: 6128 rv = fp_qual_8(unit, eid, args, 6129 bcm_field_qualify_CapwapPayloadL4HdrParseable, 6130 "CapwapPayloadL4HdrParseable"); 6131 break; 6132 case bcmFieldQualifyInterfaceIngressKeySelectClassPort: 6133 rv = fp_qual_32(unit, eid, args, bcm_field_qualify_InterfaceLookupClassPort, 6134 "InterfaceIngressKeySelectClassPort"); 6135 break; 6136 case bcmFieldQualifyITag: 6137 rv = fp_qual_32(unit, eid, args, bcm_field_qualify_ITag, 6138 "ITag"); 6139 break; 6140 case bcmFieldQualifyBfdYourDiscriminator: 6141 rv = fp_qual_32(unit, eid, args, bcm_field_qualify_BfdYourDiscriminator, 6142 "BfdYourDiscriminator"); 6143 break; 6144 case bcmFieldQualifyCpuVisibilityPacket: 6145 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_CpuVisibilityPacket, 6146 "CpuVisibilityPacket"); 6147 break; 6148 case bcmFieldQualifyDstL2MulticastGroup: 6149 rv = fp_qual_Gports(unit, eid, args, bcm_field_qualify_DstL2MulticastGroup, 6150 "DstL2MulticastGroup"); 6151 break; 6152 case bcmFieldQualifyDstL3MulticastGroup: 6153 rv = fp_qual_Gports(unit, eid, args, bcm_field_qualify_DstL3MulticastGroup, 6154 "DstL3MulticastGroup"); 6155 break; 6156 case bcmFieldQualifyISid: 6157 rv = fp_qual_32(unit, eid, args, bcm_field_qualify_ISid, 6158 "ISid"); 6159 break; 6160 case bcmFieldQualifyDownMepSatTerminated: 6161 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_DownMepSatTerminated, 6162 "DownMepSatTerminated"); 6163 break; 6164 case bcmFieldQualifyStpState: 6165 rv = fp_qual_StpState(unit, eid, args); 6166 break; 6167 case bcmFieldQualifyTosLower4Bits: 6168 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_TosLower4Bits, 6169 "TosLower4Bits"); 6170 break; 6171 case bcmFieldQualifyOamEgressClass2Vxlt: 6172 rv = fp_qual_32(unit, eid, args, bcm_field_qualify_OamEgressClass2Vxlt, 6173 "OamEgressClass2Vxlt"); 6174 break; 6175 case bcmFieldQualifyOamEgressVxltFirstHit: 6176 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_OamEgressVxltFirstHit, 6177 "OamEgressVxltFirstHit"); 6178 break; 6179 case bcmFieldQualifyOamEgressVxltSecondHit: 6180 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_OamEgressVxltSecondHit, 6181 "OamEgressVxltSecondHit"); 6182 break; 6183 case bcmFieldQualifyOamDownMEPLoopbackPacket: 6184 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_OamDownMEPLoopbackPacket, 6185 "OamDownMEPLoopbackPacket"); 6186 break; 6187 case bcmFieldQualifyOamEgressPortUnicastDstMacHit: 6188 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_OamEgressPortUnicastDstMacHit, 6189 "OamEgressPortUnicastDstMacHit"); 6190 break; 6191 case bcmFieldQualifyIngressDropEthernetOamControl: 6192 rv = fp_qual_OamDrop(unit, eid, args, bcm_field_qualify_IngressDropEthernetOamControl, 6193 "IngressDropEthernetOamControl"); 6194 break; 6195 case bcmFieldQualifyIngressDropEthernetOamData: 6196 rv = fp_qual_OamDrop(unit, eid, args, bcm_field_qualify_IngressDropEthernetOamData, 6197 "IngressDropEthernetOamData"); 6198 break; 6199 case bcmFieldQualifyIngressDropMplsOamControl: 6200 rv = fp_qual_OamDrop(unit, eid, args, bcm_field_qualify_IngressDropMplsOamControl, 6201 "IngressDropMplsOamControl"); 6202 break; 6203 case bcmFieldQualifyIngressDropMplsOamData: 6204 rv = fp_qual_OamDrop(unit, eid, args, bcm_field_qualify_IngressDropMplsOamData, 6205 "IngressDropMplsOamData"); 6206 break; 6207 case bcmFieldQualifyOamEgressEtherType: 6208 rv = fp_qual_OamEgressEtherType(unit, eid, args); 6209 break; 6210 case bcmFieldQualifyOamEgressMulticastMacHit: 6211 rv = fp_qual_OamEgressMulticastMacHit(unit, eid, args); 6212 break; 6213 case bcmFieldQualifyTrunkMemberSourceModuleId: 6214 rv = fp_qual_Gports(unit, eid, args, bcm_field_qualify_TrunkMemberSourceModuleId, 6215 "TrunkMemberSourceModuleId"); 6216 break; 6217 case bcmFieldQualifyOamEgressClassSrcMac: 6218 rv = fp_qual_32(unit, eid, args, bcm_field_qualify_OamEgressClassSrcMac, 6219 "OamEgressClassSrcMac"); 6220 break; 6221 case bcmFieldQualifyMyStation2Hit: 6222 rv = fp_qual_8(unit, eid, args, bcm_field_qualify_MyStation2Hit, 6223 "MyStation2Hit"); 6224 break; 6225 case bcmFieldQualifyPreemptablePacket: 6226 rv = fp_qual_8(unit, eid, args, 6227 bcm_field_qualify_PreemptablePacket, 6228 "PreemptablePacket"); 6229 break; 6230 case bcmFieldQualifyVxlanClassValid: 6231 rv = fp_qual_8(unit, eid, args, 6232 bcm_field_qualify_VxlanClassValid, 6233 "VxlanClassValid"); 6234 break; 6235 case bcmFieldQualifyVxlanPacket: 6236 rv = fp_qual_8(unit, eid, args, 6237 bcm_field_qualify_VxlanPacket, 6238 "VxlanPacket"); 6239 break; 6240 case bcmFieldQualifyVxlanVnidVlanTranslateHit: 6241 rv = fp_qual_8(unit, eid, args, 6242 bcm_field_qualify_VxlanVnidVlanTranslateHit, 6243 "VxlanVnidVlanTranslateHit"); 6244 break; 6245 case bcmFieldQualifyVxlanPayloadVlanFormat: 6246 rv = fp_qual_8(unit, eid, args, 6247 bcm_field_qualify_VxlanPayloadVlanFormat, 6248 "VxlanPayloadVlanFormat"); 6249 break; 6250 case bcmFieldQualifyTunnelPayloadSrcMac: 6251 rv = fp_qual_mac(unit, eid, args, 6252 bcm_field_qualify_TunnelPayloadSrcMac, 6253 "TunnelPayloadSrcMac"); 6254 break; 6255 case bcmFieldQualifyTunnelPayloadDstMac: 6256 rv = fp_qual_mac(unit, eid, args, 6257 bcm_field_qualify_TunnelPayloadDstMac, 6258 "TunnelPayloadDstMac"); 6259 break; 6260 case bcmFieldQualifyTunnelPayloadEtherType: 6261 rv = fp_qual_16(unit, eid, args, 6262 bcm_field_qualify_TunnelPayloadEtherType, 6263 "TunnelPayloadEtherType"); 6264 break; 6265 case bcmFieldQualifyTunnelPayloadOuterVlan: 6266 rv = fp_qual_vlan(unit, eid, args, 6267 bcm_field_qualify_TunnelPayloadOuterVlan, 6268 "TunnelPayloadOuterVlan"); 6269 break; 6270 case bcmFieldQualifyTunnelPayloadOuterVlanId: 6271 rv = fp_qual_16(unit, eid, args, 6272 bcm_field_qualify_TunnelPayloadOuterVlanId, 6273 "TunnelPayloadOuterVlanId"); 6274 break; 6275 case bcmFieldQualifyTunnelPayloadOuterVlanPri: 6276 rv = fp_qual_8(unit, eid, args, 6277 bcm_field_qualify_TunnelPayloadOuterVlanPri, 6278 "TunnelPayloadOuterVlanPri"); 6279 break; 6280 case bcmFieldQualifyTunnelPayloadOuterVlanCfi: 6281 rv = fp_qual_8(unit, eid, args, 6282 bcm_field_qualify_TunnelPayloadOuterVlanCfi, 6283 "TunnelPayloadOuterVlanCfi"); 6284 break; 6285 case bcmFieldQualifyTunnelPayloadSip: 6286 rv = fp_qual_ip(unit, eid, args, 6287 bcm_field_qualify_TunnelPayloadSip, 6288 "TunnelPayloadSip"); 6289 break; 6290 case bcmFieldQualifyTunnelPayloadDip: 6291 rv = fp_qual_ip(unit, eid, args, 6292 bcm_field_qualify_TunnelPayloadDip, 6293 "TunnelPayloadDip"); 6294 break; 6295 case bcmFieldQualifyTunnelPayloadSip6: 6296 rv = fp_qual_ip6(unit, eid, args, 6297 bcm_field_qualify_TunnelPayloadSip6, 6298 "TunnelPayloadSip6"); 6299 break; 6300 case bcmFieldQualifyTunnelPayloadDip6: 6301 rv = fp_qual_ip6(unit, eid, args, 6302 bcm_field_qualify_TunnelPayloadDip6, 6303 "TunnelPayloadDip6"); 6304 break; 6305 case bcmFieldQualifyTunnelPayloadIpProtocol: 6306 rv = fp_qual_8(unit, eid, args, 6307 bcm_field_qualify_TunnelPayloadIpProtocol, 6308 "TunnelPayloadIpProtocol"); 6309 break; 6310 case bcmFieldQualifyTunnelPayloadL4SrcPort: 6311 rv = fp_qual_l4port(unit, eid, args, 6312 bcm_field_qualify_TunnelPayloadL4SrcPort, 6313 "TunnelPayloadL4SrcPort"); 6314 break; 6315 case bcmFieldQualifyTunnelPayloadL4DstPort: 6316 rv = fp_qual_l4port(unit, eid, args, 6317 bcm_field_qualify_TunnelPayloadL4DstPort, 6318 "TunnelPayloadL4DstPort"); 6319 break; 6320 case bcmFieldQualifyRoeFrameType: 6321 rv = fp_qual_RoeFrameType(unit, eid, args); 6322 break; 6323 case bcmFieldQualifyIp6PktNextHeader: 6324 rv = fp_qual_8(unit, eid, args, 6325 bcm_field_qualify_Ip6PktNextHeader, 6326 "Ip6PktNextHeader"); 6327 break; 6328 case bcmFieldQualifyIp6PktHopLimit: 6329 rv = fp_qual_8(unit, eid, args, 6330 bcm_field_qualify_Ip6PktHopLimit, 6331 "Ip6PktHopLimit"); 6332 break; 6333 case bcmFieldQualifyIp6PktTrafficClass: 6334 rv = fp_qual_8(unit, eid, args, 6335 bcm_field_qualify_Ip6PktTrafficClass, 6336 "Ip6PktTrafficClass"); 6337 break; 6338 case bcmFieldQualifyInnerIp6PktNextHeader: 6339 rv = fp_qual_8(unit, eid, args, 6340 bcm_field_qualify_InnerIp6PktNextHeader, 6341 "InnerIp6PktNextHeader"); 6342 break; 6343 case bcmFieldQualifyInnerIp6PktHopLimit: 6344 rv = fp_qual_8(unit, eid, args, 6345 bcm_field_qualify_InnerIp6PktHopLimit, 6346 "InnerIp6PktHopLimit"); 6347 break; 6348 case bcmFieldQualifyInnerIp6PktTrafficClass: 6349 rv = fp_qual_8(unit, eid, args, 6350 bcm_field_qualify_InnerIp6PktTrafficClass, 6351 "InnerIp6PktTrafficClass"); 6352 break; 6353 case bcmFieldQualifyInnerDosAttack: 6354 rv = fp_qual_8(unit, eid, args, 6355 bcm_field_qualify_InnerDosAttack, 6356 "InnerDosAttack"); 6357 break; 6358 case bcmFieldQualifyDosAttackEvents: 6359 rv = fp_qual_32(unit, eid, args, 6360 bcm_field_qualify_DosAttackEvents, 6361 "DosAttackEvents"); 6362 break; 6363 case bcmFieldQualifyInnerDosAttackEvents: 6364 rv = fp_qual_32(unit, eid, args, 6365 bcm_field_qualify_InnerDosAttackEvents, 6366 "InnerDosAttackEvents"); 6367 break; 6368 case bcmFieldQualifyIp4Length: 6369 rv = fp_qual_16(unit, eid, args, 6370 bcm_field_qualify_Ip4Length, 6371 "Ip4Length"); 6372 break; 6373 case bcmFieldQualifyIp6Length: 6374 rv = fp_qual_16(unit, eid, args, 6375 bcm_field_qualify_Ip6Length, 6376 "Ip6Length"); 6377 break; 6378 case bcmFieldQualifyTunnelPayloadIp4Length: 6379 rv = fp_qual_16(unit, eid, args, 6380 bcm_field_qualify_TunnelPayloadIp4Length, 6381 "TunnelPayloadIp4Length"); 6382 break; 6383 case bcmFieldQualifyTunnelPayloadIp6Length: 6384 rv = fp_qual_16(unit, eid, args, 6385 bcm_field_qualify_TunnelPayloadIp6Length, 6386 "TunnelPayloadIp6Length"); 6387 break; 6388 case bcmFieldQualifyOpaqueTagType: 6389 rv = fp_qual_8(unit, eid, args, 6390 bcm_field_qualify_OpaqueTagType, 6391 "OpaqueTagType"); 6392 break; 6393 case bcmFieldQualifyOpaqueTagHigh: 6394 rv = fp_qual_32(unit, eid, args, 6395 bcm_field_qualify_OpaqueTagHigh, 6396 "OpaqueTagHigh"); 6397 break; 6398 case bcmFieldQualifyOpaqueTagLow: 6399 rv = fp_qual_32(unit, eid, args, 6400 bcm_field_qualify_OpaqueTagLow, 6401 "OpaqueTagLow"); 6402 break; 6403 case bcmFieldQualifyCount: 6404 default: 6405 fp_list_quals(unit, args); 6406 LOG_ERROR(BSL_LS_APPL_SHELL, 6407 (BSL_META_U(unit, 6408 "FP(unit %d) Error: Unknown qualifier: %s\n"), unit, qual_str)); 6409 rv = CMD_FAIL; 6410 } 6411 6412 if (CMD_OK != rv) { 6413 LOG_ERROR(BSL_LS_APPL_SHELL, 6414 (BSL_META_U(unit, 6415 "FP(unit %d) Error: Qualifier installation error: %s\n"), 6416 unit, qual_str)); 6417 } 6418 6419 return rv; 6420 } 6421 6422 /* 6423 * Function: 6424 * Purpose: 6425 * Parmameters: 6426 * Returns: 6427 */ 6428 STATIC int 6429 fp_qual_InPorts(int unit, bcm_field_entry_t eid, bcm_field_qualify_t qual, args_t *args) 6430 { 6431 int retval = CMD_OK; 6432 char* subcmd = NULL; 6433 bcm_pbmp_t data, mask; 6434 bcm_port_config_t pcfg; 6435 6436 if ((subcmd = ARG_GET(args)) == NULL) { 6437 return CMD_USAGE; 6438 } else if (parse_bcm_pbmp(unit, subcmd, &data) < 0) { 6439 LOG_ERROR(BSL_LS_APPL_SHELL, 6440 (BSL_META_U(unit, 6441 "FP(unit %d) Error: %s: Error: unrecognized port bitmap: %s\n"), 6442 unit, ARG_CMD(args), subcmd)); 6443 return CMD_FAIL; 6444 } 6445 6446 if (bcm_port_config_get(unit, &pcfg) != BCM_E_NONE) { 6447 LOG_ERROR(BSL_LS_APPL_SHELL, 6448 (BSL_META_U(unit, 6449 "FP(unit %d) Error: %s: Error: bcm ports not initialized\n"), unit, 6450 ARG_CMD(args))); 6451 return CMD_FAIL; 6452 } 6453 6454 if ((subcmd = ARG_GET(args)) == NULL) { 6455 BCM_PBMP_ASSIGN(mask, pcfg.all); 6456 } else if (parse_bcm_pbmp(unit, subcmd, &mask) < 0) { 6457 return CMD_FAIL; 6458 } 6459 6460 switch (qual) { 6461 case bcmFieldQualifyInPorts: 6462 /* BCM.0> fp qual 'eid' InPorts 'data' 'mask' */ 6463 retval = bcm_field_qualify_InPorts(unit, eid, data, mask); 6464 FP_CHECK_RETURN(unit, retval, "bcm_field_qualify_InPorts"); 6465 break; 6466 case bcmFieldQualifyDevicePortBitmap: 6467 /* BCM.0> fp qual 'eid' devicePortBitmap 'data' 'mask' */ 6468 retval = bcm_field_qualify_DevicePortBitmap(unit, eid, data, mask); 6469 FP_CHECK_RETURN(unit, retval, "bcm_field_qualify_DevicePortBitmap"); 6470 break; 6471 case bcmFieldQualifySystemPortBitmap: 6472 /* BCM.0> fp qual 'eid' systemPortBitmap 'data' 'mask' */ 6473 retval = bcm_field_qualify_SystemPortBitmap(unit, eid, data, mask); 6474 FP_CHECK_RETURN(unit, retval, "bcm_field_qualify_SystemPortBitmap"); 6475 break; 6476 case bcmFieldQualifySourceGportBitmap: 6477 /* BCM.0> fp qual 'eid' sourceGportBitmap 'data' 'mask' */ 6478 retval = bcm_field_qualify_SourceGportBitmap(unit, eid, data, mask); 6479 FP_CHECK_RETURN(unit, retval, "bcm_field_qualify_SourceGportBitmap"); 6480 break; 6481 default: 6482 return CMD_FAIL; 6483 } 6484 6485 return CMD_OK; 6486 } 6487 6488 /* 6489 * Function: 6490 * Purpose: 6491 * Parmameters: 6492 * Returns: 6493 */ 6494 STATIC int 6495 fp_qual_OutPorts(int unit, bcm_field_entry_t eid, args_t *args) 6496 { 6497 int retval = CMD_OK; 6498 char* subcmd = NULL; 6499 bcm_pbmp_t data, mask; 6500 bcm_port_config_t pcfg; 6501 6502 if ((subcmd = ARG_GET(args)) == NULL) { 6503 return CMD_USAGE; 6504 } else if (parse_bcm_pbmp(unit, subcmd, &data) < 0) { 6505 LOG_ERROR(BSL_LS_APPL_SHELL, 6506 (BSL_META_U(unit, 6507 "FP(unit %d) Error: %s: Error: unrecognized port bitmap: %s\n"), 6508 unit, ARG_CMD(args), subcmd)); 6509 return CMD_FAIL; 6510 } 6511 6512 if (bcm_port_config_get(unit, &pcfg) != BCM_E_NONE) { 6513 LOG_ERROR(BSL_LS_APPL_SHELL, 6514 (BSL_META_U(unit, 6515 "FP(unit %d) Error: %s: Error: bcm ports not initialized\n"), 6516 unit, ARG_CMD(args))); 6517 return CMD_FAIL; 6518 } 6519 6520 if ((subcmd = ARG_GET(args)) == NULL) { 6521 BCM_PBMP_ASSIGN(mask, pcfg.port); 6522 } else if (parse_bcm_pbmp(unit, subcmd, &mask) < 0) { 6523 return CMD_FAIL; 6524 } 6525 6526 /* BCM.0> fp qual 'eid' OutPorts 'data' 'mask' */ 6527 retval = bcm_field_qualify_OutPorts(unit, eid, data, mask); 6528 FP_CHECK_RETURN(unit, retval, "bcm_field_qualify_OutPorts"); 6529 6530 return CMD_OK; 6531 } 6532 6533 /* 6534 * Function: 6535 * Purpose: 6536 * Parmameters: 6537 * Returns: 6538 */ 6539 STATIC int 6540 fp_qual_port(int unit, bcm_field_entry_t eid, args_t *args, 6541 int func(int, bcm_field_entry_t, bcm_port_t, bcm_port_t), 6542 char *qual_str) 6543 { 6544 int retval = CMD_OK; 6545 char *subcmd = NULL; 6546 bcm_port_t data, mask; 6547 char str[FP_STAT_STR_SZ]; 6548 6549 sal_memset(str, 0, sizeof(char) * FP_STAT_STR_SZ); 6550 6551 FP_GET_PORT(unit, data, subcmd, args); 6552 FP_GET_NUMB(mask, subcmd, args); 6553 6554 /* BCM.0> fp qual 'eid' Qual 'data' 'mask' */ 6555 retval = func(unit, eid, data, mask); 6556 strcpy(str, "bcm_field_qualify_"); 6557 strncat(str, qual_str, FP_STAT_STR_SZ - 1 - strlen(str)); 6558 FP_CHECK_RETURN(unit, retval, str); 6559 6560 return CMD_OK; 6561 } 6562 6563 /* 6564 * Function: 6565 * Purpose: 6566 * Parmameters: 6567 * Returns: 6568 */ 6569 STATIC int 6570 fp_qual_modport(int unit, bcm_field_entry_t eid, args_t *args, 6571 int func(int, bcm_field_entry_t, bcm_module_t, bcm_module_t, 6572 bcm_port_t, bcm_port_t), 6573 char *qual_str) 6574 { 6575 int retval = CMD_OK; 6576 bcm_module_t data_modid, mask_modid = (1 << 6) - 1; 6577 int data_port, mask_port = (1 << 6) - 1; 6578 char str[FP_STAT_STR_SZ]; 6579 parse_table_t pt; 6580 6581 parse_table_init(unit, &pt); 6582 parse_table_add(&pt, "Modid", PQ_DFL | PQ_INT, 0, 6583 (void *)&data_modid, 0); 6584 parse_table_add(&pt, "ModidMask", PQ_DFL | PQ_INT, 0, 6585 (void *)&mask_modid, 0); 6586 parse_table_add(&pt, "Port", PQ_DFL | PQ_PORT, 0, 6587 (void *)&data_port, 0); 6588 parse_table_add(&pt, "PortMask", PQ_DFL | PQ_INT, 0, 6589 (void *)&mask_port, 0); 6590 6591 if (BCM_FAILURE(parse_arg_eq(args, &pt))) { 6592 parse_arg_eq_done(&pt); 6593 return CMD_FAIL; 6594 } 6595 6596 /* BCM.0> fp qual 'eid' Qual 'data' 'mask' */ 6597 retval = func(unit, eid, data_modid, mask_modid, data_port, mask_port); 6598 sal_memset(str, 0, sizeof(char) * FP_STAT_STR_SZ); 6599 strcpy(str, "bcm_field_qualify_"); 6600 strncat(str, qual_str, FP_STAT_STR_SZ - 1 - strlen(str)); 6601 FP_CHECK_RETURN(unit, retval, str); 6602 6603 return CMD_OK; 6604 } 6605 6606 STATIC int 6607 fp_qual_modport_help(const char *prefix, const char *qual_str, int width_col1) 6608 { 6609 if (width_col1 < sal_strlen(qual_str)) { 6610 width_col1 = sal_strlen(qual_str) + 1; 6611 } 6612 6613 /* "FieldProcessor qual <eid> DstPort" */ 6614 cli_out("%s%-*s%s\n", prefix, width_col1, qual_str, 6615 "Port=<port_numb> PortMask=<mask> Modid=<mod>, ModidMask=<mask>"); 6616 6617 return CMD_OK; 6618 } 6619 6620 /* 6621 * Function: 6622 * Purpose: 6623 * Parmameters: 6624 * Returns: 6625 */ 6626 STATIC int 6627 fp_qual_trunk(int unit, bcm_field_entry_t eid, args_t *args, 6628 int func(int, bcm_field_entry_t, bcm_trunk_t, bcm_trunk_t), 6629 char *qual_str) 6630 { 6631 int retval = CMD_OK; 6632 char *subcmd = NULL; 6633 bcm_port_t data, mask; 6634 char str[FP_STAT_STR_SZ]; 6635 6636 sal_memset(str, 0, sizeof(char) * FP_STAT_STR_SZ); 6637 6638 FP_GET_NUMB(data, subcmd, args); 6639 FP_GET_NUMB(mask, subcmd, args); 6640 6641 /* BCM.0> fp qual 'eid' Qual 'data' 'mask' */ 6642 retval = func(unit, eid, data, mask); 6643 strcpy(str, "bcm_field_qualify_"); 6644 strncat(str, qual_str, FP_STAT_STR_SZ - 1 - strlen(str)); 6645 FP_CHECK_RETURN(unit, retval, str); 6646 6647 return CMD_OK; 6648 } 6649 6650 /* 6651 * Function: 6652 * Purpose: 6653 * Parmameters: 6654 * Returns: 6655 */ 6656 STATIC int 6657 fp_qual_l4port(int unit, bcm_field_entry_t eid, args_t *args, 6658 int func(int, bcm_field_entry_t, bcm_l4_port_t, bcm_l4_port_t), 6659 char *qual_str) 6660 { 6661 int retval = CMD_OK; 6662 char *subcmd = NULL; 6663 bcm_l4_port_t data, mask; 6664 char str[FP_STAT_STR_SZ]; 6665 6666 sal_memset(str, 0, sizeof(char) * FP_STAT_STR_SZ); 6667 FP_GET_NUMB(data, subcmd, args); 6668 FP_GET_NUMB(mask, subcmd, args); 6669 6670 /* BCM.0> fp qual 'eid' Qual 'data' 'mask' */ 6671 retval = func(unit, eid, data, mask); 6672 strcpy(str, "bcm_field_qualify_"); 6673 strncat(str, qual_str, FP_STAT_STR_SZ - 1 - strlen(str)); 6674 FP_CHECK_RETURN(unit, retval, str); 6675 6676 return CMD_OK; 6677 } 6678 6679 /* 6680 * Function: 6681 * Purpose: 6682 * Parmameters: 6683 * Returns: 6684 */ 6685 STATIC int 6686 fp_qual_rangecheck(int unit, bcm_field_entry_t eid, args_t *args, 6687 int func(int, bcm_field_entry_t, bcm_field_range_t, int), 6688 char *qual_str) 6689 { 6690 int retval = CMD_OK; 6691 char *subcmd = NULL; 6692 int range, result; 6693 char str[FP_STAT_STR_SZ]; 6694 6695 sal_memset(str, 0, sizeof(char) * FP_STAT_STR_SZ); 6696 FP_GET_NUMB(range, subcmd, args); 6697 FP_GET_NUMB(result, subcmd, args); 6698 6699 /* BCM.0> fp qual 'eid' RangeCheck 'range' 'result' */ 6700 retval = func(unit, eid, range, result); 6701 strcpy(str, "bcm_field_qualify_"); 6702 strncat(str, qual_str, FP_STAT_STR_SZ - 1 - strlen(str)); 6703 FP_CHECK_RETURN(unit, retval, str); 6704 6705 return CMD_OK; 6706 } 6707 6708 /* 6709 * Function: 6710 * Purpose: 6711 * Parmameters: 6712 * Returns: 6713 */ 6714 STATIC int 6715 fp_qual_vlan(int unit, bcm_field_entry_t eid, args_t *args, 6716 int func(int, bcm_field_entry_t, bcm_vlan_t, bcm_vlan_t), 6717 char *qual_str) 6718 { 6719 int retval = CMD_OK; 6720 char *subcmd = NULL; 6721 bcm_vlan_t data, mask; 6722 char str[FP_STAT_STR_SZ]; 6723 6724 FP_GET_NUMB(data, subcmd, args); 6725 FP_GET_NUMB(mask, subcmd, args); 6726 6727 /* BCM.0> fp qual 'eid' Qual 'data' 'mask' */ 6728 retval = func(unit, eid, data, mask); 6729 strcpy(str, "bcm_field_qualify_"); 6730 strncat(str, qual_str, FP_STAT_STR_SZ - 1 - strlen(str)); 6731 FP_CHECK_RETURN(unit, retval, str); 6732 6733 return CMD_OK; 6734 } 6735 6736 /* 6737 * Function: 6738 * Purpose: 6739 * Parmameters: 6740 * Returns: 6741 */ 6742 STATIC int 6743 fp_qual_tpid(int unit, bcm_field_entry_t eid, args_t *args, 6744 int func(int, bcm_field_entry_t, uint16), 6745 char *qual_str) 6746 { 6747 int retval = CMD_OK; 6748 char *subcmd = NULL; 6749 uint16 data; 6750 char str[FP_STAT_STR_SZ]; 6751 6752 FP_GET_NUMB(data, subcmd, args); 6753 6754 /* BCM.0> fp qual 'eid' Qual 'data' */ 6755 retval = func(unit, eid, data); 6756 strcpy(str, "bcm_field_qualify_"); 6757 strncat(str, qual_str, FP_STAT_STR_SZ - 1 - strlen(str)); 6758 FP_CHECK_RETURN(unit, retval, str); 6759 6760 return CMD_OK; 6761 } 6762 6763 /* 6764 * Function: 6765 * Purpose: 6766 * Parmameters: 6767 * Returns: 6768 */ 6769 STATIC int 6770 fp_qual_ip(int unit, bcm_field_entry_t eid, args_t *args, 6771 int func(int, bcm_field_entry_t, bcm_ip_t, bcm_ip_t), 6772 char *qual_str) 6773 { 6774 int retval = CMD_OK; 6775 char *subcmd = NULL; 6776 bcm_ip_t data, mask; 6777 char stat_str[FP_STAT_STR_SZ]; 6778 6779 6780 if ((subcmd = ARG_GET(args)) == NULL) { 6781 return CMD_USAGE; 6782 } 6783 if (parse_ipaddr(subcmd, &data) < 0) { 6784 LOG_ERROR(BSL_LS_APPL_SHELL, 6785 (BSL_META_U(unit, 6786 "FP(unit %d) Error: invalid ip4 addr string: \"%s\"\n"), 6787 unit, subcmd)); 6788 return CMD_FAIL; 6789 } 6790 6791 if ((subcmd = ARG_GET(args)) == NULL) { 6792 return CMD_USAGE; 6793 } 6794 if (parse_ipaddr(subcmd, &mask) < 0) { 6795 LOG_ERROR(BSL_LS_APPL_SHELL, 6796 (BSL_META_U(unit, 6797 "FP(unit %d) Error: invalid ip4 addr string: \"%s\"\n"), unit, 6798 subcmd)); 6799 return CMD_FAIL; 6800 } 6801 6802 /* BCM.0> fp qual 'eid' Qual 'data' 'mask' */ 6803 retval = func(unit, eid, data, mask); 6804 strcpy(stat_str, "bcm_field_qualify_"); 6805 strncat(stat_str, qual_str, FP_STAT_STR_SZ - strlen(stat_str)); 6806 FP_CHECK_RETURN(unit, retval, stat_str); 6807 6808 return CMD_OK; 6809 } 6810 6811 /* 6812 * Function: 6813 * Purpose: 6814 * Parmameters: 6815 * Returns: 6816 */ 6817 STATIC int 6818 fp_qual_ip6(int unit, bcm_field_entry_t eid, args_t *args, 6819 int func(int, bcm_field_entry_t, bcm_ip6_t, bcm_ip6_t), 6820 char *qual_str) 6821 { 6822 int retval = CMD_OK; 6823 char *subcmd = NULL; 6824 bcm_ip6_t data, mask; 6825 char str[FP_STAT_STR_SZ]; 6826 6827 if ((subcmd = ARG_GET(args)) == NULL) { 6828 return CMD_USAGE; 6829 } 6830 SOC_IF_ERROR_RETURN(parse_ip6addr(subcmd, data)); 6831 6832 if ((subcmd = ARG_GET(args)) == NULL) { 6833 return CMD_USAGE; 6834 } 6835 SOC_IF_ERROR_RETURN(parse_ip6addr(subcmd, mask)); 6836 6837 /* BCM.0> fp qual 'eid' Qual 'data' 'mask' */ 6838 retval = func(unit, eid, data, mask); 6839 strcpy(str, "bcm_field_qualify_"); 6840 strncat(str, qual_str, FP_STAT_STR_SZ - 1 - strlen(str)); 6841 FP_CHECK_RETURN(unit, retval, str); 6842 6843 return CMD_OK; 6844 } 6845 6846 /* 6847 * Function: 6848 * Purpose: 6849 * Parmameters: 6850 * Returns: 6851 */ 6852 STATIC int 6853 fp_qual_mac(int unit, bcm_field_entry_t eid, args_t *args, 6854 int func(int, bcm_field_entry_t, bcm_mac_t, bcm_mac_t), 6855 char *qual_str) 6856 { 6857 int retval = CMD_OK; 6858 bcm_mac_t data, mask; 6859 char stat_str[FP_STAT_STR_SZ]; 6860 char *subcmd; 6861 parse_table_t pt; 6862 6863 /* Give data and mask default values. */ 6864 sal_memset(data, 0xff, sizeof(bcm_mac_t)); 6865 sal_memset(mask, 0xff, sizeof(bcm_mac_t)); 6866 6867 parse_table_init(unit, &pt); 6868 parse_table_add(&pt, "Data", PQ_DFL | PQ_MAC, 0, 6869 (void *)&data, 0); 6870 parse_table_add(&pt, "Mask", PQ_DFL | PQ_MAC, 0, 6871 (void *)&mask, 0); 6872 6873 if (2 != (parse_arg_eq(args, &pt))) { 6874 parse_arg_eq_done(&pt); 6875 /* Try to parse without key words. */ 6876 FP_GET_MAC(data, subcmd, args); 6877 FP_GET_MAC(mask, subcmd, args); 6878 } 6879 6880 /* BCM.0> fp qual 'eid' Qual 'data' 'mask' */ 6881 retval = func(unit, eid, data, mask); 6882 strcpy(stat_str, "bcm_field_qualify_"); 6883 strncat(stat_str, qual_str, FP_STAT_STR_SZ - 1 - strlen(stat_str)); 6884 FP_CHECK_RETURN(unit, retval, stat_str); 6885 6886 return CMD_OK; 6887 } 6888 6889 STATIC int 6890 fp_qual_mac_help(const char *prefix, const char *qual_str, int width_col1) 6891 { 6892 if (width_col1 < sal_strlen(qual_str)) { 6893 width_col1 = sal_strlen(qual_str) + 1; 6894 } 6895 6896 /* "FieldProcessor qual <eid> XxxMac" */ 6897 cli_out("%s%-*s%s\n", prefix, width_col1, qual_str, 6898 "Data=<mac> Mask=<mac>"); 6899 6900 return CMD_OK; 6901 } 6902 6903 /* 6904 * Function: 6905 * fp_qual_SrcLookupClass 6906 * Purpose: 6907 * Qualify on Source Lookup Class. 6908 * Parmameters: 6909 * Returns: 6910 */ 6911 STATIC int 6912 fp_qual_SrcLookupClass(int unit, bcm_field_entry_t eid, args_t *args, 6913 int func(int, bcm_field_entry_t, uint32, uint32), 6914 char *qual_str) 6915 { 6916 int retval = CMD_OK; 6917 char *subcmd = NULL; 6918 uint32 data, mask; 6919 char str[FP_STAT_STR_SZ]; 6920 6921 FP_GET_NUMB(data, subcmd, args); 6922 FP_GET_NUMB(mask, subcmd, args); 6923 6924 /* BCM.0> fp qual 'eid' Qual 'data' 'mask' */ 6925 retval = func(unit, eid, data, mask); 6926 strcpy(str, "bcm_field_qualify_"); 6927 strncat(str, qual_str, FP_STAT_STR_SZ - 1 - strlen(str)); 6928 FP_CHECK_RETURN(unit, retval, str); 6929 6930 return CMD_OK; 6931 } 6932 6933 6934 /* 6935 * Function: 6936 * fp_qual_DstLookupClass 6937 * Purpose: 6938 * Qualify on Destination Lookup Class. 6939 * Parmameters: 6940 * Returns: 6941 */ 6942 STATIC int 6943 fp_qual_DstLookupClass(int unit, bcm_field_entry_t eid, args_t *args, 6944 int func(int, bcm_field_entry_t, uint32, uint32), 6945 char *qual_str) 6946 { 6947 int retval = CMD_OK; 6948 char *subcmd = NULL; 6949 uint32 data, mask; 6950 char str[FP_STAT_STR_SZ]; 6951 6952 FP_GET_NUMB(data, subcmd, args); 6953 FP_GET_NUMB(mask, subcmd, args); 6954 6955 /* BCM.0> fp qual 'eid' Qual 'data' 'mask' */ 6956 retval = func(unit, eid, data, mask); 6957 strcpy(str, "bcm_field_qualify_"); 6958 strncat(str, qual_str, FP_STAT_STR_SZ - 1 - strlen(str)); 6959 FP_CHECK_RETURN(unit, retval, str); 6960 6961 return CMD_OK; 6962 } 6963 6964 /* 6965 * Function: 6966 * Purpose: 6967 * Parmameters: 6968 * Returns: 6969 */ 6970 STATIC int 6971 fp_parse_hex_string(char *str, int buf_sz, uint8 *buffer, int *length) 6972 { 6973 int str_len; 6974 char *ptr; 6975 uint8 *data_ptr; 6976 6977 /* Input parameters check. */ 6978 if ((NULL == str) || (NULL == buffer) || (NULL == length)) { 6979 cli_out("Invalid parameters fp_parse_hex_string\n"); 6980 return -1; 6981 } 6982 6983 str_len = strlen(str); 6984 6985 if (str[0] == '0' && tolower((int)str[1]) == 'x') { 6986 ptr = str + 2; 6987 } else { 6988 ptr = str; 6989 } 6990 6991 data_ptr = (uint8 *)buffer; 6992 6993 /* Tackle Input with Odd number of digits. */ 6994 if ((str_len % 2) != 0) { 6995 if (!isxdigit((unsigned) *ptr)) { /* bad character */ 6996 cli_out("Invalid data character. (%c) \n", *ptr); 6997 return -1; 6998 } 6999 *data_ptr |= xdigit2i((unsigned) *(ptr++)); 7000 data_ptr++; 7001 buf_sz--; 7002 } 7003 7004 while ((ptr < (str + str_len)) && (buf_sz > 0)) { 7005 if (!isxdigit((unsigned) *ptr)) { /* bad character */ 7006 cli_out("Invalid data character. (%c) \n", *ptr); 7007 return -1; 7008 } 7009 *data_ptr = 16 * xdigit2i((unsigned) *(ptr++)); 7010 if (!isxdigit((unsigned) *ptr)) { /* bad character */ 7011 cli_out("Invalid data character. (%c) \n", *ptr); 7012 return CMD_USAGE; 7013 } 7014 *data_ptr |= xdigit2i((unsigned) *(ptr++)); 7015 data_ptr++; 7016 buf_sz--; 7017 } 7018 *length = data_ptr - buffer; 7019 return CMD_OK; 7020 } 7021 7022 /* 7023 * Function: 7024 * Purpose: 7025 * Parmameters: 7026 * Returns: 7027 */ 7028 STATIC int 7029 fp_qual_data(int unit, bcm_field_entry_t eid, args_t *args) 7030 { 7031 _bcm_field_qual_data_t data; 7032 _bcm_field_qual_data_t mask; 7033 char *str= NULL; 7034 int retval = CMD_OK; 7035 int qualid; 7036 int data_length; 7037 int mask_length; 7038 int rv; 7039 7040 sal_memset(data, 0, sizeof(_bcm_field_qual_data_t)); 7041 sal_memset(mask, 0, sizeof(_bcm_field_qual_data_t)); 7042 7043 /* Parse command option arguments */ 7044 FP_GET_NUMB(qualid, str, args); 7045 7046 /* Get match data. */ 7047 if ((str= ARG_GET(args)) == NULL) { 7048 return CMD_USAGE; 7049 } 7050 7051 rv = fp_parse_hex_string(str, sizeof(_bcm_field_qual_data_t), 7052 (uint8 *)data, &data_length); 7053 if (rv < 0) { 7054 cli_out("Qualifier data parse error.\n"); 7055 return CMD_USAGE; 7056 } 7057 7058 /* Get match mask. */ 7059 if ((str= ARG_GET(args)) == NULL) { 7060 return CMD_USAGE; 7061 } 7062 7063 rv = fp_parse_hex_string(str, sizeof(_bcm_field_qual_data_t), 7064 (uint8 *)mask, &mask_length); 7065 if (rv < 0) { 7066 cli_out("Qualifier mask parse error.\n"); 7067 return CMD_USAGE; 7068 } 7069 7070 /* BCM.0> fp qual 'eid' data qualid length 'data' 'mask' */ 7071 retval = bcm_field_qualify_data(unit, eid, qualid, 7072 (uint8 *)data, (uint8 *)mask, mask_length); 7073 FP_CHECK_RETURN(unit, retval, "bcm_field_qualify_data"); 7074 return CMD_OK; 7075 } 7076 7077 7078 /* 7079 * Function: 7080 * Purpose: 7081 * Parmameters: 7082 * Returns: 7083 */ 7084 STATIC int 7085 fp_qual_8(int unit, bcm_field_entry_t eid, args_t *args, 7086 int func(int, bcm_field_entry_t, uint8, uint8), 7087 char *qual_str) 7088 { 7089 int retval = CMD_OK; 7090 char *subcmd = NULL; 7091 uint8 data, mask; 7092 char stat_str[FP_STAT_STR_SZ]; 7093 7094 FP_GET_NUMB(data, subcmd, args); 7095 FP_GET_NUMB(mask, subcmd, args); 7096 7097 /* BCM.0> fp qual 'eid' Qual 'data' 'mask' */ 7098 retval = func(unit, eid, data, mask); 7099 strcpy(stat_str, "bcm_field_qualify_"); 7100 strncat(stat_str, qual_str, FP_STAT_STR_SZ - 1 - strlen(stat_str)); 7101 FP_CHECK_RETURN(unit, retval, stat_str); 7102 7103 return CMD_OK; 7104 } 7105 7106 /* 7107 * Function: 7108 * Purpose: 7109 * Parmameters: 7110 * Returns: 7111 */ 7112 STATIC int 7113 fp_qual_16(int unit, bcm_field_entry_t eid, args_t *args, 7114 int func(int, bcm_field_entry_t, uint16, uint16), 7115 char *qual_str) 7116 { 7117 int retval = CMD_OK; 7118 char *subcmd = NULL; 7119 uint16 data, mask; 7120 char str[FP_STAT_STR_SZ]; 7121 7122 FP_GET_NUMB(data, subcmd, args); 7123 FP_GET_NUMB(mask, subcmd, args); 7124 7125 /* BCM.0> fp qual 'eid' Qual 'data' 'mask' */ 7126 retval = func(unit, eid, data, mask); 7127 strcpy(str, "bcm_field_qualify_"); 7128 strncat(str, qual_str, FP_STAT_STR_SZ - 1 - strlen(str)); 7129 FP_CHECK_RETURN(unit, retval, str); 7130 7131 return CMD_OK; 7132 } 7133 7134 7135 /* 7136 * Function: 7137 * Purpose: 7138 * Parmameters: 7139 * Returns: 7140 */ 7141 STATIC int 7142 fp_qual_32(int unit, bcm_field_entry_t eid, args_t *args, 7143 int func(int, bcm_field_entry_t, uint32, uint32), 7144 char *qual_str) 7145 { 7146 int retval = CMD_OK; 7147 char *subcmd = NULL; 7148 uint32 data, mask; 7149 char str[FP_STAT_STR_SZ]; 7150 7151 FP_GET_NUMB(data, subcmd, args); 7152 FP_GET_NUMB(mask, subcmd, args); 7153 7154 /* BCM.0> fp qual 'eid' Qual 'data' 'mask' */ 7155 retval = func(unit, eid, data, mask); 7156 strcpy(str, "bcm_field_qualify_"); 7157 strncat(str, qual_str, FP_STAT_STR_SZ - 1 - strlen(str)); 7158 FP_CHECK_RETURN(unit, retval, str); 7159 7160 return CMD_OK; 7161 } 7162 7163 /* 7164 * Function: 7165 * Purpose: 7166 * Parmameters: 7167 * Returns: 7168 */ 7169 STATIC int 7170 fp_qual_Decap(int unit, bcm_field_entry_t eid, args_t *args) 7171 { 7172 int retval = CMD_OK; 7173 char *subcmd = NULL; 7174 bcm_field_decap_t decap; 7175 7176 if ((subcmd = ARG_GET(args)) == NULL) { 7177 return CMD_USAGE; 7178 } 7179 7180 if (isint(subcmd)) { 7181 decap = parse_integer(subcmd); 7182 } else { 7183 decap = parse_field_decap(subcmd); 7184 if (decap == bcmFieldDecapCount) { 7185 LOG_ERROR(BSL_LS_APPL_SHELL, 7186 (BSL_META_U(unit, 7187 "FP(unit %d) Error: Unknown decap value: %s\n"), unit, subcmd)); 7188 return CMD_FAIL; 7189 } 7190 } 7191 7192 /* BCM.0> fp qual 'eid' Decap 'decap' */ 7193 retval = bcm_field_qualify_Decap(unit, eid, decap); 7194 FP_CHECK_RETURN(unit, retval, "bcm_field_qualify_Decap"); 7195 7196 return CMD_OK; 7197 } 7198 7199 STATIC int 7200 fp_qual_MplsOam_Control_pktType (int unit, bcm_field_entry_t eid, args_t *args) 7201 { 7202 int retval = CMD_OK; 7203 char *subcmd = NULL; 7204 bcm_field_MplsOam_Control_pktType_t pktType; 7205 bcm_field_MplsOam_Control_pktType_t pktTypeMask; 7206 7207 if ((subcmd = ARG_GET(args)) == NULL) { 7208 return CMD_USAGE; 7209 } 7210 7211 if (isint(subcmd)) { 7212 pktType = parse_integer(subcmd); 7213 } else { 7214 pktType = parse_field_MplsOamCtrlPktType(subcmd); 7215 if (pktType == bcmFieldMplsOamControlPktTypeCount) { 7216 LOG_ERROR(BSL_LS_APPL_SHELL, 7217 (BSL_META_U(unit, 7218 "FP(unit %d) Error: Unknown Control PacketType Value: %s\n"), unit, subcmd)); 7219 return CMD_FAIL; 7220 } 7221 } 7222 7223 if (isint(subcmd)) { 7224 pktTypeMask = parse_integer(subcmd); 7225 } else { 7226 pktTypeMask = parse_field_MplsOamCtrlPktType(subcmd); 7227 if (pktTypeMask == bcmFieldMplsOamControlPktTypeCount) { 7228 LOG_ERROR(BSL_LS_APPL_SHELL, 7229 (BSL_META_U(unit, 7230 "FP(unit %d) Error: Unknown Control PacketType Value: %s\n"), unit, subcmd)); 7231 return CMD_FAIL; 7232 } 7233 } 7234 7235 7236 /* BCM.0> fp qual 'eid' MplsOamControlPktType 'pktType' */ 7237 retval = bcm_field_qualify_MplsOamControlPktType(unit, eid, pktType); 7238 FP_CHECK_RETURN(unit, retval, "bcm_field_qualify_MplsOamControlPktType"); 7239 7240 return CMD_OK; 7241 } 7242 7243 /* 7244 * Function: 7245 * Purpose: 7246 * Parmameters: 7247 * Returns: 7248 */ 7249 STATIC int 7250 fp_qual_oam_type(int unit, bcm_field_entry_t eid, args_t *args) 7251 { 7252 int retval = CMD_OK; 7253 char *subcmd = NULL; 7254 bcm_field_oam_type_t oamType; 7255 7256 if ((subcmd = ARG_GET(args)) == NULL) { 7257 return CMD_USAGE; 7258 } 7259 7260 if (isint(subcmd)) { 7261 oamType = parse_integer(subcmd); 7262 } else { 7263 oamType = parse_field_oam_type (subcmd); 7264 if (oamType == bcmFieldOamTypeCount) { 7265 LOG_ERROR(BSL_LS_APPL_SHELL, 7266 (BSL_META_U(unit, 7267 "FP(unit %d) Error: Unknown OamType Value: %s\n"), unit, subcmd)); 7268 return CMD_FAIL; 7269 } 7270 } 7271 7272 /* BCM.0> fp qual 'eid' oamType 'oamType' */ 7273 retval = bcm_field_qualify_OamType (unit, eid, oamType); 7274 FP_CHECK_RETURN(unit, retval, "bcm_field_qualify_OamType"); 7275 7276 return CMD_OK; 7277 } 7278 7279 /* 7280 * Function: 7281 * _fp_qual_OamDrop_name 7282 * Purpose: 7283 * Translate OamDrop enum value to a text string. 7284 * Parameters: 7285 * Enum value from bcm_field_oam_drop_mep_type_e. (ex.bcmFieldOamDropPortDownMepData) 7286 * Returns: 7287 * Text name of indicated OamDrop qualifier enum value. 7288 */ 7289 STATIC char * 7290 _fp_qual_OamDrop_name(bcm_field_oam_drop_mep_type_t type) 7291 { 7292 /* Text names of the enumerated qualifier OamDrop values. */ 7293 /* All these are prefixed with "bcmFieldOamDrop" */ 7294 char *OamDrop_text[bcmFieldOamDropCount] = BCM_FIELD_OAM_DROP_MEP_TYPE_STRINGS; 7295 7296 assert(COUNTOF(OamDrop_text) == bcmFieldOamDropCount); 7297 7298 return (type >= bcmFieldOamDropCount ? "??" : OamDrop_text[type]); 7299 } 7300 7301 /* 7302 * Function: 7303 * fp_lookup_OamDrop 7304 * Purpose: 7305 * Lookup a field OamDrop value from a user string. 7306 * Parmameters: 7307 * type_str - search string 7308 * Returns: 7309 * corresponding OamDrop value 7310 */ 7311 STATIC bcm_field_oam_drop_mep_type_t 7312 fp_lookup_OamDrop(const char *type_str) 7313 { 7314 char tbl_str[FP_STAT_STR_SZ]; 7315 char lng_str[FP_STAT_STR_SZ]; 7316 const char *prefix = "bcmFieldOamDrop"; 7317 bcm_field_oam_drop_mep_type_t type; 7318 7319 assert(type_str != NULL); 7320 assert(sal_strlen(type_str) < FP_STAT_STR_SZ - 1); 7321 7322 for (type = 0; type < bcmFieldOamDropCount; (type)++) { 7323 /* Test for the suffix only */ 7324 sal_memset(tbl_str, 0, sizeof(char) * FP_STAT_STR_SZ); 7325 strncpy(tbl_str, _fp_qual_OamDrop_name(type), FP_STAT_STR_SZ - 1); 7326 if (!sal_strcasecmp(tbl_str, type_str)) { 7327 break; 7328 } 7329 /* Test for whole name of the OamDrop*/ 7330 sal_memset(lng_str, 0, sizeof(char) * FP_STAT_STR_SZ); 7331 strncpy(lng_str, prefix, sal_strlen(prefix)); 7332 strncat(lng_str, tbl_str, FP_STAT_STR_SZ - 1 - sal_strlen(prefix)); 7333 if (!sal_strcasecmp(lng_str, type_str)) { 7334 break; 7335 } 7336 } 7337 7338 /* If not found, result is bcmFieldOamDropCount */ 7339 return type; 7340 } 7341 7342 /* 7343 * Function: 7344 * fp_qual_OamDrop 7345 * Purpose: 7346 * Qualify on OamDrop. 7347 * Parmameters: 7348 * Returns: 7349 */ 7350 STATIC int 7351 fp_qual_OamDrop(int unit, bcm_field_entry_t eid, args_t *args, 7352 int func(int, bcm_field_entry_t, bcm_field_oam_drop_mep_type_t), 7353 char *qual_str) 7354 { 7355 int retval = CMD_OK; 7356 char *subcmd = NULL; 7357 bcm_field_oam_drop_mep_type_t type; 7358 char str[FP_STAT_STR_SZ]; 7359 7360 if ((subcmd = ARG_GET(args)) == NULL) { 7361 return CMD_USAGE; 7362 } 7363 7364 if (isint(subcmd)) { 7365 type = parse_integer(subcmd); 7366 } else { 7367 type = fp_lookup_OamDrop(subcmd); 7368 if (type == bcmFieldOamDropCount) { 7369 LOG_ERROR(BSL_LS_APPL_SHELL, 7370 (BSL_META_U(unit, 7371 "FP(unit %d) Error: Unknown OamDrop value: %s\n"), unit, subcmd)); 7372 return CMD_FAIL; 7373 } 7374 } 7375 7376 /* BCM.0> fp qual 'eid' Qual 'type' */ 7377 retval = func(unit, eid, type); 7378 strcpy(str, "bcm_field_qualify_"); 7379 strncat(str, qual_str, FP_STAT_STR_SZ - 1 - strlen(str)); 7380 FP_CHECK_RETURN(unit, retval, str); 7381 7382 return CMD_OK; 7383 } 7384 7385 /* 7386 * Function: 7387 * fp_qual_OamEgressEtherType 7388 * Purpose: 7389 * Qualify on OamEgressEtherType. 7390 * Parmameters: 7391 * Returns: 7392 */ 7393 STATIC int 7394 fp_qual_OamEgressEtherType(int unit, bcm_field_entry_t eid, args_t *args) 7395 { 7396 int retval = CMD_OK; 7397 char *subcmd = NULL; 7398 uint16 data; 7399 7400 if ((subcmd = ARG_GET(args)) == NULL) { 7401 return CMD_USAGE; 7402 } 7403 7404 if (isint(subcmd)) { 7405 data = parse_integer(subcmd); 7406 } else { 7407 LOG_ERROR(BSL_LS_APPL_SHELL, 7408 (BSL_META_U(unit, 7409 "FP(unit %d) Error: Unknown OamEgressEtherType value: %s\n"), unit, subcmd)); 7410 return CMD_FAIL; 7411 } 7412 7413 /* BCM.0> fp qual 'eid' Qual 'Value' */ 7414 retval = bcm_field_qualify_OamEgressEtherType(unit, eid, data); 7415 FP_CHECK_RETURN(unit, retval, "bcm_field_qualify_OamEgressEtherType"); 7416 7417 return CMD_OK; 7418 } 7419 7420 /* 7421 * Function: 7422 * fp_qual_OamEgressMulticastMacHit 7423 * Purpose: 7424 * Qualify on OamEgressMulticastMacHit. 7425 * Parmameters: 7426 * Returns: 7427 */ 7428 STATIC int 7429 fp_qual_OamEgressMulticastMacHit(int unit, bcm_field_entry_t eid, args_t *args) 7430 { 7431 int retval = CMD_OK; 7432 char *subcmd = NULL; 7433 uint8 data; 7434 7435 if ((subcmd = ARG_GET(args)) == NULL) { 7436 return CMD_USAGE; 7437 } 7438 7439 if (isint(subcmd)) { 7440 data = parse_integer(subcmd); 7441 } else { 7442 LOG_ERROR(BSL_LS_APPL_SHELL, 7443 (BSL_META_U(unit, 7444 "FP(unit %d) Error: Unknown OamEgressMulticastMacHit value: %s\n"), unit, subcmd)); 7445 return CMD_FAIL; 7446 } 7447 7448 /* BCM.0> fp qual 'eid' Qual 'Value' */ 7449 retval = bcm_field_qualify_OamEgressMulticastMacHit(unit, eid, data); 7450 FP_CHECK_RETURN(unit, retval, "bcm_field_qualify_OamEgressMulticastMacHit"); 7451 7452 return CMD_OK; 7453 } 7454 7455 /* 7456 * Function: 7457 * fp_qual_IpInfo 7458 * Purpose: 7459 * Parmameters: 7460 * Returns: 7461 */ 7462 STATIC int 7463 fp_qual_IpInfo(int unit, bcm_field_entry_t eid, args_t *args) 7464 { 7465 int retval = CMD_OK; 7466 uint32 data = 0, mask = 0; 7467 parse_table_t pt; 7468 int hdr_offset_zero= 0, hdr_flags_mf= 0, checksum_ok = 0; 7469 7470 parse_table_init(unit, &pt); 7471 parse_table_add(&pt, "HeaderOffsetZero", PQ_DFL | PQ_BOOL, 0, 7472 (void *)&hdr_offset_zero, 0); 7473 parse_table_add(&pt, "HeaderFlagsMF", PQ_DFL | PQ_BOOL, 0, 7474 (void *)&hdr_flags_mf, 0); 7475 parse_table_add(&pt, "ChecksumOK", PQ_DFL | PQ_BOOL, 0, 7476 (void *)&checksum_ok, 0); 7477 7478 if (BCM_FAILURE(parse_arg_eq(args, &pt))) { 7479 parse_arg_eq_done(&pt); 7480 return CMD_FAIL; 7481 } 7482 7483 /* Set the flags in the data and mask based on inputs. */ 7484 if (pt.pt_entries[0].pq_type & PQ_PARSED) { 7485 if (hdr_offset_zero) { 7486 data |= BCM_FIELD_IP_HDR_OFFSET_ZERO; 7487 } else { 7488 data &= ~BCM_FIELD_IP_HDR_OFFSET_ZERO; 7489 } 7490 mask |= BCM_FIELD_IP_HDR_OFFSET_ZERO; 7491 } 7492 7493 if (pt.pt_entries[1].pq_type & PQ_PARSED) { 7494 if (hdr_flags_mf) { 7495 data |= BCM_FIELD_IP_HDR_FLAGS_MF; 7496 } else { 7497 data &= ~BCM_FIELD_IP_HDR_FLAGS_MF; 7498 } 7499 mask |= BCM_FIELD_IP_HDR_FLAGS_MF; 7500 } 7501 7502 if (pt.pt_entries[2].pq_type & PQ_PARSED) { 7503 if (checksum_ok) { 7504 data |= BCM_FIELD_IP_CHECKSUM_OK; 7505 } else { 7506 data &= ~BCM_FIELD_IP_CHECKSUM_OK; 7507 } 7508 mask |= BCM_FIELD_IP_CHECKSUM_OK; 7509 } 7510 parse_arg_eq_done(&pt); 7511 7512 /* BCM.0> fp qual <eid> IpInfo [HOZ=<0/1> HFMF=<0/1> COK=<0/1>] */ 7513 LOG_VERBOSE(BSL_LS_APPL_SHELL, 7514 (BSL_META_U(unit, 7515 "FP(unit %d) verb:bcm_field_qualify_IpInfo(entry=%d, data=%#x, mask=%#x)\n"), 7516 unit, eid, data, mask)); 7517 retval = bcm_field_qualify_IpInfo(unit, eid, data, mask); 7518 FP_CHECK_RETURN(unit, retval, "bcm_field_qualify_IpInfo"); 7519 7520 return CMD_OK; 7521 } 7522 7523 STATIC int 7524 fp_qual_IpInfo_help(const char *prefix, int width_col1) { 7525 if (width_col1 < strlen("IpInfo")) { 7526 width_col1 = strlen("IpInfo") + 1; 7527 } 7528 7529 cli_out("%s%-*s%s\n", prefix, width_col1, "IpInfo", 7530 "HeaderOffsetZero=<0/1> HeaderFlagsMF=<0/1> ChecksumOK=<0/1>"); 7531 return CMD_OK; 7532 } 7533 7534 /* 7535 * Function: 7536 * Purpose: 7537 * Parmameters: 7538 * Returns: 7539 */ 7540 STATIC int 7541 fp_qual_PacketRes(int unit, bcm_field_entry_t eid, args_t *args) 7542 { 7543 int retval = CMD_OK; 7544 uint32 data = 0, mask = 0x3f; 7545 parse_table_t pt; 7546 7547 parse_table_init(unit, &pt); 7548 parse_table_add(&pt, "Res", PQ_DFL | PQ_MULTI, 0, 7549 (void *)&data, packet_res_text); 7550 7551 if (BCM_FAILURE(parse_arg_eq(args, &pt))) { 7552 parse_arg_eq_done(&pt); 7553 return CMD_FAIL; 7554 } 7555 parse_arg_eq_done(&pt); 7556 7557 /* BCM.0> fp qual <eid> PacketRes [Res=<>] */ 7558 LOG_VERBOSE(BSL_LS_APPL_SHELL, 7559 (BSL_META_U(unit, 7560 "FP(unit %d) verb:bcm_field_qualify_PacketRes(entry=%d, data=%#x, mask=%#x)\n"), 7561 unit, eid, data, mask)); 7562 retval = bcm_field_qualify_PacketRes(unit, eid, data, mask); 7563 FP_CHECK_RETURN(unit, retval, "bcm_field_qualify_PacketRes"); 7564 7565 return CMD_OK; 7566 } 7567 7568 7569 STATIC int 7570 fp_qual_PacketRes_help(const char *prefix, int width_col1) { 7571 int offset; 7572 if (width_col1 < strlen("PacketRes")) { 7573 width_col1 = strlen("PacketRes") + 1; 7574 } 7575 7576 offset = sal_strlen(prefix); 7577 if (sal_strlen("PacketRes") >= width_col1) { 7578 offset += sal_strlen("PacketRes"); 7579 } else { 7580 offset += width_col1; 7581 } 7582 offset += sal_strlen("sRes="); 7583 cli_out("%s%-*sRes=", prefix, 7584 width_col1, "PacketRes"); 7585 7586 fp_print_options(packet_res_text, offset); 7587 cli_out("\n"); 7588 7589 return CMD_OK; 7590 } 7591 7592 /* 7593 * Function: 7594 * Purpose: 7595 * Parmameters: 7596 * Returns: 7597 */ 7598 STATIC int 7599 fp_qual_Color(int unit, bcm_field_entry_t eid, args_t *args) 7600 { 7601 int retval = CMD_OK; 7602 int data = -1; 7603 parse_table_t pt; 7604 7605 parse_table_init(unit, &pt); 7606 parse_table_add(&pt, "color", PQ_DFL | PQ_MULTI, 0, 7607 (void *)&data, color_text); 7608 7609 if (BCM_FAILURE(parse_arg_eq(args, &pt))) { 7610 parse_arg_eq_done(&pt); 7611 return CMD_FAIL; 7612 } 7613 parse_arg_eq_done(&pt); 7614 7615 /* BCM.0> fp qual <eid> color [color=<>] */ 7616 LOG_VERBOSE(BSL_LS_APPL_SHELL, 7617 (BSL_META_U(unit, 7618 "FP(unit %d) verb: bcm_field_qualify_(entry=%d, data=%#x)\n"), 7619 unit, eid, data)); 7620 switch (data) { 7621 case 0: 7622 data = BCM_FIELD_COLOR_GREEN; 7623 break; 7624 case 1: 7625 data = BCM_FIELD_COLOR_YELLOW; 7626 break; 7627 case 2: 7628 data = BCM_FIELD_COLOR_RED; 7629 break; 7630 default: 7631 return CMD_FAIL; 7632 7633 } 7634 retval = bcm_field_qualify_Color(unit, eid, data); 7635 FP_CHECK_RETURN(unit, retval, "bcm_field_qualify_Color"); 7636 7637 return CMD_OK; 7638 } 7639 7640 STATIC int 7641 fp_qual_IpProtocolCommon_help(const char *prefix, int width_col1) { 7642 int offset; 7643 if (width_col1 < strlen("IpProtocolCommon")) { 7644 width_col1 = strlen("IpProtocolCommon") + 1; 7645 } 7646 7647 offset = sal_strlen(prefix); 7648 if (sal_strlen("IpProtocolCommon") >= width_col1) { 7649 offset += sal_strlen("IpProtocolCommon"); 7650 } else { 7651 offset += width_col1; 7652 } 7653 offset += sal_strlen("sIpProtocolCommon="); 7654 cli_out("%s%-*sIpProtocolCommon=", 7655 prefix, width_col1, "IpProtocolCommon"); 7656 fp_print_options(ip_protocol_common, offset); 7657 cli_out("\n"); 7658 7659 return CMD_OK; 7660 } 7661 7662 STATIC int 7663 fp_qual_Color_help(const char *prefix, int width_col1) { 7664 int offset; 7665 if (width_col1 < strlen("Color")) { 7666 width_col1 = strlen("Color") + 1; 7667 } 7668 7669 offset = sal_strlen(prefix); 7670 if (sal_strlen("color") >= width_col1) { 7671 offset += sal_strlen("color"); 7672 } else { 7673 offset += width_col1; 7674 } 7675 offset += sal_strlen("scolor="); 7676 cli_out("%s%-*scolor=", prefix, 7677 width_col1, "Color"); 7678 fp_print_options(color_text, offset); 7679 cli_out("\n"); 7680 7681 return CMD_OK; 7682 } 7683 7684 STATIC int 7685 fp_qual_ForwardingType_help(const char *prefix, int width_col1) { 7686 int offset; 7687 if (width_col1 < strlen("ForwardingType")) { 7688 width_col1 = strlen("ForwardingType") + 1; 7689 } 7690 7691 offset = sal_strlen(prefix); 7692 if (sal_strlen("ForwardingType") >= width_col1) { 7693 offset += sal_strlen("ForwardingType"); 7694 } else { 7695 offset += width_col1; 7696 } 7697 offset += sal_strlen("sfwd_type="); 7698 7699 cli_out("%s%-*sfwd_type=", prefix, 7700 width_col1, "ForwardingType"); 7701 fp_print_options(forwarding_type_text, offset); 7702 cli_out("\n"); 7703 7704 return CMD_OK; 7705 } 7706 7707 /* 7708 * Function: 7709 * fp_qual_ForwardingType 7710 * Purpose: 7711 * Qualify ForwardingType value of an entry. 7712 * Parmameters: 7713 * unit - (IN) BCM device number. 7714 * eid - (IN) Entry identifier. 7715 * args - (IN) Forwarding type value. 7716 * Returns: 7717 * CMD_XX 7718 */ 7719 STATIC int 7720 fp_qual_ForwardingType(int unit, bcm_field_entry_t eid, args_t *args) 7721 { 7722 int retval = CMD_OK; 7723 int data = bcmFieldForwardingTypeCount; 7724 parse_table_t pt; 7725 7726 parse_table_init(unit, &pt); 7727 parse_table_add(&pt, "fwd_type", PQ_DFL | PQ_MULTI, 0, 7728 (void *)&data, forwarding_type_text); 7729 7730 if (BCM_FAILURE(parse_arg_eq(args, &pt))) { 7731 parse_arg_eq_done(&pt); 7732 return CMD_FAIL; 7733 } 7734 parse_arg_eq_done(&pt); 7735 7736 if (data == bcmFieldForwardingTypeCount) { 7737 cli_out("Invalid fwd_type value\n"); 7738 fp_print_options(forwarding_type_text, sal_strlen("\tfwd_type=")); 7739 cli_out("\n"); 7740 } 7741 7742 /* BCM.0> fp qual <eid> ForwardingType [fwd_type=<>] */ 7743 LOG_VERBOSE(BSL_LS_APPL_SHELL, 7744 (BSL_META_U(unit, 7745 "FP(unit %d) verb:bcm_field_qualify_ForwardingType(entry=%d, data=%#x)\n"), 7746 unit, eid, data)); 7747 retval = bcm_field_qualify_ForwardingType(unit, eid, data); 7748 FP_CHECK_RETURN(unit, retval, "bcm_field_qualify_ForwardingType"); 7749 7750 return CMD_OK; 7751 } 7752 7753 /* 7754 * Function: 7755 * Purpose: 7756 * Parmameters: 7757 * Returns: 7758 */ 7759 STATIC int 7760 fp_qual_IpFrag(int unit, bcm_field_entry_t eid, args_t *args) 7761 { 7762 int retval = CMD_OK; 7763 int data = -1; 7764 parse_table_t pt; 7765 7766 parse_table_init(unit, &pt); 7767 parse_table_add(&pt, "frag", PQ_DFL | PQ_MULTI, 0, 7768 (void *)&data, ipfrag_text); 7769 7770 if (BCM_FAILURE(parse_arg_eq(args, &pt))) { 7771 parse_arg_eq_done(&pt); 7772 return CMD_FAIL; 7773 } 7774 parse_arg_eq_done(&pt); 7775 7776 /* BCM.0> fp qual <eid> IpFrag [Frag=<>] */ 7777 LOG_VERBOSE(BSL_LS_APPL_SHELL, 7778 (BSL_META_U(unit, 7779 "FP(unit %d) verb:bcm_field_qualify_IpFrag(entry=%d, data=%#x)\n"), 7780 unit, eid, data)); 7781 retval = bcm_field_qualify_IpFrag(unit, eid, data); 7782 FP_CHECK_RETURN(unit, retval, "bcm_field_qualify_IpFrag"); 7783 7784 return CMD_OK; 7785 } 7786 7787 7788 STATIC int 7789 fp_qual_IpFrag_help(const char *prefix, int width_col1) { 7790 int offset; 7791 if (width_col1 < strlen("IpFrag")) { 7792 width_col1 = strlen("IpFrag") + 1; 7793 } 7794 7795 offset = sal_strlen(prefix); 7796 if (sal_strlen("IpFrag") >= width_col1) { 7797 offset += sal_strlen("IpFrag"); 7798 } else { 7799 offset += width_col1; 7800 } 7801 offset += sal_strlen("sfrag="); 7802 cli_out("%s%-*sfrag=", prefix, 7803 width_col1, "IpFrag"); 7804 fp_print_options(ipfrag_text, offset); 7805 cli_out("\n"); 7806 7807 return CMD_OK; 7808 } 7809 7810 /* 7811 * Function: 7812 * Purpose: 7813 * Parmameters: 7814 * Returns: 7815 */ 7816 STATIC int 7817 fp_qual_LoopbackType(int unit, bcm_field_entry_t eid, args_t *args) 7818 { 7819 int retval = CMD_OK; 7820 int data = -1; 7821 parse_table_t pt; 7822 7823 parse_table_init(unit, &pt); 7824 parse_table_add(&pt, "lb_type", PQ_DFL | PQ_MULTI, 0, 7825 (void *)&data, loopbacktype_text); 7826 7827 if (BCM_FAILURE(parse_arg_eq(args, &pt))) { 7828 parse_arg_eq_done(&pt); 7829 return CMD_FAIL; 7830 } 7831 parse_arg_eq_done(&pt); 7832 7833 /* BCM.0> fp qual <eid> LoopbackType [lb_type =<>] */ 7834 LOG_VERBOSE(BSL_LS_APPL_SHELL, 7835 (BSL_META_U(unit, 7836 "FP(unit %d) verb: bcm_field_qualify_LoopbackType(entry=%d, data=%#x)\n"), 7837 unit, eid, data)); 7838 retval = bcm_field_qualify_LoopbackType(unit, eid, data); 7839 FP_CHECK_RETURN(unit, retval, "bcm_field_qualify_LoopbackType"); 7840 7841 return CMD_OK; 7842 } 7843 7844 7845 STATIC int 7846 fp_qual_LoopbackType_help(const char *prefix, int width_col1) { 7847 int offset; 7848 if (width_col1 < strlen("LoopbackType")) { 7849 width_col1 = strlen("LoopbackType") + 1; 7850 } 7851 7852 offset = sal_strlen(prefix); 7853 if (sal_strlen("LoopbackType") >= width_col1) { 7854 offset += sal_strlen("LoopbackType"); 7855 } else { 7856 offset += width_col1; 7857 } 7858 offset += sal_strlen("slb_type="); 7859 cli_out("%s%-*slb_type=", prefix, 7860 width_col1, "LoopbackType"); 7861 fp_print_options(loopbacktype_text, offset); 7862 cli_out("\n"); 7863 7864 return CMD_OK; 7865 } 7866 7867 /* 7868 * Function: 7869 * Purpose: 7870 * Parmameters: 7871 * Returns: 7872 */ 7873 STATIC int 7874 fp_qual_TunnelType(int unit, bcm_field_entry_t eid, args_t *args) 7875 { 7876 int retval = CMD_OK; 7877 int data = -1; 7878 parse_table_t pt; 7879 7880 parse_table_init(unit, &pt); 7881 parse_table_add(&pt, "tnl_type", PQ_DFL | PQ_MULTI, 0, 7882 (void *)&data, tunneltype_text); 7883 7884 if (BCM_FAILURE(parse_arg_eq(args, &pt))) { 7885 parse_arg_eq_done(&pt); 7886 return CMD_FAIL; 7887 } 7888 7889 parse_arg_eq_done(&pt); 7890 /* BCM.0> fp qual <eid> TunnelType [lb_type =<>] */ 7891 LOG_VERBOSE(BSL_LS_APPL_SHELL, 7892 (BSL_META_U(unit, 7893 "FP(unit %d) verb: bcm_field_qualify_TunnelType(entry=%d, data=%#x)\n"), 7894 unit, eid, data)); 7895 retval = bcm_field_qualify_TunnelType(unit, eid, data); 7896 FP_CHECK_RETURN(unit, retval, "bcm_field_qualify_TunnelType"); 7897 7898 return CMD_OK; 7899 } 7900 7901 7902 STATIC int 7903 fp_qual_TunnelType_help(const char *prefix, int width_col1) { 7904 int offset; 7905 if (width_col1 < strlen("TunnelType")) { 7906 width_col1 = strlen("TunnelType") + 1; 7907 } 7908 7909 offset = sal_strlen(prefix); 7910 if (sal_strlen("TunnelType") >= width_col1) { 7911 offset += sal_strlen("TunnelType"); 7912 } else { 7913 offset += width_col1; 7914 } 7915 offset += sal_strlen("stnl_type="); 7916 cli_out("%s%-*stnl_type=", prefix, 7917 width_col1, "TunnelType"); 7918 fp_print_options(tunneltype_text, offset); 7919 cli_out("\n"); 7920 7921 return CMD_OK; 7922 } 7923 7924 /* 7925 * Function: 7926 * fp_qual_InterfaceClass 7927 * Purpose: 7928 * Qualify on Interface class 7929 * Parmameters: 7930 * Returns: 7931 */ 7932 STATIC int 7933 fp_qual_InterfaceClass(int unit, bcm_field_entry_t eid, args_t *args, 7934 int func(int, bcm_field_entry_t, uint32, uint32), 7935 char *qual_str) 7936 { 7937 int retval = CMD_OK; 7938 char *subcmd = NULL; 7939 uint32 data, mask; 7940 char str[FP_STAT_STR_SZ]; 7941 7942 FP_GET_NUMB(data, subcmd, args); 7943 FP_GET_NUMB(mask, subcmd, args); 7944 7945 /* BCM.0> fp qual 'eid' Qual 'data' 'mask' */ 7946 retval = func(unit, eid, data, mask); 7947 strcpy(str, "bcm_field_qualify_"); 7948 strncat(str, qual_str, FP_STAT_STR_SZ - 1 - strlen(str)); 7949 FP_CHECK_RETURN(unit, retval, str); 7950 7951 return CMD_OK; 7952 } 7953 7954 /* 7955 * Function: 7956 * fp_qual_Gport 7957 * Purpose: 7958 * Qualify on Interface class 7959 * Parmameters: 7960 * Returns: 7961 */ 7962 STATIC int 7963 fp_qual_Gport(int unit, bcm_field_entry_t eid, args_t *args, 7964 int func(int, bcm_field_entry_t, int), 7965 char *qual_str) 7966 { 7967 int retval = CMD_OK; 7968 char *subcmd = NULL; 7969 uint32 data; 7970 char str[FP_STAT_STR_SZ]; 7971 7972 FP_GET_NUMB(data, subcmd, args); 7973 7974 /* BCM.0> fp qual 'eid' Qual 'data' */ 7975 retval = func(unit, eid, data); 7976 strcpy(str, "bcm_field_qualify_"); 7977 strncat(str, qual_str, FP_STAT_STR_SZ - 1 - strlen(str)); 7978 FP_CHECK_RETURN(unit, retval, str); 7979 7980 return CMD_OK; 7981 } 7982 7983 /* 7984 * Function: 7985 * fp_qual_Gports 7986 * Purpose: 7987 * Qualify on Gports 7988 * Parmameters: 7989 * Returns: 7990 */ 7991 STATIC int 7992 fp_qual_Gports(int unit, bcm_field_entry_t eid, args_t *args, 7993 int func(int, bcm_field_entry_t, int, int), 7994 char *qual_str) 7995 { 7996 int retval = CMD_OK; 7997 int length; 7998 char *subcmd = NULL; 7999 uint32 data; 8000 uint32 mask; 8001 char str[FP_STAT_STR_SZ]; 8002 char src_str[] = "bcm_field_qualify_"; 8003 8004 FP_GET_NUMB(data, subcmd, args); 8005 FP_GET_NUMB(mask, subcmd, args); 8006 8007 length = strlen(src_str); 8008 /* BCM.0> fp qual 'eid' Qual 'data' 'mask' */ 8009 retval = func(unit, eid, data,mask); 8010 strncpy(str,src_str,(length+1)); 8011 strncat(str, qual_str, FP_STAT_STR_SZ - 1 - strlen(str)); 8012 FP_CHECK_RETURN(unit, retval, str); 8013 8014 return CMD_OK; 8015 } 8016 8017 8018 /* 8019 * Function: 8020 * fp_qual_IpType 8021 * Purpose: 8022 * Qualify on IpType. 8023 * Parmameters: 8024 * Returns: 8025 */ 8026 STATIC int 8027 fp_qual_IpType(int unit, bcm_field_entry_t eid, args_t *args) 8028 { 8029 int retval = CMD_OK; 8030 char *subcmd = NULL; 8031 bcm_field_IpType_t type; 8032 8033 if ((subcmd = ARG_GET(args)) == NULL) { 8034 return CMD_USAGE; 8035 } 8036 8037 if (isint(subcmd)) { 8038 type = parse_integer(subcmd); 8039 } else { 8040 type = fp_lookup_IpType(subcmd); 8041 if (type == bcmFieldIpTypeCount) { 8042 LOG_ERROR(BSL_LS_APPL_SHELL, 8043 (BSL_META_U(unit, 8044 "FP(unit %d) Error: Unknown IpType value: %s\n"), unit, subcmd)); 8045 return CMD_FAIL; 8046 } 8047 } 8048 8049 /* BCM.0> fp qual 'eid' IpType 'type' */ 8050 retval = bcm_field_qualify_IpType(unit, eid, type); 8051 FP_CHECK_RETURN(unit, retval, "bcm_field_qualify_IpType"); 8052 8053 return CMD_OK; 8054 } 8055 8056 /* 8057 * Function: 8058 * fp_qual_InnerIpType 8059 * Purpose: 8060 * Qualify on InnerIpType. 8061 * Parmameters: 8062 * Returns: 8063 */ 8064 STATIC int 8065 fp_qual_InnerIpType(int unit, bcm_field_entry_t eid, args_t *args) 8066 { 8067 int retval = CMD_OK; 8068 char *subcmd = NULL; 8069 bcm_field_IpType_t type; 8070 8071 if ((subcmd = ARG_GET(args)) == NULL) { 8072 return CMD_USAGE; 8073 } 8074 8075 if (isint(subcmd)) { 8076 type = parse_integer(subcmd); 8077 } else { 8078 type = fp_lookup_IpType(subcmd); 8079 if (type == bcmFieldIpTypeCount) { 8080 LOG_ERROR(BSL_LS_APPL_SHELL, 8081 (BSL_META_U(unit, 8082 "FP(unit %d) Error: Unknown InnerIpType value: %s\n"), unit, subcmd)); 8083 return CMD_FAIL; 8084 } 8085 } 8086 8087 /* BCM.0> fp qual 'eid' InnerIpType 'type' */ 8088 retval = bcm_field_qualify_InnerIpType(unit, eid, type); 8089 FP_CHECK_RETURN(unit, retval, "bcm_field_qualify_InnerIpType"); 8090 8091 return CMD_OK; 8092 } 8093 8094 /* 8095 * Function: 8096 * fp_qual_L2Format 8097 * Purpose: 8098 * Qualify on L2Format. 8099 * Parmameters: 8100 * Returns: 8101 */ 8102 STATIC int 8103 fp_qual_L2Format(int unit, bcm_field_entry_t eid, args_t *args) 8104 { 8105 int retval = CMD_OK; 8106 char *subcmd = NULL; 8107 bcm_field_L2Format_t type; 8108 8109 if ((subcmd = ARG_GET(args)) == NULL) { 8110 return CMD_USAGE; 8111 } 8112 8113 if (isint(subcmd)) { 8114 type = parse_integer(subcmd); 8115 } else { 8116 type = fp_lookup_L2Format(subcmd); 8117 if (type == bcmFieldL2FormatCount) { 8118 LOG_ERROR(BSL_LS_APPL_SHELL, 8119 (BSL_META_U(unit, 8120 "FP(unit %d) Error: Unknown L2Format value: %s\n"), 8121 unit, subcmd)); 8122 return CMD_FAIL; 8123 } 8124 } 8125 8126 /* BCM.0> fp qual 'eid' L2Format 'type' */ 8127 retval = bcm_field_qualify_L2Format(unit, eid, type); 8128 FP_CHECK_RETURN(unit, retval, "bcm_field_qualify_L2Format"); 8129 8130 return CMD_OK; 8131 } 8132 8133 /* 8134 * Function: 8135 * fp_qual_IpProtocolCommon 8136 * Purpose: 8137 * Qualify on IpProtocolCommon. 8138 * Parmameters: 8139 * Returns: 8140 */ 8141 STATIC int 8142 fp_qual_IpProtocolCommon(int unit, bcm_field_entry_t eid, args_t *args) 8143 { 8144 int retval = CMD_OK; 8145 char *subcmd = NULL; 8146 bcm_field_IpProtocolCommon_t protocol; 8147 8148 if ((subcmd = ARG_GET(args)) == NULL) { 8149 return CMD_USAGE; 8150 } 8151 8152 if (isint(subcmd)) { 8153 protocol = parse_integer(subcmd); 8154 } else { 8155 protocol = fp_lookup_IpProtocolCommon(subcmd); 8156 if (protocol == bcmFieldIpProtocolCommonCount) { 8157 cli_out("Unknown IpProtocolCommon value: %s\n", subcmd) ; 8158 return CMD_FAIL; 8159 } 8160 } 8161 8162 /* BCM.0> fp qual 'eid' IpProtocolcommon 'type' */ 8163 retval = bcm_field_qualify_IpProtocolCommon(unit, eid, protocol); 8164 FP_CHECK_RETURN(unit, retval, "bcm_field_qualify_IpProtocolCommon"); 8165 8166 return CMD_OK; 8167 } 8168 8169 /* 8170 * Function: 8171 * fp_policer_create 8172 * Purpose: 8173 * Add fp meter entity. 8174 * Parmameters: 8175 * unit - (IN) Bcm device number. 8176 * args - (IN) Command arguments. 8177 * Returns: 8178 * Command result. 8179 */ 8180 STATIC int 8181 fp_policer_create(int unit, args_t *args) 8182 { 8183 parse_table_t pt; 8184 bcm_policer_config_t pol_cfg; 8185 bcm_policer_t polid = -1; 8186 cmd_result_t retCode; 8187 bcm_policer_mode_t mode; 8188 int color_blind; 8189 int color_merge_or = 0; 8190 int rv; 8191 int packet_based = 0; 8192 int pool_id_given = 0; 8193 8194 mode = bcmPolicerModeCount; 8195 color_blind = 0; 8196 bcm_policer_config_t_init(&pol_cfg); 8197 8198 /* Parse command option arguments */ 8199 parse_table_init(unit, &pt); 8200 parse_table_add(&pt, "PolId", PQ_DFL|PQ_INT, 0, &polid, NULL); 8201 parse_table_add(&pt, "ColorBlind", PQ_DFL|PQ_INT, 0, &color_blind, NULL); 8202 parse_table_add(&pt, "ColorMergeOr", PQ_DFL|PQ_INT, 0, 8203 &color_merge_or, NULL); 8204 parse_table_add(&pt, "PoolIdGiven", PQ_DFL|PQ_INT, 0, &pool_id_given, NULL); 8205 parse_table_add(&pt, "Mode", PQ_DFL | PQ_MULTI, 0, 8206 (void *)&mode, policermode_text); 8207 parse_table_add(&pt, "cbs", PQ_DFL|PQ_INT, 0, 8208 &pol_cfg.ckbits_burst, NULL); 8209 parse_table_add(&pt, "cir", PQ_DFL|PQ_INT, 0, 8210 &pol_cfg.ckbits_sec, NULL); 8211 parse_table_add(&pt, "ebs", PQ_DFL|PQ_INT, 0, 8212 &pol_cfg.pkbits_burst, NULL); 8213 parse_table_add(&pt, "eir", PQ_DFL|PQ_INT, 0, &pol_cfg.pkbits_sec, NULL); 8214 parse_table_add(&pt, "PoolId", PQ_DFL|PQ_INT, 0, &pol_cfg.pool_id, NULL); 8215 parse_table_add(&pt, "PacketBased", PQ_DFL|PQ_INT, 0, &packet_based, NULL); 8216 if (!parseEndOk(args, &pt, &retCode)) { 8217 return retCode; 8218 } 8219 8220 if (mode == bcmPolicerModeCount) { 8221 cli_out("Invalid policer mode\n"); 8222 fp_print_options(policermode_text, sal_strlen("\tMode=")); 8223 cli_out("\n"); 8224 } else { 8225 pol_cfg.mode = mode; 8226 } 8227 8228 if (polid >= 0) { 8229 pol_cfg.flags |= (BCM_POLICER_WITH_ID | BCM_POLICER_REPLACE); 8230 } 8231 8232 if (color_blind) { 8233 pol_cfg.flags |= (BCM_POLICER_COLOR_BLIND); 8234 } 8235 8236 if (color_merge_or) { 8237 pol_cfg.flags |= (BCM_POLICER_COLOR_MERGE_OR); 8238 } 8239 8240 if (packet_based) { 8241 pol_cfg.flags |= (BCM_POLICER_MODE_PACKETS); 8242 } 8243 if (pool_id_given) { 8244 pol_cfg.flags |= (BCM_POLICER_WITH_POOL_ID); 8245 } 8246 8247 if ((rv = bcm_policer_create(unit, &pol_cfg, &polid)) != BCM_E_NONE) { 8248 cli_out("Policer add failed. (%s) \n", bcm_errmsg(rv)); 8249 return CMD_FAIL; 8250 } 8251 8252 if (!(pol_cfg.flags & BCM_POLICER_WITH_ID)) { 8253 cli_out("Policer created with id: %d \n", polid); 8254 } 8255 8256 return CMD_OK; 8257 } 8258 8259 /* 8260 * Function: 8261 * fp_policer_destroy 8262 * Purpose: 8263 * Remove fp meter entity. 8264 * Parmameters: 8265 * unit - (IN) Bcm device number. 8266 * args - (IN) Command arguments. 8267 * Returns: 8268 * Command result. 8269 */ 8270 STATIC int 8271 fp_policer_destroy(int unit, args_t *args) 8272 { 8273 char *param; 8274 int rv; 8275 parse_table_t pt; 8276 cmd_result_t retCode; 8277 bcm_policer_t polid = -1; 8278 8279 param = ARG_CUR(args); 8280 if (!param) { 8281 return CMD_USAGE; 8282 } 8283 8284 if (0 == sal_strncasecmp(param, "all", 3)) { 8285 param = ARG_GET(args); 8286 if ((rv = bcm_policer_destroy_all(unit)) != BCM_E_NONE) { 8287 cli_out("ERROR: bcm_policer_destroy_all(unit=%d) failed.(%s) \n", 8288 unit, bcm_errmsg(rv)); 8289 return CMD_FAIL; 8290 } 8291 } else { 8292 /* Parse command option arguments */ 8293 parse_table_init(unit, &pt); 8294 parse_table_add(&pt, "PolId", PQ_DFL|PQ_INT, 0, &polid, NULL); 8295 if (!parseEndOk(args, &pt, &retCode)) { 8296 return retCode; 8297 } 8298 if (polid < 0) { 8299 cli_out("Invalid policer id specified\n"); 8300 return CMD_FAIL; 8301 } 8302 if ((rv = bcm_policer_destroy(unit, polid)) != BCM_E_NONE) { 8303 cli_out("ERROR: bcm_policer_destroy(unit=%d, id=%d) failed (%s) \n", 8304 unit, polid, bcm_errmsg(rv)); 8305 return CMD_FAIL; 8306 } 8307 } 8308 8309 return CMD_OK; 8310 } 8311 8312 /* 8313 * Function: 8314 * fp_policer_set 8315 * Purpose: 8316 * Modify fp meter entity. 8317 * Parmameters: 8318 * unit - (IN) Bcm device number. 8319 * args - (IN) Command arguments. 8320 * Returns: 8321 * Command result. 8322 */ 8323 STATIC int 8324 fp_policer_set(int unit, args_t *args) 8325 { 8326 parse_table_t pt; 8327 bcm_policer_config_t pol_cfg; 8328 bcm_policer_t polid = -1; 8329 cmd_result_t retCode; 8330 bcm_policer_mode_t mode; 8331 int color_blind; 8332 int color_merge_or = 0; 8333 int rv; 8334 int packet_based = 0; 8335 8336 mode = bcmPolicerModeCount; 8337 color_blind = 0; 8338 bcm_policer_config_t_init(&pol_cfg); 8339 8340 /* Parse command option arguments */ 8341 parse_table_init(unit, &pt); 8342 parse_table_add(&pt, "PolId", PQ_DFL|PQ_INT, 0, &polid, NULL); 8343 parse_table_add(&pt, "ColorBlind", PQ_DFL|PQ_INT, 0, &color_blind, NULL); 8344 parse_table_add(&pt, "ColorMergeOr", PQ_DFL|PQ_INT, 0, 8345 &color_merge_or, NULL); 8346 parse_table_add(&pt, "Mode", PQ_DFL | PQ_MULTI, 0, 8347 (void *)&mode, policermode_text); 8348 parse_table_add(&pt, "cbs", PQ_DFL|PQ_INT, 0, 8349 &pol_cfg.ckbits_burst, NULL); 8350 parse_table_add(&pt, "cir", PQ_DFL|PQ_INT, 0, 8351 &pol_cfg.ckbits_sec, NULL); 8352 parse_table_add(&pt, "ebs", PQ_DFL|PQ_INT, 0, 8353 &pol_cfg.pkbits_burst, NULL); 8354 parse_table_add(&pt, "eir", PQ_DFL|PQ_INT, 0, &pol_cfg.pkbits_sec, NULL); 8355 parse_table_add(&pt, "PacketBased", PQ_DFL|PQ_INT, 0, &packet_based, NULL); 8356 if (!parseEndOk(args, &pt, &retCode)) { 8357 return retCode; 8358 } 8359 8360 if (mode == bcmPolicerModeCount) { 8361 cli_out("Invalid policer mode\n"); 8362 fp_print_options(policermode_text, sal_strlen("\tMode=")); 8363 cli_out("\n"); 8364 } else { 8365 pol_cfg.mode = mode; 8366 } 8367 8368 if (polid < 0) { 8369 cli_out("Invalid policer id specified\n"); 8370 return CMD_FAIL; 8371 } 8372 8373 if (polid >= 0) { 8374 pol_cfg.flags |= (BCM_POLICER_WITH_ID | BCM_POLICER_REPLACE); 8375 } 8376 8377 if (color_blind) { 8378 pol_cfg.flags |= (BCM_POLICER_COLOR_BLIND); 8379 } 8380 8381 if (color_merge_or) { 8382 pol_cfg.flags |= (BCM_POLICER_COLOR_MERGE_OR); 8383 } 8384 8385 if (packet_based) { 8386 pol_cfg.flags |= (BCM_POLICER_MODE_PACKETS); 8387 } 8388 8389 if ((rv = bcm_policer_set(unit, polid, &pol_cfg)) != BCM_E_NONE) { 8390 cli_out("Policer set failed. (%s) \n", bcm_errmsg(rv)); 8391 return CMD_FAIL; 8392 } 8393 8394 return CMD_OK; 8395 } 8396 8397 /* 8398 * Function: 8399 * fp_policer_attach 8400 * Purpose: 8401 * Attach fp meter to a field entry. 8402 * Parmameters: 8403 * unit - (IN) Bcm device number. 8404 * args - (IN) Command arguments. 8405 * Returns: 8406 * Command result. 8407 */ 8408 STATIC int 8409 fp_policer_attach(int unit, args_t *args) 8410 { 8411 char *param; 8412 int rv; 8413 parse_table_t pt; 8414 cmd_result_t retCode; 8415 bcm_policer_t polid = -1; 8416 bcm_field_entry_t eid = -1; 8417 int level = 0; 8418 8419 param = ARG_CUR(args); 8420 if (!param) { 8421 return CMD_USAGE; 8422 } 8423 8424 /* Parse command option arguments */ 8425 parse_table_init(unit, &pt); 8426 parse_table_add(&pt, "PolId", PQ_DFL|PQ_INT, 0, &polid, NULL); 8427 parse_table_add(&pt, "entry", PQ_DFL|PQ_INT, 0, &eid, NULL); 8428 parse_table_add(&pt, "level", PQ_DFL|PQ_INT, 0, &level, NULL); 8429 if (!parseEndOk(args, &pt, &retCode)) { 8430 return retCode; 8431 } 8432 if (polid < 0) { 8433 cli_out("Invalid policer id specified\n"); 8434 return CMD_FAIL; 8435 } 8436 if (eid < 0) { 8437 cli_out("Invalid entry id specified\n"); 8438 return CMD_FAIL; 8439 } 8440 if ((level >= _FP_POLICER_LEVEL_COUNT) || (level < 0)) { 8441 cli_out("Invalid level specified\n"); 8442 return CMD_FAIL; 8443 } 8444 8445 if ((rv = bcm_field_entry_policer_attach(unit, eid, level, polid)) != BCM_E_NONE) { 8446 cli_out("ERROR: bcm_policer_attach(unit=%d, eid=%d, level=%d,\ 8447 polid=%d) failed (%s) \n", unit, eid, level, polid, bcm_errmsg(rv)); 8448 return CMD_FAIL; 8449 } 8450 return CMD_OK; 8451 } 8452 8453 /* 8454 * Function: 8455 * fp_policer_detach 8456 * Purpose: 8457 * Detach fp meter from a field entry. 8458 * Parmameters: 8459 * unit - (IN) Bcm device number. 8460 * args - (IN) Command arguments. 8461 * Returns: 8462 * Command result. 8463 */ 8464 STATIC int 8465 fp_policer_detach(int unit, args_t *args) 8466 { 8467 char *param; 8468 int rv; 8469 parse_table_t pt; 8470 cmd_result_t retCode; 8471 bcm_field_entry_t eid = -1; 8472 int level = 0; 8473 8474 param = ARG_CUR(args); 8475 if (!param) { 8476 return CMD_USAGE; 8477 } 8478 8479 /* Parse command option arguments */ 8480 parse_table_init(unit, &pt); 8481 parse_table_add(&pt, "entry", PQ_DFL|PQ_INT, 0, &eid, NULL); 8482 parse_table_add(&pt, "level", PQ_DFL|PQ_INT, 0, &level, NULL); 8483 if (!parseEndOk(args, &pt, &retCode)) { 8484 return retCode; 8485 } 8486 if (eid < 0) { 8487 cli_out("Invalid entry id specified\n"); 8488 return CMD_FAIL; 8489 } 8490 if ((level >= _FP_POLICER_LEVEL_COUNT) || (level < 0)) { 8491 cli_out("Invalid level specified\n"); 8492 return CMD_FAIL; 8493 } 8494 8495 if ((rv = bcm_field_entry_policer_detach(unit, eid, level)) != BCM_E_NONE) { 8496 cli_out("ERROR: bcm_policer_attach(unit=%d, eid=%d, level=%d)\ 8497 failed (%s) \n", unit, eid, level, bcm_errmsg(rv)); 8498 return CMD_FAIL; 8499 } 8500 return CMD_OK; 8501 } 8502 8503 /* 8504 * Function: 8505 * Purpose: 8506 * Parmameters: 8507 * Returns: 8508 */ 8509 STATIC int 8510 fp_policer(int unit, args_t *args) 8511 { 8512 char* subcmd = NULL; 8513 8514 if ((subcmd = ARG_GET(args)) == NULL) { 8515 return CMD_USAGE; 8516 } 8517 8518 /* BCM.0> fp policer create ... */ 8519 if(!sal_strcasecmp(subcmd, "create")) { 8520 return fp_policer_create(unit, args); 8521 } 8522 8523 /* BCM.0> fp policer destroy ... */ 8524 if(!sal_strcasecmp(subcmd, "destroy")) { 8525 return fp_policer_destroy(unit, args); 8526 } 8527 8528 /* BCM.0> fp policer set ... */ 8529 if(!sal_strcasecmp(subcmd, "set")) { 8530 return fp_policer_set(unit, args); 8531 } 8532 8533 /* BCM.0> fp policer attach ... */ 8534 if(!sal_strcasecmp(subcmd, "attach")) { 8535 return fp_policer_attach(unit, args); 8536 } 8537 8538 /* BCM.0> fp policer detach ... */ 8539 if(!sal_strcasecmp(subcmd, "detach")) { 8540 return fp_policer_detach(unit, args); 8541 } 8542 8543 return CMD_USAGE; 8544 } 8545 8546 #define _BCM_CLI_STAT_ARR_SIZE (_bcmFieldStatCount + 1) 8547 /* 8548 * Function: 8549 * fp_stat_create 8550 * Purpose: 8551 * Add fp counter entity. 8552 * Parmameters: 8553 * unit - (IN) Bcm device number. 8554 * args - (IN) Command arguments. 8555 * Returns: 8556 * Command result. 8557 */ 8558 STATIC int 8559 fp_stat_create(int unit, args_t *args) 8560 { 8561 parse_table_t pt; 8562 int statid = -1; 8563 int group = -1; 8564 cmd_result_t retCode; 8565 bcm_field_stat_t stat_arr[_BCM_CLI_STAT_ARR_SIZE]; 8566 int stat_arr_sz; 8567 char buffer[_BCM_CLI_STAT_ARR_SIZE][10]; 8568 int idx; 8569 int rv; 8570 8571 /* Initialization. */ 8572 for (idx = 0; idx < _BCM_CLI_STAT_ARR_SIZE; idx++) { 8573 /* coverity[mixed_enums] */ 8574 stat_arr[idx] = _bcmFieldStatCount; 8575 } 8576 8577 /* Parse command option arguments */ 8578 parse_table_init(unit, &pt); 8579 parse_table_add(&pt, "group", PQ_DFL|PQ_INT, 0, &group, NULL); 8580 8581 for (idx = 0; idx < _BCM_CLI_STAT_ARR_SIZE; idx++) { 8582 sal_sprintf(buffer[idx], "type%d", idx); 8583 parse_table_add(&pt, buffer[idx], PQ_DFL | PQ_MULTI, 0, 8584 (void *)&stat_arr[idx], stattype_text); 8585 } 8586 if (!parseEndOk(args, &pt, &retCode)) { 8587 return retCode; 8588 } 8589 8590 stat_arr_sz = 0; 8591 for (idx = 0; idx < _BCM_CLI_STAT_ARR_SIZE; idx++) { 8592 /* coverity[mixed_enums] */ 8593 if ((stat_arr[idx] >= 0) && 8594 (stat_arr[idx] < (bcm_field_stat_t)_bcmFieldStatCount)) { 8595 stat_arr_sz++; 8596 } 8597 } 8598 if (0 == stat_arr_sz) { 8599 cli_out("Stat type parse failed\n"); 8600 fp_print_options(stattype_text, sal_strlen("\tstatXX=")); 8601 cli_out("\n"); 8602 return CMD_FAIL; 8603 } 8604 8605 if (group < 0) { 8606 cli_out("Invalid group id (%d) \n", group); 8607 } 8608 8609 rv = bcm_field_stat_create(unit, group, stat_arr_sz, stat_arr, &statid); 8610 if (BCM_FAILURE(rv)) { 8611 cli_out("Stat add failed. (%s) \n", bcm_errmsg(rv)); 8612 return CMD_FAIL; 8613 } 8614 8615 LastCreatedStatID = statid; 8616 8617 cli_out("Stat created with id: %d \n", statid); 8618 return CMD_OK; 8619 } 8620 8621 /* 8622 * Function: 8623 * fp_stat_destroy 8624 * Purpose: 8625 * Remove fp stat entity. 8626 * Parmameters: 8627 * unit - (IN) Bcm device number. 8628 * args - (IN) Command arguments. 8629 * Returns: 8630 * Command result. 8631 */ 8632 STATIC int 8633 fp_stat_destroy(int unit, args_t *args) 8634 { 8635 char *param; 8636 int rv; 8637 parse_table_t pt; 8638 cmd_result_t retCode; 8639 int statid = -1; 8640 8641 param = ARG_CUR(args); 8642 if (!param) { 8643 return CMD_USAGE; 8644 } 8645 8646 if (0 == sal_strncasecmp(param, "all", 3)) { 8647 /* Delete all stat entities. 8648 param = ARG_GET(args); 8649 if ((rv = bcm_field_stat_destroy_all(unit)) != BCM_E_NONE) { 8650 cli_out("ERROR: bcm_field_stat_destroy_all(unit=%d) failed.(%s) \n", 8651 unit, bcm_errmsg(rv)); 8652 } 8653 */ 8654 cli_out("ERROR: bcm_field_stat_destroy_all: Unimplemented\n"); 8655 return CMD_FAIL; 8656 } else { 8657 /* Parse command option arguments */ 8658 parse_table_init(unit, &pt); 8659 parse_table_add(&pt, "StatId", PQ_DFL|PQ_INT, 0, &statid, NULL); 8660 if (!parseEndOk(args, &pt, &retCode)) { 8661 return retCode; 8662 } 8663 if (statid < 0) { 8664 cli_out("Invalid stat id specified\n"); 8665 return CMD_FAIL; 8666 } 8667 if ((rv = bcm_field_stat_destroy(unit, statid)) != BCM_E_NONE) { 8668 cli_out("ERROR: bcm_field_stat_destroy(unit=%d, id=%d) failed (%s) \n", 8669 unit, statid, bcm_errmsg(rv)); 8670 return CMD_FAIL; 8671 } 8672 } 8673 8674 return CMD_OK; 8675 } 8676 8677 /* 8678 * Function: 8679 * fp_stat_attach 8680 * Purpose: 8681 * Attach fp counter to a field entry. 8682 * Parmameters: 8683 * unit - (IN) Bcm device number. 8684 * args - (IN) Command arguments. 8685 * Returns: 8686 * Command result. 8687 */ 8688 STATIC int 8689 fp_stat_attach(int unit, args_t *args) 8690 { 8691 char *param; 8692 int rv; 8693 parse_table_t pt; 8694 cmd_result_t retCode; 8695 int statid = -1; 8696 bcm_field_entry_t eid = -1; 8697 8698 param = ARG_CUR(args); 8699 if (!param) { 8700 return CMD_USAGE; 8701 } 8702 8703 /* Parse command option arguments */ 8704 parse_table_init(unit, &pt); 8705 8706 parse_table_add(&pt, "StatId", PQ_INT, (void *) LastCreatedStatID, 8707 &statid, NULL); 8708 8709 parse_table_add(&pt, "entry", PQ_DFL|PQ_INT, 0, &eid, NULL); 8710 8711 if (!parseEndOk(args, &pt, &retCode)) { 8712 return retCode; 8713 } 8714 if (statid < 0) { 8715 cli_out("Stat id parse failed\n"); 8716 return CMD_FAIL; 8717 } 8718 if (eid < 0) { 8719 cli_out("Entry id partse failed\n"); 8720 return CMD_FAIL; 8721 } 8722 8723 if ((rv = bcm_field_entry_stat_attach(unit, eid, statid)) != BCM_E_NONE) { 8724 cli_out("ERROR: bcm_field_entry_stat_attach(unit=%d, eid=%d, \ 8725 statid=%d) failed (%s) \n", unit, eid, statid, bcm_errmsg(rv)); 8726 return CMD_FAIL; 8727 } 8728 return CMD_OK; 8729 } 8730 8731 /* 8732 * Function: 8733 * fp_stat_detach 8734 * Purpose: 8735 * Detach fp counter from a field entry. 8736 * Parmameters: 8737 * unit - (IN) Bcm device number. 8738 * args - (IN) Command arguments. 8739 * Returns: 8740 * Command result. 8741 */ 8742 STATIC int 8743 fp_stat_detach(int unit, args_t *args) 8744 { 8745 char *param; 8746 int rv; 8747 parse_table_t pt; 8748 cmd_result_t retCode; 8749 bcm_field_entry_t eid = -1; 8750 int statid = -1; 8751 8752 param = ARG_CUR(args); 8753 if (!param) { 8754 return CMD_USAGE; 8755 } 8756 8757 /* Parse command option arguments */ 8758 parse_table_init(unit, &pt); 8759 parse_table_add(&pt, "entry", PQ_DFL|PQ_INT, 0, &eid, NULL); 8760 parse_table_add(&pt, "StatId", PQ_DFL|PQ_INT, 0, &statid, NULL); 8761 if (!parseEndOk(args, &pt, &retCode)) { 8762 return retCode; 8763 } 8764 if (eid < 0) { 8765 cli_out("Invalid entry id specified\n"); 8766 return CMD_FAIL; 8767 } 8768 8769 if (statid < 0) { 8770 cli_out("Stat id parse failed\n"); 8771 return CMD_FAIL; 8772 } 8773 8774 if ((rv = bcm_field_entry_stat_detach(unit, eid, statid)) != BCM_E_NONE) { 8775 cli_out("ERROR: bcm_stat_detach(unit=%d, eid=%d, statid=%d)\ 8776 failed (%s) \n", unit, eid, statid, bcm_errmsg(rv)); 8777 return CMD_FAIL; 8778 } 8779 return CMD_OK; 8780 } 8781 8782 /* 8783 * Function: 8784 * fp_stat_set 8785 * Purpose: 8786 * Set stat value. 8787 * Parmameters: 8788 * unit - (IN) Bcm device number. 8789 * args - (IN) Command arguments. 8790 * Returns: 8791 * Command result. 8792 */ 8793 STATIC int 8794 fp_stat_set(int unit, args_t *args) 8795 { 8796 int statid = -1; 8797 bcm_field_stat_t type = _bcmFieldStatCount; 8798 cmd_result_t retval; 8799 uint64 val64; 8800 parse_table_t pt; 8801 8802 COMPILER_64_ZERO(val64); 8803 parse_table_init(unit, &pt); 8804 parse_table_add(&pt, "StatId", PQ_DFL|PQ_INT, 0, &statid, NULL); 8805 parse_table_add(&pt, "type", PQ_DFL | PQ_MULTI, 0, (void *)&type, stattype_text); 8806 parse_table_add(&pt, "val", PQ_DFL|PQ_INT64, 0, &val64, NULL); 8807 if (!parseEndOk(args, &pt, &retval)) { 8808 return retval; 8809 } 8810 8811 if (statid < 0) { 8812 cli_out("Stat id parse failed\n"); 8813 return CMD_FAIL; 8814 } 8815 8816 /* coverity[mixed_enums] */ 8817 if (type == (bcm_field_stat_t)_bcmFieldStatCount) { 8818 cli_out("Stat type parse failed\n"); 8819 fp_print_options(stattype_text, sal_strlen("\ttype=")); 8820 cli_out("\n"); 8821 } 8822 8823 retval = bcm_field_stat_set(unit, statid, type, val64); 8824 FP_CHECK_RETURN(unit, retval, "bcm_field_stat_set"); 8825 return CMD_OK; 8826 } 8827 8828 /* 8829 * Function: 8830 * fp_stat_get 8831 * Purpose: 8832 * Get stat value. 8833 * Parmameters: 8834 * unit - (IN) Bcm device number. 8835 * args - (IN) Command arguments. 8836 * Returns: 8837 * Command result. 8838 */ 8839 STATIC int 8840 fp_stat_get(int unit, args_t *args) 8841 { 8842 int statid = -1; 8843 bcm_field_stat_t stat_arr[_BCM_CLI_STAT_ARR_SIZE]; 8844 cmd_result_t retval; 8845 uint64 val64; 8846 int idx; 8847 parse_table_t pt; 8848 8849 COMPILER_64_ZERO(val64); 8850 for (idx = 0; idx < _BCM_CLI_STAT_ARR_SIZE; idx++) { 8851 /* coverity[mixed_enums] */ 8852 stat_arr[idx] = (bcm_field_stat_t) _bcmFieldStatCount; 8853 } 8854 8855 parse_table_init(unit, &pt); 8856 parse_table_add(&pt, "StatId", PQ_DFL|PQ_INT, 0, &statid, NULL); 8857 parse_table_add(&pt, "type", PQ_DFL | PQ_MULTI, 0, (void *)&stat_arr[0], stattype_text); 8858 if (!parseEndOk(args, &pt, &retval)) { 8859 return retval; 8860 } 8861 8862 if (statid < 0) { 8863 cli_out("Stat id parse failed\n"); 8864 return CMD_FAIL; 8865 } 8866 8867 /* coverity[mixed_enums] */ 8868 if (stat_arr[0] == (bcm_field_stat_t)_bcmFieldStatCount) { 8869 retval = bcm_field_stat_config_get(unit, statid, 8870 _BCM_CLI_STAT_ARR_SIZE, 8871 stat_arr); 8872 FP_CHECK_RETURN(unit, retval, "bcm_field_stat_config_get"); 8873 8874 for (idx = 0; idx < _BCM_CLI_STAT_ARR_SIZE; idx++) { 8875 /* coverity[mixed_enums] */ 8876 if (_bcmFieldStatCount == (_bcm_field_stat_t) stat_arr[idx]) { 8877 break; 8878 } 8879 retval = bcm_field_stat_get(unit, statid, stat_arr[idx], &val64); 8880 FP_CHECK_RETURN(unit, retval, "bcm_field_stat_get"); 8881 cli_out("%s, value is: 0x%x%08x\n", stattype_text[stat_arr[idx]], 8882 COMPILER_64_HI(val64), COMPILER_64_LO(val64)); 8883 } 8884 return CMD_OK; 8885 } 8886 8887 retval = bcm_field_stat_get(unit, statid, stat_arr[0], &val64); 8888 FP_CHECK_RETURN(unit, retval, "bcm_field_stat_get"); 8889 cli_out("The value is: 0x%x%08x\n", COMPILER_64_HI(val64), 8890 COMPILER_64_LO(val64)); 8891 return CMD_OK; 8892 } 8893 8894 /* 8895 * Function: 8896 * fp_stat 8897 * Purpose: 8898 * bcm_field_stat_xxx CLI implementation. 8899 * Parmameters: 8900 * unit - (IN) Bcm device number. 8901 * args - (IN) Command arguments. 8902 * Returns: 8903 * Command result. 8904 */ 8905 STATIC int 8906 fp_stat(int unit, args_t *args) 8907 { 8908 char* subcmd = NULL; 8909 8910 if ((subcmd = ARG_GET(args)) == NULL) { 8911 return CMD_USAGE; 8912 } 8913 8914 /* BCM.0> fp stat create ... */ 8915 if(!sal_strcasecmp(subcmd, "create")) { 8916 return fp_stat_create(unit, args); 8917 } 8918 8919 /* BCM.0> fp stat destroy ... */ 8920 if(!sal_strcasecmp(subcmd, "destroy")) { 8921 return fp_stat_destroy(unit, args); 8922 } 8923 8924 /* BCM.0> fp stat attach ... */ 8925 if(!sal_strcasecmp(subcmd, "attach")) { 8926 return fp_stat_attach(unit, args); 8927 } 8928 8929 /* BCM.0> fp stat detach ... */ 8930 if(!sal_strcasecmp(subcmd, "detach")) { 8931 return fp_stat_detach(unit, args); 8932 } 8933 8934 /* BCM.0> fp stat set ... */ 8935 if(!sal_strcasecmp(subcmd, "set")) { 8936 return fp_stat_set(unit, args); 8937 } 8938 8939 /* BCM.0> fp stat get ... */ 8940 if(!sal_strcasecmp(subcmd, "get")) { 8941 return fp_stat_get(unit, args); 8942 } 8943 return CMD_USAGE; 8944 } 8945 8946 /* 8947 * Function: 8948 * fp_data_create 8949 * Purpose: 8950 * Add fp data qualifier entity. 8951 * Parmameters: 8952 * unit - (IN) Bcm device number. 8953 * args - (IN) Command arguments. 8954 * Returns: 8955 * Command result. 8956 */ 8957 STATIC int 8958 fp_data_create(int unit, args_t *args) 8959 { 8960 parse_table_t pt; 8961 int length = -1; 8962 int offset = -1; 8963 int offset_base = 0; /* Packet Start. */ 8964 cmd_result_t retCode; 8965 bcm_field_data_qualifier_t data_qual; 8966 int rv; 8967 8968 /* Initialization. */ 8969 bcm_field_data_qualifier_t_init(&data_qual); 8970 8971 /* Parse command option arguments */ 8972 parse_table_init(unit, &pt); 8973 parse_table_add(&pt, "OffsetBase", PQ_DFL | PQ_MULTI, 0, 8974 (void *)&offset_base, offsetbase_text); 8975 parse_table_add(&pt, "offset", PQ_DFL|PQ_INT, 0, &offset, NULL); 8976 parse_table_add(&pt, "length", PQ_DFL|PQ_INT, 0, &length, NULL); 8977 8978 if (!parseEndOk(args, &pt, &retCode)) { 8979 return retCode; 8980 } 8981 8982 if (offset < 0) { 8983 cli_out("Offset parse failed.\n"); 8984 return CMD_FAIL; 8985 } 8986 8987 if (length < 0) { 8988 cli_out("Offset parse failed.\n"); 8989 return CMD_FAIL; 8990 } 8991 8992 data_qual.offset_base = offset_base; 8993 data_qual.offset = offset; 8994 data_qual.length = length; 8995 rv = bcm_field_data_qualifier_create(unit, &data_qual); 8996 if (BCM_FAILURE(rv)) { 8997 cli_out("Data qualifier add failed. (%s) \n", bcm_errmsg(rv)); 8998 return CMD_FAIL; 8999 } 9000 cli_out("Data qualifier created with id: %d \n", data_qual.qual_id); 9001 return CMD_OK; 9002 } 9003 9004 /* 9005 * Function: 9006 * fp_data_destroy 9007 * Purpose: 9008 * Destroy fp data qualifier entity. 9009 * Parmameters: 9010 * unit - (IN) Bcm device number. 9011 * args - (IN) Command arguments. 9012 * Returns: 9013 * Command result. 9014 */ 9015 STATIC int 9016 fp_data_destroy(int unit, args_t *args) 9017 { 9018 char *param; 9019 cmd_result_t retCode; 9020 parse_table_t pt; 9021 int qualid = -1; 9022 int rv; 9023 9024 param = ARG_CUR(args); 9025 if (!param) { 9026 return CMD_USAGE; 9027 } 9028 9029 if (0 == sal_strncasecmp(param, "all", 3)) { 9030 /* Delete all data qualifiers. */ 9031 param = ARG_GET(args); 9032 if ((rv = bcm_field_data_qualifier_destroy_all(unit)) != BCM_E_NONE) { 9033 cli_out("ERROR: data qualifier destroy all unit=%d) failed.(%s) \n", 9034 unit, bcm_errmsg(rv)); 9035 return (CMD_FAIL); 9036 } 9037 return (CMD_OK); 9038 } 9039 9040 /* Parse command option arguments */ 9041 parse_table_init(unit, &pt); 9042 parse_table_add(&pt, "QualId", PQ_DFL|PQ_INT, 0, &qualid, NULL); 9043 9044 if (!parseEndOk(args, &pt, &retCode)) { 9045 return retCode; 9046 } 9047 9048 if (qualid < 0) { 9049 cli_out("Qualifier id parse failed.\n"); 9050 return CMD_FAIL; 9051 } 9052 9053 rv = bcm_field_data_qualifier_destroy(unit, qualid); 9054 if (BCM_FAILURE(rv)) { 9055 cli_out("Data qualifier destroy failed. (%s) \n", bcm_errmsg(rv)); 9056 return CMD_FAIL; 9057 } 9058 return CMD_OK; 9059 } 9060 9061 9062 /* 9063 * Function: 9064 * fp_data_packet_format_add_delete 9065 * Purpose: 9066 * Add/delete packet format to the fp data qualifier. 9067 * Parmameters: 9068 * unit - (IN) Bcm device number. 9069 * args - (IN) Command arguments. 9070 * op - (0 delete, else add) 9071 * Returns: 9072 * Command result. 9073 */ 9074 STATIC int 9075 fp_data_packet_format_add_delete(int unit, args_t *args, int op) 9076 { 9077 bcm_field_data_packet_format_t pkt_fmt; 9078 cmd_result_t retCode; 9079 int relative_offset = 0; 9080 int vlan_tag = 0; /* Vlan Tag ANY.*/ 9081 int outer_ip = 0; /* Outer Ip ANY.*/ 9082 int inner_ip = 0; /* Inner Ip ANY.*/ 9083 int tunnel = 1; /* Tunnel None. */ 9084 int qualid = -1; 9085 int mpls = 0; /* MPLS labels ANY.*/ 9086 int higig = 0; 9087 int vntag = 0; 9088 int cntag = 0; 9089 int etag = 0; 9090 int icnm = 0; 9091 parse_table_t pt; 9092 int rv; 9093 int l2 = 0; /* L2 format ANY. */ 9094 9095 /* Initialization. */ 9096 bcm_field_data_packet_format_t_init(&pkt_fmt); 9097 9098 /* Parse command option arguments */ 9099 parse_table_init(unit, &pt); 9100 parse_table_add(&pt, "QualId", PQ_DFL|PQ_INT, 0, &qualid, NULL); 9101 parse_table_add(&pt, "RelativeOffset", PQ_DFL|PQ_INT, 0, 9102 &relative_offset, NULL); 9103 parse_table_add(&pt, "L2", PQ_DFL|PQ_MULTI, 0, 9104 (void *)&l2, data_l2_text); 9105 parse_table_add(&pt, "VlanTag", PQ_DFL|PQ_MULTI, 0, 9106 (void *)&vlan_tag, data_vlan_text); 9107 parse_table_add(&pt, "OuterIp", PQ_DFL|PQ_MULTI, 0, 9108 (void *)&outer_ip, data_ip_text); 9109 parse_table_add(&pt, "InnerIp", PQ_DFL|PQ_MULTI, 0, 9110 (void *)&inner_ip, data_ip_text); 9111 parse_table_add(&pt, "Tunnel", PQ_DFL|PQ_MULTI, 0, 9112 (void *)&tunnel, data_tunnel_text); 9113 parse_table_add(&pt, "Mpls", PQ_DFL|PQ_MULTI, 0, 9114 (void *)&mpls, data_mpls_text); 9115 parse_table_add(&pt, "Higig", PQ_DFL|PQ_MULTI, 0, (void *)&higig, 9116 data_higig_text); 9117 parse_table_add(&pt, "Vntag", PQ_DFL|PQ_MULTI, 0, (void *)&vntag, 9118 data_vntag_text); 9119 parse_table_add(&pt, "Cntag", PQ_DFL|PQ_MULTI, 0, (void *)&cntag, 9120 data_cntag_text); 9121 parse_table_add(&pt, "Etag", PQ_DFL|PQ_MULTI, 0, (void *)&etag, 9122 data_etag_text); 9123 parse_table_add(&pt, "Icnm", PQ_DFL|PQ_MULTI, 0, (void *)&icnm, 9124 data_icnm_text); 9125 9126 if (!parseEndOk(args, &pt, &retCode)) { 9127 return retCode; 9128 } 9129 9130 if (qualid < 0) { 9131 cli_out("Qualifier id parse failed.\n"); 9132 return CMD_FAIL; 9133 } 9134 9135 pkt_fmt.relative_offset = relative_offset; 9136 pkt_fmt.l2 = (l2 == 0) ? BCM_FIELD_DATA_FORMAT_L2_ANY : (1 << (l2 - 1)); 9137 pkt_fmt.vlan_tag = (vlan_tag == 0) ? BCM_FIELD_DATA_FORMAT_VLAN_TAG_ANY: \ 9138 (1 << (vlan_tag - 1)); 9139 pkt_fmt.outer_ip = (outer_ip == 0) ? BCM_FIELD_DATA_FORMAT_IP_ANY : \ 9140 (1 << (outer_ip - 1)); 9141 pkt_fmt.inner_ip = (inner_ip == 0) ? BCM_FIELD_DATA_FORMAT_IP_ANY : \ 9142 (1 << (inner_ip - 1)); 9143 pkt_fmt.tunnel = (tunnel == 0) ? BCM_FIELD_DATA_FORMAT_TUNNEL_ANY : \ 9144 (1 << (tunnel - 1)); 9145 pkt_fmt.mpls = (mpls == 0) ? BCM_FIELD_DATA_FORMAT_MPLS_ANY : \ 9146 (1 << (mpls - 1)); 9147 9148 if (higig != 0) { 9149 pkt_fmt.flags = (higig == 1) ? BCM_FIELD_DATA_FORMAT_F_ENCAP_STACK: 9150 BCM_FIELD_DATA_FORMAT_F_NO_ENCAP_STACK; 9151 } 9152 if (vntag != 0) { 9153 pkt_fmt.flags |= (vntag == 1) ? BCM_FIELD_DATA_FORMAT_F_VNTAG: 9154 BCM_FIELD_DATA_FORMAT_F_NO_VNTAG; 9155 } 9156 if (cntag != 0) { 9157 pkt_fmt.flags |= (vntag == 1) ? BCM_FIELD_DATA_FORMAT_F_CNTAG: 9158 BCM_FIELD_DATA_FORMAT_F_NO_CNTAG; 9159 } 9160 if (etag != 0) { 9161 pkt_fmt.flags |= (vntag == 1) ? BCM_FIELD_DATA_FORMAT_F_ETAG: 9162 BCM_FIELD_DATA_FORMAT_F_NO_ETAG; 9163 } 9164 if (icnm != 0) { 9165 pkt_fmt.flags |= (vntag == 1) ? BCM_FIELD_DATA_FORMAT_F_ICNM: 9166 BCM_FIELD_DATA_FORMAT_F_NO_ICNM; 9167 } 9168 9169 if (op) { 9170 rv = bcm_field_data_qualifier_packet_format_add(unit, qualid, 9171 &pkt_fmt); 9172 if (BCM_FAILURE(rv)) { 9173 cli_out("Data qualifier packet format add. (%s) \n", 9174 bcm_errmsg(rv)); 9175 return CMD_FAIL; 9176 } 9177 } else { 9178 rv = bcm_field_data_qualifier_packet_format_delete(unit, qualid, 9179 &pkt_fmt); 9180 if (BCM_FAILURE(rv)) { 9181 cli_out("Data qualifier packet format delete. (%s) \n", 9182 bcm_errmsg(rv)); 9183 return CMD_FAIL; 9184 } 9185 } 9186 return CMD_OK; 9187 } 9188 9189 /* 9190 * Function: 9191 * fp_data_ethertype_add_delete 9192 * Purpose: 9193 * Add/Delete ethertype to the fp data qualifier. 9194 * Parmameters: 9195 * unit - (IN) Bcm device number. 9196 * args - (IN) Command arguments. 9197 * op - (0 delete, else add) 9198 * Returns: 9199 * Command result. 9200 */ 9201 STATIC int 9202 fp_data_ethertype_add_delete(int unit, args_t *args, int op) 9203 { 9204 bcm_field_data_ethertype_t eth_type; 9205 cmd_result_t retCode; 9206 int relative_offset = 0; 9207 int vlan_tag = 0; /* Vlan Tag ANY. */ 9208 int l2 = 0; /* L2 format ANY. */ 9209 int ethertype = 0; /* EtherType value.*/ 9210 int qualid = -1; 9211 parse_table_t pt; 9212 int rv; 9213 int higig = 0; 9214 int vntag = 0; 9215 int cntag = 0; 9216 int etag = 0; 9217 int icnm = 0; 9218 9219 /* Initialization. */ 9220 bcm_field_data_ethertype_t_init(ð_type); 9221 9222 /* Parse command option arguments */ 9223 parse_table_init(unit, &pt); 9224 parse_table_add(&pt, "QualId", PQ_DFL|PQ_INT, 0, &qualid, NULL); 9225 parse_table_add(&pt, "RelativeOffset", PQ_DFL|PQ_INT, 0, 9226 &relative_offset, NULL); 9227 parse_table_add(&pt, "etype", PQ_DFL|PQ_INT, 0, ðertype, NULL); 9228 parse_table_add(&pt, "L2", PQ_DFL|PQ_MULTI, 0, 9229 (void *)&l2, data_l2_text); 9230 parse_table_add(&pt, "VlanTag", PQ_DFL|PQ_MULTI, 0, 9231 (void *)&vlan_tag, data_vlan_text); 9232 parse_table_add(&pt, "Higig", PQ_DFL|PQ_MULTI, 0, (void *)&higig, 9233 data_higig_text); 9234 parse_table_add(&pt, "Vntag", PQ_DFL|PQ_MULTI, 0, (void *)&vntag, 9235 data_vntag_text); 9236 parse_table_add(&pt, "Cntag", PQ_DFL|PQ_MULTI, 0, (void *)&cntag, 9237 data_cntag_text); 9238 parse_table_add(&pt, "Etag", PQ_DFL|PQ_MULTI, 0, (void *)&etag, 9239 data_etag_text); 9240 parse_table_add(&pt, "Icnm", PQ_DFL|PQ_MULTI, 0, (void *)&icnm, 9241 data_icnm_text); 9242 if (!parseEndOk(args, &pt, &retCode)) { 9243 return retCode; 9244 } 9245 9246 if (qualid < 0) { 9247 cli_out("Qualifier id parse failed.\n"); 9248 return CMD_FAIL; 9249 } 9250 9251 eth_type.relative_offset = relative_offset; 9252 eth_type.l2 = (l2 == 0) ? BCM_FIELD_DATA_FORMAT_L2_ANY : (1 << (l2 - 1)); 9253 eth_type.vlan_tag = (vlan_tag == 0) ? BCM_FIELD_DATA_FORMAT_VLAN_TAG_ANY: \ 9254 (1 << (vlan_tag - 1)); 9255 eth_type.ethertype = ethertype; 9256 if (higig != 0) { 9257 eth_type.flags = (higig == 1) ? BCM_FIELD_DATA_FORMAT_F_ENCAP_STACK: 9258 BCM_FIELD_DATA_FORMAT_F_NO_ENCAP_STACK; 9259 } 9260 if (vntag != 0) { 9261 eth_type.flags |= (vntag == 1) ? BCM_FIELD_DATA_FORMAT_F_VNTAG: 9262 BCM_FIELD_DATA_FORMAT_F_NO_VNTAG; 9263 } 9264 if (cntag != 0) { 9265 eth_type.flags |= (vntag == 1) ? BCM_FIELD_DATA_FORMAT_F_CNTAG: 9266 BCM_FIELD_DATA_FORMAT_F_NO_CNTAG; 9267 } 9268 if (etag != 0) { 9269 eth_type.flags |= (vntag == 1) ? BCM_FIELD_DATA_FORMAT_F_ETAG: 9270 BCM_FIELD_DATA_FORMAT_F_NO_ETAG; 9271 } 9272 if (icnm != 0) { 9273 eth_type.flags |= (vntag == 1) ? BCM_FIELD_DATA_FORMAT_F_ICNM: 9274 BCM_FIELD_DATA_FORMAT_F_NO_ICNM; 9275 } 9276 9277 if (op) { 9278 rv = bcm_field_data_qualifier_ethertype_add(unit, qualid, ð_type); 9279 if (BCM_FAILURE(rv)) { 9280 cli_out("Data qualifier ethertype add. (%s) \n", 9281 bcm_errmsg(rv)); 9282 return CMD_FAIL; 9283 } 9284 } else { 9285 rv = bcm_field_data_qualifier_ethertype_delete(unit, qualid, ð_type); 9286 if (BCM_FAILURE(rv)) { 9287 cli_out("Data qualifier ethertype delete. (%s) \n", 9288 bcm_errmsg(rv)); 9289 return CMD_FAIL; 9290 } 9291 } 9292 return CMD_OK; 9293 } 9294 9295 /* 9296 * Function: 9297 * fp_data_ipproto_add_delete 9298 * Purpose: 9299 * Add/Delete ip protocol to the fp data qualifier. 9300 * Parmameters: 9301 * unit - (IN) Bcm device number. 9302 * args - (IN) Command arguments. 9303 * op - (0 delete, else add) 9304 * Returns: 9305 * Command result. 9306 */ 9307 STATIC int 9308 fp_data_ipproto_add_delete(int unit, args_t *args, int op) 9309 { 9310 bcm_field_data_ip_protocol_t ipproto; 9311 cmd_result_t retCode; 9312 int relative_offset = 0; 9313 int vlan_tag = 0; /* Vlan Tag ANY. */ 9314 int l2 = 0; /* L2 format ANY. */ 9315 int ipver = 0; /* Ip type ANY. */ 9316 int protocol = -1; /* Protocol value. */ 9317 int qualid = -1; 9318 parse_table_t pt; 9319 int rv; 9320 9321 /* Initialization. */ 9322 bcm_field_data_ip_protocol_t_init(&ipproto); 9323 9324 /* Parse command option arguments */ 9325 parse_table_init(unit, &pt); 9326 parse_table_add(&pt, "QualId", PQ_DFL|PQ_INT, 0, &qualid, NULL); 9327 parse_table_add(&pt, "RelativeOffset", PQ_DFL|PQ_INT, 0, 9328 &relative_offset, NULL); 9329 parse_table_add(&pt, "protocol", PQ_DFL|PQ_INT, 0, &protocol, NULL); 9330 parse_table_add(&pt, "L2", PQ_DFL|PQ_MULTI, 0, 9331 (void *)&l2, data_l2_text); 9332 parse_table_add(&pt, "VlanTag", PQ_DFL|PQ_MULTI, 0, 9333 (void *)&vlan_tag, data_vlan_text); 9334 parse_table_add(&pt, "IpVer", PQ_DFL|PQ_MULTI, 0, 9335 (void *)&ipver, data_ip_text); 9336 if (!parseEndOk(args, &pt, &retCode)) { 9337 return retCode; 9338 } 9339 9340 if (qualid < 0) { 9341 cli_out("Qualifier id parse failed.\n"); 9342 return CMD_FAIL; 9343 } 9344 if (protocol < 0) { 9345 cli_out("Ip protocol parse failed.\n"); 9346 return CMD_FAIL; 9347 } 9348 9349 ipproto.relative_offset = relative_offset; 9350 ipproto.l2 = (l2 == 0) ? BCM_FIELD_DATA_FORMAT_L2_ANY : (1 << (l2 - 1)); 9351 ipproto.vlan_tag = (vlan_tag == 0) ? BCM_FIELD_DATA_FORMAT_VLAN_TAG_ANY: \ 9352 (1 << (vlan_tag - 1)); 9353 switch (ipver) { 9354 case 0: /* Any */ 9355 ipproto.flags = (BCM_FIELD_DATA_FORMAT_IP4 | 9356 BCM_FIELD_DATA_FORMAT_IP6); 9357 break; 9358 case 1: /* None */ 9359 ipproto.flags = 0; 9360 break; 9361 case 2: /* Ip4 */ 9362 ipproto.flags = BCM_FIELD_DATA_FORMAT_IP4; 9363 break; 9364 case 3: /* Ip6 */ 9365 ipproto.flags = BCM_FIELD_DATA_FORMAT_IP6; 9366 break; 9367 default: 9368 cli_out("Invalid IP version.\n"); 9369 return CMD_FAIL; 9370 } 9371 ipproto.ip = protocol; 9372 9373 if (op) { 9374 rv = bcm_field_data_qualifier_ip_protocol_add(unit, qualid, &ipproto); 9375 if (BCM_FAILURE(rv)) { 9376 cli_out("Data qualifier ip protocol add. (%s) \n", 9377 bcm_errmsg(rv)); 9378 return CMD_FAIL; 9379 } 9380 } else { 9381 rv = bcm_field_data_qualifier_ip_protocol_delete(unit, qualid, &ipproto); 9382 if (BCM_FAILURE(rv)) { 9383 cli_out("Data qualifier protocol delete. (%s) \n", 9384 bcm_errmsg(rv)); 9385 return CMD_FAIL; 9386 } 9387 } 9388 return CMD_OK; 9389 } 9390 9391 9392 /* 9393 * Function: 9394 * fp_data 9395 * Purpose: 9396 * bcm_field_data_xxx CLI implementation. 9397 * Parmameters: 9398 * unit - (IN) Bcm device number. 9399 * args - (IN) Command arguments. 9400 * Returns: 9401 * Command result. 9402 */ 9403 STATIC int 9404 fp_data(int unit, args_t *args) 9405 { 9406 char* subcmd = NULL; 9407 9408 if ((subcmd = ARG_GET(args)) == NULL) { 9409 return CMD_USAGE; 9410 } 9411 9412 /* BCM.0> fp data create ... */ 9413 if(!sal_strcasecmp(subcmd, "create")) { 9414 return fp_data_create(unit, args); 9415 } 9416 9417 /* BCM.0> fp data destroy ... */ 9418 if(!sal_strcasecmp(subcmd, "destroy")) { 9419 return fp_data_destroy(unit, args); 9420 } 9421 9422 /* BCM.0> fp data format ... */ 9423 if(!sal_strcasecmp(subcmd, "format")) { 9424 if ((subcmd = ARG_GET(args)) == NULL) { 9425 return CMD_USAGE; 9426 } 9427 if(!sal_strcasecmp(subcmd, "add")) { 9428 return fp_data_packet_format_add_delete(unit, args, TRUE); 9429 }else if(!sal_strcasecmp(subcmd, "delete")) { 9430 return fp_data_packet_format_add_delete(unit, args, FALSE); 9431 } else { 9432 return CMD_USAGE; 9433 } 9434 } 9435 9436 /* BCM.0> fp data ethertype ... */ 9437 if(!sal_strcasecmp(subcmd, "ethertype")) { 9438 if ((subcmd = ARG_GET(args)) == NULL) { 9439 return CMD_USAGE; 9440 } 9441 if(!sal_strcasecmp(subcmd, "add")) { 9442 return fp_data_ethertype_add_delete(unit, args, TRUE); 9443 }else if(!sal_strcasecmp(subcmd, "delete")) { 9444 return fp_data_ethertype_add_delete(unit, args, FALSE); 9445 } else { 9446 return CMD_USAGE; 9447 } 9448 } 9449 9450 /* BCM.0> fp data ipprotocol ... */ 9451 if(!sal_strcasecmp(subcmd, "ipproto")) { 9452 if ((subcmd = ARG_GET(args)) == NULL) { 9453 return CMD_USAGE; 9454 } 9455 if(!sal_strcasecmp(subcmd, "add")) { 9456 return fp_data_ipproto_add_delete(unit, args, TRUE); 9457 }else if(!sal_strcasecmp(subcmd, "delete")) { 9458 return fp_data_ipproto_add_delete(unit, args, FALSE); 9459 } else { 9460 return CMD_USAGE; 9461 } 9462 } 9463 return CMD_USAGE; 9464 } 9465 9466 /* 9467 * Function: 9468 * Purpose: 9469 * Parmameters: 9470 * Returns: 9471 */ 9472 STATIC int 9473 fp_qual_StpState(int unit, bcm_field_entry_t eid, args_t *args) 9474 { 9475 int retval = CMD_OK; 9476 uint32 data = 0; 9477 parse_table_t pt; 9478 9479 parse_table_init(unit, &pt); 9480 parse_table_add(&pt, "State", PQ_DFL | PQ_MULTI, 0, 9481 (void *)&data, data_stp_text); 9482 9483 if (BCM_FAILURE(parse_arg_eq(args, &pt))) { 9484 parse_arg_eq_done(&pt); 9485 return CMD_FAIL; 9486 } 9487 9488 /* BCM.0> fp qual <eid> StpState [State=<>] */ 9489 9490 /* Convert diag shell values to macro values */ 9491 if (data <= 3) { 9492 data = (1 << data); 9493 } else if (data == 4) { 9494 data = 3; 9495 } else if (data == 5) { 9496 data = 5; 9497 } else if (data == 6) { 9498 data = 10; 9499 } else if (data == 7) { 9500 data = 12; 9501 } else { 9502 return BCM_E_PARAM; 9503 } 9504 9505 LOG_VERBOSE(BSL_LS_APPL_SHELL, 9506 (BSL_META_U(unit, 9507 "FP(unit %d) verb:bcm_field_qualify_StpState(entry=%d, data=%#x)\n"), 9508 unit, eid, data)); 9509 retval = bcm_field_qualify_StpState(unit, eid, data); 9510 FP_CHECK_RETURN(unit, retval, "bcm_field_qualify_StpState"); 9511 9512 return CMD_OK; 9513 } 9514 9515 9516 STATIC int 9517 fp_qual_StpState_help(const char *prefix, int width_col1) { 9518 int offset; 9519 if (width_col1 < strlen("StpState")) { 9520 width_col1 = strlen("StpState") + 1; 9521 } 9522 9523 offset = sal_strlen(prefix); 9524 if (sal_strlen("StpState") >= width_col1) { 9525 offset += sal_strlen("StpState"); 9526 } else { 9527 offset += width_col1; 9528 } 9529 offset += sal_strlen("sState="); 9530 cli_out("%s%-*sState=", prefix, 9531 width_col1, "StpState"); 9532 9533 fp_print_options(data_stp_text, offset); 9534 cli_out("\n"); 9535 9536 return CMD_OK; 9537 } 9538 9539 /* 9540 * Function: 9541 * Purpose: 9542 * Parmameters: 9543 * Returns: 9544 */ 9545 STATIC int 9546 fp_qual_RoeFrameType(int unit, bcm_field_entry_t eid, args_t *args) 9547 { 9548 int retval = CMD_OK; 9549 uint32 data = 0; 9550 parse_table_t pt; 9551 9552 parse_table_init(unit, &pt); 9553 parse_table_add(&pt, "roe_type", PQ_DFL | PQ_MULTI, 0, 9554 (void *)&data, data_roe_type_text); 9555 9556 if (BCM_FAILURE(parse_arg_eq(args, &pt))) { 9557 parse_arg_eq_done(&pt); 9558 return CMD_FAIL; 9559 } 9560 9561 /* BCM.0> fp qual <eid> RoeFrameType [roe_type=<>] */ 9562 LOG_VERBOSE(BSL_LS_APPL_SHELL, 9563 (BSL_META_U(unit, 9564 "FP(unit %d) verb:bcm_field_qualify_RoeFrameType(entry=%d, data=%#x)\n"), 9565 unit, eid, data)); 9566 retval = bcm_field_qualify_RoeFrameType(unit, eid, data); 9567 FP_CHECK_RETURN(unit, retval, "bcm_field_qualify_RoeFrameType"); 9568 9569 return CMD_OK; 9570 } 9571 9572 STATIC int 9573 fp_qual_RoeFrameType_help(const char *prefix, int width_col1) { 9574 int offset; 9575 if (width_col1 < strlen("RoeFrameType")) { 9576 width_col1 = strlen("RoeFrameType") + 1; 9577 } 9578 9579 offset = sal_strlen(prefix); 9580 if (sal_strlen("RoeFrameType") >= width_col1) { 9581 offset += sal_strlen("RoeFrameType"); 9582 } else { 9583 offset += width_col1; 9584 } 9585 offset += sal_strlen("sroe_type="); 9586 cli_out("%s%-*sroe_type=", prefix, 9587 width_col1, "RoeFrameType"); 9588 9589 fp_print_options(data_roe_type_text, offset); 9590 cli_out("\n"); 9591 9592 return CMD_OK; 9593 } 9594 9595 #endif /* BCM_FIELD_SUPPORT */