[PATCH v2 2/3] drivers: introduce mtdblock abstraction
Heinrich Schuchardt
xypron.glpk at gmx.de
Wed Apr 3 11:50:29 CEST 2024
On 07.03.24 14:07, Alexey Romanov wrote:
> MTD block - abstraction over MTD subsystem, allowing
> to read and write in blocks using BLK UCLASS.
>
> Signed-off-by: Alexey Romanov <avromanov at salutedevices.com>
> ---
> drivers/block/blk-uclass.c | 1 +
> drivers/mtd/Makefile | 1 +
> drivers/mtd/mtdblock.c | 227 +++++++++++++++++++++++++++++++++++++
> include/linux/mtd/mtd.h | 12 ++
> 4 files changed, 241 insertions(+)
> create mode 100644 drivers/mtd/mtdblock.c
>
> diff --git a/drivers/block/blk-uclass.c b/drivers/block/blk-uclass.c
> index 77066da352..ab0a9105c9 100644
> --- a/drivers/block/blk-uclass.c
> +++ b/drivers/block/blk-uclass.c
> @@ -37,6 +37,7 @@ static struct {
> { UCLASS_PVBLOCK, "pvblock" },
> { UCLASS_BLKMAP, "blkmap" },
> { UCLASS_RKMTD, "rkmtd" },
> + { UCLASS_MTD, "mtd" },
> };
>
> static enum uclass_id uclass_name_to_iftype(const char *uclass_idname)
> diff --git a/drivers/mtd/Makefile b/drivers/mtd/Makefile
> index c638980ea2..993b122ac4 100644
> --- a/drivers/mtd/Makefile
> +++ b/drivers/mtd/Makefile
> @@ -26,6 +26,7 @@ obj-y += onenand/
> obj-y += spi/
> obj-$(CONFIG_MTD_UBI) += ubi/
> obj-$(CONFIG_NVMXIP) += nvmxip/
> +obj-$(CONFIG_BLK) += mtdblock.o
>
> #SPL/TPL build
> else
> diff --git a/drivers/mtd/mtdblock.c b/drivers/mtd/mtdblock.c
> new file mode 100644
> index 0000000000..b409674173
> --- /dev/null
> +++ b/drivers/mtd/mtdblock.c
> @@ -0,0 +1,227 @@
> +// SPDX-License-Identifier: GPL-2.0+
nits:
GPL-2.0-or-later
see https://spdx.org/licenses/GPL-2.0-or-later.html
> +/*
> + * MTD block - abstraction over MTD subsystem, allowing
> + * to read and write in blocks using BLK UCLASS.
> + *
> + * - Read algorithm:
> + *
> + * 1. Convert start block number to start address.
> + * 2. Read block_dev->blksz bytes using mtd_read() and
> + * add to start address pointer block_dev->blksz bytes,
> + * until the requested number of blocks have been read.
> + *
> + * - Write algorithm:
> + *
> + * 1. Convert start block number to start address.
> + * 2. Round this address down by mtd->erasesize.
> + *
> + * Erase addr Start addr
> + * | |
> + * v v
> + * +----------------+----------------+----------------+
> + * | blksz | blksz | blksz |
> + * +----------------+----------------+----------------+
> + *
> + * 3. Calculate offset between this two addresses.
> + * 4. Read mtd->erasesize bytes using mtd_read() into
> + * temporary buffer from erase address.
> + *
> + * Erase addr Start addr
> + * | |
> + * v v
> + * +----------------+----------------+----------------+
> + * | blksz | blksz | blksz |
> + * +----------------+----------------+----------------+
> + * ^
> + * |
> + * |
> + * mtd_read()
> + * from here
> + *
> + * 5. Copy data from user buffer to temporary buffer with offset,
> + * calculated at step 3.
> + * 6. Erase and write mtd->erasesize bytes at erase address
> + * pointer using mtd_erase/mtd_write().
> + * 7. Add to erase address pointer mtd->erasesize bytes.
> + * 8. goto 1 until the requested number of blocks have
> + * been written.
> + *
> + * (C) Copyright 2024 SaluteDevices, Inc.
> + *
> + * Author: Alexey Romanov <avromanov at salutedevices.com>
> + */
> +
> +#include <blk.h>
> +#include <part.h>
> +#include <dm/device.h>
> +#include <dm/device-internal.h>
> +#include <linux/mtd/mtd.h>
> +
> +int mtd_bind(struct udevice *dev, struct mtd_info **mtd)
> +{
> + struct blk_desc *bdesc;
> + struct udevice *bdev;
> + int ret;
> +
> + ret = blk_create_devicef(dev, "mtd_blk", "blk", UCLASS_MTD,
> + dev_seq(dev), 512, 0, &bdev);
> + if (ret) {
> + pr_err("Cannot create block device\n");
> + return ret;
> + }
> +
> + bdesc = dev_get_uclass_plat(bdev);
> + dev_set_priv(bdev, mtd);
> + bdesc->bdev = bdev;
> + bdesc->part_type = PART_TYPE_MTD;
> +
> + return 0;
> +}
> +
> +static ulong mtd_bread(struct udevice *dev, lbaint_t start, lbaint_t blkcnt,
nits:
Reading bread I thought of nutrition. How about mtd_blk_read()?
> + void *dst)
> +{
> + struct blk_desc *block_dev = dev_get_uclass_plat(dev);
> + struct mtd_info *mtd = blk_desc_to_mtd(block_dev);
> + unsigned int sect_size = block_dev->blksz;
> + lbaint_t cur = start;
> + ulong read_cnt = 0;
> +
> + while (read_cnt < blkcnt) {
> + int ret;
> + loff_t sect_start = cur * sect_size;
> + size_t retlen;
> +
> + ret = mtd_read(mtd, sect_start, sect_size, &retlen, dst);
> + if (ret)
> + return ret;
> +
> + if (retlen != sect_size) {
> + pr_err("mtdblock: failed to read block 0x%lx\n", cur);
> + return -EIO;
> + }
> +
> + cur++;
> + dst += sect_size;
> + read_cnt++;
> + }
> +
> + return read_cnt;
> +}
> +
> +static int mtd_erase_write(struct mtd_info *mtd, uint64_t start, const void *src)
> +{
> + int ret;
> + size_t retlen;
> + struct erase_info erase = { 0 };
> +
> + erase.mtd = mtd;
> + erase.addr = start;
> + erase.len = mtd->erasesize;
> +
> + ret = mtd_erase(mtd, &erase);
> + if (ret)
> + return ret;
> +
> + ret = mtd_write(mtd, start, mtd->erasesize, &retlen, src);
> + if (ret)
> + return ret;
> +
> + if (retlen != mtd->erasesize) {
> + pr_err("mtdblock: failed to read block at 0x%llx\n", start);
> + return -EIO;
> + }
> +
> + return 0;
> +}
> +
> +static ulong mtd_bwrite(struct udevice *dev, lbaint_t start, lbaint_t blkcnt,
mtd_blk_write()?
Best regards
Heinrich
> + const void *src)
> +{
> + struct blk_desc *block_dev = dev_get_uclass_plat(dev);
> + struct mtd_info *mtd = blk_desc_to_mtd(block_dev);
> + unsigned int sect_size = block_dev->blksz;
> + lbaint_t cur = start, blocks_todo = blkcnt;
> + ulong write_cnt = 0;
> + u8 *buf;
> + int ret = 0;
> +
> + buf = malloc(mtd->erasesize);
> + if (!buf)
> + return -ENOMEM;
> +
> + while (blocks_todo > 0) {
> + loff_t sect_start = cur * sect_size;
> + loff_t erase_start = ALIGN_DOWN(sect_start, mtd->erasesize);
> + u32 offset = sect_start - erase_start;
> + size_t cur_size = min_t(size_t, mtd->erasesize - offset,
> + blocks_todo * sect_size);
> + size_t retlen;
> + lbaint_t written;
> +
> + ret = mtd_read(mtd, erase_start, mtd->erasesize, &retlen, buf);
> + if (ret)
> + goto out;
> +
> + if (retlen != mtd->erasesize) {
> + pr_err("mtdblock: failed to read block 0x%lx\n", cur);
> + ret = -EIO;
> + goto out;
> + }
> +
> + memcpy(buf + offset, src, cur_size);
> +
> + ret = mtd_erase_write(mtd, erase_start, buf);
> + if (ret)
> + goto out;
> +
> + written = cur_size / sect_size;
> +
> + blocks_todo -= written;
> + cur += written;
> + src += cur_size;
> + write_cnt += written;
> + }
> +
> +out:
> + free(buf);
> +
> + if (ret)
> + return ret;
> +
> + return write_cnt;
> +}
> +
> +static int mtd_blk_probe(struct udevice *dev)
> +{
> + struct blk_desc *bdesc;
> + struct mtd_info *mtd;
> + int ret;
> +
> + ret = device_probe(dev);
> + if (ret) {
> + pr_err("Probing %s failed (err=%d)\n", dev->name, ret);
> + return ret;
> + }
> +
> + bdesc = dev_get_uclass_plat(dev);
> + mtd = blk_desc_to_mtd(bdesc);
> +
> + if (mtd_type_is_nand(mtd))
> + pr_warn("MTD device '%s' is NAND, please use UBI devices instead\n",
> + mtd->name);
> +
> + return 0;
> +}
> +
> +static const struct blk_ops mtd_blk_ops = {
> + .read = mtd_bread,
> + .write = mtd_bwrite,
> +};
> +
> +U_BOOT_DRIVER(mtd_blk) = {
> + .name = "mtd_blk",
> + .id = UCLASS_BLK,
> + .ops = &mtd_blk_ops,
> + .probe = mtd_blk_probe,
> +};
> diff --git a/include/linux/mtd/mtd.h b/include/linux/mtd/mtd.h
> index 09f5269887..9b997fadd1 100644
> --- a/include/linux/mtd/mtd.h
> +++ b/include/linux/mtd/mtd.h
> @@ -26,6 +26,9 @@
> #include <dm/device.h>
> #endif
> #include <dm/ofnode.h>
> +#if IS_ENABLED(CONFIG_BLK)
> +#include <blk.h>
> +#endif
>
> #define MAX_MTD_DEVICES 32
> #endif
> @@ -412,6 +415,15 @@ int mtd_write(struct mtd_info *mtd, loff_t to, size_t len, size_t *retlen,
> int mtd_panic_write(struct mtd_info *mtd, loff_t to, size_t len, size_t *retlen,
> const u_char *buf);
>
> +#if IS_ENABLED(CONFIG_BLK)
> +static inline struct mtd_info *blk_desc_to_mtd(struct blk_desc *bdesc)
> +{
> + return *((struct mtd_info **)dev_get_priv(bdesc->bdev));
> +}
> +
> +int mtd_bind(struct udevice *dev, struct mtd_info **mtd);
> +#endif
> +
> int mtd_read_oob(struct mtd_info *mtd, loff_t from, struct mtd_oob_ops *ops);
> int mtd_write_oob(struct mtd_info *mtd, loff_t to, struct mtd_oob_ops *ops);
>
More information about the U-Boot
mailing list