Introducing CONFIG_VIRT_CONCAT to separate the legacy flow from the new
approach, where individual partitions within a concatenated partition are
not registered, as they are likely not needed by the user.

Solution is focusing on fixed-partitions description only because it
depends on device boundaries.

Suggested-by: Bernhard Frauendienst <kernel@nospam.obeliks.de>
Suggested-by: Miquel Raynal <miquel.raynal@bootlin.com>
Signed-off-by: Amit Kumar Mahapatra <amit.kumar-mahapatra@amd.com>
---
 drivers/mtd/Kconfig           |   8 ++
 drivers/mtd/Makefile          |   1 +
 drivers/mtd/mtd_virt_concat.c | 254 ++++++++++++++++++++++++++++++++++
 drivers/mtd/mtdcore.c         |   7 +
 drivers/mtd/mtdpart.c         |   6 +
 include/linux/mtd/concat.h    |  24 ++++
 6 files changed, 300 insertions(+)
 create mode 100644 drivers/mtd/mtd_virt_concat.c

diff --git a/drivers/mtd/Kconfig b/drivers/mtd/Kconfig
index 796a2eccbef0..3dade7c469df 100644
--- a/drivers/mtd/Kconfig
+++ b/drivers/mtd/Kconfig
@@ -206,6 +206,14 @@ config MTD_PARTITIONED_MASTER
 	  the parent of the partition device be the master device, rather than
 	  what lies behind the master.
 
+config MTD_VIRT_CONCAT
+	tristate "Virtual concatenated MTD devices"
+	help
+	  The driver enables the creation of a virtual MTD device
+	  by concatenating multiple physical MTD devices into a single
+	  entity. This allows for the creation of partitions larger than
+	  the individual physical chips, extending across chip boundaries.
+
 source "drivers/mtd/chips/Kconfig"
 
 source "drivers/mtd/maps/Kconfig"
diff --git a/drivers/mtd/Makefile b/drivers/mtd/Makefile
index 593d0593a038..d1d577f89a22 100644
--- a/drivers/mtd/Makefile
+++ b/drivers/mtd/Makefile
@@ -22,6 +22,7 @@ obj-$(CONFIG_SM_FTL)		+= sm_ftl.o
 obj-$(CONFIG_MTD_OOPS)		+= mtdoops.o
 obj-$(CONFIG_MTD_PSTORE)	+= mtdpstore.o
 obj-$(CONFIG_MTD_SWAP)		+= mtdswap.o
+obj-$(CONFIG_MTD_VIRT_CONCAT)	+= mtd_virt_concat.o
 
 nftl-objs		:= nftlcore.o nftlmount.o
 inftl-objs		:= inftlcore.o inftlmount.o
