Artery_AT32F437_Start_MPyATE_Host/lib/mpyate/src/mpyate_host.c

#include "mpyate_host.h"

#include "private/mpyate_regs.h"

#define ATE_COMPONENT_ID 0xEACE

static ate_ret_t ate_reset(ate_t *ate);
static ate_ret_t ate_read_id(ate_t *ate, uint16_t *id);

static ate_ret_t ate_read_register(ate_t *ate, uint8_t reg, uint16_t *data);
static ate_ret_t ate_write_register(ate_t *ate, uint8_t reg, uint16_t data);

ate_ret_t ate_init(ate_t *ate) {
    ate_ret_t ret = ATE_RET_SUCCESS;

    ret = ate_reset(ate);
    if (ret != ATE_RET_SUCCESS) {
        return ret;
    }

    uint16_t id;

    ret = ate_read_id(ate, &id);
    if (ret != ATE_RET_SUCCESS) {
        return ret;
    }

    if (id != ATE_COMPONENT_ID) {
        ret = ATE_RET_FAIL;
    }

    return ret;
}

ate_ret_t ate_led_set(ate_t *ate, ate_led_t led, bool value) {
    ate_ret_t ret = ATE_RET_SUCCESS;

    uint16_t sys_aux;
    ret = ate_read_register(ate, ATE_REG_SYS_AUX, &sys_aux);
    if (ret != ATE_RET_SUCCESS) {
        return ret;
    }

    if (value) {
        sys_aux |= (1U << led);
    } else {
        sys_aux &= ~(1U << led);
    }

    ret = ate_write_register(ate, ATE_REG_SYS_AUX, sys_aux);
    return ret;
}

ate_ret_t ate_gpio_init(ate_t *ate, uint8_t pin, ate_gpio_mode_t mode) {
    ate_ret_t ret = ATE_RET_SUCCESS;

    uint16_t pin_cfg;
    ret = ate_read_register(ate, ATE_REG_GPIO_CFG, &pin_cfg);
    if (ret != ATE_RET_SUCCESS) {
        return ret;
    }

    pin_cfg &= ~(ATE_REG_GPIO_CFG_MODE_Msk << (2 * pin));
    pin_cfg |= (mode << (2 * pin));

    ret = ate_write_register(ate, ATE_REG_GPIO_CFG, pin_cfg);
    return ret;
}

ate_ret_t ate_gpio_read(ate_t *ate, uint8_t pin, bool *value) {
    ate_ret_t ret = ATE_RET_SUCCESS;

    uint16_t pin_data;
    ret = ate_read_register(ate, ATE_REG_GPIO_INPUT, &pin_data);
    if (ret != ATE_RET_SUCCESS) {
        return ret;
    }

    if (pin_data & (1U << pin)) {
        *value = true;
    } else {
        *value = false;
    }

    return ret;
}

ate_ret_t ate_gpio_write(ate_t *ate, uint8_t pin, bool value) {
    ate_ret_t ret = ATE_RET_SUCCESS;

    uint16_t pin_data;
    ret = ate_read_register(ate, ATE_REG_GPIO_OUTPUT, &pin_data);
    if (ret != ATE_RET_SUCCESS) {
        return ret;
    }

    pin_data &= ~(1U << pin);

    if (value) {
        pin_data |= (1U << pin);
    }

    ret = ate_write_register(ate, ATE_REG_GPIO_OUTPUT, pin_data);
    return ret;
}

