vsf_template_adc.h

Go to the documentation of this file.

/*****************************************************************************
 *   Copyright(C)2009-2022 by VSF Team                                       *
 *                                                                           *
 *  Licensed under the Apache License, Version 2.0 (the "License");          *
 *  you may not use this file except in compliance with the License.         *
 *  You may obtain a copy of the License at                                  *
 *                                                                           *
 *     http://www.apache.org/licenses/LICENSE-2.0                            *
 *                                                                           *
 *  Unless required by applicable law or agreed to in writing, software      *
 *  distributed under the License is distributed on an "AS IS" BASIS,        *
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. *
 *  See the License for the specific language governing permissions and      *
 *  limitations under the License.                                           *
 *                                                                           *
 ****************************************************************************/
 
#ifndef __VSF_TEMPLATE_ADC_H__
#define __VSF_TEMPLATE_ADC_H__
 
/*============================ INCLUDES ======================================*/
 
#include "./vsf_template_hal_driver.h"
#include "hal/arch/vsf_arch.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
/*============================ MACROS ========================================*/
 
#ifndef VSF_ADC_CFG_MULTI_CLASS
#   define VSF_ADC_CFG_MULTI_CLASS                      ENABLED
#endif
 
#if defined(VSF_HW_ADC_COUNT) && !defined(VSF_HW_ADC_MASK)
#   define VSF_HW_ADC_MASK                              VSF_HAL_COUNT_TO_MASK(VSF_HW_ADC_COUNT)
#endif
 
#if defined(VSF_HW_ADC_MASK) && !defined(VSF_HW_ADC_COUNT)
#   define VSF_HW_ADC_COUNT                             VSF_HAL_MASK_TO_COUNT(VSF_HW_ADC_MASK)
#endif
 
#ifndef VSF_ADC_CFG_PREFIX
#   if VSF_ADC_CFG_MULTI_CLASS == ENABLED
#       define VSF_ADC_CFG_PREFIX                       vsf
#   elif defined(VSF_HW_ADC_COUNT) && (VSF_HW_ADC_COUNT != 0)
#       define VSF_ADC_CFG_PREFIX                       vsf_hw
#   else
#       define VSF_ADC_CFG_PREFIX                       vsf
#   endif
#endif
 
#ifndef VSF_ADC_CFG_FUNCTION_RENAME
#   define VSF_ADC_CFG_FUNCTION_RENAME                  ENABLED
#endif
 
#ifndef VSF_ADC_CFG_REIMPLEMENT_TYPE_MODE
#   define VSF_ADC_CFG_REIMPLEMENT_TYPE_MODE            DISABLED
#endif
 
#ifndef VSF_ADC_CFG_REIMPLEMENT_TYPE_CHANNEL_MODE
#   define VSF_ADC_CFG_REIMPLEMENT_TYPE_CHANNEL_MODE    DISABLED
#endif
 
#ifndef VSF_ADC_CFG_REIMPLEMENT_TYPE_IRQ_MASK
#   define VSF_ADC_CFG_REIMPLEMENT_TYPE_IRQ_MASK        DISABLED
#endif
 
#ifndef VSF_ADC_CFG_REIMPLEMENT_TYPE_CHANNEL_CFG
#    define VSF_ADC_CFG_REIMPLEMENT_TYPE_CHANNEL_CFG DISABLED
#endif
 
#ifndef VSF_ADC_CFG_REIMPLEMENT_TYPE_CFG
#    define VSF_ADC_CFG_REIMPLEMENT_TYPE_CFG DISABLED
#endif
 
#ifndef VSF_ADC_CFG_REIMPLEMENT_TYPE_CAPABILITY
#    define VSF_ADC_CFG_REIMPLEMENT_TYPE_CAPABILITY DISABLED
#endif
 
#ifndef VSF_ADC_CFG_REIMPLEMENT_TYPE_STATUS
#   define VSF_ADC_CFG_REIMPLEMENT_TYPE_STATUS        DISABLED
#endif
 
#ifndef VSF_ADC_CFG_INHERIT_HAL_CAPABILITY
#   define VSF_ADC_CFG_INHERIT_HAL_CAPABILITY            ENABLED
#endif
 
/*============================ MACROFIED FUNCTIONS ===========================*/
 
