esp-idf/components/driver/rmt.c

997 lines
38 KiB
C
Raw Normal View History

2019-06-06 00:22:38 -04:00
// Copyright 2015-2019 Espressif Systems (Shanghai) PTE LTD
2016-11-09 22:23:40 -05:00
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
2019-11-19 03:10:02 -05:00
//
2016-11-09 22:23:40 -05:00
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include <stdlib.h>
2019-11-19 03:10:02 -05:00
#include <string.h>
#include <sys/lock.h>
2019-03-26 04:30:43 -04:00
#include "esp_intr_alloc.h"
2016-11-09 22:23:40 -05:00
#include "esp_log.h"
2019-11-19 03:10:02 -05:00
#include "driver/gpio.h"
2016-11-09 22:23:40 -05:00
#include "driver/periph_ctrl.h"
#include "driver/rmt.h"
2019-11-19 03:10:02 -05:00
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/semphr.h"
#include "freertos/ringbuf.h"
global: move the soc component out of the common list This MR removes the common dependency from every IDF components to the SOC component. Currently, in the ``idf_functions.cmake`` script, we include the header path of SOC component by default for all components. But for better code organization (or maybe also benifits to the compiling speed), we may remove the dependency to SOC components for most components except the driver and kernel related components. In CMAKE, we have two kinds of header visibilities (set by include path visibility): (Assume component A --(depends on)--> B, B is the current component) 1. public (``COMPONENT_ADD_INCLUDEDIRS``): means this path is visible to other depending components (A) (visible to A and B) 2. private (``COMPONENT_PRIV_INCLUDEDIRS``): means this path is only visible to source files inside the component (visible to B only) and we have two kinds of depending ways: (Assume component A --(depends on)--> B --(depends on)--> C, B is the current component) 1. public (```COMPONENT_REQUIRES```): means B can access to public include path of C. All other components rely on you (A) will also be available for the public headers. (visible to A, B) 2. private (``COMPONENT_PRIV_REQUIRES``): means B can access to public include path of C, but don't propagate this relation to other components (A). (visible to B) 1. remove the common requirement in ``idf_functions.cmake``, this makes the SOC components invisible to all other components by default. 2. if a component (for example, DRIVER) really needs the dependency to SOC, add a private dependency to SOC for it. 3. some other components that don't really depends on the SOC may still meet some errors saying "can't find header soc/...", this is because it's depended component (DRIVER) incorrectly include the header of SOC in its public headers. Moving all this kind of #include into source files, or private headers 4. Fix the include requirements for some file which miss sufficient #include directives. (Previously they include some headers by the long long long header include link) This is a breaking change. Previous code may depends on the long include chain. You may need to include the following headers for some files after this commit: - soc/soc.h - soc/soc_memory_layout.h - driver/gpio.h - esp_sleep.h The major broken include chain includes: 1. esp_system.h no longer includes esp_sleep.h. The latter includes driver/gpio.h and driver/touch_pad.h. 2. ets_sys.h no longer includes soc/soc.h 3. freertos/portmacro.h no longer includes soc/soc_memory_layout.h some peripheral headers no longer includes their hw related headers, e.g. rom/gpio.h no longer includes soc/gpio_pins.h and soc/gpio_reg.h BREAKING CHANGE
2019-04-03 01:17:38 -04:00
#include "soc/soc_memory_layout.h"
2019-11-19 03:10:02 -05:00
#include "hal/rmt_hal.h"
#include "hal/rmt_ll.h"
2016-11-09 22:23:40 -05:00
#define RMT_SOUCCE_CLK_APB (APB_CLK_FREQ) /*!< RMT source clock is APB_CLK */
#define RMT_SOURCE_CLK_REF (1 * 1000000) /*!< not used yet */
2019-11-19 03:10:02 -05:00
#define RMT_SOURCE_CLK(select) ((select == RMT_BASECLK_REF) ? (RMT_SOURCE_CLK_REF) : (RMT_SOUCCE_CLK_APB))
#define RMT_CHANNEL_ERROR_STR "RMT CHANNEL ERR"
#define RMT_ADDR_ERROR_STR "RMT ADDRESS ERR"
#define RMT_MEM_CNT_ERROR_STR "RMT MEM BLOCK NUM ERR"
#define RMT_CARRIER_ERROR_STR "RMT CARRIER LEVEL ERR"
#define RMT_MEM_OWNER_ERROR_STR "RMT MEM OWNER_ERR"
#define RMT_BASECLK_ERROR_STR "RMT BASECLK ERR"
#define RMT_WR_MEM_OVF_ERROR_STR "RMT WR MEM OVERFLOW"
#define RMT_GPIO_ERROR_STR "RMT GPIO ERROR"
#define RMT_MODE_ERROR_STR "RMT MODE ERROR"
#define RMT_CLK_DIV_ERROR_STR "RMT CLK DIV ERR"
#define RMT_DRIVER_ERROR_STR "RMT DRIVER ERR"
#define RMT_DRIVER_LENGTH_ERROR_STR "RMT PARAM LEN ERROR"
#define RMT_PSRAM_BUFFER_WARN_STR "Using buffer allocated from psram"
#define RMT_TRANSLATOR_NULL_STR "RMT translator is null"
#define RMT_TRANSLATOR_UNINIT_STR "RMT translator not init"
#define RMT_PARAM_ERR_STR "RMT param error"
static const char *RMT_TAG = "rmt";
#define RMT_CHECK(a, str, ret_val) \
if (!(a)) \
{ \
ESP_LOGE(RMT_TAG, "%s(%d): %s", __FUNCTION__, __LINE__, str); \
return (ret_val); \
}
static uint8_t s_rmt_driver_channels; // Bitmask of installed drivers' channels
// Spinlock for protecting concurrent register-level access only
2016-11-09 22:23:40 -05:00
static portMUX_TYPE rmt_spinlock = portMUX_INITIALIZER_UNLOCKED;
2019-11-19 03:10:02 -05:00
#define RMT_ENTER_CRITICAL() portENTER_CRITICAL_SAFE(&rmt_spinlock)
#define RMT_EXIT_CRITICAL() portEXIT_CRITICAL_SAFE(&rmt_spinlock)
2016-11-09 22:23:40 -05:00
// Mutex lock for protecting concurrent register/unregister of RMT channels' ISR
static _lock_t rmt_driver_isr_lock;
2019-11-19 03:10:02 -05:00
static rmt_isr_handle_t s_rmt_driver_intr_handle;
2016-11-09 22:23:40 -05:00
typedef struct {
2019-11-19 03:10:02 -05:00
rmt_hal_context_t hal;
size_t tx_offset;
size_t tx_len_rem;
size_t tx_sub_len;
bool translator;
2018-02-24 03:36:21 -05:00
bool wait_done; //Mark whether wait tx done.
2016-11-09 22:23:40 -05:00
rmt_channel_t channel;
2019-11-19 03:10:02 -05:00
const rmt_item32_t *tx_data;
2016-11-09 22:23:40 -05:00
xSemaphoreHandle tx_sem;
#if CONFIG_SPIRAM_USE_MALLOC
int intr_alloc_flags;
StaticSemaphore_t tx_sem_buffer;
#endif
2019-11-19 03:10:02 -05:00
rmt_item32_t *tx_buf;
2016-11-09 22:23:40 -05:00
RingbufHandle_t rx_buf;
sample_to_rmt_t sample_to_rmt;
size_t sample_size_remain;
const uint8_t *sample_cur;
2016-11-09 22:23:40 -05:00
} rmt_obj_t;
2019-11-19 03:10:02 -05:00
rmt_obj_t *p_rmt_obj[RMT_CHANNEL_MAX] = {0};
2016-11-09 22:23:40 -05:00
// Event called when transmission is ended
static rmt_tx_end_callback_t rmt_tx_end_callback;
2016-11-09 22:23:40 -05:00
esp_err_t rmt_set_clk_div(rmt_channel_t channel, uint8_t div_cnt)
{
RMT_CHECK(channel < RMT_CHANNEL_MAX, RMT_CHANNEL_ERROR_STR, ESP_ERR_INVALID_ARG);
2019-11-19 03:10:02 -05:00
RMT_ENTER_CRITICAL();
rmt_ll_set_counter_clock_div(p_rmt_obj[channel]->hal.regs, channel, div_cnt);
RMT_EXIT_CRITICAL();
2016-11-09 22:23:40 -05:00
return ESP_OK;
}
2019-11-19 03:10:02 -05:00
esp_err_t rmt_get_clk_div(rmt_channel_t channel, uint8_t *div_cnt)
2016-11-09 22:23:40 -05:00
{
RMT_CHECK(channel < RMT_CHANNEL_MAX, RMT_CHANNEL_ERROR_STR, ESP_ERR_INVALID_ARG);
RMT_CHECK(div_cnt != NULL, RMT_ADDR_ERROR_STR, ESP_ERR_INVALID_ARG);
2019-11-19 03:10:02 -05:00
RMT_ENTER_CRITICAL();
*div_cnt = (uint8_t)rmt_ll_get_counter_clock_div(p_rmt_obj[channel]->hal.regs, channel);
RMT_EXIT_CRITICAL();
2016-11-09 22:23:40 -05:00
return ESP_OK;
}
esp_err_t rmt_set_rx_idle_thresh(rmt_channel_t channel, uint16_t thresh)
{
RMT_CHECK(channel < RMT_CHANNEL_MAX, RMT_CHANNEL_ERROR_STR, ESP_ERR_INVALID_ARG);
2019-11-19 03:10:02 -05:00
RMT_ENTER_CRITICAL();
rmt_ll_set_rx_idle_thres(p_rmt_obj[channel]->hal.regs, channel, thresh);
RMT_EXIT_CRITICAL();
2016-11-09 22:23:40 -05:00
return ESP_OK;
}
esp_err_t rmt_get_rx_idle_thresh(rmt_channel_t channel, uint16_t *thresh)
{
RMT_CHECK(channel < RMT_CHANNEL_MAX, RMT_CHANNEL_ERROR_STR, ESP_ERR_INVALID_ARG);
RMT_CHECK(thresh != NULL, RMT_ADDR_ERROR_STR, ESP_ERR_INVALID_ARG);
2019-11-19 03:10:02 -05:00
RMT_ENTER_CRITICAL();
*thresh = (uint16_t)rmt_ll_get_rx_idle_thres(p_rmt_obj[channel]->hal.regs, channel);
RMT_EXIT_CRITICAL();
2016-11-09 22:23:40 -05:00
return ESP_OK;
}
esp_err_t rmt_set_mem_block_num(rmt_channel_t channel, uint8_t rmt_mem_num)
{
RMT_CHECK(channel < RMT_CHANNEL_MAX, RMT_CHANNEL_ERROR_STR, ESP_ERR_INVALID_ARG);
RMT_CHECK(rmt_mem_num <= RMT_CHANNEL_MAX - channel, RMT_MEM_CNT_ERROR_STR, ESP_ERR_INVALID_ARG);
2019-11-19 03:10:02 -05:00
RMT_ENTER_CRITICAL();
rmt_ll_set_mem_blocks(p_rmt_obj[channel]->hal.regs, channel, rmt_mem_num);
RMT_EXIT_CRITICAL();
2016-11-09 22:23:40 -05:00
return ESP_OK;
}
2019-11-19 03:10:02 -05:00
esp_err_t rmt_get_mem_block_num(rmt_channel_t channel, uint8_t *rmt_mem_num)
2016-11-09 22:23:40 -05:00
{
RMT_CHECK(channel < RMT_CHANNEL_MAX, RMT_CHANNEL_ERROR_STR, ESP_ERR_INVALID_ARG);
RMT_CHECK(rmt_mem_num != NULL, RMT_ADDR_ERROR_STR, ESP_ERR_INVALID_ARG);
2019-11-19 03:10:02 -05:00
RMT_ENTER_CRITICAL();
*rmt_mem_num = (uint8_t)rmt_ll_get_mem_blocks(p_rmt_obj[channel]->hal.regs, channel);
RMT_EXIT_CRITICAL();
2016-11-09 22:23:40 -05:00
return ESP_OK;
}
esp_err_t rmt_set_tx_carrier(rmt_channel_t channel, bool carrier_en, uint16_t high_level, uint16_t low_level,
2019-11-19 03:10:02 -05:00
rmt_carrier_level_t carrier_level)
2016-11-09 22:23:40 -05:00
{
RMT_CHECK(channel < RMT_CHANNEL_MAX, RMT_CHANNEL_ERROR_STR, ESP_ERR_INVALID_ARG);
RMT_CHECK(carrier_level < RMT_CARRIER_LEVEL_MAX, RMT_CARRIER_ERROR_STR, ESP_ERR_INVALID_ARG);
2019-11-19 03:10:02 -05:00
RMT_ENTER_CRITICAL();
rmt_ll_set_carrier_high_low_ticks(p_rmt_obj[channel]->hal.regs, channel, high_level, low_level);
rmt_ll_set_carrier_to_level(p_rmt_obj[channel]->hal.regs, channel, carrier_level);
rmt_ll_enable_tx_carrier(p_rmt_obj[channel]->hal.regs, channel, carrier_en);
RMT_EXIT_CRITICAL();
2016-11-09 22:23:40 -05:00
return ESP_OK;
}
esp_err_t rmt_set_mem_pd(rmt_channel_t channel, bool pd_en)
{
RMT_CHECK(channel < RMT_CHANNEL_MAX, RMT_CHANNEL_ERROR_STR, ESP_ERR_INVALID_ARG);
2019-11-19 03:10:02 -05:00
RMT_ENTER_CRITICAL();
rmt_ll_power_down_mem(p_rmt_obj[channel]->hal.regs, channel, pd_en);
RMT_EXIT_CRITICAL();
2016-11-09 22:23:40 -05:00
return ESP_OK;
}
2019-11-19 03:10:02 -05:00
esp_err_t rmt_get_mem_pd(rmt_channel_t channel, bool *pd_en)
2016-11-09 22:23:40 -05:00
{
RMT_CHECK(channel < RMT_CHANNEL_MAX, RMT_CHANNEL_ERROR_STR, ESP_ERR_INVALID_ARG);
2019-11-19 03:10:02 -05:00
RMT_ENTER_CRITICAL();
*pd_en = rmt_ll_is_mem_power_down(p_rmt_obj[channel]->hal.regs, channel);
RMT_EXIT_CRITICAL();
2016-11-09 22:23:40 -05:00
return ESP_OK;
}
esp_err_t rmt_tx_start(rmt_channel_t channel, bool tx_idx_rst)
{
RMT_CHECK(channel < RMT_CHANNEL_MAX, RMT_CHANNEL_ERROR_STR, ESP_ERR_INVALID_ARG);
2019-11-19 03:10:02 -05:00
RMT_ENTER_CRITICAL();
if (tx_idx_rst) {
rmt_ll_reset_tx_pointer(p_rmt_obj[channel]->hal.regs, channel);
2016-11-09 22:23:40 -05:00
}
2019-11-19 03:10:02 -05:00
rmt_ll_clear_tx_end_interrupt(p_rmt_obj[channel]->hal.regs, channel);
rmt_ll_enable_tx_end_interrupt(p_rmt_obj[channel]->hal.regs, channel, true);
rmt_ll_start_tx(p_rmt_obj[channel]->hal.regs, channel);
RMT_EXIT_CRITICAL();
2016-11-09 22:23:40 -05:00
return ESP_OK;
}
esp_err_t rmt_tx_stop(rmt_channel_t channel)
{
RMT_CHECK(channel < RMT_CHANNEL_MAX, RMT_CHANNEL_ERROR_STR, ESP_ERR_INVALID_ARG);
2019-11-19 03:10:02 -05:00
RMT_ENTER_CRITICAL();
rmt_ll_stop_tx(p_rmt_obj[channel]->hal.regs, channel);
rmt_ll_reset_tx_pointer(p_rmt_obj[channel]->hal.regs, channel);
RMT_EXIT_CRITICAL();
2016-11-09 22:23:40 -05:00
return ESP_OK;
}
esp_err_t rmt_rx_start(rmt_channel_t channel, bool rx_idx_rst)
{
RMT_CHECK(channel < RMT_CHANNEL_MAX, RMT_CHANNEL_ERROR_STR, ESP_ERR_INVALID_ARG);
2019-11-19 03:10:02 -05:00
RMT_ENTER_CRITICAL();
rmt_ll_enable_rx(p_rmt_obj[channel]->hal.regs, channel, false);
if (rx_idx_rst) {
rmt_ll_reset_rx_pointer(p_rmt_obj[channel]->hal.regs, channel);
2016-11-09 22:23:40 -05:00
}
2019-11-19 03:10:02 -05:00
rmt_ll_clear_rx_end_interrupt(p_rmt_obj[channel]->hal.regs, channel);
rmt_ll_enable_rx_end_interrupt(p_rmt_obj[channel]->hal.regs, channel, true);
rmt_ll_enable_rx(p_rmt_obj[channel]->hal.regs, channel, true);
RMT_EXIT_CRITICAL();
2016-11-09 22:23:40 -05:00
return ESP_OK;
}
esp_err_t rmt_rx_stop(rmt_channel_t channel)
{
RMT_CHECK(channel < RMT_CHANNEL_MAX, RMT_CHANNEL_ERROR_STR, ESP_ERR_INVALID_ARG);
2019-11-19 03:10:02 -05:00
RMT_ENTER_CRITICAL();
rmt_ll_enable_rx(p_rmt_obj[channel]->hal.regs, channel, false);
rmt_ll_enable_rx_end_interrupt(p_rmt_obj[channel]->hal.regs, channel, false);
RMT_EXIT_CRITICAL();
2016-11-09 22:23:40 -05:00
return ESP_OK;
}
esp_err_t rmt_memory_rw_rst(rmt_channel_t channel)
{
RMT_CHECK(channel < RMT_CHANNEL_MAX, RMT_CHANNEL_ERROR_STR, ESP_ERR_INVALID_ARG);
2019-11-19 03:10:02 -05:00
RMT_ENTER_CRITICAL();
rmt_ll_reset_tx_pointer(p_rmt_obj[channel]->hal.regs, channel);
rmt_ll_reset_rx_pointer(p_rmt_obj[channel]->hal.regs, channel);
RMT_EXIT_CRITICAL();
2016-11-09 22:23:40 -05:00
return ESP_OK;
}
esp_err_t rmt_set_memory_owner(rmt_channel_t channel, rmt_mem_owner_t owner)
{
RMT_CHECK(channel < RMT_CHANNEL_MAX, RMT_CHANNEL_ERROR_STR, ESP_ERR_INVALID_ARG);
RMT_CHECK(owner < RMT_MEM_OWNER_MAX, RMT_MEM_OWNER_ERROR_STR, ESP_ERR_INVALID_ARG);
2019-11-19 03:10:02 -05:00
RMT_ENTER_CRITICAL();
rmt_ll_set_mem_owner(p_rmt_obj[channel]->hal.regs, channel, owner);
RMT_EXIT_CRITICAL();
2016-11-09 22:23:40 -05:00
return ESP_OK;
}
2019-11-19 03:10:02 -05:00
esp_err_t rmt_get_memory_owner(rmt_channel_t channel, rmt_mem_owner_t *owner)
2016-11-09 22:23:40 -05:00
{
RMT_CHECK(channel < RMT_CHANNEL_MAX, RMT_CHANNEL_ERROR_STR, ESP_ERR_INVALID_ARG);
RMT_CHECK(owner != NULL, RMT_MEM_OWNER_ERROR_STR, ESP_ERR_INVALID_ARG);
2019-11-19 03:10:02 -05:00
RMT_ENTER_CRITICAL();
*owner = (rmt_mem_owner_t)rmt_ll_get_mem_owner(p_rmt_obj[channel]->hal.regs, channel);
RMT_EXIT_CRITICAL();
2016-11-09 22:23:40 -05:00
return ESP_OK;
}
esp_err_t rmt_set_tx_loop_mode(rmt_channel_t channel, bool loop_en)
{
RMT_CHECK(channel < RMT_CHANNEL_MAX, RMT_CHANNEL_ERROR_STR, ESP_ERR_INVALID_ARG);
2019-11-19 03:10:02 -05:00
RMT_ENTER_CRITICAL();
rmt_ll_enable_tx_cyclic(p_rmt_obj[channel]->hal.regs, channel, loop_en);
RMT_EXIT_CRITICAL();
2016-11-09 22:23:40 -05:00
return ESP_OK;
}
2019-11-19 03:10:02 -05:00
esp_err_t rmt_get_tx_loop_mode(rmt_channel_t channel, bool *loop_en)
2016-11-09 22:23:40 -05:00
{
RMT_CHECK(channel < RMT_CHANNEL_MAX, RMT_CHANNEL_ERROR_STR, ESP_ERR_INVALID_ARG);
2019-11-19 03:10:02 -05:00
RMT_ENTER_CRITICAL();
*loop_en = rmt_ll_is_tx_cyclic_enabled(p_rmt_obj[channel]->hal.regs, channel);
RMT_EXIT_CRITICAL();
2016-11-09 22:23:40 -05:00
return ESP_OK;
}
esp_err_t rmt_set_rx_filter(rmt_channel_t channel, bool rx_filter_en, uint8_t thresh)
{
RMT_CHECK(channel < RMT_CHANNEL_MAX, RMT_CHANNEL_ERROR_STR, ESP_ERR_INVALID_ARG);
2019-11-19 03:10:02 -05:00
RMT_ENTER_CRITICAL();
rmt_ll_enable_rx_filter(p_rmt_obj[channel]->hal.regs, channel, rx_filter_en);
rmt_ll_set_rx_filter_thres(p_rmt_obj[channel]->hal.regs, channel, thresh);
RMT_EXIT_CRITICAL();
2016-11-09 22:23:40 -05:00
return ESP_OK;
}
esp_err_t rmt_set_source_clk(rmt_channel_t channel, rmt_source_clk_t base_clk)
{
RMT_CHECK(channel < RMT_CHANNEL_MAX, RMT_CHANNEL_ERROR_STR, ESP_ERR_INVALID_ARG);
RMT_CHECK(base_clk < RMT_BASECLK_MAX, RMT_BASECLK_ERROR_STR, ESP_ERR_INVALID_ARG);
2019-11-19 03:10:02 -05:00
RMT_ENTER_CRITICAL();
rmt_ll_set_counter_clock_src(p_rmt_obj[channel]->hal.regs, channel, base_clk);
RMT_EXIT_CRITICAL();
2016-11-09 22:23:40 -05:00
return ESP_OK;
}
2019-11-19 03:10:02 -05:00
esp_err_t rmt_get_source_clk(rmt_channel_t channel, rmt_source_clk_t *src_clk)
2016-11-09 22:23:40 -05:00
{
RMT_CHECK(channel < RMT_CHANNEL_MAX, RMT_CHANNEL_ERROR_STR, ESP_ERR_INVALID_ARG);
2019-11-19 03:10:02 -05:00
RMT_ENTER_CRITICAL();
*src_clk = (rmt_source_clk_t)rmt_ll_get_counter_clock_src(p_rmt_obj[channel]->hal.regs, channel);
RMT_EXIT_CRITICAL();
2016-11-09 22:23:40 -05:00
return ESP_OK;
}
esp_err_t rmt_set_idle_level(rmt_channel_t channel, bool idle_out_en, rmt_idle_level_t level)
{
RMT_CHECK(channel < RMT_CHANNEL_MAX, RMT_CHANNEL_ERROR_STR, ESP_ERR_INVALID_ARG);
RMT_CHECK(level < RMT_IDLE_LEVEL_MAX, "RMT IDLE LEVEL ERR", ESP_ERR_INVALID_ARG);
2019-11-19 03:10:02 -05:00
RMT_ENTER_CRITICAL();
rmt_ll_enable_tx_idle(p_rmt_obj[channel]->hal.regs, channel, idle_out_en);
rmt_ll_set_tx_idle_level(p_rmt_obj[channel]->hal.regs, channel, level);
RMT_EXIT_CRITICAL();
2016-11-09 22:23:40 -05:00
return ESP_OK;
}
2019-11-19 03:10:02 -05:00
esp_err_t rmt_get_idle_level(rmt_channel_t channel, bool *idle_out_en, rmt_idle_level_t *level)
{
RMT_CHECK(channel < RMT_CHANNEL_MAX, RMT_CHANNEL_ERROR_STR, ESP_ERR_INVALID_ARG);
2019-11-19 03:10:02 -05:00
RMT_ENTER_CRITICAL();
*idle_out_en = rmt_ll_is_tx_idle_enabled(p_rmt_obj[channel]->hal.regs, channel);
*level = rmt_ll_get_tx_idle_level(p_rmt_obj[channel]->hal.regs, channel);
RMT_EXIT_CRITICAL();
return ESP_OK;
}
2019-11-19 03:10:02 -05:00
esp_err_t rmt_get_status(rmt_channel_t channel, uint32_t *status)
2016-11-09 22:23:40 -05:00
{
RMT_CHECK(channel < RMT_CHANNEL_MAX, RMT_CHANNEL_ERROR_STR, ESP_ERR_INVALID_ARG);
2019-11-19 03:10:02 -05:00
RMT_ENTER_CRITICAL();
*status = rmt_ll_get_channel_status(p_rmt_obj[channel]->hal.regs, channel);
RMT_EXIT_CRITICAL();
2016-11-09 22:23:40 -05:00
return ESP_OK;
}
void rmt_set_intr_enable_mask(uint32_t mask)
{
2019-11-19 03:10:02 -05:00
RMT_ENTER_CRITICAL();
rmt_ll_set_intr_enable_mask(mask);
RMT_EXIT_CRITICAL();
2016-11-09 22:23:40 -05:00
}
void rmt_clr_intr_enable_mask(uint32_t mask)
{
2019-11-19 03:10:02 -05:00
RMT_ENTER_CRITICAL();
rmt_ll_clr_intr_enable_mask(mask);
RMT_EXIT_CRITICAL();
2016-11-09 22:23:40 -05:00
}
esp_err_t rmt_set_rx_intr_en(rmt_channel_t channel, bool en)
{
RMT_CHECK(channel < RMT_CHANNEL_MAX, RMT_CHANNEL_ERROR_STR, ESP_ERR_INVALID_ARG);
2019-11-19 03:10:02 -05:00
RMT_ENTER_CRITICAL();
rmt_ll_enable_rx_end_interrupt(p_rmt_obj[channel]->hal.regs, channel, en);
RMT_EXIT_CRITICAL();
2016-11-09 22:23:40 -05:00
return ESP_OK;
}
esp_err_t rmt_set_err_intr_en(rmt_channel_t channel, bool en)
{
RMT_CHECK(channel < RMT_CHANNEL_MAX, RMT_CHANNEL_ERROR_STR, ESP_ERR_INVALID_ARG);
2019-11-19 03:10:02 -05:00
RMT_ENTER_CRITICAL();
rmt_ll_enable_err_interrupt(p_rmt_obj[channel]->hal.regs, channel, en);
RMT_EXIT_CRITICAL();
2016-11-09 22:23:40 -05:00
return ESP_OK;
}
esp_err_t rmt_set_tx_intr_en(rmt_channel_t channel, bool en)
{
RMT_CHECK(channel < RMT_CHANNEL_MAX, RMT_CHANNEL_ERROR_STR, ESP_ERR_INVALID_ARG);
2019-11-19 03:10:02 -05:00
RMT_ENTER_CRITICAL();
rmt_ll_enable_tx_end_interrupt(p_rmt_obj[channel]->hal.regs, channel, en);
RMT_EXIT_CRITICAL();
2016-11-09 22:23:40 -05:00
return ESP_OK;
}
esp_err_t rmt_set_tx_thr_intr_en(rmt_channel_t channel, bool en, uint16_t evt_thresh)
2016-11-09 22:23:40 -05:00
{
RMT_CHECK(channel < RMT_CHANNEL_MAX, RMT_CHANNEL_ERROR_STR, ESP_ERR_INVALID_ARG);
2019-11-19 03:10:02 -05:00
if (en) {
RMT_CHECK(evt_thresh <= 256, "RMT EVT THRESH ERR", ESP_ERR_INVALID_ARG);
2019-11-19 03:10:02 -05:00
RMT_ENTER_CRITICAL();
rmt_ll_set_tx_limit(p_rmt_obj[channel]->hal.regs, channel, evt_thresh);
rmt_ll_enable_tx_thres_interrupt(p_rmt_obj[channel]->hal.regs, channel, true);
RMT_EXIT_CRITICAL();
2016-11-09 22:23:40 -05:00
} else {
2019-11-19 03:10:02 -05:00
RMT_ENTER_CRITICAL();
rmt_ll_enable_tx_thres_interrupt(p_rmt_obj[channel]->hal.regs, channel, false);
RMT_EXIT_CRITICAL();
2016-11-09 22:23:40 -05:00
}
return ESP_OK;
}
esp_err_t rmt_set_pin(rmt_channel_t channel, rmt_mode_t mode, gpio_num_t gpio_num)
{
RMT_CHECK(channel < RMT_CHANNEL_MAX, RMT_CHANNEL_ERROR_STR, ESP_ERR_INVALID_ARG);
RMT_CHECK(mode < RMT_MODE_MAX, RMT_MODE_ERROR_STR, ESP_ERR_INVALID_ARG);
2019-11-19 03:10:02 -05:00
RMT_CHECK(((GPIO_IS_VALID_GPIO(gpio_num) && (mode == RMT_MODE_RX)) ||
(GPIO_IS_VALID_OUTPUT_GPIO(gpio_num) && (mode == RMT_MODE_TX))),
RMT_GPIO_ERROR_STR, ESP_ERR_INVALID_ARG);
2016-11-09 22:23:40 -05:00
2019-06-06 00:22:38 -04:00
PIN_FUNC_SELECT(GPIO_PIN_MUX_REG[gpio_num], PIN_FUNC_GPIO);
2019-11-19 03:10:02 -05:00
if (mode == RMT_MODE_TX) {
2016-11-09 22:23:40 -05:00
gpio_set_direction(gpio_num, GPIO_MODE_OUTPUT);
gpio_matrix_out(gpio_num, RMT_SIG_OUT0_IDX + channel, 0, 0);
} else {
gpio_set_direction(gpio_num, GPIO_MODE_INPUT);
gpio_matrix_in(gpio_num, RMT_SIG_IN0_IDX + channel, 0);
}
return ESP_OK;
}
2019-11-19 03:10:02 -05:00
static esp_err_t rmt_internal_config(rmt_dev_t *dev, const rmt_config_t *rmt_param)
2016-11-09 22:23:40 -05:00
{
uint8_t mode = rmt_param->rmt_mode;
uint8_t channel = rmt_param->channel;
uint8_t gpio_num = rmt_param->gpio_num;
uint8_t mem_cnt = rmt_param->mem_block_num;
2019-11-19 03:10:02 -05:00
uint8_t clk_div = rmt_param->clk_div;
uint32_t carrier_freq_hz = rmt_param->tx_config.carrier_freq_hz;
bool carrier_en = rmt_param->tx_config.carrier_en;
2019-11-19 03:10:02 -05:00
2016-11-09 22:23:40 -05:00
RMT_CHECK(channel < RMT_CHANNEL_MAX, RMT_CHANNEL_ERROR_STR, ESP_ERR_INVALID_ARG);
RMT_CHECK((mem_cnt + channel <= 8 && mem_cnt > 0), RMT_MEM_CNT_ERROR_STR, ESP_ERR_INVALID_ARG);
RMT_CHECK((clk_div > 0), RMT_CLK_DIV_ERROR_STR, ESP_ERR_INVALID_ARG);
2019-11-19 03:10:02 -05:00
if (mode == RMT_MODE_TX) {
RMT_CHECK((!carrier_en || carrier_freq_hz > 0), "RMT carrier frequency can't be zero", ESP_ERR_INVALID_ARG);
}
2019-11-19 03:10:02 -05:00
RMT_ENTER_CRITICAL();
rmt_ll_set_counter_clock_div(dev, channel, clk_div);
rmt_ll_enable_mem_access(dev, true);
rmt_ll_reset_tx_pointer(dev, channel);
rmt_ll_reset_rx_pointer(dev, channel);
rmt_ll_set_counter_clock_src(dev, channel, RMT_BASECLK_APB); // only support APB clock for now
rmt_ll_set_mem_blocks(dev, channel, mem_cnt);
rmt_ll_set_mem_owner(dev, channel, RMT_MEM_OWNER_HW);
RMT_EXIT_CRITICAL();
uint32_t rmt_source_clk_hz = RMT_SOURCE_CLK(RMT_BASECLK_APB);
2016-11-09 22:23:40 -05:00
2019-11-19 03:10:02 -05:00
if (mode == RMT_MODE_TX) {
2016-11-09 22:23:40 -05:00
uint16_t carrier_duty_percent = rmt_param->tx_config.carrier_duty_percent;
uint8_t carrier_level = rmt_param->tx_config.carrier_level;
uint8_t idle_level = rmt_param->tx_config.idle_level;
2019-11-19 03:10:02 -05:00
RMT_ENTER_CRITICAL();
rmt_ll_enable_tx_cyclic(dev, channel, rmt_param->tx_config.loop_en);
rmt_ll_enable_tx_pingpong(dev, true);
2016-11-09 22:23:40 -05:00
/*Set idle level */
2019-11-19 03:10:02 -05:00
rmt_ll_enable_tx_idle(dev, channel, rmt_param->tx_config.idle_output_en);
rmt_ll_set_tx_idle_level(dev, channel, idle_level);
2016-11-09 22:23:40 -05:00
/*Set carrier*/
2019-11-19 03:10:02 -05:00
rmt_ll_enable_tx_carrier(dev, channel, carrier_en);
if (carrier_en) {
uint32_t duty_div, duty_h, duty_l;
duty_div = rmt_source_clk_hz / carrier_freq_hz;
duty_h = duty_div * carrier_duty_percent / 100;
duty_l = duty_div - duty_h;
2019-11-19 03:10:02 -05:00
rmt_ll_set_carrier_to_level(dev, channel, carrier_level);
rmt_ll_set_carrier_high_low_ticks(dev, channel, duty_h, duty_l);
} else {
2019-11-19 03:10:02 -05:00
rmt_ll_set_carrier_to_level(dev, channel, 0);
rmt_ll_set_carrier_high_low_ticks(dev, channel, 0, 0);
}
2019-11-19 03:10:02 -05:00
RMT_EXIT_CRITICAL();
2016-11-09 22:23:40 -05:00
ESP_LOGD(RMT_TAG, "Rmt Tx Channel %u|Gpio %u|Sclk_Hz %u|Div %u|Carrier_Hz %u|Duty %u",
channel, gpio_num, rmt_source_clk_hz, clk_div, carrier_freq_hz, carrier_duty_percent);
2019-11-19 03:10:02 -05:00
} else if (RMT_MODE_RX == mode) {
2016-11-09 22:23:40 -05:00
uint8_t filter_cnt = rmt_param->rx_config.filter_ticks_thresh;
uint16_t threshold = rmt_param->rx_config.idle_threshold;
2019-11-19 03:10:02 -05:00
RMT_ENTER_CRITICAL();
2016-11-09 22:23:40 -05:00
/*Set idle threshold*/
2019-11-19 03:10:02 -05:00
rmt_ll_set_rx_idle_thres(dev, channel, threshold);
2016-11-09 22:23:40 -05:00
/* Set RX filter */
2019-11-19 03:10:02 -05:00
rmt_ll_set_rx_filter_thres(dev, channel, filter_cnt);
rmt_ll_enable_rx_filter(dev, channel, rmt_param->rx_config.filter_en);
RMT_EXIT_CRITICAL();
2016-11-09 22:23:40 -05:00
ESP_LOGD(RMT_TAG, "Rmt Rx Channel %u|Gpio %u|Sclk_Hz %u|Div %u|Thresold %u|Filter %u",
2019-11-19 03:10:02 -05:00
channel, gpio_num, rmt_source_clk_hz, clk_div, threshold, filter_cnt);
2016-11-09 22:23:40 -05:00
}
return ESP_OK;
}
2019-11-19 03:10:02 -05:00
esp_err_t rmt_config(const rmt_config_t *rmt_param)
2016-11-09 22:23:40 -05:00
{
2019-11-19 03:10:02 -05:00
// reset the RMT module at the first time initialize RMT driver
static bool rmt_module_enabled = false;
if (rmt_module_enabled == false) {
periph_module_reset(PERIPH_RMT_MODULE);
rmt_module_enabled = true;
2016-11-09 22:23:40 -05:00
}
2019-11-19 03:10:02 -05:00
periph_module_enable(PERIPH_RMT_MODULE);
RMT_CHECK(rmt_set_pin(rmt_param->channel, rmt_param->rmt_mode, rmt_param->gpio_num) == ESP_OK,
"set gpio for RMT driver failed", ESP_ERR_INVALID_ARG);
RMT_CHECK(rmt_internal_config(&RMT, rmt_param) == ESP_OK,
"initialize RMT driver failed", ESP_ERR_INVALID_ARG);
return ESP_OK;
}
static void IRAM_ATTR rmt_fill_memory(rmt_channel_t channel, const rmt_item32_t *item,
uint16_t item_num, uint16_t mem_offset)
{
RMT_ENTER_CRITICAL();
rmt_ll_set_mem_owner(p_rmt_obj[channel]->hal.regs, channel, RMT_MEM_OWNER_SW);
rmt_ll_write_memory(p_rmt_obj[channel]->hal.mem, channel, item, item_num, mem_offset);
rmt_ll_set_mem_owner(p_rmt_obj[channel]->hal.regs, channel, RMT_MEM_OWNER_HW);
RMT_EXIT_CRITICAL();
2016-11-09 22:23:40 -05:00
}
2019-11-19 03:10:02 -05:00
esp_err_t rmt_fill_tx_items(rmt_channel_t channel, const rmt_item32_t *item, uint16_t item_num, uint16_t mem_offset)
2016-11-09 22:23:40 -05:00
{
RMT_CHECK(channel < RMT_CHANNEL_MAX, RMT_CHANNEL_ERROR_STR, (0));
RMT_CHECK((item != NULL), RMT_ADDR_ERROR_STR, ESP_ERR_INVALID_ARG);
RMT_CHECK((item_num > 0), RMT_DRIVER_LENGTH_ERROR_STR, ESP_ERR_INVALID_ARG);
/*Each block has 64 x 32 bits of data*/
2019-11-19 03:10:02 -05:00
uint8_t mem_cnt = rmt_ll_get_mem_blocks(p_rmt_obj[channel]->hal.regs, channel);
2016-11-09 22:23:40 -05:00
RMT_CHECK((mem_cnt * RMT_MEM_ITEM_NUM >= item_num), RMT_WR_MEM_OVF_ERROR_STR, ESP_ERR_INVALID_ARG);
rmt_fill_memory(channel, item, item_num, mem_offset);
return ESP_OK;
}
2019-11-19 03:10:02 -05:00
esp_err_t rmt_isr_register(void (*fn)(void *), void *arg, int intr_alloc_flags, rmt_isr_handle_t *handle)
2016-11-09 22:23:40 -05:00
{
RMT_CHECK((fn != NULL), RMT_ADDR_ERROR_STR, ESP_ERR_INVALID_ARG);
RMT_CHECK(s_rmt_driver_channels == 0, "RMT driver installed, can not install generic ISR handler", ESP_FAIL);
return esp_intr_alloc(ETS_RMT_INTR_SOURCE, intr_alloc_flags, fn, arg, handle);
2016-11-09 22:23:40 -05:00
}
esp_err_t rmt_isr_deregister(rmt_isr_handle_t handle)
{
return esp_intr_free(handle);
}
2016-11-09 22:23:40 -05:00
static int IRAM_ATTR rmt_get_mem_len(rmt_channel_t channel)
{
2019-11-19 03:10:02 -05:00
int block_num = rmt_ll_get_mem_blocks(p_rmt_obj[channel]->hal.regs, channel);
2016-11-09 22:23:40 -05:00
int item_block_len = block_num * RMT_MEM_ITEM_NUM;
2019-11-19 03:10:02 -05:00
volatile rmt_item32_t *data = (rmt_item32_t *)RMTMEM.chan[channel].data32;
2016-11-09 22:23:40 -05:00
int idx;
2019-11-19 03:10:02 -05:00
for (idx = 0; idx < item_block_len; idx++) {
if (data[idx].duration0 == 0) {
2016-11-09 22:23:40 -05:00
return idx;
2019-11-19 03:10:02 -05:00
} else if (data[idx].duration1 == 0) {
2016-11-09 22:23:40 -05:00
return idx + 1;
}
}
return idx;
}
2019-11-19 03:10:02 -05:00
static void IRAM_ATTR rmt_driver_isr_default(void *arg)
2016-11-09 22:23:40 -05:00
{
2019-11-19 03:10:02 -05:00
uint32_t status = 0;
rmt_item32_t volatile *addr = NULL;
uint8_t channel = 0;
rmt_hal_context_t *hal = (rmt_hal_context_t *)arg;
portBASE_TYPE HPTaskAwoken = pdFALSE;
// Tx end interrupt
status = rmt_ll_get_tx_end_interrupt_status(hal->regs);
while (status) {
2019-11-19 03:10:02 -05:00
channel = __builtin_ffs(status) - 1;
status &= ~(1 << channel);
rmt_obj_t *p_rmt = p_rmt_obj[channel];
if (p_rmt) {
xSemaphoreGiveFromISR(p_rmt->tx_sem, &HPTaskAwoken);
rmt_ll_reset_tx_pointer(p_rmt_obj[channel]->hal.regs, channel);
p_rmt->tx_data = NULL;
p_rmt->tx_len_rem = 0;
p_rmt->tx_offset = 0;
p_rmt->tx_sub_len = 0;
p_rmt->sample_cur = NULL;
p_rmt->translator = false;
if (rmt_tx_end_callback.function != NULL) {
rmt_tx_end_callback.function(channel, rmt_tx_end_callback.arg);
2016-11-09 22:23:40 -05:00
}
2019-11-19 03:10:02 -05:00
}
rmt_ll_clear_tx_end_interrupt(hal->regs, channel);
}
// Tx thres interrupt
status = rmt_ll_get_tx_thres_interrupt_status(hal->regs);
while (status) {
channel = __builtin_ffs(status) - 1;
status &= ~(1 << channel);
rmt_obj_t *p_rmt = p_rmt_obj[channel];
if (p_rmt) {
if (p_rmt->translator) {
if (p_rmt->sample_size_remain > 0) {
size_t translated_size = 0;
p_rmt->sample_to_rmt((void *)p_rmt->sample_cur,
p_rmt->tx_buf,
p_rmt->sample_size_remain,
p_rmt->tx_sub_len,
&translated_size,
&p_rmt->tx_len_rem);
p_rmt->sample_size_remain -= translated_size;
p_rmt->sample_cur += translated_size;
p_rmt->tx_data = p_rmt->tx_buf;
} else {
p_rmt->sample_cur = NULL;
p_rmt->translator = false;
2019-11-19 03:10:02 -05:00
}
}
2019-11-19 03:10:02 -05:00
const rmt_item32_t *pdata = p_rmt->tx_data;
int len_rem = p_rmt->tx_len_rem;
if (len_rem >= p_rmt->tx_sub_len) {
rmt_fill_memory(channel, pdata, p_rmt->tx_sub_len, p_rmt->tx_offset);
p_rmt->tx_data += p_rmt->tx_sub_len;
p_rmt->tx_len_rem -= p_rmt->tx_sub_len;
} else if (len_rem == 0) {
rmt_item32_t stop_data = {0};
rmt_ll_write_memory(p_rmt_obj[channel]->hal.mem, channel, &stop_data, 1, p_rmt->tx_offset);
} else {
2019-11-19 03:10:02 -05:00
rmt_fill_memory(channel, pdata, len_rem, p_rmt->tx_offset);
rmt_item32_t stop_data = {0};
rmt_ll_write_memory(p_rmt_obj[channel]->hal.mem, channel, &stop_data, 1, p_rmt->tx_offset + len_rem);
p_rmt->tx_data += len_rem;
p_rmt->tx_len_rem -= len_rem;
}
if (p_rmt->tx_offset == 0) {
p_rmt->tx_offset = p_rmt->tx_sub_len;
} else {
p_rmt->tx_offset = 0;
}
}
rmt_ll_clear_tx_thres_interrupt(hal->regs, channel);
}
// Rx end interrupt
status = rmt_ll_get_rx_end_interrupt_status(hal->regs);
while (status) {
channel = __builtin_ffs(status) - 1;
status &= ~(1 << channel);
rmt_obj_t *p_rmt = p_rmt_obj[channel];
if (p_rmt) {
rmt_ll_enable_rx(p_rmt_obj[channel]->hal.regs, channel, false);
int item_len = rmt_get_mem_len(channel);
rmt_ll_set_mem_owner(p_rmt_obj[channel]->hal.regs, channel, RMT_MEM_OWNER_SW);
if (p_rmt->rx_buf) {
addr = RMTMEM.chan[channel].data32;
BaseType_t res = xRingbufferSendFromISR(p_rmt->rx_buf, (void *)addr, item_len * 4, &HPTaskAwoken);
if (res == pdFALSE) {
ESP_EARLY_LOGE(RMT_TAG, "RMT RX BUFFER FULL");
}
2019-11-19 03:10:02 -05:00
} else {
ESP_EARLY_LOGE(RMT_TAG, "RMT RX BUFFER ERROR");
2016-11-09 22:23:40 -05:00
}
2019-11-19 03:10:02 -05:00
rmt_ll_reset_rx_pointer(p_rmt_obj[channel]->hal.regs, channel);
rmt_ll_set_mem_owner(p_rmt_obj[channel]->hal.regs, channel, RMT_MEM_OWNER_HW);
rmt_ll_enable_rx(p_rmt_obj[channel]->hal.regs, channel, true);
}
rmt_ll_clear_rx_end_interrupt(hal->regs, channel);
}
// Err interrupt
status = rmt_ll_get_err_interrupt_status(hal->regs);
while (status) {
channel = __builtin_ffs(status) - 1;
status &= ~(1 << channel);
rmt_obj_t *p_rmt = p_rmt_obj[channel];
if (p_rmt) {
// Reset the receiver/transmitter's write/read addresses to prevent endless err interrupts.
rmt_ll_reset_tx_pointer(p_rmt_obj[channel]->hal.regs, channel);
rmt_ll_reset_rx_pointer(p_rmt_obj[channel]->hal.regs, channel);
2019-11-19 03:10:02 -05:00
ESP_EARLY_LOGD(RMT_TAG, "RMT[%d] ERR", channel);
ESP_EARLY_LOGD(RMT_TAG, "status: 0x%08x", rmt_ll_get_channel_status(p_rmt_obj[channel]->hal.regs, channel));
2016-11-09 22:23:40 -05:00
}
2019-11-19 03:10:02 -05:00
rmt_ll_clear_err_interrupt(hal->regs, channel);
2016-11-09 22:23:40 -05:00
}
2019-11-19 03:10:02 -05:00
if (HPTaskAwoken == pdTRUE) {
portYIELD_FROM_ISR();
}
2016-11-09 22:23:40 -05:00
}
esp_err_t rmt_driver_uninstall(rmt_channel_t channel)
{
esp_err_t err = ESP_OK;
2016-11-09 22:23:40 -05:00
RMT_CHECK(channel < RMT_CHANNEL_MAX, RMT_CHANNEL_ERROR_STR, ESP_ERR_INVALID_ARG);
RMT_CHECK((s_rmt_driver_channels & BIT(channel)) != 0, "No RMT driver for this channel", ESP_ERR_INVALID_STATE);
2019-11-19 03:10:02 -05:00
if (p_rmt_obj[channel] == NULL) {
2016-11-09 22:23:40 -05:00
return ESP_OK;
}
2018-02-24 03:36:21 -05:00
//Avoid blocking here(when the interrupt is disabled and do not wait tx done).
2019-11-19 03:10:02 -05:00
if (p_rmt_obj[channel]->wait_done) {
xSemaphoreTake(p_rmt_obj[channel]->tx_sem, portMAX_DELAY);
2018-02-24 03:36:21 -05:00
}
2016-11-09 22:23:40 -05:00
rmt_set_rx_intr_en(channel, 0);
rmt_set_err_intr_en(channel, 0);
rmt_set_tx_intr_en(channel, 0);
rmt_set_tx_thr_intr_en(channel, 0, 0xffff);
_lock_acquire_recursive(&rmt_driver_isr_lock);
s_rmt_driver_channels &= ~BIT(channel);
2019-11-19 03:10:02 -05:00
if (s_rmt_driver_channels == 0) {
// all channels have driver disabled
err = rmt_isr_deregister(s_rmt_driver_intr_handle);
s_rmt_driver_intr_handle = NULL;
}
_lock_release_recursive(&rmt_driver_isr_lock);
if (err != ESP_OK) {
return err;
}
2019-11-19 03:10:02 -05:00
if (p_rmt_obj[channel]->tx_sem) {
2016-11-09 22:23:40 -05:00
vSemaphoreDelete(p_rmt_obj[channel]->tx_sem);
p_rmt_obj[channel]->tx_sem = NULL;
}
2019-11-19 03:10:02 -05:00
if (p_rmt_obj[channel]->rx_buf) {
2016-11-09 22:23:40 -05:00
vRingbufferDelete(p_rmt_obj[channel]->rx_buf);
p_rmt_obj[channel]->rx_buf = NULL;
}
2019-11-19 03:10:02 -05:00
if (p_rmt_obj[channel]->tx_buf) {
free(p_rmt_obj[channel]->tx_buf);
p_rmt_obj[channel]->tx_buf = NULL;
}
2019-11-19 03:10:02 -05:00
if (p_rmt_obj[channel]->sample_to_rmt) {
p_rmt_obj[channel]->sample_to_rmt = NULL;
}
2016-11-09 22:23:40 -05:00
free(p_rmt_obj[channel]);
p_rmt_obj[channel] = NULL;
return ESP_OK;
2016-11-09 22:23:40 -05:00
}
esp_err_t rmt_driver_install(rmt_channel_t channel, size_t rx_buf_size, int intr_alloc_flags)
2016-11-09 22:23:40 -05:00
{
RMT_CHECK(channel < RMT_CHANNEL_MAX, RMT_CHANNEL_ERROR_STR, ESP_ERR_INVALID_ARG);
2019-11-19 03:10:02 -05:00
RMT_CHECK((s_rmt_driver_channels & BIT(channel)) == 0,
"RMT driver already installed for channel", ESP_ERR_INVALID_STATE);
esp_err_t err = ESP_OK;
2019-11-19 03:10:02 -05:00
if (p_rmt_obj[channel] != NULL) {
ESP_LOGD(RMT_TAG, "RMT driver already installed");
return ESP_ERR_INVALID_STATE;
2016-11-09 22:23:40 -05:00
}
#if !CONFIG_SPIRAM_USE_MALLOC
2019-11-19 03:10:02 -05:00
p_rmt_obj[channel] = (rmt_obj_t *)malloc(sizeof(rmt_obj_t));
#else
2019-11-19 03:10:02 -05:00
if (!(intr_alloc_flags & ESP_INTR_FLAG_IRAM)) {
p_rmt_obj[channel] = (rmt_obj_t *)malloc(sizeof(rmt_obj_t));
} else {
2019-11-19 03:10:02 -05:00
p_rmt_obj[channel] = (rmt_obj_t *)heap_caps_calloc(1, sizeof(rmt_obj_t), MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT);
}
#endif
2016-11-09 22:23:40 -05:00
2019-11-19 03:10:02 -05:00
if (p_rmt_obj[channel] == NULL) {
2016-11-09 22:23:40 -05:00
ESP_LOGE(RMT_TAG, "RMT driver malloc error");
return ESP_ERR_NO_MEM;
2016-11-09 22:23:40 -05:00
}
memset(p_rmt_obj[channel], 0, sizeof(rmt_obj_t));
2019-11-19 03:10:02 -05:00
rmt_hal_init(&p_rmt_obj[channel]->hal);
rmt_hal_channel_reset(&p_rmt_obj[channel]->hal, channel);
2016-11-09 22:23:40 -05:00
p_rmt_obj[channel]->tx_len_rem = 0;
p_rmt_obj[channel]->tx_data = NULL;
p_rmt_obj[channel]->channel = channel;
p_rmt_obj[channel]->tx_offset = 0;
p_rmt_obj[channel]->tx_sub_len = 0;
2018-02-24 03:36:21 -05:00
p_rmt_obj[channel]->wait_done = false;
p_rmt_obj[channel]->translator = false;
p_rmt_obj[channel]->sample_to_rmt = NULL;
2019-11-19 03:10:02 -05:00
if (p_rmt_obj[channel]->tx_sem == NULL) {
#if !CONFIG_SPIRAM_USE_MALLOC
2016-11-09 22:23:40 -05:00
p_rmt_obj[channel]->tx_sem = xSemaphoreCreateBinary();
#else
p_rmt_obj[channel]->intr_alloc_flags = intr_alloc_flags;
2019-11-19 03:10:02 -05:00
if (!(intr_alloc_flags & ESP_INTR_FLAG_IRAM)) {
p_rmt_obj[channel]->tx_sem = xSemaphoreCreateBinary();
} else {
p_rmt_obj[channel]->tx_sem = xSemaphoreCreateBinaryStatic(&p_rmt_obj[channel]->tx_sem_buffer);
}
#endif
2016-11-09 22:23:40 -05:00
xSemaphoreGive(p_rmt_obj[channel]->tx_sem);
}
2019-11-19 03:10:02 -05:00
if (p_rmt_obj[channel]->rx_buf == NULL && rx_buf_size > 0) {
2016-11-09 22:23:40 -05:00
p_rmt_obj[channel]->rx_buf = xRingbufferCreate(rx_buf_size, RINGBUF_TYPE_NOSPLIT);
}
2019-11-19 03:10:02 -05:00
rmt_set_err_intr_en(channel, 1);
_lock_acquire_recursive(&rmt_driver_isr_lock);
2019-11-19 03:10:02 -05:00
if (s_rmt_driver_channels == 0) {
// first RMT channel using driver
err = rmt_isr_register(rmt_driver_isr_default, &p_rmt_obj[channel]->hal, intr_alloc_flags, &s_rmt_driver_intr_handle);
2016-11-09 22:23:40 -05:00
}
if (err == ESP_OK) {
s_rmt_driver_channels |= BIT(channel);
}
_lock_release_recursive(&rmt_driver_isr_lock);
return err;
2016-11-09 22:23:40 -05:00
}
2019-11-19 03:10:02 -05:00
esp_err_t rmt_write_items(rmt_channel_t channel, const rmt_item32_t *rmt_item, int item_num, bool wait_tx_done)
2016-11-09 22:23:40 -05:00
{
RMT_CHECK(channel < RMT_CHANNEL_MAX, RMT_CHANNEL_ERROR_STR, ESP_ERR_INVALID_ARG);
RMT_CHECK(p_rmt_obj[channel] != NULL, RMT_DRIVER_ERROR_STR, ESP_FAIL);
RMT_CHECK(rmt_item != NULL, RMT_ADDR_ERROR_STR, ESP_FAIL);
RMT_CHECK(item_num > 0, RMT_DRIVER_LENGTH_ERROR_STR, ESP_ERR_INVALID_ARG);
#if CONFIG_SPIRAM_USE_MALLOC
2019-11-19 03:10:02 -05:00
if (p_rmt_obj[channel]->intr_alloc_flags & ESP_INTR_FLAG_IRAM) {
if (!esp_ptr_internal(rmt_item)) {
ESP_LOGE(RMT_TAG, RMT_PSRAM_BUFFER_WARN_STR);
return ESP_ERR_INVALID_ARG;
}
}
#endif
2019-11-19 03:10:02 -05:00
rmt_obj_t *p_rmt = p_rmt_obj[channel];
int block_num = rmt_ll_get_mem_blocks(p_rmt_obj[channel]->hal.regs, channel);
2016-11-09 22:23:40 -05:00
int item_block_len = block_num * RMT_MEM_ITEM_NUM;
int item_sub_len = block_num * RMT_MEM_ITEM_NUM / 2;
int len_rem = item_num;
xSemaphoreTake(p_rmt->tx_sem, portMAX_DELAY);
// fill the memory block first
2019-11-19 03:10:02 -05:00
if (item_num >= item_block_len) {
2016-11-09 22:23:40 -05:00
rmt_fill_memory(channel, rmt_item, item_block_len, 0);
len_rem -= item_block_len;
rmt_set_tx_loop_mode(channel, false);
rmt_set_tx_thr_intr_en(channel, 1, item_sub_len);
2016-11-09 22:23:40 -05:00
p_rmt->tx_data = rmt_item + item_block_len;
p_rmt->tx_len_rem = len_rem;
p_rmt->tx_offset = 0;
p_rmt->tx_sub_len = item_sub_len;
} else {
rmt_fill_memory(channel, rmt_item, len_rem, 0);
2019-11-19 03:10:02 -05:00
rmt_item32_t stop_data = {0};
rmt_ll_write_memory(p_rmt_obj[channel]->hal.mem, channel, &stop_data, 1, len_rem);
2018-02-24 03:36:21 -05:00
p_rmt->tx_len_rem = 0;
2016-11-09 22:23:40 -05:00
}
rmt_tx_start(channel, true);
2018-02-24 03:36:21 -05:00
p_rmt->wait_done = wait_tx_done;
2019-11-19 03:10:02 -05:00
if (wait_tx_done) {
2016-11-09 22:23:40 -05:00
xSemaphoreTake(p_rmt->tx_sem, portMAX_DELAY);
xSemaphoreGive(p_rmt->tx_sem);
}
return ESP_OK;
}
esp_err_t rmt_wait_tx_done(rmt_channel_t channel, TickType_t wait_time)
2016-11-09 22:23:40 -05:00
{
RMT_CHECK(channel < RMT_CHANNEL_MAX, RMT_CHANNEL_ERROR_STR, ESP_ERR_INVALID_ARG);
RMT_CHECK(p_rmt_obj[channel] != NULL, RMT_DRIVER_ERROR_STR, ESP_FAIL);
2019-11-19 03:10:02 -05:00
if (xSemaphoreTake(p_rmt_obj[channel]->tx_sem, wait_time) == pdTRUE) {
2018-02-24 03:36:21 -05:00
p_rmt_obj[channel]->wait_done = false;
xSemaphoreGive(p_rmt_obj[channel]->tx_sem);
return ESP_OK;
2019-11-19 03:10:02 -05:00
} else {
if (wait_time != 0) {
// Don't emit error message if just polling.
ESP_LOGE(RMT_TAG, "Timeout on wait_tx_done");
}
return ESP_ERR_TIMEOUT;
}
2016-11-09 22:23:40 -05:00
}
2019-11-19 03:10:02 -05:00
esp_err_t rmt_get_ringbuf_handle(rmt_channel_t channel, RingbufHandle_t *buf_handle)
2016-11-09 22:23:40 -05:00
{
RMT_CHECK(channel < RMT_CHANNEL_MAX, RMT_CHANNEL_ERROR_STR, ESP_ERR_INVALID_ARG);
RMT_CHECK(p_rmt_obj[channel] != NULL, RMT_DRIVER_ERROR_STR, ESP_FAIL);
RMT_CHECK(buf_handle != NULL, RMT_ADDR_ERROR_STR, ESP_ERR_INVALID_ARG);
*buf_handle = p_rmt_obj[channel]->rx_buf;
2016-11-09 22:23:40 -05:00
return ESP_OK;
}
rmt_tx_end_callback_t rmt_register_tx_end_callback(rmt_tx_end_fn_t function, void *arg)
{
rmt_tx_end_callback_t previous = rmt_tx_end_callback;
rmt_tx_end_callback.function = function;
rmt_tx_end_callback.arg = arg;
return previous;
}
esp_err_t rmt_translator_init(rmt_channel_t channel, sample_to_rmt_t fn)
{
RMT_CHECK(fn != NULL, RMT_TRANSLATOR_NULL_STR, ESP_ERR_INVALID_ARG);
RMT_CHECK(channel < RMT_CHANNEL_MAX, RMT_CHANNEL_ERROR_STR, ESP_ERR_INVALID_ARG);
RMT_CHECK(p_rmt_obj[channel] != NULL, RMT_DRIVER_ERROR_STR, ESP_FAIL);
2019-11-19 03:10:02 -05:00
const uint32_t block_size = rmt_ll_get_mem_blocks(p_rmt_obj[channel]->hal.regs, channel) *
RMT_MEM_ITEM_NUM * sizeof(rmt_item32_t);
if (p_rmt_obj[channel]->tx_buf == NULL) {
#if !CONFIG_SPIRAM_USE_MALLOC
p_rmt_obj[channel]->tx_buf = (rmt_item32_t *)malloc(block_size);
#else
2019-11-19 03:10:02 -05:00
if (p_rmt_obj[channel]->intr_alloc_flags & ESP_INTR_FLAG_IRAM) {
p_rmt_obj[channel]->tx_buf = (rmt_item32_t *)malloc(block_size);
} else {
2019-11-19 03:10:02 -05:00
p_rmt_obj[channel]->tx_buf = (rmt_item32_t *)heap_caps_calloc(1, block_size, MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT);
}
#endif
2019-11-19 03:10:02 -05:00
if (p_rmt_obj[channel]->tx_buf == NULL) {
ESP_LOGE(RMT_TAG, "RMT translator buffer create fail");
return ESP_FAIL;
}
}
p_rmt_obj[channel]->sample_to_rmt = fn;
p_rmt_obj[channel]->sample_size_remain = 0;
p_rmt_obj[channel]->sample_cur = NULL;
ESP_LOGD(RMT_TAG, "RMT translator init done");
return ESP_OK;
}
esp_err_t rmt_write_sample(rmt_channel_t channel, const uint8_t *src, size_t src_size, bool wait_tx_done)
{
RMT_CHECK(channel < RMT_CHANNEL_MAX, RMT_CHANNEL_ERROR_STR, ESP_ERR_INVALID_ARG);
RMT_CHECK(p_rmt_obj[channel] != NULL, RMT_DRIVER_ERROR_STR, ESP_FAIL);
2019-11-19 03:10:02 -05:00
RMT_CHECK(p_rmt_obj[channel]->sample_to_rmt != NULL, RMT_TRANSLATOR_UNINIT_STR, ESP_FAIL);
#if CONFIG_SPIRAM_USE_MALLOC
2019-11-19 03:10:02 -05:00
if (p_rmt_obj[channel]->intr_alloc_flags & ESP_INTR_FLAG_IRAM) {
if (!esp_ptr_internal(src)) {
ESP_LOGE(RMT_TAG, RMT_PSRAM_BUFFER_WARN_STR);
return ESP_ERR_INVALID_ARG;
}
}
#endif
size_t item_num = 0;
size_t translated_size = 0;
2019-11-19 03:10:02 -05:00
rmt_obj_t *p_rmt = p_rmt_obj[channel];
const uint32_t item_block_len = rmt_ll_get_mem_blocks(p_rmt_obj[channel]->hal.regs, channel) * RMT_MEM_ITEM_NUM;
const uint32_t item_sub_len = item_block_len / 2;
xSemaphoreTake(p_rmt->tx_sem, portMAX_DELAY);
p_rmt->sample_to_rmt((void *)src, p_rmt->tx_buf, src_size, item_block_len, &translated_size, &item_num);
p_rmt->sample_size_remain = src_size - translated_size;
p_rmt->sample_cur = src + translated_size;
rmt_fill_memory(channel, p_rmt->tx_buf, item_num, 0);
if (item_num == item_block_len) {
rmt_set_tx_thr_intr_en(channel, 1, item_sub_len);
p_rmt->tx_data = p_rmt->tx_buf;
p_rmt->tx_offset = 0;
p_rmt->tx_sub_len = item_sub_len;
p_rmt->translator = true;
} else {
2019-11-19 03:10:02 -05:00
rmt_item32_t stop_data = {0};
rmt_ll_write_memory(p_rmt_obj[channel]->hal.mem, channel, &stop_data, 1, item_num);
p_rmt->tx_len_rem = 0;
p_rmt->sample_cur = NULL;
p_rmt->translator = false;
}
rmt_tx_start(channel, true);
p_rmt->wait_done = wait_tx_done;
if (wait_tx_done) {
xSemaphoreTake(p_rmt->tx_sem, portMAX_DELAY);
xSemaphoreGive(p_rmt->tx_sem);
}
return ESP_OK;
}
esp_err_t rmt_get_channel_status(rmt_channel_status_result_t *channel_status)
{
RMT_CHECK(channel_status != NULL, RMT_PARAM_ERR_STR, ESP_ERR_INVALID_ARG);
2019-11-19 03:10:02 -05:00
for (int i = 0; i < RMT_CHANNEL_MAX; i++) {
channel_status->status[i] = RMT_CHANNEL_UNINIT;
if (p_rmt_obj[i] != NULL) {
if (p_rmt_obj[i]->tx_sem != NULL) {
if (xSemaphoreTake(p_rmt_obj[i]->tx_sem, (TickType_t)0) == pdTRUE) {
channel_status->status[i] = RMT_CHANNEL_IDLE;
global: move the soc component out of the common list This MR removes the common dependency from every IDF components to the SOC component. Currently, in the ``idf_functions.cmake`` script, we include the header path of SOC component by default for all components. But for better code organization (or maybe also benifits to the compiling speed), we may remove the dependency to SOC components for most components except the driver and kernel related components. In CMAKE, we have two kinds of header visibilities (set by include path visibility): (Assume component A --(depends on)--> B, B is the current component) 1. public (``COMPONENT_ADD_INCLUDEDIRS``): means this path is visible to other depending components (A) (visible to A and B) 2. private (``COMPONENT_PRIV_INCLUDEDIRS``): means this path is only visible to source files inside the component (visible to B only) and we have two kinds of depending ways: (Assume component A --(depends on)--> B --(depends on)--> C, B is the current component) 1. public (```COMPONENT_REQUIRES```): means B can access to public include path of C. All other components rely on you (A) will also be available for the public headers. (visible to A, B) 2. private (``COMPONENT_PRIV_REQUIRES``): means B can access to public include path of C, but don't propagate this relation to other components (A). (visible to B) 1. remove the common requirement in ``idf_functions.cmake``, this makes the SOC components invisible to all other components by default. 2. if a component (for example, DRIVER) really needs the dependency to SOC, add a private dependency to SOC for it. 3. some other components that don't really depends on the SOC may still meet some errors saying "can't find header soc/...", this is because it's depended component (DRIVER) incorrectly include the header of SOC in its public headers. Moving all this kind of #include into source files, or private headers 4. Fix the include requirements for some file which miss sufficient #include directives. (Previously they include some headers by the long long long header include link) This is a breaking change. Previous code may depends on the long include chain. You may need to include the following headers for some files after this commit: - soc/soc.h - soc/soc_memory_layout.h - driver/gpio.h - esp_sleep.h The major broken include chain includes: 1. esp_system.h no longer includes esp_sleep.h. The latter includes driver/gpio.h and driver/touch_pad.h. 2. ets_sys.h no longer includes soc/soc.h 3. freertos/portmacro.h no longer includes soc/soc_memory_layout.h some peripheral headers no longer includes their hw related headers, e.g. rom/gpio.h no longer includes soc/gpio_pins.h and soc/gpio_reg.h BREAKING CHANGE
2019-04-03 01:17:38 -04:00
xSemaphoreGive(p_rmt_obj[i]->tx_sem);
} else {
channel_status->status[i] = RMT_CHANNEL_BUSY;
}
}
}
}
return ESP_OK;
}
2019-11-19 03:10:02 -05:00
esp_err_t rmt_get_counter_clock(rmt_channel_t channel, uint32_t *clock_hz)
{
RMT_CHECK(channel < RMT_CHANNEL_MAX, RMT_CHANNEL_ERROR_STR, ESP_ERR_INVALID_ARG);
RMT_CHECK(clock_hz, "parameter clock_hz can't be null", ESP_ERR_INVALID_ARG);
RMT_ENTER_CRITICAL();
*clock_hz = rmt_hal_get_counter_clock(&p_rmt_obj[channel]->hal, channel, RMT_SOURCE_CLK(RMT_BASECLK_APB));
RMT_EXIT_CRITICAL();
return ESP_OK;
}