hpm_adc.h

Go to the documentation of this file.

/*
 * Copyright (c) 2022 HPMicro
 *
 * SPDX-License-Identifier: BSD-3-Clause
 *
 */
#ifndef HPM_ADC_H
#define HPM_ADC_H
 
#include "hpm_common.h"
#ifdef HPMSOC_HAS_HPMSDK_ADC12
#include "hpm_adc12_drv.h"
#endif
#ifdef HPMSOC_HAS_HPMSDK_ADC16
#include "hpm_adc16_drv.h"
#endif
#include "hpm_soc_feature.h"
typedef union {
#ifdef HPMSOC_HAS_HPMSDK_ADC12
    ADC12_Type *adc12;
#endif
#ifdef HPMSOC_HAS_HPMSDK_ADC16
    ADC16_Type *adc16;
#endif
} adc_base;
 
#define ADCX_MODULE_ADC12 1
#define ADCX_MODULE_ADC16 2
 
typedef enum {
    adc_module_adc12 = ADCX_MODULE_ADC12,
    adc_module_adc16 = ADCX_MODULE_ADC16
} adc_module;
 
typedef struct {
    adc_module module;
    adc_base adc_base;
    struct {
#ifdef HPMSOC_HAS_HPMSDK_ADC12
        adc12_config_t adc12;
#endif
#ifdef HPMSOC_HAS_HPMSDK_ADC16
        adc16_config_t adc16;
#endif
    } config;
} adc_config_t;
 
typedef struct {
    adc_module module;
    adc_base adc_base;
    struct {
#ifdef HPMSOC_HAS_HPMSDK_ADC12
        adc12_channel_config_t adc12_ch;
#endif
#ifdef HPMSOC_HAS_HPMSDK_ADC16
        adc16_channel_config_t adc16_ch;
#endif
    } config;
} adc_channel_config_t;
 
typedef struct {
    adc_module module;
    adc_base adc_base;
    struct {
#ifdef HPMSOC_HAS_HPMSDK_ADC12
        adc12_dma_config_t adc12;
#endif
#ifdef HPMSOC_HAS_HPMSDK_ADC16
        adc16_dma_config_t adc16;
#endif
    } config;
} adc_dma_config_t;
 
typedef struct {
    adc_module module;
    adc_base adc_base;
    struct {
#ifdef HPMSOC_HAS_HPMSDK_ADC12
        adc12_prd_config_t adc12;
#endif
#ifdef HPMSOC_HAS_HPMSDK_ADC16
        adc16_prd_config_t adc16;
#endif
    } config;
} adc_prd_config_t;
 
typedef struct {
    adc_module module;
    adc_base adc_base;
    struct {
#ifdef HPMSOC_HAS_HPMSDK_ADC12
        adc12_seq_config_t adc12;
#endif
#ifdef HPMSOC_HAS_HPMSDK_ADC16
        adc16_seq_config_t adc16;
#endif
    } config;
} adc_seq_config_t;
 
typedef struct {
    adc_module module;
    adc_base adc_base;
    struct {
#ifdef HPMSOC_HAS_HPMSDK_ADC12
        adc12_pmt_config_t adc12;
#endif
#ifdef HPMSOC_HAS_HPMSDK_ADC16
        adc16_pmt_config_t adc16;
#endif
    } config;
} adc_pmt_config_t;
 
 
typedef struct {
    adc_module module;
    adc_base adc_base;
} adc_type;
 
 
 
