fmd21 integration

Signed-off-by: Mandy Lavi <mandy.lavi@freescale.com>

Prev fmd integration was fmd19
Diffs from fmd19 to fmd21:

Added kgHashShift to t_FmPcdHashTableParams
Added nonConsistentSp to t_FmPcdManipReassemIpStats

sp - 2 layers separation - for future flib integration
rtc - 2 layers separation - for future flib integration

PFC enhancement (B4 Rev2 FMAN)
API addition (for B4 rev 2): FM_PORT_SetPfcPrioritiesMappingToQmanWQ

File fsl_fman.h renamed to lnxwrp_fsl_fman.h
The name fsl_fman.h has been applied to other fman internal header file

In dpaa_eth:
Due to renaming of fsl_fman.h to lnxwrp_fsl_fman.h
The relevant include lines in some of the files had to change accordingly

Change-Id: I8f25c758963a44a75ca8676aad45f7f96767b0b5
Reviewed-on: http://git.am.freescale.net:8181/2069
Reviewed-by: Fleming Andrew-AFLEMING <AFLEMING@freescale.com>
Tested-by: Fleming Andrew-AFLEMING <AFLEMING@freescale.com>

6 files changed, 219 insertions, 177 deletions

diff --git a/drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fm_cc.c b/drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fm_cc.c
index 85810a9..a68ff12 100644
--- a/drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fm_cc.c
+++ b/drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fm_cc.c
@@ -377,9 +377,12 @@ static t_Error AllocAndFillAdForContLookupManip(t_Handle h_CcNode)
 
     if (!p_CcNode->h_Ad)
     {
-        p_CcNode->h_Ad = (t_Handle)FM_MURAM_AllocMem(((t_FmPcd *)(p_CcNode->h_FmPcd))->h_FmMuram,
-                                           FM_PCD_CC_AD_ENTRY_SIZE,
-                                           FM_PCD_CC_AD_TABLE_ALIGN);
+        if (p_CcNode->maxNumOfKeys)
+            p_CcNode->h_Ad = p_CcNode->h_TmpAd;
+        else
+            p_CcNode->h_Ad = (t_Handle)FM_MURAM_AllocMem(((t_FmPcd *)(p_CcNode->h_FmPcd))->h_FmMuram,
+                                                         FM_PCD_CC_AD_ENTRY_SIZE,
+                                                         FM_PCD_CC_AD_TABLE_ALIGN);
 
         XX_UnlockIntrSpinlock(p_CcNode->h_Spinlock, intFlags);
 
@@ -1174,6 +1177,7 @@ static void DeleteNode(t_FmPcdCcNode *p_CcNode)
     {
         FM_MURAM_FreeMem(FmPcdGetMuramHandle(p_CcNode->h_FmPcd), p_CcNode->h_Ad);
         p_CcNode->h_Ad = NULL;
+        p_CcNode->h_TmpAd = NULL;
     }
 
     if (p_CcNode->h_StatsFLRs)
@@ -3185,12 +3189,12 @@ static void UpdateAdPtrOfTreesWhichPointsOnCrntMdfNode(t_FmPcdCcNode
     }
 }
 
