SD recording

Author: rhgndf

ch32v305/src/FreeRTOSConfig.h

@@ -64,6 +64,7 @@
 #define INCLUDE_uxTaskPriorityGet                  0
 #define INCLUDE_vTaskDelete                        0
 #define INCLUDE_vTaskSuspend                       1
+#define INCLUDE_xTaskResumeFromISR                 1
 #define INCLUDE_vTaskDelayUntil                    1
 #define INCLUDE_vTaskDelay                         1
 #define INCLUDE_xTaskAbortDelay                    0

ch32v305/src/freertos/port_ch32v30x.S

@@ -115,6 +115,8 @@ portIRQ_WRAPPER EXTI15_10_IRQHandler, EXTI15_10_IRQHandler_Body
 portIRQ_WRAPPER TIM10_CC_IRQHandler, TIM10_CC_IRQHandler_Body
 portIRQ_WRAPPER I2C2_EV_IRQHandler, I2C2_EV_IRQHandler_Body
 portIRQ_WRAPPER I2C2_ER_IRQHandler, I2C2_ER_IRQHandler_Body
+portIRQ_WRAPPER SDIO_IRQHandler, SDIO_IRQHandler_Body
+portIRQ_WRAPPER DMA2_Channel4_IRQHandler, DMA2_Channel4_IRQHandler_Body
 
 .global Ecall_M_Mode_Handler
 .type Ecall_M_Mode_Handler, @function

ch32v305/src/freertos/port_ch32v30x.c

@@ -42,6 +42,19 @@ static void systick_compare_write(uint64_t deadline)
     compare_words[1] = (uint32_t)(deadline >> 32);
     compare_words[0] = (uint32_t)deadline;
     __asm volatile("fence iorw, iorw" ::: "memory");
+
+    /*
+     * Unlike RISC-V mtimecmp, this SysTick only documents an equality
+     * condition.  If CNT reaches or passes the final compare value while the
+     * 64-bit value is being published, the hardware cannot assert it later.
+     * Pend SysTick explicitly so the handler accounts for the elapsed boundary
+     * instead of waiting for the 64-bit counter to wrap.
+     */
+    if(systick_count_read() >= deadline)
+    {
+        NVIC_SetPendingIRQ(SysTicK_IRQn);
+        __asm volatile("fence iorw, iorw" ::: "memory");
+    }
 }
 
 static BaseType_t pfic_has_enabled_pending_irq(void)

ch32v305/src/freertos/task_stacks.h

@@ -3,14 +3,17 @@
 
 /*
  * Sizes are in 32-bit StackType_t words.  The allocations include the
- * 256-byte integer/FPU context-switch frame.  Application_Task was reduced by
- * the 96 bytes removed from its compiler-emitted frame when SDCardPoll was
- * disabled; USB and I2S retain their existing margins.  Returning maskable
- * ISRs use the dedicated 1.5 KiB IRQ stack instead of application task stacks.
+ * 256-byte integer/FPU context-switch frame. The recording task's post-LTO
+ * frame is 272 bytes. Its deepest linked path (file cleanup through FatFs and
+ * asynchronous SDIO) sums to 1328 bytes before the context frame, so 432
+ * words leave 144 bytes beyond that path and the port context.
+ * Returning maskable ISRs use the dedicated 1.5 KiB IRQ stack instead of
+ * application task stacks.
  */
 #define APP_TASK_STACK_WORDS    432U
 #define USB_TASK_STACK_WORDS    256U
 #define I2S_TASK_STACK_WORDS    192U
-#define HW_STATE_TASK_STACK_WORDS 512U
+#define HW_STATE_TASK_STACK_WORDS 64U
+#define RECORDING_TASK_STACK_WORDS 432U
 
 #endif

ch32v305/src/hw/i2s.c

@@ -11,6 +11,7 @@
 #include "dac.h"
 #include "freertos/port_isr.h"
 #include "main.h"
+#include "recording.h"
 #include "pinout.h"
 #include "usb.h"
 
