/*
 ******************************************************************************
 *                     INTERPEAK SOURCE FILE
 *
 *   Document no: @(#) $Name: VXWORKS_ITER40_2019102207 $ $RCSfile: sec_dcl_api_ipfreescale.c,v $ $Revision: 1.7.12.1 $
 *   $Source: /home/interpeak/CVSRoot/ipfreescale/sec4/sec_dcl_api_ipfreescale.c,v $
 *   $Author: jsheng $
 *   $State: Exp $ $Locker:  $
 *
 *   INTERPEAK_COPYRIGHT_STRING
 ******************************************************************************
 */

/*
 * Ipfreescale extensions to the Freescale Netcomm SEC/DCL library.
 */

/* Include the internal definitions of this module */
#include <sec_dcl_api.h>
#include <sec_dcl_cmd.h>
#include <sec_dcl_ipfreescale.h>
#include <sec_dcl_api_ipfreescale.h>
#include <Sec4.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)

#define CCMP_IV_BYTES           (16)
#define CCMP_CTR0_BYTES         (16)
#define CCMP_CTR0_SECCTX_OFFSET (16)
#define CCMP_CTR0_INCTX_OFFSET  (32)
#define CCMP_MIC_SECCTX_OFFSET  (32)
#define CCMP_MAC_BYTES          (16)
#define CCMP_MIC_BYTES          (16)
#define AESCCM_B0_BYTES         (16)
#define AESCCM_CTR0_BYTES       (16)
#define AESCCM_CTR0_SECCTX_OFFSET (16)
#define AESCCM_CTR0_INCTX_OFFSET  (32)
#define AESCCM_SEC_OUTCTX_MIC_OFFSET  (32)


uint32_t InitRandNumJobDesc(uint32_t* p_Desc,
							uint32_t  ptrSize,
							uint32_t  dataLength,
							uint8_t*  data)
{
    t_DescHandle descHandle = NewDescHandle(p_Desc,ptrSize);

    uint32_t cmdFlags;

    cmdFlags = JOB_DESC_HDR_CTYPE|JOB_DESC_HDR_SHARE_NEVER;
    CmdInsertJobDescHdr(&descHandle,cmdFlags);
    
	CmdInsertAlgOperation(&descHandle, ALG_OP_TYPE_CLASS_1 | ALG_OP_ID_RNG);
	CmdInsertRngFifoStore(&descHandle, RNG_FIFO_STORE_TYPE_ADDR, dataLength, data);

    CloseJobDesc(&descHandle, 1);
    return descHandle.nextIndex;
}


uint32_t InitMd5DigestJobDesc(uint32_t* p_Desc,
							uint32_t  ptrSize,
							uint32_t  inDataBytes,
							uint32_t  outDataBytes,
							uint8_t*  inData,
							uint8_t*  outData)
{
    t_DescHandle descHandle = NewDescHandle(p_Desc,ptrSize);

    uint32_t cmdFlags;

    cmdFlags = JOB_DESC_HDR_CTYPE|JOB_DESC_HDR_SHARE_NEVER;
    CmdInsertJobDescHdr(&descHandle,cmdFlags);
    
    /* 0 size digest is not supported. Should be handled by caller */
    if(inDataBytes == 0)
    	goto exit;
    
	CmdInsertFifoLoad(&descHandle, FIFO_LOAD_CLASS_2_TYPE_MSG_L2, inDataBytes, inData);
	CmdInsertAlgOperation(&descHandle, ALG_OP_TYPE_CLASS_2 | 
										 ALG_OP_ID_MD5 |								
										 ALG_OP_AS_INITFINAL);
	CmdInsertStore(&descHandle, STORE_CLASS_2_SRC_CTX, 0, outDataBytes, outData);

exit:	
    CloseJobDesc(&descHandle, 1);
    return descHandle.nextIndex;
}


uint32_t InitSha1DigestJobDesc(uint32_t* p_Desc,
			  	            uint32_t  ptrSize,
							uint32_t  inDataBytes,
							uint32_t  outDataBytes,
							uint8_t*  inData,
							uint8_t*  outData)
{
    t_DescHandle descHandle = NewDescHandle(p_Desc,ptrSize);

    uint32_t cmdFlags;

    cmdFlags = JOB_DESC_HDR_CTYPE|JOB_DESC_HDR_SHARE_NEVER;
    CmdInsertJobDescHdr(&descHandle,cmdFlags);
    
    /* 0 size digest is not supported. Should be handled by caller */
    if(inDataBytes == 0)
    	goto exit;
    
   	CmdInsertFifoLoad(&descHandle, FIFO_LOAD_CLASS_2_TYPE_MSG_L2, inDataBytes, inData);

   	CmdInsertAlgOperation(&descHandle, ALG_OP_TYPE_CLASS_2 | 
									   ALG_OP_ID_SHA1 |								
									   ALG_OP_AS_INITFINAL);
	CmdInsertStore(&descHandle, STORE_CLASS_2_SRC_CTX, 0, outDataBytes, outData);

exit:	
    CloseJobDesc(&descHandle, 1);
    return descHandle.nextIndex;
}


uint32_t InitMd5HmacJobDesc(uint32_t* p_Desc,
			  	            uint32_t  ptrSize,
							uint32_t  inBytes,
							uint32_t  keyBytes,
							uint32_t  outBytes,
							uint8_t*  inData,
							uint8_t*  keyData,
							uint8_t*  outData)
{
    t_DescHandle descHandle = NewDescHandle(p_Desc,ptrSize);

    uint32_t cmdFlags;

    cmdFlags = JOB_DESC_HDR_CTYPE|JOB_DESC_HDR_SHARE_NEVER;
    CmdInsertJobDescHdr(&descHandle,cmdFlags);
    
	CmdInsertKey(&descHandle, KEY_CLASS_2_DST_REGISTER, keyBytes, keyData);
	CmdInsertFifoLoad(&descHandle, FIFO_LOAD_CLASS_2_TYPE_MSG_L2, inBytes, inData);
	CmdInsertAlgOperation(&descHandle, ALG_OP_TYPE_CLASS_2 | 
										 ALG_OP_ID_MD5 |
										 ALG_OP_AAI_MDS_SHA_HMAC |								
										 ALG_OP_AS_INITFINAL);
	CmdInsertStore(&descHandle, STORE_CLASS_2_SRC_CTX, 0, outBytes, outData);
    
    CloseJobDesc(&descHandle, 1);
    return descHandle.nextIndex;
}


