Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 898216c9 authored by Sudeep Holla's avatar Sudeep Holla
Browse files

firmware: arm_scmi: add device power domain support using genpd 



This patch hooks up the support for device power domain provided by
SCMI using the Linux generic power domain infrastructure.

Cc: Kevin Hilman <khilman@baylibre.com>
Reviewed-by: default avatarUlf Hansson <ulf.hansson@linaro.org>
Signed-off-by: default avatarSudeep Holla <sudeep.holla@arm.com>
parent 907b6d14

drivers/firmware/Kconfig

+13 −0
Original line number Diff line number Diff line
@@ -40,6 +40,19 @@ config ARM_SCMI_PROTOCOL 
	  This protocol library provides interface for all the client drivers

	  making use of the features offered by the SCMI.



config ARM_SCMI_POWER_DOMAIN

	tristate "SCMI power domain driver"

	depends on ARM_SCMI_PROTOCOL || (COMPILE_TEST && OF)

	default y

	select PM_GENERIC_DOMAINS if PM

	help

	  This enables support for the SCMI power domains which can be

	  enabled or disabled via the SCP firmware



	  This driver can also be built as a module.  If so, the module

	  will be called scmi_pm_domain. Note this may needed early in boot

	  before rootfs may be available.



config ARM_SCPI_PROTOCOL

	tristate "ARM System Control and Power Interface (SCPI) Message Protocol"

	depends on ARM || ARM64 || COMPILE_TEST

drivers/firmware/arm_scmi/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -2,3 +2,4 @@ obj-y = scmi-bus.o scmi-driver.o scmi-protocols.o 
scmi-bus-y = bus.o

scmi-driver-y = driver.o

scmi-protocols-y = base.o clock.o perf.o power.o sensors.o

obj-$(CONFIG_ARM_SCMI_POWER_DOMAIN) += scmi_pm_domain.o

drivers/firmware/arm_scmi/scmi_pm_domain.c

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

/*

 * SCMI Generic power domain support.

 *

 * Copyright (C) 2018 ARM Ltd.

 */



#include <linux/err.h>

#include <linux/io.h>

#include <linux/module.h>

#include <linux/pm_domain.h>

#include <linux/scmi_protocol.h>



struct scmi_pm_domain {

	struct generic_pm_domain genpd;

	const struct scmi_handle *handle;

	const char *name;

	u32 domain;

};



#define to_scmi_pd(gpd) container_of(gpd, struct scmi_pm_domain, genpd)



static int scmi_pd_power(struct generic_pm_domain *domain, bool power_on)

{

	int ret;

	u32 state, ret_state;

	struct scmi_pm_domain *pd = to_scmi_pd(domain);

	const struct scmi_power_ops *ops = pd->handle->power_ops;



	if (power_on)

		state = SCMI_POWER_STATE_GENERIC_ON;

	else

		state = SCMI_POWER_STATE_GENERIC_OFF;



	ret = ops->state_set(pd->handle, pd->domain, state);

	if (!ret)

		ret = ops->state_get(pd->handle, pd->domain, &ret_state);

	if (!ret && state != ret_state)

		return -EIO;



	return ret;

}



static int scmi_pd_power_on(struct generic_pm_domain *domain)

{

	return scmi_pd_power(domain, true);

}



static int scmi_pd_power_off(struct generic_pm_domain *domain)

{

	return scmi_pd_power(domain, false);

}



static int scmi_pm_domain_probe(struct scmi_device *sdev)

{

	int num_domains, i;

	struct device *dev = &sdev->dev;

	struct device_node *np = dev->of_node;

	struct scmi_pm_domain *scmi_pd;

	struct genpd_onecell_data *scmi_pd_data;

	struct generic_pm_domain **domains;

	const struct scmi_handle *handle = sdev->handle;



	if (!handle || !handle->power_ops)

		return -ENODEV;



	num_domains = handle->power_ops->num_domains_get(handle);

	if (num_domains < 0) {

		dev_err(dev, "number of domains not found\n");

		return num_domains;

	}



	scmi_pd = devm_kcalloc(dev, num_domains, sizeof(*scmi_pd), GFP_KERNEL);

	if (!scmi_pd)

		return -ENOMEM;



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

	if (!scmi_pd_data)

		return -ENOMEM;



	domains = devm_kcalloc(dev, num_domains, sizeof(*domains), GFP_KERNEL);

	if (!domains)

		return -ENOMEM;



	for (i = 0; i < num_domains; i++, scmi_pd++) {

		u32 state;



		domains[i] = &scmi_pd->genpd;



		scmi_pd->domain = i;

		scmi_pd->handle = handle;

		scmi_pd->name = handle->power_ops->name_get(handle, i);

		scmi_pd->genpd.name = scmi_pd->name;

		scmi_pd->genpd.power_off = scmi_pd_power_off;

		scmi_pd->genpd.power_on = scmi_pd_power_on;



		if (handle->power_ops->state_get(handle, i, &state)) {

			dev_warn(dev, "failed to get state for domain %d\n", i);

			continue;

		}



		pm_genpd_init(&scmi_pd->genpd, NULL,

			      state == SCMI_POWER_STATE_GENERIC_OFF);

	}



	scmi_pd_data->domains = domains;

	scmi_pd_data->num_domains = num_domains;



	of_genpd_add_provider_onecell(np, scmi_pd_data);



	return 0;

}



static const struct scmi_device_id scmi_id_table[] = {

	{ SCMI_PROTOCOL_POWER },

	{ },

};

MODULE_DEVICE_TABLE(scmi, scmi_id_table);



static struct scmi_driver scmi_power_domain_driver = {

	.name = "scmi-power-domain",

	.probe = scmi_pm_domain_probe,

	.id_table = scmi_id_table,

};

module_scmi_driver(scmi_power_domain_driver);



MODULE_AUTHOR("Sudeep Holla <sudeep.holla@arm.com>");

MODULE_DESCRIPTION("ARM SCMI power domain driver");

MODULE_LICENSE("GPL v2");