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

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

#include "drv_tsio_ext.h"
#include "drv_tsio_utils.h"
#include "drv_tsio_func.h"

td_s32 ext_drv_tsio_get_capability(tsio_capability *cap)
{
    return tsio_mgmt_get_cap(cap);
}
EXPORT_SYMBOL(ext_drv_tsio_get_capability);

td_s32 ext_drv_tsio_get_out_of_sync_cnt(td_u32 *cnt)
{
    return tsio_mgmt_get_out_of_sync_cnt(cnt);
}
EXPORT_SYMBOL(ext_drv_tsio_get_out_of_sync_cnt);

td_s32 ext_drv_tsio_create_session(struct tsio_session **new_session)
{
    td_s32 ret;

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

    ret = tsio_session_create(new_session);

out:
    return ret;
}
EXPORT_SYMBOL(ext_drv_tsio_create_session);

td_s32 ext_drv_tsio_destroy_session(struct tsio_session *session)
{
    td_s32 ret;

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

    ret = tsio_session_destroy(session);

out:
    return ret;
}
EXPORT_SYMBOL(ext_drv_tsio_destroy_session);

td_s32 ext_drv_tsio_get_config(tsio_config *config)
{
    return tsio_mgmt_get_config(config);
}
EXPORT_SYMBOL(ext_drv_tsio_get_config);

td_s32 ext_drv_tsio_set_config(const tsio_config *config)
{
    return tsio_mgmt_set_config(config);
}
EXPORT_SYMBOL(ext_drv_tsio_set_config);

td_s32 ext_drv_tsio_tsi_open_port(tsio_port port, const tsio_tsi_port_attrs *attrs, td_handle *handle,
    struct tsio_session *session)
{
    td_s32 ret;

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

    ret = tsio_tsi_open_port(port, attrs, handle, session);
out:
    return ret;
}
EXPORT_SYMBOL(ext_drv_tsio_tsi_open_port);

td_s32 ext_drv_tsio_tsi_get_port_attrs(td_handle handle, tsio_tsi_port_attrs *attrs)
{
    td_s32 ret;

    ret = check_handle(handle);
    if (ret != TD_SUCCESS) {
        soc_log_err("invalid handle(0x%x).\n", handle);
        ret = SOC_ERR_TSIO_INVALID_PARA;
        goto out;
    }

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

    ret = tsio_tsi_get_port_attrs(handle, attrs);

out:
    return ret;
}
EXPORT_SYMBOL(ext_drv_tsio_tsi_get_port_attrs);

td_s32 ext_drv_tsio_tsi_set_port_attrs(td_handle handle, const tsio_tsi_port_attrs *attrs)
{
    td_s32 ret;

    ret = check_handle(handle);
    if (ret != TD_SUCCESS) {
        soc_log_err("invalid handle(0x%x).\n", handle);
        ret = SOC_ERR_TSIO_INVALID_PARA;
        goto out;
    }

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

    ret = tsio_tsi_set_port_attrs(handle, attrs);

out:
    return ret;
}
EXPORT_SYMBOL(ext_drv_tsio_tsi_set_port_attrs);

td_s32 ext_drv_tsio_tsi_get_port_status(td_handle handle, tsio_tsi_port_status *status)
{
    td_s32 ret;

    ret = check_handle(handle);
    if (ret != TD_SUCCESS) {
        soc_log_err("invalid handle(0x%x).\n", handle);
        ret = SOC_ERR_TSIO_INVALID_PARA;
        goto out;
    }

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

    ret = tsio_tsi_get_port_status(handle, status);

out:
    return ret;
}
EXPORT_SYMBOL(ext_drv_tsio_tsi_get_port_status);

