[J-u-boot.git] / cmd / mtd.c

// SPDX-License-Identifier:  GPL-2.0+
/*
 * mtd.c
 *
 * Generic command to handle basic operations on any memory device.
 *
 * Copyright: Bootlin, 2018
 * Author: Miquèl Raynal <[email protected]>
 */

#include <command.h>
#include <common.h>
#include <console.h>
#include <malloc.h>
#include <mapmem.h>
#include <mtd.h>
#include <dm/devres.h>
#include <linux/err.h>

#include <linux/ctype.h>

static struct mtd_info *get_mtd_by_name(const char *name)
{
	struct mtd_info *mtd;

	mtd_probe_devices();

	mtd = get_mtd_device_nm(name);
	if (IS_ERR_OR_NULL(mtd))
		printf("MTD device %s not found, ret %ld\n", name,
		       PTR_ERR(mtd));

	return mtd;
}

static uint mtd_len_to_pages(struct mtd_info *mtd, u64 len)
{
	do_div(len, mtd->writesize);

	return len;
}

static bool mtd_is_aligned_with_min_io_size(struct mtd_info *mtd, u64 size)
{
	return !do_div(size, mtd->writesize);
}

static bool mtd_is_aligned_with_block_size(struct mtd_info *mtd, u64 size)
{
	return !do_div(size, mtd->erasesize);
}

static void mtd_dump_buf(const u8 *buf, uint len, uint offset)
{
	int i, j;

	for (i = 0; i < len; ) {
		printf("0x%08x:\t", offset + i);
		for (j = 0; j < 8; j++)
			printf("%02x ", buf[i + j]);
		printf(" ");
		i += 8;
		for (j = 0; j < 8; j++)
			printf("%02x ", buf[i + j]);
		printf("\n");
		i += 8;
	}
}

static void mtd_dump_device_buf(struct mtd_info *mtd, u64 start_off,
				const u8 *buf, u64 len, bool woob)
{
	bool has_pages = mtd->type == MTD_NANDFLASH ||
		mtd->type == MTD_MLCNANDFLASH;
	int npages = mtd_len_to_pages(mtd, len);
	uint page;

	if (has_pages) {
		for (page = 0; page < npages; page++) {
			u64 data_off = page * mtd->writesize;

			printf("\nDump %d data bytes from 0x%08llx:\n",
			       mtd->writesize, start_off + data_off);
			mtd_dump_buf(&buf[data_off],
				     mtd->writesize, start_off + data_off);

			if (woob) {
				u64 oob_off = page * mtd->oobsize;

				printf("Dump %d OOB bytes from page at 0x%08llx:\n",
				       mtd->oobsize, start_off + data_off);
				mtd_dump_buf(&buf[len + oob_off],
					     mtd->oobsize, 0);
			}
		}
	} else {
		printf("\nDump %lld data bytes from 0x%llx:\n",
		       len, start_off);
		mtd_dump_buf(buf, len, start_off);
	}
}

static void mtd_show_parts(struct mtd_info *mtd, int level)
{
	struct mtd_info *part;
	int i;

	list_for_each_entry(part, &mtd->partitions, node) {
		for (i = 0; i < level; i++)
			printf("\t");
		printf("  - 0x%012llx-0x%012llx : \"%s\"\n",
		       part->offset, part->offset + part->size, part->name);

		mtd_show_parts(part, level + 1);
	}
}

static void mtd_show_device(struct mtd_info *mtd)
{
	/* Device */
	printf("* %s\n", mtd->name);
#if defined(CONFIG_DM)
	if (mtd->dev) {
		printf("  - device: %s\n", mtd->dev->name);
		printf("  - parent: %s\n", mtd->dev->parent->name);
		printf("  - driver: %s\n", mtd->dev->driver->name);
	}
#endif
	if (IS_ENABLED(CONFIG_OF_CONTROL) && mtd->dev) {
		char buf[256];
		int res;

		res = ofnode_get_path(mtd_get_ofnode(mtd), buf, 256);
		printf("  - path: %s\n", res == 0 ? buf : "unavailable");
	}

	/* MTD device information */
	printf("  - type: ");
	switch (mtd->type) {
	case MTD_RAM:
		printf("RAM\n");
		break;
	case MTD_ROM:
		printf("ROM\n");
		break;
	case MTD_NORFLASH:
		printf("NOR flash\n");
		break;
	case MTD_NANDFLASH:
		printf("NAND flash\n");
		break;
	case MTD_DATAFLASH:
		printf("Data flash\n");
		break;
	case MTD_UBIVOLUME:
		printf("UBI volume\n");
		break;
	case MTD_MLCNANDFLASH:
		printf("MLC NAND flash\n");
		break;
	case MTD_ABSENT:
	default:
		printf("Unknown\n");
		break;
	}

	printf("  - block size: 0x%x bytes\n", mtd->erasesize);
	printf("  - min I/O: 0x%x bytes\n", mtd->writesize);

	if (mtd->oobsize) {
		printf("  - OOB size: %u bytes\n", mtd->oobsize);
		printf("  - OOB available: %u bytes\n", mtd->oobavail);
	}

	if (mtd->ecc_strength) {
		printf("  - ECC strength: %u bits\n", mtd->ecc_strength);
		printf("  - ECC step size: %u bytes\n", mtd->ecc_step_size);
		printf("  - bitflip threshold: %u bits\n",
		       mtd->bitflip_threshold);
	}

	printf("  - 0x%012llx-0x%012llx : \"%s\"\n",
	       mtd->offset, mtd->offset + mtd->size, mtd->name);

	/* MTD partitions, if any */
	mtd_show_parts(mtd, 1);
}

