Merge branch 'feature/dfs' into 'master'

Dynamic frequency scaling

See merge request !1189

Author: igrr

components/app_trace/Kconfig

@@ -63,13 +63,13 @@ config SYSVIEW_ENABLE
     help
         Enables supporrt for SEGGER SystemView tracing functionality.
 
-if !FREERTOS_UNICORE
 choice SYSVIEW_TS_SOURCE
     prompt "ESP32 timer to use as SystemView timestamp source"
     depends on SYSVIEW_ENABLE
     default SYSVIEW_TS_SOURCE_TIMER_00
     help
-        SystemView needs one source for timestamps when tracing events from both cores.
+        SystemView needs to use a hardware timer as the source of timestamps
+        when tracing 
         This option selects HW timer for it.
 
 config SYSVIEW_TS_SOURCE_TIMER_00
@@ -93,7 +93,6 @@ config SYSVIEW_TS_SOURCE_TIMER_11
         Select this to use timer 1 of group 1
 
 endchoice
-endif #FREERTOS_UNICORE
 
 config SYSVIEW_EVT_OVERFLOW_ENABLE
     bool "Trace Buffer Overflow Event"

components/app_trace/app_trace.c

@@ -203,8 +203,6 @@ const static char *TAG = "esp_apptrace";
 #define ESP_APPTRACE_LOGV( format, ... )  ESP_APPTRACE_LOG_LEV(V, ESP_LOG_VERBOSE, format, ##__VA_ARGS__)
 #define ESP_APPTRACE_LOGO( format, ... )  ESP_APPTRACE_LOG_LEV(E, ESP_LOG_NONE, format, ##__VA_ARGS__)
 
-#define ESP_APPTRACE_CPUTICKS2US(_t_)       ((_t_)/(XT_CLOCK_FREQ/1000000))
-
 // TODO: move these (and same definitions in trax.c to dport_reg.h)
 #define TRACEMEM_MUX_PROBLK0_APPBLK1            0
 #define TRACEMEM_MUX_BLK0_ONLY                  1

components/app_trace/app_trace_util.c

@@ -15,23 +15,24 @@
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
 #include "esp_app_trace_util.h"
+#include "esp_clk.h"
 
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////// TIMEOUT /////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
 
