You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1000 lines
23 KiB
1000 lines
23 KiB
/*
|
|
* 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);
|
|
|