[PATCH 0/7] treewide: misc helpers for porting

[PATCH 0/7] treewide: misc helpers for porting

[Ahmad Fatoum]

These patches resulted from yak shaving around the upcoming
sync of the Atmel NAND driver.

Ahmad Fatoum (7):
  vsprintf: support %pOF format specifier
  include: driver: make dev_(get_priv|is_probed) argument const pointer
  include: sync io-64-nonatomic-*.h headers with Linux
  clk: add prepare/unprepare helpers
  of: provide of_node_get and of_node_put stubs
  include: linux/slab.h: define krealloc/kstrdup
  barebox-wrapper: define MODULE_DEVICE_TABLE

 include/driver.h                |  4 +-
 include/io-64-nonatomic-hi-lo.h | 90 +++++++++++++++++++++++++++++++++
 include/io-64-nonatomic-lo-hi.h | 90 +++++++++++++++++++++++++++++++++
 include/linux/barebox-wrapper.h |  1 +
 include/linux/clk.h             |  2 +
 include/linux/slab.h            | 13 +++++
 include/of.h                    | 15 ++++++
 lib/vsprintf.c                  | 13 +++++
 8 files changed, 226 insertions(+), 2 deletions(-)

-- 
2.30.2

[PATCH 1/7] vsprintf: support %pOF format specifier

[Ahmad Fatoum]

Supporting %pO* is easy enough and we have at least 50 instances in
tree, where this can be used.

Signed-off-by: Ahmad Fatoum <a.fatoum@pengutronix.de>
---
 include/of.h   | 10 ++++++++++
 lib/vsprintf.c | 13 +++++++++++++
 2 files changed, 23 insertions(+)

diff --git a/include/of.h b/include/of.h
index c69fa9605415..f22730c081fe 100644
--- a/include/of.h
+++ b/include/of.h
@@ -332,6 +332,11 @@ int of_autoenable_device_by_path(char *path);
 int of_autoenable_i2c_by_component(char *path);
 int of_prepend_machine_compatible(struct device_node *root, const char *compat);
 