uint32_t InitSha1HmacJobDesc(uint32_t* p_Desc,
			  	            uint32_t  ptrSize,
							uint32_t  inBytes,
							uint32_t  keyBytes,
							uint32_t  outBytes,
							uint8_t*  inData,
							uint8_t*  keyData,
							uint8_t*  outData)
{
    t_DescHandle descHandle = NewDescHandle(p_Desc,ptrSize);

    uint32_t cmdFlags;

    cmdFlags = JOB_DESC_HDR_CTYPE|JOB_DESC_HDR_SHARE_NEVER;
    CmdInsertJobDescHdr(&descHandle,cmdFlags);
    
	CmdInsertKey(&descHandle, KEY_CLASS_2_DST_REGISTER, keyBytes, keyData);
	CmdInsertFifoLoad(&descHandle, FIFO_LOAD_CLASS_2_TYPE_MSG_L2, inBytes, inData);
	CmdInsertAlgOperation(&descHandle, ALG_OP_TYPE_CLASS_2 | 
										 ALG_OP_ID_SHA1 |
										 ALG_OP_AAI_MDS_SHA_HMAC |								
										 ALG_OP_AS_INITFINAL);
	CmdInsertStore(&descHandle, STORE_CLASS_2_SRC_CTX, 0, outBytes, outData);
    
    CloseJobDesc(&descHandle, 1);
    return descHandle.nextIndex;
}


uint32_t InitDesCbcEncryptJobDesc(uint32_t* p_Desc,
			  	            uint32_t  ptrSize,
							uint32_t  inBytes,
							uint32_t  keyBytes,
							uint32_t  inIvBytes,
							uint32_t  outBytes,
							uint8_t*  inData,
							uint8_t*  keyData,
							uint8_t*  inIvData,
							uint8_t*  outData)
{
    t_DescHandle descHandle = NewDescHandle(p_Desc,ptrSize);

    uint32_t cmdFlags;

    cmdFlags = JOB_DESC_HDR_CTYPE|JOB_DESC_HDR_SHARE_NEVER;
    CmdInsertJobDescHdr(&descHandle,cmdFlags);
    
	CmdInsertKey(&descHandle, KEY_CLASS_1_DST_REGISTER | KEY_IMM, keyBytes, keyData); /* DES has 8 has key size. We can use immediate */	
	CmdInsertLoad(&descHandle, LOAD_CLASS_1_DST_CTX, 0, inIvBytes, inIvData);
	CmdInsertFifoLoad(&descHandle, FIFO_LOAD_CLASS_1_TYPE_MSG_L1, inBytes, inData);
	/* DES CBC encrypt with parity check */
	CmdInsertAlgOperation(&descHandle, ALG_OP_TYPE_CLASS_1 | 
										 ALG_OP_ID_DES |
										 ALG_OP_DIR_ENC |
										 ALG_OP_AAI_DES_CBC |
										 ALG_OP_ICV);
	CmdInsertFifoStore(&descHandle, FIFO_STORE_CLASS_UNUSED_TYPE_MSG, inBytes, outData);

    CloseJobDesc(&descHandle, 1);
    return descHandle.nextIndex;
}


uint32_t InitDesCbcDecryptJobDesc(uint32_t* p_Desc,
			  	            uint32_t  ptrSize,
							uint32_t  inBytes,
							uint32_t  keyBytes,
							uint32_t  inIvBytes,
							uint32_t  outBytes,
							uint8_t*  inData,
							uint8_t*  keyData,
							uint8_t*  inIvData,
							uint8_t*  outData)
{
    t_DescHandle descHandle = NewDescHandle(p_Desc,ptrSize);

    uint32_t cmdFlags;

    cmdFlags = JOB_DESC_HDR_CTYPE|JOB_DESC_HDR_SHARE_NEVER;
    CmdInsertJobDescHdr(&descHandle,cmdFlags);
    
	CmdInsertKey(&descHandle, KEY_CLASS_1_DST_REGISTER | KEY_IMM, keyBytes, keyData); /* DES has key size = 8 bytes*/
	CmdInsertLoad(&descHandle, LOAD_CLASS_1_DST_CTX, 0, inIvBytes, inIvData);
	CmdInsertFifoLoad(&descHandle, FIFO_LOAD_CLASS_1_TYPE_MSG_L1, inBytes, inData);
	CmdInsertAlgOperation(&descHandle, ALG_OP_TYPE_CLASS_1 | 
										 ALG_OP_ID_DES |
										 ALG_OP_DIR_DEC |
										 ALG_OP_AAI_DES_CBC);
	CmdInsertFifoStore(&descHandle, FIFO_STORE_CLASS_UNUSED_TYPE_MSG, inBytes, outData);

    CloseJobDesc(&descHandle, 1);
    return descHandle.nextIndex;
}


uint32_t InitDesEcbEncryptJobDesc(uint32_t* p_Desc,
			  	            uint32_t  ptrSize,
							uint32_t  inBytes,
							uint32_t  keyBytes,
							uint32_t  outBytes,
							uint8_t*  inData,
							uint8_t*  keyData,
							uint8_t*  outData)
{
    t_DescHandle descHandle = NewDescHandle(p_Desc,ptrSize);

    uint32_t cmdFlags;

    cmdFlags = JOB_DESC_HDR_CTYPE|JOB_DESC_HDR_SHARE_NEVER;
    CmdInsertJobDescHdr(&descHandle,cmdFlags);
    
	CmdInsertKey(&descHandle, KEY_CLASS_1_DST_REGISTER | KEY_IMM, keyBytes, keyData); /* DES has 8 has key size */
	CmdInsertFifoLoad(&descHandle, FIFO_LOAD_CLASS_1_TYPE_MSG_L1, inBytes, inData);	
	CmdInsertAlgOperation(&descHandle, ALG_OP_TYPE_CLASS_1 | 
										 ALG_OP_ID_DES |
										 ALG_OP_DIR_ENC |
										 ALG_OP_AAI_DES_ECB);
	CmdInsertFifoStore(&descHandle, FIFO_STORE_CLASS_UNUSED_TYPE_MSG, inBytes, outData);

    CloseJobDesc(&descHandle, 1);
    return descHandle.nextIndex;
}

uint32_t InitDesEcbDecryptJobDesc(uint32_t* p_Desc,
			  	            uint32_t  ptrSize,
							uint32_t  inBytes,
							uint32_t  keyBytes,
							uint32_t  outBytes,
							uint8_t*  inData,
							uint8_t*  keyData,
							uint8_t*  outData)
{
    t_DescHandle descHandle = NewDescHandle(p_Desc,ptrSize);

    uint32_t cmdFlags;

    cmdFlags = JOB_DESC_HDR_CTYPE|JOB_DESC_HDR_SHARE_NEVER;
    CmdInsertJobDescHdr(&descHandle,cmdFlags);
    
	CmdInsertKey(&descHandle, KEY_CLASS_1_DST_REGISTER | KEY_IMM, keyBytes, keyData); /* DES has 8 has key size */
	CmdInsertFifoLoad(&descHandle, FIFO_LOAD_CLASS_1_TYPE_MSG_L1, inBytes, inData);
	CmdInsertAlgOperation(&descHandle, ALG_OP_TYPE_CLASS_1 | 
										 ALG_OP_ID_DES |
										 ALG_OP_DIR_DEC |
										 ALG_OP_AAI_DES_ECB);
	CmdInsertFifoStore(&descHandle, FIFO_STORE_CLASS_UNUSED_TYPE_MSG, inBytes, outData);

    CloseJobDesc(&descHandle, 1);
    return descHandle.nextIndex;
}