/* Logic taken from fs/ubifs/recovery.c:is_empty() */
static bool mtd_oob_write_is_empty(struct mtd_oob_ops *op)
{
	int i;

	for (i = 0; i < op->len; i++)
		if (op->datbuf[i] != 0xff)
			return false;

	for (i = 0; i < op->ooblen; i++)
		if (op->oobbuf[i] != 0xff)
			return false;

	return true;
}

static int do_mtd_list(struct cmd_tbl *cmdtp, int flag, int argc,
		       char *const argv[])
{
	struct mtd_info *mtd;
	int dev_nb = 0;

	/* Ensure all devices (and their partitions) are probed */
	mtd_probe_devices();

	printf("List of MTD devices:\n");
	mtd_for_each_device(mtd) {
		if (!mtd_is_partition(mtd))
			mtd_show_device(mtd);

		dev_nb++;
	}

	if (!dev_nb) {
		printf("No MTD device found\n");
		return CMD_RET_FAILURE;
	}

	return CMD_RET_SUCCESS;
}

static int mtd_special_write_oob(struct mtd_info *mtd, u64 off,
				 struct mtd_oob_ops *io_op,
				 bool write_empty_pages, bool woob)
{
	int ret = 0;

	/*
	 * By default, do not write an empty page.
	 * Skip it by simulating a successful write.
	 */
	if (!write_empty_pages && mtd_oob_write_is_empty(io_op)) {
		io_op->retlen = mtd->writesize;
		io_op->oobretlen = woob ? mtd->oobsize : 0;
	} else {
		ret = mtd_write_oob(mtd, off, io_op);
	}

	return ret;
}

static int do_mtd_io(struct cmd_tbl *cmdtp, int flag, int argc,
		     char *const argv[])
{
	bool dump, read, raw, woob, write_empty_pages, has_pages = false;
	u64 start_off, off, len, remaining, default_len;
	struct mtd_oob_ops io_op = {};
	uint user_addr = 0, npages;
	const char *cmd = argv[0];
	struct mtd_info *mtd;
	u32 oob_len;
	u8 *buf;
	int ret;

	if (argc < 2)
		return CMD_RET_USAGE;

	mtd = get_mtd_by_name(argv[1]);
	if (IS_ERR_OR_NULL(mtd))
		return CMD_RET_FAILURE;

	if (mtd->type == MTD_NANDFLASH || mtd->type == MTD_MLCNANDFLASH)
		has_pages = true;

	dump = !strncmp(cmd, "dump", 4);
	read = dump || !strncmp(cmd, "read", 4);
	raw = strstr(cmd, ".raw");
	woob = strstr(cmd, ".oob");
	write_empty_pages = !has_pages || strstr(cmd, ".dontskipff");

	argc -= 2;
	argv += 2;

	if (!dump) {
		if (!argc) {
			ret = CMD_RET_USAGE;
			goto out_put_mtd;
		}

		user_addr = hextoul(argv[0], NULL);
		argc--;
		argv++;
	}

	start_off = argc > 0 ? hextoul(argv[0], NULL) : 0;
	if (!mtd_is_aligned_with_min_io_size(mtd, start_off)) {
		printf("Offset not aligned with a page (0x%x)\n",
		       mtd->writesize);
		ret = CMD_RET_FAILURE;
		goto out_put_mtd;
	}

	default_len = dump ? mtd->writesize : mtd->size;
	len = argc > 1 ? hextoul(argv[1], NULL) : default_len;
	if (!mtd_is_aligned_with_min_io_size(mtd, len)) {
		len = round_up(len, mtd->writesize);
		printf("Size not on a page boundary (0x%x), rounding to 0x%llx\n",
		       mtd->writesize, len);
	}

	remaining = len;
	npages = mtd_len_to_pages(mtd, len);
	oob_len = woob ? npages * mtd->oobsize : 0;

	if (dump)
		buf = kmalloc(len + oob_len, GFP_KERNEL);
	else
		buf = map_sysmem(user_addr, 0);

	if (!buf) {
		printf("Could not map/allocate the user buffer\n");
		ret = CMD_RET_FAILURE;
		goto out_put_mtd;
	}

	if (has_pages)
		printf("%s %lld byte(s) (%d page(s)) at offset 0x%08llx%s%s%s\n",
		       read ? "Reading" : "Writing", len, npages, start_off,
		       raw ? " [raw]" : "", woob ? " [oob]" : "",
		       !read && write_empty_pages ? " [dontskipff]" : "");
	else
		printf("%s %lld byte(s) at offset 0x%08llx\n",
		       read ? "Reading" : "Writing", len, start_off);

	io_op.mode = raw ? MTD_OPS_RAW : MTD_OPS_AUTO_OOB;
	io_op.len = has_pages ? mtd->writesize : len;
	io_op.ooblen = woob ? mtd->oobsize : 0;
	io_op.datbuf = buf;
	io_op.oobbuf = woob ? &buf[len] : NULL;

	/* Search for the first good block after the given offset */
	off = start_off;
	while (mtd_block_isbad(mtd, off))
		off += mtd->erasesize;

	/* Loop over the pages to do the actual read/write */
	while (remaining) {
		/* Skip the block if it is bad */
		if (mtd_is_aligned_with_block_size(mtd, off) &&
		    mtd_block_isbad(mtd, off)) {
			off += mtd->erasesize;
			continue;
		}

		if (read)
			ret = mtd_read_oob(mtd, off, &io_op);
		else
			ret = mtd_special_write_oob(mtd, off, &io_op,
						    write_empty_pages, woob);

		if (ret) {
			printf("Failure while %s at offset 0x%llx\n",
			       read ? "reading" : "writing", off);
			break;
		}

		off += io_op.retlen;
		remaining -= io_op.retlen;
		io_op.datbuf += io_op.retlen;
		io_op.oobbuf += io_op.oobretlen;
	}

	if (!ret && dump)
		mtd_dump_device_buf(mtd, start_off, buf, len, woob);

	if (dump)
		kfree(buf);
	else
		unmap_sysmem(buf);

	if (ret) {
		printf("%s on %s failed with error %d\n",
		       read ? "Read" : "Write", mtd->name, ret);
		ret = CMD_RET_FAILURE;
	} else {
		ret = CMD_RET_SUCCESS;
	}

out_put_mtd:
	put_mtd_device(mtd);

	return ret;
}

