[PATCH v13 3/3] mtd: Add driver for concatenating devices
Amit Kumar Mahapatra
amit.kumar-mahapatra at amd.com
Tue Jun 3 12:42:09 PDT 2025
Introducing CONFIG_MTD_VIRT_CONCAT to separate the legacy flow from the new
approach, where only the concatenated partition is registered as an MTD
device, while the individual partitions that form it are not registered
independently, as they are typically not required by the user.
CONFIG_MTD_VIRT_CONCAT is a boolean configuration option that depends on
CONFIG_MTD_PARTITIONED_MASTER. When enabled, it allows flash nodes to be
exposed as individual MTD devices along with the other partitions.
The solution focuses on fixed-partitions description only as it depends on
device boundaries. It supports multiple sets of concatenated devices, each
comprising two or more partitions.
flash at 0 {
reg = <0>;
partitions {
compatible = "fixed-partitions";
part0 at 0 {
part-concat-next = <&flash0_part1>;
label = "part0_0";
reg = <0x0 0x800000>;
};
flash0_part1: part1 at 800000 {
label = "part0_1";
reg = <800000 0x800000>;
};
part2 at 1000000 {
part-concat-next = <&flash1_part0>;
label = "part0_2";
reg = <0x800000 0x800000>;
};
};
};
flash at 1 {
reg = <1>;
partitions {
compatible = "fixed-partitions";
flash1_part0: part1 at 0 {
label = "part1_0";
reg = <0x0 0x800000>;
};
part1 at 800000 {
label = "part1_1";
reg = <0x800000 0x800000>;
};
};
};
The partitions that gets created are
flash at 0
part0_0-part0_1-concat
flash at 1
part1_1
part0_2-part1_0-concat
Suggested-by: Bernhard Frauendienst <kernel at nospam.obeliks.de>
Suggested-by: Miquel Raynal <miquel.raynal at bootlin.com>
Signed-off-by: Amit Kumar Mahapatra <amit.kumar-mahapatra at amd.com>
---
Tested the virtual concat driver on the AMD-Xilinx ZynqMP board by building
the ZynqMP GQSPI driver as a module and loading it post kernel boot.
---
drivers/mtd/Kconfig | 10 ++
drivers/mtd/Makefile | 1 +
drivers/mtd/mtd_virt_concat.c | 313 ++++++++++++++++++++++++++++++++++
drivers/mtd/mtdcore.c | 12 ++
drivers/mtd/mtdpart.c | 6 +
include/linux/mtd/concat.h | 32 ++++
6 files changed, 374 insertions(+)
create mode 100644 drivers/mtd/mtd_virt_concat.c
diff --git a/drivers/mtd/Kconfig b/drivers/mtd/Kconfig
index 796a2eccbef0..b91c3026ac7c 100644
--- a/drivers/mtd/Kconfig
+++ b/drivers/mtd/Kconfig
@@ -206,6 +206,16 @@ 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
+ bool "Virtual concatenated MTD devices"
+ default n
+ depends on MTD_PARTITIONED_MASTER
+ help
+ The driver enables the creation of 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..8c618c676a51
--- /dev/null
+++ b/drivers/mtd/mtd_virt_concat.c
@@ -0,0 +1,313 @@
+// SPDX-License-Identifier: GPL-2.0+
+/*
+ * Virtual concat MTD device driver
+ *
+ * Copyright (C) 2018 Bernhard Frauendienst
+ * Author: Bernhard Frauendienst <kernel at 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-next"
+#define CONCAT_POSTFIX "concat"
+#define MIN_DEV_PER_CONCAT 1
+
+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;
+};
+
+/**
+ * mtd_is_part_concat - Check if the device is already part
+ * of a concatenated device
+ * @dev: pointer to 'device_node'
+ *
+ * Return: true if the device is already part of a concatenation,
+ * false otherwise.
+ */
+static bool mtd_is_part_concat(struct device_node *dev)
+{
+ struct mtd_virt_concat_node *item;
+ int idx;
+
+ list_for_each_entry(item, &concat_node_list, head) {
+ for (idx = 0; idx < item->count; idx++) {
+ if (item->nodes[idx] == dev)
+ return true;
+ }
+ }
+ return false;
+}
+
+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);
+ }
+ }
+}
+
+/**
+ * mtd_virt_concat_create_item - Create a concat item
+ * @parts: pointer to 'device_node'
+ * @count: number of mtd devices that make up
+ * the concatenated device.
+ *
+ * Return: 0 on success, -error otherwise.
+ */
+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;
+
+ for (i = 0; i < (count - 1); i++) {
+ if (mtd_is_part_concat(of_parse_phandle(parts, CONCAT_PROP, i)))
+ return 0;
+ }
+
+ 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;
+ }
+
+ /*
+ * The partition in which "part-concat-next" property
+ * is defined is the first device in the list of concat
+ * devices.
+ */
+ item->nodes[0] = parts;
+
+ for (i = 1; i < count; i++)
+ item->nodes[i] = of_parse_phandle(parts, CONCAT_PROP, (i - 1));
+
+ 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);
+ }
+}
+
+/**
+ * mtd_virt_concat_create_add - Add a mtd device to the concat list
+ * @mtd: pointer to 'mtd_info'
+ *
+ * Return: true on success, false otherwise.
+ */
+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;
+ 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);
+
+/**
+ * mtd_virt_concat_node_create - List all the concatenations found in DT
+ *
+ * Return: 0 on success, -error otherwise.
+ */
+int mtd_virt_concat_node_create(void)
+{
+ struct device_node *parts = NULL;
+ int ret = 0, count = 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;
+
+ if (mtd_is_part_concat(parts))
+ continue;
+
+ count = of_count_phandle_with_args(parts, CONCAT_PROP, NULL);
+ if (count < MIN_DEV_PER_CONCAT)
+ continue;
+
+ /*
+ * The partition in which "part-concat-next" property is defined
+ * is also part of the concat device, so increament count by 1.
+ */
+ count++;
+
+ ret = mtd_virt_concat_create_item(parts, count);
+ if (ret) {
+ of_node_put(parts);
+ goto destroy_items;
+ }
+ } while (parts);
+
+ return ret;
+
+destroy_items:
+ mtd_virt_concat_destroy_items();
+
+ return ret;
+}
+EXPORT_SYMBOL_GPL(mtd_virt_concat_node_create);
+
+/**
+ * mtd_virt_concat_create_join - Create and register the concatenated
+ * MTD device.
+ *
+ * Return: 0 on success, -error otherwise.
+ */
+int mtd_virt_concat_create_join(void)
+{
+ struct mtd_virt_concat_node *item;
+ struct mtd_concat *concat;
+ struct mtd_info *mtd;
+ ssize_t name_sz;
+ int ret, idx;
+ char *name;
+
+ list_for_each_entry(item, &concat_node_list, head) {
+ concat = item->concat;
+ /*
+ * Check if item->count != concat->num_subdev, it indicates
+ * that the MTD information for all devices included in the
+ * concatenation are not handy, concat MTD device can't be
+ * created hence switch to next concat device.
+ */
+ if (item->count != concat->num_subdev) {
+ continue;
+ } else {
+ /* Calculate the legth of the name of the virtual device */
+ for (idx = 0, name_sz = 0; idx < concat->num_subdev; idx++)
+ name_sz += (strlen(concat->subdev[idx]->name) + 1);
+ name_sz += strlen(CONCAT_POSTFIX);
+ name = kmalloc(name_sz + 1, GFP_KERNEL);
+ if (!name) {
+ mtd_virt_concat_put_mtd_devices(concat);
+ return -ENOMEM;
+ }
+
+ ret = 0;
+ for (idx = 0; idx < concat->num_subdev; idx++) {
+ ret += sprintf((name + ret), "%s-",
+ concat->subdev[idx]->name);
+ }
+ sprintf((name + ret), CONCAT_POSTFIX);
+
+ if (concat->mtd.name) {
+ ret = memcmp(concat->mtd.name, name, name_sz);
+ if (ret == 0)
+ continue;
+ }
+ mtd = mtd_concat_create(concat->subdev, concat->num_subdev, name);
+ if (!mtd) {
+ kfree(name);
+ return -ENXIO;
+ }
+ concat->mtd = *mtd;
+ /* Arbitrary set the first device as parent */
+ concat->mtd.dev.parent = concat->subdev[0]->dev.parent;
+ concat->mtd.dev = concat->subdev[0]->dev;
+
+ /* Add the mtd device */
+ ret = add_mtd_device(&concat->mtd);
+ if (ret)
+ goto destroy_concat;
+ }
+ }
+
+ return 0;
+
+destroy_concat:
+ mtd_concat_destroy(mtd);
+
+ return ret;
+}
+EXPORT_SYMBOL_GPL(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 at nospam.obeliks.de>");
+MODULE_AUTHOR("Amit Kumar Mahapatra <amit.kumar-mahapatra at amd.com>");
+MODULE_DESCRIPTION("Virtual concat MTD device driver");
diff --git a/drivers/mtd/mtdcore.c b/drivers/mtd/mtdcore.c
index 724f917f91ba..255062a1ab3d 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_REACHABLE(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)
@@ -1084,6 +1091,11 @@ int mtd_device_parse_register(struct mtd_info *mtd, const char * const *types,
if (ret)
goto out;
+ if (IS_REACHABLE(CONFIG_MTD_VIRT_CONCAT)) {
+ ret = mtd_virt_concat_create_join();
+ if (ret < 0)
+ goto out;
+ }
/*
* FIXME: some drivers unfortunately call this function more than once.
* So we have to check if we've already assigned the reboot notifier.
diff --git a/drivers/mtd/mtdpart.c b/drivers/mtd/mtdpart.c
index 6811a714349d..2392623646d0 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_REACHABLE(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..5b0b88d0ba44 100644
--- a/include/linux/mtd/concat.h
+++ b/include/linux/mtd/concat.h
@@ -28,5 +28,37 @@ 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);
+
+/**
+ * mtd_virt_concat_create_join - Create and register the concatenated MTD device
+ *
+ * Returns on succes, or a negative error code.
+ *
+ * Creates and registers the concatenated MTD device
+ */
+int mtd_virt_concat_create_join(void);
#endif
--
2.34.1
More information about the linux-mtd
mailing list