[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/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 int arg_off_size_onenand(int argc, char * const 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_write_oneblock_withoob(loff_t to, const u_char * buf,
					  size_t *retlen)
{
	struct mtd_oob_ops ops = {
		.len = mtd->writesize,
		.ooblen = mtd->oobsize,
		.mode = MTD_OPS_AUTO_OOB,
	};
	int page, ret = 0;
	for (page = 0; page < (mtd->erasesize / mtd->writesize); page ++) {
		ops.datbuf = (u_char *)buf;
		buf += mtd->writesize;
		ops.oobbuf = (u_char *)buf;
		buf += mtd->oobsize;
		ret = mtd_write_oob(mtd, to, &ops);
		if (ret)
			break;
		to += mtd->writesize;
	}

	*retlen = (ret) ? 0 : mtd->erasesize;
	return ret;
}

static int onenand_block_write(loff_t to, size_t len,
			       size_t *retlen, const u_char * buf, int withoob)
{
	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;
		}

		if (!withoob)
			ret = mtd_write(mtd, ofs, blocksize, &_retlen, buf);
		else
			ret = onenand_write_oneblock_withoob(ofs, buf, &_retlen);
		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;
	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;
	p = oobbuf;

	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;
}

static int do_onenand_info(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
{
	printf("%s\n", mtd->name);
	return 0;
}

static int do_onenand_bad(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
{
	ulong ofs;

	mtd = &onenand_mtd;
	/* 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;
}

static int do_onenand_read(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
{
	char *s;
	int oob = 0;
	ulong addr, ofs;
	size_t len;
	int ret = 0;
	size_t retlen = 0;

	if (argc < 3)
		return CMD_RET_USAGE;

	s = strchr(argv[0], '.');
	if ((s != NULL) && (!strcmp(s, ".oob")))
		oob = 1;

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

	printf("\nOneNAND read: ");
	if (arg_off_size_onenand(argc - 2, argv + 2, &ofs, &len) != 0)
		return 1;

	ret = onenand_block_read(ofs, len, &retlen, (u8 *)addr, oob);

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

	return ret == 0 ? 0 : 1;
}

static int do_onenand_write(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
{
	ulong addr, ofs;
	size_t len;
	int ret = 0, withoob = 0;
	size_t retlen = 0;

	if (argc < 3)
		return CMD_RET_USAGE;

	if (strncmp(argv[0] + 6, "yaffs", 5) == 0)
		withoob = 1;

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

	printf("\nOneNAND write: ");
	if (arg_off_size_onenand(argc - 2, argv + 2, &ofs, &len) != 0)
		return 1;

	ret = onenand_block_write(ofs, len, &retlen, (u8 *)addr, withoob);

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

	return ret == 0 ? 0 : 1;
}

static int do_onenand_erase(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
{
	ulong ofs;
	int ret = 0;
	size_t len;
	int force;

	/*
	 * Syntax is:
	 *   0       1     2       3    4
	 *   onenand erase [force] [off size]
	 */
	argc--;
	argv++;
	if (argc)
	{
		if (!strcmp("force", argv[0]))
		{
			force = 1;
			argc--;
			argv++;
		}
	}
	printf("\nOneNAND erase: ");

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

	ret = onenand_block_erase(ofs, len, force);

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

	return ret == 0 ? 0 : 1;
}

static int do_onenand_test(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
{
	ulong ofs;
	int ret = 0;
	size_t len;

	/*
	 * Syntax is:
	 *   0       1     2       3    4
	 *   onenand test [force] [off size]
	 */

	printf("\nOneNAND test: ");

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

	ret = onenand_block_test(ofs, len);

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

	return ret == 0 ? 0 : 1;
}

static int do_onenand_dump(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
{
	ulong ofs;
	int ret = 0;
	char *s;

	if (argc < 2)
		return CMD_RET_USAGE;

	s = strchr(argv[0], '.');
	ofs = (int)simple_strtoul(argv[1], 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;
}

static int do_onenand_markbad(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
{
	int ret = 0;
	ulong addr;

	argc -= 2;
	argv += 2;

	if (argc <= 0)
		return CMD_RET_USAGE;

	while (argc > 0) {
		addr = simple_strtoul(*argv, NULL, 16);

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

static cmd_tbl_t cmd_onenand_sub[] = {
	U_BOOT_CMD_MKENT(info, 1, 0, do_onenand_info, "", ""),
	U_BOOT_CMD_MKENT(bad, 1, 0, do_onenand_bad, "", ""),
	U_BOOT_CMD_MKENT(read, 4, 0, do_onenand_read, "", ""),
	U_BOOT_CMD_MKENT(write, 4, 0, do_onenand_write, "", ""),
	U_BOOT_CMD_MKENT(write.yaffs, 4, 0, do_onenand_write, "", ""),
	U_BOOT_CMD_MKENT(erase, 3, 0, do_onenand_erase, "", ""),
	U_BOOT_CMD_MKENT(test, 3, 0, do_onenand_test, "", ""),
	U_BOOT_CMD_MKENT(dump, 2, 0, do_onenand_dump, "", ""),
	U_BOOT_CMD_MKENT(markbad, CONFIG_SYS_MAXARGS, 0, do_onenand_markbad, "", ""),
};

#ifdef CONFIG_NEEDS_MANUAL_RELOC
void onenand_reloc(void) {
	fixup_cmdtable(cmd_onenand_sub, ARRAY_SIZE(cmd_onenand_sub));
}
#endif

static int do_onenand(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
{
	cmd_tbl_t *c;

	if (argc < 2)
		return CMD_RET_USAGE;

	mtd = &onenand_mtd;

	/* Strip off leading 'onenand' command argument */
	argc--;
	argv++;

	c = find_cmd_tbl(argv[0], &cmd_onenand_sub[0], ARRAY_SIZE(cmd_onenand_sub));

	if (c)
		return c->cmd(cmdtp, flag, argc, argv);
	else
		return CMD_RET_USAGE;
}

U_BOOT_CMD(
	onenand,	CONFIG_SYS_MAXARGS,	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[.yaffs] 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
7b15e2bb	16	#include <linux/compat.h>
d7e8ce10 KP	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
09c32807 HS	27	static int arg_off_size_onenand(int argc, char * const argv[], ulong *off,
09c32807 HS	28	size_t *size)
c438ea17 SR	29	{
	30	if (argc >= 1) {
	31	if (!(str2long(argv[0], off))) {
	32	printf("'%s' is not a number\n", argv[0]);
	33	return -1;
	34	}
	35	} else {
	36	*off = 0;
	37	}
	38
	39	if (argc >= 2) {
	40	if (!(str2long(argv[1], (ulong *)size))) {
	41	printf("'%s' is not a number\n", argv[1]);
	42	return -1;
	43	}
	44	} else {
	45	size = mtd->size - off;
	46	}
	47
	48	if ((off + size) > mtd->size) {
8d2effea	49	printf("total chip size (0x%llx) exceeded!\n", mtd->size);
c438ea17 SR	50	return -1;
	51	}
	52
	53	if (*size == mtd->size)
	54	puts("whole chip\n");
	55	else
	56	printf("offset 0x%lx, size 0x%x\n", off, size);
	57
	58	return 0;
	59	}
	60
	61	static int onenand_block_read(loff_t from, size_t len,
	62	size_t retlen, u_char buf, int oob)
	63	{
	64	struct onenand_chip *this = mtd->priv;
	65	int blocks = (int) len >> this->erase_shift;
	66	int blocksize = (1 << this->erase_shift);
	67	loff_t ofs = from;
	68	struct mtd_oob_ops ops = {
	69	.retlen = 0,
	70	};
	71	int ret;
	72
	73	if (oob)
	74	ops.ooblen = blocksize;
	75	else
	76	ops.len = blocksize;
	77
	78	while (blocks) {
dfe64e2c	79	ret = mtd_block_isbad(mtd, ofs);
c438ea17 SR	80	if (ret) {
	81	printk("Bad blocks %d at 0x%x\n",
	82	(u32)(ofs >> this->erase_shift), (u32)ofs);
	83	ofs += blocksize;
	84	continue;
	85	}
	86
	87	if (oob)
	88	ops.oobbuf = buf;
	89	else
	90	ops.datbuf = buf;
	91
	92	ops.retlen = 0;
dfe64e2c	93	ret = mtd_read_oob(mtd, ofs, &ops);
c438ea17 SR	94	if (ret) {
	95	printk("Read failed 0x%x, %d\n", (u32)ofs, ret);
	96	ofs += blocksize;
	97	continue;
	98	}
	99	ofs += blocksize;
	100	buf += blocksize;
	101	blocks--;
	102	*retlen += ops.retlen;
	103	}
	104
	105	return 0;
	106	}
	107
41c86240 LW	108	static int onenand_write_oneblock_withoob(loff_t to, const u_char * buf,
	109	size_t *retlen)
	110	{
	111	struct mtd_oob_ops ops = {
	112	.len = mtd->writesize,
	113	.ooblen = mtd->oobsize,
dfe64e2c	114	.mode = MTD_OPS_AUTO_OOB,
41c86240 LW	115	};
	116	int page, ret = 0;
	117	for (page = 0; page < (mtd->erasesize / mtd->writesize); page ++) {
	118	ops.datbuf = (u_char *)buf;
	119	buf += mtd->writesize;
	120	ops.oobbuf = (u_char *)buf;
	121	buf += mtd->oobsize;
dfe64e2c	122	ret = mtd_write_oob(mtd, to, &ops);
41c86240 LW	123	if (ret)
	124	break;
	125	to += mtd->writesize;
	126	}
	127
	128	*retlen = (ret) ? 0 : mtd->erasesize;
	129	return ret;
	130	}
	131
c438ea17	132	static int onenand_block_write(loff_t to, size_t len,
41c86240	133	size_t retlen, const u_char buf, int withoob)
c438ea17 SR	134	{
	135	struct onenand_chip *this = mtd->priv;
	136	int blocks = len >> this->erase_shift;
	137	int blocksize = (1 << this->erase_shift);
	138	loff_t ofs;
	139	size_t _retlen = 0;
	140	int ret;
	141
	142	if (to == next_ofs) {
	143	next_ofs = to + len;
	144	to += skip_ofs;
	145	} else {
	146	next_ofs = to + len;
	147	skip_ofs = 0;
	148	}
	149	ofs = to;
	150
	151	while (blocks) {
dfe64e2c	152	ret = mtd_block_isbad(mtd, ofs);
c438ea17 SR	153	if (ret) {
	154	printk("Bad blocks %d at 0x%x\n",
	155	(u32)(ofs >> this->erase_shift), (u32)ofs);
	156	skip_ofs += blocksize;
	157	goto next;
	158	}
	159
41c86240	160	if (!withoob)
dfe64e2c	161	ret = mtd_write(mtd, ofs, blocksize, &_retlen, buf);
41c86240 LW	162	else
41c86240 LW	163	ret = onenand_write_oneblock_withoob(ofs, buf, &_retlen);
c438ea17 SR	164	if (ret) {
	165	printk("Write failed 0x%x, %d", (u32)ofs, ret);
	166	skip_ofs += blocksize;
	167	goto next;
	168	}
	169
	170	buf += blocksize;
	171	blocks--;
	172	*retlen += _retlen;
	173	next:
	174	ofs += blocksize;
	175	}
	176
	177	return 0;
	178	}
	179
	180	static int onenand_block_erase(u32 start, u32 size, int force)
	181	{
	182	struct onenand_chip *this = mtd->priv;
	183	struct erase_info instr = {
	184	.callback = NULL,
	185	};
	186	loff_t ofs;
	187	int ret;
	188	int blocksize = 1 << this->erase_shift;
	189
	190	for (ofs = start; ofs < (start + size); ofs += blocksize) {
dfe64e2c	191	ret = mtd_block_isbad(mtd, ofs);
c438ea17 SR	192	if (ret && !force) {
	193	printf("Skip erase bad block %d at 0x%x\n",
	194	(u32)(ofs >> this->erase_shift), (u32)ofs);
	195	continue;
	196	}
	197
	198	instr.addr = ofs;
	199	instr.len = blocksize;
	200	instr.priv = force;
	201	instr.mtd = mtd;
dfe64e2c	202	ret = mtd_erase(mtd, &instr);
c438ea17 SR	203	if (ret) {
	204	printf("erase failed block %d at 0x%x\n",
	205	(u32)(ofs >> this->erase_shift), (u32)ofs);
	206	continue;
	207	}
	208	}
	209
	210	return 0;
	211	}
	212
	213	static int onenand_block_test(u32 start, u32 size)
	214	{
	215	struct onenand_chip *this = mtd->priv;
	216	struct erase_info instr = {
	217	.callback = NULL,
	218	.priv = 0,
	219	};
	220
	221	int blocks;
	222	loff_t ofs;
	223	int blocksize = 1 << this->erase_shift;
	224	int start_block, end_block;
	225	size_t retlen;
	226	u_char *buf;
	227	u_char *verify_buf;
	228	int ret;
	229
	230	buf = malloc(blocksize);
	231	if (!buf) {
	232	printf("Not enough malloc space available!\n");
	233	return -1;
	234	}
	235
	236	verify_buf = malloc(blocksize);
	237	if (!verify_buf) {
	238	printf("Not enough malloc space available!\n");
	239	return -1;
	240	}
	241
	242	start_block = start >> this->erase_shift;
	243	end_block = (start + size) >> this->erase_shift;
	244
	245	/* Protect boot-loader from badblock testing */
	246	if (start_block < 2)
	247	start_block = 2;
	248
	249	if (end_block > (mtd->size >> this->erase_shift))
	250	end_block = mtd->size >> this->erase_shift;
	251
	252	blocks = start_block;
	253	ofs = start;
	254	while (blocks < end_block) {
	255	printf("\rTesting block %d at 0x%x", (u32)(ofs >> this->erase_shift), (u32)ofs);
	256
dfe64e2c	257	ret = mtd_block_isbad(mtd, ofs);
c438ea17 SR	258	if (ret) {
	259	printf("Skip erase bad block %d at 0x%x\n",
	260	(u32)(ofs >> this->erase_shift), (u32)ofs);
	261	goto next;
	262	}
	263
	264	instr.addr = ofs;
	265	instr.len = blocksize;
dfe64e2c	266	ret = mtd_erase(mtd, &instr);
c438ea17 SR	267	if (ret) {
	268	printk("Erase failed 0x%x, %d\n", (u32)ofs, ret);
	269	goto next;
	270	}
	271
dfe64e2c	272	ret = mtd_write(mtd, ofs, blocksize, &retlen, buf);
c438ea17 SR	273	if (ret) {
	274	printk("Write failed 0x%x, %d\n", (u32)ofs, ret);
	275	goto next;
	276	}
	277
dfe64e2c	278	ret = mtd_read(mtd, ofs, blocksize, &retlen, verify_buf);
c438ea17 SR	279	if (ret) {
	280	printk("Read failed 0x%x, %d\n", (u32)ofs, ret);
	281	goto next;
	282	}
	283
	284	if (memcmp(buf, verify_buf, blocksize))
	285	printk("\nRead/Write test failed at 0x%x\n", (u32)ofs);
	286
	287	next:
	288	ofs += blocksize;
	289	blocks++;
	290	}
	291	printf("...Done\n");
	292
	293	free(buf);
	294	free(verify_buf);
	295
	296	return 0;
	297	}
	298
	299	static int onenand_dump(struct mtd_info *mtd, ulong off, int only_oob)
	300	{
	301	int i;
	302	u_char datbuf, oobbuf, *p;
	303	struct mtd_oob_ops ops;
	304	loff_t addr;
	305
	306	datbuf = malloc(mtd->writesize + mtd->oobsize);
	307	oobbuf = malloc(mtd->oobsize);
	308	if (!datbuf \|\| !oobbuf) {
	309	puts("No memory for page buffer\n");
	310	return 1;
	311	}
	312	off &= ~(mtd->writesize - 1);
	313	addr = (loff_t) off;
	314	memset(&ops, 0, sizeof(ops));
	315	ops.datbuf = datbuf;
a430b137	316	ops.oobbuf = oobbuf;
c438ea17 SR	317	ops.len = mtd->writesize;
	318	ops.ooblen = mtd->oobsize;
	319	ops.retlen = 0;
dfe64e2c	320	i = mtd_read_oob(mtd, addr, &ops);
c438ea17 SR	321	if (i < 0) {
	322	printf("Error (%d) reading page %08lx\n", i, off);
	323	free(datbuf);
	324	free(oobbuf);
	325	return 1;
	326	}
	327	printf("Page %08lx dump:\n", off);
	328	i = mtd->writesize >> 4;
	329	p = datbuf;
	330
	331	while (i--) {
	332	if (!only_oob)
	333	printf("\t%02x %02x %02x %02x %02x %02x %02x %02x"
	334	" %02x %02x %02x %02x %02x %02x %02x %02x\n",
	335	p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7],
	336	p[8], p[9], p[10], p[11], p[12], p[13], p[14],
	337	p[15]);
	338	p += 16;
	339	}
	340	puts("OOB:\n");
	341	i = mtd->oobsize >> 3;
a430b137 LW	342	p = oobbuf;
a430b137 LW	343
c438ea17 SR	344	while (i--) {
	345	printf("\t%02x %02x %02x %02x %02x %02x %02x %02x\n",
	346	p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]);
	347	p += 8;
	348	}
	349	free(datbuf);
	350	free(oobbuf);
	351
	352	return 0;
	353	}
d7e8ce10	354
54841ab5	355	static int do_onenand_info(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
d7e8ce10	356	{
8cd85282 FM	357	printf("%s\n", mtd->name);
	358	return 0;
	359	}
	360
54841ab5	361	static int do_onenand_bad(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
8cd85282 FM	362	{
	363	ulong ofs;
	364
	365	mtd = &onenand_mtd;
	366	/* Currently only one OneNAND device is supported */
	367	printf("\nDevice %d bad blocks:\n", 0);
	368	for (ofs = 0; ofs < mtd->size; ofs += mtd->erasesize) {
dfe64e2c	369	if (mtd_block_isbad(mtd, ofs))
8cd85282 FM	370	printf(" %08x\n", (u32)ofs);
	371	}
	372
	373	return 0;
	374	}
	375
54841ab5	376	static int do_onenand_read(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
8cd85282 FM	377	{
	378	char *s;
	379	int oob = 0;
c438ea17	380	ulong addr, ofs;
8cd85282	381	size_t len;
8360b66b	382	int ret = 0;
8cd85282	383	size_t retlen = 0;
c438ea17	384
8cd85282	385	if (argc < 3)
4c12eeb8	386	return CMD_RET_USAGE;
c438ea17	387
8cd85282 FM	388	s = strchr(argv[0], '.');
	389	if ((s != NULL) && (!strcmp(s, ".oob")))
	390	oob = 1;
d7e8ce10	391
8cd85282	392	addr = (ulong)simple_strtoul(argv[1], NULL, 16);
d7e8ce10	393
8cd85282	394	printf("\nOneNAND read: ");
09c32807	395	if (arg_off_size_onenand(argc - 2, argv + 2, &ofs, &len) != 0)
8cd85282	396	return 1;
c438ea17	397
8cd85282	398	ret = onenand_block_read(ofs, len, &retlen, (u8 *)addr, oob);
c438ea17	399
8cd85282	400	printf(" %d bytes read: %s\n", retlen, ret ? "ERROR" : "OK");
d7e8ce10	401
8cd85282 FM	402	return ret == 0 ? 0 : 1;
8cd85282 FM	403	}
a9da2b41	404
54841ab5	405	static int do_onenand_write(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
8cd85282 FM	406	{
	407	ulong addr, ofs;
	408	size_t len;
41c86240	409	int ret = 0, withoob = 0;
8cd85282	410	size_t retlen = 0;
d7e8ce10	411
8cd85282	412	if (argc < 3)
4c12eeb8	413	return CMD_RET_USAGE;
d7e8ce10	414
41c86240 LW	415	if (strncmp(argv[0] + 6, "yaffs", 5) == 0)
	416	withoob = 1;
	417
8cd85282 FM	418	addr = (ulong)simple_strtoul(argv[1], NULL, 16);
	419
	420	printf("\nOneNAND write: ");
09c32807	421	if (arg_off_size_onenand(argc - 2, argv + 2, &ofs, &len) != 0)
8cd85282	422	return 1;
d7e8ce10	423
41c86240	424	ret = onenand_block_write(ofs, len, &retlen, (u8 *)addr, withoob);
d7e8ce10	425
8cd85282	426	printf(" %d bytes written: %s\n", retlen, ret ? "ERROR" : "OK");
c438ea17	427
8cd85282 FM	428	return ret == 0 ? 0 : 1;
	429	}
	430
54841ab5	431	static int do_onenand_erase(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
8cd85282 FM	432	{
	433	ulong ofs;
	434	int ret = 0;
	435	size_t len;
	436	int force;
	437
	438	/*
	439	* Syntax is:
	440	* 0 1 2 3 4
	441	* onenand erase [force] [off size]
	442	*/
	443	argc--;
	444	argv++;
	445	if (argc)
	446	{
	447	if (!strcmp("force", argv[0]))
	448	{
	449	force = 1;
	450	argc--;
	451	argv++;
d7e8ce10	452	}
8cd85282 FM	453	}
8cd85282 FM	454	printf("\nOneNAND erase: ");
d7e8ce10	455
8cd85282	456	/* skip first two or three arguments, look for offset and size */
09c32807	457	if (arg_off_size_onenand(argc, argv, &ofs, &len) != 0)
8cd85282	458	return 1;
bfd7f386	459
8cd85282	460	ret = onenand_block_erase(ofs, len, force);
bfd7f386	461
8cd85282	462	printf("%s\n", ret ? "ERROR" : "OK");
d7e8ce10	463
8cd85282 FM	464	return ret == 0 ? 0 : 1;
8cd85282 FM	465	}
d7e8ce10	466
54841ab5	467	static int do_onenand_test(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
8cd85282 FM	468	{
	469	ulong ofs;
	470	int ret = 0;
	471	size_t len;
d7e8ce10	472
8cd85282 FM	473	/*
	474	* Syntax is:
	475	* 0 1 2 3 4
	476	* onenand test [force] [off size]
	477	*/
d7e8ce10	478
8cd85282	479	printf("\nOneNAND test: ");
d7e8ce10	480
8cd85282	481	/* skip first two or three arguments, look for offset and size */
09c32807	482	if (arg_off_size_onenand(argc - 1, argv + 1, &ofs, &len) != 0)
8cd85282	483	return 1;
d7e8ce10	484
8cd85282	485	ret = onenand_block_test(ofs, len);
d7e8ce10	486
8cd85282	487	printf("%s\n", ret ? "ERROR" : "OK");
d7e8ce10	488
8cd85282 FM	489	return ret == 0 ? 0 : 1;
8cd85282 FM	490	}
bfd7f386	491
54841ab5	492	static int do_onenand_dump(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
8cd85282 FM	493	{
	494	ulong ofs;
	495	int ret = 0;
	496	char *s;
d7e8ce10	497
8cd85282	498	if (argc < 2)
4c12eeb8	499	return CMD_RET_USAGE;
8cd85282 FM	500
	501	s = strchr(argv[0], '.');
	502	ofs = (int)simple_strtoul(argv[1], NULL, 16);
	503
	504	if (s != NULL && strcmp(s, ".oob") == 0)
	505	ret = onenand_dump(mtd, ofs, 1);
	506	else
	507	ret = onenand_dump(mtd, ofs, 0);
d7e8ce10	508
8cd85282 FM	509	return ret == 0 ? 1 : 0;
	510	}
	511
54841ab5	512	static int do_onenand_markbad(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
8cd85282 FM	513	{
	514	int ret = 0;
	515	ulong addr;
	516
	517	argc -= 2;
	518	argv += 2;
	519
	520	if (argc <= 0)
4c12eeb8	521	return CMD_RET_USAGE;
d7e8ce10	522
8cd85282 FM	523	while (argc > 0) {
	524	addr = simple_strtoul(*argv, NULL, 16);
	525
dfe64e2c	526	if (mtd_block_markbad(mtd, addr)) {
8cd85282 FM	527	printf("block 0x%08lx NOT marked "
	528	"as bad! ERROR %d\n",
	529	addr, ret);
	530	ret = 1;
	531	} else {
	532	printf("block 0x%08lx successfully "
	533	"marked as bad\n",
	534	addr);
	535	}
	536	--argc;
	537	++argv;
	538	}
	539	return ret;
	540	}
	541
	542	static cmd_tbl_t cmd_onenand_sub[] = {
	543	U_BOOT_CMD_MKENT(info, 1, 0, do_onenand_info, "", ""),
	544	U_BOOT_CMD_MKENT(bad, 1, 0, do_onenand_bad, "", ""),
	545	U_BOOT_CMD_MKENT(read, 4, 0, do_onenand_read, "", ""),
	546	U_BOOT_CMD_MKENT(write, 4, 0, do_onenand_write, "", ""),
41c86240	547	U_BOOT_CMD_MKENT(write.yaffs, 4, 0, do_onenand_write, "", ""),
8cd85282 FM	548	U_BOOT_CMD_MKENT(erase, 3, 0, do_onenand_erase, "", ""),
	549	U_BOOT_CMD_MKENT(test, 3, 0, do_onenand_test, "", ""),
	550	U_BOOT_CMD_MKENT(dump, 2, 0, do_onenand_dump, "", ""),
	551	U_BOOT_CMD_MKENT(markbad, CONFIG_SYS_MAXARGS, 0, do_onenand_markbad, "", ""),
	552	};
	553
2e5167cc	554	#ifdef CONFIG_NEEDS_MANUAL_RELOC
cdb1d4f9 EBS	555	void onenand_reloc(void) {
	556	fixup_cmdtable(cmd_onenand_sub, ARRAY_SIZE(cmd_onenand_sub));
	557	}
	558	#endif
	559
54841ab5	560	static int do_onenand(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
8cd85282 FM	561	{
	562	cmd_tbl_t *c;
	563
57ff9f24	564	if (argc < 2)
4c12eeb8	565	return CMD_RET_USAGE;
57ff9f24	566
8cd85282 FM	567	mtd = &onenand_mtd;
	568
	569	/* Strip off leading 'onenand' command argument */
	570	argc--;
	571	argv++;
c438ea17	572
8cd85282 FM	573	c = find_cmd_tbl(argv[0], &cmd_onenand_sub[0], ARRAY_SIZE(cmd_onenand_sub));
8cd85282 FM	574
47e26b1b WD	575	if (c)
	576	return c->cmd(cmdtp, flag, argc, argv);
	577	else
4c12eeb8	578	return CMD_RET_USAGE;
d7e8ce10 KP	579	}
	580
	581	U_BOOT_CMD(
8360b66b	582	onenand, CONFIG_SYS_MAXARGS, 1, do_onenand,
2fb2604d	583	"OneNAND sub-system",
c438ea17 SR	584	"info - show available OneNAND devices\n"
	585	"onenand bad - show bad blocks\n"
	586	"onenand read[.oob] addr off size\n"
41c86240	587	"onenand write[.yaffs] addr off size\n"
c438ea17 SR	588	" read/write 'size' bytes starting at offset 'off'\n"
	589	" to/from memory address 'addr', skipping bad blocks.\n"
	590	"onenand erase [force] [off size] - erase 'size' bytes from\n"
	591	"onenand test [off size] - test 'size' bytes from\n"
	592	" offset 'off' (entire device if not specified)\n"
	593	"onenand dump[.oob] off - dump page\n"
a89c33db	594	"onenand markbad off [...] - mark bad block(s) at offset (UNSAFE)"
d7e8ce10	595	);