+static inline const char *of_node_full_name(const struct device_node *np)
+{
+	return np ? np->full_name : "<no-node>";
+}
+
 #else
 static inline struct of_reserve_map *of_get_reserve_map(void)
 {
@@ -893,6 +898,11 @@ static inline int of_prepend_machine_compatible(struct device_node *root,
 	return -ENODEV;
 }
 
+static inline const char *of_node_full_name(const struct device_node *np)
+{
+	return "<no-node>";
+}
+
 #endif
 
 #define for_each_property_of_node(dn, pp) \
diff --git a/lib/vsprintf.c b/lib/vsprintf.c
index 693f3c0cc0c8..1291cf7dd95f 100644
--- a/lib/vsprintf.c
+++ b/lib/vsprintf.c
@@ -19,6 +19,7 @@
 #include <malloc.h>
 #include <kallsyms.h>
 #include <wchar.h>
+#include <of.h>
 
 #include <common.h>
 #include <pbl.h>
@@ -391,6 +392,14 @@ char *address_val(char *buf, const char *end, const void *addr,
 	return number(buf, end, num, 16, field_width, precision, flags);
 }
 
+static noinline_for_stack
+char *device_node_string(char *buf, const char *end, const struct device_node *np,
+			 int field_width, int precision, int flags, const char *fmt)
+{
+	return string(buf, end, of_node_full_name(np), field_width,
+		      precision, flags);
+}
+
 /*
  * Show a '%p' thing.  A kernel extension is that the '%p' is followed
  * by an extra set of alphanumeric characters that are extended format
@@ -454,6 +463,10 @@ static char *pointer(const char *fmt, char *buf, const char *end, const void *pt
 		break;
 	case 'e':
 		return error_string(buf, end, ptr, field_width, precision, flags, fmt);
+	case 'O':
+		if (IS_ENABLED(CONFIG_OFTREE))
+			return device_node_string(buf, end, ptr, field_width, precision, flags, fmt + 1);
+		break;
 	case 'h':
 		if (IS_ENABLED(CONFIG_PRINTF_HEXSTR))
 			return hex_string(buf, end, ptr, field_width, precision, flags, fmt);
-- 
2.30.2

[PATCH 2/7] include: driver: make dev_(get_priv|is_probed) argument const pointer

[Ahmad Fatoum]

This enables us to use the helpers in functions that themselves take a
const pointer to document their usage.

Signed-off-by: Ahmad Fatoum <a.fatoum@pengutronix.de>
---
 include/driver.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/include/driver.h b/include/driver.h
index 0ea5799d0dfb..7b04d61d168a 100644
--- a/include/driver.h
+++ b/include/driver.h
@@ -627,12 +627,12 @@ static inline struct device_node *dev_of_node(struct device *dev)
 	return IS_ENABLED(CONFIG_OFDEVICE) ? dev->of_node : NULL;
 }
 
-static inline void *dev_get_priv(struct device *dev)
+static inline void *dev_get_priv(const struct device *dev)
 {
 	return dev->priv;
 }
 
-static inline bool dev_is_probed(struct device *dev)
+static inline bool dev_is_probed(const struct device *dev)
 {
 	return dev->driver ? true : false;
 }
-- 
2.30.2

[PATCH 3/7] include: sync io-64-nonatomic-*.h headers with Linux

[Ahmad Fatoum]

The Linux headers additionally define readq/writeq_relaxed,
io(read|write)64(be|le|), which may come in handy when porting code.

Signed-off-by: Ahmad Fatoum <a.fatoum@pengutronix.de>
---
 include/io-64-nonatomic-hi-lo.h | 90 +++++++++++++++++++++++++++++++++
 include/io-64-nonatomic-lo-hi.h | 90 +++++++++++++++++++++++++++++++++
 2 files changed, 180 insertions(+)

diff --git a/include/io-64-nonatomic-hi-lo.h b/include/io-64-nonatomic-hi-lo.h
index 3393e6317e36..bac2bc6a74b9 100644
--- a/include/io-64-nonatomic-hi-lo.h
+++ b/include/io-64-nonatomic-hi-lo.h
@@ -3,6 +3,7 @@
 #define _LINUX_IO_64_NONATOMIC_HI_LO_H_
 
 #include <io.h>
+#include <asm-generic/int-ll64.h>
 
 static inline __u64 hi_lo_readq(const volatile void __iomem *addr)
 {
@@ -21,6 +22,23 @@ static inline void hi_lo_writeq(__u64 val, volatile void __iomem *addr)
 	writel(val, addr);
 }
 
+static inline __u64 hi_lo_readq_relaxed(const volatile void __iomem *addr)
+{
+	const volatile u32 __iomem *p = addr;
+	u32 low, high;
+
+	high = readl_relaxed(p + 1);
+	low = readl_relaxed(p);
+
+	return low + ((u64)high << 32);
+}
+
+static inline void hi_lo_writeq_relaxed(__u64 val, volatile void __iomem *addr)
+{
+	writel_relaxed(val >> 32, addr + 4);
+	writel_relaxed(val, addr);
+}
+
 #ifndef readq
 #define readq hi_lo_readq
 #endif
@@ -29,4 +47,76 @@ static inline void hi_lo_writeq(__u64 val, volatile void __iomem *addr)
 #define writeq hi_lo_writeq
 #endif
 
+#ifndef readq_relaxed
+#define readq_relaxed hi_lo_readq_relaxed
+#endif
+
+#ifndef writeq_relaxed
+#define writeq_relaxed hi_lo_writeq_relaxed
+#endif
+
+#ifndef ioread64_hi_lo
+#define ioread64_hi_lo ioread64_hi_lo
+static inline u64 ioread64_hi_lo(const void __iomem *addr)
+{
+	u32 low, high;
+
+	high = ioread32(addr + sizeof(u32));
+	low = ioread32(addr);
+
+	return low + ((u64)high << 32);
+}
+#endif
+
+#ifndef iowrite64_hi_lo
+#define iowrite64_hi_lo iowrite64_hi_lo
+static inline void iowrite64_hi_lo(u64 val, void __iomem *addr)
+{
+	iowrite32(val >> 32, addr + sizeof(u32));
+	iowrite32(val, addr);
+}
+#endif
+
+#ifndef ioread64be_hi_lo
+#define ioread64be_hi_lo ioread64be_hi_lo
+static inline u64 ioread64be_hi_lo(const void __iomem *addr)
+{
+	u32 low, high;
+
+	high = ioread32be(addr);
+	low = ioread32be(addr + sizeof(u32));
+
+	return low + ((u64)high << 32);
+}
+#endif
+
+#ifndef iowrite64be_hi_lo
+#define iowrite64be_hi_lo iowrite64be_hi_lo
+static inline void iowrite64be_hi_lo(u64 val, void __iomem *addr)
+{
+	iowrite32be(val >> 32, addr);
+	iowrite32be(val, addr + sizeof(u32));
+}
+#endif
+
+#ifndef ioread64
+#define ioread64_is_nonatomic
+#define ioread64 ioread64_hi_lo
+#endif
+
+#ifndef iowrite64
+#define iowrite64_is_nonatomic
+#define iowrite64 iowrite64_hi_lo
+#endif
+
+#ifndef ioread64be
+#define ioread64be_is_nonatomic
+#define ioread64be ioread64be_hi_lo
+#endif
+
+#ifndef iowrite64be
+#define iowrite64be_is_nonatomic
+#define iowrite64be iowrite64be_hi_lo
+#endif
+
 #endif	/* _LINUX_IO_64_NONATOMIC_HI_LO_H_ */
diff --git a/include/io-64-nonatomic-lo-hi.h b/include/io-64-nonatomic-lo-hi.h
index 62b40227949e..6d50204b8560 100644
--- a/include/io-64-nonatomic-lo-hi.h
+++ b/include/io-64-nonatomic-lo-hi.h
@@ -3,6 +3,7 @@
 #define _LINUX_IO_64_NONATOMIC_LO_HI_H_
 
 #include <io.h>
+#include <asm-generic/int-ll64.h>
 
 static inline __u64 lo_hi_readq(const volatile void __iomem *addr)
 {
@@ -21,6 +22,23 @@ static inline void lo_hi_writeq(__u64 val, volatile void __iomem *addr)
 	writel(val >> 32, addr + 4);
 }
 
+static inline __u64 lo_hi_readq_relaxed(const volatile void __iomem *addr)
+{
+	const volatile u32 __iomem *p = addr;
+	u32 low, high;
+
+	low = readl_relaxed(p);
+	high = readl_relaxed(p + 1);
+
+	return low + ((u64)high << 32);
+}
+
+static inline void lo_hi_writeq_relaxed(__u64 val, volatile void __iomem *addr)
+{
+	writel_relaxed(val, addr);
+	writel_relaxed(val >> 32, addr + 4);
+}
+
 #ifndef readq
 #define readq lo_hi_readq
 #endif
@@ -29,4 +47,76 @@ static inline void lo_hi_writeq(__u64 val, volatile void __iomem *addr)
 #define writeq lo_hi_writeq
 #endif
 
+#ifndef readq_relaxed
+#define readq_relaxed lo_hi_readq_relaxed
+#endif
+
+#ifndef writeq_relaxed
+#define writeq_relaxed lo_hi_writeq_relaxed
+#endif
+
+#ifndef ioread64_lo_hi
+#define ioread64_lo_hi ioread64_lo_hi
+static inline u64 ioread64_lo_hi(const void __iomem *addr)
+{
+	u32 low, high;
+
+	low = ioread32(addr);
+	high = ioread32(addr + sizeof(u32));
+
+	return low + ((u64)high << 32);
+}
+#endif
+
+#ifndef iowrite64_lo_hi
+#define iowrite64_lo_hi iowrite64_lo_hi
+static inline void iowrite64_lo_hi(u64 val, void __iomem *addr)
+{
+	iowrite32(val, addr);
+	iowrite32(val >> 32, addr + sizeof(u32));
+}
+#endif
+
+#ifndef ioread64be_lo_hi
+#define ioread64be_lo_hi ioread64be_lo_hi
+static inline u64 ioread64be_lo_hi(const void __iomem *addr)
+{
+	u32 low, high;
+
+	low = ioread32be(addr + sizeof(u32));
+	high = ioread32be(addr);
+
+	return low + ((u64)high << 32);
+}
+#endif
+
+#ifndef iowrite64be_lo_hi
+#define iowrite64be_lo_hi iowrite64be_lo_hi
+static inline void iowrite64be_lo_hi(u64 val, void __iomem *addr)
+{
+	iowrite32be(val, addr + sizeof(u32));
+	iowrite32be(val >> 32, addr);
+}
+#endif
+
+#ifndef ioread64
+#define ioread64_is_nonatomic
+#define ioread64 ioread64_lo_hi
+#endif
+
+#ifndef iowrite64
+#define iowrite64_is_nonatomic
+#define iowrite64 iowrite64_lo_hi
+#endif
+
+#ifndef ioread64be
+#define ioread64be_is_nonatomic
+#define ioread64be ioread64be_lo_hi
+#endif
+
+#ifndef iowrite64be
+#define iowrite64be_is_nonatomic
+#define iowrite64be iowrite64be_lo_hi
+#endif
+
 #endif	/* _LINUX_IO_64_NONATOMIC_LO_HI_H_ */
-- 
2.30.2

[PATCH 4/7] clk: add prepare/unprepare helpers

[Ahmad Fatoum]

barebox doesn't use interrupts, so it need not differentiate between a
possibly sleeping prepare/unprepare and an atomic enable/disable.

Provide a wrapper that just expands to the already existing functions to
simplify porting of Linux kernel drivers.

Signed-off-by: Ahmad Fatoum <a.fatoum@pengutronix.de>
---
 include/linux/clk.h | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/include/linux/clk.h b/include/linux/clk.h
index 4cece8ba5e67..bffed2bdcfe7 100644
--- a/include/linux/clk.h
+++ b/include/linux/clk.h
@@ -71,6 +71,7 @@ struct clk *clk_get(struct device *dev, const char *id);
  * Returns success (0) or negative errno.
  */
 int clk_enable(struct clk *clk);
+#define clk_prepare_enable(clk) clk_enable(clk)
 
 /**
  * clk_disable - inform the system when the clock source is no longer required.
@@ -85,6 +86,7 @@ int clk_enable(struct clk *clk);
  * disabled.
  */
 void clk_disable(struct clk *clk);
+#define clk_disable_unprepare(clk) clk_disable(clk)
 
 /**
  * clk_get_rate - obtain the current clock rate (in Hz) for a clock source.
-- 
2.30.2

[PATCH 5/7] of: provide of_node_get and of_node_put stubs

[Ahmad Fatoum]

While removal of of_node_get and of_node_put can simplify ported kernel
code, on the other hand, they can be more of a hassle with future syncs
of the driver. Just provide stubs for them, so they can be left in.

Signed-off-by: Ahmad Fatoum <a.fatoum@pengutronix.de>
---
 include/of.h | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/include/of.h b/include/of.h
index f22730c081fe..4f4e9248ada9 100644
--- a/include/of.h
+++ b/include/of.h
@@ -101,6 +101,11 @@ static inline const void *of_property_get_value(const struct property *pp)
 	return pp->value ? pp->value : pp->value_const;
 }
 
+static inline struct device_node *of_node_get(struct device_node *node)
+{
+	return node;
+}
+static inline void of_node_put(struct device_node *node) { }
 
 void of_print_property(const void *data, int len);
 void of_print_cmdline(struct device_node *root);
-- 
2.30.2

[PATCH 6/7] include: linux/slab.h: define krealloc/kstrdup

[Ahmad Fatoum]

We already have a number of stubs for other kmalloc* functions, so add
these two as well.

Signed-off-by: Ahmad Fatoum <a.fatoum@pengutronix.de>
---
 include/linux/slab.h | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/include/linux/slab.h b/include/linux/slab.h
index eb14c58e340f..dc80808938f4 100644
--- a/include/linux/slab.h
+++ b/include/linux/slab.h
@@ -3,6 +3,9 @@
 #ifndef _LINUX_SLAB_H
 #define _LINUX_SLAB_H
 
+#include <malloc.h>
+#include <linux/string.h>
+
 #define SLAB_CONSISTENCY_CHECKS	0
 #define SLAB_RED_ZONE		0
 #define SLAB_POISON		0
@@ -103,6 +106,16 @@ static inline void *kcalloc(size_t n, size_t size, gfp_t flags)
 	return calloc(n, size);
 }
 
+static inline void *krealloc(void *ptr, size_t size, gfp_t flags)
+{
+	return realloc(ptr, size);
+}
+
+static inline char *kstrdup(const char *str, gfp_t flags)
+{
+	return strdup(str);
+}
+
 #define kstrdup_const(str, flags) strdup(str)
 #define kfree_const(ptr) kfree((void *)ptr)
 
-- 
2.30.2

[PATCH 7/7] barebox-wrapper: define MODULE_DEVICE_TABLE

[Ahmad Fatoum]

We may elect to act on this in the future, but for now, define the
macro, so it can be left in when porting kernel code.

Signed-off-by: Ahmad Fatoum <a.fatoum@pengutronix.de>
---
 include/linux/barebox-wrapper.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/include/linux/barebox-wrapper.h b/include/linux/barebox-wrapper.h
index 83fa9223decc..8f2473abe8aa 100644
--- a/include/linux/barebox-wrapper.h
+++ b/include/linux/barebox-wrapper.h
@@ -20,6 +20,7 @@ static inline void vfree(const void *addr)
 #define MODULE_DESCRIPTION(x)
 #define MODULE_LICENSE(x)
 #define MODULE_ALIAS(x)
+#define MODULE_DEVICE_TABLE(bus, table)
 
 #define __user
 #define __init
-- 
2.30.2

Re: [PATCH 0/7] treewide: misc helpers for porting

[Sascha Hauer]

On Mon, Jan 09, 2023 at 04:11:45PM +0100, Ahmad Fatoum wrote:
> These patches resulted from yak shaving around the upcoming
> sync of the Atmel NAND driver.
> 
> Ahmad Fatoum (7):
>   vsprintf: support %pOF format specifier
>   include: driver: make dev_(get_priv|is_probed) argument const pointer
>   include: sync io-64-nonatomic-*.h headers with Linux
>   clk: add prepare/unprepare helpers
>   of: provide of_node_get and of_node_put stubs
>   include: linux/slab.h: define krealloc/kstrdup
>   barebox-wrapper: define MODULE_DEVICE_TABLE

Applied, thanks

Sascha

> 
>  include/driver.h                |  4 +-
>  include/io-64-nonatomic-hi-lo.h | 90 +++++++++++++++++++++++++++++++++
>  include/io-64-nonatomic-lo-hi.h | 90 +++++++++++++++++++++++++++++++++
>  include/linux/barebox-wrapper.h |  1 +
>  include/linux/clk.h             |  2 +
>  include/linux/slab.h            | 13 +++++
>  include/of.h                    | 15 ++++++
>  lib/vsprintf.c                  | 13 +++++
>  8 files changed, 226 insertions(+), 2 deletions(-)
> 
> -- 
> 2.30.2
> 
> 
> 

-- 
Pengutronix e.K.                           |                             |
Steuerwalder Str. 21                       | http://www.pengutronix.de/  |
31137 Hildesheim, Germany                  | Phone: +49-5121-206917-0    |
Amtsgericht Hildesheim, HRA 2686           | Fax:   +49-5121-206917-5555 |