td_s32 ext_drv_tsio_tsi_close_port(td_handle handle)
{
    td_s32 ret;

    ret = check_handle(handle);
    if (ret != TD_SUCCESS) {
        soc_log_err("invalid handle(0x%x).\n", handle);
        ret = SOC_ERR_TSIO_INVALID_PARA;
        goto out;
    }

    ret = tsio_tsi_close_port(handle);

out:
    return ret;
}
EXPORT_SYMBOL(ext_drv_tsio_tsi_close_port);

td_s32 ext_drv_tsio_ram_open_port(tsio_port port, const tsio_ram_port_attrs_ex *attrs, td_handle *handle,
    struct tsio_session *session)
{
    td_s32 ret;

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

    ret = tsio_ram_open_port(port, attrs, handle, session);
out:
    return ret;
}
EXPORT_SYMBOL(ext_drv_tsio_ram_open_port);

td_s32 ext_drv_tsio_ram_get_port_attrs(td_handle handle, tsio_ram_port_attrs *attrs)
{
    td_s32 ret;

    ret = check_handle(handle);
    if (ret != TD_SUCCESS) {
        soc_log_err("invalid handle(0x%x).\n", handle);
        ret = SOC_ERR_TSIO_INVALID_PARA;
        goto out;
    }

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

    ret = tsio_ram_get_port_attrs(handle, attrs);

out:
    return ret;
}
EXPORT_SYMBOL(ext_drv_tsio_ram_get_port_attrs);

td_s32 ext_drv_tsio_ram_set_port_attrs(td_handle handle, const tsio_ram_port_attrs_ex *attrs)
{
    td_s32 ret;

    ret = check_handle(handle);
    if (ret != TD_SUCCESS) {
        soc_log_err("invalid handle(0x%x).\n", handle);
        ret = SOC_ERR_TSIO_INVALID_PARA;
        goto out;
    }

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

    ret = tsio_ram_set_port_attrs(handle, attrs);

out:
    return ret;
}
EXPORT_SYMBOL(ext_drv_tsio_ram_set_port_attrs);

td_s32 ext_drv_tsio_ram_get_port_status(td_handle handle, tsio_ram_port_status *status)
{
    td_s32 ret;

    ret = check_handle(handle);
    if (ret != TD_SUCCESS) {
        soc_log_err("invalid handle(0x%x).\n", handle);
        ret = SOC_ERR_TSIO_INVALID_PARA;
        goto out;
    }

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

    ret = tsio_ram_get_port_status(handle, status);

out:
    return ret;
}
EXPORT_SYMBOL(ext_drv_tsio_ram_get_port_status);

td_s32 ext_drv_tsio_ram_begin_bulk_seg(td_handle handle, tsio_key_type key, const td_u8 *iv)
{
    td_s32 ret;

    ret = check_handle(handle);
    if (ret != TD_SUCCESS) {
        soc_log_err("invalid handle(0x%x).\n", handle);
        ret = SOC_ERR_TSIO_INVALID_PARA;
        goto out;
    }

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

    ret = tsio_ram_begin_bulk_seg(handle, key, iv);

out:
    return ret;
}
EXPORT_SYMBOL(ext_drv_tsio_ram_begin_bulk_seg);

td_s32 ext_drv_tsio_ram_end_bulk_seg(td_handle handle)
{
    td_s32 ret;

    ret = check_handle(handle);
    if (ret != TD_SUCCESS) {
        soc_log_err("invalid handle(0x%x).\n", handle);
        ret = SOC_ERR_TSIO_INVALID_PARA;
        goto out;
    }

    ret = tsio_ram_end_bulk_seg(handle);

out:
    return ret;
}
EXPORT_SYMBOL(ext_drv_tsio_ram_end_bulk_seg);

