bjayesh/m241Neelima
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

original files of m241

Browse Source
This commit is contained in:
neelimap
2026-07-30 11:19:44 +05:30
parent 170c2b3f3a
commit afc7070c1f
12254 changed files with 7655111 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
components/ip_net2-6.9/ipfreescale/sec4/NetCommSw/Peripherals/SEC/DCL/sec_dcl.c
+575
View File
@@ -0,0 +1,575 @@
/******************************************************************************
� 1995-2003, 2004, 2005-2010 Freescale Semiconductor, Inc.
All rights reserved.
This is proprietary source code of Freescale Semiconductor Inc.,
and its use is subject to the NetComm Device Drivers EULA.
The copyright notice above does not evidence any actual or intended
publication of such source code.
**************************************************************************/
/* Include the internal definitions of this module */
#include "sec_dcl.h"
#include "sec_dcl_api.h"
#include "sec_dcl_cmd.h"
/* Include the external interfaces of other modules */
#include "xx_ext.h"
#include "sec_ext.h"
#include "part_ext.h"
#include "error_ext.h"
#include "string_ext.h"
/* wind river start */
#ifdef SEC4_PREALLOC_DESC_BUF
#include "mem_ext.h"
#endif
/* wind river end */
#define __ERR_MODULE__ MODULE_SEC
static t_Error CheckInitParameters(t_SecDcl* p_SecDcl);
/* static t_Handle CreateDescObject(t_SecDcl* p_SecDcl,uint32_t length,uint32_t* p_Buffer);*/
/*******************************/
/* Initialization Unit (below) */
t_Handle SEC_DCL_Config(t_SecDclParam* p_Param)
{
t_SecDcl* p_SecDcl;
SANITY_CHECK_EXIT(p_Param,E_NULL_POINTER);
/* Allocate the driver structure */
/* ----------------------------- */
p_SecDcl = (t_SecDcl*)XX_Malloc(sizeof(t_SecDcl));
if (p_SecDcl == NULL)
{
REPORT_ERROR(MAJOR,E_NO_MEMORY,("SEC DCL driver"));
return (t_Handle)p_SecDcl;
}
memset(p_SecDcl,0,sizeof(t_SecDcl));
/* Allocate the driver parameters structure */
/* ---------------------------------------- */
p_SecDcl->p_DriverParam = (t_SecDclDriverParam*)XX_Malloc(sizeof(t_SecDclDriverParam));
if (p_SecDcl->p_DriverParam == NULL)
{
REPORT_ERROR(MAJOR,E_NO_MEMORY,("SEC DCL driver parameters"));
return (t_Handle)p_SecDcl;
}
memset(p_SecDcl->p_DriverParam,0,sizeof(t_SecDclDriverParam));
/* Configure the driver parameters */
/* ------------------------------- */
p_SecDcl->p_DriverParam->h_Sec = p_Param->h_Sec ;
p_SecDcl->p_DriverParam->memId = p_Param->memId ;
p_SecDcl->p_DriverParam->alignment = p_Param->alignment ;
p_SecDcl->p_DriverParam->prefixSize = p_Param->prefixSize ;
p_SecDcl->p_DriverParam->postfixSize = p_Param->postfixSize;
/* wind river start */
#ifdef SEC4_PREALLOC_DESC_BUF
p_SecDcl->p_DriverParam->noofBuf = p_Param->noofBuf ;
p_SecDcl->p_DriverParam->descSize = p_Param->descSize ;
p_SecDcl->p_DriverParam->descBufSize = p_Param->descBufSize;
#endif
/* wind river end */
return (t_Handle)p_SecDcl;
}
t_Error SEC_DCL_Init(t_Handle h_SecDcl)
{
t_SecDcl* p_SecDcl = (t_SecDcl*)h_SecDcl;
uint8_t majRevNum;
uint8_t minRevNum;
/* wind river start */
t_Error status;
/* wind river end */
SANITY_CHECK_EXIT(p_SecDcl,E_INVALID_HANDLE);
SANITY_CHECK_EXIT(p_SecDcl->p_DriverParam,E_INVALID_STATE);
CHECK_INIT_PARAMETERS(p_SecDcl,CheckInitParameters);
majRevNum = SEC_GetMajRevNum(p_SecDcl->p_DriverParam->h_Sec);
minRevNum = SEC_GetMinRevNum(p_SecDcl->p_DriverParam->h_Sec);
if (majRevNum==1 && minRevNum==0)
REPORT_ERROR(MAJOR,E_NOT_SUPPORTED,("SEC version"));
p_SecDcl->ptrSize = SEC_GetPtrSize(p_SecDcl->p_DriverParam->h_Sec);
p_SecDcl->memId = p_SecDcl->p_DriverParam->memId ;
p_SecDcl->alignment = p_SecDcl->p_DriverParam->alignment ;
p_SecDcl->prefixSize = p_SecDcl->p_DriverParam->prefixSize ;
p_SecDcl->postfixSize = p_SecDcl->p_DriverParam->postfixSize;
/* wind river start */
#ifdef SEC4_PREALLOC_DESC_BUF
p_SecDcl->descSize = p_SecDcl->p_DriverParam->descSize ;
p_SecDcl->descBufSize = p_SecDcl->p_DriverParam->descBufSize;
p_SecDcl->noofBuf = p_SecDcl->p_DriverParam->noofBuf ;
#endif
/* wind river end */
XX_Free(p_SecDcl->p_DriverParam);
p_SecDcl->p_DriverParam = NULL;
/* wind river start */
#ifdef SEC4_PREALLOC_DESC_BUF
/* Initiate memory to be used for pre-allocated descriptor buffers, for increased performance */
#ifdef SEC4_USE_QI
status = MEM_InitSmart("DESC", &(p_SecDcl->h_SecMem), p_SecDcl->noofBuf, p_SecDcl->descSize,
p_SecDcl->prefixSize, p_SecDcl->postfixSize, p_SecDcl->alignment, p_SecDcl->memId, FALSE);
#else
status = MEM_Init("DESC", &(p_SecDcl->h_SecMem), p_SecDcl->noofBuf, p_SecDcl->descSize,
p_SecDcl->prefixSize, p_SecDcl->postfixSize, p_SecDcl->alignment);
#endif
if(E_OK != status)
{
return status;
}
status = MEM_InitSmart("SMRT", &(p_SecDcl->h_SecMemSmart), p_SecDcl->noofBuf, p_SecDcl->descBufSize,
p_SecDcl->prefixSize, p_SecDcl->postfixSize, p_SecDcl->alignment, p_SecDcl->memId, FALSE);
if(E_OK != status)
{
return status;
}
#endif
/* wind river end */
return E_OK;
}
t_Error SEC_DCL_Free(t_Handle h_SecDcl)
{
t_SecDcl* p_SecDcl = (t_SecDcl*)h_SecDcl;
SANITY_CHECK_EXIT(p_SecDcl,E_INVALID_HANDLE);
if (p_SecDcl->p_DriverParam)
XX_Free(p_SecDcl->p_DriverParam);
XX_Free(p_SecDcl);
return E_OK;
}
/* Initialization Unit (above) */
/*******************************/
/********************************/
/* Runtime Control Unit (below) */
t_Handle SEC_DCL_InitSeqJobDesc(t_Handle h_SecDcl,
t_SeqJobDescParam* p_JobDescParam)
{
t_SecDcl* p_SecDcl = (t_SecDcl*)h_SecDcl;
t_Desc* p_ShrDesc;
uint32_t length;
uint32_t buffer[MAX_DESC_LENGTH];
/* Using MAX_DESC_LENGTH instead of MaxJobDescLen in order to keep it simple */
SANITY_CHECK_EXIT(p_SecDcl,E_INVALID_HANDLE);
SANITY_CHECK_EXIT(p_JobDescParam,E_NULL_POINTER);
p_ShrDesc = (t_Desc*)p_JobDescParam->h_ShrDesc;
SANITY_CHECK_EXIT(p_ShrDesc,E_INVALID_HANDLE);
/* Verify that casting from (uint8_t*) to (uint32_t*) can be applied safely */
ASSERT_COND((CAST_POINTER_TO_UINT64(p_ShrDesc->p_Buffer)%sizeof(uint32_t))==0);
length = InitSeqJobDesc(buffer,
p_SecDcl->ptrSize,
(uint32_t*)p_ShrDesc->p_Buffer,
p_JobDescParam->inputSeq.sgt,
p_JobDescParam->inputSeq.size,
p_JobDescParam->inputSeq.p_Data,
p_JobDescParam->outputSeq.sgt,
p_JobDescParam->outputSeq.size,
p_JobDescParam->outputSeq.p_Data);
return CreateDescObject(p_SecDcl,length,buffer);
}
t_Handle SEC_DCL_InitSplitKeyJobDesc(t_Handle h_SecDcl,
t_SplitKeyJobDescParam* p_JobDescParam)
{
t_SecDcl* p_SecDcl = (t_SecDcl*)h_SecDcl;
uint32_t length;
uint32_t buffer[MAX_DESC_LENGTH];
/* Using MAX_DESC_LENGTH instead of MaxJobDescLen in order to keep it simple */
SANITY_CHECK_EXIT(p_SecDcl,E_INVALID_HANDLE);
SANITY_CHECK_EXIT(p_JobDescParam,E_NULL_POINTER);
length = InitSplitKeyJobDesc(buffer,
p_SecDcl->ptrSize,
p_JobDescParam->p_InputKey,
p_JobDescParam->p_OutputKey,
p_JobDescParam->hashAlg);
return CreateDescObject(p_SecDcl,length,buffer);
}
t_Handle SEC_DCL_InitIpsecEncapShrDesc(t_Handle h_SecDcl,
t_IpsecShrDescParam* p_ShrDescParam,
t_IpsecEncapParam* p_EncapParam)
{
t_SecDcl* p_SecDcl = (t_SecDcl*)h_SecDcl;
uint32_t length;
uint32_t buffer[MAX_DESC_LENGTH];
/* Using MAX_DESC_LENGTH instead of MaxJobDescLen in order to keep it simple */
SANITY_CHECK_EXIT(p_SecDcl,E_INVALID_HANDLE);
SANITY_CHECK_EXIT(p_ShrDescParam,E_NULL_POINTER);
SANITY_CHECK_EXIT(p_EncapParam,E_NULL_POINTER);
length = InitIpsecEncapShrDesc(buffer,
p_SecDcl->ptrSize,
p_ShrDescParam->dataMoveSize,
p_ShrDescParam->cryptoKey.imm,
p_ShrDescParam->cryptoKey.size,
p_ShrDescParam->cryptoKey.p_Data,
p_ShrDescParam->authenKey.imm,
p_ShrDescParam->authenKey.size,
p_ShrDescParam->authenKey.p_Data,
p_ShrDescParam->cryptoAlg,
p_ShrDescParam->authenAlg,
p_EncapParam);
return CreateDescObject(p_SecDcl,length,buffer);
}
t_Handle SEC_DCL_InitIpsecDecapShrDesc(t_Handle h_SecDcl,
t_IpsecShrDescParam* p_ShrDescParam,
t_IpsecDecapParam* p_DecapParam)
{
t_SecDcl* p_SecDcl = (t_SecDcl*)h_SecDcl;
uint32_t length;
uint32_t buffer[MAX_DESC_LENGTH];
/* Using MAX_DESC_LENGTH instead of MaxShrDescLen in order to keep it simple */
SANITY_CHECK_EXIT(p_SecDcl,E_INVALID_HANDLE);
SANITY_CHECK_EXIT(p_ShrDescParam,E_NULL_POINTER);
SANITY_CHECK_EXIT(p_DecapParam,E_NULL_POINTER);
length = InitIpsecDecapShrDesc(buffer,
p_SecDcl->ptrSize,
p_ShrDescParam->dataMoveSize,
p_ShrDescParam->cryptoKey.imm,
p_ShrDescParam->cryptoKey.size,
p_ShrDescParam->cryptoKey.p_Data,
p_ShrDescParam->authenKey.imm,
p_ShrDescParam->authenKey.size,
p_ShrDescParam->authenKey.p_Data,
p_ShrDescParam->cryptoAlg,
p_ShrDescParam->authenAlg,
p_DecapParam);
return CreateDescObject(p_SecDcl,length,buffer);
}
t_Handle SEC_DCL_InitDtlsEncapShrDesc(t_Handle h_SecDcl,
t_DtlsShrDescParam* p_ShrDescParam,
t_DtlsEncapParam* p_EncapParam)
{
t_SecDcl* p_SecDcl = (t_SecDcl*)h_SecDcl;
uint32_t length;
uint32_t buffer[MAX_DESC_LENGTH];
/* Using MAX_DESC_LENGTH instead of MaxShrDescLen in order to keep it simple */
SANITY_CHECK_EXIT(p_SecDcl,E_INVALID_HANDLE);
SANITY_CHECK_EXIT(p_ShrDescParam,E_NULL_POINTER);
SANITY_CHECK_EXIT(p_EncapParam,E_NULL_POINTER);
length = InitDtlsEncapShrDesc(buffer,
p_SecDcl->ptrSize,
p_ShrDescParam->dataMoveSize,
p_ShrDescParam->cryptoKey.imm,
p_ShrDescParam->cryptoKey.size,
p_ShrDescParam->cryptoKey.p_Data,
p_ShrDescParam->authenKey.imm,
p_ShrDescParam->authenKey.size,
p_ShrDescParam->authenKey.p_Data,
p_ShrDescParam->cipherAlg,
p_EncapParam);
return CreateDescObject(p_SecDcl,length,buffer);
}
t_Handle SEC_DCL_InitDtlsDecapShrDesc(t_Handle h_SecDcl,
t_DtlsShrDescParam* p_ShrDescParam,
t_DtlsDecapParam* p_DecapParam)
{
t_SecDcl* p_SecDcl = (t_SecDcl*)h_SecDcl;
uint32_t length;
uint32_t buffer[MAX_DESC_LENGTH];
/* Using MAX_DESC_LENGTH instead of MaxShrDescLen in order to keep it simple */
SANITY_CHECK_EXIT(p_SecDcl,E_INVALID_HANDLE);
SANITY_CHECK_EXIT(p_ShrDescParam,E_NULL_POINTER);
SANITY_CHECK_EXIT(p_DecapParam,E_NULL_POINTER);
length = InitDtlsDecapShrDesc(buffer,
p_SecDcl->ptrSize,
p_ShrDescParam->dataMoveSize,
p_ShrDescParam->cryptoKey.imm,
p_ShrDescParam->cryptoKey.size,
p_ShrDescParam->cryptoKey.p_Data,
p_ShrDescParam->authenKey.imm,
p_ShrDescParam->authenKey.size,
p_ShrDescParam->authenKey.p_Data,
p_ShrDescParam->cipherAlg,
p_DecapParam);
return CreateDescObject(p_SecDcl,length,buffer);
}
t_Handle SEC_DCL_InitMacsecEncapShrDesc(t_Handle h_SecDcl,
t_MacsecShrDescParam* p_ShrDescParam,
t_MacsecEncapParam* p_EncapParam)
{
t_SecDcl* p_SecDcl = (t_SecDcl*)h_SecDcl;
uint32_t length;
uint32_t buffer[MAX_DESC_LENGTH];
/* Using MAX_DESC_LENGTH instead of MaxShrDescLen in order to keep it simple */
SANITY_CHECK_EXIT(p_SecDcl,E_INVALID_HANDLE);
SANITY_CHECK_EXIT(p_ShrDescParam,E_NULL_POINTER);
SANITY_CHECK_EXIT(p_EncapParam,E_NULL_POINTER);
length = InitMacsecEncapShrDesc(buffer,
p_SecDcl->ptrSize,
p_ShrDescParam->dataMoveSize,
p_ShrDescParam->cipherKey.imm,
p_ShrDescParam->cipherKey.size,
p_ShrDescParam->cipherKey.p_Data,
p_ShrDescParam->cipherAlg,
p_EncapParam);
return CreateDescObject(p_SecDcl,length,buffer);
}
t_Handle SEC_DCL_InitMacsecDecapShrDesc(t_Handle h_SecDcl,
t_MacsecShrDescParam* p_ShrDescParam,
t_MacsecDecapParam* p_DecapParam)
{
t_SecDcl* p_SecDcl = (t_SecDcl*)h_SecDcl;
uint32_t length;
uint32_t buffer[MAX_DESC_LENGTH];
/* Using MAX_DESC_LENGTH instead of MaxShrDescLen in order to keep it simple */
SANITY_CHECK_EXIT(p_SecDcl,E_INVALID_HANDLE);
SANITY_CHECK_EXIT(p_ShrDescParam,E_NULL_POINTER);
SANITY_CHECK_EXIT(p_DecapParam,E_NULL_POINTER);
length = InitMacsecDecapShrDesc(buffer,
p_SecDcl->ptrSize,
p_ShrDescParam->dataMoveSize,
p_ShrDescParam->cipherKey.imm,
p_ShrDescParam->cipherKey.size,
p_ShrDescParam->cipherKey.p_Data,
p_ShrDescParam->cipherAlg,
p_DecapParam);
return CreateDescObject(p_SecDcl,length,buffer);
}
uint8_t* SEC_DCL_GetDescPrefix(t_Handle h_Desc)
{
t_Desc* p_Desc = (t_Desc*)h_Desc;
SANITY_CHECK_EXIT(p_Desc,E_INVALID_HANDLE);
return p_Desc->p_Prefix;
}
uint8_t* SEC_DCL_GetDescBuffer(t_Handle h_Desc)
{
t_Desc* p_Desc = (t_Desc*)h_Desc;
SANITY_CHECK_EXIT(p_Desc,E_INVALID_HANDLE);
return p_Desc->p_Buffer;
}
uint8_t* SEC_DCL_GetDescPostfix(t_Handle h_Desc)
{
t_Desc* p_Desc = (t_Desc*)h_Desc;
SANITY_CHECK_EXIT(p_Desc,E_INVALID_HANDLE);
return p_Desc->p_Postfix;
}
uint32_t SEC_DCL_GetBufferSize(t_Handle h_Desc)
{
t_Desc* p_Desc = (t_Desc*)h_Desc;
SANITY_CHECK_EXIT(p_Desc,E_INVALID_HANDLE);
return p_Desc->bufferSize;
}
void SEC_DCL_FreeDesc(t_Handle h_Desc)
{
t_Desc* p_Desc = (t_Desc*)h_Desc;
SANITY_CHECK_EXIT(p_Desc,E_INVALID_HANDLE);
SANITY_CHECK_EXIT(p_Desc->p_Mem,E_INVALID_STATE);
/* wind river start */
#ifdef SEC4_PREALLOC_DESC_BUF
/* Use pre allocated buffer pools for increased performance */
/* Return to pre-allocated buffer pool*/
MEM_Put(p_Desc->h_SecMemSmart, p_Desc->p_Mem);
MEM_Put(p_Desc->h_SecMem, p_Desc);
#else
XX_FreeSmart(p_Desc->p_Mem);
#ifdef SEC4_USE_QI
XX_FreeSmart(p_Desc);
#else
XX_Free(p_Desc);
#endif
#endif
/* wind river end */
}
/* Runtime Control Unit (above) */
/********************************/
/*****************************/
/* Internal Routines (below) */
static t_Error CheckInitParameters(t_SecDcl* p_SecDcl)
{
if (p_SecDcl->p_DriverParam->h_Sec == NULL)
RETURN_ERROR(MAJOR,E_INVALID_HANDLE,("SEC object"));
if (p_SecDcl->p_DriverParam->alignment % sizeof(uint32_t))
RETURN_ERROR(MAJOR,E_INVALID_VALUE,("Descriptor buffer alignment must a multiple of %u",sizeof(uint32_t)));
if (!IN_RANGE(MIN_VAL_alignment,p_SecDcl->p_DriverParam->alignment,MAX_VAL_alignment))
RETURN_ERROR(MAJOR,E_NOT_IN_RANGE,("Descriptor buffer alignment must be between %u and %u",MIN_VAL_alignment,MAX_VAL_alignment));
return E_OK;
}
/* static */ /* wind river */
t_Handle CreateDescObject(t_SecDcl* p_SecDcl,uint32_t length,uint32_t* p_Buffer)
{
t_Desc* p_Desc;
int memId = p_SecDcl->memId ;
uint32_t alignment = p_SecDcl->alignment ;
uint32_t prefixSize = p_SecDcl->prefixSize ;
uint32_t postfixSize = p_SecDcl->postfixSize;
uint32_t bufferSize = length*sizeof(uint32_t);
uint32_t newAlignment = DIV_CEIL(prefixSize,alignment)*alignment;
/* [newAlignment >= prefixSize] AND [newAlignment == N*alignment] */
/* wind river start */
#ifdef SEC4_PREALLOC_DESC_BUF
t_Handle h_Mem;
/* Use pre allocated buffers for increased performance */
#ifdef SEC4_USE_QI
/* Allocate job descriptor objects from shared memory as well so that any core can release it
* E.g. shared descriptors */
p_Desc = MEM_Get(p_SecDcl->h_SecMemSmart);
h_Mem = p_SecDcl->h_SecMemSmart;
#else
p_Desc = MEM_Get(p_SecDcl->h_SecMem);
h_Mem = p_SecDcl->h_SecMem;
#endif /* #ifdef SEC4_USE_QI */
#else
#ifdef SEC4_USE_QI
/* Allocate job descriptor objects from shared memory as well so that any core can release it
* E.g. shared descriptors */
p_Desc = XX_MallocSmart(sizeof(t_Desc), memId, alignment);
#else
p_Desc = XX_Malloc(sizeof(t_Desc));
#endif /* #ifdef SEC4_USE_QI */
#endif /* #ifdef SEC4_PREALLOC_DESC_BUF */
/* wind river end */
if (p_Desc == NULL)
{
REPORT_ERROR(MAJOR,E_NO_MEMORY,("Descriptor object"));
return NULL;
}
/* wind river start */
#ifdef SEC4_PREALLOC_DESC_BUF
p_Desc->h_SecMem = h_Mem;
#endif /* #ifdef SEC4_PREALLOC_DESC_BUF */
/* wind river start */
#ifdef SEC4_PREALLOC_DESC_BUF
/* Use pre allocated buffers for increased performance */
p_Desc->p_Mem = MEM_Get(p_SecDcl->h_SecMemSmart);
h_Mem = p_SecDcl->h_SecMemSmart;
#else
p_Desc->p_Mem = XX_MallocSmart(newAlignment+bufferSize+postfixSize,memId,newAlignment);
#endif
/* wind river end */
if (p_Desc->p_Mem == NULL)
{
/* wind river start */
#ifdef SEC4_PREALLOC_DESC_BUF
MEM_Put(p_SecDcl->h_SecMem, p_Desc);
#else
XX_Free(p_Desc);
#endif
/* wind river end */
REPORT_ERROR(MAJOR,E_NO_MEMORY,("Descriptor buffer"));
return NULL;
}
/* wind river start */
#ifdef SEC4_PREALLOC_DESC_BUF
p_Desc->h_SecMemSmart = h_Mem;
#endif
/* wind river end */
p_Desc->p_Prefix = p_Desc->p_Mem+newAlignment-prefixSize;
p_Desc->p_Buffer = p_Desc->p_Mem+newAlignment;
p_Desc->p_Postfix = p_Desc->p_Mem+newAlignment+bufferSize;
p_Desc->bufferSize = bufferSize;
memcpy(p_Desc->p_Buffer,p_Buffer,bufferSize);
return (t_Handle)p_Desc;
}
/* Internal Routines (above) */
/*****************************/
components/ip_net2-6.9/ipfreescale/sec4/NetCommSw/Peripherals/SEC/DCL/sec_dcl.h
+83
View File
@@ -0,0 +1,83 @@
/******************************************************************************
� 1995-2003, 2004, 2005-2010 Freescale Semiconductor, Inc.
All rights reserved.
This is proprietary source code of Freescale Semiconductor Inc.,
and its use is subject to the NetComm Device Drivers EULA.
The copyright notice above does not evidence any actual or intended
publication of such source code.
**************************************************************************/
#ifndef __SEC_DCL_H
#define __SEC_DCL_H
#include "sec_dcl_ext.h"
typedef struct t_SecDclDriverParam
{
t_Handle h_Sec ; /* SEC object */
int memId ; /* Memory partition ID */
uint32_t alignment ; /* Alignment of each descriptor buffer */
uint32_t prefixSize ; /* Size of data preceding each descriptor buffer */
uint32_t postfixSize; /* Size of data succeeding each descriptor buffer */
/* wind river start */
#ifdef SEC4_PREALLOC_DESC_BUF
uint32_t noofBuf ; /* Number of allocated descriptor objects */
uint32_t descSize ; /* Size of data for descriptor objects */
uint32_t descBufSize; /* Size of data for descriptor buffers */
#endif
/* wind river end */
}
t_SecDclDriverParam;
typedef struct t_SecDcl
{
t_SecDclDriverParam* p_DriverParam; /* Driver parameters */
uint32_t ptrSize ; /* SEC pointer size */
int memId ; /* Memory partition ID */
uint32_t alignment ; /* Alignment of each descriptor buffer */
uint32_t prefixSize ; /* Size of data preceding each descriptor buffer */
uint32_t postfixSize; /* Size of data succeeding each descriptor buffer */
/* wind river start */
#ifdef SEC4_PREALLOC_DESC_BUF
uint32_t noofBuf ; /* Number of allocated descriptor objects */
uint32_t descSize ; /* Size of data for descriptor objects */
uint32_t descBufSize; /* Size of data for descriptor buffers */
t_Handle h_SecMem ; /* Handle for pre-allocated memory for descriptor objects */
t_Handle h_SecMemSmart; /* Handle for pre-allocated memory for descriptor buffers */
#endif
/* wind river end */
}
t_SecDcl;
typedef struct t_Desc
{
uint8_t* p_Mem ; /* Pointer to allocated memory */
uint8_t* p_Prefix ; /* Pointer to data preceding the descriptor buffer */
uint8_t* p_Buffer ; /* Pointer to the descriptor buffer */
uint8_t* p_Postfix ; /* Pointer to data succeeding the descriptor buffer */
uint32_t bufferSize; /* Size of the descriptor buffer */
/* wind river start */
#ifdef SEC4_PREALLOC_DESC_BUF
t_Handle h_SecMem ; /* Handle for pre-allocated memory for descriptor objects */
t_Handle h_SecMemSmart; /* Handle for pre-allocated memory for descriptor buffers */
#endif
/* wind river end */
}
t_Desc;
/* wind river start */
t_Handle CreateDescObject(t_SecDcl* p_SecDcl,uint32_t length,uint32_t* p_Buffer);
/* wind river end */
#define MIN_VAL_alignment 4
#define MAX_VAL_alignment 256
#endif /* __SEC_DCL_H */
components/ip_net2-6.9/ipfreescale/sec4/NetCommSw/Peripherals/SEC/DCL/sec_dcl_api.c
+774
View File
@@ -0,0 +1,774 @@
/******************************************************************************
� 1995-2003, 2004, 2005-2010 Freescale Semiconductor, Inc.
All rights reserved.
This is proprietary source code of Freescale Semiconductor Inc.,
and its use is subject to the NetComm Device Drivers EULA.
The copyright notice above does not evidence any actual or intended
publication of such source code.
**************************************************************************/
/* Include the internal definitions of this module */
#include "sec_dcl_api.h"
#include "sec_dcl_cmd.h"
/* Include the external interfaces of other modules */
#include "error_ext.h"
#include "string_ext.h"
#define EXIT_IF(cond) ASSERT_COND(!(cond))
#define KEY_IMM_IF(cond) (uint32_t)((cond)? KEY_IMM:0)
static inline uint32_t CalcSplitKeyCmdFlags(e_SplitKeyHashAlg hashAlg);
static inline uint32_t CalcIpsecCmdFlags(uint32_t initFlags,
e_IpsecCryptoAlg cryptoAlg,
e_IpsecAuthenAlg authenAlg);
static inline uint32_t CalcDtlsCmdFlags(uint32_t initFlags,
e_DtlsCipherAlg cipherAlg);
static inline uint32_t CalcMacsecCmdFlags(uint32_t initFlags,
e_MacsecCipherAlg cipherAlg);
static inline void InsertDataMoveCommands(t_DescHandle* p_DescHandle,
uint32_t dataMoveSize);
static inline void InsertNopCommands(t_DescHandle* p_DescHandle,
uint32_t numOfCommands);
uint32_t MaxJobDescLen()
{
return MAX_DESC_LENGTH;
}
uint32_t MaxShrDescLen(uint32_t ptrSize)
{
return MAX_DESC_LENGTH-1-ptrSize/sizeof(uint32_t);
}
uint32_t InitSeqJobDesc(uint32_t* p_Desc,
uint32_t ptrSize,
uint32_t* p_ShrDesc,
bool inputSeqSgt,
uint32_t inputSeqSize,
uint8_t* p_InputSeqData,
bool outputSeqSgt,
uint32_t outputSeqSize,
uint8_t* p_OutputSeqData)
{
t_DescHandle descHandle = NewDescHandle(p_Desc,ptrSize);
uint32_t cmdFlags;
cmdFlags = JOB_DESC_HDR_REO|JOB_DESC_HDR_SHARE_DEFER;
CmdInsertJobDescRefShrHdr(&descHandle,cmdFlags,p_ShrDesc);
cmdFlags = (uint32_t)(outputSeqSgt? SEQ_OUT_PTR_SGT:NO_CMD_FLAGS);
CmdInsertSeqOutPtr(&descHandle,cmdFlags,outputSeqSize,p_OutputSeqData);
cmdFlags = (uint32_t)(inputSeqSgt? SEQ_IN_PTR_SGT:NO_CMD_FLAGS);
CmdInsertSeqInPtr(&descHandle,cmdFlags,inputSeqSize,p_InputSeqData);
CloseJobDescRefShr(&descHandle,p_ShrDesc);
return descHandle.nextIndex;
}
uint32_t InitSplitKeyJobDesc(uint32_t* p_Desc,
uint32_t ptrSize,
uint8_t* p_InputKey,
uint8_t* p_OutputKey,
e_SplitKeyHashAlg hashAlg)
{
t_DescHandle descHandle = NewDescHandle(p_Desc,ptrSize);
uint32_t inputSize [] = {16,20,28,32, 48, 64};
uint32_t outputSize[] = {32,40,64,64,128,128};
uint32_t cmdFlags;
uint32_t startIndex;
cmdFlags = JOB_DESC_HDR_SHARE_NEVER;
CmdInsertJobDescHdr(&descHandle,cmdFlags);
startIndex = descHandle.nextIndex;
cmdFlags = KEY_CLASS_2_DST_REGISTER;
CmdInsertKey(&descHandle,cmdFlags,inputSize[hashAlg],p_InputKey);
cmdFlags = CalcSplitKeyCmdFlags(hashAlg);
CmdInsertAlgOperation(&descHandle,cmdFlags);
/* FIFO load of 0 bytes in order to kickstart MDHA */
cmdFlags = FIFO_LOAD_CTYPE|FIFO_LOAD_CLASS_2_TYPE_MSG_L2|FIFO_LOAD_IMM;
CmdInsertAnything(&descHandle,cmdFlags);
cmdFlags = FIFO_STORE_CLASS_2_TYPE_MDHA_SPLIT_ECB_JKEK;
CmdInsertFifoStore(&descHandle,cmdFlags,outputSize[hashAlg],p_OutputKey);
CloseJobDesc(&descHandle,startIndex);
return descHandle.nextIndex;
}
uint32_t InitIpsecEncapShrDesc(uint32_t* p_Desc,
uint32_t ptrSize,
uint32_t dataMoveSize,
bool cryptoKeyImm,
uint32_t cryptoKeySize,
uint8_t* p_CryptoKeyData,
bool authenKeyImm,
uint32_t authenKeySize,
uint8_t* p_AuthenKeyData,
e_IpsecCryptoAlg cryptoAlg,
e_IpsecAuthenAlg authenAlg,
t_IpsecEncapParam* p_Param)
{
t_DescHandle descHandle = NewDescHandle(p_Desc,ptrSize);
uint32_t cmdFlags;
uint32_t startIndex;
uint32_t jumpCmdIndex;
t_IpsecEncapPdb pdb;
memset(&pdb,0,sizeof(pdb));
pdb.nextHdr = p_Param->nextHdr ;
pdb.nhOffset = p_Param->nhOffset;
pdb.seqNum = p_Param->seqNum ;
pdb.spi = p_Param->spi ;
pdb.ipHdrLen = p_Param->ipHdrLen;
if (p_Param->copyDf)
pdb.nextHdr |= IPSEC_ENCAP_HMO_DFC;
if (p_Param->decTtl)
pdb.nextHdr |= IPSEC_ENCAP_HMO_DTTL;
if (p_Param->enCksm)
pdb.options |= IPSEC_ENCAP_OPTION_CKSM;
if (p_Param->copyDs)
pdb.options |= IPSEC_ENCAP_OPTION_DSC;
if (p_Param->randIv)
pdb.options |= IPSEC_ENCAP_OPTION_IVSRC;
if (p_Param->extSeqNum)
pdb.options |= IPSEC_ENCAP_OPTION_ESN;
switch (p_Param->ipsecVer)
{
case e_IPSEC_VER_4:
break;
case e_IPSEC_VER_6:
pdb.options |= IPSEC_ENCAP_OPTION_IPV6;
break;
}
switch (p_Param->ipsecHdr)
{
case e_IPSEC_HDR_NONE:
break;
case e_IPSEC_HDR_IN_FRAME:
pdb.options |= IPSEC_ENCAP_OPTION_INC;
break;
case e_IPSEC_HDR_IN_PARAM:
pdb.options |= IPSEC_ENCAP_OPTION_INC;
pdb.options |= IPSEC_ENCAP_OPTION_SRC;
break;
}
switch (p_Param->ipsecMode)
{
case e_IPSEC_MODE_TRANSPORT:
break;
case e_IPSEC_MODE_TUNNEL:
pdb.options |= IPSEC_ENCAP_OPTION_TUNNEL;
break;
}
switch (p_Param->ipsecType)
{
case e_IPSEC_TYPE_CBC:
memcpy((void*)pdb.alg.cbc.iv,p_Param->alg.cbc.iv,16);
break;
case e_IPSEC_TYPE_CTR:
pdb.alg.ctr.nonce = p_Param->alg.ctr.nonce ;
pdb.alg.ctr.initCount = p_Param->alg.ctr.initCount;
memcpy((void*)pdb.alg.ctr.iv,p_Param->alg.ctr.iv,8);
break;
case e_IPSEC_TYPE_CCM:
pdb.alg.ccm.salt = p_Param->alg.ccm.salt ;
pdb.alg.ccm.b0Flags = p_Param->alg.ccm.b0Flags ;
pdb.alg.ccm.ctrFlags = p_Param->alg.ccm.ctrFlags ;
pdb.alg.ccm.initCount = p_Param->alg.ccm.initCount;
memcpy((void*)pdb.alg.ccm.iv,p_Param->alg.ccm.iv,8);
break;
case e_IPSEC_TYPE_GCM:
pdb.alg.gcm.salt = p_Param->alg.gcm.salt;
memcpy((void*)pdb.alg.gcm.iv,p_Param->alg.gcm.iv,8);
break;
}
EXIT_IF(p_Param->ipsecMode==e_IPSEC_MODE_TUNNEL && p_Param->nhOffset!=0);
EXIT_IF(p_Param->extSeqNum==FALSE && p_Param->seqNum>=0x00000000FFFFFFFFLL);
EXIT_IF(p_Param->extSeqNum!=FALSE && p_Param->seqNum==0xFFFFFFFFFFFFFFFFLL);
EXIT_IF(p_Param->ipsecHdr==e_IPSEC_HDR_NONE && (p_Param->ipHdrLen!=0 || p_Param->p_IpHdr!=NULL));
EXIT_IF(p_Param->ipsecHdr==e_IPSEC_HDR_IN_FRAME && (p_Param->ipHdrLen==0 || p_Param->p_IpHdr!=NULL));
EXIT_IF(p_Param->ipsecHdr==e_IPSEC_HDR_IN_PARAM && (p_Param->ipHdrLen==0 || p_Param->p_IpHdr==NULL));
cmdFlags = SHR_DESC_HDR_SC|SHR_DESC_HDR_SHARE_SERIAL;
CmdInsertShrDescHdr(&descHandle,cmdFlags);
CmdInsertDataBlock(&descHandle,sizeof(pdb),(uint8_t*)&pdb);
if (p_Param->ipsecHdr == e_IPSEC_HDR_IN_PARAM)
CmdInsertDataBlock(&descHandle,p_Param->ipHdrLen,p_Param->p_IpHdr);
startIndex = descHandle.nextIndex;
if (dataMoveSize > 0)
InsertDataMoveCommands(&descHandle,dataMoveSize);
jumpCmdIndex = descHandle.nextIndex;
cmdFlags = JUMP_CLASS_BOTH|JUMP_SL_1|JUMP_TEST_ALL_MATCH|JUMP_COND_SL_1_SHRD;
CmdInsertLocalJump(&descHandle,cmdFlags);
cmdFlags = KEY_CLASS_2_DST_REGISTER|KEY_IMM_IF(authenKeyImm);
CmdInsertKey(&descHandle,cmdFlags,authenKeySize,p_AuthenKeyData);
cmdFlags = KEY_CLASS_1_DST_REGISTER|KEY_IMM_IF(cryptoKeyImm);
CmdInsertKey(&descHandle,cmdFlags,cryptoKeySize,p_CryptoKeyData);
CmdUpdateLocalJump(&descHandle,jumpCmdIndex);
cmdFlags = CalcIpsecCmdFlags(PCL_OP_TYPE_ENCAP_ID_IPSEC,cryptoAlg,authenAlg);
CmdInsertPclOperation(&descHandle,cmdFlags);
CloseShrDesc(&descHandle,startIndex);
return descHandle.nextIndex;
}
uint32_t InitIpsecDecapShrDesc(uint32_t* p_Desc,
uint32_t ptrSize,
uint32_t dataMoveSize,
bool cryptoKeyImm,
uint32_t cryptoKeySize,
uint8_t* p_CryptoKeyData,
bool authenKeyImm,
uint32_t authenKeySize,
uint8_t* p_AuthenKeyData,
e_IpsecCryptoAlg cryptoAlg,
e_IpsecAuthenAlg authenAlg,
t_IpsecDecapParam* p_Param)
{
t_DescHandle descHandle = NewDescHandle(p_Desc,ptrSize);
uint32_t cmdFlags;
uint32_t startIndex;
uint32_t jumpCmdIndex;
t_IpsecDecapPdb pdb;
memset(&pdb,0,sizeof(pdb));
pdb.ipHdrLen = p_Param->ipHdrLen;
pdb.nhOffset = p_Param->nhOffset;
pdb.seqNum = p_Param->seqNum ;
if (p_Param->decTtl)
pdb.ipHdrLen |= IPSEC_DECAP_HMO_DTTL;
if (p_Param->copyDs)
pdb.ipHdrLen |= IPSEC_DECAP_HMO_DSC;
if (p_Param->enCksm)
pdb.options |= IPSEC_DECAP_OPTION_CKSM;
if (p_Param->extSeqNum)
pdb.options |= IPSEC_DECAP_OPTION_ESN;
if (p_Param->outFmt)
pdb.options |= IPSEC_DECAP_OPTION_FMT;
switch (p_Param->ipsecArs)
{
case e_IPSEC_ARS_0:
break;
case e_IPSEC_ARS_32:
pdb.options |= IPSEC_DECAP_OPTION_ARS32;
break;
case e_IPSEC_ARS_64:
pdb.options |= IPSEC_DECAP_OPTION_ARS64;
break;
}
switch (p_Param->ipsecVer)
{
case e_IPSEC_VER_4:
break;
case e_IPSEC_VER_6:
pdb.options |= IPSEC_DECAP_OPTION_IPV6;
break;
}
switch (p_Param->ipsecMode)
{
case e_IPSEC_MODE_TRANSPORT:
break;
case e_IPSEC_MODE_TUNNEL:
pdb.options |= IPSEC_DECAP_OPTION_TUNNEL;
break;
}
switch (p_Param->ipsecType)
{
case e_IPSEC_TYPE_CBC:
break;
case e_IPSEC_TYPE_CTR:
pdb.alg.ctr.salt = p_Param->alg.ctr.salt ;
pdb.alg.ctr.initCount = p_Param->alg.ctr.initCount;
break;
case e_IPSEC_TYPE_CCM:
pdb.alg.ccm.salt = p_Param->alg.ccm.salt ;
pdb.alg.ccm.ivFlags = p_Param->alg.ccm.ivFlags ;
pdb.alg.ccm.ctrFlags = p_Param->alg.ccm.ctrFlags ;
pdb.alg.ccm.initCount = p_Param->alg.ccm.initCount;
break;
case e_IPSEC_TYPE_GCM:
pdb.alg.gcm.salt = p_Param->alg.gcm.salt;
break;
}
EXIT_IF(p_Param->ipsecMode==e_IPSEC_MODE_TUNNEL && p_Param->nhOffset!=0);
EXIT_IF(p_Param->extSeqNum==FALSE && p_Param->seqNum>=0x00000000FFFFFFFFLL);
EXIT_IF(p_Param->extSeqNum!=FALSE && p_Param->seqNum==0xFFFFFFFFFFFFFFFFLL);
cmdFlags = SHR_DESC_HDR_SC|SHR_DESC_HDR_SHARE_SERIAL;
CmdInsertShrDescHdr(&descHandle,cmdFlags);
CmdInsertDataBlock(&descHandle,sizeof(pdb),(uint8_t*)&pdb);
startIndex = descHandle.nextIndex;
if (dataMoveSize > 0)
InsertDataMoveCommands(&descHandle,dataMoveSize);
jumpCmdIndex = descHandle.nextIndex;
cmdFlags = JUMP_CLASS_BOTH|JUMP_SL_1|JUMP_TEST_ALL_MATCH|JUMP_COND_SL_1_SHRD;
CmdInsertLocalJump(&descHandle,cmdFlags);
cmdFlags = KEY_CLASS_2_DST_REGISTER|KEY_IMM_IF(authenKeyImm);
CmdInsertKey(&descHandle,cmdFlags,authenKeySize,p_AuthenKeyData);
cmdFlags = KEY_CLASS_1_DST_REGISTER|KEY_IMM_IF(cryptoKeyImm);
CmdInsertKey(&descHandle,cmdFlags,cryptoKeySize,p_CryptoKeyData);
CmdUpdateLocalJump(&descHandle,jumpCmdIndex);
cmdFlags = CalcIpsecCmdFlags(PCL_OP_TYPE_DECAP_ID_IPSEC,cryptoAlg,authenAlg);
CmdInsertPclOperation(&descHandle,cmdFlags);
CloseShrDesc(&descHandle,startIndex);
return descHandle.nextIndex;
}
uint32_t InitDtlsEncapShrDesc(uint32_t* p_Desc,
uint32_t ptrSize,
uint32_t dataMoveSize,
bool cryptoKeyImm,
uint32_t cryptoKeySize,
uint8_t* p_CryptoKeyData,
bool authenKeyImm,
uint32_t authenKeySize,
uint8_t* p_AuthenKeyData,
e_DtlsCipherAlg cipherAlg,
t_DtlsEncapParam* p_Param)
{
t_DescHandle descHandle = NewDescHandle(p_Desc,ptrSize);
uint32_t cmdFlags;
uint32_t startIndex;
uint32_t jumpCmdIndex;
t_DtlsEncapPdb pdb;
memset(&pdb,0,sizeof(pdb));
pdb.type = p_Param->type ;
pdb.version = p_Param->version;
pdb.epoch = p_Param->epoch ;
if (p_Param->wbIv)
pdb.options |= DTLS_ENCAP_OPTION_W_B;
if (p_Param->expIv)
pdb.options |= DTLS_ENCAP_OPTION_E_I;
pdb.seqNum1 = DTLS_ENCAP_SEQ_NUM_1(p_Param->seqNum);
pdb.seqNum2 = DTLS_ENCAP_SEQ_NUM_2(p_Param->seqNum);
memcpy((void*)pdb.iv,p_Param->iv,16);
EXIT_IF(p_Param->seqNum >= 0x0000FFFFFFFFFFFFLL);
cmdFlags = SHR_DESC_HDR_SC|SHR_DESC_HDR_SHARE_SERIAL;
CmdInsertShrDescHdr(&descHandle,cmdFlags);
CmdInsertDataBlock(&descHandle,sizeof(pdb),(uint8_t*)&pdb);
startIndex = descHandle.nextIndex;
if (dataMoveSize > 0)
InsertDataMoveCommands(&descHandle,dataMoveSize);
jumpCmdIndex = descHandle.nextIndex;
cmdFlags = JUMP_CLASS_BOTH|JUMP_SL_1|JUMP_TEST_ALL_MATCH|JUMP_COND_SL_1_SHRD;
CmdInsertLocalJump(&descHandle,cmdFlags);
cmdFlags = KEY_CLASS_2_DST_REGISTER|KEY_IMM_IF(authenKeyImm);
CmdInsertKey(&descHandle,cmdFlags,authenKeySize,p_AuthenKeyData);
cmdFlags = KEY_CLASS_1_DST_REGISTER|KEY_IMM_IF(cryptoKeyImm);
CmdInsertKey(&descHandle,cmdFlags,cryptoKeySize,p_CryptoKeyData);
CmdUpdateLocalJump(&descHandle,jumpCmdIndex);
cmdFlags = CalcDtlsCmdFlags(PCL_OP_TYPE_ENCAP_ID_DTLS,cipherAlg);
CmdInsertPclOperation(&descHandle,cmdFlags);
CloseShrDesc(&descHandle,startIndex);
return descHandle.nextIndex;
}
uint32_t InitDtlsDecapShrDesc(uint32_t* p_Desc,
uint32_t ptrSize,
uint32_t dataMoveSize,
bool cryptoKeyImm,
uint32_t cryptoKeySize,
uint8_t* p_CryptoKeyData,
bool authenKeyImm,
uint32_t authenKeySize,
uint8_t* p_AuthenKeyData,
e_DtlsCipherAlg cipherAlg,
t_DtlsDecapParam* p_Param)
{
t_DescHandle descHandle = NewDescHandle(p_Desc,ptrSize);
uint32_t cmdFlags;
uint32_t startIndex;
uint32_t jumpCmdIndex;
t_DtlsDecapPdb pdb;
memset(&pdb,0,sizeof(pdb));
pdb.epoch = p_Param->epoch;
if (p_Param->wbIv)
pdb.options |= DTLS_DECAP_OPTION_W_B;
if (p_Param->expIv)
pdb.options |= DTLS_DECAP_OPTION_E_I;
pdb.seqNum1 = DTLS_DECAP_SEQ_NUM_1(p_Param->seqNum);
pdb.seqNum2 = DTLS_DECAP_SEQ_NUM_2(p_Param->seqNum);
memcpy((void*)pdb.iv,p_Param->iv,16);
switch (p_Param->dtlsArs)
{
case e_DTLS_ARS_0:
break;
case e_DTLS_ARS_32:
pdb.options |= DTLS_DECAP_OPTION_ARS32;
break;
case e_DTLS_ARS_64:
pdb.options |= DTLS_DECAP_OPTION_ARS64;
break;
}
EXIT_IF(p_Param->seqNum >= 0x0000FFFFFFFFFFFFLL);
cmdFlags = SHR_DESC_HDR_SC|SHR_DESC_HDR_SHARE_SERIAL;
CmdInsertShrDescHdr(&descHandle,cmdFlags);
CmdInsertDataBlock(&descHandle,sizeof(pdb),(uint8_t*)&pdb);
startIndex = descHandle.nextIndex;
if (dataMoveSize > 0)
InsertDataMoveCommands(&descHandle,dataMoveSize);
jumpCmdIndex = descHandle.nextIndex;
cmdFlags = JUMP_CLASS_BOTH|JUMP_SL_1|JUMP_TEST_ALL_MATCH|JUMP_COND_SL_1_SHRD;
CmdInsertLocalJump(&descHandle,cmdFlags);
cmdFlags = KEY_CLASS_2_DST_REGISTER|KEY_IMM_IF(authenKeyImm);
CmdInsertKey(&descHandle,cmdFlags,authenKeySize,p_AuthenKeyData);
cmdFlags = KEY_CLASS_1_DST_REGISTER|KEY_IMM_IF(cryptoKeyImm);
CmdInsertKey(&descHandle,cmdFlags,cryptoKeySize,p_CryptoKeyData);
CmdUpdateLocalJump(&descHandle,jumpCmdIndex);
cmdFlags = CalcDtlsCmdFlags(PCL_OP_TYPE_DECAP_ID_DTLS,cipherAlg);
CmdInsertPclOperation(&descHandle,cmdFlags);
CloseShrDesc(&descHandle,startIndex);
return descHandle.nextIndex;
}
uint32_t InitMacsecEncapShrDesc(uint32_t* p_Desc,
uint32_t ptrSize,
uint32_t dataMoveSize,
bool cipherKeyImm,
uint32_t cipherKeySize,
uint8_t* p_CipherKeyData,
e_MacsecCipherAlg cipherAlg,
t_MacsecEncapParam* p_Param)
{
t_DescHandle descHandle = NewDescHandle(p_Desc,ptrSize);
uint32_t cmdFlags;
uint32_t startIndex;
uint32_t jumpCmdIndex;
t_MacsecEncapPdb pdb;
memset(&pdb,0,sizeof(pdb));
pdb.aadLength = p_Param->aadLength;
pdb.sci = p_Param->sci ;
pdb.etherType = p_Param->etherType;
pdb.tciAn = p_Param->tciAn ;
pdb.pn = p_Param->pn ;
cmdFlags = SHR_DESC_HDR_SC|SHR_DESC_HDR_SHARE_SERIAL;
CmdInsertShrDescHdr(&descHandle,cmdFlags);
CmdInsertDataBlock(&descHandle,sizeof(pdb),(uint8_t*)&pdb);
startIndex = descHandle.nextIndex;
if (dataMoveSize > 0)
InsertDataMoveCommands(&descHandle,dataMoveSize);
jumpCmdIndex = descHandle.nextIndex;
cmdFlags = JUMP_CLASS_1|JUMP_SL_1|JUMP_TEST_ALL_MATCH|JUMP_COND_SL_1_SHRD;
CmdInsertLocalJump(&descHandle,cmdFlags);
cmdFlags = KEY_CLASS_1_DST_REGISTER|KEY_IMM_IF(cipherKeyImm);
CmdInsertKey(&descHandle,cmdFlags,cipherKeySize,p_CipherKeyData);
CmdUpdateLocalJump(&descHandle,jumpCmdIndex);
cmdFlags = CalcMacsecCmdFlags(PCL_OP_TYPE_ENCAP_ID_MACSEC,cipherAlg);
CmdInsertPclOperation(&descHandle,cmdFlags);
CloseShrDesc(&descHandle,startIndex);
return descHandle.nextIndex;
}
uint32_t InitMacsecDecapShrDesc(uint32_t* p_Desc,
uint32_t ptrSize,
uint32_t dataMoveSize,
bool cipherKeyImm,
uint32_t cipherKeySize,
uint8_t* p_CipherKeyData,
e_MacsecCipherAlg cipherAlg,
t_MacsecDecapParam* p_Param)
{
t_DescHandle descHandle = NewDescHandle(p_Desc,ptrSize);
uint32_t cmdFlags;
uint32_t startIndex;
uint32_t jumpCmdIndex;
t_MacsecDecapPdb pdb;
memset(&pdb,0,sizeof(pdb));
pdb.aadLength = p_Param->aadLength;
pdb.sci = p_Param->sci ;
pdb.arLen = p_Param->arLen ;
pdb.pn = p_Param->pn ;
if (p_Param->enAr)
pdb.options |= MACSEC_DECAP_OPTION_AR;
cmdFlags = SHR_DESC_HDR_SC|SHR_DESC_HDR_SHARE_SERIAL;
CmdInsertShrDescHdr(&descHandle,cmdFlags);
CmdInsertDataBlock(&descHandle,sizeof(pdb),(uint8_t*)&pdb);
startIndex = descHandle.nextIndex;
if (dataMoveSize > 0)
InsertDataMoveCommands(&descHandle,dataMoveSize);
jumpCmdIndex = descHandle.nextIndex;
cmdFlags = JUMP_CLASS_1|JUMP_SL_1|JUMP_TEST_ALL_MATCH|JUMP_COND_SL_1_SHRD;
CmdInsertLocalJump(&descHandle,cmdFlags);
cmdFlags = KEY_CLASS_1_DST_REGISTER|KEY_IMM_IF(cipherKeyImm);
CmdInsertKey(&descHandle,cmdFlags,cipherKeySize,p_CipherKeyData);
CmdUpdateLocalJump(&descHandle,jumpCmdIndex);
cmdFlags = CalcMacsecCmdFlags(PCL_OP_TYPE_DECAP_ID_MACSEC,cipherAlg);
CmdInsertPclOperation(&descHandle,cmdFlags);
CloseShrDesc(&descHandle,startIndex);
return descHandle.nextIndex;
}
static inline uint32_t CalcSplitKeyCmdFlags(e_SplitKeyHashAlg hashAlg)
{
uint32_t cmdFlags = ALG_OP_TYPE_CLASS_2|ALG_OP_AAI_MDS_SHA_HMAC|ALG_OP_AS_INIT|ALG_OP_DIR_DEC;
switch (hashAlg)
{
case e_SPLIT_KEY_HASH_ALG_MD5 : cmdFlags |= ALG_OP_ID_MD5 ; break;
case e_SPLIT_KEY_HASH_ALG_SHA1 : cmdFlags |= ALG_OP_ID_SHA1 ; break;
case e_SPLIT_KEY_HASH_ALG_SHA2_224: cmdFlags |= ALG_OP_ID_SHA2_224; break;
case e_SPLIT_KEY_HASH_ALG_SHA2_256: cmdFlags |= ALG_OP_ID_SHA2_256; break;
case e_SPLIT_KEY_HASH_ALG_SHA2_384: cmdFlags |= ALG_OP_ID_SHA2_384; break;
case e_SPLIT_KEY_HASH_ALG_SHA2_512: cmdFlags |= ALG_OP_ID_SHA2_512; break;
}
return cmdFlags;
}
static inline uint32_t CalcIpsecCmdFlags(uint32_t initFlags,
e_IpsecCryptoAlg cryptoAlg,
e_IpsecAuthenAlg authenAlg)
{
uint32_t cmdFlags = initFlags;
switch (cryptoAlg)
{
case e_IPSEC_CRYPTO_ALG_DES : cmdFlags |= PCL_OP_INFO_IPSEC_DES ; break;
case e_IPSEC_CRYPTO_ALG_3DES : cmdFlags |= PCL_OP_INFO_IPSEC_3DES ; break;
case e_IPSEC_CRYPTO_ALG_NULL_ENC : cmdFlags |= PCL_OP_INFO_IPSEC_NULL_ENC ; break;
case e_IPSEC_CRYPTO_ALG_AES_CBC : cmdFlags |= PCL_OP_INFO_IPSEC_AES_CBC ; break;
case e_IPSEC_CRYPTO_ALG_AES_CTR : cmdFlags |= PCL_OP_INFO_IPSEC_AES_CTR ; break;
case e_IPSEC_CRYPTO_ALG_AES_CCM8 : cmdFlags |= PCL_OP_INFO_IPSEC_AES_CCM8 ; break;
case e_IPSEC_CRYPTO_ALG_AES_CCM12: cmdFlags |= PCL_OP_INFO_IPSEC_AES_CCM12; break;
case e_IPSEC_CRYPTO_ALG_AES_CCM16: cmdFlags |= PCL_OP_INFO_IPSEC_AES_CCM16; break;
case e_IPSEC_CRYPTO_ALG_AES_GCM8 : cmdFlags |= PCL_OP_INFO_IPSEC_AES_GCM8 ; break;
case e_IPSEC_CRYPTO_ALG_AES_GCM12: cmdFlags |= PCL_OP_INFO_IPSEC_AES_GCM12; break;
case e_IPSEC_CRYPTO_ALG_AES_GCM16: cmdFlags |= PCL_OP_INFO_IPSEC_AES_GCM16; break;
case e_IPSEC_CRYPTO_ALG_AES_GMAC : cmdFlags |= PCL_OP_INFO_IPSEC_AES_GMAC ; break;
case e_IPSEC_CRYPTO_ALG_AES_XTS : cmdFlags |= PCL_OP_INFO_IPSEC_AES_XTS ; break;
}
switch (authenAlg)
{
case e_IPSEC_AUTHEN_ALG_AES_CCM_GCM : cmdFlags |= PCL_OP_INFO_IPSEC_AES_CCM_GCM ; break;
case e_IPSEC_AUTHEN_ALG_HMAC_MD5_96 : cmdFlags |= PCL_OP_INFO_IPSEC_HMAC_MD5_96 ; break;
case e_IPSEC_AUTHEN_ALG_HMAC_SHA1_96 : cmdFlags |= PCL_OP_INFO_IPSEC_HMAC_SHA1_96 ; break;
case e_IPSEC_AUTHEN_ALG_AES_XCBC_MAC_96 : cmdFlags |= PCL_OP_INFO_IPSEC_AES_XCBC_MAC_96 ; break;
case e_IPSEC_AUTHEN_ALG_HMAC_MD5_128 : cmdFlags |= PCL_OP_INFO_IPSEC_HMAC_MD5_128 ; break;
case e_IPSEC_AUTHEN_ALG_HMAC_SHA1_160 : cmdFlags |= PCL_OP_INFO_IPSEC_HMAC_SHA1_160 ; break;
case e_IPSEC_AUTHEN_ALG_AES_CMAC_96 : cmdFlags |= PCL_OP_INFO_IPSEC_AES_CMAC_96 ; break;
case e_IPSEC_AUTHEN_ALG_HMAC_SHA2_256_128: cmdFlags |= PCL_OP_INFO_IPSEC_HMAC_SHA2_256_128; break;
case e_IPSEC_AUTHEN_ALG_HMAC_SHA2_384_192: cmdFlags |= PCL_OP_INFO_IPSEC_HMAC_SHA2_384_192; break;
case e_IPSEC_AUTHEN_ALG_HMAC_SHA2_512_256: cmdFlags |= PCL_OP_INFO_IPSEC_HMAC_SHA2_512_256; break;
}
return cmdFlags;
}
static inline uint32_t CalcDtlsCmdFlags(uint32_t initFlags,
e_DtlsCipherAlg cipherAlg)
{
uint32_t cmdFlags = initFlags;
switch (cipherAlg)
{
case e_DTLS_CIPHER_ALG_RC4_40_MD5 : cmdFlags |= PCL_OP_INFO_DTLS_RC4_40_MD5 ; break;
case e_DTLS_CIPHER_ALG_RC4_128_MD5 : cmdFlags |= PCL_OP_INFO_DTLS_RC4_128_MD5 ; break;
case e_DTLS_CIPHER_ALG_RC4_128_SHA : cmdFlags |= PCL_OP_INFO_DTLS_RC4_128_SHA ; break;
case e_DTLS_CIPHER_ALG_DES40_CBC_SHA : cmdFlags |= PCL_OP_INFO_DTLS_DES40_CBC_SHA ; break;
case e_DTLS_CIPHER_ALG_DES_CBC_SHA : cmdFlags |= PCL_OP_INFO_DTLS_DES_CBC_SHA ; break;
case e_DTLS_CIPHER_ALG_3DES_EDE_CBC_SHA : cmdFlags |= PCL_OP_INFO_DTLS_3DES_EDE_CBC_SHA ; break;
case e_DTLS_CIPHER_ALG_DES_CBC_MD5 : cmdFlags |= PCL_OP_INFO_DTLS_DES_CBC_MD5 ; break;
case e_DTLS_CIPHER_ALG_3DES_EDE_CBC_MD5 : cmdFlags |= PCL_OP_INFO_DTLS_3DES_EDE_CBC_MD5 ; break;
case e_DTLS_CIPHER_ALG_RC4_40_SHA : cmdFlags |= PCL_OP_INFO_DTLS_RC4_40_SHA ; break;
case e_DTLS_CIPHER_ALG_DES40_CBC_MD5 : cmdFlags |= PCL_OP_INFO_DTLS_DES40_CBC_MD5 ; break;
case e_DTLS_CIPHER_ALG_AES_128_CBC_SHA : cmdFlags |= PCL_OP_INFO_DTLS_AES_128_CBC_SHA ; break;
case e_DTLS_CIPHER_ALG_AES_256_CBC_SHA : cmdFlags |= PCL_OP_INFO_DTLS_AES_256_CBC_SHA ; break;
case e_DTLS_CIPHER_ALG_AES_128_CBC_SHA_256 : cmdFlags |= PCL_OP_INFO_DTLS_AES_128_CBC_SHA_256 ; break;
case e_DTLS_CIPHER_ALG_AES_256_CBC_SHA_256 : cmdFlags |= PCL_OP_INFO_DTLS_AES_256_CBC_SHA_256 ; break;
case e_DTLS_CIPHER_ALG_AES_192_CBC_SHA_160 : cmdFlags |= PCL_OP_INFO_DTLS_AES_192_CBC_SHA_160 ; break;
case e_DTLS_CIPHER_ALG_AES_192_CBC_SHA_384 : cmdFlags |= PCL_OP_INFO_DTLS_AES_192_CBC_SHA_384 ; break;
case e_DTLS_CIPHER_ALG_AES_192_CBC_SHA_224 : cmdFlags |= PCL_OP_INFO_DTLS_AES_192_CBC_SHA_224 ; break;
case e_DTLS_CIPHER_ALG_AES_192_CBC_SHA_512 : cmdFlags |= PCL_OP_INFO_DTLS_AES_192_CBC_SHA_512 ; break;
case e_DTLS_CIPHER_ALG_AES_192_CBC_SHA_256 : cmdFlags |= PCL_OP_INFO_DTLS_AES_192_CBC_SHA_256 ; break;
case e_DTLS_CIPHER_ALG_3DES_EDE_CBC_SHA_160: cmdFlags |= PCL_OP_INFO_DTLS_3DES_EDE_CBC_SHA_160; break;
case e_DTLS_CIPHER_ALG_3DES_EDE_CBC_SHA_384: cmdFlags |= PCL_OP_INFO_DTLS_3DES_EDE_CBC_SHA_384; break;
case e_DTLS_CIPHER_ALG_3DES_EDE_CBC_SHA_224: cmdFlags |= PCL_OP_INFO_DTLS_3DES_EDE_CBC_SHA_224; break;
case e_DTLS_CIPHER_ALG_3DES_EDE_CBC_SHA_512: cmdFlags |= PCL_OP_INFO_DTLS_3DES_EDE_CBC_SHA_512; break;
case e_DTLS_CIPHER_ALG_3DES_EDE_CBC_SHA_256: cmdFlags |= PCL_OP_INFO_DTLS_3DES_EDE_CBC_SHA_256; break;
case e_DTLS_CIPHER_ALG_AES_256_CBC_SHA_160 : cmdFlags |= PCL_OP_INFO_DTLS_AES_256_CBC_SHA_160 ; break;
case e_DTLS_CIPHER_ALG_AES_256_CBC_SHA_384 : cmdFlags |= PCL_OP_INFO_DTLS_AES_256_CBC_SHA_384 ; break;
case e_DTLS_CIPHER_ALG_AES_256_CBC_SHA_224 : cmdFlags |= PCL_OP_INFO_DTLS_AES_256_CBC_SHA_224 ; break;
case e_DTLS_CIPHER_ALG_AES_256_CBC_SHA_512 : cmdFlags |= PCL_OP_INFO_DTLS_AES_256_CBC_SHA_512 ; break;
case e_DTLS_CIPHER_ALG_AES_128_CBC_SHA_160 : cmdFlags |= PCL_OP_INFO_DTLS_AES_128_CBC_SHA_160 ; break;
case e_DTLS_CIPHER_ALG_AES_128_CBC_SHA_384 : cmdFlags |= PCL_OP_INFO_DTLS_AES_128_CBC_SHA_384 ; break;
case e_DTLS_CIPHER_ALG_AES_128_CBC_SHA_224 : cmdFlags |= PCL_OP_INFO_DTLS_AES_128_CBC_SHA_224 ; break;
case e_DTLS_CIPHER_ALG_AES_128_CBC_SHA_512 : cmdFlags |= PCL_OP_INFO_DTLS_AES_128_CBC_SHA_512 ; break;
}
return cmdFlags;
}
static inline uint32_t CalcMacsecCmdFlags(uint32_t initFlags,
e_MacsecCipherAlg cipherAlg)
{
uint32_t cmdFlags = initFlags;
switch (cipherAlg)
{
case e_MACSEC_CIPHER_ALG_AES_GCM_16: cmdFlags |= PCL_OP_INFO_MACSEC_AES_GCM_16; break;
}
return cmdFlags;
}
static inline void InsertDataMoveCommands(t_DescHandle* p_DescHandle,
uint32_t dataMoveSize)
{
uint32_t cmdFlags;
cmdFlags = DCTRL_LOAD_AUTO_IFIFO_DISABLED;
CmdInsertDctrlLoad(p_DescHandle,cmdFlags);
cmdFlags = FIFO_LOAD_CLASS_BOTH_TYPE_MSG_L2_L1_F1;
CmdInsertFifoLoad(p_DescHandle,cmdFlags,dataMoveSize,NULL);
cmdFlags = DCTRL_LOAD_AUTO_IFIFO_ENABLED;
CmdInsertDctrlLoad(p_DescHandle,cmdFlags);
cmdFlags = MOVE_AUX_FLSH_SRC_IFIFO1_DST_OFIFO;
CmdInsertMove(p_DescHandle,cmdFlags,0,dataMoveSize);
cmdFlags = FIFO_STORE_CLASS_UNUSED_TYPE_MSG;
CmdInsertFifoStore(p_DescHandle,cmdFlags,dataMoveSize,NULL);
}
static inline void InsertNopCommands(t_DescHandle* p_DescHandle,
uint32_t numOfCommands)
{
uint32_t i;
uint32_t jumpCmdIndex;
for (i=0; i<numOfCommands; i++)
{
jumpCmdIndex = p_DescHandle->nextIndex;
CmdInsertLocalJump(p_DescHandle,0);
CmdUpdateLocalJump(p_DescHandle,jumpCmdIndex);
}
}
components/ip_net2-6.9/ipfreescale/sec4/NetCommSw/Peripherals/SEC/DCL/sec_dcl_api.h
+156
View File
@@ -0,0 +1,156 @@
/******************************************************************************
© 1995-2003, 2004, 2005-2010 Freescale Semiconductor, Inc.
All rights reserved.
This is proprietary source code of Freescale Semiconductor Inc.,
and its use is subject to the NetComm Device Drivers EULA.
The copyright notice above does not evidence any actual or intended
publication of such source code.
**************************************************************************/
#ifndef __SEC_DCL_API_H
#define __SEC_DCL_API_H
/************************************************************************/
/* */
/* Description */
/* ----------- */
/* */
/* A set of complex routines, for creating: */
/* A protocol-specific Shared-Descriptor */
/* A Job-Descriptor referencing a Shared-Descriptor */
/* */
/* Calling Sequence: */
/* 1 * descLength = Init<TYPE>ShrDesc(p_ShrDesc,...) */
/* N * descLength = InitSeqJobDesc(p_Desc,p_ShrDesc,...) */
/* */
/* Notes: */
/* MaxJobDescLen returns the maximum length of a Job-Descriptor */
/* MaxShrDescLen returns the maximum length of a Shared-Descriptor */
/* All other routines create a Descriptor and return its length */
/* The Descriptor buffer should be allocated outside the routine */
/* The returned length indicates the number of 32-bit words used */
/* */
/************************************************************************/
#include "sec_dcl_ext.h"
uint32_t MaxJobDescLen();
uint32_t MaxShrDescLen(uint32_t ptrSize);
/************************************************/
/* Job-Descriptor Construction Routines (below) */
uint32_t InitSeqJobDesc(uint32_t* p_Desc,
uint32_t ptrSize,
uint32_t* p_ShrDesc,
bool inputSeqSgt,
uint32_t inputSeqSize,
uint8_t* p_InputSeqData,
bool outputSeqSgt,
uint32_t outputSeqSize,
uint8_t* p_OutputSeqData);
uint32_t InitSplitKeyJobDesc(uint32_t* p_Desc,
uint32_t ptrSize,
uint8_t* p_InputKey,
uint8_t* p_OutputKey,
e_SplitKeyHashAlg hashAlg);
/* Job-Descriptor Construction Routines (above) */
/************************************************/
/***************************************************/
/* Shared-Descriptor Construction Routines (below) */
uint32_t InitIpsecEncapShrDesc(uint32_t* p_Desc,
uint32_t ptrSize,
uint32_t dataMoveSize,
bool cryptoKeyImm,
uint32_t cryptoKeySize,
uint8_t* p_CryptoKeyData,
bool authenKeyImm,
uint32_t authenKeySize,
uint8_t* p_AuthenKeyData,
e_IpsecCryptoAlg cryptoAlg,
e_IpsecAuthenAlg authenAlg,
t_IpsecEncapParam* p_Param);
uint32_t InitIpsecDecapShrDesc(uint32_t* p_Desc,
uint32_t ptrSize,
uint32_t dataMoveSize,
bool cryptoKeyImm,
uint32_t cryptoKeySize,
uint8_t* p_CryptoKeyData,
bool authenKeyImm,
uint32_t authenKeySize,
uint8_t* p_AuthenKeyData,
e_IpsecCryptoAlg cryptoAlg,
e_IpsecAuthenAlg authenAlg,
t_IpsecDecapParam* p_Param);
uint32_t InitDtlsEncapShrDesc(uint32_t* p_Desc,
uint32_t ptrSize,
uint32_t dataMoveSize,
bool cryptoKeyImm,
uint32_t cryptoKeySize,
uint8_t* p_CryptoKeyData,
bool authenKeyImm,
uint32_t authenKeySize,
uint8_t* p_AuthenKeyData,
e_DtlsCipherAlg cipherAlg,
t_DtlsEncapParam* p_Param);
uint32_t InitDtlsDecapShrDesc(uint32_t* p_Desc,
uint32_t ptrSize,
uint32_t dataMoveSize,
bool cryptoKeyImm,
uint32_t cryptoKeySize,
uint8_t* p_CryptoKeyData,
bool authenKeyImm,
uint32_t authenKeySize,
uint8_t* p_AuthenKeyData,
e_DtlsCipherAlg cipherAlg,
t_DtlsDecapParam* p_Param);
uint32_t InitMacsecEncapShrDesc(uint32_t* p_Desc,
uint32_t ptrSize,
uint32_t dataMoveSize,
bool cipherKeyImm,
uint32_t cipherKeySize,
uint8_t* p_CipherKeyData,
e_MacsecCipherAlg cipherAlg,
t_MacsecEncapParam* p_Param);
uint32_t InitMacsecDecapShrDesc(uint32_t* p_Desc,
uint32_t ptrSize,
uint32_t dataMoveSize,
bool cipherKeyImm,
uint32_t cipherKeySize,
uint8_t* p_CipherKeyData,
e_MacsecCipherAlg cipherAlg,
t_MacsecDecapParam* p_Param);
/* Shared-Descriptor Construction Routines (above) */
/***************************************************/
#endif /* __SEC_DCL_API_H */
components/ip_net2-6.9/ipfreescale/sec4/NetCommSw/Peripherals/SEC/DCL/sec_dcl_cmd.c
+945
View File
@@ -0,0 +1,945 @@
/******************************************************************************
� 1995-2003, 2004, 2005-2010 Freescale Semiconductor, Inc.
All rights reserved.
This is proprietary source code of Freescale Semiconductor Inc.,
and its use is subject to the NetComm Device Drivers EULA.
The copyright notice above does not evidence any actual or intended
publication of such source code.
**************************************************************************/
/* Include the internal definitions of this module */
#include "sec_dcl_cmd.h"
/* Include the external interfaces of other modules */
#include "error_ext.h"
#define FLAGS_MATCH(word,mask,flags) (((word)&(mask))==(flags))
static inline void WriteWord(t_DescHandle* p_DescHandle,uint32_t word);
static inline void WriteAddr(t_DescHandle* p_DescHandle,void* p_Addr);
static inline void WriteData(t_DescHandle* p_DescHandle,void* p_Data,uint32_t size);
t_DescHandle NewDescHandle(uint32_t* p_Buffer,uint32_t ptrSize)
{
t_DescHandle descHandle;
descHandle.p_Buffer = p_Buffer;
descHandle.nextIndex = 0;
descHandle.ptrLength = ptrSize/sizeof(uint32_t);
return descHandle;
}
void CmdInsertShrDescHdr(t_DescHandle* p_DescHandle,
uint32_t cmdFlags)
{
/* Calculate additional flags */
cmdFlags |= (uint32_t) SHR_DESC_HDR_CTYPE;
cmdFlags |= SHR_DESC_HDR_ONE;
cmdFlags &= ~SHR_DESC_HDR_ZRO;
/* Insert the command */
WriteWord(p_DescHandle,cmdFlags);
}
void CmdInsertJobDescHdr(t_DescHandle* p_DescHandle,
uint32_t cmdFlags)
{
/* Calculate additional flags */
cmdFlags |= (uint32_t) JOB_DESC_HDR_CTYPE;
cmdFlags |= JOB_DESC_HDR_ONE;
cmdFlags &= ~JOB_DESC_HDR_ZRO;
cmdFlags &= ~JOB_DESC_HDR_SHR;
/* Insert the command */
WriteWord(p_DescHandle,cmdFlags);
}
void CmdInsertJobDescRefShrHdr(t_DescHandle* p_DescHandle,
uint32_t cmdFlags,
uint32_t* p_ShrDesc)
{
/* Assert input arguments */
ASSERT_COND(p_ShrDesc != NULL);
/* Calculate additional flags */
cmdFlags |= (uint32_t) JOB_DESC_HDR_CTYPE;
cmdFlags |= JOB_DESC_HDR_ONE;
cmdFlags &= ~JOB_DESC_HDR_ZRO;
cmdFlags |= JOB_DESC_HDR_SHR;
/* Insert the command */
WriteWord(p_DescHandle,cmdFlags);
WriteAddr(p_DescHandle,p_ShrDesc);
}
void CmdInsertKey(t_DescHandle* p_DescHandle,
uint32_t cmdFlags,
uint32_t length,
uint8_t* p_Data)
{
/* Assert input arguments */
if (FLAGS_MATCH(cmdFlags,KEY_IMM,KEY_IMM))
{
ASSERT_COND(p_Data != NULL);
ASSERT_COND(!FLAGS_MATCH(cmdFlags,KEY_SGT,KEY_SGT));
}
if (FLAGS_MATCH(cmdFlags,KEY_CLASS_DST_MASK,KEY_CLASS_1_DST_AFHA_SBOX))
{
ASSERT_COND(length == KEY_DST_AFHA_SBOX_LENGTH);
}
ASSERT_COND(IN_RANGE(MIN_KEY_LENGTH,length,MAX_KEY_LENGTH));
/* Calculate additional flags */
cmdFlags |= KEY_CTYPE;
cmdFlags |= KEY_SEQ(p_Data==NULL);
cmdFlags |= KEY_LENGTH(length);
/* Insert the command */
WriteWord(p_DescHandle,cmdFlags);
if (p_Data)
{
if (FLAGS_MATCH(cmdFlags,KEY_IMM,KEY_IMM))
WriteData(p_DescHandle,p_Data,length);
else
WriteAddr(p_DescHandle,p_Data);
}
}
void CmdInsertLoad(t_DescHandle* p_DescHandle,
uint32_t cmdFlags,
uint32_t offset,
uint32_t length,
uint8_t* p_Data)
{
bool length_in_words=FALSE; /* Interpeak. Bug correction */
/* Assert input arguments */
if (FLAGS_MATCH(cmdFlags,LOAD_IMM,LOAD_IMM))
{
ASSERT_COND(p_Data != NULL);
ASSERT_COND(!FLAGS_MATCH(cmdFlags,LOAD_SGT,LOAD_SGT));
}
if (FLAGS_MATCH(cmdFlags,LOAD_CLASS_DST_MASK,LOAD_CLASS_1_DST_KEYSZ ) ||
FLAGS_MATCH(cmdFlags,LOAD_CLASS_DST_MASK,LOAD_CLASS_2_DST_KEYSZ ) ||
FLAGS_MATCH(cmdFlags,LOAD_CLASS_DST_MASK,LOAD_CLASS_1_DST_DATASZ ) ||
FLAGS_MATCH(cmdFlags,LOAD_CLASS_DST_MASK,LOAD_CLASS_2_DST_DATASZ ) ||
FLAGS_MATCH(cmdFlags,LOAD_CLASS_DST_MASK,LOAD_CLASS_1_DST_ICVSZ ) ||
FLAGS_MATCH(cmdFlags,LOAD_CLASS_DST_MASK,LOAD_CLASS_2_DST_ICVSZ ) ||
FLAGS_MATCH(cmdFlags,LOAD_CLASS_DST_MASK,LOAD_CLASS_DECO_DST_DLIODN ) ||
FLAGS_MATCH(cmdFlags,LOAD_CLASS_DST_MASK,LOAD_CLASS_NONE_DST_CCTRL ) ||
FLAGS_MATCH(cmdFlags,LOAD_CLASS_DST_MASK,LOAD_CLASS_NONE_DST_ICTRL ) ||
FLAGS_MATCH(cmdFlags,LOAD_CLASS_DST_MASK,LOAD_CLASS_DECO_DST_DPOVRD ) ||
FLAGS_MATCH(cmdFlags,LOAD_CLASS_DST_MASK,LOAD_CLASS_NONE_DST_CLRW ) ||
FLAGS_MATCH(cmdFlags,LOAD_CLASS_DST_MASK,LOAD_CLASS_DECO_DST_DMATH0 ) ||
FLAGS_MATCH(cmdFlags,LOAD_CLASS_DST_MASK,LOAD_CLASS_DECO_DST_DMATH1 ) ||
FLAGS_MATCH(cmdFlags,LOAD_CLASS_DST_MASK,LOAD_CLASS_DECO_DST_DMATH2 ) ||
FLAGS_MATCH(cmdFlags,LOAD_CLASS_DST_MASK,LOAD_CLASS_DECO_DST_DMATH3 ) ||
FLAGS_MATCH(cmdFlags,LOAD_CLASS_DST_MASK,LOAD_CLASS_1_DST_AADSZ ) ||
FLAGS_MATCH(cmdFlags,LOAD_CLASS_DST_MASK,LOAD_CLASS_1_DST_IVSZ ) ||
FLAGS_MATCH(cmdFlags,LOAD_CLASS_DST_MASK,LOAD_CLASS_1_DST_ALTDSZ ) ||
FLAGS_MATCH(cmdFlags,LOAD_CLASS_DST_MASK,LOAD_CLASS_1_DST_PKASZ ) ||
FLAGS_MATCH(cmdFlags,LOAD_CLASS_DST_MASK,LOAD_CLASS_1_DST_PKBSZ ) ||
FLAGS_MATCH(cmdFlags,LOAD_CLASS_DST_MASK,LOAD_CLASS_1_DST_PKNSZ ) ||
FLAGS_MATCH(cmdFlags,LOAD_CLASS_DST_MASK,LOAD_CLASS_1_DST_PKESZ ) ||
FLAGS_MATCH(cmdFlags,LOAD_CLASS_DST_MASK,LOAD_CLASS_DECO_DST_DESCBUF) ||
FLAGS_MATCH(cmdFlags,LOAD_CLASS_DST_MASK,LOAD_CLASS_NONE_DST_IFIFO ))
{
ASSERT_COND((length%4) == 0); /*length /= 4;*/ /*Interpeak. Bug correction*/
length_in_words = TRUE;
}
if (FLAGS_MATCH(cmdFlags,LOAD_CLASS_DST_MASK,LOAD_CLASS_1_DST_KEYSZ ) ||
FLAGS_MATCH(cmdFlags,LOAD_CLASS_DST_MASK,LOAD_CLASS_2_DST_KEYSZ ) ||
FLAGS_MATCH(cmdFlags,LOAD_CLASS_DST_MASK,LOAD_CLASS_1_DST_DATASZ ) ||
FLAGS_MATCH(cmdFlags,LOAD_CLASS_DST_MASK,LOAD_CLASS_2_DST_DATASZ ) ||
FLAGS_MATCH(cmdFlags,LOAD_CLASS_DST_MASK,LOAD_CLASS_1_DST_ICVSZ ) ||
FLAGS_MATCH(cmdFlags,LOAD_CLASS_DST_MASK,LOAD_CLASS_2_DST_ICVSZ ) ||
FLAGS_MATCH(cmdFlags,LOAD_CLASS_DST_MASK,LOAD_CLASS_DECO_DST_DLIODN) ||
FLAGS_MATCH(cmdFlags,LOAD_CLASS_DST_MASK,LOAD_CLASS_NONE_DST_CCTRL ) ||
FLAGS_MATCH(cmdFlags,LOAD_CLASS_DST_MASK,LOAD_CLASS_NONE_DST_ICTRL ) ||
FLAGS_MATCH(cmdFlags,LOAD_CLASS_DST_MASK,LOAD_CLASS_DECO_DST_DPOVRD) ||
FLAGS_MATCH(cmdFlags,LOAD_CLASS_DST_MASK,LOAD_CLASS_NONE_DST_CLRW ) ||
FLAGS_MATCH(cmdFlags,LOAD_CLASS_DST_MASK,LOAD_CLASS_1_DST_AADSZ ) ||
FLAGS_MATCH(cmdFlags,LOAD_CLASS_DST_MASK,LOAD_CLASS_1_DST_IVSZ ) ||
FLAGS_MATCH(cmdFlags,LOAD_CLASS_DST_MASK,LOAD_CLASS_1_DST_ALTDSZ ) ||
FLAGS_MATCH(cmdFlags,LOAD_CLASS_DST_MASK,LOAD_CLASS_1_DST_PKASZ ) ||
FLAGS_MATCH(cmdFlags,LOAD_CLASS_DST_MASK,LOAD_CLASS_1_DST_PKBSZ ) ||
FLAGS_MATCH(cmdFlags,LOAD_CLASS_DST_MASK,LOAD_CLASS_1_DST_PKNSZ ) ||
FLAGS_MATCH(cmdFlags,LOAD_CLASS_DST_MASK,LOAD_CLASS_1_DST_PKESZ ) ||
FLAGS_MATCH(cmdFlags,LOAD_CLASS_DST_MASK,LOAD_CLASS_NONE_DST_IDFNS ) ||
FLAGS_MATCH(cmdFlags,LOAD_CLASS_DST_MASK,LOAD_CLASS_NONE_DST_ODFNS ) ||
FLAGS_MATCH(cmdFlags,LOAD_CLASS_DST_MASK,LOAD_CLASS_NONE_DST_IFALT ) ||
FLAGS_MATCH(cmdFlags,LOAD_CLASS_DST_MASK,LOAD_CLASS_NONE_DST_IFIFO ) ||
FLAGS_MATCH(cmdFlags,LOAD_CLASS_DST_MASK,LOAD_CLASS_NONE_DST_DFIFO ) ||
FLAGS_MATCH(cmdFlags,LOAD_CLASS_DST_MASK,LOAD_CLASS_NONE_DST_OFIFO ))
{
ASSERT_COND(FLAGS_MATCH(cmdFlags,LOAD_IMM,LOAD_IMM));
}
if (FLAGS_MATCH(cmdFlags,LOAD_IMM,LOAD_IMM))
{
if (FLAGS_MATCH(cmdFlags,LOAD_CLASS_DST_MASK,LOAD_CLASS_1_DST_CTX) ||
FLAGS_MATCH(cmdFlags,LOAD_CLASS_DST_MASK,LOAD_CLASS_2_DST_CTX))
{
ASSERT_COND((offset%8) == 0);
}
else
{
ASSERT_COND(offset == 0);
}
if (FLAGS_MATCH(cmdFlags,LOAD_CLASS_DST_MASK,LOAD_CLASS_NONE_DST_DFIFO) ||
FLAGS_MATCH(cmdFlags,LOAD_CLASS_DST_MASK,LOAD_CLASS_NONE_DST_OFIFO))
{
ASSERT_COND(length>=1 && length<=8);
}
else
{
ASSERT_COND(length==4 || length==8);
}
}
ASSERT_COND(IN_RANGE(MIN_LOAD_OFFSET,offset,MAX_LOAD_OFFSET));
ASSERT_COND(IN_RANGE(MIN_LOAD_LENGTH,length,MAX_LOAD_LENGTH));
/* Calculate additional flags */
cmdFlags |= LOAD_CTYPE;
cmdFlags |= LOAD_SEQ(p_Data==NULL);
cmdFlags |= LOAD_OFFSET(offset);
if(length_in_words==TRUE) /* Interpeak. Bug correction*/
cmdFlags |= LOAD_LENGTH(length/4);
else
cmdFlags |= LOAD_LENGTH(length);
/* Insert the command */
WriteWord(p_DescHandle,cmdFlags);
if (p_Data)
{
if (FLAGS_MATCH(cmdFlags,LOAD_IMM,LOAD_IMM))
WriteData(p_DescHandle,p_Data,length);
else
WriteAddr(p_DescHandle,p_Data);
}
}
void CmdInsertDctrlLoad(t_DescHandle* p_DescHandle,
uint32_t cmdFlags)
{
/* Calculate additional flags */
cmdFlags |= DCTRL_LOAD_CTYPE;
cmdFlags |= DCTRL_LOAD_CLASS_DECO_IMM_DST_REG;
/* Insert the command */
WriteWord(p_DescHandle,cmdFlags);
}
void CmdInsertFifoLoad(t_DescHandle* p_DescHandle,
uint32_t cmdFlags,
uint32_t length,
uint8_t* p_Data)
{
/* Assert input arguments */
if (FLAGS_MATCH(cmdFlags,FIFO_LOAD_IMM,FIFO_LOAD_IMM))
{
ASSERT_COND(p_Data != NULL);
ASSERT_COND(!FLAGS_MATCH(cmdFlags,FIFO_LOAD_SGT,FIFO_LOAD_SGT));
}
if (FLAGS_MATCH(cmdFlags,FIFO_LOAD_CLASS_TYPE_MASK,FIFO_LOAD_CLASS_SKIP_TYPE_UNUSED))
{
ASSERT_COND(p_Data == NULL);
}
if (!(FLAGS_MATCH(cmdFlags,FIFO_LOAD_VLF, FIFO_LOAD_VLF))) /* wind river added */
{
ASSERT_COND(IN_RANGE(MIN_FIFO_LOAD_LENGTH,length,MAX_FIFO_LOAD_LENGTH));
}
/* Calculate additional flags */
cmdFlags |= FIFO_LOAD_CTYPE;
cmdFlags |= FIFO_LOAD_SEQ(p_Data==NULL);
if (length > MAX_NOT_EXT_LENGTH)
{
cmdFlags |= FIFO_LOAD_EXT;
cmdFlags &= ~FIFO_LOAD_LENGTH(~0);
}
else
{
cmdFlags &= ~FIFO_LOAD_EXT;
cmdFlags |= FIFO_LOAD_LENGTH(length);
}
/* Insert the command */
WriteWord(p_DescHandle,cmdFlags);
if (p_Data)
{
if (FLAGS_MATCH(cmdFlags,FIFO_LOAD_IMM,FIFO_LOAD_IMM))
WriteData(p_DescHandle,p_Data,length);
else
WriteAddr(p_DescHandle,p_Data);
}
if (length > MAX_NOT_EXT_LENGTH)
WriteWord(p_DescHandle,length);
}
void CmdInsertBitFifoLoad(t_DescHandle* p_DescHandle,
uint32_t cmdFlags,
uint32_t length,
uint8_t* p_Data)
{
/* Assert input arguments */
if (FLAGS_MATCH(cmdFlags,BIT_FIFO_LOAD_IMM,BIT_FIFO_LOAD_IMM))
{
ASSERT_COND(p_Data != NULL);
ASSERT_COND(!FLAGS_MATCH(cmdFlags,BIT_FIFO_LOAD_SGT,BIT_FIFO_LOAD_SGT));
}
ASSERT_COND(IN_RANGE(MIN_BIT_FIFO_LOAD_LENGTH,length,MAX_BIT_FIFO_LOAD_LENGTH));
/* Calculate additional flags */
cmdFlags |= BIT_FIFO_LOAD_CTYPE;
cmdFlags |= BIT_FIFO_LOAD_SEQ(p_Data==NULL);
cmdFlags |= BIT_FIFO_LOAD_BIT_LENGTH(length);
if (length > MAX_NOT_EXT_LENGTH)
{
cmdFlags |= BIT_FIFO_LOAD_EXT;
cmdFlags &= ~BIT_FIFO_LOAD_BYTE_LENGTH(~0);
}
else
{
cmdFlags &= ~BIT_FIFO_LOAD_EXT;
cmdFlags |= BIT_FIFO_LOAD_BYTE_LENGTH(length);
}
/* Insert the command */
WriteWord(p_DescHandle,cmdFlags);
if (p_Data)
{
if (FLAGS_MATCH(cmdFlags,BIT_FIFO_LOAD_IMM,BIT_FIFO_LOAD_IMM))
WriteData(p_DescHandle,p_Data,DIV_CEIL(length,8));
else
WriteAddr(p_DescHandle,p_Data);
}
if (length > MAX_NOT_EXT_LENGTH)
WriteWord(p_DescHandle,length/8);
}
void CmdInsertStore(t_DescHandle* p_DescHandle,
uint32_t cmdFlags,
uint32_t offset,
uint32_t length,
uint8_t* p_Data)
{
/* Assert input arguments */
if (FLAGS_MATCH(cmdFlags,STORE_IMM,STORE_IMM))
{
ASSERT_COND(offset == 0);
ASSERT_COND(p_Data != NULL);
ASSERT_COND(!FLAGS_MATCH(cmdFlags,STORE_SGT,STORE_SGT));
ASSERT_COND(FLAGS_MATCH(cmdFlags,STORE_CLASS_SRC_MASK,STORE_CLASS_UNUSED_SRC_UNUSED));
}
if (FLAGS_MATCH(cmdFlags,STORE_CLASS_SRC_MASK,STORE_CLASS_1_SRC_MODE ) ||
FLAGS_MATCH(cmdFlags,STORE_CLASS_SRC_MASK,STORE_CLASS_2_SRC_MODE ) ||
FLAGS_MATCH(cmdFlags,STORE_CLASS_SRC_MASK,STORE_CLASS_DECO_SRC_DJQCR ) ||
FLAGS_MATCH(cmdFlags,STORE_CLASS_SRC_MASK,STORE_CLASS_1_SRC_KEYSZ ) ||
FLAGS_MATCH(cmdFlags,STORE_CLASS_SRC_MASK,STORE_CLASS_2_SRC_KEYSZ ) ||
FLAGS_MATCH(cmdFlags,STORE_CLASS_SRC_MASK,STORE_CLASS_DECO_SRC_DDAR ) ||
FLAGS_MATCH(cmdFlags,STORE_CLASS_SRC_MASK,STORE_CLASS_1_SRC_DATASZ ) ||
FLAGS_MATCH(cmdFlags,STORE_CLASS_SRC_MASK,STORE_CLASS_2_SRC_DATASZ ) ||
FLAGS_MATCH(cmdFlags,STORE_CLASS_SRC_MASK,STORE_CLASS_DECO_SRC_DSTAT ) ||
FLAGS_MATCH(cmdFlags,STORE_CLASS_SRC_MASK,STORE_CLASS_1_SRC_ICVSZ ) ||
FLAGS_MATCH(cmdFlags,STORE_CLASS_SRC_MASK,STORE_CLASS_2_SRC_ICVSZ ) ||
FLAGS_MATCH(cmdFlags,STORE_CLASS_SRC_MASK,STORE_CLASS_NONE_SRC_CCTRL ) ||
FLAGS_MATCH(cmdFlags,STORE_CLASS_SRC_MASK,STORE_CLASS_NONE_SRC_ICTRL ) ||
FLAGS_MATCH(cmdFlags,STORE_CLASS_SRC_MASK,STORE_CLASS_NONE_SRC_CLRW ) ||
FLAGS_MATCH(cmdFlags,STORE_CLASS_SRC_MASK,STORE_CLASS_DECO_SRC_DMATH0) ||
FLAGS_MATCH(cmdFlags,STORE_CLASS_SRC_MASK,STORE_CLASS_NONE_SRC_STAT ) ||
FLAGS_MATCH(cmdFlags,STORE_CLASS_SRC_MASK,STORE_CLASS_DECO_SRC_DMATH1) ||
FLAGS_MATCH(cmdFlags,STORE_CLASS_SRC_MASK,STORE_CLASS_DECO_SRC_DMATH2) ||
FLAGS_MATCH(cmdFlags,STORE_CLASS_SRC_MASK,STORE_CLASS_1_SRC_AADSZR ) ||
FLAGS_MATCH(cmdFlags,STORE_CLASS_SRC_MASK,STORE_CLASS_DECO_SRC_DMATH3) ||
FLAGS_MATCH(cmdFlags,STORE_CLASS_SRC_MASK,STORE_CLASS_1_SRC_IVSZ ))
{
ASSERT_COND((length%4) == 0); length /= 4;
}
ASSERT_COND(IN_RANGE(MIN_STORE_OFFSET,offset,MAX_STORE_OFFSET));
ASSERT_COND(IN_RANGE(MIN_STORE_LENGTH,length,MAX_STORE_LENGTH));
/* Calculate additional flags */
cmdFlags |= STORE_CTYPE;
cmdFlags |= STORE_SEQ(p_Data==NULL);
cmdFlags |= STORE_OFFSET(offset);
cmdFlags |= STORE_LENGTH(length);
/* Insert the command */
WriteWord(p_DescHandle,cmdFlags);
if (p_Data)
{
if (FLAGS_MATCH(cmdFlags,STORE_IMM,STORE_IMM))
WriteData(p_DescHandle,p_Data,length);
else
WriteAddr(p_DescHandle,p_Data);
}
}
void CmdInsertDescbufStore(t_DescHandle* p_DescHandle,
uint32_t cmdFlags,
uint32_t offset,
uint32_t length,
uint8_t* p_Data)
{
/* Assert input arguments */
if (FLAGS_MATCH(cmdFlags,DESCBUF_STORE_CLASS_SRC_MASK,DESCBUF_STORE_CLASS_DECO_SRC_0))
{
ASSERT_COND(offset == 0);
}
if (FLAGS_MATCH(cmdFlags,DESCBUF_STORE_CLASS_SRC_MASK,DESCBUF_STORE_CLASS_DECO_SRC_1) ||
FLAGS_MATCH(cmdFlags,DESCBUF_STORE_CLASS_SRC_MASK,DESCBUF_STORE_CLASS_DECO_SRC_2))
{
ASSERT_COND(p_Data == NULL);
}
ASSERT_COND((length%4) == 0); length /= 4;
ASSERT_COND((offset%4) == 0); offset /= 4;
ASSERT_COND(IN_RANGE(MIN_DESCBUF_STORE_OFFSET,offset,MAX_DESCBUF_STORE_OFFSET));
ASSERT_COND(IN_RANGE(MIN_DESCBUF_STORE_LENGTH,length,MAX_DESCBUF_STORE_LENGTH));
/* Calculate additional flags */
cmdFlags |= DESCBUF_STORE_CTYPE;
cmdFlags |= DESCBUF_STORE_SEQ(p_Data!=NULL && FLAGS_MATCH(cmdFlags,DESCBUF_STORE_CLASS_SRC_MASK,DESCBUF_STORE_CLASS_DECO_SRC_0));
cmdFlags |= DESCBUF_STORE_OFFSET(offset);
cmdFlags |= DESCBUF_STORE_LENGTH(length);
/* Insert the command */
WriteWord(p_DescHandle,cmdFlags);
if (p_Data)
WriteAddr(p_DescHandle,p_Data);
}
void CmdInsertFifoStore(t_DescHandle* p_DescHandle,
uint32_t cmdFlags,
uint32_t length,
uint8_t* p_Data)
{
if (FLAGS_MATCH(cmdFlags,FIFO_STORE_CLASS_TYPE_MASK,FIFO_STORE_CLASS_UNUSED_TYPE_SKIP))
{
ASSERT_COND(p_Data == NULL);
}
ASSERT_COND(IN_RANGE(MIN_FIFO_STORE_LENGTH,length,MAX_FIFO_STORE_LENGTH));
/* Calculate additional flags */
cmdFlags |= FIFO_STORE_CTYPE;
cmdFlags |= FIFO_STORE_SEQ(p_Data==NULL);
if (length > MAX_NOT_EXT_LENGTH)
{
cmdFlags |= FIFO_STORE_EXT;
cmdFlags &= ~FIFO_STORE_LENGTH(~0);
}
else
{
cmdFlags &= ~FIFO_STORE_EXT;
cmdFlags |= FIFO_STORE_LENGTH(length);
}
/* Insert the command */
WriteWord(p_DescHandle,cmdFlags);
if (p_Data)
WriteAddr(p_DescHandle,p_Data);
if (length > MAX_NOT_EXT_LENGTH)
WriteWord(p_DescHandle,length);
}
void CmdInsertRngFifoStore(t_DescHandle* p_DescHandle,
uint32_t cmdFlags,
uint32_t length,
uint8_t* p_Data)
{
if (FLAGS_MATCH(cmdFlags,RNG_FIFO_STORE_TYPE_MASK,RNG_FIFO_STORE_TYPE_OFIFO))
{
ASSERT_COND(p_Data == NULL);
}
ASSERT_COND(IN_RANGE(MIN_RNG_FIFO_STORE_LENGTH,length,MAX_RNG_FIFO_STORE_LENGTH));
/* Calculate additional flags */
cmdFlags |= RNG_FIFO_STORE_CTYPE;
cmdFlags |= RNG_FIFO_STORE_SEQ(p_Data!=NULL && FLAGS_MATCH(cmdFlags,RNG_FIFO_STORE_TYPE_MASK,RNG_FIFO_STORE_TYPE_OFIFO));
cmdFlags |= RNG_FIFO_STORE_LENGTH(length);
/* Insert the command */
WriteWord(p_DescHandle,cmdFlags);
if (p_Data)
WriteAddr(p_DescHandle,p_Data);
}
void CmdInsertMove(t_DescHandle* p_DescHandle,
uint32_t cmdFlags,
uint32_t offset,
uint32_t length)
{
/* Assert input arguments */
if (FLAGS_MATCH(cmdFlags,MOVE_AUX_SRC_DST_MASK,MOVE_AUX_NONE_SRC_OFIFO_DST_IFIFO1 ) ||
FLAGS_MATCH(cmdFlags,MOVE_AUX_SRC_DST_MASK,MOVE_AUX_LAST_SRC_OFIFO_DST_IFIFO1 ) ||
FLAGS_MATCH(cmdFlags,MOVE_AUX_SRC_DST_MASK,MOVE_AUX_FLSH_SRC_OFIFO_DST_IFIFO1 ) ||
FLAGS_MATCH(cmdFlags,MOVE_AUX_SRC_DST_MASK,MOVE_AUX_BOTH_SRC_OFIFO_DST_IFIFO1 ) ||
FLAGS_MATCH(cmdFlags,MOVE_AUX_SRC_DST_MASK,MOVE_AUX_NONE_SRC_OFIFO_DST_IFIFO2 ) ||
FLAGS_MATCH(cmdFlags,MOVE_AUX_SRC_DST_MASK,MOVE_AUX_LAST_SRC_OFIFO_DST_IFIFO2 ) ||
FLAGS_MATCH(cmdFlags,MOVE_AUX_SRC_DST_MASK,MOVE_AUX_FLSH_SRC_OFIFO_DST_IFIFO2 ) ||
FLAGS_MATCH(cmdFlags,MOVE_AUX_SRC_DST_MASK,MOVE_AUX_BOTH_SRC_OFIFO_DST_IFIFO2 ) ||
FLAGS_MATCH(cmdFlags,MOVE_AUX_SRC_DST_MASK,MOVE_AUX_UNUSED_SRC_OFIFO_DST_PKHA_A))
{
ASSERT_COND(offset == 0);
}
if (FLAGS_MATCH(cmdFlags,MOVE_AUX_SRC_DST_MASK,MOVE_AUX_UNUSED_SRC_CTX1_DST_OFIFO ) ||
FLAGS_MATCH(cmdFlags,MOVE_AUX_SRC_DST_MASK,MOVE_AUX_UNUSED_SRC_CTX2_DST_OFIFO ) ||
FLAGS_MATCH(cmdFlags,MOVE_AUX_SRC_DST_MASK,MOVE_AUX_UNUSED_SRC_DESCBUF_DST_OFIFO ) ||
FLAGS_MATCH(cmdFlags,MOVE_AUX_SRC_DST_MASK,MOVE_AUX_UNUSED_SRC_MATHREG0_DST_OFIFO ) ||
FLAGS_MATCH(cmdFlags,MOVE_AUX_SRC_DST_MASK,MOVE_AUX_UNUSED_SRC_MATHREG1_DST_OFIFO ) ||
FLAGS_MATCH(cmdFlags,MOVE_AUX_SRC_DST_MASK,MOVE_AUX_UNUSED_SRC_MATHREG2_DST_OFIFO ) ||
FLAGS_MATCH(cmdFlags,MOVE_AUX_SRC_DST_MASK,MOVE_AUX_UNUSED_SRC_MATHREG3_DST_OFIFO ) ||
FLAGS_MATCH(cmdFlags,MOVE_AUX_SRC_DST_MASK,MOVE_AUX_UNUSED_SRC_IFIFO1_DST_CTX1 ) ||
FLAGS_MATCH(cmdFlags,MOVE_AUX_SRC_DST_MASK,MOVE_AUX_UNUSED_SRC_IFIFO1_DST_CTX2 ) ||
FLAGS_MATCH(cmdFlags,MOVE_AUX_SRC_DST_MASK,MOVE_AUX_UNUSED_SRC_IFIFO1_DST_DESCBUF ) ||
FLAGS_MATCH(cmdFlags,MOVE_AUX_SRC_DST_MASK,MOVE_AUX_UNUSED_SRC_IFIFO1_DST_MATHREG0) ||
FLAGS_MATCH(cmdFlags,MOVE_AUX_SRC_DST_MASK,MOVE_AUX_UNUSED_SRC_IFIFO1_DST_MATHREG1) ||
FLAGS_MATCH(cmdFlags,MOVE_AUX_SRC_DST_MASK,MOVE_AUX_UNUSED_SRC_IFIFO1_DST_MATHREG2) ||
FLAGS_MATCH(cmdFlags,MOVE_AUX_SRC_DST_MASK,MOVE_AUX_UNUSED_SRC_IFIFO1_DST_MATHREG3) ||
FLAGS_MATCH(cmdFlags,MOVE_AUX_SRC_DST_MASK,MOVE_AUX_UNUSED_SRC_IFIFO1_DST_KEY1 ) ||
FLAGS_MATCH(cmdFlags,MOVE_AUX_SRC_DST_MASK,MOVE_AUX_UNUSED_SRC_IFIFO1_DST_KEY2 ))
{
ASSERT_COND((offset%4) == 0);
}
if (!FLAGS_MATCH(cmdFlags,MOVE_AUX_SRC_DST_MASK,MOVE_AUX_OFFSET_00B_SRC_CTX1_DST_DESCBUF) &&
!FLAGS_MATCH(cmdFlags,MOVE_AUX_SRC_DST_MASK,MOVE_AUX_OFFSET_16B_SRC_CTX1_DST_DESCBUF) &&
!FLAGS_MATCH(cmdFlags,MOVE_AUX_SRC_DST_MASK,MOVE_AUX_OFFSET_32B_SRC_CTX1_DST_DESCBUF) &&
!FLAGS_MATCH(cmdFlags,MOVE_AUX_SRC_DST_MASK,MOVE_AUX_OFFSET_48B_SRC_CTX1_DST_DESCBUF) &&
!FLAGS_MATCH(cmdFlags,MOVE_AUX_SRC_DST_MASK,MOVE_AUX_OFFSET_00B_SRC_CTX2_DST_DESCBUF) &&
!FLAGS_MATCH(cmdFlags,MOVE_AUX_SRC_DST_MASK,MOVE_AUX_OFFSET_16B_SRC_CTX2_DST_DESCBUF) &&
!FLAGS_MATCH(cmdFlags,MOVE_AUX_SRC_DST_MASK,MOVE_AUX_OFFSET_32B_SRC_CTX2_DST_DESCBUF) &&
!FLAGS_MATCH(cmdFlags,MOVE_AUX_SRC_DST_MASK,MOVE_AUX_OFFSET_48B_SRC_CTX2_DST_DESCBUF) &&
!FLAGS_MATCH(cmdFlags,MOVE_AUX_SRC_DST_MASK,MOVE_AUX_UNUSED_SRC_OFIFO_DST_DESCBUF ) &&
!FLAGS_MATCH(cmdFlags,MOVE_AUX_SRC_DST_MASK,MOVE_AUX_OFFSET_00B_SRC_DESCBUF_DST_CTX1) &&
!FLAGS_MATCH(cmdFlags,MOVE_AUX_SRC_DST_MASK,MOVE_AUX_OFFSET_16B_SRC_DESCBUF_DST_CTX1) &&
!FLAGS_MATCH(cmdFlags,MOVE_AUX_SRC_DST_MASK,MOVE_AUX_OFFSET_32B_SRC_DESCBUF_DST_CTX1) &&
!FLAGS_MATCH(cmdFlags,MOVE_AUX_SRC_DST_MASK,MOVE_AUX_OFFSET_48B_SRC_DESCBUF_DST_CTX1) &&
!FLAGS_MATCH(cmdFlags,MOVE_AUX_SRC_DST_MASK,MOVE_AUX_OFFSET_00B_SRC_DESCBUF_DST_CTX2) &&
!FLAGS_MATCH(cmdFlags,MOVE_AUX_SRC_DST_MASK,MOVE_AUX_OFFSET_16B_SRC_DESCBUF_DST_CTX2) &&
!FLAGS_MATCH(cmdFlags,MOVE_AUX_SRC_DST_MASK,MOVE_AUX_OFFSET_32B_SRC_DESCBUF_DST_CTX2) &&
!FLAGS_MATCH(cmdFlags,MOVE_AUX_SRC_DST_MASK,MOVE_AUX_OFFSET_48B_SRC_DESCBUF_DST_CTX2) &&
!FLAGS_MATCH(cmdFlags,MOVE_AUX_SRC_DST_MASK,MOVE_AUX_UNUSED_SRC_DESCBUF_DST_OFIFO ) &&
!FLAGS_MATCH(cmdFlags,MOVE_AUX_SRC_DST_MASK,MOVE_AUX_UNUSED_SRC_DESCBUF_DST_MATHREG0) &&
!FLAGS_MATCH(cmdFlags,MOVE_AUX_SRC_DST_MASK,MOVE_AUX_UNUSED_SRC_DESCBUF_DST_MATHREG1) &&
!FLAGS_MATCH(cmdFlags,MOVE_AUX_SRC_DST_MASK,MOVE_AUX_UNUSED_SRC_DESCBUF_DST_MATHREG2) &&
!FLAGS_MATCH(cmdFlags,MOVE_AUX_SRC_DST_MASK,MOVE_AUX_UNUSED_SRC_DESCBUF_DST_MATHREG3) &&
!FLAGS_MATCH(cmdFlags,MOVE_AUX_SRC_DST_MASK,MOVE_AUX_NONE_SRC_DESCBUF_DST_IFIFO1 ) &&
!FLAGS_MATCH(cmdFlags,MOVE_AUX_SRC_DST_MASK,MOVE_AUX_LAST_SRC_DESCBUF_DST_IFIFO1 ) &&
!FLAGS_MATCH(cmdFlags,MOVE_AUX_SRC_DST_MASK,MOVE_AUX_FLSH_SRC_DESCBUF_DST_IFIFO1 ) &&
!FLAGS_MATCH(cmdFlags,MOVE_AUX_SRC_DST_MASK,MOVE_AUX_BOTH_SRC_DESCBUF_DST_IFIFO1 ) &&
!FLAGS_MATCH(cmdFlags,MOVE_AUX_SRC_DST_MASK,MOVE_AUX_NONE_SRC_DESCBUF_DST_IFIFO2 ) &&
!FLAGS_MATCH(cmdFlags,MOVE_AUX_SRC_DST_MASK,MOVE_AUX_LAST_SRC_DESCBUF_DST_IFIFO2 ) &&
!FLAGS_MATCH(cmdFlags,MOVE_AUX_SRC_DST_MASK,MOVE_AUX_FLSH_SRC_DESCBUF_DST_IFIFO2 ) &&
!FLAGS_MATCH(cmdFlags,MOVE_AUX_SRC_DST_MASK,MOVE_AUX_BOTH_SRC_DESCBUF_DST_IFIFO2 ) &&
!FLAGS_MATCH(cmdFlags,MOVE_AUX_SRC_DST_MASK,MOVE_AUX_UNUSED_SRC_DESCBUF_DST_PKHA_A ) &&
!FLAGS_MATCH(cmdFlags,MOVE_AUX_SRC_DST_MASK,MOVE_AUX_UNUSED_SRC_DESCBUF_DST_KEY1 ) &&
!FLAGS_MATCH(cmdFlags,MOVE_AUX_SRC_DST_MASK,MOVE_AUX_UNUSED_SRC_DESCBUF_DST_KEY2 ) &&
!FLAGS_MATCH(cmdFlags,MOVE_AUX_SRC_DST_MASK,MOVE_AUX_UNUSED_SRC_MATHREG0_DST_DESCBUF) &&
!FLAGS_MATCH(cmdFlags,MOVE_AUX_SRC_DST_MASK,MOVE_AUX_UNUSED_SRC_MATHREG1_DST_DESCBUF) &&
!FLAGS_MATCH(cmdFlags,MOVE_AUX_SRC_DST_MASK,MOVE_AUX_UNUSED_SRC_MATHREG2_DST_DESCBUF) &&
!FLAGS_MATCH(cmdFlags,MOVE_AUX_SRC_DST_MASK,MOVE_AUX_UNUSED_SRC_MATHREG3_DST_DESCBUF) &&
!FLAGS_MATCH(cmdFlags,MOVE_AUX_SRC_DST_MASK,MOVE_AUX_UNUSED_SRC_IFIFO1_DST_DESCBUF ) &&
/* Wind River fix start */
/* offset is treated as additional 8 length bits in case of src=IFIFO and dst=OFIFO */
!FLAGS_MATCH(cmdFlags,MOVE_AUX_FLSH_C2A_SRC_IFIFO2_DST_OFIFO,MOVE_AUX_FLSH_C2A_SRC_IFIFO2_DST_OFIFO ) &&
!FLAGS_MATCH(cmdFlags,MOVE_AUX_FLSH_C1A_SRC_IFIFO2_DST_OFIFO,MOVE_AUX_FLSH_C1A_SRC_IFIFO2_DST_OFIFO ) &&
!FLAGS_MATCH(cmdFlags,MOVE_AUX_NONE_SRC_IFIFO1_DST_OFIFO,MOVE_AUX_NONE_SRC_IFIFO1_DST_OFIFO ) &&
!FLAGS_MATCH(cmdFlags,MOVE_AUX_FLSH_SRC_IFIFO1_DST_OFIFO,MOVE_AUX_FLSH_SRC_IFIFO1_DST_OFIFO ))
/* Wind River fix end */
{
ASSERT_COND(offset <= 128);
}
/* Wind River fix start */
if(!FLAGS_MATCH(cmdFlags,MOVE_AUX_FLSH_C2A_SRC_IFIFO2_DST_OFIFO,MOVE_AUX_FLSH_C2A_SRC_IFIFO2_DST_OFIFO) &&
!FLAGS_MATCH(cmdFlags,MOVE_AUX_FLSH_C1A_SRC_IFIFO2_DST_OFIFO,MOVE_AUX_FLSH_C1A_SRC_IFIFO2_DST_OFIFO) &&
!FLAGS_MATCH(cmdFlags,MOVE_AUX_NONE_SRC_IFIFO1_DST_OFIFO,MOVE_AUX_NONE_SRC_IFIFO1_DST_OFIFO ) &&
!FLAGS_MATCH(cmdFlags,MOVE_AUX_FLSH_SRC_IFIFO1_DST_OFIFO,MOVE_AUX_FLSH_SRC_IFIFO1_DST_OFIFO ))
{
/* These assert is not applicable when offset is treated as 8 additional length bits */
ASSERT_COND(IN_RANGE(MIN_MOVE_OFFSET,offset,MAX_MOVE_OFFSET));
ASSERT_COND(IN_RANGE(MIN_MOVE_LENGTH,length,MAX_MOVE_LENGTH));
}
else
{
ASSERT_COND(IN_RANGE(MIN_MOVE_LENGTH, (length | MOVE_OFFSET(offset)), UINT16_MAX));
}
/* Wind River fix end */
/* Calculate additional flags */
cmdFlags |= MOVE_CTYPE;
cmdFlags |= MOVE_OFFSET(offset);
cmdFlags |= MOVE_LENGTH(length);
/* Insert the command */
WriteWord(p_DescHandle,cmdFlags);
}
void CmdInsertAlgOperation(t_DescHandle* p_DescHandle,
uint32_t cmdFlags)
{
/* Calculate additional flags */
cmdFlags |= (uint32_t) ALG_OP_CTYPE;
/* Insert the command */
WriteWord(p_DescHandle,cmdFlags);
}
void CmdInsertPclOperation(t_DescHandle* p_DescHandle,
uint32_t cmdFlags)
{
/* Calculate additional flags */
cmdFlags |= (uint32_t) PCL_OP_CTYPE;
/* Insert the command */
WriteWord(p_DescHandle,cmdFlags);
}
void CmdInsertPkhaOperation(t_DescHandle* p_DescHandle,
uint32_t cmdFlags)
{
/* Calculate additional flags */
cmdFlags |= (uint32_t) PKHA_OP_CTYPE;
cmdFlags |= PKHA_OP_TYPE;
cmdFlags |= PKHA_OP_ID;
/* Insert the command */
WriteWord(p_DescHandle,cmdFlags);
}
void CmdInsertLocalJump(t_DescHandle* p_DescHandle,
uint32_t cmdFlags)
{
/* Calculate additional flags */
cmdFlags |= (uint32_t) JUMP_CTYPE;
cmdFlags |= JUMP_TYPE_LOCAL;
/* Insert the command */
WriteWord(p_DescHandle,cmdFlags);
}
void CmdUpdateLocalJump(t_DescHandle* p_DescHandle,
uint32_t jumpCmdIndex)
{
/* Read the Jump command */
uint32_t cmdFlags = GET_UINT32(p_DescHandle->p_Buffer[jumpCmdIndex]);
/* Assert input arguments */
ASSERT_COND(p_DescHandle->nextIndex > jumpCmdIndex);
/* Update the Jump command */
cmdFlags |= JUMP_LOCAL_OFFSET(p_DescHandle->nextIndex-jumpCmdIndex);
/* Reinsert the Jump command */
WRITE_UINT32(p_DescHandle->p_Buffer[jumpCmdIndex],cmdFlags);
}
void CmdInsertNonLocalJump(t_DescHandle* p_DescHandle,
uint32_t cmdFlags,
uint32_t* p_JumpAddr)
{
/* Assert input arguments */
ASSERT_COND(p_JumpAddr != NULL);
/* Calculate additional flags */
cmdFlags |= (uint32_t) JUMP_CTYPE;
cmdFlags |= JUMP_TYPE_NON_LOCAL;
/* Insert the command */
WriteWord(p_DescHandle,cmdFlags);
WriteAddr(p_DescHandle,p_JumpAddr);
}
void CmdInsertHaltWithTestStatus(t_DescHandle* p_DescHandle,
uint32_t cmdFlags)
{
/* Assert input arguments */
ASSERT_COND(FLAGS_MATCH(cmdFlags,JUMP_SL_MASK,JUMP_SL_0));
/* Calculate additional flags */
cmdFlags |= (uint32_t) JUMP_CTYPE;
cmdFlags |= JUMP_TYPE_HALT_TEST_STATUS;
/* Insert the command */
WriteWord(p_DescHandle,cmdFlags);
}
void CmdInsertHaltWithUserStatus(t_DescHandle* p_DescHandle,
uint32_t cmdFlags,
uint32_t status)
{
/* Calculate additional flags */
cmdFlags |= (uint32_t) JUMP_CTYPE;
cmdFlags |= JUMP_TYPE_HALT_USER_STATUS;
cmdFlags |= JUMP_HALT_USER_STATUS(status);
/* Insert the command */
WriteWord(p_DescHandle,cmdFlags);
}
void CmdInsertMath(t_DescHandle* p_DescHandle,
uint32_t cmdFlags,
uint32_t length0,
uint32_t length1,
uint8_t* p_Data0,
uint8_t* p_Data1)
{
/* Assert input arguments */
if (length0 > 0)
{
ASSERT_COND(p_Data0 != NULL);
ASSERT_COND(FLAGS_MATCH(cmdFlags,MATH_SRC0_MASK,MATH_SRC0_IMM));
}
else
{
ASSERT_COND(p_Data0 == NULL);
ASSERT_COND(!FLAGS_MATCH(cmdFlags,MATH_SRC0_MASK,MATH_SRC0_IMM));
}
if (length1 > 0)
{
ASSERT_COND(p_Data1 != NULL);
ASSERT_COND(FLAGS_MATCH(cmdFlags,MATH_SRC1_MASK,MATH_SRC1_IMM));
}
else
{
ASSERT_COND(p_Data1 == NULL);
ASSERT_COND(!FLAGS_MATCH(cmdFlags,MATH_SRC1_MASK,MATH_SRC1_IMM));
}
if (FLAGS_MATCH(cmdFlags,MATH_FUNC_MASK,MATH_FUNC_SHIFT_L))
{
ASSERT_COND(!FLAGS_MATCH(cmdFlags,MATH_DST_MASK,MATH_DST_NONE));
}
if (FLAGS_MATCH(cmdFlags,MATH_FUNC_MASK,MATH_FUNC_SHIFT_R))
{
ASSERT_COND(!FLAGS_MATCH(cmdFlags,MATH_DST_MASK,MATH_DST_NONE));
}
if (FLAGS_MATCH(cmdFlags,MATH_FUNC_MASK,MATH_FUNC_SHLD))
{
ASSERT_COND(!FLAGS_MATCH(cmdFlags,MATH_DST_MASK,MATH_DST_IMM ));
ASSERT_COND(!FLAGS_MATCH(cmdFlags,MATH_DST_MASK,MATH_DST_SIL ));
ASSERT_COND(!FLAGS_MATCH(cmdFlags,MATH_DST_MASK,MATH_DST_SOL ));
ASSERT_COND(!FLAGS_MATCH(cmdFlags,MATH_DST_MASK,MATH_DST_VSIL));
ASSERT_COND(!FLAGS_MATCH(cmdFlags,MATH_DST_MASK,MATH_DST_VSOL));
ASSERT_COND(!FLAGS_MATCH(cmdFlags,MATH_DST_MASK,MATH_DST_NONE));
}
if (FLAGS_MATCH(cmdFlags,MATH_LEN_MASK,MATH_LEN_8_BYTE))
{
ASSERT_COND(!FLAGS_MATCH(cmdFlags,MATH_DST_MASK,MATH_DST_SIL ));
ASSERT_COND(!FLAGS_MATCH(cmdFlags,MATH_DST_MASK,MATH_DST_SOL ));
ASSERT_COND(!FLAGS_MATCH(cmdFlags,MATH_DST_MASK,MATH_DST_VSIL));
ASSERT_COND(!FLAGS_MATCH(cmdFlags,MATH_DST_MASK,MATH_DST_VSOL));
}
if (length0>0 && length1>0)
{
ASSERT_COND(length0 <= 4);
ASSERT_COND(length1 <= 4);
ASSERT_COND(!FLAGS_MATCH(cmdFlags,MATH_LEN_MASK,MATH_LEN_8_BYTE));
}
/* Calculate additional flags */
cmdFlags |= (uint32_t) MATH_CTYPE;
cmdFlags |= MATH_IFB(FLAGS_MATCH(cmdFlags,MATH_LEN_MASK,MATH_LEN_8_BYTE) && length0>0 && length0<=4 && length1==0);
cmdFlags |= MATH_IFB(FLAGS_MATCH(cmdFlags,MATH_LEN_MASK,MATH_LEN_8_BYTE) && length1>0 && length1<=4 && length0==0);
/* Insert the command */
WriteWord(p_DescHandle,cmdFlags);
if (p_Data0)
WriteData(p_DescHandle,p_Data0,length0);
if (p_Data1)
WriteData(p_DescHandle,p_Data1,length1);
}
void CmdInsertSeqInPtr(t_DescHandle* p_DescHandle,
uint32_t cmdFlags,
uint32_t length,
uint8_t* p_Data)
{
/* Assert input arguments */
ASSERT_COND(IN_RANGE(MIN_SEQ_IN_PTR_LENGTH,length,MAX_SEQ_IN_PTR_LENGTH));
/* Calculate additional flags */
cmdFlags |= (uint32_t) SEQ_IN_PTR_CTYPE;
if (length > MAX_NOT_EXT_LENGTH)
{
cmdFlags |= SEQ_IN_PTR_EXT;
cmdFlags &= ~SEQ_IN_PTR_LENGTH(~0);
}
else
{
cmdFlags &= ~SEQ_IN_PTR_EXT;
cmdFlags |= SEQ_IN_PTR_LENGTH(length);
}
/* Insert the command */
WriteWord(p_DescHandle,cmdFlags);
if (p_Data)
WriteAddr(p_DescHandle,p_Data);
if (length > MAX_NOT_EXT_LENGTH)
WriteWord(p_DescHandle,length);
}
void CmdInsertSeqOutPtr(t_DescHandle* p_DescHandle,
uint32_t cmdFlags,
uint32_t length,
uint8_t* p_Data)
{
/* Assert input arguments */
ASSERT_COND(IN_RANGE(MIN_SEQ_OUT_PTR_LENGTH,length,MAX_SEQ_OUT_PTR_LENGTH));
/* Calculate additional flags */
cmdFlags |= (uint32_t) SEQ_OUT_PTR_CTYPE;
if (length > MAX_NOT_EXT_LENGTH)
{
cmdFlags |= SEQ_OUT_PTR_EXT;
cmdFlags &= ~SEQ_OUT_PTR_LENGTH(~0);
}
else
{
cmdFlags &= ~SEQ_OUT_PTR_EXT;
cmdFlags |= SEQ_OUT_PTR_LENGTH(length);
}
/* Insert the command */
WriteWord(p_DescHandle,cmdFlags);
if (p_Data)
WriteAddr(p_DescHandle,p_Data);
if (length > MAX_NOT_EXT_LENGTH)
WriteWord(p_DescHandle,length);
}
void CmdInsertAnything(t_DescHandle* p_DescHandle,
uint32_t cmdFlags)
{
/* Insert the command */
WriteWord(p_DescHandle,cmdFlags);
}
void CmdInsertDataBlock(t_DescHandle* p_DescHandle,
uint32_t length,
uint8_t* p_Data)
{
/* Assert input arguments */
ASSERT_COND(length != 0);
ASSERT_COND(p_Data != NULL);
/* Insert the command */
WriteData(p_DescHandle,p_Data,length);
}
void CloseShrDesc(t_DescHandle* p_DescHandle,uint32_t startIndex)
{
/* Read the Header command */
uint32_t cmdFlags = GET_UINT32(p_DescHandle->p_Buffer[0]);
/* Assert input arguments */
ASSERT_COND(p_DescHandle->nextIndex >= startIndex+1);
ASSERT_COND(p_DescHandle->nextIndex <= MAX_DESC_LENGTH-1-p_DescHandle->ptrLength);
/* Update the Header command */
cmdFlags |= SHR_DESC_HDR_START_INDEX(startIndex);
cmdFlags |= SHR_DESC_HDR_LENGTH_SET(p_DescHandle->nextIndex);
/* Reinsert the Header command */
WRITE_UINT32(p_DescHandle->p_Buffer[0],cmdFlags);
}
void CloseJobDesc(t_DescHandle* p_DescHandle,uint32_t startIndex)
{
/* Read the Header command */
uint32_t cmdFlags = GET_UINT32(p_DescHandle->p_Buffer[0]);
/* Assert input arguments */
ASSERT_COND(p_DescHandle->nextIndex >= startIndex+1);
ASSERT_COND(p_DescHandle->nextIndex <= MAX_DESC_LENGTH);
/* Update the Header command */
cmdFlags |= JOB_DESC_HDR_START_INDEX(startIndex);
cmdFlags |= JOB_DESC_HDR_LENGTH_SET(p_DescHandle->nextIndex);
/* Reinsert the Header command */
WRITE_UINT32(p_DescHandle->p_Buffer[0],cmdFlags);
}
void CloseJobDescRefShr(t_DescHandle* p_DescHandle,uint32_t* p_ShrDesc)
{
/* Read the Header command */
uint32_t cmdFlags = GET_UINT32(p_DescHandle->p_Buffer[0]);
/* Read the Shared-Descriptor Header command */
uint32_t shrDescCmdFlags = GET_UINT32(p_ShrDesc[0]);
/* Assert input arguments */
ASSERT_COND(p_DescHandle->nextIndex >= MIN_DESC_LENGTH);
ASSERT_COND(p_DescHandle->nextIndex <= MAX_DESC_LENGTH);
/* Update the Header command */
cmdFlags |= JOB_DESC_HDR_SHR_DESC_LENGTH(SHR_DESC_HDR_LENGTH_GET(shrDescCmdFlags));
cmdFlags |= JOB_DESC_HDR_LENGTH_SET(p_DescHandle->nextIndex);
/* Reinsert the Header command */
WRITE_UINT32(p_DescHandle->p_Buffer[0],cmdFlags);
}
static inline void WriteWord(t_DescHandle* p_DescHandle,uint32_t word)
{
ASSERT_COND(p_DescHandle->nextIndex+1 <= MAX_DESC_LENGTH);
WRITE_UINT32(p_DescHandle->p_Buffer[p_DescHandle->nextIndex],word);
p_DescHandle->nextIndex += 1;
}
static inline void WriteAddr(t_DescHandle* p_DescHandle,void* p_Addr)
{
uint32_t i,j;
ASSERT_COND(p_DescHandle->nextIndex+p_DescHandle->ptrLength <= MAX_DESC_LENGTH);
/* Interpeak start */
p_Addr = XX_VirtToPhys(p_Addr);
/* Interpeak end */
for (i=0; i<p_DescHandle->ptrLength-sizeof(void*)/sizeof(uint32_t); i++)
WRITE_UINT32(p_DescHandle->p_Buffer[p_DescHandle->nextIndex+i],0);
for (j=i; j<p_DescHandle->ptrLength; j++)
WRITE_UINT32(p_DescHandle->p_Buffer[p_DescHandle->nextIndex+j],((uint32_t*)&p_Addr)[j-i]);
p_DescHandle->nextIndex += p_DescHandle->ptrLength;
}
static inline void WriteData(t_DescHandle* p_DescHandle,void* p_Data,uint32_t size)
{
ASSERT_COND(p_DescHandle->nextIndex+DIV_CEIL(size,sizeof(uint32_t)) <= MAX_DESC_LENGTH);
COPY_BLOCK(p_DescHandle->p_Buffer+p_DescHandle->nextIndex,p_Data,size);
p_DescHandle->nextIndex += DIV_CEIL(size,sizeof(uint32_t));
}
components/ip_net2-6.9/ipfreescale/sec4/NetCommSw/Peripherals/SEC/DCL/sec_dcl_cmd.h
+1591
View File
File diff suppressed because it is too large Load Diff