blob: fa9219e5f971fb327ca90f02882b0f65384f5658 [file] [log] [blame]
/*
* Copyright (c) 2017 Vitor Massaru Iha <vitor@massaru.org>
* Copyright (c) 2022 Espressif Systems (Shanghai) Co., Ltd.
*
* SPDX-License-Identifier: Apache-2.0
*/
#define DT_DRV_COMPAT espressif_esp32_ledc
/* Include esp-idf headers first to avoid redefining BIT() macro */
#include <hal/ledc_hal.h>
#include <hal/ledc_types.h>
#include <soc.h>
#include <errno.h>
#include <string.h>
#include <zephyr/drivers/pwm.h>
#include <zephyr/kernel.h>
#include <zephyr/drivers/pinctrl.h>
#include <zephyr/drivers/clock_control.h>
#include <zephyr/logging/log.h>
LOG_MODULE_REGISTER(pwm_ledc_esp32, CONFIG_PWM_LOG_LEVEL);
struct pwm_ledc_esp32_data {
ledc_hal_context_t hal;
struct k_sem cmd_sem;
};
struct pwm_ledc_esp32_channel_config {
const uint8_t idx;
const uint8_t channel_num;
const uint8_t timer_num;
uint32_t freq;
const ledc_mode_t speed_mode;
uint8_t resolution;
ledc_clk_src_t clock_src;
uint32_t duty_val;
};
struct pwm_ledc_esp32_config {
const struct pinctrl_dev_config *pincfg;
const struct device *clock_dev;
const clock_control_subsys_t clock_subsys;
struct pwm_ledc_esp32_channel_config *channel_config;
const int channel_len;
};
static struct pwm_ledc_esp32_channel_config *get_channel_config(const struct device *dev,
int channel_id)
{
struct pwm_ledc_esp32_config *config =
(struct pwm_ledc_esp32_config *) dev->config;
for (uint8_t i = 0; i < config->channel_len; i++) {
if (config->channel_config[i].idx == channel_id) {
return &config->channel_config[i];
}
}
return NULL;
}
static void pwm_led_esp32_low_speed_update(const struct device *dev, int speed_mode, int channel)
{
uint32_t reg_addr;
struct pwm_ledc_esp32_data *data = (struct pwm_ledc_esp32_data *const)(dev)->data;
if (speed_mode == LEDC_LOW_SPEED_MODE) {
ledc_hal_ls_channel_update(&data->hal, channel);
}
}
static void pwm_led_esp32_update_duty(const struct device *dev, int speed_mode, int channel)
{
struct pwm_ledc_esp32_data *data = (struct pwm_ledc_esp32_data *const)(dev)->data;
ledc_hal_set_sig_out_en(&data->hal, channel, true);
ledc_hal_set_duty_start(&data->hal, channel, true);
pwm_led_esp32_low_speed_update(dev, speed_mode, channel);
}
static void pwm_led_esp32_duty_set(const struct device *dev,
struct pwm_ledc_esp32_channel_config *channel)
{
struct pwm_ledc_esp32_data *data = (struct pwm_ledc_esp32_data *const)(dev)->data;
ledc_hal_set_hpoint(&data->hal, channel->channel_num, 0);
ledc_hal_set_duty_int_part(&data->hal, channel->channel_num, channel->duty_val);
ledc_hal_set_duty_direction(&data->hal, channel->channel_num, 1);
ledc_hal_set_duty_num(&data->hal, channel->channel_num, 1);
ledc_hal_set_duty_cycle(&data->hal, channel->channel_num, 1);
ledc_hal_set_duty_scale(&data->hal, channel->channel_num, 0);
pwm_led_esp32_low_speed_update(dev, channel->speed_mode, channel->channel_num);
pwm_led_esp32_update_duty(dev, channel->speed_mode, channel->channel_num);
}
static int pwm_led_esp32_configure_pinctrl(const struct device *dev)
{
int ret;
struct pwm_ledc_esp32_config *config = (struct pwm_ledc_esp32_config *) dev->config;
ret = pinctrl_apply_state(config->pincfg, PINCTRL_STATE_DEFAULT);
if (ret < 0) {
LOG_ERR("PWM pinctrl setup failed (%d)", ret);
return ret;
}
return 0;
}
static void pwm_led_esp32_bind_channel_timer(const struct device *dev,
struct pwm_ledc_esp32_channel_config *channel)
{
struct pwm_ledc_esp32_data *data = (struct pwm_ledc_esp32_data *const)(dev)->data;
ledc_hal_bind_channel_timer(&data->hal, channel->channel_num, channel->timer_num);
pwm_led_esp32_low_speed_update(dev, channel->speed_mode, channel->channel_num);
}
static int pwm_led_esp32_calculate_max_resolution(struct pwm_ledc_esp32_channel_config *channel)
{
/**
* Max duty resolution can be obtained with
* max_res = log2(CLK_FREQ/FREQ)
*/
uint64_t clock_freq = channel->clock_src == LEDC_APB_CLK ? APB_CLK_FREQ : REF_CLK_FREQ;
uint32_t max_precision_n = clock_freq/channel->freq;
for (uint8_t i = 0; i <= SOC_LEDC_TIMER_BIT_WIDE_NUM; i++) {
max_precision_n /= 2;
if (!max_precision_n) {
channel->resolution = i;
return 0;
}
}
return -EINVAL;
}
static int pwm_led_esp32_timer_config(struct pwm_ledc_esp32_channel_config *channel)
{
/**
* Calculate max resolution based on the given frequency and the pwm clock.
*
* There are 2 clock resources for PWM:
*
* 1. APB_CLK (80MHz)
* 2. REF_TICK (1MHz)
*
* The low speed timers can be sourced from:
*
* 1. APB_CLK (80MHz)
* 2. RTC_CLK (8Mhz)
*
* The APB_CLK is mostly used
*
* First we try to find the largest resolution using the APB_CLK source.
* If the given frequency doesn't support it, we move to the next clock source.
*/
channel->clock_src = LEDC_APB_CLK;
if (!pwm_led_esp32_calculate_max_resolution(channel)) {
return 0;
}
channel->clock_src = LEDC_REF_TICK;
if (!pwm_led_esp32_calculate_max_resolution(channel)) {
return 0;
}
return -EINVAL;
}
static int pwm_led_esp32_timer_set(const struct device *dev,
struct pwm_ledc_esp32_channel_config *channel)
{
int prescaler = 0;
uint32_t precision = (0x1 << channel->resolution);
struct pwm_ledc_esp32_data *data = (struct pwm_ledc_esp32_data *const)(dev)->data;
__ASSERT_NO_MSG(channel->freq > 0);
switch (channel->clock_src) {
case LEDC_APB_CLK:
/** This expression comes from ESP32 Espressif's Technical Reference
* Manual chapter 13.2.2 Timers.
* div_num is a fixed point value (Q10.8).
*/
prescaler = ((uint64_t) APB_CLK_FREQ << 8) / channel->freq / precision;
break;
case LEDC_REF_TICK:
prescaler = ((uint64_t) REF_CLK_FREQ << 8) / channel->freq / precision;
break;
default:
LOG_ERR("Invalid clock source");
return -EINVAL;
}
if (prescaler < 0x100 || prescaler > 0x3FFFF) {
return -EINVAL;
}
if (channel->speed_mode == LEDC_LOW_SPEED_MODE) {
ledc_hal_set_slow_clk(&data->hal, channel->clock_src);
}
ledc_hal_set_clock_divider(&data->hal, channel->timer_num, prescaler);
ledc_hal_set_duty_resolution(&data->hal, channel->timer_num, channel->resolution);
ledc_hal_set_clock_source(&data->hal, channel->timer_num, channel->clock_src);
if (channel->speed_mode == LEDC_LOW_SPEED_MODE) {
ledc_hal_ls_timer_update(&data->hal, channel->timer_num);
}
/* reset low speed timer */
ledc_hal_timer_rst(&data->hal, channel->timer_num);
return 0;
}
static int pwm_led_esp32_get_cycles_per_sec(const struct device *dev,
uint32_t channel_idx, uint64_t *cycles)
{
struct pwm_ledc_esp32_config *config = (struct pwm_ledc_esp32_config *) dev->config;
struct pwm_ledc_esp32_channel_config *channel = get_channel_config(dev, channel_idx);
if (!channel) {
LOG_ERR("Error getting channel %d", channel_idx);
return -EINVAL;
}
*cycles = channel->clock_src == LEDC_APB_CLK ? APB_CLK_FREQ : REF_CLK_FREQ;
return 0;
}
/* period_cycles is not used, set frequency on menuconfig instead. */
static int pwm_led_esp32_set_cycles(const struct device *dev, uint32_t channel_idx,
uint32_t period_cycles,
uint32_t pulse_cycles, pwm_flags_t flags)
{
int ret;
uint64_t clk_freq;
struct pwm_ledc_esp32_config *config = (struct pwm_ledc_esp32_config *) dev->config;
struct pwm_ledc_esp32_data *data = (struct pwm_ledc_esp32_data *const)(dev)->data;
struct pwm_ledc_esp32_channel_config *channel = get_channel_config(dev, channel_idx);
if (!channel) {
LOG_ERR("Error getting channel %d", channel_idx);
return -EINVAL;
}
/* Update PWM frequency according to period_cycles */
pwm_led_esp32_get_cycles_per_sec(dev, channel_idx, &clk_freq);
channel->freq = (uint32_t) (clk_freq/period_cycles);
if (!channel->freq) {
channel->freq = 1;
}
k_sem_take(&data->cmd_sem, K_FOREVER);
ledc_hal_init(&data->hal, channel->speed_mode);
ret = pwm_led_esp32_timer_config(channel);
if (ret < 0) {
k_sem_give(&data->cmd_sem);
return ret;
}
ret = pwm_led_esp32_timer_set(dev, channel);
if (ret < 0) {
k_sem_give(&data->cmd_sem);
return ret;
}
pwm_led_esp32_bind_channel_timer(dev, channel);
/* Update PWM duty */
double duty_cycle = (double) pulse_cycles / (double) period_cycles;
channel->duty_val = (uint32_t)((double) (1 << channel->resolution) * duty_cycle);
pwm_led_esp32_duty_set(dev, channel);
ret = pwm_led_esp32_configure_pinctrl(dev);
if (ret < 0) {
k_sem_give(&data->cmd_sem);
return ret;
}
k_sem_give(&data->cmd_sem);
return ret;
}
int pwm_led_esp32_init(const struct device *dev)
{
int ret;
const struct pwm_ledc_esp32_config *config = dev->config;
struct pwm_ledc_esp32_data *data = (struct pwm_ledc_esp32_data *const)(dev)->data;
if (!device_is_ready(config->clock_dev)) {
LOG_ERR("clock control device not ready");
return -ENODEV;
}
/* Enable peripheral */
clock_control_on(config->clock_dev, config->clock_subsys);
return 0;
}
static const struct pwm_driver_api pwm_led_esp32_api = {
.set_cycles = pwm_led_esp32_set_cycles,
.get_cycles_per_sec = pwm_led_esp32_get_cycles_per_sec,
};
PINCTRL_DT_INST_DEFINE(0);
#define CHANNEL_CONFIG(node_id) \
{ \
.idx = DT_REG_ADDR(node_id), \
.channel_num = DT_REG_ADDR(node_id) % 8, \
.timer_num = DT_PROP(node_id, timer), \
.speed_mode = DT_REG_ADDR(node_id) < SOC_LEDC_CHANNEL_NUM \
? LEDC_LOW_SPEED_MODE \
: !LEDC_LOW_SPEED_MODE, \
.clock_src = LEDC_APB_CLK, \
},
static struct pwm_ledc_esp32_channel_config channel_config[] = {
DT_INST_FOREACH_CHILD(0, CHANNEL_CONFIG)
};
static struct pwm_ledc_esp32_config pwm_ledc_esp32_config = {
.pincfg = PINCTRL_DT_INST_DEV_CONFIG_GET(0),
.clock_dev = DEVICE_DT_GET(DT_INST_CLOCKS_CTLR(0)),
.clock_subsys = (clock_control_subsys_t)DT_INST_CLOCKS_CELL(0, offset),
.channel_config = channel_config,
.channel_len = ARRAY_SIZE(channel_config),
};
static struct pwm_ledc_esp32_data pwm_ledc_esp32_data = {
.hal = {
.dev = (ledc_dev_t *) DT_INST_REG_ADDR(0),
},
.cmd_sem = Z_SEM_INITIALIZER(pwm_ledc_esp32_data.cmd_sem, 1, 1),
};
DEVICE_DT_INST_DEFINE(0, &pwm_led_esp32_init, NULL,
&pwm_ledc_esp32_data,
&pwm_ledc_esp32_config,
POST_KERNEL,
CONFIG_PWM_INIT_PRIORITY,
&pwm_led_esp32_api);