/* time_out:ms */
td_s32 ext_drv_tsio_ram_get_buffer(td_handle handle, td_u32 req_len, tsio_buffer *buf, td_u32 time_out)
{
    td_s32 ret;

    ret = check_handle(handle);
    if (ret != TD_SUCCESS) {
        soc_log_err("invalid handle(0x%x).\n", handle);
        ret = SOC_ERR_TSIO_INVALID_PARA;
        goto out;
    }

    if ((req_len == 0) || (buf == TD_NULL)) {
        soc_log_err("invalid parameter.\n");
        ret = SOC_ERR_TSIO_INVALID_PARA;
        goto out;
    }

    ret = tsio_ram_get_buffer(handle, req_len, buf, time_out);

out:
    return ret;
}
EXPORT_SYMBOL(ext_drv_tsio_ram_get_buffer);

td_s32 ext_drv_tsio_ram_push_buffer(td_handle handle, tsio_buffer *buf)
{
    td_s32 ret;

    ret = check_handle(handle);
    if (ret != TD_SUCCESS) {
        soc_log_err("invalid handle(0x%x).\n", handle);
        ret = SOC_ERR_TSIO_INVALID_PARA;
        goto out;
    }

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

    ret = tsio_ram_push_buffer(handle, buf);

out:
    return ret;
}
EXPORT_SYMBOL(ext_drv_tsio_ram_push_buffer);

td_s32 ext_drv_tsio_ram_put_buffer(td_handle handle, tsio_buffer *buf)
{
    td_s32 ret;

    ret = check_handle(handle);
    if (ret != TD_SUCCESS) {
        soc_log_err("invalid handle(0x%x).\n", handle);
        ret = SOC_ERR_TSIO_INVALID_PARA;
        goto out;
    }

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

    ret = tsio_ram_put_buffer(handle, buf);

out:
    return ret;
}
EXPORT_SYMBOL(ext_drv_tsio_ram_put_buffer);

td_s32 ext_drv_tsio_ram_reset_buffer(td_handle handle)
{
    td_s32 ret;

    ret = check_handle(handle);
    if (ret != TD_SUCCESS) {
        soc_log_err("invalid handle(0x%x).\n", handle);
        ret = SOC_ERR_TSIO_INVALID_PARA;
        goto out;
    }

    ret = tsio_ram_reset_buffer(handle);

out:
    return ret;
}
EXPORT_SYMBOL(ext_drv_tsio_ram_reset_buffer);

td_s32 ext_drv_tsio_ram_close_port(td_handle handle)
{
    td_s32 ret;

    ret = check_handle(handle);
    if (ret != TD_SUCCESS) {
        soc_log_err("invalid handle(0x%x).\n", handle);
        ret = SOC_ERR_TSIO_INVALID_PARA;
        goto out;
    }

    ret = tsio_ram_close_port(handle);

out:
    return ret;
}
EXPORT_SYMBOL(ext_drv_tsio_ram_close_port);

td_s32 ext_drv_tsio_ram_pre_mmap(td_handle handle, td_handle *buf_handle,
    td_u32 *buf_size, td_void **usr_addr)
{
    td_s32 ret;

    ret = check_handle(handle);
    if (ret != TD_SUCCESS) {
        soc_log_err("invalid handle(0x%x).\n", handle);
        ret = SOC_ERR_TSIO_INVALID_PARA;
        goto out;
    }

    if (buf_handle == TD_NULL || buf_size == TD_NULL || usr_addr == TD_NULL) {
        soc_log_err("null pointer, buf_handle(%p), buf_size(%p), usr_addr(%p).\n", buf_handle, buf_size, usr_addr);
        ret = SOC_ERR_TSIO_INVALID_PARA;
        goto out;
    }

    ret = tsio_ram_pre_mmap(handle, buf_handle, buf_size, usr_addr);

out:
    return ret;
}
EXPORT_SYMBOL(ext_drv_tsio_ram_pre_mmap);