static int do_mtd_erase(struct cmd_tbl *cmdtp, int flag, int argc,
			char *const argv[])
{
	struct erase_info erase_op = {};
	struct mtd_info *mtd;
	u64 off, len;
	bool scrub;
	int ret = 0;

	if (argc < 2)
		return CMD_RET_USAGE;

	mtd = get_mtd_by_name(argv[1]);
	if (IS_ERR_OR_NULL(mtd))
		return CMD_RET_FAILURE;

	scrub = strstr(argv[0], ".dontskipbad");

	argc -= 2;
	argv += 2;

	off = argc > 0 ? hextoul(argv[0], NULL) : 0;
	len = argc > 1 ? hextoul(argv[1], NULL) : mtd->size;

	if (!mtd_is_aligned_with_block_size(mtd, off)) {
		printf("Offset not aligned with a block (0x%x)\n",
		       mtd->erasesize);
		ret = CMD_RET_FAILURE;
		goto out_put_mtd;
	}

	if (!mtd_is_aligned_with_block_size(mtd, len)) {
		printf("Size not a multiple of a block (0x%x)\n",
		       mtd->erasesize);
		ret = CMD_RET_FAILURE;
		goto out_put_mtd;
	}

	printf("Erasing 0x%08llx ... 0x%08llx (%d eraseblock(s))\n",
	       off, off + len - 1, mtd_div_by_eb(len, mtd));

	erase_op.mtd = mtd;
	erase_op.addr = off;
	erase_op.len = mtd->erasesize;

	while (len) {
		if (!scrub) {
			ret = mtd_block_isbad(mtd, erase_op.addr);
			if (ret < 0) {
				printf("Failed to get bad block at 0x%08llx\n",
				       erase_op.addr);
				ret = CMD_RET_FAILURE;
				goto out_put_mtd;
			}

			if (ret > 0) {
				printf("Skipping bad block at 0x%08llx\n",
				       erase_op.addr);
				ret = 0;
				len -= mtd->erasesize;
				erase_op.addr += mtd->erasesize;
				continue;
			}
		}

		ret = mtd_erase(mtd, &erase_op);
		if (ret && ret != -EIO)
			break;

		len -= mtd->erasesize;
		erase_op.addr += mtd->erasesize;
	}

	if (ret && ret != -EIO)
		ret = CMD_RET_FAILURE;
	else
		ret = CMD_RET_SUCCESS;

out_put_mtd:
	put_mtd_device(mtd);

	return ret;
}

static int do_mtd_bad(struct cmd_tbl *cmdtp, int flag, int argc,
		      char *const argv[])
{
	struct mtd_info *mtd;
	loff_t off;

	if (argc < 2)
		return CMD_RET_USAGE;

	mtd = get_mtd_by_name(argv[1]);
	if (IS_ERR_OR_NULL(mtd))
		return CMD_RET_FAILURE;

	if (!mtd_can_have_bb(mtd)) {
		printf("Only NAND-based devices can have bad blocks\n");
		goto out_put_mtd;
	}

	printf("MTD device %s bad blocks list:\n", mtd->name);
	for (off = 0; off < mtd->size; off += mtd->erasesize) {
		if (mtd_block_isbad(mtd, off))
			printf("\t0x%08llx\n", off);
	}

out_put_mtd:
	put_mtd_device(mtd);

	return CMD_RET_SUCCESS;
}

