2021-08-31 11:00:09 +00:00
/*
* Copyright 2008 - 2012 Freescale Semiconductor Inc .
2017-04-21 10:43:26 +00:00
*
* Redistribution and use in source and binary forms , with or without
* modification , are permitted provided that the following conditions are met :
* * Redistributions of source code must retain the above copyright
* notice , this list of conditions and the following disclaimer .
* * Redistributions in binary form must reproduce the above copyright
* notice , this list of conditions and the following disclaimer in the
* documentation and / or other materials provided with the distribution .
* * Neither the name of Freescale Semiconductor nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission .
*
*
* ALTERNATIVELY , this software may be distributed under the terms of the
* GNU General Public License ( " GPL " ) as published by the Free Software
* Foundation , either version 2 of that License or ( at your option ) any
* later version .
*
* THIS SOFTWARE IS PROVIDED BY Freescale Semiconductor ` ` AS IS ' ' AND ANY
* EXPRESS OR IMPLIED WARRANTIES , INCLUDING , BUT NOT LIMITED TO , THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED . IN NO EVENT SHALL Freescale Semiconductor BE LIABLE FOR ANY
* DIRECT , INDIRECT , INCIDENTAL , SPECIAL , EXEMPLARY , OR CONSEQUENTIAL DAMAGES
* ( INCLUDING , BUT NOT LIMITED TO , PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES ;
* LOSS OF USE , DATA , OR PROFITS ; OR BUSINESS INTERRUPTION ) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY , WHETHER IN CONTRACT , STRICT LIABILITY , OR TORT
* ( INCLUDING NEGLIGENCE OR OTHERWISE ) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE , EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE .
*/
2021-08-31 11:00:09 +00:00
2017-04-21 10:43:26 +00:00
/******************************************************************************
@ File fm_manip . c
@ Description FM PCD manip . . .
2021-08-31 11:00:09 +00:00
*/ /***************************************************************************/
2017-04-21 10:43:26 +00:00
# include "std_ext.h"
# include "error_ext.h"
# include "string_ext.h"
# include "debug_ext.h"
# include "fm_pcd_ext.h"
2021-08-31 11:00:09 +00:00
# include "fm_port_ext.h"
2017-04-21 10:43:26 +00:00
# include "fm_muram_ext.h"
# include "memcpy_ext.h"
# include "fm_common.h"
# include "fm_hc.h"
# include "fm_manip.h"
2021-08-31 11:00:09 +00:00
/****************************************/
/* static functions */
/****************************************/
static t_Handle GetManipInfo ( t_FmPcdManip * p_Manip , e_ManipInfo manipInfo )
{
t_FmPcdManip * p_CurManip = p_Manip ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
if ( ! MANIP_IS_UNIFIED ( p_Manip ) )
p_CurManip = p_Manip ;
else
{
/* go to first unified */
while ( MANIP_IS_UNIFIED_NON_FIRST ( p_CurManip ) )
p_CurManip = p_CurManip - > h_PrevManip ;
}
switch ( manipInfo )
{
case ( e_MANIP_HMCT ) :
return p_CurManip - > p_Hmct ;
case ( e_MANIP_HMTD ) :
return p_CurManip - > h_Ad ;
case ( e_MANIP_HANDLER_TABLE_OWNER ) :
return ( t_Handle ) p_CurManip ;
default :
return NULL ;
2017-04-21 10:43:26 +00:00
}
}
2021-08-31 11:00:09 +00:00
static uint16_t GetHmctSize ( t_FmPcdManip * p_Manip )
2017-04-21 10:43:26 +00:00
{
2021-08-31 11:00:09 +00:00
uint16_t size = 0 ;
t_FmPcdManip * p_CurManip = p_Manip ;
if ( ! MANIP_IS_UNIFIED ( p_Manip ) )
return p_Manip - > tableSize ;
/* accumulate sizes, starting with the first node */
while ( MANIP_IS_UNIFIED_NON_FIRST ( p_CurManip ) )
p_CurManip = p_CurManip - > h_PrevManip ;
while ( MANIP_IS_UNIFIED_NON_LAST ( p_CurManip ) )
2017-04-21 10:43:26 +00:00
{
2021-08-31 11:00:09 +00:00
size + = p_CurManip - > tableSize ;
p_CurManip = ( t_FmPcdManip * ) p_CurManip - > h_NextManip ;
2017-04-21 10:43:26 +00:00
}
2021-08-31 11:00:09 +00:00
size + = p_CurManip - > tableSize ; /* add last size */
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
return ( size ) ;
2017-04-21 10:43:26 +00:00
}
2021-08-31 11:00:09 +00:00
static uint16_t GetDataSize ( t_FmPcdManip * p_Manip )
2017-04-21 10:43:26 +00:00
{
2021-08-31 11:00:09 +00:00
uint16_t size = 0 ;
t_FmPcdManip * p_CurManip = p_Manip ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
if ( ! MANIP_IS_UNIFIED ( p_Manip ) )
return p_Manip - > dataSize ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
/* accumulate sizes, starting with the first node */
while ( MANIP_IS_UNIFIED_NON_FIRST ( p_CurManip ) )
p_CurManip = p_CurManip - > h_PrevManip ;
while ( MANIP_IS_UNIFIED_NON_LAST ( p_CurManip ) )
{
size + = p_CurManip - > dataSize ;
p_CurManip = ( t_FmPcdManip * ) p_CurManip - > h_NextManip ;
}
size + = p_CurManip - > dataSize ; /* add last size */
return ( size ) ;
2017-04-21 10:43:26 +00:00
}
2021-08-31 11:00:09 +00:00
static t_Error CalculateTableSize ( t_FmPcdManipParams * p_FmPcdManipParams ,
uint16_t * p_TableSize , uint8_t * p_DataSize )
2017-04-21 10:43:26 +00:00
{
2021-08-31 11:00:09 +00:00
uint8_t localDataSize , remain , tableSize = 0 , dataSize = 0 ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
if ( p_FmPcdManipParams - > u . hdr . rmv )
2017-04-21 10:43:26 +00:00
{
2021-08-31 11:00:09 +00:00
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 ) :
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 " ) ) ;
}
}
if ( p_FmPcdManipParams - > u . hdr . insrt )
{
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 ) ;
if ( remain )
localDataSize =
( uint8_t ) ( p_FmPcdManipParams - > u . hdr . insrtParams . u . generic . size
+ 4 - remain ) ;
else
localDataSize =
p_FmPcdManipParams - > u . hdr . insrtParams . u . generic . size ;
tableSize + = ( uint8_t ) ( HMCD_BASIC_SIZE + localDataSize ) ;
break ;
case ( e_FM_PCD_MANIP_INSRT_BY_HDR ) :
2017-04-21 10:43:26 +00:00
{
2021-08-31 11:00:09 +00:00
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 ) :
case ( e_FM_PCD_MANIP_HDR_INSRT_PPPOE ) :
dataSize + =
p_FmPcdManipParams - > u . hdr . insrtParams . u . byHdr . u . specificL2Params . size ;
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 " ) ) ;
}
2017-04-21 10:43:26 +00:00
}
2021-08-31 11:00:09 +00:00
break ;
default :
RETURN_ERROR ( MINOR , E_INVALID_SELECTION ,
( " Unknown insrtParams.type " ) ) ;
}
}
if ( p_FmPcdManipParams - > u . hdr . fieldUpdate )
{
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 )
2017-04-21 10:43:26 +00:00
{
2021-08-31 11:00:09 +00:00
tableSize + = HMCD_PTR_SIZE ;
dataSize + = DSCP_TO_VLAN_TABLE_SIZE ;
2017-04-21 10:43:26 +00:00
}
2021-08-31 11:00:09 +00:00
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 )
2017-04-21 10:43:26 +00:00
{
2021-08-31 11:00:09 +00:00
tableSize + = HMCD_PARAM_SIZE ;
dataSize + = 2 ;
2017-04-21 10:43:26 +00:00
}
2021-08-31 11:00:09 +00:00
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 )
tableSize + = HMCD_IPV4_ADDR_SIZE ;
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 )
tableSize + = HMCD_IPV6_ADDR_SIZE ;
if ( p_FmPcdManipParams - > u . hdr . fieldUpdateParams . u . ipv4 . validUpdates
& HDR_MANIP_IPV6_DST )
tableSize + = HMCD_IPV6_ADDR_SIZE ;
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 )
/* 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 ;
default :
RETURN_ERROR ( MINOR , E_INVALID_SELECTION ,
( " Unknown fieldUpdateParams.type " ) ) ;
}
}
if ( p_FmPcdManipParams - > u . hdr . custom )
{
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 + = 2 ;
2017-04-21 10:43:26 +00:00
}
2021-08-31 11:00:09 +00:00
break ;
case ( e_FM_PCD_MANIP_HDR_CUSTOM_GEN_FIELD_REPLACE ) :
tableSize + = HMCD_BASIC_SIZE + HMCD_PARAM_SIZE ;
2017-04-21 10:43:26 +00:00
break ;
2021-08-31 11:00:09 +00:00
default :
RETURN_ERROR ( MINOR , E_INVALID_SELECTION ,
( " Unknown customParams.type " ) ) ;
}
2017-04-21 10:43:26 +00:00
}
2021-08-31 11:00:09 +00:00
* p_TableSize = tableSize ;
* p_DataSize = dataSize ;
2017-04-21 10:43:26 +00:00
return E_OK ;
}
2021-08-31 11:00:09 +00:00
static t_Error GetPrOffsetByHeaderOrField ( t_FmManipHdrInfo * p_HdrInfo ,
uint8_t * parseArrayOffset )
2017-04-21 10:43:26 +00:00
{
2021-08-31 11:00:09 +00:00
e_NetHeaderType hdr = p_HdrInfo - > hdr ;
e_FmPcdHdrIndex hdrIndex = p_HdrInfo - > hdrIndex ;
bool byField = p_HdrInfo - > byField ;
t_FmPcdFields field ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
if ( byField )
field = p_HdrInfo - > fullField ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
if ( byField )
2017-04-21 10:43:26 +00:00
{
2021-08-31 11:00:09 +00:00
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 " ) ) ;
}
2017-04-21 10:43:26 +00:00
}
2021-08-31 11:00:09 +00:00
else
2017-04-21 10:43:26 +00:00
{
2021-08-31 11:00:09 +00:00
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 " ) ) ;
}
2017-04-21 10:43:26 +00:00
}
return E_OK ;
}
2021-08-31 11:00:09 +00:00
static t_Error BuildHmct ( t_FmPcdManip * p_Manip ,
t_FmPcdManipParams * p_FmPcdManipParams ,
uint8_t * p_DestHmct , uint8_t * p_DestData , bool new )
2017-04-21 10:43:26 +00:00
{
2021-08-31 11:00:09 +00:00
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 )
{
/* 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 ;
}
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 ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
/* initialize HMCD */
tmpReg = ( uint32_t ) ( HMCD_OPCODE_L2_RMV ) < < HMCD_OC_SHIFT ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
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 ;
case ( e_FM_PCD_MANIP_HDR_RMV_PPPOE ) :
hmcdOpt = HMCD_RMV_L2_PPPOE ;
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 ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
tmpReg = ( uint32_t ) ( HMCD_OPCODE_RMV_TILL )
< < HMCD_OC_SHIFT ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
err =
GetPrOffsetByHeaderOrField (
& p_FmPcdManipParams - > u . hdr . rmvParams . u . byHdr . u . hdrInfo ,
& prsArrayOffset ) ;
ASSERT_COND ( ! err ) ;
/* was previously checked */
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
tmpReg | = ( ( uint32_t ) prsArrayOffset < < 16 ) ;
}
break ;
# endif /* (DPAA_VERSION >= 11) */
default :
RETURN_ERROR ( MINOR , E_NOT_SUPPORTED ,
( " manip header remove by hdr type! " ) ) ;
}
}
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
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 ;
2017-04-21 10:43:26 +00:00
}
2021-08-31 11:00:09 +00:00
if ( p_FmPcdManipParams - > u . hdr . insrt )
{
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 ;
else
tmpReg = ( uint32_t ) ( HMCD_OPCODE_GENERIC_INSRT ) < < HMCD_OC_SHIFT ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
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 ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
size = p_FmPcdManipParams - > u . hdr . insrtParams . u . generic . size ;
p_UsrData = p_FmPcdManipParams - > u . hdr . insrtParams . u . generic . p_Data ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
WRITE_UINT32 ( * p_TmpHmct , tmpReg ) ;
/* save a pointer to the "last" indication word */
p_Last = p_TmpHmct ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
p_TmpHmct + = HMCD_BASIC_SIZE / 4 ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
/* initialize data to be inserted */
/* if size is not a multiple of 4, padd with 0's */
origSize = size ;
remain = ( uint8_t ) ( size % 4 ) ;
if ( remain )
{
size + = ( uint8_t ) ( 4 - remain ) ;
p_LocalData = ( uint32_t * ) XX_Malloc ( size ) ;
memset ( ( uint8_t * ) p_LocalData , 0 , size ) ;
memcpy ( ( uint8_t * ) p_LocalData , p_UsrData , origSize ) ;
}
else
p_LocalData = ( uint32_t * ) p_UsrData ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
/* initialize data and advance pointer to next command */
MemCpy8 ( p_TmpHmct , p_LocalData , size ) ;
p_TmpHmct + = size / sizeof ( uint32_t ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
if ( remain )
XX_Free ( p_LocalData ) ;
}
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
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 ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
/* initialize HMCD */
tmpReg = ( uint32_t ) ( HMCD_OPCODE_L2_INSRT )
< < HMCD_OC_SHIFT ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
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 ;
case ( e_FM_PCD_MANIP_HDR_INSRT_PPPOE ) :
hmcdOpt = HMCD_INSRT_L2_PPPOE ;
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 ) ;
MemCpy8 (
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 ) ;
if ( p_FmPcdManipParams - > u . hdr . insrtParams . u . byHdr . u . ipParams . dontFragOverwrite )
tmpReg | = HMCD_IP_DF_MODE ;
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 ;
WRITE_UINT8 ( * p_TmpHmct , p_FmPcdManipParams - > u . hdr . insrtParams . u . byHdr . u . ipParams . lastDstOffset ) ;
p_TmpHmct + = HMCD_PARAM_SIZE / 4 ;
MemCpy8 (
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 ;
MemCpy8 (
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 ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
WRITE_UINT32 ( * p_TmpHmct , tmpReg ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
/* save a pointer to the "last" indication word */
p_Last = p_TmpHmct ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
p_TmpHmct + = HMCD_BASIC_SIZE / 4 ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
MemCpy8 (
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! " ) ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
}
}
}
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
if ( p_FmPcdManipParams - > u . hdr . fieldUpdate )
2017-04-21 10:43:26 +00:00
{
2021-08-31 11:00:09 +00:00
switch ( p_FmPcdManipParams - > u . hdr . fieldUpdateParams . type )
2017-04-21 10:43:26 +00:00
{
2021-08-31 11:00:09 +00:00
case ( e_FM_PCD_MANIP_HDR_FIELD_UPDATE_VLAN ) :
/* set opcode */
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 )
{
/* set Mode */
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 ;
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 ;
tmpReg = 0 ;
ASSERT_COND ( p_TmpData ) ;
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 ) ) ;
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 )
{
WRITE_UINT32 ( * ( ( uint32_t * ) p_TmpData + ( i + 1 ) / 8 - 1 ) ,
tmpReg ) ;
tmpReg = 0 ;
j = 0 ;
}
}
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
WRITE_UINT32 (
* p_TmpHmct ,
( uint32_t ) ( XX_VirtToPhys ( p_TmpData ) - ( ( ( t_FmPcd * ) h_FmPcd ) - > physicalMuramBase ) ) ) ;
p_TmpHmct + = HMCD_PTR_SIZE / 4 ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
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 ;
}
break ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
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 )
tmpReg | = HMCD_IPV4_UPDATE_TTL ;
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 ;
}
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 )
tmpReg | = HMCD_IPV4_UPDATE_SRC ;
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 ;
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 ) ) ) ;
p_TmpData + = 2 ;
p_TmpHmct + = HMCD_PTR_SIZE / 4 ;
}
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
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 ;
}
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
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 ;
}
break ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
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 )
tmpReg | = HMCD_IPV6_UPDATE_HL ;
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 ;
}
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 )
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 )
{
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 )
{
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 ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
case ( e_FM_PCD_MANIP_HDR_FIELD_UPDATE_TCP_UDP ) :
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 ;
/* 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 ;
}
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 ;
/* 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 ;
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 ) ;
WRITE_UINT32 ( * p_TmpHmct , tmpReg ) ;
p_TmpHmct + = HMCD_PTR_SIZE / 4 ;
}
break ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
default :
RETURN_ERROR ( MINOR , E_INVALID_SELECTION ,
( " Unknown fieldUpdateParams.type " ) ) ;
}
}
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
if ( p_FmPcdManipParams - > u . hdr . custom )
{
switch ( p_FmPcdManipParams - > u . hdr . customParams . type )
{
case ( e_FM_PCD_MANIP_HDR_CUSTOM_IP_REPLACE ) :
/* set opcode */
tmpReg = ( uint32_t ) ( HMCD_OPCODE_REPLACE_IP ) < < HMCD_OC_SHIFT ;
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 )
/* 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. " ) ) ;
/* 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 ;
size =
p_FmPcdManipParams - > u . hdr . customParams . u . ipHdrReplace . hdrSize ;
ASSERT_COND ( p_TmpData ) ;
MemCpy8 (
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 ) ) ;
WRITE_UINT32 ( * p_TmpHmct , tmpReg ) ;
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 ) )
{
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 ;
case ( e_FM_PCD_MANIP_HDR_CUSTOM_GEN_FIELD_REPLACE ) :
/* set opcode */
tmpReg = ( uint32_t ) ( HMCD_OPCODE_GEN_FIELD_REPLACE ) < < HMCD_OC_SHIFT ;
tmpReg | = p_FmPcdManipParams - > u . hdr . customParams . u . genFieldReplace . size < < HMCD_GEN_FIELD_SIZE_SHIFT ;
tmpReg | = p_FmPcdManipParams - > u . hdr . customParams . u . genFieldReplace . srcOffset < < HMCD_GEN_FIELD_SRC_OFF_SHIFT ;
tmpReg | = p_FmPcdManipParams - > u . hdr . customParams . u . genFieldReplace . dstOffset < < HMCD_GEN_FIELD_DST_OFF_SHIFT ;
if ( p_FmPcdManipParams - > u . hdr . customParams . u . genFieldReplace . mask )
tmpReg | = HMCD_GEN_FIELD_MASK_EN ;
/* 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 . customParams . u . genFieldReplace . mask )
{
tmpReg = p_FmPcdManipParams - > u . hdr . customParams . u . genFieldReplace . mask < < HMCD_GEN_FIELD_MASK_SHIFT ;
tmpReg | = p_FmPcdManipParams - > u . hdr . customParams . u . genFieldReplace . maskOffset < < HMCD_GEN_FIELD_MASK_OFF_SHIFT ;
/* write the next 4 bytes of the descriptor */
WRITE_UINT32 ( * p_TmpHmct , tmpReg ) ;
}
p_TmpHmct + = HMCD_PARAM_SIZE / 4 ;
break ;
default :
RETURN_ERROR ( MINOR , E_INVALID_SELECTION ,
( " Unknown customParams.type " ) ) ;
}
}
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
/* If this node has a nextManip, and no parsing is required, the old table must be copied to the new table
the old table and should be freed */
if ( p_FmPcdManipParams - > h_NextManip
& & ( p_Manip - > nextManipType = = e_FM_PCD_MANIP_HDR )
& & ( MANIP_DONT_REPARSE ( p_Manip ) ) )
{
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 */
MANIP_UPDATE_UNIFIED_POSITION ( p_FmPcdManipParams - > h_NextManip ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
p_Manip - > unifiedPosition = e_MANIP_UNIFIED_FIRST ;
}
}
else
{
ASSERT_COND ( p_Last ) ;
/* set the "last" indication on the last command of the current table */
WRITE_UINT32 ( * p_Last , GET_UINT32 ( * p_Last ) | HMCD_LAST ) ;
}
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
return E_OK ;
}
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
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 ;
/* set Manip structure */
p_Manip - > dontParseAfterManip =
p_FmPcdManipParams - > u . hdr . dontParseAfterManip ;
if ( p_FmPcdManipParams - > h_NextManip )
{ /* Next Header manipulation exists */
p_Manip - > nextManipType = MANIP_GET_TYPE ( p_FmPcdManipParams - > h_NextManip ) ;
if ( ( p_Manip - > nextManipType = = e_FM_PCD_MANIP_HDR ) & & p_Manip - > dontParseAfterManip )
nextSize = ( uint32_t ) ( GetHmctSize ( p_FmPcdManipParams - > h_NextManip )
+ GetDataSize ( p_FmPcdManipParams - > h_NextManip ) ) ;
else /* either parsing is required or next manip is Frag; no table merging. */
p_Manip - > cascaded = TRUE ;
/* pass up the "cascaded" attribute. The whole chain is cascaded
* if something is cascaded along the way . */
if ( MANIP_IS_CASCADED ( p_FmPcdManipParams - > h_NextManip ) )
p_Manip - > cascaded = TRUE ;
}
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
/* Allocate new table */
/* calculate table size according to manip parameters */
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 ) ;
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 ) ) ;
/* 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 ) |
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
*/
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 " ) ) ;
}
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
if ( p_FmPcdManipParams - > h_NextManip
& & ( p_Manip - > nextManipType = = e_FM_PCD_MANIP_HDR )
& & ( MANIP_DONT_REPARSE ( p_Manip ) ) )
{
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) */
while ( MANIP_IS_UNIFIED_NON_LAST ( p_CurManip ) )
p_CurManip = p_CurManip - > h_NextManip ;
while ( p_CurManip )
{
/* 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 ) ) ) ) ;
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 ) ) ) ) ;
else
p_TmpDataPtr = NULL ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
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 ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
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 ) ;
}
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
/* Fill table */
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 ) ;
RETURN_ERROR ( MINOR , err , NO_MSG ) ;
}
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
/* Build HMTD (table descriptor) */
tmpReg = HMTD_CFG_TYPE ; /* NADEN = 0 */
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
/* add parseAfterManip */
if ( ! p_Manip - > dontParseAfterManip )
tmpReg | = HMTD_CFG_PRS_AFTER_HM ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
/* create cascade */
/*if (p_FmPcdManipParams->h_NextManip
& & ( ! MANIP_DONT_REPARSE ( p_Manip ) | | ( p_Manip - > nextManipType ! = e_FM_PCD_MANIP_HDR ) ) ) */
if ( p_Manip - > cascaded )
{
uint16_t nextAd ;
/* indicate that there's another HM table descriptor */
tmpReg | = HMTD_CFG_NEXT_AD_EN ;
/* get address of next HMTD (table descriptor; h_Ad).
* If the next HMTD was removed due to table unifing , get the address
* of the " next next " as written in the h_Ad of the next h_Manip node .
*/
if ( p_Manip - > unifiedPosition ! = e_MANIP_UNIFIED_FIRST )
nextAd = ( uint16_t ) ( ( uint32_t ) ( XX_VirtToPhys ( MANIP_GET_HMTD_PTR ( p_FmPcdManipParams - > h_NextManip ) ) - ( ( ( t_FmPcd * ) p_Manip - > h_FmPcd ) - > physicalMuramBase ) ) > > 4 ) ;
else
nextAd = ( ( t_Hmtd * ) ( ( t_FmPcdManip * ) p_FmPcdManipParams - > h_NextManip ) - > h_Ad ) - > nextAdIdx ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
WRITE_UINT16 ( ( ( t_Hmtd * ) p_Manip - > h_Ad ) - > nextAdIdx , nextAd ) ;
}
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
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 ) ) ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
WRITE_UINT8 ( ( ( t_Hmtd * ) p_Manip - > h_Ad ) - > opCode , HMAN_OC ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
if ( 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 ) ;
else
XX_Free ( ( ( t_FmPcdManip * ) p_FmPcdManipParams - > h_NextManip ) - > h_Ad ) ;
( ( t_FmPcdManip * ) p_FmPcdManipParams - > h_NextManip ) - > h_Ad = NULL ;
}
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
return E_OK ;
}
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
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 ;
err = CalculateTableSize ( p_FmPcdManipParams , & newSize , & newDataSize ) ;
if ( err )
RETURN_ERROR ( MINOR , err , NO_MSG ) ;
/* 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). " ) ) ;
if ( newDataSize > p_Manip - > dataSize )
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. " ) ) ;
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. " ) ) ;
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 ) ) ) ;
BuildHmct ( p_Manip , p_FmPcdManipParams , p_TmpHmctPtr , p_Manip - > p_Data ,
FALSE ) ;
2017-04-21 10:43:26 +00:00
}
2021-08-31 11:00:09 +00:00
else
2017-04-21 10:43:26 +00:00
{
2021-08-31 11:00:09 +00:00
p_WholeHmct = ( uint8_t * ) GetManipInfo ( p_Manip , e_MANIP_HMCT ) ;
ASSERT_COND ( p_WholeHmct ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
/* 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 ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
while ( p_CurManip )
2017-04-21 10:43:26 +00:00
{
2021-08-31 11:00:09 +00:00
/* If this is a non-head node in a unified table, point to the part of the shadow
* which is the relative offset in HMCT .
* 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 ) ) ) ;
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 ) ) ) ;
BuildHmct ( p_CurManip , & p_CurManip - > manipParams , p_TmpHmctPtr ,
p_TmpDataPtr , FALSE ) ;
p_CurManip = p_CurManip - > h_PrevManip ;
2017-04-21 10:43:26 +00:00
}
}
return E_OK ;
}
2021-08-31 11:00:09 +00:00
static t_Error CreateManipActionBackToOrig (
t_FmPcdManip * p_Manip , t_FmPcdManipParams * p_FmPcdManipParams )
2017-04-21 10:43:26 +00:00
{
2021-08-31 11:00:09 +00:00
uint8_t * p_WholeHmct = NULL , * p_TmpHmctPtr , * p_TmpDataPtr ;
t_FmPcdManip * p_CurManip = p_Manip ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
/* 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 ) ;
else
2017-04-21 10:43:26 +00:00
{
2021-08-31 11:00:09 +00:00
p_WholeHmct = ( uint8_t * ) GetManipInfo ( p_Manip , e_MANIP_HMCT ) ;
ASSERT_COND ( p_WholeHmct ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
/* 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 ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
while ( p_CurManip )
{
/* If this is a unified table, point to the part of the table
* which is the relative offset in HMCT .
*/
p_TmpHmctPtr = p_CurManip - > p_Hmct ; /*- (uint32_t)p_WholeHmct*/
p_TmpDataPtr = p_CurManip - > p_Data ; /*- (uint32_t)p_WholeHmct*/
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
BuildHmct ( p_CurManip , & p_CurManip - > manipParams , p_TmpHmctPtr ,
p_TmpDataPtr , FALSE ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
p_CurManip = p_CurManip - > h_PrevManip ;
}
}
2017-04-21 10:43:26 +00:00
return E_OK ;
}
2021-08-31 11:00:09 +00:00
# if (defined(FM_CAPWAP_SUPPORT) && (DPAA_VERSION == 10))
static t_Error UpdateManipIc ( t_Handle h_Manip , uint8_t icOffset )
2017-04-21 10:43:26 +00:00
{
2021-08-31 11:00:09 +00:00
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 ) ;
SANITY_CHECK_RETURN_ERROR ( p_Manip - > h_Ad , E_INVALID_HANDLE ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
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 )
{
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 )
{
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 " ) ; ) ;
}
}
break ;
}
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
return E_OK ;
}
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
static t_Error UpdateInitMvIntFrameHeaderFromFrameToBufferPrefix (
t_Handle h_FmPort , t_FmPcdManip * p_Manip , t_Handle h_Ad , bool validate )
{
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
t_AdOfTypeContLookup * p_Ad = ( t_AdOfTypeContLookup * ) h_Ad ;
t_FmPortGetSetCcParams fmPortGetSetCcParams ;
t_Error err ;
uint32_t tmpReg32 ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
memset ( & fmPortGetSetCcParams , 0 , sizeof ( t_FmPortGetSetCcParams ) ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
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 ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
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 " ) ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
fmPortGetSetCcParams . getCcParams . type = p_Manip - > updateParams ;
fmPortGetSetCcParams . setCcParams . type = UPDATE_PSO ;
fmPortGetSetCcParams . setCcParams . psoSize = 16 ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
err = FmPortGetSetCcParams ( h_FmPort , & fmPortGetSetCcParams ) ;
if ( err )
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 " ) ) ;
# ifdef FM_LOCKUP_ALIGNMENT_ERRATA_FMAN_SW004
ASSERT_COND ( ! ( fmPortGetSetCcParams . getCcParams . prOffset % 16 ) ) ;
# endif
}
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 " ) ) ;
fmPortGetSetCcParams . getCcParams . type = p_Manip - > shadowUpdateParams ;
fmPortGetSetCcParams . setCcParams . type = UPDATE_PSO ;
fmPortGetSetCcParams . setCcParams . psoSize = 16 ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
err = FmPortGetSetCcParams ( h_FmPort , & fmPortGetSetCcParams ) ;
if ( err )
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 " ) ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
}
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
ASSERT_COND ( p_Ad ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
if ( p_Manip - > updateParams & OFFSET_OF_PR )
{
tmpReg32 = 0 ;
tmpReg32 | = fmPortGetSetCcParams . getCcParams . prOffset ;
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 )
{
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 " ) ; ) ;
}
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
return E_OK ;
}
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
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 ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
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 ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
p_Ad = ( t_AdOfTypeContLookup * ) p_Manip - > h_Frag ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
if ( p_Manip - > updateParams )
{
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
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_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 - > capwapFragParams . dataOffset = p_SavedManipParams - > capwapParams . dataOffset ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
tmpReg32 = GET_UINT32 ( p_Ad - > pcAndOffsets ) ;
tmpReg32 | = ( ( uint32_t ) p_Manip - > capwapFragParams . dataOffset < < 16 ) ;
WRITE_UINT32 ( p_Ad - > pcAndOffsets , tmpReg32 ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
p_Manip - > updateParams & = ~ OFFSET_OF_DATA ;
p_Manip - > shadowUpdateParams | = OFFSET_OF_DATA ;
}
else if ( validate )
{
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
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 - > capwapFragParams . dataOffset ! = p_SavedManipParams - > capwapParams . dataOffset )
RETURN_ERROR ( MAJOR , E_INVALID_STATE , ( " this manipulation was updated previousely by different value " ) ) ;
}
2017-04-21 10:43:26 +00:00
return E_OK ;
}
2021-08-31 11:00:09 +00:00
static t_Error UpdateInitCapwapFragmentation ( t_Handle h_FmPort ,
t_FmPcdManip * p_Manip ,
t_Handle h_Ad ,
bool validate ,
t_Handle h_FmTree )
2017-04-21 10:43:26 +00:00
{
2021-08-31 11:00:09 +00:00
t_AdOfTypeContLookup * p_Ad ;
t_FmPortGetSetCcParams fmPortGetSetCcParams ;
t_Error err ;
uint32_t tmpReg32 = 0 ;
t_FmPcdCcSavedManipParams * p_SavedManipParams ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
UNUSED ( h_Ad ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
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 ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
p_Ad = ( t_AdOfTypeContLookup * ) p_Manip - > h_Frag ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
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 " ) ) ;
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 ;
/* For CAPWAP Rassembly used FMAN_CTRL2 hardcoded - so for fragmentation its better to use FMAN_CTRL1 */
fmPortGetSetCcParams . setCcParams . orFmanCtrl = FPM_PORT_FM_CTL1 ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
err = FmPortGetSetCcParams ( h_FmPort , & fmPortGetSetCcParams ) ;
if ( err )
RETURN_ERROR ( MAJOR , err , NO_MSG ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
if ( fmPortGetSetCcParams . getCcParams . type & OFFSET_OF_DATA )
RETURN_ERROR ( MAJOR , E_INVALID_STATE , ( " Data offset wasn't configured previousely " ) ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
p_SavedManipParams = ( t_FmPcdCcSavedManipParams * ) XX_Malloc ( sizeof ( t_FmPcdCcSavedManipParams ) ) ;
p_SavedManipParams - > capwapParams . dataOffset = fmPortGetSetCcParams . getCcParams . dataOffset ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
# ifdef FM_LOCKUP_ALIGNMENT_ERRATA_FMAN_SW004
ASSERT_COND ( ! ( p_SavedManipParams - > capwapParams . dataOffset % 16 ) ) ;
# endif /* FM_LOCKUP_ALIGNMENT_ERRATA_FMAN_SW004 */
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
FmPcdCcTreeSetSavedManipParams ( h_FmTree , ( t_Handle ) p_SavedManipParams ) ;
2017-04-21 10:43:26 +00:00
}
2021-08-31 11:00:09 +00:00
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 " ) ) ;
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 ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
if ( fmPortGetSetCcParams . getCcParams . type & OFFSET_OF_DATA )
RETURN_ERROR ( MAJOR , E_INVALID_STATE , ( " Data offset wasn't configured previousely " ) ) ;
}
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
if ( p_Manip - > updateParams )
{
tmpReg32 = GET_UINT32 ( p_Ad - > pcAndOffsets ) ;
tmpReg32 | = ( ( uint32_t ) fmPortGetSetCcParams . getCcParams . dataOffset < < 16 ) ;
WRITE_UINT32 ( p_Ad - > pcAndOffsets , tmpReg32 ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
p_Manip - > updateParams & = ~ OFFSET_OF_DATA ;
p_Manip - > shadowUpdateParams | = OFFSET_OF_DATA ;
p_Manip - > capwapFragParams . dataOffset = fmPortGetSetCcParams . getCcParams . dataOffset ;
}
else if ( validate )
{
if ( p_Manip - > capwapFragParams . dataOffset ! = fmPortGetSetCcParams . getCcParams . dataOffset )
RETURN_ERROR ( MAJOR , E_INVALID_STATE , ( " this manipulation was updated previousely by different value " ) ) ;
}
2017-04-21 10:43:26 +00:00
return E_OK ;
}
2021-08-31 11:00:09 +00:00
static t_Error UpdateInitCapwapReasm ( t_Handle h_FmPcd ,
t_Handle h_FmPort ,
t_FmPcdManip * p_Manip ,
t_Handle h_Ad ,
bool validate )
2017-04-21 10:43:26 +00:00
{
2021-08-31 11:00:09 +00:00
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 ;
2017-04-21 10:43:26 +00:00
SANITY_CHECK_RETURN_ERROR ( p_Manip , E_INVALID_HANDLE ) ;
2021-08-31 11:00:09 +00:00
SANITY_CHECK_RETURN_ERROR ( p_Manip - > h_Frag , E_INVALID_HANDLE ) ;
2017-04-21 10:43:26 +00:00
SANITY_CHECK_RETURN_ERROR ( ! p_Manip - > frag , E_INVALID_HANDLE ) ;
2021-08-31 11:00:09 +00:00
SANITY_CHECK_RETURN_ERROR ( ( p_Manip - > opcode = = HMAN_OC_CAPWAP_RMV_DTLS_IF_EXIST ) , E_INVALID_STATE ) ;
2017-04-21 10:43:26 +00:00
SANITY_CHECK_RETURN_ERROR ( h_FmPcd , E_INVALID_HANDLE ) ;
SANITY_CHECK_RETURN_ERROR ( p_FmPcd - > h_Hc , E_INVALID_HANDLE ) ;
2021-08-31 11:00:09 +00:00
if ( p_Manip - > h_FmPcd ! = h_FmPcd )
RETURN_ERROR ( MAJOR , E_INVALID_STATE ,
( " handler of PCD previously was initiated by different value " ) ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
UNUSED ( h_Ad ) ;
2017-04-21 10:43:26 +00:00
memset ( & fmPortGetSetCcParams , 0 , sizeof ( t_FmPortGetSetCcParams ) ) ;
2021-08-31 11:00:09 +00:00
p_ReassmTbl = ( t_CapwapReasmPram * ) p_Manip - > h_Frag ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
if ( p_Manip - > updateParams )
2017-04-21 10:43:26 +00:00
{
2021-08-31 11:00:09 +00:00
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 " ) ) ;
2017-04-21 10:43:26 +00:00
fmPortGetSetCcParams . getCcParams . type = p_Manip - > updateParams ;
fmPortGetSetCcParams . setCcParams . type = UPDATE_NIA_PNEN ;
2021-08-31 11:00:09 +00:00
fmPortGetSetCcParams . setCcParams . nia = NIA_FM_CTL_AC_POP_TO_N_STEP | NIA_ENG_FM_CTL ;
2017-04-21 10:43:26 +00:00
err = FmPortGetSetCcParams ( h_FmPort , & fmPortGetSetCcParams ) ;
2021-08-31 11:00:09 +00:00
if ( err )
RETURN_ERROR ( MAJOR , err , NO_MSG ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
if ( fmPortGetSetCcParams . getCcParams . type & NUM_OF_TASKS )
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 " ) ) ;
if ( fmPortGetSetCcParams . getCcParams . type & HW_PORT_ID )
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 */
2017-04-21 10:43:26 +00:00
}
else if ( validate )
{
2021-08-31 11:00:09 +00:00
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 " ) ) ;
2017-04-21 10:43:26 +00:00
fmPortGetSetCcParams . getCcParams . type = p_Manip - > shadowUpdateParams ;
fmPortGetSetCcParams . setCcParams . type = UPDATE_NIA_PNEN ;
2021-08-31 11:00:09 +00:00
fmPortGetSetCcParams . setCcParams . nia = NIA_FM_CTL_AC_POP_TO_N_STEP | NIA_ENG_FM_CTL ;
2017-04-21 10:43:26 +00:00
err = FmPortGetSetCcParams ( h_FmPort , & fmPortGetSetCcParams ) ;
2021-08-31 11:00:09 +00:00
if ( err )
RETURN_ERROR ( MAJOR , err , NO_MSG ) ;
if ( fmPortGetSetCcParams . getCcParams . type & NUM_OF_TASKS )
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 " ) ) ;
if ( fmPortGetSetCcParams . getCcParams . type & HW_PORT_ID )
RETURN_ERROR ( MAJOR , E_INVALID_STATE , ( " hwPortId wasn't updated " ) ) ;
2017-04-21 10:43:26 +00:00
}
2021-08-31 11:00:09 +00:00
if ( p_Manip - > updateParams )
2017-04-21 10:43:26 +00:00
{
2021-08-31 11:00:09 +00:00
if ( p_Manip - > updateParams & NUM_OF_TASKS )
2017-04-21 10:43:26 +00:00
{
2021-08-31 11:00:09 +00:00
/*recommendation of Microcode team - (maxNumFramesInProcess * 2) */
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 " ) ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
p_Manip - > capwapFragParams . numOfTasks = fmPortGetSetCcParams . getCcParams . numOfTasks ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
/*p_ReassmFrmDescrIndxPoolTbl*/
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 " ) ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
MemSet8 ( p_Manip - > capwapFragParams . p_ReassmFrmDescrIndxPoolTbl , 0 , ( uint32_t ) ( size + 1 ) ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
for ( i = 0 ; i < size ; i + + )
WRITE_UINT8 ( * ( uint8_t * ) PTR_MOVE ( p_Manip - > capwapFragParams . p_ReassmFrmDescrIndxPoolTbl , i ) , ( uint8_t ) ( i + 1 ) ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
tmpReg32 = ( uint32_t ) ( XX_VirtToPhys ( p_Manip - > capwapFragParams . p_ReassmFrmDescrIndxPoolTbl ) - p_FmPcd - > physicalMuramBase ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
WRITE_UINT32 ( p_ReassmTbl - > reasmFrmDescIndexPoolTblPtr , tmpReg32 ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
/*p_ReassmFrmDescrPoolTbl*/
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 ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
if ( ! p_Manip - > capwapFragParams . p_ReassmFrmDescrPoolTbl )
RETURN_ERROR ( MAJOR , E_NO_MEMORY , ( " MURAM alloc for CAPWAP Reassembly frame buffer pool table " ) ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
MemSet8 ( p_Manip - > capwapFragParams . p_ReassmFrmDescrPoolTbl , 0 , ( uint32_t ) ( ( size + 1 ) * FM_PCD_MANIP_CAPWAP_REASM_RFD_SIZE ) ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
tmpReg32 = ( uint32_t ) ( XX_VirtToPhys ( p_Manip - > capwapFragParams . p_ReassmFrmDescrPoolTbl ) - p_FmPcd - > physicalMuramBase ) ;
WRITE_UINT32 ( p_ReassmTbl - > reasmFrmDescPoolTblPtr , tmpReg32 ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
/*p_TimeOutTbl*/
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
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 ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
if ( ! p_Manip - > capwapFragParams . p_TimeOutTbl )
RETURN_ERROR ( MAJOR , E_NO_MEMORY , ( " MURAM alloc for CAPWAP Reassembly timeout table " ) ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
MemSet8 ( p_Manip - > capwapFragParams . p_TimeOutTbl , 0 , ( uint16_t ) ( ( size + 1 ) * FM_PCD_MANIP_CAPWAP_REASM_TIME_OUT_ENTRY_SIZE ) ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
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 ;
p_Manip - > shadowUpdateParams | = NUM_OF_TASKS ;
2017-04-21 10:43:26 +00:00
}
2021-08-31 11:00:09 +00:00
if ( p_Manip - > updateParams & OFFSET_OF_DATA )
2017-04-21 10:43:26 +00:00
{
2021-08-31 11:00:09 +00:00
p_Manip - > capwapFragParams . dataOffset = fmPortGetSetCcParams . getCcParams . dataOffset ;
tmpReg32 = GET_UINT32 ( p_ReassmTbl - > mode ) ;
tmpReg32 | = p_Manip - > capwapFragParams . dataOffset ;
WRITE_UINT32 ( p_ReassmTbl - > mode , tmpReg32 ) ;
p_Manip - > updateParams & = ~ OFFSET_OF_DATA ;
p_Manip - > shadowUpdateParams | = OFFSET_OF_DATA ;
}
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
if ( ! ( fmPortGetSetCcParams . getCcParams . type & OFFSET_OF_PR ) )
{
p_Manip - > capwapFragParams . prOffset = fmPortGetSetCcParams . getCcParams . prOffset ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
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 - > capwapFragParams . prOffset < < 24 ;
WRITE_UINT32 ( p_ReassmTbl - > intStatsTblPtr , tmpReg32 ) ;
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 ;
2017-04-21 10:43:26 +00:00
}
2021-08-31 11:00:09 +00:00
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 - > 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 ) ;
2017-04-21 10:43:26 +00:00
}
2021-08-31 11:00:09 +00:00
else if ( validate )
2017-04-21 10:43:26 +00:00
{
2021-08-31 11:00:09 +00:00
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 ) )
2017-04-21 10:43:26 +00:00
{
2021-08-31 11:00:09 +00:00
if ( p_Manip - > capwapFragParams . prOffset ! = fmPortGetSetCcParams . getCcParams . prOffset )
RETURN_ERROR ( MAJOR , E_INVALID_VALUE , ( " Parse result offset previously was defined by another value " ) ) ;
2017-04-21 10:43:26 +00:00
}
else
{
2021-08-31 11:00:09 +00:00
if ( p_Manip - > capwapFragParams . prOffset ! = 0xff )
RETURN_ERROR ( MAJOR , E_INVALID_VALUE , ( " Parse result offset previously was defined by another value " ) ) ;
2017-04-21 10:43:26 +00:00
}
2021-08-31 11:00:09 +00:00
if ( fmPortGetSetCcParams . getCcParams . dataOffset ! = p_Manip - > capwapFragParams . dataOffset )
RETURN_ERROR ( MAJOR , E_INVALID_VALUE , ( " Data offset previously was defined by another value " ) ) ;
2017-04-21 10:43:26 +00:00
}
return E_OK ;
}
2021-08-31 11:00:09 +00:00
# endif /* (defined(FM_CAPWAP_SUPPORT) && (DPAA_VERSION == 10)) */
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
t_Error FmPcdRegisterReassmPort ( t_Handle h_FmPcd , t_Handle h_ReasmCommonPramTbl )
{
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_ReasmCommonPramTbl ) ;
bitFor1Micro = FmGetTimeStampScale ( p_FmPcd - > h_Fm ) ;
if ( bitFor1Micro = = 0 )
RETURN_ERROR ( MAJOR , E_NOT_AVAILABLE , ( " Timestamp scale " ) ) ;
bitFor1Micro = 32 - bitFor1Micro ;
LOG2 ( FM_PCD_MANIP_REASM_TIMEOUT_THREAD_THRESH , log2num ) ;
tsbs = bitFor1Micro - log2num ;
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 ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
switch ( result )
2017-04-21 10:43:26 +00:00
{
2021-08-31 11:00:09 +00:00
case ( 0 ) :
return E_OK ;
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 " ) ) ;
case ( 3 ) :
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 ) :
RETURN_ERROR ( MAJOR , E_INVALID_SELECTION , ( " invalid sub command " ) ) ;
default :
RETURN_ERROR ( MAJOR , E_INVALID_VALUE , NO_MSG ) ;
}
return E_OK ;
}
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
static t_Error CreateReassCommonTable ( t_FmPcdManip * p_Manip )
{
uint32_t tmpReg32 = 0 , i , bitFor1Micro ;
uint64_t tmpReg64 , size ;
t_FmPcd * p_FmPcd = ( t_FmPcd * ) p_Manip - > h_FmPcd ;
t_Error err = E_OK ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
bitFor1Micro = FmGetTimeStampScale ( p_FmPcd - > h_Fm ) ;
if ( bitFor1Micro = = 0 )
RETURN_ERROR ( MAJOR , E_NOT_AVAILABLE , ( " Timestamp scale " ) ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
/* 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 ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
if ( ! p_Manip - > reassmParams . p_ReassCommonTbl )
RETURN_ERROR ( MAJOR , E_NO_MEMORY ,
( " MURAM alloc for Reassembly common parameters table " ) ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
MemSet8 ( p_Manip - > reassmParams . p_ReassCommonTbl , 0 ,
FM_PCD_MANIP_REASM_COMMON_PARAM_TABLE_SIZE ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
/* Setting the TimeOut Mode.*/
tmpReg32 = 0 ;
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 - > 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 - > reassmParams . maxNumFramesInProcess + 129 ;
/*Allocation of IP Reassembly Frame Descriptor Indexes Pool - This pool resides in the MURAM */
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 " ) ) ;
MemSet8 ( 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 - > 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 - > 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 - > reassmParams . reassFrmDescrPoolTblAddr =
PTR_TO_UINT ( XX_MallocSmart ( ( uint32_t ) ( size * 64 ) , p_Manip - > reassmParams . dataMemId , 64 ) ) ;
if ( ! p_Manip - > reassmParams . reassFrmDescrPoolTblAddr )
RETURN_ERROR ( MAJOR , E_NO_MEMORY , ( " Memory allocation FAILED " ) ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
MemSet8 ( 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 - > 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 - > reassmParams . timeOutTblAddr =
PTR_TO_UINT ( FM_MURAM_AllocMem ( p_FmPcd - > h_FmMuram , ( uint32_t ) ( size * 8 ) , 8 ) ) ;
if ( ! p_Manip - > reassmParams . timeOutTblAddr )
RETURN_ERROR ( MAJOR , E_NO_MEMORY ,
( " MURAM alloc for Reassembly timeout table " ) ) ;
MemSet8 ( 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 - > reassmParams . timeOutTblAddr ) )
- p_FmPcd - > physicalMuramBase ) ;
WRITE_UINT32 ( p_Manip - > reassmParams . p_ReassCommonTbl - > timeOutTblPtr ,
tmpReg32 ) ;
/* Sets the Expiration Delay */
tmpReg32 = 0 ;
tmpReg32 | = ( ( ( uint32_t ) ( 1 < < bitFor1Micro ) )
* p_Manip - > reassmParams . timeoutThresholdForReassmProcess ) ;
WRITE_UINT32 ( p_Manip - > reassmParams . p_ReassCommonTbl - > expirationDelay ,
tmpReg32 ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
err = FmPcdRegisterReassmPort ( p_FmPcd ,
p_Manip - > reassmParams . p_ReassCommonTbl ) ;
if ( err ! = E_OK )
2017-04-21 10:43:26 +00:00
{
2021-08-31 11:00:09 +00:00
FM_MURAM_FreeMem ( p_FmPcd - > h_FmMuram ,
p_Manip - > reassmParams . p_ReassCommonTbl ) ;
RETURN_ERROR ( MAJOR , err , ( " port registration " ) ) ;
2017-04-21 10:43:26 +00:00
}
2021-08-31 11:00:09 +00:00
return err ;
2017-04-21 10:43:26 +00:00
}
2021-08-31 11:00:09 +00:00
static t_Error CreateReassTable ( t_FmPcdManip * p_Manip , e_NetHeaderType hdr )
2017-04-21 10:43:26 +00:00
{
2021-08-31 11:00:09 +00:00
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 )
2017-04-21 10:43:26 +00:00
{
2021-08-31 11:00:09 +00:00
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 */
2017-04-21 10:43:26 +00:00
break ;
2021-08-31 11:00:09 +00:00
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 " ) ) ;
2017-04-21 10:43:26 +00:00
break ;
2021-08-31 11:00:09 +00:00
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 ;
2017-04-21 10:43:26 +00:00
break ;
default :
2021-08-31 11:00:09 +00:00
RETURN_ERROR ( MAJOR , E_NOT_SUPPORTED , ( " header type " ) ) ;
2017-04-21 10:43:26 +00:00
}
2021-08-31 11:00:09 +00:00
keySize + = 2 ; /* 2 bytes reserved for RFDIndex */
# if (DPAA_VERSION >= 11)
keySize + = 2 ; /* 2 bytes reserved */
# endif /* (DPAA_VERSION >= 11) */
waySize = ROUND_UP ( keySize , 8 ) ;
/* 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 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 ) ;
/* Get set size code */
LOG2 ( setSize , setSizeCode ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
/* Sets ways number and set size code */
WRITE_UINT16 ( ( * p_ReassTbl ) - > waysNumAndSetSize ,
( uint16_t ) ( ( numOfWays < < 8 ) | setSizeCode ) ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
/* 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 . */
numOfEntries = ( uint32_t ) ( p_Manip - > reassmParams . maxNumFramesInProcess * 2 ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
/* sets number calculation - number of entries = number of sets * number of ways */
numOfSets = numOfEntries / numOfWays ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
/* Sets AutoLearnHashKeyMask*/
NEXT_POWER_OF_2 ( numOfSets , numOfSets ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
WRITE_UINT16 ( ( * p_ReassTbl ) - > autoLearnHashKeyMask ,
( uint16_t ) ( numOfSets - 1 ) ) ;
/* 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 - > reassmParams . dataMemId , setSize ) ) ;
if ( ! * p_AutoLearnHashTblAddr )
{
FM_MURAM_FreeMem ( p_FmPcd - > h_FmMuram , * p_ReassTbl ) ;
* p_ReassTbl = NULL ;
RETURN_ERROR ( MAJOR , E_NO_MEMORY , ( " Memory allocation FAILED " ) ) ;
2017-04-21 10:43:26 +00:00
}
2021-08-31 11:00:09 +00:00
MemSet8 ( 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_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 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_ReassTbl ) ;
* p_ReassTbl = NULL ;
XX_FreeSmart ( UINT_TO_PTR ( * p_AutoLearnHashTblAddr ) ) ;
* p_AutoLearnHashTblAddr = 0 ;
RETURN_ERROR ( MAJOR , E_NO_MEMORY , ( " Memory allocation FAILED " ) ) ;
}
MemSet8 ( UINT_TO_PTR ( * p_AutoLearnSetLockTblAddr ) , 0 , ( numOfSets * 4 ) ) ;
/* sets Set Lock table pointer 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_AutoLearnSetLockTblAddr ) ) ;
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_ReassTbl ) - > minFragSize , minFragSize ) ;
WRITE_UINT16 ( ( * p_ReassTbl ) - > maxReassemblySize , maxReassemSize ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
return E_OK ;
2017-04-21 10:43:26 +00:00
}
2021-08-31 11:00:09 +00:00
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 )
2017-04-21 10:43:26 +00:00
{
2021-08-31 11:00:09 +00:00
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 ;
# 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 ) | | ( 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 ) ;
UNUSED ( h_Ad ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
if ( ! p_Manip - > updateParams )
return E_OK ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
if ( p_Manip - > h_FmPcd ! = h_FmPcd )
RETURN_ERROR (
MAJOR , E_INVALID_STATE ,
( " handler of PCD previously was initiated by different value " ) ) ;
if ( p_Manip - > updateParams )
2017-04-21 10:43:26 +00:00
{
2021-08-31 11:00:09 +00:00
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 )
2017-04-21 10:43:26 +00:00
{
2021-08-31 11:00:09 +00:00
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 )
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 " ) ) ;
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 ;
totalNumOfTnums =
( uint8_t ) ( fmPortGetSetCcParams . getCcParams . numOfTasks
+ fmPortGetSetCcParams . getCcParams . numOfExtraTasks ) ;
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 - > reassmParams . internalBufferPoolAddr )
RETURN_ERROR (
MAJOR , E_NO_MEMORY ,
( " MURAM alloc for Reassembly internal buffers pool " ) ) ;
MemSet8 (
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 - > 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_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 - > opcode = = HMAN_OC_CAPWAP_REASSEMBLY )
{
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 + + ;
2017-04-21 10:43:26 +00:00
}
2021-08-31 11:00:09 +00:00
2017-04-21 10:43:26 +00:00
}
else
{
2021-08-31 11:00:09 +00:00
if ( p_Manip - > reassmParams . ip . h_Ipv4Scheme )
{
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 - > reassmParams . ip . h_Ipv6Scheme )
{
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 - > 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 ;
SANITY_CHECK_RETURN_ERROR ( p_FmPcd , E_INVALID_HANDLE ) ;
memset ( & fmPcdCcFragScratchPoolCmdParams , 0 , sizeof ( t_FmPcdCcFragScratchPoolCmdParams ) ) ;
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 ) ;
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 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 ;
SANITY_CHECK_RETURN_ERROR ( p_FmPcd , E_INVALID_HANDLE ) ;
memset ( & fmPcdCcFragScratchPoolCmdParams , 0 , sizeof ( t_FmPcdCcFragScratchPoolCmdParams ) ) ;
fmPcdCcFragScratchPoolCmdParams . bufferPoolId = scratchBpid ;
if ( ( err = FmHcPcdCcIpFragScratchPollCmd ( p_FmPcd - > h_Hc , FALSE , & fmPcdCcFragScratchPoolCmdParams ) ) ! = E_OK )
RETURN_ERROR ( MAJOR , err , NO_MSG ) ;
return E_OK ;
}
# endif /* (DPAA_VERSION == 10) */
static void ReleaseManipHandler ( t_FmPcdManip * p_Manip , t_FmPcd * p_FmPcd )
{
if ( p_Manip - > h_Ad )
{
if ( p_Manip - > muramAllocate )
FM_MURAM_FreeMem ( p_FmPcd - > h_FmMuram , p_Manip - > h_Ad ) ;
else
XX_Free ( p_Manip - > h_Ad ) ;
p_Manip - > h_Ad = NULL ;
}
if ( p_Manip - > p_Template )
{
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 - > 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 - > fragParams . p_Frag )
{
# if (DPAA_VERSION == 10)
FmPcdFragHcScratchPoolEmpty ( ( t_Handle ) p_FmPcd , p_Manip - > fragParams . scratchBpid ) ;
# endif /* (DPAA_VERSION == 10) */
FM_MURAM_FreeMem ( p_FmPcd - > h_FmMuram , p_Manip - > fragParams . p_Frag ) ;
}
}
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 ) ;
}
# 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 )
{
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 ) :
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 " ) ) ;
}
}
2017-04-21 10:43:26 +00:00
break ;
2021-08-31 11:00:09 +00:00
default :
RETURN_ERROR ( MAJOR , E_INVALID_STATE , ( " invalid type of remove manipulation " ) ) ;
}
break ;
2017-04-21 10:43:26 +00:00
default :
2021-08-31 11:00:09 +00:00
RETURN_ERROR ( MAJOR , E_INVALID_STATE , ( " invalid type of remove manipulation " ) ) ;
}
}
else if ( p_ManipParams - > u . hdr . insrt )
{
switch ( p_ManipParams - > u . hdr . insrtParams . type )
{
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 )
{
if ( p_ManipParams - > fragOrReasmParams . frag )
{
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 " ) ) ;
}
}
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 " ) ) ;
}
}
else if ( p_ManipParams - > fragOrReasm )
{
if ( p_ManipParams - > fragOrReasmParams . frag )
{
switch ( p_ManipParams - > fragOrReasmParams . hdr )
{
case ( HEADER_TYPE_CAPWAP ) :
p_Manip - > opcode = HMAN_OC_CAPWAP_FRAGMENTATION ;
p_Manip - > muramAllocate = FALSE ;
break ;
default :
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 " ) ) ;
default :
RETURN_ERROR ( MAJOR , E_INVALID_STATE , ( " Unsupported header for reassembly " ) ) ;
}
}
}
else
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 ;
return E_OK ;
}
# 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 :
/* 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 ) & &
( MANIP_GET_TYPE ( p_ManipParams - > h_NextManip )
! = e_FM_PCD_MANIP_FRAG ) )
RETURN_ERROR (
MAJOR ,
E_NOT_SUPPORTED ,
( " For a Header Manipulation node - no support of h_NextManip of type other than Header Manipulation or Fragmentation. " ) ) ;
}
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 )
{
case ( e_FM_PCD_MANIP_RMV_BY_HDR_SPECIFIC_L2 ) :
break ;
# 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 ) :
break ;
default :
RETURN_ERROR ( MAJOR , E_INVALID_STATE ,
( " invalid type of remove manipulation " ) ) ;
}
p_Manip - > opcode = HMAN_OC ;
p_Manip - > muramAllocate = TRUE ;
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 ) :
{
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 )
{
if ( p_ManipParams - > u . hdr . customParams . type = = e_FM_PCD_MANIP_HDR_CUSTOM_GEN_FIELD_REPLACE )
{
if ( ( p_ManipParams - > u . hdr . customParams . u . genFieldReplace . size = = 0 ) | |
( p_ManipParams - > u . hdr . customParams . u . genFieldReplace . size > 8 ) )
RETURN_ERROR (
MAJOR , E_INVALID_VALUE ,
( " size should get values of 1-8 " ) ) ;
if ( p_ManipParams - > u . hdr . customParams . u . genFieldReplace . srcOffset > 7 )
RETURN_ERROR (
MAJOR , E_INVALID_VALUE ,
( " srcOffset should be <= 7 " ) ) ;
if ( ( p_ManipParams - > u . hdr . customParams . u . genFieldReplace . srcOffset +
p_ManipParams - > u . hdr . customParams . u . genFieldReplace . size ) > 8 )
RETURN_ERROR (
MAJOR , E_INVALID_VALUE ,
( " (srcOffset + size) should be <= 8 " ) ) ;
if ( ( p_ManipParams - > u . hdr . customParams . u . genFieldReplace . dstOffset +
p_ManipParams - > u . hdr . customParams . u . genFieldReplace . size ) > 256 )
RETURN_ERROR (
MAJOR , E_INVALID_VALUE ,
( " (dstOffset + size) should be <= 256 " ) ) ;
}
p_Manip - > opcode = HMAN_OC ;
p_Manip - > muramAllocate = TRUE ;
p_Manip - > custom = TRUE ;
}
break ;
case e_FM_PCD_MANIP_REASSEM :
if ( p_ManipParams - > h_NextManip )
RETURN_ERROR ( MAJOR , E_NOT_SUPPORTED ,
( " next manip with reassembly " ) ) ;
switch ( p_ManipParams - > u . reassem . hdr )
{
case ( HEADER_TYPE_IPv4 ) :
p_Manip - > reassmParams . hdr = HEADER_TYPE_IPv4 ;
p_Manip - > opcode = HMAN_OC_IP_REASSEMBLY ;
break ;
case ( 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 " ) ) ;
}
break ;
case e_FM_PCD_MANIP_FRAG :
if ( p_ManipParams - > h_NextManip )
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 - > muramAllocate = TRUE ;
break ;
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 " ) ) ;
}
break ;
default :
RETURN_ERROR ( MAJOR , E_NOT_SUPPORTED , ( " manip type " ) ) ;
}
return E_OK ;
}
# endif /* not (defined(FM_CAPWAP_SUPPORT) && (DPAA_VERSION == 10)) */
# 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 ;
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 ;
if ( p_Manip - > h_FmPcd ! = h_FmPcd )
RETURN_ERROR ( MAJOR , E_INVALID_STATE ,
( " handler of PCD previously was initiated by different value " ) ) ;
memset ( & fmPortGetSetCcParams , 0 , sizeof ( t_FmPortGetSetCcParams ) ) ;
if ( ! p_Manip - > p_StatsTbl )
{
fmPortGetSetCcParams . setCcParams . type = UPDATE_NIA_PNDN ;
fmPortGetSetCcParams . setCcParams . nia = NIA_FM_CTL_AC_CC ;
err = FmPortGetSetCcParams ( h_FmPort , & fmPortGetSetCcParams ) ;
if ( err )
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 ) ;
if ( ! p_Manip - > p_StatsTbl )
RETURN_ERROR ( MAJOR , E_NO_MEMORY , ( " MURAM alloc for Manipulation indexed statistics table " ) ) ;
MemSet8 ( 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_DPD ;
WRITE_UINT32 ( p_Ad - > ccAdBase , tmpReg32 ) ;
}
else
{
fmPortGetSetCcParams . setCcParams . type = UPDATE_NIA_PNDN ;
fmPortGetSetCcParams . setCcParams . nia = NIA_FM_CTL_AC_CC ;
err = FmPortGetSetCcParams ( h_FmPort , & fmPortGetSetCcParams ) ;
if ( err )
RETURN_ERROR ( MAJOR , err , NO_MSG ) ;
}
return E_OK ;
}
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 ;
SANITY_CHECK_RETURN_ERROR ( p_Manip , E_NULL_POINTER ) ;
SANITY_CHECK_RETURN_ERROR ( p_ManipParams , E_NULL_POINTER ) ;
SANITY_CHECK_RETURN_ERROR ( p_Manip - > h_Ad , E_INVALID_HANDLE ) ;
p_Ad = ( t_AdOfTypeContLookup * ) p_Manip - > h_Ad ;
if ( p_Manip - > rmv )
{
err = GetPrOffsetByHeaderOrField ( & p_ManipParams - > u . byHdr . u . fromStartByHdr . hdrInfo , & prsArrayOffset ) ;
if ( err )
RETURN_ERROR ( MAJOR , err , NO_MSG ) ;
tmpReg32 | = ( uint32_t ) prsArrayOffset < < 24 ;
tmpReg32 | = HMAN_RMV_HDR ;
2017-04-21 10:43:26 +00:00
}
2021-08-31 11:00:09 +00:00
if ( p_Manip - > insrt )
tmpReg32 | = HMAN_INSRT_INT_FRM_HDR ;
tmpReg32 | = ( uint32_t ) HMAN_OC_RMV_N_OR_INSRT_INT_FRM_HDR ;
WRITE_UINT32 ( p_Ad - > pcAndOffsets , tmpReg32 ) ;
tmpReg32 = 0 ;
tmpReg32 | = FM_PCD_AD_CONT_LOOKUP_TYPE ;
WRITE_UINT32 ( p_Ad - > ccAdBase , tmpReg32 ) ;
2017-04-21 10:43:26 +00:00
return E_OK ;
}
2021-08-31 11:00:09 +00:00
static t_Error MvIntFrameHeaderFromFrameToBufferPrefix ( t_FmPcdManip * p_Manip ,
bool caamUsed )
{
t_AdOfTypeContLookup * p_Ad = ( t_AdOfTypeContLookup * ) p_Manip - > h_Ad ;
uint32_t tmpReg32 = 0 ;
SANITY_CHECK_RETURN_ERROR ( p_Ad , E_INVALID_HANDLE ) ;
p_Manip - > updateParams | = OFFSET_OF_PR | INTERNAL_CONTEXT_OFFSET ;
tmpReg32 = 0 ;
tmpReg32 | = FM_PCD_AD_CONT_LOOKUP_TYPE ;
* ( uint32_t * ) & p_Ad - > ccAdBase = tmpReg32 ;
tmpReg32 = 0 ;
tmpReg32 | = HMAN_OC_MV_INT_FRAME_HDR_FROM_FRM_TO_BUFFER_PREFFIX ;
tmpReg32 | = ( uint32_t ) 0x16 < < 16 ;
* ( uint32_t * ) & p_Ad - > pcAndOffsets = tmpReg32 ;
if ( caamUsed )
* ( uint32_t * ) & p_Ad - > gmask = 0xf0000000 ;
return E_OK ;
}
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 ;
SANITY_CHECK_RETURN_ERROR ( p_Manip - > h_Ad , E_INVALID_HANDLE ) ;
p_Ad = ( t_AdOfTypeContLookup * ) p_Manip - > h_Ad ;
tmpReg32 = 0 ;
tmpReg32 | = ( uint32_t ) HMAN_OC_CAPWAP_RMV_DTLS_IF_EXIST ;
WRITE_UINT32 ( p_Ad - > pcAndOffsets , tmpReg32 ) ;
tmpReg32 = 0 ;
tmpReg32 | = FM_PCD_AD_CONT_LOOKUP_TYPE ;
if ( p_Manip - > h_Frag )
{
p_Manip - > updateParams | = INTERNAL_CONTEXT_OFFSET ;
tmpReg32 | = ( uint32_t ) ( XX_VirtToPhys ( p_Manip - > h_Frag ) - ( p_FmPcd - > physicalMuramBase ) ) ;
}
WRITE_UINT32 ( p_Ad - > ccAdBase , tmpReg32 ) ;
return err ;
}
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 ;
uint32_t bitFor1Micro ;
SANITY_CHECK_RETURN_ERROR ( p_Manip - > h_Ad , E_INVALID_HANDLE ) ;
SANITY_CHECK_RETURN_ERROR ( p_FmPcd - > h_Hc , E_INVALID_HANDLE ) ;
if ( ! p_FmPcd - > h_Hc )
RETURN_ERROR ( MAJOR , E_INVALID_VALUE , ( " hc port has to be initialized in this mode " ) ) ;
if ( ! POWER_OF_2 ( p_ManipParams - > timeoutRoutineRequestTime ) )
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 " ) ) ;
if ( ! p_ManipParams - > timeoutRoutineRequestTime & & p_ManipParams - > timeoutThresholdForReassmProcess )
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 " ) ) ;
}
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 " ) ) ;
}
bitFor1Micro = FmGetTimeStampScale ( p_FmPcd - > h_Fm ) ;
if ( bitFor1Micro = = 0 )
RETURN_ERROR ( MAJOR , E_NOT_AVAILABLE , ( " Timestamp scale " ) ) ;
p_Manip - > updateParams | = ( NUM_OF_TASKS | OFFSET_OF_PR | OFFSET_OF_DATA | HW_PORT_ID ) ;
p_Manip - > h_Frag = ( t_Handle ) FM_MURAM_AllocMem ( p_FmPcd - > h_FmMuram ,
FM_PCD_MANIP_CAPWAP_REASM_TABLE_SIZE ,
FM_PCD_MANIP_CAPWAP_REASM_TABLE_ALIGN ) ;
if ( ! p_Manip - > h_Frag )
RETURN_ERROR ( MAJOR , E_NO_MEMORY , ( " MURAM alloc CAPWAP reassembly parameters table " ) ) ;
MemSet8 ( p_Manip - > h_Frag , 0 , FM_PCD_MANIP_CAPWAP_REASM_TABLE_SIZE ) ;
p_Table = ( t_CapwapReasmPram * ) p_Manip - > h_Frag ;
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 ) ;
if ( ! p_Manip - > capwapFragParams . p_AutoLearnHashTbl )
RETURN_ERROR ( MAJOR , E_NO_MEMORY , ( " MURAM alloc for CAPWAP automatic learning hash table " ) ) ;
MemSet8 ( 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 - > 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 ;
if ( p_ManipParams - > haltOnDuplicationFrag )
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 ;
}
else
i = 4 ;
numOfSets = ( uint8_t ) ( ( p_ManipParams - > maxNumFramesInProcess * 2 ) / i ) ;
LOG2 ( numOfSets , log2Num ) ;
tmpReg32 | = ( uint32_t ) ( log2Num - 1 ) < < 24 ;
WRITE_UINT32 ( ( ( t_CapwapReasmPram * ) p_Table ) - > mode , tmpReg32 ) ;
for ( j = 0 ; j < p_ManipParams - > maxNumFramesInProcess * 2 ; j + + )
if ( ( ( j / i ) % 2 ) = = 0 )
WRITE_UINT32 ( * ( uint32_t * ) PTR_MOVE ( p_Manip - > capwapFragParams . p_AutoLearnHashTbl , j * FM_PCD_MANIP_CAPWAP_REASM_AUTO_LEARNING_HASH_ENTRY_SIZE ) , 0x80000000 ) ;
tmpReg32 = 0x00008000 ;
tmpReg32 | = ( uint32_t ) poolId < < 16 ;
WRITE_UINT32 ( ( ( t_CapwapReasmPram * ) p_Table ) - > bufferPoolIdAndRisc1SetIndexes , tmpReg32 ) ;
WRITE_UINT32 ( ( ( t_CapwapReasmPram * ) p_Table ) - > risc23SetIndexes , 0x80008000 ) ;
WRITE_UINT32 ( ( ( t_CapwapReasmPram * ) p_Table ) - > risc4SetIndexesAndExtendedStatsTblPtr , 0x80000000 ) ;
p_Manip - > capwapFragParams . maxNumFramesInProcess = p_ManipParams - > maxNumFramesInProcess ;
p_Manip - > capwapFragParams . sgBpid = poolId ;
p_Manip - > capwapFragParams . fqidForTimeOutFrames = p_ManipParams - > fqidForTimeOutFrames ;
p_Manip - > capwapFragParams . timeoutRoutineRequestTime = p_ManipParams - > timeoutRoutineRequestTime ;
p_Manip - > capwapFragParams . bitFor1Micro = bitFor1Micro ;
tmpReg32 = 0 ;
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 )
{
t_AdOfTypeContLookup * p_Ad ;
uint32_t tmpReg32 = 0 ;
SANITY_CHECK_RETURN_ERROR ( p_Manip - > h_Ad , E_INVALID_HANDLE ) ;
p_Manip - > updateParams | = OFFSET_OF_DATA ;
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 ) ;
if ( ! p_Manip - > h_Frag )
RETURN_ERROR ( MAJOR , E_NO_MEMORY , ( " MURAM alloc for CAPWAP fragmentation table descriptor " ) ) ;
MemSet8 ( p_Manip - > h_Frag , 0 , FM_PCD_CC_AD_ENTRY_SIZE ) ;
p_Ad = ( t_AdOfTypeContLookup * ) p_Manip - > h_Frag ;
tmpReg32 = 0 ;
tmpReg32 | = ( uint32_t ) HMAN_OC_CAPWAP_FRAGMENTATION ;
if ( p_ManipParams - > headerOptionsCompr )
tmpReg32 | = FM_PCD_MANIP_CAPWAP_FRAG_COMPR_OPTION_FIELD_EN ;
tmpReg32 | = ( ( uint32_t ) poolId < < 8 ) ;
WRITE_UINT32 ( p_Ad - > pcAndOffsets , tmpReg32 ) ;
tmpReg32 = 0 ;
tmpReg32 | = FM_PCD_AD_CONT_LOOKUP_TYPE ;
WRITE_UINT32 ( p_Ad - > ccAdBase , tmpReg32 ) ;
p_Manip - > sizeForFragmentation = p_ManipParams - > sizeForFragmentation ;
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 ;
}
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 ;
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 " ) ) ;
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 " ) ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
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 " ) ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
memcpy ( & tmpReg8 , & p_Template [ 14 ] , 1 * ( sizeof ( uint8_t ) ) ) ;
tmpReg8 & = 0x1f ;
tmpReg8 | = ( uint8_t ) ( p_InsrtByTemplate - > modifyOuterVlanParams . vpri < < 5 ) ;
p_Template [ 14 ] = tmpReg8 ;
2017-04-21 10:43:26 +00:00
}
2021-08-31 11:00:09 +00:00
MemCpy8 ( p_Manip - > p_Template , p_Template , p_InsrtByTemplate - > size ) ;
XX_Free ( p_Template ) ;
2017-04-21 10:43:26 +00:00
}
2021-08-31 11:00:09 +00:00
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 ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
if ( ipModify )
tmpReg32 | = ( uint32_t ) p_InsrtByTemplate - > modifyOuterIpParams . ipOuterOffset < < 8 ;
else
tmpReg32 | = ( uint32_t ) 0x0000ff00 ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
tmpReg32 | = ( uint32_t ) HMAN_OC_INSRT_HDR_BY_TEMPL_N_OR_FRAG_AFTER ;
* ( uint32_t * ) & p_Ad - > pcAndOffsets = tmpReg32 ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
tmpRegNia | = FM_PCD_AD_CONT_LOOKUP_TYPE ;
* ( uint32_t * ) & p_Ad - > ccAdBase = tmpRegNia ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
return err ;
2017-04-21 10:43:26 +00:00
}
2021-08-31 11:00:09 +00:00
static t_Error CheckStatsParamsAndSetType ( t_FmPcdManip * p_Manip , t_FmPcdStatsParams * p_StatsParams )
2017-04-21 10:43:26 +00:00
{
2021-08-31 11:00:09 +00:00
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 ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
/* 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 = CreateReassTable ( p_Manip , hdr ) ) ! = E_OK )
RETURN_ERROR ( MAJOR , err , NO_MSG ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
/* Sets the first Ad register (ccAdBase) - Action Descriptor Type and Pointer to the Reassembly Parameters Table offset from MURAM*/
2017-04-21 10:43:26 +00:00
tmpReg32 = 0 ;
tmpReg32 | = FM_PCD_AD_CONT_LOOKUP_TYPE ;
2021-08-31 11:00:09 +00:00
/* Gets the required Action descriptor table pointer */
switch ( hdr )
{
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 :
RETURN_ERROR ( MAJOR , E_NOT_SUPPORTED , ( " header type " ) ) ;
}
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
WRITE_UINT32 ( p_Ad - > ccAdBase , tmpReg32 ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
/* Sets the second Ad register (matchTblPtr) - Buffer pool ID (BPID for V2) and Scatter/Gather table offset*/
/* 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 - > reassmParams . sgBpid < < 8 ) ;
WRITE_UINT32 ( p_Ad - > matchTblPtr , tmpReg32 ) ;
# endif /* (DPAA_VERSION == 10) */
# if (DPAA_VERSION >= 11)
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) */
WRITE_UINT32 ( p_Ad - > pcAndOffsets , tmpReg32 ) ;
p_Manip - > reassm = TRUE ;
2017-04-21 10:43:26 +00:00
return E_OK ;
}
2021-08-31 11:00:09 +00:00
static t_Error SetIpv4ReassmManip ( t_FmPcdManip * p_Manip )
2017-04-21 10:43:26 +00:00
{
2021-08-31 11:00:09 +00:00
t_FmPcd * p_FmPcd = ( t_FmPcd * ) p_Manip - > h_FmPcd ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
/* Allocation if IPv4 Action descriptor */
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 " ) ) ;
}
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
memset ( p_Manip - > reassmParams . ip . h_Ipv4Ad , 0 , FM_PCD_CC_AD_ENTRY_SIZE ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
/* Fill reassembly manipulation parameter in the IP Reassembly Action Descriptor */
return FillReassmManipParams ( p_Manip , HEADER_TYPE_IPv4 ) ;
}
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
static t_Error SetIpv6ReassmManip ( t_FmPcdManip * p_Manip )
{
t_FmPcd * p_FmPcd = ( t_FmPcd * ) p_Manip - > h_FmPcd ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
/* Allocation if IPv6 Action descriptor */
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 )
2017-04-21 10:43:26 +00:00
{
2021-08-31 11:00:09 +00:00
ReleaseManipHandler ( p_Manip , p_FmPcd ) ;
RETURN_ERROR ( MAJOR , E_NO_MEMORY ,
( " Allocation of IPv6 table descriptor " ) ) ;
2017-04-21 10:43:26 +00:00
}
2021-08-31 11:00:09 +00:00
memset ( p_Manip - > reassmParams . ip . h_Ipv6Ad , 0 , FM_PCD_CC_AD_ENTRY_SIZE ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
/* Fill reassembly manipulation parameter in the IP Reassembly Action Descriptor */
return FillReassmManipParams ( p_Manip , HEADER_TYPE_IPv6 ) ;
2017-04-21 10:43:26 +00:00
}
2021-08-31 11:00:09 +00:00
static t_Error IpReassembly ( t_FmPcdManipReassemParams * p_ManipReassmParams ,
t_FmPcdManip * p_Manip )
2017-04-21 10:43:26 +00:00
{
2021-08-31 11:00:09 +00:00
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 ) ;
/* 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) " ) ) ;
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 - > 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 - > reassmParams . sgBpid = reassmManipParams . sgBpid ;
# endif /* (DPAA_VERSION == 10) */
# if (DPAA_VERSION >= 11)
if ( reassmManipParams . nonConsistentSpFqid ! = 0 )
{
p_Manip - > reassmParams . ip . nonConsistentSpFqid =
reassmManipParams . nonConsistentSpFqid ;
}
# endif /* (DPAA_VERSION >= 11) */
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
/* Creates and initializes the IP Reassembly common parameter table */
CreateReassCommonTable ( p_Manip ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
/* Creation of IPv4 reassembly manipulation */
if ( ( p_Manip - > reassmParams . hdr = = HEADER_TYPE_IPv6 )
| | ( p_Manip - > reassmParams . hdr = = HEADER_TYPE_IPv4 ) )
2017-04-21 10:43:26 +00:00
{
2021-08-31 11:00:09 +00:00
res = SetIpv4ReassmManip ( p_Manip ) ;
if ( res ! = E_OK )
return res ;
2017-04-21 10:43:26 +00:00
}
2021-08-31 11:00:09 +00:00
/* Creation of IPv6 reassembly manipulation */
if ( p_Manip - > reassmParams . hdr = = HEADER_TYPE_IPv6 )
2017-04-21 10:43:26 +00:00
{
2021-08-31 11:00:09 +00:00
res = SetIpv6ReassmManip ( p_Manip ) ;
if ( res ! = E_OK )
return res ;
2017-04-21 10:43:26 +00:00
}
2021-08-31 11:00:09 +00:00
return E_OK ;
}
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
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 ;
/* 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 ) ;
else
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 ) ;
ASSERT_COND ( res ! = FM_PCD_MAX_NUM_OF_DISTINCTION_UNITS ) ;
p_Scheme - > netEnvParams . unitIds [ 1 ] = 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*/
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 ;
}
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 ;
}
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
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 . 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 )
{
ASSERT_COND ( p_Manip ) ;
ASSERT_COND ( p_Stats ) ;
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 - > reassmParams . p_ReassCommonTbl - > totalNCSPCounter ) ;
# endif /* (DPAA_VERSION >= 11) */
if ( p_Manip - > reassmParams . ip . p_Ipv4ReassTbl )
{
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 - > reassmParams . ip . p_Ipv6ReassTbl )
{
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 ;
}
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
static t_Error IpFragmentationStats ( t_FmPcdManip * p_Manip ,
t_FmPcdManipFragIpStats * p_Stats )
{
t_AdOfTypeContLookup * p_Ad ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
ASSERT_COND ( p_Manip ) ;
ASSERT_COND ( p_Stats ) ;
ASSERT_COND ( p_Manip - > h_Ad ) ;
ASSERT_COND ( p_Manip - > fragParams . p_Frag ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
p_Ad = ( t_AdOfTypeContLookup * ) p_Manip - > h_Ad ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
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 ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
return E_OK ;
}
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
static t_Error IpFragmentation ( t_FmPcdManipFragIpParams * 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) */
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
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 ;
/* 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 " ) ) ;
MemSet8 ( 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 ;
/* 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 ) ;
/* Set Scatter/Gather BPid */
if ( p_ManipParams - > sgBpidEn )
2017-04-21 10:43:26 +00:00
{
2021-08-31 11:00:09 +00:00
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 ) ;
2017-04-21 10:43:26 +00:00
}
2021-08-31 11:00:09 +00:00
/* 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) */
/* 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 ) ;
/* Saves user's fragmentation manipulation parameters */
p_Manip - > frag = TRUE ;
p_Manip - > sizeForFragmentation = p_ManipParams - > sizeForFragmentation ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
# if (DPAA_VERSION == 10)
p_Manip - > fragParams . scratchBpid = p_ManipParams - > scratchBpid ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
/* scratch buffer pool initialization */
if ( ( err = FmPcdFragHcScratchPoolFill ( ( t_Handle ) p_FmPcd , p_ManipParams - > scratchBpid ) ) ! = E_OK )
2017-04-21 10:43:26 +00:00
{
2021-08-31 11:00:09 +00:00
FM_MURAM_FreeMem ( p_FmPcd - > h_FmMuram , p_Manip - > fragParams . p_Frag ) ;
p_Manip - > fragParams . p_Frag = NULL ;
RETURN_ERROR ( MAJOR , err , NO_MSG ) ;
2017-04-21 10:43:26 +00:00
}
2021-08-31 11:00:09 +00:00
# endif /* (DPAA_VERSION == 10) */
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
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 ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
p_Ad = ( t_AdOfTypeContLookup * ) p_Manip - > h_Ad ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
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 ;
}
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
tmpRegNia | = FM_PCD_AD_CONT_LOOKUP_TYPE ;
tmpReg32 | = HMAN_OC_IP_MANIP ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
# if (DPAA_VERSION >= 11)
tmpRegNia | = FM_PCD_MANIP_IP_CNIA ;
# endif /* (DPAA_VERSION >= 11) */
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
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.*/
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
return err ;
2017-04-21 10:43:26 +00:00
}
2021-08-31 11:00:09 +00:00
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 )
2017-04-21 10:43:26 +00:00
{
2021-08-31 11:00:09 +00:00
t_FmPortGetSetCcParams fmPortGetSetCcParams ;
t_Error err ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
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 ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
UNUSED ( h_FmPcd ) ;
UNUSED ( h_Ad ) ;
UNUSED ( h_PcdParams ) ;
UNUSED ( validate ) ;
UNUSED ( p_Manip ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
fmPortGetSetCcParams . setCcParams . type = 0 ;
fmPortGetSetCcParams . getCcParams . type = MANIP_EXTRA_SPACE ;
if ( ( err = FmPortGetSetCcParams ( h_FmPort , & fmPortGetSetCcParams ) ) ! = E_OK )
RETURN_ERROR ( MAJOR , err , NO_MSG ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
if ( ! fmPortGetSetCcParams . getCcParams . internalBufferOffset )
DBG ( WARNING , ( " manipExtraSpace must be larger than '0' " ) ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
return E_OK ;
}
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
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 ;
uint32_t power ;
SANITY_CHECK_RETURN_ERROR ( p_Manip , E_INVALID_HANDLE ) ;
SANITY_CHECK_RETURN_ERROR ( p_ManipParams , E_INVALID_HANDLE ) ;
p_IPSecParams = & p_ManipParams - > u . specialOffload . u . ipsec ;
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 ) ;
SANITY_CHECK_RETURN_ERROR (
! p_IPSecParams - > arwSize | | p_IPSecParams - > arwAddr ,
E_INVALID_VALUE ) ;
SANITY_CHECK_RETURN_ERROR (
! p_IPSecParams - > arwSize | | p_IPSecParams - > decryption ,
E_INVALID_VALUE ) ;
SANITY_CHECK_RETURN_ERROR ( ( p_IPSecParams - > arwSize % 16 ) = = 0 , E_INVALID_VALUE ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
p_Ad = ( t_AdOfTypeContLookup * ) p_Manip - > h_Ad ;
2017-04-21 10:43:26 +00:00
tmpReg32 | = FM_PCD_AD_CONT_LOOKUP_TYPE ;
2021-08-31 11:00:09 +00:00
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 ;
if ( p_IPSecParams - > arwSize )
tmpReg32 | = ( uint32_t ) ( ( XX_VirtToPhys ( UINT_TO_PTR ( p_IPSecParams - > arwAddr ) ) - FM_MM_MURAM )
& ( FM_MURAM_SIZE - 1 ) ) ;
2017-04-21 10:43:26 +00:00
WRITE_UINT32 ( p_Ad - > ccAdBase , tmpReg32 ) ;
2021-08-31 11:00:09 +00:00
tmpReg32 = 0 ;
if ( p_IPSecParams - > arwSize ) {
NEXT_POWER_OF_2 ( ( p_IPSecParams - > arwSize + 32 ) , power ) ;
LOG2 ( power , power ) ;
tmpReg32 = ( p_IPSecParams - > arwSize | ( power - 5 ) ) < < FM_PCD_MANIP_IPSEC_ARW_SIZE_SHIFT ;
}
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
if ( p_ManipParams - > h_NextManip )
tmpReg32 | =
( 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 , tmpReg32 ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
tmpReg32 = HMAN_OC_IPSEC_MANIP ;
tmpReg32 | = p_IPSecParams - > outerIPHdrLen
< < FM_PCD_MANIP_IPSEC_IP_HDR_LEN_SHIFT ;
if ( p_ManipParams - > h_NextManip )
tmpReg32 | = FM_PCD_MANIP_IPSEC_NADEN ;
WRITE_UINT32 ( p_Ad - > pcAndOffsets , tmpReg32 ) ;
return err ;
2017-04-21 10:43:26 +00:00
}
2021-08-31 11:00:09 +00:00
static t_Error SetCapwapReassmManip ( t_FmPcdManip * p_Manip )
2017-04-21 10:43:26 +00:00
{
2021-08-31 11:00:09 +00:00
t_FmPcd * p_FmPcd = ( t_FmPcd * ) p_Manip - > h_FmPcd ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
/* 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 )
{
ReleaseManipHandler ( p_Manip , p_FmPcd ) ;
RETURN_ERROR ( MAJOR , E_NO_MEMORY ,
( " Allocation of CAPWAP table descriptor " ) ) ;
}
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
memset ( p_Manip - > reassmParams . capwap . h_Ad , 0 , FM_PCD_CC_AD_ENTRY_SIZE ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
/* Fill reassembly manipulation parameter in the Reassembly Action Descriptor */
return FillReassmManipParams ( p_Manip , HEADER_TYPE_CAPWAP ) ;
}
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
static void setCapwapReassmSchemeParams ( t_FmPcd * p_FmPcd ,
t_FmPcdKgSchemeParams * p_Scheme ,
t_Handle h_CcTree , uint8_t groupId )
{
uint8_t res ;
/* 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 ;
}
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
# if (DPAA_VERSION >= 11)
static t_Error CapwapReassemblyStats ( t_FmPcdManip * p_Manip ,
t_FmPcdManipReassemCapwapStats * p_Stats )
{
ASSERT_COND ( p_Manip ) ;
ASSERT_COND ( p_Stats ) ;
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 ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
return E_OK ;
}
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
static t_Error CapwapFragmentationStats ( t_FmPcdManip * p_Manip ,
t_FmPcdManipFragCapwapStats * p_Stats )
{
t_AdOfTypeContLookup * p_Ad ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
ASSERT_COND ( p_Manip ) ;
ASSERT_COND ( p_Stats ) ;
ASSERT_COND ( p_Manip - > h_Ad ) ;
ASSERT_COND ( p_Manip - > fragParams . p_Frag ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
p_Ad = ( t_AdOfTypeContLookup * ) p_Manip - > h_Ad ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
p_Stats - > totalFrames = GET_UINT32 ( p_Ad - > gmask ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
return E_OK ;
}
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
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 ;
2017-04-21 10:43:26 +00:00
return E_OK ;
}
2021-08-31 11:00:09 +00:00
static t_Error CapwapFragmentation ( t_FmPcdManipFragCapwapParams * p_ManipParams ,
t_FmPcdManip * p_Manip )
2017-04-21 10:43:26 +00:00
{
2021-08-31 11:00:09 +00:00
t_FmPcd * p_FmPcd ;
t_AdOfTypeContLookup * p_Ad ;
uint32_t pcAndOffsetsReg = 0 , ccAdBaseReg = 0 , gmaskReg = 0 ;
uint32_t tmpReg32 = 0 , tmpRegNia = 0 ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
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 ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
/* 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 " ) ) ;
MemSet8 ( p_Manip - > fragParams . p_Frag , 0 , FM_PCD_CC_AD_ENTRY_SIZE ) ;
/* Prepare the third Ad register (pcAndOffsets)- OperationCode */
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 - > compressModeEn ) ? FM_PCD_MANIP_CAPWAP_FRAG_COMPRESS_EN :
0 ;
/* Set Scatter/Gather BPid */
if ( p_ManipParams - > sgBpidEn )
{
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 ) ;
}
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
/* 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 - > capwapFrameIdAddr ) )
- p_FmPcd - > physicalMuramBase ) ;
gmaskReg | = ( 0xFF ) < < FM_PCD_MANIP_IP_FRAG_SCRATCH_BPID ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
/* 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 ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
/* Saves user's fragmentation manipulation parameters */
p_Manip - > frag = TRUE ;
p_Manip - > sizeForFragmentation = p_ManipParams - > sizeForFragmentation ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
p_Ad = ( t_AdOfTypeContLookup * ) p_Manip - > h_Ad ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
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_CAPWAP_FRAG_CHECK ;
tmpRegNia | = FM_PCD_MANIP_CAPWAP_FRAG_CHECK_CNIA ;
2017-04-21 10:43:26 +00:00
WRITE_UINT32 ( p_Ad - > pcAndOffsets , tmpReg32 ) ;
2021-08-31 11:00:09 +00:00
WRITE_UINT32 ( p_Ad - > ccAdBase , tmpRegNia ) ;
WRITE_UINT32 ( p_Ad - > gmask , 0 ) ;
/* Total frame counter - MUST be initialized to zero.*/
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
return E_OK ;
}
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 ;
SANITY_CHECK_RETURN_ERROR ( p_Manip , E_INVALID_HANDLE ) ;
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 ) ;
UNUSED ( h_FmPcd ) ;
UNUSED ( h_Ad ) ;
UNUSED ( h_PcdParams ) ;
UNUSED ( validate ) ;
UNUSED ( p_Manip ) ;
fmPortGetSetCcParams . setCcParams . type = 0 ;
fmPortGetSetCcParams . getCcParams . type = MANIP_EXTRA_SPACE ;
if ( ( err = FmPortGetSetCcParams ( h_FmPort , & fmPortGetSetCcParams ) ) ! = E_OK )
RETURN_ERROR ( MAJOR , err , NO_MSG ) ;
if ( ! fmPortGetSetCcParams . getCcParams . internalBufferOffset )
DBG ( WARNING , ( " manipExtraSpace must be larger than '0' " ) ) ;
2017-04-21 10:43:26 +00:00
return E_OK ;
}
2021-08-31 11:00:09 +00:00
static t_Error CapwapManip ( t_FmPcdManipParams * p_ManipParams ,
t_FmPcdManip * p_Manip )
2017-04-21 10:43:26 +00:00
{
2021-08-31 11:00:09 +00:00
t_AdOfTypeContLookup * p_Ad ;
t_FmPcdManipSpecialOffloadCapwapParams * p_Params ;
t_Error err = E_OK ;
uint32_t tmpReg32 = 0 ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
SANITY_CHECK_RETURN_ERROR ( p_Manip , E_INVALID_HANDLE ) ;
SANITY_CHECK_RETURN_ERROR ( p_ManipParams , E_INVALID_HANDLE ) ;
p_Params = & p_ManipParams - > u . specialOffload . u . capwap ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
p_Ad = ( t_AdOfTypeContLookup * ) p_Manip - > h_Ad ;
tmpReg32 | = FM_PCD_AD_CONT_LOOKUP_TYPE ;
tmpReg32 | = ( p_Params - > dtls ) ? FM_PCD_MANIP_CAPWAP_DTLS : 0 ;
/* TODO - add 'qosSrc' */
WRITE_UINT32 ( p_Ad - > ccAdBase , tmpReg32 ) ;
tmpReg32 = HMAN_OC_CAPWAP_MANIP ;
if ( p_ManipParams - > h_NextManip )
2017-04-21 10:43:26 +00:00
{
2021-08-31 11:00:09 +00:00
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 ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
tmpReg32 | = FM_PCD_MANIP_CAPWAP_NADEN ;
2017-04-21 10:43:26 +00:00
}
2021-08-31 11:00:09 +00:00
WRITE_UINT32 ( p_Ad - > pcAndOffsets , tmpReg32 ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
return err ;
2017-04-21 10:43:26 +00:00
}
2021-08-31 11:00:09 +00:00
# endif /* (DPAA_VERSION >= 11) */
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
static t_Handle ManipOrStatsSetNode ( t_Handle h_FmPcd , t_Handle * p_Params ,
bool stats )
2017-04-21 10:43:26 +00:00
{
2021-08-31 11:00:09 +00:00
t_FmPcdManip * p_Manip ;
t_Error err ;
t_FmPcd * p_FmPcd = ( t_FmPcd * ) h_FmPcd ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
p_Manip = ( t_FmPcdManip * ) XX_Malloc ( sizeof ( t_FmPcdManip ) ) ;
if ( ! p_Manip )
2017-04-21 10:43:26 +00:00
{
2021-08-31 11:00:09 +00:00
REPORT_ERROR ( MAJOR , E_NO_MEMORY , ( " No memory " ) ) ;
return NULL ;
2017-04-21 10:43:26 +00:00
}
2021-08-31 11:00:09 +00:00
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 ) ) ;
if ( ! stats )
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 /* not (defined(FM_CAPWAP_SUPPORT) && (DPAA_VERSION == 10)) */
2017-04-21 10:43:26 +00:00
else
{
2021-08-31 11:00:09 +00:00
REPORT_ERROR ( MAJOR , E_NOT_SUPPORTED , ( " Statistics node! " ) ) ;
XX_Free ( p_Manip ) ;
return NULL ;
}
# endif /* (defined(FM_CAPWAP_SUPPORT) && (DPAA_VERSION == 10)) */
if ( err )
{
REPORT_ERROR ( MAJOR , E_INVALID_VALUE , ( " Invalid header manipulation type " ) ) ;
XX_Free ( p_Manip ) ;
return NULL ;
}
if ( ( p_Manip - > opcode ! = HMAN_OC_IP_REASSEMBLY ) & & ( p_Manip - > opcode ! = HMAN_OC_CAPWAP_REASSEMBLY ) )
{
/* 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 )
{
REPORT_ERROR ( MAJOR , E_NO_MEMORY , ( " MURAM alloc for Manipulation action descriptor " ) ) ;
ReleaseManipHandler ( p_Manip , p_FmPcd ) ;
XX_Free ( p_Manip ) ;
return NULL ;
}
MemSet8 ( 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 )
{
REPORT_ERROR ( MAJOR , E_NO_MEMORY , ( " Allocation of Manipulation action descriptor " ) ) ;
ReleaseManipHandler ( p_Manip , p_FmPcd ) ;
XX_Free ( p_Manip ) ;
return NULL ;
}
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
memset ( p_Manip - > h_Ad , 0 , FM_PCD_CC_AD_ENTRY_SIZE * sizeof ( uint8_t ) ) ;
}
2017-04-21 10:43:26 +00:00
}
2021-08-31 11:00:09 +00:00
p_Manip - > h_FmPcd = h_FmPcd ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
return p_Manip ;
2017-04-21 10:43:26 +00:00
}
2021-08-31 11:00:09 +00:00
static void UpdateAdPtrOfNodesWhichPointsOnCrntMdfManip (
t_FmPcdManip * p_CrntMdfManip , t_List * h_NodesLst )
2017-04-21 10:43:26 +00:00
{
2021-08-31 11:00:09 +00:00
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 ;
NCSW_LIST_FOR_EACH ( p_Pos , & p_CrntMdfManip - > nodesLst )
{
p_CcNodeInformation = CC_NODE_F_OBJECT ( p_Pos ) ;
p_NodePtrOnCurrentMdfManip =
( t_FmPcdCcNode * ) p_CcNodeInformation - > h_CcNode ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
ASSERT_COND ( p_NodePtrOnCurrentMdfManip ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
/* 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 . h_Manip
= = ( t_Handle ) p_CrntMdfManip )
{
if ( p_NodePtrOnCurrentMdfManip - > keyAndNextEngineParams [ i ] . p_StatsObj )
p_AdTablePtOnCrntCurrentMdfNode =
p_NodePtrOnCurrentMdfManip - > keyAndNextEngineParams [ i ] . p_StatsObj - > h_StatsAd ;
else
p_AdTablePtOnCrntCurrentMdfNode =
PTR_MOVE ( p_NodePtrOnCurrentMdfManip - > h_AdTable , i * FM_PCD_CC_AD_ENTRY_SIZE ) ;
memset ( & ccNodeInfo , 0 , sizeof ( t_CcNodeInformation ) ) ;
ccNodeInfo . h_CcNode = p_AdTablePtOnCrntCurrentMdfNode ;
EnqueueNodeInfoToRelevantLst ( h_NodesLst , & ccNodeInfo , NULL ) ;
}
}
}
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
ASSERT_COND ( i ! = p_NodePtrOnCurrentMdfManip - > numOfKeys ) ;
}
}
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
static void BuildHmtd ( uint8_t * p_Dest , uint8_t * p_Src , uint8_t * p_Hmcd ,
t_FmPcd * p_FmPcd )
{
t_Error err ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
/* Copy the HMTD */
MemCpy8 ( 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 ) ) ;
/* 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 ) ) ;
if ( err )
REPORT_ERROR ( MINOR , err , ( " Failed in dynamic manip change, continued to the rest of the owners. " ) ) ;
}
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
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 ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
SANITY_CHECK_RETURN_ERROR ( h_Manip , E_INVALID_HANDLE ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
UNUSED ( level ) ;
UNUSED ( h_FmTree ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
switch ( p_Manip - > opcode )
2017-04-21 10:43:26 +00:00
{
2021-08-31 11:00:09 +00:00
# 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 ;
case ( HMAN_OC_INSRT_HDR_BY_TEMPL_N_OR_FRAG_AFTER ) :
if ( ! p_Manip - > h_Frag )
break ;
case ( HMAN_OC_CAPWAP_FRAGMENTATION ) :
err = UpdateInitCapwapFragmentation ( h_FmPort , p_Manip , h_Ad , validate , h_FmTree ) ;
break ;
case ( HMAN_OC_CAPWAP_RMV_DTLS_IF_EXIST ) :
if ( p_Manip - > h_Frag )
err = UpdateInitCapwapReasm ( h_FmPcd , h_FmPort , p_Manip , h_Ad , validate ) ;
break ;
case ( HMAN_OC_CAPWAP_INDEXED_STATS ) :
err = UpdateIndxStats ( h_FmPcd , h_FmPort , p_Manip ) ;
break ;
# endif /* (defined(FM_CAPWAP_SUPPORT) && (DPAA_VERSION == 10)) */
case ( HMAN_OC_IP_REASSEMBLY ) :
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 ) ;
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 ;
2017-04-21 10:43:26 +00:00
}
2021-08-31 11:00:09 +00:00
return err ;
2017-04-21 10:43:26 +00:00
}
2021-08-31 11:00:09 +00:00
static t_Error FmPcdManipModifyUpdate ( t_Handle h_Manip , t_Handle h_Ad ,
bool validate , int level ,
t_Handle h_FmTree )
2017-04-21 10:43:26 +00:00
{
2021-08-31 11:00:09 +00:00
t_FmPcdManip * p_Manip = ( t_FmPcdManip * ) h_Manip ;
t_Error err = E_OK ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
UNUSED ( level ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
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 " ) ) ;
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 ;
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 /* (defined(FM_CAPWAP_SUPPORT) && (DPAA_VERSION == 10)) */
default :
return E_OK ;
}
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
return err ;
2017-04-21 10:43:26 +00:00
}
2021-08-31 11:00:09 +00:00
/*****************************************************************************/
/* 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 )
2017-04-21 10:43:26 +00:00
{
2021-08-31 11:00:09 +00:00
t_Error err ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
if ( ! modify )
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 ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
return err ;
}
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
void FmPcdManipUpdateOwner ( t_Handle h_Manip , bool add )
{
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
uint32_t intFlags ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
intFlags = XX_LockIntrSpinlock ( ( ( t_FmPcdManip * ) h_Manip ) - > h_Spinlock ) ;
if ( add )
( ( t_FmPcdManip * ) h_Manip ) - > owner + + ;
else
{
ASSERT_COND ( ( ( t_FmPcdManip * ) h_Manip ) - > owner ) ;
( ( t_FmPcdManip * ) h_Manip ) - > owner - - ;
}
XX_UnlockIntrSpinlock ( ( ( t_FmPcdManip * ) h_Manip ) - > h_Spinlock , intFlags ) ;
}
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
t_List * FmPcdManipGetNodeLstPointedOnThisManip ( t_Handle h_Manip )
{
ASSERT_COND ( h_Manip ) ;
return & ( ( t_FmPcdManip * ) h_Manip ) - > nodesLst ;
}
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
t_List * FmPcdManipGetSpinlock ( t_Handle h_Manip )
{
ASSERT_COND ( h_Manip ) ;
return ( ( t_FmPcdManip * ) h_Manip ) - > h_Spinlock ;
}
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
t_Error FmPcdManipCheckParamsForCcNextEngine (
t_FmPcdCcNextEngineParams * p_FmPcdCcNextEngineParams ,
uint32_t * requiredAction )
{
t_FmPcdManip * p_Manip ;
# if (defined(FM_CAPWAP_SUPPORT) && (DPAA_VERSION == 10))
t_Error err = E_OK ;
# endif /* (defined(FM_CAPWAP_SUPPORT) && (DPAA_VERSION == 10))*/
bool pointFromCc = TRUE ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
SANITY_CHECK_RETURN_ERROR ( p_FmPcdCcNextEngineParams , E_NULL_POINTER ) ;
SANITY_CHECK_RETURN_ERROR ( p_FmPcdCcNextEngineParams - > h_Manip ,
E_NULL_POINTER ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
p_Manip = ( t_FmPcdManip * ) ( p_FmPcdCcNextEngineParams - > h_Manip ) ;
* requiredAction = 0 ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
while ( p_Manip )
{
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 ;
case ( HMAN_OC_CAPWAP_RMV_DTLS_IF_EXIST ) :
* requiredAction = UPDATE_NIA_ENQ_WITHOUT_DMA ;
case ( HMAN_OC_RMV_N_OR_INSRT_INT_FRM_HDR ) :
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 ;
case ( HMAN_OC_MV_INT_FRAME_HDR_FROM_FRM_TO_BUFFER_PREFFIX ) :
if ( ( p_FmPcdCcNextEngineParams - > nextEngine ! = e_FM_PCD_CC )
& & ( FmPcdCcGetParseCode ( p_FmPcdCcNextEngineParams - > params . ccParams . h_CcNode )
! = CC_PC_GENERIC_IC_HASH_INDEXED ) )
RETURN_ERROR ( MAJOR , E_INVALID_STATE , ( " For this type of header manipulation next engine has to be CC and action = e_FM_PCD_ACTION_INDEXED_LOOKUP " ) ) ;
err = UpdateManipIc ( p_FmPcdCcNextEngineParams - > h_Manip ,
FmPcdCcGetOffset ( p_FmPcdCcNextEngineParams - > params . ccParams . h_CcNode ) ) ;
if ( err )
RETURN_ERROR ( MAJOR , err , NO_MSG ) ;
* requiredAction = UPDATE_NIA_ENQ_WITHOUT_DMA ;
break ;
# endif /* (defined(FM_CAPWAP_SUPPORT) && (DPAA_VERSION == 10)) */
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 " ) ) ;
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_CASCADED ( 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) " ) ) ;
break ;
default :
RETURN_ERROR (
MAJOR , E_INVALID_STATE ,
( " invalid type of header manipulation for this state " ) ) ;
}
p_Manip = p_Manip - > h_NextManip ;
pointFromCc = FALSE ;
}
return E_OK ;
}
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
t_Error FmPcdManipCheckParamsWithCcNodeParams ( t_Handle h_Manip ,
t_Handle h_FmPcdCcNode )
{
t_FmPcdManip * p_Manip = ( t_FmPcdManip * ) h_Manip ;
t_Error err = E_OK ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
SANITY_CHECK_RETURN_ERROR ( h_Manip , E_INVALID_HANDLE ) ;
SANITY_CHECK_RETURN_ERROR ( h_FmPcdCcNode , E_INVALID_HANDLE ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
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 ;
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 ;
# endif /* (defined(FM_CAPWAP_SUPPORT) && (DPAA_VERSION == 10)) */
default :
break ;
}
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
return err ;
}
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
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 ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
/* 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 ) */
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
ASSERT_COND ( p_Manip ) ;
ASSERT_COND ( p_CcNextEngineParams ) ;
ASSERT_COND ( p_Ad ) ;
ASSERT_COND ( p_AdNewPtr ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
FmPcdManipUpdateOwner ( h_Manip , TRUE ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
/* According to "type", either build & initialize a new AD (p_AdNew) or initialize
* 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 ;
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 (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 ) ) ;
# if (DPAA_VERSION >= 11)
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 ;
}
else
* p_AdNewPtr = p_Manip - > h_Ad ;
break ;
case ( HMAN_OC_IP_REASSEMBLY ) :
if ( FmPcdManipIpReassmIsIpv6Hdr ( p_Manip ) )
{
if ( ! p_Manip - > reassmParams . ip . ipv6Assigned )
{
* p_AdNewPtr = p_Manip - > reassmParams . ip . h_Ipv6Ad ;
p_Manip - > reassmParams . ip . ipv6Assigned = TRUE ;
FmPcdManipUpdateOwner ( h_Manip , FALSE ) ;
}
else
{
* p_AdNewPtr = p_Manip - > reassmParams . ip . h_Ipv4Ad ;
p_Manip - > reassmParams . ip . ipv6Assigned = FALSE ;
}
}
else
* p_AdNewPtr = p_Manip - > reassmParams . ip . h_Ipv4Ad ;
memcpy ( ( uint8_t * ) p_Ad , ( uint8_t * ) * p_AdNewPtr ,
sizeof ( t_AdOfTypeContLookup ) ) ;
* p_AdNewPtr = NULL ;
break ;
# 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 ;
break ;
default :
break ;
}
}
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
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 ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
/* 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 ) */
ASSERT_COND ( p_Manip ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
FmPcdManipUpdateOwner ( h_Manip , TRUE ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
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 ;
# endif /* (defined(FM_CAPWAP_SUPPORT) && (DPAA_VERSION == 10)) */
case ( HMAN_OC ) :
/* Initialize HMTD within the match table*/
MemSet8 ( 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 ) ) ;
/* update next action descriptor */
WRITE_UINT16 ( ( ( t_Hmtd * ) p_Ad ) - > nextAdIdx ,
( uint16_t ) ( adTableOffset > > 4 ) ) ;
/* mark that Manip's HMTD is not used */
* p_AdNewPtr = NULL ;
break ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
default :
break ;
}
}
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
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_Handle h_Scheme ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
ASSERT_COND ( p_FmPcd ) ;
ASSERT_COND ( h_NetEnv ) ;
ASSERT_COND ( p_Manip ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
/* scheme was already build, no need to check for IPv6 */
if ( p_Manip - > reassmParams . ip . h_Ipv4Scheme )
return E_OK ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
if ( isIpv4 ) {
h_Scheme = FmPcdKgGetSchemeHandle ( p_FmPcd , p_Manip - > reassmParams . ip . relativeSchemeId [ 0 ] ) ;
if ( h_Scheme ) {
/* scheme was found */
p_Manip - > reassmParams . ip . h_Ipv4Scheme = h_Scheme ;
return E_OK ;
}
} else {
h_Scheme = FmPcdKgGetSchemeHandle ( p_FmPcd , p_Manip - > reassmParams . ip . relativeSchemeId [ 1 ] ) ;
if ( h_Scheme ) {
/* scheme was found */
p_Manip - > reassmParams . ip . h_Ipv6Scheme = h_Scheme ;
return E_OK ;
}
}
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
p_SchemeParams = XX_Malloc ( sizeof ( t_FmPcdKgSchemeParams ) ) ;
if ( ! p_SchemeParams )
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 - > reassmParams . ip . relativeSchemeId [ 0 ] :
p_Manip - > reassmParams . ip . relativeSchemeId [ 1 ] ) ;
p_SchemeParams - > schemeCounter . update = TRUE ;
# if (DPAA_VERSION >= 11)
p_SchemeParams - > alwaysDirect = TRUE ;
p_SchemeParams - > bypassFqidGeneration = TRUE ;
# else
p_SchemeParams - > keyExtractAndHashParams . hashDistributionNumOfFqids = 1 ;
p_SchemeParams - > baseFqid = 0xFFFFFF ; /*TODO- baseFqid*/
# endif /* (DPAA_VERSION >= 11) */
setIpReassmSchemeParams ( p_FmPcd , p_SchemeParams , h_CcTree , isIpv4 , groupId ) ;
/* Sets the new scheme */
if ( isIpv4 )
p_Manip - > reassmParams . ip . h_Ipv4Scheme = FM_PCD_KgSchemeSet (
p_FmPcd , p_SchemeParams ) ;
else
p_Manip - > reassmParams . ip . h_Ipv6Scheme = FM_PCD_KgSchemeSet (
p_FmPcd , p_SchemeParams ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
XX_Free ( p_SchemeParams ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
return E_OK ;
}
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
t_Error FmPcdManipDeleteIpReassmSchemes ( t_Handle h_Manip )
{
t_FmPcdManip * p_Manip = ( t_FmPcdManip * ) h_Manip ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
ASSERT_COND ( p_Manip ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
if ( ( p_Manip - > reassmParams . ip . h_Ipv4Scheme ) & &
! FmPcdKgIsSchemeHasOwners ( p_Manip - > reassmParams . ip . h_Ipv4Scheme ) )
FM_PCD_KgSchemeDelete ( p_Manip - > reassmParams . ip . h_Ipv4Scheme ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
if ( ( p_Manip - > reassmParams . ip . h_Ipv6Scheme ) & &
! FmPcdKgIsSchemeHasOwners ( p_Manip - > reassmParams . ip . h_Ipv6Scheme ) )
FM_PCD_KgSchemeDelete ( p_Manip - > reassmParams . ip . h_Ipv6Scheme ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
return E_OK ;
}
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
bool FmPcdManipIpReassmIsIpv6Hdr ( t_Handle h_Manip )
{
t_FmPcdManip * p_Manip = ( t_FmPcdManip * ) h_Manip ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
ASSERT_COND ( p_Manip ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
return ( p_Manip - > reassmParams . hdr = = HEADER_TYPE_IPv6 ) ;
2017-04-21 10:43:26 +00:00
}
2021-08-31 11:00:09 +00:00
t_Error FmPcdManipBuildCapwapReassmScheme ( t_FmPcd * p_FmPcd , t_Handle h_NetEnv ,
t_Handle h_CcTree , t_Handle h_Manip ,
uint8_t groupId )
2017-04-21 10:43:26 +00:00
{
2021-08-31 11:00:09 +00:00
t_FmPcdManip * p_Manip = ( t_FmPcdManip * ) h_Manip ;
t_FmPcdKgSchemeParams * p_SchemeParams = NULL ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
ASSERT_COND ( p_FmPcd ) ;
ASSERT_COND ( h_NetEnv ) ;
ASSERT_COND ( p_Manip ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
/* scheme was already build, no need to check for IPv6 */
if ( p_Manip - > reassmParams . capwap . h_Scheme )
return E_OK ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
p_SchemeParams = XX_Malloc ( sizeof ( t_FmPcdKgSchemeParams ) ) ;
if ( ! p_SchemeParams )
RETURN_ERROR ( MAJOR , E_NO_MEMORY ,
( " Memory allocation failed for scheme " ) ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
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 ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
setCapwapReassmSchemeParams ( p_FmPcd , p_SchemeParams , h_CcTree , groupId ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
p_Manip - > reassmParams . capwap . h_Scheme = FM_PCD_KgSchemeSet ( p_FmPcd ,
p_SchemeParams ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
XX_Free ( p_SchemeParams ) ;
return E_OK ;
2017-04-21 10:43:26 +00:00
}
2021-08-31 11:00:09 +00:00
t_Error FmPcdManipDeleteCapwapReassmSchemes ( t_Handle h_Manip )
2017-04-21 10:43:26 +00:00
{
2021-08-31 11:00:09 +00:00
t_FmPcdManip * p_Manip = ( t_FmPcdManip * ) h_Manip ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
ASSERT_COND ( p_Manip ) ;
if ( p_Manip - > reassmParams . capwap . h_Scheme )
FM_PCD_KgSchemeDelete ( p_Manip - > reassmParams . capwap . h_Scheme ) ;
2017-04-21 10:43:26 +00:00
return E_OK ;
}
2021-08-31 11:00:09 +00:00
# if (defined(FM_CAPWAP_SUPPORT) && (DPAA_VERSION == 10))
t_Handle FmPcdManipApplSpecificBuild ( void )
2017-04-21 10:43:26 +00:00
{
2021-08-31 11:00:09 +00:00
t_FmPcdManip * p_Manip ;
2017-04-21 10:43:26 +00:00
p_Manip = ( t_FmPcdManip * ) XX_Malloc ( sizeof ( t_FmPcdManip ) ) ;
2021-08-31 11:00:09 +00:00
if ( ! p_Manip )
2017-04-21 10:43:26 +00:00
{
REPORT_ERROR ( MAJOR , E_NO_MEMORY , ( " No memory " ) ) ;
return NULL ;
}
memset ( p_Manip , 0 , sizeof ( t_FmPcdManip ) ) ;
2021-08-31 11:00:09 +00:00
p_Manip - > opcode = HMAN_OC_MV_INT_FRAME_HDR_FROM_FRM_TO_BUFFER_PREFFIX ;
p_Manip - > muramAllocate = FALSE ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
p_Manip - > h_Ad = ( t_Handle ) XX_Malloc ( FM_PCD_CC_AD_ENTRY_SIZE * sizeof ( uint8_t ) ) ;
if ( ! p_Manip - > h_Ad )
2017-04-21 10:43:26 +00:00
{
2021-08-31 11:00:09 +00:00
REPORT_ERROR ( MAJOR , E_NO_MEMORY , ( " Allocation of Manipulation action descriptor " ) ) ;
2017-04-21 10:43:26 +00:00
XX_Free ( p_Manip ) ;
return NULL ;
}
2021-08-31 11:00:09 +00:00
memset ( p_Manip - > h_Ad , 0 , FM_PCD_CC_AD_ENTRY_SIZE * sizeof ( uint8_t ) ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
/*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 */
if ( MvIntFrameHeaderFromFrameToBufferPrefix ( p_Manip , TRUE ) ! = E_OK )
2017-04-21 10:43:26 +00:00
{
2021-08-31 11:00:09 +00:00
XX_Free ( p_Manip - > h_Ad ) ;
XX_Free ( p_Manip ) ;
return NULL ;
2017-04-21 10:43:26 +00:00
}
return p_Manip ;
}
2021-08-31 11:00:09 +00:00
bool FmPcdManipIsCapwapApplSpecific ( t_Handle h_Manip )
{
t_FmPcdManip * p_Manip = ( t_FmPcdManip * ) h_Manip ;
ASSERT_COND ( h_Manip ) ;
return ( bool ) ( ( p_Manip - > opcode = = HMAN_OC_CAPWAP_RMV_DTLS_IF_EXIST ) ? TRUE : FALSE ) ;
}
# endif /* (defined(FM_CAPWAP_SUPPORT) && (DPAA_VERSION == 10)) */
/*********************** End of inter-module routines ************************/
/****************************************/
/* API Init unit functions */
/****************************************/
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
t_Handle FM_PCD_ManipNodeSet ( t_Handle h_FmPcd ,
t_FmPcdManipParams * p_ManipParams )
2017-04-21 10:43:26 +00:00
{
2021-08-31 11:00:09 +00:00
t_FmPcd * p_FmPcd = ( t_FmPcd * ) h_FmPcd ;
t_FmPcdManip * p_Manip ;
2017-04-21 10:43:26 +00:00
t_Error err ;
2021-08-31 11:00:09 +00:00
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 ) ;
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 )
| | ( 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 ) ) )
2017-04-21 10:43:26 +00:00
{
2021-08-31 11:00:09 +00:00
REPORT_ERROR ( MAJOR , E_INVALID_STATE , ( " Advanced-offload must be enabled " ) ) ;
XX_Free ( p_Manip ) ;
return NULL ;
2017-04-21 10:43:26 +00:00
}
2021-08-31 11:00:09 +00:00
p_Manip - > h_Spinlock = XX_InitSpinlock ( ) ;
if ( ! p_Manip - > h_Spinlock )
2017-04-21 10:43:26 +00:00
{
2021-08-31 11:00:09 +00:00
REPORT_ERROR ( MAJOR , E_INVALID_VALUE , ( " UNSUPPORTED HEADER MANIPULATION TYPE " ) ) ;
ReleaseManipHandler ( p_Manip , p_FmPcd ) ;
XX_Free ( p_Manip ) ;
return NULL ;
} INIT_LIST ( & p_Manip - > nodesLst ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
switch ( p_Manip - > opcode )
2017-04-21 10:43:26 +00:00
{
2021-08-31 11:00:09 +00:00
case ( HMAN_OC_IP_REASSEMBLY ) :
/* IpReassembly */
err = IpReassembly ( & p_ManipParams - > u . reassem , p_Manip ) ;
break ;
case ( HMAN_OC_IP_FRAGMENTATION ) :
/* IpFragmentation */
err = IpFragmentation ( & p_ManipParams - > u . frag . u . ipFrag , p_Manip ) ;
if ( err )
break ;
err = IPManip ( p_Manip ) ;
break ;
case ( HMAN_OC_IPSEC_MANIP ) :
err = IPSecManip ( p_ManipParams , p_Manip ) ;
break ;
# 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 ) :
err = CapwapFragmentation ( & p_ManipParams - > fragOrReasmParams . u . capwapFragParams ,
p_Manip ,
p_FmPcd ,
p_ManipParams - > fragOrReasmParams . sgBpid ) ;
if ( err )
{
REPORT_ERROR ( MAJOR , E_INVALID_VALUE , ( " UNSUPPORTED HEADER MANIPULATION TYPE " ) ) ;
ReleaseManipHandler ( p_Manip , p_FmPcd ) ;
XX_Free ( p_Manip ) ;
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 ) :
/* 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 ) :
err = CapwapReassembly ( & p_ManipParams - > fragOrReasmParams . u . capwapReasmParams ,
p_Manip ,
p_FmPcd ,
p_ManipParams - > fragOrReasmParams . sgBpid ) ;
if ( err )
{
REPORT_ERROR ( MAJOR , E_INVALID_VALUE , ( " UNSUPPORTED HEADER MANIPULATION TYPE " ) ) ;
ReleaseManipHandler ( p_Manip , p_FmPcd ) ;
XX_Free ( p_Manip ) ;
return NULL ;
}
if ( p_Manip - > rmv )
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 ;
case ( HMAN_OC_MV_INT_FRAME_HDR_FROM_FRM_TO_BUFFER_PREFFIX ) :
/*Application Specific type 1*/
err = MvIntFrameHeaderFromFrameToBufferPrefix ( p_Manip , TRUE ) ;
break ;
# endif /* (defined(FM_CAPWAP_SUPPORT) && (DPAA_VERSION == 10)) */
case ( HMAN_OC ) :
/* New Manip */
err = CreateManipActionNew ( p_Manip , p_ManipParams ) ;
break ;
2017-04-21 10:43:26 +00:00
default :
2021-08-31 11:00:09 +00:00
REPORT_ERROR ( MAJOR , E_INVALID_VALUE , ( " UNSUPPORTED HEADER MANIPULATION TYPE " ) ) ;
ReleaseManipHandler ( p_Manip , p_FmPcd ) ;
XX_Free ( p_Manip ) ;
return NULL ;
2017-04-21 10:43:26 +00:00
}
2021-08-31 11:00:09 +00:00
if ( err )
{
REPORT_ERROR ( MAJOR , err , NO_MSG ) ;
ReleaseManipHandler ( p_Manip , p_FmPcd ) ;
XX_Free ( p_Manip ) ;
return NULL ;
}
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
if ( p_ManipParams - > h_NextManip )
2017-04-21 10:43:26 +00:00
{
2021-08-31 11:00:09 +00:00
/* in the check routine we've verified that h_NextManip has no owners
* and that only supported types are allowed . */
p_Manip - > h_NextManip = p_ManipParams - > h_NextManip ;
/* save a "prev" pointer in h_NextManip */
MANIP_SET_PREV ( p_Manip - > h_NextManip , p_Manip ) ;
FmPcdManipUpdateOwner ( p_Manip - > h_NextManip , TRUE ) ;
2017-04-21 10:43:26 +00:00
}
2021-08-31 11:00:09 +00:00
return p_Manip ;
2017-04-21 10:43:26 +00:00
}
2021-08-31 11:00:09 +00:00
t_Error FM_PCD_ManipNodeReplace ( t_Handle h_Manip ,
t_FmPcdManipParams * p_ManipParams )
2017-04-21 10:43:26 +00:00
{
2021-08-31 11:00:09 +00:00
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 ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
INIT_LIST ( & lstOfNodeshichPointsOnCrntMdfManip ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
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. " ) ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
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 ) ) ;
p_Manip - > manipParams . h_NextManip = p_Manip - > h_NextManip ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
/* The replacement of the HdrManip depends on the node type.*/
/*
* ( 1 ) If this is an independent node , all its owners should be updated .
*
* ( 2 ) If it is the head of a cascaded chain ( it does not have a " prev " but
* it has a " next " and it has a " cascaded " indication ) , the next
* node remains unchanged , and the behavior is as in ( 1 ) .
*
* ( 3 ) If it is not the head , but a part of a cascaded chain , in can be
* also replaced as a regular node with just one owner .
*
* ( 4 ) If it is a part of a chain implemented as a unified table , the
* whole table is replaced and the owners of the head node must be updated .
*
*/
/* lock shadow */
if ( ! p_FmPcd - > p_CcShadow )
RETURN_ERROR ( MAJOR , E_NO_MEMORY , ( " CC Shadow not allocated " ) ) ;
if ( ! TRY_LOCK ( p_FmPcd - > h_ShadowSpinlock , & p_FmPcd - > shadowLock ) )
return ERROR_CODE ( E_BUSY ) ;
/* this routine creates a new manip action in the CC Shadow. */
err = CreateManipActionShadow ( p_Manip , p_ManipParams ) ;
if ( err )
RETURN_ERROR ( MINOR , err , NO_MSG ) ;
/* If the owners list is empty (these are NOT the "owners" counter, but pointers from CC)
* replace only HMTD and no lcok is required . Otherwise
* lock the whole PCD
* In case 4 MANIP_IS_UNIFIED_NON_FIRST ( p_Manip ) - Use the head node instead . */
if ( ! FmPcdLockTryLockAll ( p_FmPcd ) )
{
DBG ( TRACE , ( " FmPcdLockTryLockAll failed " ) ) ;
return ERROR_CODE ( E_BUSY ) ;
2017-04-21 10:43:26 +00:00
}
2021-08-31 11:00:09 +00:00
p_ShadowHmct = ( uint8_t * ) PTR_MOVE ( p_FmPcd - > p_CcShadow , 16 ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
p_FirstManip = ( t_FmPcdManip * ) GetManipInfo ( p_Manip ,
e_MANIP_HANDLER_TABLE_OWNER ) ;
ASSERT_COND ( p_FirstManip ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
if ( ! NCSW_LIST_IsEmpty ( & p_FirstManip - > nodesLst ) )
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 ) ) ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
NCSW_LIST_FOR_EACH ( p_Pos , & lstOfNodeshichPointsOnCrntMdfManip )
2017-04-21 10:43:26 +00:00
{
2021-08-31 11:00:09 +00:00
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 ) ) ) ;
2017-04-21 10:43:26 +00:00
}
2021-08-31 11:00:09 +00:00
p_WholeHmct = ( uint8_t * ) GetManipInfo ( p_Manip , e_MANIP_HMCT ) ;
ASSERT_COND ( p_WholeHmct ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
/* re-build the HMCT n the original location */
err = CreateManipActionBackToOrig ( p_Manip , p_ManipParams ) ;
if ( err )
{
RELEASE_LOCK ( p_FmPcd - > shadowLock ) ;
RETURN_ERROR ( MINOR , err , NO_MSG ) ;
}
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
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 ) ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
/* If NCSW_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 */ NCSW_LIST_FOR_EACH ( p_Pos , & lstOfNodeshichPointsOnCrntMdfManip )
2017-04-21 10:43:26 +00:00
{
2021-08-31 11:00:09 +00:00
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 ) ) ) ;
2017-04-21 10:43:26 +00:00
}
2021-08-31 11:00:09 +00:00
ReleaseLst ( & lstOfNodeshichPointsOnCrntMdfManip ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
FmPcdLockUnlockAll ( p_FmPcd ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
/* unlock shadow */
RELEASE_LOCK ( p_FmPcd - > shadowLock ) ;
return E_OK ;
2017-04-21 10:43:26 +00:00
}
2021-08-31 11:00:09 +00:00
t_Error FM_PCD_ManipNodeDelete ( t_Handle h_ManipNode )
2017-04-21 10:43:26 +00:00
{
2021-08-31 11:00:09 +00:00
t_FmPcdManip * p_Manip = ( t_FmPcdManip * ) h_ManipNode ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
SANITY_CHECK_RETURN_ERROR ( p_Manip , E_INVALID_HANDLE ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
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 " ) ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
if ( p_Manip - > h_NextManip )
{
MANIP_SET_PREV ( p_Manip - > h_NextManip , NULL ) ;
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 ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
if ( p_Manip - > h_Spinlock )
2017-04-21 10:43:26 +00:00
{
2021-08-31 11:00:09 +00:00
XX_FreeSpinlock ( p_Manip - > h_Spinlock ) ;
p_Manip - > h_Spinlock = NULL ;
2017-04-21 10:43:26 +00:00
}
2021-08-31 11:00:09 +00:00
ReleaseManipHandler ( p_Manip , p_Manip - > h_FmPcd ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
XX_Free ( h_ManipNode ) ;
return E_OK ;
}
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
t_Error FM_PCD_ManipGetStatistics ( t_Handle h_ManipNode ,
t_FmPcdManipStats * p_FmPcdManipStats )
{
t_FmPcdManip * p_Manip = ( t_FmPcdManip * ) h_ManipNode ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
SANITY_CHECK_RETURN_ERROR ( p_Manip , E_INVALID_HANDLE ) ;
SANITY_CHECK_RETURN_ERROR ( p_FmPcdManipStats , E_NULL_POINTER ) ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
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 ) ;
# if (DPAA_VERSION >= 11)
case ( HMAN_OC_CAPWAP_REASSEMBLY ) :
return CapwapReassemblyStats (
p_Manip , & p_FmPcdManipStats - > u . reassem . u . capwapReassem ) ;
case ( HMAN_OC_CAPWAP_FRAGMENTATION ) :
return CapwapFragmentationStats (
p_Manip , & p_FmPcdManipStats - > u . frag . u . capwapFrag ) ;
# endif /* (DPAA_VERSION >= 11) */
default :
RETURN_ERROR ( MAJOR , E_NOT_SUPPORTED ,
( " no statistics to this type of manip " ) ) ;
}
2017-04-21 10:43:26 +00:00
return E_OK ;
}
2021-08-31 11:00:09 +00:00
# if (defined(FM_CAPWAP_SUPPORT) && (DPAA_VERSION == 10))
2017-04-21 10:43:26 +00:00
t_Handle FM_PCD_StatisticsSetNode ( t_Handle h_FmPcd , t_FmPcdStatsParams * p_StatsParams )
{
2021-08-31 11:00:09 +00:00
t_FmPcd * p_FmPcd = ( t_FmPcd * ) h_FmPcd ;
t_FmPcdManip * p_Manip ;
t_Error err ;
2017-04-21 10:43:26 +00:00
SANITY_CHECK_RETURN_VALUE ( h_FmPcd , E_INVALID_HANDLE , NULL ) ;
SANITY_CHECK_RETURN_VALUE ( p_StatsParams , E_INVALID_HANDLE , NULL ) ;
2021-08-31 11:00:09 +00:00
p_Manip = ManipOrStatsSetNode ( h_FmPcd , ( t_Handle ) p_StatsParams , TRUE ) ;
if ( ! p_Manip )
return NULL ;
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
switch ( p_Manip - > opcode )
2017-04-21 10:43:26 +00:00
{
2021-08-31 11:00:09 +00:00
case ( HMAN_OC_CAPWAP_INDEXED_STATS ) :
/* 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 ;
}
2017-04-21 10:43:26 +00:00
2021-08-31 11:00:09 +00:00
if ( err )
{
REPORT_ERROR ( MAJOR , err , NO_MSG ) ;
ReleaseManipHandler ( p_Manip , p_FmPcd ) ;
XX_Free ( p_Manip ) ;
return NULL ;
2017-04-21 10:43:26 +00:00
}
2021-08-31 11:00:09 +00:00
return p_Manip ;
}
# endif /* (defined(FM_CAPWAP_SUPPORT) && (DPAA_VERSION == 10)) */
