hpm_ffa_drv.h

Go to the documentation of this file.

/*
 * Copyright (c) 2022 HPMicro
 *
 * SPDX-License-Identifier: BSD-3-Clause
 *
 */
#ifndef HPM_FFA_DRV_H
#define HPM_FFA_DRV_H
 
#include "hpm_common.h"
#include "hpm_soc_feature.h"
#include "hpm_ffa_regs.h"
 
/***********************************************************************************************************************
 *
 * Definitions
 *
 **********************************************************************************************************************/
#define FFA_OPCMD_FIR (0U)      /* !< FIR operation command index */
#define FFA_OPCMD_FFT (2U)      /* !< FFT operation command index */
 
#define FFA_DATA_TYPE_REAL_Q31      (0U)    /* !< FFA Data type:  Real Q31 */
#define FFA_DATA_TYPE_REAL_Q15      (1U)    /* !< FFA Data type: Real Q15 */
#define FFA_DATA_TYPE_COMPLEX_Q31   (2U)    /* !< FFA Data type: Complex Q31 */
#define FFA_DATA_TYPE_COMPLEX_Q15   (3U)    /* !< FFA Data type: Complex Q15 */
#if defined(HPM_IP_FEATURE_FFA_FP32) && HPM_IP_FEATURE_FFA_FP32
#define FFA_DATA_TYPE_COMPLEX_FP32  (4U)    /* !< FFA Data type: Complex Q15 */
#define FFA_DATA_TYPE_REAL_FP32     (5U)    /* !< FFA Data type: Complex Q15 */
#endif
 
typedef int32_t ffa_q31_t;
 
typedef int16_t ffa_q15_t;
 
typedef struct {
    ffa_q31_t real;
    ffa_q31_t image;
} ffa_complex_q31_t;
 
typedef struct {
    ffa_q15_t real;
    ffa_q15_t image;
} ffa_complex_q15_t;
 
typedef struct {
    uint16_t is_ifft;           /* !< Is Inverse FFT transform */
    uint8_t src_data_type;      /* !< Source data type */
    uint8_t dst_data_type;      /* !< Destination date type */
    uint32_t num_points;        /* !< Number of points */
    const void *src;            /* !< Source data buffer */
    void *dst;                  /* !< Destination Data buffer */
    uint32_t interrupt_mask;    /* !< Interrupt mask */
} fft_xfer_t;
 
typedef struct {
    uint16_t data_type;         /* !< Data type */
    uint16_t coef_taps;         /* !< Coefficient taps */
    uint32_t input_taps;        /* !< Input data taps */
    const void *src;            /* !< Source data buffer */
    const void *coeff;          /* !< Coefficient data buffer */
    void *dst;                  /* !< Destination data buffer */
    uint32_t interrupt_mask;    /* !< Interrupt mask */
} fir_xfer_t;
 
enum {
    status_ffa_fir_overflow = MAKE_STATUS(status_group_ffa, 0),         /* !< FIR overflow */
    status_ffa_fft_overflow = MAKE_STATUS(status_group_ffa, 1),         /* !< FFR overflow */
    status_ffa_write_error = MAKE_STATUS(status_group_ffa, 2),          /* !< FFA write error */
    status_ffa_read_next_error = MAKE_STATUS(status_group_ffa, 3),      /* !< FFA read next data error */
    status_ffa_read_error = MAKE_STATUS(status_group_ffa, 4),           
};
 
#if defined(HPM_IP_FEATURE_FFA_FP32) && HPM_IP_FEATURE_FFA_FP32
typedef enum {
    input_data = 0,
    output_data = 1,
    coeff_data = 2
} ffa_fp32_status_source_t;
#endif
 
#ifdef __cplusplus
extern "C" {
#endif
 
static inline void ffa_enable(FFA_Type *ptr)
{
    ptr->CTRL = (ptr->CTRL & ~FFA_CTRL_SFTRST_MASK) | FFA_CTRL_EN_MASK;
}
 
static inline void ffa_disable(FFA_Type *ptr)
{
    ptr->CTRL = (ptr->CTRL & ~FFA_CTRL_EN_MASK) | FFA_CTRL_SFTRST_MASK;
}
 
static inline uint32_t ffa_get_status(FFA_Type *ptr)
{
    return ptr->STATUS;
}
 
static inline void ffa_enable_interrupt(FFA_Type *ptr, uint32_t mask)
{
    ptr->INT_EN |= mask;
}
 
static inline void ffa_disable_interrupt(FFA_Type *ptr, uint32_t mask)
{
    ptr->INT_EN &= ~mask;
}
 
#if defined(HPM_IP_FEATURE_FFA_FP32) && HPM_IP_FEATURE_FFA_FP32
 
static inline void ffa_enable_fp32_interrupt(FFA_Type *ptr, uint32_t mask)
{
    ptr->FP_CTRL |= mask;
}
 
static inline void ffa_disable_fp32_interrupt(FFA_Type *ptr, uint32_t mask)
{
    ptr->FP_CTRL &= ~mask;
}
 
static inline void ffa_set_fp_status_source(FFA_Type *ptr, ffa_fp32_status_source_t source)
{
    ptr->FP_CTRL = FFA_FP_CTRL_EXP_ST_SEL_SET(source);
}
 
static inline void ffa_enable_fp_bias(FFA_Type *ptr)
{
    ptr->FP_CTRL |= FFA_FP_CTRL_OPT_BIAS_EXP_MASK;
}
 
static inline void ffa_disable_fp_bias(FFA_Type *ptr)
{
    ptr->FP_CTRL &= ~FFA_FP_CTRL_OPT_BIAS_EXP_MASK;
}
 
static inline void ffa_set_coef_max_index(FFA_Type *ptr, uint8_t max)
{
    ptr->FP_CTRL = (ptr->FP_CTRL & ~FFA_FP_CTRL_COEF_MAX_MASK) | FFA_FP_CTRL_COEF_MAX_SET(max);
}
 
static inline void ffa_set_output_max_index(FFA_Type *ptr, uint8_t max)
{
    ptr->FP_CTRL = (ptr->FP_CTRL & ~FFA_FP_CTRL_OUT_MAX_MASK) | FFA_FP_CTRL_OUT_MAX_SET(max);
}
 
static inline void ffa_set_input_max_index(FFA_Type *ptr, uint8_t max)
{
    ptr->FP_CTRL = (ptr->FP_CTRL & ~FFA_FP_CTRL_IN_MAX_MASK) | FFA_FP_CTRL_IN_MAX_SET(max);
}
 
static inline uint32_t ffa_get_fp_status(FFA_Type *ptr)
{
    return ptr->FP_ST;
}
 
#endif
 
void ffa_start_fft(FFA_Type *ptr, fft_xfer_t *fft_xfer);
 
void ffa_start_fir(FFA_Type *ptr, fir_xfer_t *fir_xfer);
 
hpm_stat_t ffa_calculate_fft_blocking(FFA_Type *ptr, fft_xfer_t *fft_xfer);
 
hpm_stat_t ffa_calculate_fir_blocking(FFA_Type *ptr, fir_xfer_t *fir_xfer);
 
 
#ifdef __cplusplus
}
#endif
#endif /* HPM_FFA_DRV_H */