PoC cache configuration control

bootloaders/eboot/eboot.c

@@ -68,7 +68,7 @@ int load_app_from_flash_raw(const uint32_t flash_addr)
             load = true;
         }
 
-        if (address >= 0x40100000 && address < 0x40108000) {
+        if (address >= 0x40100000 && address < 0x4010C000) {
             load = true;
         }
 

cores/esp8266/Arduino.h

@@ -241,6 +241,10 @@ const int TIM_DIV265 __attribute__((deprecated, weak)) = TIM_DIV256;
 #include "Updater.h"
 #include "debug.h"
 
+
+#include "mmu_iram.h"
+
+
 using std::min;
 using std::max;
 using std::round;

cores/esp8266/Esp-frag.cpp

@@ -30,14 +30,15 @@ void EspClass::getHeapStats(uint32_t* hfree, uint16_t* hmax, uint8_t* hfrag)
     // 100 * (1 - sqrt(sum(hole-size²)) / sum(hole-size))
 
     umm_info(NULL, false);
-    uint8_t block_size = umm_block_size();
+
+    uint32_t free_size = umm_free_heap_size_core();
     if (hfree)
-        *hfree = ummHeapInfo.freeBlocks * block_size;
+        *hfree = free_size;
     if (hmax)
-        *hmax = (uint16_t)ummHeapInfo.maxFreeContiguousBlocks * block_size;
+        *hmax = (uint16_t)umm_max_block_size_core();
     if (hfrag) {
-      if (ummHeapInfo.freeBlocks) {
-        *hfrag = 100 - (sqrt32(ummHeapInfo.freeBlocksSquared) * 100) / ummHeapInfo.freeBlocks;
+      if (free_size) {
+        *hfrag = umm_fragmentation_metric_core();
       } else {
         *hfrag = 0;
       }
@@ -46,11 +47,5 @@ void EspClass::getHeapStats(uint32_t* hfree, uint16_t* hmax, uint8_t* hfrag)
 
 uint8_t EspClass::getHeapFragmentation()
 {
-#ifdef UMM_INLINE_METRICS
-    return (uint8_t)umm_fragmentation_metric();
-#else
-    uint8_t hfrag;
-    getHeapStats(nullptr, nullptr, &hfrag);
-    return hfrag;
-#endif
+  return (uint8_t)umm_fragmentation_metric();
 }

cores/esp8266/Esp.cpp

@@ -27,6 +27,8 @@
 #include "umm_malloc/umm_malloc.h"
 #include "cont.h"
 #include "coredecls.h"
+#include "umm_malloc/umm_malloc.h"
+// #include "core_esp8266_vm.h"
 
 extern "C" {
 #include "user_interface.h"
@@ -759,3 +761,47 @@ String EspClass::getSketchMD5()
     result = md5.toString();
     return result;
 }
+
+void EspClass::enableVM()
+{
+#ifdef UMM_HEAP_EXTERNAL
+    if (!vmEnabled)
+        install_vm_exception_handler();
+    vmEnabled = true;
+#endif
+}
+
+void EspClass::setExternalHeap()
+{
+#ifdef UMM_HEAP_EXTERNAL
+    if (vmEnabled)
+        umm_push_heap(UMM_HEAP_EXTERNAL);
+#endif
+}
+
+void EspClass::setIramHeap()
+{
+#ifdef UMM_HEAP_IRAM
+    umm_push_heap(UMM_HEAP_IRAM);
+#endif
+}
+
+void EspClass::setDramHeap()
+{
+#if defined(UMM_HEAP_EXTERNAL) && !defined(UMM_HEAP_IRAM)
+    if (vmEnabled)
+        umm_push_heap(UMM_HEAP_DRAM);
+#elif defined(UMM_HEAP_IRAM)
+    umm_push_heap(UMM_HEAP_DRAM);
+#endif
+}
+
+void EspClass::resetHeap()
+{
+#if defined(UMM_HEAP_EXTERNAL) && !defined(UMM_HEAP_IRAM)
+    if (vmEnabled)
+        umm_pop_heap();
+#elif defined(UMM_HEAP_IRAM)
+    umm_pop_heap();
+#endif
+}

cores/esp8266/Esp.h

@@ -172,6 +172,17 @@ class EspClass {
 #else
         uint32_t getCycleCount();
 #endif
+
+        void enableVM();
+        void setDramHeap();
+        void setIramHeap();
+        void setExternalHeap();
+        void setInternalHeap() {setDramHeap();}; // depricated
+        void resetHeap();
+private:
+#ifdef UMM_HEAP_EXTERNAL
+        bool vmEnabled = false;
+#endif
 };
 
 #ifndef CORE_MOCK

cores/esp8266/StackThunk.cpp

@@ -31,6 +31,7 @@
 #include "debug.h"
 #include "StackThunk.h"
 #include <ets_sys.h>
+#include <umm_malloc/umm_malloc.h>
 
 extern "C" {
 
@@ -48,7 +49,10 @@ void stack_thunk_add_ref()
 {
   stack_thunk_refcnt++;
   if (stack_thunk_refcnt == 1) {
+    ETS_PRINTF("\nStackThunk malloc(%u)\n", _stackSize * sizeof(uint32_t));
+    HeapSelectDram ephemeral;
     stack_thunk_ptr = (uint32_t *)malloc(_stackSize * sizeof(uint32_t));
+    ETS_PRINTF("StackThunk stack_thunk_ptr: %p\n", stack_thunk_ptr);
     if (!stack_thunk_ptr) {
         // This is a fatal error, stop the sketch
         DEBUGV("Unable to allocate BearSSL stack\n");

cores/esp8266/core_esp8266_main.cpp

@@ -35,6 +35,9 @@ extern "C" {
 #include <core_version.h>
 #include "gdb_hooks.h"
 #include "flash_quirks.h"
+#include <umm_malloc/umm_malloc.h>
+#include <core_esp8266_non32xfer.h>
+
 
 #define LOOP_TASK_PRIORITY 1
 #define LOOP_QUEUE_SIZE    1
@@ -308,14 +311,20 @@ extern "C" void app_entry_redefinable(void)
     cont_t s_cont __attribute__((aligned(16)));
     g_pcont = &s_cont;
 
+    DBG_MMU_PRINT_STATUS();
+
+    DBG_MMU_PRINT_IRAM_BANK_REG(0, "");
+
+    DBG_MMU_PRINTF("\nCall call_user_start()\n");
+
     /* Call the entry point of the SDK code. */
     call_user_start();
 }
-
 static void app_entry_custom (void) __attribute__((weakref("app_entry_redefinable")));
 
 extern "C" void app_entry (void)
 {
+    umm_init();
     return app_entry_custom();
 }
 
@@ -335,10 +344,16 @@ extern "C" void user_init(void) {
 
     initVariant();
 
-    experimental::initFlashQuirks(); // Chip specific flash init.
+    // experimental::initFlashQuirks(); // Chip specific flash init.
 
     cont_init(g_pcont);
 
+#if defined(NON32XFER_HANDLER)
+    install_non32xfer_exception_handler();
+#endif
+#if defined(MMU_IRAM_HEAP)
+    umm_init_iram();
+#endif
     preinit(); // Prior to C++ Dynamic Init (not related to above init() ). Meant to be user redefinable.
 
     ets_task(loop_task,