v811_spc009/vendor/huanglong/linux/drv/otp/drv_otp.c

/*
 * Copyright (c) Hisilicon Technologies Co., Ltd. 2019-2021. All rights reserved.
 * Description: Define otp driver
 * Author : Hisilicon
 * Create: 2019/06/19
 */

#include "drv_otp.h"

#include "drv_otp_ext.h"
#include "hal_otp.h"

static struct otp_mgmt g_otp_mgmt = {{0}};

struct otp_mgmt *priv_get_otp_mgmt(td_void)
{
    return &g_otp_mgmt;
}

static otp_export_func g_otp_export_funcs = {
    .write_byte = ext_drv_otp_write_byte,
    .read_byte = ext_drv_otp_read_byte,
};

td_s32 drv_otp_init(td_void)
{
    td_s32 ret;
    struct otp_mgmt *mgmt = priv_get_otp_mgmt();

    ret = osal_mutex_init(&mgmt->lock);
    if (ret != TD_SUCCESS) {
        print_err_func(osal_mutex_init, ret);
        return ret;
    }

    ret = osal_exportfunc_register(SOC_ID_OTP, "SOC_OTP", (td_void *)&g_otp_export_funcs);
    if (ret != TD_SUCCESS) {
        print_err_func(osal_exportfunc_register, ret);
        osal_mutex_destroy(&mgmt->lock);
        return ret;
    }
    soc_print("OTP osal_exportfunc_register success\n");
    return hal_otp_init();
}

td_void drv_otp_deinit(td_void)
{
    struct otp_mgmt *mgmt = priv_get_otp_mgmt();

    hal_otp_deinit();
    osal_exportfunc_unregister(SOC_ID_OTP);
    osal_mutex_destroy(&mgmt->lock);

    return;
}

static td_void _mutex_lock(td_void)
{
    struct otp_mgmt *mgmt = priv_get_otp_mgmt();

    osal_mutex_lock(&mgmt->lock);
}

static td_void _mutex_unlock(td_void)
{
    struct otp_mgmt *mgmt = priv_get_otp_mgmt();

    osal_mutex_unlock(&mgmt->lock);
}

td_s32 otp_open_impl(td_void *private_data)
{
    if (private_data == TD_NULL) {
        return SOC_ERR_OTP_PTR_NULL;
    }

    private_data = (td_void *)(uintptr_t)(td_ulong)osal_get_pid();

    return TD_SUCCESS;
}

td_s32 otp_release_impl(td_void *private_data)
{
    if (private_data == TD_NULL) {
        return SOC_ERR_OTP_PTR_NULL;
    }

    private_data = TD_NULL;

    return TD_SUCCESS;
}

td_s32 ext_drv_otp_reset(td_void)
{
    td_s32 ret;

    _mutex_lock();

    ret = hal_otp_reset();

    _mutex_unlock();
    return ret;
}
EXPORT_SYMBOL(ext_drv_otp_reset);

td_s32 ext_drv_otp_read(td_u32 addr, td_u32 *value)
{
    td_s32 ret;

    _mutex_lock();

    ret = hal_otp_read(addr, value);

    _mutex_unlock();
    return ret;
}
EXPORT_SYMBOL(ext_drv_otp_read);

td_s32 ext_drv_otp_read_byte(td_u32 addr, td_u8 *value)
{
    td_s32 ret;

    _mutex_lock();

    ret = hal_otp_read_byte(addr, value);

    _mutex_unlock();
    return ret;
}
EXPORT_SYMBOL(ext_drv_otp_read_byte);

td_s32 ext_drv_otp_read_bits_onebyte(td_u32 addr, td_u32 start_bit, td_u32 bit_width, td_u8 *value)
{
    td_s32 ret;

    _mutex_lock();

    ret = hal_otp_read_bits_onebyte(addr, start_bit, bit_width, value);

    _mutex_unlock();
    return ret;
}
EXPORT_SYMBOL(hal_otp_read_bits_onebyte);

td_s32 ext_drv_otp_write(td_u32 addr, td_u32 value)
{
    td_s32 ret;

    _mutex_lock();

    ret = hal_otp_write(addr, value);

    _mutex_unlock();
    return ret;
}
EXPORT_SYMBOL(ext_drv_otp_write);

td_s32 ext_drv_otp_write_byte(td_u32 addr, td_u8 value)
{
    td_s32 ret;

    _mutex_lock();

    ret = hal_otp_write_byte(addr, value);

    _mutex_unlock();
    return ret;
}
EXPORT_SYMBOL(ext_drv_otp_write_byte);

td_s32 ext_drv_otp_write_bit(td_u32 addr, td_u32 bit_pos)
{
    td_s32 ret;

    _mutex_lock();

    ret = hal_otp_write_bit(addr, bit_pos);

    _mutex_unlock();
    return ret;
}
EXPORT_SYMBOL(ext_drv_otp_write_bit);

td_s32 ext_drv_otp_write_bits_onebyte(td_u32 addr, td_u32 start_bit, td_u32 bit_width, td_u8 value)
{
    td_s32 ret;

    _mutex_lock();

    ret = hal_otp_write_bits_onebyte(addr, start_bit, bit_width, value);

    _mutex_unlock();
    return ret;
}
EXPORT_SYMBOL(ext_drv_otp_write_bits_onebyte);