Re: [PATCHv3 14/26] power: domain: Introduce driver for raw TI K3 PDs

Hi Tero,

On 5/6/21 2:55 AM, Tero Kristo wrote:

From: Tero Kristo t-kristo@ti.com

Normally, power domains are handled via TI-SCI in K3 SoCs. However, SPL is not going to have access to sysfw resources, so it must control them directly. Add driver for supporting this.

Signed-off-by: Tero Kristo t-kristo@ti.com Signed-off-by: Tero Kristo kristo@kernel.org

---

drivers/power/domain/Kconfig | 7 + drivers/power/domain/Makefile | 1 + drivers/power/domain/ti-power-domain.c | 377 +++++++++++++++++++++++++ include/k3-dev.h | 76 +++++ 4 files changed, 461 insertions(+) create mode 100644 drivers/power/domain/ti-power-domain.c create mode 100644 include/k3-dev.h

diff --git a/drivers/power/domain/Kconfig b/drivers/power/domain/Kconfig index a0fd980752..b03a82d82c 100644 --- a/drivers/power/domain/Kconfig +++ b/drivers/power/domain/Kconfig @@ -72,4 +72,11 @@ config TI_SCI_POWER_DOMAIN help Generic power domain implementation for TI devices implementing the TI SCI protocol.

+config TI_POWER_DOMAIN

• bool "Enable the TI K3 Power domain driver"
• depends on POWER_DOMAIN

Add your ARCH config as "depends on". This is TI specific thing.

• help

•  Generic power domain implementation for TI K3 devices.
  

endmenu diff --git a/drivers/power/domain/Makefile b/drivers/power/domain/Makefile index 45bf9f6383..3d1e5f073c 100644 --- a/drivers/power/domain/Makefile +++ b/drivers/power/domain/Makefile @@ -14,3 +14,4 @@ obj-$(CONFIG_SANDBOX_POWER_DOMAIN) += sandbox-power-domain.o obj-$(CONFIG_SANDBOX_POWER_DOMAIN) += sandbox-power-domain-test.o obj-$(CONFIG_TEGRA186_POWER_DOMAIN) += tegra186-power-domain.o obj-$(CONFIG_TI_SCI_POWER_DOMAIN) += ti-sci-power-domain.o +obj-$(CONFIG_TI_POWER_DOMAIN) += ti-power-domain.o diff --git a/drivers/power/domain/ti-power-domain.c b/drivers/power/domain/ti-power-domain.c new file mode 100644 index 0000000000..ee2dc698ae --- /dev/null +++ b/drivers/power/domain/ti-power-domain.c @@ -0,0 +1,377 @@ +// SPDX-License-Identifier: GPL-2.0+ +/*

• • Texas Instruments power domain driver
• • Copyright (C) 2020 Texas Instruments Incorporated - http://www.ti.com/

2021?

• • Tero Kristo t-kristo@ti.com
• */

+#include <asm/io.h> +#include <common.h> +#include <dm.h> +#include <errno.h> +#include <power-domain-uclass.h> +#include <soc.h> +#include <k3-dev.h>

+#define PSC_PTCMD 0x120 +#define PSC_PTSTAT 0x128 +#define PSC_PDSTAT 0x200 +#define PSC_PDCTL 0x300 +#define PSC_MDSTAT 0x800 +#define PSC_MDCTL 0xa00

+#define PDCTL_STATE_MASK 0x1 +#define PDCTL_STATE_OFF 0x0 +#define PDCTL_STATE_ON 0x1

+#define MDSTAT_STATE_MASK 0x3f +#define MDSTAT_BUSY_MASK 0x30 +#define MDSTAT_STATE_SWRSTDISABLE 0x0 +#define MDSTAT_STATE_ENABLE 0x3

+#define LPSC_TIMEOUT 100000 +#define PD_TIMEOUT 100000

+static u32 psc_read(struct ti_psc *psc, u32 reg) +{

• u32 val;
• val = readl(psc->base + reg);
• debug("%s: 0x%x from %p\n", __func__, val, psc->base + reg);
• return val;

+}

+static void psc_write(u32 val, struct ti_psc *psc, u32 reg) +{

• debug("%s: 0x%x to %p\n", __func__, val, psc->base + reg);
• writel(val, psc->base + reg);

+}