-static t_FmPcdModifyCcKeyAdditionalParams* ModifyKeyCommonPart1(t_Handle        h_FmPcdCcNodeOrTree,
-                                                                uint16_t        keyIndex,
-                                                                e_ModifyState   modifyState,
-                                                                bool            ttlCheck,
-                                                                bool            hashCheck,
-                                                                bool            tree)
+static t_FmPcdModifyCcKeyAdditionalParams * ModifyNodeCommonPart(t_Handle        h_FmPcdCcNodeOrTree,
+                                                                 uint16_t        keyIndex,
+                                                                 e_ModifyState   modifyState,
+                                                                 bool            ttlCheck,
+                                                                 bool            hashCheck,
+                                                                 bool            tree)
 {
     t_FmPcdModifyCcKeyAdditionalParams  *p_FmPcdModifyCcKeyAdditionalParams;
     int                                 i = 0, j = 0;
@@ -3202,14 +3206,6 @@ static t_FmPcdModifyCcKeyAdditionalParams* ModifyKeyCommonPart1(t_Handle
 
     SANITY_CHECK_RETURN_VALUE(h_FmPcdCcNodeOrTree, E_INVALID_HANDLE, NULL);
 
-    p_KeyAndNextEngineParams = (t_FmPcdCcKeyAndNextEngineParams *)XX_Malloc(sizeof(t_FmPcdCcKeyAndNextEngineParams)*CC_MAX_NUM_OF_KEYS);
-    if (!p_KeyAndNextEngineParams)
-    {
-        REPORT_ERROR(MAJOR, E_NO_MEMORY, ("Next engine and required action structure"));
-        return NULL;
-    }
-    memset(p_KeyAndNextEngineParams, 0, sizeof(t_FmPcdCcKeyAndNextEngineParams)*CC_MAX_NUM_OF_KEYS);
-
     if (!tree)
     {
         p_CcNode = (t_FmPcdCcNode *)h_FmPcdCcNodeOrTree;
@@ -3219,22 +3215,26 @@ static t_FmPcdModifyCcKeyAdditionalParams* ModifyKeyCommonPart1(t_Handle
         if (!LIST_NumOfObjs(&p_CcNode->ccPrevNodesLst) &&
             !LIST_NumOfObjs(&p_CcNode->ccTreeIdLst))
         {
-            XX_Free(p_KeyAndNextEngineParams);
             REPORT_ERROR(MAJOR, E_INVALID_VALUE, ("node has to be pointed by node or tree"));
             return NULL;
         }
 
         if (!LIST_NumOfObjs(&p_CcNode->ccTreesLst) ||
-           (LIST_NumOfObjs(&p_CcNode->ccTreesLst) != 1))
+            (LIST_NumOfObjs(&p_CcNode->ccTreesLst) != 1))
         {
-            XX_Free(p_KeyAndNextEngineParams);
             REPORT_ERROR(MAJOR, E_INVALID_VALUE, ("node has to be belonging to some tree and only to one tree"));
             return NULL;
         }
 
+        p_KeyAndNextEngineParams = (t_FmPcdCcKeyAndNextEngineParams *)XX_Malloc(sizeof(t_FmPcdCcKeyAndNextEngineParams)*(numOfKeys+1));
+        if (!p_KeyAndNextEngineParams)
+        {
+            REPORT_ERROR(MAJOR, E_NO_MEMORY, ("Next engine and required action structure"));
+            return NULL;
+        }
         memcpy(p_KeyAndNextEngineParams,
                p_CcNode->keyAndNextEngineParams,
-               CC_MAX_NUM_OF_KEYS * sizeof(t_FmPcdCcKeyAndNextEngineParams));
+               (numOfKeys+1) * sizeof(t_FmPcdCcKeyAndNextEngineParams));
 
         if (ttlCheck)
         {
@@ -3261,6 +3261,13 @@ static t_FmPcdModifyCcKeyAdditionalParams* ModifyKeyCommonPart1(t_Handle
     {
         p_FmPcdCcTree = (t_FmPcdCcTree *)h_FmPcdCcNodeOrTree;
         numOfKeys = p_FmPcdCcTree->numOfEntries;
+
+        p_KeyAndNextEngineParams = (t_FmPcdCcKeyAndNextEngineParams *)XX_Malloc(sizeof(t_FmPcdCcKeyAndNextEngineParams)*FM_PCD_MAX_NUM_OF_CC_GROUPS);
+        if (!p_KeyAndNextEngineParams)
+        {
+            REPORT_ERROR(MAJOR, E_NO_MEMORY, ("Next engine and required action structure"));
+            return NULL;
+        }
         memcpy(p_KeyAndNextEngineParams,
                p_FmPcdCcTree->keyAndNextEngineParams,
                FM_PCD_MAX_NUM_OF_CC_GROUPS * sizeof(t_FmPcdCcKeyAndNextEngineParams));
@@ -3779,17 +3786,15 @@ static t_Error ModifyNextEngineParamNode(t_Handle                    h_FmPcd,
     INIT_LIST(&h_OldPointersLst);
     INIT_LIST(&h_NewPointersLst);
 
-    p_ModifyKeyParams = ModifyKeyCommonPart1(p_CcNode, keyIndex, e_MODIFY_STATE_CHANGE, FALSE, FALSE, FALSE);
+    p_ModifyKeyParams = ModifyNodeCommonPart(p_CcNode, keyIndex, e_MODIFY_STATE_CHANGE, FALSE, FALSE, FALSE);
     if (!p_ModifyKeyParams)
         RETURN_ERROR(MAJOR, E_INVALID_STATE, NO_MSG);
 
-    if (p_CcNode->maxNumOfKeys)
+    if (p_CcNode->maxNumOfKeys &&
+        !TRY_LOCK(p_FmPcd->h_ShadowSpinlock, &p_FmPcd->shadowLock))
     {
-        if (!TRY_LOCK(p_FmPcd->h_ShadowSpinlock, &p_FmPcd->shadowLock))
-        {
-            XX_Free(p_ModifyKeyParams);
-            return ERROR_CODE(E_BUSY);
-        }
+        XX_Free(p_ModifyKeyParams);
+        return ERROR_CODE(E_BUSY);
     }
 
     err = BuildNewNodeModifyNextEngine(h_FmPcd,
@@ -4327,18 +4332,18 @@ t_Error FmPcdCcModifyNextEngineParamTree(t_Handle                   h_FmPcd,
 
     keyIndex = (uint16_t)(p_FmPcdCcTree->fmPcdGroupParam[grpId].baseGroupEntry + index);
 
-    p_ModifyKeyParams = ModifyKeyCommonPart1(p_FmPcdCcTree, keyIndex, e_MODIFY_STATE_CHANGE, FALSE, FALSE, TRUE);
+    p_ModifyKeyParams = ModifyNodeCommonPart(p_FmPcdCcTree, keyIndex, e_MODIFY_STATE_CHANGE, FALSE, FALSE, TRUE);
     if (!p_ModifyKeyParams)
         RETURN_ERROR(MAJOR, E_INVALID_STATE, NO_MSG);
 
     p_ModifyKeyParams->tree = TRUE;
 
-    if (p_FmPcd->p_CcShadow)
-        if (!TRY_LOCK(p_FmPcd->h_ShadowSpinlock, &p_FmPcd->shadowLock))
-        {
-            XX_Free(p_ModifyKeyParams);
-            return ERROR_CODE(E_BUSY);
-        }
+    if (p_FmPcd->p_CcShadow &&
+        !TRY_LOCK(p_FmPcd->h_ShadowSpinlock, &p_FmPcd->shadowLock))
+    {
+        XX_Free(p_ModifyKeyParams);
+        return ERROR_CODE(E_BUSY);
+    }
 
     err = BuildNewNodeModifyNextEngine(p_FmPcd,
                                        p_FmPcdCcTree,
@@ -4388,7 +4393,7 @@ t_Error FmPcdCcRemoveKey(t_Handle   h_FmPcd,
     INIT_LIST(&h_OldPointersLst);
     INIT_LIST(&h_NewPointersLst);
 
-    p_ModifyKeyParams = ModifyKeyCommonPart1(p_CcNode, keyIndex, e_MODIFY_STATE_REMOVE, TRUE, TRUE, FALSE);
+    p_ModifyKeyParams = ModifyNodeCommonPart(p_CcNode, keyIndex, e_MODIFY_STATE_REMOVE, TRUE, TRUE, FALSE);
     if (!p_ModifyKeyParams)
         RETURN_ERROR(MAJOR, E_INVALID_STATE, NO_MSG);
 
@@ -4475,7 +4480,7 @@ t_Error FmPcdCcModifyKey(t_Handle   h_FmPcd,
     INIT_LIST(&h_OldPointersLst);
     INIT_LIST(&h_NewPointersLst);
 
-    p_ModifyKeyParams = ModifyKeyCommonPart1(p_CcNode, keyIndex, e_MODIFY_STATE_CHANGE, TRUE, TRUE, FALSE);
+    p_ModifyKeyParams = ModifyNodeCommonPart(p_CcNode, keyIndex, e_MODIFY_STATE_CHANGE, TRUE, TRUE, FALSE);
     if (!p_ModifyKeyParams)
         RETURN_ERROR(MAJOR, E_INVALID_STATE, NO_MSG);
 
@@ -4548,17 +4553,15 @@ t_Error FmPcdCcModifyMissNextEngineParamNode(t_Handle                   h_FmPcd,
     INIT_LIST(&h_OldPointersLst);
     INIT_LIST(&h_NewPointersLst);
 
-    p_ModifyKeyParams = ModifyKeyCommonPart1(p_CcNode, keyIndex, e_MODIFY_STATE_CHANGE, FALSE, TRUE, FALSE);
+    p_ModifyKeyParams = ModifyNodeCommonPart(p_CcNode, keyIndex, e_MODIFY_STATE_CHANGE, FALSE, TRUE, FALSE);
     if (!p_ModifyKeyParams)
         RETURN_ERROR(MAJOR, E_INVALID_STATE, NO_MSG);
 
-    if (p_CcNode->maxNumOfKeys)
+    if (p_CcNode->maxNumOfKeys &&
+        !TRY_LOCK(p_FmPcd->h_ShadowSpinlock, &p_FmPcd->shadowLock))
     {
-        if (!TRY_LOCK(p_FmPcd->h_ShadowSpinlock, &p_FmPcd->shadowLock))
-        {
-            XX_Free(p_ModifyKeyParams);
-            return ERROR_CODE(E_BUSY);
-        }
+        XX_Free(p_ModifyKeyParams);
+        return ERROR_CODE(E_BUSY);
     }
 
     err = BuildNewNodeModifyNextEngine(h_FmPcd,
@@ -4621,7 +4624,7 @@ t_Error FmPcdCcAddKey(t_Handle              h_FmPcd,
                        p_FmPcdCcKeyParams->p_Mask,
                        &tmpKeyIndex);
     if (GET_ERROR_TYPE(err) != E_NOT_FOUND)
-        RETURN_ERROR(MINOR, E_ALREADY_EXISTS,
+        RETURN_ERROR(MAJOR, E_ALREADY_EXISTS,
                      ("The received key and mask pair was already found in the match table of the provided node"));
 
     p_FmPcd = (t_FmPcd *)p_CcNode->h_FmPcd;
@@ -4629,7 +4632,7 @@ t_Error FmPcdCcAddKey(t_Handle              h_FmPcd,
     INIT_LIST(&h_OldPointersLst);
     INIT_LIST(&h_NewPointersLst);
 
-    p_ModifyKeyParams = ModifyKeyCommonPart1(p_CcNode,
+    p_ModifyKeyParams = ModifyNodeCommonPart(p_CcNode,
                                              keyIndex,
                                              e_MODIFY_STATE_ADD,
                                              TRUE,
@@ -4725,7 +4728,7 @@ t_Error FmPcdCcModifyKeyAndNextEngine(t_Handle              h_FmPcd,
     INIT_LIST(&h_OldPointersLst);
     INIT_LIST(&h_NewPointersLst);
 
-    p_ModifyKeyParams = ModifyKeyCommonPart1(p_CcNode, keyIndex, e_MODIFY_STATE_CHANGE, TRUE, TRUE, FALSE);
+    p_ModifyKeyParams = ModifyNodeCommonPart(p_CcNode, keyIndex, e_MODIFY_STATE_CHANGE, TRUE, TRUE, FALSE);
     if (!p_ModifyKeyParams)
         RETURN_ERROR(MAJOR, E_INVALID_STATE, NO_MSG);
 
@@ -5676,10 +5679,10 @@ t_Handle FM_PCD_MatchTableSet(t_Handle h_FmPcd, t_FmPcdCcNodeParams *p_CcNodePar
         /* If manipulation will be initialized before this node, it will use the table
            descriptor in the AD table of previous node and this node will need an extra
            AD as his table descriptor. */
-        p_CcNode->h_Ad = (t_Handle)FM_MURAM_AllocMem(h_FmMuram,
+        p_CcNode->h_TmpAd = (t_Handle)FM_MURAM_AllocMem(h_FmMuram,
                                                      FM_PCD_CC_AD_ENTRY_SIZE,
                                                      FM_PCD_CC_AD_TABLE_ALIGN);
-        if (!p_CcNode->h_Ad)
+        if (!p_CcNode->h_TmpAd)
         {
             DeleteNode(p_CcNode);
             REPORT_ERROR(MAJOR, E_NO_MEMORY, ("MURAM allocation for CC action descriptor"));
@@ -5932,6 +5935,7 @@ t_Handle FM_PCD_MatchTableSet(t_Handle h_FmPcd, t_FmPcdCcNodeParams *p_CcNodePar
     }
 
     FmPcdLockUnlockAll(h_FmPcd);
+
     return p_CcNode;
 }
 
@@ -5945,6 +5949,8 @@ t_Error FM_PCD_MatchTableDelete(t_Handle h_CcNode)
     p_FmPcd = (t_FmPcd *)p_CcNode->h_FmPcd;
     SANITY_CHECK_RETURN_ERROR(p_FmPcd, E_INVALID_HANDLE);
 
+    UNUSED(p_FmPcd);
+
     if (p_CcNode->owners)
         RETURN_ERROR(MAJOR, E_INVALID_STATE, ("This node cannot be removed because it is occupied; first unbind this node"));
 
@@ -6732,7 +6738,10 @@ t_Handle FM_PCD_HashTableSet(t_Handle h_FmPcd, t_FmPcdHashTableParams *p_Param)
     p_IndxHashCcNodeParam->keysParams.keySize        = 2;
 
     p_CcNodeHashTbl = FM_PCD_MatchTableSet(h_FmPcd, p_IndxHashCcNodeParam);
-
+ 
+    if (p_CcNodeHashTbl)
+        p_CcNodeHashTbl->kgHashShift = p_Param->kgHashShift;
+ 
     XX_Free(p_IndxHashCcNodeParam);
     XX_Free(p_ExactMatchCcNodeParam);
 
@@ -6790,7 +6799,7 @@ t_Error FM_PCD_HashTableAddKey(t_Handle            h_HashTbl,
     err = FM_PCD_MatchTableGetIndexedHashBucket(p_HashTbl,
                                                 keySize,
                                                 p_KeyParams->p_Key,
-                                                p_HashTbl->userOffset,
+                                                p_HashTbl->kgHashShift,
                                                 &h_HashBucket,
                                                 &bucketIndex,
                                                 &lastIndex);
@@ -6819,7 +6828,7 @@ t_Error FM_PCD_HashTableRemoveKey(t_Handle h_HashTbl,
     err = FM_PCD_MatchTableGetIndexedHashBucket(p_HashTbl,
                                                 keySize,
                                                 p_Key,
-                                                p_HashTbl->userOffset,
+                                                p_HashTbl->kgHashShift,
                                                 &h_HashBucket,
                                                 &bucketIndex,
                                                 &lastIndex);
@@ -6850,7 +6859,7 @@ t_Error FM_PCD_HashTableModifyNextEngine(t_Handle                  h_HashTbl,
     err = FM_PCD_MatchTableGetIndexedHashBucket(p_HashTbl,
                                                 keySize,
                                                 p_Key,
-                                                p_HashTbl->userOffset,
+                                                p_HashTbl->kgHashShift,
                                                 &h_HashBucket,
                                                 &bucketIndex,
                                                 &lastIndex);
@@ -6925,7 +6934,7 @@ t_Error FM_PCD_HashTableFindNGetKeyStatistics(t_Handle                 h_HashTbl
     err = FM_PCD_MatchTableGetIndexedHashBucket(p_HashTbl,
                                                 keySize,
                                                 p_Key,
-                                                p_HashTbl->userOffset,
+                                                p_HashTbl->kgHashShift,
                                                 &h_HashBucket,
                                                 &bucketIndex,
                                                 &lastIndex);
diff --git a/drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fm_cc.h b/drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fm_cc.h
index 9efe721..eeb43a2 100644
--- a/drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fm_cc.h
+++ b/drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fm_cc.h
@@ -326,6 +326,7 @@ typedef struct
     t_Handle            h_KeysMatchTable;
     t_Handle            h_AdTable;
     t_Handle            h_StatsAds;
+    t_Handle            h_TmpAd;
     t_Handle            h_Ad;
     t_Handle            h_StatsFLRs;
 
@@ -340,6 +341,7 @@ typedef struct
     uint32_t            shadowAction;
     uint8_t             userSizeOfExtraction;
     uint8_t             userOffset;
+    uint8_t             kgHashShift;            /* used in hash-table */
 
     t_Handle            h_Spinlock;
 
diff --git a/drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fm_kg.c b/drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fm_kg.c
index bdbc8ae..5570bb1 100644
--- a/drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fm_kg.c
+++ b/drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fm_kg.c
@@ -838,6 +838,7 @@ static void UnbindPortToClsPlanGrp(t_FmPcd *p_FmPcd, uint8_t hardwarePortId)
     KgWriteCpp(p_FmPcd, hardwarePortId, 0);
 }
 
+#if (defined(DEBUG_ERRORS) && (DEBUG_ERRORS > 0))
 static uint32_t ReadClsPlanBlockActionReg(uint8_t grpId)
 {
     return (uint32_t)(FM_KG_KGAR_GO |
@@ -851,6 +852,7 @@ static uint32_t ReadClsPlanBlockActionReg(uint8_t grpId)
        sel = (uint8_t)(0x01 << (7- (entryId % CLS_PLAN_NUM_PER_GRP)));
      */
 }
+#endif /* (defined(DEBUG_ERRORS) && ... */
 
 static void PcdKgErrorException(t_Handle h_FmPcd)
 {
diff --git a/drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fm_manip.c b/drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fm_manip.c
index e6c8d2d..60f71d7 100644
--- a/drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fm_manip.c
+++ b/drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fm_manip.c
@@ -397,7 +397,7 @@ static t_Error BuildHmct(t_FmPcdManip *p_Manip, t_FmPcdManipParams *p_FmPcdManip
 
                     tmpReg = 0;
                     ASSERT_COND(p_TmpData);
-                    for (i=0; i<FM_PCD_MANIP_DSCP_VALUES; i++)
+                    for (i=0; i<HMCD_DSCP_VALUES; i++)
                     {
                         /* first we build from each 8 values a 32bit register */
                         tmpReg |= (p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.vlan.u.dscpToVpri.dscpToVpriTable[i]) << (32-4*(j+1));
@@ -834,9 +834,11 @@ static t_Error CreateManipActionShadow(t_FmPcdManip *p_Manip, t_FmPcdManipParams
 
 static t_Error CreateManipActionBackToOrig(t_FmPcdManip *p_Manip, t_FmPcdManipParams *p_FmPcdManipParams)
 {
-    uint8_t         *p_WholeHmct, *p_TmpHmctPtr, *p_TmpDataPtr;
+    uint8_t         *p_WholeHmct = NULL, *p_TmpHmctPtr, *p_TmpDataPtr;
     t_FmPcdManip    *p_CurManip = p_Manip;
 
+    UNUSED(p_WholeHmct);
+
     /* Build the new table in the shadow */
     if (!MANIP_IS_UNIFIED(p_Manip))
         BuildHmct(p_Manip, p_FmPcdManipParams, p_Manip->p_Hmct, p_Manip->p_Data, FALSE);
@@ -2187,92 +2189,7 @@ static t_Error UpdateIndxStats(t_Handle     h_FmPcd,
 
     return E_OK;
 }
-#endif /* FM_CAPWAP_SUPPORT */
 
-static t_Error FmPcdManipInitUpdate(t_Handle h_FmPcd,
-                                    t_Handle h_PcdParams,
-                                    t_Handle h_FmPort,
-                                    t_Handle h_Manip,
-                                    t_Handle h_Ad,
-                                    bool     validate,
-                                    int      level,
-                                    t_Handle h_FmTree)
-{
-    t_FmPcdManip *p_Manip = (t_FmPcdManip *)h_Manip;
-    t_Error      err = E_OK;
-
-    SANITY_CHECK_RETURN_ERROR(h_Manip,E_INVALID_HANDLE);
-
-    UNUSED(level);
-    UNUSED(h_FmPcd);
-    UNUSED(h_FmTree);
-
-    switch (p_Manip->opcode)
-    {
-        case (HMAN_OC_MV_INT_FRAME_HDR_FROM_FRM_TO_BUFFER_PREFFIX):
-            err = UpdateInitMvIntFrameHeaderFromFrameToBufferPrefix(h_FmPort, p_Manip, h_Ad, validate);
-            break;
-#ifdef FM_CAPWAP_SUPPORT
-        case (HMAN_OC_INSRT_HDR_BY_TEMPL_N_OR_FRAG_AFTER):
-            if (!p_Manip->h_Frag)
-                break;
-        case (HMAN_OC_CAPWAP_FRAGMENTATION):
-            err = UpdateInitCapwapFragmentation(h_FmPort, p_Manip, h_Ad, validate, h_FmTree);
-            break;
-        case (HMAN_OC_CAPWAP_RMV_DTLS_IF_EXIST):
-            if (p_Manip->h_Frag)
-                err = UpdateInitCapwapReasm(h_FmPcd, h_FmPort, p_Manip, h_Ad, validate);
-            break;
-        case (HMAN_OC_CAPWAP_INDEXED_STATS):
-            err = UpdateIndxStats(h_FmPcd, h_FmPort, p_Manip);
-            break;
-#endif /* FM_CAPWAP_SUPPORT */
-        case (HMAN_OC_IP_REASSEMBLY):
-            err = UpdateInitIpReasm(h_FmPcd, h_PcdParams, h_FmPort, p_Manip, h_Ad, validate);
-            break;
-        default:
-            return E_OK;
-    }
-
-    return err;
-}
-
-static t_Error FmPcdManipModifyUpdate(t_Handle h_Manip, t_Handle h_Ad, bool validate, int level, t_Handle h_FmTree)
-{
-
-    t_FmPcdManip    *p_Manip = (t_FmPcdManip *)h_Manip;
-    t_Error         err = E_OK;
-
-    UNUSED(level);
-
-    switch (p_Manip->opcode)
-    {
-        case (HMAN_OC_MV_INT_FRAME_HDR_FROM_FRM_TO_BUFFER_PREFFIX):
-            RETURN_ERROR(MAJOR, E_INVALID_STATE, ("modify node with this type of manipulation  is not suppported"));
-        case (HMAN_OC_CAPWAP_RMV_DTLS_IF_EXIST):
-
-           if (p_Manip->h_Frag)
-           {
-               if (!(p_Manip->shadowUpdateParams & NUM_OF_TASKS) &&
-                   !(p_Manip->shadowUpdateParams & OFFSET_OF_DATA) &&
-                   !(p_Manip->shadowUpdateParams & OFFSET_OF_PR))
-                    RETURN_ERROR(MAJOR, E_INVALID_STATE, ("modify node with this type of manipulation requires manipulation be updated previously in SetPcd function"));
-           }
-           break;
-#ifdef FM_CAPWAP_SUPPORT
-        case (HMAN_OC_INSRT_HDR_BY_TEMPL_N_OR_FRAG_AFTER):
-            if (p_Manip->h_Frag)
-                err = UpdateModifyCapwapFragmenation(p_Manip, h_Ad, validate, h_FmTree);
-            break;
-#endif /* FM_CAPWAP_SUPPORT */
-        default:
-            return E_OK;
-    }
-
-    return err;
-}
-
-#ifdef FM_CAPWAP_SUPPORT
 static t_Error GetPrOffsetByHeaderOrField(t_FmManipHdrInfo *p_HdrInfo, uint8_t *parseArrayOffset)
 {
     e_NetHeaderType hdr         = p_HdrInfo->hdr;
@@ -2867,6 +2784,9 @@ static t_Error IpReassemblyStats(t_FmPcdManip *p_Manip, t_FmPcdManipReassemIpSta
     p_Stats->externalBufferBusy     = GET_UINT32(p_Manip->ipReassmParams.p_IpReassCommonTbl->totalExternalBufferBusy);
     p_Stats->sgFragments            = GET_UINT32(p_Manip->ipReassmParams.p_IpReassCommonTbl->totalSgFragmentCounter);
     p_Stats->dmaSemaphoreDepletion  = GET_UINT32(p_Manip->ipReassmParams.p_IpReassCommonTbl->totalDmaSemaphoreDepletionCounter);
+#if (DPAA_VERSION >= 11)
+    p_Stats->nonConsistentSp        = GET_UINT32(p_Manip->ipReassmParams.p_IpReassCommonTbl->totalNCSPCounter);
+#endif /* (DPAA_VERSION >= 11) */
 
     if (p_Manip->ipReassmParams.p_Ipv4ReassTbl)
     {
@@ -3241,6 +3161,38 @@ static t_Error IPManip(t_FmPcdManip *p_Manip)
     return err;
 }
 
+static t_Error UpdateInitIpFrag(t_Handle       h_FmPcd,
+                                t_Handle       h_PcdParams,
+                                t_Handle       h_FmPort,
+                                t_FmPcdManip   *p_Manip,
+                                t_Handle       h_Ad,
+                                bool           validate)
+{
+    t_FmPortGetSetCcParams      fmPortGetSetCcParams;
+    t_Error                     err;
+
+    SANITY_CHECK_RETURN_ERROR(p_Manip, E_INVALID_HANDLE);
+    SANITY_CHECK_RETURN_ERROR((p_Manip->opcode == HMAN_OC_IP_FRAGMENTATION), E_INVALID_STATE);
+    SANITY_CHECK_RETURN_ERROR(h_FmPcd, E_INVALID_HANDLE);
+    SANITY_CHECK_RETURN_ERROR(h_FmPort, E_INVALID_HANDLE);
+
+    UNUSED(h_FmPcd);
+    UNUSED(h_Ad);
+    UNUSED(h_PcdParams);
+    UNUSED(validate);
+    UNUSED(p_Manip);
+ 
+    fmPortGetSetCcParams.setCcParams.type = 0;
+    fmPortGetSetCcParams.getCcParams.type = MANIP_EXTRA_SPACE;
+    if ((err = FmPortGetSetCcParams(h_FmPort, &fmPortGetSetCcParams)) != E_OK)
+        RETURN_ERROR(MAJOR, err, NO_MSG);
+ 
+    if (!fmPortGetSetCcParams.getCcParams.internalBufferOffset)
+        DBG(WARNING, ("manipExtraSpace must be larger than '0'"));
+ 
+    return E_OK;
+}
+
 static t_Error IPSecManip(t_FmPcdManipParams    *p_ManipParams,
                           t_FmPcdManip          *p_Manip)
 {
@@ -3439,6 +3391,92 @@ static void BuildHmtd(uint8_t *p_Dest, uint8_t *p_Src, uint8_t *p_Hmcd, t_FmPcd
         REPORT_ERROR(MINOR, err, ("Failed in dynamic manip change, continued to the rest of the owners."));
 }
 
+static t_Error FmPcdManipInitUpdate(t_Handle h_FmPcd,
+                                    t_Handle h_PcdParams,
+                                    t_Handle h_FmPort,
+                                    t_Handle h_Manip,
+                                    t_Handle h_Ad,
+                                    bool     validate,
+                                    int      level,
+                                    t_Handle h_FmTree)
+{
+    t_FmPcdManip *p_Manip = (t_FmPcdManip *)h_Manip;
+    t_Error      err = E_OK;
+
+    SANITY_CHECK_RETURN_ERROR(h_Manip,E_INVALID_HANDLE);
+
+    UNUSED(level);
+    UNUSED(h_FmPcd);
+    UNUSED(h_FmTree);
+
+    switch (p_Manip->opcode)
+    {
+        case (HMAN_OC_MV_INT_FRAME_HDR_FROM_FRM_TO_BUFFER_PREFFIX):
+            err = UpdateInitMvIntFrameHeaderFromFrameToBufferPrefix(h_FmPort, p_Manip, h_Ad, validate);
+            break;
+#ifdef FM_CAPWAP_SUPPORT
+        case (HMAN_OC_INSRT_HDR_BY_TEMPL_N_OR_FRAG_AFTER):
+            if (!p_Manip->h_Frag)
+                break;
+        case (HMAN_OC_CAPWAP_FRAGMENTATION):
+            err = UpdateInitCapwapFragmentation(h_FmPort, p_Manip, h_Ad, validate, h_FmTree);
+            break;
+        case (HMAN_OC_CAPWAP_RMV_DTLS_IF_EXIST):
+            if (p_Manip->h_Frag)
+                err = UpdateInitCapwapReasm(h_FmPcd, h_FmPort, p_Manip, h_Ad, validate);
+            break;
+        case (HMAN_OC_CAPWAP_INDEXED_STATS):
+            err = UpdateIndxStats(h_FmPcd, h_FmPort, p_Manip);
+            break;
+#endif /* FM_CAPWAP_SUPPORT */
+        case (HMAN_OC_IP_REASSEMBLY):
+            err = UpdateInitIpReasm(h_FmPcd, h_PcdParams, h_FmPort, p_Manip, h_Ad, validate);
+            break;
+        case (HMAN_OC_IP_FRAGMENTATION):
+            err = UpdateInitIpFrag(h_FmPcd, h_PcdParams, h_FmPort, p_Manip, h_Ad, validate);
+            break;
+        default:
+            return E_OK;
+    }
+
+    return err;
+}
+
+static t_Error FmPcdManipModifyUpdate(t_Handle h_Manip, t_Handle h_Ad, bool validate, int level, t_Handle h_FmTree)
+{
+
+    t_FmPcdManip    *p_Manip = (t_FmPcdManip *)h_Manip;
+    t_Error         err = E_OK;
+
+    UNUSED(level);
+
+    switch (p_Manip->opcode)
+    {
+        case (HMAN_OC_MV_INT_FRAME_HDR_FROM_FRM_TO_BUFFER_PREFFIX):
+            RETURN_ERROR(MAJOR, E_INVALID_STATE, ("modify node with this type of manipulation  is not suppported"));
+        case (HMAN_OC_CAPWAP_RMV_DTLS_IF_EXIST):
+
+           if (p_Manip->h_Frag)
+           {
+               if (!(p_Manip->shadowUpdateParams & NUM_OF_TASKS) &&
+                   !(p_Manip->shadowUpdateParams & OFFSET_OF_DATA) &&
+                   !(p_Manip->shadowUpdateParams & OFFSET_OF_PR))
+                    RETURN_ERROR(MAJOR, E_INVALID_STATE, ("modify node with this type of manipulation requires manipulation be updated previously in SetPcd function"));
+           }
+           break;
+#ifdef FM_CAPWAP_SUPPORT
+        case (HMAN_OC_INSRT_HDR_BY_TEMPL_N_OR_FRAG_AFTER):
+            if (p_Manip->h_Frag)
+                err = UpdateModifyCapwapFragmenation(p_Manip, h_Ad, validate, h_FmTree);
+            break;
+#endif /* FM_CAPWAP_SUPPORT */
+        default:
+            return E_OK;
+    }
+
+    return err;
+}
+
 /*****************************************************************************/
 /*              Inter-module API routines                                    */
 /*****************************************************************************/
@@ -3550,19 +3588,6 @@ t_Error FmPcdManipCheckParamsForCcNextEngine(t_FmPcdCcNextEngineParams *p_FmPcdC
                 *requiredAction = UPDATE_NIA_ENQ_WITHOUT_DMA;
                 break;
             case (HMAN_OC_IP_FRAGMENTATION):
-#if (DPAA_VERSION == 10)
-                if (!(p_FmPcdCcNextEngineParams->nextEngine == e_FM_PCD_DONE))
-                        RETURN_ERROR(MAJOR, E_INVALID_STATE,
-                                     ("For this type of header manipulation has to be nextEngine e_FM_PCD_DONE"));
-#else
-                if (!((p_FmPcdCcNextEngineParams->nextEngine == e_FM_PCD_DONE) ||
-                      (p_FmPcdCcNextEngineParams->nextEngine == e_FM_PCD_PLCR)))
-                    RETURN_ERROR(MAJOR, E_INVALID_STATE,
-                                 ("For this type of header manipulation has to be nextEngine "
-                                  "e_FM_PCD_DONE or e_FM_PCD_PLCR"));
-#endif /* (DPAA_VERSION == 10) */
-                p_Manip->ownerTmp++;
-                break;
             case (HMAN_OC_IP_REASSEMBLY):
                 if (p_FmPcdCcNextEngineParams->nextEngine != e_FM_PCD_DONE)
                     RETURN_ERROR(MAJOR, E_INVALID_STATE, ("For this type of header manipulation has to be nextEngine e_FM_PCD_DONE"));
diff --git a/drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fm_manip.h b/drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fm_manip.h
index 390ca6e..2ab9b15 100644
--- a/drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fm_manip.h
+++ b/drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fm_manip.h
@@ -332,7 +332,8 @@ typedef _Packed struct t_IpReassCommonTbl {
     volatile uint32_t totalExternalBufferBusy;
     volatile uint32_t totalSgFragmentCounter;
     volatile uint32_t totalDmaSemaphoreDepletionCounter;
-    volatile uint32_t reserved3[2];
+    volatile uint32_t totalNCSPCounter;
+    volatile uint32_t reserved3[1];
 } _PackedType t_IpReassCommonTbl;
 
 typedef _Packed struct t_Hmtd {
diff --git a/drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fm_pcd.c b/drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fm_pcd.c
index 747347c..6bde6a0 100644
--- a/drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fm_pcd.c
+++ b/drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fm_pcd.c
@@ -756,10 +756,17 @@ void FmPcdLockUnlockAll(t_Handle h_FmPcd)
     CORE_MemoryBarrier();
 }
 
+t_Error FmPcdHcSync(t_Handle h_FmPcd)
+{
+    ASSERT_COND(h_FmPcd);
+    ASSERT_COND(((t_FmPcd*)h_FmPcd)->h_Hc);
+
+    return FmHcPcdSync(((t_FmPcd*)h_FmPcd)->h_Hc);
+}
+
 t_Handle FmPcdGetHcHandle(t_Handle h_FmPcd)
 {
     ASSERT_COND(h_FmPcd);
-    SANITY_CHECK_RETURN_VALUE(((t_FmPcd*)h_FmPcd)->h_Hc, E_INVALID_HANDLE, NULL);
     return ((t_FmPcd*)h_FmPcd)->h_Hc;
 }
 
@@ -895,13 +902,6 @@ t_Handle FM_PCD_Config(t_FmPcdParams *p_FmPcdParams)
     return p_FmPcd;
 }
 
-t_Handle FM_PCD_GetHcDevH(t_Handle h_FmPcd)
-{
-    t_FmPcd        *p_FmPcd = (t_FmPcd *) h_FmPcd;
-
-    return (p_FmPcd) ? FmGcGetHcPortDevH(p_FmPcd->h_Hc) : NULL;
-}
-
 t_Error FM_PCD_Init(t_Handle h_FmPcd)
 {
     t_FmPcd         *p_FmPcd = (t_FmPcd*)h_FmPcd;
@@ -1228,7 +1228,7 @@ t_Handle FM_PCD_NetEnvCharacteristicsSet(t_Handle h_FmPcd, t_FmPcdNetEnvParams
     uint8_t                 ipsecAhUnit = 0,ipsecEspUnit = 0;
     bool                    ipsecAhExists = FALSE, ipsecEspExists = FALSE, shim1Selected = FALSE;
     uint8_t                 hdrNum;
-    t_FmPcdNetEnvParams     *p_modifiedNetEnvParams;
+    t_FmPcdNetEnvParams     *p_ModifiedNetEnvParams;
 
     SANITY_CHECK_RETURN_VALUE(h_FmPcd, E_INVALID_STATE, NULL);
     SANITY_CHECK_RETURN_VALUE(!p_FmPcd->p_FmPcdDriverParam, E_INVALID_STATE, NULL);
@@ -1254,15 +1254,15 @@ t_Handle FM_PCD_NetEnvCharacteristicsSet(t_Handle h_FmPcd, t_FmPcdNetEnvParams
     /* As anyone doesn't have handle of this netEnv yet, no need
        to protect it with spinlocks */
 
-    p_modifiedNetEnvParams = (t_FmPcdNetEnvParams *) XX_Malloc(sizeof(t_FmPcdNetEnvParams));
-    if (!p_modifiedNetEnvParams)
+    p_ModifiedNetEnvParams = (t_FmPcdNetEnvParams *)XX_Malloc(sizeof(t_FmPcdNetEnvParams));
+    if (!p_ModifiedNetEnvParams)
     {
         REPORT_ERROR(MAJOR, E_NO_MEMORY, ("FmPcdNetEnvParams"));
         return NULL;
     }
 
-    memcpy(p_modifiedNetEnvParams, p_NetEnvParams, sizeof(t_FmPcdNetEnvParams));
-    p_NetEnvParams = p_modifiedNetEnvParams;
+    memcpy(p_ModifiedNetEnvParams, p_NetEnvParams, sizeof(t_FmPcdNetEnvParams));
+    p_NetEnvParams = p_ModifiedNetEnvParams;
 
     netEnvCurrId = (uint8_t)i;
 
@@ -1295,7 +1295,7 @@ t_Handle FM_PCD_NetEnvCharacteristicsSet(t_Handle h_FmPcd, t_FmPcdNetEnvParams
                     {
                         REPORT_ERROR(MINOR, E_FULL,
                                 ("Illegal unit - header with opt may not be interchangeable with the same header without opt"));
-                        XX_Free(p_modifiedNetEnvParams);
+                        XX_Free(p_ModifiedNetEnvParams);
                         return NULL;
                     }
                 }
@@ -1319,7 +1319,7 @@ t_Handle FM_PCD_NetEnvCharacteristicsSet(t_Handle h_FmPcd, t_FmPcdNetEnvParams
                 if (ipsecEspExists && (ipsecEspUnit != i))
                 {
                     REPORT_ERROR(MINOR, E_INVALID_STATE, ("HEADER_TYPE_IPSEC_AH and HEADER_TYPE_IPSEC_ESP may not be defined in separate units"));
-                    XX_Free(p_modifiedNetEnvParams);
+                    XX_Free(p_ModifiedNetEnvParams);
                     return NULL;
                 }
                 else
@@ -1333,7 +1333,7 @@ t_Handle FM_PCD_NetEnvCharacteristicsSet(t_Handle h_FmPcd, t_FmPcdNetEnvParams
                 if (ipsecAhExists && (ipsecAhUnit != i))
                 {
                     REPORT_ERROR(MINOR, E_INVALID_STATE, ("HEADER_TYPE_IPSEC_AH and HEADER_TYPE_IPSEC_ESP may not be defined in separate units"));
-                    XX_Free(p_modifiedNetEnvParams);
+                    XX_Free(p_ModifiedNetEnvParams);
                     return NULL;
                 }
                 else
@@ -1415,7 +1415,7 @@ t_Handle FM_PCD_NetEnvCharacteristicsSet(t_Handle h_FmPcd, t_FmPcdNetEnvParams
             if (p_FmPcd->netEnvs[netEnvCurrId].units[i].hdrs[1].hdr != HEADER_TYPE_NONE)
             {
                 REPORT_ERROR(MAJOR, E_NOT_SUPPORTED, ("SHIM header may not be interchanged with other headers"));
-                XX_Free(p_modifiedNetEnvParams);
+                XX_Free(p_ModifiedNetEnvParams);
                 return NULL;
             }
     }
@@ -1429,12 +1429,12 @@ t_Handle FM_PCD_NetEnvCharacteristicsSet(t_Handle h_FmPcd, t_FmPcdNetEnvParams
                     if (shim1Selected)
                     {
                         REPORT_ERROR(MAJOR, E_NOT_SUPPORTED, ("SHIM header cannot be selected with UDP_IPSEC_ESP"));
-                        XX_Free(p_modifiedNetEnvParams);
+                        XX_Free(p_ModifiedNetEnvParams);
                         return NULL;
                     }
                     shim1Selected = TRUE;
                     p_FmPcd->netEnvs[netEnvCurrId].unitsVectors[i] = 0x00000001;
-                break;
+                    break;
                 case (HEADER_TYPE_USER_DEFINED_SHIM2):
                     p_FmPcd->netEnvs[netEnvCurrId].unitsVectors[i] = 0x00000002;
                     break;
@@ -1466,14 +1466,14 @@ t_Handle FM_PCD_NetEnvCharacteristicsSet(t_Handle h_FmPcd, t_FmPcdNetEnvParams
                 if ((hdrNum == ILLEGAL_HDR_NUM) || (hdrNum == NO_HDR_NUM))
                 {
                     REPORT_ERROR(MAJOR, E_NOT_SUPPORTED, NO_MSG);
-                    XX_Free(p_modifiedNetEnvParams);
+                    XX_Free(p_ModifiedNetEnvParams);
                     return NULL;
                 }
                 p_FmPcd->netEnvs[netEnvCurrId].lcvs[hdrNum] |= p_FmPcd->netEnvs[netEnvCurrId].unitsVectors[i];
             }
         }
     }
-    XX_Free(p_modifiedNetEnvParams);
+    XX_Free(p_ModifiedNetEnvParams);
 
     p_FmPcd->netEnvs[netEnvCurrId].h_Spinlock = XX_InitSpinlock();
     if (!p_FmPcd->netEnvs[netEnvCurrId].h_Spinlock)
@@ -1542,7 +1542,10 @@ t_Error FM_PCD_SetAdvancedOffloadSupport(t_Handle h_FmPcd)
         revInfo.packageRev = IP_OFFLOAD_PACKAGE_NUMBER;
     }
     if (revInfo.packageRev != IP_OFFLOAD_PACKAGE_NUMBER)
-        RETURN_ERROR(MINOR, E_NOT_SUPPORTED, ("Fman ctrl code package"));
+        RETURN_ERROR(MAJOR, E_NOT_SUPPORTED, ("Fman ctrl code package"));
+
+    if (!p_FmPcd->h_Hc)
+        RETURN_ERROR(MAJOR, E_INVALID_HANDLE, ("HC must be initialized in this mode"));
 
     p_FmPcd->advancedOffloadSupport = TRUE;