diff --git a/components/drivers/Kconfig b/components/drivers/Kconfig index 87e37864bd0..a2a6dc9ef63 100755 --- a/components/drivers/Kconfig +++ b/components/drivers/Kconfig @@ -34,6 +34,7 @@ rsource "hwcache/Kconfig" rsource "regulator/Kconfig" rsource "reset/Kconfig" rsource "pmdomain/Kconfig" +rsource "power/Kconfig" rsource "thermal/Kconfig" rsource "virtio/Kconfig" rsource "nvmem/Kconfig" diff --git a/components/drivers/include/drivers/power_supply.h b/components/drivers/include/drivers/power_supply.h new file mode 100644 index 00000000000..15ee64e90b1 --- /dev/null +++ b/components/drivers/include/drivers/power_supply.h @@ -0,0 +1,277 @@ +/* + * Copyright (c) 2006-2022, RT-Thread Development Team + * + * SPDX-License-Identifier: Apache-2.0 + * + * Change Logs: + * Date Author Notes + * 2022-11-21 GuEe-GUI first version + */ + +#ifndef __POWER_SUPPLY_H__ +#define __POWER_SUPPLY_H__ + +#include +#include +#include + +enum rt_power_supply_type +{ + RT_POWER_SUPPLY_TYPE_UNKNOWN = 0, + RT_POWER_SUPPLY_TYPE_BATTERY, + RT_POWER_SUPPLY_TYPE_UPS, + RT_POWER_SUPPLY_TYPE_MAINS, + RT_POWER_SUPPLY_TYPE_USB_SDP, /* Standard Downstream Port */ + RT_POWER_SUPPLY_TYPE_USB_DCP, /* Dedicated Charging Port */ + RT_POWER_SUPPLY_TYPE_USB_CDP, /* Charging Downstream Port */ + RT_POWER_SUPPLY_TYPE_USB_ACA, /* Accessory Charger Adapters */ + RT_POWER_SUPPLY_TYPE_USB_TYPE_C, /* Type C Port */ + RT_POWER_SUPPLY_TYPE_USB_PD, /* Power Delivery Port */ + RT_POWER_SUPPLY_TYPE_USB_PD_DRP, /* PD Dual Role Port */ + RT_POWER_SUPPLY_TYPE_USB_PD_PPS, /* PD Programmable Power Supply */ + RT_POWER_SUPPLY_TYPE_WIRELESS, /* Wireless */ +}; + +enum rt_power_supply_status +{ + RT_POWER_SUPPLY_STATUS_UNKNOWN = 0, + RT_POWER_SUPPLY_STATUS_CHARGING, + RT_POWER_SUPPLY_STATUS_DISCHARGING, + RT_POWER_SUPPLY_STATUS_NOT_CHARGING, + RT_POWER_SUPPLY_STATUS_FULL, +}; + +enum rt_power_supply_charge_type +{ + RT_POWER_SUPPLY_CHARGE_TYPE_UNKNOWN = 0, + RT_POWER_SUPPLY_CHARGE_TYPE_NONE, + RT_POWER_SUPPLY_CHARGE_TYPE_TRICKLE, /* Slow speed */ + RT_POWER_SUPPLY_CHARGE_TYPE_FAST, /* Fast speed */ + RT_POWER_SUPPLY_CHARGE_TYPE_STANDARD, /* Normal speed */ + RT_POWER_SUPPLY_CHARGE_TYPE_ADAPTIVE, /* Dynamically adjusted speed */ + RT_POWER_SUPPLY_CHARGE_TYPE_CUSTOM, /* Use CHARGE_CONTROL_* props */ + RT_POWER_SUPPLY_CHARGE_TYPE_LONGLIFE, /* Slow speed, longer life */ + RT_POWER_SUPPLY_CHARGE_TYPE_BYPASS, /* Bypassing the charger */ +}; + +enum rt_power_supply_health +{ + RT_POWER_SUPPLY_HEALTH_UNKNOWN = 0, + RT_POWER_SUPPLY_HEALTH_GOOD, + RT_POWER_SUPPLY_HEALTH_OVERHEAT, + RT_POWER_SUPPLY_HEALTH_DEAD, + RT_POWER_SUPPLY_HEALTH_OVERVOLTAGE, + RT_POWER_SUPPLY_HEALTH_UNSPEC_FAILURE, + RT_POWER_SUPPLY_HEALTH_COLD, + RT_POWER_SUPPLY_HEALTH_WATCHDOG_TIMER_EXPIRE, + RT_POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE, + RT_POWER_SUPPLY_HEALTH_OVERCURRENT, + RT_POWER_SUPPLY_HEALTH_CALIBRATION_REQUIRED, + RT_POWER_SUPPLY_HEALTH_WARM, + RT_POWER_SUPPLY_HEALTH_COOL, + RT_POWER_SUPPLY_HEALTH_HOT, + RT_POWER_SUPPLY_HEALTH_NO_BATTERY, +}; + +enum rt_power_supply_technology +{ + RT_POWER_SUPPLY_TECHNOLOGY_UNKNOWN = 0, + RT_POWER_SUPPLY_TECHNOLOGY_NiMH, + RT_POWER_SUPPLY_TECHNOLOGY_LION, + RT_POWER_SUPPLY_TECHNOLOGY_LIPO, + RT_POWER_SUPPLY_TECHNOLOGY_LiFe, + RT_POWER_SUPPLY_TECHNOLOGY_NiCd, + RT_POWER_SUPPLY_TECHNOLOGY_LiMn, +}; + +enum rt_power_supply_capacity_level +{ + RT_POWER_SUPPLY_CAPACITY_LEVEL_UNKNOWN = 0, + RT_POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL, + RT_POWER_SUPPLY_CAPACITY_LEVEL_LOW, + RT_POWER_SUPPLY_CAPACITY_LEVEL_NORMAL, + RT_POWER_SUPPLY_CAPACITY_LEVEL_HIGH, + RT_POWER_SUPPLY_CAPACITY_LEVEL_FULL, +}; + +enum rt_power_supply_scope +{ + RT_POWER_SUPPLY_SCOPE_UNKNOWN = 0, + RT_POWER_SUPPLY_SCOPE_SYSTEM, + RT_POWER_SUPPLY_SCOPE_DEVICE, +}; + +enum rt_power_supply_property +{ + /* Properties of type `int' */ + RT_POWER_SUPPLY_PROP_STATUS = 0, + RT_POWER_SUPPLY_PROP_CHARGE_TYPE, + RT_POWER_SUPPLY_PROP_HEALTH, + RT_POWER_SUPPLY_PROP_PRESENT, + RT_POWER_SUPPLY_PROP_ONLINE, + RT_POWER_SUPPLY_PROP_AUTHENTIC, + RT_POWER_SUPPLY_PROP_TECHNOLOGY, + RT_POWER_SUPPLY_PROP_CYCLE_COUNT, + RT_POWER_SUPPLY_PROP_VOLTAGE_MAX, + RT_POWER_SUPPLY_PROP_VOLTAGE_MIN, + RT_POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN, + RT_POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN, + RT_POWER_SUPPLY_PROP_VOLTAGE_NOW, + RT_POWER_SUPPLY_PROP_VOLTAGE_AVG, + RT_POWER_SUPPLY_PROP_VOLTAGE_OCV, + RT_POWER_SUPPLY_PROP_VOLTAGE_BOOT, + RT_POWER_SUPPLY_PROP_CURRENT_MAX, + RT_POWER_SUPPLY_PROP_CURRENT_NOW, + RT_POWER_SUPPLY_PROP_CURRENT_AVG, + RT_POWER_SUPPLY_PROP_CURRENT_BOOT, + RT_POWER_SUPPLY_PROP_POWER_NOW, + RT_POWER_SUPPLY_PROP_POWER_AVG, + RT_POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN, + RT_POWER_SUPPLY_PROP_CHARGE_EMPTY_DESIGN, + RT_POWER_SUPPLY_PROP_CHARGE_FULL, + RT_POWER_SUPPLY_PROP_CHARGE_EMPTY, + RT_POWER_SUPPLY_PROP_CHARGE_NOW, + RT_POWER_SUPPLY_PROP_CHARGE_AVG, + RT_POWER_SUPPLY_PROP_CHARGE_COUNTER, + RT_POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT, + RT_POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX, + RT_POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE, + RT_POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX, + RT_POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT, + RT_POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT_MAX, + RT_POWER_SUPPLY_PROP_CHARGE_CONTROL_START_THRESHOLD, + RT_POWER_SUPPLY_PROP_CHARGE_CONTROL_END_THRESHOLD, + RT_POWER_SUPPLY_PROP_CHARGE_BEHAVIOUR, + RT_POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT, + RT_POWER_SUPPLY_PROP_INPUT_VOLTAGE_LIMIT, + RT_POWER_SUPPLY_PROP_INPUT_POWER_LIMIT, + RT_POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN, + RT_POWER_SUPPLY_PROP_ENERGY_EMPTY_DESIGN, + RT_POWER_SUPPLY_PROP_ENERGY_FULL, + RT_POWER_SUPPLY_PROP_ENERGY_EMPTY, + RT_POWER_SUPPLY_PROP_ENERGY_NOW, + RT_POWER_SUPPLY_PROP_ENERGY_AVG, + RT_POWER_SUPPLY_PROP_CAPACITY, + RT_POWER_SUPPLY_PROP_CAPACITY_ALERT_MIN, + RT_POWER_SUPPLY_PROP_CAPACITY_ALERT_MAX, + RT_POWER_SUPPLY_PROP_CAPACITY_ERROR_MARGIN, + RT_POWER_SUPPLY_PROP_CAPACITY_LEVEL, + RT_POWER_SUPPLY_PROP_TEMP, + RT_POWER_SUPPLY_PROP_TEMP_MAX, + RT_POWER_SUPPLY_PROP_TEMP_MIN, + RT_POWER_SUPPLY_PROP_TEMP_ALERT_MIN, + RT_POWER_SUPPLY_PROP_TEMP_ALERT_MAX, + RT_POWER_SUPPLY_PROP_TEMP_AMBIENT, + RT_POWER_SUPPLY_PROP_TEMP_AMBIENT_ALERT_MIN, + RT_POWER_SUPPLY_PROP_TEMP_AMBIENT_ALERT_MAX, + RT_POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW, + RT_POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG, + RT_POWER_SUPPLY_PROP_TIME_TO_FULL_NOW, + RT_POWER_SUPPLY_PROP_TIME_TO_FULL_AVG, + RT_POWER_SUPPLY_PROP_SCOPE, + RT_POWER_SUPPLY_PROP_PRECHARGE_CURRENT, + RT_POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT, + RT_POWER_SUPPLY_PROP_CALIBRATE, + RT_POWER_SUPPLY_PROP_MANUFACTURE_YEAR, + RT_POWER_SUPPLY_PROP_MANUFACTURE_MONTH, + RT_POWER_SUPPLY_PROP_MANUFACTURE_DAY, + /* Properties of type `const char *' */ + RT_POWER_SUPPLY_PROP_MODEL_NAME, + RT_POWER_SUPPLY_PROP_MANUFACTURER, + RT_POWER_SUPPLY_PROP_SERIAL_NUMBER, +}; + +union rt_power_supply_property_val +{ + int intval; + const char *strval; +}; + +struct rt_power_supply_battery_info +{ + enum rt_power_supply_technology technology; + int energy_full_design_uwh; + int charge_full_design_uah; + int voltage_min_design_uv; + int voltage_max_design_uv; + int precharge_current_ua; + int charge_term_current_ua; + int charge_restart_voltage_uv; + int constant_charge_current_max_ua; + int constant_charge_voltage_max_uv; + int temp_ambient_alert_min; + int temp_ambient_alert_max; + int temp_alert_min; + int temp_alert_max; + int temp_min; + int temp_max; +}; + +struct rt_power_supply_ops; +struct rt_power_supply_notifier; + +struct rt_power_supply +{ + rt_list_t list; + + struct rt_device *dev; + + enum rt_power_supply_type type; + + rt_size_t properties_nr; + enum rt_power_supply_property *properties; + struct rt_power_supply_battery_info *battery_info; + + const struct rt_power_supply_ops *ops; + + struct rt_ref ref; + +#ifdef RT_USING_THERMAL + struct rt_thermal_zone_device *thermal_dev; +#endif + +#ifdef RT_USING_LED + struct rt_led_device *led_dev; +#endif + + struct rt_work changed_work; +}; + +struct rt_power_supply_ops +{ + rt_err_t (*get_property)(struct rt_power_supply *psy, + enum rt_power_supply_property prop, union rt_power_supply_property_val *val); + rt_err_t (*set_property)(struct rt_power_supply *psy, + enum rt_power_supply_property prop, const union rt_power_supply_property_val *val); +}; + +typedef rt_err_t (*rt_power_supply_notifier_callback)(struct rt_power_supply_notifier *notifier, + struct rt_power_supply *psy); + +struct rt_power_supply_notifier +{ + rt_list_t list; + + rt_power_supply_notifier_callback callback; + void *priv; +}; + +rt_err_t rt_power_supply_register(struct rt_power_supply *psy); +rt_err_t rt_power_supply_unregister(struct rt_power_supply *psy); + +rt_err_t rt_power_supply_notifier_register(struct rt_power_supply_notifier *notifier); +rt_err_t rt_power_supply_notifier_unregister(struct rt_power_supply_notifier *notifier); + +rt_err_t rt_power_supply_get_property(struct rt_power_supply *psy, + enum rt_power_supply_property prop, + union rt_power_supply_property_val *val); +rt_err_t rt_power_supply_set_property(struct rt_power_supply *psy, + enum rt_power_supply_property prop, + const union rt_power_supply_property_val *val); + +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); + +#endif /* __POWER_SUPPLY_H__ */ diff --git a/components/drivers/include/rtdevice.h b/components/drivers/include/rtdevice.h index 89af4b933c0..0f2a640794f 100644 --- a/components/drivers/include/rtdevice.h +++ b/components/drivers/include/rtdevice.h @@ -134,6 +134,10 @@ 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 */ diff --git a/components/drivers/power/Kconfig b/components/drivers/power/Kconfig new file mode 100644 index 00000000000..b832ac23502 --- /dev/null +++ b/components/drivers/power/Kconfig @@ -0,0 +1,2 @@ +rsource "reset/Kconfig" +rsource "supply/Kconfig" diff --git a/components/drivers/power/SConscript b/components/drivers/power/SConscript new file mode 100644 index 00000000000..0b84689e91c --- /dev/null +++ b/components/drivers/power/SConscript @@ -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') diff --git a/components/drivers/power/reset/Kconfig b/components/drivers/power/reset/Kconfig new file mode 100644 index 00000000000..376418398cd --- /dev/null +++ b/components/drivers/power/reset/Kconfig @@ -0,0 +1,39 @@ +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 diff --git a/components/drivers/power/reset/SConscript b/components/drivers/power/reset/SConscript new file mode 100644 index 00000000000..6174e407e15 --- /dev/null +++ b/components/drivers/power/reset/SConscript @@ -0,0 +1,33 @@ +from building import * + +group = [] + +if not GetDepend(['RT_USING_POWER_RESET']): + Return('group') + +cwd = GetCurrentDir() +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') diff --git a/components/drivers/power/reset/gpio-poweroff.c b/components/drivers/power/reset/gpio-poweroff.c new file mode 100644 index 00000000000..a54a1e7f682 --- /dev/null +++ b/components/drivers/power/reset/gpio-poweroff.c @@ -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 +#include + +#define DBG_TAG "reset.gpio.poweroff" +#define DBG_LVL DBG_INFO +#include + +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); diff --git a/components/drivers/power/reset/gpio-restart.c b/components/drivers/power/reset/gpio-restart.c new file mode 100644 index 00000000000..02eff0a7f42 --- /dev/null +++ b/components/drivers/power/reset/gpio-restart.c @@ -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 +#include + +#define DBG_TAG "reset.gpio.restart" +#define DBG_LVL DBG_INFO +#include + +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); diff --git a/components/drivers/power/reset/reboot-mode.c b/components/drivers/power/reset/reboot-mode.c new file mode 100644 index 00000000000..d2a65f53fbd --- /dev/null +++ b/components/drivers/power/reset/reboot-mode.c @@ -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; +} diff --git a/components/drivers/power/reset/reboot-mode.h b/components/drivers/power/reset/reboot-mode.h new file mode 100644 index 00000000000..30358820367 --- /dev/null +++ b/components/drivers/power/reset/reboot-mode.h @@ -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 +#include + +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__ */ diff --git a/components/drivers/power/reset/syscon-poweroff.c b/components/drivers/power/reset/syscon-poweroff.c new file mode 100644 index 00000000000..aaa8d25b6eb --- /dev/null +++ b/components/drivers/power/reset/syscon-poweroff.c @@ -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 +#include + +#define DBG_TAG "reset.syscon.poweroff" +#define DBG_LVL DBG_INFO +#include + +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); diff --git a/components/drivers/power/reset/syscon-reboot-mode.c b/components/drivers/power/reset/syscon-reboot-mode.c new file mode 100644 index 00000000000..da3afc7441b --- /dev/null +++ b/components/drivers/power/reset/syscon-reboot-mode.c @@ -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 +#include + +#define DBG_TAG "reset.syscon.reboot-mode" +#define DBG_LVL DBG_INFO +#include + +#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); diff --git a/components/drivers/power/reset/syscon-reboot.c b/components/drivers/power/reset/syscon-reboot.c new file mode 100644 index 00000000000..b4151b4d78d --- /dev/null +++ b/components/drivers/power/reset/syscon-reboot.c @@ -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 +#include + +#define DBG_TAG "reset.syscon.reboot" +#define DBG_LVL DBG_INFO +#include + +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); diff --git a/components/drivers/power/supply/Kconfig b/components/drivers/power/supply/Kconfig new file mode 100644 index 00000000000..b03ffa1e056 --- /dev/null +++ b/components/drivers/power/supply/Kconfig @@ -0,0 +1,35 @@ +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 + default n + +config RT_POWER_SUPPLY_DAEMON + bool "System supply daemon" + depends on RT_USING_POWER_SUPPLY + default y + +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 diff --git a/components/drivers/power/supply/SConscript b/components/drivers/power/supply/SConscript new file mode 100644 index 00000000000..5039b34f043 --- /dev/null +++ b/components/drivers/power/supply/SConscript @@ -0,0 +1,24 @@ +from building import * + +group = [] + +if not GetDepend(['RT_USING_POWER_SUPPLY']): + Return('group') + +cwd = GetCurrentDir() +CPPPATH = [cwd + '/../../include'] + +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') diff --git a/components/drivers/power/supply/emu-power.c b/components/drivers/power/supply/emu-power.c new file mode 100644 index 00000000000..f28438cd927 --- /dev/null +++ b/components/drivers/power/supply/emu-power.c @@ -0,0 +1,379 @@ +/* + * 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 +#include +#include + +#define POLL_INTERVAL_MS 3000 +#define CHARGE_STEP_FAST 4 +#define CHARGE_STEP_NORMAL 2 +#define CHARGE_STEP_TRICKLE 1 +#define DISCHARGE_BASE_RATE 1 +#define TEMP_SENSITIVITY 30 + +struct emu_power +{ + struct rt_device parent; + + struct rt_power_supply battery; + struct rt_power_supply charger; + + struct rt_timer poller; + + rt_uint32_t status; + rt_uint32_t health; + rt_uint32_t present; + rt_uint32_t capacity; + rt_uint32_t voltage; + rt_uint32_t temp; + rt_uint32_t charge_counter; + rt_uint32_t current_now; + rt_uint32_t current_avg; + rt_uint32_t charge_full_uah; + rt_uint32_t cycle_count; + rt_uint32_t ac_online; + rt_uint32_t voltage_max; + rt_uint32_t current_max; + + rt_tick_t last_poll_tick; + + rt_uint8_t load_index; + rt_ubase_t cpu_load; + rt_ubase_t load_history[5]; + rt_ubase_t last_idle; + rt_ubase_t last_total; +}; +static struct emu_power _emu_power; + +static enum rt_power_supply_property emu_battery_properties[] = +{ + RT_POWER_SUPPLY_PROP_STATUS, + RT_POWER_SUPPLY_PROP_HEALTH, + RT_POWER_SUPPLY_PROP_PRESENT, + RT_POWER_SUPPLY_PROP_TECHNOLOGY, + RT_POWER_SUPPLY_PROP_CAPACITY, + RT_POWER_SUPPLY_PROP_VOLTAGE_NOW, + RT_POWER_SUPPLY_PROP_TEMP, + RT_POWER_SUPPLY_PROP_CHARGE_COUNTER, + RT_POWER_SUPPLY_PROP_CURRENT_NOW, + RT_POWER_SUPPLY_PROP_CURRENT_AVG, + RT_POWER_SUPPLY_PROP_CHARGE_FULL, + RT_POWER_SUPPLY_PROP_CYCLE_COUNT, + RT_POWER_SUPPLY_PROP_SCOPE, +}; + +static struct rt_power_supply_battery_info emu_battery_info = +{ + .technology = RT_POWER_SUPPLY_TECHNOLOGY_LION, + .energy_full_design_uwh = 3000000000, /* 3000mWh */ + .charge_full_design_uah = 3000000, /* 3000mAh */ + .voltage_min_design_uv = 3000000, /* 3.0V */ + .voltage_max_design_uv = 4200000, /* 4.2V */ + .precharge_current_ua = 500000, /* 500mA */ + .charge_term_current_ua = 1000000, /* 1000mA */ + .charge_restart_voltage_uv = 3500000, /* 3.5V */ + .constant_charge_current_max_ua = 2000000, /* 2000mA */ + .constant_charge_voltage_max_uv = 4200000, /* 4.2V */ + .temp_ambient_alert_min = -10000, /* -10C */ + .temp_ambient_alert_max = 40000, /* 40C */ + .temp_alert_min = 20000, /* 20C */ + .temp_alert_max = 25000, /* 25C */ + .temp_min = 0, /* 0C */ + .temp_max = 35000, /* 35C */ +}; + +static rt_err_t emu_battery_get_property(struct rt_power_supply *psy, + enum rt_power_supply_property prop, union rt_power_supply_property_val *val) +{ + struct emu_power *ep = rt_container_of(psy, struct emu_power, battery); + + switch (prop) + { + case RT_POWER_SUPPLY_PROP_STATUS: + val->intval = ep->status; + break; + + case RT_POWER_SUPPLY_PROP_HEALTH: + val->intval = ep->health; + break; + + case RT_POWER_SUPPLY_PROP_PRESENT: + val->intval = ep->present; + break; + + case RT_POWER_SUPPLY_PROP_TECHNOLOGY: + val->intval = RT_POWER_SUPPLY_TECHNOLOGY_LION; + break; + + case RT_POWER_SUPPLY_PROP_CAPACITY: + val->intval = ep->capacity; + break; + + case RT_POWER_SUPPLY_PROP_VOLTAGE_NOW: + val->intval = ep->voltage; + break; + + case RT_POWER_SUPPLY_PROP_TEMP: + val->intval = ep->temp; + break; + + case RT_POWER_SUPPLY_PROP_CHARGE_COUNTER: + val->intval = ep->charge_counter; + break; + + case RT_POWER_SUPPLY_PROP_CURRENT_NOW: + val->intval = ep->current_now; + break; + + case RT_POWER_SUPPLY_PROP_CURRENT_AVG: + val->intval = ep->current_avg; + break; + + case RT_POWER_SUPPLY_PROP_CHARGE_FULL: + val->intval = ep->charge_full_uah; + break; + + case RT_POWER_SUPPLY_PROP_CYCLE_COUNT: + val->intval = ep->cycle_count; + break; + + case RT_POWER_SUPPLY_PROP_SCOPE: + val->intval = RT_POWER_SUPPLY_SCOPE_SYSTEM; + break; + + default: + return -RT_EINVAL; + } + + return RT_EOK; +} + +static const struct rt_power_supply_ops emu_battery_ops = +{ + .get_property = emu_battery_get_property, +}; + +static enum rt_power_supply_property emu_charger_properties[] = +{ + RT_POWER_SUPPLY_PROP_ONLINE, + RT_POWER_SUPPLY_PROP_VOLTAGE_MAX, + RT_POWER_SUPPLY_PROP_CURRENT_MAX, +}; + +static rt_err_t emu_charger_get_property(struct rt_power_supply *psy, + enum rt_power_supply_property prop, union rt_power_supply_property_val *val) +{ + struct emu_power *ep = rt_container_of(psy, struct emu_power, charger); + + switch (prop) + { + case RT_POWER_SUPPLY_PROP_ONLINE: + val->intval = ep->ac_online; + break; + + case RT_POWER_SUPPLY_PROP_VOLTAGE_MAX: + val->intval = ep->voltage_max; + break; + + case RT_POWER_SUPPLY_PROP_CURRENT_MAX: + val->intval = ep->current_max; + break; + + default: + return -RT_ENOSYS; + } + + return RT_EOK; +} + +static const struct rt_power_supply_ops emu_charger_ops = +{ + .get_property = emu_charger_get_property, +}; + +static void emu_power_poll(void *param) +{ + rt_tick_t current_tick; + rt_uint32_t elapsed_ms, avg_load = 0; + rt_ubase_t current_idle, current_total, idle_diff, total_diff; + struct rt_cpu_usage_stats *stats = &rt_cpu_self()->cpu_stat; + struct emu_power *ep = param; + + current_tick = rt_tick_get(); + elapsed_ms = (current_tick - ep->last_poll_tick) * (1000 / RT_TICK_PER_SECOND); + ep->last_poll_tick = current_tick; + + current_idle = stats->idle; + current_total = stats->user + stats->system + stats->irq + current_idle; + + idle_diff = current_idle - ep->last_idle; + total_diff = current_total - ep->last_total; + + ep->last_idle = current_idle; + ep->last_total = current_total; + + if (total_diff > 0) + { + ep->cpu_load = 100 - (idle_diff * 100) / total_diff; + } + else + { + ep->cpu_load = 0; + } + ep->cpu_load = rt_clamp((rt_ubase_t)ep->cpu_load, 0UL, 100UL); + + ep->load_history[ep->load_index++ % RT_ARRAY_SIZE(ep->load_history)] = ep->cpu_load; + + for (int i = 0; i < RT_ARRAY_SIZE(ep->load_history); i++) + { + avg_load += ep->load_history[i]; + } + avg_load /= RT_ARRAY_SIZE(ep->load_history); + + if (ep->ac_online) + { + int step; + + if (ep->capacity < 80) + { + step = CHARGE_STEP_FAST; + ep->current_now = 2000000; + } + else if (ep->capacity < 95) + { + step = CHARGE_STEP_NORMAL; + ep->current_now = 1000000; + } + else + { + step = CHARGE_STEP_TRICKLE; + ep->current_now = 500000; + } + + ep->capacity = rt_min_t(rt_uint32_t, + ep->capacity + (step * elapsed_ms) / POLL_INTERVAL_MS, 100); + + ep->voltage = emu_battery_info.voltage_max_design_uv - (100 - ep->capacity) * 30; + + if (ep->capacity >= 100) + { + ep->status = RT_POWER_SUPPLY_STATUS_FULL; + } + else + { + ep->status = RT_POWER_SUPPLY_STATUS_CHARGING; + } + } + else + { + int drain = (avg_load * DISCHARGE_BASE_RATE * elapsed_ms) / 1000; + + ep->capacity = rt_max_t(rt_uint32_t, ep->capacity - drain, 0); + ep->current_now = -(500000 + (avg_load * 5000)); + ep->voltage = emu_battery_info.voltage_min_design_uv + ep->capacity * 1200; + + ep->status = (ep->capacity > 0) ? + RT_POWER_SUPPLY_STATUS_DISCHARGING : RT_POWER_SUPPLY_STATUS_NOT_CHARGING; + } + + ep->temp = 25000 + (ep->current_now / 1000) * TEMP_SENSITIVITY; + ep->temp = rt_clamp((rt_uint32_t)ep->temp, + (rt_uint32_t)emu_battery_info.temp_min, (rt_uint32_t)emu_battery_info.temp_max); + + rt_power_supply_changed(&ep->charger); + rt_power_supply_changed(&ep->battery); +} + +static int emu_power_init(void) +{ + struct rt_cpu_usage_stats *stats = &rt_cpu_self()->cpu_stat; + struct emu_power *ep = &_emu_power; + + rt_memset(ep, 0, sizeof(*ep)); + + rt_dm_dev_set_name(&ep->parent, "emu-power"); + + ep->battery.dev = &ep->parent, + ep->battery.type = RT_POWER_SUPPLY_TYPE_BATTERY, + ep->battery.properties_nr = RT_ARRAY_SIZE(emu_battery_properties), + ep->battery.properties = emu_battery_properties, + ep->battery.battery_info = &emu_battery_info, + ep->battery.ops = &emu_battery_ops, + + ep->charger.dev = &ep->parent, + ep->charger.type = RT_POWER_SUPPLY_TYPE_USB_SDP, + ep->charger.properties_nr = RT_ARRAY_SIZE(emu_charger_properties), + ep->charger.properties = emu_charger_properties, + ep->charger.ops = &emu_charger_ops, + + ep->status = RT_POWER_SUPPLY_STATUS_DISCHARGING; + ep->health = RT_POWER_SUPPLY_HEALTH_GOOD; + ep->present = 1; + ep->capacity = 100; + ep->voltage = 3800000; + ep->voltage_max = emu_battery_info.voltage_max_design_uv; + ep->current_max = emu_battery_info.constant_charge_current_max_ua; + ep->temp = 25000; + ep->last_poll_tick = rt_tick_get(); + ep->last_idle = stats->idle; + ep->last_total = stats->user + stats->system + stats->irq + stats->idle; + + rt_power_supply_register(&ep->battery); + rt_power_supply_register(&ep->charger); + + rt_timer_init(&ep->poller, ep->parent.parent.name, &emu_power_poll, ep, + rt_tick_from_millisecond(POLL_INTERVAL_MS), RT_TIMER_FLAG_PERIODIC); + rt_timer_start(&ep->poller); + + return 0; +} +INIT_DEVICE_EXPORT(emu_power_init); + +static int emu_charger(int argc, char**argv) +{ + rt_base_t level; + struct emu_power *ep = &_emu_power; + + if (argc != 2) + { + goto _help; + } + + level = rt_hw_interrupt_disable(); + + if (!rt_strcmp(argv[1], "on")) + { + ep->status = RT_POWER_SUPPLY_STATUS_CHARGING; + ep->ac_online = 1; + ep->current_max = emu_battery_info.constant_charge_current_max_ua; + } + else if (!rt_strcmp(argv[1], "off")) + { + ep->status = RT_POWER_SUPPLY_STATUS_DISCHARGING; + ep->ac_online = 0; + ep->current_max = 0; + } + else + { + rt_hw_interrupt_enable(level); + goto _help; + } + + rt_hw_interrupt_enable(level); + + return 0; + +_help: + rt_kprintf("Usage: %s [on|off]\n", __func__); + + return -1; +} +MSH_CMD_EXPORT(emu_charger, emu charger switch); diff --git a/components/drivers/power/supply/gpio-charger.c b/components/drivers/power/supply/gpio-charger.c new file mode 100644 index 00000000000..1843a959a40 --- /dev/null +++ b/components/drivers/power/supply/gpio-charger.c @@ -0,0 +1,346 @@ +/* + * 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 +#include + +struct gpio_desc +{ + rt_base_t pin; + rt_uint8_t flags; +}; + +rt_packed(struct gpio_mapping +{ + rt_uint32_t limit_ua; + rt_uint32_t gpiodata; +}); + +struct gpio_charger +{ + struct rt_power_supply parent; + + struct gpio_desc gpiod; + struct gpio_desc charge_status; + + rt_ssize_t current_limit_gpios_nr; + struct gpio_desc *current_limit_gpios; + struct gpio_mapping *current_limit_map; + + rt_uint32_t current_limit_map_size; + rt_uint32_t charge_current_limit; + + /* To be fill */ + enum rt_power_supply_property gpio_charger_properties[3]; +}; + +static rt_err_t set_charge_current_limit(struct gpio_charger *gpioc, int val) +{ + int i; + struct gpio_mapping mapping; + struct gpio_desc *gpios = gpioc->current_limit_gpios; + + if (!gpioc->current_limit_map_size) + { + return -RT_EINVAL; + } + + for (i = 0; i < gpioc->current_limit_map_size; i++) + { + if (gpioc->current_limit_map[i].limit_ua <= val) + { + break; + } + } + mapping = gpioc->current_limit_map[i]; + + for (i = 0; i < gpioc->current_limit_gpios_nr; i++) + { + rt_bool_t val = (mapping.gpiodata >> i) & 1; + struct gpio_desc *gpio = &gpios[gpioc->current_limit_gpios_nr - i - 1]; + + rt_pin_mode(gpio->pin, PIN_MODE_OUTPUT); + rt_pin_write(gpio->pin, val ? gpio->flags : !gpio->flags); + } + + gpioc->charge_current_limit = mapping.limit_ua; + + return RT_EOK; +} + +static rt_err_t gpio_charger_get_property(struct rt_power_supply *psy, + enum rt_power_supply_property prop, union rt_power_supply_property_val *val) +{ + struct gpio_charger *gpioc = rt_container_of(psy, struct gpio_charger, parent); + + switch (prop) + { + case RT_POWER_SUPPLY_PROP_ONLINE: + rt_pin_mode(gpioc->gpiod.pin, PIN_MODE_INPUT); + val->intval = rt_pin_read(gpioc->gpiod.pin) == gpioc->gpiod.flags; + break; + + case RT_POWER_SUPPLY_PROP_STATUS: + rt_pin_mode(gpioc->charge_status.pin, PIN_MODE_INPUT); + if (rt_pin_read(gpioc->charge_status.pin) == gpioc->charge_status.flags) + { + val->intval = RT_POWER_SUPPLY_STATUS_CHARGING; + } + else + { + val->intval = RT_POWER_SUPPLY_STATUS_NOT_CHARGING; + } + break; + + case RT_POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX: + val->intval = gpioc->charge_current_limit; + break; + + default: + return -RT_ENOSYS; + } + + return RT_EOK; +} + +static rt_err_t gpio_charger_set_property(struct rt_power_supply *psy, + enum rt_power_supply_property prop, const union rt_power_supply_property_val *val) +{ + struct gpio_charger *gpioc = rt_container_of(psy, struct gpio_charger, parent); + + switch (prop) + { + case RT_POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX: + return set_charge_current_limit(gpioc, val->intval); + + default: + return -EINVAL; + } + + return RT_EOK; +} + +static const struct rt_power_supply_ops gpio_charger_ops = +{ + .get_property = gpio_charger_get_property, + .set_property = gpio_charger_set_property, +}; + +static void gpio_charger_isr(void *args) +{ + struct gpio_charger *gpioc = args; + + rt_power_supply_changed(&gpioc->parent); +} + +static rt_err_t init_charge_current_limit(struct rt_device *dev, + struct gpio_charger *gpioc) +{ + rt_ssize_t len; + rt_uint32_t cur_limit = RT_UINT32_MAX; + + gpioc->current_limit_gpios_nr = rt_pin_get_named_pin_count(dev, "charge-current-limit"); + if (gpioc->current_limit_gpios_nr <= 0) + { + return gpioc->current_limit_gpios_nr; + } + + gpioc->current_limit_gpios = rt_malloc(gpioc->current_limit_gpios_nr * + sizeof(*gpioc->current_limit_gpios)); + if (!gpioc->current_limit_gpios) + { + return RT_EOK; + } + + len = rt_dm_dev_prop_count_of_u32(dev, "charge-current-limit-mapping"); + if (len < 0) + { + return len; + } + + if (len == 0 || len % 2) + { + return -RT_EINVAL; + } + gpioc->current_limit_map_size = len / 2; + + gpioc->current_limit_map = rt_malloc(gpioc->current_limit_map_size * + sizeof(*gpioc->current_limit_map)); + if (!gpioc->current_limit_map) + { + return -RT_ENOMEM; + } + + len = rt_dm_dev_prop_read_u32_array_index(dev, "charge-current-limit-mapping", + 0, (int)len, (rt_uint32_t *)(void *)gpioc->current_limit_map); + if (len < 0) + { + return len; + } + + for (int i = 0; i < gpioc->current_limit_map_size; ++i) + { + if (gpioc->current_limit_map[i].limit_ua > cur_limit) + { + return -RT_EINVAL; + } + + cur_limit = gpioc->current_limit_map[i].limit_ua; + } + + /* Default to smallest current limitation for safety reasons */ + len = gpioc->current_limit_map_size - 1; + set_charge_current_limit(gpioc, gpioc->current_limit_map[len].limit_ua); + + return RT_EOK; +} + +static rt_err_t gpio_charger_probe(struct rt_platform_device *pdev) +{ + rt_err_t err; + int num_props = 0; + const char *chargetype; + struct gpio_charger *gpioc; + struct rt_device *dev = &pdev->parent; + + gpioc = rt_calloc(1, sizeof(*gpioc)); + + if (!gpioc) + { + return -RT_ENOMEM; + } + + gpioc->gpiod.pin = rt_pin_get_named_pin(dev, RT_NULL, 0, RT_NULL, &gpioc->gpiod.flags); + + if (gpioc->gpiod.pin < 0 && gpioc->gpiod.pin != -RT_EEMPTY) + { + err = -RT_EINVAL; + goto _fail; + } + + if (gpioc->gpiod.pin >= 0) + { + gpioc->gpio_charger_properties[num_props] = RT_POWER_SUPPLY_PROP_ONLINE; + ++num_props; + } + + gpioc->charge_status.pin = rt_pin_get_named_pin(dev, "charge-status", 0, + RT_NULL, &gpioc->charge_status.flags); + + if (gpioc->charge_status.pin < 0 && gpioc->charge_status.pin != -RT_EEMPTY) + { + err = -RT_EINVAL; + goto _fail; + } + + if (gpioc->charge_status.pin >= 0) + { + gpioc->gpio_charger_properties[num_props] = RT_POWER_SUPPLY_PROP_STATUS; + ++num_props; + } + + if ((err = init_charge_current_limit(dev, gpioc))) + { + goto _fail; + } + + if (gpioc->current_limit_map) + { + gpioc->gpio_charger_properties[num_props] = RT_POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX; + ++num_props; + } + + if (!rt_dm_dev_prop_read_string(dev, "charger-type", &chargetype)) + { + if (!rt_strcmp("unknown", chargetype)) + { + gpioc->parent.type = RT_POWER_SUPPLY_TYPE_UNKNOWN; + } + else if (!rt_strcmp("battery", chargetype)) + { + gpioc->parent.type = RT_POWER_SUPPLY_TYPE_BATTERY; + } + else if (!rt_strcmp("ups", chargetype)) + { + gpioc->parent.type = RT_POWER_SUPPLY_TYPE_UPS; + } + else if (!rt_strcmp("mains", chargetype)) + { + gpioc->parent.type = RT_POWER_SUPPLY_TYPE_MAINS; + } + else if (!rt_strcmp("usb-sdp", chargetype)) + { + gpioc->parent.type = RT_POWER_SUPPLY_TYPE_USB_SDP; + } + else if (!rt_strcmp("usb-dcp", chargetype)) + { + gpioc->parent.type = RT_POWER_SUPPLY_TYPE_USB_DCP; + } + else if (!rt_strcmp("usb-cdp", chargetype)) + { + gpioc->parent.type = RT_POWER_SUPPLY_TYPE_USB_CDP; + } + else if (!rt_strcmp("usb-aca", chargetype)) + { + gpioc->parent.type = RT_POWER_SUPPLY_TYPE_USB_ACA; + } + else + { + gpioc->parent.type = RT_POWER_SUPPLY_TYPE_UNKNOWN; + } + } + + gpioc->parent.dev = dev, + gpioc->parent.properties_nr = num_props, + gpioc->parent.properties = gpioc->gpio_charger_properties, + gpioc->parent.ops = &gpio_charger_ops; + + if ((err = rt_power_supply_register(&gpioc->parent))) + { + goto _fail; + } + + rt_pin_mode(gpioc->gpiod.pin, PIN_MODE_INPUT); + rt_pin_attach_irq(gpioc->gpiod.pin, PIN_IRQ_MODE_RISING, gpio_charger_isr, gpioc); + rt_pin_irq_enable(gpioc->gpiod.pin, RT_TRUE); + + rt_pin_mode(gpioc->charge_status.pin, PIN_MODE_INPUT); + rt_pin_attach_irq(gpioc->charge_status.pin, PIN_IRQ_MODE_RISING, gpio_charger_isr, gpioc); + rt_pin_irq_enable(gpioc->charge_status.pin, RT_TRUE); + + return RT_EOK; +_fail: + if (gpioc->current_limit_map) + { + rt_free(gpioc->current_limit_map); + } + if (gpioc->current_limit_gpios) + { + rt_free(gpioc->current_limit_gpios); + } + rt_free(gpioc); + + return err; +} + +static const struct rt_ofw_node_id gpio_charger_ofw_ids[] = +{ + { .compatible = "gpio-charger" }, + { /* sentinel */ } +}; + +static struct rt_platform_driver gpio_charger_driver = +{ + .name = "gpio-charger", + .ids = gpio_charger_ofw_ids, + + .probe = gpio_charger_probe, +}; +RT_PLATFORM_DRIVER_EXPORT(gpio_charger_driver); diff --git a/components/drivers/power/supply/supply-daemon.c b/components/drivers/power/supply/supply-daemon.c new file mode 100644 index 00000000000..8f0286e4965 --- /dev/null +++ b/components/drivers/power/supply/supply-daemon.c @@ -0,0 +1,179 @@ +/* + * 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 + +#define DBG_TAG "power_supply.daemon" +#define DBG_LVL DBG_INFO +#include + +#ifdef RT_USING_PM +static rt_bool_t low_power_mode = RT_FALSE; +static rt_uint8_t raw_pm_run_mode = PM_RUN_MODE_MAX; +static rt_uint8_t raw_pm_sleep_mode = PM_RUN_MODE_MAX; +static rt_uint8_t last_pm_sleep_mode; +#endif + +static rt_err_t daemon_power_supply_notify(struct rt_power_supply_notifier *notifier, + struct rt_power_supply *psy) +{ + union rt_power_supply_property_val propval; + rt_uint32_t voltage_now, voltage_min, voltage_max; + + if (!rt_power_supply_get_property(psy, RT_POWER_SUPPLY_PROP_CAPACITY, &propval)) + { + goto _capacity_check; + } + + if (rt_power_supply_get_property(psy, RT_POWER_SUPPLY_PROP_VOLTAGE_NOW, &propval)) + { + return -RT_ENOSYS; + } + voltage_now = propval.intval / 1000000; + + if (rt_power_supply_get_property(psy, RT_POWER_SUPPLY_PROP_VOLTAGE_MIN, &propval)) + { + return -RT_ENOSYS; + } + voltage_min = propval.intval / 1000000; + + if (rt_power_supply_get_property(psy, RT_POWER_SUPPLY_PROP_VOLTAGE_MAX, &propval)) + { + return -RT_ENOSYS; + } + voltage_max = propval.intval / 1000000; + + propval.intval = (voltage_now - voltage_min) * 100 / (voltage_max - voltage_min); + +_capacity_check: + if (propval.intval >= 80) + { + rt_bool_t full_power = propval.intval == 100; + + if (rt_power_supply_get_property(psy, RT_POWER_SUPPLY_PROP_STATUS, &propval)) + { + return -RT_ENOSYS; + } + + if (propval.intval == RT_POWER_SUPPLY_STATUS_CHARGING) + { + if (full_power) + { + LOG_I("%s: Power is full", rt_dm_dev_get_name(psy->dev)); + } + else + { + LOG_I("%s: Power is sufficient", rt_dm_dev_get_name(psy->dev)); + } + } + } + else if (propval.intval <= 20) + { + #ifdef RT_USING_PM + rt_uint8_t pm_sleep_mode; + struct rt_pm *pm = rt_pm_get_handle(); + + RT_ASSERT(pm != RT_NULL); + + low_power_mode = RT_TRUE; + + if (raw_pm_run_mode == PM_RUN_MODE_MAX) + { + raw_pm_run_mode = pm->run_mode; + } + if (raw_pm_sleep_mode == PM_SLEEP_MODE_MAX) + { + last_pm_sleep_mode = raw_pm_sleep_mode = pm->sleep_mode; + } + pm_sleep_mode = pm->sleep_mode; + #endif /* RT_USING_PM */ + + if (propval.intval <= 5) + { + do { + #ifdef RT_USING_PM + if (pm_sleep_mode != PM_SLEEP_MODE_SHUTDOWN && propval.intval > 1) + { + pm_sleep_mode = PM_SLEEP_MODE_SHUTDOWN; + break; + } + #endif + + 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)); + rt_hw_cpu_shutdown(); + } + } while (0); + + LOG_E("%s: Power is critical", rt_dm_dev_get_name(psy->dev)); + } + else if (propval.intval <= 10) + { + #ifdef RT_USING_PM + pm_sleep_mode = PM_SLEEP_MODE_STANDBY; + rt_pm_run_enter(PM_RUN_MODE_LOW_SPEED); + #endif + } + else if (propval.intval <= 15) + { + #ifdef RT_USING_PM + pm_sleep_mode = PM_SLEEP_MODE_DEEP; + rt_pm_run_enter(PM_RUN_MODE_MEDIUM_SPEED); + #endif + } + else if (propval.intval <= 20) + { + #ifdef RT_USING_PM + 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)); + } + + #ifdef RT_USING_PM + if (pm_sleep_mode != last_pm_sleep_mode) + { + rt_pm_release(last_pm_sleep_mode); + rt_pm_request(pm_sleep_mode); + + last_pm_sleep_mode = pm_sleep_mode; + } + #endif /* RT_USING_PM */ + } + else + { + #ifdef RT_USING_PM + if (low_power_mode) + { + rt_pm_release(last_pm_sleep_mode); + rt_pm_request(raw_pm_sleep_mode); + + rt_pm_run_enter(raw_pm_run_mode); + + low_power_mode = RT_FALSE; + } + #endif /* RT_USING_PM */ + } + + return RT_EOK; +} + +static int power_supply_daemon_init(void) +{ + static struct rt_power_supply_notifier daemon_notifier; + + daemon_notifier.callback = daemon_power_supply_notify; + rt_power_supply_notifier_register(&daemon_notifier); + + return 0; +} +INIT_ENV_EXPORT(power_supply_daemon_init); diff --git a/components/drivers/power/supply/supply.c b/components/drivers/power/supply/supply.c new file mode 100644 index 00000000000..bce91ad9975 --- /dev/null +++ b/components/drivers/power/supply/supply.c @@ -0,0 +1,694 @@ +/* + * 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 + +#define DBG_TAG "rtdm.power_supply" +#define DBG_LVL DBG_INFO +#include + +#ifndef INT_MAX +#define INT_MAX (RT_UINT32_MAX >> 1) +#endif + +#ifndef INT_MIN +#define INT_MIN (-INT_MAX - 1) +#endif + +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); + +static rt_bool_t power_supply_have_property(struct rt_power_supply *psy, + enum rt_power_supply_property prop); + +#ifdef RT_USING_THERMAL +static rt_err_t power_supply_thermal_zone_get_temp(struct rt_thermal_zone_device *zdev, + int *out_temp) +{ + rt_err_t err; + union rt_power_supply_property_val val; + struct rt_power_supply *psy = zdev->priv; + + if ((err = rt_power_supply_get_property(psy, RT_POWER_SUPPLY_PROP_TEMP, &val))) + { + return err; + } + + *out_temp = val.intval; + + return RT_EOK; +} + +const static struct rt_thermal_zone_ops power_supply_thermal_zone_ops = +{ + .get_temp = power_supply_thermal_zone_get_temp, +}; + +rt_err_t power_supply_thermal_register(struct rt_power_supply *psy) +{ + if (psy->thermal_dev) + { + return RT_EOK; + } + + if (power_supply_have_property(psy, RT_POWER_SUPPLY_PROP_TEMP)) + { + rt_err_t err; + + if (!(psy->thermal_dev = rt_calloc(1, sizeof(*psy->thermal_dev)))) + { + return -RT_ENOMEM; + } + + rt_dm_dev_set_name(&psy->thermal_dev->parent, rt_dm_dev_get_name(psy->dev)); + psy->thermal_dev->zone_id = 0; + psy->thermal_dev->ops = &power_supply_thermal_zone_ops; + psy->thermal_dev->parent.ofw_node = psy->dev->ofw_node; + psy->thermal_dev->priv = psy; + + if ((err = rt_thermal_zone_device_register(psy->thermal_dev))) + { + rt_free(psy->thermal_dev); + psy->thermal_dev = RT_NULL; + + return err; + } + } + + return RT_EOK; +} + +rt_err_t power_supply_thermal_unregister(struct rt_power_supply *psy) +{ + rt_err_t err = RT_EOK; + + if (psy->thermal_dev) + { + if (!(err = rt_thermal_zone_device_unregister(psy->thermal_dev))) + { + rt_free(psy->thermal_dev); + psy->thermal_dev = RT_NULL; + } + } + + return err; +} +#else +rt_err_t power_supply_thermal_register(struct rt_power_supply *psy) +{ + return RT_EOK; +} + +rt_err_t power_supply_thermal_unregister(struct rt_power_supply *psy) +{ + return RT_EOK; +} +#endif /* RT_USING_THERMAL */ + +#ifdef RT_USING_LED +static void power_supply_update_battery_led(struct rt_power_supply *psy) +{ + union rt_power_supply_property_val status; + + if (rt_power_supply_get_property(psy, RT_POWER_SUPPLY_PROP_STATUS, &status)) + { + return; + } + + switch (status.intval) + { + case RT_POWER_SUPPLY_STATUS_FULL: + rt_led_set_state(psy->led_dev, RT_LED_S_ON); + rt_led_set_brightness(psy->led_dev, 255); + break; + + case RT_POWER_SUPPLY_STATUS_CHARGING: + rt_led_set_state(psy->led_dev, RT_LED_S_ON); + rt_led_set_brightness(psy->led_dev, 255 >> 1); + break; + + default: + rt_led_set_state(psy->led_dev, RT_LED_S_OFF); + break; + } +} +static void power_supply_update_online_led(struct rt_power_supply *psy) +{ + union rt_power_supply_property_val online; + + if (rt_power_supply_get_property(psy, RT_POWER_SUPPLY_PROP_ONLINE, &online)) + { + return; + } + + if (online.intval) + { + rt_led_set_state(psy->led_dev, RT_LED_S_ON); + } + else + { + rt_led_set_state(psy->led_dev, RT_LED_S_OFF); + } +} + +static void power_supply_update_led(struct rt_power_supply *psy) +{ + if (!psy->led_dev) + { + return; + } + + if (psy->type == RT_POWER_SUPPLY_TYPE_BATTERY) + { + power_supply_update_battery_led(psy); + } + else + { + power_supply_update_online_led(psy); + } +} +#else +static void power_supply_update_led(struct rt_power_supply *psy) +{ +} +#endif /* RT_USING_LED */ + +static void power_supply_changed_work(struct rt_work *work, void *work_data) +{ + struct rt_power_supply *psy = work_data; + struct rt_power_supply_notifier *notifier, *next_notifier; + + power_supply_update_led(psy); + + rt_spin_lock(&nodes_lock); + + rt_list_for_each_entry_safe(notifier, next_notifier, &power_supply_notifier_nodes, list) + { + rt_spin_unlock(&nodes_lock); + + notifier->callback(notifier, psy); + + rt_spin_lock(&nodes_lock); + } + + rt_spin_unlock(&nodes_lock); +} + +rt_err_t rt_power_supply_register(struct rt_power_supply *psy) +{ + rt_err_t err; + + if (!psy || !psy->dev) + { + return -RT_EINVAL; + } + + if (!psy->battery_info && (!psy->properties_nr || !psy->properties || !psy->ops)) + { + return -RT_EINVAL; + } + + if ((err = power_supply_thermal_register(psy))) + { + return err; + } + + rt_ref_init(&psy->ref); + rt_list_init(&psy->list); + rt_work_init(&psy->changed_work, power_supply_changed_work, psy); + + rt_spin_lock(&nodes_lock); + rt_list_insert_before(&power_supply_nodes, &psy->list); + rt_spin_unlock(&nodes_lock); + + if (psy->dev->ofw_node) + { + rt_dm_dev_bind_fwdata(psy->dev, RT_NULL, psy); + } + + return RT_EOK; +} + +rt_err_t rt_power_supply_unregister(struct rt_power_supply *psy) +{ + rt_err_t err; + + if (!psy) + { + return -RT_EINVAL; + } + + rt_spin_lock(&nodes_lock); + + if (rt_ref_read(&psy->ref) > 1) + { + err = -RT_EBUSY; + goto _unlock; + } + + rt_list_remove(&psy->list); + + if (psy->dev->ofw_node) + { + rt_dm_dev_unbind_fwdata(psy->dev, RT_NULL); + } + +_unlock: + rt_spin_unlock(&nodes_lock); + + if (!err) + { + rt_work_cancel(&psy->changed_work); + + err = power_supply_thermal_unregister(psy); + } + + return err; +} + +rt_err_t rt_power_supply_notifier_register(struct rt_power_supply_notifier *notifier) +{ + if (!notifier || !notifier->callback) + { + return -RT_EINVAL; + } + + rt_list_init(¬ifier->list); + + rt_spin_lock(&nodes_lock); + rt_list_insert_before(&power_supply_notifier_nodes, ¬ifier->list); + rt_spin_unlock(&nodes_lock); + + return RT_EOK; +} + +rt_err_t rt_power_supply_notifier_unregister(struct rt_power_supply_notifier *notifier) +{ + if (!notifier) + { + return -RT_EINVAL; + } + + rt_spin_lock(&nodes_lock); + rt_list_remove(¬ifier->list); + rt_spin_unlock(&nodes_lock); + + return RT_EOK; +} + +static rt_bool_t power_supply_have_property(struct rt_power_supply *psy, + enum rt_power_supply_property prop) +{ + if (!psy->ops->get_property) + { + return RT_FALSE; + } + + for (int i = 0; i < psy->properties_nr; ++i) + { + if (psy->properties[i] == prop) + { + return RT_TRUE; + } + } + + return RT_FALSE; +} + +static rt_bool_t power_supply_battery_info_have_property( + struct rt_power_supply_battery_info *info, enum rt_power_supply_property prop) +{ + if (!info) + { + return RT_FALSE; + } + + switch (prop) + { + case RT_POWER_SUPPLY_PROP_TECHNOLOGY: + return info->technology != RT_POWER_SUPPLY_TECHNOLOGY_UNKNOWN; + + case RT_POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN: + return info->energy_full_design_uwh >= 0; + + case RT_POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN: + return info->charge_full_design_uah >= 0; + + case RT_POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN: + return info->voltage_min_design_uv >= 0; + + case RT_POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN: + return info->voltage_max_design_uv >= 0; + + case RT_POWER_SUPPLY_PROP_PRECHARGE_CURRENT: + return info->precharge_current_ua >= 0; + + case RT_POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT: + return info->charge_term_current_ua >= 0; + + case RT_POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX: + return info->constant_charge_current_max_ua >= 0; + + case RT_POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX: + return info->constant_charge_voltage_max_uv >= 0; + + case RT_POWER_SUPPLY_PROP_TEMP_AMBIENT_ALERT_MIN: + return info->temp_ambient_alert_min > INT_MIN; + + case RT_POWER_SUPPLY_PROP_TEMP_AMBIENT_ALERT_MAX: + return info->temp_ambient_alert_max < INT_MAX; + + case RT_POWER_SUPPLY_PROP_TEMP_ALERT_MIN: + return info->temp_alert_min > INT_MIN; + + case RT_POWER_SUPPLY_PROP_TEMP_ALERT_MAX: + return info->temp_alert_max < INT_MAX; + + case RT_POWER_SUPPLY_PROP_TEMP_MIN: + return info->temp_min > INT_MIN; + + case RT_POWER_SUPPLY_PROP_TEMP_MAX: + return info->temp_max < INT_MAX; + + default: + return RT_FALSE; + } +} + +static rt_err_t power_supply_battery_info_get_property( + struct rt_power_supply_battery_info *info, enum rt_power_supply_property prop, + union rt_power_supply_property_val *val) +{ + switch (prop) + { + case RT_POWER_SUPPLY_PROP_TECHNOLOGY: + val->intval = info->technology; + break; + + case RT_POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN: + val->intval = info->energy_full_design_uwh; + break; + + case RT_POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN: + val->intval = info->charge_full_design_uah; + break; + + case RT_POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN: + val->intval = info->voltage_min_design_uv; + break; + + case RT_POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN: + val->intval = info->voltage_max_design_uv; + break; + + case RT_POWER_SUPPLY_PROP_PRECHARGE_CURRENT: + val->intval = info->precharge_current_ua; + break; + + case RT_POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT: + val->intval = info->charge_term_current_ua; + break; + + case RT_POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX: + val->intval = info->constant_charge_current_max_ua; + break; + + case RT_POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX: + val->intval = info->constant_charge_voltage_max_uv; + break; + + case RT_POWER_SUPPLY_PROP_TEMP_AMBIENT_ALERT_MIN: + val->intval = info->temp_ambient_alert_min; + break; + + case RT_POWER_SUPPLY_PROP_TEMP_AMBIENT_ALERT_MAX: + val->intval = info->temp_ambient_alert_max; + break; + + case RT_POWER_SUPPLY_PROP_TEMP_ALERT_MIN: + val->intval = info->temp_alert_min; + break; + + case RT_POWER_SUPPLY_PROP_TEMP_ALERT_MAX: + val->intval = info->temp_alert_max; + break; + + case RT_POWER_SUPPLY_PROP_TEMP_MIN: + val->intval = info->temp_min; + break; + + case RT_POWER_SUPPLY_PROP_TEMP_MAX: + val->intval = info->temp_max; + break; + + default: + return -RT_EINVAL; + } + + return RT_EOK; +} + +rt_err_t rt_power_supply_get_property(struct rt_power_supply *psy, + enum rt_power_supply_property prop, + union rt_power_supply_property_val *val) +{ + if (!psy || !val) + { + return -RT_EINVAL; + } + + if (power_supply_have_property(psy, prop)) + { + return psy->ops->get_property(psy, prop, val); + } + else if (power_supply_battery_info_have_property(psy->battery_info, prop)) + { + return power_supply_battery_info_get_property(psy->battery_info, prop, val); + } + + return -RT_ENOSYS; +} + +rt_err_t rt_power_supply_set_property(struct rt_power_supply *psy, + enum rt_power_supply_property prop, + const union rt_power_supply_property_val *val) +{ + if (!psy || !val) + { + return -RT_EINVAL; + } + + if (!psy->ops->set_property) + { + return -RT_ENOSYS; + } + + return psy->ops->set_property(psy, prop, val); +} + +void rt_power_supply_changed(struct rt_power_supply *psy) +{ + RT_ASSERT(psy != RT_NULL); + + rt_work_submit(&psy->changed_work, 0); +} + +struct rt_power_supply *rt_power_supply_get(struct rt_device *dev, const char *id) +{ + struct rt_power_supply *psy = RT_NULL; + + if (!dev || !id) + { + return rt_err_ptr(-RT_EINVAL); + } + +#ifdef RT_USING_OFW + if (dev->ofw_node) + { + struct rt_ofw_node *psy_np = rt_ofw_parse_phandle(dev->ofw_node, id, 0); + + if (!psy_np) + { + return psy; + } + + psy = rt_ofw_data(psy_np); + } +#endif /* RT_USING_OFW */ + + if (!psy) + { + struct rt_power_supply *psy_target, *psy_next; + + rt_spin_lock(&nodes_lock); + + rt_list_for_each_entry_safe(psy_target, psy_next, &power_supply_nodes, list) + { + if (!rt_strcmp(psy_target->dev->parent.name, id)) + { + psy = psy_target; + break; + } + } + + rt_spin_unlock(&nodes_lock); + } + + return psy; +} + +static void power_supply_release(struct rt_ref *r) +{ + struct rt_power_supply *psy = rt_container_of(r, struct rt_power_supply, ref); + + rt_power_supply_unregister(psy); +} + +void rt_power_supply_put(struct rt_power_supply *psy) +{ + if (!psy) + { + return; + } + + 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[] = +{ + [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", +}; + +static int list_power_supply(int argc, char**argv) +{ + struct rt_power_supply *psy, *psy_next; + union rt_power_supply_property_val propval = {}; + + 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; + + 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; + + rt_power_supply_get_property(psy, RT_POWER_SUPPLY_PROP_HEALTH, &propval); + rt_kprintf("health: %s\n", health_str[propval.intval]), propval.intval = 0; + + 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_kputs("\n"); + + rt_spin_lock(&nodes_lock); + } + + rt_spin_unlock(&nodes_lock); + + return 0; +} +MSH_CMD_EXPORT(list_power_supply, dump all of power supply information); +#endif /* RT_USING_CONSOLE && RT_USING_MSH */