#ifdef CONFIG_AUTO_COMPLETE
static int mtd_name_complete(int argc, char *const argv[], char last_char,
			     int maxv, char *cmdv[])
{
	int len = 0, n_found = 0;
	struct mtd_info *mtd;

	argc--;
	argv++;

	if (argc > 1 ||
	    (argc == 1 && (last_char == '\0' || isblank(last_char))))
		return 0;

	if (argc)
		len = strlen(argv[0]);

	mtd_for_each_device(mtd) {
		if (argc &&
		    (len > strlen(mtd->name) ||
		     strncmp(argv[0], mtd->name, len)))
			continue;

		if (n_found >= maxv - 2) {
			cmdv[n_found++] = "...";
			break;
		}

		cmdv[n_found++] = mtd->name;
	}

	cmdv[n_found] = NULL;

	return n_found;
}
#endif /* CONFIG_AUTO_COMPLETE */

U_BOOT_LONGHELP(mtd,
	"- generic operations on memory technology devices\n\n"
	"mtd list\n"
	"mtd read[.raw][.oob]                  <name> <addr> [<off> [<size>]]\n"
	"mtd dump[.raw][.oob]                  <name>        [<off> [<size>]]\n"
	"mtd write[.raw][.oob][.dontskipff]    <name> <addr> [<off> [<size>]]\n"
	"mtd erase[.dontskipbad]               <name>        [<off> [<size>]]\n"
	"\n"
	"Specific functions:\n"
	"mtd bad                               <name>\n"
	"\n"
	"With:\n"
	"\t<name>: NAND partition/chip name (or corresponding DM device name or OF path)\n"
	"\t<addr>: user address from/to which data will be retrieved/stored\n"
	"\t<off>: offset in <name> in bytes (default: start of the part)\n"
	"\t\t* must be block-aligned for erase\n"
	"\t\t* must be page-aligned otherwise\n"
	"\t<size>: length of the operation in bytes (default: the entire device)\n"
	"\t\t* must be a multiple of a block for erase\n"
	"\t\t* must be a multiple of a page otherwise (special case: default is a page with dump)\n"
	"\n"
	"The .dontskipff option forces writing empty pages, don't use it if unsure.\n");

U_BOOT_CMD_WITH_SUBCMDS(mtd, "MTD utils", mtd_help_text,
		U_BOOT_SUBCMD_MKENT(list, 1, 1, do_mtd_list),
		U_BOOT_SUBCMD_MKENT_COMPLETE(read, 5, 0, do_mtd_io,
					     mtd_name_complete),
		U_BOOT_SUBCMD_MKENT_COMPLETE(write, 5, 0, do_mtd_io,
					     mtd_name_complete),
		U_BOOT_SUBCMD_MKENT_COMPLETE(dump, 4, 0, do_mtd_io,
					     mtd_name_complete),
		U_BOOT_SUBCMD_MKENT_COMPLETE(erase, 4, 0, do_mtd_erase,
					     mtd_name_complete),
		U_BOOT_SUBCMD_MKENT_COMPLETE(bad, 2, 1, do_mtd_bad,
					     mtd_name_complete));
Commit	Line	Data
5db66b3a MR	1	// SPDX-License-Identifier: GPL-2.0+
	2	/*
	3	* mtd.c
	4	*
	5	* Generic command to handle basic operations on any memory device.
	6	*
	7	* Copyright: Bootlin, 2018
	8	* Author: Miquèl Raynal <[email protected]>
	9	*/
	10
	11	#include <command.h>
	12	#include <common.h>
	13	#include <console.h>
	14	#include <malloc.h>
	15	#include <mapmem.h>
	16	#include <mtd.h>
61b29b82 SG	17	#include <dm/devres.h>
61b29b82 SG	18	#include <linux/err.h>
5db66b3a	19
9671243e BB	20	#include <linux/ctype.h>
	21
	22	static struct mtd_info get_mtd_by_name(const char name)
	23	{
	24	struct mtd_info *mtd;
	25
	26	mtd_probe_devices();
	27
	28	mtd = get_mtd_device_nm(name);
	29	if (IS_ERR_OR_NULL(mtd))
	30	printf("MTD device %s not found, ret %ld\n", name,
	31	PTR_ERR(mtd));
	32
	33	return mtd;
	34	}
	35
