2003-03-26 15:55:25 +09:00
|
|
|
/*
|
|
|
|
* Driver for NAND support, Rick Bronson
|
|
|
|
* borrowed heavily from:
|
|
|
|
* (c) 1999 Machine Vision Holdings, Inc.
|
|
|
|
* (c) 1999, 2000 David Woodhouse <dwmw2@infradead.org>
|
2005-04-04 07:35:21 +09:00
|
|
|
*
|
2010-07-06 02:27:07 +09:00
|
|
|
* Ported 'dynenv' to 'nand env.oob' command
|
|
|
|
* (C) 2010 Nanometrics, Inc.
|
|
|
|
* 'dynenv' -- Dynamic environment offset in NAND OOB
|
|
|
|
* (C) Copyright 2006-2007 OpenMoko, Inc.
|
2005-04-04 07:35:21 +09:00
|
|
|
* Added 16-bit nand support
|
|
|
|
* (C) 2004 Texas Instruments
|
2010-08-03 03:04:24 +09:00
|
|
|
*
|
|
|
|
* Copyright 2010 Freescale Semiconductor
|
|
|
|
* The portions of this file whose copyright is held by Freescale and which
|
|
|
|
* are not considered a derived work of GPL v2-only code may be distributed
|
|
|
|
* and/or modified under the terms of the GNU General Public License as
|
|
|
|
* published by the Free Software Foundation; either version 2 of the
|
|
|
|
* License, or (at your option) any later version.
|
2003-03-26 15:55:25 +09:00
|
|
|
*/
|
|
|
|
|
|
|
|
#include <common.h>
|
2007-10-31 21:53:06 +09:00
|
|
|
#include <linux/mtd/mtd.h>
|
2006-03-06 02:57:33 +09:00
|
|
|
#include <command.h>
|
|
|
|
#include <watchdog.h>
|
|
|
|
#include <malloc.h>
|
|
|
|
#include <asm/byteorder.h>
|
|
|
|
#include <jffs2/jffs2.h>
|
|
|
|
#include <nand.h>
|
|
|
|
|
2009-04-21 09:26:31 +09:00
|
|
|
#if defined(CONFIG_CMD_MTDPARTS)
|
2006-10-28 22:55:52 +09:00
|
|
|
|
2009-11-18 05:27:39 +09:00
|
|
|
/* partition handling routines */
|
2006-10-28 22:55:52 +09:00
|
|
|
int mtdparts_init(void);
|
|
|
|
int id_parse(const char *id, const char **ret_id, u8 *dev_type, u8 *dev_num);
|
|
|
|
int find_dev_and_part(const char *id, struct mtd_device **dev,
|
2008-08-14 21:41:06 +09:00
|
|
|
u8 *part_num, struct part_info **part);
|
2006-10-28 22:55:52 +09:00
|
|
|
#endif
|
|
|
|
|
2010-08-26 05:24:01 +09:00
|
|
|
static int nand_dump(nand_info_t *nand, ulong off, int only_oob, int repeat)
|
2006-03-06 02:57:33 +09:00
|
|
|
{
|
|
|
|
int i;
|
2007-12-15 00:33:45 +09:00
|
|
|
u_char *datbuf, *oobbuf, *p;
|
2010-08-26 05:24:01 +09:00
|
|
|
static loff_t last;
|
|
|
|
|
|
|
|
if (repeat)
|
|
|
|
off = last + nand->writesize;
|
|
|
|
|
|
|
|
last = off;
|
2006-03-06 02:57:33 +09:00
|
|
|
|
2007-12-15 00:33:45 +09:00
|
|
|
datbuf = malloc(nand->writesize + nand->oobsize);
|
|
|
|
oobbuf = malloc(nand->oobsize);
|
|
|
|
if (!datbuf || !oobbuf) {
|
2006-03-06 02:57:33 +09:00
|
|
|
puts("No memory for page buffer\n");
|
|
|
|
return 1;
|
|
|
|
}
|
2007-10-31 21:53:06 +09:00
|
|
|
off &= ~(nand->writesize - 1);
|
|
|
|
loff_t addr = (loff_t) off;
|
2007-12-15 00:33:45 +09:00
|
|
|
struct mtd_oob_ops ops;
|
|
|
|
memset(&ops, 0, sizeof(ops));
|
|
|
|
ops.datbuf = datbuf;
|
|
|
|
ops.oobbuf = oobbuf; /* must exist, but oob data will be appended to ops.datbuf */
|
|
|
|
ops.len = nand->writesize;
|
|
|
|
ops.ooblen = nand->oobsize;
|
|
|
|
ops.mode = MTD_OOB_RAW;
|
|
|
|
i = nand->read_oob(nand, addr, &ops);
|
2006-03-06 02:57:33 +09:00
|
|
|
if (i < 0) {
|
2008-07-10 17:10:54 +09:00
|
|
|
printf("Error (%d) reading page %08lx\n", i, off);
|
2007-12-15 00:33:45 +09:00
|
|
|
free(datbuf);
|
|
|
|
free(oobbuf);
|
2006-03-06 02:57:33 +09:00
|
|
|
return 1;
|
|
|
|
}
|
2008-07-10 17:10:54 +09:00
|
|
|
printf("Page %08lx dump:\n", off);
|
2007-12-15 00:33:45 +09:00
|
|
|
i = nand->writesize >> 4;
|
|
|
|
p = datbuf;
|
2008-08-14 21:41:06 +09:00
|
|
|
|
2006-03-06 02:57:33 +09:00
|
|
|
while (i--) {
|
2007-12-15 00:33:45 +09:00
|
|
|
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],
|
2008-06-13 03:20:16 +09:00
|
|
|
p[8], p[9], p[10], p[11], p[12], p[13], p[14],
|
|
|
|
p[15]);
|
2006-03-06 02:57:33 +09:00
|
|
|
p += 16;
|
|
|
|
}
|
|
|
|
puts("OOB:\n");
|
|
|
|
i = nand->oobsize >> 3;
|
|
|
|
while (i--) {
|
2007-10-31 21:53:06 +09:00
|
|
|
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]);
|
2006-03-06 02:57:33 +09:00
|
|
|
p += 8;
|
|
|
|
}
|
2007-12-15 00:33:45 +09:00
|
|
|
free(datbuf);
|
|
|
|
free(oobbuf);
|
2006-03-06 02:57:33 +09:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* ------------------------------------------------------------------------- */
|
|
|
|
|
2010-08-03 03:04:24 +09:00
|
|
|
static int set_dev(int dev)
|
|
|
|
{
|
|
|
|
if (dev < 0 || dev >= CONFIG_SYS_MAX_NAND_DEVICE ||
|
|
|
|
!nand_info[dev].name) {
|
|
|
|
puts("No such device\n");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (nand_curr_device == dev)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
printf("Device %d: %s", dev, nand_info[dev].name);
|
|
|
|
puts("... is now current device\n");
|
|
|
|
nand_curr_device = dev;
|
|
|
|
|
|
|
|
#ifdef CONFIG_SYS_NAND_SELECT_DEVICE
|
|
|
|
board_nand_select_device(nand_info[dev].priv, dev);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int str2off(const char *p, loff_t *num)
|
|
|
|
{
|
|
|
|
char *endptr;
|
|
|
|
|
|
|
|
*num = simple_strtoull(p, &endptr, 16);
|
|
|
|
return *p != '\0' && *endptr == '\0';
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int str2long(const char *p, ulong *num)
|
2006-03-06 02:57:33 +09:00
|
|
|
{
|
2006-10-28 22:55:52 +09:00
|
|
|
char *endptr;
|
2006-03-06 02:57:33 +09:00
|
|
|
|
2006-10-28 22:55:52 +09:00
|
|
|
*num = simple_strtoul(p, &endptr, 16);
|
2010-08-03 03:04:24 +09:00
|
|
|
return *p != '\0' && *endptr == '\0';
|
2006-10-28 22:55:52 +09:00
|
|
|
}
|
2006-03-06 02:57:33 +09:00
|
|
|
|
2010-08-03 03:04:24 +09:00
|
|
|
static int get_part(const char *partname, int *idx, loff_t *off, loff_t *size)
|
2006-10-28 22:55:52 +09:00
|
|
|
{
|
2010-08-03 03:04:24 +09:00
|
|
|
#ifdef CONFIG_CMD_MTDPARTS
|
2006-10-28 22:55:52 +09:00
|
|
|
struct mtd_device *dev;
|
|
|
|
struct part_info *part;
|
|
|
|
u8 pnum;
|
2010-08-03 03:04:24 +09:00
|
|
|
int ret;
|
2006-10-28 22:55:52 +09:00
|
|
|
|
2010-08-03 03:04:24 +09:00
|
|
|
ret = mtdparts_init();
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
ret = find_dev_and_part(partname, &dev, &pnum, &part);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
if (dev->id->type != MTD_DEV_TYPE_NAND) {
|
|
|
|
puts("not a NAND device\n");
|
|
|
|
return -1;
|
2006-10-28 22:55:52 +09:00
|
|
|
}
|
2010-08-03 03:04:24 +09:00
|
|
|
|
|
|
|
*off = part->offset;
|
|
|
|
*size = part->size;
|
|
|
|
*idx = dev->id->num;
|
|
|
|
|
|
|
|
ret = set_dev(*idx);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
#else
|
|
|
|
puts("offset is not a number\n");
|
|
|
|
return -1;
|
2006-03-06 02:57:33 +09:00
|
|
|
#endif
|
2010-08-03 03:04:24 +09:00
|
|
|
}
|
2006-03-06 02:57:33 +09:00
|
|
|
|
2010-08-03 03:04:24 +09:00
|
|
|
static int arg_off(const char *arg, int *idx, loff_t *off, loff_t *maxsize)
|
|
|
|
{
|
|
|
|
if (!str2off(arg, off))
|
|
|
|
return get_part(arg, idx, off, maxsize);
|
|
|
|
|
|
|
|
if (*off >= nand_info[*idx].size) {
|
|
|
|
puts("Offset exceeds device limit\n");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
*maxsize = nand_info[*idx].size - *off;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int arg_off_size(int argc, char *const argv[], int *idx,
|
|
|
|
loff_t *off, loff_t *size)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
loff_t maxsize;
|
|
|
|
|
|
|
|
if (argc == 0) {
|
2006-10-28 22:55:52 +09:00
|
|
|
*off = 0;
|
2010-08-03 03:04:24 +09:00
|
|
|
*size = nand_info[*idx].size;
|
|
|
|
goto print;
|
2006-10-28 22:55:52 +09:00
|
|
|
}
|
2006-03-06 02:57:33 +09:00
|
|
|
|
2010-08-03 03:04:24 +09:00
|
|
|
ret = arg_off(argv[0], idx, off, &maxsize);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
if (argc == 1) {
|
|
|
|
*size = maxsize;
|
|
|
|
goto print;
|
2006-03-06 02:57:33 +09:00
|
|
|
}
|
|
|
|
|
2010-08-03 03:04:24 +09:00
|
|
|
if (!str2off(argv[1], size)) {
|
|
|
|
printf("'%s' is not a number\n", argv[1]);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (*size > maxsize) {
|
|
|
|
puts("Size exceeds partition or device limit\n");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
print:
|
|
|
|
printf("device %d ", *idx);
|
|
|
|
if (*size == nand_info[*idx].size)
|
2006-10-28 22:55:52 +09:00
|
|
|
puts("whole chip\n");
|
|
|
|
else
|
2010-08-03 03:04:24 +09:00
|
|
|
printf("offset 0x%llx, size 0x%llx\n",
|
|
|
|
(unsigned long long)*off, (unsigned long long)*size);
|
2006-10-28 22:55:52 +09:00
|
|
|
return 0;
|
2006-03-06 02:57:33 +09:00
|
|
|
}
|
|
|
|
|
2008-12-14 00:43:06 +09:00
|
|
|
#ifdef CONFIG_CMD_NAND_LOCK_UNLOCK
|
|
|
|
static void print_status(ulong start, ulong end, ulong erasesize, int status)
|
|
|
|
{
|
|
|
|
printf("%08lx - %08lx: %08lx blocks %s%s%s\n",
|
|
|
|
start,
|
|
|
|
end - 1,
|
|
|
|
(end - start) / erasesize,
|
|
|
|
((status & NAND_LOCK_STATUS_TIGHT) ? "TIGHT " : ""),
|
|
|
|
((status & NAND_LOCK_STATUS_LOCK) ? "LOCK " : ""),
|
|
|
|
((status & NAND_LOCK_STATUS_UNLOCK) ? "UNLOCK " : ""));
|
|
|
|
}
|
|
|
|
|
|
|
|
static void do_nand_status(nand_info_t *nand)
|
|
|
|
{
|
|
|
|
ulong block_start = 0;
|
|
|
|
ulong off;
|
|
|
|
int last_status = -1;
|
|
|
|
|
|
|
|
struct nand_chip *nand_chip = nand->priv;
|
|
|
|
/* check the WP bit */
|
|
|
|
nand_chip->cmdfunc(nand, NAND_CMD_STATUS, -1, -1);
|
|
|
|
printf("device is %swrite protected\n",
|
|
|
|
(nand_chip->read_byte(nand) & 0x80 ?
|
|
|
|
"NOT " : ""));
|
|
|
|
|
|
|
|
for (off = 0; off < nand->size; off += nand->erasesize) {
|
|
|
|
int s = nand_get_lock_status(nand, off);
|
|
|
|
|
|
|
|
/* print message only if status has changed */
|
|
|
|
if (s != last_status && off != 0) {
|
|
|
|
print_status(block_start, off, nand->erasesize,
|
|
|
|
last_status);
|
|
|
|
block_start = off;
|
|
|
|
}
|
|
|
|
last_status = s;
|
|
|
|
}
|
|
|
|
/* Print the last block info */
|
|
|
|
print_status(block_start, off, nand->erasesize, last_status);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2010-07-06 02:27:07 +09:00
|
|
|
#ifdef CONFIG_ENV_OFFSET_OOB
|
|
|
|
unsigned long nand_env_oob_offset;
|
|
|
|
|
2010-08-03 03:04:24 +09:00
|
|
|
int do_nand_env_oob(cmd_tbl_t *cmdtp, int argc, char *const argv[])
|
2010-07-06 02:27:07 +09:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
uint32_t oob_buf[ENV_OFFSET_SIZE/sizeof(uint32_t)];
|
2010-08-03 03:04:24 +09:00
|
|
|
nand_info_t *nand = &nand_info[0];
|
2010-07-06 02:27:07 +09:00
|
|
|
char *cmd = argv[1];
|
|
|
|
|
2010-08-03 03:04:24 +09:00
|
|
|
if (CONFIG_SYS_MAX_NAND_DEVICE == 0 || !nand->name) {
|
|
|
|
puts("no devices available\n");
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
set_dev(0);
|
|
|
|
|
2010-07-06 02:27:07 +09:00
|
|
|
if (!strcmp(cmd, "get")) {
|
|
|
|
ret = get_nand_env_oob(nand, &nand_env_oob_offset);
|
2010-07-13 08:17:40 +09:00
|
|
|
if (ret)
|
2010-07-06 02:27:07 +09:00
|
|
|
return 1;
|
2010-07-13 08:17:40 +09:00
|
|
|
|
|
|
|
printf("0x%08lx\n", nand_env_oob_offset);
|
2010-07-06 02:27:07 +09:00
|
|
|
} else if (!strcmp(cmd, "set")) {
|
2010-08-03 03:04:24 +09:00
|
|
|
loff_t addr;
|
|
|
|
loff_t maxsize;
|
2010-07-06 02:27:07 +09:00
|
|
|
struct mtd_oob_ops ops;
|
2010-08-03 03:04:24 +09:00
|
|
|
int idx = 0;
|
2010-07-06 02:27:07 +09:00
|
|
|
|
|
|
|
if (argc < 3)
|
|
|
|
goto usage;
|
|
|
|
|
2010-08-03 03:04:24 +09:00
|
|
|
if (arg_off(argv[2], &idx, &addr, &maxsize)) {
|
|
|
|
puts("Offset or partition name expected\n");
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (idx != 0) {
|
|
|
|
puts("Partition not on first NAND device\n");
|
2010-07-06 02:27:07 +09:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (nand->oobavail < ENV_OFFSET_SIZE) {
|
2010-07-13 08:17:40 +09:00
|
|
|
printf("Insufficient available OOB bytes:\n"
|
|
|
|
"%d OOB bytes available but %d required for "
|
|
|
|
"env.oob support\n",
|
|
|
|
nand->oobavail, ENV_OFFSET_SIZE);
|
2010-07-06 02:27:07 +09:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((addr & (nand->erasesize - 1)) != 0) {
|
|
|
|
printf("Environment offset must be block-aligned\n");
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
ops.datbuf = NULL;
|
|
|
|
ops.mode = MTD_OOB_AUTO;
|
|
|
|
ops.ooboffs = 0;
|
|
|
|
ops.ooblen = ENV_OFFSET_SIZE;
|
|
|
|
ops.oobbuf = (void *) oob_buf;
|
|
|
|
|
|
|
|
oob_buf[0] = ENV_OOB_MARKER;
|
|
|
|
oob_buf[1] = addr / nand->erasesize;
|
|
|
|
|
|
|
|
ret = nand->write_oob(nand, ENV_OFFSET_SIZE, &ops);
|
2010-07-13 08:17:40 +09:00
|
|
|
if (ret) {
|
2010-07-06 02:27:07 +09:00
|
|
|
printf("Error writing OOB block 0\n");
|
|
|
|
return ret;
|
|
|
|
}
|
2010-07-13 08:17:40 +09:00
|
|
|
|
|
|
|
ret = get_nand_env_oob(nand, &nand_env_oob_offset);
|
|
|
|
if (ret) {
|
|
|
|
printf("Error reading env offset in OOB\n");
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (addr != nand_env_oob_offset) {
|
|
|
|
printf("Verification of env offset in OOB failed: "
|
2010-08-03 03:04:24 +09:00
|
|
|
"0x%08llx expected but got 0x%08lx\n",
|
|
|
|
(unsigned long long)addr, nand_env_oob_offset);
|
2010-07-13 08:17:40 +09:00
|
|
|
return 1;
|
|
|
|
}
|
2010-07-06 02:27:07 +09:00
|
|
|
} else {
|
|
|
|
goto usage;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
usage:
|
2010-07-17 08:06:04 +09:00
|
|
|
return cmd_usage(cmdtp);
|
2010-07-06 02:27:07 +09:00
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
2009-02-12 02:38:20 +09:00
|
|
|
static void nand_print_info(int idx)
|
|
|
|
{
|
|
|
|
nand_info_t *nand = &nand_info[idx];
|
|
|
|
struct nand_chip *chip = nand->priv;
|
|
|
|
printf("Device %d: ", idx);
|
|
|
|
if (chip->numchips > 1)
|
|
|
|
printf("%dx ", chip->numchips);
|
|
|
|
printf("%s, sector size %u KiB\n",
|
|
|
|
nand->name, nand->erasesize >> 10);
|
|
|
|
}
|
|
|
|
|
2010-06-29 05:00:46 +09:00
|
|
|
int do_nand(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
|
2006-03-06 02:57:33 +09:00
|
|
|
{
|
2010-08-03 03:04:24 +09:00
|
|
|
int i, ret = 0;
|
|
|
|
ulong addr;
|
|
|
|
loff_t off, size;
|
2006-03-06 02:57:33 +09:00
|
|
|
char *cmd, *s;
|
|
|
|
nand_info_t *nand;
|
2008-10-16 22:01:15 +09:00
|
|
|
#ifdef CONFIG_SYS_NAND_QUIET
|
|
|
|
int quiet = CONFIG_SYS_NAND_QUIET;
|
2007-09-12 19:36:53 +09:00
|
|
|
#else
|
2006-10-10 19:36:02 +09:00
|
|
|
int quiet = 0;
|
2007-09-12 19:36:53 +09:00
|
|
|
#endif
|
2006-10-10 19:36:02 +09:00
|
|
|
const char *quiet_str = getenv("quiet");
|
2010-08-03 03:04:24 +09:00
|
|
|
int dev = nand_curr_device;
|
2010-08-26 05:24:01 +09:00
|
|
|
int repeat = flag & CMD_FLAG_REPEAT;
|
2006-03-06 02:57:33 +09:00
|
|
|
|
|
|
|
/* at least two arguments please */
|
|
|
|
if (argc < 2)
|
|
|
|
goto usage;
|
|
|
|
|
2006-10-10 19:36:02 +09:00
|
|
|
if (quiet_str)
|
|
|
|
quiet = simple_strtoul(quiet_str, NULL, 0) != 0;
|
|
|
|
|
2006-03-06 02:57:33 +09:00
|
|
|
cmd = argv[1];
|
|
|
|
|
2010-08-26 05:24:01 +09:00
|
|
|
/* Only "dump" is repeatable. */
|
|
|
|
if (repeat && strcmp(cmd, "dump"))
|
|
|
|
return 0;
|
|
|
|
|
2006-03-06 02:57:33 +09:00
|
|
|
if (strcmp(cmd, "info") == 0) {
|
|
|
|
|
|
|
|
putc('\n');
|
2008-10-16 22:01:15 +09:00
|
|
|
for (i = 0; i < CONFIG_SYS_MAX_NAND_DEVICE; i++) {
|
2006-03-06 02:57:33 +09:00
|
|
|
if (nand_info[i].name)
|
2009-02-12 02:38:20 +09:00
|
|
|
nand_print_info(i);
|
2006-03-06 02:57:33 +09:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (strcmp(cmd, "device") == 0) {
|
|
|
|
if (argc < 3) {
|
2009-02-12 02:38:20 +09:00
|
|
|
putc('\n');
|
2010-08-03 03:04:24 +09:00
|
|
|
if (dev < 0 || dev >= CONFIG_SYS_MAX_NAND_DEVICE)
|
2009-02-12 02:38:20 +09:00
|
|
|
puts("no devices available\n");
|
2006-03-06 02:57:33 +09:00
|
|
|
else
|
2010-08-03 03:04:24 +09:00
|
|
|
nand_print_info(dev);
|
2006-03-06 02:57:33 +09:00
|
|
|
return 0;
|
|
|
|
}
|
2006-10-20 21:28:52 +09:00
|
|
|
|
2010-08-03 03:04:24 +09:00
|
|
|
dev = (int)simple_strtoul(argv[2], NULL, 10);
|
|
|
|
set_dev(dev);
|
2006-10-20 21:28:52 +09:00
|
|
|
|
2006-03-06 02:57:33 +09:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-07-06 02:27:07 +09:00
|
|
|
#ifdef CONFIG_ENV_OFFSET_OOB
|
|
|
|
/* this command operates only on the first nand device */
|
2010-08-03 03:04:24 +09:00
|
|
|
if (strcmp(cmd, "env.oob") == 0)
|
|
|
|
return do_nand_env_oob(cmdtp, argc - 1, argv + 1);
|
2010-07-06 02:27:07 +09:00
|
|
|
#endif
|
|
|
|
|
2010-08-03 03:04:24 +09:00
|
|
|
/* The following commands operate on the current device, unless
|
|
|
|
* overridden by a partition specifier. Note that if somehow the
|
|
|
|
* current device is invalid, it will have to be changed to a valid
|
|
|
|
* one before these commands can run, even if a partition specifier
|
|
|
|
* for another device is to be used.
|
|
|
|
*/
|
|
|
|
if (dev < 0 || dev >= CONFIG_SYS_MAX_NAND_DEVICE ||
|
|
|
|
!nand_info[dev].name) {
|
2006-03-06 02:57:33 +09:00
|
|
|
puts("\nno devices available\n");
|
|
|
|
return 1;
|
|
|
|
}
|
2010-08-03 03:04:24 +09:00
|
|
|
nand = &nand_info[dev];
|
2006-03-06 02:57:33 +09:00
|
|
|
|
|
|
|
if (strcmp(cmd, "bad") == 0) {
|
2010-08-03 03:04:24 +09:00
|
|
|
printf("\nDevice %d bad blocks:\n", dev);
|
2006-03-06 02:57:33 +09:00
|
|
|
for (off = 0; off < nand->size; off += nand->erasesize)
|
|
|
|
if (nand_block_isbad(nand, off))
|
2010-08-03 03:04:24 +09:00
|
|
|
printf(" %08llx\n", (unsigned long long)off);
|
2006-03-06 02:57:33 +09:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-10-28 22:55:52 +09:00
|
|
|
/*
|
|
|
|
* Syntax is:
|
|
|
|
* 0 1 2 3 4
|
|
|
|
* nand erase [clean] [off size]
|
|
|
|
*/
|
nand erase: .spread, .part, .chip subcommands
A while back, in http://lists.denx.de/pipermail/u-boot/2009-June/054428.html,
Michele De Candia posted a patch to not count bad blocks toward the
requested size to be erased. This is desireable when you're passing in
something like $filesize, but not when you're trying to erase a partition.
Thus, a .spread subcommand (named for consistency with
http://lists.denx.de/pipermail/u-boot/2010-August/075163.html) is introduced
to make explicit the user's desire to erase for a given amount of data,
rather than to erase a specific region of the chip.
While passing $filesize to "nand erase" is useful, accidentally passing
something like $fliesize currently produces quite unpleasant results, as the
variable evaluates to nothing and U-Boot assumes that you want to erase
the entire rest of the chip/partition. To improve the safety of the
erase command, require the user to make explicit their intentions by
using a .part or .chip subcommand. This is an incompatible user interface
change, but keeping compatibility would eliminate the safety gain, and IMHO
it's worth it.
While touching nand_erase_opts(), make it accept 64-bit offsets and sizes,
fix the percentage display when erase length is rounded up, eliminate
an inconsistent warning about rounding up the erase length which only
happened when the length was less than one block (rounding up for $filesize
is normal operation), and add a diagnostic if there's an attempt to erase
beginning at a non-block boundary.
Signed-off-by: Scott Wood <scottwood@freescale.com>
Tested-by: Ben Gardiner <bengardiner@nanometrics.ca>
2010-08-26 04:43:29 +09:00
|
|
|
if (strncmp(cmd, "erase", 5) == 0 || strncmp(cmd, "scrub", 5) == 0) {
|
2006-10-10 19:36:02 +09:00
|
|
|
nand_erase_options_t opts;
|
2006-10-28 22:55:52 +09:00
|
|
|
/* "clean" at index 2 means request to write cleanmarker */
|
2007-11-14 22:28:11 +09:00
|
|
|
int clean = argc > 2 && !strcmp("clean", argv[2]);
|
2006-10-28 22:55:52 +09:00
|
|
|
int o = clean ? 3 : 2;
|
nand erase: .spread, .part, .chip subcommands
A while back, in http://lists.denx.de/pipermail/u-boot/2009-June/054428.html,
Michele De Candia posted a patch to not count bad blocks toward the
requested size to be erased. This is desireable when you're passing in
something like $filesize, but not when you're trying to erase a partition.
Thus, a .spread subcommand (named for consistency with
http://lists.denx.de/pipermail/u-boot/2010-August/075163.html) is introduced
to make explicit the user's desire to erase for a given amount of data,
rather than to erase a specific region of the chip.
While passing $filesize to "nand erase" is useful, accidentally passing
something like $fliesize currently produces quite unpleasant results, as the
variable evaluates to nothing and U-Boot assumes that you want to erase
the entire rest of the chip/partition. To improve the safety of the
erase command, require the user to make explicit their intentions by
using a .part or .chip subcommand. This is an incompatible user interface
change, but keeping compatibility would eliminate the safety gain, and IMHO
it's worth it.
While touching nand_erase_opts(), make it accept 64-bit offsets and sizes,
fix the percentage display when erase length is rounded up, eliminate
an inconsistent warning about rounding up the erase length which only
happened when the length was less than one block (rounding up for $filesize
is normal operation), and add a diagnostic if there's an attempt to erase
beginning at a non-block boundary.
Signed-off-by: Scott Wood <scottwood@freescale.com>
Tested-by: Ben Gardiner <bengardiner@nanometrics.ca>
2010-08-26 04:43:29 +09:00
|
|
|
int scrub = !strncmp(cmd, "scrub", 5);
|
|
|
|
int part = 0;
|
|
|
|
int chip = 0;
|
|
|
|
int spread = 0;
|
|
|
|
int args = 2;
|
|
|
|
|
|
|
|
if (cmd[5] != 0) {
|
|
|
|
if (!strcmp(&cmd[5], ".spread")) {
|
|
|
|
spread = 1;
|
|
|
|
} else if (!strcmp(&cmd[5], ".part")) {
|
|
|
|
part = 1;
|
|
|
|
args = 1;
|
|
|
|
} else if (!strcmp(&cmd[5], ".chip")) {
|
|
|
|
chip = 1;
|
|
|
|
args = 0;
|
|
|
|
} else {
|
|
|
|
goto usage;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Don't allow missing arguments to cause full chip/partition
|
|
|
|
* erases -- easy to do accidentally, e.g. with a misspelled
|
|
|
|
* variable name.
|
|
|
|
*/
|
|
|
|
if (argc != o + args)
|
|
|
|
goto usage;
|
2006-10-10 19:36:02 +09:00
|
|
|
|
nand erase: .spread, .part, .chip subcommands
A while back, in http://lists.denx.de/pipermail/u-boot/2009-June/054428.html,
Michele De Candia posted a patch to not count bad blocks toward the
requested size to be erased. This is desireable when you're passing in
something like $filesize, but not when you're trying to erase a partition.
Thus, a .spread subcommand (named for consistency with
http://lists.denx.de/pipermail/u-boot/2010-August/075163.html) is introduced
to make explicit the user's desire to erase for a given amount of data,
rather than to erase a specific region of the chip.
While passing $filesize to "nand erase" is useful, accidentally passing
something like $fliesize currently produces quite unpleasant results, as the
variable evaluates to nothing and U-Boot assumes that you want to erase
the entire rest of the chip/partition. To improve the safety of the
erase command, require the user to make explicit their intentions by
using a .part or .chip subcommand. This is an incompatible user interface
change, but keeping compatibility would eliminate the safety gain, and IMHO
it's worth it.
While touching nand_erase_opts(), make it accept 64-bit offsets and sizes,
fix the percentage display when erase length is rounded up, eliminate
an inconsistent warning about rounding up the erase length which only
happened when the length was less than one block (rounding up for $filesize
is normal operation), and add a diagnostic if there's an attempt to erase
beginning at a non-block boundary.
Signed-off-by: Scott Wood <scottwood@freescale.com>
Tested-by: Ben Gardiner <bengardiner@nanometrics.ca>
2010-08-26 04:43:29 +09:00
|
|
|
printf("\nNAND %s: ", cmd);
|
2006-10-28 22:55:52 +09:00
|
|
|
/* skip first two or three arguments, look for offset and size */
|
2010-08-03 03:04:24 +09:00
|
|
|
if (arg_off_size(argc - o, argv + o, &dev, &off, &size) != 0)
|
2006-10-28 22:55:52 +09:00
|
|
|
return 1;
|
2006-10-10 19:36:02 +09:00
|
|
|
|
2010-08-03 03:04:24 +09:00
|
|
|
nand = &nand_info[dev];
|
|
|
|
|
2006-10-10 19:36:02 +09:00
|
|
|
memset(&opts, 0, sizeof(opts));
|
|
|
|
opts.offset = off;
|
|
|
|
opts.length = size;
|
|
|
|
opts.jffs2 = clean;
|
|
|
|
opts.quiet = quiet;
|
nand erase: .spread, .part, .chip subcommands
A while back, in http://lists.denx.de/pipermail/u-boot/2009-June/054428.html,
Michele De Candia posted a patch to not count bad blocks toward the
requested size to be erased. This is desireable when you're passing in
something like $filesize, but not when you're trying to erase a partition.
Thus, a .spread subcommand (named for consistency with
http://lists.denx.de/pipermail/u-boot/2010-August/075163.html) is introduced
to make explicit the user's desire to erase for a given amount of data,
rather than to erase a specific region of the chip.
While passing $filesize to "nand erase" is useful, accidentally passing
something like $fliesize currently produces quite unpleasant results, as the
variable evaluates to nothing and U-Boot assumes that you want to erase
the entire rest of the chip/partition. To improve the safety of the
erase command, require the user to make explicit their intentions by
using a .part or .chip subcommand. This is an incompatible user interface
change, but keeping compatibility would eliminate the safety gain, and IMHO
it's worth it.
While touching nand_erase_opts(), make it accept 64-bit offsets and sizes,
fix the percentage display when erase length is rounded up, eliminate
an inconsistent warning about rounding up the erase length which only
happened when the length was less than one block (rounding up for $filesize
is normal operation), and add a diagnostic if there's an attempt to erase
beginning at a non-block boundary.
Signed-off-by: Scott Wood <scottwood@freescale.com>
Tested-by: Ben Gardiner <bengardiner@nanometrics.ca>
2010-08-26 04:43:29 +09:00
|
|
|
opts.spread = spread;
|
2006-10-10 19:36:02 +09:00
|
|
|
|
|
|
|
if (scrub) {
|
2006-10-28 22:55:52 +09:00
|
|
|
puts("Warning: "
|
|
|
|
"scrub option will erase all factory set "
|
|
|
|
"bad blocks!\n"
|
|
|
|
" "
|
|
|
|
"There is no reliable way to recover them.\n"
|
|
|
|
" "
|
|
|
|
"Use this command only for testing purposes "
|
|
|
|
"if you\n"
|
|
|
|
" "
|
|
|
|
"are sure of what you are doing!\n"
|
|
|
|
"\nReally scrub this NAND flash? <y/N>\n");
|
2006-10-10 19:36:02 +09:00
|
|
|
|
2010-03-21 03:02:58 +09:00
|
|
|
if (getc() == 'y') {
|
|
|
|
puts("y");
|
|
|
|
if (getc() == '\r')
|
|
|
|
opts.scrub = 1;
|
|
|
|
else {
|
|
|
|
puts("scrub aborted\n");
|
|
|
|
return -1;
|
|
|
|
}
|
2006-10-10 19:36:02 +09:00
|
|
|
} else {
|
2006-10-28 22:55:52 +09:00
|
|
|
puts("scrub aborted\n");
|
2006-10-10 19:36:02 +09:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
ret = nand_erase_opts(nand, &opts);
|
2006-03-06 02:57:33 +09:00
|
|
|
printf("%s\n", ret ? "ERROR" : "OK");
|
|
|
|
|
|
|
|
return ret == 0 ? 0 : 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (strncmp(cmd, "dump", 4) == 0) {
|
|
|
|
if (argc < 3)
|
|
|
|
goto usage;
|
|
|
|
|
|
|
|
off = (int)simple_strtoul(argv[2], NULL, 16);
|
2010-08-26 05:24:01 +09:00
|
|
|
ret = nand_dump(nand, off, !strcmp(&cmd[4], ".oob"), repeat);
|
2006-03-06 02:57:33 +09:00
|
|
|
|
|
|
|
return ret == 0 ? 1 : 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (strncmp(cmd, "read", 4) == 0 || strncmp(cmd, "write", 5) == 0) {
|
2010-08-03 03:04:24 +09:00
|
|
|
size_t rwsize;
|
2006-10-10 19:36:02 +09:00
|
|
|
int read;
|
|
|
|
|
2006-03-06 02:57:33 +09:00
|
|
|
if (argc < 4)
|
|
|
|
goto usage;
|
2006-10-10 19:36:02 +09:00
|
|
|
|
2006-03-06 02:57:33 +09:00
|
|
|
addr = (ulong)simple_strtoul(argv[2], NULL, 16);
|
|
|
|
|
2006-10-10 19:36:02 +09:00
|
|
|
read = strncmp(cmd, "read", 4) == 0; /* 1 = read, 0 = write */
|
2006-10-28 22:55:52 +09:00
|
|
|
printf("\nNAND %s: ", read ? "read" : "write");
|
2010-08-03 03:04:24 +09:00
|
|
|
if (arg_off_size(argc - 3, argv + 3, &dev, &off, &size) != 0)
|
2006-10-28 22:55:52 +09:00
|
|
|
return 1;
|
2007-11-08 18:39:53 +09:00
|
|
|
|
2010-08-03 03:04:24 +09:00
|
|
|
nand = &nand_info[dev];
|
|
|
|
rwsize = size;
|
|
|
|
|
2006-10-10 19:36:02 +09:00
|
|
|
s = strchr(cmd, '.');
|
2008-06-13 03:13:23 +09:00
|
|
|
if (!s || !strcmp(s, ".jffs2") ||
|
|
|
|
!strcmp(s, ".e") || !strcmp(s, ".i")) {
|
2008-06-13 03:20:16 +09:00
|
|
|
if (read)
|
2010-08-03 03:04:24 +09:00
|
|
|
ret = nand_read_skip_bad(nand, off, &rwsize,
|
2008-08-14 21:41:06 +09:00
|
|
|
(u_char *)addr);
|
2008-06-13 03:20:16 +09:00
|
|
|
else
|
2010-08-03 03:04:24 +09:00
|
|
|
ret = nand_write_skip_bad(nand, off, &rwsize,
|
2011-01-06 12:11:58 +09:00
|
|
|
(u_char *)addr, 0);
|
2011-06-15 05:35:07 +09:00
|
|
|
#ifdef CONFIG_CMD_NAND_TRIMFFS
|
|
|
|
} else if (!strcmp(s, ".trimffs")) {
|
|
|
|
if (read) {
|
|
|
|
printf("Unknown nand command suffix '%s'\n", s);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
ret = nand_write_skip_bad(nand, off, &rwsize,
|
|
|
|
(u_char *)addr,
|
|
|
|
WITH_DROP_FFS);
|
|
|
|
#endif
|
2011-01-06 12:11:58 +09:00
|
|
|
#ifdef CONFIG_CMD_NAND_YAFFS
|
|
|
|
} else if (!strcmp(s, ".yaffs")) {
|
|
|
|
if (read) {
|
|
|
|
printf("Unknown nand command suffix '%s'.\n", s);
|
|
|
|
return 1;
|
|
|
|
}
|
nand_util: convert nand_write_skip_bad() to flags
In a future commit the behaviour of nand_write_skip_bad()
will be further extended.
Convert the only flag currently passed to the nand_write_
skip_bad() function to a bitfield of only one allocated
member. This should avoid an explosion of int's at the
end of the parameter list or the ambiguous calls like
nand_write_skip_bad(info, offset, len, buf, 0, 1, 1);
nand_write_skip_bad(info, offset, len, buf, 0, 1, 0);
Instead there will be:
nand_write_skip_bad(info, offset, len, buf, WITH_YAFFS_OOB |
WITH_OTHER);
Signed-off-by: Ben Gardiner <bengardiner@nanometrics.ca>
Acked-by: Detlev Zundel <dzu@denx.de>
Signed-off-by: Scott Wood <scottwood@freescale.com>
2011-05-24 23:18:35 +09:00
|
|
|
ret = nand_write_skip_bad(nand, off, &rwsize,
|
|
|
|
(u_char *)addr, WITH_YAFFS_OOB);
|
2011-01-06 12:11:58 +09:00
|
|
|
#endif
|
2009-04-13 11:29:20 +09:00
|
|
|
} else if (!strcmp(s, ".oob")) {
|
2007-10-31 21:53:06 +09:00
|
|
|
/* out-of-band data */
|
|
|
|
mtd_oob_ops_t ops = {
|
|
|
|
.oobbuf = (u8 *)addr,
|
2010-08-03 03:04:24 +09:00
|
|
|
.ooblen = rwsize,
|
2007-10-31 21:53:06 +09:00
|
|
|
.mode = MTD_OOB_RAW
|
|
|
|
};
|
|
|
|
|
2007-12-19 22:12:53 +09:00
|
|
|
if (read)
|
2007-10-31 21:53:06 +09:00
|
|
|
ret = nand->read_oob(nand, off, &ops);
|
2007-12-19 22:12:53 +09:00
|
|
|
else
|
2007-10-31 21:53:06 +09:00
|
|
|
ret = nand->write_oob(nand, off, &ops);
|
2006-10-28 22:55:52 +09:00
|
|
|
} else {
|
2008-06-13 03:13:23 +09:00
|
|
|
printf("Unknown nand command suffix '%s'.\n", s);
|
|
|
|
return 1;
|
2006-10-10 19:36:02 +09:00
|
|
|
}
|
|
|
|
|
2010-08-03 03:04:24 +09:00
|
|
|
printf(" %zu bytes %s: %s\n", rwsize,
|
2006-10-10 19:36:02 +09:00
|
|
|
read ? "read" : "written", ret ? "ERROR" : "OK");
|
2006-03-06 02:57:33 +09:00
|
|
|
|
|
|
|
return ret == 0 ? 0 : 1;
|
|
|
|
}
|
2006-10-10 19:36:02 +09:00
|
|
|
|
|
|
|
if (strcmp(cmd, "markbad") == 0) {
|
2009-05-25 00:34:33 +09:00
|
|
|
argc -= 2;
|
|
|
|
argv += 2;
|
2006-10-10 19:36:02 +09:00
|
|
|
|
2009-05-25 00:34:33 +09:00
|
|
|
if (argc <= 0)
|
|
|
|
goto usage;
|
|
|
|
|
|
|
|
while (argc > 0) {
|
|
|
|
addr = simple_strtoul(*argv, NULL, 16);
|
|
|
|
|
|
|
|
if (nand->block_markbad(nand, 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;
|
2006-10-10 19:36:02 +09:00
|
|
|
}
|
2009-05-25 00:34:33 +09:00
|
|
|
return ret;
|
2006-10-10 19:36:02 +09:00
|
|
|
}
|
2008-06-13 03:20:16 +09:00
|
|
|
|
2006-10-10 19:36:02 +09:00
|
|
|
if (strcmp(cmd, "biterr") == 0) {
|
|
|
|
/* todo */
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2008-12-14 00:43:06 +09:00
|
|
|
#ifdef CONFIG_CMD_NAND_LOCK_UNLOCK
|
2006-10-10 19:36:02 +09:00
|
|
|
if (strcmp(cmd, "lock") == 0) {
|
2008-12-14 00:43:06 +09:00
|
|
|
int tight = 0;
|
2006-10-10 19:36:02 +09:00
|
|
|
int status = 0;
|
|
|
|
if (argc == 3) {
|
|
|
|
if (!strcmp("tight", argv[2]))
|
|
|
|
tight = 1;
|
|
|
|
if (!strcmp("status", argv[2]))
|
|
|
|
status = 1;
|
|
|
|
}
|
|
|
|
if (status) {
|
2008-12-14 00:43:06 +09:00
|
|
|
do_nand_status(nand);
|
2007-10-31 21:53:06 +09:00
|
|
|
} else {
|
2007-11-09 21:32:30 +09:00
|
|
|
if (!nand_lock(nand, tight)) {
|
|
|
|
puts("NAND flash successfully locked\n");
|
|
|
|
} else {
|
|
|
|
puts("Error locking NAND flash\n");
|
|
|
|
return 1;
|
|
|
|
}
|
2006-10-10 19:36:02 +09:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (strcmp(cmd, "unlock") == 0) {
|
2010-10-14 01:04:30 +09:00
|
|
|
if (arg_off_size(argc - 2, argv + 2, &dev, &off, &size) < 0)
|
2006-10-28 22:55:52 +09:00
|
|
|
return 1;
|
2006-10-10 19:36:02 +09:00
|
|
|
|
2010-08-03 03:04:24 +09:00
|
|
|
if (!nand_unlock(&nand_info[dev], off, size)) {
|
2007-11-09 21:32:30 +09:00
|
|
|
puts("NAND flash successfully unlocked\n");
|
|
|
|
} else {
|
|
|
|
puts("Error unlocking NAND flash, "
|
2007-11-14 22:28:11 +09:00
|
|
|
"write and erase will probably fail\n");
|
2007-11-09 21:32:30 +09:00
|
|
|
return 1;
|
|
|
|
}
|
2006-10-10 19:36:02 +09:00
|
|
|
return 0;
|
|
|
|
}
|
2008-12-14 00:43:06 +09:00
|
|
|
#endif
|
2006-10-10 19:36:02 +09:00
|
|
|
|
2006-03-06 02:57:33 +09:00
|
|
|
usage:
|
2010-07-17 08:06:04 +09:00
|
|
|
return cmd_usage(cmdtp);
|
2006-03-06 02:57:33 +09:00
|
|
|
}
|
|
|
|
|
2010-07-31 22:01:53 +09:00
|
|
|
U_BOOT_CMD(
|
|
|
|
nand, CONFIG_SYS_MAXARGS, 1, do_nand,
|
2009-05-25 00:06:54 +09:00
|
|
|
"NAND sub-system",
|
|
|
|
"info - show available NAND devices\n"
|
|
|
|
"nand device [dev] - show or set current device\n"
|
|
|
|
"nand read - addr off|partition size\n"
|
|
|
|
"nand write - addr off|partition size\n"
|
|
|
|
" read/write 'size' bytes starting at offset 'off'\n"
|
|
|
|
" to/from memory address 'addr', skipping bad blocks.\n"
|
2011-06-15 05:35:07 +09:00
|
|
|
#ifdef CONFIG_CMD_NAND_TRIMFFS
|
|
|
|
"nand write.trimffs - addr off|partition size\n"
|
|
|
|
" write 'size' bytes starting at offset 'off' from memory address\n"
|
|
|
|
" 'addr', skipping bad blocks and dropping any pages at the end\n"
|
|
|
|
" of eraseblocks that contain only 0xFF\n"
|
|
|
|
#endif
|
2011-01-06 12:11:58 +09:00
|
|
|
#ifdef CONFIG_CMD_NAND_YAFFS
|
|
|
|
"nand write.yaffs - addr off|partition size\n"
|
|
|
|
" write 'size' bytes starting at offset 'off' with yaffs format\n"
|
|
|
|
" from memory address 'addr', skipping bad blocks.\n"
|
|
|
|
#endif
|
2011-05-20 02:28:54 +09:00
|
|
|
"nand erase[.spread] [clean] off size - erase 'size' bytes "
|
nand erase: .spread, .part, .chip subcommands
A while back, in http://lists.denx.de/pipermail/u-boot/2009-June/054428.html,
Michele De Candia posted a patch to not count bad blocks toward the
requested size to be erased. This is desireable when you're passing in
something like $filesize, but not when you're trying to erase a partition.
Thus, a .spread subcommand (named for consistency with
http://lists.denx.de/pipermail/u-boot/2010-August/075163.html) is introduced
to make explicit the user's desire to erase for a given amount of data,
rather than to erase a specific region of the chip.
While passing $filesize to "nand erase" is useful, accidentally passing
something like $fliesize currently produces quite unpleasant results, as the
variable evaluates to nothing and U-Boot assumes that you want to erase
the entire rest of the chip/partition. To improve the safety of the
erase command, require the user to make explicit their intentions by
using a .part or .chip subcommand. This is an incompatible user interface
change, but keeping compatibility would eliminate the safety gain, and IMHO
it's worth it.
While touching nand_erase_opts(), make it accept 64-bit offsets and sizes,
fix the percentage display when erase length is rounded up, eliminate
an inconsistent warning about rounding up the erase length which only
happened when the length was less than one block (rounding up for $filesize
is normal operation), and add a diagnostic if there's an attempt to erase
beginning at a non-block boundary.
Signed-off-by: Scott Wood <scottwood@freescale.com>
Tested-by: Ben Gardiner <bengardiner@nanometrics.ca>
2010-08-26 04:43:29 +09:00
|
|
|
"from offset 'off'\n"
|
|
|
|
" With '.spread', erase enough for given file size, otherwise,\n"
|
|
|
|
" 'size' includes skipped bad blocks.\n"
|
|
|
|
"nand erase.part [clean] partition - erase entire mtd partition'\n"
|
|
|
|
"nand erase.chip [clean] - erase entire chip'\n"
|
2009-05-25 00:06:54 +09:00
|
|
|
"nand bad - show bad blocks\n"
|
|
|
|
"nand dump[.oob] off - dump page\n"
|
nand erase: .spread, .part, .chip subcommands
A while back, in http://lists.denx.de/pipermail/u-boot/2009-June/054428.html,
Michele De Candia posted a patch to not count bad blocks toward the
requested size to be erased. This is desireable when you're passing in
something like $filesize, but not when you're trying to erase a partition.
Thus, a .spread subcommand (named for consistency with
http://lists.denx.de/pipermail/u-boot/2010-August/075163.html) is introduced
to make explicit the user's desire to erase for a given amount of data,
rather than to erase a specific region of the chip.
While passing $filesize to "nand erase" is useful, accidentally passing
something like $fliesize currently produces quite unpleasant results, as the
variable evaluates to nothing and U-Boot assumes that you want to erase
the entire rest of the chip/partition. To improve the safety of the
erase command, require the user to make explicit their intentions by
using a .part or .chip subcommand. This is an incompatible user interface
change, but keeping compatibility would eliminate the safety gain, and IMHO
it's worth it.
While touching nand_erase_opts(), make it accept 64-bit offsets and sizes,
fix the percentage display when erase length is rounded up, eliminate
an inconsistent warning about rounding up the erase length which only
happened when the length was less than one block (rounding up for $filesize
is normal operation), and add a diagnostic if there's an attempt to erase
beginning at a non-block boundary.
Signed-off-by: Scott Wood <scottwood@freescale.com>
Tested-by: Ben Gardiner <bengardiner@nanometrics.ca>
2010-08-26 04:43:29 +09:00
|
|
|
"nand scrub off size | scrub.part partition | scrub.chip\n"
|
|
|
|
" really clean NAND erasing bad blocks (UNSAFE)\n"
|
2009-05-25 00:06:54 +09:00
|
|
|
"nand markbad off [...] - mark bad block(s) at offset (UNSAFE)\n"
|
|
|
|
"nand biterr off - make a bit error at offset (UNSAFE)"
|
2008-12-14 00:43:06 +09:00
|
|
|
#ifdef CONFIG_CMD_NAND_LOCK_UNLOCK
|
2009-05-25 00:06:54 +09:00
|
|
|
"\n"
|
|
|
|
"nand lock [tight] [status]\n"
|
|
|
|
" bring nand to lock state or display locked pages\n"
|
|
|
|
"nand unlock [offset] [size] - unlock section"
|
2008-12-14 00:43:06 +09:00
|
|
|
#endif
|
2010-07-06 02:27:07 +09:00
|
|
|
#ifdef CONFIG_ENV_OFFSET_OOB
|
|
|
|
"\n"
|
|
|
|
"nand env.oob - environment offset in OOB of block 0 of"
|
|
|
|
" first device.\n"
|
|
|
|
"nand env.oob set off|partition - set enviromnent offset\n"
|
|
|
|
"nand env.oob get - get environment offset"
|
|
|
|
#endif
|
2008-12-14 00:43:06 +09:00
|
|
|
);
|
2006-03-06 02:57:33 +09:00
|
|
|
|
2006-10-28 22:55:52 +09:00
|
|
|
static int nand_load_image(cmd_tbl_t *cmdtp, nand_info_t *nand,
|
2008-08-14 21:41:06 +09:00
|
|
|
ulong offset, ulong addr, char *cmd)
|
2006-03-06 02:57:33 +09:00
|
|
|
{
|
|
|
|
int r;
|
2011-01-12 04:56:34 +09:00
|
|
|
char *ep, *s;
|
2008-04-28 19:08:18 +09:00
|
|
|
size_t cnt;
|
2006-03-06 02:57:33 +09:00
|
|
|
image_header_t *hdr;
|
2008-03-12 18:33:01 +09:00
|
|
|
#if defined(CONFIG_FIT)
|
2008-06-07 06:07:40 +09:00
|
|
|
const void *fit_hdr = NULL;
|
2008-03-12 18:33:01 +09:00
|
|
|
#endif
|
2007-07-06 21:58:39 +09:00
|
|
|
|
|
|
|
s = strchr(cmd, '.');
|
|
|
|
if (s != NULL &&
|
2009-03-18 02:06:04 +09:00
|
|
|
(strcmp(s, ".jffs2") && strcmp(s, ".e") && strcmp(s, ".i"))) {
|
2008-06-13 03:13:23 +09:00
|
|
|
printf("Unknown nand load suffix '%s'\n", s);
|
|
|
|
show_boot_progress(-53);
|
|
|
|
return 1;
|
|
|
|
}
|
2006-03-06 02:57:33 +09:00
|
|
|
|
2006-10-28 22:55:52 +09:00
|
|
|
printf("\nLoading from %s, offset 0x%lx\n", nand->name, offset);
|
2006-03-06 02:57:33 +09:00
|
|
|
|
2007-10-31 21:53:06 +09:00
|
|
|
cnt = nand->writesize;
|
2009-03-13 22:38:19 +09:00
|
|
|
r = nand_read_skip_bad(nand, offset, &cnt, (u_char *) addr);
|
2006-03-06 02:57:33 +09:00
|
|
|
if (r) {
|
2006-10-28 22:55:52 +09:00
|
|
|
puts("** Read error\n");
|
2007-07-13 16:54:17 +09:00
|
|
|
show_boot_progress (-56);
|
2006-03-06 02:57:33 +09:00
|
|
|
return 1;
|
|
|
|
}
|
2007-07-13 16:54:17 +09:00
|
|
|
show_boot_progress (56);
|
2006-03-06 02:57:33 +09:00
|
|
|
|
2008-02-29 22:58:34 +09:00
|
|
|
switch (genimg_get_format ((void *)addr)) {
|
2008-02-04 16:28:09 +09:00
|
|
|
case IMAGE_FORMAT_LEGACY:
|
|
|
|
hdr = (image_header_t *)addr;
|
|
|
|
|
|
|
|
show_boot_progress (57);
|
|
|
|
image_print_contents (hdr);
|
2006-03-06 02:57:33 +09:00
|
|
|
|
2008-02-04 16:28:09 +09:00
|
|
|
cnt = image_get_image_size (hdr);
|
|
|
|
break;
|
|
|
|
#if defined(CONFIG_FIT)
|
|
|
|
case IMAGE_FORMAT_FIT:
|
2008-03-12 18:33:01 +09:00
|
|
|
fit_hdr = (const void *)addr;
|
|
|
|
puts ("Fit image detected...\n");
|
|
|
|
|
|
|
|
cnt = fit_get_size (fit_hdr);
|
|
|
|
break;
|
2008-02-04 16:28:09 +09:00
|
|
|
#endif
|
|
|
|
default:
|
2008-03-12 18:33:01 +09:00
|
|
|
show_boot_progress (-57);
|
2008-02-04 16:28:09 +09:00
|
|
|
puts ("** Unknown image type\n");
|
2006-03-06 02:57:33 +09:00
|
|
|
return 1;
|
|
|
|
}
|
2007-11-14 22:28:11 +09:00
|
|
|
show_boot_progress (57);
|
2006-03-06 02:57:33 +09:00
|
|
|
|
2009-03-13 22:38:19 +09:00
|
|
|
r = nand_read_skip_bad(nand, offset, &cnt, (u_char *) addr);
|
2006-03-06 02:57:33 +09:00
|
|
|
if (r) {
|
2006-10-28 22:55:52 +09:00
|
|
|
puts("** Read error\n");
|
2007-07-13 16:54:17 +09:00
|
|
|
show_boot_progress (-58);
|
2006-03-06 02:57:33 +09:00
|
|
|
return 1;
|
|
|
|
}
|
2007-07-13 16:54:17 +09:00
|
|
|
show_boot_progress (58);
|
2006-03-06 02:57:33 +09:00
|
|
|
|
2008-03-12 18:33:01 +09:00
|
|
|
#if defined(CONFIG_FIT)
|
|
|
|
/* This cannot be done earlier, we need complete FIT image in RAM first */
|
2008-06-07 06:07:40 +09:00
|
|
|
if (genimg_get_format ((void *)addr) == IMAGE_FORMAT_FIT) {
|
|
|
|
if (!fit_check_format (fit_hdr)) {
|
|
|
|
show_boot_progress (-150);
|
|
|
|
puts ("** Bad FIT image format\n");
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
show_boot_progress (151);
|
|
|
|
fit_print_contents (fit_hdr);
|
|
|
|
}
|
2008-03-12 18:33:01 +09:00
|
|
|
#endif
|
|
|
|
|
2006-03-06 02:57:33 +09:00
|
|
|
/* Loading ok, update default load address */
|
|
|
|
|
|
|
|
load_addr = addr;
|
|
|
|
|
|
|
|
/* Check if we should attempt an auto-start */
|
2011-01-12 04:56:34 +09:00
|
|
|
if (((ep = getenv("autostart")) != NULL) && (strcmp(ep, "yes") == 0)) {
|
2006-03-06 02:57:33 +09:00
|
|
|
char *local_args[2];
|
|
|
|
|
2006-10-28 22:55:52 +09:00
|
|
|
local_args[0] = cmd;
|
2006-03-06 02:57:33 +09:00
|
|
|
local_args[1] = NULL;
|
|
|
|
|
|
|
|
printf("Automatic boot of image at addr 0x%08lx ...\n", addr);
|
|
|
|
|
|
|
|
do_bootm(cmdtp, 0, 1, local_args);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-06-29 05:00:46 +09:00
|
|
|
int do_nandboot(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
|
2006-10-28 22:55:52 +09:00
|
|
|
{
|
|
|
|
char *boot_device = NULL;
|
|
|
|
int idx;
|
|
|
|
ulong addr, offset = 0;
|
2009-04-21 09:26:31 +09:00
|
|
|
#if defined(CONFIG_CMD_MTDPARTS)
|
2006-10-28 22:55:52 +09:00
|
|
|
struct mtd_device *dev;
|
|
|
|
struct part_info *part;
|
|
|
|
u8 pnum;
|
|
|
|
|
|
|
|
if (argc >= 2) {
|
|
|
|
char *p = (argc == 2) ? argv[1] : argv[2];
|
|
|
|
if (!(str2long(p, &addr)) && (mtdparts_init() == 0) &&
|
|
|
|
(find_dev_and_part(p, &dev, &pnum, &part) == 0)) {
|
|
|
|
if (dev->id->type != MTD_DEV_TYPE_NAND) {
|
|
|
|
puts("Not a NAND device\n");
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
if (argc > 3)
|
|
|
|
goto usage;
|
|
|
|
if (argc == 3)
|
2007-07-06 21:58:39 +09:00
|
|
|
addr = simple_strtoul(argv[1], NULL, 16);
|
2006-10-28 22:55:52 +09:00
|
|
|
else
|
2008-10-16 22:01:15 +09:00
|
|
|
addr = CONFIG_SYS_LOAD_ADDR;
|
2006-10-28 22:55:52 +09:00
|
|
|
return nand_load_image(cmdtp, &nand_info[dev->id->num],
|
2008-08-14 21:41:06 +09:00
|
|
|
part->offset, addr, argv[0]);
|
2006-10-28 22:55:52 +09:00
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2007-07-13 16:54:17 +09:00
|
|
|
show_boot_progress(52);
|
2006-10-28 22:55:52 +09:00
|
|
|
switch (argc) {
|
|
|
|
case 1:
|
2008-10-16 22:01:15 +09:00
|
|
|
addr = CONFIG_SYS_LOAD_ADDR;
|
2006-10-28 22:55:52 +09:00
|
|
|
boot_device = getenv("bootdevice");
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
addr = simple_strtoul(argv[1], NULL, 16);
|
|
|
|
boot_device = getenv("bootdevice");
|
|
|
|
break;
|
|
|
|
case 3:
|
|
|
|
addr = simple_strtoul(argv[1], NULL, 16);
|
|
|
|
boot_device = argv[2];
|
|
|
|
break;
|
|
|
|
case 4:
|
|
|
|
addr = simple_strtoul(argv[1], NULL, 16);
|
|
|
|
boot_device = argv[2];
|
|
|
|
offset = simple_strtoul(argv[3], NULL, 16);
|
|
|
|
break;
|
|
|
|
default:
|
2009-04-21 09:26:31 +09:00
|
|
|
#if defined(CONFIG_CMD_MTDPARTS)
|
2006-10-28 22:55:52 +09:00
|
|
|
usage:
|
|
|
|
#endif
|
2007-07-13 16:54:17 +09:00
|
|
|
show_boot_progress(-53);
|
2010-07-17 08:06:04 +09:00
|
|
|
return cmd_usage(cmdtp);
|
2006-10-28 22:55:52 +09:00
|
|
|
}
|
|
|
|
|
2007-07-13 16:54:17 +09:00
|
|
|
show_boot_progress(53);
|
2006-10-28 22:55:52 +09:00
|
|
|
if (!boot_device) {
|
|
|
|
puts("\n** No boot device **\n");
|
2007-07-13 16:54:17 +09:00
|
|
|
show_boot_progress(-54);
|
2006-10-28 22:55:52 +09:00
|
|
|
return 1;
|
|
|
|
}
|
2007-07-13 16:54:17 +09:00
|
|
|
show_boot_progress(54);
|
2006-03-06 02:57:33 +09:00
|
|
|
|
2006-10-28 22:55:52 +09:00
|
|
|
idx = simple_strtoul(boot_device, NULL, 16);
|
|
|
|
|
2008-10-16 22:01:15 +09:00
|
|
|
if (idx < 0 || idx >= CONFIG_SYS_MAX_NAND_DEVICE || !nand_info[idx].name) {
|
2006-10-28 22:55:52 +09:00
|
|
|
printf("\n** Device %d not available\n", idx);
|
2007-07-13 16:54:17 +09:00
|
|
|
show_boot_progress(-55);
|
2006-10-28 22:55:52 +09:00
|
|
|
return 1;
|
|
|
|
}
|
2007-07-13 16:54:17 +09:00
|
|
|
show_boot_progress(55);
|
2006-10-28 22:55:52 +09:00
|
|
|
|
|
|
|
return nand_load_image(cmdtp, &nand_info[idx], offset, addr, argv[0]);
|
|
|
|
}
|
|
|
|
|
|
|
|
U_BOOT_CMD(nboot, 4, 1, do_nandboot,
|
2009-01-28 09:03:12 +09:00
|
|
|
"boot from NAND device",
|
2009-05-25 00:06:54 +09:00
|
|
|
"[partition] | [[[loadAddr] dev] offset]"
|
|
|
|
);
|