#define VSF_ADC_APIS(__prefix_name) \
    __VSF_HAL_TEMPLATE_API(__prefix_name, vsf_err_t,            adc, init,                 VSF_MCONNECT(__prefix_name, _t) *adc_ptr, vsf_adc_cfg_t *cfg_ptr) \
    __VSF_HAL_TEMPLATE_API(__prefix_name, void,                 adc, fini,                 VSF_MCONNECT(__prefix_name, _t) *adc_ptr) \
    __VSF_HAL_TEMPLATE_API(__prefix_name, vsf_err_t,            adc, get_configuration,    VSF_MCONNECT(__prefix_name, _t) *adc_ptr, vsf_adc_cfg_t *cfg_ptr) \
    __VSF_HAL_TEMPLATE_API(__prefix_name, fsm_rt_t,             adc, enable,               VSF_MCONNECT(__prefix_name, _t) *adc_ptr) \
    __VSF_HAL_TEMPLATE_API(__prefix_name, fsm_rt_t,             adc, disable,              VSF_MCONNECT(__prefix_name, _t) *adc_ptr) \
    __VSF_HAL_TEMPLATE_API(__prefix_name, vsf_adc_status_t,     adc, status,               VSF_MCONNECT(__prefix_name, _t) *adc_ptr) \
    __VSF_HAL_TEMPLATE_API(__prefix_name, vsf_adc_capability_t, adc, capability,           VSF_MCONNECT(__prefix_name, _t) *adc_ptr) \
    __VSF_HAL_TEMPLATE_API(__prefix_name, void,                 adc, irq_enable,           VSF_MCONNECT(__prefix_name, _t) *adc_ptr, vsf_adc_irq_mask_t irq_mask) \
    __VSF_HAL_TEMPLATE_API(__prefix_name, void,                 adc, irq_disable,          VSF_MCONNECT(__prefix_name, _t) *adc_ptr, vsf_adc_irq_mask_t irq_mask) \
    __VSF_HAL_TEMPLATE_API(__prefix_name, vsf_adc_irq_mask_t,   adc, irq_clear,            VSF_MCONNECT(__prefix_name, _t) *adc_ptr, vsf_adc_irq_mask_t irq_mask) \
    __VSF_HAL_TEMPLATE_API(__prefix_name, vsf_err_t,            adc, channel_request_once, VSF_MCONNECT(__prefix_name, _t) *adc_ptr, vsf_adc_channel_cfg_t *channel_cfg, void *buffer_ptr) \
    __VSF_HAL_TEMPLATE_API(__prefix_name, vsf_err_t,            adc, channel_config,       VSF_MCONNECT(__prefix_name, _t) *adc_ptr, vsf_adc_channel_cfg_t *channel_cfgs_ptr, uint32_t channel_cfgs_cnt) \
    __VSF_HAL_TEMPLATE_API(__prefix_name, vsf_err_t,            adc, channel_request,      VSF_MCONNECT(__prefix_name, _t) *adc_ptr, void *buffer_ptr, uint_fast32_t count) \
    __VSF_HAL_TEMPLATE_API(__prefix_name, vsf_err_t,            adc, ctrl,                 VSF_MCONNECT(__prefix_name, _t) *adc_ptr, vsf_adc_ctrl_t ctrl, void* param)
 
/*============================ TYPES =========================================*/
 
#if VSF_ADC_CFG_REIMPLEMENT_TYPE_MODE == DISABLED
typedef enum vsf_adc_mode_t {
    VSF_ADC_REF_VDD_1               = (0 << 0),
 
    VSF_ADC_REF_VDD_1_2             = (1 << 0),
 
    VSF_ADC_REF_VDD_1_3             = (2 << 0),
 
    VSF_ADC_REF_VDD_1_4             = (3 << 0),
 
    VSF_ADC_DATA_ALIGN_RIGHT        = (0 << 2),
 
    VSF_ADC_DATA_ALIGN_LEFT         = (1 << 2),
 
    VSF_ADC_SCAN_CONV_SINGLE_MODE   = (0 << 3),
 
    VSF_ADC_SCAN_CONV_SEQUENCE_MODE = (1 << 3),
 
    VSF_ADC_EXTERN_TRIGGER_0        = (0 << 4),
 
    VSF_ADC_EXTERN_TRIGGER_1        = (1 << 4),
 
    VSF_ADC_EXTERN_TRIGGER_2        = (2 << 4),
} vsf_adc_mode_t;
#endif
 
