[people/ms/u-boot.git] / common / cmd_onenand.c

/*
 *  U-Boot command for OneNAND support
 *
 *  Copyright (C) 2005-2008 Samsung Electronics
 *  Kyungmin Park <kyungmin.park@samsung.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

#include <common.h>
#include <command.h>
#include <malloc.h>

#include <linux/mtd/compat.h>
#include <linux/mtd/mtd.h>
#include <linux/mtd/onenand.h>

#include <asm/io.h>

#if !defined(CONFIG_SYS_64BIT_VSPRINTF)
#warning Please define CONFIG_SYS_64BIT_VSPRINTF for correct output!
#endif

static struct mtd_info *mtd;

static loff_t next_ofs;
static loff_t skip_ofs;

static inline int str2long(char *p, ulong *num)
{
	char *endptr;

	*num = simple_strtoul(p, &endptr, 16);
	return (*p != '\0' && *endptr == '\0') ? 1 : 0;
}

static int arg_off_size(int argc, char *argv[], ulong *off, size_t *size)
{
	if (argc >= 1) {
		if (!(str2long(argv[0], off))) {
			printf("'%s' is not a number\n", argv[0]);
			return -1;
		}
	} else {
		*off = 0;
	}

	if (argc >= 2) {
		if (!(str2long(argv[1], (ulong *)size))) {
			printf("'%s' is not a number\n", argv[1]);
			return -1;
		}
	} else {
		*size = mtd->size - *off;
	}

	if ((*off + *size) > mtd->size) {
		printf("total chip size (0x%llx) exceeded!\n", mtd->size);
		return -1;
	}

	if (*size == mtd->size)
		puts("whole chip\n");
	else
		printf("offset 0x%lx, size 0x%x\n", *off, *size);

	return 0;
}

static int onenand_block_read(loff_t from, size_t len,
			      size_t *retlen, u_char *buf, int oob)
{
	struct onenand_chip *this = mtd->priv;
	int blocks = (int) len >> this->erase_shift;
	int blocksize = (1 << this->erase_shift);
	loff_t ofs = from;
	struct mtd_oob_ops ops = {
		.retlen		= 0,
	};
	int ret;

	if (oob)
		ops.ooblen = blocksize;
	else
		ops.len = blocksize;

	while (blocks) {
		ret = mtd->block_isbad(mtd, ofs);
		if (ret) {
			printk("Bad blocks %d at 0x%x\n",
			       (u32)(ofs >> this->erase_shift), (u32)ofs);
			ofs += blocksize;
			continue;
		}

		if (oob)
			ops.oobbuf = buf;
		else
			ops.datbuf = buf;

		ops.retlen = 0;
		ret = mtd->read_oob(mtd, ofs, &ops);
		if (ret) {
			printk("Read failed 0x%x, %d\n", (u32)ofs, ret);
			ofs += blocksize;
			continue;
		}
		ofs += blocksize;
		buf += blocksize;
		blocks--;
		*retlen += ops.retlen;
	}

	return 0;
}

static int onenand_block_write(loff_t to, size_t len,
			       size_t *retlen, const u_char * buf)
{
	struct onenand_chip *this = mtd->priv;
	int blocks = len >> this->erase_shift;
	int blocksize = (1 << this->erase_shift);
	loff_t ofs;
	size_t _retlen = 0;
	int ret;

	if (to == next_ofs) {
		next_ofs = to + len;
		to += skip_ofs;
	} else {
		next_ofs = to + len;
		skip_ofs = 0;
	}
	ofs = to;

	while (blocks) {
		ret = mtd->block_isbad(mtd, ofs);
		if (ret) {
			printk("Bad blocks %d at 0x%x\n",
			       (u32)(ofs >> this->erase_shift), (u32)ofs);
			skip_ofs += blocksize;
			goto next;
		}

		ret = mtd->write(mtd, ofs, blocksize, &_retlen, buf);
		if (ret) {
			printk("Write failed 0x%x, %d", (u32)ofs, ret);
			skip_ofs += blocksize;
			goto next;
		}

		buf += blocksize;
		blocks--;
		*retlen += _retlen;
next:
		ofs += blocksize;
	}

	return 0;
}

static int onenand_block_erase(u32 start, u32 size, int force)
{
	struct onenand_chip *this = mtd->priv;
	struct erase_info instr = {
		.callback	= NULL,
	};
	loff_t ofs;
	int ret;
	int blocksize = 1 << this->erase_shift;

	for (ofs = start; ofs < (start + size); ofs += blocksize) {
		ret = mtd->block_isbad(mtd, ofs);
		if (ret && !force) {
			printf("Skip erase bad block %d at 0x%x\n",
			       (u32)(ofs >> this->erase_shift), (u32)ofs);
			continue;
		}

		instr.addr = ofs;
		instr.len = blocksize;
		instr.priv = force;
		instr.mtd = mtd;
		ret = mtd->erase(mtd, &instr);
		if (ret) {
			printf("erase failed block %d at 0x%x\n",
			       (u32)(ofs >> this->erase_shift), (u32)ofs);
			continue;
		}
	}

	return 0;
}

static int onenand_block_test(u32 start, u32 size)
{
	struct onenand_chip *this = mtd->priv;
	struct erase_info instr = {
		.callback	= NULL,
		.priv		= 0,
	};

	int blocks;
	loff_t ofs;
	int blocksize = 1 << this->erase_shift;
	int start_block, end_block;
	size_t retlen;
	u_char *buf;
	u_char *verify_buf;
	int ret;

	buf = malloc(blocksize);
	if (!buf) {
		printf("Not enough malloc space available!\n");
		return -1;
	}

	verify_buf = malloc(blocksize);
	if (!verify_buf) {
		printf("Not enough malloc space available!\n");
		return -1;
	}

	start_block = start >> this->erase_shift;
	end_block = (start + size) >> this->erase_shift;

	/* Protect boot-loader from badblock testing */
	if (start_block < 2)
		start_block = 2;

	if (end_block > (mtd->size >> this->erase_shift))
		end_block = mtd->size >> this->erase_shift;

	blocks = start_block;
	ofs = start;
	while (blocks < end_block) {
		printf("\rTesting block %d at 0x%x", (u32)(ofs >> this->erase_shift), (u32)ofs);

		ret = mtd->block_isbad(mtd, ofs);
		if (ret) {
			printf("Skip erase bad block %d at 0x%x\n",
			       (u32)(ofs >> this->erase_shift), (u32)ofs);
			goto next;
		}

		instr.addr = ofs;
		instr.len = blocksize;
		ret = mtd->erase(mtd, &instr);
		if (ret) {
			printk("Erase failed 0x%x, %d\n", (u32)ofs, ret);
			goto next;
		}

		ret = mtd->write(mtd, ofs, blocksize, &retlen, buf);
		if (ret) {
			printk("Write failed 0x%x, %d\n", (u32)ofs, ret);
			goto next;
		}

		ret = mtd->read(mtd, ofs, blocksize, &retlen, verify_buf);
		if (ret) {
			printk("Read failed 0x%x, %d\n", (u32)ofs, ret);
			goto next;
		}

		if (memcmp(buf, verify_buf, blocksize))
			printk("\nRead/Write test failed at 0x%x\n", (u32)ofs);

next:
		ofs += blocksize;
		blocks++;
	}
	printf("...Done\n");

	free(buf);
	free(verify_buf);

	return 0;
}

