mcu/driver/devdrv/soe/src/drv_soe.c

/*****************************************************************************
*  Copyright Statement:
*  --------------------
*  This software is protected by Copyright and the information contained
*  herein is confidential. The software may not be copied and the information
*  contained herein may not be used or disclosed except with the written
*  permission of MediaTek Inc. (C) 2013
*
*  BY OPENING THIS FILE, BUYER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
*  THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
*  RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO BUYER ON
*  AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES,
*  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
*  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT.
*  NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE
*  SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR
*  SUPPLIED WITH THE MEDIATEK SOFTWARE, AND BUYER AGREES TO LOOK ONLY TO SUCH
*  THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. MEDIATEK SHALL ALSO
*  NOT BE RESPONSIBLE FOR ANY MEDIATEK SOFTWARE RELEASES MADE TO BUYER'S
*  SPECIFICATION OR TO CONFORM TO A PARTICULAR STANDARD OR OPEN FORUM.
*
*  BUYER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND CUMULATIVE
*  LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE RELEASED HEREUNDER WILL BE,
*  AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE MEDIATEK SOFTWARE AT ISSUE,
*  OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY BUYER TO
*  MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE.
*
*  THE TRANSACTION CONTEMPLATED HEREUNDER SHALL BE CONSTRUED IN ACCORDANCE
*  WITH THE LAWS OF THE STATE OF CALIFORNIA, USA, EXCLUDING ITS CONFLICT OF
*  LAWS PRINCIPLES.  ANY DISPUTES, CONTROVERSIES OR CLAIMS ARISING THEREOF AND
*  RELATED THERETO SHALL BE SETTLED BY ARBITRATION IN SAN FRANCISCO, CA, UNDER
*  THE RULES OF THE INTERNATIONAL CHAMBER OF COMMERCE (ICC).
*
*****************************************************************************/
/*****************************************************************************
 *
 * Filename:
 * ---------
 *  drv_soe.c
 *
 * Description:
 * ------------
 *   SOE Driver
 *
 * Author:
 * -------
 * -------
 *
 *============================================================================
 *             HISTORY
 * Below this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
 *------------------------------------------------------------------------------
 * removed!
 * removed!
 * removed!
 *
 * removed!
 * removed!
 *
 * removed!
 * removed!
 *
 * removed!
 * removed!
 *
 * removed!
 * removed!
 *
 * removed!
 * removed!
 * removed!
 *
 * removed!
 * removed!
 * removed!
 *
 * removed!
 * removed!
 *
 * removed!
 * removed!
 *
 * removed!
 * removed!
 *
 * removed!
 * removed!
 *
 *
 *------------------------------------------------------------------------------
 * Upper this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
 *============================================================================
 *****************************************************************************/


/*******************************************************************************
 * Include header files
 *******************************************************************************/
#include "kal_general_types.h"
#include "sleepdrv_interface.h"
#include "drvpdn.h"
#include "ex_public.h"

#include "drv_soe_reg.h"
#include "drv_soe_key.h"
#include "drv_soe_bm.h"
#include "drv_soe_engine.h"

#ifdef SOE_CHB_MODE
  #define SOE_GPD_CHK SOE_CHK_32
#else
  #define SOE_GPD_CHK SOE_CHK_28
#endif
#define SOE_BD_CHK SOE_CHK_16

#if 0 //defined(ATEST_ENABLE)
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
#else
#define DRV_MSG(level, fmt...)
#endif

#if defined(ATEST_ENABLE)
kal_uint32 drv_soe_dbg_frc[5];
kal_uint32 drv_soe_frc_start[5], drv_soe_frc_end[5];
extern kal_uint32 drv_sm_getCurFRC(void);

#define DRV_DBG_FRC_INIT(t)  drv_soe_dbg_frc[t]=0
#define DRV_DBG_FRC_START(t) do{  drv_soe_frc_start[t] = drv_sm_getCurFRC(); \
                               }while(0)

#define DRV_DBG_FRC_END(t) do{  drv_soe_frc_end[t] = drv_sm_getCurFRC(); \
                                drv_soe_dbg_frc[t] += (drv_soe_frc_end[t] - drv_soe_frc_start[t]); \
                               }while(0)
#else
#define DRV_DBG_FRC_INIT(t)
#define DRV_DBG_FRC_START(t)
#define DRV_DBG_FRC_END(t)
#endif

//#define DRV_DISABLE_IRQ

/*******************************************************************************
 * global variable definitions
 *******************************************************************************/
static kal_bool drv_inited = KAL_FALSE;
static kal_enhmutexid drv_soe_locker;
static kal_eventgrpid  drv_soe_egid;
#ifdef ATEST_ENABLE
static void (*drv_soe_lisr_handler_cb)(kal_uint32 vector) = NULL;
#endif

kal_bool drv_soe_irq_en = KAL_TRUE;

/*******************************************************************************
 * SOE register dump
 *******************************************************************************/
EX_BBREG_DUMP soe_reg_dump;
const kal_uint32 soe_reg_dump_regions[] = {
	SOE_BASE,        0xC0, 4,
	SOE_BASE+0x200,  0xB0, 4,
	SOE_BASE+0x8000, 0x10, 4,
};