enum {
    VSF_ADC_REF_VDD_COUNT           = 4,
    VSF_ADC_REF_VDD_MASK            = VSF_ADC_REF_VDD_1 |
                                      VSF_ADC_REF_VDD_1_2 |
                                      VSF_ADC_REF_VDD_1_3 |
                                      VSF_ADC_REF_VDD_1_4,
 
    VSF_ADC_DATA_ALIGN_COUNT        = 2,
    VSF_ADC_DATA_ALIGN_MASK         = VSF_ADC_DATA_ALIGN_RIGHT |
                                      VSF_ADC_DATA_ALIGN_LEFT,
 
    VSF_ADC_SCAN_CONV_COUNT         = 2,
    VSF_ADC_SCAN_CONV_MASK          = VSF_ADC_SCAN_CONV_SINGLE_MODE |
                                      VSF_ADC_SCAN_CONV_SEQUENCE_MODE,
 
    VSF_ADC_EXTERN_TRIGGER_COUNT    = 3,
    VSF_ADC_EXTERN_TRIGGER_MASK     = VSF_ADC_EXTERN_TRIGGER_0 |
                                      VSF_ADC_EXTERN_TRIGGER_1 |
                                      VSF_ADC_EXTERN_TRIGGER_2,
 
    VSF_ADC_MODE_MASK_COUNT         = 4,
    VSF_ADC_MODE_ALL_BITS_MASK      = VSF_ADC_REF_VDD_MASK |
                                      VSF_ADC_DATA_ALIGN_MASK |
                                      VSF_ADC_SCAN_CONV_MASK |
                                      VSF_ADC_EXTERN_TRIGGER_MASK,
};
 
#if VSF_ADC_CFG_REIMPLEMENT_TYPE_CHANNEL_MODE == DISABLED
typedef enum vsf_adc_channel_mode_t {
    VSF_ADC_CHANNEL_GAIN_1_6        = (0 << 0),
 
    VSF_ADC_CHANNEL_GAIN_1_5        = (1 << 0),
 
    VSF_ADC_CHANNEL_GAIN_1_4        = (2 << 0),
 
    VSF_ADC_CHANNEL_GAIN_1_3        = (3 << 0),
 
    VSF_ADC_CHANNEL_GAIN_1_2        = (4 << 0),
 
    VSF_ADC_CHANNEL_GAIN_1          = (5 << 0),
 
    VSF_ADC_CHANNEL_REF_VDD_1       = (0 << 4),
 
    VSF_ADC_CHANNEL_REF_VDD_1_2     = (1 << 4),
 
    VSF_ADC_CHANNEL_REF_VDD_1_3     = (2 << 4),
 
    VSF_ADC_CHANNEL_REF_VDD_1_4     = (3 << 4),
} vsf_adc_channel_mode_t;
#endif
 
enum {
    VSF_ADC_CHANNEL_GAIN_COUNT      = 6,
    VSF_ADC_CHANNEL_GAIN_MASK       = VSF_ADC_CHANNEL_GAIN_1_6 |
                                      VSF_ADC_CHANNEL_GAIN_1_5 |
                                      VSF_ADC_CHANNEL_GAIN_1_4 |
                                      VSF_ADC_CHANNEL_GAIN_1_3 |
                                      VSF_ADC_CHANNEL_GAIN_1_2 |
                                      VSF_ADC_CHANNEL_GAIN_1,
 
    VSF_ADC_CHANNEL_REF_VDD_COUNT   = 4,
    VSF_ADC_CHANNEL_REF_VDD_MASK    = VSF_ADC_CHANNEL_REF_VDD_1 |
                                      VSF_ADC_CHANNEL_REF_VDD_1_2 |
                                      VSF_ADC_CHANNEL_REF_VDD_1_3 |
                                      VSF_ADC_CHANNEL_REF_VDD_1_4,
 
    VSF_ADC_CHANNEL_MODE_MASK_COUNT = 2,
    VSF_ADC_CHANNEL_MODE_ALL_BITS_MASK
                                    = VSF_ADC_CHANNEL_GAIN_MASK |
                                      VSF_ADC_CHANNEL_REF_VDD_MASK,
};
 