uint32_t InitTdesCbcEncryptJobDesc(uint32_t* p_Desc,
			  	            uint32_t  ptrSize,
							uint32_t  inBytes,
							uint32_t  keyBytes,
							uint32_t  inIvBytes,
							uint32_t  outBytes,
							uint8_t*  inData,
							uint8_t*  keyData,
							uint8_t*  inIvData,
							uint8_t*  outData)
{
    t_DescHandle descHandle = NewDescHandle(p_Desc,ptrSize);

    uint32_t cmdFlags;

    cmdFlags = JOB_DESC_HDR_CTYPE|JOB_DESC_HDR_SHARE_NEVER;
    CmdInsertJobDescHdr(&descHandle,cmdFlags);
    
	CmdInsertKey(&descHandle, KEY_CLASS_1_DST_REGISTER, keyBytes, keyData);
	CmdInsertLoad(&descHandle, LOAD_CLASS_1_DST_CTX, 0, inIvBytes, inIvData);
	CmdInsertFifoLoad(&descHandle, FIFO_LOAD_CLASS_1_TYPE_MSG_L1, inBytes, inData);
	CmdInsertAlgOperation(&descHandle, ALG_OP_TYPE_CLASS_1 | 
										 ALG_OP_ID_3DES |
										 ALG_OP_DIR_ENC |
										 ALG_OP_AAI_DES_CBC);
	CmdInsertFifoStore(&descHandle, FIFO_STORE_CLASS_UNUSED_TYPE_MSG, inBytes, outData);

    CloseJobDesc(&descHandle, 1);
    return descHandle.nextIndex;
}


uint32_t InitTdesCbcDecryptJobDesc(uint32_t* p_Desc,
			  	            uint32_t  ptrSize,
							uint32_t  inBytes,
							uint32_t  keyBytes,
							uint32_t  inIvBytes,
							uint32_t  outBytes,
							uint8_t*  inData,
							uint8_t*  keyData,
							uint8_t*  inIvData,
							uint8_t*  outData)
{
    t_DescHandle descHandle = NewDescHandle(p_Desc,ptrSize);

    uint32_t cmdFlags;

    cmdFlags = JOB_DESC_HDR_CTYPE|JOB_DESC_HDR_SHARE_NEVER;
    CmdInsertJobDescHdr(&descHandle,cmdFlags);
    
	CmdInsertKey(&descHandle, KEY_CLASS_1_DST_REGISTER, keyBytes, keyData);
	CmdInsertLoad(&descHandle, LOAD_CLASS_1_DST_CTX, 0, inIvBytes, inIvData);
	CmdInsertFifoLoad(&descHandle, FIFO_LOAD_CLASS_1_TYPE_MSG_L1, inBytes, inData);
	CmdInsertAlgOperation(&descHandle, ALG_OP_TYPE_CLASS_1 | 
										 ALG_OP_ID_3DES |
										 ALG_OP_DIR_DEC |
										 ALG_OP_AAI_DES_CBC);
	CmdInsertFifoStore(&descHandle, FIFO_STORE_CLASS_UNUSED_TYPE_MSG, inBytes, outData);

    CloseJobDesc(&descHandle, 1);
    return descHandle.nextIndex;
}


uint32_t InitTdesEcbEncryptJobDesc(uint32_t* p_Desc,
			  	            uint32_t  ptrSize,
							uint32_t  inBytes,
							uint32_t  keyBytes,
							uint32_t  outBytes,
							uint8_t*  inData,
							uint8_t*  keyData,
							uint8_t*  outData)
{
    t_DescHandle descHandle = NewDescHandle(p_Desc,ptrSize);

    uint32_t cmdFlags;

    cmdFlags = JOB_DESC_HDR_CTYPE|JOB_DESC_HDR_SHARE_NEVER;
    CmdInsertJobDescHdr(&descHandle,cmdFlags);
    
	CmdInsertKey(&descHandle, KEY_CLASS_1_DST_REGISTER, keyBytes, keyData);
	CmdInsertFifoLoad(&descHandle, FIFO_LOAD_CLASS_1_TYPE_MSG_L1, inBytes, inData);
	CmdInsertAlgOperation(&descHandle, ALG_OP_TYPE_CLASS_1 | 
										 ALG_OP_ID_3DES |
										 ALG_OP_DIR_ENC |
										 ALG_OP_AAI_DES_ECB);
	CmdInsertFifoStore(&descHandle, FIFO_STORE_CLASS_UNUSED_TYPE_MSG, inBytes, outData);

    CloseJobDesc(&descHandle, 1);
    return descHandle.nextIndex;
}


uint32_t InitTdesEcbDecryptJobDesc(uint32_t* p_Desc,
			  	            uint32_t  ptrSize,
							uint32_t  inBytes,
							uint32_t  keyBytes,
							uint32_t  outBytes,
							uint8_t*  inData,
							uint8_t*  keyData,
							uint8_t*  outData)
{
    t_DescHandle descHandle = NewDescHandle(p_Desc,ptrSize);

    uint32_t cmdFlags;

    cmdFlags = JOB_DESC_HDR_CTYPE|JOB_DESC_HDR_SHARE_NEVER;
    CmdInsertJobDescHdr(&descHandle,cmdFlags);
    
	CmdInsertKey(&descHandle, KEY_CLASS_1_DST_REGISTER, keyBytes, keyData);
	CmdInsertFifoLoad(&descHandle, FIFO_LOAD_CLASS_1_TYPE_MSG_L1, inBytes, inData);
	CmdInsertAlgOperation(&descHandle, ALG_OP_TYPE_CLASS_1 | 
										 ALG_OP_ID_3DES |
										 ALG_OP_DIR_DEC |
										 ALG_OP_AAI_DES_ECB);
	CmdInsertFifoStore(&descHandle, FIFO_STORE_CLASS_UNUSED_TYPE_MSG, inBytes, outData);    

    CloseJobDesc(&descHandle, 1);
    return descHandle.nextIndex;
}