td_s32 ext_drv_tsio_ram_pst_mmap(td_handle handle, td_void *buf_usr_addr)
{
    td_s32 ret;

    ret = check_handle(handle);
    if (ret != TD_SUCCESS) {
        soc_log_err("invalid handle(0x%x).\n", handle);
        ret = SOC_ERR_TSIO_INVALID_PARA;
        goto out;
    }

    ret = tsio_ram_pst_mmap(handle, buf_usr_addr);

out:
    return ret;
}
EXPORT_SYMBOL(ext_drv_tsio_ram_pst_mmap);

td_s32 ext_drv_tsio_pid_create_channel(td_handle pt_handle, td_u32 pid, td_handle *handle, struct tsio_session *session)
{
    td_s32 ret;

    ret = check_handle(pt_handle);
    if (ret != TD_SUCCESS) {
        soc_log_err("invalid handle(0x%x).\n", pt_handle);
        ret = SOC_ERR_TSIO_INVALID_PARA;
        goto out;
    }

    if (pid > INVALID_PID) {
        soc_log_err("invalid pid(%d).\n", pid);
        ret = SOC_ERR_TSIO_INVALID_PARA;
        goto out;
    }

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

    ret = tsio_pid_create_channel(pt_handle, pid, handle, session);

out:
    return ret;
}
EXPORT_SYMBOL(ext_drv_tsio_pid_create_channel);

td_s32 ext_drv_tsio_pid_get_channel_status(td_handle handle, tsio_pid_channel_status *status)
{
    td_s32 ret;

    ret = check_handle(handle);
    if (ret != TD_SUCCESS) {
        soc_log_err("invalid handle(0x%x).\n", handle);
        ret = SOC_ERR_TSIO_INVALID_PARA;
        goto out;
    }

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

    ret = tsio_pid_get_channel_status(handle, status);

out:
    return ret;
}
EXPORT_SYMBOL(ext_drv_tsio_pid_get_channel_status);

td_s32 ext_drv_tsio_pid_destroy_channel(td_handle handle)
{
    td_s32 ret;

    ret = check_handle(handle);
    if (ret != TD_SUCCESS) {
        soc_log_err("invalid handle(0x%x).\n", handle);
        ret = SOC_ERR_TSIO_INVALID_PARA;
        goto out;
    }

    ret = tsio_pid_destroy_channel(handle);

out:
    return ret;
}
EXPORT_SYMBOL(ext_drv_tsio_pid_destroy_channel);

td_s32 ext_drv_tsio_raw_create_channel(td_handle pt_handle, td_handle *handle, struct tsio_session *session)
{
    td_s32 ret;

    ret = check_handle(pt_handle);
    if (ret != TD_SUCCESS) {
        soc_log_err("invalid handle(0x%x).\n", pt_handle);
        ret = SOC_ERR_TSIO_INVALID_PARA;
        goto out;
    }

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

    ret = tsio_raw_create_channel(pt_handle, handle, session);

out:
    return ret;
}
EXPORT_SYMBOL(ext_drv_tsio_raw_create_channel);

td_s32 ext_drv_tsio_raw_destroy_channel(td_handle handle)
{
    td_s32 ret;

    ret = check_handle(handle);
    if (ret != TD_SUCCESS) {
        soc_log_err("invalid handle(0x%x).\n", handle);
        ret = SOC_ERR_TSIO_INVALID_PARA;
        goto out;
    }

    ret = tsio_raw_destroy_channel(handle);

out:
    return ret;
}
EXPORT_SYMBOL(ext_drv_tsio_raw_destroy_channel);

td_s32 ext_drv_tsio_sp_create_channel(td_handle pt_handle, td_handle *handle, struct tsio_session *session)
{
    td_s32 ret;

    ret = check_handle(pt_handle);
    if (ret != TD_SUCCESS) {
        soc_log_err("invalid handle(0x%x).\n", pt_handle);
        ret = SOC_ERR_TSIO_INVALID_PARA;
        goto out;
    }

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

    ret = tsio_sp_create_channel(pt_handle, handle, session);

out:
    return ret;
}
EXPORT_SYMBOL(ext_drv_tsio_sp_create_channel);

