traverse_client.c - openbcm - Git mirror of https://github.com/Broadcom-Network-Switching-Software/OpenBCM

traverse_client.c (144212B)
      1 /*
      2  * DO NOT EDIT THIS FILE!
      3  * This file is auto-generated.
      4  * Edits to this file will be lost when it is regenerated.
      5  *
      6  * 
      7  * This license is set out in https://raw.githubusercontent.com/Broadcom-Network-Switching-Software/OpenBCM/master/Legal/LICENSE file.
      8  * 
      9  * Copyright 2007-2020 Broadcom Inc. All rights reserved.
     10  *
     11  * File:	traverse_client.c
     12  * Purpose:	BCM API Traverse Server routines for remote units
     13  * Generator:	mkdispatch 1.54
     14  */
     15 
     16 #include <shared/alloc.h>
     17 #include <bcm/types.h>
     18 #include <bcm/bregex.h>
     19 #include <bcm/cosq.h>
     20 #include <bcm/extender.h>
     21 #include <bcm/fabric.h>
     22 #include <bcm/fcoe.h>
     23 #include <bcm/field.h>
     24 #include <bcm/flow.h>
     25 #include <bcm/flowtracker.h>
     26 #include <bcm/hash.h>
     27 #include <bcm/instru.h>
     28 #include <bcm/ipfix.h>
     29 #include <bcm/ipmc.h>
     30 #include <bcm/l2.h>
     31 #include <bcm/l2gre.h>
     32 #include <bcm/l3.h>
     33 #include <bcm/mim.h>
     34 #include <bcm/mirror.h>
     35 #include <bcm/mpls.h>
     36 #include <bcm/multicast.h>
     37 #include <bcm/nat.h>
     38 #include <bcm/niv.h>
     39 #include <bcm/oam.h>
     40 #include <bcm/policer.h>
     41 #include <bcm/port.h>
     42 #include <bcm/proxy.h>
     43 #include <bcm/pstats.h>
     44 #include <bcm/range.h>
     45 #include <bcm/sat.h>
     46 #include <bcm/srv6.h>
     47 #include <bcm/subport.h>
     48 #include <bcm/switch.h>
     49 #include <bcm/time.h>
     50 #include <bcm/trill.h>
     51 #include <bcm/trunk.h>
     52 #include <bcm/tsn.h>
     53 #include <bcm/tunnel.h>
     54 #include <bcm/vlan.h>
     55 #include <bcm/vswitch.h>
     56 #include <bcm/vxlan.h>
     57 #include <bcm/wlan.h>
     58 
     59 #include <bcm_int/rpc/pack.h>
     60 #include "traverse.h"
     61 
     62 #ifdef	BCM_RPC_SUPPORT
     63 
     64 
     65 int
     66 bcm_client_cosq_gport_traverse(
     67 	int	unit,
     68 	bcm_cosq_gport_traverse_cb	cb,
     69 	void *	user_data)
     70 {
     71 	bcm_rlink_traverse_data_t	r_req;
     72 	int	r_rv;
     73 	uint32	r_key[] = {
     74 		0xcdd16376,0x9b8ac79f,0xd0b2074a,0x456f0101,0xb667687c };
     75 	bcm_gport_t	r_port;
     76 	int	r_numq;
     77 	uint32	r_flags;
     78 	bcm_gport_t	r_gport;
     79 
     80 	sal_memset(&r_req, 0, sizeof(r_req));
     81 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
     82 	if (BCM_SUCCESS(r_rv)) {
     83 		/* Pack request */
     84 		/* Skip unit */
     85 
     86 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
     87 			/* Unpack reply */
     88 			/* Skip unit */
     89 			BCM_UNPACK_U32(r_req.rx_ptr, r_port);
     90 			BCM_UNPACK_U32(r_req.rx_ptr, r_numq);
     91 			BCM_UNPACK_U32(r_req.rx_ptr, r_flags);
     92 			BCM_UNPACK_U32(r_req.rx_ptr, r_gport);
     93 
     94 			r_rv = cb(unit, r_port, r_numq, r_flags, r_gport, user_data);
     95 
     96 			if (BCM_FAILURE(r_rv)) {
     97 				break;
     98 			}
     99 		}
    100 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
    101 	}
    102 
    103 	return r_rv;
    104 }
    105 
    106 int
    107 bcm_client_cosq_gport_traverse_by_port(
    108 	int	unit,
    109 	bcm_gport_t	port,
    110 	bcm_cosq_gport_traverse_cb	cb,
    111 	void *	user_data)
    112 {
    113 	bcm_rlink_traverse_data_t	r_req;
    114 	int	r_rv;
    115 	uint32	r_key[] = {
    116 		0x3c49f0f4,0xc84b0c8c,0x666ee956,0xd8e60b14,0x1dfedb8f };
    117 	bcm_gport_t	r_port;
    118 	int	r_numq;
    119 	uint32	r_flags;
    120 	bcm_gport_t	r_gport;
    121 
    122 	sal_memset(&r_req, 0, sizeof(r_req));
    123 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
    124 	if (BCM_SUCCESS(r_rv)) {
    125 		/* Pack request */
    126 		/* Skip unit */
    127 		BCM_PACK_U32(r_req.tx_ptr, port);
    128 
    129 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
    130 			/* Unpack reply */
    131 			/* Skip unit */
    132 			BCM_UNPACK_U32(r_req.rx_ptr, r_port);
    133 			BCM_UNPACK_U32(r_req.rx_ptr, r_numq);
    134 			BCM_UNPACK_U32(r_req.rx_ptr, r_flags);
    135 			BCM_UNPACK_U32(r_req.rx_ptr, r_gport);
    136 
    137 			r_rv = cb(unit, r_port, r_numq, r_flags, r_gport, user_data);
    138 
    139 			if (BCM_FAILURE(r_rv)) {
    140 				break;
    141 			}
    142 		}
    143 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
    144 	}
    145 
    146 	return r_rv;
    147 }
    148 
    149 int
    150 bcm_client_cosq_pfc_deadlock_recovery_event_register(
    151 	int	unit,
    152 	bcm_cosq_pfc_deadlock_recovery_event_cb_t	callback,
    153 	void *	userdata)
    154 {
    155 	bcm_rlink_traverse_data_t	r_req;
    156 	int	r_rv;
    157 	uint32	r_key[] = {
    158 		0x0a03a8c6,0x354d3590,0xb61e4c9d,0x23e091c7,0xcc467be9 };
    159 	bcm_port_t	r_port;
    160 	bcm_cos_queue_t	r_cosq;
    161 	bcm_cosq_pfc_deadlock_recovery_event_t	r_recovery_state;
    162 
    163 	sal_memset(&r_req, 0, sizeof(r_req));
    164 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
    165 	if (BCM_SUCCESS(r_rv)) {
    166 		/* Pack request */
    167 		/* Skip unit */
    168 
    169 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
    170 			/* Unpack reply */
    171 			/* Skip unit */
    172 			BCM_UNPACK_U32(r_req.rx_ptr, r_port);
    173 			BCM_UNPACK_U32(r_req.rx_ptr, r_cosq);
    174 			BCM_UNPACK_U32(r_req.rx_ptr, r_recovery_state);
    175 
    176 			r_rv = callback(unit, r_port, r_cosq, r_recovery_state, userdata);
    177 
    178 			if (BCM_FAILURE(r_rv)) {
    179 				break;
    180 			}
    181 		}
    182 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
    183 	}
    184 
    185 	return r_rv;
    186 }
    187 
    188 int
    189 bcm_client_cosq_pfc_deadlock_recovery_event_unregister(
    190 	int	unit,
    191 	bcm_cosq_pfc_deadlock_recovery_event_cb_t	callback,
    192 	void *	userdata)
    193 {
    194 	bcm_rlink_traverse_data_t	r_req;
    195 	int	r_rv;
    196 	uint32	r_key[] = {
    197 		0x1639fee7,0x7ab663d0,0xaf8a309b,0xbf754839,0xb474ecaf };
    198 	bcm_port_t	r_port;
    199 	bcm_cos_queue_t	r_cosq;
    200 	bcm_cosq_pfc_deadlock_recovery_event_t	r_recovery_state;
    201 
    202 	sal_memset(&r_req, 0, sizeof(r_req));
    203 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
    204 	if (BCM_SUCCESS(r_rv)) {
    205 		/* Pack request */
    206 		/* Skip unit */
    207 
    208 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
    209 			/* Unpack reply */
    210 			/* Skip unit */
    211 			BCM_UNPACK_U32(r_req.rx_ptr, r_port);
    212 			BCM_UNPACK_U32(r_req.rx_ptr, r_cosq);
    213 			BCM_UNPACK_U32(r_req.rx_ptr, r_recovery_state);
    214 
    215 			r_rv = callback(unit, r_port, r_cosq, r_recovery_state, userdata);
    216 
    217 			if (BCM_FAILURE(r_rv)) {
    218 				break;
    219 			}
    220 		}
    221 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
    222 	}
    223 
    224 	return r_rv;
    225 }
    226 
    227 int
    228 bcm_client_cosq_subscriber_traverse(
    229 	int	unit,
    230 	bcm_cosq_subscriber_map_traverse_cb	cb,
    231 	void *	user_data)
    232 {
    233 	bcm_rlink_traverse_data_t	r_req;
    234 	int	r_rv;
    235 	uint32	r_key[] = {
    236 		0x7eaa044b,0x4739ff12,0x82703193,0x8bc6a763,0x26eb7aae };
    237 	bcm_cosq_subscriber_map_t	r_map;
    238 	bcm_cosq_subscriber_map_t *	r_p_map;
    239 
    240 	sal_memset(&r_req, 0, sizeof(r_req));
    241 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
    242 	if (BCM_SUCCESS(r_rv)) {
    243 		/* Pack request */
    244 		/* Skip unit */
    245 
    246 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
    247 			/* Unpack reply */
    248 			/* Skip unit */
    249 			if (*r_req.rx_ptr++ == 1) {
    250 				r_p_map = NULL;
    251 			} else {
    252 				r_p_map = &r_map;
    253 				r_req.rx_ptr = _bcm_unpack_cosq_subscriber_map(r_req.rx_ptr, r_p_map);
    254 			}
    255 
    256 			r_rv = cb(unit, r_p_map, user_data);
    257 
    258 			if (BCM_FAILURE(r_rv)) {
    259 				break;
    260 			}
    261 		}
    262 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
    263 	}
    264 
    265 	return r_rv;
    266 }
    267 
    268 int
    269 bcm_client_cosq_tas_profile_traverse(
    270 	int	unit,
    271 	bcm_gport_t	port,
    272 	bcm_cosq_tas_profile_traverse_cb	cb,
    273 	void *	user_data)
    274 {
    275 	bcm_rlink_traverse_data_t	r_req;
    276 	int	r_rv;
    277 	uint32	r_key[] = {
    278 		0x200a12ad,0xfb7ad646,0x7aa9921e,0x58a58191,0xd601c631 };
    279 	bcm_gport_t	r_port;
    280 	bcm_cosq_tas_profile_id_t	r_pid;
    281 
    282 	sal_memset(&r_req, 0, sizeof(r_req));
    283 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
    284 	if (BCM_SUCCESS(r_rv)) {
    285 		/* Pack request */
    286 		/* Skip unit */
    287 		BCM_PACK_U32(r_req.tx_ptr, port);
    288 
    289 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
    290 			/* Unpack reply */
    291 			/* Skip unit */
    292 			BCM_UNPACK_U32(r_req.rx_ptr, r_port);
    293 			BCM_UNPACK_U32(r_req.rx_ptr, r_pid);
    294 
    295 			r_rv = cb(unit, r_port, r_pid, user_data);
    296 
    297 			if (BCM_FAILURE(r_rv)) {
    298 				break;
    299 			}
    300 		}
    301 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
    302 	}
    303 
    304 	return r_rv;
    305 }
    306 
    307 #ifdef	INCLUDE_L3
    308 
    309 int
    310 bcm_client_extender_encap_traverse(
    311 	int	unit,
    312 	bcm_extender_encap_traverse_cb	cb,
    313 	void *	user_data)
    314 {
    315 	bcm_rlink_traverse_data_t	r_req;
    316 	int	r_rv;
    317 	uint32	r_key[] = {
    318 		0xf016ce91,0xe1f3dfdd,0xcc2bf4a3,0x8d6c6965,0x051ef3b5 };
    319 	bcm_extender_encap_t	r_extender_encap;
    320 	bcm_extender_encap_t *	r_p_extender_encap;
    321 
    322 	sal_memset(&r_req, 0, sizeof(r_req));
    323 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
    324 	if (BCM_SUCCESS(r_rv)) {
    325 		/* Pack request */
    326 		/* Skip unit */
    327 
    328 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
    329 			/* Unpack reply */
    330 			/* Skip unit */
    331 			if (*r_req.rx_ptr++ == 1) {
    332 				r_p_extender_encap = NULL;
    333 			} else {
    334 				r_p_extender_encap = &r_extender_encap;
    335 				r_req.rx_ptr = _bcm_unpack_extender_encap(r_req.rx_ptr, r_p_extender_encap);
    336 			}
    337 
    338 			r_rv = cb(unit, r_p_extender_encap, user_data);
    339 
    340 			if (BCM_FAILURE(r_rv)) {
    341 				break;
    342 			}
    343 		}
    344 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
    345 	}
    346 
    347 	return r_rv;
    348 }
    349 
    350 int
    351 bcm_client_extender_forward_traverse(
    352 	int	unit,
    353 	bcm_extender_forward_traverse_cb	cb,
    354 	void *	user_data)
    355 {
    356 	bcm_rlink_traverse_data_t	r_req;
    357 	int	r_rv;
    358 	uint32	r_key[] = {
    359 		0x3e5a5367,0xd7207b54,0x4aeac8c6,0x13cc01c5,0xb2b2c801 };
    360 	bcm_extender_forward_t	r_extender_forward_entry;
    361 	bcm_extender_forward_t *	r_p_extender_forward_entry;
    362 
    363 	sal_memset(&r_req, 0, sizeof(r_req));
    364 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
    365 	if (BCM_SUCCESS(r_rv)) {
    366 		/* Pack request */
    367 		/* Skip unit */
    368 
    369 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
    370 			/* Unpack reply */
    371 			/* Skip unit */
    372 			if (*r_req.rx_ptr++ == 1) {
    373 				r_p_extender_forward_entry = NULL;
    374 			} else {
    375 				r_p_extender_forward_entry = &r_extender_forward_entry;
    376 				r_req.rx_ptr = _bcm_unpack_extender_forward(r_req.rx_ptr, r_p_extender_forward_entry);
    377 			}
    378 
    379 			r_rv = cb(unit, r_p_extender_forward_entry, user_data);
    380 
    381 			if (BCM_FAILURE(r_rv)) {
    382 				break;
    383 			}
    384 		}
    385 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
    386 	}
    387 
    388 	return r_rv;
    389 }
    390 
    391 int
    392 bcm_client_extender_port_traverse(
    393 	int	unit,
    394 	bcm_extender_port_traverse_cb	cb,
    395 	void *	user_data)
    396 {
    397 	bcm_rlink_traverse_data_t	r_req;
    398 	int	r_rv;
    399 	uint32	r_key[] = {
    400 		0x7e9ac770,0xd851ab92,0x9977eecf,0x07c509f4,0xe57e5cd0 };
    401 	bcm_extender_port_t	r_extender_port;
    402 	bcm_extender_port_t *	r_p_extender_port;
    403 
    404 	sal_memset(&r_req, 0, sizeof(r_req));
    405 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
    406 	if (BCM_SUCCESS(r_rv)) {
    407 		/* Pack request */
    408 		/* Skip unit */
    409 
    410 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
    411 			/* Unpack reply */
    412 			/* Skip unit */
    413 			if (*r_req.rx_ptr++ == 1) {
    414 				r_p_extender_port = NULL;
    415 			} else {
    416 				r_p_extender_port = &r_extender_port;
    417 				r_req.rx_ptr = _bcm_unpack_extender_port(r_req.rx_ptr, r_p_extender_port);
    418 			}
    419 
    420 			r_rv = cb(unit, r_p_extender_port, user_data);
    421 
    422 			if (BCM_FAILURE(r_rv)) {
    423 				break;
    424 			}
    425 		}
    426 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
    427 	}
    428 
    429 	return r_rv;
    430 }
    431 
    432 #endif	/* INCLUDE_L3 */
    433 
    434 int
    435 bcm_client_fabric_action_traverse(
    436 	int	unit,
    437 	bcm_fabric_action_traverse_cb	cb,
    438 	void *	user_data)
    439 {
    440 	bcm_rlink_traverse_data_t	r_req;
    441 	int	r_rv;
    442 	uint32	r_key[] = {
    443 		0xd09547e4,0x74756cf0,0x892ce5f5,0x73a3ea6c,0xff536521 };
    444 	bcm_fabric_action_t	r_action_id;
    445 	bcm_fabric_action_info_t	r_action_info;
    446 	bcm_fabric_action_info_t *	r_p_action_info;
    447 
    448 	sal_memset(&r_req, 0, sizeof(r_req));
    449 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
    450 	if (BCM_SUCCESS(r_rv)) {
    451 		/* Pack request */
    452 		/* Skip unit */
    453 
    454 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
    455 			/* Unpack reply */
    456 			/* Skip unit */
    457 			BCM_UNPACK_U32(r_req.rx_ptr, r_action_id);
    458 			if (*r_req.rx_ptr++ == 1) {
    459 				r_p_action_info = NULL;
    460 			} else {
    461 				r_p_action_info = &r_action_info;
    462 				r_req.rx_ptr = _bcm_unpack_fabric_action_info(r_req.rx_ptr, r_p_action_info);
    463 			}
    464 
    465 			r_rv = cb(unit, r_action_id, r_p_action_info, user_data);
    466 
    467 			if (BCM_FAILURE(r_rv)) {
    468 				break;
    469 			}
    470 		}
    471 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
    472 	}
    473 
    474 	return r_rv;
    475 }
    476 
    477 int
    478 bcm_client_fabric_predicate_action_traverse(
    479 	int	unit,
    480 	bcm_fabric_predicate_action_traverse_cb	cb,
    481 	void *	user_data)
    482 {
    483 	bcm_rlink_traverse_data_t	r_req;
    484 	int	r_rv;
    485 	uint32	r_key[] = {
    486 		0xe3e74fd8,0x96476661,0x8047f5a8,0x117c2bbf,0xeabeaf58 };
    487 	bcm_fabric_predicate_action_t	r_predicate_action_id;
    488 	bcm_fabric_predicate_action_info_t	r_predicate_action_info;
    489 	bcm_fabric_predicate_action_info_t *	r_p_predicate_action_info;
    490 
    491 	sal_memset(&r_req, 0, sizeof(r_req));
    492 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
    493 	if (BCM_SUCCESS(r_rv)) {
    494 		/* Pack request */
    495 		/* Skip unit */
    496 
    497 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
    498 			/* Unpack reply */
    499 			/* Skip unit */
    500 			BCM_UNPACK_U32(r_req.rx_ptr, r_predicate_action_id);
    501 			if (*r_req.rx_ptr++ == 1) {
    502 				r_p_predicate_action_info = NULL;
    503 			} else {
    504 				r_p_predicate_action_info = &r_predicate_action_info;
    505 				r_req.rx_ptr = _bcm_unpack_fabric_predicate_action_info(r_req.rx_ptr, r_p_predicate_action_info);
    506 			}
    507 
    508 			r_rv = cb(unit, r_predicate_action_id, r_p_predicate_action_info, user_data);
    509 
    510 			if (BCM_FAILURE(r_rv)) {
    511 				break;
    512 			}
    513 		}
    514 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
    515 	}
    516 
    517 	return r_rv;
    518 }
    519 
    520 int
    521 bcm_client_fabric_predicate_traverse(
    522 	int	unit,
    523 	bcm_fabric_predicate_traverse_cb	cb,
    524 	void *	user_data)
    525 {
    526 	bcm_rlink_traverse_data_t	r_req;
    527 	int	r_rv;
    528 	uint32	r_key[] = {
    529 		0x9b5315c0,0xb0c3eeb2,0x69dcd64b,0x615311d9,0x84425616 };
    530 	bcm_fabric_predicate_t	r_pred_id;
    531 	bcm_fabric_predicate_info_t	r_pred_info;
    532 	bcm_fabric_predicate_info_t *	r_p_pred_info;
    533 
    534 	sal_memset(&r_req, 0, sizeof(r_req));
    535 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
    536 	if (BCM_SUCCESS(r_rv)) {
    537 		/* Pack request */
    538 		/* Skip unit */
    539 
    540 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
    541 			/* Unpack reply */
    542 			/* Skip unit */
    543 			BCM_UNPACK_U32(r_req.rx_ptr, r_pred_id);
    544 			if (*r_req.rx_ptr++ == 1) {
    545 				r_p_pred_info = NULL;
    546 			} else {
    547 				r_p_pred_info = &r_pred_info;
    548 				r_req.rx_ptr = _bcm_unpack_fabric_predicate_info(r_req.rx_ptr, r_p_pred_info);
    549 			}
    550 
    551 			r_rv = cb(unit, r_pred_id, r_p_pred_info, user_data);
    552 
    553 			if (BCM_FAILURE(r_rv)) {
    554 				break;
    555 			}
    556 		}
    557 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
    558 	}
    559 
    560 	return r_rv;
    561 }
    562 
    563 int
    564 bcm_client_fabric_qsel_entry_traverse(
    565 	int	unit,
    566 	bcm_fabric_qsel_t	qsel_id,
    567 	bcm_fabric_qsel_entry_traverse_cb	cb,
    568 	void *	user_data)
    569 {
    570 	bcm_rlink_traverse_data_t	r_req;
    571 	int	r_rv;
    572 	uint32	r_key[] = {
    573 		0x295c9feb,0x8c75e357,0x8c42628e,0x49db7cf4,0x39540b43 };
    574 	bcm_fabric_qsel_t	r_qsel_id;
    575 	int	r_offset;
    576 	bcm_gport_t	r_queue;
    577 	bcm_fabric_qsel_offset_t	r_qsel_offset;
    578 
    579 	sal_memset(&r_req, 0, sizeof(r_req));
    580 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
    581 	if (BCM_SUCCESS(r_rv)) {
    582 		/* Pack request */
    583 		/* Skip unit */
    584 		BCM_PACK_U32(r_req.tx_ptr, qsel_id);
    585 
    586 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
    587 			/* Unpack reply */
    588 			/* Skip unit */
    589 			BCM_UNPACK_U32(r_req.rx_ptr, r_qsel_id);
    590 			BCM_UNPACK_U32(r_req.rx_ptr, r_offset);
    591 			BCM_UNPACK_U32(r_req.rx_ptr, r_queue);
    592 			BCM_UNPACK_U32(r_req.rx_ptr, r_qsel_offset);
    593 
    594 			r_rv = cb(unit, r_qsel_id, r_offset, r_queue, r_qsel_offset, user_data);
    595 
    596 			if (BCM_FAILURE(r_rv)) {
    597 				break;
    598 			}
    599 		}
    600 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
    601 	}
    602 
    603 	return r_rv;
    604 }
    605 
    606 int
    607 bcm_client_fabric_qsel_offset_entry_traverse(
    608 	int	unit,
    609 	bcm_fabric_qsel_offset_t	qsel_offset_id,
    610 	bcm_fabric_qsel_offset_entry_traverse_cb	cb,
    611 	void *	user_data)
    612 {
    613 	bcm_rlink_traverse_data_t	r_req;
    614 	int	r_rv;
    615 	uint32	r_key[] = {
    616 		0xb00d7a12,0xfbe0dca1,0x4a6e8f4d,0xa249d050,0x792767aa };
    617 	bcm_fabric_qsel_offset_t	r_qsel_offset_id;
    618 	bcm_cos_t	r_int_pri;
    619 	int	r_offset;
    620 
    621 	sal_memset(&r_req, 0, sizeof(r_req));
    622 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
    623 	if (BCM_SUCCESS(r_rv)) {
    624 		/* Pack request */
    625 		/* Skip unit */
    626 		BCM_PACK_U32(r_req.tx_ptr, qsel_offset_id);
    627 
    628 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
    629 			/* Unpack reply */
    630 			/* Skip unit */
    631 			BCM_UNPACK_U32(r_req.rx_ptr, r_qsel_offset_id);
    632 			BCM_UNPACK_U32(r_req.rx_ptr, r_int_pri);
    633 			BCM_UNPACK_U32(r_req.rx_ptr, r_offset);
    634 
    635 			r_rv = cb(unit, r_qsel_offset_id, r_int_pri, r_offset, user_data);
    636 
    637 			if (BCM_FAILURE(r_rv)) {
    638 				break;
    639 			}
    640 		}
    641 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
    642 	}
    643 
    644 	return r_rv;
    645 }
    646 
    647 int
    648 bcm_client_fabric_qsel_offset_traverse(
    649 	int	unit,
    650 	bcm_fabric_qsel_offset_traverse_cb	cb,
    651 	void *	user_data)
    652 {
    653 	bcm_rlink_traverse_data_t	r_req;
    654 	int	r_rv;
    655 	uint32	r_key[] = {
    656 		0x23b0dc69,0x3a9bee91,0x30cb05d4,0x7dc2246d,0x09b7ad84 };
    657 	bcm_fabric_qsel_offset_t	r_qsel_offset_id;
    658 	uint32	r_flags;
    659 
    660 	sal_memset(&r_req, 0, sizeof(r_req));
    661 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
    662 	if (BCM_SUCCESS(r_rv)) {
    663 		/* Pack request */
    664 		/* Skip unit */
    665 
    666 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
    667 			/* Unpack reply */
    668 			/* Skip unit */
    669 			BCM_UNPACK_U32(r_req.rx_ptr, r_qsel_offset_id);
    670 			BCM_UNPACK_U32(r_req.rx_ptr, r_flags);
    671 
    672 			r_rv = cb(unit, r_qsel_offset_id, r_flags, user_data);
    673 
    674 			if (BCM_FAILURE(r_rv)) {
    675 				break;
    676 			}
    677 		}
    678 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
    679 	}
    680 
    681 	return r_rv;
    682 }
    683 
    684 int
    685 bcm_client_fabric_qsel_traverse(
    686 	int	unit,
    687 	bcm_fabric_qsel_traverse_cb	cb,
    688 	void *	user_data)
    689 {
    690 	bcm_rlink_traverse_data_t	r_req;
    691 	int	r_rv;
    692 	uint32	r_key[] = {
    693 		0x2428b5d0,0x909f54aa,0xf64a8cee,0x9b352323,0x7e3273ef };
    694 	bcm_fabric_qsel_t	r_qsel_id;
    695 	uint32	r_flags;
    696 	int	r_base;
    697 	int	r_count;
    698 
    699 	sal_memset(&r_req, 0, sizeof(r_req));
    700 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
    701 	if (BCM_SUCCESS(r_rv)) {
    702 		/* Pack request */
    703 		/* Skip unit */
    704 
    705 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
    706 			/* Unpack reply */
    707 			/* Skip unit */
    708 			BCM_UNPACK_U32(r_req.rx_ptr, r_qsel_id);
    709 			BCM_UNPACK_U32(r_req.rx_ptr, r_flags);
    710 			BCM_UNPACK_U32(r_req.rx_ptr, r_base);
    711 			BCM_UNPACK_U32(r_req.rx_ptr, r_count);
    712 
    713 			r_rv = cb(unit, r_qsel_id, r_flags, r_base, r_count, user_data);
    714 
    715 			if (BCM_FAILURE(r_rv)) {
    716 				break;
    717 			}
    718 		}
    719 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
    720 	}
    721 
    722 	return r_rv;
    723 }
    724 
    725 int
    726 bcm_client_fcoe_route_traverse(
    727 	int	unit,
    728 	uint32	flags,
    729 	bcm_fcoe_route_traverse_cb	trav_fn,
    730 	void *	user_data)
    731 {
    732 	bcm_rlink_traverse_data_t	r_req;
    733 	int	r_rv;
    734 	uint32	r_key[] = {
    735 		0x11f430d4,0x77be922f,0xe6ae6c0c,0x93c6aad5,0xbe032cc2 };
    736 	bcm_fcoe_route_t	r_route;
    737 	bcm_fcoe_route_t *	r_p_route;
    738 
    739 	sal_memset(&r_req, 0, sizeof(r_req));
    740 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
    741 	if (BCM_SUCCESS(r_rv)) {
    742 		/* Pack request */
    743 		/* Skip unit */
    744 		BCM_PACK_U32(r_req.tx_ptr, flags);
    745 
    746 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
    747 			/* Unpack reply */
    748 			/* Skip unit */
    749 			if (*r_req.rx_ptr++ == 1) {
    750 				r_p_route = NULL;
    751 			} else {
    752 				r_p_route = &r_route;
    753 				r_req.rx_ptr = _bcm_unpack_fcoe_route(r_req.rx_ptr, r_p_route);
    754 			}
    755 
    756 			r_rv = trav_fn(unit, r_p_route, user_data);
    757 
    758 			if (BCM_FAILURE(r_rv)) {
    759 				break;
    760 			}
    761 		}
    762 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
    763 	}
    764 
    765 	return r_rv;
    766 }
    767 
    768 int
    769 bcm_client_fcoe_vsan_traverse(
    770 	int	unit,
    771 	uint32	flags,
    772 	bcm_fcoe_vsan_traverse_cb	trav_fn,
    773 	void *	user_data)
    774 {
    775 	bcm_rlink_traverse_data_t	r_req;
    776 	int	r_rv;
    777 	uint32	r_key[] = {
    778 		0x1d2f1ea4,0xe2d4a29a,0x5e48b834,0xf3e30cd0,0xe11a1ff4 };
    779 	bcm_fcoe_vsan_id_t	r_vsan_id;
    780 	bcm_fcoe_vsan_t	r_vsan;
    781 	bcm_fcoe_vsan_t *	r_p_vsan;
    782 
    783 	sal_memset(&r_req, 0, sizeof(r_req));
    784 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
    785 	if (BCM_SUCCESS(r_rv)) {
    786 		/* Pack request */
    787 		/* Skip unit */
    788 		BCM_PACK_U32(r_req.tx_ptr, flags);
    789 
    790 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
    791 			/* Unpack reply */
    792 			/* Skip unit */
    793 			BCM_UNPACK_U32(r_req.rx_ptr, r_vsan_id);
    794 			if (*r_req.rx_ptr++ == 1) {
    795 				r_p_vsan = NULL;
    796 			} else {
    797 				r_p_vsan = &r_vsan;
    798 				r_req.rx_ptr = _bcm_unpack_fcoe_vsan(r_req.rx_ptr, r_p_vsan);
    799 			}
    800 
    801 			r_rv = trav_fn(unit, r_vsan_id, r_p_vsan, user_data);
    802 
    803 			if (BCM_FAILURE(r_rv)) {
    804 				break;
    805 			}
    806 		}
    807 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
    808 	}
    809 
    810 	return r_rv;
    811 }
    812 
    813 int
    814 bcm_client_fcoe_zone_traverse(
    815 	int	unit,
    816 	uint32	flags,
    817 	bcm_fcoe_zone_traverse_cb	trav_fn,
    818 	void *	user_data)
    819 {
    820 	bcm_rlink_traverse_data_t	r_req;
    821 	int	r_rv;
    822 	uint32	r_key[] = {
    823 		0x3fde7d72,0x13dca9fb,0x26a6e5f6,0x808ef4a4,0x0b11388b };
    824 	bcm_fcoe_zone_entry_t	r_zone;
    825 	bcm_fcoe_zone_entry_t *	r_p_zone;
    826 
    827 	sal_memset(&r_req, 0, sizeof(r_req));
    828 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
    829 	if (BCM_SUCCESS(r_rv)) {
    830 		/* Pack request */
    831 		/* Skip unit */
    832 		BCM_PACK_U32(r_req.tx_ptr, flags);
    833 
    834 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
    835 			/* Unpack reply */
    836 			/* Skip unit */
    837 			if (*r_req.rx_ptr++ == 1) {
    838 				r_p_zone = NULL;
    839 			} else {
    840 				r_p_zone = &r_zone;
    841 				r_req.rx_ptr = _bcm_unpack_fcoe_zone_entry(r_req.rx_ptr, r_p_zone);
    842 			}
    843 
    844 			r_rv = trav_fn(unit, r_p_zone, user_data);
    845 
    846 			if (BCM_FAILURE(r_rv)) {
    847 				break;
    848 			}
    849 		}
    850 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
    851 	}
    852 
    853 	return r_rv;
    854 }
    855 
    856 int
    857 bcm_client_field_group_traverse(
    858 	int	unit,
    859 	bcm_field_group_traverse_cb	callback,
    860 	void *	user_data)
    861 {
    862 	bcm_rlink_traverse_data_t	r_req;
    863 	int	r_rv;
    864 	uint32	r_key[] = {
    865 		0xabd27cfb,0x948c6a65,0x086d4a58,0x4f1490e8,0x6e2aa45d };
    866 	bcm_field_group_t	r_group;
    867 
    868 	sal_memset(&r_req, 0, sizeof(r_req));
    869 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
    870 	if (BCM_SUCCESS(r_rv)) {
    871 		/* Pack request */
    872 		/* Skip unit */
    873 
    874 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
    875 			/* Unpack reply */
    876 			/* Skip unit */
    877 			BCM_UNPACK_U32(r_req.rx_ptr, r_group);
    878 
    879 			r_rv = callback(unit, r_group, user_data);
    880 
    881 			if (BCM_FAILURE(r_rv)) {
    882 				break;
    883 			}
    884 		}
    885 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
    886 	}
    887 
    888 	return r_rv;
    889 }
    890 
    891 #ifdef	INCLUDE_L3
    892 
    893 int
    894 bcm_client_flow_encap_traverse(
    895 	int	unit,
    896 	bcm_flow_encap_traverse_cb	cb,
    897 	void *	user_data)
    898 {
    899 	bcm_rlink_traverse_data_t	r_req;
    900 	int	r_rv;
    901 	int	r_i;
    902 	uint32	r_key[] = {
    903 		0x6592817f,0x1f32e355,0x63c422f7,0x858785d7,0x09be07db };
    904 	bcm_flow_encap_config_t	r_info;
    905 	uint32	r_num_of_fields;
    906 	bcm_flow_encap_config_t *	r_p_info;
    907 	bcm_flow_logical_field_t *	r_p_field;
    908 
    909 	sal_memset(&r_req, 0, sizeof(r_req));
    910 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
    911 	if (BCM_SUCCESS(r_rv)) {
    912 		/* Pack request */
    913 		/* Skip unit */
    914 
    915 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
    916 			/* Unpack reply */
    917 			r_rv = BCM_E_NONE;
    918 			/* Skip unit */
    919 			if (*r_req.rx_ptr++ == 1) {
    920 				r_p_info = NULL;
    921 			} else {
    922 				r_p_info = &r_info;
    923 				r_req.rx_ptr = _bcm_unpack_flow_encap_config(r_req.rx_ptr, r_p_info);
    924 			}
    925 			BCM_UNPACK_U32(r_req.rx_ptr, r_num_of_fields);
    926 			if (*r_req.rx_ptr++ == 1) {
    927 				r_p_field = NULL;
    928 			} else {
    929 				r_p_field = sal_alloc(r_num_of_fields*sizeof(bcm_flow_logical_field_t), "traverse r_field");
    930 				if (r_p_field == NULL) {
    931 					r_rv = BCM_E_MEMORY;
    932 				} else {
    933 					for (r_i = 0; r_i < r_num_of_fields; r_i++) {
    934 						r_req.rx_ptr = _bcm_unpack_flow_logical_field(r_req.rx_ptr, r_p_field+r_i);
    935 					}
    936 				}
    937 			}
    938 
    939 			if (BCM_SUCCESS(r_rv)) {
    940 				r_rv = cb(unit, r_p_info, r_num_of_fields, r_p_field, user_data);
    941 			}
    942 
    943 			if (r_p_field != NULL) {
    944 				sal_free(r_p_field);
    945 			}
    946 
    947 			if (BCM_FAILURE(r_rv)) {
    948 				break;
    949 			}
    950 		}
    951 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
    952 	}
    953 
    954 	return r_rv;
    955 }
    956 
    957 int
    958 bcm_client_flow_match_traverse(
    959 	int	unit,
    960 	bcm_flow_match_traverse_cb	cb,
    961 	void *	user_data)
    962 {
    963 	bcm_rlink_traverse_data_t	r_req;
    964 	int	r_rv;
    965 	int	r_i;
    966 	uint32	r_key[] = {
    967 		0x81ba6960,0x4e9f9b8c,0x175b3bce,0x258ff077,0x15cd6d66 };
    968 	bcm_flow_match_config_t	r_info;
    969 	uint32	r_num_of_fields;
    970 	bcm_flow_match_config_t *	r_p_info;
    971 	bcm_flow_logical_field_t *	r_p_field;
    972 
    973 	sal_memset(&r_req, 0, sizeof(r_req));
    974 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
    975 	if (BCM_SUCCESS(r_rv)) {
    976 		/* Pack request */
    977 		/* Skip unit */
    978 
    979 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
    980 			/* Unpack reply */
    981 			r_rv = BCM_E_NONE;
    982 			/* Skip unit */
    983 			if (*r_req.rx_ptr++ == 1) {
    984 				r_p_info = NULL;
    985 			} else {
    986 				r_p_info = &r_info;
    987 				r_req.rx_ptr = _bcm_unpack_flow_match_config(r_req.rx_ptr, r_p_info);
    988 			}
    989 			BCM_UNPACK_U32(r_req.rx_ptr, r_num_of_fields);
    990 			if (*r_req.rx_ptr++ == 1) {
    991 				r_p_field = NULL;
    992 			} else {
    993 				r_p_field = sal_alloc(r_num_of_fields*sizeof(bcm_flow_logical_field_t), "traverse r_field");
    994 				if (r_p_field == NULL) {
    995 					r_rv = BCM_E_MEMORY;
    996 				} else {
    997 					for (r_i = 0; r_i < r_num_of_fields; r_i++) {
    998 						r_req.rx_ptr = _bcm_unpack_flow_logical_field(r_req.rx_ptr, r_p_field+r_i);
    999 					}
   1000 				}
   1001 			}
   1002 
   1003 			if (BCM_SUCCESS(r_rv)) {
   1004 				r_rv = cb(unit, r_p_info, r_num_of_fields, r_p_field, user_data);
   1005 			}
   1006 
   1007 			if (r_p_field != NULL) {
   1008 				sal_free(r_p_field);
   1009 			}
   1010 
   1011 			if (BCM_FAILURE(r_rv)) {
   1012 				break;
   1013 			}
   1014 		}
   1015 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   1016 	}
   1017 
   1018 	return r_rv;
   1019 }
   1020 
   1021 int
   1022 bcm_client_flow_tunnel_initiator_traverse(
   1023 	int	unit,
   1024 	bcm_flow_tunnel_initiator_traverse_cb	cb,
   1025 	void *	user_data)
   1026 {
   1027 	bcm_rlink_traverse_data_t	r_req;
   1028 	int	r_rv;
   1029 	int	r_i;
   1030 	uint32	r_key[] = {
   1031 		0x11322c75,0x2183e25c,0xb7faf1de,0xd2fce25e,0xc650a0b5 };
   1032 	bcm_flow_tunnel_initiator_t	r_info;
   1033 	uint32	r_num_of_fields;
   1034 	bcm_flow_tunnel_initiator_t *	r_p_info;
   1035 	bcm_flow_logical_field_t *	r_p_field;
   1036 
   1037 	sal_memset(&r_req, 0, sizeof(r_req));
   1038 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   1039 	if (BCM_SUCCESS(r_rv)) {
   1040 		/* Pack request */
   1041 		/* Skip unit */
   1042 
   1043 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   1044 			/* Unpack reply */
   1045 			r_rv = BCM_E_NONE;
   1046 			/* Skip unit */
   1047 			if (*r_req.rx_ptr++ == 1) {
   1048 				r_p_info = NULL;
   1049 			} else {
   1050 				r_p_info = &r_info;
   1051 				r_req.rx_ptr = _bcm_unpack_flow_tunnel_initiator(r_req.rx_ptr, r_p_info);
   1052 			}
   1053 			BCM_UNPACK_U32(r_req.rx_ptr, r_num_of_fields);
   1054 			if (*r_req.rx_ptr++ == 1) {
   1055 				r_p_field = NULL;
   1056 			} else {
   1057 				r_p_field = sal_alloc(r_num_of_fields*sizeof(bcm_flow_logical_field_t), "traverse r_field");
   1058 				if (r_p_field == NULL) {
   1059 					r_rv = BCM_E_MEMORY;
   1060 				} else {
   1061 					for (r_i = 0; r_i < r_num_of_fields; r_i++) {
   1062 						r_req.rx_ptr = _bcm_unpack_flow_logical_field(r_req.rx_ptr, r_p_field+r_i);
   1063 					}
   1064 				}
   1065 			}
   1066 
   1067 			if (BCM_SUCCESS(r_rv)) {
   1068 				r_rv = cb(unit, r_p_info, r_num_of_fields, r_p_field, user_data);
   1069 			}
   1070 
   1071 			if (r_p_field != NULL) {
   1072 				sal_free(r_p_field);
   1073 			}
   1074 
   1075 			if (BCM_FAILURE(r_rv)) {
   1076 				break;
   1077 			}
   1078 		}
   1079 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   1080 	}
   1081 
   1082 	return r_rv;
   1083 }
   1084 
   1085 int
   1086 bcm_client_flow_tunnel_terminator_traverse(
   1087 	int	unit,
   1088 	bcm_flow_tunnel_terminator_traverse_cb	cb,
   1089 	void *	user_data)
   1090 {
   1091 	bcm_rlink_traverse_data_t	r_req;
   1092 	int	r_rv;
   1093 	int	r_i;
   1094 	uint32	r_key[] = {
   1095 		0xde6fc490,0xd1e7d3b8,0xe1d03dce,0x19d24374,0x3045a319 };
   1096 	bcm_flow_tunnel_terminator_t	r_info;
   1097 	uint32	r_num_of_fields;
   1098 	bcm_flow_tunnel_terminator_t *	r_p_info;
   1099 	bcm_flow_logical_field_t *	r_p_field;
   1100 
   1101 	sal_memset(&r_req, 0, sizeof(r_req));
   1102 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   1103 	if (BCM_SUCCESS(r_rv)) {
   1104 		/* Pack request */
   1105 		/* Skip unit */
   1106 
   1107 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   1108 			/* Unpack reply */
   1109 			r_rv = BCM_E_NONE;
   1110 			/* Skip unit */
   1111 			if (*r_req.rx_ptr++ == 1) {
   1112 				r_p_info = NULL;
   1113 			} else {
   1114 				r_p_info = &r_info;
   1115 				r_req.rx_ptr = _bcm_unpack_flow_tunnel_terminator(r_req.rx_ptr, r_p_info);
   1116 			}
   1117 			BCM_UNPACK_U32(r_req.rx_ptr, r_num_of_fields);
   1118 			if (*r_req.rx_ptr++ == 1) {
   1119 				r_p_field = NULL;
   1120 			} else {
   1121 				r_p_field = sal_alloc(r_num_of_fields*sizeof(bcm_flow_logical_field_t), "traverse r_field");
   1122 				if (r_p_field == NULL) {
   1123 					r_rv = BCM_E_MEMORY;
   1124 				} else {
   1125 					for (r_i = 0; r_i < r_num_of_fields; r_i++) {
   1126 						r_req.rx_ptr = _bcm_unpack_flow_logical_field(r_req.rx_ptr, r_p_field+r_i);
   1127 					}
   1128 				}
   1129 			}
   1130 
   1131 			if (BCM_SUCCESS(r_rv)) {
   1132 				r_rv = cb(unit, r_p_info, r_num_of_fields, r_p_field, user_data);
   1133 			}
   1134 
   1135 			if (r_p_field != NULL) {
   1136 				sal_free(r_p_field);
   1137 			}
   1138 
   1139 			if (BCM_FAILURE(r_rv)) {
   1140 				break;
   1141 			}
   1142 		}
   1143 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   1144 	}
   1145 
   1146 	return r_rv;
   1147 }
   1148 
   1149 int
   1150 bcm_client_flow_vpn_traverse(
   1151 	int	unit,
   1152 	bcm_flow_vpn_traverse_cb	cb,
   1153 	void *	user_data)
   1154 {
   1155 	bcm_rlink_traverse_data_t	r_req;
   1156 	int	r_rv;
   1157 	uint32	r_key[] = {
   1158 		0xb1216e1d,0x9b30098f,0x773c692c,0x54c6ede0,0x51e7deff };
   1159 	bcm_vpn_t	r_vpn;
   1160 	bcm_flow_vpn_config_t	r_info;
   1161 	bcm_flow_vpn_config_t *	r_p_info;
   1162 
   1163 	sal_memset(&r_req, 0, sizeof(r_req));
   1164 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   1165 	if (BCM_SUCCESS(r_rv)) {
   1166 		/* Pack request */
   1167 		/* Skip unit */
   1168 
   1169 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   1170 			/* Unpack reply */
   1171 			/* Skip unit */
   1172 			BCM_UNPACK_U16(r_req.rx_ptr, r_vpn);
   1173 			if (*r_req.rx_ptr++ == 1) {
   1174 				r_p_info = NULL;
   1175 			} else {
   1176 				r_p_info = &r_info;
   1177 				BCM_UNPACK_U32(r_req.rx_ptr, r_p_info->flags);
   1178 				BCM_UNPACK_U32(r_req.rx_ptr, r_p_info->broadcast_group);
   1179 				BCM_UNPACK_U32(r_req.rx_ptr, r_p_info->unknown_unicast_group);
   1180 				BCM_UNPACK_U32(r_req.rx_ptr, r_p_info->unknown_multicast_group);
   1181 				BCM_UNPACK_U32(r_req.rx_ptr, r_p_info->protocol_pkt.mmrp_action);
   1182 				BCM_UNPACK_U32(r_req.rx_ptr, r_p_info->protocol_pkt.srp_action);
   1183 				BCM_UNPACK_U32(r_req.rx_ptr, r_p_info->protocol_pkt.arp_reply_action);
   1184 				BCM_UNPACK_U32(r_req.rx_ptr, r_p_info->protocol_pkt.arp_request_action);
   1185 				BCM_UNPACK_U32(r_req.rx_ptr, r_p_info->protocol_pkt.nd_action);
   1186 				BCM_UNPACK_U32(r_req.rx_ptr, r_p_info->protocol_pkt.dhcp_action);
   1187 				BCM_UNPACK_U32(r_req.rx_ptr, r_p_info->protocol_pkt.igmp_report_leave_action);
   1188 				BCM_UNPACK_U32(r_req.rx_ptr, r_p_info->protocol_pkt.igmp_query_action);
   1189 				BCM_UNPACK_U32(r_req.rx_ptr, r_p_info->protocol_pkt.igmp_unknown_msg_action);
   1190 				BCM_UNPACK_U32(r_req.rx_ptr, r_p_info->protocol_pkt.mld_report_done_action);
   1191 				BCM_UNPACK_U32(r_req.rx_ptr, r_p_info->protocol_pkt.mld_query_action);
   1192 				BCM_UNPACK_U32(r_req.rx_ptr, r_p_info->protocol_pkt.ip4_rsvd_mc_action);
   1193 				BCM_UNPACK_U32(r_req.rx_ptr, r_p_info->protocol_pkt.ip6_rsvd_mc_action);
   1194 				BCM_UNPACK_U32(r_req.rx_ptr, r_p_info->protocol_pkt.ip4_mc_router_adv_action);
   1195 				BCM_UNPACK_U32(r_req.rx_ptr, r_p_info->protocol_pkt.ip6_mc_router_adv_action);
   1196 				BCM_UNPACK_U32(r_req.rx_ptr, r_p_info->protocol_pkt.flood_action_according_to_pfm);
   1197 				BCM_UNPACK_U32(r_req.rx_ptr, r_p_info->match_port_class);
   1198 			}
   1199 
   1200 			r_rv = cb(unit, r_vpn, r_p_info, user_data);
   1201 
   1202 			if (BCM_FAILURE(r_rv)) {
   1203 				break;
   1204 			}
   1205 		}
   1206 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   1207 	}
   1208 
   1209 	return r_rv;
   1210 }
   1211 
   1212 #endif	/* INCLUDE_L3 */
   1213 
   1214 int
   1215 bcm_client_flowtracker_check_traverse(
   1216 	int	unit,
   1217 	bcm_flowtracker_check_traverse_cb	cb,
   1218 	void *	user_data)
   1219 {
   1220 	bcm_rlink_traverse_data_t	r_req;
   1221 	int	r_rv;
   1222 	uint32	r_key[] = {
   1223 		0x80c0e350,0x5cd52793,0x173df485,0x1605f02d,0x0fdbd644 };
   1224 	bcm_flowtracker_check_t	r_check_id;
   1225 	bcm_flowtracker_check_info_t	r_check_info;
   1226 	bcm_flowtracker_check_info_t *	r_p_check_info;
   1227 
   1228 	sal_memset(&r_req, 0, sizeof(r_req));
   1229 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   1230 	if (BCM_SUCCESS(r_rv)) {
   1231 		/* Pack request */
   1232 		/* Skip unit */
   1233 
   1234 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   1235 			/* Unpack reply */
   1236 			/* Skip unit */
   1237 			BCM_UNPACK_U32(r_req.rx_ptr, r_check_id);
   1238 			if (*r_req.rx_ptr++ == 1) {
   1239 				r_p_check_info = NULL;
   1240 			} else {
   1241 				r_p_check_info = &r_check_info;
   1242 				r_req.rx_ptr = _bcm_unpack_flowtracker_check_info(r_req.rx_ptr, r_p_check_info);
   1243 			}
   1244 
   1245 			r_rv = cb(unit, r_check_id, r_p_check_info, user_data);
   1246 
   1247 			if (BCM_FAILURE(r_rv)) {
   1248 				break;
   1249 			}
   1250 		}
   1251 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   1252 	}
   1253 
   1254 	return r_rv;
   1255 }
   1256 
   1257 int
   1258 bcm_client_hash_flex_bin_traverse(
   1259 	int	unit,
   1260 	uint32	option,
   1261 	bcm_hash_flex_bin_traverse_cb	cb,
   1262 	void *	user_data)
   1263 {
   1264 	bcm_rlink_traverse_data_t	r_req;
   1265 	int	r_rv;
   1266 	int	r_i;
   1267 	uint32	r_key[] = {
   1268 		0xd01b170f,0x66e58955,0x4064f80a,0x826a4128,0xf782776c };
   1269 	bcm_hash_flex_bin_config_t	r_cfg;
   1270 	int	r_num_bins;
   1271 	int	r_num_fields;
   1272 	bcm_hash_flex_bin_config_t *	r_p_cfg;
   1273 	bcm_hash_flex_bin_cmd_t *	r_p_bin_cmd;
   1274 	bcm_hash_flex_field_t *	r_p_flex_field;
   1275 
   1276 	sal_memset(&r_req, 0, sizeof(r_req));
   1277 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   1278 	if (BCM_SUCCESS(r_rv)) {
   1279 		/* Pack request */
   1280 		/* Skip unit */
   1281 		BCM_PACK_U32(r_req.tx_ptr, option);
   1282 
   1283 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   1284 			/* Unpack reply */
   1285 			r_rv = BCM_E_NONE;
   1286 			/* Skip unit */
   1287 			if (*r_req.rx_ptr++ == 1) {
   1288 				r_p_cfg = NULL;
   1289 			} else {
   1290 				r_p_cfg = &r_cfg;
   1291 				r_req.rx_ptr = _bcm_unpack_hash_flex_bin_config(r_req.rx_ptr, r_p_cfg);
   1292 			}
   1293 			BCM_UNPACK_U32(r_req.rx_ptr, r_num_bins);
   1294 			if (*r_req.rx_ptr++ == 1) {
   1295 				r_p_bin_cmd = NULL;
   1296 			} else {
   1297 				r_p_bin_cmd = sal_alloc(r_num_bins*sizeof(bcm_hash_flex_bin_cmd_t), "traverse r_bin_cmd");
   1298 				if (r_p_bin_cmd == NULL) {
   1299 					r_rv = BCM_E_MEMORY;
   1300 				} else {
   1301 					for (r_i = 0; r_i < r_num_bins; r_i++) {
   1302 						r_req.rx_ptr = _bcm_unpack_hash_flex_bin_cmd(r_req.rx_ptr, r_p_bin_cmd+r_i);
   1303 					}
   1304 				}
   1305 			}
   1306 			BCM_UNPACK_U32(r_req.rx_ptr, r_num_fields);
   1307 			if (*r_req.rx_ptr++ == 1) {
   1308 				r_p_flex_field = NULL;
   1309 			} else {
   1310 				r_p_flex_field = sal_alloc(r_num_fields*sizeof(bcm_hash_flex_field_t), "traverse r_flex_field");
   1311 				if (r_p_flex_field == NULL) {
   1312 					r_rv = BCM_E_MEMORY;
   1313 				} else {
   1314 					for (r_i = 0; r_i < r_num_fields; r_i++) {
   1315 						r_req.rx_ptr = _bcm_unpack_hash_flex_field(r_req.rx_ptr, r_p_flex_field+r_i);
   1316 					}
   1317 				}
   1318 			}
   1319 
   1320 			if (BCM_SUCCESS(r_rv)) {
   1321 				r_rv = cb(unit, r_p_cfg, r_num_bins, r_p_bin_cmd, r_num_fields, r_p_flex_field, user_data);
   1322 			}
   1323 
   1324 			if (r_p_bin_cmd != NULL) {
   1325 				sal_free(r_p_bin_cmd);
   1326 			}
   1327 			if (r_p_flex_field != NULL) {
   1328 				sal_free(r_p_flex_field);
   1329 			}
   1330 
   1331 			if (BCM_FAILURE(r_rv)) {
   1332 				break;
   1333 			}
   1334 		}
   1335 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   1336 	}
   1337 
   1338 	return r_rv;
   1339 }
   1340 
   1341 int
   1342 bcm_client_instru_sflow_encap_traverse(
   1343 	int	unit,
   1344 	bcm_instru_sflow_encap_traverse_cb	cb,
   1345 	void *	user_data)
   1346 {
   1347 	bcm_rlink_traverse_data_t	r_req;
   1348 	int	r_rv;
   1349 	uint32	r_key[] = {
   1350 		0xb940a220,0x44e0c1bd,0x9bfd9616,0xb95430c3,0xdeef329e };
   1351 	bcm_instru_sflow_encap_info_t	r_sflow_encap_info;
   1352 	bcm_instru_sflow_encap_info_t *	r_p_sflow_encap_info;
   1353 
   1354 	sal_memset(&r_req, 0, sizeof(r_req));
   1355 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   1356 	if (BCM_SUCCESS(r_rv)) {
   1357 		/* Pack request */
   1358 		/* Skip unit */
   1359 
   1360 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   1361 			/* Unpack reply */
   1362 			/* Skip unit */
   1363 			if (*r_req.rx_ptr++ == 1) {
   1364 				r_p_sflow_encap_info = NULL;
   1365 			} else {
   1366 				r_p_sflow_encap_info = &r_sflow_encap_info;
   1367 				r_req.rx_ptr = _bcm_unpack_instru_sflow_encap_info(r_req.rx_ptr, r_p_sflow_encap_info);
   1368 			}
   1369 
   1370 			r_rv = cb(unit, r_p_sflow_encap_info, user_data);
   1371 
   1372 			if (BCM_FAILURE(r_rv)) {
   1373 				break;
   1374 			}
   1375 		}
   1376 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   1377 	}
   1378 
   1379 	return r_rv;
   1380 }
   1381 
   1382 int
   1383 bcm_client_ipfix_rate_traverse(
   1384 	int	unit,
   1385 	bcm_ipfix_rate_traverse_cb	cb,
   1386 	void *	userdata)
   1387 {
   1388 	bcm_rlink_traverse_data_t	r_req;
   1389 	int	r_rv;
   1390 	uint32	r_key[] = {
   1391 		0x46a4972e,0x92ec830b,0x9b8f6d89,0x04fc1820,0x272f503f };
   1392 	bcm_ipfix_rate_t	r_rate_info;
   1393 	bcm_ipfix_rate_t *	r_p_rate_info;
   1394 
   1395 	sal_memset(&r_req, 0, sizeof(r_req));
   1396 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   1397 	if (BCM_SUCCESS(r_rv)) {
   1398 		/* Pack request */
   1399 		/* Skip unit */
   1400 
   1401 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   1402 			/* Unpack reply */
   1403 			/* Skip unit */
   1404 			if (*r_req.rx_ptr++ == 1) {
   1405 				r_p_rate_info = NULL;
   1406 			} else {
   1407 				r_p_rate_info = &r_rate_info;
   1408 				r_req.rx_ptr = _bcm_unpack_ipfix_rate(r_req.rx_ptr, r_p_rate_info);
   1409 			}
   1410 
   1411 			r_rv = cb(unit, r_p_rate_info, userdata);
   1412 
   1413 			if (BCM_FAILURE(r_rv)) {
   1414 				break;
   1415 			}
   1416 		}
   1417 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   1418 	}
   1419 
   1420 	return r_rv;
   1421 }
   1422 
   1423 #ifdef	INCLUDE_L3
   1424 
   1425 int
   1426 bcm_client_ipmc_traverse(
   1427 	int	unit,
   1428 	uint32	flags,
   1429 	bcm_ipmc_traverse_cb	cb,
   1430 	void *	user_data)
   1431 {
   1432 	bcm_rlink_traverse_data_t	r_req;
   1433 	int	r_rv;
   1434 	uint32	r_key[] = {
   1435 		0xe6cd13ba,0x125638c6,0xbbe75b93,0x7e25925e,0x0d8b8c42 };
   1436 	bcm_ipmc_addr_t	r_info;
   1437 	bcm_ipmc_addr_t *	r_p_info;
   1438 
   1439 	sal_memset(&r_req, 0, sizeof(r_req));
   1440 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   1441 	if (BCM_SUCCESS(r_rv)) {
   1442 		/* Pack request */
   1443 		/* Skip unit */
   1444 		BCM_PACK_U32(r_req.tx_ptr, flags);
   1445 
   1446 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   1447 			/* Unpack reply */
   1448 			/* Skip unit */
   1449 			if (*r_req.rx_ptr++ == 1) {
   1450 				r_p_info = NULL;
   1451 			} else {
   1452 				r_p_info = &r_info;
   1453 				r_req.rx_ptr = _bcm_unpack_ipmc_addr(r_req.rx_ptr, r_p_info);
   1454 			}
   1455 
   1456 			r_rv = cb(unit, r_p_info, user_data);
   1457 
   1458 			if (BCM_FAILURE(r_rv)) {
   1459 				break;
   1460 			}
   1461 		}
   1462 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   1463 	}
   1464 
   1465 	return r_rv;
   1466 }
   1467 
   1468 #endif	/* INCLUDE_L3 */
   1469 
   1470 int
   1471 bcm_client_l2_auth_traverse(
   1472 	int	unit,
   1473 	bcm_l2_auth_traverse_cb	trav_fn,
   1474 	void *	user_data)
   1475 {
   1476 	bcm_rlink_traverse_data_t	r_req;
   1477 	int	r_rv;
   1478 	uint32	r_key[] = {
   1479 		0x9ec5f6e7,0x2f479259,0xc3625b7f,0xc9630cc7,0x2b8f401f };
   1480 	bcm_l2_auth_addr_t	r_info;
   1481 	bcm_l2_auth_addr_t *	r_p_info;
   1482 
   1483 	sal_memset(&r_req, 0, sizeof(r_req));
   1484 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   1485 	if (BCM_SUCCESS(r_rv)) {
   1486 		/* Pack request */
   1487 		/* Skip unit */
   1488 
   1489 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   1490 			/* Unpack reply */
   1491 			/* Skip unit */
   1492 			if (*r_req.rx_ptr++ == 1) {
   1493 				r_p_info = NULL;
   1494 			} else {
   1495 				r_p_info = &r_info;
   1496 				r_req.rx_ptr = _bcm_unpack_l2_auth_addr(r_req.rx_ptr, r_p_info);
   1497 			}
   1498 
   1499 			r_rv = trav_fn(unit, r_p_info, user_data);
   1500 
   1501 			if (BCM_FAILURE(r_rv)) {
   1502 				break;
   1503 			}
   1504 		}
   1505 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   1506 	}
   1507 
   1508 	return r_rv;
   1509 }
   1510 
   1511 #ifdef	INCLUDE_L3
   1512 
   1513 int
   1514 bcm_client_l2_change_fields_traverse(
   1515 	int	unit,
   1516 	bcm_l2_change_fields_traverse_cb	cb,
   1517 	void *	user_data)
   1518 {
   1519 	bcm_rlink_traverse_data_t	r_req;
   1520 	int	r_rv;
   1521 	uint32	r_key[] = {
   1522 		0xe0d937aa,0xd45dd961,0xb9e1228d,0x865531fc,0x3feb0e69 };
   1523 	bcm_l2_change_fields_t	r_l2_fields_info;
   1524 	bcm_l2_change_fields_t *	r_p_l2_fields_info;
   1525 
   1526 	sal_memset(&r_req, 0, sizeof(r_req));
   1527 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   1528 	if (BCM_SUCCESS(r_rv)) {
   1529 		/* Pack request */
   1530 		/* Skip unit */
   1531 
   1532 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   1533 			/* Unpack reply */
   1534 			/* Skip unit */
   1535 			if (*r_req.rx_ptr++ == 1) {
   1536 				r_p_l2_fields_info = NULL;
   1537 			} else {
   1538 				r_p_l2_fields_info = &r_l2_fields_info;
   1539 				r_req.rx_ptr = _bcm_unpack_l2_change_fields(r_req.rx_ptr, r_p_l2_fields_info);
   1540 			}
   1541 
   1542 			r_rv = cb(unit, r_p_l2_fields_info, user_data);
   1543 
   1544 			if (BCM_FAILURE(r_rv)) {
   1545 				break;
   1546 			}
   1547 		}
   1548 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   1549 	}
   1550 
   1551 	return r_rv;
   1552 }
   1553 
   1554 #endif	/* INCLUDE_L3 */
   1555 
   1556 int
   1557 bcm_client_l2_egress_traverse(
   1558 	int	unit,
   1559 	bcm_l2_egress_traverse_cb	trav_fn,
   1560 	void *	user_data)
   1561 {
   1562 	bcm_rlink_traverse_data_t	r_req;
   1563 	int	r_rv;
   1564 	uint32	r_key[] = {
   1565 		0xb8c6c76d,0x66647c41,0xaaf33868,0x35da5d0a,0x53e675bb };
   1566 	bcm_l2_egress_t	r_egr;
   1567 	bcm_l2_egress_t *	r_p_egr;
   1568 
   1569 	sal_memset(&r_req, 0, sizeof(r_req));
   1570 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   1571 	if (BCM_SUCCESS(r_rv)) {
   1572 		/* Pack request */
   1573 		/* Skip unit */
   1574 
   1575 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   1576 			/* Unpack reply */
   1577 			/* Skip unit */
   1578 			if (*r_req.rx_ptr++ == 1) {
   1579 				r_p_egr = NULL;
   1580 			} else {
   1581 				r_p_egr = &r_egr;
   1582 				r_req.rx_ptr = _bcm_unpack_l2_egress(r_req.rx_ptr, r_p_egr);
   1583 			}
   1584 
   1585 			r_rv = trav_fn(unit, r_p_egr, user_data);
   1586 
   1587 			if (BCM_FAILURE(r_rv)) {
   1588 				break;
   1589 			}
   1590 		}
   1591 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   1592 	}
   1593 
   1594 	return r_rv;
   1595 }
   1596 
   1597 int
   1598 bcm_client_l2_mac_port_traverse(
   1599 	int	unit,
   1600 	bcm_l2_mac_port_traverse_cb	cb,
   1601 	void *	user_data)
   1602 {
   1603 	bcm_rlink_traverse_data_t	r_req;
   1604 	int	r_rv;
   1605 	uint32	r_key[] = {
   1606 		0xe62643c8,0x8af78de7,0x9b5abb3c,0x5831fc7b,0x4ef6b3bc };
   1607 	bcm_l2_mac_port_t	r_mac_port;
   1608 	bcm_l2_mac_port_t *	r_p_mac_port;
   1609 
   1610 	sal_memset(&r_req, 0, sizeof(r_req));
   1611 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   1612 	if (BCM_SUCCESS(r_rv)) {
   1613 		/* Pack request */
   1614 		/* Skip unit */
   1615 
   1616 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   1617 			/* Unpack reply */
   1618 			/* Skip unit */
   1619 			if (*r_req.rx_ptr++ == 1) {
   1620 				r_p_mac_port = NULL;
   1621 			} else {
   1622 				r_p_mac_port = &r_mac_port;
   1623 				r_req.rx_ptr = _bcm_unpack_l2_mac_port(r_req.rx_ptr, r_p_mac_port);
   1624 			}
   1625 
   1626 			r_rv = cb(unit, r_p_mac_port, user_data);
   1627 
   1628 			if (BCM_FAILURE(r_rv)) {
   1629 				break;
   1630 			}
   1631 		}
   1632 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   1633 	}
   1634 
   1635 	return r_rv;
   1636 }
   1637 
   1638 int
   1639 bcm_client_l2_match_masked_traverse(
   1640 	int	unit,
   1641 	uint32	flags,
   1642 	bcm_l2_addr_t *	match_addr,
   1643 	bcm_l2_addr_t *	mask_addr,
   1644 	bcm_l2_traverse_cb	trav_fn,
   1645 	void *	user_data)
   1646 {
   1647 	bcm_rlink_traverse_data_t	r_req;
   1648 	int	r_rv;
   1649 	uint32	r_key[] = {
   1650 #ifndef	BCM_RPC_PBMP_64
   1651 		0x0396d57d,0x166559c9,0xbdc8e080,0x7734c265,0x5142f43f
   1652 #else
   1653 		0xf5ec06b5,0x2dd13ba9,0x061676c1,0x619a1933,0xae2fd4d2
   1654 #endif	/* BCM_RPC_PBMP_64 */
   1655 	};
   1656 	bcm_l2_addr_t	r_info;
   1657 	bcm_l2_addr_t *	r_p_info;
   1658 
   1659 	sal_memset(&r_req, 0, sizeof(r_req));
   1660 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   1661 	if (BCM_SUCCESS(r_rv)) {
   1662 		/* Pack request */
   1663 		/* Skip unit */
   1664 		BCM_PACK_U32(r_req.tx_ptr, flags);
   1665 		if (match_addr == NULL) {
   1666 			BCM_PACK_U8(r_req.tx_ptr, 1);
   1667 		} else {
   1668 			BCM_PACK_U8(r_req.tx_ptr, 0);
   1669 			r_req.tx_ptr = _bcm_pack_l2_addr(r_req.tx_ptr, match_addr);
   1670 		}
   1671 		if (mask_addr == NULL) {
   1672 			BCM_PACK_U8(r_req.tx_ptr, 1);
   1673 		} else {
   1674 			BCM_PACK_U8(r_req.tx_ptr, 0);
   1675 			r_req.tx_ptr = _bcm_pack_l2_addr(r_req.tx_ptr, mask_addr);
   1676 		}
   1677 
   1678 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   1679 			/* Unpack reply */
   1680 			/* Skip unit */
   1681 			if (*r_req.rx_ptr++ == 1) {
   1682 				r_p_info = NULL;
   1683 			} else {
   1684 				r_p_info = &r_info;
   1685 				r_req.rx_ptr = _bcm_unpack_l2_addr(r_req.rx_ptr, r_p_info);
   1686 			}
   1687 
   1688 			r_rv = trav_fn(unit, r_p_info, user_data);
   1689 
   1690 			if (BCM_FAILURE(r_rv)) {
   1691 				break;
   1692 			}
   1693 		}
   1694 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   1695 	}
   1696 
   1697 	return r_rv;
   1698 }
   1699 
   1700 int
   1701 bcm_client_l2_matched_traverse(
   1702 	int	unit,
   1703 	uint32	flags,
   1704 	bcm_l2_addr_t *	match_addr,
   1705 	bcm_l2_traverse_cb	trav_fn,
   1706 	void *	user_data)
   1707 {
   1708 	bcm_rlink_traverse_data_t	r_req;
   1709 	int	r_rv;
   1710 	uint32	r_key[] = {
   1711 #ifndef	BCM_RPC_PBMP_64
   1712 		0xa3a533b9,0xba88c109,0xe886451e,0xaecc1c4b,0x8b0c3ad9
   1713 #else
   1714 		0x8337bf80,0xf9c0065e,0xd49ac356,0x5bf4fb73,0x07303de9
   1715 #endif	/* BCM_RPC_PBMP_64 */
   1716 	};
   1717 	bcm_l2_addr_t	r_info;
   1718 	bcm_l2_addr_t *	r_p_info;
   1719 
   1720 	sal_memset(&r_req, 0, sizeof(r_req));
   1721 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   1722 	if (BCM_SUCCESS(r_rv)) {
   1723 		/* Pack request */
   1724 		/* Skip unit */
   1725 		BCM_PACK_U32(r_req.tx_ptr, flags);
   1726 		if (match_addr == NULL) {
   1727 			BCM_PACK_U8(r_req.tx_ptr, 1);
   1728 		} else {
   1729 			BCM_PACK_U8(r_req.tx_ptr, 0);
   1730 			r_req.tx_ptr = _bcm_pack_l2_addr(r_req.tx_ptr, match_addr);
   1731 		}
   1732 
   1733 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   1734 			/* Unpack reply */
   1735 			/* Skip unit */
   1736 			if (*r_req.rx_ptr++ == 1) {
   1737 				r_p_info = NULL;
   1738 			} else {
   1739 				r_p_info = &r_info;
   1740 				r_req.rx_ptr = _bcm_unpack_l2_addr(r_req.rx_ptr, r_p_info);
   1741 			}
   1742 
   1743 			r_rv = trav_fn(unit, r_p_info, user_data);
   1744 
   1745 			if (BCM_FAILURE(r_rv)) {
   1746 				break;
   1747 			}
   1748 		}
   1749 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   1750 	}
   1751 
   1752 	return r_rv;
   1753 }
   1754 
   1755 int
   1756 bcm_client_l2_station_traverse(
   1757 	int	unit,
   1758 	bcm_l2_station_traverse_cb	trav_fn,
   1759 	void *	user_data)
   1760 {
   1761 	bcm_rlink_traverse_data_t	r_req;
   1762 	int	r_rv;
   1763 	uint32	r_key[] = {
   1764 		0x0a2abfad,0xb9ef458a,0xd9875a99,0x33e667b4,0xd1a36089 };
   1765 	bcm_l2_station_t	r_l2_station_addr;
   1766 	bcm_l2_station_t *	r_p_l2_station_addr;
   1767 
   1768 	sal_memset(&r_req, 0, sizeof(r_req));
   1769 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   1770 	if (BCM_SUCCESS(r_rv)) {
   1771 		/* Pack request */
   1772 		/* Skip unit */
   1773 
   1774 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   1775 			/* Unpack reply */
   1776 			/* Skip unit */
   1777 			if (*r_req.rx_ptr++ == 1) {
   1778 				r_p_l2_station_addr = NULL;
   1779 			} else {
   1780 				r_p_l2_station_addr = &r_l2_station_addr;
   1781 				r_req.rx_ptr = _bcm_unpack_l2_station(r_req.rx_ptr, r_p_l2_station_addr);
   1782 			}
   1783 
   1784 			r_rv = trav_fn(unit, r_p_l2_station_addr, user_data);
   1785 
   1786 			if (BCM_FAILURE(r_rv)) {
   1787 				break;
   1788 			}
   1789 		}
   1790 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   1791 	}
   1792 
   1793 	return r_rv;
   1794 }
   1795 
   1796 int
   1797 bcm_client_l2_traverse(
   1798 	int	unit,
   1799 	bcm_l2_traverse_cb	trav_fn,
   1800 	void *	user_data)
   1801 {
   1802 	bcm_rlink_traverse_data_t	r_req;
   1803 	int	r_rv;
   1804 	uint32	r_key[] = {
   1805 		0x60a22b31,0x6ec6ca4f,0xe1b0ce78,0xee3264b2,0x1e544bd4 };
   1806 	bcm_l2_addr_t	r_info;
   1807 	bcm_l2_addr_t *	r_p_info;
   1808 
   1809 	sal_memset(&r_req, 0, sizeof(r_req));
   1810 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   1811 	if (BCM_SUCCESS(r_rv)) {
   1812 		/* Pack request */
   1813 		/* Skip unit */
   1814 
   1815 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   1816 			/* Unpack reply */
   1817 			/* Skip unit */
   1818 			if (*r_req.rx_ptr++ == 1) {
   1819 				r_p_info = NULL;
   1820 			} else {
   1821 				r_p_info = &r_info;
   1822 				r_req.rx_ptr = _bcm_unpack_l2_addr(r_req.rx_ptr, r_p_info);
   1823 			}
   1824 
   1825 			r_rv = trav_fn(unit, r_p_info, user_data);
   1826 
   1827 			if (BCM_FAILURE(r_rv)) {
   1828 				break;
   1829 			}
   1830 		}
   1831 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   1832 	}
   1833 
   1834 	return r_rv;
   1835 }
   1836 
   1837 #ifdef	INCLUDE_L3
   1838 
   1839 int
   1840 bcm_client_l2gre_tunnel_initiator_traverse(
   1841 	int	unit,
   1842 	bcm_tunnel_initiator_traverse_cb	cb,
   1843 	void *	user_data)
   1844 {
   1845 	bcm_rlink_traverse_data_t	r_req;
   1846 	int	r_rv;
   1847 	uint32	r_key[] = {
   1848 		0x5930b6da,0xe0ea0015,0x7ec8c0bd,0xe95b013f,0x856bac4c };
   1849 	bcm_tunnel_initiator_t	r_info;
   1850 	bcm_tunnel_initiator_t *	r_p_info;
   1851 
   1852 	sal_memset(&r_req, 0, sizeof(r_req));
   1853 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   1854 	if (BCM_SUCCESS(r_rv)) {
   1855 		/* Pack request */
   1856 		/* Skip unit */
   1857 
   1858 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   1859 			/* Unpack reply */
   1860 			/* Skip unit */
   1861 			if (*r_req.rx_ptr++ == 1) {
   1862 				r_p_info = NULL;
   1863 			} else {
   1864 				r_p_info = &r_info;
   1865 				r_req.rx_ptr = _bcm_unpack_tunnel_initiator(r_req.rx_ptr, r_p_info);
   1866 			}
   1867 
   1868 			r_rv = cb(unit, r_p_info, user_data);
   1869 
   1870 			if (BCM_FAILURE(r_rv)) {
   1871 				break;
   1872 			}
   1873 		}
   1874 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   1875 	}
   1876 
   1877 	return r_rv;
   1878 }
   1879 
   1880 int
   1881 bcm_client_l2gre_tunnel_terminator_traverse(
   1882 	int	unit,
   1883 	bcm_tunnel_terminator_traverse_cb	cb,
   1884 	void *	user_data)
   1885 {
   1886 	bcm_rlink_traverse_data_t	r_req;
   1887 	int	r_rv;
   1888 	uint32	r_key[] = {
   1889 		0x4e505a92,0x21e818f4,0x37e0072f,0xd5c79292,0x4a7a67a2 };
   1890 	bcm_tunnel_terminator_t	r_info;
   1891 	bcm_tunnel_terminator_t *	r_p_info;
   1892 
   1893 	sal_memset(&r_req, 0, sizeof(r_req));
   1894 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   1895 	if (BCM_SUCCESS(r_rv)) {
   1896 		/* Pack request */
   1897 		/* Skip unit */
   1898 
   1899 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   1900 			/* Unpack reply */
   1901 			/* Skip unit */
   1902 			if (*r_req.rx_ptr++ == 1) {
   1903 				r_p_info = NULL;
   1904 			} else {
   1905 				r_p_info = &r_info;
   1906 				r_req.rx_ptr = _bcm_unpack_tunnel_terminator(r_req.rx_ptr, r_p_info);
   1907 			}
   1908 
   1909 			r_rv = cb(unit, r_p_info, user_data);
   1910 
   1911 			if (BCM_FAILURE(r_rv)) {
   1912 				break;
   1913 			}
   1914 		}
   1915 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   1916 	}
   1917 
   1918 	return r_rv;
   1919 }
   1920 
   1921 int
   1922 bcm_client_l2gre_vpn_traverse(
   1923 	int	unit,
   1924 	bcm_l2gre_vpn_traverse_cb	cb,
   1925 	void *	user_data)
   1926 {
   1927 	bcm_rlink_traverse_data_t	r_req;
   1928 	int	r_rv;
   1929 	uint32	r_key[] = {
   1930 		0x0a1e5cfa,0x9f4444e7,0xb2958c32,0x3a17c284,0x98f9394a };
   1931 	bcm_l2gre_vpn_config_t	r_info;
   1932 	bcm_l2gre_vpn_config_t *	r_p_info;
   1933 
   1934 	sal_memset(&r_req, 0, sizeof(r_req));
   1935 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   1936 	if (BCM_SUCCESS(r_rv)) {
   1937 		/* Pack request */
   1938 		/* Skip unit */
   1939 
   1940 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   1941 			/* Unpack reply */
   1942 			/* Skip unit */
   1943 			if (*r_req.rx_ptr++ == 1) {
   1944 				r_p_info = NULL;
   1945 			} else {
   1946 				r_p_info = &r_info;
   1947 				r_req.rx_ptr = _bcm_unpack_l2gre_vpn_config(r_req.rx_ptr, r_p_info);
   1948 			}
   1949 
   1950 			r_rv = cb(unit, r_p_info, user_data);
   1951 
   1952 			if (BCM_FAILURE(r_rv)) {
   1953 				break;
   1954 			}
   1955 		}
   1956 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   1957 	}
   1958 
   1959 	return r_rv;
   1960 }
   1961 
   1962 int
   1963 bcm_client_l3_ecmp_traverse(
   1964 	int	unit,
   1965 	bcm_l3_ecmp_traverse_cb	trav_fn,
   1966 	void *	user_data)
   1967 {
   1968 	bcm_rlink_traverse_data_t	r_req;
   1969 	int	r_rv;
   1970 	int	r_i;
   1971 	uint32	r_key[] = {
   1972 		0x61c3ab33,0xa8a60460,0xb2413345,0xf7c9766c,0xa8184f60 };
   1973 	bcm_l3_egress_ecmp_t	r_ecmp_info;
   1974 	int	r_ecmp_member_count;
   1975 	bcm_l3_egress_ecmp_t *	r_p_ecmp_info;
   1976 	bcm_l3_ecmp_member_t *	r_p_ecmp_member_array;
   1977 
   1978 	sal_memset(&r_req, 0, sizeof(r_req));
   1979 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   1980 	if (BCM_SUCCESS(r_rv)) {
   1981 		/* Pack request */
   1982 		/* Skip unit */
   1983 
   1984 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   1985 			/* Unpack reply */
   1986 			r_rv = BCM_E_NONE;
   1987 			/* Skip unit */
   1988 			if (*r_req.rx_ptr++ == 1) {
   1989 				r_p_ecmp_info = NULL;
   1990 			} else {
   1991 				r_p_ecmp_info = &r_ecmp_info;
   1992 				r_req.rx_ptr = _bcm_unpack_l3_egress_ecmp(r_req.rx_ptr, r_p_ecmp_info);
   1993 			}
   1994 			BCM_UNPACK_U32(r_req.rx_ptr, r_ecmp_member_count);
   1995 			if (*r_req.rx_ptr++ == 1) {
   1996 				r_p_ecmp_member_array = NULL;
   1997 			} else {
   1998 				r_p_ecmp_member_array = sal_alloc(r_ecmp_member_count*sizeof(bcm_l3_ecmp_member_t), "traverse r_ecmp_member_array");
   1999 				if (r_p_ecmp_member_array == NULL) {
   2000 					r_rv = BCM_E_MEMORY;
   2001 				} else {
   2002 					for (r_i = 0; r_i < r_ecmp_member_count; r_i++) {
   2003 						r_req.rx_ptr = _bcm_unpack_l3_ecmp_member(r_req.rx_ptr, r_p_ecmp_member_array+r_i);
   2004 					}
   2005 				}
   2006 			}
   2007 
   2008 			if (BCM_SUCCESS(r_rv)) {
   2009 				r_rv = trav_fn(unit, r_p_ecmp_info, r_ecmp_member_count, r_p_ecmp_member_array, user_data);
   2010 			}
   2011 
   2012 			if (r_p_ecmp_member_array != NULL) {
   2013 				sal_free(r_p_ecmp_member_array);
   2014 			}
   2015 
   2016 			if (BCM_FAILURE(r_rv)) {
   2017 				break;
   2018 			}
   2019 		}
   2020 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   2021 	}
   2022 
   2023 	return r_rv;
   2024 }
   2025 
   2026 int
   2027 bcm_client_l3_egress_arp_traverse(
   2028 	int	unit,
   2029 	bcm_l3_egress_traverse_cb	trav_fn,
   2030 	void *	user_data)
   2031 {
   2032 	bcm_rlink_traverse_data_t	r_req;
   2033 	int	r_rv;
   2034 	uint32	r_key[] = {
   2035 		0xafff1cdc,0x187fb02c,0x1ad2b98b,0xdb01f81d,0x81afe9a7 };
   2036 	bcm_if_t	r_intf;
   2037 	bcm_l3_egress_t	r_info;
   2038 	bcm_l3_egress_t *	r_p_info;
   2039 
   2040 	sal_memset(&r_req, 0, sizeof(r_req));
   2041 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   2042 	if (BCM_SUCCESS(r_rv)) {
   2043 		/* Pack request */
   2044 		/* Skip unit */
   2045 
   2046 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   2047 			/* Unpack reply */
   2048 			/* Skip unit */
   2049 			BCM_UNPACK_U32(r_req.rx_ptr, r_intf);
   2050 			if (*r_req.rx_ptr++ == 1) {
   2051 				r_p_info = NULL;
   2052 			} else {
   2053 				r_p_info = &r_info;
   2054 				r_req.rx_ptr = _bcm_unpack_l3_egress(r_req.rx_ptr, r_p_info);
   2055 			}
   2056 
   2057 			r_rv = trav_fn(unit, r_intf, r_p_info, user_data);
   2058 
   2059 			if (BCM_FAILURE(r_rv)) {
   2060 				break;
   2061 			}
   2062 		}
   2063 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   2064 	}
   2065 
   2066 	return r_rv;
   2067 }
   2068 
   2069 int
   2070 bcm_client_l3_egress_ecmp_resilient_traverse(
   2071 	int	unit,
   2072 	uint32	flags,
   2073 	bcm_l3_egress_ecmp_resilient_entry_t *	match_entry,
   2074 	bcm_l3_egress_ecmp_resilient_traverse_cb	trav_fn,
   2075 	void *	user_data)
   2076 {
   2077 	bcm_rlink_traverse_data_t	r_req;
   2078 	int	r_rv;
   2079 	uint32	r_key[] = {
   2080 		0xbf99b390,0xccf9cdce,0x076e8030,0xc9b9472f,0xa9e73130 };
   2081 	bcm_l3_egress_ecmp_resilient_entry_t	r_entry;
   2082 	bcm_l3_egress_ecmp_resilient_entry_t *	r_p_entry;
   2083 
   2084 	sal_memset(&r_req, 0, sizeof(r_req));
   2085 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   2086 	if (BCM_SUCCESS(r_rv)) {
   2087 		/* Pack request */
   2088 		/* Skip unit */
   2089 		BCM_PACK_U32(r_req.tx_ptr, flags);
   2090 		if (match_entry == NULL) {
   2091 			BCM_PACK_U8(r_req.tx_ptr, 1);
   2092 		} else {
   2093 			BCM_PACK_U8(r_req.tx_ptr, 0);
   2094 			r_req.tx_ptr = _bcm_pack_l3_egress_ecmp_resilient_entry(r_req.tx_ptr, match_entry);
   2095 		}
   2096 
   2097 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   2098 			/* Unpack reply */
   2099 			/* Skip unit */
   2100 			if (*r_req.rx_ptr++ == 1) {
   2101 				r_p_entry = NULL;
   2102 			} else {
   2103 				r_p_entry = &r_entry;
   2104 				r_req.rx_ptr = _bcm_unpack_l3_egress_ecmp_resilient_entry(r_req.rx_ptr, r_p_entry);
   2105 			}
   2106 
   2107 			r_rv = trav_fn(unit, r_p_entry, user_data);
   2108 
   2109 			if (BCM_FAILURE(r_rv)) {
   2110 				break;
   2111 			}
   2112 		}
   2113 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   2114 	}
   2115 
   2116 	return r_rv;
   2117 }
   2118 
   2119 int
   2120 bcm_client_l3_egress_ecmp_traverse(
   2121 	int	unit,
   2122 	bcm_l3_egress_ecmp_traverse_cb	trav_fn,
   2123 	void *	user_data)
   2124 {
   2125 	bcm_rlink_traverse_data_t	r_req;
   2126 	int	r_rv;
   2127 	int	r_i;
   2128 	uint32	r_key[] = {
   2129 		0x6e067c6f,0xe832c80e,0x240868d6,0x83302b31,0x92c7a1e7 };
   2130 	bcm_l3_egress_ecmp_t	r_ecmp;
   2131 	int	r_intf_count;
   2132 	bcm_l3_egress_ecmp_t *	r_p_ecmp;
   2133 	bcm_if_t *	r_p_intf_array;
   2134 
   2135 	sal_memset(&r_req, 0, sizeof(r_req));
   2136 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   2137 	if (BCM_SUCCESS(r_rv)) {
   2138 		/* Pack request */
   2139 		/* Skip unit */
   2140 
   2141 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   2142 			/* Unpack reply */
   2143 			r_rv = BCM_E_NONE;
   2144 			/* Skip unit */
   2145 			if (*r_req.rx_ptr++ == 1) {
   2146 				r_p_ecmp = NULL;
   2147 			} else {
   2148 				r_p_ecmp = &r_ecmp;
   2149 				r_req.rx_ptr = _bcm_unpack_l3_egress_ecmp(r_req.rx_ptr, r_p_ecmp);
   2150 			}
   2151 			BCM_UNPACK_U32(r_req.rx_ptr, r_intf_count);
   2152 			if (*r_req.rx_ptr++ == 1) {
   2153 				r_p_intf_array = NULL;
   2154 			} else {
   2155 				r_p_intf_array = sal_alloc(r_intf_count*sizeof(bcm_if_t), "traverse r_intf_array");
   2156 				if (r_p_intf_array == NULL) {
   2157 					r_rv = BCM_E_MEMORY;
   2158 				} else {
   2159 					for (r_i = 0; r_i < r_intf_count; r_i++) {
   2160 						BCM_UNPACK_U32(r_req.rx_ptr, *(r_p_intf_array+r_i));
   2161 					}
   2162 				}
   2163 			}
   2164 
   2165 			if (BCM_SUCCESS(r_rv)) {
   2166 				r_rv = trav_fn(unit, r_p_ecmp, r_intf_count, r_p_intf_array, user_data);
   2167 			}
   2168 
   2169 			if (r_p_intf_array != NULL) {
   2170 				sal_free(r_p_intf_array);
   2171 			}
   2172 
   2173 			if (BCM_FAILURE(r_rv)) {
   2174 				break;
   2175 			}
   2176 		}
   2177 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   2178 	}
   2179 
   2180 	return r_rv;
   2181 }
   2182 
   2183 int
   2184 bcm_client_l3_egress_multipath_traverse(
   2185 	int	unit,
   2186 	bcm_l3_egress_multipath_traverse_cb	trav_fn,
   2187 	void *	user_data)
   2188 {
   2189 	bcm_rlink_traverse_data_t	r_req;
   2190 	int	r_rv;
   2191 	int	r_i;
   2192 	uint32	r_key[] = {
   2193 		0x22876dbb,0x559c93df,0x84dcc649,0x6d3fe0ae,0x14dbec70 };
   2194 	bcm_if_t	r_mpintf;
   2195 	int	r_intf_count;
   2196 	bcm_if_t *	r_p_intf_array;
   2197 
   2198 	sal_memset(&r_req, 0, sizeof(r_req));
   2199 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   2200 	if (BCM_SUCCESS(r_rv)) {
   2201 		/* Pack request */
   2202 		/* Skip unit */
   2203 
   2204 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   2205 			/* Unpack reply */
   2206 			r_rv = BCM_E_NONE;
   2207 			/* Skip unit */
   2208 			BCM_UNPACK_U32(r_req.rx_ptr, r_mpintf);
   2209 			BCM_UNPACK_U32(r_req.rx_ptr, r_intf_count);
   2210 			if (*r_req.rx_ptr++ == 1) {
   2211 				r_p_intf_array = NULL;
   2212 			} else {
   2213 				r_p_intf_array = sal_alloc(r_intf_count*sizeof(bcm_if_t), "traverse r_intf_array");
   2214 				if (r_p_intf_array == NULL) {
   2215 					r_rv = BCM_E_MEMORY;
   2216 				} else {
   2217 					for (r_i = 0; r_i < r_intf_count; r_i++) {
   2218 						BCM_UNPACK_U32(r_req.rx_ptr, *(r_p_intf_array+r_i));
   2219 					}
   2220 				}
   2221 			}
   2222 
   2223 			if (BCM_SUCCESS(r_rv)) {
   2224 				r_rv = trav_fn(unit, r_mpintf, r_intf_count, r_p_intf_array, user_data);
   2225 			}
   2226 
   2227 			if (r_p_intf_array != NULL) {
   2228 				sal_free(r_p_intf_array);
   2229 			}
   2230 
   2231 			if (BCM_FAILURE(r_rv)) {
   2232 				break;
   2233 			}
   2234 		}
   2235 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   2236 	}
   2237 
   2238 	return r_rv;
   2239 }
   2240 
   2241 int
   2242 bcm_client_l3_egress_traverse(
   2243 	int	unit,
   2244 	bcm_l3_egress_traverse_cb	trav_fn,
   2245 	void *	user_data)
   2246 {
   2247 	bcm_rlink_traverse_data_t	r_req;
   2248 	int	r_rv;
   2249 	uint32	r_key[] = {
   2250 		0x5ab66d8d,0x122fdf0c,0x33bd285e,0x1f8c56ed,0x1ad886d3 };
   2251 	bcm_if_t	r_intf;
   2252 	bcm_l3_egress_t	r_info;
   2253 	bcm_l3_egress_t *	r_p_info;
   2254 
   2255 	sal_memset(&r_req, 0, sizeof(r_req));
   2256 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   2257 	if (BCM_SUCCESS(r_rv)) {
   2258 		/* Pack request */
   2259 		/* Skip unit */
   2260 
   2261 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   2262 			/* Unpack reply */
   2263 			/* Skip unit */
   2264 			BCM_UNPACK_U32(r_req.rx_ptr, r_intf);
   2265 			if (*r_req.rx_ptr++ == 1) {
   2266 				r_p_info = NULL;
   2267 			} else {
   2268 				r_p_info = &r_info;
   2269 				r_req.rx_ptr = _bcm_unpack_l3_egress(r_req.rx_ptr, r_p_info);
   2270 			}
   2271 
   2272 			r_rv = trav_fn(unit, r_intf, r_p_info, user_data);
   2273 
   2274 			if (BCM_FAILURE(r_rv)) {
   2275 				break;
   2276 			}
   2277 		}
   2278 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   2279 	}
   2280 
   2281 	return r_rv;
   2282 }
   2283 
   2284 int
   2285 bcm_client_l3_host_traverse(
   2286 	int	unit,
   2287 	uint32	flags,
   2288 	uint32	start,
   2289 	uint32	end,
   2290 	bcm_l3_host_traverse_cb	cb,
   2291 	void *	user_data)
   2292 {
   2293 	bcm_rlink_traverse_data_t	r_req;
   2294 	int	r_rv;
   2295 	uint32	r_key[] = {
   2296 		0x65fa4078,0x7c353975,0xc28647e2,0x1d35a278,0xcbaeef5d };
   2297 	int	r_index;
   2298 	bcm_l3_host_t	r_info;
   2299 	bcm_l3_host_t *	r_p_info;
   2300 
   2301 	sal_memset(&r_req, 0, sizeof(r_req));
   2302 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   2303 	if (BCM_SUCCESS(r_rv)) {
   2304 		/* Pack request */
   2305 		/* Skip unit */
   2306 		BCM_PACK_U32(r_req.tx_ptr, flags);
   2307 		BCM_PACK_U32(r_req.tx_ptr, start);
   2308 		BCM_PACK_U32(r_req.tx_ptr, end);
   2309 
   2310 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   2311 			/* Unpack reply */
   2312 			/* Skip unit */
   2313 			BCM_UNPACK_U32(r_req.rx_ptr, r_index);
   2314 			if (*r_req.rx_ptr++ == 1) {
   2315 				r_p_info = NULL;
   2316 			} else {
   2317 				r_p_info = &r_info;
   2318 				r_req.rx_ptr = _bcm_unpack_l3_host(r_req.rx_ptr, r_p_info);
   2319 			}
   2320 
   2321 			r_rv = cb(unit, r_index, r_p_info, user_data);
   2322 
   2323 			if (BCM_FAILURE(r_rv)) {
   2324 				break;
   2325 			}
   2326 		}
   2327 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   2328 	}
   2329 
   2330 	return r_rv;
   2331 }
   2332 
   2333 int
   2334 bcm_client_l3_ingress_traverse(
   2335 	int	unit,
   2336 	bcm_l3_ingress_traverse_cb	trav_fn,
   2337 	void *	user_data)
   2338 {
   2339 	bcm_rlink_traverse_data_t	r_req;
   2340 	int	r_rv;
   2341 	uint32	r_key[] = {
   2342 		0x167de67a,0x4556a271,0xdc2c824a,0x9422f096,0x666e0a05 };
   2343 	bcm_if_t	r_intf_id;
   2344 	bcm_l3_ingress_t	r_ing_intf;
   2345 	bcm_l3_ingress_t *	r_p_ing_intf;
   2346 
   2347 	sal_memset(&r_req, 0, sizeof(r_req));
   2348 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   2349 	if (BCM_SUCCESS(r_rv)) {
   2350 		/* Pack request */
   2351 		/* Skip unit */
   2352 
   2353 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   2354 			/* Unpack reply */
   2355 			/* Skip unit */
   2356 			BCM_UNPACK_U32(r_req.rx_ptr, r_intf_id);
   2357 			if (*r_req.rx_ptr++ == 1) {
   2358 				r_p_ing_intf = NULL;
   2359 			} else {
   2360 				r_p_ing_intf = &r_ing_intf;
   2361 				r_req.rx_ptr = _bcm_unpack_l3_ingress(r_req.rx_ptr, r_p_ing_intf);
   2362 			}
   2363 
   2364 			r_rv = trav_fn(unit, r_intf_id, r_p_ing_intf, user_data);
   2365 
   2366 			if (BCM_FAILURE(r_rv)) {
   2367 				break;
   2368 			}
   2369 		}
   2370 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   2371 	}
   2372 
   2373 	return r_rv;
   2374 }
   2375 
   2376 int
   2377 bcm_client_l3_large_nat_egress_traverse(
   2378 	int	unit,
   2379 	bcm_l3_large_nat_egress_traverse_cb	cb,
   2380 	void *	user_data)
   2381 {
   2382 	bcm_rlink_traverse_data_t	r_req;
   2383 	int	r_rv;
   2384 	uint32	r_key[] = {
   2385 		0x69af71dc,0x705dd0c4,0xc00705b8,0xdbe5a092,0xcb22060f };
   2386 	bcm_l3_large_nat_egress_t	r_nat_info;
   2387 	bcm_l3_large_nat_egress_t *	r_p_nat_info;
   2388 
   2389 	sal_memset(&r_req, 0, sizeof(r_req));
   2390 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   2391 	if (BCM_SUCCESS(r_rv)) {
   2392 		/* Pack request */
   2393 		/* Skip unit */
   2394 
   2395 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   2396 			/* Unpack reply */
   2397 			/* Skip unit */
   2398 			if (*r_req.rx_ptr++ == 1) {
   2399 				r_p_nat_info = NULL;
   2400 			} else {
   2401 				r_p_nat_info = &r_nat_info;
   2402 				r_req.rx_ptr = _bcm_unpack_l3_large_nat_egress(r_req.rx_ptr, r_p_nat_info);
   2403 			}
   2404 
   2405 			r_rv = cb(unit, r_p_nat_info, user_data);
   2406 
   2407 			if (BCM_FAILURE(r_rv)) {
   2408 				break;
   2409 			}
   2410 		}
   2411 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   2412 	}
   2413 
   2414 	return r_rv;
   2415 }
   2416 
   2417 int
   2418 bcm_client_l3_nat_egress_traverse(
   2419 	int	unit,
   2420 	uint32	flags,
   2421 	uint32	start,
   2422 	uint32	end,
   2423 	bcm_l3_nat_egress_traverse_cb	cb,
   2424 	void *	user_data)
   2425 {
   2426 	bcm_rlink_traverse_data_t	r_req;
   2427 	int	r_rv;
   2428 	uint32	r_key[] = {
   2429 		0xa1121fdb,0x44050e85,0x65ebc921,0xb733a73a,0xf5017ada };
   2430 	int	r_index;
   2431 	bcm_l3_nat_egress_t	r_nat_info;
   2432 	bcm_l3_nat_egress_t *	r_p_nat_info;
   2433 
   2434 	sal_memset(&r_req, 0, sizeof(r_req));
   2435 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   2436 	if (BCM_SUCCESS(r_rv)) {
   2437 		/* Pack request */
   2438 		/* Skip unit */
   2439 		BCM_PACK_U32(r_req.tx_ptr, flags);
   2440 		BCM_PACK_U32(r_req.tx_ptr, start);
   2441 		BCM_PACK_U32(r_req.tx_ptr, end);
   2442 
   2443 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   2444 			/* Unpack reply */
   2445 			/* Skip unit */
   2446 			BCM_UNPACK_U32(r_req.rx_ptr, r_index);
   2447 			if (*r_req.rx_ptr++ == 1) {
   2448 				r_p_nat_info = NULL;
   2449 			} else {
   2450 				r_p_nat_info = &r_nat_info;
   2451 				r_req.rx_ptr = _bcm_unpack_l3_nat_egress(r_req.rx_ptr, r_p_nat_info);
   2452 			}
   2453 
   2454 			r_rv = cb(unit, r_index, r_p_nat_info, user_data);
   2455 
   2456 			if (BCM_FAILURE(r_rv)) {
   2457 				break;
   2458 			}
   2459 		}
   2460 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   2461 	}
   2462 
   2463 	return r_rv;
   2464 }
   2465 
   2466 int
   2467 bcm_client_l3_nat_ingress_traverse(
   2468 	int	unit,
   2469 	uint32	flags,
   2470 	uint32	start,
   2471 	uint32	end,
   2472 	bcm_l3_nat_ingress_traverse_cb	cb,
   2473 	void *	user_data)
   2474 {
   2475 	bcm_rlink_traverse_data_t	r_req;
   2476 	int	r_rv;
   2477 	uint32	r_key[] = {
   2478 		0xd28cc963,0xe38b1845,0xd4394a78,0xc171d148,0x12286049 };
   2479 	int	r_index;
   2480 	bcm_l3_nat_ingress_t	r_nat_info;
   2481 	bcm_l3_nat_ingress_t *	r_p_nat_info;
   2482 
   2483 	sal_memset(&r_req, 0, sizeof(r_req));
   2484 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   2485 	if (BCM_SUCCESS(r_rv)) {
   2486 		/* Pack request */
   2487 		/* Skip unit */
   2488 		BCM_PACK_U32(r_req.tx_ptr, flags);
   2489 		BCM_PACK_U32(r_req.tx_ptr, start);
   2490 		BCM_PACK_U32(r_req.tx_ptr, end);
   2491 
   2492 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   2493 			/* Unpack reply */
   2494 			/* Skip unit */
   2495 			BCM_UNPACK_U32(r_req.rx_ptr, r_index);
   2496 			if (*r_req.rx_ptr++ == 1) {
   2497 				r_p_nat_info = NULL;
   2498 			} else {
   2499 				r_p_nat_info = &r_nat_info;
   2500 				r_req.rx_ptr = _bcm_unpack_l3_nat_ingress(r_req.rx_ptr, r_p_nat_info);
   2501 			}
   2502 
   2503 			r_rv = cb(unit, r_index, r_p_nat_info, user_data);
   2504 
   2505 			if (BCM_FAILURE(r_rv)) {
   2506 				break;
   2507 			}
   2508 		}
   2509 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   2510 	}
   2511 
   2512 	return r_rv;
   2513 }
   2514 
   2515 int
   2516 bcm_client_l3_route_traverse(
   2517 	int	unit,
   2518 	uint32	flags,
   2519 	uint32	start,
   2520 	uint32	end,
   2521 	bcm_l3_route_traverse_cb	trav_fn,
   2522 	void *	user_data)
   2523 {
   2524 	bcm_rlink_traverse_data_t	r_req;
   2525 	int	r_rv;
   2526 	uint32	r_key[] = {
   2527 		0x3abb9ca2,0x9b9849d1,0x3fa6df34,0x889a975e,0xf18da8c9 };
   2528 	int	r_index;
   2529 	bcm_l3_route_t	r_info;
   2530 	bcm_l3_route_t *	r_p_info;
   2531 
   2532 	sal_memset(&r_req, 0, sizeof(r_req));
   2533 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   2534 	if (BCM_SUCCESS(r_rv)) {
   2535 		/* Pack request */
   2536 		/* Skip unit */
   2537 		BCM_PACK_U32(r_req.tx_ptr, flags);
   2538 		BCM_PACK_U32(r_req.tx_ptr, start);
   2539 		BCM_PACK_U32(r_req.tx_ptr, end);
   2540 
   2541 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   2542 			/* Unpack reply */
   2543 			/* Skip unit */
   2544 			BCM_UNPACK_U32(r_req.rx_ptr, r_index);
   2545 			if (*r_req.rx_ptr++ == 1) {
   2546 				r_p_info = NULL;
   2547 			} else {
   2548 				r_p_info = &r_info;
   2549 				r_req.rx_ptr = _bcm_unpack_l3_route(r_req.rx_ptr, r_p_info);
   2550 			}
   2551 
   2552 			r_rv = trav_fn(unit, r_index, r_p_info, user_data);
   2553 
   2554 			if (BCM_FAILURE(r_rv)) {
   2555 				break;
   2556 			}
   2557 		}
   2558 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   2559 	}
   2560 
   2561 	return r_rv;
   2562 }
   2563 
   2564 int
   2565 bcm_client_l3_source_bind_traverse(
   2566 	int	unit,
   2567 	bcm_l3_source_bind_traverse_cb	cb,
   2568 	void *	user_data)
   2569 {
   2570 	bcm_rlink_traverse_data_t	r_req;
   2571 	int	r_rv;
   2572 	uint32	r_key[] = {
   2573 		0xd2779d49,0xa91716ef,0xd4db8d97,0x5419c650,0xceaaa2c9 };
   2574 	bcm_l3_source_bind_t	r_info;
   2575 	bcm_l3_source_bind_t *	r_p_info;
   2576 
   2577 	sal_memset(&r_req, 0, sizeof(r_req));
   2578 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   2579 	if (BCM_SUCCESS(r_rv)) {
   2580 		/* Pack request */
   2581 		/* Skip unit */
   2582 
   2583 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   2584 			/* Unpack reply */
   2585 			/* Skip unit */
   2586 			if (*r_req.rx_ptr++ == 1) {
   2587 				r_p_info = NULL;
   2588 			} else {
   2589 				r_p_info = &r_info;
   2590 				r_req.rx_ptr = _bcm_unpack_l3_source_bind(r_req.rx_ptr, r_p_info);
   2591 			}
   2592 
   2593 			r_rv = cb(unit, r_p_info, user_data);
   2594 
   2595 			if (BCM_FAILURE(r_rv)) {
   2596 				break;
   2597 			}
   2598 		}
   2599 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   2600 	}
   2601 
   2602 	return r_rv;
   2603 }
   2604 
   2605 int
   2606 bcm_client_l3_vpbr_traverse(
   2607 	int	unit,
   2608 	uint32	flags,
   2609 	bcm_l3_vpbr_traverse_cb	cb,
   2610 	void *	user_data)
   2611 {
   2612 	bcm_rlink_traverse_data_t	r_req;
   2613 	int	r_rv;
   2614 	uint32	r_key[] = {
   2615 		0x13d58d97,0x0d995f47,0xa89f8451,0x6c40eab3,0x5d749ca9 };
   2616 	bcm_l3_vpbr_entry_t	r_entry;
   2617 	bcm_l3_vpbr_entry_t *	r_p_entry;
   2618 
   2619 	sal_memset(&r_req, 0, sizeof(r_req));
   2620 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   2621 	if (BCM_SUCCESS(r_rv)) {
   2622 		/* Pack request */
   2623 		/* Skip unit */
   2624 		BCM_PACK_U32(r_req.tx_ptr, flags);
   2625 
   2626 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   2627 			/* Unpack reply */
   2628 			/* Skip unit */
   2629 			if (*r_req.rx_ptr++ == 1) {
   2630 				r_p_entry = NULL;
   2631 			} else {
   2632 				r_p_entry = &r_entry;
   2633 				r_req.rx_ptr = _bcm_unpack_l3_vpbr_entry(r_req.rx_ptr, r_p_entry);
   2634 			}
   2635 
   2636 			r_rv = cb(unit, r_p_entry, user_data);
   2637 
   2638 			if (BCM_FAILURE(r_rv)) {
   2639 				break;
   2640 			}
   2641 		}
   2642 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   2643 	}
   2644 
   2645 	return r_rv;
   2646 }
   2647 
   2648 int
   2649 bcm_client_mim_vpn_traverse(
   2650 	int	unit,
   2651 	bcm_mim_vpn_traverse_cb	cb,
   2652 	void *	user_data)
   2653 {
   2654 	bcm_rlink_traverse_data_t	r_req;
   2655 	int	r_rv;
   2656 	uint32	r_key[] = {
   2657 		0x532bf474,0x5fc8a40c,0x05cfbef4,0x927b5787,0x09fc1173 };
   2658 	bcm_mim_vpn_config_t	r_info;
   2659 	bcm_mim_vpn_config_t *	r_p_info;
   2660 
   2661 	sal_memset(&r_req, 0, sizeof(r_req));
   2662 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   2663 	if (BCM_SUCCESS(r_rv)) {
   2664 		/* Pack request */
   2665 		/* Skip unit */
   2666 
   2667 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   2668 			/* Unpack reply */
   2669 			/* Skip unit */
   2670 			if (*r_req.rx_ptr++ == 1) {
   2671 				r_p_info = NULL;
   2672 			} else {
   2673 				r_p_info = &r_info;
   2674 				r_req.rx_ptr = _bcm_unpack_mim_vpn_config(r_req.rx_ptr, r_p_info);
   2675 			}
   2676 
   2677 			r_rv = cb(unit, r_p_info, user_data);
   2678 
   2679 			if (BCM_FAILURE(r_rv)) {
   2680 				break;
   2681 			}
   2682 		}
   2683 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   2684 	}
   2685 
   2686 	return r_rv;
   2687 }
   2688 
   2689 #endif	/* INCLUDE_L3 */
   2690 
   2691 int
   2692 bcm_client_mirror_destination_traverse(
   2693 	int	unit,
   2694 	bcm_mirror_destination_traverse_cb	cb,
   2695 	void *	user_data)
   2696 {
   2697 	bcm_rlink_traverse_data_t	r_req;
   2698 	int	r_rv;
   2699 	uint32	r_key[] = {
   2700 		0xdcd8d11e,0x2fee11c8,0xfdc6b378,0x9fefee8c,0x8980f333 };
   2701 	bcm_mirror_destination_t	r_mirror_dest;
   2702 	bcm_mirror_destination_t *	r_p_mirror_dest;
   2703 
   2704 	sal_memset(&r_req, 0, sizeof(r_req));
   2705 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   2706 	if (BCM_SUCCESS(r_rv)) {
   2707 		/* Pack request */
   2708 		/* Skip unit */
   2709 
   2710 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   2711 			/* Unpack reply */
   2712 			/* Skip unit */
   2713 			if (*r_req.rx_ptr++ == 1) {
   2714 				r_p_mirror_dest = NULL;
   2715 			} else {
   2716 				r_p_mirror_dest = &r_mirror_dest;
   2717 				r_req.rx_ptr = _bcm_unpack_mirror_destination(r_req.rx_ptr, r_p_mirror_dest);
   2718 			}
   2719 
   2720 			r_rv = cb(unit, r_p_mirror_dest, user_data);
   2721 
   2722 			if (BCM_FAILURE(r_rv)) {
   2723 				break;
   2724 			}
   2725 		}
   2726 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   2727 	}
   2728 
   2729 	return r_rv;
   2730 }
   2731 
   2732 #ifdef	INCLUDE_L3
   2733 
   2734 int
   2735 bcm_client_mpls_entropy_identifier_traverse(
   2736 	int	unit,
   2737 	bcm_mpls_entropy_identifier_traverse_cb	cb,
   2738 	void *	user_data)
   2739 {
   2740 	bcm_rlink_traverse_data_t	r_req;
   2741 	int	r_rv;
   2742 	uint32	r_key[] = {
   2743 		0xcab468f9,0x4a3c978a,0xbf3eaad3,0x341f8494,0x05609c55 };
   2744 	bcm_mpls_entropy_identifier_t	r_info;
   2745 	bcm_mpls_entropy_identifier_t *	r_p_info;
   2746 
   2747 	sal_memset(&r_req, 0, sizeof(r_req));
   2748 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   2749 	if (BCM_SUCCESS(r_rv)) {
   2750 		/* Pack request */
   2751 		/* Skip unit */
   2752 
   2753 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   2754 			/* Unpack reply */
   2755 			/* Skip unit */
   2756 			if (*r_req.rx_ptr++ == 1) {
   2757 				r_p_info = NULL;
   2758 			} else {
   2759 				r_p_info = &r_info;
   2760 				r_req.rx_ptr = _bcm_unpack_mpls_entropy_identifier(r_req.rx_ptr, r_p_info);
   2761 			}
   2762 
   2763 			r_rv = cb(unit, r_p_info, user_data);
   2764 
   2765 			if (BCM_FAILURE(r_rv)) {
   2766 				break;
   2767 			}
   2768 		}
   2769 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   2770 	}
   2771 
   2772 	return r_rv;
   2773 }
   2774 
   2775 int
   2776 bcm_client_mpls_esi_encap_traverse(
   2777 	int	unit,
   2778 	bcm_mpls_esi_encap_traverse_cb	cb,
   2779 	void *	user_data)
   2780 {
   2781 	bcm_rlink_traverse_data_t	r_req;
   2782 	int	r_rv;
   2783 	uint32	r_key[] = {
   2784 		0xd106a109,0x33252c67,0xeffc9ac7,0xeb61d6ab,0xe1ee8754 };
   2785 	bcm_mpls_esi_info_t	r_info;
   2786 	bcm_mpls_esi_info_t *	r_p_info;
   2787 
   2788 	sal_memset(&r_req, 0, sizeof(r_req));
   2789 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   2790 	if (BCM_SUCCESS(r_rv)) {
   2791 		/* Pack request */
   2792 		/* Skip unit */
   2793 
   2794 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   2795 			/* Unpack reply */
   2796 			/* Skip unit */
   2797 			if (*r_req.rx_ptr++ == 1) {
   2798 				r_p_info = NULL;
   2799 			} else {
   2800 				r_p_info = &r_info;
   2801 				r_req.rx_ptr = _bcm_unpack_mpls_esi_info(r_req.rx_ptr, r_p_info);
   2802 			}
   2803 
   2804 			r_rv = cb(unit, r_p_info, user_data);
   2805 
   2806 			if (BCM_FAILURE(r_rv)) {
   2807 				break;
   2808 			}
   2809 		}
   2810 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   2811 	}
   2812 
   2813 	return r_rv;
   2814 }
   2815 
   2816 int
   2817 bcm_client_mpls_port_traverse(
   2818 	int	unit,
   2819 	bcm_mpls_port_traverse_info_t	additional_info,
   2820 	bcm_mpls_port_traverse_cb	trav_fn,
   2821 	void *	user_data)
   2822 {
   2823 	bcm_rlink_traverse_data_t	r_req;
   2824 	int	r_rv;
   2825 	uint32	r_key[] = {
   2826 		0x68d48889,0x8916263e,0x15cff8b5,0x9c8d6abd,0x9c994231 };
   2827 	bcm_mpls_port_t	r_mpls_port;
   2828 	bcm_mpls_port_t *	r_p_mpls_port;
   2829 
   2830 	sal_memset(&r_req, 0, sizeof(r_req));
   2831 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   2832 	if (BCM_SUCCESS(r_rv)) {
   2833 		/* Pack request */
   2834 		/* Skip unit */
   2835 		BCM_PACK_U32(r_req.tx_ptr, additional_info.flags);
   2836 		BCM_PACK_U32(r_req.tx_ptr, additional_info.flags2);
   2837 		BCM_PACK_U32(r_req.tx_ptr, additional_info.traverse_flags);
   2838 		BCM_PACK_U32(r_req.tx_ptr, additional_info.vpn);
   2839 
   2840 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   2841 			/* Unpack reply */
   2842 			/* Skip unit */
   2843 			if (*r_req.rx_ptr++ == 1) {
   2844 				r_p_mpls_port = NULL;
   2845 			} else {
   2846 				r_p_mpls_port = &r_mpls_port;
   2847 				r_req.rx_ptr = _bcm_unpack_mpls_port(r_req.rx_ptr, r_p_mpls_port);
   2848 			}
   2849 
   2850 			r_rv = trav_fn(unit, r_p_mpls_port, user_data);
   2851 
   2852 			if (BCM_FAILURE(r_rv)) {
   2853 				break;
   2854 			}
   2855 		}
   2856 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   2857 	}
   2858 
   2859 	return r_rv;
   2860 }
   2861 
   2862 int
   2863 bcm_client_mpls_special_label_egress_traverse(
   2864 	int	unit,
   2865 	bcm_mpls_special_label_egress_traverse_cb	cb,
   2866 	void *	user_data)
   2867 {
   2868 	bcm_rlink_traverse_data_t	r_req;
   2869 	int	r_rv;
   2870 	uint32	r_key[] = {
   2871 		0xdc9f2dc6,0x4d998332,0x5fc5f44a,0x0e5fdb8a,0x94bfcb4f };
   2872 	bcm_mpls_special_label_type_t	r_label_type;
   2873 	bcm_mpls_special_label_t	r_label_info;
   2874 	bcm_mpls_special_label_type_t *	r_p_label_type;
   2875 	bcm_mpls_special_label_t *	r_p_label_info;
   2876 
   2877 	sal_memset(&r_req, 0, sizeof(r_req));
   2878 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   2879 	if (BCM_SUCCESS(r_rv)) {
   2880 		/* Pack request */
   2881 		/* Skip unit */
   2882 
   2883 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   2884 			/* Unpack reply */
   2885 			/* Skip unit */
   2886 			if (*r_req.rx_ptr++ == 1) {
   2887 				r_p_label_type = NULL;
   2888 			} else {
   2889 				r_p_label_type = &r_label_type;
   2890 				BCM_UNPACK_U32(r_req.rx_ptr, *r_p_label_type);
   2891 			}
   2892 			if (*r_req.rx_ptr++ == 1) {
   2893 				r_p_label_info = NULL;
   2894 			} else {
   2895 				r_p_label_info = &r_label_info;
   2896 				r_req.rx_ptr = _bcm_unpack_mpls_special_label(r_req.rx_ptr, r_p_label_info);
   2897 			}
   2898 
   2899 			r_rv = cb(unit, r_p_label_type, r_p_label_info, user_data);
   2900 
   2901 			if (BCM_FAILURE(r_rv)) {
   2902 				break;
   2903 			}
   2904 		}
   2905 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   2906 	}
   2907 
   2908 	return r_rv;
   2909 }
   2910 
   2911 int
   2912 bcm_client_mpls_special_label_identifier_traverse(
   2913 	int	unit,
   2914 	bcm_mpls_special_label_identifier_traverse_cb	cb,
   2915 	void *	user_data)
   2916 {
   2917 	bcm_rlink_traverse_data_t	r_req;
   2918 	int	r_rv;
   2919 	uint32	r_key[] = {
   2920 		0xf3c794d4,0xc30aaa9f,0x492a6eba,0x858f6aad,0x44f84b93 };
   2921 	bcm_mpls_special_label_type_t	r_label_type;
   2922 	bcm_mpls_special_label_t	r_label_info;
   2923 	bcm_mpls_special_label_type_t *	r_p_label_type;
   2924 	bcm_mpls_special_label_t *	r_p_label_info;
   2925 
   2926 	sal_memset(&r_req, 0, sizeof(r_req));
   2927 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   2928 	if (BCM_SUCCESS(r_rv)) {
   2929 		/* Pack request */
   2930 		/* Skip unit */
   2931 
   2932 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   2933 			/* Unpack reply */
   2934 			/* Skip unit */
   2935 			if (*r_req.rx_ptr++ == 1) {
   2936 				r_p_label_type = NULL;
   2937 			} else {
   2938 				r_p_label_type = &r_label_type;
   2939 			}
   2940 			if (*r_req.rx_ptr++ == 1) {
   2941 				r_p_label_info = NULL;
   2942 			} else {
   2943 				r_p_label_info = &r_label_info;
   2944 			}
   2945 
   2946 			r_rv = cb(unit, r_p_label_type, r_p_label_info, user_data);
   2947 
   2948 			if (BCM_FAILURE(r_rv)) {
   2949 				break;
   2950 			}
   2951 		}
   2952 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   2953 	}
   2954 
   2955 	return r_rv;
   2956 }
   2957 
   2958 int
   2959 bcm_client_mpls_tunnel_initiator_traverse(
   2960 	int	unit,
   2961 	bcm_mpls_tunnel_initiator_traverse_info_t *	additional_info,
   2962 	bcm_mpls_tunnel_initiator_traverse_cb	cb,
   2963 	void *	user_data)
   2964 {
   2965 	bcm_rlink_traverse_data_t	r_req;
   2966 	int	r_rv;
   2967 	uint32	r_key[] = {
   2968 		0x6342aa9d,0x9a80546b,0x35413215,0x38d202c1,0x3a737e17 };
   2969 	int	r_num_labels;
   2970 	bcm_mpls_egress_label_t	r_label_array;
   2971 	bcm_mpls_egress_label_t *	r_p_label_array;
   2972 
   2973 	sal_memset(&r_req, 0, sizeof(r_req));
   2974 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   2975 	if (BCM_SUCCESS(r_rv)) {
   2976 		/* Pack request */
   2977 		/* Skip unit */
   2978 		if (additional_info == NULL) {
   2979 			BCM_PACK_U8(r_req.tx_ptr, 1);
   2980 		} else {
   2981 			BCM_PACK_U8(r_req.tx_ptr, 0);
   2982 			BCM_PACK_U32(r_req.tx_ptr, additional_info->flags);
   2983 		}
   2984 
   2985 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   2986 			/* Unpack reply */
   2987 			/* Skip unit */
   2988 			BCM_UNPACK_U32(r_req.rx_ptr, r_num_labels);
   2989 			if (*r_req.rx_ptr++ == 1) {
   2990 				r_p_label_array = NULL;
   2991 			} else {
   2992 				r_p_label_array = &r_label_array;
   2993 				r_req.rx_ptr = _bcm_unpack_mpls_egress_label(r_req.rx_ptr, r_p_label_array);
   2994 			}
   2995 
   2996 			r_rv = cb(unit, r_num_labels, r_p_label_array, user_data);
   2997 
   2998 			if (BCM_FAILURE(r_rv)) {
   2999 				break;
   3000 			}
   3001 		}
   3002 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   3003 	}
   3004 
   3005 	return r_rv;
   3006 }
   3007 
   3008 int
   3009 bcm_client_mpls_tunnel_switch_traverse(
   3010 	int	unit,
   3011 	bcm_mpls_tunnel_switch_traverse_cb	cb,
   3012 	void *	user_data)
   3013 {
   3014 	bcm_rlink_traverse_data_t	r_req;
   3015 	int	r_rv;
   3016 	uint32	r_key[] = {
   3017 		0xe78321d1,0x5f8959d3,0x6b5dc068,0x3bd16a35,0x8fa5673f };
   3018 	bcm_mpls_tunnel_switch_t	r_info;
   3019 	bcm_mpls_tunnel_switch_t *	r_p_info;
   3020 
   3021 	sal_memset(&r_req, 0, sizeof(r_req));
   3022 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   3023 	if (BCM_SUCCESS(r_rv)) {
   3024 		/* Pack request */
   3025 		/* Skip unit */
   3026 
   3027 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   3028 			/* Unpack reply */
   3029 			/* Skip unit */
   3030 			if (*r_req.rx_ptr++ == 1) {
   3031 				r_p_info = NULL;
   3032 			} else {
   3033 				r_p_info = &r_info;
   3034 				r_req.rx_ptr = _bcm_unpack_mpls_tunnel_switch(r_req.rx_ptr, r_p_info);
   3035 			}
   3036 
   3037 			r_rv = cb(unit, r_p_info, user_data);
   3038 
   3039 			if (BCM_FAILURE(r_rv)) {
   3040 				break;
   3041 			}
   3042 		}
   3043 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   3044 	}
   3045 
   3046 	return r_rv;
   3047 }
   3048 
   3049 int
   3050 bcm_client_mpls_vpn_traverse(
   3051 	int	unit,
   3052 	bcm_mpls_vpn_traverse_cb	cb,
   3053 	void *	user_data)
   3054 {
   3055 	bcm_rlink_traverse_data_t	r_req;
   3056 	int	r_rv;
   3057 	uint32	r_key[] = {
   3058 		0xa6b62e4d,0xf0357ad3,0x3eb5c1f8,0xc1112545,0xff607622 };
   3059 	bcm_mpls_vpn_config_t	r_info;
   3060 	bcm_mpls_vpn_config_t *	r_p_info;
   3061 
   3062 	sal_memset(&r_req, 0, sizeof(r_req));
   3063 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   3064 	if (BCM_SUCCESS(r_rv)) {
   3065 		/* Pack request */
   3066 		/* Skip unit */
   3067 
   3068 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   3069 			/* Unpack reply */
   3070 			/* Skip unit */
   3071 			if (*r_req.rx_ptr++ == 1) {
   3072 				r_p_info = NULL;
   3073 			} else {
   3074 				r_p_info = &r_info;
   3075 				r_req.rx_ptr = _bcm_unpack_mpls_vpn_config(r_req.rx_ptr, r_p_info);
   3076 			}
   3077 
   3078 			r_rv = cb(unit, r_p_info, user_data);
   3079 
   3080 			if (BCM_FAILURE(r_rv)) {
   3081 				break;
   3082 			}
   3083 		}
   3084 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   3085 	}
   3086 
   3087 	return r_rv;
   3088 }
   3089 
   3090 #endif	/* INCLUDE_L3 */
   3091 
   3092 int
   3093 bcm_client_multicast_encap_extension_traverse(
   3094 	int	unit,
   3095 	bcm_multicast_encap_extension_traverse_cb	trav_fn,
   3096 	void *	user_data)
   3097 {
   3098 	bcm_rlink_traverse_data_t	r_req;
   3099 	int	r_rv;
   3100 	uint32	r_key[] = {
   3101 		0x1e5b3d1b,0xf70617f9,0x6ca206fc,0xbd060cf5,0xaed7dd12 };
   3102 	bcm_if_t	r_multicast_replication_index;
   3103 	uint32	r_flags;
   3104 
   3105 	sal_memset(&r_req, 0, sizeof(r_req));
   3106 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   3107 	if (BCM_SUCCESS(r_rv)) {
   3108 		/* Pack request */
   3109 		/* Skip unit */
   3110 
   3111 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   3112 			/* Unpack reply */
   3113 			/* Skip unit */
   3114 			BCM_UNPACK_U32(r_req.rx_ptr, r_multicast_replication_index);
   3115 			BCM_UNPACK_U32(r_req.rx_ptr, r_flags);
   3116 
   3117 			r_rv = trav_fn(unit, r_multicast_replication_index, r_flags, user_data);
   3118 
   3119 			if (BCM_FAILURE(r_rv)) {
   3120 				break;
   3121 			}
   3122 		}
   3123 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   3124 	}
   3125 
   3126 	return r_rv;
   3127 }
   3128 
   3129 int
   3130 bcm_client_multicast_group_traverse(
   3131 	int	unit,
   3132 	bcm_multicast_group_traverse_cb_t	trav_fn,
   3133 	uint32	flags,
   3134 	void *	user_data)
   3135 {
   3136 	bcm_rlink_traverse_data_t	r_req;
   3137 	int	r_rv;
   3138 	uint32	r_key[] = {
   3139 		0x609d585a,0x28d1d4b4,0x9dafcc73,0x0600d68f,0x56fdedd2 };
   3140 	bcm_multicast_t	r_group;
   3141 	uint32	r_flags;
   3142 
   3143 	sal_memset(&r_req, 0, sizeof(r_req));
   3144 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   3145 	if (BCM_SUCCESS(r_rv)) {
   3146 		/* Pack request */
   3147 		/* Skip unit */
   3148 		BCM_PACK_U32(r_req.tx_ptr, flags);
   3149 
   3150 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   3151 			/* Unpack reply */
   3152 			/* Skip unit */
   3153 			BCM_UNPACK_U32(r_req.rx_ptr, r_group);
   3154 			BCM_UNPACK_U32(r_req.rx_ptr, r_flags);
   3155 
   3156 			r_rv = trav_fn(unit, r_group, r_flags, user_data);
   3157 
   3158 			if (BCM_FAILURE(r_rv)) {
   3159 				break;
   3160 			}
   3161 		}
   3162 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   3163 	}
   3164 
   3165 	return r_rv;
   3166 }
   3167 
   3168 #ifdef	INCLUDE_L3
   3169 
   3170 int
   3171 bcm_client_niv_forward_traverse(
   3172 	int	unit,
   3173 	bcm_niv_forward_traverse_cb	cb,
   3174 	void *	user_data)
   3175 {
   3176 	bcm_rlink_traverse_data_t	r_req;
   3177 	int	r_rv;
   3178 	uint32	r_key[] = {
   3179 		0xdff5e37c,0x63f8f445,0x7eb5490d,0xae8f690c,0x87f6eec7 };
   3180 	bcm_niv_forward_t	r_iv_fwd_entry;
   3181 	bcm_niv_forward_t *	r_p_iv_fwd_entry;
   3182 
   3183 	sal_memset(&r_req, 0, sizeof(r_req));
   3184 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   3185 	if (BCM_SUCCESS(r_rv)) {
   3186 		/* Pack request */
   3187 		/* Skip unit */
   3188 
   3189 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   3190 			/* Unpack reply */
   3191 			/* Skip unit */
   3192 			if (*r_req.rx_ptr++ == 1) {
   3193 				r_p_iv_fwd_entry = NULL;
   3194 			} else {
   3195 				r_p_iv_fwd_entry = &r_iv_fwd_entry;
   3196 				r_req.rx_ptr = _bcm_unpack_niv_forward(r_req.rx_ptr, r_p_iv_fwd_entry);
   3197 			}
   3198 
   3199 			r_rv = cb(unit, r_p_iv_fwd_entry, user_data);
   3200 
   3201 			if (BCM_FAILURE(r_rv)) {
   3202 				break;
   3203 			}
   3204 		}
   3205 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   3206 	}
   3207 
   3208 	return r_rv;
   3209 }
   3210 
   3211 int
   3212 bcm_client_niv_port_traverse(
   3213 	int	unit,
   3214 	bcm_niv_port_traverse_cb	cb,
   3215 	void *	user_data)
   3216 {
   3217 	bcm_rlink_traverse_data_t	r_req;
   3218 	int	r_rv;
   3219 	uint32	r_key[] = {
   3220 		0xf576f989,0xe875babe,0xdc063963,0xedd55a31,0xd47ff86a };
   3221 	bcm_niv_port_t	r_niv_port;
   3222 	bcm_niv_port_t *	r_p_niv_port;
   3223 
   3224 	sal_memset(&r_req, 0, sizeof(r_req));
   3225 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   3226 	if (BCM_SUCCESS(r_rv)) {
   3227 		/* Pack request */
   3228 		/* Skip unit */
   3229 
   3230 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   3231 			/* Unpack reply */
   3232 			/* Skip unit */
   3233 			if (*r_req.rx_ptr++ == 1) {
   3234 				r_p_niv_port = NULL;
   3235 			} else {
   3236 				r_p_niv_port = &r_niv_port;
   3237 				r_req.rx_ptr = _bcm_unpack_niv_port(r_req.rx_ptr, r_p_niv_port);
   3238 			}
   3239 
   3240 			r_rv = cb(unit, r_p_niv_port, user_data);
   3241 
   3242 			if (BCM_FAILURE(r_rv)) {
   3243 				break;
   3244 			}
   3245 		}
   3246 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   3247 	}
   3248 
   3249 	return r_rv;
   3250 }
   3251 
   3252 #endif	/* INCLUDE_L3 */
   3253 
   3254 int
   3255 bcm_client_oam_endpoint_traverse(
   3256 	int	unit,
   3257 	bcm_oam_group_t	group,
   3258 	bcm_oam_endpoint_traverse_cb	cb,
   3259 	void *	user_data)
   3260 {
   3261 	bcm_rlink_traverse_data_t	r_req;
   3262 	int	r_rv;
   3263 	uint32	r_key[] = {
   3264 		0x84d3139b,0x63882899,0x779a64f2,0x780bebd5,0x7c6293da };
   3265 	bcm_oam_endpoint_info_t	r_endpoint_info;
   3266 	bcm_oam_endpoint_info_t *	r_p_endpoint_info;
   3267 
   3268 	sal_memset(&r_req, 0, sizeof(r_req));
   3269 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   3270 	if (BCM_SUCCESS(r_rv)) {
   3271 		/* Pack request */
   3272 		/* Skip unit */
   3273 		BCM_PACK_U32(r_req.tx_ptr, group);
   3274 
   3275 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   3276 			/* Unpack reply */
   3277 			/* Skip unit */
   3278 			if (*r_req.rx_ptr++ == 1) {
   3279 				r_p_endpoint_info = NULL;
   3280 			} else {
   3281 				r_p_endpoint_info = &r_endpoint_info;
   3282 				r_req.rx_ptr = _bcm_unpack_oam_endpoint_info(r_req.rx_ptr, r_p_endpoint_info);
   3283 			}
   3284 
   3285 			r_rv = cb(unit, r_p_endpoint_info, user_data);
   3286 
   3287 			if (BCM_FAILURE(r_rv)) {
   3288 				break;
   3289 			}
   3290 		}
   3291 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   3292 	}
   3293 
   3294 	return r_rv;
   3295 }
   3296 
   3297 int
   3298 bcm_client_oam_group_traverse(
   3299 	int	unit,
   3300 	bcm_oam_group_traverse_cb	cb,
   3301 	void *	user_data)
   3302 {
   3303 	bcm_rlink_traverse_data_t	r_req;
   3304 	int	r_rv;
   3305 	uint32	r_key[] = {
   3306 		0xc0d84a55,0xb28f41a5,0xa3f7be33,0x6c24dde9,0x98e0eccb };
   3307 	bcm_oam_group_info_t	r_group_info;
   3308 	bcm_oam_group_info_t *	r_p_group_info;
   3309 
   3310 	sal_memset(&r_req, 0, sizeof(r_req));
   3311 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   3312 	if (BCM_SUCCESS(r_rv)) {
   3313 		/* Pack request */
   3314 		/* Skip unit */
   3315 
   3316 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   3317 			/* Unpack reply */
   3318 			/* Skip unit */
   3319 			if (*r_req.rx_ptr++ == 1) {
   3320 				r_p_group_info = NULL;
   3321 			} else {
   3322 				r_p_group_info = &r_group_info;
   3323 				r_req.rx_ptr = _bcm_unpack_oam_group_info(r_req.rx_ptr, r_p_group_info);
   3324 			}
   3325 
   3326 			r_rv = cb(unit, r_p_group_info, user_data);
   3327 
   3328 			if (BCM_FAILURE(r_rv)) {
   3329 				break;
   3330 			}
   3331 		}
   3332 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   3333 	}
   3334 
   3335 	return r_rv;
   3336 }
   3337 
   3338 int
   3339 bcm_client_oam_pm_profile_traverse(
   3340 	int	unit,
   3341 	bcm_oam_pm_profile_traverse_cb	cb,
   3342 	void *	user_data)
   3343 {
   3344 	bcm_rlink_traverse_data_t	r_req;
   3345 	int	r_rv;
   3346 	uint32	r_key[] = {
   3347 		0xde7d15e2,0x10c7b82d,0x3bb91dba,0xbec325f2,0x41ca999f };
   3348 	bcm_oam_pm_profile_info_t	r_profile_info;
   3349 	bcm_oam_pm_profile_info_t *	r_p_profile_info;
   3350 
   3351 	sal_memset(&r_req, 0, sizeof(r_req));
   3352 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   3353 	if (BCM_SUCCESS(r_rv)) {
   3354 		/* Pack request */
   3355 		/* Skip unit */
   3356 
   3357 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   3358 			/* Unpack reply */
   3359 			/* Skip unit */
   3360 			if (*r_req.rx_ptr++ == 1) {
   3361 				r_p_profile_info = NULL;
   3362 			} else {
   3363 				r_p_profile_info = &r_profile_info;
   3364 				r_req.rx_ptr = _bcm_unpack_oam_pm_profile_info(r_req.rx_ptr, r_p_profile_info);
   3365 			}
   3366 
   3367 			r_rv = cb(unit, r_p_profile_info, user_data);
   3368 
   3369 			if (BCM_FAILURE(r_rv)) {
   3370 				break;
   3371 			}
   3372 		}
   3373 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   3374 	}
   3375 
   3376 	return r_rv;
   3377 }
   3378 
   3379 int
   3380 bcm_client_policer_traverse(
   3381 	int	unit,
   3382 	bcm_policer_traverse_cb	cb,
   3383 	void *	user_data)
   3384 {
   3385 	bcm_rlink_traverse_data_t	r_req;
   3386 	int	r_rv;
   3387 	uint32	r_key[] = {
   3388 		0xf1700d39,0x5240c888,0x4932cc67,0xdfa88306,0x7424edf3 };
   3389 	bcm_policer_t	r_policer_id;
   3390 	bcm_policer_config_t	r_info;
   3391 	bcm_policer_config_t *	r_p_info;
   3392 
   3393 	sal_memset(&r_req, 0, sizeof(r_req));
   3394 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   3395 	if (BCM_SUCCESS(r_rv)) {
   3396 		/* Pack request */
   3397 		/* Skip unit */
   3398 
   3399 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   3400 			/* Unpack reply */
   3401 			/* Skip unit */
   3402 			BCM_UNPACK_U32(r_req.rx_ptr, r_policer_id);
   3403 			if (*r_req.rx_ptr++ == 1) {
   3404 				r_p_info = NULL;
   3405 			} else {
   3406 				r_p_info = &r_info;
   3407 				r_req.rx_ptr = _bcm_unpack_policer_config(r_req.rx_ptr, r_p_info);
   3408 			}
   3409 
   3410 			r_rv = cb(unit, r_policer_id, r_p_info, user_data);
   3411 
   3412 			if (BCM_FAILURE(r_rv)) {
   3413 				break;
   3414 			}
   3415 		}
   3416 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   3417 	}
   3418 
   3419 	return r_rv;
   3420 }
   3421 
   3422 int
   3423 bcm_client_port_e2efc_remote_module_traverse(
   3424 	int	unit,
   3425 	bcm_port_e2efc_remote_module_traverse_cb	cb,
   3426 	void *	user_data)
   3427 {
   3428 	bcm_rlink_traverse_data_t	r_req;
   3429 	int	r_rv;
   3430 	uint32	r_key[] = {
   3431 		0xbb048347,0xb06d97d6,0x2f20eb36,0x1210bd53,0x94bde811 };
   3432 	bcm_module_t	r_remote_module;
   3433 	bcm_port_e2efc_mode_t	r_mode;
   3434 
   3435 	sal_memset(&r_req, 0, sizeof(r_req));
   3436 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   3437 	if (BCM_SUCCESS(r_rv)) {
   3438 		/* Pack request */
   3439 		/* Skip unit */
   3440 
   3441 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   3442 			/* Unpack reply */
   3443 			/* Skip unit */
   3444 			BCM_UNPACK_U32(r_req.rx_ptr, r_remote_module);
   3445 			BCM_UNPACK_U32(r_req.rx_ptr, r_mode);
   3446 
   3447 			r_rv = cb(unit, r_remote_module, r_mode, user_data);
   3448 
   3449 			if (BCM_FAILURE(r_rv)) {
   3450 				break;
   3451 			}
   3452 		}
   3453 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   3454 	}
   3455 
   3456 	return r_rv;
   3457 }
   3458 
   3459 int
   3460 bcm_client_port_e2efc_remote_port_traverse(
   3461 	int	unit,
   3462 	bcm_port_e2efc_remote_port_traverse_cb	cb,
   3463 	void *	user_data)
   3464 {
   3465 	bcm_rlink_traverse_data_t	r_req;
   3466 	int	r_rv;
   3467 	uint32	r_key[] = {
   3468 		0x625ac1ae,0x1e171eed,0x7c4ca017,0xb3911667,0x19dc3de2 };
   3469 	int	r_rport_handle_id;
   3470 
   3471 	sal_memset(&r_req, 0, sizeof(r_req));
   3472 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   3473 	if (BCM_SUCCESS(r_rv)) {
   3474 		/* Pack request */
   3475 		/* Skip unit */
   3476 
   3477 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   3478 			/* Unpack reply */
   3479 			/* Skip unit */
   3480 			BCM_UNPACK_U32(r_req.rx_ptr, r_rport_handle_id);
   3481 
   3482 			r_rv = cb(unit, r_rport_handle_id, user_data);
   3483 
   3484 			if (BCM_FAILURE(r_rv)) {
   3485 				break;
   3486 			}
   3487 		}
   3488 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   3489 	}
   3490 
   3491 	return r_rv;
   3492 }
   3493 
   3494 int
   3495 bcm_client_port_resource_traverse(
   3496 	int	unit,
   3497 	bcm_port_resource_traverse_cb	trav_fn,
   3498 	void *	user_data)
   3499 {
   3500 	bcm_rlink_traverse_data_t	r_req;
   3501 	int	r_rv;
   3502 	uint32	r_key[] = {
   3503 		0x77e30c28,0x25d0aaae,0x75a81f9c,0x5c9b3b00,0xbe3e9473 };
   3504 	bcm_port_resource_t	r_resource;
   3505 	bcm_port_resource_t *	r_p_resource;
   3506 
   3507 	sal_memset(&r_req, 0, sizeof(r_req));
   3508 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   3509 	if (BCM_SUCCESS(r_rv)) {
   3510 		/* Pack request */
   3511 		/* Skip unit */
   3512 
   3513 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   3514 			/* Unpack reply */
   3515 			/* Skip unit */
   3516 			if (*r_req.rx_ptr++ == 1) {
   3517 				r_p_resource = NULL;
   3518 			} else {
   3519 				r_p_resource = &r_resource;
   3520 				r_req.rx_ptr = _bcm_unpack_port_resource(r_req.rx_ptr, r_p_resource);
   3521 			}
   3522 
   3523 			r_rv = trav_fn(unit, r_p_resource, user_data);
   3524 
   3525 			if (BCM_FAILURE(r_rv)) {
   3526 				break;
   3527 			}
   3528 		}
   3529 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   3530 	}
   3531 
   3532 	return r_rv;
   3533 }
   3534 
   3535 #ifdef	INCLUDE_L3
   3536 
   3537 int
   3538 bcm_client_proxy_egress_traverse(
   3539 	int	unit,
   3540 	bcm_proxy_egress_traverse_cb	trav_fn,
   3541 	void *	user_data)
   3542 {
   3543 	bcm_rlink_traverse_data_t	r_req;
   3544 	int	r_rv;
   3545 	uint32	r_key[] = {
   3546 		0x991de8b3,0xd507f533,0x79a88425,0x85992902,0xc42c48e8 };
   3547 	bcm_if_t	r_proxy_if_id;
   3548 	bcm_proxy_egress_t	r_info;
   3549 	bcm_proxy_egress_t *	r_p_info;
   3550 
   3551 	sal_memset(&r_req, 0, sizeof(r_req));
   3552 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   3553 	if (BCM_SUCCESS(r_rv)) {
   3554 		/* Pack request */
   3555 		/* Skip unit */
   3556 
   3557 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   3558 			/* Unpack reply */
   3559 			/* Skip unit */
   3560 			BCM_UNPACK_U32(r_req.rx_ptr, r_proxy_if_id);
   3561 			if (*r_req.rx_ptr++ == 1) {
   3562 				r_p_info = NULL;
   3563 			} else {
   3564 				r_p_info = &r_info;
   3565 				r_req.rx_ptr = _bcm_unpack_proxy_egress(r_req.rx_ptr, r_p_info);
   3566 			}
   3567 
   3568 			r_rv = trav_fn(unit, r_proxy_if_id, r_p_info, user_data);
   3569 
   3570 			if (BCM_FAILURE(r_rv)) {
   3571 				break;
   3572 			}
   3573 		}
   3574 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   3575 	}
   3576 
   3577 	return r_rv;
   3578 }
   3579 
   3580 #endif	/* INCLUDE_L3 */
   3581 #ifdef	INCLUDE_PSTATS
   3582 
   3583 int
   3584 bcm_client_pstats_session_traverse(
   3585 	int	unit,
   3586 	bcm_pstats_session_traverse_cb	cb,
   3587 	void *	user_data)
   3588 {
   3589 	bcm_rlink_traverse_data_t	r_req;
   3590 	int	r_rv;
   3591 	int	r_i;
   3592 	uint32	r_key[] = {
   3593 		0x6365cc98,0x3ed346b9,0xb1dbab1e,0x854a8e1a,0xcd7c7c72 };
   3594 	bcm_pstats_session_id_t	r_session_id;
   3595 	int	r_array_count;
   3596 	bcm_pstats_session_element_t *	r_p_element_array;
   3597 
   3598 	sal_memset(&r_req, 0, sizeof(r_req));
   3599 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   3600 	if (BCM_SUCCESS(r_rv)) {
   3601 		/* Pack request */
   3602 		/* Skip unit */
   3603 
   3604 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   3605 			/* Unpack reply */
   3606 			r_rv = BCM_E_NONE;
   3607 			/* Skip unit */
   3608 			BCM_UNPACK_U32(r_req.rx_ptr, r_session_id);
   3609 			BCM_UNPACK_U32(r_req.rx_ptr, r_array_count);
   3610 			if (*r_req.rx_ptr++ == 1) {
   3611 				r_p_element_array = NULL;
   3612 			} else {
   3613 				r_p_element_array = sal_alloc(r_array_count*sizeof(bcm_pstats_session_element_t), "traverse r_element_array");
   3614 				if (r_p_element_array == NULL) {
   3615 					r_rv = BCM_E_MEMORY;
   3616 				} else {
   3617 					for (r_i = 0; r_i < r_array_count; r_i++) {
   3618 						r_req.rx_ptr = _bcm_unpack_pstats_session_element(r_req.rx_ptr, r_p_element_array+r_i);
   3619 					}
   3620 				}
   3621 			}
   3622 
   3623 			if (BCM_SUCCESS(r_rv)) {
   3624 				r_rv = cb(unit, r_session_id, r_array_count, r_p_element_array, user_data);
   3625 			}
   3626 
   3627 			if (r_p_element_array != NULL) {
   3628 				sal_free(r_p_element_array);
   3629 			}
   3630 
   3631 			if (BCM_FAILURE(r_rv)) {
   3632 				break;
   3633 			}
   3634 		}
   3635 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   3636 	}
   3637 
   3638 	return r_rv;
   3639 }
   3640 
   3641 #endif	/* INCLUDE_PSTATS */
   3642 
   3643 int
   3644 bcm_client_range_traverse(
   3645 	int	unit,
   3646 	bcm_range_traverse_cb	callback,
   3647 	void *	user_data)
   3648 {
   3649 	bcm_rlink_traverse_data_t	r_req;
   3650 	int	r_rv;
   3651 	uint32	r_key[] = {
   3652 		0xa56156d3,0xdbb5a53b,0xfe4e2003,0xd821e6e4,0x98fc5a69 };
   3653 	bcm_range_config_t	r_range_cfg;
   3654 	bcm_range_config_t *	r_p_range_cfg;
   3655 
   3656 	sal_memset(&r_req, 0, sizeof(r_req));
   3657 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   3658 	if (BCM_SUCCESS(r_rv)) {
   3659 		/* Pack request */
   3660 		/* Skip unit */
   3661 
   3662 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   3663 			/* Unpack reply */
   3664 			/* Skip unit */
   3665 			if (*r_req.rx_ptr++ == 1) {
   3666 				r_p_range_cfg = NULL;
   3667 			} else {
   3668 				r_p_range_cfg = &r_range_cfg;
   3669 				r_req.rx_ptr = _bcm_unpack_range_config(r_req.rx_ptr, r_p_range_cfg);
   3670 			}
   3671 
   3672 			r_rv = callback(unit, r_p_range_cfg, user_data);
   3673 
   3674 			if (BCM_FAILURE(r_rv)) {
   3675 				break;
   3676 			}
   3677 		}
   3678 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   3679 	}
   3680 
   3681 	return r_rv;
   3682 }
   3683 
   3684 #ifdef	INCLUDE_REGEX
   3685 
   3686 int
   3687 bcm_client_regex_session_traverse(
   3688 	int	unit,
   3689 	int	flags,
   3690 	bcm_regex_session_traverse_cb	cb,
   3691 	void *	user_data)
   3692 {
   3693 	bcm_rlink_traverse_data_t	r_req;
   3694 	int	r_rv;
   3695 	uint32	r_key[] = {
   3696 		0x97881531,0x3f638671,0x091072ca,0x638d7506,0xa71444d4 };
   3697 	bcm_regex_session_key_t	r_session_key;
   3698 	bcm_regex_session_t	r_session_data;
   3699 	bcm_regex_session_key_t *	r_p_session_key;
   3700 	bcm_regex_session_t *	r_p_session_data;
   3701 
   3702 	sal_memset(&r_req, 0, sizeof(r_req));
   3703 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   3704 	if (BCM_SUCCESS(r_rv)) {
   3705 		/* Pack request */
   3706 		/* Skip unit */
   3707 		BCM_PACK_U32(r_req.tx_ptr, flags);
   3708 
   3709 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   3710 			/* Unpack reply */
   3711 			/* Skip unit */
   3712 			if (*r_req.rx_ptr++ == 1) {
   3713 				r_p_session_key = NULL;
   3714 			} else {
   3715 				r_p_session_key = &r_session_key;
   3716 				BCM_UNPACK_U32(r_req.rx_ptr, r_p_session_key->flags);
   3717 				BCM_UNPACK_U32(r_req.rx_ptr, r_p_session_key->sip);
   3718 				BCM_UNPACK_U32(r_req.rx_ptr, r_p_session_key->dip);
   3719 				r_req.rx_ptr = _bcm_unpack_ip6(r_req.rx_ptr, (*r_p_session_key).sip6);
   3720 				r_req.rx_ptr = _bcm_unpack_ip6(r_req.rx_ptr, (*r_p_session_key).dip6);
   3721 				BCM_UNPACK_U32(r_req.rx_ptr, r_p_session_key->dst_port);
   3722 				BCM_UNPACK_U32(r_req.rx_ptr, r_p_session_key->src_port);
   3723 				BCM_UNPACK_U8(r_req.rx_ptr, r_p_session_key->protocol);
   3724 			}
   3725 			if (*r_req.rx_ptr++ == 1) {
   3726 				r_p_session_data = NULL;
   3727 			} else {
   3728 				r_p_session_data = &r_session_data;
   3729 				BCM_UNPACK_U32(r_req.rx_ptr, r_p_session_data->flags);
   3730 				BCM_UNPACK_U32(r_req.rx_ptr, r_p_session_data->policy);
   3731 				BCM_UNPACK_U32(r_req.rx_ptr, r_p_session_data->inactivity_timeout);
   3732 				BCM_UNPACK_U32(r_req.rx_ptr, r_p_session_data->timestamp);
   3733 			}
   3734 
   3735 			r_rv = cb(unit, r_p_session_key, r_p_session_data, user_data);
   3736 
   3737 			if (BCM_FAILURE(r_rv)) {
   3738 				break;
   3739 			}
   3740 		}
   3741 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   3742 	}
   3743 
   3744 	return r_rv;
   3745 }
   3746 
   3747 #endif	/* INCLUDE_REGEX */
   3748 
   3749 int
   3750 bcm_client_sat_ctf_traverse(
   3751 	int	unit,
   3752 	bcm_sat_ctf_traverse_cb	cb,
   3753 	void *	user_data)
   3754 {
   3755 	bcm_rlink_traverse_data_t	r_req;
   3756 	int	r_rv;
   3757 	uint32	r_key[] = {
   3758 		0xe34b222d,0x1face4cc,0x3db24490,0x4bba330f,0xff39899d };
   3759 	bcm_sat_ctf_t	r_ctf_id;
   3760 
   3761 	sal_memset(&r_req, 0, sizeof(r_req));
   3762 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   3763 	if (BCM_SUCCESS(r_rv)) {
   3764 		/* Pack request */
   3765 		/* Skip unit */
   3766 
   3767 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   3768 			/* Unpack reply */
   3769 			/* Skip unit */
   3770 			BCM_UNPACK_U32(r_req.rx_ptr, r_ctf_id);
   3771 
   3772 			r_rv = cb(unit, r_ctf_id, user_data);
   3773 
   3774 			if (BCM_FAILURE(r_rv)) {
   3775 				break;
   3776 			}
   3777 		}
   3778 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   3779 	}
   3780 
   3781 	return r_rv;
   3782 }
   3783 
   3784 int
   3785 bcm_client_sat_endpoint_traverse(
   3786 	int	unit,
   3787 	uint32	flags,
   3788 	bcm_sat_endpoint_traverse_cb	cb,
   3789 	void *	user_data)
   3790 {
   3791 	bcm_rlink_traverse_data_t	r_req;
   3792 	int	r_rv;
   3793 	uint32	r_key[] = {
   3794 		0xb59cc366,0xe824ff05,0xe18f2431,0xb51aeeaf,0xc0300b33 };
   3795 	bcm_sat_endpoint_info_t	r_endpoint_info;
   3796 	bcm_sat_endpoint_info_t *	r_p_endpoint_info;
   3797 
   3798 	sal_memset(&r_req, 0, sizeof(r_req));
   3799 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   3800 	if (BCM_SUCCESS(r_rv)) {
   3801 		/* Pack request */
   3802 		/* Skip unit */
   3803 		BCM_PACK_U32(r_req.tx_ptr, flags);
   3804 
   3805 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   3806 			/* Unpack reply */
   3807 			/* Skip unit */
   3808 			if (*r_req.rx_ptr++ == 1) {
   3809 				r_p_endpoint_info = NULL;
   3810 			} else {
   3811 				r_p_endpoint_info = &r_endpoint_info;
   3812 				r_req.rx_ptr = _bcm_unpack_sat_endpoint_info(r_req.rx_ptr, r_p_endpoint_info);
   3813 			}
   3814 
   3815 			r_rv = cb(unit, r_p_endpoint_info, user_data);
   3816 
   3817 			if (BCM_FAILURE(r_rv)) {
   3818 				break;
   3819 			}
   3820 		}
   3821 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   3822 	}
   3823 
   3824 	return r_rv;
   3825 }
   3826 
   3827 int
   3828 bcm_client_sat_gtf_traverse(
   3829 	int	unit,
   3830 	bcm_sat_gtf_traverse_cb	cb,
   3831 	void *	user_data)
   3832 {
   3833 	bcm_rlink_traverse_data_t	r_req;
   3834 	int	r_rv;
   3835 	uint32	r_key[] = {
   3836 		0x39c117c2,0x6bf312a0,0xacf86abd,0x666c2f12,0x5044bbb8 };
   3837 	bcm_sat_gtf_t	r_gtf_id;
   3838 
   3839 	sal_memset(&r_req, 0, sizeof(r_req));
   3840 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   3841 	if (BCM_SUCCESS(r_rv)) {
   3842 		/* Pack request */
   3843 		/* Skip unit */
   3844 
   3845 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   3846 			/* Unpack reply */
   3847 			/* Skip unit */
   3848 			BCM_UNPACK_U32(r_req.rx_ptr, r_gtf_id);
   3849 
   3850 			r_rv = cb(unit, r_gtf_id, user_data);
   3851 
   3852 			if (BCM_FAILURE(r_rv)) {
   3853 				break;
   3854 			}
   3855 		}
   3856 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   3857 	}
   3858 
   3859 	return r_rv;
   3860 }
   3861 
   3862 int
   3863 bcm_client_srv6_sid_initiator_traverse(
   3864 	int	unit,
   3865 	bcm_srv6_sid_initiator_traverse_info_t	additional_info,
   3866 	bcm_srv6_sid_initiator_traverse_cb	cb,
   3867 	void *	user_data)
   3868 {
   3869 	bcm_rlink_traverse_data_t	r_req;
   3870 	int	r_rv;
   3871 	uint32	r_key[] = {
   3872 		0xc038f065,0x286397f6,0x1f0e0f9f,0x14fa6f62,0x9a03a75f };
   3873 	bcm_srv6_sid_initiator_info_t	r_info;
   3874 	bcm_srv6_sid_initiator_info_t *	r_p_info;
   3875 
   3876 	sal_memset(&r_req, 0, sizeof(r_req));
   3877 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   3878 	if (BCM_SUCCESS(r_rv)) {
   3879 		/* Pack request */
   3880 		/* Skip unit */
   3881 		BCM_PACK_U32(r_req.tx_ptr, additional_info.flags);
   3882 		BCM_PACK_U32(r_req.tx_ptr, additional_info.traverse_flags);
   3883 
   3884 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   3885 			/* Unpack reply */
   3886 			/* Skip unit */
   3887 			if (*r_req.rx_ptr++ == 1) {
   3888 				r_p_info = NULL;
   3889 			} else {
   3890 				r_p_info = &r_info;
   3891 				r_req.rx_ptr = _bcm_unpack_srv6_sid_initiator_info(r_req.rx_ptr, r_p_info);
   3892 			}
   3893 
   3894 			r_rv = cb(unit, r_p_info, user_data);
   3895 
   3896 			if (BCM_FAILURE(r_rv)) {
   3897 				break;
   3898 			}
   3899 		}
   3900 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   3901 	}
   3902 
   3903 	return r_rv;
   3904 }
   3905 
   3906 int
   3907 bcm_client_srv6_srh_base_initiator_traverse(
   3908 	int	unit,
   3909 	bcm_srv6_srh_base_initiator_traverse_info_t	additional_info,
   3910 	bcm_srv6_srh_base_initiator_traverse_cb	cb,
   3911 	void *	user_data)
   3912 {
   3913 	bcm_rlink_traverse_data_t	r_req;
   3914 	int	r_rv;
   3915 	uint32	r_key[] = {
   3916 		0x69fc19ed,0x68010f28,0x70232e07,0x2eeeabff,0xa011f87a };
   3917 	bcm_srv6_srh_base_initiator_info_t	r_info;
   3918 	bcm_srv6_srh_base_initiator_info_t *	r_p_info;
   3919 
   3920 	sal_memset(&r_req, 0, sizeof(r_req));
   3921 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   3922 	if (BCM_SUCCESS(r_rv)) {
   3923 		/* Pack request */
   3924 		/* Skip unit */
   3925 		BCM_PACK_U32(r_req.tx_ptr, additional_info.flags);
   3926 		BCM_PACK_U32(r_req.tx_ptr, additional_info.traverse_flags);
   3927 
   3928 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   3929 			/* Unpack reply */
   3930 			/* Skip unit */
   3931 			if (*r_req.rx_ptr++ == 1) {
   3932 				r_p_info = NULL;
   3933 			} else {
   3934 				r_p_info = &r_info;
   3935 				r_req.rx_ptr = _bcm_unpack_srv6_srh_base_initiator_info(r_req.rx_ptr, r_p_info);
   3936 			}
   3937 
   3938 			r_rv = cb(unit, r_p_info, user_data);
   3939 
   3940 			if (BCM_FAILURE(r_rv)) {
   3941 				break;
   3942 			}
   3943 		}
   3944 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   3945 	}
   3946 
   3947 	return r_rv;
   3948 }
   3949 
   3950 int
   3951 bcm_client_srv6_terminator_next_protocol_traverse(
   3952 	int	unit,
   3953 	bcm_srv6_terminator_next_protocol_traverse_info_t	additional_info,
   3954 	bcm_srv6_terminator_next_protocol_traverse_cb	cb,
   3955 	void *	user_data)
   3956 {
   3957 	bcm_rlink_traverse_data_t	r_req;
   3958 	int	r_rv;
   3959 	uint32	r_key[] = {
   3960 		0xe76f5992,0xa18b68ba,0xb5525608,0xd7662cc2,0xaab28c2f };
   3961 	bcm_srv6_terminator_next_protocol_mapping_t	r_info;
   3962 	bcm_srv6_terminator_next_protocol_mapping_t *	r_p_info;
   3963 
   3964 	sal_memset(&r_req, 0, sizeof(r_req));
   3965 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   3966 	if (BCM_SUCCESS(r_rv)) {
   3967 		/* Pack request */
   3968 		/* Skip unit */
   3969 		BCM_PACK_U32(r_req.tx_ptr, additional_info.flags);
   3970 		BCM_PACK_U32(r_req.tx_ptr, additional_info.traverse_flags);
   3971 
   3972 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   3973 			/* Unpack reply */
   3974 			/* Skip unit */
   3975 			if (*r_req.rx_ptr++ == 1) {
   3976 				r_p_info = NULL;
   3977 			} else {
   3978 				r_p_info = &r_info;
   3979 				r_req.rx_ptr = _bcm_unpack_srv6_terminator_next_protocol_mapping(r_req.rx_ptr, r_p_info);
   3980 			}
   3981 
   3982 			r_rv = cb(unit, r_p_info, user_data);
   3983 
   3984 			if (BCM_FAILURE(r_rv)) {
   3985 				break;
   3986 			}
   3987 		}
   3988 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   3989 	}
   3990 
   3991 	return r_rv;
   3992 }
   3993 
   3994 int
   3995 bcm_client_subport_group_traverse(
   3996 	int	unit,
   3997 	bcm_gport_t	subport_group,
   3998 	bcm_subport_port_traverse_cb	cb,
   3999 	void *	user_data)
   4000 {
   4001 	bcm_rlink_traverse_data_t	r_req;
   4002 	int	r_rv;
   4003 	uint32	r_key[] = {
   4004 		0xb50c8de4,0x0eedad4b,0x4f656714,0x62ed3ed6,0xecbc999a };
   4005 	bcm_gport_t	r_port;
   4006 	bcm_subport_config_t	r_config;
   4007 	bcm_subport_config_t *	r_p_config;
   4008 
   4009 	sal_memset(&r_req, 0, sizeof(r_req));
   4010 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   4011 	if (BCM_SUCCESS(r_rv)) {
   4012 		/* Pack request */
   4013 		/* Skip unit */
   4014 		BCM_PACK_U32(r_req.tx_ptr, subport_group);
   4015 
   4016 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   4017 			/* Unpack reply */
   4018 			/* Skip unit */
   4019 			BCM_UNPACK_U32(r_req.rx_ptr, r_port);
   4020 			if (*r_req.rx_ptr++ == 1) {
   4021 				r_p_config = NULL;
   4022 			} else {
   4023 				r_p_config = &r_config;
   4024 				r_req.rx_ptr = _bcm_unpack_subport_config(r_req.rx_ptr, r_p_config);
   4025 			}
   4026 
   4027 			r_rv = cb(unit, r_port, r_p_config, user_data);
   4028 
   4029 			if (BCM_FAILURE(r_rv)) {
   4030 				break;
   4031 			}
   4032 		}
   4033 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   4034 	}
   4035 
   4036 	return r_rv;
   4037 }
   4038 
   4039 int
   4040 bcm_client_subport_port_traverse(
   4041 	int	unit,
   4042 	bcm_subport_port_traverse_cb	cb,
   4043 	void *	user_data)
   4044 {
   4045 	bcm_rlink_traverse_data_t	r_req;
   4046 	int	r_rv;
   4047 	uint32	r_key[] = {
   4048 		0x36115c4e,0x15b39040,0xea52c661,0x326f8213,0x13b775b1 };
   4049 	bcm_gport_t	r_port;
   4050 	bcm_subport_config_t	r_config;
   4051 	bcm_subport_config_t *	r_p_config;
   4052 
   4053 	sal_memset(&r_req, 0, sizeof(r_req));
   4054 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   4055 	if (BCM_SUCCESS(r_rv)) {
   4056 		/* Pack request */
   4057 		/* Skip unit */
   4058 
   4059 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   4060 			/* Unpack reply */
   4061 			/* Skip unit */
   4062 			BCM_UNPACK_U32(r_req.rx_ptr, r_port);
   4063 			if (*r_req.rx_ptr++ == 1) {
   4064 				r_p_config = NULL;
   4065 			} else {
   4066 				r_p_config = &r_config;
   4067 				r_req.rx_ptr = _bcm_unpack_subport_config(r_req.rx_ptr, r_p_config);
   4068 			}
   4069 
   4070 			r_rv = cb(unit, r_port, r_p_config, user_data);
   4071 
   4072 			if (BCM_FAILURE(r_rv)) {
   4073 				break;
   4074 			}
   4075 		}
   4076 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   4077 	}
   4078 
   4079 	return r_rv;
   4080 }
   4081 
   4082 int
   4083 bcm_client_switch_agm_traverse(
   4084 	int	unit,
   4085 	int	flags,
   4086 	bcm_switch_agm_traverse_cb	trav_fn,
   4087 	void *	user_data)
   4088 {
   4089 	bcm_rlink_traverse_data_t	r_req;
   4090 	int	r_rv;
   4091 	uint32	r_key[] = {
   4092 		0x6f855f85,0xc253d521,0x5ff55969,0x292ea278,0x2eaf6d1a };
   4093 	bcm_switch_agm_info_t	r_agm_info;
   4094 	bcm_switch_agm_info_t *	r_p_agm_info;
   4095 
   4096 	sal_memset(&r_req, 0, sizeof(r_req));
   4097 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   4098 	if (BCM_SUCCESS(r_rv)) {
   4099 		/* Pack request */
   4100 		/* Skip unit */
   4101 		BCM_PACK_U32(r_req.tx_ptr, flags);
   4102 
   4103 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   4104 			/* Unpack reply */
   4105 			/* Skip unit */
   4106 			if (*r_req.rx_ptr++ == 1) {
   4107 				r_p_agm_info = NULL;
   4108 			} else {
   4109 				r_p_agm_info = &r_agm_info;
   4110 				r_req.rx_ptr = _bcm_unpack_switch_agm_info(r_req.rx_ptr, r_p_agm_info);
   4111 			}
   4112 
   4113 			r_rv = trav_fn(unit, r_p_agm_info, user_data);
   4114 
   4115 			if (BCM_FAILURE(r_rv)) {
   4116 				break;
   4117 			}
   4118 		}
   4119 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   4120 	}
   4121 
   4122 	return r_rv;
   4123 }
   4124 
   4125 int
   4126 bcm_client_switch_encap_traverse(
   4127 	int	unit,
   4128 	bcm_switch_encap_traverse_cb	cb_fn,
   4129 	void *	user_data)
   4130 {
   4131 	bcm_rlink_traverse_data_t	r_req;
   4132 	int	r_rv;
   4133 	uint32	r_key[] = {
   4134 		0xfe921663,0x6c99629c,0x9a58724c,0x95e40429,0xd6a94df4 };
   4135 	bcm_if_t	r_encap_id;
   4136 	bcm_switch_encap_info_t	r_encap_info;
   4137 	bcm_switch_encap_info_t *	r_p_encap_info;
   4138 
   4139 	sal_memset(&r_req, 0, sizeof(r_req));
   4140 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   4141 	if (BCM_SUCCESS(r_rv)) {
   4142 		/* Pack request */
   4143 		/* Skip unit */
   4144 
   4145 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   4146 			/* Unpack reply */
   4147 			/* Skip unit */
   4148 			BCM_UNPACK_U32(r_req.rx_ptr, r_encap_id);
   4149 			if (*r_req.rx_ptr++ == 1) {
   4150 				r_p_encap_info = NULL;
   4151 			} else {
   4152 				r_p_encap_info = &r_encap_info;
   4153 				r_req.rx_ptr = _bcm_unpack_switch_encap_info(r_req.rx_ptr, r_p_encap_info);
   4154 			}
   4155 
   4156 			r_rv = cb_fn(unit, r_encap_id, r_p_encap_info, user_data);
   4157 
   4158 			if (BCM_FAILURE(r_rv)) {
   4159 				break;
   4160 			}
   4161 		}
   4162 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   4163 	}
   4164 
   4165 	return r_rv;
   4166 }
   4167 
   4168 int
   4169 bcm_client_switch_hash_entry_traverse(
   4170 	int	unit,
   4171 	int	flags,
   4172 	bcm_switch_hash_entry_traverse_cb	cb_fn,
   4173 	void *	user_data)
   4174 {
   4175 	bcm_rlink_traverse_data_t	r_req;
   4176 	int	r_rv;
   4177 	uint32	r_key[] = {
   4178 		0x24111cc8,0x7879b2b9,0x05585e2b,0x1611ffa2,0x92bdc4f3 };
   4179 	int	r_flags;
   4180 	bcm_hash_entry_t	r_entry;
   4181 
   4182 	sal_memset(&r_req, 0, sizeof(r_req));
   4183 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   4184 	if (BCM_SUCCESS(r_rv)) {
   4185 		/* Pack request */
   4186 		/* Skip unit */
   4187 		BCM_PACK_U32(r_req.tx_ptr, flags);
   4188 
   4189 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   4190 			/* Unpack reply */
   4191 			/* Skip unit */
   4192 			BCM_UNPACK_U32(r_req.rx_ptr, r_flags);
   4193 			BCM_UNPACK_U32(r_req.rx_ptr, r_entry);
   4194 
   4195 			r_rv = cb_fn(unit, r_flags, r_entry, user_data);
   4196 
   4197 			if (BCM_FAILURE(r_rv)) {
   4198 				break;
   4199 			}
   4200 		}
   4201 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   4202 	}
   4203 
   4204 	return r_rv;
   4205 }
   4206 
   4207 int
   4208 bcm_client_switch_match_config_traverse(
   4209 	int	unit,
   4210 	bcm_switch_match_service_t	match_service,
   4211 	bcm_switch_match_config_traverse_cb	cb_fn,
   4212 	void *	user_data)
   4213 {
   4214 	bcm_rlink_traverse_data_t	r_req;
   4215 	int	r_rv;
   4216 	uint32	r_key[] = {
   4217 		0x54c718ae,0xf3af5ae9,0x5704faf4,0xc93439fc,0xfb810d3c };
   4218 	int	r_match_id;
   4219 	bcm_switch_match_config_info_t	r_config_info;
   4220 	bcm_switch_match_config_info_t *	r_p_config_info;
   4221 
   4222 	sal_memset(&r_req, 0, sizeof(r_req));
   4223 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   4224 	if (BCM_SUCCESS(r_rv)) {
   4225 		/* Pack request */
   4226 		/* Skip unit */
   4227 		BCM_PACK_U32(r_req.tx_ptr, match_service);
   4228 
   4229 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   4230 			/* Unpack reply */
   4231 			/* Skip unit */
   4232 			BCM_UNPACK_U32(r_req.rx_ptr, r_match_id);
   4233 			if (*r_req.rx_ptr++ == 1) {
   4234 				r_p_config_info = NULL;
   4235 			} else {
   4236 				r_p_config_info = &r_config_info;
   4237 				r_req.rx_ptr = _bcm_unpack_switch_match_config_info(r_req.rx_ptr, r_p_config_info);
   4238 			}
   4239 
   4240 			r_rv = cb_fn(unit, r_match_id, r_p_config_info, user_data);
   4241 
   4242 			if (BCM_FAILURE(r_rv)) {
   4243 				break;
   4244 			}
   4245 		}
   4246 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   4247 	}
   4248 
   4249 	return r_rv;
   4250 }
   4251 
   4252 int
   4253 bcm_client_switch_match_control_traverse(
   4254 	int	unit,
   4255 	bcm_switch_match_service_t	match_service,
   4256 	bcm_switch_match_control_traverse_cb	cb_fn,
   4257 	void *	user_data)
   4258 {
   4259 	bcm_rlink_traverse_data_t	r_req;
   4260 	int	r_rv;
   4261 	uint32	r_key[] = {
   4262 		0x80bebbc6,0xcb5a54a4,0x2bc78daf,0x113e0d8a,0xd27d16de };
   4263 	bcm_switch_match_control_type_t	r_control_type;
   4264 	bcm_gport_t	r_gport;
   4265 	bcm_switch_match_control_info_t	r_control_info;
   4266 	bcm_switch_match_control_info_t *	r_p_control_info;
   4267 
   4268 	sal_memset(&r_req, 0, sizeof(r_req));
   4269 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   4270 	if (BCM_SUCCESS(r_rv)) {
   4271 		/* Pack request */
   4272 		/* Skip unit */
   4273 		BCM_PACK_U32(r_req.tx_ptr, match_service);
   4274 
   4275 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   4276 			/* Unpack reply */
   4277 			/* Skip unit */
   4278 			BCM_UNPACK_U32(r_req.rx_ptr, r_control_type);
   4279 			BCM_UNPACK_U32(r_req.rx_ptr, r_gport);
   4280 			if (*r_req.rx_ptr++ == 1) {
   4281 				r_p_control_info = NULL;
   4282 			} else {
   4283 				r_p_control_info = &r_control_info;
   4284 				r_req.rx_ptr = _bcm_unpack_switch_match_control_info(r_req.rx_ptr, r_p_control_info);
   4285 			}
   4286 
   4287 			r_rv = cb_fn(unit, r_control_type, r_gport, r_p_control_info, user_data);
   4288 
   4289 			if (BCM_FAILURE(r_rv)) {
   4290 				break;
   4291 			}
   4292 		}
   4293 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   4294 	}
   4295 
   4296 	return r_rv;
   4297 }
   4298 
   4299 int
   4300 bcm_client_switch_olp_l2_addr_traverse(
   4301 	int	unit,
   4302 	bcm_switch_olp_l2_addr_traverse_cb	cb_fn,
   4303 	void *	user_data)
   4304 {
   4305 	bcm_rlink_traverse_data_t	r_req;
   4306 	int	r_rv;
   4307 	uint32	r_key[] = {
   4308 		0x1f2a7e12,0x01c0b8f5,0x95eb51d6,0x1fa69a8e,0x1c53704a };
   4309 	bcm_switch_olp_l2_addr_t	r_l2_addr;
   4310 	bcm_switch_olp_l2_addr_t *	r_p_l2_addr;
   4311 
   4312 	sal_memset(&r_req, 0, sizeof(r_req));
   4313 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   4314 	if (BCM_SUCCESS(r_rv)) {
   4315 		/* Pack request */
   4316 		/* Skip unit */
   4317 
   4318 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   4319 			/* Unpack reply */
   4320 			/* Skip unit */
   4321 			if (*r_req.rx_ptr++ == 1) {
   4322 				r_p_l2_addr = NULL;
   4323 			} else {
   4324 				r_p_l2_addr = &r_l2_addr;
   4325 				r_req.rx_ptr = _bcm_unpack_switch_olp_l2_addr(r_req.rx_ptr, r_p_l2_addr);
   4326 			}
   4327 
   4328 			r_rv = cb_fn(unit, r_p_l2_addr, user_data);
   4329 
   4330 			if (BCM_FAILURE(r_rv)) {
   4331 				break;
   4332 			}
   4333 		}
   4334 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   4335 	}
   4336 
   4337 	return r_rv;
   4338 }
   4339 
   4340 int
   4341 bcm_client_time_interface_traverse(
   4342 	int	unit,
   4343 	bcm_time_interface_traverse_cb	cb,
   4344 	void *	user_data)
   4345 {
   4346 	bcm_rlink_traverse_data_t	r_req;
   4347 	int	r_rv;
   4348 	uint32	r_key[] = {
   4349 		0xb7e7bce3,0xf36ec46a,0x4b1c9ac0,0x8c196613,0x6f327905 };
   4350 	bcm_time_interface_t	r_intf;
   4351 	bcm_time_interface_t *	r_p_intf;
   4352 
   4353 	sal_memset(&r_req, 0, sizeof(r_req));
   4354 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   4355 	if (BCM_SUCCESS(r_rv)) {
   4356 		/* Pack request */
   4357 		/* Skip unit */
   4358 
   4359 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   4360 			/* Unpack reply */
   4361 			/* Skip unit */
   4362 			if (*r_req.rx_ptr++ == 1) {
   4363 				r_p_intf = NULL;
   4364 			} else {
   4365 				r_p_intf = &r_intf;
   4366 				r_req.rx_ptr = _bcm_unpack_time_interface(r_req.rx_ptr, r_p_intf);
   4367 			}
   4368 
   4369 			r_rv = cb(unit, r_p_intf, user_data);
   4370 
   4371 			if (BCM_FAILURE(r_rv)) {
   4372 				break;
   4373 			}
   4374 		}
   4375 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   4376 	}
   4377 
   4378 	return r_rv;
   4379 }
   4380 
   4381 #ifdef	INCLUDE_L3
   4382 
   4383 int
   4384 bcm_client_trill_multicast_adjacency_traverse(
   4385 	int	unit,
   4386 	bcm_trill_multicast_adjacency_traverse_cb	cb,
   4387 	void *	user_data)
   4388 {
   4389 	bcm_rlink_traverse_data_t	r_req;
   4390 	int	r_rv;
   4391 	uint32	r_key[] = {
   4392 		0x0ac4451b,0x1b679cf5,0xc07134b4,0xf9190f9a,0x404d3762 };
   4393 	bcm_trill_multicast_adjacency_t	r_info;
   4394 	bcm_trill_multicast_adjacency_t *	r_p_info;
   4395 
   4396 	sal_memset(&r_req, 0, sizeof(r_req));
   4397 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   4398 	if (BCM_SUCCESS(r_rv)) {
   4399 		/* Pack request */
   4400 		/* Skip unit */
   4401 
   4402 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   4403 			/* Unpack reply */
   4404 			/* Skip unit */
   4405 			if (*r_req.rx_ptr++ == 1) {
   4406 				r_p_info = NULL;
   4407 			} else {
   4408 				r_p_info = &r_info;
   4409 				r_req.rx_ptr = _bcm_unpack_trill_multicast_adjacency(r_req.rx_ptr, r_p_info);
   4410 			}
   4411 
   4412 			r_rv = cb(unit, r_p_info, user_data);
   4413 
   4414 			if (BCM_FAILURE(r_rv)) {
   4415 				break;
   4416 			}
   4417 		}
   4418 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   4419 	}
   4420 
   4421 	return r_rv;
   4422 }
   4423 
   4424 int
   4425 bcm_client_trill_multicast_entry_traverse(
   4426 	int	unit,
   4427 	bcm_trill_multicast_entry_traverse_cb	cb,
   4428 	void *	user_data)
   4429 {
   4430 	bcm_rlink_traverse_data_t	r_req;
   4431 	int	r_rv;
   4432 	uint32	r_key[] = {
   4433 		0x69e11ce7,0x630dfe6f,0x2da8206d,0x0a0a6755,0x3b399ed8 };
   4434 	bcm_trill_multicast_entry_t	r_trill_mc_entry;
   4435 	bcm_trill_multicast_entry_t *	r_p_trill_mc_entry;
   4436 
   4437 	sal_memset(&r_req, 0, sizeof(r_req));
   4438 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   4439 	if (BCM_SUCCESS(r_rv)) {
   4440 		/* Pack request */
   4441 		/* Skip unit */
   4442 
   4443 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   4444 			/* Unpack reply */
   4445 			/* Skip unit */
   4446 			if (*r_req.rx_ptr++ == 1) {
   4447 				r_p_trill_mc_entry = NULL;
   4448 			} else {
   4449 				r_p_trill_mc_entry = &r_trill_mc_entry;
   4450 				r_req.rx_ptr = _bcm_unpack_trill_multicast_entry(r_req.rx_ptr, r_p_trill_mc_entry);
   4451 			}
   4452 
   4453 			r_rv = cb(unit, r_p_trill_mc_entry, user_data);
   4454 
   4455 			if (BCM_FAILURE(r_rv)) {
   4456 				break;
   4457 			}
   4458 		}
   4459 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   4460 	}
   4461 
   4462 	return r_rv;
   4463 }
   4464 
   4465 int
   4466 bcm_client_trill_multicast_source_traverse(
   4467 	int	unit,
   4468 	bcm_trill_multicast_source_traverse_cb	cb,
   4469 	void *	user_data)
   4470 {
   4471 	bcm_rlink_traverse_data_t	r_req;
   4472 	int	r_rv;
   4473 	uint32	r_key[] = {
   4474 		0x08f576a7,0x7bddad71,0xdc08b493,0x2359ce15,0x9ba1b582 };
   4475 	bcm_trill_name_t	r_root_name;
   4476 	bcm_trill_name_t	r_source_rbridge_name;
   4477 	bcm_gport_t	r_port;
   4478 
   4479 	sal_memset(&r_req, 0, sizeof(r_req));
   4480 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   4481 	if (BCM_SUCCESS(r_rv)) {
   4482 		/* Pack request */
   4483 		/* Skip unit */
   4484 
   4485 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   4486 			/* Unpack reply */
   4487 			/* Skip unit */
   4488 			BCM_UNPACK_U32(r_req.rx_ptr, r_root_name);
   4489 			BCM_UNPACK_U32(r_req.rx_ptr, r_source_rbridge_name);
   4490 			BCM_UNPACK_U32(r_req.rx_ptr, r_port);
   4491 
   4492 			r_rv = cb(unit, r_root_name, r_source_rbridge_name, r_port, user_data);
   4493 
   4494 			if (BCM_FAILURE(r_rv)) {
   4495 				break;
   4496 			}
   4497 		}
   4498 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   4499 	}
   4500 
   4501 	return r_rv;
   4502 }
   4503 
   4504 int
   4505 bcm_client_trill_vpn_traverse(
   4506 	int	unit,
   4507 	bcm_trill_vpn_traverse_cb	cb,
   4508 	void *	user_data)
   4509 {
   4510 	bcm_rlink_traverse_data_t	r_req;
   4511 	int	r_rv;
   4512 	uint32	r_key[] = {
   4513 		0xef0ba6f2,0x2f1be987,0xd6790ddb,0xc641032e,0x477b06a0 };
   4514 	bcm_trill_vpn_config_t	r_info;
   4515 	bcm_trill_vpn_config_t *	r_p_info;
   4516 
   4517 	sal_memset(&r_req, 0, sizeof(r_req));
   4518 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   4519 	if (BCM_SUCCESS(r_rv)) {
   4520 		/* Pack request */
   4521 		/* Skip unit */
   4522 
   4523 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   4524 			/* Unpack reply */
   4525 			/* Skip unit */
   4526 			if (*r_req.rx_ptr++ == 1) {
   4527 				r_p_info = NULL;
   4528 			} else {
   4529 				r_p_info = &r_info;
   4530 				r_req.rx_ptr = _bcm_unpack_trill_vpn_config(r_req.rx_ptr, r_p_info);
   4531 			}
   4532 
   4533 			r_rv = cb(unit, r_p_info, user_data);
   4534 
   4535 			if (BCM_FAILURE(r_rv)) {
   4536 				break;
   4537 			}
   4538 		}
   4539 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   4540 	}
   4541 
   4542 	return r_rv;
   4543 }
   4544 
   4545 #endif	/* INCLUDE_L3 */
   4546 
   4547 int
   4548 bcm_client_trunk_resilient_traverse(
   4549 	int	unit,
   4550 	uint32	flags,
   4551 	bcm_trunk_resilient_entry_t *	match_entry,
   4552 	bcm_trunk_resilient_traverse_cb	trav_fn,
   4553 	void *	user_data)
   4554 {
   4555 	bcm_rlink_traverse_data_t	r_req;
   4556 	int	r_rv;
   4557 	uint32	r_key[] = {
   4558 		0x4318345d,0xb11fb2ee,0xbbb9d365,0x1654c88a,0x81e3f8b0 };
   4559 	bcm_trunk_resilient_entry_t	r_entry;
   4560 	bcm_trunk_resilient_entry_t *	r_p_entry;
   4561 
   4562 	sal_memset(&r_req, 0, sizeof(r_req));
   4563 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   4564 	if (BCM_SUCCESS(r_rv)) {
   4565 		/* Pack request */
   4566 		/* Skip unit */
   4567 		BCM_PACK_U32(r_req.tx_ptr, flags);
   4568 		if (match_entry == NULL) {
   4569 			BCM_PACK_U8(r_req.tx_ptr, 1);
   4570 		} else {
   4571 			BCM_PACK_U8(r_req.tx_ptr, 0);
   4572 			r_req.tx_ptr = _bcm_pack_trunk_resilient_entry(r_req.tx_ptr, match_entry);
   4573 		}
   4574 
   4575 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   4576 			/* Unpack reply */
   4577 			/* Skip unit */
   4578 			if (*r_req.rx_ptr++ == 1) {
   4579 				r_p_entry = NULL;
   4580 			} else {
   4581 				r_p_entry = &r_entry;
   4582 				r_req.rx_ptr = _bcm_unpack_trunk_resilient_entry(r_req.rx_ptr, r_p_entry);
   4583 			}
   4584 
   4585 			r_rv = trav_fn(unit, r_p_entry, user_data);
   4586 
   4587 			if (BCM_FAILURE(r_rv)) {
   4588 				break;
   4589 			}
   4590 		}
   4591 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   4592 	}
   4593 
   4594 	return r_rv;
   4595 }
   4596 
   4597 int
   4598 bcm_client_tsn_flowset_traverse(
   4599 	int	unit,
   4600 	bcm_tsn_flowset_traverse_cb	cb,
   4601 	void *	user_data)
   4602 {
   4603 	bcm_rlink_traverse_data_t	r_req;
   4604 	int	r_rv;
   4605 	uint32	r_key[] = {
   4606 		0x6a3fbfcb,0xaac26c81,0x912cc039,0xd1e3b258,0x1bbb6998 };
   4607 	bcm_tsn_flowset_t	r_flowset;
   4608 
   4609 	sal_memset(&r_req, 0, sizeof(r_req));
   4610 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   4611 	if (BCM_SUCCESS(r_rv)) {
   4612 		/* Pack request */
   4613 		/* Skip unit */
   4614 
   4615 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   4616 			/* Unpack reply */
   4617 			/* Skip unit */
   4618 			BCM_UNPACK_U32(r_req.rx_ptr, r_flowset);
   4619 
   4620 			r_rv = cb(unit, r_flowset, user_data);
   4621 
   4622 			if (BCM_FAILURE(r_rv)) {
   4623 				break;
   4624 			}
   4625 		}
   4626 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   4627 	}
   4628 
   4629 	return r_rv;
   4630 }
   4631 
   4632 int
   4633 bcm_client_tsn_mtu_profile_traverse(
   4634 	int	unit,
   4635 	bcm_tsn_mtu_profile_traverse_cb	cb,
   4636 	void *	user_data)
   4637 {
   4638 	bcm_rlink_traverse_data_t	r_req;
   4639 	int	r_rv;
   4640 	uint32	r_key[] = {
   4641 		0x180b66f7,0xe9303243,0x081b9c56,0xb35e6163,0xb6ae99df };
   4642 	int	r_profile_id;
   4643 
   4644 	sal_memset(&r_req, 0, sizeof(r_req));
   4645 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   4646 	if (BCM_SUCCESS(r_rv)) {
   4647 		/* Pack request */
   4648 		/* Skip unit */
   4649 
   4650 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   4651 			/* Unpack reply */
   4652 			/* Skip unit */
   4653 			BCM_UNPACK_U32(r_req.rx_ptr, r_profile_id);
   4654 
   4655 			r_rv = cb(unit, r_profile_id, user_data);
   4656 
   4657 			if (BCM_FAILURE(r_rv)) {
   4658 				break;
   4659 			}
   4660 		}
   4661 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   4662 	}
   4663 
   4664 	return r_rv;
   4665 }
   4666 
   4667 int
   4668 bcm_client_tsn_pri_map_traverse(
   4669 	int	unit,
   4670 	bcm_tsn_pri_map_traverse_cb	cb,
   4671 	void *	user_data)
   4672 {
   4673 	bcm_rlink_traverse_data_t	r_req;
   4674 	int	r_rv;
   4675 	uint32	r_key[] = {
   4676 		0x88111dac,0x1ce4379e,0x766185dc,0x29da72fa,0x0ca81746 };
   4677 	bcm_tsn_pri_map_t	r_map_id;
   4678 
   4679 	sal_memset(&r_req, 0, sizeof(r_req));
   4680 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   4681 	if (BCM_SUCCESS(r_rv)) {
   4682 		/* Pack request */
   4683 		/* Skip unit */
   4684 
   4685 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   4686 			/* Unpack reply */
   4687 			/* Skip unit */
   4688 			BCM_UNPACK_U32(r_req.rx_ptr, r_map_id);
   4689 
   4690 			r_rv = cb(unit, r_map_id, user_data);
   4691 
   4692 			if (BCM_FAILURE(r_rv)) {
   4693 				break;
   4694 			}
   4695 		}
   4696 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   4697 	}
   4698 
   4699 	return r_rv;
   4700 }
   4701 
   4702 int
   4703 bcm_client_tsn_sr_auto_learn_group_traverse(
   4704 	int	unit,
   4705 	bcm_tsn_sr_auto_learn_group_traverse_cb	cb,
   4706 	void *	user_data)
   4707 {
   4708 	bcm_rlink_traverse_data_t	r_req;
   4709 	int	r_rv;
   4710 	uint32	r_key[] = {
   4711 		0x96580783,0xa3e28103,0x555bbfc9,0x7467e2d9,0x940e4740 };
   4712 	int	r_group_id;
   4713 
   4714 	sal_memset(&r_req, 0, sizeof(r_req));
   4715 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   4716 	if (BCM_SUCCESS(r_rv)) {
   4717 		/* Pack request */
   4718 		/* Skip unit */
   4719 
   4720 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   4721 			/* Unpack reply */
   4722 			/* Skip unit */
   4723 			BCM_UNPACK_U32(r_req.rx_ptr, r_group_id);
   4724 
   4725 			r_rv = cb(unit, r_group_id, user_data);
   4726 
   4727 			if (BCM_FAILURE(r_rv)) {
   4728 				break;
   4729 			}
   4730 		}
   4731 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   4732 	}
   4733 
   4734 	return r_rv;
   4735 }
   4736 
   4737 int
   4738 bcm_client_tsn_sr_flowset_traverse(
   4739 	int	unit,
   4740 	int	is_rx,
   4741 	bcm_tsn_sr_flowset_traverse_cb	cb,
   4742 	void *	user_data)
   4743 {
   4744 	bcm_rlink_traverse_data_t	r_req;
   4745 	int	r_rv;
   4746 	uint32	r_key[] = {
   4747 		0x4f0ed9d0,0xcfb08fd5,0xeb8b186d,0x18747c5a,0xd8d03ebb };
   4748 	bcm_tsn_sr_flowset_t	r_flowset;
   4749 
   4750 	sal_memset(&r_req, 0, sizeof(r_req));
   4751 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   4752 	if (BCM_SUCCESS(r_rv)) {
   4753 		/* Pack request */
   4754 		/* Skip unit */
   4755 		BCM_PACK_U32(r_req.tx_ptr, is_rx);
   4756 
   4757 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   4758 			/* Unpack reply */
   4759 			/* Skip unit */
   4760 			BCM_UNPACK_U32(r_req.rx_ptr, r_flowset);
   4761 
   4762 			r_rv = cb(unit, r_flowset, user_data);
   4763 
   4764 			if (BCM_FAILURE(r_rv)) {
   4765 				break;
   4766 			}
   4767 		}
   4768 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   4769 	}
   4770 
   4771 	return r_rv;
   4772 }
   4773 
   4774 int
   4775 bcm_client_tsn_stat_group_traverse(
   4776 	int	unit,
   4777 	bcm_tsn_stat_group_traverse_cb	cb,
   4778 	void *	user_data)
   4779 {
   4780 	bcm_rlink_traverse_data_t	r_req;
   4781 	int	r_rv;
   4782 	uint32	r_key[] = {
   4783 		0x6143b6b2,0xb17fc08a,0x6767beb2,0xf24d5859,0x290180ab };
   4784 	bcm_tsn_stat_group_t	r_id;
   4785 
   4786 	sal_memset(&r_req, 0, sizeof(r_req));
   4787 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   4788 	if (BCM_SUCCESS(r_rv)) {
   4789 		/* Pack request */
   4790 		/* Skip unit */
   4791 
   4792 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   4793 			/* Unpack reply */
   4794 			/* Skip unit */
   4795 			BCM_UNPACK_U32(r_req.rx_ptr, r_id);
   4796 
   4797 			r_rv = cb(unit, r_id, user_data);
   4798 
   4799 			if (BCM_FAILURE(r_rv)) {
   4800 				break;
   4801 			}
   4802 		}
   4803 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   4804 	}
   4805 
   4806 	return r_rv;
   4807 }
   4808 
   4809 int
   4810 bcm_client_tsn_stu_profile_traverse(
   4811 	int	unit,
   4812 	bcm_tsn_stu_profile_traverse_cb	cb,
   4813 	void *	user_data)
   4814 {
   4815 	bcm_rlink_traverse_data_t	r_req;
   4816 	int	r_rv;
   4817 	uint32	r_key[] = {
   4818 		0x68c7882c,0xe66787f9,0xa4e9df2e,0xa8f2bbfd,0xa2ca63d0 };
   4819 	int	r_profile_id;
   4820 
   4821 	sal_memset(&r_req, 0, sizeof(r_req));
   4822 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   4823 	if (BCM_SUCCESS(r_rv)) {
   4824 		/* Pack request */
   4825 		/* Skip unit */
   4826 
   4827 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   4828 			/* Unpack reply */
   4829 			/* Skip unit */
   4830 			BCM_UNPACK_U32(r_req.rx_ptr, r_profile_id);
   4831 
   4832 			r_rv = cb(unit, r_profile_id, user_data);
   4833 
   4834 			if (BCM_FAILURE(r_rv)) {
   4835 				break;
   4836 			}
   4837 		}
   4838 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   4839 	}
   4840 
   4841 	return r_rv;
   4842 }
   4843 
   4844 int
   4845 bcm_client_tsn_taf_cosq_mapping_profile_traverse(
   4846 	int	unit,
   4847 	bcm_tsn_taf_cosq_mapping_profile_traverse_cb	cb,
   4848 	void *	user_data)
   4849 {
   4850 	bcm_rlink_traverse_data_t	r_req;
   4851 	int	r_rv;
   4852 	uint32	r_key[] = {
   4853 		0xf63a1f4c,0x0d11b393,0x15cafbf8,0x26cecae7,0x1d2c0b99 };
   4854 	int	r_cosq_profile;
   4855 
   4856 	sal_memset(&r_req, 0, sizeof(r_req));
   4857 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   4858 	if (BCM_SUCCESS(r_rv)) {
   4859 		/* Pack request */
   4860 		/* Skip unit */
   4861 
   4862 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   4863 			/* Unpack reply */
   4864 			/* Skip unit */
   4865 			BCM_UNPACK_U32(r_req.rx_ptr, r_cosq_profile);
   4866 
   4867 			r_rv = cb(unit, r_cosq_profile, user_data);
   4868 
   4869 			if (BCM_FAILURE(r_rv)) {
   4870 				break;
   4871 			}
   4872 		}
   4873 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   4874 	}
   4875 
   4876 	return r_rv;
   4877 }
   4878 
   4879 int
   4880 bcm_client_tsn_taf_gate_max_bytes_profile_traverse(
   4881 	int	unit,
   4882 	int	taf_gate_id,
   4883 	bcm_tsn_taf_gate_max_bytes_profile_traverse_cb	cb,
   4884 	void *	user_data)
   4885 {
   4886 	bcm_rlink_traverse_data_t	r_req;
   4887 	int	r_rv;
   4888 	uint32	r_key[] = {
   4889 		0x220804c1,0xe673abd3,0x2cb44f01,0x617481d8,0x3592bf92 };
   4890 	int	r_taf_gate_id;
   4891 	int	r_profile_id;
   4892 
   4893 	sal_memset(&r_req, 0, sizeof(r_req));
   4894 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   4895 	if (BCM_SUCCESS(r_rv)) {
   4896 		/* Pack request */
   4897 		/* Skip unit */
   4898 		BCM_PACK_U32(r_req.tx_ptr, taf_gate_id);
   4899 
   4900 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   4901 			/* Unpack reply */
   4902 			/* Skip unit */
   4903 			BCM_UNPACK_U32(r_req.rx_ptr, r_taf_gate_id);
   4904 			BCM_UNPACK_U32(r_req.rx_ptr, r_profile_id);
   4905 
   4906 			r_rv = cb(unit, r_taf_gate_id, r_profile_id, user_data);
   4907 
   4908 			if (BCM_FAILURE(r_rv)) {
   4909 				break;
   4910 			}
   4911 		}
   4912 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   4913 	}
   4914 
   4915 	return r_rv;
   4916 }
   4917 
   4918 int
   4919 bcm_client_tsn_taf_gate_traverse(
   4920 	int	unit,
   4921 	bcm_tsn_taf_gate_traverse_cb	cb,
   4922 	void *	user_data)
   4923 {
   4924 	bcm_rlink_traverse_data_t	r_req;
   4925 	int	r_rv;
   4926 	uint32	r_key[] = {
   4927 		0x8df4de24,0x870eff37,0x3dbbc488,0xe796f10d,0xfed2907b };
   4928 	int	r_taf_gate;
   4929 
   4930 	sal_memset(&r_req, 0, sizeof(r_req));
   4931 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   4932 	if (BCM_SUCCESS(r_rv)) {
   4933 		/* Pack request */
   4934 		/* Skip unit */
   4935 
   4936 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   4937 			/* Unpack reply */
   4938 			/* Skip unit */
   4939 			BCM_UNPACK_U32(r_req.rx_ptr, r_taf_gate);
   4940 
   4941 			r_rv = cb(unit, r_taf_gate, user_data);
   4942 
   4943 			if (BCM_FAILURE(r_rv)) {
   4944 				break;
   4945 			}
   4946 		}
   4947 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   4948 	}
   4949 
   4950 	return r_rv;
   4951 }
   4952 
   4953 int
   4954 bcm_client_tsn_taf_profile_traverse(
   4955 	int	unit,
   4956 	int	taf_gate,
   4957 	bcm_tsn_taf_profile_traverse_cb	cb,
   4958 	void *	user_data)
   4959 {
   4960 	bcm_rlink_traverse_data_t	r_req;
   4961 	int	r_rv;
   4962 	uint32	r_key[] = {
   4963 		0x7adcf05c,0x6704b5d0,0xa4ff5095,0x94ddc9a4,0x444131f9 };
   4964 	int	r_taf_gate;
   4965 	bcm_tsn_taf_profile_id_t	r_pid;
   4966 
   4967 	sal_memset(&r_req, 0, sizeof(r_req));
   4968 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   4969 	if (BCM_SUCCESS(r_rv)) {
   4970 		/* Pack request */
   4971 		/* Skip unit */
   4972 		BCM_PACK_U32(r_req.tx_ptr, taf_gate);
   4973 
   4974 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   4975 			/* Unpack reply */
   4976 			/* Skip unit */
   4977 			BCM_UNPACK_U32(r_req.rx_ptr, r_taf_gate);
   4978 			BCM_UNPACK_U32(r_req.rx_ptr, r_pid);
   4979 
   4980 			r_rv = cb(unit, r_taf_gate, r_pid, user_data);
   4981 
   4982 			if (BCM_FAILURE(r_rv)) {
   4983 				break;
   4984 			}
   4985 		}
   4986 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   4987 	}
   4988 
   4989 	return r_rv;
   4990 }
   4991 
   4992 #ifdef	INCLUDE_L3
   4993 
   4994 int
   4995 bcm_client_tunnel_initiator_traverse(
   4996 	int	unit,
   4997 	bcm_tunnel_initiator_traverse_cb	cb,
   4998 	void *	user_data)
   4999 {
   5000 	bcm_rlink_traverse_data_t	r_req;
   5001 	int	r_rv;
   5002 	uint32	r_key[] = {
   5003 		0x90aa59df,0x23e558c0,0x152679e9,0xbfdc8a62,0x05e3ca52 };
   5004 	bcm_tunnel_initiator_t	r_info;
   5005 	bcm_tunnel_initiator_t *	r_p_info;
   5006 
   5007 	sal_memset(&r_req, 0, sizeof(r_req));
   5008 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   5009 	if (BCM_SUCCESS(r_rv)) {
   5010 		/* Pack request */
   5011 		/* Skip unit */
   5012 
   5013 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   5014 			/* Unpack reply */
   5015 			/* Skip unit */
   5016 			if (*r_req.rx_ptr++ == 1) {
   5017 				r_p_info = NULL;
   5018 			} else {
   5019 				r_p_info = &r_info;
   5020 				r_req.rx_ptr = _bcm_unpack_tunnel_initiator(r_req.rx_ptr, r_p_info);
   5021 			}
   5022 
   5023 			r_rv = cb(unit, r_p_info, user_data);
   5024 
   5025 			if (BCM_FAILURE(r_rv)) {
   5026 				break;
   5027 			}
   5028 		}
   5029 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   5030 	}
   5031 
   5032 	return r_rv;
   5033 }
   5034 
   5035 int
   5036 bcm_client_tunnel_terminator_config_traverse(
   5037 	int	unit,
   5038 	bcm_tunnel_terminator_config_traverse_cb	cb,
   5039 	void *	user_data)
   5040 {
   5041 	bcm_rlink_traverse_data_t	r_req;
   5042 	int	r_rv;
   5043 	uint32	r_key[] = {
   5044 		0xd7f837b9,0x3137bb6c,0x5c83172d,0xbb3e07ae,0x4819091d };
   5045 	bcm_tunnel_terminator_config_key_t	r_info;
   5046 	bcm_tunnel_terminator_config_key_t *	r_p_info;
   5047 
   5048 	sal_memset(&r_req, 0, sizeof(r_req));
   5049 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   5050 	if (BCM_SUCCESS(r_rv)) {
   5051 		/* Pack request */
   5052 		/* Skip unit */
   5053 
   5054 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   5055 			/* Unpack reply */
   5056 			/* Skip unit */
   5057 			if (*r_req.rx_ptr++ == 1) {
   5058 				r_p_info = NULL;
   5059 			} else {
   5060 				r_p_info = &r_info;
   5061 				r_req.rx_ptr = _bcm_unpack_tunnel_terminator_config_key(r_req.rx_ptr, r_p_info);
   5062 			}
   5063 
   5064 			r_rv = cb(unit, r_p_info, user_data);
   5065 
   5066 			if (BCM_FAILURE(r_rv)) {
   5067 				break;
   5068 			}
   5069 		}
   5070 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   5071 	}
   5072 
   5073 	return r_rv;
   5074 }
   5075 
   5076 int
   5077 bcm_client_tunnel_terminator_traverse(
   5078 	int	unit,
   5079 	bcm_tunnel_terminator_traverse_cb	cb,
   5080 	void *	user_data)
   5081 {
   5082 	bcm_rlink_traverse_data_t	r_req;
   5083 	int	r_rv;
   5084 	uint32	r_key[] = {
   5085 		0xebac6b51,0x4b5e8c2d,0xfd8326cf,0x1e467ef5,0x97a852bd };
   5086 	bcm_tunnel_terminator_t	r_info;
   5087 	bcm_tunnel_terminator_t *	r_p_info;
   5088 
   5089 	sal_memset(&r_req, 0, sizeof(r_req));
   5090 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   5091 	if (BCM_SUCCESS(r_rv)) {
   5092 		/* Pack request */
   5093 		/* Skip unit */
   5094 
   5095 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   5096 			/* Unpack reply */
   5097 			/* Skip unit */
   5098 			if (*r_req.rx_ptr++ == 1) {
   5099 				r_p_info = NULL;
   5100 			} else {
   5101 				r_p_info = &r_info;
   5102 				r_req.rx_ptr = _bcm_unpack_tunnel_terminator(r_req.rx_ptr, r_p_info);
   5103 			}
   5104 
   5105 			r_rv = cb(unit, r_p_info, user_data);
   5106 
   5107 			if (BCM_FAILURE(r_rv)) {
   5108 				break;
   5109 			}
   5110 		}
   5111 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   5112 	}
   5113 
   5114 	return r_rv;
   5115 }
   5116 
   5117 #endif	/* INCLUDE_L3 */
   5118 
   5119 int
   5120 bcm_client_vlan_cross_connect_traverse(
   5121 	int	unit,
   5122 	bcm_vlan_cross_connect_traverse_cb	cb,
   5123 	void *	user_data)
   5124 {
   5125 	bcm_rlink_traverse_data_t	r_req;
   5126 	int	r_rv;
   5127 	uint32	r_key[] = {
   5128 		0x9b81a1e3,0x30e13ed8,0x2c88e0b6,0x806061d6,0x2d25b128 };
   5129 	bcm_vlan_t	r_outer_vlan;
   5130 	bcm_vlan_t	r_inner_vlan;
   5131 	bcm_gport_t	r_port_1;
   5132 	bcm_gport_t	r_port_2;
   5133 
   5134 	sal_memset(&r_req, 0, sizeof(r_req));
   5135 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   5136 	if (BCM_SUCCESS(r_rv)) {
   5137 		/* Pack request */
   5138 		/* Skip unit */
   5139 
   5140 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   5141 			/* Unpack reply */
   5142 			/* Skip unit */
   5143 			BCM_UNPACK_U16(r_req.rx_ptr, r_outer_vlan);
   5144 			BCM_UNPACK_U16(r_req.rx_ptr, r_inner_vlan);
   5145 			BCM_UNPACK_U32(r_req.rx_ptr, r_port_1);
   5146 			BCM_UNPACK_U32(r_req.rx_ptr, r_port_2);
   5147 
   5148 			r_rv = cb(unit, r_outer_vlan, r_inner_vlan, r_port_1, r_port_2, user_data);
   5149 
   5150 			if (BCM_FAILURE(r_rv)) {
   5151 				break;
   5152 			}
   5153 		}
   5154 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   5155 	}
   5156 
   5157 	return r_rv;
   5158 }
   5159 
   5160 int
   5161 bcm_client_vlan_dtag_range_traverse(
   5162 	int	unit,
   5163 	bcm_vlan_dtag_range_traverse_cb	cb,
   5164 	void *	user_data)
   5165 {
   5166 	bcm_rlink_traverse_data_t	r_req;
   5167 	int	r_rv;
   5168 	uint32	r_key[] = {
   5169 		0xecace45d,0x604f598a,0x2bd096c2,0x08717feb,0x18c78766 };
   5170 	bcm_gport_t	r_port;
   5171 	bcm_vlan_t	r_old_vlan_low;
   5172 	bcm_vlan_t	r_old_vlan_high;
   5173 	bcm_vlan_t	r_new_vlan;
   5174 	int	r_prio;
   5175 
   5176 	sal_memset(&r_req, 0, sizeof(r_req));
   5177 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   5178 	if (BCM_SUCCESS(r_rv)) {
   5179 		/* Pack request */
   5180 		/* Skip unit */
   5181 
   5182 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   5183 			/* Unpack reply */
   5184 			/* Skip unit */
   5185 			BCM_UNPACK_U32(r_req.rx_ptr, r_port);
   5186 			BCM_UNPACK_U16(r_req.rx_ptr, r_old_vlan_low);
   5187 			BCM_UNPACK_U16(r_req.rx_ptr, r_old_vlan_high);
   5188 			BCM_UNPACK_U16(r_req.rx_ptr, r_new_vlan);
   5189 			BCM_UNPACK_U32(r_req.rx_ptr, r_prio);
   5190 
   5191 			r_rv = cb(unit, r_port, r_old_vlan_low, r_old_vlan_high, r_new_vlan, r_prio, user_data);
   5192 
   5193 			if (BCM_FAILURE(r_rv)) {
   5194 				break;
   5195 			}
   5196 		}
   5197 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   5198 	}
   5199 
   5200 	return r_rv;
   5201 }
   5202 
   5203 int
   5204 bcm_client_vlan_dtag_traverse(
   5205 	int	unit,
   5206 	bcm_vlan_dtag_traverse_cb	cb,
   5207 	void *	user_data)
   5208 {
   5209 	bcm_rlink_traverse_data_t	r_req;
   5210 	int	r_rv;
   5211 	uint32	r_key[] = {
   5212 		0x9463324c,0x9c4abd42,0xd58d3258,0x97c563e2,0xb4754ba3 };
   5213 	bcm_gport_t	r_port;
   5214 	bcm_vlan_t	r_old_vlan;
   5215 	bcm_vlan_t	r_new_vlan;
   5216 	int	r_prio;
   5217 
   5218 	sal_memset(&r_req, 0, sizeof(r_req));
   5219 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   5220 	if (BCM_SUCCESS(r_rv)) {
   5221 		/* Pack request */
   5222 		/* Skip unit */
   5223 
   5224 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   5225 			/* Unpack reply */
   5226 			/* Skip unit */
   5227 			BCM_UNPACK_U32(r_req.rx_ptr, r_port);
   5228 			BCM_UNPACK_U16(r_req.rx_ptr, r_old_vlan);
   5229 			BCM_UNPACK_U16(r_req.rx_ptr, r_new_vlan);
   5230 			BCM_UNPACK_U32(r_req.rx_ptr, r_prio);
   5231 
   5232 			r_rv = cb(unit, r_port, r_old_vlan, r_new_vlan, r_prio, user_data);
   5233 
   5234 			if (BCM_FAILURE(r_rv)) {
   5235 				break;
   5236 			}
   5237 		}
   5238 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   5239 	}
   5240 
   5241 	return r_rv;
   5242 }
   5243 
   5244 int
   5245 bcm_client_vlan_ip_action_traverse(
   5246 	int	unit,
   5247 	bcm_vlan_ip_action_traverse_cb	cb,
   5248 	void *	user_data)
   5249 {
   5250 	bcm_rlink_traverse_data_t	r_req;
   5251 	int	r_rv;
   5252 	uint32	r_key[] = {
   5253 		0xefbb89d5,0x4a559662,0xde80ed51,0x4c007b8f,0x0974bb66 };
   5254 	bcm_vlan_ip_t	r_vlan_ip;
   5255 	bcm_vlan_action_set_t	r_action;
   5256 	bcm_vlan_ip_t *	r_p_vlan_ip;
   5257 	bcm_vlan_action_set_t *	r_p_action;
   5258 
   5259 	sal_memset(&r_req, 0, sizeof(r_req));
   5260 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   5261 	if (BCM_SUCCESS(r_rv)) {
   5262 		/* Pack request */
   5263 		/* Skip unit */
   5264 
   5265 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   5266 			/* Unpack reply */
   5267 			/* Skip unit */
   5268 			if (*r_req.rx_ptr++ == 1) {
   5269 				r_p_vlan_ip = NULL;
   5270 			} else {
   5271 				r_p_vlan_ip = &r_vlan_ip;
   5272 				r_req.rx_ptr = _bcm_unpack_vlan_ip(r_req.rx_ptr, r_p_vlan_ip);
   5273 			}
   5274 			if (*r_req.rx_ptr++ == 1) {
   5275 				r_p_action = NULL;
   5276 			} else {
   5277 				r_p_action = &r_action;
   5278 				r_req.rx_ptr = _bcm_unpack_vlan_action_set(r_req.rx_ptr, r_p_action);
   5279 			}
   5280 
   5281 			r_rv = cb(unit, r_p_vlan_ip, r_p_action, user_data);
   5282 
   5283 			if (BCM_FAILURE(r_rv)) {
   5284 				break;
   5285 			}
   5286 		}
   5287 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   5288 	}
   5289 
   5290 	return r_rv;
   5291 }
   5292 
   5293 int
   5294 bcm_client_vlan_mac_action_traverse(
   5295 	int	unit,
   5296 	bcm_vlan_mac_action_traverse_cb	cb,
   5297 	void *	user_data)
   5298 {
   5299 	bcm_rlink_traverse_data_t	r_req;
   5300 	int	r_rv;
   5301 	uint32	r_key[] = {
   5302 		0xa3ed9bb5,0x865fc75a,0xa70b17e5,0x985c5995,0x70c760f8 };
   5303 	bcm_mac_t	r_mac;
   5304 	bcm_vlan_action_set_t	r_action;
   5305 	bcm_vlan_action_set_t *	r_p_action;
   5306 
   5307 	sal_memset(&r_req, 0, sizeof(r_req));
   5308 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   5309 	if (BCM_SUCCESS(r_rv)) {
   5310 		/* Pack request */
   5311 		/* Skip unit */
   5312 
   5313 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   5314 			/* Unpack reply */
   5315 			/* Skip unit */
   5316 			r_req.rx_ptr = _bcm_unpack_mac(r_req.rx_ptr, r_mac);
   5317 			if (*r_req.rx_ptr++ == 1) {
   5318 				r_p_action = NULL;
   5319 			} else {
   5320 				r_p_action = &r_action;
   5321 				r_req.rx_ptr = _bcm_unpack_vlan_action_set(r_req.rx_ptr, r_p_action);
   5322 			}
   5323 
   5324 			r_rv = cb(unit, r_mac, r_p_action, user_data);
   5325 
   5326 			if (BCM_FAILURE(r_rv)) {
   5327 				break;
   5328 			}
   5329 		}
   5330 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   5331 	}
   5332 
   5333 	return r_rv;
   5334 }
   5335 
   5336 int
   5337 bcm_client_vlan_port_protocol_action_traverse(
   5338 	int	unit,
   5339 	bcm_vlan_port_protocol_action_traverse_cb	cb,
   5340 	void *	user_data)
   5341 {
   5342 	bcm_rlink_traverse_data_t	r_req;
   5343 	int	r_rv;
   5344 	uint32	r_key[] = {
   5345 		0x05e54e9f,0xdb836cfa,0xe46d5689,0x89bcfb19,0xff0ee886 };
   5346 	bcm_port_t	r_port;
   5347 	bcm_port_frametype_t	r_frame;
   5348 	bcm_port_ethertype_t	r_ether;
   5349 	bcm_vlan_action_set_t	r_action;
   5350 	bcm_vlan_action_set_t *	r_p_action;
   5351 
   5352 	sal_memset(&r_req, 0, sizeof(r_req));
   5353 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   5354 	if (BCM_SUCCESS(r_rv)) {
   5355 		/* Pack request */
   5356 		/* Skip unit */
   5357 
   5358 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   5359 			/* Unpack reply */
   5360 			/* Skip unit */
   5361 			BCM_UNPACK_U32(r_req.rx_ptr, r_port);
   5362 			BCM_UNPACK_U32(r_req.rx_ptr, r_frame);
   5363 			BCM_UNPACK_U16(r_req.rx_ptr, r_ether);
   5364 			if (*r_req.rx_ptr++ == 1) {
   5365 				r_p_action = NULL;
   5366 			} else {
   5367 				r_p_action = &r_action;
   5368 				r_req.rx_ptr = _bcm_unpack_vlan_action_set(r_req.rx_ptr, r_p_action);
   5369 			}
   5370 
   5371 			r_rv = cb(unit, r_port, r_frame, r_ether, r_p_action, user_data);
   5372 
   5373 			if (BCM_FAILURE(r_rv)) {
   5374 				break;
   5375 			}
   5376 		}
   5377 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   5378 	}
   5379 
   5380 	return r_rv;
   5381 }
   5382 
   5383 int
   5384 bcm_client_vlan_port_traverse(
   5385 	int	unit,
   5386 	bcm_vlan_port_traverse_info_t *	additional_info,
   5387 	bcm_vlan_port_traverse_cb	trav_fn,
   5388 	void *	user_data)
   5389 {
   5390 	bcm_rlink_traverse_data_t	r_req;
   5391 	int	r_rv;
   5392 	uint32	r_key[] = {
   5393 		0xe6204f0c,0xea05a511,0xd03ba466,0xf71764f3,0xac36ba33 };
   5394 	bcm_vlan_port_t	r_vlan_port;
   5395 	bcm_vlan_port_t *	r_p_vlan_port;
   5396 
   5397 	sal_memset(&r_req, 0, sizeof(r_req));
   5398 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   5399 	if (BCM_SUCCESS(r_rv)) {
   5400 		/* Pack request */
   5401 		/* Skip unit */
   5402 		if (additional_info == NULL) {
   5403 			BCM_PACK_U8(r_req.tx_ptr, 1);
   5404 		} else {
   5405 			BCM_PACK_U8(r_req.tx_ptr, 0);
   5406 			BCM_PACK_U32(r_req.tx_ptr, additional_info->flags);
   5407 		}
   5408 
   5409 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   5410 			/* Unpack reply */
   5411 			/* Skip unit */
   5412 			if (*r_req.rx_ptr++ == 1) {
   5413 				r_p_vlan_port = NULL;
   5414 			} else {
   5415 				r_p_vlan_port = &r_vlan_port;
   5416 				r_req.rx_ptr = _bcm_unpack_vlan_port(r_req.rx_ptr, r_p_vlan_port);
   5417 			}
   5418 
   5419 			r_rv = trav_fn(unit, r_p_vlan_port, user_data);
   5420 
   5421 			if (BCM_FAILURE(r_rv)) {
   5422 				break;
   5423 			}
   5424 		}
   5425 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   5426 	}
   5427 
   5428 	return r_rv;
   5429 }
   5430 
   5431 int
   5432 bcm_client_vlan_translate_action_range_traverse(
   5433 	int	unit,
   5434 	bcm_vlan_translate_action_range_traverse_cb	cb,
   5435 	void *	user_data)
   5436 {
   5437 	bcm_rlink_traverse_data_t	r_req;
   5438 	int	r_rv;
   5439 	uint32	r_key[] = {
   5440 		0x31fa6e34,0xacb376f6,0xc54b4087,0xf40b84c4,0x11d6c6d8 };
   5441 	bcm_gport_t	r_port;
   5442 	bcm_vlan_t	r_outer_vlan_low;
   5443 	bcm_vlan_t	r_outer_vlan_high;
   5444 	bcm_vlan_t	r_inner_vlan_low;
   5445 	bcm_vlan_t	r_inner_vlan_high;
   5446 	bcm_vlan_action_set_t	r_action;
   5447 	bcm_vlan_action_set_t *	r_p_action;
   5448 
   5449 	sal_memset(&r_req, 0, sizeof(r_req));
   5450 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   5451 	if (BCM_SUCCESS(r_rv)) {
   5452 		/* Pack request */
   5453 		/* Skip unit */
   5454 
   5455 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   5456 			/* Unpack reply */
   5457 			/* Skip unit */
   5458 			BCM_UNPACK_U32(r_req.rx_ptr, r_port);
   5459 			BCM_UNPACK_U16(r_req.rx_ptr, r_outer_vlan_low);
   5460 			BCM_UNPACK_U16(r_req.rx_ptr, r_outer_vlan_high);
   5461 			BCM_UNPACK_U16(r_req.rx_ptr, r_inner_vlan_low);
   5462 			BCM_UNPACK_U16(r_req.rx_ptr, r_inner_vlan_high);
   5463 			if (*r_req.rx_ptr++ == 1) {
   5464 				r_p_action = NULL;
   5465 			} else {
   5466 				r_p_action = &r_action;
   5467 				r_req.rx_ptr = _bcm_unpack_vlan_action_set(r_req.rx_ptr, r_p_action);
   5468 			}
   5469 
   5470 			r_rv = cb(unit, r_port, r_outer_vlan_low, r_outer_vlan_high, r_inner_vlan_low, r_inner_vlan_high, r_p_action, user_data);
   5471 
   5472 			if (BCM_FAILURE(r_rv)) {
   5473 				break;
   5474 			}
   5475 		}
   5476 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   5477 	}
   5478 
   5479 	return r_rv;
   5480 }
   5481 
   5482 int
   5483 bcm_client_vlan_translate_action_traverse(
   5484 	int	unit,
   5485 	bcm_vlan_translate_action_traverse_cb	cb,
   5486 	void *	user_data)
   5487 {
   5488 	bcm_rlink_traverse_data_t	r_req;
   5489 	int	r_rv;
   5490 	uint32	r_key[] = {
   5491 		0x6994f48d,0x4364f04f,0x0c31cf30,0x5487894a,0xccc734a1 };
   5492 	bcm_gport_t	r_port;
   5493 	bcm_vlan_translate_key_t	r_key_type;
   5494 	bcm_vlan_t	r_outer_vlan;
   5495 	bcm_vlan_t	r_inner_vlan;
   5496 	bcm_vlan_action_set_t	r_action;
   5497 	bcm_vlan_action_set_t *	r_p_action;
   5498 
   5499 	sal_memset(&r_req, 0, sizeof(r_req));
   5500 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   5501 	if (BCM_SUCCESS(r_rv)) {
   5502 		/* Pack request */
   5503 		/* Skip unit */
   5504 
   5505 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   5506 			/* Unpack reply */
   5507 			/* Skip unit */
   5508 			BCM_UNPACK_U32(r_req.rx_ptr, r_port);
   5509 			BCM_UNPACK_U32(r_req.rx_ptr, r_key_type);
   5510 			BCM_UNPACK_U16(r_req.rx_ptr, r_outer_vlan);
   5511 			BCM_UNPACK_U16(r_req.rx_ptr, r_inner_vlan);
   5512 			if (*r_req.rx_ptr++ == 1) {
   5513 				r_p_action = NULL;
   5514 			} else {
   5515 				r_p_action = &r_action;
   5516 				r_req.rx_ptr = _bcm_unpack_vlan_action_set(r_req.rx_ptr, r_p_action);
   5517 			}
   5518 
   5519 			r_rv = cb(unit, r_port, r_key_type, r_outer_vlan, r_inner_vlan, r_p_action, user_data);
   5520 
   5521 			if (BCM_FAILURE(r_rv)) {
   5522 				break;
   5523 			}
   5524 		}
   5525 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   5526 	}
   5527 
   5528 	return r_rv;
   5529 }
   5530 
   5531 int
   5532 bcm_client_vlan_translate_egress_action_traverse(
   5533 	int	unit,
   5534 	bcm_vlan_translate_egress_action_traverse_cb	cb,
   5535 	void *	user_data)
   5536 {
   5537 	bcm_rlink_traverse_data_t	r_req;
   5538 	int	r_rv;
   5539 	uint32	r_key[] = {
   5540 		0xc13ddf2f,0xfb47b82d,0x4cda9795,0xc016496d,0xd6ec48fd };
   5541 	int	r_port_class;
   5542 	bcm_vlan_t	r_outer_vlan;
   5543 	bcm_vlan_t	r_inner_vlan;
   5544 	bcm_vlan_action_set_t	r_action;
   5545 	bcm_vlan_action_set_t *	r_p_action;
   5546 
   5547 	sal_memset(&r_req, 0, sizeof(r_req));
   5548 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   5549 	if (BCM_SUCCESS(r_rv)) {
   5550 		/* Pack request */
   5551 		/* Skip unit */
   5552 
   5553 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   5554 			/* Unpack reply */
   5555 			/* Skip unit */
   5556 			BCM_UNPACK_U32(r_req.rx_ptr, r_port_class);
   5557 			BCM_UNPACK_U16(r_req.rx_ptr, r_outer_vlan);
   5558 			BCM_UNPACK_U16(r_req.rx_ptr, r_inner_vlan);
   5559 			if (*r_req.rx_ptr++ == 1) {
   5560 				r_p_action = NULL;
   5561 			} else {
   5562 				r_p_action = &r_action;
   5563 				r_req.rx_ptr = _bcm_unpack_vlan_action_set(r_req.rx_ptr, r_p_action);
   5564 			}
   5565 
   5566 			r_rv = cb(unit, r_port_class, r_outer_vlan, r_inner_vlan, r_p_action, user_data);
   5567 
   5568 			if (BCM_FAILURE(r_rv)) {
   5569 				break;
   5570 			}
   5571 		}
   5572 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   5573 	}
   5574 
   5575 	return r_rv;
   5576 }
   5577 
   5578 int
   5579 bcm_client_vlan_translate_egress_traverse(
   5580 	int	unit,
   5581 	bcm_vlan_translate_egress_traverse_cb	cb,
   5582 	void *	user_data)
   5583 {
   5584 	bcm_rlink_traverse_data_t	r_req;
   5585 	int	r_rv;
   5586 	uint32	r_key[] = {
   5587 		0x2d222e96,0x2f3ca059,0x8b18e874,0xa3c14190,0xf4512a5b };
   5588 	bcm_gport_t	r_port;
   5589 	bcm_vlan_t	r_old_vlan;
   5590 	bcm_vlan_t	r_new_vlan;
   5591 	int	r_prio;
   5592 
   5593 	sal_memset(&r_req, 0, sizeof(r_req));
   5594 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   5595 	if (BCM_SUCCESS(r_rv)) {
   5596 		/* Pack request */
   5597 		/* Skip unit */
   5598 
   5599 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   5600 			/* Unpack reply */
   5601 			/* Skip unit */
   5602 			BCM_UNPACK_U32(r_req.rx_ptr, r_port);
   5603 			BCM_UNPACK_U16(r_req.rx_ptr, r_old_vlan);
   5604 			BCM_UNPACK_U16(r_req.rx_ptr, r_new_vlan);
   5605 			BCM_UNPACK_U32(r_req.rx_ptr, r_prio);
   5606 
   5607 			r_rv = cb(unit, r_port, r_old_vlan, r_new_vlan, r_prio, user_data);
   5608 
   5609 			if (BCM_FAILURE(r_rv)) {
   5610 				break;
   5611 			}
   5612 		}
   5613 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   5614 	}
   5615 
   5616 	return r_rv;
   5617 }
   5618 
   5619 int
   5620 bcm_client_vlan_translate_range_traverse(
   5621 	int	unit,
   5622 	bcm_vlan_translate_range_traverse_cb	cb,
   5623 	void *	user_data)
   5624 {
   5625 	bcm_rlink_traverse_data_t	r_req;
   5626 	int	r_rv;
   5627 	uint32	r_key[] = {
   5628 		0x1fc89dd9,0xc16c9083,0x4aeb7b35,0x1b8d0c83,0x4f104003 };
   5629 	bcm_gport_t	r_port;
   5630 	bcm_vlan_t	r_old_vlan_low;
   5631 	bcm_vlan_t	r_old_vlan_high;
   5632 	bcm_vlan_t	r_new_vlan;
   5633 	int	r_prio;
   5634 
   5635 	sal_memset(&r_req, 0, sizeof(r_req));
   5636 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   5637 	if (BCM_SUCCESS(r_rv)) {
   5638 		/* Pack request */
   5639 		/* Skip unit */
   5640 
   5641 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   5642 			/* Unpack reply */
   5643 			/* Skip unit */
   5644 			BCM_UNPACK_U32(r_req.rx_ptr, r_port);
   5645 			BCM_UNPACK_U16(r_req.rx_ptr, r_old_vlan_low);
   5646 			BCM_UNPACK_U16(r_req.rx_ptr, r_old_vlan_high);
   5647 			BCM_UNPACK_U16(r_req.rx_ptr, r_new_vlan);
   5648 			BCM_UNPACK_U32(r_req.rx_ptr, r_prio);
   5649 
   5650 			r_rv = cb(unit, r_port, r_old_vlan_low, r_old_vlan_high, r_new_vlan, r_prio, user_data);
   5651 
   5652 			if (BCM_FAILURE(r_rv)) {
   5653 				break;
   5654 			}
   5655 		}
   5656 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   5657 	}
   5658 
   5659 	return r_rv;
   5660 }
   5661 
   5662 int
   5663 bcm_client_vlan_translate_traverse(
   5664 	int	unit,
   5665 	bcm_vlan_translate_traverse_cb	cb,
   5666 	void *	user_data)
   5667 {
   5668 	bcm_rlink_traverse_data_t	r_req;
   5669 	int	r_rv;
   5670 	uint32	r_key[] = {
   5671 		0x0640d32f,0x4f1e5c31,0xcdf1e172,0xae1e6445,0x9ce22c65 };
   5672 	bcm_gport_t	r_port;
   5673 	bcm_vlan_t	r_old_vlan;
   5674 	bcm_vlan_t	r_new_vlan;
   5675 	int	r_prio;
   5676 
   5677 	sal_memset(&r_req, 0, sizeof(r_req));
   5678 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   5679 	if (BCM_SUCCESS(r_rv)) {
   5680 		/* Pack request */
   5681 		/* Skip unit */
   5682 
   5683 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   5684 			/* Unpack reply */
   5685 			/* Skip unit */
   5686 			BCM_UNPACK_U32(r_req.rx_ptr, r_port);
   5687 			BCM_UNPACK_U16(r_req.rx_ptr, r_old_vlan);
   5688 			BCM_UNPACK_U16(r_req.rx_ptr, r_new_vlan);
   5689 			BCM_UNPACK_U32(r_req.rx_ptr, r_prio);
   5690 
   5691 			r_rv = cb(unit, r_port, r_old_vlan, r_new_vlan, r_prio, user_data);
   5692 
   5693 			if (BCM_FAILURE(r_rv)) {
   5694 				break;
   5695 			}
   5696 		}
   5697 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   5698 	}
   5699 
   5700 	return r_rv;
   5701 }
   5702 
   5703 #ifdef	INCLUDE_L3
   5704 
   5705 int
   5706 bcm_client_vlan_vpn_traverse(
   5707 	int	unit,
   5708 	bcm_vlan_vpn_traverse_cb	cb,
   5709 	void *	user_data)
   5710 {
   5711 	bcm_rlink_traverse_data_t	r_req;
   5712 	int	r_rv;
   5713 	uint32	r_key[] = {
   5714 		0x916f158c,0xfaf8a47f,0x119d86f8,0x00e0d93d,0xb225bc67 };
   5715 	bcm_vlan_vpn_config_t	r_info;
   5716 	bcm_vlan_vpn_config_t *	r_p_info;
   5717 
   5718 	sal_memset(&r_req, 0, sizeof(r_req));
   5719 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   5720 	if (BCM_SUCCESS(r_rv)) {
   5721 		/* Pack request */
   5722 		/* Skip unit */
   5723 
   5724 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   5725 			/* Unpack reply */
   5726 			/* Skip unit */
   5727 			if (*r_req.rx_ptr++ == 1) {
   5728 				r_p_info = NULL;
   5729 			} else {
   5730 				r_p_info = &r_info;
   5731 				r_req.rx_ptr = _bcm_unpack_vlan_vpn_config(r_req.rx_ptr, r_p_info);
   5732 			}
   5733 
   5734 			r_rv = cb(unit, r_p_info, user_data);
   5735 
   5736 			if (BCM_FAILURE(r_rv)) {
   5737 				break;
   5738 			}
   5739 		}
   5740 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   5741 	}
   5742 
   5743 	return r_rv;
   5744 }
   5745 
   5746 #endif	/* INCLUDE_L3 */
   5747 
   5748 int
   5749 bcm_client_vswitch_cross_connect_traverse(
   5750 	int	unit,
   5751 	bcm_vswitch_cross_connect_traverse_cb	cb,
   5752 	void *	user_data)
   5753 {
   5754 	bcm_rlink_traverse_data_t	r_req;
   5755 	int	r_rv;
   5756 	uint32	r_key[] = {
   5757 		0x9e2f0a59,0x55f5b476,0x79588357,0x0d51da96,0x143c212f };
   5758 	bcm_vswitch_cross_connect_t	r_gports;
   5759 	bcm_vswitch_cross_connect_t *	r_p_gports;
   5760 
   5761 	sal_memset(&r_req, 0, sizeof(r_req));
   5762 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   5763 	if (BCM_SUCCESS(r_rv)) {
   5764 		/* Pack request */
   5765 		/* Skip unit */
   5766 
   5767 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   5768 			/* Unpack reply */
   5769 			/* Skip unit */
   5770 			if (*r_req.rx_ptr++ == 1) {
   5771 				r_p_gports = NULL;
   5772 			} else {
   5773 				r_p_gports = &r_gports;
   5774 				r_req.rx_ptr = _bcm_unpack_vswitch_cross_connect(r_req.rx_ptr, r_p_gports);
   5775 			}
   5776 
   5777 			r_rv = cb(unit, r_p_gports, user_data);
   5778 
   5779 			if (BCM_FAILURE(r_rv)) {
   5780 				break;
   5781 			}
   5782 		}
   5783 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   5784 	}
   5785 
   5786 	return r_rv;
   5787 }
   5788 
   5789 int
   5790 bcm_client_vswitch_port_traverse(
   5791 	int	unit,
   5792 	bcm_vlan_t	vsi,
   5793 	bcm_vswitch_port_traverse_cb	cb,
   5794 	void *	user_data)
   5795 {
   5796 	bcm_rlink_traverse_data_t	r_req;
   5797 	int	r_rv;
   5798 	uint32	r_key[] = {
   5799 		0x49d835d6,0xa0e649e4,0xe5ccb8a1,0x5528cc10,0x2111ef4a };
   5800 	bcm_vlan_t	r_vsi;
   5801 	bcm_gport_t	r_port;
   5802 
   5803 	sal_memset(&r_req, 0, sizeof(r_req));
   5804 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   5805 	if (BCM_SUCCESS(r_rv)) {
   5806 		/* Pack request */
   5807 		/* Skip unit */
   5808 		BCM_PACK_U16(r_req.tx_ptr, vsi);
   5809 
   5810 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   5811 			/* Unpack reply */
   5812 			/* Skip unit */
   5813 			BCM_UNPACK_U16(r_req.rx_ptr, r_vsi);
   5814 			BCM_UNPACK_U32(r_req.rx_ptr, r_port);
   5815 
   5816 			r_rv = cb(unit, r_vsi, r_port, user_data);
   5817 
   5818 			if (BCM_FAILURE(r_rv)) {
   5819 				break;
   5820 			}
   5821 		}
   5822 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   5823 	}
   5824 
   5825 	return r_rv;
   5826 }
   5827 
   5828 #ifdef	INCLUDE_L3
   5829 
   5830 int
   5831 bcm_client_vxlan_network_domain_config_traverse(
   5832 	int	unit,
   5833 	bcm_vxlan_network_domain_config_additional_info_t *	additional_info,
   5834 	bcm_vxlan_network_domain_config_traverse_cb	cb,
   5835 	void *	user_data)
   5836 {
   5837 	bcm_rlink_traverse_data_t	r_req;
   5838 	int	r_rv;
   5839 	uint32	r_key[] = {
   5840 		0xb7ae1ea6,0x543b9c79,0x76ae9868,0x5e33c02a,0x35e1b661 };
   5841 	bcm_vxlan_network_domain_config_t	r_info;
   5842 	bcm_vxlan_network_domain_config_t *	r_p_info;
   5843 
   5844 	sal_memset(&r_req, 0, sizeof(r_req));
   5845 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   5846 	if (BCM_SUCCESS(r_rv)) {
   5847 		/* Pack request */
   5848 		/* Skip unit */
   5849 		if (additional_info == NULL) {
   5850 			BCM_PACK_U8(r_req.tx_ptr, 1);
   5851 		} else {
   5852 			BCM_PACK_U8(r_req.tx_ptr, 0);
   5853 			BCM_PACK_U32(r_req.tx_ptr, additional_info->flags);
   5854 		}
   5855 
   5856 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   5857 			/* Unpack reply */
   5858 			/* Skip unit */
   5859 			if (*r_req.rx_ptr++ == 1) {
   5860 				r_p_info = NULL;
   5861 			} else {
   5862 				r_p_info = &r_info;
   5863 				r_req.rx_ptr = _bcm_unpack_vxlan_network_domain_config(r_req.rx_ptr, r_p_info);
   5864 			}
   5865 
   5866 			r_rv = cb(unit, r_p_info, user_data);
   5867 
   5868 			if (BCM_FAILURE(r_rv)) {
   5869 				break;
   5870 			}
   5871 		}
   5872 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   5873 	}
   5874 
   5875 	return r_rv;
   5876 }
   5877 
   5878 int
   5879 bcm_client_vxlan_port_traverse(
   5880 	int	unit,
   5881 	bcm_vxlan_port_traverse_cb	cb,
   5882 	void *	user_data)
   5883 {
   5884 	bcm_rlink_traverse_data_t	r_req;
   5885 	int	r_rv;
   5886 	uint32	r_key[] = {
   5887 		0x5cff6bd0,0x7fcf8106,0x1aae4f3a,0x7923c677,0x16fe5011 };
   5888 	bcm_vxlan_port_t	r_info;
   5889 	bcm_vxlan_port_t *	r_p_info;
   5890 
   5891 	sal_memset(&r_req, 0, sizeof(r_req));
   5892 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   5893 	if (BCM_SUCCESS(r_rv)) {
   5894 		/* Pack request */
   5895 		/* Skip unit */
   5896 
   5897 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   5898 			/* Unpack reply */
   5899 			/* Skip unit */
   5900 			if (*r_req.rx_ptr++ == 1) {
   5901 				r_p_info = NULL;
   5902 			} else {
   5903 				r_p_info = &r_info;
   5904 				r_req.rx_ptr = _bcm_unpack_vxlan_port(r_req.rx_ptr, r_p_info);
   5905 			}
   5906 
   5907 			r_rv = cb(unit, r_p_info, user_data);
   5908 
   5909 			if (BCM_FAILURE(r_rv)) {
   5910 				break;
   5911 			}
   5912 		}
   5913 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   5914 	}
   5915 
   5916 	return r_rv;
   5917 }
   5918 
   5919 int
   5920 bcm_client_vxlan_tunnel_initiator_traverse(
   5921 	int	unit,
   5922 	bcm_tunnel_initiator_traverse_cb	cb,
   5923 	void *	user_data)
   5924 {
   5925 	bcm_rlink_traverse_data_t	r_req;
   5926 	int	r_rv;
   5927 	uint32	r_key[] = {
   5928 		0xbc51e59b,0x398a74d7,0x01f51080,0x586f40a7,0xd7b07863 };
   5929 	bcm_tunnel_initiator_t	r_info;
   5930 	bcm_tunnel_initiator_t *	r_p_info;
   5931 
   5932 	sal_memset(&r_req, 0, sizeof(r_req));
   5933 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   5934 	if (BCM_SUCCESS(r_rv)) {
   5935 		/* Pack request */
   5936 		/* Skip unit */
   5937 
   5938 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   5939 			/* Unpack reply */
   5940 			/* Skip unit */
   5941 			if (*r_req.rx_ptr++ == 1) {
   5942 				r_p_info = NULL;
   5943 			} else {
   5944 				r_p_info = &r_info;
   5945 				r_req.rx_ptr = _bcm_unpack_tunnel_initiator(r_req.rx_ptr, r_p_info);
   5946 			}
   5947 
   5948 			r_rv = cb(unit, r_p_info, user_data);
   5949 
   5950 			if (BCM_FAILURE(r_rv)) {
   5951 				break;
   5952 			}
   5953 		}
   5954 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   5955 	}
   5956 
   5957 	return r_rv;
   5958 }
   5959 
   5960 int
   5961 bcm_client_vxlan_tunnel_terminator_traverse(
   5962 	int	unit,
   5963 	bcm_tunnel_terminator_traverse_cb	cb,
   5964 	void *	user_data)
   5965 {
   5966 	bcm_rlink_traverse_data_t	r_req;
   5967 	int	r_rv;
   5968 	uint32	r_key[] = {
   5969 		0x5662fadf,0xfce47da3,0x34b7cd10,0xec6b5a16,0x9f0c27e7 };
   5970 	bcm_tunnel_terminator_t	r_info;
   5971 	bcm_tunnel_terminator_t *	r_p_info;
   5972 
   5973 	sal_memset(&r_req, 0, sizeof(r_req));
   5974 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   5975 	if (BCM_SUCCESS(r_rv)) {
   5976 		/* Pack request */
   5977 		/* Skip unit */
   5978 
   5979 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   5980 			/* Unpack reply */
   5981 			/* Skip unit */
   5982 			if (*r_req.rx_ptr++ == 1) {
   5983 				r_p_info = NULL;
   5984 			} else {
   5985 				r_p_info = &r_info;
   5986 				r_req.rx_ptr = _bcm_unpack_tunnel_terminator(r_req.rx_ptr, r_p_info);
   5987 			}
   5988 
   5989 			r_rv = cb(unit, r_p_info, user_data);
   5990 
   5991 			if (BCM_FAILURE(r_rv)) {
   5992 				break;
   5993 			}
   5994 		}
   5995 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   5996 	}
   5997 
   5998 	return r_rv;
   5999 }
   6000 
   6001 int
   6002 bcm_client_vxlan_vpn_traverse(
   6003 	int	unit,
   6004 	bcm_vxlan_vpn_traverse_cb	cb,
   6005 	void *	user_data)
   6006 {
   6007 	bcm_rlink_traverse_data_t	r_req;
   6008 	int	r_rv;
   6009 	uint32	r_key[] = {
   6010 		0x45431813,0x968e724f,0x056b3aa5,0xb5103248,0x701ce63a };
   6011 	bcm_vxlan_vpn_config_t	r_info;
   6012 	bcm_vxlan_vpn_config_t *	r_p_info;
   6013 
   6014 	sal_memset(&r_req, 0, sizeof(r_req));
   6015 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   6016 	if (BCM_SUCCESS(r_rv)) {
   6017 		/* Pack request */
   6018 		/* Skip unit */
   6019 
   6020 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   6021 			/* Unpack reply */
   6022 			/* Skip unit */
   6023 			if (*r_req.rx_ptr++ == 1) {
   6024 				r_p_info = NULL;
   6025 			} else {
   6026 				r_p_info = &r_info;
   6027 				r_req.rx_ptr = _bcm_unpack_vxlan_vpn_config(r_req.rx_ptr, r_p_info);
   6028 			}
   6029 
   6030 			r_rv = cb(unit, r_p_info, user_data);
   6031 
   6032 			if (BCM_FAILURE(r_rv)) {
   6033 				break;
   6034 			}
   6035 		}
   6036 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   6037 	}
   6038 
   6039 	return r_rv;
   6040 }
   6041 
   6042 int
   6043 bcm_client_wlan_client_traverse(
   6044 	int	unit,
   6045 	bcm_wlan_client_traverse_cb	cb,
   6046 	void *	user_data)
   6047 {
   6048 	bcm_rlink_traverse_data_t	r_req;
   6049 	int	r_rv;
   6050 	uint32	r_key[] = {
   6051 		0xa128eb0b,0xefa0c614,0x0584f855,0xfe95099e,0x95ad77ea };
   6052 	bcm_wlan_client_t	r_info;
   6053 	bcm_wlan_client_t *	r_p_info;
   6054 
   6055 	sal_memset(&r_req, 0, sizeof(r_req));
   6056 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   6057 	if (BCM_SUCCESS(r_rv)) {
   6058 		/* Pack request */
   6059 		/* Skip unit */
   6060 
   6061 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   6062 			/* Unpack reply */
   6063 			/* Skip unit */
   6064 			if (*r_req.rx_ptr++ == 1) {
   6065 				r_p_info = NULL;
   6066 			} else {
   6067 				r_p_info = &r_info;
   6068 				r_req.rx_ptr = _bcm_unpack_wlan_client(r_req.rx_ptr, r_p_info);
   6069 			}
   6070 
   6071 			r_rv = cb(unit, r_p_info, user_data);
   6072 
   6073 			if (BCM_FAILURE(r_rv)) {
   6074 				break;
   6075 			}
   6076 		}
   6077 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   6078 	}
   6079 
   6080 	return r_rv;
   6081 }
   6082 
   6083 int
   6084 bcm_client_wlan_port_traverse(
   6085 	int	unit,
   6086 	bcm_wlan_port_traverse_cb	cb,
   6087 	void *	user_data)
   6088 {
   6089 	bcm_rlink_traverse_data_t	r_req;
   6090 	int	r_rv;
   6091 	uint32	r_key[] = {
   6092 		0xc5c947cb,0xcb5fa2e9,0x62b91776,0x5327848f,0x5208fc54 };
   6093 	bcm_wlan_port_t	r_info;
   6094 	bcm_wlan_port_t *	r_p_info;
   6095 
   6096 	sal_memset(&r_req, 0, sizeof(r_req));
   6097 	r_rv = bcm_rlink_traverse_request_start(unit, &r_req, r_key);
   6098 	if (BCM_SUCCESS(r_rv)) {
   6099 		/* Pack request */
   6100 		/* Skip unit */
   6101 
   6102 		while (bcm_rlink_traverse_reply_get(unit, &r_req)) {
   6103 			/* Unpack reply */
   6104 			/* Skip unit */
   6105 			if (*r_req.rx_ptr++ == 1) {
   6106 				r_p_info = NULL;
   6107 			} else {
   6108 				r_p_info = &r_info;
   6109 				r_req.rx_ptr = _bcm_unpack_wlan_port(r_req.rx_ptr, r_p_info);
   6110 			}
   6111 
   6112 			r_rv = cb(unit, r_p_info, user_data);
   6113 
   6114 			if (BCM_FAILURE(r_rv)) {
   6115 				break;
   6116 			}
   6117 		}
   6118 		r_rv = bcm_rlink_traverse_request_done(unit, r_rv, &r_req);
   6119 	}
   6120 
   6121 	return r_rv;
   6122 }
   6123 
   6124 #endif	/* INCLUDE_L3 */
   6125 
   6126 #endif	/* BCM_RPC_SUPPORT */
	openbcm Git mirror of https://github.com/Broadcom-Network-Switching-Software/OpenBCM
	git clone git://git.finwo.net/mirror/broadcom/openbcm
	Log \| Files \| Refs \| README