static int onenand_dump(struct mtd_info *mtd, ulong off, int only_oob)
{
	int i;
	u_char *datbuf, *oobbuf, *p;
	struct mtd_oob_ops ops;
	loff_t addr;

	datbuf = malloc(mtd->writesize + mtd->oobsize);
	oobbuf = malloc(mtd->oobsize);
	if (!datbuf || !oobbuf) {
		puts("No memory for page buffer\n");
		return 1;
	}
	off &= ~(mtd->writesize - 1);
	addr = (loff_t) off;
	memset(&ops, 0, sizeof(ops));
	ops.datbuf = datbuf;
	ops.oobbuf = oobbuf; /* must exist, but oob data will be appended to ops.datbuf */
	ops.len = mtd->writesize;
	ops.ooblen = mtd->oobsize;
	ops.retlen = 0;
	i = mtd->read_oob(mtd, addr, &ops);
	if (i < 0) {
		printf("Error (%d) reading page %08lx\n", i, off);
		free(datbuf);
		free(oobbuf);
		return 1;
	}
	printf("Page %08lx dump:\n", off);
	i = mtd->writesize >> 4;
	p = datbuf;

	while (i--) {
		if (!only_oob)
			printf("\t%02x %02x %02x %02x %02x %02x %02x %02x"
			       "  %02x %02x %02x %02x %02x %02x %02x %02x\n",
			       p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7],
			       p[8], p[9], p[10], p[11], p[12], p[13], p[14],
			       p[15]);
		p += 16;
	}
	puts("OOB:\n");
	i = mtd->oobsize >> 3;
	while (i--) {
		printf("\t%02x %02x %02x %02x %02x %02x %02x %02x\n",
		       p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]);
		p += 8;
	}
	free(datbuf);
	free(oobbuf);

	return 0;
}