-// TODO: get actual clock from PLL config
-#define ESP_APPTRACE_CPUTICKS2US(_t_)       ((_t_)/(XT_CLOCK_FREQ/1000000))
-#define ESP_APPTRACE_US2CPUTICKS(_t_)       ((_t_)*(XT_CLOCK_FREQ/1000000))
+#define ESP_APPTRACE_CPUTICKS2US(_t_, _cpu_freq_)       ((_t_)/(_cpu_freq_/1000000))
+#define ESP_APPTRACE_US2CPUTICKS(_t_, _cpu_freq_)       ((_t_)*(_cpu_freq_/1000000))
 
 esp_err_t esp_apptrace_tmo_check(esp_apptrace_tmo_t *tmo)
 {
+    int cpu_freq = esp_clk_cpu_freq();
     if (tmo->tmo != ESP_APPTRACE_TMO_INFINITE) {
         unsigned cur = portGET_RUN_TIME_COUNTER_VALUE();
         if (tmo->start <= cur) {
-            tmo->elapsed = ESP_APPTRACE_CPUTICKS2US(cur - tmo->start);
+            tmo->elapsed = ESP_APPTRACE_CPUTICKS2US(cur - tmo->start, cpu_freq);
         } else {
-            tmo->elapsed = ESP_APPTRACE_CPUTICKS2US(0xFFFFFFFF - tmo->start + cur);
+            tmo->elapsed = ESP_APPTRACE_CPUTICKS2US(0xFFFFFFFF - tmo->start + cur, cpu_freq);
         }
         if (tmo->elapsed >= tmo->tmo) {
             return ESP_ERR_TIMEOUT;

components/app_trace/sys_view/Sample/Config/SEGGER_SYSVIEW_Config_FreeRTOS.c

@@ -70,6 +70,7 @@ Revision: $Rev: 3734 $
 #include "esp_app_trace.h"
 #include "esp_app_trace_util.h"
 #include "esp_intr_alloc.h"
+#include "esp_clk.h"
 
 extern const SEGGER_SYSVIEW_OS_API SYSVIEW_X_OS_TraceAPI;
 
@@ -85,14 +86,12 @@ extern const SEGGER_SYSVIEW_OS_API SYSVIEW_X_OS_TraceAPI;
 // The target device name
 #define SYSVIEW_DEVICE_NAME     "ESP32"
 
+// Timer group timer divisor
+#define SYSVIEW_TIMER_DIV       2
 // Frequency of the timestamp.
-#if CONFIG_FREERTOS_UNICORE == 0
-#define SYSVIEW_TIMESTAMP_FREQ  (TIMER_BASE_CLK/2)
-#else
-#define SYSVIEW_TIMESTAMP_FREQ  (XT_CLOCK_FREQ)
-#endif
+#define SYSVIEW_TIMESTAMP_FREQ  (esp_clk_apb_freq() / SYSVIEW_TIMER_DIV)
 // System Frequency.
-#define SYSVIEW_CPU_FREQ        (XT_CLOCK_FREQ)
+#define SYSVIEW_CPU_FREQ        (esp_clk_cpu_freq())
 
 // The lowest RAM address used for IDs (pointers)
 #define SYSVIEW_RAM_BASE        (0x3F400000)
@@ -104,10 +103,8 @@ extern const SEGGER_SYSVIEW_OS_API SYSVIEW_X_OS_TraceAPI;
     #define SYSTICK_INTR_ID (ETS_INTERNAL_TIMER1_INTR_SOURCE+ETS_INTERNAL_INTR_SOURCE_OFF)
 #endif
 
-#if CONFIG_FREERTOS_UNICORE == 0
 static timer_idx_t s_ts_timer_idx;
 static timer_group_t s_ts_timer_group;
-#endif
 
 // SystemView is single core specific: it implies that SEGGER_SYSVIEW_LOCK()
 // disables IRQs (disables rescheduling globaly). So we can not use finite timeouts for locks and return error
@@ -214,7 +211,6 @@ static void _cbSendSystemDesc(void) {
 *
 **********************************************************************
 */
-#if CONFIG_FREERTOS_UNICORE == 0
 static void SEGGER_SYSVIEW_TS_Init()
 {
     timer_config_t config;
@@ -238,7 +234,7 @@ static void SEGGER_SYSVIEW_TS_Init()
     config.alarm_en = 0;
     config.auto_reload = 0;
     config.counter_dir = TIMER_COUNT_UP;
-    config.divider = 2;
+    config.divider = SYSVIEW_TIMER_DIV;
     config.counter_en = 0;
     /*Configure timer*/
     timer_init(s_ts_timer_group, s_ts_timer_idx, &config);
@@ -247,14 +243,11 @@ static void SEGGER_SYSVIEW_TS_Init()
     /*Enable timer interrupt*/
     timer_start(s_ts_timer_group, s_ts_timer_idx);
 }
-#endif
 
 void SEGGER_SYSVIEW_Conf(void) {
     U32 disable_evts = 0;
 
-#if CONFIG_FREERTOS_UNICORE == 0
     SEGGER_SYSVIEW_TS_Init();
-#endif
     SEGGER_SYSVIEW_Init(SYSVIEW_TIMESTAMP_FREQ, SYSVIEW_CPU_FREQ,
                         &SYSVIEW_X_OS_TraceAPI, _cbSendSystemDesc);
     SEGGER_SYSVIEW_SetRAMBase(SYSVIEW_RAM_BASE);

components/app_trace/sys_view/esp32/SEGGER_RTT_esp32.c

@@ -26,16 +26,6 @@ const static char *TAG = "segger_rtt";
 
 #define SYSVIEW_EVENTS_BUF_SZ         255U
 
-#if SYSVIEW_RTT_MAX_DATA_RATE > 0
-#include "SEGGER_SYSVIEW_Conf.h"
-#if CONFIG_FREERTOS_UNICORE == 0
-#include "driver/timer.h"
-#define SYSVIEW_TIMESTAMP_FREQ  (TIMER_BASE_CLK/2)
-#else
-#define SYSVIEW_TIMESTAMP_FREQ  (XT_CLOCK_FREQ)
-#endif
-#endif
-
 // size of down channel data buf
 #define SYSVIEW_DOWN_BUF_SIZE   32
 #define SEGGER_HOST_WAIT_TMO    500 //us

components/app_trace/test/test_trace.c

@@ -87,8 +87,6 @@ static void esp_apptrace_test_timer_init(int timer_group, int timer_idx, uint32_
 #define ESP_APPTRACE_TEST_WRITE_FROM_ISR(_b_, _s_)   esp_apptrace_write(ESP_APPTRACE_DEST_TRAX, _b_, _s_, 0UL)
 #define ESP_APPTRACE_TEST_WRITE_NOWAIT(_b_, _s_)     esp_apptrace_write(ESP_APPTRACE_DEST_TRAX, _b_, _s_, 0)
 
-#define ESP_APPTRACE_TEST_CPUTICKS2US(_t_)       ((_t_)/(XT_CLOCK_FREQ/1000000))
-
 typedef struct {
     uint8_t *buf;
     uint32_t buf_sz;

components/bt/bt.c

@@ -33,6 +33,7 @@
 #include "bt.h"
 #include "esp_err.h"
 #include "esp_log.h"
+#include "esp_pm.h"
 
 #if CONFIG_BT_ENABLED
 
@@ -147,6 +148,10 @@ static esp_bt_controller_status_t btdm_controller_status = ESP_BT_CONTROLLER_STA
 
 static portMUX_TYPE global_int_mux = portMUX_INITIALIZER_UNLOCKED;
 
+#ifdef CONFIG_PM_ENABLE
+static esp_pm_lock_handle_t s_pm_lock;
+#endif
+
 static void IRAM_ATTR interrupt_disable(void)
 {
     portENTER_CRITICAL(&global_int_mux);
@@ -442,6 +447,13 @@ esp_err_t esp_bt_controller_init(esp_bt_controller_config_t *cfg)
         return ESP_ERR_INVALID_ARG;
     }
 
+#ifdef CONFIG_PM_ENABLE
+    esp_err_t err = esp_pm_lock_create(ESP_PM_APB_FREQ_MAX, 0, "bt", &s_pm_lock);
+    if (err != ESP_OK) {
+        return err;
+    }
+#endif
+
     btdm_osi_funcs_register(&osi_funcs);
 
     btdm_controller_mem_init();
@@ -450,6 +462,10 @@ esp_err_t esp_bt_controller_init(esp_bt_controller_config_t *cfg)
 
     ret = btdm_controller_init(btdm_cfg_mask, cfg);
     if (ret) {
+#ifdef CONFIG_PM_ENABLE
+        esp_pm_lock_delete(s_pm_lock);
+        s_pm_lock = NULL;
+#endif
         return ESP_ERR_NO_MEM;
     }
 
@@ -468,6 +484,12 @@ esp_err_t esp_bt_controller_deinit(void)
     }
 
     btdm_controller_status = ESP_BT_CONTROLLER_STATUS_IDLE;
+
+#ifdef CONFIG_PM_ENABLE
+    esp_pm_lock_delete(s_pm_lock);
+    s_pm_lock = NULL;
+#endif
+
     return ESP_OK;
 }
 
@@ -484,6 +506,10 @@ esp_err_t esp_bt_controller_enable(esp_bt_mode_t mode)
         return ESP_ERR_INVALID_ARG;
     }
 
+#ifdef CONFIG_PM_ENABLE
+    esp_pm_lock_acquire(s_pm_lock);
+#endif
+
     esp_phy_load_cal_and_init();
 
     if (btdm_bb_init_flag == false) {
@@ -519,6 +545,10 @@ esp_err_t esp_bt_controller_disable(void)
         btdm_controller_status = ESP_BT_CONTROLLER_STATUS_INITED;
     }
 
+#ifdef CONFIG_PM_ENABLE
+    esp_pm_lock_release(s_pm_lock);
+#endif
+
     return ESP_OK;
 }
 

components/driver/include/driver/uart.h

@@ -106,7 +106,8 @@ typedef struct {
     uart_parity_t parity;               /*!< UART parity mode*/
     uart_stop_bits_t stop_bits;         /*!< UART stop bits*/
     uart_hw_flowcontrol_t flow_ctrl;    /*!< UART HW flow control mode (cts/rts)*/
-    uint8_t rx_flow_ctrl_thresh ;       /*!< UART HW RTS threshold*/
+    uint8_t rx_flow_ctrl_thresh;        /*!< UART HW RTS threshold*/
+    bool use_ref_tick;                  /*!< Set to true if UART should be clocked from REF_TICK */
 } uart_config_t;
 
 /**

components/driver/sdmmc_transaction.c

@@ -15,6 +15,7 @@
 #include <string.h>
 #include "esp_err.h"
 #include "esp_log.h"
+#include "esp_pm.h"
 #include "freertos/FreeRTOS.h"
 #include "freertos/queue.h"
 #include "freertos/semphr.h"
@@ -67,6 +68,9 @@ static sdmmc_desc_t s_dma_desc[SDMMC_DMA_DESC_CNT];
 static sdmmc_transfer_state_t s_cur_transfer = { 0 };
 static QueueHandle_t s_request_mutex;
 static bool s_is_app_cmd;   // This flag is set if the next command is an APP command
+#ifdef CONFIG_PM_ENABLE
+static esp_pm_lock_handle_t s_pm_lock;
+#endif
 
 static esp_err_t handle_idle_state_events();
 static sdmmc_hw_cmd_t make_hw_cmd(sdmmc_command_t* cmd);
@@ -83,19 +87,34 @@ esp_err_t sdmmc_host_transaction_handler_init()
         return ESP_ERR_NO_MEM;
     }
     s_is_app_cmd = false;
+#ifdef CONFIG_PM_ENABLE
+    esp_err_t err = esp_pm_lock_create(ESP_PM_APB_FREQ_MAX, 0, "sdmmc", &s_pm_lock);
+    if (err != ESP_OK) {
+        vSemaphoreDelete(s_request_mutex);
+        s_request_mutex = NULL;
+        return err;
+    }
+#endif
     return ESP_OK;
 }
 
 void sdmmc_host_transaction_handler_deinit()
 {
     assert(s_request_mutex);
+#ifdef CONFIG_PM_ENABLE
+    esp_pm_lock_delete(s_pm_lock);
+    s_pm_lock = NULL;
+#endif
     vSemaphoreDelete(s_request_mutex);
     s_request_mutex = NULL;
 }
 
 esp_err_t sdmmc_host_do_transaction(int slot, sdmmc_command_t* cmdinfo)
 {
     xSemaphoreTake(s_request_mutex, portMAX_DELAY);
+#ifdef CONFIG_PM_ENABLE
+    esp_pm_lock_acquire(s_pm_lock);
+#endif
     // dispose of any events which happened asynchronously
     handle_idle_state_events();
     // convert cmdinfo to hardware register value
@@ -141,6 +160,9 @@ esp_err_t sdmmc_host_do_transaction(int slot, sdmmc_command_t* cmdinfo)
         }
     }
     s_is_app_cmd = (ret == ESP_OK && cmdinfo->opcode == MMC_APP_CMD);
+#ifdef CONFIG_PM_ENABLE
+    esp_pm_lock_release(s_pm_lock);
+#endif
     xSemaphoreGive(s_request_mutex);
     return ret;
 }

components/driver/spi_master.c

@@ -47,6 +47,7 @@ queue and re-enabling the interrupt will trigger the interrupt again, which can
 #include "esp_intr_alloc.h"
 #include "esp_log.h"
 #include "esp_err.h"
+#include "esp_pm.h"
 #include "freertos/FreeRTOS.h"
 #include "freertos/semphr.h"
 #include "freertos/xtensa_api.h"
@@ -84,6 +85,9 @@ typedef struct {
     bool no_gpio_matrix;
     int dma_chan;
     int max_transfer_sz;
+#ifdef CONFIG_PM_ENABLE
+    esp_pm_lock_handle_t pm_lock;
+#endif
 } spi_host_t;
 
 struct spi_device_t {
@@ -129,6 +133,13 @@ esp_err_t spi_bus_initialize(spi_host_device_t host, const spi_bus_config_t *bus
     spihost[host]=malloc(sizeof(spi_host_t));
     if (spihost[host]==NULL) goto nomem;
     memset(spihost[host], 0, sizeof(spi_host_t));
+#ifdef CONFIG_PM_ENABLE
+    esp_err_t err = esp_pm_lock_create(ESP_PM_APB_FREQ_MAX, 0, "spi_master",
+            &spihost[host]->pm_lock);
+    if (err != ESP_OK) {
+        goto nomem;
+    }
+#endif //CONFIG_PM_ENABLE
 
     spicommon_bus_initialize_io(host, bus_config, dma_chan, SPICOMMON_BUSFLAG_MASTER|SPICOMMON_BUSFLAG_QUAD, &native);
     spihost[host]->no_gpio_matrix=native;
@@ -180,6 +191,11 @@ esp_err_t spi_bus_initialize(spi_host_device_t host, const spi_bus_config_t *bus
     if (spihost[host]) {
         free(spihost[host]->dmadesc_tx);
         free(spihost[host]->dmadesc_rx);
+#ifdef CONFIG_PM_ENABLE
+        if (spihost[host]->pm_lock) {
+            esp_pm_lock_delete(spihost[host]->pm_lock);
+        }
+#endif
     }
     free(spihost[host]);
     spicommon_periph_free(host);
@@ -199,6 +215,9 @@ esp_err_t spi_bus_free(spi_host_device_t host)
     if ( spihost[host]->dma_chan > 0 ) {
         spicommon_dma_chan_free ( spihost[host]->dma_chan );
     }
+#ifdef CONFIG_PM_ENABLE
+    esp_pm_lock_delete(spihost[host]->pm_lock);
+#endif
     spihost[host]->hw->slave.trans_inten=0;
     spihost[host]->hw->slave.trans_done=0;
     esp_intr_free(spihost[host]->intr);
@@ -412,6 +431,10 @@ static void IRAM_ATTR spi_intr(void *arg)
     if (i==NO_CS) {
         //No packet waiting. Disable interrupt.
         esp_intr_disable(host->intr);
+#ifdef CONFIG_PM_ENABLE
+        //Release APB frequency lock
+        esp_pm_lock_release(host->pm_lock);
+#endif
     } else {
         host->hw->slave.trans_done=0; //clear int bit
         //We have a transaction. Send it.
@@ -649,6 +672,9 @@ esp_err_t spi_device_queue_trans(spi_device_handle_t handle, spi_transaction_t *
         // else use the original buffer (forced-conversion) or assign to NULL
         trans_buf.buffer_to_send = (uint32_t*)txdata;
     }
+#ifdef CONFIG_PM_ENABLE
+    esp_pm_lock_acquire(handle->host->pm_lock);
+#endif
 
     r=xQueueSend(handle->trans_queue, (void*)&trans_buf, ticks_to_wait);
     if (!r) return ESP_ERR_TIMEOUT;