5db66b3a MR	36	static uint mtd_len_to_pages(struct mtd_info *mtd, u64 len)
	37	{
	38	do_div(len, mtd->writesize);
	39
	40	return len;
	41	}
	42
	43	static bool mtd_is_aligned_with_min_io_size(struct mtd_info *mtd, u64 size)
	44	{
	45	return !do_div(size, mtd->writesize);
	46	}
	47
	48	static bool mtd_is_aligned_with_block_size(struct mtd_info *mtd, u64 size)
	49	{
	50	return !do_div(size, mtd->erasesize);
	51	}
	52
	53	static void mtd_dump_buf(const u8 *buf, uint len, uint offset)
	54	{
	55	int i, j;
	56
	57	for (i = 0; i < len; ) {
	58	printf("0x%08x:\t", offset + i);
	59	for (j = 0; j < 8; j++)
	60	printf("%02x ", buf[i + j]);
	61	printf(" ");
	62	i += 8;
	63	for (j = 0; j < 8; j++)
	64	printf("%02x ", buf[i + j]);
	65	printf("\n");
	66	i += 8;
	67	}
	68	}
	69
	70	static void mtd_dump_device_buf(struct mtd_info *mtd, u64 start_off,
	71	const u8 *buf, u64 len, bool woob)
	72	{
	73	bool has_pages = mtd->type == MTD_NANDFLASH \|\|
	74	mtd->type == MTD_MLCNANDFLASH;
	75	int npages = mtd_len_to_pages(mtd, len);
	76	uint page;
	77
	78	if (has_pages) {
	79	for (page = 0; page < npages; page++) {
	80	u64 data_off = page * mtd->writesize;
	81
	82	printf("\nDump %d data bytes from 0x%08llx:\n",
	83	mtd->writesize, start_off + data_off);
	84	mtd_dump_buf(&buf[data_off],
	85	mtd->writesize, start_off + data_off);
	86
	87	if (woob) {
	88	u64 oob_off = page * mtd->oobsize;
	89
	90	printf("Dump %d OOB bytes from page at 0x%08llx:\n",
	91	mtd->oobsize, start_off + data_off);
	92	mtd_dump_buf(&buf[len + oob_off],
	93	mtd->oobsize, 0);
	94	}
	95	}
	96	} else {
	97	printf("\nDump %lld data bytes from 0x%llx:\n",
	98	len, start_off);
	99	mtd_dump_buf(buf, len, start_off);
100	}
101	}
102
103	static void mtd_show_parts(struct mtd_info *mtd, int level)
104	{
105	struct mtd_info *part;
106	int i;
107
108	list_for_each_entry(part, &mtd->partitions, node) {
109	for (i = 0; i < level; i++)
110	printf("\t");
111	printf(" - 0x%012llx-0x%012llx : \"%s\"\n",
112	part->offset, part->offset + part->size, part->name);
113
114	mtd_show_parts(part, level + 1);
115	}
116	}
117
118	static void mtd_show_device(struct mtd_info *mtd)
119	{
120	/* Device */
121	printf("* %s\n", mtd->name);
122	#if defined(CONFIG_DM)
123	if (mtd->dev) {
124	printf(" - device: %s\n", mtd->dev->name);
125	printf(" - parent: %s\n", mtd->dev->parent->name);
126	printf(" - driver: %s\n", mtd->dev->driver->name);
127	}
128	#endif
0b6f907d MB	129	if (IS_ENABLED(CONFIG_OF_CONTROL) && mtd->dev) {
	130	char buf[256];
	131	int res;
	132
	133	res = ofnode_get_path(mtd_get_ofnode(mtd), buf, 256);
	134	printf(" - path: %s\n", res == 0 ? buf : "unavailable");
	135	}
5db66b3a MR	136
	137	/* MTD device information */
	138	printf(" - type: ");
	139	switch (mtd->type) {
	140	case MTD_RAM:
	141	printf("RAM\n");
	142	break;
	143	case MTD_ROM:
	144	printf("ROM\n");
	145	break;
	146	case MTD_NORFLASH:
	147	printf("NOR flash\n");
	148	break;
	149	case MTD_NANDFLASH:
	150	printf("NAND flash\n");
	151	break;
	152	case MTD_DATAFLASH:
	153	printf("Data flash\n");
	154	break;
	155	case MTD_UBIVOLUME:
	156	printf("UBI volume\n");
	157	break;
	158	case MTD_MLCNANDFLASH:
	159	printf("MLC NAND flash\n");
	160	break;
	161	case MTD_ABSENT:
	162	default:
	163	printf("Unknown\n");
	164	break;
	165	}
	166
	167	printf(" - block size: 0x%x bytes\n", mtd->erasesize);
	168	printf(" - min I/O: 0x%x bytes\n", mtd->writesize);
	169
	170	if (mtd->oobsize) {
	171	printf(" - OOB size: %u bytes\n", mtd->oobsize);
	172	printf(" - OOB available: %u bytes\n", mtd->oobavail);
	173	}
	174
	175	if (mtd->ecc_strength) {
	176	printf(" - ECC strength: %u bits\n", mtd->ecc_strength);
	177	printf(" - ECC step size: %u bytes\n", mtd->ecc_step_size);
	178	printf(" - bitflip threshold: %u bits\n",
	179	mtd->bitflip_threshold);
	180	}
	181
	182	printf(" - 0x%012llx-0x%012llx : \"%s\"\n",
	183	mtd->offset, mtd->offset + mtd->size, mtd->name);
	184
	185	/* MTD partitions, if any */
	186	mtd_show_parts(mtd, 1);
	187	}
	188
	189	/* Logic taken from fs/ubifs/recovery.c:is_empty() */
	190	static bool mtd_oob_write_is_empty(struct mtd_oob_ops *op)
	191	{
	192	int i;
	193
	194	for (i = 0; i < op->len; i++)
	195	if (op->datbuf[i] != 0xff)
	196	return false;
	197
	198	for (i = 0; i < op->ooblen; i++)
	199	if (op->oobbuf[i] != 0xff)
200	return false;
201
202	return true;
203	}
204
09140113 SG	205	static int do_mtd_list(struct cmd_tbl *cmdtp, int flag, int argc,
09140113 SG	206	char *const argv[])
5db66b3a MR	207	{
	208	struct mtd_info *mtd;
	209	int dev_nb = 0;
	210
	211	/* Ensure all devices (and their partitions) are probed */
	212	mtd_probe_devices();
	213
	214	printf("List of MTD devices:\n");
	215	mtd_for_each_device(mtd) {
	216	if (!mtd_is_partition(mtd))
	217	mtd_show_device(mtd);
	218
	219	dev_nb++;
	220	}
	221
	222	if (!dev_nb) {
	223	printf("No MTD device found\n");
	224	return CMD_RET_FAILURE;
	225	}
	226
	227	return CMD_RET_SUCCESS;
	228	}
	229
	230	static int mtd_special_write_oob(struct mtd_info *mtd, u64 off,
	231	struct mtd_oob_ops *io_op,
	232	bool write_empty_pages, bool woob)
	233	{
	234	int ret = 0;
	235
	236	/*
	237	* By default, do not write an empty page.
	238	* Skip it by simulating a successful write.
	239	*/
	240	if (!write_empty_pages && mtd_oob_write_is_empty(io_op)) {
	241	io_op->retlen = mtd->writesize;
	242	io_op->oobretlen = woob ? mtd->oobsize : 0;
	243	} else {
	244	ret = mtd_write_oob(mtd, off, io_op);
	245	}
	246
	247	return ret;
	248	}
	249