static void drv_soe_register_bbreg_dump(void)
{
    soe_reg_dump.regions = (kal_uint32*)soe_reg_dump_regions;
    soe_reg_dump.num = sizeof(soe_reg_dump_regions) / (sizeof(kal_uint32) * 3);
    soe_reg_dump.bbreg_dump_callback = NULL;
    EX_REGISTER_BBREG_DUMP(&soe_reg_dump);
}
 
/*******************************************************************************
 * Function definitions
 *******************************************************************************/
static kal_uint8 drv_soe_calc_chksum(kal_uint8 *data, kal_uint16 len)
{
    kal_uint8 *uDataPtr, ckSum;
    kal_uint16 i;

    *(data + 1) = 0x0;
    uDataPtr = data;
    ckSum = 0;
    for (i = 0; i < len; i++)
        ckSum += *(uDataPtr + i);
    return 0xFF - ckSum;
}

static void drv_soe_set_reg(kal_uint32 reg, kal_uint32 mask, kal_uint32 val, kal_uint32 offset)
{
    kal_uint32 tmp;
    tmp = SOE_REG(reg);
    tmp &= (~mask);
    tmp |= (val << offset);
    SOE_REG(SOE_CR) = tmp;
}

void drv_soe_lisr(kal_uint32 irq_id)
{
    kal_uint32 intr_status;

#ifdef ATEST_ENABLE
    if(drv_soe_lisr_handler_cb != NULL) {
        drv_soe_lisr_handler_cb(irq_id);
        return;
    }
#endif
    intr_status = SOE_REG(SOE_L2ISAR);
    SOE_REG(SOE_L2ISAR) = intr_status;
#if defined(MT6297)
    intr_status |= (SOE_REG(SOE_ASYM_STATUS_REG7) << 8);
#endif
    Data_Sync_Barrier();
    IRQClearInt(SOE_IRQ);
    Data_Sync_Barrier();

    kal_set_eg_events(drv_soe_egid, intr_status, KAL_OR);
}

#ifdef ATEST_ENABLE
void drv_soe_reg_interrupt(void (*handler)(kal_uint32 vector))
{
    drv_soe_lisr_handler_cb = handler;
}
#endif

void drv_soe_init(void)
{
    if(drv_inited) {
        return;
    }

    drv_soe_locker = kal_create_enh_mutex("SOEMtx");
    if(!drv_soe_locker) ASSERT(0);

    drv_soe_egid = kal_create_event_group("SOEEvt");
    if(!drv_soe_egid) ASSERT(0);

    //move to interface/service/config/kal_config/xxx_isr_config.h
    //IRQ_Register_LISR(SOE_IRQ, drv_soe_lisr, "SOE handler");
    //IRQSensitivity(SOE_IRQ, KAL_TRUE);
    IRQClearInt(SOE_IRQ);
    IRQUnmask(SOE_IRQ);
    
    drv_inited = KAL_TRUE;
    DRV_DBG_FRC_INIT(0);
    DRV_DBG_FRC_INIT(1);
	drv_soe_register_bbreg_dump();
}