ate_ret_t ate_adc_configure(ate_t *ate, bool enable, uint8_t ch_mask) {
    ate_ret_t ret = ATE_RET_SUCCESS;
    uint16_t  data;

    ret = ate_read_register(ate, ATE_REG_ADC_CTRL, &data);
    if (ret != ATE_RET_SUCCESS) {
        return ret;
    }

    if (data & ATE_REG_ADC_CTRL_CONV_Msk) {
        /* If ADC is started, stop first. */
        ret = ate_write_register(ate, ATE_REG_ADC_CTRL, 0x0000U);
        if (ret != ATE_RET_SUCCESS) {
            return ret;
        }
    }

    /* Clear status flag */
    ret = ate_write_register(ate, ATE_REG_ADC_STAT, ATE_REG_ADC_STAT_DONE_Msk);
    if (ret != ATE_RET_SUCCESS) {
        return ret;
    }

    /* Enable ADC */
    data = ATE_REG_ADC_CTRL_CONV_Msk | ch_mask;
    ret  = ate_write_register(ate, ATE_REG_ADC_CTRL, data);
    return ret;
}

ate_ret_t ate_adc_status(ate_t *ate, bool *enable) {
    ate_ret_t ret = ATE_RET_SUCCESS;
    uint16_t  data;

    ret = ate_read_register(ate, ATE_REG_ADC_CTRL, &data);
    if (ret != ATE_RET_SUCCESS) {
        return ret;
    }

    *enable = (data & ATE_REG_ADC_CTRL_CONV_Msk) ? true : false;
    return ret;
}

ate_ret_t ate_adc_read(ate_t *ate, uint8_t ch, uint16_t *result) {
    ate_ret_t ret = ATE_RET_SUCCESS;
    uint16_t  data;

    ret = ate_read_register(ate, ATE_REG_ADC_STAT, &data);
    if (ret != ATE_RET_SUCCESS) {
        return ret;
    }

    if ((data & ATE_REG_ADC_STAT_DONE_Msk) == 0U) {
        return ATE_RET_NOT_READY;
    }

    ret = ate_read_register(ate, ATE_REG_ADC_CH(ch), result);
    if (ret != ATE_RET_SUCCESS) {
        return ret;
    }

    return ret;
}

ate_ret_t ate_dac_set(ate_t *ate, uint16_t da_value) {
    ate_ret_t ret = ATE_RET_SUCCESS;

    ret = ate_write_register(ate, ATE_REG_DAC_DATA, da_value);
    return ret;
}

static ate_ret_t ate_reset(ate_t *ate) {
    ate_ret_t ret = ATE_RET_SUCCESS;

    uint16_t cfg;
    ret = ate_read_register(ate, ATE_REG_SYS_CFG, &cfg);
    if (ret != ATE_RET_SUCCESS) {
        return ret;
    }

    cfg |= ATE_REG_SYS_CFG_RST_Msk;

    ret = ate_write_register(ate, ATE_REG_SYS_CFG, cfg);
    if (ret != ATE_RET_SUCCESS) {
        return ret;
    }

    ret = ate->ops.delay(ate, 120);

    return ret;
}

static ate_ret_t ate_read_id(ate_t *ate, uint16_t *id) {
    return ate_read_register(ate, ATE_REG_SYS_ID, id);
}

static ate_ret_t ate_read_register(ate_t *ate, uint8_t reg, uint16_t *data) {
    ate_ret_t ret = ATE_RET_SUCCESS;

    uint8_t tx_data[2] = {reg, 0x00};
    uint8_t rx_data[2] = {0x00, 0x00};

    ret = ate->ops.write(ate->user_data, tx_data, 0x01);
    if (ret != ATE_RET_SUCCESS) {
        return ret;
    }

    ret = ate->ops.read(ate->user_data, rx_data, 2);
    if (ret != ATE_RET_SUCCESS) {
        return ret;
    }

    *data = rx_data[1] << 8U | rx_data[0];

    return ret;
}

static ate_ret_t ate_write_register(ate_t *ate, uint8_t reg, uint16_t data) {
    ate_ret_t ret = ATE_RET_SUCCESS;

    uint8_t tx_data[3] = {reg, 0x00, 0x00};

    tx_data[1] = data & 0xFFU;
    tx_data[2] = (data >> 8U) & 0xFFU;

    ret = ate->ops.write(ate->user_data, tx_data, 0x03);
    if (ret != ATE_RET_SUCCESS) {
        return ret;
    }

    return ret;
}