09140113 SG	250	static int do_mtd_io(struct cmd_tbl *cmdtp, int flag, int argc,
09140113 SG	251	char *const argv[])
5db66b3a	252	{
9671243e BB	253	bool dump, read, raw, woob, write_empty_pages, has_pages = false;
	254	u64 start_off, off, len, remaining, default_len;
	255	struct mtd_oob_ops io_op = {};
	256	uint user_addr = 0, npages;
	257	const char *cmd = argv[0];
5db66b3a	258	struct mtd_info *mtd;
9671243e BB	259	u32 oob_len;
	260	u8 *buf;
	261	int ret;
5db66b3a	262
5db66b3a MR	263	if (argc < 2)
	264	return CMD_RET_USAGE;
	265
9671243e BB	266	mtd = get_mtd_by_name(argv[1]);
	267	if (IS_ERR_OR_NULL(mtd))
	268	return CMD_RET_FAILURE;
5db66b3a	269
9671243e BB	270	if (mtd->type == MTD_NANDFLASH \|\| mtd->type == MTD_MLCNANDFLASH)
9671243e BB	271	has_pages = true;
5db66b3a	272
9671243e BB	273	dump = !strncmp(cmd, "dump", 4);
	274	read = dump \|\| !strncmp(cmd, "read", 4);
	275	raw = strstr(cmd, ".raw");
	276	woob = strstr(cmd, ".oob");
	277	write_empty_pages = !has_pages \|\| strstr(cmd, ".dontskipff");
5db66b3a	278
9671243e BB	279	argc -= 2;
9671243e BB	280	argv += 2;
5db66b3a	281
9671243e BB	282	if (!dump) {
	283	if (!argc) {
	284	ret = CMD_RET_USAGE;
	285	goto out_put_mtd;
5db66b3a MR	286	}
5db66b3a MR	287
7e5f460e	288	user_addr = hextoul(argv[0], NULL);
9671243e BB	289	argc--;
	290	argv++;
	291	}
5db66b3a	292
7e5f460e	293	start_off = argc > 0 ? hextoul(argv[0], NULL) : 0;
9671243e BB	294	if (!mtd_is_aligned_with_min_io_size(mtd, start_off)) {
	295	printf("Offset not aligned with a page (0x%x)\n",
	296	mtd->writesize);
	297	ret = CMD_RET_FAILURE;
	298	goto out_put_mtd;
	299	}
5db66b3a	300
9671243e	301	default_len = dump ? mtd->writesize : mtd->size;
7e5f460e	302	len = argc > 1 ? hextoul(argv[1], NULL) : default_len;
9671243e BB	303	if (!mtd_is_aligned_with_min_io_size(mtd, len)) {
	304	len = round_up(len, mtd->writesize);
	305	printf("Size not on a page boundary (0x%x), rounding to 0x%llx\n",
	306	mtd->writesize, len);
	307	}
5db66b3a	308
9671243e BB	309	remaining = len;
	310	npages = mtd_len_to_pages(mtd, len);
	311	oob_len = woob ? npages * mtd->oobsize : 0;
5db66b3a	312
9671243e BB	313	if (dump)
	314	buf = kmalloc(len + oob_len, GFP_KERNEL);
	315	else
	316	buf = map_sysmem(user_addr, 0);
	317
	318	if (!buf) {
	319	printf("Could not map/allocate the user buffer\n");
	320	ret = CMD_RET_FAILURE;
	321	goto out_put_mtd;
	322	}
	323
	324	if (has_pages)
	325	printf("%s %lld byte(s) (%d page(s)) at offset 0x%08llx%s%s%s\n",
	326	read ? "Reading" : "Writing", len, npages, start_off,
	327	raw ? " [raw]" : "", woob ? " [oob]" : "",
	328	!read && write_empty_pages ? " [dontskipff]" : "");
	329	else
	330	printf("%s %lld byte(s) at offset 0x%08llx\n",
	331	read ? "Reading" : "Writing", len, start_off);
	332
	333	io_op.mode = raw ? MTD_OPS_RAW : MTD_OPS_AUTO_OOB;
	334	io_op.len = has_pages ? mtd->writesize : len;
	335	io_op.ooblen = woob ? mtd->oobsize : 0;
	336	io_op.datbuf = buf;
	337	io_op.oobbuf = woob ? &buf[len] : NULL;
	338
	339	/* Search for the first good block after the given offset */
	340	off = start_off;
	341	while (mtd_block_isbad(mtd, off))
	342	off += mtd->erasesize;
	343
	344	/* Loop over the pages to do the actual read/write */
	345	while (remaining) {
	346	/* Skip the block if it is bad */
	347	if (mtd_is_aligned_with_block_size(mtd, off) &&
	348	mtd_block_isbad(mtd, off)) {
	349	off += mtd->erasesize;
	350	continue;
5db66b3a MR	351	}
5db66b3a MR	352
9671243e BB	353	if (read)
9671243e BB	354	ret = mtd_read_oob(mtd, off, &io_op);
5db66b3a	355	else
9671243e BB	356	ret = mtd_special_write_oob(mtd, off, &io_op,
9671243e BB	357	write_empty_pages, woob);
5db66b3a	358
9671243e BB	359	if (ret) {
	360	printf("Failure while %s at offset 0x%llx\n",
	361	read ? "reading" : "writing", off);
	362	break;
	363	}
5db66b3a	364
9671243e BB	365	off += io_op.retlen;
	366	remaining -= io_op.retlen;
	367	io_op.datbuf += io_op.retlen;
	368	io_op.oobbuf += io_op.oobretlen;
	369	}
5db66b3a	370
9671243e BB	371	if (!ret && dump)
9671243e BB	372	mtd_dump_device_buf(mtd, start_off, buf, len, woob);
5db66b3a	373
9671243e BB	374	if (dump)
	375	kfree(buf);
	376	else
	377	unmap_sysmem(buf);
5db66b3a	378
9671243e BB	379	if (ret) {
	380	printf("%s on %s failed with error %d\n",
	381	read ? "Read" : "Write", mtd->name, ret);
	382	ret = CMD_RET_FAILURE;
	383	} else {
	384	ret = CMD_RET_SUCCESS;
	385	}
5db66b3a	386
9671243e BB	387	out_put_mtd:
9671243e BB	388	put_mtd_device(mtd);
5db66b3a	389
9671243e BB	390	return ret;
9671243e BB	391	}
5db66b3a	392
09140113 SG	393	static int do_mtd_erase(struct cmd_tbl *cmdtp, int flag, int argc,
09140113 SG	394	char *const argv[])
9671243e BB	395	{
	396	struct erase_info erase_op = {};
	397	struct mtd_info *mtd;
	398	u64 off, len;
	399	bool scrub;
b1b147f2	400	int ret = 0;
5db66b3a	401
9671243e BB	402	if (argc < 2)
9671243e BB	403	return CMD_RET_USAGE;
5db66b3a	404
9671243e BB	405	mtd = get_mtd_by_name(argv[1]);
	406	if (IS_ERR_OR_NULL(mtd))
	407	return CMD_RET_FAILURE;
5db66b3a	408
9671243e	409	scrub = strstr(argv[0], ".dontskipbad");
5db66b3a	410
9671243e BB	411	argc -= 2;
9671243e BB	412	argv += 2;
5db66b3a	413
7e5f460e SG	414	off = argc > 0 ? hextoul(argv[0], NULL) : 0;
7e5f460e SG	415	len = argc > 1 ? hextoul(argv[1], NULL) : mtd->size;
5db66b3a	416
9671243e BB	417	if (!mtd_is_aligned_with_block_size(mtd, off)) {
	418	printf("Offset not aligned with a block (0x%x)\n",
	419	mtd->erasesize);
	420	ret = CMD_RET_FAILURE;
	421	goto out_put_mtd;
	422	}
5db66b3a	423
9671243e BB	424	if (!mtd_is_aligned_with_block_size(mtd, len)) {
	425	printf("Size not a multiple of a block (0x%x)\n",
	426	mtd->erasesize);
	427	ret = CMD_RET_FAILURE;
	428	goto out_put_mtd;
	429	}
5db66b3a	430
9671243e BB	431	printf("Erasing 0x%08llx ... 0x%08llx (%d eraseblock(s))\n",
9671243e BB	432	off, off + len - 1, mtd_div_by_eb(len, mtd));
5db66b3a	433
9671243e BB	434	erase_op.mtd = mtd;
9671243e BB	435	erase_op.addr = off;
b1b147f2	436	erase_op.len = mtd->erasesize;
5db66b3a	437
b1b147f2	438	while (len) {
d09807ad DB	439	if (!scrub) {
	440	ret = mtd_block_isbad(mtd, erase_op.addr);
	441	if (ret < 0) {
	442	printf("Failed to get bad block at 0x%08llx\n",
	443	erase_op.addr);
	444	ret = CMD_RET_FAILURE;
	445	goto out_put_mtd;
	446	}
5db66b3a	447
d09807ad DB	448	if (ret > 0) {
	449	printf("Skipping bad block at 0x%08llx\n",
	450	erase_op.addr);
	451	ret = 0;
	452	len -= mtd->erasesize;
	453	erase_op.addr += mtd->erasesize;
	454	continue;
	455	}
b1b147f2	456	}
9671243e	457
d09807ad DB	458	ret = mtd_erase(mtd, &erase_op);
	459	if (ret && ret != -EIO)
	460	break;
	461
b1b147f2 PD	462	len -= mtd->erasesize;
b1b147f2 PD	463	erase_op.addr += mtd->erasesize;
9671243e BB	464	}
	465
	466	if (ret && ret != -EIO)
	467	ret = CMD_RET_FAILURE;
	468	else
	469	ret = CMD_RET_SUCCESS;
	470
	471	out_put_mtd:
	472	put_mtd_device(mtd);
	473
	474	return ret;
	475	}
	476