+static u32 pd_read(struct ti_pd *pd, u32 reg) +{

• return psc_read(pd->psc, reg + 4 * pd->id);

+}

+static void pd_write(u32 val, struct ti_pd *pd, u32 reg) +{

• psc_write(val, pd->psc, reg + 4 * pd->id);

+}

+static u32 lpsc_read(struct ti_lpsc *lpsc, u32 reg) +{

• return psc_read(lpsc->psc, reg + 4 * lpsc->id);

+}

+static void lpsc_write(u32 val, struct ti_lpsc *lpsc, u32 reg) +{

• psc_write(val, lpsc->psc, reg + 4 * lpsc->id);

+}

+static const struct soc_attr ti_k3_soc_pd_data[] = { +#ifdef CONFIG_SOC_K3_J721E

• {

• .family = "J721E",
  

• .data = &j721e_pd_platdata,
  

• },
• {

• .family = "J7200",
  

• .data = &j7200_pd_platdata,
  

• },

+#endif

• { /* sentinel */ }

+};

+static int ti_power_domain_probe(struct udevice *dev) +{

• struct ti_k3_pd_platdata *data = dev_get_priv(dev);
• const struct soc_attr *soc_match_data;
• const struct ti_k3_pd_platdata *pdata;
• printf("%s(dev=%p)\n", __func__, dev);
• if (!data)

• return -ENOMEM;
  

• soc_match_data = soc_device_match(ti_k3_soc_pd_data);
• if (!soc_match_data)

• return -ENODEV;
  

• pdata = (const struct ti_k3_pd_platdata *)soc_match_data->data;
• data->psc = pdata->psc;
• data->pd = pdata->pd;
• data->lpsc = pdata->lpsc;
• data->devs = pdata->devs;
• data->num_psc = pdata->num_psc;
• data->num_pd = pdata->num_pd;
• data->num_lpsc = pdata->num_lpsc;
• data->num_devs = pdata->num_devs;
• return 0;

+}

+static int ti_pd_wait(struct ti_pd *pd) +{

• u32 ptstat;
• int i = PD_TIMEOUT;
• while (i) {

• ptstat = psc_read(pd->psc, PSC_PTSTAT);
  

• if (!(ptstat & BIT(pd->id)))
  

• 	return 0;
  

• i--;
  

• }

doesn't use readl_pool_timeout() function?

• debug("%s: psc%d, pd%d failed to transition.\n", __func__,

•      pd->psc->id, pd->id);
  

• return -ETIMEDOUT;

+}

+static void ti_pd_transition(struct ti_pd *pd) +{

• psc_write(BIT(pd->id), pd->psc, PSC_PTCMD);

+}

+static u8 ti_pd_state(struct ti_pd *pd) +{

• u32 pdctl;

Not need to use pdctl variable.

return pd_read(pd, PSC_PDCTL) & PDCTL_STATE_MASK;

• pdctl = pd_read(pd, PSC_PDCTL);
• return pdctl & PDCTL_STATE_MASK;

+}

+static int ti_pd_get(struct ti_pd *pd) +{

• u32 pdctl;
• int ret;
• pd->usecount++;
• if (pd->usecount > 1)

• return 0;
  

• if (pd->depend) {

• ret = ti_pd_get(pd->depend);
  

• if (ret)
  

• 	return ret;
  

• ti_pd_transition(pd->depend);
  

• ret = ti_pd_wait(pd->depend);
  

• if (ret)
  

• 	return ret;
  

• }
• pdctl = pd_read(pd, PSC_PDCTL);
• if ((pdctl & PDCTL_STATE_MASK) == PDCTL_STATE_ON)

• return 0;
  

• debug("%s: enabling psc:%d, pd:%d\n", __func__, pd->psc->id, pd->id);
• pdctl &= ~PDCTL_STATE_MASK;
• pdctl |= PDCTL_STATE_ON;
• pd_write(pdctl, pd, PSC_PDCTL);
• return 0;

+}