td_s32 ext_drv_tsio_sp_destroy_channel(td_handle handle)
{
    td_s32 ret;

    ret = check_handle(handle);
    if (ret != TD_SUCCESS) {
        soc_log_err("invalid handle(0x%x).\n", handle);
        ret = SOC_ERR_TSIO_INVALID_PARA;
        goto out;
    }

    ret = tsio_sp_destroy_channel(handle);

out:
    return ret;
}
EXPORT_SYMBOL(ext_drv_tsio_sp_destroy_channel);

td_s32 ext_drv_tsio_ivr_create_channel(td_handle pt_handle, td_handle *handle, struct tsio_session *session)
{
    td_s32 ret;

    ret = check_handle(pt_handle);
    if (ret != TD_SUCCESS) {
        soc_log_err("invalid handle(0x%x).\n", pt_handle);
        ret = SOC_ERR_TSIO_INVALID_PARA;
        goto out;
    }

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

    ret = tsio_ivr_create_channel(pt_handle, handle, session);

out:
    return ret;
}
EXPORT_SYMBOL(ext_drv_tsio_ivr_create_channel);

td_s32 ext_drv_tsio_ivr_destroy_channel(td_handle handle)
{
    td_s32 ret;

    ret = check_handle(handle);
    if (ret != TD_SUCCESS) {
        soc_log_err("invalid handle(0x%x).\n", handle);
        ret = SOC_ERR_TSIO_INVALID_PARA;
        goto out;
    }

    ret = tsio_ivr_destroy_channel(handle);

out:
    return ret;
}
EXPORT_SYMBOL(ext_drv_tsio_ivr_destroy_channel);

td_s32 ext_drv_tsio_se_create(tsio_sid sid, const tsio_secure_engine_attrs *attrs, td_handle *handle,
    struct tsio_session *session)
{
    td_s32 ret;

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

    ret = tsio_se_create(sid, attrs, handle, session);

out:
    return ret;
}
EXPORT_SYMBOL(ext_drv_tsio_se_create);

td_s32 ext_drv_tsio_se_open(td_handle handle)
{
    td_s32 ret;

    ret = check_handle(handle);
    if (ret != TD_SUCCESS) {
        soc_log_err("invalid handle(0x%x).\n", handle);
        ret = SOC_ERR_TSIO_INVALID_PARA;
        goto out;
    }

    ret = tsio_se_open(handle);

out:
    return ret;
}
EXPORT_SYMBOL(ext_drv_tsio_se_open);

td_s32 ext_drv_tsio_se_get_attrs(td_handle handle, tsio_secure_engine_attrs *attrs)
{
    td_s32 ret;

    ret = check_handle(handle);
    if (ret != TD_SUCCESS) {
        soc_log_err("invalid handle(0x%x).\n", handle);
        ret = SOC_ERR_TSIO_INVALID_PARA;
        goto out;
    }

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

    ret = tsio_se_get_attrs(handle, attrs);

out:
    return ret;
}
EXPORT_SYMBOL(ext_drv_tsio_se_get_attrs);

td_s32 ext_drv_tsio_se_set_attrs(td_handle handle, const tsio_secure_engine_attrs *attrs)
{
    td_s32 ret;

    ret = check_handle(handle);
    if (ret != TD_SUCCESS) {
        soc_log_err("invalid handle(0x%x).\n", handle);
        ret = SOC_ERR_TSIO_INVALID_PARA;
        goto out;
    }

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

    ret = tsio_se_set_attrs(handle, attrs);

out:
    return ret;
}
EXPORT_SYMBOL(ext_drv_tsio_se_set_attrs);

