int esp_apptrace_fseek(esp_apptrace_dest_t dest, void *stream, long offset, int whence) { esp_apptrace_fseek_args_t cmd_args; ESP_EARLY_LOGV(TAG, "esp_apptrace_fseek f %p o 0x%lx w %d", stream, offset, whence); cmd_args.file = stream; cmd_args.offset = offset; cmd_args.whence = whence; esp_err_t ret = esp_apptrace_file_cmd_send(dest, ESP_APPTRACE_FILE_CMD_FSEEK, esp_apptrace_fseek_args_prepare, &cmd_args, sizeof(cmd_args)); if (ret != ESP_OK) { ESP_EARLY_LOGE(TAG, "Failed to send file cmd (%d)!", ret); return -1; } // now read the answer int resp; ret = esp_apptrace_file_rsp_recv(dest, (uint8_t *)&resp, sizeof(resp)); if (ret != ESP_OK) { ESP_EARLY_LOGE(TAG, "Failed to read response (%d)!", ret); return -1; } return resp; }
static esp_err_t esp_apptrace_file_cmd_send(esp_apptrace_dest_t dest, uint8_t cmd, void (*prep_args)(uint8_t *, void *), void *args, uint32_t args_len) { esp_err_t ret; esp_apptrace_fcmd_hdr_t *hdr; ESP_EARLY_LOGV(TAG, "%s %d", __func__, cmd); uint8_t *ptr = esp_apptrace_buffer_get(dest, sizeof(*hdr) + args_len, ESP_APPTRACE_TMO_INFINITE); //TODO: finite tmo if (ptr == NULL) { return ESP_ERR_NO_MEM; } hdr = (esp_apptrace_fcmd_hdr_t *)ptr; hdr->cmd = cmd; if (prep_args) { prep_args(ptr + sizeof(hdr->cmd), args); } // now indicate that this buffer is ready to be sent off to host ret = esp_apptrace_buffer_put(dest, ptr, ESP_APPTRACE_TMO_INFINITE);//TODO: finite tmo if (ret != ESP_OK) { ESP_EARLY_LOGE(TAG, "Failed to put apptrace buffer (%d)!", ret); return ret; } ret = esp_apptrace_flush(dest, ESP_APPTRACE_TMO_INFINITE);//TODO: finite tmo if (ret != ESP_OK) { ESP_EARLY_LOGE(TAG, "Failed to flush apptrace buffer (%d)!", ret); return ret; } return ESP_OK; }
size_t esp_apptrace_fread(esp_apptrace_dest_t dest, void *ptr, size_t size, size_t nmemb, void *stream) { esp_apptrace_fread_args_t cmd_args; ESP_EARLY_LOGV(TAG, "esp_apptrace_fread f %p l %d", stream, size*nmemb); cmd_args.size = size * nmemb; cmd_args.file = stream; esp_err_t ret = esp_apptrace_file_cmd_send(dest, ESP_APPTRACE_FILE_CMD_FREAD, esp_apptrace_fread_args_prepare, &cmd_args, sizeof(cmd_args)); if (ret != ESP_OK) { ESP_EARLY_LOGE(TAG, "Failed to send file cmd (%d)!", ret); return 0; } // now read the answer size_t resp; ret = esp_apptrace_file_rsp_recv(dest, (uint8_t *)&resp, sizeof(resp)); if (ret != ESP_OK) { ESP_EARLY_LOGE(TAG, "Failed to read response (%d)!", ret); return 0; } if (resp > 0) { ret = esp_apptrace_file_rsp_recv(dest, ptr, resp); if (ret != ESP_OK) { ESP_EARLY_LOGE(TAG, "Failed to read file data (%d)!", ret); return 0; } } return resp; }
size_t esp_apptrace_fwrite(esp_apptrace_dest_t dest, const void *ptr, size_t size, size_t nmemb, void *stream) { esp_apptrace_fwrite_args_t cmd_args; ESP_EARLY_LOGV(TAG, "esp_apptrace_fwrite f %p l %d", stream, size*nmemb); cmd_args.buf = (void *)ptr; cmd_args.size = size * nmemb; cmd_args.file = stream; esp_err_t ret = esp_apptrace_file_cmd_send(dest, ESP_APPTRACE_FILE_CMD_FWRITE, esp_apptrace_fwrite_args_prepare, &cmd_args, sizeof(cmd_args.file)+cmd_args.size); if (ret != ESP_OK) { ESP_EARLY_LOGE(TAG, "Failed to send file cmd (%d)!", ret); return 0; } // now read the answer size_t resp; ret = esp_apptrace_file_rsp_recv(dest, (uint8_t *)&resp, sizeof(resp)); if (ret != ESP_OK) { ESP_EARLY_LOGE(TAG, "Failed to read response (%d)!", ret); return 0; } return resp; }
void *esp_apptrace_fopen(esp_apptrace_dest_t dest, const char *path, const char *mode) { esp_apptrace_fopen_args_t cmd_args; ESP_EARLY_LOGV(TAG, "esp_apptrace_fopen '%s' '%s'", path, mode); cmd_args.path = path; cmd_args.path_len = strlen(path) + 1; cmd_args.mode = mode; cmd_args.mode_len = strlen(mode) + 1; esp_err_t ret = esp_apptrace_file_cmd_send(dest, ESP_APPTRACE_FILE_CMD_FOPEN, esp_apptrace_fopen_args_prepare, &cmd_args, cmd_args.path_len+cmd_args.mode_len); if (ret != ESP_OK) { ESP_EARLY_LOGE(TAG, "Failed to send file cmd (%d)!", ret); return NULL; } // now read the answer void *resp; ret = esp_apptrace_file_rsp_recv(dest, (uint8_t *)&resp, sizeof(resp)); if (ret != ESP_OK) { ESP_EARLY_LOGE(TAG, "Failed to read response (%d)!", ret); return NULL; } return resp; }
//Modify regions array to disable the given range of memory. static void disable_mem_region(soc_memory_region_t *regions, intptr_t from, intptr_t to) { //Align from and to on word boundaries from = from & ~3; to = (to + 3) & ~3; for (int i = 0; i < soc_memory_region_count; i++) { soc_memory_region_t *region = ®ions[i]; intptr_t regStart = region->start; intptr_t regEnd = region->start + region->size; if (regStart >= from && regEnd <= to) { //Entire region falls in the range. Disable entirely. regions[i].type = -1; } else if (regStart >= from && regEnd > to && regStart < to) { //Start of the region falls in the range. Modify address/len. intptr_t overlap = to - regStart; region->start += overlap; region->size -= overlap; if (region->iram_address) { region->iram_address += overlap; } } else if (regStart < from && regEnd > from && regEnd <= to) { //End of the region falls in the range. Modify length. region->size -= regEnd - from; } else if (regStart < from && regEnd > to) { //Range punches a hole in the region! We do not support this. ESP_EARLY_LOGE(TAG, "region %d: hole punching is not supported!", i); regions->type = -1; //Just disable memory region. That'll teach them! } } }
int esp_apptrace_fstop(esp_apptrace_dest_t dest) { ESP_EARLY_LOGV(TAG, "%s", __func__); esp_err_t ret = esp_apptrace_file_cmd_send(dest, ESP_APPTRACE_FILE_CMD_STOP, NULL, NULL, 0); if (ret != ESP_OK) { ESP_EARLY_LOGE(TAG, "Failed to send files transfer stop cmd (%d)!", ret); } return ret; }
int esp_apptrace_ftell(esp_apptrace_dest_t dest, void *stream) { esp_apptrace_ftell_args_t cmd_args; cmd_args.file = stream; esp_err_t ret = esp_apptrace_file_cmd_send(dest, ESP_APPTRACE_FILE_CMD_FTELL, esp_apptrace_ftell_args_prepare, &cmd_args, sizeof(cmd_args)); if (ret != ESP_OK) { ESP_EARLY_LOGE(TAG, "Failed to send file cmd (%d)!", ret); return -1; } // now read the answer int resp; ret = esp_apptrace_file_rsp_recv(dest, (uint8_t *)&resp, sizeof(resp)); if (ret != ESP_OK) { ESP_EARLY_LOGE(TAG, "Failed to read response (%d)!", ret); return -1; } return resp; }
static esp_err_t esp_apptrace_file_rsp_recv(esp_apptrace_dest_t dest, uint8_t *buf, uint32_t buf_len) { uint32_t tot_rd = 0; while (tot_rd < buf_len) { uint32_t rd_size = buf_len - tot_rd; esp_err_t ret = esp_apptrace_read(dest, buf + tot_rd, &rd_size, ESP_APPTRACE_TMO_INFINITE); //TODO: finite tmo if (ret != ESP_OK) { ESP_EARLY_LOGE(TAG, "Failed to read (%d)!", ret); return ret; } ESP_EARLY_LOGV(TAG, "%s read %d bytes", __FUNCTION__, rd_size); tot_rd += rd_size; } return ESP_OK; }
static void example_timer_isr(void *arg) { example_event_data_t *tim_arg = (example_event_data_t *)arg; if (tim_arg->thnd != NULL) { if (tim_arg->count++ < 10) { BaseType_t xHigherPriorityTaskWoken = pdFALSE; SYSVIEW_EXAMPLE_SEND_EVENT_START(); if (xTaskNotifyFromISR(tim_arg->thnd, tim_arg->count, eSetValueWithOverwrite, &xHigherPriorityTaskWoken) != pdPASS) { ESP_EARLY_LOGE(TAG, "Failed to notify task %p", tim_arg->thnd); } else { SYSVIEW_EXAMPLE_SEND_EVENT_END(tim_arg->count); if (xHigherPriorityTaskWoken == pdTRUE) { portYIELD_FROM_ISR(); } } } } // re-start timer example_timer_rearm(tim_arg->group, tim_arg->timer); }
/** * @brief Free memory previously allocated via heap_caps_(m/c/r/z)alloc(). */ void IRAM_ATTR _heap_caps_free(void *ptr, const char *file, size_t line) { int num; mem_blk_t *mem_blk; mem_blk_t *tmp, *next, *prev, *last; if ((int)line == 0) { ESP_EARLY_LOGV(TAG, "caller func %p", file); } else { ESP_EARLY_LOGV(TAG, "caller file %s line %d", file, line); } if (!ptr) { ESP_EARLY_LOGE(TAG, "free(ptr=NULL)"); if ((int)line == 0) { ESP_EARLY_LOGE(TAG, "caller func %p", file); } else { ESP_EARLY_LOGE(TAG, "caller file %s line %d", file, line); } return; } num = get_blk_region(ptr); if (num >= HEAP_REGIONS_MAX) { ESP_EARLY_LOGE(TAG, "free(ptr_region=NULL)"); return; } mem_blk = ptr2blk(ptr, ptr_is_traced(ptr)); if (!mem_blk_is_used(mem_blk)) { ESP_EARLY_LOGE(TAG, "%p already freed\n", ptr); return; } ESP_EARLY_LOGV(TAG, "Free(ptr=%p, mem_blk=%p, region=%d)", ptr, mem_blk, num); _heap_caps_lock(num); g_heap_region[num].free_bytes += blk_link_size(mem_blk); ESP_EARLY_LOGV(TAG, "ptr prev=%p next=%p", mem_blk_prev(mem_blk), mem_blk_next(mem_blk)); ESP_EARLY_LOGV(TAG, "ptr1 prev->next=%p next->prev=%p", mem_blk_prev(mem_blk) ? mem_blk_next(mem_blk_prev(mem_blk)) : NULL, mem_blk_prev(mem_blk_next(mem_blk))); mem_blk_set_unused(mem_blk); mem_blk_set_untraced((mem2_blk_t *)mem_blk); prev = mem_blk_prev(mem_blk); next = mem_blk_next(mem_blk); last = mem_blk_next(next); if (prev && !mem_blk_is_used(prev)) { mem_blk_set_next(prev, next); mem_blk_set_prev(next, prev); tmp = prev; } else tmp = mem_blk; if (last && !mem_blk_is_used(next)) { mem_blk_set_next(tmp, last); mem_blk_set_prev(last, tmp); } ESP_EARLY_LOGV(TAG, "ptr2 prev->next=%p next->prev=%p", mem_blk_prev(mem_blk) ? mem_blk_next(mem_blk_prev(mem_blk)) : NULL, mem_blk_prev(mem_blk_next(mem_blk))); if ((uint8_t *)mem_blk < (uint8_t *)g_heap_region[num].free_blk) { ESP_EARLY_LOGV(TAG, "Free update free block from %p to %p", g_heap_region[num].free_blk, mem_blk); g_heap_region[num].free_blk = mem_blk; } _heap_caps_unlock(num); }
static void IRAM_ATTR rmt_driver_isr_default(void* arg) { uint32_t intr_st = RMT.int_st.val; uint32_t i = 0; uint8_t channel; portBASE_TYPE HPTaskAwoken = 0; for(i = 0; i < 32; i++) { if(i < 24) { if(intr_st & BIT(i)) { channel = i / 3; rmt_obj_t* p_rmt = p_rmt_obj[channel]; switch(i % 3) { //TX END case 0: ESP_EARLY_LOGD(RMT_TAG, "RMT INTR : TX END"); xSemaphoreGiveFromISR(p_rmt->tx_sem, &HPTaskAwoken); if(HPTaskAwoken == pdTRUE) { portYIELD_FROM_ISR(); } p_rmt->tx_data = NULL; p_rmt->tx_len_rem = 0; p_rmt->tx_offset = 0; p_rmt->tx_sub_len = 0; break; //RX_END case 1: ESP_EARLY_LOGD(RMT_TAG, "RMT INTR : RX END"); RMT.conf_ch[channel].conf1.rx_en = 0; int item_len = rmt_get_mem_len(channel); //change memory owner to protect data. RMT.conf_ch[channel].conf1.mem_owner = RMT_MEM_OWNER_TX; if(p_rmt->rx_buf) { BaseType_t res = xRingbufferSendFromISR(p_rmt->rx_buf, (void*) RMTMEM.chan[channel].data32, item_len * 4, &HPTaskAwoken); if(res == pdFALSE) { ESP_EARLY_LOGE(RMT_TAG, "RMT RX BUFFER FULL"); } else { } if(HPTaskAwoken == pdTRUE) { portYIELD_FROM_ISR(); } } else { ESP_EARLY_LOGE(RMT_TAG, "RMT RX BUFFER ERROR\n"); } RMT.conf_ch[channel].conf1.mem_wr_rst = 1; RMT.conf_ch[channel].conf1.mem_owner = RMT_MEM_OWNER_RX; RMT.conf_ch[channel].conf1.rx_en = 1; break; //ERR case 2: ESP_EARLY_LOGE(RMT_TAG, "RMT[%d] ERR", channel); ESP_EARLY_LOGE(RMT_TAG, "status: 0x%08x", RMT.status_ch[channel]); RMT.int_ena.val &= (~(BIT(i))); break; default: break; } RMT.int_clr.val = BIT(i); } } else { if(intr_st & (BIT(i))) { channel = i - 24; rmt_obj_t* p_rmt = p_rmt_obj[channel]; RMT.int_clr.val = BIT(i); ESP_EARLY_LOGD(RMT_TAG, "RMT CH[%d]: EVT INTR", channel); if(p_rmt->tx_data == NULL) { //skip } else { const rmt_item32_t* pdata = p_rmt->tx_data; int len_rem = p_rmt->tx_len_rem; if(len_rem >= p_rmt->tx_sub_len) { rmt_fill_memory(channel, pdata, p_rmt->tx_sub_len, p_rmt->tx_offset); p_rmt->tx_data += p_rmt->tx_sub_len; p_rmt->tx_len_rem -= p_rmt->tx_sub_len; } else if(len_rem == 0) { RMTMEM.chan[channel].data32[p_rmt->tx_offset].val = 0; } else { rmt_fill_memory(channel, pdata, len_rem, p_rmt->tx_offset); RMTMEM.chan[channel].data32[p_rmt->tx_offset + len_rem].val = 0; p_rmt->tx_data += len_rem; p_rmt->tx_len_rem -= len_rem; } if(p_rmt->tx_offset == 0) { p_rmt->tx_offset = p_rmt->tx_sub_len; } else { p_rmt->tx_offset = 0; } } } } } }