static kal_uint32 drv_soe_gen_key_attr(drv_soe_key_attr_t *key_attr, sec_key_t *key_table)
{
#ifdef SOE_CHB_MODE
    kal_uint32 kindex2;
#endif
    kal_uint32 i, kindex = 0;
    kal_bool extKey = KAL_TRUE;

    //Get valid key index
    for(i=0; i < SOE_DRV_KEY_ENTRY_MAX; i++) {
        if(!SECK_GET_VALID(key_table[i])) {
            kindex = i;
#ifdef SOE_CHB_MODE
            kindex2 = (i + 1);
#endif
            break;
        }
    }
    if(i == (SOE_KEY_ENTRY_MAX + 1)) {
        return 1;
    }

    if (key_attr->mode == SECK_CHB) {
        key_attr->en = SECK_DEC;
    }

    if((kal_uint32)key_attr->key >= (kal_uint32)key_table && 
        (kal_uint32)key_attr->key < ((kal_uint32)key_table + sizeof(sec_key_t))) {
        extKey = KAL_FALSE;
    }
    else {
        memset(&key_table[kindex], 0, sizeof(sec_key_t));
    }
    SECK_SET_VALID(key_table[kindex]);
    key_attr->idx = (kindex + 1);

    if (key_attr->en == SECK_ENC) {
        SECK_SET_ENC(key_table[kindex]);
    }
    else {
        SECK_SET_DEC(key_table[kindex]);
    }
    
    if (key_attr->mode == SECK_CHB) {
        SECK_SET_MODE(key_table[kindex], SECK_AES);
    }
    else {
        SECK_SET_MODE(key_table[kindex], key_attr->mode);
    }
    SECK_SET_OPT(key_table[kindex], key_attr->opt);
    SECK_SET_ALG(key_table[kindex], key_attr->alg);

    if (key_attr->mode == SECK_DES && key_attr->opt == SECK_OPT_3DES) {
        SECK_SET_3DES(key_table[kindex], key_attr->desmode);
    }
#if defined(SOE_MD97_HW)
    if (key_attr->mode == SECK_RC5) {
        rc5_para_t rc5_para;
        rc5_para.pack.keylen = key_attr->var_key.rc5_len;
        rc5_para.pack.block = key_attr->ops_para.rc5_attr.word_size / SECK_RC5_WORD_SIZE_BIT_INC;
        rc5_para.pack.round = key_attr->ops_para.rc5_attr.rounds / SECK_RC5_ROUND_INC ;
        SECK_SET_RC5_ATTR(key_table[kindex], rc5_para.p);
    }

    if (key_attr->mode == SECK_IDEA && key_attr->opt == SECK_OPT_3IDEA) {
        SECK_SET_3IDEA(key_table[kindex], key_attr->ideamode);
    }

    if (key_attr->mode == SECK_CAST5 || key_attr->mode == SECK_CAST6 || key_attr->mode == SECK_BLOWFISH) {
        SECK_SET_VAR_KEYLEN(key_table[kindex], key_attr->keylen);
    }
    if ((key_attr->mode == SECK_HASH || key_attr->mode == SECK_HMAC) && (key_attr->alg == SECK_ALG_TIGER))
    {
        tiger_para_t tiger_para;
        tiger_para.pack.bits = key_attr->ops_para.tiger_attr.bits;
        tiger_para.pack.rounds = key_attr->ops_para.tiger_attr.rounds;
        SECK_SET_TIGER_ATTR(key_table[kindex], tiger_para.p);
    }
#endif
    /*MSG(MSG_INFO, "%s mod = %d\r\n", __FUNCTION__, attr->mode);*/

    if (key_attr->key && extKey) {
        SECK_SET_KEY(key_table[kindex], key_attr->key, key_attr->keylen);
    }
    SOE_CACHE_STORE(&key_table[kindex], sizeof(sec_key_t));
#ifdef SOE_CHB_MODE
    if (key_attr->mode == SECK_CHB) {
        if(extKey) {
            memset(&key_table[kindex2], 0, sizeof(sec_key_t));
        }
        SECK_SET_VALID(key_table[kindex2]);
        key_attr->idx2 = (kindex2 + 1);

        if (key_attr->en == SECK_ENC) {
            SECK_SET_ENC(key_table[kindex2]);
        }
        else {
            SECK_SET_DEC(key_table[kindex2]);
        }

        SECK_SET_MODE(key_table[kindex2], SECK_HMAC);
        SECK_SET_OPT(key_table[kindex2], key_attr->opt2);
        SECK_SET_ALG(key_table[kindex2], key_attr->alg2);

        if (key_attr->key2 && extKey) {
            SECK_SET_KEY(key_table[kindex2], key_attr->key2, key_attr->keylen2);
        }
        SOE_CACHE_STORE(&key_table[kindex2], sizeof(sec_key_t));
    }
#endif
    return 0;
}

