v811_spc009/vendor/huanglong/custom/amp/drv_amp_common.c

/*
 * Copyright (c) Hisilicon Technologies Co., Ltd.. 2019-2020. All rights reserved.
 * Description: amp common device api
 * Author: audio
 * Create: 2019-12-30
 */

#include "drv_amp_common.h"
#include "osal_ext.h"
#include "soc_errno.h"
#include "drv_amp_debug.h"
#include "drv_proc_ext.h"

#include "drv_amp_osal.h"
#include "linux/huanglong/securec.h"

#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */

#define AMP_INIT_INTERVAL 65 /* delay 65ms */

static td_s32 amp_pull_gpio(const amp_ctrl_gpio *gpio, td_bool dir)
{
    td_s32 ret;
    td_u32 value;

    ret = amp_osal_gpio_set_direction(gpio);
    if (ret != TD_SUCCESS) {
        soc_err_print_call_fun_err(amp_osal_gpio_set_direction, ret);
        return ret;
    }

    osal_msleep(1);

    value = ((dir == TD_TRUE) ? gpio->value : !gpio->value);
    ret = amp_osal_gpio_write_bit(gpio, value);
    if (ret != TD_SUCCESS) {
        soc_err_print_call_fun_err(amp_osal_gpio_write_bit, ret);
        return ret;
    }

    return TD_SUCCESS;
}

td_void drv_amp_dev_hw_mute(const amp_platform_device *dev, td_bool mute)
{
    td_s32 ret;
    if (dev == TD_NULL) {
        return;
    }

    soc_warn_print_u32(dev->mute_gpio.group);
    soc_warn_print_u32(dev->mute_gpio.bit);
    soc_warn_print_u32(dev->mute_gpio.value);
    soc_warn_print_u32(dev->mute_gpio.polarity);
    soc_warn_print_u32(mute);

    if ((dev->mute_gpio.group == GPIO_INVALID) && (dev->mute_gpio.bit == GPIO_INVALID)) {
        soc_log_warn("devid(%d) no need set mute_gpio", dev->dev_id);
        return;
    }

    ret = amp_pull_gpio(&dev->mute_gpio, mute);
    if (ret != TD_SUCCESS) {
        soc_err_print_call_fun_err(amp_pull_gpio, ret);
        return;
    }

    osal_msleep(1);
}

td_void drv_amp_dev_hw_reset(const amp_platform_device *dev, td_bool reset)
{
    td_s32 ret;
    if (dev == TD_NULL) {
        return;
    }

    soc_warn_print_u32(dev->reset_gpio.group);
    soc_warn_print_u32(dev->reset_gpio.bit);
    soc_warn_print_u32(dev->mute_gpio.value);
    soc_warn_print_u32(dev->reset_gpio.polarity);
    soc_warn_print_u32(reset);

    if ((dev->reset_gpio.group == GPIO_INVALID) && (dev->reset_gpio.bit == GPIO_INVALID)) {
        soc_log_warn("devid(%d) no need set reset_gpio", dev->dev_id);
        return;
    }

    ret = amp_pull_gpio(&dev->reset_gpio, reset);
    if (ret != TD_SUCCESS) {
        soc_err_print_call_fun_err(amp_pull_gpio, ret);
        return;
    }

    osal_msleep(AMP_INIT_INTERVAL);
}

td_void drv_amp_dev_write_reg_map(const amp_platform_device *dev,
    drv_amp_reg_map *reg_map)
{
    td_s32 ret;
    td_u32 addr;
    td_u32 size;
    td_u8 delay_ms;
    td_u8 *reg = TD_NULL;

    if (dev == TD_NULL) {
        return;
    }

    while (1) {
        if ((reg_map == TD_NULL) || (reg_map->addr == ENDTBL_FLAG)) {
            return;
        }

        addr = reg_map->addr;
        reg = reg_map->reg;
        size = reg_map->size;
        delay_ms = reg_map->delay_ms;
        ret = amp_osal_i2c_write(&dev->i2c, addr, reg, size);
        if (ret != TD_SUCCESS) {
            soc_err_print_call_fun_err(amp_osal_i2c_write, ret);
            return;
        }

        if (delay_ms != 0) {
            osal_msleep(delay_ms);
        }

        reg_map++;
    }
}

static td_void add_line_to_row_tail(td_u32 space_len, td_void *file)
{
    td_u32 i = 0;
    for (i = 0; i < space_len - 1; i++) {
        if (file == TD_NULL) {
            osal_proc_echo(" ");
        } else {
            osal_seq_printf(file, " ");
        }
    }
    if (file == TD_NULL) {
        osal_proc_echo("%s\n", "|");
    } else {
        osal_seq_printf(file, "%s\n", "|");
    }
}


td_void drv_amp_dev_dump_reg_map(const amp_platform_device *dev, td_void *file,
    const drv_amp_reg_map *reg_map)
{
    td_u32 i;
    td_s32 ret;
    td_u32 addr;
    td_u32 size;
    td_u8 reg[AMP_REG_SIZE_MAX];
    td_u32 space_len;

    if (dev == TD_NULL) {
        return;
    }

    if (file == TD_NULL) {
        osal_proc_echo("%-4s | %-4s | %-108s |\n",
            "addr", "size", "value");
    } else {
        osal_seq_printf(file, "%-4s | %-4s | %-108s |\n",
            "addr", "size", "value");
    }

    while (1) {
        if ((reg_map == TD_NULL) || (reg_map->addr == ENDTBL_FLAG)) {
            return;
        }

        addr = reg_map->addr;
        size = reg_map->size;
        if ((size > AMP_REG_SIZE_MAX) || (size == 0)) {
            return;
        }

        memset_s(reg, AMP_REG_SIZE_MAX, 0, sizeof(reg));

        ret = amp_osal_i2c_read(&dev->i2c, addr, reg, size);
        if (ret != TD_SUCCESS) {
            soc_err_print_call_fun_err(amp_osal_i2c_read, ret);
            return;
        }

        if (file == TD_NULL) {
            osal_proc_echo("0x%02x | %-4d | ", addr, size);
            for (i = 0; i < size; i++) {
                osal_proc_echo("0x%02x ", reg[i]);
            }
        } else {
            osal_proc_print(file, "0x%02x | %-4d | ", addr, size);
            for (i = 0; i < size; i++) {
                osal_seq_printf(file, "0x%02x ", reg[i]);
            }
        }
        space_len = LINE_LENGTH - 14 - size * 5; /* 14 is addr & size len, 5 is len of value */
        add_line_to_row_tail(space_len, file);

        reg_map++;
    }
}


#ifdef __cplusplus
}
#endif /* __cplusplus */