Commit 279b7e8a authored by Rajendra Nayak's avatar Rajendra Nayak Committed by Andy Gross
Browse files

soc: qcom: rpmhpd: Add RPMh power domain driver 



The RPMh power domain driver aggregates the corner votes from various
consumers for the ARC resources and communicates it to RPMh.

With RPMh we use 2 different numbering space for corners, one used
by the clients to express their performance needs, and another used
to communicate to RPMh hardware.

The clients express their performance requirements using a sparse
numbering space which are mapped to meaningful levels like RET, SVS,
NOMINAL, TURBO etc which then get mapped to another number space
between 0 and 15 which is communicated to RPMh. The sparse number space,
also referred to as vlvl is mapped to the continuous number space of 0
to 15, also referred to as hlvl, using command DB.

Some power domain clients could request a performance state only while
the CPU is active, while some others could request for a certain
performance state all the time regardless of the state of the CPU.
We handle this by internally aggregating the votes from both type of
clients and then send the aggregated votes to RPMh.

There are also 3 different types of votes that are comunicated to RPMh
for every resource.
1. ACTIVE_ONLY:
	This specifies the requirement for the resource when the CPU is
 	active
2. SLEEP:
	This specifies the requirement for the resource when the CPU is
	going to sleep
3. WAKE_ONLY:
	This specifies the requirement for the resource when the CPU is
	coming out of sleep to active state

We add data for all power domains on sdm845 SoC as part of the patch.
The driver can be extended to support other SoCs which support RPMh

Reviewed-by: default avatarUlf Hansson <ulf.hansson@linaro.org>
Reviewed-by: default avatarStephen Boyd <swboyd@chromium.org>
Signed-off-by: default avatarRajendra Nayak <rnayak@codeaurora.org>
Signed-off-by: default avatarBjorn Andersson <bjorn.andersson@linaro.org>
Signed-off-by: default avatarAndy Gross <andy.gross@linaro.org>
parent 075d3db8

drivers/soc/qcom/Kconfig

+9 −0
Original line number Diff line number Diff line
@@ -98,6 +98,15 @@ config QCOM_RPMH 
	  of hardware components aggregate requests for these resources and

	  help apply the aggregated state on the resource.



config QCOM_RPMHPD

	bool "Qualcomm RPMh Power domain driver"

	depends on QCOM_RPMH && QCOM_COMMAND_DB

	help

	  QCOM RPMh Power domain driver to support power-domains with

	  performance states. The driver communicates a performance state

	  value to RPMh which then translates it into corresponding voltage

	  for the voltage rail.



config QCOM_RPMPD

	bool "Qualcomm RPM Power domain driver"

	depends on MFD_QCOM_RPM && QCOM_SMD_RPM

drivers/soc/qcom/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -21,4 +21,5 @@ obj-$(CONFIG_QCOM_WCNSS_CTRL) += wcnss_ctrl.o 
obj-$(CONFIG_QCOM_APR) += apr.o

obj-$(CONFIG_QCOM_LLCC) += llcc-slice.o

obj-$(CONFIG_QCOM_SDM845_LLCC) += llcc-sdm845.o

obj-$(CONFIG_QCOM_RPMHPD) += rpmhpd.o

obj-$(CONFIG_QCOM_RPMPD) += rpmpd.o

drivers/soc/qcom/rpmhpd.c

0 → 100644
+395 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0

/* Copyright (c) 2018, The Linux Foundation. All rights reserved.*/



#include <linux/err.h>

#include <linux/init.h>

#include <linux/kernel.h>

#include <linux/mutex.h>

#include <linux/pm_domain.h>

#include <linux/slab.h>

#include <linux/of.h>

#include <linux/of_device.h>

#include <linux/platform_device.h>

#include <linux/pm_opp.h>

#include <soc/qcom/cmd-db.h>

#include <soc/qcom/rpmh.h>

#include <dt-bindings/power/qcom-rpmpd.h>



