nathan/CoolPi-Armbian-Rockchip-RK3588-Upstream-Linux-6.1-LTS-Kernel
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
CoolPi-Armbian-Rockchip-RK3.../drivers/soc/rockchip/rockchip_pm_config.c

758 lines
19 KiB
C
Raw Blame History

/*
* Rockchip Generic power configuration support.
*
* Copyright (c) 2017 Rockchip Electronics Co., Ltd.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*/
#include <linux/arm-smccc.h>
#include <linux/bitops.h>
#include <linux/cpu.h>
#include <linux/module.h>
#include <linux/of_gpio.h>
#include <linux/platform_device.h>
#include <linux/pm.h>
#include <linux/pm_domain.h>
#include <linux/pm_runtime.h>
#include <linux/reboot.h>
#include <linux/regulator/driver.h>
#include <linux/regulator/machine.h>
#include <linux/rockchip/rockchip_pm_config.h>
#include <linux/rockchip/rockchip_sip.h>
#include <linux/suspend.h>
#include <dt-bindings/input/input.h>
#include <../drivers/regulator/internal.h>
#define PM_INVALID_GPIO 0xffff
#define MAX_ON_OFF_REG_NUM 30
#define MAX_ON_OFF_REG_PROP_NAME_LEN 60
#define MAX_CONFIG_PROP_NAME_LEN 60
#define RK_ATAG_MCU_SLP_CORE 0x526b0001
#define RK_ATAG_MCU_SLP_MAX 0x526b00ff
#define RK_ATAG_NONE 0x00000000
enum rk_pm_state {
RK_PM_MEM = 0,
RK_PM_MEM_LITE,
RK_PM_MEM_ULTRA,
RK_PM_STATE_MAX
};
static const char * const pm_state_str[RK_PM_STATE_MAX] = {
[RK_PM_MEM] = "mem",
[RK_PM_MEM_LITE] = "mem-lite",
[RK_PM_MEM_ULTRA] = "mem-ultra",
};
static struct rk_on_off_regulator_dev_list {
struct regulator_dev *on_reg_list[MAX_ON_OFF_REG_NUM];
struct regulator_dev *off_reg_list[MAX_ON_OFF_REG_NUM];
} on_off_regs_dev_list[RK_PM_STATE_MAX];
static struct rk_regulator {
const char *name;
struct regulator *reg;
} on_reg_list_before_mem[MAX_ON_OFF_REG_NUM];
/* rk_tag related defines */
#define sleep_tag_next(t) \
((struct rk_sleep_tag *)((__u32 *)(t) + (t)->hdr.size))
struct rk_tag_header {
u32 size;
u32 tag;
};
struct rk_sleep_tag {
struct rk_tag_header hdr;
u32 params[];
};
struct rk_mcu_sleep_core_tag {
struct rk_tag_header hdr;
u32 total_size;
u32 reserve[13];
};
struct rk_mcu_sleep_tags {
struct rk_mcu_sleep_core_tag core;
struct rk_sleep_tag slp_tags;
};
struct rk_sleep_config *sleep_config;
static const struct of_device_id pm_match_table[] = {
{ .compatible = "rockchip,pm-config",},
{ .compatible = "rockchip,pm-px30",},
{ .compatible = "rockchip,pm-rk1808",},
{ .compatible = "rockchip,pm-rk322x",},
{ .compatible = "rockchip,pm-rk3288",},
{ .compatible = "rockchip,pm-rk3308",},
{ .compatible = "rockchip,pm-rk3328",},
{ .compatible = "rockchip,pm-rk3368",},
{ .compatible = "rockchip,pm-rk3399",},
{ .compatible = "rockchip,pm-rk3528",},
{ .compatible = "rockchip,pm-rk3562",},
{ .compatible = "rockchip,pm-rk3568",},
{ .compatible = "rockchip,pm-rk3588",},
{ .compatible = "rockchip,pm-rv1126",},
{ },
};
enum {
RK_PM_VIRT_PWROFF_EN = 0,
RK_PM_VIRT_PWROFF_IRQ_CFG = 1,
RK_PM_VIRT_PWROFF_MAX,
};
static u32 *virtual_pwroff_irqs;
static inline suspend_state_t get_mem_sleep_current(void)
{
return __is_defined(MODULE) ? PM_SUSPEND_MEM : mem_sleep_current;
}
static int rockchip_pm_virt_pwroff_prepare(struct sys_off_data *data)
{
int error, i;
pm_wakeup_clear(0);
regulator_suspend_prepare(PM_SUSPEND_MEM);
error = suspend_disable_secondary_cpus();
if (error) {
pr_err("Disable nonboot cpus failed!\n");
return NOTIFY_DONE;
}
sip_smc_set_suspend_mode(VIRTUAL_POWEROFF, RK_PM_VIRT_PWROFF_EN, 1);
if (virtual_pwroff_irqs) {
for (i = 0; virtual_pwroff_irqs[i]; i++) {
error = sip_smc_set_suspend_mode(VIRTUAL_POWEROFF,
RK_PM_VIRT_PWROFF_IRQ_CFG,
virtual_pwroff_irqs[i]);
if (error) {
pr_err("%s: config virtual_pwroff_irqs[%d] error, overflow or update trust!\n",
__func__, i);
break;
}
}
}
sip_smc_virtual_poweroff();
return NOTIFY_DONE;
}
static int parse_virtual_pwroff_config(struct platform_device *pdev, struct device_node *node)
{
int ret = 0, cnt;
u32 virtual_poweroff_en = 0;
if (!of_property_read_u32_array(node,
"rockchip,virtual-poweroff",
&virtual_poweroff_en, 1) &&
virtual_poweroff_en) {
ret = devm_register_sys_off_handler(&pdev->dev,
SYS_OFF_MODE_POWER_OFF_PREPARE,
SYS_OFF_PRIO_DEFAULT,
rockchip_pm_virt_pwroff_prepare,
NULL);
if (ret)
dev_err(&pdev->dev, "failed to register sys-off handler: %d\n", ret);
}
if (!virtual_poweroff_en)
return 0;
cnt = of_property_count_u32_elems(node, "rockchip,virtual-poweroff-irqs");
if (cnt > 0) {
/* 0 as the last element of virtual_pwroff_irqs */
virtual_pwroff_irqs = kzalloc((cnt + 1) * sizeof(u32), GFP_KERNEL);
if (!virtual_pwroff_irqs) {
ret = -ENOMEM;
goto out;
}
ret = of_property_read_u32_array(node, "rockchip,virtual-poweroff-irqs",
virtual_pwroff_irqs, cnt);
if (ret) {
pr_err("%s: get rockchip,virtual-poweroff-irqs error\n",
__func__);
goto out;
}
}
out:
return ret;
}
static int parse_sleep_config(struct device_node *node, enum rk_pm_state state)
{
char mode_prop_name[MAX_CONFIG_PROP_NAME_LEN];
char wkup_prop_name[MAX_CONFIG_PROP_NAME_LEN];
struct rk_sleep_config *config;
if (state == RK_PM_MEM || state >= RK_PM_STATE_MAX)
return -EINVAL;
snprintf(mode_prop_name, sizeof(mode_prop_name),
"sleep-mode-config-%s", pm_state_str[state]);
snprintf(wkup_prop_name, sizeof(wkup_prop_name),
"wakeup-config-%s", pm_state_str[state]);
config = &sleep_config[state];
if (of_property_read_u32_array(node,
mode_prop_name,
&config->mode_config, 1))
pr_info("%s not set sleep-mode-config for %s\n",
node->name, pm_state_str[state]);
if (of_property_read_u32_array(node,
wkup_prop_name,
&config->wakeup_config, 1))
pr_info("%s not set wakeup-config for %s\n",
node->name, pm_state_str[state]);
return 0;
}
static int parse_regulator_dev_list(struct device_node *node,
char *prop_name,
struct regulator_dev **out_list)
{
struct device_node *dn;
struct regulator_dev *reg;
int i, j;
if (of_find_property(node, prop_name, NULL)) {
for (i = 0, j = 0;
(dn = of_parse_phandle(node, prop_name, i)) && j < MAX_ON_OFF_REG_NUM;
i++) {
reg = of_find_regulator_by_node(dn);
if (reg == NULL) {
pr_warn("failed to find regulator %s for %s\n",
dn->name, prop_name);
} else {
pr_debug("%s %s regulator=%s\n", __func__,
prop_name,
reg->desc->name);
out_list[j++] = reg;
}
of_node_put(dn);
}
}
return 0;
}
static int parse_on_off_regulator_dev(struct device_node *node, enum rk_pm_state state)
{
char on_prop_name[MAX_ON_OFF_REG_PROP_NAME_LEN];
char off_prop_name[MAX_ON_OFF_REG_PROP_NAME_LEN];
if (state >= RK_PM_STATE_MAX)
return -EINVAL;
snprintf(on_prop_name, sizeof(on_prop_name),
"rockchip,regulator-on-in-%s", pm_state_str[state]);
snprintf(off_prop_name, sizeof(off_prop_name),
"rockchip,regulator-off-in-%s", pm_state_str[state]);
parse_regulator_dev_list(node, on_prop_name, on_off_regs_dev_list[state].on_reg_list);
parse_regulator_dev_list(node, off_prop_name, on_off_regs_dev_list[state].off_reg_list);
return 0;
}
const struct rk_sleep_config *rockchip_get_cur_sleep_config(void)
{
suspend_state_t suspend_state = get_mem_sleep_current();
enum rk_pm_state state = suspend_state - PM_SUSPEND_MEM;
if (state >= RK_PM_STATE_MAX)
return NULL;
return &sleep_config[state];
}
EXPORT_SYMBOL_GPL(rockchip_get_cur_sleep_config);
static int parse_regulator_list(struct platform_device *pdev,
struct device_node *node,
char *prop_name,
struct rk_regulator *reg_list)
{
struct device_node *dn;
struct regulator *reg;
const char *reg_name;
int i, j;
if (of_find_property(node, prop_name, NULL)) {
for (i = 0, j = 0;
(dn = of_parse_phandle(node, prop_name, i)) && j < MAX_ON_OFF_REG_NUM;
i++) {
if (of_property_read_string(dn, "regulator-name", &reg_name) == 0) {
reg = devm_regulator_get(&pdev->dev, reg_name);
if (IS_ERR(reg)) {
dev_err(&pdev->dev, "failed to get regulator %s for %s\n",
reg_name, prop_name);
} else {
reg_list[j].name = reg_name;
reg_list[j].reg = reg;
j++;
}
} else {
dev_err(&pdev->dev, "failed to get regulator-name property in %s\n",
dn->name);
}
of_node_put(dn);
}
}
return 0;
}
static int parse_mcu_sleep_config(struct device_node *node)
{
int ret, cnt;
struct arm_smccc_res res;
struct device_node *mcu_sleep_node;
struct device_node *child;
struct rk_mcu_sleep_tags *config;
struct rk_sleep_tag *slp_tag;
char *end;
mcu_sleep_node = of_find_node_by_name(node, "rockchip-mcu-sleep-cfg");
if (IS_ERR_OR_NULL(mcu_sleep_node)) {
ret = -ENODEV;
goto out;
}
cnt = of_get_child_count(mcu_sleep_node);
if (!cnt) {
ret = -EINVAL;
goto free_mcu_mode;
}
/*
* 4kb for sleep parameters
*/
res = sip_smc_request_share_mem(1, SHARE_PAGE_TYPE_SLEEP);
if (res.a0 != 0) {
pr_err("%s: no trust memory for mcu_sleep\n", __func__);
ret = -ENOMEM;
goto free_mcu_mode;
}
/* Initialize core tag.
* Compiler may optimize the following code into: "str xzr, ..." or "stp xzr, xzr, ..."
* if using memset, that can't guarantee the target address to be 8-byte alignment.
* So we use memset_io instead.
*/
memset_io((void *)res.a1, 0, sizeof(struct rk_mcu_sleep_tags));
config = (struct rk_mcu_sleep_tags *)res.a1;
config->core.hdr.tag = RK_ATAG_MCU_SLP_CORE;
config->core.hdr.size = sizeof(struct rk_mcu_sleep_core_tag) / sizeof(u32);
config->core.total_size = sizeof(struct rk_mcu_sleep_tags) -
sizeof(struct rk_sleep_tag);
slp_tag = &config->slp_tags;
/* End point of sleep data */
end = (char *)config + PAGE_SIZE - sizeof(struct rk_sleep_tag);
for_each_available_child_of_node(mcu_sleep_node, child) {
/* Is overflow? */
if ((char *)slp_tag->params >= end)
break;
ret = of_property_read_u32_array(child, "rockchip,tag",
&slp_tag->hdr.tag, 1);
if (ret ||
slp_tag->hdr.tag <= RK_ATAG_MCU_SLP_CORE ||
slp_tag->hdr.tag >= RK_ATAG_MCU_SLP_MAX) {
pr_info("%s: no or invalid rockchip,tag in %s\n",
__func__, child->name);
continue;
}
cnt = of_property_count_u32_elems(child, "rockchip,params");
if (cnt > 0) {
/* Is overflow? */
if ((char *)(slp_tag->params + cnt) >= end) {
pr_warn("%s: no more space for rockchip,tag in %s\n",
__func__, child->name);
break;
}
ret = of_property_read_u32_array(child, "rockchip,params",
slp_tag->params, cnt);
if (ret) {
pr_err("%s: rockchip,params error in %s\n",
__func__, child->name);
break;
}
slp_tag->hdr.size =
cnt + sizeof(struct rk_tag_header) / sizeof(u32);
} else if (cnt == 0) {
slp_tag->hdr.size = 0;
} else {
continue;
}
config->core.total_size += slp_tag->hdr.size * sizeof(u32);
slp_tag = sleep_tag_next(slp_tag);
}
/* Add none tag.
* Compiler will combine the follow code as "str xzr, [x28]", but
* "slp->hdr" may not be 8-byte alignment. So we use memset_io instead:
* slp_tag->hdr.size = 0;
* slp_tag->hdr.tag = RK_ATAG_NONE;
*/
memset_io(&slp_tag->hdr, 0, sizeof(slp_tag->hdr));
config->core.total_size += sizeof(struct rk_sleep_tag);
ret = 0;
free_mcu_mode:
of_node_put(mcu_sleep_node);
out:
return ret;
}
static int parse_io_config(struct device *dev)
{
int ret = 0, cnt, i;
struct device_node *node = dev->of_node;
struct rk_sleep_config *config = &sleep_config[RK_PM_MEM];
cnt = of_property_count_u32_elems(node, "rockchip,sleep-io-config");
if (cnt > 0) {
/* 0 as the last element of virtual_pwroff_irqs */
config->sleep_io_config =
devm_kmalloc_array(dev, cnt, sizeof(u32), GFP_KERNEL);
if (!config->sleep_io_config) {
ret = -ENOMEM;
goto out;
}
ret = of_property_read_u32_array(node, "rockchip,sleep-io-config",
config->sleep_io_config, cnt);
if (ret) {
dev_err(dev, "get rockchip,sleep-io-config error\n");
goto out;
}
config->sleep_io_config_cnt = cnt;
sip_smc_set_suspend_mode(SLEEP_IO_CONFIG, RK_PM_SLEEP_IO_CFG_CNT, cnt);
for (i = 0; i < cnt; i++)
sip_smc_set_suspend_mode(SLEEP_IO_CONFIG,
RK_PM_SLEEP_IO_CFG_VAL,
config->sleep_io_config[i]);
} else {
dev_dbg(dev, "not set sleep-pin-config\n");
}
out:
return ret;
}
static int parse_pm_domains(struct device *dev)
{
struct device **pd_dev;
struct device_link **pd_link;
int num_pds, i, ret;
num_pds = of_count_phandle_with_args(dev->of_node, "power-domains",
"#power-domain-cells");
if (num_pds <= 1)
return 0;
pd_dev = devm_kcalloc(dev, num_pds, sizeof(*pd_dev), GFP_KERNEL);
if (!pd_dev)
return -ENOMEM;
pd_link = devm_kcalloc(dev, num_pds, sizeof(*pd_link), GFP_KERNEL);
if (!pd_link)
return -ENOMEM;
for (i = 0; i < num_pds; i++) {
pd_dev[i] = dev_pm_domain_attach_by_id(dev, i);
if (IS_ERR(pd_dev[i])) {
ret = PTR_ERR(pd_dev[i]);
goto detach;
}
pd_link[i] = device_link_add(dev, pd_dev[i], DL_FLAG_STATELESS |
DL_FLAG_PM_RUNTIME);
if (!pd_link[i]) {
ret = -EINVAL;
goto detach;
}
}
devm_kfree(dev, pd_link);
return 0;
detach:
for (i = num_pds - 1; i >= 0; i--) {
if (pd_link[i])
device_link_del(pd_link[i]);
if (!IS_ERR_OR_NULL(pd_dev[i]))
dev_pm_domain_detach(pd_dev[i], true);
}
return ret;
}
static int pm_config_probe(struct platform_device *pdev)
{
const struct of_device_id *match_id;
struct device_node *node;
struct rk_sleep_config *config;
enum of_gpio_flags flags;
int i = 0;
int length;
int ret;
match_id = of_match_node(pm_match_table, pdev->dev.of_node);
if (!match_id)
return -ENODEV;
node = of_find_node_by_name(NULL, "rockchip-suspend");
if (IS_ERR_OR_NULL(node)) {
dev_err(&pdev->dev, "%s dev node err\n", __func__);
return -ENODEV;
}
sleep_config =
devm_kmalloc_array(&pdev->dev, RK_PM_STATE_MAX,
sizeof(*sleep_config),
GFP_KERNEL | __GFP_ZERO);
if (!sleep_config)
return -ENOMEM;
config = &sleep_config[RK_PM_MEM];
if (of_property_read_u32_array(node,
"rockchip,sleep-mode-config",
&config->mode_config, 1))
dev_warn(&pdev->dev, "not set sleep mode config\n");
else
sip_smc_set_suspend_mode(SUSPEND_MODE_CONFIG, config->mode_config, 0);
if (of_property_read_u32_array(node,
"rockchip,wakeup-config",
&config->wakeup_config, 1))
dev_warn(&pdev->dev, "not set wakeup-config\n");
else
sip_smc_set_suspend_mode(WKUP_SOURCE_CONFIG, config->wakeup_config, 0);
if (of_property_read_u32_array(node,
"rockchip,pwm-regulator-config",
&config->pwm_regulator_config, 1))
dev_warn(&pdev->dev, "not set pwm-regulator-config\n");
else
sip_smc_set_suspend_mode(PWM_REGULATOR_CONFIG,
config->pwm_regulator_config,
0);
length = of_gpio_named_count(node, "rockchip,power-ctrl");
if (length > 0 && length < 10) {
config->power_ctrl_config_cnt = length;
config->power_ctrl_config =
devm_kmalloc_array(&pdev->dev, length,
sizeof(u32), GFP_KERNEL);
if (!config->power_ctrl_config)
return -ENOMEM;
for (i = 0; i < length; i++) {
config->power_ctrl_config[i] =
of_get_named_gpio_flags(node,
"rockchip,power-ctrl",
i,
&flags);
if (!gpio_is_valid(config->power_ctrl_config[i]))
break;
sip_smc_set_suspend_mode(GPIO_POWER_CONFIG,
i,
config->power_ctrl_config[i]);
}
}
sip_smc_set_suspend_mode(GPIO_POWER_CONFIG, i, PM_INVALID_GPIO);
if (!of_property_read_u32_array(node,
"rockchip,sleep-debug-en",
&config->sleep_debug_en, 1))
sip_smc_set_suspend_mode(SUSPEND_DEBUG_ENABLE,
config->sleep_debug_en,
0);
if (!of_property_read_u32_array(node,
"rockchip,apios-suspend",
&config->apios_suspend, 1))
sip_smc_set_suspend_mode(APIOS_SUSPEND_CONFIG,
config->apios_suspend,
0);
if (!of_property_read_u32_array(node,
"rockchip,sleep-io-ret-config",
&config->io_ret_config, 1)) {
ret = sip_smc_set_suspend_mode(SUSPEND_IO_RET_CONFIG, config->io_ret_config, 0);
if (ret)
dev_warn(&pdev->dev,
"sleep-io-ret-config failed (%d), check parameters or update trust\n",
ret);
}
if (!of_property_read_u32_array(node,
"rockchip,sleep-pin-config",
config->sleep_pin_config, 2)) {
ret = sip_smc_set_suspend_mode(SLEEP_PIN_CONFIG,
config->sleep_pin_config[0],
config->sleep_pin_config[1]);
if (ret)
dev_warn(&pdev->dev,
"sleep-pin-config failed (%d), check parameters or update trust\n",
ret);
}
parse_io_config(&pdev->dev);
parse_mcu_sleep_config(node);
parse_regulator_list(pdev, node,
"rockchip,regulator-on-before-mem",
on_reg_list_before_mem);
ret = parse_pm_domains(&pdev->dev);
if (ret) {
dev_err(&pdev->dev, "failed to parse pm domains, ret=%d\n", ret);
return ret;
}
pm_runtime_enable(&pdev->dev);
if (__is_defined(MODULE))
return 0;
parse_virtual_pwroff_config(pdev, node);
for (i = RK_PM_MEM; i < RK_PM_STATE_MAX; i++) {
parse_sleep_config(node, i);
parse_on_off_regulator_dev(node, i);
}
return 0;
}
static int pm_config_prepare(struct device *dev)
{
int i;
suspend_state_t suspend_state = get_mem_sleep_current();
enum rk_pm_state state = suspend_state - PM_SUSPEND_MEM;
struct regulator_dev **on_list;
struct regulator_dev **off_list;
struct rk_sleep_config *config, *def_config = &sleep_config[RK_PM_MEM];
sip_smc_set_suspend_mode(LINUX_PM_STATE,
suspend_state,
0);
if (state >= RK_PM_STATE_MAX)
return 0;
config = &sleep_config[state];
if (config->mode_config)
sip_smc_set_suspend_mode(SUSPEND_MODE_CONFIG,
config->mode_config, 0);
else if (def_config->mode_config)
sip_smc_set_suspend_mode(SUSPEND_MODE_CONFIG,
def_config->mode_config, 0);
if (config->wakeup_config)
sip_smc_set_suspend_mode(WKUP_SOURCE_CONFIG,
config->wakeup_config, 0);
else if (def_config->wakeup_config)
sip_smc_set_suspend_mode(WKUP_SOURCE_CONFIG,
def_config->wakeup_config, 0);
on_list = on_off_regs_dev_list[state].on_reg_list;
off_list = on_off_regs_dev_list[state].off_reg_list;
for (i = 0; i < MAX_ON_OFF_REG_NUM && on_list[i]; i++)
regulator_suspend_enable(on_list[i], PM_SUSPEND_MEM);
for (i = 0; i < MAX_ON_OFF_REG_NUM && off_list[i]; i++)
regulator_suspend_disable(off_list[i], PM_SUSPEND_MEM);
return pm_runtime_resume_and_get(dev);
}
static void pm_config_complete(struct device *dev)
{
pm_runtime_put_sync(dev);
}
static int pm_config_suspend_late(struct device *dev)
{
int i;
for (i = 0; i < MAX_ON_OFF_REG_NUM && on_reg_list_before_mem[i].reg; i++)
if (regulator_enable(on_reg_list_before_mem[i].reg))
dev_err(dev, "fail to enable regulator:%s\n",
on_reg_list_before_mem[i].name);
return 0;
}
static int pm_config_resume_early(struct device *dev)
{
int i;
for (i = 0; i < MAX_ON_OFF_REG_NUM && on_reg_list_before_mem[i].reg; i++)
if (regulator_disable(on_reg_list_before_mem[i].reg))
dev_err(dev, "fail to disable regulator:%s\n",
on_reg_list_before_mem[i].name);
return 0;
}
static const struct dev_pm_ops rockchip_pm_ops = {
.prepare = pm_config_prepare,
.complete = pm_config_complete,
.suspend_late = pm_config_suspend_late,
.resume_early = pm_config_resume_early,
};
static struct platform_driver pm_driver = {
.probe = pm_config_probe,
.driver = {
.name = "rockchip-pm",
.of_match_table = pm_match_table,
.pm = &rockchip_pm_ops,
},
};
static int __init rockchip_pm_drv_register(void)
{
return platform_driver_register(&pm_driver);
}
late_initcall_sync(rockchip_pm_drv_register);
MODULE_DESCRIPTION("Rockchip suspend mode config");
MODULE_LICENSE("GPL");
Reference in New Issue View Git Blame Copy Permalink