td_s32 ext_drv_tsio_se_get_status(td_handle handle, tsio_secure_engine_status *status)
{
    td_s32 ret;

    ret = check_handle(handle);
    if (ret != TD_SUCCESS) {
        soc_log_err("invalid handle(0x%x).\n", handle);
        ret = SOC_ERR_TSIO_INVALID_PARA;
        goto out;
    }

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

    ret = tsio_se_get_status(handle, status);

out:
    return ret;
}
EXPORT_SYMBOL(ext_drv_tsio_se_get_status);

td_s32 ext_drv_tsio_se_add_channel(td_handle handle, td_handle ch_handle)
{
    td_s32 ret;

    ret = check_handle(handle);
    if (ret != TD_SUCCESS) {
        soc_log_err("invalid handle(0x%x).\n", handle);
        ret = SOC_ERR_TSIO_INVALID_PARA;
        goto out;
    }

    ret = check_handle(ch_handle);
    if (ret != TD_SUCCESS) {
        soc_log_err("invalid handle(0x%x).\n", ch_handle);
        ret = SOC_ERR_TSIO_INVALID_PARA;
        goto out;
    }

    ret = tsio_se_add_channel(handle, ch_handle);

out:
    return ret;
}
EXPORT_SYMBOL(ext_drv_tsio_se_add_channel);

td_s32 ext_drv_tsio_se_del_channel(td_handle handle, td_handle ch_handle)
{
    td_s32 ret;

    ret = check_handle(handle);
    if (ret != TD_SUCCESS) {
        soc_log_err("invalid handle(0x%x).\n", handle);
        ret = SOC_ERR_TSIO_INVALID_PARA;
        goto out;
    }

    ret = check_handle(ch_handle);
    if (ret != TD_SUCCESS) {
        soc_log_err("invalid handle(0x%x).\n", ch_handle);
        ret = SOC_ERR_TSIO_INVALID_PARA;
        goto out;
    }

    ret = tsio_se_del_channel(handle, ch_handle);

out:
    return ret;
}
EXPORT_SYMBOL(ext_drv_tsio_se_del_channel);

td_s32 ext_drv_tsio_se_del_all_channels(td_handle handle)
{
    td_s32 ret;

    ret = check_handle(handle);
    if (ret != TD_SUCCESS) {
        soc_log_err("invalid handle(0x%x).\n", handle);
        ret = SOC_ERR_TSIO_INVALID_PARA;
        goto out;
    }

    ret = tsio_se_del_all_channels(handle);

out:
    return ret;
}
EXPORT_SYMBOL(ext_drv_tsio_se_del_all_channels);

td_s32 ext_drv_tsio_se_acquire_buffer(td_handle handle, td_u32 req_len, tsio_buffer *buf, td_u32 time_out)
{
    td_s32 ret;

    ret = check_handle(handle);
    if (ret != TD_SUCCESS) {
        soc_log_err("invalid handle(0x%x).\n", handle);
        ret = SOC_ERR_TSIO_INVALID_PARA;
        goto out;
    }

    if ((req_len == 0) || (buf == TD_NULL)) {
        soc_log_err("invalid parameter.\n");
        ret = SOC_ERR_TSIO_INVALID_PARA;
        goto out;
    }

    ret = tsio_se_acquire_buffer(handle, req_len, buf, time_out);

out:
    return ret;
}
EXPORT_SYMBOL(ext_drv_tsio_se_acquire_buffer);

td_s32 ext_drv_tsio_se_release_buffer(td_handle handle, const tsio_buffer *buf)
{
    td_s32 ret;

    ret = check_handle(handle);
    if (ret != TD_SUCCESS) {
        soc_log_err("invalid handle(0x%x).\n", handle);
        ret = SOC_ERR_TSIO_INVALID_PARA;
        goto out;
    }

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

    ret = tsio_se_release_buffer(handle, buf);

out:
    return ret;
}
EXPORT_SYMBOL(ext_drv_tsio_se_release_buffer);

