Mirrors/esp-idf
1
0
Fork 0
mirror of https://github.com/espressif/esp-idf.git synced 2026-10-02 03:00:34 +03:00
Code Issues Packages Projects Releases Wiki Activity

ci(header_check): Add check for public header should not include freertos

Browse Source
This commit is contained in:
C.S.M
2025-12-10 15:10:43 +08:00
parent 473b2fe27d
commit ed64e7bf78
62 changed files with 162 additions and 109 deletions
Download Patch File Download Diff File Expand all files Collapse all files
components/bt/common/ble_log/ble_log_spi_out.c
+1
View File
@@ -3,6 +3,7 @@
*
* SPDX-License-Identifier: Apache-2.0
*/
#include "freertos/FreeRTOS.h"
#include "ble_log/ble_log_spi_out.h"
#if CONFIG_BT_BLE_LOG_SPI_OUT_ENABLED
components/esp_driver_dac/esp32s2/dac_dma.c
+1
View File
@@ -33,6 +33,7 @@
#endif
#include "esp_check.h"
#include "esp_attr.h"
#include "esp_heap_caps.h"
#define DAC_DMA_PERIPH_SPI_HOST SPI3_HOST
components/esp_driver_isp/include/esp_private/isp_private.h
+2 -4
View File
@@ -16,9 +16,7 @@
#include "esp_check.h"
#include "esp_heap_caps.h"
#include "esp_intr_alloc.h"
#include "freertos/FreeRTOS.h"
#include "freertos/queue.h"
#include "freertos/idf_additions.h"
#include "esp_private/critical_section.h"
#include "driver/isp_types.h"
#include "soc/soc_caps.h"
#if SOC_ISP_SUPPORTED
@@ -69,7 +67,7 @@ typedef struct isp_processor_t {
void *csi_brg_hw;
#endif
ISP_ATOMIC_TYPE(isp_fsm_t) isp_fsm;
portMUX_TYPE spinlock;
DECLARE_CRIT_SECTION_LOCK_IN_STRUCT(spinlock);
color_space_pixel_format_t in_color_format;
color_space_pixel_format_t out_color_format;
uint32_t h_res;
components/esp_driver_sd_intf/include/driver/sd_host.h
+1 -1
View File
@@ -102,7 +102,7 @@ esp_err_t sd_host_slot_enable_io_int(sd_host_slot_handle_t slot);
* - ESP_ERR_INVALID_ARG: Invalid argument
* - ESP_ERR_TIMEOUT: Timeout
*/
esp_err_t sd_host_slot_wait_io_int(sd_host_slot_handle_t slot, TickType_t timeout_ticks);
esp_err_t sd_host_slot_wait_io_int(sd_host_slot_handle_t slot, uint32_t timeout_ticks);
/**
* @brief Get slot info
components/esp_driver_sd_intf/include/esp_private/sd_driver_interface.h
+1 -1
View File
@@ -125,7 +125,7 @@ struct sd_slot_driver_t {
* - ESP_ERR_INVALID_ARG: Invalid argument
* - ESP_ERR_TIMEOUT: Timeout
*/
esp_err_t (*wait_io_int)(sd_slot_driver_t *slot_drv, TickType_t timeout_ticks);
esp_err_t (*wait_io_int)(sd_slot_driver_t *slot_drv, uint32_t timeout_ticks);
/**
* @brief Get slot info
components/esp_driver_sd_intf/sd_host.c
+2 -1
View File
@@ -7,6 +7,7 @@
#include <string.h>
#include "esp_types.h"
#include "sdkconfig.h"
#include "freertos/FreeRTOS.h"
#include "esp_err.h"
#include "esp_log.h"
#include "esp_check.h"
@@ -85,7 +86,7 @@ esp_err_t sd_host_slot_enable_io_int(sd_host_slot_handle_t slot)
return slot->enable_io_int(slot);
}
esp_err_t sd_host_slot_wait_io_int(sd_host_slot_handle_t slot, TickType_t timeout_ticks)
esp_err_t sd_host_slot_wait_io_int(sd_host_slot_handle_t slot, uint32_t timeout_ticks)
{
SD_HOST_ARG_CHECK(slot);
SD_HOST_FUNC_CHECK(slot->wait_io_int);
components/esp_driver_sdio/include/driver/sdio_slave.h
+5 -6
View File
@@ -7,7 +7,6 @@
#pragma once
#include "esp_err.h"
#include "freertos/FreeRTOS.h" // for TickType_t
#include "hal/sdio_slave_types.h"
#ifdef __cplusplus
@@ -160,7 +159,7 @@ esp_err_t sdio_slave_recv_load_buf(sdio_slave_buf_handle_t handle);
* - ESP_ERR_NOT_FINISHED if returned buffer is not the end of a packet from the host, should call this API again until the end of a packet
* - ESP_OK if success
*/
esp_err_t sdio_slave_recv_packet(sdio_slave_buf_handle_t* handle_ret, TickType_t wait);
esp_err_t sdio_slave_recv_packet(sdio_slave_buf_handle_t* handle_ret, uint32_t wait);
/** Get received data if exist. The driver returns the ownership of the buffer to the app.
*
@@ -177,7 +176,7 @@ esp_err_t sdio_slave_recv_packet(sdio_slave_buf_handle_t* handle_ret, TickType_t
* - ESP_ERR_TIMEOUT if timeout before receiving new data
* - ESP_OK if success
*/
esp_err_t sdio_slave_recv(sdio_slave_buf_handle_t* handle_ret, uint8_t **out_addr, size_t *out_len, TickType_t wait);
esp_err_t sdio_slave_recv(sdio_slave_buf_handle_t* handle_ret, uint8_t **out_addr, size_t *out_len, uint32_t wait);
/** Retrieve the buffer corresponding to a handle.
*
@@ -205,7 +204,7 @@ uint8_t* sdio_slave_recv_get_buf(sdio_slave_buf_handle_t handle, size_t *len_o);
* - ESP_ERR_TIMEOUT if the queue is still full until timeout.
* - ESP_OK if success.
*/
esp_err_t sdio_slave_send_queue(uint8_t* addr, size_t len, void* arg, TickType_t wait);
esp_err_t sdio_slave_send_queue(uint8_t* addr, size_t len, void* arg, uint32_t wait);
/** Return the ownership of a finished transaction.
* @param out_arg Argument of the finished transaction. Set to NULL if unused.
@@ -213,7 +212,7 @@ esp_err_t sdio_slave_send_queue(uint8_t* addr, size_t len, void* arg, TickType_t
*
* @return ESP_ERR_TIMEOUT if no transaction finished, or ESP_OK if succeed.
*/
esp_err_t sdio_slave_send_get_finished(void** out_arg, TickType_t wait);
esp_err_t sdio_slave_send_get_finished(void** out_arg, uint32_t wait);
/** Start a new sending transfer, and wait for it (blocked) to be finished.
*
@@ -289,7 +288,7 @@ void sdio_slave_clear_host_int(sdio_slave_hostint_t mask);
*
* @return ESP_OK if success, ESP_ERR_TIMEOUT if timeout.
*/
esp_err_t sdio_slave_wait_int(int pos, TickType_t wait);
esp_err_t sdio_slave_wait_int(int pos, uint32_t wait);
#ifdef __cplusplus
}
components/esp_driver_sdio/src/sdio_slave.c
+5 -5
View File
@@ -503,7 +503,7 @@ static void sdio_intr_host(void *arg)
}
}
esp_err_t sdio_slave_wait_int(int pos, TickType_t wait)
esp_err_t sdio_slave_wait_int(int pos, uint32_t wait)
{
SDIO_SLAVE_CHECK(pos >= 0 && pos < 8, "interrupt num invalid", ESP_ERR_INVALID_ARG);
return xSemaphoreTake(context.events[pos], wait);
@@ -615,7 +615,7 @@ static void sdio_intr_send(void *arg)
}
}
esp_err_t sdio_slave_send_queue(uint8_t *addr, size_t len, void *arg, TickType_t wait)
esp_err_t sdio_slave_send_queue(uint8_t *addr, size_t len, void *arg, uint32_t wait)
{
SDIO_SLAVE_CHECK(len > 0, "len <= 0", ESP_ERR_INVALID_ARG);
SDIO_SLAVE_CHECK(esp_ptr_dma_capable(addr) && (uint32_t)addr % 4 == 0, "buffer to send should be DMA capable and 32-bit aligned",
@@ -636,7 +636,7 @@ esp_err_t sdio_slave_send_queue(uint8_t *addr, size_t len, void *arg, TickType_t
return ESP_OK;
}
esp_err_t sdio_slave_send_get_finished(void **out_arg, TickType_t wait)
esp_err_t sdio_slave_send_get_finished(void **out_arg, uint32_t wait)
{
void *arg = NULL;
BaseType_t err = xQueueReceive(context.ret_queue, &arg, wait);
@@ -783,7 +783,7 @@ sdio_slave_buf_handle_t sdio_slave_recv_register_buf(uint8_t *start)
return desc;
}
esp_err_t sdio_slave_recv(sdio_slave_buf_handle_t *handle_ret, uint8_t **out_addr, size_t *out_len, TickType_t wait)
esp_err_t sdio_slave_recv(sdio_slave_buf_handle_t *handle_ret, uint8_t **out_addr, size_t *out_len, uint32_t wait)
{
esp_err_t ret = sdio_slave_recv_packet(handle_ret, wait);
if (ret == ESP_ERR_NOT_FINISHED) {
@@ -802,7 +802,7 @@ esp_err_t sdio_slave_recv(sdio_slave_buf_handle_t *handle_ret, uint8_t **out_add
return ret;
}
esp_err_t sdio_slave_recv_packet(sdio_slave_buf_handle_t *handle_ret, TickType_t wait)
esp_err_t sdio_slave_recv_packet(sdio_slave_buf_handle_t *handle_ret, uint32_t wait)
{
SDIO_SLAVE_CHECK(handle_ret != NULL, "handle address cannot be 0", ESP_ERR_INVALID_ARG);
BaseType_t err = xSemaphoreTake(context.recv_event, wait);
components/esp_driver_sdmmc/legacy/include/driver/sdmmc_host.h
+1 -1
View File
@@ -207,7 +207,7 @@ esp_err_t sdmmc_host_io_int_enable(int slot);
* - ESP_OK on success (interrupt received)
* - ESP_ERR_TIMEOUT if the interrupt did not occur within timeout_ticks
*/
esp_err_t sdmmc_host_io_int_wait(int slot, TickType_t timeout_ticks);
esp_err_t sdmmc_host_io_int_wait(int slot, uint32_t timeout_ticks);
/**
* @brief Disable SDMMC host and release allocated resources gracefully
components/esp_driver_sdmmc/legacy/src/sdmmc_host.c
+1 -1
View File
@@ -233,7 +233,7 @@ esp_err_t sdmmc_host_io_int_enable(int slot)
return sd_host_slot_enable_io_int(hdl);
}
esp_err_t sdmmc_host_io_int_wait(int slot, TickType_t timeout_ticks)
esp_err_t sdmmc_host_io_int_wait(int slot, uint32_t timeout_ticks)
{
assert(slot == 0 || slot == 1);
sd_host_slot_handle_t hdl = sdmmc_get_slot_handle(slot);
components/esp_driver_sdmmc/src/sd_host_sdmmc.c
+1
View File
@@ -29,6 +29,7 @@
#include "esp_private/esp_cache_private.h"
#include "esp_private/gpio.h"
#include "esp_private/sd_host_private.h"
#include "freertos/FreeRTOS.h"
typedef struct sd_platform_t {
_lock_t mutex;
components/esp_driver_sdmmc/test_apps/sd_test_utils/components/common_test_flows/sdmmc_test_cd_wp_common.c
+1
View File
@@ -10,6 +10,7 @@
#include "hal/gpio_hal.h"
#include "sdmmc_cmd.h"
#include "sdmmc_test_cd_wp_common.h"
#include "esp_heap_caps.h"
void sdmmc_test_cd_input(int gpio_cd_num, const sdmmc_host_t* config)
{
components/esp_driver_sdmmc/test_apps/sd_test_utils/components/common_test_flows/sdmmc_test_erase_common_sd.c
+1
View File
@@ -9,6 +9,7 @@
#include <sys/time.h>
#include "unity.h"
#include "sdmmc_cmd.h"
#include "esp_heap_caps.h"
#define PATTERN_SEED 0x12345678
#define FLAG_ERASE_TEST_ADJACENT (1 << 0)
components/esp_driver_sdmmc/test_apps/sd_test_utils/components/common_test_flows/sdmmc_test_rw_common.c
+1
View File
@@ -18,6 +18,7 @@
#include "sd_protocol_defs.h"
#include "sdmmc_cmd.h"
#include "sdmmc_test_rw_common.h"
#include "freertos/FreeRTOS.h"
static void do_single_rw_perf_test(sdmmc_card_t* card, size_t start_block,
size_t block_count, size_t alignment, FILE* performance_log,
components/esp_driver_sdmmc/test_apps/sdmmc/components/sdmmc_tests/sdmmc_test_probe_sd.c
+1
View File
@@ -7,6 +7,7 @@
#include "unity.h"
#include "sdmmc_cmd.h"
#include "sdmmc_test_begin_end_sd.h"
#include "esp_heap_caps.h"
#define SDMMC_FREQ_CUSTOM_10M 10000
components/esp_driver_sdspi/include/driver/sdspi_host.h
+1 -1
View File
@@ -225,7 +225,7 @@ esp_err_t sdspi_host_io_int_enable(sdspi_dev_handle_t handle);
* @return
* - ESP_OK on success
*/
esp_err_t sdspi_host_io_int_wait(sdspi_dev_handle_t handle, TickType_t timeout_ticks);
esp_err_t sdspi_host_io_int_wait(sdspi_dev_handle_t handle, uint32_t timeout_ticks);
/**
* @brief Check if the buffer meets the alignment requirements
components/esp_driver_sdspi/src/sdspi_host.c
+1 -1
View File
@@ -1024,7 +1024,7 @@ esp_err_t sdspi_host_io_int_enable(sdspi_dev_handle_t handle)
}
//the interrupt will give the semaphore and then disable itself
esp_err_t sdspi_host_io_int_wait(sdspi_dev_handle_t handle, TickType_t timeout_ticks)
esp_err_t sdspi_host_io_int_wait(sdspi_dev_handle_t handle, uint32_t timeout_ticks)
{
slot_info_t* slot = get_slot_info(handle);
//skip the interrupt and semaphore if the gpio is already low.
components/esp_driver_sdspi/test_apps/sdspi/components/sdspi_tests/sdmmc_test_erase_common_spi.c
+1
View File
@@ -10,6 +10,7 @@
#include "unity.h"
#include "sdmmc_cmd.h"
#include "sdmmc_test_begin_end_spi.h"
#include "esp_heap_caps.h"
#define PATTERN_SEED 0x12345678
#define FLAG_ERASE_TEST_ADJACENT (1 << 0)
components/esp_driver_sdspi/test_apps/sdspi/components/sdspi_tests/sdmmc_test_probe_spi.c
+1
View File
@@ -7,6 +7,7 @@
#include "unity.h"
#include "sdmmc_cmd.h"
#include "sdmmc_test_begin_end_spi.h"
#include "esp_heap_caps.h"
#define SDMMC_FREQ_CUSTOM_10M 10000
components/esp_driver_spi/include/driver/spi_master.h
+6 -7
View File
@@ -1,5 +1,5 @@
/*
* SPDX-FileCopyrightText: 2010-2024 Espressif Systems (Shanghai) CO LTD
* SPDX-FileCopyrightText: 2010-2025 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
@@ -7,7 +7,6 @@
#pragma once
#include "esp_err.h"
#include "freertos/FreeRTOS.h"
#include "hal/spi_types.h"
//for spi_bus_initialization functions. to be back-compatible
#include "driver/spi_common.h"
@@ -219,7 +218,7 @@ esp_err_t spi_bus_remove_device(spi_device_handle_t handle);
* - ESP_ERR_INVALID_STATE if previous transactions are not finished
* - ESP_OK on success
*/
esp_err_t spi_device_queue_trans(spi_device_handle_t handle, spi_transaction_t *trans_desc, TickType_t ticks_to_wait);
esp_err_t spi_device_queue_trans(spi_device_handle_t handle, spi_transaction_t *trans_desc, uint32_t ticks_to_wait);
/**
* @brief Get the result of a SPI transaction queued earlier by ``spi_device_queue_trans``.
@@ -241,7 +240,7 @@ esp_err_t spi_device_queue_trans(spi_device_handle_t handle, spi_transaction_t *
* - ESP_ERR_TIMEOUT if there was no completed transaction before ticks_to_wait expired
* - ESP_OK on success
*/
esp_err_t spi_device_get_trans_result(spi_device_handle_t handle, spi_transaction_t **trans_desc, TickType_t ticks_to_wait);
esp_err_t spi_device_get_trans_result(spi_device_handle_t handle, spi_transaction_t **trans_desc, uint32_t ticks_to_wait);
/**
* @brief Send a SPI transaction, wait for it to complete, and return the result
@@ -282,7 +281,7 @@ esp_err_t spi_device_transmit(spi_device_handle_t handle, spi_transaction_t *tra
* - ESP_ERR_INVALID_STATE if previous transactions are not finished
* - ESP_OK on success
*/
esp_err_t spi_device_polling_start(spi_device_handle_t handle, spi_transaction_t *trans_desc, TickType_t ticks_to_wait);
esp_err_t spi_device_polling_start(spi_device_handle_t handle, spi_transaction_t *trans_desc, uint32_t ticks_to_wait);
/**
* @brief Poll until the polling transaction ends.
@@ -299,7 +298,7 @@ esp_err_t spi_device_polling_start(spi_device_handle_t handle, spi_transaction_t
* - ESP_ERR_TIMEOUT if the transaction cannot finish before ticks_to_wait expired
* - ESP_OK on success
*/
esp_err_t spi_device_polling_end(spi_device_handle_t handle, TickType_t ticks_to_wait);
esp_err_t spi_device_polling_end(spi_device_handle_t handle, uint32_t ticks_to_wait);
/**
* @brief Send a polling transaction, wait for it to complete, and return the result
@@ -336,7 +335,7 @@ esp_err_t spi_device_polling_transmit(spi_device_handle_t handle, spi_transactio
* - ESP_ERR_INVALID_ARG : ``wait`` is not set to portMAX_DELAY.
* - ESP_OK : Success.
*/
esp_err_t spi_device_acquire_bus(spi_device_handle_t device, TickType_t wait);
esp_err_t spi_device_acquire_bus(spi_device_handle_t device, uint32_t wait);
/**
* @brief Release the SPI bus occupied by the device. All other devices can start sending transactions.
components/esp_driver_spi/include/driver/spi_slave.h
+4 -6
View File
@@ -1,5 +1,5 @@
/*
* SPDX-FileCopyrightText: 2010-2024 Espressif Systems (Shanghai) CO LTD
* SPDX-FileCopyrightText: 2010-2025 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
@@ -8,8 +8,6 @@
#define _DRIVER_SPI_SLAVE_H_
#include "esp_err.h"
#include "freertos/FreeRTOS.h"
#include "freertos/semphr.h"
#include "driver/spi_common.h"
#ifdef __cplusplus
@@ -167,7 +165,7 @@ esp_err_t spi_slave_disable(spi_host_device_t host);
* - ESP_ERR_INVALID_STATE if sync data between Cache and memory failed
* - ESP_OK on success
*/
esp_err_t spi_slave_queue_trans(spi_host_device_t host, const spi_slave_transaction_t *trans_desc, TickType_t ticks_to_wait);
esp_err_t spi_slave_queue_trans(spi_host_device_t host, const spi_slave_transaction_t *trans_desc, uint32_t ticks_to_wait);
/**
* @brief Get the result of a SPI transaction queued earlier
@@ -189,7 +187,7 @@ esp_err_t spi_slave_queue_trans(spi_host_device_t host, const spi_slave_transact
* - ESP_ERR_NOT_SUPPORTED if flag `SPI_SLAVE_NO_RETURN_RESULT` is set
* - ESP_OK on success
*/
esp_err_t spi_slave_get_trans_result(spi_host_device_t host, spi_slave_transaction_t **trans_desc, TickType_t ticks_to_wait);
esp_err_t spi_slave_get_trans_result(spi_host_device_t host, spi_slave_transaction_t **trans_desc, uint32_t ticks_to_wait);
/**
* @brief Do a SPI transaction
@@ -208,7 +206,7 @@ esp_err_t spi_slave_get_trans_result(spi_host_device_t host, spi_slave_transacti
* - ESP_ERR_INVALID_ARG if parameter is invalid
* - ESP_OK on success
*/
esp_err_t spi_slave_transmit(spi_host_device_t host, spi_slave_transaction_t *trans_desc, TickType_t ticks_to_wait);
esp_err_t spi_slave_transmit(spi_host_device_t host, spi_slave_transaction_t *trans_desc, uint32_t ticks_to_wait);
#ifdef __cplusplus
}
components/esp_driver_spi/include/driver/spi_slave_hd.h
+6 -8
View File
@@ -1,5 +1,5 @@
/*
* SPDX-FileCopyrightText: 2010-2024 Espressif Systems (Shanghai) CO LTD
* SPDX-FileCopyrightText: 2010-2025 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
@@ -8,8 +8,6 @@
#include "esp_types.h"
#include "soc/soc_caps.h"
#include "freertos/FreeRTOS.h"
#include "hal/spi_types.h"
#include "driver/spi_common.h"
#include "sdkconfig.h"
@@ -41,7 +39,7 @@ typedef struct {
} spi_slave_hd_event_t;
/// Callback for SPI Slave HD
typedef bool (*slave_cb_t)(void* arg, spi_slave_hd_event_t* event, BaseType_t* awoken);
typedef bool (*slave_cb_t)(void* arg, spi_slave_hd_event_t* event, int* awoken);
/// Channel of SPI Slave HD to do data transaction
typedef enum {
@@ -153,7 +151,7 @@ esp_err_t spi_slave_hd_disable(spi_host_device_t host_id);
* - ESP_ERR_TIMEOUT: Cannot queue the data before timeout. Master is still processing previous transaction.
* - ESP_ERR_INVALID_STATE: Function called in invalid state. This API should be called under segment mode.
*/
esp_err_t spi_slave_hd_queue_trans(spi_host_device_t host_id, spi_slave_chan_t chan, spi_slave_hd_data_t* trans, TickType_t timeout);
esp_err_t spi_slave_hd_queue_trans(spi_host_device_t host_id, spi_slave_chan_t chan, spi_slave_hd_data_t* trans, uint32_t timeout);
/**
* @brief Get the result of a data transaction (segment mode)
@@ -170,7 +168,7 @@ esp_err_t spi_slave_hd_queue_trans(spi_host_device_t host_id, spi_slave_chan_t c
* - ESP_ERR_TIMEOUT: There's no transaction done before timeout
* - ESP_ERR_INVALID_STATE: Function called in invalid state. This API should be called under segment mode.
*/
esp_err_t spi_slave_hd_get_trans_res(spi_host_device_t host_id, spi_slave_chan_t chan, spi_slave_hd_data_t **out_trans, TickType_t timeout);
esp_err_t spi_slave_hd_get_trans_res(spi_host_device_t host_id, spi_slave_chan_t chan, spi_slave_hd_data_t **out_trans, uint32_t timeout);
/**
* @brief Read the shared registers
@@ -210,7 +208,7 @@ void spi_slave_hd_write_buffer(spi_host_device_t host_id, int addr, uint8_t *dat
* - ESP_ERR_TIMEOUT: Master is still processing previous transaction. There is no available transaction for slave to load
* - ESP_ERR_INVALID_STATE: Function called in invalid state. This API should be called under append mode.
*/
esp_err_t spi_slave_hd_append_trans(spi_host_device_t host_id, spi_slave_chan_t chan, spi_slave_hd_data_t *trans, TickType_t timeout);
esp_err_t spi_slave_hd_append_trans(spi_host_device_t host_id, spi_slave_chan_t chan, spi_slave_hd_data_t *trans, uint32_t timeout);
/**
* @brief Get the result of a data transaction (append mode)
@@ -227,7 +225,7 @@ esp_err_t spi_slave_hd_append_trans(spi_host_device_t host_id, spi_slave_chan_t
* - ESP_ERR_TIMEOUT: There's no transaction done before timeout
* - ESP_ERR_INVALID_STATE: Function called in invalid state. This API should be called under append mode.
*/
esp_err_t spi_slave_hd_get_append_trans_res(spi_host_device_t host_id, spi_slave_chan_t chan, spi_slave_hd_data_t **out_trans, TickType_t timeout);
esp_err_t spi_slave_hd_get_append_trans_res(spi_host_device_t host_id, spi_slave_chan_t chan, spi_slave_hd_data_t **out_trans, uint32_t timeout);
#ifdef __cplusplus
}
components/esp_driver_spi/include/esp_private/spi_common_internal.h
-1
View File
@@ -10,7 +10,6 @@
#include <esp_intr_alloc.h>
#include "driver/spi_common.h"
#include "freertos/FreeRTOS.h"
#include "hal/spi_types.h"
#include "hal/dma_types.h"
#include "soc/ext_mem_defs.h" //for SOC_NON_CACHEABLE_OFFSET
components/esp_driver_spi/include/esp_private/spi_master_internal.h
+2 -2
View File
@@ -94,7 +94,7 @@ esp_err_t spi_bus_multi_trans_mode_enable(spi_device_handle_t handle, bool enabl
* - ESP_ERR_INVALID_STATE: Invalid states, e.g.: an SPI polling transaction is ongoing, SCT mode isn't enabled, DMA descriptors not enough, etc.
* - ESP_ERR_TIMEOUT: Timeout, this SCT transaction isn't queued successfully
*/
esp_err_t spi_device_queue_multi_trans(spi_device_handle_t handle, spi_multi_transaction_t *seg_trans_desc, uint32_t trans_num, TickType_t ticks_to_wait);
esp_err_t spi_device_queue_multi_trans(spi_device_handle_t handle, spi_multi_transaction_t *seg_trans_desc, uint32_t trans_num, uint32_t ticks_to_wait);
/**
* @brief Get the result of an SPI Segmented-Configure-Transaction (SCT).
@@ -114,7 +114,7 @@ esp_err_t spi_device_queue_multi_trans(spi_device_handle_t handle, spi_multi_tra
* - ESP_ERR_INVALID_STATE: Invalid states, e.g.: SCT mode isn't enabled, etc.
* - ESP_ERR_TIMEOUT: Timeout, didn't get a completed SCT transaction
*/
esp_err_t spi_device_get_multi_trans_result(spi_device_handle_t handle, spi_multi_transaction_t **seg_trans_desc, TickType_t ticks_to_wait);
esp_err_t spi_device_get_multi_trans_result(spi_device_handle_t handle, spi_multi_transaction_t **seg_trans_desc, uint32_t ticks_to_wait);
#endif //#if SOC_SPI_SCT_SUPPORTED
#ifdef __cplusplus
components/esp_driver_spi/src/gpspi/spi_common.c
+1
View File
@@ -25,6 +25,7 @@
#include "esp_private/sleep_retention.h"
#include "esp_dma_utils.h"
#include "hal/spi_hal.h"
#include "freertos/FreeRTOS.h"
#if CONFIG_IDF_TARGET_ESP32
#include "soc/dport_reg.h"
#endif
components/esp_driver_spi/src/gpspi/spi_master.c
+10 -7
View File
@@ -121,6 +121,9 @@ We have two bits to control the interrupt:
#include "esp_log.h"
#include "esp_check.h"
#include "esp_ipc.h"
#include "esp_cache.h"
#include "esp_heap_caps.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/queue.h"
#include "soc/soc_memory_layout.h"
@@ -1233,7 +1236,7 @@ clean_up:
return ESP_ERR_NO_MEM;
}
esp_err_t SPI_MASTER_ATTR spi_device_queue_trans(spi_device_handle_t handle, spi_transaction_t *trans_desc, TickType_t ticks_to_wait)
esp_err_t SPI_MASTER_ATTR spi_device_queue_trans(spi_device_handle_t handle, spi_transaction_t *trans_desc, uint32_t ticks_to_wait)
{
esp_err_t ret = check_trans_valid(handle, trans_desc);
if (ret != ESP_OK) {
@@ -1285,7 +1288,7 @@ clean_up:
return ret;
}
esp_err_t SPI_MASTER_ATTR spi_device_get_trans_result(spi_device_handle_t handle, spi_transaction_t **trans_desc, TickType_t ticks_to_wait)
esp_err_t SPI_MASTER_ATTR spi_device_get_trans_result(spi_device_handle_t handle, spi_transaction_t **trans_desc, uint32_t ticks_to_wait)
{
BaseType_t r;
spi_trans_priv_t trans_buf;
@@ -1332,7 +1335,7 @@ esp_err_t SPI_MASTER_ATTR spi_device_transmit(spi_device_handle_t handle, spi_tr
return ESP_OK;
}
esp_err_t SPI_MASTER_ISR_ATTR spi_device_acquire_bus(spi_device_t *device, TickType_t wait)
esp_err_t SPI_MASTER_ISR_ATTR spi_device_acquire_bus(spi_device_t *device, uint32_t wait)
{
spi_host_t *const host = device->host;
SPI_CHECK(wait == portMAX_DELAY, "acquire finite time not supported now.", ESP_ERR_INVALID_ARG);
@@ -1396,7 +1399,7 @@ void SPI_MASTER_ISR_ATTR spi_device_release_bus(spi_device_t *dev)
(void) ret;
}
esp_err_t SPI_MASTER_ISR_ATTR spi_device_polling_start(spi_device_handle_t handle, spi_transaction_t *trans_desc, TickType_t ticks_to_wait)
esp_err_t SPI_MASTER_ISR_ATTR spi_device_polling_start(spi_device_handle_t handle, spi_transaction_t *trans_desc, uint32_t ticks_to_wait)
{
esp_err_t ret;
SPI_CHECK(ticks_to_wait == portMAX_DELAY, "currently timeout is not available for polling transactions", ESP_ERR_INVALID_ARG);
@@ -1443,7 +1446,7 @@ esp_err_t SPI_MASTER_ISR_ATTR spi_device_polling_start(spi_device_handle_t handl
return ESP_OK;
}
esp_err_t SPI_MASTER_ISR_ATTR spi_device_polling_end(spi_device_handle_t handle, TickType_t ticks_to_wait)
esp_err_t SPI_MASTER_ISR_ATTR spi_device_polling_end(spi_device_handle_t handle, uint32_t ticks_to_wait)
{
SPI_CHECK(handle != NULL, "invalid dev handle", ESP_ERR_INVALID_ARG);
spi_host_t *host = handle->host;
@@ -1821,7 +1824,7 @@ static void SPI_MASTER_ATTR s_sct_format_conf_buffer(spi_device_handle_t handle,
spi_hal_sct_format_conf_buffer(hal, &seg_config, hal_dev, buffer);
}
esp_err_t SPI_MASTER_ATTR spi_device_queue_multi_trans(spi_device_handle_t handle, spi_multi_transaction_t *seg_trans_desc, uint32_t trans_num, TickType_t ticks_to_wait)
esp_err_t SPI_MASTER_ATTR spi_device_queue_multi_trans(spi_device_handle_t handle, spi_multi_transaction_t *seg_trans_desc, uint32_t trans_num, uint32_t ticks_to_wait)
{
SPI_CHECK(handle, "Invalid arguments.", ESP_ERR_INVALID_ARG);
SPI_CHECK(SOC_SPI_SCT_SUPPORTED_PERIPH(handle->host->id), "Invalid arguments", ESP_ERR_INVALID_ARG);
@@ -1923,7 +1926,7 @@ esp_err_t SPI_MASTER_ATTR spi_device_queue_multi_trans(spi_device_handle_t handl
return ESP_OK;
}
esp_err_t SPI_MASTER_ATTR spi_device_get_multi_trans_result(spi_device_handle_t handle, spi_multi_transaction_t **seg_trans_desc, TickType_t ticks_to_wait)
esp_err_t SPI_MASTER_ATTR spi_device_get_multi_trans_result(spi_device_handle_t handle, spi_multi_transaction_t **seg_trans_desc, uint32_t ticks_to_wait)
{
SPI_CHECK(handle, "Invalid arguments.", ESP_ERR_INVALID_ARG);
SPI_CHECK(SOC_SPI_SCT_SUPPORTED_PERIPH(handle->host->id), "Invalid arguments", ESP_ERR_INVALID_ARG);
components/esp_driver_spi/src/gpspi/spi_slave.c
+3 -3
View File
@@ -473,7 +473,7 @@ static esp_err_t SPI_SLAVE_ISR_ATTR spi_slave_setup_priv_trans(spi_host_device_t
return ESP_OK;
}
esp_err_t SPI_SLAVE_ATTR spi_slave_queue_trans(spi_host_device_t host, const spi_slave_transaction_t *trans_desc, TickType_t ticks_to_wait)
esp_err_t SPI_SLAVE_ATTR spi_slave_queue_trans(spi_host_device_t host, const spi_slave_transaction_t *trans_desc, uint32_t ticks_to_wait)
{
BaseType_t r;
SPI_CHECK(is_valid_host(host), "invalid host", ESP_ERR_INVALID_ARG);
@@ -601,7 +601,7 @@ esp_err_t SPI_SLAVE_ISR_ATTR spi_slave_queue_reset_isr(spi_host_device_t host)
return ESP_OK;
}
esp_err_t SPI_SLAVE_ATTR spi_slave_get_trans_result(spi_host_device_t host, spi_slave_transaction_t **trans_desc, TickType_t ticks_to_wait)
esp_err_t SPI_SLAVE_ATTR spi_slave_get_trans_result(spi_host_device_t host, spi_slave_transaction_t **trans_desc, uint32_t ticks_to_wait)
{
BaseType_t r;
SPI_CHECK(is_valid_host(host), "invalid host", ESP_ERR_INVALID_ARG);
@@ -620,7 +620,7 @@ esp_err_t SPI_SLAVE_ATTR spi_slave_get_trans_result(spi_host_device_t host, spi_
return ESP_OK;
}
esp_err_t SPI_SLAVE_ATTR spi_slave_transmit(spi_host_device_t host, spi_slave_transaction_t *trans_desc, TickType_t ticks_to_wait)
esp_err_t SPI_SLAVE_ATTR spi_slave_transmit(spi_host_device_t host, spi_slave_transaction_t *trans_desc, uint32_t ticks_to_wait)
{
esp_err_t ret;
spi_slave_transaction_t *ret_trans;
components/esp_driver_spi/src/gpspi/spi_slave_hd.c
+4 -4
View File
@@ -836,7 +836,7 @@ esp_err_t s_spi_slave_hd_append_rxdma(spi_slave_hd_slot_t *host, uint8_t *data,
}
//---------------------------------------------------------Segment Mode Transaction APIs-----------------------------------------------------------//
esp_err_t spi_slave_hd_queue_trans(spi_host_device_t host_id, spi_slave_chan_t chan, spi_slave_hd_data_t *trans, TickType_t timeout)
esp_err_t spi_slave_hd_queue_trans(spi_host_device_t host_id, spi_slave_chan_t chan, spi_slave_hd_data_t *trans, uint32_t timeout)
{
spi_slave_hd_slot_t *host = spihost[host_id];
@@ -864,7 +864,7 @@ esp_err_t spi_slave_hd_queue_trans(spi_host_device_t host_id, spi_slave_chan_t c
return ESP_OK;
}
esp_err_t spi_slave_hd_get_trans_res(spi_host_device_t host_id, spi_slave_chan_t chan, spi_slave_hd_data_t **out_trans, TickType_t timeout)
esp_err_t spi_slave_hd_get_trans_res(spi_host_device_t host_id, spi_slave_chan_t chan, spi_slave_hd_data_t **out_trans, uint32_t timeout)
{
esp_err_t ret;
spi_slave_hd_slot_t *host = spihost[host_id];
@@ -887,7 +887,7 @@ void spi_slave_hd_write_buffer(spi_host_device_t host_id, int addr, uint8_t *dat
}
//---------------------------------------------------------Append Mode Transaction APIs-----------------------------------------------------------//
esp_err_t spi_slave_hd_append_trans(spi_host_device_t host_id, spi_slave_chan_t chan, spi_slave_hd_data_t *trans, TickType_t timeout)
esp_err_t spi_slave_hd_append_trans(spi_host_device_t host_id, spi_slave_chan_t chan, spi_slave_hd_data_t *trans, uint32_t timeout)
{
esp_err_t err;
spi_slave_hd_slot_t *host = spihost[host_id];
@@ -921,7 +921,7 @@ esp_err_t spi_slave_hd_append_trans(spi_host_device_t host_id, spi_slave_chan_t
return err;
}
esp_err_t spi_slave_hd_get_append_trans_res(spi_host_device_t host_id, spi_slave_chan_t chan, spi_slave_hd_data_t **out_trans, TickType_t timeout)
esp_err_t spi_slave_hd_get_append_trans_res(spi_host_device_t host_id, spi_slave_chan_t chan, spi_slave_hd_data_t **out_trans, uint32_t timeout)
{
esp_err_t ret;
spi_slave_hd_slot_t *host = spihost[host_id];
components/esp_driver_uart/include/driver/uart.h
+2 -2
View File
@@ -516,7 +516,7 @@ esp_err_t uart_intr_config(uart_port_t uart_num, const uart_intr_config_t *intr_
* - ESP_FAIL Parameter error
* - ESP_ERR_TIMEOUT Timeout
*/
esp_err_t uart_wait_tx_done(uart_port_t uart_num, TickType_t ticks_to_wait);
esp_err_t uart_wait_tx_done(uart_port_t uart_num, uint32_t ticks_to_wait);
/**
* @brief Send data to the UART port from a given buffer and length.
@@ -587,7 +587,7 @@ int uart_write_bytes_with_break(uart_port_t uart_num, const void* src, size_t si
* - (-1) Error
* - OTHERS (>=0) The number of bytes read from UART buffer
*/
int uart_read_bytes(uart_port_t uart_num, void* buf, uint32_t length, TickType_t ticks_to_wait);
int uart_read_bytes(uart_port_t uart_num, void* buf, uint32_t length, uint32_t ticks_to_wait);
/**
* @brief Alias of uart_flush_input.
components/esp_driver_uart/include/driver/uhci.h
-2
View File
@@ -7,8 +7,6 @@
#pragma once
#include "esp_err.h"
#include "freertos/FreeRTOS.h"
#include "freertos/queue.h"
#include "driver/uhci_types.h"
#ifdef __cplusplus
components/esp_driver_uart/src/uart.c
+2 -2
View File
@@ -1540,7 +1540,7 @@ static void UART_ISR_ATTR uart_rx_intr_handler_default(void *param)
}
/**************************************************************/
esp_err_t uart_wait_tx_done(uart_port_t uart_num, TickType_t ticks_to_wait)
esp_err_t uart_wait_tx_done(uart_port_t uart_num, uint32_t ticks_to_wait)
{
ESP_RETURN_ON_FALSE((uart_num < UART_NUM_MAX), ESP_FAIL, UART_TAG, "uart_num error");
ESP_RETURN_ON_FALSE((p_uart_obj[uart_num]), ESP_FAIL, UART_TAG, "uart driver error");
@@ -1720,7 +1720,7 @@ static bool uart_check_buf_full(uart_port_t uart_num)
return false;
}
int uart_read_bytes(uart_port_t uart_num, void *buf, uint32_t length, TickType_t ticks_to_wait)
int uart_read_bytes(uart_port_t uart_num, void *buf, uint32_t length, uint32_t ticks_to_wait)
{
ESP_RETURN_ON_FALSE((uart_num < UART_NUM_MAX), (-1), UART_TAG, "uart_num error");
ESP_RETURN_ON_FALSE((buf), (-1), UART_TAG, "uart data null");
components/esp_driver_usb_serial_jtag/include/driver/usb_serial_jtag.h
+4 -6
View File
@@ -1,5 +1,5 @@
/*
* SPDX-FileCopyrightText: 2021-2024 Espressif Systems (Shanghai) CO LTD
* SPDX-FileCopyrightText: 2021-2025 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
@@ -7,8 +7,6 @@
#pragma once
#include "esp_err.h"
#include "freertos/FreeRTOS.h"
#include "freertos/semphr.h"
#ifdef __cplusplus
extern "C" {
@@ -57,7 +55,7 @@ esp_err_t usb_serial_jtag_driver_install(usb_serial_jtag_driver_config_t *usb_se
* @return
* - The number of bytes read from USB_SERIAL FIFO
*/
int usb_serial_jtag_read_bytes(void* buf, uint32_t length, TickType_t ticks_to_wait);
int usb_serial_jtag_read_bytes(void* buf, uint32_t length, uint32_t ticks_to_wait);
/**
* @brief Send data to the USB-UART port from a given buffer and length,
@@ -72,7 +70,7 @@ int usb_serial_jtag_read_bytes(void* buf, uint32_t length, TickType_t ticks_to_w
* @return
* - The number of bytes pushed to the TX FIFO
*/
int usb_serial_jtag_write_bytes(const void* src, size_t size, TickType_t ticks_to_wait);
int usb_serial_jtag_write_bytes(const void* src, size_t size, uint32_t ticks_to_wait);
/**
* @brief Blocks until all data written using `usb_serial_jtag_write_bytes` is sent to the host, or until timeout.
@@ -81,7 +79,7 @@ int usb_serial_jtag_write_bytes(const void* src, size_t size, TickType_t ticks_t
*
* @return ESP_OK when flushed, ESP_ERR_TIMEOUT on timeout.
*/
esp_err_t usb_serial_jtag_wait_tx_done(TickType_t ticks_to_wait);
esp_err_t usb_serial_jtag_wait_tx_done(uint32_t ticks_to_wait);
/**
* @brief Uninstall USB-SERIAL-JTAG driver.
components/esp_driver_usb_serial_jtag/include/driver/usb_serial_jtag_select.h
+1 -1
View File
@@ -19,7 +19,7 @@ typedef enum {
USJ_SELECT_ERROR_NOTIF,
} usj_select_notif_t;
typedef void (*usj_select_notif_callback_t)(usj_select_notif_t usb_serial_jtag_select_notif, BaseType_t *task_woken);
typedef void (*usj_select_notif_callback_t)(usj_select_notif_t usb_serial_jtag_select_notif, int *task_woken);
/**
* @brief Set notification callback function for select() events
components/esp_driver_usb_serial_jtag/src/usb_serial_jtag.c
+3 -3
View File
@@ -239,7 +239,7 @@ _exit:
return err;
}
int usb_serial_jtag_read_bytes(void* buf, uint32_t length, TickType_t ticks_to_wait)
int usb_serial_jtag_read_bytes(void* buf, uint32_t length, uint32_t ticks_to_wait)
{
uint8_t *data = NULL;
size_t data_read_len = 0;
@@ -262,7 +262,7 @@ int usb_serial_jtag_read_bytes(void* buf, uint32_t length, TickType_t ticks_to_w
return data_read_len;
}
int usb_serial_jtag_write_bytes(const void* src, size_t size, TickType_t ticks_to_wait)
int usb_serial_jtag_write_bytes(const void* src, size_t size, uint32_t ticks_to_wait)
{
ESP_RETURN_ON_FALSE(src && size, 0, USB_SERIAL_JTAG_TAG, "invalid buffer or size");
ESP_RETURN_ON_FALSE(p_usb_serial_jtag_obj != NULL, 0, USB_SERIAL_JTAG_TAG, "driver is not initialized yet");
@@ -288,7 +288,7 @@ int usb_serial_jtag_write_bytes(const void* src, size_t size, TickType_t ticks_t
return (result == pdFALSE) ? 0 : size;
}
esp_err_t usb_serial_jtag_wait_tx_done(TickType_t ticks_to_wait)
esp_err_t usb_serial_jtag_wait_tx_done(uint32_t ticks_to_wait)
{
int r;
TimeOut_t timeout;
components/esp_driver_usb_serial_jtag/src/usb_serial_jtag_connection_monitor.c
+1
View File
@@ -7,6 +7,7 @@
#include <stdbool.h>
#include "driver/usb_serial_jtag.h"
#include "hal/usb_serial_jtag_ll.h"
#include "freertos/FreeRTOS.h"
#include "esp_private/startup_internal.h"
#include "esp_freertos_hooks.h"
#include "esp_pm.h"
components/esp_driver_usb_serial_jtag/src/usb_serial_jtag_vfs.c
+1 -1
View File
@@ -373,7 +373,7 @@ static int usb_serial_jtag_fsync(int fd)
#ifdef CONFIG_VFS_SUPPORT_SELECT
static void select_notif_callback_isr(usj_select_notif_t usj_select_notif, BaseType_t *task_woken)
static void select_notif_callback_isr(usj_select_notif_t usj_select_notif, int *task_woken)
{
portENTER_CRITICAL_ISR(&s_registered_select_lock);
for (int i = 0; i < s_registered_select_num; ++i) {
components/esp_hw_support/include/esp_private/spi_share_hw_ctrl.h
+4 -4
View File
@@ -12,7 +12,7 @@
#include "soc/spi_periph.h"
#include "soc/gpio_struct.h"
#include "esp_private/periph_ctrl.h"
#include "freertos/FreeRTOS.h"
#include "esp_err.h"
#ifdef __cplusplus
extern "C" {
@@ -334,7 +334,7 @@ bool spi_bus_lock_touch(spi_bus_lock_dev_handle_t dev_handle);
* - ESP_OK: on success
* - ESP_ERR_INVALID_ARG: timeout is not portMAX_DELAY
*/
esp_err_t spi_bus_lock_acquire_start(spi_bus_lock_dev_handle_t dev_handle, TickType_t wait);
esp_err_t spi_bus_lock_acquire_start(spi_bus_lock_dev_handle_t dev_handle, uint32_t wait);
/**
* Release the bus acquired. Will pass the acquiring processor to other blocked
@@ -395,7 +395,7 @@ esp_err_t spi_bus_lock_bg_request(spi_bus_lock_dev_handle_t dev_handle);
* - ESP_ERR_INVALID_STATE: The device is not the acquiring bus.
* - ESP_ERR_INVALID_ARG: Timeout is not portMAX_DELAY.
*/
esp_err_t spi_bus_lock_wait_bg_done(spi_bus_lock_dev_handle_t dev_handle, TickType_t wait);
esp_err_t spi_bus_lock_wait_bg_done(spi_bus_lock_dev_handle_t dev_handle, uint32_t wait);
/**
* Handle interrupt and closure of last operation. Should be called at the beginning of the ISR,
@@ -437,7 +437,7 @@ bool spi_bus_lock_bg_entry(spi_bus_lock_handle_t lock);
* @return false if retry is required, indicating that there is pending BG request.
* otherwise true and quit ISR is allowed.
*/
bool spi_bus_lock_bg_exit(spi_bus_lock_handle_t lock, bool wip, BaseType_t* do_yield);
bool spi_bus_lock_bg_exit(spi_bus_lock_handle_t lock, bool wip, int* do_yield);
/**
* Check whether there is device asking for the acquiring device, and the desired
components/esp_hw_support/include/soc/esp32s3/soc_memprot_types.h
+1 -2
View File
@@ -1,5 +1,5 @@
/*
* SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
* SPDX-FileCopyrightText: 2021-2025 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
@@ -14,7 +14,6 @@
#include <stdint.h>
#include <stdbool.h>
#include "soc/soc.h"
#include "freertos/FreeRTOSConfig.h"
#ifdef __cplusplus
extern "C" {
components/esp_hw_support/power_supply/include/esp_vbat.h
+1 -2
View File
@@ -7,7 +7,6 @@
#pragma once
#include "sdkconfig.h"
#include "freertos/FreeRTOS.h"
#include "esp_err.h"
#ifdef __cplusplus
@@ -32,7 +31,7 @@ typedef enum {
* - ESP_FAIL: Called in ISR context
* - ESP_ERR_TIMEOUT: Timeout waiting for battery charging to complete
*/
esp_err_t esp_vbat_wait_battery_charge_done(TickType_t checking_period);
esp_err_t esp_vbat_wait_battery_charge_done(uint32_t checking_period);
#endif
/**
components/esp_hw_support/power_supply/vbat.c
+1 -1
View File
@@ -120,7 +120,7 @@ IRAM_ATTR static void vbat_isr_handler(void *arg)
}
#if CONFIG_ESP_VBAT_USE_RECHARGEABLE_BATTERY
esp_err_t esp_vbat_wait_battery_charge_done(TickType_t checking_period)
esp_err_t esp_vbat_wait_battery_charge_done(uint32_t checking_period)
{
BaseType_t ret;
if (!xPortInIsrContext()) {
components/esp_hw_support/spi_bus_lock.c
+4 -4
View File
@@ -721,7 +721,7 @@ IRAM_ATTR bool spi_bus_lock_touch(spi_bus_lock_dev_handle_t dev_handle)
/*******************************************************************************
* Acquiring service
******************************************************************************/
IRAM_ATTR esp_err_t spi_bus_lock_acquire_start(spi_bus_lock_dev_t *dev_handle, TickType_t wait)
IRAM_ATTR esp_err_t spi_bus_lock_acquire_start(spi_bus_lock_dev_t *dev_handle, uint32_t wait)
{
ESP_RETURN_ON_FALSE_ISR(wait == portMAX_DELAY, ESP_ERR_INVALID_ARG, TAG, "timeout other than portMAX_DELAY not supported");
@@ -774,9 +774,9 @@ SPI_BUS_LOCK_ISR_ATTR bool spi_bus_lock_bg_entry(spi_bus_lock_t* lock)
return bg_entry_core(lock);
}
SPI_BUS_LOCK_ISR_ATTR bool spi_bus_lock_bg_exit(spi_bus_lock_t* lock, bool wip, BaseType_t* do_yield)
SPI_BUS_LOCK_ISR_ATTR bool spi_bus_lock_bg_exit(spi_bus_lock_t* lock, bool wip, int* do_yield)
{
return bg_exit_core(lock, wip, do_yield);
return bg_exit_core(lock, wip, (BaseType_t*)do_yield);
}
SPI_BUSLOCK_ATTR esp_err_t spi_bus_lock_bg_request(spi_bus_lock_dev_t *dev_handle)
@@ -785,7 +785,7 @@ SPI_BUSLOCK_ATTR esp_err_t spi_bus_lock_bg_request(spi_bus_lock_dev_t *dev_handl
return ESP_OK;
}
IRAM_ATTR esp_err_t spi_bus_lock_wait_bg_done(spi_bus_lock_dev_handle_t dev_handle, TickType_t wait)
IRAM_ATTR esp_err_t spi_bus_lock_wait_bg_done(spi_bus_lock_dev_handle_t dev_handle, uint32_t wait)
{
spi_bus_lock_t *lock = dev_handle->parent;
components/esp_lcd/spi/esp_lcd_panel_io_spi.c
+1
View File
@@ -24,6 +24,7 @@
#include "esp_log.h"
#include "esp_check.h"
#include "esp_lcd_common.h"
#include "freertos/FreeRTOS.h"
static const char *TAG = "lcd_panel.io.spi";
components/esp_system/startup_funcs.c
+1
View File
@@ -25,6 +25,7 @@
#include "hal/wdt_hal.h"
#include "hal/uart_types.h"
#include "hal/uart_ll.h"
#include "freertos/FreeRTOS.h"
#if CONFIG_SW_COEXIST_ENABLE || CONFIG_EXTERNAL_COEX_ENABLE
#include "private/esp_coexist_internal.h"
components/sdmmc/include/esp_private/sdmmc_common.h
-2
View File
@@ -20,8 +20,6 @@
#include "esp_log.h"
#include "esp_check.h"
#include "esp_heap_caps.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "sd_protocol_defs.h"
#include "sd_protocol_types.h"
#include "sdmmc_cmd.h"
components/sdmmc/include/sd_protocol_types.h
+1 -2
View File
@@ -26,7 +26,6 @@
#include <stdint.h>
#include <stddef.h>
#include "esp_err.h"
#include "freertos/FreeRTOS.h"
#include "sd_pwr_ctrl.h"
#include "esp_dma_utils.h"
#include "hal/sd_types.h"
@@ -218,7 +217,7 @@ typedef struct {
esp_err_t (*deinit_p)(int slot); /*!< host function to deinitialize the driver, called with the `slot` */
};
esp_err_t (*io_int_enable)(int slot); /*!< Host function to enable SDIO interrupt line */
esp_err_t (*io_int_wait)(int slot, TickType_t timeout_ticks); /*!< Host function to wait for SDIO interrupt line to be active */
esp_err_t (*io_int_wait)(int slot, uint32_t timeout_ticks); /*!< Host function to wait for SDIO interrupt line to be active */
int command_timeout_ms; /*!< timeout, in milliseconds, of a single command. Set to 0 to use the default value. */
esp_err_t (*get_real_freq)(int slot, int* real_freq); /*!< Host function to provide real working freq, based on SDMMC controller setup */
sdmmc_delay_phase_t input_delay_phase; /*!< input delay phase, this will only take into effect when the host works in SDMMC_FREQ_HIGHSPEED or SDMMC_FREQ_52M. Driver will print out how long the delay is*/
components/sdmmc/include/sdmmc_cmd.h
+1 -1
View File
@@ -317,7 +317,7 @@ esp_err_t sdmmc_io_enable_int(sdmmc_card_t* card);
* IO interrupts
* - ESP_ERR_TIMEOUT if the interrupt does not happen in timeout_ticks
*/
esp_err_t sdmmc_io_wait_int(sdmmc_card_t* card, TickType_t timeout_ticks);
esp_err_t sdmmc_io_wait_int(sdmmc_card_t* card, uint32_t timeout_ticks);
/**
* Get the data of CIS region of an SDIO card.
components/sdmmc/sdmmc_cmd.c
+1
View File
@@ -5,6 +5,7 @@
*/
#include <inttypes.h>
#include "freertos/FreeRTOS.h"
#include "esp_private/sdmmc_common.h"
static const char* TAG = "sdmmc_cmd";
components/sdmmc/sdmmc_common.c
+1
View File
@@ -17,6 +17,7 @@
#include <inttypes.h>
#include "esp_log.h"
#include "freertos/FreeRTOS.h"
#include "esp_timer.h"
#include "esp_private/sdmmc_common.h"
components/sdmmc/sdmmc_io.c
+2 -1
View File
@@ -17,6 +17,7 @@
#include <inttypes.h>
#include "esp_private/sdmmc_common.h"
#include "freertos/FreeRTOS.h"
#include "esp_attr.h"
#include "esp_compiler.h"
@@ -497,7 +498,7 @@ esp_err_t sdmmc_io_enable_int(sdmmc_card_t* card)
return (*card->host.io_int_enable)(card->host.slot);
}
esp_err_t sdmmc_io_wait_int(sdmmc_card_t* card, TickType_t timeout_ticks)
esp_err_t sdmmc_io_wait_int(sdmmc_card_t* card, uint32_t timeout_ticks)
{
if (card->host.io_int_wait == NULL) {
return ESP_ERR_NOT_SUPPORTED;
components/sdmmc/sdmmc_sd.c
+1
View File
@@ -20,6 +20,7 @@
#include "esp_timer.h"
#include "esp_cache.h"
#include "esp_private/sdmmc_common.h"
#include "freertos/FreeRTOS.h"
#define SDMMC_DELAY_NUMS_MAX 10
components/spi_flash/esp_flash_api.c
+1
View File
@@ -24,6 +24,7 @@
#include "esp_check.h"
#include "hal/efuse_hal.h"
#include "soc/chip_revision.h"
#include "esp_cpu.h"
#if CONFIG_IDF_TARGET_ESP32S2
#include "esp_crypto_lock.h" // for locking flash encryption peripheral