static kal_uint32 drv_soe_list_init(drv_soe_list_attr_t *attr)
{
    kal_uint16 i, type;
    gpd_t *gpd_now = NULL, *gpd_new;
    bd_t *bd_now = NULL, *bd_new;
    drv_soe_gpd_attr_t *gpd_attr;
    drv_soe_key_attr_t *key_attr;
    kal_uint32 len;
    kal_uint8 *buf;

    for (i = 0; i < attr->gpdnum; i++) {
        /* reset variable */
        gpd_attr = &attr->gpd[i];
        key_attr = &attr->key[i];
        bd_now = NULL;
        gpd_new = gpd_attr->gpd;      
        if (gpd_now != NULL) {
            SOE_SET_NEXT(gpd_now, virt_to_phys(gpd_new));
            SOE_SET_CHKSUM(gpd_now, SOE_GPD_CHK);
        }
        memset(gpd_new, 0, GPD_SIZE);
        SOE_SET_FLAGS_HWO(gpd_new);
        if (gpd_attr->bd == NULL) {
            SOE_CLR_FLAGS_BDP(gpd_new);
        } else {
            SOE_SET_FLAGS_BDP(gpd_new);
        }
        SOE_CLR_FORMAT_VR(gpd_new);

        if(!SOE_IS_DYNA_DRAM((kal_uint32)gpd_attr->outbuf, gpd_attr->outlen)) {
            return DRV_SOE_ERR_INVALID_PTR;
        }
        if(query_is_cached_ram((kal_uint32)gpd_attr->outbuf, gpd_attr->outlen)) {
            SOE_CACHE_STORE(gpd_attr->outbuf, gpd_attr->outlen);
            SOE_CACHE_INVALIDATE(gpd_attr->outbuf, gpd_attr->outlen);
            gpd_attr->outbuf = (kal_uint8*)virt_to_phys(gpd_attr->outbuf);
        }
        SOE_SET_BUF_LEN(gpd_new, gpd_attr->buflen);
        SOE_SET_OUTPTR(gpd_new, gpd_attr->outbuf);

        if(gpd_attr->icblen) {
            if(!SOE_IS_DYNA_DRAM((kal_uint32)gpd_attr->icb, gpd_attr->icblen)) {
                return DRV_SOE_ERR_INVALID_PTR;
            }
            if(query_is_cached_ram((kal_uint32)gpd_attr->icb, gpd_attr->icblen)) {
                SOE_CACHE_STORE(gpd_attr->icb, gpd_attr->icblen);
                gpd_attr->icb = (kal_uint8*)virt_to_phys(gpd_attr->icb);
            }
            SOE_SET_ICBPTR(gpd_new, gpd_attr->icb);
            if(key_attr->alg == SECK_ALG_CBC) {
#if defined(SOE_MD97_HW) && !defined(MT6297)
                SOE_SET_FORMAT_UI(gpd_new);
#else
                /* Apollo is not ready for using UI with new algorithms */
                do {
                if(key_attr->mode == SECK_DES || key_attr->mode == SECK_AES)
                    SOE_SET_FORMAT_UI(gpd_new);        
                }while(0);
#endif
            }
        }
        else {
            SOE_SET_ICBPTR(gpd_new, gpd_attr->outbuf); //dummy ptr
        }
        
        if(gpd_attr->icvlen) {
            if(!SOE_IS_DYNA_DRAM((kal_uint32)gpd_attr->icv, gpd_attr->icvlen)) {
                return DRV_SOE_ERR_INVALID_PTR;
            }
            if(query_is_cached_ram((kal_uint32)gpd_attr->icv, gpd_attr->icvlen)) {
                SOE_CACHE_STORE(gpd_attr->icv, gpd_attr->icvlen);
                SOE_CACHE_INVALIDATE(gpd_attr->icv, gpd_attr->icvlen);
                gpd_attr->icv = (kal_uint8*)virt_to_phys(gpd_attr->icv);
            }
            SOE_SET_ICVPTR(gpd_new, gpd_attr->icv);
        }
        else {
            SOE_SET_ICVPTR(gpd_new, gpd_attr->outbuf); //dummy ptr
        }
        SOE_SET_KEY_IDX(gpd_new, gpd_attr->keyidx);
#ifdef SOE_CHB_MODE
        SOE_SET_KEY_IDX2(gpd_new, gpd_attr->keyidx2);
        SOE_SET_CIPHER_OFFSET(gpd_new, gpd_attr->cipher_offset);
        if (key_attr->mode == SECK_CHB) {
            SOE_SET_FORMAT_CHB(gpd_new);
        }
        else {
            SOE_CLR_FORMAT_CHB(gpd_new);
        }
#endif

        if (gpd_attr->bd == NULL) {
            /* No BD, set data ptr */
            if(!SOE_IS_DYNA_DRAM((kal_uint32)gpd_attr->inbuf, gpd_attr->inlen)) {
                return DRV_SOE_ERR_INVALID_PTR;
            }
            if(query_is_cached_ram((kal_uint32)gpd_attr->inbuf, gpd_attr->inlen)) {
                SOE_CACHE_STORE(gpd_attr->inbuf, gpd_attr->inlen);
                gpd_attr->inbuf = (kal_uint8*)virt_to_phys(gpd_attr->inbuf);
            }            
            SOE_SET_DATA(gpd_new, gpd_attr->inbuf);
        } else {
            /* Generate BDs */
            for (type = 0; type < 2; type++) {
                if(key_attr->alg == SECK_ALG_XCBC) {
                    // XCBC
                    buf = type ? gpd_attr->inbuf : gpd_attr->icb;
                    len = type ? gpd_attr->inlen : gpd_attr->icblen;
                }
                else {
                    // CCM/GCM
                    buf = type ? gpd_attr->inbuf : gpd_attr->abuf;
                    len = type ? gpd_attr->inlen : gpd_attr->alen;
                }
                
                if(!SOE_IS_DYNA_DRAM((kal_uint32)buf, len)) {
                    return DRV_SOE_ERR_INVALID_PTR;
                }
                if(query_is_cached_ram((kal_uint32)buf, len)) {
                    SOE_CACHE_STORE(buf, len);
                    buf = (kal_uint8*)virt_to_phys(buf);
                }
                bd_new = &gpd_attr->bd[type];

                /* set data ptr */
                memset(bd_new, 0, BD_SIZE);
                BD_SET_DATA(bd_new, buf);
                BD_SET_BUF_LEN(bd_new, len);
                /* set list */
                if (bd_now == NULL) {
                    SOE_SET_BD(gpd_new, virt_to_phys(bd_new));
                } else {
                    if(!len)
                        BD_SET_FLAGS_EOL(bd_now);
                    BD_SET_NEXT(bd_now, virt_to_phys(bd_new));
                    BD_SET_CHKSUM(bd_now, SOE_BD_CHK);
                    SOE_CACHE_STORE(bd_now, BD_SIZE);
                }
                if (type == 1) { /* last BD */
                    BD_SET_FLAGS_EOL(bd_new);
                }
                bd_now = bd_new;
            }
            BD_SET_CHKSUM(bd_now, SOE_BD_CHK);
            SOE_CACHE_STORE(bd_now, BD_SIZE);            
        }
        SOE_SET_CHKSUM(gpd_new, SOE_GPD_CHK);
        SOE_CACHE_STORE(gpd_new, GPD_SIZE);
        gpd_now = gpd_new;
    }
    /* link last GPD */
    gpd_new = (gpd_t *)&gpd_now[1];
    SOE_SET_NEXT(gpd_now, virt_to_phys(gpd_new));
    SOE_SET_FLAGS_INT(gpd_now);
    SOE_SET_CHKSUM(gpd_now, SOE_GPD_CHK);
    SOE_CACHE_STORE(gpd_now, GPD_SIZE);
    memset(gpd_new, 0, GPD_SIZE);
    SOE_CACHE_STORE(gpd_new, GPD_SIZE);
    return 0;
}