td_s32 ext_drv_tsio_se_close(td_handle handle)
{
    td_s32 ret;

    ret = check_handle(handle);
    if (ret != TD_SUCCESS) {
        soc_log_err("invalid handle(0x%x).\n", handle);
        ret = SOC_ERR_TSIO_INVALID_PARA;
        goto out;
    }

    ret = tsio_se_close(handle);

out:
    return ret;
}
EXPORT_SYMBOL(ext_drv_tsio_se_close);

td_s32 ext_drv_tsio_se_destroy(td_handle handle)
{
    td_s32 ret;

    ret = check_handle(handle);
    if (ret != TD_SUCCESS) {
        soc_log_err("invalid handle(0x%x).\n", handle);
        ret = SOC_ERR_TSIO_INVALID_PARA;
        goto out;
    }

    ret = tsio_se_destroy(handle);

out:
    return ret;
}
EXPORT_SYMBOL(ext_drv_tsio_se_destroy);

td_s32 ext_drv_tsio_se_pre_mmap(td_handle handle, td_handle *buf_handle,
    td_u32 *buf_size, td_void **usr_addr)
{
    td_s32 ret;

    ret = check_handle(handle);
    if (ret != TD_SUCCESS) {
        soc_log_err("invalid handle(0x%x).\n", handle);
        ret = SOC_ERR_TSIO_INVALID_PARA;
        goto out;
    }

    if (buf_handle == TD_NULL || buf_size == TD_NULL || usr_addr == TD_NULL) {
        soc_log_err("null pointer, buf_handle(%p), buf_size(%p), usr_addr(%p).\n", buf_handle, buf_size, usr_addr);
        ret = SOC_ERR_TSIO_INVALID_PARA;
        goto out;
    }

    ret = tsio_se_pre_mmap(handle, buf_handle, buf_size, usr_addr);

out:
    return ret;
}
EXPORT_SYMBOL(ext_drv_tsio_se_pre_mmap);

td_s32 ext_drv_tsio_se_pst_mmap(td_handle handle, td_void *buf_usr_addr)
{
    td_s32 ret;

    ret = check_handle(handle);
    if (ret != TD_SUCCESS) {
        soc_log_err("invalid handle(0x%x).\n", handle);
        ret = SOC_ERR_TSIO_INVALID_PARA;
        goto out;
    }

    ret = tsio_se_pst_mmap(handle, buf_usr_addr);

out:
    return ret;
}
EXPORT_SYMBOL(ext_drv_tsio_se_pst_mmap);

td_s32 ext_drv_tsio_cc_send(const td_uchar *cmd, td_u32 cmd_len, td_uchar *resp, td_u32 *resp_len, td_u32 time_out)
{
    td_s32 ret;

    if ((cmd == TD_NULL) || (cmd_len == 0) || (resp == TD_NULL) || (resp_len == TD_NULL)) {
        soc_log_err("invalid parameter.\n");
        ret = SOC_ERR_TSIO_INVALID_PARA;
        goto out;
    }

    if ((cmd_len < MIN_CC_CMD_LEN || *resp_len < MIN_CC_CMD_LEN) ||
        (cmd_len > MAX_CC_CMD_LEN || *resp_len > MAX_CC_CMD_LEN)) {
        soc_log_err("cmd buffer len(%d) or resp buffer len(%d) is invalid.\n", cmd_len, *resp_len);
        ret = SOC_ERR_TSIO_INVALID_PARA;
        goto out;
    }

    ret = tsio_cc_send(cmd, cmd_len, resp, resp_len, time_out);

out:
    return ret;
}
EXPORT_SYMBOL(ext_drv_tsio_cc_send);

td_s32 ext_drv_tsio_suspend(td_void)
{
    return tsio_mgmt_suspend();
}
EXPORT_SYMBOL(ext_drv_tsio_suspend);

td_s32 ext_drv_tsio_resume(td_void)
{
    return tsio_mgmt_resume();
}
EXPORT_SYMBOL(ext_drv_tsio_resume);