#define domain_to_rpmhpd(domain) container_of(domain, struct rpmhpd, pd)



#define RPMH_ARC_MAX_LEVELS	16



/**

 * struct rpmhpd - top level RPMh power domain resource data structure

 * @dev:		rpmh power domain controller device

 * @pd:			generic_pm_domain corrresponding to the power domain

 * @peer:		A peer power domain in case Active only Voting is

 *			supported

 * @active_only:	True if it represents an Active only peer

 * @level:		An array of level (vlvl) to corner (hlvl) mappings

 *			derived from cmd-db

 * @level_count:	Number of levels supported by the power domain. max

 *			being 16 (0 - 15)

 * @enabled:		true if the power domain is enabled

 * @res_name:		Resource name used for cmd-db lookup

 * @addr:		Resource address as looped up using resource name from

 *			cmd-db

 */

struct rpmhpd {

	struct device	*dev;

	struct generic_pm_domain pd;

	struct generic_pm_domain *parent;

	struct rpmhpd	*peer;

	const bool	active_only;

	unsigned int	corner;

	unsigned int	active_corner;

	u32		level[RPMH_ARC_MAX_LEVELS];

	size_t		level_count;

	bool		enabled;

	const char	*res_name;

	u32		addr;

};



struct rpmhpd_desc {

	struct rpmhpd **rpmhpds;

	size_t num_pds;

};



static DEFINE_MUTEX(rpmhpd_lock);



/* SDM845 RPMH powerdomains */



static struct rpmhpd sdm845_ebi = {

	.pd = { .name = "ebi", },

	.res_name = "ebi.lvl",

};



static struct rpmhpd sdm845_lmx = {

	.pd = { .name = "lmx", },

	.res_name = "lmx.lvl",

};



static struct rpmhpd sdm845_lcx = {

	.pd = { .name = "lcx", },

	.res_name = "lcx.lvl",

};



static struct rpmhpd sdm845_gfx = {

	.pd = { .name = "gfx", },

	.res_name = "gfx.lvl",

};



static struct rpmhpd sdm845_mss = {

	.pd = { .name = "mss", },

	.res_name = "mss.lvl",

};



static struct rpmhpd sdm845_mx_ao;

static struct rpmhpd sdm845_mx = {

	.pd = { .name = "mx", },

	.peer = &sdm845_mx_ao,

	.res_name = "mx.lvl",

};



static struct rpmhpd sdm845_mx_ao = {

	.pd = { .name = "mx_ao", },

	.peer = &sdm845_mx,

	.res_name = "mx.lvl",

};



static struct rpmhpd sdm845_cx_ao;

static struct rpmhpd sdm845_cx = {

	.pd = { .name = "cx", },

	.peer = &sdm845_cx_ao,

	.res_name = "cx.lvl",

};



static struct rpmhpd sdm845_cx_ao = {

	.pd = { .name = "cx_ao", },

	.peer = &sdm845_cx,

	.res_name = "cx.lvl",

};



static struct rpmhpd *sdm845_rpmhpds[] = {

	[SDM845_EBI] = &sdm845_ebi,

	[SDM845_MX] = &sdm845_mx,

	[SDM845_MX_AO] = &sdm845_mx_ao,

	[SDM845_CX] = &sdm845_cx,

	[SDM845_CX_AO] = &sdm845_cx_ao,

	[SDM845_LMX] = &sdm845_lmx,

	[SDM845_LCX] = &sdm845_lcx,

	[SDM845_GFX] = &sdm845_gfx,

	[SDM845_MSS] = &sdm845_mss,

};



static const struct rpmhpd_desc sdm845_desc = {

	.rpmhpds = sdm845_rpmhpds,

	.num_pds = ARRAY_SIZE(sdm845_rpmhpds),

};



static const struct of_device_id rpmhpd_match_table[] = {

	{ .compatible = "qcom,sdm845-rpmhpd", .data = &sdm845_desc },

	{ }

};



static int rpmhpd_send_corner(struct rpmhpd *pd, int state,

			      unsigned int corner, bool sync)