int do_onenand(cmd_tbl_t * cmdtp, int flag, int argc, char *argv[])
{
	struct onenand_chip *this;
	int blocksize;
	ulong addr, ofs;
	size_t len, retlen = 0;
	int ret;
	char *cmd, *s;

	mtd = &onenand_mtd;
	this = mtd->priv;
	blocksize = (1 << this->erase_shift);

	cmd = argv[1];

	switch (argc) {
	case 0:
	case 1:
		goto usage;

	case 2:
		if (strcmp(cmd, "info") == 0) {
			printf("%s\n", mtd->name);
			return 0;
		}

		if (strcmp(cmd, "bad") == 0) {
			/* Currently only one OneNAND device is supported */
			printf("\nDevice %d bad blocks:\n", 0);
			for (ofs = 0; ofs < mtd->size; ofs += mtd->erasesize) {
				if (mtd->block_isbad(mtd, ofs))
					printf("  %08x\n", (u32)ofs);
			}

			return 0;
		}

	default:
		/* At least 4 args */

		/*
		 * Syntax is:
		 *   0       1     2       3    4
		 *   onenand erase [force] [off size]
		 */
		if ((strcmp(cmd, "erase") == 0) || (strcmp(cmd, "test") == 0)) {
			int force = argc > 2 && !strcmp("force", argv[2]);
			int o = force ? 3 : 2;
			int erase;

			erase = strcmp(cmd, "erase") == 0; /* 1 = erase, 0 = test */
			printf("\nOneNAND %s: ", erase ? "erase" : "test");

			/* skip first two or three arguments, look for offset and size */
			if (arg_off_size(argc - o, argv + o, &ofs, &len) != 0)
				return 1;

			if (erase)
				ret = onenand_block_erase(ofs, len, force);
			else
				ret = onenand_block_test(ofs, len);

			printf("%s\n", ret ? "ERROR" : "OK");

			return ret == 0 ? 0 : 1;
		}

		if (strncmp(cmd, "read", 4) == 0 || strncmp(cmd, "write", 5) == 0) {
			int read;
			int oob = 0;

			if (argc < 4)
				goto usage;

			addr = (ulong)simple_strtoul(argv[2], NULL, 16);

			read = strncmp(cmd, "read", 4) == 0; /* 1 = read, 0 = write */
			printf("\nOneNAND %s: ", read ? "read" : "write");
			if (arg_off_size(argc - 3, argv + 3, &ofs, &len) != 0)
				return 1;

			s = strchr(cmd, '.');
			if ((s != NULL) && (!strcmp(s, ".oob")))
				oob = 1;

			if (read) {
				ret = onenand_block_read(ofs, len, &retlen,
							 (u8 *)addr, oob);
			} else {
				ret = onenand_block_write(ofs, len, &retlen,
							  (u8 *)addr);
			}

			printf(" %d bytes %s: %s\n", retlen,
			       read ? "read" : "written", ret ? "ERROR" : "OK");

			return ret == 0 ? 0 : 1;
		}

		if (strcmp(cmd, "markbad") == 0) {
			addr = (ulong)simple_strtoul(argv[2], NULL, 16);

			int ret = mtd->block_markbad(mtd, addr);
			if (ret == 0) {
				printf("block 0x%08lx successfully marked as bad\n",
						(ulong) addr);
				return 0;
			} else {
				printf("block 0x%08lx NOT marked as bad! ERROR %d\n",
						(ulong) addr, ret);
			}
			return 1;
		}

		if (strncmp(cmd, "dump", 4) == 0) {
			if (argc < 3)
				goto usage;

			s = strchr(cmd, '.');
			ofs = (int)simple_strtoul(argv[2], NULL, 16);

			if (s != NULL && strcmp(s, ".oob") == 0)
				ret = onenand_dump(mtd, ofs, 1);
			else
				ret = onenand_dump(mtd, ofs, 0);

			return ret == 0 ? 1 : 0;
		}

		break;
	}

	return 0;

usage:
	cmd_usage(cmdtp);
	return 1;
}

