diff --git a/bsp/rockchip/dm/clk/clk-rk-gate.h b/bsp/rockchip/dm/clk/clk-rk-gate.h index c4d91072add..d05069b4e78 100755 --- a/bsp/rockchip/dm/clk/clk-rk-gate.h +++ b/bsp/rockchip/dm/clk/clk-rk-gate.h @@ -28,17 +28,17 @@ } #define GATE_NO_SET_RATE(_id, cname, pname, f, o, b, gf) \ -(void *)&(struct rockchip_clk_cell) \ -{ \ - .cell.name = cname, \ - .cell.ops = &rockchip_gate_clk_ops, \ - .cell.parent_name = pname, \ - .cell.parents_nr = 1, \ - .cell.flags = f | RT_CLK_F_SET_RATE_PARENT, \ - .id = _id, \ - .gate_offset = o, \ - .gate_shift = b, \ - .gate_flags = gf, \ +(void *)&(struct rockchip_clk_cell) \ +{ \ + .cell.name = cname, \ + .cell.ops = &rockchip_gate_clk_ops, \ + .cell.parent_name = pname, \ + .cell.parents_nr = 1, \ + .cell.flags = (f) & ~RT_CLK_F_SET_RATE_PARENT, \ + .id = _id, \ + .gate_offset = o, \ + .gate_shift = b, \ + .gate_flags = gf, \ } extern const struct rt_clk_ops rockchip_gate_clk_ops; diff --git a/bsp/rockchip/dm/regulator/regulator-rk8xx.c b/bsp/rockchip/dm/regulator/regulator-rk8xx.c index 3a0c6250a46..7977f462895 100755 --- a/bsp/rockchip/dm/regulator/regulator-rk8xx.c +++ b/bsp/rockchip/dm/regulator/regulator-rk8xx.c @@ -1115,6 +1115,7 @@ static rt_err_t append_rk8xx_regulator(struct rk8xx *rk8xx, struct rt_ofw_node * rgp = &rk8xx_reg->parent; rgp->ops = rk8xx_reg->desc->ops; rgp->param = &rk8xx_reg->param; + rgp->supply_name = rgp->param->name; rgp->dev = &rk8xx_reg->device; rgp->dev->ofw_node = np; diff --git a/bsp/rockchip/rk3500/.config b/bsp/rockchip/rk3500/.config index 4ec0c9be97e..ab1359d1cb1 100644 --- a/bsp/rockchip/rk3500/.config +++ b/bsp/rockchip/rk3500/.config @@ -252,7 +252,31 @@ CONFIG_DFS_USING_POSIX=y CONFIG_DFS_USING_WORKDIR=y CONFIG_DFS_FD_MAX=512 CONFIG_RT_USING_DFS_V2=y -# CONFIG_RT_USING_DFS_ELMFAT is not set +CONFIG_RT_USING_DFS_ELMFAT=y + +# +# elm-chan's FatFs, Generic FAT Filesystem Module +# +CONFIG_RT_DFS_ELM_CODE_PAGE=437 +CONFIG_RT_DFS_ELM_WORD_ACCESS=y +# CONFIG_RT_DFS_ELM_USE_LFN_0 is not set +# CONFIG_RT_DFS_ELM_USE_LFN_1 is not set +# CONFIG_RT_DFS_ELM_USE_LFN_2 is not set +CONFIG_RT_DFS_ELM_USE_LFN_3=y +CONFIG_RT_DFS_ELM_USE_LFN=3 +CONFIG_RT_DFS_ELM_LFN_UNICODE_0=y +# CONFIG_RT_DFS_ELM_LFN_UNICODE_1 is not set +# CONFIG_RT_DFS_ELM_LFN_UNICODE_2 is not set +# CONFIG_RT_DFS_ELM_LFN_UNICODE_3 is not set +CONFIG_RT_DFS_ELM_LFN_UNICODE=0 +CONFIG_RT_DFS_ELM_MAX_LFN=255 +CONFIG_RT_DFS_ELM_DRIVES=4 +CONFIG_RT_DFS_ELM_MAX_SECTOR_SIZE=512 +# CONFIG_RT_DFS_ELM_USE_ERASE is not set +# CONFIG_RT_DFS_ELM_REENTRANT is not set +CONFIG_RT_DFS_ELM_USE_EXFAT=y +# end of elm-chan's FatFs, Generic FAT Filesystem Module + CONFIG_RT_USING_DFS_DEVFS=y # CONFIG_RT_USING_DFS_ROMFS is not set CONFIG_RT_USING_DFS_PTYFS=y diff --git a/bsp/rockchip/rk3500/rtconfig.h b/bsp/rockchip/rk3500/rtconfig.h index 3ba507746d1..4905a15a983 100644 --- a/bsp/rockchip/rk3500/rtconfig.h +++ b/bsp/rockchip/rk3500/rtconfig.h @@ -170,6 +170,21 @@ #define DFS_USING_WORKDIR #define DFS_FD_MAX 512 #define RT_USING_DFS_V2 +#define RT_USING_DFS_ELMFAT + +/* elm-chan's FatFs, Generic FAT Filesystem Module */ + +#define RT_DFS_ELM_CODE_PAGE 437 +#define RT_DFS_ELM_WORD_ACCESS +#define RT_DFS_ELM_USE_LFN_3 +#define RT_DFS_ELM_USE_LFN 3 +#define RT_DFS_ELM_LFN_UNICODE_0 +#define RT_DFS_ELM_LFN_UNICODE 0 +#define RT_DFS_ELM_MAX_LFN 255 +#define RT_DFS_ELM_DRIVES 4 +#define RT_DFS_ELM_MAX_SECTOR_SIZE 512 +#define RT_DFS_ELM_USE_EXFAT +/* end of elm-chan's FatFs, Generic FAT Filesystem Module */ #define RT_USING_DFS_DEVFS #define RT_USING_DFS_PTYFS #define RT_USING_DFS_PROCFS diff --git a/bsp/stm32/libraries/HAL_Drivers/drivers/drv_hard_i2c.c b/bsp/stm32/libraries/HAL_Drivers/drivers/drv_hard_i2c.c index 424adaf0c4e..7f571945ff5 100644 --- a/bsp/stm32/libraries/HAL_Drivers/drivers/drv_hard_i2c.c +++ b/bsp/stm32/libraries/HAL_Drivers/drivers/drv_hard_i2c.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2006-2023, RT-Thread Development Team + * Copyright (c) 2006-2024, RT-Thread Development Team * * SPDX-License-Identifier: Apache-2.0 * @@ -8,18 +8,21 @@ * 2024-02-17 Dyyt587 first version * 2024-04-23 Zeidan fix bugs, test on STM32F429IGTx * 2024-12-10 zzk597 add support for STM32F1 series + * 2024-06-23 wdfk-prog Add blocking modes and distinguish POLL,INT,DMA modes */ #include "drv_hard_i2c.h" -/* not fully support for I2C4 */ -#if defined(BSP_USING_HARD_I2C1) || defined(BSP_USING_HARD_I2C2) || defined(BSP_USING_HARD_I2C3) +#if defined(BSP_HARDWARE_I2C) -//#define DRV_DEBUG +// #define DRV_DEBUG #define LOG_TAG "drv.i2c.hw" #include -enum +/* only buffer length >= DMA_TRANS_MIN_LEN will use DMA mode */ +#define DMA_TRANS_MIN_LEN 2 + +typedef enum { #ifdef BSP_USING_HARD_I2C1 I2C1_INDEX, @@ -30,7 +33,10 @@ enum #ifdef BSP_USING_HARD_I2C3 I2C3_INDEX, #endif /* BSP_USING_HARD_I2C3 */ -}; +#ifdef BSP_USING_HARD_I2C4 + I2C4_INDEX, +#endif /* BSP_USING_HARD_I2C4 */ +}i2c_index_t; static struct stm32_i2c_config i2c_config[] = { @@ -43,6 +49,9 @@ static struct stm32_i2c_config i2c_config[] = #ifdef BSP_USING_HARD_I2C3 I2C3_BUS_CONFIG, #endif /* BSP_USING_HARD_I2C3 */ +#ifdef BSP_USING_HARD_I2C4 + I2C4_BUS_CONFIG, +#endif /* BSP_USING_HARD_I2C4 */ }; static struct stm32_i2c i2c_objs[sizeof(i2c_config) / sizeof(i2c_config[0])] = {0}; @@ -55,15 +64,14 @@ static rt_err_t stm32_i2c_init(struct stm32_i2c *i2c_drv) struct stm32_i2c_config *cfg = i2c_drv->config; rt_memset(i2c_handle, 0, sizeof(I2C_HandleTypeDef)); - i2c_handle->Instance = cfg->Instance; #if defined(SOC_SERIES_STM32H7) i2c_handle->Init.Timing = cfg->timing; -#endif /* defined(SOC_SERIES_STM32H7) */ -#if defined(SOC_SERIES_STM32F1) || defined(SOC_SERIES_STM32F4) + i2c_handle->Init.OwnAddress2Masks = I2C_OA2_NOMASK; +#else i2c_handle->Init.ClockSpeed = 100000; i2c_handle->Init.DutyCycle = I2C_DUTYCYCLE_2; -#endif /* defined(SOC_SERIES_STM32F1) || defined(SOC_SERIES_STM32F4) */ +#endif /* defined(SOC_SERIES_STM32H7) */ i2c_handle->Init.OwnAddress1 = 0; i2c_handle->Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT; i2c_handle->Init.DualAddressMode = I2C_DUALADDRESS_DISABLE; @@ -92,8 +100,9 @@ static rt_err_t stm32_i2c_init(struct stm32_i2c *i2c_drv) return -RT_EFAULT; } #endif /* defined(SOC_SERIES_STM32H7) */ +#if defined(BSP_I2C_RX_USING_DMA) /* I2C2 DMA Init */ - if (i2c_drv->i2c_dma_flag & I2C_USING_RX_DMA_FLAG) + if (i2c_drv->i2c_dma_flag & RT_DEVICE_FLAG_DMA_RX) { HAL_DMA_Init(&i2c_drv->dma.handle_rx); @@ -103,8 +112,9 @@ static rt_err_t stm32_i2c_init(struct stm32_i2c *i2c_drv) HAL_NVIC_SetPriority(i2c_drv->config->dma_rx->dma_irq, 0, 0); HAL_NVIC_EnableIRQ(i2c_drv->config->dma_rx->dma_irq); } - - if (i2c_drv->i2c_dma_flag & I2C_USING_TX_DMA_FLAG) +#endif /* defined(BSP_I2C_RX_USING_DMA) */ +#if defined(BSP_I2C_TX_USING_DMA) + if (i2c_drv->i2c_dma_flag & RT_DEVICE_FLAG_DMA_TX) { HAL_DMA_Init(&i2c_drv->dma.handle_tx); @@ -114,13 +124,19 @@ static rt_err_t stm32_i2c_init(struct stm32_i2c *i2c_drv) HAL_NVIC_SetPriority(i2c_drv->config->dma_tx->dma_irq, 1, 0); HAL_NVIC_EnableIRQ(i2c_drv->config->dma_tx->dma_irq); } - - /* In the data transfer function stm32_i2c_master_xfer(), the IT transfer function - HAL_I2C_Master_Seq_Transmit_IT() is used when DMA is not used, so the IT interrupt - must be enable anyway, regardless of the DMA configuration, otherwise - the rt_completion_wait() will always timeout. */ - HAL_NVIC_SetPriority(i2c_drv->config->evirq_type, 2, 0); - HAL_NVIC_EnableIRQ(i2c_drv->config->evirq_type); +#endif /* defined(BSP_I2C_TX_USING_DMA) */ +#if defined(BSP_I2C_USING_IRQ) + if ((i2c_drv->i2c_dma_flag & RT_DEVICE_FLAG_DMA_TX || i2c_drv->i2c_dma_flag & RT_DEVICE_FLAG_DMA_RX) + || (i2c_drv->i2c_dma_flag & RT_DEVICE_FLAG_INT_TX || i2c_drv->i2c_dma_flag & RT_DEVICE_FLAG_INT_RX)) + { + /* In the data transfer function stm32_i2c_master_xfer(), the IT transfer function + HAL_I2C_Master_Seq_Transmit_IT() is used when DMA is not used, so the IT interrupt + must be enable anyway, regardless of the DMA configuration, otherwise + the rt_completion_wait() will always timeout. */ + HAL_NVIC_SetPriority(i2c_drv->config->evirq_type, 2, 0); + HAL_NVIC_EnableIRQ(i2c_drv->config->evirq_type); + } +#endif /* defined(BSP_I2C_USING_IRQ) */ return RT_EOK; } @@ -132,6 +148,171 @@ static rt_err_t stm32_i2c_configure(struct rt_i2c_bus_device *bus) return stm32_i2c_init(i2c_drv); } + +/** + * @brief Start one master receive transfer and report whether wait is required. + * @param i2c_obj Pointer to the STM32 I2C driver object. + * @param handle Pointer to the HAL I2C handle. + * @param msg Pointer to the RT-Thread I2C message descriptor. + * @param mode HAL sequential transfer mode. + * @param timeout Timeout in RT-Thread ticks for polling transfer. + * @param need_wait Output flag set to RT_TRUE when IT/DMA path is used. + * @return HAL status returned by the selected HAL receive API. + * @retval HAL_OK Transfer start succeeded. + * @retval HAL_ERROR Transfer start failed or no receive backend is enabled. + */ +static HAL_StatusTypeDef stm32_i2c_master_receive_start(struct stm32_i2c *i2c_obj, + I2C_HandleTypeDef *handle, + struct rt_i2c_msg *msg, + uint32_t mode, + rt_uint32_t timeout, + rt_bool_t *need_wait) +{ + RT_UNUSED(i2c_obj); + RT_UNUSED(mode); + RT_UNUSED(timeout); + RT_ASSERT(i2c_obj != RT_NULL); + RT_ASSERT(handle != RT_NULL); + RT_ASSERT(msg != RT_NULL); + RT_ASSERT(need_wait != RT_NULL); + + *need_wait = RT_FALSE; + +#if defined(BSP_I2C_RX_USING_DMA) + if ((i2c_obj->i2c_dma_flag & RT_DEVICE_FLAG_DMA_RX) && (msg->len >= DMA_TRANS_MIN_LEN)) + { + *need_wait = RT_TRUE; + return HAL_I2C_Master_Seq_Receive_DMA(handle, (msg->addr << 1), msg->buf, msg->len, mode); + } +#endif /* defined(BSP_I2C_RX_USING_DMA) */ + +#if defined(BSP_I2C_RX_USING_INT) + if (i2c_obj->i2c_dma_flag & RT_DEVICE_FLAG_INT_RX) + { + *need_wait = RT_TRUE; + return HAL_I2C_Master_Seq_Receive_IT(handle, (msg->addr << 1), msg->buf, msg->len, mode); + } +#endif /* defined(BSP_I2C_RX_USING_INT) */ + +#if defined(BSP_I2C_RX_USING_POLL) + return HAL_I2C_Master_Receive(handle, (msg->addr << 1), msg->buf, msg->len, timeout); +#else + return HAL_ERROR; +#endif /* defined(BSP_I2C_RX_USING_POLL) */ +} + +/** + * @brief Start one master transmit transfer and report whether wait is required. + * @param i2c_obj Pointer to the STM32 I2C driver object. + * @param handle Pointer to the HAL I2C handle. + * @param msg Pointer to the RT-Thread I2C message descriptor. + * @param mode HAL sequential transfer mode. + * @param timeout Timeout in RT-Thread ticks for polling transfer. + * @param need_wait Output flag set to RT_TRUE when IT/DMA path is used. + * @return HAL status returned by the selected HAL transmit API. + * @retval HAL_OK Transfer start succeeded. + * @retval HAL_ERROR Transfer start failed or no transmit backend is enabled. + */ +static HAL_StatusTypeDef stm32_i2c_master_transmit_start(struct stm32_i2c *i2c_obj, + I2C_HandleTypeDef *handle, + struct rt_i2c_msg *msg, + uint32_t mode, + rt_uint32_t timeout, + rt_bool_t *need_wait) +{ + RT_UNUSED(i2c_obj); + RT_UNUSED(mode); + RT_UNUSED(timeout); + RT_ASSERT(i2c_obj != RT_NULL); + RT_ASSERT(handle != RT_NULL); + RT_ASSERT(msg != RT_NULL); + RT_ASSERT(need_wait != RT_NULL); + + *need_wait = RT_FALSE; + +#if defined(BSP_I2C_TX_USING_DMA) + if ((i2c_obj->i2c_dma_flag & RT_DEVICE_FLAG_DMA_TX) && (msg->len >= DMA_TRANS_MIN_LEN)) + { + *need_wait = RT_TRUE; + return HAL_I2C_Master_Seq_Transmit_DMA(handle, (msg->addr << 1), msg->buf, msg->len, mode); + } +#endif /* defined(BSP_I2C_TX_USING_DMA) */ + +#if defined(BSP_I2C_TX_USING_INT) + if (i2c_obj->i2c_dma_flag & RT_DEVICE_FLAG_INT_TX) + { + *need_wait = RT_TRUE; + return HAL_I2C_Master_Seq_Transmit_IT(handle, (msg->addr << 1), msg->buf, msg->len, mode); + } +#endif /* defined(BSP_I2C_TX_USING_INT) */ + +#if defined(BSP_I2C_TX_USING_POLL) + return HAL_I2C_Master_Transmit(handle, (msg->addr << 1), msg->buf, msg->len, timeout); +#else + return HAL_ERROR; +#endif /* defined(BSP_I2C_TX_USING_POLL) */ +} + +/** + * @brief Compute HAL transfer mode for the current message in a sequence. + * @param index Index of the current message. + * @param msg Pointer to the current I2C message. + * @param next_msg Pointer to the next I2C message, or RT_NULL for the last one. + * @param is_last RT_TRUE when the current message is the last frame. + * @return HAL sequential transfer option used by the message. + * @retval I2C_FIRST_AND_NEXT_FRAME Continue transfer without repeated start. + * @retval I2C_LAST_FRAME_NO_STOP Keep bus active for following frame semantics. + * @retval I2C_LAST_FRAME End transfer with the last frame behavior. + */ +static uint32_t stm32_i2c_get_xfer_mode(rt_int32_t index, + struct rt_i2c_msg *msg, + struct rt_i2c_msg *next_msg, + rt_bool_t is_last) +{ + if (is_last) + { + if (msg->flags & RT_I2C_NO_STOP) + { + return I2C_LAST_FRAME_NO_STOP; + } + + return I2C_LAST_FRAME; + } + + if (next_msg->flags & RT_I2C_NO_START) + { + if ((next_msg->flags & RT_I2C_RD) == (msg->flags & RT_I2C_RD)) + { + /* The same mode, can use no start */ + return I2C_FIRST_AND_NEXT_FRAME; + } + + /* Not allowed to use no start, sending address is required when changing direction, user setting error */ + LOG_W("user set flags error msg[%d] flags RT_I2C_NO_START has canceled", index + 1); + } + + return I2C_LAST_FRAME_NO_STOP; +} + +/** + * @brief Convert HAL transfer mode value to a readable log string. + * @param mode HAL sequential transfer option. + * @return Constant string for logging. + */ +const char *stm32_i2c_mode_name(uint32_t mode) +{ + switch (mode) + { + case I2C_FIRST_AND_NEXT_FRAME: + return "I2C_FIRST_AND_NEXT_FRAME"; + case I2C_LAST_FRAME_NO_STOP: + return "I2C_FIRST_FRAME/I2C_LAST_FRAME_NO_STOP"; + case I2C_LAST_FRAME: + return "I2C_LAST_FRAME"; + default: + return "unknown mode"; + } +} /** * @brief Hardware I2C driver transfer * @@ -144,185 +325,126 @@ static rt_ssize_t stm32_i2c_master_xfer(struct rt_i2c_bus_device *bus, struct rt_i2c_msg msgs[], rt_uint32_t num) { - /* for stm32 dma may more stability */ -#define DMA_TRANS_MIN_LEN 2 /* only buffer length >= DMA_TRANS_MIN_LEN will use DMA mode */ -#define TRANS_TIMEOUT_PERSEC 8 /* per ms will trans nums bytes */ - - rt_int32_t i, ret; - struct rt_i2c_msg *msg = msgs; - struct rt_i2c_msg *next_msg = 0; + rt_uint32_t i = 0; + rt_int32_t ret = 0; + struct rt_i2c_msg *msg = RT_NULL; + struct rt_i2c_msg *next_msg = RT_NULL; struct stm32_i2c *i2c_obj; + rt_bool_t is_last = RT_FALSE; uint32_t mode = 0; - uint8_t next_flag = 0; - struct rt_completion *completion; rt_uint32_t timeout; - if (num == 0) { return 0; } RT_ASSERT((msgs != RT_NULL) && (bus != RT_NULL)); - i2c_obj = rt_container_of(bus, struct stm32_i2c, i2c_bus); - completion = &i2c_obj->completion; + RT_ASSERT(i2c_obj != RT_NULL); I2C_HandleTypeDef *handle = &i2c_obj->handle; + RT_ASSERT(handle != RT_NULL); +#if defined(BSP_I2C_USING_IRQ) + struct rt_completion *completion; + completion = &i2c_obj->completion; +#endif /* defined(BSP_I2C_USING_IRQ) */ + LOG_D("xfer start %d megs", num); + + rt_uint32_t freq_khz = bus->config.usage_freq / 1000; + if (freq_khz == 0) + { + freq_khz = 1; + } - LOG_D("xfer start %d mags", num); - for (i = 0; i < (num - 1); i++) + for (i = 0; i < num; i++) { - mode = 0; + rt_bool_t need_wait = RT_FALSE; msg = &msgs[i]; + is_last = (i == (num - 1)); + next_msg = is_last ? RT_NULL : &msgs[i + 1]; + mode = stm32_i2c_get_xfer_mode(i, msg, next_msg, is_last); LOG_D("xfer msgs[%d] addr=0x%2x buf=0x%x len= 0x%x flags= 0x%x", i, msg->addr, msg->buf, msg->len, msg->flags); - next_msg = &msgs[i + 1]; - next_flag = next_msg->flags; - timeout = msg->len/TRANS_TIMEOUT_PERSEC + 5; - if (next_flag & RT_I2C_NO_START) - { - if ((next_flag & RT_I2C_RD) == (msg->flags & RT_I2C_RD)) - { /* The same mode, can use no start */ - mode = I2C_FIRST_AND_NEXT_FRAME; - } - else - { - /* Not allowed to use no start, sending address is required when changing direction, user setting error */ - LOG_W("user set flags error msg[%d] flags RT_I2C_NO_START has canceled", i + 1); - mode = I2C_LAST_FRAME_NO_STOP; - } - } - else - { - mode = I2C_LAST_FRAME_NO_STOP; - } + + // timeout= data_time + dev_addr_time + reserve_time + timeout = (msg->len * 8) / freq_khz + 1 + 5; if (msg->flags & RT_I2C_RD) { - LOG_D("xfer rec msgs[%d] hal mode = %s", i, mode == I2C_FIRST_AND_NEXT_FRAME ? "I2C_FIRST_AND_NEXT_FRAME" : mode == I2C_LAST_FRAME_NO_STOP ? "I2C_FIRST_FRAME/I2C_LAST_FRAME_NO_STOP" - : mode == I2C_LAST_FRAME ? "I2C_LAST_FRAME" - : "nuknown mode"); - if ((i2c_obj->i2c_dma_flag & I2C_USING_RX_DMA_FLAG) && (msg->len >= DMA_TRANS_MIN_LEN)) + LOG_D("xfer rec msgs[%d] hal mode = %s", i, stm32_i2c_mode_name(mode)); + ret = stm32_i2c_master_receive_start(i2c_obj, handle, msg, mode, timeout, &need_wait); + if (ret != HAL_OK) { - ret = HAL_I2C_Master_Seq_Receive_DMA(handle, (msg->addr<<1), msg->buf, msg->len, mode); - } - else - { - ret = HAL_I2C_Master_Seq_Receive_IT(handle, (msg->addr<<1), msg->buf, msg->len, mode); - } - if (ret != RT_EOK) - { - LOG_E("[%s:%d]I2C Read error(%d)!\n", __func__, __LINE__, ret); + LOG_E("I2C[%s] Read error(%d)!\n", bus->parent.parent.name, ret); goto out; } - if (rt_completion_wait(completion, timeout) != RT_EOK) +#if defined(BSP_I2C_USING_IRQ) + if (need_wait) { - LOG_D("receive time out"); - goto out; - + ret = rt_completion_wait(completion, timeout); + if (ret != RT_EOK) + { + LOG_W("I2C[%s] receive wait failed %d, timeout %d", bus->parent.parent.name, ret, timeout); + goto out; + } } +#endif /* defined(BSP_I2C_USING_IRQ) */ } else { - LOG_D("xfer trans msgs[%d] hal mode = %s", i, mode == I2C_FIRST_AND_NEXT_FRAME ? "I2C_FIRST_AND_NEXT_FRAME" : mode == I2C_LAST_FRAME_NO_STOP ? "I2C_FIRST_FRAME/I2C_LAST_FRAME_NO_STOP" - : mode == I2C_LAST_FRAME ? "I2C_LAST_FRAME" - : "nuknown mode"); - if ((i2c_obj->i2c_dma_flag & I2C_USING_TX_DMA_FLAG) && (msg->len >= DMA_TRANS_MIN_LEN)) - { - ret = HAL_I2C_Master_Seq_Transmit_DMA(handle, (msg->addr<<1), msg->buf, msg->len, mode); - } - else + LOG_D("xfer trans msgs[%d] hal mode = %s", i, stm32_i2c_mode_name(mode)); + ret = stm32_i2c_master_transmit_start(i2c_obj, handle, msg, mode, timeout, &need_wait); + if (ret != HAL_OK) { - ret = HAL_I2C_Master_Seq_Transmit_IT(handle, (msg->addr<<1), msg->buf, msg->len, mode); - } - if (ret != RT_EOK) - { - LOG_D("[%s:%d]I2C Write error(%d)!\n", __func__, __LINE__, ret); + LOG_E("I2C[%s] Write error(%d)!\n", bus->parent.parent.name, ret); goto out; } - if (rt_completion_wait(completion, timeout) != RT_EOK) +#if defined(BSP_I2C_USING_IRQ) + if (need_wait) { - LOG_D("transmit time out"); - goto out; - + ret = rt_completion_wait(completion, timeout); + if (ret != RT_EOK) + { + LOG_W("I2C[%s] transmit wait failed %d, timeout %d", bus->parent.parent.name, ret, timeout); + goto out; + } } +#endif /* defined(BSP_I2C_USING_IRQ) */ } - LOG_D("xfer next msgs[%d] addr=0x%2x buf= 0x%x len= 0x%x flags = 0x%x\r\n", i + 1, next_msg->addr, next_msg->buf, next_msg->len, next_msg->flags); - } - /* last msg */ - msg = &msgs[i]; - timeout = msg->len/TRANS_TIMEOUT_PERSEC + 5; - if (msg->flags & RT_I2C_NO_STOP) - mode = I2C_LAST_FRAME_NO_STOP; - else - mode = I2C_LAST_FRAME; - LOG_D("xfer last msgs[%d] addr=0x%2x buf= 0x%x len= 0x%x flags = 0x%x", i, msg->addr, msg->buf, msg->len, msg->flags); - if (msg->flags & RT_I2C_RD) - { - LOG_D("xfer rec msgs[%d] hal mode=%s", i, mode == I2C_FIRST_AND_NEXT_FRAME ? "I2C_FIRST_AND_NEXT_FRAME" : mode == I2C_LAST_FRAME_NO_STOP ? "I2C_FIRST_FRAME/I2C_LAST_FRAME_NO_STOP" - : mode == I2C_LAST_FRAME ? "I2C_LAST_FRAME" - : "nuknown mode"); - if ((i2c_obj->i2c_dma_flag & I2C_USING_RX_DMA_FLAG) && (msg->len >= DMA_TRANS_MIN_LEN)) - { - ret = HAL_I2C_Master_Seq_Receive_DMA(handle, (msg->addr<<1), msg->buf, msg->len, mode); - } - else - { - ret = HAL_I2C_Master_Seq_Receive_IT(handle,(msg->addr<<1), msg->buf, msg->len, mode); - } - if (ret != RT_EOK) - { - LOG_D("[%s:%d]I2C Read error(%d)!\n", __func__, __LINE__, ret); - goto out; - } - if (rt_completion_wait(completion, timeout) != RT_EOK) + if (!is_last) { - LOG_D("receive time out"); - goto out; - } - } - else - { - LOG_D("xfer trans msgs[%d] hal mode = %s", i, mode == I2C_FIRST_AND_NEXT_FRAME ? "I2C_FIRST_AND_NEXT_FRAME" : mode == I2C_LAST_FRAME ? "I2C_LAST_FRAME" - : mode == I2C_LAST_FRAME_NO_STOP ? "I2C_FIRST_FRAME/I2C_LAST_FRAME_NO_STOP" - : "nuknown mode"); - if ((i2c_obj->i2c_dma_flag & I2C_USING_TX_DMA_FLAG) && (msg->len >= DMA_TRANS_MIN_LEN)) - { - ret = HAL_I2C_Master_Seq_Transmit_DMA(handle, (msg->addr<<1), msg->buf, msg->len, mode); - } - else - { - ret = HAL_I2C_Master_Seq_Transmit_IT(handle, (msg->addr<<1), msg->buf, msg->len, mode); - } - if (ret != RT_EOK) - { - LOG_D("[%s:%d]I2C Write error(%d)!\n", __func__, __LINE__, ret); - goto out; - } - if (rt_completion_wait(completion, timeout) != RT_EOK) - { - LOG_D("transmit time out"); - goto out; - + LOG_D("xfer next msgs[%d] addr=0x%2x buf= 0x%x len= 0x%x flags = 0x%x\r\n", i + 1, next_msg->addr, next_msg->buf, next_msg->len, next_msg->flags); } } ret = num; - LOG_D("xfer end %d mags\r\n", num); + LOG_D("xfer end %d megs\r\n", num); return ret; out: - if (handle->ErrorCode == HAL_I2C_ERROR_AF) + ret = i; + /* + * On STM32H7, STOPI only enables STOP-event interrupt handling. + * It does not actively generate a STOP condition on the bus. + * + * For non-H7 STM32 series, the legacy HAL error handler already + * generates a STOP condition on AF in master/memory modes, so + * this driver does not manually issue another STOP in the AF path. + */ + if (handle->ErrorCode & HAL_I2C_ERROR_AF) { - LOG_D("I2C NACK Error now stoped"); - /* Send stop signal to prevent bus lock-up */ + LOG_W("I2C[%s] NACK Error", bus->parent.parent.name); #if defined(SOC_SERIES_STM32H7) handle->Instance->CR1 |= I2C_IT_STOPI; -#endif /* defined(SOC_SERIES_STM32H7) */ +#endif /* defined(SOC_SERIES_STM32H7) */ } - if (handle->ErrorCode == HAL_I2C_ERROR_BERR) + if (handle->ErrorCode & HAL_I2C_ERROR_BERR) { - LOG_D("I2C BUS Error now stoped"); + LOG_W("I2C[%s] BUS Error", bus->parent.parent.name); +#if defined(SOC_SERIES_STM32H7) + handle->Instance->CR1 |= I2C_IT_STOPI; +#else handle->Instance->CR1 |= I2C_CR1_STOP; - ret=i-1; +#endif /* defined(SOC_SERIES_STM32H7) */ } + return ret; } @@ -330,7 +452,7 @@ static const struct rt_i2c_bus_device_ops stm32_i2c_ops = { .master_xfer = stm32_i2c_master_xfer, RT_NULL, - RT_NULL + RT_NULL, }; int RT_hw_i2c_bus_init(void) @@ -343,8 +465,8 @@ int RT_hw_i2c_bus_init(void) i2c_objs[i].i2c_bus.ops = &stm32_i2c_ops; i2c_objs[i].config = &i2c_config[i]; i2c_objs[i].i2c_bus.timeout = i2c_config[i].timeout; - - if ((i2c_objs[i].i2c_dma_flag & I2C_USING_RX_DMA_FLAG)) +#ifdef BSP_I2C_USING_DMA + if ((i2c_objs[i].i2c_dma_flag & RT_DEVICE_FLAG_DMA_RX)) { i2c_objs[i].dma.handle_rx.Instance = i2c_config[i].dma_rx->Instance; #if defined(SOC_SERIES_STM32F2) || defined(SOC_SERIES_STM32F4) || defined(SOC_SERIES_STM32F7) @@ -386,7 +508,8 @@ int RT_hw_i2c_bus_init(void) } } - if (i2c_objs[i].i2c_dma_flag & I2C_USING_TX_DMA_FLAG) +#ifdef BSP_I2C_USING_DMA + if (i2c_objs[i].i2c_dma_flag & RT_DEVICE_FLAG_DMA_TX) { i2c_objs[i].dma.handle_tx.Instance = i2c_config[i].dma_tx->Instance; #if defined(SOC_SERIES_STM32F2) || defined(SOC_SERIES_STM32F4) || defined(SOC_SERIES_STM32F7) @@ -405,10 +528,10 @@ int RT_hw_i2c_bus_init(void) #endif #if defined(SOC_SERIES_STM32F2) || defined(SOC_SERIES_STM32F4) || defined(SOC_SERIES_STM32F7) || defined(SOC_SERIES_STM32MP1) || defined(SOC_SERIES_STM32H7) - i2c_objs[i].dma.handle_tx.Init.FIFOMode = DMA_FIFOMODE_DISABLE; - i2c_objs[i].dma.handle_tx.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL; - i2c_objs[i].dma.handle_tx.Init.MemBurst = DMA_MBURST_INC4; - i2c_objs[i].dma.handle_tx.Init.PeriphBurst = DMA_PBURST_INC4; + i2c_objs[i].dma.handle_tx.Init.FIFOMode = DMA_FIFOMODE_DISABLE; + i2c_objs[i].dma.handle_tx.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL; + i2c_objs[i].dma.handle_tx.Init.MemBurst = DMA_MBURST_INC4; + i2c_objs[i].dma.handle_tx.Init.PeriphBurst = DMA_PBURST_INC4; #endif /* defined(SOC_SERIES_STM32F2) || defined(SOC_SERIES_STM32F4) || defined(SOC_SERIES_STM32F7) || defined(SOC_SERIES_STM32MP1) || defined(SOC_SERIES_STM32H7) */ { rt_uint32_t tmpreg = 0x00U; @@ -429,109 +552,185 @@ int RT_hw_i2c_bus_init(void) } } +#endif /* BSP_I2C_USING_DMA */ +#if defined(BSP_I2C_USING_IRQ) rt_completion_init(&i2c_objs[i].completion); - stm32_i2c_configure(&i2c_objs[i].i2c_bus); +#endif /* defined(BSP_I2C_USING_IRQ) */ + ret = stm32_i2c_configure(&i2c_objs[i].i2c_bus); + if (ret != RT_EOK) + { + LOG_E("%s bus configure failed %d", i2c_config[i].name, ret); + return -RT_ERROR; + } ret = rt_i2c_bus_device_register(&i2c_objs[i].i2c_bus, i2c_objs[i].config->name); - RT_ASSERT(ret == RT_EOK); - LOG_D("%s bus init done", i2c_config[i].name); + if(ret != RT_EOK) + { + LOG_E("%s bus init failed %d", i2c_config[i].name, ret); + } + else + { + LOG_D("%s bus init done", i2c_config[i].name); + } } return ret; } -static void stm32_get_dma_info(void) +static void stm32_get_info(void) { -#ifdef BSP_I2C1_RX_USING_DMA - i2c_objs[I2C1_INDEX].i2c_dma_flag |= I2C_USING_RX_DMA_FLAG; - static struct dma_config I2C1_dma_rx = I2C1_RX_DMA_CONFIG; - i2c_config[I2C1_INDEX].dma_rx = &I2C1_dma_rx; -#endif /* BSP_I2C1_RX_USING_DMA */ -#ifdef BSP_I2C1_TX_USING_DMA - i2c_objs[I2C1_INDEX].i2c_dma_flag |= I2C_USING_TX_DMA_FLAG; +#if defined(BSP_USING_HARD_I2C1) + i2c_objs[I2C1_INDEX].i2c_dma_flag = 0; + +#if defined (BSP_I2C1_TX_USING_INT) + i2c_objs[I2C1_INDEX].i2c_dma_flag |= RT_DEVICE_FLAG_INT_TX; +#elif defined(BSP_I2C1_TX_USING_DMA) + i2c_objs[I2C1_INDEX].i2c_dma_flag |= RT_DEVICE_FLAG_DMA_TX; static struct dma_config I2C1_dma_tx = I2C1_TX_DMA_CONFIG; i2c_config[I2C1_INDEX].dma_tx = &I2C1_dma_tx; -#endif /* BSP_I2C1_TX_USING_DMA */ +#endif /* defined (BSP_I2C1_TX_USING_INT) */ -#ifdef BSP_I2C2_RX_USING_DMA - i2c_objs[I2C2_INDEX].i2c_dma_flag |= I2C_USING_RX_DMA_FLAG; - static struct dma_config I2C2_dma_rx = I2C2_RX_DMA_CONFIG; - i2c_config[I2C2_INDEX].dma_rx = &I2C2_dma_rx; -#endif /* BSP_I2C2_RX_USING_DMA */ -#ifdef BSP_I2C2_TX_USING_DMA - i2c_objs[I2C2_INDEX].i2c_dma_flag |= I2C_USING_TX_DMA_FLAG; +#if defined (BSP_I2C1_RX_USING_INT) + i2c_objs[I2C1_INDEX].i2c_dma_flag |= RT_DEVICE_FLAG_INT_RX; +#elif defined(BSP_I2C1_RX_USING_DMA) + i2c_objs[I2C1_INDEX].i2c_dma_flag |= RT_DEVICE_FLAG_DMA_RX; + static struct dma_config I2C1_dma_rx = I2C1_RX_DMA_CONFIG; + i2c_config[I2C1_INDEX].dma_rx = &I2C1_dma_rx; +#endif /* defined (BSP_I2C1_RX_USING_INT) */ + +#endif /* defined(BSP_USING_HARD_I2C1) */ + +#if defined(BSP_USING_HARD_I2C2) + i2c_objs[I2C2_INDEX].i2c_dma_flag = 0; + +#if defined (BSP_I2C2_TX_USING_INT) + i2c_objs[I2C2_INDEX].i2c_dma_flag |= RT_DEVICE_FLAG_INT_TX; +#elif defined(BSP_I2C2_TX_USING_DMA) + i2c_objs[I2C2_INDEX].i2c_dma_flag |= RT_DEVICE_FLAG_DMA_TX; static struct dma_config I2C2_dma_tx = I2C2_TX_DMA_CONFIG; i2c_config[I2C2_INDEX].dma_tx = &I2C2_dma_tx; -#endif /* BSP_I2C2_TX_USING_DMA */ +#endif /* defined (BSP_I2C2_TX_USING_INT) */ -#ifdef BSP_I2C3_RX_USING_DMA - i2c_objs[I2C3_INDEX].i2c_dma_flag |= I2C_USING_RX_DMA_FLAG; - static struct dma_config I2C3_dma_rx = I2C3_RX_DMA_CONFIG; - i2c_config[I2C3_INDEX].dma_rx = &I2C3_dma_rx; -#endif /* BSP_I2C3_RX_USING_DMA */ -#ifdef BSP_I2C3_TX_USING_DMA - i2c_objs[I2C3_INDEX].i2c_dma_flag |= I2C_USING_TX_DMA_FLAG; +#if defined (BSP_I2C2_RX_USING_INT) + i2c_objs[I2C2_INDEX].i2c_dma_flag |= RT_DEVICE_FLAG_INT_RX; +#elif defined(BSP_I2C2_RX_USING_DMA) + i2c_objs[I2C2_INDEX].i2c_dma_flag |= RT_DEVICE_FLAG_DMA_RX; + static struct dma_config I2C2_dma_rx = I2C2_RX_DMA_CONFIG; + i2c_config[I2C2_INDEX].dma_rx = &I2C2_dma_rx; +#endif /* defined (BSP_I2C2_RX_USING_INT) */ + +#endif /* defined(BSP_USING_HARD_I2C2) */ + +#if defined(BSP_USING_HARD_I2C3) + i2c_objs[I2C3_INDEX].i2c_dma_flag = 0; + +#if defined (BSP_I2C3_TX_USING_INT) + i2c_objs[I2C3_INDEX].i2c_dma_flag |= RT_DEVICE_FLAG_INT_TX; +#elif defined(BSP_I2C3_TX_USING_DMA) + i2c_objs[I2C3_INDEX].i2c_dma_flag |= RT_DEVICE_FLAG_DMA_TX; static struct dma_config I2C3_dma_tx = I2C3_TX_DMA_CONFIG; i2c_config[I2C3_INDEX].dma_tx = &I2C3_dma_tx; -#endif /* BSP_I2C3_TX_USING_DMA */ +#endif /* defined (BSP_I2C3_TX_USING_INT) */ + +#if defined (BSP_I2C3_RX_USING_INT) + i2c_objs[I2C3_INDEX].i2c_dma_flag |= RT_DEVICE_FLAG_INT_RX; +#elif defined(BSP_I2C3_RX_USING_DMA) + i2c_objs[I2C3_INDEX].i2c_dma_flag |= RT_DEVICE_FLAG_DMA_RX; + static struct dma_config I2C3_dma_rx = I2C3_RX_DMA_CONFIG; + i2c_config[I2C3_INDEX].dma_rx = &I2C3_dma_rx; +#endif /* defined (BSP_I2C3_RX_USING_INT) */ + +#endif /* defined(BSP_USING_HARD_I2C3) */ + +#if defined(BSP_USING_HARD_I2C4) + i2c_objs[I2C4_INDEX].i2c_dma_flag = 0; + +#if defined (BSP_I2C4_TX_USING_INT) + i2c_objs[I2C4_INDEX].i2c_dma_flag |= RT_DEVICE_FLAG_INT_TX; +#elif defined(BSP_I2C4_TX_USING_DMA) + i2c_objs[I2C4_INDEX].i2c_dma_flag |= RT_DEVICE_FLAG_DMA_TX; + static struct dma_config I2C4_dma_tx = I2C4_TX_DMA_CONFIG; + i2c_config[I2C4_INDEX].dma_tx = &I2C4_dma_tx; +#endif /* defined (BSP_I2C4_TX_USING_INT) */ + +#if defined (BSP_I2C4_RX_USING_INT) + i2c_objs[I2C4_INDEX].i2c_dma_flag |= RT_DEVICE_FLAG_INT_RX; +#elif defined(BSP_I2C4_RX_USING_DMA) + i2c_objs[I2C4_INDEX].i2c_dma_flag |= RT_DEVICE_FLAG_DMA_RX; + static struct dma_config I2C4_dma_rx = I2C4_RX_DMA_CONFIG; + i2c_config[I2C4_INDEX].dma_rx = &I2C4_dma_rx; +#endif /* defined (BSP_I2C4_RX_USING_INT) */ + +#endif /* defined(BSP_USING_HARD_I2C4) */ } +#ifdef BSP_I2C_USING_IRQ void HAL_I2C_MasterTxCpltCallback(I2C_HandleTypeDef *hi2c) { struct stm32_i2c *i2c_drv = rt_container_of(hi2c, struct stm32_i2c, handle); rt_completion_done(&i2c_drv->completion); } + void HAL_I2C_MasterRxCpltCallback(I2C_HandleTypeDef *hi2c) { struct stm32_i2c *i2c_drv = rt_container_of(hi2c, struct stm32_i2c, handle); rt_completion_done(&i2c_drv->completion); } + void HAL_I2C_ErrorCallback(I2C_HandleTypeDef *hi2c) { + LOG_W("%s error code %d", hi2c->Instance == I2C1 ? "I2C1" + : hi2c->Instance == I2C2 ? "I2C2" + : hi2c->Instance == I2C3 ? "I2C3" +#ifdef I2C4 + : hi2c->Instance == I2C4 ? "I2C4" +#endif /* I2C4 */ + : "unknown", + hi2c->ErrorCode); #if defined(SOC_SERIES_STM32H7) /* Send stop signal to prevent bus lock-up */ if (hi2c->ErrorCode == HAL_I2C_ERROR_AF) { - LOG_D("I2C NACK Error now stoped"); + LOG_W("I2C NACK Error now stoped"); hi2c->Instance->CR1 |= I2C_IT_STOPI; } if (hi2c->ErrorCode == HAL_I2C_ERROR_BERR) { - LOG_D("I2C BUS Error now stoped"); + LOG_W("I2C BUS Error now stoped"); hi2c->Instance->CR1 |= I2C_IT_STOPI; } #endif /* defined(SOC_SERIES_STM32H7) */ - } + #ifdef BSP_USING_HARD_I2C1 /** - * @brief This function handles I2C2 event interrupt. + * @brief This function handles I2C1 event interrupt. */ void I2C1_EV_IRQHandler(void) { - /* USER CODE BEGIN I2C2_EV_IRQn 0 */ + /* USER CODE BEGIN I2C1_EV_IRQn 0 */ /* enter interrupt */ rt_interrupt_enter(); - /* USER CODE END I2C2_EV_IRQn 0 */ + /* USER CODE END I2C1_EV_IRQn 0 */ HAL_I2C_EV_IRQHandler(&i2c_objs[I2C1_INDEX].handle); - /* USER CODE BEGIN I2C2_EV_IRQn 1 */ + /* USER CODE BEGIN I2C1_EV_IRQn 1 */ /* leave interrupt */ rt_interrupt_leave(); - /* USER CODE END I2C2_EV_IRQn 1 */ + /* USER CODE END I2C1_EV_IRQn 1 */ } /** - * @brief This function handles I2C2 error interrupt. + * @brief This function handles I2C1 error interrupt. */ void I2C1_ER_IRQHandler(void) { - /* USER CODE BEGIN I2C2_ER_IRQn 0 */ + /* USER CODE BEGIN I2C1_ER_IRQn 0 */ /* enter interrupt */ rt_interrupt_enter(); - /* USER CODE END I2C2_ER_IRQn 0 */ + /* USER CODE END I2C1_ER_IRQn 0 */ HAL_I2C_ER_IRQHandler(&i2c_objs[I2C1_INDEX].handle); - /* USER CODE BEGIN I2C2_ER_IRQn 1 */ + /* USER CODE BEGIN I2C1_ER_IRQn 1 */ /* leave interrupt */ rt_interrupt_leave(); - /* USER CODE END I2C2_ER_IRQn 1 */ + /* USER CODE END I2C1_ER_IRQn 1 */ } #endif /* BSP_USING_HARD_I2C1 */ @@ -571,38 +770,74 @@ void I2C2_ER_IRQHandler(void) #ifdef BSP_USING_HARD_I2C3 /** - * @brief This function handles I2C2 event interrupt. + * @brief This function handles I2C3 event interrupt. */ void I2C3_EV_IRQHandler(void) { - /* USER CODE BEGIN I2C2_EV_IRQn 0 */ + /* USER CODE BEGIN I2C3_EV_IRQn 0 */ /* enter interrupt */ rt_interrupt_enter(); - /* USER CODE END I2C2_EV_IRQn 0 */ + /* USER CODE END I2C3_EV_IRQn 0 */ HAL_I2C_EV_IRQHandler(&i2c_objs[I2C3_INDEX].handle); - /* USER CODE BEGIN I2C2_EV_IRQn 1 */ + /* USER CODE BEGIN I2C3_EV_IRQn 1 */ /* leave interrupt */ rt_interrupt_leave(); - /* USER CODE END I2C2_EV_IRQn 1 */ + /* USER CODE END I2C3_EV_IRQn 1 */ } /** - * @brief This function handles I2C2 error interrupt. + * @brief This function handles I2C3 error interrupt. */ void I2C3_ER_IRQHandler(void) { - /* USER CODE BEGIN I2C2_ER_IRQn 0 */ + /* USER CODE BEGIN I2C3_ER_IRQn 0 */ /* enter interrupt */ rt_interrupt_enter(); - /* USER CODE END I2C2_ER_IRQn 0 */ + /* USER CODE END I2C3_ER_IRQn 0 */ HAL_I2C_ER_IRQHandler(&i2c_objs[I2C3_INDEX].handle); - /* USER CODE BEGIN I2C2_ER_IRQn 1 */ + /* USER CODE BEGIN I2C3_ER_IRQn 1 */ /* leave interrupt */ rt_interrupt_leave(); /* USER CODE END I2C2_ER_IRQn 1 */ } #endif /* BSP_USING_HARD_I2C3 */ +#ifdef BSP_USING_HARD_I2C4 +/** + * @brief This function handles I2C4 event interrupt. + */ +void I2C4_EV_IRQHandler(void) +{ + /* USER CODE BEGIN I2C4_EV_IRQn 0 */ + /* enter interrupt */ + rt_interrupt_enter(); + /* USER CODE END I2C4_EV_IRQn 0 */ + HAL_I2C_EV_IRQHandler(&i2c_objs[I2C4_INDEX].handle); + /* USER CODE BEGIN I2C4_EV_IRQn 1 */ + /* leave interrupt */ + rt_interrupt_leave(); + /* USER CODE END I2C4_EV_IRQn 1 */ +} + +/** + * @brief This function handles I2C4 error interrupt. + */ +void I2C4_ER_IRQHandler(void) +{ + /* USER CODE BEGIN I2C4_ER_IRQn 0 */ + /* enter interrupt */ + rt_interrupt_enter(); + /* USER CODE END I2C4_ER_IRQn 0 */ + HAL_I2C_ER_IRQHandler(&i2c_objs[I2C4_INDEX].handle); + /* USER CODE BEGIN I2C4_ER_IRQn 1 */ + /* leave interrupt */ + rt_interrupt_leave(); + /* USER CODE END I2C4_ER_IRQn 1 */ +} +#endif /* BSP_USING_HARD_I2C4 */ +#endif /* BSP_I2C_USING_IRQ */ + +#ifdef BSP_I2C_USING_DMA #if defined(BSP_USING_HARD_I2C1) && defined(BSP_I2C1_RX_USING_DMA) /** * @brief This function handles DMA Rx interrupt request. @@ -711,11 +946,48 @@ void I2C3_DMA_TX_IRQHandler(void) } #endif /* defined(BSP_USING_HARD_I2C3) && defined(BSP_I2C3_TX_USING_DMA) */ +#if defined(BSP_USING_HARD_I2C4) && defined(BSP_I2C4_RX_USING_DMA) +/** + * @brief This function handles DMA Rx interrupt request. + * @param None + * @retval None + */ +void I2C4_DMA_RX_IRQHandler(void) +{ + /* enter interrupt */ + rt_interrupt_enter(); + + HAL_DMA_IRQHandler(&i2c_objs[I2C4_INDEX].dma.handle_rx); + + /* leave interrupt */ + rt_interrupt_leave(); +} +#endif /* defined(BSP_USING_HARD_I2C4) && defined(BSP_I2C4_RX_USING_DMA) */ + +#if defined(BSP_USING_HARD_I2C4) && defined(BSP_I2C4_TX_USING_DMA) +/** + * @brief This function handles DMA Rx interrupt request. + * @param None + * @retval None + */ +void I2C4_DMA_TX_IRQHandler(void) +{ + /* enter interrupt */ + rt_interrupt_enter(); + + HAL_DMA_IRQHandler(&i2c_objs[I2C4_INDEX].dma.handle_tx); + + /* leave interrupt */ + rt_interrupt_leave(); +} +#endif /* defined(BSP_USING_HARD_I2C4) && defined(BSP_I2C4_TX_USING_DMA) */ +#endif /* BSP_I2C_USING_DMA */ + int rt_hw_hw_i2c_init(void) { - stm32_get_dma_info(); + stm32_get_info(); return RT_hw_i2c_bus_init(); } INIT_BOARD_EXPORT(rt_hw_hw_i2c_init); -#endif /* defined(BSP_USING_HARD_I2C1) || defined(BSP_USING_HARD_I2C2) || defined(BSP_USING_HARD_I2C3) */ +#endif /* defined(BSP_HARDWARE_I2C) */ diff --git a/bsp/stm32/libraries/HAL_Drivers/drivers/drv_hard_i2c.h b/bsp/stm32/libraries/HAL_Drivers/drivers/drv_hard_i2c.h index 06046512965..89a88b00459 100644 --- a/bsp/stm32/libraries/HAL_Drivers/drivers/drv_hard_i2c.h +++ b/bsp/stm32/libraries/HAL_Drivers/drivers/drv_hard_i2c.h @@ -1,11 +1,12 @@ /* - * Copyright (c) 2006-2023, RT-Thread Development Team + * Copyright (c) 2006-2024, RT-Thread Development Team * * SPDX-License-Identifier: Apache-2.0 * * Change Logs: * Date Author Notes - * 2024-02-17 Dyyt587 first version + * 2024-02-17 Dyyt587 first version + * 2024-06-23 wdfk-prog Add mode selection scaffolding */ #ifndef __DRV_HARD_I2C_H__ @@ -22,35 +23,118 @@ extern "C" { #endif +/* hardware bus */ +#if defined(BSP_USING_HARD_I2C1) \ + || defined(BSP_USING_HARD_I2C2) \ + || defined(BSP_USING_HARD_I2C3) \ + || defined(BSP_USING_HARD_I2C4) +#define BSP_HARDWARE_I2C +#endif + +/* poll */ +#if defined(BSP_I2C1_TX_USING_POLL) \ + || defined(BSP_I2C2_TX_USING_POLL) \ + || defined(BSP_I2C3_TX_USING_POLL) \ + || defined(BSP_I2C4_TX_USING_POLL) +#define BSP_I2C_TX_USING_POLL +#endif + +#if defined(BSP_I2C1_RX_USING_POLL) \ + || defined(BSP_I2C2_RX_USING_POLL) \ + || defined(BSP_I2C3_RX_USING_POLL) \ + || defined(BSP_I2C4_RX_USING_POLL) +#define BSP_I2C_RX_USING_POLL +#endif + +#if defined (BSP_I2C_TX_USING_POLL) \ + || defined (BSP_I2C_RX_USING_POLL) +#define BSP_I2C_USING_POLL +#endif + +/* DMA */ +#if defined(BSP_I2C1_TX_USING_DMA) \ + || defined(BSP_I2C2_TX_USING_DMA) \ + || defined(BSP_I2C3_TX_USING_DMA) \ + || defined(BSP_I2C4_TX_USING_DMA) +#define BSP_I2C_TX_USING_DMA +#endif + +#if defined(BSP_I2C1_RX_USING_DMA) \ + || defined(BSP_I2C2_RX_USING_DMA) \ + || defined(BSP_I2C3_RX_USING_DMA) \ + || defined(BSP_I2C4_RX_USING_DMA) +#define BSP_I2C_RX_USING_DMA +#endif + +#if defined (BSP_I2C_TX_USING_DMA) \ + || defined (BSP_I2C_RX_USING_DMA) +#define BSP_I2C_USING_DMA +#endif + +/* INT */ +#if defined(BSP_I2C1_TX_USING_INT) \ + || defined(BSP_I2C2_TX_USING_INT) \ + || defined(BSP_I2C3_TX_USING_INT) \ + || defined(BSP_I2C4_TX_USING_INT) +#define BSP_I2C_TX_USING_INT +#endif + +#if defined(BSP_I2C1_RX_USING_INT) \ + || defined(BSP_I2C2_RX_USING_INT) \ + || defined(BSP_I2C3_RX_USING_INT) \ + || defined(BSP_I2C4_RX_USING_INT) +#define BSP_I2C_RX_USING_INT +#endif + +#if defined (BSP_I2C_TX_USING_INT) \ + || defined (BSP_I2C_RX_USING_INT) +#define BSP_I2C_USING_INT +#endif + +/* IRQ */ +#if defined (BSP_I2C_USING_DMA) \ + || defined (BSP_I2C_USING_INT) +#define BSP_I2C_USING_IRQ +#endif + struct stm32_i2c_config { - const char *name; - I2C_TypeDef *Instance; - rt_uint32_t timing; - rt_uint32_t timeout; - IRQn_Type evirq_type; - IRQn_Type erirq_type; - struct dma_config *dma_rx; - struct dma_config *dma_tx; + const char *name; + I2C_TypeDef *Instance; + rt_uint32_t timing; + rt_uint32_t timeout; + IRQn_Type evirq_type; + IRQn_Type erirq_type; +#ifdef BSP_I2C_RX_USING_DMA + struct dma_config *dma_rx; +#endif /* BSP_I2C_RX_USING_DMA */ +#ifdef BSP_I2C_TX_USING_DMA + struct dma_config *dma_tx; +#endif /* BSP_I2C_TX_USING_DMA */ }; struct stm32_i2c { - I2C_HandleTypeDef handle; - struct stm32_i2c_config *config; + I2C_HandleTypeDef handle; + struct stm32_i2c_config *config; + struct rt_i2c_bus_device i2c_bus; + rt_uint16_t i2c_dma_flag; +#ifdef BSP_I2C_USING_IRQ + struct rt_completion completion; +#endif /* BSP_I2C_USING_IRQ */ +#ifdef BSP_I2C_USING_DMA struct { - DMA_HandleTypeDef handle_rx; - DMA_HandleTypeDef handle_tx; +#ifdef BSP_I2C_RX_USING_DMA + DMA_HandleTypeDef handle_rx; +#endif /* BSP_I2C_RX_USING_DMA */ +#ifdef BSP_I2C_TX_USING_DMA + DMA_HandleTypeDef handle_tx; +#endif /* BSP_I2C_TX_USING_DMA */ } dma; - rt_uint8_t i2c_dma_flag; - struct rt_i2c_bus_device i2c_bus; - struct rt_completion completion; +#endif /* BSP_I2C_USING_DMA */ }; -#define I2C_USING_TX_DMA_FLAG (1U) -#define I2C_USING_RX_DMA_FLAG (1U << 1) - #ifdef __cplusplus } #endif diff --git a/components/drivers/core/power_domain.c b/components/drivers/core/power_domain.c index 254010b4fe4..77da3b26344 100644 --- a/components/drivers/core/power_domain.c +++ b/components/drivers/core/power_domain.c @@ -105,6 +105,12 @@ rt_err_t rt_dm_power_domain_register_child(struct rt_dm_power_domain *domain, dm_power_domain_init(child_domain); child_domain->parent_domain = domain; + rt_hw_spin_lock(&domain->lock.lock); + + rt_list_insert_before(&domain->child_nodes, &child_domain->list); + + rt_hw_spin_unlock(&domain->lock.lock); + return RT_EOK; } diff --git a/components/drivers/include/drivers/power_supply.h b/components/drivers/include/drivers/power_supply.h index 15ee64e90b1..8dc8f2ac032 100644 --- a/components/drivers/include/drivers/power_supply.h +++ b/components/drivers/include/drivers/power_supply.h @@ -6,6 +6,7 @@ * Change Logs: * Date Author Notes * 2022-11-21 GuEe-GUI first version + * 2026-03-27 Evlers add snapshot helpers and public name getter */ #ifndef __POWER_SUPPLY_H__ @@ -274,4 +275,8 @@ void rt_power_supply_changed(struct rt_power_supply *psy); struct rt_power_supply *rt_power_supply_get(struct rt_device *dev, const char *id); void rt_power_supply_put(struct rt_power_supply *psy); +const char *rt_power_supply_name(struct rt_power_supply *psy); +struct rt_power_supply **rt_power_supply_snapshot(rt_size_t *count); +void rt_power_supply_snapshot_free(struct rt_power_supply **nodes, rt_size_t count); + #endif /* __POWER_SUPPLY_H__ */ diff --git a/components/drivers/include/drivers/regulator.h b/components/drivers/include/drivers/regulator.h index 73ab7863e1c..005609431ff 100644 --- a/components/drivers/include/drivers/regulator.h +++ b/components/drivers/include/drivers/regulator.h @@ -6,6 +6,7 @@ * Change Logs: * Date Author Notes * 2023-09-23 GuEe-GUI first version + * 2026-03-27 Evlers add current control API and snapshot helpers */ #ifndef __REGULATOR_H__ @@ -18,6 +19,7 @@ #include #define RT_REGULATOR_UVOLT_INVALID (((int)(RT_UINT32_MAX >> 1))) +#define RT_REGULATOR_UAMP_INVALID (((int)(RT_UINT32_MAX >> 1))) struct rt_regulator_param { @@ -86,6 +88,8 @@ struct rt_regulator_ops rt_bool_t (*is_enabled)(struct rt_regulator_node *reg); rt_err_t (*set_voltage)(struct rt_regulator_node *reg, int min_uvolt, int max_uvolt); int (*get_voltage)(struct rt_regulator_node *reg); + rt_err_t (*set_current)(struct rt_regulator_node *reg, int min_uamp, int max_uamp); + int (*get_current)(struct rt_regulator_node *reg); rt_err_t (*set_mode)(struct rt_regulator_node *reg, rt_uint32_t mode); rt_int32_t (*get_mode)(struct rt_regulator_node *reg); rt_err_t (*set_ramp_delay)(struct rt_regulator_node *reg, int ramp); @@ -98,6 +102,8 @@ struct rt_regulator_notifier; #define RT_REGULATOR_MSG_DISABLE RT_BIT(1) #define RT_REGULATOR_MSG_VOLTAGE_CHANGE RT_BIT(2) #define RT_REGULATOR_MSG_VOLTAGE_CHANGE_ERR RT_BIT(3) +#define RT_REGULATOR_MSG_CURRENT_CHANGE RT_BIT(4) +#define RT_REGULATOR_MSG_CURRENT_CHANGE_ERR RT_BIT(5) union rt_regulator_notifier_args { @@ -107,6 +113,12 @@ union rt_regulator_notifier_args int min_uvolt; int max_uvolt; }; + struct + { + int old_uamp; + int min_uamp; + int max_uamp; + }; }; typedef rt_err_t (*rt_regulator_notifier_callback)(struct rt_regulator_notifier *notifier, @@ -140,9 +152,16 @@ rt_bool_t rt_regulator_is_supported_voltage(struct rt_regulator *reg, int min_uv rt_err_t rt_regulator_set_voltage(struct rt_regulator *reg, int min_uvolt, int max_uvolt); int rt_regulator_get_voltage(struct rt_regulator *reg); +rt_bool_t rt_regulator_is_supported_current(struct rt_regulator *reg, int min_uamp, int max_uamp); +rt_err_t rt_regulator_set_current(struct rt_regulator *reg, int min_uamp, int max_uamp); +int rt_regulator_get_current(struct rt_regulator *reg); + rt_err_t rt_regulator_set_mode(struct rt_regulator *reg, rt_uint32_t mode); rt_int32_t rt_regulator_get_mode(struct rt_regulator *reg); +struct rt_regulator_node **rt_regulator_nodes_snapshot(rt_size_t *count); +void rt_regulator_nodes_snapshot_free(struct rt_regulator_node **nodes, rt_size_t count); + rt_inline rt_err_t rt_regulator_set_voltage_triplet(struct rt_regulator *reg, int min_uvolt, int target_uvolt, int max_uvolt) { @@ -154,4 +173,15 @@ rt_inline rt_err_t rt_regulator_set_voltage_triplet(struct rt_regulator *reg, return rt_regulator_set_voltage(reg, min_uvolt, max_uvolt); } +rt_inline rt_err_t rt_regulator_set_current_triplet(struct rt_regulator *reg, + int min_uamp, int target_uamp, int max_uamp) +{ + if (!rt_regulator_set_current(reg, target_uamp, max_uamp)) + { + return RT_EOK; + } + + return rt_regulator_set_current(reg, min_uamp, max_uamp); +} + #endif /* __REGULATOR_H__ */ diff --git a/components/drivers/include/rtdevice.h b/components/drivers/include/rtdevice.h index c3a1277449c..4914fe329c1 100644 --- a/components/drivers/include/rtdevice.h +++ b/components/drivers/include/rtdevice.h @@ -7,6 +7,7 @@ * Date Author Notes * 2012-01-08 bernard first version. * 2014-07-12 bernard Add workqueue implementation. + * 2026-03-27 Evlers reorder regulator/power supply headers after DM deps */ #ifndef __RT_DEVICE_H__ @@ -118,10 +119,6 @@ extern "C" { #endif /* RT_PCI_ENDPOINT */ #endif /* RT_USING_PCI */ -#ifdef RT_USING_REGULATOR -#include "drivers/regulator.h" -#endif /* RT_USING_REGULATOR */ - #ifdef RT_USING_RESET #include "drivers/reset.h" #endif /* RT_USING_RESET */ @@ -148,15 +145,19 @@ extern "C" { #include "drivers/hwcache.h" #endif /* RT_USING_HWCACHE */ -#ifdef RT_USING_POWER_SUPPLY -#include "drivers/power_supply.h" -#endif /* RT_USING_POWER_SUPPLY */ - #ifdef RT_USING_NVMEM #include "drivers/nvmem.h" #endif /* RT_USING_NVMEM */ #endif /* RT_USING_DM */ +#ifdef RT_USING_REGULATOR +#include "drivers/regulator.h" +#endif /* RT_USING_REGULATOR */ + +#ifdef RT_USING_POWER_SUPPLY +#include "drivers/power_supply.h" +#endif /* RT_USING_POWER_SUPPLY */ + #ifdef RT_USING_RTC #include "drivers/dev_rtc.h" #ifdef RT_USING_ALARM diff --git a/components/drivers/power/supply/Kconfig b/components/drivers/power/supply/Kconfig index b03ffa1e056..435a79c623a 100644 --- a/components/drivers/power/supply/Kconfig +++ b/components/drivers/power/supply/Kconfig @@ -1,6 +1,5 @@ menuconfig RT_USING_POWER_SUPPLY bool "Using Power supply class support" - depends on RT_USING_DM select RT_USING_ADT select RT_USING_ADT_REF select RT_USING_SYSTEM_WORKQUEUE @@ -27,6 +26,8 @@ config RT_POWER_SUPPLY_EMU config RT_POWER_SUPPLY_CHARGER_GPIO bool "GPIO charger" depends on RT_USING_POWER_SUPPLY + depends on RT_USING_DM + depends on RT_USING_OFW depends on RT_USING_PIN default y diff --git a/components/drivers/power/supply/SConscript b/components/drivers/power/supply/SConscript index 5039b34f043..56ca1e8dbdf 100644 --- a/components/drivers/power/supply/SConscript +++ b/components/drivers/power/supply/SConscript @@ -8,7 +8,7 @@ if not GetDepend(['RT_USING_POWER_SUPPLY']): cwd = GetCurrentDir() CPPPATH = [cwd + '/../../include'] -src = ['supply.c'] +src = ['supply.c', 'supply_cmd.c'] if GetDepend(['RT_POWER_SUPPLY_DAEMON']): src += ['supply-daemon.c'] diff --git a/components/drivers/power/supply/emu-power.c b/components/drivers/power/supply/emu-power.c index f28438cd927..7197d9ee88f 100644 --- a/components/drivers/power/supply/emu-power.c +++ b/components/drivers/power/supply/emu-power.c @@ -6,6 +6,7 @@ * Change Logs: * Date Author Notes * 2023-02-25 GuEe-GUI the first version + * 2026-03-27 Evlers allow building without DM by naming parent directly */ #include @@ -299,7 +300,11 @@ static int emu_power_init(void) rt_memset(ep, 0, sizeof(*ep)); +#ifdef RT_USING_DM rt_dm_dev_set_name(&ep->parent, "emu-power"); +#else + ep->parent.parent.name = "emu-power"; +#endif ep->battery.dev = &ep->parent, ep->battery.type = RT_POWER_SUPPLY_TYPE_BATTERY, diff --git a/components/drivers/power/supply/supply-daemon.c b/components/drivers/power/supply/supply-daemon.c index 8f0286e4965..772e064bd67 100644 --- a/components/drivers/power/supply/supply-daemon.c +++ b/components/drivers/power/supply/supply-daemon.c @@ -6,6 +6,7 @@ * Change Logs: * Date Author Notes * 2023-02-25 GuEe-GUI the first version + * 2026-03-27 Evlers support builds without DM names and improve logging */ #include @@ -66,11 +67,11 @@ static rt_err_t daemon_power_supply_notify(struct rt_power_supply_notifier *noti { if (full_power) { - LOG_I("%s: Power is full", rt_dm_dev_get_name(psy->dev)); + LOG_I("%s: Power is full", rt_power_supply_name(psy)); } else { - LOG_I("%s: Power is sufficient", rt_dm_dev_get_name(psy->dev)); + LOG_I("%s: Power is sufficient", rt_power_supply_name(psy)); } } } @@ -109,12 +110,12 @@ static rt_err_t daemon_power_supply_notify(struct rt_power_supply_notifier *noti if (!rt_power_supply_get_property(psy, RT_POWER_SUPPLY_PROP_SCOPE, &propval) && propval.intval == RT_POWER_SUPPLY_SCOPE_SYSTEM) { - LOG_E("%s: Power is critical, poweroff now", rt_dm_dev_get_name(psy->dev)); + LOG_E("%s: Power is critical, poweroff now", rt_power_supply_name(psy)); rt_hw_cpu_shutdown(); } } while (0); - LOG_E("%s: Power is critical", rt_dm_dev_get_name(psy->dev)); + LOG_E("%s: Power is critical", rt_power_supply_name(psy)); } else if (propval.intval <= 10) { @@ -136,7 +137,7 @@ static rt_err_t daemon_power_supply_notify(struct rt_power_supply_notifier *noti pm_sleep_mode = PM_SLEEP_MODE_LIGHT; rt_pm_run_enter(PM_RUN_MODE_NORMAL_SPEED); #endif - LOG_W("%s: Power is low", rt_dm_dev_get_name(psy->dev)); + LOG_W("%s: Power is low", rt_power_supply_name(psy)); } #ifdef RT_USING_PM diff --git a/components/drivers/power/supply/supply.c b/components/drivers/power/supply/supply.c index bce91ad9975..bdd8d84e228 100644 --- a/components/drivers/power/supply/supply.c +++ b/components/drivers/power/supply/supply.c @@ -6,6 +6,7 @@ * Change Logs: * Date Author Notes * 2023-02-25 GuEe-GUI the first version + * 2026-03-27 Evlers add CLI snapshot/name helpers and OFW guards */ #include @@ -26,6 +27,17 @@ static RT_DEFINE_SPINLOCK(nodes_lock); static rt_list_t power_supply_nodes = RT_LIST_OBJECT_INIT(power_supply_nodes); static rt_list_t power_supply_notifier_nodes = RT_LIST_OBJECT_INIT(power_supply_notifier_nodes); +const char *rt_power_supply_name(struct rt_power_supply *psy) +{ + struct rt_device *dev = psy ? psy->dev : RT_NULL; + +#ifdef RT_USING_DM + return rt_dm_dev_get_name(dev); +#else + return dev ? dev->parent.name : ""; +#endif +} + static rt_bool_t power_supply_have_property(struct rt_power_supply *psy, enum rt_power_supply_property prop); @@ -68,10 +80,16 @@ rt_err_t power_supply_thermal_register(struct rt_power_supply *psy) return -RT_ENOMEM; } +#ifdef RT_USING_DM rt_dm_dev_set_name(&psy->thermal_dev->parent, rt_dm_dev_get_name(psy->dev)); +#else + psy->thermal_dev->parent.parent.name = rt_power_supply_name(psy); +#endif psy->thermal_dev->zone_id = 0; psy->thermal_dev->ops = &power_supply_thermal_zone_ops; +#ifdef RT_USING_OFW psy->thermal_dev->parent.ofw_node = psy->dev->ofw_node; +#endif psy->thermal_dev->priv = psy; if ((err = rt_thermal_zone_device_register(psy->thermal_dev))) @@ -229,10 +247,14 @@ rt_err_t rt_power_supply_register(struct rt_power_supply *psy) rt_list_insert_before(&power_supply_nodes, &psy->list); rt_spin_unlock(&nodes_lock); +#ifdef RT_USING_OFW if (psy->dev->ofw_node) { +#ifdef RT_USING_DM rt_dm_dev_bind_fwdata(psy->dev, RT_NULL, psy); +#endif } +#endif return RT_EOK; } @@ -256,10 +278,14 @@ rt_err_t rt_power_supply_unregister(struct rt_power_supply *psy) rt_list_remove(&psy->list); +#ifdef RT_USING_OFW if (psy->dev->ofw_node) { +#ifdef RT_USING_DM rt_dm_dev_unbind_fwdata(psy->dev, RT_NULL); +#endif } +#endif _unlock: rt_spin_unlock(&nodes_lock); @@ -562,133 +588,62 @@ void rt_power_supply_put(struct rt_power_supply *psy) rt_ref_put(&psy->ref, power_supply_release); } -#if defined(RT_USING_CONSOLE) && defined(RT_USING_MSH) -const char * const type_str[] = -{ - [RT_POWER_SUPPLY_TYPE_UNKNOWN] = "UnKnown", - [RT_POWER_SUPPLY_TYPE_BATTERY] = "Battery", - [RT_POWER_SUPPLY_TYPE_UPS] = "UPS", - [RT_POWER_SUPPLY_TYPE_MAINS] = "Mains", - [RT_POWER_SUPPLY_TYPE_USB_SDP] = "USB SDP", - [RT_POWER_SUPPLY_TYPE_USB_DCP] = "USB DCP", - [RT_POWER_SUPPLY_TYPE_USB_CDP] = "USB CDP", - [RT_POWER_SUPPLY_TYPE_USB_ACA] = "USB ACA", - [RT_POWER_SUPPLY_TYPE_USB_TYPE_C] = "USB TypeC", - [RT_POWER_SUPPLY_TYPE_USB_PD] = "USB PD", - [RT_POWER_SUPPLY_TYPE_USB_PD_DRP] = "USB PD DRP", - [RT_POWER_SUPPLY_TYPE_USB_PD_PPS] = "USB PD PPS", - [RT_POWER_SUPPLY_TYPE_WIRELESS] = "Wireless", -}; - -const char * const status_str[] = -{ - [RT_POWER_SUPPLY_STATUS_UNKNOWN] = "UnKnown", - [RT_POWER_SUPPLY_STATUS_CHARGING] = "Charging", - [RT_POWER_SUPPLY_STATUS_DISCHARGING] = "Discharging", - [RT_POWER_SUPPLY_STATUS_NOT_CHARGING] = "Not Charging", - [RT_POWER_SUPPLY_STATUS_FULL] = "Full", -}; - -const char * const charge_type_str[] = +struct rt_power_supply **rt_power_supply_snapshot(rt_size_t *count) { - [RT_POWER_SUPPLY_CHARGE_TYPE_UNKNOWN] = "Unknown", - [RT_POWER_SUPPLY_CHARGE_TYPE_NONE] = "None", - [RT_POWER_SUPPLY_CHARGE_TYPE_TRICKLE] = "Trickle", - [RT_POWER_SUPPLY_CHARGE_TYPE_FAST] = "Fast", - [RT_POWER_SUPPLY_CHARGE_TYPE_STANDARD] = "Standard", - [RT_POWER_SUPPLY_CHARGE_TYPE_ADAPTIVE] = "Adaptive", - [RT_POWER_SUPPLY_CHARGE_TYPE_CUSTOM] = "Custom", - [RT_POWER_SUPPLY_CHARGE_TYPE_LONGLIFE] = "Longlife", - [RT_POWER_SUPPLY_CHARGE_TYPE_BYPASS] = "Bypass", -}; - -const char * const health_str[] = -{ - [RT_POWER_SUPPLY_HEALTH_UNKNOWN] = "Unknown", - [RT_POWER_SUPPLY_HEALTH_GOOD] = "Good", - [RT_POWER_SUPPLY_HEALTH_OVERHEAT] = "Overheat", - [RT_POWER_SUPPLY_HEALTH_DEAD] = "Dead", - [RT_POWER_SUPPLY_HEALTH_OVERVOLTAGE] = "Overvoltage", - [RT_POWER_SUPPLY_HEALTH_UNSPEC_FAILURE] = "Unspec Failure", - [RT_POWER_SUPPLY_HEALTH_COLD] = "Cold", - [RT_POWER_SUPPLY_HEALTH_WATCHDOG_TIMER_EXPIRE] = "Watchdog Timer Expire", - [RT_POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE] = "Safety Timer Expire", - [RT_POWER_SUPPLY_HEALTH_OVERCURRENT] = "Overcurrent", - [RT_POWER_SUPPLY_HEALTH_CALIBRATION_REQUIRED] = "Calibration Required", - [RT_POWER_SUPPLY_HEALTH_WARM] = "Warm", - [RT_POWER_SUPPLY_HEALTH_COOL] = "Cool", - [RT_POWER_SUPPLY_HEALTH_HOT] = "Hot", - [RT_POWER_SUPPLY_HEALTH_NO_BATTERY] = "No Battery", -}; + struct rt_power_supply *psy, *psy_next; + struct rt_power_supply **nodes; + rt_size_t total = 0; + rt_size_t idx = 0; -const char * const tech_str[] = -{ - [RT_POWER_SUPPLY_TECHNOLOGY_UNKNOWN] = "UnKnown", - [RT_POWER_SUPPLY_TECHNOLOGY_NiMH] = "NiMH", - [RT_POWER_SUPPLY_TECHNOLOGY_LION] = "LION", - [RT_POWER_SUPPLY_TECHNOLOGY_LIPO] = "LIPO", - [RT_POWER_SUPPLY_TECHNOLOGY_LiFe] = "LiFe", - [RT_POWER_SUPPLY_TECHNOLOGY_NiCd] = "NiCd", - [RT_POWER_SUPPLY_TECHNOLOGY_LiMn] = "LiMn", -}; + if (!count) + { + return RT_NULL; + } -static int list_power_supply(int argc, char**argv) -{ - struct rt_power_supply *psy, *psy_next; - union rt_power_supply_property_val propval = {}; + *count = 0; rt_spin_lock(&nodes_lock); - rt_list_for_each_entry_safe(psy, psy_next, &power_supply_nodes, list) { - rt_spin_unlock(&nodes_lock); - - rt_kprintf("%s %s\n", rt_dm_dev_get_name(psy->dev), type_str[psy->type]); - - rt_power_supply_get_property(psy, RT_POWER_SUPPLY_PROP_STATUS, &propval); - rt_kprintf("status: %s\n", status_str[propval.intval]), propval.intval = 0; + total++; + } + rt_spin_unlock(&nodes_lock); - rt_power_supply_get_property(psy, RT_POWER_SUPPLY_PROP_CHARGE_TYPE, &propval); - rt_kprintf("charge type: %s\n", charge_type_str[propval.intval]), propval.intval = 0; + if (!total) + { + return RT_NULL; + } - rt_power_supply_get_property(psy, RT_POWER_SUPPLY_PROP_HEALTH, &propval); - rt_kprintf("health: %s\n", health_str[propval.intval]), propval.intval = 0; + nodes = rt_calloc(total, sizeof(*nodes)); + if (!nodes) + { + return RT_NULL; + } - if (psy->battery_info) - { - struct rt_power_supply_battery_info *info = psy->battery_info; - - rt_power_supply_get_property(psy, RT_POWER_SUPPLY_PROP_CAPACITY, &propval); - rt_kprintf("capacity: %d%%\n", propval.intval), propval.intval = 0; - - rt_kprintf("technology: %s\n", tech_str[info->technology]); - rt_kprintf("energy full design: %u uWh\n", info->energy_full_design_uwh); - rt_kprintf("charge full design: %u uAh\n", info->charge_full_design_uah); - rt_kprintf("voltage design range: %u~%u uV\n", info->voltage_min_design_uv, info->voltage_max_design_uv); - rt_kprintf("precharge current: %u uA\n", info->precharge_current_ua); - rt_kprintf("charge term current: %u uA\n", info->charge_term_current_ua); - rt_kprintf("charge restart voltage: %u uV\n", info->charge_restart_voltage_uv); - rt_kprintf("constant charge current max: %u uA\n", info->constant_charge_current_max_ua); - rt_kprintf("constant charge voltage max: %u uV\n", info->constant_charge_voltage_max_uv); - rt_kprintf("temp ambient alert range: %+d.%u~%+d.%u C\n", - info->temp_ambient_alert_min / 1000, rt_abs(info->temp_ambient_alert_min) % 1000, - info->temp_ambient_alert_max / 1000, rt_abs(info->temp_ambient_alert_max) % 1000); - rt_kprintf("temp alert range: %+d.%u~%+d.%u C\n", - info->temp_alert_min / 1000, rt_abs(info->temp_alert_min) % 1000, - info->temp_alert_max / 1000, rt_abs(info->temp_alert_max) % 1000); - rt_kprintf("temp range: %+d.%u~%+d.%u C\n", - info->temp_min / 1000, rt_abs(info->temp_min) % 1000, - info->temp_max / 1000, rt_abs(info->temp_max) % 1000); - } + rt_spin_lock(&nodes_lock); + rt_list_for_each_entry_safe(psy, psy_next, &power_supply_nodes, list) + { + nodes[idx] = psy; + rt_ref_get(&psy->ref); + idx++; + } + rt_spin_unlock(&nodes_lock); - rt_kputs("\n"); + *count = total; + return nodes; +} - rt_spin_lock(&nodes_lock); +void rt_power_supply_snapshot_free(struct rt_power_supply **nodes, rt_size_t count) +{ + if (!nodes) + { + return; } - rt_spin_unlock(&nodes_lock); + while (count--) + { + rt_ref_put(&nodes[count]->ref, power_supply_release); + } - return 0; + rt_free(nodes); } -MSH_CMD_EXPORT(list_power_supply, dump all of power supply information); -#endif /* RT_USING_CONSOLE && RT_USING_MSH */ diff --git a/components/drivers/power/supply/supply_cmd.c b/components/drivers/power/supply/supply_cmd.c new file mode 100644 index 00000000000..96e91cedd9e --- /dev/null +++ b/components/drivers/power/supply/supply_cmd.c @@ -0,0 +1,401 @@ +/* + * Copyright (c) 2006-2026, RT-Thread Development Team + * + * SPDX-License-Identifier: Apache-2.0 + * + * Change Logs: + * Date Author Notes + * 2026-03-27 Evlers first version + */ + +#include + +#if defined(RT_USING_CONSOLE) && defined(RT_USING_MSH) + +const char * const type_str[] = +{ + [RT_POWER_SUPPLY_TYPE_UNKNOWN] = "UnKnown", + [RT_POWER_SUPPLY_TYPE_BATTERY] = "Battery", + [RT_POWER_SUPPLY_TYPE_UPS] = "UPS", + [RT_POWER_SUPPLY_TYPE_MAINS] = "Mains", + [RT_POWER_SUPPLY_TYPE_USB_SDP] = "USB SDP", + [RT_POWER_SUPPLY_TYPE_USB_DCP] = "USB DCP", + [RT_POWER_SUPPLY_TYPE_USB_CDP] = "USB CDP", + [RT_POWER_SUPPLY_TYPE_USB_ACA] = "USB ACA", + [RT_POWER_SUPPLY_TYPE_USB_TYPE_C] = "USB TypeC", + [RT_POWER_SUPPLY_TYPE_USB_PD] = "USB PD", + [RT_POWER_SUPPLY_TYPE_USB_PD_DRP] = "USB PD DRP", + [RT_POWER_SUPPLY_TYPE_USB_PD_PPS] = "USB PD PPS", + [RT_POWER_SUPPLY_TYPE_WIRELESS] = "Wireless", +}; + +const char * const status_str[] = +{ + [RT_POWER_SUPPLY_STATUS_UNKNOWN] = "UnKnown", + [RT_POWER_SUPPLY_STATUS_CHARGING] = "Charging", + [RT_POWER_SUPPLY_STATUS_DISCHARGING] = "Discharging", + [RT_POWER_SUPPLY_STATUS_NOT_CHARGING] = "Not Charging", + [RT_POWER_SUPPLY_STATUS_FULL] = "Full", +}; + +const char * const charge_type_str[] = +{ + [RT_POWER_SUPPLY_CHARGE_TYPE_UNKNOWN] = "Unknown", + [RT_POWER_SUPPLY_CHARGE_TYPE_NONE] = "None", + [RT_POWER_SUPPLY_CHARGE_TYPE_TRICKLE] = "Trickle", + [RT_POWER_SUPPLY_CHARGE_TYPE_FAST] = "Fast", + [RT_POWER_SUPPLY_CHARGE_TYPE_STANDARD] = "Standard", + [RT_POWER_SUPPLY_CHARGE_TYPE_ADAPTIVE] = "Adaptive", + [RT_POWER_SUPPLY_CHARGE_TYPE_CUSTOM] = "Custom", + [RT_POWER_SUPPLY_CHARGE_TYPE_LONGLIFE] = "Longlife", + [RT_POWER_SUPPLY_CHARGE_TYPE_BYPASS] = "Bypass", +}; + +const char * const health_str[] = +{ + [RT_POWER_SUPPLY_HEALTH_UNKNOWN] = "Unknown", + [RT_POWER_SUPPLY_HEALTH_GOOD] = "Good", + [RT_POWER_SUPPLY_HEALTH_OVERHEAT] = "Overheat", + [RT_POWER_SUPPLY_HEALTH_DEAD] = "Dead", + [RT_POWER_SUPPLY_HEALTH_OVERVOLTAGE] = "Overvoltage", + [RT_POWER_SUPPLY_HEALTH_UNSPEC_FAILURE] = "Unspec Failure", + [RT_POWER_SUPPLY_HEALTH_COLD] = "Cold", + [RT_POWER_SUPPLY_HEALTH_WATCHDOG_TIMER_EXPIRE] = "Watchdog Timer Expire", + [RT_POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE] = "Safety Timer Expire", + [RT_POWER_SUPPLY_HEALTH_OVERCURRENT] = "Overcurrent", + [RT_POWER_SUPPLY_HEALTH_CALIBRATION_REQUIRED] = "Calibration Required", + [RT_POWER_SUPPLY_HEALTH_WARM] = "Warm", + [RT_POWER_SUPPLY_HEALTH_COOL] = "Cool", + [RT_POWER_SUPPLY_HEALTH_HOT] = "Hot", + [RT_POWER_SUPPLY_HEALTH_NO_BATTERY] = "No Battery", +}; + +const char * const tech_str[] = +{ + [RT_POWER_SUPPLY_TECHNOLOGY_UNKNOWN] = "UnKnown", + [RT_POWER_SUPPLY_TECHNOLOGY_NiMH] = "NiMH", + [RT_POWER_SUPPLY_TECHNOLOGY_LION] = "LION", + [RT_POWER_SUPPLY_TECHNOLOGY_LIPO] = "LIPO", + [RT_POWER_SUPPLY_TECHNOLOGY_LiFe] = "LiFe", + [RT_POWER_SUPPLY_TECHNOLOGY_NiCd] = "NiCd", + [RT_POWER_SUPPLY_TECHNOLOGY_LiMn] = "LiMn", +}; + +const char * const capacity_level_str[] = +{ + [RT_POWER_SUPPLY_CAPACITY_LEVEL_UNKNOWN] = "Unknown", + [RT_POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL] = "Critical", + [RT_POWER_SUPPLY_CAPACITY_LEVEL_LOW] = "Low", + [RT_POWER_SUPPLY_CAPACITY_LEVEL_NORMAL] = "Normal", + [RT_POWER_SUPPLY_CAPACITY_LEVEL_HIGH] = "High", + [RT_POWER_SUPPLY_CAPACITY_LEVEL_FULL] = "Full", +}; + +const char * const scope_str[] = +{ + [RT_POWER_SUPPLY_SCOPE_UNKNOWN] = "Unknown", + [RT_POWER_SUPPLY_SCOPE_SYSTEM] = "System", + [RT_POWER_SUPPLY_SCOPE_DEVICE] = "Device", +}; + +enum power_supply_prop_dump_type +{ + POWER_SUPPLY_PROP_DUMP_INT = 0, + POWER_SUPPLY_PROP_DUMP_ENUM, + POWER_SUPPLY_PROP_DUMP_STR, +}; + +struct power_supply_prop_desc +{ + enum rt_power_supply_property prop; + const char *name; + const char *label; + const char *unit; + enum power_supply_prop_dump_type type; + const char * const *str_tab; + rt_size_t str_tab_size; +}; + +static const struct power_supply_prop_desc g_power_supply_prop_desc[] = +{ + {RT_POWER_SUPPLY_PROP_ONLINE, "online", "online:", RT_NULL, POWER_SUPPLY_PROP_DUMP_INT, RT_NULL, 0}, + {RT_POWER_SUPPLY_PROP_PRESENT, "present", "present:", RT_NULL, POWER_SUPPLY_PROP_DUMP_INT, RT_NULL, 0}, + {RT_POWER_SUPPLY_PROP_AUTHENTIC, "authentic", "authentic:", RT_NULL, POWER_SUPPLY_PROP_DUMP_INT, RT_NULL, 0}, + {RT_POWER_SUPPLY_PROP_STATUS, "status", "status:", RT_NULL, POWER_SUPPLY_PROP_DUMP_ENUM, status_str, sizeof(status_str) / sizeof(status_str[0])}, + {RT_POWER_SUPPLY_PROP_CHARGE_TYPE, "charge_type", "charge type:", RT_NULL, POWER_SUPPLY_PROP_DUMP_ENUM, charge_type_str, sizeof(charge_type_str) / sizeof(charge_type_str[0])}, + {RT_POWER_SUPPLY_PROP_HEALTH, "health", "health:", RT_NULL, POWER_SUPPLY_PROP_DUMP_ENUM, health_str, sizeof(health_str) / sizeof(health_str[0])}, + {RT_POWER_SUPPLY_PROP_SCOPE, "scope", "scope:", RT_NULL, POWER_SUPPLY_PROP_DUMP_ENUM, scope_str, sizeof(scope_str) / sizeof(scope_str[0])}, + {RT_POWER_SUPPLY_PROP_CAPACITY, "capacity", "capacity:", "%", POWER_SUPPLY_PROP_DUMP_INT, RT_NULL, 0}, + {RT_POWER_SUPPLY_PROP_CAPACITY_LEVEL, "capacity_level", "capacity level:", RT_NULL, POWER_SUPPLY_PROP_DUMP_ENUM, capacity_level_str, sizeof(capacity_level_str) / sizeof(capacity_level_str[0])}, + {RT_POWER_SUPPLY_PROP_VOLTAGE_NOW, "voltage_now", "voltage now:", "uV", POWER_SUPPLY_PROP_DUMP_INT, RT_NULL, 0}, + {RT_POWER_SUPPLY_PROP_VOLTAGE_AVG, "voltage_avg", "voltage avg:", "uV", POWER_SUPPLY_PROP_DUMP_INT, RT_NULL, 0}, + {RT_POWER_SUPPLY_PROP_CURRENT_NOW, "current_now", "current now:", "uA", POWER_SUPPLY_PROP_DUMP_INT, RT_NULL, 0}, + {RT_POWER_SUPPLY_PROP_CURRENT_AVG, "current_avg", "current avg:", "uA", POWER_SUPPLY_PROP_DUMP_INT, RT_NULL, 0}, + {RT_POWER_SUPPLY_PROP_POWER_NOW, "power_now", "power now:", "uW", POWER_SUPPLY_PROP_DUMP_INT, RT_NULL, 0}, + {RT_POWER_SUPPLY_PROP_POWER_AVG, "power_avg", "power avg:", "uW", POWER_SUPPLY_PROP_DUMP_INT, RT_NULL, 0}, + {RT_POWER_SUPPLY_PROP_INPUT_VOLTAGE_LIMIT, "input_voltage_limit", "input voltage limit:", "uV", POWER_SUPPLY_PROP_DUMP_INT, RT_NULL, 0}, + {RT_POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT, "input_current_limit", "input current limit:", "uA", POWER_SUPPLY_PROP_DUMP_INT, RT_NULL, 0}, + {RT_POWER_SUPPLY_PROP_INPUT_POWER_LIMIT, "input_power_limit", "input power limit:", "uW", POWER_SUPPLY_PROP_DUMP_INT, RT_NULL, 0}, + {RT_POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE, "constant_charge_voltage", "constant charge voltage:", "uV", POWER_SUPPLY_PROP_DUMP_INT, RT_NULL, 0}, + {RT_POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX, "constant_charge_voltage_max", "constant charge voltage max:", "uV", POWER_SUPPLY_PROP_DUMP_INT, RT_NULL, 0}, + {RT_POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT, "constant_charge_current", "constant charge current:", "uA", POWER_SUPPLY_PROP_DUMP_INT, RT_NULL, 0}, + {RT_POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX, "constant_charge_current_max", "constant charge current max:", "uA", POWER_SUPPLY_PROP_DUMP_INT, RT_NULL, 0}, + {RT_POWER_SUPPLY_PROP_TEMP, "temp", "temp:", "mC", POWER_SUPPLY_PROP_DUMP_INT, RT_NULL, 0}, + {RT_POWER_SUPPLY_PROP_TEMP_AMBIENT, "temp_ambient", "temp ambient:", "mC", POWER_SUPPLY_PROP_DUMP_INT, RT_NULL, 0}, + {RT_POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW, "time_to_empty_now", "time to empty now:", "s", POWER_SUPPLY_PROP_DUMP_INT, RT_NULL, 0}, + {RT_POWER_SUPPLY_PROP_TIME_TO_FULL_NOW, "time_to_full_now", "time to full now:", "s", POWER_SUPPLY_PROP_DUMP_INT, RT_NULL, 0}, + {RT_POWER_SUPPLY_PROP_MODEL_NAME, "model_name", "model name:", RT_NULL, POWER_SUPPLY_PROP_DUMP_STR, RT_NULL, 0}, + {RT_POWER_SUPPLY_PROP_MANUFACTURER, "manufacturer", "manufacturer:", RT_NULL, POWER_SUPPLY_PROP_DUMP_STR, RT_NULL, 0}, + {RT_POWER_SUPPLY_PROP_SERIAL_NUMBER, "serial_number", "serial number:", RT_NULL, POWER_SUPPLY_PROP_DUMP_STR, RT_NULL, 0}, +}; + +#ifdef FINSH_USING_OPTION_COMPLETION +static struct msh_cmd_opt power_supply_msh_options[] = +{ + {0, RT_NULL, RT_NULL}, +}; +#endif + +static const struct power_supply_prop_desc *power_supply_find_prop_desc(const char *name) +{ + rt_size_t i; + + if (!name) + { + return RT_NULL; + } + + for (i = 0; i < sizeof(g_power_supply_prop_desc) / sizeof(g_power_supply_prop_desc[0]); ++i) + { + if (!rt_strcmp(g_power_supply_prop_desc[i].name, name)) + { + return &g_power_supply_prop_desc[i]; + } + } + + return RT_NULL; +} + +static struct rt_power_supply *power_supply_find_by_name(const char *name) +{ + struct rt_power_supply **nodes; + struct rt_power_supply *result = RT_NULL; + rt_size_t count = 0; + rt_size_t i; + + if (!name) + { + return RT_NULL; + } + + nodes = rt_power_supply_snapshot(&count); + if (!nodes) + { + return RT_NULL; + } + + for (i = 0; i < count; ++i) + { + const char *dev_name = rt_power_supply_name(nodes[i]); + + if (!rt_strcmp(dev_name, name)) + { + result = nodes[i]; + rt_ref_get(&result->ref); + break; + } + } + + rt_power_supply_snapshot_free(nodes, count); + return result; +} + +static rt_err_t power_supply_dump_one_property(struct rt_power_supply *psy, + const struct power_supply_prop_desc *desc, + rt_bool_t print_unsupported) +{ + union rt_power_supply_property_val val = {}; + rt_err_t err; + + err = rt_power_supply_get_property(psy, desc->prop, &val); + if (err != RT_EOK) + { + if (print_unsupported) + { + rt_kprintf("%-30s \n", desc->label); + } + return err; + } + + if (desc->type == POWER_SUPPLY_PROP_DUMP_STR) + { + rt_kprintf("%-30s %s\n", desc->label, val.strval ? val.strval : ""); + return RT_EOK; + } + + if (desc->type == POWER_SUPPLY_PROP_DUMP_ENUM) + { + if ((val.intval >= 0) && ((rt_size_t)val.intval < desc->str_tab_size) && desc->str_tab[val.intval]) + { + rt_kprintf("%-30s %s\n", desc->label, desc->str_tab[val.intval]); + } + else + { + rt_kprintf("%-30s %d\n", desc->label, val.intval); + } + return RT_EOK; + } + + if (desc->unit) + { + rt_kprintf("%-30s %d %s\n", desc->label, val.intval, desc->unit); + } + else + { + rt_kprintf("%-30s %d\n", desc->label, val.intval); + } + + return RT_EOK; +} + +static void power_supply_dump_known_property_names(void) +{ + rt_size_t i; + + rt_kputs("Known properties:\n"); + + for (i = 0; i < sizeof(g_power_supply_prop_desc) / sizeof(g_power_supply_prop_desc[0]); ++i) + { + rt_kprintf(" %s\n", g_power_supply_prop_desc[i].name); + } +} + +static void power_supply_dump_battery_info(struct rt_power_supply *psy) +{ + if (psy->battery_info) + { + struct rt_power_supply_battery_info *info = psy->battery_info; + + rt_kprintf("technology: %s\n", tech_str[info->technology]); + rt_kprintf("energy full design: %u uWh\n", info->energy_full_design_uwh); + rt_kprintf("charge full design: %u uAh\n", info->charge_full_design_uah); + rt_kprintf("voltage design range: %u~%u uV\n", info->voltage_min_design_uv, info->voltage_max_design_uv); + rt_kprintf("precharge current: %u uA\n", info->precharge_current_ua); + rt_kprintf("charge term current: %u uA\n", info->charge_term_current_ua); + rt_kprintf("charge restart voltage: %u uV\n", info->charge_restart_voltage_uv); + rt_kprintf("constant charge current max: %u uA\n", info->constant_charge_current_max_ua); + rt_kprintf("constant charge voltage max: %u uV\n", info->constant_charge_voltage_max_uv); + rt_kprintf("temp ambient alert range: %+d.%u~%+d.%u C\n", + info->temp_ambient_alert_min / 1000, rt_abs(info->temp_ambient_alert_min) % 1000, + info->temp_ambient_alert_max / 1000, rt_abs(info->temp_ambient_alert_max) % 1000); + rt_kprintf("temp alert range: %+d.%u~%+d.%u C\n", + info->temp_alert_min / 1000, rt_abs(info->temp_alert_min) % 1000, + info->temp_alert_max / 1000, rt_abs(info->temp_alert_max) % 1000); + rt_kprintf("temp range: %+d.%u~%+d.%u C\n", + info->temp_min / 1000, rt_abs(info->temp_min) % 1000, + info->temp_max / 1000, rt_abs(info->temp_max) % 1000); + } +} + +static void power_supply_dump_properties(struct rt_power_supply *psy) +{ + rt_size_t i; + + for (i = 0; i < sizeof(g_power_supply_prop_desc) / sizeof(g_power_supply_prop_desc[0]); ++i) + { + power_supply_dump_one_property(psy, &g_power_supply_prop_desc[i], RT_FALSE); + } +} + +static int power_supply_do_list(void) +{ + struct rt_power_supply **nodes; + rt_size_t count = 0; + rt_size_t i; + + nodes = rt_power_supply_snapshot(&count); + if (!nodes || !count) + { + return 0; + } + + for (i = 0; i < count; ++i) + { + rt_kprintf("%s %s\n", rt_power_supply_name(nodes[i]), type_str[nodes[i]->type]); + power_supply_dump_properties(nodes[i]); + power_supply_dump_battery_info(nodes[i]); + } + + rt_power_supply_snapshot_free(nodes, count); + return 0; +} + +static int power_supply_do_show(const char *name) +{ + struct rt_power_supply *psy = power_supply_find_by_name(name); + + if (!psy) + { + rt_kprintf("power_supply: device '%s' not found\n", name ? name : ""); + return -RT_ERROR; + } + + rt_kprintf("%s %s\n", rt_power_supply_name(psy), type_str[psy->type]); + power_supply_dump_properties(psy); + power_supply_dump_battery_info(psy); + rt_power_supply_put(psy); + return RT_EOK; +} + +static int power_supply_do_get(const char *name, const char *prop_name) +{ + struct rt_power_supply *psy = power_supply_find_by_name(name); + const struct power_supply_prop_desc *desc = power_supply_find_prop_desc(prop_name); + int ret; + + if (!psy) + { + rt_kprintf("power_supply: device '%s' not found\n", name ? name : ""); + return -RT_ERROR; + } + + if (!desc) + { + rt_kprintf("power_supply: unknown property '%s'\n", prop_name ? prop_name : ""); + power_supply_dump_known_property_names(); + rt_power_supply_put(psy); + return -RT_EINVAL; + } + + ret = power_supply_dump_one_property(psy, desc, RT_TRUE); + rt_power_supply_put(psy); + return ret; +} + +static int power_supply(int argc, char **argv) +{ + if (argc == 2 && !rt_strcmp(argv[1], "list")) + { + return power_supply_do_list(); + } + + if (argc == 3 && !rt_strcmp(argv[1], "show")) + { + return power_supply_do_show(argv[2]); + } + + if (argc == 4 && !rt_strcmp(argv[1], "get")) + { + return power_supply_do_get(argv[2], argv[3]); + } + + rt_kputs("Usage:\n"); + rt_kputs(" power_supply list\n"); + rt_kputs(" power_supply show \n"); + rt_kputs(" power_supply get \n"); + + return RT_EOK; +} +MSH_CMD_EXPORT(power_supply, power supply helper use power_supply list); + +#endif /* RT_USING_CONSOLE && RT_USING_MSH */ diff --git a/components/drivers/regulator/Kconfig b/components/drivers/regulator/Kconfig index 9137bc4e58d..17d2f5b17aa 100644 --- a/components/drivers/regulator/Kconfig +++ b/components/drivers/regulator/Kconfig @@ -2,12 +2,13 @@ menuconfig RT_USING_REGULATOR bool "Using Voltage and Current Regulator" select RT_USING_ADT select RT_USING_ADT_REF - depends on RT_USING_DM default n config RT_REGULATOR_FIXED bool "Fixed regulator support" depends on RT_USING_REGULATOR + depends on RT_USING_DM + depends on RT_USING_OFW depends on RT_USING_PIN depends on RT_USING_PINCTRL default y @@ -15,6 +16,8 @@ config RT_REGULATOR_FIXED config RT_REGULATOR_GPIO bool "GPIO regulator support" depends on RT_USING_REGULATOR + depends on RT_USING_DM + depends on RT_USING_OFW depends on RT_USING_PIN default y diff --git a/components/drivers/regulator/SConscript b/components/drivers/regulator/SConscript index f95f49b196d..2069f508695 100755 --- a/components/drivers/regulator/SConscript +++ b/components/drivers/regulator/SConscript @@ -8,7 +8,7 @@ if not GetDepend(['RT_USING_REGULATOR']): cwd = GetCurrentDir() CPPPATH = [cwd + '/../include'] -src = ['regulator.c', 'regulator_dm.c'] +src = ['regulator.c', 'regulator_dm.c', 'regulator_cmd.c'] if GetDepend(['RT_REGULATOR_FIXED']): src += ['regulator-fixed.c'] diff --git a/components/drivers/regulator/regulator.c b/components/drivers/regulator/regulator.c index d335c3b6807..61c429f1dfe 100644 --- a/components/drivers/regulator/regulator.c +++ b/components/drivers/regulator/regulator.c @@ -6,32 +6,69 @@ * Change Logs: * Date Author Notes * 2023-09-23 GuEe-GUI first version + * 2026-03-27 Evlers add current support and break away from reliance on DM, + * and solve the problem of enabling counting. */ #include #include +#include #define DBG_TAG "rtdm.regulator" #define DBG_LVL DBG_INFO #include -#include -#include -#include - struct rt_regulator { struct rt_regulator_node *reg_np; }; +struct rt_regulator_record +{ + rt_list_t list; + struct rt_regulator_node *reg_np; +}; + static RT_DEFINE_SPINLOCK(_regulator_lock); +static rt_list_t _regulator_records = RT_LIST_OBJECT_INIT(_regulator_records); static rt_err_t regulator_enable(struct rt_regulator_node *reg_np); static rt_err_t regulator_disable(struct rt_regulator_node *reg_np); +static struct rt_regulator_record *regulator_find_record_by_name(const char *name) +{ + struct rt_regulator_record *record = RT_NULL; + + rt_list_for_each_entry(record, &_regulator_records, list) + { + if (!rt_strcmp(record->reg_np->supply_name, name)) + { + return record; + } + } + + return RT_NULL; +} + +static struct rt_regulator_record *regulator_find_record_by_node(struct rt_regulator_node *reg_np) +{ + struct rt_regulator_record *record = RT_NULL; + + rt_list_for_each_entry(record, &_regulator_records, list) + { + if (record->reg_np == reg_np) + { + return record; + } + } + + return RT_NULL; +} + rt_err_t rt_regulator_register(struct rt_regulator_node *reg_np) { rt_err_t err; + struct rt_regulator_record *record; const struct rt_regulator_param *param; if (!reg_np || !reg_np->dev || !reg_np->param || !reg_np->ops) @@ -59,6 +96,28 @@ rt_err_t rt_regulator_register(struct rt_regulator_node *reg_np) } } + rt_hw_spin_lock(&_regulator_lock.lock); + + if (regulator_find_record_by_name(reg_np->supply_name)) + { + rt_hw_spin_unlock(&_regulator_lock.lock); + return -RT_EBUSY; + } + + record = rt_calloc(1, sizeof(*record)); + + if (!record) + { + rt_hw_spin_unlock(&_regulator_lock.lock); + return -RT_ENOMEM; + } + + record->reg_np = reg_np; + rt_list_init(&record->list); + rt_list_insert_before(&_regulator_records, &record->list); + + rt_hw_spin_unlock(&_regulator_lock.lock); + #ifdef RT_USING_OFW if (reg_np->dev->ofw_node) { @@ -77,6 +136,7 @@ rt_err_t rt_regulator_register(struct rt_regulator_node *reg_np) rt_err_t rt_regulator_unregister(struct rt_regulator_node *reg_np) { rt_err_t err = RT_EOK; + struct rt_regulator_record *record; if (!reg_np) { @@ -109,9 +169,21 @@ rt_err_t rt_regulator_unregister(struct rt_regulator_node *reg_np) reg_np->parent = RT_NULL; rt_list_remove(®_np->list); + record = regulator_find_record_by_node(reg_np); + + if (record) + { + rt_list_remove(&record->list); + } + _unlock: rt_hw_spin_unlock(&_regulator_lock.lock); + if (!err && record) + { + rt_free(record); + } + return err; } @@ -286,7 +358,6 @@ static rt_err_t regulator_enable(struct rt_regulator_node *reg_np) regulator_delay(enable_delay); } - rt_atomic_add(®_np->enabled_count, 1); err = regulator_notifier_call_chain(reg_np, RT_REGULATOR_MSG_ENABLE, RT_NULL); } } @@ -302,6 +373,7 @@ static rt_err_t regulator_enable(struct rt_regulator_node *reg_np) rt_err_t rt_regulator_enable(struct rt_regulator *reg) { rt_err_t err; + int enabled_cnt; if (!reg) { @@ -310,11 +382,20 @@ rt_err_t rt_regulator_enable(struct rt_regulator *reg) if (rt_regulator_is_enabled(reg)) { + rt_atomic_add(®->reg_np->enabled_count, 1); return RT_EOK; } rt_hw_spin_lock(&_regulator_lock.lock); + enabled_cnt = rt_atomic_load(®->reg_np->enabled_count); + if (enabled_cnt > 0) + { + rt_atomic_add(®->reg_np->enabled_count, 1); + rt_hw_spin_unlock(&_regulator_lock.lock); + return RT_EOK; + } + err = regulator_enable(reg->reg_np); rt_hw_spin_unlock(&_regulator_lock.lock); @@ -351,7 +432,8 @@ static rt_err_t regulator_disable(struct rt_regulator_node *reg_np) rt_err_t rt_regulator_disable(struct rt_regulator *reg) { - rt_err_t err; + rt_err_t err = RT_EOK; + int enabled_cnt; if (!reg) { @@ -363,16 +445,15 @@ rt_err_t rt_regulator_disable(struct rt_regulator *reg) return RT_EOK; } - if (rt_atomic_load(®->reg_np->enabled_count) != 0) - { - rt_atomic_sub(®->reg_np->enabled_count, 1); - - return RT_EOK; - } - rt_hw_spin_lock(&_regulator_lock.lock); - err = regulator_disable(reg->reg_np); + enabled_cnt = rt_atomic_load(®->reg_np->enabled_count); + rt_atomic_sub(®->reg_np->enabled_count, 1); + + if (enabled_cnt == 1) + { + err = regulator_disable(reg->reg_np); + } rt_hw_spin_unlock(&_regulator_lock.lock); @@ -383,7 +464,7 @@ rt_bool_t rt_regulator_is_enabled(struct rt_regulator *reg) { if (!reg) { - return -RT_EINVAL; + return RT_FALSE; } if (reg->reg_np->ops->is_enabled) @@ -440,6 +521,41 @@ static rt_err_t regulator_set_voltage(struct rt_regulator_node *reg_np, int min_ return err; } +static rt_err_t regulator_set_current(struct rt_regulator_node *reg_np, int min_uamp, int max_uamp) +{ + rt_err_t err = RT_EOK; + + if (reg_np->ops->set_current) + { + union rt_regulator_notifier_args args; + + RT_ASSERT(reg_np->ops->get_current != RT_NULL); + + args.old_uamp = reg_np->ops->get_current(reg_np); + args.min_uamp = min_uamp; + args.max_uamp = max_uamp; + + err = regulator_notifier_call_chain(reg_np, RT_REGULATOR_MSG_CURRENT_CHANGE, &args); + + if (!err) + { + err = reg_np->ops->set_current(reg_np, min_uamp, max_uamp); + } + + if (err) + { + regulator_notifier_call_chain(reg_np, RT_REGULATOR_MSG_CURRENT_CHANGE_ERR, + (void *)(rt_base_t)args.old_uamp); + } + } + else + { + err = -RT_ENOSYS; + } + + return err; +} + rt_bool_t rt_regulator_is_supported_voltage(struct rt_regulator *reg, int min_uvolt, int max_uvolt) { const struct rt_regulator_param *param; @@ -502,6 +618,71 @@ int rt_regulator_get_voltage(struct rt_regulator *reg) return uvolt; } +rt_bool_t rt_regulator_is_supported_current(struct rt_regulator *reg, int min_uamp, int max_uamp) +{ + const struct rt_regulator_param *param; + + if (!reg) + { + return RT_FALSE; + } + + param = reg->reg_np->param; + + if (!param || param->max_uamp <= 0) + { + return RT_FALSE; + } + + return param->min_uamp <= min_uamp && param->max_uamp >= max_uamp; +} + +rt_err_t rt_regulator_set_current(struct rt_regulator *reg, int min_uamp, int max_uamp) +{ + rt_err_t err; + + if (!reg) + { + return -RT_EINVAL; + } + + rt_hw_spin_lock(&_regulator_lock.lock); + + err = regulator_set_current(reg->reg_np, min_uamp, max_uamp); + + rt_hw_spin_unlock(&_regulator_lock.lock); + + return err; +} + +int rt_regulator_get_current(struct rt_regulator *reg) +{ + int uamp = RT_REGULATOR_UAMP_INVALID; + struct rt_regulator_node *reg_np; + + if (!reg) + { + return -RT_EINVAL; + } + + rt_hw_spin_lock(&_regulator_lock.lock); + + reg_np = reg->reg_np; + + if (reg_np->ops->get_current) + { + uamp = reg_np->ops->get_current(reg_np); + } + else + { + uamp = -RT_ENOSYS; + } + + rt_hw_spin_unlock(&_regulator_lock.lock); + + return uamp; +} + rt_err_t rt_regulator_set_mode(struct rt_regulator *reg, rt_uint32_t mode) { rt_err_t err; @@ -603,14 +784,14 @@ struct rt_regulator *rt_regulator_get(struct rt_device *dev, const char *id) struct rt_regulator *reg = RT_NULL; struct rt_regulator_node *reg_np = RT_NULL; - if (!dev || !id) + if (!id) { reg = rt_err_ptr(-RT_EINVAL); goto _end; } #ifdef RT_USING_OFW - if (dev->ofw_node) + if (dev && dev->ofw_node) { rt_phandle supply_phandle; struct rt_ofw_node *np = dev->ofw_node; @@ -639,6 +820,19 @@ struct rt_regulator *rt_regulator_get(struct rt_device *dev, const char *id) } #endif /* RT_USING_OFW */ + if (!reg_np) + { + struct rt_regulator_record *record; + + rt_hw_spin_lock(&_regulator_lock.lock); + record = regulator_find_record_by_name(id); + if (record) + { + reg_np = record->reg_np; + } + rt_hw_spin_unlock(&_regulator_lock.lock); + } + if (!reg_np) { goto _end; @@ -682,3 +876,63 @@ void rt_regulator_put(struct rt_regulator *reg) rt_ref_put(®->reg_np->ref, ®ulator_release); rt_free(reg); } + +struct rt_regulator_node **rt_regulator_nodes_snapshot(rt_size_t *count) +{ + struct rt_regulator_record *record; + struct rt_regulator_node **nodes; + rt_size_t total = 0; + rt_size_t idx = 0; + + if (!count) + { + return RT_NULL; + } + + *count = 0; + + rt_hw_spin_lock(&_regulator_lock.lock); + rt_list_for_each_entry(record, &_regulator_records, list) + { + total++; + } + rt_hw_spin_unlock(&_regulator_lock.lock); + + if (!total) + { + return RT_NULL; + } + + nodes = rt_calloc(total, sizeof(*nodes)); + if (!nodes) + { + return RT_NULL; + } + + rt_hw_spin_lock(&_regulator_lock.lock); + rt_list_for_each_entry(record, &_regulator_records, list) + { + nodes[idx] = record->reg_np; + rt_ref_get(&record->reg_np->ref); + idx++; + } + rt_hw_spin_unlock(&_regulator_lock.lock); + + *count = total; + return nodes; +} + +void rt_regulator_nodes_snapshot_free(struct rt_regulator_node **nodes, rt_size_t count) +{ + if (!nodes) + { + return; + } + + while (count--) + { + rt_ref_put(&nodes[count]->ref, ®ulator_release); + } + + rt_free(nodes); +} diff --git a/components/drivers/regulator/regulator_cmd.c b/components/drivers/regulator/regulator_cmd.c new file mode 100644 index 00000000000..c3438b24984 --- /dev/null +++ b/components/drivers/regulator/regulator_cmd.c @@ -0,0 +1,548 @@ +/* + * Copyright (c) 2006-2026, RT-Thread Development Team + * + * SPDX-License-Identifier: Apache-2.0 + * + * Change Logs: + * Date Author Notes + * 2026-03-27 Evlers first version + */ + +#include + +#ifdef RT_USING_FINSH + +#include +#include + +static void regulator_msh_usage(void) +{ + rt_kprintf("Usage:\n"); + rt_kprintf(" regulator list\n"); + rt_kprintf(" regulator info \n"); + rt_kprintf(" regulator on|off|status\n"); + rt_kprintf(" regulator getv\n"); + rt_kprintf(" regulator setv [max_uV]\n"); + rt_kprintf(" regulator getc\n"); + rt_kprintf(" regulator setc [max_uA]\n"); +} + +static rt_bool_t regulator_node_is_enabled(struct rt_regulator_node *node) +{ + if (!node) + { + return RT_FALSE; + } + + if (node->ops->is_enabled) + { + return node->ops->is_enabled(node); + } + + return rt_atomic_load(&node->enabled_count) > 0; +} + +static rt_err_t regulator_msh_parse_value(const char *str, int *out) +{ + char *endptr; + long value; + + if (!str || !out) + { + return -RT_EINVAL; + } + + value = strtol(str, &endptr, 10); + if (endptr == str || *endptr != '\0') + { + return -RT_EINVAL; + } + + if (value <= 0 || value > INT_MAX) + { + return -RT_EINVAL; + } + + *out = (int)value; + return RT_EOK; +} + +static rt_err_t regulator_msh_get_reg(const char *name, struct rt_regulator **out) +{ + struct rt_regulator *reg; + + if (!name || !out) + { + return -RT_EINVAL; + } + + reg = rt_regulator_get(RT_NULL, name); + if (!reg) + { + rt_kprintf("regulator '%s' not found\n", name); + return -RT_ERROR; + } + + if (rt_is_err(reg)) + { + rt_err_t err = rt_ptr_err(reg); + + rt_kprintf("regulator '%s' get failed: %d\n", name, err); + return err; + } + + *out = reg; + return RT_EOK; +} + +static struct rt_regulator_node *regulator_find_node_by_name(const char *name) +{ + struct rt_regulator_node **nodes; + struct rt_regulator_node *result = RT_NULL; + rt_size_t count = 0; + rt_size_t i; + + if (!name) + { + return RT_NULL; + } + + nodes = rt_regulator_nodes_snapshot(&count); + if (!nodes) + { + return RT_NULL; + } + + for (i = 0; i < count; ++i) + { + if (nodes[i]->supply_name && !rt_strcmp(nodes[i]->supply_name, name)) + { + result = nodes[i]; + break; + } + } + + rt_regulator_nodes_snapshot_free(nodes, count); + return result; +} + +static rt_err_t regulator_msh_info(const char *name) +{ + struct rt_regulator *reg; + struct rt_regulator_node *node; + const struct rt_regulator_param *param; + rt_err_t err; + int value; + + node = regulator_find_node_by_name(name); + if (!node) + { + rt_kprintf("regulator '%s' not found\n", name ? name : "(null)"); + return -RT_ERROR; + } + + err = regulator_msh_get_reg(name, ®); + if (err) + { + return err; + } + + param = node->param; + + rt_kprintf("Regulator info:\n"); + rt_kprintf(" name : %s\n", node->supply_name ? node->supply_name : "(null)"); + rt_kprintf(" state : %s\n", regulator_node_is_enabled(node) ? "on" : "off"); + rt_kprintf(" enabled_cnt : %d\n", rt_atomic_load(&node->enabled_count)); + + if (param) + { + rt_kprintf(" boot_on : %d\n", param->boot_on); + rt_kprintf(" always_on : %d\n", param->always_on); + if (param->min_uvolt || param->max_uvolt) + { + rt_kprintf(" volt_range : [%d, %d] uV\n", param->min_uvolt, param->max_uvolt); + } + if (param->min_uamp || param->max_uamp) + { + rt_kprintf(" curr_range : [%d, %d] uA\n", param->min_uamp, param->max_uamp); + } + if (param->enable_delay) + { + rt_kprintf(" enable_delay: %d us\n", param->enable_delay); + } + if (param->off_on_delay) + { + rt_kprintf(" off_on_delay: %d us\n", param->off_on_delay); + } + } + + value = rt_regulator_get_voltage(reg); + if (value >= 0) + { + rt_kprintf(" voltage_now : %d uV\n", value); + } + + value = rt_regulator_get_current(reg); + if (value >= 0) + { + rt_kprintf(" current_now : %d uA\n", value); + } + + value = rt_regulator_get_mode(reg); + if (value >= 0) + { + rt_kprintf(" mode : 0x%X\n", value); + } + + rt_regulator_put(reg); + + return RT_EOK; +} + +static void regulator_msh_list(void) +{ + struct rt_regulator_node **nodes; + rt_size_t count = 0; + rt_size_t idx; + + nodes = rt_regulator_nodes_snapshot(&count); + + rt_kprintf("Regulator list:\n"); + + if (!nodes || !count) + { + rt_kprintf(" (none)\n"); + return; + } + + for (idx = 0; idx < count; idx++) + { + rt_kprintf("%2d) %-20s state=%-3s boot_on=%d always_on=%d\n", + (int)(idx + 1), + nodes[idx]->supply_name ? nodes[idx]->supply_name : "(null)", + regulator_node_is_enabled(nodes[idx]) ? "on" : "off", + nodes[idx]->param ? nodes[idx]->param->boot_on : 0, + nodes[idx]->param ? nodes[idx]->param->always_on : 0); + } + + rt_kprintf("Total: %d\n", (int)count); + rt_regulator_nodes_snapshot_free(nodes, count); +} + +static rt_err_t regulator_msh_switch(const char *name, rt_bool_t enable) +{ + struct rt_regulator *reg; + struct rt_regulator_node *node; + rt_err_t err; + int enabled_cnt = -1; + + err = regulator_msh_get_reg(name, ®); + if (err) + { + return err; + } + + node = regulator_find_node_by_name(name); + + if (enable) + { + err = rt_regulator_enable(reg); + } + else + { + err = rt_regulator_disable(reg); + } + + if (err) + { + rt_kprintf("%s '%s' failed: %d\n", enable ? "enable" : "disable", name, err); + } + else + { + if (node) + { + enabled_cnt = (int)rt_atomic_load(&node->enabled_count); + } + + if (enabled_cnt >= 0) + { + rt_kprintf("regulator '%s' %s (enabled_cnt=%d)\n", name, + enable ? "enabled" : "disabled", enabled_cnt); + } + else + { + rt_kprintf("regulator '%s' %s\n", name, enable ? "enabled" : "disabled"); + } + } + + rt_regulator_put(reg); + return err; +} + +static rt_err_t regulator_msh_status(const char *name) +{ + struct rt_regulator *reg; + rt_err_t err; + + err = regulator_msh_get_reg(name, ®); + if (err) + { + return err; + } + + rt_kprintf("regulator '%s' is %s\n", name, rt_regulator_is_enabled(reg) ? "on" : "off"); + rt_regulator_put(reg); + + return RT_EOK; +} + +static rt_err_t regulator_msh_get_voltage_cmd(const char *name) +{ + struct rt_regulator *reg; + rt_err_t err; + int value; + + err = regulator_msh_get_reg(name, ®); + if (err) + { + return err; + } + + value = rt_regulator_get_voltage(reg); + if (value < 0) + { + rt_kprintf("get voltage of '%s' failed: %d\n", name, value); + err = value; + } + else + { + rt_kprintf("regulator '%s' voltage: %d uV\n", name, value); + } + + rt_regulator_put(reg); + return err; +} + +static rt_err_t regulator_msh_set_voltage_cmd(const char *name, const char *min_str, const char *max_str) +{ + struct rt_regulator *reg; + int min_uvolt; + int max_uvolt; + rt_err_t err; + + if ((err = regulator_msh_parse_value(min_str, &min_uvolt))) + { + rt_kprintf("invalid min_uV: %s\n", min_str ? min_str : "(null)"); + return err; + } + + if (max_str) + { + if ((err = regulator_msh_parse_value(max_str, &max_uvolt))) + { + rt_kprintf("invalid max_uV: %s\n", max_str); + return err; + } + } + else + { + max_uvolt = min_uvolt; + } + + if (max_uvolt < min_uvolt) + { + rt_kprintf("max_uV must be >= min_uV\n"); + return -RT_EINVAL; + } + + err = regulator_msh_get_reg(name, ®); + if (err) + { + return err; + } + + err = rt_regulator_set_voltage(reg, min_uvolt, max_uvolt); + if (err) + { + rt_kprintf("set voltage of '%s' failed: %d\n", name, err); + } + else + { + rt_kprintf("regulator '%s' voltage set to [%d, %d] uV\n", name, min_uvolt, max_uvolt); + } + + rt_regulator_put(reg); + return err; +} + +static rt_err_t regulator_msh_get_current_cmd(const char *name) +{ + struct rt_regulator *reg; + rt_err_t err; + int value; + + err = regulator_msh_get_reg(name, ®); + if (err) + { + return err; + } + + value = rt_regulator_get_current(reg); + if (value < 0) + { + rt_kprintf("get current of '%s' failed: %d\n", name, value); + err = value; + } + else + { + rt_kprintf("regulator '%s' current: %d uA\n", name, value); + } + + rt_regulator_put(reg); + return err; +} + +static rt_err_t regulator_msh_set_current_cmd(const char *name, const char *min_str, const char *max_str) +{ + struct rt_regulator *reg; + int min_uamp; + int max_uamp; + rt_err_t err; + + if ((err = regulator_msh_parse_value(min_str, &min_uamp))) + { + rt_kprintf("invalid min_uA: %s\n", min_str ? min_str : "(null)"); + return err; + } + + if (max_str) + { + if ((err = regulator_msh_parse_value(max_str, &max_uamp))) + { + rt_kprintf("invalid max_uA: %s\n", max_str); + return err; + } + } + else + { + max_uamp = min_uamp; + } + + if (max_uamp < min_uamp) + { + rt_kprintf("max_uA must be >= min_uA\n"); + return -RT_EINVAL; + } + + err = regulator_msh_get_reg(name, ®); + if (err) + { + return err; + } + + if (!rt_regulator_is_supported_current(reg, min_uamp, max_uamp)) + { + rt_kprintf("regulator '%s' does not support current setting in [%d, %d] uA\n", + name, min_uamp, max_uamp); + rt_regulator_put(reg); + return -RT_ENOSYS; + } + + err = rt_regulator_set_current(reg, min_uamp, max_uamp); + if (err) + { + rt_kprintf("set current of '%s' failed: %d\n", name, err); + } + else + { + rt_kprintf("regulator '%s' current set to [%d, %d] uA\n", name, min_uamp, max_uamp); + } + + rt_regulator_put(reg); + return err; +} + +static int regulator_msh(int argc, char **argv) +{ + if (argc < 2) + { + regulator_msh_usage(); + return RT_EOK; + } + + if (!rt_strcmp(argv[1], "list")) + { + regulator_msh_list(); + return RT_EOK; + } + + if (!rt_strcmp(argv[1], "info")) + { + if (argc < 3) + { + regulator_msh_usage(); + return -RT_EINVAL; + } + + return regulator_msh_info(argv[2]); + } + + if (argc < 3) + { + regulator_msh_usage(); + return -RT_EINVAL; + } + + if (!rt_strcmp(argv[2], "on")) + { + return regulator_msh_switch(argv[1], RT_TRUE); + } + + if (!rt_strcmp(argv[2], "off")) + { + return regulator_msh_switch(argv[1], RT_FALSE); + } + + if (!rt_strcmp(argv[2], "status")) + { + return regulator_msh_status(argv[1]); + } + + if (!rt_strcmp(argv[2], "getv")) + { + return regulator_msh_get_voltage_cmd(argv[1]); + } + + if (!rt_strcmp(argv[2], "setv")) + { + if (argc < 4) + { + regulator_msh_usage(); + return -RT_EINVAL; + } + + return regulator_msh_set_voltage_cmd(argv[1], argv[3], argc >= 5 ? argv[4] : RT_NULL); + } + + if (!rt_strcmp(argv[2], "getc")) + { + return regulator_msh_get_current_cmd(argv[1]); + } + + if (!rt_strcmp(argv[2], "setc")) + { + if (argc < 4) + { + regulator_msh_usage(); + return -RT_EINVAL; + } + + return regulator_msh_set_current_cmd(argv[1], argv[3], argc >= 5 ? argv[4] : RT_NULL); + } + + regulator_msh_usage(); + return -RT_EINVAL; +} +MSH_CMD_EXPORT_ALIAS(regulator_msh, regulator, regulator command); + +#endif /* RT_USING_FINSH */ diff --git a/components/drivers/regulator/regulator_dm.h b/components/drivers/regulator/regulator_dm.h index 207bb127946..eabe4912f96 100644 --- a/components/drivers/regulator/regulator_dm.h +++ b/components/drivers/regulator/regulator_dm.h @@ -6,6 +6,7 @@ * Change Logs: * Date Author Notes * 2023-09-23 GuEe-GUI first version + * 2026-03-27 Evlers stub out regulator_ofw_parse when OFW disabled */ #ifndef __REGULATOR_DM_H__ @@ -17,8 +18,10 @@ #ifdef RT_USING_OFW rt_err_t regulator_ofw_parse(struct rt_ofw_node *np, struct rt_regulator_param *param); #else -rt_inline rt_err_t regulator_ofw_parse(struct rt_ofw_node *np, struct rt_regulator_param *param); +rt_inline rt_err_t regulator_ofw_parse(void *np, struct rt_regulator_param *param) { + RT_UNUSED(np); + RT_UNUSED(param); return RT_EOK; } #endif /* RT_USING_OFW */ diff --git a/include/rtdef.h b/include/rtdef.h index 0dc919e77e4..db711aadff8 100644 --- a/include/rtdef.h +++ b/include/rtdef.h @@ -935,6 +935,8 @@ struct rt_thread #ifdef RT_USING_CPU_USAGE_TRACER rt_ubase_t user_time; /**< Ticks on user */ rt_ubase_t system_time; /**< Ticks on system */ + rt_ubase_t total_time_prev; /**< Previous total ticks snapshot */ + rt_uint8_t cpu_usage; /**< Recent CPU usage in percent */ #endif /* RT_USING_CPU_USAGE_TRACER */ #ifdef RT_USING_MEM_PROTECTION diff --git a/include/rtthread.h b/include/rtthread.h index 08c57f58101..486ad7a3028 100644 --- a/include/rtthread.h +++ b/include/rtthread.h @@ -218,6 +218,7 @@ rt_err_t rt_thread_idle_sethook(void (*hook)(void)); rt_err_t rt_thread_idle_delhook(void (*hook)(void)); #endif /* defined(RT_USING_HOOK) || defined(RT_USING_IDLE_HOOK) */ rt_thread_t rt_thread_idle_gethandler(void); +rt_bool_t rt_thread_is_idle_thread(rt_thread_t thread); /* * schedule service diff --git a/src/Kconfig b/src/Kconfig index ee1ecbd1269..b35bcd2e68d 100644 --- a/src/Kconfig +++ b/src/Kconfig @@ -199,6 +199,17 @@ config RT_USING_CPU_USAGE_TRACER percentage information through the list thread command. It will automatically integrate with the scheduler to track thread execution time. +if RT_USING_CPU_USAGE_TRACER + config RT_CPU_USAGE_CALC_INTERVAL_MS + int "CPU usage sampling interval (ms)" + default 200 + range 50 5000 + help + Sampling window for thread CPU usage display. + A shorter interval updates faster but fluctuates more. + A longer interval is smoother but has higher display latency. +endif + menu "kservice options" config RT_USING_TINY_FFS bool "Enable kservice to use tiny finding first bit set method" diff --git a/src/idle.c b/src/idle.c index 9a048061990..64ee6156c56 100644 --- a/src/idle.c +++ b/src/idle.c @@ -212,4 +212,42 @@ rt_thread_t rt_thread_idle_gethandler(void) return (rt_thread_t)(&idle_thread[id]); } +/** + * @brief Check whether the specified thread is one of the system idle threads. + * + * @details + * RT-Thread creates an idle thread for each CPU. These idle threads are special + * scheduler-owned threads that act as the fallback runnable threads when no + * other ready thread exists. + * + * This helper is mainly used for defensive checks in code paths that may block + * or suspend a thread, because an idle thread must never enter a blocking or + * suspended state. Suspending an idle thread may leave the system with no ready + * thread and break scheduling. + * + * @param thread The thread to test. + * + * @return RT_TRUE if @p thread is an idle thread of any CPU; otherwise RT_FALSE. + * + * @note + * - In SMP configurations, there is one idle thread per CPU, so this function + * checks against all idle thread objects. + * - Passing RT_NULL returns RT_FALSE. + */ +rt_bool_t rt_thread_is_idle_thread(rt_thread_t thread) +{ + rt_ubase_t i; + + if (thread != RT_NULL) + { + for (i = 0; i < _CPUS_NR; i++) + { + if (thread == &idle_thread[i]) + return RT_TRUE; + } + } + + return RT_FALSE; +} + /** @} group_thread_management */ diff --git a/src/kservice.c b/src/kservice.c index 1c77acac8a3..5a5ea24331d 100644 --- a/src/kservice.c +++ b/src/kservice.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2006-2024, RT-Thread Development Team + * Copyright (c) 2006-2026, RT-Thread Development Team * * SPDX-License-Identifier: Apache-2.0 * @@ -28,6 +28,7 @@ * 2023-10-21 Shell support the common backtrace API which is arch-independent * 2023-12-10 xqyjlj perf rt_hw_interrupt_disable/enable, fix memheap lock * 2024-03-10 Meco Man move std libc related functions to rtklibc + * 2026-03-16 Rbb666 Change rt_thread_get_usage to incremental statistics. */ #include @@ -572,49 +573,174 @@ rt_err_t rt_backtrace_thread(rt_thread_t thread) } #ifdef RT_USING_CPU_USAGE_TRACER + +#define RT_CPU_USAGE_CALC_INTERVAL_TICK \ + ((RT_TICK_PER_SECOND * RT_CPU_USAGE_CALC_INTERVAL_MS + 999U) / 1000U) + +static rt_tick_t _cpu_usage_sample_tick; +static rt_bool_t _cpu_usage_inited = RT_FALSE; +static struct rt_cpu_usage_stats _cpu_usage_prev_cpu_stat[RT_CPUS_NR]; +static struct rt_spinlock _cpu_usage_lock = RT_SPINLOCK_INIT; + +/* + * Calculate total CPU-time delta for this sampling window and + * refresh per-CPU snapshots. + * + * Each counter delta is computed in rt_ubase_t width first, so wrap-around + * on 32-bit targets is handled naturally by unsigned arithmetic. + */ +static rt_uint64_t _cpu_usage_calc_total_delta(void) +{ + rt_uint64_t total_delta = 0; + int i; + + for (i = 0; i < RT_CPUS_NR; i++) + { + rt_cpu_t pcpu = rt_cpu_index(i); + rt_ubase_t user_now = pcpu->cpu_stat.user; + rt_ubase_t system_now = pcpu->cpu_stat.system; + rt_ubase_t idle_now = pcpu->cpu_stat.idle; + + /* Per-counter delta first to avoid overflow artifacts after sum. */ + rt_ubase_t user_delta = (rt_ubase_t)(user_now - _cpu_usage_prev_cpu_stat[i].user); + rt_ubase_t system_delta = (rt_ubase_t)(system_now - _cpu_usage_prev_cpu_stat[i].system); + rt_ubase_t idle_delta = (rt_ubase_t)(idle_now - _cpu_usage_prev_cpu_stat[i].idle); + + total_delta += (rt_uint64_t)user_delta; + total_delta += (rt_uint64_t)system_delta; + total_delta += (rt_uint64_t)idle_delta; + + _cpu_usage_prev_cpu_stat[i].user = user_now; + _cpu_usage_prev_cpu_stat[i].system = system_now; + _cpu_usage_prev_cpu_stat[i].idle = idle_now; + } + + return total_delta; +} + +static void _cpu_usage_snapshot_init(void) +{ + struct rt_object_information *info; + rt_list_t *list; + rt_list_t *node; + rt_base_t level; + int i; + + info = rt_object_get_information(RT_Object_Class_Thread); + list = &info->object_list; + + level = rt_spin_lock_irqsave(&info->spinlock); + for (node = list->next; node != list; node = node->next) + { + struct rt_object *obj = rt_list_entry(node, struct rt_object, list); + struct rt_thread *t = (struct rt_thread *)obj; + + t->total_time_prev = 0U; + t->cpu_usage = 0U; + } + rt_spin_unlock_irqrestore(&info->spinlock, level); + + for (i = 0; i < RT_CPUS_NR; i++) + { + _cpu_usage_prev_cpu_stat[i].user = 0U; + _cpu_usage_prev_cpu_stat[i].system = 0U; + _cpu_usage_prev_cpu_stat[i].idle = 0U; + } + + _cpu_usage_sample_tick = rt_tick_get(); + _cpu_usage_inited = RT_TRUE; +} + +static void _cpu_usage_refresh_threads(rt_uint64_t total_delta) +{ + struct rt_object_information *info; + rt_list_t *list; + rt_list_t *node; + rt_base_t level; + + info = rt_object_get_information(RT_Object_Class_Thread); + list = &info->object_list; + + level = rt_spin_lock_irqsave(&info->spinlock); + for (node = list->next; node != list; node = node->next) + { + struct rt_object *obj = rt_list_entry(node, struct rt_object, list); + struct rt_thread *t = (struct rt_thread *)obj; + rt_ubase_t total_now = (rt_ubase_t)(t->user_time + t->system_time); + rt_ubase_t total_delta_now = (rt_ubase_t)(total_now - t->total_time_prev); + rt_uint64_t thread_delta = (rt_uint64_t)total_delta_now; + + if (total_delta > 0U) + { + rt_uint64_t usage = (thread_delta * 100U) / total_delta; + t->cpu_usage = (rt_uint8_t)(usage > 100U ? 100U : usage); + } + else + { + t->cpu_usage = 0U; + } + + t->total_time_prev = total_now; + } + rt_spin_unlock_irqrestore(&info->spinlock, level); +} + +static void _cpu_usage_update(void) +{ + rt_tick_t tick_now; + rt_tick_t delta_tick; + rt_uint64_t total_delta; + rt_bool_t bypass_interval_check = RT_FALSE; + + if (!_cpu_usage_inited) + { + _cpu_usage_snapshot_init(); + bypass_interval_check = RT_TRUE; + } + + tick_now = rt_tick_get(); + delta_tick = rt_tick_get_delta(_cpu_usage_sample_tick); + if (!bypass_interval_check && delta_tick < RT_CPU_USAGE_CALC_INTERVAL_TICK) + { + return; + } + + total_delta = _cpu_usage_calc_total_delta(); + _cpu_usage_refresh_threads(total_delta); + _cpu_usage_sample_tick = tick_now; +} + /** - * @brief Get thread usage percentage relative to total system CPU time + * @brief Get thread CPU usage percentage in the recent sampling window * - * This function calculates the CPU usage percentage of a specific thread - * relative to the total CPU time consumed by all threads in the system. + * This function returns per-thread CPU usage based on delta runtime in the + * latest sampling window, rather than cumulative runtime since boot. * * @param thread Pointer to the thread object. Must not be NULL. * * @return The CPU usage percentage as an integer value (0-100). - * Returns 0 if total system time is 0 or if CPU usage tracing is not enabled. + * If sampling interval has not elapsed yet, the previous cached value + * is returned (initial value is 0). * * @note This function requires RT_USING_CPU_USAGE_TRACER to be enabled. - * @note The percentage is calculated as: (thread_time * 100) / total_system_time - * @note Due to integer arithmetic, the result is truncated and may not sum - * to exactly 100% across all threads due to rounding. + * @note The percentage is calculated as + * (thread_time_delta * 100) / total_time_delta, + * where total_time_delta is the sum of user/system/idle deltas of all CPUs. + * @note Sampling interval can be tuned with RT_CPU_USAGE_CALC_INTERVAL_MS. * @note If thread is NULL, an assertion will be triggered in debug builds. */ rt_uint8_t rt_thread_get_usage(rt_thread_t thread) { - rt_ubase_t thread_time; - rt_ubase_t total_time = 0U; - int i; - rt_cpu_t pcpu; + rt_uint8_t usage; RT_ASSERT(thread != RT_NULL); - thread_time = thread->user_time + thread->system_time; - - /* Calculate total system time by summing all CPUs' time */ - for (i = 0; i < RT_CPUS_NR; i++) - { - pcpu = rt_cpu_index(i); - total_time += pcpu->cpu_stat.user + pcpu->cpu_stat.system + pcpu->cpu_stat.idle; - } - - if (total_time > 0U) - { - /* Calculate thread usage percentage: (thread_time * 100) / total_time */ - rt_ubase_t usage = (thread_time * 100U) / total_time; - return (rt_uint8_t)(usage > 100U ? 100U : usage); - } + rt_spin_lock(&_cpu_usage_lock); + _cpu_usage_update(); + usage = thread->cpu_usage; + rt_spin_unlock(&_cpu_usage_lock); - return 0U; + return usage; } #endif /* RT_USING_CPU_USAGE_TRACER */ diff --git a/src/thread.c b/src/thread.c index 15e4ee45e85..745e3f774f2 100644 --- a/src/thread.c +++ b/src/thread.c @@ -277,6 +277,13 @@ static rt_err_t _thread_init(struct rt_thread *thread, thread->system_time = 0; #endif +#ifdef RT_USING_CPU_USAGE_TRACER + thread->user_time = 0; + thread->system_time = 0; + thread->total_time_prev = 0; + thread->cpu_usage = 0; +#endif /* RT_USING_CPU_USAGE_TRACER */ + #ifdef RT_USING_PTHREADS thread->pthread_data = RT_NULL; #endif /* RT_USING_PTHREADS */ @@ -943,6 +950,7 @@ rt_err_t rt_thread_suspend_to_list(rt_thread_t thread, rt_list_t *susp_list, int /* parameter check */ RT_ASSERT(thread != RT_NULL); RT_ASSERT(rt_object_get_type((rt_object_t)thread) == RT_Object_Class_Thread); + RT_ASSERT(!rt_thread_is_idle_thread(thread)); LOG_D("thread suspend: %s", thread->parent.name);