[dm][power] add new drivers for power framework
ToolsCI / Tools (push) Has been cancelled
RT-Thread BSP Static Build Check / 🔍 Summary of Git Diff Changes (push) Has been cancelled
doc_doxygen / doxygen_doc generate (push) Has been cancelled
pkgs_test / change (push) Has been cancelled
utest_auto_run / A9 :components/dfs.cfg (push) Has been cancelled
utest_auto_run / A9 :components/lwip.cfg (push) Has been cancelled
utest_auto_run / A9 :components/netdev.cfg (push) Has been cancelled
utest_auto_run / A9 :components/sal.cfg (push) Has been cancelled
utest_auto_run / A9 :cpp11/cpp11.cfg (push) Has been cancelled
utest_auto_run / AARCH64-rtsmart :default.cfg (push) Has been cancelled
utest_auto_run / A9-rtsmart :default.cfg (push) Has been cancelled
utest_auto_run / RISCV-rtsmart :default.cfg (push) Has been cancelled
utest_auto_run / XUANTIE-rtsmart :default.cfg (push) Has been cancelled
utest_auto_run / AARCH64 :default.cfg (push) Has been cancelled
utest_auto_run / AARCH64-smp :default.cfg (push) Has been cancelled
utest_auto_run / A9 :default.cfg (push) Has been cancelled
utest_auto_run / A9-smp :default.cfg (push) Has been cancelled
utest_auto_run / RISCV :default.cfg (push) Has been cancelled
utest_auto_run / RISCV-smp :default.cfg (push) Has been cancelled
utest_auto_run / A9 :kernel/atomic_c11.cfg (push) Has been cancelled
utest_auto_run / RISCV :kernel/atomic_c11.cfg (push) Has been cancelled
utest_auto_run / A9 :kernel/ipc.cfg (push) Has been cancelled
utest_auto_run / A9 :kernel/kernel_basic.cfg (push) Has been cancelled
utest_auto_run / A9 :kernel/mem.cfg (push) Has been cancelled
RT-Thread BSP Static Build Check / ${{ matrix.legs.RTT_BSP }} (push) Has been cancelled
RT-Thread BSP Static Build Check / collect-artifacts (push) Has been cancelled
doc_doxygen / deploy (push) Has been cancelled
Weekly CI Scheduler / Trigger and Monitor CIs (push) Has been cancelled
Weekly CI Scheduler / Create Discussion Report (push) Has been cancelled

1. GPIO poweroff/restart
2. Generic SYSCON regmap poweroff/reboot mode/reboot
3. Emulator battery(thermal)/charger
4. GPIO charger

Signed-off-by: GuEe-GUI <2991707448@qq.com>
This commit is contained in:
GuEe-GUI authored and R b b666 committed 2025-12-17 10:29:05 +08:00
1 parent b4d332706e
commit df990e91d3
15 files changed
+1464

No files matched your search