U_BOOT_CMD(
	onenand,	6,	1,	do_onenand,
	"OneNAND sub-system",
	"info - show available OneNAND devices\n"
	"onenand bad - show bad blocks\n"
	"onenand read[.oob] addr off size\n"
	"onenand write[.oob] addr off size\n"
	"    read/write 'size' bytes starting at offset 'off'\n"
	"    to/from memory address 'addr', skipping bad blocks.\n"
	"onenand erase [force] [off size] - erase 'size' bytes from\n"
	"onenand test [off size] - test 'size' bytes from\n"
	"    offset 'off' (entire device if not specified)\n"
	"onenand dump[.oob] off - dump page\n"
	"onenand markbad off [...] - mark bad block(s) at offset (UNSAFE)"
);
Commit	Line	Data
d7e8ce10 KP	1	/*
	2	* U-Boot command for OneNAND support
	3	*
c438ea17	4	* Copyright (C) 2005-2008 Samsung Electronics
d7e8ce10 KP	5	* Kyungmin Park <kyungmin.park@samsung.com>
	6	*
	7	* This program is free software; you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License version 2 as
	9	* published by the Free Software Foundation.
	10	*/
	11
	12	#include <common.h>
	13	#include <command.h>
c438ea17	14	#include <malloc.h>
d7e8ce10	15
d7e8ce10 KP	16	#include <linux/mtd/compat.h>
	17	#include <linux/mtd/mtd.h>
	18	#include <linux/mtd/onenand.h>
	19
	20	#include <asm/io.h>
	21
8d2effea SR	22	#if !defined(CONFIG_SYS_64BIT_VSPRINTF)
	23	#warning Please define CONFIG_SYS_64BIT_VSPRINTF for correct output!
	24	#endif
	25
