Implement support for ESP32 C6 and P4 SOCs (#421)

- Implement generic ESP32 devices
- Updated GitHub Actions to first build the SDKs. These are now based on the generic device implementations and the build act as a filter before compiling the dozens of other devices. It should save on resources when boards fail to compile.
- Adapted code to C6 and P4 differences, heavily borrowed from from https://github.com/ByteWelder/Tactility/pull/394 written by @marciogranzotto, with some changes of my own
- Updated `device.py` to make the `[display]` section optional

TactilityCore/Source/CpuAffinity.cpp

@@ -1,3 +1,7 @@
+#ifdef ESP_PLATFORM
+#include <sdkconfig.h>
+#endif
+
 #include "Tactility/CpuAffinity.h"
 
 #include <Tactility/Check.h>
@@ -6,25 +10,39 @@ namespace tt {
 
 #ifdef ESP_PLATFORM
 
+#ifdef CONFIG_ESP_WIFI_ENABLED
+
 static CpuAffinity getEspWifiAffinity() {
-#ifdef CONFIG_ESP32_WIFI_TASK_PINNED_TO_CORE_0
+#if CONFIG_FREERTOS_NUMBER_OF_CORES == 1
     return 0;
-#elif defined(CONFIG_ESP32_WIFI_TASK_PINNED_TO_CORE_1)
+#elif defined(CONFIG_ESP_WIFI_TASK_PINNED_TO_CORE_0)
+    return 0;
+#elif defined(CONFIG_ESP_WIFI_TASK_PINNED_TO_CORE_1)
     return 1;
+#else // Assume core 0 (risky, but safer than "None")
+    return 0;
 #endif
 }
 
+#endif
+
 // Warning: Must watch ESP WiFi, as this task is used by WiFi
 static CpuAffinity getEspMainSchedulerAffinity() {
-#ifdef CONFIG_ESP32_WIFI_TASK_PINNED_TO_CORE_0
+#if CONFIG_FREERTOS_NUMBER_OF_CORES == 1
     return 0;
-#elif defined(CONFIG_ESP32_WIFI_TASK_PINNED_TO_CORE_1)
+#elif defined(CONFIG_ESP_WIFI_TASK_PINNED_TO_CORE_0)
+    return 0;
+#elif defined(CONFIG_ESP_WIFI_TASK_PINNED_TO_CORE_1)
     return 1;
+#else
+    return None;
 #endif
 }
 
 static CpuAffinity getFreeRtosTimerAffinity() {
-#if defined(CONFIG_FREERTOS_TIMER_TASK_NO_AFFINITY)
+#if CONFIG_FREERTOS_NUMBER_OF_CORES == 1
+    return 0;
+#elif defined(CONFIG_FREERTOS_TIMER_TASK_NO_AFFINITY)
     return None;
 #elif defined(CONFIG_FREERTOS_TIMER_TASK_AFFINITY_CPU0)
     return 0;
@@ -48,7 +66,11 @@ static const CpuAffinityConfiguration esp = {
 static const CpuAffinityConfiguration esp = {
     .system = 0,
     .graphics = 1,
+#ifdef CONFIG_ESP_WIFI_ENABLED
     .wifi = getEspWifiAffinity(),
+#else
+    .wifi = 0,
+#endif
     .mainDispatcher = getEspMainSchedulerAffinity(),
     .apps = 1,
     .timer = getFreeRtosTimerAffinity()

TactilityCore/Source/kernel/PanicHandler.cpp

@@ -1,11 +1,13 @@
-#ifdef ESP_PLATFORM
+#if defined(ESP_PLATFORM) && defined(CONFIG_IDF_TARGET_ARCH_XTENSA)
 
 #include "Tactility/kernel/PanicHandler.h"
 
 #include <esp_debug_helpers.h>
 #include <esp_attr.h>
 #include <esp_memory_utils.h>
+#include <esp_cpu.h>
 #include <esp_cpu_utils.h>
+#include <xtensa/xtruntime.h>
 
 extern "C" {
 
@@ -35,10 +37,15 @@ void __wrap_esp_panic_handler(void* info) {
 #endif
     crashData.callstackLength++;
 
-    crashData.callstackCorrupted = !(esp_stack_ptr_is_sane(frame.sp) &&
-        (esp_ptr_executable((void *)esp_cpu_process_stack_pc(frame.pc)) ||
-        /* Ignore the first corrupted PC in case of InstrFetchProhibited */
-        (frame.exc_frame && ((XtExcFrame *)frame.exc_frame)->exccause == EXCCAUSE_INSTR_PROHIBITED)));
+    uint32_t processed_pc = esp_cpu_process_stack_pc(frame.pc);
+    bool pc_is_valid = esp_ptr_executable((void *)processed_pc);
+
+    /* Ignore the first corrupted PC in case of InstrFetchProhibited on Xtensa */
+    if (frame.exc_frame && ((XtExcFrame *)frame.exc_frame)->exccause == EXCCAUSE_INSTR_PROHIBITED) {
+        pc_is_valid = true;
+    }
+
+    crashData.callstackCorrupted = !(esp_stack_ptr_is_sane(frame.sp) && pc_is_valid);
 
     while (
         frame.next_pc != 0 &&
@@ -46,6 +53,14 @@ void __wrap_esp_panic_handler(void* info) {
         && crashData.callstackLength < CRASH_DATA_CALLSTACK_LIMIT
     ) {
         if (esp_backtrace_get_next_frame(&frame)) {
+            // Validate the current frame
+            uint32_t processed_frame_pc = esp_cpu_process_stack_pc(frame.pc);
+            bool frame_pc_is_valid = esp_ptr_executable((void *)processed_frame_pc);
+
+            if (!esp_stack_ptr_is_sane(frame.sp) || !frame_pc_is_valid) {
+                crashData.callstackCorrupted = true;
+                break;
+            }
             crashData.callstack[crashData.callstackLength].pc = frame.pc;
 #if CRASH_DATA_INCLUDES_SP
             crashData.callstack[crashData.callstackLength].sp = frame.sp;
@@ -66,4 +81,15 @@ void __wrap_esp_panic_handler(void* info) {
 
 const CrashData& getRtcCrashData() { return crashData; }
 
+#elif defined(ESP_PLATFORM)
+
+// Stub implementation for RISC-V and other architectures
+// TODO: Implement crash data collection for RISC-V using frame pointer or EH frame
+
+#include <Tactility/kernel/PanicHandler.h>
+
+static CrashData emptyCrashData = {};
+
+const CrashData& getRtcCrashData() { return emptyCrashData; }
+
 #endif