static kal_uint32 drv_soe_gen_gpd_attr(drv_soe_gpd_attr_t *attr, drv_soe_key_attr_t *key)
{
    kal_uint32 err = 0;

    // check keylen and datalen
    switch(key->mode) {
        case SECK_NULL:
            err = 0;
            break;
        case SECK_HMAC:
            switch(key->alg) {
                case SECK_ALG_MD5:
                case SECK_ALG_SHA1:
                case SECK_ALG_SHA256:
#if defined(SOE_MD97_HW)				
                case SECK_ALG_TIGER:
#endif
                    if(key->keylen != 64) err = DRV_SOE_ERR_KEYLEN;
                    break;
                case SECK_ALG_SHA384:
                case SECK_ALG_SHA512:
                    if(key->keylen != 128) err = DRV_SOE_ERR_KEYLEN;
                    break;
                default:
                    err = DRV_SOE_ERR_ALG;
                    break;
            }            
            //following check as HASH
        case SECK_HASH:
            if(attr->inlen > 65535) err = DRV_SOE_ERR_INLEN;
#if defined(SOE_MD97_HW)
            if(key->alg > SECK_ALG_TIGER) err = DRV_SOE_ERR_ALG;
#else
            if(key->alg > SECK_ALG_SHA512) err = DRV_SOE_ERR_ALG;
#endif
            switch(key->alg) {
                case SECK_ALG_MD5:
                    if(attr->outlen != 16) err = DRV_SOE_ERR_OUTLEN;
                    break;
                case SECK_ALG_SHA1:
                    if(attr->outlen != 20) err = DRV_SOE_ERR_OUTLEN;
                    break;
                case SECK_ALG_SHA256:
                    if(attr->outlen != 32) err = DRV_SOE_ERR_OUTLEN;
                    break;
                case SECK_ALG_SHA384:
                    if(attr->outlen != 48) err = DRV_SOE_ERR_OUTLEN;
                    break;
                case SECK_ALG_SHA512:
                    if(attr->outlen != 64) err = DRV_SOE_ERR_OUTLEN;
                    break;
#if defined(SOE_MD97_HW)
                case SECK_ALG_TIGER:
                    if(attr->outlen != 16 && attr->outlen != 24 && attr->outlen != 32) err = DRV_SOE_ERR_OUTLEN;
                    break;
#endif
                default:
                    err = DRV_SOE_ERR_ALG;
                    break;
            }
            break;
        case SECK_DES:
            if(key->opt > SECK_OPT_3DES) err = DRV_SOE_ERR_OPT;
            if(key->alg > SECK_ALG_CBC) err = DRV_SOE_ERR_ALG;
            if(!(attr->inlen == 8 || (attr->inlen >= 16 && attr->inlen <= 65528))) err = DRV_SOE_ERR_INLEN;
            if(attr->inlen != attr->outlen) err = DRV_SOE_ERR_OUTLEN;
            if(key->opt == SECK_OPT_DES && key->keylen != 8) err = DRV_SOE_ERR_KEYLEN;
            if(key->opt == SECK_OPT_3DES && key->keylen != 24) err = DRV_SOE_ERR_KEYLEN;
            if(key->alg == SECK_ALG_CBC && attr->icblen != 8) err = DRV_SOE_ERR_ICBLEN;
            break;
        case SECK_AES:
            if(key->alg != SECK_ALG_XCBC && key->alg != SECK_ALG_CMAC) {
                if(key->opt > SECK_AES_256) err = DRV_SOE_ERR_OPT;
                if(attr->inlen != attr->outlen) err = DRV_SOE_ERR_OUTLEN;
            }
            else {
                if(key->opt > SECK_AES_128) err = DRV_SOE_ERR_OPT;
                if(attr->inlen > 65535) err = DRV_SOE_ERR_INLEN;
                if(key->en == SECK_DEC && attr->icvlen != 16) err = DRV_SOE_ERR_ICVLEN;
            }
            switch(key->alg) {
                case SECK_ALG_CBC:
                    if(attr->icblen != 16) err = DRV_SOE_ERR_ICBLEN;
                    //following check as ECB
                case SECK_ALG_ECB:
                    if(!(attr->inlen == 16 || (attr->inlen >= 32 && attr->inlen <= 65520))) err = DRV_SOE_ERR_INLEN;
                    break;
                case SECK_ALG_CTR:
                    if(attr->inlen == 0 || attr->inlen > 65535) {
                        err = DRV_SOE_ERR_INLEN;
                    }
                    if(attr->icblen != 16) err = DRV_SOE_ERR_ICBLEN;
                    break;
                case SECK_ALG_CCM:
                case SECK_ALG_GCM:
                    //check in next stage
                default:
                    break;
            }            
            break;
#if defined(SOE_MD97_HW)			
        case SECK_RC5:
            if(key->opt != 0) err = DRV_SOE_ERR_OPT;
            if(key->alg > SECK_ALG_CBC) err = DRV_SOE_ERR_ALG;
            if(!(attr->inlen == 8 || (attr->inlen >= 16 && attr->inlen <= 65528))) err = DRV_SOE_ERR_INLEN;
            if(attr->inlen != attr->outlen) err = DRV_SOE_ERR_OUTLEN;
            if(key->alg == SECK_ALG_CBC && (attr->icblen != 4 && attr->icblen != 8 && attr->icblen != 16)) err = DRV_SOE_ERR_ICBLEN;
            if(key->keylen == 0 /*|| key->keylen > 255 */) err = DRV_SOE_ERR_KEYLEN;
            break;
        case SECK_IDEA:
            if(key->opt > SECK_OPT_3IDEA) err = DRV_SOE_ERR_OPT;
            if(key->alg > SECK_ALG_CBC) err = DRV_SOE_ERR_ALG;
            if(!(attr->inlen == 8 || (attr->inlen >= 16 && attr->inlen <= 65528))) err = DRV_SOE_ERR_INLEN;
            if(attr->inlen != attr->outlen) err = DRV_SOE_ERR_OUTLEN;
            if(key->opt == SECK_OPT_IDEA && key->keylen != 16) err = DRV_SOE_ERR_KEYLEN;
            if(key->opt == SECK_OPT_3IDEA && key->keylen != 48) err = DRV_SOE_ERR_KEYLEN;
            if(key->alg == SECK_ALG_CBC && attr->icblen != 8) err = DRV_SOE_ERR_ICBLEN;
            break;
        case SECK_CAST5:
            if(key->opt != 0) err = DRV_SOE_ERR_OPT;
            if(key->alg > SECK_ALG_CBC) err = DRV_SOE_ERR_ALG;
            if(!(attr->inlen == 8 || (attr->inlen >= 16 && attr->inlen <= 65528))) err = DRV_SOE_ERR_INLEN;
            if(attr->inlen != attr->outlen) err = DRV_SOE_ERR_OUTLEN;
            if(key->alg == SECK_ALG_CBC && attr->icblen != 8) err = DRV_SOE_ERR_ICBLEN;
            if(key->keylen < 5 || key->keylen > 16) err = DRV_SOE_ERR_KEYLEN;
            break;
        case SECK_CAST6:
            if(key->opt != 0) err = DRV_SOE_ERR_OPT;
            if(key->alg > SECK_ALG_CBC) err = DRV_SOE_ERR_ALG;
            if(!(attr->inlen == 16 || (attr->inlen >= 32 && attr->inlen <= 65520))) err = DRV_SOE_ERR_INLEN;
            if(attr->inlen != attr->outlen) err = DRV_SOE_ERR_OUTLEN;
            if(key->alg == SECK_ALG_CBC && attr->icblen != 16) err = DRV_SOE_ERR_ICBLEN;
            if(key->keylen < 16 || key->keylen > 32 || (key->keylen & 3) != 0) err = DRV_SOE_ERR_KEYLEN;
            break;
        case SECK_BLOWFISH:
            if(key->opt != 0) err = DRV_SOE_ERR_OPT;
            if(key->alg > SECK_ALG_CBC) err = DRV_SOE_ERR_ALG;
            if(!(attr->inlen == 8 || (attr->inlen >= 16 && attr->inlen <= 65528))) err = DRV_SOE_ERR_INLEN;
            if(attr->inlen != attr->outlen) err = DRV_SOE_ERR_OUTLEN;
            if(key->alg == SECK_ALG_CBC && attr->icblen != 8) err = DRV_SOE_ERR_ICBLEN;
            if(key->keylen < 4 || key->keylen > 56) err = DRV_SOE_ERR_KEYLEN;
            break;
        case SECK_CHB:
            if (key->opt != SECK_AES_128) err = DRV_SOE_ERR_OPT;
            if (key->alg != SECK_ALG_CBC) err = DRV_SOE_ERR_ALG;
            if (key->alg2 > SECK_ALG_SHA256) err = 3;
            break;
        case SECK_RSADH:
            if (key->opt != 0) err = DRV_SOE_ERR_OPT;
            if (key->alg > SECK_ALG_MODEXP) err = DRV_SOE_ERR_ALG;
            break;
        case SECK_ECC:
            if (key->opt != 0) err = DRV_SOE_ERR_OPT;
            if (key->alg > SECK_ALG_PADD) err = DRV_SOE_ERR_ALG;
            break;
#endif			
        default:
            err = DRV_SOE_ERR_MODE;
    }

    //check CHB mode
    if (key->mode != SECK_CHB) {
        if ((key->mode == SECK_AES) && (key->alg == SECK_ALG_CCM || key->alg == SECK_ALG_GCM)) {
            attr->buflen = attr->inlen;
            if((attr->inlen + attr->alen) > 65535) {
                err = DRV_SOE_ERR_CHBLEN;
            }
        }
        else {
            attr->alen = 0;
        }
    }
    else {
        attr->alen = 0;
    }
    if(err) {
        DRV_MSG(MSG_INFO, "%s err: %x\r\n", __FUNCTION__, err);
        return err;
    }
    
    //assign keyidx
    attr->keyidx = key->idx;
    if (key->mode == SECK_CHB) {
        attr->keyidx2 = key->idx2;
    }
    DRV_MSG(MSG_INFO, "%s keyidx:%d keyidx2:%d\r\n", __FUNCTION__, attr->keyidx, attr->keyidx2);
    
    return 0;
}

