hal_pwm.h

#ifndef HAL_PWM_H
#define HAL_PWM_H

#include <stdint.h>
#include "in_mmap.h"

/*
 * Defines
 ****************************************************************************************
 */


/*
 * Enumeration
 ****************************************************************************************
 */

enum pwm_id {
    PWM0_ID,
    PWM1_ID,
    PWM2_ID,
    PWM3_ID,
    PWM4_ID,
    PWM5_ID,
    PWM6_ID,
    PWM7_ID,
    PWM_MAX_ID,
};

enum pwm_err {
    PWM_ERR_OK = 0,
    PWM_ERR_INVALID_PARAM = -1,
    PWM_ERR_BAD_STATE = -2,
} ;

/*
 * Inline Functions
 ****************************************************************************************
 */
static INLINE void pwm_enable(int id)
{
    uint32_t reg = RD_WORD(PWM_REGS_MISC_CTRL);
    reg |= (1 << id);
    WR_WORD(PWM_REGS_MISC_CTRL, reg); 
}

static INLINE void pwm_disable(int id)
{
    uint32_t reg = RD_WORD(PWM_REGS_MISC_CTRL);
    reg &= ~(1 << id);
    WR_WORD(PWM_REGS_MISC_CTRL, reg); 
}

static INLINE void pwm_pause(int id, int pause)
{
    uint32_t reg = RD_WORD(PWM_REGS_MISC_CTRL);
    if (pause) {
        reg |= (1 << (PWM_REGS_MISC_CTRL_CTL_PWM_PAUSE_SHIFT + id));
    } else {
        reg &= ~(1 << (PWM_REGS_MISC_CTRL_CTL_PWM_PAUSE_SHIFT + id));
    }
    WR_WORD(PWM_REGS_MISC_CTRL, reg); 
}

static INLINE void pwm_polarity(int id, int invert)
{
    uint32_t reg = RD_WORD(PWM_REGS_MISC_CTRL);
    if (invert) {
        reg |= (1 << (PWM_REGS_MISC_CTRL_CTL_PWM_POLARITY_SHIFT + id));
    } else {
        reg &= ~(1 << (PWM_REGS_MISC_CTRL_CTL_PWM_POLARITY_SHIFT + id));
    }
    WR_WORD(PWM_REGS_MISC_CTRL, reg); 
}

static INLINE void pwm_config(int id, uint32_t duration, uint32_t high_duration)
{
    uint32_t addr1, addr2;

    if (id == PWM0_ID) {
        addr1 = PWM_REGS_PWM_DURATION_0;
        addr2 = PWM_REGS_PWM_HIGH_DURATION_0;
    } else if (id == PWM1_ID) {
        addr1 = PWM_REGS_PWM_DURATION_1;
        addr2 = PWM_REGS_PWM_HIGH_DURATION_1;
    } else if (id == PWM2_ID) {
        addr1 = PWM_REGS_PWM_DURATION_2;
        addr2 = PWM_REGS_PWM_HIGH_DURATION_2;
    } else if (id == PWM3_ID) {
        addr1 = PWM_REGS_PWM_DURATION_3;
        addr2 = PWM_REGS_PWM_HIGH_DURATION_3;
    } else if (id == PWM4_ID) {
        addr1 = PWM_REGS_PWM_DURATION_4;
        addr2 = PWM_REGS_PWM_HIGH_DURATION_4;
    } else if (id == PWM5_ID) {
        addr1 = PWM_REGS_PWM_DURATION_5;
        addr2 = PWM_REGS_PWM_HIGH_DURATION_5;
    } else if (id == PWM6_ID) {
        addr1 = PWM_REGS_PWM_DURATION_6;
        addr2 = PWM_REGS_PWM_HIGH_DURATION_6;
    } else {
        addr1 = PWM_REGS_PWM_DURATION_7;
        addr2 = PWM_REGS_PWM_HIGH_DURATION_7;
    }

    WR_WORD(addr1, duration);
    WR_WORD(addr2, high_duration);
}

