freertos(IDF): Refactor port heap functions

Vanilla FreeRTOS expects applications to use one of the heap implementations
provided by FreeRTOS (i.e., heap_x.c), where functions such as pvPortMalloc()
and vPortFree() are defined in the heap implementation.

However, ESP-IDF already provides its own heap implementation
(i.e., esp_heap_caps.h). Thus, the pvPortMallc()/vPortFree() functions were
previously overriden by macro to call esp_heap functions directly.

This commit refactors the FreeRTOS port's heap as such:

- Added a heap_idf.c that implements all of the heap related functions required
  by FreeRTOS source
- All dynamic memory allocated by FreeRTOS is from internal memory. Thus, the
  FreeRTOS heap is the internal memory subset of the ESP-IDF heap.
- Removed some old macros to reduce diff from upstream source code.

components/freertos/heap_idf.c

@@ -0,0 +1,127 @@
+/*
+ * SPDX-FileCopyrightText: 2020 Amazon.com, Inc. or its affiliates
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * SPDX-FileContributor: 2023 Espressif Systems (Shanghai) CO LTD
+ */
+
+/*
+ * FreeRTOS Kernel V10.4.3
+ * Copyright (C) 2020 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * https://www.FreeRTOS.org
+ * https://github.com/FreeRTOS
+ *
+ */
+
+#include "sdkconfig.h"
+
+/* This file implements the heap related functions that are called by FreeRTOS.
+ * ESP-IDF provides its own heap containing memory with different capabilities
+ * (see esp_heap_caps.h). Thus, this file maps a subset of the ESP-IDF heap to
+ * act as the FreeRTOS heap.
+ *
+ * All dynamic allocation done by FreeRTOS should be placed in internal 8-bit
+ * accessible RAM (i.e., using the MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT flags).
+ * This is due to the fact that FreeRTOS objects (e.g., task stacks, TCBs,
+ * queues etc) must be accessible even if the cache is disabled. Therefore, the
+ * heap that is made available to FreeRTOS for dynamic allocation is a subset of
+ * the ESP-IDF heap (where all MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT memory is
+ * made available to FreeRTOS for dynamic allocation).
+ */
+
+/* Defining MPU_WRAPPERS_INCLUDED_FROM_API_FILE prevents task.h from redefining
+ * all the API functions to use the MPU wrappers.  That should only be done when
+ * task.h is included from an application file. */
+#define MPU_WRAPPERS_INCLUDED_FROM_API_FILE
+
+#include "FreeRTOS.h"
+
+#undef MPU_WRAPPERS_INCLUDED_FROM_API_FILE
+
+#if ( configSUPPORT_DYNAMIC_ALLOCATION == 0 )
+    #error This file must not be used if configSUPPORT_DYNAMIC_ALLOCATION is 0
+#endif
+
+#include "esp_heap_caps.h"
+
+#if !CONFIG_IDF_TARGET_LINUX
+    /* Memory util functions are not implemented in the Linux simulator */
+    #include "esp_memory_utils.h"
+#endif /* CONFIG_IDF_TARGET_LINUX */
+
+#define portFREERTOS_HEAP_CAPS    ( MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT )
+
+/*-----------------------------------------------------------*/
+
+void * pvPortMalloc( size_t xWantedSize )
+{
+    void * pvReturn = NULL;
+
+    /* All dynamic allocation done by FreeRTOS goes through this function. If
+     * users need to allocate FreeRTOS objects into external RAM, they should
+     * use the "static" equivalents of FreeRTOS API to create FreeRTOS objects
+     * (e.g., queues). */
+    pvReturn = heap_caps_malloc( xWantedSize, portFREERTOS_HEAP_CAPS );
+
+    return pvReturn;
+}
+/*-----------------------------------------------------------*/
+
+void vPortFree( void * pv )
+{
+    heap_caps_free( pv );
+}
+/*-----------------------------------------------------------*/
+
+size_t xPortGetFreeHeapSize( void )
+{
+    return heap_caps_get_free_size( portFREERTOS_HEAP_CAPS );
+}
+/*-----------------------------------------------------------*/
+
+size_t xPortGetMinimumEverFreeHeapSize( void )
+{
+    return heap_caps_get_minimum_free_size( portFREERTOS_HEAP_CAPS );
+}
+/*-----------------------------------------------------------*/
+
+bool xPortCheckValidTCBMem(const void *ptr)
+{
+    #if CONFIG_IDF_TARGET_LINUX
+        return true;
+    #else /* CONFIG_IDF_TARGET_LINUX */
+        return esp_ptr_internal(ptr) && esp_ptr_byte_accessible(ptr);
+    #endif /* CONFIG_IDF_TARGET_LINUX */
+}
+
+bool xPortcheckValidStackMem(const void *ptr)
+{
+    #if CONFIG_IDF_TARGET_LINUX
+        return true;
+    #else /* CONFIG_IDF_TARGET_LINUX */
+        #ifdef CONFIG_SPIRAM_ALLOW_STACK_EXTERNAL_MEMORY
+            return esp_ptr_byte_accessible(ptr);
+        #else
+            return esp_ptr_internal(ptr) && esp_ptr_byte_accessible(ptr);
+        #endif
+    #endif /* CONFIG_IDF_TARGET_LINUX */
+}