{

	struct tcs_cmd cmd = {

		.addr = pd->addr,

		.data = corner,

	};



	/*

	 * Wait for an ack only when we are increasing the

	 * perf state of the power domain

	 */

	if (sync)

		return rpmh_write(pd->dev, state, &cmd, 1);

	else

		return rpmh_write_async(pd->dev, state, &cmd, 1);

}



static void to_active_sleep(struct rpmhpd *pd, unsigned int corner,

			    unsigned int *active, unsigned int *sleep)

{

	*active = corner;



	if (pd->active_only)

		*sleep = 0;

	else

		*sleep = *active;

}



/*

 * This function is used to aggregate the votes across the active only

 * resources and its peers. The aggregated votes are sent to RPMh as

 * ACTIVE_ONLY votes (which take effect immediately), as WAKE_ONLY votes

 * (applied by RPMh on system wakeup) and as SLEEP votes (applied by RPMh

 * on system sleep).

 * We send ACTIVE_ONLY votes for resources without any peers. For others,

 * which have an active only peer, all 3 votes are sent.

 */

static int rpmhpd_aggregate_corner(struct rpmhpd *pd, unsigned int corner)

{

	int ret;

	struct rpmhpd *peer = pd->peer;

	unsigned int active_corner, sleep_corner;

	unsigned int this_active_corner = 0, this_sleep_corner = 0;

	unsigned int peer_active_corner = 0, peer_sleep_corner = 0;



	to_active_sleep(pd, corner, &this_active_corner, &this_sleep_corner);



	if (peer && peer->enabled)

		to_active_sleep(peer, peer->corner, &peer_active_corner,

				&peer_sleep_corner);



	active_corner = max(this_active_corner, peer_active_corner);



	ret = rpmhpd_send_corner(pd, RPMH_ACTIVE_ONLY_STATE, active_corner,

				 active_corner > pd->active_corner);

	if (ret)

		return ret;



	pd->active_corner = active_corner;



	if (peer) {

		peer->active_corner = active_corner;



		ret = rpmhpd_send_corner(pd, RPMH_WAKE_ONLY_STATE,

					 active_corner, false);

		if (ret)

			return ret;



		sleep_corner = max(this_sleep_corner, peer_sleep_corner);



		return rpmhpd_send_corner(pd, RPMH_SLEEP_STATE, sleep_corner,

					  false);

	}



	return ret;

}



static int rpmhpd_power_on(struct generic_pm_domain *domain)

{

	struct rpmhpd *pd = domain_to_rpmhpd(domain);

	int ret = 0;



	mutex_lock(&rpmhpd_lock);



	if (pd->corner)

		ret = rpmhpd_aggregate_corner(pd, pd->corner);



	if (!ret)

		pd->enabled = true;



	mutex_unlock(&rpmhpd_lock);



	return ret;

}



static int rpmhpd_power_off(struct generic_pm_domain *domain)

{

	struct rpmhpd *pd = domain_to_rpmhpd(domain);

	int ret = 0;



	mutex_lock(&rpmhpd_lock);



	ret = rpmhpd_aggregate_corner(pd, pd->level[0]);



	if (!ret)

		pd->enabled = false;



	mutex_unlock(&rpmhpd_lock);



	return ret;

}



static int rpmhpd_set_performance_state(struct generic_pm_domain *domain,

					unsigned int level)

{

	struct rpmhpd *pd = domain_to_rpmhpd(domain);

	int ret = 0, i;



	mutex_lock(&rpmhpd_lock);



	for (i = 0; i < pd->level_count; i++)

		if (level <= pd->level[i])

			break;



	/*

	 * If the level requested is more than that supported by the

	 * max corner, just set it to max anyway.

	 */

	if (i == pd->level_count)

		i--;



	if (pd->enabled) {

		ret = rpmhpd_aggregate_corner(pd, i);

		if (ret)

			goto out;

	}



	pd->corner = i;

out:

	mutex_unlock(&rpmhpd_lock);



	return ret;

}



