Commit 993330e0 authored by Arnd Bergmann's avatar Arnd Bergmann
Browse files

Merge tag 'amlogic-drivers' of... 

Merge tag 'amlogic-drivers' of git://git.kernel.org/pub/scm/linux/kernel/git/khilman/linux-amlogic into arm/drivers

soc: drivers: Amlogic updates for v5.7
- Add secure power domain controller

* tag 'amlogic-drivers' of git://git.kernel.org/pub/scm/linux/kernel/git/khilman/linux-amlogic:
  dt-bindings: power: Fix dt_binding_check error
  soc: amlogic: fix compile failure with MESON_SECURE_PM_DOMAINS & !MESON_SM
  soc: amlogic: Add support for Secure power domains controller
  dt-bindings: power: add Amlogic secure power domains bindings
  firmware: meson_sm: Add secure power domain support

Link: https://lore.kernel.org/r/7hpndcugoo.fsf@baylibre.com


Signed-off-by: default avatarArnd Bergmann <arnd@arndb.de>
parents f22940b7 d85eed03

Documentation/devicetree/bindings/power/amlogic,meson-sec-pwrc.yaml

0 → 100644
+40 −0
Original line number Diff line number Diff line 
# SPDX-License-Identifier: (GPL-2.0+ OR MIT)

# Copyright (c) 2019 Amlogic, Inc

# Author: Jianxin Pan <jianxin.pan@amlogic.com>

%YAML 1.2

---

$id: "http://devicetree.org/schemas/power/amlogic,meson-sec-pwrc.yaml#"

$schema: "http://devicetree.org/meta-schemas/core.yaml#"



title: Amlogic Meson Secure Power Domains



maintainers:

  - Jianxin Pan <jianxin.pan@amlogic.com>



description: |+

  Secure Power Domains used in Meson A1/C1 SoCs, and should be the child node

  of secure-monitor.



properties:

  compatible:

    enum:

      - amlogic,meson-a1-pwrc



  "#power-domain-cells":

    const: 1



required:

  - compatible

  - "#power-domain-cells"



examples:

  - |

    secure-monitor {

        compatible = "amlogic,meson-gxbb-sm";



        pwrc: power-controller {

            compatible = "amlogic,meson-a1-pwrc";

            #power-domain-cells = <1>;

        };

    };

drivers/firmware/meson/meson_sm.c

+2 −0
Original line number Diff line number Diff line
@@ -44,6 +44,8 @@ static const struct meson_sm_chip gxbb_chip = { 
		CMD(SM_EFUSE_WRITE,	0x82000031),

		CMD(SM_EFUSE_USER_MAX,	0x82000033),

		CMD(SM_GET_CHIP_ID,	0x82000044),

		CMD(SM_A1_PWRC_SET,	0x82000093),

		CMD(SM_A1_PWRC_GET,	0x82000095),

		{ /* sentinel */ },

	},

};

drivers/soc/amlogic/Kconfig

+13 −0
Original line number Diff line number Diff line
@@ -48,6 +48,19 @@ config MESON_EE_PM_DOMAINS 
	  Say yes to expose Amlogic Meson Everything-Else Power Domains as

	  Generic Power Domains.



config MESON_SECURE_PM_DOMAINS

	bool "Amlogic Meson Secure Power Domains driver"

	depends on (ARCH_MESON || COMPILE_TEST) && MESON_SM

	depends on PM && OF

	depends on HAVE_ARM_SMCCC

	default ARCH_MESON

	select PM_GENERIC_DOMAINS

	select PM_GENERIC_DOMAINS_OF

	help

	  Support for the power controller on Amlogic A1/C1 series.

	  Say yes to expose Amlogic Meson Secure Power Domains as Generic

	  Power Domains.



config MESON_MX_SOCINFO

	bool "Amlogic Meson MX SoC Information driver"

	depends on ARCH_MESON || COMPILE_TEST

