field_ha_int.h (74935B)
1 /*! \file field_ha.h 2 * 3 * Field header file. 4 * This file contains the HA management for Field module. 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 12 #ifndef BCMI_LTSW_FIELD_HA_H 13 #define BCMI_LTSW_FIELD_HA_H 14 15 #include <shr/shr_bitop.h> 16 #include <bcm_int/ltsw/ha.h> 17 #include <bcm_int/ltsw/generated/field_ha.h> 18 19 /****************************************************************************** 20 * Defines 21 */ 22 /*! Array size of HA Block IDs */ 23 #define BCM_FIELD_HA_BLK_ID_ARRAY_SIZE 256 24 25 /*! Minimum valid block id for FP HA blocks. */ 26 #define BCM_FIELD_HA_BLK_ID_MIN 0x1 27 28 /*! Maximum valid block id for FP HA blocks. */ 29 #define BCM_FIELD_HA_BLK_ID_MAX 0xFE 30 31 /*! Invalid HA block ID. Used in HA block id validations. */ 32 #define BCM_FIELD_HA_BLK_ID_INVALID 0x0 33 34 /*! Signature for Field HA blocks. */ 35 #define BCM_FIELD_HA_STRUCT_SIGN 0xBABA0000 36 37 /*! Since block offset is uint32_t type the max offset is ((2^32) -1). 38 * This macros is used to identify invalid HA block offset. 39 */ 40 #define BCM_FIELD_HA_BLK_OFFSET_INVALID 0xFFFFFFFF 41 42 /*! Macro to get the HA block id reserved for a given stage_id. */ 43 #define BCM_FIELD_HA_STAGE_ID_TO_BLK_ID(stage_id, blk_id) \ 44 do { \ 45 if (stage_id == bcmiFieldStageIngress) { \ 46 blk_id = BCM_FIELD_HA_BLK_ID_INGRESS; \ 47 } else if (stage_id == bcmiFieldStageEgress) { \ 48 blk_id = BCM_FIELD_HA_BLK_ID_EGRESS; \ 49 } else if (stage_id == bcmiFieldStageVlan) { \ 50 blk_id = BCM_FIELD_HA_BLK_ID_VLAN; \ 51 } else if (stage_id == bcmiFieldStageExactMatch) { \ 52 blk_id = BCM_FIELD_HA_BLK_ID_EM; \ 53 } else if (stage_id == bcmiFieldStageFlowTracker) { \ 54 blk_id = BCM_FIELD_HA_BLK_ID_FT; \ 55 } else { \ 56 SHR_ERR_EXIT(SHR_E_INTERNAL); \ 57 } \ 58 } while(0) 59 60 /*! Macro to validate the HA block Id. This will check whether 61 * HA block id is with in the min, max limits of valid block Ids. 62 */ 63 #define BCM_FIELD_HA_BLK_ID_VALIDATE(unit, blk_id) \ 64 do { \ 65 SHR_IF_ERR_EXIT( \ 66 (blk_id == BCM_FIELD_HA_BLK_ID_INVALID) ? \ 67 SHR_E_INTERNAL : SHR_E_NONE); \ 68 SHR_IF_ERR_EXIT( \ 69 (blk_id > BCM_FIELD_HA_BLK_ID_MAX) ? \ 70 SHR_E_INTERNAL : SHR_E_NONE); \ 71 SHR_IF_ERR_EXIT( \ 72 (blk_id < BCM_FIELD_HA_BLK_ID_MIN) ? \ 73 SHR_E_INTERNAL : SHR_E_NONE); \ 74 } while(0) 75 76 /*! Macros to validate the HA block offset. */ 77 #define BCM_FIELD_HA_BLK_OFFSET_VALIDATE(unit, blk_id, blk_offset) \ 78 do { \ 79 void *_ha_ptr = NULL; \ 80 uint32_t _size = 0; \ 81 bcmi_field_ha_blk_hdr_t *_blk_hdr = NULL; \ 82 SHR_IF_ERR_EXIT( \ 83 (blk_offset == BCM_FIELD_HA_BLK_OFFSET_INVALID) ? \ 84 SHR_E_INTERNAL: SHR_E_NONE); \ 85 if (((blk_offset - sizeof(bcmi_field_ha_blk_hdr_t)) % \ 86 sizeof(bcmi_field_ha_element_t)) != 0) { \ 87 SHR_ERR_EXIT(SHR_E_INTERNAL); \ 88 } \ 89 _ha_ptr = BCM_FIELD_HA_PTR(unit, blk_id); \ 90 if (_ha_ptr == NULL) { \ 91 SHR_ERR_EXIT(SHR_E_NOT_FOUND); \ 92 } \ 93 _blk_hdr = (bcmi_field_ha_blk_hdr_t *)_ha_ptr; \ 94 SHR_IF_ERR_EXIT( \ 95 (blk_offset > _blk_hdr->blk_size) ? \ 96 SHR_E_INTERNAL : SHR_E_NONE); \ 97 _size = blk_offset + sizeof(bcmi_field_ha_element_t); \ 98 SHR_IF_ERR_EXIT( \ 99 (_size > _blk_hdr->blk_size) ? \ 100 SHR_E_INTERNAL : SHR_E_NONE); \ 101 } while(0) 102 103 104 /*! Reserved FP HA Root block Ids. */ 105 #define BCMI_FIELD_HA_BLK_ID_ROOT 1 106 107 typedef struct ltsw_fp_ha_local_info_s { 108 uint8_t last_allocated_blk_id; 109 uint8_t blk_id[BCMI_FIELD_HA_BLK_TYPE_LAST_COUNT]; 110 void *blk_hdrs[BCM_FIELD_HA_BLK_ID_MAX]; 111 } ltsw_fp_ha_local_info_t; 112 113 extern ltsw_fp_ha_local_info_t *ltsw_fp_ha_info[BCM_MAX_NUM_UNITS]; 114 115 #define FP_HA_INFO(_u_) \ 116 ltsw_fp_ha_info[_u_] 117 118 #define FP_HA_BLK_HDR_PTR(_u_, _blk_id_) \ 119 FP_HA_INFO(_u_)->blk_hdrs[_blk_id_] 120 121 #define FP_HA_INFO_UPDATE_ALLOCATED_BLK_ID(_u_, _id) \ 122 { \ 123 FP_HA_INFO(_u_)->last_allocated_blk_id = _id; \ 124 } 125 126 #define FP_HA_NEW_BLK_ID(_u, _id) \ 127 { \ 128 _id = FP_HA_INFO(_u)->last_allocated_blk_id + 1; \ 129 if ((_id > BCM_FIELD_HA_BLK_ID_MAX) || \ 130 (FP_HA_BLK_HDR_PTR(_u, _id) != NULL)) { \ 131 for (_id = 2; _id < BCM_FIELD_HA_BLK_ID_MAX; _id++) { \ 132 if (FP_HA_BLK_HDR_PTR(_u, _id) != NULL) { \ 133 continue; \ 134 } \ 135 break; \ 136 } \ 137 if (_id == BCM_FIELD_HA_BLK_ID_MAX) { \ 138 SHR_IF_ERR_VERBOSE_EXIT(SHR_E_INTERNAL); \ 139 } \ 140 } \ 141 FP_HA_INFO(_u)->last_allocated_blk_id = _id; \ 142 } 143 144 #define FP_BLK_ID_INFO_SET(_u_, _blk_hdr, _blk_id) \ 145 { \ 146 FP_HA_INFO(_u_)->blk_id[_blk_hdr->blk_type] = _blk_id; \ 147 } 148 149 #define FP_HA_ROOT_BLK_ID_BMP_SET(_u_, _blk_id) \ 150 { \ 151 void *_ptr; \ 152 bcmi_field_ha_root_blk_t *_root; \ 153 _ptr = FP_HA_BLK_HDR_PTR(unit, BCMI_FIELD_HA_BLK_ID_ROOT); \ 154 _root = (bcmi_field_ha_root_blk_t *) \ 155 ((uint8_t *)_ptr + sizeof(bcmi_field_ha_blk_hdr_t));\ 156 SHR_BITSET(_root->in_use_ha_blk_id_bmp.w, _blk_id); \ 157 } 158 159 #define FP_HA_ROOT_BLK_ID_BMP_CLR(_u_, _blk_id) \ 160 { \ 161 void *_ptr; \ 162 bcmi_field_ha_root_blk_t *_root; \ 163 _ptr = FP_HA_BLK_HDR_PTR(unit, BCMI_FIELD_HA_BLK_ID_ROOT); \ 164 _root = (bcmi_field_ha_root_blk_t *) \ 165 ((uint8_t *)_ptr + sizeof(bcmi_field_ha_blk_hdr_t));\ 166 SHR_BITCLR(_root->in_use_ha_blk_id_bmp.w, _blk_id); \ 167 } 168 169 #define FP_ROOT_BLK_ID(_u_) \ 170 FP_HA_INFO(_u_)->blk_id[BCMI_FIELD_HA_BLK_TYPE_ROOT]; 171 172 #define FP_IFP_GRP_INFO_BLK_ID(_u_) \ 173 FP_HA_INFO(_u_)->blk_id[BCMI_FIELD_HA_BLK_TYPE_IFP_GROUP_INFO]; 174 175 #define FP_IFP_GRP_HASH_BLK_ID(_u_) \ 176 FP_HA_INFO(_u_)->blk_id[BCMI_FIELD_HA_BLK_TYPE_IFP_GROUP_HASH]; 177 178 #define FP_IFP_PRESEL_INFO_BLK_ID(_u_) \ 179 FP_HA_INFO(_u_)->blk_id[BCMI_FIELD_HA_BLK_TYPE_IFP_PRESEL_INFO]; 180 181 #define FP_IFP_PRESEL_HASH_BLK_ID(_u_) \ 182 FP_HA_INFO(_u_)->blk_id[BCMI_FIELD_HA_BLK_TYPE_IFP_PRESEL_HASH]; 183 184 #define FP_IFP_ENT_INFO_BLK_ID(_u_) \ 185 FP_HA_INFO(_u_)->blk_id[BCMI_FIELD_HA_BLK_TYPE_IFP_ENTRY_INFO]; 186 187 #define FP_IFP_ENT_HASH_BLK_ID(_u_) \ 188 FP_HA_INFO(_u_)->blk_id[BCMI_FIELD_HA_BLK_TYPE_IFP_ENTRY_HASH]; 189 190 #define FP_IFP_SBR_INFO_BLK_ID(_u_) \ 191 FP_HA_INFO(_u_)->blk_id[BCMI_FIELD_HA_BLK_TYPE_IFP_SBR_OPER]; 192 193 #define FP_EFP_PRESEL_INFO_BLK_ID(_u_) \ 194 FP_HA_INFO(_u_)->blk_id[BCMI_FIELD_HA_BLK_TYPE_EFP_PRESEL_INFO]; 195 196 #define FP_EFP_PRESEL_HASH_BLK_ID(_u_) \ 197 FP_HA_INFO(_u_)->blk_id[BCMI_FIELD_HA_BLK_TYPE_EFP_PRESEL_HASH]; 198 199 #define FP_EFP_GRP_INFO_BLK_ID(_u_) \ 200 FP_HA_INFO(_u_)->blk_id[BCMI_FIELD_HA_BLK_TYPE_EFP_GROUP_INFO]; 201 202 #define FP_EFP_GRP_HASH_BLK_ID(_u_) \ 203 FP_HA_INFO(_u_)->blk_id[BCMI_FIELD_HA_BLK_TYPE_EFP_GROUP_HASH]; 204 205 #define FP_EFP_ENT_INFO_BLK_ID(_u_) \ 206 FP_HA_INFO(_u_)->blk_id[BCMI_FIELD_HA_BLK_TYPE_EFP_ENTRY_INFO]; 207 208 #define FP_EFP_ENT_HASH_BLK_ID(_u_) \ 209 FP_HA_INFO(_u_)->blk_id[BCMI_FIELD_HA_BLK_TYPE_EFP_ENTRY_HASH]; 210 211 #define FP_EFP_SBR_INFO_BLK_ID(_u_) \ 212 FP_HA_INFO(_u_)->blk_id[BCMI_FIELD_HA_BLK_TYPE_EFP_SBR_OPER]; 213 214 #define FP_VFP_PRESEL_INFO_BLK_ID(_u_) \ 215 FP_HA_INFO(_u_)->blk_id[BCMI_FIELD_HA_BLK_TYPE_VFP_PRESEL_INFO]; 216 217 #define FP_VFP_PRESEL_HASH_BLK_ID(_u_) \ 218 FP_HA_INFO(_u_)->blk_id[BCMI_FIELD_HA_BLK_TYPE_VFP_PRESEL_HASH]; 219 220 #define FP_VFP_GRP_INFO_BLK_ID(_u_) \ 221 FP_HA_INFO(_u_)->blk_id[BCMI_FIELD_HA_BLK_TYPE_VFP_GROUP_INFO]; 222 223 #define FP_VFP_GRP_HASH_BLK_ID(_u_) \ 224 FP_HA_INFO(_u_)->blk_id[BCMI_FIELD_HA_BLK_TYPE_VFP_GROUP_HASH]; 225 226 #define FP_VFP_ENT_INFO_BLK_ID(_u_) \ 227 FP_HA_INFO(_u_)->blk_id[BCMI_FIELD_HA_BLK_TYPE_VFP_ENTRY_INFO]; 228 229 #define FP_VFP_ENT_HASH_BLK_ID(_u_) \ 230 FP_HA_INFO(_u_)->blk_id[BCMI_FIELD_HA_BLK_TYPE_VFP_ENTRY_HASH]; 231 232 #define FP_VFP_SBR_INFO_BLK_ID(_u_) \ 233 FP_HA_INFO(_u_)->blk_id[BCMI_FIELD_HA_BLK_TYPE_VFP_SBR_OPER]; 234 235 #define FP_EMFP_PRESEL_INFO_BLK_ID(_u_) \ 236 FP_HA_INFO(_u_)->blk_id[BCMI_FIELD_HA_BLK_TYPE_EMFP_PRESEL_INFO]; 237 238 #define FP_EMFP_PRESEL_HASH_BLK_ID(_u_) \ 239 FP_HA_INFO(_u_)->blk_id[BCMI_FIELD_HA_BLK_TYPE_EMFP_PRESEL_HASH]; 240 241 #define FP_EMFP_GRP_INFO_BLK_ID(_u_) \ 242 FP_HA_INFO(_u_)->blk_id[BCMI_FIELD_HA_BLK_TYPE_EMFP_GROUP_INFO]; 243 244 #define FP_EMFP_GRP_HASH_BLK_ID(_u_) \ 245 FP_HA_INFO(_u_)->blk_id[BCMI_FIELD_HA_BLK_TYPE_EMFP_GROUP_HASH]; 246 247 #define FP_EMFP_ENT_INFO_BLK_ID(_u_) \ 248 FP_HA_INFO(_u_)->blk_id[BCMI_FIELD_HA_BLK_TYPE_EMFP_ENTRY_INFO]; 249 250 #define FP_EMFP_ENT_HASH_BLK_ID(_u_) \ 251 FP_HA_INFO(_u_)->blk_id[BCMI_FIELD_HA_BLK_TYPE_EMFP_ENTRY_HASH]; 252 253 #define FP_EMFP_SBR_INFO_BLK_ID(_u_) \ 254 FP_HA_INFO(_u_)->blk_id[BCMI_FIELD_HA_BLK_TYPE_EMFP_SBR_OPER]; 255 256 #define FP_EMFT_PRESEL_INFO_BLK_ID(_u_) \ 257 FP_HA_INFO(_u_)->blk_id[BCMI_FIELD_HA_BLK_TYPE_EMFT_PRESEL_INFO]; 258 259 #define FP_EMFT_PRESEL_HASH_BLK_ID(_u_) \ 260 FP_HA_INFO(_u_)->blk_id[BCMI_FIELD_HA_BLK_TYPE_EMFT_PRESEL_HASH]; 261 262 #define FP_EMFT_GRP_INFO_BLK_ID(_u_) \ 263 FP_HA_INFO(_u_)->blk_id[BCMI_FIELD_HA_BLK_TYPE_EMFT_GROUP_INFO]; 264 265 #define FP_EMFT_GRP_HASH_BLK_ID(_u_) \ 266 FP_HA_INFO(_u_)->blk_id[BCMI_FIELD_HA_BLK_TYPE_EMFT_GROUP_HASH]; 267 268 #define FP_EMFT_ENT_INFO_BLK_ID(_u_) \ 269 FP_HA_INFO(_u_)->blk_id[BCMI_FIELD_HA_BLK_TYPE_EMFT_ENTRY_INFO]; 270 271 #define FP_EMFT_ENT_HASH_BLK_ID(_u_) \ 272 FP_HA_INFO(_u_)->blk_id[BCMI_FIELD_HA_BLK_TYPE_EMFT_ENTRY_HASH]; 273 274 #define FP_EMFT_SBR_INFO_BLK_ID(_u_) \ 275 FP_HA_INFO(_u_)->blk_id[BCMI_FIELD_HA_BLK_TYPE_EMFT_SBR_OPER]; 276 277 #define FP_IFP_COLOR_TBL_INFO_BLK_ID(_u_) \ 278 FP_HA_INFO(_u_)->blk_id[BCMI_FIELD_HA_BLK_TYPE_IFP_COLOR_TBL_INFO]; 279 280 #define FP_IFP_COLOR_TBL_PDD_INFO_BLK_ID(_u_) \ 281 FP_HA_INFO(_u_)->blk_id[BCMI_FIELD_HA_BLK_TYPE_IFP_COLOR_TBL_PDD_INFO]; 282 283 #define FP_IFP_COLOR_TBL_SBR_INFO_BLK_ID(_u_) \ 284 FP_HA_INFO(_u_)->blk_id[BCMI_FIELD_HA_BLK_TYPE_IFP_COLOR_TBL_SBR_INFO]; 285 286 #define FP_EFP_COLOR_TBL_INFO_BLK_ID(_u_) \ 287 FP_HA_INFO(_u_)->blk_id[BCMI_FIELD_HA_BLK_TYPE_EFP_COLOR_TBL_INFO]; 288 289 #define FP_EFP_COLOR_TBL_PDD_INFO_BLK_ID(_u_) \ 290 FP_HA_INFO(_u_)->blk_id[BCMI_FIELD_HA_BLK_TYPE_EFP_COLOR_TBL_PDD_INFO]; 291 292 #define FP_EFP_COLOR_TBL_SBR_INFO_BLK_ID(_u_) \ 293 FP_HA_INFO(_u_)->blk_id[BCMI_FIELD_HA_BLK_TYPE_EFP_COLOR_TBL_SBR_INFO]; 294 295 #define FP_HINT_LIST_BLK_ID(_u_) \ 296 FP_HA_INFO(_u_)->blk_id[BCMI_FIELD_HA_BLK_TYPE_HINT_LIST]; 297 298 #define FP_HINT_ENTRY_BLK_ID(_u_) \ 299 FP_HA_INFO(_u_)->blk_id[BCMI_FIELD_HA_BLK_TYPE_HINT_ENTRY]; 300 301 #define FP_GRP_INFO_BLK_ID(_u_, _stage_, _blk_id) \ 302 { \ 303 switch (_stage_) { \ 304 case bcmiFieldStageIngress: \ 305 _blk_id = FP_IFP_GRP_INFO_BLK_ID(_u_); \ 306 break; \ 307 case bcmiFieldStageVlan: \ 308 _blk_id = FP_VFP_GRP_INFO_BLK_ID(_u_); \ 309 break; \ 310 case bcmiFieldStageEgress: \ 311 _blk_id = FP_EFP_GRP_INFO_BLK_ID(_u_); \ 312 break; \ 313 case bcmiFieldStageExactMatch: \ 314 _blk_id = FP_EMFP_GRP_INFO_BLK_ID(_u_); \ 315 break; \ 316 case bcmiFieldStageFlowTracker: \ 317 _blk_id = FP_EMFT_GRP_INFO_BLK_ID(_u_); \ 318 break; \ 319 default: \ 320 SHR_IF_ERR_VERBOSE_EXIT(SHR_E_INTERNAL); \ 321 } \ 322 } 323 324 #define FP_GRP_HASH_BLK_ID(_u_, _stage_, _blk_id) \ 325 { \ 326 switch (_stage_) { \ 327 case bcmiFieldStageIngress: \ 328 _blk_id = FP_IFP_GRP_HASH_BLK_ID(_u_); \ 329 break; \ 330 case bcmiFieldStageVlan: \ 331 _blk_id = FP_VFP_GRP_HASH_BLK_ID(_u_); \ 332 break; \ 333 case bcmiFieldStageEgress: \ 334 _blk_id = FP_EFP_GRP_HASH_BLK_ID(_u_); \ 335 break; \ 336 case bcmiFieldStageExactMatch: \ 337 _blk_id = FP_EMFP_GRP_HASH_BLK_ID(_u_); \ 338 break; \ 339 case bcmiFieldStageFlowTracker: \ 340 _blk_id = FP_EMFT_GRP_HASH_BLK_ID(_u_); \ 341 break; \ 342 default: \ 343 SHR_IF_ERR_VERBOSE_EXIT(SHR_E_INTERNAL); \ 344 } \ 345 } 346 347 #define FP_PRESEL_INFO_BLK_ID(_u_, _stage_, _blk_id) \ 348 { \ 349 switch (_stage_) { \ 350 case bcmiFieldStageIngress: \ 351 _blk_id = FP_IFP_PRESEL_INFO_BLK_ID(_u_); \ 352 break; \ 353 case bcmiFieldStageVlan: \ 354 _blk_id = FP_VFP_PRESEL_INFO_BLK_ID(_u_); \ 355 break; \ 356 case bcmiFieldStageEgress: \ 357 _blk_id = FP_EFP_PRESEL_INFO_BLK_ID(_u_); \ 358 break; \ 359 case bcmiFieldStageExactMatch: \ 360 _blk_id = FP_EMFP_PRESEL_INFO_BLK_ID(_u_); \ 361 break; \ 362 case bcmiFieldStageFlowTracker: \ 363 _blk_id = FP_EMFT_PRESEL_INFO_BLK_ID(_u_); \ 364 break; \ 365 default: \ 366 SHR_IF_ERR_VERBOSE_EXIT(SHR_E_INTERNAL); \ 367 } \ 368 } 369 370 #define FP_PRESEL_HASH_BLK_ID(_u_, _stage_, _blk_id) \ 371 { \ 372 switch (_stage_) { \ 373 case bcmiFieldStageIngress: \ 374 _blk_id = FP_IFP_PRESEL_HASH_BLK_ID(_u_); \ 375 break; \ 376 case bcmiFieldStageVlan: \ 377 _blk_id = FP_VFP_PRESEL_HASH_BLK_ID(_u_); \ 378 break; \ 379 case bcmiFieldStageEgress: \ 380 _blk_id = FP_EFP_PRESEL_HASH_BLK_ID(_u_); \ 381 break; \ 382 case bcmiFieldStageExactMatch: \ 383 _blk_id = FP_EMFP_PRESEL_HASH_BLK_ID(_u_); \ 384 break; \ 385 case bcmiFieldStageFlowTracker: \ 386 _blk_id = FP_EMFT_PRESEL_HASH_BLK_ID(_u_); \ 387 break; \ 388 default: \ 389 SHR_IF_ERR_VERBOSE_EXIT(SHR_E_INTERNAL); \ 390 } \ 391 } 392 393 #define FP_ENTRY_INFO_BLK_ID(_u_, _stage_, _blk_id) \ 394 { \ 395 switch (_stage_) { \ 396 case bcmiFieldStageIngress: \ 397 _blk_id = FP_IFP_ENT_INFO_BLK_ID(_u_); \ 398 break; \ 399 case bcmiFieldStageVlan: \ 400 _blk_id = FP_VFP_ENT_INFO_BLK_ID(_u_); \ 401 break; \ 402 case bcmiFieldStageEgress: \ 403 _blk_id = FP_EFP_ENT_INFO_BLK_ID(_u_); \ 404 break; \ 405 case bcmiFieldStageExactMatch: \ 406 _blk_id = FP_EMFP_ENT_INFO_BLK_ID(_u_); \ 407 break; \ 408 case bcmiFieldStageFlowTracker: \ 409 _blk_id = FP_EMFT_ENT_INFO_BLK_ID(_u_); \ 410 break; \ 411 default: \ 412 SHR_IF_ERR_VERBOSE_EXIT(SHR_E_INTERNAL); \ 413 } \ 414 } 415 416 #define FP_ENTRY_HASH_BLK_ID(_u_, _stage_, _blk_id) \ 417 { \ 418 switch (_stage_) { \ 419 case bcmiFieldStageIngress: \ 420 _blk_id = FP_IFP_ENT_HASH_BLK_ID(_u_); \ 421 break; \ 422 case bcmiFieldStageVlan: \ 423 _blk_id = FP_VFP_ENT_HASH_BLK_ID(_u_); \ 424 break; \ 425 case bcmiFieldStageEgress: \ 426 _blk_id = FP_EFP_ENT_HASH_BLK_ID(_u_); \ 427 break; \ 428 case bcmiFieldStageExactMatch: \ 429 _blk_id = FP_EMFP_ENT_HASH_BLK_ID(_u_); \ 430 break; \ 431 case bcmiFieldStageFlowTracker: \ 432 _blk_id = FP_EMFT_ENT_HASH_BLK_ID(_u_); \ 433 break; \ 434 default: \ 435 SHR_IF_ERR_VERBOSE_EXIT(SHR_E_INTERNAL); \ 436 } \ 437 } 438 439 #define FP_SBR_INFO_BLK_ID(_u_, _stage_, _blk_id) \ 440 { \ 441 switch (_stage_) { \ 442 case bcmiFieldStageIngress: \ 443 _blk_id = FP_IFP_SBR_INFO_BLK_ID(_u_); \ 444 break; \ 445 case bcmiFieldStageVlan: \ 446 _blk_id = FP_VFP_SBR_INFO_BLK_ID(_u_); \ 447 break; \ 448 case bcmiFieldStageEgress: \ 449 _blk_id = FP_EFP_SBR_INFO_BLK_ID(_u_); \ 450 break; \ 451 case bcmiFieldStageExactMatch: \ 452 _blk_id = FP_EMFP_SBR_INFO_BLK_ID(_u_); \ 453 break; \ 454 case bcmiFieldStageFlowTracker: \ 455 _blk_id = FP_EMFT_SBR_INFO_BLK_ID(_u_); \ 456 break; \ 457 default: \ 458 SHR_IF_ERR_VERBOSE_EXIT(SHR_E_INTERNAL); \ 459 } \ 460 } 461 462 #define FP_COLOR_TBL_INFO_BLK_ID(_u_, _stage_, _blk_id) \ 463 { \ 464 switch (_stage_) { \ 465 case bcmiFieldStageIngress: \ 466 _blk_id = FP_IFP_COLOR_TBL_INFO_BLK_ID(_u_); \ 467 break; \ 468 case bcmiFieldStageEgress: \ 469 _blk_id = FP_EFP_COLOR_TBL_INFO_BLK_ID(_u_); \ 470 break; \ 471 default: \ 472 SHR_IF_ERR_VERBOSE_EXIT(SHR_E_INTERNAL); \ 473 } \ 474 } 475 476 #define FP_COLOR_TBL_PDD_INFO_BLK_ID(_u_, _stage_, _blk_id) \ 477 { \ 478 switch (_stage_) { \ 479 case bcmiFieldStageIngress: \ 480 _blk_id = FP_IFP_COLOR_TBL_PDD_INFO_BLK_ID(_u_);\ 481 break; \ 482 case bcmiFieldStageEgress: \ 483 _blk_id = FP_EFP_COLOR_TBL_PDD_INFO_BLK_ID(_u_);\ 484 break; \ 485 default: \ 486 SHR_IF_ERR_VERBOSE_EXIT(SHR_E_INTERNAL); \ 487 } \ 488 } 489 490 #define FP_COLOR_TBL_SBR_INFO_BLK_ID(_u_, _stage_, _blk_id) \ 491 { \ 492 switch (_stage_) { \ 493 case bcmiFieldStageIngress: \ 494 _blk_id = FP_IFP_COLOR_TBL_SBR_INFO_BLK_ID(_u_);\ 495 break; \ 496 case bcmiFieldStageEgress: \ 497 _blk_id = FP_EFP_COLOR_TBL_SBR_INFO_BLK_ID(_u_);\ 498 break; \ 499 default: \ 500 SHR_IF_ERR_VERBOSE_EXIT(SHR_E_INTERNAL); \ 501 } \ 502 } 503 504 #define FP_COLOR_TBL_INFO_BLK_TYPE(_u_, _stage_, _blk_type) \ 505 { \ 506 switch (_stage_) { \ 507 case bcmiFieldStageIngress: \ 508 _blk_type = BCMI_FIELD_HA_BLK_TYPE_IFP_COLOR_TBL_INFO; \ 509 break; \ 510 case bcmiFieldStageEgress: \ 511 _blk_type = BCMI_FIELD_HA_BLK_TYPE_EFP_COLOR_TBL_INFO; \ 512 break; \ 513 default: \ 514 SHR_IF_ERR_VERBOSE_EXIT(SHR_E_INTERNAL); \ 515 } \ 516 } 517 518 #define FP_COLOR_TBL_PDD_INFO_BLK_TYPE(_u_, _stage_, _blk_type) \ 519 { \ 520 switch (_stage_) { \ 521 case bcmiFieldStageIngress: \ 522 _blk_type = BCMI_FIELD_HA_BLK_TYPE_IFP_COLOR_TBL_PDD_INFO; \ 523 break; \ 524 case bcmiFieldStageEgress: \ 525 _blk_type = BCMI_FIELD_HA_BLK_TYPE_EFP_COLOR_TBL_PDD_INFO; \ 526 break; \ 527 default: \ 528 SHR_IF_ERR_VERBOSE_EXIT(SHR_E_INTERNAL); \ 529 } \ 530 } 531 532 #define FP_COLOR_TBL_SBR_INFO_BLK_TYPE(_u_, _stage_, _blk_type) \ 533 { \ 534 switch (_stage_) { \ 535 case bcmiFieldStageIngress: \ 536 _blk_type = BCMI_FIELD_HA_BLK_TYPE_IFP_COLOR_TBL_SBR_INFO; \ 537 break; \ 538 case bcmiFieldStageEgress: \ 539 _blk_type = BCMI_FIELD_HA_BLK_TYPE_EFP_COLOR_TBL_SBR_INFO; \ 540 break; \ 541 default: \ 542 SHR_IF_ERR_VERBOSE_EXIT(SHR_E_INTERNAL); \ 543 } \ 544 } 545 546 #define FP_STAGE_GRP_INFO_BLK_TYPE(_u_, _stage_, _blk_type) \ 547 { \ 548 switch (_stage_) { \ 549 case bcmiFieldStageIngress: \ 550 _blk_type = BCMI_FIELD_HA_BLK_TYPE_IFP_GROUP_INFO; \ 551 break; \ 552 case bcmiFieldStageVlan: \ 553 _blk_type = BCMI_FIELD_HA_BLK_TYPE_VFP_GROUP_INFO; \ 554 break; \ 555 case bcmiFieldStageEgress: \ 556 _blk_type = BCMI_FIELD_HA_BLK_TYPE_EFP_GROUP_INFO; \ 557 break; \ 558 case bcmiFieldStageExactMatch: \ 559 _blk_type = BCMI_FIELD_HA_BLK_TYPE_EMFP_GROUP_INFO; \ 560 break; \ 561 case bcmiFieldStageFlowTracker: \ 562 _blk_type = BCMI_FIELD_HA_BLK_TYPE_EMFT_GROUP_INFO; \ 563 break; \ 564 default: \ 565 SHR_IF_ERR_VERBOSE_EXIT(SHR_E_INTERNAL); \ 566 } \ 567 } 568 569 #define FP_STAGE_GRP_HASH_BLK_TYPE(_u_, _stage_, _blk_type) \ 570 { \ 571 switch (_stage_) { \ 572 case bcmiFieldStageIngress: \ 573 _blk_type = BCMI_FIELD_HA_BLK_TYPE_IFP_GROUP_HASH; \ 574 break; \ 575 case bcmiFieldStageVlan: \ 576 _blk_type = BCMI_FIELD_HA_BLK_TYPE_VFP_GROUP_HASH; \ 577 break; \ 578 case bcmiFieldStageEgress: \ 579 _blk_type = BCMI_FIELD_HA_BLK_TYPE_EFP_GROUP_HASH; \ 580 break; \ 581 case bcmiFieldStageExactMatch: \ 582 _blk_type = BCMI_FIELD_HA_BLK_TYPE_EMFP_GROUP_HASH; \ 583 break; \ 584 case bcmiFieldStageFlowTracker: \ 585 _blk_type = BCMI_FIELD_HA_BLK_TYPE_EMFT_GROUP_HASH; \ 586 break; \ 587 default: \ 588 SHR_IF_ERR_VERBOSE_EXIT(SHR_E_INTERNAL); \ 589 } \ 590 } 591 592 #define FP_STAGE_GRP_OPER_BLK_TYPE(_u_, _stage_, _blk_type) \ 593 { \ 594 switch (_stage_) { \ 595 case bcmiFieldStageIngress: \ 596 _blk_type = BCMI_FIELD_HA_BLK_TYPE_IFP_GROUP_OPER; \ 597 break; \ 598 case bcmiFieldStageVlan: \ 599 _blk_type = BCMI_FIELD_HA_BLK_TYPE_VFP_GROUP_OPER; \ 600 break; \ 601 case bcmiFieldStageEgress: \ 602 _blk_type = BCMI_FIELD_HA_BLK_TYPE_EFP_GROUP_OPER; \ 603 break; \ 604 case bcmiFieldStageExactMatch: \ 605 _blk_type = BCMI_FIELD_HA_BLK_TYPE_EMFP_GROUP_OPER; \ 606 break; \ 607 case bcmiFieldStageFlowTracker: \ 608 _blk_type = BCMI_FIELD_HA_BLK_TYPE_EMFT_GROUP_OPER; \ 609 break; \ 610 default: \ 611 SHR_IF_ERR_VERBOSE_EXIT(SHR_E_INTERNAL); \ 612 } \ 613 } 614 615 616 #define FP_STAGE_PRESEL_INFO_BLK_TYPE(_u_, _stage_, _blk_type) \ 617 { \ 618 switch (_stage_) { \ 619 case bcmiFieldStageIngress: \ 620 _blk_type = BCMI_FIELD_HA_BLK_TYPE_IFP_PRESEL_INFO; \ 621 break; \ 622 case bcmiFieldStageVlan: \ 623 _blk_type = BCMI_FIELD_HA_BLK_TYPE_VFP_PRESEL_INFO; \ 624 break; \ 625 case bcmiFieldStageEgress: \ 626 _blk_type = BCMI_FIELD_HA_BLK_TYPE_EFP_PRESEL_INFO; \ 627 break; \ 628 case bcmiFieldStageExactMatch: \ 629 _blk_type = BCMI_FIELD_HA_BLK_TYPE_EMFP_PRESEL_INFO; \ 630 break; \ 631 case bcmiFieldStageFlowTracker: \ 632 _blk_type = BCMI_FIELD_HA_BLK_TYPE_EMFT_PRESEL_INFO; \ 633 break; \ 634 default: \ 635 SHR_IF_ERR_VERBOSE_EXIT(SHR_E_INTERNAL); \ 636 } \ 637 } 638 639 #define FP_STAGE_PRESEL_HASH_BLK_TYPE(_u_, _stage_, _blk_type) \ 640 { \ 641 switch (_stage_) { \ 642 case bcmiFieldStageIngress: \ 643 _blk_type = BCMI_FIELD_HA_BLK_TYPE_IFP_PRESEL_HASH; \ 644 break; \ 645 case bcmiFieldStageVlan: \ 646 _blk_type = BCMI_FIELD_HA_BLK_TYPE_VFP_PRESEL_HASH; \ 647 break; \ 648 case bcmiFieldStageEgress: \ 649 _blk_type = BCMI_FIELD_HA_BLK_TYPE_EFP_PRESEL_HASH; \ 650 break; \ 651 case bcmiFieldStageExactMatch: \ 652 _blk_type = BCMI_FIELD_HA_BLK_TYPE_EMFP_PRESEL_HASH; \ 653 break; \ 654 case bcmiFieldStageFlowTracker: \ 655 _blk_type = BCMI_FIELD_HA_BLK_TYPE_EMFT_PRESEL_HASH; \ 656 break; \ 657 default: \ 658 SHR_IF_ERR_VERBOSE_EXIT(SHR_E_INTERNAL); \ 659 } \ 660 } 661 662 #define FP_STAGE_PRESEL_OPER_BLK_TYPE(_u_, _stage_, _blk_type) \ 663 { \ 664 switch (_stage_) { \ 665 case bcmiFieldStageIngress: \ 666 _blk_type = BCMI_FIELD_HA_BLK_TYPE_IFP_PRESEL_OPER; \ 667 break; \ 668 case bcmiFieldStageVlan: \ 669 _blk_type = BCMI_FIELD_HA_BLK_TYPE_VFP_PRESEL_OPER; \ 670 break; \ 671 case bcmiFieldStageEgress: \ 672 _blk_type = BCMI_FIELD_HA_BLK_TYPE_EFP_PRESEL_OPER; \ 673 break; \ 674 case bcmiFieldStageExactMatch: \ 675 _blk_type = BCMI_FIELD_HA_BLK_TYPE_EMFP_PRESEL_OPER; \ 676 break; \ 677 case bcmiFieldStageFlowTracker: \ 678 _blk_type = BCMI_FIELD_HA_BLK_TYPE_EMFT_PRESEL_OPER; \ 679 break; \ 680 default: \ 681 SHR_IF_ERR_VERBOSE_EXIT(SHR_E_INTERNAL); \ 682 } \ 683 } 684 685 #define FP_STAGE_ENTRY_INFO_BLK_TYPE(_u_, _stage_, _blk_type) \ 686 { \ 687 switch (_stage_) { \ 688 case bcmiFieldStageIngress: \ 689 _blk_type = BCMI_FIELD_HA_BLK_TYPE_IFP_ENTRY_INFO; \ 690 break; \ 691 case bcmiFieldStageVlan: \ 692 _blk_type = BCMI_FIELD_HA_BLK_TYPE_VFP_ENTRY_INFO; \ 693 break; \ 694 case bcmiFieldStageEgress: \ 695 _blk_type = BCMI_FIELD_HA_BLK_TYPE_EFP_ENTRY_INFO; \ 696 break; \ 697 case bcmiFieldStageExactMatch: \ 698 _blk_type = BCMI_FIELD_HA_BLK_TYPE_EMFP_ENTRY_INFO; \ 699 break; \ 700 case bcmiFieldStageFlowTracker: \ 701 _blk_type = BCMI_FIELD_HA_BLK_TYPE_EMFT_ENTRY_INFO; \ 702 break; \ 703 default: \ 704 SHR_IF_ERR_VERBOSE_EXIT(SHR_E_INTERNAL); \ 705 } \ 706 } 707 708 #define FP_STAGE_ENTRY_HASH_BLK_TYPE(_u_, _stage_, _blk_type) \ 709 { \ 710 switch (_stage_) { \ 711 case bcmiFieldStageIngress: \ 712 _blk_type = BCMI_FIELD_HA_BLK_TYPE_IFP_ENTRY_HASH; \ 713 break; \ 714 case bcmiFieldStageVlan: \ 715 _blk_type = BCMI_FIELD_HA_BLK_TYPE_VFP_ENTRY_HASH; \ 716 break; \ 717 case bcmiFieldStageEgress: \ 718 _blk_type = BCMI_FIELD_HA_BLK_TYPE_EFP_ENTRY_HASH; \ 719 break; \ 720 case bcmiFieldStageExactMatch: \ 721 _blk_type = BCMI_FIELD_HA_BLK_TYPE_EMFP_ENTRY_HASH; \ 722 break; \ 723 case bcmiFieldStageFlowTracker: \ 724 _blk_type = BCMI_FIELD_HA_BLK_TYPE_EMFT_ENTRY_HASH; \ 725 break; \ 726 default: \ 727 SHR_IF_ERR_VERBOSE_EXIT(SHR_E_INTERNAL); \ 728 } \ 729 } 730 731 #define FP_STAGE_ENTRY_OPER_BLK_TYPE(_u_, _stage_, _blk_type) \ 732 { \ 733 switch (_stage_) { \ 734 case bcmiFieldStageIngress: \ 735 _blk_type = BCMI_FIELD_HA_BLK_TYPE_IFP_ENTRY_OPER; \ 736 break; \ 737 case bcmiFieldStageVlan: \ 738 _blk_type = BCMI_FIELD_HA_BLK_TYPE_VFP_ENTRY_OPER; \ 739 break; \ 740 case bcmiFieldStageEgress: \ 741 _blk_type = BCMI_FIELD_HA_BLK_TYPE_EFP_ENTRY_OPER; \ 742 break; \ 743 case bcmiFieldStageExactMatch: \ 744 _blk_type = BCMI_FIELD_HA_BLK_TYPE_EMFP_ENTRY_OPER; \ 745 break; \ 746 case bcmiFieldStageFlowTracker: \ 747 _blk_type = BCMI_FIELD_HA_BLK_TYPE_EMFT_ENTRY_OPER; \ 748 break; \ 749 default: \ 750 SHR_IF_ERR_VERBOSE_EXIT(SHR_E_INTERNAL); \ 751 } \ 752 } 753 754 #define FP_STAGE_SBR_INFO_BLK_TYPE(_u_, _stage_, _blk_type) \ 755 { \ 756 switch (_stage_) { \ 757 case bcmiFieldStageIngress: \ 758 _blk_type = BCMI_FIELD_HA_BLK_TYPE_IFP_SBR_INFO; \ 759 break; \ 760 case bcmiFieldStageVlan: \ 761 _blk_type = BCMI_FIELD_HA_BLK_TYPE_VFP_SBR_INFO; \ 762 break; \ 763 case bcmiFieldStageEgress: \ 764 _blk_type = BCMI_FIELD_HA_BLK_TYPE_EFP_SBR_INFO; \ 765 break; \ 766 case bcmiFieldStageExactMatch: \ 767 _blk_type = BCMI_FIELD_HA_BLK_TYPE_EMFP_SBR_INFO; \ 768 break; \ 769 case bcmiFieldStageFlowTracker: \ 770 _blk_type = BCMI_FIELD_HA_BLK_TYPE_EMFT_SBR_INFO; \ 771 break; \ 772 default: \ 773 SHR_IF_ERR_VERBOSE_EXIT(SHR_E_INTERNAL); \ 774 } \ 775 } 776 777 #define FP_HINT_LIST_BLK_TYPE(_u_, _blk_type) \ 778 { \ 779 _blk_type = BCMI_FIELD_HA_BLK_TYPE_HINT_LIST; \ 780 } 781 782 #define FP_HINT_ENTRY_BLK_TYPE(_u_, _blk_type) \ 783 { \ 784 _blk_type = BCMI_FIELD_HA_BLK_TYPE_HINT_ENTRY; \ 785 } 786 787 #define FP_HA_DYNAMIC_BLK_SIZE(_u_, _p, _blk_type, _blk_size) \ 788 { \ 789 switch (_blk_type) { \ 790 case BCMI_FIELD_HA_BLK_TYPE_IFP_GROUP_OPER: \ 791 /* _blk_size = pipe * max_groups * sizeof(group_oper) */ \ 792 _blk_size = _p * 20 * sizeof(bcmi_field_ha_group_oper_t); \ 793 break; \ 794 case BCMI_FIELD_HA_BLK_TYPE_VFP_GROUP_OPER: \ 795 case BCMI_FIELD_HA_BLK_TYPE_EFP_GROUP_OPER: \ 796 _blk_size = _p * 4 * sizeof(bcmi_field_ha_group_oper_t); \ 797 break; \ 798 case BCMI_FIELD_HA_BLK_TYPE_EMFP_GROUP_OPER: \ 799 case BCMI_FIELD_HA_BLK_TYPE_EMFT_GROUP_OPER: \ 800 _blk_size = _p * 4 * sizeof(bcmi_field_ha_group_oper_t); \ 801 break; \ 802 case BCMI_FIELD_HA_BLK_TYPE_IFP_ENTRY_OPER: \ 803 _blk_size = _p * 4096 * sizeof(bcmi_field_ha_entry_oper_t); \ 804 break; \ 805 case BCMI_FIELD_HA_BLK_TYPE_VFP_ENTRY_OPER: \ 806 case BCMI_FIELD_HA_BLK_TYPE_EFP_ENTRY_OPER: \ 807 _blk_size = _p * 1024 * sizeof(bcmi_field_ha_entry_oper_t); \ 808 break; \ 809 case BCMI_FIELD_HA_BLK_TYPE_EMFP_ENTRY_OPER: \ 810 case BCMI_FIELD_HA_BLK_TYPE_EMFT_ENTRY_OPER: \ 811 _blk_size = _p * 10240 * sizeof(bcmi_field_ha_entry_oper_t); \ 812 break; \ 813 case BCMI_FIELD_HA_BLK_TYPE_IFP_PRESEL_OPER: \ 814 case BCMI_FIELD_HA_BLK_TYPE_VFP_PRESEL_OPER: \ 815 case BCMI_FIELD_HA_BLK_TYPE_EFP_PRESEL_OPER: \ 816 case BCMI_FIELD_HA_BLK_TYPE_EMFP_PRESEL_OPER: \ 817 case BCMI_FIELD_HA_BLK_TYPE_EMFT_PRESEL_OPER: \ 818 _blk_size = _p * 32 * sizeof(bcmi_field_ha_presel_oper_t); \ 819 break; \ 820 case BCMI_FIELD_HA_BLK_TYPE_HINT_ENTRY: \ 821 _blk_size = 40 * sizeof(bcmi_field_ha_hint_entry_t); \ 822 break; \ 823 default: \ 824 SHR_IF_ERR_VERBOSE_EXIT(SHR_E_INTERNAL); \ 825 } \ 826 } 827 828 #define FP_HA_MEM_ALLOC(_u_, _comp_, _sub_comp_, \ 829 _size_, _ha_ptr_, _descr_, _w_) \ 830 { \ 831 uint32_t _ha_size_ = _size_; \ 832 _ha_ptr_ = bcmi_ltsw_ha_mem_alloc(_u_, \ 833 _comp_, \ 834 _sub_comp_, \ 835 _descr_, \ 836 &_ha_size_); \ 837 if (_w_ == 0) { \ 838 SHR_NULL_CHECK(_ha_ptr_, SHR_E_MEMORY); \ 839 SHR_IF_ERR_VERBOSE_EXIT((_ha_size_ < _size_) ? \ 840 SHR_E_MEMORY : SHR_E_NONE); \ 841 } else { \ 842 SHR_NULL_CHECK(_ha_ptr_, SHR_E_INTERNAL); \ 843 _size_ = _ha_size_; \ 844 } \ 845 } 846 847 848 #define FP_HA_GROUP_OPER_DEF_ENTRY_ASET_ARR_GET(_u_, _grp_oper, _aset) \ 849 { \ 850 bcm_field_action_t _a; \ 851 for (_a = 0; _a < _grp_oper->def_action_cnt; _a++) { \ 852 BCM_FIELD_ASET_ADD(_aset, _grp_oper->def_aset_arr[_a]); \ 853 } \ 854 } 855 856 #define FP_HA_GROUP_OPER_DEF_ENTRY_ASET_ARR_SET(_u_, _grp_oper, _aset) \ 857 { \ 858 uint16_t _ct = 0; \ 859 bcm_field_action_t _a; \ 860 for (_a = 0; _a < bcmFieldActionCount; _a++) { \ 861 if (BCM_FIELD_ASET_TEST(_aset, _a)) { \ 862 _grp_oper->def_aset_arr[_ct++] = _a; \ 863 } \ 864 } \ 865 _grp_oper->def_action_cnt = _ct; \ 866 } 867 868 #define FP_HA_GROUP_OPER_DEF_ENTRY_ASET_TEST(_grp_oper, _act, _f) \ 869 { \ 870 bcm_field_action_t _a; \ 871 _f = FALSE; \ 872 for (_a = 0; _a < _grp_oper->def_action_cnt; _a++) { \ 873 if (_grp_oper->def_aset_arr[_a] == _act) { \ 874 _f = TRUE; \ 875 break; \ 876 } \ 877 } \ 878 } 879 880 #define FP_HA_GROUP_OPER_ASET_ARR_GET(_u_, _grp_oper, _aset) \ 881 { \ 882 bcm_field_action_t _a; \ 883 for (_a = 0; _a < _grp_oper->action_cnt; _a++) { \ 884 BCM_FIELD_ASET_ADD(_aset, _grp_oper->aset_arr[_a]); \ 885 } \ 886 } 887 888 #define FP_HA_GROUP_OPER_ASET_ARR_SET(_u_, _grp_oper, _aset) \ 889 { \ 890 uint16_t _ct = 0; \ 891 bcm_field_action_t _a; \ 892 for (_a = 0; _a < bcmFieldActionCount; _a++) { \ 893 if (BCM_FIELD_ASET_TEST(_aset, _a)) { \ 894 _grp_oper->aset_arr[_ct++] = _a; \ 895 } \ 896 } \ 897 _grp_oper->action_cnt = _ct; \ 898 } 899 900 #define FP_HA_GROUP_OPER_ASET_TEST(_grp_oper, _act, _f) \ 901 { \ 902 bcm_field_action_t _a; \ 903 _f = FALSE; \ 904 for (_a = 0; _a < _grp_oper->action_cnt; _a++) { \ 905 if (_grp_oper->aset_arr[_a] == _act) { \ 906 _f = TRUE; \ 907 break; \ 908 } \ 909 } \ 910 } 911 912 #define FP_HA_GROUP_OPER_QSET_ARR_GET(_u_, _grp_oper, _qset) \ 913 { \ 914 bcmi_field_qualify_t _q; \ 915 for (_q = 0; _q < _grp_oper->qual_cnt; _q++) { \ 916 BCM_FIELD_QSET_ADD(_qset, _grp_oper->qset_arr[_q]); \ 917 } \ 918 } 919 920 #define FP_HA_GROUP_OPER_QSET_ARR_SET(_u_, _grp_oper, _qset) \ 921 { \ 922 uint16_t _ct = 0; \ 923 bcmi_field_qualify_t _q; \ 924 for (_q = 0; _q < bcmiFieldQualifyLastCount; _q++) { \ 925 if (BCM_FIELD_QSET_TEST(_qset, _q)) { \ 926 _grp_oper->qset_arr[_ct++] = _q; \ 927 } \ 928 } \ 929 _grp_oper->qual_cnt = _ct; \ 930 } 931 932 #define FP_HA_GROUP_OPER_QSET_TEST(_grp_oper, _qual, _f) \ 933 { \ 934 bcmi_field_qualify_t _q; \ 935 _f = FALSE; \ 936 for (_q = 0; _q < _grp_oper->qual_cnt; _q++) { \ 937 if (_grp_oper->qset_arr[_q] == _qual) { \ 938 _f = TRUE; \ 939 break; \ 940 } \ 941 } \ 942 } 943 944 #define FP_HA_GROUP_OPER_PRESEL_ARR_GET(_u_, _grp_oper, _pset) \ 945 { \ 946 uint16_t _p; \ 947 for (_p = 0; _p < _grp_oper->presel_cnt; _p++) { \ 948 BCM_FIELD_PRESEL_ADD(_pset, _grp_oper->presel_arr[_p]);\ 949 } \ 950 } 951 952 953 #define FP_HA_GROUP_OPER_PRESEL_ARR_SET(_u_, _grp_oper, _pset) \ 954 { \ 955 uint16_t _ct = 0; \ 956 uint16_t _p; \ 957 for (_p = 0; _p < BCM_FIELD_PRESEL_SEL_MAX; _p++) { \ 958 if (BCM_FIELD_PRESEL_TEST(_pset, _p)) { \ 959 _grp_oper->presel_arr[_ct++] = _p; \ 960 } \ 961 } \ 962 _grp_oper->presel_cnt = _ct; \ 963 } 964 965 966 #define FP_HA_GROUP_OPER_PRESEL_TEST(_grp_oper, _presel, _f) \ 967 { \ 968 int _p; \ 969 _f = FALSE; \ 970 for (_p = 0; _p < _grp_oper->presel_cnt; _p++) { \ 971 if (_grp_oper->presel_arr[_p] == _presel) { \ 972 _f = TRUE; \ 973 break; \ 974 } \ 975 } \ 976 } 977 978 #define FP_HA_GRP_BASE_BLK_GET(_u, _stage, _hash_off, _grp_base) \ 979 { \ 980 int _blk_type; \ 981 void *_hash_blk = NULL; \ 982 uint8_t _blk_id = BCM_FIELD_HA_BLK_ID_INVALID; \ 983 bcmi_field_ha_blk_hdr_t *_blk_hdr; \ 984 FP_GRP_HASH_BLK_ID(_u, _stage, _blk_id); \ 985 _hash_blk = FP_HA_BLK_HDR_PTR(_u, _blk_id); \ 986 if ((_blk_id == BCM_FIELD_HA_BLK_ID_INVALID) || \ 987 (_hash_blk == NULL)) { \ 988 SHR_ERR_EXIT(SHR_E_INTERNAL); \ 989 } \ 990 FP_STAGE_GRP_HASH_BLK_TYPE(_u, _stage, _blk_type); \ 991 _blk_hdr = (bcmi_field_ha_blk_hdr_t *)_hash_blk; \ 992 if (_blk_hdr->blk_type != _blk_type) { \ 993 SHR_ERR_EXIT(SHR_E_INTERNAL); \ 994 } \ 995 _grp_base = (bcmi_field_ha_blk_info_t *) \ 996 (_hash_blk + sizeof(bcmi_field_ha_blk_hdr_t)); \ 997 _grp_base = _grp_base + _hash_off; \ 998 } 999 1000 #define FP_HA_GRP_OPER_GET(_u, _stage, _hash_off, _oper) \ 1001 { \ 1002 int _blk_type; \ 1003 void *_ptr = NULL; \ 1004 bcmi_field_ha_blk_info_t *_head; \ 1005 uint8_t _blk_id = BCM_FIELD_HA_BLK_ID_INVALID; \ 1006 uint32_t _blk_off; \ 1007 bcmi_field_ha_blk_hdr_t *_blk_hdr; \ 1008 FP_HA_GRP_BASE_BLK_GET(_u, _stage, _hash_off, _head); \ 1009 _blk_id = _head->blk_id; \ 1010 _blk_off = _head->blk_offset; \ 1011 if (_blk_id == BCM_FIELD_HA_BLK_ID_INVALID) { \ 1012 _oper = NULL; \ 1013 } else { \ 1014 FP_STAGE_GRP_OPER_BLK_TYPE(_u, _stage, _blk_type); \ 1015 _ptr = FP_HA_BLK_HDR_PTR(unit, _blk_id); \ 1016 _blk_hdr = (bcmi_field_ha_blk_hdr_t *)_ptr; \ 1017 if (_blk_hdr->blk_type != _blk_type) { \ 1018 SHR_ERR_EXIT(SHR_E_INTERNAL); \ 1019 } \ 1020 _oper = (bcmi_field_ha_group_oper_t *)(_ptr + _blk_off); \ 1021 } \ 1022 } 1023 1024 #define FP_HA_GRP_BASE_OPER_GET(_u, _stage, _g_base, _hash_off, _oper) \ 1025 { \ 1026 uint8_t _blk_id = BCM_FIELD_HA_BLK_ID_INVALID; \ 1027 uint32_t _blk_off; \ 1028 uint32_t _blk_type; \ 1029 bcmi_field_ha_blk_hdr_t *_blk_hdr; \ 1030 bcmi_field_ha_blk_info_t *_b_info; \ 1031 void *_ptr; \ 1032 if (_g_base == NULL) { \ 1033 SHR_ERR_EXIT(SHR_E_INTERNAL); \ 1034 } \ 1035 _b_info = _g_base + _hash_off; \ 1036 _blk_id = _b_info->blk_id; \ 1037 if (_blk_id == BCM_FIELD_HA_BLK_ID_INVALID) { \ 1038 _oper = NULL; \ 1039 } else { \ 1040 _blk_off = _b_info->blk_offset; \ 1041 FP_STAGE_GRP_OPER_BLK_TYPE(_u, _stage, _blk_type); \ 1042 _ptr = FP_HA_BLK_HDR_PTR(unit, _blk_id); \ 1043 _blk_hdr = (bcmi_field_ha_blk_hdr_t *)_ptr; \ 1044 if (_blk_hdr->blk_type != _blk_type) { \ 1045 SHR_ERR_EXIT(SHR_E_INTERNAL); \ 1046 } \ 1047 _oper = (bcmi_field_ha_group_oper_t *)(_ptr + _blk_off); \ 1048 } \ 1049 } 1050 1051 #define FP_HA_GRP_OPER_NEXT(_u, _oper, _oper_next) \ 1052 { \ 1053 if (_oper->next.blk_id != BCM_FIELD_HA_BLK_ID_INVALID) { \ 1054 _oper_next = (bcmi_field_ha_group_oper_t *) \ 1055 (FP_HA_BLK_HDR_PTR(_u, _oper->next.blk_id) + \ 1056 _oper->next.blk_offset); \ 1057 } else { \ 1058 _oper_next = NULL; \ 1059 } \ 1060 } 1061 1062 1063 #define FP_HA_ENT_BASE_BLK_GET(_u, _stage, _hash_off, _ent_base) \ 1064 { \ 1065 int _blk_type; \ 1066 void *_hash_blk = NULL; \ 1067 uint8_t _blk_id = BCM_FIELD_HA_BLK_ID_INVALID; \ 1068 bcmi_field_ha_blk_hdr_t *_blk_hdr; \ 1069 FP_ENTRY_HASH_BLK_ID(_u, _stage, _blk_id); \ 1070 _hash_blk = FP_HA_BLK_HDR_PTR(_u, _blk_id); \ 1071 if ((_blk_id == BCM_FIELD_HA_BLK_ID_INVALID) || \ 1072 (_hash_blk == NULL)) { \ 1073 SHR_ERR_EXIT(SHR_E_INTERNAL); \ 1074 } \ 1075 FP_STAGE_ENTRY_HASH_BLK_TYPE(_u, _stage, _blk_type); \ 1076 _blk_hdr = (bcmi_field_ha_blk_hdr_t *)_hash_blk; \ 1077 if (_blk_hdr->blk_type != _blk_type) { \ 1078 SHR_ERR_EXIT(SHR_E_INTERNAL); \ 1079 } \ 1080 _ent_base = (bcmi_field_ha_blk_info_t *) \ 1081 (_hash_blk + sizeof(bcmi_field_ha_blk_hdr_t)); \ 1082 _ent_base = _ent_base + _hash_off; \ 1083 } 1084 1085 #define FP_HA_ENT_OPER_GET(_u, _stage, _hash_off, _oper) \ 1086 { \ 1087 int _blk_type; \ 1088 void *_ptr = NULL; \ 1089 bcmi_field_ha_blk_info_t *_ent_head; \ 1090 uint8_t _blk_id = BCM_FIELD_HA_BLK_ID_INVALID; \ 1091 uint32_t _blk_off; \ 1092 bcmi_field_ha_blk_hdr_t *_blk_hdr; \ 1093 FP_HA_ENT_BASE_BLK_GET(_u, _stage, _hash_off, _ent_head); \ 1094 _blk_id = _ent_head->blk_id; \ 1095 _blk_off = _ent_head->blk_offset; \ 1096 if (_blk_id == BCM_FIELD_HA_BLK_ID_INVALID) { \ 1097 _oper = NULL; \ 1098 } else { \ 1099 FP_STAGE_ENTRY_OPER_BLK_TYPE(_u, _stage, _blk_type); \ 1100 _ptr = FP_HA_BLK_HDR_PTR(unit, _blk_id); \ 1101 _blk_hdr = (bcmi_field_ha_blk_hdr_t *)_ptr; \ 1102 if (_blk_hdr->blk_type != _blk_type) { \ 1103 SHR_ERR_EXIT(SHR_E_INTERNAL); \ 1104 } \ 1105 _oper = (bcmi_field_ha_entry_oper_t *) (_ptr + _blk_off); \ 1106 } \ 1107 } 1108 1109 #define FP_HA_ENT_BASE_OPER_GET(_u, _stage, _e_base, _hash_off, _oper) \ 1110 { \ 1111 uint8_t _blk_id = BCM_FIELD_HA_BLK_ID_INVALID; \ 1112 uint32_t _blk_off; \ 1113 uint32_t _blk_type; \ 1114 bcmi_field_ha_blk_hdr_t *_blk_hdr; \ 1115 bcmi_field_ha_blk_info_t *_b_info; \ 1116 void *_ptr; \ 1117 if (_e_base == NULL) { \ 1118 SHR_ERR_EXIT(SHR_E_INTERNAL); \ 1119 } \ 1120 _b_info = _e_base + _hash_off; \ 1121 _blk_id = _b_info->blk_id; \ 1122 if (_blk_id == BCM_FIELD_HA_BLK_ID_INVALID) { \ 1123 _oper = NULL; \ 1124 } else { \ 1125 _blk_off = _b_info->blk_offset; \ 1126 FP_STAGE_ENTRY_OPER_BLK_TYPE(_u, _stage, _blk_type); \ 1127 _ptr = FP_HA_BLK_HDR_PTR(unit, _blk_id); \ 1128 _blk_hdr = (bcmi_field_ha_blk_hdr_t *)_ptr; \ 1129 if (_blk_hdr->blk_type != _blk_type) { \ 1130 SHR_ERR_EXIT(SHR_E_INTERNAL); \ 1131 } \ 1132 _oper = (bcmi_field_ha_entry_oper_t *)(_ptr + _blk_off); \ 1133 } \ 1134 } 1135 1136 #define FP_HA_ENT_OPER_NEXT(_u, _oper, _oper_next) \ 1137 { \ 1138 if (_oper->next.blk_id != BCM_FIELD_HA_BLK_ID_INVALID) { \ 1139 _oper_next = (bcmi_field_ha_entry_oper_t *) \ 1140 (FP_HA_BLK_HDR_PTR(_u, _oper->next.blk_id) + \ 1141 _oper->next.blk_offset); \ 1142 } else { \ 1143 _oper_next = NULL; \ 1144 } \ 1145 } 1146 1147 #define FP_HA_PRESEL_BASE_BLK_GET(_u, _stage, _hash_off, _ent_base) \ 1148 { \ 1149 int _blk_type; \ 1150 void *_hash_blk = NULL; \ 1151 uint8_t _blk_id = BCM_FIELD_HA_BLK_ID_INVALID; \ 1152 bcmi_field_ha_blk_hdr_t *_blk_hdr; \ 1153 FP_PRESEL_HASH_BLK_ID(_u, _stage, _blk_id); \ 1154 _hash_blk = FP_HA_BLK_HDR_PTR(_u, _blk_id); \ 1155 if ((_blk_id == BCM_FIELD_HA_BLK_ID_INVALID) || \ 1156 (_hash_blk == NULL)) { \ 1157 SHR_ERR_EXIT(SHR_E_INTERNAL); \ 1158 } \ 1159 FP_STAGE_PRESEL_HASH_BLK_TYPE(_u, _stage, _blk_type); \ 1160 _blk_hdr = (bcmi_field_ha_blk_hdr_t *)_hash_blk; \ 1161 if (_blk_hdr->blk_type != _blk_type) { \ 1162 SHR_ERR_EXIT(SHR_E_INTERNAL); \ 1163 } \ 1164 _ent_base = (bcmi_field_ha_blk_info_t *) \ 1165 (_hash_blk + sizeof(bcmi_field_ha_blk_hdr_t)); \ 1166 _ent_base = _ent_base + _hash_off; \ 1167 } 1168 1169 #define FP_HA_PRESEL_OPER_GET(_u, _stage, _hash_off, _oper) \ 1170 { \ 1171 int _blk_type; \ 1172 void *_ptr = NULL; \ 1173 bcmi_field_ha_blk_info_t *_ent_head; \ 1174 uint8_t _blk_id = BCM_FIELD_HA_BLK_ID_INVALID; \ 1175 uint32_t _blk_off; \ 1176 bcmi_field_ha_blk_hdr_t *_blk_hdr; \ 1177 FP_HA_PRESEL_BASE_BLK_GET(_u, _stage, _hash_off, _ent_head); \ 1178 _blk_id = _ent_head->blk_id; \ 1179 _blk_off = _ent_head->blk_offset; \ 1180 if (_blk_id == BCM_FIELD_HA_BLK_ID_INVALID) { \ 1181 _oper = NULL; \ 1182 } else { \ 1183 FP_STAGE_PRESEL_OPER_BLK_TYPE(_u, _stage, _blk_type); \ 1184 _ptr = FP_HA_BLK_HDR_PTR(unit, _blk_id); \ 1185 _blk_hdr = (bcmi_field_ha_blk_hdr_t *)_ptr; \ 1186 if (_blk_hdr->blk_type != _blk_type) { \ 1187 SHR_ERR_EXIT(SHR_E_INTERNAL); \ 1188 } \ 1189 _oper = (bcmi_field_ha_presel_oper_t *) (_ptr + _blk_off); \ 1190 } \ 1191 } 1192 1193 #define FP_HA_PRESEL_BASE_OPER_GET(_u, _stage, _e_base, _hash_off, _oper) \ 1194 { \ 1195 uint8_t _blk_id = BCM_FIELD_HA_BLK_ID_INVALID; \ 1196 uint32_t _blk_off; \ 1197 int _blk_type; \ 1198 void *_ptr; \ 1199 bcmi_field_ha_blk_hdr_t *_blk_hdr; \ 1200 bcmi_field_ha_blk_info_t *_b_info; \ 1201 if (_e_base == NULL) { \ 1202 SHR_ERR_EXIT(SHR_E_INTERNAL); \ 1203 } \ 1204 _b_info = _e_base + _hash_off; \ 1205 _blk_id = _b_info->blk_id; \ 1206 if (_blk_id == BCM_FIELD_HA_BLK_ID_INVALID) { \ 1207 _oper = NULL; \ 1208 } else { \ 1209 _blk_off = _b_info->blk_offset; \ 1210 FP_STAGE_PRESEL_OPER_BLK_TYPE(_u, _stage, _blk_type); \ 1211 _ptr = FP_HA_BLK_HDR_PTR(unit, _blk_id); \ 1212 _blk_hdr = (bcmi_field_ha_blk_hdr_t *)_ptr; \ 1213 if (_blk_hdr->blk_type != _blk_type) { \ 1214 SHR_ERR_EXIT(SHR_E_INTERNAL); \ 1215 } \ 1216 _oper = (bcmi_field_ha_presel_oper_t *) (_ptr + _blk_off); \ 1217 } \ 1218 } 1219 1220 #define FP_HA_PRESEL_OPER_NEXT(_u, _oper, _oper_next) \ 1221 { \ 1222 if (_oper->next.blk_id != BCM_FIELD_HA_BLK_ID_INVALID) { \ 1223 _oper_next = (bcmi_field_ha_presel_oper_t *) \ 1224 (FP_HA_BLK_HDR_PTR(_u, _oper->next.blk_id) + \ 1225 _oper->next.blk_offset); \ 1226 } else { \ 1227 _oper_next = NULL; \ 1228 } \ 1229 } 1230 1231 1232 #define FP_HINT_ENTRY_OPER_FIRST(_u, blk_id, blk_off, _oper_first) \ 1233 { \ 1234 if (blk_id != BCM_FIELD_HA_BLK_ID_INVALID) { \ 1235 _oper_first = (bcmi_field_ha_hint_entry_t *) \ 1236 (FP_HA_BLK_HDR_PTR(_u, blk_id) + blk_off); \ 1237 } else { \ 1238 _oper_first = NULL; \ 1239 } \ 1240 } 1241 1242 #define FP_HINT_ENTRY_OPER_NEXT(_u, _oper, _oper_next) \ 1243 { \ 1244 if (_oper->next.blk_id != BCM_FIELD_HA_BLK_ID_INVALID) { \ 1245 _oper_next = (bcmi_field_ha_hint_entry_t *) \ 1246 (FP_HA_BLK_HDR_PTR(_u, _oper->next.blk_id) + \ 1247 _oper->next.blk_offset); \ 1248 } else { \ 1249 _oper_next = NULL; \ 1250 } \ 1251 } 1252 1253 1254 #define FP_HA_BLK_ID_DEALLOCATE(_u, _blk_id) \ 1255 { \ 1256 void *_ptr; \ 1257 if (_blk_id == BCM_FIELD_HA_BLK_ID_INVALID) { \ 1258 SHR_IF_ERR_VERBOSE_EXIT(SHR_E_INTERNAL); \ 1259 } \ 1260 _ptr = FP_HA_BLK_HDR_PTR(_u, _blk_id); \ 1261 if (_ptr == NULL) { \ 1262 SHR_IF_ERR_VERBOSE_EXIT(SHR_E_INTERNAL); \ 1263 } \ 1264 SHR_IF_ERR_VERBOSE_EXIT \ 1265 (bcmi_ltsw_ha_mem_free(_u, _ptr)); \ 1266 FP_HA_BLK_HDR_PTR(unit, blk_id) = NULL; \ 1267 } 1268 1269 1270 extern int 1271 bcmint_field_ha_blk_element_acquire( 1272 int unit, 1273 bcmi_field_ha_blk_type_t blk_type, 1274 void **ha_element, 1275 uint8_t *ha_blk_id, 1276 uint32_t *ha_blk_offset); 1277 1278 extern int 1279 bcmint_field_ha_blk_element_release( 1280 int unit, 1281 uint8_t blk_id, 1282 uint32_t blk_offset, 1283 bcmi_field_ha_blk_type_t blk_type); 1284 extern int 1285 bcmint_field_ha_init(int unit, bool warm); 1286 extern int 1287 bcmint_field_ha_cleanup(int unit, bool warm); 1288 1289 #endif /* BCMI_LTSW_FIELD_HA_H */