Received-SPF: pass (google.com: domain of linux-kernel+bounces-18025-linux.lists.archive=gmail.com@vger.kernel.org designates 139.178.88.99 as permitted sender) client-ip=139.178.88.99;
From: Krzysztof Kozlowski <krzysztof.kozlowski@linaro.org>
To: Srinivas Kandagatla <srinivas.kandagatla@linaro.org>,
	Banajit Goswami <bgoswami@quicinc.com>,
	Bjorn Andersson <andersson@kernel.org>,
	Konrad Dybcio <konrad.dybcio@linaro.org>,
	Liam Girdwood <lgirdwood@gmail.com>,
	Mark Brown <broonie@kernel.org>,
	Rob Herring <robh+dt@kernel.org>,
	Krzysztof Kozlowski <krzysztof.kozlowski+dt@linaro.org>,
	Conor Dooley <conor+dt@kernel.org>,
	Philipp Zabel <p.zabel@pengutronix.de>,
	Jaroslav Kysela <perex@perex.cz>,
	Takashi Iwai <tiwai@suse.com>,
	alsa-devel@alsa-project.org,
	linux-arm-msm@vger.kernel.org,
	linux-sound@vger.kernel.org,
	devicetree@vger.kernel.org,
	linux-kernel@vger.kernel.org
Cc: Krzysztof Kozlowski <krzysztof.kozlowski@linaro.org>,
	Bartosz Golaszewski <brgl@bgdev.pl>,
	Sean Anderson <sean.anderson@seco.com>
Subject: [PATCH v2 2/4] reset: Instantiate reset GPIO controller for shared reset-gpios
Date: Fri,  5 Jan 2024 16:59:16 +0100
Message-Id: <20240105155918.279657-3-krzysztof.kozlowski@linaro.org>
In-Reply-To: <20240105155918.279657-1-krzysztof.kozlowski@linaro.org>
References: <20240105155918.279657-1-krzysztof.kozlowski@linaro.org>
Precedence: bulk
MIME-Version: 1.0
Content-Transfer-Encoding: 8bit

Devices sharing a reset GPIO could use the reset framework for
coordinated handling of that shared GPIO line.  We have several cases of
such needs, at least for Devicetree-based platforms.

If Devicetree-based device requests a reset line, which is missing but
there is a reset-gpios property, instantiate a new "reset-gpio" platform
device which will handle such reset line.  This allows seamless handling
of such shared reset-gpios without need of changing Devicetree binding [1].

All newly registered "reset-gpio" platform devices will be stored on
their own list to avoid any duplicated devices.  The key to find each of
such platform device is the entire Devicetree GPIO specifier: phandle to
GPIO controller, GPIO number and GPIO flags.  If two devices have
conflicting "reset-gpios" property, e.g. with different ACTIVE_xxx
flags, this would spawn two separate "reset-gpio" devices, where the
second would fail probing on busy GPIO reques

Link: https://lore.kernel.org/all/YXi5CUCEi7YmNxXM@robh.at.kernel.org/ [1]
Cc: Bartosz Golaszewski <brgl@bgdev.pl>
Cc: Sean Anderson <sean.anderson@seco.com>
Signed-off-by: Krzysztof Kozlowski <krzysztof.kozlowski@linaro.org>
---
 drivers/reset/core.c             | 176 ++++++++++++++++++++++++++++---
 include/linux/reset-controller.h |   4 +
 2 files changed, 167 insertions(+), 13 deletions(-)

diff --git a/drivers/reset/core.c b/drivers/reset/core.c
index 4d5a78d3c085..ec9b3ff419cf 100644
--- a/drivers/reset/core.c
+++ b/drivers/reset/core.c
@@ -13,6 +13,7 @@
 #include <linux/module.h>
 #include <linux/of.h>
 #include <linux/acpi.h>
+#include <linux/platform_device.h>
 #include <linux/reset.h>
 #include <linux/reset-controller.h>
 #include <linux/slab.h>
@@ -23,6 +24,10 @@ static LIST_HEAD(reset_controller_list);
 static DEFINE_MUTEX(reset_lookup_mutex);
 static LIST_HEAD(reset_lookup_list);
 
