[RFC PATCH 0/1] Timer module support pre-requisite

[RFC PATCH 0/1] Timer module support pre-requisite

[Daniel Lezcano]

Converting the timer driver modules requires a particular care
because, depending on the platform, that may be not supported.

A previous study showed we are safe regarding how the module refcount
is held and if THIS_MODULE is set for the clockevent and the
clocksource when they are registered.

It won't be possible to unload a module if a clockevent is registered.

It will be possible to unload a module if only a clocksource is
registered and it is not the current one.

However platforms without architected timers may need the timer driver
to be initialized very early while others can be initialized later. The
former can not be a module and the init function receives a
device_node pointer, there is no device associated and devres is not
used. That results in a lot of rollbacking code where usually it is
where we find bug and resource leaks. The latter can be converted to a
module and uses a module_platform_driver(), thus the init function is
a probe function receiving a struct platform_device pointer parameter.

We end up with two approaches and duplicate code for the init
functions. This is not optimal (and ugly).

Finally, we have the driver having to be initialized very early on
some platforms and be built as a module on other platforms, resulting
on having two init functions co-existing in the same driver.

The proposed change provides what is needed to move to the same probe
function for early init, builtin and module timers.

Daniel Lezcano (1):
  clocksource/drivers/timer-probe: Create a platform_device before the
    framework is initialized

 drivers/clocksource/timer-probe.c | 63 ++++++++++++++++++++++++++++++-
 include/asm-generic/vmlinux.lds.h | 10 +++++
 include/linux/clocksource.h       | 21 +++++++++++
 3 files changed, 93 insertions(+), 1 deletion(-)

-- 
2.43.0

[RFC PATCH 1/1] clocksource/drivers/timer-probe: Create a platform_device before the framework is initialized

[Daniel Lezcano]

In the context of the time keeping and the timers, some platforms have
timers which need to be initialized very early. It is the case of the
ARM platform which do not have the architected timers.

The macro TIMER_OF_DECLARE adds an entry in the timer init functions
array at compile time and the function timer_probe is called from the
timer_init() function in kernel/time.c

This array contains a tuple with the init function and the compatible
string.

The init function has a device node pointer parameter.

The timer_probe() function browses the of nodes and find the ones
matching the compatible string given when using the TIMER_OF_DECLARE
macro. It then calls the init function with the device node as a
pointer.

But there are some platforms where there are multiple timers like the
ARM64 with the architected timers. Those are always initialized very
early and the other timers can be initialized later.

For this reason we find timer drivers with the platform_driver
version. Consequently their init functions are different, they
have a platform_device pointer parameter and rely on the devm_
function for rollbacking.

To summarize, we have:
 - TIMER_OF_DECLARE with init function prototype:
   int (*init)(struct device_node *np);

 - module_platform_driver (and variant) with the probe function
   prototype:
   int (*init)(struct platform_device *pdev);

The current situation with the timers is the following:

 - Two platforms can have the same timer hardware, hence the same
   driver but one without alternate timers and the other with multiple
   timers. For example, the Exynos platform has only the Exynos MCT on
   ARM but has the architeched timers in addition on the ARM64.

 - The timer drivers can be modules now which was not the case until
   recently. TIMER_OF_DECLARE do not allow the build as a module.

It results in duplicate init functions (one with rollback and one with
devm_) and different way to declare the driver (TIMER_OF_DECLARE and
module_platform_driver).

This proposed change is to unify the prototyping of the init functions
to receive a platform_device pointer as parameter. Consequently, it
will allow a smoother and nicer module conversion and a huge cleanup
of the init functions by removing all the rollback code from all the
timer drivers. It introduces a TIMER_PDEV_DECLARE() macro.

The platform drivers registered through TIMER_PDEV_DECLARE() are not
registered with the driver core. Instead, their probe function is
invoked directly during early init, as the full driver model is not
available at this stage.

If the early initialization is needed, then the macro usage will
result in a platform_device manually allocated and initialized with
the needed information for the probe function. Otherwise the
module_platform_driver can be used instead with the same probe
function without the timer_probe() usage like any other devices using
the driver model.

This mirrors the existing TIMER_OF_DECLARE() behavior while allowing
a unified probe interface and enabling the use of devm-managed
resources in timer drivers.

The plan is to have all timers to use TIMER_PDEV_DECLARE with all the
init functions cleanups and then remove the TIMER_OF_DECLARE macro.

Signed-off-by: Daniel Lezcano <daniel.lezcano@oss.qualcomm.com>
Cc: Hans de Goede <hansg@kernel.org>
Cc: Ilpo Järvinen <ilpo.jarvinen@linux.intel.com>
Cc: Bryan O'Donoghue <bryan.odonoghue@linaro.org>
Cc: Rob Herring <robh@kernel.org>
Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
---
 drivers/clocksource/timer-probe.c | 63 ++++++++++++++++++++++++++++++-
 include/asm-generic/vmlinux.lds.h | 10 +++++
 include/linux/clocksource.h       | 21 +++++++++++
 3 files changed, 93 insertions(+), 1 deletion(-)