+static int ti_pd_put(struct ti_pd *pd) +{

• u32 pdctl;
• int ret;
• pd->usecount--;
• if (pd->usecount > 0)

• return 0;
  

• pdctl = pd_read(pd, PSC_PDCTL);
• if ((pdctl & PDCTL_STATE_MASK) == PDCTL_STATE_OFF)

• return 0;
  

• pdctl &= ~PDCTL_STATE_MASK;
• pdctl |= PDCTL_STATE_OFF;
• debug("%s: disabling psc:%d, pd:%d\n", __func__, pd->psc->id, pd->id);
• pd_write(pdctl, pd, PSC_PDCTL);
• if (pd->depend) {

• ti_pd_transition(pd);
  

• ret = ti_pd_wait(pd);
  

• if (ret)
  

• 	return ret;
  

• ret = ti_pd_put(pd->depend);
  

• if (ret)
  

• 	return ret;
  

• ti_pd_transition(pd->depend);
  

• ret = ti_pd_wait(pd->depend);
  

• if (ret)
  

• 	return ret;
  

• }
• return 0;

+}

+static int ti_lpsc_wait(struct ti_lpsc *lpsc) +{

• u32 mdstat;
• int i = LPSC_TIMEOUT;
• while (i) {

• mdstat = lpsc_read(lpsc, PSC_MDSTAT);
  

• if (!(mdstat & MDSTAT_BUSY_MASK))
  

• 	return 0;
  

• i--;
  

• }
• printf("%s: module %d failed to transition.\n", __func__, lpsc->id);
• return -ETIMEDOUT;

+}

+static u8 lpsc_get_state(struct ti_lpsc *lpsc) +{

• u32 mdctl;
• mdctl = lpsc_read(lpsc, PSC_MDCTL);
• return mdctl & MDSTAT_STATE_MASK;

Ditto. return lpas_rad() & MDSTATE_STATE_MASK;

+}

+static int ti_lpsc_transition(struct ti_lpsc *lpsc, u8 state) +{

• struct ti_pd *psc_pd;
• int ret;
• u32 mdctl;
• psc_pd = lpsc->pd;
• if (state == MDSTAT_STATE_ENABLE) {

• lpsc->usecount++;
  

• if (lpsc->usecount > 1)
  

• 	return 0;
  

• } else {

• lpsc->usecount--;
  

• if (lpsc->usecount >= 1)
  

• 	return 0;
  

• }
• debug("%s: transitioning psc:%d, lpsc:%d to %x\n", __func__,

•      lpsc->psc->id, lpsc->id, state);
  

• if (lpsc->depend)

• ti_lpsc_transition(lpsc->depend, state);
  

• mdctl = lpsc_read(lpsc, PSC_MDCTL);
• if ((mdctl & MDSTAT_STATE_MASK) == state)

• return 0;
  

• if (state == MDSTAT_STATE_ENABLE)

• ti_pd_get(psc_pd);
  

• else

• ti_pd_put(psc_pd);
  

• mdctl &= ~MDSTAT_STATE_MASK;
• mdctl |= state;
• lpsc_write(mdctl, lpsc, PSC_MDCTL);
• ti_pd_transition(psc_pd);
• ret = ti_pd_wait(psc_pd);
• if (ret)

• return ret;
  

• return ti_lpsc_wait(lpsc);

+}

+static int ti_power_domain_transition(struct power_domain *pd, u8 state) +{

• struct ti_lpsc *lpsc = pd->priv;
• return ti_lpsc_transition(lpsc, state);

+}

+static int ti_power_domain_on(struct power_domain *pd) +{

• debug("%s(pd=%p, id=%lu)\n", __func__, pd, pd->id);
• return ti_power_domain_transition(pd, MDSTAT_STATE_ENABLE);

+}

+static int ti_power_domain_off(struct power_domain *pd) +{

• debug("%s(pd=%p, id=%lu)\n", __func__, pd, pd->id);
• return ti_power_domain_transition(pd, MDSTAT_STATE_SWRSTDISABLE);

+}

+static struct ti_lpsc *lpsc_lookup(struct ti_k3_pd_platdata *data, int id) +{

• int idx;
• for (idx = 0; idx < data->num_devs; idx++)

• if (data->devs[idx].id == id)
  

• 	return data->devs[idx].lpsc;
  

• return NULL;

+}

+static int ti_power_domain_of_xlate(struct power_domain *pd,

• 		    struct ofnode_phandle_args *args)
  