uint32_t InitAesCbcEncryptJobDesc(uint32_t* p_Desc,
			  	            uint32_t  ptrSize,
							uint32_t  inBytes,
							uint32_t  keyBytes,
							uint32_t  inIvBytes,
							uint32_t  outCtxBytes,
							uint8_t*  inData,
							uint8_t*  keyData,
							uint8_t*  inIvData,
							uint8_t*  outData,
							uint8_t*  outCtxData)
{
    t_DescHandle descHandle = NewDescHandle(p_Desc,ptrSize);

    uint32_t cmdFlags;

    cmdFlags = JOB_DESC_HDR_CTYPE|JOB_DESC_HDR_SHARE_NEVER;
    CmdInsertJobDescHdr(&descHandle,cmdFlags);
    
	CmdInsertKey(&descHandle, KEY_CLASS_1_DST_REGISTER, keyBytes, keyData);
	CmdInsertLoad(&descHandle, LOAD_CLASS_1_DST_CTX, 0, inIvBytes, inIvData);
	CmdInsertFifoLoad(&descHandle, FIFO_LOAD_CLASS_1_TYPE_MSG_L1, inBytes, inData);
	CmdInsertAlgOperation(&descHandle, ALG_OP_TYPE_CLASS_1 | 
										 ALG_OP_ID_AES |
										 ALG_OP_AS_INITFINAL |
										 ALG_OP_DIR_ENC |
										 ALG_OP_AAI_AES_CBC);
	CmdInsertFifoStore(&descHandle, FIFO_STORE_CLASS_UNUSED_TYPE_MSG, inBytes, outData);	
    CmdInsertStore(&descHandle, STORE_CLASS_1_SRC_CTX, 0, outCtxBytes, outCtxData);

    CloseJobDesc(&descHandle, 1);
    return descHandle.nextIndex;
}


uint32_t InitAesCbcDecryptJobDesc(uint32_t* p_Desc,
			  	            uint32_t  ptrSize,
							uint32_t  inBytes,
							uint32_t  keyBytes,
							uint32_t  inIvBytes,
                            uint32_t  outCtxBytes,
							uint8_t*  inData,
							uint8_t*  keyData,
							uint8_t*  inIvData,
							uint8_t*  outData,
							uint8_t*  outCtxData)
{
    t_DescHandle descHandle = NewDescHandle(p_Desc,ptrSize);

    uint32_t cmdFlags;

    cmdFlags = JOB_DESC_HDR_CTYPE|JOB_DESC_HDR_SHARE_NEVER;
    CmdInsertJobDescHdr(&descHandle,cmdFlags);
    
	CmdInsertKey(&descHandle, KEY_CLASS_1_DST_REGISTER, keyBytes, keyData);
	CmdInsertLoad(&descHandle, LOAD_CLASS_1_DST_CTX, 0, inIvBytes, inIvData);
	CmdInsertFifoLoad(&descHandle, FIFO_LOAD_CLASS_1_TYPE_MSG_L1, inBytes, inData);
	CmdInsertAlgOperation(&descHandle, ALG_OP_TYPE_CLASS_1 | 
										 ALG_OP_ID_AES |
										 ALG_OP_DIR_DEC |
										 ALG_OP_AS_INITFINAL |										 
										 ALG_OP_AAI_AES_CBC);
	CmdInsertFifoStore(&descHandle, FIFO_STORE_CLASS_UNUSED_TYPE_MSG, inBytes, outData);
    CmdInsertStore(&descHandle, STORE_CLASS_1_SRC_CTX, 0, outCtxBytes, outCtxData);

    CloseJobDesc(&descHandle, 1);
    return descHandle.nextIndex;
}


uint32_t InitAesEcbEncryptJobDesc(uint32_t* p_Desc,
			  	            uint32_t  ptrSize,
							uint32_t  inBytes,
							uint32_t  keyBytes,
							uint32_t  outBytes,
							uint8_t*  inData,
							uint8_t*  keyData,
							uint8_t*  outData)
{
    t_DescHandle descHandle = NewDescHandle(p_Desc,ptrSize);

    uint32_t cmdFlags;

    cmdFlags = JOB_DESC_HDR_CTYPE|JOB_DESC_HDR_SHARE_NEVER;
    CmdInsertJobDescHdr(&descHandle,cmdFlags);
    
	CmdInsertKey(&descHandle, KEY_CLASS_1_DST_REGISTER, keyBytes, keyData);
	CmdInsertFifoLoad(&descHandle, FIFO_LOAD_CLASS_1_TYPE_MSG_L1, inBytes, inData);
	CmdInsertAlgOperation(&descHandle, ALG_OP_TYPE_CLASS_1 | 
										 ALG_OP_ID_AES |
										 ALG_OP_DIR_ENC |
										 ALG_OP_AAI_AES_ECB);
	CmdInsertFifoStore(&descHandle, FIFO_STORE_CLASS_UNUSED_TYPE_MSG, inBytes, outData);

    CloseJobDesc(&descHandle, 1);
    return descHandle.nextIndex;
}


uint32_t InitAesEcbDecryptJobDesc(uint32_t* p_Desc,
			  	            uint32_t  ptrSize,
							uint32_t  inBytes,
							uint32_t  keyBytes,
							uint32_t  outBytes,
							uint8_t*  inData,
							uint8_t*  keyData,
							uint8_t*  outData)
{
    t_DescHandle descHandle = NewDescHandle(p_Desc,ptrSize);

    uint32_t cmdFlags;

    cmdFlags = JOB_DESC_HDR_CTYPE|JOB_DESC_HDR_SHARE_NEVER;
    CmdInsertJobDescHdr(&descHandle,cmdFlags);
    
	CmdInsertKey(&descHandle, KEY_CLASS_1_DST_REGISTER, keyBytes, keyData);
	CmdInsertFifoLoad(&descHandle, FIFO_LOAD_CLASS_1_TYPE_MSG_L1, inBytes, inData);
	CmdInsertAlgOperation(&descHandle, ALG_OP_TYPE_CLASS_1 | 
										 ALG_OP_ID_AES |
										 ALG_OP_DIR_DEC |
										 ALG_OP_AAI_AES_ECB);
	CmdInsertFifoStore(&descHandle, FIFO_STORE_CLASS_UNUSED_TYPE_MSG, inBytes, outData);

    CloseJobDesc(&descHandle, 1);
    return descHandle.nextIndex;
}


uint32_t InitModExpJobDesc(uint32_t* p_Desc,
			  	            uint32_t  ptrSize,
							uint32_t  aBytes,
							uint32_t  expBytes,
							uint32_t  modBytes,
							uint32_t  outBytes,
							uint8_t*  aData,
							uint8_t*  expData,
							uint8_t*  modData,
							uint8_t*  outData)
{
    t_DescHandle descHandle = NewDescHandle(p_Desc,ptrSize);

    uint32_t cmdFlags;

    cmdFlags = JOB_DESC_HDR_CTYPE|JOB_DESC_HDR_SHARE_NEVER;
    CmdInsertJobDescHdr(&descHandle,cmdFlags);
    /* bData=adata^expData % modData */
	CmdInsertKey(&descHandle, KEY_CLASS_1_DST_PKHA_E_MEM, expBytes, expData);
	CmdInsertFifoLoad(&descHandle, FIFO_LOAD_CLASS_1_TYPE_PKHA_A, aBytes, aData);
	CmdInsertFifoLoad(&descHandle, FIFO_LOAD_CLASS_1_TYPE_PKHA_N, modBytes, modData);
	CmdInsertPkhaOperation(&descHandle, PKHA_OP_MODE_MOD_EXP_B );
	CmdInsertFifoStore(&descHandle, FIFO_STORE_CLASS_1_TYPE_PKHA_B, outBytes, outData);
    
    CloseJobDesc(&descHandle, 1);
    return descHandle.nextIndex;
}


