diff options
| author | Mandy Lavi <mandy.lavi@freescale.com> | 2014-07-15 16:09:49 (GMT) |
|---|---|---|
| committer | Matthew Weigel <Matthew.Weigel@freescale.com> | 2014-12-11 18:39:15 (GMT) |
| commit | 46a570f8d99c33121870421252cc153d394bc063 (patch) | |
| tree | 3e80b1d3e9112b75d432ef7585568e4cf4d42447 /drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fm_manip.c | |
| parent | 1dda6a67c62d681f2e0fd3f54172308644cbb6b4 (diff) | |
| download | linux-fsl-qoriq-46a570f8d99c33121870421252cc153d394bc063.tar.xz | |
fmd: tmp capwap support
Signed-off-by: Mandy Lavi <mandy.lavi@freescale.com>
Change-Id: I426f384c05479a5ddc1607e9b8fa92d972c612ce
Reviewed-on: http://git.am.freescale.net:8181/21432
Reviewed-by: Jiafei Pan <Jiafei.Pan@freescale.com>
Reviewed-by: Shengzhou Liu <Shengzhou.Liu@freescale.com>
Tested-by: Shengzhou Liu <Shengzhou.Liu@freescale.com>
Diffstat (limited to 'drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fm_manip.c')
| -rw-r--r-- | drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fm_manip.c | 5056 |
1 files changed, 3149 insertions, 1907 deletions
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 1027783..48cadee 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 @@ -35,7 +35,7 @@ @File fm_manip.c @Description FM PCD manip ... -*//***************************************************************************/ + *//***************************************************************************/ #include "std_ext.h" #include "error_ext.h" #include "string_ext.h" @@ -49,13 +49,12 @@ #include "fm_hc.h" #include "fm_manip.h" - /****************************************/ /* static functions */ /****************************************/ static t_Handle GetManipInfo(t_FmPcdManip *p_Manip, e_ManipInfo manipInfo) { - t_FmPcdManip *p_CurManip = p_Manip; + t_FmPcdManip *p_CurManip = p_Manip; if (!MANIP_IS_UNIFIED(p_Manip)) p_CurManip = p_Manip; @@ -78,10 +77,11 @@ static t_Handle GetManipInfo(t_FmPcdManip *p_Manip, e_ManipInfo manipInfo) return NULL; } } -static uint16_t GetHmctSize(t_FmPcdManip *p_Manip) + +static uint16_t GetHmctSize(t_FmPcdManip *p_Manip) { - uint16_t size = 0; - t_FmPcdManip *p_CurManip = p_Manip; + uint16_t size = 0; + t_FmPcdManip *p_CurManip = p_Manip; if (!MANIP_IS_UNIFIED(p_Manip)) return p_Manip->tableSize; @@ -97,12 +97,13 @@ static uint16_t GetHmctSize(t_FmPcdManip *p_Manip) } size += p_CurManip->tableSize; /* add last size */ - return(size); + return (size); } -static uint16_t GetDataSize(t_FmPcdManip *p_Manip) + +static uint16_t GetDataSize(t_FmPcdManip *p_Manip) { - uint16_t size = 0; - t_FmPcdManip *p_CurManip = p_Manip; + uint16_t size = 0; + t_FmPcdManip *p_CurManip = p_Manip; if (!MANIP_IS_UNIFIED(p_Manip)) return p_Manip->dataSize; @@ -118,111 +119,179 @@ static uint16_t GetDataSize(t_FmPcdManip *p_Manip) } size += p_CurManip->dataSize; /* add last size */ - return(size); + return (size); } -static t_Error CalculateTableSize(t_FmPcdManipParams *p_FmPcdManipParams, uint16_t *p_TableSize, uint8_t *p_DataSize) + +static t_Error CalculateTableSize(t_FmPcdManipParams *p_FmPcdManipParams, + uint16_t *p_TableSize, uint8_t *p_DataSize) { uint8_t localDataSize, remain, tableSize = 0, dataSize = 0; if (p_FmPcdManipParams->u.hdr.rmv) { - switch (p_FmPcdManipParams->u.hdr.rmvParams.type){ + switch (p_FmPcdManipParams->u.hdr.rmvParams.type) + { case (e_FM_PCD_MANIP_RMV_GENERIC): + tableSize += HMCD_BASIC_SIZE; + break; case (e_FM_PCD_MANIP_RMV_BY_HDR): - /* As long as the only rmv command is the L2, no check on type is required */ - tableSize += HMCD_BASIC_SIZE; - break; + switch (p_FmPcdManipParams->u.hdr.rmvParams.u.byHdr.type) + { + case (e_FM_PCD_MANIP_RMV_BY_HDR_SPECIFIC_L2): +#if (DPAA_VERSION >= 11) + case (e_FM_PCD_MANIP_RMV_BY_HDR_CAPWAP): + case (e_FM_PCD_MANIP_RMV_BY_HDR_FROM_START): +#endif /* (DPAA_VERSION >= 11) */ + tableSize += HMCD_BASIC_SIZE; + break; + default: + RETURN_ERROR(MINOR, E_INVALID_SELECTION, + ("Unknown byHdr.type")); + } + break; default: - RETURN_ERROR(MINOR, E_INVALID_SELECTION, ("Unknown rmvParams.type")); + RETURN_ERROR(MINOR, E_INVALID_SELECTION, + ("Unknown rmvParams.type")); } } if (p_FmPcdManipParams->u.hdr.insrt) { - switch (p_FmPcdManipParams->u.hdr.insrtParams.type){ + switch (p_FmPcdManipParams->u.hdr.insrtParams.type) + { case (e_FM_PCD_MANIP_INSRT_GENERIC): - remain = (uint8_t)(p_FmPcdManipParams->u.hdr.insrtParams.u.generic.size % 4); + remain = + (uint8_t)(p_FmPcdManipParams->u.hdr.insrtParams.u.generic.size + % 4); if (remain) - localDataSize = (uint8_t)(p_FmPcdManipParams->u.hdr.insrtParams.u.generic.size + 4 - remain); + localDataSize = + (uint8_t)(p_FmPcdManipParams->u.hdr.insrtParams.u.generic.size + + 4 - remain); else - localDataSize = p_FmPcdManipParams->u.hdr.insrtParams.u.generic.size; + localDataSize = + p_FmPcdManipParams->u.hdr.insrtParams.u.generic.size; tableSize += (uint8_t)(HMCD_BASIC_SIZE + localDataSize); - break; + break; case (e_FM_PCD_MANIP_INSRT_BY_HDR): - /* As long as the only insert command is the internal L2, no check on type is required */ - tableSize += HMCD_BASIC_SIZE+HMCD_PTR_SIZE; - if (p_FmPcdManipParams->u.hdr.insrtParams.u.byHdr.type == e_FM_PCD_MANIP_INSRT_BY_HDR_SPECIFIC_L2) - switch (p_FmPcdManipParams->u.hdr.insrtParams.u.byHdr.u.specificL2Params.specificL2) - { - case (e_FM_PCD_MANIP_HDR_INSRT_MPLS): - dataSize += p_FmPcdManipParams->u.hdr.insrtParams.u.byHdr.u.specificL2Params.size; + { + switch (p_FmPcdManipParams->u.hdr.insrtParams.u.byHdr.type) + { + + case (e_FM_PCD_MANIP_INSRT_BY_HDR_SPECIFIC_L2): + tableSize += HMCD_BASIC_SIZE + HMCD_PTR_SIZE; + switch (p_FmPcdManipParams->u.hdr.insrtParams.u.byHdr.u.specificL2Params.specificL2) + { + case (e_FM_PCD_MANIP_HDR_INSRT_MPLS): + dataSize += + p_FmPcdManipParams->u.hdr.insrtParams.u.byHdr.u.specificL2Params.size; + break; + default: + RETURN_ERROR(MINOR, E_NOT_SUPPORTED, NO_MSG); + } break; - default: - RETURN_ERROR(MINOR, E_NOT_SUPPORTED, NO_MSG); - } - break; +#if (DPAA_VERSION >= 11) + case (e_FM_PCD_MANIP_INSRT_BY_HDR_IP): + tableSize += + (HMCD_BASIC_SIZE + HMCD_PTR_SIZE + + HMCD_PARAM_SIZE + + p_FmPcdManipParams->u.hdr.insrtParams.u.byHdr.u.ipParams.insrt.size); + dataSize += 2; + break; + + case (e_FM_PCD_MANIP_INSRT_BY_HDR_UDP): + case (e_FM_PCD_MANIP_INSRT_BY_HDR_UDP_LITE): + tableSize += (HMCD_BASIC_SIZE + HMCD_L4_HDR_SIZE); + + break; + + case (e_FM_PCD_MANIP_INSRT_BY_HDR_CAPWAP): + tableSize += + (HMCD_BASIC_SIZE + + p_FmPcdManipParams->u.hdr.insrtParams.u.byHdr.u.insrt.size); + break; +#endif /* (DPAA_VERSION >= 11) */ + default: + RETURN_ERROR(MINOR, E_INVALID_SELECTION, + ("Unknown byHdr.type")); + } + } + break; default: - RETURN_ERROR(MINOR, E_INVALID_SELECTION, ("Unknown insrtParams.type")); + RETURN_ERROR(MINOR, E_INVALID_SELECTION, + ("Unknown insrtParams.type")); } } + if (p_FmPcdManipParams->u.hdr.fieldUpdate) { - switch (p_FmPcdManipParams->u.hdr.fieldUpdateParams.type){ + switch (p_FmPcdManipParams->u.hdr.fieldUpdateParams.type) + { case (e_FM_PCD_MANIP_HDR_FIELD_UPDATE_VLAN): tableSize += HMCD_BASIC_SIZE; - if (p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.vlan.updateType == - e_FM_PCD_MANIP_HDR_FIELD_UPDATE_DSCP_TO_VLAN) + if (p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.vlan.updateType + == e_FM_PCD_MANIP_HDR_FIELD_UPDATE_DSCP_TO_VLAN) { tableSize += HMCD_PTR_SIZE; dataSize += DSCP_TO_VLAN_TABLE_SIZE; } - break; + break; case (e_FM_PCD_MANIP_HDR_FIELD_UPDATE_IPV4): tableSize += HMCD_BASIC_SIZE; - if (p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.ipv4.validUpdates & HDR_MANIP_IPV4_ID) + if (p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.ipv4.validUpdates + & HDR_MANIP_IPV4_ID) { tableSize += HMCD_PARAM_SIZE; dataSize += 2; } - if (p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.ipv4.validUpdates & HDR_MANIP_IPV4_SRC) + if (p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.ipv4.validUpdates + & HDR_MANIP_IPV4_SRC) tableSize += HMCD_IPV4_ADDR_SIZE; - if (p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.ipv4.validUpdates & HDR_MANIP_IPV4_DST) + if (p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.ipv4.validUpdates + & HDR_MANIP_IPV4_DST) tableSize += HMCD_IPV4_ADDR_SIZE; - break; + break; case (e_FM_PCD_MANIP_HDR_FIELD_UPDATE_IPV6): tableSize += HMCD_BASIC_SIZE; - if (p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.ipv4.validUpdates & HDR_MANIP_IPV6_SRC) + if (p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.ipv4.validUpdates + & HDR_MANIP_IPV6_SRC) tableSize += HMCD_IPV6_ADDR_SIZE; - if (p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.ipv4.validUpdates & HDR_MANIP_IPV6_DST) + if (p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.ipv4.validUpdates + & HDR_MANIP_IPV6_DST) tableSize += HMCD_IPV6_ADDR_SIZE; - break; + break; case (e_FM_PCD_MANIP_HDR_FIELD_UPDATE_TCP_UDP): - if (p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.tcpUdp.validUpdates == HDR_MANIP_TCP_UDP_CHECKSUM) + if (p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.tcpUdp.validUpdates + == HDR_MANIP_TCP_UDP_CHECKSUM) /* we implement this case with the update-checksum descriptor */ tableSize += HMCD_BASIC_SIZE; else /* we implement this case with the TCP/UDP-update descriptor */ tableSize += HMCD_BASIC_SIZE + HMCD_PARAM_SIZE; - break; + break; default: - RETURN_ERROR(MINOR, E_INVALID_SELECTION, ("Unknown fieldUpdateParams.type")); + RETURN_ERROR(MINOR, E_INVALID_SELECTION, + ("Unknown fieldUpdateParams.type")); } } if (p_FmPcdManipParams->u.hdr.custom) { - switch (p_FmPcdManipParams->u.hdr.customParams.type){ + switch (p_FmPcdManipParams->u.hdr.customParams.type) + { case (e_FM_PCD_MANIP_HDR_CUSTOM_IP_REPLACE): { tableSize += HMCD_BASIC_SIZE + HMCD_PARAM_SIZE + HMCD_PARAM_SIZE; - dataSize += p_FmPcdManipParams->u.hdr.customParams.u.ipHdrReplace.hdrSize; - if ((p_FmPcdManipParams->u.hdr.customParams.u.ipHdrReplace.replaceType == e_FM_PCD_MANIP_HDR_CUSTOM_REPLACE_IPV6_BY_IPV4) && - (p_FmPcdManipParams->u.hdr.customParams.u.ipHdrReplace.updateIpv4Id)) + dataSize += + p_FmPcdManipParams->u.hdr.customParams.u.ipHdrReplace.hdrSize; + if ((p_FmPcdManipParams->u.hdr.customParams.u.ipHdrReplace.replaceType + == e_FM_PCD_MANIP_HDR_CUSTOM_REPLACE_IPV6_BY_IPV4) + && (p_FmPcdManipParams->u.hdr.customParams.u.ipHdrReplace.updateIpv4Id)) dataSize += 2; } - break; + break; default: - RETURN_ERROR(MINOR, E_INVALID_SELECTION, ("Unknown customParams.type")); + RETURN_ERROR(MINOR, E_INVALID_SELECTION, + ("Unknown customParams.type")); } } @@ -232,74 +301,238 @@ static t_Error CalculateTableSize(t_FmPcdManipParams *p_FmPcdManipParams, uint16 return E_OK; } -static t_Error BuildHmct(t_FmPcdManip *p_Manip, t_FmPcdManipParams *p_FmPcdManipParams, uint8_t *p_DestHmct, uint8_t *p_DestData, bool new) +static t_Error GetPrOffsetByHeaderOrField(t_FmManipHdrInfo *p_HdrInfo, + uint8_t *parseArrayOffset) { - uint32_t *p_TmpHmct = (uint32_t*)p_DestHmct, *p_LocalData; - uint32_t tmpReg=0, *p_Last = NULL; - uint8_t remain, i, size=0, origSize, *p_UsrData = NULL, *p_TmpData = p_DestData; - t_Handle h_FmPcd = p_Manip->h_FmPcd; - uint8_t j=0; + e_NetHeaderType hdr = p_HdrInfo->hdr; + e_FmPcdHdrIndex hdrIndex = p_HdrInfo->hdrIndex; + bool byField = p_HdrInfo->byField; + t_FmPcdFields field; + + if (byField) + field = p_HdrInfo->fullField; + + if (byField) + { + switch (hdr) + { + case (HEADER_TYPE_ETH): + switch (field.eth) + { + case (NET_HEADER_FIELD_ETH_TYPE): + *parseArrayOffset = CC_PC_PR_ETYPE_LAST_OFFSET; + break; + default: + RETURN_ERROR( + MAJOR, + E_NOT_SUPPORTED, + ("Header manipulation of the type Ethernet with this field not supported")); + } + break; + case (HEADER_TYPE_VLAN): + switch (field.vlan) + { + case (NET_HEADER_FIELD_VLAN_TCI): + if ((hdrIndex == e_FM_PCD_HDR_INDEX_NONE) + || (hdrIndex == e_FM_PCD_HDR_INDEX_1)) + *parseArrayOffset = CC_PC_PR_VLAN1_OFFSET; + else + if (hdrIndex == e_FM_PCD_HDR_INDEX_LAST) + *parseArrayOffset = CC_PC_PR_VLAN2_OFFSET; + break; + default: + RETURN_ERROR( + MAJOR, + E_NOT_SUPPORTED, + ("Header manipulation of the type VLAN with this field not supported")); + } + break; + default: + RETURN_ERROR( + MAJOR, + E_NOT_SUPPORTED, + ("Header manipulation of this header by field not supported")); + } + } + else + { + switch (hdr) + { + case (HEADER_TYPE_ETH): + *parseArrayOffset = (uint8_t)CC_PC_PR_ETH_OFFSET; + break; + case (HEADER_TYPE_USER_DEFINED_SHIM1): + *parseArrayOffset = (uint8_t)CC_PC_PR_USER_DEFINED_SHIM1_OFFSET; + break; + case (HEADER_TYPE_USER_DEFINED_SHIM2): + *parseArrayOffset = (uint8_t)CC_PC_PR_USER_DEFINED_SHIM2_OFFSET; + break; + case (HEADER_TYPE_LLC_SNAP): + *parseArrayOffset = CC_PC_PR_USER_LLC_SNAP_OFFSET; + break; + case (HEADER_TYPE_PPPoE): + *parseArrayOffset = CC_PC_PR_PPPOE_OFFSET; + break; + case (HEADER_TYPE_MPLS): + if ((hdrIndex == e_FM_PCD_HDR_INDEX_NONE) + || (hdrIndex == e_FM_PCD_HDR_INDEX_1)) + *parseArrayOffset = CC_PC_PR_MPLS1_OFFSET; + else + if (hdrIndex == e_FM_PCD_HDR_INDEX_LAST) + *parseArrayOffset = CC_PC_PR_MPLS_LAST_OFFSET; + break; + case (HEADER_TYPE_IPv4): + case (HEADER_TYPE_IPv6): + if ((hdrIndex == e_FM_PCD_HDR_INDEX_NONE) + || (hdrIndex == e_FM_PCD_HDR_INDEX_1)) + *parseArrayOffset = CC_PC_PR_IP1_OFFSET; + else + if (hdrIndex == e_FM_PCD_HDR_INDEX_2) + *parseArrayOffset = CC_PC_PR_IP_LAST_OFFSET; + break; + case (HEADER_TYPE_MINENCAP): + *parseArrayOffset = CC_PC_PR_MINENC_OFFSET; + break; + case (HEADER_TYPE_GRE): + *parseArrayOffset = CC_PC_PR_GRE_OFFSET; + break; + case (HEADER_TYPE_TCP): + case (HEADER_TYPE_UDP): + case (HEADER_TYPE_IPSEC_AH): + case (HEADER_TYPE_IPSEC_ESP): + case (HEADER_TYPE_DCCP): + case (HEADER_TYPE_SCTP): + *parseArrayOffset = CC_PC_PR_L4_OFFSET; + break; + case (HEADER_TYPE_CAPWAP): + case (HEADER_TYPE_CAPWAP_DTLS): + *parseArrayOffset = CC_PC_PR_NEXT_HEADER_OFFSET; + break; + default: + RETURN_ERROR( + MAJOR, + E_NOT_SUPPORTED, + ("Header manipulation of this header is not supported")); + } + } + return E_OK; +} + +static t_Error BuildHmct(t_FmPcdManip *p_Manip, + t_FmPcdManipParams *p_FmPcdManipParams, + uint8_t *p_DestHmct, uint8_t *p_DestData, bool new) +{ + uint32_t *p_TmpHmct = (uint32_t*)p_DestHmct, *p_LocalData; + uint32_t tmpReg = 0, *p_Last = NULL, tmp_ipv6_addr; + uint8_t remain, i, size = 0, origSize, *p_UsrData = NULL, *p_TmpData = + p_DestData; + t_Handle h_FmPcd = p_Manip->h_FmPcd; + uint8_t j = 0; if (p_FmPcdManipParams->u.hdr.rmv) { - if (p_FmPcdManipParams->u.hdr.rmvParams.type == e_FM_PCD_MANIP_RMV_GENERIC) + if (p_FmPcdManipParams->u.hdr.rmvParams.type + == e_FM_PCD_MANIP_RMV_GENERIC) { /* initialize HMCD */ tmpReg = (uint32_t)(HMCD_OPCODE_GENERIC_RMV) << HMCD_OC_SHIFT; /* tmp, should be conditional */ - tmpReg |= p_FmPcdManipParams->u.hdr.rmvParams.u.generic.offset << HMCD_RMV_OFFSET_SHIFT; - tmpReg |= p_FmPcdManipParams->u.hdr.rmvParams.u.generic.size << HMCD_RMV_SIZE_SHIFT; + tmpReg |= p_FmPcdManipParams->u.hdr.rmvParams.u.generic.offset + << HMCD_RMV_OFFSET_SHIFT; + tmpReg |= p_FmPcdManipParams->u.hdr.rmvParams.u.generic.size + << HMCD_RMV_SIZE_SHIFT; } - else if (p_FmPcdManipParams->u.hdr.rmvParams.type == e_FM_PCD_MANIP_RMV_BY_HDR) - { - uint8_t hmcdOpt; - if (!p_FmPcdManipParams->u.hdr.rmvParams.u.byHdr.type == e_FM_PCD_MANIP_RMV_BY_HDR_SPECIFIC_L2) - RETURN_ERROR(MINOR, E_NOT_SUPPORTED, NO_MSG); + else + if (p_FmPcdManipParams->u.hdr.rmvParams.type + == e_FM_PCD_MANIP_RMV_BY_HDR) + { + switch (p_FmPcdManipParams->u.hdr.rmvParams.u.byHdr.type) + { + case (e_FM_PCD_MANIP_RMV_BY_HDR_SPECIFIC_L2): + { + uint8_t hmcdOpt; - /* initialize HMCD */ - tmpReg = (uint32_t)(HMCD_OPCODE_L2_RMV) << HMCD_OC_SHIFT; + /* initialize HMCD */ + tmpReg = (uint32_t)(HMCD_OPCODE_L2_RMV) << HMCD_OC_SHIFT; + + switch (p_FmPcdManipParams->u.hdr.rmvParams.u.byHdr.u.specificL2) + { + case (e_FM_PCD_MANIP_HDR_RMV_ETHERNET): + hmcdOpt = HMCD_RMV_L2_ETHERNET; + break; + case (e_FM_PCD_MANIP_HDR_RMV_STACKED_QTAGS): + hmcdOpt = HMCD_RMV_L2_STACKED_QTAGS; + break; + case (e_FM_PCD_MANIP_HDR_RMV_ETHERNET_AND_MPLS): + hmcdOpt = HMCD_RMV_L2_ETHERNET_AND_MPLS; + break; + case (e_FM_PCD_MANIP_HDR_RMV_MPLS): + hmcdOpt = HMCD_RMV_L2_MPLS; + break; + default: + RETURN_ERROR(MINOR, E_NOT_SUPPORTED, NO_MSG); + } + tmpReg |= hmcdOpt << HMCD_L2_MODE_SHIFT; + break; + } +#if (DPAA_VERSION >= 11) + case (e_FM_PCD_MANIP_RMV_BY_HDR_CAPWAP): + tmpReg = (uint32_t)(HMCD_OPCODE_CAPWAP_RMV) + << HMCD_OC_SHIFT; + break; + case (e_FM_PCD_MANIP_RMV_BY_HDR_FROM_START): + { + uint8_t prsArrayOffset; + t_Error err = E_OK; + + UNUSED(err); + tmpReg = (uint32_t)(HMCD_OPCODE_RMV_TILL) + << HMCD_OC_SHIFT; + + err = + GetPrOffsetByHeaderOrField( + &p_FmPcdManipParams->u.hdr.rmvParams.u.byHdr.u.hdrInfo, + &prsArrayOffset); + ASSERT_COND(!err); + /* was previously checked */ + + tmpReg |= ((uint32_t)prsArrayOffset << 16); + } + break; +#endif /* (DPAA_VERSION >= 11) */ + default: + RETURN_ERROR(MINOR, E_NOT_SUPPORTED, + ("manip header remove by hdr type!")); + } - switch (p_FmPcdManipParams->u.hdr.rmvParams.u.byHdr.u.specificL2) - { - case (e_FM_PCD_MANIP_HDR_RMV_ETHERNET): - hmcdOpt = HMCD_RMV_L2_ETHERNET; - break; - case (e_FM_PCD_MANIP_HDR_RMV_STACKED_QTAGS): - hmcdOpt = HMCD_RMV_L2_STACKED_QTAGS; - break; - case (e_FM_PCD_MANIP_HDR_RMV_ETHERNET_AND_MPLS): - hmcdOpt = HMCD_RMV_L2_ETHERNET_AND_MPLS; - break; - case (e_FM_PCD_MANIP_HDR_RMV_MPLS): - hmcdOpt = HMCD_RMV_L2_MPLS; - break; - default: - RETURN_ERROR(MINOR, E_NOT_SUPPORTED, NO_MSG); } - tmpReg |= hmcdOpt << HMCD_L2_MODE_SHIFT; - } - else - RETURN_ERROR(MINOR, E_NOT_SUPPORTED, ("manip header remove 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 */ p_Last = p_TmpHmct; /* advance to next command */ - p_TmpHmct += HMCD_BASIC_SIZE/4; + p_TmpHmct += HMCD_BASIC_SIZE / 4; } if (p_FmPcdManipParams->u.hdr.insrt) { - if (p_FmPcdManipParams->u.hdr.insrtParams.type == e_FM_PCD_MANIP_INSRT_GENERIC) + if (p_FmPcdManipParams->u.hdr.insrtParams.type + == e_FM_PCD_MANIP_INSRT_GENERIC) { /* initialize HMCD */ if (p_FmPcdManipParams->u.hdr.insrtParams.u.generic.replace) - tmpReg = (uint32_t)(HMCD_OPCODE_GENERIC_REPLACE) << HMCD_OC_SHIFT; + tmpReg = (uint32_t)(HMCD_OPCODE_GENERIC_REPLACE) + << HMCD_OC_SHIFT; else tmpReg = (uint32_t)(HMCD_OPCODE_GENERIC_INSRT) << HMCD_OC_SHIFT; - tmpReg |= p_FmPcdManipParams->u.hdr.insrtParams.u.generic.offset << HMCD_INSRT_OFFSET_SHIFT; - tmpReg |= p_FmPcdManipParams->u.hdr.insrtParams.u.generic.size << HMCD_INSRT_SIZE_SHIFT; + tmpReg |= p_FmPcdManipParams->u.hdr.insrtParams.u.generic.offset + << HMCD_INSRT_OFFSET_SHIFT; + tmpReg |= p_FmPcdManipParams->u.hdr.insrtParams.u.generic.size + << HMCD_INSRT_SIZE_SHIFT; size = p_FmPcdManipParams->u.hdr.insrtParams.u.generic.size; p_UsrData = p_FmPcdManipParams->u.hdr.insrtParams.u.generic.p_Data; @@ -308,7 +541,7 @@ static t_Error BuildHmct(t_FmPcdManip *p_Manip, t_FmPcdManipParams *p_FmPcdManip /* save a pointer to the "last" indication word */ p_Last = p_TmpHmct; - p_TmpHmct += HMCD_BASIC_SIZE/4; + p_TmpHmct += HMCD_BASIC_SIZE / 4; /* initialize data to be inserted */ /* if size is not a multiple of 4, padd with 0's */ @@ -325,232 +558,397 @@ static t_Error BuildHmct(t_FmPcdManip *p_Manip, t_FmPcdManipParams *p_FmPcdManip p_LocalData = (uint32_t*)p_UsrData; /* initialize data and advance pointer to next command */ - for (i = 0; i<size/4 ; i++, p_TmpHmct += HMCD_BASIC_SIZE/4) + for (i = 0; i < size / 4; i++, p_TmpHmct += HMCD_BASIC_SIZE / 4) WRITE_UINT32(*p_TmpHmct, *(p_LocalData+i)); if (remain) XX_Free(p_LocalData); } - else if (p_FmPcdManipParams->u.hdr.insrtParams.type == e_FM_PCD_MANIP_INSRT_BY_HDR) - { - uint8_t hmcdOpt; - if (!p_FmPcdManipParams->u.hdr.insrtParams.u.byHdr.type == e_FM_PCD_MANIP_INSRT_BY_HDR_SPECIFIC_L2) - RETURN_ERROR(MINOR, E_NOT_SUPPORTED, NO_MSG); + else + if (p_FmPcdManipParams->u.hdr.insrtParams.type + == e_FM_PCD_MANIP_INSRT_BY_HDR) + { + switch (p_FmPcdManipParams->u.hdr.insrtParams.u.byHdr.type) + { + case (e_FM_PCD_MANIP_INSRT_BY_HDR_SPECIFIC_L2): + { + uint8_t hmcdOpt; - /* initialize HMCD */ - tmpReg = (uint32_t)(HMCD_OPCODE_L2_INSRT) << HMCD_OC_SHIFT; + /* initialize HMCD */ + tmpReg = (uint32_t)(HMCD_OPCODE_L2_INSRT) + << HMCD_OC_SHIFT; - switch (p_FmPcdManipParams->u.hdr.insrtParams.u.byHdr.u.specificL2Params.specificL2) - { - case (e_FM_PCD_MANIP_HDR_INSRT_MPLS): - if (p_FmPcdManipParams->u.hdr.insrtParams.u.byHdr.u.specificL2Params.update) - hmcdOpt = HMCD_INSRT_N_UPDATE_L2_MPLS; - else - hmcdOpt = HMCD_INSRT_L2_MPLS; - break; - default: - RETURN_ERROR(MINOR, E_NOT_SUPPORTED, NO_MSG); - } - tmpReg |= hmcdOpt << HMCD_L2_MODE_SHIFT; + switch (p_FmPcdManipParams->u.hdr.insrtParams.u.byHdr.u.specificL2Params.specificL2) + { + case (e_FM_PCD_MANIP_HDR_INSRT_MPLS): + if (p_FmPcdManipParams->u.hdr.insrtParams.u.byHdr.u.specificL2Params.update) + hmcdOpt = HMCD_INSRT_N_UPDATE_L2_MPLS; + else + hmcdOpt = HMCD_INSRT_L2_MPLS; + break; + default: + RETURN_ERROR(MINOR, E_NOT_SUPPORTED, NO_MSG); + } + tmpReg |= hmcdOpt << HMCD_L2_MODE_SHIFT; + + WRITE_UINT32(*p_TmpHmct, tmpReg); + /* save a pointer to the "last" indication word */ + p_Last = p_TmpHmct; + + p_TmpHmct += HMCD_BASIC_SIZE / 4; + + /* set size and pointer of user's data */ + size = + (uint8_t)p_FmPcdManipParams->u.hdr.insrtParams.u.byHdr.u.specificL2Params.size; + + ASSERT_COND(p_TmpData); + Mem2IOCpy32( + p_TmpData, + p_FmPcdManipParams->u.hdr.insrtParams.u.byHdr.u.specificL2Params.p_Data, + size); + tmpReg = + (size << HMCD_INSRT_L2_SIZE_SHIFT) + | (uint32_t)(XX_VirtToPhys(p_TmpData) + - (((t_FmPcd*)h_FmPcd)->physicalMuramBase)); + WRITE_UINT32(*p_TmpHmct, tmpReg); + p_TmpHmct += HMCD_PTR_SIZE / 4; + p_TmpData += size; + } + break; +#if (DPAA_VERSION >= 11) + case (e_FM_PCD_MANIP_INSRT_BY_HDR_IP): + tmpReg = (uint32_t)(HMCD_OPCODE_IP_INSRT) + << HMCD_OC_SHIFT; + if (p_FmPcdManipParams->u.hdr.insrtParams.u.byHdr.u.ipParams.calcL4Checksum) + tmpReg |= HMCD_IP_L4_CS_CALC; + if (p_FmPcdManipParams->u.hdr.insrtParams.u.byHdr.u.ipParams.mappingMode + == e_FM_PCD_MANIP_HDR_QOS_MAPPING_AS_IS) + tmpReg |= HMCD_IP_OR_QOS; + tmpReg |= + p_FmPcdManipParams->u.hdr.insrtParams.u.byHdr.u.ipParams.lastPidOffset + & HMCD_IP_LAST_PID_MASK; + tmpReg |= + ((p_FmPcdManipParams->u.hdr.insrtParams.u.byHdr.u.ipParams.insrt.size + << HMCD_IP_SIZE_SHIFT) + & HMCD_IP_SIZE_MASK); + + WRITE_UINT32(*p_TmpHmct, tmpReg); + + /* save a pointer to the "last" indication word */ + p_Last = p_TmpHmct; + + p_TmpHmct += HMCD_BASIC_SIZE / 4; + + /* set IP id */ + ASSERT_COND(p_TmpData); + WRITE_UINT16( + *(uint16_t*)p_TmpData, + p_FmPcdManipParams->u.hdr.insrtParams.u.byHdr.u.ipParams.id); + WRITE_UINT32( + *p_TmpHmct, + (uint32_t)(XX_VirtToPhys(p_TmpData) - (((t_FmPcd*)p_Manip->h_FmPcd)->physicalMuramBase))); + p_TmpData += 2; + p_TmpHmct += HMCD_PTR_SIZE / 4; + p_TmpHmct += HMCD_PARAM_SIZE / 4; + + Mem2IOCpy32( + p_TmpHmct, + p_FmPcdManipParams->u.hdr.insrtParams.u.byHdr.u.ipParams.insrt.p_Data, + p_FmPcdManipParams->u.hdr.insrtParams.u.byHdr.u.ipParams.insrt.size); + p_TmpHmct += + p_FmPcdManipParams->u.hdr.insrtParams.u.byHdr.u.ipParams.insrt.size + / 4; + break; + case (e_FM_PCD_MANIP_INSRT_BY_HDR_UDP_LITE): + tmpReg = HMCD_INSRT_UDP_LITE; + case (e_FM_PCD_MANIP_INSRT_BY_HDR_UDP): + tmpReg |= (uint32_t)(HMCD_OPCODE_UDP_INSRT) + << HMCD_OC_SHIFT; + + WRITE_UINT32(*p_TmpHmct, tmpReg); + + /* save a pointer to the "last" indication word */ + p_Last = p_TmpHmct; + + p_TmpHmct += HMCD_BASIC_SIZE / 4; + + Mem2IOCpy32( + p_TmpHmct, + p_FmPcdManipParams->u.hdr.insrtParams.u.byHdr.u.insrt.p_Data, + p_FmPcdManipParams->u.hdr.insrtParams.u.byHdr.u.insrt.size); + p_TmpHmct += + p_FmPcdManipParams->u.hdr.insrtParams.u.byHdr.u.insrt.size + / 4; + break; + case (e_FM_PCD_MANIP_INSRT_BY_HDR_CAPWAP): + tmpReg = (uint32_t)(HMCD_OPCODE_CAPWAP_INSRT) + << HMCD_OC_SHIFT; + tmpReg |= HMCD_CAPWAP_INSRT; - WRITE_UINT32(*p_TmpHmct, tmpReg); - /* save a pointer to the "last" indication word */ - p_Last = p_TmpHmct; + WRITE_UINT32(*p_TmpHmct, tmpReg); - p_TmpHmct += HMCD_BASIC_SIZE/4; + /* save a pointer to the "last" indication word */ + p_Last = p_TmpHmct; - /* set size and pointer of user's data */ - size = (uint8_t)p_FmPcdManipParams->u.hdr.insrtParams.u.byHdr.u.specificL2Params.size; + p_TmpHmct += HMCD_BASIC_SIZE / 4; - ASSERT_COND(p_TmpData); - Mem2IOCpy32(p_TmpData, p_FmPcdManipParams->u.hdr.insrtParams.u.byHdr.u.specificL2Params.p_Data, size); - tmpReg = (size << HMCD_INSRT_L2_SIZE_SHIFT) | (uint32_t)(XX_VirtToPhys(p_TmpData) - (((t_FmPcd*)h_FmPcd)->physicalMuramBase)); - WRITE_UINT32(*p_TmpHmct, tmpReg); - p_TmpHmct += HMCD_PTR_SIZE/4; - p_TmpData += size; - } - else - RETURN_ERROR(MINOR, E_NOT_SUPPORTED, ("manip header insert type!")); + Mem2IOCpy32( + p_TmpHmct, + p_FmPcdManipParams->u.hdr.insrtParams.u.byHdr.u.insrt.p_Data, + p_FmPcdManipParams->u.hdr.insrtParams.u.byHdr.u.insrt.size); + p_TmpHmct += + p_FmPcdManipParams->u.hdr.insrtParams.u.byHdr.u.insrt.size + / 4; + break; +#endif /* (DPAA_VERSION >= 11) */ + default: + RETURN_ERROR(MINOR, E_NOT_SUPPORTED, + ("manip header insert by header type!")); + + } + } + else + RETURN_ERROR(MINOR, E_NOT_SUPPORTED, + ("manip header insert type!")); } if (p_FmPcdManipParams->u.hdr.fieldUpdate) { - switch (p_FmPcdManipParams->u.hdr.fieldUpdateParams.type){ + switch (p_FmPcdManipParams->u.hdr.fieldUpdateParams.type) + { case (e_FM_PCD_MANIP_HDR_FIELD_UPDATE_VLAN): /* set opcode */ - tmpReg = (uint32_t)(HMCD_OPCODE_VLAN_PRI_UPDATE) << HMCD_OC_SHIFT; + tmpReg = (uint32_t)(HMCD_OPCODE_VLAN_PRI_UPDATE) + << HMCD_OC_SHIFT; /* set mode & table pointer */ - if (p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.vlan.updateType == - e_FM_PCD_MANIP_HDR_FIELD_UPDATE_DSCP_TO_VLAN) + if (p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.vlan.updateType + == e_FM_PCD_MANIP_HDR_FIELD_UPDATE_DSCP_TO_VLAN) { /* set Mode */ - tmpReg |= (uint32_t)(HMCD_VLAN_PRI_UPDATE_DSCP_TO_VPRI) << HMCD_VLAN_PRI_REP_MODE_SHIFT; + tmpReg |= (uint32_t)(HMCD_VLAN_PRI_UPDATE_DSCP_TO_VPRI) + << HMCD_VLAN_PRI_REP_MODE_SHIFT; /* set VPRI default */ - tmpReg |= p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.vlan.u.dscpToVpri.vpriDefVal; + tmpReg |= + p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.vlan.u.dscpToVpri.vpriDefVal; WRITE_UINT32(*p_TmpHmct, tmpReg); /* save a pointer to the "last" indication word */ p_Last = p_TmpHmct; /* write the table pointer into the Manip descriptor */ - p_TmpHmct += HMCD_BASIC_SIZE/4; + p_TmpHmct += HMCD_BASIC_SIZE / 4; tmpReg = 0; ASSERT_COND(p_TmpData); - for (i=0; i<HMCD_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)); + tmpReg |= + (p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.vlan.u.dscpToVpri.dscpToVpriTable[i]) + << (32 - 4 * (j + 1)); j++; /* Than we write this register to the next table word * (i=7-->word 0, i=15-->word 1,... i=63-->word 7) */ - if ((i%8) == 7) + if ((i % 8) == 7) { - WRITE_UINT32(*((uint32_t*)p_TmpData + (i+1)/8-1), tmpReg); + WRITE_UINT32(*((uint32_t*)p_TmpData + (i+1)/8-1), + tmpReg); tmpReg = 0; j = 0; } } - WRITE_UINT32(*p_TmpHmct, (uint32_t)(XX_VirtToPhys(p_TmpData) - (((t_FmPcd*)h_FmPcd)->physicalMuramBase))); - p_TmpHmct += HMCD_PTR_SIZE/4; + + WRITE_UINT32( + *p_TmpHmct, + (uint32_t)(XX_VirtToPhys(p_TmpData) - (((t_FmPcd*)h_FmPcd)->physicalMuramBase))); + p_TmpHmct += HMCD_PTR_SIZE / 4; p_TmpData += DSCP_TO_VLAN_TABLE_SIZE; } - else if (p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.vlan.updateType == - e_FM_PCD_MANIP_HDR_FIELD_UPDATE_VLAN_VPRI) - { - /* set Mode */ - /* line commented out as it has no-side-effect ('0' value). */ - /*tmpReg |= HMCD_VLAN_PRI_UPDATE << HMCD_VLAN_PRI_REP_MODE_SHIFT*/; - /* set VPRI parameter */ - tmpReg |= p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.vlan.u.vpri; - WRITE_UINT32(*p_TmpHmct, tmpReg); - /* save a pointer to the "last" indication word */ - p_Last = p_TmpHmct; - p_TmpHmct += HMCD_BASIC_SIZE/4; - } + else + if (p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.vlan.updateType + == e_FM_PCD_MANIP_HDR_FIELD_UPDATE_VLAN_VPRI) + { + /* set Mode */ + /* line commented out as it has no-side-effect ('0' value). */ + /*tmpReg |= HMCD_VLAN_PRI_UPDATE << HMCD_VLAN_PRI_REP_MODE_SHIFT*/; + /* set VPRI parameter */ + tmpReg |= + p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.vlan.u.vpri; + WRITE_UINT32(*p_TmpHmct, tmpReg); + /* save a pointer to the "last" indication word */ + p_Last = p_TmpHmct; + p_TmpHmct += HMCD_BASIC_SIZE / 4; + } break; case (e_FM_PCD_MANIP_HDR_FIELD_UPDATE_IPV4): /* set opcode */ tmpReg = (uint32_t)(HMCD_OPCODE_IPV4_UPDATE) << HMCD_OC_SHIFT; - if (p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.ipv4.validUpdates & HDR_MANIP_IPV4_TTL) + if (p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.ipv4.validUpdates + & HDR_MANIP_IPV4_TTL) tmpReg |= HMCD_IPV4_UPDATE_TTL; - if (p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.ipv4.validUpdates & HDR_MANIP_IPV4_TOS) + if (p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.ipv4.validUpdates + & HDR_MANIP_IPV4_TOS) { tmpReg |= HMCD_IPV4_UPDATE_TOS; - tmpReg |= p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.ipv4.tos << HMCD_IPV4_UPDATE_TOS_SHIFT; + tmpReg |= + p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.ipv4.tos + << HMCD_IPV4_UPDATE_TOS_SHIFT; } - if (p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.ipv4.validUpdates & HDR_MANIP_IPV4_ID) + if (p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.ipv4.validUpdates + & HDR_MANIP_IPV4_ID) tmpReg |= HMCD_IPV4_UPDATE_ID; - if (p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.ipv4.validUpdates & HDR_MANIP_IPV4_SRC) + if (p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.ipv4.validUpdates + & HDR_MANIP_IPV4_SRC) tmpReg |= HMCD_IPV4_UPDATE_SRC; - if (p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.ipv4.validUpdates & HDR_MANIP_IPV4_DST) + if (p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.ipv4.validUpdates + & HDR_MANIP_IPV4_DST) tmpReg |= HMCD_IPV4_UPDATE_DST; /* write the first 4 bytes of the descriptor */ WRITE_UINT32(*p_TmpHmct, tmpReg); /* save a pointer to the "last" indication word */ p_Last = p_TmpHmct; - p_TmpHmct += HMCD_BASIC_SIZE/4; + p_TmpHmct += HMCD_BASIC_SIZE / 4; - if (p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.ipv4.validUpdates & HDR_MANIP_IPV4_ID) + if (p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.ipv4.validUpdates + & HDR_MANIP_IPV4_ID) { ASSERT_COND(p_TmpData); - WRITE_UINT16(*(uint16_t*)p_TmpData, p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.ipv4.id); - WRITE_UINT32(*p_TmpHmct, (uint32_t)(XX_VirtToPhys(p_TmpData) - (((t_FmPcd*)p_Manip->h_FmPcd)->physicalMuramBase))); + WRITE_UINT16( + *(uint16_t*)p_TmpData, + p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.ipv4.id); + WRITE_UINT32( + *p_TmpHmct, + (uint32_t)(XX_VirtToPhys(p_TmpData) - (((t_FmPcd*)p_Manip->h_FmPcd)->physicalMuramBase))); p_TmpData += 2; - p_TmpHmct += HMCD_PTR_SIZE/4; + p_TmpHmct += HMCD_PTR_SIZE / 4; } - if (p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.ipv4.validUpdates & HDR_MANIP_IPV4_SRC) + if (p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.ipv4.validUpdates + & HDR_MANIP_IPV4_SRC) { - WRITE_UINT32(*p_TmpHmct, p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.ipv4.src); - p_TmpHmct += HMCD_IPV4_ADDR_SIZE/4; + WRITE_UINT32( + *p_TmpHmct, + p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.ipv4.src); + p_TmpHmct += HMCD_IPV4_ADDR_SIZE / 4; } - if (p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.ipv4.validUpdates & HDR_MANIP_IPV4_DST) + if (p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.ipv4.validUpdates + & HDR_MANIP_IPV4_DST) { - WRITE_UINT32(*p_TmpHmct, p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.ipv4.dst); - p_TmpHmct += HMCD_IPV4_ADDR_SIZE/4; + WRITE_UINT32( + *p_TmpHmct, + p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.ipv4.dst); + p_TmpHmct += HMCD_IPV4_ADDR_SIZE / 4; } break; case (e_FM_PCD_MANIP_HDR_FIELD_UPDATE_IPV6): /* set opcode */ tmpReg = (uint32_t)(HMCD_OPCODE_IPV6_UPDATE) << HMCD_OC_SHIFT; - if (p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.ipv6.validUpdates & HDR_MANIP_IPV6_HL) + if (p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.ipv6.validUpdates + & HDR_MANIP_IPV6_HL) tmpReg |= HMCD_IPV6_UPDATE_HL; - if (p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.ipv6.validUpdates & HDR_MANIP_IPV6_TC) + if (p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.ipv6.validUpdates + & HDR_MANIP_IPV6_TC) { tmpReg |= HMCD_IPV6_UPDATE_TC; - tmpReg |= p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.ipv6.trafficClass << HMCD_IPV6_UPDATE_TC_SHIFT; + tmpReg |= + p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.ipv6.trafficClass + << HMCD_IPV6_UPDATE_TC_SHIFT; } - if (p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.ipv6.validUpdates & HDR_MANIP_IPV6_SRC) + if (p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.ipv6.validUpdates + & HDR_MANIP_IPV6_SRC) tmpReg |= HMCD_IPV6_UPDATE_SRC; - if (p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.ipv6.validUpdates & HDR_MANIP_IPV6_DST) + if (p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.ipv6.validUpdates + & HDR_MANIP_IPV6_DST) tmpReg |= HMCD_IPV6_UPDATE_DST; /* write the first 4 bytes of the descriptor */ WRITE_UINT32(*p_TmpHmct, tmpReg); /* save a pointer to the "last" indication word */ p_Last = p_TmpHmct; - p_TmpHmct += HMCD_BASIC_SIZE/4; - if (p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.ipv6.validUpdates & HDR_MANIP_IPV6_SRC) - for (i = 0 ; i < NET_HEADER_FIELD_IPv6_ADDR_SIZE ; i+=4) + p_TmpHmct += HMCD_BASIC_SIZE / 4; + if (p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.ipv6.validUpdates + & HDR_MANIP_IPV6_SRC) + { + for (i = 0; i < NET_HEADER_FIELD_IPv6_ADDR_SIZE; i += 4) { - WRITE_UINT32(*p_TmpHmct, *(uint32_t*)&p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.ipv6.src[i]); - p_TmpHmct += HMCD_PTR_SIZE/4; + memcpy(&tmp_ipv6_addr, + &p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.ipv6.src[i], + sizeof(uint32_t)); + WRITE_UINT32(*p_TmpHmct, tmp_ipv6_addr); + p_TmpHmct += HMCD_PTR_SIZE / 4; } - if (p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.ipv6.validUpdates & HDR_MANIP_IPV6_DST) - for (i = 0 ; i < NET_HEADER_FIELD_IPv6_ADDR_SIZE ; i+=4) + } + if (p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.ipv6.validUpdates + & HDR_MANIP_IPV6_DST) + { + for (i = 0; i < NET_HEADER_FIELD_IPv6_ADDR_SIZE; i += 4) { - WRITE_UINT32(*p_TmpHmct, *(uint32_t*)&p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.ipv6.dst[i]); - p_TmpHmct += HMCD_PTR_SIZE/4; + memcpy(&tmp_ipv6_addr, + &p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.ipv6.dst[i], + sizeof(uint32_t)); + WRITE_UINT32(*p_TmpHmct, tmp_ipv6_addr); + p_TmpHmct += HMCD_PTR_SIZE / 4; } + } break; case (e_FM_PCD_MANIP_HDR_FIELD_UPDATE_TCP_UDP): - if (p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.tcpUdp.validUpdates == HDR_MANIP_TCP_UDP_CHECKSUM) + if (p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.tcpUdp.validUpdates + == HDR_MANIP_TCP_UDP_CHECKSUM) { /* we implement this case with the update-checksum descriptor */ /* set opcode */ - tmpReg = (uint32_t)(HMCD_OPCODE_TCP_UDP_CHECKSUM) << HMCD_OC_SHIFT; + tmpReg = (uint32_t)(HMCD_OPCODE_TCP_UDP_CHECKSUM) + << HMCD_OC_SHIFT; /* write the first 4 bytes of the descriptor */ WRITE_UINT32(*p_TmpHmct, tmpReg); /* save a pointer to the "last" indication word */ p_Last = p_TmpHmct; - p_TmpHmct += HMCD_BASIC_SIZE/4; + p_TmpHmct += HMCD_BASIC_SIZE / 4; } else { /* we implement this case with the TCP/UDP update descriptor */ /* set opcode */ - tmpReg = (uint32_t)(HMCD_OPCODE_TCP_UDP_UPDATE) << HMCD_OC_SHIFT; - if (p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.tcpUdp.validUpdates & HDR_MANIP_TCP_UDP_DST) - tmpReg |= HMCD_TCP_UDP_UPDATE_DST; - if (p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.tcpUdp.validUpdates & HDR_MANIP_TCP_UDP_SRC) - tmpReg |= HMCD_TCP_UDP_UPDATE_SRC; + tmpReg = (uint32_t)(HMCD_OPCODE_TCP_UDP_UPDATE) + << HMCD_OC_SHIFT; + if (p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.tcpUdp.validUpdates + & HDR_MANIP_TCP_UDP_DST) + tmpReg |= HMCD_TCP_UDP_UPDATE_DST; + if (p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.tcpUdp.validUpdates + & HDR_MANIP_TCP_UDP_SRC) + tmpReg |= HMCD_TCP_UDP_UPDATE_SRC; /* write the first 4 bytes of the descriptor */ WRITE_UINT32(*p_TmpHmct, tmpReg); /* save a pointer to the "last" indication word */ p_Last = p_TmpHmct; - p_TmpHmct += HMCD_BASIC_SIZE/4; + p_TmpHmct += HMCD_BASIC_SIZE / 4; tmpReg = 0; - if (p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.tcpUdp.validUpdates & HDR_MANIP_TCP_UDP_SRC) - tmpReg |= ((uint32_t)p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.tcpUdp.src) << HMCD_TCP_UDP_UPDATE_SRC_SHIFT; - if (p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.tcpUdp.validUpdates & HDR_MANIP_TCP_UDP_DST) - tmpReg |= ((uint32_t)p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.tcpUdp.dst); + if (p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.tcpUdp.validUpdates + & HDR_MANIP_TCP_UDP_SRC) + tmpReg |= + ((uint32_t)p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.tcpUdp.src) + << HMCD_TCP_UDP_UPDATE_SRC_SHIFT; + if (p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.tcpUdp.validUpdates + & HDR_MANIP_TCP_UDP_DST) + tmpReg |= + ((uint32_t)p_FmPcdManipParams->u.hdr.fieldUpdateParams.u.tcpUdp.dst); WRITE_UINT32(*p_TmpHmct, tmpReg); - p_TmpHmct += HMCD_PTR_SIZE/4; + p_TmpHmct += HMCD_PTR_SIZE / 4; } break; default: - RETURN_ERROR(MINOR, E_INVALID_SELECTION, ("Unknown fieldUpdateParams.type")); + RETURN_ERROR(MINOR, E_INVALID_SELECTION, + ("Unknown fieldUpdateParams.type")); } } @@ -564,73 +962,92 @@ static t_Error BuildHmct(t_FmPcdManip *p_Manip, t_FmPcdManipParams *p_FmPcdManip if (p_FmPcdManipParams->u.hdr.customParams.u.ipHdrReplace.decTtlHl) tmpReg |= HMCD_IP_REPLACE_TTL_HL; - if (p_FmPcdManipParams->u.hdr.customParams.u.ipHdrReplace.replaceType == e_FM_PCD_MANIP_HDR_CUSTOM_REPLACE_IPV4_BY_IPV6) + if (p_FmPcdManipParams->u.hdr.customParams.u.ipHdrReplace.replaceType + == e_FM_PCD_MANIP_HDR_CUSTOM_REPLACE_IPV4_BY_IPV6) /* line commented out as it has no-side-effect ('0' value). */ /*tmpReg |= HMCD_IP_REPLACE_REPLACE_IPV4*/; - else if (p_FmPcdManipParams->u.hdr.customParams.u.ipHdrReplace.replaceType == e_FM_PCD_MANIP_HDR_CUSTOM_REPLACE_IPV6_BY_IPV4) - { - tmpReg |= HMCD_IP_REPLACE_REPLACE_IPV6; - if (p_FmPcdManipParams->u.hdr.customParams.u.ipHdrReplace.updateIpv4Id) - tmpReg |= HMCD_IP_REPLACE_ID; - } else - RETURN_ERROR(MINOR, E_NOT_SUPPORTED, - ("One flag out of HDR_MANIP_IP_REPLACE_IPV4, HDR_MANIP_IP_REPLACE_IPV6 - must be set.")); + if (p_FmPcdManipParams->u.hdr.customParams.u.ipHdrReplace.replaceType + == e_FM_PCD_MANIP_HDR_CUSTOM_REPLACE_IPV6_BY_IPV4) + { + tmpReg |= HMCD_IP_REPLACE_REPLACE_IPV6; + if (p_FmPcdManipParams->u.hdr.customParams.u.ipHdrReplace.updateIpv4Id) + tmpReg |= HMCD_IP_REPLACE_ID; + } + else + RETURN_ERROR( + MINOR, + E_NOT_SUPPORTED, + ("One flag out of HDR_MANIP_IP_REPLACE_IPV4, HDR_MANIP_IP_REPLACE_IPV6 - must be set.")); /* write the first 4 bytes of the descriptor */ WRITE_UINT32(*p_TmpHmct, tmpReg); /* save a pointer to the "last" indication word */ p_Last = p_TmpHmct; - p_TmpHmct += HMCD_BASIC_SIZE/4; + p_TmpHmct += HMCD_BASIC_SIZE / 4; - size = p_FmPcdManipParams->u.hdr.customParams.u.ipHdrReplace.hdrSize; + size = + p_FmPcdManipParams->u.hdr.customParams.u.ipHdrReplace.hdrSize; ASSERT_COND(p_TmpData); - Mem2IOCpy32(p_TmpData, p_FmPcdManipParams->u.hdr.customParams.u.ipHdrReplace.hdr, size); + Mem2IOCpy32( + p_TmpData, + p_FmPcdManipParams->u.hdr.customParams.u.ipHdrReplace.hdr, + size); tmpReg = (uint32_t)(size << HMCD_IP_REPLACE_L3HDRSIZE_SHIFT); - tmpReg |= (uint32_t)(XX_VirtToPhys(p_TmpData) - (((t_FmPcd*)h_FmPcd)->physicalMuramBase)); + tmpReg |= (uint32_t)(XX_VirtToPhys(p_TmpData) + - (((t_FmPcd*)h_FmPcd)->physicalMuramBase)); WRITE_UINT32(*p_TmpHmct, tmpReg); - p_TmpHmct += HMCD_PTR_SIZE/4; + p_TmpHmct += HMCD_PTR_SIZE / 4; p_TmpData += size; - if ((p_FmPcdManipParams->u.hdr.customParams.u.ipHdrReplace.replaceType == e_FM_PCD_MANIP_HDR_CUSTOM_REPLACE_IPV6_BY_IPV4) && - (p_FmPcdManipParams->u.hdr.customParams.u.ipHdrReplace.updateIpv4Id)) + if ((p_FmPcdManipParams->u.hdr.customParams.u.ipHdrReplace.replaceType + == e_FM_PCD_MANIP_HDR_CUSTOM_REPLACE_IPV6_BY_IPV4) + && (p_FmPcdManipParams->u.hdr.customParams.u.ipHdrReplace.updateIpv4Id)) { - WRITE_UINT16(*(uint16_t*)p_TmpData, p_FmPcdManipParams->u.hdr.customParams.u.ipHdrReplace.id); - WRITE_UINT32(*p_TmpHmct, (uint32_t)(XX_VirtToPhys(p_TmpData) - (((t_FmPcd*)h_FmPcd)->physicalMuramBase))); + WRITE_UINT16( + *(uint16_t*)p_TmpData, + p_FmPcdManipParams->u.hdr.customParams.u.ipHdrReplace.id); + WRITE_UINT32( + *p_TmpHmct, + (uint32_t)(XX_VirtToPhys(p_TmpData) - (((t_FmPcd*)h_FmPcd)->physicalMuramBase))); p_TmpData += 2; } - p_TmpHmct += HMCD_PTR_SIZE/4; - break; + p_TmpHmct += HMCD_PTR_SIZE / 4; + break; default: - RETURN_ERROR(MINOR, E_INVALID_SELECTION, ("Unknown customParams.type")); + RETURN_ERROR(MINOR, E_INVALID_SELECTION, + ("Unknown customParams.type")); } } /* If this node has a nextManip, and no parsing is required after it, the old table must be copied to the new table - the old table and should be freed */ - if (p_FmPcdManipParams->h_NextManip && - (MANIP_DONT_REPARSE(p_FmPcdManipParams->h_NextManip))) + the old table and should be freed */ + if (p_FmPcdManipParams->h_NextManip + && (MANIP_DONT_REPARSE(p_FmPcdManipParams->h_NextManip))) { if (new) { - /* If this is the first time this manip is created we need to free unused memory. If it - * is a dynamic changes case, the memory used is either the CC shadow or the existing - * table - no allocation, no free */ + /* If this is the first time this manip is created we need to free unused memory. If it + * is a dynamic changes case, the memory used is either the CC shadow or the existing + * table - no allocation, no free */ MANIP_UPDATE_UNIFIED_POSITION(p_FmPcdManipParams->h_NextManip); p_Manip->unifiedPosition = e_MANIP_UNIFIED_FIRST; /* The HMTD of the next Manip is never going to be used */ if (((t_FmPcdManip *)p_FmPcdManipParams->h_NextManip)->muramAllocate) - FM_MURAM_FreeMem(((t_FmPcd *)((t_FmPcdManip *)p_FmPcdManipParams->h_NextManip)->h_FmPcd)->h_FmMuram, ((t_FmPcdManip *)p_FmPcdManipParams->h_NextManip)->h_Ad); + FM_MURAM_FreeMem( + ((t_FmPcd *)((t_FmPcdManip *)p_FmPcdManipParams->h_NextManip)->h_FmPcd)->h_FmMuram, + ((t_FmPcdManip *)p_FmPcdManipParams->h_NextManip)->h_Ad); 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; + p_TmpHmct += MANIP_GET_HMCT_SIZE(p_FmPcdManipParams->h_NextManip) + / 4; } } else @@ -643,63 +1060,71 @@ static t_Error BuildHmct(t_FmPcdManip *p_Manip, t_FmPcdManipParams *p_FmPcdManip return E_OK; } -static t_Error CreateManipActionNew(t_FmPcdManip *p_Manip, t_FmPcdManipParams *p_FmPcdManipParams) +static t_Error CreateManipActionNew(t_FmPcdManip *p_Manip, + t_FmPcdManipParams *p_FmPcdManipParams) { - t_FmPcdManip *p_CurManip; - t_Error err; - uint32_t nextSize = 0, totalSize; - uint16_t tmpReg; - uint8_t *p_OldHmct, *p_TmpHmctPtr, *p_TmpDataPtr; + t_FmPcdManip *p_CurManip; + t_Error err; + uint32_t nextSize = 0, totalSize; + uint16_t tmpReg; + uint8_t *p_OldHmct, *p_TmpHmctPtr, *p_TmpDataPtr; /* set Manip structure */ if (p_FmPcdManipParams->h_NextManip) { if (MANIP_DONT_REPARSE(p_FmPcdManipParams->h_NextManip)) - nextSize = (uint32_t)(GetHmctSize(p_FmPcdManipParams->h_NextManip) + GetDataSize(p_FmPcdManipParams->h_NextManip)); + nextSize = (uint32_t)(GetHmctSize(p_FmPcdManipParams->h_NextManip) + + GetDataSize(p_FmPcdManipParams->h_NextManip)); else p_Manip->cascadedNext = TRUE; } - p_Manip->dontParseAfterManip = p_FmPcdManipParams->u.hdr.dontParseAfterManip; + p_Manip->dontParseAfterManip = + p_FmPcdManipParams->u.hdr.dontParseAfterManip; /* Allocate new table */ /* calculate table size according to manip parameters */ - err = CalculateTableSize(p_FmPcdManipParams, &p_Manip->tableSize, &p_Manip->dataSize); + err = CalculateTableSize(p_FmPcdManipParams, &p_Manip->tableSize, + &p_Manip->dataSize); if (err) RETURN_ERROR(MINOR, err, NO_MSG); - totalSize =(uint16_t)(p_Manip->tableSize + p_Manip->dataSize + nextSize); + totalSize = (uint16_t)(p_Manip->tableSize + p_Manip->dataSize + nextSize); - p_Manip->p_Hmct = (uint8_t*)FM_MURAM_AllocMem(((t_FmPcd *)p_Manip->h_FmPcd)->h_FmMuram, totalSize, 4); + p_Manip->p_Hmct = (uint8_t*)FM_MURAM_AllocMem( + ((t_FmPcd *)p_Manip->h_FmPcd)->h_FmMuram, totalSize, 4); if (!p_Manip->p_Hmct) RETURN_ERROR(MAJOR, E_NO_MEMORY, ("MURAM alloc failed")); if (p_Manip->dataSize) - p_Manip->p_Data = (uint8_t*)PTR_MOVE(p_Manip->p_Hmct, (p_Manip->tableSize + nextSize)); + p_Manip->p_Data = + (uint8_t*)PTR_MOVE(p_Manip->p_Hmct, (p_Manip->tableSize + nextSize)); /* update shadow size to allow runtime replacement of Header manipulation */ /* The allocated shadow is divided as follows: - 0 . . . 16 . . . - -------------------------------- - | Shadow | Shadow HMTD | - | HMTD | Match Table | - | (16 bytes) | (maximal size) | - -------------------------------- + 0 . . . 16 . . . + -------------------------------- + | Shadow | Shadow HMTD | + | HMTD | Match Table | + | (16 bytes) | (maximal size) | + -------------------------------- */ - err = FmPcdUpdateCcShadow (p_Manip->h_FmPcd, (uint32_t)(totalSize + 16), (uint16_t)FM_PCD_CC_AD_TABLE_ALIGN); + err = FmPcdUpdateCcShadow(p_Manip->h_FmPcd, (uint32_t)(totalSize + 16), + (uint16_t)FM_PCD_CC_AD_TABLE_ALIGN); if (err != E_OK) { FM_MURAM_FreeMem(p_Manip->h_FmPcd, p_Manip->p_Hmct); - RETURN_ERROR(MAJOR, E_NO_MEMORY, ("MURAM allocation for HdrManip node shadow")); + RETURN_ERROR(MAJOR, E_NO_MEMORY, + ("MURAM allocation for HdrManip node shadow")); } - - if (p_FmPcdManipParams->h_NextManip && - (MANIP_DONT_REPARSE(p_FmPcdManipParams->h_NextManip))) + if (p_FmPcdManipParams->h_NextManip + && (MANIP_DONT_REPARSE(p_FmPcdManipParams->h_NextManip))) { - p_OldHmct = (uint8_t *)GetManipInfo(p_FmPcdManipParams->h_NextManip, e_MANIP_HMCT); + p_OldHmct = (uint8_t *)GetManipInfo(p_FmPcdManipParams->h_NextManip, + e_MANIP_HMCT); p_CurManip = p_FmPcdManipParams->h_NextManip; - /* Run till the last Manip (which is the first to configure) */ + /* Run till the last Manip (which is the first to configure) */ while (MANIP_IS_UNIFIED_NON_LAST(p_CurManip)) p_CurManip = p_CurManip->h_NextManip; @@ -707,32 +1132,35 @@ static t_Error CreateManipActionNew(t_FmPcdManip *p_Manip, t_FmPcdManipParams *p { /* If this is a unified table, point to the part of the table * which is the relative offset in HMCT. - */ + */ p_TmpHmctPtr = (uint8_t*)PTR_MOVE(p_Manip->p_Hmct, - (p_Manip->tableSize + - (PTR_TO_UINT(p_CurManip->p_Hmct) - - PTR_TO_UINT(p_OldHmct)))); + (p_Manip->tableSize + + (PTR_TO_UINT(p_CurManip->p_Hmct) - + PTR_TO_UINT(p_OldHmct)))); if (p_CurManip->p_Data) p_TmpDataPtr = (uint8_t*)PTR_MOVE(p_Manip->p_Hmct, - (p_Manip->tableSize + - (PTR_TO_UINT(p_CurManip->p_Data) - - PTR_TO_UINT(p_OldHmct)))); + (p_Manip->tableSize + + (PTR_TO_UINT(p_CurManip->p_Data) - + PTR_TO_UINT(p_OldHmct)))); else p_TmpDataPtr = NULL; - BuildHmct(p_CurManip, &p_CurManip->manipParams, p_TmpHmctPtr, p_TmpDataPtr, FALSE); + BuildHmct(p_CurManip, &p_CurManip->manipParams, p_TmpHmctPtr, + p_TmpDataPtr, FALSE); /* update old manip table pointer */ MANIP_SET_HMCT_PTR(p_CurManip, p_TmpHmctPtr); MANIP_SET_DATA_PTR(p_CurManip, p_TmpDataPtr); p_CurManip = p_CurManip->h_PrevManip; - } + } /* We copied the HMCT to create a new large HMCT so we can free the old one */ - FM_MURAM_FreeMem(MANIP_GET_MURAM(p_FmPcdManipParams->h_NextManip), p_OldHmct); + FM_MURAM_FreeMem(MANIP_GET_MURAM(p_FmPcdManipParams->h_NextManip), + p_OldHmct); } /* Fill table */ - err = BuildHmct(p_Manip, p_FmPcdManipParams, p_Manip->p_Hmct, p_Manip->p_Data, TRUE); + err = BuildHmct(p_Manip, p_FmPcdManipParams, p_Manip->p_Hmct, + p_Manip->p_Data, TRUE); if (err) { FM_MURAM_FreeMem(p_Manip->h_FmPcd, p_Manip->p_Hmct); @@ -745,32 +1173,34 @@ static t_Error CreateManipActionNew(t_FmPcdManip *p_Manip, t_FmPcdManipParams *p if (!p_Manip->dontParseAfterManip) tmpReg |= HMTD_CFG_PRS_AFTER_HM; /* create cascade */ - if (p_FmPcdManipParams->h_NextManip && - !MANIP_DONT_REPARSE(p_FmPcdManipParams->h_NextManip)) + if (p_FmPcdManipParams->h_NextManip + && !MANIP_DONT_REPARSE(p_FmPcdManipParams->h_NextManip)) { /* indicate that there's another HM table descriptor */ tmpReg |= HMTD_CFG_NEXT_AD_EN; - WRITE_UINT16(((t_Hmtd *)p_Manip->h_Ad)->nextAdIdx, - (uint16_t)((uint32_t)(XX_VirtToPhys(MANIP_GET_HMTD_PTR(p_FmPcdManipParams->h_NextManip)) - - (((t_FmPcd*)p_Manip->h_FmPcd)->physicalMuramBase)) >> 4)); + WRITE_UINT16( + ((t_Hmtd *)p_Manip->h_Ad)->nextAdIdx, + (uint16_t)((uint32_t)(XX_VirtToPhys(MANIP_GET_HMTD_PTR(p_FmPcdManipParams->h_NextManip)) - (((t_FmPcd*)p_Manip->h_FmPcd)->physicalMuramBase)) >> 4)); } WRITE_UINT16(((t_Hmtd *)p_Manip->h_Ad)->cfg, tmpReg); - WRITE_UINT32(((t_Hmtd *)p_Manip->h_Ad)->hmcdBasePtr, - (uint32_t)(XX_VirtToPhys(p_Manip->p_Hmct) - (((t_FmPcd*)p_Manip->h_FmPcd)->physicalMuramBase))); + WRITE_UINT32( + ((t_Hmtd *)p_Manip->h_Ad)->hmcdBasePtr, + (uint32_t)(XX_VirtToPhys(p_Manip->p_Hmct) - (((t_FmPcd*)p_Manip->h_FmPcd)->physicalMuramBase))); WRITE_UINT8(((t_Hmtd *)p_Manip->h_Ad)->opCode, HMAN_OC); return E_OK; } -static t_Error CreateManipActionShadow(t_FmPcdManip *p_Manip, t_FmPcdManipParams *p_FmPcdManipParams) +static t_Error CreateManipActionShadow(t_FmPcdManip *p_Manip, + t_FmPcdManipParams *p_FmPcdManipParams) { - uint8_t *p_WholeHmct, *p_TmpHmctPtr, newDataSize, *p_TmpDataPtr = NULL; - uint16_t newSize; - t_FmPcd *p_FmPcd = (t_FmPcd *)p_Manip->h_FmPcd; - t_Error err; - t_FmPcdManip *p_CurManip = p_Manip; + uint8_t *p_WholeHmct, *p_TmpHmctPtr, newDataSize, *p_TmpDataPtr = NULL; + uint16_t newSize; + t_FmPcd *p_FmPcd = (t_FmPcd *)p_Manip->h_FmPcd; + t_Error err; + t_FmPcdManip *p_CurManip = p_Manip; err = CalculateTableSize(p_FmPcdManipParams, &newSize, &newDataSize); if (err) @@ -778,29 +1208,45 @@ static t_Error CreateManipActionShadow(t_FmPcdManip *p_Manip, t_FmPcdManipParams /* check coherency of new table parameters */ if (newSize > p_Manip->tableSize) - RETURN_ERROR(MINOR, E_INVALID_VALUE, ("New Hdr Manip configuration requires larger size than current one (command table).")); + RETURN_ERROR( + MINOR, + E_INVALID_VALUE, + ("New Hdr Manip configuration requires larger size than current one (command table).")); if (newDataSize > p_Manip->dataSize) - RETURN_ERROR(MINOR, E_INVALID_VALUE, ("New Hdr Manip configuration requires larger size than current one (data).")); + RETURN_ERROR( + MINOR, + E_INVALID_VALUE, + ("New Hdr Manip configuration requires larger size than current one (data).")); if (p_FmPcdManipParams->h_NextManip) - RETURN_ERROR(MINOR, E_INVALID_VALUE, ("New Hdr Manip configuration can not contain h_NextManip.")); + RETURN_ERROR( + MINOR, E_INVALID_VALUE, + ("New Hdr Manip configuration can not contain h_NextManip.")); if (MANIP_IS_UNIFIED(p_Manip) && (newSize != p_Manip->tableSize)) - RETURN_ERROR(MINOR, E_INVALID_VALUE, ("New Hdr Manip configuration in a chained manipulation requires different size than current one.")); - if (p_Manip->dontParseAfterManip != p_FmPcdManipParams->u.hdr.dontParseAfterManip) - RETURN_ERROR(MINOR, E_INVALID_VALUE, ("New Hdr Manip configuration differs in dontParseAfterManip value.")); + RETURN_ERROR( + MINOR, + E_INVALID_VALUE, + ("New Hdr Manip configuration in a chained manipulation requires different size than current one.")); + if (p_Manip->dontParseAfterManip + != p_FmPcdManipParams->u.hdr.dontParseAfterManip) + RETURN_ERROR( + MINOR, + E_INVALID_VALUE, + ("New Hdr Manip configuration differs in dontParseAfterManip value.")); p_Manip->tableSize = newSize; p_Manip->dataSize = newDataSize; - /* Build the new table in the shadow */ if (!MANIP_IS_UNIFIED(p_Manip)) { p_TmpHmctPtr = (uint8_t*)PTR_MOVE(p_FmPcd->p_CcShadow, 16); if (p_Manip->p_Data) - p_TmpDataPtr = (uint8_t*)PTR_MOVE(p_TmpHmctPtr, - (PTR_TO_UINT(p_Manip->p_Data) - PTR_TO_UINT(p_Manip->p_Hmct))); + p_TmpDataPtr = + (uint8_t*)PTR_MOVE(p_TmpHmctPtr, + (PTR_TO_UINT(p_Manip->p_Data) - PTR_TO_UINT(p_Manip->p_Hmct))); - BuildHmct(p_Manip, p_FmPcdManipParams, p_TmpHmctPtr, p_Manip->p_Data, FALSE); + BuildHmct(p_Manip, p_FmPcdManipParams, p_TmpHmctPtr, p_Manip->p_Data, + FALSE); } else { @@ -818,13 +1264,16 @@ static t_Error CreateManipActionShadow(t_FmPcdManip *p_Manip, t_FmPcdManipParams * else, point to the beginning of the * shadow table (we save 16 for the HMTD. */ - p_TmpHmctPtr = (uint8_t*)PTR_MOVE(p_FmPcd->p_CcShadow, - (16 + PTR_TO_UINT(p_CurManip->p_Hmct) - PTR_TO_UINT(p_WholeHmct))); + p_TmpHmctPtr = + (uint8_t*)PTR_MOVE(p_FmPcd->p_CcShadow, + (16 + PTR_TO_UINT(p_CurManip->p_Hmct) - PTR_TO_UINT(p_WholeHmct))); if (p_CurManip->p_Data) - p_TmpDataPtr = (uint8_t*)PTR_MOVE(p_FmPcd->p_CcShadow, - (16 + PTR_TO_UINT(p_CurManip->p_Data) - PTR_TO_UINT(p_WholeHmct))); + p_TmpDataPtr = + (uint8_t*)PTR_MOVE(p_FmPcd->p_CcShadow, + (16 + PTR_TO_UINT(p_CurManip->p_Data) - PTR_TO_UINT(p_WholeHmct))); - BuildHmct(p_CurManip, &p_CurManip->manipParams, p_TmpHmctPtr, p_TmpDataPtr, FALSE); + BuildHmct(p_CurManip, &p_CurManip->manipParams, p_TmpHmctPtr, + p_TmpDataPtr, FALSE); p_CurManip = p_CurManip->h_PrevManip; } } @@ -832,16 +1281,18 @@ static t_Error CreateManipActionShadow(t_FmPcdManip *p_Manip, t_FmPcdManipParams return E_OK; } -static t_Error CreateManipActionBackToOrig(t_FmPcdManip *p_Manip, t_FmPcdManipParams *p_FmPcdManipParams) +static t_Error CreateManipActionBackToOrig( + t_FmPcdManip *p_Manip, t_FmPcdManipParams *p_FmPcdManipParams) { - uint8_t *p_WholeHmct = NULL, *p_TmpHmctPtr, *p_TmpDataPtr; - t_FmPcdManip *p_CurManip = p_Manip; + 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); + BuildHmct(p_Manip, p_FmPcdManipParams, p_Manip->p_Hmct, p_Manip->p_Data, + FALSE); else { p_WholeHmct = (uint8_t *)GetManipInfo(p_Manip, e_MANIP_HMCT); @@ -859,7 +1310,8 @@ static t_Error CreateManipActionBackToOrig(t_FmPcdManip *p_Manip, t_FmPcdManipPa p_TmpHmctPtr = p_CurManip->p_Hmct; /*- (uint32_t)p_WholeHmct*/ p_TmpDataPtr = p_CurManip->p_Data; /*- (uint32_t)p_WholeHmct*/ - BuildHmct(p_CurManip, &p_CurManip->manipParams, p_TmpHmctPtr, p_TmpDataPtr, FALSE); + BuildHmct(p_CurManip, &p_CurManip->manipParams, p_TmpHmctPtr, + p_TmpDataPtr, FALSE); p_CurManip = p_CurManip->h_PrevManip; } @@ -868,77 +1320,86 @@ static t_Error CreateManipActionBackToOrig(t_FmPcdManip *p_Manip, t_FmPcdManipPa return E_OK; } +#if (defined(FM_CAPWAP_SUPPORT) && (DPAA_VERSION == 10)) static t_Error UpdateManipIc(t_Handle h_Manip, uint8_t icOffset) { t_FmPcdManip *p_Manip = (t_FmPcdManip *)h_Manip; - t_Handle p_Ad; - uint32_t tmpReg32 = 0; - SANITY_CHECK_RETURN_ERROR(h_Manip,E_INVALID_HANDLE); + t_Handle p_Ad; + uint32_t tmpReg32 = 0; + SANITY_CHECK_RETURN_ERROR(h_Manip, E_INVALID_HANDLE); SANITY_CHECK_RETURN_ERROR(p_Manip->h_Ad, E_INVALID_HANDLE); switch (p_Manip->opcode) { case (HMAN_OC_MV_INT_FRAME_HDR_FROM_FRM_TO_BUFFER_PREFFIX): - p_Ad = (t_AdOfTypeContLookup *)p_Manip->h_Ad; - if (p_Manip->updateParams & INTERNAL_CONTEXT_OFFSET) + p_Ad = (t_AdOfTypeContLookup *)p_Manip->h_Ad; + if (p_Manip->updateParams & INTERNAL_CONTEXT_OFFSET) + { + tmpReg32 = + *(uint32_t *)&((t_AdOfTypeContLookup *)p_Ad)->pcAndOffsets; + tmpReg32 |= (uint32_t)((uint32_t)icOffset << 16); + *(uint32_t *)&((t_AdOfTypeContLookup *)p_Ad)->pcAndOffsets = + tmpReg32; + p_Manip->updateParams &= ~INTERNAL_CONTEXT_OFFSET; + p_Manip->icOffset = icOffset; + } + else + { + if (p_Manip->icOffset != icOffset) + RETURN_ERROR( + MAJOR, + E_INVALID_VALUE, + ("this manipulation was updated previously by different value");); + } + break; + case (HMAN_OC_CAPWAP_RMV_DTLS_IF_EXIST): + if (p_Manip->h_Frag) + { + if (p_Manip->updateParams & INTERNAL_CONTEXT_OFFSET) { - tmpReg32 = *(uint32_t *)&((t_AdOfTypeContLookup *)p_Ad)->pcAndOffsets; - tmpReg32 |= (uint32_t)((uint32_t)icOffset << 16); - *(uint32_t *)&((t_AdOfTypeContLookup *)p_Ad)->pcAndOffsets = tmpReg32; + p_Ad = (t_AdOfTypeContLookup *)p_Manip->h_Ad; + tmpReg32 |= GET_UINT32(((t_AdOfTypeContLookup *)p_Ad)->pcAndOffsets); + tmpReg32 |= (uint32_t)((uint32_t)icOffset << 16); + WRITE_UINT32(((t_AdOfTypeContLookup *)p_Ad)->pcAndOffsets, tmpReg32); p_Manip->updateParams &= ~INTERNAL_CONTEXT_OFFSET; p_Manip->icOffset = icOffset; } else { if (p_Manip->icOffset != icOffset) - RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("this manipulation was updated previously by different value");); - } - break; -#ifdef FM_CAPWAP_SUPPORT - case (HMAN_OC_CAPWAP_RMV_DTLS_IF_EXIST): - if (p_Manip->h_Frag) - { - if (p_Manip->updateParams & INTERNAL_CONTEXT_OFFSET) - { - p_Ad = (t_AdOfTypeContLookup *)p_Manip->h_Ad; - tmpReg32 |= GET_UINT32(((t_AdOfTypeContLookup *)p_Ad)->pcAndOffsets); - tmpReg32 |= (uint32_t)((uint32_t)icOffset << 16); - WRITE_UINT32(((t_AdOfTypeContLookup *)p_Ad)->pcAndOffsets, tmpReg32); - p_Manip->updateParams &= ~INTERNAL_CONTEXT_OFFSET; - p_Manip->icOffset = icOffset; - } - else - { - if (p_Manip->icOffset != icOffset) - RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("this manipulation was updated previousely by different value");); - } + RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("this manipulation was updated previousely by different value");); } - break; -#endif /* FM_CAPWAP_SUPPORT */ + } + break; } return E_OK; } -static t_Error UpdateInitMvIntFrameHeaderFromFrameToBufferPrefix(t_Handle h_FmPort, t_FmPcdManip *p_Manip, t_Handle h_Ad, bool validate) +static t_Error UpdateInitMvIntFrameHeaderFromFrameToBufferPrefix( + t_Handle h_FmPort, t_FmPcdManip *p_Manip, t_Handle h_Ad, bool validate) { - t_AdOfTypeContLookup *p_Ad = (t_AdOfTypeContLookup *)h_Ad; - t_FmPortGetSetCcParams fmPortGetSetCcParams; - t_Error err; - uint32_t tmpReg32; + t_AdOfTypeContLookup *p_Ad = (t_AdOfTypeContLookup *)h_Ad; + t_FmPortGetSetCcParams fmPortGetSetCcParams; + t_Error err; + uint32_t tmpReg32; memset(&fmPortGetSetCcParams, 0, sizeof(t_FmPortGetSetCcParams)); - SANITY_CHECK_RETURN_ERROR(p_Manip,E_INVALID_HANDLE); - SANITY_CHECK_RETURN_ERROR((p_Manip->opcode & HMAN_OC_MV_INT_FRAME_HDR_FROM_FRM_TO_BUFFER_PREFFIX), E_INVALID_STATE); + SANITY_CHECK_RETURN_ERROR(p_Manip, E_INVALID_HANDLE); + SANITY_CHECK_RETURN_ERROR( + (p_Manip->opcode & HMAN_OC_MV_INT_FRAME_HDR_FROM_FRM_TO_BUFFER_PREFFIX), + E_INVALID_STATE); SANITY_CHECK_RETURN_ERROR(!p_Manip->muramAllocate, E_INVALID_STATE); if (p_Manip->updateParams) { - if ((!(p_Manip->updateParams & OFFSET_OF_PR)) || - (p_Manip->shadowUpdateParams & OFFSET_OF_PR)) - RETURN_ERROR(MAJOR, E_INVALID_STATE, ("in this stage parameters from Port has not be updated")); + if ((!(p_Manip->updateParams & OFFSET_OF_PR)) + || (p_Manip->shadowUpdateParams & OFFSET_OF_PR)) + RETURN_ERROR( + MAJOR, E_INVALID_STATE, + ("in this stage parameters from Port has not be updated")); fmPortGetSetCcParams.getCcParams.type = p_Manip->updateParams; fmPortGetSetCcParams.setCcParams.type = UPDATE_PSO; @@ -946,27 +1407,34 @@ static t_Error UpdateInitMvIntFrameHeaderFromFrameToBufferPrefix(t_Handle h_FmPo err = FmPortGetSetCcParams(h_FmPort, &fmPortGetSetCcParams); if (err) - RETURN_ERROR(MAJOR, err, NO_MSG); + RETURN_ERROR(MAJOR, err, NO_MSG); if (fmPortGetSetCcParams.getCcParams.type & OFFSET_OF_PR) - RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Parser result offset wasn't configured previousely")); + RETURN_ERROR( + MAJOR, E_INVALID_STATE, + ("Parser result offset wasn't configured previousely")); #ifdef FM_LOCKUP_ALIGNMENT_ERRATA_FMAN_SW004 ASSERT_COND(!(fmPortGetSetCcParams.getCcParams.prOffset % 16)); #endif } - else if (validate) + else + if (validate) { - if ((!(p_Manip->shadowUpdateParams & OFFSET_OF_PR)) || - (p_Manip->updateParams & OFFSET_OF_PR)) - RETURN_ERROR(MAJOR, E_INVALID_STATE, ("in this stage parameters from Port has be updated")); + if ((!(p_Manip->shadowUpdateParams & OFFSET_OF_PR)) + || (p_Manip->updateParams & OFFSET_OF_PR)) + RETURN_ERROR( + MAJOR, E_INVALID_STATE, + ("in this stage parameters from Port has be updated")); fmPortGetSetCcParams.getCcParams.type = p_Manip->shadowUpdateParams; fmPortGetSetCcParams.setCcParams.type = UPDATE_PSO; fmPortGetSetCcParams.setCcParams.psoSize = 16; err = FmPortGetSetCcParams(h_FmPort, &fmPortGetSetCcParams); if (err) - RETURN_ERROR(MAJOR, err, NO_MSG); + RETURN_ERROR(MAJOR, err, NO_MSG); if (fmPortGetSetCcParams.getCcParams.type & OFFSET_OF_PR) - RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Parser result offset wasn't configured previousely")); + RETURN_ERROR( + MAJOR, E_INVALID_STATE, + ("Parser result offset wasn't configured previousely")); } @@ -976,76 +1444,80 @@ static t_Error UpdateInitMvIntFrameHeaderFromFrameToBufferPrefix(t_Handle h_FmPo { tmpReg32 = 0; tmpReg32 |= fmPortGetSetCcParams.getCcParams.prOffset; - WRITE_UINT32(p_Ad->matchTblPtr, (GET_UINT32(p_Ad->matchTblPtr) | tmpReg32)); + WRITE_UINT32(p_Ad->matchTblPtr, + (GET_UINT32(p_Ad->matchTblPtr) | tmpReg32)); p_Manip->updateParams &= ~OFFSET_OF_PR; p_Manip->shadowUpdateParams |= OFFSET_OF_PR; } - else if (validate) + else + if (validate) { tmpReg32 = GET_UINT32(p_Ad->matchTblPtr); if ((uint8_t)tmpReg32 != fmPortGetSetCcParams.getCcParams.prOffset) - RETURN_ERROR(MAJOR, E_INVALID_STATE, ("this manipulation was updated previousely by different value");); + RETURN_ERROR( + MAJOR, + E_INVALID_STATE, + ("this manipulation was updated previousely by different value");); } return E_OK; } -#ifdef FM_CAPWAP_SUPPORT static t_Error UpdateModifyCapwapFragmenation(t_FmPcdManip *p_Manip, t_Handle h_Ad, bool validate,t_Handle h_FmTree) { - t_AdOfTypeContLookup *p_Ad = (t_AdOfTypeContLookup *)h_Ad; - t_FmPcdCcSavedManipParams *p_SavedManipParams = NULL; - uint32_t tmpReg32 = 0; + t_AdOfTypeContLookup *p_Ad = (t_AdOfTypeContLookup *)h_Ad; + t_FmPcdCcSavedManipParams *p_SavedManipParams = NULL; + uint32_t tmpReg32 = 0; SANITY_CHECK_RETURN_ERROR(p_Manip,E_INVALID_HANDLE); SANITY_CHECK_RETURN_ERROR(p_Manip->h_Frag,E_INVALID_HANDLE); SANITY_CHECK_RETURN_ERROR(p_Manip->frag,E_INVALID_HANDLE); SANITY_CHECK_RETURN_ERROR(((p_Manip->opcode == HMAN_OC_CAPWAP_FRAGMENTATION) || (p_Manip->opcode == HMAN_OC_INSRT_HDR_BY_TEMPL_N_OR_FRAG_AFTER)), E_INVALID_STATE); - p_Ad = (t_AdOfTypeContLookup *)p_Manip->h_Frag; + p_Ad = (t_AdOfTypeContLookup *)p_Manip->h_Frag; if (p_Manip->updateParams) { if ((!(p_Manip->updateParams & OFFSET_OF_DATA)) || - ((p_Manip->shadowUpdateParams & OFFSET_OF_DATA))) - RETURN_ERROR(MAJOR, E_INVALID_STATE, ("in this stage parameters from Port has not be updated")); + ((p_Manip->shadowUpdateParams & OFFSET_OF_DATA))) + RETURN_ERROR(MAJOR, E_INVALID_STATE, ("in this stage parameters from Port has not be updated")); p_SavedManipParams = FmPcdCcTreeGetSavedManipParams(h_FmTree); if (!p_SavedManipParams) - RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("for this manipulation tree has to be configured previosely with this type")); - p_Manip->fragParams.dataOffset = p_SavedManipParams->capwapParams.dataOffset; + RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("for this manipulation tree has to be configured previosely with this type")); + p_Manip->capwapFragParams.dataOffset = p_SavedManipParams->capwapParams.dataOffset; tmpReg32 = GET_UINT32(p_Ad->pcAndOffsets); - tmpReg32 |= ((uint32_t)p_Manip->fragParams.dataOffset<< 16); + tmpReg32 |= ((uint32_t)p_Manip->capwapFragParams.dataOffset<< 16); WRITE_UINT32(p_Ad->pcAndOffsets,tmpReg32); p_Manip->updateParams &= ~OFFSET_OF_DATA; p_Manip->shadowUpdateParams |= OFFSET_OF_DATA; } - else if (validate) - { + else if (validate) + { p_SavedManipParams = FmPcdCcTreeGetSavedManipParams(h_FmTree); if (!p_SavedManipParams) - RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("for this manipulation tree has to be configured previosely with this type")); - if (p_Manip->fragParams.dataOffset != p_SavedManipParams->capwapParams.dataOffset) - RETURN_ERROR(MAJOR, E_INVALID_STATE, ("this manipulation was updated previousely by different value")); - } + RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("for this manipulation tree has to be configured previosely with this type")); + if (p_Manip->capwapFragParams.dataOffset != p_SavedManipParams->capwapParams.dataOffset) + RETURN_ERROR(MAJOR, E_INVALID_STATE, ("this manipulation was updated previousely by different value")); + } return E_OK; } -static t_Error UpdateInitCapwapFragmentation(t_Handle h_FmPort, - t_FmPcdManip *p_Manip, - t_Handle h_Ad, - bool validate, - t_Handle h_FmTree) +static t_Error UpdateInitCapwapFragmentation(t_Handle h_FmPort, + t_FmPcdManip *p_Manip, + t_Handle h_Ad, + bool validate, + t_Handle h_FmTree) { - t_AdOfTypeContLookup *p_Ad; - t_FmPortGetSetCcParams fmPortGetSetCcParams; - t_Error err; - uint32_t tmpReg32 = 0; - t_FmPcdCcSavedManipParams *p_SavedManipParams; + t_AdOfTypeContLookup *p_Ad; + t_FmPortGetSetCcParams fmPortGetSetCcParams; + t_Error err; + uint32_t tmpReg32 = 0; + t_FmPcdCcSavedManipParams *p_SavedManipParams; UNUSED(h_Ad); @@ -1053,15 +1525,15 @@ static t_Error UpdateInitCapwapFragmentation(t_Handle h_FmPort, SANITY_CHECK_RETURN_ERROR(p_Manip->h_Frag,E_INVALID_HANDLE); SANITY_CHECK_RETURN_ERROR(p_Manip->frag,E_INVALID_HANDLE); SANITY_CHECK_RETURN_ERROR(((p_Manip->opcode == HMAN_OC_CAPWAP_FRAGMENTATION) || - (p_Manip->opcode == HMAN_OC_INSRT_HDR_BY_TEMPL_N_OR_FRAG_AFTER)), E_INVALID_STATE); + (p_Manip->opcode == HMAN_OC_INSRT_HDR_BY_TEMPL_N_OR_FRAG_AFTER)), E_INVALID_STATE); - p_Ad = (t_AdOfTypeContLookup *)p_Manip->h_Frag; + p_Ad = (t_AdOfTypeContLookup *)p_Manip->h_Frag; if (p_Manip->updateParams) { if ((!(p_Manip->updateParams & OFFSET_OF_DATA)) || - ((p_Manip->shadowUpdateParams & OFFSET_OF_DATA))) - RETURN_ERROR(MAJOR, E_INVALID_STATE, ("in this stage parameters from Port has not be updated")); + ((p_Manip->shadowUpdateParams & OFFSET_OF_DATA))) + RETURN_ERROR(MAJOR, E_INVALID_STATE, ("in this stage parameters from Port has not be updated")); fmPortGetSetCcParams.getCcParams.type = p_Manip->updateParams; fmPortGetSetCcParams.setCcParams.type = UPDATE_NIA_PNEN | UPDATE_FMFP_PRC_WITH_ONE_RISC_ONLY; fmPortGetSetCcParams.setCcParams.nia = NIA_FM_CTL_AC_POP_TO_N_STEP | NIA_ENG_FM_CTL; @@ -1070,10 +1542,10 @@ static t_Error UpdateInitCapwapFragmentation(t_Handle h_FmPort, err = FmPortGetSetCcParams(h_FmPort, &fmPortGetSetCcParams); if (err) - RETURN_ERROR(MAJOR, err, NO_MSG); + RETURN_ERROR(MAJOR, err, NO_MSG); if (fmPortGetSetCcParams.getCcParams.type & OFFSET_OF_DATA) - RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Data offset wasn't configured previousely")); + RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Data offset wasn't configured previousely")); p_SavedManipParams = (t_FmPcdCcSavedManipParams *)XX_Malloc(sizeof(t_FmPcdCcSavedManipParams)); p_SavedManipParams->capwapParams.dataOffset = fmPortGetSetCcParams.getCcParams.dataOffset; @@ -1087,17 +1559,17 @@ static t_Error UpdateInitCapwapFragmentation(t_Handle h_FmPort, else if (validate) { if ((!(p_Manip->shadowUpdateParams & OFFSET_OF_DATA)) || - ((p_Manip->updateParams & OFFSET_OF_DATA))) - RETURN_ERROR(MAJOR, E_INVALID_STATE, ("in this stage parameters from Port has be updated")); + ((p_Manip->updateParams & OFFSET_OF_DATA))) + RETURN_ERROR(MAJOR, E_INVALID_STATE, ("in this stage parameters from Port has be updated")); fmPortGetSetCcParams.getCcParams.type = p_Manip->shadowUpdateParams; fmPortGetSetCcParams.setCcParams.type = UPDATE_NIA_PNEN | UPDATE_FMFP_PRC_WITH_ONE_RISC_ONLY; fmPortGetSetCcParams.setCcParams.nia = NIA_FM_CTL_AC_POP_TO_N_STEP | NIA_ENG_FM_CTL; err = FmPortGetSetCcParams(h_FmPort, &fmPortGetSetCcParams); if (err) - RETURN_ERROR(MAJOR, err, NO_MSG); + RETURN_ERROR(MAJOR, err, NO_MSG); if (fmPortGetSetCcParams.getCcParams.type & OFFSET_OF_DATA) - RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Data offset wasn't configured previousely")); + RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Data offset wasn't configured previousely")); } if (p_Manip->updateParams) @@ -1108,31 +1580,31 @@ static t_Error UpdateInitCapwapFragmentation(t_Handle h_FmPort, p_Manip->updateParams &= ~OFFSET_OF_DATA; p_Manip->shadowUpdateParams |= OFFSET_OF_DATA; - p_Manip->fragParams.dataOffset = fmPortGetSetCcParams.getCcParams.dataOffset; + p_Manip->capwapFragParams.dataOffset = fmPortGetSetCcParams.getCcParams.dataOffset; } else if (validate) { - if (p_Manip->fragParams.dataOffset != fmPortGetSetCcParams.getCcParams.dataOffset) - RETURN_ERROR(MAJOR, E_INVALID_STATE, ("this manipulation was updated previousely by different value")); + if (p_Manip->capwapFragParams.dataOffset != fmPortGetSetCcParams.getCcParams.dataOffset) + RETURN_ERROR(MAJOR, E_INVALID_STATE, ("this manipulation was updated previousely by different value")); } return E_OK; } -static t_Error UpdateInitCapwapReasm(t_Handle h_FmPcd, - t_Handle h_FmPort, - t_FmPcdManip *p_Manip, - t_Handle h_Ad, - bool validate) +static t_Error UpdateInitCapwapReasm(t_Handle h_FmPcd, + t_Handle h_FmPort, + t_FmPcdManip *p_Manip, + t_Handle h_Ad, + bool validate) { - t_CapwapReasmPram *p_ReassmTbl; - t_Error err; - t_FmPortGetSetCcParams fmPortGetSetCcParams; - uint8_t i = 0; - uint16_t size; - uint32_t tmpReg32; - t_FmPcd *p_FmPcd = (t_FmPcd *)h_FmPcd; - t_FmPcdCcCapwapReassmTimeoutParams ccCapwapReassmTimeoutParams; + t_CapwapReasmPram *p_ReassmTbl; + t_Error err; + t_FmPortGetSetCcParams fmPortGetSetCcParams; + uint8_t i = 0; + uint16_t size; + uint32_t tmpReg32; + t_FmPcd *p_FmPcd = (t_FmPcd *)h_FmPcd; + t_FmPcdCcCapwapReassmTimeoutParams ccCapwapReassmTimeoutParams; SANITY_CHECK_RETURN_ERROR(p_Manip,E_INVALID_HANDLE); SANITY_CHECK_RETURN_ERROR(p_Manip->h_Frag,E_INVALID_HANDLE); @@ -1142,24 +1614,24 @@ static t_Error UpdateInitCapwapReasm(t_Handle h_FmPcd, SANITY_CHECK_RETURN_ERROR(p_FmPcd->h_Hc,E_INVALID_HANDLE); if (p_Manip->h_FmPcd != h_FmPcd) - RETURN_ERROR(MAJOR, E_INVALID_STATE, - ("handler of PCD previously was initiated by different value")); + RETURN_ERROR(MAJOR, E_INVALID_STATE, + ("handler of PCD previously was initiated by different value")); UNUSED(h_Ad); memset(&fmPortGetSetCcParams, 0, sizeof(t_FmPortGetSetCcParams)); - p_ReassmTbl = (t_CapwapReasmPram *)p_Manip->h_Frag; + p_ReassmTbl = (t_CapwapReasmPram *)p_Manip->h_Frag; if (p_Manip->updateParams) { if ((!(p_Manip->updateParams & NUM_OF_TASKS) && - !(p_Manip->updateParams & OFFSET_OF_DATA) && - !(p_Manip->updateParams & OFFSET_OF_PR) && - !(p_Manip->updateParams & HW_PORT_ID)) || - ((p_Manip->shadowUpdateParams & NUM_OF_TASKS) || - (p_Manip->shadowUpdateParams & OFFSET_OF_DATA) || (p_Manip->shadowUpdateParams & OFFSET_OF_PR) || - (p_Manip->shadowUpdateParams & HW_PORT_ID))) - RETURN_ERROR(MAJOR, E_INVALID_STATE, ("in this stage parameters from Port has not be updated")); + !(p_Manip->updateParams & OFFSET_OF_DATA) && + !(p_Manip->updateParams & OFFSET_OF_PR) && + !(p_Manip->updateParams & HW_PORT_ID)) || + ((p_Manip->shadowUpdateParams & NUM_OF_TASKS) || + (p_Manip->shadowUpdateParams & OFFSET_OF_DATA) || (p_Manip->shadowUpdateParams & OFFSET_OF_PR) || + (p_Manip->shadowUpdateParams & HW_PORT_ID))) + RETURN_ERROR(MAJOR, E_INVALID_STATE, ("in this stage parameters from Port has not be updated")); fmPortGetSetCcParams.getCcParams.type = p_Manip->updateParams; fmPortGetSetCcParams.setCcParams.type = UPDATE_NIA_PNEN; @@ -1167,28 +1639,28 @@ static t_Error UpdateInitCapwapReasm(t_Handle h_FmPcd, err = FmPortGetSetCcParams(h_FmPort, &fmPortGetSetCcParams); if (err) - RETURN_ERROR(MAJOR, err, NO_MSG); + RETURN_ERROR(MAJOR, err, NO_MSG); if (fmPortGetSetCcParams.getCcParams.type & NUM_OF_TASKS) - RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Num of tasks wasn't configured previousely")); + RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Num of tasks wasn't configured previousely")); if (fmPortGetSetCcParams.getCcParams.type & OFFSET_OF_DATA) - RETURN_ERROR(MAJOR, E_INVALID_STATE, ("offset of the data wasn't configured previousely")); + RETURN_ERROR(MAJOR, E_INVALID_STATE, ("offset of the data wasn't configured previousely")); if (fmPortGetSetCcParams.getCcParams.type & HW_PORT_ID) - RETURN_ERROR(MAJOR, E_INVALID_STATE, ("hwPortId wasn't updated")); + RETURN_ERROR(MAJOR, E_INVALID_STATE, ("hwPortId wasn't updated")); #ifdef FM_LOCKUP_ALIGNMENT_ERRATA_FMAN_SW004 ASSERT_COND((fmPortGetSetCcParams.getCcParams.dataOffset % 16) == 0); #endif /* FM_LOCKUP_ALIGNMENT_ERRATA_FMAN_SW004 */ } else if (validate) { - if ((!(p_Manip->shadowUpdateParams & NUM_OF_TASKS) && - !(p_Manip->shadowUpdateParams & OFFSET_OF_DATA) && - !(p_Manip->shadowUpdateParams & OFFSET_OF_PR) && - !(p_Manip->shadowUpdateParams & HW_PORT_ID)) && - ((p_Manip->updateParams & NUM_OF_TASKS) || - (p_Manip->updateParams & OFFSET_OF_DATA) || (p_Manip->updateParams & OFFSET_OF_PR) || - (p_Manip->updateParams & HW_PORT_ID))) - RETURN_ERROR(MAJOR, E_INVALID_STATE, ("in this stage parameters from Port has be updated")); + if ((!(p_Manip->shadowUpdateParams & NUM_OF_TASKS) && + !(p_Manip->shadowUpdateParams & OFFSET_OF_DATA) && + !(p_Manip->shadowUpdateParams & OFFSET_OF_PR) && + !(p_Manip->shadowUpdateParams & HW_PORT_ID)) && + ((p_Manip->updateParams & NUM_OF_TASKS) || + (p_Manip->updateParams & OFFSET_OF_DATA) || (p_Manip->updateParams & OFFSET_OF_PR) || + (p_Manip->updateParams & HW_PORT_ID))) + RETURN_ERROR(MAJOR, E_INVALID_STATE, ("in this stage parameters from Port has be updated")); fmPortGetSetCcParams.getCcParams.type = p_Manip->shadowUpdateParams; fmPortGetSetCcParams.setCcParams.type = UPDATE_NIA_PNEN; @@ -1196,14 +1668,14 @@ static t_Error UpdateInitCapwapReasm(t_Handle h_FmPcd, err = FmPortGetSetCcParams(h_FmPort, &fmPortGetSetCcParams); if (err) - RETURN_ERROR(MAJOR, err, NO_MSG); + RETURN_ERROR(MAJOR, err, NO_MSG); if (fmPortGetSetCcParams.getCcParams.type & NUM_OF_TASKS) - RETURN_ERROR(MAJOR, E_INVALID_STATE, ("NumOfTasks wasn't configured previously")); + RETURN_ERROR(MAJOR, E_INVALID_STATE, ("NumOfTasks wasn't configured previously")); if (fmPortGetSetCcParams.getCcParams.type & OFFSET_OF_DATA) - RETURN_ERROR(MAJOR, E_INVALID_STATE, ("offset of the data wasn't configured previously")); + RETURN_ERROR(MAJOR, E_INVALID_STATE, ("offset of the data wasn't configured previously")); if (fmPortGetSetCcParams.getCcParams.type & HW_PORT_ID) - RETURN_ERROR(MAJOR, E_INVALID_STATE, ("hwPortId wasn't updated")); + RETURN_ERROR(MAJOR, E_INVALID_STATE, ("hwPortId wasn't updated")); } if (p_Manip->updateParams) @@ -1211,57 +1683,57 @@ static t_Error UpdateInitCapwapReasm(t_Handle h_FmPcd, if (p_Manip->updateParams & NUM_OF_TASKS) { /*recommendation of Microcode team - (maxNumFramesInProcess * 2) */ - size = (uint16_t)(p_Manip->fragParams.maxNumFramesInProcess*2 + fmPortGetSetCcParams.getCcParams.numOfTasks); - if (size > 255) - RETURN_ERROR(MAJOR,E_INVALID_VALUE, ("numOfOpenReassmEntries + numOfTasks per port can not be greater than 256")); + size = (uint16_t)(p_Manip->capwapFragParams.maxNumFramesInProcess*2 + fmPortGetSetCcParams.getCcParams.numOfTasks); + if (size > 255) + RETURN_ERROR(MAJOR,E_INVALID_VALUE, ("numOfOpenReassmEntries + numOfTasks per port can not be greater than 256")); - p_Manip->fragParams.numOfTasks = fmPortGetSetCcParams.getCcParams.numOfTasks; + p_Manip->capwapFragParams.numOfTasks = fmPortGetSetCcParams.getCcParams.numOfTasks; /*p_ReassmFrmDescrIndxPoolTbl*/ - p_Manip->fragParams.p_ReassmFrmDescrIndxPoolTbl = - (t_Handle)FM_MURAM_AllocMem(p_FmPcd->h_FmMuram, - (uint32_t)(size + 1), - 4); - if (!p_Manip->fragParams.p_ReassmFrmDescrIndxPoolTbl) - RETURN_ERROR(MAJOR, E_NO_MEMORY, ("MURAM alloc for CAPWAP Reassembly frame buffer index pool table")); + p_Manip->capwapFragParams.p_ReassmFrmDescrIndxPoolTbl = + (t_Handle)FM_MURAM_AllocMem(p_FmPcd->h_FmMuram, + (uint32_t)(size + 1), + 4); + if (!p_Manip->capwapFragParams.p_ReassmFrmDescrIndxPoolTbl) + RETURN_ERROR(MAJOR, E_NO_MEMORY, ("MURAM alloc for CAPWAP Reassembly frame buffer index pool table")); - IOMemSet32(p_Manip->fragParams.p_ReassmFrmDescrIndxPoolTbl, 0, (uint32_t)(size + 1)); + IOMemSet32(p_Manip->capwapFragParams.p_ReassmFrmDescrIndxPoolTbl, 0, (uint32_t)(size + 1)); for ( i = 0; i < size; i++) - WRITE_UINT8(*(uint8_t *)PTR_MOVE(p_Manip->fragParams.p_ReassmFrmDescrIndxPoolTbl, i), (uint8_t)(i+1)); + WRITE_UINT8(*(uint8_t *)PTR_MOVE(p_Manip->capwapFragParams.p_ReassmFrmDescrIndxPoolTbl, i), (uint8_t)(i+1)); - tmpReg32 = (uint32_t)(XX_VirtToPhys(p_Manip->fragParams.p_ReassmFrmDescrIndxPoolTbl) - p_FmPcd->physicalMuramBase); + tmpReg32 = (uint32_t)(XX_VirtToPhys(p_Manip->capwapFragParams.p_ReassmFrmDescrIndxPoolTbl) - p_FmPcd->physicalMuramBase); WRITE_UINT32(p_ReassmTbl->reasmFrmDescIndexPoolTblPtr, tmpReg32); /*p_ReassmFrmDescrPoolTbl*/ - p_Manip->fragParams.p_ReassmFrmDescrPoolTbl = - (t_Handle)FM_MURAM_AllocMem(p_FmPcd->h_FmMuram, - (uint32_t)((size + 1) * FM_PCD_MANIP_CAPWAP_REASM_RFD_SIZE), - 4); + p_Manip->capwapFragParams.p_ReassmFrmDescrPoolTbl = + (t_Handle)FM_MURAM_AllocMem(p_FmPcd->h_FmMuram, + (uint32_t)((size + 1) * FM_PCD_MANIP_CAPWAP_REASM_RFD_SIZE), + 4); - if (!p_Manip->fragParams.p_ReassmFrmDescrPoolTbl) - RETURN_ERROR(MAJOR, E_NO_MEMORY, ("MURAM alloc for CAPWAP Reassembly frame buffer pool table")); + if (!p_Manip->capwapFragParams.p_ReassmFrmDescrPoolTbl) + RETURN_ERROR(MAJOR, E_NO_MEMORY, ("MURAM alloc for CAPWAP Reassembly frame buffer pool table")); - IOMemSet32(p_Manip->fragParams.p_ReassmFrmDescrPoolTbl, 0, (uint32_t)((size +1)* FM_PCD_MANIP_CAPWAP_REASM_RFD_SIZE)); + IOMemSet32(p_Manip->capwapFragParams.p_ReassmFrmDescrPoolTbl, 0, (uint32_t)((size +1)* FM_PCD_MANIP_CAPWAP_REASM_RFD_SIZE)); - tmpReg32 = (uint32_t)(XX_VirtToPhys(p_Manip->fragParams.p_ReassmFrmDescrPoolTbl) - p_FmPcd->physicalMuramBase); + tmpReg32 = (uint32_t)(XX_VirtToPhys(p_Manip->capwapFragParams.p_ReassmFrmDescrPoolTbl) - p_FmPcd->physicalMuramBase); WRITE_UINT32(p_ReassmTbl->reasmFrmDescPoolTblPtr, tmpReg32); /*p_TimeOutTbl*/ - p_Manip->fragParams.p_TimeOutTbl = - (t_Handle)FM_MURAM_AllocMem(p_FmPcd->h_FmMuram, - (uint32_t)((size + 1)* FM_PCD_MANIP_CAPWAP_REASM_TIME_OUT_ENTRY_SIZE), - 4); + p_Manip->capwapFragParams.p_TimeOutTbl = + (t_Handle)FM_MURAM_AllocMem(p_FmPcd->h_FmMuram, + (uint32_t)((size + 1)* FM_PCD_MANIP_CAPWAP_REASM_TIME_OUT_ENTRY_SIZE), + 4); - if (!p_Manip->fragParams.p_TimeOutTbl) - RETURN_ERROR(MAJOR, E_NO_MEMORY, ("MURAM alloc for CAPWAP Reassembly timeout table")); + if (!p_Manip->capwapFragParams.p_TimeOutTbl) + RETURN_ERROR(MAJOR, E_NO_MEMORY, ("MURAM alloc for CAPWAP Reassembly timeout table")); - IOMemSet32(p_Manip->fragParams.p_TimeOutTbl, 0, (uint16_t)((size + 1)*FM_PCD_MANIP_CAPWAP_REASM_TIME_OUT_ENTRY_SIZE)); + IOMemSet32(p_Manip->capwapFragParams.p_TimeOutTbl, 0, (uint16_t)((size + 1)*FM_PCD_MANIP_CAPWAP_REASM_TIME_OUT_ENTRY_SIZE)); - tmpReg32 = (uint32_t)(XX_VirtToPhys(p_Manip->fragParams.p_TimeOutTbl) - p_FmPcd->physicalMuramBase); + tmpReg32 = (uint32_t)(XX_VirtToPhys(p_Manip->capwapFragParams.p_TimeOutTbl) - p_FmPcd->physicalMuramBase); WRITE_UINT32(p_ReassmTbl->timeOutTblPtr, tmpReg32); p_Manip->updateParams &= ~NUM_OF_TASKS; @@ -1270,9 +1742,9 @@ static t_Error UpdateInitCapwapReasm(t_Handle h_FmPcd, if (p_Manip->updateParams & OFFSET_OF_DATA) { - p_Manip->fragParams.dataOffset = fmPortGetSetCcParams.getCcParams.dataOffset; + p_Manip->capwapFragParams.dataOffset = fmPortGetSetCcParams.getCcParams.dataOffset; tmpReg32 = GET_UINT32(p_ReassmTbl->mode); - tmpReg32|= p_Manip->fragParams.dataOffset; + tmpReg32|= p_Manip->capwapFragParams.dataOffset; WRITE_UINT32(p_ReassmTbl->mode, tmpReg32); p_Manip->updateParams &= ~OFFSET_OF_DATA; p_Manip->shadowUpdateParams |= OFFSET_OF_DATA; @@ -1280,83 +1752,84 @@ static t_Error UpdateInitCapwapReasm(t_Handle h_FmPcd, if (!(fmPortGetSetCcParams.getCcParams.type & OFFSET_OF_PR)) { - p_Manip->fragParams.prOffset = fmPortGetSetCcParams.getCcParams.prOffset; + p_Manip->capwapFragParams.prOffset = fmPortGetSetCcParams.getCcParams.prOffset; tmpReg32 = GET_UINT32(p_ReassmTbl->mode); tmpReg32|= FM_PCD_MANIP_CAPWAP_REASM_PR_COPY; WRITE_UINT32(p_ReassmTbl->mode, tmpReg32); tmpReg32 = GET_UINT32(p_ReassmTbl->intStatsTblPtr); - tmpReg32 |= (uint32_t)p_Manip->fragParams.prOffset << 24; + tmpReg32 |= (uint32_t)p_Manip->capwapFragParams.prOffset << 24; WRITE_UINT32(p_ReassmTbl->intStatsTblPtr, tmpReg32); - p_Manip->updateParams &= ~OFFSET_OF_PR; - p_Manip->shadowUpdateParams |= OFFSET_OF_PR; - } - else - { - p_Manip->fragParams.prOffset = 0xff; - p_Manip->updateParams &= ~OFFSET_OF_PR; - p_Manip->shadowUpdateParams |= OFFSET_OF_PR; - } - - p_Manip->fragParams.hwPortId = fmPortGetSetCcParams.getCcParams.hardwarePortId; - p_Manip->updateParams &= ~HW_PORT_ID; - p_Manip->shadowUpdateParams |= HW_PORT_ID; + p_Manip->updateParams &= ~OFFSET_OF_PR; + p_Manip->shadowUpdateParams |= OFFSET_OF_PR; + } + else + { + p_Manip->capwapFragParams.prOffset = 0xff; + p_Manip->updateParams &= ~OFFSET_OF_PR; + p_Manip->shadowUpdateParams |= OFFSET_OF_PR; + } + + p_Manip->capwapFragParams.hwPortId = fmPortGetSetCcParams.getCcParams.hardwarePortId; + p_Manip->updateParams &= ~HW_PORT_ID; + p_Manip->shadowUpdateParams |= HW_PORT_ID; /*timeout hc */ - ccCapwapReassmTimeoutParams.fqidForTimeOutFrames = p_Manip->fragParams.fqidForTimeOutFrames; - ccCapwapReassmTimeoutParams.portIdAndCapwapReassmTbl = (uint32_t)p_Manip->fragParams.hwPortId << 24; - ccCapwapReassmTimeoutParams.portIdAndCapwapReassmTbl |= (uint32_t)((XX_VirtToPhys(p_ReassmTbl) - p_FmPcd->physicalMuramBase)); - ccCapwapReassmTimeoutParams.timeoutRequestTime = (((uint32_t)1<<p_Manip->fragParams.bitFor1Micro) * p_Manip->fragParams.timeoutRoutineRequestTime)/2; - return FmHcPcdCcCapwapTimeoutReassm(p_FmPcd->h_Hc,&ccCapwapReassmTimeoutParams); + ccCapwapReassmTimeoutParams.fqidForTimeOutFrames = p_Manip->capwapFragParams.fqidForTimeOutFrames; + ccCapwapReassmTimeoutParams.portIdAndCapwapReassmTbl = (uint32_t)p_Manip->capwapFragParams.hwPortId << 24; + ccCapwapReassmTimeoutParams.portIdAndCapwapReassmTbl |= (uint32_t)((XX_VirtToPhys(p_ReassmTbl) - p_FmPcd->physicalMuramBase)); + ccCapwapReassmTimeoutParams.timeoutRequestTime = (((uint32_t)1<<p_Manip->capwapFragParams.bitFor1Micro) * p_Manip->capwapFragParams.timeoutRoutineRequestTime)/2; + return FmHcPcdCcCapwapTimeoutReassm(p_FmPcd->h_Hc,&ccCapwapReassmTimeoutParams); } else if (validate) { - if (fmPortGetSetCcParams.getCcParams.hardwarePortId != p_Manip->fragParams.hwPortId) - RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("Reassembly manipulation previously was assigned to another port")); - if (fmPortGetSetCcParams.getCcParams.numOfTasks != p_Manip->fragParams.numOfTasks) - RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("numOfTasks for this manipulation previously was defined by another value ")); - + if (fmPortGetSetCcParams.getCcParams.hardwarePortId != p_Manip->capwapFragParams.hwPortId) + RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("Reassembly manipulation previously was assigned to another port")); + if (fmPortGetSetCcParams.getCcParams.numOfTasks != p_Manip->capwapFragParams.numOfTasks) + RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("numOfTasks for this manipulation previously was defined by another value ")); if (!(fmPortGetSetCcParams.getCcParams.type & OFFSET_OF_PR)) { - if (p_Manip->fragParams.prOffset != fmPortGetSetCcParams.getCcParams.prOffset) - RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("Parse result offset previously was defined by another value ")); + if (p_Manip->capwapFragParams.prOffset != fmPortGetSetCcParams.getCcParams.prOffset) + RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("Parse result offset previously was defined by another value ")); } else { - if (p_Manip->fragParams.prOffset != 0xff) - RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("Parse result offset previously was defined by another value ")); + if (p_Manip->capwapFragParams.prOffset != 0xff) + RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("Parse result offset previously was defined by another value ")); } - if (fmPortGetSetCcParams.getCcParams.dataOffset != p_Manip->fragParams.dataOffset) - RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("Data offset previously was defined by another value ")); + if (fmPortGetSetCcParams.getCcParams.dataOffset != p_Manip->capwapFragParams.dataOffset) + RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("Data offset previously was defined by another value ")); } return E_OK; } -#endif /* FM_CAPWAP_SUPPORT */ +#endif /* (defined(FM_CAPWAP_SUPPORT) && (DPAA_VERSION == 10)) */ -t_Error FmPcdRegisterReassmPort(t_Handle h_FmPcd, t_Handle h_IpReasmCommonPramTbl) +t_Error FmPcdRegisterReassmPort(t_Handle h_FmPcd, t_Handle h_ReasmCommonPramTbl) { - t_FmPcd *p_FmPcd = (t_FmPcd*)h_FmPcd; - t_FmPcdCcIpReassmTimeoutParams ccIpReassmTimeoutParams = {0}; - t_Error err = E_OK; - uint8_t result; - uint32_t bitFor1Micro, tsbs, log2num; + t_FmPcd *p_FmPcd = (t_FmPcd*)h_FmPcd; + t_FmPcdCcReassmTimeoutParams ccReassmTimeoutParams = { 0 }; + t_Error err = E_OK; + uint8_t result; + uint32_t bitFor1Micro, tsbs, log2num; ASSERT_COND(p_FmPcd); - ASSERT_COND(h_IpReasmCommonPramTbl); + ASSERT_COND(h_ReasmCommonPramTbl); bitFor1Micro = FmGetTimeStampScale(p_FmPcd->h_Fm); bitFor1Micro = 32 - bitFor1Micro; - LOG2(FM_PCD_MANIP_IP_REASSM_TIMEOUT_THREAD_THRESH, log2num); + LOG2(FM_PCD_MANIP_REASM_TIMEOUT_THREAD_THRESH, log2num); tsbs = bitFor1Micro - log2num; - ccIpReassmTimeoutParams.iprcpt = (uint32_t)(XX_VirtToPhys(h_IpReasmCommonPramTbl) - p_FmPcd->physicalMuramBase); - ccIpReassmTimeoutParams.tsbs = (uint8_t)tsbs; - ccIpReassmTimeoutParams.activate = TRUE; - if ((err = FmHcPcdCcIpTimeoutReassm(p_FmPcd->h_Hc, &ccIpReassmTimeoutParams, &result)) != E_OK) + ccReassmTimeoutParams.iprcpt = (uint32_t)(XX_VirtToPhys( + h_ReasmCommonPramTbl) - p_FmPcd->physicalMuramBase); + ccReassmTimeoutParams.tsbs = (uint8_t)tsbs; + ccReassmTimeoutParams.activate = TRUE; + if ((err = FmHcPcdCcTimeoutReassm(p_FmPcd->h_Hc, &ccReassmTimeoutParams, + &result)) != E_OK) RETURN_ERROR(MAJOR, err, NO_MSG); switch (result) @@ -1366,9 +1839,12 @@ t_Error FmPcdRegisterReassmPort(t_Handle h_FmPcd, t_Handle h_IpReasmCommonPramTb case (1): RETURN_ERROR(MAJOR, E_NO_MEMORY, ("failed to allocate TNUM")); case (2): - RETURN_ERROR(MAJOR, E_NO_MEMORY, ("failed to allocate internal buffer from the HC-Port")); + RETURN_ERROR( + MAJOR, E_NO_MEMORY, + ("failed to allocate internal buffer from the HC-Port")); case (3): - RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("'Disable Timeout Task' with invalid IPRCPT")); + RETURN_ERROR(MAJOR, E_INVALID_VALUE, + ("'Disable Timeout Task' with invalid IPRCPT")); case (4): RETURN_ERROR(MAJOR, E_FULL, ("too many timeout tasks")); case (5): @@ -1379,137 +1855,188 @@ t_Error FmPcdRegisterReassmPort(t_Handle h_FmPcd, t_Handle h_IpReasmCommonPramTb return E_OK; } -static t_Error CreateIpReassCommonTable(t_FmPcdManip *p_Manip) +static t_Error CreateReassCommonTable(t_FmPcdManip *p_Manip) { - uint32_t tmpReg32 = 0, i; - uint64_t tmpReg64, size; - t_FmPcd *p_FmPcd = (t_FmPcd *)p_Manip->h_FmPcd; - t_Error err = E_OK; + uint32_t tmpReg32 = 0, i; + uint64_t tmpReg64, size; + t_FmPcd *p_FmPcd = (t_FmPcd *)p_Manip->h_FmPcd; + t_Error err = E_OK; - /* Allocation of the IP 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. - It contains parameters that are common to both the IPv4 reassembly function and IPv6 - reassembly function.*/ - p_Manip->ipReassmParams.p_IpReassCommonTbl = - (t_IpReassCommonTbl *)FM_MURAM_AllocMem(p_FmPcd->h_FmMuram, - FM_PCD_MANIP_IP_REASM_COMMON_PARAM_TABLE_SIZE, - FM_PCD_MANIP_IP_REASM_COMMON_PARAM_TABLE_ALIGN); + /* 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 = + (t_ReassCommonTbl *)FM_MURAM_AllocMem( + p_FmPcd->h_FmMuram, + FM_PCD_MANIP_REASM_COMMON_PARAM_TABLE_SIZE, + FM_PCD_MANIP_REASM_COMMON_PARAM_TABLE_ALIGN); - if (!p_Manip->ipReassmParams.p_IpReassCommonTbl) - RETURN_ERROR(MAJOR, E_NO_MEMORY, ("MURAM alloc for Reassembly common parameters table")); + if (!p_Manip->reassmParams.p_ReassCommonTbl) + RETURN_ERROR(MAJOR, E_NO_MEMORY, + ("MURAM alloc for Reassembly common parameters table")); - IOMemSet32(p_Manip->ipReassmParams.p_IpReassCommonTbl, 0, FM_PCD_MANIP_IP_REASM_COMMON_PARAM_TABLE_SIZE); + IOMemSet32(p_Manip->reassmParams.p_ReassCommonTbl, 0, + FM_PCD_MANIP_REASM_COMMON_PARAM_TABLE_SIZE); /* Setting the TimeOut Mode.*/ tmpReg32 = 0; - if (p_Manip->ipReassmParams.timeOutMode == e_FM_PCD_MANIP_TIME_OUT_BETWEEN_FRAMES) - tmpReg32 |= FM_PCD_MANIP_IP_REASM_TIME_OUT_BETWEEN_FRAMES; + if (p_Manip->reassmParams.timeOutMode + == e_FM_PCD_MANIP_TIME_OUT_BETWEEN_FRAMES) + tmpReg32 |= FM_PCD_MANIP_REASM_TIME_OUT_BETWEEN_FRAMES; /* Setting TimeOut FQID - Frames that time out are enqueued to this FQID. - In order to cause TimeOut frames to be discarded, this queue should be configured accordingly*/ - tmpReg32 |= p_Manip->ipReassmParams.fqidForTimeOutFrames; - WRITE_UINT32(p_Manip->ipReassmParams.p_IpReassCommonTbl->timeoutModeAndFqid, tmpReg32); + In order to cause TimeOut frames to be discarded, this queue should be configured accordingly*/ + tmpReg32 |= p_Manip->reassmParams.fqidForTimeOutFrames; + WRITE_UINT32(p_Manip->reassmParams.p_ReassCommonTbl->timeoutModeAndFqid, + tmpReg32); /* Calculation the size of IP Reassembly Frame Descriptor - number of frames that are allowed to be reassembled simultaneously + 129.*/ - size = p_Manip->ipReassmParams.maxNumFramesInProcess + 129; + size = p_Manip->reassmParams.maxNumFramesInProcess + 129; /*Allocation of IP Reassembly Frame Descriptor Indexes Pool - This pool resides in the MURAM */ - p_Manip->ipReassmParams.reassFrmDescrIndxPoolTblAddr = - PTR_TO_UINT(FM_MURAM_AllocMem(p_FmPcd->h_FmMuram, - (uint32_t)(size * 2), - 256)); - if (!p_Manip->ipReassmParams.reassFrmDescrIndxPoolTblAddr) - RETURN_ERROR(MAJOR, E_NO_MEMORY, ("MURAM alloc for Reassembly frame descriptor indexes pool")); - - IOMemSet32(UINT_TO_PTR(p_Manip->ipReassmParams.reassFrmDescrIndxPoolTblAddr), 0, (uint32_t)(size * 2)); + p_Manip->reassmParams.reassFrmDescrIndxPoolTblAddr = + PTR_TO_UINT(FM_MURAM_AllocMem(p_FmPcd->h_FmMuram, + (uint32_t)(size * 2), + 256)); + if (!p_Manip->reassmParams.reassFrmDescrIndxPoolTblAddr) + RETURN_ERROR( + MAJOR, E_NO_MEMORY, + ("MURAM alloc for Reassembly frame descriptor indexes pool")); + + IOMemSet32(UINT_TO_PTR(p_Manip->reassmParams.reassFrmDescrIndxPoolTblAddr), + 0, (uint32_t)(size * 2)); /* The entries in IP Reassembly Frame Descriptor Indexes Pool contains indexes starting with 1 up to - the maximum number of frames that are allowed to be reassembled simultaneously + 128. - The last entry in this pool must contain the index zero*/ - for (i=0; i<(size-1); i++) - WRITE_UINT16(*(uint16_t *)PTR_MOVE(UINT_TO_PTR(p_Manip->ipReassmParams.reassFrmDescrIndxPoolTblAddr), (i<<1)), - (uint16_t)(i+1)); + the maximum number of frames that are allowed to be reassembled simultaneously + 128. + The last entry in this pool must contain the index zero*/ + for (i = 0; i < (size - 1); i++) + WRITE_UINT16( + *(uint16_t *)PTR_MOVE(UINT_TO_PTR(p_Manip->reassmParams.reassFrmDescrIndxPoolTblAddr), (i<<1)), + (uint16_t)(i+1)); /* Sets the IP Reassembly Frame Descriptor Indexes Pool offset from MURAM */ - tmpReg32 = (uint32_t)(XX_VirtToPhys(UINT_TO_PTR(p_Manip->ipReassmParams.reassFrmDescrIndxPoolTblAddr)) - p_FmPcd->physicalMuramBase); - WRITE_UINT32(p_Manip->ipReassmParams.p_IpReassCommonTbl->reassFrmDescIndexPoolTblPtr, tmpReg32); + tmpReg32 = (uint32_t)(XX_VirtToPhys( + UINT_TO_PTR(p_Manip->reassmParams.reassFrmDescrIndxPoolTblAddr)) + - p_FmPcd->physicalMuramBase); + WRITE_UINT32( + p_Manip->reassmParams.p_ReassCommonTbl->reassFrmDescIndexPoolTblPtr, + tmpReg32); /* Allocation of the Reassembly Frame Descriptors Pool - This pool resides in external memory. - The number of entries in this pool should be equal to the number of entries in IP Reassembly Frame Descriptor Indexes Pool.*/ - p_Manip->ipReassmParams.reassFrmDescrPoolTblAddr = - PTR_TO_UINT(XX_MallocSmart((uint32_t)(size * 64), p_Manip->ipReassmParams.dataMemId, 64)); + The number of entries in this pool should be equal to the number of entries in IP Reassembly Frame Descriptor Indexes Pool.*/ + p_Manip->reassmParams.reassFrmDescrPoolTblAddr = + PTR_TO_UINT(XX_MallocSmart((uint32_t)(size * 64), p_Manip->reassmParams.dataMemId, 64)); - if (!p_Manip->ipReassmParams.reassFrmDescrPoolTblAddr) + if (!p_Manip->reassmParams.reassFrmDescrPoolTblAddr) RETURN_ERROR(MAJOR, E_NO_MEMORY, ("Memory allocation FAILED")); - IOMemSet32(UINT_TO_PTR(p_Manip->ipReassmParams.reassFrmDescrPoolTblAddr), 0, (uint32_t)(size * 64)); + IOMemSet32(UINT_TO_PTR(p_Manip->reassmParams.reassFrmDescrPoolTblAddr), 0, + (uint32_t)(size * 64)); /* Sets the Reassembly Frame Descriptors Pool and liodn offset*/ - tmpReg64 = (uint64_t)(XX_VirtToPhys(UINT_TO_PTR(p_Manip->ipReassmParams.reassFrmDescrPoolTblAddr))); - tmpReg64 |= ((uint64_t)(p_Manip->ipReassmParams.dataLiodnOffset & FM_PCD_MANIP_IP_REASM_LIODN_MASK) << (uint64_t)FM_PCD_MANIP_IP_REASM_LIODN_SHIFT); - tmpReg64 |= ((uint64_t)(p_Manip->ipReassmParams.dataLiodnOffset & FM_PCD_MANIP_IP_REASM_ELIODN_MASK) << (uint64_t)FM_PCD_MANIP_IP_REASM_ELIODN_SHIFT); - WRITE_UINT32(p_Manip->ipReassmParams.p_IpReassCommonTbl->liodnAndReassFrmDescPoolPtrHi, (uint32_t)(tmpReg64 >> 32)); - WRITE_UINT32(p_Manip->ipReassmParams.p_IpReassCommonTbl->reassFrmDescPoolPtrLow, (uint32_t)tmpReg64); + tmpReg64 = (uint64_t)(XX_VirtToPhys( + UINT_TO_PTR(p_Manip->reassmParams.reassFrmDescrPoolTblAddr))); + tmpReg64 |= ((uint64_t)(p_Manip->reassmParams.dataLiodnOffset + & FM_PCD_MANIP_REASM_LIODN_MASK) + << (uint64_t)FM_PCD_MANIP_REASM_LIODN_SHIFT); + tmpReg64 |= ((uint64_t)(p_Manip->reassmParams.dataLiodnOffset + & FM_PCD_MANIP_REASM_ELIODN_MASK) + << (uint64_t)FM_PCD_MANIP_REASM_ELIODN_SHIFT); + WRITE_UINT32( + p_Manip->reassmParams.p_ReassCommonTbl->liodnAndReassFrmDescPoolPtrHi, + (uint32_t)(tmpReg64 >> 32)); + WRITE_UINT32( + p_Manip->reassmParams.p_ReassCommonTbl->reassFrmDescPoolPtrLow, + (uint32_t)tmpReg64); /*Allocation of the TimeOut table - This table resides in the MURAM. - The number of entries in this table is identical to the number of entries in the Reassembly Frame Descriptors Pool*/ - p_Manip->ipReassmParams.timeOutTblAddr = - PTR_TO_UINT(FM_MURAM_AllocMem(p_FmPcd->h_FmMuram, (uint32_t)(size * 8),8)); + The number of entries in this table is identical to the number of entries in the Reassembly Frame Descriptors Pool*/ + p_Manip->reassmParams.timeOutTblAddr = + PTR_TO_UINT(FM_MURAM_AllocMem(p_FmPcd->h_FmMuram, (uint32_t)(size * 8),8)); - if (!p_Manip->ipReassmParams.timeOutTblAddr) - RETURN_ERROR(MAJOR, E_NO_MEMORY, ("MURAM alloc for Reassembly timeout table")); + if (!p_Manip->reassmParams.timeOutTblAddr) + RETURN_ERROR(MAJOR, E_NO_MEMORY, + ("MURAM alloc for Reassembly timeout table")); - IOMemSet32(UINT_TO_PTR(p_Manip->ipReassmParams.timeOutTblAddr), 0, (uint16_t)(size * 8)); + IOMemSet32(UINT_TO_PTR(p_Manip->reassmParams.timeOutTblAddr), 0, + (uint16_t)(size * 8)); /* Sets the TimeOut table offset from MURAM */ - tmpReg32 = (uint32_t)(XX_VirtToPhys(UINT_TO_PTR(p_Manip->ipReassmParams.timeOutTblAddr)) - p_FmPcd->physicalMuramBase); - WRITE_UINT32(p_Manip->ipReassmParams.p_IpReassCommonTbl->timeOutTblPtr, tmpReg32); + tmpReg32 = (uint32_t)(XX_VirtToPhys( + UINT_TO_PTR(p_Manip->reassmParams.timeOutTblAddr)) + - p_FmPcd->physicalMuramBase); + WRITE_UINT32(p_Manip->reassmParams.p_ReassCommonTbl->timeOutTblPtr, + tmpReg32); /* Sets the Expiration Delay */ tmpReg32 = 0; - tmpReg32 |= (((uint32_t)(1 << FmGetTimeStampScale(p_FmPcd->h_Fm))) * p_Manip->ipReassmParams.timeoutThresholdForReassmProcess); - WRITE_UINT32(p_Manip->ipReassmParams.p_IpReassCommonTbl->expirationDelay, tmpReg32); + tmpReg32 |= (((uint32_t)(1 << FmGetTimeStampScale(p_FmPcd->h_Fm))) + * p_Manip->reassmParams.timeoutThresholdForReassmProcess); + WRITE_UINT32(p_Manip->reassmParams.p_ReassCommonTbl->expirationDelay, + tmpReg32); - err = FmPcdRegisterReassmPort(p_FmPcd, p_Manip->ipReassmParams.p_IpReassCommonTbl); + err = FmPcdRegisterReassmPort(p_FmPcd, + p_Manip->reassmParams.p_ReassCommonTbl); if (err != E_OK) { - FM_MURAM_FreeMem(p_FmPcd->h_FmMuram, p_Manip->ipReassmParams.p_IpReassCommonTbl); + FM_MURAM_FreeMem(p_FmPcd->h_FmMuram, + p_Manip->reassmParams.p_ReassCommonTbl); RETURN_ERROR(MAJOR, err, ("port registration")); } return err; } -static t_Error CreateIpReassTable(t_FmPcdManip *p_Manip, bool ipv4) +static t_Error CreateReassTable(t_FmPcdManip *p_Manip, e_NetHeaderType hdr) { - t_FmPcd *p_FmPcd = p_Manip->h_FmPcd; - uint32_t tmpReg32, autoLearnHashTblSize; - uint32_t numOfWays, setSize, setSizeCode, keySize; - uint32_t waySize, numOfSets, numOfEntries; - uint64_t tmpReg64; - uint16_t minFragSize; - uintptr_t *p_AutoLearnHashTblAddr, *p_AutoLearnSetLockTblAddr; - t_IpReassTbl **p_IpReassTbl; - - if (ipv4) - { - p_IpReassTbl = &p_Manip->ipReassmParams.p_Ipv4ReassTbl; - p_AutoLearnHashTblAddr = &p_Manip->ipReassmParams.ipv4AutoLearnHashTblAddr; - p_AutoLearnSetLockTblAddr = &p_Manip->ipReassmParams.ipv4AutoLearnSetLockTblAddr; - minFragSize = p_Manip->ipReassmParams.minFragSize[0]; - numOfWays = p_Manip->ipReassmParams.numOfFramesPerHashEntry[0]; - keySize = 4 + 4 + 1 + 2; /* 3-tuple + IP-Id */ - } - else + t_FmPcd *p_FmPcd = p_Manip->h_FmPcd; + uint32_t tmpReg32, autoLearnHashTblSize; + uint32_t numOfWays, setSize, setSizeCode, keySize; + uint32_t waySize, numOfSets, numOfEntries; + uint64_t tmpReg64; + uint16_t minFragSize; + uint16_t maxReassemSize; + uintptr_t *p_AutoLearnHashTblAddr, *p_AutoLearnSetLockTblAddr; + t_ReassTbl **p_ReassTbl; + + switch (hdr) { - p_IpReassTbl = &p_Manip->ipReassmParams.p_Ipv6ReassTbl; - p_AutoLearnHashTblAddr = &p_Manip->ipReassmParams.ipv6AutoLearnHashTblAddr; - p_AutoLearnSetLockTblAddr = &p_Manip->ipReassmParams.ipv6AutoLearnSetLockTblAddr; - minFragSize = p_Manip->ipReassmParams.minFragSize[1]; - numOfWays = p_Manip->ipReassmParams.numOfFramesPerHashEntry[1]; - keySize = 16 + 16 + 4; /* 2-tuple + IP-Id */ - if (numOfWays > e_FM_PCD_MANIP_SIX_WAYS_HASH) - RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("num of ways")); + case HEADER_TYPE_IPv4: + p_ReassTbl = &p_Manip->reassmParams.ip.p_Ipv4ReassTbl; + p_AutoLearnHashTblAddr = + &p_Manip->reassmParams.ip.ipv4AutoLearnHashTblAddr; + p_AutoLearnSetLockTblAddr = + &p_Manip->reassmParams.ip.ipv4AutoLearnSetLockTblAddr; + minFragSize = p_Manip->reassmParams.ip.minFragSize[0]; + maxReassemSize = 0; + numOfWays = p_Manip->reassmParams.ip.numOfFramesPerHashEntry[0]; + keySize = 4 + 4 + 1 + 2; /* 3-tuple + IP-Id */ + break; + case HEADER_TYPE_IPv6: + p_ReassTbl = &p_Manip->reassmParams.ip.p_Ipv6ReassTbl; + p_AutoLearnHashTblAddr = + &p_Manip->reassmParams.ip.ipv6AutoLearnHashTblAddr; + p_AutoLearnSetLockTblAddr = + &p_Manip->reassmParams.ip.ipv6AutoLearnSetLockTblAddr; + minFragSize = p_Manip->reassmParams.ip.minFragSize[1]; + maxReassemSize = 0; + numOfWays = p_Manip->reassmParams.ip.numOfFramesPerHashEntry[1]; + keySize = 16 + 16 + 4; /* 2-tuple + IP-Id */ + if (numOfWays > e_FM_PCD_MANIP_SIX_WAYS_HASH) + RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("num of ways")); + break; + case HEADER_TYPE_CAPWAP: + p_ReassTbl = &p_Manip->reassmParams.capwap.p_ReassTbl; + p_AutoLearnHashTblAddr = + &p_Manip->reassmParams.capwap.autoLearnHashTblAddr; + p_AutoLearnSetLockTblAddr = + &p_Manip->reassmParams.capwap.autoLearnSetLockTblAddr; + minFragSize = 0; + maxReassemSize = p_Manip->reassmParams.capwap.maxRessembledsSize; + numOfWays = p_Manip->reassmParams.capwap.numOfFramesPerHashEntry; + keySize = 4; + break; + default: + break; } keySize += 2; /* 2 bytes reserved for RFDIndex */ #if (DPAA_VERSION >= 11) @@ -1517,17 +2044,19 @@ static t_Error CreateIpReassTable(t_FmPcdManip *p_Manip, bool ipv4) #endif /* (DPAA_VERSION >= 11) */ waySize = ROUND_UP(keySize, 8); - /* Allocates the IP Reassembly Parameters Table - This table is located in the MURAM.*/ - *p_IpReassTbl = (t_IpReassTbl *)FM_MURAM_AllocMem(p_FmPcd->h_FmMuram, - FM_PCD_MANIP_IP_REASM_TABLE_SIZE, - FM_PCD_MANIP_IP_REASM_TABLE_ALIGN); - if (!*p_IpReassTbl) - RETURN_ERROR(MAJOR, E_NO_MEMORY, ("MURAM alloc for Reassembly IPv4/IPv6 specific parameters table")); - memset(*p_IpReassTbl, 0, sizeof(t_IpReassTbl)); + /* Allocates the Reassembly Parameters Table - This table is located in the MURAM.*/ + *p_ReassTbl = (t_ReassTbl *)FM_MURAM_AllocMem( + p_FmPcd->h_FmMuram, FM_PCD_MANIP_REASM_TABLE_SIZE, + FM_PCD_MANIP_REASM_TABLE_ALIGN); + if (!*p_ReassTbl) + RETURN_ERROR( MAJOR, E_NO_MEMORY, + ("MURAM alloc for Reassembly specific parameters table")); + memset(*p_ReassTbl, 0, sizeof(t_ReassTbl)); - /* Sets the IP Reassembly common Parameters table offset from MURAM in the IP Reassembly Table descriptor*/ - tmpReg32 = (uint32_t)(XX_VirtToPhys(p_Manip->ipReassmParams.p_IpReassCommonTbl) - p_FmPcd->physicalMuramBase); - WRITE_UINT32((*p_IpReassTbl)->ipReassCommonPrmTblPtr, tmpReg32); + /* Sets the Reassembly common Parameters table offset from MURAM in the Reassembly Table descriptor*/ + tmpReg32 = (uint32_t)(XX_VirtToPhys(p_Manip->reassmParams.p_ReassCommonTbl) + - p_FmPcd->physicalMuramBase); + WRITE_UINT32((*p_ReassTbl)->reassCommonPrmTblPtr, tmpReg32); /* Calculate set size (set size is rounded-up to next power of 2) */ NEXT_POWER_OF_2(numOfWays * waySize, setSize); @@ -1536,12 +2065,13 @@ static t_Error CreateIpReassTable(t_FmPcdManip *p_Manip, bool ipv4) LOG2(setSize, setSizeCode); /* Sets ways number and set size code */ - WRITE_UINT16((*p_IpReassTbl)->waysNumAndSetSize, (uint16_t)((numOfWays << 8) | setSizeCode)); + WRITE_UINT16((*p_ReassTbl)->waysNumAndSetSize, + (uint16_t)((numOfWays << 8) | setSizeCode)); /* It is recommended that the total number of entries in this table - (number of sets * number of ways) will be twice the number of frames that + (number of sets * number of ways) will be twice the number of frames that are expected to be reassembled simultaneously.*/ - numOfEntries = (uint32_t)(p_Manip->ipReassmParams.maxNumFramesInProcess * 2); + numOfEntries = (uint32_t)(p_Manip->reassmParams.maxNumFramesInProcess * 2); /* sets number calculation - number of entries = number of sets * number of ways */ numOfSets = numOfEntries / numOfWays; @@ -1549,77 +2079,92 @@ static t_Error CreateIpReassTable(t_FmPcdManip *p_Manip, bool ipv4) /* Sets AutoLearnHashKeyMask*/ NEXT_POWER_OF_2(numOfSets, numOfSets); - WRITE_UINT16((*p_IpReassTbl)->autoLearnHashKeyMask, (uint16_t)(numOfSets - 1)); + WRITE_UINT16((*p_ReassTbl)->autoLearnHashKeyMask, + (uint16_t)(numOfSets - 1)); - /* Allocation of IP Reassembly Automatic Learning Hash Table - This table resides in external memory. - The size of this table is determined by the number of sets and the set size. - Table size = set size * number of sets - This table base address should be aligned to SetSize.*/ + /* Allocation of Reassembly Automatic Learning Hash Table - This table resides in external memory. + The size of this table is determined by the number of sets and the set size. + Table size = set size * number of sets + This table base address should be aligned to SetSize.*/ autoLearnHashTblSize = numOfSets * setSize; - *p_AutoLearnHashTblAddr = PTR_TO_UINT(XX_MallocSmart(autoLearnHashTblSize, p_Manip->ipReassmParams.dataMemId, setSize)); + *p_AutoLearnHashTblAddr = + PTR_TO_UINT(XX_MallocSmart(autoLearnHashTblSize, p_Manip->reassmParams.dataMemId, setSize)); if (!*p_AutoLearnHashTblAddr) { - FM_MURAM_FreeMem(p_FmPcd->h_FmMuram, *p_IpReassTbl); - *p_IpReassTbl = NULL; + FM_MURAM_FreeMem(p_FmPcd->h_FmMuram, *p_ReassTbl); + *p_ReassTbl = NULL; RETURN_ERROR(MAJOR, E_NO_MEMORY, ("Memory allocation FAILED")); } - IOMemSet32(UINT_TO_PTR(*p_AutoLearnHashTblAddr), 0, autoLearnHashTblSize); - - /* Sets the IP Reassembly Automatic Learning Hash Table and liodn offset */ - tmpReg64 = ((uint64_t)(p_Manip->ipReassmParams.dataLiodnOffset & FM_PCD_MANIP_IP_REASM_LIODN_MASK) << (uint64_t)FM_PCD_MANIP_IP_REASM_LIODN_SHIFT); - tmpReg64 |= ((uint64_t)(p_Manip->ipReassmParams.dataLiodnOffset & FM_PCD_MANIP_IP_REASM_ELIODN_MASK) << (uint64_t)FM_PCD_MANIP_IP_REASM_ELIODN_SHIFT); + IOMemSet32(UINT_TO_PTR(*p_AutoLearnHashTblAddr), 0, autoLearnHashTblSize); + + /* Sets the Reassembly Automatic Learning Hash Table and liodn offset */ + tmpReg64 = ((uint64_t)(p_Manip->reassmParams.dataLiodnOffset + & FM_PCD_MANIP_REASM_LIODN_MASK) + << (uint64_t)FM_PCD_MANIP_REASM_LIODN_SHIFT); + tmpReg64 |= ((uint64_t)(p_Manip->reassmParams.dataLiodnOffset + & FM_PCD_MANIP_REASM_ELIODN_MASK) + << (uint64_t)FM_PCD_MANIP_REASM_ELIODN_SHIFT); tmpReg64 |= XX_VirtToPhys(UINT_TO_PTR(*p_AutoLearnHashTblAddr)); - WRITE_UINT32((*p_IpReassTbl)->liodnAlAndAutoLearnHashTblPtrHi, (uint32_t)(tmpReg64 >> 32)); - WRITE_UINT32((*p_IpReassTbl)->autoLearnHashTblPtrLow, (uint32_t)tmpReg64); + WRITE_UINT32( (*p_ReassTbl)->liodnAlAndAutoLearnHashTblPtrHi, + (uint32_t)(tmpReg64 >> 32)); + WRITE_UINT32((*p_ReassTbl)->autoLearnHashTblPtrLow, (uint32_t)tmpReg64); /* Allocation of the Set Lock table - This table resides in external memory - The size of this table is (number of sets in the IP Reassembly Automatic Learning Hash table)*4 bytes. - This table resides in external memory and its base address should be 4-byte aligned */ - *p_AutoLearnSetLockTblAddr = PTR_TO_UINT(XX_MallocSmart((uint32_t)(numOfSets * 4), p_Manip->ipReassmParams.dataMemId, 4)); + The size of this table is (number of sets in the Reassembly Automatic Learning Hash table)*4 bytes. + This table resides in external memory and its base address should be 4-byte aligned */ + *p_AutoLearnSetLockTblAddr = + PTR_TO_UINT(XX_MallocSmart((uint32_t)(numOfSets * 4), p_Manip->reassmParams.dataMemId, 4)); if (!*p_AutoLearnSetLockTblAddr) { - FM_MURAM_FreeMem(p_FmPcd->h_FmMuram, *p_IpReassTbl); - *p_IpReassTbl = NULL; + FM_MURAM_FreeMem(p_FmPcd->h_FmMuram, *p_ReassTbl); + *p_ReassTbl = NULL; XX_FreeSmart(UINT_TO_PTR(*p_AutoLearnHashTblAddr)); *p_AutoLearnHashTblAddr = 0; RETURN_ERROR(MAJOR, E_NO_MEMORY, ("Memory allocation FAILED")); } - IOMemSet32(UINT_TO_PTR(*p_AutoLearnSetLockTblAddr), 0, (numOfSets * 4)); + IOMemSet32(UINT_TO_PTR(*p_AutoLearnSetLockTblAddr), 0, (numOfSets * 4)); /* sets Set Lock table pointer and liodn offset*/ - tmpReg64 = ((uint64_t)(p_Manip->ipReassmParams.dataLiodnOffset & FM_PCD_MANIP_IP_REASM_LIODN_MASK) << (uint64_t)FM_PCD_MANIP_IP_REASM_LIODN_SHIFT); - tmpReg64 |= ((uint64_t)(p_Manip->ipReassmParams.dataLiodnOffset & FM_PCD_MANIP_IP_REASM_ELIODN_MASK) << (uint64_t)FM_PCD_MANIP_IP_REASM_ELIODN_SHIFT); + tmpReg64 = ((uint64_t)(p_Manip->reassmParams.dataLiodnOffset + & FM_PCD_MANIP_REASM_LIODN_MASK) + << (uint64_t)FM_PCD_MANIP_REASM_LIODN_SHIFT); + tmpReg64 |= ((uint64_t)(p_Manip->reassmParams.dataLiodnOffset + & FM_PCD_MANIP_REASM_ELIODN_MASK) + << (uint64_t)FM_PCD_MANIP_REASM_ELIODN_SHIFT); tmpReg64 |= XX_VirtToPhys(UINT_TO_PTR(*p_AutoLearnSetLockTblAddr)); - WRITE_UINT32((*p_IpReassTbl)->liodnSlAndAutoLearnSetLockTblPtrHi, (uint32_t)(tmpReg64 >> 32)); - WRITE_UINT32((*p_IpReassTbl)->autoLearnSetLockTblPtrLow, (uint32_t)tmpReg64); + WRITE_UINT32( (*p_ReassTbl)->liodnSlAndAutoLearnSetLockTblPtrHi, + (uint32_t)(tmpReg64 >> 32)); + WRITE_UINT32((*p_ReassTbl)->autoLearnSetLockTblPtrLow, (uint32_t)tmpReg64); /* Sets user's requested minimum fragment size (in Bytes) for First/Middle fragment */ - WRITE_UINT16((*p_IpReassTbl)->minFragSize, minFragSize); + WRITE_UINT16((*p_ReassTbl)->minFragSize, minFragSize); + + WRITE_UINT16((*p_ReassTbl)->maxReassemblySize, maxReassemSize); return E_OK; } -static t_Error UpdateInitIpReasm(t_Handle h_FmPcd, - t_Handle h_PcdParams, - t_Handle h_FmPort, - t_FmPcdManip *p_Manip, - t_Handle h_Ad, - bool validate) +static t_Error UpdateInitReasm(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; - uint32_t tmpReg32; - t_Error err; - t_FmPortPcdParams *p_PcdParams = (t_FmPortPcdParams *)h_PcdParams; + t_FmPortGetSetCcParams fmPortGetSetCcParams; + uint32_t tmpReg32; + t_Error err; + t_FmPortPcdParams *p_PcdParams = (t_FmPortPcdParams *)h_PcdParams; #if (DPAA_VERSION >= 11) - t_FmPcdCtrlParamsPage *p_ParamsPage; + t_FmPcdCtrlParamsPage *p_ParamsPage; #endif /* (DPAA_VERSION >= 11) */ SANITY_CHECK_RETURN_ERROR(p_Manip, E_INVALID_HANDLE); SANITY_CHECK_RETURN_ERROR(!p_Manip->frag, E_INVALID_HANDLE); - SANITY_CHECK_RETURN_ERROR((p_Manip->opcode == HMAN_OC_IP_REASSEMBLY), E_INVALID_STATE); + SANITY_CHECK_RETURN_ERROR( + (p_Manip->opcode == HMAN_OC_IP_REASSEMBLY) || (p_Manip->opcode == HMAN_OC_CAPWAP_REASSEMBLY), + E_INVALID_STATE); SANITY_CHECK_RETURN_ERROR(h_FmPcd, E_INVALID_HANDLE); - SANITY_CHECK_RETURN_ERROR(!p_Manip->updateParams || h_PcdParams, E_INVALID_HANDLE); + SANITY_CHECK_RETURN_ERROR(!p_Manip->updateParams || h_PcdParams, + E_INVALID_HANDLE); UNUSED(h_Ad); @@ -1627,128 +2172,184 @@ static t_Error UpdateInitIpReasm(t_Handle h_FmPcd, return E_OK; if (p_Manip->h_FmPcd != h_FmPcd) - RETURN_ERROR(MAJOR, E_INVALID_STATE, ("handler of PCD previously was initiated by different value")); + RETURN_ERROR( + MAJOR, E_INVALID_STATE, + ("handler of PCD previously was initiated by different value")); if (p_Manip->updateParams) { - if ((!(p_Manip->updateParams & (NUM_OF_TASKS | NUM_OF_EXTRA_TASKS | DISCARD_MASK))) || - ((p_Manip->shadowUpdateParams & (NUM_OF_TASKS | NUM_OF_EXTRA_TASKS | DISCARD_MASK)))) - RETURN_ERROR(MAJOR, E_INVALID_STATE, ("in this stage parameters from Port has not be updated")); + if ((!(p_Manip->updateParams + & (NUM_OF_TASKS | NUM_OF_EXTRA_TASKS | DISCARD_MASK))) + || ((p_Manip->shadowUpdateParams + & (NUM_OF_TASKS | NUM_OF_EXTRA_TASKS | DISCARD_MASK)))) + RETURN_ERROR( + MAJOR, E_INVALID_STATE, + ("in this stage parameters from Port has not be updated")); fmPortGetSetCcParams.setCcParams.type = 0; + if (p_Manip->opcode == HMAN_OC_CAPWAP_REASSEMBLY) + { + fmPortGetSetCcParams.setCcParams.type |= UPDATE_OFP_DPTE; + fmPortGetSetCcParams.setCcParams.ofpDpde = 0xF; + } fmPortGetSetCcParams.getCcParams.type = p_Manip->updateParams | FM_REV; - if ((err = FmPortGetSetCcParams(h_FmPort, &fmPortGetSetCcParams)) != E_OK) + 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 | 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 (fmPortGetSetCcParams.getCcParams.type + & (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)) + if (p_Manip->updateParams + & (NUM_OF_TASKS | NUM_OF_EXTRA_TASKS | DISCARD_MASK)) { - t_FmPcd *p_FmPcd = (t_FmPcd *)h_FmPcd; - uint8_t *p_Ptr, i, totalNumOfTnums; + t_FmPcd *p_FmPcd = (t_FmPcd *)h_FmPcd; + uint8_t *p_Ptr, i, totalNumOfTnums; - totalNumOfTnums = (uint8_t)(fmPortGetSetCcParams.getCcParams.numOfTasks + - fmPortGetSetCcParams.getCcParams.numOfExtraTasks); + totalNumOfTnums = + (uint8_t)(fmPortGetSetCcParams.getCcParams.numOfTasks + + fmPortGetSetCcParams.getCcParams.numOfExtraTasks); - p_Manip->ipReassmParams.internalBufferPoolAddr = + p_Manip->reassmParams.internalBufferPoolAddr = PTR_TO_UINT(FM_MURAM_AllocMem(p_FmPcd->h_FmMuram, - (uint32_t)(totalNumOfTnums * BMI_FIFO_UNITS), - BMI_FIFO_UNITS)); - if (!p_Manip->ipReassmParams.internalBufferPoolAddr) - RETURN_ERROR(MAJOR, E_NO_MEMORY, ("MURAM alloc for Reassembly internal buffers pool")); - IOMemSet32(UINT_TO_PTR(p_Manip->ipReassmParams.internalBufferPoolAddr), - 0, - (uint32_t)(totalNumOfTnums * BMI_FIFO_UNITS)); - - p_Manip->ipReassmParams.internalBufferPoolManagementIndexAddr = + (uint32_t)(totalNumOfTnums * BMI_FIFO_UNITS), + BMI_FIFO_UNITS)); + if (!p_Manip->reassmParams.internalBufferPoolAddr) + RETURN_ERROR( + MAJOR, E_NO_MEMORY, + ("MURAM alloc for Reassembly internal buffers pool")); + IOMemSet32( + UINT_TO_PTR(p_Manip->reassmParams.internalBufferPoolAddr), + 0, (uint32_t)(totalNumOfTnums * BMI_FIFO_UNITS)); + + p_Manip->reassmParams.internalBufferPoolManagementIndexAddr = PTR_TO_UINT(FM_MURAM_AllocMem(p_FmPcd->h_FmMuram, - (uint32_t)(5 + totalNumOfTnums), - 4)); - if (!p_Manip->ipReassmParams.internalBufferPoolManagementIndexAddr) - RETURN_ERROR(MAJOR, E_NO_MEMORY, ("MURAM alloc for Reassembly internal buffers management")); - - p_Ptr = (uint8_t*)UINT_TO_PTR(p_Manip->ipReassmParams.internalBufferPoolManagementIndexAddr); - WRITE_UINT32(*(uint32_t*)p_Ptr, (uint32_t)(XX_VirtToPhys(UINT_TO_PTR(p_Manip->ipReassmParams.internalBufferPoolAddr)) - p_FmPcd->physicalMuramBase)); - for (i=0, p_Ptr += 4; i < totalNumOfTnums; i++, p_Ptr++) + (uint32_t)(5 + totalNumOfTnums), + 4)); + if (!p_Manip->reassmParams.internalBufferPoolManagementIndexAddr) + RETURN_ERROR( + MAJOR, + E_NO_MEMORY, + ("MURAM alloc for Reassembly internal buffers management")); + + p_Ptr = + (uint8_t*)UINT_TO_PTR(p_Manip->reassmParams.internalBufferPoolManagementIndexAddr); + WRITE_UINT32( + *(uint32_t*)p_Ptr, + (uint32_t)(XX_VirtToPhys(UINT_TO_PTR(p_Manip->reassmParams.internalBufferPoolAddr)) - p_FmPcd->physicalMuramBase)); + for (i = 0, p_Ptr += 4; i < totalNumOfTnums; i++, p_Ptr++) WRITE_UINT8(*p_Ptr, i); WRITE_UINT8(*p_Ptr, 0xFF); - tmpReg32 = (4 << FM_PCD_MANIP_IP_REASM_COMMON_INT_BUFFER_IDX_SHIFT) | - ((uint32_t)(XX_VirtToPhys(UINT_TO_PTR(p_Manip->ipReassmParams.internalBufferPoolManagementIndexAddr)) - p_FmPcd->physicalMuramBase)); - WRITE_UINT32(p_Manip->ipReassmParams.p_IpReassCommonTbl->internalBufferManagement, tmpReg32); - - p_Manip->updateParams &= ~(NUM_OF_TASKS | NUM_OF_EXTRA_TASKS | DISCARD_MASK); - p_Manip->shadowUpdateParams |= (NUM_OF_TASKS | NUM_OF_EXTRA_TASKS | DISCARD_MASK); + tmpReg32 = + (4 << FM_PCD_MANIP_REASM_COMMON_INT_BUFFER_IDX_SHIFT) + | ((uint32_t)(XX_VirtToPhys( + UINT_TO_PTR(p_Manip->reassmParams.internalBufferPoolManagementIndexAddr)) + - p_FmPcd->physicalMuramBase)); + WRITE_UINT32( + p_Manip->reassmParams.p_ReassCommonTbl->internalBufferManagement, + tmpReg32); + + p_Manip->updateParams &= ~(NUM_OF_TASKS | NUM_OF_EXTRA_TASKS + | DISCARD_MASK); + p_Manip->shadowUpdateParams |= (NUM_OF_TASKS | NUM_OF_EXTRA_TASKS + | DISCARD_MASK); } } - if (p_Manip->ipReassmParams.h_Ipv4Scheme) + if (p_Manip->opcode == HMAN_OC_CAPWAP_REASSEMBLY) { - p_PcdParams->p_KgParams->h_Schemes[p_PcdParams->p_KgParams->numOfSchemes] = p_Manip->ipReassmParams.h_Ipv4Scheme; - p_PcdParams->p_KgParams->numOfSchemes++; - } - if (p_Manip->ipReassmParams.h_Ipv6Scheme) - { - p_PcdParams->p_KgParams->h_Schemes[p_PcdParams->p_KgParams->numOfSchemes] = p_Manip->ipReassmParams.h_Ipv6Scheme; - p_PcdParams->p_KgParams->numOfSchemes++; - } + if (p_Manip->reassmParams.capwap.h_Scheme) + { + p_PcdParams->p_KgParams->h_Schemes[p_PcdParams->p_KgParams->numOfSchemes] = + p_Manip->reassmParams.capwap.h_Scheme; + p_PcdParams->p_KgParams->numOfSchemes++; + } -#if (DPAA_VERSION >= 11) - if (fmPortGetSetCcParams.getCcParams.revInfo.majorRev >= 6) + } + else { - if ((err = FmPortSetGprFunc(h_FmPort, e_FM_PORT_GPR_MURAM_PAGE, (void**)&p_ParamsPage)) != E_OK) - RETURN_ERROR(MAJOR, err, NO_MSG); - - tmpReg32 = NIA_ENG_KG; - if (p_Manip->ipReassmParams.h_Ipv4Scheme) + if (p_Manip->reassmParams.ip.h_Ipv4Scheme) { - tmpReg32 |= NIA_KG_DIRECT; - tmpReg32 |= NIA_KG_CC_EN; - tmpReg32 |= FmPcdKgGetSchemeId(p_Manip->ipReassmParams.h_Ipv4Scheme); - WRITE_UINT32(p_ParamsPage->iprIpv4Nia, tmpReg32); + p_PcdParams->p_KgParams->h_Schemes[p_PcdParams->p_KgParams->numOfSchemes] = + p_Manip->reassmParams.ip.h_Ipv4Scheme; + p_PcdParams->p_KgParams->numOfSchemes++; } - if (p_Manip->ipReassmParams.h_Ipv6Scheme) + if (p_Manip->reassmParams.ip.h_Ipv6Scheme) { - tmpReg32 &= ~NIA_AC_MASK; - tmpReg32 |= NIA_KG_DIRECT; - tmpReg32 |= NIA_KG_CC_EN; - tmpReg32 |= FmPcdKgGetSchemeId(p_Manip->ipReassmParams.h_Ipv6Scheme); - WRITE_UINT32(p_ParamsPage->iprIpv6Nia, tmpReg32); + p_PcdParams->p_KgParams->h_Schemes[p_PcdParams->p_KgParams->numOfSchemes] = + p_Manip->reassmParams.ip.h_Ipv6Scheme; + p_PcdParams->p_KgParams->numOfSchemes++; + } +#if (DPAA_VERSION >= 11) + if (fmPortGetSetCcParams.getCcParams.revInfo.majorRev >= 6) + { + if ((err = FmPortSetGprFunc(h_FmPort, e_FM_PORT_GPR_MURAM_PAGE, + (void**)&p_ParamsPage)) != E_OK) + RETURN_ERROR(MAJOR, err, NO_MSG); + + tmpReg32 = NIA_ENG_KG; + if (p_Manip->reassmParams.ip.h_Ipv4Scheme) + { + tmpReg32 |= NIA_KG_DIRECT; + tmpReg32 |= NIA_KG_CC_EN; + tmpReg32 |= FmPcdKgGetSchemeId( + p_Manip->reassmParams.ip.h_Ipv4Scheme); + WRITE_UINT32(p_ParamsPage->iprIpv4Nia, tmpReg32); + } + if (p_Manip->reassmParams.ip.h_Ipv6Scheme) + { + tmpReg32 &= ~NIA_AC_MASK; + tmpReg32 |= NIA_KG_DIRECT; + tmpReg32 |= NIA_KG_CC_EN; + tmpReg32 |= FmPcdKgGetSchemeId( + p_Manip->reassmParams.ip.h_Ipv6Scheme); + WRITE_UINT32(p_ParamsPage->iprIpv6Nia, tmpReg32); + } } - } #else - if (fmPortGetSetCcParams.getCcParams.revInfo.majorRev < 6) - { - WRITE_UINT32(p_Manip->ipReassmParams.p_IpReassCommonTbl->discardMask, - fmPortGetSetCcParams.getCcParams.discardMask); - } + if (fmPortGetSetCcParams.getCcParams.revInfo.majorRev < 6) + { + WRITE_UINT32(p_Manip->reassmParams.p_ReassCommonTbl->discardMask, + fmPortGetSetCcParams.getCcParams.discardMask); + } #endif /* (DPAA_VERSION >= 11) */ - + } return E_OK; } #if (DPAA_VERSION == 10) static t_Error FmPcdFragHcScratchPoolFill(t_Handle h_FmPcd, uint8_t scratchBpid) { - t_FmPcd *p_FmPcd = (t_FmPcd*)h_FmPcd; - t_FmPcdCcFragScratchPoolCmdParams fmPcdCcFragScratchPoolCmdParams; - t_Error err; + t_FmPcd *p_FmPcd = (t_FmPcd*)h_FmPcd; + t_FmPcdCcFragScratchPoolCmdParams fmPcdCcFragScratchPoolCmdParams; + t_Error err; SANITY_CHECK_RETURN_ERROR(p_FmPcd, E_INVALID_HANDLE); @@ -1757,21 +2358,21 @@ static t_Error FmPcdFragHcScratchPoolFill(t_Handle h_FmPcd, uint8_t scratchBpid) fmPcdCcFragScratchPoolCmdParams.numOfBuffers = NUM_OF_SCRATCH_POOL_BUFFERS; fmPcdCcFragScratchPoolCmdParams.bufferPoolId = scratchBpid; if ((err = FmHcPcdCcIpFragScratchPollCmd(p_FmPcd->h_Hc, TRUE, &fmPcdCcFragScratchPoolCmdParams)) != E_OK) - RETURN_ERROR(MAJOR, err, NO_MSG); + RETURN_ERROR(MAJOR, err, NO_MSG); if (fmPcdCcFragScratchPoolCmdParams.numOfBuffers != 0) - RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Fill scratch pool failed," - "Failed to release %d buffers to the BM (missing FBPRs)", - fmPcdCcFragScratchPoolCmdParams.numOfBuffers)); + RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Fill scratch pool failed," + "Failed to release %d buffers to the BM (missing FBPRs)", + fmPcdCcFragScratchPoolCmdParams.numOfBuffers)); return E_OK; } static t_Error FmPcdFragHcScratchPoolEmpty(t_Handle h_FmPcd, uint8_t scratchBpid) { - t_FmPcd *p_FmPcd = (t_FmPcd*)h_FmPcd; - t_FmPcdCcFragScratchPoolCmdParams fmPcdCcFragScratchPoolCmdParams; - t_Error err; + t_FmPcd *p_FmPcd = (t_FmPcd*)h_FmPcd; + t_FmPcdCcFragScratchPoolCmdParams fmPcdCcFragScratchPoolCmdParams; + t_Error err; SANITY_CHECK_RETURN_ERROR(p_FmPcd, E_INVALID_HANDLE); @@ -1779,7 +2380,7 @@ static t_Error FmPcdFragHcScratchPoolEmpty(t_Handle h_FmPcd, uint8_t scratchBpid fmPcdCcFragScratchPoolCmdParams.bufferPoolId = scratchBpid; if ((err = FmHcPcdCcIpFragScratchPollCmd(p_FmPcd->h_Hc, FALSE, &fmPcdCcFragScratchPoolCmdParams)) != E_OK) - RETURN_ERROR(MAJOR, err, NO_MSG); + RETURN_ERROR(MAJOR, err, NO_MSG); return E_OK; } @@ -1800,134 +2401,163 @@ static void ReleaseManipHandler(t_FmPcdManip *p_Manip, t_FmPcd *p_FmPcd) FM_MURAM_FreeMem(p_FmPcd->h_FmMuram, p_Manip->p_Template); p_Manip->p_Template = NULL; } +#if (defined(FM_CAPWAP_SUPPORT) && (DPAA_VERSION == 10)) if (p_Manip->h_Frag) { - if (p_Manip->fragParams.p_AutoLearnHashTbl) - FM_MURAM_FreeMem(p_FmPcd->h_FmMuram, p_Manip->fragParams.p_AutoLearnHashTbl); - if (p_Manip->fragParams.p_ReassmFrmDescrPoolTbl) - FM_MURAM_FreeMem(p_FmPcd->h_FmMuram, p_Manip->fragParams.p_ReassmFrmDescrPoolTbl); - if (p_Manip->fragParams.p_ReassmFrmDescrIndxPoolTbl) - FM_MURAM_FreeMem(p_FmPcd->h_FmMuram, p_Manip->fragParams.p_ReassmFrmDescrIndxPoolTbl); - if (p_Manip->fragParams.p_TimeOutTbl) - FM_MURAM_FreeMem(p_FmPcd->h_FmMuram, p_Manip->fragParams.p_TimeOutTbl); + if (p_Manip->capwapFragParams.p_AutoLearnHashTbl) + FM_MURAM_FreeMem(p_FmPcd->h_FmMuram, + p_Manip->capwapFragParams.p_AutoLearnHashTbl); + if (p_Manip->capwapFragParams.p_ReassmFrmDescrPoolTbl) + FM_MURAM_FreeMem(p_FmPcd->h_FmMuram, + p_Manip->capwapFragParams.p_ReassmFrmDescrPoolTbl); + if (p_Manip->capwapFragParams.p_ReassmFrmDescrIndxPoolTbl) + FM_MURAM_FreeMem(p_FmPcd->h_FmMuram, + p_Manip->capwapFragParams.p_ReassmFrmDescrIndxPoolTbl); + if (p_Manip->capwapFragParams.p_TimeOutTbl) + FM_MURAM_FreeMem(p_FmPcd->h_FmMuram, + p_Manip->capwapFragParams.p_TimeOutTbl); FM_MURAM_FreeMem(p_FmPcd->h_FmMuram, p_Manip->h_Frag); } +#endif /* (defined(FM_CAPWAP_SUPPORT) && (DPAA_VERSION == 10)) */ if (p_Manip->frag) { - if (p_Manip->ipFragParams.p_Frag) + if (p_Manip->fragParams.p_Frag) { #if (DPAA_VERSION == 10) - FmPcdFragHcScratchPoolEmpty((t_Handle)p_FmPcd, p_Manip->ipFragParams.scratchBpid); + FmPcdFragHcScratchPoolEmpty((t_Handle)p_FmPcd, p_Manip->fragParams.scratchBpid); #endif /* (DPAA_VERSION == 10) */ - FM_MURAM_FreeMem(p_FmPcd->h_FmMuram, p_Manip->ipFragParams.p_Frag); + FM_MURAM_FreeMem(p_FmPcd->h_FmMuram, p_Manip->fragParams.p_Frag); } } - else if (p_Manip->reassm) - { - FmPcdUnregisterReassmPort(p_FmPcd, p_Manip->ipReassmParams.p_IpReassCommonTbl); - - if (p_Manip->ipReassmParams.timeOutTblAddr) - FM_MURAM_FreeMem(p_FmPcd->h_FmMuram, UINT_TO_PTR(p_Manip->ipReassmParams.timeOutTblAddr)); - if (p_Manip->ipReassmParams.reassFrmDescrPoolTblAddr) - XX_FreeSmart(UINT_TO_PTR(p_Manip->ipReassmParams.reassFrmDescrPoolTblAddr)); - - if (p_Manip->ipReassmParams.ipv4AutoLearnHashTblAddr) - XX_FreeSmart(UINT_TO_PTR(p_Manip->ipReassmParams.ipv4AutoLearnHashTblAddr)); - if (p_Manip->ipReassmParams.ipv6AutoLearnHashTblAddr) - XX_FreeSmart(UINT_TO_PTR(p_Manip->ipReassmParams.ipv6AutoLearnHashTblAddr)); - if (p_Manip->ipReassmParams.ipv4AutoLearnSetLockTblAddr) - XX_FreeSmart(UINT_TO_PTR(p_Manip->ipReassmParams.ipv4AutoLearnSetLockTblAddr)); - if (p_Manip->ipReassmParams.ipv6AutoLearnSetLockTblAddr) - XX_FreeSmart(UINT_TO_PTR(p_Manip->ipReassmParams.ipv6AutoLearnSetLockTblAddr)); - if (p_Manip->ipReassmParams.p_Ipv4ReassTbl) - FM_MURAM_FreeMem(p_FmPcd->h_FmMuram, p_Manip->ipReassmParams.p_Ipv4ReassTbl); - if (p_Manip->ipReassmParams.p_Ipv6ReassTbl) - FM_MURAM_FreeMem(p_FmPcd->h_FmMuram, p_Manip->ipReassmParams.p_Ipv6ReassTbl); - if (p_Manip->ipReassmParams.p_IpReassCommonTbl) - FM_MURAM_FreeMem(p_FmPcd->h_FmMuram, p_Manip->ipReassmParams.p_IpReassCommonTbl); - if (p_Manip->ipReassmParams.reassFrmDescrIndxPoolTblAddr) - FM_MURAM_FreeMem(p_FmPcd->h_FmMuram, UINT_TO_PTR(p_Manip->ipReassmParams.reassFrmDescrIndxPoolTblAddr)); - if (p_Manip->ipReassmParams.internalBufferPoolManagementIndexAddr) - FM_MURAM_FreeMem(p_FmPcd->h_FmMuram, UINT_TO_PTR(p_Manip->ipReassmParams.internalBufferPoolManagementIndexAddr)); - if (p_Manip->ipReassmParams.internalBufferPoolAddr) - FM_MURAM_FreeMem(p_FmPcd->h_FmMuram, UINT_TO_PTR(p_Manip->ipReassmParams.internalBufferPoolAddr)); - - if (p_Manip->ipReassmParams.h_Ipv6Ad) - XX_FreeSmart(p_Manip->ipReassmParams.h_Ipv6Ad); - if (p_Manip->ipReassmParams.h_Ipv4Ad) - XX_FreeSmart(p_Manip->ipReassmParams.h_Ipv4Ad); - } + else + if (p_Manip->reassm) + { + FmPcdUnregisterReassmPort(p_FmPcd, + p_Manip->reassmParams.p_ReassCommonTbl); + + if (p_Manip->reassmParams.timeOutTblAddr) + FM_MURAM_FreeMem( + p_FmPcd->h_FmMuram, + UINT_TO_PTR(p_Manip->reassmParams.timeOutTblAddr)); + if (p_Manip->reassmParams.reassFrmDescrPoolTblAddr) + XX_FreeSmart( + UINT_TO_PTR(p_Manip->reassmParams.reassFrmDescrPoolTblAddr)); + if (p_Manip->reassmParams.p_ReassCommonTbl) + FM_MURAM_FreeMem(p_FmPcd->h_FmMuram, + p_Manip->reassmParams.p_ReassCommonTbl); + if (p_Manip->reassmParams.reassFrmDescrIndxPoolTblAddr) + FM_MURAM_FreeMem( + p_FmPcd->h_FmMuram, + UINT_TO_PTR(p_Manip->reassmParams.reassFrmDescrIndxPoolTblAddr)); + if (p_Manip->reassmParams.internalBufferPoolManagementIndexAddr) + FM_MURAM_FreeMem( + p_FmPcd->h_FmMuram, + UINT_TO_PTR(p_Manip->reassmParams.internalBufferPoolManagementIndexAddr)); + if (p_Manip->reassmParams.internalBufferPoolAddr) + FM_MURAM_FreeMem( + p_FmPcd->h_FmMuram, + UINT_TO_PTR(p_Manip->reassmParams.internalBufferPoolAddr)); + if (p_Manip->reassmParams.hdr == HEADER_TYPE_CAPWAP) + { + + } + else + { + if (p_Manip->reassmParams.ip.ipv4AutoLearnHashTblAddr) + XX_FreeSmart( + UINT_TO_PTR(p_Manip->reassmParams.ip.ipv4AutoLearnHashTblAddr)); + if (p_Manip->reassmParams.ip.ipv6AutoLearnHashTblAddr) + XX_FreeSmart( + UINT_TO_PTR(p_Manip->reassmParams.ip.ipv6AutoLearnHashTblAddr)); + if (p_Manip->reassmParams.ip.ipv4AutoLearnSetLockTblAddr) + XX_FreeSmart( + UINT_TO_PTR(p_Manip->reassmParams.ip.ipv4AutoLearnSetLockTblAddr)); + if (p_Manip->reassmParams.ip.ipv6AutoLearnSetLockTblAddr) + XX_FreeSmart( + UINT_TO_PTR(p_Manip->reassmParams.ip.ipv6AutoLearnSetLockTblAddr)); + if (p_Manip->reassmParams.ip.p_Ipv4ReassTbl) + FM_MURAM_FreeMem(p_FmPcd->h_FmMuram, + p_Manip->reassmParams.ip.p_Ipv4ReassTbl); + if (p_Manip->reassmParams.ip.p_Ipv6ReassTbl) + FM_MURAM_FreeMem(p_FmPcd->h_FmMuram, + p_Manip->reassmParams.ip.p_Ipv6ReassTbl); + if (p_Manip->reassmParams.ip.h_Ipv6Ad) + XX_FreeSmart(p_Manip->reassmParams.ip.h_Ipv6Ad); + if (p_Manip->reassmParams.ip.h_Ipv4Ad) + XX_FreeSmart(p_Manip->reassmParams.ip.h_Ipv4Ad); + } + } if (p_Manip->p_StatsTbl) FM_MURAM_FreeMem(p_FmPcd->h_FmMuram, p_Manip->p_StatsTbl); } -#ifdef FM_CAPWAP_SUPPORT -static t_Error CheckManipParamsAndSetType(t_FmPcdManip *p_Manip, t_FmPcdManipParams *p_ManipParams) +#if (defined(FM_CAPWAP_SUPPORT) && (DPAA_VERSION == 10)) +static t_Error CheckManipParamsAndSetType(t_FmPcdManip *p_Manip, t_FmPcdManipParams *p_ManipParams) { if (p_ManipParams->u.hdr.rmv) { switch (p_ManipParams->u.hdr.rmvParams.type) { case (e_FM_PCD_MANIP_RMV_BY_HDR): - switch (p_ManipParams->u.hdr.rmvParams.u.byHdr.type) + switch (p_ManipParams->u.hdr.rmvParams.u.byHdr.type) + { + case (e_FM_PCD_MANIP_RMV_BY_HDR_FROM_START) : + if (p_ManipParams->u.hdr.rmvParams.u.byHdr.u.fromStartByHdr.include) { - case (e_FM_PCD_MANIP_RMV_BY_HDR_FROM_START) : - if (p_ManipParams->u.hdr.rmvParams.u.byHdr.u.fromStartByHdr.include) - { - switch (p_ManipParams->u.hdr.rmvParams.u.byHdr.u.fromStartByHdr.hdrInfo.hdr) - { - case (HEADER_TYPE_CAPWAP_DTLS) : - p_Manip->opcode = HMAN_OC_CAPWAP_RMV_DTLS_IF_EXIST; - p_Manip->muramAllocate = TRUE; - if (p_ManipParams->u.hdr.insrt) - RETURN_ERROR(MAJOR, E_INVALID_STATE, ("for CAPWAP_DTLS_HDR remove can not be insrt manipualtion after")); - if (p_ManipParams->fragOrReasm) - { - if (!p_ManipParams->fragOrReasmParams.frag) - { - switch (p_ManipParams->fragOrReasmParams.hdr) - { - case (HEADER_TYPE_CAPWAP): - p_Manip->opcode = HMAN_OC_CAPWAP_REASSEMBLY; - break; - default: - RETURN_ERROR(MAJOR, E_INVALID_STATE, ("unsupported header for Reassembly")); - } - } - else - RETURN_ERROR(MAJOR, E_INVALID_STATE, ("for this type of manipulation frag can not be TRUE")); - } - break; - default: - RETURN_ERROR(MAJOR, E_INVALID_STATE, ("non valid net header of remove location")); - } - } - else + switch (p_ManipParams->u.hdr.rmvParams.u.byHdr.u.fromStartByHdr.hdrInfo.hdr) + { + case (HEADER_TYPE_CAPWAP_DTLS) : + p_Manip->opcode = HMAN_OC_CAPWAP_RMV_DTLS_IF_EXIST; + p_Manip->muramAllocate = TRUE; + if (p_ManipParams->u.hdr.insrt) + RETURN_ERROR(MAJOR, E_INVALID_STATE, ("for CAPWAP_DTLS_HDR remove can not be insrt manipualtion after")); + if (p_ManipParams->fragOrReasm) { - switch (p_ManipParams->u.hdr.rmvParams.u.byHdr.u.fromStartByHdr.hdrInfo.hdr) + if (!p_ManipParams->fragOrReasmParams.frag) { - case (HEADER_TYPE_CAPWAP_DTLS) : - case (HEADER_TYPE_CAPWAP) : - if (p_ManipParams->fragOrReasm || p_ManipParams->u.hdr.insrt) - RETURN_ERROR(MAJOR, E_INVALID_STATE, ("for the type of remove e_FM_PCD_MANIP_RMV_FROM_START_OF_FRAME_TILL_CAPWAP can not be insert or fragOrReasm TRUE")); - p_Manip->opcode = HMAN_OC_RMV_N_OR_INSRT_INT_FRM_HDR; - p_Manip->muramAllocate = TRUE; - p_ManipParams->u.hdr.insrt = TRUE; //internal frame header + switch (p_ManipParams->fragOrReasmParams.hdr) + { + case (HEADER_TYPE_CAPWAP): + p_Manip->opcode = HMAN_OC_CAPWAP_REASSEMBLY; break; - default : - RETURN_ERROR(MAJOR, E_INVALID_STATE, ("invalid type of remove manipulation")); + default: + RETURN_ERROR(MAJOR, E_INVALID_STATE, ("unsupported header for Reassembly")); + } } + else + RETURN_ERROR(MAJOR, E_INVALID_STATE, ("for this type of manipulation frag can not be TRUE")); } break; - default : - RETURN_ERROR(MAJOR, E_INVALID_STATE, ("invalid type of remove manipulation")); - } - break; - default: + default: + RETURN_ERROR(MAJOR, E_INVALID_STATE, ("non valid net header of remove location")); + } + } + else + { + switch (p_ManipParams->u.hdr.rmvParams.u.byHdr.u.fromStartByHdr.hdrInfo.hdr) + { + case (HEADER_TYPE_CAPWAP_DTLS) : + case (HEADER_TYPE_CAPWAP) : + if (p_ManipParams->fragOrReasm || p_ManipParams->u.hdr.insrt) + RETURN_ERROR(MAJOR, E_INVALID_STATE, ("for the type of remove e_FM_PCD_MANIP_RMV_FROM_START_OF_FRAME_TILL_CAPWAP can not be insert or fragOrReasm TRUE")); + p_Manip->opcode = HMAN_OC_RMV_N_OR_INSRT_INT_FRM_HDR; + p_Manip->muramAllocate = TRUE; + p_ManipParams->u.hdr.insrt = TRUE; //internal frame header + break; + default : + RETURN_ERROR(MAJOR, E_INVALID_STATE, ("invalid type of remove manipulation")); + } + } + break; + default : RETURN_ERROR(MAJOR, E_INVALID_STATE, ("invalid type of remove manipulation")); + } + break; + default: + RETURN_ERROR(MAJOR, E_INVALID_STATE, ("invalid type of remove manipulation")); } } else if (p_ManipParams->u.hdr.insrt) @@ -1936,28 +2566,28 @@ static t_Error CheckManipParamsAndSetType(t_FmPcdManip *p_Manip, t_FmPcdManipPa { case (e_FM_PCD_MANIP_INSRT_BY_TEMPLATE) : - p_Manip->opcode = HMAN_OC_INSRT_HDR_BY_TEMPL_N_OR_FRAG_AFTER; - p_Manip->muramAllocate = FALSE; - if (p_ManipParams->fragOrReasm) + p_Manip->opcode = HMAN_OC_INSRT_HDR_BY_TEMPL_N_OR_FRAG_AFTER; + p_Manip->muramAllocate = FALSE; + if (p_ManipParams->fragOrReasm) + { + if (p_ManipParams->fragOrReasmParams.frag) { - if (p_ManipParams->fragOrReasmParams.frag) + switch (p_ManipParams->fragOrReasmParams.hdr) { - switch (p_ManipParams->fragOrReasmParams.hdr) - { - case (HEADER_TYPE_CAPWAP): - p_Manip->opcode = HMAN_OC_CAPWAP_FRAGMENTATION; - break; - default: - RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Invalid header for fragmentation")); - } + case (HEADER_TYPE_CAPWAP): + p_Manip->opcode = HMAN_OC_CAPWAP_FRAGMENTATION; + break; + default: + RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Invalid header for fragmentation")); } - else - RETURN_ERROR(MAJOR, E_INVALID_STATE,("can not reach this point")); } - break; + else + RETURN_ERROR(MAJOR, E_INVALID_STATE,("can not reach this point")); + } + break; default: - RETURN_ERROR(MAJOR, E_INVALID_STATE, ("for only isert manipulation unsupported type")); + RETURN_ERROR(MAJOR, E_INVALID_STATE, ("for only isert manipulation unsupported type")); } } else if (p_ManipParams->fragOrReasm) @@ -1967,47 +2597,54 @@ static t_Error CheckManipParamsAndSetType(t_FmPcdManip *p_Manip, t_FmPcdManipPa switch (p_ManipParams->fragOrReasmParams.hdr) { case (HEADER_TYPE_CAPWAP): - p_Manip->opcode = HMAN_OC_CAPWAP_FRAGMENTATION; - p_Manip->muramAllocate = FALSE; - break; + p_Manip->opcode = HMAN_OC_CAPWAP_FRAGMENTATION; + p_Manip->muramAllocate = FALSE; + break; default: - RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Unsupported header for fragmentation")); - } + RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Unsupported header for fragmentation")); + } } else { switch (p_ManipParams->fragOrReasmParams.hdr) { case (HEADER_TYPE_CAPWAP): - RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Reassembly has to be with additional operation - rmv = TRUE, type of remove - e_FM_PCD_MANIP_RMV_FROM_START_OF_FRAME_INCLUDE_SPECIFIC_LOCATION,type = e_FM_PCD_MANIP_LOC_BY_HDR, hdr = HEADER_TYPE_CAPWAP_DTLS")); + RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Reassembly has to be with additional operation - rmv = TRUE, type of remove - e_FM_PCD_MANIP_RMV_FROM_START_OF_FRAME_INCLUDE_SPECIFIC_LOCATION,type = e_FM_PCD_MANIP_LOC_BY_HDR, hdr = HEADER_TYPE_CAPWAP_DTLS")); default: - RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Unsupported header for reassembly")); + RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Unsupported header for reassembly")); } } } else - RETURN_ERROR(MAJOR, E_INVALID_STATE, ("User didn't ask for any manipulation")); + RETURN_ERROR(MAJOR, E_INVALID_STATE, ("User didn't ask for any manipulation")); p_Manip->insrt = p_ManipParams->u.hdr.insrt; - p_Manip->rmv = p_ManipParams->u.hdr.rmv; + p_Manip->rmv = p_ManipParams->u.hdr.rmv; return E_OK; } -#else /* not FM_CAPWAP_SUPPORT */ -static t_Error CheckManipParamsAndSetType(t_FmPcdManip *p_Manip, t_FmPcdManipParams *p_ManipParams) +#else /* not (defined(FM_CAPWAP_SUPPORT) && (DPAA_VERSION == 10)) */ +static t_Error CheckManipParamsAndSetType(t_FmPcdManip *p_Manip, + t_FmPcdManipParams *p_ManipParams) { switch (p_ManipParams->type) { - case e_FM_PCD_MANIP_HDR : + case e_FM_PCD_MANIP_HDR: /* Check that next-manip is not already used */ if (p_ManipParams->h_NextManip) { if (!MANIP_IS_FIRST(p_ManipParams->h_NextManip)) - RETURN_ERROR(MAJOR, E_INVALID_STATE, ("h_NextManip is already a part of another chain")); - if (MANIP_GET_TYPE(p_ManipParams->h_NextManip) != e_FM_PCD_MANIP_HDR) - RETURN_ERROR(MAJOR, E_NOT_SUPPORTED, ("For a Header Manipulation node - no support of h_NextManip of type other than Header Manipulation.")); + RETURN_ERROR( + MAJOR, E_INVALID_STATE, + ("h_NextManip is already a part of another chain")); + if (MANIP_GET_TYPE(p_ManipParams->h_NextManip) + != e_FM_PCD_MANIP_HDR) + RETURN_ERROR( + MAJOR, + E_NOT_SUPPORTED, + ("For a Header Manipulation node - no support of h_NextManip of type other than Header Manipulation.")); } if (p_ManipParams->u.hdr.rmv) @@ -2017,136 +2654,240 @@ static t_Error CheckManipParamsAndSetType(t_FmPcdManip *p_Manip, t_FmPcdManipPar case (e_FM_PCD_MANIP_RMV_BY_HDR): switch (p_ManipParams->u.hdr.rmvParams.u.byHdr.type) { - case (e_FM_PCD_MANIP_RMV_BY_HDR_SPECIFIC_L2) : - p_Manip->opcode = HMAN_OC; - p_Manip->muramAllocate = TRUE; + case (e_FM_PCD_MANIP_RMV_BY_HDR_SPECIFIC_L2): break; - default : - RETURN_ERROR(MAJOR, E_INVALID_STATE, ("invalid type of remove manipulation")); +#if (DPAA_VERSION >= 11) + case (e_FM_PCD_MANIP_RMV_BY_HDR_CAPWAP): + break; + case (e_FM_PCD_MANIP_RMV_BY_HDR_FROM_START): + { + t_Error err; + uint8_t prsArrayOffset; + + err = + GetPrOffsetByHeaderOrField( + &p_ManipParams->u.hdr.rmvParams.u.byHdr.u.hdrInfo, + &prsArrayOffset); + if (err) + RETURN_ERROR(MAJOR, err, NO_MSG); + break; + } +#endif /* (DPAA_VERSION >= 11) */ + default: + RETURN_ERROR( + MAJOR, + E_INVALID_STATE, + ("invalid type of remove manipulation")); } break; - case (e_FM_PCD_MANIP_RMV_GENERIC): - p_Manip->opcode = HMAN_OC; - p_Manip->muramAllocate = TRUE; - break; - default: - RETURN_ERROR(MAJOR, E_INVALID_STATE, ("invalid type of remove manipulation")); - } - p_Manip->rmv = TRUE; - } - else if (p_ManipParams->u.hdr.insrt) - { - switch (p_ManipParams->u.hdr.insrtParams.type) - { - case (e_FM_PCD_MANIP_INSRT_BY_HDR) : - case (e_FM_PCD_MANIP_INSRT_GENERIC): - p_Manip->opcode = HMAN_OC; - p_Manip->muramAllocate = TRUE; + case (e_FM_PCD_MANIP_RMV_GENERIC): break; default: - RETURN_ERROR(MAJOR, E_INVALID_STATE, ("for only isert manipulation unsupported type")); + RETURN_ERROR(MAJOR, E_INVALID_STATE, + ("invalid type of remove manipulation")); } - p_Manip->insrt = TRUE; + p_Manip->opcode = HMAN_OC; + p_Manip->muramAllocate = TRUE; + p_Manip->rmv = TRUE; } - else if (p_ManipParams->u.hdr.fieldUpdate) - { - /* Check parameters */ - if (p_ManipParams->u.hdr.fieldUpdateParams.type == e_FM_PCD_MANIP_HDR_FIELD_UPDATE_VLAN) + else + if (p_ManipParams->u.hdr.insrt) { - if ((p_ManipParams->u.hdr.fieldUpdateParams.u.vlan.updateType == e_FM_PCD_MANIP_HDR_FIELD_UPDATE_VLAN_VPRI) - && (p_ManipParams->u.hdr.fieldUpdateParams.u.vlan.u.vpri > 7)) - RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("vpri should get values of 0-7 ")); - if (p_ManipParams->u.hdr.fieldUpdateParams.u.vlan.updateType == e_FM_PCD_MANIP_HDR_FIELD_UPDATE_DSCP_TO_VLAN) + switch (p_ManipParams->u.hdr.insrtParams.type) { - int i; - - if (p_ManipParams->u.hdr.fieldUpdateParams.u.vlan.u.dscpToVpri.vpriDefVal > 7) - RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("vpriDefVal should get values of 0-7 ")); - for (i = 0 ; i < FM_PCD_MANIP_DSCP_TO_VLAN_TRANS ; i++) - if (p_ManipParams->u.hdr.fieldUpdateParams.u.vlan.u.dscpToVpri.dscpToVpriTable[i] & 0xf0) - RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("dscpToVpriTabl value out of range (0-15)")); + case (e_FM_PCD_MANIP_INSRT_BY_HDR): + { + switch (p_ManipParams->u.hdr.insrtParams.u.byHdr.type) + { + case (e_FM_PCD_MANIP_INSRT_BY_HDR_SPECIFIC_L2): + /* nothing to check */ + break; +#if (DPAA_VERSION >= 11) + case (e_FM_PCD_MANIP_INSRT_BY_HDR_IP): + if (p_ManipParams->u.hdr.insrtParams.u.byHdr.u.ipParams.insrt.size + % 4) + RETURN_ERROR( + MAJOR, + E_INVALID_VALUE, + ("IP inserted header must be of size which is a multiple of four bytes")); + break; + case (e_FM_PCD_MANIP_INSRT_BY_HDR_CAPWAP): + if (p_ManipParams->u.hdr.insrtParams.u.byHdr.u.insrt.size + % 4) + RETURN_ERROR( + MAJOR, + E_INVALID_VALUE, + ("CAPWAP inserted header must be of size which is a multiple of four bytes")); + break; + case (e_FM_PCD_MANIP_INSRT_BY_HDR_UDP): + case (e_FM_PCD_MANIP_INSRT_BY_HDR_UDP_LITE): + if (p_ManipParams->u.hdr.insrtParams.u.byHdr.u.insrt.size + != 8) + RETURN_ERROR( + MAJOR, + E_INVALID_VALUE, + ("Inserted header must be of size 8")); + break; +#endif /* (DPAA_VERSION >= 11) */ + default: + RETURN_ERROR( + MAJOR, + E_INVALID_STATE, + ("unsupported insert by header type")); + } + } + case (e_FM_PCD_MANIP_INSRT_GENERIC): + break; + default: + RETURN_ERROR( + MAJOR, + E_INVALID_STATE, + ("for only insert manipulation unsupported type")); } - + p_Manip->opcode = HMAN_OC; + p_Manip->muramAllocate = TRUE; + p_Manip->insrt = TRUE; } + else + if (p_ManipParams->u.hdr.fieldUpdate) + { + /* Check parameters */ + if (p_ManipParams->u.hdr.fieldUpdateParams.type + == e_FM_PCD_MANIP_HDR_FIELD_UPDATE_VLAN) + { + if ((p_ManipParams->u.hdr.fieldUpdateParams.u.vlan.updateType + == e_FM_PCD_MANIP_HDR_FIELD_UPDATE_VLAN_VPRI) + && (p_ManipParams->u.hdr.fieldUpdateParams.u.vlan.u.vpri + > 7)) + RETURN_ERROR( + MAJOR, E_INVALID_VALUE, + ("vpri should get values of 0-7 ")); + if (p_ManipParams->u.hdr.fieldUpdateParams.u.vlan.updateType + == e_FM_PCD_MANIP_HDR_FIELD_UPDATE_DSCP_TO_VLAN) + { + int i; + + if (p_ManipParams->u.hdr.fieldUpdateParams.u.vlan.u.dscpToVpri.vpriDefVal + > 7) + RETURN_ERROR( + MAJOR, + E_INVALID_VALUE, + ("vpriDefVal should get values of 0-7 ")); + for (i = 0; i < FM_PCD_MANIP_DSCP_TO_VLAN_TRANS; + i++) + if (p_ManipParams->u.hdr.fieldUpdateParams.u.vlan.u.dscpToVpri.dscpToVpriTable[i] + & 0xf0) + RETURN_ERROR( + MAJOR, + E_INVALID_VALUE, + ("dscpToVpriTabl value out of range (0-15)")); + } - p_Manip->opcode = HMAN_OC; - p_Manip->muramAllocate = TRUE; - p_Manip->fieldUpdate = TRUE; - } - else if (p_ManipParams->u.hdr.custom) - { - p_Manip->opcode = HMAN_OC; - p_Manip->muramAllocate = TRUE; - p_Manip->custom = TRUE; - } + } + + p_Manip->opcode = HMAN_OC; + p_Manip->muramAllocate = TRUE; + p_Manip->fieldUpdate = TRUE; + } + else + if (p_ManipParams->u.hdr.custom) + { + p_Manip->opcode = HMAN_OC; + p_Manip->muramAllocate = TRUE; + p_Manip->custom = TRUE; + } break; - case e_FM_PCD_MANIP_REASSEM : + case e_FM_PCD_MANIP_REASSEM: if (p_ManipParams->h_NextManip) - RETURN_ERROR(MAJOR, E_NOT_SUPPORTED, ("next manip with reassembly")); + RETURN_ERROR(MAJOR, E_NOT_SUPPORTED, + ("next manip with reassembly")); switch (p_ManipParams->u.reassem.hdr) { case (HEADER_TYPE_IPv4): - p_Manip->ipReassmParams.hdr = HEADER_TYPE_IPv4; + p_Manip->reassmParams.hdr = HEADER_TYPE_IPv4; + p_Manip->opcode = HMAN_OC_IP_REASSEMBLY; break; case (HEADER_TYPE_IPv6): - p_Manip->ipReassmParams.hdr = HEADER_TYPE_IPv6; + p_Manip->reassmParams.hdr = HEADER_TYPE_IPv6; + p_Manip->opcode = HMAN_OC_IP_REASSEMBLY; + break; +#if (DPAA_VERSION >= 11) + case (HEADER_TYPE_CAPWAP): + p_Manip->reassmParams.hdr = HEADER_TYPE_CAPWAP; + p_Manip->opcode = HMAN_OC_CAPWAP_REASSEMBLY; break; +#endif /* (DPAA_VERSION >= 11) */ default: - RETURN_ERROR(MAJOR, E_NOT_SUPPORTED, ("header for reassembly")); - } - p_Manip->opcode = HMAN_OC_IP_REASSEMBLY; + RETURN_ERROR(MAJOR, E_NOT_SUPPORTED, + ("header for reassembly")); + } break; - case e_FM_PCD_MANIP_FRAG : + case e_FM_PCD_MANIP_FRAG: if (p_ManipParams->h_NextManip) - RETURN_ERROR(MAJOR, E_NOT_SUPPORTED, ("next manip with fragmentation")); + RETURN_ERROR(MAJOR, E_NOT_SUPPORTED, + ("next manip with fragmentation")); switch (p_ManipParams->u.frag.hdr) { case (HEADER_TYPE_IPv4): case (HEADER_TYPE_IPv6): + p_Manip->opcode = HMAN_OC_IP_FRAGMENTATION; + break; +#if (DPAA_VERSION >= 11) + case (HEADER_TYPE_CAPWAP): + p_Manip->opcode = HMAN_OC_CAPWAP_FRAGMENTATION; break; +#endif /* (DPAA_VERSION >= 11) */ default: - RETURN_ERROR(MAJOR, E_NOT_SUPPORTED, ("header for fragmentation")); - } - p_Manip->opcode = HMAN_OC_IP_FRAGMENTATION; + RETURN_ERROR(MAJOR, E_NOT_SUPPORTED, + ("header for fragmentation")); + } p_Manip->muramAllocate = TRUE; break; - case e_FM_PCD_MANIP_SPECIAL_OFFLOAD : + case e_FM_PCD_MANIP_SPECIAL_OFFLOAD: switch (p_ManipParams->u.specialOffload.type) { case (e_FM_PCD_MANIP_SPECIAL_OFFLOAD_IPSEC): p_Manip->opcode = HMAN_OC_IPSEC_MANIP; p_Manip->muramAllocate = TRUE; break; +#if (DPAA_VERSION >= 11) + case (e_FM_PCD_MANIP_SPECIAL_OFFLOAD_CAPWAP): + p_Manip->opcode = HMAN_OC_CAPWAP_MANIP; + p_Manip->muramAllocate = TRUE; + break; +#endif /* (DPAA_VERSION >= 11) */ default: - RETURN_ERROR(MAJOR, E_NOT_SUPPORTED, ("special offload type")); + RETURN_ERROR(MAJOR, E_NOT_SUPPORTED, + ("special offload type")); } break; - default : + default: RETURN_ERROR(MAJOR, E_NOT_SUPPORTED, ("manip type")); } return E_OK; } -#endif /* not FM_CAPWAP_SUPPORT */ +#endif /* not (defined(FM_CAPWAP_SUPPORT) && (DPAA_VERSION == 10)) */ -#ifdef FM_CAPWAP_SUPPORT -static t_Error UpdateIndxStats(t_Handle h_FmPcd, - t_Handle h_FmPort, - t_FmPcdManip *p_Manip) +#if (defined(FM_CAPWAP_SUPPORT) && (DPAA_VERSION == 10)) + +static t_Error UpdateIndxStats(t_Handle h_FmPcd, + t_Handle h_FmPort, + t_FmPcdManip *p_Manip) { - t_FmPcd *p_FmPcd = (t_FmPcd *)h_FmPcd; - uint32_t tmpReg32 = 0; - t_AdOfTypeContLookup *p_Ad; - t_FmPortGetSetCcParams fmPortGetSetCcParams; - t_Error err; + t_FmPcd *p_FmPcd = (t_FmPcd *)h_FmPcd; + uint32_t tmpReg32 = 0; + t_AdOfTypeContLookup *p_Ad; + t_FmPortGetSetCcParams fmPortGetSetCcParams; + t_Error err; SANITY_CHECK_RETURN_ERROR(p_Manip,E_INVALID_HANDLE); SANITY_CHECK_RETURN_ERROR(p_Manip->h_Ad,E_INVALID_HANDLE); - p_Ad = (t_AdOfTypeContLookup *)p_Manip->h_Ad; + p_Ad = (t_AdOfTypeContLookup *)p_Manip->h_Ad; if (p_Manip->h_FmPcd != h_FmPcd) - RETURN_ERROR(MAJOR, E_INVALID_STATE, - ("handler of PCD previously was initiated by different value")); + RETURN_ERROR(MAJOR, E_INVALID_STATE, + ("handler of PCD previously was initiated by different value")); memset(&fmPortGetSetCcParams, 0, sizeof(t_FmPortGetSetCcParams)); @@ -2157,25 +2898,25 @@ static t_Error UpdateIndxStats(t_Handle h_FmPcd, fmPortGetSetCcParams.setCcParams.nia = NIA_FM_CTL_AC_CC; err = FmPortGetSetCcParams(h_FmPort, &fmPortGetSetCcParams); if (err) - RETURN_ERROR(MAJOR, err, NO_MSG); + RETURN_ERROR(MAJOR, err, NO_MSG); tmpReg32 = GET_UINT32(p_Ad->ccAdBase); p_Manip->p_StatsTbl = - (t_Handle)FM_MURAM_AllocMem(p_FmPcd->h_FmMuram, - (uint32_t)p_Manip->owner * FM_PCD_MANIP_INDEXED_STATS_ENTRY_SIZE, - 4); + (t_Handle)FM_MURAM_AllocMem(p_FmPcd->h_FmMuram, + (uint32_t)p_Manip->owner * FM_PCD_MANIP_INDEXED_STATS_ENTRY_SIZE, + 4); if (!p_Manip->p_StatsTbl) - RETURN_ERROR(MAJOR, E_NO_MEMORY, ("MURAM alloc for Manipulation indexed statistics table")); + RETURN_ERROR(MAJOR, E_NO_MEMORY, ("MURAM alloc for Manipulation indexed statistics table")); - IOMemSet32(p_Manip->p_StatsTbl, 0, (uint32_t)(p_Manip->owner * 4)); + IOMemSet32(p_Manip->p_StatsTbl, 0, (uint32_t)(p_Manip->owner * 4)); tmpReg32 |= (uint32_t)(XX_VirtToPhys(p_Manip->p_StatsTbl) - p_FmPcd->physicalMuramBase); if (p_Manip->cnia) - tmpReg32 |= FM_PCD_MANIP_INDEXED_STATS_CNIA; + tmpReg32 |= FM_PCD_MANIP_INDEXED_STATS_CNIA; - tmpReg32 |= FM_PCD_MANIP_INDEXED_STATS_DPD; + tmpReg32 |= FM_PCD_MANIP_INDEXED_STATS_DPD; WRITE_UINT32(p_Ad->ccAdBase, tmpReg32); } else @@ -2184,115 +2925,18 @@ static t_Error UpdateIndxStats(t_Handle h_FmPcd, fmPortGetSetCcParams.setCcParams.nia = NIA_FM_CTL_AC_CC; err = FmPortGetSetCcParams(h_FmPort, &fmPortGetSetCcParams); if (err) - RETURN_ERROR(MAJOR, err, NO_MSG); + RETURN_ERROR(MAJOR, err, NO_MSG); } return E_OK; } -static t_Error GetPrOffsetByHeaderOrField(t_FmManipHdrInfo *p_HdrInfo, uint8_t *parseArrayOffset) -{ - e_NetHeaderType hdr = p_HdrInfo->hdr; - e_FmPcdHdrIndex hdrIndex = p_HdrInfo->hdrIndex; - bool byField = p_HdrInfo->byField; - t_FmPcdFields field; - - if (byField) - field = p_HdrInfo->fullField; - - if (byField) - { - switch (hdr) - { - case (HEADER_TYPE_ETH): - switch (field.eth) - { - case (NET_HEADER_FIELD_ETH_TYPE): - *parseArrayOffset = CC_PC_PR_ETYPE_LAST_OFFSET; - break; - default: - RETURN_ERROR(MAJOR, E_NOT_SUPPORTED, ("Header manipulation of the type Ethernet with this field not supported")); - } - break; - case (HEADER_TYPE_VLAN): - switch (field.vlan) - { - case (NET_HEADER_FIELD_VLAN_TCI) : - if ((hdrIndex == e_FM_PCD_HDR_INDEX_NONE) || (hdrIndex == e_FM_PCD_HDR_INDEX_1)) - *parseArrayOffset = CC_PC_PR_VLAN1_OFFSET; - else if (hdrIndex == e_FM_PCD_HDR_INDEX_LAST) - *parseArrayOffset = CC_PC_PR_VLAN2_OFFSET; - break; - default: - RETURN_ERROR(MAJOR, E_NOT_SUPPORTED, ("Header manipulation of the type VLAN with this field not supported")); - } - break; - default: - RETURN_ERROR(MAJOR, E_NOT_SUPPORTED, ("Header manipulation of this header by field not supported")); - } - } - else - { - switch (hdr){ - case (HEADER_TYPE_ETH): - *parseArrayOffset = (uint8_t)CC_PC_PR_ETH_OFFSET; - break; - case (HEADER_TYPE_USER_DEFINED_SHIM1): - *parseArrayOffset = (uint8_t)CC_PC_PR_USER_DEFINED_SHIM1_OFFSET; - break; - case (HEADER_TYPE_USER_DEFINED_SHIM2): - *parseArrayOffset = (uint8_t)CC_PC_PR_USER_DEFINED_SHIM2_OFFSET; - break; - case (HEADER_TYPE_LLC_SNAP): - *parseArrayOffset = CC_PC_PR_USER_LLC_SNAP_OFFSET; - break; - case (HEADER_TYPE_PPPoE): - *parseArrayOffset = CC_PC_PR_PPPOE_OFFSET; - break; - case (HEADER_TYPE_MPLS): - if ((hdrIndex == e_FM_PCD_HDR_INDEX_NONE) || (hdrIndex == e_FM_PCD_HDR_INDEX_1)) - *parseArrayOffset = CC_PC_PR_MPLS1_OFFSET; - else if (hdrIndex == e_FM_PCD_HDR_INDEX_LAST) - *parseArrayOffset = CC_PC_PR_MPLS_LAST_OFFSET; - break; - case (HEADER_TYPE_IPv4): - case (HEADER_TYPE_IPv6): - if ((hdrIndex == e_FM_PCD_HDR_INDEX_NONE) || (hdrIndex == e_FM_PCD_HDR_INDEX_1)) - *parseArrayOffset = CC_PC_PR_IP1_OFFSET; - else if (hdrIndex == e_FM_PCD_HDR_INDEX_2) - *parseArrayOffset = CC_PC_PR_IP_LAST_OFFSET; - break; - case (HEADER_TYPE_MINENCAP): - *parseArrayOffset = CC_PC_PR_MINENC_OFFSET; - break; - case (HEADER_TYPE_GRE): - *parseArrayOffset = CC_PC_PR_GRE_OFFSET; - break; - case (HEADER_TYPE_TCP): - case (HEADER_TYPE_UDP): - case (HEADER_TYPE_IPSEC_AH): - case (HEADER_TYPE_IPSEC_ESP): - case (HEADER_TYPE_DCCP): - case (HEADER_TYPE_SCTP): - *parseArrayOffset = CC_PC_PR_L4_OFFSET; - break; - case (HEADER_TYPE_CAPWAP): - case (HEADER_TYPE_CAPWAP_DTLS): - *parseArrayOffset = CC_PC_PR_NEXT_HEADER_OFFSET; - break; - default: - RETURN_ERROR(MAJOR, E_NOT_SUPPORTED, ("Header manipulation of this header is not supported")); - } - } - return E_OK; -} - -static t_Error RmvHdrTillSpecLocNOrInsrtIntFrmHdr(t_FmPcdManipHdrRmvParams *p_ManipParams, t_FmPcdManip *p_Manip) +static t_Error RmvHdrTillSpecLocNOrInsrtIntFrmHdr(t_FmPcdManipHdrRmvParams *p_ManipParams, t_FmPcdManip *p_Manip) { - t_AdOfTypeContLookup *p_Ad; - uint32_t tmpReg32 = 0; - uint8_t prsArrayOffset = 0; - t_Error err; + t_AdOfTypeContLookup *p_Ad; + uint32_t tmpReg32 = 0; + uint8_t prsArrayOffset = 0; + t_Error err; SANITY_CHECK_RETURN_ERROR(p_Manip,E_NULL_POINTER); SANITY_CHECK_RETURN_ERROR(p_ManipParams,E_NULL_POINTER); @@ -2303,14 +2947,14 @@ static t_Error RmvHdrTillSpecLocNOrInsrtIntFrmHdr(t_FmPcdManipHdrRmvParams *p_M { err = GetPrOffsetByHeaderOrField(&p_ManipParams->u.byHdr.u.fromStartByHdr.hdrInfo, &prsArrayOffset); if (err) - RETURN_ERROR(MAJOR, err, NO_MSG); + RETURN_ERROR(MAJOR, err, NO_MSG); tmpReg32 |= (uint32_t)prsArrayOffset << 24; tmpReg32 |= HMAN_RMV_HDR; } if (p_Manip->insrt) - tmpReg32 |= HMAN_INSRT_INT_FRM_HDR; + tmpReg32 |= HMAN_INSRT_INT_FRM_HDR; tmpReg32 |= (uint32_t)HMAN_OC_RMV_N_OR_INSRT_INT_FRM_HDR; @@ -2322,14 +2966,14 @@ static t_Error RmvHdrTillSpecLocNOrInsrtIntFrmHdr(t_FmPcdManipHdrRmvParams *p_M return E_OK; } -#endif /* FM_CAPWAP_SUPPORT */ -static t_Error MvIntFrameHeaderFromFrameToBufferPrefix(t_FmPcdManip *p_Manip, bool caamUsed) +static t_Error MvIntFrameHeaderFromFrameToBufferPrefix(t_FmPcdManip *p_Manip, + bool caamUsed) { - t_AdOfTypeContLookup *p_Ad = (t_AdOfTypeContLookup *)p_Manip->h_Ad; - uint32_t tmpReg32 = 0; + t_AdOfTypeContLookup *p_Ad = (t_AdOfTypeContLookup *)p_Manip->h_Ad; + uint32_t tmpReg32 = 0; - SANITY_CHECK_RETURN_ERROR(p_Ad,E_INVALID_HANDLE); + SANITY_CHECK_RETURN_ERROR(p_Ad, E_INVALID_HANDLE); p_Manip->updateParams |= OFFSET_OF_PR | INTERNAL_CONTEXT_OFFSET; @@ -2343,21 +2987,20 @@ static t_Error MvIntFrameHeaderFromFrameToBufferPrefix(t_FmPcdManip *p_Manip, bo *(uint32_t *)&p_Ad->pcAndOffsets = tmpReg32; if (caamUsed) - *(uint32_t *)&p_Ad->gmask = 0xf0000000; + *(uint32_t *)&p_Ad->gmask = 0xf0000000; return E_OK; } -#ifdef FM_CAPWAP_SUPPORT static t_Error CapwapRmvDtlsHdr(t_FmPcd *p_FmPcd, t_FmPcdManip *p_Manip) { - t_AdOfTypeContLookup *p_Ad; - uint32_t tmpReg32 = 0; - t_Error err = E_OK; + t_AdOfTypeContLookup *p_Ad; + uint32_t tmpReg32 = 0; + t_Error err = E_OK; SANITY_CHECK_RETURN_ERROR(p_Manip->h_Ad,E_INVALID_HANDLE); - p_Ad = (t_AdOfTypeContLookup *)p_Manip->h_Ad; + p_Ad = (t_AdOfTypeContLookup *)p_Manip->h_Ad; tmpReg32 = 0; tmpReg32 |= (uint32_t)HMAN_OC_CAPWAP_RMV_DTLS_IF_EXIST; @@ -2378,81 +3021,80 @@ static t_Error CapwapRmvDtlsHdr(t_FmPcd *p_FmPcd, t_FmPcdManip *p_Manip) return err; } -static t_Error CapwapReassembly(t_CapwapReassemblyParams *p_ManipParams, - t_FmPcdManip *p_Manip, - t_FmPcd *p_FmPcd, - uint8_t poolId) +static t_Error CapwapReassembly(t_CapwapReassemblyParams *p_ManipParams, + t_FmPcdManip *p_Manip, + t_FmPcd *p_FmPcd, + uint8_t poolId) { - t_Handle p_Table; - uint32_t tmpReg32 = 0; - int i = 0; - uint8_t log2Num; - uint8_t numOfSets; - uint32_t j = 0; + t_Handle p_Table; + uint32_t tmpReg32 = 0; + int i = 0; + uint8_t log2Num; + uint8_t numOfSets; + uint32_t j = 0; 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) || - (p_ManipParams->maxNumFramesInProcess > 512)) - RETURN_ERROR(MAJOR,E_INVALID_VALUE, ("In the case of numOfFramesPerHashEntry = e_FM_PCD_MANIP_EIGHT_WAYS_HASH maxNumFramesInProcess has to be in the range 4-512")); + (p_ManipParams->maxNumFramesInProcess > 512)) + RETURN_ERROR(MAJOR,E_INVALID_VALUE, ("In the case of numOfFramesPerHashEntry = e_FM_PCD_MANIP_EIGHT_WAYS_HASH maxNumFramesInProcess has to be in the range 4-512")); } else { if ((p_ManipParams->maxNumFramesInProcess < 8) || - (p_ManipParams->maxNumFramesInProcess > 2048)) - 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")); + (p_ManipParams->maxNumFramesInProcess > 2048)) + 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")); } 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); + 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); + IOMemSet32(p_Manip->h_Frag, 0, FM_PCD_MANIP_CAPWAP_REASM_TABLE_SIZE); p_Table = (t_CapwapReasmPram *)p_Manip->h_Frag; - p_Manip->fragParams.p_AutoLearnHashTbl = - (t_Handle)FM_MURAM_AllocMem(p_FmPcd->h_FmMuram, - (uint32_t)(p_ManipParams->maxNumFramesInProcess * 2 * FM_PCD_MANIP_CAPWAP_REASM_AUTO_LEARNING_HASH_ENTRY_SIZE), - FM_PCD_MANIP_CAPWAP_REASM_TABLE_ALIGN); - - if (!p_Manip->fragParams.p_AutoLearnHashTbl) - RETURN_ERROR(MAJOR, E_NO_MEMORY,("MURAM alloc for CAPWAP automatic learning hash table")); + p_Manip->capwapFragParams.p_AutoLearnHashTbl = + (t_Handle)FM_MURAM_AllocMem(p_FmPcd->h_FmMuram, + (uint32_t)(p_ManipParams->maxNumFramesInProcess * 2 * FM_PCD_MANIP_CAPWAP_REASM_AUTO_LEARNING_HASH_ENTRY_SIZE), + FM_PCD_MANIP_CAPWAP_REASM_TABLE_ALIGN); - IOMemSet32(p_Manip->fragParams.p_AutoLearnHashTbl, 0, (uint32_t)(p_ManipParams->maxNumFramesInProcess * 2 * FM_PCD_MANIP_CAPWAP_REASM_AUTO_LEARNING_HASH_ENTRY_SIZE)); + if (!p_Manip->capwapFragParams.p_AutoLearnHashTbl) + 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)); - tmpReg32 = (uint32_t)(XX_VirtToPhys(p_Manip->fragParams.p_AutoLearnHashTbl) - p_FmPcd->physicalMuramBase); + tmpReg32 = (uint32_t)(XX_VirtToPhys(p_Manip->capwapFragParams.p_AutoLearnHashTbl) - p_FmPcd->physicalMuramBase); WRITE_UINT32(((t_CapwapReasmPram *)p_Table)->autoLearnHashTblPtr, tmpReg32); 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; - tmpReg32 |= FM_PCD_MANIP_CAPWAP_REASM_AUTOMATIC_LEARNIN_HASH_8_WAYS; + tmpReg32 |= FM_PCD_MANIP_CAPWAP_REASM_AUTOMATIC_LEARNIN_HASH_8_WAYS; } else - i = 4; + i = 4; numOfSets = (uint8_t)((p_ManipParams->maxNumFramesInProcess * 2) / i); LOG2(numOfSets, log2Num); @@ -2461,8 +3103,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->fragParams.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; @@ -2470,28 +3112,28 @@ static t_Error CapwapReassembly(t_CapwapReassemblyParams *p_ManipParams, WRITE_UINT32(((t_CapwapReasmPram *)p_Table)->risc23SetIndexes, 0x80008000); WRITE_UINT32(((t_CapwapReasmPram *)p_Table)->risc4SetIndexesAndExtendedStatsTblPtr, 0x80000000); - p_Manip->fragParams.maxNumFramesInProcess = p_ManipParams->maxNumFramesInProcess; + p_Manip->capwapFragParams.maxNumFramesInProcess = p_ManipParams->maxNumFramesInProcess; - p_Manip->fragParams.sgBpid = poolId; + p_Manip->capwapFragParams.sgBpid = poolId; - p_Manip->fragParams.fqidForTimeOutFrames = p_ManipParams->fqidForTimeOutFrames; - p_Manip->fragParams.timeoutRoutineRequestTime = p_ManipParams->timeoutRoutineRequestTime; - p_Manip->fragParams.bitFor1Micro = FmGetTimeStampScale(p_FmPcd->h_Fm); + p_Manip->capwapFragParams.fqidForTimeOutFrames = p_ManipParams->fqidForTimeOutFrames; + p_Manip->capwapFragParams.timeoutRoutineRequestTime = p_ManipParams->timeoutRoutineRequestTime; + p_Manip->capwapFragParams.bitFor1Micro = FmGetTimeStampScale(p_FmPcd->h_Fm); tmpReg32 = 0; - tmpReg32 |= (((uint32_t)1<<p_Manip->fragParams.bitFor1Micro) * p_ManipParams->timeoutThresholdForReassmProcess); + tmpReg32 |= (((uint32_t)1<<p_Manip->capwapFragParams.bitFor1Micro) * p_ManipParams->timeoutThresholdForReassmProcess); WRITE_UINT32(((t_CapwapReasmPram *)p_Table)->expirationDelay, tmpReg32); return E_OK; } -static t_Error CapwapFragmentation(t_CapwapFragmentationParams *p_ManipParams, - t_FmPcdManip *p_Manip, - t_FmPcd *p_FmPcd, - uint8_t poolId) +static t_Error CapwapFragmentation(t_CapwapFragmentationParams *p_ManipParams, + t_FmPcdManip *p_Manip, + t_FmPcd *p_FmPcd, + uint8_t poolId) { - t_AdOfTypeContLookup *p_Ad; - uint32_t tmpReg32 = 0; + t_AdOfTypeContLookup *p_Ad; + uint32_t tmpReg32 = 0; SANITY_CHECK_RETURN_ERROR(p_Manip->h_Ad,E_INVALID_HANDLE); @@ -2500,12 +3142,12 @@ static t_Error CapwapFragmentation(t_CapwapFragmentationParams *p_ManipParams, p_Manip->frag = TRUE; p_Manip->h_Frag = (t_Handle)FM_MURAM_AllocMem(p_FmPcd->h_FmMuram, - FM_PCD_CC_AD_ENTRY_SIZE, - FM_PCD_CC_AD_TABLE_ALIGN); + FM_PCD_CC_AD_ENTRY_SIZE, + FM_PCD_CC_AD_TABLE_ALIGN); if (!p_Manip->h_Frag) - RETURN_ERROR(MAJOR, E_NO_MEMORY, ("MURAM alloc for CAPWAP fragmentation table descriptor")); + RETURN_ERROR(MAJOR, E_NO_MEMORY, ("MURAM alloc for CAPWAP fragmentation table descriptor")); - IOMemSet32(p_Manip->h_Frag, 0, FM_PCD_CC_AD_ENTRY_SIZE); + IOMemSet32(p_Manip->h_Frag, 0, FM_PCD_CC_AD_ENTRY_SIZE); p_Ad = (t_AdOfTypeContLookup *)p_Manip->h_Frag; @@ -2513,7 +3155,7 @@ static t_Error CapwapFragmentation(t_CapwapFragmentationParams *p_ManipParams, tmpReg32 |= (uint32_t)HMAN_OC_CAPWAP_FRAGMENTATION; if (p_ManipParams->headerOptionsCompr) - tmpReg32 |= FM_PCD_MANIP_CAPWAP_FRAG_COMPR_OPTION_FIELD_EN; + tmpReg32 |= FM_PCD_MANIP_CAPWAP_FRAG_COMPR_OPTION_FIELD_EN; tmpReg32 |= ((uint32_t)poolId << 8); WRITE_UINT32(p_Ad->pcAndOffsets, tmpReg32); @@ -2522,39 +3164,292 @@ static t_Error CapwapFragmentation(t_CapwapFragmentationParams *p_ManipParams, WRITE_UINT32(p_Ad->ccAdBase, tmpReg32); p_Manip->sizeForFragmentation = p_ManipParams->sizeForFragmentation; - p_Manip->fragParams.sgBpid = poolId; + p_Manip->capwapFragParams.sgBpid = poolId; + + return E_OK; +} + +static t_Error IndxStats(t_FmPcdStatsParams *p_StatsParams,t_FmPcdManip *p_Manip,t_FmPcd *p_FmPcd) +{ + t_AdOfTypeContLookup *p_Ad; + uint32_t tmpReg32 = 0; + + SANITY_CHECK_RETURN_ERROR(p_Manip->h_Ad,E_INVALID_HANDLE); + + UNUSED(p_FmPcd); + + p_Ad = (t_AdOfTypeContLookup *)p_Manip->h_Ad; + + tmpReg32 = 0; + tmpReg32 |= (uint32_t)HMAN_OC_CAPWAP_INDEXED_STATS; + if (p_StatsParams->type == e_FM_PCD_STATS_PER_FLOWID) + tmpReg32 |= (uint32_t)0x16 << 16; + WRITE_UINT32(p_Ad->pcAndOffsets, tmpReg32); + + tmpReg32 = 0; + tmpReg32 |= FM_PCD_AD_CONT_LOOKUP_TYPE; + WRITE_UINT32(p_Ad->ccAdBase, tmpReg32); return E_OK; } -#endif /* FM_CAPWAP_SUPPORT */ -static t_Error FillReassmManipParams(t_FmPcdManip *p_Manip, bool ipv4) +static t_Error InsrtHdrByTempl(t_FmPcdManipHdrInsrtParams *p_ManipParams, t_FmPcdManip *p_Manip, t_FmPcd *p_FmPcd) { + t_FmPcdManipHdrInsrtByTemplateParams *p_InsrtByTemplate = &p_ManipParams->u.byTemplate; + uint8_t tmpReg8 = 0xff; t_AdOfTypeContLookup *p_Ad; - t_FmPcd *p_FmPcd = (t_FmPcd *)p_Manip->h_FmPcd; - uint32_t tmpReg32; - t_Error err = E_OK; + bool ipModify = FALSE; + uint32_t tmpReg32 = 0, tmpRegNia = 0; + uint16_t tmpReg16 = 0; + t_Error err = E_OK; + uint8_t extraAddedBytes = 0, blockSize = 0, extraAddedBytesAlignedToBlockSize = 0, log2Num = 0; + uint8_t *p_Template = NULL; + + SANITY_CHECK_RETURN_ERROR(p_ManipParams,E_NULL_POINTER); + SANITY_CHECK_RETURN_ERROR(p_Manip,E_NULL_POINTER); + SANITY_CHECK_RETURN_ERROR(p_Manip->h_Ad,E_INVALID_HANDLE); + SANITY_CHECK_RETURN_ERROR(p_FmPcd,E_NULL_POINTER); + + p_Ad = (t_AdOfTypeContLookup *)p_Manip->h_Ad; + if (p_Manip->insrt) + { + if ((!p_InsrtByTemplate->size && p_InsrtByTemplate->modifyOuterIp) || + (!p_InsrtByTemplate->size && p_InsrtByTemplate->modifyOuterVlan)) + RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Inconsistent parameters : asking for header template modifications with no template for insertion (template size)")); + + if (p_InsrtByTemplate->size && p_InsrtByTemplate->modifyOuterIp && (p_InsrtByTemplate->size <= p_InsrtByTemplate->modifyOuterIpParams.ipOuterOffset)) + RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Inconsistent parameters : size of template < ipOuterOffset")); - /* Creates the IP Reassembly Parameters table. It contains parameters that are specific to either the IPv4 reassembly + if (p_InsrtByTemplate->size > 128) + RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("Size of header template for insertion can not be more than 128")); + + if (p_InsrtByTemplate->size) + { + p_Manip->p_Template = (uint8_t *)FM_MURAM_AllocMem(p_FmPcd->h_FmMuram, + p_InsrtByTemplate->size, + FM_PCD_CC_AD_TABLE_ALIGN); + if(!p_Manip->p_Template) + RETURN_ERROR(MAJOR, E_NO_MEMORY, ("Memory allocation in MURAM FAILED")); + + tmpReg32 = (uint32_t)(XX_VirtToPhys(p_Manip->p_Template) - (p_FmPcd->physicalMuramBase)); + tmpReg32 |= (uint32_t)p_InsrtByTemplate->size << 24; + *(uint32_t *)&p_Ad->matchTblPtr = tmpReg32; + } + + tmpReg32 = 0; + + p_Template = (uint8_t *)XX_Malloc(p_InsrtByTemplate->size * sizeof(uint8_t)); + + if (!p_Template) + RETURN_ERROR(MAJOR, E_NO_MEMORY, ("XX_Malloc allocation FAILED")); + + memcpy(p_Template, p_InsrtByTemplate->hdrTemplate, p_InsrtByTemplate->size * sizeof(uint8_t)); + + if (p_InsrtByTemplate->modifyOuterIp) + { + ipModify = TRUE; + + tmpReg8 = (uint8_t)p_Template[p_InsrtByTemplate->modifyOuterIpParams.ipOuterOffset]; + + if((tmpReg8 & 0xf0) == 0x40) + tmpReg8 = 4; + else if((tmpReg8 & 0xf0) == 0x60) + tmpReg8 = 6; + else + tmpReg8 = 0xff; + + if (tmpReg8 != 0xff) + { + if(p_InsrtByTemplate->modifyOuterIpParams.dscpEcn & 0xff00) + RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Inconsistent parameters : IPV4 present in header template, dscpEcn has to be only 1 byte")); + if(p_InsrtByTemplate->modifyOuterIpParams.recalculateLength) + { + + if((p_InsrtByTemplate->modifyOuterIpParams.recalculateLengthParams.extraBytesAddedAlignedToBlockSize + p_InsrtByTemplate->modifyOuterIpParams.recalculateLengthParams.extraBytesAddedNotAlignedToBlockSize) > 255) + RETURN_ERROR(MAJOR, E_INVALID_STATE, ("extra Byte added can not be more than 256 bytes")); + extraAddedBytes = (uint8_t) (p_InsrtByTemplate->modifyOuterIpParams.recalculateLengthParams.extraBytesAddedAlignedToBlockSize + p_InsrtByTemplate->modifyOuterIpParams.recalculateLengthParams.extraBytesAddedNotAlignedToBlockSize); + blockSize = p_InsrtByTemplate->modifyOuterIpParams.recalculateLengthParams.blockSize; + extraAddedBytesAlignedToBlockSize = p_InsrtByTemplate->modifyOuterIpParams.recalculateLengthParams.extraBytesAddedAlignedToBlockSize; + /*IP header template - IP totalLength - + (1 byte) extraByteForIp = headerTemplateSize - ipOffset + insertedBytesAfterThisStage , + in the case of SEC insertedBytesAfterThisStage - SEC trailer (21/31) + header(13) + second byte - extraByteForIp = headerTemplate - ipOffset + insertedBytesAfterThisStage*/ + } + if (blockSize) + { + if (!POWER_OF_2(blockSize)) + RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("inputFrmPaddingUpToBlockSize has to be power of 2")); + } + + } + if (tmpReg8 == 4) + { + if ((IPv4_HDRCHECKSUM_FIELD_OFFSET_FROM_IP + p_InsrtByTemplate->modifyOuterIpParams.ipOuterOffset) > p_InsrtByTemplate->size) + RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Inconsistent parameters : IP present in header template, user asked for IP modifications but ipOffset + ipTotalLengthFieldOffset in header template bigger than template size")); + + p_Template[p_InsrtByTemplate->modifyOuterIpParams.ipOuterOffset + IPv4_DSCECN_FIELD_OFFSET_FROM_IP] = (uint8_t)p_InsrtByTemplate->modifyOuterIpParams.dscpEcn; + + if (blockSize) + blockSize -= 1; + + if ((p_InsrtByTemplate->size - p_InsrtByTemplate->modifyOuterIpParams.ipOuterOffset + extraAddedBytes) > 255) + RETURN_ERROR(MAJOR, E_INVALID_STATE, ("p_InsrtByTemplate->size - p_InsrtByTemplate->modifyOuterIpParams.ipOuterOffset + extraAddedBytes has to be less than 255")); + + p_Template[p_InsrtByTemplate->modifyOuterIpParams.ipOuterOffset + IPv4_TOTALLENGTH_FIELD_OFFSET_FROM_IP + 1] = blockSize; // IPV6 - in AD instead of SEQ IND + p_Template[p_InsrtByTemplate->modifyOuterIpParams.ipOuterOffset + IPv4_TOTALLENGTH_FIELD_OFFSET_FROM_IP] = (uint8_t)(p_InsrtByTemplate->size - p_InsrtByTemplate->modifyOuterIpParams.ipOuterOffset + extraAddedBytes);// for IPV6 decrement additional 40 bytes of IPV6 heade size + + p_Template[p_InsrtByTemplate->modifyOuterIpParams.ipOuterOffset + IPv4_ID_FIELD_OFFSET_FROM_IP] = 0x00; + p_Template[p_InsrtByTemplate->modifyOuterIpParams.ipOuterOffset + IPv4_ID_FIELD_OFFSET_FROM_IP + 1] = extraAddedBytesAlignedToBlockSize; + + /*IP header template - relevant only for ipv4 CheckSum = 0*/ + p_Template[p_InsrtByTemplate->modifyOuterIpParams.ipOuterOffset + IPv4_HDRCHECKSUM_FIELD_OFFSET_FROM_IP] = 0x00; + p_Template[p_InsrtByTemplate->modifyOuterIpParams.ipOuterOffset + IPv4_HDRCHECKSUM_FIELD_OFFSET_FROM_IP + 1] = 0x00; + + /*UDP checksum has to be 0*/ + if (p_InsrtByTemplate->modifyOuterIpParams.udpPresent) + { + if ((p_InsrtByTemplate->modifyOuterIpParams.udpOffset + UDP_CHECKSUM_FIELD_OFFSET_FROM_UDP + UDP_CHECKSUM_FIELD_SIZE) > p_InsrtByTemplate->size) + RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Inconsistent parameters : UDP present according to user but (UDP offset + UDP header size) < size of header template")); + + p_Template[p_InsrtByTemplate->modifyOuterIpParams.udpOffset + UDP_CHECKSUM_FIELD_OFFSET_FROM_UDP ] = 0x00; + p_Template[p_InsrtByTemplate->modifyOuterIpParams.udpOffset + UDP_CHECKSUM_FIELD_OFFSET_FROM_UDP + 1] = 0x00; + + } + + if (p_InsrtByTemplate->modifyOuterIpParams.ipIdentGenId > 7) + RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("ipIdentGenId has to be one out of 8 sequence number generators (0 - 7) for IP identification field")); + + tmpRegNia |= (uint32_t)p_InsrtByTemplate->modifyOuterIpParams.ipIdentGenId<<24; + } + else if (tmpReg8 == 6) + { + /*TODO - add check for maximum value of blockSize;*/ + if (blockSize) + LOG2(blockSize, log2Num); + tmpRegNia |= (uint32_t)log2Num << 24; + + // for IPV6 decrement additional 40 bytes of IPV6 heade size - because IPV6 header size is not included in payloadLength + p_Template[p_InsrtByTemplate->modifyOuterIpParams.ipOuterOffset + IPv6_PAYLOAD_LENGTH_OFFSET_FROM_IP] = (uint8_t)(p_InsrtByTemplate->size - p_InsrtByTemplate->modifyOuterIpParams.ipOuterOffset + extraAddedBytes - 40); + p_Template[p_InsrtByTemplate->modifyOuterIpParams.ipOuterOffset + IPv6_PAYLOAD_LENGTH_OFFSET_FROM_IP + 1] = extraAddedBytesAlignedToBlockSize; + if (p_InsrtByTemplate->modifyOuterIpParams.udpPresent) + { + if ((p_InsrtByTemplate->modifyOuterIpParams.udpOffset + UDP_CHECKSUM_FIELD_OFFSET_FROM_UDP + UDP_CHECKSUM_FIELD_SIZE) > p_InsrtByTemplate->size) + RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Inconsistent parameters : UDP present according to user but (UDP offset + UDP header size) < size of header template")); + if (p_Template[p_InsrtByTemplate->modifyOuterIpParams.ipOuterOffset + IPv6_NEXT_HEADER_OFFSET_FROM_IP] != 0x88) + RETURN_ERROR(MAJOR, E_INVALID_STATE, ("OUr suppport is only IPv6/UDPLite")); + p_Template[p_InsrtByTemplate->modifyOuterIpParams.udpOffset + UDP_LENGTH_FIELD_OFFSET_FROM_UDP] = 0x00; + p_Template[p_InsrtByTemplate->modifyOuterIpParams.udpOffset + UDP_LENGTH_FIELD_OFFSET_FROM_UDP + 1] = 0x08; + p_Template[p_InsrtByTemplate->modifyOuterIpParams.udpOffset + UDP_CHECKSUM_FIELD_OFFSET_FROM_UDP] = 0x00; + p_Template[p_InsrtByTemplate->modifyOuterIpParams.udpOffset + UDP_CHECKSUM_FIELD_OFFSET_FROM_UDP + 1] = 0x00; + } + } + else + RETURN_ERROR(MAJOR, E_INVALID_STATE, ("IP version supported only IPV4")); + } + + tmpReg32 = tmpReg16 = tmpReg8 = 0; + /*TODO - check it*/ + if (p_InsrtByTemplate->modifyOuterVlan) + { + if (p_InsrtByTemplate->modifyOuterVlanParams.vpri & ~0x07) + RETURN_ERROR(MAJOR, E_INVALID_STATE,("Inconsistent parameters : user asked for VLAN modifications but VPRI more than 3 bits")); + + memcpy(&tmpReg16, &p_Template[VLAN_TAG_FIELD_OFFSET_FROM_ETH], 2*(sizeof(uint8_t))); + if ((tmpReg16 != 0x9100) && (tmpReg16!= 0x9200) && (tmpReg16 != 0x8100)) + RETURN_ERROR(MAJOR, E_INVALID_STATE,("Inconsistent parameters : user asked for VLAN modifications but Tag Protocol identifier is not VLAN ")); + + memcpy(&tmpReg8, &p_Template[14],1*(sizeof(uint8_t))); + tmpReg8 &= 0x1f; + tmpReg8 |= (uint8_t)(p_InsrtByTemplate->modifyOuterVlanParams.vpri << 5); + + p_Template[14] = tmpReg8; + } + + Mem2IOCpy32(p_Manip->p_Template, p_Template, p_InsrtByTemplate->size); + + XX_Free(p_Template); + } + + tmpReg32 = 0; + if (p_Manip->h_Frag) + { + tmpRegNia |= (uint32_t)(XX_VirtToPhys(p_Manip->h_Frag) - (p_FmPcd->physicalMuramBase)); + tmpReg32 |= (uint32_t)p_Manip->sizeForFragmentation << 16; + } + else + tmpReg32 = 0xffff0000; + + if (ipModify) + tmpReg32 |= (uint32_t)p_InsrtByTemplate->modifyOuterIpParams.ipOuterOffset << 8; + else + tmpReg32 |= (uint32_t)0x0000ff00; + + tmpReg32 |= (uint32_t)HMAN_OC_INSRT_HDR_BY_TEMPL_N_OR_FRAG_AFTER; + *(uint32_t *)&p_Ad->pcAndOffsets = tmpReg32; + + tmpRegNia |= FM_PCD_AD_CONT_LOOKUP_TYPE; + *(uint32_t *)&p_Ad->ccAdBase = tmpRegNia; + + return err; +} + +static t_Error CheckStatsParamsAndSetType(t_FmPcdManip *p_Manip, t_FmPcdStatsParams *p_StatsParams) +{ + + switch (p_StatsParams->type) + { + case (e_FM_PCD_STATS_PER_FLOWID): + p_Manip->opcode = HMAN_OC_CAPWAP_INDEXED_STATS; + p_Manip->muramAllocate = TRUE; + break; + default: + RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Unsupported statistics type")); + } + + return E_OK; +} +#endif /* (defined(FM_CAPWAP_SUPPORT) && (DPAA_VERSION == 10)) */ + +static t_Error FillReassmManipParams(t_FmPcdManip *p_Manip, e_NetHeaderType hdr) +{ + t_AdOfTypeContLookup *p_Ad; + t_FmPcd *p_FmPcd = (t_FmPcd *)p_Manip->h_FmPcd; + uint32_t tmpReg32; + t_Error err = E_OK; + + /* Creates the Reassembly Parameters table. It contains parameters that are specific to either the IPv4 reassembly function or to the IPv6 reassembly function. If both IPv4 reassembly and IPv6 reassembly are required, then two separate IP Reassembly Parameter tables are required.*/ - if ((err = CreateIpReassTable(p_Manip, ipv4)) != E_OK) + if ((err = CreateReassTable(p_Manip, hdr)) != E_OK) RETURN_ERROR(MAJOR, err, NO_MSG); - /* Sets the first Ad register (ccAdBase) - Action Descriptor Type and Pointer to the IP Reassembly Parameters Table offset from MURAM*/ + /* Sets the first Ad register (ccAdBase) - Action Descriptor Type and Pointer to the Reassembly Parameters Table offset from MURAM*/ tmpReg32 = 0; tmpReg32 |= FM_PCD_AD_CONT_LOOKUP_TYPE; /* Gets the required Action descriptor table pointer */ - if (ipv4) + switch (hdr) { - p_Ad = (t_AdOfTypeContLookup *)p_Manip->ipReassmParams.h_Ipv4Ad; - tmpReg32 |= (uint32_t)(XX_VirtToPhys(p_Manip->ipReassmParams.p_Ipv4ReassTbl) - (p_FmPcd->physicalMuramBase)); - } - else - { - p_Ad = (t_AdOfTypeContLookup *)p_Manip->ipReassmParams.h_Ipv6Ad; - tmpReg32 |= (uint32_t)(XX_VirtToPhys(p_Manip->ipReassmParams.p_Ipv6ReassTbl) - (p_FmPcd->physicalMuramBase)); + case HEADER_TYPE_IPv4: + p_Ad = (t_AdOfTypeContLookup *)p_Manip->reassmParams.ip.h_Ipv4Ad; + tmpReg32 |= (uint32_t)(XX_VirtToPhys( + p_Manip->reassmParams.ip.p_Ipv4ReassTbl) + - (p_FmPcd->physicalMuramBase)); + break; + case HEADER_TYPE_IPv6: + p_Ad = (t_AdOfTypeContLookup *)p_Manip->reassmParams.ip.h_Ipv6Ad; + tmpReg32 |= (uint32_t)(XX_VirtToPhys( + p_Manip->reassmParams.ip.p_Ipv6ReassTbl) + - (p_FmPcd->physicalMuramBase)); + break; + case HEADER_TYPE_CAPWAP: + p_Ad = (t_AdOfTypeContLookup *)p_Manip->reassmParams.capwap.h_Ad; + tmpReg32 |= (uint32_t)(XX_VirtToPhys( + p_Manip->reassmParams.capwap.p_ReassTbl) + - (p_FmPcd->physicalMuramBase)); + break; + default: + break; } WRITE_UINT32(p_Ad->ccAdBase, tmpReg32); @@ -2563,21 +3458,33 @@ static t_Error FillReassmManipParams(t_FmPcdManip *p_Manip, bool ipv4) /* mark the Scatter/Gather table offset to be set later on when the port will be known */ p_Manip->updateParams = (NUM_OF_TASKS | NUM_OF_EXTRA_TASKS | DISCARD_MASK); + if ((hdr == HEADER_TYPE_IPv6) || (hdr == HEADER_TYPE_IPv4)) + { #if (DPAA_VERSION == 10) - tmpReg32 = (uint32_t)(p_Manip->ipReassmParams.sgBpid << 8); - WRITE_UINT32(p_Ad->matchTblPtr, tmpReg32); + tmpReg32 = (uint32_t)(p_Manip->reassmParams.sgBpid << 8); + WRITE_UINT32(p_Ad->matchTblPtr, tmpReg32); #endif /* (DPAA_VERSION == 10) */ #if (DPAA_VERSION >= 11) - if (p_Manip->ipReassmParams.nonConsistentSpFqid != 0) - { - tmpReg32 = FM_PCD_AD_NCSPFQIDM_MASK | (uint32_t)(p_Manip->ipReassmParams.nonConsistentSpFqid); - WRITE_UINT32(p_Ad->gmask, tmpReg32); + if (p_Manip->reassmParams.ip.nonConsistentSpFqid != 0) + { + tmpReg32 = FM_PCD_AD_NCSPFQIDM_MASK + | (uint32_t)(p_Manip->reassmParams.ip.nonConsistentSpFqid); + WRITE_UINT32(p_Ad->gmask, tmpReg32); + } +#endif /* (DPAA_VERSION >= 11) */ + /* Sets the third Ad register (pcAndOffsets)- IP Reassemble Operation Code*/ + tmpReg32 = 0; + tmpReg32 |= (uint32_t)HMAN_OC_IP_REASSEMBLY; } +#if (DPAA_VERSION >= 11) + else + if (hdr == HEADER_TYPE_CAPWAP) + { + tmpReg32 = 0; + tmpReg32 |= (uint32_t)HMAN_OC_CAPWAP_REASSEMBLY; + } #endif /* (DPAA_VERSION >= 11) */ - /* Sets the third Ad register (pcAndOffsets)- IP Reassemble Operation Code*/ - tmpReg32 = 0; - tmpReg32 |= (uint32_t)HMAN_OC_IP_REASSEMBLY; WRITE_UINT32(p_Ad->pcAndOffsets, tmpReg32); p_Manip->reassm = TRUE; @@ -2590,20 +3497,20 @@ static t_Error SetIpv4ReassmManip(t_FmPcdManip *p_Manip) t_FmPcd *p_FmPcd = (t_FmPcd *)p_Manip->h_FmPcd; /* Allocation if IPv4 Action descriptor */ - p_Manip->ipReassmParams.h_Ipv4Ad = - (t_Handle)XX_MallocSmart(FM_PCD_CC_AD_ENTRY_SIZE, - p_Manip->ipReassmParams.dataMemId, - FM_PCD_CC_AD_TABLE_ALIGN); - if (!p_Manip->ipReassmParams.h_Ipv4Ad) + p_Manip->reassmParams.ip.h_Ipv4Ad = (t_Handle)XX_MallocSmart( + FM_PCD_CC_AD_ENTRY_SIZE, p_Manip->reassmParams.dataMemId, + FM_PCD_CC_AD_TABLE_ALIGN); + if (!p_Manip->reassmParams.ip.h_Ipv4Ad) { ReleaseManipHandler(p_Manip, p_FmPcd); - RETURN_ERROR(MAJOR, E_NO_MEMORY, ("Allocation of IPv4 table descriptor")); + RETURN_ERROR(MAJOR, E_NO_MEMORY, + ("Allocation of IPv4 table descriptor")); } - memset(p_Manip->ipReassmParams.h_Ipv4Ad, 0, FM_PCD_CC_AD_ENTRY_SIZE); + memset(p_Manip->reassmParams.ip.h_Ipv4Ad, 0, FM_PCD_CC_AD_ENTRY_SIZE); /* Fill reassembly manipulation parameter in the IP Reassembly Action Descriptor */ - return FillReassmManipParams(p_Manip, TRUE); + return FillReassmManipParams(p_Manip, HEADER_TYPE_IPv4); } static t_Error SetIpv6ReassmManip(t_FmPcdManip *p_Manip) @@ -2611,74 +3518,90 @@ static t_Error SetIpv6ReassmManip(t_FmPcdManip *p_Manip) t_FmPcd *p_FmPcd = (t_FmPcd *)p_Manip->h_FmPcd; /* Allocation if IPv6 Action descriptor */ - p_Manip->ipReassmParams.h_Ipv6Ad = - (t_Handle)XX_MallocSmart(FM_PCD_CC_AD_ENTRY_SIZE, - p_Manip->ipReassmParams.dataMemId, - FM_PCD_CC_AD_TABLE_ALIGN); - if (!p_Manip->ipReassmParams.h_Ipv6Ad) - { + p_Manip->reassmParams.ip.h_Ipv6Ad = (t_Handle)XX_MallocSmart( + FM_PCD_CC_AD_ENTRY_SIZE, p_Manip->reassmParams.dataMemId, + FM_PCD_CC_AD_TABLE_ALIGN); + if (!p_Manip->reassmParams.ip.h_Ipv6Ad) + { ReleaseManipHandler(p_Manip, p_FmPcd); - RETURN_ERROR(MAJOR, E_NO_MEMORY, ("Allocation of IPv6 table descriptor")); - } + RETURN_ERROR(MAJOR, E_NO_MEMORY, + ("Allocation of IPv6 table descriptor")); + } - memset(p_Manip->ipReassmParams.h_Ipv6Ad, 0, FM_PCD_CC_AD_ENTRY_SIZE); + memset(p_Manip->reassmParams.ip.h_Ipv6Ad, 0, FM_PCD_CC_AD_ENTRY_SIZE); /* Fill reassembly manipulation parameter in the IP Reassembly Action Descriptor */ - return FillReassmManipParams(p_Manip, FALSE); + return FillReassmManipParams(p_Manip, HEADER_TYPE_IPv6); } -static t_Error IpReassembly(t_FmPcdManipReassemParams *p_ManipReassmParams, - t_FmPcdManip *p_Manip) +static t_Error IpReassembly(t_FmPcdManipReassemParams *p_ManipReassmParams, + t_FmPcdManip *p_Manip) { - uint32_t maxSetNumber = 10000; - t_FmPcdManipReassemIpParams reassmManipParams = p_ManipReassmParams->u.ipReassem; - t_Error res; + uint32_t maxSetNumber = 10000; + t_FmPcdManipReassemIpParams reassmManipParams = + p_ManipReassmParams->u.ipReassem; + t_Error res; SANITY_CHECK_RETURN_ERROR(p_Manip->h_FmPcd, E_INVALID_HANDLE); - SANITY_CHECK_RETURN_ERROR(((t_FmPcd *)p_Manip->h_FmPcd)->h_Hc, E_INVALID_HANDLE); + SANITY_CHECK_RETURN_ERROR(((t_FmPcd *)p_Manip->h_FmPcd)->h_Hc, + E_INVALID_HANDLE); /* Check validation of user's parameter.*/ - if ((reassmManipParams.timeoutThresholdForReassmProcess < 1000) || - (reassmManipParams.timeoutThresholdForReassmProcess > 8000000)) - RETURN_ERROR(MAJOR, E_INVALID_VALUE,("timeoutThresholdForReassmProcess should be 1msec - 8sec")); + if ((reassmManipParams.timeoutThresholdForReassmProcess < 1000) + || (reassmManipParams.timeoutThresholdForReassmProcess > 8000000)) + RETURN_ERROR( + MAJOR, E_INVALID_VALUE, + ("timeoutThresholdForReassmProcess should be 1msec - 8sec")); /* It is recommended that the total number of entries in this table (number of sets * number of ways) - will be twice the number of frames that are expected to be reassembled simultaneously.*/ - if (reassmManipParams.maxNumFramesInProcess > - (reassmManipParams.maxNumFramesInProcess * maxSetNumber / 2)) - RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("maxNumFramesInProcess has to be less than (maximun set number * number of ways / 2)")); - - if ((p_ManipReassmParams->hdr == HEADER_TYPE_IPv6) && - (reassmManipParams.minFragSize[1] < 256)) + will be twice the number of frames that are expected to be reassembled simultaneously.*/ + if (reassmManipParams.maxNumFramesInProcess + > (reassmManipParams.maxNumFramesInProcess * maxSetNumber / 2)) + RETURN_ERROR( + MAJOR, + E_INVALID_VALUE, + ("maxNumFramesInProcess has to be less than (maximun set number * number of ways / 2)")); + + if ((p_ManipReassmParams->hdr == HEADER_TYPE_IPv6) + && (reassmManipParams.minFragSize[1] < 256)) RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("minFragSize[1] must be >= 256")); /* Saves user's reassembly manipulation parameters */ - p_Manip->ipReassmParams.relativeSchemeId[0] = reassmManipParams.relativeSchemeId[0]; - p_Manip->ipReassmParams.relativeSchemeId[1] = reassmManipParams.relativeSchemeId[1]; - p_Manip->ipReassmParams.numOfFramesPerHashEntry[0] = reassmManipParams.numOfFramesPerHashEntry[0]; - p_Manip->ipReassmParams.numOfFramesPerHashEntry[1] = reassmManipParams.numOfFramesPerHashEntry[1]; - p_Manip->ipReassmParams.minFragSize[0] = reassmManipParams.minFragSize[0]; - p_Manip->ipReassmParams.minFragSize[1] = reassmManipParams.minFragSize[1]; - p_Manip->ipReassmParams.maxNumFramesInProcess = reassmManipParams.maxNumFramesInProcess; - p_Manip->ipReassmParams.timeOutMode = reassmManipParams.timeOutMode; - p_Manip->ipReassmParams.fqidForTimeOutFrames = reassmManipParams.fqidForTimeOutFrames; - p_Manip->ipReassmParams.timeoutThresholdForReassmProcess = reassmManipParams.timeoutThresholdForReassmProcess; - p_Manip->ipReassmParams.dataMemId = reassmManipParams.dataMemId; - p_Manip->ipReassmParams.dataLiodnOffset = reassmManipParams.dataLiodnOffset; + p_Manip->reassmParams.ip.relativeSchemeId[0] = + reassmManipParams.relativeSchemeId[0]; + p_Manip->reassmParams.ip.relativeSchemeId[1] = + reassmManipParams.relativeSchemeId[1]; + p_Manip->reassmParams.ip.numOfFramesPerHashEntry[0] = + reassmManipParams.numOfFramesPerHashEntry[0]; + p_Manip->reassmParams.ip.numOfFramesPerHashEntry[1] = + reassmManipParams.numOfFramesPerHashEntry[1]; + p_Manip->reassmParams.ip.minFragSize[0] = reassmManipParams.minFragSize[0]; + p_Manip->reassmParams.ip.minFragSize[1] = reassmManipParams.minFragSize[1]; + p_Manip->reassmParams.maxNumFramesInProcess = + reassmManipParams.maxNumFramesInProcess; + p_Manip->reassmParams.timeOutMode = reassmManipParams.timeOutMode; + p_Manip->reassmParams.fqidForTimeOutFrames = + reassmManipParams.fqidForTimeOutFrames; + p_Manip->reassmParams.timeoutThresholdForReassmProcess = + reassmManipParams.timeoutThresholdForReassmProcess; + p_Manip->reassmParams.dataMemId = reassmManipParams.dataMemId; + p_Manip->reassmParams.dataLiodnOffset = reassmManipParams.dataLiodnOffset; #if (DPAA_VERSION == 10) - p_Manip->ipReassmParams.sgBpid = reassmManipParams.sgBpid; + p_Manip->reassmParams.sgBpid = reassmManipParams.sgBpid; #endif /* (DPAA_VERSION == 10) */ #if (DPAA_VERSION >= 11) if (reassmManipParams.nonConsistentSpFqid != 0) { - p_Manip->ipReassmParams.nonConsistentSpFqid = reassmManipParams.nonConsistentSpFqid; + p_Manip->reassmParams.ip.nonConsistentSpFqid = + reassmManipParams.nonConsistentSpFqid; } #endif /* (DPAA_VERSION >= 11) */ /* Creates and initializes the IP Reassembly common parameter table */ - CreateIpReassCommonTable(p_Manip); + CreateReassCommonTable(p_Manip); /* Creation of IPv4 reassembly manipulation */ - if ((p_Manip->ipReassmParams.hdr == HEADER_TYPE_IPv6) || (p_Manip->ipReassmParams.hdr == HEADER_TYPE_IPv4)) + if ((p_Manip->reassmParams.hdr == HEADER_TYPE_IPv6) + || (p_Manip->reassmParams.hdr == HEADER_TYPE_IPv4)) { res = SetIpv4ReassmManip(p_Manip); if (res != E_OK) @@ -2686,7 +3609,7 @@ static t_Error IpReassembly(t_FmPcdManipReassemParams *p_ManipReassmParams, } /* Creation of IPv6 reassembly manipulation */ - if (p_Manip->ipReassmParams.hdr == HEADER_TYPE_IPv6) + if (p_Manip->reassmParams.hdr == HEADER_TYPE_IPv6) { res = SetIpv6ReassmManip(p_Manip); if (res != E_OK) @@ -2696,21 +3619,30 @@ static t_Error IpReassembly(t_FmPcdManipReassemParams *p_ManipReassmParams, return E_OK; } -static void setReassmSchemeParams(t_FmPcd* p_FmPcd, t_FmPcdKgSchemeParams *p_Scheme, t_Handle h_CcTree, bool ipv4, uint8_t groupId) +static void setIpReassmSchemeParams(t_FmPcd* p_FmPcd, + t_FmPcdKgSchemeParams *p_Scheme, + t_Handle h_CcTree, bool ipv4, + uint8_t groupId) { - uint32_t j; - uint8_t res; + uint32_t j; + uint8_t res; /* Configures scheme's network environment parameters */ p_Scheme->netEnvParams.numOfDistinctionUnits = 2; if (ipv4) - res = FmPcdNetEnvGetUnitId(p_FmPcd, FmPcdGetNetEnvId(p_Scheme->netEnvParams.h_NetEnv), HEADER_TYPE_IPv4, FALSE, 0); + res = FmPcdNetEnvGetUnitId( + p_FmPcd, FmPcdGetNetEnvId(p_Scheme->netEnvParams.h_NetEnv), + HEADER_TYPE_IPv4, FALSE, 0); else - res = FmPcdNetEnvGetUnitId(p_FmPcd, FmPcdGetNetEnvId(p_Scheme->netEnvParams.h_NetEnv), HEADER_TYPE_IPv6, FALSE, 0); + res = FmPcdNetEnvGetUnitId( + p_FmPcd, FmPcdGetNetEnvId(p_Scheme->netEnvParams.h_NetEnv), + HEADER_TYPE_IPv6, FALSE, 0); ASSERT_COND(res != FM_PCD_MAX_NUM_OF_DISTINCTION_UNITS); p_Scheme->netEnvParams.unitIds[0] = res; - res = FmPcdNetEnvGetUnitId(p_FmPcd, FmPcdGetNetEnvId(p_Scheme->netEnvParams.h_NetEnv), HEADER_TYPE_USER_DEFINED_SHIM2, FALSE, 0); + res = FmPcdNetEnvGetUnitId( + p_FmPcd, FmPcdGetNetEnvId(p_Scheme->netEnvParams.h_NetEnv), + HEADER_TYPE_USER_DEFINED_SHIM2, FALSE, 0); ASSERT_COND(res != FM_PCD_MAX_NUM_OF_DISTINCTION_UNITS); p_Scheme->netEnvParams.unitIds[1] = res; @@ -2724,455 +3656,610 @@ static void setReassmSchemeParams(t_FmPcd* p_FmPcd, t_FmPcdKgSchemeParams *p_Sch if (ipv4 == TRUE) { p_Scheme->keyExtractAndHashParams.numOfUsedExtracts = 4; - p_Scheme->keyExtractAndHashParams.extractArray[0].type = e_FM_PCD_EXTRACT_BY_HDR; - p_Scheme->keyExtractAndHashParams.extractArray[0].extractByHdr.type = e_FM_PCD_EXTRACT_FULL_FIELD; - p_Scheme->keyExtractAndHashParams.extractArray[0].extractByHdr.hdr = HEADER_TYPE_IPv4 ; - p_Scheme->keyExtractAndHashParams.extractArray[0].extractByHdr.extractByHdrType.fullField.ipv4 = NET_HEADER_FIELD_IPv4_DST_IP; - p_Scheme->keyExtractAndHashParams.extractArray[1].type = e_FM_PCD_EXTRACT_BY_HDR; - p_Scheme->keyExtractAndHashParams.extractArray[1].extractByHdr.type = e_FM_PCD_EXTRACT_FULL_FIELD; - p_Scheme->keyExtractAndHashParams.extractArray[1].extractByHdr.hdr = HEADER_TYPE_IPv4; - p_Scheme->keyExtractAndHashParams.extractArray[1].extractByHdr.extractByHdrType.fullField.ipv4 = NET_HEADER_FIELD_IPv4_SRC_IP; - p_Scheme->keyExtractAndHashParams.extractArray[2].type = e_FM_PCD_EXTRACT_BY_HDR; - p_Scheme->keyExtractAndHashParams.extractArray[2].extractByHdr.type = e_FM_PCD_EXTRACT_FULL_FIELD; - p_Scheme->keyExtractAndHashParams.extractArray[2].extractByHdr.hdr = HEADER_TYPE_IPv4; - p_Scheme->keyExtractAndHashParams.extractArray[2].extractByHdr.extractByHdrType.fullField.ipv4 = NET_HEADER_FIELD_IPv4_PROTO; - p_Scheme->keyExtractAndHashParams.extractArray[3].type = e_FM_PCD_EXTRACT_BY_HDR; - p_Scheme->keyExtractAndHashParams.extractArray[3].extractByHdr.hdr = HEADER_TYPE_IPv4; - p_Scheme->keyExtractAndHashParams.extractArray[3].extractByHdr.type = e_FM_PCD_EXTRACT_FROM_HDR; - p_Scheme->keyExtractAndHashParams.extractArray[3].extractByHdr.ignoreProtocolValidation = FALSE; - p_Scheme->keyExtractAndHashParams.extractArray[3].extractByHdr.extractByHdrType.fromHdr.size = 2; - p_Scheme->keyExtractAndHashParams.extractArray[3].extractByHdr.extractByHdrType.fromHdr.offset = 4; + p_Scheme->keyExtractAndHashParams.extractArray[0].type = + e_FM_PCD_EXTRACT_BY_HDR; + p_Scheme->keyExtractAndHashParams.extractArray[0].extractByHdr.type = + e_FM_PCD_EXTRACT_FULL_FIELD; + p_Scheme->keyExtractAndHashParams.extractArray[0].extractByHdr.hdr = + HEADER_TYPE_IPv4; + p_Scheme->keyExtractAndHashParams.extractArray[0].extractByHdr.extractByHdrType.fullField.ipv4 = + NET_HEADER_FIELD_IPv4_DST_IP; + p_Scheme->keyExtractAndHashParams.extractArray[1].type = + e_FM_PCD_EXTRACT_BY_HDR; + p_Scheme->keyExtractAndHashParams.extractArray[1].extractByHdr.type = + e_FM_PCD_EXTRACT_FULL_FIELD; + p_Scheme->keyExtractAndHashParams.extractArray[1].extractByHdr.hdr = + HEADER_TYPE_IPv4; + p_Scheme->keyExtractAndHashParams.extractArray[1].extractByHdr.extractByHdrType.fullField.ipv4 = + NET_HEADER_FIELD_IPv4_SRC_IP; + p_Scheme->keyExtractAndHashParams.extractArray[2].type = + e_FM_PCD_EXTRACT_BY_HDR; + p_Scheme->keyExtractAndHashParams.extractArray[2].extractByHdr.type = + e_FM_PCD_EXTRACT_FULL_FIELD; + p_Scheme->keyExtractAndHashParams.extractArray[2].extractByHdr.hdr = + HEADER_TYPE_IPv4; + p_Scheme->keyExtractAndHashParams.extractArray[2].extractByHdr.extractByHdrType.fullField.ipv4 = + NET_HEADER_FIELD_IPv4_PROTO; + p_Scheme->keyExtractAndHashParams.extractArray[3].type = + e_FM_PCD_EXTRACT_BY_HDR; + p_Scheme->keyExtractAndHashParams.extractArray[3].extractByHdr.hdr = + HEADER_TYPE_IPv4; + p_Scheme->keyExtractAndHashParams.extractArray[3].extractByHdr.type = + e_FM_PCD_EXTRACT_FROM_HDR; + p_Scheme->keyExtractAndHashParams.extractArray[3].extractByHdr.ignoreProtocolValidation = + FALSE; + p_Scheme->keyExtractAndHashParams.extractArray[3].extractByHdr.extractByHdrType.fromHdr.size = + 2; + p_Scheme->keyExtractAndHashParams.extractArray[3].extractByHdr.extractByHdrType.fromHdr.offset = + 4; } else /* IPv6 */ { p_Scheme->keyExtractAndHashParams.numOfUsedExtracts = 3; - p_Scheme->keyExtractAndHashParams.extractArray[0].type = e_FM_PCD_EXTRACT_BY_HDR; - p_Scheme->keyExtractAndHashParams.extractArray[0].extractByHdr.type = e_FM_PCD_EXTRACT_FULL_FIELD; - p_Scheme->keyExtractAndHashParams.extractArray[0].extractByHdr.hdr = HEADER_TYPE_IPv6 ; - p_Scheme->keyExtractAndHashParams.extractArray[0].extractByHdr.extractByHdrType.fullField.ipv6 = NET_HEADER_FIELD_IPv6_DST_IP; - p_Scheme->keyExtractAndHashParams.extractArray[1].type = e_FM_PCD_EXTRACT_BY_HDR; - p_Scheme->keyExtractAndHashParams.extractArray[1].extractByHdr.type = e_FM_PCD_EXTRACT_FULL_FIELD; - p_Scheme->keyExtractAndHashParams.extractArray[1].extractByHdr.hdr = HEADER_TYPE_IPv6; - p_Scheme->keyExtractAndHashParams.extractArray[1].extractByHdr.extractByHdrType.fullField.ipv6 = NET_HEADER_FIELD_IPv6_SRC_IP; - p_Scheme->keyExtractAndHashParams.extractArray[2].type = e_FM_PCD_EXTRACT_BY_HDR; - p_Scheme->keyExtractAndHashParams.extractArray[2].extractByHdr.hdr = HEADER_TYPE_USER_DEFINED_SHIM2; - p_Scheme->keyExtractAndHashParams.extractArray[2].extractByHdr.type = e_FM_PCD_EXTRACT_FROM_HDR; - p_Scheme->keyExtractAndHashParams.extractArray[2].extractByHdr.extractByHdrType.fromHdr.size = 4; - p_Scheme->keyExtractAndHashParams.extractArray[2].extractByHdr.extractByHdrType.fromHdr.offset = 4; - p_Scheme->keyExtractAndHashParams.extractArray[2].extractByHdr.ignoreProtocolValidation = TRUE; + p_Scheme->keyExtractAndHashParams.extractArray[0].type = + e_FM_PCD_EXTRACT_BY_HDR; + p_Scheme->keyExtractAndHashParams.extractArray[0].extractByHdr.type = + e_FM_PCD_EXTRACT_FULL_FIELD; + p_Scheme->keyExtractAndHashParams.extractArray[0].extractByHdr.hdr = + HEADER_TYPE_IPv6; + p_Scheme->keyExtractAndHashParams.extractArray[0].extractByHdr.extractByHdrType.fullField.ipv6 = + NET_HEADER_FIELD_IPv6_DST_IP; + p_Scheme->keyExtractAndHashParams.extractArray[1].type = + e_FM_PCD_EXTRACT_BY_HDR; + p_Scheme->keyExtractAndHashParams.extractArray[1].extractByHdr.type = + e_FM_PCD_EXTRACT_FULL_FIELD; + p_Scheme->keyExtractAndHashParams.extractArray[1].extractByHdr.hdr = + HEADER_TYPE_IPv6; + p_Scheme->keyExtractAndHashParams.extractArray[1].extractByHdr.extractByHdrType.fullField.ipv6 = + NET_HEADER_FIELD_IPv6_SRC_IP; + p_Scheme->keyExtractAndHashParams.extractArray[2].type = + e_FM_PCD_EXTRACT_BY_HDR; + p_Scheme->keyExtractAndHashParams.extractArray[2].extractByHdr.hdr = + HEADER_TYPE_USER_DEFINED_SHIM2; + p_Scheme->keyExtractAndHashParams.extractArray[2].extractByHdr.type = + e_FM_PCD_EXTRACT_FROM_HDR; + p_Scheme->keyExtractAndHashParams.extractArray[2].extractByHdr.extractByHdrType.fromHdr.size = + 4; + p_Scheme->keyExtractAndHashParams.extractArray[2].extractByHdr.extractByHdrType.fromHdr.offset = + 4; + p_Scheme->keyExtractAndHashParams.extractArray[2].extractByHdr.ignoreProtocolValidation = + TRUE; } p_Scheme->keyExtractAndHashParams.privateDflt0 = 0x01020304; p_Scheme->keyExtractAndHashParams.privateDflt1 = 0x11121314; - p_Scheme->keyExtractAndHashParams.numOfUsedDflts = FM_PCD_KG_NUM_OF_DEFAULT_GROUPS; - for (j=0; j<FM_PCD_KG_NUM_OF_DEFAULT_GROUPS; j++) + p_Scheme->keyExtractAndHashParams.numOfUsedDflts = + FM_PCD_KG_NUM_OF_DEFAULT_GROUPS; + for (j = 0; j < FM_PCD_KG_NUM_OF_DEFAULT_GROUPS; j++) { - p_Scheme->keyExtractAndHashParams.dflts[j].type = (e_FmPcdKgKnownFieldsDfltTypes)j; /* all types */ - p_Scheme->keyExtractAndHashParams.dflts[j].dfltSelect = e_FM_PCD_KG_DFLT_GBL_0; + p_Scheme->keyExtractAndHashParams.dflts[j].type = + (e_FmPcdKgKnownFieldsDfltTypes)j; /* all types */ + p_Scheme->keyExtractAndHashParams.dflts[j].dfltSelect = + e_FM_PCD_KG_DFLT_GBL_0; } } -static t_Error IpReassemblyStats(t_FmPcdManip *p_Manip, t_FmPcdManipReassemIpStats *p_Stats) +static t_Error IpReassemblyStats(t_FmPcdManip *p_Manip, + t_FmPcdManipReassemIpStats *p_Stats) { ASSERT_COND(p_Manip); ASSERT_COND(p_Stats); - ASSERT_COND(p_Manip->ipReassmParams.p_IpReassCommonTbl); - - p_Stats->timeout = GET_UINT32(p_Manip->ipReassmParams.p_IpReassCommonTbl->totalTimeOutCounter); - p_Stats->rfdPoolBusy = GET_UINT32(p_Manip->ipReassmParams.p_IpReassCommonTbl->totalRfdPoolBusyCounter); - p_Stats->internalBufferBusy = GET_UINT32(p_Manip->ipReassmParams.p_IpReassCommonTbl->totalInternalBufferBusy); - 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); + ASSERT_COND(p_Manip->reassmParams.p_ReassCommonTbl); + + p_Stats->timeout = + GET_UINT32(p_Manip->reassmParams.p_ReassCommonTbl->totalTimeOutCounter); + p_Stats->rfdPoolBusy = + GET_UINT32(p_Manip->reassmParams.p_ReassCommonTbl->totalRfdPoolBusyCounter); + p_Stats->internalBufferBusy = + GET_UINT32(p_Manip->reassmParams.p_ReassCommonTbl->totalInternalBufferBusy); + p_Stats->externalBufferBusy = + GET_UINT32(p_Manip->reassmParams.p_ReassCommonTbl->totalExternalBufferBusy); + p_Stats->sgFragments = + GET_UINT32(p_Manip->reassmParams.p_ReassCommonTbl->totalSgFragmentCounter); + p_Stats->dmaSemaphoreDepletion = + GET_UINT32(p_Manip->reassmParams.p_ReassCommonTbl->totalDmaSemaphoreDepletionCounter); #if (DPAA_VERSION >= 11) - p_Stats->nonConsistentSp = GET_UINT32(p_Manip->ipReassmParams.p_IpReassCommonTbl->totalNCSPCounter); + p_Stats->nonConsistentSp = + GET_UINT32(p_Manip->reassmParams.p_ReassCommonTbl->totalNCSPCounter); #endif /* (DPAA_VERSION >= 11) */ - if (p_Manip->ipReassmParams.p_Ipv4ReassTbl) + if (p_Manip->reassmParams.ip.p_Ipv4ReassTbl) { - p_Stats->specificHdrStatistics[0].successfullyReassembled = GET_UINT32(p_Manip->ipReassmParams.p_Ipv4ReassTbl->totalSuccessfullyReasmFramesCounter); - p_Stats->specificHdrStatistics[0].validFragments = GET_UINT32(p_Manip->ipReassmParams.p_Ipv4ReassTbl->totalValidFragmentCounter); - p_Stats->specificHdrStatistics[0].processedFragments = GET_UINT32(p_Manip->ipReassmParams.p_Ipv4ReassTbl->totalProcessedFragCounter); - p_Stats->specificHdrStatistics[0].malformedFragments = GET_UINT32(p_Manip->ipReassmParams.p_Ipv4ReassTbl->totalMalformdFragCounter); - p_Stats->specificHdrStatistics[0].autoLearnBusy = GET_UINT32(p_Manip->ipReassmParams.p_Ipv4ReassTbl->totalSetBusyCounter); - p_Stats->specificHdrStatistics[0].discardedFragments = GET_UINT32(p_Manip->ipReassmParams.p_Ipv4ReassTbl->totalDiscardedFragsCounter); - p_Stats->specificHdrStatistics[0].moreThan16Fragments = GET_UINT32(p_Manip->ipReassmParams.p_Ipv4ReassTbl->totalMoreThan16FramesCounter); + p_Stats->specificHdrStatistics[0].successfullyReassembled = + GET_UINT32(p_Manip->reassmParams.ip.p_Ipv4ReassTbl->totalSuccessfullyReasmFramesCounter); + p_Stats->specificHdrStatistics[0].validFragments = + GET_UINT32(p_Manip->reassmParams.ip.p_Ipv4ReassTbl->totalValidFragmentCounter); + p_Stats->specificHdrStatistics[0].processedFragments = + GET_UINT32(p_Manip->reassmParams.ip.p_Ipv4ReassTbl->totalProcessedFragCounter); + p_Stats->specificHdrStatistics[0].malformedFragments = + GET_UINT32(p_Manip->reassmParams.ip.p_Ipv4ReassTbl->totalMalformdFragCounter); + p_Stats->specificHdrStatistics[0].autoLearnBusy = + GET_UINT32(p_Manip->reassmParams.ip.p_Ipv4ReassTbl->totalSetBusyCounter); + p_Stats->specificHdrStatistics[0].discardedFragments = + GET_UINT32(p_Manip->reassmParams.ip.p_Ipv4ReassTbl->totalDiscardedFragsCounter); + p_Stats->specificHdrStatistics[0].moreThan16Fragments = + GET_UINT32(p_Manip->reassmParams.ip.p_Ipv4ReassTbl->totalMoreThan16FramesCounter); } - if (p_Manip->ipReassmParams.p_Ipv6ReassTbl) + if (p_Manip->reassmParams.ip.p_Ipv6ReassTbl) { - p_Stats->specificHdrStatistics[1].successfullyReassembled = GET_UINT32(p_Manip->ipReassmParams.p_Ipv6ReassTbl->totalSuccessfullyReasmFramesCounter); - p_Stats->specificHdrStatistics[1].validFragments = GET_UINT32(p_Manip->ipReassmParams.p_Ipv6ReassTbl->totalValidFragmentCounter); - p_Stats->specificHdrStatistics[1].processedFragments = GET_UINT32(p_Manip->ipReassmParams.p_Ipv6ReassTbl->totalProcessedFragCounter); - p_Stats->specificHdrStatistics[1].malformedFragments = GET_UINT32(p_Manip->ipReassmParams.p_Ipv6ReassTbl->totalMalformdFragCounter); - p_Stats->specificHdrStatistics[1].autoLearnBusy = GET_UINT32(p_Manip->ipReassmParams.p_Ipv6ReassTbl->totalSetBusyCounter); - p_Stats->specificHdrStatistics[1].discardedFragments = GET_UINT32(p_Manip->ipReassmParams.p_Ipv6ReassTbl->totalDiscardedFragsCounter); - p_Stats->specificHdrStatistics[1].moreThan16Fragments = GET_UINT32(p_Manip->ipReassmParams.p_Ipv6ReassTbl->totalMoreThan16FramesCounter); + p_Stats->specificHdrStatistics[1].successfullyReassembled = + GET_UINT32(p_Manip->reassmParams.ip.p_Ipv6ReassTbl->totalSuccessfullyReasmFramesCounter); + p_Stats->specificHdrStatistics[1].validFragments = + GET_UINT32(p_Manip->reassmParams.ip.p_Ipv6ReassTbl->totalValidFragmentCounter); + p_Stats->specificHdrStatistics[1].processedFragments = + GET_UINT32(p_Manip->reassmParams.ip.p_Ipv6ReassTbl->totalProcessedFragCounter); + p_Stats->specificHdrStatistics[1].malformedFragments = + GET_UINT32(p_Manip->reassmParams.ip.p_Ipv6ReassTbl->totalMalformdFragCounter); + p_Stats->specificHdrStatistics[1].autoLearnBusy = + GET_UINT32(p_Manip->reassmParams.ip.p_Ipv6ReassTbl->totalSetBusyCounter); + p_Stats->specificHdrStatistics[1].discardedFragments = + GET_UINT32(p_Manip->reassmParams.ip.p_Ipv6ReassTbl->totalDiscardedFragsCounter); + p_Stats->specificHdrStatistics[1].moreThan16Fragments = + GET_UINT32(p_Manip->reassmParams.ip.p_Ipv6ReassTbl->totalMoreThan16FramesCounter); } return E_OK; } -#ifdef FM_CAPWAP_SUPPORT -static t_Error IndxStats(t_FmPcdStatsParams *p_StatsParams,t_FmPcdManip *p_Manip,t_FmPcd *p_FmPcd) +static t_Error IpFragmentationStats(t_FmPcdManip *p_Manip, + t_FmPcdManipFragIpStats *p_Stats) { - t_AdOfTypeContLookup *p_Ad; - uint32_t tmpReg32 = 0; - - SANITY_CHECK_RETURN_ERROR(p_Manip->h_Ad,E_INVALID_HANDLE); - - UNUSED(p_FmPcd); + t_AdOfTypeContLookup *p_Ad; - p_Ad = (t_AdOfTypeContLookup *)p_Manip->h_Ad; + ASSERT_COND(p_Manip); + ASSERT_COND(p_Stats); + ASSERT_COND(p_Manip->h_Ad); + ASSERT_COND(p_Manip->fragParams.p_Frag); - tmpReg32 = 0; - tmpReg32 |= (uint32_t)HMAN_OC_CAPWAP_INDEXED_STATS; - if (p_StatsParams->type == e_FM_PCD_STATS_PER_FLOWID) - tmpReg32 |= (uint32_t)0x16 << 16; - WRITE_UINT32(p_Ad->pcAndOffsets, tmpReg32); + p_Ad = (t_AdOfTypeContLookup *)p_Manip->h_Ad; - tmpReg32 = 0; - tmpReg32 |= FM_PCD_AD_CONT_LOOKUP_TYPE; - WRITE_UINT32(p_Ad->ccAdBase, tmpReg32); + p_Stats->totalFrames = GET_UINT32(p_Ad->gmask); + p_Stats->fragmentedFrames = GET_UINT32(p_Manip->fragParams.p_Frag->ccAdBase) + & 0x00ffffff; + p_Stats->generatedFragments = + GET_UINT32(p_Manip->fragParams.p_Frag->matchTblPtr); return E_OK; } -static t_Error InsrtHdrByTempl(t_FmPcdManipHdrInsrtParams *p_ManipParams, t_FmPcdManip *p_Manip, t_FmPcd *p_FmPcd) +static t_Error IpFragmentation(t_FmPcdManipFragIpParams *p_ManipParams, + t_FmPcdManip *p_Manip) { - t_FmPcdManipHdrInsrtByTemplateParams *p_InsrtByTemplate = &p_ManipParams->u.byTemplate; - uint8_t tmpReg8 = 0xff; - t_AdOfTypeContLookup *p_Ad; - bool ipModify = FALSE; - uint32_t tmpReg32 = 0, tmpRegNia = 0; - uint16_t tmpReg16 = 0; - t_Error err = E_OK; - uint8_t extraAddedBytes = 0, blockSize = 0, extraAddedBytesAlignedToBlockSize = 0, log2Num = 0; - uint8_t *p_Template = NULL; + uint32_t pcAndOffsetsReg = 0, ccAdBaseReg = 0, gmaskReg = 0; + t_FmPcd *p_FmPcd; +#if (DPAA_VERSION == 10) + t_Error err = E_OK; +#endif /* (DPAA_VERSION == 10) */ - SANITY_CHECK_RETURN_ERROR(p_ManipParams,E_NULL_POINTER); - SANITY_CHECK_RETURN_ERROR(p_Manip,E_NULL_POINTER); - SANITY_CHECK_RETURN_ERROR(p_Manip->h_Ad,E_INVALID_HANDLE); - SANITY_CHECK_RETURN_ERROR(p_FmPcd,E_NULL_POINTER); + SANITY_CHECK_RETURN_ERROR(p_Manip->h_Ad, E_INVALID_HANDLE); + SANITY_CHECK_RETURN_ERROR(p_ManipParams->sizeForFragmentation != 0xFFFF, + E_INVALID_VALUE); - p_Ad = (t_AdOfTypeContLookup *)p_Manip->h_Ad; - if (p_Manip->insrt) - { - if ((!p_InsrtByTemplate->size && p_InsrtByTemplate->modifyOuterIp) || - (!p_InsrtByTemplate->size && p_InsrtByTemplate->modifyOuterVlan)) - RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Inconsistent parameters : asking for header template modifications with no template for insertion (template size)")); + p_FmPcd = p_Manip->h_FmPcd; + /* Allocation of fragmentation Action Descriptor */ + p_Manip->fragParams.p_Frag = (t_AdOfTypeContLookup *)FM_MURAM_AllocMem( + p_FmPcd->h_FmMuram, FM_PCD_CC_AD_ENTRY_SIZE, + FM_PCD_CC_AD_TABLE_ALIGN); + if (!p_Manip->fragParams.p_Frag) + RETURN_ERROR(MAJOR, E_NO_MEMORY, + ("MURAM alloc for Fragmentation table descriptor")); + IOMemSet32(p_Manip->fragParams.p_Frag, 0, FM_PCD_CC_AD_ENTRY_SIZE); - if (p_InsrtByTemplate->size && p_InsrtByTemplate->modifyOuterIp && (p_InsrtByTemplate->size <= p_InsrtByTemplate->modifyOuterIpParams.ipOuterOffset)) - RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Inconsistent parameters : size of template < ipOuterOffset")); + /* Prepare the third Ad register (pcAndOffsets)- OperationCode */ + pcAndOffsetsReg = (uint32_t)HMAN_OC_IP_FRAGMENTATION; - if (p_InsrtByTemplate->size > 128) - RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("Size of header template for insertion can not be more than 128")); + /* Prepare the first Ad register (ccAdBase) - Don't frag action and Action descriptor type*/ + ccAdBaseReg = FM_PCD_AD_CONT_LOOKUP_TYPE; + ccAdBaseReg |= (p_ManipParams->dontFragAction + << FM_PCD_MANIP_IP_FRAG_DF_SHIFT); - if (p_InsrtByTemplate->size) - { - p_Manip->p_Template = (uint8_t *)FM_MURAM_AllocMem(p_FmPcd->h_FmMuram, - p_InsrtByTemplate->size, - FM_PCD_CC_AD_TABLE_ALIGN); - if(!p_Manip->p_Template) - RETURN_ERROR(MAJOR, E_NO_MEMORY, ("Memory allocation in MURAM FAILED")); - tmpReg32 = (uint32_t)(XX_VirtToPhys(p_Manip->p_Template) - (p_FmPcd->physicalMuramBase)); - tmpReg32 |= (uint32_t)p_InsrtByTemplate->size << 24; - *(uint32_t *)&p_Ad->matchTblPtr = tmpReg32; - } + /* Set Scatter/Gather BPid */ + if (p_ManipParams->sgBpidEn) + { + ccAdBaseReg |= FM_PCD_MANIP_IP_FRAG_SG_BDID_EN; + pcAndOffsetsReg |= ((p_ManipParams->sgBpid + << FM_PCD_MANIP_IP_FRAG_SG_BDID_SHIFT) + & FM_PCD_MANIP_IP_FRAG_SG_BDID_MASK); + } - tmpReg32 = 0; + /* Prepare the first Ad register (gmask) - scratch buffer pool id and Pointer to fragment ID */ + gmaskReg = (uint32_t)(XX_VirtToPhys(UINT_TO_PTR(p_FmPcd->ipv6FrameIdAddr)) + - p_FmPcd->physicalMuramBase); +#if (DPAA_VERSION == 10) + gmaskReg |= p_ManipParams->scratchBpid << FM_PCD_MANIP_IP_FRAG_SCRATCH_BPID; +#else + gmaskReg |= (0xFF) << FM_PCD_MANIP_IP_FRAG_SCRATCH_BPID; +#endif /* (DPAA_VERSION == 10) */ - p_Template = (uint8_t *)XX_Malloc(p_InsrtByTemplate->size * sizeof(uint8_t)); + /* Set all Ad registers */ + WRITE_UINT32(p_Manip->fragParams.p_Frag->pcAndOffsets, pcAndOffsetsReg); + WRITE_UINT32(p_Manip->fragParams.p_Frag->ccAdBase, ccAdBaseReg); + WRITE_UINT32(p_Manip->fragParams.p_Frag->gmask, gmaskReg); - if (!p_Template) - RETURN_ERROR(MAJOR, E_NO_MEMORY, ("XX_Malloc allocation FAILED")); + /* Saves user's fragmentation manipulation parameters */ + p_Manip->frag = TRUE; + p_Manip->sizeForFragmentation = p_ManipParams->sizeForFragmentation; - memcpy(p_Template, p_InsrtByTemplate->hdrTemplate, p_InsrtByTemplate->size * sizeof(uint8_t)); +#if (DPAA_VERSION == 10) + p_Manip->fragParams.scratchBpid = p_ManipParams->scratchBpid; + + /* scratch buffer pool initialization */ + if ((err = FmPcdFragHcScratchPoolFill((t_Handle)p_FmPcd, p_ManipParams->scratchBpid)) != E_OK) + { + FM_MURAM_FreeMem(p_FmPcd->h_FmMuram, p_Manip->fragParams.p_Frag); + p_Manip->fragParams.p_Frag = NULL; + RETURN_ERROR(MAJOR, err, NO_MSG); + } +#endif /* (DPAA_VERSION == 10) */ + return E_OK; +} + +static t_Error IPManip(t_FmPcdManip *p_Manip) +{ + t_Error err = E_OK; + t_FmPcd *p_FmPcd; + t_AdOfTypeContLookup *p_Ad; + uint32_t tmpReg32 = 0, tmpRegNia = 0; - if (p_InsrtByTemplate->modifyOuterIp) - { - ipModify = TRUE; + SANITY_CHECK_RETURN_ERROR(p_Manip, E_INVALID_HANDLE); + p_FmPcd = p_Manip->h_FmPcd; + SANITY_CHECK_RETURN_ERROR(p_FmPcd, E_INVALID_HANDLE); - tmpReg8 = (uint8_t)p_Template[p_InsrtByTemplate->modifyOuterIpParams.ipOuterOffset]; + p_Ad = (t_AdOfTypeContLookup *)p_Manip->h_Ad; - if((tmpReg8 & 0xf0) == 0x40) - tmpReg8 = 4; - else if((tmpReg8 & 0xf0) == 0x60) - tmpReg8 = 6; - else - tmpReg8 = 0xff; + tmpReg32 = FM_PCD_MANIP_IP_NO_FRAGMENTATION; + if (p_Manip->frag == TRUE) + { + tmpRegNia = (uint32_t)(XX_VirtToPhys(p_Manip->fragParams.p_Frag) + - (p_FmPcd->physicalMuramBase)); + tmpReg32 = (uint32_t)p_Manip->sizeForFragmentation + << FM_PCD_MANIP_IP_MTU_SHIFT; + } - if (tmpReg8 != 0xff) - { - if(p_InsrtByTemplate->modifyOuterIpParams.dscpEcn & 0xff00) - RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Inconsistent parameters : IPV4 present in header template, dscpEcn has to be only 1 byte")); - if(p_InsrtByTemplate->modifyOuterIpParams.recalculateLength) - { - - if((p_InsrtByTemplate->modifyOuterIpParams.recalculateLengthParams.extraBytesAddedAlignedToBlockSize + p_InsrtByTemplate->modifyOuterIpParams.recalculateLengthParams.extraBytesAddedNotAlignedToBlockSize) > 255) - RETURN_ERROR(MAJOR, E_INVALID_STATE, ("extra Byte added can not be more than 256 bytes")); - extraAddedBytes = (uint8_t) (p_InsrtByTemplate->modifyOuterIpParams.recalculateLengthParams.extraBytesAddedAlignedToBlockSize + p_InsrtByTemplate->modifyOuterIpParams.recalculateLengthParams.extraBytesAddedNotAlignedToBlockSize); - blockSize = p_InsrtByTemplate->modifyOuterIpParams.recalculateLengthParams.blockSize; - extraAddedBytesAlignedToBlockSize = p_InsrtByTemplate->modifyOuterIpParams.recalculateLengthParams.extraBytesAddedAlignedToBlockSize; - /*IP header template - IP totalLength - - (1 byte) extraByteForIp = headerTemplateSize - ipOffset + insertedBytesAfterThisStage , - in the case of SEC insertedBytesAfterThisStage - SEC trailer (21/31) + header(13) - second byte - extraByteForIp = headerTemplate - ipOffset + insertedBytesAfterThisStage*/ - } - if (blockSize) - { - if (!POWER_OF_2(blockSize)) - RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("inputFrmPaddingUpToBlockSize has to be power of 2")); - } + tmpRegNia |= FM_PCD_AD_CONT_LOOKUP_TYPE; + tmpReg32 |= HMAN_OC_IP_MANIP; - } - if (tmpReg8 == 4) - { - if ((IPv4_HDRCHECKSUM_FIELD_OFFSET_FROM_IP + p_InsrtByTemplate->modifyOuterIpParams.ipOuterOffset) > p_InsrtByTemplate->size) - RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Inconsistent parameters : IP present in header template, user asked for IP modifications but ipOffset + ipTotalLengthFieldOffset in header template bigger than template size")); +#if (DPAA_VERSION >= 11) + tmpRegNia |= FM_PCD_MANIP_IP_CNIA; +#endif /* (DPAA_VERSION >= 11) */ + WRITE_UINT32(p_Ad->pcAndOffsets, tmpReg32); + WRITE_UINT32(p_Ad->ccAdBase, tmpRegNia); + WRITE_UINT32(p_Ad->gmask, 0); + /* Total frame counter - MUST be initialized to zero.*/ - p_Template[p_InsrtByTemplate->modifyOuterIpParams.ipOuterOffset + IPv4_DSCECN_FIELD_OFFSET_FROM_IP] = (uint8_t)p_InsrtByTemplate->modifyOuterIpParams.dscpEcn; + return err; +} - if (blockSize) - blockSize -= 1; +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; - if ((p_InsrtByTemplate->size - p_InsrtByTemplate->modifyOuterIpParams.ipOuterOffset + extraAddedBytes) > 255) - RETURN_ERROR(MAJOR, E_INVALID_STATE, ("p_InsrtByTemplate->size - p_InsrtByTemplate->modifyOuterIpParams.ipOuterOffset + extraAddedBytes has to be less than 255")); + 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); - p_Template[p_InsrtByTemplate->modifyOuterIpParams.ipOuterOffset + IPv4_TOTALLENGTH_FIELD_OFFSET_FROM_IP + 1] = blockSize;// IPV6 - in AD instead of SEQ IND - p_Template[p_InsrtByTemplate->modifyOuterIpParams.ipOuterOffset + IPv4_TOTALLENGTH_FIELD_OFFSET_FROM_IP] = (uint8_t)(p_InsrtByTemplate->size - p_InsrtByTemplate->modifyOuterIpParams.ipOuterOffset + extraAddedBytes);// for IPV6 decrement additional 40 bytes of IPV6 heade size + UNUSED(h_FmPcd); + UNUSED(h_Ad); + UNUSED(h_PcdParams); + UNUSED(validate); + UNUSED(p_Manip); - p_Template[p_InsrtByTemplate->modifyOuterIpParams.ipOuterOffset + IPv4_ID_FIELD_OFFSET_FROM_IP] = 0x00; - p_Template[p_InsrtByTemplate->modifyOuterIpParams.ipOuterOffset + IPv4_ID_FIELD_OFFSET_FROM_IP + 1] = extraAddedBytesAlignedToBlockSize; + 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; +} - /*IP header template - relevant only for ipv4 CheckSum = 0*/ - p_Template[p_InsrtByTemplate->modifyOuterIpParams.ipOuterOffset + IPv4_HDRCHECKSUM_FIELD_OFFSET_FROM_IP] = 0x00; - p_Template[p_InsrtByTemplate->modifyOuterIpParams.ipOuterOffset + IPv4_HDRCHECKSUM_FIELD_OFFSET_FROM_IP + 1] = 0x00; +static t_Error IPSecManip(t_FmPcdManipParams *p_ManipParams, + t_FmPcdManip *p_Manip) +{ + t_AdOfTypeContLookup *p_Ad; + t_FmPcdManipSpecialOffloadIPSecParams *p_IPSecParams; + t_Error err = E_OK; + uint32_t tmpReg32 = 0; + SANITY_CHECK_RETURN_ERROR(p_Manip, E_INVALID_HANDLE); + SANITY_CHECK_RETURN_ERROR(p_ManipParams, E_INVALID_HANDLE); - /*UDP checksum has to be 0*/ - if (p_InsrtByTemplate->modifyOuterIpParams.udpPresent) - { - if ((p_InsrtByTemplate->modifyOuterIpParams.udpOffset + UDP_CHECKSUM_FIELD_OFFSET_FROM_UDP + UDP_CHECKSUM_FIELD_SIZE) > p_InsrtByTemplate->size) - RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Inconsistent parameters : UDP present according to user but (UDP offset + UDP header size) < size of header template")); + p_IPSecParams = &p_ManipParams->u.specialOffload.u.ipsec; - p_Template[p_InsrtByTemplate->modifyOuterIpParams.udpOffset + UDP_CHECKSUM_FIELD_OFFSET_FROM_UDP ] = 0x00; - p_Template[p_InsrtByTemplate->modifyOuterIpParams.udpOffset + UDP_CHECKSUM_FIELD_OFFSET_FROM_UDP + 1] = 0x00; + SANITY_CHECK_RETURN_ERROR( + !p_IPSecParams->variableIpHdrLen || p_IPSecParams->decryption, + E_INVALID_VALUE); + SANITY_CHECK_RETURN_ERROR( + !p_IPSecParams->variableIpVersion || !p_IPSecParams->decryption, + E_INVALID_VALUE); + SANITY_CHECK_RETURN_ERROR( + !p_IPSecParams->variableIpVersion || p_IPSecParams->outerIPHdrLen, + E_INVALID_VALUE); - } + p_Ad = (t_AdOfTypeContLookup *)p_Manip->h_Ad; - if (p_InsrtByTemplate->modifyOuterIpParams.ipIdentGenId > 7) - RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("ipIdentGenId has to be one out of 8 sequence number generators (0 - 7) for IP identification field")); + tmpReg32 |= FM_PCD_AD_CONT_LOOKUP_TYPE; + tmpReg32 |= (p_IPSecParams->decryption) ? FM_PCD_MANIP_IPSEC_DEC : 0; + tmpReg32 |= (p_IPSecParams->ecnCopy) ? FM_PCD_MANIP_IPSEC_ECN_EN : 0; + tmpReg32 |= (p_IPSecParams->dscpCopy) ? FM_PCD_MANIP_IPSEC_DSCP_EN : 0; + tmpReg32 |= + (p_IPSecParams->variableIpHdrLen) ? FM_PCD_MANIP_IPSEC_VIPL_EN : 0; + tmpReg32 |= + (p_IPSecParams->variableIpVersion) ? FM_PCD_MANIP_IPSEC_VIPV_EN : 0; + WRITE_UINT32(p_Ad->ccAdBase, tmpReg32); - tmpRegNia |= (uint32_t)p_InsrtByTemplate->modifyOuterIpParams.ipIdentGenId<<24; - } - else if (tmpReg8 == 6) - { - /*TODO - add check for maximum value of blockSize;*/ - if (blockSize) - LOG2(blockSize, log2Num); - tmpRegNia |= (uint32_t)log2Num << 24; + tmpReg32 = HMAN_OC_IPSEC_MANIP; + tmpReg32 |= p_IPSecParams->outerIPHdrLen + << FM_PCD_MANIP_IPSEC_IP_HDR_LEN_SHIFT; + if (p_ManipParams->h_NextManip) + { + WRITE_UINT32( + p_Ad->matchTblPtr, + (uint32_t)(XX_VirtToPhys(((t_FmPcdManip *)p_ManipParams->h_NextManip)->h_Ad)- (((t_FmPcd *)p_Manip->h_FmPcd)->physicalMuramBase)) >> 4); - // for IPV6 decrement additional 40 bytes of IPV6 heade size - because IPV6 header size is not included in payloadLength - p_Template[p_InsrtByTemplate->modifyOuterIpParams.ipOuterOffset + IPv6_PAYLOAD_LENGTH_OFFSET_FROM_IP] = (uint8_t)(p_InsrtByTemplate->size - p_InsrtByTemplate->modifyOuterIpParams.ipOuterOffset + extraAddedBytes - 40); - p_Template[p_InsrtByTemplate->modifyOuterIpParams.ipOuterOffset + IPv6_PAYLOAD_LENGTH_OFFSET_FROM_IP + 1] = extraAddedBytesAlignedToBlockSize; - if (p_InsrtByTemplate->modifyOuterIpParams.udpPresent) - { - if ((p_InsrtByTemplate->modifyOuterIpParams.udpOffset + UDP_CHECKSUM_FIELD_OFFSET_FROM_UDP + UDP_CHECKSUM_FIELD_SIZE) > p_InsrtByTemplate->size) - RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Inconsistent parameters : UDP present according to user but (UDP offset + UDP header size) < size of header template")); - if (p_Template[p_InsrtByTemplate->modifyOuterIpParams.ipOuterOffset + IPv6_NEXT_HEADER_OFFSET_FROM_IP] != 0x88) - RETURN_ERROR(MAJOR, E_INVALID_STATE, ("OUr suppport is only IPv6/UDPLite")); - p_Template[p_InsrtByTemplate->modifyOuterIpParams.udpOffset + UDP_LENGTH_FIELD_OFFSET_FROM_UDP] = 0x00; - p_Template[p_InsrtByTemplate->modifyOuterIpParams.udpOffset + UDP_LENGTH_FIELD_OFFSET_FROM_UDP + 1] = 0x08; - p_Template[p_InsrtByTemplate->modifyOuterIpParams.udpOffset + UDP_CHECKSUM_FIELD_OFFSET_FROM_UDP] = 0x00; - p_Template[p_InsrtByTemplate->modifyOuterIpParams.udpOffset + UDP_CHECKSUM_FIELD_OFFSET_FROM_UDP + 1] = 0x00; - } - } - else - RETURN_ERROR(MAJOR, E_INVALID_STATE, ("IP version supported only IPV4")); - } - - tmpReg32 = tmpReg16 = tmpReg8 = 0; - /*TODO - check it*/ - if (p_InsrtByTemplate->modifyOuterVlan) - { - if (p_InsrtByTemplate->modifyOuterVlanParams.vpri & ~0x07) - RETURN_ERROR(MAJOR, E_INVALID_STATE,("Inconsistent parameters : user asked for VLAN modifications but VPRI more than 3 bits")); - - memcpy(&tmpReg16, &p_Template[VLAN_TAG_FIELD_OFFSET_FROM_ETH], 2*(sizeof(uint8_t))); - if ((tmpReg16 != 0x9100) && (tmpReg16!= 0x9200) && (tmpReg16 != 0x8100)) - RETURN_ERROR(MAJOR, E_INVALID_STATE,("Inconsistent parameters : user asked for VLAN modifications but Tag Protocol identifier is not VLAN ")); - - memcpy(&tmpReg8, &p_Template[14],1*(sizeof(uint8_t))); - tmpReg8 &= 0x1f; - tmpReg8 |= (uint8_t)(p_InsrtByTemplate->modifyOuterVlanParams.vpri << 5); - - p_Template[14] = tmpReg8; - } + tmpReg32 |= FM_PCD_MANIP_IPSEC_NADEN; + }WRITE_UINT32(p_Ad->pcAndOffsets, tmpReg32); - Mem2IOCpy32(p_Manip->p_Template, p_Template, p_InsrtByTemplate->size); + return err; +} - XX_Free(p_Template); - } +static t_Error SetCapwapReassmManip(t_FmPcdManip *p_Manip) +{ + t_FmPcd *p_FmPcd = (t_FmPcd *)p_Manip->h_FmPcd; - tmpReg32 = 0; - if (p_Manip->h_Frag) + /* Allocation if CAPWAP Action descriptor */ + p_Manip->reassmParams.capwap.h_Ad = (t_Handle)XX_MallocSmart( + FM_PCD_CC_AD_ENTRY_SIZE, p_Manip->reassmParams.dataMemId, + FM_PCD_CC_AD_TABLE_ALIGN); + if (!p_Manip->reassmParams.capwap.h_Ad) { - tmpRegNia |= (uint32_t)(XX_VirtToPhys(p_Manip->h_Frag) - (p_FmPcd->physicalMuramBase)); - tmpReg32 |= (uint32_t)p_Manip->sizeForFragmentation << 16; + ReleaseManipHandler(p_Manip, p_FmPcd); + RETURN_ERROR(MAJOR, E_NO_MEMORY, + ("Allocation of CAPWAP table descriptor")); } - else - tmpReg32 = 0xffff0000; - if (ipModify) - tmpReg32 |= (uint32_t)p_InsrtByTemplate->modifyOuterIpParams.ipOuterOffset << 8; - else - tmpReg32 |= (uint32_t)0x0000ff00; + memset(p_Manip->reassmParams.capwap.h_Ad, 0, FM_PCD_CC_AD_ENTRY_SIZE); - tmpReg32 |= (uint32_t)HMAN_OC_INSRT_HDR_BY_TEMPL_N_OR_FRAG_AFTER; - *(uint32_t *)&p_Ad->pcAndOffsets = tmpReg32; + /* Fill reassembly manipulation parameter in the Reassembly Action Descriptor */ + return FillReassmManipParams(p_Manip, HEADER_TYPE_CAPWAP); +} - tmpRegNia |= FM_PCD_AD_CONT_LOOKUP_TYPE; - *(uint32_t *)&p_Ad->ccAdBase = tmpRegNia; +static void setCapwapReassmSchemeParams(t_FmPcd* p_FmPcd, + t_FmPcdKgSchemeParams *p_Scheme, + t_Handle h_CcTree, uint8_t groupId) +{ + uint32_t j; + uint8_t res; - return err; + /* Configures scheme's network environment parameters */ + p_Scheme->netEnvParams.numOfDistinctionUnits = 1; + res = FmPcdNetEnvGetUnitId( + p_FmPcd, FmPcdGetNetEnvId(p_Scheme->netEnvParams.h_NetEnv), + HEADER_TYPE_USER_DEFINED_SHIM2, FALSE, 0); + ASSERT_COND(res != FM_PCD_MAX_NUM_OF_DISTINCTION_UNITS); + p_Scheme->netEnvParams.unitIds[0] = res; + + /* Configures scheme's next engine parameters*/ + p_Scheme->nextEngine = e_FM_PCD_CC; + p_Scheme->kgNextEngineParams.cc.h_CcTree = h_CcTree; + p_Scheme->kgNextEngineParams.cc.grpId = groupId; + p_Scheme->useHash = TRUE; + + /* Configures scheme's key*/ + p_Scheme->keyExtractAndHashParams.numOfUsedExtracts = 2; + p_Scheme->keyExtractAndHashParams.extractArray[0].type = + e_FM_PCD_EXTRACT_NON_HDR; + p_Scheme->keyExtractAndHashParams.extractArray[0].extractNonHdr.src = + e_FM_PCD_EXTRACT_FROM_PARSE_RESULT; + p_Scheme->keyExtractAndHashParams.extractArray[0].extractNonHdr.action = + e_FM_PCD_ACTION_NONE; + p_Scheme->keyExtractAndHashParams.extractArray[0].extractNonHdr.offset = 20; + p_Scheme->keyExtractAndHashParams.extractArray[0].extractNonHdr.size = 4; + p_Scheme->keyExtractAndHashParams.extractArray[1].type = + e_FM_PCD_EXTRACT_NON_HDR; + p_Scheme->keyExtractAndHashParams.extractArray[1].extractNonHdr.src = + e_FM_PCD_EXTRACT_FROM_DFLT_VALUE; + p_Scheme->keyExtractAndHashParams.extractArray[1].extractNonHdr.action = + e_FM_PCD_ACTION_NONE; + p_Scheme->keyExtractAndHashParams.extractArray[1].extractNonHdr.offset = 0; + p_Scheme->keyExtractAndHashParams.extractArray[1].extractNonHdr.size = 1; + + p_Scheme->keyExtractAndHashParams.privateDflt0 = 0x0; + p_Scheme->keyExtractAndHashParams.privateDflt1 = 0x0; + p_Scheme->keyExtractAndHashParams.numOfUsedDflts = 1; + p_Scheme->keyExtractAndHashParams.dflts[0].type = e_FM_PCD_KG_GENERIC_NOT_FROM_DATA; + p_Scheme->keyExtractAndHashParams.dflts[0].dfltSelect = e_FM_PCD_KG_DFLT_PRIVATE_0; } -#endif /* FM_CAPWAP_SUPPORT */ -static t_Error IpFragmentationStats(t_FmPcdManip *p_Manip, t_FmPcdManipFragIpStats *p_Stats) +#if (DPAA_VERSION >= 11) +static t_Error CapwapReassemblyStats(t_FmPcdManip *p_Manip, + t_FmPcdManipReassemCapwapStats *p_Stats) { - t_AdOfTypeContLookup *p_Ad; - ASSERT_COND(p_Manip); ASSERT_COND(p_Stats); - ASSERT_COND(p_Manip->h_Ad); - ASSERT_COND(p_Manip->ipFragParams.p_Frag); + ASSERT_COND(p_Manip->reassmParams.p_ReassCommonTbl); + + p_Stats->timeout = + GET_UINT32(p_Manip->reassmParams.p_ReassCommonTbl->totalTimeOutCounter); + p_Stats->rfdPoolBusy = + GET_UINT32(p_Manip->reassmParams.p_ReassCommonTbl->totalRfdPoolBusyCounter); + p_Stats->internalBufferBusy = + GET_UINT32(p_Manip->reassmParams.p_ReassCommonTbl->totalInternalBufferBusy); + p_Stats->externalBufferBusy = + GET_UINT32(p_Manip->reassmParams.p_ReassCommonTbl->totalExternalBufferBusy); + p_Stats->sgFragments = + GET_UINT32(p_Manip->reassmParams.p_ReassCommonTbl->totalSgFragmentCounter); + p_Stats->dmaSemaphoreDepletion = + GET_UINT32(p_Manip->reassmParams.p_ReassCommonTbl->totalDmaSemaphoreDepletionCounter); + p_Stats->exceedMaxReassemblyFrameLen = + GET_UINT32(p_Manip->reassmParams.p_ReassCommonTbl->totalNCSPCounter); + + p_Stats->successfullyReassembled = + GET_UINT32(p_Manip->reassmParams.capwap.p_ReassTbl->totalSuccessfullyReasmFramesCounter); + p_Stats->validFragments = + GET_UINT32(p_Manip->reassmParams.capwap.p_ReassTbl->totalValidFragmentCounter); + p_Stats->processedFragments = + GET_UINT32(p_Manip->reassmParams.capwap.p_ReassTbl->totalProcessedFragCounter); + p_Stats->malformedFragments = + GET_UINT32(p_Manip->reassmParams.capwap.p_ReassTbl->totalMalformdFragCounter); + p_Stats->autoLearnBusy = + GET_UINT32(p_Manip->reassmParams.capwap.p_ReassTbl->totalSetBusyCounter); + p_Stats->discardedFragments = + GET_UINT32(p_Manip->reassmParams.capwap.p_ReassTbl->totalDiscardedFragsCounter); + p_Stats->moreThan16Fragments = + GET_UINT32(p_Manip->reassmParams.capwap.p_ReassTbl->totalMoreThan16FramesCounter); - p_Ad = (t_AdOfTypeContLookup *)p_Manip->h_Ad; + return E_OK; +} - p_Stats->totalFrames = GET_UINT32(p_Ad->gmask); - p_Stats->fragmentedFrames = GET_UINT32(p_Manip->ipFragParams.p_Frag->ccAdBase) & 0x00ffffff; - p_Stats->generatedFragments = GET_UINT32(p_Manip->ipFragParams.p_Frag->matchTblPtr); +static t_Error CapwapReassembly(t_FmPcdManipReassemParams *p_ManipReassmParams, + t_FmPcdManip *p_Manip) +{ + uint32_t maxSetNumber = 10000; + t_FmPcdManipReassemCapwapParams reassmManipParams = + p_ManipReassmParams->u.capwapReassem; + t_Error res; + + SANITY_CHECK_RETURN_ERROR(p_Manip->h_FmPcd, E_INVALID_HANDLE); + SANITY_CHECK_RETURN_ERROR(((t_FmPcd *)p_Manip->h_FmPcd)->h_Hc, + E_INVALID_HANDLE); + + /* Check validation of user's parameter.*/ + if ((reassmManipParams.timeoutThresholdForReassmProcess < 1000) + || (reassmManipParams.timeoutThresholdForReassmProcess > 8000000)) + RETURN_ERROR( + MAJOR, E_INVALID_VALUE, + ("timeoutThresholdForReassmProcess should be 1msec - 8sec")); + /* It is recommended that the total number of entries in this table (number of sets * number of ways) + will be twice the number of frames that are expected to be reassembled simultaneously.*/ + if (reassmManipParams.maxNumFramesInProcess + > (reassmManipParams.maxNumFramesInProcess * maxSetNumber / 2)) + RETURN_ERROR( + MAJOR, + E_INVALID_VALUE, + ("maxNumFramesInProcess has to be less than (maximun set number * number of ways / 2)")); + + /* Saves user's reassembly manipulation parameters */ + p_Manip->reassmParams.capwap.relativeSchemeId = + reassmManipParams.relativeSchemeId; + p_Manip->reassmParams.capwap.numOfFramesPerHashEntry = + reassmManipParams.numOfFramesPerHashEntry; + p_Manip->reassmParams.capwap.maxRessembledsSize = + reassmManipParams.maxReassembledFrameLength; + p_Manip->reassmParams.maxNumFramesInProcess = + reassmManipParams.maxNumFramesInProcess; + p_Manip->reassmParams.timeOutMode = reassmManipParams.timeOutMode; + p_Manip->reassmParams.fqidForTimeOutFrames = + reassmManipParams.fqidForTimeOutFrames; + p_Manip->reassmParams.timeoutThresholdForReassmProcess = + reassmManipParams.timeoutThresholdForReassmProcess; + p_Manip->reassmParams.dataMemId = reassmManipParams.dataMemId; + p_Manip->reassmParams.dataLiodnOffset = reassmManipParams.dataLiodnOffset; + + /* Creates and initializes the Reassembly common parameter table */ + CreateReassCommonTable(p_Manip); + + res = SetCapwapReassmManip(p_Manip); + if (res != E_OK) + return res; return E_OK; } -static t_Error IpFragmentation(t_FmPcdManipFragIpParams *p_ManipParams, t_FmPcdManip *p_Manip) +static t_Error CapwapFragmentation(t_FmPcdManipFragCapwapParams *p_ManipParams, + t_FmPcdManip *p_Manip) { - uint32_t pcAndOffsetsReg = 0, ccAdBaseReg = 0, gmaskReg = 0; - t_FmPcd *p_FmPcd; -#if (DPAA_VERSION == 10) - t_Error err = E_OK; -#endif /* (DPAA_VERSION == 10) */ - - SANITY_CHECK_RETURN_ERROR(p_Manip->h_Ad,E_INVALID_HANDLE); - SANITY_CHECK_RETURN_ERROR(p_ManipParams->sizeForFragmentation != 0xFFFF, E_INVALID_VALUE); + t_FmPcd *p_FmPcd; + t_AdOfTypeContLookup *p_Ad; + uint32_t pcAndOffsetsReg = 0, ccAdBaseReg = 0, gmaskReg = 0; + uint32_t tmpReg32 = 0, tmpRegNia = 0; + SANITY_CHECK_RETURN_ERROR(p_Manip->h_Ad, E_INVALID_HANDLE); + SANITY_CHECK_RETURN_ERROR(p_ManipParams->sizeForFragmentation != 0xFFFF, + E_INVALID_VALUE); p_FmPcd = p_Manip->h_FmPcd; + SANITY_CHECK_RETURN_ERROR(p_FmPcd, E_INVALID_HANDLE); + /* Allocation of fragmentation Action Descriptor */ - p_Manip->ipFragParams.p_Frag = (t_AdOfTypeContLookup *)FM_MURAM_AllocMem(p_FmPcd->h_FmMuram, - FM_PCD_CC_AD_ENTRY_SIZE, - FM_PCD_CC_AD_TABLE_ALIGN); - if (!p_Manip->ipFragParams.p_Frag) - RETURN_ERROR(MAJOR, E_NO_MEMORY, ("MURAM alloc for Fragmentation table descriptor")); - IOMemSet32( p_Manip->ipFragParams.p_Frag, 0, FM_PCD_CC_AD_ENTRY_SIZE); + p_Manip->fragParams.p_Frag = (t_AdOfTypeContLookup *)FM_MURAM_AllocMem( + p_FmPcd->h_FmMuram, FM_PCD_CC_AD_ENTRY_SIZE, + FM_PCD_CC_AD_TABLE_ALIGN); + if (!p_Manip->fragParams.p_Frag) + RETURN_ERROR(MAJOR, E_NO_MEMORY, + ("MURAM alloc for Fragmentation table descriptor")); + IOMemSet32(p_Manip->fragParams.p_Frag, 0, FM_PCD_CC_AD_ENTRY_SIZE); /* Prepare the third Ad register (pcAndOffsets)- OperationCode */ - pcAndOffsetsReg = (uint32_t)HMAN_OC_IP_FRAGMENTATION; + pcAndOffsetsReg = (uint32_t)HMAN_OC_CAPWAP_FRAGMENTATION; /* Prepare the first Ad register (ccAdBase) - Don't frag action and Action descriptor type*/ ccAdBaseReg = FM_PCD_AD_CONT_LOOKUP_TYPE; - ccAdBaseReg |= (p_ManipParams->dontFragAction << FM_PCD_MANIP_IP_FRAG_DF_SHIFT); - + ccAdBaseReg |= + (p_ManipParams->compressModeEn) ? FM_PCD_MANIP_CAPWAP_FRAG_COMPRESS_EN : + 0; /* Set Scatter/Gather BPid */ if (p_ManipParams->sgBpidEn) { - ccAdBaseReg |= FM_PCD_MANIP_IP_FRAG_SG_BDID_EN; - pcAndOffsetsReg |= ((p_ManipParams->sgBpid << FM_PCD_MANIP_IP_FRAG_SG_BDID_SHIFT) & FM_PCD_MANIP_IP_FRAG_SG_BDID_MASK); + ccAdBaseReg |= FM_PCD_MANIP_CAPWAP_FRAG_SG_BDID_EN; + pcAndOffsetsReg |= ((p_ManipParams->sgBpid + << FM_PCD_MANIP_CAPWAP_FRAG_SG_BDID_SHIFT) + & FM_PCD_MANIP_CAPWAP_FRAG_SG_BDID_MASK); } /* Prepare the first Ad register (gmask) - scratch buffer pool id and Pointer to fragment ID */ - gmaskReg = (uint32_t)(XX_VirtToPhys(UINT_TO_PTR(p_FmPcd->ipv6FrameIdAddr)) - p_FmPcd->physicalMuramBase); -#if (DPAA_VERSION == 10) - gmaskReg |= p_ManipParams->scratchBpid << FM_PCD_MANIP_IP_FRAG_SCRATCH_BPID; -#else + gmaskReg = (uint32_t)(XX_VirtToPhys(UINT_TO_PTR(p_FmPcd->capwapFrameIdAddr)) + - p_FmPcd->physicalMuramBase); gmaskReg |= (0xFF) << FM_PCD_MANIP_IP_FRAG_SCRATCH_BPID; -#endif /* (DPAA_VERSION == 10) */ /* Set all Ad registers */ - WRITE_UINT32(p_Manip->ipFragParams.p_Frag->pcAndOffsets, pcAndOffsetsReg); - WRITE_UINT32(p_Manip->ipFragParams.p_Frag->ccAdBase, ccAdBaseReg); - WRITE_UINT32(p_Manip->ipFragParams.p_Frag->gmask, gmaskReg); + WRITE_UINT32(p_Manip->fragParams.p_Frag->pcAndOffsets, pcAndOffsetsReg); + WRITE_UINT32(p_Manip->fragParams.p_Frag->ccAdBase, ccAdBaseReg); + WRITE_UINT32(p_Manip->fragParams.p_Frag->gmask, gmaskReg); /* Saves user's fragmentation manipulation parameters */ p_Manip->frag = TRUE; p_Manip->sizeForFragmentation = p_ManipParams->sizeForFragmentation; -#if (DPAA_VERSION == 10) - p_Manip->ipFragParams.scratchBpid = p_ManipParams->scratchBpid; - - /* scratch buffer pool initialization */ - if ((err = FmPcdFragHcScratchPoolFill((t_Handle)p_FmPcd, p_ManipParams->scratchBpid)) != E_OK) - { - FM_MURAM_FreeMem(p_FmPcd->h_FmMuram, p_Manip->ipFragParams.p_Frag); - p_Manip->ipFragParams.p_Frag = NULL; - RETURN_ERROR(MAJOR, err, NO_MSG); - } -#endif /* (DPAA_VERSION == 10) */ - - return E_OK; -} - -static t_Error IPManip(t_FmPcdManip *p_Manip) -{ - t_Error err = E_OK; - t_FmPcd *p_FmPcd; - t_AdOfTypeContLookup *p_Ad; - uint32_t tmpReg32 = 0, tmpRegNia = 0; - - SANITY_CHECK_RETURN_ERROR(p_Manip,E_INVALID_HANDLE); - p_FmPcd = p_Manip->h_FmPcd; - SANITY_CHECK_RETURN_ERROR(p_FmPcd,E_INVALID_HANDLE); - p_Ad = (t_AdOfTypeContLookup *)p_Manip->h_Ad; - tmpReg32 = FM_PCD_MANIP_IP_NO_FRAGMENTATION; - if (p_Manip->frag == TRUE) - { - tmpRegNia = (uint32_t)(XX_VirtToPhys(p_Manip->ipFragParams.p_Frag) - (p_FmPcd->physicalMuramBase)); - tmpReg32 = (uint32_t)p_Manip->sizeForFragmentation << FM_PCD_MANIP_IP_MTU_SHIFT; - } + tmpRegNia = (uint32_t)(XX_VirtToPhys(p_Manip->fragParams.p_Frag) + - (p_FmPcd->physicalMuramBase)); + tmpReg32 = (uint32_t)p_Manip->sizeForFragmentation + << FM_PCD_MANIP_CAPWAP_FRAG_CHECK_MTU_SHIFT; tmpRegNia |= FM_PCD_AD_CONT_LOOKUP_TYPE; - tmpReg32 |= HMAN_OC_IP_MANIP; + tmpReg32 |= HMAN_OC_CAPWAP_FRAG_CHECK; -#if (DPAA_VERSION >= 11) - tmpRegNia |= FM_PCD_MANIP_IP_CNIA; -#endif /* (DPAA_VERSION >= 11) */ + tmpRegNia |= FM_PCD_MANIP_CAPWAP_FRAG_CHECK_CNIA; WRITE_UINT32(p_Ad->pcAndOffsets, tmpReg32); WRITE_UINT32(p_Ad->ccAdBase, tmpRegNia); - WRITE_UINT32(p_Ad->gmask, 0); /* Total frame counter - MUST be initialized to zero.*/ + WRITE_UINT32(p_Ad->gmask, 0); + /* Total frame counter - MUST be initialized to zero.*/ - return err; + return E_OK; } -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) +static t_Error UpdateInitCapwapFrag(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; + 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((p_Manip->opcode == HMAN_OC_CAPWAP_FRAGMENTATION), + E_INVALID_STATE); SANITY_CHECK_RETURN_ERROR(h_FmPcd, E_INVALID_HANDLE); SANITY_CHECK_RETURN_ERROR(h_FmPort, E_INVALID_HANDLE); @@ -3181,86 +4268,59 @@ static t_Error UpdateInitIpFrag(t_Handle h_FmPcd, 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) +static t_Error CapwapManip(t_FmPcdManipParams *p_ManipParams, + t_FmPcdManip *p_Manip) { - t_AdOfTypeContLookup *p_Ad; - t_FmPcdManipSpecialOffloadIPSecParams *p_IPSecParams; - t_Error err = E_OK; - uint32_t tmpReg32 = 0; - - SANITY_CHECK_RETURN_ERROR(p_Manip,E_INVALID_HANDLE); - SANITY_CHECK_RETURN_ERROR(p_ManipParams,E_INVALID_HANDLE); + t_AdOfTypeContLookup *p_Ad; + t_FmPcdManipSpecialOffloadCapwapParams *p_Params; + t_Error err = E_OK; + uint32_t tmpReg32 = 0; - p_IPSecParams = &p_ManipParams->u.specialOffload.u.ipsec; + SANITY_CHECK_RETURN_ERROR(p_Manip, E_INVALID_HANDLE); + SANITY_CHECK_RETURN_ERROR(p_ManipParams, E_INVALID_HANDLE); - SANITY_CHECK_RETURN_ERROR(!p_IPSecParams->variableIpHdrLen || - p_IPSecParams->decryption, E_INVALID_VALUE); - SANITY_CHECK_RETURN_ERROR(!p_IPSecParams->variableIpVersion || - !p_IPSecParams->decryption, E_INVALID_VALUE); - SANITY_CHECK_RETURN_ERROR(!p_IPSecParams->variableIpVersion || - p_IPSecParams->outerIPHdrLen, E_INVALID_VALUE); + p_Params = &p_ManipParams->u.specialOffload.u.capwap; p_Ad = (t_AdOfTypeContLookup *)p_Manip->h_Ad; - tmpReg32 |= FM_PCD_AD_CONT_LOOKUP_TYPE; - tmpReg32 |= (p_IPSecParams->decryption)?FM_PCD_MANIP_IPSEC_DEC:0; - tmpReg32 |= (p_IPSecParams->ecnCopy)?FM_PCD_MANIP_IPSEC_ECN_EN:0; - tmpReg32 |= (p_IPSecParams->dscpCopy)?FM_PCD_MANIP_IPSEC_DSCP_EN:0; - tmpReg32 |= (p_IPSecParams->variableIpHdrLen)?FM_PCD_MANIP_IPSEC_VIPL_EN:0; - tmpReg32 |= (p_IPSecParams->variableIpVersion)?FM_PCD_MANIP_IPSEC_VIPV_EN:0; + tmpReg32 |= (p_Params->dtls) ? FM_PCD_MANIP_CAPWAP_DTLS : 0; + /* TODO - add 'qosSrc' */ WRITE_UINT32(p_Ad->ccAdBase, tmpReg32); - tmpReg32 = HMAN_OC_IPSEC_MANIP; - tmpReg32 |= p_IPSecParams->outerIPHdrLen << FM_PCD_MANIP_IPSEC_IP_HDR_LEN_SHIFT; + tmpReg32 = HMAN_OC_CAPWAP_MANIP; if (p_ManipParams->h_NextManip) { - WRITE_UINT32(p_Ad->matchTblPtr, - (uint32_t)(XX_VirtToPhys(((t_FmPcdManip *)p_ManipParams->h_NextManip)->h_Ad)- - (((t_FmPcd *)p_Manip->h_FmPcd)->physicalMuramBase)) >> 4); + WRITE_UINT32( + p_Ad->matchTblPtr, + (uint32_t)(XX_VirtToPhys(((t_FmPcdManip *)p_ManipParams->h_NextManip)->h_Ad)- (((t_FmPcd *)p_Manip->h_FmPcd)->physicalMuramBase)) >> 4); - tmpReg32 |= FM_PCD_MANIP_IPSEC_NADEN; + tmpReg32 |= FM_PCD_MANIP_CAPWAP_NADEN; } + WRITE_UINT32(p_Ad->pcAndOffsets, tmpReg32); return err; } +#endif /* (DPAA_VERSION >= 11) */ -#ifdef FM_CAPWAP_SUPPORT -static t_Error CheckStatsParamsAndSetType(t_FmPcdManip *p_Manip, t_FmPcdStatsParams *p_StatsParams) -{ - - switch (p_StatsParams->type) - { - case (e_FM_PCD_STATS_PER_FLOWID): - p_Manip->opcode = HMAN_OC_CAPWAP_INDEXED_STATS; - p_Manip->muramAllocate = TRUE; - break; - default: - RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Unsupported statistics type")); - } - - return E_OK; -} -#endif /* FM_CAPWAP_SUPPORT */ - -static t_Handle ManipOrStatsSetNode(t_Handle h_FmPcd, t_Handle *p_Params, bool stats) +static t_Handle ManipOrStatsSetNode(t_Handle h_FmPcd, t_Handle *p_Params, + bool stats) { - t_FmPcdManip *p_Manip; - t_Error err; - t_FmPcd *p_FmPcd = (t_FmPcd *)h_FmPcd; + t_FmPcdManip *p_Manip; + t_Error err; + t_FmPcd *p_FmPcd = (t_FmPcd *)h_FmPcd; p_Manip = (t_FmPcdManip*)XX_Malloc(sizeof(t_FmPcdManip)); if (!p_Manip) @@ -3271,20 +4331,22 @@ static t_Handle ManipOrStatsSetNode(t_Handle h_FmPcd, t_Handle *p_Params, bool s memset(p_Manip, 0, sizeof(t_FmPcdManip)); p_Manip->type = ((t_FmPcdManipParams *)p_Params)->type; - memcpy((uint8_t*)&p_Manip->manipParams, p_Params, sizeof(p_Manip->manipParams)); + memcpy((uint8_t*)&p_Manip->manipParams, p_Params, + sizeof(p_Manip->manipParams)); if (!stats) - err = CheckManipParamsAndSetType(p_Manip, (t_FmPcdManipParams *)p_Params); -#ifdef FM_CAPWAP_SUPPORT + err = CheckManipParamsAndSetType(p_Manip, + (t_FmPcdManipParams *)p_Params); +#if (defined(FM_CAPWAP_SUPPORT) && (DPAA_VERSION == 10)) else - err = CheckStatsParamsAndSetType(p_Manip, (t_FmPcdStatsParams *)p_Params); -#else + 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!")); return NULL; } -#endif /* FM_CAPWAP_SUPPORT */ +#endif /* (defined(FM_CAPWAP_SUPPORT) && (DPAA_VERSION == 10)) */ if (err) { REPORT_ERROR(MAJOR, E_INVALID_VALUE, ("INVALID HEADER MANIPULATION TYPE")); @@ -3293,37 +4355,38 @@ static t_Handle ManipOrStatsSetNode(t_Handle h_FmPcd, t_Handle *p_Params, bool s return NULL; } - if (p_Manip->opcode != HMAN_OC_IP_REASSEMBLY) + if ((p_Manip->opcode != HMAN_OC_IP_REASSEMBLY) && (p_Manip->opcode != HMAN_OC_CAPWAP_REASSEMBLY)) { - /* In Case of IP reassembly manipulation the IPv4/IPv6 reassembly action descriptor will - be defines later on */ + /* In Case of reassembly manipulation the reassembly action descriptor will + be defines later on */ if (p_Manip->muramAllocate) { - p_Manip->h_Ad = (t_Handle)FM_MURAM_AllocMem(p_FmPcd->h_FmMuram, - FM_PCD_CC_AD_ENTRY_SIZE, - FM_PCD_CC_AD_TABLE_ALIGN); - if (!p_Manip->h_Ad) - { + p_Manip->h_Ad = (t_Handle)FM_MURAM_AllocMem( + p_FmPcd->h_FmMuram, FM_PCD_CC_AD_ENTRY_SIZE, + FM_PCD_CC_AD_TABLE_ALIGN); + if (!p_Manip->h_Ad) + { REPORT_ERROR(MAJOR, E_NO_MEMORY, ("MURAM alloc for Manipulation action descriptor")); ReleaseManipHandler(p_Manip, p_FmPcd); XX_Free(p_Manip); return NULL; - } + } - IOMemSet32(p_Manip->h_Ad, 0, FM_PCD_CC_AD_ENTRY_SIZE); + IOMemSet32(p_Manip->h_Ad, 0, FM_PCD_CC_AD_ENTRY_SIZE); } else { - p_Manip->h_Ad = (t_Handle)XX_Malloc(FM_PCD_CC_AD_ENTRY_SIZE * sizeof(uint8_t)); - if (!p_Manip->h_Ad) - { + p_Manip->h_Ad = (t_Handle)XX_Malloc( + FM_PCD_CC_AD_ENTRY_SIZE * sizeof(uint8_t)); + if (!p_Manip->h_Ad) + { REPORT_ERROR(MAJOR, E_NO_MEMORY, ("Allocation of Manipulation action descriptor")); ReleaseManipHandler(p_Manip, p_FmPcd); XX_Free(p_Manip); return NULL; - } + } - memset(p_Manip->h_Ad, 0, FM_PCD_CC_AD_ENTRY_SIZE * sizeof(uint8_t)); + memset(p_Manip->h_Ad, 0, FM_PCD_CC_AD_ENTRY_SIZE * sizeof(uint8_t)); } } @@ -3332,29 +4395,32 @@ static t_Handle ManipOrStatsSetNode(t_Handle h_FmPcd, t_Handle *p_Params, bool s return p_Manip; } -static void UpdateAdPtrOfNodesWhichPointsOnCrntMdfManip(t_FmPcdManip *p_CrntMdfManip, - t_List *h_NodesLst) +static void UpdateAdPtrOfNodesWhichPointsOnCrntMdfManip( + t_FmPcdManip *p_CrntMdfManip, t_List *h_NodesLst) { - t_CcNodeInformation *p_CcNodeInformation; - t_FmPcdCcNode *p_NodePtrOnCurrentMdfManip = NULL; - t_List *p_Pos; - int i = 0; - t_Handle p_AdTablePtOnCrntCurrentMdfNode/*, p_AdTableNewModified*/; - t_CcNodeInformation ccNodeInfo; + t_CcNodeInformation *p_CcNodeInformation; + t_FmPcdCcNode *p_NodePtrOnCurrentMdfManip = NULL; + t_List *p_Pos; + int i = 0; + t_Handle p_AdTablePtOnCrntCurrentMdfNode/*, p_AdTableNewModified*/; + t_CcNodeInformation ccNodeInfo; LIST_FOR_EACH(p_Pos, &p_CrntMdfManip->nodesLst) { p_CcNodeInformation = CC_NODE_F_OBJECT(p_Pos); - p_NodePtrOnCurrentMdfManip = (t_FmPcdCcNode *)p_CcNodeInformation->h_CcNode; + p_NodePtrOnCurrentMdfManip = + (t_FmPcdCcNode *)p_CcNodeInformation->h_CcNode; ASSERT_COND(p_NodePtrOnCurrentMdfManip); /* Search in the previous node which exact index points on this current modified node for getting AD */ for (i = 0; i < p_NodePtrOnCurrentMdfManip->numOfKeys + 1; i++) { - if (p_NodePtrOnCurrentMdfManip->keyAndNextEngineParams[i].nextEngineParams.nextEngine == e_FM_PCD_CC) + if (p_NodePtrOnCurrentMdfManip->keyAndNextEngineParams[i].nextEngineParams.nextEngine + == e_FM_PCD_CC) { - if (p_NodePtrOnCurrentMdfManip->keyAndNextEngineParams[i].nextEngineParams.h_Manip == (t_Handle)p_CrntMdfManip) + if (p_NodePtrOnCurrentMdfManip->keyAndNextEngineParams[i].nextEngineParams.h_Manip + == (t_Handle)p_CrntMdfManip) { if (p_NodePtrOnCurrentMdfManip->keyAndNextEngineParams[i].p_StatsObj) p_AdTablePtOnCrntCurrentMdfNode = @@ -3374,36 +4440,35 @@ static void UpdateAdPtrOfNodesWhichPointsOnCrntMdfManip(t_FmPcdManip *p_Crnt } } -static void BuildHmtd(uint8_t *p_Dest, uint8_t *p_Src, uint8_t *p_Hmcd, t_FmPcd *p_FmPcd) +static void BuildHmtd(uint8_t *p_Dest, uint8_t *p_Src, uint8_t *p_Hmcd, + t_FmPcd *p_FmPcd) { t_Error err; - /* Copy the HMTD */ + /* Copy the HMTD */ IO2IOCpy32(p_Dest, (uint8_t*)p_Src, 16); /* Replace the HMCT table pointer */ - WRITE_UINT32(((t_Hmtd *)p_Dest)->hmcdBasePtr, - (uint32_t)(XX_VirtToPhys(p_Hmcd) - ((t_FmPcd*)p_FmPcd)->physicalMuramBase)); + WRITE_UINT32( + ((t_Hmtd *)p_Dest)->hmcdBasePtr, + (uint32_t)(XX_VirtToPhys(p_Hmcd) - ((t_FmPcd*)p_FmPcd)->physicalMuramBase)); /* Call Host Command to replace HMTD by a new HMTD */ - err = FmHcPcdCcDoDynamicChange(p_FmPcd->h_Hc, - (uint32_t)(XX_VirtToPhys(p_Src) - p_FmPcd->physicalMuramBase), - (uint32_t)(XX_VirtToPhys(p_Dest) - p_FmPcd->physicalMuramBase)); + err = FmHcPcdCcDoDynamicChange( + p_FmPcd->h_Hc, + (uint32_t)(XX_VirtToPhys(p_Src) - p_FmPcd->physicalMuramBase), + (uint32_t)(XX_VirtToPhys(p_Dest) - p_FmPcd->physicalMuramBase)); if (err) 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, +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; + t_Error err = E_OK; - SANITY_CHECK_RETURN_ERROR(h_Manip,E_INVALID_HANDLE); + SANITY_CHECK_RETURN_ERROR(h_Manip, E_INVALID_HANDLE); UNUSED(level); UNUSED(h_FmPcd); @@ -3411,30 +4476,45 @@ static t_Error FmPcdManipInitUpdate(t_Handle h_FmPcd, switch (p_Manip->opcode) { +#if (defined(FM_CAPWAP_SUPPORT) && (DPAA_VERSION == 10)) 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 + err = UpdateInitMvIntFrameHeaderFromFrameToBufferPrefix(h_FmPort, + p_Manip, + h_Ad, + validate); + break; case (HMAN_OC_INSRT_HDR_BY_TEMPL_N_OR_FRAG_AFTER): - if (!p_Manip->h_Frag) - break; + if (!p_Manip->h_Frag) + break; case (HMAN_OC_CAPWAP_FRAGMENTATION): - err = UpdateInitCapwapFragmentation(h_FmPort, p_Manip, h_Ad, validate, h_FmTree); - break; + 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; + 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 */ + err = UpdateIndxStats(h_FmPcd, h_FmPort, p_Manip); + break; +#endif /* (defined(FM_CAPWAP_SUPPORT) && (DPAA_VERSION == 10)) */ case (HMAN_OC_IP_REASSEMBLY): - err = UpdateInitIpReasm(h_FmPcd, h_PcdParams, h_FmPort, p_Manip, h_Ad, validate); + err = UpdateInitReasm(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); + err = UpdateInitIpFrag(h_FmPcd, h_PcdParams, h_FmPort, p_Manip, + h_Ad, validate); + break; +#if (DPAA_VERSION >= 11) + case (HMAN_OC_CAPWAP_FRAGMENTATION): + err = UpdateInitCapwapFrag(h_FmPcd, h_PcdParams, h_FmPort, p_Manip, + h_Ad, validate); + break; + case (HMAN_OC_CAPWAP_REASSEMBLY): + err = UpdateInitReasm(h_FmPcd, h_PcdParams, h_FmPort, p_Manip, h_Ad, + validate); break; +#endif /* (DPAA_VERSION >= 11) */ default: return E_OK; } @@ -3442,34 +4522,42 @@ static t_Error FmPcdManipInitUpdate(t_Handle h_FmPcd, return err; } -static t_Error FmPcdManipModifyUpdate(t_Handle h_Manip, t_Handle h_Ad, bool validate, int level, t_Handle h_FmTree) +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; + t_FmPcdManip *p_Manip = (t_FmPcdManip *)h_Manip; + t_Error err = E_OK; UNUSED(level); switch (p_Manip->opcode) { +#if (defined(FM_CAPWAP_SUPPORT) && (DPAA_VERSION == 10)) 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")); + 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 + 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; 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 */ + if (p_Manip->h_Frag) + err = UpdateModifyCapwapFragmenation(p_Manip, h_Ad, validate, h_FmTree); + break; +#endif /* (defined(FM_CAPWAP_SUPPORT) && (DPAA_VERSION == 10)) */ default: return E_OK; } @@ -3481,46 +4569,26 @@ static t_Error FmPcdManipModifyUpdate(t_Handle h_Manip, t_Handle h_Ad, bool vali /* Inter-module API routines */ /*****************************************************************************/ -t_Error FmPcdManipUpdate(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, - bool modify) +t_Error FmPcdManipUpdate(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, + bool modify) { t_Error err; if (!modify) - err = FmPcdManipInitUpdate(h_FmPcd, h_PcdParams, h_FmPort, h_Manip, h_Ad, validate, level, h_FmTree); + err = FmPcdManipInitUpdate(h_FmPcd, h_PcdParams, h_FmPort, h_Manip, + h_Ad, validate, level, h_FmTree); else err = FmPcdManipModifyUpdate(h_Manip, h_Ad, validate, level, h_FmTree); return err; } -uint32_t FmPcdManipGetRequiredAction (t_Handle h_Manip) -{ - t_FmPcdManip *p_Manip = (t_FmPcdManip *)h_Manip; - - ASSERT_COND(h_Manip); - - switch (p_Manip->opcode) - { - case (HMAN_OC_CAPWAP_RMV_DTLS_IF_EXIST): - case (HMAN_OC_MV_INT_FRAME_HDR_FROM_FRM_TO_BUFFER_PREFFIX): - return UPDATE_NIA_ENQ_WITHOUT_DMA; - default: - return 0; - } -} - void FmPcdManipUpdateOwner(t_Handle h_Manip, bool add) { - uint32_t intFlags; + uint32_t intFlags; intFlags = XX_LockIntrSpinlock(((t_FmPcdManip *)h_Manip)->h_Spinlock); if (add) @@ -3542,19 +4610,22 @@ t_List *FmPcdManipGetNodeLstPointedOnThisManip(t_Handle h_Manip) t_List *FmPcdManipGetSpinlock(t_Handle h_Manip) { ASSERT_COND(h_Manip); - return ((t_FmPcdManip *)h_Manip)->h_Spinlock; + return ((t_FmPcdManip *)h_Manip)->h_Spinlock; } -t_Error FmPcdManipCheckParamsForCcNextEngine(t_FmPcdCcNextEngineParams *p_FmPcdCcNextEngineParams, uint32_t *requiredAction) +t_Error FmPcdManipCheckParamsForCcNextEngine( + t_FmPcdCcNextEngineParams *p_FmPcdCcNextEngineParams, + uint32_t *requiredAction) { - t_FmPcdManip *p_Manip; - t_Error err; - bool pointFromCc = TRUE; - + t_FmPcdManip *p_Manip; + t_Error err = E_OK; + bool pointFromCc = TRUE; SANITY_CHECK_RETURN_ERROR(p_FmPcdCcNextEngineParams, E_NULL_POINTER); - SANITY_CHECK_RETURN_ERROR(p_FmPcdCcNextEngineParams->h_Manip, 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; @@ -3562,48 +4633,84 @@ t_Error FmPcdManipCheckParamsForCcNextEngine(t_FmPcdCcNextEngineParams *p_FmPcdC { switch (p_Manip->opcode) { +#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) && - !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; + 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; 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; + 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) + case (HMAN_OC_CAPWAP_REASSEMBLY): + case (HMAN_OC_CAPWAP_FRAGMENTATION): +#endif /* (DPAA_VERSION >= 11) */ 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")); + RETURN_ERROR( + MAJOR, + E_INVALID_STATE, + ("For this type of header manipulation has to be nextEngine e_FM_PCD_DONE")); p_Manip->ownerTmp++; break; case (HMAN_OC_IPSEC_MANIP): +#if (DPAA_VERSION >= 11) + case (HMAN_OC_CAPWAP_MANIP): +#endif /* (DPAA_VERSION >= 11) */ p_Manip->ownerTmp++; break; case (HMAN_OC): - if (( p_FmPcdCcNextEngineParams->nextEngine == e_FM_PCD_CC) && MANIP_IS_CASCADE_NEXT(p_Manip)) - RETURN_ERROR(MINOR, E_INVALID_STATE, ("Can't have a cascaded manipulation when and Next Engine is CC")); + if ((p_FmPcdCcNextEngineParams->nextEngine == e_FM_PCD_CC) + && MANIP_IS_CASCADE_NEXT(p_Manip)) + RETURN_ERROR( + MINOR, + E_INVALID_STATE, + ("Can't have a cascaded manipulation when and Next Engine is CC")); if (!MANIP_IS_FIRST(p_Manip) && pointFromCc) - RETURN_ERROR(MAJOR, E_INVALID_STATE, ("h_Manip is already used and may not be shared (no sharing of non-head manip nodes)")); + RETURN_ERROR( + MAJOR, + E_INVALID_STATE, + ("h_Manip is already used and may not be shared (no sharing of non-head manip nodes)")); break; default: - RETURN_ERROR(MAJOR, E_INVALID_STATE,("invalid type of header manipulation for this state")); + RETURN_ERROR( + MAJOR, E_INVALID_STATE, + ("invalid type of header manipulation for this state")); } p_Manip = p_Manip->h_NextManip; pointFromCc = FALSE; @@ -3612,30 +4719,39 @@ t_Error FmPcdManipCheckParamsForCcNextEngine(t_FmPcdCcNextEngineParams *p_FmPcdC } -t_Error FmPcdManipCheckParamsWithCcNodeParams(t_Handle h_Manip, t_Handle h_FmPcdCcNode) +t_Error FmPcdManipCheckParamsWithCcNodeParams(t_Handle h_Manip, + t_Handle h_FmPcdCcNode) { t_FmPcdManip *p_Manip = (t_FmPcdManip *)h_Manip; - t_Error err = E_OK; + t_Error err = E_OK; SANITY_CHECK_RETURN_ERROR(h_Manip, E_INVALID_HANDLE); SANITY_CHECK_RETURN_ERROR(h_FmPcdCcNode, E_INVALID_HANDLE); switch (p_Manip->opcode) { +#if (defined(FM_CAPWAP_SUPPORT) && (DPAA_VERSION == 10)) case (HMAN_OC_CAPWAP_INDEXED_STATS): - if (p_Manip->ownerTmp != FmPcdCcGetNumOfKeys(h_FmPcdCcNode)) - RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("The manipulation of the type statistics flowId if exist has to be pointed by all numOfKeys")); - break; + if (p_Manip->ownerTmp != FmPcdCcGetNumOfKeys(h_FmPcdCcNode)) + RETURN_ERROR( + MAJOR, + E_INVALID_VALUE, + ("The manipulation of the type statistics flowId if exist has to be pointed by all numOfKeys")); + break; case (HMAN_OC_CAPWAP_RMV_DTLS_IF_EXIST): - if (p_Manip->h_Frag) - { - if (p_Manip->ownerTmp != FmPcdCcGetNumOfKeys(h_FmPcdCcNode)) - RETURN_ERROR(MAJOR, E_INVALID_VALUE, ("The manipulation of the type remove DTLS if exist has to be pointed by all numOfKeys")); - err = UpdateManipIc(h_Manip, FmPcdCcGetOffset(h_FmPcdCcNode)); - if (err) - RETURN_ERROR(MAJOR, err, NO_MSG); - } - break; + if (p_Manip->h_Frag) + { + if (p_Manip->ownerTmp != FmPcdCcGetNumOfKeys(h_FmPcdCcNode)) + RETURN_ERROR( + MAJOR, + E_INVALID_VALUE, + ("The manipulation of the type remove DTLS if exist has to be pointed by all numOfKeys")); + err = UpdateManipIc(h_Manip, FmPcdCcGetOffset(h_FmPcdCcNode)); + if (err) + RETURN_ERROR(MAJOR, err, NO_MSG); + } + break; +#endif /* (defined(FM_CAPWAP_SUPPORT) && (DPAA_VERSION == 10)) */ default: break; } @@ -3643,13 +4759,11 @@ t_Error FmPcdManipCheckParamsWithCcNodeParams(t_Handle h_Manip, t_Handle h_FmPcd return err; } -void FmPcdManipUpdateAdResultForCc(t_Handle h_Manip, - t_FmPcdCcNextEngineParams *p_CcNextEngineParams, - t_Handle p_Ad, - t_Handle *p_AdNewPtr) +void FmPcdManipUpdateAdResultForCc( + t_Handle h_Manip, t_FmPcdCcNextEngineParams *p_CcNextEngineParams, + t_Handle p_Ad, t_Handle *p_AdNewPtr) { - t_FmPcdManip *p_Manip = (t_FmPcdManip *)h_Manip; - + t_FmPcdManip *p_Manip = (t_FmPcdManip *)h_Manip; /* This routine creates a Manip AD and can return in "p_AdNewPtr" * either the new descriptor or NULL if it writes the Manip AD into p_AD (into the match table) */ @@ -3665,22 +4779,42 @@ void FmPcdManipUpdateAdResultForCc(t_Handle h_Manip, * p_Ad ( the AD in the match table) and set p_AdNew = NULL. */ switch (p_Manip->opcode) { +#if (defined(FM_CAPWAP_SUPPORT) && (DPAA_VERSION == 10)) case (HMAN_OC_RMV_N_OR_INSRT_INT_FRM_HDR): case (HMAN_OC_CAPWAP_RMV_DTLS_IF_EXIST): case (HMAN_OC_CAPWAP_INDEXED_STATS): - *p_AdNewPtr = p_Manip->h_Ad; - break; + *p_AdNewPtr = p_Manip->h_Ad; + break; + case (HMAN_OC_INSRT_HDR_BY_TEMPL_N_OR_FRAG_AFTER): + case (HMAN_OC_CAPWAP_FRAGMENTATION): + WRITE_UINT32(((t_AdOfTypeResult *)p_Ad)->fqid, + ((t_AdOfTypeResult *)(p_Manip->h_Ad))->fqid); + WRITE_UINT32(((t_AdOfTypeResult *)p_Ad)->plcrProfile, + ((t_AdOfTypeResult *)(p_Manip->h_Ad))->plcrProfile); + WRITE_UINT32(((t_AdOfTypeResult *)p_Ad)->nia, + ((t_AdOfTypeResult *)(p_Manip->h_Ad))->nia); + *p_AdNewPtr = NULL; + break; +#endif /* (defined(FM_CAPWAP_SUPPORT) && (DPAA_VERSION == 10)) */ case (HMAN_OC_IPSEC_MANIP): +#if (DPAA_VERSION >= 11) + case (HMAN_OC_CAPWAP_MANIP): +#endif /* (DPAA_VERSION >= 11) */ *p_AdNewPtr = p_Manip->h_Ad; break; case (HMAN_OC_IP_FRAGMENTATION): - if ((p_CcNextEngineParams->nextEngine == e_FM_PCD_DONE) && - (!p_CcNextEngineParams->params.enqueueParams.overrideFqid)) +#if (DPAA_VERSION >= 11) + case (HMAN_OC_CAPWAP_FRAGMENTATION): +#endif /* (DPAA_VERSION >= 11) */ + if ((p_CcNextEngineParams->nextEngine == e_FM_PCD_DONE) + && (!p_CcNextEngineParams->params.enqueueParams.overrideFqid)) { - memcpy((uint8_t *)p_Ad, (uint8_t *)p_Manip->h_Ad, sizeof(t_AdOfTypeContLookup)); + memcpy((uint8_t *)p_Ad, (uint8_t *)p_Manip->h_Ad, + sizeof(t_AdOfTypeContLookup)); #if (DPAA_VERSION >= 11) - WRITE_UINT32(((t_AdOfTypeContLookup *)p_Ad)->ccAdBase, - GET_UINT32(((t_AdOfTypeContLookup *)p_Ad)->ccAdBase) & ~FM_PCD_MANIP_IP_CNIA); + WRITE_UINT32( + ((t_AdOfTypeContLookup *)p_Ad)->ccAdBase, + GET_UINT32(((t_AdOfTypeContLookup *)p_Ad)->ccAdBase) & ~FM_PCD_MANIP_IP_CNIA); #endif /* (DPAA_VERSION >= 11) */ *p_AdNewPtr = NULL; } @@ -3690,30 +4824,32 @@ void FmPcdManipUpdateAdResultForCc(t_Handle h_Manip, case (HMAN_OC_IP_REASSEMBLY): if (FmPcdManipIpReassmIsIpv6Hdr(p_Manip)) { - if (!p_Manip->ipReassmParams.ipv6Assigned) + if (!p_Manip->reassmParams.ip.ipv6Assigned) { - *p_AdNewPtr = p_Manip->ipReassmParams.h_Ipv6Ad; - p_Manip->ipReassmParams.ipv6Assigned = TRUE; + *p_AdNewPtr = p_Manip->reassmParams.ip.h_Ipv6Ad; + p_Manip->reassmParams.ip.ipv6Assigned = TRUE; FmPcdManipUpdateOwner(h_Manip, FALSE); } else { - *p_AdNewPtr = p_Manip->ipReassmParams.h_Ipv4Ad; - p_Manip->ipReassmParams.ipv6Assigned = FALSE; + *p_AdNewPtr = p_Manip->reassmParams.ip.h_Ipv4Ad; + p_Manip->reassmParams.ip.ipv6Assigned = FALSE; } } else - *p_AdNewPtr = p_Manip->ipReassmParams.h_Ipv4Ad; - memcpy((uint8_t *)p_Ad, (uint8_t *)*p_AdNewPtr, sizeof(t_AdOfTypeContLookup)); + *p_AdNewPtr = p_Manip->reassmParams.ip.h_Ipv4Ad; + memcpy((uint8_t *)p_Ad, (uint8_t *)*p_AdNewPtr, + sizeof(t_AdOfTypeContLookup)); *p_AdNewPtr = NULL; break; - case (HMAN_OC_INSRT_HDR_BY_TEMPL_N_OR_FRAG_AFTER): - case (HMAN_OC_CAPWAP_FRAGMENTATION): - WRITE_UINT32(((t_AdOfTypeResult *)p_Ad)->fqid, ((t_AdOfTypeResult *)(p_Manip->h_Ad))->fqid); - WRITE_UINT32(((t_AdOfTypeResult *)p_Ad)->plcrProfile, ((t_AdOfTypeResult *)(p_Manip->h_Ad))->plcrProfile); - WRITE_UINT32(((t_AdOfTypeResult *)p_Ad)->nia, ((t_AdOfTypeResult *)(p_Manip->h_Ad))->nia); +#if (DPAA_VERSION >= 11) + case (HMAN_OC_CAPWAP_REASSEMBLY): + *p_AdNewPtr = p_Manip->reassmParams.capwap.h_Ad; + memcpy((uint8_t *)p_Ad, (uint8_t *)*p_AdNewPtr, + sizeof(t_AdOfTypeContLookup)); *p_AdNewPtr = NULL; break; +#endif /* (DPAA_VERSION >= 11) */ case (HMAN_OC): /* Allocate and initialize HMTD */ *p_AdNewPtr = p_Manip->h_Ad; @@ -3723,9 +4859,11 @@ void FmPcdManipUpdateAdResultForCc(t_Handle h_Manip, } } -void FmPcdManipUpdateAdContLookupForCc(t_Handle h_Manip, t_Handle p_Ad, t_Handle *p_AdNewPtr, uint32_t adTableOffset) +void FmPcdManipUpdateAdContLookupForCc(t_Handle h_Manip, t_Handle p_Ad, + t_Handle *p_AdNewPtr, + uint32_t adTableOffset) { - t_FmPcdManip *p_Manip = (t_FmPcdManip *)h_Manip; + t_FmPcdManip *p_Manip = (t_FmPcdManip *)h_Manip; /* This routine creates a Manip AD and can return in "p_AdNewPtr" * either the new descriptor or NULL if it writes the Manip AD into p_AD (into the match table) */ @@ -3735,25 +4873,36 @@ void FmPcdManipUpdateAdContLookupForCc(t_Handle h_Manip, t_Handle p_Ad, t_Handle switch (p_Manip->opcode) { +#if (defined(FM_CAPWAP_SUPPORT) && (DPAA_VERSION == 10)) case (HMAN_OC_MV_INT_FRAME_HDR_FROM_FRM_TO_BUFFER_PREFFIX): - WRITE_UINT32(((t_AdOfTypeContLookup *)p_Ad)->ccAdBase, ((t_AdOfTypeContLookup *)(p_Manip->h_Ad))->ccAdBase); - WRITE_UINT32(((t_AdOfTypeContLookup *)p_Ad)->matchTblPtr, ((t_AdOfTypeContLookup *)(p_Manip->h_Ad))->matchTblPtr); - WRITE_UINT32(((t_AdOfTypeContLookup *)p_Ad)->pcAndOffsets, ((t_AdOfTypeContLookup *)(p_Manip->h_Ad))->pcAndOffsets); - WRITE_UINT32(((t_AdOfTypeContLookup *)p_Ad)->gmask, ((t_AdOfTypeContLookup *)(p_Manip->h_Ad))->gmask); - WRITE_UINT32(((t_AdOfTypeContLookup *)p_Ad)->ccAdBase, (GET_UINT32(((t_AdOfTypeContLookup *)p_Ad)->ccAdBase) | adTableOffset)); - *p_AdNewPtr = NULL; - break; - + WRITE_UINT32(((t_AdOfTypeContLookup *)p_Ad)->ccAdBase, + ((t_AdOfTypeContLookup *)(p_Manip->h_Ad))->ccAdBase); + WRITE_UINT32( + ((t_AdOfTypeContLookup *)p_Ad)->matchTblPtr, + ((t_AdOfTypeContLookup *)(p_Manip->h_Ad))->matchTblPtr); + WRITE_UINT32( + ((t_AdOfTypeContLookup *)p_Ad)->pcAndOffsets, + ((t_AdOfTypeContLookup *)(p_Manip->h_Ad))->pcAndOffsets); + WRITE_UINT32(((t_AdOfTypeContLookup *)p_Ad)->gmask, + ((t_AdOfTypeContLookup *)(p_Manip->h_Ad))->gmask); + WRITE_UINT32( + ((t_AdOfTypeContLookup *)p_Ad)->ccAdBase, + (GET_UINT32(((t_AdOfTypeContLookup *)p_Ad)->ccAdBase) | adTableOffset)); + *p_AdNewPtr = NULL; + break; +#endif /* (defined(FM_CAPWAP_SUPPORT) && (DPAA_VERSION == 10)) */ case (HMAN_OC): /* Initialize HMTD within the match table*/ - IOMemSet32(p_Ad, 0, FM_PCD_CC_AD_ENTRY_SIZE); - /* copy the existing HMTD */ /* ask Alla - memcpy??? */ + IOMemSet32(p_Ad, 0, FM_PCD_CC_AD_ENTRY_SIZE); + /* copy the existing HMTD *//* ask Alla - memcpy??? */ memcpy((uint8_t*)p_Ad, p_Manip->h_Ad, sizeof(t_Hmtd)); /* update NADEN to be "1"*/ - WRITE_UINT16(((t_Hmtd *)p_Ad)->cfg, - (uint16_t)(GET_UINT16(((t_Hmtd *)p_Ad)->cfg) | HMTD_CFG_NEXT_AD_EN)); + WRITE_UINT16( + ((t_Hmtd *)p_Ad)->cfg, + (uint16_t)(GET_UINT16(((t_Hmtd *)p_Ad)->cfg) | HMTD_CFG_NEXT_AD_EN)); /* update next action descriptor */ - WRITE_UINT16(((t_Hmtd *)p_Ad)->nextAdIdx, (uint16_t)(adTableOffset >> 4)); + WRITE_UINT16(((t_Hmtd *)p_Ad)->nextAdIdx, + (uint16_t)(adTableOffset >> 4)); /* mark that Manip's HMTD is not used */ *p_AdNewPtr = NULL; break; @@ -3763,30 +4912,32 @@ void FmPcdManipUpdateAdContLookupForCc(t_Handle h_Manip, t_Handle p_Ad, t_Handle } } -t_Error FmPcdManipBuildIpReassmScheme(t_FmPcd *p_FmPcd, t_Handle h_NetEnv, t_Handle h_CcTree, t_Handle h_Manip, bool isIpv4, uint8_t groupId) +t_Error FmPcdManipBuildIpReassmScheme(t_FmPcd *p_FmPcd, t_Handle h_NetEnv, + t_Handle h_CcTree, t_Handle h_Manip, + bool isIpv4, uint8_t groupId) { - t_FmPcdManip *p_Manip = (t_FmPcdManip *)h_Manip; - t_FmPcdKgSchemeParams *p_SchemeParams = NULL; + t_FmPcdManip *p_Manip = (t_FmPcdManip *)h_Manip; + t_FmPcdKgSchemeParams *p_SchemeParams = NULL; ASSERT_COND(p_FmPcd); ASSERT_COND(h_NetEnv); ASSERT_COND(p_Manip); /* scheme was already build, no need to check for IPv6 */ - if (p_Manip->ipReassmParams.h_Ipv4Scheme) + if (p_Manip->reassmParams.ip.h_Ipv4Scheme) return E_OK; p_SchemeParams = XX_Malloc(sizeof(t_FmPcdKgSchemeParams)); if (!p_SchemeParams) - RETURN_ERROR(MAJOR, E_NO_MEMORY, ("Memory allocation failed for scheme")); + RETURN_ERROR(MAJOR, E_NO_MEMORY, + ("Memory allocation failed for scheme")); /* Configures the IPv4 or IPv6 scheme*/ memset(p_SchemeParams, 0, sizeof(t_FmPcdKgSchemeParams)); p_SchemeParams->netEnvParams.h_NetEnv = h_NetEnv; - p_SchemeParams->id.relativeSchemeId = - (uint8_t)((isIpv4 == TRUE) ? - p_Manip->ipReassmParams.relativeSchemeId[0] : - p_Manip->ipReassmParams.relativeSchemeId[1]); + p_SchemeParams->id.relativeSchemeId = (uint8_t)( + (isIpv4 == TRUE) ? p_Manip->reassmParams.ip.relativeSchemeId[0] : + p_Manip->reassmParams.ip.relativeSchemeId[1]); p_SchemeParams->schemeCounter.update = TRUE; #if (DPAA_VERSION >= 11) p_SchemeParams->alwaysDirect = TRUE; @@ -3796,13 +4947,15 @@ t_Error FmPcdManipBuildIpReassmScheme(t_FmPcd *p_FmPcd, t_Handle h_NetEnv, t_Han p_SchemeParams->baseFqid = 0xFFFFFF; /*TODO- baseFqid*/ #endif /* (DPAA_VERSION >= 11) */ - setReassmSchemeParams(p_FmPcd, p_SchemeParams, h_CcTree, isIpv4, groupId); + setIpReassmSchemeParams(p_FmPcd, p_SchemeParams, h_CcTree, isIpv4, groupId); /* Sets the new scheme */ if (isIpv4) - p_Manip->ipReassmParams.h_Ipv4Scheme = FM_PCD_KgSchemeSet(p_FmPcd, p_SchemeParams); + p_Manip->reassmParams.ip.h_Ipv4Scheme = FM_PCD_KgSchemeSet( + p_FmPcd, p_SchemeParams); else - p_Manip->ipReassmParams.h_Ipv6Scheme = FM_PCD_KgSchemeSet(p_FmPcd, p_SchemeParams); + p_Manip->reassmParams.ip.h_Ipv6Scheme = FM_PCD_KgSchemeSet( + p_FmPcd, p_SchemeParams); XX_Free(p_SchemeParams); @@ -3811,29 +4964,78 @@ t_Error FmPcdManipBuildIpReassmScheme(t_FmPcd *p_FmPcd, t_Handle h_NetEnv, t_Han t_Error FmPcdManipDeleteIpReassmSchemes(t_Handle h_Manip) { - t_FmPcdManip *p_Manip = (t_FmPcdManip *)h_Manip; + t_FmPcdManip *p_Manip = (t_FmPcdManip *)h_Manip; ASSERT_COND(p_Manip); - if (p_Manip->ipReassmParams.h_Ipv4Scheme) - FM_PCD_KgSchemeDelete(p_Manip->ipReassmParams.h_Ipv4Scheme); + if (p_Manip->reassmParams.ip.h_Ipv4Scheme) + FM_PCD_KgSchemeDelete(p_Manip->reassmParams.ip.h_Ipv4Scheme); - if (p_Manip->ipReassmParams.h_Ipv6Scheme) - FM_PCD_KgSchemeDelete(p_Manip->ipReassmParams.h_Ipv6Scheme); + if (p_Manip->reassmParams.ip.h_Ipv6Scheme) + FM_PCD_KgSchemeDelete(p_Manip->reassmParams.ip.h_Ipv6Scheme); return E_OK; } bool FmPcdManipIpReassmIsIpv6Hdr(t_Handle h_Manip) { - t_FmPcdManip *p_Manip = (t_FmPcdManip *)h_Manip; + t_FmPcdManip *p_Manip = (t_FmPcdManip *)h_Manip; + + ASSERT_COND(p_Manip); + + return (p_Manip->reassmParams.hdr == HEADER_TYPE_IPv6); +} + +t_Error FmPcdManipBuildCapwapReassmScheme(t_FmPcd *p_FmPcd, t_Handle h_NetEnv, + t_Handle h_CcTree, t_Handle h_Manip, + uint8_t groupId) +{ + t_FmPcdManip *p_Manip = (t_FmPcdManip *)h_Manip; + t_FmPcdKgSchemeParams *p_SchemeParams = NULL; + + ASSERT_COND(p_FmPcd); + ASSERT_COND(h_NetEnv); + ASSERT_COND(p_Manip); + + /* scheme was already build, no need to check for IPv6 */ + if (p_Manip->reassmParams.capwap.h_Scheme) + return E_OK; + + p_SchemeParams = XX_Malloc(sizeof(t_FmPcdKgSchemeParams)); + if (!p_SchemeParams) + RETURN_ERROR(MAJOR, E_NO_MEMORY, + ("Memory allocation failed for scheme")); + + memset(p_SchemeParams, 0, sizeof(t_FmPcdKgSchemeParams)); + p_SchemeParams->netEnvParams.h_NetEnv = h_NetEnv; + p_SchemeParams->id.relativeSchemeId = + (uint8_t)p_Manip->reassmParams.capwap.relativeSchemeId; + p_SchemeParams->schemeCounter.update = TRUE; + p_SchemeParams->bypassFqidGeneration = TRUE; + + setCapwapReassmSchemeParams(p_FmPcd, p_SchemeParams, h_CcTree, groupId); + + p_Manip->reassmParams.capwap.h_Scheme = FM_PCD_KgSchemeSet(p_FmPcd, + p_SchemeParams); + + XX_Free(p_SchemeParams); + + return E_OK; +} + +t_Error FmPcdManipDeleteCapwapReassmSchemes(t_Handle h_Manip) +{ + t_FmPcdManip *p_Manip = (t_FmPcdManip *)h_Manip; ASSERT_COND(p_Manip); - return (p_Manip->ipReassmParams.hdr == HEADER_TYPE_IPv6); + if (p_Manip->reassmParams.capwap.h_Scheme) + FM_PCD_KgSchemeDelete(p_Manip->reassmParams.capwap.h_Scheme); + + return E_OK; } -#ifdef FM_CAPWAP_SUPPORT +#if (defined(FM_CAPWAP_SUPPORT) && (DPAA_VERSION == 10)) t_Handle FmPcdManipApplSpecificBuild(void) { t_FmPcdManip *p_Manip; @@ -3850,18 +5052,18 @@ t_Handle FmPcdManipApplSpecificBuild(void) p_Manip->muramAllocate = FALSE; p_Manip->h_Ad = (t_Handle)XX_Malloc(FM_PCD_CC_AD_ENTRY_SIZE * sizeof(uint8_t)); - if (!p_Manip->h_Ad) - { + if (!p_Manip->h_Ad) + { REPORT_ERROR(MAJOR, E_NO_MEMORY, ("Allocation of Manipulation action descriptor")); XX_Free(p_Manip); return NULL; - } + } - memset(p_Manip->h_Ad, 0, FM_PCD_CC_AD_ENTRY_SIZE * sizeof(uint8_t)); + memset(p_Manip->h_Ad, 0, FM_PCD_CC_AD_ENTRY_SIZE * sizeof(uint8_t)); /*treatFdStatusFieldsAsErrors = TRUE hardcoded - assumption its always come after CAAM*/ /*Application specific = type of flowId index, move internal frame header from data to IC, - SEC errors check*/ + SEC errors check*/ if (MvIntFrameHeaderFromFrameToBufferPrefix(p_Manip, TRUE)!= E_OK) { XX_Free(p_Manip->h_Ad); @@ -3878,33 +5080,37 @@ bool FmPcdManipIsCapwapApplSpecific(t_Handle h_Manip) return (bool)((p_Manip->opcode == HMAN_OC_CAPWAP_RMV_DTLS_IF_EXIST) ? TRUE : FALSE); } -#endif /* FM_CAPWAP_SUPPORT */ +#endif /* (defined(FM_CAPWAP_SUPPORT) && (DPAA_VERSION == 10)) */ /*********************** End of inter-module routines ************************/ - /****************************************/ /* API Init unit functions */ /****************************************/ -t_Handle FM_PCD_ManipNodeSet(t_Handle h_FmPcd, t_FmPcdManipParams *p_ManipParams) +t_Handle FM_PCD_ManipNodeSet(t_Handle h_FmPcd, + t_FmPcdManipParams *p_ManipParams) { - t_FmPcd *p_FmPcd = (t_FmPcd *)h_FmPcd; - t_FmPcdManip *p_Manip; - t_Error err; + t_FmPcd *p_FmPcd = (t_FmPcd *)h_FmPcd; + t_FmPcdManip *p_Manip; + t_Error err; - SANITY_CHECK_RETURN_VALUE(h_FmPcd,E_INVALID_HANDLE,NULL); - SANITY_CHECK_RETURN_VALUE(p_ManipParams,E_INVALID_HANDLE,NULL); + SANITY_CHECK_RETURN_VALUE(h_FmPcd, E_INVALID_HANDLE, NULL); + SANITY_CHECK_RETURN_VALUE(p_ManipParams, E_INVALID_HANDLE, NULL); - p_Manip = ManipOrStatsSetNode(h_FmPcd, (t_Handle)p_ManipParams, FALSE); + p_Manip = ManipOrStatsSetNode(h_FmPcd, (t_Handle)p_ManipParams, FALSE); if (!p_Manip) return NULL; - if (((p_Manip->opcode == HMAN_OC_IP_REASSEMBLY) || - (p_Manip->opcode == HMAN_OC_IP_FRAGMENTATION) || - (p_Manip->opcode == HMAN_OC_MV_INT_FRAME_HDR_FROM_FRM_TO_BUFFER_PREFFIX) || - (p_Manip->opcode == HMAN_OC) || - (p_Manip->opcode == HMAN_OC_IPSEC_MANIP)) && - (!FmPcdIsAdvancedOffloadSupported(p_FmPcd))) + if (((p_Manip->opcode == HMAN_OC_IP_REASSEMBLY) + || (p_Manip->opcode == HMAN_OC_IP_FRAGMENTATION) + || (p_Manip->opcode == HMAN_OC) + || (p_Manip->opcode == HMAN_OC_IPSEC_MANIP) +#if (DPAA_VERSION >= 11) + || (p_Manip->opcode == HMAN_OC_CAPWAP_MANIP) + || (p_Manip->opcode == HMAN_OC_CAPWAP_FRAGMENTATION) + || (p_Manip->opcode == HMAN_OC_CAPWAP_REASSEMBLY) +#endif /* (DPAA_VERSION >= 11) */ + ) && (!FmPcdIsAdvancedOffloadSupported(p_FmPcd))) { REPORT_ERROR(MAJOR, E_INVALID_STATE, ("Advanced-offload must be enabled")); XX_Free(p_Manip); @@ -3917,8 +5123,7 @@ t_Handle FM_PCD_ManipNodeSet(t_Handle h_FmPcd, t_FmPcdManipParams *p_ManipParams ReleaseManipHandler(p_Manip, p_FmPcd); XX_Free(p_Manip); return NULL; - } - INIT_LIST(&p_Manip->nodesLst); + }INIT_LIST(&p_Manip->nodesLst); switch (p_Manip->opcode) { @@ -3926,26 +5131,40 @@ t_Handle FM_PCD_ManipNodeSet(t_Handle h_FmPcd, t_FmPcdManipParams *p_ManipParams /* IpReassembly */ err = IpReassembly(&p_ManipParams->u.reassem, p_Manip); break; - case (HMAN_OC_IP_FRAGMENTATION): + case (HMAN_OC_IP_FRAGMENTATION): /* IpFragmentation */ - err = IpFragmentation(&p_ManipParams->u.frag.u.ipFrag ,p_Manip); + err = IpFragmentation(&p_ManipParams->u.frag.u.ipFrag, p_Manip); if (err) break; err = IPManip(p_Manip); break; - case (HMAN_OC_IPSEC_MANIP) : + case (HMAN_OC_IPSEC_MANIP): err = IPSecManip(p_ManipParams, p_Manip); break; -#ifdef FM_CAPWAP_SUPPORT - case (HMAN_OC_RMV_N_OR_INSRT_INT_FRM_HDR): +#if (DPAA_VERSION >= 11) + case (HMAN_OC_CAPWAP_REASSEMBLY): + /* CapwapReassembly */ + err = CapwapReassembly(&p_ManipParams->u.reassem, p_Manip); + break; + case (HMAN_OC_CAPWAP_FRAGMENTATION): + /* CapwapFragmentation */ + err = CapwapFragmentation(&p_ManipParams->u.frag.u.capwapFrag, + p_Manip); + break; + case (HMAN_OC_CAPWAP_MANIP): + err = CapwapManip(p_ManipParams, p_Manip); + break; +#endif /* (DPAA_VERSION >= 11) */ +#if (defined(FM_CAPWAP_SUPPORT) && (DPAA_VERSION == 10)) + case (HMAN_OC_RMV_N_OR_INSRT_INT_FRM_HDR): /* HmanType1 */ err = RmvHdrTillSpecLocNOrInsrtIntFrmHdr(&p_ManipParams->u.hdr.rmvParams, p_Manip); break; - case (HMAN_OC_CAPWAP_FRAGMENTATION): + case (HMAN_OC_CAPWAP_FRAGMENTATION): err = CapwapFragmentation(&p_ManipParams->fragOrReasmParams.u.capwapFragParams, - p_Manip, - p_FmPcd, - p_ManipParams->fragOrReasmParams.sgBpid); + p_Manip, + p_FmPcd, + p_ManipParams->fragOrReasmParams.sgBpid); if (err) { REPORT_ERROR(MAJOR, E_INVALID_VALUE, ("UNSUPPORTED HEADER MANIPULATION TYPE")); @@ -3954,16 +5173,16 @@ t_Handle FM_PCD_ManipNodeSet(t_Handle h_FmPcd, t_FmPcdManipParams *p_ManipParams return NULL; } if (p_Manip->insrt) - p_Manip->opcode = HMAN_OC_INSRT_HDR_BY_TEMPL_N_OR_FRAG_AFTER; - case (HMAN_OC_INSRT_HDR_BY_TEMPL_N_OR_FRAG_AFTER): + p_Manip->opcode = HMAN_OC_INSRT_HDR_BY_TEMPL_N_OR_FRAG_AFTER; + case (HMAN_OC_INSRT_HDR_BY_TEMPL_N_OR_FRAG_AFTER): /* HmanType2 + if user asked only for fragmentation still need to allocate HmanType2 */ err = InsrtHdrByTempl(&p_ManipParams->u.hdr.insrtParams, p_Manip, p_FmPcd); break; - case (HMAN_OC_CAPWAP_REASSEMBLY): + case (HMAN_OC_CAPWAP_REASSEMBLY): err = CapwapReassembly(&p_ManipParams->fragOrReasmParams.u.capwapReasmParams, - p_Manip, - p_FmPcd, - p_ManipParams->fragOrReasmParams.sgBpid); + p_Manip, + p_FmPcd, + p_ManipParams->fragOrReasmParams.sgBpid); if (err) { REPORT_ERROR(MAJOR, E_INVALID_VALUE, ("UNSUPPORTED HEADER MANIPULATION TYPE")); @@ -3972,21 +5191,21 @@ t_Handle FM_PCD_ManipNodeSet(t_Handle h_FmPcd, t_FmPcdManipParams *p_ManipParams return NULL; } if (p_Manip->rmv) - p_Manip->opcode = HMAN_OC_CAPWAP_RMV_DTLS_IF_EXIST; - case (HMAN_OC_CAPWAP_RMV_DTLS_IF_EXIST): + p_Manip->opcode = HMAN_OC_CAPWAP_RMV_DTLS_IF_EXIST; + case (HMAN_OC_CAPWAP_RMV_DTLS_IF_EXIST): /*CAPWAP decapsulation + if user asked only for reassembly still need to allocate CAPWAP decapsulation*/ err = CapwapRmvDtlsHdr(p_FmPcd, p_Manip); break; -#endif /* FM_CAPWAP_SUPPORT */ - case (HMAN_OC_MV_INT_FRAME_HDR_FROM_FRM_TO_BUFFER_PREFFIX): + case (HMAN_OC_MV_INT_FRAME_HDR_FROM_FRM_TO_BUFFER_PREFFIX): /*Application Specific type 1*/ err = MvIntFrameHeaderFromFrameToBufferPrefix(p_Manip, TRUE); break; - case (HMAN_OC): - /* New Manip */ - err = CreateManipActionNew(p_Manip, p_ManipParams); - break; - default: +#endif /* (defined(FM_CAPWAP_SUPPORT) && (DPAA_VERSION == 10)) */ + case (HMAN_OC): + /* New Manip */ + err = CreateManipActionNew(p_Manip, p_ManipParams); + break; + default: REPORT_ERROR(MAJOR, E_INVALID_VALUE, ("UNSUPPORTED HEADER MANIPULATION TYPE")); ReleaseManipHandler(p_Manip, p_FmPcd); XX_Free(p_Manip); @@ -4014,27 +5233,31 @@ t_Handle FM_PCD_ManipNodeSet(t_Handle h_FmPcd, t_FmPcdManipParams *p_ManipParams return p_Manip; } -t_Error FM_PCD_ManipNodeReplace(t_Handle h_Manip, t_FmPcdManipParams *p_ManipParams) +t_Error FM_PCD_ManipNodeReplace(t_Handle h_Manip, + t_FmPcdManipParams *p_ManipParams) { - t_FmPcdManip *p_Manip = (t_FmPcdManip *)h_Manip, *p_FirstManip; - t_FmPcd *p_FmPcd = (t_FmPcd *)(p_Manip->h_FmPcd); - t_Error err; - uint8_t *p_WholeHmct = NULL, *p_ShadowHmct = NULL, *p_Hmtd = NULL; - t_List lstOfNodeshichPointsOnCrntMdfManip, *p_Pos; - t_CcNodeInformation *p_CcNodeInfo; - SANITY_CHECK_RETURN_ERROR(h_Manip,E_INVALID_HANDLE); - SANITY_CHECK_RETURN_ERROR(p_ManipParams,E_INVALID_HANDLE); + t_FmPcdManip *p_Manip = (t_FmPcdManip *)h_Manip, *p_FirstManip; + t_FmPcd *p_FmPcd = (t_FmPcd *)(p_Manip->h_FmPcd); + t_Error err; + uint8_t *p_WholeHmct = NULL, *p_ShadowHmct = NULL, *p_Hmtd = NULL; + t_List lstOfNodeshichPointsOnCrntMdfManip, *p_Pos; + t_CcNodeInformation *p_CcNodeInfo; + SANITY_CHECK_RETURN_ERROR(h_Manip, E_INVALID_HANDLE); + SANITY_CHECK_RETURN_ERROR(p_ManipParams, E_INVALID_HANDLE); INIT_LIST(&lstOfNodeshichPointsOnCrntMdfManip); - if ((p_ManipParams->type != e_FM_PCD_MANIP_HDR) || - (p_Manip->type != e_FM_PCD_MANIP_HDR)) - RETURN_ERROR(MINOR, E_NOT_SUPPORTED, - ("FM_PCD_ManipNodeReplace Functionality supported only for Header Manipulation.")); + if ((p_ManipParams->type != e_FM_PCD_MANIP_HDR) + || (p_Manip->type != e_FM_PCD_MANIP_HDR)) + RETURN_ERROR( + MINOR, + E_NOT_SUPPORTED, + ("FM_PCD_ManipNodeReplace Functionality supported only for Header Manipulation.")); ASSERT_COND(p_Manip->opcode == HMAN_OC); ASSERT_COND(p_Manip->manipParams.h_NextManip == p_Manip->h_NextManip); - memcpy((uint8_t*)&p_Manip->manipParams, p_ManipParams, sizeof(p_Manip->manipParams)); + memcpy((uint8_t*)&p_Manip->manipParams, p_ManipParams, + sizeof(p_Manip->manipParams)); p_Manip->manipParams.h_NextManip = p_Manip->h_NextManip; /* The replacement of the HdrManip depends on the node type.*/ @@ -4076,20 +5299,24 @@ t_Error FM_PCD_ManipNodeReplace(t_Handle h_Manip, t_FmPcdManipParams *p_ManipPar p_ShadowHmct = (uint8_t*)PTR_MOVE(p_FmPcd->p_CcShadow, 16); - p_FirstManip = (t_FmPcdManip*)GetManipInfo(p_Manip, e_MANIP_HANDLER_TABLE_OWNER); + p_FirstManip = (t_FmPcdManip*)GetManipInfo(p_Manip, + e_MANIP_HANDLER_TABLE_OWNER); ASSERT_COND(p_FirstManip); if (!LIST_IsEmpty(&p_FirstManip->nodesLst)) - UpdateAdPtrOfNodesWhichPointsOnCrntMdfManip(p_FirstManip, &lstOfNodeshichPointsOnCrntMdfManip); + UpdateAdPtrOfNodesWhichPointsOnCrntMdfManip( + p_FirstManip, &lstOfNodeshichPointsOnCrntMdfManip); p_Hmtd = (uint8_t *)GetManipInfo(p_Manip, e_MANIP_HMTD); ASSERT_COND(p_Hmtd); - BuildHmtd(p_FmPcd->p_CcShadow, (uint8_t *)p_Hmtd, p_ShadowHmct, ((t_FmPcd*)(p_Manip->h_FmPcd))); + BuildHmtd(p_FmPcd->p_CcShadow, (uint8_t *)p_Hmtd, p_ShadowHmct, + ((t_FmPcd*)(p_Manip->h_FmPcd))); LIST_FOR_EACH(p_Pos, &lstOfNodeshichPointsOnCrntMdfManip) { p_CcNodeInfo = CC_NODE_F_OBJECT(p_Pos); - BuildHmtd(p_FmPcd->p_CcShadow, (uint8_t *)p_CcNodeInfo->h_CcNode, p_ShadowHmct, ((t_FmPcd*)(p_Manip->h_FmPcd))); + BuildHmtd(p_FmPcd->p_CcShadow, (uint8_t *)p_CcNodeInfo->h_CcNode, + p_ShadowHmct, ((t_FmPcd*)(p_Manip->h_FmPcd))); } p_WholeHmct = (uint8_t *)GetManipInfo(p_Manip, e_MANIP_HMCT); @@ -4105,15 +5332,16 @@ t_Error FM_PCD_ManipNodeReplace(t_Handle h_Manip, t_FmPcdManipParams *p_ManipPar p_Hmtd = (uint8_t *)GetManipInfo(p_Manip, e_MANIP_HMTD); ASSERT_COND(p_Hmtd); - BuildHmtd(p_FmPcd->p_CcShadow, (uint8_t *)p_Hmtd, p_WholeHmct,((t_FmPcd*)p_Manip->h_FmPcd)); + BuildHmtd(p_FmPcd->p_CcShadow, (uint8_t *)p_Hmtd, p_WholeHmct, + ((t_FmPcd*)p_Manip->h_FmPcd)); /* If LIST > 0, create a list of p_Ad's that point to the HMCT. Join also t_HMTD to this list. * For each p_Hmct (from list+fixed): - * call Host Command to replace HMTD by a new one */ - LIST_FOR_EACH(p_Pos, &lstOfNodeshichPointsOnCrntMdfManip) + * call Host Command to replace HMTD by a new one */LIST_FOR_EACH(p_Pos, &lstOfNodeshichPointsOnCrntMdfManip) { p_CcNodeInfo = CC_NODE_F_OBJECT(p_Pos); - BuildHmtd(p_FmPcd->p_CcShadow, (uint8_t *)p_CcNodeInfo->h_CcNode, p_WholeHmct, ((t_FmPcd*)(p_Manip->h_FmPcd))); + BuildHmtd(p_FmPcd->p_CcShadow, (uint8_t *)p_CcNodeInfo->h_CcNode, + p_WholeHmct, ((t_FmPcd*)(p_Manip->h_FmPcd))); } @@ -4124,17 +5352,20 @@ t_Error FM_PCD_ManipNodeReplace(t_Handle h_Manip, t_FmPcdManipParams *p_ManipPar /* unlock shadow */ RELEASE_LOCK(p_FmPcd->shadowLock); - return E_OK; + return E_OK; } t_Error FM_PCD_ManipNodeDelete(t_Handle h_ManipNode) { - t_FmPcdManip *p_Manip = (t_FmPcdManip *)h_ManipNode; + t_FmPcdManip *p_Manip = (t_FmPcdManip *)h_ManipNode; - SANITY_CHECK_RETURN_ERROR(p_Manip,E_INVALID_HANDLE); + SANITY_CHECK_RETURN_ERROR(p_Manip, E_INVALID_HANDLE); if (p_Manip->owner) - RETURN_ERROR(MAJOR, E_INVALID_STATE, ("This manipulation node not be removed because this node is occupied, first - unbind this node ")); + RETURN_ERROR( + MAJOR, + E_INVALID_STATE, + ("This manipulation node not be removed because this node is occupied, first - unbind this node ")); if (p_Manip->h_NextManip) { @@ -4142,14 +5373,16 @@ t_Error FM_PCD_ManipNodeDelete(t_Handle h_ManipNode) FmPcdManipUpdateOwner(p_Manip->h_NextManip, FALSE); } - if (p_Manip->p_Hmct && (MANIP_IS_UNIFIED_FIRST(p_Manip) || !MANIP_IS_UNIFIED(p_Manip))) - FM_MURAM_FreeMem(((t_FmPcd *)p_Manip->h_FmPcd)->h_FmMuram, p_Manip->p_Hmct); + if (p_Manip->p_Hmct + && (MANIP_IS_UNIFIED_FIRST(p_Manip) || !MANIP_IS_UNIFIED(p_Manip))) + FM_MURAM_FreeMem(((t_FmPcd *)p_Manip->h_FmPcd)->h_FmMuram, + p_Manip->p_Hmct); if (p_Manip->h_Spinlock) - { - XX_FreeSpinlock(p_Manip->h_Spinlock); - p_Manip->h_Spinlock = NULL; - } + { + XX_FreeSpinlock(p_Manip->h_Spinlock); + p_Manip->h_Spinlock = NULL; + } ReleaseManipHandler(p_Manip, p_Manip->h_FmPcd); @@ -4158,9 +5391,10 @@ t_Error FM_PCD_ManipNodeDelete(t_Handle h_ManipNode) return E_OK; } -t_Error FM_PCD_ManipGetStatistics(t_Handle h_ManipNode, t_FmPcdManipStats *p_FmPcdManipStats) +t_Error FM_PCD_ManipGetStatistics(t_Handle h_ManipNode, + t_FmPcdManipStats *p_FmPcdManipStats) { - t_FmPcdManip *p_Manip = (t_FmPcdManip *)h_ManipNode; + t_FmPcdManip *p_Manip = (t_FmPcdManip *)h_ManipNode; SANITY_CHECK_RETURN_ERROR(p_Manip, E_INVALID_HANDLE); SANITY_CHECK_RETURN_ERROR(p_FmPcdManipStats, E_NULL_POINTER); @@ -4168,51 +5402,59 @@ t_Error FM_PCD_ManipGetStatistics(t_Handle h_ManipNode, t_FmPcdManipStats *p_FmP switch (p_Manip->opcode) { case (HMAN_OC_IP_REASSEMBLY): - return IpReassemblyStats(p_Manip, &p_FmPcdManipStats->u.reassem.u.ipReassem); - case (HMAN_OC_IP_FRAGMENTATION): - return IpFragmentationStats(p_Manip, &p_FmPcdManipStats->u.frag.u.ipFrag); - default: - RETURN_ERROR(MAJOR, E_NOT_SUPPORTED, ("no statistics to this type of manip")); + return IpReassemblyStats(p_Manip, + &p_FmPcdManipStats->u.reassem.u.ipReassem); + case (HMAN_OC_IP_FRAGMENTATION): + return IpFragmentationStats(p_Manip, + &p_FmPcdManipStats->u.frag.u.ipFrag); +#if (DPAA_VERSION >= 11) + case (HMAN_OC_CAPWAP_REASSEMBLY): + return CapwapReassemblyStats( + p_Manip, &p_FmPcdManipStats->u.reassem.u.capwapReassem); +#endif /* (DPAA_VERSION >= 11) */ + default: + RETURN_ERROR(MAJOR, E_NOT_SUPPORTED, + ("no statistics to this type of manip")); } return E_OK; } -#ifdef FM_CAPWAP_SUPPORT +#if (defined(FM_CAPWAP_SUPPORT) && (DPAA_VERSION == 10)) t_Handle FM_PCD_StatisticsSetNode(t_Handle h_FmPcd, t_FmPcdStatsParams *p_StatsParams) { - t_FmPcd *p_FmPcd = (t_FmPcd *)h_FmPcd; - t_FmPcdManip *p_Manip; - t_Error err; + t_FmPcd *p_FmPcd = (t_FmPcd *)h_FmPcd; + t_FmPcdManip *p_Manip; + t_Error err; SANITY_CHECK_RETURN_VALUE(h_FmPcd,E_INVALID_HANDLE,NULL); SANITY_CHECK_RETURN_VALUE(p_StatsParams,E_INVALID_HANDLE,NULL); - p_Manip = ManipOrStatsSetNode(h_FmPcd, (t_Handle)p_StatsParams, TRUE); + p_Manip = ManipOrStatsSetNode(h_FmPcd, (t_Handle)p_StatsParams, TRUE); if (!p_Manip) - return NULL; + return NULL; - switch (p_Manip->opcode) - { + switch (p_Manip->opcode) + { case (HMAN_OC_CAPWAP_INDEXED_STATS): - /* Indexed statistics */ - err = IndxStats(p_StatsParams, p_Manip, p_FmPcd); - break; + /* Indexed statistics */ + err = IndxStats(p_StatsParams, p_Manip, p_FmPcd); + break; default: - REPORT_ERROR(MAJOR, E_INVALID_VALUE, ("UNSUPPORTED Statistics type")); - ReleaseManipHandler(p_Manip, p_FmPcd); - XX_Free(p_Manip); - return NULL; - } + REPORT_ERROR(MAJOR, E_INVALID_VALUE, ("UNSUPPORTED Statistics type")); + ReleaseManipHandler(p_Manip, p_FmPcd); + XX_Free(p_Manip); + return NULL; + } - if (err) - { - REPORT_ERROR(MAJOR, err, NO_MSG); - ReleaseManipHandler(p_Manip, p_FmPcd); - XX_Free(p_Manip); - return NULL; - } + if (err) + { + REPORT_ERROR(MAJOR, err, NO_MSG); + ReleaseManipHandler(p_Manip, p_FmPcd); + XX_Free(p_Manip); + return NULL; + } - return p_Manip; + return p_Manip; } -#endif /* FM_CAPWAP_SUPPORT */ +#endif /* (defined(FM_CAPWAP_SUPPORT) && (DPAA_VERSION == 10)) */ |