#include <linux/bitfield.h>
#include <linux/mailbox/riscv-rpmi-message.h>
#include <linux/mutex.h>
#include <linux/platform_device.h>
#include <linux/pm_domain.h>
#define RPMI_PM_DOMAIN_NAME_LEN 16
#define RPMI_POWER_STATE_CONTEXT_MASK GENMASK(16, 16)
#define RPMI_POWER_STATE_CONTEXT_PRESERVED 0
#define RPMI_POWER_STATE_CONTEXT_LOST 1
#define RPMI_POWER_STATE_VALUE_MASK GENMASK(15, 0)
#define RPMI_POWER_STATE_VALUE_ON 0
#define RPMI_POWER_STATE_VALUE_OFF 3
#define RPMI_POWER_STATE_PARAM(context_type, state_value) \
((FIELD_PREP(RPMI_POWER_STATE_CONTEXT_MASK, context_type)) | \
(FIELD_PREP(RPMI_POWER_STATE_VALUE_MASK, state_value)))
#define RPMI_POWER_STATE_GENERIC_ON \
RPMI_POWER_STATE_PARAM(RPMI_POWER_STATE_CONTEXT_PRESERVED, \
RPMI_POWER_STATE_VALUE_ON)
#define RPMI_POWER_STATE_GENERIC_OFF \
RPMI_POWER_STATE_PARAM(RPMI_POWER_STATE_CONTEXT_PRESERVED, \
RPMI_POWER_STATE_VALUE_OFF)
struct rpmi_ctx {
struct mbox_chan *chan;
struct mbox_client client;
struct mutex lock;
};
struct rpmi_device_power_domain {
u32 id;
u32 transition_latency;
struct device *dev;
struct rpmi_ctx *mpxy_ctx;
struct generic_pm_domain genpd;
char name[RPMI_PM_DOMAIN_NAME_LEN];
};
#define to_rpmi_pd(gpd) container_of(gpd, struct rpmi_device_power_domain, genpd)
struct rpmi_pm_get_num_domain_rx {
__le32 status;
__le32 num_domains;
};
struct rpmi_pm_get_domain_attrs_tx {
__le32 domain_id;
};
struct rpmi_pm_get_domain_attrs_rx {
__le32 status;
__le32 flags;
__le32 transition_latency;
char name[RPMI_PM_DOMAIN_NAME_LEN];
};
struct rpmi_pm_set_power_state_tx {
__le32 domain_id;
__le32 power_state;
};
struct rpmi_pm_set_power_state_rx {
__le32 status;
};
struct rpmi_pm_get_power_state_tx {
__le32 domain_id;
};
struct rpmi_pm_get_power_state_rx {
__le32 status;
__le32 power_state;
};
static int rpmi_pm_send_message(struct rpmi_ctx *mpxy_ctx,
struct rpmi_mbox_message *msg)
{
guard(mutex)(&mpxy_ctx->lock);
return rpmi_mbox_send_message(mpxy_ctx->chan, msg);
}
static int rpmi_power_state_get(struct rpmi_device_power_domain *mpxy_pm_domain,
u32 domain_id, u32 *state)
{
struct rpmi_pm_get_power_state_rx rx = { };
struct rpmi_pm_get_power_state_tx tx;
struct rpmi_mbox_message msg;
int ret;
tx.domain_id = cpu_to_le32(domain_id);
rpmi_mbox_init_send_with_response(&msg, RPMI_DP_SRV_GET_STATE,
&tx, sizeof(tx), &rx, sizeof(rx));
ret = rpmi_pm_send_message(mpxy_pm_domain->mpxy_ctx, &msg);
if (ret)
return ret;
if (rx.status)
return rpmi_to_linux_error(le32_to_cpu(rx.status));
if (msg.data.out_response_len < sizeof(rx))
return -EPROTO;
*state = le32_to_cpu(rx.power_state);
return 0;
}
static int rpmi_power_state_set(struct rpmi_device_power_domain *mpxy_pm_domain,
u32 domain_id, u32 state)
{
struct rpmi_pm_set_power_state_rx rx = { };
struct rpmi_pm_set_power_state_tx tx;
struct rpmi_mbox_message msg;
int ret;
tx.domain_id = cpu_to_le32(domain_id);
tx.power_state = cpu_to_le32(state);
rpmi_mbox_init_send_with_response(&msg, RPMI_DP_SRV_SET_STATE,
&tx, sizeof(tx), &rx, sizeof(rx));
ret = rpmi_pm_send_message(mpxy_pm_domain->mpxy_ctx, &msg);
if (ret)
return ret;
if (rx.status)
return rpmi_to_linux_error(le32_to_cpu(rx.status));
if (msg.data.out_response_len < sizeof(rx))
return -EPROTO;
return 0;
}
static int rpmi_pd_power(struct generic_pm_domain *domain, bool power_on)
{
struct rpmi_device_power_domain *mpxy_pm_domain;
u32 state, ret_state, domain_id;
int ret;
if (power_on)
state = RPMI_POWER_STATE_GENERIC_ON;
else
state = RPMI_POWER_STATE_GENERIC_OFF;
mpxy_pm_domain = to_rpmi_pd(domain);
domain_id = mpxy_pm_domain->id;
ret = rpmi_power_state_set(mpxy_pm_domain, domain_id, state);
if (ret)
return ret;
ret = rpmi_power_state_get(mpxy_pm_domain, domain_id, &ret_state);
if (ret)
return ret;
if (FIELD_GET(RPMI_POWER_STATE_VALUE_MASK, ret_state) !=
FIELD_GET(RPMI_POWER_STATE_VALUE_MASK, state))
return -EIO;
return ret;
}
static int rpmi_pd_power_on(struct generic_pm_domain *domain)
{
return rpmi_pd_power(domain, true);
}
static int rpmi_pd_power_off(struct generic_pm_domain *domain)
{
return rpmi_pd_power(domain, false);
}
static int rpmi_pm_get_num_domains(struct rpmi_ctx *mpxy_ctx, u32 *domain)
{
struct rpmi_pm_get_num_domain_rx rx = { };
struct rpmi_mbox_message msg;
int ret;
rpmi_mbox_init_send_with_response(&msg, RPMI_DP_SRV_GET_NUM_DOMAINS,
NULL, 0, &rx, sizeof(rx));
ret = rpmi_pm_send_message(mpxy_ctx, &msg);
if (ret)
return ret;
if (rx.status)
return rpmi_to_linux_error(le32_to_cpu(rx.status));
if (msg.data.out_response_len < sizeof(rx))
return -EPROTO;
*domain = le32_to_cpu(rx.num_domains);
return 0;
}
static int rpmi_device_power_get_attrs(u32 domain_id,
struct rpmi_device_power_domain *mpxy_pm_domain)
{
struct rpmi_pm_get_domain_attrs_rx rx = { };
struct rpmi_pm_get_domain_attrs_tx tx;
struct rpmi_mbox_message msg;
int ret;
tx.domain_id = cpu_to_le32(domain_id);
rpmi_mbox_init_send_with_response(&msg, RPMI_DP_SRV_GET_ATTRS,
&tx, sizeof(tx), &rx, sizeof(rx));
ret = rpmi_pm_send_message(mpxy_pm_domain->mpxy_ctx, &msg);
if (ret)
return ret;
if (rx.status)
return rpmi_to_linux_error(le32_to_cpu(rx.status));
if (msg.data.out_response_len < sizeof(rx))
return -EPROTO;
mpxy_pm_domain->transition_latency = le32_to_cpu(rx.transition_latency);
strscpy(mpxy_pm_domain->name, rx.name, sizeof(mpxy_pm_domain->name));
return 0;
}
static int rpmi_pm_attr_setup(struct device *dev, struct rpmi_ctx *mpxy_ctx)
{
struct rpmi_mbox_message msg;
int ret;
rpmi_mbox_init_get_attribute(&msg, RPMI_MBOX_ATTR_SPEC_VERSION);
ret = rpmi_pm_send_message(mpxy_ctx, &msg);
if (ret) {
dev_dbg(dev, "Failed to get spec version\n");
return ret;
}
if (msg.attr.value < RPMI_MKVER(1, 0)) {
dev_dbg(dev,
"msg protocol version mismatch, expected 0x%x, found 0x%x\n",
RPMI_MKVER(1, 0), msg.attr.value);
return -EINVAL;
}
rpmi_mbox_init_get_attribute(&msg, RPMI_MBOX_ATTR_SERVICEGROUP_ID);
ret = rpmi_pm_send_message(mpxy_ctx, &msg);
if (ret) {
dev_dbg(dev, "Failed to get service group ID\n");
return ret;
}
if (msg.attr.value != RPMI_SRVGRP_DEVICE_POWER) {
dev_dbg(dev,
"service group match failed, expected 0x%x, found 0x%x\n",
RPMI_SRVGRP_DEVICE_POWER, msg.attr.value);
return -EINVAL;
}
rpmi_mbox_init_get_attribute(&msg, RPMI_MBOX_ATTR_SERVICEGROUP_VERSION);
ret = rpmi_pm_send_message(mpxy_ctx, &msg);
if (ret) {
dev_dbg(dev, "Failed to get service group version\n");
return ret;
}
if (msg.attr.value < RPMI_MKVER(1, 0)) {
dev_dbg(dev,
"service group version failed, expected 0x%x, found 0x%x\n",
RPMI_MKVER(1, 0), msg.attr.value);
return -EINVAL;
}
return 0;
}
static void rpmi_pm_domain_mbox_chan_release(void *data)
{
mbox_free_channel((struct mbox_chan *)data);
}
static int rpmi_pm_domain_probe(struct platform_device *pdev)
{
struct device_node *np = pdev->dev.of_node;
struct rpmi_device_power_domain *mpxy_pd;
struct genpd_onecell_data *mpxy_pd_data;
struct generic_pm_domain **domains;
struct device *dev = &pdev->dev;
struct rpmi_ctx *mpxy_ctx;
u32 num_domains = 0;
int ret;
u32 i;
mpxy_ctx = devm_kzalloc_obj(&pdev->dev, *mpxy_ctx);
if (!mpxy_ctx)
return -ENOMEM;
ret = devm_mutex_init(dev, &mpxy_ctx->lock);
if (ret)
return ret;
mpxy_ctx->client.dev = dev;
mpxy_ctx->client.rx_callback = NULL;
mpxy_ctx->client.tx_block = false;
mpxy_ctx->client.knows_txdone = true;
mpxy_ctx->client.tx_tout = 0;
mpxy_ctx->chan = mbox_request_channel(&mpxy_ctx->client, 0);
if (IS_ERR(mpxy_ctx->chan))
return PTR_ERR(mpxy_ctx->chan);
ret = devm_add_action_or_reset(dev, rpmi_pm_domain_mbox_chan_release,
mpxy_ctx->chan);
if (ret)
return dev_err_probe(dev, ret,
"failed to add rpmi mbox channel cleanup\n");
ret = rpmi_pm_attr_setup(dev, mpxy_ctx);
if (ret)
return dev_err_probe(dev, ret,
"failed to verify RPMI attribute\n");
ret = rpmi_pm_get_num_domains(mpxy_ctx, &num_domains);
if (ret)
return dev_err_probe(dev, ret,
"failed to get number of pm domains\n");
if (!num_domains)
return dev_err_probe(dev, -EINVAL, "No PM domains found!\n");
dev_info(&pdev->dev, "%u MPXY PM domains are found\n", num_domains);
mpxy_pd = devm_kzalloc_objs(&pdev->dev, *mpxy_pd, num_domains);
if (!mpxy_pd)
return -ENOMEM;
domains = devm_kzalloc_objs(&pdev->dev, *domains, num_domains);
if (!domains)
return -ENOMEM;
mpxy_pd_data = devm_kzalloc_obj(&pdev->dev, *mpxy_pd_data);
if (!mpxy_pd_data)
return -ENOMEM;
for (i = 0; i < num_domains; i++, mpxy_pd++) {
u32 state;
mpxy_pd->dev = &pdev->dev;
mpxy_pd->mpxy_ctx = mpxy_ctx;
mpxy_pd->id = i;
ret = rpmi_device_power_get_attrs(i, mpxy_pd);
if (ret) {
dev_warn(mpxy_pd->dev,
"power domain %u initialization failed\n",
mpxy_pd->id);
domains[i] = NULL;
continue;
}
ret = rpmi_power_state_get(mpxy_pd, i, &state);
if (ret) {
dev_warn(mpxy_pd->dev,
"failed to get state for power domain %u\n",
mpxy_pd->id);
domains[i] = NULL;
continue;
}
state = FIELD_GET(RPMI_POWER_STATE_VALUE_MASK, state);
if (state != RPMI_POWER_STATE_VALUE_OFF &&
state != RPMI_POWER_STATE_VALUE_ON) {
dev_warn(mpxy_pd->dev,
"unsupported state 0x%x for power domain %u\n",
state, mpxy_pd->id);
domains[i] = NULL;
continue;
}
mpxy_pd->genpd.name = mpxy_pd->name;
mpxy_pd->genpd.power_off = rpmi_pd_power_off;
mpxy_pd->genpd.power_on = rpmi_pd_power_on;
mpxy_pd->genpd.flags = GENPD_FLAG_DEV_NAME_FW;
ret = pm_genpd_init(&mpxy_pd->genpd, NULL,
state == RPMI_POWER_STATE_VALUE_OFF);
if (ret) {
dev_warn(mpxy_pd->dev,
"failed to init power domain %u\n",
mpxy_pd->id);
domains[i] = NULL;
continue;
}
domains[i] = &mpxy_pd->genpd;
}
mpxy_pd_data->domains = domains;
mpxy_pd_data->num_domains = num_domains;
ret = of_genpd_add_provider_onecell(np, mpxy_pd_data);
if (ret) {
while (i--) {
if (domains[i])
pm_genpd_remove(domains[i]);
}
return dev_err_probe(dev, ret, "failed to add genpd provider\n");
}
return 0;
}
static const struct of_device_id rpmi_pm_domain_of_match[] = {
{ .compatible = "riscv,rpmi-device-power" },
{},
};
static struct platform_driver rpmi_pm_domain_platdrv = {
.driver = {
.name = "riscv-rpmi-device-power",
.of_match_table = rpmi_pm_domain_of_match,
.suppress_bind_attrs = true,
},
.probe = rpmi_pm_domain_probe,
};
builtin_platform_driver(rpmi_pm_domain_platdrv);
MODULE_AUTHOR("Joshua Yeong <joshua.yeong@starfivetech.com>");
MODULE_DESCRIPTION("Device Power Driver based on RPMI message protocol");
MODULE_LICENSE("GPL"