uint32_t InitRc4EncryptJobDesc(uint32_t* p_Desc,
						       uint32_t  ptrSize,
							   uint32_t  inBytes,
						       uint32_t  keyBytes,
							   uint32_t  inCtxBytes,
							   uint32_t  outCtxBytes,
							   uint8_t  *inData,
							   uint8_t  *keyData,
							   uint8_t  *inCtxData,
							   uint8_t  *outData,
							   uint8_t  *outCtxData)
{
    t_DescHandle descHandle = NewDescHandle(p_Desc,ptrSize);

    uint32_t cmdFlags;

    cmdFlags = JOB_DESC_HDR_CTYPE|JOB_DESC_HDR_SHARE_NEVER;
    CmdInsertJobDescHdr(&descHandle,cmdFlags);
    
	/* ENC bit needs to be set only for counter accuracy even though encrypt/decrypt is the same for rc4 */
    cmdFlags = ALG_OP_TYPE_CLASS_1 | ALG_OP_ID_ARC4 | ALG_OP_DIR_ENC;

	/* Add key if there is one (no input context) */
	if(keyData != NULL)
	{
		CmdInsertKey(&descHandle, KEY_CLASS_1_DST_REGISTER, keyBytes, keyData);
		cmdFlags |= ALG_OP_AS_INIT;
	}
	/* Load input context if there is one */
	if (inCtxData != NULL)
	{
		/* Load S-box, I and J pointers (as black key) from earlier job */
		CmdInsertKey(&descHandle, KEY_CLASS_1_DST_AFHA_SBOX | KEY_ENC_ON_EKT_AES_ECB_TK_OFF, KEY_DST_AFHA_SBOX_LENGTH, inCtxData);
		cmdFlags |= ALG_OP_AS_UPDATE;
	}
	CmdInsertFifoLoad(&descHandle, FIFO_LOAD_CLASS_1_TYPE_MSG_L1, inBytes, inData);
	CmdInsertAlgOperation(&descHandle, cmdFlags); 
	/* Store msg */
	CmdInsertFifoStore(&descHandle, FIFO_STORE_CLASS_UNUSED_TYPE_MSG, inBytes, outData);
	/* Save Out context (S-box, I and J pointers (as black key) for jobs to come */
	CmdInsertFifoStore(&descHandle, FIFO_STORE_CLASS_1_TYPE_AFHA_SBOX_ECB_JKEK, KEY_DST_AFHA_SBOX_LENGTH, outCtxData);

    
    CloseJobDesc(&descHandle, 1);
    return descHandle.nextIndex;
}


uint32_t InitCcmpEncryptJobDesc(uint32_t* p_Desc,
						       uint32_t  ptrSize,
							   uint32_t  inBytes,
						       uint32_t  keyBytes,
							   uint32_t  AADBytes,
							   uint32_t  MICDataBytes,
							   uint32_t  inCtxBytes,
							   uint32_t  outBytes,
							   uint8_t  *inData,
							   uint8_t  *keyData,
							   uint8_t  *AADData,
							   uint8_t  *MICData,
							   uint8_t  *inCtxData,
							   uint8_t  *outData)
{
    t_DescHandle descHandle = NewDescHandle(p_Desc,ptrSize);

    uint32_t cmdFlags;

    cmdFlags = JOB_DESC_HDR_CTYPE|JOB_DESC_HDR_SHARE_NEVER;
    CmdInsertJobDescHdr(&descHandle,cmdFlags);
    
    /* inCtxData */
    /* +--------------------------------+
     * | [0:63]    | IV [0:63]          |
     * +--------------------------------+
     * | [64:127]  | IV [64:127]        |
     * +--------------------------------+
     * | [128:191] | CCMP CTR0 [0:63]   |
     * +--------------------------------+
     * | [192:255] |                    |
     * +--------------------------------+
     */ 
    /* SEC4 Out Context Data */
    /* +--------------------------------+
     * | [0:63]    | MAC [0:63]         |
     * +--------------------------------+
     * | [64:127]  | MAC [64:127]       |
     * +--------------------------------+
     * | [128:191] | <hole>             |
     * +--------------------------------+
     * | [192:255] | <hole>             |
     * +--------------------------------+
     * | [256:319] | E(MAC[0:63])       |
     * +--------------------------------+
     * | [320:383] | E(MAC[64:127])     |
     * +--------------------------------+
     */

    /* Load key */
	CmdInsertKey(&descHandle, KEY_CLASS_1_DST_REGISTER, keyBytes, keyData);
	/* Load IV */
	CmdInsertLoad(&descHandle, LOAD_CLASS_1_DST_CTX, 0, CCMP_IV_BYTES, inCtxData);
	/* Load initial CTR0 value at offset in context*/
	CmdInsertLoad(&descHandle, LOAD_CLASS_1_DST_CTX, CCMP_CTR0_SECCTX_OFFSET, CCMP_CTR0_BYTES, inCtxData + CCMP_CTR0_INCTX_OFFSET);
	/* AAD data */
	if(AADBytes > 0)
	{
		CmdInsertFifoLoad(&descHandle, FIFO_LOAD_CLASS_1_TYPE_AAD_F1, AADBytes, AADData);
	}
	/* Message data */
	CmdInsertFifoLoad(&descHandle, FIFO_LOAD_CLASS_1_TYPE_MSG_L1, inBytes, inData);
	CmdInsertAlgOperation(&descHandle, ALG_OP_TYPE_CLASS_1 | 
										 ALG_OP_ID_AES |
										 ALG_OP_DIR_ENC |
										 ALG_OP_AAI_AES_CCM |
										 ALG_OP_AAI_CTR_MOD128 | 
										 ALG_OP_AS_INITFINAL ); 
	CmdInsertFifoStore(&descHandle, FIFO_STORE_CLASS_UNUSED_TYPE_MSG, outBytes, outData);
	/* Store output MAC and MIC data */
	CmdInsertStore(&descHandle, STORE_CLASS_1_SRC_CTX, 0, CCMP_MAC_BYTES, MICData);
	CmdInsertStore(&descHandle, STORE_CLASS_1_SRC_CTX, CCMP_MIC_SECCTX_OFFSET, CCMP_MIC_BYTES, MICData + CCMP_MAC_BYTES);
	
    CloseJobDesc(&descHandle, 1);
    return descHandle.nextIndex;
}