#if VSF_ADC_CFG_REIMPLEMENT_TYPE_IRQ_MASK == DISABLED
typedef enum vsf_adc_irq_mask_t {
    VSF_ADC_IRQ_MASK_CPL = (0x1ul << 0),  
} vsf_adc_irq_mask_t;
#endif
 
enum {
    VSF_ADC_IRQ_COUNT               = 1,
    VSF_ADC_IRQ_ALL_BITS_MASK       = VSF_ADC_IRQ_MASK_CPL,
};
 
#if VSF_ADC_CFG_REIMPLEMENT_TYPE_CHANNEL_CFG == DISABLED
typedef struct vsf_adc_channel_cfg_t {
    vsf_adc_channel_mode_t mode;    
    uint16_t sample_cycles;         
    uint8_t  channel;               
} vsf_adc_channel_cfg_t;
#endif
 
#if VSF_ADC_CFG_REIMPLEMENT_TYPE_CFG == DISABLED
typedef struct vsf_adc_t vsf_adc_t;
typedef void vsf_adc_isr_handler_t(void *target_ptr,
                                   vsf_adc_t *adc_ptr,
                                   vsf_adc_irq_mask_t irq_mask);
typedef struct vsf_adc_isr_t {
    vsf_adc_isr_handler_t  *handler_fn;
    void                   *target_ptr;
    vsf_arch_prio_t         prio;
} vsf_adc_isr_t;
 
typedef struct vsf_adc_cfg_t {
    vsf_adc_mode_t  mode;           
    vsf_adc_isr_t   isr;            
    uint32_t        clock_hz;       
} vsf_adc_cfg_t;
#endif
 
#if VSF_ADC_CFG_REIMPLEMENT_TYPE_STATUS == DISABLED
typedef struct vsf_adc_status_t {
    union {
        inherit(vsf_peripheral_status_t)
        struct {
            uint32_t is_busy : 1;
        };
        uint32_t value;
    };
} vsf_adc_status_t;
#endif
 
#if VSF_ADC_CFG_REIMPLEMENT_TYPE_CAPABILITY == DISABLED
typedef struct vsf_adc_capability_t {
#if VSF_ADC_CFG_INHERIT_HAL_CAPABILITY == ENABLED
    inherit(vsf_peripheral_capability_t)
#endif
    vsf_adc_irq_mask_t irq_mask;
 
    uint8_t max_data_bits;
    uint8_t channel_count;
} vsf_adc_capability_t;
#endif
 
#if VSF_ADC_CFG_REIMPLEMENT_TYPE_CTRL == DISABLED
typedef enum vsf_adc_ctrl_t {
    __VSF_ADC_CTRL_DUMMY = 0,
} vsf_adc_ctrl_t;
#endif
 
typedef struct vsf_adc_op_t {
#undef  __VSF_HAL_TEMPLATE_API
#define __VSF_HAL_TEMPLATE_API VSF_HAL_TEMPLATE_API_FP
 
    VSF_ADC_APIS(vsf_adc)
} vsf_adc_op_t;
 
#if VSF_ADC_CFG_MULTI_CLASS == ENABLED
struct vsf_adc_t  {
    const vsf_adc_op_t * op;
};
#endif
 
/*============================ PROTOTYPES ====================================*/
 
extern vsf_err_t vsf_adc_init(vsf_adc_t *adc_ptr, vsf_adc_cfg_t *cfg_ptr);
 
extern void vsf_adc_fini(vsf_adc_t *adc_ptr);
 
extern vsf_err_t vsf_adc_get_configuration(vsf_adc_t *adc_ptr, vsf_adc_cfg_t *cfg_ptr);
 
extern fsm_rt_t vsf_adc_enable(vsf_adc_t *adc_ptr);
 
extern fsm_rt_t vsf_adc_disable(vsf_adc_t *adc_ptr);
 
extern void vsf_adc_irq_enable(vsf_adc_t *adc_ptr, vsf_adc_irq_mask_t irq_mask);
 
extern void vsf_adc_irq_disable(vsf_adc_t *adc_ptr, vsf_adc_irq_mask_t irq_mask);
 
extern vsf_adc_irq_mask_t vsf_adc_irq_clear(vsf_adc_t *adc_ptr, vsf_adc_irq_mask_t irq_mask);
 
extern vsf_adc_status_t vsf_adc_status(vsf_adc_t *adc_ptr);
 
extern vsf_adc_capability_t vsf_adc_capability(vsf_adc_t *adc_ptr);
 
