vsf_template_exti.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_EXTI_H__
#define __VSF_TEMPLATE_EXTI_H__
 
/*============================ INCLUDES ======================================*/
 
#include "./vsf_template_hal_driver.h"
#include "hal/arch/vsf_arch.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
/*============================ MACROS ========================================*/
 
#ifndef VSF_EXTI_CFG_MULTI_CLASS
#   define VSF_EXTI_CFG_MULTI_CLASS                 ENABLED
#endif
 
#if defined(VSF_HW_EXTI_COUNT) && !defined(VSF_HW_EXTI_MASK)
#   define VSF_HW_EXTI_MASK                         VSF_HAL_COUNT_TO_MASK(VSF_HW_EXTI_COUNT)
#endif
 
#if defined(VSF_HW_EXTI_MASK) && !defined(VSF_HW_EXTI_COUNT)
#   define VSF_HW_EXTI_COUNT                        VSF_HAL_MASK_TO_COUNT(VSF_HW_EXTI_MASK)
#endif
 
#if defined(VSF_HW_EXTI_CHANNEL_COUNT) && !defined(VSF_HW_EXTI_CHANNEL_MASK)
#   define VSF_HW_EXTI_CHANNEL_MASK                 VSF_HAL_COUNT_TO_MASK(VSF_HW_EXTI_CHANNEL_COUNT)
#endif
 
#if defined(VSF_HW_EXTI_CHANNEL_MASK) && !defined(VSF_HW_EXTI_CHANNEL_COUNT)
#   define VSF_HW_EXTI_CHANNEL_COUNT                VSF_HAL_MASK_TO_COUNT(VSF_HW_EXTI_CHANNEL_MASK)
#endif
 
#ifndef VSF_EXTI_CFG_PREFIX
#   if VSF_EXTI_CFG_MULTI_CLASS == ENABLED
#       define VSF_EXTI_CFG_PREFIX                  vsf
#   elif defined(VSF_HW_EXTI_CHANNEL_MASK) && (VSF_HW_EXTI_CHANNEL_MASK != 0)
#       define VSF_EXTI_CFG_PREFIX                  vsf_hw
#   else
#       define VSF_EXTI_CFG_PREFIX                  vsf
#   endif
#endif
 
#ifndef VSF_EXTI_CFG_REIMPLEMENT_TYPE_MODE
#   define VSF_EXTI_CFG_REIMPLEMENT_TYPE_MODE       DISABLED
#endif
 
#ifndef VSF_EXTI_CFG_FUNCTION_RENAME
#   define VSF_EXTI_CFG_FUNCTION_RENAME             ENABLED
#endif
 
 
#ifndef VSF_EXTI_CFG_REIMPLEMENT_TYPE_CFG
#    define VSF_EXTI_CFG_REIMPLEMENT_TYPE_CFG       DISABLED
#endif
 
#ifndef VSF_EXTI_CFG_REIMPLEMENT_TYPE_CAPABILITY
#    define VSF_EXTI_CFG_REIMPLEMENT_TYPE_CAPABILITY DISABLED
#endif
 
 
#ifndef VSF_EXTI_CFG_INHERIT_HAL_CAPABILITY
#   define VSF_EXTI_CFG_INHERIT_HAL_CAPABILITY       ENABLED
#endif
 
#ifndef VSF_EXTI_CFG_REIMPLEMENT_TYPE_CTRL
#   define VSF_EXTI_CFG_REIMPLEMENT_TYPE_CTRL        DISABLED
#endif
 
/*============================ MACROFIED FUNCTIONS ===========================*/
 
#define VSF_EXTI_APIS(__prefix_name)                                                                                                                                                                \
    __VSF_HAL_TEMPLATE_API(__prefix_name, vsf_err_t,                exti, init,             VSF_MCONNECT(__prefix_name, _t) *exti_ptr)                                                              \
    __VSF_HAL_TEMPLATE_API(__prefix_name, void,                     exti, fini,             VSF_MCONNECT(__prefix_name, _t) *exti_ptr)                                                              \
    __VSF_HAL_TEMPLATE_API(__prefix_name, vsf_exti_status_t,        exti, status,           VSF_MCONNECT(__prefix_name, _t) *exti_ptr)                                                              \
    __VSF_HAL_TEMPLATE_API(__prefix_name, vsf_exti_capability_t,    exti, capability,       VSF_MCONNECT(__prefix_name, _t) *exti_ptr)                                                              \
    __VSF_HAL_TEMPLATE_API(__prefix_name, vsf_err_t,                exti, trigger,          VSF_MCONNECT(__prefix_name, _t) *exti_ptr, vsf_exti_channel_mask_t channel_mask)                        \
    __VSF_HAL_TEMPLATE_API(__prefix_name, vsf_err_t,                exti, config_channels,  VSF_MCONNECT(__prefix_name, _t) *exti_ptr, vsf_exti_channel_mask_t channel_mask, vsf_exti_channel_cfg_t * cfg_ptr)\
    __VSF_HAL_TEMPLATE_API(__prefix_name, vsf_err_t,                exti, irq_enable,       VSF_MCONNECT(__prefix_name, _t) *exti_ptr, vsf_exti_channel_mask_t channel_mask)                        \
    __VSF_HAL_TEMPLATE_API(__prefix_name, vsf_err_t,                exti, irq_disable,      VSF_MCONNECT(__prefix_name, _t) *exti_ptr, vsf_exti_channel_mask_t channel_mask)                        \
    __VSF_HAL_TEMPLATE_API(__prefix_name, vsf_exti_channel_mask_t, exti, irq_clear,         VSF_MCONNECT(__prefix_name, _t) *exti_ptr, vsf_exti_channel_mask_t channel_mask) \
    __VSF_HAL_TEMPLATE_API(__prefix_name, vsf_err_t,                exti, ctrl,             VSF_MCONNECT(__prefix_name, _t) *exti_ptr, vsf_exti_ctrl_t ctrl, void* param)
 
