esp-idf/components/driver/mcpwm/mcpwm_sync.c

297 wiersze
11 KiB
C

/*
* SPDX-FileCopyrightText: 2022-2023 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
#include <stdlib.h>
#include <stdarg.h>
#include <sys/cdefs.h>
#include "sdkconfig.h"
#if CONFIG_MCPWM_ENABLE_DEBUG_LOG
// The local log level must be defined before including esp_log.h
// Set the maximum log level for this source file
#define LOG_LOCAL_LEVEL ESP_LOG_DEBUG
#endif
#include "freertos/FreeRTOS.h"
#include "esp_attr.h"
#include "esp_check.h"
#include "esp_err.h"
#include "esp_log.h"
#include "esp_memory_utils.h"
#include "soc/soc_caps.h"
#include "soc/mcpwm_periph.h"
#include "hal/mcpwm_ll.h"
#include "driver/mcpwm_sync.h"
#include "driver/gpio.h"
#include "mcpwm_private.h"
static const char *TAG = "mcpwm";
static esp_err_t mcpwm_del_timer_sync_src(mcpwm_sync_t *sync_src);
static esp_err_t mcpwm_del_gpio_sync_src(mcpwm_sync_t *sync_src);
static esp_err_t mcpwm_del_soft_sync_src(mcpwm_sync_t *sync_src);
static esp_err_t mcpwm_timer_sync_src_register_to_timer(mcpwm_timer_sync_src_t *timer_sync_src, mcpwm_timer_t *timer)
{
bool new_sync = false;
portENTER_CRITICAL(&timer->spinlock);
if (!timer->sync_src) {
new_sync = true;
timer->sync_src = timer_sync_src;
}
portEXIT_CRITICAL(&timer->spinlock);
ESP_RETURN_ON_FALSE(new_sync, ESP_ERR_INVALID_STATE, TAG, "timer sync_src already installed for timer (%d,%d)",
timer->group->group_id, timer->timer_id);
timer_sync_src->timer = timer;
return ESP_OK;
}
static void mcpwm_timer_sync_src_unregister_from_timer(mcpwm_timer_sync_src_t *timer_sync_src)
{
mcpwm_timer_t *timer = timer_sync_src->timer;
portENTER_CRITICAL(&timer->spinlock);
timer->sync_src = NULL;
portEXIT_CRITICAL(&timer->spinlock);
}
static esp_err_t mcpwm_timer_sync_src_destroy(mcpwm_timer_sync_src_t *timer_sync_src)
{
if (timer_sync_src->timer) {
mcpwm_timer_sync_src_unregister_from_timer(timer_sync_src);
}
free(timer_sync_src);
return ESP_OK;
}
esp_err_t mcpwm_new_timer_sync_src(mcpwm_timer_handle_t timer, const mcpwm_timer_sync_src_config_t *config, mcpwm_sync_handle_t *ret_sync)
{
esp_err_t ret = ESP_OK;
mcpwm_timer_sync_src_t *timer_sync_src = NULL;
ESP_GOTO_ON_FALSE(timer && config && ret_sync, ESP_ERR_INVALID_ARG, err, TAG, "invalid argument");
timer_sync_src = heap_caps_calloc(1, sizeof(mcpwm_timer_sync_src_t), MCPWM_MEM_ALLOC_CAPS);
ESP_GOTO_ON_FALSE(timer_sync_src, ESP_ERR_NO_MEM, err, TAG, "no mem for timer sync_src");
ESP_GOTO_ON_ERROR(mcpwm_timer_sync_src_register_to_timer(timer_sync_src, timer), err, TAG, "register timer sync_src failed");
mcpwm_group_t *group = timer->group;
mcpwm_hal_context_t *hal = &group->hal;
int timer_id = timer->timer_id;
if (config->flags.propagate_input_sync) {
mcpwm_ll_timer_propagate_input_sync(hal->dev, timer_id);
} else {
switch (config->timer_event) {
case MCPWM_TIMER_EVENT_EMPTY:
mcpwm_ll_timer_sync_out_on_timer_event(hal->dev, timer_id, MCPWM_TIMER_EVENT_EMPTY);
break;
case MCPWM_TIMER_EVENT_FULL:
mcpwm_ll_timer_sync_out_on_timer_event(hal->dev, timer_id, MCPWM_TIMER_EVENT_FULL);
break;
default:
ESP_GOTO_ON_FALSE(false, ESP_ERR_INVALID_ARG, err, TAG, "unknown timer sync event:%d", config->timer_event);
break;
}
}
timer_sync_src->base.group = group;
timer_sync_src->base.type = MCPWM_SYNC_TYPE_TIMER;
timer_sync_src->base.del = mcpwm_del_timer_sync_src;
*ret_sync = &timer_sync_src->base;
ESP_LOGD(TAG, "new timer sync_src at %p in timer (%d,%d), event:%c", timer_sync_src, group->group_id, timer_id, "EP?"[config->timer_event]);
return ESP_OK;
err:
if (timer_sync_src) {
mcpwm_timer_sync_src_destroy(timer_sync_src);
}
return ret;
}
static esp_err_t mcpwm_del_timer_sync_src(mcpwm_sync_t *sync_src)
{
mcpwm_timer_sync_src_t *timer_sync_src = __containerof(sync_src, mcpwm_timer_sync_src_t, base);
mcpwm_timer_t *timer = timer_sync_src->timer;
int timer_id = timer->timer_id;
mcpwm_group_t *group = sync_src->group;
mcpwm_ll_timer_disable_sync_out(group->hal.dev, timer_id);
ESP_LOGD(TAG, "del timer sync_src in timer (%d,%d)", group->group_id, timer_id);
ESP_RETURN_ON_ERROR(mcpwm_timer_sync_src_destroy(timer_sync_src), TAG, "destroy timer sync_src failed");
return ESP_OK;
}
static esp_err_t mcpwm_gpio_sync_src_register_to_group(mcpwm_gpio_sync_src_t *gpio_sync_src, int group_id)
{
mcpwm_group_t *group = mcpwm_acquire_group_handle(group_id);
ESP_RETURN_ON_FALSE(group, ESP_ERR_NO_MEM, TAG, "no mem for group (%d)", group_id);
int sync_id = -1;
portENTER_CRITICAL(&group->spinlock);
for (int i = 0; i < SOC_MCPWM_GPIO_SYNCHROS_PER_GROUP; i++) {
if (!group->gpio_sync_srcs[i]) {
sync_id = i;
group->gpio_sync_srcs[i] = gpio_sync_src;
break;
}
}
portEXIT_CRITICAL(&group->spinlock);
if (sync_id < 0) {
mcpwm_release_group_handle(group);
group = NULL;
} else {
gpio_sync_src->base.group = group;
gpio_sync_src->sync_id = sync_id;
}
ESP_RETURN_ON_FALSE(sync_id >= 0, ESP_ERR_NOT_FOUND, TAG, "no free gpio sync_src in group (%d)", group_id);
return ESP_OK;
}
static void mcpwm_gpio_sync_src_unregister_from_group(mcpwm_gpio_sync_src_t *gpio_sync_src)
{
mcpwm_group_t *group = gpio_sync_src->base.group;
int sync_id = gpio_sync_src->sync_id;
portENTER_CRITICAL(&group->spinlock);
group->gpio_sync_srcs[sync_id] = NULL;
portEXIT_CRITICAL(&group->spinlock);
// sync_src has a reference on group, release it now
mcpwm_release_group_handle(group);
}
static esp_err_t mcpwm_gpio_sync_src_destroy(mcpwm_gpio_sync_src_t *gpio_sync_src)
{
if (gpio_sync_src->base.group) {
mcpwm_gpio_sync_src_unregister_from_group(gpio_sync_src);
}
free(gpio_sync_src);
return ESP_OK;
}
esp_err_t mcpwm_new_gpio_sync_src(const mcpwm_gpio_sync_src_config_t *config, mcpwm_sync_handle_t *ret_sync)
{
#if CONFIG_MCPWM_ENABLE_DEBUG_LOG
esp_log_level_set(TAG, ESP_LOG_DEBUG);
#endif
esp_err_t ret = ESP_OK;
mcpwm_gpio_sync_src_t *gpio_sync_src = NULL;
ESP_GOTO_ON_FALSE(config && ret_sync, ESP_ERR_INVALID_ARG, err, TAG, "invalid argument");
ESP_GOTO_ON_FALSE(config->group_id < SOC_MCPWM_GROUPS && config->group_id >= 0, ESP_ERR_INVALID_ARG,
err, TAG, "invalid group ID:%d", config->group_id);
gpio_sync_src = heap_caps_calloc(1, sizeof(mcpwm_gpio_sync_src_t), MCPWM_MEM_ALLOC_CAPS);
ESP_GOTO_ON_FALSE(gpio_sync_src, ESP_ERR_NO_MEM, err, TAG, "no mem for gpio sync_src");
ESP_GOTO_ON_ERROR(mcpwm_gpio_sync_src_register_to_group(gpio_sync_src, config->group_id), err, TAG, "register gpio sync_src failed");
mcpwm_group_t *group = gpio_sync_src->base.group;
int group_id = group->group_id;
int sync_id = gpio_sync_src->sync_id;
// GPIO configuration
gpio_config_t gpio_conf = {
.intr_type = GPIO_INTR_DISABLE,
.mode = GPIO_MODE_INPUT | (config->flags.io_loop_back ? GPIO_MODE_OUTPUT : 0), // also enable the output path if `io_loop_back` is enabled
.pin_bit_mask = (1ULL << config->gpio_num),
.pull_down_en = config->flags.pull_down,
.pull_up_en = config->flags.pull_up,
};
ESP_GOTO_ON_ERROR(gpio_config(&gpio_conf), err, TAG, "config sync GPIO failed");
esp_rom_gpio_connect_in_signal(config->gpio_num, mcpwm_periph_signals.groups[group_id].gpio_synchros[sync_id].sync_sig, 0);
// different ext sync share the same config register, using a group level spin lock
portENTER_CRITICAL(&group->spinlock);
mcpwm_ll_invert_gpio_sync_input(group->hal.dev, sync_id, config->flags.active_neg);
portEXIT_CRITICAL(&group->spinlock);
// fill in other operator members
gpio_sync_src->base.type = MCPWM_SYNC_TYPE_GPIO;
gpio_sync_src->gpio_num = config->gpio_num;
gpio_sync_src->base.del = mcpwm_del_gpio_sync_src;
*ret_sync = &gpio_sync_src->base;
ESP_LOGD(TAG, "new gpio sync_src (%d,%d) at %p, GPIO:%d", group_id, sync_id, gpio_sync_src, config->gpio_num);
return ESP_OK;
err:
if (gpio_sync_src) {
mcpwm_gpio_sync_src_destroy(gpio_sync_src);
}
return ret;
}
static esp_err_t mcpwm_del_gpio_sync_src(mcpwm_sync_t *sync_src)
{
mcpwm_gpio_sync_src_t *gpio_sync_src = __containerof(sync_src, mcpwm_gpio_sync_src_t, base);
mcpwm_group_t *group = sync_src->group;
ESP_LOGD(TAG, "del gpio sync_src (%d,%d)", group->group_id, gpio_sync_src->sync_id);
gpio_reset_pin(gpio_sync_src->gpio_num);
// recycle memory resource
ESP_RETURN_ON_ERROR(mcpwm_gpio_sync_src_destroy(gpio_sync_src), TAG, "destroy GPIO sync_src failed");
return ESP_OK;
}
esp_err_t mcpwm_new_soft_sync_src(const mcpwm_soft_sync_config_t *config, mcpwm_sync_handle_t *ret_sync)
{
esp_err_t ret = ESP_OK;
mcpwm_soft_sync_src_t *soft_sync = NULL;
ESP_GOTO_ON_FALSE(config && ret_sync, ESP_ERR_INVALID_ARG, err, TAG, "invalid argument");
soft_sync = heap_caps_calloc(1, sizeof(mcpwm_soft_sync_src_t), MCPWM_MEM_ALLOC_CAPS);
ESP_GOTO_ON_FALSE(soft_sync, ESP_ERR_NO_MEM, err, TAG, "no mem for soft sync");
// fill in other sync member
soft_sync->soft_sync_from = MCPWM_SOFT_SYNC_FROM_NONE;
soft_sync->base.type = MCPWM_SYNC_TYPE_SOFT;
soft_sync->base.del = mcpwm_del_soft_sync_src;
*ret_sync = &soft_sync->base;
ESP_LOGD(TAG, "new soft sync at %p", soft_sync);
return ESP_OK;
err:
// soft_sync must be NULL in the error handling path, and it's a determined behaviour to free a NULL pointer in esp-idf
free(soft_sync);
return ret;
}
static esp_err_t mcpwm_del_soft_sync_src(mcpwm_sync_t *sync_src)
{
mcpwm_soft_sync_src_t *soft_sync = __containerof(sync_src, mcpwm_soft_sync_src_t, base);
ESP_LOGD(TAG, "del soft sync %p", soft_sync);
free(soft_sync);
return ESP_OK;
}
esp_err_t mcpwm_del_sync_src(mcpwm_sync_handle_t sync_src)
{
ESP_RETURN_ON_FALSE(sync_src, ESP_ERR_INVALID_ARG, TAG, "invalid argument");
return sync_src->del(sync_src);
}
esp_err_t mcpwm_soft_sync_activate(mcpwm_sync_handle_t sync_src)
{
ESP_RETURN_ON_FALSE(sync_src, ESP_ERR_INVALID_ARG, TAG, "invalid argument");
ESP_RETURN_ON_FALSE(sync_src->type == MCPWM_SYNC_TYPE_SOFT, ESP_ERR_INVALID_ARG, TAG, "not a valid soft sync");
mcpwm_group_t *group = sync_src->group;
mcpwm_soft_sync_src_t *soft_sync = __containerof(sync_src, mcpwm_soft_sync_src_t, base);
switch (soft_sync->soft_sync_from) {
case MCPWM_SOFT_SYNC_FROM_TIMER: {
mcpwm_timer_t *timer = soft_sync->timer;
mcpwm_ll_timer_trigger_soft_sync(group->hal.dev, timer->timer_id);
break;
}
case MCPWM_SOFT_SYNC_FROM_CAP: {
mcpwm_ll_capture_trigger_sw_sync(group->hal.dev);
break;
}
default:
ESP_RETURN_ON_FALSE(false, ESP_ERR_INVALID_STATE, TAG, "no soft sync generator is assigned");
break;
}
return ESP_OK;
}