Merge branch 'master' into increase_stack_size

me-no-dev · web-flow · commit 1077c47966a4 · 2025-08-05T12:27:25.000+03:00
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -75,7 +75,7 @@ if(IDF_TARGET STREQUAL "esp32" OR IDF_TARGET STREQUAL "esp32s2" OR IDF_TARGET ST
       )
   endif()
 
-  set(priv_requires freertos nvs_flash)
+  set(priv_requires freertos nvs_flash esp_mm)
 
   set(min_version_for_esp_timer "4.2")
   if (idf_version VERSION_GREATER_EQUAL min_version_for_esp_timer)
@@ -91,6 +91,10 @@ if(IDF_TARGET STREQUAL "esp32" OR IDF_TARGET STREQUAL "esp32s2" OR IDF_TARGET ST
     list(APPEND srcs driver/sccb.c)
   endif()
 
+  if (idf_version VERSION_GREATER_EQUAL "6.0")
+    list(APPEND priv_requires esp_driver_gpio)
+  endif()
+
 endif()
 
 idf_component_register(
diff --git a/driver/cam_hal.c b/driver/cam_hal.c
@@ -17,13 +17,21 @@
 #include <stdalign.h>
 #include "esp_heap_caps.h"
 #include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
 #include "ll_cam.h"
 #include "cam_hal.h"
 
 #if (ESP_IDF_VERSION_MAJOR == 3) && (ESP_IDF_VERSION_MINOR == 3)
 #include "rom/ets_sys.h"
 #else
 #include "esp_timer.h"
+#include "esp_cache.h"
+#include "hal/cache_hal.h"
+#include "hal/cache_ll.h"
+#include "esp_idf_version.h"
+#ifndef ESP_CACHE_MSYNC_FLAG_DIR_M2C
+#define ESP_CACHE_MSYNC_FLAG_DIR_M2C 0
+#endif
 #if CONFIG_IDF_TARGET_ESP32
 #include "esp32/rom/ets_sys.h"  // will be removed in idf v5.0
 #elif CONFIG_IDF_TARGET_ESP32S2
@@ -56,6 +64,53 @@ static portMUX_TYPE g_psram_dma_lock = portMUX_INITIALIZER_UNLOCKED;
 #define CAM_LOG_SPAM_EVERY_FRAME 0   /* set to 1 to restore old behaviour */
 #endif
 
+/* Number of bytes copied to SRAM for SOI validation when capturing
+ * directly to PSRAM. Tunable to probe more of the frame start if needed. */
+#ifndef CAM_SOI_PROBE_BYTES
+#define CAM_SOI_PROBE_BYTES 32
+#endif
+
+/* Number of bytes copied to SRAM for EOI validation when capturing
+ * directly to PSRAM. Tunable to probe more of the frame tail if needed. */
+#ifndef CAM_EOI_PROBE_BYTES
+#define CAM_EOI_PROBE_BYTES 32
+#endif
+
+/*
+ * PSRAM DMA may bypass the CPU cache.  Always call esp_cache_msync() on the
+ * SOI probe region so cached reads see the data written by DMA.
+ */
+
+static inline size_t dcache_line_size(void)
+{
+#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 2, 0)
+    /* cache_hal_get_cache_line_size() added extra argument from IDF 5.2 */
+    return cache_hal_get_cache_line_size(CACHE_LL_LEVEL_EXT_MEM, CACHE_TYPE_DATA);
+#else
+    /* Older releases only expose the ROM helper, all current targets
+     * have a 32‑byte DCache line */
+    return 32;
+#endif
+}
+
+/*
+ * Invalidate CPU data cache lines that cover a region in PSRAM which
+ * has just been written by DMA. This guarantees subsequent CPU reads
+ * fetch the fresh data from PSRAM rather than stale cache contents.
+ * Both address and length are aligned to the data cache line size.
+ */
+static inline void cam_drop_psram_cache(void *addr, size_t len)
+{
+    size_t line = dcache_line_size();
+    if (line == 0) {
+        line = 32; /* sane fallback */
+    }
+    uintptr_t start = (uintptr_t)addr & ~(line - 1);
+    size_t sync_len = (len + ((uintptr_t)addr - start) + line - 1) & ~(line - 1);
+    esp_cache_msync((void *)start, sync_len,
+                    ESP_CACHE_MSYNC_FLAG_DIR_M2C | ESP_CACHE_MSYNC_FLAG_INVALIDATE);
+}
+
 /* Throttle repeated warnings printed from tight loops / ISRs.
  *
  * counter – static DRAM/IRAM uint16_t you pass in
@@ -208,21 +263,67 @@ static void cam_task(void *arg)
                             &frame_buffer_event->buf[frame_buffer_event->len],
                             &cam_obj->dma_buffer[(cnt % cam_obj->dma_half_buffer_cnt) * cam_obj->dma_half_buffer_size],
                             cam_obj->dma_half_buffer_size);
+                    } else {
+                        // stop if the next DMA copy would exceed the framebuffer slot
+                        // size, since we're called only after the copy occurs
+                        // This effectively reduces maximum usable frame buffer size
+                        // by one DMA operation, as we can't predict here, if the next
+                        // cam event will be a VSYNC
+                        if (cnt + 1 >= cam_obj->frame_copy_cnt) {
+                            ESP_CAMERA_ETS_PRINTF(DRAM_STR("cam_hal: DMA overflow\r\n"));
+                            ll_cam_stop(cam_obj);
+                            cam_obj->state = CAM_STATE_IDLE;
+                            continue;
+                        }
                     }
+
                     //Check for JPEG SOI in the first buffer. stop if not found
-                    if (cam_obj->jpeg_mode && cnt == 0 && cam_verify_jpeg_soi(frame_buffer_event->buf, frame_buffer_event->len) != 0) {
-                        ll_cam_stop(cam_obj);
-                        cam_obj->state = CAM_STATE_IDLE;
+                    if (cam_obj->jpeg_mode && cnt == 0) {
+                        if (cam_obj->psram_mode) {
+                            /* dma_half_buffer_size already in BYTES (see ll_cam_memcpy()) */
+                            size_t probe_len = cam_obj->dma_half_buffer_size;
+                            /* clamp to avoid copying past the end of soi_probe */
+                            if (probe_len > CAM_SOI_PROBE_BYTES) {
+                                probe_len = CAM_SOI_PROBE_BYTES;
+                            }
+                            /* Invalidate cache lines for the DMA buffer before probing */
+                            cam_drop_psram_cache(frame_buffer_event->buf, probe_len);
+
+                            uint8_t soi_probe[CAM_SOI_PROBE_BYTES];
+                            memcpy(soi_probe, frame_buffer_event->buf, probe_len);
+                            int soi_off = cam_verify_jpeg_soi(soi_probe, probe_len);
+                            if (soi_off != 0) {
+                                static uint16_t warn_psram_soi_cnt = 0;
+                                if (soi_off > 0) {
+                                    CAM_WARN_THROTTLE(warn_psram_soi_cnt,
+                                                      "NO-SOI - JPEG start marker not at pos 0 (PSRAM)");
+                                } else {
+                                    CAM_WARN_THROTTLE(warn_psram_soi_cnt,
+                                                      "NO-SOI - JPEG start marker missing (PSRAM)");
+                                }
+                                ll_cam_stop(cam_obj);
+                                cam_obj->state = CAM_STATE_IDLE;
+                                continue;
+                            }
+                        } else {
+                            int soi_off = cam_verify_jpeg_soi(frame_buffer_event->buf, frame_buffer_event->len);
+                            if (soi_off != 0) {
+                                static uint16_t warn_soi_bad_cnt = 0;
+                                if (soi_off > 0) {
+                                    CAM_WARN_THROTTLE(warn_soi_bad_cnt,
+                                                      "NO-SOI - JPEG start marker not at pos 0");
+                                } else {
+                                    CAM_WARN_THROTTLE(warn_soi_bad_cnt,
+                                                      "NO-SOI - JPEG start marker missing");
+                                }
+                                ll_cam_stop(cam_obj);
+                                cam_obj->state = CAM_STATE_IDLE;
+                                continue;
+                            }
+                        }
                     }