/*============================ TYPES =========================================*/
 
#ifndef vsf_exti_channel_mask_t
#   if defined(VSF_HW_EXTI_CHANNEL_COUNT) && (VSF_HW_EXTI_CHANNEL_COUNT > 32)
typedef uint64_t vsf_exti_channel_mask_t;
#   elif defined(VSF_HW_EXTI_CHANNEL_MASK) && (VSF_HW_EXTI_CHANNEL_MASK & 0xFFFFFFFF00000000)
typedef uint64_t vsf_exti_channel_mask_t;
#   else
typedef uint32_t vsf_exti_channel_mask_t;
#   endif
#   define vsf_exti_channel_mask_t vsf_exti_channel_mask_t
#endif
 
#if VSF_EXTI_CFG_REIMPLEMENT_TYPE_MODE == DISABLED
typedef enum vsf_exti_mode_t {
    VSF_EXTI_MODE_NONE                  = (0 << 0),
 
    VSF_EXTI_MODE_RISING                = (3 << 0),
 
    VSF_EXTI_MODE_FALLING               = (4 << 0),
 
    VSF_EXTI_MODE_EDGE_RISING_FALLING   = VSF_EXTI_MODE_RISING | VSF_EXTI_MODE_FALLING,
 
    VSF_EXTI_MODE_LOW_LEVEL             = (1 << 0),
#define VSF_EXTI_MODE_LOW_LEVEL         VSF_EXTI_MODE_LOW_LEVEL
 
    VSF_EXTI_MODE_HIGH_LEVEL            = (2 << 0),
#define VSF_EXTI_MODE_HIGH_LEVEL        VSF_EXTI_MODE_HIGH_LEVEL
} vsf_exti_mode_t;
#endif
 
enum {
    VSF_EXTI_MODE_MASK                  = VSF_EXTI_MODE_NONE
#ifdef VSF_EXTI_MODE_LOW_LEVEL
                                        | VSF_EXTI_MODE_LOW_LEVEL
#endif
#ifdef VSF_EXTI_MODE_HIGH_LEVEL
                                        | VSF_EXTI_MODE_HIGH_LEVEL
#endif
                                        | VSF_EXTI_MODE_RISING
                                        | VSF_EXTI_MODE_FALLING
                                        | VSF_EXTI_MODE_RISING_FALLING,
};
 
#if VSF_EXTI_CFG_REIMPLEMENT_TYPE_CFG == DISABLED
typedef struct vsf_exti_t vsf_exti_t;
 
typedef void vsf_exti_isr_handler_t(void *target_ptr, vsf_exti_t *exti_ptr,
                                         vsf_exti_channel_mask_t channel_mask);
 
typedef struct vsf_exti_channel_cfg_t {
    vsf_exti_mode_t             mode;
    vsf_exti_isr_handler_t      *handler_fn;
    void                        *target_ptr;
    vsf_arch_prio_t              prio;
} vsf_exti_channel_cfg_t;
#endif
 
#if VSF_EXTI_CFG_REIMPLEMENT_TYPE_STATUS == DISABLED
typedef struct vsf_exti_status_t {
    vsf_exti_channel_mask_t     enable_mask;
    vsf_exti_channel_mask_t     status_mask;
} vsf_exti_status_t;
#endif
 
#if VSF_EXTI_CFG_REIMPLEMENT_TYPE_CTRL == DISABLED
typedef enum vsf_exti_ctrl_t {
    __VSF_EXTI_CTRL_DUMMY = 0,
} vsf_exti_ctrl_t;
#endif
 
#if VSF_EXTI_CFG_REIMPLEMENT_TYPE_CAPABILITY == DISABLED
typedef struct vsf_exti_capability_t {
#if VSF_EXTI_CFG_INHERIT_HAL_CAPABILITY == ENABLED
    inherit(vsf_peripheral_capability_t)
#endif
 
    uint8_t support_level_trigger   : 1;
 
    uint8_t support_edge_trigger    : 1;
 
    uint8_t support_sw_trigger      : 1;
 
    uint8_t irq_num;
 
    vsf_exti_channel_mask_t channel_mask;
 
    vsf_exti_channel_mask_t irq_channel_mask[0];
} vsf_exti_capability_t;
#endif
 
