v811_spc009/vendor/huanglong/linux/drv/tsr2rcipher/drv_tsr2rcipher.c

/*
 * Copyright (c) Hisilicon Technologies Co., Ltd. 2019-2021. All rights reserved.
 * Description: tsr2rcipher drv func impl.
 * Author: Hisilicon
 * Create: 2019-08-02
 */

#include "td_type.h"
#include "soc_log.h"
#include "drv_tsr2rcipher_ext.h"

#include "drv_tsr2rcipher_func.h"
#include "drv_tsr2rcipher_utils.h"

td_s32 ext_drv_tsr2rcipher_get_capability(tsr2rcipher_capability *cap)
{
    td_s32 ret;

    if (cap == TD_NULL) {
        soc_log_err("invalid parameter.\n");
        ret = SOC_ERR_TSR2RCIPHER_INVALID_PARA;
        goto out;
    }

    ret = tsr2rcipher_mgmt_get_cap(cap);
out:
    return ret;
}
EXPORT_SYMBOL(ext_drv_tsr2rcipher_get_capability);

td_s32 ext_drv_tsr2rcipher_create_session(struct tsr2rcipher_session **new_session)
{
    td_s32 ret;

    if (new_session == TD_NULL) {
        soc_log_err("invalid parameter.\n");
        ret = SOC_ERR_TSR2RCIPHER_INVALID_PARA;
        goto out;
    }

    ret = tsr2rcipher_session_create(new_session);

out:
    return ret;
}
EXPORT_SYMBOL(ext_drv_tsr2rcipher_create_session);

td_s32 ext_drv_tsr2rcipher_destroy_session(struct tsr2rcipher_session *session)
{
    td_s32 ret;

    if (session == TD_NULL) {
        soc_log_err("invalid parameter.\n");
        ret = SOC_ERR_TSR2RCIPHER_INVALID_PARA;
        goto out;
    }

    ret = tsr2rcipher_session_destroy(session);

out:
    return ret;
}
EXPORT_SYMBOL(ext_drv_tsr2rcipher_destroy_session);

td_s32 ext_drv_tsr2rcipher_create(const tsr2rcipher_attr *tsc_attr, td_handle *handle,
    struct tsr2rcipher_session *session)
{
    td_s32 ret;

    if ((handle == TD_NULL) || (session == TD_NULL) || (tsc_attr == TD_NULL)) {
        soc_log_err("invalid parameter.\n");
        ret = SOC_ERR_TSR2RCIPHER_INVALID_PARA;
        goto out;
    }

    ret = tsr2rcipher_ch_create(tsc_attr, handle, session);
out:
    return ret;
}
EXPORT_SYMBOL(ext_drv_tsr2rcipher_create);

td_s32 ext_drv_tsr2rcipher_get_attr(td_handle handle, tsr2rcipher_attr *tsc_attr)
{
    td_s32 ret;

    check_handle(handle);

    if (tsc_attr == TD_NULL) {
        soc_log_err("invalid parameter.\n");
        ret = SOC_ERR_TSR2RCIPHER_INVALID_PARA;
        goto out;
    }

    ret = tsr2rcipher_ch_get_attr(handle, tsc_attr);
out:
    return ret;
}
EXPORT_SYMBOL(ext_drv_tsr2rcipher_get_attr);

td_s32 ext_drv_tsr2rcipher_set_attr(td_handle handle, const tsr2rcipher_attr *tsc_attr)
{
    td_s32 ret;

    check_handle(handle);

    if (tsc_attr == TD_NULL) {
        soc_log_err("invalid parameter.\n");
        ret = SOC_ERR_TSR2RCIPHER_INVALID_PARA;
        goto out;
    }

    ret = tsr2rcipher_ch_set_attr(handle, tsc_attr);
out:
    return ret;
}
EXPORT_SYMBOL(ext_drv_tsr2rcipher_set_attr);

td_s32 ext_drv_tsr2rcipher_get_keyslot_handle(td_handle tsc_handle, td_handle *ks_handle)
{
    td_s32 ret;

    check_handle(tsc_handle);

    if (ks_handle == TD_NULL) {
        soc_log_err("invalid parameter.\n");
        ret = SOC_ERR_TSR2RCIPHER_INVALID_PARA;
        goto out;
    }

    ret = tsr2rcipher_ch_get_ks_handle(tsc_handle, ks_handle);
out:
    return ret;
}
EXPORT_SYMBOL(ext_drv_tsr2rcipher_get_keyslot_handle);

td_s32 ext_drv_tsr2rcipher_attach_keyslot(td_handle tsc_handle, td_handle ks_handle)
{
    check_handle(tsc_handle);
    check_ks(ks_handle);

    return tsr2rcipher_ch_attach_ks(tsc_handle, ks_handle);
}
EXPORT_SYMBOL(ext_drv_tsr2rcipher_attach_keyslot);