+
                     cnt++;
-                    // stop when too many DMA copies occur so the PSRAM
-                    // framebuffer slot doesn't overflow from runaway transfers
-                    if (cnt >= cam_obj->frame_copy_cnt) {
-                        ESP_LOGE(TAG, "DMA overflow");
-                        ll_cam_stop(cam_obj);
-                        cam_obj->state = CAM_STATE_IDLE;
-                        continue;
-                    }
 
                 } else if (cam_event == CAM_VSYNC_EVENT) {
                     //DBG_PIN_SET(1);
@@ -320,6 +421,9 @@ static esp_err_t cam_dma_config(const camera_config_t *config)
 
     cam_obj->dma_node_cnt = (cam_obj->dma_buffer_size) / cam_obj->dma_node_buffer_size; // Number of DMA nodes
     cam_obj->frame_copy_cnt = cam_obj->recv_size / cam_obj->dma_half_buffer_size; // Number of interrupted copies, ping-pong copy
+    if (cam_obj->psram_mode) {
+        cam_obj->frame_copy_cnt++;
+    }
 
     ESP_LOGI(TAG, "buffer_size: %d, half_buffer_size: %d, node_buffer_size: %d, node_cnt: %d, total_cnt: %d",
              (int) cam_obj->dma_buffer_size, (int) cam_obj->dma_half_buffer_size, (int) cam_obj->dma_node_buffer_size,
@@ -338,6 +442,7 @@ static esp_err_t cam_dma_config(const camera_config_t *config)
         if (cam_obj->fb_size < cam_obj->recv_size) {
             fb_size = cam_obj->recv_size;
         }
+        fb_size += cam_obj->dma_half_buffer_size;
     }
 
     /* Allocate memory for frame buffer */
@@ -589,12 +694,38 @@ camera_fb_t *cam_take(TickType_t timeout)
 
         if (cam_obj->jpeg_mode) {
             /* find the end marker for JPEG. Data after that can be discarded */
-            int offset_e = cam_verify_jpeg_eoi(dma_buffer->buf, dma_buffer->len);
+            int offset_e = -1;
+            if (cam_obj->psram_mode) {
+                size_t probe_len = dma_buffer->len;
+                if (probe_len > CAM_EOI_PROBE_BYTES) {
+                    probe_len = CAM_EOI_PROBE_BYTES;
+                }
+                if (probe_len == 0) {
+                    goto skip_eoi_check;
+                }
+                cam_drop_psram_cache(dma_buffer->buf + dma_buffer->len - probe_len, probe_len);
+
+                uint8_t eoi_probe[CAM_EOI_PROBE_BYTES];
+                memcpy(eoi_probe, dma_buffer->buf + dma_buffer->len - probe_len, probe_len);
+                int off = cam_verify_jpeg_eoi(eoi_probe, probe_len);
+                if (off >= 0) {
+                    offset_e = dma_buffer->len - probe_len + off;
+                }
+            } else {
+                offset_e = cam_verify_jpeg_eoi(dma_buffer->buf, dma_buffer->len);
+            }
+
             if (offset_e >= 0) {
                 dma_buffer->len = offset_e + sizeof(JPEG_EOI_MARKER);
+                if (cam_obj->psram_mode) {
+                    /* DMA may bypass cache, ensure full frame is visible */
+                    cam_drop_psram_cache(dma_buffer->buf, dma_buffer->len);
+                }
                 return dma_buffer;
             }
 
+skip_eoi_check:
+
             CAM_WARN_THROTTLE(warn_eoi_miss_cnt,
                               "NO-EOI - JPEG end marker missing");
             cam_give(dma_buffer);
@@ -605,6 +736,11 @@ camera_fb_t *cam_take(TickType_t timeout)
             dma_buffer->len = ll_cam_memcpy(cam_obj, dma_buffer->buf, dma_buffer->buf, dma_buffer->len);
         }
 
+        if (cam_obj->psram_mode) {
+            /* DMA may bypass cache, ensure full frame is visible to the app */
+            cam_drop_psram_cache(dma_buffer->buf, dma_buffer->len);
+        }
+
         return dma_buffer;
     }
 }