static unsigned int rpmhpd_get_performance_state(struct generic_pm_domain *genpd,

						 struct dev_pm_opp *opp)

{

	return dev_pm_opp_get_level(opp);

}



static int rpmhpd_update_level_mapping(struct rpmhpd *rpmhpd)

{

	int i;

	const u16 *buf;



	buf = cmd_db_read_aux_data(rpmhpd->res_name, &rpmhpd->level_count);

	if (IS_ERR(buf))

		return PTR_ERR(buf);



	/* 2 bytes used for each command DB aux data entry */

	rpmhpd->level_count >>= 1;



	if (rpmhpd->level_count > RPMH_ARC_MAX_LEVELS)

		return -EINVAL;



	for (i = 0; i < rpmhpd->level_count; i++) {

		rpmhpd->level[i] = buf[i];



		/*

		 * The AUX data may be zero padded.  These 0 valued entries at

		 * the end of the map must be ignored.

		 */

		if (i > 0 && rpmhpd->level[i] == 0) {

			rpmhpd->level_count = i;

			break;

		}

		pr_debug("%s: ARC hlvl=%2d --> vlvl=%4u\n", rpmhpd->res_name, i,

			 rpmhpd->level[i]);

	}



	return 0;

}



static int rpmhpd_probe(struct platform_device *pdev)

{

	int i, ret;

	size_t num_pds;

	struct device *dev = &pdev->dev;

	struct genpd_onecell_data *data;

	struct rpmhpd **rpmhpds;

	const struct rpmhpd_desc *desc;



	desc = of_device_get_match_data(dev);

	if (!desc)

		return -EINVAL;



	rpmhpds = desc->rpmhpds;

	num_pds = desc->num_pds;



	data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);

	if (!data)

		return -ENOMEM;



	data->domains = devm_kcalloc(dev, num_pds, sizeof(*data->domains),

				     GFP_KERNEL);

	if (!data->domains)

		return -ENOMEM;



	data->num_domains = num_pds;



	for (i = 0; i < num_pds; i++) {

		if (!rpmhpds[i]) {

			dev_warn(dev, "rpmhpds[%d] is empty\n", i);

			continue;

		}



		rpmhpds[i]->dev = dev;

		rpmhpds[i]->addr = cmd_db_read_addr(rpmhpds[i]->res_name);

		if (!rpmhpds[i]->addr) {

			dev_err(dev, "Could not find RPMh address for resource %s\n",

				rpmhpds[i]->res_name);

			return -ENODEV;

		}



		ret = cmd_db_read_slave_id(rpmhpds[i]->res_name);

		if (ret != CMD_DB_HW_ARC) {

			dev_err(dev, "RPMh slave ID mismatch\n");

			return -EINVAL;

		}



		ret = rpmhpd_update_level_mapping(rpmhpds[i]);

		if (ret)

			return ret;



		rpmhpds[i]->pd.power_off = rpmhpd_power_off;

		rpmhpds[i]->pd.power_on = rpmhpd_power_on;

		rpmhpds[i]->pd.set_performance_state = rpmhpd_set_performance_state;

		rpmhpds[i]->pd.opp_to_performance_state = rpmhpd_get_performance_state;

		pm_genpd_init(&rpmhpds[i]->pd, NULL, true);



		data->domains[i] = &rpmhpds[i]->pd;

	}



	return of_genpd_add_provider_onecell(pdev->dev.of_node, data);

}



static struct platform_driver rpmhpd_driver = {

	.driver = {

		.name = "qcom-rpmhpd",

		.of_match_table = rpmhpd_match_table,

		.suppress_bind_attrs = true,

	},

	.probe = rpmhpd_probe,

};



static int __init rpmhpd_init(void)

{

	return platform_driver_register(&rpmhpd_driver);

}

core_initcall(rpmhpd_init);

CRA Git | Maintained and supported by SUSTech CRA and CCSE