+{

• struct ti_k3_pd_platdata *data = dev_get_priv(pd->dev);
• struct ti_lpsc *lpsc;
• debug("%s(power_domain=%p, id=%d)\n", __func__, pd, args->args[0]);
• if (args->args_count < 1) {

• debug("Invalid args_count: %d\n", args->args_count);
  

• return -EINVAL;
  

• }
• lpsc = lpsc_lookup(data, args->args[0]);
• if (!lpsc) {

• printf("%s: invalid dev-id: %d\n", __func__, args->args[0]);
  

Well, you're using debug to display error message. but it's used printf at here. how about choosing one of them?

• return -ENOENT;
  

• }
• pd->id = lpsc->id;
• pd->priv = lpsc;
• return 0;

+}

+static int ti_power_domain_request(struct power_domain *pd) +{

• return 0;

+}

+static int ti_power_domain_free(struct power_domain *pd) +{

• return 0;

+}

+static const struct udevice_id ti_power_domain_of_match[] = {

• { .compatible = "ti,sci-pm-domain" },
• { /* sentinel */ }

+};

+static struct power_domain_ops ti_power_domain_ops = {

• .on = ti_power_domain_on,
• .off = ti_power_domain_off,
• .of_xlate = ti_power_domain_of_xlate,
• .request = ti_power_domain_request,
• .rfree = ti_power_domain_free,

+};

+U_BOOT_DRIVER(ti_pm_domains) = {

• .name = "ti-pm-domains",
• .id = UCLASS_POWER_DOMAIN,
• .of_match = ti_power_domain_of_match,
• .probe = ti_power_domain_probe,
• .priv_auto = sizeof(struct ti_k3_pd_platdata),
• .ops = &ti_power_domain_ops,

+}; diff --git a/include/k3-dev.h b/include/k3-dev.h new file mode 100644 index 0000000000..de3a8bdf9e --- /dev/null +++ b/include/k3-dev.h @@ -0,0 +1,76 @@ +/* SPDX-License-Identifier: GPL-2.0+ */ +/*

• • Texas Instruments K3 Device Platform Data
• • Copyright (C) 2020 Texas Instruments Incorporated - http://www.ti.com/
• */

+#ifndef __K3_DEV_H__ +#define __K3_DEV_H__

+#include <asm/io.h> +#include <linux/types.h> +#include <stdint.h>

+#define LPSC_MODULE_EXISTS BIT(0) +#define LPSC_NO_CLOCK_GATING BIT(1) +#define LPSC_DEPENDS BIT(2) +#define LPSC_HAS_RESET_ISO BIT(3) +#define LPSC_HAS_LOCAL_RESET BIT(4) +#define LPSC_NO_MODULE_RESET BIT(5)

+#define PSC_PD_EXISTS BIT(0) +#define PSC_PD_ALWAYSON BIT(1) +#define PSC_PD_DEPENDS BIT(2)

+struct ti_psc {

• int id;
• void __iomem *base;

+};

+struct ti_pd;

+struct ti_pd {

• int id;
• int usecount;
• struct ti_psc *psc;
• struct ti_pd *depend;

+};

+struct ti_lpsc;

+struct ti_lpsc {

• int id;
• int usecount;
• struct ti_psc *psc;
• struct ti_pd *pd;
• struct ti_lpsc *depend;

+};

+struct ti_dev {

• struct ti_lpsc *lpsc;
• int id;

+};

+/**

• • struct ti_k3_pd_platdata - pm domain controller information structure
• */

+struct ti_k3_pd_platdata {

• struct ti_psc *psc;
• struct ti_pd *pd;
• struct ti_lpsc *lpsc;
• struct ti_dev *devs;
• int num_psc;
• int num_pd;
• int num_lpsc;
• int num_devs;

+};

+#define PSC(_id, _base) { .id = _id, .base = (void *)_base, } +#define PSC_PD(_id, _psc, _depend) { .id = _id, .psc = _psc, .depend = _depend } +#define PSC_LPSC(_id, _psc, _pd, _depend) { .id = _id, .psc = _psc, .pd = _pd, .depend = _depend } +#define PSC_DEV(_id, _lpsc) { .id = _id, .lpsc = _lpsc }

+extern const struct ti_k3_pd_platdata j721e_pd_platdata; +extern const struct ti_k3_pd_platdata j7200_pd_platdata;

+#endif