kal_uint32 drv_soe_gen_attr(drv_soe_ctrl_struct_t *ctrl)
{
    drv_soe_list_attr_t *attr = &ctrl->list_attr;
    kal_uint32 i, idx, ret;

    DRV_DBG_FRC_START(0);

    // check ptr
    if(ctrl->gpd == NULL || ctrl->key == NULL) {
        return DRV_SOE_ERR_INVALID_PTR;
    }
    if(!SOE_IS_DYNA_DRAM((kal_uint32)ctrl->gpd, sizeof(gpd_t))) {
        return DRV_SOE_ERR_INVALID_PTR;
    }
    if(!SOE_IS_DYNA_DRAM((kal_uint32)ctrl->key, sizeof(sec_key_t))) {
        return DRV_SOE_ERR_INVALID_PTR;
    }

    // set key table
    for(i = 0, idx = 0; i < attr->gpdnum; i++) {
        if(idx == (SOE_DRV_GPD_MAX + 1)) {
            return DRV_SOE_ERR_GPD_OVERFLOW;
        }
        
        ret = drv_soe_gen_key_attr(&attr->key[i], ctrl->key);
        if(ret) {
            DRV_MSG(MSG_INFO, "%s gen_key err: %x\r\n", __FUNCTION__, ret);
            return ret;
        }

        if(attr->gpd[i].alen > 0) {
            ret = attr->key[i].idx - 1;
            SECK_SET_ADATA(ctrl->key[ret], attr->gpd[i].alen);
            SOE_CACHE_STORE(&ctrl->key[ret], sizeof(sec_key_t));
        }
        
        memset(&ctrl->gpd[idx], 0, sizeof(gpd_t));
        attr->gpd[i].gpd = &ctrl->gpd[idx++];
        ret = drv_soe_gen_gpd_attr(&attr->gpd[i], &attr->key[i]);
        if(ret) {
            DRV_MSG(MSG_INFO, "%s gen_gpd err: %x\r\n", __FUNCTION__, ret);
            return ret;
        }
        if(attr->gpd[i].alen || (attr->key[i].mode == SECK_AES && attr->key[i].alg == SECK_ALG_XCBC && attr->gpd[i].icblen) ) {
            memset(&ctrl->gpd[idx], 0, sizeof(gpd_t));
            attr->gpd[i].bd = (bd_t*)&ctrl->gpd[attr->gpdnum + idx];
        }
    }
    ret = drv_soe_list_init(attr);

#ifdef ATEST_ENABLE
    if(!ret) 
        ctrl->r_gpd_cnt += attr->gpdnum;
#endif
    DRV_DBG_FRC_END(0);
    return ret;
}