uint32_t InitCRCJobDesc(uint32_t* p_Desc,
			            uint32_t  ptrSize,
			            uint32_t  inDataBytes,
			            uint8_t*  inData,
			            uint8_t   outDataBytes,
			            uint8_t*  outData,
			            uint32_t  inCtxBytes,
			            uint8_t*  inCtxData,
			            uint8_t*  polynomialData,
			            uint32_t  crcOptions)
{
    t_DescHandle descHandle = NewDescHandle(p_Desc,ptrSize);

    uint32_t cmdFlags;
    
    cmdFlags = JOB_DESC_HDR_CTYPE|JOB_DESC_HDR_SHARE_NEVER;
    CmdInsertJobDescHdr(&descHandle,cmdFlags);
    
    /* 0 size CRC is not supported. Should be handled by caller */
    if(inDataBytes == 0)
    	goto exit;

    /* Load inCtx data, e.g. for chained CRC calculation */
    if(inCtxData != NULL)
    	CmdInsertLoad(&descHandle, LOAD_CLASS_2_DST_CTX | LOAD_IMM, 0, inCtxBytes, inCtxData);

    /* Input data */
    cmdFlags = 0;
    if(crcOptions & SEC4_OPT_INDATA_IS_SGT)
    	cmdFlags = FIFO_LOAD_SGT;
    CmdInsertFifoLoad(&descHandle, cmdFlags | FIFO_LOAD_CLASS_2_TYPE_MSG_L2, inDataBytes, inData);
    
    /* Load polynomial if needed */
    if(!(crcOptions & (SEC4_DCL_OPT_CRC_IEEE802 | SEC4_DCL_OPT_CRC_IETF3385)))
    {
    	/* Load key (polynomial) */
    	CmdInsertKey(&descHandle, KEY_CLASS_2_DST_REGISTER | KEY_IMM, outDataBytes, polynomialData);
    }
    /* Issue CRC command based on polynomial */
	cmdFlags = ALG_OP_TYPE_CLASS_2 | ALG_OP_ID_CRC | ALG_OP_AS_INITFINAL; /* TODO: Support for partial CRC */
	if(crcOptions & (SEC4_DCL_OPT_CRC_IEEE802))
		cmdFlags |= ALG_OP_AAI_CRC_IEEE_802;
	else if(crcOptions & (SEC4_DCL_OPT_CRC_IETF3385))
		cmdFlags |= ALG_OP_AAI_CRC_IETF_3385;
	else
		cmdFlags |= ALG_OP_AAI_CRC_CUST_POLY;
	if(crcOptions & SEC4_DCL_OPT_CRC_DIS)
		cmdFlags |= ALG_OP_AAI_CRC_DIS;
	if(crcOptions & SEC4_DCL_OPT_CRC_DOS)
		cmdFlags |= ALG_OP_AAI_CRC_DOS;
	if(crcOptions & SEC4_DCL_OPT_CRC_DOC)
		cmdFlags |= ALG_OP_AAI_CRC_DOC;

	/* TODO: Add options */
	//ALG_OP_AAI_CRC_IVZ
	CmdInsertAlgOperation(&descHandle, cmdFlags);
	CmdInsertStore(&descHandle, STORE_CLASS_2_SRC_CTX, 0, outDataBytes, outData);

exit:	
    CloseJobDesc(&descHandle, 1);
    return descHandle.nextIndex;
}

uint32_t InitMoveDataJobDesc(uint32_t* p_Desc,
						 	 uint32_t  ptrSize,
						 	 uint32_t  inDataBytes,
						 	 uint8_t*  inData,
						 	 uint8_t*  outData,
						 	 uint32_t  options)
{
    t_DescHandle descHandle = NewDescHandle(p_Desc,ptrSize);

    uint32_t cmdFlags;

    cmdFlags = JOB_DESC_HDR_CTYPE|JOB_DESC_HDR_SHARE_NEVER;
    CmdInsertJobDescHdr(&descHandle,cmdFlags);
    
    /* Disable automatic iNformation FIFO entries */
    cmdFlags = DCTRL_LOAD_AUTO_IFIFO_DISABLED;
    CmdInsertDctrlLoad(&descHandle,cmdFlags);
    
    /* Input data */
    cmdFlags = 0;
    if(options & SEC4_OPT_INDATA_IS_SGT)
    	cmdFlags = FIFO_LOAD_SGT;
    CmdInsertFifoLoad(&descHandle, cmdFlags | FIFO_LOAD_CLASS_BOTH_TYPE_MSG_L2_L1_F1, inDataBytes, inData);
   
    /* Re-enable automatic iNformation FIFO entries*/
    cmdFlags = DCTRL_LOAD_AUTO_IFIFO_ENABLED;
    CmdInsertDctrlLoad(&descHandle,cmdFlags);
        
    /* Move data to output FIFO */
    /* When moving data from IFIFO to OFIFO, offset are treated as additional 8 bits for length */ 
    CmdInsertMove(&descHandle, MOVE_AUX_FLSH_SRC_IFIFO1_DST_OFIFO, (inDataBytes >> 8) & 0xFF, inDataBytes & 0xFF);

    /* Store output data */
    cmdFlags = 0;
    if(options & SEC4_OPT_OUTDATA_IS_SGT)
    	cmdFlags = FIFO_STORE_SGT;
    CmdInsertFifoStore(&descHandle, cmdFlags | FIFO_STORE_CLASS_UNUSED_TYPE_MSG, inDataBytes, outData);
    
exit:	
    CloseJobDesc(&descHandle, 1);
    return descHandle.nextIndex;
}