09140113 SG	477	static int do_mtd_bad(struct cmd_tbl *cmdtp, int flag, int argc,
09140113 SG	478	char *const argv[])
9671243e BB	479	{
	480	struct mtd_info *mtd;
	481	loff_t off;
	482
	483	if (argc < 2)
5db66b3a	484	return CMD_RET_USAGE;
9671243e BB	485
	486	mtd = get_mtd_by_name(argv[1]);
	487	if (IS_ERR_OR_NULL(mtd))
	488	return CMD_RET_FAILURE;
	489
	490	if (!mtd_can_have_bb(mtd)) {
	491	printf("Only NAND-based devices can have bad blocks\n");
	492	goto out_put_mtd;
	493	}
	494
	495	printf("MTD device %s bad blocks list:\n", mtd->name);
	496	for (off = 0; off < mtd->size; off += mtd->erasesize) {
	497	if (mtd_block_isbad(mtd, off))
	498	printf("\t0x%08llx\n", off);
5db66b3a MR	499	}
5db66b3a MR	500
9671243e BB	501	out_put_mtd:
	502	put_mtd_device(mtd);
	503
5db66b3a MR	504	return CMD_RET_SUCCESS;
	505	}
	506
9671243e	507	#ifdef CONFIG_AUTO_COMPLETE
09140113	508	static int mtd_name_complete(int argc, char *const argv[], char last_char,
9671243e BB	509	int maxv, char *cmdv[])
	510	{
	511	int len = 0, n_found = 0;
	512	struct mtd_info *mtd;
	513
	514	argc--;
	515	argv++;
	516
	517	if (argc > 1 \|\|
	518	(argc == 1 && (last_char == '\0' \|\| isblank(last_char))))
	519	return 0;
	520
	521	if (argc)
	522	len = strlen(argv[0]);
	523
	524	mtd_for_each_device(mtd) {
	525	if (argc &&
	526	(len > strlen(mtd->name) \|\|
	527	strncmp(argv[0], mtd->name, len)))
	528	continue;
	529
	530	if (n_found >= maxv - 2) {
	531	cmdv[n_found++] = "...";
	532	break;
	533	}
	534
	535	cmdv[n_found++] = mtd->name;
	536	}
	537
	538	cmdv[n_found] = NULL;
	539
	540	return n_found;
	541	}
	542	#endif /* CONFIG_AUTO_COMPLETE */
	543