static INLINE void pwm_high_duration(int id, uint32_t high_duration)
{
    uint32_t addr;

    if (id == PWM0_ID) {
        addr = PWM_REGS_PWM_HIGH_DURATION_0;
    } else if (id == PWM1_ID) {
        addr = PWM_REGS_PWM_HIGH_DURATION_1;
    } else if (id == PWM2_ID) {
        addr = PWM_REGS_PWM_HIGH_DURATION_2;
    } else if (id == PWM3_ID) {
        addr = PWM_REGS_PWM_HIGH_DURATION_3;
    } else if (id == PWM4_ID) {
        addr = PWM_REGS_PWM_HIGH_DURATION_4;
    } else if (id == PWM5_ID) {
        addr = PWM_REGS_PWM_HIGH_DURATION_5;
    } else if (id == PWM6_ID) {
        addr = PWM_REGS_PWM_HIGH_DURATION_6;
    } else {
        addr = PWM_REGS_PWM_HIGH_DURATION_7;
    }

    WR_WORD(addr, high_duration);
}

static INLINE int pwm_output(int id)
{
    uint32_t addr;

    if (id == PWM0_ID) {
        addr = PWM_REGS_PWM_OUTPUT_0;
    } else if (id == PWM1_ID) {
        addr = PWM_REGS_PWM_OUTPUT_1;
    } else if (id == PWM2_ID) {
        addr = PWM_REGS_PWM_OUTPUT_2;
    } else if (id == PWM3_ID) {
        addr = PWM_REGS_PWM_OUTPUT_3;
    } else if (id == PWM4_ID) {
        addr = PWM_REGS_PWM_OUTPUT_4;
    } else if (id == PWM5_ID) {
        addr = PWM_REGS_PWM_OUTPUT_5;
    } else if (id == PWM6_ID) {
        addr = PWM_REGS_PWM_OUTPUT_6;
    } else {
        addr = PWM_REGS_PWM_OUTPUT_7;
    }

    return (RD_WORD(addr) & 1);
}

static INLINE uint32_t pwm_int_status(void)
{
    return (RD_WORD(PWM_REGS_INTR_STATUS) & 0xFF);
}

static INLINE uint32_t pwm_int_mask_status(void)
{
    return (RD_WORD(PWM_REGS_INTR_MASK_STATUS) & 0xFF);
}

static INLINE void pwm_int_clr_all(void)
{
    WR_WORD(PWM_REGS_INTR_CLEAR, 0xFF);
}

static INLINE void pwm_int_clr(int id)
{
    WR_WORD(PWM_REGS_INTR_CLEAR, (1 << id));
}

static INLINE void pwm_int_mask_all(void)
{
    WR_WORD(PWM_REGS_INTR_MASK_SET, 0xFF);
}

static INLINE void pwm_int_mask(int id)
{
    WR_WORD(PWM_REGS_INTR_MASK_SET, (1 << id));
}

static INLINE void pwm_int_unmask(int id)
{
    WR_WORD(PWM_REGS_INTR_MASK_CLEAR, (1 << id));
}

static INLINE void pwm_int_reset(void)
{
    WR_WORD(PWM_REGS_RESET_INTR, PWM_REGS_RESET_INTR_CTL_PWM_INTR_SRESET);
}

static INLINE void pwm_duration_load(uint32_t pwm_load)
{
    WR_WORD(PWM_REGS_PWM_HIGH_DURATION_0, pwm_load&PWM_REGS_PWM_HIGH_DURATION_0_DURATION_MASK);
}


/*
 * Internal Functions
 ****************************************************************************************
 */
int hal_pwm_open_status(void);
int hal_pwm_isr_status(void);
void hal_crc_register_cb(void * arg, void (*cb)(void* arg));

/*
 * APIs
 ****************************************************************************************
 */

void *hal_pwm_open(int id, int prio, void *arg, void (*callback)(void *));

int hal_pwm_close(void *hdl);


uint32_t hal_pwm_us_to_ticks(uint32_t us);

int hal_pwm_start(void *hdl, uint32_t period_ticks, uint32_t high_ticks);


int hal_pwm_stop(void *hdl);


int hal_pwm_pause(void *hdl);

int hal_pwm_resume(void *hdl);



int hal_pwm_update(void *hdl, uint32_t period_ticks, uint32_t high_ticks);

int hal_pwm_update_high_duration(void *hdl, uint32_t high_ticks);



#endif  // HAL_PWM_H