+2
View File
@@ -0,0 +1,2 @@
rsource "reset/Kconfig"
rsource "supply/Kconfig"
+11
View File
@@ -0,0 +1,11 @@
from building import *
cwd = GetCurrentDir()
objs = []
list = os.listdir(cwd)
for d in list:
path = os.path.join(cwd, d)
if os.path.isfile(os.path.join(path, 'SConscript')):
objs = objs + SConscript(os.path.join(d, 'SConscript'))
Return('objs')
+32
View File
@@ -2,6 +2,38 @@ menuconfig RT_USING_POWER_RESET
bool "Using Board level reset or poweroff"
depends on RT_USING_DM
config RT_POWER_RESET_GPIO_POWEROFF
bool "GPIO poweroff"
depends on RT_USING_POWER_RESET
depends on RT_USING_PIN
depends on RT_USING_PINCTRL
config RT_POWER_RESET_GPIO_RESTART
bool "GPIO restart"
depends on RT_USING_POWER_RESET
depends on RT_USING_PIN
depends on RT_USING_PINCTRL
config RT_POWER_RESET_SYSCON_POWEROFF
bool "Generic SYSCON regmap poweroff driver"
depends on RT_USING_POWER_RESET
depends on RT_MFD_SYSCON
config RT_POWER_RESET_SYSCON_REBOOT_MODE
bool "Generic SYSCON regmap reboot mode driver"
depends on RT_USING_POWER_RESET
depends on RT_MFD_SYSCON
select RT_POWER_RESET_REBOOT_MODE
config RT_POWER_RESET_SYSCON_REBOOT
bool "Generic SYSCON regmap reboot driver"
depends on RT_USING_POWER_RESET
depends on RT_MFD_SYSCON
if RT_USING_POWER_RESET
osource "$(SOC_DM_POWER_RESET_DIR)/Kconfig"
endif
config RT_POWER_RESET_REBOOT_MODE
bool
depends on RT_USING_OFW
+18
View File
@@ -10,6 +10,24 @@ CPPPATH = [cwd + '/../../include']
src = []
if GetDepend(['RT_POWER_RESET_GPIO_POWEROFF']):
src += ['gpio-poweroff.c']
if GetDepend(['RT_POWER_RESET_GPIO_RESTART']):
src += ['gpio-restart.c']
if GetDepend(['RT_POWER_RESET_REBOOT_MODE']):
src += ['reboot-mode.c']
if GetDepend(['RT_POWER_RESET_SYSCON_POWEROFF']):
src += ['syscon-poweroff.c']
if GetDepend(['RT_POWER_RESET_SYSCON_REBOOT_MODE']):
src += ['syscon-reboot-mode.c']
if GetDepend(['RT_POWER_RESET_SYSCON_REBOOT']):
src += ['syscon-reboot.c']
group = DefineGroup('DeviceDrivers', src, depend = [''], CPPPATH = CPPPATH)
Return('group')
@@ -0,0 +1,100 @@
/*
* Copyright (c) 2006-2023, RT-Thread Development Team
*
* SPDX-License-Identifier: Apache-2.0
*
* Change Logs:
* Date Author Notes
* 2023-02-25 GuEe-GUI the first version
*/
#include <rtthread.h>
#include <rtdevice.h>
#define DBG_TAG "reset.gpio.poweroff"
#define DBG_LVL DBG_INFO
#include <rtdbg.h>
struct gpio_poweroff
{
rt_ubase_t pin;
rt_uint8_t active_value;
rt_uint32_t timeout_ms;
rt_uint32_t active_delay_ms;
rt_uint32_t inactive_delay_ms;
};
static rt_err_t gpio_poweroff_do_poweroff(struct rt_device *dev)
{
struct gpio_poweroff *gp = dev->user_data;
rt_pin_mode(gp->pin, PIN_MODE_OUTPUT);
rt_thread_mdelay(gp->active_delay_ms);
rt_pin_write(gp->pin, !gp->active_value);
rt_thread_mdelay(gp->inactive_delay_ms);
rt_pin_write(gp->pin, gp->active_value);
rt_thread_mdelay(gp->timeout_ms);
return RT_EOK;
}
static rt_err_t gpio_poweroff_probe(struct rt_platform_device *pdev)
{
rt_err_t err;
struct rt_device *dev = &pdev->parent;
struct gpio_poweroff *gp = rt_calloc(1, sizeof(*gp));
if (!gp)
{
return -RT_ENOMEM;
}
gp->pin = rt_pin_get_named_pin(dev, RT_NULL, 0, RT_NULL, &gp->active_value);
if (gp->pin < 0)
{
err = gp->pin;
goto _fail;
}
gp->active_delay_ms = 100;
gp->inactive_delay_ms = 100;
gp->timeout_ms = 3000;
rt_dm_dev_prop_read_u32(dev, "active-delay-ms", &gp->active_delay_ms);
rt_dm_dev_prop_read_u32(dev, "inactive-delay-ms", &gp->inactive_delay_ms);
rt_dm_dev_prop_read_u32(dev, "timeout-ms", &gp->timeout_ms);
dev->user_data = gp;
if ((err = rt_dm_power_off_handler(dev, RT_DM_POWER_OFF_MODE_SHUTDOWN,
RT_DM_POWER_OFF_PRIO_DEFAULT, gpio_poweroff_do_poweroff)))
{
goto _fail;
}
return RT_EOK;
_fail:
rt_free(gp);
return err;
}
static const struct rt_ofw_node_id gpio_poweroff_ofw_ids[] =
{
{ .compatible = "gpio-poweroff" },
{ /* sentinel */ }
};
static struct rt_platform_driver gpio_poweroff_driver =
{
.name = "reset-gpio-poweroff",
.ids = gpio_poweroff_ofw_ids,
.probe = gpio_poweroff_probe,
};
RT_PLATFORM_DRIVER_EXPORT(gpio_poweroff_driver);
@@ -0,0 +1,100 @@
/*
* Copyright (c) 2006-2023, RT-Thread Development Team
*
* SPDX-License-Identifier: Apache-2.0
*
* Change Logs:
* Date Author Notes
* 2023-02-25 GuEe-GUI the first version
*/
#include <rtthread.h>
#include <rtdevice.h>
#define DBG_TAG "reset.gpio.restart"
#define DBG_LVL DBG_INFO
#include <rtdbg.h>
struct gpio_restart
{
rt_ubase_t pin;
rt_uint8_t active_value;
rt_uint32_t wait_delay_ms;
rt_uint32_t active_delay_ms;
rt_uint32_t inactive_delay_ms;
};
static rt_err_t gpio_restart_do_restart(struct rt_device *dev)
{
struct gpio_restart *gr = dev->user_data;
rt_pin_mode(gr->pin, PIN_MODE_OUTPUT);
rt_thread_mdelay(gr->active_delay_ms);
rt_pin_write(gr->pin, !gr->active_value);
rt_thread_mdelay(gr->inactive_delay_ms);
rt_pin_write(gr->pin, gr->active_value);
rt_thread_mdelay(gr->wait_delay_ms);
return RT_EOK;
}
static rt_err_t gpio_restart_probe(struct rt_platform_device *pdev)
{
rt_err_t err;
struct rt_device *dev = &pdev->parent;
struct gpio_restart *gr = rt_calloc(1, sizeof(*gr));
if (!gr)
{
return -RT_ENOMEM;
}
gr->pin = rt_pin_get_named_pin(dev, RT_NULL, 0, RT_NULL, &gr->active_value);
if (gr->pin < 0)
{
err = gr->pin;
goto _fail;
}
gr->active_delay_ms = 100;
gr->inactive_delay_ms = 100;
gr->wait_delay_ms = 3000;
rt_dm_dev_prop_read_u32(dev, "active-delay", &gr->active_delay_ms);
rt_dm_dev_prop_read_u32(dev, "inactive-delay", &gr->inactive_delay_ms);
rt_dm_dev_prop_read_u32(dev, "wait-delay", &gr->wait_delay_ms);
dev->user_data = gr;
if ((err = rt_dm_power_off_handler(dev, RT_DM_POWER_OFF_MODE_RESET,
RT_DM_POWER_OFF_PRIO_DEFAULT, gpio_restart_do_restart)))
{
goto _fail;
}
return RT_EOK;
_fail:
rt_free(gr);
return err;
}
static const struct rt_ofw_node_id gpio_restart_ofw_ids[] =
{
{ .compatible = "gpio-restart" },
{ /* sentinel */ }
};
static struct rt_platform_driver gpio_restart_driver =
{
.name = "reset-gpio-restart",
.ids = gpio_restart_ofw_ids,
.probe = gpio_restart_probe,
};
RT_PLATFORM_DRIVER_EXPORT(gpio_restart_driver);
@@ -0,0 +1,105 @@
/*
* Copyright (c) 2006-2023, RT-Thread Development Team
*
* SPDX-License-Identifier: Apache-2.0
*
* Change Logs:
* Date Author Notes
* 2023-02-25 GuEe-GUI the first version
*/
#include "reboot-mode.h"
#define MODE_SUFFIXE "mode-"
struct mode_info
{
rt_slist_t list;
const char *mode;
rt_uint32_t magic;
};
static rt_err_t reboot_mode_work(struct rt_device *dev, char *cmd)
{
struct mode_info *info;
struct reboot_mode *reboot = (void *)dev;
cmd = cmd ? : "normal";
rt_slist_for_each_entry(info, &reboot->mode_nodes, list)
{
if (!rt_strcmp(info->mode, cmd))
{
reboot->write(reboot, info->magic);
break;
}
}
return RT_EOK;
}
rt_err_t reboot_mode_register(struct reboot_mode *reboot)
{
rt_err_t err;
struct mode_info *info;
struct rt_ofw_prop *prop;
struct rt_ofw_node *np = reboot->dev->ofw_node;
const int mode_suffixe_len = sizeof(MODE_SUFFIXE) - 1;
if (!reboot || !reboot->dev)
{
return -RT_EINVAL;
}
rt_slist_init(&reboot->mode_nodes);
rt_ofw_foreach_prop(np, prop)
{
if (rt_strncmp(prop->name, MODE_SUFFIXE, mode_suffixe_len))
{
continue;
}
info = rt_malloc(sizeof(*info));
if (!info)
{
err = -RT_ENOMEM;
goto _end;
}
info->mode = prop->name + mode_suffixe_len;
info->magic = fdt32_to_cpu(*(const fdt32_t *)prop->value);
rt_slist_init(&info->list);
rt_slist_insert(&reboot->mode_nodes, &info->list);
}
err = rt_dm_reboot_mode_register((void *)reboot, &reboot_mode_work);
_end:
if (err)
{
struct mode_info *prev_info = RT_NULL;
rt_slist_for_each_entry(info, &reboot->mode_nodes, list)
{
if (prev_info)
{
rt_free(prev_info);
}
prev_info = info;
}
if (prev_info)
{
rt_free(prev_info);
}
}
return err;
}
@@ -0,0 +1,27 @@
/*
* Copyright (c) 2006-2023, RT-Thread Development Team
*
* SPDX-License-Identifier: Apache-2.0
*
* Change Logs:
* Date Author Notes
* 2023-02-25 GuEe-GUI the first version
*/
#ifndef __RESET_REBOOT_MODE_H__
#define __RESET_REBOOT_MODE_H__
#include <rtthread.h>
#include <rtdevice.h>
struct reboot_mode
{
rt_slist_t mode_nodes;
struct rt_device *dev;
rt_err_t (*write)(struct reboot_mode *reboot, rt_uint32_t magic);
};
rt_err_t reboot_mode_register(struct reboot_mode *reboot);
#endif /* __RESET_REBOOT_MODE_H__ */
@@ -0,0 +1,104 @@
/*
* Copyright (c) 2006-2023, RT-Thread Development Team
*
* SPDX-License-Identifier: Apache-2.0
*
* Change Logs:
* Date Author Notes
* 2023-02-25 GuEe-GUI the first version
*/
#include <rtthread.h>
#include <rtdevice.h>
#define DBG_TAG "reset.syscon.poweroff"
#define DBG_LVL DBG_INFO
#include <rtdbg.h>
static struct rt_syscon *syscon;
static rt_uint32_t offset, value, mask;
static void syscon_poweroff(void)
{
/* Issue the poweroff */
rt_syscon_update_bits(syscon, offset, mask, value);
rt_thread_mdelay(1000);
LOG_E("Unable to poweroff system");
}
static rt_err_t syscon_poweroff_probe(struct rt_platform_device *pdev)
{
rt_err_t mask_err, value_err;
struct rt_ofw_node *np = pdev->parent.ofw_node;
syscon = rt_syscon_find_by_ofw_phandle(np, "regmap");
if (!syscon)
{
return -RT_ERROR;
}
if (rt_ofw_prop_read_u32(np, "offset", &offset))
{
LOG_E("read '%s' fail", "offset");
return -RT_EINVAL;
}
value_err = rt_ofw_prop_read_u32(np, "value", &value);
mask_err = rt_ofw_prop_read_u32(np, "mask", &mask);
if (value_err && mask_err)
{
LOG_E("read '%s' and '%s' fail", "value", "mask");
return -RT_EINVAL;
}
if (value_err)
{
/* support old binding */
value = mask;
mask = 0xffffffff;
}
else if (mask_err)
{
/* support value without mask */
mask = 0xffffffff;
}
if (rt_dm_machine_shutdown)
{
LOG_E("rt_dm_machine_shutdown have hook %p", rt_dm_machine_shutdown);
return -RT_EBUSY;
}
rt_dm_machine_shutdown = syscon_poweroff;
return RT_EOK;
}
static const struct rt_ofw_node_id syscon_poweroff_ofw_ids[] =
{
{ .compatible = "syscon-poweroff" },
{ /* sentinel */ }
};
static struct rt_platform_driver syscon_poweroff_driver =
{
.name = "reset-syscon-poweroff",
.ids = syscon_poweroff_ofw_ids,
.probe = syscon_poweroff_probe,
};
static int syscon_poweroff_driver_register(void)
{
rt_platform_driver_register(&syscon_poweroff_driver);
return 0;
}
INIT_SUBSYS_EXPORT(syscon_poweroff_driver_register);
@@ -0,0 +1,115 @@
/*
* Copyright (c) 2006-2023, RT-Thread Development Team
*
* SPDX-License-Identifier: Apache-2.0
*
* Change Logs:
* Date Author Notes
* 2023-02-25 GuEe-GUI the first version
*/
#include <rtthread.h>
#include <rtdevice.h>
#define DBG_TAG "reset.syscon.reboot-mode"
#define DBG_LVL DBG_INFO
#include <rtdbg.h>
#include "reboot-mode.h"
struct syscon_reboot_mode
{
struct rt_syscon *map;
struct reboot_mode reboot;
rt_uint32_t offset;
rt_uint32_t mask;
};
static rt_err_t syscon_reboot_mode_write(struct reboot_mode *reboot,
rt_uint32_t magic)
{
rt_err_t err;
struct syscon_reboot_mode *srbm;
srbm = rt_container_of(reboot, struct syscon_reboot_mode, reboot);
err = rt_syscon_update_bits(srbm->map, srbm->offset, srbm->mask, magic);
if (err)
{
LOG_E("Update reboot mode bits failed");
}
return err;
}
static rt_err_t syscon_reboot_mode_probe(struct rt_platform_device *pdev)
{
rt_err_t err;
struct rt_ofw_node *np;
struct rt_device *dev = &pdev->parent;
struct syscon_reboot_mode *srbm = rt_calloc(1, sizeof(*srbm));
if (!srbm)
{
return -RT_ENOMEM;
}
np = rt_ofw_get_parent(dev->ofw_node);
srbm->map = rt_syscon_find_by_ofw_node(np);
rt_ofw_node_put(np);
if (!srbm->map)
{
err = -RT_EIO;
goto _fail;
}
srbm->reboot.dev = dev;
srbm->reboot.write = syscon_reboot_mode_write;
srbm->mask = 0xffffffff;
if (rt_dm_dev_prop_read_u32(dev, "offset", &srbm->offset))
{
err = -RT_EINVAL;
goto _fail;
}
rt_dm_dev_prop_read_u32(dev, "mask", &srbm->mask);
if ((err = reboot_mode_register(&srbm->reboot)))
{
goto _fail;
}
return RT_EOK;
_fail:
rt_free(srbm);
return err;
}
static const struct rt_ofw_node_id syscon_reboot_mode_ofw_ids[] =
{
{ .compatible = "syscon-reboot-mode" },
{ /* sentinel */ }
};
static struct rt_platform_driver syscon_reboot_mode_driver =
{
.name = "reset-syscon-reboot-mode",
.ids = syscon_reboot_mode_ofw_ids,
.probe = syscon_reboot_mode_probe,
};
static int syscon_reboot_mode_driver_register(void)
{
rt_platform_driver_register(&syscon_reboot_mode_driver);
return 0;
}
INIT_SUBSYS_EXPORT(syscon_reboot_mode_driver_register);
@@ -0,0 +1,104 @@
/*
* Copyright (c) 2006-2023, RT-Thread Development Team
*
* SPDX-License-Identifier: Apache-2.0
*
* Change Logs:
* Date Author Notes
* 2023-02-25 GuEe-GUI the first version
*/
#include <rtthread.h>
#include <rtdevice.h>
#define DBG_TAG "reset.syscon.reboot"
#define DBG_LVL DBG_INFO
#include <rtdbg.h>
static struct rt_syscon *syscon;
static rt_uint32_t offset, value, mask;
static void syscon_reboot(void)
{
/* Issue the reboot */
rt_syscon_update_bits(syscon, offset, mask, value);
rt_thread_mdelay(1000);
LOG_E("Unable to restart system");
}
static rt_err_t syscon_reboot_probe(struct rt_platform_device *pdev)
{
rt_err_t mask_err, value_err;
struct rt_ofw_node *np = pdev->parent.ofw_node;
syscon = rt_syscon_find_by_ofw_phandle(np, "regmap");
if (!syscon)
{
return -RT_ERROR;
}
if (rt_ofw_prop_read_u32(np, "offset", &offset))
{
LOG_E("read '%s' fail", "offset");
return -RT_EINVAL;
}
value_err = rt_ofw_prop_read_u32(np, "value", &value);
mask_err = rt_ofw_prop_read_u32(np, "mask", &mask);
if (value_err && mask_err)
{
LOG_E("read '%s' and '%s' fail", "value", "mask");
return -RT_EINVAL;
}
if (value_err)
{
/* support old binding */
value = mask;
mask = 0xffffffff;
}
else if (mask_err)
{
/* support value without mask */
mask = 0xffffffff;
}
if (rt_dm_machine_reset)
{
LOG_E("rt_dm_machine_reset have hook %p", rt_dm_machine_reset);
return -RT_EBUSY;
}
rt_dm_machine_reset = syscon_reboot;
return RT_EOK;
}
static const struct rt_ofw_node_id syscon_reboot_ofw_ids[] =
{
{ .compatible = "syscon-reboot" },
{ /* sentinel */ }
};
static struct rt_platform_driver syscon_reboot_driver =
{
.name = "reset-syscon-reboot",
.ids = syscon_reboot_ofw_ids,
.probe = syscon_reboot_probe,
};
static int syscon_reboot_driver_register(void)
{
rt_platform_driver_register(&syscon_reboot_driver);
return 0;
}
INIT_SUBSYS_EXPORT(syscon_reboot_driver_register);
+15
View File
@@ -15,6 +15,21 @@ if RT_USING_POWER_SUPPLY
comment "Power Supply Device Drivers"
endif
config RT_POWER_SUPPLY_EMU
bool "Emulator battery(thermal)/charger"
depends on RT_USING_POWER_SUPPLY
depends on RT_USING_PM
depends on RT_USING_CONSOLE
depends on RT_USING_MSH
depends on RT_USING_CPU_USAGE_TRACER
default n
config RT_POWER_SUPPLY_CHARGER_GPIO
bool "GPIO charger"
depends on RT_USING_POWER_SUPPLY
depends on RT_USING_PIN
default y
if RT_USING_POWER_SUPPLY
osource "$(SOC_DM_POWER_SUPPLY_DIR)/Kconfig"
endif
@@ -13,6 +13,12 @@ src = ['supply.c']
if GetDepend(['RT_POWER_SUPPLY_DAEMON']):
src += ['supply-daemon.c']
if GetDepend(['RT_POWER_SUPPLY_EMU']):
src += ['emu-power.c']
if GetDepend(['RT_POWER_SUPPLY_CHARGER_GPIO']):
src += ['gpio-charger.c']
group = DefineGroup('DeviceDrivers', src, depend = [''], CPPPATH = CPPPATH)
Return('group')
File diff suppressed because it is too large. Load diff
File diff suppressed because it is too large. Load diff