sec2_diag.c

freescale ppc sec2加解密单元驱动

	
    for(loopCnt = 0; loopCnt < SEC2_HANDLE_QUEUE_DEPTH; loopCnt ++)
    {
        if((GENERIC_REQ*)NULL != sec2_queue->pReq)
        {
            useCnt++;
        }
        if(loopCnt < 10)
        {
            sprintf((buffer+strlen(buffer)),"%d ",loopCnt);
        }
        else
        {
            sprintf((buffer+strlen(buffer)),"%d",loopCnt);
        }
	    sprintf((buffer+strlen(buffer)),"\t 0x%x\n",sec2_queue->requestingTaskId);
		sec2_queue = sec2_Queue[loopCnt].next;
    }
	
    sprintf((buffer+strlen(buffer)),"handle queue   used = %d\n",useCnt);
    sprintf((buffer+strlen(buffer)),"handle queue unused = %d\n",SEC2_HANDLE_QUEUE_DEPTH-useCnt);
    sprintf(buffer+strlen(buffer),"\n======\tSec2 Core handle queue end\t ======\n");
}


void sec2_test_des_callback(DRV_SEC2_CONTEXT *ctx)
{
    algo_msg_crypt_t *crypt;

    crypt = (algo_msg_crypt_t *)(ctx->msg);    

    /*先释放上次的ctx*/
    drv_sec2_free_context(ctx);
    
    sec2_test_des_decrypt(crypt);
    
    /* 不管是否成功，都要释放内存 */
    if(NULL != crypt->outData)
    {
        free(crypt->outData);
    }
    if(NULL != crypt->inData)
    {
        free(crypt->inData);
    }
    if(NULL != crypt->key)
    {
        free(crypt->key);
    }
    if(NULL != crypt->iv)
    {
        free(crypt->iv);
    }
    if(NULL != crypt)
    {
        free(crypt);
    }

}

void sec2_test_3des_callback(DRV_SEC2_CONTEXT *ctx)
{
    algo_msg_crypt_t *crypt;

    crypt = (algo_msg_crypt_t *)ctx->msg;    

    /*先释放上次的ctx*/
    drv_sec2_free_context(ctx);

    sec2_test_3des_decrypt(crypt);

    /* 不管是否成功，都要释放内存 */
    if(NULL != crypt->outData)
    {
        free(crypt->outData);
    }
    if(NULL != crypt->inData)
    {
        free(crypt->inData);
    }
    if(NULL != crypt->key)
    {
        free(crypt->key);
    }
    if(NULL != crypt->iv)
    {
        free(crypt->iv);
    }
    if(NULL != crypt)
    {
        free(crypt);
    }

}

void sec2_test_aes_callback(DRV_SEC2_CONTEXT *ctx)
{
    algo_msg_crypt_t *crypt;

    crypt = (algo_msg_crypt_t *)ctx->msg;    

    /*先释放上次的ctx*/
    drv_sec2_free_context(ctx);

    sec2_test_aes_decrypt(crypt);

    /* 不管是否成功，都要释放内存 */
    if(NULL != crypt->outData)
    {
        free(crypt->outData);
    }
    if(NULL != crypt->inData)
    {
        free(crypt->inData);
    }
    if(NULL != crypt->key)
    {
        free(crypt->key);
    }
    if(NULL != crypt->iv)
    {
        free(crypt->iv);
    }
    if(NULL != crypt)
    {
        free(crypt);
    }

}


