keygen_qual_cfg.c (37314B)
1 /* 2 * This license is set out in https://raw.githubusercontent.com/Broadcom-Network-Switching-Software/OpenBCM/master/Legal/LICENSE file. 3 * 4 * Copyright 2007-2019 Broadcom Inc. All rights reserved. 5 */ 6 #include <bcm_int/esw/keygen_md.h> 7 8 STATIC int 9 bcmi_keygen_qual_cfg_info_free(int unit, 10 bcmi_keygen_qual_cfg_info_t **qual_cfg_info) 11 { 12 bcm_field_qualify_t qual_id; 13 14 BCMI_KEYGEN_FUNC_ENTER(unit); 15 16 if (qual_cfg_info) { 17 for (qual_id = 0; qual_id < BCM_FIELD_QUALIFY_MAX; qual_id++) { 18 if (qual_cfg_info[qual_id]) { 19 BCMI_KEYGEN_FREE(qual_cfg_info[qual_id]->qual_cfg_arr); 20 BCMI_KEYGEN_FREE(qual_cfg_info[qual_id]); 21 } 22 } 23 } 24 25 BCMI_KEYGEN_FUNC_EXIT(); 26 } 27 28 int 29 bcmi_keygen_qual_cfg_info_db_free(int unit, 30 bcmi_keygen_qual_cfg_info_db_t *qual_cfg_info_db) 31 { 32 bcmi_keygen_qual_cfg_info_t **qual_cfg_info = NULL; 33 34 BCMI_KEYGEN_FUNC_ENTER(unit); 35 36 BCMI_KEYGEN_NULL_CHECK(qual_cfg_info_db, BCM_E_NONE); 37 38 /* Free bus qids sec_cfg memory. */ 39 qual_cfg_info = qual_cfg_info_db->qual_cfg_info; 40 bcmi_keygen_qual_cfg_info_free(unit, qual_cfg_info); 41 42 exit: 43 BCMI_KEYGEN_FUNC_EXIT(); 44 } 45 46 STATIC int 47 bcmi_keygen_md_free(int unit, bcmi_keygen_cfg_t *keygen_cfg, bcmi_keygen_md_t *keygen_md) 48 { 49 uint8 level = 0; 50 51 BCMI_KEYGEN_FUNC_ENTER(unit); 52 53 BCMI_KEYGEN_NULL_CHECK(keygen_md, BCM_E_NONE); 54 BCMI_KEYGEN_NULL_CHECK(keygen_cfg, BCM_E_NONE); 55 56 BCMI_KEYGEN_FREE(keygen_md->qual_cfg_id_arr); 57 BCMI_KEYGEN_FREE(keygen_md->pmux_info); 58 59 (void)bcmi_keygen_qual_cfg_info_free(unit, keygen_md->qual_cfg_info); 60 for (level = 0; level < BCMI_KEYGEN_EXT_LEVEL_COUNT; level++) { 61 if (keygen_md->qual_cfg_info_db[level] == NULL) { 62 continue; 63 } 64 (void)bcmi_keygen_qual_cfg_info_db_free(unit, 65 keygen_md->qual_cfg_info_db[level]); 66 BCMI_KEYGEN_FREE(keygen_md->qual_cfg_info_db[level]); 67 } 68 69 if (keygen_md->ext_cfg_db != NULL) { 70 BCMI_KEYGEN_IF_ERR_EXIT 71 (bcmi_keygen_ext_cfg_db_free(unit, keygen_md->ext_cfg_db)); 72 } 73 74 exit: 75 BCMI_KEYGEN_FUNC_EXIT(); 76 } 77 78 STATIC int 79 bcmi_keygen_qual_cfg_is_valid(int unit, 80 bcm_field_qualify_t qual_id, 81 bcmi_keygen_cfg_t *keygen_cfg, 82 bcmi_keygen_qual_cfg_t *qual_cfg, 83 uint16 qual_cfg_max_size, 84 uint8 *qual_cfg_is_valid) 85 { 86 uint8 idx = 0; 87 uint8 qual_cfg_chunk_id = 0; 88 uint16 bit = 0; 89 uint16 start_bit = 0; 90 uint16 end_bit = 0; 91 uint16 width = 0; 92 uint32 *qual_bitmap = NULL; 93 uint32 qual_bitmap1[BCMI_KEYGEN_QUAL_BITMAP_MAX_WORDS] = {0}; 94 uint32 qual_bitmap2[BCMI_KEYGEN_QUAL_BITMAP_MAX_WORDS] = {0}; 95 96 BCMI_KEYGEN_FUNC_ENTER(unit); 97 98 BCMI_KEYGEN_NULL_CHECK(keygen_cfg, BCM_E_PARAM); 99 BCMI_KEYGEN_NULL_CHECK(qual_cfg, BCM_E_PARAM); 100 BCMI_KEYGEN_NULL_CHECK(qual_cfg_is_valid, BCM_E_PARAM); 101 102 *qual_cfg_is_valid = 0; 103 104 if (keygen_cfg->mode == BCMI_KEYGEN_MODE_SINGLE) { 105 if (SHR_BITGET(qual_cfg->qual_flags.w, 106 BCMI_KEYGEN_QUAL_FLAGS_NOT_IN_SINGLE)) { 107 BCMI_KEYGEN_RETURN_VAL_EXIT(BCM_E_NONE); 108 } 109 } 110 111 for (idx = 0; idx < keygen_cfg->qual_info_count; idx++) { 112 if (keygen_cfg->qual_info_arr[idx].qual_id == qual_id && 113 keygen_cfg->qual_info_arr[idx].partial == TRUE) { 114 qual_bitmap = keygen_cfg->qual_info_arr[idx].bitmap; 115 break; 116 } 117 } 118 119 if (qual_bitmap == NULL) { 120 sal_memset(qual_bitmap2, 0, sizeof(qual_bitmap2)); 121 for (bit = 0; bit < qual_cfg_max_size; bit++) { 122 SHR_BITSET(qual_bitmap2, bit); 123 } 124 qual_bitmap = qual_bitmap2; 125 } 126 127 start_bit = 0; 128 end_bit = 0; 129 width = 0; 130 sal_memset(qual_bitmap1, 0, sizeof(qual_bitmap1)); 131 for (qual_cfg_chunk_id = 0; 132 qual_cfg_chunk_id < qual_cfg->num_chunks; 133 qual_cfg_chunk_id++) { 134 start_bit += width; 135 width = qual_cfg->e_params[qual_cfg_chunk_id].width; 136 end_bit += width; 137 for (bit = start_bit; bit < end_bit; bit++) { 138 SHR_BITSET(qual_bitmap1, bit); 139 } 140 } 141 142 *qual_cfg_is_valid = TRUE; 143 SHR_BIT_ITER(qual_bitmap, qual_cfg_max_size - 1, bit) { 144 if (!SHR_BITGET(qual_bitmap1, bit)) { 145 *qual_cfg_is_valid = FALSE; 146 break; 147 } 148 } 149 150 exit: 151 BCMI_KEYGEN_FUNC_EXIT(); 152 } 153 154 STATIC int 155 bcmi_keygen_qual_cfg_info_alloc(int unit, 156 bcmi_keygen_cfg_t *keygen_cfg, 157 bcmi_keygen_md_t *keygen_md) 158 { 159 uint8 qual_cfg_is_valid = FALSE; 160 uint8 qual_cfg_count = 0; 161 uint8 valid_qual_cfg_count = 0; 162 uint8 qual_cfg_id = 0; 163 uint16 idx = 0; 164 uint16 qual_cfg_max_size = 0; 165 uint32 qual_cfg_id_bmp = 0; 166 bcm_field_qualify_t qual_id; 167 bcmi_keygen_qual_cfg_t *qual_cfg = NULL; 168 bcmi_keygen_qual_cfg_t *qual_cfg_arr = NULL; 169 bcmi_keygen_qual_cfg_info_t **qual_cfg_info1 = NULL; 170 bcmi_keygen_qual_cfg_info_t *qual_cfg_info2 = NULL; 171 172 BCMI_KEYGEN_FUNC_ENTER(unit); 173 174 BCMI_KEYGEN_NULL_CHECK(keygen_md, BCM_E_PARAM); 175 BCMI_KEYGEN_NULL_CHECK(keygen_cfg, BCM_E_PARAM); 176 177 qual_cfg_info1 = keygen_cfg->qual_cfg_info_db->qual_cfg_info; 178 179 BCMI_KEYGEN_IF_ERR_EXIT((qual_cfg_info1 == NULL) ? BCM_E_INTERNAL : BCM_E_NONE); 180 181 for (idx = 0; idx < keygen_cfg->qual_info_count; idx++) { 182 183 qual_id = keygen_cfg->qual_info_arr[idx].qual_id; 184 185 if (qual_cfg_info1[qual_id] == NULL) { 186 continue; 187 } 188 189 BCMI_KEYGEN_IF_ERR_VERBOSE_EXIT( 190 bcmi_keygen_qual_cfg_max_size_get(unit, 191 keygen_cfg, 192 qual_id, 193 &qual_cfg_max_size)); 194 195 valid_qual_cfg_count = 0; 196 qual_cfg_id_bmp = 0; 197 for (qual_cfg_id = 0; 198 qual_cfg_id < qual_cfg_info1[qual_id]->num_qual_cfg; 199 qual_cfg_id++) { 200 201 qual_cfg = &(qual_cfg_info1[qual_id]->qual_cfg_arr[qual_cfg_id]); 202 qual_cfg_is_valid = FALSE; 203 BCMI_KEYGEN_IF_ERR_VERBOSE_EXIT( 204 bcmi_keygen_qual_cfg_is_valid(unit, 205 qual_id, 206 keygen_cfg, 207 qual_cfg, 208 qual_cfg_max_size, 209 &qual_cfg_is_valid)); 210 211 if (qual_cfg_is_valid == TRUE) { 212 SHR_BITSET(&qual_cfg_id_bmp, qual_cfg_id); 213 valid_qual_cfg_count++; 214 } 215 } 216 217 BCMI_KEYGEN_IF_ERR_VERBOSE_EXIT( 218 (valid_qual_cfg_count == 0) ? BCM_E_CONFIG : BCM_E_NONE); 219 220 qual_cfg_info2 = NULL; 221 BCMI_KEYGEN_ALLOC(qual_cfg_info2, 222 sizeof(bcmi_keygen_qual_cfg_info_t), 223 "BCMI_KEYGEN: Group Qual Config Information"); 224 keygen_md->qual_cfg_info[qual_id] = qual_cfg_info2; 225 226 qual_cfg_arr = NULL; 227 BCMI_KEYGEN_ALLOC(qual_cfg_arr, 228 valid_qual_cfg_count * sizeof(bcmi_keygen_qual_cfg_t), 229 "BCMI_KEYGEN:Group Qual Configuration array"); 230 qual_cfg_info2->num_qual_cfg = valid_qual_cfg_count; 231 qual_cfg_info2->qual_cfg_arr = qual_cfg_arr; 232 233 qual_cfg_count = 0; 234 for (qual_cfg_id = 0; 235 qual_cfg_id < qual_cfg_info1[qual_id]->num_qual_cfg; 236 qual_cfg_id++) { 237 238 qual_cfg = 239 &(qual_cfg_info1[qual_id]->qual_cfg_arr[qual_cfg_id]); 240 241 if (SHR_BITGET(&qual_cfg_id_bmp, qual_cfg_id)) { 242 qual_cfg = 243 &(qual_cfg_info1[qual_id]->qual_cfg_arr[qual_cfg_id]); 244 sal_memcpy(&(qual_cfg_arr[qual_cfg_count]), 245 qual_cfg, sizeof(bcmi_keygen_qual_cfg_t)); 246 qual_cfg_count++; 247 } 248 } 249 } 250 251 exit: 252 if (BCMI_KEYGEN_FUNC_ERR()) { 253 (void)bcmi_keygen_qual_cfg_info_free(unit, keygen_md->qual_cfg_info); 254 } 255 256 BCMI_KEYGEN_FUNC_EXIT(); 257 } 258 259 STATIC int 260 bcmi_keygen_qual_cfg_info_db_alloc(int unit, 261 bcmi_keygen_cfg_t *keygen_cfg, 262 bcmi_keygen_md_t *keygen_md) 263 { 264 uint8 level = 0; 265 uint16 idx = 0; 266 bcm_field_qualify_t qual_id; 267 bcmi_keygen_qual_cfg_t *qual_cfg_arr = NULL; 268 bcmi_keygen_qual_cfg_info_t *qual_cfg_info = NULL; 269 270 BCMI_KEYGEN_FUNC_ENTER(unit); 271 272 BCMI_KEYGEN_NULL_CHECK(keygen_md, BCM_E_PARAM); 273 BCMI_KEYGEN_NULL_CHECK(keygen_cfg, BCM_E_PARAM); 274 275 for (level = 0; level < BCMI_KEYGEN_EXT_LEVEL_COUNT; level++) { 276 keygen_md->qual_cfg_info_db[level] = NULL; 277 } 278 279 BCMI_KEYGEN_ALLOC(keygen_md->qual_cfg_info_db[0], 280 sizeof(bcmi_keygen_qual_cfg_info_db_t), 281 "BCMI_KEYGEN:Group Qualifer Config Information DB"); 282 283 for (idx = 0; idx < keygen_cfg->qual_info_count; idx++) { 284 qual_id = keygen_cfg->qual_info_arr[idx].qual_id; 285 if (keygen_cfg->qual_cfg_info_db->qual_cfg_info[qual_id] == NULL) { 286 continue; 287 } 288 BCMI_KEYGEN_ALLOC(qual_cfg_info, 289 sizeof(bcmi_keygen_qual_cfg_info_t), 290 "BCMI_KEYGEN:Group Qual Config Information"); 291 keygen_md->qual_cfg_info_db[0]->qual_cfg_info[qual_id] = qual_cfg_info; 292 BCMI_KEYGEN_ALLOC(qual_cfg_arr, 293 sizeof(bcmi_keygen_qual_cfg_t), 294 "BCMI_KEYGEN:Group Qual Config"); 295 qual_cfg_info->qual_cfg_arr = qual_cfg_arr; 296 qual_cfg_info->num_qual_cfg = 1; 297 qual_cfg_info = NULL; 298 qual_cfg_arr = NULL; 299 } 300 301 exit: 302 if (BCMI_KEYGEN_FUNC_ERR()) { 303 (void)bcmi_keygen_qual_cfg_info_db_free(unit, 304 keygen_md->qual_cfg_info_db[0]); 305 BCMI_KEYGEN_FREE(keygen_md->qual_cfg_info_db[0]); 306 } 307 BCMI_KEYGEN_FUNC_EXIT(); 308 } 309 310 STATIC int 311 bcmi_keygen_qual_cfg_id_array_alloc(int unit, 312 bcmi_keygen_cfg_t *keygen_cfg, 313 bcmi_keygen_md_t *keygen_md) 314 { 315 uint16 idx = 0; 316 bcm_field_qualify_t qual_id; 317 bcmi_keygen_qual_cfg_t *qual_cfg = NULL; 318 319 BCMI_KEYGEN_FUNC_ENTER(unit); 320 321 BCMI_KEYGEN_NULL_CHECK(keygen_md, BCM_E_PARAM); 322 BCMI_KEYGEN_NULL_CHECK(keygen_cfg, BCM_E_PARAM); 323 324 BCMI_KEYGEN_ALLOC(keygen_md->qual_cfg_id_arr, 325 sizeof(uint8) * keygen_cfg->qual_info_count, 326 "Group Qual Config ID Tracker"); 327 328 keygen_md->qual_cfg_combinations = 1; 329 for (idx = 0; idx < keygen_cfg->qual_info_count; idx++) { 330 qual_id = keygen_cfg->qual_info_arr[idx].qual_id; 331 if (keygen_md->qual_cfg_info[qual_id] == NULL) { 332 continue; 333 } 334 qual_cfg = 335 &(keygen_md->qual_cfg_info[qual_id]->qual_cfg_arr[0]); 336 if (SHR_BITGET(qual_cfg->qual_flags.w, 337 BCMI_KEYGEN_QUAL_FLAGS_PMUX)) { 338 continue; 339 } 340 keygen_md->qual_cfg_combinations *= 341 keygen_md->qual_cfg_info[qual_id]->num_qual_cfg; 342 } 343 344 exit: 345 BCMI_KEYGEN_FUNC_EXIT(); 346 } 347 348 STATIC int 349 bcmi_keygen_acl_attrs_update(int unit, 350 bcmi_keygen_cfg_t *keygen_cfg, 351 bcmi_keygen_md_t *keygen_md) 352 { 353 uint8 part = 0; 354 uint16 idx = 0; 355 356 BCMI_KEYGEN_FUNC_ENTER(unit); 357 358 BCMI_KEYGEN_NULL_CHECK(keygen_md, BCM_E_PARAM); 359 BCMI_KEYGEN_NULL_CHECK(keygen_cfg, BCM_E_PARAM); 360 361 if (keygen_cfg->ext_ctrl_sel_info == NULL || 362 keygen_cfg->ext_ctrl_sel_info_count == 0) { 363 BCMI_KEYGEN_RETURN_VAL_EXIT(BCM_E_NONE); 364 } 365 366 for (idx = 0; idx < keygen_cfg->ext_ctrl_sel_info_count; idx++) { 367 part = keygen_cfg->ext_ctrl_sel_info[idx].part; 368 if (keygen_cfg->ext_ctrl_sel_info[idx].ctrl_sel == 369 BCMI_KEYGEN_EXT_CTRL_SEL_IPBM_PRESENT) { 370 SHR_BITSET(keygen_md->acl_attrs[part].w, 371 BCMI_KEYGEN_ACL_ATTR_PMUX_IPBM); 372 } 373 if (keygen_cfg->ext_ctrl_sel_info[idx].ctrl_sel == 374 BCMI_KEYGEN_EXT_CTRL_SEL_PMUX) { 375 switch (keygen_cfg->ext_ctrl_sel_info[idx].ctrl_sel_val) { 376 case 0: 377 SHR_BITSET(keygen_md->acl_attrs[part].w, 378 BCMI_KEYGEN_ACL_ATTR_PMUX_DROP); 379 break; 380 case 1: 381 SHR_BITSET(keygen_md->acl_attrs[part].w, 382 BCMI_KEYGEN_ACL_ATTR_PMUX_NAT_NEEDED); 383 break; 384 case 2: 385 SHR_BITSET(keygen_md->acl_attrs[part].w, 386 BCMI_KEYGEN_ACL_ATTR_PMUX_NAT_DST_REALM_ID); 387 break; 388 case 3: 389 SHR_BITSET(keygen_md->acl_attrs[part].w, 390 BCMI_KEYGEN_ACL_ATTR_PMUX_EM_FIRST_LOOKUP_HIT); 391 SHR_BITSET(keygen_md->acl_attrs[part].w, 392 BCMI_KEYGEN_ACL_ATTR_PMUX_EM_SECOND_LOOKUP_HIT); 393 break; 394 case 4: 395 if (keygen_cfg->mode == BCMI_KEYGEN_MODE_SINGLE) { 396 SHR_BITSET(keygen_md->acl_attrs[part].w, 397 BCMI_KEYGEN_ACL_ATTR_PMUX_SRC_DST_CONT_MSB_HM); 398 } else { 399 SHR_BITSET(keygen_md->acl_attrs[part].w, 400 BCMI_KEYGEN_ACL_ATTR_PMUX_SRC_DST_CONT_MSB); 401 } 402 break; 403 case 12: 404 SHR_BITSET(keygen_md->acl_attrs[part].w, 405 BCMI_KEYGEN_ACL_ATTR_PMUX_SRC_DST_CONT_0_HM); 406 break; 407 case 14: 408 SHR_BITSET(keygen_md->acl_attrs[part].w, 409 BCMI_KEYGEN_ACL_ATTR_PMUX_SRC_DST_CONT_0); 410 break; 411 case 11: 412 SHR_BITSET(keygen_md->acl_attrs[part].w, 413 BCMI_KEYGEN_ACL_ATTR_PMUX_SRC_DST_CONT_1_HM); 414 break; 415 case 13: 416 SHR_BITSET(keygen_md->acl_attrs[part].w, 417 BCMI_KEYGEN_ACL_ATTR_PMUX_SRC_DST_CONT_1); 418 break; 419 case 8: 420 SHR_BITSET(keygen_md->acl_attrs[part].w, 421 BCMI_KEYGEN_ACL_ATTR_PMUX_EM_FIRST_LOOKUP_CLASSID_BITS_0_3); 422 break; 423 case 9: 424 SHR_BITSET(keygen_md->acl_attrs[part].w, 425 BCMI_KEYGEN_ACL_ATTR_PMUX_EM_FIRST_LOOKUP_CLASSID_BITS_4_7); 426 break; 427 case 10: 428 SHR_BITSET(keygen_md->acl_attrs[part].w, 429 BCMI_KEYGEN_ACL_ATTR_PMUX_EM_FIRST_LOOKUP_CLASSID_BITS_8_11); 430 break; 431 case 5: 432 SHR_BITSET(keygen_md->acl_attrs[part].w, 433 BCMI_KEYGEN_ACL_ATTR_PMUX_EM_SECOND_LOOKUP_CLASSID_BITS_0_3); 434 break; 435 case 6: 436 SHR_BITSET(keygen_md->acl_attrs[part].w, 437 BCMI_KEYGEN_ACL_ATTR_PMUX_EM_SECOND_LOOKUP_CLASSID_BITS_4_7); 438 break; 439 case 7: 440 SHR_BITSET(keygen_md->acl_attrs[part].w, 441 BCMI_KEYGEN_ACL_ATTR_PMUX_EM_SECOND_LOOKUP_CLASSID_BITS_8_11); 442 break; 443 default: 444 BCMI_KEYGEN_IF_ERR_EXIT(BCM_E_INTERNAL); 445 } 446 } 447 } 448 449 exit: 450 BCMI_KEYGEN_FUNC_EXIT(); 451 } 452 453 STATIC int 454 bcmi_keygen_acl_attrs_init(int unit, 455 bcmi_keygen_cfg_t *keygen_cfg, 456 bcmi_keygen_md_t *keygen_md) 457 { 458 uint8 idx = 0; 459 uint8 chunk = 0; 460 bcmi_keygen_ext_section_t pmux_section; 461 bcmi_keygen_qual_cfg_t *qual_cfg = NULL; 462 bcmi_keygen_pmux_info_t *pmux_info = NULL; 463 464 BCMI_KEYGEN_FUNC_ENTER(unit); 465 466 BCMI_KEYGEN_NULL_CHECK(keygen_md, BCM_E_PARAM); 467 BCMI_KEYGEN_NULL_CHECK(keygen_cfg, BCM_E_PARAM); 468 469 if ((keygen_cfg->flags & BCMI_KEYGEN_CFG_FLAGS_QSET_UPDATE)) { 470 BCMI_KEYGEN_IF_ERR_VERBOSE_EXIT( 471 bcmi_keygen_acl_attrs_update(unit, keygen_cfg, keygen_md)); 472 } 473 474 for (idx = 0; idx < keygen_md->num_pmux_qual; idx++) { 475 pmux_info = &(keygen_md->pmux_info[idx]); 476 qual_cfg = pmux_info->pmux_qual_cfg; 477 for (chunk = 0; chunk < qual_cfg->num_chunks; chunk++) { 478 pmux_section = qual_cfg->e_params[chunk].section; 479 if (pmux_section == 480 BCMI_KEYGEN_EXT_SECTION_IPBM) { 481 SHR_BITSET(keygen_md->acl_attrs[pmux_info->pmux_part].w, 482 BCMI_KEYGEN_ACL_ATTR_PMUX_IPBM); 483 } else if (pmux_section == 484 BCMI_KEYGEN_EXT_SECTION_DROP) { 485 SHR_BITSET(keygen_md->acl_attrs[pmux_info->pmux_part].w, 486 BCMI_KEYGEN_ACL_ATTR_PMUX_DROP); 487 } else if (pmux_section == 488 BCMI_KEYGEN_EXT_SECTION_NAT_NEEDED) { 489 SHR_BITSET(keygen_md->acl_attrs[pmux_info->pmux_part].w, 490 BCMI_KEYGEN_ACL_ATTR_PMUX_NAT_NEEDED); 491 } else if (pmux_section == 492 BCMI_KEYGEN_EXT_SECTION_NAT_DST_REALMID) { 493 SHR_BITSET(keygen_md->acl_attrs[pmux_info->pmux_part].w, 494 BCMI_KEYGEN_ACL_ATTR_PMUX_NAT_DST_REALM_ID); 495 } else if (pmux_section == 496 BCMI_KEYGEN_EXT_SECTION_SRC_DST_CONTAINER_0 && 497 keygen_cfg->mode == BCMI_KEYGEN_MODE_SINGLE) { 498 SHR_BITSET(keygen_md->acl_attrs[pmux_info->pmux_part].w, 499 BCMI_KEYGEN_ACL_ATTR_PMUX_SRC_DST_CONT_0_HM); 500 } else if (pmux_section == 501 BCMI_KEYGEN_EXT_SECTION_SRC_DST_CONTAINER_1 && 502 keygen_cfg->mode == BCMI_KEYGEN_MODE_SINGLE) { 503 SHR_BITSET(keygen_md->acl_attrs[pmux_info->pmux_part].w, 504 BCMI_KEYGEN_ACL_ATTR_PMUX_SRC_DST_CONT_1_HM); 505 } else if (pmux_section == 506 BCMI_KEYGEN_EXT_SECTION_SRC_DST_CONTAINERS_MSB && 507 keygen_cfg->mode == BCMI_KEYGEN_MODE_SINGLE) { 508 SHR_BITSET(keygen_md->acl_attrs[pmux_info->pmux_part].w, 509 BCMI_KEYGEN_ACL_ATTR_PMUX_SRC_DST_CONT_MSB_HM); 510 } else if (pmux_section == 511 BCMI_KEYGEN_EXT_SECTION_SRC_DST_CONTAINER_0) { 512 SHR_BITSET(keygen_md->acl_attrs[pmux_info->pmux_part].w, 513 BCMI_KEYGEN_ACL_ATTR_PMUX_SRC_DST_CONT_0); 514 } else if (pmux_section == 515 BCMI_KEYGEN_EXT_SECTION_SRC_DST_CONTAINER_1) { 516 SHR_BITSET(keygen_md->acl_attrs[pmux_info->pmux_part].w, 517 BCMI_KEYGEN_ACL_ATTR_PMUX_SRC_DST_CONT_1); 518 } else if (pmux_section == 519 BCMI_KEYGEN_EXT_SECTION_SRC_DST_CONTAINERS_MSB) { 520 SHR_BITSET(keygen_md->acl_attrs[pmux_info->pmux_part].w, 521 BCMI_KEYGEN_ACL_ATTR_PMUX_SRC_DST_CONT_MSB); 522 } else if (pmux_section == 523 BCMI_KEYGEN_EXT_SECTION_EM_FIRST_LOOKUP_HIT) { 524 SHR_BITSET(keygen_md->acl_attrs[pmux_info->pmux_part].w, 525 BCMI_KEYGEN_ACL_ATTR_PMUX_EM_FIRST_LOOKUP_HIT); 526 } else if (pmux_section == 527 BCMI_KEYGEN_EXT_SECTION_EM_SECOND_LOOKUP_HIT) { 528 SHR_BITSET(keygen_md->acl_attrs[pmux_info->pmux_part].w, 529 BCMI_KEYGEN_ACL_ATTR_PMUX_EM_SECOND_LOOKUP_HIT); 530 } else if (pmux_section == 531 BCMI_KEYGEN_EXT_SECTION_EM_FIRST_LOOKUP_CLASSID_BITS_0_3) { 532 SHR_BITSET(keygen_md->acl_attrs[pmux_info->pmux_part].w, 533 BCMI_KEYGEN_ACL_ATTR_PMUX_EM_FIRST_LOOKUP_CLASSID_BITS_0_3); 534 } else if (pmux_section == 535 BCMI_KEYGEN_EXT_SECTION_EM_FIRST_LOOKUP_CLASSID_BITS_4_7) { 536 SHR_BITSET(keygen_md->acl_attrs[pmux_info->pmux_part].w, 537 BCMI_KEYGEN_ACL_ATTR_PMUX_EM_FIRST_LOOKUP_CLASSID_BITS_4_7); 538 } else if (pmux_section == 539 BCMI_KEYGEN_EXT_SECTION_EM_FIRST_LOOKUP_CLASSID_BITS_8_11) { 540 SHR_BITSET(keygen_md->acl_attrs[pmux_info->pmux_part].w, 541 BCMI_KEYGEN_ACL_ATTR_PMUX_EM_FIRST_LOOKUP_CLASSID_BITS_8_11); 542 } else if (pmux_section == 543 BCMI_KEYGEN_EXT_SECTION_EM_SECOND_LOOKUP_CLASSID_BITS_0_3) { 544 SHR_BITSET(keygen_md->acl_attrs[pmux_info->pmux_part].w, 545 BCMI_KEYGEN_ACL_ATTR_PMUX_EM_SECOND_LOOKUP_CLASSID_BITS_0_3); 546 } else if (pmux_section == 547 BCMI_KEYGEN_EXT_SECTION_EM_SECOND_LOOKUP_CLASSID_BITS_4_7) { 548 SHR_BITSET(keygen_md->acl_attrs[pmux_info->pmux_part].w, 549 BCMI_KEYGEN_ACL_ATTR_PMUX_EM_SECOND_LOOKUP_CLASSID_BITS_4_7); 550 } else if (pmux_section == 551 BCMI_KEYGEN_EXT_SECTION_EM_SECOND_LOOKUP_CLASSID_BITS_8_11) { 552 SHR_BITSET(keygen_md->acl_attrs[pmux_info->pmux_part].w, 553 BCMI_KEYGEN_ACL_ATTR_PMUX_EM_SECOND_LOOKUP_CLASSID_BITS_8_11); 554 } else if (pmux_section == 555 BCMI_KEYGEN_EXT_SECTION_DST_CONTAINER_A) { 556 SHR_BITSET(keygen_md->acl_attrs[pmux_info->pmux_part].w, 557 BCMI_KEYGEN_ACL_ATTR_PMUX_DST_CONTAINER_A); 558 } else if (pmux_section == 559 BCMI_KEYGEN_EXT_SECTION_DST_CONTAINER_B) { 560 SHR_BITSET(keygen_md->acl_attrs[pmux_info->pmux_part].w, 561 BCMI_KEYGEN_ACL_ATTR_PMUX_DST_CONTAINER_B); 562 } else if (pmux_section == 563 BCMI_KEYGEN_EXT_SECTION_LOOKUP_STATUS_VECTOR_BITS_0_3) { 564 SHR_BITSET(keygen_md->acl_attrs[pmux_info->pmux_part].w, 565 BCMI_KEYGEN_ACL_ATTR_PMUX_LOOKUP_STATUS_VECTOR_BITS_0_3); 566 } else if (pmux_section == 567 BCMI_KEYGEN_EXT_SECTION_LOOKUP_STATUS_VECTOR_BITS_4_7) { 568 SHR_BITSET(keygen_md->acl_attrs[pmux_info->pmux_part].w, 569 BCMI_KEYGEN_ACL_ATTR_PMUX_LOOKUP_STATUS_VECTOR_BITS_4_7); 570 } else if (pmux_section == 571 BCMI_KEYGEN_EXT_SECTION_PKT_RESOLUTION) { 572 SHR_BITSET(keygen_md->acl_attrs[pmux_info->pmux_part].w, 573 BCMI_KEYGEN_ACL_ATTR_PMUX_PKT_RESOLUTION); 574 } else if (pmux_section == 575 BCMI_KEYGEN_EXT_SECTION_CLASS_ID_C) { 576 SHR_BITSET(keygen_md->acl_attrs[pmux_info->pmux_part].w, 577 BCMI_KEYGEN_ACL_ATTR_PMUX_CLASS_ID_C); 578 } else if (pmux_section == 579 BCMI_KEYGEN_EXT_SECTION_CLASS_ID_D) { 580 SHR_BITSET(keygen_md->acl_attrs[pmux_info->pmux_part].w, 581 BCMI_KEYGEN_ACL_ATTR_PMUX_CLASS_ID_D); 582 } else if (pmux_section == 583 BCMI_KEYGEN_EXT_SECTION_INT_PRI) { 584 SHR_BITSET(keygen_md->acl_attrs[pmux_info->pmux_part].w, 585 BCMI_KEYGEN_ACL_ATTR_PMUX_INT_PRI); 586 } else if (pmux_section == 587 BCMI_KEYGEN_EXT_SECTION_IFP_DROP_VECTOR) { 588 SHR_BITSET(keygen_md->acl_attrs[pmux_info->pmux_part].w, 589 BCMI_KEYGEN_ACL_ATTR_PMUX_IFP_DROP_VECTOR); 590 } else if (pmux_section == 591 BCMI_KEYGEN_EXT_SECTION_MH_OPCODE) { 592 SHR_BITSET(keygen_md->acl_attrs[pmux_info->pmux_part].w, 593 BCMI_KEYGEN_ACL_ATTR_PMUX_MH_OPCODE); 594 } else if (pmux_section == 595 BCMI_KEYGEN_EXT_SECTION_LTID) { 596 SHR_BITSET(keygen_md->acl_attrs[pmux_info->pmux_part].w, 597 BCMI_KEYGEN_ACL_ATTR_PMUX_LTID); 598 } else { 599 BCMI_KEYGEN_IF_ERR_EXIT(BCM_E_INTERNAL); 600 } 601 continue; 602 } 603 } 604 605 if (keygen_cfg->mode == BCMI_KEYGEN_MODE_SINGLE) { 606 SHR_BITSET(keygen_md->acl_attrs[0].w, BCMI_KEYGEN_ACL_ATTR_MODE_HALF); 607 } 608 609 if (keygen_cfg->mode == BCMI_KEYGEN_MODE_SINGLE_ASET_WIDE) { 610 SHR_BITSET(keygen_md->acl_attrs[0].w, 611 BCMI_KEYGEN_ACL_ATTR_MODE_SINGLE_ASET_WIDE); 612 } 613 614 exit: 615 BCMI_KEYGEN_FUNC_EXIT(); 616 } 617 618 STATIC int 619 bcmi_keygen_md_alloc(int unit, 620 bcmi_keygen_cfg_t *keygen_cfg, 621 bcmi_keygen_md_t **keygen_md) 622 { 623 uint8 part = 0; 624 625 BCMI_KEYGEN_FUNC_ENTER(unit); 626 627 BCMI_KEYGEN_NULL_CHECK(keygen_md, BCM_E_PARAM); 628 BCMI_KEYGEN_NULL_CHECK(keygen_cfg, BCM_E_PARAM); 629 630 BCMI_KEYGEN_ALLOC(*keygen_md, sizeof(bcmi_keygen_md_t), "Group MetaData"); 631 632 BCMI_KEYGEN_IF_ERR_VERBOSE_EXIT 633 (bcmi_keygen_qual_cfg_info_alloc(unit, keygen_cfg, *keygen_md)); 634 635 BCMI_KEYGEN_IF_ERR_VERBOSE_EXIT 636 (bcmi_keygen_qual_cfg_info_db_alloc(unit, keygen_cfg, *keygen_md)); 637 638 BCMI_KEYGEN_IF_ERR_VERBOSE_EXIT 639 (bcmi_keygen_ext_cfg_alloc(unit, keygen_cfg, *keygen_md)); 640 641 BCMI_KEYGEN_IF_ERR_VERBOSE_EXIT 642 (bcmi_keygen_qual_cfg_id_array_alloc(unit, keygen_cfg, *keygen_md)); 643 644 BCMI_KEYGEN_IF_ERR_VERBOSE_EXIT 645 (bcmi_keygen_ext_sections_get(unit, keygen_cfg, *keygen_md)); 646 647 BCMI_KEYGEN_IF_ERR_VERBOSE_EXIT 648 (bcmi_keygen_pmux_process(unit, keygen_cfg, *keygen_md)); 649 650 BCMI_KEYGEN_IF_ERR_VERBOSE_EXIT 651 (bcmi_keygen_acl_attrs_init(unit, keygen_cfg, *keygen_md)); 652 653 BCMI_KEYGEN_IF_ERR_VERBOSE_EXIT 654 (bcmi_keygen_ext_section_gran_info_init(unit, *keygen_md)); 655 656 BCMI_KEYGEN_IF_ERR_VERBOSE_EXIT 657 (bcmi_keygen_ext_section_drain_bits_update(unit, *keygen_md)); 658 659 for (part = 0; part < keygen_cfg->num_parts; part++) { 660 BCMI_KEYGEN_IF_ERR_VERBOSE_EXIT 661 (bcmi_keygen_ext_codes_init(unit, &((*keygen_md)->ext_codes[part]))); 662 } 663 664 exit: 665 BCMI_KEYGEN_FUNC_EXIT(); 666 } 667 668 STATIC int 669 bcmi_keygen_cfg_md_process(int unit, 670 bcmi_keygen_cfg_t *keygen_cfg, 671 bcmi_keygen_oper_t *keygen_oper, 672 bcmi_keygen_md_t *keygen_md) 673 { 674 uint8 *qual_cfg_id_arr = NULL; 675 uint16 idx = 0; 676 uint16 first_non_pmux_qual_idx = 0; 677 uint8 all_pmux_qset = TRUE; 678 uint32 qual_cfg_combinations = 0; 679 uint32 qual_cfg_combinations_tried = 0; 680 bcm_field_qualify_t qual_id = bcmFieldQualifyCount; 681 bcmi_keygen_qual_cfg_t *qual_cfg1 = NULL; 682 bcmi_keygen_qual_cfg_t *qual_cfg2 = NULL; 683 bcmi_keygen_qual_cfg_info_t **qual_cfg_info = NULL; 684 685 BCMI_KEYGEN_FUNC_ENTER(unit); 686 687 BCMI_KEYGEN_NULL_CHECK(keygen_md, BCM_E_PARAM); 688 BCMI_KEYGEN_NULL_CHECK(keygen_cfg, BCM_E_PARAM); 689 690 qual_cfg_info = keygen_md->qual_cfg_info; 691 qual_id = keygen_cfg->qual_info_arr[0].qual_id; 692 qual_cfg_id_arr = keygen_md->qual_cfg_id_arr; 693 qual_cfg_combinations = keygen_md->qual_cfg_combinations; 694 695 for (idx = 0; idx < keygen_cfg->qual_info_count; idx++) { 696 qual_id = keygen_cfg->qual_info_arr[idx].qual_id; 697 qual_cfg1 = &(qual_cfg_info[qual_id]->qual_cfg_arr[0]); 698 if (!SHR_BITGET(qual_cfg1->qual_flags.w, 699 BCMI_KEYGEN_QUAL_FLAGS_PMUX)) { 700 first_non_pmux_qual_idx = idx; 701 all_pmux_qset = FALSE; 702 break; 703 } 704 } 705 706 if (all_pmux_qset == TRUE) { 707 BCMI_KEYGEN_RETURN_VAL_EXIT 708 (bcmi_keygen_ext_alloc(unit, 709 keygen_cfg, 710 keygen_oper, 711 keygen_md)); 712 } 713 714 while (TRUE) { 715 _func_rv = 716 bcmi_keygen_ext_alloc(unit, keygen_cfg, keygen_oper, keygen_md); 717 if (BCMI_KEYGEN_FAILURE(_func_rv) && (_func_rv != BCM_E_RESOURCE)) { 718 BCMI_KEYGEN_IF_ERR_VERBOSE_EXIT(_func_rv); 719 } else if (BCMI_KEYGEN_SUCCESS(_func_rv)) { 720 break; 721 } 722 723 qual_cfg_combinations_tried++; 724 725 /* all combinations are tried , but still no success. */ 726 if (qual_cfg_combinations_tried == qual_cfg_combinations) { 727 BCMI_KEYGEN_IF_ERR_VERBOSE_EXIT(_func_rv); 728 } 729 730 /* Identify the next configuration of each qualifer to try with. */ 731 qual_id = keygen_cfg->qual_info_arr[first_non_pmux_qual_idx].qual_id; 732 733 if (qual_cfg_id_arr[first_non_pmux_qual_idx] == 734 qual_cfg_info[qual_id]->num_qual_cfg - 1) { 735 736 qual_cfg_id_arr[first_non_pmux_qual_idx] = 0; 737 738 idx = first_non_pmux_qual_idx + 1; 739 while (idx < keygen_cfg->qual_info_count) { 740 qual_id = keygen_cfg->qual_info_arr[idx].qual_id; 741 qual_cfg2 = &(qual_cfg_info[qual_id]->qual_cfg_arr[0]); 742 if (SHR_BITGET(qual_cfg2->qual_flags.w, 743 BCMI_KEYGEN_QUAL_FLAGS_PMUX)) { 744 idx++; 745 continue; 746 } 747 if (qual_cfg_id_arr[idx] < 748 qual_cfg_info[qual_id]->num_qual_cfg - 1) { 749 qual_cfg_id_arr[idx]++; 750 break; 751 } else { 752 qual_cfg_id_arr[idx] = 0; 753 } 754 idx++; 755 } 756 } else { 757 qual_cfg_id_arr[first_non_pmux_qual_idx]++; 758 } 759 } 760 761 exit: 762 BCMI_KEYGEN_FUNC_EXIT(); 763 } 764 765 int 766 bcmi_keygen_qual_cfg_max_size_get(int unit, 767 bcmi_keygen_cfg_t *keygen_cfg, 768 bcm_field_qualify_t qual_id, 769 uint16 *qual_cfg_max_size) 770 { 771 uint8 qual_cfg_id = 0; 772 uint8 qual_cfg_chunk_id = 0; 773 uint16 qual_cfg_size = 0; 774 bcmi_keygen_qual_cfg_t *qual_cfg = NULL; 775 bcmi_keygen_qual_cfg_info_t *qual_cfg_info = NULL; 776 777 BCMI_KEYGEN_FUNC_ENTER(unit); 778 779 BCMI_KEYGEN_NULL_CHECK(keygen_cfg, BCM_E_PARAM); 780 BCMI_KEYGEN_NULL_CHECK(qual_cfg_max_size, BCM_E_PARAM); 781 782 *qual_cfg_max_size = 0; 783 784 qual_cfg_info = keygen_cfg->qual_cfg_info_db->qual_cfg_info[qual_id]; 785 786 for (qual_cfg_id = 0; 787 qual_cfg_id < qual_cfg_info->num_qual_cfg; 788 qual_cfg_id++) { 789 qual_cfg = &(qual_cfg_info->qual_cfg_arr[qual_cfg_id]); 790 qual_cfg_size = 0; 791 for (qual_cfg_chunk_id = 0; 792 qual_cfg_chunk_id < qual_cfg->num_chunks; 793 qual_cfg_chunk_id++) { 794 qual_cfg_size += qual_cfg->e_params[qual_cfg_chunk_id].width; 795 } 796 797 if (*qual_cfg_max_size < qual_cfg_size) { 798 *qual_cfg_max_size = qual_cfg_size; 799 } 800 } 801 802 exit: 803 BCMI_KEYGEN_FUNC_EXIT(); 804 } 805 806 int 807 bcmi_keygen_keysize_get(int unit, 808 bcmi_keygen_cfg_t *keygen_cfg, 809 uint16 *rkey_size) 810 { 811 int key_size = 0; 812 uint8 chunk = 0; 813 uint16 idx = 0; 814 bcm_field_qualify_t qual_id; 815 bcmi_keygen_qual_cfg_t *qual_cfg = NULL; 816 bcmi_keygen_qual_cfg_info_t *qual_cfg_info = NULL; 817 818 BCMI_KEYGEN_FUNC_ENTER(unit); 819 820 BCMI_KEYGEN_NULL_CHECK(rkey_size, BCM_E_PARAM); 821 BCMI_KEYGEN_NULL_CHECK(keygen_cfg, BCM_E_PARAM); 822 823 *rkey_size = 0; 824 for (idx = 0; idx < keygen_cfg->qual_info_count; idx++) { 825 qual_id = keygen_cfg->qual_info_arr[idx].qual_id; 826 qual_cfg_info = keygen_cfg->qual_cfg_info_db->qual_cfg_info[qual_id]; 827 if (qual_cfg_info == NULL) { 828 continue; 829 } 830 qual_cfg = &(qual_cfg_info->qual_cfg_arr[0]); 831 if (qual_cfg == NULL) { 832 continue; 833 } 834 if (qual_cfg->pri_ctrl_sel != BCMI_KEYGEN_EXT_CTRL_SEL_DISABLE) { 835 continue; 836 } 837 if (SHR_BITGET(qual_cfg->qual_flags.w, BCMI_KEYGEN_QUAL_FLAGS_PMUX)) { 838 continue; 839 } 840 if (keygen_cfg->qual_info_arr[idx].partial == TRUE) { 841 key_size = 0; 842 SHR_BITCOUNT_RANGE(keygen_cfg->qual_info_arr[idx].bitmap, key_size, 843 0, sizeof(uint32) * BCMI_KEYGEN_QUAL_BITMAP_MAX_WORDS); 844 *rkey_size += key_size; 845 } else { 846 for (chunk = 0; chunk < qual_cfg->num_chunks; chunk++) { 847 *rkey_size += qual_cfg->e_params[chunk].width; 848 } 849 } 850 } 851 852 exit: 853 BCMI_KEYGEN_FUNC_EXIT(); 854 } 855 856 int 857 bcmi_keygen_oper_free(int unit, 858 uint16 num_parts, 859 bcmi_keygen_oper_t *keygen_oper) 860 { 861 uint16 part = 0; 862 bcmi_keygen_qual_offset_info_t *offset_info = NULL; 863 864 BCMI_KEYGEN_FUNC_ENTER(unit); 865 866 if (keygen_oper == NULL) { 867 BCMI_KEYGEN_RETURN_VAL_EXIT(BCM_E_NONE); 868 } 869 870 if (keygen_oper->qual_offset_info == NULL && 871 keygen_oper->ext_ctrl_sel_info == NULL) { 872 BCMI_KEYGEN_IF_ERR_VERBOSE_EXIT(BCM_E_NONE); 873 } 874 875 if (keygen_oper->qual_offset_info != NULL) { 876 for (part = 0; part < num_parts; part++) { 877 offset_info = &(keygen_oper->qual_offset_info[part]); 878 BCMI_KEYGEN_FREE(offset_info->qid_arr); 879 BCMI_KEYGEN_FREE(offset_info->offset_arr); 880 } 881 BCMI_KEYGEN_FREE(keygen_oper->qual_offset_info); 882 } 883 884 if (keygen_oper->ext_ctrl_sel_info != NULL) { 885 BCMI_KEYGEN_FREE(keygen_oper->ext_ctrl_sel_info); 886 } 887 888 exit: 889 BCMI_KEYGEN_FUNC_EXIT(); 890 } 891 892 int 893 bcmi_keygen_qual_cfg_t_init(int unit, bcmi_keygen_qual_cfg_t *qual_cfg) 894 { 895 BCMI_KEYGEN_FUNC_ENTER(unit); 896 897 BCMI_KEYGEN_NULL_CHECK(qual_cfg, BCM_E_PARAM); 898 899 sal_memset(qual_cfg, 0, sizeof(bcmi_keygen_qual_cfg_t)); 900 901 exit: 902 BCMI_KEYGEN_FUNC_EXIT(); 903 } 904 905 int 906 bcmi_keygen_qual_cfg_insert(int unit, 907 bcm_field_qualify_t qual_id, 908 bcmi_keygen_qual_cfg_t *new_qual_cfg, 909 bcmi_keygen_qual_cfg_info_db_t *qual_cfg_info_db) 910 { 911 uint8 qual_cfg_info_db_alloc = 0; 912 uint8 qual_cfg_info_alloc = 0; 913 uint8 chunk = 0; 914 uint8 num_qual_cfg = 0; 915 bcmi_keygen_qual_cfg_t *qual_cfg = NULL; 916 bcmi_keygen_qual_cfg_t *qual_cfg_arr = NULL; 917 bcmi_keygen_qual_cfg_info_t *qual_cfg_info = NULL; 918 919 BCMI_KEYGEN_FUNC_ENTER(unit); 920 921 BCMI_KEYGEN_NULL_CHECK(new_qual_cfg, BCM_E_PARAM); 922 BCMI_KEYGEN_NULL_CHECK(qual_cfg_info_db, BCM_E_PARAM); 923 924 qual_cfg_info = qual_cfg_info_db->qual_cfg_info[qual_id]; 925 if (qual_cfg_info == NULL) { 926 BCMI_KEYGEN_ALLOC(qual_cfg_info, 927 sizeof(bcmi_keygen_qual_cfg_info_t), 928 "BCMI_KEYGEN:Qualifier Config Info"); 929 qual_cfg_info_db->qual_cfg_info[qual_id] = qual_cfg_info; 930 qual_cfg_info->qual = qual_id; 931 qual_cfg_info_alloc = 1; 932 } 933 934 num_qual_cfg = qual_cfg_info->num_qual_cfg + 1; 935 936 BCMI_KEYGEN_ALLOC(qual_cfg_arr, 937 num_qual_cfg * sizeof(bcmi_keygen_qual_cfg_t), 938 "BCMI_KEYGEN:Qualifier config"); 939 940 sal_memcpy(qual_cfg_arr, 941 qual_cfg_info->qual_cfg_arr, 942 sizeof(bcmi_keygen_qual_cfg_t) * (num_qual_cfg - 1)); 943 944 qual_cfg = &(qual_cfg_arr[num_qual_cfg - 1]); 945 946 for (chunk = 0; chunk < new_qual_cfg->num_chunks; chunk++) { 947 if (BCMI_KEYGEN_EXT_SECTION_L1E32 == 948 new_qual_cfg->e_params[chunk].section) { 949 new_qual_cfg->e_params[chunk].size = 32; 950 } else if (BCMI_KEYGEN_EXT_SECTION_L1E16 == 951 new_qual_cfg->e_params[chunk].section) { 952 new_qual_cfg->e_params[chunk].size = 16; 953 } else if (BCMI_KEYGEN_EXT_SECTION_L1E8 == 954 new_qual_cfg->e_params[chunk].section) { 955 new_qual_cfg->e_params[chunk].size = 8; 956 } else if (BCMI_KEYGEN_EXT_SECTION_L1E4 == 957 new_qual_cfg->e_params[chunk].section) { 958 new_qual_cfg->e_params[chunk].size = 4; 959 } else if (BCMI_KEYGEN_EXT_SECTION_L1E2 == 960 new_qual_cfg->e_params[chunk].section) { 961 new_qual_cfg->e_params[chunk].size = 2; 962 } 963 } 964 965 sal_memcpy(qual_cfg, new_qual_cfg, sizeof(bcmi_keygen_qual_cfg_t)); 966 967 BCMI_KEYGEN_FREE(qual_cfg_info->qual_cfg_arr); 968 969 qual_cfg_info->qual_cfg_arr = qual_cfg_arr; 970 qual_cfg_info->num_qual_cfg++; 971 972 BCMI_KEYGEN_FUNC_EXIT(); 973 974 exit: 975 BCMI_KEYGEN_FREE(qual_cfg_arr); 976 if (qual_cfg_info_db_alloc) { 977 BCMI_KEYGEN_FREE(qual_cfg_info_db); 978 } 979 if (qual_cfg_info_alloc) { 980 BCMI_KEYGEN_FREE(qual_cfg_info); 981 } 982 BCMI_KEYGEN_FUNC_EXIT(); 983 } 984 985 int 986 bcmi_keygen_cfg_process(int unit, 987 bcmi_keygen_cfg_t *keygen_cfg, 988 bcmi_keygen_oper_t *keygen_oper) 989 { 990 bcmi_keygen_md_t *keygen_md = NULL; 991 992 BCMI_KEYGEN_FUNC_ENTER(unit); 993 994 BCMI_KEYGEN_NULL_CHECK(keygen_cfg, BCM_E_PARAM); 995 996 if (keygen_cfg->qual_info_count == 0) { 997 BCMI_KEYGEN_RETURN_VAL_EXIT(BCM_E_NONE); 998 } 999 1000 BCMI_KEYGEN_IF_ERR_VERBOSE_EXIT(bcmi_keygen_md_alloc(unit, keygen_cfg, &keygen_md)); 1001 1002 BCMI_KEYGEN_IF_ERR_VERBOSE_EXIT( 1003 bcmi_keygen_cfg_md_process(unit, keygen_cfg, keygen_oper, keygen_md)); 1004 exit: 1005 (void)bcmi_keygen_md_free(unit, keygen_cfg, keygen_md); 1006 BCMI_KEYGEN_FREE(keygen_md); 1007 BCMI_KEYGEN_FUNC_EXIT(); 1008 }