OP-943 uses pios_mem API for heap allocation

flight/libraries/WorldMagModel.c

@@ -40,7 +40,6 @@
  * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  */
 
-// I don't want this dependency, but currently using pvPortMalloc
 #include "openpilot.h"
 
 #include <stdio.h>
@@ -52,7 +51,7 @@
 #include "WorldMagModel.h"
 #include "WMMInternal.h"
 
-#define MALLOC(x) pvPortMalloc(x)
+#define MALLOC(x) pios_malloc(x)
 #define FREE(x)   vPortFree(x)
 // #define MALLOC(x) malloc(x)
 // #define FREE(x) free(x)

flight/libraries/math/sin_lookup.c

@@ -78,7 +78,7 @@ int sin_lookup_initalize()
         return 0;
     }
 
-    sin_table = (float *)pvPortMalloc(sizeof(float) * SIN_RESOLUTION);
+    sin_table = (float *)pios_malloc(sizeof(float) * SIN_RESOLUTION);
     if (sin_table == NULL) {
         return -1;
     }

flight/modules/Airspeed/gps_airspeed.c

@@ -73,7 +73,7 @@ static inline float Sq(float x)
 void gps_airspeedInitialize()
 {
     // This method saves memory in case we don't use the GPS module.
-    gps = (struct GPSGlobals *)pvPortMalloc(sizeof(struct GPSGlobals));
+    gps = (struct GPSGlobals *)pios_malloc(sizeof(struct GPSGlobals));
 
     // GPS airspeed calculation variables
     VelocityStateInitialize();

flight/modules/CameraStab/camerastab.c

@@ -110,7 +110,7 @@ int32_t CameraStabInitialize(void)
 
     if (cameraStabEnabled) {
         // allocate and initialize the static data storage only if module is enabled
-        csd = (struct CameraStab_data *)pvPortMalloc(sizeof(struct CameraStab_data));
+        csd = (struct CameraStab_data *)pios_malloc(sizeof(struct CameraStab_data));
         if (!csd) {
             return -1;
         }

flight/modules/ComUsbBridge/ComUsbBridge.c

@@ -115,9 +115,9 @@ static int32_t comUsbBridgeInitialize(void)
 #endif
 
     if (bridge_enabled) {
-        com2usb_buf = pvPortMalloc(BRIDGE_BUF_LEN);
+        com2usb_buf = pios_malloc(BRIDGE_BUF_LEN);
         PIOS_Assert(com2usb_buf);
-        usb2com_buf = pvPortMalloc(BRIDGE_BUF_LEN);
+        usb2com_buf = pios_malloc(BRIDGE_BUF_LEN);
         PIOS_Assert(usb2com_buf);
 
         updateSettings();

flight/modules/Fault/Fault.c

@@ -73,7 +73,7 @@ static int32_t fault_initialize(void)
             break;
         case FAULTSETTINGS_ACTIVATEFAULT_INITOUTOFMEMORY:
             /* Leak all available memory */
-            while (pvPortMalloc(10)) {
+            while (pios_malloc(10)) {
                 ;
             }
             break;
@@ -126,7 +126,7 @@ static void fault_task(__attribute__((unused)) void *parameters)
         break;
     case FAULTSETTINGS_ACTIVATEFAULT_TASKOUTOFMEMORY:
         /* Leak all available memory and then sleep */
-        while (pvPortMalloc(10)) {
+        while (pios_malloc(10)) {
             ;
         }
         while (1) {

flight/modules/FirmwareIAP/firmwareiap.c

@@ -193,7 +193,7 @@ static void FirmwareIAPCallback(UAVObjEvent *ev)
                     /* Note: Cant just wait timeout value, because first time is randomized */
                     reset_count = 0;
                     lastResetSysTime = xTaskGetTickCount();
-                    UAVObjEvent *event = pvPortMalloc(sizeof(UAVObjEvent));
+                    UAVObjEvent *event = pios_malloc(sizeof(UAVObjEvent));
                     memset(event, 0, sizeof(UAVObjEvent));
                     EventPeriodicCallbackCreate(event, resetTask, 100);
                     iap_state = IAP_STATE_RESETTING;

flight/modules/GPS/GPS.c

@@ -175,10 +175,10 @@ int32_t GPSInitialize(void)
         GPSSettingsDataProtocolGet(&gpsProtocol);
         switch (gpsProtocol) {
         case GPSSETTINGS_DATAPROTOCOL_NMEA:
-            gps_rx_buffer = pvPortMalloc(NMEA_MAX_PACKET_LENGTH);
+            gps_rx_buffer = pios_malloc(NMEA_MAX_PACKET_LENGTH);
             break;
         case GPSSETTINGS_DATAPROTOCOL_UBX:
-            gps_rx_buffer = pvPortMalloc(sizeof(struct UBXPacket));
+            gps_rx_buffer = pios_malloc(sizeof(struct UBXPacket));
             break;
         default:
             gps_rx_buffer = NULL;

flight/modules/Logging/Logging.c

@@ -58,7 +58,7 @@ int32_t LoggingInitialize(void)
     DebugLogEntryInitialize();
     FlightStatusInitialize();
     PIOS_DEBUGLOG_Initialize();
-    entry = pvPortMalloc(sizeof(DebugLogEntryData));
+    entry = pios_malloc(sizeof(DebugLogEntryData));
     if (!entry) {
         return -1;
     }

flight/modules/Osd/osdinput/osdinput.c

@@ -102,7 +102,7 @@ int32_t osdinputInitialize(void)
 
     oposdPort = PIOS_COM_OSD;
 
-    oposd_rx_buffer = pvPortMalloc(MAX_PACKET_LENGTH);
+    oposd_rx_buffer = pios_malloc(MAX_PACKET_LENGTH);
     PIOS_Assert(oposd_rx_buffer);
 
     return 0;

flight/modules/OveroSync/overosync.c

@@ -118,7 +118,7 @@ int32_t OveroSyncStart(void)
         return -1;
     }
 
-    overosync = (struct overosync *)pvPortMalloc(sizeof(*overosync));
+    overosync = (struct overosync *)pios_malloc(sizeof(*overosync));
     if (overosync == NULL) {
         return -1;
     }

flight/modules/OveroSync/simulated/overosync.c

@@ -106,7 +106,7 @@ int32_t OveroSyncInitialize(void)
  */
 int32_t OveroSyncStart(void)
 {
-    overosync = (struct overosync *)pvPortMalloc(sizeof(*overosync));
+    overosync = (struct overosync *)pios_malloc(sizeof(*overosync));
     if (overosync == NULL) {
         return -1;
     }

flight/modules/RadioComBridge/RadioComBridge.c

@@ -225,7 +225,7 @@ static int32_t RadioComBridgeStart(void)
 static int32_t RadioComBridgeInitialize(void)
 {
     // allocate and initialize the static data storage only if module is enabled
-    data = (RadioComBridgeData *)pvPortMalloc(sizeof(RadioComBridgeData));
+    data = (RadioComBridgeData *)pios_malloc(sizeof(RadioComBridgeData));
     if (!data) {
         return -1;
     }

flight/modules/StateEstimation/filterair.c

@@ -57,7 +57,7 @@ int32_t filterAirInitialize(stateFilter *handle)
 {
     handle->init      = &init;
     handle->filter    = &filter;
-    handle->localdata = pvPortMalloc(sizeof(struct data));
+    handle->localdata = pios_malloc(sizeof(struct data));
     return STACK_REQUIRED;
 }
 

flight/modules/StateEstimation/filteraltitude.c

@@ -82,7 +82,7 @@ int32_t filterAltitudeInitialize(stateFilter *handle)
 {
     handle->init      = &init;
     handle->filter    = &filter;
-    handle->localdata = pvPortMalloc(sizeof(struct data));
+    handle->localdata = pios_malloc(sizeof(struct data));
     HomeLocationInitialize();
     AttitudeStateInitialize();
     AltitudeFilterSettingsInitialize();

flight/modules/StateEstimation/filterbaro.c

@@ -63,7 +63,7 @@ int32_t filterBaroInitialize(stateFilter *handle)
 {
     handle->init      = &initwithgps;
     handle->filter    = &filter;
-    handle->localdata = pvPortMalloc(sizeof(struct data));
+    handle->localdata = pios_malloc(sizeof(struct data));
     return STACK_REQUIRED;
 }
 
@@ -71,7 +71,7 @@ int32_t filterBaroiInitialize(stateFilter *handle)
 {
     handle->init      = &initwithoutgps;
     handle->filter    = &filter;
-    handle->localdata = pvPortMalloc(sizeof(struct data));
+    handle->localdata = pios_malloc(sizeof(struct data));
     return STACK_REQUIRED;
 }
 

flight/modules/StateEstimation/filtercf.c

@@ -106,7 +106,7 @@ int32_t filterCFInitialize(stateFilter *handle)
     globalInit();
     handle->init      = &initwithoutmag;
     handle->filter    = &filter;
-    handle->localdata = pvPortMalloc(sizeof(struct data));
+    handle->localdata = pios_malloc(sizeof(struct data));
     return STACK_REQUIRED;
 }
 
@@ -115,7 +115,7 @@ int32_t filterCFMInitialize(stateFilter *handle)
     globalInit();
     handle->init      = &initwithmag;
     handle->filter    = &filter;
-    handle->localdata = pvPortMalloc(sizeof(struct data));
+    handle->localdata = pios_malloc(sizeof(struct data));
     return STACK_REQUIRED;
 }
 

flight/modules/StateEstimation/filterekf.c

@@ -104,7 +104,7 @@ int32_t filterEKF13iInitialize(stateFilter *handle)
     globalInit();
     handle->init      = &init13i;
     handle->filter    = &filter;
-    handle->localdata = pvPortMalloc(sizeof(struct data));
+    handle->localdata = pios_malloc(sizeof(struct data));
     return STACK_REQUIRED;
 }
 int32_t filterEKF13Initialize(stateFilter *handle)
@@ -112,7 +112,7 @@ int32_t filterEKF13Initialize(stateFilter *handle)
     globalInit();
     handle->init      = &init13;
     handle->filter    = &filter;
-    handle->localdata = pvPortMalloc(sizeof(struct data));
+    handle->localdata = pios_malloc(sizeof(struct data));
     return STACK_REQUIRED;
 }
 // XXX
@@ -123,7 +123,7 @@ int32_t filterEKF16iInitialize(stateFilter *handle)
     globalInit();
     handle->init      = &init13i;
     handle->filter    = &filter;
-    handle->localdata = pvPortMalloc(sizeof(struct data));
+    handle->localdata = pios_malloc(sizeof(struct data));
     return STACK_REQUIRED;
 }
 int32_t filterEKF16Initialize(stateFilter *handle)
@@ -131,7 +131,7 @@ int32_t filterEKF16Initialize(stateFilter *handle)
     globalInit();
     handle->init      = &init13;
     handle->filter    = &filter;
-    handle->localdata = pvPortMalloc(sizeof(struct data));
+    handle->localdata = pios_malloc(sizeof(struct data));
     return STACK_REQUIRED;
 }
 

flight/modules/StateEstimation/filterlla.c

@@ -60,7 +60,7 @@ int32_t filterLLAInitialize(stateFilter *handle)
 {
     handle->init      = &init;
     handle->filter    = &filter;
-    handle->localdata = pvPortMalloc(sizeof(struct data));
+    handle->localdata = pios_malloc(sizeof(struct data));
     GPSSettingsInitialize();
     GPSPositionSensorInitialize();
     HomeLocationInitialize();

flight/modules/StateEstimation/filtermag.c

@@ -68,7 +68,7 @@ int32_t filterMagInitialize(stateFilter *handle)
 {
     handle->init      = &init;
     handle->filter    = &filter;
-    handle->localdata = pvPortMalloc(sizeof(struct data));
+    handle->localdata = pios_malloc(sizeof(struct data));
     HomeLocationInitialize();
     return STACK_REQUIRED;
 }

flight/pios/common/pios_adxl345.c

@@ -59,7 +59,7 @@ static struct adxl345_dev *PIOS_ADXL345_alloc(void)
 {
     struct adxl345_dev *adxl345_dev;
 
-    adxl345_dev = (struct adxl345_dev *)pvPortMalloc(sizeof(*adxl345_dev));
+    adxl345_dev = (struct adxl345_dev *)pios_malloc(sizeof(*adxl345_dev));
     if (!adxl345_dev) {
         return NULL;
     }

flight/pios/common/pios_bma180.c

@@ -73,7 +73,7 @@ static struct bma180_dev *PIOS_BMA180_alloc(void)
 {
     struct bma180_dev *bma180_dev;
 
-    bma180_dev = (struct bma180_dev *)pvPortMalloc(sizeof(*bma180_dev));
+    bma180_dev = (struct bma180_dev *)pios_malloc(sizeof(*bma180_dev));
     if (!bma180_dev) {
         return NULL;
     }

flight/pios/common/pios_callbackscheduler.c

@@ -273,7 +273,7 @@ DelayedCallbackInfo *PIOS_CALLBACKSCHEDULER_Create(
     // if given priorityTask does not exist, create it
     if (!task) {
         // allocate memory if possible
-        task = (struct DelayedCallbackTaskStruct *)pvPortMalloc(sizeof(struct DelayedCallbackTaskStruct));
+        task = (struct DelayedCallbackTaskStruct *)pios_malloc(sizeof(struct DelayedCallbackTaskStruct));
         if (!task) {
             xSemaphoreGiveRecursive(mutex);
             return NULL;
@@ -329,7 +329,7 @@ DelayedCallbackInfo *PIOS_CALLBACKSCHEDULER_Create(
     }
 
     // initialize callback scheduling info
-    DelayedCallbackInfo *info = (DelayedCallbackInfo *)pvPortMalloc(sizeof(DelayedCallbackInfo));
+    DelayedCallbackInfo *info = (DelayedCallbackInfo *)pios_malloc(sizeof(DelayedCallbackInfo));
     if (!info) {
         xSemaphoreGiveRecursive(mutex);
         return NULL; // error - not enough memory

flight/pios/common/pios_com.c

@@ -71,7 +71,7 @@ static struct pios_com_dev *PIOS_COM_alloc(void)
 {
     struct pios_com_dev *com_dev;
 
-    com_dev = (struct pios_com_dev *)pvPortMalloc(sizeof(struct pios_com_dev));
+    com_dev = (struct pios_com_dev *)pios_malloc(sizeof(struct pios_com_dev));
     if (!com_dev) {
         return NULL;
     }

flight/pios/common/pios_debuglog.c

@@ -66,7 +66,7 @@ void PIOS_DEBUGLOG_Initialize()
 #if defined(PIOS_INCLUDE_FREERTOS)
     if (!mutex) {
         mutex  = xSemaphoreCreateRecursiveMutex();
-        buffer = pvPortMalloc(sizeof(DebugLogEntryData));
+        buffer = pios_malloc(sizeof(DebugLogEntryData));
     }
 #else
     buffer = &staticbuffer;

flight/pios/common/pios_flash_jedec.c

@@ -93,7 +93,7 @@ static struct jedec_flash_dev *PIOS_Flash_Jedec_alloc(void)
 {
     struct jedec_flash_dev *flash_dev;
 
-    flash_dev = (struct jedec_flash_dev *)pvPortMalloc(sizeof(*flash_dev));
+    flash_dev = (struct jedec_flash_dev *)pios_malloc(sizeof(*flash_dev));
     if (!flash_dev) {
         return NULL;
     }

flight/pios/common/pios_flashfs_logfs.c

@@ -485,7 +485,7 @@ static struct logfs_state *PIOS_FLASHFS_Logfs_alloc(void)
 {
     struct logfs_state *logfs;
 
-    logfs = (struct logfs_state *)pvPortMalloc(sizeof(*logfs));
+    logfs = (struct logfs_state *)pios_malloc(sizeof(*logfs));
     if (!logfs) {
         return NULL;
     }

flight/pios/common/pios_gcsrcvr.c

@@ -70,7 +70,7 @@ static struct pios_gcsrcvr_dev *PIOS_gcsrcvr_alloc(void)
 {
     struct pios_gcsrcvr_dev *gcsrcvr_dev;
 
-    gcsrcvr_dev = (struct pios_gcsrcvr_dev *)pvPortMalloc(sizeof(*gcsrcvr_dev));
+    gcsrcvr_dev = (struct pios_gcsrcvr_dev *)pios_malloc(sizeof(*gcsrcvr_dev));
     if (!gcsrcvr_dev) {
         return NULL;
     }

flight/pios/common/pios_hcsr04.c

@@ -69,7 +69,7 @@ static struct pios_hcsr04_dev *PIOS_PWM_alloc(void)
 {
     struct pios_hcsr04_dev *hcsr04_dev;
 
-    hcsr04_dev = (struct pios_hcsr04_dev *)pvPortMalloc(sizeof(*hcsr04_dev));
+    hcsr04_dev = (struct pios_hcsr04_dev *)pios_malloc(sizeof(*hcsr04_dev));
     if (!hcsr04_dev) {
         return NULL;
     }

flight/pios/common/pios_l3gd20.c

@@ -77,7 +77,7 @@ static struct l3gd20_dev *PIOS_L3GD20_alloc(void)
 {
     struct l3gd20_dev *l3gd20_dev;
 
-    l3gd20_dev = (struct l3gd20_dev *)pvPortMalloc(sizeof(*l3gd20_dev));
+    l3gd20_dev = (struct l3gd20_dev *)pios_malloc(sizeof(*l3gd20_dev));
     if (!l3gd20_dev) {
         return NULL;
     }

flight/pios/common/pios_mpu6000.c

@@ -79,7 +79,7 @@ static struct mpu6000_dev *PIOS_MPU6000_alloc(void)
 {
     struct mpu6000_dev *mpu6000_dev;
 
-    mpu6000_dev = (struct mpu6000_dev *)pvPortMalloc(sizeof(*mpu6000_dev));
+    mpu6000_dev = (struct mpu6000_dev *)pios_malloc(sizeof(*mpu6000_dev));
     if (!mpu6000_dev) {
         return NULL;
     }

flight/pios/common/pios_oplinkrcvr.c

@@ -70,7 +70,7 @@ static struct pios_oplinkrcvr_dev *PIOS_oplinkrcvr_alloc(void)
 {
     struct pios_oplinkrcvr_dev *oplinkrcvr_dev;
 
-    oplinkrcvr_dev = (struct pios_oplinkrcvr_dev *)pvPortMalloc(sizeof(*oplinkrcvr_dev));
+    oplinkrcvr_dev = (struct pios_oplinkrcvr_dev *)pios_malloc(sizeof(*oplinkrcvr_dev));
     if (!oplinkrcvr_dev) {
         return NULL;
     }

flight/pios/common/pios_rcvr.c

@@ -24,7 +24,7 @@ static struct pios_rcvr_dev *PIOS_RCVR_alloc(void)
 {
     struct pios_rcvr_dev *rcvr_dev;
 
-    rcvr_dev = (struct pios_rcvr_dev *)pvPortMalloc(sizeof(*rcvr_dev));
+    rcvr_dev = (struct pios_rcvr_dev *)pios_malloc(sizeof(*rcvr_dev));
     if (!rcvr_dev) {
         return NULL;
     }

flight/pios/common/pios_rfm22b.c

@@ -2408,7 +2408,7 @@ static struct pios_rfm22b_dev *pios_rfm22_alloc(void)
 {
     struct pios_rfm22b_dev *rfm22b_dev;
 
-    rfm22b_dev = (struct pios_rfm22b_dev *)pvPortMalloc(sizeof(*rfm22b_dev));
+    rfm22b_dev = (struct pios_rfm22b_dev *)pios_malloc(sizeof(*rfm22b_dev));
     rfm22b_dev->spi_id = 0;
     if (!rfm22b_dev) {
         return NULL;

flight/pios/common/pios_sbus.c

@@ -74,7 +74,7 @@ static struct pios_sbus_dev *PIOS_SBus_Alloc(void)
 {
     struct pios_sbus_dev *sbus_dev;
 
-    sbus_dev = (struct pios_sbus_dev *)pvPortMalloc(sizeof(*sbus_dev));
+    sbus_dev = (struct pios_sbus_dev *)pios_malloc(sizeof(*sbus_dev));
     if (!sbus_dev) {
         return NULL;
     }

flight/pios/common/pios_task_monitor.c

@@ -46,7 +46,7 @@ int32_t PIOS_TASK_MONITOR_Initialize(uint16_t max_tasks)
         return -1;
     }
 
-    mTaskHandles = (xTaskHandle *)pvPortMalloc(max_tasks * sizeof(xTaskHandle));
+    mTaskHandles = (xTaskHandle *)pios_malloc(max_tasks * sizeof(xTaskHandle));
     if (!mTaskHandles) {
         return -1;
     }

flight/pios/inc/pios_mem.h

@@ -29,7 +29,7 @@
 #define PIOS_MEM_H
 #ifdef PIOS_TARGET_PROVIDES_FAST_HEAP
 // relies on pios_general_malloc to perform the allocation (i.e. pios_msheap.c)
-extern void *pios_general_malloc(size_t size);
+extern void *pios_general_malloc(size_t size, bool fastheap);
 
 inline void *pios_fastheapmalloc(size_t size)
 {
@@ -44,7 +44,7 @@ inline void *pios_malloc(size_t size)
 
 inline void *pios_free(void *p)
 {
-	return vPortFree(p);
+	vPortFree(p);
 }
 
 #else

flight/pios/stm32f10x/pios_adc.c

@@ -93,7 +93,7 @@ static struct pios_adc_dev *PIOS_ADC_Allocate()
 {
     struct pios_adc_dev *adc_dev;
 
-    adc_dev = (struct pios_adc_dev *)pvPortMalloc(sizeof(*adc_dev));
+    adc_dev = (struct pios_adc_dev *)pios_malloc(sizeof(*adc_dev));
     if (!adc_dev) {
         return NULL;
     }

flight/pios/stm32f10x/pios_dsm.c

@@ -79,7 +79,7 @@ static struct pios_dsm_dev *PIOS_DSM_Alloc(void)
 {
     struct pios_dsm_dev *dsm_dev;
 
-    dsm_dev = (struct pios_dsm_dev *)pvPortMalloc(sizeof(*dsm_dev));
+    dsm_dev = (struct pios_dsm_dev *)pios_malloc(sizeof(*dsm_dev));
     if (!dsm_dev) {
         return NULL;
     }

flight/pios/stm32f10x/pios_flash_internal.c

@@ -76,7 +76,7 @@ static struct pios_internal_flash_dev *PIOS_Flash_Internal_alloc(void)
 {
     struct pios_internal_flash_dev *flash_dev;
 
-    flash_dev = (struct pios_internal_flash_dev *)pvPortMalloc(sizeof(*flash_dev));
+    flash_dev = (struct pios_internal_flash_dev *)pios_malloc(sizeof(*flash_dev));
     if (!flash_dev) {
         return NULL;
     }

flight/pios/stm32f10x/pios_i2c.c

@@ -835,7 +835,7 @@ static struct pios_i2c_adapter *PIOS_I2C_alloc(void)
 {
     struct pios_i2c_adapter *i2c_adapter;
 
-    i2c_adapter = (struct pios_i2c_adapter *)pvPortMalloc(sizeof(*i2c_adapter));
+    i2c_adapter = (struct pios_i2c_adapter *)pios_malloc(sizeof(*i2c_adapter));
     if (!i2c_adapter) {
         return NULL;
     }

flight/pios/stm32f10x/pios_ppm.c

@@ -97,7 +97,7 @@ static struct pios_ppm_dev *PIOS_PPM_alloc(void)
 {
     struct pios_ppm_dev *ppm_dev;
 
-    ppm_dev = (struct pios_ppm_dev *)pvPortMalloc(sizeof(*ppm_dev));
+    ppm_dev = (struct pios_ppm_dev *)pios_malloc(sizeof(*ppm_dev));
     if (!ppm_dev) {
         return NULL;
     }

flight/pios/stm32f10x/pios_ppm_out.c

@@ -73,7 +73,7 @@ static struct pios_ppm_out_dev *PIOS_PPM_OUT_alloc(void)
 {
     struct pios_ppm_out_dev *ppm_dev;
 
-    ppm_dev = (struct pios_ppm_out_dev *)pvPortMalloc(sizeof(*ppm_dev));
+    ppm_dev = (struct pios_ppm_out_dev *)pios_malloc(sizeof(*ppm_dev));
     if (!ppm_dev) {
         return NULL;
     }

flight/pios/stm32f10x/pios_pwm.c

@@ -72,7 +72,7 @@ static struct pios_pwm_dev *PIOS_PWM_alloc(void)
 {
     struct pios_pwm_dev *pwm_dev;
 
-    pwm_dev = (struct pios_pwm_dev *)pvPortMalloc(sizeof(*pwm_dev));
+    pwm_dev = (struct pios_pwm_dev *)pios_malloc(sizeof(*pwm_dev));
     if (!pwm_dev) {
         return NULL;
     }

flight/pios/stm32f10x/pios_spi.c

@@ -48,7 +48,7 @@ static bool PIOS_SPI_validate(__attribute__((unused)) struct pios_spi_dev *com_d
 #if defined(PIOS_INCLUDE_FREERTOS)
 static struct pios_spi_dev *PIOS_SPI_alloc(void)
 {
-    return pvPortMalloc(sizeof(struct pios_spi_dev));
+    return pios_malloc(sizeof(struct pios_spi_dev));
 }
 #else
 static struct pios_spi_dev pios_spi_devs[PIOS_SPI_MAX_DEVS];

flight/pios/stm32f10x/pios_tim.c

@@ -30,7 +30,7 @@ static struct pios_tim_dev *PIOS_TIM_alloc(void)
 {
     struct pios_tim_dev *tim_dev;
 
-    tim_dev = (struct pios_tim_dev *)malloc(sizeof(*tim_dev));
+    tim_dev = (struct pios_tim_dev *)pios_malloc(sizeof(*tim_dev));
     if (!tim_dev) {
         return NULL;
     }

flight/pios/stm32f10x/pios_usart.c

@@ -75,7 +75,7 @@ static struct pios_usart_dev *PIOS_USART_alloc(void)
 {
     struct pios_usart_dev *usart_dev;
 
-    usart_dev = (struct pios_usart_dev *)pvPortMalloc(sizeof(struct pios_usart_dev));
+    usart_dev = (struct pios_usart_dev *)pios_malloc(sizeof(struct pios_usart_dev));
     if (!usart_dev) {
         return NULL;
     }

flight/pios/stm32f10x/pios_usb.c

@@ -74,7 +74,7 @@ static struct pios_usb_dev *PIOS_USB_alloc(void)
 {
     struct pios_usb_dev *usb_dev;
 
-    usb_dev = (struct pios_usb_dev *)pvPortMalloc(sizeof(*usb_dev));
+    usb_dev = (struct pios_usb_dev *)pios_malloc(sizeof(*usb_dev));
     if (!usb_dev) {
         return NULL;
     }

flight/pios/stm32f10x/pios_usb_cdc.c

@@ -90,7 +90,7 @@ static struct pios_usb_cdc_dev *PIOS_USB_CDC_alloc(void)
 {
     struct pios_usb_cdc_dev *usb_cdc_dev;
 
-    usb_cdc_dev = (struct pios_usb_cdc_dev *)pvPortMalloc(sizeof(struct pios_usb_cdc_dev));
+    usb_cdc_dev = (struct pios_usb_cdc_dev *)pios_malloc(sizeof(struct pios_usb_cdc_dev));
     if (!usb_cdc_dev) {
         return NULL;
     }

flight/pios/stm32f10x/pios_usb_hid.c

@@ -84,7 +84,7 @@ static struct pios_usb_hid_dev *PIOS_USB_HID_alloc(void)
 {
     struct pios_usb_hid_dev *usb_hid_dev;
 
-    usb_hid_dev = (struct pios_usb_hid_dev *)pvPortMalloc(sizeof(struct pios_usb_hid_dev));
+    usb_hid_dev = (struct pios_usb_hid_dev *)pios_malloc(sizeof(struct pios_usb_hid_dev));
     if (!usb_hid_dev) {
         return NULL;
     }

flight/pios/stm32f10x/pios_usb_rctx.c

@@ -65,7 +65,7 @@ static struct pios_usb_rctx_dev *PIOS_USB_RCTX_alloc(void)
 {
     struct pios_usb_rctx_dev *usb_rctx_dev;
 
-    usb_rctx_dev = (struct pios_usb_rctx_dev *)pvPortMalloc(sizeof(*usb_rctx_dev));
+    usb_rctx_dev = (struct pios_usb_rctx_dev *)pios_malloc(sizeof(*usb_rctx_dev));
     if (!usb_rctx_dev) {
         return NULL;
     }

flight/pios/stm32f4xx/pios_adc.c

@@ -238,7 +238,7 @@ static struct pios_adc_dev *PIOS_ADC_Allocate()
 {
     struct pios_adc_dev *adc_dev;
 
-    adc_dev = (struct pios_adc_dev *)pvPortMalloc(sizeof(*adc_dev));
+    adc_dev = (struct pios_adc_dev *)pios_malloc(sizeof(*adc_dev));
     if (!adc_dev) {
         return NULL;
     }

flight/pios/stm32f4xx/pios_dsm.c

@@ -82,7 +82,7 @@ static struct pios_dsm_dev *PIOS_DSM_Alloc(void)
 {
     struct pios_dsm_dev *dsm_dev;
 
-    dsm_dev = (struct pios_dsm_dev *)pvPortMalloc(sizeof(*dsm_dev));
+    dsm_dev = (struct pios_dsm_dev *)pios_malloc(sizeof(*dsm_dev));
     if (!dsm_dev) {
         return NULL;
     }

flight/pios/stm32f4xx/pios_flash_internal.c

@@ -141,7 +141,7 @@ static struct pios_internal_flash_dev *PIOS_Flash_Internal_alloc(void)
 {
     struct pios_internal_flash_dev *flash_dev;
 
-    flash_dev = (struct pios_internal_flash_dev *)pvPortMalloc(sizeof(*flash_dev));
+    flash_dev = (struct pios_internal_flash_dev *)pios_malloc(sizeof(*flash_dev));
     if (!flash_dev) {
         return NULL;
     }

flight/pios/stm32f4xx/pios_i2c.c

@@ -903,7 +903,7 @@ static struct pios_i2c_dev *PIOS_I2C_alloc(void)
 {
     struct pios_i2c_dev *i2c_adapter;
 
-    i2c_adapter = (struct pios_i2c_adapter *)malloc(sizeof(*i2c_adapter));
+    i2c_adapter = (struct pios_i2c_adapter *)pios_malloc(sizeof(*i2c_adapter));
     if (!i2c_adapter) {
         return NULL;
     }

flight/pios/stm32f4xx/pios_overo.c

@@ -98,7 +98,7 @@ static struct pios_overo_dev *PIOS_OVERO_alloc(void)
 {
     struct pios_overo_dev *overo_dev;
 
-    overo_dev = (struct pios_overo_dev *)pvPortMalloc(sizeof(*overo_dev));
+    overo_dev = (struct pios_overo_dev *)pios_malloc(sizeof(*overo_dev));
     if (!overo_dev) {
         return NULL;
     }

flight/pios/stm32f4xx/pios_ppm.c

@@ -92,7 +92,7 @@ static struct pios_ppm_dev *PIOS_PPM_alloc(void)
 {
     struct pios_ppm_dev *ppm_dev;
 
-    ppm_dev = (struct pios_ppm_dev *)pvPortMalloc(sizeof(*ppm_dev));
+    ppm_dev = (struct pios_ppm_dev *)pios_malloc(sizeof(*ppm_dev));
     if (!ppm_dev) {
         return NULL;
     }

flight/pios/stm32f4xx/pios_pwm.c

@@ -71,7 +71,7 @@ static struct pios_pwm_dev *PIOS_PWM_alloc(void)
 {
     struct pios_pwm_dev *pwm_dev;
 
-    pwm_dev = (struct pios_pwm_dev *)pvPortMalloc(sizeof(*pwm_dev));
+    pwm_dev = (struct pios_pwm_dev *)pios_malloc(sizeof(*pwm_dev));
     if (!pwm_dev) {
         return NULL;
     }

flight/pios/stm32f4xx/pios_spi.c

@@ -53,7 +53,7 @@ static bool PIOS_SPI_validate(__attribute__((unused)) struct pios_spi_dev *com_d
 #if defined(PIOS_INCLUDE_FREERTOS)
 static struct pios_spi_dev *PIOS_SPI_alloc(void)
 {
-    return pvPortMalloc(sizeof(struct pios_spi_dev));
+    return pios_malloc(sizeof(struct pios_spi_dev));
 }
 #else
 static struct pios_spi_dev pios_spi_devs[PIOS_SPI_MAX_DEVS];

flight/pios/stm32f4xx/pios_usart.c

@@ -77,7 +77,7 @@ static struct pios_usart_dev *PIOS_USART_alloc(void)
 {
     struct pios_usart_dev *usart_dev;
 
-    usart_dev = (struct pios_usart_dev *)pvPortMalloc(sizeof(struct pios_usart_dev));
+    usart_dev = (struct pios_usart_dev *)pios_malloc(sizeof(struct pios_usart_dev));
     if (!usart_dev) {
         return NULL;
     }

flight/pios/stm32f4xx/pios_usb.c

@@ -70,7 +70,7 @@ static struct pios_usb_dev *PIOS_USB_alloc(void)
 {
     struct pios_usb_dev *usb_dev;
 
-    usb_dev = (struct pios_usb_dev *)pvPortMalloc(sizeof(*usb_dev));
+    usb_dev = (struct pios_usb_dev *)pios_malloc(sizeof(*usb_dev));
     if (!usb_dev) {
         return NULL;
     }

flight/pios/stm32f4xx/pios_usb_cdc.c

@@ -103,7 +103,7 @@ static struct pios_usb_cdc_dev *PIOS_USB_CDC_alloc(void)
 {
     struct pios_usb_cdc_dev *usb_cdc_dev;
 
-    usb_cdc_dev = (struct pios_usb_cdc_dev *)pvPortMalloc(sizeof(struct pios_usb_cdc_dev));
+    usb_cdc_dev = (struct pios_usb_cdc_dev *)pios_malloc(sizeof(struct pios_usb_cdc_dev));
     if (!usb_cdc_dev) {
         return NULL;
     }

flight/pios/stm32f4xx/pios_usb_hid.c

@@ -87,7 +87,7 @@ static struct pios_usb_hid_dev *PIOS_USB_HID_alloc(void)
 {
     struct pios_usb_hid_dev *usb_hid_dev;
 
-    usb_hid_dev = (struct pios_usb_hid_dev *)pvPortMalloc(sizeof(struct pios_usb_hid_dev));
+    usb_hid_dev = (struct pios_usb_hid_dev *)pios_malloc(sizeof(struct pios_usb_hid_dev));
     if (!usb_hid_dev) {
         return NULL;
     }

flight/pios/stm32f4xx/pios_ws2811.c

@@ -175,7 +175,7 @@ void PIOS_WS2811_Init(const struct pios_ws2811_cfg *ws2811_cfg, const struct pio
         dmaSource[i] = (ledbuf_t)pios_ws2811_pin_cfg->gpioInit.GPIO_Pin;
     }
 
-    fb = (ledbuf_t *)pvPortMalloc(PIOS_WS2811_BUFFER_SIZE * sizeof(ledbuf_t));
+    fb = (ledbuf_t *)pios_malloc(PIOS_WS2811_BUFFER_SIZE * sizeof(ledbuf_t));
     memset(fb, 0, PIOS_WS2811_BUFFER_SIZE * sizeof(ledbuf_t));
     Color ledoff = { 0, 0, 0 };
     for (uint8_t i = 0; i < PIOS_WS2811_NUMLEDS; i++) {

flight/targets/boards/coptercontrol/firmware/pios_board.c

@@ -302,8 +302,8 @@ void PIOS_Board_Init(void)
             if (PIOS_USB_CDC_Init(&pios_usb_cdc_id, &pios_usb_cdc_cfg, pios_usb_id)) {
                 PIOS_Assert(0);
             }
-            uint8_t *rx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_TELEM_USB_RX_BUF_LEN);
+            uint8_t *rx_buffer = (uint8_t *)pios_malloc(PIOS_COM_TELEM_USB_RX_BUF_LEN);
-            uint8_t *tx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_TELEM_USB_TX_BUF_LEN);
+            uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_TELEM_USB_TX_BUF_LEN);
             PIOS_Assert(rx_buffer);
             PIOS_Assert(tx_buffer);
             if (PIOS_COM_Init(&pios_com_telem_usb_id, &pios_usb_cdc_com_driver, pios_usb_cdc_id,
@@ -321,8 +321,8 @@ void PIOS_Board_Init(void)
             if (PIOS_USB_CDC_Init(&pios_usb_cdc_id, &pios_usb_cdc_cfg, pios_usb_id)) {
                 PIOS_Assert(0);
             }
-            uint8_t *rx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_BRIDGE_RX_BUF_LEN);
+            uint8_t *rx_buffer = (uint8_t *)pios_malloc(PIOS_COM_BRIDGE_RX_BUF_LEN);
-            uint8_t *tx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_BRIDGE_TX_BUF_LEN);
+            uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_BRIDGE_TX_BUF_LEN);
             PIOS_Assert(rx_buffer);
             PIOS_Assert(tx_buffer);
             if (PIOS_COM_Init(&pios_com_vcp_id, &pios_usb_cdc_com_driver, pios_usb_cdc_id,
@@ -341,7 +341,7 @@ void PIOS_Board_Init(void)
             if (PIOS_USB_CDC_Init(&pios_usb_cdc_id, &pios_usb_cdc_cfg, pios_usb_id)) {
                 PIOS_Assert(0);
             }
-            uint8_t *tx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_DEBUGCONSOLE_TX_BUF_LEN);
+            uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_DEBUGCONSOLE_TX_BUF_LEN);
             PIOS_Assert(tx_buffer);
             if (PIOS_COM_Init(&pios_com_debug_id, &pios_usb_cdc_com_driver, pios_usb_cdc_id,
                               NULL, 0,
@@ -375,8 +375,8 @@ void PIOS_Board_Init(void)
             if (PIOS_USB_HID_Init(&pios_usb_hid_id, &pios_usb_hid_cfg, pios_usb_id)) {
                 PIOS_Assert(0);
             }
-            uint8_t *rx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_TELEM_USB_RX_BUF_LEN);
+            uint8_t *rx_buffer = (uint8_t *)pios_malloc(PIOS_COM_TELEM_USB_RX_BUF_LEN);
-            uint8_t *tx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_TELEM_USB_TX_BUF_LEN);
+            uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_TELEM_USB_TX_BUF_LEN);
             PIOS_Assert(rx_buffer);
             PIOS_Assert(tx_buffer);
             if (PIOS_COM_Init(&pios_com_telem_usb_id, &pios_usb_hid_com_driver, pios_usb_hid_id,
@@ -419,8 +419,8 @@ void PIOS_Board_Init(void)
                 PIOS_Assert(0);
             }
 
-            uint8_t *rx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_TELEM_RF_RX_BUF_LEN);
+            uint8_t *rx_buffer = (uint8_t *)pios_malloc(PIOS_COM_TELEM_RF_RX_BUF_LEN);
-            uint8_t *tx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_TELEM_RF_TX_BUF_LEN);
+            uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_TELEM_RF_TX_BUF_LEN);
             PIOS_Assert(rx_buffer);
             PIOS_Assert(tx_buffer);
             if (PIOS_COM_Init(&pios_com_telem_rf_id, &pios_usart_com_driver, pios_usart_generic_id,
@@ -460,7 +460,7 @@ void PIOS_Board_Init(void)
                 PIOS_Assert(0);
             }
 
-            uint8_t *rx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_GPS_RX_BUF_LEN);
+            uint8_t *rx_buffer = (uint8_t *)pios_malloc(PIOS_COM_GPS_RX_BUF_LEN);
             PIOS_Assert(rx_buffer);
             if (PIOS_COM_Init(&pios_com_gps_id, &pios_usart_com_driver, pios_usart_generic_id,
                               rx_buffer, PIOS_COM_GPS_RX_BUF_LEN,
@@ -522,7 +522,7 @@ void PIOS_Board_Init(void)
                 PIOS_Assert(0);
             }
 
-            uint8_t *tx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_DEBUGCONSOLE_TX_BUF_LEN);
+            uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_DEBUGCONSOLE_TX_BUF_LEN);
             PIOS_Assert(tx_buffer);
             if (PIOS_COM_Init(&pios_com_debug_id, &pios_usart_com_driver, pios_usart_generic_id,
                               NULL, 0,
@@ -540,9 +540,9 @@ void PIOS_Board_Init(void)
             PIOS_Assert(0);
         }
 
-        uint8_t *rx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_BRIDGE_RX_BUF_LEN);
+        uint8_t *rx_buffer = (uint8_t *)pios_malloc(PIOS_COM_BRIDGE_RX_BUF_LEN);
         PIOS_Assert(rx_buffer);
-        uint8_t *tx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_BRIDGE_TX_BUF_LEN);
+        uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_BRIDGE_TX_BUF_LEN);
         PIOS_Assert(tx_buffer);
         if (PIOS_COM_Init(&pios_com_bridge_id, &pios_usart_com_driver, pios_usart_generic_id,
                           rx_buffer, PIOS_COM_BRIDGE_RX_BUF_LEN,
@@ -558,7 +558,7 @@ void PIOS_Board_Init(void)
             PIOS_Assert(0);
         }
 
-        uint8_t *tx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_HKOSD_TX_BUF_LEN);
+        uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_HKOSD_TX_BUF_LEN);
         PIOS_Assert(tx_buffer);
         if (PIOS_COM_Init(&pios_com_hkosd_id, &pios_usart_com_driver, pios_usart_hkosd_id,
                           NULL, 0,
@@ -583,8 +583,8 @@ void PIOS_Board_Init(void)
             if (PIOS_USART_Init(&pios_usart_generic_id, &pios_usart_generic_flexi_cfg)) {
                 PIOS_Assert(0);
             }
-            uint8_t *rx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_TELEM_RF_RX_BUF_LEN);
+            uint8_t *rx_buffer = (uint8_t *)pios_malloc(PIOS_COM_TELEM_RF_RX_BUF_LEN);
-            uint8_t *tx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_TELEM_RF_TX_BUF_LEN);
+            uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_TELEM_RF_TX_BUF_LEN);
             PIOS_Assert(rx_buffer);
             PIOS_Assert(tx_buffer);
             if (PIOS_COM_Init(&pios_com_telem_rf_id, &pios_usart_com_driver, pios_usart_generic_id,
@@ -602,8 +602,8 @@ void PIOS_Board_Init(void)
             PIOS_Assert(0);
         }
 
-        uint8_t *rx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_BRIDGE_RX_BUF_LEN);
+        uint8_t *rx_buffer = (uint8_t *)pios_malloc(PIOS_COM_BRIDGE_RX_BUF_LEN);
-        uint8_t *tx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_BRIDGE_TX_BUF_LEN);
+        uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_BRIDGE_TX_BUF_LEN);
         PIOS_Assert(rx_buffer);
         PIOS_Assert(tx_buffer);
         if (PIOS_COM_Init(&pios_com_bridge_id, &pios_usart_com_driver, pios_usart_generic_id,
@@ -620,7 +620,7 @@ void PIOS_Board_Init(void)
             if (PIOS_USART_Init(&pios_usart_generic_id, &pios_usart_generic_flexi_cfg)) {
                 PIOS_Assert(0);
             }
-            uint8_t *rx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_GPS_RX_BUF_LEN);
+            uint8_t *rx_buffer = (uint8_t *)pios_malloc(PIOS_COM_GPS_RX_BUF_LEN);
             PIOS_Assert(rx_buffer);
             if (PIOS_COM_Init(&pios_com_gps_id, &pios_usart_com_driver, pios_usart_generic_id,
                               rx_buffer, PIOS_COM_GPS_RX_BUF_LEN,
@@ -696,7 +696,7 @@ void PIOS_Board_Init(void)
                 PIOS_Assert(0);
             }
 
-            uint8_t *tx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_DEBUGCONSOLE_TX_BUF_LEN);
+            uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_DEBUGCONSOLE_TX_BUF_LEN);
             PIOS_Assert(tx_buffer);
             if (PIOS_COM_Init(&pios_com_debug_id, &pios_usart_com_driver, pios_usart_generic_id,
                               NULL, 0,
@@ -723,7 +723,7 @@ void PIOS_Board_Init(void)
             PIOS_Assert(0);
         }
 
-        uint8_t *tx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_HKOSD_TX_BUF_LEN);
+        uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_HKOSD_TX_BUF_LEN);
         PIOS_Assert(tx_buffer);
         if (PIOS_COM_Init(&pios_com_hkosd_id, &pios_usart_com_driver, pios_usart_hkosd_id,
                           NULL, 0,

flight/targets/boards/discoveryf4bare/firmware/pios_board.c

@@ -249,10 +249,10 @@ static void PIOS_Board_configure_com(const struct pios_usart_cfg *usart_port_cfg
         PIOS_Assert(0);
     }
 
-    uint8_t *rx_buffer = (uint8_t *)pvPortMalloc(rx_buf_len);
+    uint8_t *rx_buffer = (uint8_t *)pios_malloc(rx_buf_len);
     PIOS_Assert(rx_buffer);
     if (tx_buf_len != (size_t)-1) { // this is the case for rx/tx ports
-        uint8_t *tx_buffer = (uint8_t *)pvPortMalloc(tx_buf_len);
+        uint8_t *tx_buffer = (uint8_t *)pios_malloc(tx_buf_len);
         PIOS_Assert(tx_buffer);
 
         if (PIOS_COM_Init(pios_com_id, com_driver, pios_usart_id,
@@ -483,8 +483,8 @@ void PIOS_Board_Init(void)
     case HWSETTINGS_USB_VCPPORT_USBTELEMETRY:
 #if defined(PIOS_INCLUDE_COM)
         {
-            uint8_t *rx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_TELEM_USB_RX_BUF_LEN);
+            uint8_t *rx_buffer = (uint8_t *)pios_malloc(PIOS_COM_TELEM_USB_RX_BUF_LEN);
-            uint8_t *tx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_TELEM_USB_TX_BUF_LEN);
+            uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_TELEM_USB_TX_BUF_LEN);
             PIOS_Assert(rx_buffer);
             PIOS_Assert(tx_buffer);
             if (PIOS_COM_Init(&pios_com_telem_usb_id, &pios_usb_cdc_com_driver, pios_usb_cdc_id,
@@ -498,8 +498,8 @@ void PIOS_Board_Init(void)
     case HWSETTINGS_USB_VCPPORT_COMBRIDGE:
 #if defined(PIOS_INCLUDE_COM)
         {
-            uint8_t *rx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_BRIDGE_RX_BUF_LEN);
+            uint8_t *rx_buffer = (uint8_t *)pios_malloc(PIOS_COM_BRIDGE_RX_BUF_LEN);
-            uint8_t *tx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_BRIDGE_TX_BUF_LEN);
+            uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_BRIDGE_TX_BUF_LEN);
             PIOS_Assert(rx_buffer);
             PIOS_Assert(tx_buffer);
             if (PIOS_COM_Init(&pios_com_vcp_id, &pios_usb_cdc_com_driver, pios_usb_cdc_id,
@@ -514,7 +514,7 @@ void PIOS_Board_Init(void)
 #if defined(PIOS_INCLUDE_COM)
 #if defined(PIOS_INCLUDE_DEBUG_CONSOLE)
         {
-            uint8_t *tx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_DEBUGCONSOLE_TX_BUF_LEN);
+            uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_DEBUGCONSOLE_TX_BUF_LEN);
             PIOS_Assert(tx_buffer);
             if (PIOS_COM_Init(&pios_com_debug_id, &pios_usb_cdc_com_driver, pios_usb_cdc_id,
                               NULL, 0,
@@ -545,8 +545,8 @@ void PIOS_Board_Init(void)
     case HWSETTINGS_USB_HIDPORT_USBTELEMETRY:
 #if defined(PIOS_INCLUDE_COM)
         {
-            uint8_t *rx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_TELEM_USB_RX_BUF_LEN);
+            uint8_t *rx_buffer = (uint8_t *)pios_malloc(PIOS_COM_TELEM_USB_RX_BUF_LEN);
-            uint8_t *tx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_TELEM_USB_TX_BUF_LEN);
+            uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_TELEM_USB_TX_BUF_LEN);
             PIOS_Assert(rx_buffer);
             PIOS_Assert(tx_buffer);
             if (PIOS_COM_Init(&pios_com_telem_usb_id, &pios_usb_hid_com_driver, pios_usb_hid_id,
@@ -740,8 +740,8 @@ void PIOS_Board_Init(void)
         }
 
         /* Configure the radio com interface */
-        uint8_t *rx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_RFM22B_RF_RX_BUF_LEN);
+        uint8_t *rx_buffer = (uint8_t *)pios_malloc(PIOS_COM_RFM22B_RF_RX_BUF_LEN);
-        uint8_t *tx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_RFM22B_RF_TX_BUF_LEN);
+        uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_RFM22B_RF_TX_BUF_LEN);
         PIOS_Assert(rx_buffer);
         PIOS_Assert(tx_buffer);
         if (PIOS_COM_Init(&pios_com_telem_rf_id, &pios_rfm22b_com_driver, pios_rfm22b_id,

flight/targets/boards/oplinkmini/firmware/pios_board.c

@@ -185,8 +185,8 @@ void PIOS_Board_Init(void)
         if (PIOS_USB_HID_Init(&pios_usb_hid_id, &pios_usb_hid_cfg, pios_usb_id)) {
             PIOS_Assert(0);
         }
-        uint8_t *rx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_TELEM_USB_RX_BUF_LEN);
+        uint8_t *rx_buffer = (uint8_t *)pios_malloc(PIOS_COM_TELEM_USB_RX_BUF_LEN);
-        uint8_t *tx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_TELEM_USB_TX_BUF_LEN);
+        uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_TELEM_USB_TX_BUF_LEN);
         PIOS_Assert(rx_buffer);
         PIOS_Assert(tx_buffer);
         if (PIOS_COM_Init(&pios_com_telem_usb_id, &pios_usb_hid_com_driver, pios_usb_hid_id,
@@ -203,8 +203,8 @@ void PIOS_Board_Init(void)
         if (PIOS_USB_CDC_Init(&pios_usb_cdc_id, &pios_usb_cdc_cfg, pios_usb_id)) {
             PIOS_Assert(0);
         }
-        uint8_t *rx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_TELEM_VCP_RX_BUF_LEN);
+        uint8_t *rx_buffer = (uint8_t *)pios_malloc(PIOS_COM_TELEM_VCP_RX_BUF_LEN);
-        uint8_t *tx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_TELEM_VCP_TX_BUF_LEN);
+        uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_TELEM_VCP_TX_BUF_LEN);
         PIOS_Assert(rx_buffer);
         PIOS_Assert(tx_buffer);
         if (PIOS_COM_Init(&pios_com_telem_vcp_id, &pios_usb_cdc_com_driver, pios_usb_cdc_id,
@@ -216,8 +216,8 @@ void PIOS_Board_Init(void)
 #endif
 
     /* Allocate the uart buffers. */
-    pios_uart_rx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_TELEM_RX_BUF_LEN);
+    pios_uart_rx_buffer = (uint8_t *)pios_malloc(PIOS_COM_TELEM_RX_BUF_LEN);
-    pios_uart_tx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_TELEM_TX_BUF_LEN);
+    pios_uart_tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_TELEM_TX_BUF_LEN);
 
     // Configure the main port
     OPLinkSettingsData oplinkSettings;
@@ -372,8 +372,8 @@ void PIOS_Board_Init(void)
         }
 
         // Configure the radio com interface
-        uint8_t *rx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_RFM22B_RF_RX_BUF_LEN);
+        uint8_t *rx_buffer = (uint8_t *)pios_malloc(PIOS_COM_RFM22B_RF_RX_BUF_LEN);
-        uint8_t *tx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_RFM22B_RF_TX_BUF_LEN);
+        uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_RFM22B_RF_TX_BUF_LEN);
         PIOS_Assert(rx_buffer);
         PIOS_Assert(tx_buffer);
         if (PIOS_COM_Init(&pios_com_rfm22b_id, &pios_rfm22b_com_driver, pios_rfm22b_id,

flight/targets/boards/osd/firmware/pios_board.c

@@ -260,8 +260,8 @@ void PIOS_Board_Init(void)
             if (PIOS_USB_CDC_Init(&pios_usb_cdc_id, &pios_usb_cdc_cfg, pios_usb_id)) {
                 PIOS_Assert(0);
             }
-            uint8_t *rx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_TELEM_USB_RX_BUF_LEN);
+            uint8_t *rx_buffer = (uint8_t *)pios_malloc(PIOS_COM_TELEM_USB_RX_BUF_LEN);
-            uint8_t *tx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_TELEM_USB_TX_BUF_LEN);
+            uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_TELEM_USB_TX_BUF_LEN);
             PIOS_Assert(rx_buffer);
             PIOS_Assert(tx_buffer);
             if (PIOS_COM_Init(&pios_com_telem_usb_id, &pios_usb_cdc_com_driver, pios_usb_cdc_id,
@@ -279,8 +279,8 @@ void PIOS_Board_Init(void)
             if (PIOS_USB_CDC_Init(&pios_usb_cdc_id, &pios_usb_cdc_cfg, pios_usb_id)) {
                 PIOS_Assert(0);
             }
-            uint8_t *rx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_BRIDGE_RX_BUF_LEN);
+            uint8_t *rx_buffer = (uint8_t *)pios_malloc(PIOS_COM_BRIDGE_RX_BUF_LEN);
-            uint8_t *tx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_BRIDGE_TX_BUF_LEN);
+            uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_BRIDGE_TX_BUF_LEN);
             PIOS_Assert(rx_buffer);
             PIOS_Assert(tx_buffer);
             if (PIOS_COM_Init(&pios_com_vcp_id, &pios_usb_cdc_com_driver, pios_usb_cdc_id,
@@ -314,8 +314,8 @@ void PIOS_Board_Init(void)
             if (PIOS_USB_HID_Init(&pios_usb_hid_id, &pios_usb_hid_cfg, pios_usb_id)) {
                 PIOS_Assert(0);
             }
-            uint8_t *rx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_TELEM_USB_RX_BUF_LEN);
+            uint8_t *rx_buffer = (uint8_t *)pios_malloc(PIOS_COM_TELEM_USB_RX_BUF_LEN);
-            uint8_t *tx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_TELEM_USB_TX_BUF_LEN);
+            uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_TELEM_USB_TX_BUF_LEN);
             PIOS_Assert(rx_buffer);
             PIOS_Assert(tx_buffer);
             if (PIOS_COM_Init(&pios_com_telem_usb_id, &pios_usb_hid_com_driver, pios_usb_hid_id,
@@ -343,7 +343,7 @@ void PIOS_Board_Init(void)
         PIOS_Assert(0);
     }
 
-    uint8_t *gps_rx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_GPS_RX_BUF_LEN);
+    uint8_t *gps_rx_buffer = (uint8_t *)pios_malloc(PIOS_COM_GPS_RX_BUF_LEN);
     PIOS_Assert(gps_rx_buffer);
     if (PIOS_COM_Init(&pios_com_gps_id, &pios_usart_com_driver, pios_usart_gps_id,
                       gps_rx_buffer, PIOS_COM_GPS_RX_BUF_LEN,
@@ -361,8 +361,8 @@ void PIOS_Board_Init(void)
             PIOS_DEBUG_Assert(0);
         }
 
-        uint8_t *aux_rx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_AUX_RX_BUF_LEN);
+        uint8_t *aux_rx_buffer = (uint8_t *)pios_malloc(PIOS_COM_AUX_RX_BUF_LEN);
-        uint8_t *aux_tx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_AUX_TX_BUF_LEN);
+        uint8_t *aux_tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_AUX_TX_BUF_LEN);
         PIOS_Assert(aux_rx_buffer);
         PIOS_Assert(aux_tx_buffer);
 
@@ -383,8 +383,8 @@ void PIOS_Board_Init(void)
             PIOS_Assert(0);
         }
 
-        uint8_t *telem_rx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_TELEM_RF_RX_BUF_LEN);
+        uint8_t *telem_rx_buffer = (uint8_t *)pios_malloc(PIOS_COM_TELEM_RF_RX_BUF_LEN);
-        uint8_t *telem_tx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_TELEM_RF_TX_BUF_LEN);
+        uint8_t *telem_tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_TELEM_RF_TX_BUF_LEN);
         PIOS_Assert(telem_rx_buffer);
         PIOS_Assert(telem_tx_buffer);
         if (PIOS_COM_Init(&pios_com_telem_rf_id, &pios_usart_com_driver, pios_usart_telem_rf_id,

flight/targets/boards/revolution/firmware/pios_board.c

@@ -251,10 +251,10 @@ static void PIOS_Board_configure_com(const struct pios_usart_cfg *usart_port_cfg
         PIOS_Assert(0);
     }
 
-    uint8_t *rx_buffer = (uint8_t *)pvPortMalloc(rx_buf_len);
+    uint8_t *rx_buffer = (uint8_t *)pios_malloc(rx_buf_len);
     PIOS_Assert(rx_buffer);
     if (tx_buf_len != (size_t)-1) { // this is the case for rx/tx ports
-        uint8_t *tx_buffer = (uint8_t *)pvPortMalloc(tx_buf_len);
+        uint8_t *tx_buffer = (uint8_t *)pios_malloc(tx_buf_len);
         PIOS_Assert(tx_buffer);
 
         if (PIOS_COM_Init(pios_com_id, com_driver, pios_usart_id,
@@ -494,8 +494,8 @@ void PIOS_Board_Init(void)
     case HWSETTINGS_USB_VCPPORT_USBTELEMETRY:
 #if defined(PIOS_INCLUDE_COM)
         {
-            uint8_t *rx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_TELEM_USB_RX_BUF_LEN);
+            uint8_t *rx_buffer = (uint8_t *)pios_malloc(PIOS_COM_TELEM_USB_RX_BUF_LEN);
-            uint8_t *tx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_TELEM_USB_TX_BUF_LEN);
+            uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_TELEM_USB_TX_BUF_LEN);
             PIOS_Assert(rx_buffer);
             PIOS_Assert(tx_buffer);
             if (PIOS_COM_Init(&pios_com_telem_usb_id, &pios_usb_cdc_com_driver, pios_usb_cdc_id,
@@ -509,8 +509,8 @@ void PIOS_Board_Init(void)
     case HWSETTINGS_USB_VCPPORT_COMBRIDGE:
 #if defined(PIOS_INCLUDE_COM)
         {
-            uint8_t *rx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_BRIDGE_RX_BUF_LEN);
+            uint8_t *rx_buffer = (uint8_t *)pios_malloc(PIOS_COM_BRIDGE_RX_BUF_LEN);
-            uint8_t *tx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_BRIDGE_TX_BUF_LEN);
+            uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_BRIDGE_TX_BUF_LEN);
             PIOS_Assert(rx_buffer);
             PIOS_Assert(tx_buffer);
             if (PIOS_COM_Init(&pios_com_vcp_id, &pios_usb_cdc_com_driver, pios_usb_cdc_id,
@@ -525,7 +525,7 @@ void PIOS_Board_Init(void)
 #if defined(PIOS_INCLUDE_COM)
 #if defined(PIOS_INCLUDE_DEBUG_CONSOLE)
         {
-            uint8_t *tx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_DEBUGCONSOLE_TX_BUF_LEN);
+            uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_DEBUGCONSOLE_TX_BUF_LEN);
             PIOS_Assert(tx_buffer);
             if (PIOS_COM_Init(&pios_com_debug_id, &pios_usb_cdc_com_driver, pios_usb_cdc_id,
                               NULL, 0,
@@ -556,8 +556,8 @@ void PIOS_Board_Init(void)
     case HWSETTINGS_USB_HIDPORT_USBTELEMETRY:
 #if defined(PIOS_INCLUDE_COM)
         {
-            uint8_t *rx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_TELEM_USB_RX_BUF_LEN);
+            uint8_t *rx_buffer = (uint8_t *)pios_malloc(PIOS_COM_TELEM_USB_RX_BUF_LEN);
-            uint8_t *tx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_TELEM_USB_TX_BUF_LEN);
+            uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_TELEM_USB_TX_BUF_LEN);
             PIOS_Assert(rx_buffer);
             PIOS_Assert(tx_buffer);
             if (PIOS_COM_Init(&pios_com_telem_usb_id, &pios_usb_hid_com_driver, pios_usb_hid_id,
@@ -751,8 +751,8 @@ void PIOS_Board_Init(void)
         }
 
         /* Configure the radio com interface */
-        uint8_t *rx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_RFM22B_RF_RX_BUF_LEN);
+        uint8_t *rx_buffer = (uint8_t *)pios_malloc(PIOS_COM_RFM22B_RF_RX_BUF_LEN);
-        uint8_t *tx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_RFM22B_RF_TX_BUF_LEN);
+        uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_RFM22B_RF_TX_BUF_LEN);
         PIOS_Assert(rx_buffer);
         PIOS_Assert(tx_buffer);
         if (PIOS_COM_Init(&pios_com_rf_id, &pios_rfm22b_com_driver, pios_rfm22b_id,

flight/targets/boards/revoproto/firmware/pios_board.c

@@ -321,10 +321,10 @@ static void PIOS_Board_configure_com(const struct pios_usart_cfg *usart_port_cfg
         PIOS_Assert(0);
     }
 
-    uint8_t *rx_buffer = (uint8_t *)pvPortMalloc(rx_buf_len);
+    uint8_t *rx_buffer = (uint8_t *)pios_malloc(rx_buf_len);
     PIOS_Assert(rx_buffer);
     if (tx_buf_len != (size_t)-1) { // this is the case for rx/tx ports
-        uint8_t *tx_buffer = (uint8_t *)pvPortMalloc(tx_buf_len);
+        uint8_t *tx_buffer = (uint8_t *)pios_malloc(tx_buf_len);
         PIOS_Assert(tx_buffer);
 
         if (PIOS_COM_Init(pios_com_id, com_driver, pios_usart_id,
@@ -529,8 +529,8 @@ void PIOS_Board_Init(void)
     case HWSETTINGS_USB_VCPPORT_USBTELEMETRY:
 #if defined(PIOS_INCLUDE_COM)
         {
-            uint8_t *rx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_TELEM_USB_RX_BUF_LEN);
+            uint8_t *rx_buffer = (uint8_t *)pios_malloc(PIOS_COM_TELEM_USB_RX_BUF_LEN);
-            uint8_t *tx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_TELEM_USB_TX_BUF_LEN);
+            uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_TELEM_USB_TX_BUF_LEN);
             PIOS_Assert(rx_buffer);
             PIOS_Assert(tx_buffer);
             if (PIOS_COM_Init(&pios_com_telem_usb_id, &pios_usb_cdc_com_driver, pios_usb_cdc_id,
@@ -544,8 +544,8 @@ void PIOS_Board_Init(void)
     case HWSETTINGS_USB_VCPPORT_COMBRIDGE:
 #if defined(PIOS_INCLUDE_COM)
         {
-            uint8_t *rx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_BRIDGE_RX_BUF_LEN);
+            uint8_t *rx_buffer = (uint8_t *)pios_malloc(PIOS_COM_BRIDGE_RX_BUF_LEN);
-            uint8_t *tx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_BRIDGE_TX_BUF_LEN);
+            uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_BRIDGE_TX_BUF_LEN);
             PIOS_Assert(rx_buffer);
             PIOS_Assert(tx_buffer);
             if (PIOS_COM_Init(&pios_com_vcp_id, &pios_usb_cdc_com_driver, pios_usb_cdc_id,
@@ -560,7 +560,7 @@ void PIOS_Board_Init(void)
 #if defined(PIOS_INCLUDE_COM)
 #if defined(PIOS_INCLUDE_DEBUG_CONSOLE)
         {
-            uint8_t *tx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_DEBUGCONSOLE_TX_BUF_LEN);
+            uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_DEBUGCONSOLE_TX_BUF_LEN);
             PIOS_Assert(tx_buffer);
             if (PIOS_COM_Init(&pios_com_debug_id, &pios_usb_cdc_com_driver, pios_usb_cdc_id,
                               NULL, 0,
@@ -591,8 +591,8 @@ void PIOS_Board_Init(void)
     case HWSETTINGS_USB_HIDPORT_USBTELEMETRY:
 #if defined(PIOS_INCLUDE_COM)
         {
-            uint8_t *rx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_TELEM_USB_RX_BUF_LEN);
+            uint8_t *rx_buffer = (uint8_t *)pios_malloc(PIOS_COM_TELEM_USB_RX_BUF_LEN);
-            uint8_t *tx_buffer = (uint8_t *)pvPortMalloc(PIOS_COM_TELEM_USB_TX_BUF_LEN);
+            uint8_t *tx_buffer = (uint8_t *)pios_malloc(PIOS_COM_TELEM_USB_TX_BUF_LEN);
             PIOS_Assert(rx_buffer);
             PIOS_Assert(tx_buffer);
             if (PIOS_COM_Init(&pios_com_telem_usb_id, &pios_usb_hid_com_driver, pios_usb_hid_id,
@@ -871,8 +871,8 @@ void PIOS_Board_Init(void)
                 PIOS_DEBUG_Assert(0);
             }
             const uint32_t PACKET_SIZE = 1024;
-            uint8_t *rx_buffer = (uint8_t *)pvPortMalloc(PACKET_SIZE);
+            uint8_t *rx_buffer = (uint8_t *)pios_malloc(PACKET_SIZE);
-            uint8_t *tx_buffer = (uint8_t *)pvPortMalloc(PACKET_SIZE);
+            uint8_t *tx_buffer = (uint8_t *)pios_malloc(PACKET_SIZE);
             PIOS_Assert(rx_buffer);
             PIOS_Assert(tx_buffer);
             if (PIOS_COM_Init(&pios_com_overo_id, &pios_overo_com_driver, pios_overo_id,

flight/uavobjects/eventdispatcher.c

@@ -228,7 +228,7 @@ static int32_t eventPeriodicCreate(UAVObjEvent *ev, UAVObjEventCallback cb, xQue
         }
     }
     // Create handle
-    objEntry = (PeriodicObjectList *)pvPortMalloc(sizeof(PeriodicObjectList));
+    objEntry = (PeriodicObjectList *)pios_malloc(sizeof(PeriodicObjectList));
     if (objEntry == NULL) {
         return -1;
     }

flight/uavobjects/uavobjectmanager.c

@@ -278,7 +278,7 @@ static struct UAVOData *UAVObjAllocSingle(uint32_t num_bytes)
     uint32_t object_size = sizeof(struct UAVOSingle) + num_bytes;
 
     /* Allocate the object from the heap */
-    struct UAVOSingle *uavo_single = (struct UAVOSingle *)pvPortMalloc(object_size);
+    struct UAVOSingle *uavo_single = (struct UAVOSingle *)pios_malloc(object_size);
 
     if (!uavo_single) {
         return NULL;
@@ -303,7 +303,7 @@ static struct UAVOData *UAVObjAllocMulti(uint32_t num_bytes)
     uint32_t object_size = sizeof(struct UAVOMulti) + num_bytes;
 
     /* Allocate the object from the heap */
-    struct UAVOMulti *uavo_multi = (struct UAVOMulti *)pvPortMalloc(object_size);
+    struct UAVOMulti *uavo_multi = (struct UAVOMulti *)pios_malloc(object_size);
 
     if (!uavo_multi) {
         return NULL;
@@ -1802,7 +1802,7 @@ static InstanceHandle createInstance(struct UAVOData *obj, uint16_t instId)
 
     /* Create the actual instance */
     uint32_t size = sizeof(struct UAVOMultiInst) + obj->instance_size;
-    instEntry = (struct UAVOMultiInst *)pvPortMalloc(size);
+    instEntry = (struct UAVOMultiInst *)pios_malloc(size);
     if (!instEntry) {
         return NULL;
     }
@@ -1890,7 +1890,7 @@ static int32_t connectObj(UAVObjHandle obj_handle, xQueueHandle queue,
     }
 
     // Add queue to list
-    event = (struct ObjectEventEntry *)pvPortMalloc(sizeof(struct ObjectEventEntry));
+    event = (struct ObjectEventEntry *)pios_malloc(sizeof(struct ObjectEventEntry));
     if (event == NULL) {
         return -1;
     }

flight/uavtalk/uavtalk.c

@@ -64,7 +64,7 @@ static void updateAck(UAVTalkConnectionData *connection, uint8_t type, uint32_t
 UAVTalkConnection UAVTalkInitialize(UAVTalkOutputStream outputStream)
 {
     // allocate object
-    UAVTalkConnectionData *connection = pvPortMalloc(sizeof(UAVTalkConnectionData));
+    UAVTalkConnectionData *connection = pios_malloc(sizeof(UAVTalkConnectionData));
 
     if (!connection) {
         return 0;
@@ -76,11 +76,11 @@ UAVTalkConnection UAVTalkInitialize(UAVTalkOutputStream outputStream)
     connection->lock = xSemaphoreCreateRecursiveMutex();
     connection->transLock   = xSemaphoreCreateRecursiveMutex();
     // allocate buffers
-    connection->rxBuffer    = pvPortMalloc(UAVTALK_MAX_PACKET_LENGTH);
+    connection->rxBuffer    = pios_malloc(UAVTALK_MAX_PACKET_LENGTH);
     if (!connection->rxBuffer) {
         return 0;
     }
-    connection->txBuffer = pvPortMalloc(UAVTALK_MAX_PACKET_LENGTH);
+    connection->txBuffer = pios_malloc(UAVTALK_MAX_PACKET_LENGTH);
     if (!connection->txBuffer) {
         return 0;
     }