libs/rt-thread-official
libs
/
rt-thread-official
mirror of https://github.com/RT-Thread/rt-thread.git
4
0
Fork 0
Code Issues Releases Wiki Activity
rt-thread-official/bsp/wch/risc-v/Libraries/ch56x_drivers/ch56x_pwm.c

289 lines
8.6 KiB
C
Raw Blame History

/*
* Copyright (c) 2006-2023, RT-Thread Development Team
*
* SPDX-License-Identifier: Apache-2.0
*
* Change Logs:
* Date Author Notes
* 2022-08-04 Emuzit first version
*/
#include <rthw.h>
#include <rtdebug.h>
#include <drivers/rt_drv_pwm.h>
#include <drivers/pin.h>
#include "ch56x_pwm.h"
#include "ch56x_sys.h"
#define PWM_CYCLE_MAX 255 // must be 255 for 0%~100% duty cycle
struct pwm_device
{
struct rt_device_pwm parent;
volatile struct pwm_registers *reg_base;
uint32_t period;
};
static struct pwm_device pwmx_device;
static const uint8_t pwmx_pin[] = {PWM0_PIN, PWM1_PIN, PWM2_PIN, PWM3_PIN};
/**
* @brief Enable or disable PWM channel output.
* Make sure PWM clock is ON for writing registers.
*
* @param device is pointer to the rt_device_pwm device.
*
* @param channel is the PWM channel (0~3) to operate on.
*
* @param enable is to enable PWM when RT_TRUE, or disable when RT_FALSE.
*
* @return None.
*/
static void pwm_channel_enable(struct rt_device_pwm *device,
uint32_t channel, rt_bool_t enable)
{
struct pwm_device *pwm_device = (struct pwm_device *)device;
volatile struct pwm_registers *pxreg = pwm_device->reg_base;
uint8_t ctrl_mod, polar;
if (enable)
{
/* set pwm_out_en to allow pwm output */
ctrl_mod = pxreg->CTRL_MOD.reg;
pxreg->CTRL_MOD.reg = ctrl_mod | (RB_PWM0_OUT_EN << channel);
}
else
{
/* ch56x has no disable bit, set pin out to quiesce */
ctrl_mod = pxreg->CTRL_MOD.reg;
polar = ctrl_mod & (RB_PWM0_POLAR << channel);
rt_pin_write(pwmx_pin[channel], polar ? PIN_HIGH : PIN_LOW);
ctrl_mod &= ~(RB_PWM0_OUT_EN << channel);
pxreg->CTRL_MOD.reg = ctrl_mod;
}
}
/**
* @brief Set period of the PWM channel.
* Make sure PWM clock is ON for writing registers.
*
* @param device is pointer to the rt_device_pwm device.
*
* @param channel is the PWM channel (0~3) to operate on.
*
* @param period is PWM period in nanoseconds.
*
* @return RT_EOK if successful.
*/
static rt_err_t pwm_channel_period(struct rt_device_pwm *device,
uint32_t channel, uint32_t period)
{
struct pwm_device *pwm_device = (struct pwm_device *)device;
uint32_t clock_div;
/* All ch56x PWMX channels share the same period, channel ignored.
*
* Max allowed period is when Fsys@2MHz and CLOCK_DIV is 0 (256) :
* (1 / 2MHz) * 256 * PWM_CYCLE_MAX => 32640000 ns
* Note that `period * F_MHz` won't overflow in calculation below.
*/
if (period > (256 * PWM_CYCLE_MAX * 1000 / 2))
return -RT_EINVAL;
if (period != pwm_device->period)
{
uint32_t Fsys = sys_hclk_get();
uint32_t F_MHz = Fsys / 1000000;
uint32_t F_mod = Fsys % 1000000;
/* period = (clock_div / Fsys) * 10^9 * PWM_CYCLE_MAX */
clock_div = period * F_MHz + (1000 * PWM_CYCLE_MAX / 2);
/* Fsys is mostly in integer MHz, likely to be skipped */
if (F_mod != 0)
{
uint64_t u64v = ((uint64_t)period * F_mod) / 1000000;
clock_div += (uint32_t)u64v;
}
clock_div = clock_div / (1000 * PWM_CYCLE_MAX);
if (clock_div > 256)
return -RT_EINVAL;
/* CLOCK_DIV will be 0 if `clock_div` is 256 */
pwm_device->reg_base->CLOCK_DIV = (uint8_t)clock_div;
/* cycle_sel set to PWM_CYCLE_SEL_255 for 0%~100% duty cycle */
pwmx_device.reg_base->CTRL_CFG.cycle_sel = PWM_CYCLE_SEL_255;
pwm_device->period = period;
}
return RT_EOK;
}
/**
* @brief Set pulse duration of the PWM channel.
* Make sure PWM clock is ON for writing registers.
*
* @param device is pointer to the rt_device_pwm device.
*
* @param channel is the PWM channel (0~3) to operate on.
*
* @param pulse is PWM pulse duration in nanoseconds.
*
* @return RT_EOK if successful.
*/
static rt_err_t pwm_channel_pulse(struct rt_device_pwm *device,
uint32_t channel, uint32_t pulse)
{
struct pwm_device *pwm_device = (struct pwm_device *)device;
uint32_t pdata, period;
/* duty cycle is calculated with "raw" period setting */
period = pwm_device->period;
if (!period || pulse > period)
return -RT_EINVAL;
pdata = (pulse * PWM_CYCLE_MAX + (period >> 1)) / period;
pwm_device->reg_base->PWM_DATA[channel] = pdata;
return RT_EOK;
}
/**
* @brief Set period & pulse of the PWM channel, remain disabled.
* Make sure PWM clock is ON for writing registers.
*
* @param device is pointer to the rt_device_pwm device.
*
* @param configuration is the channel/period/pulse specification.
* ch56x PWM has no complementary pin, complementary ignored.
* FIXME: can we specify PWM output polarity somehow ?
*
* @return RT_EOK if successful.
*/
static rt_err_t pwm_device_set(struct rt_device_pwm *device,
struct rt_pwm_configuration *configuration)
{
struct pwm_device *pwm_device = (struct pwm_device *)device;
uint32_t channel = configuration->channel;
rt_err_t res;
res = pwm_channel_period(device, channel, configuration->period);
if (res == RT_EOK)
{
res = pwm_channel_pulse(device, channel, configuration->pulse);
if (res == RT_EOK)
{
rt_pin_mode(pwmx_pin[channel], PIN_MODE_OUTPUT);
/* seems to be kept disabled according to sample code */
pwm_channel_enable(device, channel, RT_FALSE);
}
}
return res;
}
/**
* @brief Get period & pulse of the PWM channel.
* The returned information is calculated with h/w setting.
*
* @param device is pointer to the rt_device_pwm device.
*
* @param configuration->channel specify the PWM channel (0~3).
* configuration->period & pulse return the calculated result.
*
* @return RT_EOK if successful.
*/
static rt_err_t pwm_device_get(struct rt_device_pwm *device,
struct rt_pwm_configuration *configuration)
{
struct pwm_device *pwm_device = (struct pwm_device *)device;
volatile struct pwm_registers *pxreg = pwm_device->reg_base;
uint32_t channel = configuration->channel;
uint32_t Fsys = sys_hclk_get();
uint32_t clock_div;
uint32_t pdata;
uint64_t u64v;
/* clock_div is actually 256 when CLOCK_DIV is 0 */
clock_div = pxreg->CLOCK_DIV;
if (clock_div == 0)
clock_div = 256;
u64v = clock_div;
u64v = (u64v * 1000*1000*1000 * PWM_CYCLE_MAX + (Fsys >> 1)) / Fsys;
configuration->period = (uint32_t)u64v;
/* `pdata` <= PWM_CYCLE_MAX, calculated pulse won't exceed period */
pdata = pxreg->PWM_DATA[channel];
u64v = clock_div;
u64v = (u64v * 1000*1000*1000 * pdata + (Fsys >> 1)) / Fsys;
configuration->pulse = (uint32_t)u64v;
return RT_EOK;
}
static rt_err_t pwm_control(struct rt_device_pwm *device, int cmd, void *arg)
{
struct pwm_device *pwm_device = (struct pwm_device *)device;
struct rt_pwm_configuration *configuration = arg;
uint32_t channel = configuration->channel;
rt_err_t res = RT_EOK;
RT_ASSERT(device != RT_NULL);
if (channel >= PWM_CHANNELS)
return -RT_EINVAL;
/* PWM clock needs to be ON to write PWM registers */
sys_slp_clk_off0(RB_SLP_CLK_PWMX, SYS_SLP_CLK_ON);
switch (cmd)
{
case PWM_CMD_ENABLE:
pwm_channel_enable(device, channel, RT_TRUE);
break;
case PWM_CMD_DISABLE:
pwm_channel_enable(device, channel, RT_FALSE);
break;
case PWM_CMD_SET:
return pwm_device_set(device, configuration);
case PWM_CMD_GET:
return pwm_device_get(device, configuration);
case PWM_CMD_SET_PERIOD:
return pwm_channel_period(device, channel, configuration->period);
case PWM_CMD_SET_PULSE:
return pwm_channel_pulse(device, channel, configuration->pulse);
default:
res = -RT_EINVAL;
}
/* disable PWMX clocking, if all channels are disabled */
if ((pwm_device->reg_base->CTRL_MOD.reg & PWM_OUT_EN_MASK) == 0)
sys_slp_clk_off0(RB_SLP_CLK_PWMX, SYS_SLP_CLK_OFF);
return res;
}
static struct rt_pwm_ops pwm_ops =
{
.control = pwm_control
};
static int rt_hw_pwm_init(void)
{
/* init pwmx_device with code to save some flash space */
pwmx_device.reg_base = (struct pwm_registers *)PWMX_REG_BASE;
/* Note: PWM clock OFF here => PWM registers not writable */
return rt_device_pwm_register(
&pwmx_device.parent, PWM_DEVICE_NAME, &pwm_ops, RT_NULL);
}
INIT_DEVICE_EXPORT(rt_hw_pwm_init);
View Git Blame Copy Permalink