uint32_t InitAesCcmEncryptJobDesc(uint32_t* p_Desc,
						       uint32_t  ptrSize,
							   uint32_t  inBytes,
						       uint32_t  keyBytes,
							   uint32_t  AADBytes,
							   uint32_t  MICDataBytes,
							   uint32_t  inCtxBytes,
							   uint32_t  outBytes,
							   uint8_t  *inData,
							   uint8_t  *keyData,
							   uint8_t  *AADData,
							   uint8_t  *inMICData,
							   uint8_t  *outMICData,
							   uint8_t  *inCtxData,
							   uint8_t  *outData,
							   uint32_t  options)
{
    t_DescHandle descHandle = NewDescHandle(p_Desc,ptrSize);

    uint32_t cmdFlags;

    cmdFlags = JOB_DESC_HDR_CTYPE|JOB_DESC_HDR_SHARE_NEVER;
    CmdInsertJobDescHdr(&descHandle,cmdFlags);
    
    /* inCtxData */
    /* +--------------------------------+
     * | [0:63]    | B0 (IV) [0:63]     |
     * +--------------------------------+
     * | [64:127]  | B0 (IV) [64:127]   |
     * +--------------------------------+
     * | [128:191] | CTR0 [0:63]        |
     * +--------------------------------+
     * | [192:255] | CTR0 [64:127]      |
     * +--------------------------------+
     */ 
    /* SEC4 Out Context Data */
    /* +--------------------------------+
     * | [0:63]    | MAC [0:63]         |
     * +--------------------------------+
     * | [64:127]  | MAC [64:127]       |
     * +--------------------------------+
     * | [128:191] | <hole>             |
     * +--------------------------------+
     * | [192:255] | <hole>             |
     * +--------------------------------+
     * | [256:319] | E(MAC[0:63]) (MIC) |
     * +--------------------------------+
     * | [320:383] | E(MAC[64:127])(MIC)|
     * +--------------------------------+
     */

    /* Load key */
	CmdInsertKey(&descHandle, KEY_CLASS_1_DST_REGISTER, keyBytes, keyData);
	/* Load AES CCM initial B0 block */
	CmdInsertLoad(&descHandle, LOAD_CLASS_1_DST_CTX, 0, AESCCM_B0_BYTES, inCtxData);
	/* Load initial CTR0 value at offset in context*/
	CmdInsertLoad(&descHandle, LOAD_CLASS_1_DST_CTX, AESCCM_CTR0_SECCTX_OFFSET, AESCCM_CTR0_BYTES, inCtxData + AESCCM_CTR0_INCTX_OFFSET);
	/* AAD data */
	if(AADBytes > 0)
	{
		CmdInsertFifoLoad(&descHandle, FIFO_LOAD_CLASS_1_TYPE_AAD_F1, AADBytes, AADData);
	}
	/* Load message data */
	cmdFlags = 0;
	if(options & SEC4_OPT_INDATA_IS_SGT)
        cmdFlags = FIFO_LOAD_SGT;
	CmdInsertFifoLoad(&descHandle, cmdFlags | FIFO_LOAD_CLASS_1_TYPE_MSG_L1, inBytes, inData);
	CmdInsertAlgOperation(&descHandle, ALG_OP_TYPE_CLASS_1 | 
										 ALG_OP_ID_AES |
										 ALG_OP_DIR_ENC |
										 ALG_OP_AAI_AES_CCM |
										 ALG_OP_AAI_CTR_MOD128 | 
										 ALG_OP_AS_INITFINAL );
	/* Store encrypted out data */
	cmdFlags = 0;
	if(options & SEC4_OPT_OUTDATA_IS_SGT)
        cmdFlags = FIFO_STORE_SGT;
	CmdInsertFifoStore(&descHandle, cmdFlags | FIFO_STORE_CLASS_UNUSED_TYPE_MSG, outBytes, outData);
	/* Store output MIC data */
	CmdInsertStore(&descHandle, STORE_CLASS_1_SRC_CTX, CCMP_MIC_SECCTX_OFFSET, MICDataBytes, outMICData);
	
    CloseJobDesc(&descHandle, 1);
    return descHandle.nextIndex;
}

uint32_t InitAesCcmDecryptJobDesc(uint32_t* p_Desc,
						       uint32_t  ptrSize,
							   uint32_t  inBytes,
						       uint32_t  keyBytes,
							   uint32_t  AADBytes,
							   uint32_t  MICDataBytes,
							   uint32_t  inCtxBytes,
							   uint32_t  outBytes,
							   uint8_t  *inData,
							   uint8_t  *keyData,
							   uint8_t  *AADData,
							   uint8_t  *inMICData,
							   uint8_t  *outMICData,							   
							   uint8_t  *inCtxData,
							   uint8_t  *outData,
							   uint32_t  options)
{
    t_DescHandle descHandle = NewDescHandle(p_Desc,ptrSize);

    uint32_t cmdFlags;

    cmdFlags = JOB_DESC_HDR_CTYPE|JOB_DESC_HDR_SHARE_NEVER;
    CmdInsertJobDescHdr(&descHandle,cmdFlags);
    
    /* inCtxData */
    /* +--------------------------------+
     * | [0:63]    | B0 (IV) [0:63]     |
     * +--------------------------------+
     * | [64:127]  | B0 (IV) [64:127]   |
     * +--------------------------------+
     * | [128:191] | CTR0 [0:63]        |
     * +--------------------------------+
     * | [192:255] | CTR0 [64:127]      |
     * +--------------------------------+
     */ 
    /* SEC4 Out Context Data */
    /* +--------------------------------+
     * | [0:63]    | MAC [0:63]         |
     * +--------------------------------+
     * | [64:127]  | MAC [64:127]       |
     * +--------------------------------+
     * | [128:191] | <hole>             |
     * +--------------------------------+
     * | [192:255] | <hole>             |
     * +--------------------------------+
     * | [256:319] | E(MAC[0:63]) (MIC) |
     * +--------------------------------+
     * | [320:383] | E(MAC[64:127])(MIC)|
     * +--------------------------------+
     */

    /* Load key */
	CmdInsertKey(&descHandle, KEY_CLASS_1_DST_REGISTER, keyBytes, keyData);
	/* Load IV */
	CmdInsertLoad(&descHandle, LOAD_CLASS_1_DST_CTX, 0, AESCCM_B0_BYTES, inCtxData);
	/* Load initial CTR0 value at offset in context*/
	CmdInsertLoad(&descHandle, LOAD_CLASS_1_DST_CTX, AESCCM_CTR0_SECCTX_OFFSET, AESCCM_CTR0_BYTES, inCtxData + AESCCM_CTR0_INCTX_OFFSET);
	/* AAD data */
	if(AADBytes > 0)
	{
		CmdInsertFifoLoad(&descHandle, FIFO_LOAD_CLASS_1_TYPE_AAD_F1, AADBytes, AADData);
	}
	/* Load message data */
	cmdFlags = 0;
	if(options & SEC4_OPT_INDATA_IS_SGT)
        cmdFlags = FIFO_LOAD_SGT;
	CmdInsertFifoLoad(&descHandle, cmdFlags | FIFO_LOAD_CLASS_1_TYPE_MSG_F1, inBytes, inData);
	/* Input MIC data */
	CmdInsertFifoLoad(&descHandle, FIFO_LOAD_CLASS_1_TYPE_ICV_L1, MICDataBytes, inMICData);
	/* Decrypt */
	cmdFlags = ALG_OP_TYPE_CLASS_1 | 
			   ALG_OP_ID_AES |
			   ALG_OP_DIR_DEC |
			   ALG_OP_AAI_AES_CCM |
			   ALG_OP_AAI_CTR_MOD128 | 
			   ALG_OP_AS_INITFINAL;
	if(options & SEC4_DCL_OPT_ICV)
		cmdFlags |= ALG_OP_ICV;
	CmdInsertAlgOperation(&descHandle, cmdFlags); 
	/* Store decrypted out data */
	cmdFlags = 0;
	if(options & SEC4_OPT_OUTDATA_IS_SGT)
        cmdFlags = FIFO_STORE_SGT;
	CmdInsertFifoStore(&descHandle, cmdFlags | FIFO_STORE_CLASS_UNUSED_TYPE_MSG, outBytes, outData);
	/* Store output MAC data (decrypted MIC) */
	CmdInsertStore(&descHandle, STORE_CLASS_1_SRC_CTX, AESCCM_SEC_OUTCTX_MIC_OFFSET, MICDataBytes, outMICData);
	
    CloseJobDesc(&descHandle, 1);
    return descHandle.nextIndex;
}