diff --git a/target/esp32/ll_cam.c b/target/esp32/ll_cam.c
@@ -39,6 +39,7 @@ static inline int gpio_ll_get_level(gpio_dev_t *hw, int gpio_num)
 #endif
 
 #if (ESP_IDF_VERSION_MAJOR >= 5)
+#include "driver/gpio.h"
 #define GPIO_PIN_INTR_POSEDGE GPIO_INTR_POSEDGE
 #define GPIO_PIN_INTR_NEGEDGE GPIO_INTR_NEGEDGE
 #define gpio_matrix_in(a,b,c) esp_rom_gpio_connect_in_signal(a,b,c)
diff --git a/target/esp32s2/ll_cam.c b/target/esp32s2/ll_cam.c
@@ -26,6 +26,7 @@
 #endif
 
 #if (ESP_IDF_VERSION_MAJOR >= 5)
+#include "driver/gpio.h"
 #define GPIO_PIN_INTR_POSEDGE GPIO_INTR_POSEDGE
 #define GPIO_PIN_INTR_NEGEDGE GPIO_INTR_NEGEDGE
 #define gpio_matrix_in(a,b,c) esp_rom_gpio_connect_in_signal(a,b,c)
diff --git a/target/esp32s3/ll_cam.c b/target/esp32s3/ll_cam.c
@@ -27,6 +27,7 @@
 #include "esp_rom_gpio.h"
 
 #if (ESP_IDF_VERSION_MAJOR >= 5)
+#include "driver/gpio.h"
 #include "soc/gpio_sig_map.h"
 #include "soc/gpio_periph.h"
 #include "soc/io_mux_reg.h"
diff --git a/target/xclk.c b/target/xclk.c
@@ -51,7 +51,10 @@ esp_err_t camera_enable_out_clock(const camera_config_t* config)
     ch_conf.gpio_num = config->pin_xclk;
     ch_conf.speed_mode = LEDC_LOW_SPEED_MODE;
     ch_conf.channel = config->ledc_channel;
-    ch_conf.intr_type = LEDC_INTR_DISABLE;
+#if ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(6,0,0)  
+    // no need to explicitly configure interrupt, handled in the driver (IDF v6.0 and above)
+    ch_conf.intr_type = LEDC_INTR_DISABLE; 
+#endif
     ch_conf.timer_sel = config->ledc_timer;
     ch_conf.duty = 1;
     ch_conf.hpoint = 0;
