tmr.h

 
/******************************************************************************
 *
 * Copyright (C) 2022-2023 Maxim Integrated Products, Inc. (now owned by 
 * Analog Devices, Inc.),
 * Copyright (C) 2023-2024 Analog Devices, Inc.
 *
 * 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.
 *
 ******************************************************************************/
 
/* Define to prevent redundant inclusion */
#ifndef LIBRARIES_PERIPHDRIVERS_INCLUDE_MAX32680_TMR_H_
#define LIBRARIES_PERIPHDRIVERS_INCLUDE_MAX32680_TMR_H_
 
/* **** Includes **** */
#include <stdint.h>
#include <stdbool.h>
#include "mxc_device.h"
#include "tmr_regs.h"
#include "mxc_sys.h"
#include "gcr_regs.h"
#include "mcr_regs.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef enum {
    MXC_TMR_PRES_1 = MXC_S_TMR_CTRL0_CLKDIV_A_DIV_BY_1, 
    MXC_TMR_PRES_2 = MXC_S_TMR_CTRL0_CLKDIV_A_DIV_BY_2, 
    MXC_TMR_PRES_4 = MXC_S_TMR_CTRL0_CLKDIV_A_DIV_BY_4, 
    MXC_TMR_PRES_8 = MXC_S_TMR_CTRL0_CLKDIV_A_DIV_BY_8, 
    MXC_TMR_PRES_16 = MXC_S_TMR_CTRL0_CLKDIV_A_DIV_BY_16, 
    MXC_TMR_PRES_32 = MXC_S_TMR_CTRL0_CLKDIV_A_DIV_BY_32, 
    MXC_TMR_PRES_64 = MXC_S_TMR_CTRL0_CLKDIV_A_DIV_BY_64, 
    MXC_TMR_PRES_128 = MXC_S_TMR_CTRL0_CLKDIV_A_DIV_BY_128, 
    MXC_TMR_PRES_256 = MXC_S_TMR_CTRL0_CLKDIV_A_DIV_BY_256, 
    MXC_TMR_PRES_512 = MXC_S_TMR_CTRL0_CLKDIV_A_DIV_BY_512, 
    MXC_TMR_PRES_1024 = MXC_S_TMR_CTRL0_CLKDIV_A_DIV_BY_1024, 
    MXC_TMR_PRES_2048 = MXC_S_TMR_CTRL0_CLKDIV_A_DIV_BY_2048, 
    MXC_TMR_PRES_4096 = MXC_S_TMR_CTRL0_CLKDIV_A_DIV_BY_4096, 
    // Legacy names
    TMR_PRES_1 = MXC_TMR_PRES_1,
    TMR_PRES_2 = MXC_TMR_PRES_2,
    TMR_PRES_4 = MXC_TMR_PRES_4,
    TMR_PRES_8 = MXC_TMR_PRES_8,
    TMR_PRES_16 = MXC_TMR_PRES_16,
    TMR_PRES_32 = MXC_TMR_PRES_32,
    TMR_PRES_64 = MXC_TMR_PRES_64,
    TMR_PRES_128 = MXC_TMR_PRES_128,
    TMR_PRES_256 = MXC_TMR_PRES_256,
    TMR_PRES_512 = MXC_TMR_PRES_512,
    TMR_PRES_1024 = MXC_TMR_PRES_1024,
    TMR_PRES_2048 = MXC_TMR_PRES_2048,
    TMR_PRES_4096 = MXC_TMR_PRES_4096
} mxc_tmr_pres_t;
 
typedef enum {
    MXC_TMR_MODE_ONESHOT = MXC_V_TMR_CTRL0_MODE_A_ONE_SHOT, 
    MXC_TMR_MODE_CONTINUOUS = MXC_V_TMR_CTRL0_MODE_A_CONTINUOUS, 
    MXC_TMR_MODE_COUNTER = MXC_V_TMR_CTRL0_MODE_A_COUNTER, 
    MXC_TMR_MODE_PWM = MXC_V_TMR_CTRL0_MODE_A_PWM, 
    MXC_TMR_MODE_CAPTURE = MXC_V_TMR_CTRL0_MODE_A_CAPTURE, 
    MXC_TMR_MODE_COMPARE = MXC_V_TMR_CTRL0_MODE_A_COMPARE, 
    MXC_TMR_MODE_GATED = MXC_V_TMR_CTRL0_MODE_A_GATED, 
    MXC_TMR_MODE_CAPTURE_COMPARE = MXC_V_TMR_CTRL0_MODE_A_CAPCOMP, 
    MXC_TMR_MODE_DUAL_EDGE = MXC_V_TMR_CTRL0_MODE_A_DUAL_EDGE, 
 
    // Legacy names
    TMR_MODE_ONESHOT = MXC_TMR_MODE_ONESHOT,
    TMR_MODE_CONTINUOUS = MXC_TMR_MODE_CONTINUOUS,
    TMR_MODE_COUNTER = MXC_TMR_MODE_COUNTER,
    TMR_MODE_PWM = MXC_TMR_MODE_PWM,
    TMR_MODE_CAPTURE = MXC_TMR_MODE_CAPTURE,
    TMR_MODE_COMPARE = MXC_TMR_MODE_COMPARE,
    TMR_MODE_GATED = MXC_TMR_MODE_GATED,
    TMR_MODE_CAPTURE_COMPARE = MXC_TMR_MODE_CAPTURE_COMPARE,
    TMR_MODE_DUAL_EDGE = MXC_TMR_MODE_DUAL_EDGE
} mxc_tmr_mode_t;
 
