Merge tag 'reset-for-4.17-2' of git://git.pengutronix.de/git/pza/linux into next/drivers

Pull "Reset controller changes for v4.17, part 2" from Philipp Zabel:

This tag contains reset lookup support, similar to pwm lookups, for legacy
non-DT platforms, a few new reset controls and a Kconfig fix for uniphier
SoCs, as well as a new driver for the STM32MP1 peripheral reset controller.

The reset lookups are merged from a separate, immutable branch, that may
also be merged into the davinci tree.

* tag 'reset-for-4.17-2' of git://git.pengutronix.de/git/pza/linux:
  reset: uniphier: add ethernet reset control support for PXs3
  reset: stm32mp1: Enable stm32mp1 reset driver
  dt-bindings: reset: add STM32MP1 resets
  reset: uniphier: add Pro4/Pro5/PXs2 audio systems reset control
  reset: imx7: add 'depends on HAS_IOMEM' to fix unmet dependency
  reset: modify the way reset lookup works for board files
  reset: add support for non-DT systems

5 files changed, 223 insertions, 1 deletions

diff --git a/drivers/reset/Kconfig b/drivers/reset/Kconfig
index 18f152d251d7..c0b292be1b72 100644
--- a/drivers/reset/Kconfig
+++ b/drivers/reset/Kconfig
@@ -49,6 +49,7 @@ config RESET_HSDK
 
 config RESET_IMX7
         bool "i.MX7 Reset Driver" if COMPILE_TEST
+        depends on HAS_IOMEM
         default SOC_IMX7D
         select MFD_SYSCON
         help
@@ -96,6 +97,12 @@ config RESET_SIMPLE
            - Allwinner SoCs
            - ZTE's zx2967 family
 
+config RESET_STM32MP157
+        bool "STM32MP157 Reset Driver" if COMPILE_TEST
+        default MACH_STM32MP157
+        help
+          This enables the RCC reset controller driver for STM32 MPUs.
+
 config RESET_SUNXI
         bool "Allwinner SoCs Reset Driver" if COMPILE_TEST && !ARCH_SUNXI
         default ARCH_SUNXI
diff --git a/drivers/reset/Makefile b/drivers/reset/Makefile
index 132c24f5ddb5..c1261dcfe9ad 100644
--- a/drivers/reset/Makefile
+++ b/drivers/reset/Makefile
@@ -15,6 +15,7 @@ obj-$(CONFIG_RESET_MESON) += reset-meson.o
 obj-$(CONFIG_RESET_OXNAS) += reset-oxnas.o
 obj-$(CONFIG_RESET_PISTACHIO) += reset-pistachio.o
 obj-$(CONFIG_RESET_SIMPLE) += reset-simple.o
+obj-$(CONFIG_RESET_STM32MP157) += reset-stm32mp1.o
 obj-$(CONFIG_RESET_SUNXI) += reset-sunxi.o
 obj-$(CONFIG_RESET_TI_SCI) += reset-ti-sci.o
 obj-$(CONFIG_RESET_TI_SYSCON) += reset-ti-syscon.o
diff --git a/drivers/reset/core.c b/drivers/reset/core.c
index da4292e9de97..6488292e129c 100644
--- a/drivers/reset/core.c
+++ b/drivers/reset/core.c
@@ -23,6 +23,9 @@
 static DEFINE_MUTEX(reset_list_mutex);
 static LIST_HEAD(reset_controller_list);
 