typedef struct vsf_exti_op_t {
#undef __VSF_HAL_TEMPLATE_API
#define __VSF_HAL_TEMPLATE_API VSF_HAL_TEMPLATE_API_FP
 
    VSF_EXTI_APIS(vsf_exti)
} vsf_exti_op_t;
 
#if VSF_EXTI_CFG_MULTI_CLASS == ENABLED
struct vsf_exti_t  {
    const vsf_exti_op_t * op;
};
#endif
 
/*============================ GLOBAL VARIABLES ==============================*/
/*============================ MACROFIED FUNCTIONS ===========================*/
/*============================ PROTOTYPES ====================================*/
 
extern vsf_err_t vsf_exti_init(vsf_exti_t *exti_ptr);
 
extern void vsf_exti_fini(vsf_exti_t *exti_ptr);
 
extern vsf_err_t vsf_exti_trigger(vsf_exti_t *exti_ptr, vsf_exti_channel_mask_t  channel_mask);
 
extern vsf_exti_status_t vsf_exti_status(vsf_exti_t *exti_ptr);
 
extern vsf_err_t vsf_exti_config_channels(vsf_exti_t                *exti_ptr,
                                           vsf_exti_channel_mask_t  channel_mask,
                                           vsf_exti_channel_cfg_t   *cfg_ptr);
 
extern vsf_exti_capability_t vsf_exti_capability(vsf_exti_t *exti_ptr);
 
extern vsf_err_t vsf_exti_irq_enable(vsf_exti_t *exti_ptr, vsf_exti_channel_mask_t channel_mask);
 
extern vsf_err_t vsf_exti_irq_disable(vsf_exti_t *exti_ptr, vsf_exti_channel_mask_t channel_mask);
 
extern vsf_exti_channel_mask_t vsf_exti_irq_clear(vsf_exti_t *exti_ptr, vsf_exti_channel_mask_t channel_mask);
 
extern vsf_err_t vsf_exti_ctrl(vsf_exti_t *exti_ptr, vsf_exti_ctrl_t ctrl, void * param);
 
/*============================ MACROS ========================================*/
 
#if VSF_EXTI_CFG_FUNCTION_RENAME == ENABLED
#   define __vsf_exti_t                                 VSF_MCONNECT(VSF_EXTI_CFG_PREFIX, _exti_t)
#   define vsf_exti_init(__EXTI)                        VSF_MCONNECT(VSF_EXTI_CFG_PREFIX, _exti_init)                   ((__vsf_exti_t *)(__EXTI))
#   define vsf_exti_fini(__EXTI)                        VSF_MCONNECT(VSF_EXTI_CFG_PREFIX, _exti_fini)                   ((__vsf_exti_t *)(__EXTI))
#   define vsf_exti_status(__EXTI)                      VSF_MCONNECT(VSF_EXTI_CFG_PREFIX, _exti_status)                 ((__vsf_exti_t *)(__EXTI))
#   define vsf_exti_capability(__EXTI)                  VSF_MCONNECT(VSF_EXTI_CFG_PREFIX, _exti_capability)             ((__vsf_exti_t *)(__EXTI))
#   define vsf_exti_trigger(__EXTI, ...)                VSF_MCONNECT(VSF_EXTI_CFG_PREFIX, _exti_trigger)                ((__vsf_exti_t *)(__EXTI), ##__VA_ARGS__)
#   define vsf_exti_config_channels(__EXTI, ...)        VSF_MCONNECT(VSF_EXTI_CFG_PREFIX, _exti_config_channels)        ((__vsf_exti_t *)(__EXTI), ##__VA_ARGS__)
#   define vsf_exti_irq_enable(__EXTI, ...)             VSF_MCONNECT(VSF_EXTI_CFG_PREFIX, _exti_irq_enable)             ((__vsf_exti_t *)(__EXTI), ##__VA_ARGS__)
#   define vsf_exti_irq_disable(__EXTI, ...)            VSF_MCONNECT(VSF_EXTI_CFG_PREFIX, _exti_irq_disable)            ((__vsf_exti_t *)(__EXTI), ##__VA_ARGS__)
#   define vsf_exti_irq_clear(__EXTI, ...)              VSF_MCONNECT(VSF_EXTI_CFG_PREFIX, _exti_irq_clear)              ((__vsf_exti_t *)(__EXTI), ##__VA_ARGS__)
#   define vsf_exti_ctrl(__EXTI, ...)                   VSF_MCONNECT(VSF_EXTI_CFG_PREFIX, _exti_ctrl)                   ((__vsf_exti_t *)(__EXTI), ##__VA_ARGS__)
#endif
 
#ifdef __cplusplus
}
#endif
 
#endif  /* __VSF_TEMPLATE_EXTI_H__ */