Replaced heap_caps_malloc/free with malloc/free.

salal-m · salal-m · commit 8e08fabc8374 · 2020-05-08T21:06:46.000+05:00
diff --git a/esp32/fatfs/src/drivers/sflash_diskio.c b/esp32/fatfs/src/drivers/sflash_diskio.c
@@ -54,7 +54,7 @@ DRESULT sflash_disk_init (void) {
             sflash_start_address = SFLASH_START_ADDR_4MB;
             sflash_fs_sector_count = SFLASH_FS_SECTOR_COUNT_4MB;
         }
-        sflash_block_cache = (uint8_t *)heap_caps_malloc(SFLASH_BLOCK_SIZE, MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT);
+        sflash_block_cache = (uint8_t *)malloc(SFLASH_BLOCK_SIZE);
         sflash_prev_block_addr = UINT32_MAX;
         sflash_cache_is_dirty = false;
         sflash_init_done = true;
diff --git a/esp32/ftp/ftp.c b/esp32/ftp/ftp.c
@@ -614,10 +614,10 @@ static void ftp_return_to_previous_path (char *pwd, char *dir);
  ******************************************************************************/
 void ftp_init (void) {
     // allocate memory for the data buffer, and the file system structs (from the RTOS heap)
-    ftp_data.dBuffer = heap_caps_malloc(FTP_BUFFER_SIZE, MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT);
-    ftp_path = heap_caps_malloc(FTP_MAX_PARAM_SIZE, MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT);
-    ftp_scratch_buffer = heap_caps_malloc(FTP_MAX_PARAM_SIZE, MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT);
-    ftp_cmd_buffer = heap_caps_malloc(FTP_MAX_PARAM_SIZE + FTP_CMD_SIZE_MAX, MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT);
+    ftp_data.dBuffer = malloc(FTP_BUFFER_SIZE);
+    ftp_path = malloc(FTP_MAX_PARAM_SIZE);
+    ftp_scratch_buffer = malloc(FTP_MAX_PARAM_SIZE);
+    ftp_cmd_buffer = malloc(FTP_MAX_PARAM_SIZE + FTP_CMD_SIZE_MAX);
     SOCKETFIFO_Init (&ftp_socketfifo, (void *)ftp_fifoelements, FTP_SOCKETFIFO_ELEMENTS_MAX);
     ftp_data.c_sd  = -1;
     ftp_data.d_sd  = -1;
diff --git a/esp32/lte/lteppp.c b/esp32/lte/lteppp.c
@@ -159,7 +159,7 @@ void lteppp_init(void) {
 
     lteppp_connstatus = LTE_PPP_IDLE;
 #ifdef LTE_DEBUG_BUFF
-    lteppp_log.log = heap_caps_malloc(LTE_LOG_BUFF_SIZE, MALLOC_CAP_SPIRAM);
+    lteppp_log.log = malloc(LTE_LOG_BUFF_SIZE);
 #endif
 }
 
diff --git a/esp32/main.c b/esp32/main.c
@@ -149,7 +149,7 @@ void app_main(void) {
         micropy_lpwan_dio_pin_num = 23;
         micropy_lpwan_dio_pin = &pin_GPIO23;
 
-        mpTaskStack = heap_caps_malloc(MICROPY_TASK_STACK_SIZE_PSRAM, MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT);
+        mpTaskStack = malloc(MICROPY_TASK_STACK_SIZE_PSRAM);
 
         // create the MicroPython task
         mpTaskHandle =
@@ -172,7 +172,7 @@ void app_main(void) {
         micropy_lpwan_dio_pin_num = 23;
         micropy_lpwan_dio_pin = &pin_GPIO23;
 
-        mpTaskStack = heap_caps_malloc(MICROPY_TASK_STACK_SIZE, MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT);
+        mpTaskStack = malloc(MICROPY_TASK_STACK_SIZE);
 
         // create the MicroPython task
         mpTaskHandle =
diff --git a/esp32/mods/modbt.c b/esp32/mods/modbt.c
@@ -500,7 +500,7 @@ static void remove_all_bonded_devices(void)
 {
     int dev_num = esp_ble_get_bond_device_num();
 
-    esp_ble_bond_dev_t *dev_list = heap_caps_malloc(sizeof(esp_ble_bond_dev_t) * dev_num, MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT);
+    esp_ble_bond_dev_t *dev_list = malloc(sizeof(esp_ble_bond_dev_t) * dev_num);
     esp_ble_get_bond_device_list(&dev_num, dev_list);
     for (int i = 0; i < dev_num; i++) {
         esp_ble_remove_bond_device(dev_list[i].bd_addr);
@@ -801,8 +801,8 @@ STATIC void gatts_char_callback_handler(void *arg) {
         tuple[1] = mp_const_none;
         if(((char_cbk_arg_t*)arg)->data_length > 0) {
             tuple[1] = mp_obj_new_bytes(((char_cbk_arg_t*)arg)->data, ((char_cbk_arg_t*)arg)->data_length);
-            heap_caps_free(((char_cbk_arg_t*)arg)->data);
-            heap_caps_free((char_cbk_arg_t*)arg);
+            free(((char_cbk_arg_t*)arg)->data);
+            free((char_cbk_arg_t*)arg);
         }
 
         mp_obj_t r_value = mp_call_function_2(chr->handler, chr->handler_arg, mp_obj_new_tuple(2, tuple));
@@ -865,7 +865,7 @@ static void gatts_event_handler(esp_gatts_cb_event_t event, esp_gatt_if_t gatts_
                     char_obj->read_request = true;
                     char_obj->trans_id = p->read.trans_id;
 
-                    char_cbk_arg_t *cbk_arg = heap_caps_malloc(sizeof(char_cbk_arg_t), MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT);
+                    char_cbk_arg_t *cbk_arg = malloc(sizeof(char_cbk_arg_t));
 
                     cbk_arg->chr = char_obj;
                     cbk_arg->event = MOD_BT_GATTS_READ_EVT;
@@ -900,12 +900,12 @@ static void gatts_event_handler(esp_gatts_cb_event_t event, esp_gatt_if_t gatts_
                     char_obj->events |= MOD_BT_GATTS_WRITE_EVT;
                     if (char_obj->trigger & MOD_BT_GATTS_WRITE_EVT) {
 
-                        char_cbk_arg_t *cbk_arg = heap_caps_malloc(sizeof(char_cbk_arg_t), MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT);
+                        char_cbk_arg_t *cbk_arg = malloc(sizeof(char_cbk_arg_t));
 
                         cbk_arg->chr = char_obj;
                         cbk_arg->event = MOD_BT_GATTS_WRITE_EVT;
                         cbk_arg->data_length = write_len;
-                        cbk_arg->data = heap_caps_malloc(cbk_arg->data_length, MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT);
+                        cbk_arg->data = malloc(cbk_arg->data_length);
                         memcpy(cbk_arg->data, p->write.value, cbk_arg->data_length);
 
                         mp_irq_queue_interrupt_non_ISR(gatts_char_callback_handler, cbk_arg);
@@ -918,7 +918,7 @@ static void gatts_event_handler(esp_gatts_cb_event_t event, esp_gatt_if_t gatts_
                         char_obj->events |= MOD_BT_GATTS_SUBSCRIBE_EVT;
                         if (char_obj->trigger & MOD_BT_GATTS_SUBSCRIBE_EVT) {
 
-                            char_cbk_arg_t *cbk_arg = heap_caps_malloc(sizeof(char_cbk_arg_t), MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT);
+                            char_cbk_arg_t *cbk_arg = malloc(sizeof(char_cbk_arg_t));
 
                             cbk_arg->chr = char_obj;
                             cbk_arg->event = MOD_BT_GATTS_SUBSCRIBE_EVT;
@@ -2344,7 +2344,7 @@ STATIC mp_obj_t bt_srv_characteristics(mp_obj_t self_in) {
                                      &attr_count);
 
         if (attr_count > 0) {
-            esp_gattc_char_elem_t *char_elems = (esp_gattc_char_elem_t *)heap_caps_malloc(sizeof(esp_gattc_char_elem_t) * attr_count, MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT);
+            esp_gattc_char_elem_t *char_elems = (esp_gattc_char_elem_t *)malloc(sizeof(esp_gattc_char_elem_t) * attr_count);
             if (!char_elems) {
                 mp_raise_OSError(MP_ENOMEM);
             } else {
@@ -2585,7 +2585,7 @@ STATIC mp_obj_t bt_char_callback(mp_uint_t n_args, const mp_obj_t *pos_args, mp_
                                          self->characteristic.char_handle,
                                          &attr_count);
             if (attr_count > 0) {
-                esp_gattc_descr_elem_t *descr_elems = (esp_gattc_descr_elem_t *)heap_caps_malloc(sizeof(esp_gattc_descr_elem_t) * attr_count, MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT);
+                esp_gattc_descr_elem_t *descr_elems = (esp_gattc_descr_elem_t *)malloc(sizeof(esp_gattc_descr_elem_t) * attr_count);
                 if (!descr_elems) {
                     mp_raise_OSError(MP_ENOMEM);
                 } else {
diff --git a/esp32/mods/moduqueue.c b/esp32/mods/moduqueue.c
@@ -45,7 +45,7 @@ STATIC mp_obj_t mod_uqueue_queue(mp_uint_t n_args, const mp_obj_t *pos_args, mp_
     mp_obj_queue_t *queue = m_new_obj_with_finaliser(mp_obj_queue_t);
 
     // allocate the queue storage and the queue buffer
-    queue->buffer = heap_caps_malloc(sizeof(StaticQueue_t), MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT);
+    queue->buffer = malloc(sizeof(StaticQueue_t));
     if (NULL == queue->buffer) {
         nlr_raise(mp_obj_new_exception_msg(&mp_type_MemoryError, "no memory available to create the queue"));
     }
diff --git a/esp32/mptask.c b/esp32/mptask.c
@@ -174,12 +174,12 @@ void TASK_Micropython (void *pvParameters) {
 
     if (esp32_get_chip_rev() > 0) {
         gc_pool_size = GC_POOL_SIZE_BYTES_PSRAM;
-        gc_pool_upy = heap_caps_malloc(GC_POOL_SIZE_BYTES_PSRAM, MALLOC_CAP_SPIRAM);
     } else {
         gc_pool_size = GC_POOL_SIZE_BYTES;
-        gc_pool_upy = heap_caps_malloc(GC_POOL_SIZE_BYTES, MALLOC_CAP_INTERNAL);
     }
 
+    gc_pool_upy = malloc(gc_pool_size);
+
     if (NULL == gc_pool_upy) {
         printf("GC pool malloc failed!\n");
         for ( ; ; );
diff --git a/esp32/mpthreadport.c b/esp32/mpthreadport.c
@@ -171,15 +171,15 @@ void mp_thread_create_ex(void *(*entry)(void*), void *arg, size_t *stack_size, i
     // allocate TCB, stack and linked-list node (must be outside thread_mutex lock)
     if (mp_chip_revision > 0) {
         // for revision 1 devices we allocate from the internal memory of the malloc heap
-        tcb = heap_caps_malloc(sizeof(StaticTask_t), MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT);
+        tcb = malloc(sizeof(StaticTask_t));
         if (!tcb) {
             goto memory_error;
         }
-        stack = heap_caps_malloc(*stack_size, MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT);
+        stack = malloc(*stack_size);
         if (!stack) {
             goto memory_error;
         }
-        th = heap_caps_malloc(sizeof(thread_t), MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT);
+        th = malloc(sizeof(thread_t));
         if (!th) {
             goto memory_error;
         }
diff --git a/esp32/telnet/telnet.c b/esp32/telnet/telnet.c
@@ -154,7 +154,7 @@ static void telnet_reset_buffer (void);
  ******************************************************************************/
 void telnet_init (void) {
     // allocate memory for the receive buffer (from the RTOS heap)
-    telnet_data.rxBuffer = heap_caps_malloc(TELNET_RX_BUFFER_SIZE, MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT);
+    telnet_data.rxBuffer = malloc(TELNET_RX_BUFFER_SIZE);
     telnet_data.state = E_TELNET_STE_DISABLED;
 }
 

Original file line number	Diff line number	Diff line change
`@@ -54,7 +54,7 @@ DRESULT sflash_disk_init (void) {`
`54`	`54`	`sflash_start_address = SFLASH_START_ADDR_4MB;`
`55`	`55`	`sflash_fs_sector_count = SFLASH_FS_SECTOR_COUNT_4MB;`
`56`	`56`	`}`
`57`		`- sflash_block_cache = (uint8_t *)heap_caps_malloc(SFLASH_BLOCK_SIZE, MALLOC_CAP_INTERNAL \| MALLOC_CAP_8BIT);`
	`57`	`+ sflash_block_cache = (uint8_t *)malloc(SFLASH_BLOCK_SIZE);`
`58`	`58`	`sflash_prev_block_addr = UINT32_MAX;`
`59`	`59`	`sflash_cache_is_dirty = false;`
`60`	`60`	`sflash_init_done = true;`
Original file line number	Diff line number	Diff line change
`@@ -159,7 +159,7 @@ void lteppp_init(void) {`
`159`	`159`
`160`	`160`	`lteppp_connstatus = LTE_PPP_IDLE;`
`161`	`161`	`#ifdef LTE_DEBUG_BUFF`
`162`		`- lteppp_log.log = heap_caps_malloc(LTE_LOG_BUFF_SIZE, MALLOC_CAP_SPIRAM);`
	`162`	`+ lteppp_log.log = malloc(LTE_LOG_BUFF_SIZE);`
`163`	`163`	`#endif`
`164`	`164`	`}`
`165`	`165`
Original file line number	Diff line number	Diff line change
`@@ -45,7 +45,7 @@ STATIC mp_obj_t mod_uqueue_queue(mp_uint_t n_args, const mp_obj_t *pos_args, mp_`
`45`	`45`	`mp_obj_queue_t *queue = m_new_obj_with_finaliser(mp_obj_queue_t);`
`46`	`46`
`47`	`47`	`// allocate the queue storage and the queue buffer`
`48`		`- queue->buffer = heap_caps_malloc(sizeof(StaticQueue_t), MALLOC_CAP_INTERNAL \| MALLOC_CAP_8BIT);`
	`48`	`+ queue->buffer = malloc(sizeof(StaticQueue_t));`
`49`	`49`	`if (NULL == queue->buffer) {`
`50`	`50`	`nlr_raise(mp_obj_new_exception_msg(&mp_type_MemoryError, "no memory available to create the queue"));`
`51`	`51`	`}`
Original file line number	Diff line number	Diff line change
`@@ -171,15 +171,15 @@ void mp_thread_create_ex(void (entry)(void), void arg, size_t *stack_size, i`
`171`	`171`	`// allocate TCB, stack and linked-list node (must be outside thread_mutex lock)`
`172`	`172`	`if (mp_chip_revision > 0) {`
`173`	`173`	`// for revision 1 devices we allocate from the internal memory of the malloc heap`
`174`		`- tcb = heap_caps_malloc(sizeof(StaticTask_t), MALLOC_CAP_INTERNAL \| MALLOC_CAP_8BIT);`
	`174`	`+ tcb = malloc(sizeof(StaticTask_t));`
`175`	`175`	`if (!tcb) {`
`176`	`176`	`goto memory_error;`
`177`	`177`	`}`
`178`		`- stack = heap_caps_malloc(*stack_size, MALLOC_CAP_INTERNAL \| MALLOC_CAP_8BIT);`
	`178`	`+ stack = malloc(*stack_size);`
`179`	`179`	`if (!stack) {`
`180`	`180`	`goto memory_error;`
`181`	`181`	`}`
`182`		`- th = heap_caps_malloc(sizeof(thread_t), MALLOC_CAP_INTERNAL \| MALLOC_CAP_8BIT);`
	`182`	`+ th = malloc(sizeof(thread_t));`
`183`	`183`	`if (!th) {`
`184`	`184`	`goto memory_error;`
`185`	`185`	`}`
Original file line number	Diff line number	Diff line change
`@@ -154,7 +154,7 @@ static void telnet_reset_buffer (void);`
`154`	`154`	`******************************************************************************/`
`155`	`155`	`void telnet_init (void) {`
`156`	`156`	`// allocate memory for the receive buffer (from the RTOS heap)`
`157`		`- telnet_data.rxBuffer = heap_caps_malloc(TELNET_RX_BUFFER_SIZE, MALLOC_CAP_INTERNAL \| MALLOC_CAP_8BIT);`
	`157`	`+ telnet_data.rxBuffer = malloc(TELNET_RX_BUFFER_SIZE);`
`158`	`158`	`telnet_data.state = E_TELNET_STE_DISABLED;`
`159`	`159`	`}`
`160`	`160`