+static DEFINE_MUTEX(reset_lookup_mutex);
+static LIST_HEAD(reset_lookup_list);
+
 /**
  * struct reset_control - a reset control
  * @rcdev: a pointer to the reset controller device
@@ -148,6 +151,33 @@ int devm_reset_controller_register(struct device *dev,
 }
 EXPORT_SYMBOL_GPL(devm_reset_controller_register);
 
+/**
+ * reset_controller_add_lookup - register a set of lookup entries
+ * @lookup: array of reset lookup entries
+ * @num_entries: number of entries in the lookup array
+ */
+void reset_controller_add_lookup(struct reset_control_lookup *lookup,
+                                 unsigned int num_entries)
+{
+        struct reset_control_lookup *entry;
+        unsigned int i;
+
+        mutex_lock(&reset_lookup_mutex);
+        for (i = 0; i < num_entries; i++) {
+                entry = &lookup[i];
+
+                if (!entry->dev_id || !entry->provider) {
+                        pr_warn("%s(): reset lookup entry badly specified, skipping\n",
+                                __func__);
+                        continue;
+                }
+
+                list_add_tail(&entry->list, &reset_lookup_list);
+        }
+        mutex_unlock(&reset_lookup_mutex);
+}
+EXPORT_SYMBOL_GPL(reset_controller_add_lookup);
+
 static inline struct reset_control_array *
 rstc_to_array(struct reset_control *rstc) {
         return container_of(rstc, struct reset_control_array, base);
@@ -493,6 +523,70 @@ struct reset_control *__of_reset_control_get(struct device_node *node,
 }
 EXPORT_SYMBOL_GPL(__of_reset_control_get);
 
+static struct reset_controller_dev *
+__reset_controller_by_name(const char *name)
+{
+        struct reset_controller_dev *rcdev;
+
+        lockdep_assert_held(&reset_list_mutex);
+
+        list_for_each_entry(rcdev, &reset_controller_list, list) {
+                if (!rcdev->dev)
+                        continue;
+
+                if (!strcmp(name, dev_name(rcdev->dev)))
+                        return rcdev;
+        }
+
+        return NULL;
+}
+
+static struct reset_control *
+__reset_control_get_from_lookup(struct device *dev, const char *con_id,
+                                bool shared, bool optional)
+{
+        const struct reset_control_lookup *lookup;
+        struct reset_controller_dev *rcdev;
+        const char *dev_id = dev_name(dev);
+        struct reset_control *rstc = NULL;
+
+        if (!dev)
+                return ERR_PTR(-EINVAL);
+
+        mutex_lock(&reset_lookup_mutex);
+
+        list_for_each_entry(lookup, &reset_lookup_list, list) {
+                if (strcmp(lookup->dev_id, dev_id))
+                        continue;
+
+                if ((!con_id && !lookup->con_id) ||
+                    ((con_id && lookup->con_id) &&
+                     !strcmp(con_id, lookup->con_id))) {
+                        mutex_lock(&reset_list_mutex);
+                        rcdev = __reset_controller_by_name(lookup->provider);
+                        if (!rcdev) {
+                                mutex_unlock(&reset_list_mutex);
+                                mutex_unlock(&reset_lookup_mutex);
+                                /* Reset provider may not be ready yet. */
+                                return ERR_PTR(-EPROBE_DEFER);
+                        }
+
+                        rstc = __reset_control_get_internal(rcdev,
+                                                            lookup->index,
+                                                            shared);
+                        mutex_unlock(&reset_list_mutex);
+                        break;
+                }
+        }
+
+        mutex_unlock(&reset_lookup_mutex);
+
+        if (!rstc)
+                return optional ? NULL : ERR_PTR(-ENOENT);
+
+        return rstc;
+}
+
 struct reset_control *__reset_control_get(struct device *dev, const char *id,
                                           int index, bool shared, bool optional)
 {
@@ -500,7 +594,7 @@ struct reset_control *__reset_control_get(struct device *dev, const char *id,
                 return __of_reset_control_get(dev->of_node, id, index, shared,
                                               optional);
 
-        return optional ? NULL : ERR_PTR(-EINVAL);
+        return __reset_control_get_from_lookup(dev, id, shared, optional);
 }
 EXPORT_SYMBOL_GPL(__reset_control_get);
 
diff --git a/drivers/reset/reset-stm32mp1.c b/drivers/reset/reset-stm32mp1.c
new file mode 100644
index 000000000000..b221a28041fa
--- /dev/null
+++ b/drivers/reset/reset-stm32mp1.c
@@ -0,0 +1,115 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (C) STMicroelectronics 2018 - All Rights Reserved
+ * Author: Gabriel Fernandez <gabriel.fernandez@st.com> for STMicroelectronics.
+ */
+
+#include <linux/device.h>
+#include <linux/err.h>
+#include <linux/io.h>
+#include <linux/of.h>
+#include <linux/platform_device.h>
+#include <linux/reset-controller.h>
+
+#define CLR_OFFSET 0x4
+
+struct stm32_reset_data {
+        struct reset_controller_dev     rcdev;
+        void __iomem                    *membase;
+};
+
+static inline struct stm32_reset_data *
+to_stm32_reset_data(struct reset_controller_dev *rcdev)
+{
+        return container_of(rcdev, struct stm32_reset_data, rcdev);
+}
+
+static int stm32_reset_update(struct reset_controller_dev *rcdev,
+                              unsigned long id, bool assert)
+{
+        struct stm32_reset_data *data = to_stm32_reset_data(rcdev);
+        int reg_width = sizeof(u32);
+        int bank = id / (reg_width * BITS_PER_BYTE);
+        int offset = id % (reg_width * BITS_PER_BYTE);
+        void __iomem *addr;
+
+        addr = data->membase + (bank * reg_width);
+        if (!assert)
+                addr += CLR_OFFSET;
+
+        writel(BIT(offset), addr);
+
+        return 0;
+}
+
+static int stm32_reset_assert(struct reset_controller_dev *rcdev,
+                              unsigned long id)
+{
+        return stm32_reset_update(rcdev, id, true);
+}
+
+static int stm32_reset_deassert(struct reset_controller_dev *rcdev,
+                                unsigned long id)
+{
+        return stm32_reset_update(rcdev, id, false);
+}
+
+static int stm32_reset_status(struct reset_controller_dev *rcdev,
+                              unsigned long id)
+{
+        struct stm32_reset_data *data = to_stm32_reset_data(rcdev);
+        int reg_width = sizeof(u32);
+        int bank = id / (reg_width * BITS_PER_BYTE);
+        int offset = id % (reg_width * BITS_PER_BYTE);
+        u32 reg;
+
+        reg = readl(data->membase + (bank * reg_width));
+
+        return !!(reg & BIT(offset));
+}
+
+static const struct reset_control_ops stm32_reset_ops = {
+        .assert         = stm32_reset_assert,
+        .deassert       = stm32_reset_deassert,
+        .status         = stm32_reset_status,
+};
+
+static const struct of_device_id stm32_reset_dt_ids[] = {
+        { .compatible = "st,stm32mp1-rcc"},
+        { /* sentinel */ },
+};
+
+static int stm32_reset_probe(struct platform_device *pdev)
+{
+        struct device *dev = &pdev->dev;
+        struct stm32_reset_data *data;
+        void __iomem *membase;
+        struct resource *res;
+
+        data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
+        if (!data)
+                return -ENOMEM;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        membase = devm_ioremap_resource(dev, res);
+        if (IS_ERR(membase))
+                return PTR_ERR(membase);
+
+        data->membase = membase;
+        data->rcdev.owner = THIS_MODULE;
+        data->rcdev.nr_resets = resource_size(res) * BITS_PER_BYTE;
+        data->rcdev.ops = &stm32_reset_ops;
+        data->rcdev.of_node = dev->of_node;
+
+        return devm_reset_controller_register(dev, &data->rcdev);
+}
+
+static struct platform_driver stm32_reset_driver = {
+        .probe  = stm32_reset_probe,
+        .driver = {
+                .name           = "stm32mp1-reset",
+                .of_match_table = stm32_reset_dt_ids,
+        },
+};
+
+builtin_platform_driver(stm32_reset_driver);
diff --git a/drivers/reset/reset-uniphier.c b/drivers/reset/reset-uniphier.c
index e8bb023ff15e..360e06b20c53 100644
--- a/drivers/reset/reset-uniphier.c
+++ b/drivers/reset/reset-uniphier.c
@@ -63,6 +63,7 @@ static const struct uniphier_reset_data uniphier_pro4_sys_reset_data[] = {
         UNIPHIER_RESETX(12, 0x2000, 6),         /* GIO (Ether, SATA, USB3) */
         UNIPHIER_RESETX(14, 0x2000, 17),        /* USB30 */
         UNIPHIER_RESETX(15, 0x2004, 17),        /* USB31 */
+        UNIPHIER_RESETX(40, 0x2000, 13),        /* AIO */
         UNIPHIER_RESET_END,
 };
 
@@ -72,6 +73,7 @@ static const struct uniphier_reset_data uniphier_pro5_sys_reset_data[] = {
         UNIPHIER_RESETX(12, 0x2000, 6),         /* GIO (PCIe, USB3) */
         UNIPHIER_RESETX(14, 0x2000, 17),        /* USB30 */
         UNIPHIER_RESETX(15, 0x2004, 17),        /* USB31 */
+        UNIPHIER_RESETX(40, 0x2000, 13),        /* AIO */
         UNIPHIER_RESET_END,
 };
 
@@ -88,6 +90,7 @@ static const struct uniphier_reset_data uniphier_pxs2_sys_reset_data[] = {
         UNIPHIER_RESETX(21, 0x2014, 1),         /* USB31-PHY1 */
         UNIPHIER_RESETX(28, 0x2014, 12),        /* SATA */
         UNIPHIER_RESET(29, 0x2014, 8),          /* SATA-PHY (active high) */
+        UNIPHIER_RESETX(40, 0x2000, 13),        /* AIO */
         UNIPHIER_RESET_END,
 };
 
@@ -121,6 +124,8 @@ static const struct uniphier_reset_data uniphier_ld20_sys_reset_data[] = {
 static const struct uniphier_reset_data uniphier_pxs3_sys_reset_data[] = {
         UNIPHIER_RESETX(2, 0x200c, 0),          /* NAND */
         UNIPHIER_RESETX(4, 0x200c, 2),          /* eMMC */
+        UNIPHIER_RESETX(6, 0x200c, 9),          /* Ether0 */
+        UNIPHIER_RESETX(7, 0x200c, 10),         /* Ether1 */
         UNIPHIER_RESETX(8, 0x200c, 12),         /* STDMAC */
         UNIPHIER_RESETX(12, 0x200c, 4),         /* USB30 link (GIO0) */
         UNIPHIER_RESETX(13, 0x200c, 5),         /* USB31 link (GIO1) */