diff --git a/drivers/clocksource/timer-probe.c b/drivers/clocksource/timer-probe.c
index b7860bc0db4b..f4705a78eee1 100644
--- a/drivers/clocksource/timer-probe.c
+++ b/drivers/clocksource/timer-probe.c
@@ -7,13 +7,14 @@
 #include <linux/init.h>
 #include <linux/of.h>
 #include <linux/clocksource.h>
+#include <linux/platform_device.h>
 
 extern struct of_device_id __timer_of_table[];
 
 static const struct of_device_id __timer_of_table_sentinel
 	__used __section("__timer_of_table_end");
 
-void __init timer_probe(void)
+static int __init timer_of_probe(void)
 {
 	struct device_node *np;
 	const struct of_device_id *match;
@@ -38,6 +39,66 @@ void __init timer_probe(void)
 		timers++;
 	}
 
+	return timers;
+}
+
+static int __init __timer_pdev_probe(struct platform_driver *drv)
+{
+	struct device_node *np;
+	struct platform_device *pdev;
+	const struct of_device_id *match;
+	unsigned int timers = 0;
+	int ret;
+
+	for_each_matching_node_and_match(np, drv->driver.of_match_table, &match) {
+		if (!of_device_is_available(np))
+			continue;
+
+		pdev = platform_device_alloc(of_node_full_name(np), -1);
+		if (!pdev)
+			continue;
+
+		ret = device_add_of_node(&pdev->dev, np);
+		if (ret) {
+			platform_device_put(pdev);
+			continue;
+		}
+
+		dev_set_name(&pdev->dev, pdev->name);
+
+		ret = drv->probe(pdev);
+		if (!ret) {
+			timers++;
+			continue;
+		}
+
+		if (ret != -EPROBE_DEFER)
+			pr_err("Failed to initialize '%pOF': %d\n", np, ret);
+
+		device_remove_of_node(&pdev->dev);
+
+		platform_device_put(pdev);
+	}
+
+	return timers;
+}
+
+static int __init timer_pdev_probe(void)
+{
+	struct platform_driver **drv;
+
+	for_each_pdev_timer_table(drv)
+		__timer_pdev_probe(*drv);
+
+	return 0;
+}
+
+void __init timer_probe(void)
+{
+	unsigned timers = 0;
+
+	timers += timer_of_probe();
+	timers += timer_pdev_probe();
 	timers += acpi_probe_device_table(timer);
 
 	if (!timers)
diff --git a/include/asm-generic/vmlinux.lds.h b/include/asm-generic/vmlinux.lds.h
index 60c8c22fd3e4..1efdac063560 100644
--- a/include/asm-generic/vmlinux.lds.h
+++ b/include/asm-generic/vmlinux.lds.h
@@ -359,6 +359,15 @@
 #define THERMAL_TABLE(name)
 #endif
 
+#ifdef CONFIG_TIMER_OF
+#define TIMER_TABLE(name)						\
+	. = ALIGN(8);							\
+	BOUNDED_SECTION_POST_LABEL(__##name##_timer_table,		\
+				   __##name##_timer_table,, _end)
+#else
+#define TIMER_TABLE(name)
+#endif
+
 #define KERNEL_DTB()							\
 	STRUCT_ALIGN();							\
 	__dtb_start = .;						\
@@ -731,6 +740,7 @@
 	ACPI_PROBE_TABLE(irqchip)					\
 	ACPI_PROBE_TABLE(timer)						\
 	THERMAL_TABLE(governor)						\
+	TIMER_TABLE(pdev)						\
 	EARLYCON_TABLE()						\
 	LSM_TABLE()							\
 	EARLY_LSM_TABLE()						\
diff --git a/include/linux/clocksource.h b/include/linux/clocksource.h
index 7c38190b10bf..b7595e589fd5 100644
--- a/include/linux/clocksource.h
+++ b/include/linux/clocksource.h
@@ -18,6 +18,7 @@
 #include <linux/init.h>
 #include <linux/of.h>
 #include <linux/clocksource_ids.h>
+#include <linux/platform_device.h>
 #include <asm/div64.h>
 #include <asm/io.h>
 
@@ -295,6 +296,26 @@ extern void timer_probe(void);
 static inline void timer_probe(void) {}
 #endif
 
+extern struct platform_driver *__pdev_timer_table[];
+extern struct platform_driver *__pdev_timer_table_end[];
+
+#define TIMER_PDEV_DECLARE(__name, __probe, __remove, __match)		\
+	static struct platform_driver __pdev_timer_table_entry_##__name = { \
+		.probe = __probe,					\
+		.remove = __remove,					\
+		.driver = {						\
+			.name = #__name,				\
+			.of_match_table = __match			\
+		},							\
+	};								\
+	static struct platform_driver *___pdev_timer_table_entry_##__name \
+	__used __section("__pdev_timer_table") = &__pdev_timer_table_entry_##__name
+
+#define for_each_pdev_timer_table(__pdev)     \
+	for (__pdev = __pdev_timer_table;     \
+	     __pdev < __pdev_timer_table_end; \
+	     __pdev++)
+
 #define TIMER_ACPI_DECLARE(name, table_id, fn)		\
 	ACPI_DECLARE_PROBE_ENTRY(timer, name, table_id, 0, NULL, 0, fn)
 
-- 
2.43.0