int sec2_test_des_encrypt(algo_msg_crypt_t *cbc)
{
    DRV_SEC2_CONTEXT  *ctx = (DRV_SEC2_CONTEXT *)NULL;
    DES_LOADCTX_CRYPT_REQ *cryptReq = (DES_LOADCTX_CRYPT_REQ *)NULL; 
    int     ipsec_status = SEC2_ERROR;
    
    
    ctx = (DRV_SEC2_CONTEXT*)SEC2_GETBUF(sizeof(DRV_SEC2_CONTEXT));
    if (NULL == ctx)
    {
        DRV_IPSEC_DBG("drv_sec2_des_crypt:  malloc DRV_SEC2_CONTEXT failed!\n");
        return SEC2_ERROR;
    }
        

    /**************** 分配描述符内存 ****************/
    
    ctx->dpdReqMem= (UINT8*)SEC2_GETBUF(sizeof(DES_LOADCTX_CRYPT_REQ));
    if (NULL == ctx->dpdReqMem)
    {
        DRV_IPSEC_DBG("drv_sec2_des_crypt:  malloc ctx->dpdReqMem failed!\n");
        drv_sec2_free_context(ctx);
        return SEC2_ERROR;
    }

    ctx->msg = (void*)cbc;
    
    cryptReq = (DES_LOADCTX_CRYPT_REQ*) (ctx->dpdReqMem);

    /**************** 描述符填充: DES_LOADCTX_CRYPT_REQ  ****************/
    cryptReq->opId    = DPD_SDES_CBC_CTX_ENCRYPT;
    cryptReq->channel = 0;                       /*动态处理*/
    cryptReq->notify  = (PSEC_NOTIFY_ROUTINE)sec2_test_des_callback;       
    cryptReq->pNotifyCtx = ctx;
    cryptReq->notify_on_error = (PSEC_NOTIFY_ON_ERROR_ROUTINE)sec2_test_des_callback; 
    cryptReq->ctxNotifyOnErr.request = ctx;
    cryptReq->status  = 0;
    cryptReq->nextReq = NULL;                    /*the next req will be NULL*/

    cryptReq->inIvBytes  = (unsigned long)cbc->ivlen;
    cryptReq->inIvData   = (unsigned char*)cbc->iv;
    cryptReq->keyBytes   = (unsigned long)cbc->keyLen;
    cryptReq->keyData    = (unsigned char*)cbc->key;
    cryptReq->inBytes    = (unsigned long)cbc->inLen;
    cryptReq->inData     = (unsigned char*)cbc->inData;  /* 输入数据内存不需要再分配*/
    cryptReq->outIvBytes = (unsigned long)cbc->ivlen;
    cryptReq->outIvData  = drv_ipsec_iv_out;
    cryptReq->outData    = (unsigned char*)cbc->outData;
    
    /**************** 下发硬件处理 ****************/
    ipsec_status = SEC2_ioctl(IOCTL_PROC_REQ, cryptReq); 
    if (SEC2_SUCCESS != ipsec_status)
    {
       DRV_IPSEC_DBG("drv_sec2_des_crypt: Ioctl failed!\n");
       drv_sec2_free_context(ctx);
     }

    return ipsec_status;
}

int sec2_test_des_decrypt(algo_msg_crypt_t *cbc)
{
    DRV_SEC2_CONTEXT  *ctx = (DRV_SEC2_CONTEXT *)NULL;  /* 上下文结构 */ 
    DES_LOADCTX_CRYPT_REQ *cryptReq = (DES_LOADCTX_CRYPT_REQ *)NULL; /* 描述符 请求结构 */ 
    int     ipsec_status = SEC2_ERROR;
    
    
    ctx = (DRV_SEC2_CONTEXT*)SEC2_GETBUF(sizeof(DRV_SEC2_CONTEXT));
    if (NULL == ctx)
    {
        DRV_IPSEC_DBG("drv_sec2_des_crypt:  malloc DRV_SEC2_CONTEXT failed!\n");
        return SEC2_ERROR;
    }
        
    /**************** 分配描述符内存 ****************/
    
    ctx->dpdReqMem= (UINT8*)SEC2_GETBUF(sizeof(DES_LOADCTX_CRYPT_REQ));
    if (NULL == ctx->dpdReqMem)
    {
        DRV_IPSEC_DBG("drv_sec2_des_crypt:  malloc ctx->dpdReqMem failed!\n");
        drv_sec2_free_context(ctx);
        return SEC2_ERROR;
    }
    
    cryptReq = (DES_LOADCTX_CRYPT_REQ*) (ctx->dpdReqMem);

    /**************** 描述符填充: DES_LOADCTX_CRYPT_REQ  ****************/
    cryptReq->opId    = DPD_SDES_CBC_CTX_DECRYPT;
    cryptReq->channel = 0;                       /*动态处理*/
    cryptReq->notify  = (PSEC_NOTIFY_ROUTINE)drv_sec2_free_context;       
    cryptReq->pNotifyCtx = ctx;
    cryptReq->notify_on_error = (PSEC_NOTIFY_ON_ERROR_ROUTINE)drv_sec2_free_context; 
    cryptReq->ctxNotifyOnErr.request = ctx;
    cryptReq->status  = 0;
    cryptReq->nextReq = NULL;                    /*the next req will be NULL*/

    cryptReq->inIvBytes  = (unsigned long)cbc->ivlen;
    cryptReq->inIvData   = (unsigned char*)cbc->iv;
    cryptReq->keyBytes   = (unsigned long)cbc->keyLen;
    cryptReq->keyData    = (unsigned char*)cbc->key;
    cryptReq->inBytes    = (unsigned long)cbc->inLen;
    cryptReq->inData     = (unsigned char*)cbc->outData;  /* 输入数据内存不需要再分配*/
    cryptReq->outIvBytes = (unsigned long)cbc->ivlen;
    cryptReq->outIvData  = drv_ipsec_iv_out;
    cryptReq->outData    = ipsec_onlytest;
    
    /**************** 下发硬件处理 ****************/
    ipsec_status = SEC2_ioctl(IOCTL_PROC_REQ, cryptReq); 
    if (SEC2_SUCCESS != ipsec_status)
    {
       DRV_IPSEC_DBG("drv_sec2_des_crypt: Ioctl failed!\n");
       drv_sec2_free_context(ctx);
       return SEC2_ERROR;
     }

    taskDelay(1);

    if(memcmp(ipsec_onlytest,cbc->inData,128) == 0)
    {
        diag_sec2->sec2_des_dec_succ_cnt++;
    }
    else
    {
        return SEC2_ERROR;
    }    
    
    return SEC2_SUCCESS;
}