drivers/soc/amlogic/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -5,3 +5,4 @@ obj-$(CONFIG_MESON_GX_SOCINFO) += meson-gx-socinfo.o 
obj-$(CONFIG_MESON_GX_PM_DOMAINS) += meson-gx-pwrc-vpu.o

obj-$(CONFIG_MESON_MX_SOCINFO) += meson-mx-socinfo.o

obj-$(CONFIG_MESON_EE_PM_DOMAINS) += meson-ee-pwrc.o

obj-$(CONFIG_MESON_SECURE_PM_DOMAINS) += meson-secure-pwrc.o

drivers/soc/amlogic/meson-secure-pwrc.c

0 → 100644
+204 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: (GPL-2.0+ OR MIT)

/*

 * Copyright (c) 2019 Amlogic, Inc.

 * Author: Jianxin Pan <jianxin.pan@amlogic.com>

 */



#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt



#include <linux/io.h>

#include <linux/of_device.h>

#include <linux/platform_device.h>

#include <linux/pm_domain.h>

#include <dt-bindings/power/meson-a1-power.h>

#include <linux/arm-smccc.h>

#include <linux/firmware/meson/meson_sm.h>



#define PWRC_ON		1

#define PWRC_OFF	0



struct meson_secure_pwrc_domain {

	struct generic_pm_domain base;

	unsigned int index;

	struct meson_secure_pwrc *pwrc;

};



struct meson_secure_pwrc {

	struct meson_secure_pwrc_domain *domains;

	struct genpd_onecell_data xlate;

	struct meson_sm_firmware *fw;

};



struct meson_secure_pwrc_domain_desc {

	unsigned int index;

	unsigned int flags;

	char *name;

	bool (*is_off)(struct meson_secure_pwrc_domain *pwrc_domain);

};



struct meson_secure_pwrc_domain_data {

	unsigned int count;

	struct meson_secure_pwrc_domain_desc *domains;

};



static bool pwrc_secure_is_off(struct meson_secure_pwrc_domain *pwrc_domain)

{

	int is_off = 1;



	if (meson_sm_call(pwrc_domain->pwrc->fw, SM_A1_PWRC_GET, &is_off,

			  pwrc_domain->index, 0, 0, 0, 0) < 0)

		pr_err("failed to get power domain status\n");



	return is_off;

}



static int meson_secure_pwrc_off(struct generic_pm_domain *domain)

{

	int ret = 0;

	struct meson_secure_pwrc_domain *pwrc_domain =

		container_of(domain, struct meson_secure_pwrc_domain, base);



	if (meson_sm_call(pwrc_domain->pwrc->fw, SM_A1_PWRC_SET, NULL,

			  pwrc_domain->index, PWRC_OFF, 0, 0, 0) < 0) {

		pr_err("failed to set power domain off\n");

		ret = -EINVAL;

	}



	return ret;

}



static int meson_secure_pwrc_on(struct generic_pm_domain *domain)

{

	int ret = 0;

	struct meson_secure_pwrc_domain *pwrc_domain =

		container_of(domain, struct meson_secure_pwrc_domain, base);



	if (meson_sm_call(pwrc_domain->pwrc->fw, SM_A1_PWRC_SET, NULL,

			  pwrc_domain->index, PWRC_ON, 0, 0, 0) < 0) {

		pr_err("failed to set power domain on\n");

		ret = -EINVAL;

	}



	return ret;

}



#define SEC_PD(__name, __flag)			\