diff --git a/drivers/mtd/mtd_virt_concat.c b/drivers/mtd/mtd_virt_concat.c
new file mode 100644
index 000000000000..3de67305a09b
--- /dev/null
+++ b/drivers/mtd/mtd_virt_concat.c
@@ -0,0 +1,254 @@
+// SPDX-License-Identifier: GPL-2.0+
+/*
+ * Virtual concat MTD device driver
+ *
+ * Copyright (C) 2018 Bernhard Frauendienst
+ * Author: Bernhard Frauendienst <kernel@nospam.obeliks.de>
+ */
+
+#include <linux/module.h>
+#include <linux/device.h>
+#include <linux/mtd/mtd.h>
+#include "mtdcore.h"
+#include <linux/mtd/partitions.h>
+#include <linux/of.h>
+#include <linux/of_platform.h>
+#include <linux/slab.h>
+#include <linux/mtd/concat.h>
+
+#define CONCAT_PROP "part-concat"
+#define MIN_DEV_PER_CONCAT 2
+
+static LIST_HEAD(concat_node_list);
+
+/**
+ * struct mtd_virt_concat_node - components of a concatenation
+ * @head: List handle
+ * @count: Number of nodes
+ * @nodes: Pointer to the nodes (partitions) to concatenate
+ * @concat: Concatenation container
+ */
+struct mtd_virt_concat_node {
+	struct list_head head;
+	unsigned int count;
+	struct device_node **nodes;
+	struct mtd_concat *concat;
+};
+
+static void mtd_virt_concat_put_mtd_devices(struct mtd_concat *concat)
+{
+	int i;
+
+	for (i = 0; i < concat->num_subdev; i++)
+		put_mtd_device(concat->subdev[i]);
+}
+
+static void mtd_virt_concat_destroy_joins(void)
+{
+	struct mtd_virt_concat_node *item, *tmp;
+	struct mtd_info *mtd;
+
+	list_for_each_entry_safe(item, tmp, &concat_node_list, head) {
+		mtd = &item->concat->mtd;
+		if (item->concat) {
+			mtd_device_unregister(mtd);
+			kfree(mtd->name);
+			mtd_concat_destroy(mtd);
+			mtd_virt_concat_put_mtd_devices(item->concat);
+		}
+	}
+}
+
+static int mtd_virt_concat_create_item(struct device_node *parts,
+				       unsigned int count)
+{
+	struct mtd_virt_concat_node *item;
+	struct mtd_concat *concat;
+	int i;
+
+	item = kzalloc(sizeof(*item), GFP_KERNEL);
+	if (!item)
+		return -ENOMEM;
+
+	item->count = count;
+	item->nodes = kcalloc(count, sizeof(*item->nodes), GFP_KERNEL);
+	if (!item->nodes) {
+		kfree(item);
+		return -ENOMEM;
+	}
+
+	for (i = 0; i < count; i++)
+		item->nodes[i] = of_parse_phandle(parts, CONCAT_PROP, i);
+
+	concat = kzalloc(sizeof(*concat), GFP_KERNEL);
+	if (!concat) {
+		kfree(item);
+		return -ENOMEM;
+	}
+
+	concat->subdev = kcalloc(count, sizeof(*concat->subdev), GFP_KERNEL);
+	if (!concat->subdev) {
+		kfree(item);
+		kfree(concat);
+		return -ENOMEM;
+	}
+	item->concat = concat;
+
+	list_add_tail(&item->head, &concat_node_list);
+
+	return 0;
+}
+
+static void mtd_virt_concat_destroy_items(void)
+{
+	struct mtd_virt_concat_node *item, *temp;
+	int i;
+
+	list_for_each_entry_safe(item, temp, &concat_node_list, head) {
+		for (i = 0; i < item->count; i++)
+			of_node_put(item->nodes[i]);
+
+		kfree(item->nodes);
+		kfree(item);
+	}
+}
+
+bool mtd_virt_concat_add(struct mtd_info *mtd)
+{
+	struct mtd_virt_concat_node *item;
+	struct mtd_concat *concat;
+	int idx;
+
+	list_for_each_entry(item, &concat_node_list, head) {
+		concat = item->concat;
+		if (item->count == concat->num_subdev)
+			return false;
+
+		for (idx = 0; idx < item->count; idx++) {
+			if (item->nodes[idx] == mtd->dev.of_node) {
+				concat->subdev[concat->num_subdev++] = mtd;
+				return true;
+			}
+		}
+	}
+	return false;
+}
+EXPORT_SYMBOL_GPL(mtd_virt_concat_add);
+
+int mtd_virt_concat_node_create(void)
+{
+	struct mtd_concat *concat;
+	struct device_node *parts = NULL;
+	int ret = 0, count;
+
+	if (!list_empty(&concat_node_list))
+		return 0;
+
+	/* List all the concatenations found in DT */
+	do {
+		parts = of_find_node_with_property(parts, CONCAT_PROP);
+		if (!of_device_is_available(parts))
+			continue;
+
+		count = of_count_phandle_with_args(parts, CONCAT_PROP, NULL);
+		if (count < MIN_DEV_PER_CONCAT)
+			continue;
+
+		ret = mtd_virt_concat_create_item(parts, count);
+		if (ret) {
+			of_node_put(parts);
+			goto destroy_items;
+		}
+	} while (parts);
+
+	concat = kzalloc(sizeof(*concat), GFP_KERNEL);
+	if (!concat) {
+		ret = -ENOMEM;
+		of_node_put(parts);
+		goto destroy_items;
+	}
+
+	concat->subdev = kcalloc(count, sizeof(*concat->subdev), GFP_KERNEL);
+	if (!concat->subdev) {
+		kfree(concat);
+		ret = -ENOMEM;
+		of_node_put(parts);
+		goto destroy_items;
+	}
+
+	return count;
+
+destroy_items:
+	mtd_virt_concat_destroy_items();
+
+	return ret;
+}
+EXPORT_SYMBOL_GPL(mtd_virt_concat_node_create);
+
+static int __init mtd_virt_concat_create_join(void)
+{
+	struct mtd_virt_concat_node *item;
+	struct mtd_concat *concat;
+	struct mtd_info *mtd;
+	ssize_t name_sz;
+	char *name;
+	int ret;
+
+	list_for_each_entry(item, &concat_node_list, head) {
+		concat = item->concat;
+		mtd = &concat->mtd;
+		/* Create the virtual device */
+		name_sz = snprintf(NULL, 0, "%s-%s%s-concat",
+				   concat->subdev[0]->name,
+				   concat->subdev[1]->name,
+				   concat->num_subdev > MIN_DEV_PER_CONCAT ?
+				   "-+" : "");
+		name = kmalloc(name_sz + 1, GFP_KERNEL);
+		if (!name) {
+			mtd_virt_concat_put_mtd_devices(concat);
+			return -ENOMEM;
+		}
+
+		sprintf(name, "%s-%s%s-concat",
+			concat->subdev[0]->name,
+			concat->subdev[1]->name,
+			concat->num_subdev > MIN_DEV_PER_CONCAT ?
+			"-+" : "");
+
+		mtd = mtd_concat_create(concat->subdev, concat->num_subdev, name);
+		if (!mtd) {
+			kfree(name);
+			return -ENXIO;
+		}
+
+		/* Arbitrary set the first device as parent */
+		mtd->dev.parent = concat->subdev[0]->dev.parent;
+		mtd->dev = concat->subdev[0]->dev;
+
+		/* Register the platform device */
+		ret = mtd_device_register(mtd, NULL, 0);
+		if (ret)
+			goto destroy_concat;
+	}
+
+	return 0;
+
+destroy_concat:
+	mtd_concat_destroy(mtd);
+
+	return ret;
+}
+
+late_initcall(mtd_virt_concat_create_join);
+
+static void __exit mtd_virt_concat_exit(void)
+{
+	mtd_virt_concat_destroy_joins();
+	mtd_virt_concat_destroy_items();
+}
+module_exit(mtd_virt_concat_exit);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Bernhard Frauendienst <kernel@nospam.obeliks.de>");
+MODULE_AUTHOR("Amit Kumar Mahapatra <amit.kumar-mahapatra@amd.com>");
+MODULE_DESCRIPTION("Virtual concat MTD device driver");
diff --git a/drivers/mtd/mtdcore.c b/drivers/mtd/mtdcore.c
index 724f917f91ba..2264fe81810f 100644
--- a/drivers/mtd/mtdcore.c
+++ b/drivers/mtd/mtdcore.c
@@ -34,6 +34,7 @@
 
 #include <linux/mtd/mtd.h>
 #include <linux/mtd/partitions.h>
