hpm_tamp_drv.h

Go to the documentation of this file.

/*
 * Copyright (c) 2024 HPMicro
 *
 * SPDX-License-Identifier: BSD-3-Clause
 *
 */
 
#ifndef HPM_TAMP_DRV_H
#define HPM_TAMP_DRV_H
 
#include "hpm_common.h"
#include "hpm_tamp_regs.h"
 
typedef enum {
    spd_1_time_per_sec = 0,
    spd_2_times_per_sec,
    spd_4_times_per_sec,
    spd_8_times_per_sec,
    spd_16_times_per_sec,
    spd_32_times_per_sec,
    spd_64_times_per_sec,
    spd_128_times_per_sec,
    spd_256_times_per_sec,
    spd_512_times_per_sec,
    spd_1024_times_per_sec,
    spd_2048_times_per_sec,
    spd_4096_times_per_sec,
    spd_8192_times_per_sec,
    spd_16384_times_per_sec,
    spd_32768_times_per_sec,
} tamper_speed_t;
 
typedef enum {
    filter_len_1_cycle = 0,
    filter_len_2_cycles,
    filter_len_4_cycles,
    filter_len_8_cycles,
    filter_len_16_cycles,
    filter_len_32_cycles,
    filter_len_64_cycles,
    filter_len_128_cycles,
    filter_len_256_cycles,
    filter_len_512_cycles,
    filter_len_1024_cycles,
    filter_len_2048_cycles,
    filter_len_4096_cycles,
    filter_len_8192_cycles,
    filter_len_16384_cycles,
    filter_len_32768_cycles,
} tamper_filter_len_t;
 
 typedef struct {
    bool enable;
    bool active_mode;
    bool filter_bypass;
    bool expect_high_level;
    tamper_speed_t speed;
    tamper_filter_len_t filter_len;
    bool auto_recover;    /* used in active mode */
    uint32_t poly;    /* used in active mode */
    uint32_t lfsr;    /* used in active mode */
} tamper_ch_config_t;
 
 
#ifdef __cplusplus
extern "C" {
#endif
 
void tamp_init_ch_config(TAMP_Type *ptr, uint8_t ch, tamper_ch_config_t *config);
 
void tamp_get_default_ch_config(TAMP_Type *ptr, tamper_ch_config_t *config);
 
static inline void tamp_set_ch_enable(TAMP_Type *ptr, uint8_t ch, bool enable)
{
    ch >>= 1u;
    if (enable) {
        ptr->TAMP[ch].CONTROL |= TAMP_TAMP_CONTROL_ENABLE_MASK;
    } else {
        ptr->TAMP[ch].CONTROL &= ~TAMP_TAMP_CONTROL_ENABLE_MASK;
    }
}
 
static inline void tamp_set_ch_config_lock(TAMP_Type *ptr, uint8_t ch, bool lock)
{
    ch >>= 1u;
    if (lock) {
        ptr->TAMP[ch].CONTROL |= TAMP_TAMP_CONTROL_LOCK_MASK;
    } else {
        ptr->TAMP[ch].CONTROL &= ~TAMP_TAMP_CONTROL_LOCK_MASK;
    }
}
 
static inline uint32_t tamp_get_flags(TAMP_Type *ptr)
{
    return TAMP_TAMP_FLAG_FLAG_GET(ptr->TAMP_FLAG);
}
 
static inline void tamp_clear_flags(TAMP_Type *ptr, uint32_t flags)
{
    ptr->TAMP_FLAG = TAMP_TAMP_FLAG_FLAG_SET(flags);
}
 
static inline bool tamp_check_ch_flag(TAMP_Type *ptr, uint8_t ch)
{
    return ((TAMP_TAMP_FLAG_FLAG_GET(ptr->TAMP_FLAG) & (1u << ch)) != 0u) ? true : false;
}
 
static inline void tamp_clear_ch_flag(TAMP_Type *ptr, uint8_t ch)
{
    ptr->TAMP_FLAG = TAMP_TAMP_FLAG_FLAG_SET(1u << ch);
}
 
static inline void tamp_enable_ch_irq(TAMP_Type *ptr, uint8_t ch, bool enable)
{
    if (enable) {
        ptr->IRQ_EN |= TAMP_IRQ_EN_IRQ_EN_SET(1u << ch);
    } else {
        ptr->IRQ_EN &= ~TAMP_IRQ_EN_IRQ_EN_SET(1u << ch);
    }
}
 
static inline void tamp_set_irq_lock(TAMP_Type *ptr, bool lock)
{
    if (lock) {
        ptr->IRQ_EN |= TAMP_IRQ_EN_LOCK_MASK;
    } else {
        ptr->IRQ_EN &= ~TAMP_IRQ_EN_LOCK_MASK;
    }
}
 
#ifdef __cplusplus
}
#endif
#endif /* HPM_TAMP_DRV_H */