// SPDX-License-Identifier: GPL-2.0+
|
/*
|
* Copyright (C) 2023 Rockchip Electronics Co., Ltd
|
*/
|
|
#include <common.h>
|
#include <dm.h>
|
#include <misc.h>
|
#include <asm/io.h>
|
#include <linux/bitops.h>
|
#include <asm/arch/rockchip_smccc.h>
|
|
DECLARE_GLOBAL_DATA_PTR;
|
|
#define RK_ATAG_MCU_SLP_CORE 0x526b0001
|
#define RK_ATAG_MCU_SLP_MAX 0x526b00ff
|
#define RK_ATAG_NONE 0x00000000
|
|
/* 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;
|
};
|
|
static int rockchip_pm_config_ioctl(struct udevice *dev,
|
unsigned long request,
|
void *buf)
|
{
|
int ret = -EINVAL;
|
|
switch (request) {
|
case IOCTL_REQ_START:
|
break;
|
default:
|
printf("Unsupported ioctl: %ld\n", (ulong)request);
|
break;
|
}
|
|
return ret;
|
}
|
|
static const struct misc_ops rockchip_pm_config_ops = {
|
.ioctl = rockchip_pm_config_ioctl,
|
};
|
|
static int parse_mcu_sleep_config(ofnode node)
|
{
|
int ret, len;
|
ofnode mcu_sleep_node;
|
ofnode child;
|
struct arm_smccc_res res;
|
struct rk_mcu_sleep_tags *config;
|
struct rk_sleep_tag *slp_tag;
|
char *end;
|
|
mcu_sleep_node = ofnode_find_subnode(node, "rockchip-mcu-sleep-cfg");
|
if (ofnode_valid(mcu_sleep_node) == 0) {
|
ret = -ENODEV;
|
goto out;
|
}
|
|
child = ofnode_first_subnode(mcu_sleep_node);
|
if (ofnode_valid(child) == 0) {
|
pr_err("%s: no valid child node in rockchip-mcu-sleep-cfg\n",
|
__func__);
|
ret = -ENODEV;
|
goto out;
|
}
|
|
/*
|
* 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 out;
|
}
|
|
/* Initialize core tag */
|
memset((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);
|
|
ofnode_for_each_subnode(child, mcu_sleep_node) {
|
/* Is overflow? */
|
if ((char *)slp_tag->params >= end)
|
break;
|
|
ret = ofnode_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_err("%s: no or invalid rockchip,tag in %s\n",
|
__func__, ofnode_get_name(child));
|
|
continue;
|
}
|
|
len = ofnode_read_size(child, "rockchip,params");
|
if (len > 0) {
|
/* Is overflow? */
|
if ((char *)(slp_tag->params + len) >= end) {
|
pr_warn("%s: no more space for rockchip,tag in %s\n",
|
__func__, ofnode_get_name(child));
|
break;
|
}
|
|
ret = ofnode_read_u32_array(child, "rockchip,params",
|
slp_tag->params,
|
len / sizeof(u32));
|
if (ret) {
|
pr_err("%s: read rockchip,params error in %s\n",
|
__func__, ofnode_get_name(child));
|
break;
|
}
|
|
slp_tag->hdr.size =
|
(len + sizeof(struct rk_tag_header)) / sizeof(u32);
|
} else if (len == 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;
|
|
out:
|
return ret;
|
}
|
|
static int rockchip_pm_config_probe(struct udevice *dev)
|
{
|
parse_mcu_sleep_config(dev_ofnode(dev));
|
|
return 0;
|
}
|
|
static const struct udevice_id rockchip_pm_config_ids[] = {
|
{ .compatible = "rockchip,pm-rk3588" },
|
{}
|
};
|
|
U_BOOT_DRIVER(rockchip_pm_config) = {
|
.name = "rockchip_pm_config",
|
.id = UCLASS_MISC,
|
.of_match = rockchip_pm_config_ids,
|
.probe = rockchip_pm_config_probe,
|
.ops = &rockchip_pm_config_ops,
|
};
|
