1 /* 2 * Copyright 2008-2012 Freescale Semiconductor Inc. 3 * 4 * Redistribution and use in source and binary forms, with or without 5 * modification, are permitted provided that the following conditions are met: 6 * * Redistributions of source code must retain the above copyright 7 * notice, this list of conditions and the following disclaimer. 8 * * Redistributions in binary form must reproduce the above copyright 9 * notice, this list of conditions and the following disclaimer in the 10 * documentation and/or other materials provided with the distribution. 11 * * Neither the name of Freescale Semiconductor nor the 12 * names of its contributors may be used to endorse or promote products 13 * derived from this software without specific prior written permission. 14 * 15 * 16 * ALTERNATIVELY, this software may be distributed under the terms of the 17 * GNU General Public License ("GPL") as published by the Free Software 18 * Foundation, either version 2 of that License or (at your option) any 19 * later version. 20 * 21 * THIS SOFTWARE IS PROVIDED BY Freescale Semiconductor ``AS IS'' AND ANY 22 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 23 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 24 * DISCLAIMED. IN NO EVENT SHALL Freescale Semiconductor BE LIABLE FOR ANY 25 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 26 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 27 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND 28 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 29 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 30 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 31 */ 32 33 34 /****************************************************************************** 35 @File fm_cc.c 36 37 @Description FM Coarse Classifier implementation 38 *//***************************************************************************/ 39 #include <sys/cdefs.h> 40 #include <sys/endian.h> 41 #include "std_ext.h" 42 #include "error_ext.h" 43 #include "string_ext.h" 44 #include "debug_ext.h" 45 #include "fm_pcd_ext.h" 46 #include "fm_muram_ext.h" 47 48 #include "fm_common.h" 49 #include "fm_pcd.h" 50 #include "fm_hc.h" 51 #include "fm_cc.h" 52 #include "crc64.h" 53 54 /****************************************/ 55 /* static functions */ 56 /****************************************/ 57 58 59 static t_Error CcRootTryLock(t_Handle h_FmPcdCcTree) 60 { 61 t_FmPcdCcTree *p_FmPcdCcTree = (t_FmPcdCcTree *)h_FmPcdCcTree; 62 63 ASSERT_COND(h_FmPcdCcTree); 64 65 if (FmPcdLockTryLock(p_FmPcdCcTree->p_Lock)) 66 return E_OK; 67 68 return ERROR_CODE(E_BUSY); 69 } 70 71 static void CcRootReleaseLock(t_Handle h_FmPcdCcTree) 72 { 73 t_FmPcdCcTree *p_FmPcdCcTree = (t_FmPcdCcTree *)h_FmPcdCcTree; 74 75 ASSERT_COND(h_FmPcdCcTree); 76 77 FmPcdLockUnlock(p_FmPcdCcTree->p_Lock); 78 } 79 80 static void UpdateNodeOwner(t_FmPcdCcNode *p_CcNode, bool add) 81 { 82 uint32_t intFlags; 83 84 ASSERT_COND(p_CcNode); 85 86 intFlags = XX_LockIntrSpinlock(p_CcNode->h_Spinlock); 87 88 if (add) 89 p_CcNode->owners++; 90 else 91 { 92 ASSERT_COND(p_CcNode->owners); 93 p_CcNode->owners--; 94 } 95 96 XX_UnlockIntrSpinlock(p_CcNode->h_Spinlock, intFlags); 97 } 98 99 static __inline__ t_FmPcdStatsObj* DequeueStatsObj(t_List *p_List) 100 { 101 t_FmPcdStatsObj *p_StatsObj = NULL; 102 t_List *p_Next; 103 104 if (!NCSW_LIST_IsEmpty(p_List)) 105 { 106 p_Next = NCSW_LIST_FIRST(p_List); 107 p_StatsObj = NCSW_LIST_OBJECT(p_Next, t_FmPcdStatsObj, node); 108 ASSERT_COND(p_StatsObj); 109 NCSW_LIST_DelAndInit(p_Next); 110 } 111 112 return p_StatsObj; 113 } 114 115 static __inline__ void EnqueueStatsObj(t_List *p_List, 116 t_FmPcdStatsObj *p_StatsObj) 117 { 118 NCSW_LIST_AddToTail(&p_StatsObj->node, p_List); 119 } 120 121 static void FreeStatObjects(t_List *p_List, t_Handle h_FmMuram) 122 { 123 t_FmPcdStatsObj *p_StatsObj; 124 125 while (!NCSW_LIST_IsEmpty(p_List)) 126 { 127 p_StatsObj = DequeueStatsObj(p_List); 128 ASSERT_COND(p_StatsObj); 129 130 FM_MURAM_FreeMem(h_FmMuram, p_StatsObj->h_StatsAd); 131 FM_MURAM_FreeMem(h_FmMuram, p_StatsObj->h_StatsCounters); 132 133 XX_Free(p_StatsObj); 134 } 135 } 136 137 static t_FmPcdStatsObj* GetStatsObj(t_FmPcdCcNode *p_CcNode) 138 { 139 t_FmPcdStatsObj* p_StatsObj; 140 t_Handle h_FmMuram; 141 142 ASSERT_COND(p_CcNode); 143 144 /* If 'maxNumOfKeys' was passed, all statistics object were preallocated 145 upon node initialization */ 146 if (p_CcNode->maxNumOfKeys) 147 { 148 p_StatsObj = DequeueStatsObj(&p_CcNode->availableStatsLst); 149 } 150 else 151 { 152 h_FmMuram = ((t_FmPcd *)(p_CcNode->h_FmPcd))->h_FmMuram; 153 ASSERT_COND(h_FmMuram); 154 155 p_StatsObj = XX_Malloc(sizeof(t_FmPcdStatsObj)); 156 if (!p_StatsObj) 157 { 158 REPORT_ERROR(MAJOR, E_NO_MEMORY, ("statistics object")); 159 return NULL; 160 } 161 162 p_StatsObj->h_StatsAd = (t_Handle)FM_MURAM_AllocMem( 163 h_FmMuram, FM_PCD_CC_AD_ENTRY_SIZE, FM_PCD_CC_AD_TABLE_ALIGN); 164 if (!p_StatsObj->h_StatsAd) 165 { 166 XX_Free(p_StatsObj); 167 REPORT_ERROR(MAJOR, E_NO_MEMORY, ("MURAM allocation for statistics ADs")); 168 return NULL; 169 } 170 MemSet8(p_StatsObj->h_StatsAd, 0, FM_PCD_CC_AD_ENTRY_SIZE); 171 172 p_StatsObj->h_StatsCounters = (t_Handle)FM_MURAM_AllocMem( 173 h_FmMuram, p_CcNode->countersArraySize, 174 FM_PCD_CC_AD_TABLE_ALIGN); 175 if (!p_StatsObj->h_StatsCounters) 176 { 177 FM_MURAM_FreeMem(h_FmMuram, p_StatsObj->h_StatsAd); 178 XX_Free(p_StatsObj); 179 REPORT_ERROR(MAJOR, E_NO_MEMORY, ("MURAM allocation for statistics counters")); 180 return NULL; 181 } 182 MemSet8(p_StatsObj->h_StatsCounters, 0, p_CcNode->countersArraySize); 183 } 184 185 return p_StatsObj; 186 } 187 188 static void PutStatsObj(t_FmPcdCcNode *p_CcNode, t_FmPcdStatsObj *p_StatsObj) 189 { 190 t_Handle h_FmMuram; 191 192 ASSERT_COND(p_CcNode); 193 ASSERT_COND(p_StatsObj); 194 195 /* If 'maxNumOfKeys' was passed, all statistics object were preallocated 196 upon node initialization and now will be enqueued back to the list */ 197 if (p_CcNode->maxNumOfKeys) 198 { 199 /* Nullify counters */ 200 MemSet8(p_StatsObj->h_StatsCounters, 0, p_CcNode->countersArraySize); 201 202 EnqueueStatsObj(&p_CcNode->availableStatsLst, p_StatsObj); 203 } 204 else 205 { 206 h_FmMuram = ((t_FmPcd *)(p_CcNode->h_FmPcd))->h_FmMuram; 207 ASSERT_COND(h_FmMuram); 208 209 FM_MURAM_FreeMem(h_FmMuram, p_StatsObj->h_StatsAd); 210 FM_MURAM_FreeMem(h_FmMuram, p_StatsObj->h_StatsCounters); 211 212 XX_Free(p_StatsObj); 213 } 214 } 215 216 static void SetStatsCounters(t_AdOfTypeStats *p_StatsAd, 217 uint32_t statsCountersAddr) 218 { 219 uint32_t tmp = (statsCountersAddr & FM_PCD_AD_STATS_COUNTERS_ADDR_MASK); 220 221 WRITE_UINT32(p_StatsAd->statsTableAddr, tmp); 222 } 223 224 225 static void UpdateStatsAd(t_FmPcdCcStatsParams *p_FmPcdCcStatsParams, 226 t_Handle h_Ad, uint64_t physicalMuramBase) 227 { 228 t_AdOfTypeStats *p_StatsAd; 229 uint32_t statsCountersAddr, nextActionAddr, tmp; 230 #if (DPAA_VERSION >= 11) 231 uint32_t frameLengthRangesAddr; 232 #endif /* (DPAA_VERSION >= 11) */ 233 234 p_StatsAd = (t_AdOfTypeStats *)p_FmPcdCcStatsParams->h_StatsAd; 235 236 tmp = FM_PCD_AD_STATS_TYPE; 237 238 #if (DPAA_VERSION >= 11) 239 if (p_FmPcdCcStatsParams->h_StatsFLRs) 240 { 241 frameLengthRangesAddr = (uint32_t)((XX_VirtToPhys( 242 p_FmPcdCcStatsParams->h_StatsFLRs) - physicalMuramBase)); 243 tmp |= (frameLengthRangesAddr & FM_PCD_AD_STATS_FLR_ADDR_MASK); 244 } 245 #endif /* (DPAA_VERSION >= 11) */ 246 WRITE_UINT32(p_StatsAd->profileTableAddr, tmp); 247 248 nextActionAddr = (uint32_t)((XX_VirtToPhys(h_Ad) - physicalMuramBase)); 249 tmp = 0; 250 tmp |= (uint32_t)((nextActionAddr << FM_PCD_AD_STATS_NEXT_ACTION_SHIFT) 251 & FM_PCD_AD_STATS_NEXT_ACTION_MASK); 252 tmp |= (FM_PCD_AD_STATS_NAD_EN | FM_PCD_AD_STATS_OP_CODE); 253 254 #if (DPAA_VERSION >= 11) 255 if (p_FmPcdCcStatsParams->h_StatsFLRs) 256 tmp |= FM_PCD_AD_STATS_FLR_EN; 257 #endif /* (DPAA_VERSION >= 11) */ 258 259 WRITE_UINT32(p_StatsAd->nextActionIndx, tmp); 260 261 statsCountersAddr = (uint32_t)((XX_VirtToPhys( 262 p_FmPcdCcStatsParams->h_StatsCounters) - physicalMuramBase)); 263 SetStatsCounters(p_StatsAd, statsCountersAddr); 264 } 265 266 static void FillAdOfTypeContLookup(t_Handle h_Ad, 267 t_FmPcdCcStatsParams *p_FmPcdCcStatsParams, 268 t_Handle h_FmPcd, t_Handle p_CcNode, 269 t_Handle h_Manip, t_Handle h_FrmReplic) 270 { 271 t_FmPcdCcNode *p_Node = (t_FmPcdCcNode *)p_CcNode; 272 t_AdOfTypeContLookup *p_AdContLookup = (t_AdOfTypeContLookup *)h_Ad; 273 t_Handle h_TmpAd; 274 t_FmPcd *p_FmPcd = (t_FmPcd*)h_FmPcd; 275 uint32_t tmpReg32; 276 t_Handle p_AdNewPtr = NULL; 277 278 UNUSED(h_Manip); 279 UNUSED(h_FrmReplic); 280 281 /* there are 3 cases handled in this routine of building a "Continue lookup" type AD. 282 * Case 1: No Manip. The action descriptor is built within the match table. 283 * p_AdResult = p_AdNewPtr; 284 * Case 2: Manip exists. A new AD is created - p_AdNewPtr. It is initialized 285 * either in the FmPcdManipUpdateAdResultForCc routine or it was already 286 * initialized and returned here. 287 * p_AdResult (within the match table) will be initialized after 288 * this routine returns and point to the existing AD. 289 * Case 3: Manip exists. The action descriptor is built within the match table. 290 * FmPcdManipUpdateAdContLookupForCc returns a NULL p_AdNewPtr. 291 */ 292 293 /* As default, the "new" ptr is the current one. i.e. the content of the result 294 * AD will be written into the match table itself (case (1))*/ 295 p_AdNewPtr = p_AdContLookup; 296 297 /* Initialize an action descriptor, if current statistics mode requires an Ad */ 298 if (p_FmPcdCcStatsParams) 299 { 300 ASSERT_COND(p_FmPcdCcStatsParams->h_StatsAd); 301 ASSERT_COND(p_FmPcdCcStatsParams->h_StatsCounters); 302 303 /* Swapping addresses between statistics Ad and the current lookup AD */ 304 h_TmpAd = p_FmPcdCcStatsParams->h_StatsAd; 305 p_FmPcdCcStatsParams->h_StatsAd = h_Ad; 306 h_Ad = h_TmpAd; 307 308 p_AdNewPtr = h_Ad; 309 p_AdContLookup = h_Ad; 310 311 /* Init statistics Ad and connect current lookup AD as 'next action' from statistics Ad */ 312 UpdateStatsAd(p_FmPcdCcStatsParams, h_Ad, p_FmPcd->physicalMuramBase); 313 } 314 315 #if DPAA_VERSION >= 11 316 if (h_Manip && h_FrmReplic) 317 FmPcdManipUpdateAdContLookupForCc( 318 h_Manip, 319 h_Ad, 320 &p_AdNewPtr, 321 (uint32_t)((XX_VirtToPhys( 322 FrmReplicGroupGetSourceTableDescriptor(h_FrmReplic)) 323 - p_FmPcd->physicalMuramBase))); 324 else 325 if (h_FrmReplic) 326 FrmReplicGroupUpdateAd(h_FrmReplic, h_Ad, &p_AdNewPtr); 327 else 328 #endif /* (DPAA_VERSION >= 11) */ 329 if (h_Manip) 330 FmPcdManipUpdateAdContLookupForCc( 331 h_Manip, 332 h_Ad, 333 &p_AdNewPtr, 334 335 #ifdef FM_CAPWAP_SUPPORT 336 /*no check for opcode of manip - this step can be reached only with capwap_applic_specific*/ 337 (uint32_t)((XX_VirtToPhys(p_Node->h_AdTable) - p_FmPcd->physicalMuramBase)) 338 #else /* not FM_CAPWAP_SUPPORT */ 339 (uint32_t)((XX_VirtToPhys(p_Node->h_Ad) 340 - p_FmPcd->physicalMuramBase)) 341 #endif /* not FM_CAPWAP_SUPPORT */ 342 ); 343 344 /* if (p_AdNewPtr = NULL) --> Done. (case (3)) */ 345 if (p_AdNewPtr) 346 { 347 /* cases (1) & (2) */ 348 tmpReg32 = 0; 349 tmpReg32 |= FM_PCD_AD_CONT_LOOKUP_TYPE; 350 tmpReg32 |= 351 p_Node->sizeOfExtraction ? ((p_Node->sizeOfExtraction - 1) << 24) : 352 0; 353 tmpReg32 |= (uint32_t)(XX_VirtToPhys(p_Node->h_AdTable) 354 - p_FmPcd->physicalMuramBase); 355 WRITE_UINT32(p_AdContLookup->ccAdBase, tmpReg32); 356 357 tmpReg32 = 0; 358 tmpReg32 |= p_Node->numOfKeys << 24; 359 tmpReg32 |= (p_Node->lclMask ? FM_PCD_AD_CONT_LOOKUP_LCL_MASK : 0); 360 tmpReg32 |= 361 p_Node->h_KeysMatchTable ? (uint32_t)(XX_VirtToPhys( 362 p_Node->h_KeysMatchTable) - p_FmPcd->physicalMuramBase) : 363 0; 364 WRITE_UINT32(p_AdContLookup->matchTblPtr, tmpReg32); 365 366 tmpReg32 = 0; 367 tmpReg32 |= p_Node->prsArrayOffset << 24; 368 tmpReg32 |= p_Node->offset << 16; 369 tmpReg32 |= p_Node->parseCode; 370 WRITE_UINT32(p_AdContLookup->pcAndOffsets, tmpReg32); 371 372 MemCpy8((void*)&p_AdContLookup->gmask, p_Node->p_GlblMask, 373 CC_GLBL_MASK_SIZE); 374 } 375 } 376 377 static t_Error AllocAndFillAdForContLookupManip(t_Handle h_CcNode) 378 { 379 t_FmPcdCcNode *p_CcNode = (t_FmPcdCcNode *)h_CcNode; 380 uint32_t intFlags; 381 382 ASSERT_COND(p_CcNode); 383 384 intFlags = XX_LockIntrSpinlock(p_CcNode->h_Spinlock); 385 386 if (!p_CcNode->h_Ad) 387 { 388 if (p_CcNode->maxNumOfKeys) 389 p_CcNode->h_Ad = p_CcNode->h_TmpAd; 390 else 391 p_CcNode->h_Ad = (t_Handle)FM_MURAM_AllocMem( 392 ((t_FmPcd *)(p_CcNode->h_FmPcd))->h_FmMuram, 393 FM_PCD_CC_AD_ENTRY_SIZE, FM_PCD_CC_AD_TABLE_ALIGN); 394 395 XX_UnlockIntrSpinlock(p_CcNode->h_Spinlock, intFlags); 396 397 if (!p_CcNode->h_Ad) 398 RETURN_ERROR(MAJOR, E_NO_MEMORY, 399 ("MURAM allocation for CC action descriptor")); 400 401 MemSet8(p_CcNode->h_Ad, 0, FM_PCD_CC_AD_ENTRY_SIZE); 402 403 FillAdOfTypeContLookup(p_CcNode->h_Ad, NULL, p_CcNode->h_FmPcd, 404 p_CcNode, NULL, NULL); 405 } 406 else 407 XX_UnlockIntrSpinlock(p_CcNode->h_Spinlock, intFlags); 408 409 return E_OK; 410 } 411 412 static t_Error SetRequiredAction1( 413 t_Handle h_FmPcd, uint32_t requiredAction, 414 t_FmPcdCcKeyAndNextEngineParams *p_CcKeyAndNextEngineParamsTmp, 415 t_Handle h_AdTmp, uint16_t numOfEntries, t_Handle h_Tree) 416 { 417 t_AdOfTypeResult *p_AdTmp = (t_AdOfTypeResult *)h_AdTmp; 418 uint32_t tmpReg32; 419 t_Error err; 420 t_FmPcdCcNode *p_CcNode; 421 int i = 0; 422 uint16_t tmp = 0; 423 uint16_t profileId; 424 uint8_t relativeSchemeId, physicalSchemeId; 425 t_CcNodeInformation ccNodeInfo; 426 427 for (i = 0; i < numOfEntries; i++) 428 { 429 if (i == 0) 430 h_AdTmp = PTR_MOVE(h_AdTmp, i*FM_PCD_CC_AD_ENTRY_SIZE); 431 else 432 h_AdTmp = PTR_MOVE(h_AdTmp, FM_PCD_CC_AD_ENTRY_SIZE); 433 434 switch (p_CcKeyAndNextEngineParamsTmp[i].nextEngineParams.nextEngine) 435 { 436 case (e_FM_PCD_CC): 437 if (requiredAction) 438 { 439 p_CcNode = 440 p_CcKeyAndNextEngineParamsTmp[i].nextEngineParams.params.ccParams.h_CcNode; 441 ASSERT_COND(p_CcNode); 442 if (p_CcNode->shadowAction == requiredAction) 443 break; 444 if ((requiredAction & UPDATE_CC_WITH_TREE) 445 && !(p_CcNode->shadowAction & UPDATE_CC_WITH_TREE)) 446 { 447 448 memset(&ccNodeInfo, 0, sizeof(t_CcNodeInformation)); 449 ccNodeInfo.h_CcNode = h_Tree; 450 EnqueueNodeInfoToRelevantLst(&p_CcNode->ccTreesLst, 451 &ccNodeInfo, NULL); 452 p_CcKeyAndNextEngineParamsTmp[i].shadowAction |= 453 UPDATE_CC_WITH_TREE; 454 } 455 if ((requiredAction & UPDATE_CC_SHADOW_CLEAR) 456 && !(p_CcNode->shadowAction & UPDATE_CC_SHADOW_CLEAR)) 457 { 458 459 p_CcNode->shadowAction = 0; 460 } 461 462 if ((requiredAction & UPDATE_CC_WITH_DELETE_TREE) 463 && !(p_CcNode->shadowAction 464 & UPDATE_CC_WITH_DELETE_TREE)) 465 { 466 DequeueNodeInfoFromRelevantLst(&p_CcNode->ccTreesLst, 467 h_Tree, NULL); 468 p_CcKeyAndNextEngineParamsTmp[i].shadowAction |= 469 UPDATE_CC_WITH_DELETE_TREE; 470 } 471 if (p_CcNode->keyAndNextEngineParams[p_CcNode->numOfKeys].nextEngineParams.nextEngine 472 != e_FM_PCD_INVALID) 473 tmp = (uint8_t)(p_CcNode->numOfKeys + 1); 474 else 475 tmp = p_CcNode->numOfKeys; 476 err = SetRequiredAction1(h_FmPcd, requiredAction, 477 p_CcNode->keyAndNextEngineParams, 478 p_CcNode->h_AdTable, tmp, h_Tree); 479 if (err != E_OK) 480 return err; 481 if (requiredAction != UPDATE_CC_SHADOW_CLEAR) 482 p_CcNode->shadowAction |= requiredAction; 483 } 484 break; 485 486 case (e_FM_PCD_KG): 487 if ((requiredAction & UPDATE_NIA_ENQ_WITHOUT_DMA) 488 && !(p_CcKeyAndNextEngineParamsTmp[i].shadowAction 489 & UPDATE_NIA_ENQ_WITHOUT_DMA)) 490 { 491 physicalSchemeId = 492 FmPcdKgGetSchemeId( 493 p_CcKeyAndNextEngineParamsTmp[i].nextEngineParams.params.kgParams.h_DirectScheme); 494 relativeSchemeId = FmPcdKgGetRelativeSchemeId( 495 h_FmPcd, physicalSchemeId); 496 if (relativeSchemeId == FM_PCD_KG_NUM_OF_SCHEMES) 497 RETURN_ERROR(MAJOR, E_NOT_IN_RANGE, NO_MSG); 498 if (!FmPcdKgIsSchemeValidSw( 499 p_CcKeyAndNextEngineParamsTmp[i].nextEngineParams.params.kgParams.h_DirectScheme)) 500 RETURN_ERROR(MAJOR, E_INVALID_STATE, 501 ("Invalid direct scheme.")); 502 if (!KgIsSchemeAlwaysDirect(h_FmPcd, relativeSchemeId)) 503 RETURN_ERROR( 504 MAJOR, E_INVALID_STATE, 505 ("For this action scheme has to be direct.")); 506 err = 507 FmPcdKgCcGetSetParams( 508 h_FmPcd, 509 p_CcKeyAndNextEngineParamsTmp[i].nextEngineParams.params.kgParams.h_DirectScheme, 510 requiredAction, 0); 511 if (err != E_OK) 512 RETURN_ERROR(MAJOR, err, NO_MSG); 513 p_CcKeyAndNextEngineParamsTmp[i].shadowAction |= 514 requiredAction; 515 } 516 break; 517 518 case (e_FM_PCD_PLCR): 519 if ((requiredAction & UPDATE_NIA_ENQ_WITHOUT_DMA) 520 && !(p_CcKeyAndNextEngineParamsTmp[i].shadowAction 521 & UPDATE_NIA_ENQ_WITHOUT_DMA)) 522 { 523 if (!p_CcKeyAndNextEngineParamsTmp[i].nextEngineParams.params.plcrParams.overrideParams) 524 RETURN_ERROR( 525 MAJOR, 526 E_NOT_SUPPORTED, 527 ("In this initialization only overrideFqid can be initialized")); 528 if (!p_CcKeyAndNextEngineParamsTmp[i].nextEngineParams.params.plcrParams.sharedProfile) 529 RETURN_ERROR( 530 MAJOR, 531 E_NOT_SUPPORTED, 532 ("In this initialization only overrideFqid can be initialized")); 533 err = 534 FmPcdPlcrGetAbsoluteIdByProfileParams( 535 h_FmPcd, 536 e_FM_PCD_PLCR_SHARED, 537 NULL, 538 p_CcKeyAndNextEngineParamsTmp[i].nextEngineParams.params.plcrParams.newRelativeProfileId, 539 &profileId); 540 if (err != E_OK) 541 RETURN_ERROR(MAJOR, err, NO_MSG); 542 err = FmPcdPlcrCcGetSetParams(h_FmPcd, profileId, 543 requiredAction); 544 if (err != E_OK) 545 RETURN_ERROR(MAJOR, err, NO_MSG); 546 p_CcKeyAndNextEngineParamsTmp[i].shadowAction |= 547 requiredAction; 548 } 549 break; 550 551 case (e_FM_PCD_DONE): 552 if ((requiredAction & UPDATE_NIA_ENQ_WITHOUT_DMA) 553 && !(p_CcKeyAndNextEngineParamsTmp[i].shadowAction 554 & UPDATE_NIA_ENQ_WITHOUT_DMA)) 555 { 556 tmpReg32 = GET_UINT32(p_AdTmp->nia); 557 if ((tmpReg32 & GET_NIA_BMI_AC_ENQ_FRAME(h_FmPcd)) 558 != GET_NIA_BMI_AC_ENQ_FRAME(h_FmPcd)) 559 RETURN_ERROR( 560 MAJOR, 561 E_INVALID_STATE, 562 ("Next engine was previously assigned not as PCD_DONE")); 563 tmpReg32 |= NIA_BMI_AC_ENQ_FRAME_WITHOUT_DMA; 564 WRITE_UINT32(p_AdTmp->nia, tmpReg32); 565 p_CcKeyAndNextEngineParamsTmp[i].shadowAction |= 566 requiredAction; 567 } 568 break; 569 570 default: 571 break; 572 } 573 } 574 575 return E_OK; 576 } 577 578 static t_Error SetRequiredAction( 579 t_Handle h_FmPcd, uint32_t requiredAction, 580 t_FmPcdCcKeyAndNextEngineParams *p_CcKeyAndNextEngineParamsTmp, 581 t_Handle h_AdTmp, uint16_t numOfEntries, t_Handle h_Tree) 582 { 583 t_Error err = SetRequiredAction1(h_FmPcd, requiredAction, 584 p_CcKeyAndNextEngineParamsTmp, h_AdTmp, 585 numOfEntries, h_Tree); 586 if (err != E_OK) 587 return err; 588 return SetRequiredAction1(h_FmPcd, UPDATE_CC_SHADOW_CLEAR, 589 p_CcKeyAndNextEngineParamsTmp, h_AdTmp, 590 numOfEntries, h_Tree); 591 } 592 593 static t_Error ReleaseModifiedDataStructure( 594 t_Handle h_FmPcd, t_List *h_FmPcdOldPointersLst, 595 t_List *h_FmPcdNewPointersLst, 596 t_FmPcdModifyCcKeyAdditionalParams *p_AdditionalParams, 597 bool useShadowStructs) 598 { 599 t_List *p_Pos; 600 t_Error err = E_OK; 601 t_CcNodeInformation ccNodeInfo, *p_CcNodeInformation; 602 t_Handle h_Muram; 603 t_FmPcdCcNode *p_FmPcdCcNextNode, *p_FmPcdCcWorkingOnNode; 604 t_List *p_UpdateLst; 605 uint32_t intFlags; 606 607 SANITY_CHECK_RETURN_ERROR(h_FmPcd, E_INVALID_HANDLE); 608 SANITY_CHECK_RETURN_ERROR(p_AdditionalParams->h_CurrentNode, 609 E_INVALID_HANDLE); 610 SANITY_CHECK_RETURN_ERROR(h_FmPcdOldPointersLst, E_INVALID_HANDLE); 611 SANITY_CHECK_RETURN_ERROR(h_FmPcdNewPointersLst, E_INVALID_HANDLE); 612 613 /* We don't update subtree of the new node with new tree because it was done in the previous stage */ 614 if (p_AdditionalParams->h_NodeForAdd) 615 { 616 p_FmPcdCcNextNode = (t_FmPcdCcNode*)p_AdditionalParams->h_NodeForAdd; 617 618 if (!p_AdditionalParams->tree) 619 p_UpdateLst = &p_FmPcdCcNextNode->ccPrevNodesLst; 620 else 621 p_UpdateLst = &p_FmPcdCcNextNode->ccTreeIdLst; 622 623 p_CcNodeInformation = FindNodeInfoInReleventLst( 624 p_UpdateLst, p_AdditionalParams->h_CurrentNode, 625 p_FmPcdCcNextNode->h_Spinlock); 626 627 if (p_CcNodeInformation) 628 p_CcNodeInformation->index++; 629 else 630 { 631 memset(&ccNodeInfo, 0, sizeof(t_CcNodeInformation)); 632 ccNodeInfo.h_CcNode = (t_Handle)p_AdditionalParams->h_CurrentNode; 633 ccNodeInfo.index = 1; 634 EnqueueNodeInfoToRelevantLst(p_UpdateLst, &ccNodeInfo, 635 p_FmPcdCcNextNode->h_Spinlock); 636 } 637 if (p_AdditionalParams->h_ManipForAdd) 638 { 639 p_CcNodeInformation = FindNodeInfoInReleventLst( 640 FmPcdManipGetNodeLstPointedOnThisManip( 641 p_AdditionalParams->h_ManipForAdd), 642 p_AdditionalParams->h_CurrentNode, 643 FmPcdManipGetSpinlock(p_AdditionalParams->h_ManipForAdd)); 644 645 if (p_CcNodeInformation) 646 p_CcNodeInformation->index++; 647 else 648 { 649 memset(&ccNodeInfo, 0, sizeof(t_CcNodeInformation)); 650 ccNodeInfo.h_CcNode = 651 (t_Handle)p_AdditionalParams->h_CurrentNode; 652 ccNodeInfo.index = 1; 653 EnqueueNodeInfoToRelevantLst( 654 FmPcdManipGetNodeLstPointedOnThisManip( 655 p_AdditionalParams->h_ManipForAdd), 656 &ccNodeInfo, 657 FmPcdManipGetSpinlock( 658 p_AdditionalParams->h_ManipForAdd)); 659 } 660 } 661 } 662 663 if (p_AdditionalParams->h_NodeForRmv) 664 { 665 p_FmPcdCcNextNode = (t_FmPcdCcNode*)p_AdditionalParams->h_NodeForRmv; 666 667 if (!p_AdditionalParams->tree) 668 { 669 p_UpdateLst = &p_FmPcdCcNextNode->ccPrevNodesLst; 670 p_FmPcdCcWorkingOnNode = 671 (t_FmPcdCcNode *)(p_AdditionalParams->h_CurrentNode); 672 673 for (p_Pos = NCSW_LIST_FIRST(&p_FmPcdCcWorkingOnNode->ccTreesLst); 674 p_Pos != (&p_FmPcdCcWorkingOnNode->ccTreesLst); p_Pos = 675 NCSW_LIST_NEXT(p_Pos)) 676 { 677 p_CcNodeInformation = CC_NODE_F_OBJECT(p_Pos); 678 679 ASSERT_COND(p_CcNodeInformation->h_CcNode); 680 681 err = 682 SetRequiredAction( 683 h_FmPcd, 684 UPDATE_CC_WITH_DELETE_TREE, 685 &((t_FmPcdCcNode *)(p_AdditionalParams->h_CurrentNode))->keyAndNextEngineParams[p_AdditionalParams->savedKeyIndex], 686 PTR_MOVE(((t_FmPcdCcNode *)(p_AdditionalParams->h_CurrentNode))->h_AdTable, p_AdditionalParams->savedKeyIndex*FM_PCD_CC_AD_ENTRY_SIZE), 687 1, p_CcNodeInformation->h_CcNode); 688 } 689 } 690 else 691 { 692 p_UpdateLst = &p_FmPcdCcNextNode->ccTreeIdLst; 693 694 err = 695 SetRequiredAction( 696 h_FmPcd, 697 UPDATE_CC_WITH_DELETE_TREE, 698 &((t_FmPcdCcTree *)(p_AdditionalParams->h_CurrentNode))->keyAndNextEngineParams[p_AdditionalParams->savedKeyIndex], 699 UINT_TO_PTR(((t_FmPcdCcTree *)(p_AdditionalParams->h_CurrentNode))->ccTreeBaseAddr + p_AdditionalParams->savedKeyIndex*FM_PCD_CC_AD_ENTRY_SIZE), 700 1, p_AdditionalParams->h_CurrentNode); 701 } 702 if (err) 703 return err; 704 705 /* We remove from the subtree of the removed node tree because it wasn't done in the previous stage 706 Update ccPrevNodesLst or ccTreeIdLst of the removed node 707 Update of the node owner */ 708 p_CcNodeInformation = FindNodeInfoInReleventLst( 709 p_UpdateLst, p_AdditionalParams->h_CurrentNode, 710 p_FmPcdCcNextNode->h_Spinlock); 711 712 ASSERT_COND(p_CcNodeInformation); 713 ASSERT_COND(p_CcNodeInformation->index); 714 715 p_CcNodeInformation->index--; 716 717 if (p_CcNodeInformation->index == 0) 718 DequeueNodeInfoFromRelevantLst(p_UpdateLst, 719 p_AdditionalParams->h_CurrentNode, 720 p_FmPcdCcNextNode->h_Spinlock); 721 722 UpdateNodeOwner(p_FmPcdCcNextNode, FALSE); 723 724 if (p_AdditionalParams->h_ManipForRmv) 725 { 726 p_CcNodeInformation = FindNodeInfoInReleventLst( 727 FmPcdManipGetNodeLstPointedOnThisManip( 728 p_AdditionalParams->h_ManipForRmv), 729 p_AdditionalParams->h_CurrentNode, 730 FmPcdManipGetSpinlock(p_AdditionalParams->h_ManipForRmv)); 731 732 ASSERT_COND(p_CcNodeInformation); 733 ASSERT_COND(p_CcNodeInformation->index); 734 735 p_CcNodeInformation->index--; 736 737 if (p_CcNodeInformation->index == 0) 738 DequeueNodeInfoFromRelevantLst( 739 FmPcdManipGetNodeLstPointedOnThisManip( 740 p_AdditionalParams->h_ManipForRmv), 741 p_AdditionalParams->h_CurrentNode, 742 FmPcdManipGetSpinlock( 743 p_AdditionalParams->h_ManipForRmv)); 744 } 745 } 746 747 if (p_AdditionalParams->h_ManipForRmv) 748 FmPcdManipUpdateOwner(p_AdditionalParams->h_ManipForRmv, FALSE); 749 750 if (p_AdditionalParams->p_StatsObjForRmv) 751 PutStatsObj((t_FmPcdCcNode *)(p_AdditionalParams->h_CurrentNode), 752 p_AdditionalParams->p_StatsObjForRmv); 753 754 #if (DPAA_VERSION >= 11) 755 if (p_AdditionalParams->h_FrmReplicForRmv) 756 FrmReplicGroupUpdateOwner(p_AdditionalParams->h_FrmReplicForRmv, 757 FALSE/* remove */); 758 #endif /* (DPAA_VERSION >= 11) */ 759 760 if (!useShadowStructs) 761 { 762 h_Muram = FmPcdGetMuramHandle(h_FmPcd); 763 ASSERT_COND(h_Muram); 764 765 if ((p_AdditionalParams->tree && !((t_FmPcd *)h_FmPcd)->p_CcShadow) 766 || (!p_AdditionalParams->tree 767 && !((t_FmPcdCcNode *)(p_AdditionalParams->h_CurrentNode))->maxNumOfKeys)) 768 { 769 /* We release new AD which was allocated and updated for copy from to actual AD */ 770 for (p_Pos = NCSW_LIST_FIRST(h_FmPcdNewPointersLst); 771 p_Pos != (h_FmPcdNewPointersLst); p_Pos = NCSW_LIST_NEXT(p_Pos)) 772 { 773 774 p_CcNodeInformation = CC_NODE_F_OBJECT(p_Pos); 775 ASSERT_COND(p_CcNodeInformation->h_CcNode); 776 FM_MURAM_FreeMem(h_Muram, p_CcNodeInformation->h_CcNode); 777 } 778 } 779 780 /* Free Old data structure if it has to be freed - new data structure was allocated*/ 781 if (p_AdditionalParams->p_AdTableOld) 782 FM_MURAM_FreeMem(h_Muram, p_AdditionalParams->p_AdTableOld); 783 784 if (p_AdditionalParams->p_KeysMatchTableOld) 785 FM_MURAM_FreeMem(h_Muram, p_AdditionalParams->p_KeysMatchTableOld); 786 } 787 788 /* Update current modified node with changed fields if it's required*/ 789 if (!p_AdditionalParams->tree) 790 { 791 if (p_AdditionalParams->p_AdTableNew) 792 ((t_FmPcdCcNode *)(p_AdditionalParams->h_CurrentNode))->h_AdTable = 793 p_AdditionalParams->p_AdTableNew; 794 795 if (p_AdditionalParams->p_KeysMatchTableNew) 796 ((t_FmPcdCcNode *)(p_AdditionalParams->h_CurrentNode))->h_KeysMatchTable = 797 p_AdditionalParams->p_KeysMatchTableNew; 798 799 /* Locking node's spinlock before updating 'keys and next engine' structure, 800 as it maybe used to retrieve keys statistics */ 801 intFlags = 802 XX_LockIntrSpinlock( 803 ((t_FmPcdCcNode *)(p_AdditionalParams->h_CurrentNode))->h_Spinlock); 804 805 ((t_FmPcdCcNode *)(p_AdditionalParams->h_CurrentNode))->numOfKeys = 806 p_AdditionalParams->numOfKeys; 807 808 memcpy(((t_FmPcdCcNode *)(p_AdditionalParams->h_CurrentNode))->keyAndNextEngineParams, 809 &p_AdditionalParams->keyAndNextEngineParams, 810 sizeof(t_FmPcdCcKeyAndNextEngineParams) * (CC_MAX_NUM_OF_KEYS)); 811 812 XX_UnlockIntrSpinlock( 813 ((t_FmPcdCcNode *)(p_AdditionalParams->h_CurrentNode))->h_Spinlock, 814 intFlags); 815 } 816 else 817 { 818 uint8_t numEntries = 819 ((t_FmPcdCcTree *)(p_AdditionalParams->h_CurrentNode))->numOfEntries; 820 ASSERT_COND(numEntries < FM_PCD_MAX_NUM_OF_CC_GROUPS); 821 memcpy(&((t_FmPcdCcTree *)(p_AdditionalParams->h_CurrentNode))->keyAndNextEngineParams, 822 &p_AdditionalParams->keyAndNextEngineParams, 823 sizeof(t_FmPcdCcKeyAndNextEngineParams) * numEntries); 824 } 825 826 ReleaseLst(h_FmPcdOldPointersLst); 827 ReleaseLst(h_FmPcdNewPointersLst); 828 829 XX_Free(p_AdditionalParams); 830 831 return E_OK; 832 } 833 834 static t_Handle BuildNewAd( 835 t_Handle h_Ad, 836 t_FmPcdModifyCcKeyAdditionalParams *p_FmPcdModifyCcKeyAdditionalParams, 837 t_FmPcdCcNode *p_CcNode, 838 t_FmPcdCcNextEngineParams *p_FmPcdCcNextEngineParams) 839 { 840 t_FmPcdCcNode *p_FmPcdCcNodeTmp; 841 t_Handle h_OrigAd = NULL; 842 843 p_FmPcdCcNodeTmp = (t_FmPcdCcNode*)XX_Malloc(sizeof(t_FmPcdCcNode)); 844 if (!p_FmPcdCcNodeTmp) 845 { 846 REPORT_ERROR(MAJOR, E_NO_MEMORY, ("p_FmPcdCcNodeTmp")); 847 return NULL; 848 } 849 memset(p_FmPcdCcNodeTmp, 0, sizeof(t_FmPcdCcNode)); 850 851 p_FmPcdCcNodeTmp->numOfKeys = p_FmPcdModifyCcKeyAdditionalParams->numOfKeys; 852 p_FmPcdCcNodeTmp->h_KeysMatchTable = 853 p_FmPcdModifyCcKeyAdditionalParams->p_KeysMatchTableNew; 854 p_FmPcdCcNodeTmp->h_AdTable = 855 p_FmPcdModifyCcKeyAdditionalParams->p_AdTableNew; 856 857 p_FmPcdCcNodeTmp->lclMask = p_CcNode->lclMask; 858 p_FmPcdCcNodeTmp->parseCode = p_CcNode->parseCode; 859 p_FmPcdCcNodeTmp->offset = p_CcNode->offset; 860 p_FmPcdCcNodeTmp->prsArrayOffset = p_CcNode->prsArrayOffset; 861 p_FmPcdCcNodeTmp->ctrlFlow = p_CcNode->ctrlFlow; 862 p_FmPcdCcNodeTmp->ccKeySizeAccExtraction = p_CcNode->ccKeySizeAccExtraction; 863 p_FmPcdCcNodeTmp->sizeOfExtraction = p_CcNode->sizeOfExtraction; 864 p_FmPcdCcNodeTmp->glblMaskSize = p_CcNode->glblMaskSize; 865 p_FmPcdCcNodeTmp->p_GlblMask = p_CcNode->p_GlblMask; 866 867 if (p_FmPcdCcNextEngineParams->nextEngine == e_FM_PCD_CC) 868 { 869 if (p_FmPcdCcNextEngineParams->h_Manip) 870 { 871 h_OrigAd = p_CcNode->h_Ad; 872 if (AllocAndFillAdForContLookupManip( 873 p_FmPcdCcNextEngineParams->params.ccParams.h_CcNode) 874 != E_OK) 875 { 876 REPORT_ERROR(MAJOR, E_INVALID_STATE, NO_MSG); 877 XX_Free(p_FmPcdCcNodeTmp); 878 return NULL; 879 } 880 } 881 FillAdOfTypeContLookup(h_Ad, NULL, p_CcNode->h_FmPcd, p_FmPcdCcNodeTmp, 882 h_OrigAd ? NULL : p_FmPcdCcNextEngineParams->h_Manip, NULL); 883 } 884 885 #if (DPAA_VERSION >= 11) 886 if ((p_FmPcdCcNextEngineParams->nextEngine == e_FM_PCD_FR) 887 && (p_FmPcdCcNextEngineParams->params.frParams.h_FrmReplic)) 888 { 889 FillAdOfTypeContLookup( 890 h_Ad, NULL, p_CcNode->h_FmPcd, p_FmPcdCcNodeTmp, 891 p_FmPcdCcNextEngineParams->h_Manip, 892 p_FmPcdCcNextEngineParams->params.frParams.h_FrmReplic); 893 } 894 #endif /* (DPAA_VERSION >= 11) */ 895 896 XX_Free(p_FmPcdCcNodeTmp); 897 898 return NULL; 899 } 900 901 static t_Error DynamicChangeHc( 902 t_Handle h_FmPcd, t_List *h_OldPointersLst, t_List *h_NewPointersLst, 903 t_FmPcdModifyCcKeyAdditionalParams *p_AdditionalParams, 904 bool useShadowStructs) 905 { 906 t_List *p_PosOld, *p_PosNew; 907 uint32_t oldAdAddrOffset, newAdAddrOffset; 908 uint16_t i = 0; 909 t_Error err = E_OK; 910 uint8_t numOfModifiedPtr; 911 912 ASSERT_COND(h_FmPcd); 913 ASSERT_COND(h_OldPointersLst); 914 ASSERT_COND(h_NewPointersLst); 915 916 numOfModifiedPtr = (uint8_t)NCSW_LIST_NumOfObjs(h_OldPointersLst); 917 918 if (numOfModifiedPtr) 919 { 920 p_PosNew = NCSW_LIST_FIRST(h_NewPointersLst); 921 p_PosOld = NCSW_LIST_FIRST(h_OldPointersLst); 922 923 /* Retrieve address of new AD */ 924 newAdAddrOffset = FmPcdCcGetNodeAddrOffsetFromNodeInfo(h_FmPcd, 925 p_PosNew); 926 if (newAdAddrOffset == (uint32_t)ILLEGAL_BASE) 927 { 928 ReleaseModifiedDataStructure(h_FmPcd, h_OldPointersLst, 929 h_NewPointersLst, 930 p_AdditionalParams, useShadowStructs); 931 RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("New AD address")); 932 } 933 934 for (i = 0; i < numOfModifiedPtr; i++) 935 { 936 /* Retrieve address of current AD */ 937 oldAdAddrOffset = FmPcdCcGetNodeAddrOffsetFromNodeInfo(h_FmPcd, 938 p_PosOld); 939 if (oldAdAddrOffset == (uint32_t)ILLEGAL_BASE) 940 { 941 ReleaseModifiedDataStructure(h_FmPcd, h_OldPointersLst, 942 h_NewPointersLst, 943 p_AdditionalParams, 944 useShadowStructs); 945 RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("Old AD address")); 946 } 947 948 /* Invoke host command to copy from new AD to old AD */ 949 err = FmHcPcdCcDoDynamicChange(((t_FmPcd *)h_FmPcd)->h_Hc, 950 oldAdAddrOffset, newAdAddrOffset); 951 if (err) 952 { 953 ReleaseModifiedDataStructure(h_FmPcd, h_OldPointersLst, 954 h_NewPointersLst, 955 p_AdditionalParams, 956 useShadowStructs); 957 RETURN_ERROR( 958 MAJOR, 959 err, 960 ("For part of nodes changes are done - situation is danger")); 961 } 962 963 p_PosOld = NCSW_LIST_NEXT(p_PosOld); 964 } 965 } 966 return E_OK; 967 } 968 969 static t_Error DoDynamicChange( 970 t_Handle h_FmPcd, t_List *h_OldPointersLst, t_List *h_NewPointersLst, 971 t_FmPcdModifyCcKeyAdditionalParams *p_AdditionalParams, 972 bool useShadowStructs) 973 { 974 t_FmPcdCcNode *p_CcNode = 975 (t_FmPcdCcNode *)(p_AdditionalParams->h_CurrentNode); 976 t_List *p_PosNew; 977 t_CcNodeInformation *p_CcNodeInfo; 978 t_FmPcdCcNextEngineParams nextEngineParams; 979 t_Handle h_Ad; 980 uint32_t keySize; 981 t_Error err = E_OK; 982 uint8_t numOfModifiedPtr; 983 984 ASSERT_COND(h_FmPcd); 985 986 memset(&nextEngineParams, 0, sizeof(t_FmPcdCcNextEngineParams)); 987 988 numOfModifiedPtr = (uint8_t)NCSW_LIST_NumOfObjs(h_OldPointersLst); 989 990 if (numOfModifiedPtr) 991 { 992 993 p_PosNew = NCSW_LIST_FIRST(h_NewPointersLst); 994 995 /* Invoke host-command to copy from the new Ad to existing Ads */ 996 err = DynamicChangeHc(h_FmPcd, h_OldPointersLst, h_NewPointersLst, 997 p_AdditionalParams, useShadowStructs); 998 if (err) 999 RETURN_ERROR(MAJOR, err, NO_MSG); 1000 1001 if (useShadowStructs) 1002 { 1003 /* When the host-command above has ended, the old structures are 'free'and we can update 1004 them by copying from the new shadow structures. */ 1005 if (p_CcNode->lclMask) 1006 keySize = (uint32_t)(2 * p_CcNode->ccKeySizeAccExtraction); 1007 else 1008 keySize = p_CcNode->ccKeySizeAccExtraction; 1009 1010 MemCpy8(p_AdditionalParams->p_KeysMatchTableOld, 1011 p_AdditionalParams->p_KeysMatchTableNew, 1012 p_CcNode->maxNumOfKeys * keySize * sizeof(uint8_t)); 1013 1014 MemCpy8( 1015 p_AdditionalParams->p_AdTableOld, 1016 p_AdditionalParams->p_AdTableNew, 1017 (uint32_t)((p_CcNode->maxNumOfKeys + 1) 1018 * FM_PCD_CC_AD_ENTRY_SIZE)); 1019 1020 /* Retrieve the address of the allocated Ad */ 1021 p_CcNodeInfo = CC_NODE_F_OBJECT(p_PosNew); 1022 h_Ad = p_CcNodeInfo->h_CcNode; 1023 1024 /* Build a new Ad that holds the old (now updated) structures */ 1025 p_AdditionalParams->p_KeysMatchTableNew = 1026 p_AdditionalParams->p_KeysMatchTableOld; 1027 p_AdditionalParams->p_AdTableNew = p_AdditionalParams->p_AdTableOld; 1028 1029 nextEngineParams.nextEngine = e_FM_PCD_CC; 1030 nextEngineParams.params.ccParams.h_CcNode = (t_Handle)p_CcNode; 1031 1032 BuildNewAd(h_Ad, p_AdditionalParams, p_CcNode, &nextEngineParams); 1033 1034 /* HC to copy from the new Ad (old updated structures) to current Ad (uses shadow structures) */ 1035 err = DynamicChangeHc(h_FmPcd, h_OldPointersLst, h_NewPointersLst, 1036 p_AdditionalParams, useShadowStructs); 1037 if (err) 1038 RETURN_ERROR(MAJOR, err, NO_MSG); 1039 } 1040 } 1041 1042 err = ReleaseModifiedDataStructure(h_FmPcd, h_OldPointersLst, 1043 h_NewPointersLst, 1044 p_AdditionalParams, useShadowStructs); 1045 if (err) 1046 RETURN_ERROR(MAJOR, err, NO_MSG); 1047 1048 return E_OK; 1049 } 1050 1051 #ifdef FM_CAPWAP_SUPPORT 1052 static bool IsCapwapApplSpecific(t_Handle h_Node) 1053 { 1054 t_FmPcdCcNode *p_CcNode = (t_FmPcdCcNode *)h_Node; 1055 bool isManipForCapwapApplSpecificBuild = FALSE; 1056 int i = 0; 1057 1058 ASSERT_COND(h_Node); 1059 /* assumption that this function called only for INDEXED_FLOW_ID - so no miss*/ 1060 for (i = 0; i < p_CcNode->numOfKeys; i++) 1061 { 1062 if ( p_CcNode->keyAndNextEngineParams[i].nextEngineParams.h_Manip && 1063 FmPcdManipIsCapwapApplSpecific(p_CcNode->keyAndNextEngineParams[i].nextEngineParams.h_Manip)) 1064 { 1065 isManipForCapwapApplSpecificBuild = TRUE; 1066 break; 1067 } 1068 } 1069 return isManipForCapwapApplSpecificBuild; 1070 1071 } 1072 #endif /* FM_CAPWAP_SUPPORT */ 1073 1074 static t_Error CcUpdateParam( 1075 t_Handle h_FmPcd, t_Handle h_PcdParams, t_Handle h_FmPort, 1076 t_FmPcdCcKeyAndNextEngineParams *p_CcKeyAndNextEngineParams, 1077 uint16_t numOfEntries, t_Handle h_Ad, bool validate, uint16_t level, 1078 t_Handle h_FmTree, bool modify) 1079 { 1080 t_FmPcdCcNode *p_CcNode; 1081 t_Error err; 1082 uint16_t tmp = 0; 1083 int i = 0; 1084 t_FmPcdCcTree *p_CcTree = (t_FmPcdCcTree *)h_FmTree; 1085 1086 level++; 1087 1088 if (p_CcTree->h_IpReassemblyManip) 1089 { 1090 err = FmPcdManipUpdate(h_FmPcd, h_PcdParams, h_FmPort, 1091 p_CcTree->h_IpReassemblyManip, NULL, validate, 1092 level, h_FmTree, modify); 1093 if (err) 1094 RETURN_ERROR(MAJOR, err, NO_MSG); 1095 } 1096 1097 if (p_CcTree->h_CapwapReassemblyManip) 1098 { 1099 err = FmPcdManipUpdate(h_FmPcd, h_PcdParams, h_FmPort, 1100 p_CcTree->h_CapwapReassemblyManip, NULL, validate, 1101 level, h_FmTree, modify); 1102 if (err) 1103 RETURN_ERROR(MAJOR, err, NO_MSG); 1104 } 1105 1106 if (numOfEntries) 1107 { 1108 for (i = 0; i < numOfEntries; i++) 1109 { 1110 if (i == 0) 1111 h_Ad = PTR_MOVE(h_Ad, i*FM_PCD_CC_AD_ENTRY_SIZE); 1112 else 1113 h_Ad = PTR_MOVE(h_Ad, FM_PCD_CC_AD_ENTRY_SIZE); 1114 1115 if (p_CcKeyAndNextEngineParams[i].nextEngineParams.nextEngine 1116 == e_FM_PCD_CC) 1117 { 1118 p_CcNode = 1119 p_CcKeyAndNextEngineParams[i].nextEngineParams.params.ccParams.h_CcNode; 1120 ASSERT_COND(p_CcNode); 1121 1122 if (p_CcKeyAndNextEngineParams[i].nextEngineParams.h_Manip) 1123 { 1124 err = 1125 FmPcdManipUpdate( 1126 h_FmPcd, 1127 NULL, 1128 h_FmPort, 1129 p_CcKeyAndNextEngineParams[i].nextEngineParams.h_Manip, 1130 h_Ad, validate, level, h_FmTree, modify); 1131 if (err) 1132 RETURN_ERROR(MAJOR, err, NO_MSG); 1133 } 1134 1135 if (p_CcNode->keyAndNextEngineParams[p_CcNode->numOfKeys].nextEngineParams.nextEngine 1136 != e_FM_PCD_INVALID) 1137 tmp = (uint8_t)(p_CcNode->numOfKeys + 1); 1138 else 1139 tmp = p_CcNode->numOfKeys; 1140 1141 err = CcUpdateParam(h_FmPcd, h_PcdParams, h_FmPort, 1142 p_CcNode->keyAndNextEngineParams, tmp, 1143 p_CcNode->h_AdTable, validate, level, 1144 h_FmTree, modify); 1145 if (err) 1146 RETURN_ERROR(MAJOR, err, NO_MSG); 1147 } 1148 else 1149 { 1150 if (p_CcKeyAndNextEngineParams[i].nextEngineParams.h_Manip) 1151 { 1152 err = 1153 FmPcdManipUpdate( 1154 h_FmPcd, 1155 NULL, 1156 h_FmPort, 1157 p_CcKeyAndNextEngineParams[i].nextEngineParams.h_Manip, 1158 h_Ad, validate, level, h_FmTree, modify); 1159 if (err) 1160 RETURN_ERROR(MAJOR, err, NO_MSG); 1161 } 1162 } 1163 } 1164 } 1165 1166 return E_OK; 1167 } 1168 1169 static ccPrivateInfo_t IcDefineCode(t_FmPcdCcNodeParams *p_CcNodeParam) 1170 { 1171 switch (p_CcNodeParam->extractCcParams.extractNonHdr.action) 1172 { 1173 case (e_FM_PCD_ACTION_EXACT_MATCH): 1174 switch (p_CcNodeParam->extractCcParams.extractNonHdr.src) 1175 { 1176 case (e_FM_PCD_EXTRACT_FROM_KEY): 1177 return CC_PRIVATE_INFO_IC_KEY_EXACT_MATCH; 1178 case (e_FM_PCD_EXTRACT_FROM_HASH): 1179 return CC_PRIVATE_INFO_IC_HASH_EXACT_MATCH; 1180 default: 1181 return CC_PRIVATE_INFO_NONE; 1182 } 1183 1184 case (e_FM_PCD_ACTION_INDEXED_LOOKUP): 1185 switch (p_CcNodeParam->extractCcParams.extractNonHdr.src) 1186 { 1187 case (e_FM_PCD_EXTRACT_FROM_HASH): 1188 return CC_PRIVATE_INFO_IC_HASH_INDEX_LOOKUP; 1189 case (e_FM_PCD_EXTRACT_FROM_FLOW_ID): 1190 return CC_PRIVATE_INFO_IC_DEQ_FQID_INDEX_LOOKUP; 1191 default: 1192 return CC_PRIVATE_INFO_NONE; 1193 } 1194 1195 default: 1196 break; 1197 } 1198 1199 return CC_PRIVATE_INFO_NONE; 1200 } 1201 1202 static t_CcNodeInformation * DequeueAdditionalInfoFromRelevantLst( 1203 t_List *p_List) 1204 { 1205 t_CcNodeInformation *p_CcNodeInfo = NULL; 1206 1207 if (!NCSW_LIST_IsEmpty(p_List)) 1208 { 1209 p_CcNodeInfo = CC_NODE_F_OBJECT(p_List->p_Next); 1210 NCSW_LIST_DelAndInit(&p_CcNodeInfo->node); 1211 } 1212 1213 return p_CcNodeInfo; 1214 } 1215 1216 void ReleaseLst(t_List *p_List) 1217 { 1218 t_CcNodeInformation *p_CcNodeInfo = NULL; 1219 1220 if (!NCSW_LIST_IsEmpty(p_List)) 1221 { 1222 p_CcNodeInfo = DequeueAdditionalInfoFromRelevantLst(p_List); 1223 while (p_CcNodeInfo) 1224 { 1225 XX_Free(p_CcNodeInfo); 1226 p_CcNodeInfo = DequeueAdditionalInfoFromRelevantLst(p_List); 1227 } 1228 } 1229 1230 NCSW_LIST_Del(p_List); 1231 } 1232 1233 static void DeleteNode(t_FmPcdCcNode *p_CcNode) 1234 { 1235 uint32_t i; 1236 1237 if (!p_CcNode) 1238 return; 1239 1240 if (p_CcNode->p_GlblMask) 1241 { 1242 XX_Free(p_CcNode->p_GlblMask); 1243 p_CcNode->p_GlblMask = NULL; 1244 } 1245 1246 if (p_CcNode->h_KeysMatchTable) 1247 { 1248 FM_MURAM_FreeMem(FmPcdGetMuramHandle(p_CcNode->h_FmPcd), 1249 p_CcNode->h_KeysMatchTable); 1250 p_CcNode->h_KeysMatchTable = NULL; 1251 } 1252 1253 if (p_CcNode->h_AdTable) 1254 { 1255 FM_MURAM_FreeMem(FmPcdGetMuramHandle(p_CcNode->h_FmPcd), 1256 p_CcNode->h_AdTable); 1257 p_CcNode->h_AdTable = NULL; 1258 } 1259 1260 if (p_CcNode->h_Ad) 1261 { 1262 FM_MURAM_FreeMem(FmPcdGetMuramHandle(p_CcNode->h_FmPcd), 1263 p_CcNode->h_Ad); 1264 p_CcNode->h_Ad = NULL; 1265 p_CcNode->h_TmpAd = NULL; 1266 } 1267 1268 if (p_CcNode->h_StatsFLRs) 1269 { 1270 FM_MURAM_FreeMem(FmPcdGetMuramHandle(p_CcNode->h_FmPcd), 1271 p_CcNode->h_StatsFLRs); 1272 p_CcNode->h_StatsFLRs = NULL; 1273 } 1274 1275 if (p_CcNode->h_Spinlock) 1276 { 1277 XX_FreeSpinlock(p_CcNode->h_Spinlock); 1278 p_CcNode->h_Spinlock = NULL; 1279 } 1280 1281 /* Restore the original counters pointer instead of the mutual pointer (mutual to all hash buckets) */ 1282 if (p_CcNode->isHashBucket 1283 && (p_CcNode->statisticsMode != e_FM_PCD_CC_STATS_MODE_NONE)) 1284 p_CcNode->keyAndNextEngineParams[p_CcNode->numOfKeys].p_StatsObj->h_StatsCounters = 1285 p_CcNode->h_PrivMissStatsCounters; 1286 1287 /* Releasing all currently used statistics objects, including 'miss' entry */ 1288 for (i = 0; i < p_CcNode->numOfKeys + 1; i++) 1289 if (p_CcNode->keyAndNextEngineParams[i].p_StatsObj) 1290 PutStatsObj(p_CcNode, 1291 p_CcNode->keyAndNextEngineParams[i].p_StatsObj); 1292 1293 if (!NCSW_LIST_IsEmpty(&p_CcNode->availableStatsLst)) 1294 { 1295 t_Handle h_FmMuram = FmPcdGetMuramHandle(p_CcNode->h_FmPcd); 1296 ASSERT_COND(h_FmMuram); 1297 1298 FreeStatObjects(&p_CcNode->availableStatsLst, h_FmMuram); 1299 } 1300 1301 NCSW_LIST_Del(&p_CcNode->availableStatsLst); 1302 1303 ReleaseLst(&p_CcNode->ccPrevNodesLst); 1304 ReleaseLst(&p_CcNode->ccTreeIdLst); 1305 ReleaseLst(&p_CcNode->ccTreesLst); 1306 1307 XX_Free(p_CcNode); 1308 } 1309 1310 static void DeleteTree(t_FmPcdCcTree *p_FmPcdTree, t_FmPcd *p_FmPcd) 1311 { 1312 if (p_FmPcdTree) 1313 { 1314 if (p_FmPcdTree->ccTreeBaseAddr) 1315 { 1316 FM_MURAM_FreeMem(FmPcdGetMuramHandle(p_FmPcd), 1317 UINT_TO_PTR(p_FmPcdTree->ccTreeBaseAddr)); 1318 p_FmPcdTree->ccTreeBaseAddr = 0; 1319 } 1320 1321 ReleaseLst(&p_FmPcdTree->fmPortsLst); 1322 1323 XX_Free(p_FmPcdTree); 1324 } 1325 } 1326 1327 static void GetCcExtractKeySize(uint8_t parseCodeRealSize, 1328 uint8_t *parseCodeCcSize) 1329 { 1330 if ((parseCodeRealSize > 0) && (parseCodeRealSize < 2)) 1331 *parseCodeCcSize = 1; 1332 else 1333 if (parseCodeRealSize == 2) 1334 *parseCodeCcSize = 2; 1335 else 1336 if ((parseCodeRealSize > 2) && (parseCodeRealSize <= 4)) 1337 *parseCodeCcSize = 4; 1338 else 1339 if ((parseCodeRealSize > 4) && (parseCodeRealSize <= 8)) 1340 *parseCodeCcSize = 8; 1341 else 1342 if ((parseCodeRealSize > 8) && (parseCodeRealSize <= 16)) 1343 *parseCodeCcSize = 16; 1344 else 1345 if ((parseCodeRealSize > 16) 1346 && (parseCodeRealSize <= 24)) 1347 *parseCodeCcSize = 24; 1348 else 1349 if ((parseCodeRealSize > 24) 1350 && (parseCodeRealSize <= 32)) 1351 *parseCodeCcSize = 32; 1352 else 1353 if ((parseCodeRealSize > 32) 1354 && (parseCodeRealSize <= 40)) 1355 *parseCodeCcSize = 40; 1356 else 1357 if ((parseCodeRealSize > 40) 1358 && (parseCodeRealSize <= 48)) 1359 *parseCodeCcSize = 48; 1360 else 1361 if ((parseCodeRealSize > 48) 1362 && (parseCodeRealSize <= 56)) 1363 *parseCodeCcSize = 56; 1364 else 1365 *parseCodeCcSize = 0; 1366 } 1367 1368 static void GetSizeHeaderField(e_NetHeaderType hdr, t_FmPcdFields field, 1369 uint8_t *parseCodeRealSize) 1370 { 1371 switch (hdr) 1372 { 1373 case (HEADER_TYPE_ETH): 1374 switch (field.eth) 1375 { 1376 case (NET_HEADER_FIELD_ETH_DA): 1377 *parseCodeRealSize = 6; 1378 break; 1379 1380 case (NET_HEADER_FIELD_ETH_SA): 1381 *parseCodeRealSize = 6; 1382 break; 1383 1384 case (NET_HEADER_FIELD_ETH_TYPE): 1385 *parseCodeRealSize = 2; 1386 break; 1387 1388 default: 1389 REPORT_ERROR(MAJOR, E_NOT_SUPPORTED, ("Extraction not supported1")); 1390 *parseCodeRealSize = CC_SIZE_ILLEGAL; 1391 break; 1392 } 1393 break; 1394 1395 case (HEADER_TYPE_PPPoE): 1396 switch (field.pppoe) 1397 { 1398 case (NET_HEADER_FIELD_PPPoE_PID): 1399 *parseCodeRealSize = 2; 1400 break; 1401 1402 default: 1403 REPORT_ERROR(MAJOR, E_NOT_SUPPORTED, ("Extraction not supported1")); 1404 *parseCodeRealSize = CC_SIZE_ILLEGAL; 1405 break; 1406 } 1407 break; 1408 1409 case (HEADER_TYPE_VLAN): 1410 switch (field.vlan) 1411 { 1412 case (NET_HEADER_FIELD_VLAN_TCI): 1413 *parseCodeRealSize = 2; 1414 break; 1415 1416 default: 1417 REPORT_ERROR(MAJOR, E_NOT_SUPPORTED, ("Extraction not supported2")); 1418 *parseCodeRealSize = CC_SIZE_ILLEGAL; 1419 break; 1420 } 1421 break; 1422 1423 case (HEADER_TYPE_MPLS): 1424 switch (field.mpls) 1425 { 1426 case (NET_HEADER_FIELD_MPLS_LABEL_STACK): 1427 *parseCodeRealSize = 4; 1428 break; 1429 1430 default: 1431 REPORT_ERROR(MAJOR, E_NOT_SUPPORTED, ("Extraction not supported3")); 1432 *parseCodeRealSize = CC_SIZE_ILLEGAL; 1433 break; 1434 } 1435 break; 1436 1437 case (HEADER_TYPE_IPv4): 1438 switch (field.ipv4) 1439 { 1440 case (NET_HEADER_FIELD_IPv4_DST_IP): 1441 case (NET_HEADER_FIELD_IPv4_SRC_IP): 1442 *parseCodeRealSize = 4; 1443 break; 1444 1445 case (NET_HEADER_FIELD_IPv4_TOS): 1446 case (NET_HEADER_FIELD_IPv4_PROTO): 1447 *parseCodeRealSize = 1; 1448 break; 1449 1450 case (NET_HEADER_FIELD_IPv4_DST_IP 1451 | NET_HEADER_FIELD_IPv4_SRC_IP): 1452 *parseCodeRealSize = 8; 1453 break; 1454 1455 case (NET_HEADER_FIELD_IPv4_TTL): 1456 *parseCodeRealSize = 1; 1457 break; 1458 1459 default: 1460 REPORT_ERROR(MAJOR, E_NOT_SUPPORTED, ("Extraction not supported4")); 1461 *parseCodeRealSize = CC_SIZE_ILLEGAL; 1462 break; 1463 } 1464 break; 1465 1466 case (HEADER_TYPE_IPv6): 1467 switch (field.ipv6) 1468 { 1469 case (NET_HEADER_FIELD_IPv6_VER | NET_HEADER_FIELD_IPv6_FL 1470 | NET_HEADER_FIELD_IPv6_TC): 1471 *parseCodeRealSize = 4; 1472 break; 1473 1474 case (NET_HEADER_FIELD_IPv6_NEXT_HDR): 1475 case (NET_HEADER_FIELD_IPv6_HOP_LIMIT): 1476 *parseCodeRealSize = 1; 1477 break; 1478 1479 case (NET_HEADER_FIELD_IPv6_DST_IP): 1480 case (NET_HEADER_FIELD_IPv6_SRC_IP): 1481 *parseCodeRealSize = 16; 1482 break; 1483 1484 default: 1485 REPORT_ERROR(MAJOR, E_NOT_SUPPORTED, ("Extraction not supported5")); 1486 *parseCodeRealSize = CC_SIZE_ILLEGAL; 1487 break; 1488 } 1489 break; 1490 1491 case (HEADER_TYPE_IP): 1492 switch (field.ip) 1493 { 1494 case (NET_HEADER_FIELD_IP_DSCP): 1495 case (NET_HEADER_FIELD_IP_PROTO): 1496 *parseCodeRealSize = 1; 1497 break; 1498 1499 default: 1500 REPORT_ERROR(MAJOR, E_NOT_SUPPORTED, ("Extraction not supported5")); 1501 *parseCodeRealSize = CC_SIZE_ILLEGAL; 1502 break; 1503 } 1504 break; 1505 1506 case (HEADER_TYPE_GRE): 1507 switch (field.gre) 1508 { 1509 case (NET_HEADER_FIELD_GRE_TYPE): 1510 *parseCodeRealSize = 2; 1511 break; 1512 1513 default: 1514 REPORT_ERROR(MAJOR, E_NOT_SUPPORTED, ("Extraction not supported6")); 1515 *parseCodeRealSize = CC_SIZE_ILLEGAL; 1516 break; 1517 } 1518 break; 1519 1520 case (HEADER_TYPE_MINENCAP): 1521 switch (field.minencap) 1522 { 1523 case (NET_HEADER_FIELD_MINENCAP_TYPE): 1524 *parseCodeRealSize = 1; 1525 break; 1526 1527 case (NET_HEADER_FIELD_MINENCAP_DST_IP): 1528 case (NET_HEADER_FIELD_MINENCAP_SRC_IP): 1529 *parseCodeRealSize = 4; 1530 break; 1531 1532 case (NET_HEADER_FIELD_MINENCAP_SRC_IP 1533 | NET_HEADER_FIELD_MINENCAP_DST_IP): 1534 *parseCodeRealSize = 8; 1535 break; 1536 1537 default: 1538 REPORT_ERROR(MAJOR, E_NOT_SUPPORTED, ("Extraction not supported7")); 1539 *parseCodeRealSize = CC_SIZE_ILLEGAL; 1540 break; 1541 } 1542 break; 1543 1544 case (HEADER_TYPE_TCP): 1545 switch (field.tcp) 1546 { 1547 case (NET_HEADER_FIELD_TCP_PORT_SRC): 1548 case (NET_HEADER_FIELD_TCP_PORT_DST): 1549 *parseCodeRealSize = 2; 1550 break; 1551 1552 case (NET_HEADER_FIELD_TCP_PORT_SRC 1553 | NET_HEADER_FIELD_TCP_PORT_DST): 1554 *parseCodeRealSize = 4; 1555 break; 1556 1557 default: 1558 REPORT_ERROR(MAJOR, E_NOT_SUPPORTED, ("Extraction not supported8")); 1559 *parseCodeRealSize = CC_SIZE_ILLEGAL; 1560 break; 1561 } 1562 break; 1563 1564 case (HEADER_TYPE_UDP): 1565 switch (field.udp) 1566 { 1567 case (NET_HEADER_FIELD_UDP_PORT_SRC): 1568 case (NET_HEADER_FIELD_UDP_PORT_DST): 1569 *parseCodeRealSize = 2; 1570 break; 1571 1572 case (NET_HEADER_FIELD_UDP_PORT_SRC 1573 | NET_HEADER_FIELD_UDP_PORT_DST): 1574 *parseCodeRealSize = 4; 1575 break; 1576 1577 default: 1578 REPORT_ERROR(MAJOR, E_NOT_SUPPORTED, ("Extraction not supported9")); 1579 *parseCodeRealSize = CC_SIZE_ILLEGAL; 1580 break; 1581 } 1582 break; 1583 1584 default: 1585 REPORT_ERROR(MAJOR, E_NOT_SUPPORTED, ("Extraction not supported10")); 1586 *parseCodeRealSize = CC_SIZE_ILLEGAL; 1587 break; 1588 } 1589 } 1590 1591 t_Error ValidateNextEngineParams( 1592 t_Handle h_FmPcd, t_FmPcdCcNextEngineParams *p_FmPcdCcNextEngineParams, 1593 e_FmPcdCcStatsMode statsMode) 1594 { 1595 uint16_t absoluteProfileId; 1596 t_Error err = E_OK; 1597 uint8_t relativeSchemeId; 1598 1599 if ((statsMode == e_FM_PCD_CC_STATS_MODE_NONE) 1600 && (p_FmPcdCcNextEngineParams->statisticsEn)) 1601 RETURN_ERROR( 1602 MAJOR, 1603 E_CONFLICT, 1604 ("Statistics are requested for a key, but statistics mode was set" 1605 "to 'NONE' upon initialization")); 1606 1607 switch (p_FmPcdCcNextEngineParams->nextEngine) 1608 { 1609 case (e_FM_PCD_INVALID): 1610 err = E_NOT_SUPPORTED; 1611 break; 1612 1613 case (e_FM_PCD_DONE): 1614 if ((p_FmPcdCcNextEngineParams->params.enqueueParams.action 1615 == e_FM_PCD_ENQ_FRAME) 1616 && p_FmPcdCcNextEngineParams->params.enqueueParams.overrideFqid) 1617 { 1618 if (!p_FmPcdCcNextEngineParams->params.enqueueParams.newFqid) 1619 RETURN_ERROR( 1620 MAJOR, 1621 E_CONFLICT, 1622 ("When overrideFqid is set, newFqid must not be zero")); 1623 if (p_FmPcdCcNextEngineParams->params.enqueueParams.newFqid 1624 & ~0x00FFFFFF) 1625 RETURN_ERROR( 1626 MAJOR, E_INVALID_VALUE, 1627 ("fqidForCtrlFlow must be between 1 and 2^24-1")); 1628 } 1629 break; 1630 1631 case (e_FM_PCD_KG): 1632 relativeSchemeId = 1633 FmPcdKgGetRelativeSchemeId( 1634 h_FmPcd, 1635 FmPcdKgGetSchemeId( 1636 p_FmPcdCcNextEngineParams->params.kgParams.h_DirectScheme)); 1637 if (relativeSchemeId == FM_PCD_KG_NUM_OF_SCHEMES) 1638 RETURN_ERROR(MAJOR, E_NOT_IN_RANGE, NO_MSG); 1639 if (!FmPcdKgIsSchemeValidSw( 1640 p_FmPcdCcNextEngineParams->params.kgParams.h_DirectScheme)) 1641 RETURN_ERROR(MAJOR, E_INVALID_STATE, 1642 ("not valid schemeIndex in KG next engine param")); 1643 if (!KgIsSchemeAlwaysDirect(h_FmPcd, relativeSchemeId)) 1644 RETURN_ERROR( 1645 MAJOR, 1646 E_INVALID_STATE, 1647 ("CC Node may point only to a scheme that is always direct.")); 1648 break; 1649 1650 case (e_FM_PCD_PLCR): 1651 if (p_FmPcdCcNextEngineParams->params.plcrParams.overrideParams) 1652 { 1653 /* if private policer profile, it may be uninitialized yet, therefore no checks are done at this stage */ 1654 if (p_FmPcdCcNextEngineParams->params.plcrParams.sharedProfile) 1655 { 1656 err = 1657 FmPcdPlcrGetAbsoluteIdByProfileParams( 1658 h_FmPcd, 1659 e_FM_PCD_PLCR_SHARED, 1660 NULL, 1661 p_FmPcdCcNextEngineParams->params.plcrParams.newRelativeProfileId, 1662 &absoluteProfileId); 1663 if (err) 1664 RETURN_ERROR(MAJOR, err, 1665 ("Shared profile offset is out of range")); 1666 if (!FmPcdPlcrIsProfileValid(h_FmPcd, absoluteProfileId)) 1667 RETURN_ERROR(MAJOR, E_INVALID_STATE, 1668 ("Invalid profile")); 1669 } 1670 } 1671 break; 1672 1673 case (e_FM_PCD_HASH): 1674 p_FmPcdCcNextEngineParams->nextEngine = e_FM_PCD_CC; 1675 case (e_FM_PCD_CC): 1676 if (!p_FmPcdCcNextEngineParams->params.ccParams.h_CcNode) 1677 RETURN_ERROR(MAJOR, E_NULL_POINTER, 1678 ("handler to next Node is NULL")); 1679 break; 1680 1681 #if (DPAA_VERSION >= 11) 1682 case (e_FM_PCD_FR): 1683 if (!p_FmPcdCcNextEngineParams->params.frParams.h_FrmReplic) 1684 err = E_NOT_SUPPORTED; 1685 break; 1686 #endif /* (DPAA_VERSION >= 11) */ 1687 1688 default: 1689 RETURN_ERROR(MAJOR, E_INVALID_STATE, 1690 ("Next engine is not correct")); 1691 } 1692 1693 1694 return err; 1695 } 1696 1697 static uint8_t GetGenParseCode(e_FmPcdExtractFrom src, 1698 uint32_t offset, bool glblMask, 1699 uint8_t *parseArrayOffset, bool fromIc, 1700 ccPrivateInfo_t icCode) 1701 { 1702 if (!fromIc) 1703 { 1704 switch (src) 1705 { 1706 case (e_FM_PCD_EXTRACT_FROM_FRAME_START): 1707 if (glblMask) 1708 return CC_PC_GENERIC_WITH_MASK; 1709 else 1710 return CC_PC_GENERIC_WITHOUT_MASK; 1711 1712 case (e_FM_PCD_EXTRACT_FROM_CURR_END_OF_PARSE): 1713 *parseArrayOffset = CC_PC_PR_NEXT_HEADER_OFFSET; 1714 if (offset) 1715 return CC_PR_OFFSET; 1716 else 1717 return CC_PR_WITHOUT_OFFSET; 1718 1719 default: 1720 REPORT_ERROR(MAJOR, E_INVALID_VALUE, ("Illegal 'extract from' src")); 1721 return CC_PC_ILLEGAL; 1722 } 1723 } 1724 else 1725 { 1726 switch (icCode) 1727 { 1728 case (CC_PRIVATE_INFO_IC_KEY_EXACT_MATCH): 1729 *parseArrayOffset = 0x50; 1730 return CC_PC_GENERIC_IC_GMASK; 1731 1732 case (CC_PRIVATE_INFO_IC_HASH_EXACT_MATCH): 1733 *parseArrayOffset = 0x48; 1734 return CC_PC_GENERIC_IC_GMASK; 1735 1736 case (CC_PRIVATE_INFO_IC_HASH_INDEX_LOOKUP): 1737 *parseArrayOffset = 0x48; 1738 return CC_PC_GENERIC_IC_HASH_INDEXED; 1739 1740 case (CC_PRIVATE_INFO_IC_DEQ_FQID_INDEX_LOOKUP): 1741 *parseArrayOffset = 0x16; 1742 return CC_PC_GENERIC_IC_HASH_INDEXED; 1743 1744 default: 1745 REPORT_ERROR(MAJOR, E_INVALID_VALUE, ("Illegal 'extract from' src")); 1746 break; 1747 } 1748 } 1749 1750 return CC_PC_ILLEGAL; 1751 } 1752 1753 static uint8_t GetFullFieldParseCode(e_NetHeaderType hdr, e_FmPcdHdrIndex index, 1754 t_FmPcdFields field) 1755 { 1756 switch (hdr) 1757 { 1758 case (HEADER_TYPE_NONE): 1759 ASSERT_COND(FALSE); 1760 return CC_PC_ILLEGAL; 1761 1762 case (HEADER_TYPE_ETH): 1763 switch (field.eth) 1764 { 1765 case (NET_HEADER_FIELD_ETH_DA): 1766 return CC_PC_FF_MACDST; 1767 case (NET_HEADER_FIELD_ETH_SA): 1768 return CC_PC_FF_MACSRC; 1769 case (NET_HEADER_FIELD_ETH_TYPE): 1770 return CC_PC_FF_ETYPE; 1771 default: 1772 REPORT_ERROR(MAJOR, E_NOT_SUPPORTED, ("Extraction not supported")); 1773 return CC_PC_ILLEGAL; 1774 } 1775 1776 case (HEADER_TYPE_VLAN): 1777 switch (field.vlan) 1778 { 1779 case (NET_HEADER_FIELD_VLAN_TCI): 1780 if ((index == e_FM_PCD_HDR_INDEX_NONE) 1781 || (index == e_FM_PCD_HDR_INDEX_1)) 1782 return CC_PC_FF_TCI1; 1783 if (index == e_FM_PCD_HDR_INDEX_LAST) 1784 return CC_PC_FF_TCI2; 1785 REPORT_ERROR(MAJOR, E_NOT_SUPPORTED, ("Extraction not supported")); 1786 return CC_PC_ILLEGAL; 1787 default: 1788 REPORT_ERROR(MAJOR, E_NOT_SUPPORTED, ("Extraction not supported")); 1789 return CC_PC_ILLEGAL; 1790 } 1791 1792 case (HEADER_TYPE_MPLS): 1793 switch (field.mpls) 1794 { 1795 case (NET_HEADER_FIELD_MPLS_LABEL_STACK): 1796 if ((index == e_FM_PCD_HDR_INDEX_NONE) 1797 || (index == e_FM_PCD_HDR_INDEX_1)) 1798 return CC_PC_FF_MPLS1; 1799 if (index == e_FM_PCD_HDR_INDEX_LAST) 1800 return CC_PC_FF_MPLS_LAST; 1801 REPORT_ERROR(MAJOR, E_NOT_SUPPORTED, ("Illegal MPLS index")); 1802 return CC_PC_ILLEGAL; 1803 default: 1804 REPORT_ERROR(MAJOR, E_NOT_SUPPORTED, ("Extraction not supported")); 1805 return CC_PC_ILLEGAL; 1806 } 1807 1808 case (HEADER_TYPE_IPv4): 1809 switch (field.ipv4) 1810 { 1811 case (NET_HEADER_FIELD_IPv4_DST_IP): 1812 if ((index == e_FM_PCD_HDR_INDEX_NONE) 1813 || (index == e_FM_PCD_HDR_INDEX_1)) 1814 return CC_PC_FF_IPV4DST1; 1815 if (index == e_FM_PCD_HDR_INDEX_2) 1816 return CC_PC_FF_IPV4DST2; 1817 REPORT_ERROR(MAJOR, E_NOT_SUPPORTED, ("Illegal IPv4 index")); 1818 return CC_PC_ILLEGAL; 1819 case (NET_HEADER_FIELD_IPv4_TOS): 1820 if ((index == e_FM_PCD_HDR_INDEX_NONE) 1821 || (index == e_FM_PCD_HDR_INDEX_1)) 1822 return CC_PC_FF_IPV4IPTOS_TC1; 1823 if (index == e_FM_PCD_HDR_INDEX_2) 1824 return CC_PC_FF_IPV4IPTOS_TC2; 1825 REPORT_ERROR(MAJOR, E_NOT_SUPPORTED, ("Illegal IPv4 index")); 1826 return CC_PC_ILLEGAL; 1827 case (NET_HEADER_FIELD_IPv4_PROTO): 1828 if ((index == e_FM_PCD_HDR_INDEX_NONE) 1829 || (index == e_FM_PCD_HDR_INDEX_1)) 1830 return CC_PC_FF_IPV4PTYPE1; 1831 if (index == e_FM_PCD_HDR_INDEX_2) 1832 return CC_PC_FF_IPV4PTYPE2; 1833 REPORT_ERROR(MAJOR, E_NOT_SUPPORTED, ("Illegal IPv4 index")); 1834 return CC_PC_ILLEGAL; 1835 case (NET_HEADER_FIELD_IPv4_SRC_IP): 1836 if ((index == e_FM_PCD_HDR_INDEX_NONE) 1837 || (index == e_FM_PCD_HDR_INDEX_1)) 1838 return CC_PC_FF_IPV4SRC1; 1839 if (index == e_FM_PCD_HDR_INDEX_2) 1840 return CC_PC_FF_IPV4SRC2; 1841 REPORT_ERROR(MAJOR, E_NOT_SUPPORTED, ("Illegal IPv4 index")); 1842 return CC_PC_ILLEGAL; 1843 case (NET_HEADER_FIELD_IPv4_SRC_IP 1844 | NET_HEADER_FIELD_IPv4_DST_IP): 1845 if ((index == e_FM_PCD_HDR_INDEX_NONE) 1846 || (index == e_FM_PCD_HDR_INDEX_1)) 1847 return CC_PC_FF_IPV4SRC1_IPV4DST1; 1848 if (index == e_FM_PCD_HDR_INDEX_2) 1849 return CC_PC_FF_IPV4SRC2_IPV4DST2; 1850 REPORT_ERROR(MAJOR, E_NOT_SUPPORTED, ("Illegal IPv4 index")); 1851 return CC_PC_ILLEGAL; 1852 case (NET_HEADER_FIELD_IPv4_TTL): 1853 return CC_PC_FF_IPV4TTL; 1854 default: 1855 REPORT_ERROR(MAJOR, E_NOT_SUPPORTED, ("Extraction not supported")); 1856 return CC_PC_ILLEGAL; 1857 } 1858 1859 case (HEADER_TYPE_IPv6): 1860 switch (field.ipv6) 1861 { 1862 case (NET_HEADER_FIELD_IPv6_VER | NET_HEADER_FIELD_IPv6_FL 1863 | NET_HEADER_FIELD_IPv6_TC): 1864 if ((index == e_FM_PCD_HDR_INDEX_NONE) 1865 || (index == e_FM_PCD_HDR_INDEX_1)) 1866 return CC_PC_FF_IPTOS_IPV6TC1_IPV6FLOW1; 1867 if (index == e_FM_PCD_HDR_INDEX_2) 1868 return CC_PC_FF_IPTOS_IPV6TC2_IPV6FLOW2; 1869 REPORT_ERROR(MAJOR, E_NOT_SUPPORTED, ("Illegal IPv6 index")); 1870 return CC_PC_ILLEGAL; 1871 1872 case (NET_HEADER_FIELD_IPv6_NEXT_HDR): 1873 if ((index == e_FM_PCD_HDR_INDEX_NONE) 1874 || (index == e_FM_PCD_HDR_INDEX_1)) 1875 return CC_PC_FF_IPV6PTYPE1; 1876 if (index == e_FM_PCD_HDR_INDEX_2) 1877 return CC_PC_FF_IPV6PTYPE2; 1878 if (index == e_FM_PCD_HDR_INDEX_LAST) 1879 return CC_PC_FF_IPPID; 1880 REPORT_ERROR(MAJOR, E_NOT_SUPPORTED, ("Illegal IPv6 index")); 1881 return CC_PC_ILLEGAL; 1882 1883 case (NET_HEADER_FIELD_IPv6_DST_IP): 1884 if ((index == e_FM_PCD_HDR_INDEX_NONE) 1885 || (index == e_FM_PCD_HDR_INDEX_1)) 1886 return CC_PC_FF_IPV6DST1; 1887 if (index == e_FM_PCD_HDR_INDEX_2) 1888 return CC_PC_FF_IPV6DST2; 1889 REPORT_ERROR(MAJOR, E_NOT_SUPPORTED, ("Illegal IPv6 index")); 1890 return CC_PC_ILLEGAL; 1891 1892 case (NET_HEADER_FIELD_IPv6_SRC_IP): 1893 if ((index == e_FM_PCD_HDR_INDEX_NONE) 1894 || (index == e_FM_PCD_HDR_INDEX_1)) 1895 return CC_PC_FF_IPV6SRC1; 1896 if (index == e_FM_PCD_HDR_INDEX_2) 1897 return CC_PC_FF_IPV6SRC2; 1898 REPORT_ERROR(MAJOR, E_NOT_SUPPORTED, ("Illegal IPv6 index")); 1899 return CC_PC_ILLEGAL; 1900 1901 case (NET_HEADER_FIELD_IPv6_HOP_LIMIT): 1902 return CC_PC_FF_IPV6HOP_LIMIT; 1903 1904 default: 1905 REPORT_ERROR(MAJOR, E_NOT_SUPPORTED, ("Extraction not supported")); 1906 return CC_PC_ILLEGAL; 1907 } 1908 1909 case (HEADER_TYPE_IP): 1910 switch (field.ip) 1911 { 1912 case (NET_HEADER_FIELD_IP_DSCP): 1913 if ((index == e_FM_PCD_HDR_INDEX_NONE) 1914 || (index == e_FM_PCD_HDR_INDEX_1)) 1915 return CC_PC_FF_IPDSCP; 1916 REPORT_ERROR(MAJOR, E_NOT_SUPPORTED, ("Illegal IP index")); 1917 return CC_PC_ILLEGAL; 1918 1919 case (NET_HEADER_FIELD_IP_PROTO): 1920 if (index == e_FM_PCD_HDR_INDEX_LAST) 1921 return CC_PC_FF_IPPID; 1922 REPORT_ERROR(MAJOR, E_NOT_SUPPORTED, ("Illegal IP index")); 1923 return CC_PC_ILLEGAL; 1924 1925 default: 1926 REPORT_ERROR(MAJOR, E_NOT_SUPPORTED, ("Extraction not supported")); 1927 return CC_PC_ILLEGAL; 1928 } 1929 1930 case (HEADER_TYPE_GRE): 1931 switch (field.gre) 1932 { 1933 case (NET_HEADER_FIELD_GRE_TYPE): 1934 return CC_PC_FF_GREPTYPE; 1935 1936 default: 1937 REPORT_ERROR(MAJOR, E_NOT_SUPPORTED, ("Extraction not supported")); 1938 return CC_PC_ILLEGAL; 1939 } 1940 1941 case (HEADER_TYPE_MINENCAP): 1942 switch (field.minencap) 1943 { 1944 case (NET_HEADER_FIELD_MINENCAP_TYPE): 1945 return CC_PC_FF_MINENCAP_PTYPE; 1946 1947 case (NET_HEADER_FIELD_MINENCAP_DST_IP): 1948 return CC_PC_FF_MINENCAP_IPDST; 1949 1950 case (NET_HEADER_FIELD_MINENCAP_SRC_IP): 1951 return CC_PC_FF_MINENCAP_IPSRC; 1952 1953 case (NET_HEADER_FIELD_MINENCAP_SRC_IP 1954 | NET_HEADER_FIELD_MINENCAP_DST_IP): 1955 return CC_PC_FF_MINENCAP_IPSRC_IPDST; 1956 1957 default: 1958 REPORT_ERROR(MAJOR, E_NOT_SUPPORTED, ("Extraction not supported")); 1959 return CC_PC_ILLEGAL; 1960 } 1961 1962 case (HEADER_TYPE_TCP): 1963 switch (field.tcp) 1964 { 1965 case (NET_HEADER_FIELD_TCP_PORT_SRC): 1966 return CC_PC_FF_L4PSRC; 1967 1968 case (NET_HEADER_FIELD_TCP_PORT_DST): 1969 return CC_PC_FF_L4PDST; 1970 1971 case (NET_HEADER_FIELD_TCP_PORT_DST 1972 | NET_HEADER_FIELD_TCP_PORT_SRC): 1973 return CC_PC_FF_L4PSRC_L4PDST; 1974 1975 default: 1976 REPORT_ERROR(MAJOR, E_NOT_SUPPORTED, ("Extraction not supported")); 1977 return CC_PC_ILLEGAL; 1978 } 1979 1980 case (HEADER_TYPE_PPPoE): 1981 switch (field.pppoe) 1982 { 1983 case (NET_HEADER_FIELD_PPPoE_PID): 1984 return CC_PC_FF_PPPPID; 1985 1986 default: 1987 REPORT_ERROR(MAJOR, E_NOT_SUPPORTED, ("Extraction not supported")); 1988 return CC_PC_ILLEGAL; 1989 } 1990 1991 case (HEADER_TYPE_UDP): 1992 switch (field.udp) 1993 { 1994 case (NET_HEADER_FIELD_UDP_PORT_SRC): 1995 return CC_PC_FF_L4PSRC; 1996 1997 case (NET_HEADER_FIELD_UDP_PORT_DST): 1998 return CC_PC_FF_L4PDST; 1999 2000 case (NET_HEADER_FIELD_UDP_PORT_DST 2001 | NET_HEADER_FIELD_UDP_PORT_SRC): 2002 return CC_PC_FF_L4PSRC_L4PDST; 2003 2004 default: 2005 REPORT_ERROR(MAJOR, E_NOT_SUPPORTED, ("Extraction not supported")); 2006 return CC_PC_ILLEGAL; 2007 } 2008 2009 default: 2010 REPORT_ERROR(MAJOR, E_NOT_SUPPORTED, ("Extraction not supported")); 2011 return CC_PC_ILLEGAL; 2012 } 2013 } 2014 2015 static uint8_t GetPrParseCode(e_NetHeaderType hdr, e_FmPcdHdrIndex hdrIndex, 2016 uint32_t offset, bool glblMask, 2017 uint8_t *parseArrayOffset) 2018 { 2019 bool offsetRelevant = FALSE; 2020 2021 if (offset) 2022 offsetRelevant = TRUE; 2023 2024 switch (hdr) 2025 { 2026 case (HEADER_TYPE_NONE): 2027 ASSERT_COND(FALSE); 2028 return CC_PC_ILLEGAL; 2029 2030 case (HEADER_TYPE_ETH): 2031 *parseArrayOffset = (uint8_t)CC_PC_PR_ETH_OFFSET; 2032 break; 2033 2034 case (HEADER_TYPE_USER_DEFINED_SHIM1): 2035 if (offset || glblMask) 2036 *parseArrayOffset = (uint8_t)CC_PC_PR_USER_DEFINED_SHIM1_OFFSET; 2037 else 2038 return CC_PC_PR_SHIM1; 2039 break; 2040 2041 case (HEADER_TYPE_USER_DEFINED_SHIM2): 2042 if (offset || glblMask) 2043 *parseArrayOffset = (uint8_t)CC_PC_PR_USER_DEFINED_SHIM2_OFFSET; 2044 else 2045 return CC_PC_PR_SHIM2; 2046 break; 2047 2048 case (HEADER_TYPE_LLC_SNAP): 2049 *parseArrayOffset = CC_PC_PR_USER_LLC_SNAP_OFFSET; 2050 break; 2051 2052 case (HEADER_TYPE_PPPoE): 2053 *parseArrayOffset = CC_PC_PR_PPPOE_OFFSET; 2054 break; 2055 2056 case (HEADER_TYPE_MPLS): 2057 if ((hdrIndex == e_FM_PCD_HDR_INDEX_NONE) 2058 || (hdrIndex == e_FM_PCD_HDR_INDEX_1)) 2059 *parseArrayOffset = CC_PC_PR_MPLS1_OFFSET; 2060 else 2061 if (hdrIndex == e_FM_PCD_HDR_INDEX_LAST) 2062 *parseArrayOffset = CC_PC_PR_MPLS_LAST_OFFSET; 2063 else 2064 { 2065 REPORT_ERROR(MAJOR, E_NOT_SUPPORTED, ("Illegal MPLS header index")); 2066 return CC_PC_ILLEGAL; 2067 } 2068 break; 2069 2070 case (HEADER_TYPE_IPv4): 2071 case (HEADER_TYPE_IPv6): 2072 if ((hdrIndex == e_FM_PCD_HDR_INDEX_NONE) 2073 || (hdrIndex == e_FM_PCD_HDR_INDEX_1)) 2074 *parseArrayOffset = CC_PC_PR_IP1_OFFSET; 2075 else 2076 if (hdrIndex == e_FM_PCD_HDR_INDEX_2) 2077 *parseArrayOffset = CC_PC_PR_IP_LAST_OFFSET; 2078 else 2079 { 2080 REPORT_ERROR(MAJOR, E_NOT_SUPPORTED, ("Illegal IP header index")); 2081 return CC_PC_ILLEGAL; 2082 } 2083 break; 2084 2085 case (HEADER_TYPE_MINENCAP): 2086 *parseArrayOffset = CC_PC_PR_MINENC_OFFSET; 2087 break; 2088 2089 case (HEADER_TYPE_GRE): 2090 *parseArrayOffset = CC_PC_PR_GRE_OFFSET; 2091 break; 2092 2093 case (HEADER_TYPE_TCP): 2094 case (HEADER_TYPE_UDP): 2095 case (HEADER_TYPE_IPSEC_AH): 2096 case (HEADER_TYPE_IPSEC_ESP): 2097 case (HEADER_TYPE_DCCP): 2098 case (HEADER_TYPE_SCTP): 2099 *parseArrayOffset = CC_PC_PR_L4_OFFSET; 2100 break; 2101 2102 default: 2103 REPORT_ERROR(MAJOR, E_NOT_SUPPORTED, ("Illegal IP header for this type of operation")); 2104 return CC_PC_ILLEGAL; 2105 } 2106 2107 if (offsetRelevant) 2108 return CC_PR_OFFSET; 2109 else 2110 return CC_PR_WITHOUT_OFFSET; 2111 } 2112 2113 static uint8_t GetFieldParseCode(e_NetHeaderType hdr, t_FmPcdFields field, 2114 uint32_t offset, uint8_t *parseArrayOffset, 2115 e_FmPcdHdrIndex hdrIndex) 2116 { 2117 bool offsetRelevant = FALSE; 2118 2119 if (offset) 2120 offsetRelevant = TRUE; 2121 2122 switch (hdr) 2123 { 2124 case (HEADER_TYPE_NONE): 2125 ASSERT_COND(FALSE); 2126 break; 2127 case (HEADER_TYPE_ETH): 2128 switch (field.eth) 2129 { 2130 case (NET_HEADER_FIELD_ETH_TYPE): 2131 *parseArrayOffset = CC_PC_PR_ETYPE_LAST_OFFSET; 2132 break; 2133 2134 default: 2135 REPORT_ERROR(MAJOR, E_NOT_SUPPORTED, ("Extraction not supported")); 2136 return CC_PC_ILLEGAL; 2137 } 2138 break; 2139 2140 case (HEADER_TYPE_VLAN): 2141 switch (field.vlan) 2142 { 2143 case (NET_HEADER_FIELD_VLAN_TCI): 2144 if ((hdrIndex == e_FM_PCD_HDR_INDEX_NONE) 2145 || (hdrIndex == e_FM_PCD_HDR_INDEX_1)) 2146 *parseArrayOffset = CC_PC_PR_VLAN1_OFFSET; 2147 else 2148 if (hdrIndex == e_FM_PCD_HDR_INDEX_LAST) 2149 *parseArrayOffset = CC_PC_PR_VLAN2_OFFSET; 2150 break; 2151 2152 default: 2153 REPORT_ERROR(MAJOR, E_NOT_SUPPORTED, ("Extraction not supported")); 2154 return CC_PC_ILLEGAL; 2155 } 2156 break; 2157 2158 default: 2159 REPORT_ERROR(MAJOR, E_NOT_SUPPORTED, ("Illegal header ")); 2160 return CC_PC_ILLEGAL; 2161 } 2162 2163 if (offsetRelevant) 2164 return CC_PR_OFFSET; 2165 else 2166 return CC_PR_WITHOUT_OFFSET; 2167 } 2168 2169 static void FillAdOfTypeResult(t_Handle h_Ad, 2170 t_FmPcdCcStatsParams *p_FmPcdCcStatsParams, 2171 t_FmPcd *p_FmPcd, 2172 t_FmPcdCcNextEngineParams *p_CcNextEngineParams) 2173 { 2174 t_AdOfTypeResult *p_AdResult = (t_AdOfTypeResult *)h_Ad; 2175 t_Handle h_TmpAd; 2176 uint32_t tmp = 0, tmpNia = 0; 2177 uint16_t profileId; 2178 t_Handle p_AdNewPtr = NULL; 2179 t_Error err = E_OK; 2180 2181 /* There are 3 cases handled in this routine of building a "result" type AD. 2182 * Case 1: No Manip. The action descriptor is built within the match table. 2183 * Case 2: Manip exists. A new AD is created - p_AdNewPtr. It is initialized 2184 * either in the FmPcdManipUpdateAdResultForCc routine or it was already 2185 * initialized and returned here. 2186 * p_AdResult (within the match table) will be initialized after 2187 * this routine returns and point to the existing AD. 2188 * Case 3: Manip exists. The action descriptor is built within the match table. 2189 * FmPcdManipUpdateAdResultForCc returns a NULL p_AdNewPtr. 2190 * 2191 * If statistics were enabled and the statistics mode of this node requires 2192 * a statistics Ad, it will be placed after the result Ad and before the 2193 * manip Ad, if manip Ad exists here. 2194 */ 2195 2196 /* As default, the "new" ptr is the current one. i.e. the content of the result 2197 * AD will be written into the match table itself (case (1))*/ 2198 p_AdNewPtr = p_AdResult; 2199 2200 /* Initialize an action descriptor, if current statistics mode requires an Ad */ 2201 if (p_FmPcdCcStatsParams) 2202 { 2203 ASSERT_COND(p_FmPcdCcStatsParams->h_StatsAd); 2204 ASSERT_COND(p_FmPcdCcStatsParams->h_StatsCounters); 2205 2206 /* Swapping addresses between statistics Ad and the current lookup AD addresses */ 2207 h_TmpAd = p_FmPcdCcStatsParams->h_StatsAd; 2208 p_FmPcdCcStatsParams->h_StatsAd = h_Ad; 2209 h_Ad = h_TmpAd; 2210 2211 p_AdNewPtr = h_Ad; 2212 p_AdResult = h_Ad; 2213 2214 /* Init statistics Ad and connect current lookup AD as 'next action' from statistics Ad */ 2215 UpdateStatsAd(p_FmPcdCcStatsParams, h_Ad, p_FmPcd->physicalMuramBase); 2216 } 2217 2218 /* Create manip and return p_AdNewPtr to either a new descriptor or NULL */ 2219 if (p_CcNextEngineParams->h_Manip) 2220 FmPcdManipUpdateAdResultForCc(p_CcNextEngineParams->h_Manip, 2221 p_CcNextEngineParams, h_Ad, &p_AdNewPtr); 2222 2223 /* if (p_AdNewPtr = NULL) --> Done. (case (3)) */ 2224 if (p_AdNewPtr) 2225 { 2226 /* case (1) and (2) */ 2227 switch (p_CcNextEngineParams->nextEngine) 2228 { 2229 case (e_FM_PCD_DONE): 2230 if (p_CcNextEngineParams->params.enqueueParams.action 2231 == e_FM_PCD_ENQ_FRAME) 2232 { 2233 if (p_CcNextEngineParams->params.enqueueParams.overrideFqid) 2234 { 2235 tmp = FM_PCD_AD_RESULT_CONTRL_FLOW_TYPE; 2236 tmp |= 2237 p_CcNextEngineParams->params.enqueueParams.newFqid; 2238 #if (DPAA_VERSION >= 11) 2239 tmp |= 2240 (p_CcNextEngineParams->params.enqueueParams.newRelativeStorageProfileId 2241 & FM_PCD_AD_RESULT_VSP_MASK) 2242 << FM_PCD_AD_RESULT_VSP_SHIFT; 2243 #endif /* (DPAA_VERSION >= 11) */ 2244 } 2245 else 2246 { 2247 tmp = FM_PCD_AD_RESULT_DATA_FLOW_TYPE; 2248 tmp |= FM_PCD_AD_RESULT_PLCR_DIS; 2249 } 2250 } 2251 2252 if (p_CcNextEngineParams->params.enqueueParams.action 2253 == e_FM_PCD_DROP_FRAME) 2254 tmpNia |= GET_NIA_BMI_AC_DISCARD_FRAME(p_FmPcd); 2255 else 2256 tmpNia |= GET_NIA_BMI_AC_ENQ_FRAME(p_FmPcd); 2257 break; 2258 2259 case (e_FM_PCD_KG): 2260 if (p_CcNextEngineParams->params.kgParams.overrideFqid) 2261 { 2262 tmp = FM_PCD_AD_RESULT_CONTRL_FLOW_TYPE; 2263 tmp |= p_CcNextEngineParams->params.kgParams.newFqid; 2264 #if (DPAA_VERSION >= 11) 2265 tmp |= 2266 (p_CcNextEngineParams->params.kgParams.newRelativeStorageProfileId 2267 & FM_PCD_AD_RESULT_VSP_MASK) 2268 << FM_PCD_AD_RESULT_VSP_SHIFT; 2269 #endif /* (DPAA_VERSION >= 11) */ 2270 } 2271 else 2272 { 2273 tmp = FM_PCD_AD_RESULT_DATA_FLOW_TYPE; 2274 tmp |= FM_PCD_AD_RESULT_PLCR_DIS; 2275 } 2276 tmpNia = NIA_KG_DIRECT; 2277 tmpNia |= NIA_ENG_KG; 2278 tmpNia |= NIA_KG_CC_EN; 2279 tmpNia |= FmPcdKgGetSchemeId( 2280 p_CcNextEngineParams->params.kgParams.h_DirectScheme); 2281 break; 2282 2283 case (e_FM_PCD_PLCR): 2284 if (p_CcNextEngineParams->params.plcrParams.overrideParams) 2285 { 2286 tmp = FM_PCD_AD_RESULT_CONTRL_FLOW_TYPE; 2287 2288 /* if private policer profile, it may be uninitialized yet, therefore no checks are done at this stage */ 2289 if (p_CcNextEngineParams->params.plcrParams.sharedProfile) 2290 { 2291 tmpNia |= NIA_PLCR_ABSOLUTE; 2292 err = FmPcdPlcrGetAbsoluteIdByProfileParams( 2293 (t_Handle)p_FmPcd, 2294 e_FM_PCD_PLCR_SHARED, 2295 NULL, 2296 p_CcNextEngineParams->params.plcrParams.newRelativeProfileId, 2297 &profileId); 2298 if (err != E_OK) 2299 return; 2300 2301 } 2302 else 2303 profileId = 2304 p_CcNextEngineParams->params.plcrParams.newRelativeProfileId; 2305 2306 tmp |= p_CcNextEngineParams->params.plcrParams.newFqid; 2307 #if (DPAA_VERSION >= 11) 2308 tmp |= 2309 (p_CcNextEngineParams->params.plcrParams.newRelativeStorageProfileId 2310 & FM_PCD_AD_RESULT_VSP_MASK) 2311 << FM_PCD_AD_RESULT_VSP_SHIFT; 2312 #endif /* (DPAA_VERSION >= 11) */ 2313 WRITE_UINT32( 2314 p_AdResult->plcrProfile, 2315 (uint32_t)((uint32_t)profileId << FM_PCD_AD_PROFILEID_FOR_CNTRL_SHIFT)); 2316 } 2317 else 2318 tmp = FM_PCD_AD_RESULT_DATA_FLOW_TYPE; 2319 2320 tmpNia |= 2321 NIA_ENG_PLCR 2322 | p_CcNextEngineParams->params.plcrParams.newRelativeProfileId; 2323 break; 2324 2325 default: 2326 return; 2327 }WRITE_UINT32(p_AdResult->fqid, tmp); 2328 2329 if (p_CcNextEngineParams->h_Manip) 2330 { 2331 tmp = GET_UINT32(p_AdResult->plcrProfile); 2332 tmp |= (uint32_t)(XX_VirtToPhys(p_AdNewPtr) 2333 - (p_FmPcd->physicalMuramBase)) >> 4; 2334 WRITE_UINT32(p_AdResult->plcrProfile, tmp); 2335 2336 tmpNia |= FM_PCD_AD_RESULT_EXTENDED_MODE; 2337 tmpNia |= FM_PCD_AD_RESULT_NADEN; 2338 } 2339 2340 #if (DPAA_VERSION >= 11) 2341 tmpNia |= FM_PCD_AD_RESULT_NO_OM_VSPE; 2342 #endif /* (DPAA_VERSION >= 11) */ 2343 WRITE_UINT32(p_AdResult->nia, tmpNia); 2344 } 2345 } 2346 2347 static t_Error CcUpdateParams(t_Handle h_FmPcd, t_Handle h_PcdParams, 2348 t_Handle h_FmPort, t_Handle h_FmTree, 2349 bool validate) 2350 { 2351 t_FmPcdCcTree *p_CcTree = (t_FmPcdCcTree *)h_FmTree; 2352 2353 return CcUpdateParam(h_FmPcd, h_PcdParams, h_FmPort, 2354 p_CcTree->keyAndNextEngineParams, 2355 p_CcTree->numOfEntries, 2356 UINT_TO_PTR(p_CcTree->ccTreeBaseAddr), validate, 0, 2357 h_FmTree, FALSE); 2358 } 2359 2360 2361 static void ReleaseNewNodeCommonPart( 2362 t_FmPcdModifyCcKeyAdditionalParams *p_AdditionalInfo) 2363 { 2364 if (p_AdditionalInfo->p_AdTableNew) 2365 FM_MURAM_FreeMem( 2366 FmPcdGetMuramHandle( 2367 ((t_FmPcdCcNode *)(p_AdditionalInfo->h_CurrentNode))->h_FmPcd), 2368 p_AdditionalInfo->p_AdTableNew); 2369 2370 if (p_AdditionalInfo->p_KeysMatchTableNew) 2371 FM_MURAM_FreeMem( 2372 FmPcdGetMuramHandle( 2373 ((t_FmPcdCcNode *)(p_AdditionalInfo->h_CurrentNode))->h_FmPcd), 2374 p_AdditionalInfo->p_KeysMatchTableNew); 2375 } 2376 2377 static t_Error UpdateGblMask(t_FmPcdCcNode *p_CcNode, uint8_t keySize, 2378 uint8_t *p_Mask) 2379 { 2380 uint8_t prvGlblMaskSize = p_CcNode->glblMaskSize; 2381 2382 if (p_Mask && !p_CcNode->glblMaskUpdated && (keySize <= 4) 2383 && !p_CcNode->lclMask) 2384 { 2385 if (p_CcNode->parseCode && (p_CcNode->parseCode != CC_PC_FF_TCI1) 2386 && (p_CcNode->parseCode != CC_PC_FF_TCI2) 2387 && (p_CcNode->parseCode != CC_PC_FF_MPLS1) 2388 && (p_CcNode->parseCode != CC_PC_FF_MPLS_LAST) 2389 && (p_CcNode->parseCode != CC_PC_FF_IPV4IPTOS_TC1) 2390 && (p_CcNode->parseCode != CC_PC_FF_IPV4IPTOS_TC2) 2391 && (p_CcNode->parseCode != CC_PC_FF_IPTOS_IPV6TC1_IPV6FLOW1) 2392 && (p_CcNode->parseCode != CC_PC_FF_IPDSCP) 2393 && (p_CcNode->parseCode != CC_PC_FF_IPTOS_IPV6TC2_IPV6FLOW2)) 2394 { 2395 p_CcNode->glblMaskSize = 0; 2396 p_CcNode->lclMask = TRUE; 2397 } 2398 else 2399 { 2400 memcpy(p_CcNode->p_GlblMask, p_Mask, (sizeof(uint8_t)) * keySize); 2401 p_CcNode->glblMaskUpdated = TRUE; 2402 p_CcNode->glblMaskSize = 4; 2403 } 2404 } 2405 else 2406 if (p_Mask && (keySize <= 4) && !p_CcNode->lclMask) 2407 { 2408 if (memcmp(p_CcNode->p_GlblMask, p_Mask, keySize) != 0) 2409 { 2410 p_CcNode->lclMask = TRUE; 2411 p_CcNode->glblMaskSize = 0; 2412 } 2413 } 2414 else 2415 if (!p_Mask && p_CcNode->glblMaskUpdated && (keySize <= 4)) 2416 { 2417 uint32_t tmpMask = 0xffffffff; 2418 if (memcmp(p_CcNode->p_GlblMask, &tmpMask, 4) != 0) 2419 { 2420 p_CcNode->lclMask = TRUE; 2421 p_CcNode->glblMaskSize = 0; 2422 } 2423 } 2424 else 2425 if (p_Mask) 2426 { 2427 p_CcNode->lclMask = TRUE; 2428 p_CcNode->glblMaskSize = 0; 2429 } 2430 2431 /* In static mode (maxNumOfKeys > 0), local mask is supported 2432 only is mask support was enabled at initialization */ 2433 if (p_CcNode->maxNumOfKeys && (!p_CcNode->maskSupport) && p_CcNode->lclMask) 2434 { 2435 p_CcNode->lclMask = FALSE; 2436 p_CcNode->glblMaskSize = prvGlblMaskSize; 2437 return ERROR_CODE(E_NOT_SUPPORTED); 2438 } 2439 2440 return E_OK; 2441 } 2442 2443 static __inline__ t_Handle GetNewAd(t_Handle h_FmPcdCcNodeOrTree, bool isTree) 2444 { 2445 t_FmPcd *p_FmPcd; 2446 t_Handle h_Ad; 2447 2448 if (isTree) 2449 p_FmPcd = (t_FmPcd *)(((t_FmPcdCcTree *)h_FmPcdCcNodeOrTree)->h_FmPcd); 2450 else 2451 p_FmPcd = (t_FmPcd *)(((t_FmPcdCcNode *)h_FmPcdCcNodeOrTree)->h_FmPcd); 2452 2453 if ((isTree && p_FmPcd->p_CcShadow) 2454 || (!isTree && ((t_FmPcdCcNode *)h_FmPcdCcNodeOrTree)->maxNumOfKeys)) 2455 { 2456 /* The allocated shadow is divided as follows: 2457 0 . . . 16 . . . 2458 --------------------------------------------------- 2459 | Shadow | Shadow Keys | Shadow Next | 2460 | Ad | Match Table | Engine Table | 2461 | (16 bytes) | (maximal size) | (maximal size) | 2462 --------------------------------------------------- 2463 */ 2464 if (!p_FmPcd->p_CcShadow) 2465 { 2466 REPORT_ERROR(MAJOR, E_NO_MEMORY, ("CC Shadow not allocated")); 2467 return NULL; 2468 } 2469 2470 h_Ad = p_FmPcd->p_CcShadow; 2471 } 2472 else 2473 { 2474 h_Ad = (t_Handle)FM_MURAM_AllocMem(FmPcdGetMuramHandle(p_FmPcd), 2475 FM_PCD_CC_AD_ENTRY_SIZE, 2476 FM_PCD_CC_AD_TABLE_ALIGN); 2477 if (!h_Ad) 2478 { 2479 REPORT_ERROR(MAJOR, E_NO_MEMORY, ("MURAM allocation for CC node action descriptor")); 2480 return NULL; 2481 } 2482 } 2483 2484 return h_Ad; 2485 } 2486 2487 static t_Error BuildNewNodeCommonPart( 2488 t_FmPcdCcNode *p_CcNode, int *size, 2489 t_FmPcdModifyCcKeyAdditionalParams *p_AdditionalInfo) 2490 { 2491 t_FmPcd *p_FmPcd = (t_FmPcd *)p_CcNode->h_FmPcd; 2492 2493 if (p_CcNode->lclMask) 2494 *size = 2 * p_CcNode->ccKeySizeAccExtraction; 2495 else 2496 *size = p_CcNode->ccKeySizeAccExtraction; 2497 2498 if (p_CcNode->maxNumOfKeys == 0) 2499 { 2500 p_AdditionalInfo->p_AdTableNew = (t_Handle)FM_MURAM_AllocMem( 2501 FmPcdGetMuramHandle(p_FmPcd), 2502 (uint32_t)((p_AdditionalInfo->numOfKeys + 1) 2503 * FM_PCD_CC_AD_ENTRY_SIZE), 2504 FM_PCD_CC_AD_TABLE_ALIGN); 2505 if (!p_AdditionalInfo->p_AdTableNew) 2506 RETURN_ERROR( 2507 MAJOR, E_NO_MEMORY, 2508 ("MURAM allocation for CC node action descriptors table")); 2509 2510 p_AdditionalInfo->p_KeysMatchTableNew = (t_Handle)FM_MURAM_AllocMem( 2511 FmPcdGetMuramHandle(p_FmPcd), 2512 (uint32_t)(*size * sizeof(uint8_t) 2513 * (p_AdditionalInfo->numOfKeys + 1)), 2514 FM_PCD_CC_KEYS_MATCH_TABLE_ALIGN); 2515 if (!p_AdditionalInfo->p_KeysMatchTableNew) 2516 { 2517 FM_MURAM_FreeMem(FmPcdGetMuramHandle(p_CcNode->h_FmPcd), 2518 p_AdditionalInfo->p_AdTableNew); 2519 p_AdditionalInfo->p_AdTableNew = NULL; 2520 RETURN_ERROR(MAJOR, E_NO_MEMORY, 2521 ("MURAM allocation for CC node key match table")); 2522 } 2523 2524 MemSet8( 2525 (uint8_t*)p_AdditionalInfo->p_AdTableNew, 2526 0, 2527 (uint32_t)((p_AdditionalInfo->numOfKeys + 1) 2528 * FM_PCD_CC_AD_ENTRY_SIZE)); 2529 MemSet8((uint8_t*)p_AdditionalInfo->p_KeysMatchTableNew, 0, 2530 *size * sizeof(uint8_t) * (p_AdditionalInfo->numOfKeys + 1)); 2531 } 2532 else 2533 { 2534 /* The allocated shadow is divided as follows: 2535 0 . . . 16 . . . 2536 --------------------------------------------------- 2537 | Shadow | Shadow Keys | Shadow Next | 2538 | Ad | Match Table | Engine Table | 2539 | (16 bytes) | (maximal size) | (maximal size) | 2540 --------------------------------------------------- 2541 */ 2542 2543 if (!p_FmPcd->p_CcShadow) 2544 RETURN_ERROR(MAJOR, E_NO_MEMORY, ("CC Shadow not allocated")); 2545 2546 p_AdditionalInfo->p_KeysMatchTableNew = 2547 PTR_MOVE(p_FmPcd->p_CcShadow, FM_PCD_CC_AD_ENTRY_SIZE); 2548 p_AdditionalInfo->p_AdTableNew = 2549 PTR_MOVE(p_AdditionalInfo->p_KeysMatchTableNew, p_CcNode->keysMatchTableMaxSize); 2550 2551 MemSet8( 2552 (uint8_t*)p_AdditionalInfo->p_AdTableNew, 2553 0, 2554 (uint32_t)((p_CcNode->maxNumOfKeys + 1) 2555 * FM_PCD_CC_AD_ENTRY_SIZE)); 2556 MemSet8((uint8_t*)p_AdditionalInfo->p_KeysMatchTableNew, 0, 2557 (*size) * sizeof(uint8_t) * (p_CcNode->maxNumOfKeys)); 2558 } 2559 2560 p_AdditionalInfo->p_AdTableOld = p_CcNode->h_AdTable; 2561 p_AdditionalInfo->p_KeysMatchTableOld = p_CcNode->h_KeysMatchTable; 2562 2563 return E_OK; 2564 } 2565 2566 static t_Error BuildNewNodeAddOrMdfyKeyAndNextEngine( 2567 t_Handle h_FmPcd, t_FmPcdCcNode *p_CcNode, uint16_t keyIndex, 2568 t_FmPcdCcKeyParams *p_KeyParams, 2569 t_FmPcdModifyCcKeyAdditionalParams *p_AdditionalInfo, bool add) 2570 { 2571 t_Error err = E_OK; 2572 t_Handle p_AdTableNewTmp, p_KeysMatchTableNewTmp; 2573 t_Handle p_KeysMatchTableOldTmp, p_AdTableOldTmp; 2574 int size; 2575 int i = 0, j = 0; 2576 t_FmPcd *p_FmPcd = (t_FmPcd*)h_FmPcd; 2577 uint32_t requiredAction = 0; 2578 bool prvLclMask; 2579 t_CcNodeInformation *p_CcNodeInformation; 2580 t_FmPcdCcStatsParams statsParams = { 0 }; 2581 t_List *p_Pos; 2582 t_FmPcdStatsObj *p_StatsObj; 2583 2584 /* Check that new NIA is legal */ 2585 err = ValidateNextEngineParams(h_FmPcd, &p_KeyParams->ccNextEngineParams, 2586 p_CcNode->statisticsMode); 2587 if (err) 2588 RETURN_ERROR(MAJOR, err, NO_MSG); 2589 2590 prvLclMask = p_CcNode->lclMask; 2591 2592 /* Check that new key is not require update of localMask */ 2593 err = UpdateGblMask(p_CcNode, p_CcNode->ccKeySizeAccExtraction, 2594 p_KeyParams->p_Mask); 2595 if (err) 2596 RETURN_ERROR(MAJOR, err, (NO_MSG)); 2597 2598 /* Update internal data structure with new next engine for the given index */ 2599 memcpy(&p_AdditionalInfo->keyAndNextEngineParams[keyIndex].nextEngineParams, 2600 &p_KeyParams->ccNextEngineParams, sizeof(t_FmPcdCcNextEngineParams)); 2601 2602 memcpy(p_AdditionalInfo->keyAndNextEngineParams[keyIndex].key, 2603 p_KeyParams->p_Key, p_CcNode->userSizeOfExtraction); 2604 2605 if ((p_AdditionalInfo->keyAndNextEngineParams[keyIndex].nextEngineParams.nextEngine 2606 == e_FM_PCD_CC) 2607 && p_AdditionalInfo->keyAndNextEngineParams[keyIndex].nextEngineParams.h_Manip) 2608 { 2609 err = 2610 AllocAndFillAdForContLookupManip( 2611 p_AdditionalInfo->keyAndNextEngineParams[keyIndex].nextEngineParams.params.ccParams.h_CcNode); 2612 if (err) 2613 RETURN_ERROR(MAJOR, err, (NO_MSG)); 2614 } 2615 2616 if (p_KeyParams->p_Mask) 2617 memcpy(p_AdditionalInfo->keyAndNextEngineParams[keyIndex].mask, 2618 p_KeyParams->p_Mask, p_CcNode->userSizeOfExtraction); 2619 else 2620 memset(p_AdditionalInfo->keyAndNextEngineParams[keyIndex].mask, 0xFF, 2621 p_CcNode->userSizeOfExtraction); 2622 2623 /* Update numOfKeys */ 2624 if (add) 2625 p_AdditionalInfo->numOfKeys = (uint8_t)(p_CcNode->numOfKeys + 1); 2626 else 2627 p_AdditionalInfo->numOfKeys = (uint8_t)p_CcNode->numOfKeys; 2628 2629 /* Allocate new tables in MURAM: keys match table and action descriptors table */ 2630 err = BuildNewNodeCommonPart(p_CcNode, &size, p_AdditionalInfo); 2631 if (err) 2632 RETURN_ERROR(MAJOR, err, NO_MSG); 2633 2634 /* Check that manip is legal and what requiredAction is necessary for this manip */ 2635 if (p_KeyParams->ccNextEngineParams.h_Manip) 2636 { 2637 err = FmPcdManipCheckParamsForCcNextEngine( 2638 &p_KeyParams->ccNextEngineParams, &requiredAction); 2639 if (err) 2640 RETURN_ERROR(MAJOR, err, (NO_MSG)); 2641 } 2642 2643 p_AdditionalInfo->keyAndNextEngineParams[keyIndex].requiredAction = 2644 requiredAction; 2645 p_AdditionalInfo->keyAndNextEngineParams[keyIndex].requiredAction |= 2646 UPDATE_CC_WITH_TREE; 2647 2648 /* Update new Ad and new Key Table according to new requirement */ 2649 i = 0; 2650 for (j = 0; j < p_AdditionalInfo->numOfKeys; j++) 2651 { 2652 p_AdTableNewTmp = 2653 PTR_MOVE(p_AdditionalInfo->p_AdTableNew, j*FM_PCD_CC_AD_ENTRY_SIZE); 2654 2655 if (j == keyIndex) 2656 { 2657 if (p_KeyParams->ccNextEngineParams.statisticsEn) 2658 { 2659 /* Allocate a statistics object that holds statistics AD and counters. 2660 - For added key - New statistics AD and counters pointer need to be allocated 2661 new statistics object. If statistics were enabled, we need to replace the 2662 existing descriptor with a new descriptor with nullified counters. 2663 */ 2664 p_StatsObj = GetStatsObj(p_CcNode); 2665 ASSERT_COND(p_StatsObj); 2666 2667 /* Store allocated statistics object */ 2668 ASSERT_COND(keyIndex < CC_MAX_NUM_OF_KEYS); 2669 p_AdditionalInfo->keyAndNextEngineParams[keyIndex].p_StatsObj = 2670 p_StatsObj; 2671 2672 statsParams.h_StatsAd = p_StatsObj->h_StatsAd; 2673 statsParams.h_StatsCounters = p_StatsObj->h_StatsCounters; 2674 #if (DPAA_VERSION >= 11) 2675 statsParams.h_StatsFLRs = p_CcNode->h_StatsFLRs; 2676 2677 #endif /* (DPAA_VERSION >= 11) */ 2678 2679 /* Building action descriptor for the received new key */ 2680 NextStepAd(p_AdTableNewTmp, &statsParams, 2681 &p_KeyParams->ccNextEngineParams, p_FmPcd); 2682 } 2683 else 2684 { 2685 /* Building action descriptor for the received new key */ 2686 NextStepAd(p_AdTableNewTmp, NULL, 2687 &p_KeyParams->ccNextEngineParams, p_FmPcd); 2688 } 2689 2690 /* Copy the received new key into keys match table */ 2691 p_KeysMatchTableNewTmp = 2692 PTR_MOVE(p_AdditionalInfo->p_KeysMatchTableNew, j*size*sizeof(uint8_t)); 2693 2694 MemCpy8((void*)p_KeysMatchTableNewTmp, p_KeyParams->p_Key, 2695 p_CcNode->userSizeOfExtraction); 2696 2697 /* Update mask for the received new key */ 2698 if (p_CcNode->lclMask) 2699 { 2700 if (p_KeyParams->p_Mask) 2701 { 2702 MemCpy8(PTR_MOVE(p_KeysMatchTableNewTmp, 2703 p_CcNode->ccKeySizeAccExtraction), 2704 p_KeyParams->p_Mask, 2705 p_CcNode->userSizeOfExtraction); 2706 } 2707 else 2708 if (p_CcNode->ccKeySizeAccExtraction > 4) 2709 { 2710 MemSet8(PTR_MOVE(p_KeysMatchTableNewTmp, 2711 p_CcNode->ccKeySizeAccExtraction), 2712 0xff, p_CcNode->userSizeOfExtraction); 2713 } 2714 else 2715 { 2716 MemCpy8(PTR_MOVE(p_KeysMatchTableNewTmp, 2717 p_CcNode->ccKeySizeAccExtraction), 2718 p_CcNode->p_GlblMask, 2719 p_CcNode->userSizeOfExtraction); 2720 } 2721 } 2722 2723 /* If key modification requested, the old entry is omitted and replaced by the new parameters */ 2724 if (!add) 2725 i++; 2726 } 2727 else 2728 { 2729 /* Copy existing action descriptors to the newly allocated Ad table */ 2730 p_AdTableOldTmp = 2731 PTR_MOVE(p_AdditionalInfo->p_AdTableOld, i*FM_PCD_CC_AD_ENTRY_SIZE); 2732 MemCpy8(p_AdTableNewTmp, p_AdTableOldTmp, 2733 FM_PCD_CC_AD_ENTRY_SIZE); 2734 2735 /* Copy existing keys and their masks to the newly allocated keys match table */ 2736 p_KeysMatchTableNewTmp = 2737 PTR_MOVE(p_AdditionalInfo->p_KeysMatchTableNew, j * size * sizeof(uint8_t)); 2738 p_KeysMatchTableOldTmp = 2739 PTR_MOVE(p_AdditionalInfo->p_KeysMatchTableOld, i * size * sizeof(uint8_t)); 2740 2741 if (p_CcNode->lclMask) 2742 { 2743 if (prvLclMask) 2744 { 2745 MemCpy8( 2746 PTR_MOVE(p_KeysMatchTableNewTmp, p_CcNode->ccKeySizeAccExtraction), 2747 PTR_MOVE(p_KeysMatchTableOldTmp, p_CcNode->ccKeySizeAccExtraction), 2748 p_CcNode->ccKeySizeAccExtraction); 2749 } 2750 else 2751 { 2752 p_KeysMatchTableOldTmp = 2753 PTR_MOVE(p_CcNode->h_KeysMatchTable, 2754 i * (int)p_CcNode->ccKeySizeAccExtraction * sizeof(uint8_t)); 2755 2756 if (p_CcNode->ccKeySizeAccExtraction > 4) 2757 { 2758 MemSet8(PTR_MOVE(p_KeysMatchTableNewTmp, 2759 p_CcNode->ccKeySizeAccExtraction), 2760 0xff, p_CcNode->userSizeOfExtraction); 2761 } 2762 else 2763 { 2764 MemCpy8(PTR_MOVE(p_KeysMatchTableNewTmp, 2765 p_CcNode->ccKeySizeAccExtraction), 2766 p_CcNode->p_GlblMask, 2767 p_CcNode->userSizeOfExtraction); 2768 } 2769 } 2770 } 2771 2772 MemCpy8(p_KeysMatchTableNewTmp, p_KeysMatchTableOldTmp, 2773 p_CcNode->ccKeySizeAccExtraction); 2774 2775 i++; 2776 } 2777 } 2778 2779 /* Miss action descriptor */ 2780 p_AdTableNewTmp = 2781 PTR_MOVE(p_AdditionalInfo->p_AdTableNew, j * FM_PCD_CC_AD_ENTRY_SIZE); 2782 p_AdTableOldTmp = 2783 PTR_MOVE(p_AdditionalInfo->p_AdTableOld, i * FM_PCD_CC_AD_ENTRY_SIZE); 2784 MemCpy8(p_AdTableNewTmp, p_AdTableOldTmp, FM_PCD_CC_AD_ENTRY_SIZE); 2785 2786 if (!NCSW_LIST_IsEmpty(&p_CcNode->ccTreesLst)) 2787 { 2788 NCSW_LIST_FOR_EACH(p_Pos, &p_CcNode->ccTreesLst) 2789 { 2790 p_CcNodeInformation = CC_NODE_F_OBJECT(p_Pos); 2791 ASSERT_COND(p_CcNodeInformation->h_CcNode); 2792 /* Update the manipulation which has to be updated from parameters of the port */ 2793 /* It's has to be updated with restrictions defined in the function */ 2794 err = 2795 SetRequiredAction( 2796 p_CcNode->h_FmPcd, 2797 p_CcNode->shadowAction 2798 | p_AdditionalInfo->keyAndNextEngineParams[keyIndex].requiredAction, 2799 &p_AdditionalInfo->keyAndNextEngineParams[keyIndex], 2800 PTR_MOVE(p_AdditionalInfo->p_AdTableNew, keyIndex*FM_PCD_CC_AD_ENTRY_SIZE), 2801 1, p_CcNodeInformation->h_CcNode); 2802 if (err) 2803 RETURN_ERROR(MAJOR, err, (NO_MSG)); 2804 2805 err = 2806 CcUpdateParam( 2807 p_CcNode->h_FmPcd, 2808 NULL, 2809 NULL, 2810 &p_AdditionalInfo->keyAndNextEngineParams[keyIndex], 2811 1, 2812 PTR_MOVE(p_AdditionalInfo->p_AdTableNew, keyIndex*FM_PCD_CC_AD_ENTRY_SIZE), 2813 TRUE, p_CcNodeInformation->index, 2814 p_CcNodeInformation->h_CcNode, TRUE); 2815 if (err) 2816 RETURN_ERROR(MAJOR, err, (NO_MSG)); 2817 } 2818 } 2819 2820 if (p_CcNode->lclMask) 2821 memset(p_CcNode->p_GlblMask, 0xff, CC_GLBL_MASK_SIZE * sizeof(uint8_t)); 2822 2823 if (p_KeyParams->ccNextEngineParams.nextEngine == e_FM_PCD_CC) 2824 p_AdditionalInfo->h_NodeForAdd = 2825 p_KeyParams->ccNextEngineParams.params.ccParams.h_CcNode; 2826 if (p_KeyParams->ccNextEngineParams.h_Manip) 2827 p_AdditionalInfo->h_ManipForAdd = 2828 p_KeyParams->ccNextEngineParams.h_Manip; 2829 2830 #if (DPAA_VERSION >= 11) 2831 if ((p_KeyParams->ccNextEngineParams.nextEngine == e_FM_PCD_FR) 2832 && (p_KeyParams->ccNextEngineParams.params.frParams.h_FrmReplic)) 2833 p_AdditionalInfo->h_FrmReplicForAdd = 2834 p_KeyParams->ccNextEngineParams.params.frParams.h_FrmReplic; 2835 #endif /* (DPAA_VERSION >= 11) */ 2836 2837 if (!add) 2838 { 2839 if (p_CcNode->keyAndNextEngineParams[keyIndex].nextEngineParams.nextEngine 2840 == e_FM_PCD_CC) 2841 p_AdditionalInfo->h_NodeForRmv = 2842 p_CcNode->keyAndNextEngineParams[keyIndex].nextEngineParams.params.ccParams.h_CcNode; 2843 2844 if (p_CcNode->keyAndNextEngineParams[keyIndex].nextEngineParams.h_Manip) 2845 p_AdditionalInfo->h_ManipForRmv = 2846 p_CcNode->keyAndNextEngineParams[keyIndex].nextEngineParams.h_Manip; 2847 2848 /* If statistics were previously enabled, store the old statistics object to be released */ 2849 if (p_CcNode->keyAndNextEngineParams[keyIndex].p_StatsObj) 2850 { 2851 p_AdditionalInfo->p_StatsObjForRmv = 2852 p_CcNode->keyAndNextEngineParams[keyIndex].p_StatsObj; 2853 } 2854 2855 #if (DPAA_VERSION >= 11) 2856 if ((p_CcNode->keyAndNextEngineParams[keyIndex].nextEngineParams.nextEngine 2857 == e_FM_PCD_FR) 2858 && (p_CcNode->keyAndNextEngineParams[keyIndex].nextEngineParams.params.frParams.h_FrmReplic)) 2859 p_AdditionalInfo->h_FrmReplicForRmv = 2860 p_CcNode->keyAndNextEngineParams[keyIndex].nextEngineParams.params.frParams.h_FrmReplic; 2861 #endif /* (DPAA_VERSION >= 11) */ 2862 } 2863 2864 return E_OK; 2865 } 2866 2867 static t_Error BuildNewNodeRemoveKey( 2868 t_FmPcdCcNode *p_CcNode, uint16_t keyIndex, 2869 t_FmPcdModifyCcKeyAdditionalParams *p_AdditionalInfo) 2870 { 2871 int i = 0, j = 0; 2872 t_Handle p_AdTableNewTmp, p_KeysMatchTableNewTmp; 2873 t_Handle p_KeysMatchTableOldTmp, p_AdTableOldTmp; 2874 int size; 2875 t_Error err = E_OK; 2876 2877 /*save new numOfKeys*/ 2878 p_AdditionalInfo->numOfKeys = (uint16_t)(p_CcNode->numOfKeys - 1); 2879 2880 /*function which allocates in the memory new KeyTbl, AdTbl*/ 2881 err = BuildNewNodeCommonPart(p_CcNode, &size, p_AdditionalInfo); 2882 if (err) 2883 RETURN_ERROR(MAJOR, err, NO_MSG); 2884 2885 /*update new Ad and new Key Table according to new requirement*/ 2886 for (i = 0, j = 0; j < p_CcNode->numOfKeys; i++, j++) 2887 { 2888 if (j == keyIndex) 2889 j++; 2890 2891 if (j == p_CcNode->numOfKeys) 2892 break; 2893 p_AdTableNewTmp = 2894 PTR_MOVE(p_AdditionalInfo->p_AdTableNew, i * FM_PCD_CC_AD_ENTRY_SIZE); 2895 p_AdTableOldTmp = 2896 PTR_MOVE(p_AdditionalInfo->p_AdTableOld, j * FM_PCD_CC_AD_ENTRY_SIZE); 2897 MemCpy8(p_AdTableNewTmp, p_AdTableOldTmp, FM_PCD_CC_AD_ENTRY_SIZE); 2898 2899 p_KeysMatchTableOldTmp = 2900 PTR_MOVE(p_AdditionalInfo->p_KeysMatchTableOld, j * size * sizeof(uint8_t)); 2901 p_KeysMatchTableNewTmp = 2902 PTR_MOVE(p_AdditionalInfo->p_KeysMatchTableNew, i * size * sizeof(uint8_t)); 2903 MemCpy8(p_KeysMatchTableNewTmp, p_KeysMatchTableOldTmp, 2904 size * sizeof(uint8_t)); 2905 } 2906 2907 p_AdTableNewTmp = 2908 PTR_MOVE(p_AdditionalInfo->p_AdTableNew, i * FM_PCD_CC_AD_ENTRY_SIZE); 2909 p_AdTableOldTmp = 2910 PTR_MOVE(p_AdditionalInfo->p_AdTableOld, j * FM_PCD_CC_AD_ENTRY_SIZE); 2911 MemCpy8(p_AdTableNewTmp, p_AdTableOldTmp, FM_PCD_CC_AD_ENTRY_SIZE); 2912 2913 if (p_CcNode->keyAndNextEngineParams[keyIndex].nextEngineParams.nextEngine 2914 == e_FM_PCD_CC) 2915 p_AdditionalInfo->h_NodeForRmv = 2916 p_CcNode->keyAndNextEngineParams[keyIndex].nextEngineParams.params.ccParams.h_CcNode; 2917 2918 if (p_CcNode->keyAndNextEngineParams[keyIndex].nextEngineParams.h_Manip) 2919 p_AdditionalInfo->h_ManipForRmv = 2920 p_CcNode->keyAndNextEngineParams[keyIndex].nextEngineParams.h_Manip; 2921 2922 /* If statistics were previously enabled, store the old statistics object to be released */ 2923 if (p_CcNode->keyAndNextEngineParams[keyIndex].p_StatsObj) 2924 { 2925 p_AdditionalInfo->p_StatsObjForRmv = 2926 p_CcNode->keyAndNextEngineParams[keyIndex].p_StatsObj; 2927 } 2928 2929 #if (DPAA_VERSION >= 11) 2930 if ((p_CcNode->keyAndNextEngineParams[keyIndex].nextEngineParams.nextEngine 2931 == e_FM_PCD_FR) 2932 && (p_CcNode->keyAndNextEngineParams[keyIndex].nextEngineParams.params.frParams.h_FrmReplic)) 2933 p_AdditionalInfo->h_FrmReplicForRmv = 2934 p_CcNode->keyAndNextEngineParams[keyIndex].nextEngineParams.params.frParams.h_FrmReplic; 2935 #endif /* (DPAA_VERSION >= 11) */ 2936 2937 return E_OK; 2938 } 2939 2940 static t_Error BuildNewNodeModifyKey( 2941 t_FmPcdCcNode *p_CcNode, uint16_t keyIndex, uint8_t *p_Key, 2942 uint8_t *p_Mask, t_FmPcdModifyCcKeyAdditionalParams *p_AdditionalInfo) 2943 { 2944 t_FmPcd *p_FmPcd = (t_FmPcd *)p_CcNode->h_FmPcd; 2945 t_Error err = E_OK; 2946 t_Handle p_AdTableNewTmp, p_KeysMatchTableNewTmp; 2947 t_Handle p_KeysMatchTableOldTmp, p_AdTableOldTmp; 2948 int size; 2949 int i = 0, j = 0; 2950 bool prvLclMask; 2951 t_FmPcdStatsObj *p_StatsObj, tmpStatsObj; 2952 p_AdditionalInfo->numOfKeys = p_CcNode->numOfKeys; 2953 2954 prvLclMask = p_CcNode->lclMask; 2955 2956 /* Check that new key is not require update of localMask */ 2957 err = UpdateGblMask(p_CcNode, p_CcNode->ccKeySizeAccExtraction, p_Mask); 2958 if (err) 2959 RETURN_ERROR(MAJOR, err, (NO_MSG)); 2960 2961 /* Update internal data structure with new next engine for the given index */ 2962 memcpy(p_AdditionalInfo->keyAndNextEngineParams[keyIndex].key, p_Key, 2963 p_CcNode->userSizeOfExtraction); 2964 2965 if (p_Mask) 2966 memcpy(p_AdditionalInfo->keyAndNextEngineParams[keyIndex].mask, p_Mask, 2967 p_CcNode->userSizeOfExtraction); 2968 else 2969 memset(p_AdditionalInfo->keyAndNextEngineParams[keyIndex].mask, 0xFF, 2970 p_CcNode->userSizeOfExtraction); 2971 2972 /*function which build in the memory new KeyTbl, AdTbl*/ 2973 err = BuildNewNodeCommonPart(p_CcNode, &size, p_AdditionalInfo); 2974 if (err) 2975 RETURN_ERROR(MAJOR, err, NO_MSG); 2976 2977 /*fill the New AdTable and New KeyTable*/ 2978 for (j = 0, i = 0; j < p_AdditionalInfo->numOfKeys; j++, i++) 2979 { 2980 p_AdTableNewTmp = 2981 PTR_MOVE(p_AdditionalInfo->p_AdTableNew, j*FM_PCD_CC_AD_ENTRY_SIZE); 2982 p_AdTableOldTmp = 2983 PTR_MOVE(p_AdditionalInfo->p_AdTableOld, i*FM_PCD_CC_AD_ENTRY_SIZE); 2984 2985 MemCpy8(p_AdTableNewTmp, p_AdTableOldTmp, FM_PCD_CC_AD_ENTRY_SIZE); 2986 2987 if (j == keyIndex) 2988 { 2989 ASSERT_COND(keyIndex < CC_MAX_NUM_OF_KEYS); 2990 if (p_CcNode->keyAndNextEngineParams[keyIndex].p_StatsObj) 2991 { 2992 /* As statistics were enabled, we need to update the existing 2993 statistics descriptor with a new nullified counters. */ 2994 p_StatsObj = GetStatsObj(p_CcNode); 2995 ASSERT_COND(p_StatsObj); 2996 2997 SetStatsCounters( 2998 p_AdTableNewTmp, 2999 (uint32_t)((XX_VirtToPhys(p_StatsObj->h_StatsCounters) 3000 - p_FmPcd->physicalMuramBase))); 3001 3002 tmpStatsObj.h_StatsAd = p_StatsObj->h_StatsAd; 3003 tmpStatsObj.h_StatsCounters = p_StatsObj->h_StatsCounters; 3004 3005 /* As we need to replace only the counters, we build a new statistics 3006 object that holds the old AD and the new counters - this will be the 3007 currently used statistics object. 3008 The newly allocated AD is not required and may be released back to 3009 the available objects with the previous counters pointer. */ 3010 p_StatsObj->h_StatsAd = 3011 p_CcNode->keyAndNextEngineParams[keyIndex].p_StatsObj->h_StatsAd; 3012 3013 p_CcNode->keyAndNextEngineParams[keyIndex].p_StatsObj->h_StatsAd = 3014 tmpStatsObj.h_StatsAd; 3015 3016 /* Store allocated statistics object */ 3017 p_AdditionalInfo->keyAndNextEngineParams[keyIndex].p_StatsObj = 3018 p_StatsObj; 3019 3020 /* As statistics were previously enabled, store the old statistics object to be released */ 3021 p_AdditionalInfo->p_StatsObjForRmv = 3022 p_CcNode->keyAndNextEngineParams[keyIndex].p_StatsObj; 3023 } 3024 3025 p_KeysMatchTableNewTmp = 3026 PTR_MOVE(p_AdditionalInfo->p_KeysMatchTableNew, j * size * sizeof(uint8_t)); 3027 3028 MemCpy8(p_KeysMatchTableNewTmp, p_Key, 3029 p_CcNode->userSizeOfExtraction); 3030 3031 if (p_CcNode->lclMask) 3032 { 3033 if (p_Mask) 3034 MemCpy8(PTR_MOVE(p_KeysMatchTableNewTmp, 3035 p_CcNode->ccKeySizeAccExtraction), 3036 p_Mask, p_CcNode->userSizeOfExtraction); 3037 else 3038 if (p_CcNode->ccKeySizeAccExtraction > 4) 3039 MemSet8(PTR_MOVE(p_KeysMatchTableNewTmp, 3040 p_CcNode->ccKeySizeAccExtraction), 3041 0xff, p_CcNode->userSizeOfExtraction); 3042 else 3043 MemCpy8(PTR_MOVE(p_KeysMatchTableNewTmp, 3044 p_CcNode->ccKeySizeAccExtraction), 3045 p_CcNode->p_GlblMask, 3046 p_CcNode->userSizeOfExtraction); 3047 } 3048 } 3049 else 3050 { 3051 p_KeysMatchTableNewTmp = 3052 PTR_MOVE(p_AdditionalInfo->p_KeysMatchTableNew, j * size * sizeof(uint8_t)); 3053 p_KeysMatchTableOldTmp = 3054 PTR_MOVE(p_CcNode->h_KeysMatchTable, i * size * sizeof(uint8_t)); 3055 3056 if (p_CcNode->lclMask) 3057 { 3058 if (prvLclMask) 3059 MemCpy8( 3060 PTR_MOVE(p_KeysMatchTableNewTmp, p_CcNode->ccKeySizeAccExtraction), 3061 PTR_MOVE(p_KeysMatchTableOldTmp, p_CcNode->ccKeySizeAccExtraction), 3062 p_CcNode->userSizeOfExtraction); 3063 else 3064 { 3065 p_KeysMatchTableOldTmp = 3066 PTR_MOVE(p_CcNode->h_KeysMatchTable, 3067 i * (int)p_CcNode->ccKeySizeAccExtraction * sizeof(uint8_t)); 3068 3069 if (p_CcNode->ccKeySizeAccExtraction > 4) 3070 MemSet8(PTR_MOVE(p_KeysMatchTableNewTmp, 3071 p_CcNode->ccKeySizeAccExtraction), 3072 0xff, p_CcNode->userSizeOfExtraction); 3073 else 3074 MemCpy8( 3075 PTR_MOVE(p_KeysMatchTableNewTmp, p_CcNode->ccKeySizeAccExtraction), 3076 p_CcNode->p_GlblMask, 3077 p_CcNode->userSizeOfExtraction); 3078 } 3079 } 3080 MemCpy8((void*)p_KeysMatchTableNewTmp, p_KeysMatchTableOldTmp, 3081 p_CcNode->ccKeySizeAccExtraction); 3082 } 3083 } 3084 3085 p_AdTableNewTmp = 3086 PTR_MOVE(p_AdditionalInfo->p_AdTableNew, j * FM_PCD_CC_AD_ENTRY_SIZE); 3087 p_AdTableOldTmp = PTR_MOVE(p_CcNode->h_AdTable, i * FM_PCD_CC_AD_ENTRY_SIZE); 3088 3089 MemCpy8(p_AdTableNewTmp, p_AdTableOldTmp, FM_PCD_CC_AD_ENTRY_SIZE); 3090 3091 return E_OK; 3092 } 3093 3094 static t_Error BuildNewNodeModifyNextEngine( 3095 t_Handle h_FmPcd, t_Handle h_FmPcdCcNodeOrTree, uint16_t keyIndex, 3096 t_FmPcdCcNextEngineParams *p_CcNextEngineParams, t_List *h_OldLst, 3097 t_List *h_NewLst, t_FmPcdModifyCcKeyAdditionalParams *p_AdditionalInfo) 3098 { 3099 t_Error err = E_OK; 3100 uint32_t requiredAction = 0; 3101 t_List *p_Pos; 3102 t_CcNodeInformation *p_CcNodeInformation, ccNodeInfo; 3103 t_Handle p_Ad; 3104 t_FmPcdCcNode *p_FmPcdCcNode1 = NULL; 3105 t_FmPcdCcTree *p_FmPcdCcTree = NULL; 3106 t_FmPcdStatsObj *p_StatsObj; 3107 t_FmPcdCcStatsParams statsParams = { 0 }; 3108 3109 ASSERT_COND(p_CcNextEngineParams); 3110 3111 /* check that new NIA is legal */ 3112 if (!p_AdditionalInfo->tree) 3113 err = ValidateNextEngineParams( 3114 h_FmPcd, p_CcNextEngineParams, 3115 ((t_FmPcdCcNode *)h_FmPcdCcNodeOrTree)->statisticsMode); 3116 else 3117 /* Statistics are not supported for CC root */ 3118 err = ValidateNextEngineParams(h_FmPcd, p_CcNextEngineParams, 3119 e_FM_PCD_CC_STATS_MODE_NONE); 3120 if (err) 3121 RETURN_ERROR(MAJOR, err, NO_MSG); 3122 3123 /* Update internal data structure for next engine per index (index - key) */ 3124 memcpy(&p_AdditionalInfo->keyAndNextEngineParams[keyIndex].nextEngineParams, 3125 p_CcNextEngineParams, sizeof(t_FmPcdCcNextEngineParams)); 3126 3127 /* Check that manip is legal and what requiredAction is necessary for this manip */ 3128 if (p_CcNextEngineParams->h_Manip) 3129 { 3130 err = FmPcdManipCheckParamsForCcNextEngine(p_CcNextEngineParams, 3131 &requiredAction); 3132 if (err) 3133 RETURN_ERROR(MAJOR, err, (NO_MSG)); 3134 } 3135 3136 if (!p_AdditionalInfo->tree) 3137 { 3138 p_FmPcdCcNode1 = (t_FmPcdCcNode *)h_FmPcdCcNodeOrTree; 3139 p_AdditionalInfo->numOfKeys = p_FmPcdCcNode1->numOfKeys; 3140 p_Ad = p_FmPcdCcNode1->h_AdTable; 3141 3142 if (p_FmPcdCcNode1->keyAndNextEngineParams[keyIndex].nextEngineParams.nextEngine 3143 == e_FM_PCD_CC) 3144 p_AdditionalInfo->h_NodeForRmv = 3145 p_FmPcdCcNode1->keyAndNextEngineParams[keyIndex].nextEngineParams.params.ccParams.h_CcNode; 3146 3147 if (p_FmPcdCcNode1->keyAndNextEngineParams[keyIndex].nextEngineParams.h_Manip) 3148 p_AdditionalInfo->h_ManipForRmv = 3149 p_FmPcdCcNode1->keyAndNextEngineParams[keyIndex].nextEngineParams.h_Manip; 3150 3151 #if (DPAA_VERSION >= 11) 3152 if ((p_FmPcdCcNode1->keyAndNextEngineParams[keyIndex].nextEngineParams.nextEngine 3153 == e_FM_PCD_FR) 3154 && (p_FmPcdCcNode1->keyAndNextEngineParams[keyIndex].nextEngineParams.params.frParams.h_FrmReplic)) 3155 p_AdditionalInfo->h_FrmReplicForRmv = 3156 p_FmPcdCcNode1->keyAndNextEngineParams[keyIndex].nextEngineParams.params.frParams.h_FrmReplic; 3157 #endif /* (DPAA_VERSION >= 11) */ 3158 } 3159 else 3160 { 3161 p_FmPcdCcTree = (t_FmPcdCcTree *)h_FmPcdCcNodeOrTree; 3162 p_Ad = UINT_TO_PTR(p_FmPcdCcTree->ccTreeBaseAddr); 3163 3164 if (p_FmPcdCcTree->keyAndNextEngineParams[keyIndex].nextEngineParams.nextEngine 3165 == e_FM_PCD_CC) 3166 p_AdditionalInfo->h_NodeForRmv = 3167 p_FmPcdCcTree->keyAndNextEngineParams[keyIndex].nextEngineParams.params.ccParams.h_CcNode; 3168 3169 if (p_FmPcdCcTree->keyAndNextEngineParams[keyIndex].nextEngineParams.h_Manip) 3170 p_AdditionalInfo->h_ManipForRmv = 3171 p_FmPcdCcTree->keyAndNextEngineParams[keyIndex].nextEngineParams.h_Manip; 3172 3173 #if (DPAA_VERSION >= 11) 3174 if ((p_FmPcdCcTree->keyAndNextEngineParams[keyIndex].nextEngineParams.nextEngine 3175 == e_FM_PCD_FR) 3176 && (p_FmPcdCcTree->keyAndNextEngineParams[keyIndex].nextEngineParams.params.frParams.h_FrmReplic)) 3177 p_AdditionalInfo->h_FrmReplicForRmv = 3178 p_FmPcdCcTree->keyAndNextEngineParams[keyIndex].nextEngineParams.params.frParams.h_FrmReplic; 3179 #endif /* (DPAA_VERSION >= 11) */ 3180 } 3181 3182 if ((p_CcNextEngineParams->nextEngine == e_FM_PCD_CC) 3183 && p_CcNextEngineParams->h_Manip) 3184 { 3185 err = AllocAndFillAdForContLookupManip( 3186 p_CcNextEngineParams->params.ccParams.h_CcNode); 3187 if (err) 3188 RETURN_ERROR(MAJOR, err, (NO_MSG)); 3189 } 3190 3191 ASSERT_COND(p_Ad); 3192 3193 memset(&ccNodeInfo, 0, sizeof(t_CcNodeInformation)); 3194 ccNodeInfo.h_CcNode = PTR_MOVE(p_Ad, keyIndex * FM_PCD_CC_AD_ENTRY_SIZE); 3195 3196 /* If statistics were enabled, this Ad is the statistics Ad. Need to follow its 3197 nextAction to retrieve the actual Nia-Ad. If statistics should remain enabled, 3198 only the actual Nia-Ad should be modified. */ 3199 if ((!p_AdditionalInfo->tree) 3200 && (((t_FmPcdCcNode *)h_FmPcdCcNodeOrTree)->keyAndNextEngineParams[keyIndex].p_StatsObj) 3201 && (p_CcNextEngineParams->statisticsEn)) 3202 ccNodeInfo.h_CcNode = 3203 ((t_FmPcdCcNode *)h_FmPcdCcNodeOrTree)->keyAndNextEngineParams[keyIndex].p_StatsObj->h_StatsAd; 3204 3205 EnqueueNodeInfoToRelevantLst(h_OldLst, &ccNodeInfo, NULL); 3206 3207 memset(&ccNodeInfo, 0, sizeof(t_CcNodeInformation)); 3208 p_Ad = GetNewAd(h_FmPcdCcNodeOrTree, p_AdditionalInfo->tree); 3209 if (!p_Ad) 3210 RETURN_ERROR(MAJOR, E_NO_MEMORY, 3211 ("MURAM allocation for CC node action descriptor")); 3212 MemSet8((uint8_t *)p_Ad, 0, FM_PCD_CC_AD_ENTRY_SIZE); 3213 3214 /* If statistics were not enabled before, but requested now - Allocate a statistics 3215 object that holds statistics AD and counters. */ 3216 if ((!p_AdditionalInfo->tree) 3217 && (!((t_FmPcdCcNode *)h_FmPcdCcNodeOrTree)->keyAndNextEngineParams[keyIndex].p_StatsObj) 3218 && (p_CcNextEngineParams->statisticsEn)) 3219 { 3220 p_StatsObj = GetStatsObj((t_FmPcdCcNode *)h_FmPcdCcNodeOrTree); 3221 ASSERT_COND(p_StatsObj); 3222 3223 /* Store allocated statistics object */ 3224 p_AdditionalInfo->keyAndNextEngineParams[keyIndex].p_StatsObj = 3225 p_StatsObj; 3226 3227 statsParams.h_StatsAd = p_StatsObj->h_StatsAd; 3228 statsParams.h_StatsCounters = p_StatsObj->h_StatsCounters; 3229 3230 #if (DPAA_VERSION >= 11) 3231 statsParams.h_StatsFLRs = 3232 ((t_FmPcdCcNode *)h_FmPcdCcNodeOrTree)->h_StatsFLRs; 3233 3234 #endif /* (DPAA_VERSION >= 11) */ 3235 3236 NextStepAd(p_Ad, &statsParams, p_CcNextEngineParams, h_FmPcd); 3237 } 3238 else 3239 NextStepAd(p_Ad, NULL, p_CcNextEngineParams, h_FmPcd); 3240 3241 ccNodeInfo.h_CcNode = p_Ad; 3242 EnqueueNodeInfoToRelevantLst(h_NewLst, &ccNodeInfo, NULL); 3243 3244 p_AdditionalInfo->keyAndNextEngineParams[keyIndex].requiredAction = 3245 requiredAction; 3246 p_AdditionalInfo->keyAndNextEngineParams[keyIndex].requiredAction |= 3247 UPDATE_CC_WITH_TREE; 3248 3249 if (!p_AdditionalInfo->tree) 3250 { 3251 ASSERT_COND(p_FmPcdCcNode1); 3252 if (!NCSW_LIST_IsEmpty(&p_FmPcdCcNode1->ccTreesLst)) 3253 { 3254 NCSW_LIST_FOR_EACH(p_Pos, &p_FmPcdCcNode1->ccTreesLst) 3255 { 3256 p_CcNodeInformation = CC_NODE_F_OBJECT(p_Pos); 3257 3258 ASSERT_COND(p_CcNodeInformation->h_CcNode); 3259 /* Update the manipulation which has to be updated from parameters of the port 3260 it's has to be updated with restrictions defined in the function */ 3261 3262 err = 3263 SetRequiredAction( 3264 p_FmPcdCcNode1->h_FmPcd, 3265 p_FmPcdCcNode1->shadowAction 3266 | p_AdditionalInfo->keyAndNextEngineParams[keyIndex].requiredAction, 3267 &p_AdditionalInfo->keyAndNextEngineParams[keyIndex], 3268 p_Ad, 1, p_CcNodeInformation->h_CcNode); 3269 if (err) 3270 RETURN_ERROR(MAJOR, err, (NO_MSG)); 3271 3272 err = CcUpdateParam( 3273 p_FmPcdCcNode1->h_FmPcd, NULL, NULL, 3274 &p_AdditionalInfo->keyAndNextEngineParams[keyIndex], 1, 3275 p_Ad, TRUE, p_CcNodeInformation->index, 3276 p_CcNodeInformation->h_CcNode, TRUE); 3277 if (err) 3278 RETURN_ERROR(MAJOR, err, (NO_MSG)); 3279 } 3280 } 3281 } 3282 else 3283 { 3284 ASSERT_COND(p_FmPcdCcTree); 3285 3286 err = 3287 SetRequiredAction( 3288 h_FmPcd, 3289 p_FmPcdCcTree->requiredAction 3290 | p_AdditionalInfo->keyAndNextEngineParams[keyIndex].requiredAction, 3291 &p_AdditionalInfo->keyAndNextEngineParams[keyIndex], 3292 p_Ad, 1, (t_Handle)p_FmPcdCcTree); 3293 if (err) 3294 RETURN_ERROR(MAJOR, err, (NO_MSG)); 3295 3296 err = CcUpdateParam(h_FmPcd, NULL, NULL, 3297 &p_AdditionalInfo->keyAndNextEngineParams[keyIndex], 3298 1, p_Ad, TRUE, 0, (t_Handle)p_FmPcdCcTree, TRUE); 3299 if (err) 3300 RETURN_ERROR(MAJOR, err, (NO_MSG)); 3301 } 3302 3303 if (p_CcNextEngineParams->nextEngine == e_FM_PCD_CC) 3304 p_AdditionalInfo->h_NodeForAdd = 3305 p_CcNextEngineParams->params.ccParams.h_CcNode; 3306 if (p_CcNextEngineParams->h_Manip) 3307 p_AdditionalInfo->h_ManipForAdd = p_CcNextEngineParams->h_Manip; 3308 3309 /* If statistics were previously enabled, but now are disabled, 3310 store the old statistics object to be released */ 3311 if ((!p_AdditionalInfo->tree) 3312 && (((t_FmPcdCcNode *)h_FmPcdCcNodeOrTree)->keyAndNextEngineParams[keyIndex].p_StatsObj) 3313 && (!p_CcNextEngineParams->statisticsEn)) 3314 { 3315 p_AdditionalInfo->p_StatsObjForRmv = 3316 ((t_FmPcdCcNode *)h_FmPcdCcNodeOrTree)->keyAndNextEngineParams[keyIndex].p_StatsObj; 3317 3318 3319 p_AdditionalInfo->keyAndNextEngineParams[keyIndex].p_StatsObj = NULL; 3320 } 3321 #if (DPAA_VERSION >= 11) 3322 if ((p_CcNextEngineParams->nextEngine == e_FM_PCD_FR) 3323 && (p_CcNextEngineParams->params.frParams.h_FrmReplic)) 3324 p_AdditionalInfo->h_FrmReplicForAdd = 3325 p_CcNextEngineParams->params.frParams.h_FrmReplic; 3326 #endif /* (DPAA_VERSION >= 11) */ 3327 3328 return E_OK; 3329 } 3330 3331 static void UpdateAdPtrOfNodesWhichPointsOnCrntMdfNode( 3332 t_FmPcdCcNode *p_CrntMdfNode, t_List *h_OldLst, 3333 t_FmPcdCcNextEngineParams **p_NextEngineParams) 3334 { 3335 t_CcNodeInformation *p_CcNodeInformation; 3336 t_FmPcdCcNode *p_NodePtrOnCurrentMdfNode = NULL; 3337 t_List *p_Pos; 3338 int i = 0; 3339 t_Handle p_AdTablePtOnCrntCurrentMdfNode/*, p_AdTableNewModified*/; 3340 t_CcNodeInformation ccNodeInfo; 3341 3342 NCSW_LIST_FOR_EACH(p_Pos, &p_CrntMdfNode->ccPrevNodesLst) 3343 { 3344 p_CcNodeInformation = CC_NODE_F_OBJECT(p_Pos); 3345 p_NodePtrOnCurrentMdfNode = 3346 (t_FmPcdCcNode *)p_CcNodeInformation->h_CcNode; 3347 3348 ASSERT_COND(p_NodePtrOnCurrentMdfNode); 3349 3350 /* Search in the previous node which exact index points on this current modified node for getting AD */ 3351 for (i = 0; i < p_NodePtrOnCurrentMdfNode->numOfKeys + 1; i++) 3352 { 3353 if (p_NodePtrOnCurrentMdfNode->keyAndNextEngineParams[i].nextEngineParams.nextEngine 3354 == e_FM_PCD_CC) 3355 { 3356 if (p_NodePtrOnCurrentMdfNode->keyAndNextEngineParams[i].nextEngineParams.params.ccParams.h_CcNode 3357 == (t_Handle)p_CrntMdfNode) 3358 { 3359 if (p_NodePtrOnCurrentMdfNode->keyAndNextEngineParams[i].nextEngineParams.h_Manip) 3360 p_AdTablePtOnCrntCurrentMdfNode = p_CrntMdfNode->h_Ad; 3361 else 3362 if (p_NodePtrOnCurrentMdfNode->keyAndNextEngineParams[i].p_StatsObj) 3363 p_AdTablePtOnCrntCurrentMdfNode = 3364 p_NodePtrOnCurrentMdfNode->keyAndNextEngineParams[i].p_StatsObj->h_StatsAd; 3365 else 3366 p_AdTablePtOnCrntCurrentMdfNode = 3367 PTR_MOVE(p_NodePtrOnCurrentMdfNode->h_AdTable, i*FM_PCD_CC_AD_ENTRY_SIZE); 3368 3369 memset(&ccNodeInfo, 0, sizeof(t_CcNodeInformation)); 3370 ccNodeInfo.h_CcNode = p_AdTablePtOnCrntCurrentMdfNode; 3371 EnqueueNodeInfoToRelevantLst(h_OldLst, &ccNodeInfo, NULL); 3372 3373 if (!(*p_NextEngineParams)) 3374 *p_NextEngineParams = 3375 &p_NodePtrOnCurrentMdfNode->keyAndNextEngineParams[i].nextEngineParams; 3376 } 3377 } 3378 } 3379 3380 ASSERT_COND(i != p_NodePtrOnCurrentMdfNode->numOfKeys); 3381 } 3382 } 3383 3384 static void UpdateAdPtrOfTreesWhichPointsOnCrntMdfNode( 3385 t_FmPcdCcNode *p_CrntMdfNode, t_List *h_OldLst, 3386 t_FmPcdCcNextEngineParams **p_NextEngineParams) 3387 { 3388 t_CcNodeInformation *p_CcNodeInformation; 3389 t_FmPcdCcTree *p_TreePtrOnCurrentMdfNode = NULL; 3390 t_List *p_Pos; 3391 int i = 0; 3392 t_Handle p_AdTableTmp; 3393 t_CcNodeInformation ccNodeInfo; 3394 3395 NCSW_LIST_FOR_EACH(p_Pos, &p_CrntMdfNode->ccTreeIdLst) 3396 { 3397 p_CcNodeInformation = CC_NODE_F_OBJECT(p_Pos); 3398 p_TreePtrOnCurrentMdfNode = 3399 (t_FmPcdCcTree *)p_CcNodeInformation->h_CcNode; 3400 3401 ASSERT_COND(p_TreePtrOnCurrentMdfNode); 3402 3403 /*search in the trees which exact index points on this current modified node for getting AD */ 3404 for (i = 0; i < p_TreePtrOnCurrentMdfNode->numOfEntries; i++) 3405 { 3406 if (p_TreePtrOnCurrentMdfNode->keyAndNextEngineParams[i].nextEngineParams.nextEngine 3407 == e_FM_PCD_CC) 3408 { 3409 if (p_TreePtrOnCurrentMdfNode->keyAndNextEngineParams[i].nextEngineParams.params.ccParams.h_CcNode 3410 == (t_Handle)p_CrntMdfNode) 3411 { 3412 p_AdTableTmp = 3413 UINT_TO_PTR(p_TreePtrOnCurrentMdfNode->ccTreeBaseAddr + i*FM_PCD_CC_AD_ENTRY_SIZE); 3414 memset(&ccNodeInfo, 0, sizeof(t_CcNodeInformation)); 3415 ccNodeInfo.h_CcNode = p_AdTableTmp; 3416 EnqueueNodeInfoToRelevantLst(h_OldLst, &ccNodeInfo, NULL); 3417 3418 if (!(*p_NextEngineParams)) 3419 *p_NextEngineParams = 3420 &p_TreePtrOnCurrentMdfNode->keyAndNextEngineParams[i].nextEngineParams; 3421 } 3422 } 3423 } 3424 3425 ASSERT_COND(i == p_TreePtrOnCurrentMdfNode->numOfEntries); 3426 } 3427 } 3428 3429 static t_FmPcdModifyCcKeyAdditionalParams * ModifyNodeCommonPart( 3430 t_Handle h_FmPcdCcNodeOrTree, uint16_t keyIndex, 3431 e_ModifyState modifyState, bool ttlCheck, bool hashCheck, bool tree) 3432 { 3433 t_FmPcdModifyCcKeyAdditionalParams *p_FmPcdModifyCcKeyAdditionalParams; 3434 int i = 0, j = 0; 3435 bool wasUpdate = FALSE; 3436 t_FmPcdCcNode *p_CcNode = NULL; 3437 t_FmPcdCcTree *p_FmPcdCcTree; 3438 uint16_t numOfKeys; 3439 t_FmPcdCcKeyAndNextEngineParams *p_KeyAndNextEngineParams; 3440 3441 SANITY_CHECK_RETURN_VALUE(h_FmPcdCcNodeOrTree, E_INVALID_HANDLE, NULL); 3442 3443 if (!tree) 3444 { 3445 p_CcNode = (t_FmPcdCcNode *)h_FmPcdCcNodeOrTree; 3446 numOfKeys = p_CcNode->numOfKeys; 3447 3448 /* node has to be pointed by another node or tree */ 3449 3450 p_KeyAndNextEngineParams = (t_FmPcdCcKeyAndNextEngineParams *)XX_Malloc( 3451 sizeof(t_FmPcdCcKeyAndNextEngineParams) * (numOfKeys + 1)); 3452 if (!p_KeyAndNextEngineParams) 3453 { 3454 REPORT_ERROR(MAJOR, E_NO_MEMORY, ("Next engine and required action structure")); 3455 return NULL; 3456 } 3457 memcpy(p_KeyAndNextEngineParams, p_CcNode->keyAndNextEngineParams, 3458 (numOfKeys + 1) * sizeof(t_FmPcdCcKeyAndNextEngineParams)); 3459 3460 if (ttlCheck) 3461 { 3462 if ((p_CcNode->parseCode == CC_PC_FF_IPV4TTL) 3463 || (p_CcNode->parseCode == CC_PC_FF_IPV6HOP_LIMIT)) 3464 { 3465 XX_Free(p_KeyAndNextEngineParams); 3466 REPORT_ERROR(MAJOR, E_INVALID_VALUE, ("nodeId of CC_PC_FF_IPV4TTL or CC_PC_FF_IPV6HOP_LIMIT can not be used for this operation")); 3467 return NULL; 3468 } 3469 } 3470 3471 if (hashCheck) 3472 { 3473 if (p_CcNode->parseCode == CC_PC_GENERIC_IC_HASH_INDEXED) 3474 { 3475 XX_Free(p_KeyAndNextEngineParams); 3476 REPORT_ERROR(MAJOR, E_INVALID_VALUE, ("nodeId of CC_PC_GENERIC_IC_HASH_INDEXED can not be used for this operation")); 3477 return NULL; 3478 } 3479 } 3480 } 3481 else 3482 { 3483 p_FmPcdCcTree = (t_FmPcdCcTree *)h_FmPcdCcNodeOrTree; 3484 numOfKeys = p_FmPcdCcTree->numOfEntries; 3485 3486 p_KeyAndNextEngineParams = (t_FmPcdCcKeyAndNextEngineParams *)XX_Malloc( 3487 sizeof(t_FmPcdCcKeyAndNextEngineParams) 3488 * FM_PCD_MAX_NUM_OF_CC_GROUPS); 3489 if (!p_KeyAndNextEngineParams) 3490 { 3491 REPORT_ERROR(MAJOR, E_NO_MEMORY, ("Next engine and required action structure")); 3492 return NULL; 3493 } 3494 memcpy(p_KeyAndNextEngineParams, 3495 p_FmPcdCcTree->keyAndNextEngineParams, 3496 FM_PCD_MAX_NUM_OF_CC_GROUPS 3497 * sizeof(t_FmPcdCcKeyAndNextEngineParams)); 3498 } 3499 3500 p_FmPcdModifyCcKeyAdditionalParams = 3501 (t_FmPcdModifyCcKeyAdditionalParams *)XX_Malloc( 3502 sizeof(t_FmPcdModifyCcKeyAdditionalParams)); 3503 if (!p_FmPcdModifyCcKeyAdditionalParams) 3504 { 3505 XX_Free(p_KeyAndNextEngineParams); 3506 REPORT_ERROR(MAJOR, E_NO_MEMORY, ("Allocation of internal data structure FAILED")); 3507 return NULL; 3508 } 3509 memset(p_FmPcdModifyCcKeyAdditionalParams, 0, 3510 sizeof(t_FmPcdModifyCcKeyAdditionalParams)); 3511 3512 p_FmPcdModifyCcKeyAdditionalParams->h_CurrentNode = h_FmPcdCcNodeOrTree; 3513 p_FmPcdModifyCcKeyAdditionalParams->savedKeyIndex = keyIndex; 3514 3515 while (i < numOfKeys) 3516 { 3517 if ((j == keyIndex) && !wasUpdate) 3518 { 3519 if (modifyState == e_MODIFY_STATE_ADD) 3520 j++; 3521 else 3522 if (modifyState == e_MODIFY_STATE_REMOVE) 3523 i++; 3524 wasUpdate = TRUE; 3525 } 3526 else 3527 { 3528 memcpy(&p_FmPcdModifyCcKeyAdditionalParams->keyAndNextEngineParams[j], 3529 p_KeyAndNextEngineParams + i, 3530 sizeof(t_FmPcdCcKeyAndNextEngineParams)); 3531 i++; 3532 j++; 3533 } 3534 } 3535 3536 if (keyIndex == numOfKeys) 3537 { 3538 if (modifyState == e_MODIFY_STATE_ADD) 3539 j++; 3540 } 3541 3542 memcpy(&p_FmPcdModifyCcKeyAdditionalParams->keyAndNextEngineParams[j], 3543 p_KeyAndNextEngineParams + numOfKeys, 3544 sizeof(t_FmPcdCcKeyAndNextEngineParams)); 3545 3546 XX_Free(p_KeyAndNextEngineParams); 3547 3548 return p_FmPcdModifyCcKeyAdditionalParams; 3549 } 3550 3551 static t_Error UpdatePtrWhichPointOnCrntMdfNode( 3552 t_FmPcdCcNode *p_CcNode, 3553 t_FmPcdModifyCcKeyAdditionalParams *p_FmPcdModifyCcKeyAdditionalParams, 3554 t_List *h_OldLst, t_List *h_NewLst) 3555 { 3556 t_FmPcdCcNextEngineParams *p_NextEngineParams = NULL; 3557 t_CcNodeInformation ccNodeInfo = { 0 }; 3558 t_Handle h_NewAd; 3559 t_Handle h_OrigAd = NULL; 3560 3561 /* Building a list of all action descriptors that point to the previous node */ 3562 if (!NCSW_LIST_IsEmpty(&p_CcNode->ccPrevNodesLst)) 3563 UpdateAdPtrOfNodesWhichPointsOnCrntMdfNode(p_CcNode, h_OldLst, 3564 &p_NextEngineParams); 3565 3566 if (!NCSW_LIST_IsEmpty(&p_CcNode->ccTreeIdLst)) 3567 UpdateAdPtrOfTreesWhichPointsOnCrntMdfNode(p_CcNode, h_OldLst, 3568 &p_NextEngineParams); 3569 3570 /* This node must be found as next engine of one of its previous nodes or trees*/ 3571 if (p_NextEngineParams) 3572 { 3573 /* Building a new action descriptor that points to the modified node */ 3574 h_NewAd = GetNewAd(p_CcNode, FALSE); 3575 if (!h_NewAd) 3576 RETURN_ERROR(MAJOR, E_NO_MEMORY, NO_MSG); 3577 MemSet8(h_NewAd, 0, FM_PCD_CC_AD_ENTRY_SIZE); 3578 3579 h_OrigAd = p_CcNode->h_Ad; 3580 BuildNewAd(h_NewAd, p_FmPcdModifyCcKeyAdditionalParams, p_CcNode, 3581 p_NextEngineParams); 3582 3583 ccNodeInfo.h_CcNode = h_NewAd; 3584 EnqueueNodeInfoToRelevantLst(h_NewLst, &ccNodeInfo, NULL); 3585 3586 if (p_NextEngineParams->h_Manip && !h_OrigAd) 3587 FmPcdManipUpdateOwner(p_NextEngineParams->h_Manip, FALSE); 3588 } 3589 return E_OK; 3590 } 3591 3592 static void UpdateCcRootOwner(t_FmPcdCcTree *p_FmPcdCcTree, bool add) 3593 { 3594 ASSERT_COND(p_FmPcdCcTree); 3595 3596 /* this routine must be protected by the calling routine! */ 3597 3598 if (add) 3599 p_FmPcdCcTree->owners++; 3600 else 3601 { 3602 ASSERT_COND(p_FmPcdCcTree->owners); 3603 p_FmPcdCcTree->owners--; 3604 } 3605 } 3606 3607 static t_Error CheckAndSetManipParamsWithCcNodeParams(t_FmPcdCcNode *p_CcNode) 3608 { 3609 t_Error err = E_OK; 3610 int i = 0; 3611 3612 for (i = 0; i < p_CcNode->numOfKeys; i++) 3613 { 3614 if (p_CcNode->keyAndNextEngineParams[i].nextEngineParams.h_Manip) 3615 { 3616 err = 3617 FmPcdManipCheckParamsWithCcNodeParams( 3618 p_CcNode->keyAndNextEngineParams[i].nextEngineParams.h_Manip, 3619 (t_Handle)p_CcNode); 3620 if (err) 3621 return err; 3622 } 3623 } 3624 3625 return err; 3626 } 3627 static t_Error ValidateAndCalcStatsParams(t_FmPcdCcNode *p_CcNode, 3628 t_FmPcdCcNodeParams *p_CcNodeParam, 3629 uint32_t *p_NumOfRanges, 3630 uint32_t *p_CountersArraySize) 3631 { 3632 e_FmPcdCcStatsMode statisticsMode = p_CcNode->statisticsMode; 3633 uint32_t i; 3634 3635 UNUSED(p_CcNodeParam); 3636 3637 switch (statisticsMode) 3638 { 3639 case e_FM_PCD_CC_STATS_MODE_NONE: 3640 for (i = 0; i < p_CcNode->numOfKeys; i++) 3641 if (p_CcNodeParam->keysParams.keyParams[i].ccNextEngineParams.statisticsEn) 3642 RETURN_ERROR( 3643 MAJOR, 3644 E_INVALID_VALUE, 3645 ("Statistics cannot be enabled for key %d when statistics mode was set to 'NONE'", i)); 3646 return E_OK; 3647 3648 case e_FM_PCD_CC_STATS_MODE_FRAME: 3649 case e_FM_PCD_CC_STATS_MODE_BYTE_AND_FRAME: 3650 *p_NumOfRanges = 1; 3651 *p_CountersArraySize = 2 * FM_PCD_CC_STATS_COUNTER_SIZE; 3652 return E_OK; 3653 3654 #if (DPAA_VERSION >= 11) 3655 case e_FM_PCD_CC_STATS_MODE_RMON: 3656 { 3657 uint16_t *p_FrameLengthRanges = 3658 p_CcNodeParam->keysParams.frameLengthRanges; 3659 uint32_t i; 3660 3661 if (p_FrameLengthRanges[0] <= 0) 3662 RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("Statistics mode")); 3663 3664 if (p_FrameLengthRanges[0] == 0xFFFF) 3665 { 3666 *p_NumOfRanges = 1; 3667 *p_CountersArraySize = 2 * FM_PCD_CC_STATS_COUNTER_SIZE; 3668 return E_OK; 3669 } 3670 3671 for (i = 1; i < FM_PCD_CC_STATS_MAX_NUM_OF_FLR; i++) 3672 { 3673 if (p_FrameLengthRanges[i - 1] >= p_FrameLengthRanges[i]) 3674 RETURN_ERROR( 3675 MAJOR, 3676 E_INVALID_VALUE, 3677 ("Frame length range must be larger at least by 1 from preceding range")); 3678 3679 /* Stop when last range is reached */ 3680 if (p_FrameLengthRanges[i] == 0xFFFF) 3681 break; 3682 } 3683 3684 if ((i >= FM_PCD_CC_STATS_MAX_NUM_OF_FLR) 3685 || (p_FrameLengthRanges[i] != 0xFFFF)) 3686 RETURN_ERROR(MAJOR, E_INVALID_VALUE, 3687 ("Last Frame length range must be 0xFFFF")); 3688 3689 *p_NumOfRanges = i + 1; 3690 3691 /* Allocate an extra counter for byte count, as counters 3692 array always begins with byte count */ 3693 *p_CountersArraySize = (*p_NumOfRanges + 1) 3694 * FM_PCD_CC_STATS_COUNTER_SIZE; 3695 3696 } 3697 return E_OK; 3698 #endif /* (DPAA_VERSION >= 11) */ 3699 3700 default: 3701 RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("Statistics mode")); 3702 } 3703 } 3704 3705 static t_Error CheckParams(t_Handle h_FmPcd, t_FmPcdCcNodeParams *p_CcNodeParam, 3706 t_FmPcdCcNode *p_CcNode, bool *isKeyTblAlloc) 3707 { 3708 int tmp = 0; 3709 t_FmPcdCcKeyParams *p_KeyParams; 3710 t_Error err; 3711 uint32_t requiredAction = 0; 3712 3713 /* Validate statistics parameters */ 3714 err = ValidateAndCalcStatsParams(p_CcNode, p_CcNodeParam, 3715 &(p_CcNode->numOfStatsFLRs), 3716 &(p_CcNode->countersArraySize)); 3717 if (err) 3718 RETURN_ERROR(MAJOR, err, ("Invalid statistics parameters")); 3719 3720 /* Validate next engine parameters on Miss */ 3721 err = ValidateNextEngineParams( 3722 h_FmPcd, &p_CcNodeParam->keysParams.ccNextEngineParamsForMiss, 3723 p_CcNode->statisticsMode); 3724 if (err) 3725 RETURN_ERROR(MAJOR, err, 3726 ("For this node MissNextEngineParams are not valid")); 3727 3728 if (p_CcNodeParam->keysParams.ccNextEngineParamsForMiss.h_Manip) 3729 { 3730 err = FmPcdManipCheckParamsForCcNextEngine( 3731 &p_CcNodeParam->keysParams.ccNextEngineParamsForMiss, 3732 &requiredAction); 3733 if (err) 3734 RETURN_ERROR(MAJOR, err, (NO_MSG)); 3735 } 3736 3737 memcpy(&p_CcNode->keyAndNextEngineParams[p_CcNode->numOfKeys].nextEngineParams, 3738 &p_CcNodeParam->keysParams.ccNextEngineParamsForMiss, 3739 sizeof(t_FmPcdCcNextEngineParams)); 3740 3741 p_CcNode->keyAndNextEngineParams[p_CcNode->numOfKeys].requiredAction = 3742 requiredAction; 3743 3744 if ((p_CcNode->keyAndNextEngineParams[p_CcNode->numOfKeys].nextEngineParams.nextEngine 3745 == e_FM_PCD_CC) 3746 && p_CcNode->keyAndNextEngineParams[p_CcNode->numOfKeys].nextEngineParams.h_Manip) 3747 { 3748 err = 3749 AllocAndFillAdForContLookupManip( 3750 p_CcNode->keyAndNextEngineParams[p_CcNode->numOfKeys].nextEngineParams.params.ccParams.h_CcNode); 3751 if (err) 3752 RETURN_ERROR(MAJOR, err, (NO_MSG)); 3753 } 3754 3755 for (tmp = 0; tmp < p_CcNode->numOfKeys; tmp++) 3756 { 3757 p_KeyParams = &p_CcNodeParam->keysParams.keyParams[tmp]; 3758 3759 if (!p_KeyParams->p_Key) 3760 RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("p_Key is not initialized")); 3761 3762 err = ValidateNextEngineParams(h_FmPcd, 3763 &p_KeyParams->ccNextEngineParams, 3764 p_CcNode->statisticsMode); 3765 if (err) 3766 RETURN_ERROR(MAJOR, err, (NO_MSG)); 3767 3768 err = UpdateGblMask(p_CcNode, p_CcNodeParam->keysParams.keySize, 3769 p_KeyParams->p_Mask); 3770 if (err) 3771 RETURN_ERROR(MAJOR, err, (NO_MSG)); 3772 3773 if (p_KeyParams->ccNextEngineParams.h_Manip) 3774 { 3775 err = FmPcdManipCheckParamsForCcNextEngine( 3776 &p_KeyParams->ccNextEngineParams, &requiredAction); 3777 if (err) 3778 RETURN_ERROR(MAJOR, err, (NO_MSG)); 3779 } 3780 3781 /* Store 'key' parameters - key, mask (if passed by the user) */ 3782 memcpy(p_CcNode->keyAndNextEngineParams[tmp].key, p_KeyParams->p_Key, 3783 p_CcNodeParam->keysParams.keySize); 3784 3785 if (p_KeyParams->p_Mask) 3786 memcpy(p_CcNode->keyAndNextEngineParams[tmp].mask, 3787 p_KeyParams->p_Mask, p_CcNodeParam->keysParams.keySize); 3788 else 3789 memset((void *)(p_CcNode->keyAndNextEngineParams[tmp].mask), 0xFF, 3790 p_CcNodeParam->keysParams.keySize); 3791 3792 /* Store next engine parameters */ 3793 memcpy(&p_CcNode->keyAndNextEngineParams[tmp].nextEngineParams, 3794 &p_KeyParams->ccNextEngineParams, 3795 sizeof(t_FmPcdCcNextEngineParams)); 3796 3797 p_CcNode->keyAndNextEngineParams[tmp].requiredAction = requiredAction; 3798 3799 if ((p_CcNode->keyAndNextEngineParams[tmp].nextEngineParams.nextEngine 3800 == e_FM_PCD_CC) 3801 && p_CcNode->keyAndNextEngineParams[tmp].nextEngineParams.h_Manip) 3802 { 3803 err = 3804 AllocAndFillAdForContLookupManip( 3805 p_CcNode->keyAndNextEngineParams[tmp].nextEngineParams.params.ccParams.h_CcNode); 3806 if (err) 3807 RETURN_ERROR(MAJOR, err, (NO_MSG)); 3808 } 3809 } 3810 3811 if (p_CcNode->maxNumOfKeys) 3812 { 3813 if (p_CcNode->maxNumOfKeys < p_CcNode->numOfKeys) 3814 RETURN_ERROR( 3815 MAJOR, 3816 E_INVALID_VALUE, 3817 ("Number of keys exceed the provided maximal number of keys")); 3818 } 3819 3820 *isKeyTblAlloc = TRUE; 3821 3822 return E_OK; 3823 } 3824 3825 static t_Error Ipv4TtlOrIpv6HopLimitCheckParams( 3826 t_Handle h_FmPcd, t_FmPcdCcNodeParams *p_CcNodeParam, 3827 t_FmPcdCcNode *p_CcNode, bool *isKeyTblAlloc) 3828 { 3829 int tmp = 0; 3830 t_FmPcdCcKeyParams *p_KeyParams; 3831 t_Error err; 3832 uint8_t key = 0x01; 3833 uint32_t requiredAction = 0; 3834 3835 if (p_CcNode->numOfKeys != 1) 3836 RETURN_ERROR( 3837 MAJOR, 3838 E_INVALID_VALUE, 3839 ("For node of the type IPV4_TTL or IPV6_HOP_LIMIT the maximal supported 'numOfKeys' is 1")); 3840 3841 if ((p_CcNodeParam->keysParams.maxNumOfKeys) 3842 && (p_CcNodeParam->keysParams.maxNumOfKeys != 1)) 3843 RETURN_ERROR( 3844 MAJOR, 3845 E_INVALID_VALUE, 3846 ("For node of the type IPV4_TTL or IPV6_HOP_LIMIT the maximal supported 'maxNumOfKeys' is 1")); 3847 3848 /* Validate statistics parameters */ 3849 err = ValidateAndCalcStatsParams(p_CcNode, p_CcNodeParam, 3850 &(p_CcNode->numOfStatsFLRs), 3851 &(p_CcNode->countersArraySize)); 3852 if (err) 3853 RETURN_ERROR(MAJOR, err, ("Invalid statistics parameters")); 3854 3855 err = ValidateNextEngineParams( 3856 h_FmPcd, &p_CcNodeParam->keysParams.ccNextEngineParamsForMiss, 3857 p_CcNodeParam->keysParams.statisticsMode); 3858 if (err) 3859 RETURN_ERROR(MAJOR, err, 3860 ("For this node MissNextEngineParams are not valid")); 3861 3862 if (p_CcNodeParam->keysParams.ccNextEngineParamsForMiss.h_Manip) 3863 { 3864 err = FmPcdManipCheckParamsForCcNextEngine( 3865 &p_CcNodeParam->keysParams.ccNextEngineParamsForMiss, 3866 &requiredAction); 3867 if (err) 3868 RETURN_ERROR(MAJOR, err, (NO_MSG)); 3869 } 3870 3871 memcpy(&p_CcNode->keyAndNextEngineParams[p_CcNode->numOfKeys].nextEngineParams, 3872 &p_CcNodeParam->keysParams.ccNextEngineParamsForMiss, 3873 sizeof(t_FmPcdCcNextEngineParams)); 3874 3875 p_CcNode->keyAndNextEngineParams[p_CcNode->numOfKeys].requiredAction = 3876 requiredAction; 3877 3878 if ((p_CcNode->keyAndNextEngineParams[p_CcNode->numOfKeys].nextEngineParams.nextEngine 3879 == e_FM_PCD_CC) 3880 && p_CcNode->keyAndNextEngineParams[p_CcNode->numOfKeys].nextEngineParams.h_Manip) 3881 { 3882 err = 3883 AllocAndFillAdForContLookupManip( 3884 p_CcNode->keyAndNextEngineParams[p_CcNode->numOfKeys].nextEngineParams.params.ccParams.h_CcNode); 3885 if (err) 3886 RETURN_ERROR(MAJOR, err, (NO_MSG)); 3887 } 3888 3889 for (tmp = 0; tmp < p_CcNode->numOfKeys; tmp++) 3890 { 3891 p_KeyParams = &p_CcNodeParam->keysParams.keyParams[tmp]; 3892 3893 if (p_KeyParams->p_Mask) 3894 RETURN_ERROR( 3895 MAJOR, 3896 E_INVALID_VALUE, 3897 ("For node of the type IPV4_TTL or IPV6_HOP_LIMIT p_Mask can not be initialized")); 3898 3899 if (memcmp(p_KeyParams->p_Key, &key, 1) != 0) 3900 RETURN_ERROR( 3901 MAJOR, 3902 E_INVALID_VALUE, 3903 ("For node of the type IPV4_TTL or IPV6_HOP_LIMIT p_Key has to be 1")); 3904 3905 err = ValidateNextEngineParams(h_FmPcd, 3906 &p_KeyParams->ccNextEngineParams, 3907 p_CcNode->statisticsMode); 3908 if (err) 3909 RETURN_ERROR(MAJOR, err, (NO_MSG)); 3910 3911 if (p_KeyParams->ccNextEngineParams.h_Manip) 3912 { 3913 err = FmPcdManipCheckParamsForCcNextEngine( 3914 &p_KeyParams->ccNextEngineParams, &requiredAction); 3915 if (err) 3916 RETURN_ERROR(MAJOR, err, (NO_MSG)); 3917 } 3918 3919 /* Store 'key' parameters - key (fixed to 0x01), key size of 1 byte and full mask */ 3920 p_CcNode->keyAndNextEngineParams[tmp].key[0] = key; 3921 p_CcNode->keyAndNextEngineParams[tmp].mask[0] = 0xFF; 3922 3923 /* Store NextEngine parameters */ 3924 memcpy(&p_CcNode->keyAndNextEngineParams[tmp].nextEngineParams, 3925 &p_KeyParams->ccNextEngineParams, 3926 sizeof(t_FmPcdCcNextEngineParams)); 3927 3928 if ((p_CcNode->keyAndNextEngineParams[tmp].nextEngineParams.nextEngine 3929 == e_FM_PCD_CC) 3930 && p_CcNode->keyAndNextEngineParams[tmp].nextEngineParams.h_Manip) 3931 { 3932 err = 3933 AllocAndFillAdForContLookupManip( 3934 p_CcNode->keyAndNextEngineParams[tmp].nextEngineParams.params.ccParams.h_CcNode); 3935 if (err) 3936 RETURN_ERROR(MAJOR, err, (NO_MSG)); 3937 } 3938 p_CcNode->keyAndNextEngineParams[tmp].requiredAction = requiredAction; 3939 } 3940 3941 *isKeyTblAlloc = FALSE; 3942 3943 return E_OK; 3944 } 3945 3946 static t_Error IcHashIndexedCheckParams(t_Handle h_FmPcd, 3947 t_FmPcdCcNodeParams *p_CcNodeParam, 3948 t_FmPcdCcNode *p_CcNode, 3949 bool *isKeyTblAlloc) 3950 { 3951 int tmp = 0, countOnes = 0; 3952 t_FmPcdCcKeyParams *p_KeyParams; 3953 t_Error err; 3954 uint16_t glblMask = p_CcNodeParam->extractCcParams.extractNonHdr.icIndxMask; 3955 uint16_t countMask = (uint16_t)(glblMask >> 4); 3956 uint32_t requiredAction = 0; 3957 3958 if (glblMask & 0x000f) 3959 RETURN_ERROR(MAJOR, E_INVALID_VALUE, 3960 ("icIndxMask has to be with last nibble 0")); 3961 3962 while (countMask) 3963 { 3964 countOnes++; 3965 countMask = (uint16_t)(countMask >> 1); 3966 } 3967 3968 if (!POWER_OF_2(p_CcNode->numOfKeys)) 3969 RETURN_ERROR( 3970 MAJOR, 3971 E_INVALID_VALUE, 3972 ("For Node of the type INDEXED numOfKeys has to be powerOfTwo")); 3973 3974 if (p_CcNode->numOfKeys != ((uint32_t)1 << countOnes)) 3975 RETURN_ERROR( 3976 MAJOR, 3977 E_INVALID_VALUE, 3978 ("For Node of the type IC_HASH_INDEXED numOfKeys has to be powerOfTwo")); 3979 3980 if (p_CcNodeParam->keysParams.maxNumOfKeys 3981 && (p_CcNodeParam->keysParams.maxNumOfKeys != p_CcNode->numOfKeys)) 3982 RETURN_ERROR( 3983 MAJOR, 3984 E_INVALID_VALUE, 3985 ("For Node of the type INDEXED 'maxNumOfKeys' should be 0 or equal 'numOfKeys'")); 3986 3987 /* Validate statistics parameters */ 3988 err = ValidateAndCalcStatsParams(p_CcNode, p_CcNodeParam, 3989 &(p_CcNode->numOfStatsFLRs), 3990 &(p_CcNode->countersArraySize)); 3991 if (err) 3992 RETURN_ERROR(MAJOR, err, ("Invalid statistics parameters")); 3993 3994 err = ValidateNextEngineParams( 3995 h_FmPcd, &p_CcNodeParam->keysParams.ccNextEngineParamsForMiss, 3996 p_CcNode->statisticsMode); 3997 if (GET_ERROR_TYPE(err) != E_NOT_SUPPORTED) 3998 RETURN_ERROR( 3999 MAJOR, 4000 err, 4001 ("MissNextEngineParams for the node of the type IC_INDEX_HASH has to be UnInitialized")); 4002 4003 for (tmp = 0; tmp < p_CcNode->numOfKeys; tmp++) 4004 { 4005 p_KeyParams = &p_CcNodeParam->keysParams.keyParams[tmp]; 4006 4007 if (p_KeyParams->p_Mask || p_KeyParams->p_Key) 4008 RETURN_ERROR( 4009 MAJOR, 4010 E_INVALID_VALUE, 4011 ("For Node of the type IC_HASH_INDEXED p_Key or p_Mask has to be NULL")); 4012 4013 if ((glblMask & (tmp * 16)) == (tmp * 16)) 4014 { 4015 err = ValidateNextEngineParams(h_FmPcd, 4016 &p_KeyParams->ccNextEngineParams, 4017 p_CcNode->statisticsMode); 4018 if (err) 4019 RETURN_ERROR( 4020 MAJOR, 4021 err, 4022 ("This index has to be initialized for the node of the type IC_INDEX_HASH according to settings of GlobalMask ")); 4023 4024 if (p_KeyParams->ccNextEngineParams.h_Manip) 4025 { 4026 err = FmPcdManipCheckParamsForCcNextEngine( 4027 &p_KeyParams->ccNextEngineParams, &requiredAction); 4028 if (err) 4029 RETURN_ERROR(MAJOR, err, (NO_MSG)); 4030 p_CcNode->keyAndNextEngineParams[tmp].requiredAction = 4031 requiredAction; 4032 } 4033 4034 memcpy(&p_CcNode->keyAndNextEngineParams[tmp].nextEngineParams, 4035 &p_KeyParams->ccNextEngineParams, 4036 sizeof(t_FmPcdCcNextEngineParams)); 4037 4038 if ((p_CcNode->keyAndNextEngineParams[tmp].nextEngineParams.nextEngine 4039 == e_FM_PCD_CC) 4040 && p_CcNode->keyAndNextEngineParams[tmp].nextEngineParams.h_Manip) 4041 { 4042 err = 4043 AllocAndFillAdForContLookupManip( 4044 p_CcNode->keyAndNextEngineParams[tmp].nextEngineParams.params.ccParams.h_CcNode); 4045 if (err) 4046 RETURN_ERROR(MAJOR, err, (NO_MSG)); 4047 } 4048 } 4049 else 4050 { 4051 err = ValidateNextEngineParams(h_FmPcd, 4052 &p_KeyParams->ccNextEngineParams, 4053 p_CcNode->statisticsMode); 4054 if (GET_ERROR_TYPE(err) != E_NOT_SUPPORTED) 4055 RETURN_ERROR( 4056 MAJOR, 4057 err, 4058 ("This index has to be UnInitialized for the node of the type IC_INDEX_HASH according to settings of GlobalMask")); 4059 } 4060 } 4061 4062 *isKeyTblAlloc = FALSE; 4063 glblMask = htobe16(glblMask); 4064 memcpy(PTR_MOVE(p_CcNode->p_GlblMask, 2), &glblMask, 2); 4065 4066 return E_OK; 4067 } 4068 4069 static t_Error ModifyNextEngineParamNode( 4070 t_Handle h_FmPcd, t_Handle h_FmPcdCcNode, uint16_t keyIndex, 4071 t_FmPcdCcNextEngineParams *p_FmPcdCcNextEngineParams) 4072 { 4073 t_FmPcdCcNode *p_CcNode = (t_FmPcdCcNode *)h_FmPcdCcNode; 4074 t_FmPcd *p_FmPcd; 4075 t_List h_OldPointersLst, h_NewPointersLst; 4076 t_FmPcdModifyCcKeyAdditionalParams *p_ModifyKeyParams; 4077 t_Error err = E_OK; 4078 4079 SANITY_CHECK_RETURN_ERROR(h_FmPcd, E_INVALID_VALUE); 4080 SANITY_CHECK_RETURN_ERROR(p_CcNode, E_INVALID_HANDLE); 4081 4082 if (keyIndex >= p_CcNode->numOfKeys) 4083 RETURN_ERROR(MAJOR, E_INVALID_STATE, 4084 ("keyIndex > previously cleared last index + 1")); 4085 4086 p_FmPcd = (t_FmPcd *)p_CcNode->h_FmPcd; 4087 4088 INIT_LIST(&h_OldPointersLst); 4089 INIT_LIST(&h_NewPointersLst); 4090 4091 p_ModifyKeyParams = ModifyNodeCommonPart(p_CcNode, keyIndex, 4092 e_MODIFY_STATE_CHANGE, FALSE, 4093 FALSE, FALSE); 4094 if (!p_ModifyKeyParams) 4095 RETURN_ERROR(MAJOR, E_INVALID_STATE, NO_MSG); 4096 4097 if (p_CcNode->maxNumOfKeys 4098 && !TRY_LOCK(p_FmPcd->h_ShadowSpinlock, &p_FmPcd->shadowLock)) 4099 { 4100 XX_Free(p_ModifyKeyParams); 4101 return ERROR_CODE(E_BUSY); 4102 } 4103 4104 err = BuildNewNodeModifyNextEngine(h_FmPcd, p_CcNode, keyIndex, 4105 p_FmPcdCcNextEngineParams, 4106 &h_OldPointersLst, &h_NewPointersLst, 4107 p_ModifyKeyParams); 4108 if (err) 4109 { 4110 XX_Free(p_ModifyKeyParams); 4111 if (p_CcNode->maxNumOfKeys) 4112 RELEASE_LOCK(p_FmPcd->shadowLock); 4113 RETURN_ERROR(MAJOR, err, NO_MSG); 4114 } 4115 4116 err = DoDynamicChange(p_FmPcd, &h_OldPointersLst, &h_NewPointersLst, 4117 p_ModifyKeyParams, FALSE); 4118 4119 if (p_CcNode->maxNumOfKeys) 4120 RELEASE_LOCK(p_FmPcd->shadowLock); 4121 4122 return err; 4123 } 4124 4125 static t_Error FindKeyIndex(t_Handle h_CcNode, uint8_t keySize, uint8_t *p_Key, 4126 uint8_t *p_Mask, uint16_t *p_KeyIndex) 4127 { 4128 t_FmPcdCcNode *p_CcNode = (t_FmPcdCcNode *)h_CcNode; 4129 uint8_t tmpMask[FM_PCD_MAX_SIZE_OF_KEY]; 4130 uint16_t i; 4131 4132 ASSERT_COND(p_Key); 4133 ASSERT_COND(p_KeyIndex); 4134 ASSERT_COND(keySize < FM_PCD_MAX_SIZE_OF_KEY); 4135 4136 if (keySize != p_CcNode->userSizeOfExtraction) 4137 RETURN_ERROR( 4138 MINOR, E_INVALID_VALUE, 4139 ("Key size doesn't match the extraction size of the node")); 4140 4141 /* If user didn't pass a mask for this key, we'll look for full extraction mask */ 4142 if (!p_Mask) 4143 memset(tmpMask, 0xFF, keySize); 4144 4145 for (i = 0; i < p_CcNode->numOfKeys; i++) 4146 { 4147 /* Comparing received key */ 4148 if (memcmp(p_Key, p_CcNode->keyAndNextEngineParams[i].key, keySize) 4149 == 0) 4150 { 4151 if (p_Mask) 4152 { 4153 /* If a user passed a mask for this key, it must match to the existing key's mask for a correct match */ 4154 if (memcmp(p_Mask, p_CcNode->keyAndNextEngineParams[i].mask, 4155 keySize) == 0) 4156 { 4157 *p_KeyIndex = i; 4158 return E_OK; 4159 } 4160 } 4161 else 4162 { 4163 /* If user didn't pass a mask for this key, check if the existing key mask is full extraction */ 4164 if (memcmp(tmpMask, p_CcNode->keyAndNextEngineParams[i].mask, 4165 keySize) == 0) 4166 { 4167 *p_KeyIndex = i; 4168 return E_OK; 4169 } 4170 } 4171 } 4172 } 4173 4174 return ERROR_CODE(E_NOT_FOUND); 4175 } 4176 4177 static t_Error CalcAndUpdateCcShadow(t_FmPcdCcNode *p_CcNode, 4178 bool isKeyTblAlloc, 4179 uint32_t *p_MatchTableSize, 4180 uint32_t *p_AdTableSize) 4181 { 4182 uint32_t shadowSize; 4183 t_Error err; 4184 4185 /* Calculate keys table maximal size - each entry consists of a key and a mask, 4186 (if local mask support is requested) */ 4187 *p_MatchTableSize = p_CcNode->ccKeySizeAccExtraction * sizeof(uint8_t) 4188 * p_CcNode->maxNumOfKeys; 4189 4190 if (p_CcNode->maskSupport) 4191 *p_MatchTableSize *= 2; 4192 4193 /* Calculate next action descriptors table, including one more entry for miss */ 4194 *p_AdTableSize = (uint32_t)((p_CcNode->maxNumOfKeys + 1) 4195 * FM_PCD_CC_AD_ENTRY_SIZE); 4196 4197 /* Calculate maximal shadow size of this node. 4198 All shadow structures will be used for runtime modifications host command. If 4199 keys table was allocated for this node, the keys table and next engines table may 4200 be modified in run time (entries added or removed), so shadow tables are requires. 4201 Otherwise, the only supported runtime modification is a specific next engine update 4202 and this requires shadow memory of a single AD */ 4203 4204 /* Shadow size should be enough to hold the following 3 structures: 4205 * 1 - an action descriptor */ 4206 shadowSize = FM_PCD_CC_AD_ENTRY_SIZE; 4207 4208 /* 2 - keys match table, if was allocated for the current node */ 4209 if (isKeyTblAlloc) 4210 shadowSize += *p_MatchTableSize; 4211 4212 /* 3 - next action descriptors table */ 4213 shadowSize += *p_AdTableSize; 4214 4215 /* Update shadow to the calculated size */ 4216 err = FmPcdUpdateCcShadow(p_CcNode->h_FmPcd, (uint32_t)shadowSize, 4217 FM_PCD_CC_AD_TABLE_ALIGN); 4218 if (err != E_OK) 4219 { 4220 DeleteNode(p_CcNode); 4221 RETURN_ERROR(MAJOR, E_NO_MEMORY, ("MURAM allocation for CC node shadow")); 4222 } 4223 4224 return E_OK; 4225 } 4226 4227 static t_Error AllocStatsObjs(t_FmPcdCcNode *p_CcNode) 4228 { 4229 t_FmPcdStatsObj *p_StatsObj; 4230 t_Handle h_FmMuram, h_StatsAd, h_StatsCounters; 4231 uint32_t i; 4232 4233 h_FmMuram = FmPcdGetMuramHandle(p_CcNode->h_FmPcd); 4234 if (!h_FmMuram) 4235 RETURN_ERROR(MAJOR, E_INVALID_HANDLE, ("FM MURAM")); 4236 4237 /* Allocate statistics ADs and statistics counter. An extra pair (AD + counters) 4238 will be allocated to support runtime modifications */ 4239 for (i = 0; i < p_CcNode->maxNumOfKeys + 2; i++) 4240 { 4241 /* Allocate list object structure */ 4242 p_StatsObj = XX_Malloc(sizeof(t_FmPcdStatsObj)); 4243 if (!p_StatsObj) 4244 { 4245 FreeStatObjects(&p_CcNode->availableStatsLst, h_FmMuram); 4246 RETURN_ERROR(MAJOR, E_NO_MEMORY, ("Statistics object")); 4247 } 4248 memset(p_StatsObj, 0, sizeof(t_FmPcdStatsObj)); 4249 4250 /* Allocate statistics AD from MURAM */ 4251 h_StatsAd = (t_Handle)FM_MURAM_AllocMem(h_FmMuram, 4252 FM_PCD_CC_AD_ENTRY_SIZE, 4253 FM_PCD_CC_AD_TABLE_ALIGN); 4254 if (!h_StatsAd) 4255 { 4256 FreeStatObjects(&p_CcNode->availableStatsLst, h_FmMuram); 4257 XX_Free(p_StatsObj); 4258 RETURN_ERROR(MAJOR, E_NO_MEMORY, 4259 ("MURAM allocation for statistics ADs")); 4260 } 4261 MemSet8(h_StatsAd, 0, FM_PCD_CC_AD_ENTRY_SIZE); 4262 4263 /* Allocate statistics counters from MURAM */ 4264 h_StatsCounters = (t_Handle)FM_MURAM_AllocMem( 4265 h_FmMuram, p_CcNode->countersArraySize, 4266 FM_PCD_CC_AD_TABLE_ALIGN); 4267 if (!h_StatsCounters) 4268 { 4269 FreeStatObjects(&p_CcNode->availableStatsLst, h_FmMuram); 4270 FM_MURAM_FreeMem(h_FmMuram, h_StatsAd); 4271 XX_Free(p_StatsObj); 4272 RETURN_ERROR(MAJOR, E_NO_MEMORY, 4273 ("MURAM allocation for statistics counters")); 4274 } 4275 MemSet8(h_StatsCounters, 0, p_CcNode->countersArraySize); 4276 4277 p_StatsObj->h_StatsAd = h_StatsAd; 4278 p_StatsObj->h_StatsCounters = h_StatsCounters; 4279 4280 EnqueueStatsObj(&p_CcNode->availableStatsLst, p_StatsObj); 4281 } 4282 4283 return E_OK; 4284 } 4285 4286 static t_Error MatchTableGetKeyStatistics( 4287 t_FmPcdCcNode *p_CcNode, uint16_t keyIndex, 4288 t_FmPcdCcKeyStatistics *p_KeyStatistics) 4289 { 4290 uint32_t *p_StatsCounters, i; 4291 4292 if (p_CcNode->statisticsMode == e_FM_PCD_CC_STATS_MODE_NONE) 4293 RETURN_ERROR(MAJOR, E_INVALID_STATE, 4294 ("Statistics were not enabled for this match table")); 4295 4296 if (!p_CcNode->keyAndNextEngineParams[keyIndex].p_StatsObj) 4297 RETURN_ERROR(MAJOR, E_INVALID_STATE, 4298 ("Statistics were not enabled for this key")); 4299 4300 memset(p_KeyStatistics, 0, sizeof(t_FmPcdCcKeyStatistics)); 4301 4302 p_StatsCounters = 4303 p_CcNode->keyAndNextEngineParams[keyIndex].p_StatsObj->h_StatsCounters; 4304 ASSERT_COND(p_StatsCounters); 4305 4306 p_KeyStatistics->byteCount = GET_UINT32(*p_StatsCounters); 4307 4308 for (i = 1; i <= p_CcNode->numOfStatsFLRs; i++) 4309 { 4310 p_StatsCounters = 4311 PTR_MOVE(p_StatsCounters, FM_PCD_CC_STATS_COUNTER_SIZE); 4312 4313 p_KeyStatistics->frameCount += GET_UINT32(*p_StatsCounters); 4314 4315 #if (DPAA_VERSION >= 11) 4316 p_KeyStatistics->frameLengthRangeCount[i - 1] = 4317 GET_UINT32(*p_StatsCounters); 4318 #endif /* (DPAA_VERSION >= 11) */ 4319 } 4320 4321 return E_OK; 4322 } 4323 4324 static t_Error MatchTableSet(t_Handle h_FmPcd, t_FmPcdCcNode *p_CcNode, 4325 t_FmPcdCcNodeParams *p_CcNodeParam) 4326 { 4327 t_FmPcd *p_FmPcd = (t_FmPcd *)h_FmPcd; 4328 t_FmPcdCcNode *p_FmPcdCcNextNode; 4329 t_Error err = E_OK; 4330 uint32_t tmp, keySize; 4331 bool glblMask = FALSE; 4332 t_FmPcdCcKeyParams *p_KeyParams; 4333 t_Handle h_FmMuram, p_KeysMatchTblTmp, p_AdTableTmp; 4334 #if (DPAA_VERSION >= 11) 4335 t_Handle h_StatsFLRs; 4336 #endif /* (DPAA_VERSION >= 11) */ 4337 bool fullField = FALSE; 4338 ccPrivateInfo_t icCode = CC_PRIVATE_INFO_NONE; 4339 bool isKeyTblAlloc, fromIc = FALSE; 4340 uint32_t matchTableSize, adTableSize; 4341 t_CcNodeInformation ccNodeInfo, *p_CcInformation; 4342 t_FmPcdStatsObj *p_StatsObj; 4343 t_FmPcdCcStatsParams statsParams = { 0 }; 4344 t_Handle h_Manip; 4345 4346 ASSERT_COND(h_FmPcd); 4347 ASSERT_COND(p_CcNode); 4348 ASSERT_COND(p_CcNodeParam); 4349 4350 p_CcNode->p_GlblMask = (t_Handle)XX_Malloc( 4351 CC_GLBL_MASK_SIZE * sizeof(uint8_t)); 4352 memset(p_CcNode->p_GlblMask, 0, CC_GLBL_MASK_SIZE * sizeof(uint8_t)); 4353 4354 p_CcNode->h_FmPcd = h_FmPcd; 4355 p_CcNode->numOfKeys = p_CcNodeParam->keysParams.numOfKeys; 4356 p_CcNode->maxNumOfKeys = p_CcNodeParam->keysParams.maxNumOfKeys; 4357 p_CcNode->maskSupport = p_CcNodeParam->keysParams.maskSupport; 4358 p_CcNode->statisticsMode = p_CcNodeParam->keysParams.statisticsMode; 4359 4360 /* For backward compatibility - even if statistics mode is nullified, 4361 we'll fix it to frame mode so we can support per-key request for 4362 statistics using 'statisticsEn' in next engine parameters */ 4363 if (!p_CcNode->maxNumOfKeys 4364 && (p_CcNode->statisticsMode == e_FM_PCD_CC_STATS_MODE_NONE)) 4365 p_CcNode->statisticsMode = e_FM_PCD_CC_STATS_MODE_FRAME; 4366 4367 h_FmMuram = FmPcdGetMuramHandle(h_FmPcd); 4368 if (!h_FmMuram) 4369 RETURN_ERROR(MAJOR, E_INVALID_HANDLE, ("FM MURAM")); 4370 4371 INIT_LIST(&p_CcNode->ccPrevNodesLst); 4372 INIT_LIST(&p_CcNode->ccTreeIdLst); 4373 INIT_LIST(&p_CcNode->ccTreesLst); 4374 INIT_LIST(&p_CcNode->availableStatsLst); 4375 4376 p_CcNode->h_Spinlock = XX_InitSpinlock(); 4377 if (!p_CcNode->h_Spinlock) 4378 { 4379 DeleteNode(p_CcNode); 4380 RETURN_ERROR(MAJOR, E_NO_MEMORY, ("CC node spinlock")); 4381 } 4382 4383 if ((p_CcNodeParam->extractCcParams.type == e_FM_PCD_EXTRACT_BY_HDR) 4384 && ((p_CcNodeParam->extractCcParams.extractByHdr.hdr 4385 == HEADER_TYPE_IPv4) 4386 || (p_CcNodeParam->extractCcParams.extractByHdr.hdr 4387 == HEADER_TYPE_IPv6)) 4388 && (p_CcNodeParam->extractCcParams.extractByHdr.type 4389 == e_FM_PCD_EXTRACT_FULL_FIELD) 4390 && ((p_CcNodeParam->extractCcParams.extractByHdr.extractByHdrType.fullField.ipv6 4391 == NET_HEADER_FIELD_IPv6_HOP_LIMIT) 4392 || (p_CcNodeParam->extractCcParams.extractByHdr.extractByHdrType.fullField.ipv4 4393 == NET_HEADER_FIELD_IPv4_TTL))) 4394 { 4395 err = Ipv4TtlOrIpv6HopLimitCheckParams(h_FmPcd, p_CcNodeParam, p_CcNode, 4396 &isKeyTblAlloc); 4397 glblMask = FALSE; 4398 } 4399 else 4400 if ((p_CcNodeParam->extractCcParams.type == e_FM_PCD_EXTRACT_NON_HDR) 4401 && ((p_CcNodeParam->extractCcParams.extractNonHdr.src 4402 == e_FM_PCD_EXTRACT_FROM_KEY) 4403 || (p_CcNodeParam->extractCcParams.extractNonHdr.src 4404 == e_FM_PCD_EXTRACT_FROM_HASH) 4405 || (p_CcNodeParam->extractCcParams.extractNonHdr.src 4406 == e_FM_PCD_EXTRACT_FROM_FLOW_ID))) 4407 { 4408 if ((p_CcNodeParam->extractCcParams.extractNonHdr.src 4409 == e_FM_PCD_EXTRACT_FROM_FLOW_ID) 4410 && (p_CcNodeParam->extractCcParams.extractNonHdr.offset != 0)) 4411 { 4412 DeleteNode(p_CcNode); 4413 RETURN_ERROR( 4414 MAJOR, 4415 E_INVALID_VALUE, 4416 ("In the case of the extraction from e_FM_PCD_EXTRACT_FROM_FLOW_ID offset has to be 0")); 4417 } 4418 4419 icCode = IcDefineCode(p_CcNodeParam); 4420 fromIc = TRUE; 4421 if (icCode == CC_PRIVATE_INFO_NONE) 4422 { 4423 DeleteNode(p_CcNode); 4424 RETURN_ERROR( 4425 MAJOR, 4426 E_INVALID_STATE, 4427 ("user asked extraction from IC and field in internal context or action wasn't initialized in the right way")); 4428 } 4429 4430 if ((icCode == CC_PRIVATE_INFO_IC_DEQ_FQID_INDEX_LOOKUP) 4431 || (icCode == CC_PRIVATE_INFO_IC_HASH_INDEX_LOOKUP)) 4432 { 4433 err = IcHashIndexedCheckParams(h_FmPcd, p_CcNodeParam, p_CcNode, 4434 &isKeyTblAlloc); 4435 glblMask = TRUE; 4436 } 4437 else 4438 { 4439 err = CheckParams(h_FmPcd, p_CcNodeParam, p_CcNode, 4440 &isKeyTblAlloc); 4441 if (p_CcNode->glblMaskSize) 4442 glblMask = TRUE; 4443 } 4444 } 4445 else 4446 { 4447 err = CheckParams(h_FmPcd, p_CcNodeParam, p_CcNode, &isKeyTblAlloc); 4448 if (p_CcNode->glblMaskSize) 4449 glblMask = TRUE; 4450 } 4451 4452 if (err) 4453 { 4454 DeleteNode(p_CcNode); 4455 RETURN_ERROR(MAJOR, err, NO_MSG); 4456 } 4457 4458 switch (p_CcNodeParam->extractCcParams.type) 4459 { 4460 case (e_FM_PCD_EXTRACT_BY_HDR): 4461 switch (p_CcNodeParam->extractCcParams.extractByHdr.type) 4462 { 4463 case (e_FM_PCD_EXTRACT_FULL_FIELD): 4464 p_CcNode->parseCode = 4465 GetFullFieldParseCode( 4466 p_CcNodeParam->extractCcParams.extractByHdr.hdr, 4467 p_CcNodeParam->extractCcParams.extractByHdr.hdrIndex, 4468 p_CcNodeParam->extractCcParams.extractByHdr.extractByHdrType.fullField); 4469 GetSizeHeaderField( 4470 p_CcNodeParam->extractCcParams.extractByHdr.hdr, 4471 p_CcNodeParam->extractCcParams.extractByHdr.extractByHdrType.fullField, 4472 &p_CcNode->sizeOfExtraction); 4473 fullField = TRUE; 4474 if ((p_CcNode->parseCode != CC_PC_FF_TCI1) 4475 && (p_CcNode->parseCode != CC_PC_FF_TCI2) 4476 && (p_CcNode->parseCode != CC_PC_FF_MPLS1) 4477 && (p_CcNode->parseCode != CC_PC_FF_MPLS_LAST) 4478 && (p_CcNode->parseCode != CC_PC_FF_IPV4IPTOS_TC1) 4479 && (p_CcNode->parseCode != CC_PC_FF_IPV4IPTOS_TC2) 4480 && (p_CcNode->parseCode 4481 != CC_PC_FF_IPTOS_IPV6TC1_IPV6FLOW1) 4482 && (p_CcNode->parseCode != CC_PC_FF_IPDSCP) 4483 && (p_CcNode->parseCode 4484 != CC_PC_FF_IPTOS_IPV6TC2_IPV6FLOW2) 4485 && glblMask) 4486 { 4487 glblMask = FALSE; 4488 p_CcNode->glblMaskSize = 4; 4489 p_CcNode->lclMask = TRUE; 4490 } 4491 break; 4492 4493 case (e_FM_PCD_EXTRACT_FROM_HDR): 4494 p_CcNode->sizeOfExtraction = 4495 p_CcNodeParam->extractCcParams.extractByHdr.extractByHdrType.fromHdr.size; 4496 p_CcNode->offset = 4497 p_CcNodeParam->extractCcParams.extractByHdr.extractByHdrType.fromHdr.offset; 4498 p_CcNode->userOffset = 4499 p_CcNodeParam->extractCcParams.extractByHdr.extractByHdrType.fromHdr.offset; 4500 p_CcNode->parseCode = 4501 GetPrParseCode( 4502 p_CcNodeParam->extractCcParams.extractByHdr.hdr, 4503 p_CcNodeParam->extractCcParams.extractByHdr.hdrIndex, 4504 p_CcNode->offset, glblMask, 4505 &p_CcNode->prsArrayOffset); 4506 break; 4507 4508 case (e_FM_PCD_EXTRACT_FROM_FIELD): 4509 p_CcNode->offset = 4510 p_CcNodeParam->extractCcParams.extractByHdr.extractByHdrType.fromField.offset; 4511 p_CcNode->userOffset = 4512 p_CcNodeParam->extractCcParams.extractByHdr.extractByHdrType.fromField.offset; 4513 p_CcNode->sizeOfExtraction = 4514 p_CcNodeParam->extractCcParams.extractByHdr.extractByHdrType.fromField.size; 4515 p_CcNode->parseCode = 4516 GetFieldParseCode( 4517 p_CcNodeParam->extractCcParams.extractByHdr.hdr, 4518 p_CcNodeParam->extractCcParams.extractByHdr.extractByHdrType.fromField.field, 4519 p_CcNode->offset, 4520 &p_CcNode->prsArrayOffset, 4521 p_CcNodeParam->extractCcParams.extractByHdr.hdrIndex); 4522 break; 4523 4524 default: 4525 DeleteNode(p_CcNode); 4526 RETURN_ERROR(MAJOR, E_INVALID_SELECTION, NO_MSG); 4527 } 4528 break; 4529 4530 case (e_FM_PCD_EXTRACT_NON_HDR): 4531 /* get the field code for the generic extract */ 4532 p_CcNode->sizeOfExtraction = 4533 p_CcNodeParam->extractCcParams.extractNonHdr.size; 4534 p_CcNode->offset = 4535 p_CcNodeParam->extractCcParams.extractNonHdr.offset; 4536 p_CcNode->userOffset = 4537 p_CcNodeParam->extractCcParams.extractNonHdr.offset; 4538 p_CcNode->parseCode = GetGenParseCode( 4539 p_CcNodeParam->extractCcParams.extractNonHdr.src, 4540 p_CcNode->offset, glblMask, &p_CcNode->prsArrayOffset, 4541 fromIc, icCode); 4542 4543 if (p_CcNode->parseCode == CC_PC_GENERIC_IC_HASH_INDEXED) 4544 { 4545 if ((p_CcNode->offset + p_CcNode->sizeOfExtraction) > 8) 4546 { 4547 DeleteNode(p_CcNode); 4548 RETURN_ERROR( 4549 MAJOR, 4550 E_INVALID_SELECTION, 4551 ("when node of the type CC_PC_GENERIC_IC_HASH_INDEXED offset + size can not be bigger then size of HASH 64 bits (8 bytes)")); 4552 } 4553 } 4554 if ((p_CcNode->parseCode == CC_PC_GENERIC_IC_GMASK) 4555 || (p_CcNode->parseCode == CC_PC_GENERIC_IC_HASH_INDEXED)) 4556 { 4557 p_CcNode->offset += p_CcNode->prsArrayOffset; 4558 p_CcNode->prsArrayOffset = 0; 4559 } 4560 break; 4561 4562 default: 4563 DeleteNode(p_CcNode); 4564 RETURN_ERROR(MAJOR, E_INVALID_SELECTION, NO_MSG); 4565 } 4566 4567 if (p_CcNode->parseCode == CC_PC_ILLEGAL) 4568 { 4569 DeleteNode(p_CcNode); 4570 RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("illegal extraction type")); 4571 } 4572 4573 if ((p_CcNode->sizeOfExtraction > FM_PCD_MAX_SIZE_OF_KEY) 4574 || !p_CcNode->sizeOfExtraction) 4575 { 4576 DeleteNode(p_CcNode); 4577 RETURN_ERROR(MAJOR, E_INVALID_VALUE, 4578 ("sizeOfExatrction can not be greater than 56 and not 0")); 4579 } 4580 4581 if (p_CcNodeParam->keysParams.keySize != p_CcNode->sizeOfExtraction) 4582 { 4583 DeleteNode(p_CcNode); 4584 RETURN_ERROR(MAJOR, E_INVALID_VALUE, 4585 ("keySize has to be equal to sizeOfExtraction")); 4586 } 4587 4588 p_CcNode->userSizeOfExtraction = p_CcNode->sizeOfExtraction; 4589 4590 if (!glblMask) 4591 memset(p_CcNode->p_GlblMask, 0xff, CC_GLBL_MASK_SIZE * sizeof(uint8_t)); 4592 4593 err = CheckAndSetManipParamsWithCcNodeParams(p_CcNode); 4594 if (err != E_OK) 4595 { 4596 DeleteNode(p_CcNode); 4597 RETURN_ERROR(MAJOR, E_INVALID_VALUE, 4598 ("keySize has to be equal to sizeOfExtraction")); 4599 } 4600 4601 /* Calculating matching table entry size by rounding up the user-defined size of extraction to valid entry size */ 4602 GetCcExtractKeySize(p_CcNode->sizeOfExtraction, 4603 &p_CcNode->ccKeySizeAccExtraction); 4604 4605 /* If local mask is used, it is stored next to each key in the keys match table */ 4606 if (p_CcNode->lclMask) 4607 keySize = (uint32_t)(2 * p_CcNode->ccKeySizeAccExtraction); 4608 else 4609 keySize = p_CcNode->ccKeySizeAccExtraction; 4610 4611 /* Update CC shadow with maximal size required by this node */ 4612 if (p_CcNode->maxNumOfKeys) 4613 { 4614 err = CalcAndUpdateCcShadow(p_CcNode, isKeyTblAlloc, &matchTableSize, 4615 &adTableSize); 4616 if (err != E_OK) 4617 { 4618 DeleteNode(p_CcNode); 4619 RETURN_ERROR(MAJOR, err, NO_MSG); 4620 } 4621 4622 p_CcNode->keysMatchTableMaxSize = matchTableSize; 4623 4624 if (p_CcNode->statisticsMode != e_FM_PCD_CC_STATS_MODE_NONE) 4625 { 4626 err = AllocStatsObjs(p_CcNode); 4627 if (err != E_OK) 4628 { 4629 DeleteNode(p_CcNode); 4630 RETURN_ERROR(MAJOR, err, NO_MSG); 4631 } 4632 } 4633 4634 /* If manipulation will be initialized before this node, it will use the table 4635 descriptor in the AD table of previous node and this node will need an extra 4636 AD as his table descriptor. */ 4637 p_CcNode->h_TmpAd = (t_Handle)FM_MURAM_AllocMem( 4638 h_FmMuram, FM_PCD_CC_AD_ENTRY_SIZE, FM_PCD_CC_AD_TABLE_ALIGN); 4639 if (!p_CcNode->h_TmpAd) 4640 { 4641 DeleteNode(p_CcNode); 4642 RETURN_ERROR(MAJOR, E_NO_MEMORY, 4643 ("MURAM allocation for CC action descriptor")); 4644 } 4645 } 4646 else 4647 { 4648 matchTableSize = (uint32_t)(keySize * sizeof(uint8_t) 4649 * (p_CcNode->numOfKeys + 1)); 4650 adTableSize = (uint32_t)(FM_PCD_CC_AD_ENTRY_SIZE 4651 * (p_CcNode->numOfKeys + 1)); 4652 } 4653 4654 #if (DPAA_VERSION >= 11) 4655 switch (p_CcNode->statisticsMode) 4656 { 4657 4658 case e_FM_PCD_CC_STATS_MODE_RMON: 4659 /* If RMON statistics or RMON conditional statistics modes are requested, 4660 allocate frame length ranges array */ 4661 p_CcNode->h_StatsFLRs = FM_MURAM_AllocMem( 4662 h_FmMuram, 4663 (uint32_t)(p_CcNode->numOfStatsFLRs) 4664 * FM_PCD_CC_STATS_FLR_SIZE, 4665 FM_PCD_CC_AD_TABLE_ALIGN); 4666 4667 if (!p_CcNode->h_StatsFLRs) 4668 { 4669 DeleteNode(p_CcNode); 4670 RETURN_ERROR( 4671 MAJOR, E_NO_MEMORY, 4672 ("MURAM allocation for CC frame length ranges array")); 4673 } 4674 4675 /* Initialize using value received from the user */ 4676 for (tmp = 0; tmp < p_CcNode->numOfStatsFLRs; tmp++) 4677 { 4678 uint16_t flr = 4679 cpu_to_be16(p_CcNodeParam->keysParams.frameLengthRanges[tmp]); 4680 4681 h_StatsFLRs = 4682 PTR_MOVE(p_CcNode->h_StatsFLRs, tmp * FM_PCD_CC_STATS_FLR_SIZE); 4683 4684 MemCpy8(h_StatsFLRs, 4685 &flr, 4686 FM_PCD_CC_STATS_FLR_SIZE); 4687 } 4688 break; 4689 4690 default: 4691 break; 4692 } 4693 #endif /* (DPAA_VERSION >= 11) */ 4694 4695 /* Allocate keys match table. Not required for some CC nodes, for example for IPv4 TTL 4696 identification, IPv6 hop count identification, etc. */ 4697 if (isKeyTblAlloc) 4698 { 4699 p_CcNode->h_KeysMatchTable = (t_Handle)FM_MURAM_AllocMem( 4700 h_FmMuram, matchTableSize, FM_PCD_CC_KEYS_MATCH_TABLE_ALIGN); 4701 if (!p_CcNode->h_KeysMatchTable) 4702 { 4703 DeleteNode(p_CcNode); 4704 RETURN_ERROR(MAJOR, E_NO_MEMORY, 4705 ("MURAM allocation for CC node key match table")); 4706 } 4707 MemSet8((uint8_t *)p_CcNode->h_KeysMatchTable, 0, matchTableSize); 4708 } 4709 4710 /* Allocate action descriptors table */ 4711 p_CcNode->h_AdTable = (t_Handle)FM_MURAM_AllocMem(h_FmMuram, adTableSize, 4712 FM_PCD_CC_AD_TABLE_ALIGN); 4713 if (!p_CcNode->h_AdTable) 4714 { 4715 DeleteNode(p_CcNode); 4716 RETURN_ERROR(MAJOR, E_NO_MEMORY, 4717 ("MURAM allocation for CC node action descriptors table")); 4718 } 4719 MemSet8((uint8_t *)p_CcNode->h_AdTable, 0, adTableSize); 4720 4721 p_KeysMatchTblTmp = p_CcNode->h_KeysMatchTable; 4722 p_AdTableTmp = p_CcNode->h_AdTable; 4723 4724 /* For each key, create the key and the next step AD */ 4725 for (tmp = 0; tmp < p_CcNode->numOfKeys; tmp++) 4726 { 4727 p_KeyParams = &p_CcNodeParam->keysParams.keyParams[tmp]; 4728 4729 if (p_KeysMatchTblTmp) 4730 { 4731 /* Copy the key */ 4732 MemCpy8((void*)p_KeysMatchTblTmp, p_KeyParams->p_Key, 4733 p_CcNode->sizeOfExtraction); 4734 4735 /* Copy the key mask or initialize it to 0xFF..F */ 4736 if (p_CcNode->lclMask && p_KeyParams->p_Mask) 4737 { 4738 MemCpy8(PTR_MOVE(p_KeysMatchTblTmp, 4739 p_CcNode->ccKeySizeAccExtraction), /* User's size of extraction rounded up to a valid matching table entry size */ 4740 p_KeyParams->p_Mask, p_CcNode->sizeOfExtraction); /* Exact size of extraction as received from the user */ 4741 } 4742 else 4743 if (p_CcNode->lclMask) 4744 { 4745 MemSet8(PTR_MOVE(p_KeysMatchTblTmp, 4746 p_CcNode->ccKeySizeAccExtraction), /* User's size of extraction rounded up to a valid matching table entry size */ 4747 0xff, p_CcNode->sizeOfExtraction); /* Exact size of extraction as received from the user */ 4748 } 4749 4750 p_KeysMatchTblTmp = 4751 PTR_MOVE(p_KeysMatchTblTmp, keySize * sizeof(uint8_t)); 4752 } 4753 4754 /* Create the next action descriptor in the match table */ 4755 if (p_KeyParams->ccNextEngineParams.statisticsEn) 4756 { 4757 p_StatsObj = GetStatsObj(p_CcNode); 4758 ASSERT_COND(p_StatsObj); 4759 4760 statsParams.h_StatsAd = p_StatsObj->h_StatsAd; 4761 statsParams.h_StatsCounters = p_StatsObj->h_StatsCounters; 4762 #if (DPAA_VERSION >= 11) 4763 statsParams.h_StatsFLRs = p_CcNode->h_StatsFLRs; 4764 4765 #endif /* (DPAA_VERSION >= 11) */ 4766 NextStepAd(p_AdTableTmp, &statsParams, 4767 &p_KeyParams->ccNextEngineParams, p_FmPcd); 4768 4769 p_CcNode->keyAndNextEngineParams[tmp].p_StatsObj = p_StatsObj; 4770 } 4771 else 4772 { 4773 NextStepAd(p_AdTableTmp, NULL, &p_KeyParams->ccNextEngineParams, 4774 p_FmPcd); 4775 4776 p_CcNode->keyAndNextEngineParams[tmp].p_StatsObj = NULL; 4777 } 4778 4779 p_AdTableTmp = PTR_MOVE(p_AdTableTmp, FM_PCD_CC_AD_ENTRY_SIZE); 4780 } 4781 4782 /* Update next engine for the 'miss' entry */ 4783 if (p_CcNodeParam->keysParams.ccNextEngineParamsForMiss.statisticsEn) 4784 { 4785 p_StatsObj = GetStatsObj(p_CcNode); 4786 ASSERT_COND(p_StatsObj); 4787 4788 /* All 'bucket' nodes of a hash table should share the same statistics counters, 4789 allocated by the hash table. So, if this node is a bucket of a hash table, 4790 we'll replace the locally allocated counters with the shared counters. */ 4791 if (p_CcNode->isHashBucket) 4792 { 4793 ASSERT_COND(p_CcNode->h_MissStatsCounters); 4794 4795 /* Store original counters pointer and replace it with mutual preallocated pointer */ 4796 p_CcNode->h_PrivMissStatsCounters = p_StatsObj->h_StatsCounters; 4797 p_StatsObj->h_StatsCounters = p_CcNode->h_MissStatsCounters; 4798 } 4799 4800 statsParams.h_StatsAd = p_StatsObj->h_StatsAd; 4801 statsParams.h_StatsCounters = p_StatsObj->h_StatsCounters; 4802 #if (DPAA_VERSION >= 11) 4803 statsParams.h_StatsFLRs = p_CcNode->h_StatsFLRs; 4804 4805 #endif /* (DPAA_VERSION >= 11) */ 4806 4807 NextStepAd(p_AdTableTmp, &statsParams, 4808 &p_CcNodeParam->keysParams.ccNextEngineParamsForMiss, 4809 p_FmPcd); 4810 4811 p_CcNode->keyAndNextEngineParams[tmp].p_StatsObj = p_StatsObj; 4812 } 4813 else 4814 { 4815 NextStepAd(p_AdTableTmp, NULL, 4816 &p_CcNodeParam->keysParams.ccNextEngineParamsForMiss, 4817 p_FmPcd); 4818 4819 p_CcNode->keyAndNextEngineParams[tmp].p_StatsObj = NULL; 4820 } 4821 4822 /* This parameter will be used to initialize the "key length" field in the action descriptor 4823 that points to this node and it should be 0 for full field extraction */ 4824 if (fullField == TRUE) 4825 p_CcNode->sizeOfExtraction = 0; 4826 4827 for (tmp = 0; tmp < MIN(p_CcNode->numOfKeys + 1, CC_MAX_NUM_OF_KEYS); tmp++) 4828 { 4829 if (p_CcNode->keyAndNextEngineParams[tmp].nextEngineParams.nextEngine 4830 == e_FM_PCD_CC) 4831 { 4832 p_FmPcdCcNextNode = 4833 (t_FmPcdCcNode*)p_CcNode->keyAndNextEngineParams[tmp].nextEngineParams.params.ccParams.h_CcNode; 4834 p_CcInformation = FindNodeInfoInReleventLst( 4835 &p_FmPcdCcNextNode->ccPrevNodesLst, (t_Handle)p_CcNode, 4836 p_FmPcdCcNextNode->h_Spinlock); 4837 if (!p_CcInformation) 4838 { 4839 memset(&ccNodeInfo, 0, sizeof(t_CcNodeInformation)); 4840 ccNodeInfo.h_CcNode = (t_Handle)p_CcNode; 4841 ccNodeInfo.index = 1; 4842 EnqueueNodeInfoToRelevantLst(&p_FmPcdCcNextNode->ccPrevNodesLst, 4843 &ccNodeInfo, 4844 p_FmPcdCcNextNode->h_Spinlock); 4845 } 4846 else 4847 p_CcInformation->index++; 4848 4849 if (p_CcNode->keyAndNextEngineParams[tmp].nextEngineParams.h_Manip) 4850 { 4851 h_Manip = 4852 p_CcNode->keyAndNextEngineParams[tmp].nextEngineParams.h_Manip; 4853 p_CcInformation = FindNodeInfoInReleventLst( 4854 FmPcdManipGetNodeLstPointedOnThisManip(h_Manip), 4855 (t_Handle)p_CcNode, FmPcdManipGetSpinlock(h_Manip)); 4856 if (!p_CcInformation) 4857 { 4858 memset(&ccNodeInfo, 0, sizeof(t_CcNodeInformation)); 4859 ccNodeInfo.h_CcNode = (t_Handle)p_CcNode; 4860 ccNodeInfo.index = 1; 4861 EnqueueNodeInfoToRelevantLst( 4862 FmPcdManipGetNodeLstPointedOnThisManip(h_Manip), 4863 &ccNodeInfo, FmPcdManipGetSpinlock(h_Manip)); 4864 } 4865 else 4866 p_CcInformation->index++; 4867 } 4868 } 4869 } 4870 4871 p_AdTableTmp = p_CcNode->h_AdTable; 4872 4873 if (!FmPcdLockTryLockAll(h_FmPcd)) 4874 { 4875 FM_PCD_MatchTableDelete((t_Handle)p_CcNode); 4876 DBG(TRACE, ("FmPcdLockTryLockAll failed")); 4877 return ERROR_CODE(E_BUSY); 4878 } 4879 4880 /* Required action for each next engine */ 4881 for (tmp = 0; tmp < MIN(p_CcNode->numOfKeys + 1, CC_MAX_NUM_OF_KEYS); tmp++) 4882 { 4883 if (p_CcNode->keyAndNextEngineParams[tmp].requiredAction) 4884 { 4885 err = SetRequiredAction( 4886 h_FmPcd, 4887 p_CcNode->keyAndNextEngineParams[tmp].requiredAction, 4888 &p_CcNode->keyAndNextEngineParams[tmp], p_AdTableTmp, 1, 4889 NULL); 4890 if (err) 4891 { 4892 FmPcdLockUnlockAll(h_FmPcd); 4893 FM_PCD_MatchTableDelete((t_Handle)p_CcNode); 4894 RETURN_ERROR(MAJOR, err, NO_MSG); 4895 } 4896 p_AdTableTmp = PTR_MOVE(p_AdTableTmp, FM_PCD_CC_AD_ENTRY_SIZE); 4897 } 4898 } 4899 4900 FmPcdLockUnlockAll(h_FmPcd); 4901 4902 return E_OK; 4903 } 4904 /************************** End of static functions **************************/ 4905 4906 /*****************************************************************************/ 4907 /* Inter-module API routines */ 4908 /*****************************************************************************/ 4909 4910 t_CcNodeInformation* FindNodeInfoInReleventLst(t_List *p_List, t_Handle h_Info, 4911 t_Handle h_Spinlock) 4912 { 4913 t_CcNodeInformation *p_CcInformation; 4914 t_List *p_Pos; 4915 uint32_t intFlags; 4916 4917 intFlags = XX_LockIntrSpinlock(h_Spinlock); 4918 4919 for (p_Pos = NCSW_LIST_FIRST(p_List); p_Pos != (p_List); 4920 p_Pos = NCSW_LIST_NEXT(p_Pos)) 4921 { 4922 p_CcInformation = CC_NODE_F_OBJECT(p_Pos); 4923 4924 ASSERT_COND(p_CcInformation->h_CcNode); 4925 4926 if (p_CcInformation->h_CcNode == h_Info) 4927 { 4928 XX_UnlockIntrSpinlock(h_Spinlock, intFlags); 4929 return p_CcInformation; 4930 } 4931 } 4932 4933 XX_UnlockIntrSpinlock(h_Spinlock, intFlags); 4934 4935 return NULL; 4936 } 4937 4938 void EnqueueNodeInfoToRelevantLst(t_List *p_List, t_CcNodeInformation *p_CcInfo, 4939 t_Handle h_Spinlock) 4940 { 4941 t_CcNodeInformation *p_CcInformation; 4942 uint32_t intFlags = 0; 4943 4944 p_CcInformation = (t_CcNodeInformation *)XX_Malloc( 4945 sizeof(t_CcNodeInformation)); 4946 4947 if (p_CcInformation) 4948 { 4949 memset(p_CcInformation, 0, sizeof(t_CcNodeInformation)); 4950 memcpy(p_CcInformation, p_CcInfo, sizeof(t_CcNodeInformation)); 4951 INIT_LIST(&p_CcInformation->node); 4952 4953 if (h_Spinlock) 4954 intFlags = XX_LockIntrSpinlock(h_Spinlock); 4955 4956 NCSW_LIST_AddToTail(&p_CcInformation->node, p_List); 4957 4958 if (h_Spinlock) 4959 XX_UnlockIntrSpinlock(h_Spinlock, intFlags); 4960 } 4961 else 4962 REPORT_ERROR(MAJOR, E_NO_MEMORY, ("CC Node Information")); 4963 } 4964 4965 void DequeueNodeInfoFromRelevantLst(t_List *p_List, t_Handle h_Info, 4966 t_Handle h_Spinlock) 4967 { 4968 t_CcNodeInformation *p_CcInformation = NULL; 4969 uint32_t intFlags = 0; 4970 t_List *p_Pos; 4971 4972 if (h_Spinlock) 4973 intFlags = XX_LockIntrSpinlock(h_Spinlock); 4974 4975 if (NCSW_LIST_IsEmpty(p_List)) 4976 { 4977 XX_RestoreAllIntr(intFlags); 4978 return; 4979 } 4980 4981 for (p_Pos = NCSW_LIST_FIRST(p_List); p_Pos != (p_List); 4982 p_Pos = NCSW_LIST_NEXT(p_Pos)) 4983 { 4984 p_CcInformation = CC_NODE_F_OBJECT(p_Pos); 4985 ASSERT_COND(p_CcInformation); 4986 ASSERT_COND(p_CcInformation->h_CcNode); 4987 if (p_CcInformation->h_CcNode == h_Info) 4988 break; 4989 } 4990 4991 if (p_CcInformation) 4992 { 4993 NCSW_LIST_DelAndInit(&p_CcInformation->node); 4994 XX_Free(p_CcInformation); 4995 } 4996 4997 if (h_Spinlock) 4998 XX_UnlockIntrSpinlock(h_Spinlock, intFlags); 4999 } 5000 5001 void NextStepAd(t_Handle h_Ad, t_FmPcdCcStatsParams *p_FmPcdCcStatsParams, 5002 t_FmPcdCcNextEngineParams *p_FmPcdCcNextEngineParams, 5003 t_FmPcd *p_FmPcd) 5004 { 5005 switch (p_FmPcdCcNextEngineParams->nextEngine) 5006 { 5007 case (e_FM_PCD_KG): 5008 case (e_FM_PCD_PLCR): 5009 case (e_FM_PCD_DONE): 5010 /* if NIA is not CC, create a "result" type AD */ 5011 FillAdOfTypeResult(h_Ad, p_FmPcdCcStatsParams, p_FmPcd, 5012 p_FmPcdCcNextEngineParams); 5013 break; 5014 #if (DPAA_VERSION >= 11) 5015 case (e_FM_PCD_FR): 5016 if (p_FmPcdCcNextEngineParams->params.frParams.h_FrmReplic) 5017 { 5018 FillAdOfTypeContLookup( 5019 h_Ad, p_FmPcdCcStatsParams, p_FmPcd, 5020 p_FmPcdCcNextEngineParams->params.ccParams.h_CcNode, 5021 p_FmPcdCcNextEngineParams->h_Manip, 5022 p_FmPcdCcNextEngineParams->params.frParams.h_FrmReplic); 5023 FrmReplicGroupUpdateOwner( 5024 p_FmPcdCcNextEngineParams->params.frParams.h_FrmReplic, 5025 TRUE/* add */); 5026 } 5027 break; 5028 #endif /* (DPAA_VERSION >= 11) */ 5029 5030 case (e_FM_PCD_CC): 5031 /* if NIA is not CC, create a TD to continue the CC lookup */ 5032 FillAdOfTypeContLookup( 5033 h_Ad, p_FmPcdCcStatsParams, p_FmPcd, 5034 p_FmPcdCcNextEngineParams->params.ccParams.h_CcNode, 5035 p_FmPcdCcNextEngineParams->h_Manip, NULL); 5036 5037 UpdateNodeOwner(p_FmPcdCcNextEngineParams->params.ccParams.h_CcNode, 5038 TRUE); 5039 break; 5040 5041 default: 5042 return; 5043 } 5044 } 5045 5046 t_Error FmPcdCcTreeAddIPR(t_Handle h_FmPcd, t_Handle h_FmTree, 5047 t_Handle h_NetEnv, t_Handle h_IpReassemblyManip, 5048 bool createSchemes) 5049 { 5050 t_FmPcdCcTree *p_FmPcdCcTree = (t_FmPcdCcTree *)h_FmTree; 5051 t_FmPcdCcNextEngineParams nextEngineParams; 5052 t_NetEnvParams netEnvParams; 5053 t_Handle h_Ad; 5054 bool isIpv6Present; 5055 uint8_t ipv4GroupId, ipv6GroupId; 5056 t_Error err; 5057 5058 ASSERT_COND(p_FmPcdCcTree); 5059 5060 /* this routine must be protected by the calling routine! */ 5061 5062 memset(&nextEngineParams, 0, sizeof(t_FmPcdCcNextEngineParams)); 5063 memset(&netEnvParams, 0, sizeof(t_NetEnvParams)); 5064 5065 h_Ad = UINT_TO_PTR(p_FmPcdCcTree->ccTreeBaseAddr); 5066 5067 isIpv6Present = FmPcdManipIpReassmIsIpv6Hdr(h_IpReassemblyManip); 5068 5069 if (isIpv6Present 5070 && (p_FmPcdCcTree->numOfEntries > (FM_PCD_MAX_NUM_OF_CC_GROUPS - 2))) 5071 RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("need two free entries for IPR")); 5072 5073 if (p_FmPcdCcTree->numOfEntries > (FM_PCD_MAX_NUM_OF_CC_GROUPS - 1)) 5074 RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("need two free entries for IPR")); 5075 5076 nextEngineParams.nextEngine = e_FM_PCD_DONE; 5077 nextEngineParams.h_Manip = h_IpReassemblyManip; 5078 5079 /* Lock tree */ 5080 err = CcRootTryLock(p_FmPcdCcTree); 5081 if (err) 5082 return ERROR_CODE(E_BUSY); 5083 5084 if (p_FmPcdCcTree->h_IpReassemblyManip == h_IpReassemblyManip) 5085 { 5086 CcRootReleaseLock(p_FmPcdCcTree); 5087 return E_OK; 5088 } 5089 5090 if ((p_FmPcdCcTree->h_IpReassemblyManip) 5091 && (p_FmPcdCcTree->h_IpReassemblyManip != h_IpReassemblyManip)) 5092 { 5093 CcRootReleaseLock(p_FmPcdCcTree); 5094 RETURN_ERROR(MAJOR, E_INVALID_STATE, 5095 ("This tree was previously updated with different IPR")); 5096 } 5097 5098 /* Initialize IPR for the first time for this tree */ 5099 if (isIpv6Present) 5100 { 5101 ipv6GroupId = p_FmPcdCcTree->numOfGrps++; 5102 p_FmPcdCcTree->fmPcdGroupParam[ipv6GroupId].baseGroupEntry = 5103 (FM_PCD_MAX_NUM_OF_CC_GROUPS - 2); 5104 5105 if (createSchemes) 5106 { 5107 err = FmPcdManipBuildIpReassmScheme(h_FmPcd, h_NetEnv, 5108 p_FmPcdCcTree, 5109 h_IpReassemblyManip, FALSE, 5110 ipv6GroupId); 5111 if (err) 5112 { 5113 p_FmPcdCcTree->numOfGrps--; 5114 CcRootReleaseLock(p_FmPcdCcTree); 5115 RETURN_ERROR(MAJOR, err, NO_MSG); 5116 } 5117 } 5118 5119 NextStepAd( 5120 PTR_MOVE(h_Ad, (FM_PCD_MAX_NUM_OF_CC_GROUPS-2) * FM_PCD_CC_AD_ENTRY_SIZE), 5121 NULL, &nextEngineParams, h_FmPcd); 5122 } 5123 5124 ipv4GroupId = p_FmPcdCcTree->numOfGrps++; 5125 p_FmPcdCcTree->fmPcdGroupParam[ipv4GroupId].totalBitsMask = 0; 5126 p_FmPcdCcTree->fmPcdGroupParam[ipv4GroupId].baseGroupEntry = 5127 (FM_PCD_MAX_NUM_OF_CC_GROUPS - 1); 5128 5129 if (createSchemes) 5130 { 5131 err = FmPcdManipBuildIpReassmScheme(h_FmPcd, h_NetEnv, p_FmPcdCcTree, 5132 h_IpReassemblyManip, TRUE, 5133 ipv4GroupId); 5134 if (err) 5135 { 5136 p_FmPcdCcTree->numOfGrps--; 5137 if (isIpv6Present) 5138 { 5139 p_FmPcdCcTree->numOfGrps--; 5140 FmPcdManipDeleteIpReassmSchemes(h_IpReassemblyManip); 5141 } 5142 CcRootReleaseLock(p_FmPcdCcTree); 5143 RETURN_ERROR(MAJOR, err, NO_MSG); 5144 } 5145 } 5146 5147 NextStepAd( 5148 PTR_MOVE(h_Ad, (FM_PCD_MAX_NUM_OF_CC_GROUPS-1) * FM_PCD_CC_AD_ENTRY_SIZE), 5149 NULL, &nextEngineParams, h_FmPcd); 5150 5151 p_FmPcdCcTree->h_IpReassemblyManip = h_IpReassemblyManip; 5152 5153 CcRootReleaseLock(p_FmPcdCcTree); 5154 5155 return E_OK; 5156 } 5157 5158 t_Error FmPcdCcTreeAddCPR(t_Handle h_FmPcd, t_Handle h_FmTree, 5159 t_Handle h_NetEnv, t_Handle h_ReassemblyManip, 5160 bool createSchemes) 5161 { 5162 t_FmPcdCcTree *p_FmPcdCcTree = (t_FmPcdCcTree *)h_FmTree; 5163 t_FmPcdCcNextEngineParams nextEngineParams; 5164 t_NetEnvParams netEnvParams; 5165 t_Handle h_Ad; 5166 uint8_t groupId; 5167 t_Error err; 5168 5169 ASSERT_COND(p_FmPcdCcTree); 5170 5171 /* this routine must be protected by the calling routine! */ 5172 memset(&nextEngineParams, 0, sizeof(t_FmPcdCcNextEngineParams)); 5173 memset(&netEnvParams, 0, sizeof(t_NetEnvParams)); 5174 5175 h_Ad = UINT_TO_PTR(p_FmPcdCcTree->ccTreeBaseAddr); 5176 5177 if (p_FmPcdCcTree->numOfEntries > (FM_PCD_MAX_NUM_OF_CC_GROUPS - 1)) 5178 RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("need one free entries for CPR")); 5179 5180 nextEngineParams.nextEngine = e_FM_PCD_DONE; 5181 nextEngineParams.h_Manip = h_ReassemblyManip; 5182 5183 /* Lock tree */ 5184 err = CcRootTryLock(p_FmPcdCcTree); 5185 if (err) 5186 return ERROR_CODE(E_BUSY); 5187 5188 if (p_FmPcdCcTree->h_CapwapReassemblyManip == h_ReassemblyManip) 5189 { 5190 CcRootReleaseLock(p_FmPcdCcTree); 5191 return E_OK; 5192 } 5193 5194 if ((p_FmPcdCcTree->h_CapwapReassemblyManip) 5195 && (p_FmPcdCcTree->h_CapwapReassemblyManip != h_ReassemblyManip)) 5196 { 5197 CcRootReleaseLock(p_FmPcdCcTree); 5198 RETURN_ERROR(MAJOR, E_INVALID_STATE, 5199 ("This tree was previously updated with different CPR")); 5200 } 5201 5202 groupId = p_FmPcdCcTree->numOfGrps++; 5203 p_FmPcdCcTree->fmPcdGroupParam[groupId].baseGroupEntry = 5204 (FM_PCD_MAX_NUM_OF_CC_GROUPS - 1); 5205 5206 if (createSchemes) 5207 { 5208 err = FmPcdManipBuildCapwapReassmScheme(h_FmPcd, h_NetEnv, 5209 p_FmPcdCcTree, 5210 h_ReassemblyManip, groupId); 5211 if (err) 5212 { 5213 p_FmPcdCcTree->numOfGrps--; 5214 CcRootReleaseLock(p_FmPcdCcTree); 5215 RETURN_ERROR(MAJOR, err, NO_MSG); 5216 } 5217 } 5218 5219 NextStepAd( 5220 PTR_MOVE(h_Ad, (FM_PCD_MAX_NUM_OF_CC_GROUPS-1) * FM_PCD_CC_AD_ENTRY_SIZE), 5221 NULL, &nextEngineParams, h_FmPcd); 5222 5223 p_FmPcdCcTree->h_CapwapReassemblyManip = h_ReassemblyManip; 5224 5225 CcRootReleaseLock(p_FmPcdCcTree); 5226 5227 return E_OK; 5228 } 5229 5230 t_Handle FmPcdCcTreeGetSavedManipParams(t_Handle h_FmTree) 5231 { 5232 t_FmPcdCcTree *p_FmPcdCcTree = (t_FmPcdCcTree *)h_FmTree; 5233 5234 ASSERT_COND(p_FmPcdCcTree); 5235 5236 return p_FmPcdCcTree->h_FmPcdCcSavedManipParams; 5237 } 5238 5239 void FmPcdCcTreeSetSavedManipParams(t_Handle h_FmTree, 5240 t_Handle h_SavedManipParams) 5241 { 5242 t_FmPcdCcTree *p_FmPcdCcTree = (t_FmPcdCcTree *)h_FmTree; 5243 5244 ASSERT_COND(p_FmPcdCcTree); 5245 5246 p_FmPcdCcTree->h_FmPcdCcSavedManipParams = h_SavedManipParams; 5247 } 5248 5249 uint8_t FmPcdCcGetParseCode(t_Handle h_CcNode) 5250 { 5251 t_FmPcdCcNode *p_CcNode = (t_FmPcdCcNode *)h_CcNode; 5252 5253 ASSERT_COND(p_CcNode); 5254 5255 return p_CcNode->parseCode; 5256 } 5257 5258 uint8_t FmPcdCcGetOffset(t_Handle h_CcNode) 5259 { 5260 t_FmPcdCcNode *p_CcNode = (t_FmPcdCcNode *)h_CcNode; 5261 5262 ASSERT_COND(p_CcNode); 5263 5264 return p_CcNode->offset; 5265 } 5266 5267 uint16_t FmPcdCcGetNumOfKeys(t_Handle h_CcNode) 5268 { 5269 t_FmPcdCcNode *p_CcNode = (t_FmPcdCcNode *)h_CcNode; 5270 5271 ASSERT_COND(p_CcNode); 5272 5273 return p_CcNode->numOfKeys; 5274 } 5275 5276 t_Error FmPcdCcModifyNextEngineParamTree( 5277 t_Handle h_FmPcd, t_Handle h_FmPcdCcTree, uint8_t grpId, uint8_t index, 5278 t_FmPcdCcNextEngineParams *p_FmPcdCcNextEngineParams) 5279 { 5280 t_FmPcdCcTree *p_FmPcdCcTree = (t_FmPcdCcTree *)h_FmPcdCcTree; 5281 t_FmPcd *p_FmPcd; 5282 t_List h_OldPointersLst, h_NewPointersLst; 5283 uint16_t keyIndex; 5284 t_FmPcdModifyCcKeyAdditionalParams *p_ModifyKeyParams; 5285 t_Error err = E_OK; 5286 5287 SANITY_CHECK_RETURN_ERROR(h_FmPcd, E_INVALID_HANDLE); 5288 SANITY_CHECK_RETURN_ERROR(h_FmPcdCcTree, E_INVALID_HANDLE); 5289 SANITY_CHECK_RETURN_ERROR((grpId <= 7), E_INVALID_VALUE); 5290 5291 if (grpId >= p_FmPcdCcTree->numOfGrps) 5292 RETURN_ERROR(MAJOR, E_INVALID_HANDLE, 5293 ("grpId you asked > numOfGroup of relevant tree")); 5294 5295 if (index >= p_FmPcdCcTree->fmPcdGroupParam[grpId].numOfEntriesInGroup) 5296 RETURN_ERROR(MAJOR, E_INVALID_HANDLE, ("index > numOfEntriesInGroup")); 5297 5298 p_FmPcd = (t_FmPcd *)h_FmPcd; 5299 5300 INIT_LIST(&h_OldPointersLst); 5301 INIT_LIST(&h_NewPointersLst); 5302 5303 keyIndex = (uint16_t)(p_FmPcdCcTree->fmPcdGroupParam[grpId].baseGroupEntry 5304 + index); 5305 5306 p_ModifyKeyParams = ModifyNodeCommonPart(p_FmPcdCcTree, keyIndex, 5307 e_MODIFY_STATE_CHANGE, FALSE, 5308 FALSE, TRUE); 5309 if (!p_ModifyKeyParams) 5310 RETURN_ERROR(MAJOR, E_INVALID_STATE, NO_MSG); 5311 5312 p_ModifyKeyParams->tree = TRUE; 5313 5314 if (p_FmPcd->p_CcShadow 5315 && !TRY_LOCK(p_FmPcd->h_ShadowSpinlock, &p_FmPcd->shadowLock)) 5316 { 5317 XX_Free(p_ModifyKeyParams); 5318 return ERROR_CODE(E_BUSY); 5319 } 5320 5321 err = BuildNewNodeModifyNextEngine(p_FmPcd, p_FmPcdCcTree, keyIndex, 5322 p_FmPcdCcNextEngineParams, 5323 &h_OldPointersLst, &h_NewPointersLst, 5324 p_ModifyKeyParams); 5325 if (err) 5326 { 5327 XX_Free(p_ModifyKeyParams); 5328 RETURN_ERROR(MAJOR, err, NO_MSG); 5329 } 5330 5331 err = DoDynamicChange(p_FmPcd, &h_OldPointersLst, &h_NewPointersLst, 5332 p_ModifyKeyParams, FALSE); 5333 5334 if (p_FmPcd->p_CcShadow) 5335 RELEASE_LOCK(p_FmPcd->shadowLock); 5336 5337 return err; 5338 5339 } 5340 5341 t_Error FmPcdCcRemoveKey(t_Handle h_FmPcd, t_Handle h_FmPcdCcNode, 5342 uint16_t keyIndex) 5343 { 5344 5345 t_FmPcdCcNode *p_CcNode = (t_FmPcdCcNode *)h_FmPcdCcNode; 5346 t_FmPcd *p_FmPcd; 5347 t_FmPcdModifyCcKeyAdditionalParams *p_ModifyKeyParams; 5348 t_List h_OldPointersLst, h_NewPointersLst; 5349 bool useShadowStructs = FALSE; 5350 t_Error err = E_OK; 5351 5352 if (keyIndex >= p_CcNode->numOfKeys) 5353 RETURN_ERROR(MAJOR, E_INVALID_VALUE, 5354 ("impossible to remove key when numOfKeys <= keyIndex")); 5355 5356 if (p_CcNode->h_FmPcd != h_FmPcd) 5357 RETURN_ERROR( 5358 MAJOR, 5359 E_INVALID_VALUE, 5360 ("handler to FmPcd is different from the handle provided at node initialization time")); 5361 5362 p_FmPcd = (t_FmPcd *)p_CcNode->h_FmPcd; 5363 5364 INIT_LIST(&h_OldPointersLst); 5365 INIT_LIST(&h_NewPointersLst); 5366 5367 p_ModifyKeyParams = ModifyNodeCommonPart(p_CcNode, keyIndex, 5368 e_MODIFY_STATE_REMOVE, TRUE, TRUE, 5369 FALSE); 5370 if (!p_ModifyKeyParams) 5371 RETURN_ERROR(MAJOR, E_INVALID_STATE, NO_MSG); 5372 5373 if (p_CcNode->maxNumOfKeys) 5374 { 5375 if (!TRY_LOCK(p_FmPcd->h_ShadowSpinlock, &p_FmPcd->shadowLock)) 5376 { 5377 XX_Free(p_ModifyKeyParams); 5378 return ERROR_CODE(E_BUSY); 5379 } 5380 5381 useShadowStructs = TRUE; 5382 } 5383 5384 err = BuildNewNodeRemoveKey(p_CcNode, keyIndex, p_ModifyKeyParams); 5385 if (err) 5386 { 5387 XX_Free(p_ModifyKeyParams); 5388 if (p_CcNode->maxNumOfKeys) 5389 RELEASE_LOCK(p_FmPcd->shadowLock); 5390 RETURN_ERROR(MAJOR, err, NO_MSG); 5391 } 5392 5393 err = UpdatePtrWhichPointOnCrntMdfNode(p_CcNode, p_ModifyKeyParams, 5394 &h_OldPointersLst, 5395 &h_NewPointersLst); 5396 if (err) 5397 { 5398 ReleaseNewNodeCommonPart(p_ModifyKeyParams); 5399 XX_Free(p_ModifyKeyParams); 5400 if (p_CcNode->maxNumOfKeys) 5401 RELEASE_LOCK(p_FmPcd->shadowLock); 5402 RETURN_ERROR(MAJOR, err, NO_MSG); 5403 } 5404 5405 err = DoDynamicChange(p_FmPcd, &h_OldPointersLst, &h_NewPointersLst, 5406 p_ModifyKeyParams, useShadowStructs); 5407 5408 if (p_CcNode->maxNumOfKeys) 5409 RELEASE_LOCK(p_FmPcd->shadowLock); 5410 5411 return err; 5412 } 5413 5414 t_Error FmPcdCcModifyKey(t_Handle h_FmPcd, t_Handle h_FmPcdCcNode, 5415 uint16_t keyIndex, uint8_t keySize, uint8_t *p_Key, 5416 uint8_t *p_Mask) 5417 { 5418 t_FmPcdCcNode *p_CcNode = (t_FmPcdCcNode *)h_FmPcdCcNode; 5419 t_FmPcd *p_FmPcd; 5420 t_List h_OldPointersLst, h_NewPointersLst; 5421 t_FmPcdModifyCcKeyAdditionalParams *p_ModifyKeyParams; 5422 uint16_t tmpKeyIndex; 5423 bool useShadowStructs = FALSE; 5424 t_Error err = E_OK; 5425 5426 if (keyIndex >= p_CcNode->numOfKeys) 5427 RETURN_ERROR(MAJOR, E_INVALID_STATE, 5428 ("keyIndex > previously cleared last index + 1")); 5429 5430 if (keySize != p_CcNode->userSizeOfExtraction) 5431 RETURN_ERROR( 5432 MAJOR, 5433 E_INVALID_VALUE, 5434 ("size for ModifyKey has to be the same as defined in SetNode")); 5435 5436 if (p_CcNode->h_FmPcd != h_FmPcd) 5437 RETURN_ERROR( 5438 MAJOR, 5439 E_INVALID_VALUE, 5440 ("handler to FmPcd is different from the handle provided at node initialization time")); 5441 5442 err = FindKeyIndex(h_FmPcdCcNode, keySize, p_Key, p_Mask, &tmpKeyIndex); 5443 if (GET_ERROR_TYPE(err) != E_NOT_FOUND) 5444 RETURN_ERROR( 5445 MINOR, 5446 E_ALREADY_EXISTS, 5447 ("The received key and mask pair was already found in the match table of the provided node")); 5448 5449 p_FmPcd = (t_FmPcd *)p_CcNode->h_FmPcd; 5450 5451 INIT_LIST(&h_OldPointersLst); 5452 INIT_LIST(&h_NewPointersLst); 5453 5454 p_ModifyKeyParams = ModifyNodeCommonPart(p_CcNode, keyIndex, 5455 e_MODIFY_STATE_CHANGE, TRUE, TRUE, 5456 FALSE); 5457 if (!p_ModifyKeyParams) 5458 RETURN_ERROR(MAJOR, E_INVALID_STATE, NO_MSG); 5459 5460 if (p_CcNode->maxNumOfKeys) 5461 { 5462 if (!TRY_LOCK(p_FmPcd->h_ShadowSpinlock, &p_FmPcd->shadowLock)) 5463 { 5464 XX_Free(p_ModifyKeyParams); 5465 return ERROR_CODE(E_BUSY); 5466 } 5467 5468 useShadowStructs = TRUE; 5469 } 5470 5471 err = BuildNewNodeModifyKey(p_CcNode, keyIndex, p_Key, p_Mask, 5472 p_ModifyKeyParams); 5473 if (err) 5474 { 5475 XX_Free(p_ModifyKeyParams); 5476 if (p_CcNode->maxNumOfKeys) 5477 RELEASE_LOCK(p_FmPcd->shadowLock); 5478 RETURN_ERROR(MAJOR, err, NO_MSG); 5479 } 5480 5481 err = UpdatePtrWhichPointOnCrntMdfNode(p_CcNode, p_ModifyKeyParams, 5482 &h_OldPointersLst, 5483 &h_NewPointersLst); 5484 if (err) 5485 { 5486 ReleaseNewNodeCommonPart(p_ModifyKeyParams); 5487 XX_Free(p_ModifyKeyParams); 5488 if (p_CcNode->maxNumOfKeys) 5489 RELEASE_LOCK(p_FmPcd->shadowLock); 5490 RETURN_ERROR(MAJOR, err, NO_MSG); 5491 } 5492 5493 err = DoDynamicChange(p_FmPcd, &h_OldPointersLst, &h_NewPointersLst, 5494 p_ModifyKeyParams, useShadowStructs); 5495 5496 if (p_CcNode->maxNumOfKeys) 5497 RELEASE_LOCK(p_FmPcd->shadowLock); 5498 5499 return err; 5500 } 5501 5502 t_Error FmPcdCcModifyMissNextEngineParamNode( 5503 t_Handle h_FmPcd, t_Handle h_FmPcdCcNode, 5504 t_FmPcdCcNextEngineParams *p_FmPcdCcNextEngineParams) 5505 { 5506 t_FmPcdCcNode *p_CcNode = (t_FmPcdCcNode *)h_FmPcdCcNode; 5507 t_FmPcd *p_FmPcd; 5508 t_List h_OldPointersLst, h_NewPointersLst; 5509 uint16_t keyIndex; 5510 t_FmPcdModifyCcKeyAdditionalParams *p_ModifyKeyParams; 5511 t_Error err = E_OK; 5512 5513 SANITY_CHECK_RETURN_ERROR(p_CcNode, E_INVALID_VALUE); 5514 5515 keyIndex = p_CcNode->numOfKeys; 5516 5517 p_FmPcd = (t_FmPcd *)p_CcNode->h_FmPcd; 5518 5519 INIT_LIST(&h_OldPointersLst); 5520 INIT_LIST(&h_NewPointersLst); 5521 5522 p_ModifyKeyParams = ModifyNodeCommonPart(p_CcNode, keyIndex, 5523 e_MODIFY_STATE_CHANGE, FALSE, TRUE, 5524 FALSE); 5525 if (!p_ModifyKeyParams) 5526 RETURN_ERROR(MAJOR, E_INVALID_STATE, NO_MSG); 5527 5528 if (p_CcNode->maxNumOfKeys 5529 && !TRY_LOCK(p_FmPcd->h_ShadowSpinlock, &p_FmPcd->shadowLock)) 5530 { 5531 XX_Free(p_ModifyKeyParams); 5532 return ERROR_CODE(E_BUSY); 5533 } 5534 5535 err = BuildNewNodeModifyNextEngine(h_FmPcd, p_CcNode, keyIndex, 5536 p_FmPcdCcNextEngineParams, 5537 &h_OldPointersLst, &h_NewPointersLst, 5538 p_ModifyKeyParams); 5539 if (err) 5540 { 5541 XX_Free(p_ModifyKeyParams); 5542 if (p_CcNode->maxNumOfKeys) 5543 RELEASE_LOCK(p_FmPcd->shadowLock); 5544 RETURN_ERROR(MAJOR, err, NO_MSG); 5545 } 5546 5547 err = DoDynamicChange(p_FmPcd, &h_OldPointersLst, &h_NewPointersLst, 5548 p_ModifyKeyParams, FALSE); 5549 5550 if (p_CcNode->maxNumOfKeys) 5551 RELEASE_LOCK(p_FmPcd->shadowLock); 5552 5553 return err; 5554 } 5555 5556 t_Error FmPcdCcAddKey(t_Handle h_FmPcd, t_Handle h_FmPcdCcNode, 5557 uint16_t keyIndex, uint8_t keySize, 5558 t_FmPcdCcKeyParams *p_FmPcdCcKeyParams) 5559 { 5560 t_FmPcdCcNode *p_CcNode = (t_FmPcdCcNode *)h_FmPcdCcNode; 5561 t_FmPcd *p_FmPcd; 5562 t_FmPcdModifyCcKeyAdditionalParams *p_ModifyKeyParams; 5563 t_List h_OldPointersLst, h_NewPointersLst; 5564 bool useShadowStructs = FALSE; 5565 uint16_t tmpKeyIndex; 5566 t_Error err = E_OK; 5567 5568 if (keyIndex > p_CcNode->numOfKeys) 5569 RETURN_ERROR(MAJOR, E_NOT_IN_RANGE, 5570 ("keyIndex > previously cleared last index + 1")); 5571 5572 if (keySize != p_CcNode->userSizeOfExtraction) 5573 RETURN_ERROR( 5574 MAJOR, 5575 E_INVALID_VALUE, 5576 ("keySize has to be defined as it was defined in initialization step")); 5577 5578 if (p_CcNode->h_FmPcd != h_FmPcd) 5579 RETURN_ERROR( 5580 MAJOR, 5581 E_INVALID_VALUE, 5582 ("handler to FmPcd is different from the handle provided at node initialization time")); 5583 5584 if (p_CcNode->maxNumOfKeys) 5585 { 5586 if (p_CcNode->numOfKeys == p_CcNode->maxNumOfKeys) 5587 RETURN_ERROR( 5588 MAJOR, 5589 E_FULL, 5590 ("number of keys exceeds the maximal number of keys provided at node initialization time")); 5591 } 5592 else 5593 if (p_CcNode->numOfKeys == FM_PCD_MAX_NUM_OF_KEYS) 5594 RETURN_ERROR( 5595 MAJOR, 5596 E_INVALID_VALUE, 5597 ("number of keys can not be larger than %d", FM_PCD_MAX_NUM_OF_KEYS)); 5598 5599 err = FindKeyIndex(h_FmPcdCcNode, keySize, p_FmPcdCcKeyParams->p_Key, 5600 p_FmPcdCcKeyParams->p_Mask, &tmpKeyIndex); 5601 if (GET_ERROR_TYPE(err) != E_NOT_FOUND) 5602 RETURN_ERROR( 5603 MAJOR, 5604 E_ALREADY_EXISTS, 5605 ("The received key and mask pair was already found in the match table of the provided node")); 5606 5607 p_FmPcd = (t_FmPcd *)p_CcNode->h_FmPcd; 5608 5609 INIT_LIST(&h_OldPointersLst); 5610 INIT_LIST(&h_NewPointersLst); 5611 5612 p_ModifyKeyParams = ModifyNodeCommonPart(p_CcNode, keyIndex, 5613 e_MODIFY_STATE_ADD, TRUE, TRUE, 5614 FALSE); 5615 if (!p_ModifyKeyParams) 5616 RETURN_ERROR(MAJOR, E_INVALID_STATE, NO_MSG); 5617 5618 if (p_CcNode->maxNumOfKeys) 5619 { 5620 if (!TRY_LOCK(p_FmPcd->h_ShadowSpinlock, &p_FmPcd->shadowLock)) 5621 { 5622 XX_Free(p_ModifyKeyParams); 5623 return ERROR_CODE(E_BUSY); 5624 } 5625 5626 useShadowStructs = TRUE; 5627 } 5628 5629 err = BuildNewNodeAddOrMdfyKeyAndNextEngine(h_FmPcd, p_CcNode, keyIndex, 5630 p_FmPcdCcKeyParams, 5631 p_ModifyKeyParams, TRUE); 5632 if (err) 5633 { 5634 ReleaseNewNodeCommonPart(p_ModifyKeyParams); 5635 XX_Free(p_ModifyKeyParams); 5636 if (p_CcNode->maxNumOfKeys) 5637 RELEASE_LOCK(p_FmPcd->shadowLock); 5638 RETURN_ERROR(MAJOR, err, NO_MSG); 5639 } 5640 5641 err = UpdatePtrWhichPointOnCrntMdfNode(p_CcNode, p_ModifyKeyParams, 5642 &h_OldPointersLst, 5643 &h_NewPointersLst); 5644 if (err) 5645 { 5646 ReleaseNewNodeCommonPart(p_ModifyKeyParams); 5647 XX_Free(p_ModifyKeyParams); 5648 if (p_CcNode->maxNumOfKeys) 5649 RELEASE_LOCK(p_FmPcd->shadowLock); 5650 RETURN_ERROR(MAJOR, err, NO_MSG); 5651 } 5652 5653 err = DoDynamicChange(p_FmPcd, &h_OldPointersLst, &h_NewPointersLst, 5654 p_ModifyKeyParams, useShadowStructs); 5655 if (p_CcNode->maxNumOfKeys) 5656 RELEASE_LOCK(p_FmPcd->shadowLock); 5657 5658 return err; 5659 } 5660 5661 t_Error FmPcdCcModifyKeyAndNextEngine(t_Handle h_FmPcd, t_Handle h_FmPcdCcNode, 5662 uint16_t keyIndex, uint8_t keySize, 5663 t_FmPcdCcKeyParams *p_FmPcdCcKeyParams) 5664 { 5665 t_FmPcdCcNode *p_CcNode = (t_FmPcdCcNode *)h_FmPcdCcNode; 5666 t_FmPcd *p_FmPcd; 5667 t_List h_OldPointersLst, h_NewPointersLst; 5668 t_FmPcdModifyCcKeyAdditionalParams *p_ModifyKeyParams; 5669 uint16_t tmpKeyIndex; 5670 bool useShadowStructs = FALSE; 5671 t_Error err = E_OK; 5672 5673 if (keyIndex > p_CcNode->numOfKeys) 5674 RETURN_ERROR(MAJOR, E_INVALID_STATE, 5675 ("keyIndex > previously cleared last index + 1")); 5676 5677 if (keySize != p_CcNode->userSizeOfExtraction) 5678 RETURN_ERROR( 5679 MAJOR, 5680 E_INVALID_VALUE, 5681 ("keySize has to be defined as it was defined in initialization step")); 5682 5683 if (p_CcNode->h_FmPcd != h_FmPcd) 5684 RETURN_ERROR( 5685 MAJOR, 5686 E_INVALID_VALUE, 5687 ("handler to FmPcd is different from the handle provided at node initialization time")); 5688 5689 err = FindKeyIndex(h_FmPcdCcNode, keySize, p_FmPcdCcKeyParams->p_Key, 5690 p_FmPcdCcKeyParams->p_Mask, &tmpKeyIndex); 5691 if (GET_ERROR_TYPE(err) != E_NOT_FOUND) 5692 RETURN_ERROR( 5693 MINOR, 5694 E_ALREADY_EXISTS, 5695 ("The received key and mask pair was already found in the match table of the provided node")); 5696 5697 p_FmPcd = (t_FmPcd *)p_CcNode->h_FmPcd; 5698 5699 INIT_LIST(&h_OldPointersLst); 5700 INIT_LIST(&h_NewPointersLst); 5701 5702 p_ModifyKeyParams = ModifyNodeCommonPart(p_CcNode, keyIndex, 5703 e_MODIFY_STATE_CHANGE, TRUE, TRUE, 5704 FALSE); 5705 if (!p_ModifyKeyParams) 5706 RETURN_ERROR(MAJOR, E_INVALID_STATE, NO_MSG); 5707 5708 if (p_CcNode->maxNumOfKeys) 5709 { 5710 if (!TRY_LOCK(p_FmPcd->h_ShadowSpinlock, &p_FmPcd->shadowLock)) 5711 { 5712 XX_Free(p_ModifyKeyParams); 5713 return ERROR_CODE(E_BUSY); 5714 } 5715 5716 useShadowStructs = TRUE; 5717 } 5718 5719 err = BuildNewNodeAddOrMdfyKeyAndNextEngine(h_FmPcd, p_CcNode, keyIndex, 5720 p_FmPcdCcKeyParams, 5721 p_ModifyKeyParams, FALSE); 5722 if (err) 5723 { 5724 ReleaseNewNodeCommonPart(p_ModifyKeyParams); 5725 XX_Free(p_ModifyKeyParams); 5726 if (p_CcNode->maxNumOfKeys) 5727 RELEASE_LOCK(p_FmPcd->shadowLock); 5728 RETURN_ERROR(MAJOR, err, NO_MSG); 5729 } 5730 5731 err = UpdatePtrWhichPointOnCrntMdfNode(p_CcNode, p_ModifyKeyParams, 5732 &h_OldPointersLst, 5733 &h_NewPointersLst); 5734 if (err) 5735 { 5736 ReleaseNewNodeCommonPart(p_ModifyKeyParams); 5737 XX_Free(p_ModifyKeyParams); 5738 if (p_CcNode->maxNumOfKeys) 5739 RELEASE_LOCK(p_FmPcd->shadowLock); 5740 RETURN_ERROR(MAJOR, err, NO_MSG); 5741 } 5742 5743 err = DoDynamicChange(p_FmPcd, &h_OldPointersLst, &h_NewPointersLst, 5744 p_ModifyKeyParams, useShadowStructs); 5745 5746 if (p_CcNode->maxNumOfKeys) 5747 RELEASE_LOCK(p_FmPcd->shadowLock); 5748 5749 return err; 5750 } 5751 5752 uint32_t FmPcdCcGetNodeAddrOffsetFromNodeInfo(t_Handle h_FmPcd, 5753 t_Handle h_Pointer) 5754 { 5755 t_FmPcd *p_FmPcd = (t_FmPcd *)h_FmPcd; 5756 t_CcNodeInformation *p_CcNodeInfo; 5757 5758 SANITY_CHECK_RETURN_VALUE(h_FmPcd, E_INVALID_HANDLE, 5759 (uint32_t)ILLEGAL_BASE); 5760 5761 p_CcNodeInfo = CC_NODE_F_OBJECT(h_Pointer); 5762 5763 return (uint32_t)(XX_VirtToPhys(p_CcNodeInfo->h_CcNode) 5764 - p_FmPcd->physicalMuramBase); 5765 } 5766 5767 t_Error FmPcdCcGetGrpParams(t_Handle h_FmPcdCcTree, uint8_t grpId, 5768 uint32_t *p_GrpBits, uint8_t *p_GrpBase) 5769 { 5770 t_FmPcdCcTree *p_FmPcdCcTree = (t_FmPcdCcTree *)h_FmPcdCcTree; 5771 5772 SANITY_CHECK_RETURN_ERROR(h_FmPcdCcTree, E_INVALID_HANDLE); 5773 5774 if (grpId >= p_FmPcdCcTree->numOfGrps) 5775 RETURN_ERROR(MAJOR, E_INVALID_HANDLE, 5776 ("grpId you asked > numOfGroup of relevant tree")); 5777 5778 *p_GrpBits = p_FmPcdCcTree->fmPcdGroupParam[grpId].totalBitsMask; 5779 *p_GrpBase = p_FmPcdCcTree->fmPcdGroupParam[grpId].baseGroupEntry; 5780 5781 return E_OK; 5782 } 5783 5784 t_Error FmPcdCcBindTree(t_Handle h_FmPcd, t_Handle h_PcdParams, 5785 t_Handle h_FmPcdCcTree, uint32_t *p_Offset, 5786 t_Handle h_FmPort) 5787 { 5788 t_FmPcd *p_FmPcd = (t_FmPcd*)h_FmPcd; 5789 t_FmPcdCcTree *p_FmPcdCcTree = (t_FmPcdCcTree *)h_FmPcdCcTree; 5790 t_Error err = E_OK; 5791 5792 SANITY_CHECK_RETURN_ERROR(h_FmPcd, E_INVALID_HANDLE); 5793 SANITY_CHECK_RETURN_ERROR(h_FmPcdCcTree, E_INVALID_HANDLE); 5794 5795 /* this routine must be protected by the calling routine by locking all PCD modules! */ 5796 5797 err = CcUpdateParams(h_FmPcd, h_PcdParams, h_FmPort, h_FmPcdCcTree, TRUE); 5798 5799 if (err == E_OK) 5800 UpdateCcRootOwner(p_FmPcdCcTree, TRUE); 5801 5802 *p_Offset = (uint32_t)(XX_VirtToPhys( 5803 UINT_TO_PTR(p_FmPcdCcTree->ccTreeBaseAddr)) 5804 - p_FmPcd->physicalMuramBase); 5805 5806 return err; 5807 } 5808 5809 t_Error FmPcdCcUnbindTree(t_Handle h_FmPcd, t_Handle h_FmPcdCcTree) 5810 { 5811 t_FmPcdCcTree *p_FmPcdCcTree = (t_FmPcdCcTree *)h_FmPcdCcTree; 5812 5813 /* this routine must be protected by the calling routine by locking all PCD modules! */ 5814 5815 UNUSED(h_FmPcd); 5816 5817 SANITY_CHECK_RETURN_ERROR(h_FmPcdCcTree, E_INVALID_HANDLE); 5818 5819 UpdateCcRootOwner(p_FmPcdCcTree, FALSE); 5820 5821 return E_OK; 5822 } 5823 5824 t_Error FmPcdCcNodeTreeTryLock(t_Handle h_FmPcd, t_Handle h_FmPcdCcNode, 5825 t_List *p_List) 5826 { 5827 t_FmPcdCcNode *p_CcNode = (t_FmPcdCcNode *)h_FmPcdCcNode; 5828 t_List *p_Pos, *p_Tmp; 5829 t_CcNodeInformation *p_CcNodeInfo, nodeInfo; 5830 uint32_t intFlags; 5831 t_Error err = E_OK; 5832 5833 intFlags = FmPcdLock(h_FmPcd); 5834 5835 NCSW_LIST_FOR_EACH(p_Pos, &p_CcNode->ccTreesLst) 5836 { 5837 p_CcNodeInfo = CC_NODE_F_OBJECT(p_Pos); 5838 ASSERT_COND(p_CcNodeInfo->h_CcNode); 5839 5840 err = CcRootTryLock(p_CcNodeInfo->h_CcNode); 5841 5842 if (err) 5843 { 5844 NCSW_LIST_FOR_EACH(p_Tmp, &p_CcNode->ccTreesLst) 5845 { 5846 if (p_Tmp == p_Pos) 5847 break; 5848 5849 CcRootReleaseLock(p_CcNodeInfo->h_CcNode); 5850 } 5851 break; 5852 } 5853 5854 memset(&nodeInfo, 0, sizeof(t_CcNodeInformation)); 5855 nodeInfo.h_CcNode = p_CcNodeInfo->h_CcNode; 5856 EnqueueNodeInfoToRelevantLst(p_List, &nodeInfo, NULL); 5857 } 5858 5859 FmPcdUnlock(h_FmPcd, intFlags); 5860 CORE_MemoryBarrier(); 5861 5862 return err; 5863 } 5864 5865 void FmPcdCcNodeTreeReleaseLock(t_Handle h_FmPcd, t_List *p_List) 5866 { 5867 t_List *p_Pos; 5868 t_CcNodeInformation *p_CcNodeInfo; 5869 t_Handle h_FmPcdCcTree; 5870 uint32_t intFlags; 5871 5872 intFlags = FmPcdLock(h_FmPcd); 5873 5874 NCSW_LIST_FOR_EACH(p_Pos, p_List) 5875 { 5876 p_CcNodeInfo = CC_NODE_F_OBJECT(p_Pos); 5877 h_FmPcdCcTree = p_CcNodeInfo->h_CcNode; 5878 CcRootReleaseLock(h_FmPcdCcTree); 5879 } 5880 5881 ReleaseLst(p_List); 5882 5883 FmPcdUnlock(h_FmPcd, intFlags); 5884 CORE_MemoryBarrier(); 5885 } 5886 5887 t_Error FmPcdUpdateCcShadow(t_FmPcd *p_FmPcd, uint32_t size, uint32_t align) 5888 { 5889 uint32_t intFlags; 5890 uint32_t newSize = 0, newAlign = 0; 5891 bool allocFail = FALSE; 5892 5893 ASSERT_COND(p_FmPcd); 5894 5895 if (!size) 5896 RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("size must be larger then 0")); 5897 5898 if (!POWER_OF_2(align)) 5899 RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("alignment must be power of 2")); 5900 5901 newSize = p_FmPcd->ccShadowSize; 5902 newAlign = p_FmPcd->ccShadowAlign; 5903 5904 /* Check if current shadow is large enough to hold the requested size */ 5905 if (size > p_FmPcd->ccShadowSize) 5906 newSize = size; 5907 5908 /* Check if current shadow matches the requested alignment */ 5909 if (align > p_FmPcd->ccShadowAlign) 5910 newAlign = align; 5911 5912 /* If a bigger shadow size or bigger shadow alignment are required, 5913 a new shadow will be allocated */ 5914 if ((newSize != p_FmPcd->ccShadowSize) 5915 || (newAlign != p_FmPcd->ccShadowAlign)) 5916 { 5917 intFlags = FmPcdLock(p_FmPcd); 5918 5919 if (p_FmPcd->p_CcShadow) 5920 { 5921 FM_MURAM_FreeMem(FmPcdGetMuramHandle(p_FmPcd), p_FmPcd->p_CcShadow); 5922 p_FmPcd->ccShadowSize = 0; 5923 p_FmPcd->ccShadowAlign = 0; 5924 } 5925 5926 p_FmPcd->p_CcShadow = FM_MURAM_AllocMem(FmPcdGetMuramHandle(p_FmPcd), 5927 newSize, newAlign); 5928 if (!p_FmPcd->p_CcShadow) 5929 { 5930 allocFail = TRUE; 5931 5932 /* If new shadow size allocation failed, 5933 re-allocate with previous parameters */ 5934 p_FmPcd->p_CcShadow = FM_MURAM_AllocMem( 5935 FmPcdGetMuramHandle(p_FmPcd), p_FmPcd->ccShadowSize, 5936 p_FmPcd->ccShadowAlign); 5937 } 5938 5939 FmPcdUnlock(p_FmPcd, intFlags); 5940 5941 if (allocFail) 5942 RETURN_ERROR(MAJOR, E_NO_MEMORY, 5943 ("MURAM allocation for CC Shadow memory")); 5944 5945 p_FmPcd->ccShadowSize = newSize; 5946 p_FmPcd->ccShadowAlign = newAlign; 5947 } 5948 5949 return E_OK; 5950 } 5951 5952 #if (DPAA_VERSION >= 11) 5953 void FmPcdCcGetAdTablesThatPointOnReplicGroup(t_Handle h_Node, 5954 t_Handle h_ReplicGroup, 5955 t_List *p_AdTables, 5956 uint32_t *p_NumOfAdTables) 5957 { 5958 t_FmPcdCcNode *p_CurrentNode = (t_FmPcdCcNode *)h_Node; 5959 int i = 0; 5960 void * p_AdTable; 5961 t_CcNodeInformation ccNodeInfo; 5962 5963 ASSERT_COND(h_Node); 5964 *p_NumOfAdTables = 0; 5965 5966 /* search in the current node which exact index points on this current replicator group for getting AD */ 5967 for (i = 0; i < p_CurrentNode->numOfKeys + 1; i++) 5968 { 5969 if ((p_CurrentNode->keyAndNextEngineParams[i].nextEngineParams.nextEngine 5970 == e_FM_PCD_FR) 5971 && ((p_CurrentNode->keyAndNextEngineParams[i].nextEngineParams.params.frParams.h_FrmReplic 5972 == (t_Handle)h_ReplicGroup))) 5973 { 5974 /* save the current ad table in the list */ 5975 /* this entry uses the input replicator group */ 5976 p_AdTable = 5977 PTR_MOVE(p_CurrentNode->h_AdTable, i*FM_PCD_CC_AD_ENTRY_SIZE); 5978 memset(&ccNodeInfo, 0, sizeof(t_CcNodeInformation)); 5979 ccNodeInfo.h_CcNode = p_AdTable; 5980 EnqueueNodeInfoToRelevantLst(p_AdTables, &ccNodeInfo, NULL); 5981 (*p_NumOfAdTables)++; 5982 } 5983 } 5984 5985 ASSERT_COND(i != p_CurrentNode->numOfKeys); 5986 } 5987 #endif /* (DPAA_VERSION >= 11) */ 5988 /*********************** End of inter-module routines ************************/ 5989 5990 /****************************************/ 5991 /* API Init unit functions */ 5992 /****************************************/ 5993 5994 t_Handle FM_PCD_CcRootBuild(t_Handle h_FmPcd, 5995 t_FmPcdCcTreeParams *p_PcdGroupsParam) 5996 { 5997 t_FmPcd *p_FmPcd = (t_FmPcd *)h_FmPcd; 5998 t_Error err = E_OK; 5999 int i = 0, j = 0, k = 0; 6000 t_FmPcdCcTree *p_FmPcdCcTree; 6001 uint8_t numOfEntries; 6002 t_Handle p_CcTreeTmp; 6003 t_FmPcdCcGrpParams *p_FmPcdCcGroupParams; 6004 t_FmPcdCcKeyAndNextEngineParams *p_Params, *p_KeyAndNextEngineParams; 6005 t_NetEnvParams netEnvParams; 6006 uint8_t lastOne = 0; 6007 uint32_t requiredAction = 0; 6008 t_FmPcdCcNode *p_FmPcdCcNextNode; 6009 t_CcNodeInformation ccNodeInfo, *p_CcInformation; 6010 6011 SANITY_CHECK_RETURN_VALUE(h_FmPcd, E_INVALID_HANDLE, NULL); 6012 SANITY_CHECK_RETURN_VALUE(p_PcdGroupsParam, E_INVALID_HANDLE, NULL); 6013 6014 if (p_PcdGroupsParam->numOfGrps > FM_PCD_MAX_NUM_OF_CC_GROUPS) 6015 { 6016 REPORT_ERROR(MAJOR, E_INVALID_VALUE, ("numOfGrps should not exceed %d", FM_PCD_MAX_NUM_OF_CC_GROUPS)); 6017 return NULL; 6018 } 6019 6020 p_FmPcdCcTree = (t_FmPcdCcTree*)XX_Malloc(sizeof(t_FmPcdCcTree)); 6021 if (!p_FmPcdCcTree) 6022 { 6023 REPORT_ERROR(MAJOR, E_NO_MEMORY, ("PCD tree structure")); 6024 return NULL; 6025 } 6026 memset(p_FmPcdCcTree, 0, sizeof(t_FmPcdCcTree)); 6027 p_FmPcdCcTree->h_FmPcd = h_FmPcd; 6028 6029 p_Params = (t_FmPcdCcKeyAndNextEngineParams*)XX_Malloc( 6030 FM_PCD_MAX_NUM_OF_CC_GROUPS 6031 * sizeof(t_FmPcdCcKeyAndNextEngineParams)); 6032 memset(p_Params, 6033 0, 6034 FM_PCD_MAX_NUM_OF_CC_GROUPS 6035 * sizeof(t_FmPcdCcKeyAndNextEngineParams)); 6036 6037 INIT_LIST(&p_FmPcdCcTree->fmPortsLst); 6038 6039 #ifdef FM_CAPWAP_SUPPORT 6040 if ((p_PcdGroupsParam->numOfGrps == 1) && 6041 (p_PcdGroupsParam->ccGrpParams[0].numOfDistinctionUnits == 0) && 6042 (p_PcdGroupsParam->ccGrpParams[0].nextEnginePerEntriesInGrp[0].nextEngine == e_FM_PCD_CC) && 6043 p_PcdGroupsParam->ccGrpParams[0].nextEnginePerEntriesInGrp[0].params.ccParams.h_CcNode && 6044 IsCapwapApplSpecific(p_PcdGroupsParam->ccGrpParams[0].nextEnginePerEntriesInGrp[0].params.ccParams.h_CcNode)) 6045 { 6046 p_PcdGroupsParam->ccGrpParams[0].nextEnginePerEntriesInGrp[0].h_Manip = FmPcdManipApplSpecificBuild(); 6047 if (!p_PcdGroupsParam->ccGrpParams[0].nextEnginePerEntriesInGrp[0].h_Manip) 6048 { 6049 DeleteTree(p_FmPcdCcTree,p_FmPcd); 6050 XX_Free(p_Params); 6051 REPORT_ERROR(MAJOR, E_INVALID_STATE, NO_MSG); 6052 return NULL; 6053 } 6054 } 6055 #endif /* FM_CAPWAP_SUPPORT */ 6056 6057 numOfEntries = 0; 6058 p_FmPcdCcTree->netEnvId = FmPcdGetNetEnvId(p_PcdGroupsParam->h_NetEnv); 6059 6060 for (i = 0; i < p_PcdGroupsParam->numOfGrps; i++) 6061 { 6062 p_FmPcdCcGroupParams = &p_PcdGroupsParam->ccGrpParams[i]; 6063 6064 if (p_FmPcdCcGroupParams->numOfDistinctionUnits 6065 > FM_PCD_MAX_NUM_OF_CC_UNITS) 6066 { 6067 DeleteTree(p_FmPcdCcTree, p_FmPcd); 6068 XX_Free(p_Params); 6069 REPORT_ERROR(MAJOR, E_INVALID_VALUE, 6070 ("numOfDistinctionUnits (group %d) should not exceed %d", i, FM_PCD_MAX_NUM_OF_CC_UNITS)); 6071 return NULL; 6072 } 6073 6074 p_FmPcdCcTree->fmPcdGroupParam[i].baseGroupEntry = numOfEntries; 6075 p_FmPcdCcTree->fmPcdGroupParam[i].numOfEntriesInGroup = (uint8_t)(0x01 6076 << p_FmPcdCcGroupParams->numOfDistinctionUnits); 6077 numOfEntries += p_FmPcdCcTree->fmPcdGroupParam[i].numOfEntriesInGroup; 6078 if (numOfEntries > FM_PCD_MAX_NUM_OF_CC_GROUPS) 6079 { 6080 DeleteTree(p_FmPcdCcTree, p_FmPcd); 6081 XX_Free(p_Params); 6082 REPORT_ERROR(MAJOR, E_INVALID_VALUE, ("numOfEntries can not be larger than %d", FM_PCD_MAX_NUM_OF_CC_GROUPS)); 6083 return NULL; 6084 } 6085 6086 if (lastOne) 6087 { 6088 if (p_FmPcdCcTree->fmPcdGroupParam[i].numOfEntriesInGroup > lastOne) 6089 { 6090 DeleteTree(p_FmPcdCcTree, p_FmPcd); 6091 XX_Free(p_Params); 6092 REPORT_ERROR(MAJOR, E_CONFLICT, ("numOfEntries per group must be set in descending order")); 6093 return NULL; 6094 } 6095 } 6096 6097 lastOne = p_FmPcdCcTree->fmPcdGroupParam[i].numOfEntriesInGroup; 6098 6099 netEnvParams.netEnvId = p_FmPcdCcTree->netEnvId; 6100 netEnvParams.numOfDistinctionUnits = 6101 p_FmPcdCcGroupParams->numOfDistinctionUnits; 6102 6103 memcpy(netEnvParams.unitIds, &p_FmPcdCcGroupParams->unitIds, 6104 (sizeof(uint8_t)) * p_FmPcdCcGroupParams->numOfDistinctionUnits); 6105 6106 err = PcdGetUnitsVector(p_FmPcd, &netEnvParams); 6107 if (err) 6108 { 6109 DeleteTree(p_FmPcdCcTree, p_FmPcd); 6110 XX_Free(p_Params); 6111 REPORT_ERROR(MAJOR, err, NO_MSG); 6112 return NULL; 6113 } 6114 6115 p_FmPcdCcTree->fmPcdGroupParam[i].totalBitsMask = netEnvParams.vector; 6116 for (j = 0; j < p_FmPcdCcTree->fmPcdGroupParam[i].numOfEntriesInGroup; 6117 j++) 6118 { 6119 err = ValidateNextEngineParams( 6120 h_FmPcd, 6121 &p_FmPcdCcGroupParams->nextEnginePerEntriesInGrp[j], 6122 e_FM_PCD_CC_STATS_MODE_NONE); 6123 if (err) 6124 { 6125 DeleteTree(p_FmPcdCcTree, p_FmPcd); 6126 XX_Free(p_Params); 6127 REPORT_ERROR(MAJOR, err, (NO_MSG)); 6128 return NULL; 6129 } 6130 6131 if (p_FmPcdCcGroupParams->nextEnginePerEntriesInGrp[j].h_Manip) 6132 { 6133 err = FmPcdManipCheckParamsForCcNextEngine( 6134 &p_FmPcdCcGroupParams->nextEnginePerEntriesInGrp[j], 6135 &requiredAction); 6136 if (err) 6137 { 6138 DeleteTree(p_FmPcdCcTree, p_FmPcd); 6139 XX_Free(p_Params); 6140 REPORT_ERROR(MAJOR, E_INVALID_STATE, NO_MSG); 6141 return NULL; 6142 } 6143 } 6144 p_KeyAndNextEngineParams = p_Params + k; 6145 6146 memcpy(&p_KeyAndNextEngineParams->nextEngineParams, 6147 &p_FmPcdCcGroupParams->nextEnginePerEntriesInGrp[j], 6148 sizeof(t_FmPcdCcNextEngineParams)); 6149 6150 if ((p_KeyAndNextEngineParams->nextEngineParams.nextEngine 6151 == e_FM_PCD_CC) 6152 && p_KeyAndNextEngineParams->nextEngineParams.h_Manip) 6153 { 6154 err = 6155 AllocAndFillAdForContLookupManip( 6156 p_KeyAndNextEngineParams->nextEngineParams.params.ccParams.h_CcNode); 6157 if (err) 6158 { 6159 DeleteTree(p_FmPcdCcTree, p_FmPcd); 6160 XX_Free(p_Params); 6161 REPORT_ERROR(MAJOR, E_NO_MEMORY, ("MURAM allocation for CC Tree")); 6162 return NULL; 6163 } 6164 } 6165 6166 requiredAction |= UPDATE_CC_WITH_TREE; 6167 p_KeyAndNextEngineParams->requiredAction = requiredAction; 6168 6169 k++; 6170 } 6171 } 6172 6173 p_FmPcdCcTree->numOfEntries = (uint8_t)k; 6174 p_FmPcdCcTree->numOfGrps = p_PcdGroupsParam->numOfGrps; 6175 6176 p_FmPcdCcTree->ccTreeBaseAddr = 6177 PTR_TO_UINT(FM_MURAM_AllocMem(FmPcdGetMuramHandle(h_FmPcd), 6178 (uint32_t)( FM_PCD_MAX_NUM_OF_CC_GROUPS * FM_PCD_CC_AD_ENTRY_SIZE), 6179 FM_PCD_CC_TREE_ADDR_ALIGN)); 6180 if (!p_FmPcdCcTree->ccTreeBaseAddr) 6181 { 6182 DeleteTree(p_FmPcdCcTree, p_FmPcd); 6183 XX_Free(p_Params); 6184 REPORT_ERROR(MAJOR, E_NO_MEMORY, ("MURAM allocation for CC Tree")); 6185 return NULL; 6186 } 6187 MemSet8( 6188 UINT_TO_PTR(p_FmPcdCcTree->ccTreeBaseAddr), 0, 6189 (uint32_t)(FM_PCD_MAX_NUM_OF_CC_GROUPS * FM_PCD_CC_AD_ENTRY_SIZE)); 6190 6191 p_CcTreeTmp = UINT_TO_PTR(p_FmPcdCcTree->ccTreeBaseAddr); 6192 6193 for (i = 0; i < numOfEntries; i++) 6194 { 6195 p_KeyAndNextEngineParams = p_Params + i; 6196 6197 NextStepAd(p_CcTreeTmp, NULL, 6198 &p_KeyAndNextEngineParams->nextEngineParams, p_FmPcd); 6199 6200 p_CcTreeTmp = PTR_MOVE(p_CcTreeTmp, FM_PCD_CC_AD_ENTRY_SIZE); 6201 6202 memcpy(&p_FmPcdCcTree->keyAndNextEngineParams[i], 6203 p_KeyAndNextEngineParams, 6204 sizeof(t_FmPcdCcKeyAndNextEngineParams)); 6205 6206 if (p_FmPcdCcTree->keyAndNextEngineParams[i].nextEngineParams.nextEngine 6207 == e_FM_PCD_CC) 6208 { 6209 p_FmPcdCcNextNode = 6210 (t_FmPcdCcNode*)p_FmPcdCcTree->keyAndNextEngineParams[i].nextEngineParams.params.ccParams.h_CcNode; 6211 p_CcInformation = FindNodeInfoInReleventLst( 6212 &p_FmPcdCcNextNode->ccTreeIdLst, (t_Handle)p_FmPcdCcTree, 6213 p_FmPcdCcNextNode->h_Spinlock); 6214 6215 if (!p_CcInformation) 6216 { 6217 memset(&ccNodeInfo, 0, sizeof(t_CcNodeInformation)); 6218 ccNodeInfo.h_CcNode = (t_Handle)p_FmPcdCcTree; 6219 ccNodeInfo.index = 1; 6220 EnqueueNodeInfoToRelevantLst(&p_FmPcdCcNextNode->ccTreeIdLst, 6221 &ccNodeInfo, 6222 p_FmPcdCcNextNode->h_Spinlock); 6223 } 6224 else 6225 p_CcInformation->index++; 6226 } 6227 } 6228 6229 FmPcdIncNetEnvOwners(h_FmPcd, p_FmPcdCcTree->netEnvId); 6230 p_CcTreeTmp = UINT_TO_PTR(p_FmPcdCcTree->ccTreeBaseAddr); 6231 6232 if (!FmPcdLockTryLockAll(p_FmPcd)) 6233 { 6234 FM_PCD_CcRootDelete(p_FmPcdCcTree); 6235 XX_Free(p_Params); 6236 DBG(TRACE, ("FmPcdLockTryLockAll failed")); 6237 return NULL; 6238 } 6239 6240 for (i = 0; i < numOfEntries; i++) 6241 { 6242 if (p_FmPcdCcTree->keyAndNextEngineParams[i].requiredAction) 6243 { 6244 err = SetRequiredAction( 6245 h_FmPcd, 6246 p_FmPcdCcTree->keyAndNextEngineParams[i].requiredAction, 6247 &p_FmPcdCcTree->keyAndNextEngineParams[i], p_CcTreeTmp, 1, 6248 p_FmPcdCcTree); 6249 if (err) 6250 { 6251 FmPcdLockUnlockAll(p_FmPcd); 6252 FM_PCD_CcRootDelete(p_FmPcdCcTree); 6253 XX_Free(p_Params); 6254 REPORT_ERROR(MAJOR, E_NO_MEMORY, ("No memory")); 6255 return NULL; 6256 } 6257 p_CcTreeTmp = PTR_MOVE(p_CcTreeTmp, FM_PCD_CC_AD_ENTRY_SIZE); 6258 } 6259 } 6260 6261 FmPcdLockUnlockAll(p_FmPcd); 6262 p_FmPcdCcTree->p_Lock = FmPcdAcquireLock(p_FmPcd); 6263 if (!p_FmPcdCcTree->p_Lock) 6264 { 6265 FM_PCD_CcRootDelete(p_FmPcdCcTree); 6266 XX_Free(p_Params); 6267 REPORT_ERROR(MAJOR, E_NO_MEMORY, ("FM CC lock")); 6268 return NULL; 6269 } 6270 6271 XX_Free(p_Params); 6272 6273 return p_FmPcdCcTree; 6274 } 6275 6276 t_Error FM_PCD_CcRootDelete(t_Handle h_CcTree) 6277 { 6278 t_FmPcd *p_FmPcd; 6279 t_FmPcdCcTree *p_CcTree = (t_FmPcdCcTree *)h_CcTree; 6280 int i = 0; 6281 6282 SANITY_CHECK_RETURN_ERROR(p_CcTree, E_INVALID_STATE); 6283 p_FmPcd = (t_FmPcd *)p_CcTree->h_FmPcd; 6284 SANITY_CHECK_RETURN_ERROR(p_FmPcd, E_INVALID_HANDLE); 6285 6286 FmPcdDecNetEnvOwners(p_FmPcd, p_CcTree->netEnvId); 6287 6288 if (p_CcTree->owners) 6289 RETURN_ERROR( 6290 MAJOR, 6291 E_INVALID_SELECTION, 6292 ("the tree with this ID can not be removed because this tree is occupied, first - unbind this tree")); 6293 6294 /* Delete ip-reassembly schemes if exist */ 6295 if (p_CcTree->h_IpReassemblyManip) 6296 { 6297 FmPcdManipDeleteIpReassmSchemes(p_CcTree->h_IpReassemblyManip); 6298 FmPcdManipUpdateOwner(p_CcTree->h_IpReassemblyManip, FALSE); 6299 } 6300 6301 /* Delete capwap-reassembly schemes if exist */ 6302 if (p_CcTree->h_CapwapReassemblyManip) 6303 { 6304 FmPcdManipDeleteCapwapReassmSchemes(p_CcTree->h_CapwapReassemblyManip); 6305 FmPcdManipUpdateOwner(p_CcTree->h_CapwapReassemblyManip, FALSE); 6306 } 6307 6308 for (i = 0; i < p_CcTree->numOfEntries; i++) 6309 { 6310 if (p_CcTree->keyAndNextEngineParams[i].nextEngineParams.nextEngine 6311 == e_FM_PCD_CC) 6312 UpdateNodeOwner( 6313 p_CcTree->keyAndNextEngineParams[i].nextEngineParams.params.ccParams.h_CcNode, 6314 FALSE); 6315 6316 if (p_CcTree->keyAndNextEngineParams[i].nextEngineParams.h_Manip) 6317 FmPcdManipUpdateOwner( 6318 p_CcTree->keyAndNextEngineParams[i].nextEngineParams.h_Manip, 6319 FALSE); 6320 6321 #ifdef FM_CAPWAP_SUPPORT 6322 if ((p_CcTree->numOfGrps == 1) && 6323 (p_CcTree->fmPcdGroupParam[0].numOfEntriesInGroup == 1) && 6324 (p_CcTree->keyAndNextEngineParams[0].nextEngineParams.nextEngine == e_FM_PCD_CC) && 6325 p_CcTree->keyAndNextEngineParams[0].nextEngineParams.params.ccParams.h_CcNode && 6326 IsCapwapApplSpecific(p_CcTree->keyAndNextEngineParams[0].nextEngineParams.params.ccParams.h_CcNode)) 6327 { 6328 if (FM_PCD_ManipNodeDelete(p_CcTree->keyAndNextEngineParams[0].nextEngineParams.h_Manip) != E_OK) 6329 return E_INVALID_STATE; 6330 } 6331 #endif /* FM_CAPWAP_SUPPORT */ 6332 6333 #if (DPAA_VERSION >= 11) 6334 if ((p_CcTree->keyAndNextEngineParams[i].nextEngineParams.nextEngine 6335 == e_FM_PCD_FR) 6336 && (p_CcTree->keyAndNextEngineParams[i].nextEngineParams.params.frParams.h_FrmReplic)) 6337 FrmReplicGroupUpdateOwner( 6338 p_CcTree->keyAndNextEngineParams[i].nextEngineParams.params.frParams.h_FrmReplic, 6339 FALSE); 6340 #endif /* (DPAA_VERSION >= 11) */ 6341 } 6342 6343 if (p_CcTree->p_Lock) 6344 FmPcdReleaseLock(p_CcTree->h_FmPcd, p_CcTree->p_Lock); 6345 6346 DeleteTree(p_CcTree, p_FmPcd); 6347 6348 return E_OK; 6349 } 6350 6351 t_Error FM_PCD_CcRootModifyNextEngine( 6352 t_Handle h_CcTree, uint8_t grpId, uint8_t index, 6353 t_FmPcdCcNextEngineParams *p_FmPcdCcNextEngineParams) 6354 { 6355 t_FmPcd *p_FmPcd; 6356 t_FmPcdCcTree *p_CcTree = (t_FmPcdCcTree *)h_CcTree; 6357 t_Error err = E_OK; 6358 6359 SANITY_CHECK_RETURN_ERROR(p_FmPcdCcNextEngineParams, E_NULL_POINTER); 6360 SANITY_CHECK_RETURN_ERROR(p_CcTree, E_INVALID_STATE); 6361 p_FmPcd = (t_FmPcd *)p_CcTree->h_FmPcd; 6362 SANITY_CHECK_RETURN_ERROR(p_FmPcd, E_INVALID_HANDLE); 6363 6364 if (!FmPcdLockTryLockAll(p_FmPcd)) 6365 { 6366 DBG(TRACE, ("FmPcdLockTryLockAll failed")); 6367 return ERROR_CODE(E_BUSY); 6368 } 6369 6370 err = FmPcdCcModifyNextEngineParamTree(p_FmPcd, p_CcTree, grpId, index, 6371 p_FmPcdCcNextEngineParams); 6372 FmPcdLockUnlockAll(p_FmPcd); 6373 6374 if (err) 6375 { 6376 RETURN_ERROR(MAJOR, err, NO_MSG); 6377 } 6378 6379 return E_OK; 6380 } 6381 6382 t_Handle FM_PCD_MatchTableSet(t_Handle h_FmPcd, 6383 t_FmPcdCcNodeParams *p_CcNodeParam) 6384 { 6385 t_FmPcdCcNode *p_CcNode; 6386 t_Error err; 6387 6388 SANITY_CHECK_RETURN_VALUE(h_FmPcd, E_INVALID_HANDLE, NULL); 6389 SANITY_CHECK_RETURN_VALUE(p_CcNodeParam, E_NULL_POINTER, NULL); 6390 6391 p_CcNode = (t_FmPcdCcNode*)XX_Malloc(sizeof(t_FmPcdCcNode)); 6392 if (!p_CcNode) 6393 { 6394 REPORT_ERROR(MAJOR, E_NO_MEMORY, ("No memory")); 6395 return NULL; 6396 } 6397 memset(p_CcNode, 0, sizeof(t_FmPcdCcNode)); 6398 6399 err = MatchTableSet(h_FmPcd, p_CcNode, p_CcNodeParam); 6400 6401 switch(GET_ERROR_TYPE(err) 6402 ) { 6403 case E_OK: 6404 break; 6405 6406 case E_BUSY: 6407 DBG(TRACE, ("E_BUSY error")); 6408 return NULL; 6409 6410 default: 6411 REPORT_ERROR(MAJOR, err, NO_MSG); 6412 return NULL; 6413 } 6414 6415 return p_CcNode; 6416 } 6417 6418 t_Error FM_PCD_MatchTableDelete(t_Handle h_CcNode) 6419 { 6420 t_FmPcdCcNode *p_CcNode = (t_FmPcdCcNode *)h_CcNode; 6421 int i = 0; 6422 6423 SANITY_CHECK_RETURN_ERROR(p_CcNode, E_INVALID_HANDLE); 6424 SANITY_CHECK_RETURN_ERROR(p_CcNode->h_FmPcd, E_INVALID_HANDLE); 6425 6426 if (p_CcNode->owners) 6427 RETURN_ERROR( 6428 MAJOR, 6429 E_INVALID_STATE, 6430 ("This node cannot be removed because it is occupied; first unbind this node")); 6431 6432 for (i = 0; i < p_CcNode->numOfKeys; i++) 6433 if (p_CcNode->keyAndNextEngineParams[i].nextEngineParams.nextEngine 6434 == e_FM_PCD_CC) 6435 UpdateNodeOwner( 6436 p_CcNode->keyAndNextEngineParams[i].nextEngineParams.params.ccParams.h_CcNode, 6437 FALSE); 6438 6439 if (p_CcNode->keyAndNextEngineParams[i].nextEngineParams.nextEngine 6440 == e_FM_PCD_CC) 6441 UpdateNodeOwner( 6442 p_CcNode->keyAndNextEngineParams[i].nextEngineParams.params.ccParams.h_CcNode, 6443 FALSE); 6444 6445 /* Handle also Miss entry */ 6446 for (i = 0; i < p_CcNode->numOfKeys + 1; i++) 6447 { 6448 if (p_CcNode->keyAndNextEngineParams[i].nextEngineParams.h_Manip) 6449 FmPcdManipUpdateOwner( 6450 p_CcNode->keyAndNextEngineParams[i].nextEngineParams.h_Manip, 6451 FALSE); 6452 6453 #if (DPAA_VERSION >= 11) 6454 if ((p_CcNode->keyAndNextEngineParams[i].nextEngineParams.nextEngine 6455 == e_FM_PCD_FR) 6456 && (p_CcNode->keyAndNextEngineParams[i].nextEngineParams.params.frParams.h_FrmReplic)) 6457 { 6458 FrmReplicGroupUpdateOwner( 6459 p_CcNode->keyAndNextEngineParams[i].nextEngineParams.params.frParams.h_FrmReplic, 6460 FALSE); 6461 } 6462 #endif /* (DPAA_VERSION >= 11) */ 6463 } 6464 6465 DeleteNode(p_CcNode); 6466 6467 return E_OK; 6468 } 6469 6470 t_Error FM_PCD_MatchTableAddKey(t_Handle h_CcNode, uint16_t keyIndex, 6471 uint8_t keySize, 6472 t_FmPcdCcKeyParams *p_KeyParams) 6473 { 6474 t_FmPcd *p_FmPcd; 6475 t_FmPcdCcNode *p_CcNode = (t_FmPcdCcNode *)h_CcNode; 6476 t_Error err = E_OK; 6477 6478 SANITY_CHECK_RETURN_ERROR(p_KeyParams, E_NULL_POINTER); 6479 SANITY_CHECK_RETURN_ERROR(p_CcNode, E_INVALID_HANDLE); 6480 p_FmPcd = (t_FmPcd *)p_CcNode->h_FmPcd; 6481 SANITY_CHECK_RETURN_ERROR(p_FmPcd, E_INVALID_HANDLE); 6482 SANITY_CHECK_RETURN_ERROR(p_FmPcd->h_Hc, E_INVALID_HANDLE); 6483 6484 if (keyIndex == FM_PCD_LAST_KEY_INDEX) 6485 keyIndex = p_CcNode->numOfKeys; 6486 6487 if (!FmPcdLockTryLockAll(p_FmPcd)) 6488 { 6489 DBG(TRACE, ("FmPcdLockTryLockAll failed")); 6490 return ERROR_CODE(E_BUSY); 6491 } 6492 6493 err = FmPcdCcAddKey(p_FmPcd, p_CcNode, keyIndex, keySize, p_KeyParams); 6494 6495 FmPcdLockUnlockAll(p_FmPcd); 6496 6497 switch(GET_ERROR_TYPE(err) 6498 ) { 6499 case E_OK: 6500 return E_OK; 6501 6502 case E_BUSY: 6503 DBG(TRACE, ("E_BUSY error")); 6504 return ERROR_CODE(E_BUSY); 6505 6506 default: 6507 RETURN_ERROR(MAJOR, err, NO_MSG); 6508 } 6509 } 6510 6511 t_Error FM_PCD_MatchTableRemoveKey(t_Handle h_CcNode, uint16_t keyIndex) 6512 { 6513 t_FmPcd *p_FmPcd; 6514 t_FmPcdCcNode *p_CcNode = (t_FmPcdCcNode *)h_CcNode; 6515 t_Error err = E_OK; 6516 6517 SANITY_CHECK_RETURN_ERROR(p_CcNode, E_INVALID_HANDLE); 6518 p_FmPcd = (t_FmPcd *)p_CcNode->h_FmPcd; 6519 SANITY_CHECK_RETURN_ERROR(p_FmPcd, E_INVALID_HANDLE); 6520 SANITY_CHECK_RETURN_ERROR(p_FmPcd->h_Hc, E_INVALID_HANDLE); 6521 6522 if (!FmPcdLockTryLockAll(p_FmPcd)) 6523 { 6524 DBG(TRACE, ("FmPcdLockTryLockAll failed")); 6525 return ERROR_CODE(E_BUSY); 6526 } 6527 6528 err = FmPcdCcRemoveKey(p_FmPcd, p_CcNode, keyIndex); 6529 6530 FmPcdLockUnlockAll(p_FmPcd); 6531 6532 switch(GET_ERROR_TYPE(err) 6533 ) { 6534 case E_OK: 6535 return E_OK; 6536 6537 case E_BUSY: 6538 DBG(TRACE, ("E_BUSY error")); 6539 return ERROR_CODE(E_BUSY); 6540 6541 default: 6542 RETURN_ERROR(MAJOR, err, NO_MSG); 6543 } 6544 6545 return E_OK; 6546 } 6547 6548 t_Error FM_PCD_MatchTableModifyKey(t_Handle h_CcNode, uint16_t keyIndex, 6549 uint8_t keySize, uint8_t *p_Key, 6550 uint8_t *p_Mask) 6551 { 6552 t_FmPcd *p_FmPcd; 6553 t_FmPcdCcNode *p_CcNode = (t_FmPcdCcNode *)h_CcNode; 6554 t_Error err = E_OK; 6555 6556 SANITY_CHECK_RETURN_ERROR(p_CcNode, E_INVALID_HANDLE); 6557 SANITY_CHECK_RETURN_ERROR(p_Key, E_NULL_POINTER); 6558 p_FmPcd = (t_FmPcd *)p_CcNode->h_FmPcd; 6559 SANITY_CHECK_RETURN_ERROR(p_FmPcd, E_INVALID_HANDLE); 6560 SANITY_CHECK_RETURN_ERROR(p_FmPcd->h_Hc, E_INVALID_HANDLE); 6561 6562 6563 if (!FmPcdLockTryLockAll(p_FmPcd)) 6564 { 6565 DBG(TRACE, ("FmPcdLockTryLockAll failed")); 6566 return ERROR_CODE(E_BUSY); 6567 } 6568 6569 err = FmPcdCcModifyKey(p_FmPcd, p_CcNode, keyIndex, keySize, p_Key, p_Mask); 6570 6571 FmPcdLockUnlockAll(p_FmPcd); 6572 6573 switch(GET_ERROR_TYPE(err) 6574 ) { 6575 case E_OK: 6576 return E_OK; 6577 6578 case E_BUSY: 6579 DBG(TRACE, ("E_BUSY error")); 6580 return ERROR_CODE(E_BUSY); 6581 6582 default: 6583 RETURN_ERROR(MAJOR, err, NO_MSG); 6584 } 6585 } 6586 6587 t_Error FM_PCD_MatchTableModifyNextEngine( 6588 t_Handle h_CcNode, uint16_t keyIndex, 6589 t_FmPcdCcNextEngineParams *p_FmPcdCcNextEngineParams) 6590 { 6591 t_FmPcd *p_FmPcd; 6592 t_FmPcdCcNode *p_CcNode = (t_FmPcdCcNode *)h_CcNode; 6593 t_Error err = E_OK; 6594 6595 SANITY_CHECK_RETURN_ERROR(p_FmPcdCcNextEngineParams, E_NULL_POINTER); 6596 SANITY_CHECK_RETURN_ERROR(p_CcNode, E_INVALID_HANDLE); 6597 p_FmPcd = (t_FmPcd *)p_CcNode->h_FmPcd; 6598 SANITY_CHECK_RETURN_ERROR(p_FmPcd, E_INVALID_HANDLE); 6599 SANITY_CHECK_RETURN_ERROR(p_FmPcd->h_Hc, E_INVALID_HANDLE); 6600 6601 if (!FmPcdLockTryLockAll(p_FmPcd)) 6602 { 6603 DBG(TRACE, ("FmPcdLockTryLockAll failed")); 6604 return ERROR_CODE(E_BUSY); 6605 } 6606 6607 err = ModifyNextEngineParamNode(p_FmPcd, p_CcNode, keyIndex, 6608 p_FmPcdCcNextEngineParams); 6609 6610 FmPcdLockUnlockAll(p_FmPcd); 6611 6612 switch(GET_ERROR_TYPE(err) 6613 ) { 6614 case E_OK: 6615 return E_OK; 6616 6617 case E_BUSY: 6618 DBG(TRACE, ("E_BUSY error")); 6619 return ERROR_CODE(E_BUSY); 6620 6621 default: 6622 RETURN_ERROR(MAJOR, err, NO_MSG); 6623 } 6624 } 6625 6626 t_Error FM_PCD_MatchTableModifyMissNextEngine( 6627 t_Handle h_CcNode, t_FmPcdCcNextEngineParams *p_FmPcdCcNextEngineParams) 6628 { 6629 t_FmPcd *p_FmPcd; 6630 t_FmPcdCcNode *p_CcNode = (t_FmPcdCcNode *)h_CcNode; 6631 t_Error err = E_OK; 6632 6633 SANITY_CHECK_RETURN_ERROR(p_FmPcdCcNextEngineParams, E_NULL_POINTER); 6634 SANITY_CHECK_RETURN_ERROR(p_CcNode, E_INVALID_HANDLE); 6635 p_FmPcd = (t_FmPcd *)p_CcNode->h_FmPcd; 6636 SANITY_CHECK_RETURN_ERROR(p_FmPcd, E_INVALID_HANDLE); 6637 SANITY_CHECK_RETURN_ERROR(p_FmPcd->h_Hc, E_INVALID_HANDLE); 6638 6639 if (!FmPcdLockTryLockAll(p_FmPcd)) 6640 { 6641 DBG(TRACE, ("FmPcdLockTryLockAll failed")); 6642 return ERROR_CODE(E_BUSY); 6643 } 6644 6645 err = FmPcdCcModifyMissNextEngineParamNode(p_FmPcd, p_CcNode, 6646 p_FmPcdCcNextEngineParams); 6647 6648 FmPcdLockUnlockAll(p_FmPcd); 6649 6650 switch(GET_ERROR_TYPE(err) 6651 ) { 6652 case E_OK: 6653 return E_OK; 6654 6655 case E_BUSY: 6656 DBG(TRACE, ("E_BUSY error")); 6657 return ERROR_CODE(E_BUSY); 6658 6659 default: 6660 RETURN_ERROR(MAJOR, err, NO_MSG); 6661 } 6662 } 6663 6664 t_Error FM_PCD_MatchTableModifyKeyAndNextEngine(t_Handle h_CcNode, 6665 uint16_t keyIndex, 6666 uint8_t keySize, 6667 t_FmPcdCcKeyParams *p_KeyParams) 6668 { 6669 t_FmPcd *p_FmPcd; 6670 t_FmPcdCcNode *p_CcNode = (t_FmPcdCcNode *)h_CcNode; 6671 t_Error err = E_OK; 6672 6673 SANITY_CHECK_RETURN_ERROR(p_KeyParams, E_NULL_POINTER); 6674 SANITY_CHECK_RETURN_ERROR(p_CcNode, E_INVALID_HANDLE); 6675 p_FmPcd = (t_FmPcd *)p_CcNode->h_FmPcd; 6676 SANITY_CHECK_RETURN_ERROR(p_FmPcd, E_INVALID_HANDLE); 6677 SANITY_CHECK_RETURN_ERROR(p_FmPcd->h_Hc, E_INVALID_HANDLE); 6678 6679 if (!FmPcdLockTryLockAll(p_FmPcd)) 6680 { 6681 DBG(TRACE, ("FmPcdLockTryLockAll failed")); 6682 return ERROR_CODE(E_BUSY); 6683 } 6684 6685 err = FmPcdCcModifyKeyAndNextEngine(p_FmPcd, p_CcNode, keyIndex, keySize, 6686 p_KeyParams); 6687 6688 FmPcdLockUnlockAll(p_FmPcd); 6689 6690 switch(GET_ERROR_TYPE(err) 6691 ) { 6692 case E_OK: 6693 return E_OK; 6694 6695 case E_BUSY: 6696 DBG(TRACE, ("E_BUSY error")); 6697 return ERROR_CODE(E_BUSY); 6698 6699 default: 6700 RETURN_ERROR(MAJOR, err, NO_MSG); 6701 } 6702 } 6703 6704 t_Error FM_PCD_MatchTableFindNRemoveKey(t_Handle h_CcNode, uint8_t keySize, 6705 uint8_t *p_Key, uint8_t *p_Mask) 6706 { 6707 t_FmPcd *p_FmPcd; 6708 t_FmPcdCcNode *p_CcNode = (t_FmPcdCcNode *)h_CcNode; 6709 uint16_t keyIndex; 6710 t_Error err; 6711 6712 SANITY_CHECK_RETURN_ERROR(p_Key, E_NULL_POINTER); 6713 SANITY_CHECK_RETURN_ERROR(p_CcNode, E_INVALID_HANDLE); 6714 p_FmPcd = (t_FmPcd *)p_CcNode->h_FmPcd; 6715 SANITY_CHECK_RETURN_ERROR(p_FmPcd, E_INVALID_HANDLE); 6716 SANITY_CHECK_RETURN_ERROR(p_FmPcd->h_Hc, E_INVALID_HANDLE); 6717 6718 if (!FmPcdLockTryLockAll(p_FmPcd)) 6719 { 6720 DBG(TRACE, ("FmPcdLockTryLockAll failed")); 6721 return ERROR_CODE(E_BUSY); 6722 } 6723 6724 err = FindKeyIndex(p_CcNode, keySize, p_Key, p_Mask, &keyIndex); 6725 if (GET_ERROR_TYPE(err) != E_OK) 6726 { 6727 FmPcdLockUnlockAll(p_FmPcd); 6728 RETURN_ERROR( 6729 MAJOR, 6730 err, 6731 ("The received key and mask pair was not found in the match table of the provided node")); 6732 } 6733 6734 err = FmPcdCcRemoveKey(p_FmPcd, p_CcNode, keyIndex); 6735 6736 FmPcdLockUnlockAll(p_FmPcd); 6737 6738 switch(GET_ERROR_TYPE(err) 6739 ) { 6740 case E_OK: 6741 return E_OK; 6742 6743 case E_BUSY: 6744 DBG(TRACE, ("E_BUSY error")); 6745 return ERROR_CODE(E_BUSY); 6746 6747 default: 6748 RETURN_ERROR(MAJOR, err, NO_MSG); 6749 } 6750 } 6751 6752 t_Error FM_PCD_MatchTableFindNModifyNextEngine( 6753 t_Handle h_CcNode, uint8_t keySize, uint8_t *p_Key, uint8_t *p_Mask, 6754 t_FmPcdCcNextEngineParams *p_FmPcdCcNextEngineParams) 6755 { 6756 t_FmPcd *p_FmPcd; 6757 t_FmPcdCcNode *p_CcNode = (t_FmPcdCcNode *)h_CcNode; 6758 uint16_t keyIndex; 6759 t_Error err; 6760 6761 SANITY_CHECK_RETURN_ERROR(p_Key, E_NULL_POINTER); 6762 SANITY_CHECK_RETURN_ERROR(p_FmPcdCcNextEngineParams, E_NULL_POINTER); 6763 SANITY_CHECK_RETURN_ERROR(p_CcNode, E_INVALID_HANDLE); 6764 p_FmPcd = (t_FmPcd *)p_CcNode->h_FmPcd; 6765 SANITY_CHECK_RETURN_ERROR(p_FmPcd, E_INVALID_HANDLE); 6766 SANITY_CHECK_RETURN_ERROR(p_FmPcd->h_Hc, E_INVALID_HANDLE); 6767 6768 if (!FmPcdLockTryLockAll(p_FmPcd)) 6769 { 6770 DBG(TRACE, ("FmPcdLockTryLockAll failed")); 6771 return ERROR_CODE(E_BUSY); 6772 } 6773 6774 err = FindKeyIndex(p_CcNode, keySize, p_Key, p_Mask, &keyIndex); 6775 if (GET_ERROR_TYPE(err) != E_OK) 6776 { 6777 FmPcdLockUnlockAll(p_FmPcd); 6778 RETURN_ERROR( 6779 MAJOR, 6780 err, 6781 ("The received key and mask pair was not found in the match table of the provided node")); 6782 } 6783 6784 err = ModifyNextEngineParamNode(p_FmPcd, p_CcNode, keyIndex, 6785 p_FmPcdCcNextEngineParams); 6786 6787 FmPcdLockUnlockAll(p_FmPcd); 6788 6789 switch(GET_ERROR_TYPE(err) 6790 ) { 6791 case E_OK: 6792 return E_OK; 6793 6794 case E_BUSY: 6795 DBG(TRACE, ("E_BUSY error")); 6796 return ERROR_CODE(E_BUSY); 6797 6798 default: 6799 RETURN_ERROR(MAJOR, err, NO_MSG); 6800 } 6801 } 6802 6803 t_Error FM_PCD_MatchTableFindNModifyKeyAndNextEngine( 6804 t_Handle h_CcNode, uint8_t keySize, uint8_t *p_Key, uint8_t *p_Mask, 6805 t_FmPcdCcKeyParams *p_KeyParams) 6806 { 6807 t_FmPcd *p_FmPcd; 6808 t_FmPcdCcNode *p_CcNode = (t_FmPcdCcNode *)h_CcNode; 6809 uint16_t keyIndex; 6810 t_Error err; 6811 6812 SANITY_CHECK_RETURN_ERROR(p_Key, E_NULL_POINTER); 6813 SANITY_CHECK_RETURN_ERROR(p_KeyParams, E_NULL_POINTER); 6814 SANITY_CHECK_RETURN_ERROR(p_CcNode, E_INVALID_HANDLE); 6815 p_FmPcd = (t_FmPcd *)p_CcNode->h_FmPcd; 6816 SANITY_CHECK_RETURN_ERROR(p_FmPcd, E_INVALID_HANDLE); 6817 SANITY_CHECK_RETURN_ERROR(p_FmPcd->h_Hc, E_INVALID_HANDLE); 6818 6819 if (!FmPcdLockTryLockAll(p_FmPcd)) 6820 { 6821 DBG(TRACE, ("FmPcdLockTryLockAll failed")); 6822 return ERROR_CODE(E_BUSY); 6823 } 6824 6825 err = FindKeyIndex(p_CcNode, keySize, p_Key, p_Mask, &keyIndex); 6826 if (GET_ERROR_TYPE(err) != E_OK) 6827 { 6828 FmPcdLockUnlockAll(p_FmPcd); 6829 RETURN_ERROR( 6830 MAJOR, 6831 err, 6832 ("The received key and mask pair was not found in the match table of the provided node")); 6833 } 6834 6835 err = FmPcdCcModifyKeyAndNextEngine(p_FmPcd, h_CcNode, keyIndex, keySize, 6836 p_KeyParams); 6837 6838 FmPcdLockUnlockAll(p_FmPcd); 6839 6840 switch(GET_ERROR_TYPE(err) 6841 ) { 6842 case E_OK: 6843 return E_OK; 6844 6845 case E_BUSY: 6846 DBG(TRACE, ("E_BUSY error")); 6847 return ERROR_CODE(E_BUSY); 6848 6849 default: 6850 RETURN_ERROR(MAJOR, err, NO_MSG); 6851 } 6852 } 6853 6854 t_Error FM_PCD_MatchTableFindNModifyKey(t_Handle h_CcNode, uint8_t keySize, 6855 uint8_t *p_Key, uint8_t *p_Mask, 6856 uint8_t *p_NewKey, uint8_t *p_NewMask) 6857 { 6858 t_FmPcd *p_FmPcd; 6859 t_FmPcdCcNode *p_CcNode = (t_FmPcdCcNode *)h_CcNode; 6860 t_List h_List; 6861 uint16_t keyIndex; 6862 t_Error err; 6863 6864 SANITY_CHECK_RETURN_ERROR(p_Key, E_NULL_POINTER); 6865 SANITY_CHECK_RETURN_ERROR(p_NewKey, E_NULL_POINTER); 6866 SANITY_CHECK_RETURN_ERROR(p_CcNode, E_INVALID_HANDLE); 6867 p_FmPcd = (t_FmPcd *)p_CcNode->h_FmPcd; 6868 SANITY_CHECK_RETURN_ERROR(p_FmPcd, E_INVALID_HANDLE); 6869 SANITY_CHECK_RETURN_ERROR(p_FmPcd->h_Hc, E_INVALID_HANDLE); 6870 6871 INIT_LIST(&h_List); 6872 6873 err = FmPcdCcNodeTreeTryLock(p_FmPcd, p_CcNode, &h_List); 6874 if (err) 6875 { 6876 DBG(TRACE, ("Node's trees lock failed")); 6877 return ERROR_CODE(E_BUSY); 6878 } 6879 6880 err = FindKeyIndex(p_CcNode, keySize, p_Key, p_Mask, &keyIndex); 6881 if (GET_ERROR_TYPE(err) != E_OK) 6882 { 6883 FmPcdCcNodeTreeReleaseLock(p_FmPcd, &h_List); 6884 RETURN_ERROR(MAJOR, err, 6885 ("The received key and mask pair was not found in the " 6886 "match table of the provided node")); 6887 } 6888 6889 err = FmPcdCcModifyKey(p_FmPcd, p_CcNode, keyIndex, keySize, p_NewKey, 6890 p_NewMask); 6891 6892 FmPcdCcNodeTreeReleaseLock(p_FmPcd, &h_List); 6893 6894 switch(GET_ERROR_TYPE(err) 6895 ) { 6896 case E_OK: 6897 return E_OK; 6898 6899 case E_BUSY: 6900 DBG(TRACE, ("E_BUSY error")); 6901 return ERROR_CODE(E_BUSY); 6902 6903 default: 6904 RETURN_ERROR(MAJOR, err, NO_MSG); 6905 } 6906 } 6907 6908 t_Error FM_PCD_MatchTableGetNextEngine( 6909 t_Handle h_CcNode, uint16_t keyIndex, 6910 t_FmPcdCcNextEngineParams *p_FmPcdCcNextEngineParams) 6911 { 6912 t_FmPcdCcNode *p_CcNode = (t_FmPcdCcNode *)h_CcNode; 6913 6914 SANITY_CHECK_RETURN_ERROR(p_CcNode, E_INVALID_HANDLE); 6915 SANITY_CHECK_RETURN_ERROR(p_FmPcdCcNextEngineParams, E_NULL_POINTER); 6916 6917 if (keyIndex >= p_CcNode->numOfKeys) 6918 RETURN_ERROR(MAJOR, E_INVALID_STATE, 6919 ("keyIndex exceeds current number of keys")); 6920 6921 if (keyIndex > (FM_PCD_MAX_NUM_OF_KEYS - 1)) 6922 RETURN_ERROR( 6923 MAJOR, 6924 E_INVALID_VALUE, 6925 ("keyIndex can not be larger than %d", (FM_PCD_MAX_NUM_OF_KEYS - 1))); 6926 6927 memcpy(p_FmPcdCcNextEngineParams, 6928 &p_CcNode->keyAndNextEngineParams[keyIndex].nextEngineParams, 6929 sizeof(t_FmPcdCcNextEngineParams)); 6930 6931 return E_OK; 6932 } 6933 6934 6935 uint32_t FM_PCD_MatchTableGetKeyCounter(t_Handle h_CcNode, uint16_t keyIndex) 6936 { 6937 t_FmPcdCcNode *p_CcNode = (t_FmPcdCcNode *)h_CcNode; 6938 uint32_t *p_StatsCounters, frameCount; 6939 uint32_t intFlags; 6940 6941 SANITY_CHECK_RETURN_VALUE(p_CcNode, E_INVALID_HANDLE, 0); 6942 6943 if (p_CcNode->statisticsMode == e_FM_PCD_CC_STATS_MODE_NONE) 6944 { 6945 REPORT_ERROR(MAJOR, E_INVALID_STATE, ("Statistics were not enabled for this match table")); 6946 return 0; 6947 } 6948 6949 if ((p_CcNode->statisticsMode != e_FM_PCD_CC_STATS_MODE_FRAME) 6950 && (p_CcNode->statisticsMode 6951 != e_FM_PCD_CC_STATS_MODE_BYTE_AND_FRAME)) 6952 { 6953 REPORT_ERROR(MAJOR, E_INVALID_STATE, ("Frame count is not supported in the statistics mode of this match table")); 6954 return 0; 6955 } 6956 6957 intFlags = XX_LockIntrSpinlock(p_CcNode->h_Spinlock); 6958 6959 if (keyIndex >= p_CcNode->numOfKeys) 6960 { 6961 XX_UnlockIntrSpinlock(p_CcNode->h_Spinlock, intFlags); 6962 REPORT_ERROR(MAJOR, E_INVALID_STATE, ("The provided keyIndex exceeds the number of keys in this match table")); 6963 return 0; 6964 } 6965 6966 if (!p_CcNode->keyAndNextEngineParams[keyIndex].p_StatsObj) 6967 { 6968 XX_UnlockIntrSpinlock(p_CcNode->h_Spinlock, intFlags); 6969 REPORT_ERROR(MAJOR, E_INVALID_STATE, ("Statistics were not enabled for this key")); 6970 return 0; 6971 } 6972 6973 p_StatsCounters = 6974 p_CcNode->keyAndNextEngineParams[keyIndex].p_StatsObj->h_StatsCounters; 6975 ASSERT_COND(p_StatsCounters); 6976 6977 /* The first counter is byte counter, so we need to advance to the next counter */ 6978 frameCount = GET_UINT32(*(uint32_t *)(PTR_MOVE(p_StatsCounters, 6979 FM_PCD_CC_STATS_COUNTER_SIZE))); 6980 6981 XX_UnlockIntrSpinlock(p_CcNode->h_Spinlock, intFlags); 6982 6983 return frameCount; 6984 } 6985 6986 t_Error FM_PCD_MatchTableGetKeyStatistics( 6987 t_Handle h_CcNode, uint16_t keyIndex, 6988 t_FmPcdCcKeyStatistics *p_KeyStatistics) 6989 { 6990 t_FmPcdCcNode *p_CcNode = (t_FmPcdCcNode *)h_CcNode; 6991 uint32_t intFlags; 6992 t_Error err; 6993 6994 SANITY_CHECK_RETURN_ERROR(h_CcNode, E_INVALID_HANDLE); 6995 SANITY_CHECK_RETURN_ERROR(p_KeyStatistics, E_NULL_POINTER); 6996 6997 intFlags = XX_LockIntrSpinlock(p_CcNode->h_Spinlock); 6998 6999 if (keyIndex >= p_CcNode->numOfKeys) 7000 RETURN_ERROR( 7001 MAJOR, 7002 E_INVALID_STATE, 7003 ("The provided keyIndex exceeds the number of keys in this match table")); 7004 7005 err = MatchTableGetKeyStatistics(p_CcNode, keyIndex, p_KeyStatistics); 7006 7007 XX_UnlockIntrSpinlock(p_CcNode->h_Spinlock, intFlags); 7008 7009 if (err != E_OK) 7010 RETURN_ERROR(MAJOR, err, NO_MSG); 7011 7012 return E_OK; 7013 } 7014 7015 t_Error FM_PCD_MatchTableGetMissStatistics( 7016 t_Handle h_CcNode, t_FmPcdCcKeyStatistics *p_MissStatistics) 7017 { 7018 t_FmPcdCcNode *p_CcNode = (t_FmPcdCcNode *)h_CcNode; 7019 uint32_t intFlags; 7020 t_Error err; 7021 7022 SANITY_CHECK_RETURN_ERROR(h_CcNode, E_INVALID_HANDLE); 7023 SANITY_CHECK_RETURN_ERROR(p_MissStatistics, E_NULL_POINTER); 7024 7025 intFlags = XX_LockIntrSpinlock(p_CcNode->h_Spinlock); 7026 7027 err = MatchTableGetKeyStatistics(p_CcNode, p_CcNode->numOfKeys, 7028 p_MissStatistics); 7029 7030 XX_UnlockIntrSpinlock(p_CcNode->h_Spinlock, intFlags); 7031 7032 if (err != E_OK) 7033 RETURN_ERROR(MAJOR, err, NO_MSG); 7034 7035 return E_OK; 7036 } 7037 7038 t_Error FM_PCD_MatchTableFindNGetKeyStatistics( 7039 t_Handle h_CcNode, uint8_t keySize, uint8_t *p_Key, uint8_t *p_Mask, 7040 t_FmPcdCcKeyStatistics *p_KeyStatistics) 7041 { 7042 t_FmPcdCcNode *p_CcNode = (t_FmPcdCcNode *)h_CcNode; 7043 uint16_t keyIndex; 7044 uint32_t intFlags; 7045 t_Error err; 7046 7047 SANITY_CHECK_RETURN_ERROR(p_Key, E_NULL_POINTER); 7048 SANITY_CHECK_RETURN_ERROR(p_KeyStatistics, E_NULL_POINTER); 7049 7050 intFlags = XX_LockIntrSpinlock(p_CcNode->h_Spinlock); 7051 7052 err = FindKeyIndex(p_CcNode, keySize, p_Key, p_Mask, &keyIndex); 7053 if (GET_ERROR_TYPE(err) != E_OK) 7054 { 7055 XX_UnlockIntrSpinlock(p_CcNode->h_Spinlock, intFlags); 7056 RETURN_ERROR(MAJOR, err, 7057 ("The received key and mask pair was not found in the " 7058 "match table of the provided node")); 7059 } 7060 7061 ASSERT_COND(keyIndex < p_CcNode->numOfKeys); 7062 7063 err = MatchTableGetKeyStatistics(p_CcNode, keyIndex, p_KeyStatistics); 7064 7065 XX_UnlockIntrSpinlock(p_CcNode->h_Spinlock, intFlags); 7066 7067 if (err != E_OK) 7068 RETURN_ERROR(MAJOR, err, NO_MSG); 7069 7070 return E_OK; 7071 } 7072 7073 t_Error FM_PCD_MatchTableGetIndexedHashBucket(t_Handle h_CcNode, 7074 uint8_t keySize, uint8_t *p_Key, 7075 uint8_t hashShift, 7076 t_Handle *p_CcNodeBucketHandle, 7077 uint8_t *p_BucketIndex, 7078 uint16_t *p_LastIndex) 7079 { 7080 t_FmPcdCcNode *p_CcNode = (t_FmPcdCcNode *)h_CcNode; 7081 uint16_t glblMask; 7082 uint64_t crc64 = 0; 7083 7084 SANITY_CHECK_RETURN_ERROR(h_CcNode, E_INVALID_HANDLE); 7085 SANITY_CHECK_RETURN_ERROR( 7086 p_CcNode->parseCode == CC_PC_GENERIC_IC_HASH_INDEXED, 7087 E_INVALID_STATE); 7088 SANITY_CHECK_RETURN_ERROR(p_Key, E_NULL_POINTER); 7089 SANITY_CHECK_RETURN_ERROR(p_CcNodeBucketHandle, E_NULL_POINTER); 7090 7091 memcpy(&glblMask, PTR_MOVE(p_CcNode->p_GlblMask, 2), 2); 7092 glblMask = be16toh(glblMask); 7093 7094 crc64 = crc64_init(); 7095 crc64 = crc64_compute(p_Key, keySize, crc64); 7096 crc64 >>= hashShift; 7097 7098 *p_BucketIndex = (uint8_t)(((crc64 >> (8 * (6 - p_CcNode->userOffset))) 7099 & glblMask) >> 4); 7100 if (*p_BucketIndex >= p_CcNode->numOfKeys) 7101 RETURN_ERROR(MINOR, E_NOT_IN_RANGE, ("bucket index!")); 7102 7103 *p_CcNodeBucketHandle = 7104 p_CcNode->keyAndNextEngineParams[*p_BucketIndex].nextEngineParams.params.ccParams.h_CcNode; 7105 if (!*p_CcNodeBucketHandle) 7106 RETURN_ERROR(MINOR, E_NOT_FOUND, ("bucket!")); 7107 7108 *p_LastIndex = ((t_FmPcdCcNode *)*p_CcNodeBucketHandle)->numOfKeys; 7109 7110 return E_OK; 7111 } 7112 7113 t_Handle FM_PCD_HashTableSet(t_Handle h_FmPcd, t_FmPcdHashTableParams *p_Param) 7114 { 7115 t_FmPcdCcNode *p_CcNodeHashTbl; 7116 t_FmPcdCcNodeParams *p_IndxHashCcNodeParam, *p_ExactMatchCcNodeParam; 7117 t_FmPcdCcNode *p_CcNode; 7118 t_Handle h_MissStatsCounters = NULL; 7119 t_FmPcdCcKeyParams *p_HashKeyParams; 7120 int i; 7121 uint16_t numOfSets, numOfWays, countMask, onesCount = 0; 7122 bool statsEnForMiss = FALSE; 7123 t_Error err; 7124 7125 SANITY_CHECK_RETURN_VALUE(h_FmPcd, E_INVALID_HANDLE, NULL); 7126 SANITY_CHECK_RETURN_VALUE(p_Param, E_NULL_POINTER, NULL); 7127 7128 if (p_Param->maxNumOfKeys == 0) 7129 { 7130 REPORT_ERROR(MINOR, E_INVALID_VALUE, ("Max number of keys must be higher then 0")); 7131 return NULL; 7132 } 7133 7134 if (p_Param->hashResMask == 0) 7135 { 7136 REPORT_ERROR(MINOR, E_INVALID_VALUE, ("Hash result mask must differ from 0")); 7137 return NULL; 7138 } 7139 7140 /*Fix: QorIQ SDK / QSDK-2131*/ 7141 if (p_Param->ccNextEngineParamsForMiss.nextEngine == e_FM_PCD_INVALID) 7142 { 7143 REPORT_ERROR(MAJOR, E_INVALID_VALUE, ("Next PCD Engine for on-miss entry is invalid. On-miss entry is always required. You can use e_FM_PCD_DONE.")); 7144 return NULL; 7145 } 7146 7147 #if (DPAA_VERSION >= 11) 7148 if (p_Param->statisticsMode == e_FM_PCD_CC_STATS_MODE_RMON) 7149 { 7150 REPORT_ERROR(MAJOR, E_INVALID_VALUE, 7151 ("RMON statistics mode is not supported for hash table")); 7152 return NULL; 7153 } 7154 #endif /* (DPAA_VERSION >= 11) */ 7155 7156 p_ExactMatchCcNodeParam = (t_FmPcdCcNodeParams*)XX_Malloc( 7157 sizeof(t_FmPcdCcNodeParams)); 7158 if (!p_ExactMatchCcNodeParam) 7159 { 7160 REPORT_ERROR(MAJOR, E_NO_MEMORY, ("p_ExactMatchCcNodeParam")); 7161 return NULL; 7162 } 7163 memset(p_ExactMatchCcNodeParam, 0, sizeof(t_FmPcdCcNodeParams)); 7164 7165 p_IndxHashCcNodeParam = (t_FmPcdCcNodeParams*)XX_Malloc( 7166 sizeof(t_FmPcdCcNodeParams)); 7167 if (!p_IndxHashCcNodeParam) 7168 { 7169 XX_Free(p_ExactMatchCcNodeParam); 7170 REPORT_ERROR(MAJOR, E_NO_MEMORY, ("p_IndxHashCcNodeParam")); 7171 return NULL; 7172 } 7173 memset(p_IndxHashCcNodeParam, 0, sizeof(t_FmPcdCcNodeParams)); 7174 7175 /* Calculate number of sets and number of ways of the hash table */ 7176 countMask = (uint16_t)(p_Param->hashResMask >> 4); 7177 while (countMask) 7178 { 7179 onesCount++; 7180 countMask = (uint16_t)(countMask >> 1); 7181 } 7182 7183 numOfSets = (uint16_t)(1 << onesCount); 7184 numOfWays = (uint16_t)DIV_CEIL(p_Param->maxNumOfKeys, numOfSets); 7185 7186 if (p_Param->maxNumOfKeys % numOfSets) 7187 DBG(INFO, ("'maxNumOfKeys' is not a multiple of hash number of ways, so number of ways will be rounded up")); 7188 7189 if ((p_Param->statisticsMode == e_FM_PCD_CC_STATS_MODE_FRAME) 7190 || (p_Param->statisticsMode == e_FM_PCD_CC_STATS_MODE_BYTE_AND_FRAME)) 7191 { 7192 /* Allocating a statistics counters table that will be used by all 7193 'miss' entries of the hash table */ 7194 h_MissStatsCounters = (t_Handle)FM_MURAM_AllocMem( 7195 FmPcdGetMuramHandle(h_FmPcd), 2 * FM_PCD_CC_STATS_COUNTER_SIZE, 7196 FM_PCD_CC_AD_TABLE_ALIGN); 7197 if (!h_MissStatsCounters) 7198 { 7199 REPORT_ERROR(MAJOR, E_NO_MEMORY, ("MURAM allocation for statistics table for hash miss")); 7200 XX_Free(p_IndxHashCcNodeParam); 7201 XX_Free(p_ExactMatchCcNodeParam); 7202 return NULL; 7203 } 7204 memset(h_MissStatsCounters, 0, (2 * FM_PCD_CC_STATS_COUNTER_SIZE)); 7205 7206 /* Always enable statistics for 'miss', so that a statistics AD will be 7207 initialized from the start. We'll store the requested 'statistics enable' 7208 value and it will be used when statistics are read by the user. */ 7209 statsEnForMiss = p_Param->ccNextEngineParamsForMiss.statisticsEn; 7210 p_Param->ccNextEngineParamsForMiss.statisticsEn = TRUE; 7211 } 7212 7213 /* Building exact-match node params, will be used to create the hash buckets */ 7214 p_ExactMatchCcNodeParam->extractCcParams.type = e_FM_PCD_EXTRACT_NON_HDR; 7215 7216 p_ExactMatchCcNodeParam->extractCcParams.extractNonHdr.src = 7217 e_FM_PCD_EXTRACT_FROM_KEY; 7218 p_ExactMatchCcNodeParam->extractCcParams.extractNonHdr.action = 7219 e_FM_PCD_ACTION_EXACT_MATCH; 7220 p_ExactMatchCcNodeParam->extractCcParams.extractNonHdr.offset = 0; 7221 p_ExactMatchCcNodeParam->extractCcParams.extractNonHdr.size = 7222 p_Param->matchKeySize; 7223 7224 p_ExactMatchCcNodeParam->keysParams.maxNumOfKeys = numOfWays; 7225 p_ExactMatchCcNodeParam->keysParams.maskSupport = FALSE; 7226 p_ExactMatchCcNodeParam->keysParams.statisticsMode = 7227 p_Param->statisticsMode; 7228 p_ExactMatchCcNodeParam->keysParams.numOfKeys = 0; 7229 p_ExactMatchCcNodeParam->keysParams.keySize = p_Param->matchKeySize; 7230 p_ExactMatchCcNodeParam->keysParams.ccNextEngineParamsForMiss = 7231 p_Param->ccNextEngineParamsForMiss; 7232 7233 p_HashKeyParams = p_IndxHashCcNodeParam->keysParams.keyParams; 7234 7235 for (i = 0; i < numOfSets; i++) 7236 { 7237 /* Each exact-match node will be marked as a 'bucket' and provided with 7238 a pointer to statistics counters, to be used for 'miss' entry 7239 statistics */ 7240 p_CcNode = (t_FmPcdCcNode *)XX_Malloc(sizeof(t_FmPcdCcNode)); 7241 if (!p_CcNode) 7242 break; 7243 memset(p_CcNode, 0, sizeof(t_FmPcdCcNode)); 7244 7245 p_CcNode->isHashBucket = TRUE; 7246 p_CcNode->h_MissStatsCounters = h_MissStatsCounters; 7247 7248 err = MatchTableSet(h_FmPcd, p_CcNode, p_ExactMatchCcNodeParam); 7249 if (err) 7250 break; 7251 7252 p_HashKeyParams[i].ccNextEngineParams.nextEngine = e_FM_PCD_CC; 7253 p_HashKeyParams[i].ccNextEngineParams.statisticsEn = FALSE; 7254 p_HashKeyParams[i].ccNextEngineParams.params.ccParams.h_CcNode = 7255 p_CcNode; 7256 } 7257 7258 if (i < numOfSets) 7259 { 7260 for (i = i - 1; i >= 0; i--) 7261 FM_PCD_MatchTableDelete( 7262 p_HashKeyParams[i].ccNextEngineParams.params.ccParams.h_CcNode); 7263 7264 FM_MURAM_FreeMem(FmPcdGetMuramHandle(h_FmPcd), h_MissStatsCounters); 7265 7266 REPORT_ERROR(MAJOR, E_NULL_POINTER, NO_MSG); 7267 XX_Free(p_IndxHashCcNodeParam); 7268 XX_Free(p_ExactMatchCcNodeParam); 7269 return NULL; 7270 } 7271 7272 /* Creating indexed-hash CC node */ 7273 p_IndxHashCcNodeParam->extractCcParams.type = e_FM_PCD_EXTRACT_NON_HDR; 7274 p_IndxHashCcNodeParam->extractCcParams.extractNonHdr.src = 7275 e_FM_PCD_EXTRACT_FROM_HASH; 7276 p_IndxHashCcNodeParam->extractCcParams.extractNonHdr.action = 7277 e_FM_PCD_ACTION_INDEXED_LOOKUP; 7278 p_IndxHashCcNodeParam->extractCcParams.extractNonHdr.icIndxMask = 7279 p_Param->hashResMask; 7280 p_IndxHashCcNodeParam->extractCcParams.extractNonHdr.offset = 7281 p_Param->hashShift; 7282 p_IndxHashCcNodeParam->extractCcParams.extractNonHdr.size = 2; 7283 7284 p_IndxHashCcNodeParam->keysParams.maxNumOfKeys = numOfSets; 7285 p_IndxHashCcNodeParam->keysParams.maskSupport = FALSE; 7286 p_IndxHashCcNodeParam->keysParams.statisticsMode = 7287 e_FM_PCD_CC_STATS_MODE_NONE; 7288 /* Number of keys of this node is number of sets of the hash */ 7289 p_IndxHashCcNodeParam->keysParams.numOfKeys = numOfSets; 7290 p_IndxHashCcNodeParam->keysParams.keySize = 2; 7291 7292 p_CcNodeHashTbl = FM_PCD_MatchTableSet(h_FmPcd, p_IndxHashCcNodeParam); 7293 7294 if (p_CcNodeHashTbl) 7295 { 7296 p_CcNodeHashTbl->kgHashShift = p_Param->kgHashShift; 7297 7298 /* Storing the allocated counters for buckets 'miss' in the hash table 7299 and if statistics for miss were enabled. */ 7300 p_CcNodeHashTbl->h_MissStatsCounters = h_MissStatsCounters; 7301 p_CcNodeHashTbl->statsEnForMiss = statsEnForMiss; 7302 } 7303 7304 XX_Free(p_IndxHashCcNodeParam); 7305 XX_Free(p_ExactMatchCcNodeParam); 7306 7307 return p_CcNodeHashTbl; 7308 } 7309 7310 t_Error FM_PCD_HashTableDelete(t_Handle h_HashTbl) 7311 { 7312 t_FmPcdCcNode *p_HashTbl = (t_FmPcdCcNode *)h_HashTbl; 7313 t_Handle h_FmPcd; 7314 t_Handle *p_HashBuckets, h_MissStatsCounters; 7315 uint16_t i, numOfBuckets; 7316 t_Error err; 7317 7318 SANITY_CHECK_RETURN_ERROR(p_HashTbl, E_INVALID_HANDLE); 7319 7320 /* Store all hash buckets before the hash is freed */ 7321 numOfBuckets = p_HashTbl->numOfKeys; 7322 7323 p_HashBuckets = (t_Handle *)XX_Malloc(numOfBuckets * sizeof(t_Handle)); 7324 if (!p_HashBuckets) 7325 RETURN_ERROR(MAJOR, E_NO_MEMORY, NO_MSG); 7326 7327 for (i = 0; i < numOfBuckets; i++) 7328 p_HashBuckets[i] = 7329 p_HashTbl->keyAndNextEngineParams[i].nextEngineParams.params.ccParams.h_CcNode; 7330 7331 h_FmPcd = p_HashTbl->h_FmPcd; 7332 h_MissStatsCounters = p_HashTbl->h_MissStatsCounters; 7333 7334 /* Free the hash */ 7335 err = FM_PCD_MatchTableDelete(p_HashTbl); 7336 7337 /* Free each hash bucket */ 7338 for (i = 0; i < numOfBuckets; i++) 7339 err |= FM_PCD_MatchTableDelete(p_HashBuckets[i]); 7340 7341 XX_Free(p_HashBuckets); 7342 7343 /* Free statistics counters for 'miss', if these were allocated */ 7344 if (h_MissStatsCounters) 7345 FM_MURAM_FreeMem(FmPcdGetMuramHandle(h_FmPcd), h_MissStatsCounters); 7346 7347 if (err) 7348 RETURN_ERROR(MAJOR, err, NO_MSG); 7349 7350 return E_OK; 7351 } 7352 7353 t_Error FM_PCD_HashTableAddKey(t_Handle h_HashTbl, uint8_t keySize, 7354 t_FmPcdCcKeyParams *p_KeyParams) 7355 { 7356 t_FmPcdCcNode *p_HashTbl = (t_FmPcdCcNode *)h_HashTbl; 7357 t_Handle h_HashBucket; 7358 uint8_t bucketIndex; 7359 uint16_t lastIndex; 7360 t_Error err; 7361 7362 SANITY_CHECK_RETURN_ERROR(p_HashTbl, E_INVALID_HANDLE); 7363 SANITY_CHECK_RETURN_ERROR(p_KeyParams, E_NULL_POINTER); 7364 SANITY_CHECK_RETURN_ERROR(p_KeyParams->p_Key, E_NULL_POINTER); 7365 7366 if (p_KeyParams->p_Mask) 7367 RETURN_ERROR(MAJOR, E_INVALID_VALUE, 7368 ("Keys masks not supported for hash table")); 7369 7370 err = FM_PCD_MatchTableGetIndexedHashBucket(p_HashTbl, keySize, 7371 p_KeyParams->p_Key, 7372 p_HashTbl->kgHashShift, 7373 &h_HashBucket, &bucketIndex, 7374 &lastIndex); 7375 if (err) 7376 RETURN_ERROR(MAJOR, err, NO_MSG); 7377 7378 return FM_PCD_MatchTableAddKey(h_HashBucket, FM_PCD_LAST_KEY_INDEX, keySize, 7379 p_KeyParams); 7380 } 7381 7382 t_Error FM_PCD_HashTableRemoveKey(t_Handle h_HashTbl, uint8_t keySize, 7383 uint8_t *p_Key) 7384 { 7385 t_FmPcdCcNode *p_HashTbl = (t_FmPcdCcNode *)h_HashTbl; 7386 t_Handle h_HashBucket; 7387 uint8_t bucketIndex; 7388 uint16_t lastIndex; 7389 t_Error err; 7390 7391 SANITY_CHECK_RETURN_ERROR(p_HashTbl, E_INVALID_HANDLE); 7392 SANITY_CHECK_RETURN_ERROR(p_Key, E_NULL_POINTER); 7393 7394 err = FM_PCD_MatchTableGetIndexedHashBucket(p_HashTbl, keySize, p_Key, 7395 p_HashTbl->kgHashShift, 7396 &h_HashBucket, &bucketIndex, 7397 &lastIndex); 7398 if (err) 7399 RETURN_ERROR(MAJOR, err, NO_MSG); 7400 7401 return FM_PCD_MatchTableFindNRemoveKey(h_HashBucket, keySize, p_Key, NULL); 7402 } 7403 7404 t_Error FM_PCD_HashTableModifyNextEngine( 7405 t_Handle h_HashTbl, uint8_t keySize, uint8_t *p_Key, 7406 t_FmPcdCcNextEngineParams *p_FmPcdCcNextEngineParams) 7407 { 7408 t_FmPcdCcNode *p_HashTbl = (t_FmPcdCcNode *)h_HashTbl; 7409 t_Handle h_HashBucket; 7410 uint8_t bucketIndex; 7411 uint16_t lastIndex; 7412 t_Error err; 7413 7414 SANITY_CHECK_RETURN_ERROR(p_HashTbl, E_INVALID_HANDLE); 7415 SANITY_CHECK_RETURN_ERROR(p_Key, E_NULL_POINTER); 7416 SANITY_CHECK_RETURN_ERROR(p_FmPcdCcNextEngineParams, E_NULL_POINTER); 7417 7418 err = FM_PCD_MatchTableGetIndexedHashBucket(p_HashTbl, keySize, p_Key, 7419 p_HashTbl->kgHashShift, 7420 &h_HashBucket, &bucketIndex, 7421 &lastIndex); 7422 if (err) 7423 RETURN_ERROR(MAJOR, err, NO_MSG); 7424 7425 return FM_PCD_MatchTableFindNModifyNextEngine(h_HashBucket, keySize, p_Key, 7426 NULL, 7427 p_FmPcdCcNextEngineParams); 7428 } 7429 7430 t_Error FM_PCD_HashTableModifyMissNextEngine( 7431 t_Handle h_HashTbl, 7432 t_FmPcdCcNextEngineParams *p_FmPcdCcNextEngineParams) 7433 { 7434 t_FmPcdCcNode *p_HashTbl = (t_FmPcdCcNode *)h_HashTbl; 7435 t_Handle h_HashBucket; 7436 uint8_t i; 7437 bool nullifyMissStats = FALSE; 7438 t_Error err; 7439 7440 SANITY_CHECK_RETURN_ERROR(h_HashTbl, E_INVALID_HANDLE); 7441 SANITY_CHECK_RETURN_ERROR(p_FmPcdCcNextEngineParams, E_NULL_POINTER); 7442 7443 if ((!p_HashTbl->h_MissStatsCounters) 7444 && (p_FmPcdCcNextEngineParams->statisticsEn)) 7445 RETURN_ERROR( 7446 MAJOR, 7447 E_CONFLICT, 7448 ("Statistics are requested for a key, but statistics mode was set" 7449 "to 'NONE' upon initialization")); 7450 7451 if (p_HashTbl->h_MissStatsCounters) 7452 { 7453 if ((!p_HashTbl->statsEnForMiss) 7454 && (p_FmPcdCcNextEngineParams->statisticsEn)) 7455 nullifyMissStats = TRUE; 7456 7457 if ((p_HashTbl->statsEnForMiss) 7458 && (!p_FmPcdCcNextEngineParams->statisticsEn)) 7459 { 7460 p_HashTbl->statsEnForMiss = FALSE; 7461 p_FmPcdCcNextEngineParams->statisticsEn = TRUE; 7462 } 7463 } 7464 7465 for (i = 0; i < p_HashTbl->numOfKeys; i++) 7466 { 7467 h_HashBucket = 7468 p_HashTbl->keyAndNextEngineParams[i].nextEngineParams.params.ccParams.h_CcNode; 7469 7470 err = FM_PCD_MatchTableModifyMissNextEngine(h_HashBucket, 7471 p_FmPcdCcNextEngineParams); 7472 if (err) 7473 RETURN_ERROR(MAJOR, err, NO_MSG); 7474 } 7475 7476 if (nullifyMissStats) 7477 { 7478 memset(p_HashTbl->h_MissStatsCounters, 0, 7479 (2 * FM_PCD_CC_STATS_COUNTER_SIZE)); 7480 memset(p_HashTbl->h_MissStatsCounters, 0, 7481 (2 * FM_PCD_CC_STATS_COUNTER_SIZE)); 7482 p_HashTbl->statsEnForMiss = TRUE; 7483 } 7484 7485 return E_OK; 7486 } 7487 7488 7489 t_Error FM_PCD_HashTableGetMissNextEngine( 7490 t_Handle h_HashTbl, 7491 t_FmPcdCcNextEngineParams *p_FmPcdCcNextEngineParams) 7492 { 7493 t_FmPcdCcNode *p_HashTbl = (t_FmPcdCcNode *)h_HashTbl; 7494 t_FmPcdCcNode *p_HashBucket; 7495 7496 SANITY_CHECK_RETURN_ERROR(p_HashTbl, E_INVALID_HANDLE); 7497 7498 /* Miss next engine of each bucket was initialized with the next engine of the hash table */ 7499 p_HashBucket = 7500 p_HashTbl->keyAndNextEngineParams[0].nextEngineParams.params.ccParams.h_CcNode; 7501 7502 memcpy(p_FmPcdCcNextEngineParams, 7503 &p_HashBucket->keyAndNextEngineParams[p_HashBucket->numOfKeys].nextEngineParams, 7504 sizeof(t_FmPcdCcNextEngineParams)); 7505 7506 return E_OK; 7507 } 7508 7509 t_Error FM_PCD_HashTableFindNGetKeyStatistics( 7510 t_Handle h_HashTbl, uint8_t keySize, uint8_t *p_Key, 7511 t_FmPcdCcKeyStatistics *p_KeyStatistics) 7512 { 7513 t_FmPcdCcNode *p_HashTbl = (t_FmPcdCcNode *)h_HashTbl; 7514 t_Handle h_HashBucket; 7515 uint8_t bucketIndex; 7516 uint16_t lastIndex; 7517 t_Error err; 7518 7519 SANITY_CHECK_RETURN_ERROR(p_HashTbl, E_INVALID_HANDLE); 7520 SANITY_CHECK_RETURN_ERROR(p_Key, E_NULL_POINTER); 7521 SANITY_CHECK_RETURN_ERROR(p_KeyStatistics, E_NULL_POINTER); 7522 7523 err = FM_PCD_MatchTableGetIndexedHashBucket(p_HashTbl, keySize, p_Key, 7524 p_HashTbl->kgHashShift, 7525 &h_HashBucket, &bucketIndex, 7526 &lastIndex); 7527 if (err) 7528 RETURN_ERROR(MAJOR, err, NO_MSG); 7529 7530 return FM_PCD_MatchTableFindNGetKeyStatistics(h_HashBucket, keySize, p_Key, 7531 NULL, p_KeyStatistics); 7532 } 7533 7534 t_Error FM_PCD_HashTableGetMissStatistics( 7535 t_Handle h_HashTbl, t_FmPcdCcKeyStatistics *p_MissStatistics) 7536 { 7537 t_FmPcdCcNode *p_HashTbl = (t_FmPcdCcNode *)h_HashTbl; 7538 t_Handle h_HashBucket; 7539 7540 SANITY_CHECK_RETURN_ERROR(p_HashTbl, E_INVALID_HANDLE); 7541 SANITY_CHECK_RETURN_ERROR(p_MissStatistics, E_NULL_POINTER); 7542 7543 if (!p_HashTbl->statsEnForMiss) 7544 RETURN_ERROR(MAJOR, E_INVALID_STATE, 7545 ("Statistics were not enabled for miss")); 7546 7547 h_HashBucket = 7548 p_HashTbl->keyAndNextEngineParams[0].nextEngineParams.params.ccParams.h_CcNode; 7549 7550 return FM_PCD_MatchTableGetMissStatistics(h_HashBucket, p_MissStatistics); 7551 } 7552