typedef enum {
    MXC_TMR_BIT_MODE_32 = 0, 
    MXC_TMR_BIT_MODE_16A, 
    MXC_TMR_BIT_MODE_16B, 
    // Legacy names
    TMR_BIT_MODE_32 = MXC_TMR_BIT_MODE_32,
    TMR_BIT_MODE_16A = MXC_TMR_BIT_MODE_16A,
    TMR_BIT_MODE_16B = MXC_TMR_BIT_MODE_16B,
} mxc_tmr_bit_mode_t;
 
typedef enum {
    MXC_TMR_UNIT_NANOSEC = 0, 
    MXC_TMR_UNIT_MICROSEC, 
    MXC_TMR_UNIT_MILLISEC, 
    MXC_TMR_UNIT_SEC, 
    // Legacy names
    TMR_UNIT_NANOSEC = MXC_TMR_UNIT_NANOSEC,
    TMR_UNIT_MICROSEC = MXC_TMR_UNIT_MICROSEC,
    TMR_UNIT_MILLISEC = MXC_TMR_UNIT_MILLISEC,
    TMR_UNIT_SEC = MXC_TMR_UNIT_SEC,
} mxc_tmr_unit_t;
 
typedef enum {
    MXC_TMR_APB_CLK = 0, 
    MXC_TMR_EXT_CLK = 1, 
    MXC_TMR_ISO_CLK = 2, 
    MXC_TMR_IBRO_CLK = 3, 
    MXC_TMR_INRO_CLK = 4, 
    MXC_TMR_IBRO_DIV8_CLK = 5, 
    // Legacy names
    /*8M and 60M clocks can be used for Timers 0,1,2 and 3*/
    MXC_TMR_32M_CLK, // ERFO not supported as a clock source for TMR
    MXC_TMR_8M_CLK = MXC_TMR_IBRO_CLK,
    /*32K clock can be used for Timers 0,1,2,3 and 4*/
    MXC_TMR_32K_CLK, // ERTCO not supported as a clock source for TMR
    /*8K and EXT clocks can only be used for Timers 4 and 5*/
    MXC_TMR_8K_CLK = MXC_TMR_INRO_CLK,
} mxc_tmr_clock_t;
 
typedef struct {
    mxc_tmr_pres_t pres; 
    mxc_tmr_mode_t mode; 
    mxc_tmr_bit_mode_t bitMode; 
    mxc_tmr_clock_t clock; 
    uint32_t cmp_cnt; 
    unsigned pol; 
} mxc_tmr_cfg_t;
 
/* **** Definitions **** */
typedef void (*mxc_tmr_complete_t)(int error);
 
/* **** Function Prototypes **** */
 
int MXC_TMR_Init(mxc_tmr_regs_t *tmr, mxc_tmr_cfg_t *cfg, bool init_pins);
 
void MXC_TMR_Shutdown(mxc_tmr_regs_t *tmr);
 
void MXC_TMR_Start(mxc_tmr_regs_t *tmr);
 
void MXC_TMR_Stop(mxc_tmr_regs_t *tmr);
 
int MXC_TMR_SetPWM(mxc_tmr_regs_t *tmr, uint32_t pwm);
 
uint32_t MXC_TMR_GetCompare(mxc_tmr_regs_t *tmr);
 
uint32_t MXC_TMR_GetCapture(mxc_tmr_regs_t *tmr);
 
uint32_t MXC_TMR_GetCount(mxc_tmr_regs_t *tmr);
 
uint32_t MXC_TMR_GetPeriod(mxc_tmr_regs_t *tmr, mxc_tmr_clock_t clock, uint32_t prescalar,
                           uint32_t frequency);
 
void MXC_TMR_ClearFlags(mxc_tmr_regs_t *tmr);
 
uint32_t MXC_TMR_GetFlags(mxc_tmr_regs_t *tmr);
 
void MXC_TMR_EnableInt(mxc_tmr_regs_t *tmr);
 
void MXC_TMR_DisableInt(mxc_tmr_regs_t *tmr);
 
void MXC_TMR_EnableWakeup(mxc_tmr_regs_t *tmr, mxc_tmr_cfg_t *cfg);
 
void MXC_TMR_DisableWakeup(mxc_tmr_regs_t *tmr, mxc_tmr_cfg_t *cfg);
 
void MXC_TMR_SetCompare(mxc_tmr_regs_t *tmr, uint32_t cmp_cnt);
 
void MXC_TMR_SetCount(mxc_tmr_regs_t *tmr, uint32_t cnt);
 
void MXC_TMR_Delay(mxc_tmr_regs_t *tmr, uint32_t us);
 
void MXC_TMR_TO_Start(mxc_tmr_regs_t *tmr, uint32_t us);
 
int MXC_TMR_TO_Check(mxc_tmr_regs_t *tmr);
 
void MXC_TMR_TO_Stop(mxc_tmr_regs_t *tmr);
 
void MXC_TMR_TO_Clear(mxc_tmr_regs_t *tmr);
 
unsigned int MXC_TMR_TO_Elapsed(mxc_tmr_regs_t *tmr);
 
unsigned int MXC_TMR_TO_Remaining(mxc_tmr_regs_t *tmr);
 
void MXC_TMR_SW_Start(mxc_tmr_regs_t *tmr);
 
unsigned int MXC_TMR_SW_Stop(mxc_tmr_regs_t *tmr);
 
int MXC_TMR_GetTime(mxc_tmr_regs_t *tmr, uint32_t ticks, uint32_t *time, mxc_tmr_unit_t *units);
 
int MXC_TMR_GetTicks(mxc_tmr_regs_t *tmr, uint32_t time, mxc_tmr_unit_t units, uint32_t *ticks);
 
#ifdef __cplusplus
}
#endif
 
#endif // LIBRARIES_PERIPHDRIVERS_INCLUDE_MAX32680_TMR_H_