+/* Protects reset_gpio_device_list */
+static DEFINE_MUTEX(reset_gpio_device_mutex);
+static LIST_HEAD(reset_gpio_device_list);
+
 /**
  * struct reset_control - a reset control
  * @rcdev: a pointer to the reset controller device
@@ -63,6 +68,16 @@ struct reset_control_array {
 	struct reset_control *rstc[] __counted_by(num_rstcs);
 };
 
+/**
+ * struct reset_gpio_device - ad-hoc created reset-gpio device
+ * @of_args: phandle to the reset controller with all the args like GPIO number
+ * @list: list entry for the reset_lookup_list
+ */
+struct reset_gpio_device {
+	struct of_phandle_args of_args;
+	struct list_head list;
+};
+
 static const char *rcdev_name(struct reset_controller_dev *rcdev)
 {
 	if (rcdev->dev)
@@ -813,13 +828,119 @@ static void __reset_control_put_internal(struct reset_control *rstc)
 	kref_put(&rstc->refcnt, __reset_control_release);
 }
 
+static bool __reset_gpios_args_match(const struct of_phandle_args *a1,
+				     const struct of_phandle_args *a2)
+{
+	unsigned int i;
+
+	if (!a2)
+		return false;
+
+	if (a1->args_count != a2->args_count)
+		return false;
+
+	for (i = 0; i < a1->args_count; i++)
+		if (a1->args[i] != a2->args[i])
+			break;
+
+	/* All args matched? */
+	if (i == a1->args_count)
+		return true;
+
+	return false;
+}
+
+/*
+ * @node:	node of the device requesting reset
+ * @reset_args:	phandle to the reset controller with all the args like GPIO number
+ */
+static int __reset_add_reset_gpio_device(struct device_node *node,
+					 struct of_phandle_args *args)
+{
+	struct reset_gpio_device *rgpio_dev;
+	struct platform_device *pdev;
+	int ret;
+
+	lockdep_assert_not_held(&reset_list_mutex);
+
+	mutex_lock(&reset_gpio_device_mutex);
+
+	list_for_each_entry(rgpio_dev, &reset_gpio_device_list, list) {
+		if (args->np == rgpio_dev->of_args.np) {
+			if (__reset_gpios_args_match(args,
+						     &rgpio_dev->of_args)) {
+				ret = 0;
+				goto out_unlock;
+			}
+		}
+	}
+
+	/* Not freed in normal path, persisent subsyst data */
+	rgpio_dev = kzalloc(sizeof(*rgpio_dev), GFP_KERNEL);
+	if (!rgpio_dev) {
+		ret = -ENOMEM;
+		goto out_unlock;
+	}
+
+	rgpio_dev->of_args = *args;
+	pdev = platform_device_register_data(NULL, "reset-gpio",
+					     PLATFORM_DEVID_AUTO, &node,
+					     sizeof(node));
+	ret = PTR_ERR_OR_ZERO(pdev);
+	if (!ret)
+		list_add(&rgpio_dev->list, &reset_gpio_device_list);
+	else
+		kfree(rgpio_dev);
+
+out_unlock:
+	mutex_unlock(&reset_gpio_device_mutex);
+
+	return ret;
+}
+
+static struct reset_controller_dev *__reset_find_rcdev(struct of_phandle_args *args,
+						       bool gpio_fallback,
+						       const void *cookie)
+{
+	struct reset_controller_dev *r, *rcdev;
+
+	lockdep_assert_held(&reset_list_mutex);
+
+	rcdev = NULL;
+	list_for_each_entry(r, &reset_controller_list, list) {
+		if (args->np == r->of_node) {
+			if (gpio_fallback) {
+				if (__reset_gpios_args_match(args, r->of_args)) {
+					/*
+					 * Fake args (take first reset) and
+					 * args_count (to matcg reset-gpio
+					 * of_reset_n_cells) because reset-gpio
+					 * has only one reset and does not care
+					 * about reset of GPIO specifier.
+					 */
+					args->args[0] = 0;
+					args->args_count = 1;
+					rcdev = r;
+					break;
+				}
+			} else {
+				rcdev = r;
+				break;
+			}
+		}
+	}
+
+	return rcdev;
+}
+
 struct reset_control *
 __of_reset_control_get(struct device_node *node, const char *id, int index,
 		       bool shared, bool optional, bool acquired)
 {
+	struct of_phandle_args args = {0};
+	bool gpio_fallback = false;
 	struct reset_control *rstc;
-	struct reset_controller_dev *r, *rcdev;
-	struct of_phandle_args args;
+	struct reset_controller_dev *rcdev;
 	int rstc_id;
 	int ret;
 
@@ -839,21 +960,50 @@ __of_reset_control_get(struct device_node *node, const char *id, int index,
 					 index, &args);
 	if (ret == -EINVAL)
 		return ERR_PTR(ret);
-	if (ret)
-		return optional ? NULL : ERR_PTR(ret);
+	if (ret) {
+		/*
+		 * There can be only one reset-gpio for regular devices, so
+		 * don't bother with GPIO index.
+		 */
+		ret = of_parse_phandle_with_args(node, "reset-gpios", "#gpio-cells",
+						 0, &args);
+		if (ret)
+			return optional ? NULL : ERR_PTR(ret);
 
-	mutex_lock(&reset_list_mutex);
-	rcdev = NULL;
-	list_for_each_entry(r, &reset_controller_list, list) {
-		if (args.np == r->of_node) {
-			rcdev = r;
-			break;
-		}
+		gpio_fallback = true;
 	}
 
+	mutex_lock(&reset_list_mutex);
+	rcdev = __reset_find_rcdev(&args, gpio_fallback, NULL);
+
 	if (!rcdev) {
-		rstc = ERR_PTR(-EPROBE_DEFER);
-		goto out;
+		if (gpio_fallback) {
+			/*
+			 * Registering reset-gpio device might cause immediate
+			 * bind, thus taking reset_list_mutex lock via
+			 * reset_controller_register().
+			 */
+			mutex_unlock(&reset_list_mutex);
+			ret = __reset_add_reset_gpio_device(node, &args);
+			mutex_lock(&reset_list_mutex);
+			if (ret) {
+				rstc = ERR_PTR(ret);
+				goto out;
+			}
+			/*
+			 * Success: reset-gpio could probe immediately, so
+			 * re-check the lookup.
+			 */
+			rcdev = __reset_find_rcdev(&args, gpio_fallback, NULL);
+			if (!rcdev) {
+				rstc = ERR_PTR(-EPROBE_DEFER);
+				goto out;
+			}
+			/* Success, rcdev is valid thus do not bail out */
+		} else {
+			rstc = ERR_PTR(-EPROBE_DEFER);
+			goto out;
+		}
 	}
 
 	if (WARN_ON(args.args_count != rcdev->of_reset_n_cells)) {
diff --git a/include/linux/reset-controller.h b/include/linux/reset-controller.h
index 0fa4f60e1186..e064473215de 100644
--- a/include/linux/reset-controller.h
+++ b/include/linux/reset-controller.h
@@ -61,6 +61,9 @@ struct reset_control_lookup {
  * @dev: corresponding driver model device struct
  * @of_node: corresponding device tree node as phandle target
  * @of_reset_n_cells: number of cells in reset line specifiers
+ * TODO: of_args have of_node, so we have here duplication
+ * @of_args: for reset-gpios controllers: corresponding phandle args with GPIO
+ *           number complementing of_node
  * @of_xlate: translation function to translate from specifier as found in the
  *            device tree to id as given to the reset control ops, defaults
  *            to :c:func:`of_reset_simple_xlate`.
@@ -74,6 +77,7 @@ struct reset_controller_dev {
 	struct device *dev;
 	struct device_node *of_node;
 	int of_reset_n_cells;
+	const struct of_phandle_args *of_args;
 	int (*of_xlate)(struct reset_controller_dev *rcdev,
 			const struct of_phandle_args *reset_spec);
 	unsigned int nr_resets;
-- 
2.34.1