pwm.c

Go to the documentation of this file.

#include "cfg/cfg_pwm.h"

#include <cfg/macros.h>
#include <cfg/module.h>

// Define logging setting (for cfg/log.h module).
#define LOG_LEVEL         PWM_LOG_LEVEL
#define LOG_VERBOSITY     PWM_LOG_FORMAT

#include <cfg/log.h>
#include <cfg/debug.h>

#include <drv/pwm.h>

#include CPU_HEADER(pwm)

#include <cpu/types.h>
#include <cpu/irq.h>

#include <string.h>

#if CFG_PWM_ENABLE_OLD_API

    void pwm_setDuty(PwmDev dev, pwm_duty_t duty)
    {
        pwm_period_t period = 0;
        pwm_duty_t real_duty = 0;

        duty = MIN(duty, PWM_MAX_DUTY);

        period = pwm_hw_getPeriod(dev);

        real_duty = (uint64_t)(duty * period) >> (uint64_t)PWM_MAX_PERIOD_LOG2;

        LOG_INFO("real_duty[%d] duty[%d], period[%d]\n", real_duty, duty, period);
        pwm_hw_setDutyUnlock(dev, real_duty);
    }

    void pwm_setFrequency(PwmDev dev, pwm_freq_t freq)
    {
        pwm_hw_setFrequency(dev, freq);
    }

    void pwm_enable(PwmDev dev, bool state)
    {
        if (state)
            pwm_hw_enable(dev);
        else
            pwm_hw_disable(dev);
    }

    MOD_DEFINE(pwm);

    void pwm_init(void)
    {
        cpu_flags_t flags;
        PwmDev dev;

        IRQ_SAVE_DISABLE(flags);

        pwm_hw_init();

        /* set all pwm to 0 */
        for (dev = 0; dev < PWM_CNT; dev++)
            pwm_setDuty(dev, 0);

        IRQ_RESTORE(flags);
        MOD_INIT(pwm);
    }
#endif

#if !CFG_PWM_ENABLE_OLD_API || defined(__doxygen__)

    INLINE void setRealDuty(Pwm *ctx, pwm_duty_t duty)
    {
        if (ctx->pol == PWM_POL_LOW_PULSE)
            duty = PWM_MAX_DUTY - duty;

        pwm_hwreg_t period = pwm_hw_getPeriod(ctx);
        pwm_hwreg_t hw_duty;

        switch (duty)
        {
        case 0:
            hw_duty = 0;
            break;
        case PWM_MAX_DUTY:
            hw_duty = period;
            break;
        default:
            hw_duty = (uint64_t)(duty * period) >> (uint64_t)PWM_MAX_PERIOD_LOG2;
        }

        pwm_hw_setDuty(ctx, hw_duty);
    }

    void pwm_setDuty(Pwm *ctx, pwm_duty_t duty)
    {
        ctx->duty = duty;

        if (ctx->enabled)
            setRealDuty(ctx, duty);
    }

    void pwm_setFrequency(Pwm *ctx, pwm_freq_t freq)
    {
        pwm_hw_setFrequency(ctx, freq);
        pwm_enable(ctx, ctx->enabled);
    }

    void pwm_setPolarity(Pwm *ctx, PwmPolarity pol)
    {
        ctx->pol = pol;
        pwm_enable(ctx, ctx->enabled);
    }

    void pwm_enable(Pwm *ctx, bool enable)
    {
        ctx->enabled = enable;

        if (enable)
            setRealDuty(ctx, ctx->duty);
        else
            setRealDuty(ctx, 0);
    }

    void pwm_init(Pwm *ctx, unsigned channel)
    {
        memset(ctx, 0, sizeof(*ctx));
        ctx->ch = channel;

        pwm_hw_init(ctx, channel);
    }

#endif