+#include <linux/mtd/concat.h>
 
 #include "mtdcore.h"
 
@@ -1067,6 +1068,12 @@ int mtd_device_parse_register(struct mtd_info *mtd, const char * const *types,
 			goto out;
 	}
 
+	if (IS_ENABLED(CONFIG_MTD_VIRT_CONCAT)) {
+		ret = mtd_virt_concat_node_create();
+		if (ret < 0)
+			goto out;
+	}
+
 	/* Prefer parsed partitions over driver-provided fallback */
 	ret = parse_mtd_partitions(mtd, types, parser_data);
 	if (ret == -EPROBE_DEFER)
diff --git a/drivers/mtd/mtdpart.c b/drivers/mtd/mtdpart.c
index 6811a714349d..4f50e14b96dd 100644
--- a/drivers/mtd/mtdpart.c
+++ b/drivers/mtd/mtdpart.c
@@ -18,6 +18,7 @@
 #include <linux/err.h>
 #include <linux/of.h>
 #include <linux/of_platform.h>
+#include <linux/mtd/concat.h>
 
 #include "mtdcore.h"
 
@@ -409,6 +410,11 @@ int add_mtd_partitions(struct mtd_info *parent,
 			goto err_del_partitions;
 		}
 
+		if (IS_ENABLED(CONFIG_MTD_VIRT_CONCAT)) {
+			if (mtd_virt_concat_add(child))
+				continue;
+		}
+
 		mutex_lock(&master->master.partitions_lock);
 		list_add_tail(&child->part.node, &parent->partitions);
 		mutex_unlock(&master->master.partitions_lock);
