ccm_pack.c (17605B)
1 /* 2 * 3 * This license is set out in https://raw.githubusercontent.com/Broadcom-Network-Switching-Software/OpenBCM/master/Legal/LICENSE file. 4 * 5 * Copyright 2007-2019 Broadcom Inc. All rights reserved. 6 * 7 * File: ccm_pack.c 8 * Purpose: CCM pack and unpack routines for: 9 * - CCM Control messages 10 * 11 * CCM control messages 12 * 13 * CCM messages between the Host CPU and uController are sent 14 * using the uc_message module which allows short messages 15 * to be passed (see include/soc/shared/mos_msg_common.h) 16 * 17 * Additional information for a given message (a long message) is passed 18 * using DMA. The CCM control message types defines the format 19 * for these long messages. 20 * 21 * This file is shared between SDK and uKernel. 22 */ 23 24 #include <soc/shared/ccm_msg.h> 25 26 27 /* 28 * Functions: 29 * shr_ccm_msg_ctrl_<type>_pack/unpack 30 * Purpose: 31 * The following set of routines pack/unpack specified 32 * CCM control message into/from a given buffer 33 * Parameters: 34 * _pack() 35 * buffer - (OUT) Buffer where to pack message. 36 * msg - (IN) CCM control message to pack. 37 * _unpack() 38 * buffer - (IN) Buffer with message to unpack. 39 * msg - (OUT) Returns CCM control message. 40 * Returns: 41 * Pointer to next position in buffer. 42 * Notes: 43 * Assumes pointers are valid and contain enough memory space. 44 */ 45 uint8 * 46 shr_ccm_msg_ctrl_init_pack(uint8 *buf, shr_ccm_msg_ctrl_init_t *msg) 47 { 48 49 _SHR_PACK_U32(buf, msg->max_groups); 50 _SHR_PACK_U32(buf, msg->max_meps); 51 _SHR_PACK_U32(buf, msg->rx_channel); 52 53 return buf; 54 } 55 56 uint8 * 57 shr_ccm_msg_ctrl_init_unpack(uint8 *buf, shr_ccm_msg_ctrl_init_t *msg) 58 { 59 60 _SHR_UNPACK_U32(buf, msg->max_groups); 61 _SHR_UNPACK_U32(buf, msg->max_meps); 62 _SHR_UNPACK_U32(buf, msg->rx_channel); 63 64 return buf; 65 } 66 67 /* MEP data from SDK to UKENREL - Pack routine */ 68 uint8 * 69 shr_ccm_msg_ctrl_mep_set_pack(uint8 *buf, shr_ccm_msg_ctrl_mep_data_t *msg) 70 { 71 uint16 i; 72 73 _SHR_PACK_U32(buf, msg->flags); 74 _SHR_PACK_U32(buf, msg->mep_data.flags); 75 76 /* If update, send only modified data */ 77 if (msg->flags & _MEP_REPLACE) { 78 79 _SHR_PACK_U32(buf, msg->mep_data.ep_id); 80 if (msg->flags & _REPLACE_INTF_STATUS) { 81 _SHR_PACK_U8(buf, msg->mep_data.intf_state); 82 } 83 84 if (msg->flags & _REPLACE_PORT_STATUS) { 85 _SHR_PACK_U8(buf, msg->mep_data.port_state); 86 } 87 88 if (msg->flags & _REPLACE_TRUNK_INDEX) { 89 _SHR_PACK_U32(buf, msg->mep_data.trunk_index); 90 _SHR_PACK_U32(buf, msg->mep_data.dglp); 91 } 92 93 if (msg->flags & _REPLACE_CTRS) { 94 _SHR_PACK_U8(buf, msg->mep_data.num_ctrs); 95 for (i=0; i< msg->mep_data.num_ctrs; i++) { 96 _SHR_PACK_U8(buf, msg->mep_data.counter_offset[i]); 97 _SHR_PACK_U32(buf, msg->mep_data.flex_stat_id[i]); 98 99 } 100 } 101 102 if (msg->flags & _MEP_OLP_RECREATE) { 103 for (i = 0; i < _FP_OAM_OLP_TX_LEN; i++) { 104 _SHR_PACK_U8(buf, msg->OLP_Tx_Hdr[i]); 105 } 106 } 107 108 return buf; 109 } 110 111 /* Else send everything */ 112 _SHR_PACK_U32(buf, msg->mep_data.ep_id); 113 _SHR_PACK_U32(buf, msg->mep_data.group_id); 114 115 for (i=0; i<6; i++) { 116 _SHR_PACK_U8(buf, msg->mep_data.da[i]); 117 } 118 for (i=0; i<6; i++) { 119 _SHR_PACK_U8(buf, msg->mep_data.sa[i]); 120 } 121 122 _SHR_PACK_U8(buf, msg->mep_data.type); 123 _SHR_PACK_U8(buf, msg->mep_data.level); 124 _SHR_PACK_U16(buf, msg->mep_data.name); 125 _SHR_PACK_U32(buf, msg->mep_data.period); 126 127 _SHR_PACK_U16(buf, msg->mep_data.vlan); 128 _SHR_PACK_U16(buf, msg->mep_data.inner_vlan); 129 _SHR_PACK_U8(buf, msg->mep_data.pkt_pri); 130 _SHR_PACK_U8(buf, msg->mep_data.inner_vlan_pri); 131 _SHR_PACK_U16(buf, msg->mep_data.tpid); 132 _SHR_PACK_U16(buf, msg->mep_data.inner_tpid); 133 134 _SHR_PACK_U32(buf, msg->mep_data.gport); 135 _SHR_PACK_U32(buf, msg->mep_data.sglp); 136 _SHR_PACK_U32(buf, msg->mep_data.dglp); 137 _SHR_PACK_U32(buf, msg->mep_data.trunk_index); 138 139 _SHR_PACK_U8(buf, msg->mep_data.port_state); 140 _SHR_PACK_U8(buf, msg->mep_data.intf_state); 141 142 /* We need not pack/unpack faults data from SDK to UKERNEL */ 143 144 _SHR_PACK_U8(buf, msg->mep_data.num_ctrs); 145 for (i=0; i< msg->mep_data.num_ctrs; i++) { 146 _SHR_PACK_U8(buf, msg->mep_data.counter_offset[i]); 147 _SHR_PACK_U32(buf, msg->mep_data.flex_stat_id[i]); 148 149 } 150 151 if (msg->flags & _MEP_L2_ENCAP_RECREATE) { 152 _SHR_PACK_U8(buf, msg->l2_encap_len); 153 for (i = 0; i < msg->l2_encap_len; i++) { 154 _SHR_PACK_U8(buf, msg->L2_encap[i]); 155 } 156 } 157 158 if (msg->flags & _MEP_OLP_RECREATE) { 159 for (i = 0; i < _FP_OAM_OLP_TX_LEN; i++) { 160 _SHR_PACK_U8(buf, msg->OLP_Tx_Hdr[i]); 161 } 162 } 163 164 return buf; 165 } 166 167 /* MEP data from SDK to UKENREL - UnPack routine */ 168 uint8 * 169 shr_ccm_msg_ctrl_mep_set_unpack(uint8 *buf, shr_ccm_msg_ctrl_mep_data_t *msg) 170 { 171 uint16 i; 172 173 _SHR_UNPACK_U32(buf, msg->flags); 174 _SHR_UNPACK_U32(buf, msg->mep_data.flags); 175 176 /* If update, unpack only modified data */ 177 if (msg->flags & _MEP_REPLACE) { 178 179 _SHR_UNPACK_U32(buf, msg->mep_data.ep_id); 180 if (msg->flags & _REPLACE_INTF_STATUS) { 181 _SHR_UNPACK_U8(buf, msg->mep_data.intf_state); 182 } 183 184 if (msg->flags & _REPLACE_PORT_STATUS) { 185 _SHR_UNPACK_U8(buf, msg->mep_data.port_state); 186 } 187 188 if (msg->flags & _REPLACE_TRUNK_INDEX) { 189 _SHR_UNPACK_U32(buf, msg->mep_data.trunk_index); 190 _SHR_UNPACK_U32(buf, msg->mep_data.dglp); 191 } 192 193 if (msg->flags & _REPLACE_CTRS) { 194 _SHR_UNPACK_U8(buf, msg->mep_data.num_ctrs); 195 for (i=0; i< msg->mep_data.num_ctrs; i++) { 196 _SHR_UNPACK_U8(buf, msg->mep_data.counter_offset[i]); 197 _SHR_UNPACK_U32(buf, msg->mep_data.flex_stat_id[i]); 198 199 } 200 } 201 202 if (msg->flags & _MEP_OLP_RECREATE) { 203 for (i = 0; i < _FP_OAM_OLP_TX_LEN; i++) { 204 _SHR_UNPACK_U8(buf, msg->OLP_Tx_Hdr[i]); 205 } 206 } 207 208 return buf; 209 } 210 211 /* Else unpack everything */ 212 _SHR_UNPACK_U32(buf, msg->mep_data.ep_id); 213 _SHR_UNPACK_U32(buf, msg->mep_data.group_id); 214 215 for (i=0; i<6; i++) { 216 _SHR_UNPACK_U8(buf, msg->mep_data.da[i]); 217 } 218 for (i=0; i<6; i++) { 219 _SHR_UNPACK_U8(buf, msg->mep_data.sa[i]); 220 } 221 222 _SHR_UNPACK_U8(buf, msg->mep_data.type); 223 _SHR_UNPACK_U8(buf, msg->mep_data.level); 224 _SHR_UNPACK_U16(buf, msg->mep_data.name); 225 _SHR_UNPACK_U32(buf, msg->mep_data.period); 226 227 _SHR_UNPACK_U16(buf, msg->mep_data.vlan); 228 _SHR_UNPACK_U16(buf, msg->mep_data.inner_vlan); 229 _SHR_UNPACK_U8(buf, msg->mep_data.pkt_pri); 230 _SHR_UNPACK_U8(buf, msg->mep_data.inner_vlan_pri); 231 _SHR_UNPACK_U16(buf, msg->mep_data.tpid); 232 _SHR_UNPACK_U16(buf, msg->mep_data.inner_tpid); 233 234 _SHR_UNPACK_U32(buf, msg->mep_data.gport); 235 _SHR_UNPACK_U32(buf, msg->mep_data.sglp); 236 _SHR_UNPACK_U32(buf, msg->mep_data.dglp); 237 _SHR_UNPACK_U32(buf, msg->mep_data.trunk_index); 238 239 _SHR_UNPACK_U8(buf, msg->mep_data.port_state); 240 _SHR_UNPACK_U8(buf, msg->mep_data.intf_state); 241 242 /* We need not pack/unpack faults data from SDK to UKERNEL */ 243 244 _SHR_UNPACK_U8(buf, msg->mep_data.num_ctrs); 245 for (i=0; i< msg->mep_data.num_ctrs; i++) { 246 _SHR_UNPACK_U8(buf, msg->mep_data.counter_offset[i]); 247 _SHR_UNPACK_U32(buf, msg->mep_data.flex_stat_id[i]); 248 249 } 250 251 if (msg->flags & _MEP_L2_ENCAP_RECREATE) { 252 _SHR_UNPACK_U8(buf, msg->l2_encap_len); 253 for (i = 0; i < msg->l2_encap_len; i++) { 254 _SHR_UNPACK_U8(buf, msg->L2_encap[i]); 255 } 256 } 257 258 if (msg->flags & _MEP_OLP_RECREATE) { 259 for (i = 0; i < _FP_OAM_OLP_TX_LEN; i++) { 260 _SHR_UNPACK_U8(buf, msg->OLP_Tx_Hdr[i]); 261 } 262 } 263 264 return buf; 265 } 266 267 /* Recover Mep data from UKENREL to SDK - Pack routine */ 268 uint8 * 269 shr_ccm_msg_ctrl_mep_get_pack(uint8 *buf, shr_ccm_msg_ctrl_mep_data_t *msg) 270 { 271 uint16 i; 272 273 _SHR_PACK_U32(buf, msg->flags); 274 _SHR_PACK_U32(buf, msg->mep_data.flags); 275 276 if (msg->flags & _MEP_GET_FAULTS_ONLY) { 277 _SHR_PACK_U32(buf, msg->mep_data.faults); 278 _SHR_PACK_U32(buf, msg->mep_data.persistent_faults); 279 _SHR_PACK_U8(buf, msg->mep_data.port_state); 280 _SHR_PACK_U8(buf, msg->mep_data.intf_state); 281 for (i=0; i<6; i++) { 282 _SHR_PACK_U8(buf, msg->mep_data.da[i]); 283 } 284 for (i=0; i<6; i++) { 285 _SHR_PACK_U8(buf, msg->mep_data.sa[i]); 286 } 287 return buf; 288 } 289 290 _SHR_PACK_U32(buf, msg->mep_data.ep_id); 291 _SHR_PACK_U32(buf, msg->mep_data.group_id); 292 293 for (i=0; i<6; i++) { 294 _SHR_PACK_U8(buf, msg->mep_data.da[i]); 295 } 296 for (i=0; i<6; i++) { 297 _SHR_PACK_U8(buf, msg->mep_data.sa[i]); 298 } 299 300 _SHR_PACK_U8(buf, msg->mep_data.type); 301 _SHR_PACK_U8(buf, msg->mep_data.level); 302 _SHR_PACK_U16(buf, msg->mep_data.name); 303 _SHR_PACK_U32(buf, msg->mep_data.period); 304 305 _SHR_PACK_U16(buf, msg->mep_data.vlan); 306 _SHR_PACK_U16(buf, msg->mep_data.inner_vlan); 307 _SHR_PACK_U8(buf, msg->mep_data.pkt_pri); 308 _SHR_PACK_U8(buf, msg->mep_data.inner_vlan_pri); 309 _SHR_PACK_U16(buf, msg->mep_data.tpid); 310 _SHR_PACK_U16(buf, msg->mep_data.inner_tpid); 311 312 _SHR_PACK_U32(buf, msg->mep_data.gport); 313 _SHR_PACK_U32(buf, msg->mep_data.sglp); 314 _SHR_PACK_U32(buf, msg->mep_data.dglp); 315 _SHR_PACK_U32(buf, msg->mep_data.trunk_index); 316 317 _SHR_PACK_U8(buf, msg->mep_data.port_state); 318 _SHR_PACK_U8(buf, msg->mep_data.intf_state); 319 320 _SHR_PACK_U32(buf, msg->mep_data.faults); 321 _SHR_PACK_U32(buf, msg->mep_data.persistent_faults); 322 323 _SHR_PACK_U8(buf, msg->mep_data.num_ctrs); 324 for (i=0; i< msg->mep_data.num_ctrs; i++) { 325 _SHR_PACK_U8(buf, msg->mep_data.counter_offset[i]); 326 _SHR_PACK_U32(buf, msg->mep_data.flex_stat_id[i]); 327 328 } 329 330 /* We need not pack/unpack L2 Header data from UKERNEL to SDK */ 331 332 return buf; 333 } 334 335 /* Recover Mep data from UKENREL to SDK - UnPack routine */ 336 uint8 * 337 shr_ccm_msg_ctrl_mep_get_unpack(uint8 *buf, shr_ccm_msg_ctrl_mep_data_t *msg) 338 { 339 uint16 i; 340 341 _SHR_UNPACK_U32(buf, msg->flags); 342 _SHR_UNPACK_U32(buf, msg->mep_data.flags); 343 344 if (msg->flags & _MEP_GET_FAULTS_ONLY) { 345 _SHR_UNPACK_U32(buf, msg->mep_data.faults); 346 _SHR_UNPACK_U32(buf, msg->mep_data.persistent_faults); 347 _SHR_UNPACK_U8(buf, msg->mep_data.port_state); 348 _SHR_UNPACK_U8(buf, msg->mep_data.intf_state); 349 for (i=0; i<6; i++) { 350 _SHR_UNPACK_U8(buf, msg->mep_data.da[i]); 351 } 352 for (i=0; i<6; i++) { 353 _SHR_UNPACK_U8(buf, msg->mep_data.sa[i]); 354 } 355 return buf; 356 } 357 358 _SHR_UNPACK_U32(buf, msg->mep_data.ep_id); 359 _SHR_UNPACK_U32(buf, msg->mep_data.group_id); 360 361 for (i=0; i<6; i++) { 362 _SHR_UNPACK_U8(buf, msg->mep_data.da[i]); 363 } 364 for (i=0; i<6; i++) { 365 _SHR_UNPACK_U8(buf, msg->mep_data.sa[i]); 366 } 367 368 _SHR_UNPACK_U8(buf, msg->mep_data.type); 369 _SHR_UNPACK_U8(buf, msg->mep_data.level); 370 _SHR_UNPACK_U16(buf, msg->mep_data.name); 371 _SHR_UNPACK_U32(buf, msg->mep_data.period); 372 373 _SHR_UNPACK_U16(buf, msg->mep_data.vlan); 374 _SHR_UNPACK_U16(buf, msg->mep_data.inner_vlan); 375 _SHR_UNPACK_U8(buf, msg->mep_data.pkt_pri); 376 _SHR_UNPACK_U8(buf, msg->mep_data.inner_vlan_pri); 377 _SHR_UNPACK_U16(buf, msg->mep_data.tpid); 378 _SHR_UNPACK_U16(buf, msg->mep_data.inner_tpid); 379 380 _SHR_UNPACK_U32(buf, msg->mep_data.gport); 381 _SHR_UNPACK_U32(buf, msg->mep_data.sglp); 382 _SHR_UNPACK_U32(buf, msg->mep_data.dglp); 383 _SHR_UNPACK_U32(buf, msg->mep_data.trunk_index); 384 385 _SHR_UNPACK_U8(buf, msg->mep_data.port_state); 386 _SHR_UNPACK_U8(buf, msg->mep_data.intf_state); 387 388 _SHR_UNPACK_U32(buf, msg->mep_data.faults); 389 _SHR_UNPACK_U32(buf, msg->mep_data.persistent_faults); 390 391 _SHR_UNPACK_U8(buf, msg->mep_data.num_ctrs); 392 for (i=0; i< msg->mep_data.num_ctrs; i++) { 393 _SHR_UNPACK_U8(buf, msg->mep_data.counter_offset[i]); 394 _SHR_UNPACK_U32(buf, msg->mep_data.flex_stat_id[i]); 395 396 } 397 398 /* We need not pack/unpack L2 Header data from UKERNEL to SDK */ 399 400 return buf; 401 } 402 403 /* Group data from SDK to UKENREL - Pack routine */ 404 uint8 * 405 shr_ccm_msg_ctrl_group_set_pack(uint8 *buf, shr_ccm_msg_ctrl_group_data_t *msg) 406 { 407 uint16 i; 408 409 _SHR_PACK_U32(buf, msg->flags); 410 _SHR_PACK_U32(buf, msg->group_data.flags); 411 412 /* If update, send only modified data */ 413 if (msg->flags & _GRP_REPLACE) { 414 415 _SHR_PACK_U32(buf, msg->group_data.group_id); 416 /* Sw RDI is taken care in the flags */ 417 if (msg->flags & _GRP_REPLACE_LOWEST_ALARM_PRIO) { 418 _SHR_PACK_U32(buf, msg->group_data.lowest_alarm_priority); 419 } 420 421 return buf; 422 } 423 424 /* Else send everything */ 425 _SHR_PACK_U32(buf, msg->group_data.group_id); 426 _SHR_PACK_U32(buf, msg->group_data.lowest_alarm_priority); 427 /* We need not pack/unpack faults data from SDK to UKERNEL */ 428 for (i=0; i<_FP_OAM_MAID_LEN; i++) { 429 _SHR_PACK_U8(buf, msg->group_data.name[i]); 430 } 431 /* We need not pack/unpack lmepid, rmep_bitmap from SDK to UKERNEL */ 432 return buf; 433 } 434 435 /* Group data from SDK to UKENREL - UnPack routine */ 436 uint8 * 437 shr_ccm_msg_ctrl_group_set_unpack(uint8 *buf, shr_ccm_msg_ctrl_group_data_t *msg) 438 { 439 uint16 i; 440 441 _SHR_UNPACK_U32(buf, msg->flags); 442 _SHR_UNPACK_U32(buf, msg->group_data.flags); 443 444 /* If update, send only modified data */ 445 if (msg->flags & _GRP_REPLACE) { 446 447 _SHR_UNPACK_U32(buf, msg->group_data.group_id); 448 /* Sw RDI is taken care in the flags */ 449 if (msg->flags & _GRP_REPLACE_LOWEST_ALARM_PRIO) { 450 _SHR_UNPACK_U32(buf, msg->group_data.lowest_alarm_priority); 451 } 452 453 return buf; 454 } 455 456 /* Else send everything */ 457 _SHR_UNPACK_U32(buf, msg->group_data.group_id); 458 _SHR_UNPACK_U32(buf, msg->group_data.lowest_alarm_priority); 459 /* We need not pack/unpack faults data from SDK to UKERNEL */ 460 for (i=0; i<_FP_OAM_MAID_LEN; i++) { 461 _SHR_UNPACK_U8(buf, msg->group_data.name[i]); 462 } 463 /* We need not pack/unpack lmepid, rmep_bitmap from SDK to UKERNEL */ 464 return buf; 465 } 466 467 /* Get Group data from UKERNEL to SDK - Pack routine */ 468 uint8 * 469 shr_ccm_msg_ctrl_group_get_pack(uint8 *buf, shr_ccm_msg_ctrl_group_data_t *msg) 470 { 471 uint16 i; 472 473 _SHR_PACK_U32(buf, msg->flags); 474 _SHR_PACK_U32(buf, msg->group_data.flags); 475 476 if (msg->flags & _GRP_GET_FAULTS_ONLY) { 477 _SHR_PACK_U32(buf, msg->group_data.faults); 478 _SHR_PACK_U32(buf, msg->group_data.persistent_faults); 479 return buf; 480 } 481 482 _SHR_PACK_U32(buf, msg->group_data.group_id); 483 _SHR_PACK_U32(buf, msg->group_data.lmep_id); 484 _SHR_PACK_U32(buf, msg->group_data.lowest_alarm_priority); 485 _SHR_PACK_U32(buf, msg->group_data.faults); 486 _SHR_PACK_U32(buf, msg->group_data.persistent_faults); 487 for (i=0; i<_FP_OAM_MAID_LEN; i++) { 488 _SHR_PACK_U8(buf, msg->group_data.name[i]); 489 } 490 for (i=0; i<_CCM_MEP_BIT_FIELD_LEN; i++) { 491 _SHR_PACK_U32(buf, msg->group_data.rmep_bitmap[i]); 492 } 493 494 return buf; 495 } 496 497 /* Get Group data from UKERNEL to SDK - UnPack routine */ 498 uint8 * 499 shr_ccm_msg_ctrl_group_get_unpack(uint8 *buf, shr_ccm_msg_ctrl_group_data_t *msg) 500 { 501 uint16 i; 502 503 _SHR_UNPACK_U32(buf, msg->flags); 504 _SHR_UNPACK_U32(buf, msg->group_data.flags); 505 506 if (msg->flags & _GRP_GET_FAULTS_ONLY) { 507 _SHR_UNPACK_U32(buf, msg->group_data.faults); 508 _SHR_UNPACK_U32(buf, msg->group_data.persistent_faults); 509 return buf; 510 } 511 512 _SHR_UNPACK_U32(buf, msg->group_data.group_id); 513 _SHR_UNPACK_U32(buf, msg->group_data.lmep_id); 514 _SHR_UNPACK_U32(buf, msg->group_data.lowest_alarm_priority); 515 _SHR_UNPACK_U32(buf, msg->group_data.faults); 516 _SHR_UNPACK_U32(buf, msg->group_data.persistent_faults); 517 for (i=0; i<_FP_OAM_MAID_LEN; i++) { 518 _SHR_UNPACK_U8(buf, msg->group_data.name[i]); 519 } 520 for (i=0; i<_CCM_MEP_BIT_FIELD_LEN; i++) { 521 _SHR_UNPACK_U32(buf, msg->group_data.rmep_bitmap[i]); 522 } 523 524 return buf; 525 } 526 527 /* Get App data from UKERNEL to SDK - Pack routine */ 528 uint8 * 529 shr_ccm_msg_ctrl_app_data_pack(uint8 *buf, shr_ccm_msg_ctrl_app_data_t *msg) 530 { 531 uint16 i; 532 533 _SHR_PACK_U32(buf, msg->flags); 534 535 for (i=0; i<_CCM_GRP_BIT_FILED_LEN; i++) { 536 _SHR_PACK_U32(buf, msg->group_bitmap[i]); 537 } 538 539 return buf; 540 } 541 542 /* Get App data from UKERNEL to SDK - UnPack routine */ 543 uint8 * 544 shr_ccm_msg_ctrl_app_data_unpack(uint8 *buf, shr_ccm_msg_ctrl_app_data_t *msg) 545 { 546 uint16 i; 547 548 _SHR_UNPACK_U32(buf, msg->flags); 549 550 for (i=0; i<_CCM_GRP_BIT_FILED_LEN; i++) { 551 _SHR_UNPACK_U32(buf, msg->group_bitmap[i]); 552 } 553 554 return buf; 555 } 556 557 558 /* Pack port trunk map update msg into buf */ 559 uint8 * 560 shr_ccm_msg_ctrl_port_trunk_upd_pack(uint8 *buf, shr_ccm_msg_ctrl_port_trunk_upd_t *msg) 561 { 562 uint16 i; 563 _SHR_PACK_U16(buf, msg->num_ports); 564 _SHR_PACK_U16(buf, msg->trunk_id); 565 for (i = 0; i < msg->num_ports; i++) { 566 _SHR_PACK_U16(buf, msg->list_of_ports[i]); 567 } 568 569 return buf; 570 } 571 572 /* Unpack port trunk map update info from buf to msg structure*/ 573 uint8 * 574 shr_ccm_msg_ctrl_port_trunk_upd_unpack(uint8 *buf, shr_ccm_msg_ctrl_port_trunk_upd_t *msg) 575 { 576 uint16 i; 577 _SHR_UNPACK_U16(buf, msg->num_ports); 578 _SHR_UNPACK_U16(buf, msg->trunk_id); 579 for (i = 0; i < msg->num_ports; i++) { 580 _SHR_UNPACK_U16(buf, msg->list_of_ports[i]); 581 } 582 583 return buf; 584 }