fmd: fix static analysis issues

Change-Id: I2d6cead7b62116cd6a264ec91d82f3bdc3a03c10
Signed-off-by: Mandy Lavi <mandy.lavi@freescale.com>
Reviewed-on: http://git.am.freescale.net:8181/23939
Reviewed-by: Igal Liberman <Igal.Liberman@freescale.com>
Tested-by: Richard Schmitt <richard.schmitt@freescale.com>
Reviewed-by: Richard Schmitt <richard.schmitt@freescale.com>

12 files changed, 243 insertions, 289 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 52a3314..fc42642 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
@@ -590,7 +590,7 @@ static t_Error SetRequiredAction(
 
 static t_Error ReleaseModifiedDataStructure(
         t_Handle h_FmPcd, t_List *h_FmPcdOldPointersLst,
-        t_List *h_FmPcdNewPointersLst, uint16_t numOfGoodChanges,
+        t_List *h_FmPcdNewPointersLst,
         t_FmPcdModifyCcKeyAdditionalParams *p_AdditionalParams,
         bool useShadowStructs)
 {
@@ -602,8 +602,6 @@ static t_Error ReleaseModifiedDataStructure(
     t_List *p_UpdateLst;
     uint32_t intFlags;
 
-    UNUSED(numOfGoodChanges);
-
     SANITY_CHECK_RETURN_ERROR(h_FmPcd, E_INVALID_HANDLE);
     SANITY_CHECK_RETURN_ERROR(p_AdditionalParams->h_CurrentNode,
                               E_INVALID_HANDLE);
@@ -872,6 +870,7 @@ static t_Handle BuildNewAd(
                     != E_OK)
             {
                 REPORT_ERROR(MAJOR, E_INVALID_STATE, NO_MSG);
+                XX_Free(p_FmPcdCcNodeTmp);
                 return NULL;
             }
         }
@@ -923,7 +922,7 @@ static t_Error DynamicChangeHc(
         if (newAdAddrOffset == (uint32_t)ILLEGAL_BASE)
         {
             ReleaseModifiedDataStructure(h_FmPcd, h_OldPointersLst,
-                                         h_NewPointersLst, 0,
+                                         h_NewPointersLst,
                                          p_AdditionalParams, useShadowStructs);
             RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("New AD address"));
         }
@@ -936,7 +935,7 @@ static t_Error DynamicChangeHc(
             if (oldAdAddrOffset == (uint32_t)ILLEGAL_BASE)
             {
                 ReleaseModifiedDataStructure(h_FmPcd, h_OldPointersLst,
-                                             h_NewPointersLst, i,
+                                             h_NewPointersLst,
                                              p_AdditionalParams,
                                              useShadowStructs);
                 RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("Old AD address"));
@@ -948,7 +947,7 @@ static t_Error DynamicChangeHc(
             if (err)
             {
                 ReleaseModifiedDataStructure(h_FmPcd, h_OldPointersLst,
-                                             h_NewPointersLst, i,
+                                             h_NewPointersLst,
                                              p_AdditionalParams,
                                              useShadowStructs);
                 RETURN_ERROR(
@@ -994,49 +993,50 @@ static t_Error DoDynamicChange(
                               p_AdditionalParams, useShadowStructs);
         if (err)
             RETURN_ERROR(MAJOR, err, NO_MSG);
-    }
-    if (useShadowStructs)
-    {
-        /* When the host-command above has ended, the old structures are 'free'and we can update
-         them by copying from the new shadow structures. */
-        if (p_CcNode->lclMask)
-            keySize = (uint32_t)(2 * p_CcNode->ccKeySizeAccExtraction);
-        else
-            keySize = p_CcNode->ccKeySizeAccExtraction;
 
-        IO2IOCpy32(p_AdditionalParams->p_KeysMatchTableOld,
-                   p_AdditionalParams->p_KeysMatchTableNew,
-                   p_CcNode->maxNumOfKeys * keySize * sizeof(uint8_t));
+		if (useShadowStructs)
+		{
+			/* When the host-command above has ended, the old structures are 'free'and we can update
+			 them by copying from the new shadow structures. */
+			if (p_CcNode->lclMask)
+				keySize = (uint32_t)(2 * p_CcNode->ccKeySizeAccExtraction);
+			else
+				keySize = p_CcNode->ccKeySizeAccExtraction;
 
-        IO2IOCpy32(
-                p_AdditionalParams->p_AdTableOld,
-                p_AdditionalParams->p_AdTableNew,
-                (uint32_t)((p_CcNode->maxNumOfKeys + 1)
-                        * FM_PCD_CC_AD_ENTRY_SIZE));
+			IO2IOCpy32(p_AdditionalParams->p_KeysMatchTableOld,
+					   p_AdditionalParams->p_KeysMatchTableNew,
+					   p_CcNode->maxNumOfKeys * keySize * sizeof(uint8_t));
 
-        /* Retrieve the address of the allocated Ad */
-        p_CcNodeInfo = CC_NODE_F_OBJECT(p_PosNew);
-        h_Ad = p_CcNodeInfo->h_CcNode;
+			IO2IOCpy32(
+					p_AdditionalParams->p_AdTableOld,
+					p_AdditionalParams->p_AdTableNew,
+					(uint32_t)((p_CcNode->maxNumOfKeys + 1)
+							* FM_PCD_CC_AD_ENTRY_SIZE));
 
-        /* Build a new Ad that holds the old (now updated) structures */
-        p_AdditionalParams->p_KeysMatchTableNew =
-                p_AdditionalParams->p_KeysMatchTableOld;
-        p_AdditionalParams->p_AdTableNew = p_AdditionalParams->p_AdTableOld;
+			/* Retrieve the address of the allocated Ad */
+			p_CcNodeInfo = CC_NODE_F_OBJECT(p_PosNew);
+			h_Ad = p_CcNodeInfo->h_CcNode;
 
-        nextEngineParams.nextEngine = e_FM_PCD_CC;
-        nextEngineParams.params.ccParams.h_CcNode = (t_Handle)p_CcNode;
+			/* Build a new Ad that holds the old (now updated) structures */
+			p_AdditionalParams->p_KeysMatchTableNew =
+					p_AdditionalParams->p_KeysMatchTableOld;
+			p_AdditionalParams->p_AdTableNew = p_AdditionalParams->p_AdTableOld;
 
-        BuildNewAd(h_Ad, p_AdditionalParams, p_CcNode, &nextEngineParams);
+			nextEngineParams.nextEngine = e_FM_PCD_CC;
+			nextEngineParams.params.ccParams.h_CcNode = (t_Handle)p_CcNode;
 
-        /* HC to copy from the new Ad (old updated structures) to current Ad (uses shadow structures) */
-        err = DynamicChangeHc(h_FmPcd, h_OldPointersLst, h_NewPointersLst,
-                              p_AdditionalParams, useShadowStructs);
-        if (err)
-            RETURN_ERROR(MAJOR, err, NO_MSG);
+			BuildNewAd(h_Ad, p_AdditionalParams, p_CcNode, &nextEngineParams);
+
+			/* HC to copy from the new Ad (old updated structures) to current Ad (uses shadow structures) */
+			err = DynamicChangeHc(h_FmPcd, h_OldPointersLst, h_NewPointersLst,
+								  p_AdditionalParams, useShadowStructs);
+			if (err)
+				RETURN_ERROR(MAJOR, err, NO_MSG);
+		}
     }
 
     err = ReleaseModifiedDataStructure(h_FmPcd, h_OldPointersLst,
-                                       h_NewPointersLst, numOfModifiedPtr,
+                                       h_NewPointersLst,
                                        p_AdditionalParams, useShadowStructs);
     if (err)
         RETURN_ERROR(MAJOR, err, NO_MSG);
@@ -1361,10 +1361,9 @@ static void GetCcExtractKeySize(uint8_t parseCodeRealSize,
                                             *parseCodeCcSize = 0;
 }
 
-static void GetSizeHeaderField(e_NetHeaderType hdr, e_FmPcdHdrIndex index,
-                               t_FmPcdFields field, uint8_t *parseCodeRealSize)
+static void GetSizeHeaderField(e_NetHeaderType hdr, t_FmPcdFields field,
+		                       uint8_t *parseCodeRealSize)
 {
-    UNUSED(index);
     switch (hdr)
     {
         case (HEADER_TYPE_ETH):
@@ -1691,13 +1690,11 @@ t_Error ValidateNextEngineParams(
     return err;
 }
 
-static uint8_t GetGenParseCode(t_Handle h_FmPcd, e_FmPcdExtractFrom src,
+static uint8_t GetGenParseCode(e_FmPcdExtractFrom src,
                                uint32_t offset, bool glblMask,
                                uint8_t *parseArrayOffset, bool fromIc,
                                ccPrivateInfo_t icCode)
 {
-    UNUSED(h_FmPcd);
-
     if (!fromIc)
     {
         switch (src)
@@ -2122,6 +2119,7 @@ static uint8_t GetFieldParseCode(e_NetHeaderType hdr, t_FmPcdFields field,
     {
         case (HEADER_TYPE_NONE):
             ASSERT_COND(FALSE);
+                break;
         case (HEADER_TYPE_ETH):
             switch (field.eth)
             {
@@ -2278,7 +2276,6 @@ static void FillAdOfTypeResult(t_Handle h_Ad,
                 break;
 
             case (e_FM_PCD_PLCR):
-                tmp = 0;
                 if (p_CcNextEngineParams->params.plcrParams.overrideParams)
                 {
                     tmp = FM_PCD_AD_RESULT_CONTRL_FLOW_TYPE;
@@ -2746,7 +2743,7 @@ static t_Error BuildNewNodeAddOrMdfyKeyAndNextEngine(
                 {
                     p_KeysMatchTableOldTmp =
                             PTR_MOVE(p_CcNode->h_KeysMatchTable,
-                                    i * p_CcNode->ccKeySizeAccExtraction*sizeof(uint8_t));
+                                    i * (int)p_CcNode->ccKeySizeAccExtraction * sizeof(uint8_t));
 
                     if (p_CcNode->ccKeySizeAccExtraction > 4)
                     {
@@ -2881,11 +2878,8 @@ static t_Error BuildNewNodeRemoveKey(
     for (i = 0, j = 0; j < p_CcNode->numOfKeys; i++, j++)
     {
         if (j == keyIndex)
-        {
-            p_AdTableOldTmp =
-                    PTR_MOVE(p_AdditionalInfo->p_AdTableOld, j * FM_PCD_CC_AD_ENTRY_SIZE);
             j++;
-        }
+
         if (j == p_CcNode->numOfKeys)
             break;
         p_AdTableNewTmp =
@@ -3061,7 +3055,8 @@ static t_Error BuildNewNodeModifyKey(
                 else
                 {
                     p_KeysMatchTableOldTmp =
-                            PTR_MOVE(p_CcNode->h_KeysMatchTable, i * p_CcNode->ccKeySizeAccExtraction * sizeof(uint8_t));
+                            PTR_MOVE(p_CcNode->h_KeysMatchTable,
+                                     i * (int)p_CcNode->ccKeySizeAccExtraction * sizeof(uint8_t));
 
                     if (p_CcNode->ccKeySizeAccExtraction > 4)
                         IOMemSet32(PTR_MOVE(p_KeysMatchTableNewTmp,
@@ -3534,9 +3529,6 @@ static t_FmPcdModifyCcKeyAdditionalParams * ModifyNodeCommonPart(
     {
         if (modifyState == e_MODIFY_STATE_ADD)
             j++;
-        else
-            if (modifyState == e_MODIFY_STATE_REMOVE)
-                i++;
     }
 
     memcpy(&p_FmPcdModifyCcKeyAdditionalParams->keyAndNextEngineParams[j],
@@ -3569,7 +3561,6 @@ static t_Error UpdatePtrWhichPointOnCrntMdfNode(
     /* This node must be found as next engine of one of its previous nodes or trees*/
     if (p_NextEngineParams)
     {
-
         /* Building a new action descriptor that points to the modified node */
         h_NewAd = GetNewAd(p_CcNode, FALSE);
         if (!h_NewAd)
@@ -4213,7 +4204,7 @@ static t_Error CalcAndUpdateCcShadow(t_FmPcdCcNode *p_CcNode,
     if (err != E_OK)
     {
         DeleteNode(p_CcNode);
-        REPORT_ERROR(MAJOR, E_NO_MEMORY, ("MURAM allocation for CC node shadow"));
+        RETURN_ERROR(MAJOR, E_NO_MEMORY, ("MURAM allocation for CC node shadow"));
     }
 
     return E_OK;
@@ -4463,7 +4454,6 @@ static t_Error MatchTableSet(t_Handle h_FmPcd, t_FmPcdCcNode *p_CcNode,
                                     p_CcNodeParam->extractCcParams.extractByHdr.extractByHdrType.fullField);
                     GetSizeHeaderField(
                             p_CcNodeParam->extractCcParams.extractByHdr.hdr,
-                            p_CcNodeParam->extractCcParams.extractByHdr.hdrIndex,
                             p_CcNodeParam->extractCcParams.extractByHdr.extractByHdrType.fullField,
                             &p_CcNode->sizeOfExtraction);
                     fullField = TRUE;
@@ -4532,7 +4522,7 @@ static t_Error MatchTableSet(t_Handle h_FmPcd, t_FmPcdCcNode *p_CcNode,
             p_CcNode->userOffset =
                     p_CcNodeParam->extractCcParams.extractNonHdr.offset;
             p_CcNode->parseCode = GetGenParseCode(
-                    h_FmPcd, p_CcNodeParam->extractCcParams.extractNonHdr.src,
+                    p_CcNodeParam->extractCcParams.extractNonHdr.src,
                     p_CcNode->offset, glblMask, &p_CcNode->prsArrayOffset,
                     fromIc, icCode);
 
@@ -5346,12 +5336,6 @@ t_Error FmPcdCcRemoveKey(t_Handle h_FmPcd, t_Handle h_FmPcdCcNode,
         RETURN_ERROR(MAJOR, E_INVALID_VALUE,
                      ("impossible to remove key when numOfKeys <= keyIndex"));
 
-    if (!p_CcNode->numOfKeys)
-        RETURN_ERROR(
-                MAJOR,
-                E_INVALID_VALUE,
-                ("keyIndex you asked > numOfKeys of relevant node that was initialized"));
-
     if (p_CcNode->h_FmPcd != h_FmPcd)
         RETURN_ERROR(
                 MAJOR,
@@ -5831,10 +5815,6 @@ t_Error FmPcdCcNodeTreeTryLock(t_Handle h_FmPcd, t_Handle h_FmPcdCcNode,
 
     intFlags = FmPcdLock(h_FmPcd);
 
- //   if (LIST_IsEmpty(&p_CcNode->ccTreesLst))
-   //     RETURN_ERROR(MAJOR, E_NOT_AVAILABLE,
-  //                   ("asked for more nodes in CC than MAX"));
-
     LIST_FOR_EACH(p_Pos, &p_CcNode->ccTreesLst)
     {
         p_CcNodeInfo = CC_NODE_F_OBJECT(p_Pos);
@@ -6193,7 +6173,6 @@ t_Handle FM_PCD_CcRootBuild(t_Handle h_FmPcd,
 
     p_CcTreeTmp = UINT_TO_PTR(p_FmPcdCcTree->ccTreeBaseAddr);
 
-    j = 0;
     for (i = 0; i < numOfEntries; i++)
     {
         p_KeyAndNextEngineParams = p_Params + i;
@@ -6421,15 +6400,11 @@ t_Handle FM_PCD_MatchTableSet(t_Handle h_FmPcd,
 
 t_Error FM_PCD_MatchTableDelete(t_Handle h_CcNode)
 {
-    t_FmPcd *p_FmPcd;
     t_FmPcdCcNode *p_CcNode = (t_FmPcdCcNode *)h_CcNode;
     int i = 0;
 
     SANITY_CHECK_RETURN_ERROR(p_CcNode, E_INVALID_HANDLE);
-    p_FmPcd = (t_FmPcd *)p_CcNode->h_FmPcd;
-    SANITY_CHECK_RETURN_ERROR(p_FmPcd, E_INVALID_HANDLE);
-
-    UNUSED(p_FmPcd);
+    SANITY_CHECK_RETURN_ERROR(p_CcNode->h_FmPcd, E_INVALID_HANDLE);
 
     if (p_CcNode->owners)
         RETURN_ERROR(
@@ -7200,6 +7175,8 @@ t_Handle FM_PCD_HashTableSet(t_Handle h_FmPcd, t_FmPcdHashTableParams *p_Param)
         if (!h_MissStatsCounters)
         {
             REPORT_ERROR(MAJOR, E_NO_MEMORY, ("MURAM allocation for statistics table for hash miss"));
+            XX_Free(p_IndxHashCcNodeParam);
+            XX_Free(p_ExactMatchCcNodeParam);
             return NULL;
         }
         memset(h_MissStatsCounters, 0, (2 * FM_PCD_CC_STATS_COUNTER_SIZE));
@@ -7285,7 +7262,8 @@ t_Handle FM_PCD_HashTableSet(t_Handle h_FmPcd, t_FmPcdHashTableParams *p_Param)
     p_IndxHashCcNodeParam->keysParams.maskSupport = FALSE;
     p_IndxHashCcNodeParam->keysParams.statisticsMode =
             e_FM_PCD_CC_STATS_MODE_NONE;
-    p_IndxHashCcNodeParam->keysParams.numOfKeys = numOfSets; /* Number of keys of this node is number of sets of the hash */
+    /* Number of keys of this node is number of sets of the hash */
+    p_IndxHashCcNodeParam->keysParams.numOfKeys = numOfSets;
     p_IndxHashCcNodeParam->keysParams.keySize = 2;
 
     p_CcNodeHashTbl = FM_PCD_MatchTableSet(h_FmPcd, p_IndxHashCcNodeParam);
@@ -7295,7 +7273,7 @@ t_Handle FM_PCD_HashTableSet(t_Handle h_FmPcd, t_FmPcdHashTableParams *p_Param)
         p_CcNodeHashTbl->kgHashShift = p_Param->kgHashShift;
 
         /* Storing the allocated counters for buckets 'miss' in the hash table
-         and is statistics for miss wre enabled. */
+         and if statistics for miss were enabled. */
         p_CcNodeHashTbl->h_MissStatsCounters = h_MissStatsCounters;
         p_CcNodeHashTbl->statsEnForMiss = statsEnForMiss;
     }
@@ -7337,14 +7315,14 @@ t_Error FM_PCD_HashTableDelete(t_Handle h_HashTbl)
     for (i = 0; i < numOfBuckets; i++)
         err |= FM_PCD_MatchTableDelete(p_HashBuckets[i]);
 
-    if (err)
-        RETURN_ERROR(MAJOR, err, NO_MSG);
+    XX_Free(p_HashBuckets);
 
-    /* Free statistics counters for 'miss', id these were allocated */
+    /* Free statistics counters for 'miss', if these were allocated */
     if (h_MissStatsCounters)
         FM_MURAM_FreeMem(FmPcdGetMuramHandle(h_FmPcd), h_MissStatsCounters);
 
-    XX_Free(p_HashBuckets);
+    if (err)
+        RETURN_ERROR(MAJOR, err, NO_MSG);
 
     return E_OK;
 }
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 ceb8e1d..3bc7585 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
@@ -190,35 +190,35 @@ typedef uint32_t ccPrivateInfo_t; /**< private info of CC: */
 #pragma pack(push,1)
 #endif /* defined(__MWERKS__) && ... */
 
-typedef _Packed struct
+typedef struct
 {
     volatile uint32_t fqid;
     volatile uint32_t plcrProfile;
     volatile uint32_t nia;
     volatile uint32_t res;
-} _PackedType t_AdOfTypeResult;
+} t_AdOfTypeResult;
 
-typedef _Packed struct
+typedef struct
 {
     volatile uint32_t ccAdBase;
     volatile uint32_t matchTblPtr;
     volatile uint32_t pcAndOffsets;
     volatile uint32_t gmask;
-} _PackedType t_AdOfTypeContLookup;
+} t_AdOfTypeContLookup;
 
-typedef _Packed struct
+typedef struct
 {
     volatile uint32_t profileTableAddr;
     volatile uint32_t reserved;
     volatile uint32_t nextActionIndx;
     volatile uint32_t statsTableAddr;
-} _PackedType t_AdOfTypeStats;
+} t_AdOfTypeStats;
 
-typedef _Packed union
+typedef union
 {
     volatile t_AdOfTypeResult        adResult;
     volatile t_AdOfTypeContLookup    adContLookup;
-} _PackedType t_Ad;
+} t_Ad;
 
 #if defined(__MWERKS__) && !defined(__GNUC__)
 #pragma pack(pop)
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 e423d90..cadc12a 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
@@ -114,7 +114,7 @@ static e_FmPcdKgExtractDfltSelect GetGenericSwDefault(t_FmPcdKgExtractDflt swDef
             for (i=0 ; i<numOfSwDefaults ; i++)
                 if (swDefaults[i].type == e_FM_PCD_KG_GENERIC_NOT_FROM_DATA)
                     return swDefaults[i].dfltSelect;
-            ASSERT_COND(FALSE);
+            break;
         case (KG_SCH_GEN_SHIM1):
         case (KG_SCH_GEN_SHIM2):
         case (KG_SCH_GEN_IP_PID_NO_V):
@@ -133,7 +133,7 @@ static e_FmPcdKgExtractDfltSelect GetGenericSwDefault(t_FmPcdKgExtractDflt swDef
             for (i=0 ; i<numOfSwDefaults ; i++)
                 if (swDefaults[i].type == e_FM_PCD_KG_GENERIC_FROM_DATA_NO_V)
                     return swDefaults[i].dfltSelect;
-
+            break;
         case (KG_SCH_GEN_START_OF_FRM):
         case (KG_SCH_GEN_ETH):
         case (KG_SCH_GEN_SNAP):
@@ -160,9 +160,12 @@ static e_FmPcdKgExtractDfltSelect GetGenericSwDefault(t_FmPcdKgExtractDflt swDef
             for (i=0 ; i<numOfSwDefaults ; i++)
                 if (swDefaults[i].type == e_FM_PCD_KG_GENERIC_FROM_DATA)
                     return swDefaults[i].dfltSelect;
+            break;
         default:
-            return e_FM_PCD_KG_DFLT_ILLEGAL;
+            break;
     }
+
+    return e_FM_PCD_KG_DFLT_ILLEGAL;
 }
 
 static uint8_t GetGenCode(e_FmPcdExtractFrom src, uint8_t *p_Offset)
@@ -301,6 +304,7 @@ static t_GenericCodes GetGenFieldCode(e_NetHeaderType hdr, t_FmPcdFields field,
         {
             case (HEADER_TYPE_NONE):
                 ASSERT_COND(FALSE);
+                break;
             case (HEADER_TYPE_ETH):
                 switch (field.eth)
                 {
@@ -310,6 +314,7 @@ static t_GenericCodes GetGenFieldCode(e_NetHeaderType hdr, t_FmPcdFields field,
                         REPORT_ERROR(MAJOR, E_NOT_SUPPORTED, ("Extraction not supported"));
                         return 0;
                 }
+                break;
             case (HEADER_TYPE_VLAN):
                 switch (field.vlan)
                 {
@@ -321,6 +326,7 @@ static t_GenericCodes GetGenFieldCode(e_NetHeaderType hdr, t_FmPcdFields field,
                         REPORT_ERROR(MAJOR, E_NOT_SUPPORTED, ("Illegal VLAN header index"));
                         return 0;
                 }
+                break;
             case (HEADER_TYPE_MPLS):
             case (HEADER_TYPE_IPSEC_AH):
             case (HEADER_TYPE_IPSEC_ESP):
@@ -337,24 +343,27 @@ static t_GenericCodes GetGenFieldCode(e_NetHeaderType hdr, t_FmPcdFields field,
             case (HEADER_TYPE_DCCP):
             case (HEADER_TYPE_USER_DEFINED_L4):
                 REPORT_ERROR(MAJOR, E_NOT_SUPPORTED, ("Extraction not supported"));
-            default:
-                REPORT_ERROR(MAJOR, E_NOT_SUPPORTED, ("Header not supported"));
                 return 0;
+            default:
+                break;
+
         }
         else
             switch (hdr)
             {
                 case (HEADER_TYPE_NONE):
                     ASSERT_COND(FALSE);
+                    break;
                 case (HEADER_TYPE_ETH):
-                switch (field.eth)
-                {
-                    case (NET_HEADER_FIELD_ETH_TYPE):
-                        return KG_SCH_GEN_ETH_TYPE_NO_V;
-                    default:
-                        REPORT_ERROR(MAJOR, E_NOT_SUPPORTED, ("Extraction not supported"));
-                        return 0;
-                }
+                    switch (field.eth)
+                    {
+                        case (NET_HEADER_FIELD_ETH_TYPE):
+                            return KG_SCH_GEN_ETH_TYPE_NO_V;
+                        default:
+                            REPORT_ERROR(MAJOR, E_NOT_SUPPORTED, ("Extraction not supported"));
+                            return 0;
+                    }
+                    break;
                 case (HEADER_TYPE_VLAN):
                     switch (field.vlan)
                     {
@@ -366,6 +375,7 @@ static t_GenericCodes GetGenFieldCode(e_NetHeaderType hdr, t_FmPcdFields field,
                             REPORT_ERROR(MAJOR, E_NOT_SUPPORTED, ("Illegal VLAN header index"));
                             return 0;
                     }
+                    break;
                 case (HEADER_TYPE_IPv4):
                     switch (field.ipv4)
                     {
@@ -375,6 +385,7 @@ static t_GenericCodes GetGenFieldCode(e_NetHeaderType hdr, t_FmPcdFields field,
                             REPORT_ERROR(MAJOR, E_NOT_SUPPORTED, ("Extraction not supported"));
                             return 0;
                     }
+                    break;
                 case (HEADER_TYPE_IPv6):
                    switch (field.ipv6)
                     {
@@ -384,6 +395,7 @@ static t_GenericCodes GetGenFieldCode(e_NetHeaderType hdr, t_FmPcdFields field,
                             REPORT_ERROR(MAJOR, E_NOT_SUPPORTED, ("Extraction not supported"));
                             return 0;
                     }
+                    break;
                 case (HEADER_TYPE_MPLS):
                 case (HEADER_TYPE_LLC_SNAP):
                 case (HEADER_TYPE_PPPoE):
@@ -400,9 +412,10 @@ static t_GenericCodes GetGenFieldCode(e_NetHeaderType hdr, t_FmPcdFields field,
                     REPORT_ERROR(MAJOR, E_NOT_SUPPORTED, ("Extraction not supported"));
                     return 0;
                 default:
-                    REPORT_ERROR(MAJOR, E_NOT_SUPPORTED, ("Header not supported"));
-                    return 0;
+                    break;
             }
+    REPORT_ERROR(MAJOR, E_NOT_SUPPORTED, ("Header not supported"));
+    return 0;
 }
 
 static t_KnownFieldsMasks GetKnownProtMask(t_FmPcd *p_FmPcd, e_NetHeaderType hdr, e_FmPcdHdrIndex index, t_FmPcdFields field)
@@ -413,6 +426,7 @@ static t_KnownFieldsMasks GetKnownProtMask(t_FmPcd *p_FmPcd, e_NetHeaderType hdr
     {
         case (HEADER_TYPE_NONE):
             ASSERT_COND(FALSE);
+            break;
         case (HEADER_TYPE_ETH):
             switch (field.eth)
             {
@@ -658,9 +672,12 @@ static t_KnownFieldsMasks GetKnownProtMask(t_FmPcd *p_FmPcd, e_NetHeaderType hdr
                     return 0;
             }
         default:
-            REPORT_ERROR(MAJOR, E_NOT_SUPPORTED, ("Extraction not supported"));
-            return 0;
+            break;
+
     }
+
+    REPORT_ERROR(MAJOR, E_NOT_SUPPORTED, ("Extraction not supported"));
+    return 0;
 }
 
 
@@ -1220,8 +1237,6 @@ static t_Error BuildSchemeRegs(t_FmPcdKgScheme            *p_Scheme,
                         p_SchemeRegs->kgse_ppc = ppcTmp;
                     }
                 }
-                else
-                    ppcTmp = KG_SCH_PP_NO_GEN;
             }
             break;
         case (e_FM_PCD_DONE):
@@ -1242,7 +1257,6 @@ static t_Error BuildSchemeRegs(t_FmPcdKgScheme            *p_Scheme,
     {
         p_SchemeRegs->kgse_om |= KG_SCH_OM_VSPE;
 
-        tmpReg = 0;
         if (p_SchemeParams->storageProfile.direct)
         {
             profileId = p_SchemeParams->storageProfile.profileSelect.directRelativeProfileId;
@@ -1416,14 +1430,12 @@ static t_Error BuildSchemeRegs(t_FmPcdKgScheme            *p_Scheme,
                                         case (NET_HEADER_FIELD_UDP_ENCAP_ESP_SPI):
                                             p_Extract->extractByHdr.type = e_FM_PCD_EXTRACT_FROM_HDR;
                                             p_Extract->extractByHdr.hdr = FmPcdGetAliasHdr(p_FmPcd, p_Scheme->netEnvId, HEADER_TYPE_UDP_ENCAP_ESP);
-                                            p_Extract->extractByHdr.extractByHdrType.fromField.size = p_Extract->extractByHdr.extractByHdrType.fromField.size;
                                             /*p_Extract->extractByHdr.extractByHdrType.fromField.offset += ESP_SPI_OFFSET;*/
                                             p_Extract->extractByHdr.ignoreProtocolValidation = TRUE;
                                             break;
                                         case (NET_HEADER_FIELD_UDP_ENCAP_ESP_SEQUENCE_NUM):
                                             p_Extract->extractByHdr.type = e_FM_PCD_EXTRACT_FROM_HDR;
                                             p_Extract->extractByHdr.hdr = FmPcdGetAliasHdr(p_FmPcd, p_Scheme->netEnvId, HEADER_TYPE_UDP_ENCAP_ESP);
-                                            p_Extract->extractByHdr.extractByHdrType.fromField.size = p_Extract->extractByHdr.extractByHdrType.fromField.size;
                                             p_Extract->extractByHdr.extractByHdrType.fromField.offset += ESP_SEQ_NUM_OFFSET;
                                             p_Extract->extractByHdr.ignoreProtocolValidation = TRUE;
                                             break;
@@ -1492,17 +1504,18 @@ static t_Error BuildSchemeRegs(t_FmPcdKgScheme            *p_Scheme,
                                 }
                                 else
                                     generic = TRUE;
-
                             }
                             else
                                 generic = TRUE;
                             if (generic)
                             {
                                 /* tmp - till we cover more headers under generic */
+                                XX_Free(p_LocalExtractsArray);
                                 RETURN_ERROR(MAJOR, E_NOT_SUPPORTED, ("Full header selection not supported"));
                             }
                             break;
                         default:
+                            XX_Free(p_LocalExtractsArray);
                             RETURN_ERROR(MAJOR, E_INVALID_SELECTION, NO_MSG);
                     }
                     break;
@@ -1523,15 +1536,24 @@ static t_Error BuildSchemeRegs(t_FmPcdKgScheme            *p_Scheme,
             {
                 /* set generic register fields */
                 if (currGenId >= FM_KG_NUM_OF_GENERIC_REGS)
+                {
+                    XX_Free(p_LocalExtractsArray);
                     RETURN_ERROR(MAJOR, E_FULL, ("Generic registers are fully used"));
+                }
                 if (!code)
+                {
+                    XX_Free(p_LocalExtractsArray);
                     RETURN_ERROR(MAJOR, E_NOT_SUPPORTED, NO_MSG);
+                }
 
                 genTmp = KG_SCH_GEN_VALID;
                 genTmp |= (uint32_t)(code << KG_SCH_GEN_HT_SHIFT);
                 genTmp |= offset;
                 if ((size > MAX_KG_SCH_SIZE) || (size < 1))
-                      RETURN_ERROR(MAJOR, E_NOT_SUPPORTED, ("Illegal extraction (size out of range)"));
+                {
+                    XX_Free(p_LocalExtractsArray);
+                    RETURN_ERROR(MAJOR, E_NOT_SUPPORTED, ("Illegal extraction (size out of range)"));
+                }
                 genTmp |= (uint32_t)((size - 1) << KG_SCH_GEN_SIZE_SHIFT);
                 swDefault = GetGenericSwDefault(swDefaults, numOfSwDefaults, code);
                 if (swDefault == e_FM_PCD_KG_DFLT_ILLEGAL)
@@ -1553,8 +1575,11 @@ static t_Error BuildSchemeRegs(t_FmPcdKgScheme            *p_Scheme,
         maskTmp = 0xFFFFFFFF;
         /*  configure kgse_bmch, kgse_bmcl and kgse_fqb */
 
-        if (p_KeyAndHash->numOfUsedMasks >= FM_PCD_KG_NUM_OF_EXTRACT_MASKS)
+        if (p_KeyAndHash->numOfUsedMasks > FM_PCD_KG_NUM_OF_EXTRACT_MASKS)
+        {
+            XX_Free(p_LocalExtractsArray);
             RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("Only %d masks supported", FM_PCD_KG_NUM_OF_EXTRACT_MASKS));
+        }
         for ( i=0 ;i<p_KeyAndHash->numOfUsedMasks ; i++)
         {
             /* Get the relative id of the extract (for known 0-0x1f, for generic 0-7) */
@@ -1589,9 +1614,15 @@ static t_Error BuildSchemeRegs(t_FmPcdKgScheme            *p_Scheme,
 
         /*  configure kgse_hc  */
         if (p_KeyAndHash->hashShift > MAX_HASH_SHIFT)
-             RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("hashShift must not be larger than %d", MAX_HASH_SHIFT));
+        {
+            XX_Free(p_LocalExtractsArray);
+            RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("hashShift must not be larger than %d", MAX_HASH_SHIFT));
+        }
         if (p_KeyAndHash->hashDistributionFqidsShift > MAX_DIST_FQID_SHIFT)
-             RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("hashDistributionFqidsShift must not be larger than %d", MAX_DIST_FQID_SHIFT));
+        {
+            XX_Free(p_LocalExtractsArray);
+            RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("hashDistributionFqidsShift must not be larger than %d", MAX_DIST_FQID_SHIFT));
+        }
 
         tmpReg = 0;
 
@@ -1604,7 +1635,10 @@ static t_Error BuildSchemeRegs(t_FmPcdKgScheme            *p_Scheme,
                     (!!(p_SchemeRegs->kgse_ekfc & KG_SCH_KN_IPSRC1) != !!(p_SchemeRegs->kgse_ekfc & KG_SCH_KN_IPDST1)) ||
                     (!!(p_SchemeRegs->kgse_ekfc & KG_SCH_KN_IPSRC2) != !!(p_SchemeRegs->kgse_ekfc & KG_SCH_KN_IPDST2)) ||
                     (!!(p_SchemeRegs->kgse_ekfc & KG_SCH_KN_L4PSRC) != !!(p_SchemeRegs->kgse_ekfc & KG_SCH_KN_L4PDST)))
+            {
+                XX_Free(p_LocalExtractsArray);
                 RETURN_ERROR(MAJOR, E_INVALID_STATE, ("symmetricHash set but src/dest extractions missing"));
+            }
             tmpReg |= KG_SCH_HASH_CONFIG_SYM;
         }
         p_SchemeRegs->kgse_hc = tmpReg;
@@ -1650,8 +1684,6 @@ static t_Error BuildSchemeRegs(t_FmPcdKgScheme            *p_Scheme,
             }
         }
         XX_Free(p_LocalExtractsArray);
-        p_LocalExtractsArray = NULL;
-
     }
     else
     {
@@ -2001,7 +2033,7 @@ void FmPcdKgDestroyClsPlanGrp(t_Handle h_FmPcd, uint8_t grpId)
     memset(&p_FmPcd->p_FmPcdKg->clsPlanGrps[grpId], 0, sizeof(t_FmPcdKgClsPlanGrp));
 }
 
-t_Error FmPcdKgBuildBindPortToSchemes(t_Handle h_FmPcd , t_FmPcdKgInterModuleBindPortToSchemes *p_BindPort, uint32_t *p_SpReg, bool add)
+t_Error FmPcdKgBuildBindPortToSchemes(t_Handle h_FmPcd, t_FmPcdKgInterModuleBindPortToSchemes *p_BindPort, uint32_t *p_SpReg, bool add)
 {
     t_FmPcd                 *p_FmPcd = (t_FmPcd*)h_FmPcd;
     uint32_t                j, schemesPerPortVector = 0;
@@ -2053,7 +2085,9 @@ t_Error FmPcdKgBuildBindPortToSchemes(t_Handle h_FmPcd , t_FmPcdKgInterModuleBin
                 the match vector and the grpBits (= ccUnits) */
                 if ((p_Scheme->matchVector != SCHEME_ALWAYS_DIRECT) || p_Scheme->ccUnits)
                 {
+                    uint8_t netEnvId;
                     walking1Mask = 0x80000000;
+                    netEnvId = (p_Scheme->netEnvId == ILLEGAL_NETENV)? p_BindPort->netEnvId:p_Scheme->netEnvId;
                     tmp = (p_Scheme->matchVector == SCHEME_ALWAYS_DIRECT)? 0:p_Scheme->matchVector;
                     tmp |= p_Scheme->ccUnits;
                     while (tmp)
@@ -2061,7 +2095,7 @@ t_Error FmPcdKgBuildBindPortToSchemes(t_Handle h_FmPcd , t_FmPcdKgInterModuleBin
                         if (tmp & walking1Mask)
                         {
                             tmp &= ~walking1Mask;
-                            if (!PcdNetEnvIsUnitWithoutOpts(p_FmPcd, p_Scheme->netEnvId, walking1Mask))
+                            if (!PcdNetEnvIsUnitWithoutOpts(p_FmPcd, netEnvId, walking1Mask))
                                 RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Port (without clsPlan) may not be bound to requested scheme - uses clsPlan options"));
                         }
                         walking1Mask >>= 1;
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 ddf661a..e69ea1d 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
@@ -485,7 +485,6 @@ static t_Error BuildHmct(t_FmPcdManip *p_Manip,
                         uint8_t prsArrayOffset;
                         t_Error err = E_OK;
 
-                        UNUSED(err);
                         tmpReg = (uint32_t)(HMCD_OPCODE_RMV_TILL)
                                 << HMCD_OC_SHIFT;
 
@@ -504,11 +503,7 @@ static t_Error BuildHmct(t_FmPcdManip *p_Manip,
                         RETURN_ERROR(MINOR, E_NOT_SUPPORTED,
                                      ("manip header remove by hdr type!"));
                 }
-
             }
-            else
-                RETURN_ERROR(MINOR, E_NOT_SUPPORTED,
-                             ("manip header remove type!"));
 
         WRITE_UINT32(*p_TmpHmct, tmpReg);
         /* save a pointer to the "last" indication word */
@@ -708,9 +703,6 @@ static t_Error BuildHmct(t_FmPcdManip *p_Manip,
 
                 }
             }
-            else
-                RETURN_ERROR(MINOR, E_NOT_SUPPORTED,
-                             ("manip header insert type!"));
     }
 
     if (p_FmPcdManipParams->u.hdr.fieldUpdate)
@@ -1044,10 +1036,6 @@ static t_Error BuildHmct(t_FmPcdManip *p_Manip,
             else
                 XX_Free(((t_FmPcdManip *)p_FmPcdManipParams->h_NextManip)->h_Ad);
             ((t_FmPcdManip *)p_FmPcdManipParams->h_NextManip)->h_Ad = NULL;
-
-            /* advance pointer */
-            p_TmpHmct += MANIP_GET_HMCT_SIZE(p_FmPcdManipParams->h_NextManip)
-                    / 4;
         }
     }
     else
@@ -1287,8 +1275,6 @@ static t_Error CreateManipActionBackToOrig(
     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,
@@ -1820,6 +1806,9 @@ t_Error FmPcdRegisterReassmPort(t_Handle h_FmPcd, t_Handle h_ReasmCommonPramTbl)
     ASSERT_COND(h_ReasmCommonPramTbl);
 
     bitFor1Micro = FmGetTimeStampScale(p_FmPcd->h_Fm);
+    if (bitFor1Micro == 0)
+        RETURN_ERROR(MAJOR, E_NOT_AVAILABLE, ("Timestamp scale"));
+
     bitFor1Micro = 32 - bitFor1Micro;
     LOG2(FM_PCD_MANIP_REASM_TIMEOUT_THREAD_THRESH, log2num);
     tsbs = bitFor1Micro - log2num;
@@ -1857,11 +1846,15 @@ t_Error FmPcdRegisterReassmPort(t_Handle h_FmPcd, t_Handle h_ReasmCommonPramTbl)
 
 static t_Error CreateReassCommonTable(t_FmPcdManip *p_Manip)
 {
-    uint32_t tmpReg32 = 0, i;
+    uint32_t tmpReg32 = 0, i, bitFor1Micro;
     uint64_t tmpReg64, size;
     t_FmPcd *p_FmPcd = (t_FmPcd *)p_Manip->h_FmPcd;
     t_Error err = E_OK;
 
+    bitFor1Micro = FmGetTimeStampScale(p_FmPcd->h_Fm);
+    if (bitFor1Micro == 0)
+        RETURN_ERROR(MAJOR, E_NOT_AVAILABLE, ("Timestamp scale"));
+
     /* Allocation of the Reassembly Common Parameters table. This table is located in the
      MURAM. Its size is 64 bytes and its base address should be 8-byte aligned. */
     p_Manip->reassmParams.p_ReassCommonTbl =
@@ -1969,7 +1962,7 @@ static t_Error CreateReassCommonTable(t_FmPcdManip *p_Manip)
 
     /* Sets the Expiration Delay */
     tmpReg32 = 0;
-    tmpReg32 |= (((uint32_t)(1 << FmGetTimeStampScale(p_FmPcd->h_Fm)))
+    tmpReg32 |= (((uint32_t)(1 << bitFor1Micro))
             * p_Manip->reassmParams.timeoutThresholdForReassmProcess);
     WRITE_UINT32(p_Manip->reassmParams.p_ReassCommonTbl->expirationDelay,
                  tmpReg32);
@@ -2036,7 +2029,7 @@ static t_Error CreateReassTable(t_FmPcdManip *p_Manip, e_NetHeaderType hdr)
             keySize = 4;
             break;
         default:
-            break;
+            RETURN_ERROR(MAJOR, E_NOT_SUPPORTED, ("header type"));
     }
     keySize += 2; /* 2 bytes reserved for RFDIndex */
 #if (DPAA_VERSION >= 11)
@@ -2200,32 +2193,6 @@ static t_Error UpdateInitReasm(t_Handle h_FmPcd, t_Handle h_PcdParams,
                 & (NUM_OF_TASKS | NUM_OF_EXTRA_TASKS | DISCARD_MASK | FM_REV))
             RETURN_ERROR(MAJOR, E_INVALID_STATE,
                          ("offset of the data wasn't configured previously"));
-    }
-    else
-        if (validate)
-        {
-            if ((!(p_Manip->shadowUpdateParams
-                    & (NUM_OF_TASKS | NUM_OF_EXTRA_TASKS | DISCARD_MASK)))
-                    || ((p_Manip->updateParams
-                            & (NUM_OF_TASKS | NUM_OF_EXTRA_TASKS | DISCARD_MASK))))
-                RETURN_ERROR(
-                        MAJOR, E_INVALID_STATE,
-                        ("in this stage parameters from Port has be updated"));
-
-            fmPortGetSetCcParams.setCcParams.type = 0;
-            fmPortGetSetCcParams.getCcParams.type = p_Manip->shadowUpdateParams;
-            if ((err = FmPortGetSetCcParams(h_FmPort, &fmPortGetSetCcParams))
-                    != E_OK)
-                RETURN_ERROR(MAJOR, err, NO_MSG);
-            if (fmPortGetSetCcParams.getCcParams.type
-                    & (NUM_OF_TASKS | NUM_OF_EXTRA_TASKS | DISCARD_MASK))
-                RETURN_ERROR(
-                        MAJOR, E_INVALID_STATE,
-                        ("offset of the data wasn't configured previously"));
-        }
-
-    if (p_Manip->updateParams)
-    {
         if (p_Manip->updateParams
                 & (NUM_OF_TASKS | NUM_OF_EXTRA_TASKS | DISCARD_MASK))
         {
@@ -3032,18 +2999,19 @@ static t_Error CapwapReassembly(t_CapwapReassemblyParams *p_ManipParams,
     uint8_t log2Num;
     uint8_t numOfSets;
     uint32_t j = 0;
+    uint32_t bitFor1Micro;
 
     SANITY_CHECK_RETURN_ERROR(p_Manip->h_Ad, E_INVALID_HANDLE);
     SANITY_CHECK_RETURN_ERROR(p_FmPcd->h_Hc, E_INVALID_HANDLE);
 
     if (!p_FmPcd->h_Hc)
-    RETURN_ERROR(MAJOR, E_INVALID_VALUE,("hc port has to be initialized in this mode"));
+        RETURN_ERROR(MAJOR, E_INVALID_VALUE,("hc port has to be initialized in this mode"));
     if (!POWER_OF_2(p_ManipParams->timeoutRoutineRequestTime))
-    RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("timeoutRoutineRequestTime has to be power of 2"));
+        RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("timeoutRoutineRequestTime has to be power of 2"));
     if (!POWER_OF_2(p_ManipParams->maxNumFramesInProcess))
-    RETURN_ERROR(MAJOR, E_INVALID_VALUE,("maxNumFramesInProcess has to be power of 2"));
+        RETURN_ERROR(MAJOR, E_INVALID_VALUE,("maxNumFramesInProcess has to be power of 2"));
     if (!p_ManipParams->timeoutRoutineRequestTime && p_ManipParams->timeoutThresholdForReassmProcess)
-    DBG(WARNING, ("if timeoutRoutineRequestTime 0,  timeoutThresholdForReassmProcess is uselessly"));
+        DBG(WARNING, ("if timeoutRoutineRequestTime 0,  timeoutThresholdForReassmProcess is uselessly"));
     if (p_ManipParams->numOfFramesPerHashEntry == e_FM_PCD_MANIP_FOUR_WAYS_HASH)
     {
         if ((p_ManipParams->maxNumFramesInProcess < 4) ||
@@ -3057,13 +3025,17 @@ static t_Error CapwapReassembly(t_CapwapReassemblyParams *p_ManipParams,
         RETURN_ERROR(MAJOR,E_INVALID_VALUE, ("In the case of numOfFramesPerHashEntry = e_FM_PCD_MANIP_FOUR_WAYS_HASH maxNumFramesInProcess has to be in the range 8-2048"));
     }
 
+    bitFor1Micro = FmGetTimeStampScale(p_FmPcd->h_Fm);
+    if (bitFor1Micro == 0)
+        RETURN_ERROR(MAJOR, E_NOT_AVAILABLE, ("Timestamp scale"));
+
     p_Manip->updateParams |= (NUM_OF_TASKS | OFFSET_OF_PR | OFFSET_OF_DATA | HW_PORT_ID);
 
     p_Manip->h_Frag = (t_Handle)FM_MURAM_AllocMem(p_FmPcd->h_FmMuram,
             FM_PCD_MANIP_CAPWAP_REASM_TABLE_SIZE,
             FM_PCD_MANIP_CAPWAP_REASM_TABLE_ALIGN);
     if (!p_Manip->h_Frag)
-    RETURN_ERROR(MAJOR, E_NO_MEMORY, ("MURAM alloc CAPWAP reassembly parameters table"));
+        RETURN_ERROR(MAJOR, E_NO_MEMORY, ("MURAM alloc CAPWAP reassembly parameters table"));
 
     IOMemSet32(p_Manip->h_Frag, 0, FM_PCD_MANIP_CAPWAP_REASM_TABLE_SIZE);
 
@@ -3075,7 +3047,7 @@ static t_Error CapwapReassembly(t_CapwapReassemblyParams *p_ManipParams,
             FM_PCD_MANIP_CAPWAP_REASM_TABLE_ALIGN);
 
     if (!p_Manip->capwapFragParams.p_AutoLearnHashTbl)
-    RETURN_ERROR(MAJOR, E_NO_MEMORY,("MURAM alloc for CAPWAP automatic learning hash table"));
+        RETURN_ERROR(MAJOR, E_NO_MEMORY,("MURAM alloc for CAPWAP automatic learning hash table"));
 
     IOMemSet32(p_Manip->capwapFragParams.p_AutoLearnHashTbl, 0, (uint32_t)(p_ManipParams->maxNumFramesInProcess * 2 * FM_PCD_MANIP_CAPWAP_REASM_AUTO_LEARNING_HASH_ENTRY_SIZE));
 
@@ -3085,9 +3057,9 @@ static t_Error CapwapReassembly(t_CapwapReassemblyParams *p_ManipParams,
 
     tmpReg32 = 0;
     if (p_ManipParams->timeOutMode == e_FM_PCD_MANIP_TIME_OUT_BETWEEN_FRAMES)
-    tmpReg32 |= FM_PCD_MANIP_CAPWAP_REASM_TIME_OUT_BETWEEN_FRAMES;
+        tmpReg32 |= FM_PCD_MANIP_CAPWAP_REASM_TIME_OUT_BETWEEN_FRAMES;
     if (p_ManipParams->haltOnDuplicationFrag)
-    tmpReg32 |= FM_PCD_MANIP_CAPWAP_REASM_HALT_ON_DUPLICATE_FRAG;
+        tmpReg32 |= FM_PCD_MANIP_CAPWAP_REASM_HALT_ON_DUPLICATE_FRAG;
     if (p_ManipParams->numOfFramesPerHashEntry == e_FM_PCD_MANIP_EIGHT_WAYS_HASH)
     {
         i = 8;
@@ -3103,8 +3075,8 @@ static t_Error CapwapReassembly(t_CapwapReassemblyParams *p_ManipParams,
     WRITE_UINT32(((t_CapwapReasmPram *)p_Table)->mode, tmpReg32);
 
     for (j=0; j<p_ManipParams->maxNumFramesInProcess*2; j++)
-    if (((j / i) % 2)== 0)
-    WRITE_UINT32(*(uint32_t *)PTR_MOVE(p_Manip->capwapFragParams.p_AutoLearnHashTbl, j * FM_PCD_MANIP_CAPWAP_REASM_AUTO_LEARNING_HASH_ENTRY_SIZE), 0x80000000);
+        if (((j / i) % 2)== 0)
+            WRITE_UINT32(*(uint32_t *)PTR_MOVE(p_Manip->capwapFragParams.p_AutoLearnHashTbl, j * FM_PCD_MANIP_CAPWAP_REASM_AUTO_LEARNING_HASH_ENTRY_SIZE), 0x80000000);
 
     tmpReg32 = 0x00008000;
     tmpReg32 |= (uint32_t)poolId << 16;
@@ -3118,7 +3090,7 @@ static t_Error CapwapReassembly(t_CapwapReassemblyParams *p_ManipParams,
 
     p_Manip->capwapFragParams.fqidForTimeOutFrames = p_ManipParams->fqidForTimeOutFrames;
     p_Manip->capwapFragParams.timeoutRoutineRequestTime = p_ManipParams->timeoutRoutineRequestTime;
-    p_Manip->capwapFragParams.bitFor1Micro = FmGetTimeStampScale(p_FmPcd->h_Fm);
+    p_Manip->capwapFragParams.bitFor1Micro = bitFor1Micro;
 
     tmpReg32 = 0;
     tmpReg32 |= (((uint32_t)1<<p_Manip->capwapFragParams.bitFor1Micro) * p_ManipParams->timeoutThresholdForReassmProcess);
@@ -3449,7 +3421,7 @@ static t_Error FillReassmManipParams(t_FmPcdManip *p_Manip, e_NetHeaderType hdr)
                     - (p_FmPcd->physicalMuramBase));
             break;
         default:
-            break;
+            RETURN_ERROR(MAJOR, E_NOT_SUPPORTED, ("header type"));
     }
 
     WRITE_UINT32(p_Ad->ccAdBase, tmpReg32);
@@ -4037,7 +4009,6 @@ static void setCapwapReassmSchemeParams(t_FmPcd* p_FmPcd,
                                         t_FmPcdKgSchemeParams *p_Scheme,
                                         t_Handle h_CcTree, uint8_t groupId)
 {
-    uint32_t j;
     uint8_t res;
 
     /* Configures scheme's network environment parameters */
@@ -4356,18 +4327,18 @@ static t_Handle ManipOrStatsSetNode(t_Handle h_FmPcd, t_Handle *p_Params,
                                          (t_FmPcdManipParams *)p_Params);
 #if (defined(FM_CAPWAP_SUPPORT) && (DPAA_VERSION == 10))
     else
-    err = CheckStatsParamsAndSetType(p_Manip, (t_FmPcdStatsParams *)p_Params);
+        err = CheckStatsParamsAndSetType(p_Manip, (t_FmPcdStatsParams *)p_Params);
 #else /* not (defined(FM_CAPWAP_SUPPORT) && (DPAA_VERSION == 10)) */
     else
     {
         REPORT_ERROR(MAJOR, E_NOT_SUPPORTED, ("Statistics node!"));
+        XX_Free(p_Manip);
         return NULL;
     }
 #endif /* (defined(FM_CAPWAP_SUPPORT) && (DPAA_VERSION == 10)) */
     if (err)
     {
-        REPORT_ERROR(MAJOR, E_INVALID_VALUE, ("INVALID HEADER MANIPULATION TYPE"));
-        ReleaseManipHandler(p_Manip, p_FmPcd);
+        REPORT_ERROR(MAJOR, E_INVALID_VALUE, ("Invalid header manipulation type"));
         XX_Free(p_Manip);
         return NULL;
     }
@@ -4488,7 +4459,6 @@ static t_Error FmPcdManipInitUpdate(t_Handle h_FmPcd, t_Handle h_PcdParams,
     SANITY_CHECK_RETURN_ERROR(h_Manip, E_INVALID_HANDLE);
 
     UNUSED(level);
-    UNUSED(h_FmPcd);
     UNUSED(h_FmTree);
 
     switch (p_Manip->opcode)
@@ -4635,14 +4605,15 @@ t_Error FmPcdManipCheckParamsForCcNextEngine(
         uint32_t *requiredAction)
 {
     t_FmPcdManip *p_Manip;
+#if (defined(FM_CAPWAP_SUPPORT) && (DPAA_VERSION == 10))
     t_Error err = E_OK;
+#endif /* (defined(FM_CAPWAP_SUPPORT) && (DPAA_VERSION == 10))*/
     bool pointFromCc = TRUE;
 
     SANITY_CHECK_RETURN_ERROR(p_FmPcdCcNextEngineParams, E_NULL_POINTER);
     SANITY_CHECK_RETURN_ERROR(p_FmPcdCcNextEngineParams->h_Manip,
                               E_NULL_POINTER);
 
-    UNUSED(err);
     p_Manip = (t_FmPcdManip *)(p_FmPcdCcNextEngineParams->h_Manip);
     *requiredAction = 0;
 
@@ -4652,46 +4623,36 @@ t_Error FmPcdManipCheckParamsForCcNextEngine(
         {
 #if (defined(FM_CAPWAP_SUPPORT) && (DPAA_VERSION == 10))
             case (HMAN_OC_CAPWAP_INDEXED_STATS):
-            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"));
-            if (p_FmPcdCcNextEngineParams->params.enqueueParams.overrideFqid)
-            p_Manip->cnia = TRUE;
+                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"));
+                if (p_FmPcdCcNextEngineParams->params.enqueueParams.overrideFqid)
+                    p_Manip->cnia = TRUE;
             case (HMAN_OC_CAPWAP_RMV_DTLS_IF_EXIST):
-            *requiredAction = UPDATE_NIA_ENQ_WITHOUT_DMA;
+                *requiredAction = UPDATE_NIA_ENQ_WITHOUT_DMA;
             case (HMAN_OC_RMV_N_OR_INSRT_INT_FRM_HDR):
-            p_Manip->ownerTmp++;
-            break;
+                p_Manip->ownerTmp++;
+                break;
             case (HMAN_OC_INSRT_HDR_BY_TEMPL_N_OR_FRAG_AFTER):
-            if ((p_FmPcdCcNextEngineParams->nextEngine != e_FM_PCD_DONE)
+                if ((p_FmPcdCcNextEngineParams->nextEngine != e_FM_PCD_DONE)
                     && !p_FmPcdCcNextEngineParams->params.enqueueParams.overrideFqid)
-            RETURN_ERROR(
-                    MAJOR,
-                    E_INVALID_STATE,
-                    ("For this type of header manipulation has to be nextEngine e_FM_PCD_DONE with fqidForCtrlFlow FALSE"));
-            p_Manip->ownerTmp++;
-            break;
+                    RETURN_ERROR(
+                        MAJOR,
+                        E_INVALID_STATE,
+                        ("For this type of header manipulation has to be nextEngine e_FM_PCD_DONE with fqidForCtrlFlow FALSE"));
+                p_Manip->ownerTmp++;
+                break;
             case (HMAN_OC_MV_INT_FRAME_HDR_FROM_FRM_TO_BUFFER_PREFFIX):
-            if ((p_FmPcdCcNextEngineParams->nextEngine != e_FM_PCD_CC)
-                    && (FmPcdCcGetParseCode(
-                                    p_FmPcdCcNextEngineParams->params.ccParams.h_CcNode)
-                            != CC_PC_GENERIC_IC_HASH_INDEXED))
-            RETURN_ERROR(
-                    MAJOR,
-                    E_INVALID_STATE,
-                    ("For this type of header manipulation next engine has to be CC and action = e_FM_PCD_ACTION_INDEXED_LOOKUP"));
-            err =
-            UpdateManipIc(
-                    p_FmPcdCcNextEngineParams->h_Manip,
-                    FmPcdCcGetOffset(
-                            p_FmPcdCcNextEngineParams->params.ccParams.h_CcNode));
-            if (err)
-            RETURN_ERROR(MAJOR, err, NO_MSG);
-            *requiredAction = UPDATE_NIA_ENQ_WITHOUT_DMA;
-            break;
-#endif /* (defined(FM_CAPWAP_SUPPORT) && (DPAA_VERSION == 10)) */
+                if ((p_FmPcdCcNextEngineParams->nextEngine != e_FM_PCD_CC)
+                    && (FmPcdCcGetParseCode(p_FmPcdCcNextEngineParams->params.ccParams.h_CcNode)
+                        != CC_PC_GENERIC_IC_HASH_INDEXED))
+                    RETURN_ERROR(MAJOR, E_INVALID_STATE, ("For this type of header manipulation next engine has to be CC and action = e_FM_PCD_ACTION_INDEXED_LOOKUP"));
+                err = UpdateManipIc(p_FmPcdCcNextEngineParams->h_Manip,
+                                    FmPcdCcGetOffset(p_FmPcdCcNextEngineParams->params.ccParams.h_CcNode));
+                if (err)
+                    RETURN_ERROR(MAJOR, err, NO_MSG);
+                *requiredAction = UPDATE_NIA_ENQ_WITHOUT_DMA;
+                break;
+ #endif /* (defined(FM_CAPWAP_SUPPORT) && (DPAA_VERSION == 10)) */
             case (HMAN_OC_IP_FRAGMENTATION):
             case (HMAN_OC_IP_REASSEMBLY):
 #if (DPAA_VERSION >= 11)
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 2827578..de7e4c8 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
@@ -312,7 +312,7 @@ typedef enum e_ManipInfo {
 #endif /* defined(__MWERKS__) && ... */
 
 #if (defined(FM_CAPWAP_SUPPORT) && (DPAA_VERSION == 10))
-typedef _Packed struct t_CapwapReasmPram {
+typedef struct t_CapwapReasmPram {
     volatile uint32_t mode;
     volatile uint32_t autoLearnHashTblPtr;
     volatile uint32_t intStatsTblPtr;
@@ -336,7 +336,7 @@ typedef _Packed struct t_CapwapReasmPram {
     volatile uint32_t internalBufferBusy;
     volatile uint32_t externalBufferBusy;
     volatile uint32_t reserved1[4];
-} _PackedType t_CapwapReasmPram;
+} t_CapwapReasmPram;
 #endif /* (defined(FM_CAPWAP_SUPPORT) && (DPAA_VERSION == 10)) */
 
 typedef _Packed struct t_ReassTbl {
@@ -359,7 +359,7 @@ typedef _Packed struct t_ReassTbl {
     volatile uint32_t reserved2[2];
 } _PackedType t_ReassTbl;
 
-typedef _Packed struct t_ReassCommonTbl {
+typedef struct t_ReassCommonTbl {
     volatile uint32_t timeoutModeAndFqid;
     volatile uint32_t reassFrmDescIndexPoolTblPtr;
     volatile uint32_t liodnAndReassFrmDescPoolPtrHi;
@@ -376,7 +376,7 @@ typedef _Packed struct t_ReassCommonTbl {
     volatile uint32_t totalDmaSemaphoreDepletionCounter;
     volatile uint32_t totalNCSPCounter;
     volatile uint32_t discardMask;
-} _PackedType t_ReassCommonTbl;
+} t_ReassCommonTbl;
 
 typedef _Packed struct t_Hmtd {
     volatile uint16_t   cfg;
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 379e984..4adf9a1 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
@@ -1044,8 +1044,7 @@ t_Error FM_PCD_Free(t_Handle h_FmPcd)
 
     if (p_FmPcd->p_FmPcdPlcr)
     {
-        if ((err = PlcrFree(p_FmPcd)) != E_OK)
-            RETURN_ERROR(MINOR, err, NO_MSG);
+        PlcrFree(p_FmPcd);
         XX_Free(p_FmPcd->p_FmPcdPlcr);
         p_FmPcd->p_FmPcdPlcr = NULL;
     }
@@ -1485,7 +1484,7 @@ t_Handle FM_PCD_NetEnvCharacteristicsSet(t_Handle h_FmPcd, t_FmPcdNetEnvParams
             for (k = 0; (k < FM_PCD_MAX_NUM_OF_INTERCHANGEABLE_HDRS)
                     && (p_FmPcd->netEnvs[netEnvCurrId].units[i].hdrs[k].hdr != HEADER_TYPE_NONE); k++)
             {
-                GET_PRS_HDR_NUM(hdrNum, p_FmPcd->netEnvs[netEnvCurrId].units[i].hdrs[k].hdr);
+                hdrNum = GetPrsHdrNum(p_FmPcd->netEnvs[netEnvCurrId].units[i].hdrs[k].hdr);
                 if ((hdrNum == ILLEGAL_HDR_NUM) || (hdrNum == NO_HDR_NUM))
                 {
                     REPORT_ERROR(MAJOR, E_NOT_SUPPORTED, NO_MSG);
@@ -1749,11 +1748,8 @@ uint32_t FM_PCD_GetCounter(t_Handle h_FmPcd, e_FmPcdCounters counter)
                 return GET_UINT32(p_FmPcd->p_FmPcdPlcr->p_FmPcdPlcrRegs->fmpl_tpcnt);
         case (e_FM_PCD_PLCR_COUNTERS_LENGTH_MISMATCH):
                 return GET_UINT32(p_FmPcd->p_FmPcdPlcr->p_FmPcdPlcrRegs->fmpl_flmcnt);
-
-        default:
-            REPORT_ERROR(MINOR, E_INVALID_STATE, ("Unsupported type of counter"));
-            return 0;
     }
+    return 0;
 }
 
 #if (defined(DEBUG_ERRORS) && (DEBUG_ERRORS > 0))
@@ -1824,15 +1820,12 @@ t_Error FM_PCD_SetException(t_Handle h_FmPcd, e_FmPcdExceptions exception, bool
             case (e_FM_PCD_PLCR_EXCEPTION_ATOMIC_ACTION_COMPLETE):
                 if (!p_FmPcd->p_FmPcdPlcr)
                     RETURN_ERROR(MINOR, E_INVALID_STATE, ("Can't ask for this interrupt - policer is not working"));
-            break;
+                break;
             case (e_FM_PCD_PRS_EXCEPTION_DOUBLE_ECC):
             case (e_FM_PCD_PRS_EXCEPTION_SINGLE_ECC):
                 if (!p_FmPcd->p_FmPcdPrs)
                     RETURN_ERROR(MINOR, E_INVALID_STATE, ("Can't ask for this interrupt - parser is not working"));
-            break;
-            default:
-                RETURN_ERROR(MINOR, E_INVALID_STATE, ("Unsupported exception"));
-
+                break;
         }
 
         switch (exception)
@@ -1901,24 +1894,20 @@ t_Error FM_PCD_SetException(t_Handle h_FmPcd, e_FmPcdExceptions exception, bool
                     tmpReg &= ~FM_PCD_PLCR_ATOMIC_ACTION_COMPLETE;
                 WRITE_UINT32(p_FmPcd->p_FmPcdPlcr->p_FmPcdPlcrRegs->fmpl_ier, tmpReg);
                 break;
-             default:
-                RETURN_ERROR(MINOR, E_INVALID_STATE, ("Unsupported exception"));
         }
         /* for ECC exceptions driver automatically enables ECC mechanism, if disabled.
            Driver may disable them automatically, depending on driver's status */
-        if (enable && ( (exception == e_FM_PCD_KG_EXCEPTION_DOUBLE_ECC) |
+        if (enable && ((exception == e_FM_PCD_KG_EXCEPTION_DOUBLE_ECC) |
                        (exception == e_FM_PCD_PLCR_EXCEPTION_DOUBLE_ECC) |
                        (exception == e_FM_PCD_PRS_EXCEPTION_DOUBLE_ECC) |
                        (exception == e_FM_PCD_PRS_EXCEPTION_SINGLE_ECC)))
             FmEnableRamsEcc(p_FmPcd->h_Fm);
-        if (!enable && ( (exception == e_FM_PCD_KG_EXCEPTION_DOUBLE_ECC) |
+        if (!enable && ((exception == e_FM_PCD_KG_EXCEPTION_DOUBLE_ECC) |
                        (exception == e_FM_PCD_PLCR_EXCEPTION_DOUBLE_ECC) |
                        (exception == e_FM_PCD_PRS_EXCEPTION_DOUBLE_ECC) |
                        (exception == e_FM_PCD_PRS_EXCEPTION_SINGLE_ECC)))
             FmDisableRamsEcc(p_FmPcd->h_Fm);
     }
-    else
-        RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("Undefined exception"));
 
     return E_OK;
 }
@@ -1953,8 +1942,7 @@ t_Error FM_PCD_ForceIntr (t_Handle h_FmPcd, e_FmPcdExceptions exception)
                 RETURN_ERROR(MINOR, E_INVALID_STATE, ("Can't ask for this interrupt -parsrer is not working"));
             break;
         default:
-            RETURN_ERROR(MINOR, E_INVALID_STATE, ("Invalid interrupt requested"));
-
+            RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Invalid interrupt requested"));
     }
     switch (exception)
     {
@@ -1996,8 +1984,6 @@ t_Error FM_PCD_ForceIntr (t_Handle h_FmPcd, e_FmPcdExceptions exception)
                 RETURN_ERROR(MINOR, E_NOT_SUPPORTED, ("The selected exception is masked"));
             WRITE_UINT32(p_FmPcd->p_FmPcdPlcr->p_FmPcdPlcrRegs->fmpl_ifr, FM_PCD_PLCR_ATOMIC_ACTION_COMPLETE);
             break;
-        default:
-            RETURN_ERROR(MINOR, E_NOT_SUPPORTED, ("The selected exception may not be forced"));
     }
 
     return E_OK;
@@ -2130,11 +2116,9 @@ t_Error FM_PCD_ModifyCounter(t_Handle h_FmPcd, e_FmPcdCounters counter, uint32_t
         case (e_FM_PCD_PLCR_COUNTERS_LENGTH_MISMATCH):
               WRITE_UINT32(p_FmPcd->p_FmPcdPlcr->p_FmPcdPlcrRegs->fmpl_flmcnt, value);
             break;
-        default:
-            RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Unsupported type of counter"));
     }
 
-return E_OK;
+    return E_OK;
 }
 
 t_Handle FM_PCD_GetHcPort(t_Handle h_FmPcd)
diff --git a/drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fm_pcd.h b/drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fm_pcd.h
index 138145f..27ec9c5 100644
--- a/drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fm_pcd.h
+++ b/drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fm_pcd.h
@@ -127,7 +127,7 @@ switch (exception){                                                 \
 #endif /* defined(__MWERKS__) && ... */
 
 
-typedef _Packed struct {
+typedef struct {
 /* General Configuration and Status Registers */
     volatile uint32_t fmpl_gcr;         /* 0x000 FMPL_GCR  - FM Policer General Configuration */
     volatile uint32_t fmpl_gsr;         /* 0x004 FMPL_GSR  - FM Policer Global Status Register */
@@ -158,7 +158,7 @@ typedef _Packed struct {
     volatile uint32_t fmpl_dpmr;        /* 0x200 FMPL_DPMR - FM Policer Default Mapping Register */
     volatile uint32_t fmpl_pmr[63];     /*+default 0x204-0x2FF FMPL_PMR1 - FMPL_PMR63, - FM Policer Profile Mapping Registers.
                                            (for port-ID 1-11, only for supported Port-ID registers) */
-} _PackedType t_FmPcdPlcrRegs;
+} t_FmPcdPlcrRegs;
 
 #if defined(__MWERKS__) && !defined(__GNUC__)
 #pragma pack(pop)
@@ -238,11 +238,11 @@ typedef struct {
 #endif
 } t_FmPcdKgScheme;
 
-typedef _Packed union {
+typedef union {
     struct fman_kg_scheme_regs schemeRegs;
     struct fman_kg_pe_regs portRegs;
     struct fman_kg_cp_regs clsPlanRegs;
-} _PackedType u_FmPcdKgIndirectAccessRegs;
+} u_FmPcdKgIndirectAccessRegs;
 
 typedef struct {
     struct fman_kg_regs *p_FmPcdKgRegs;
diff --git a/drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fm_plcr.c b/drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fm_plcr.c
index e4eeddc..a28b363 100644
--- a/drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fm_plcr.c
+++ b/drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fm_plcr.c
@@ -216,7 +216,7 @@ static void GetInfoRateReg(e_FmPcdPlcrRateMode  rateMode,
 
 /* .......... */
 
-static void CalcRates(t_Handle                              h_FmPcd,
+static void CalcRates(uint32_t                              bitFor1Micro,
                       t_FmPcdPlcrNonPassthroughAlgParams    *p_NonPassthroughAlgParam,
                       uint32_t                              *cir,
                       uint32_t                              *cbs,
@@ -224,14 +224,12 @@ static void CalcRates(t_Handle                              h_FmPcd,
                       uint32_t                              *pbs_ebs,
                       uint32_t                              *fpp)
 {
-    t_FmPcd     *p_FmPcd = (t_FmPcd*)h_FmPcd;
     uint64_t    integer, fraction;
-    uint32_t    temp, tsuInTenthNanos, bitFor1Micro;
+    uint32_t    temp, tsuInTenthNanos;
     uint8_t     fppShift=0;
 
-    bitFor1Micro = FmGetTimeStampScale(p_FmPcd->h_Fm);  /* TimeStamp per nano seconds units */
     /* we want the tsu to count 10 nano for better precision normally tsu is 3.9 nano, now we will get 39 */
-    tsuInTenthNanos = (uint32_t)(1000*10/(1<<bitFor1Micro));
+    tsuInTenthNanos = (uint32_t)(1000*10/(1 << bitFor1Micro));
 
     /* we choose the faster rate to calibrate fpp */
     /* The meaning of this step:
@@ -337,10 +335,14 @@ static t_Error BuildProfileRegs(t_FmPcd                     *p_FmPcd,
                                 t_FmPcdPlcrProfileRegs      *p_PlcrRegs)
 {
     t_Error                 err = E_OK;
-    uint32_t                pemode, gnia, ynia, rnia;
+    uint32_t                pemode, gnia, ynia, rnia, bitFor1Micro;
 
     ASSERT_COND(p_FmPcd);
 
+    bitFor1Micro = FmGetTimeStampScale(p_FmPcd->h_Fm);
+    if (bitFor1Micro == 0)
+    RETURN_ERROR(MAJOR, E_NOT_AVAILABLE, ("Timestamp scale"));
+
 /* Set G, Y, R Nia */
     err = SetProfileNia(p_FmPcd, p_ProfileParams->nextEngineOnGreen,  &(p_ProfileParams->paramsOnGreen), &gnia);
     if (err)
@@ -485,7 +487,7 @@ cont_rfc:
             {
                 uint32_t cir=0, cbs=0, pir_eir=0, pbs_ebs=0, fpp=0;
 
-                CalcRates(p_FmPcd, &p_ProfileParams->nonPassthroughAlgParams, &cir, &cbs, &pir_eir, &pbs_ebs, &fpp);
+                CalcRates(bitFor1Micro, &p_ProfileParams->nonPassthroughAlgParams, &cir, &cbs, &pir_eir, &pbs_ebs, &fpp);
 
                 /*  Set Committed Information Rate (CIR) */
                 p_PlcrRegs->fmpl_pecir = cir;
@@ -1562,7 +1564,6 @@ t_Error FM_PCD_PlcrDumpRegs(t_Handle h_FmPcd)
     DUMP_VAR(p_FmPcd->p_FmPcdPlcr->p_FmPcdPlcrRegs,fmpl_rypcnt);
     DUMP_VAR(p_FmPcd->p_FmPcdPlcr->p_FmPcdPlcrRegs,fmpl_tpcnt);
     DUMP_VAR(p_FmPcd->p_FmPcdPlcr->p_FmPcdPlcrRegs,fmpl_flmcnt);
-
     DUMP_VAR(p_FmPcd->p_FmPcdPlcr->p_FmPcdPlcrRegs,fmpl_serc);
     DUMP_VAR(p_FmPcd->p_FmPcdPlcr->p_FmPcdPlcrRegs,fmpl_upcr);
     DUMP_VAR(p_FmPcd->p_FmPcdPlcr->p_FmPcdPlcrRegs,fmpl_dpmr);
@@ -1625,6 +1626,11 @@ t_Handle FM_PCD_PlcrProfileSet(t_Handle     h_FmPcd,
                                                     p_ProfileParams->id.newParams.h_FmPort,
                                                     p_ProfileParams->id.newParams.relativeProfileId,
                                                     &absoluteProfileId);
+        if (err)
+        {
+             REPORT_ERROR(MAJOR, err, NO_MSG);
+             return NULL;
+        }
 
          if (absoluteProfileId >= FM_PCD_PLCR_NUM_ENTRIES)
          {
diff --git a/drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fm_prs.c b/drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fm_prs.c
index 73f3b223..e6ac6df 100644
--- a/drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fm_prs.c
+++ b/drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fm_prs.c
@@ -118,6 +118,12 @@ t_Handle PrsConfig(t_FmPcd *p_FmPcd,t_FmPcdParams *p_FmPcdParams)
     return p_FmPcdPrs;
 }
 
+#if ((DPAA_VERSION == 10) && defined(FM_CAPWAP_SUPPORT))
+    static uint8_t             swPrsPatch[] = SW_PRS_UDP_LITE_PATCH;
+#else
+    static uint8_t             swPrsPatch[] = SW_PRS_OFFLOAD_PATCH;
+#endif /* FM_CAPWAP_SUPPORT */
+
 t_Error PrsInit(t_FmPcd *p_FmPcd)
 {
     t_FmPcdDriverParam  *p_Param = p_FmPcd->p_FmPcdDriverParam;
@@ -125,11 +131,6 @@ t_Error PrsInit(t_FmPcd *p_FmPcd)
     uint32_t            *p_LoadTarget = (uint32_t *)PTR_MOVE(p_FmPcd->p_FmPcdPrs->p_SwPrsCode,
                                                              FM_PCD_SW_PRS_SIZE-FM_PCD_PRS_SW_PATCHES_SIZE);
     struct fman_prs_regs *PrsRegs = (struct fman_prs_regs *)p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs;
-#if ((DPAA_VERSION == 10) && defined(FM_CAPWAP_SUPPORT))
-    uint8_t             swPrsPatch[] = SW_PRS_UDP_LITE_PATCH;
-#else
-    uint8_t             swPrsPatch[] = SW_PRS_OFFLOAD_PATCH;
-#endif /* FM_CAPWAP_SUPPORT */
     uint32_t            i;
 
     ASSERT_COND(sizeof(swPrsPatch) <= (FM_PCD_PRS_SW_PATCHES_SIZE-FM_PCD_PRS_SW_TAIL_SIZE));
diff --git a/drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fm_replic.c b/drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fm_replic.c
index 7f84080..ee82f73 100644
--- a/drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fm_replic.c
+++ b/drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fm_replic.c
@@ -380,10 +380,11 @@ static t_Error AllocMember(t_FmPcdFrmReplicGroup *p_ReplicGroup)
         (t_AdOfTypeResult*)FM_MURAM_AllocMem(h_Muram,
                                              FM_PCD_CC_AD_ENTRY_SIZE,
                                              FM_PCD_CC_AD_TABLE_ALIGN);
-
     if (!p_CurrentMember->p_MemberAd)
+    {
+        XX_Free(p_CurrentMember);
         RETURN_ERROR(MAJOR, E_NO_MEMORY, ("member AD table"));
-
+    }
     IOMemSet32((uint8_t*)p_CurrentMember->p_MemberAd, 0, FM_PCD_CC_AD_ENTRY_SIZE);
 
     /* Add the new member to the available members list */
@@ -591,7 +592,6 @@ static void DeleteGroup(t_FmPcdFrmReplicGroup *p_ReplicGroup)
 
         /* free the replicator group */
         XX_Free(p_ReplicGroup);
-        p_ReplicGroup = NULL;
     }
 }
 
@@ -833,13 +833,8 @@ t_Error FM_PCD_FrmReplicAddMember(t_Handle                  h_ReplicGroup,
 
     /* group lock */
     err = FrmReplicGroupTryLock(p_ReplicGroup);
-    if (err)
-    {
-        if (GET_ERROR_TYPE(err) == E_BUSY)
-            return ERROR_CODE(E_BUSY);
-        else
-            RETURN_ERROR(MAJOR, err, ("try lock in Add member"));
-    }
+    if (GET_ERROR_TYPE(err) == E_BUSY)
+        return ERROR_CODE(E_BUSY);
 
     if (memberIndex > p_ReplicGroup->numOfEntries)
     {
@@ -954,13 +949,8 @@ t_Error FM_PCD_FrmReplicRemoveMember(t_Handle   h_ReplicGroup,
 
     /* lock */
     err = FrmReplicGroupTryLock(p_ReplicGroup);
-    if (err)
-    {
-        if (GET_ERROR_TYPE(err) == E_BUSY)
-            return ERROR_CODE(E_BUSY);
-        else
-            RETURN_ERROR(MAJOR, err, ("try lock in Remove member"));
-    }
+    if (GET_ERROR_TYPE(err) == E_BUSY)
+        return ERROR_CODE(E_BUSY);
 
     if (memberIndex >= p_ReplicGroup->numOfEntries)
         RETURN_ERROR(MAJOR, E_INVALID_SELECTION, ("member index to remove"));
diff --git a/drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fm_replic.h b/drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fm_replic.h
index 7e4224b..0e8e8bc 100644
--- a/drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fm_replic.h
+++ b/drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fm_replic.h
@@ -68,13 +68,13 @@
 } e_SourceTdOption;
 */
 
-typedef _Packed struct
+typedef struct
 {
     volatile uint32_t type;
     volatile uint32_t frGroupPointer;
     volatile uint32_t operationCode;
     volatile uint32_t reserved;
-} _PackedType t_FrmReplicGroupSourceAd;
+} t_FrmReplicGroupSourceAd;
 
 typedef struct t_FmPcdFrmReplicMember
 {
diff --git a/drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fman_kg.c b/drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fman_kg.c
index 6e77c9386..49b86e8 100644
--- a/drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fman_kg.c
+++ b/drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fman_kg.c
@@ -267,7 +267,7 @@ void fman_kg_write_sp(struct fman_kg_regs *regs, uint32_t sp, bool add)
 
 	struct fman_kg_pe_regs *kgpe_regs;
 	uint32_t tmp;
-	
+
 	kgpe_regs = (struct fman_kg_pe_regs *)&(regs->fmkg_indirect[0]);
 	tmp = ioread32be(&kgpe_regs->fmkg_pe_sp);
 
@@ -283,7 +283,7 @@ void fman_kg_write_sp(struct fman_kg_regs *regs, uint32_t sp, bool add)
 void fman_kg_write_cpp(struct fman_kg_regs *regs, uint32_t cpp)
 {
 	struct fman_kg_pe_regs *kgpe_regs;
-	
+
 	kgpe_regs = (struct fman_kg_pe_regs *)&(regs->fmkg_indirect[0]);
 
 	iowrite32be(cpp, &kgpe_regs->fmkg_pe_cpp);
@@ -318,7 +318,7 @@ void fman_kg_init(struct fman_kg_regs *regs,
 {
 	uint32_t tmp;
 	int i;
-	
+
 	iowrite32be(FM_EX_KG_DOUBLE_ECC | FM_EX_KG_KEYSIZE_OVERFLOW,
 			&regs->fmkg_eer);
 
@@ -328,7 +328,7 @@ void fman_kg_init(struct fman_kg_regs *regs,
 
 	if (exceptions & FM_EX_KG_KEYSIZE_OVERFLOW)
 		tmp |= FM_EX_KG_KEYSIZE_OVERFLOW;
-	
+
 	iowrite32be(tmp, &regs->fmkg_eeer);
 	iowrite32be(0, &regs->fmkg_fdor);
 	iowrite32be(0, &regs->fmkg_gdv0r);
@@ -471,7 +471,7 @@ int fman_kg_build_scheme(struct fman_kg_scheme_params *params,
 		tmp_reg |= (uint32_t)params->cc_params.base_offset <<
 				FMAN_KG_SCH_MODE_CCOBASE_SHIFT;
 	}
-	
+
 	tmp_reg |= FMAN_KG_SCH_MODE_EN;
 	scheme_regs->kgse_mode = tmp_reg;
 
@@ -644,7 +644,7 @@ int fman_kg_build_scheme(struct fman_kg_scheme_params *params,
 
 	/* Policer Profile register */
 	if (params->policer_params.bypass_pp_gen) {
-		tmp_reg = FMAN_KG_SCH_PP_NO_GEN;
+		tmp_reg = 0;
 	} else {
 		/* Lower 8 bits of 24-bits extracted from hash result
 		 * are used for policer profile generation.
@@ -862,7 +862,7 @@ int fman_kg_build_bind_cls_plans(uint8_t grp_base,
 					uint32_t *bind_cls_plans)
 {
 	/* Check grp_base and grp_mask are 5-bits values */
-	if ((grp_base & ~0x0000001F) || (grp_mask & !0x0000001F))
+	if ((grp_base & ~0x0000001F) || (grp_mask & ~0x0000001F))
 		return -EINVAL;
 
 	*bind_cls_plans = (uint32_t) ((grp_mask << FMAN_KG_PE_CPP_MASK_SHIFT) | grp_base);
@@ -879,7 +879,7 @@ int fman_kg_write_bind_cls_plans(struct fman_kg_regs *regs,
 	int err;
 
 	kg_pe_regs = (struct fman_kg_pe_regs *)&(regs->fmkg_indirect[0]);
-	
+
 	iowrite32be(bind_cls_plans, &kg_pe_regs->fmkg_pe_cpp);
 
 	tmp_reg = build_ar_bind_cls_plan(hwport_id, TRUE);