diff --git a/include/linux/mtd/concat.h b/include/linux/mtd/concat.h
index b42d9af87c4e..65c9a18774f6 100644
--- a/include/linux/mtd/concat.h
+++ b/include/linux/mtd/concat.h
@@ -28,5 +28,29 @@ struct mtd_info *mtd_concat_create(
 
 void mtd_concat_destroy(struct mtd_info *mtd);
 
+/**
+ * mtd_virt_concat_node_create - Create a component for concatenation
+ *
+ * Returns a positive number representing the no. of devices found for
+ * concatenation, or a negative error code.
+ *
+ * List all the devices for concatenations found in DT and create a
+ * component for concatenation.
+ */
+int mtd_virt_concat_node_create(void);
+
+/**
+ * mtd_virt_concat_add - add mtd_info object to the list of subdevices for concatenation
+ * @mtd: pointer to new MTD device info structure
+ *
+ * Returns true if the mtd_info object is added successfully else returns false.
+ *
+ * The mtd_info object is added to the list of subdevices for concatenation.
+ * It returns true if a match is found, and false if all subdevices have
+ * already been added or if the mtd_info object does not match any of the
+ * intended MTD devices.
+ */
+bool mtd_virt_concat_add(struct mtd_info *mtd);
+
 #endif
 
-- 
2.34.1

On 05/02/2025 at 19:07:30 +0530, Amit Kumar Mahapatra <amit.kumar-mahapatra@amd.com> wrote:

> Introducing CONFIG_VIRT_CONCAT to separate the legacy flow from the
> new

CONFIG_MTD_VIRT_CONCAT

> approach, where individual partitions within a concatenated partition are
> not registered, as they are likely not needed by the user.

I am not a big fan of this choice. We had issues with hiding things to
the user in the first place. Could we find a way to expose both the
original mtd devices as well as the virtually concatenated partitions?

> Solution is focusing on fixed-partitions description only because it
> depends on device boundaries.
>
> Suggested-by: Bernhard Frauendienst <kernel@nospam.obeliks.de>
> Suggested-by: Miquel Raynal <miquel.raynal@bootlin.com>
> Signed-off-by: Amit Kumar Mahapatra <amit.kumar-mahapatra@amd.com>
> ---
>  drivers/mtd/Kconfig           |   8 ++
>  drivers/mtd/Makefile          |   1 +
>  drivers/mtd/mtd_virt_concat.c | 254 ++++++++++++++++++++++++++++++++++
>  drivers/mtd/mtdcore.c         |   7 +
>  drivers/mtd/mtdpart.c         |   6 +
>  include/linux/mtd/concat.h    |  24 ++++
>  6 files changed, 300 insertions(+)
>  create mode 100644 drivers/mtd/mtd_virt_concat.c
>
> diff --git a/drivers/mtd/Kconfig b/drivers/mtd/Kconfig
> index 796a2eccbef0..3dade7c469df 100644
> --- a/drivers/mtd/Kconfig
> +++ b/drivers/mtd/Kconfig
> @@ -206,6 +206,14 @@ config MTD_PARTITIONED_MASTER
>  	  the parent of the partition device be the master device, rather than
>  	  what lies behind the master.
>  
> +config MTD_VIRT_CONCAT
> +	tristate "Virtual concatenated MTD devices"
> +	help
> +	  The driver enables the creation of a virtual MTD device

                                          of virtual MTD devices

> +	  by concatenating multiple physical MTD devices into a single
> +	  entity. This allows for the creation of partitions larger than
> +	  the individual physical chips, extending across chip boundaries.
> +

...

> +static int __init mtd_virt_concat_create_join(void)
> +{
> +	struct mtd_virt_concat_node *item;
> +	struct mtd_concat *concat;
> +	struct mtd_info *mtd;
> +	ssize_t name_sz;
> +	char *name;
> +	int ret;
> +
> +	list_for_each_entry(item, &concat_node_list, head) {
> +		concat = item->concat;
> +		mtd = &concat->mtd;
> +		/* Create the virtual device */
> +		name_sz = snprintf(NULL, 0, "%s-%s%s-concat",
> +				   concat->subdev[0]->name,
> +				   concat->subdev[1]->name,
> +				   concat->num_subdev > MIN_DEV_PER_CONCAT ?
> +				   "-+" : "");
> +		name = kmalloc(name_sz + 1, GFP_KERNEL);
> +		if (!name) {
> +			mtd_virt_concat_put_mtd_devices(concat);
> +			return -ENOMEM;
> +		}
> +
> +		sprintf(name, "%s-%s%s-concat",
> +			concat->subdev[0]->name,
> +			concat->subdev[1]->name,
> +			concat->num_subdev > MIN_DEV_PER_CONCAT ?
> +			"-+" : "");
> +
> +		mtd = mtd_concat_create(concat->subdev, concat->num_subdev, name);
> +		if (!mtd) {
> +			kfree(name);
> +			return -ENXIO;
> +		}
> +
> +		/* Arbitrary set the first device as parent */

Here we may face runtime PM issues. At some point the device model
expects a single parent per struct device, but here we have two. I do
not have any hints at the moment on how we could solve that.

> +		mtd->dev.parent = concat->subdev[0]->dev.parent;
> +		mtd->dev = concat->subdev[0]->dev;
> +
> +		/* Register the platform device */
> +		ret = mtd_device_register(mtd, NULL, 0);
> +		if (ret)
> +			goto destroy_concat;
> +	}
> +
> +	return 0;
> +
> +destroy_concat:
> +	mtd_concat_destroy(mtd);
> +
> +	return ret;
> +}
> +
> +late_initcall(mtd_virt_concat_create_join);

The current implementation does not support probe deferrals, I believe
it should be handled.

> +static void __exit mtd_virt_concat_exit(void)
> +{
> +	mtd_virt_concat_destroy_joins();
> +	mtd_virt_concat_destroy_items();
> +}
> +module_exit(mtd_virt_concat_exit);
> +
> +MODULE_LICENSE("GPL");
> +MODULE_AUTHOR("Bernhard Frauendienst <kernel@nospam.obeliks.de>");
> +MODULE_AUTHOR("Amit Kumar Mahapatra <amit.kumar-mahapatra@amd.com>");
> +MODULE_DESCRIPTION("Virtual concat MTD device driver");
> diff --git a/drivers/mtd/mtdcore.c b/drivers/mtd/mtdcore.c
> index 724f917f91ba..2264fe81810f 100644
> --- a/drivers/mtd/mtdcore.c
> +++ b/drivers/mtd/mtdcore.c
> @@ -34,6 +34,7 @@
>  
>  #include <linux/mtd/mtd.h>
>  #include <linux/mtd/partitions.h>
> +#include <linux/mtd/concat.h>
>  
>  #include "mtdcore.h"
>  
> @@ -1067,6 +1068,12 @@ int mtd_device_parse_register(struct mtd_info *mtd, const char * const *types,
>  			goto out;
>  	}
>  
> +	if (IS_ENABLED(CONFIG_MTD_VIRT_CONCAT)) {

Maybe IS_REACHABLE() is more relevant?

> +		ret = mtd_virt_concat_node_create();
> +		if (ret < 0)
> +			goto out;
> +	}
> +
>  	/* Prefer parsed partitions over driver-provided fallback */
>  	ret = parse_mtd_partitions(mtd, types, parser_data);
>  	if (ret == -EPROBE_DEFER)

Thanks,
Miquèl

I suggest to improve implementation details another bit at a few source code places.

Examples:
…
> +++ b/drivers/mtd/mtd_virt_concat.c
> @@ -0,0 +1,254 @@
…
> +static int mtd_virt_concat_create_item(struct device_node *parts,
> +				       unsigned int count)
> +{

+	struct mtd_virt_concat_node *item __free(kfree) = kzalloc(sizeof(*item), GFP_KERNEL);


…
> +int mtd_virt_concat_node_create(void)
> +{
…

+e_nomem:
+	ret = -ENOMEM;
+put_parts:
+	of_node_put(parts);

> +destroy_items:
> +	mtd_virt_concat_destroy_items();
> +
> +	return ret;
> +}
…


Regards,
Markus