#ifdef __cplusplus
extern "C" {
#endif
 
static inline void hpm_adc_init_default_config(adc_config_t *config)
{
    if (config->module == adc_module_adc12) {
#ifdef HPMSOC_HAS_HPMSDK_ADC12
        adc12_get_default_config(&config->config.adc12);
#endif
    } else if (config->module == adc_module_adc16) {
#ifdef HPMSOC_HAS_HPMSDK_ADC16
        adc16_get_default_config(&config->config.adc16);
#endif
    }
}
 
static inline void hpm_adc_init_channel_default_config(adc_channel_config_t *config)
{
    if (config->module == adc_module_adc12) {
#ifdef HPMSOC_HAS_HPMSDK_ADC12
        adc12_get_channel_default_config(&config->config.adc12_ch);
#endif
    } else if (config->module == adc_module_adc16) {
#ifdef HPMSOC_HAS_HPMSDK_ADC16
        adc16_get_channel_default_config(&config->config.adc16_ch);
#endif
    }
}
 
static inline hpm_stat_t hpm_adc_init(adc_config_t *config)
{
    if (config->module == adc_module_adc12) {
#ifdef HPMSOC_HAS_HPMSDK_ADC12
        return adc12_init(config->adc_base.adc12, &config->config.adc12);
#else
        return status_invalid_argument;
#endif
    } else if (config->module == adc_module_adc16) {
#ifdef HPMSOC_HAS_HPMSDK_ADC16
        return adc16_init(config->adc_base.adc16, &config->config.adc16);
#else
        return status_invalid_argument;
#endif
    } else {
        return status_invalid_argument;
    }
}
 
static inline hpm_stat_t hpm_adc_channel_init(adc_channel_config_t *config)
{
    if (config->module == adc_module_adc12) {
#ifdef HPMSOC_HAS_HPMSDK_ADC12
        return adc12_init_channel(config->adc_base.adc12, &config->config.adc12_ch);
#else
        return status_invalid_argument;
#endif
    } else if (config->module == adc_module_adc16) {
#ifdef HPMSOC_HAS_HPMSDK_ADC16
        return adc16_init_channel(config->adc_base.adc16, &config->config.adc16_ch);
#else
        return status_invalid_argument;
#endif
    } else {
        return status_invalid_argument;
    }
}
 
static inline hpm_stat_t hpm_adc_set_period_config(adc_prd_config_t *config)
{
    if (config->module == adc_module_adc12) {
#ifdef HPMSOC_HAS_HPMSDK_ADC12
        return adc12_set_prd_config(config->adc_base.adc12, &config->config.adc12);
#else
        return status_invalid_argument;
#endif
    } else if (config->module == adc_module_adc16) {
#ifdef HPMSOC_HAS_HPMSDK_ADC16
        return adc16_set_prd_config(config->adc_base.adc16, &config->config.adc16);
#else
        return status_invalid_argument;
#endif
    } else {
        return status_invalid_argument;
    }
}
 
static inline hpm_stat_t hpm_adc_set_sequence_config(adc_seq_config_t *config)
{
    if (config->module == adc_module_adc12) {
#ifdef HPMSOC_HAS_HPMSDK_ADC12
        return adc12_set_seq_config(config->adc_base.adc12, &config->config.adc12);
#else
        return status_invalid_argument;
#endif
    } else if (config->module == adc_module_adc16) {
#ifdef HPMSOC_HAS_HPMSDK_ADC16
        return adc16_set_seq_config(config->adc_base.adc16, &config->config.adc16);
#else
        return status_invalid_argument;
#endif
    } else {
        return status_invalid_argument;
    }
}
 
static inline hpm_stat_t hpm_adc_set_preempt_config(adc_pmt_config_t *config)
{
    if (config->module == adc_module_adc12) {
#ifdef HPMSOC_HAS_HPMSDK_ADC12
        return adc12_set_pmt_config(config->adc_base.adc12, &config->config.adc12);
#else
        return status_invalid_argument;
#endif
    } else if (config->module == adc_module_adc16) {
#ifdef HPMSOC_HAS_HPMSDK_ADC16
        return adc16_set_pmt_config(config->adc_base.adc16, &config->config.adc16);
#else
        return status_invalid_argument;
#endif
    } else {
        return status_invalid_argument;
    }
}
 
static inline void hpm_adc_set_seq_stop_pos(adc_type *ptr, uint16_t stop_pos)
{
    if (ptr->module == adc_module_adc12) {
#ifdef HPMSOC_HAS_HPMSDK_ADC12
        adc12_set_seq_stop_pos(ptr->adc_base.adc12, stop_pos);
#endif
    } else if (ptr->module == adc_module_adc16) {
#ifdef HPMSOC_HAS_HPMSDK_ADC16
        adc16_set_seq_stop_pos(ptr->adc_base.adc16, stop_pos);
#endif
    }
}
 
static inline void hpm_adc_init_pmt_dma(adc_type *ptr, uint32_t addr)
{
    if (ptr->module == adc_module_adc12) {
#ifdef HPMSOC_HAS_HPMSDK_ADC12
        adc12_init_pmt_dma(ptr->adc_base.adc12, addr);
#endif
    } else if (ptr->module == adc_module_adc16) {
#ifdef HPMSOC_HAS_HPMSDK_ADC16
        adc16_init_pmt_dma(ptr->adc_base.adc16, addr);
#endif
    }
}
 
static inline void hpm_adc_init_seq_dma(adc_dma_config_t *config)
{
    if (config->module == adc_module_adc12) {
#ifdef HPMSOC_HAS_HPMSDK_ADC12
        adc12_init_seq_dma(config->adc_base.adc12, &config->config.adc12);
#endif
    } else if (config->module == adc_module_adc16) {
#ifdef HPMSOC_HAS_HPMSDK_ADC16
        adc16_init_seq_dma(config->adc_base.adc16, &config->config.adc16);
#endif
    }
}
 
static inline void hpm_adc_disable_busywait(adc_dma_config_t *config)
{
    if (config->module == adc_module_adc12) {
#ifdef HPMSOC_HAS_HPMSDK_ADC12
        adc12_disable_busywait(config->adc_base.adc12);
#endif
    } else if (config->module == adc_module_adc16) {
#ifdef HPMSOC_HAS_HPMSDK_ADC16
        adc16_disable_busywait(config->adc_base.adc16);
#endif
    }
}
 
static inline void hpm_adc_enable_busywait(adc_dma_config_t *config)
{
    if (config->module == adc_module_adc12) {
#ifdef HPMSOC_HAS_HPMSDK_ADC12
        adc12_enable_busywait(config->adc_base.adc12);
#endif
    } else if (config->module == adc_module_adc16) {
#ifdef HPMSOC_HAS_HPMSDK_ADC16
        adc16_enable_busywait(config->adc_base.adc16);
#endif
    }
}
 
 
static inline uint32_t hpm_adc_get_status_flags(adc_type *ptr)
{
    if (ptr->module == adc_module_adc12) {
#ifdef HPMSOC_HAS_HPMSDK_ADC12
        return adc12_get_status_flags(ptr->adc_base.adc12);
#else
        return status_invalid_argument;
#endif
    } else if (ptr->module == adc_module_adc16) {
#ifdef HPMSOC_HAS_HPMSDK_ADC16
        return adc16_get_status_flags(ptr->adc_base.adc16);
#else
        return status_invalid_argument;
#endif
    } else {
        return status_invalid_argument;
    }
}
 
static inline bool hpm_adc_get_conv_valid_status(adc_type *ptr, uint8_t ch)
{
    if (ptr->module == adc_module_adc12) {
#ifdef HPMSOC_HAS_HPMSDK_ADC12
        return adc12_get_conv_valid_status(ptr->adc_base.adc12, ch);
#else
        return status_invalid_argument;
#endif
    } else if (ptr->module == adc_module_adc16) {
#ifdef HPMSOC_HAS_HPMSDK_ADC16
        return adc16_get_conv_valid_status(ptr->adc_base.adc16, ch);
#else
        return status_invalid_argument;
#endif
    } else {
        return status_invalid_argument;
    }
}
 
static inline void hpm_adc_clear_status_flags(adc_type *ptr, uint32_t mask)
{
    if (ptr->module == adc_module_adc12) {
#ifdef HPMSOC_HAS_HPMSDK_ADC12
        adc12_clear_status_flags(ptr->adc_base.adc12, mask);
#endif
    } else if (ptr->module == adc_module_adc16) {
#ifdef HPMSOC_HAS_HPMSDK_ADC16
        adc16_clear_status_flags(ptr->adc_base.adc16, mask);
#endif
    }
}
 
static inline void hpm_adc_enable_interrupts(adc_type *ptr, uint32_t mask)
{
    if (ptr->module == adc_module_adc12) {
#ifdef HPMSOC_HAS_HPMSDK_ADC12
        adc12_enable_interrupts(ptr->adc_base.adc12, mask);
#endif
    } else if (ptr->module == adc_module_adc16) {
#ifdef HPMSOC_HAS_HPMSDK_ADC16
        adc16_enable_interrupts(ptr->adc_base.adc16, mask);
#endif
    }
}
 
static inline void hpm_adc_disable_interrupts(adc_type *ptr, uint32_t mask)
{
    if (ptr->module == adc_module_adc12) {
#ifdef HPMSOC_HAS_HPMSDK_ADC12
        adc12_disable_interrupts(ptr->adc_base.adc12, mask);
#endif
    } else if (ptr->module == adc_module_adc16) {
#ifdef HPMSOC_HAS_HPMSDK_ADC16
        adc16_disable_interrupts(ptr->adc_base.adc16, mask);
#endif
    }
}
 
static inline hpm_stat_t hpm_adc_get_oneshot_result(adc_type *ptr, uint8_t ch, uint16_t *result)
{
    if (ptr->module == adc_module_adc12) {
#ifdef HPMSOC_HAS_HPMSDK_ADC12
        return adc12_get_oneshot_result(ptr->adc_base.adc12, ch, result);
#else
        return status_invalid_argument;
#endif
    } else if (ptr->module == adc_module_adc16) {
#ifdef HPMSOC_HAS_HPMSDK_ADC16
        return adc16_get_oneshot_result(ptr->adc_base.adc16, ch, result);
#else
        return status_invalid_argument;
#endif
    } else {
        return status_invalid_argument;
    }
}
 
static inline hpm_stat_t hpm_adc_get_prd_result(adc_type *ptr, uint8_t ch, uint16_t *result)
{
    if (ptr->module == adc_module_adc12) {
#ifdef HPMSOC_HAS_HPMSDK_ADC12
        return adc12_get_prd_result(ptr->adc_base.adc12, ch, result);
#else
        return status_invalid_argument;
#endif
    } else if (ptr->module == adc_module_adc16) {
#ifdef HPMSOC_HAS_HPMSDK_ADC16
        return adc16_get_prd_result(ptr->adc_base.adc16, ch, result);
#else
        return status_invalid_argument;
#endif
    } else {
        return status_invalid_argument;
    }
}
 
static inline hpm_stat_t hpm_adc_trigger_seq_by_sw(adc_type *ptr)
{
     if (ptr->module == adc_module_adc12) {
#ifdef HPMSOC_HAS_HPMSDK_ADC12
        return adc12_trigger_seq_by_sw(ptr->adc_base.adc12);
#endif
    } else if (ptr->module == adc_module_adc16) {
#ifdef HPMSOC_HAS_HPMSDK_ADC16
        return adc16_trigger_seq_by_sw(ptr->adc_base.adc16);
#endif
    } else {
        return status_invalid_argument;
    }
}
 
#ifdef __cplusplus
}
#endif
 
#endif