2003-03-26 14:55:25 +08: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 06:35:21 +08:00
|
|
|
*
|
2010-07-06 01:27:07 +08: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 06:35:21 +08:00
|
|
|
* Added 16-bit nand support
|
|
|
|
* (C) 2004 Texas Instruments
|
2010-08-03 02:04:24 +08:00
|
|
|
*
|
2012-03-03 04:01:57 +08:00
|
|
|
* Copyright 2010, 2012 Freescale Semiconductor
|
2010-08-03 02:04:24 +08:00
|
|
|
* 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 14:55:25 +08:00
|
|
|
*/
|
|
|
|
|
|
|
|
#include <common.h>
|
2007-10-31 20:53:06 +08:00
|
|
|
#include <linux/mtd/mtd.h>
|
2006-03-06 01:57:33 +08:00
|
|
|
#include <command.h>
|
|
|
|
#include <watchdog.h>
|
|
|
|
#include <malloc.h>
|
|
|
|
#include <asm/byteorder.h>
|
|
|
|
#include <jffs2/jffs2.h>
|
|
|
|
#include <nand.h>
|
|
|
|
|
2009-04-21 08:26:31 +08:00
|
|
|
#if defined(CONFIG_CMD_MTDPARTS)
|
2006-10-28 21:55:52 +08:00
|
|
|
|
2009-11-18 04:27:39 +08:00
|
|
|
/* partition handling routines */
|
2006-10-28 21:55:52 +08: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 20:41:06 +08:00
|
|
|
u8 *part_num, struct part_info **part);
|
2006-10-28 21:55:52 +08:00
|
|
|
#endif
|
|
|
|
|
2010-08-26 04:24:01 +08:00
|
|
|
static int nand_dump(nand_info_t *nand, ulong off, int only_oob, int repeat)
|
2006-03-06 01:57:33 +08:00
|
|
|
{
|
|
|
|
int i;
|
2007-12-14 23:33:45 +08:00
|
|
|
u_char *datbuf, *oobbuf, *p;
|
2010-08-26 04:24:01 +08:00
|
|
|
static loff_t last;
|
2013-07-11 16:27:12 +08:00
|
|
|
int ret = 0;
|
2010-08-26 04:24:01 +08:00
|
|
|
|
|
|
|
if (repeat)
|
|
|
|
off = last + nand->writesize;
|
|
|
|
|
|
|
|
last = off;
|
2006-03-06 01:57:33 +08:00
|
|
|
|
2012-07-31 04:21:55 +08:00
|
|
|
datbuf = memalign(ARCH_DMA_MINALIGN, nand->writesize);
|
2013-07-11 16:27:12 +08:00
|
|
|
if (!datbuf) {
|
2006-03-06 01:57:33 +08:00
|
|
|
puts("No memory for page buffer\n");
|
|
|
|
return 1;
|
|
|
|
}
|
2013-07-11 16:27:12 +08:00
|
|
|
|
|
|
|
oobbuf = memalign(ARCH_DMA_MINALIGN, nand->oobsize);
|
|
|
|
if (!oobbuf) {
|
|
|
|
puts("No memory for page buffer\n");
|
|
|
|
ret = 1;
|
|
|
|
goto free_dat;
|
|
|
|
}
|
2007-10-31 20:53:06 +08:00
|
|
|
off &= ~(nand->writesize - 1);
|
|
|
|
loff_t addr = (loff_t) off;
|
2007-12-14 23:33:45 +08:00
|
|
|
struct mtd_oob_ops ops;
|
|
|
|
memset(&ops, 0, sizeof(ops));
|
|
|
|
ops.datbuf = datbuf;
|
2012-02-24 06:47:46 +08:00
|
|
|
ops.oobbuf = oobbuf;
|
2007-12-14 23:33:45 +08:00
|
|
|
ops.len = nand->writesize;
|
|
|
|
ops.ooblen = nand->oobsize;
|
2013-01-14 11:46:50 +08:00
|
|
|
ops.mode = MTD_OPS_RAW;
|
|
|
|
i = mtd_read_oob(nand, addr, &ops);
|
2006-03-06 01:57:33 +08:00
|
|
|
if (i < 0) {
|
2008-07-10 16:10:54 +08:00
|
|
|
printf("Error (%d) reading page %08lx\n", i, off);
|
2013-07-11 16:27:12 +08:00
|
|
|
ret = 1;
|
|
|
|
goto free_all;
|
2006-03-06 01:57:33 +08:00
|
|
|
}
|
2008-07-10 16:10:54 +08:00
|
|
|
printf("Page %08lx dump:\n", off);
|
2008-08-14 20:41:06 +08:00
|
|
|
|
2013-07-11 16:27:13 +08:00
|
|
|
if (!only_oob) {
|
|
|
|
i = nand->writesize >> 4;
|
|
|
|
p = datbuf;
|
|
|
|
|
|
|
|
while (i--) {
|
2007-12-14 23:33:45 +08:00
|
|
|
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 02:20:16 +08:00
|
|
|
p[8], p[9], p[10], p[11], p[12], p[13], p[14],
|
|
|
|
p[15]);
|
2013-07-11 16:27:13 +08:00
|
|
|
p += 16;
|
|
|
|
}
|
2006-03-06 01:57:33 +08:00
|
|
|
}
|
2013-07-11 16:27:13 +08:00
|
|
|
|
2006-03-06 01:57:33 +08:00
|
|
|
puts("OOB:\n");
|
|
|
|
i = nand->oobsize >> 3;
|
2012-02-24 06:47:46 +08:00
|
|
|
p = oobbuf;
|
2006-03-06 01:57:33 +08:00
|
|
|
while (i--) {
|
2007-10-31 20:53:06 +08: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 01:57:33 +08:00
|
|
|
p += 8;
|
|
|
|
}
|
2013-07-11 16:27:12 +08:00
|
|
|
|
|
|
|
free_all:
|
2007-12-14 23:33:45 +08:00
|
|
|
free(oobbuf);
|
2013-07-11 16:27:12 +08:00
|
|
|
free_dat:
|
|
|
|
free(datbuf);
|
2006-03-06 01:57:33 +08:00
|
|
|
|
2013-07-11 16:27:12 +08:00
|
|
|
return ret;
|
2006-03-06 01:57:33 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/* ------------------------------------------------------------------------- */
|
|
|
|
|
2010-08-03 02:04:24 +08: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 01:57:33 +08:00
|
|
|
{
|
2006-10-28 21:55:52 +08:00
|
|
|
char *endptr;
|
2006-03-06 01:57:33 +08:00
|
|
|
|
2006-10-28 21:55:52 +08:00
|
|
|
*num = simple_strtoul(p, &endptr, 16);
|
2010-08-03 02:04:24 +08:00
|
|
|
return *p != '\0' && *endptr == '\0';
|
2006-10-28 21:55:52 +08:00
|
|
|
}
|
2006-03-06 01:57:33 +08:00
|
|
|
|
2013-03-14 13:32:50 +08:00
|
|
|
static int get_part(const char *partname, int *idx, loff_t *off, loff_t *size,
|
|
|
|
loff_t *maxsize)
|
2006-10-28 21:55:52 +08:00
|
|
|
{
|
2010-08-03 02:04:24 +08:00
|
|
|
#ifdef CONFIG_CMD_MTDPARTS
|
2006-10-28 21:55:52 +08:00
|
|
|
struct mtd_device *dev;
|
|
|
|
struct part_info *part;
|
|
|
|
u8 pnum;
|
2010-08-03 02:04:24 +08:00
|
|
|
int ret;
|
2006-10-28 21:55:52 +08:00
|
|
|
|
2010-08-03 02:04:24 +08: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 21:55:52 +08:00
|
|
|
}
|
2010-08-03 02:04:24 +08:00
|
|
|
|
|
|
|
*off = part->offset;
|
|
|
|
*size = part->size;
|
2013-03-14 13:32:50 +08:00
|
|
|
*maxsize = part->size;
|
2010-08-03 02:04:24 +08:00
|
|
|
*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 01:57:33 +08:00
|
|
|
#endif
|
2010-08-03 02:04:24 +08:00
|
|
|
}
|
2006-03-06 01:57:33 +08:00
|
|
|
|
2013-03-14 13:32:50 +08:00
|
|
|
static int arg_off(const char *arg, int *idx, loff_t *off, loff_t *size,
|
|
|
|
loff_t *maxsize)
|
2010-08-03 02:04:24 +08:00
|
|
|
{
|
|
|
|
if (!str2off(arg, off))
|
2013-03-14 13:32:50 +08:00
|
|
|
return get_part(arg, idx, off, size, maxsize);
|
2010-08-03 02:04:24 +08:00
|
|
|
|
|
|
|
if (*off >= nand_info[*idx].size) {
|
|
|
|
puts("Offset exceeds device limit\n");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
*maxsize = nand_info[*idx].size - *off;
|
2013-03-14 13:32:50 +08:00
|
|
|
*size = *maxsize;
|
2010-08-03 02:04:24 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int arg_off_size(int argc, char *const argv[], int *idx,
|
2013-03-14 13:32:50 +08:00
|
|
|
loff_t *off, loff_t *size, loff_t *maxsize)
|
2010-08-03 02:04:24 +08:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (argc == 0) {
|
2006-10-28 21:55:52 +08:00
|
|
|
*off = 0;
|
2010-08-03 02:04:24 +08:00
|
|
|
*size = nand_info[*idx].size;
|
2013-03-14 13:32:50 +08:00
|
|
|
*maxsize = *size;
|
2010-08-03 02:04:24 +08:00
|
|
|
goto print;
|
2006-10-28 21:55:52 +08:00
|
|
|
}
|
2006-03-06 01:57:33 +08:00
|
|
|
|
2013-03-14 13:32:50 +08:00
|
|
|
ret = arg_off(argv[0], idx, off, size, maxsize);
|
2010-08-03 02:04:24 +08:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
2013-03-14 13:32:50 +08:00
|
|
|
if (argc == 1)
|
2010-08-03 02:04:24 +08:00
|
|
|
goto print;
|
2006-03-06 01:57:33 +08:00
|
|
|
|
2010-08-03 02:04:24 +08:00
|
|
|
if (!str2off(argv[1], size)) {
|
|
|
|
printf("'%s' is not a number\n", argv[1]);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2013-03-14 13:32:50 +08:00
|
|
|
if (*size > *maxsize) {
|
2010-08-03 02:04:24 +08:00
|
|
|
puts("Size exceeds partition or device limit\n");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
print:
|
|
|
|
printf("device %d ", *idx);
|
|
|
|
if (*size == nand_info[*idx].size)
|
2006-10-28 21:55:52 +08:00
|
|
|
puts("whole chip\n");
|
|
|
|
else
|
2010-08-03 02:04:24 +08:00
|
|
|
printf("offset 0x%llx, size 0x%llx\n",
|
|
|
|
(unsigned long long)*off, (unsigned long long)*size);
|
2006-10-28 21:55:52 +08:00
|
|
|
return 0;
|
2006-03-06 01:57:33 +08:00
|
|
|
}
|
|
|
|
|
2008-12-13 23:43:06 +08:00
|
|
|
#ifdef CONFIG_CMD_NAND_LOCK_UNLOCK
|
|
|
|
static void print_status(ulong start, ulong end, ulong erasesize, int status)
|
|
|
|
{
|
2012-08-23 05:49:45 +08:00
|
|
|
/*
|
|
|
|
* Micron NAND flash (e.g. MT29F4G08ABADAH4) BLOCK LOCK READ STATUS is
|
|
|
|
* not the same as others. Instead of bit 1 being lock, it is
|
|
|
|
* #lock_tight. To make the driver support either format, ignore bit 1
|
|
|
|
* and use only bit 0 and bit 2.
|
|
|
|
*/
|
2008-12-13 23:43:06 +08:00
|
|
|
printf("%08lx - %08lx: %08lx blocks %s%s%s\n",
|
|
|
|
start,
|
|
|
|
end - 1,
|
|
|
|
(end - start) / erasesize,
|
|
|
|
((status & NAND_LOCK_STATUS_TIGHT) ? "TIGHT " : ""),
|
2012-08-23 05:49:45 +08:00
|
|
|
(!(status & NAND_LOCK_STATUS_UNLOCK) ? "LOCK " : ""),
|
2008-12-13 23:43:06 +08:00
|
|
|
((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 01:27:07 +08:00
|
|
|
#ifdef CONFIG_ENV_OFFSET_OOB
|
|
|
|
unsigned long nand_env_oob_offset;
|
|
|
|
|
2010-08-03 02:04:24 +08:00
|
|
|
int do_nand_env_oob(cmd_tbl_t *cmdtp, int argc, char *const argv[])
|
2010-07-06 01:27:07 +08:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
uint32_t oob_buf[ENV_OFFSET_SIZE/sizeof(uint32_t)];
|
2010-08-03 02:04:24 +08:00
|
|
|
nand_info_t *nand = &nand_info[0];
|
2010-07-06 01:27:07 +08:00
|
|
|
char *cmd = argv[1];
|
|
|
|
|
2010-08-03 02:04:24 +08:00
|
|
|
if (CONFIG_SYS_MAX_NAND_DEVICE == 0 || !nand->name) {
|
|
|
|
puts("no devices available\n");
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
set_dev(0);
|
|
|
|
|
2010-07-06 01:27:07 +08:00
|
|
|
if (!strcmp(cmd, "get")) {
|
|
|
|
ret = get_nand_env_oob(nand, &nand_env_oob_offset);
|
2010-07-13 07:17:40 +08:00
|
|
|
if (ret)
|
2010-07-06 01:27:07 +08:00
|
|
|
return 1;
|
2010-07-13 07:17:40 +08:00
|
|
|
|
|
|
|
printf("0x%08lx\n", nand_env_oob_offset);
|
2010-07-06 01:27:07 +08:00
|
|
|
} else if (!strcmp(cmd, "set")) {
|
2010-08-03 02:04:24 +08:00
|
|
|
loff_t addr;
|
|
|
|
loff_t maxsize;
|
2010-07-06 01:27:07 +08:00
|
|
|
struct mtd_oob_ops ops;
|
2010-08-03 02:04:24 +08:00
|
|
|
int idx = 0;
|
2010-07-06 01:27:07 +08:00
|
|
|
|
|
|
|
if (argc < 3)
|
|
|
|
goto usage;
|
|
|
|
|
2013-03-14 13:32:50 +08:00
|
|
|
/* We don't care about size, or maxsize. */
|
|
|
|
if (arg_off(argv[2], &idx, &addr, &maxsize, &maxsize)) {
|
2010-08-03 02:04:24 +08:00
|
|
|
puts("Offset or partition name expected\n");
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (idx != 0) {
|
|
|
|
puts("Partition not on first NAND device\n");
|
2010-07-06 01:27:07 +08:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (nand->oobavail < ENV_OFFSET_SIZE) {
|
2010-07-13 07:17:40 +08: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 01:27:07 +08: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 07:17:40 +08:00
|
|
|
if (ret) {
|
2010-07-06 01:27:07 +08:00
|
|
|
printf("Error writing OOB block 0\n");
|
|
|
|
return ret;
|
|
|
|
}
|
2010-07-13 07:17:40 +08: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 02:04:24 +08:00
|
|
|
"0x%08llx expected but got 0x%08lx\n",
|
|
|
|
(unsigned long long)addr, nand_env_oob_offset);
|
2010-07-13 07:17:40 +08:00
|
|
|
return 1;
|
|
|
|
}
|
2010-07-06 01:27:07 +08:00
|
|
|
} else {
|
|
|
|
goto usage;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
usage:
|
2011-12-10 16:44:01 +08:00
|
|
|
return CMD_RET_USAGE;
|
2010-07-06 01:27:07 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
2011-09-22 09:57:26 +08:00
|
|
|
static void nand_print_and_set_info(int idx)
|
2009-02-12 01:38:20 +08:00
|
|
|
{
|
|
|
|
nand_info_t *nand = &nand_info[idx];
|
|
|
|
struct nand_chip *chip = nand->priv;
|
2011-09-22 09:57:26 +08:00
|
|
|
|
2009-02-12 01:38:20 +08:00
|
|
|
printf("Device %d: ", idx);
|
|
|
|
if (chip->numchips > 1)
|
|
|
|
printf("%dx ", chip->numchips);
|
|
|
|
printf("%s, sector size %u KiB\n",
|
|
|
|
nand->name, nand->erasesize >> 10);
|
2011-09-22 09:57:26 +08:00
|
|
|
printf(" Page size %8d b\n", nand->writesize);
|
|
|
|
printf(" OOB size %8d b\n", nand->oobsize);
|
|
|
|
printf(" Erase size %8d b\n", nand->erasesize);
|
|
|
|
|
|
|
|
/* Set geometry info */
|
2013-02-25 01:33:22 +08:00
|
|
|
setenv_hex("nand_writesize", nand->writesize);
|
|
|
|
setenv_hex("nand_oobsize", nand->oobsize);
|
|
|
|
setenv_hex("nand_erasesize", nand->erasesize);
|
2009-02-12 01:38:20 +08:00
|
|
|
}
|
|
|
|
|
2012-03-03 04:01:57 +08:00
|
|
|
static int raw_access(nand_info_t *nand, ulong addr, loff_t off, ulong count,
|
|
|
|
int read)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
while (count--) {
|
|
|
|
/* Raw access */
|
|
|
|
mtd_oob_ops_t ops = {
|
|
|
|
.datbuf = (u8 *)addr,
|
|
|
|
.oobbuf = ((u8 *)addr) + nand->writesize,
|
|
|
|
.len = nand->writesize,
|
|
|
|
.ooblen = nand->oobsize,
|
2013-01-14 11:46:50 +08:00
|
|
|
.mode = MTD_OPS_RAW
|
2012-03-03 04:01:57 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
if (read)
|
2013-01-14 11:46:50 +08:00
|
|
|
ret = mtd_read_oob(nand, off, &ops);
|
2012-03-03 04:01:57 +08:00
|
|
|
else
|
2013-01-14 11:46:50 +08:00
|
|
|
ret = mtd_write_oob(nand, off, &ops);
|
2012-03-03 04:01:57 +08:00
|
|
|
|
|
|
|
if (ret) {
|
|
|
|
printf("%s: error at offset %llx, ret %d\n",
|
|
|
|
__func__, (long long)off, ret);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
addr += nand->writesize + nand->oobsize;
|
|
|
|
off += nand->writesize;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2013-02-27 01:57:14 +08:00
|
|
|
/* Adjust a chip/partition size down for bad blocks so we don't
|
2013-06-21 01:45:31 +08:00
|
|
|
* read/write past the end of a chip/partition by accident.
|
2013-02-27 01:57:14 +08:00
|
|
|
*/
|
|
|
|
static void adjust_size_for_badblocks(loff_t *size, loff_t offset, int dev)
|
|
|
|
{
|
|
|
|
/* We grab the nand info object here fresh because this is usually
|
|
|
|
* called after arg_off_size() which can change the value of dev.
|
|
|
|
*/
|
|
|
|
nand_info_t *nand = &nand_info[dev];
|
|
|
|
loff_t maxoffset = offset + *size;
|
|
|
|
int badblocks = 0;
|
|
|
|
|
|
|
|
/* count badblocks in NAND from offset to offset + size */
|
|
|
|
for (; offset < maxoffset; offset += nand->erasesize) {
|
|
|
|
if (nand_block_isbad(nand, offset))
|
|
|
|
badblocks++;
|
|
|
|
}
|
|
|
|
/* adjust size if any bad blocks found */
|
|
|
|
if (badblocks) {
|
|
|
|
*size -= badblocks * nand->erasesize;
|
|
|
|
printf("size adjusted to 0x%llx (%d bad blocks)\n",
|
|
|
|
(unsigned long long)*size, badblocks);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-10-29 21:34:31 +08:00
|
|
|
static int do_nand(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
2006-03-06 01:57:33 +08:00
|
|
|
{
|
2010-08-03 02:04:24 +08:00
|
|
|
int i, ret = 0;
|
|
|
|
ulong addr;
|
2013-03-14 13:32:50 +08:00
|
|
|
loff_t off, size, maxsize;
|
2006-03-06 01:57:33 +08:00
|
|
|
char *cmd, *s;
|
|
|
|
nand_info_t *nand;
|
2008-10-16 21:01:15 +08:00
|
|
|
#ifdef CONFIG_SYS_NAND_QUIET
|
|
|
|
int quiet = CONFIG_SYS_NAND_QUIET;
|
2007-09-12 18:36:53 +08:00
|
|
|
#else
|
2006-10-10 18:36:02 +08:00
|
|
|
int quiet = 0;
|
2007-09-12 18:36:53 +08:00
|
|
|
#endif
|
2006-10-10 18:36:02 +08:00
|
|
|
const char *quiet_str = getenv("quiet");
|
2010-08-03 02:04:24 +08:00
|
|
|
int dev = nand_curr_device;
|
2010-08-26 04:24:01 +08:00
|
|
|
int repeat = flag & CMD_FLAG_REPEAT;
|
2006-03-06 01:57:33 +08:00
|
|
|
|
|
|
|
/* at least two arguments please */
|
|
|
|
if (argc < 2)
|
|
|
|
goto usage;
|
|
|
|
|
2006-10-10 18:36:02 +08:00
|
|
|
if (quiet_str)
|
|
|
|
quiet = simple_strtoul(quiet_str, NULL, 0) != 0;
|
|
|
|
|
2006-03-06 01:57:33 +08:00
|
|
|
cmd = argv[1];
|
|
|
|
|
2010-08-26 04:24:01 +08:00
|
|
|
/* Only "dump" is repeatable. */
|
|
|
|
if (repeat && strcmp(cmd, "dump"))
|
|
|
|
return 0;
|
|
|
|
|
2006-03-06 01:57:33 +08:00
|
|
|
if (strcmp(cmd, "info") == 0) {
|
|
|
|
|
|
|
|
putc('\n');
|
2008-10-16 21:01:15 +08:00
|
|
|
for (i = 0; i < CONFIG_SYS_MAX_NAND_DEVICE; i++) {
|
2006-03-06 01:57:33 +08:00
|
|
|
if (nand_info[i].name)
|
2011-09-22 09:57:26 +08:00
|
|
|
nand_print_and_set_info(i);
|
2006-03-06 01:57:33 +08:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (strcmp(cmd, "device") == 0) {
|
|
|
|
if (argc < 3) {
|
2009-02-12 01:38:20 +08:00
|
|
|
putc('\n');
|
2010-08-03 02:04:24 +08:00
|
|
|
if (dev < 0 || dev >= CONFIG_SYS_MAX_NAND_DEVICE)
|
2009-02-12 01:38:20 +08:00
|
|
|
puts("no devices available\n");
|
2006-03-06 01:57:33 +08:00
|
|
|
else
|
2011-09-22 09:57:26 +08:00
|
|
|
nand_print_and_set_info(dev);
|
2006-03-06 01:57:33 +08:00
|
|
|
return 0;
|
|
|
|
}
|
2006-10-20 20:28:52 +08:00
|
|
|
|
2010-08-03 02:04:24 +08:00
|
|
|
dev = (int)simple_strtoul(argv[2], NULL, 10);
|
|
|
|
set_dev(dev);
|
2006-10-20 20:28:52 +08:00
|
|
|
|
2006-03-06 01:57:33 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-07-06 01:27:07 +08:00
|
|
|
#ifdef CONFIG_ENV_OFFSET_OOB
|
|
|
|
/* this command operates only on the first nand device */
|
2010-08-03 02:04:24 +08:00
|
|
|
if (strcmp(cmd, "env.oob") == 0)
|
|
|
|
return do_nand_env_oob(cmdtp, argc - 1, argv + 1);
|
2010-07-06 01:27:07 +08:00
|
|
|
#endif
|
|
|
|
|
2010-08-03 02:04:24 +08: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 01:57:33 +08:00
|
|
|
puts("\nno devices available\n");
|
|
|
|
return 1;
|
|
|
|
}
|
2010-08-03 02:04:24 +08:00
|
|
|
nand = &nand_info[dev];
|
2006-03-06 01:57:33 +08:00
|
|
|
|
|
|
|
if (strcmp(cmd, "bad") == 0) {
|
2010-08-03 02:04:24 +08:00
|
|
|
printf("\nDevice %d bad blocks:\n", dev);
|
2006-03-06 01:57:33 +08:00
|
|
|
for (off = 0; off < nand->size; off += nand->erasesize)
|
|
|
|
if (nand_block_isbad(nand, off))
|
2010-08-03 02:04:24 +08:00
|
|
|
printf(" %08llx\n", (unsigned long long)off);
|
2006-03-06 01:57:33 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-10-28 21:55:52 +08: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 03:43:29 +08:00
|
|
|
if (strncmp(cmd, "erase", 5) == 0 || strncmp(cmd, "scrub", 5) == 0) {
|
2006-10-10 18:36:02 +08:00
|
|
|
nand_erase_options_t opts;
|
2006-10-28 21:55:52 +08:00
|
|
|
/* "clean" at index 2 means request to write cleanmarker */
|
2007-11-14 21:28:11 +08:00
|
|
|
int clean = argc > 2 && !strcmp("clean", argv[2]);
|
2011-09-14 06:20:35 +08:00
|
|
|
int scrub_yes = argc > 2 && !strcmp("-y", argv[2]);
|
|
|
|
int o = (clean || scrub_yes) ? 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 03:43:29 +08:00
|
|
|
int scrub = !strncmp(cmd, "scrub", 5);
|
|
|
|
int spread = 0;
|
|
|
|
int args = 2;
|
2011-09-14 06:20:35 +08:00
|
|
|
const char *scrub_warn =
|
|
|
|
"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";
|
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 03:43:29 +08:00
|
|
|
|
|
|
|
if (cmd[5] != 0) {
|
|
|
|
if (!strcmp(&cmd[5], ".spread")) {
|
|
|
|
spread = 1;
|
|
|
|
} else if (!strcmp(&cmd[5], ".part")) {
|
|
|
|
args = 1;
|
|
|
|
} else if (!strcmp(&cmd[5], ".chip")) {
|
|
|
|
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 18:36:02 +08: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 03:43:29 +08:00
|
|
|
printf("\nNAND %s: ", cmd);
|
2006-10-28 21:55:52 +08:00
|
|
|
/* skip first two or three arguments, look for offset and size */
|
2013-03-14 13:32:50 +08:00
|
|
|
if (arg_off_size(argc - o, argv + o, &dev, &off, &size,
|
|
|
|
&maxsize) != 0)
|
2006-10-28 21:55:52 +08:00
|
|
|
return 1;
|
2006-10-10 18:36:02 +08:00
|
|
|
|
2010-08-03 02:04:24 +08:00
|
|
|
nand = &nand_info[dev];
|
|
|
|
|
2006-10-10 18:36:02 +08: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 03:43:29 +08:00
|
|
|
opts.spread = spread;
|
2006-10-10 18:36:02 +08:00
|
|
|
|
|
|
|
if (scrub) {
|
2014-04-24 16:30:07 +08:00
|
|
|
if (scrub_yes) {
|
2011-09-14 06:20:35 +08:00
|
|
|
opts.scrub = 1;
|
2014-04-24 16:30:07 +08:00
|
|
|
} else {
|
|
|
|
puts(scrub_warn);
|
|
|
|
if (confirm_yesno()) {
|
2010-03-21 02:02:58 +08:00
|
|
|
opts.scrub = 1;
|
2014-04-24 16:30:07 +08:00
|
|
|
} else {
|
2010-03-21 02:02:58 +08:00
|
|
|
puts("scrub aborted\n");
|
2013-07-11 16:29:57 +08:00
|
|
|
return 1;
|
2010-03-21 02:02:58 +08:00
|
|
|
}
|
2006-10-10 18:36:02 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
ret = nand_erase_opts(nand, &opts);
|
2006-03-06 01:57:33 +08: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 04:24:01 +08:00
|
|
|
ret = nand_dump(nand, off, !strcmp(&cmd[4], ".oob"), repeat);
|
2006-03-06 01:57:33 +08:00
|
|
|
|
|
|
|
return ret == 0 ? 1 : 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (strncmp(cmd, "read", 4) == 0 || strncmp(cmd, "write", 5) == 0) {
|
2010-08-03 02:04:24 +08:00
|
|
|
size_t rwsize;
|
2012-03-03 04:01:57 +08:00
|
|
|
ulong pagecount = 1;
|
2006-10-10 18:36:02 +08:00
|
|
|
int read;
|
2013-02-07 19:34:44 +08:00
|
|
|
int raw = 0;
|
2006-10-10 18:36:02 +08:00
|
|
|
|
2006-03-06 01:57:33 +08:00
|
|
|
if (argc < 4)
|
|
|
|
goto usage;
|
2006-10-10 18:36:02 +08:00
|
|
|
|
2006-03-06 01:57:33 +08:00
|
|
|
addr = (ulong)simple_strtoul(argv[2], NULL, 16);
|
|
|
|
|
2006-10-10 18:36:02 +08:00
|
|
|
read = strncmp(cmd, "read", 4) == 0; /* 1 = read, 0 = write */
|
2006-10-28 21:55:52 +08:00
|
|
|
printf("\nNAND %s: ", read ? "read" : "write");
|
2007-11-08 17:39:53 +08:00
|
|
|
|
2010-08-03 02:04:24 +08:00
|
|
|
nand = &nand_info[dev];
|
|
|
|
|
2006-10-10 18:36:02 +08:00
|
|
|
s = strchr(cmd, '.');
|
2012-03-03 04:01:57 +08:00
|
|
|
|
2012-06-08 01:19:18 +08:00
|
|
|
if (s && !strcmp(s, ".raw")) {
|
2012-03-03 04:01:57 +08:00
|
|
|
raw = 1;
|
|
|
|
|
2013-03-14 13:32:50 +08:00
|
|
|
if (arg_off(argv[3], &dev, &off, &size, &maxsize))
|
2012-03-03 04:01:57 +08:00
|
|
|
return 1;
|
|
|
|
|
|
|
|
if (argc > 4 && !str2long(argv[4], &pagecount)) {
|
|
|
|
printf("'%s' is not a number\n", argv[4]);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (pagecount * nand->writesize > size) {
|
|
|
|
puts("Size exceeds partition or device limit\n");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
rwsize = pagecount * (nand->writesize + nand->oobsize);
|
|
|
|
} else {
|
|
|
|
if (arg_off_size(argc - 3, argv + 3, &dev,
|
2013-03-14 13:32:50 +08:00
|
|
|
&off, &size, &maxsize) != 0)
|
2012-03-03 04:01:57 +08:00
|
|
|
return 1;
|
|
|
|
|
2013-02-27 01:57:14 +08:00
|
|
|
/* size is unspecified */
|
|
|
|
if (argc < 5)
|
|
|
|
adjust_size_for_badblocks(&size, off, dev);
|
2012-03-03 04:01:57 +08:00
|
|
|
rwsize = size;
|
|
|
|
}
|
|
|
|
|
2008-06-13 02:13:23 +08:00
|
|
|
if (!s || !strcmp(s, ".jffs2") ||
|
|
|
|
!strcmp(s, ".e") || !strcmp(s, ".i")) {
|
2008-06-13 02:20:16 +08:00
|
|
|
if (read)
|
2010-08-03 02:04:24 +08:00
|
|
|
ret = nand_read_skip_bad(nand, off, &rwsize,
|
2013-03-14 13:32:50 +08:00
|
|
|
NULL, maxsize,
|
2008-08-14 20:41:06 +08:00
|
|
|
(u_char *)addr);
|
2008-06-13 02:20:16 +08:00
|
|
|
else
|
2010-08-03 02:04:24 +08:00
|
|
|
ret = nand_write_skip_bad(nand, off, &rwsize,
|
2013-03-14 13:32:50 +08:00
|
|
|
NULL, maxsize,
|
2011-01-06 11:11:58 +08:00
|
|
|
(u_char *)addr, 0);
|
2011-06-15 04:35:07 +08:00
|
|
|
#ifdef CONFIG_CMD_NAND_TRIMFFS
|
|
|
|
} else if (!strcmp(s, ".trimffs")) {
|
|
|
|
if (read) {
|
|
|
|
printf("Unknown nand command suffix '%s'\n", s);
|
|
|
|
return 1;
|
|
|
|
}
|
2013-03-14 13:32:50 +08:00
|
|
|
ret = nand_write_skip_bad(nand, off, &rwsize, NULL,
|
|
|
|
maxsize, (u_char *)addr,
|
2011-06-15 04:35:07 +08:00
|
|
|
WITH_DROP_FFS);
|
|
|
|
#endif
|
2011-01-06 11:11:58 +08:00
|
|
|
#ifdef CONFIG_CMD_NAND_YAFFS
|
|
|
|
} else if (!strcmp(s, ".yaffs")) {
|
|
|
|
if (read) {
|
|
|
|
printf("Unknown nand command suffix '%s'.\n", s);
|
|
|
|
return 1;
|
|
|
|
}
|
2013-03-14 13:32:50 +08:00
|
|
|
ret = nand_write_skip_bad(nand, off, &rwsize, NULL,
|
|
|
|
maxsize, (u_char *)addr,
|
2013-03-14 13:32:51 +08:00
|
|
|
WITH_YAFFS_OOB);
|
2011-01-06 11:11:58 +08:00
|
|
|
#endif
|
2009-04-13 10:29:20 +08:00
|
|
|
} else if (!strcmp(s, ".oob")) {
|
2007-10-31 20:53:06 +08:00
|
|
|
/* out-of-band data */
|
|
|
|
mtd_oob_ops_t ops = {
|
|
|
|
.oobbuf = (u8 *)addr,
|
2010-08-03 02:04:24 +08:00
|
|
|
.ooblen = rwsize,
|
2013-01-14 11:46:50 +08:00
|
|
|
.mode = MTD_OPS_RAW
|
2007-10-31 20:53:06 +08:00
|
|
|
};
|
|
|
|
|
2011-09-23 21:43:10 +08:00
|
|
|
if (read)
|
2013-01-14 11:46:50 +08:00
|
|
|
ret = mtd_read_oob(nand, off, &ops);
|
2011-09-23 21:43:10 +08:00
|
|
|
else
|
2013-01-14 11:46:50 +08:00
|
|
|
ret = mtd_write_oob(nand, off, &ops);
|
2012-03-03 04:01:57 +08:00
|
|
|
} else if (raw) {
|
|
|
|
ret = raw_access(nand, addr, off, pagecount, read);
|
2006-10-28 21:55:52 +08:00
|
|
|
} else {
|
2008-06-13 02:13:23 +08:00
|
|
|
printf("Unknown nand command suffix '%s'.\n", s);
|
|
|
|
return 1;
|
2006-10-10 18:36:02 +08:00
|
|
|
}
|
|
|
|
|
2010-08-03 02:04:24 +08:00
|
|
|
printf(" %zu bytes %s: %s\n", rwsize,
|
2006-10-10 18:36:02 +08:00
|
|
|
read ? "read" : "written", ret ? "ERROR" : "OK");
|
2006-03-06 01:57:33 +08:00
|
|
|
|
|
|
|
return ret == 0 ? 0 : 1;
|
|
|
|
}
|
2006-10-10 18:36:02 +08:00
|
|
|
|
2012-11-17 03:20:54 +08:00
|
|
|
#ifdef CONFIG_CMD_NAND_TORTURE
|
|
|
|
if (strcmp(cmd, "torture") == 0) {
|
|
|
|
if (argc < 3)
|
|
|
|
goto usage;
|
|
|
|
|
|
|
|
if (!str2off(argv[2], &off)) {
|
|
|
|
puts("Offset is not a valid number\n");
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
printf("\nNAND torture: device %d offset 0x%llx size 0x%x\n",
|
|
|
|
dev, off, nand->erasesize);
|
|
|
|
ret = nand_torture(nand, off);
|
|
|
|
printf(" %s\n", ret ? "Failed" : "Passed");
|
|
|
|
|
|
|
|
return ret == 0 ? 0 : 1;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2006-10-10 18:36:02 +08:00
|
|
|
if (strcmp(cmd, "markbad") == 0) {
|
2009-05-24 23:34:33 +08:00
|
|
|
argc -= 2;
|
|
|
|
argv += 2;
|
2006-10-10 18:36:02 +08:00
|
|
|
|
2009-05-24 23:34:33 +08:00
|
|
|
if (argc <= 0)
|
|
|
|
goto usage;
|
|
|
|
|
|
|
|
while (argc > 0) {
|
|
|
|
addr = simple_strtoul(*argv, NULL, 16);
|
|
|
|
|
2013-01-14 11:46:50 +08:00
|
|
|
if (mtd_block_markbad(nand, addr)) {
|
2009-05-24 23:34:33 +08:00
|
|
|
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 18:36:02 +08:00
|
|
|
}
|
2009-05-24 23:34:33 +08:00
|
|
|
return ret;
|
2006-10-10 18:36:02 +08:00
|
|
|
}
|
2008-06-13 02:20:16 +08:00
|
|
|
|
2006-10-10 18:36:02 +08:00
|
|
|
if (strcmp(cmd, "biterr") == 0) {
|
|
|
|
/* todo */
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2008-12-13 23:43:06 +08:00
|
|
|
#ifdef CONFIG_CMD_NAND_LOCK_UNLOCK
|
2006-10-10 18:36:02 +08:00
|
|
|
if (strcmp(cmd, "lock") == 0) {
|
2008-12-13 23:43:06 +08:00
|
|
|
int tight = 0;
|
2006-10-10 18:36:02 +08: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-13 23:43:06 +08:00
|
|
|
do_nand_status(nand);
|
2007-10-31 20:53:06 +08:00
|
|
|
} else {
|
2007-11-09 20:32:30 +08:00
|
|
|
if (!nand_lock(nand, tight)) {
|
|
|
|
puts("NAND flash successfully locked\n");
|
|
|
|
} else {
|
|
|
|
puts("Error locking NAND flash\n");
|
|
|
|
return 1;
|
|
|
|
}
|
2006-10-10 18:36:02 +08:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-08-23 05:49:42 +08:00
|
|
|
if (strncmp(cmd, "unlock", 5) == 0) {
|
|
|
|
int allexcept = 0;
|
|
|
|
|
|
|
|
s = strchr(cmd, '.');
|
|
|
|
|
|
|
|
if (s && !strcmp(s, ".allexcept"))
|
|
|
|
allexcept = 1;
|
|
|
|
|
2013-03-14 13:32:50 +08:00
|
|
|
if (arg_off_size(argc - 2, argv + 2, &dev, &off, &size,
|
|
|
|
&maxsize) < 0)
|
2006-10-28 21:55:52 +08:00
|
|
|
return 1;
|
2006-10-10 18:36:02 +08:00
|
|
|
|
2012-08-23 05:49:42 +08:00
|
|
|
if (!nand_unlock(&nand_info[dev], off, size, allexcept)) {
|
2007-11-09 20:32:30 +08:00
|
|
|
puts("NAND flash successfully unlocked\n");
|
|
|
|
} else {
|
|
|
|
puts("Error unlocking NAND flash, "
|
2007-11-14 21:28:11 +08:00
|
|
|
"write and erase will probably fail\n");
|
2007-11-09 20:32:30 +08:00
|
|
|
return 1;
|
|
|
|
}
|
2006-10-10 18:36:02 +08:00
|
|
|
return 0;
|
|
|
|
}
|
2008-12-13 23:43:06 +08:00
|
|
|
#endif
|
2006-10-10 18:36:02 +08:00
|
|
|
|
2006-03-06 01:57:33 +08:00
|
|
|
usage:
|
2011-12-10 16:44:01 +08:00
|
|
|
return CMD_RET_USAGE;
|
2006-03-06 01:57:33 +08:00
|
|
|
}
|
|
|
|
|
2012-10-29 21:34:31 +08:00
|
|
|
#ifdef CONFIG_SYS_LONGHELP
|
|
|
|
static char nand_help_text[] =
|
2009-05-24 23:06:54 +08:00
|
|
|
"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"
|
2012-03-03 04:01:57 +08:00
|
|
|
"nand read.raw - addr off|partition [count]\n"
|
|
|
|
"nand write.raw - addr off|partition [count]\n"
|
|
|
|
" Use read.raw/write.raw to avoid ECC and access the flash as-is.\n"
|
2011-06-15 04:35:07 +08: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 11:11:58 +08: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 01:28:54 +08: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 03:43:29 +08: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-24 23:06:54 +08:00
|
|
|
"nand bad - show bad blocks\n"
|
|
|
|
"nand dump[.oob] off - dump page\n"
|
2012-11-17 03:20:54 +08:00
|
|
|
#ifdef CONFIG_CMD_NAND_TORTURE
|
|
|
|
"nand torture off - torture block at offset\n"
|
|
|
|
#endif
|
2011-09-14 06:20:35 +08:00
|
|
|
"nand scrub [-y] off size | scrub.part partition | scrub.chip\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 03:43:29 +08:00
|
|
|
" really clean NAND erasing bad blocks (UNSAFE)\n"
|
2009-05-24 23:06:54 +08:00
|
|
|
"nand markbad off [...] - mark bad block(s) at offset (UNSAFE)\n"
|
|
|
|
"nand biterr off - make a bit error at offset (UNSAFE)"
|
2008-12-13 23:43:06 +08:00
|
|
|
#ifdef CONFIG_CMD_NAND_LOCK_UNLOCK
|
2009-05-24 23:06:54 +08:00
|
|
|
"\n"
|
|
|
|
"nand lock [tight] [status]\n"
|
|
|
|
" bring nand to lock state or display locked pages\n"
|
2012-08-23 05:49:42 +08:00
|
|
|
"nand unlock[.allexcept] [offset] [size] - unlock section"
|
2008-12-13 23:43:06 +08:00
|
|
|
#endif
|
2010-07-06 01:27:07 +08: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
|
2012-10-29 21:34:31 +08:00
|
|
|
"";
|
|
|
|
#endif
|
|
|
|
|
|
|
|
U_BOOT_CMD(
|
|
|
|
nand, CONFIG_SYS_MAXARGS, 1, do_nand,
|
|
|
|
"NAND sub-system", nand_help_text
|
2008-12-13 23:43:06 +08:00
|
|
|
);
|
2006-03-06 01:57:33 +08:00
|
|
|
|
2006-10-28 21:55:52 +08:00
|
|
|
static int nand_load_image(cmd_tbl_t *cmdtp, nand_info_t *nand,
|
2008-08-14 20:41:06 +08:00
|
|
|
ulong offset, ulong addr, char *cmd)
|
2006-03-06 01:57:33 +08:00
|
|
|
{
|
|
|
|
int r;
|
2011-06-05 21:43:02 +08:00
|
|
|
char *s;
|
2008-04-28 18:08:18 +08:00
|
|
|
size_t cnt;
|
2014-05-28 17:33:33 +08:00
|
|
|
#if defined(CONFIG_IMAGE_FORMAT_LEGACY)
|
2006-03-06 01:57:33 +08:00
|
|
|
image_header_t *hdr;
|
2014-05-28 17:33:33 +08:00
|
|
|
#endif
|
2008-03-12 17:33:01 +08:00
|
|
|
#if defined(CONFIG_FIT)
|
2008-06-07 05:07:40 +08:00
|
|
|
const void *fit_hdr = NULL;
|
2008-03-12 17:33:01 +08:00
|
|
|
#endif
|
2007-07-06 20:58:39 +08:00
|
|
|
|
|
|
|
s = strchr(cmd, '.');
|
|
|
|
if (s != NULL &&
|
2009-03-18 01:06:04 +08:00
|
|
|
(strcmp(s, ".jffs2") && strcmp(s, ".e") && strcmp(s, ".i"))) {
|
2008-06-13 02:13:23 +08:00
|
|
|
printf("Unknown nand load suffix '%s'\n", s);
|
2012-02-13 21:51:18 +08:00
|
|
|
bootstage_error(BOOTSTAGE_ID_NAND_SUFFIX);
|
2008-06-13 02:13:23 +08:00
|
|
|
return 1;
|
|
|
|
}
|
2006-03-06 01:57:33 +08:00
|
|
|
|
2006-10-28 21:55:52 +08:00
|
|
|
printf("\nLoading from %s, offset 0x%lx\n", nand->name, offset);
|
2006-03-06 01:57:33 +08:00
|
|
|
|
2007-10-31 20:53:06 +08:00
|
|
|
cnt = nand->writesize;
|
2013-03-14 13:32:50 +08:00
|
|
|
r = nand_read_skip_bad(nand, offset, &cnt, NULL, nand->size,
|
|
|
|
(u_char *)addr);
|
2006-03-06 01:57:33 +08:00
|
|
|
if (r) {
|
2006-10-28 21:55:52 +08:00
|
|
|
puts("** Read error\n");
|
2012-02-13 21:51:18 +08:00
|
|
|
bootstage_error(BOOTSTAGE_ID_NAND_HDR_READ);
|
2006-03-06 01:57:33 +08:00
|
|
|
return 1;
|
|
|
|
}
|
2012-02-13 21:51:18 +08:00
|
|
|
bootstage_mark(BOOTSTAGE_ID_NAND_HDR_READ);
|
2006-03-06 01:57:33 +08:00
|
|
|
|
2008-02-29 21:58:34 +08:00
|
|
|
switch (genimg_get_format ((void *)addr)) {
|
2014-05-28 17:33:33 +08:00
|
|
|
#if defined(CONFIG_IMAGE_FORMAT_LEGACY)
|
2008-02-04 15:28:09 +08:00
|
|
|
case IMAGE_FORMAT_LEGACY:
|
|
|
|
hdr = (image_header_t *)addr;
|
|
|
|
|
2012-02-13 21:51:18 +08:00
|
|
|
bootstage_mark(BOOTSTAGE_ID_NAND_TYPE);
|
2008-02-04 15:28:09 +08:00
|
|
|
image_print_contents (hdr);
|
2006-03-06 01:57:33 +08:00
|
|
|
|
2008-02-04 15:28:09 +08:00
|
|
|
cnt = image_get_image_size (hdr);
|
|
|
|
break;
|
2014-05-28 17:33:33 +08:00
|
|
|
#endif
|
2008-02-04 15:28:09 +08:00
|
|
|
#if defined(CONFIG_FIT)
|
|
|
|
case IMAGE_FORMAT_FIT:
|
2008-03-12 17:33:01 +08:00
|
|
|
fit_hdr = (const void *)addr;
|
|
|
|
puts ("Fit image detected...\n");
|
|
|
|
|
|
|
|
cnt = fit_get_size (fit_hdr);
|
|
|
|
break;
|
2008-02-04 15:28:09 +08:00
|
|
|
#endif
|
|
|
|
default:
|
2012-02-13 21:51:18 +08:00
|
|
|
bootstage_error(BOOTSTAGE_ID_NAND_TYPE);
|
2008-02-04 15:28:09 +08:00
|
|
|
puts ("** Unknown image type\n");
|
2006-03-06 01:57:33 +08:00
|
|
|
return 1;
|
|
|
|
}
|
2012-02-13 21:51:18 +08:00
|
|
|
bootstage_mark(BOOTSTAGE_ID_NAND_TYPE);
|
2006-03-06 01:57:33 +08:00
|
|
|
|
2013-03-14 13:32:50 +08:00
|
|
|
r = nand_read_skip_bad(nand, offset, &cnt, NULL, nand->size,
|
|
|
|
(u_char *)addr);
|
2006-03-06 01:57:33 +08:00
|
|
|
if (r) {
|
2006-10-28 21:55:52 +08:00
|
|
|
puts("** Read error\n");
|
2012-02-13 21:51:18 +08:00
|
|
|
bootstage_error(BOOTSTAGE_ID_NAND_READ);
|
2006-03-06 01:57:33 +08:00
|
|
|
return 1;
|
|
|
|
}
|
2012-02-13 21:51:18 +08:00
|
|
|
bootstage_mark(BOOTSTAGE_ID_NAND_READ);
|
2006-03-06 01:57:33 +08:00
|
|
|
|
2008-03-12 17:33:01 +08:00
|
|
|
#if defined(CONFIG_FIT)
|
|
|
|
/* This cannot be done earlier, we need complete FIT image in RAM first */
|
2008-06-07 05:07:40 +08:00
|
|
|
if (genimg_get_format ((void *)addr) == IMAGE_FORMAT_FIT) {
|
|
|
|
if (!fit_check_format (fit_hdr)) {
|
2012-02-13 21:51:18 +08:00
|
|
|
bootstage_error(BOOTSTAGE_ID_NAND_FIT_READ);
|
2008-06-07 05:07:40 +08:00
|
|
|
puts ("** Bad FIT image format\n");
|
|
|
|
return 1;
|
|
|
|
}
|
2012-02-13 21:51:18 +08:00
|
|
|
bootstage_mark(BOOTSTAGE_ID_NAND_FIT_READ_OK);
|
2008-06-07 05:07:40 +08:00
|
|
|
fit_print_contents (fit_hdr);
|
|
|
|
}
|
2008-03-12 17:33:01 +08:00
|
|
|
#endif
|
|
|
|
|
2006-03-06 01:57:33 +08:00
|
|
|
/* Loading ok, update default load address */
|
|
|
|
|
|
|
|
load_addr = addr;
|
|
|
|
|
2011-06-05 21:43:02 +08:00
|
|
|
return bootm_maybe_autostart(cmdtp, cmd);
|
2006-03-06 01:57:33 +08:00
|
|
|
}
|
|
|
|
|
2012-10-29 21:34:31 +08:00
|
|
|
static int do_nandboot(cmd_tbl_t *cmdtp, int flag, int argc,
|
|
|
|
char * const argv[])
|
2006-10-28 21:55:52 +08:00
|
|
|
{
|
|
|
|
char *boot_device = NULL;
|
|
|
|
int idx;
|
|
|
|
ulong addr, offset = 0;
|
2009-04-21 08:26:31 +08:00
|
|
|
#if defined(CONFIG_CMD_MTDPARTS)
|
2006-10-28 21:55:52 +08: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 20:58:39 +08:00
|
|
|
addr = simple_strtoul(argv[1], NULL, 16);
|
2006-10-28 21:55:52 +08:00
|
|
|
else
|
2008-10-16 21:01:15 +08:00
|
|
|
addr = CONFIG_SYS_LOAD_ADDR;
|
2006-10-28 21:55:52 +08:00
|
|
|
return nand_load_image(cmdtp, &nand_info[dev->id->num],
|
2008-08-14 20:41:06 +08:00
|
|
|
part->offset, addr, argv[0]);
|
2006-10-28 21:55:52 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2012-02-13 21:51:18 +08:00
|
|
|
bootstage_mark(BOOTSTAGE_ID_NAND_PART);
|
2006-10-28 21:55:52 +08:00
|
|
|
switch (argc) {
|
|
|
|
case 1:
|
2008-10-16 21:01:15 +08:00
|
|
|
addr = CONFIG_SYS_LOAD_ADDR;
|
2006-10-28 21:55:52 +08: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 08:26:31 +08:00
|
|
|
#if defined(CONFIG_CMD_MTDPARTS)
|
2006-10-28 21:55:52 +08:00
|
|
|
usage:
|
|
|
|
#endif
|
2012-02-13 21:51:18 +08:00
|
|
|
bootstage_error(BOOTSTAGE_ID_NAND_SUFFIX);
|
2011-12-10 16:44:01 +08:00
|
|
|
return CMD_RET_USAGE;
|
2006-10-28 21:55:52 +08:00
|
|
|
}
|
2012-02-13 21:51:18 +08:00
|
|
|
bootstage_mark(BOOTSTAGE_ID_NAND_SUFFIX);
|
2006-10-28 21:55:52 +08:00
|
|
|
|
|
|
|
if (!boot_device) {
|
|
|
|
puts("\n** No boot device **\n");
|
2012-02-13 21:51:18 +08:00
|
|
|
bootstage_error(BOOTSTAGE_ID_NAND_BOOT_DEVICE);
|
2006-10-28 21:55:52 +08:00
|
|
|
return 1;
|
|
|
|
}
|
2012-02-13 21:51:18 +08:00
|
|
|
bootstage_mark(BOOTSTAGE_ID_NAND_BOOT_DEVICE);
|
2006-03-06 01:57:33 +08:00
|
|
|
|
2006-10-28 21:55:52 +08:00
|
|
|
idx = simple_strtoul(boot_device, NULL, 16);
|
|
|
|
|
2008-10-16 21:01:15 +08:00
|
|
|
if (idx < 0 || idx >= CONFIG_SYS_MAX_NAND_DEVICE || !nand_info[idx].name) {
|
2006-10-28 21:55:52 +08:00
|
|
|
printf("\n** Device %d not available\n", idx);
|
2012-02-13 21:51:18 +08:00
|
|
|
bootstage_error(BOOTSTAGE_ID_NAND_AVAILABLE);
|
2006-10-28 21:55:52 +08:00
|
|
|
return 1;
|
|
|
|
}
|
2012-02-13 21:51:18 +08:00
|
|
|
bootstage_mark(BOOTSTAGE_ID_NAND_AVAILABLE);
|
2006-10-28 21:55:52 +08:00
|
|
|
|
|
|
|
return nand_load_image(cmdtp, &nand_info[idx], offset, addr, argv[0]);
|
|
|
|
}
|
|
|
|
|
|
|
|
U_BOOT_CMD(nboot, 4, 1, do_nandboot,
|
2009-01-28 08:03:12 +08:00
|
|
|
"boot from NAND device",
|
2009-05-24 23:06:54 +08:00
|
|
|
"[partition] | [[[loadAddr] dev] offset]"
|
|
|
|
);
|