uint32_t InitIpsecJobDesc(uint32_t* p_Desc,
					      uint32_t  ptrSize,
					      t_IpsecJobDescParam    *param)
{
    t_DescHandle descHandle = NewDescHandle(p_Desc,ptrSize);

    uint32_t cmdFlags;
    
    /* Job descriptor header */
    cmdFlags = JOB_DESC_HDR_CTYPE|JOB_DESC_HDR_SHARE_NEVER;
    CmdInsertJobDescHdr(&descHandle,cmdFlags);
    
    /* If decrypt, first generate digest over whole ESP pkt */
    if (param->jobDirection == e_DCL_JOB_DEC)
    {    	
    	CmdInsertKey(&descHandle, KEY_CLASS_2_DST_REGISTER | KEY_IMM, param->hashKeyDataBytes, param->hashKeyData);
    	CmdInsertFifoLoad(&descHandle, FIFO_LOAD_CLASS_2_TYPE_MSG_L2, param->hashInDataBytes + param->inDataBytes, param->hashInData);
    	cmdFlags = ALG_OP_TYPE_CLASS_2 | ALG_OP_AAI_MDS_SHA_HMAC | ALG_OP_AS_INITFINAL;
    	
    	EXIT_IF((param->authAlg != e_IPSEC_AUTHEN_ALG_HMAC_SHA1_96) &&
    			(param->authAlg != e_IPSEC_AUTHEN_ALG_HMAC_MD5_96));
    	switch(param->authAlg)
    	{
    	case e_IPSEC_AUTHEN_ALG_HMAC_SHA1_96:
    		cmdFlags = cmdFlags | ALG_OP_ID_SHA1;
    		break;
    	case e_IPSEC_AUTHEN_ALG_HMAC_MD5_96:
    		cmdFlags = cmdFlags | ALG_OP_ID_MD5;
    		break;    		
    	default:
    		/* We shouldn't end up here */
    		cmdFlags = 0;
    		break;
    	}
    	CmdInsertAlgOperation(&descHandle, cmdFlags);
    	CmdInsertStore(&descHandle, STORE_CLASS_2_SRC_CTX, 0, param->hashOutDataBytes, param->hashOutData);
    }
    
    /*** Encrypt/Decrypt data ***/
	CmdInsertKey(&descHandle, KEY_CLASS_1_DST_REGISTER | KEY_IMM, param->cryptoKeyDataBytes, param->cryptoKeyData);
    /*CmdInsertKey(&descHandle, KEY_CLASS_1_DST_REGISTER, param->cryptoKeyDataBytes, param->cryptoKeyData);*/
    /* Initialization Vector (IV) */
	CmdInsertLoad(&descHandle, LOAD_CLASS_1_DST_CTX, 0, param->inCtxDataBytes, param->inCtxData);
	CmdInsertFifoLoad(&descHandle, FIFO_LOAD_CLASS_1_TYPE_MSG_L1, param->inDataBytes, param->inData);
	cmdFlags = ALG_OP_TYPE_CLASS_1;
	if (param->jobDirection == e_DCL_JOB_ENC)
		cmdFlags = cmdFlags | ALG_OP_DIR_ENC;
	else
		cmdFlags = cmdFlags | ALG_OP_DIR_DEC;
	
	EXIT_IF((param->cryptoAlg != e_IPSEC_CRYPTO_ALG_DES) &&
			(param->cryptoAlg != e_IPSEC_CRYPTO_ALG_3DES) &&
			(param->cryptoAlg != e_IPSEC_CRYPTO_ALG_AES_CBC));
	switch(param->cryptoAlg)
	{
	case e_IPSEC_CRYPTO_ALG_DES:
		cmdFlags = cmdFlags | ALG_OP_ID_DES | ALG_OP_AAI_DES_CBC;
		break;
	case e_IPSEC_CRYPTO_ALG_3DES:
		cmdFlags = cmdFlags | ALG_OP_ID_3DES | ALG_OP_AAI_DES_CBC;
		break;
	case e_IPSEC_CRYPTO_ALG_AES_CBC:
		cmdFlags = cmdFlags | ALG_OP_ID_AES | ALG_OP_AAI_AES_CBC;
		break;		
	default:
		/* We shouldn't end up here */
		cmdFlags = 0;
		break;
	}	
	CmdInsertAlgOperation(&descHandle, cmdFlags);
	CmdInsertFifoStore(&descHandle, FIFO_STORE_CLASS_UNUSED_TYPE_MSG, param->inDataBytes, param->outData + param->hashInDataBytes);
		
	/* Store output ctx data (IV for next pkt) */	
	if(param->outCtxData != NULL)	
		CmdInsertStore(&descHandle, STORE_CLASS_1_SRC_CTX, 0, param->outCtxDataBytes, param->outCtxData);

	/* If Encrypt, generate digest last over whole encrypted pkt and header */
	if (param->jobDirection == e_DCL_JOB_ENC)
	{
		/* Generate Hash */ /* TODO: Optimize. Dont write back to memory and load it back again. Is it possible? */
		CmdInsertKey(&descHandle, KEY_CLASS_2_DST_REGISTER | KEY_IMM, param->hashKeyDataBytes, param->hashKeyData);
		CmdInsertFifoLoad(&descHandle, FIFO_LOAD_CLASS_2_TYPE_MSG_L2, param->hashInDataBytes + param->inDataBytes, param->outData);
		cmdFlags = ALG_OP_TYPE_CLASS_2 | ALG_OP_AAI_MDS_SHA_HMAC | ALG_OP_AS_INITFINAL;
		EXIT_IF((param->authAlg != e_IPSEC_AUTHEN_ALG_HMAC_SHA1_96) &&
				(param->authAlg != e_IPSEC_AUTHEN_ALG_HMAC_MD5_96));
		switch(param->authAlg)
		{
		case e_IPSEC_AUTHEN_ALG_HMAC_SHA1_96:
			cmdFlags = cmdFlags | ALG_OP_ID_SHA1;
			break;
		case e_IPSEC_AUTHEN_ALG_HMAC_MD5_96:
			cmdFlags = cmdFlags | ALG_OP_ID_MD5;
			break;
		default:
			/* We shouldn't end up here */
			cmdFlags = 0;
			break;
		}
		CmdInsertAlgOperation(&descHandle, cmdFlags);
		CmdInsertStore(&descHandle, STORE_CLASS_2_SRC_CTX, 0, param->hashOutDataBytes, param->hashOutData);
	}
	
    CloseJobDesc(&descHandle, 1);
    return descHandle.nextIndex;
}