int sec2_diag_des(algo_msg_crypt_t *cbc)
{
    UINT8 pt3[8] = "01234567"; 
    
    cbc->inLen = 128;                                                      /*输入数据长度*/
    cbc->inData = (UINT8*)malloc(cbc->inLen);                                 /*分配输入内存*/
    if (cbc->inData == NULL)
    {
        printf("sec2_test_des: failed to malloc inData!\n");
        free(cbc);
        return SEC2_ERROR;
    }
    memset(cbc->inData, 0x67, cbc->inLen);                    /*输入数据,128 位*/
    
    cbc->keyLen = 8;                                                        /*输入密钥长度*/
    cbc->key = (UINT8*)malloc(cbc->keyLen);                /*分配内存空间*/
    if (cbc->key == NULL)
    {
        printf("sec2_test_des: failed to malloc key!\n");
        free(cbc->inData);
        free(cbc);
        return SEC2_ERROR;
    }
    memcpy(cbc->key, pt3, cbc->keyLen);                      /*输入密钥*/

    cbc->ivlen = 8;                                                           /*初始化向量长度*/
    cbc->iv = (UINT8*)malloc(cbc->ivlen);
    if (cbc->iv == NULL)
    {
        printf("sec2_test_des: failed to malloc iv!\n");
        free(cbc->inData);
        free(cbc->key);
        free(cbc);
        return SEC2_ERROR;
    }
    memcpy(cbc->iv, pt3, cbc->ivlen);                             /*初始化向量赋值*/

    cbc->outLen = 128;
    cbc->outData = (UINT8*)malloc(cbc->outLen);                    /*分配输出内存*/
    if (cbc->outData == NULL)                                     /*如果分配失败则释放*/
    {
        printf("sec2_test_des: failed to malloc outData!\n");
        free(cbc->inData);
        free(cbc->key);
        free(cbc->iv);
        free(cbc);
        return SEC2_ERROR;
    }
    memset(cbc->outData, 0, 128);

    return SEC2_SUCCESS;
}


int sec2_diag_des_ctrl(void)
{
    algo_msg_crypt_t *cbc;
    int test_cnt;
    
    for(test_cnt = 0;test_cnt < 10;test_cnt++)
    {
        cbc = (algo_msg_crypt_t*)malloc(sizeof(algo_msg_crypt_t));
        if(NULL == cbc)
        {
             return SEC2_ERROR;
        }
        
        sec2_diag_des(cbc);

        if(SEC2_SUCCESS == sec2_test_des_encrypt(cbc))
        {
           diag_sec2->sec2_des_enc_succ_cnt++;
        }
        else
        {
            if(NULL != cbc->outData)
            {
                free(cbc->outData);
            }
            if(NULL != cbc->inData)
            {
                free(cbc->inData);
            }
            if(NULL != cbc->key)
            {
                free(cbc->key);
            }
            if(NULL != cbc->iv)
            {
                free(cbc->iv);
            }
            if(NULL != cbc)
            {
                free(cbc);
            }
        }
        taskDelay(1);
    }

    return SEC2_SUCCESS;
    
}


int sec2_test_3des_encrypt(algo_msg_crypt_t *cbc)
{
    DRV_SEC2_CONTEXT  *ctx = (DRV_SEC2_CONTEXT *)NULL;
    DES_LOADCTX_CRYPT_REQ *cryptReq = (DES_LOADCTX_CRYPT_REQ *)NULL; 
    int     ipsec_status = SEC2_ERROR;
    
    
    ctx = (DRV_SEC2_CONTEXT*)SEC2_GETBUF(sizeof(DRV_SEC2_CONTEXT));
    if (NULL == ctx)
    {