From c91565d538b83d4d043e8f5f684a4866668c2f68 Mon Sep 17 00:00:00 2001 From: morris Date: Mon, 16 Mar 2020 14:41:47 +0800 Subject: [PATCH] rmt: update rmt ll APIs --- components/driver/include/driver/rmt.h | 2 +- components/driver/rmt.c | 67 +++++----- .../soc/soc/esp32s2/include/soc/rmt_caps.h | 10 +- .../soc/soc/esp32s2/include/soc/rmt_struct.h | 4 +- components/soc/src/esp32/include/hal/rmt_ll.h | 20 +-- .../soc/src/esp32s2/include/hal/rmt_ll.h | 118 +++++++++++++----- components/soc/src/hal/rmt_hal.c | 2 +- .../components/test_utils/ref_clock.c | 2 +- 8 files changed, 144 insertions(+), 81 deletions(-) diff --git a/components/driver/include/driver/rmt.h b/components/driver/include/driver/rmt.h index 6f3b38a6fb..751f0b774e 100644 --- a/components/driver/include/driver/rmt.h +++ b/components/driver/include/driver/rmt.h @@ -59,7 +59,7 @@ typedef struct { #ifdef RMT_SUPPORT_RX_DEMODULATION bool rm_carrier; /*!< RMT receiver remove carrier enable */ - uint16_t high_thres; /*!< The threshold of carrier high level tick number */ + uint16_t high_thres; /*!< The threshold of carrier high level tick number */ uint16_t low_thres; /*!< The threshold of carrier low level tick number */ rmt_carrier_level_t carrier_level; /*!< The level need to remove carrier */ #endif diff --git a/components/driver/rmt.c b/components/driver/rmt.c index 52b8175c84..498996b3cf 100644 --- a/components/driver/rmt.c +++ b/components/driver/rmt.c @@ -1,4 +1,4 @@ -// Copyright 2015-2019 Espressif Systems (Shanghai) PTE LTD +// Copyright 2015-2020 Espressif Systems (Shanghai) PTE LTD // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. @@ -79,7 +79,7 @@ typedef struct { #endif rmt_item32_t *tx_buf; RingbufHandle_t rx_buf; -#ifdef RMT_SUPPORT_RX_PINGPONG_MODE +#ifdef RMT_SUPPORT_RX_PINGPONG rmt_item32_t *rx_item_buf; uint32_t rx_item_buf_size; uint32_t rx_item_len; @@ -160,8 +160,8 @@ esp_err_t rmt_set_tx_carrier(rmt_channel_t channel, bool carrier_en, uint16_t hi 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); 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_set_tx_carrier_high_low_ticks(p_rmt_obj[channel]->hal.regs, channel, high_level, low_level); + rmt_ll_set_carrier_on_level(p_rmt_obj[channel]->hal.regs, channel, carrier_level); rmt_ll_enable_carrier(p_rmt_obj[channel]->hal.regs, channel, carrier_en); RMT_EXIT_CRITICAL(); return ESP_OK; @@ -171,7 +171,7 @@ 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); RMT_ENTER_CRITICAL(); - rmt_ll_power_down_mem(p_rmt_obj[channel]->hal.regs, channel, pd_en); + rmt_ll_power_down_mem(p_rmt_obj[channel]->hal.regs, pd_en); RMT_EXIT_CRITICAL(); return ESP_OK; } @@ -180,7 +180,7 @@ esp_err_t rmt_get_mem_pd(rmt_channel_t channel, bool *pd_en) { RMT_CHECK(channel < RMT_CHANNEL_MAX, RMT_CHANNEL_ERROR_STR, ESP_ERR_INVALID_ARG); RMT_ENTER_CRITICAL(); - *pd_en = rmt_ll_is_mem_power_down(p_rmt_obj[channel]->hal.regs, channel); + *pd_en = rmt_ll_is_mem_power_down(p_rmt_obj[channel]->hal.regs); RMT_EXIT_CRITICAL(); return ESP_OK; } @@ -220,12 +220,12 @@ esp_err_t rmt_rx_start(rmt_channel_t channel, bool rx_idx_rst) 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); -#ifdef RMT_SUPPORT_RX_PINGPONG_MODE +#ifdef RMT_SUPPORT_RX_PINGPONG const uint32_t item_block_len = rmt_ll_get_mem_blocks(p_rmt_obj[channel]->hal.regs, channel) * RMT_MEM_ITEM_NUM; rmt_ll_set_rx_limit(p_rmt_obj[channel]->hal.regs, channel, item_block_len / 2); p_rmt_obj[channel]->rx_item_start_idx = 0; p_rmt_obj[channel]->rx_item_len = 0; - if (rmt_ll_get_rx_pingpong_en(p_rmt_obj[channel]->hal.regs, channel)) { + if (rmt_ll_is_rx_pingpong_enabled(p_rmt_obj[channel]->hal.regs, channel)) { rmt_ll_enable_rx_thres_interrupt(p_rmt_obj[channel]->hal.regs, channel, true); } #endif @@ -241,7 +241,7 @@ esp_err_t rmt_rx_stop(rmt_channel_t channel) 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); -#ifdef RMT_SUPPORT_RX_PINGPONG_MODE +#ifdef RMT_SUPPORT_RX_PINGPONG rmt_ll_enable_rx_thres_interrupt(p_rmt_obj[channel]->hal.regs, channel, false); #endif RMT_EXIT_CRITICAL(); @@ -282,7 +282,7 @@ 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); RMT_ENTER_CRITICAL(); - rmt_ll_enable_tx_cyclic(p_rmt_obj[channel]->hal.regs, channel, loop_en); + rmt_ll_enable_tx_loop(p_rmt_obj[channel]->hal.regs, channel, loop_en); RMT_EXIT_CRITICAL(); return ESP_OK; } @@ -291,7 +291,7 @@ esp_err_t rmt_get_tx_loop_mode(rmt_channel_t channel, bool *loop_en) { RMT_CHECK(channel < RMT_CHANNEL_MAX, RMT_CHANNEL_ERROR_STR, ESP_ERR_INVALID_ARG); RMT_ENTER_CRITICAL(); - *loop_en = rmt_ll_is_tx_cyclic_enabled(p_rmt_obj[channel]->hal.regs, channel); + *loop_en = rmt_ll_is_tx_loop_enabled(p_rmt_obj[channel]->hal.regs, channel); RMT_EXIT_CRITICAL(); return ESP_OK; } @@ -378,8 +378,8 @@ esp_err_t rmt_set_rx_intr_en(rmt_channel_t channel, bool en) return ESP_OK; } -#ifdef RMT_SUPPORT_RX_PINGPONG_MODE -esp_err_t rmt_set_rx_thr_intr_en(rmt_channel_t channel, bool en, uint16_t evt_thresh) +#ifdef RMT_SUPPORT_RX_PINGPONG +static esp_err_t rmt_set_rx_thr_intr_en(rmt_channel_t channel, bool en, uint16_t evt_thresh) { RMT_CHECK(channel < RMT_CHANNEL_MAX, RMT_CHANNEL_ERROR_STR, ESP_ERR_INVALID_ARG); if (en) { @@ -497,7 +497,7 @@ static esp_err_t rmt_internal_config(rmt_dev_t *dev, const rmt_config_t *rmt_par uint8_t idle_level = rmt_param->tx_config.idle_level; RMT_ENTER_CRITICAL(); - rmt_ll_enable_tx_cyclic(dev, channel, rmt_param->tx_config.loop_en); + rmt_ll_enable_tx_loop(dev, channel, rmt_param->tx_config.loop_en); rmt_ll_enable_tx_pingpong(dev, true); /*Set idle level */ rmt_ll_enable_tx_idle(dev, channel, rmt_param->tx_config.idle_output_en); @@ -509,11 +509,11 @@ static esp_err_t rmt_internal_config(rmt_dev_t *dev, const rmt_config_t *rmt_par duty_div = rmt_source_clk_hz / carrier_freq_hz; duty_h = duty_div * carrier_duty_percent / 100; duty_l = duty_div - duty_h; - rmt_ll_set_carrier_to_level(dev, channel, carrier_level); - rmt_ll_set_carrier_high_low_ticks(dev, channel, duty_h, duty_l); + rmt_ll_set_carrier_on_level(dev, channel, carrier_level); + rmt_ll_set_tx_carrier_high_low_ticks(dev, channel, duty_h, duty_l); } else { - rmt_ll_set_carrier_to_level(dev, channel, 0); - rmt_ll_set_carrier_high_low_ticks(dev, channel, 0, 0); + rmt_ll_set_carrier_on_level(dev, channel, 0); + rmt_ll_set_tx_carrier_high_low_ticks(dev, channel, 0, 0); } RMT_EXIT_CRITICAL(); @@ -530,15 +530,14 @@ static esp_err_t rmt_internal_config(rmt_dev_t *dev, const rmt_config_t *rmt_par rmt_ll_set_rx_filter_thres(dev, channel, filter_cnt); rmt_ll_enable_rx_filter(dev, channel, rmt_param->rx_config.filter_en); -#ifdef RMT_SUPPORT_RX_PINGPONG_MODE +#ifdef RMT_SUPPORT_RX_PINGPONG rmt_ll_enable_rx_pingpong(dev, channel, true); #endif #ifdef RMT_SUPPORT_RX_DEMODULATION rmt_ll_enable_rx_carrier_rm(dev, channel, rmt_param->rx_config.rm_carrier); - rmt_ll_set_carrier_rm_high_thres_ticks(dev, channel, rmt_param->rx_config.high_thres); - rmt_ll_set_carrier_rm_low_thres_ticks(dev, channel, rmt_param->rx_config.low_thres); - rmt_ll_set_carrier_to_level(dev, channel, rmt_param->rx_config.carrier_level); + rmt_ll_set_rx_carrier_high_low_ticks(dev, channel, rmt_param->rx_config.high_thres, rmt_param->rx_config.low_thres ); + rmt_ll_set_carrier_on_level(dev, channel, rmt_param->rx_config.carrier_level); #endif RMT_EXIT_CRITICAL(); @@ -710,11 +709,11 @@ static void IRAM_ATTR rmt_driver_isr_default(void *arg) 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; -#ifdef RMT_SUPPORT_RX_PINGPONG_MODE - if(item_len > p_rmt->rx_item_start_idx) { +#ifdef RMT_SUPPORT_RX_PINGPONG + if (item_len > p_rmt->rx_item_start_idx) { item_len = item_len - p_rmt->rx_item_start_idx; } - memcpy((void*)(p_rmt->rx_item_buf + p_rmt->rx_item_len), (void*)(addr + p_rmt->rx_item_start_idx), item_len * 4); + memcpy((void *)(p_rmt->rx_item_buf + p_rmt->rx_item_len), (void *)(addr + p_rmt->rx_item_start_idx), item_len * 4); p_rmt->rx_item_len += item_len; BaseType_t res = xRingbufferSendFromISR(p_rmt->rx_buf, (void *)(p_rmt->rx_item_buf), p_rmt->rx_item_len * 4, &HPTaskAwoken); #else @@ -727,10 +726,10 @@ static void IRAM_ATTR rmt_driver_isr_default(void *arg) ESP_EARLY_LOGE(RMT_TAG, "RMT RX BUFFER ERROR"); } -#ifdef RMT_SUPPORT_RX_PINGPONG_MODE +#ifdef RMT_SUPPORT_RX_PINGPONG p_rmt->rx_item_start_idx = 0; p_rmt->rx_item_len = 0; - memset((void*)p_rmt->rx_item_buf, 0, p_rmt->rx_item_buf_size); + memset((void *)p_rmt->rx_item_buf, 0, p_rmt->rx_item_buf_size); #endif 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); @@ -739,7 +738,7 @@ static void IRAM_ATTR rmt_driver_isr_default(void *arg) rmt_ll_clear_rx_end_interrupt(hal->regs, channel); } -#ifdef RMT_SUPPORT_RX_PINGPONG_MODE +#ifdef RMT_SUPPORT_RX_PINGPONG // Rx thres interrupt status = rmt_ll_get_rx_thres_interrupt_status(hal->regs); while (status) { @@ -749,8 +748,8 @@ static void IRAM_ATTR rmt_driver_isr_default(void *arg) int mem_item_size = rmt_ll_get_mem_blocks(p_rmt_obj[channel]->hal.regs, channel) * RMT_MEM_ITEM_NUM; int rx_thres_lim = rmt_ll_get_rx_limit(p_rmt_obj[channel]->hal.regs, channel); int item_len = (p_rmt->rx_item_start_idx == 0) ? rx_thres_lim : (mem_item_size - rx_thres_lim); - if((p_rmt->rx_item_len + item_len) < (p_rmt->rx_item_buf_size / 4)) { - memcpy((void*)(p_rmt->rx_item_buf + p_rmt->rx_item_len), (void*)(RMTMEM.chan[channel].data32 + p_rmt->rx_item_start_idx), item_len * 4); + if ((p_rmt->rx_item_len + item_len) < (p_rmt->rx_item_buf_size / 4)) { + memcpy((void *)(p_rmt->rx_item_buf + p_rmt->rx_item_len), (void *)(RMTMEM.chan[channel].data32 + p_rmt->rx_item_start_idx), item_len * 4); p_rmt->rx_item_len += item_len; p_rmt->rx_item_start_idx += item_len; if (p_rmt->rx_item_start_idx >= mem_item_size) { @@ -800,7 +799,7 @@ esp_err_t rmt_driver_uninstall(rmt_channel_t channel) rmt_set_err_intr_en(channel, 0); rmt_set_tx_intr_en(channel, 0); rmt_set_tx_thr_intr_en(channel, 0, 0xffff); -#ifdef RMT_SUPPORT_RX_PINGPONG_MODE +#ifdef RMT_SUPPORT_RX_PINGPONG rmt_set_rx_thr_intr_en(channel, 0, 0xffff); #endif @@ -835,7 +834,7 @@ esp_err_t rmt_driver_uninstall(rmt_channel_t channel) p_rmt_obj[channel]->sample_to_rmt = NULL; } -#ifdef RMT_SUPPORT_RX_PINGPONG_MODE +#ifdef RMT_SUPPORT_RX_PINGPONG if (p_rmt_obj[channel]->rx_item_buf) { free(p_rmt_obj[channel]->rx_item_buf); p_rmt_obj[channel]->rx_item_buf = NULL; @@ -905,12 +904,12 @@ esp_err_t rmt_driver_install(rmt_channel_t channel, size_t rx_buf_size, int intr p_rmt_obj[channel]->rx_buf = xRingbufferCreate(rx_buf_size, RINGBUF_TYPE_NOSPLIT); } -#ifdef RMT_SUPPORT_RX_PINGPONG_MODE +#ifdef RMT_SUPPORT_RX_PINGPONG if (p_rmt_obj[channel]->rx_item_buf == NULL && rx_buf_size > 0) { #if !CONFIG_SPIRAM_USE_MALLOC p_rmt_obj[channel]->rx_item_buf = (rmt_item32_t *)malloc(rx_buf_size); #else - if (p_rmt_obj[channel]->intr_alloc_flags & ESP_INTR_FLAG_IRAM) { + if (!(p_rmt_obj[channel]->intr_alloc_flags & ESP_INTR_FLAG_IRAM)) { p_rmt_obj[channel]->rx_item_buf = (rmt_item32_t *)malloc(rx_buf_size); } else { p_rmt_obj[channel]->rx_item_buf = (rmt_item32_t *)heap_caps_calloc(1, rx_buf_size, MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT); diff --git a/components/soc/soc/esp32s2/include/soc/rmt_caps.h b/components/soc/soc/esp32s2/include/soc/rmt_caps.h index c8fe064a5c..10ea3bcffb 100644 --- a/components/soc/soc/esp32s2/include/soc/rmt_caps.h +++ b/components/soc/soc/esp32s2/include/soc/rmt_caps.h @@ -18,10 +18,12 @@ extern "C" { #endif -#define RMT_CHANNEL_MEM_WORDS (64) /*!< Each channel owns 64 words memory */ -#define RMT_CHANNELS_NUM (4) /*!< Total 4 channels */ -#define RMT_SUPPORT_RX_PINGPONG_MODE (1) -#define RMT_SUPPORT_RX_DEMODULATION (1) +#define RMT_CHANNEL_MEM_WORDS (64) /*!< Each channel owns 64 words memory (1 word = 4 Bytes) */ +#define RMT_CHANNELS_NUM (4) /*!< Total 4 channels */ +#define RMT_SUPPORT_RX_PINGPONG (1) /*!< Support Ping-Pong mode on RX path */ +#define RMT_SUPPORT_RX_DEMODULATION (1) /*!< Support signal demodulation on RX path (i.e. remove carrier) */ +#define RMT_SUPPORT_TX_LOOP_COUNT (1) /*!< Support transmit specified number of cycles in loop mode */ +#define RMT_SUPPORT_TX_SIMULTANEOUS (1) /*!< Support multiple channel transmit simultaneously */ #ifdef __cplusplus } diff --git a/components/soc/soc/esp32s2/include/soc/rmt_struct.h b/components/soc/soc/esp32s2/include/soc/rmt_struct.h index 11d5bc704b..e33fb3aff0 100644 --- a/components/soc/soc/esp32s2/include/soc/rmt_struct.h +++ b/components/soc/soc/esp32s2/include/soc/rmt_struct.h @@ -21,7 +21,7 @@ extern "C" { #endif typedef volatile struct { - uint32_t data_ch[4]; /**/ + uint32_t data_ch[4]; /* Data FIFO, Can only be accessed by PeriBus2 */ struct { union { struct { @@ -283,7 +283,7 @@ typedef volatile struct { uint32_t reserved_f0; uint32_t reserved_f4; uint32_t reserved_f8; - uint32_t date; /**/ + uint32_t date; /* Version Control Register */ } rmt_dev_t; extern rmt_dev_t RMT; diff --git a/components/soc/src/esp32/include/hal/rmt_ll.h b/components/soc/src/esp32/include/hal/rmt_ll.h index 3482117815..d38de16683 100644 --- a/components/soc/src/esp32/include/hal/rmt_ll.h +++ b/components/soc/src/esp32/include/hal/rmt_ll.h @@ -21,6 +21,11 @@ extern "C" { #include "soc/rmt_struct.h" #include "soc/rmt_caps.h" +static inline void rmt_ll_enable_drive_clock(rmt_dev_t *dev, bool enable) +{ + dev->conf_ch[0].conf0.clk_en = enable; +} + static inline void rmt_ll_reset_counter_clock_div(rmt_dev_t *dev, uint32_t channel) { dev->conf_ch[channel].conf1.ref_cnt_rst = 1; @@ -57,12 +62,12 @@ static inline void rmt_ll_enable_rx(rmt_dev_t *dev, uint32_t channel, bool enabl dev->conf_ch[channel].conf1.rx_en = enable; } -static inline void rmt_ll_power_down_mem(rmt_dev_t *dev, uint32_t channel, bool enable) +static inline void rmt_ll_power_down_mem(rmt_dev_t *dev, bool enable) { dev->conf_ch[0].conf0.mem_pd = enable; // Only conf0 register of channel0 has `mem_pd` } -static inline bool rmt_ll_is_mem_power_down(rmt_dev_t *dev, uint32_t channel) +static inline bool rmt_ll_is_mem_power_down(rmt_dev_t *dev) { return dev->conf_ch[0].conf0.mem_pd; // Only conf0 register of channel0 has `mem_pd` } @@ -84,7 +89,8 @@ static inline void rmt_ll_set_counter_clock_div(rmt_dev_t *dev, uint32_t channel static inline uint32_t rmt_ll_get_counter_clock_div(rmt_dev_t *dev, uint32_t channel) { - return dev->conf_ch[channel].conf0.div_cnt; + uint32_t div = dev->conf_ch[channel].conf0.div_cnt; + return div == 0 ? 256 : div; } static inline void rmt_ll_enable_tx_pingpong(rmt_dev_t *dev, bool enable) @@ -117,12 +123,12 @@ static inline uint32_t rmt_ll_get_mem_owner(rmt_dev_t *dev, uint32_t channel) return dev->conf_ch[channel].conf1.mem_owner; } -static inline void rmt_ll_enable_tx_cyclic(rmt_dev_t *dev, uint32_t channel, bool enable) +static inline void rmt_ll_enable_tx_loop(rmt_dev_t *dev, uint32_t channel, bool enable) { dev->conf_ch[channel].conf1.tx_conti_mode = enable; } -static inline bool rmt_ll_is_tx_cyclic_enabled(rmt_dev_t *dev, uint32_t channel) +static inline bool rmt_ll_is_tx_loop_enabled(rmt_dev_t *dev, uint32_t channel) { return dev->conf_ch[channel].conf1.tx_conti_mode; } @@ -248,7 +254,7 @@ static inline uint32_t rmt_ll_get_tx_thres_interrupt_status(rmt_dev_t *dev) return (status & 0xFF000000) >> 24; } -static inline void rmt_ll_set_carrier_high_low_ticks(rmt_dev_t *dev, uint32_t channel, uint32_t high_ticks, uint32_t low_ticks) +static inline void rmt_ll_set_tx_carrier_high_low_ticks(rmt_dev_t *dev, uint32_t channel, uint32_t high_ticks, uint32_t low_ticks) { dev->carrier_duty_ch[channel].high = high_ticks; dev->carrier_duty_ch[channel].low = low_ticks; @@ -265,7 +271,7 @@ static inline void rmt_ll_enable_carrier(rmt_dev_t *dev, uint32_t channel, bool dev->conf_ch[channel].conf0.carrier_en = enable; } -static inline void rmt_ll_set_carrier_to_level(rmt_dev_t *dev, uint32_t channel, uint8_t level) +static inline void rmt_ll_set_carrier_on_level(rmt_dev_t *dev, uint32_t channel, uint8_t level) { dev->conf_ch[channel].conf0.carrier_out_lv = level; } diff --git a/components/soc/src/esp32s2/include/hal/rmt_ll.h b/components/soc/src/esp32s2/include/hal/rmt_ll.h index 61b89b2da5..dcd362c48e 100644 --- a/components/soc/src/esp32s2/include/hal/rmt_ll.h +++ b/components/soc/src/esp32s2/include/hal/rmt_ll.h @@ -21,9 +21,16 @@ extern "C" { #include "soc/rmt_struct.h" #include "soc/rmt_caps.h" +static inline void rmt_ll_enable_drive_clock(rmt_dev_t *dev, bool enable) +{ + dev->apb_conf.clk_en = enable; // register clock gating + dev->apb_conf.mem_clk_force_on = enable; // memory clock gating +} + static inline void rmt_ll_reset_counter_clock_div(rmt_dev_t *dev, uint32_t channel) { - + dev->ref_cnt_rst.val |= (1 << channel); + dev->ref_cnt_rst.val &= ~(1 << channel); } static inline void rmt_ll_reset_tx_pointer(rmt_dev_t *dev, uint32_t channel) @@ -53,15 +60,18 @@ static inline void rmt_ll_enable_rx(rmt_dev_t *dev, uint32_t channel, bool enabl dev->conf_ch[channel].conf1.rx_en = enable; } -static inline void rmt_ll_power_down_mem(rmt_dev_t *dev, uint32_t channel, bool enable) +static inline void rmt_ll_power_down_mem(rmt_dev_t *dev, bool enable) { - dev->apb_conf.mem_force_pu = enable; + dev->apb_conf.mem_force_pu = !enable; dev->apb_conf.mem_force_pd = enable; } -static inline bool rmt_ll_is_mem_power_down(rmt_dev_t *dev, uint32_t channel) +static inline bool rmt_ll_is_mem_power_down(rmt_dev_t *dev) { - return (dev->apb_conf.mem_force_pu) && (dev->apb_conf.mem_force_pd); + // the RTC domain can also power down RMT memory + // so it's probably not enough to detect whether it's powered down or not + // mem_force_pd has higher priority than mem_force_pu + return (dev->apb_conf.mem_force_pd) || !(dev->apb_conf.mem_force_pu); } static inline void rmt_ll_set_mem_blocks(rmt_dev_t *dev, uint32_t channel, uint8_t block_num) @@ -81,7 +91,8 @@ static inline void rmt_ll_set_counter_clock_div(rmt_dev_t *dev, uint32_t channel static inline uint32_t rmt_ll_get_counter_clock_div(rmt_dev_t *dev, uint32_t channel) { - return dev->conf_ch[channel].conf0.div_cnt; + uint32_t div = dev->conf_ch[channel].conf0.div_cnt; + return div == 0 ? 256 : div; } static inline void rmt_ll_enable_tx_pingpong(rmt_dev_t *dev, bool enable) @@ -114,16 +125,48 @@ static inline uint32_t rmt_ll_get_mem_owner(rmt_dev_t *dev, uint32_t channel) return dev->conf_ch[channel].conf1.mem_owner; } -static inline void rmt_ll_enable_tx_cyclic(rmt_dev_t *dev, uint32_t channel, bool enable) +static inline void rmt_ll_enable_tx_loop(rmt_dev_t *dev, uint32_t channel, bool enable) { dev->conf_ch[channel].conf1.tx_conti_mode = enable; } -static inline bool rmt_ll_is_tx_cyclic_enabled(rmt_dev_t *dev, uint32_t channel) +static inline bool rmt_ll_is_tx_loop_enabled(rmt_dev_t *dev, uint32_t channel) { return dev->conf_ch[channel].conf1.tx_conti_mode; } +static inline void rmt_ll_set_tx_loop_count(rmt_dev_t *dev, uint32_t channel, uint32_t count) +{ + dev->tx_lim_ch[channel].tx_loop_num = count; +} + +static inline void rmt_ll_reset_tx_loop(rmt_dev_t *dev, uint32_t channel) +{ + dev->tx_lim_ch[channel].loop_count_reset = 1; + dev->tx_lim_ch[channel].loop_count_reset = 0; +} + +static inline void rmt_ll_enable_tx_loop_count(rmt_dev_t *dev, uint32_t channel, bool enable) +{ + dev->tx_lim_ch[channel].tx_loop_cnt_en = enable; +} + +static inline void rmt_ll_enable_tx_sync(rmt_dev_t *dev, bool enable) +{ + dev->tx_sim.en = enable; +} + +static inline void rmt_ll_add_channel_to_group(rmt_dev_t *dev, uint32_t channel) +{ + dev->tx_sim.val |= 1 << channel; +} + +static inline uint32_t rmt_ll_remove_channel_from_group(rmt_dev_t *dev, uint32_t channel) +{ + dev->tx_sim.val &= ~(1 << channel); + return dev->tx_sim.val & 0x0F; +} + static inline void rmt_ll_enable_rx_filter(rmt_dev_t *dev, uint32_t channel, bool enable) { dev->conf_ch[channel].conf1.rx_filter_en = enable; @@ -208,6 +251,12 @@ static inline void rmt_ll_enable_tx_thres_interrupt(rmt_dev_t *dev, uint32_t cha dev->int_ena.val |= (enable << (channel + 12)); } +static inline void rmt_ll_enable_tx_loop_interrupt(rmt_dev_t *dev, uint32_t channel, bool enable) +{ + dev->int_ena.val &= ~(1 << (channel + 16)); + dev->int_ena.val |= (enable << (channel + 16)); +} + static inline void rmt_ll_enable_rx_thres_interrupt(rmt_dev_t *dev, uint32_t channel, bool enable) { dev->int_ena.val &= ~(1 << (channel + 20)); @@ -234,6 +283,11 @@ static inline void rmt_ll_clear_tx_thres_interrupt(rmt_dev_t *dev, uint32_t chan dev->int_clr.val = (1 << (channel + 12)); } +static inline void rmt_ll_clear_tx_loop_interrupt(rmt_dev_t *dev, uint32_t channel) +{ + dev->int_clr.val = (1 << (channel + 16)); +} + static inline void rmt_ll_clear_rx_thres_interrupt(rmt_dev_t *dev, uint32_t channel) { dev->int_clr.val = (1 << (channel + 20)); @@ -254,7 +308,7 @@ static inline uint32_t rmt_ll_get_rx_end_interrupt_status(rmt_dev_t *dev) static inline uint32_t rmt_ll_get_err_interrupt_status(rmt_dev_t *dev) { uint32_t status = dev->int_st.val; - return ((status & 0x04) >> 2) | ((status & 0x20) >> 4) | ((status & 0x100) >> 6) | ((status & 0x800) >> 8);; + return ((status & 0x04) >> 2) | ((status & 0x20) >> 4) | ((status & 0x100) >> 6) | ((status & 0x800) >> 8); } static inline uint32_t rmt_ll_get_tx_thres_interrupt_status(rmt_dev_t *dev) @@ -263,34 +317,56 @@ static inline uint32_t rmt_ll_get_tx_thres_interrupt_status(rmt_dev_t *dev) return (status & 0xF000) >> 12; } +static inline uint32_t rmt_ll_get_tx_loop_interrupt_status(rmt_dev_t *dev) +{ + uint32_t status = dev->int_st.val; + return (status & 0xF0000) >> 16; +} + static inline uint32_t rmt_ll_get_rx_thres_interrupt_status(rmt_dev_t *dev) { uint32_t status = dev->int_st.val; return (status & 0xF00000) >> 20; } -static inline void rmt_ll_set_carrier_high_low_ticks(rmt_dev_t *dev, uint32_t channel, uint32_t high_ticks, uint32_t low_ticks) +static inline void rmt_ll_set_tx_carrier_high_low_ticks(rmt_dev_t *dev, uint32_t channel, uint32_t high_ticks, uint32_t low_ticks) { dev->carrier_duty_ch[channel].high = high_ticks; dev->carrier_duty_ch[channel].low = low_ticks; } +static inline void rmt_ll_set_rx_carrier_high_low_ticks(rmt_dev_t *dev, uint32_t channel, uint32_t high_ticks, uint32_t low_ticks) +{ + dev->ch_rx_carrier_rm[channel].carrier_high_thres_ch = high_ticks; + dev->ch_rx_carrier_rm[channel].carrier_low_thres_ch = low_ticks; +} + static inline void rmt_ll_get_carrier_high_low_ticks(rmt_dev_t *dev, uint32_t channel, uint32_t *high_ticks, uint32_t *low_ticks) { *high_ticks = dev->carrier_duty_ch[channel].high; *low_ticks = dev->carrier_duty_ch[channel].low; } +// This function has different meaning for TX and RX +// TX: enable to modulate carrier +// RX: enable to demodulate carrier static inline void rmt_ll_enable_carrier(rmt_dev_t *dev, uint32_t channel, bool enable) { dev->conf_ch[channel].conf0.carrier_en = enable; } -static inline void rmt_ll_set_carrier_to_level(rmt_dev_t *dev, uint32_t channel, uint8_t level) +static inline void rmt_ll_set_carrier_on_level(rmt_dev_t *dev, uint32_t channel, uint8_t level) { dev->conf_ch[channel].conf0.carrier_out_lv = level; } +// set true, enable carrier in all RMT state (idle, reading, sending) +// set false, enable carrier only in sending state (i.e. there're effective data in RAM to be sent) +static inline void rmt_ll_tx_set_carrier_always_on(rmt_dev_t *dev, uint32_t channel, bool enable) +{ + dev->conf_ch[channel].conf0.carrier_eff_en = !enable; +} + static inline void rmt_ll_write_memory(rmt_mem_t *mem, uint32_t channel, const rmt_item32_t *data, uint32_t length, uint32_t off) { length = (off + length) > RMT_CHANNEL_MEM_WORDS ? (RMT_CHANNEL_MEM_WORDS - off) : length; @@ -304,26 +380,6 @@ static inline void rmt_ll_enable_rx_pingpong(rmt_dev_t *dev, uint32_t channel, b dev->conf_ch[channel].conf1.chk_rx_carrier_en = enable; } -static inline bool rmt_ll_get_rx_pingpong_en(rmt_dev_t *dev, uint32_t channel) -{ - return dev->conf_ch[channel].conf1.chk_rx_carrier_en; -} - -static inline void rmt_ll_enable_rx_carrier_rm(rmt_dev_t *dev, uint32_t channel, bool enable) -{ - dev->conf_ch[channel].conf0.carrier_en = enable; -} - -static inline void rmt_ll_set_carrier_rm_high_thres_ticks(rmt_dev_t *dev, uint32_t channel, uint16_t high_ticks) -{ - dev->ch_rx_carrier_rm[channel].carrier_high_thres_ch = high_ticks; -} - -static inline void rmt_ll_set_carrier_rm_low_thres_ticks(rmt_dev_t *dev, uint32_t channel, uint16_t low_ticks) -{ - dev->ch_rx_carrier_rm[channel].carrier_low_thres_ch = low_ticks; -} - /************************************************************************************************ * Following Low Level APIs only used for backward compatible, will be deprecated in the future! ***********************************************************************************************/ diff --git a/components/soc/src/hal/rmt_hal.c b/components/soc/src/hal/rmt_hal.c index e87f290577..7b64f51eeb 100644 --- a/components/soc/src/hal/rmt_hal.c +++ b/components/soc/src/hal/rmt_hal.c @@ -56,7 +56,7 @@ void rmt_hal_set_carrier_clock(rmt_hal_context_t *hal, uint32_t channel, uint32_ uint32_t carrier_div = (base_clk_hz + carrier_clk_hz / 2) / carrier_clk_hz; uint32_t div_high = (uint32_t)(carrier_div * carrier_clk_duty); uint32_t div_low = carrier_div - div_high; - rmt_ll_set_carrier_high_low_ticks(hal->regs, channel, div_high, div_low); + rmt_ll_set_tx_carrier_high_low_ticks(hal->regs, channel, div_high, div_low); } void rmt_hal_get_carrier_clock(rmt_hal_context_t *hal, uint32_t channel, uint32_t base_clk_hz, uint32_t *carrier_clk_hz, float *carrier_clk_duty) diff --git a/tools/unit-test-app/components/test_utils/ref_clock.c b/tools/unit-test-app/components/test_utils/ref_clock.c index 3e912e3544..2f8a981534 100644 --- a/tools/unit-test-app/components/test_utils/ref_clock.c +++ b/tools/unit-test-app/components/test_utils/ref_clock.c @@ -101,7 +101,7 @@ void ref_clock_init() rmt_ll_set_counter_clock_div(s_rmt.regs, REF_CLOCK_RMT_CHANNEL, 1); rmt_ll_set_mem_blocks(s_rmt.regs, REF_CLOCK_RMT_CHANNEL, 1); rmt_ll_set_counter_clock_src(s_rmt.regs, REF_CLOCK_RMT_CHANNEL, 0); - rmt_ll_enable_tx_cyclic(s_rmt.regs, REF_CLOCK_RMT_CHANNEL, true); + rmt_ll_enable_tx_loop(s_rmt.regs, REF_CLOCK_RMT_CHANNEL, true); rmt_ll_start_tx(s_rmt.regs, REF_CLOCK_RMT_CHANNEL); // Route signal to PCNT