kal_uint32 drv_soe_update_attr(drv_soe_ctrl_struct_t *ctrl)
{
    drv_soe_list_attr_t *attr = &ctrl->list_attr;
    kal_uint32 ret;

    DRV_DBG_FRC_START(0);

    // check ctrl
    if(!SOE_GET_NEXT(ctrl->gpd)) {
        return DRV_SOE_ERR_INVALID_GPD;
    }
    
    // update GPD
    ret = drv_soe_list_init(attr);

#ifdef ATEST_ENABLE
    if(!ret) 
        ctrl->r_gpd_cnt += attr->gpdnum;
#endif
    DRV_DBG_FRC_END(0);
    return ret;
}

kal_uint32 drv_soe_trigger(gpd_t *pGpd, sec_key_t *pKey)
{
    kal_uint32 err = 0;
    kal_uint32 event_group = 0;
    kal_uint32 soe_timeout_ticks;
    gpd_t *last_gpd = pGpd;

    //check GPD/KEY
    if(last_gpd == NULL || pKey == NULL) return DRV_SOE_ERR_INVALID_PTR;
    if((kal_uint32)last_gpd & 0x3) return DRV_SOE_ERR_INVALID_PTR;
    if((kal_uint32)pKey & 0x3) return DRV_SOE_ERR_INVALID_PTR;
    if(!SOE_IS_DYNA_DRAM((kal_uint32)pGpd, sizeof(gpd_t))) return DRV_SOE_ERR_INVALID_PTR;

    pKey = (sec_key_t*)((kal_uint32)pKey - sizeof(sec_key_t));
    if(!SOE_IS_DYNA_DRAM((kal_uint32)pKey, sizeof(sec_key_t))) return DRV_SOE_ERR_INVALID_PTR;
    while(SOE_IS_FLAGS_HWO(last_gpd)) {
        if(!SECK_GET_VALID(pKey[last_gpd->keyidx])) return DRV_SOE_ERR_INVALID_KEY;
        if(last_gpd->pnext == NULL) return DRV_SOE_ERR_INVALID_PNEXT;
        if(last_gpd->icbptr == NULL) return DRV_SOE_ERR_INVALID_ICB;
        if(last_gpd->icvptr == NULL) return DRV_SOE_ERR_INVALID_ICV;
        last_gpd = last_gpd->pnext;
    }
    if(last_gpd == pGpd) return DRV_SOE_ERR_INVALID_GPD;

    DRV_DBG_FRC_START(0);

    //check drv init
    if(!drv_inited) {
        drv_soe_init();
    }

    //mutex lock
    kal_take_enh_mutex(drv_soe_locker);
    SleepDrv_LockSleep(SLEEP_CTL_SOE, SMP);
    PDN_CLR(PDN_SOE);

    //check SOE status
    Data_Mem_Barrier();
    if(SOE_REG(SOE_QCSR) & SOQ_STAT) {
        err = DRV_SOE_ERR_STAT_BUSY;
        goto EngineError;
    }

    //unmask irq
#ifndef DRV_DISABLE_IRQ
    if(drv_soe_irq_en) {
        SOE_REG(SOE_L2ISAR) = 0xFFFFFFFF;
        SOE_REG(SOE_L2IMCR) = 0xFFFFFFFF;
        IRQClearInt(SOE_IRQ);
        IRQUnmask(SOE_IRQ);
    }
#endif

    //config SOE
#if defined(MT6297)
    SOE_REG(SOE_ASYM_STATUS_REG7) = 0xFFFFFFFF;
#endif
    SOE_REG(SOE_CR) = (SOE_CS_EN | SOE_CSALL_EN);
    drv_soe_set_reg(SOE_CR, SOE_DMA_MODE, SOE_DMA_MODE, SOE_DMA_MODE_BITS);
    if(query_is_cached_ram((kal_uint32)pKey, sizeof(sec_key_t))) {
        SOE_REG(SOE_KTSAR) = virt_to_phys(pKey);
    }
    else {
        SOE_REG(SOE_KTSAR) = (kal_uint32)pKey;
    }
    if(query_is_cached_ram((kal_uint32)pGpd, sizeof(gpd_t))) {
        SOE_REG(SOE_QSAR) = virt_to_phys(pGpd);
    }
    else {
        SOE_REG(SOE_QSAR) = (kal_uint32)pGpd;
    }

    //start queue
    Data_Mem_Barrier();
    DRV_DBG_FRC_START(1);
    SOE_REG(SOE_QCSR) = SOQ_START;
    Data_Sync_Barrier();
    
    //wait done
#ifndef DRV_DISABLE_IRQ
    if(drv_soe_irq_en) {
        kal_retrieve_eg_events(drv_soe_egid, (SO_ERROR_MASK | SO_DONE), KAL_OR_CONSUME, &event_group, KAL_SUSPEND);
    }
    else
#endif
    {
        soe_timeout_ticks = drv_get_current_time();
        while(SOE_REG(SOE_QCSR) & SOQ_STAT) {
            if(drv_get_duration_ms(soe_timeout_ticks) > 8000) {
                DRV_DBG_FRC_END(1);
                err = DRV_SOE_ERR_STAT_BUSY;
                goto EngineError;
            }
        }
        event_group = SOE_REG(SOE_L2ISAR);
        #if defined(MT6297)
        event_group |= (SOE_REG(SOE_ASYM_STATUS_REG7) << 8);
        #endif
    }
    DRV_DBG_FRC_END(1);
    if(event_group & SO_GPD_CSERR) err = DRV_SOE_ERR_GPD_CSERR;
    if(event_group & SO_BD_CSERR) err = DRV_SOE_ERR_BD_CSERR;
    if(event_group & SO_LENERR) err = DRV_SOE_ERR_LENERR;
    if(event_group & SO_KTERR) err = DRV_SOE_ERR_KTERR;
    if(SOE_IS_FORMAT_VR(pGpd)) err = DRV_SOE_ERR_VRERR;
    if(event_group & SO_ASYM_ERROR_MASK) err = DRV_SOE_ERR_ASYMERR;
    if(err) goto EngineError;

    SOE_REG(SOE_L2IMSR) = 0xFFFFFFFF;
    Data_Sync_Barrier();
EngineError:
    PDN_SET(PDN_SOE);
    SleepDrv_UnlockSleep(SLEEP_CTL_SOE, SMP);
    kal_give_enh_mutex(drv_soe_locker);
    DRV_DBG_FRC_END(0);
    return err;    
}

void drv_soe_cache_ctrl(kal_bool clean, kal_bool invalidate, kal_uint32 addr, kal_uint32 ln)
{
    if(clean)
        SOE_CACHE_STORE(addr, ln);
    if(invalidate)
        SOE_CACHE_INVALIDATE(addr, ln);
}

void* drv_soe_memcpy(kal_uint8 *dst, kal_uint8 *src, kal_uint32 ln)
{
    return memcpy((kal_uint8*)virt_to_phys(dst), \
                  (kal_uint8*)virt_to_phys(src), \
                  ln);
}

//Call from devdrv_common.c Drv_Init_Phase2()
void SOE_Drv_Init(void)
{
    drv_soe_init();
    PDN_SET(PDN_SOE);
}