td_s32 ext_drv_tsr2rcipher_detach_keyslot(td_handle tsc_handle, td_handle ks_handle)
{
    check_handle(tsc_handle);
    check_ks(ks_handle);

    return tsr2rcipher_ch_detach_ks(tsc_handle, ks_handle);
}
EXPORT_SYMBOL(ext_drv_tsr2rcipher_detach_keyslot);

td_s32 ext_drv_tsr2rcipher_set_iv(td_handle handle, tsr2rcipher_iv_type iv_type, const td_u8 *iv, td_u32 iv_len)
{
    td_s32 ret;

    check_handle(handle);

    if ((iv == TD_NULL) || (iv_len < TSR2RCIPHER_MIN_IV_LEN) || (iv_len > TSR2RCIPHER_MAX_IV_LEN) ||
        (iv_type >= TSR2RCIPHER_IV_MAX)) {
        soc_log_err("invalid parameter. IV[%#x], ivlen[%#x], ivtype[%#x]\n", iv, iv_len, iv_type);
        ret = SOC_ERR_TSR2RCIPHER_INVALID_PARA;
        goto out;
    }

    ret = tsr2rcipher_ch_set_iv(handle, iv_type, iv, iv_len);
out:
    return ret;
}
EXPORT_SYMBOL(ext_drv_tsr2rcipher_set_iv);

static td_s32 drv_tsr2rcipher_trim_data_args(td_mem_handle_t src_buf_handle, td_mem_handle_t dst_buf_handle, td_u32 len)
{
    if ((len < TSR2RCIPHER_TS_PACKAGE_LEN) || (len > TSR2RCIPHER_MAX_SIZE_PRE_DESC) ||
        (len % TSR2RCIPHER_TS_PACKAGE_LEN)) {
        soc_log_err("data len = 0x%x is invalid, correct rang is (0x%x ~ 0x%x ), or not 188 times\n",
            len, TSR2RCIPHER_TS_PACKAGE_LEN, TSR2RCIPHER_MAX_SIZE_PRE_DESC);
        return SOC_ERR_TSR2RCIPHER_INVALID_PARA;
    }

    if (src_buf_handle < 0 || dst_buf_handle < 0) {
        soc_log_err("src_buf_handle[%d] or dst_buf_handle[%d] is invalid!\n",
            src_buf_handle, dst_buf_handle);
        return SOC_ERR_TSR2RCIPHER_INVALID_PARA;
    }

    return TD_SUCCESS;
}

td_s32 ext_drv_tsr2rcipher_encrypt(td_handle handle, tsr2rcipher_mem_handle src_mem_handle,
    tsr2rcipher_mem_handle dst_mem_handle, td_u32 data_len)
{
    td_s32 ret;

    check_handle(handle);

    ret = drv_tsr2rcipher_trim_data_args(src_mem_handle.mem_handle, dst_mem_handle.mem_handle, data_len);
    if (ret != TD_SUCCESS) {
        goto out;
    }

    ret = tsr2rcipher_ch_encrypt(handle, src_mem_handle, dst_mem_handle, data_len);

out:
    return ret;
}
EXPORT_SYMBOL(ext_drv_tsr2rcipher_encrypt);

td_s32 ext_drv_tsr2rcipher_decrypt(td_handle handle, tsr2rcipher_mem_handle src_mem_handle,
    tsr2rcipher_mem_handle dst_mem_handle, td_u32 data_len)
{
    td_s32 ret;

    check_handle(handle);

    ret = drv_tsr2rcipher_trim_data_args(src_mem_handle.mem_handle, dst_mem_handle.mem_handle, data_len);
    if (ret != TD_SUCCESS) {
        goto out;
    }

    ret = tsr2rcipher_ch_decrypt(handle, src_mem_handle, dst_mem_handle, data_len);

out:
    return ret;
}
EXPORT_SYMBOL(ext_drv_tsr2rcipher_decrypt);

td_s32 ext_drv_tsr2rcipher_destroy(td_handle handle)
{
    check_handle(handle);

    return tsr2rcipher_ch_destroy(handle);
}
EXPORT_SYMBOL(ext_drv_tsr2rcipher_destroy);

td_s32 ext_drv_tsr2rcipher_suspend(td_void)
{
    return tsr2rcipher_mgmt_suspend();
}
EXPORT_SYMBOL(ext_drv_tsr2rcipher_suspend);

td_s32 ext_drv_tsr2rcipher_resume(td_void)
{
    return tsr2rcipher_mgmt_resume();
}
EXPORT_SYMBOL(ext_drv_tsr2rcipher_resume);