3616218b	544	U_BOOT_LONGHELP(mtd,
5db66b3a MR	545	"- generic operations on memory technology devices\n\n"
	546	"mtd list\n"
	547	"mtd read[.raw][.oob] <name> <addr> [<off> [<size>]]\n"
	548	"mtd dump[.raw][.oob] <name> [<off> [<size>]]\n"
	549	"mtd write[.raw][.oob][.dontskipff] <name> <addr> [<off> [<size>]]\n"
	550	"mtd erase[.dontskipbad] <name> [<off> [<size>]]\n"
	551	"\n"
	552	"Specific functions:\n"
	553	"mtd bad <name>\n"
	554	"\n"
	555	"With:\n"
e41a2bc6	556	"\t<name>: NAND partition/chip name (or corresponding DM device name or OF path)\n"
5db66b3a MR	557	"\t<addr>: user address from/to which data will be retrieved/stored\n"
	558	"\t<off>: offset in <name> in bytes (default: start of the part)\n"
	559	"\t\t* must be block-aligned for erase\n"
	560	"\t\t* must be page-aligned otherwise\n"
	561	"\t<size>: length of the operation in bytes (default: the entire device)\n"
	562	"\t\t* must be a multiple of a block for erase\n"
	563	"\t\t* must be a multiple of a page otherwise (special case: default is a page with dump)\n"
	564	"\n"
3616218b	565	"The .dontskipff option forces writing empty pages, don't use it if unsure.\n");
5db66b3a	566
9671243e BB	567	U_BOOT_CMD_WITH_SUBCMDS(mtd, "MTD utils", mtd_help_text,
	568	U_BOOT_SUBCMD_MKENT(list, 1, 1, do_mtd_list),
	569	U_BOOT_SUBCMD_MKENT_COMPLETE(read, 5, 0, do_mtd_io,
	570	mtd_name_complete),
	571	U_BOOT_SUBCMD_MKENT_COMPLETE(write, 5, 0, do_mtd_io,
	572	mtd_name_complete),
	573	U_BOOT_SUBCMD_MKENT_COMPLETE(dump, 4, 0, do_mtd_io,
	574	mtd_name_complete),
	575	U_BOOT_SUBCMD_MKENT_COMPLETE(erase, 4, 0, do_mtd_erase,
	576	mtd_name_complete),
	577	U_BOOT_SUBCMD_MKENT_COMPLETE(bad, 2, 1, do_mtd_bad,
	578	mtd_name_complete));