c438ea17 SR	26	static struct mtd_info *mtd;
	27
	28	static loff_t next_ofs;
	29	static loff_t skip_ofs;
	30
	31	static inline int str2long(char p, ulong num)
	32	{
	33	char *endptr;
	34
	35	*num = simple_strtoul(p, &endptr, 16);
	36	return (p != '\0' && endptr == '\0') ? 1 : 0;
	37	}
	38
	39	static int arg_off_size(int argc, char argv[], ulong off, size_t *size)
	40	{
	41	if (argc >= 1) {
	42	if (!(str2long(argv[0], off))) {
	43	printf("'%s' is not a number\n", argv[0]);
	44	return -1;
	45	}
	46	} else {
	47	*off = 0;
	48	}
	49
	50	if (argc >= 2) {
	51	if (!(str2long(argv[1], (ulong *)size))) {
	52	printf("'%s' is not a number\n", argv[1]);
	53	return -1;
	54	}
	55	} else {
	56	size = mtd->size - off;
	57	}
	58
	59	if ((off + size) > mtd->size) {
8d2effea	60	printf("total chip size (0x%llx) exceeded!\n", mtd->size);
c438ea17 SR	61	return -1;
	62	}
	63
	64	if (*size == mtd->size)
	65	puts("whole chip\n");
	66	else
	67	printf("offset 0x%lx, size 0x%x\n", off, size);
	68
	69	return 0;
	70	}
	71
	72	static int onenand_block_read(loff_t from, size_t len,
	73	size_t retlen, u_char buf, int oob)
	74	{
	75	struct onenand_chip *this = mtd->priv;
	76	int blocks = (int) len >> this->erase_shift;
	77	int blocksize = (1 << this->erase_shift);
	78	loff_t ofs = from;
	79	struct mtd_oob_ops ops = {
	80	.retlen = 0,
	81	};
	82	int ret;
	83
	84	if (oob)
	85	ops.ooblen = blocksize;
	86	else
	87	ops.len = blocksize;
	88
	89	while (blocks) {
	90	ret = mtd->block_isbad(mtd, ofs);
	91	if (ret) {
	92	printk("Bad blocks %d at 0x%x\n",
	93	(u32)(ofs >> this->erase_shift), (u32)ofs);
	94	ofs += blocksize;
	95	continue;
	96	}
	97
	98	if (oob)
	99	ops.oobbuf = buf;
	100	else
	101	ops.datbuf = buf;
	102
	103	ops.retlen = 0;
	104	ret = mtd->read_oob(mtd, ofs, &ops);
	105	if (ret) {
	106	printk("Read failed 0x%x, %d\n", (u32)ofs, ret);
	107	ofs += blocksize;
	108	continue;
	109	}
	110	ofs += blocksize;
	111	buf += blocksize;
	112	blocks--;
	113	*retlen += ops.retlen;
	114	}
	115
	116	return 0;
	117	}
	118
	119	static int onenand_block_write(loff_t to, size_t len,
	120	size_t retlen, const u_char buf)
	121	{
	122	struct onenand_chip *this = mtd->priv;
	123	int blocks = len >> this->erase_shift;
	124	int blocksize = (1 << this->erase_shift);
125	loff_t ofs;
126	size_t _retlen = 0;
127	int ret;
128
129	if (to == next_ofs) {
130	next_ofs = to + len;
131	to += skip_ofs;
132	} else {
133	next_ofs = to + len;
134	skip_ofs = 0;
135	}
136	ofs = to;
137
138	while (blocks) {
139	ret = mtd->block_isbad(mtd, ofs);
140	if (ret) {
141	printk("Bad blocks %d at 0x%x\n",
142	(u32)(ofs >> this->erase_shift), (u32)ofs);
143	skip_ofs += blocksize;
144	goto next;
145	}
146
147	ret = mtd->write(mtd, ofs, blocksize, &_retlen, buf);
148	if (ret) {
149	printk("Write failed 0x%x, %d", (u32)ofs, ret);
150	skip_ofs += blocksize;
151	goto next;
152	}
153
154	buf += blocksize;
155	blocks--;
156	*retlen += _retlen;
157	next:
158	ofs += blocksize;
159	}
160
161	return 0;
162	}
163
164	static int onenand_block_erase(u32 start, u32 size, int force)
165	{
166	struct onenand_chip *this = mtd->priv;
167	struct erase_info instr = {
168	.callback = NULL,
169	};
170	loff_t ofs;
171	int ret;
172	int blocksize = 1 << this->erase_shift;
173
174	for (ofs = start; ofs < (start + size); ofs += blocksize) {
175	ret = mtd->block_isbad(mtd, ofs);
176	if (ret && !force) {
177	printf("Skip erase bad block %d at 0x%x\n",
178	(u32)(ofs >> this->erase_shift), (u32)ofs);
179	continue;
180	}
181
182	instr.addr = ofs;
183	instr.len = blocksize;
184	instr.priv = force;
185	instr.mtd = mtd;
186	ret = mtd->erase(mtd, &instr);
187	if (ret) {
188	printf("erase failed block %d at 0x%x\n",
189	(u32)(ofs >> this->erase_shift), (u32)ofs);
190	continue;
191	}
192	}
193
194	return 0;
195	}
196
197	static int onenand_block_test(u32 start, u32 size)
198	{
199	struct onenand_chip *this = mtd->priv;
200	struct erase_info instr = {
201	.callback = NULL,
202	.priv = 0,
203	};
204
205	int blocks;
206	loff_t ofs;
207	int blocksize = 1 << this->erase_shift;
208	int start_block, end_block;
209	size_t retlen;
210	u_char *buf;
211	u_char *verify_buf;
212	int ret;
213
214	buf = malloc(blocksize);
215	if (!buf) {
216	printf("Not enough malloc space available!\n");
217	return -1;
218	}
219
220	verify_buf = malloc(blocksize);
221	if (!verify_buf) {
222	printf("Not enough malloc space available!\n");
223	return -1;
224	}
225
226	start_block = start >> this->erase_shift;
227	end_block = (start + size) >> this->erase_shift;
228
229	/* Protect boot-loader from badblock testing */
230	if (start_block < 2)
231	start_block = 2;
232
233	if (end_block > (mtd->size >> this->erase_shift))
234	end_block = mtd->size >> this->erase_shift;
235
236	blocks = start_block;
237	ofs = start;
238	while (blocks < end_block) {
239	printf("\rTesting block %d at 0x%x", (u32)(ofs >> this->erase_shift), (u32)ofs);
240
241	ret = mtd->block_isbad(mtd, ofs);
242	if (ret) {
243	printf("Skip erase bad block %d at 0x%x\n",
244	(u32)(ofs >> this->erase_shift), (u32)ofs);
245	goto next;
246	}
247
248	instr.addr = ofs;
249	instr.len = blocksize;
250	ret = mtd->erase(mtd, &instr);
251	if (ret) {
252	printk("Erase failed 0x%x, %d\n", (u32)ofs, ret);
253	goto next;
254	}
255
256	ret = mtd->write(mtd, ofs, blocksize, &retlen, buf);
257	if (ret) {
258	printk("Write failed 0x%x, %d\n", (u32)ofs, ret);
259	goto next;
260	}
261
262	ret = mtd->read(mtd, ofs, blocksize, &retlen, verify_buf);
263	if (ret) {
264	printk("Read failed 0x%x, %d\n", (u32)ofs, ret);
265	goto next;
266	}
267
268	if (memcmp(buf, verify_buf, blocksize))
269	printk("\nRead/Write test failed at 0x%x\n", (u32)ofs);
270
271	next:
272	ofs += blocksize;
273	blocks++;
274	}
275	printf("...Done\n");
276
277	free(buf);
278	free(verify_buf);
279
280	return 0;
281	}
282
283	static int onenand_dump(struct mtd_info *mtd, ulong off, int only_oob)
284	{
285	int i;
286	u_char datbuf, oobbuf, *p;
287	struct mtd_oob_ops ops;
288	loff_t addr;
289
290	datbuf = malloc(mtd->writesize + mtd->oobsize);
291	oobbuf = malloc(mtd->oobsize);
292	if (!datbuf \|\| !oobbuf) {
293	puts("No memory for page buffer\n");
294	return 1;
295	}
296	off &= ~(mtd->writesize - 1);
297	addr = (loff_t) off;
298	memset(&ops, 0, sizeof(ops));
299	ops.datbuf = datbuf;
300	ops.oobbuf = oobbuf; /* must exist, but oob data will be appended to ops.datbuf */
301	ops.len = mtd->writesize;
302	ops.ooblen = mtd->oobsize;
303	ops.retlen = 0;
304	i = mtd->read_oob(mtd, addr, &ops);
305	if (i < 0) {
306	printf("Error (%d) reading page %08lx\n", i, off);
307	free(datbuf);
308	free(oobbuf);
309	return 1;
310	}
311	printf("Page %08lx dump:\n", off);
312	i = mtd->writesize >> 4;
313	p = datbuf;
314
315	while (i--) {
316	if (!only_oob)
317	printf("\t%02x %02x %02x %02x %02x %02x %02x %02x"
318	" %02x %02x %02x %02x %02x %02x %02x %02x\n",
319	p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7],
320	p[8], p[9], p[10], p[11], p[12], p[13], p[14],
321	p[15]);
322	p += 16;
323	}
324	puts("OOB:\n");
325	i = mtd->oobsize >> 3;
326	while (i--) {
327	printf("\t%02x %02x %02x %02x %02x %02x %02x %02x\n",
328	p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]);
329	p += 8;
330	}
331	free(datbuf);
332	free(oobbuf);
333
334	return 0;
335	}
d7e8ce10 KP	336
	337	int do_onenand(cmd_tbl_t * cmdtp, int flag, int argc, char *argv[])
	338	{
c438ea17 SR	339	struct onenand_chip *this;
	340	int blocksize;
	341	ulong addr, ofs;
	342	size_t len, retlen = 0;
	343	int ret;
	344	char cmd, s;
	345
	346	mtd = &onenand_mtd;
	347	this = mtd->priv;
	348	blocksize = (1 << this->erase_shift);
	349
	350	cmd = argv[1];
d7e8ce10 KP	351
	352	switch (argc) {
	353	case 0:
	354	case 1:
c438ea17	355	goto usage;
d7e8ce10 KP	356
d7e8ce10 KP	357	case 2:
c438ea17 SR	358	if (strcmp(cmd, "info") == 0) {
	359	printf("%s\n", mtd->name);
	360	return 0;
	361	}
	362
	363	if (strcmp(cmd, "bad") == 0) {
	364	/* Currently only one OneNAND device is supported */
	365	printf("\nDevice %d bad blocks:\n", 0);
	366	for (ofs = 0; ofs < mtd->size; ofs += mtd->erasesize) {
	367	if (mtd->block_isbad(mtd, ofs))
	368	printf(" %08x\n", (u32)ofs);
	369	}
	370
d7e8ce10 KP	371	return 0;
d7e8ce10 KP	372	}
d7e8ce10 KP	373
	374	default:
	375	/* At least 4 args */
a9da2b41	376
c438ea17 SR	377	/*
	378	* Syntax is:
	379	* 0 1 2 3 4
	380	* onenand erase [force] [off size]
	381	*/
	382	if ((strcmp(cmd, "erase") == 0) \|\| (strcmp(cmd, "test") == 0)) {
	383	int force = argc > 2 && !strcmp("force", argv[2]);
	384	int o = force ? 3 : 2;
	385	int erase;
d7e8ce10	386
c438ea17 SR	387	erase = strcmp(cmd, "erase") == 0; /* 1 = erase, 0 = test */
c438ea17 SR	388	printf("\nOneNAND %s: ", erase ? "erase" : "test");
d7e8ce10	389
c438ea17 SR	390	/* skip first two or three arguments, look for offset and size */
	391	if (arg_off_size(argc - o, argv + o, &ofs, &len) != 0)
	392	return 1;
d7e8ce10	393
c438ea17 SR	394	if (erase)
	395	ret = onenand_block_erase(ofs, len, force);
	396	else
	397	ret = onenand_block_test(ofs, len);
d7e8ce10	398
c438ea17 SR	399	printf("%s\n", ret ? "ERROR" : "OK");
	400
	401	return ret == 0 ? 0 : 1;
d7e8ce10 KP	402	}
d7e8ce10 KP	403
c438ea17 SR	404	if (strncmp(cmd, "read", 4) == 0 \|\| strncmp(cmd, "write", 5) == 0) {
	405	int read;
	406	int oob = 0;
bfd7f386	407
c438ea17 SR	408	if (argc < 4)
c438ea17 SR	409	goto usage;
bfd7f386	410
c438ea17	411	addr = (ulong)simple_strtoul(argv[2], NULL, 16);
d7e8ce10	412
c438ea17 SR	413	read = strncmp(cmd, "read", 4) == 0; /* 1 = read, 0 = write */
	414	printf("\nOneNAND %s: ", read ? "read" : "write");
	415	if (arg_off_size(argc - 3, argv + 3, &ofs, &len) != 0)
	416	return 1;
d7e8ce10	417
c438ea17 SR	418	s = strchr(cmd, '.');
	419	if ((s != NULL) && (!strcmp(s, ".oob")))
	420	oob = 1;
d7e8ce10	421
c438ea17 SR	422	if (read) {
	423	ret = onenand_block_read(ofs, len, &retlen,
	424	(u8 *)addr, oob);
	425	} else {
	426	ret = onenand_block_write(ofs, len, &retlen,
	427	(u8 *)addr);
	428	}
d7e8ce10	429
c438ea17 SR	430	printf(" %d bytes %s: %s\n", retlen,
c438ea17 SR	431	read ? "read" : "written", ret ? "ERROR" : "OK");
d7e8ce10	432
c438ea17	433	return ret == 0 ? 0 : 1;
d7e8ce10 KP	434	}
d7e8ce10 KP	435
c438ea17 SR	436	if (strcmp(cmd, "markbad") == 0) {
c438ea17 SR	437	addr = (ulong)simple_strtoul(argv[2], NULL, 16);
bfd7f386	438
c438ea17 SR	439	int ret = mtd->block_markbad(mtd, addr);
	440	if (ret == 0) {
	441	printf("block 0x%08lx successfully marked as bad\n",
	442	(ulong) addr);
	443	return 0;
	444	} else {
	445	printf("block 0x%08lx NOT marked as bad! ERROR %d\n",
	446	(ulong) addr, ret);
	447	}
	448	return 1;
	449	}
d7e8ce10	450
c438ea17 SR	451	if (strncmp(cmd, "dump", 4) == 0) {
	452	if (argc < 3)
	453	goto usage;
d7e8ce10	454
c438ea17 SR	455	s = strchr(cmd, '.');
c438ea17 SR	456	ofs = (int)simple_strtoul(argv[2], NULL, 16);
bfd7f386	457
c438ea17 SR	458	if (s != NULL && strcmp(s, ".oob") == 0)
	459	ret = onenand_dump(mtd, ofs, 1);
	460	else
	461	ret = onenand_dump(mtd, ofs, 0);
d7e8ce10	462
c438ea17	463	return ret == 0 ? 1 : 0;
d7e8ce10 KP	464	}
	465
	466	break;
	467	}
	468
	469	return 0;
c438ea17 SR	470
c438ea17 SR	471	usage:
62c3ae7c	472	cmd_usage(cmdtp);
c438ea17	473	return 1;
d7e8ce10 KP	474	}
	475
	476	U_BOOT_CMD(
	477	onenand, 6, 1, do_onenand,
2fb2604d	478	"OneNAND sub-system",
c438ea17 SR	479	"info - show available OneNAND devices\n"
	480	"onenand bad - show bad blocks\n"
	481	"onenand read[.oob] addr off size\n"
	482	"onenand write[.oob] addr off size\n"
	483	" read/write 'size' bytes starting at offset 'off'\n"
	484	" to/from memory address 'addr', skipping bad blocks.\n"
	485	"onenand erase [force] [off size] - erase 'size' bytes from\n"
	486	"onenand test [off size] - test 'size' bytes from\n"
	487	" offset 'off' (entire device if not specified)\n"
	488	"onenand dump[.oob] off - dump page\n"
a89c33db	489	"onenand markbad off [...] - mark bad block(s) at offset (UNSAFE)"
d7e8ce10	490	);