12e192b24SSimon Glass /*
22e192b24SSimon Glass * U-Boot command for OneNAND support
32e192b24SSimon Glass *
42e192b24SSimon Glass * Copyright (C) 2005-2008 Samsung Electronics
52e192b24SSimon Glass * Kyungmin Park <kyungmin.park@samsung.com>
62e192b24SSimon Glass *
72e192b24SSimon Glass * This program is free software; you can redistribute it and/or modify
82e192b24SSimon Glass * it under the terms of the GNU General Public License version 2 as
92e192b24SSimon Glass * published by the Free Software Foundation.
102e192b24SSimon Glass */
112e192b24SSimon Glass
122e192b24SSimon Glass #include <common.h>
132e192b24SSimon Glass #include <command.h>
142e192b24SSimon Glass #include <malloc.h>
152e192b24SSimon Glass
162e192b24SSimon Glass #include <linux/compat.h>
172e192b24SSimon Glass #include <linux/mtd/mtd.h>
182e192b24SSimon Glass #include <linux/mtd/onenand.h>
192e192b24SSimon Glass
202e192b24SSimon Glass #include <asm/io.h>
212e192b24SSimon Glass
222e192b24SSimon Glass static struct mtd_info *mtd;
232e192b24SSimon Glass
242e192b24SSimon Glass static loff_t next_ofs;
252e192b24SSimon Glass static loff_t skip_ofs;
262e192b24SSimon Glass
arg_off_size_onenand(int argc,char * const argv[],ulong * off,size_t * size)272e192b24SSimon Glass static int arg_off_size_onenand(int argc, char * const argv[], ulong *off,
282e192b24SSimon Glass size_t *size)
292e192b24SSimon Glass {
302e192b24SSimon Glass if (argc >= 1) {
312e192b24SSimon Glass if (!(str2long(argv[0], off))) {
322e192b24SSimon Glass printf("'%s' is not a number\n", argv[0]);
332e192b24SSimon Glass return -1;
342e192b24SSimon Glass }
352e192b24SSimon Glass } else {
362e192b24SSimon Glass *off = 0;
372e192b24SSimon Glass }
382e192b24SSimon Glass
392e192b24SSimon Glass if (argc >= 2) {
402e192b24SSimon Glass if (!(str2long(argv[1], (ulong *)size))) {
412e192b24SSimon Glass printf("'%s' is not a number\n", argv[1]);
422e192b24SSimon Glass return -1;
432e192b24SSimon Glass }
442e192b24SSimon Glass } else {
452e192b24SSimon Glass *size = mtd->size - *off;
462e192b24SSimon Glass }
472e192b24SSimon Glass
482e192b24SSimon Glass if ((*off + *size) > mtd->size) {
492e192b24SSimon Glass printf("total chip size (0x%llx) exceeded!\n", mtd->size);
502e192b24SSimon Glass return -1;
512e192b24SSimon Glass }
522e192b24SSimon Glass
532e192b24SSimon Glass if (*size == mtd->size)
542e192b24SSimon Glass puts("whole chip\n");
552e192b24SSimon Glass else
562e192b24SSimon Glass printf("offset 0x%lx, size 0x%x\n", *off, *size);
572e192b24SSimon Glass
582e192b24SSimon Glass return 0;
592e192b24SSimon Glass }
602e192b24SSimon Glass
onenand_block_read(loff_t from,size_t len,size_t * retlen,u_char * buf,int oob)612e192b24SSimon Glass static int onenand_block_read(loff_t from, size_t len,
622e192b24SSimon Glass size_t *retlen, u_char *buf, int oob)
632e192b24SSimon Glass {
642e192b24SSimon Glass struct onenand_chip *this = mtd->priv;
652e192b24SSimon Glass int blocks = (int) len >> this->erase_shift;
662e192b24SSimon Glass int blocksize = (1 << this->erase_shift);
672e192b24SSimon Glass loff_t ofs = from;
682e192b24SSimon Glass struct mtd_oob_ops ops = {
692e192b24SSimon Glass .retlen = 0,
702e192b24SSimon Glass };
712e192b24SSimon Glass int ret;
722e192b24SSimon Glass
732e192b24SSimon Glass if (oob)
742e192b24SSimon Glass ops.ooblen = blocksize;
752e192b24SSimon Glass else
762e192b24SSimon Glass ops.len = blocksize;
772e192b24SSimon Glass
782e192b24SSimon Glass while (blocks) {
792e192b24SSimon Glass ret = mtd_block_isbad(mtd, ofs);
802e192b24SSimon Glass if (ret) {
812e192b24SSimon Glass printk("Bad blocks %d at 0x%x\n",
822e192b24SSimon Glass (u32)(ofs >> this->erase_shift), (u32)ofs);
832e192b24SSimon Glass ofs += blocksize;
842e192b24SSimon Glass continue;
852e192b24SSimon Glass }
862e192b24SSimon Glass
872e192b24SSimon Glass if (oob)
882e192b24SSimon Glass ops.oobbuf = buf;
892e192b24SSimon Glass else
902e192b24SSimon Glass ops.datbuf = buf;
912e192b24SSimon Glass
922e192b24SSimon Glass ops.retlen = 0;
932e192b24SSimon Glass ret = mtd_read_oob(mtd, ofs, &ops);
942e192b24SSimon Glass if (ret) {
952e192b24SSimon Glass printk("Read failed 0x%x, %d\n", (u32)ofs, ret);
962e192b24SSimon Glass ofs += blocksize;
972e192b24SSimon Glass continue;
982e192b24SSimon Glass }
992e192b24SSimon Glass ofs += blocksize;
1002e192b24SSimon Glass buf += blocksize;
1012e192b24SSimon Glass blocks--;
1022e192b24SSimon Glass *retlen += ops.retlen;
1032e192b24SSimon Glass }
1042e192b24SSimon Glass
1052e192b24SSimon Glass return 0;
1062e192b24SSimon Glass }
1072e192b24SSimon Glass
onenand_write_oneblock_withoob(loff_t to,const u_char * buf,size_t * retlen)1082e192b24SSimon Glass static int onenand_write_oneblock_withoob(loff_t to, const u_char * buf,
1092e192b24SSimon Glass size_t *retlen)
1102e192b24SSimon Glass {
1112e192b24SSimon Glass struct mtd_oob_ops ops = {
1122e192b24SSimon Glass .len = mtd->writesize,
1132e192b24SSimon Glass .ooblen = mtd->oobsize,
1142e192b24SSimon Glass .mode = MTD_OPS_AUTO_OOB,
1152e192b24SSimon Glass };
1162e192b24SSimon Glass int page, ret = 0;
1172e192b24SSimon Glass for (page = 0; page < (mtd->erasesize / mtd->writesize); page ++) {
1182e192b24SSimon Glass ops.datbuf = (u_char *)buf;
1192e192b24SSimon Glass buf += mtd->writesize;
1202e192b24SSimon Glass ops.oobbuf = (u_char *)buf;
1212e192b24SSimon Glass buf += mtd->oobsize;
1222e192b24SSimon Glass ret = mtd_write_oob(mtd, to, &ops);
1232e192b24SSimon Glass if (ret)
1242e192b24SSimon Glass break;
1252e192b24SSimon Glass to += mtd->writesize;
1262e192b24SSimon Glass }
1272e192b24SSimon Glass
1282e192b24SSimon Glass *retlen = (ret) ? 0 : mtd->erasesize;
1292e192b24SSimon Glass return ret;
1302e192b24SSimon Glass }
1312e192b24SSimon Glass
onenand_block_write(loff_t to,size_t len,size_t * retlen,const u_char * buf,int withoob)1322e192b24SSimon Glass static int onenand_block_write(loff_t to, size_t len,
1332e192b24SSimon Glass size_t *retlen, const u_char * buf, int withoob)
1342e192b24SSimon Glass {
1352e192b24SSimon Glass struct onenand_chip *this = mtd->priv;
1362e192b24SSimon Glass int blocks = len >> this->erase_shift;
1372e192b24SSimon Glass int blocksize = (1 << this->erase_shift);
1382e192b24SSimon Glass loff_t ofs;
1392e192b24SSimon Glass size_t _retlen = 0;
1402e192b24SSimon Glass int ret;
1412e192b24SSimon Glass
142*9c00d982SLadislav Michl if ((to & (mtd->writesize - 1)) != 0) {
143*9c00d982SLadislav Michl printf("Attempt to write non block-aligned data\n");
144*9c00d982SLadislav Michl *retlen = 0;
145*9c00d982SLadislav Michl return 1;
146*9c00d982SLadislav Michl }
147*9c00d982SLadislav Michl
1482e192b24SSimon Glass if (to == next_ofs) {
1492e192b24SSimon Glass next_ofs = to + len;
1502e192b24SSimon Glass to += skip_ofs;
1512e192b24SSimon Glass } else {
1522e192b24SSimon Glass next_ofs = to + len;
1532e192b24SSimon Glass skip_ofs = 0;
1542e192b24SSimon Glass }
1552e192b24SSimon Glass ofs = to;
1562e192b24SSimon Glass
1572e192b24SSimon Glass while (blocks) {
1582e192b24SSimon Glass ret = mtd_block_isbad(mtd, ofs);
1592e192b24SSimon Glass if (ret) {
1602e192b24SSimon Glass printk("Bad blocks %d at 0x%x\n",
1612e192b24SSimon Glass (u32)(ofs >> this->erase_shift), (u32)ofs);
1622e192b24SSimon Glass skip_ofs += blocksize;
1632e192b24SSimon Glass goto next;
1642e192b24SSimon Glass }
1652e192b24SSimon Glass
1662e192b24SSimon Glass if (!withoob)
1672e192b24SSimon Glass ret = mtd_write(mtd, ofs, blocksize, &_retlen, buf);
1682e192b24SSimon Glass else
1692e192b24SSimon Glass ret = onenand_write_oneblock_withoob(ofs, buf, &_retlen);
1702e192b24SSimon Glass if (ret) {
1712e192b24SSimon Glass printk("Write failed 0x%x, %d", (u32)ofs, ret);
1722e192b24SSimon Glass skip_ofs += blocksize;
1732e192b24SSimon Glass goto next;
1742e192b24SSimon Glass }
1752e192b24SSimon Glass
1762e192b24SSimon Glass buf += blocksize;
1772e192b24SSimon Glass blocks--;
1782e192b24SSimon Glass *retlen += _retlen;
1792e192b24SSimon Glass next:
1802e192b24SSimon Glass ofs += blocksize;
1812e192b24SSimon Glass }
1822e192b24SSimon Glass
1832e192b24SSimon Glass return 0;
1842e192b24SSimon Glass }
1852e192b24SSimon Glass
onenand_block_erase(u32 start,u32 size,int force)1862e192b24SSimon Glass static int onenand_block_erase(u32 start, u32 size, int force)
1872e192b24SSimon Glass {
1882e192b24SSimon Glass struct onenand_chip *this = mtd->priv;
1892e192b24SSimon Glass struct erase_info instr = {
1902e192b24SSimon Glass .callback = NULL,
1912e192b24SSimon Glass };
1922e192b24SSimon Glass loff_t ofs;
1932e192b24SSimon Glass int ret;
1942e192b24SSimon Glass int blocksize = 1 << this->erase_shift;
1952e192b24SSimon Glass
1962e192b24SSimon Glass for (ofs = start; ofs < (start + size); ofs += blocksize) {
1972e192b24SSimon Glass ret = mtd_block_isbad(mtd, ofs);
1982e192b24SSimon Glass if (ret && !force) {
1992e192b24SSimon Glass printf("Skip erase bad block %d at 0x%x\n",
2002e192b24SSimon Glass (u32)(ofs >> this->erase_shift), (u32)ofs);
2012e192b24SSimon Glass continue;
2022e192b24SSimon Glass }
2032e192b24SSimon Glass
2042e192b24SSimon Glass instr.addr = ofs;
2052e192b24SSimon Glass instr.len = blocksize;
2062e192b24SSimon Glass instr.priv = force;
2072e192b24SSimon Glass instr.mtd = mtd;
2082e192b24SSimon Glass ret = mtd_erase(mtd, &instr);
2092e192b24SSimon Glass if (ret) {
2102e192b24SSimon Glass printf("erase failed block %d at 0x%x\n",
2112e192b24SSimon Glass (u32)(ofs >> this->erase_shift), (u32)ofs);
2122e192b24SSimon Glass continue;
2132e192b24SSimon Glass }
2142e192b24SSimon Glass }
2152e192b24SSimon Glass
2162e192b24SSimon Glass return 0;
2172e192b24SSimon Glass }
2182e192b24SSimon Glass
onenand_block_test(u32 start,u32 size)2192e192b24SSimon Glass static int onenand_block_test(u32 start, u32 size)
2202e192b24SSimon Glass {
2212e192b24SSimon Glass struct onenand_chip *this = mtd->priv;
2222e192b24SSimon Glass struct erase_info instr = {
2232e192b24SSimon Glass .callback = NULL,
2242e192b24SSimon Glass .priv = 0,
2252e192b24SSimon Glass };
2262e192b24SSimon Glass
2272e192b24SSimon Glass int blocks;
2282e192b24SSimon Glass loff_t ofs;
2292e192b24SSimon Glass int blocksize = 1 << this->erase_shift;
2302e192b24SSimon Glass int start_block, end_block;
2312e192b24SSimon Glass size_t retlen;
2322e192b24SSimon Glass u_char *buf;
2332e192b24SSimon Glass u_char *verify_buf;
2342e192b24SSimon Glass int ret;
2352e192b24SSimon Glass
2362e192b24SSimon Glass buf = malloc(blocksize);
2372e192b24SSimon Glass if (!buf) {
2382e192b24SSimon Glass printf("Not enough malloc space available!\n");
2392e192b24SSimon Glass return -1;
2402e192b24SSimon Glass }
2412e192b24SSimon Glass
2422e192b24SSimon Glass verify_buf = malloc(blocksize);
2432e192b24SSimon Glass if (!verify_buf) {
2442e192b24SSimon Glass printf("Not enough malloc space available!\n");
2452e192b24SSimon Glass return -1;
2462e192b24SSimon Glass }
2472e192b24SSimon Glass
2482e192b24SSimon Glass start_block = start >> this->erase_shift;
2492e192b24SSimon Glass end_block = (start + size) >> this->erase_shift;
2502e192b24SSimon Glass
2512e192b24SSimon Glass /* Protect boot-loader from badblock testing */
2522e192b24SSimon Glass if (start_block < 2)
2532e192b24SSimon Glass start_block = 2;
2542e192b24SSimon Glass
2552e192b24SSimon Glass if (end_block > (mtd->size >> this->erase_shift))
2562e192b24SSimon Glass end_block = mtd->size >> this->erase_shift;
2572e192b24SSimon Glass
2582e192b24SSimon Glass blocks = start_block;
2592e192b24SSimon Glass ofs = start;
2602e192b24SSimon Glass while (blocks < end_block) {
2612e192b24SSimon Glass printf("\rTesting block %d at 0x%x", (u32)(ofs >> this->erase_shift), (u32)ofs);
2622e192b24SSimon Glass
2632e192b24SSimon Glass ret = mtd_block_isbad(mtd, ofs);
2642e192b24SSimon Glass if (ret) {
2652e192b24SSimon Glass printf("Skip erase bad block %d at 0x%x\n",
2662e192b24SSimon Glass (u32)(ofs >> this->erase_shift), (u32)ofs);
2672e192b24SSimon Glass goto next;
2682e192b24SSimon Glass }
2692e192b24SSimon Glass
2702e192b24SSimon Glass instr.addr = ofs;
2712e192b24SSimon Glass instr.len = blocksize;
2722e192b24SSimon Glass ret = mtd_erase(mtd, &instr);
2732e192b24SSimon Glass if (ret) {
2742e192b24SSimon Glass printk("Erase failed 0x%x, %d\n", (u32)ofs, ret);
2752e192b24SSimon Glass goto next;
2762e192b24SSimon Glass }
2772e192b24SSimon Glass
2782e192b24SSimon Glass ret = mtd_write(mtd, ofs, blocksize, &retlen, buf);
2792e192b24SSimon Glass if (ret) {
2802e192b24SSimon Glass printk("Write failed 0x%x, %d\n", (u32)ofs, ret);
2812e192b24SSimon Glass goto next;
2822e192b24SSimon Glass }
2832e192b24SSimon Glass
2842e192b24SSimon Glass ret = mtd_read(mtd, ofs, blocksize, &retlen, verify_buf);
2852e192b24SSimon Glass if (ret) {
2862e192b24SSimon Glass printk("Read failed 0x%x, %d\n", (u32)ofs, ret);
2872e192b24SSimon Glass goto next;
2882e192b24SSimon Glass }
2892e192b24SSimon Glass
2902e192b24SSimon Glass if (memcmp(buf, verify_buf, blocksize))
2912e192b24SSimon Glass printk("\nRead/Write test failed at 0x%x\n", (u32)ofs);
2922e192b24SSimon Glass
2932e192b24SSimon Glass next:
2942e192b24SSimon Glass ofs += blocksize;
2952e192b24SSimon Glass blocks++;
2962e192b24SSimon Glass }
2972e192b24SSimon Glass printf("...Done\n");
2982e192b24SSimon Glass
2992e192b24SSimon Glass free(buf);
3002e192b24SSimon Glass free(verify_buf);
3012e192b24SSimon Glass
3022e192b24SSimon Glass return 0;
3032e192b24SSimon Glass }
3042e192b24SSimon Glass
onenand_dump(struct mtd_info * mtd,ulong off,int only_oob)3052e192b24SSimon Glass static int onenand_dump(struct mtd_info *mtd, ulong off, int only_oob)
3062e192b24SSimon Glass {
3072e192b24SSimon Glass int i;
3082e192b24SSimon Glass u_char *datbuf, *oobbuf, *p;
3092e192b24SSimon Glass struct mtd_oob_ops ops;
3102e192b24SSimon Glass loff_t addr;
3112e192b24SSimon Glass
3122e192b24SSimon Glass datbuf = malloc(mtd->writesize + mtd->oobsize);
3132e192b24SSimon Glass oobbuf = malloc(mtd->oobsize);
3142e192b24SSimon Glass if (!datbuf || !oobbuf) {
3152e192b24SSimon Glass puts("No memory for page buffer\n");
3162e192b24SSimon Glass return 1;
3172e192b24SSimon Glass }
3182e192b24SSimon Glass off &= ~(mtd->writesize - 1);
3192e192b24SSimon Glass addr = (loff_t) off;
3202e192b24SSimon Glass memset(&ops, 0, sizeof(ops));
3212e192b24SSimon Glass ops.datbuf = datbuf;
3222e192b24SSimon Glass ops.oobbuf = oobbuf;
3232e192b24SSimon Glass ops.len = mtd->writesize;
3242e192b24SSimon Glass ops.ooblen = mtd->oobsize;
3252e192b24SSimon Glass ops.retlen = 0;
3262e192b24SSimon Glass i = mtd_read_oob(mtd, addr, &ops);
3272e192b24SSimon Glass if (i < 0) {
3282e192b24SSimon Glass printf("Error (%d) reading page %08lx\n", i, off);
3292e192b24SSimon Glass free(datbuf);
3302e192b24SSimon Glass free(oobbuf);
3312e192b24SSimon Glass return 1;
3322e192b24SSimon Glass }
3332e192b24SSimon Glass printf("Page %08lx dump:\n", off);
3342e192b24SSimon Glass i = mtd->writesize >> 4;
3352e192b24SSimon Glass p = datbuf;
3362e192b24SSimon Glass
3372e192b24SSimon Glass while (i--) {
3382e192b24SSimon Glass if (!only_oob)
3392e192b24SSimon Glass printf("\t%02x %02x %02x %02x %02x %02x %02x %02x"
3402e192b24SSimon Glass " %02x %02x %02x %02x %02x %02x %02x %02x\n",
3412e192b24SSimon Glass p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7],
3422e192b24SSimon Glass p[8], p[9], p[10], p[11], p[12], p[13], p[14],
3432e192b24SSimon Glass p[15]);
3442e192b24SSimon Glass p += 16;
3452e192b24SSimon Glass }
3462e192b24SSimon Glass puts("OOB:\n");
3472e192b24SSimon Glass i = mtd->oobsize >> 3;
3482e192b24SSimon Glass p = oobbuf;
3492e192b24SSimon Glass
3502e192b24SSimon Glass while (i--) {
3512e192b24SSimon Glass printf("\t%02x %02x %02x %02x %02x %02x %02x %02x\n",
3522e192b24SSimon Glass p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]);
3532e192b24SSimon Glass p += 8;
3542e192b24SSimon Glass }
3552e192b24SSimon Glass free(datbuf);
3562e192b24SSimon Glass free(oobbuf);
3572e192b24SSimon Glass
3582e192b24SSimon Glass return 0;
3592e192b24SSimon Glass }
3602e192b24SSimon Glass
do_onenand_info(cmd_tbl_t * cmdtp,int flag,int argc,char * const argv[])3612e192b24SSimon Glass static int do_onenand_info(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
3622e192b24SSimon Glass {
3632e192b24SSimon Glass printf("%s\n", mtd->name);
3642e192b24SSimon Glass return 0;
3652e192b24SSimon Glass }
3662e192b24SSimon Glass
do_onenand_bad(cmd_tbl_t * cmdtp,int flag,int argc,char * const argv[])3672e192b24SSimon Glass static int do_onenand_bad(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
3682e192b24SSimon Glass {
3692e192b24SSimon Glass ulong ofs;
3702e192b24SSimon Glass
3712e192b24SSimon Glass mtd = &onenand_mtd;
3722e192b24SSimon Glass /* Currently only one OneNAND device is supported */
3732e192b24SSimon Glass printf("\nDevice %d bad blocks:\n", 0);
3742e192b24SSimon Glass for (ofs = 0; ofs < mtd->size; ofs += mtd->erasesize) {
3752e192b24SSimon Glass if (mtd_block_isbad(mtd, ofs))
3762e192b24SSimon Glass printf(" %08x\n", (u32)ofs);
3772e192b24SSimon Glass }
3782e192b24SSimon Glass
3792e192b24SSimon Glass return 0;
3802e192b24SSimon Glass }
3812e192b24SSimon Glass
do_onenand_read(cmd_tbl_t * cmdtp,int flag,int argc,char * const argv[])3822e192b24SSimon Glass static int do_onenand_read(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
3832e192b24SSimon Glass {
3842e192b24SSimon Glass char *s;
3852e192b24SSimon Glass int oob = 0;
3862e192b24SSimon Glass ulong addr, ofs;
3872e192b24SSimon Glass size_t len;
3882e192b24SSimon Glass int ret = 0;
3892e192b24SSimon Glass size_t retlen = 0;
3902e192b24SSimon Glass
3912e192b24SSimon Glass if (argc < 3)
3922e192b24SSimon Glass return CMD_RET_USAGE;
3932e192b24SSimon Glass
3942e192b24SSimon Glass s = strchr(argv[0], '.');
3952e192b24SSimon Glass if ((s != NULL) && (!strcmp(s, ".oob")))
3962e192b24SSimon Glass oob = 1;
3972e192b24SSimon Glass
3982e192b24SSimon Glass addr = (ulong)simple_strtoul(argv[1], NULL, 16);
3992e192b24SSimon Glass
4002e192b24SSimon Glass printf("\nOneNAND read: ");
4012e192b24SSimon Glass if (arg_off_size_onenand(argc - 2, argv + 2, &ofs, &len) != 0)
4022e192b24SSimon Glass return 1;
4032e192b24SSimon Glass
4042e192b24SSimon Glass ret = onenand_block_read(ofs, len, &retlen, (u8 *)addr, oob);
4052e192b24SSimon Glass
4062e192b24SSimon Glass printf(" %d bytes read: %s\n", retlen, ret ? "ERROR" : "OK");
4072e192b24SSimon Glass
4082e192b24SSimon Glass return ret == 0 ? 0 : 1;
4092e192b24SSimon Glass }
4102e192b24SSimon Glass
do_onenand_write(cmd_tbl_t * cmdtp,int flag,int argc,char * const argv[])4112e192b24SSimon Glass static int do_onenand_write(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
4122e192b24SSimon Glass {
4132e192b24SSimon Glass ulong addr, ofs;
4142e192b24SSimon Glass size_t len;
4152e192b24SSimon Glass int ret = 0, withoob = 0;
4162e192b24SSimon Glass size_t retlen = 0;
4172e192b24SSimon Glass
4182e192b24SSimon Glass if (argc < 3)
4192e192b24SSimon Glass return CMD_RET_USAGE;
4202e192b24SSimon Glass
4212e192b24SSimon Glass if (strncmp(argv[0] + 6, "yaffs", 5) == 0)
4222e192b24SSimon Glass withoob = 1;
4232e192b24SSimon Glass
4242e192b24SSimon Glass addr = (ulong)simple_strtoul(argv[1], NULL, 16);
4252e192b24SSimon Glass
4262e192b24SSimon Glass printf("\nOneNAND write: ");
4272e192b24SSimon Glass if (arg_off_size_onenand(argc - 2, argv + 2, &ofs, &len) != 0)
4282e192b24SSimon Glass return 1;
4292e192b24SSimon Glass
4302e192b24SSimon Glass ret = onenand_block_write(ofs, len, &retlen, (u8 *)addr, withoob);
4312e192b24SSimon Glass
4322e192b24SSimon Glass printf(" %d bytes written: %s\n", retlen, ret ? "ERROR" : "OK");
4332e192b24SSimon Glass
4342e192b24SSimon Glass return ret == 0 ? 0 : 1;
4352e192b24SSimon Glass }
4362e192b24SSimon Glass
do_onenand_erase(cmd_tbl_t * cmdtp,int flag,int argc,char * const argv[])4372e192b24SSimon Glass static int do_onenand_erase(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
4382e192b24SSimon Glass {
4392e192b24SSimon Glass ulong ofs;
4402e192b24SSimon Glass int ret = 0;
4412e192b24SSimon Glass size_t len;
4422e192b24SSimon Glass int force;
4432e192b24SSimon Glass
4442e192b24SSimon Glass /*
4452e192b24SSimon Glass * Syntax is:
4462e192b24SSimon Glass * 0 1 2 3 4
4472e192b24SSimon Glass * onenand erase [force] [off size]
4482e192b24SSimon Glass */
4492e192b24SSimon Glass argc--;
4502e192b24SSimon Glass argv++;
4512e192b24SSimon Glass if (argc)
4522e192b24SSimon Glass {
4532e192b24SSimon Glass if (!strcmp("force", argv[0]))
4542e192b24SSimon Glass {
4552e192b24SSimon Glass force = 1;
4562e192b24SSimon Glass argc--;
4572e192b24SSimon Glass argv++;
4582e192b24SSimon Glass }
4592e192b24SSimon Glass }
4602e192b24SSimon Glass printf("\nOneNAND erase: ");
4612e192b24SSimon Glass
4622e192b24SSimon Glass /* skip first two or three arguments, look for offset and size */
4632e192b24SSimon Glass if (arg_off_size_onenand(argc, argv, &ofs, &len) != 0)
4642e192b24SSimon Glass return 1;
4652e192b24SSimon Glass
4662e192b24SSimon Glass ret = onenand_block_erase(ofs, len, force);
4672e192b24SSimon Glass
4682e192b24SSimon Glass printf("%s\n", ret ? "ERROR" : "OK");
4692e192b24SSimon Glass
4702e192b24SSimon Glass return ret == 0 ? 0 : 1;
4712e192b24SSimon Glass }
4722e192b24SSimon Glass
do_onenand_test(cmd_tbl_t * cmdtp,int flag,int argc,char * const argv[])4732e192b24SSimon Glass static int do_onenand_test(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
4742e192b24SSimon Glass {
4752e192b24SSimon Glass ulong ofs;
4762e192b24SSimon Glass int ret = 0;
4772e192b24SSimon Glass size_t len;
4782e192b24SSimon Glass
4792e192b24SSimon Glass /*
4802e192b24SSimon Glass * Syntax is:
4812e192b24SSimon Glass * 0 1 2 3 4
4822e192b24SSimon Glass * onenand test [force] [off size]
4832e192b24SSimon Glass */
4842e192b24SSimon Glass
4852e192b24SSimon Glass printf("\nOneNAND test: ");
4862e192b24SSimon Glass
4872e192b24SSimon Glass /* skip first two or three arguments, look for offset and size */
4882e192b24SSimon Glass if (arg_off_size_onenand(argc - 1, argv + 1, &ofs, &len) != 0)
4892e192b24SSimon Glass return 1;
4902e192b24SSimon Glass
4912e192b24SSimon Glass ret = onenand_block_test(ofs, len);
4922e192b24SSimon Glass
4932e192b24SSimon Glass printf("%s\n", ret ? "ERROR" : "OK");
4942e192b24SSimon Glass
4952e192b24SSimon Glass return ret == 0 ? 0 : 1;
4962e192b24SSimon Glass }
4972e192b24SSimon Glass
do_onenand_dump(cmd_tbl_t * cmdtp,int flag,int argc,char * const argv[])4982e192b24SSimon Glass static int do_onenand_dump(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
4992e192b24SSimon Glass {
5002e192b24SSimon Glass ulong ofs;
5012e192b24SSimon Glass int ret = 0;
5022e192b24SSimon Glass char *s;
5032e192b24SSimon Glass
5042e192b24SSimon Glass if (argc < 2)
5052e192b24SSimon Glass return CMD_RET_USAGE;
5062e192b24SSimon Glass
5072e192b24SSimon Glass s = strchr(argv[0], '.');
5082e192b24SSimon Glass ofs = (int)simple_strtoul(argv[1], NULL, 16);
5092e192b24SSimon Glass
5102e192b24SSimon Glass if (s != NULL && strcmp(s, ".oob") == 0)
5112e192b24SSimon Glass ret = onenand_dump(mtd, ofs, 1);
5122e192b24SSimon Glass else
5132e192b24SSimon Glass ret = onenand_dump(mtd, ofs, 0);
5142e192b24SSimon Glass
5152e192b24SSimon Glass return ret == 0 ? 1 : 0;
5162e192b24SSimon Glass }
5172e192b24SSimon Glass
do_onenand_markbad(cmd_tbl_t * cmdtp,int flag,int argc,char * const argv[])5182e192b24SSimon Glass static int do_onenand_markbad(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
5192e192b24SSimon Glass {
5202e192b24SSimon Glass int ret = 0;
5212e192b24SSimon Glass ulong addr;
5222e192b24SSimon Glass
5232e192b24SSimon Glass argc -= 2;
5242e192b24SSimon Glass argv += 2;
5252e192b24SSimon Glass
5262e192b24SSimon Glass if (argc <= 0)
5272e192b24SSimon Glass return CMD_RET_USAGE;
5282e192b24SSimon Glass
5292e192b24SSimon Glass while (argc > 0) {
5302e192b24SSimon Glass addr = simple_strtoul(*argv, NULL, 16);
5312e192b24SSimon Glass
5322e192b24SSimon Glass if (mtd_block_markbad(mtd, addr)) {
5332e192b24SSimon Glass printf("block 0x%08lx NOT marked "
5342e192b24SSimon Glass "as bad! ERROR %d\n",
5352e192b24SSimon Glass addr, ret);
5362e192b24SSimon Glass ret = 1;
5372e192b24SSimon Glass } else {
5382e192b24SSimon Glass printf("block 0x%08lx successfully "
5392e192b24SSimon Glass "marked as bad\n",
5402e192b24SSimon Glass addr);
5412e192b24SSimon Glass }
5422e192b24SSimon Glass --argc;
5432e192b24SSimon Glass ++argv;
5442e192b24SSimon Glass }
5452e192b24SSimon Glass return ret;
5462e192b24SSimon Glass }
5472e192b24SSimon Glass
5482e192b24SSimon Glass static cmd_tbl_t cmd_onenand_sub[] = {
5492e192b24SSimon Glass U_BOOT_CMD_MKENT(info, 1, 0, do_onenand_info, "", ""),
5502e192b24SSimon Glass U_BOOT_CMD_MKENT(bad, 1, 0, do_onenand_bad, "", ""),
5512e192b24SSimon Glass U_BOOT_CMD_MKENT(read, 4, 0, do_onenand_read, "", ""),
5522e192b24SSimon Glass U_BOOT_CMD_MKENT(write, 4, 0, do_onenand_write, "", ""),
5532e192b24SSimon Glass U_BOOT_CMD_MKENT(write.yaffs, 4, 0, do_onenand_write, "", ""),
5542e192b24SSimon Glass U_BOOT_CMD_MKENT(erase, 3, 0, do_onenand_erase, "", ""),
5552e192b24SSimon Glass U_BOOT_CMD_MKENT(test, 3, 0, do_onenand_test, "", ""),
5562e192b24SSimon Glass U_BOOT_CMD_MKENT(dump, 2, 0, do_onenand_dump, "", ""),
5572e192b24SSimon Glass U_BOOT_CMD_MKENT(markbad, CONFIG_SYS_MAXARGS, 0, do_onenand_markbad, "", ""),
5582e192b24SSimon Glass };
5592e192b24SSimon Glass
5602e192b24SSimon Glass #ifdef CONFIG_NEEDS_MANUAL_RELOC
onenand_reloc(void)5612e192b24SSimon Glass void onenand_reloc(void) {
5622e192b24SSimon Glass fixup_cmdtable(cmd_onenand_sub, ARRAY_SIZE(cmd_onenand_sub));
5632e192b24SSimon Glass }
5642e192b24SSimon Glass #endif
5652e192b24SSimon Glass
do_onenand(cmd_tbl_t * cmdtp,int flag,int argc,char * const argv[])5662e192b24SSimon Glass static int do_onenand(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
5672e192b24SSimon Glass {
5682e192b24SSimon Glass cmd_tbl_t *c;
5692e192b24SSimon Glass
5702e192b24SSimon Glass if (argc < 2)
5712e192b24SSimon Glass return CMD_RET_USAGE;
5722e192b24SSimon Glass
5732e192b24SSimon Glass mtd = &onenand_mtd;
5742e192b24SSimon Glass
5752e192b24SSimon Glass /* Strip off leading 'onenand' command argument */
5762e192b24SSimon Glass argc--;
5772e192b24SSimon Glass argv++;
5782e192b24SSimon Glass
5792e192b24SSimon Glass c = find_cmd_tbl(argv[0], &cmd_onenand_sub[0], ARRAY_SIZE(cmd_onenand_sub));
5802e192b24SSimon Glass
5812e192b24SSimon Glass if (c)
5822e192b24SSimon Glass return c->cmd(cmdtp, flag, argc, argv);
5832e192b24SSimon Glass else
5842e192b24SSimon Glass return CMD_RET_USAGE;
5852e192b24SSimon Glass }
5862e192b24SSimon Glass
5872e192b24SSimon Glass U_BOOT_CMD(
5882e192b24SSimon Glass onenand, CONFIG_SYS_MAXARGS, 1, do_onenand,
5892e192b24SSimon Glass "OneNAND sub-system",
5902e192b24SSimon Glass "info - show available OneNAND devices\n"
5912e192b24SSimon Glass "onenand bad - show bad blocks\n"
5922e192b24SSimon Glass "onenand read[.oob] addr off size\n"
5932e192b24SSimon Glass "onenand write[.yaffs] addr off size\n"
5942e192b24SSimon Glass " read/write 'size' bytes starting at offset 'off'\n"
5952e192b24SSimon Glass " to/from memory address 'addr', skipping bad blocks.\n"
5962e192b24SSimon Glass "onenand erase [force] [off size] - erase 'size' bytes from\n"
5972e192b24SSimon Glass "onenand test [off size] - test 'size' bytes from\n"
5982e192b24SSimon Glass " offset 'off' (entire device if not specified)\n"
5992e192b24SSimon Glass "onenand dump[.oob] off - dump page\n"
6002e192b24SSimon Glass "onenand markbad off [...] - mark bad block(s) at offset (UNSAFE)"
6012e192b24SSimon Glass );
602