[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>

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