soc: ti: add initial PRM driver with reset control support

Add initial PRM (Power and Reset Management) driver for TI OMAP class
SoCs. Initially this driver only supports reset control, but can be
extended to support rest of the functionality, like powerdomain
control, PRCM irq support etc.

Signed-off-by: Tero Kristo <t-kristo@ti.com>
Reviewed-by: Philipp Zabel <p.zabel@pengutronix.de>
Reviewed-by: Tony Lindgren <tony@atomide.com>
Signed-off-by: Santosh Shilimkar <santosh.shilimkar@oracle.com>

diff --git a/arch/arm/mach-omap2/Kconfig b/arch/arm/mach-omap2/Kconfig
index fdb6743760a2ef90e36ee3c3787176791e535fc7..ad08d470a2cac3f9f767844e0857a371ecb7bdf9 100644 (file)
--- a/arch/arm/mach-omap2/Kconfig
+++ b/arch/arm/mach-omap2/Kconfig
@@ -109,6 +109,7 @@ config ARCH_OMAP2PLUS
        select TI_SYSC
        select OMAP_IRQCHIP
        select CLKSRC_TI_32K
+       select ARCH_HAS_RESET_CONTROLLER
        help
          Systems based on OMAP2, OMAP3, OMAP4 or OMAP5
 

diff --git a/drivers/soc/ti/Makefile b/drivers/soc/ti/Makefile
index b3868d392d4fdf8e7a600a32197d01c3e9744809..788b5cd1e18008d15610b6119cb19e4a76e09e2d 100644 (file)
--- a/drivers/soc/ti/Makefile
+++ b/drivers/soc/ti/Makefile
@@ -6,6 +6,7 @@ obj-$(CONFIG_KEYSTONE_NAVIGATOR_QMSS)   += knav_qmss.o
 knav_qmss-y := knav_qmss_queue.o knav_qmss_acc.o
 obj-$(CONFIG_KEYSTONE_NAVIGATOR_DMA)   += knav_dma.o
 obj-$(CONFIG_AMX3_PM)                  += pm33xx.o
+obj-$(CONFIG_ARCH_OMAP2PLUS)           += omap_prm.o
 obj-$(CONFIG_WKUP_M3_IPC)              += wkup_m3_ipc.o
 obj-$(CONFIG_TI_SCI_PM_DOMAINS)                += ti_sci_pm_domains.o
 obj-$(CONFIG_TI_SCI_INTA_MSI_DOMAIN)   += ti_sci_inta_msi.o