[PWRC_##__name##_ID] =				\

{						\

	.name = #__name,			\

	.index = PWRC_##__name##_ID,		\

	.is_off = pwrc_secure_is_off,	\

	.flags = __flag,			\

}



static struct meson_secure_pwrc_domain_desc a1_pwrc_domains[] = {

	SEC_PD(DSPA,	0),

	SEC_PD(DSPB,	0),

	/* UART should keep working in ATF after suspend and before resume */

	SEC_PD(UART,	GENPD_FLAG_ALWAYS_ON),

	/* DMC is for DDR PHY ana/dig and DMC, and should be always on */

	SEC_PD(DMC,	GENPD_FLAG_ALWAYS_ON),

	SEC_PD(I2C,	0),

	SEC_PD(PSRAM,	0),

	SEC_PD(ACODEC,	0),

	SEC_PD(AUDIO,	0),

	SEC_PD(OTP,	0),

	SEC_PD(DMA,	0),

	SEC_PD(SD_EMMC,	0),

	SEC_PD(RAMA,	0),

	/* SRAMB is used as ATF runtime memory, and should be always on */

	SEC_PD(RAMB,	GENPD_FLAG_ALWAYS_ON),

	SEC_PD(IR,	0),

	SEC_PD(SPICC,	0),

	SEC_PD(SPIFC,	0),

	SEC_PD(USB,	0),

	/* NIC is for the Arm NIC-400 interconnect, and should be always on */

	SEC_PD(NIC,	GENPD_FLAG_ALWAYS_ON),

	SEC_PD(PDMIN,	0),

	SEC_PD(RSA,	0),

};



static int meson_secure_pwrc_probe(struct platform_device *pdev)

{

	int i;

	struct device_node *sm_np;

	struct meson_secure_pwrc *pwrc;

	const struct meson_secure_pwrc_domain_data *match;



	match = of_device_get_match_data(&pdev->dev);

	if (!match) {

		dev_err(&pdev->dev, "failed to get match data\n");

		return -ENODEV;

	}



	sm_np = of_find_compatible_node(NULL, NULL, "amlogic,meson-gxbb-sm");

	if (!sm_np) {

		dev_err(&pdev->dev, "no secure-monitor node\n");

		return -ENODEV;

	}



	pwrc = devm_kzalloc(&pdev->dev, sizeof(*pwrc), GFP_KERNEL);

	if (!pwrc)

		return -ENOMEM;



	pwrc->fw = meson_sm_get(sm_np);

	of_node_put(sm_np);

	if (!pwrc->fw)

		return -EPROBE_DEFER;



	pwrc->xlate.domains = devm_kcalloc(&pdev->dev, match->count,

					   sizeof(*pwrc->xlate.domains),

					   GFP_KERNEL);

	if (!pwrc->xlate.domains)

		return -ENOMEM;



	pwrc->domains = devm_kcalloc(&pdev->dev, match->count,

				     sizeof(*pwrc->domains), GFP_KERNEL);

	if (!pwrc->domains)

		return -ENOMEM;



	pwrc->xlate.num_domains = match->count;

	platform_set_drvdata(pdev, pwrc);



	for (i = 0 ; i < match->count ; ++i) {

		struct meson_secure_pwrc_domain *dom = &pwrc->domains[i];



		if (!match->domains[i].index)

			continue;



		dom->pwrc = pwrc;

		dom->index = match->domains[i].index;

		dom->base.name = match->domains[i].name;

		dom->base.flags = match->domains[i].flags;

		dom->base.power_on = meson_secure_pwrc_on;

		dom->base.power_off = meson_secure_pwrc_off;



		pm_genpd_init(&dom->base, NULL, match->domains[i].is_off(dom));



		pwrc->xlate.domains[i] = &dom->base;

	}



	return of_genpd_add_provider_onecell(pdev->dev.of_node, &pwrc->xlate);

}



static struct meson_secure_pwrc_domain_data meson_secure_a1_pwrc_data = {

	.domains = a1_pwrc_domains,

	.count = ARRAY_SIZE(a1_pwrc_domains),

};



static const struct of_device_id meson_secure_pwrc_match_table[] = {

	{

		.compatible = "amlogic,meson-a1-pwrc",

		.data = &meson_secure_a1_pwrc_data,

	},

	{ /* sentinel */ }

};



static struct platform_driver meson_secure_pwrc_driver = {

	.probe = meson_secure_pwrc_probe,

	.driver = {

		.name		= "meson_secure_pwrc",

		.of_match_table	= meson_secure_pwrc_match_table,

	},

};

builtin_platform_driver(meson_secure_pwrc_driver);

CRA Git | Maintained and supported by SUSTech CRA and CCSE