@@ -121,17 +122,25 @@ static void i2s_bitslip_detect(volatile uint16_t const *src_words)
     }
 
     volatile uint32_t const *src32 = (volatile uint32_t const *)(uintptr_t)src_words;
+    bool ch2_nonzero = true;
+    bool ch1_zero = true;
     for(size_t i = 0; i < I2S_RX_DMA_CHUNK_WORDS / 2U; i++)
     {
         uint32_t raw = src32[i];
         uint32_t sample_32 = (raw << 16) | (raw >> 16);
-        bool should_be_ch1_mute = (i & 1U) == 0U;
-        if(should_be_ch1_mute && (sample_32 != 0U))
-        {
-            s_i2s_needs_reset = true;
-            return;
+        if((i & 1U) == 0) {
+            // CH1
+            ch1_zero &= sample_32 == 0;
+        } else {
+            // CH2
+            ch2_nonzero &= sample_32 != 0;
         }
     }
+    if(! (ch2_nonzero && ch1_zero))
+    {
+        s_i2s_needs_reset = true;
+        return;
+    }
 }
 
 static void i2s_process_buf(volatile uint16_t *src_words)
@@ -158,6 +167,8 @@ static void i2s_process_buf(volatile uint16_t *src_words)
     }
     s_fft_sample_cnt = fft_idx;
 
+    recording_submit_i2s(src_words, I2S_RX_DMA_CHUNK_WORDS);
+
     s_rx_word_count += I2S_RX_DMA_CHUNK_WORDS;
     audio_usb_mic_write(src_words, I2S_RX_DMA_CHUNK_WORDS);
     demod_process(src_words, I2S_RX_DMA_CHUNK_WORDS);

ch32v305/src/hw/sdcard/sdcard.cpp

@@ -7,9 +7,7 @@ extern "C" {
 #include "bitbang.h"
 
 #include <algorithm>
-#include <array>
 #include <concepts>
-#include <cstring>
 #include <expected>
 #include <limits>
 
@@ -55,11 +53,7 @@ class SDCard {
 
     ErrorStatus read_sector(uint32_t sector, std::span<uint8_t, 512> buf)
     {
-        if(!initialized ||
-           (!sdhc && sector > std::numeric_limits<uint32_t>::max() / 512U))
-            return NoREADY;
-        uint32_t addr = sdhc ? sector : sector * 512U;
-        return transport.read_blocks(addr, buf);
+        return read_sectors(sector, buf);
     }
 
     ErrorStatus read_sectors(uint32_t start_sector, std::span<uint8_t> buf)
@@ -79,6 +73,7 @@ class SDCard {
         {
             uint32_t sector = start_sector + static_cast<uint32_t>(block_offset);
             uint32_t addr = sdhc ? sector : sector * 512U;
+
             std::size_t blocks_remaining =
                 static_cast<std::size_t>(block_count) - block_offset;
             std::size_t blocks_this_transfer =
@@ -117,17 +112,6 @@ class SDCard {
         {
             uint32_t sector = start_sector + static_cast<uint32_t>(block_offset);
             uint32_t addr = sdhc ? sector : sector * 512U;
-            const uint8_t* source = buf.data() + block_offset * 512U;
-            bool aligned = (reinterpret_cast<uintptr_t>(source) & 3U) == 0U;
-
-            if(!aligned)
-            {
-                std::memcpy(write_bounce.data(), source, write_bounce.size());
-                if(transport.write_blocks(addr, write_bounce) != READY)
-                    return NoREADY;
-                ++block_offset;
-                continue;
-            }
 
             std::size_t blocks_remaining =
                 static_cast<std::size_t>(block_count) - block_offset;
@@ -154,7 +138,6 @@ class SDCard {
     bool initialized = false;
     bool sdhc = false;
     CID card_cid = {};
-    alignas(4) std::array<uint8_t, 512> write_bounce{};
 };
 
 // --- compile-time transport selection -------------------------------------