extern vsf_err_t vsf_adc_channel_request_once(vsf_adc_t *adc_ptr,
                                              vsf_adc_channel_cfg_t *channel_cfg,
                                              void *buffer_ptr);
 
extern vsf_err_t vsf_adc_channel_config(vsf_adc_t *adc_ptr,
                                        vsf_adc_channel_cfg_t *cfgs_ptr,
                                        uint32_t cnt);
 
extern vsf_err_t vsf_adc_channel_request(vsf_adc_t *adc_ptr,
                                         void *buffer_ptr,
                                         uint_fast32_t count);
 
extern vsf_err_t vsf_adc_ctrl(vsf_adc_t *adc_ptr, vsf_adc_ctrl_t ctrl, void *param);
 
/*============================ MACROFIED FUNCTIONS ===========================*/
 
#if VSF_ADC_CFG_FUNCTION_RENAME == ENABLED
#   define __vsf_adc_t                              VSF_MCONNECT(VSF_ADC_CFG_PREFIX, _adc_t)
#   define vsf_adc_init(__ADC, ...)                 VSF_MCONNECT(VSF_ADC_CFG_PREFIX, _adc_init)                 ((__vsf_adc_t *)(__ADC), ##__VA_ARGS__)
#   define vsf_adc_fini(__ADC)                      VSF_MCONNECT(VSF_ADC_CFG_PREFIX, _adc_fini)                 ((__vsf_adc_t *)(__ADC))
#   define vsf_adc_get_configuration(__ADC, ...)    VSF_MCONNECT(VSF_ADC_CFG_PREFIX, _adc_get_configuration)    ((__vsf_adc_t *)(__ADC), ##__VA_ARGS__)
#   define vsf_adc_enable(__ADC)                    VSF_MCONNECT(VSF_ADC_CFG_PREFIX, _adc_enable)               ((__vsf_adc_t *)(__ADC))
#   define vsf_adc_disable(__ADC)                   VSF_MCONNECT(VSF_ADC_CFG_PREFIX, _adc_disable)              ((__vsf_adc_t *)(__ADC))
#   define vsf_adc_status(__ADC)                    VSF_MCONNECT(VSF_ADC_CFG_PREFIX, _adc_status)               ((__vsf_adc_t *)(__ADC))
#   define vsf_adc_capability(__ADC)                VSF_MCONNECT(VSF_ADC_CFG_PREFIX, _adc_capability)           ((__vsf_adc_t *)(__ADC))
#   define vsf_adc_irq_enable(__ADC, ...)           VSF_MCONNECT(VSF_ADC_CFG_PREFIX, _adc_irq_enable)           ((__vsf_adc_t *)(__ADC), ##__VA_ARGS__)
#   define vsf_adc_irq_disable(__ADC, ...)          VSF_MCONNECT(VSF_ADC_CFG_PREFIX, _adc_irq_disable)          ((__vsf_adc_t *)(__ADC), ##__VA_ARGS__)
#   define vsf_adc_irq_clear(__ADC, ...)            VSF_MCONNECT(VSF_ADC_CFG_PREFIX, _adc_irq_clear)             ((__vsf_adc_t *)(__ADC), ##__VA_ARGS__)
#   define vsf_adc_channel_request_once(__ADC, ...) VSF_MCONNECT(VSF_ADC_CFG_PREFIX, _adc_channel_request_once) ((__vsf_adc_t *)(__ADC), ##__VA_ARGS__)
#   define vsf_adc_channel_config(__ADC, ...)       VSF_MCONNECT(VSF_ADC_CFG_PREFIX, _adc_channel_config)       ((__vsf_adc_t *)(__ADC), ##__VA_ARGS__)
#   define vsf_adc_channel_request(__ADC, ...)      VSF_MCONNECT(VSF_ADC_CFG_PREFIX, _adc_channel_request)      ((__vsf_adc_t *)(__ADC), ##__VA_ARGS__)
#   define vsf_adc_ctrl(__ADC, ...)                 VSF_MCONNECT(VSF_ADC_CFG_PREFIX, _adc_ctrl)                 ((__vsf_adc_t *)(__ADC), ##__VA_ARGS__)
#endif
 
#ifdef __cplusplus
}
#endif
 
#endif  /*__VSF_TEMPLATE_ADC_H__*/