diff --git a/drivers/soc/ti/omap_prm.c b/drivers/soc/ti/omap_prm.c
new file mode 100644 (file)
index 0000000..d171e96
--- /dev/null
+++ b/drivers/soc/ti/omap_prm.c
@@ -0,0 +1,258 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * OMAP2+ PRM driver
+ *
+ * Copyright (C) 2019 Texas Instruments Incorporated - http://www.ti.com/
+ *     Tero Kristo <t-kristo@ti.com>
+ */
+
+#include <linux/kernel.h>
+#include <linux/device.h>
+#include <linux/io.h>
+#include <linux/iopoll.h>
+#include <linux/of.h>
+#include <linux/of_device.h>
+#include <linux/platform_device.h>
+#include <linux/reset-controller.h>
+#include <linux/delay.h>
+
+struct omap_rst_map {
+       s8 rst;
+       s8 st;
+};
+
+struct omap_prm_data {
+       u32 base;
+       const char *name;
+       u16 rstctrl;
+       u16 rstst;
+       const struct omap_rst_map *rstmap;
+       u8 flags;
+};
+
+struct omap_prm {
+       const struct omap_prm_data *data;
+       void __iomem *base;
+};
+
+struct omap_reset_data {
+       struct reset_controller_dev rcdev;
+       struct omap_prm *prm;
+       u32 mask;
+       spinlock_t lock;
+};
+
+#define to_omap_reset_data(p) container_of((p), struct omap_reset_data, rcdev)
+
+#define OMAP_MAX_RESETS                8
+#define OMAP_RESET_MAX_WAIT    10000
+
+#define OMAP_PRM_HAS_RSTCTRL   BIT(0)
+#define OMAP_PRM_HAS_RSTST     BIT(1)
+
+#define OMAP_PRM_HAS_RESETS    (OMAP_PRM_HAS_RSTCTRL | OMAP_PRM_HAS_RSTST)
+
+static const struct of_device_id omap_prm_id_table[] = {
+       { },
+};
+
+static bool _is_valid_reset(struct omap_reset_data *reset, unsigned long id)
+{
+       if (reset->mask & BIT(id))
+               return true;
+
+       return false;
+}
+
+static int omap_reset_get_st_bit(struct omap_reset_data *reset,
+                                unsigned long id)
+{
+       const struct omap_rst_map *map = reset->prm->data->rstmap;
+
+       while (map->rst >= 0) {
+               if (map->rst == id)
+                       return map->st;
+
+               map++;
+       }
+
+       return id;
+}
+
+static int omap_reset_status(struct reset_controller_dev *rcdev,
+                            unsigned long id)
+{
+       struct omap_reset_data *reset = to_omap_reset_data(rcdev);
+       u32 v;
+       int st_bit = omap_reset_get_st_bit(reset, id);
+       bool has_rstst = reset->prm->data->rstst ||
+               (reset->prm->data->flags & OMAP_PRM_HAS_RSTST);
+
+       /* Check if we have rstst */
+       if (!has_rstst)
+               return -ENOTSUPP;
+
+       /* Check if hw reset line is asserted */
+       v = readl_relaxed(reset->prm->base + reset->prm->data->rstctrl);
+       if (v & BIT(id))
+               return 1;
+
+       /*
+        * Check reset status, high value means reset sequence has been
+        * completed successfully so we can return 0 here (reset deasserted)
+        */
+       v = readl_relaxed(reset->prm->base + reset->prm->data->rstst);
+       v >>= st_bit;
+       v &= 1;
+
+       return !v;
+}
+
+static int omap_reset_assert(struct reset_controller_dev *rcdev,
+                            unsigned long id)
+{
+       struct omap_reset_data *reset = to_omap_reset_data(rcdev);
+       u32 v;
+       unsigned long flags;
+
+       /* assert the reset control line */
+       spin_lock_irqsave(&reset->lock, flags);
+       v = readl_relaxed(reset->prm->base + reset->prm->data->rstctrl);
+       v |= 1 << id;
+       writel_relaxed(v, reset->prm->base + reset->prm->data->rstctrl);
+       spin_unlock_irqrestore(&reset->lock, flags);
+
+       return 0;
+}
+
+static int omap_reset_deassert(struct reset_controller_dev *rcdev,
+                              unsigned long id)
+{
+       struct omap_reset_data *reset = to_omap_reset_data(rcdev);
+       u32 v;
+       int st_bit;
+       bool has_rstst;
+       unsigned long flags;
+
+       has_rstst = reset->prm->data->rstst ||
+               (reset->prm->data->flags & OMAP_PRM_HAS_RSTST);
+
+       if (has_rstst) {
+               st_bit = omap_reset_get_st_bit(reset, id);
+
+               /* Clear the reset status by writing 1 to the status bit */
+               v = 1 << st_bit;
+               writel_relaxed(v, reset->prm->base + reset->prm->data->rstst);
+       }
+
+       /* de-assert the reset control line */
+       spin_lock_irqsave(&reset->lock, flags);
+       v = readl_relaxed(reset->prm->base + reset->prm->data->rstctrl);
+       v &= ~(1 << id);
+       writel_relaxed(v, reset->prm->base + reset->prm->data->rstctrl);
+       spin_unlock_irqrestore(&reset->lock, flags);
+
+       return 0;
+}
+
+static const struct reset_control_ops omap_reset_ops = {
+       .assert         = omap_reset_assert,
+       .deassert       = omap_reset_deassert,
+       .status         = omap_reset_status,
+};
+
+static int omap_prm_reset_xlate(struct reset_controller_dev *rcdev,
+                               const struct of_phandle_args *reset_spec)
+{
+       struct omap_reset_data *reset = to_omap_reset_data(rcdev);
+
+       if (!_is_valid_reset(reset, reset_spec->args[0]))
+               return -EINVAL;
+
+       return reset_spec->args[0];
+}
+
+static int omap_prm_reset_init(struct platform_device *pdev,
+                              struct omap_prm *prm)
+{
+       struct omap_reset_data *reset;
+       const struct omap_rst_map *map;
+
+       /*
+        * Check if we have controllable resets. If either rstctrl is non-zero
+        * or OMAP_PRM_HAS_RSTCTRL flag is set, we have reset control register
+        * for the domain.
+        */
+       if (!prm->data->rstctrl && !(prm->data->flags & OMAP_PRM_HAS_RSTCTRL))
+               return 0;
+
+       map = prm->data->rstmap;
+       if (!map)
+               return -EINVAL;
+
+       reset = devm_kzalloc(&pdev->dev, sizeof(*reset), GFP_KERNEL);
+       if (!reset)
+               return -ENOMEM;
+
+       reset->rcdev.owner = THIS_MODULE;
+       reset->rcdev.ops = &omap_reset_ops;
+       reset->rcdev.of_node = pdev->dev.of_node;
+       reset->rcdev.nr_resets = OMAP_MAX_RESETS;
+       reset->rcdev.of_xlate = omap_prm_reset_xlate;
+       reset->rcdev.of_reset_n_cells = 1;
+       spin_lock_init(&reset->lock);
+
+       reset->prm = prm;
+
+       while (map->rst >= 0) {
+               reset->mask |= BIT(map->rst);
+               map++;
+       }
+
+       return devm_reset_controller_register(&pdev->dev, &reset->rcdev);
+}
+
+static int omap_prm_probe(struct platform_device *pdev)
+{
+       struct resource *res;
+       const struct omap_prm_data *data;
+       struct omap_prm *prm;
+       const struct of_device_id *match;
+
+       res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+       if (!res)
+               return -ENODEV;
+
+       match = of_match_device(omap_prm_id_table, &pdev->dev);
+       if (!match)
+               return -ENOTSUPP;
+
+       prm = devm_kzalloc(&pdev->dev, sizeof(*prm), GFP_KERNEL);
+       if (!prm)
+               return -ENOMEM;
+
+       data = match->data;
+
+       while (data->base != res->start) {
+               if (!data->base)
+                       return -EINVAL;
+               data++;
+       }
+
+       prm->data = data;
+
+       prm->base = devm_ioremap_resource(&pdev->dev, res);
+       if (!prm->base)
+               return -ENOMEM;
+
+       return omap_prm_reset_init(pdev, prm);
+}
+
+static struct platform_driver omap_prm_driver = {
+       .probe = omap_prm_probe,
+       .driver = {
+               .name           = KBUILD_MODNAME,
+               .of_match_table = omap_prm_id_table,
+       },
+};
+builtin_platform_driver(omap_prm_driver);