v811_spc009/vendor/huanglong/uapi/ssm/source/mpi_ssm.c

/*
 * Copyright (c) Hisilicon Technologies Co., Ltd. 2019-2020. All rights reserved.
 * Description: MPI function file for Huanglong SSM
 * Author: ssm group
 * Create: 2019/12/11
 */

#include "mpi_ssm_ext.h"

#include <pthread.h>
#include <fcntl.h>
#include <unistd.h>
#include <limits.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include "securec.h"
#include "soc_log.h"
#include "soc_errno.h"

#undef LOG_MODULE_ID
#define LOG_MODULE_ID SOC_ID_SSM

#define ssm_check_pointer_return_if_fail(pointer) \
    do { \
        if ((pointer) == TD_NULL) { \
            soc_log_err("pointer %s is null\n", #pointer); \
            return SOC_ERR_SSM_NULL_PTR; \
        } \
    } while (0)

#define ssm_lock()   (td_void)pthread_mutex_lock(&g_ssm_locker)
#define ssm_unlock() (td_void)pthread_mutex_unlock(&g_ssm_locker)

#define SOC_DEV_SSM_NAME    "soc_ssm"
#define SSM_DEV_NAME "/dev/" SOC_DEV_SSM_NAME

static td_s32 g_ssm_fd = -1;
static td_s32 g_ssm_open_counter = 0;
static pthread_mutex_t   g_ssm_locker = PTHREAD_MUTEX_INITIALIZER;

td_s32 ext_mpi_ssm_init(td_void)
{
    soc_info_func_enter();
    ssm_lock();
    if (g_ssm_fd != -1) {
        if (g_ssm_open_counter < INT_MAX) {
            g_ssm_open_counter++;
            ssm_unlock();
            soc_log_info("%s %d g_ssm_open_counter=%d\n", __func__, __LINE__, g_ssm_open_counter);
            soc_info_func_exit();
            return TD_SUCCESS;
        }
        ssm_unlock();
        soc_log_err("open ssm too many times\n");
        return TD_FAILURE;
    }

    g_ssm_fd = open(SSM_DEV_NAME, O_RDWR, 0);
    if (g_ssm_fd < 0) {
        soc_log_err("open g_ssm_fd fail:%x", g_ssm_fd);
        ssm_unlock();
        return TD_FAILURE;
    }

    g_ssm_open_counter++;
    ssm_unlock();
    soc_log_info("%s %d g_ssm_open_counter=%d\n", __func__, __LINE__, g_ssm_open_counter);
    soc_info_func_exit();
    return TD_SUCCESS;
}

td_s32 ext_mpi_ssm_deinit(td_void)
{
    soc_info_func_enter();
    ssm_lock();

    if (g_ssm_fd < 0) {
        soc_log_err("cannot deinit ssm:%x", g_ssm_fd);
        ssm_unlock();
        return TD_FAILURE;
    }

    g_ssm_open_counter--;
    if (g_ssm_open_counter == 0) {
        close(g_ssm_fd);
        g_ssm_fd = -1;
    }

    ssm_unlock();
    soc_info_func_exit();
    return TD_SUCCESS;
}

td_s32 ext_mpi_ssm_create(td_handle *session_handle, const ext_ssm_attr *session_attr)
{
    td_s32 ret;
    ssm_ioctl_create create = {0};

    soc_info_func_enter();
    ssm_check_pointer_return_if_fail(session_handle);
    ssm_check_pointer_return_if_fail(session_attr);

    create.intent = session_attr->intent;
    create.ssm_handle = TD_INVALID_HANDLE;

    ret = ioctl(g_ssm_fd, CMD_SSM_CREATE, &create);
    if (ret != TD_SUCCESS) {
        soc_log_err("ioctl to create fail\n");
        return ret;
    }

    *(session_handle) = create.ssm_handle;
    soc_info_func_exit();
    return TD_SUCCESS;
}

td_s32 ext_mpi_ssm_destroy(const td_handle session_handle)
{
    td_s32 ret;
    ssm_ioctl_destroy destroy = {0};

    soc_info_func_enter();
    destroy.ssm_handle = session_handle;

    ret = ioctl(g_ssm_fd, CMD_SSM_DESTROY, &destroy);
    if (ret != TD_SUCCESS) {
        soc_log_err("ioctl to destroy fail\n");
        return ret;
    }
    soc_info_func_exit();
    return TD_SUCCESS;
}

td_s32 ext_mpi_ssm_add_resource(const td_handle session_handle, const ext_ssm_module_resource *resource_info)
{
    td_s32 ret;
    ssm_ioctl_add_resource add_info = {0};

    soc_info_func_enter();
    ssm_check_pointer_return_if_fail(resource_info);

    add_info.ssm_handle = session_handle;
    add_info.res_info.module_handle = resource_info->module_handle;

    ret = ioctl(g_ssm_fd, CMD_SSM_ADD_RESOURCE, &add_info);
    if (ret != TD_SUCCESS) {
        soc_log_err("ioctl to add resource fail\n");
        return ret;
    }
    soc_info_func_exit();
    return TD_SUCCESS;
}

td_s32 ext_mpi_ssm_attach_buffer(const ext_ssm_buffer_attach_info *buf_attach_info, td_u64 *sec_info_addr)
{
    td_s32 ret;
    ssm_ioctl_attach_buffer attach_info = {0};

    soc_info_func_enter();
    ssm_check_pointer_return_if_fail(sec_info_addr);
    ssm_check_pointer_return_if_fail(buf_attach_info);

    attach_info.secure_info_addr = 0;
    ret = memcpy_s(&(attach_info.attach_info), sizeof(attach_info.attach_info),
        buf_attach_info, sizeof(ext_ssm_buffer_attach_info));
    if (ret != TD_SUCCESS) {
        soc_log_err("memcpy attach info fail\n");
        return SOC_ERR_SSM_NO_MEMORY;
    }

    ret = ioctl(g_ssm_fd, CMD_SSM_ATTACH_BUFFER, &attach_info);
    if (ret != TD_SUCCESS) {
        soc_log_err("ioctl attach fail\n");
        return ret;
    }

    (*sec_info_addr) = attach_info.secure_info_addr;
    soc_info_func_exit();
    return TD_SUCCESS;
}

td_s32 ext_mpi_ssm_get_intent(const td_handle session_handle, ext_ssm_intent *intent)
{
    td_s32 ret;
    ssm_ioctl_get_intent get_info = {0};

    soc_info_func_enter();
    ssm_check_pointer_return_if_fail(intent);

    get_info.ssm_handle = session_handle;
    get_info.intent = EXT_SSM_INTENT_MAX;

    ret = ioctl(g_ssm_fd, CMD_SSM_GET_INTENT, &get_info);
    if (ret != TD_SUCCESS) {
        soc_log_err("ioctl get intent fail\n");
        return ret;
    }

    (*intent) = get_info.intent;
    soc_info_func_exit();
    return TD_SUCCESS;
}