xref: /openbmc/u-boot/cmd/nand.c (revision c2147e26)
1 /*
2  * Driver for NAND support, Rick Bronson
3  * borrowed heavily from:
4  * (c) 1999 Machine Vision Holdings, Inc.
5  * (c) 1999, 2000 David Woodhouse <dwmw2@infradead.org>
6  *
7  * Ported 'dynenv' to 'nand env.oob' command
8  * (C) 2010 Nanometrics, Inc.
9  * 'dynenv' -- Dynamic environment offset in NAND OOB
10  * (C) Copyright 2006-2007 OpenMoko, Inc.
11  * Added 16-bit nand support
12  * (C) 2004 Texas Instruments
13  *
14  * Copyright 2010, 2012 Freescale Semiconductor
15  * The portions of this file whose copyright is held by Freescale and which
16  * are not considered a derived work of GPL v2-only code may be distributed
17  * and/or modified under the terms of the GNU General Public License as
18  * published by the Free Software Foundation; either version 2 of the
19  * License, or (at your option) any later version.
20  */
21 
22 #include <common.h>
23 #include <linux/mtd/mtd.h>
24 #include <command.h>
25 #include <console.h>
26 #include <watchdog.h>
27 #include <malloc.h>
28 #include <asm/byteorder.h>
29 #include <jffs2/jffs2.h>
30 #include <nand.h>
31 
32 #if defined(CONFIG_CMD_MTDPARTS)
33 
34 /* partition handling routines */
35 int mtdparts_init(void);
36 int id_parse(const char *id, const char **ret_id, u8 *dev_type, u8 *dev_num);
37 int find_dev_and_part(const char *id, struct mtd_device **dev,
38 		      u8 *part_num, struct part_info **part);
39 #endif
40 
41 static int nand_dump(struct mtd_info *mtd, ulong off, int only_oob,
42 		     int repeat)
43 {
44 	int i;
45 	u_char *datbuf, *oobbuf, *p;
46 	static loff_t last;
47 	int ret = 0;
48 
49 	if (repeat)
50 		off = last + mtd->writesize;
51 
52 	last = off;
53 
54 	datbuf = memalign(ARCH_DMA_MINALIGN, mtd->writesize);
55 	if (!datbuf) {
56 		puts("No memory for page buffer\n");
57 		return 1;
58 	}
59 
60 	oobbuf = memalign(ARCH_DMA_MINALIGN, mtd->oobsize);
61 	if (!oobbuf) {
62 		puts("No memory for page buffer\n");
63 		ret = 1;
64 		goto free_dat;
65 	}
66 	off &= ~(mtd->writesize - 1);
67 	loff_t addr = (loff_t) off;
68 	struct mtd_oob_ops ops;
69 	memset(&ops, 0, sizeof(ops));
70 	ops.datbuf = datbuf;
71 	ops.oobbuf = oobbuf;
72 	ops.len = mtd->writesize;
73 	ops.ooblen = mtd->oobsize;
74 	ops.mode = MTD_OPS_RAW;
75 	i = mtd_read_oob(mtd, addr, &ops);
76 	if (i < 0) {
77 		printf("Error (%d) reading page %08lx\n", i, off);
78 		ret = 1;
79 		goto free_all;
80 	}
81 	printf("Page %08lx dump:\n", off);
82 
83 	if (!only_oob) {
84 		i = mtd->writesize >> 4;
85 		p = datbuf;
86 
87 		while (i--) {
88 			printf("\t%02x %02x %02x %02x %02x %02x %02x %02x"
89 			       "  %02x %02x %02x %02x %02x %02x %02x %02x\n",
90 			       p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7],
91 			       p[8], p[9], p[10], p[11], p[12], p[13], p[14],
92 			       p[15]);
93 			p += 16;
94 		}
95 	}
96 
97 	puts("OOB:\n");
98 	i = mtd->oobsize >> 3;
99 	p = oobbuf;
100 	while (i--) {
101 		printf("\t%02x %02x %02x %02x %02x %02x %02x %02x\n",
102 		       p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]);
103 		p += 8;
104 	}
105 
106 free_all:
107 	free(oobbuf);
108 free_dat:
109 	free(datbuf);
110 
111 	return ret;
112 }
113 
114 /* ------------------------------------------------------------------------- */
115 
116 static int set_dev(int dev)
117 {
118 	if (dev < 0 || dev >= CONFIG_SYS_MAX_NAND_DEVICE ||
119 	    !nand_info[dev]->name) {
120 		puts("No such device\n");
121 		return -1;
122 	}
123 
124 	if (nand_curr_device == dev)
125 		return 0;
126 
127 	printf("Device %d: %s", dev, nand_info[dev]->name);
128 	puts("... is now current device\n");
129 	nand_curr_device = dev;
130 
131 #ifdef CONFIG_SYS_NAND_SELECT_DEVICE
132 	board_nand_select_device(nand_info[dev]->priv, dev);
133 #endif
134 
135 	return 0;
136 }
137 
138 #ifdef CONFIG_CMD_NAND_LOCK_UNLOCK
139 static void print_status(ulong start, ulong end, ulong erasesize, int status)
140 {
141 	/*
142 	 * Micron NAND flash (e.g. MT29F4G08ABADAH4) BLOCK LOCK READ STATUS is
143 	 * not the same as others.  Instead of bit 1 being lock, it is
144 	 * #lock_tight. To make the driver support either format, ignore bit 1
145 	 * and use only bit 0 and bit 2.
146 	 */
147 	printf("%08lx - %08lx: %08lx blocks %s%s%s\n",
148 		start,
149 		end - 1,
150 		(end - start) / erasesize,
151 		((status & NAND_LOCK_STATUS_TIGHT) ?  "TIGHT " : ""),
152 		(!(status & NAND_LOCK_STATUS_UNLOCK) ?  "LOCK " : ""),
153 		((status & NAND_LOCK_STATUS_UNLOCK) ?  "UNLOCK " : ""));
154 }
155 
156 static void do_nand_status(struct mtd_info *mtd)
157 {
158 	ulong block_start = 0;
159 	ulong off;
160 	int last_status = -1;
161 
162 	struct nand_chip *nand_chip = mtd_to_nand(mtd);
163 	/* check the WP bit */
164 	nand_chip->cmdfunc(mtd, NAND_CMD_STATUS, -1, -1);
165 	printf("device is %swrite protected\n",
166 		(nand_chip->read_byte(mtd) & 0x80 ?
167 		 "NOT " : ""));
168 
169 	for (off = 0; off < mtd->size; off += mtd->erasesize) {
170 		int s = nand_get_lock_status(mtd, off);
171 
172 		/* print message only if status has changed */
173 		if (s != last_status && off != 0) {
174 			print_status(block_start, off, mtd->erasesize,
175 					last_status);
176 			block_start = off;
177 		}
178 		last_status = s;
179 	}
180 	/* Print the last block info */
181 	print_status(block_start, off, mtd->erasesize, last_status);
182 }
183 #endif
184 
185 #ifdef CONFIG_ENV_OFFSET_OOB
186 unsigned long nand_env_oob_offset;
187 
188 int do_nand_env_oob(cmd_tbl_t *cmdtp, int argc, char *const argv[])
189 {
190 	int ret;
191 	uint32_t oob_buf[ENV_OFFSET_SIZE/sizeof(uint32_t)];
192 	struct mtd_info *mtd = nand_info[0];
193 	char *cmd = argv[1];
194 
195 	if (CONFIG_SYS_MAX_NAND_DEVICE == 0 || !mtd->name) {
196 		puts("no devices available\n");
197 		return 1;
198 	}
199 
200 	set_dev(0);
201 
202 	if (!strcmp(cmd, "get")) {
203 		ret = get_nand_env_oob(mtd, &nand_env_oob_offset);
204 		if (ret)
205 			return 1;
206 
207 		printf("0x%08lx\n", nand_env_oob_offset);
208 	} else if (!strcmp(cmd, "set")) {
209 		loff_t addr;
210 		loff_t maxsize;
211 		struct mtd_oob_ops ops;
212 		int idx = 0;
213 
214 		if (argc < 3)
215 			goto usage;
216 
217 		/* We don't care about size, or maxsize. */
218 		if (mtd_arg_off(argv[2], &idx, &addr, &maxsize, &maxsize,
219 				MTD_DEV_TYPE_NAND, nand_info[idx]->size)) {
220 			puts("Offset or partition name expected\n");
221 			return 1;
222 		}
223 		if (set_dev(idx)) {
224 			puts("Offset or partition name expected\n");
225 			return 1;
226 		}
227 
228 		if (idx != 0) {
229 			puts("Partition not on first NAND device\n");
230 			return 1;
231 		}
232 
233 		if (mtd->oobavail < ENV_OFFSET_SIZE) {
234 			printf("Insufficient available OOB bytes:\n"
235 			       "%d OOB bytes available but %d required for "
236 			       "env.oob support\n",
237 			       mtd->oobavail, ENV_OFFSET_SIZE);
238 			return 1;
239 		}
240 
241 		if ((addr & (mtd->erasesize - 1)) != 0) {
242 			printf("Environment offset must be block-aligned\n");
243 			return 1;
244 		}
245 
246 		ops.datbuf = NULL;
247 		ops.mode = MTD_OOB_AUTO;
248 		ops.ooboffs = 0;
249 		ops.ooblen = ENV_OFFSET_SIZE;
250 		ops.oobbuf = (void *) oob_buf;
251 
252 		oob_buf[0] = ENV_OOB_MARKER;
253 		oob_buf[1] = addr / mtd->erasesize;
254 
255 		ret = mtd->write_oob(mtd, ENV_OFFSET_SIZE, &ops);
256 		if (ret) {
257 			printf("Error writing OOB block 0\n");
258 			return ret;
259 		}
260 
261 		ret = get_nand_env_oob(mtd, &nand_env_oob_offset);
262 		if (ret) {
263 			printf("Error reading env offset in OOB\n");
264 			return ret;
265 		}
266 
267 		if (addr != nand_env_oob_offset) {
268 			printf("Verification of env offset in OOB failed: "
269 			       "0x%08llx expected but got 0x%08lx\n",
270 			       (unsigned long long)addr, nand_env_oob_offset);
271 			return 1;
272 		}
273 	} else {
274 		goto usage;
275 	}
276 
277 	return ret;
278 
279 usage:
280 	return CMD_RET_USAGE;
281 }
282 
283 #endif
284 
285 static void nand_print_and_set_info(int idx)
286 {
287 	struct mtd_info *mtd = nand_info[idx];
288 	struct nand_chip *chip = mtd_to_nand(mtd);
289 
290 	printf("Device %d: ", idx);
291 	if (chip->numchips > 1)
292 		printf("%dx ", chip->numchips);
293 	printf("%s, sector size %u KiB\n",
294 	       mtd->name, mtd->erasesize >> 10);
295 	printf("  Page size   %8d b\n", mtd->writesize);
296 	printf("  OOB size    %8d b\n", mtd->oobsize);
297 	printf("  Erase size  %8d b\n", mtd->erasesize);
298 	printf("  subpagesize %8d b\n", chip->subpagesize);
299 	printf("  options     0x%8x\n", chip->options);
300 	printf("  bbt options 0x%8x\n", chip->bbt_options);
301 
302 	/* Set geometry info */
303 	setenv_hex("nand_writesize", mtd->writesize);
304 	setenv_hex("nand_oobsize", mtd->oobsize);
305 	setenv_hex("nand_erasesize", mtd->erasesize);
306 }
307 
308 static int raw_access(struct mtd_info *mtd, ulong addr, loff_t off,
309 		      ulong count, int read, int no_verify)
310 {
311 	int ret = 0;
312 
313 	while (count--) {
314 		/* Raw access */
315 		mtd_oob_ops_t ops = {
316 			.datbuf = (u8 *)addr,
317 			.oobbuf = ((u8 *)addr) + mtd->writesize,
318 			.len = mtd->writesize,
319 			.ooblen = mtd->oobsize,
320 			.mode = MTD_OPS_RAW
321 		};
322 
323 		if (read) {
324 			ret = mtd_read_oob(mtd, off, &ops);
325 		} else {
326 			ret = mtd_write_oob(mtd, off, &ops);
327 			if (!ret && !no_verify)
328 				ret = nand_verify_page_oob(mtd, &ops, off);
329 		}
330 
331 		if (ret) {
332 			printf("%s: error at offset %llx, ret %d\n",
333 				__func__, (long long)off, ret);
334 			break;
335 		}
336 
337 		addr += mtd->writesize + mtd->oobsize;
338 		off += mtd->writesize;
339 	}
340 
341 	return ret;
342 }
343 
344 /* Adjust a chip/partition size down for bad blocks so we don't
345  * read/write past the end of a chip/partition by accident.
346  */
347 static void adjust_size_for_badblocks(loff_t *size, loff_t offset, int dev)
348 {
349 	/* We grab the nand info object here fresh because this is usually
350 	 * called after arg_off_size() which can change the value of dev.
351 	 */
352 	struct mtd_info *mtd = nand_info[dev];
353 	loff_t maxoffset = offset + *size;
354 	int badblocks = 0;
355 
356 	/* count badblocks in NAND from offset to offset + size */
357 	for (; offset < maxoffset; offset += mtd->erasesize) {
358 		if (nand_block_isbad(mtd, offset))
359 			badblocks++;
360 	}
361 	/* adjust size if any bad blocks found */
362 	if (badblocks) {
363 		*size -= badblocks * mtd->erasesize;
364 		printf("size adjusted to 0x%llx (%d bad blocks)\n",
365 		       (unsigned long long)*size, badblocks);
366 	}
367 }
368 
369 static int do_nand(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
370 {
371 	int i, ret = 0;
372 	ulong addr;
373 	loff_t off, size, maxsize;
374 	char *cmd, *s;
375 	struct mtd_info *mtd;
376 #ifdef CONFIG_SYS_NAND_QUIET
377 	int quiet = CONFIG_SYS_NAND_QUIET;
378 #else
379 	int quiet = 0;
380 #endif
381 	const char *quiet_str = getenv("quiet");
382 	int dev = nand_curr_device;
383 	int repeat = flag & CMD_FLAG_REPEAT;
384 
385 	/* at least two arguments please */
386 	if (argc < 2)
387 		goto usage;
388 
389 	if (quiet_str)
390 		quiet = simple_strtoul(quiet_str, NULL, 0) != 0;
391 
392 	cmd = argv[1];
393 
394 	/* Only "dump" is repeatable. */
395 	if (repeat && strcmp(cmd, "dump"))
396 		return 0;
397 
398 	if (strcmp(cmd, "info") == 0) {
399 
400 		putc('\n');
401 		for (i = 0; i < CONFIG_SYS_MAX_NAND_DEVICE; i++) {
402 			if (nand_info[i]->name)
403 				nand_print_and_set_info(i);
404 		}
405 		return 0;
406 	}
407 
408 	if (strcmp(cmd, "device") == 0) {
409 		if (argc < 3) {
410 			putc('\n');
411 			if (dev < 0 || dev >= CONFIG_SYS_MAX_NAND_DEVICE)
412 				puts("no devices available\n");
413 			else
414 				nand_print_and_set_info(dev);
415 			return 0;
416 		}
417 
418 		dev = (int)simple_strtoul(argv[2], NULL, 10);
419 		set_dev(dev);
420 
421 		return 0;
422 	}
423 
424 #ifdef CONFIG_ENV_OFFSET_OOB
425 	/* this command operates only on the first nand device */
426 	if (strcmp(cmd, "env.oob") == 0)
427 		return do_nand_env_oob(cmdtp, argc - 1, argv + 1);
428 #endif
429 
430 	/* The following commands operate on the current device, unless
431 	 * overridden by a partition specifier.  Note that if somehow the
432 	 * current device is invalid, it will have to be changed to a valid
433 	 * one before these commands can run, even if a partition specifier
434 	 * for another device is to be used.
435 	 */
436 	if (dev < 0 || dev >= CONFIG_SYS_MAX_NAND_DEVICE ||
437 	    !nand_info[dev]->name) {
438 		puts("\nno devices available\n");
439 		return 1;
440 	}
441 	mtd = nand_info[dev];
442 
443 	if (strcmp(cmd, "bad") == 0) {
444 		printf("\nDevice %d bad blocks:\n", dev);
445 		for (off = 0; off < mtd->size; off += mtd->erasesize)
446 			if (nand_block_isbad(mtd, off))
447 				printf("  %08llx\n", (unsigned long long)off);
448 		return 0;
449 	}
450 
451 	/*
452 	 * Syntax is:
453 	 *   0    1     2       3    4
454 	 *   nand erase [clean] [off size]
455 	 */
456 	if (strncmp(cmd, "erase", 5) == 0 || strncmp(cmd, "scrub", 5) == 0) {
457 		nand_erase_options_t opts;
458 		/* "clean" at index 2 means request to write cleanmarker */
459 		int clean = argc > 2 && !strcmp("clean", argv[2]);
460 		int scrub_yes = argc > 2 && !strcmp("-y", argv[2]);
461 		int o = (clean || scrub_yes) ? 3 : 2;
462 		int scrub = !strncmp(cmd, "scrub", 5);
463 		int spread = 0;
464 		int args = 2;
465 		const char *scrub_warn =
466 			"Warning: "
467 			"scrub option will erase all factory set bad blocks!\n"
468 			"         "
469 			"There is no reliable way to recover them.\n"
470 			"         "
471 			"Use this command only for testing purposes if you\n"
472 			"         "
473 			"are sure of what you are doing!\n"
474 			"\nReally scrub this NAND flash? <y/N>\n";
475 
476 		if (cmd[5] != 0) {
477 			if (!strcmp(&cmd[5], ".spread")) {
478 				spread = 1;
479 			} else if (!strcmp(&cmd[5], ".part")) {
480 				args = 1;
481 			} else if (!strcmp(&cmd[5], ".chip")) {
482 				args = 0;
483 			} else {
484 				goto usage;
485 			}
486 		}
487 
488 		/*
489 		 * Don't allow missing arguments to cause full chip/partition
490 		 * erases -- easy to do accidentally, e.g. with a misspelled
491 		 * variable name.
492 		 */
493 		if (argc != o + args)
494 			goto usage;
495 
496 		printf("\nNAND %s: ", cmd);
497 		/* skip first two or three arguments, look for offset and size */
498 		if (mtd_arg_off_size(argc - o, argv + o, &dev, &off, &size,
499 				     &maxsize, MTD_DEV_TYPE_NAND,
500 				     nand_info[dev]->size) != 0)
501 			return 1;
502 
503 		if (set_dev(dev))
504 			return 1;
505 
506 		mtd = nand_info[dev];
507 
508 		memset(&opts, 0, sizeof(opts));
509 		opts.offset = off;
510 		opts.length = size;
511 		opts.jffs2  = clean;
512 		opts.quiet  = quiet;
513 		opts.spread = spread;
514 
515 		if (scrub) {
516 			if (scrub_yes) {
517 				opts.scrub = 1;
518 			} else {
519 				puts(scrub_warn);
520 				if (confirm_yesno()) {
521 					opts.scrub = 1;
522 				} else {
523 					puts("scrub aborted\n");
524 					return 1;
525 				}
526 			}
527 		}
528 		ret = nand_erase_opts(mtd, &opts);
529 		printf("%s\n", ret ? "ERROR" : "OK");
530 
531 		return ret == 0 ? 0 : 1;
532 	}
533 
534 	if (strncmp(cmd, "dump", 4) == 0) {
535 		if (argc < 3)
536 			goto usage;
537 
538 		off = (int)simple_strtoul(argv[2], NULL, 16);
539 		ret = nand_dump(mtd, off, !strcmp(&cmd[4], ".oob"), repeat);
540 
541 		return ret == 0 ? 1 : 0;
542 	}
543 
544 	if (strncmp(cmd, "read", 4) == 0 || strncmp(cmd, "write", 5) == 0) {
545 		size_t rwsize;
546 		ulong pagecount = 1;
547 		int read;
548 		int raw = 0;
549 		int no_verify = 0;
550 
551 		if (argc < 4)
552 			goto usage;
553 
554 		addr = (ulong)simple_strtoul(argv[2], NULL, 16);
555 
556 		read = strncmp(cmd, "read", 4) == 0; /* 1 = read, 0 = write */
557 		printf("\nNAND %s: ", read ? "read" : "write");
558 
559 		s = strchr(cmd, '.');
560 
561 		if (s && !strncmp(s, ".raw", 4)) {
562 			raw = 1;
563 
564 			if (!strcmp(s, ".raw.noverify"))
565 				no_verify = 1;
566 
567 			if (mtd_arg_off(argv[3], &dev, &off, &size, &maxsize,
568 					MTD_DEV_TYPE_NAND,
569 					nand_info[dev]->size))
570 				return 1;
571 
572 			if (set_dev(dev))
573 				return 1;
574 
575 			mtd = nand_info[dev];
576 
577 			if (argc > 4 && !str2long(argv[4], &pagecount)) {
578 				printf("'%s' is not a number\n", argv[4]);
579 				return 1;
580 			}
581 
582 			if (pagecount * mtd->writesize > size) {
583 				puts("Size exceeds partition or device limit\n");
584 				return -1;
585 			}
586 
587 			rwsize = pagecount * (mtd->writesize + mtd->oobsize);
588 		} else {
589 			if (mtd_arg_off_size(argc - 3, argv + 3, &dev, &off,
590 					     &size, &maxsize,
591 					     MTD_DEV_TYPE_NAND,
592 					     nand_info[dev]->size) != 0)
593 				return 1;
594 
595 			if (set_dev(dev))
596 				return 1;
597 
598 			/* size is unspecified */
599 			if (argc < 5)
600 				adjust_size_for_badblocks(&size, off, dev);
601 			rwsize = size;
602 		}
603 
604 		mtd = nand_info[dev];
605 
606 		if (!s || !strcmp(s, ".jffs2") ||
607 		    !strcmp(s, ".e") || !strcmp(s, ".i")) {
608 			if (read)
609 				ret = nand_read_skip_bad(mtd, off, &rwsize,
610 							 NULL, maxsize,
611 							 (u_char *)addr);
612 			else
613 				ret = nand_write_skip_bad(mtd, off, &rwsize,
614 							  NULL, maxsize,
615 							  (u_char *)addr,
616 							  WITH_WR_VERIFY);
617 #ifdef CONFIG_CMD_NAND_TRIMFFS
618 		} else if (!strcmp(s, ".trimffs")) {
619 			if (read) {
620 				printf("Unknown nand command suffix '%s'\n", s);
621 				return 1;
622 			}
623 			ret = nand_write_skip_bad(mtd, off, &rwsize, NULL,
624 						maxsize, (u_char *)addr,
625 						WITH_DROP_FFS | WITH_WR_VERIFY);
626 #endif
627 		} else if (!strcmp(s, ".oob")) {
628 			/* out-of-band data */
629 			mtd_oob_ops_t ops = {
630 				.oobbuf = (u8 *)addr,
631 				.ooblen = rwsize,
632 				.mode = MTD_OPS_RAW
633 			};
634 
635 			if (read)
636 				ret = mtd_read_oob(mtd, off, &ops);
637 			else
638 				ret = mtd_write_oob(mtd, off, &ops);
639 		} else if (raw) {
640 			ret = raw_access(mtd, addr, off, pagecount, read,
641 					 no_verify);
642 		} else {
643 			printf("Unknown nand command suffix '%s'.\n", s);
644 			return 1;
645 		}
646 
647 		printf(" %zu bytes %s: %s\n", rwsize,
648 		       read ? "read" : "written", ret ? "ERROR" : "OK");
649 
650 		return ret == 0 ? 0 : 1;
651 	}
652 
653 #ifdef CONFIG_CMD_NAND_TORTURE
654 	if (strcmp(cmd, "torture") == 0) {
655 		loff_t endoff;
656 		unsigned int failed = 0, passed = 0;
657 
658 		if (argc < 3)
659 			goto usage;
660 
661 		if (!str2off(argv[2], &off)) {
662 			puts("Offset is not a valid number\n");
663 			return 1;
664 		}
665 
666 		size = mtd->erasesize;
667 		if (argc > 3) {
668 			if (!str2off(argv[3], &size)) {
669 				puts("Size is not a valid number\n");
670 				return 1;
671 			}
672 		}
673 
674 		endoff = off + size;
675 		if (endoff > mtd->size) {
676 			puts("Arguments beyond end of NAND\n");
677 			return 1;
678 		}
679 
680 		off = round_down(off, mtd->erasesize);
681 		endoff = round_up(endoff, mtd->erasesize);
682 		size = endoff - off;
683 		printf("\nNAND torture: device %d offset 0x%llx size 0x%llx (block size 0x%x)\n",
684 		       dev, off, size, mtd->erasesize);
685 		while (off < endoff) {
686 			ret = nand_torture(mtd, off);
687 			if (ret) {
688 				failed++;
689 				printf("  block at 0x%llx failed\n", off);
690 			} else {
691 				passed++;
692 			}
693 			off += mtd->erasesize;
694 		}
695 		printf(" Passed: %u, failed: %u\n", passed, failed);
696 		return failed != 0;
697 	}
698 #endif
699 
700 	if (strcmp(cmd, "markbad") == 0) {
701 		argc -= 2;
702 		argv += 2;
703 
704 		if (argc <= 0)
705 			goto usage;
706 
707 		while (argc > 0) {
708 			addr = simple_strtoul(*argv, NULL, 16);
709 
710 			if (mtd_block_markbad(mtd, addr)) {
711 				printf("block 0x%08lx NOT marked "
712 					"as bad! ERROR %d\n",
713 					addr, ret);
714 				ret = 1;
715 			} else {
716 				printf("block 0x%08lx successfully "
717 					"marked as bad\n",
718 					addr);
719 			}
720 			--argc;
721 			++argv;
722 		}
723 		return ret;
724 	}
725 
726 	if (strcmp(cmd, "biterr") == 0) {
727 		/* todo */
728 		return 1;
729 	}
730 
731 #ifdef CONFIG_CMD_NAND_LOCK_UNLOCK
732 	if (strcmp(cmd, "lock") == 0) {
733 		int tight = 0;
734 		int status = 0;
735 		if (argc == 3) {
736 			if (!strcmp("tight", argv[2]))
737 				tight = 1;
738 			if (!strcmp("status", argv[2]))
739 				status = 1;
740 		}
741 		if (status) {
742 			do_nand_status(mtd);
743 		} else {
744 			if (!nand_lock(mtd, tight)) {
745 				puts("NAND flash successfully locked\n");
746 			} else {
747 				puts("Error locking NAND flash\n");
748 				return 1;
749 			}
750 		}
751 		return 0;
752 	}
753 
754 	if (strncmp(cmd, "unlock", 5) == 0) {
755 		int allexcept = 0;
756 
757 		s = strchr(cmd, '.');
758 
759 		if (s && !strcmp(s, ".allexcept"))
760 			allexcept = 1;
761 
762 		if (mtd_arg_off_size(argc - 2, argv + 2, &dev, &off, &size,
763 				     &maxsize, MTD_DEV_TYPE_NAND,
764 				     nand_info[dev]->size) < 0)
765 			return 1;
766 
767 		if (set_dev(dev))
768 			return 1;
769 
770 		if (!nand_unlock(nand_info[dev], off, size, allexcept)) {
771 			puts("NAND flash successfully unlocked\n");
772 		} else {
773 			puts("Error unlocking NAND flash, "
774 			     "write and erase will probably fail\n");
775 			return 1;
776 		}
777 		return 0;
778 	}
779 #endif
780 
781 usage:
782 	return CMD_RET_USAGE;
783 }
784 
785 #ifdef CONFIG_SYS_LONGHELP
786 static char nand_help_text[] =
787 	"info - show available NAND devices\n"
788 	"nand device [dev] - show or set current device\n"
789 	"nand read - addr off|partition size\n"
790 	"nand write - addr off|partition size\n"
791 	"    read/write 'size' bytes starting at offset 'off'\n"
792 	"    to/from memory address 'addr', skipping bad blocks.\n"
793 	"nand read.raw - addr off|partition [count]\n"
794 	"nand write.raw[.noverify] - addr off|partition [count]\n"
795 	"    Use read.raw/write.raw to avoid ECC and access the flash as-is.\n"
796 #ifdef CONFIG_CMD_NAND_TRIMFFS
797 	"nand write.trimffs - addr off|partition size\n"
798 	"    write 'size' bytes starting at offset 'off' from memory address\n"
799 	"    'addr', skipping bad blocks and dropping any pages at the end\n"
800 	"    of eraseblocks that contain only 0xFF\n"
801 #endif
802 	"nand erase[.spread] [clean] off size - erase 'size' bytes "
803 	"from offset 'off'\n"
804 	"    With '.spread', erase enough for given file size, otherwise,\n"
805 	"    'size' includes skipped bad blocks.\n"
806 	"nand erase.part [clean] partition - erase entire mtd partition'\n"
807 	"nand erase.chip [clean] - erase entire chip'\n"
808 	"nand bad - show bad blocks\n"
809 	"nand dump[.oob] off - dump page\n"
810 #ifdef CONFIG_CMD_NAND_TORTURE
811 	"nand torture off - torture one block at offset\n"
812 	"nand torture off [size] - torture blocks from off to off+size\n"
813 #endif
814 	"nand scrub [-y] off size | scrub.part partition | scrub.chip\n"
815 	"    really clean NAND erasing bad blocks (UNSAFE)\n"
816 	"nand markbad off [...] - mark bad block(s) at offset (UNSAFE)\n"
817 	"nand biterr off - make a bit error at offset (UNSAFE)"
818 #ifdef CONFIG_CMD_NAND_LOCK_UNLOCK
819 	"\n"
820 	"nand lock [tight] [status]\n"
821 	"    bring nand to lock state or display locked pages\n"
822 	"nand unlock[.allexcept] [offset] [size] - unlock section"
823 #endif
824 #ifdef CONFIG_ENV_OFFSET_OOB
825 	"\n"
826 	"nand env.oob - environment offset in OOB of block 0 of"
827 	"    first device.\n"
828 	"nand env.oob set off|partition - set enviromnent offset\n"
829 	"nand env.oob get - get environment offset"
830 #endif
831 	"";
832 #endif
833 
834 U_BOOT_CMD(
835 	nand, CONFIG_SYS_MAXARGS, 1, do_nand,
836 	"NAND sub-system", nand_help_text
837 );
838 
839 static int nand_load_image(cmd_tbl_t *cmdtp, struct mtd_info *mtd,
840 			   ulong offset, ulong addr, char *cmd)
841 {
842 	int r;
843 	char *s;
844 	size_t cnt;
845 #if defined(CONFIG_IMAGE_FORMAT_LEGACY)
846 	image_header_t *hdr;
847 #endif
848 #if defined(CONFIG_FIT)
849 	const void *fit_hdr = NULL;
850 #endif
851 
852 	s = strchr(cmd, '.');
853 	if (s != NULL &&
854 	    (strcmp(s, ".jffs2") && strcmp(s, ".e") && strcmp(s, ".i"))) {
855 		printf("Unknown nand load suffix '%s'\n", s);
856 		bootstage_error(BOOTSTAGE_ID_NAND_SUFFIX);
857 		return 1;
858 	}
859 
860 	printf("\nLoading from %s, offset 0x%lx\n", mtd->name, offset);
861 
862 	cnt = mtd->writesize;
863 	r = nand_read_skip_bad(mtd, offset, &cnt, NULL, mtd->size,
864 			       (u_char *)addr);
865 	if (r) {
866 		puts("** Read error\n");
867 		bootstage_error(BOOTSTAGE_ID_NAND_HDR_READ);
868 		return 1;
869 	}
870 	bootstage_mark(BOOTSTAGE_ID_NAND_HDR_READ);
871 
872 	switch (genimg_get_format ((void *)addr)) {
873 #if defined(CONFIG_IMAGE_FORMAT_LEGACY)
874 	case IMAGE_FORMAT_LEGACY:
875 		hdr = (image_header_t *)addr;
876 
877 		bootstage_mark(BOOTSTAGE_ID_NAND_TYPE);
878 		image_print_contents (hdr);
879 
880 		cnt = image_get_image_size (hdr);
881 		break;
882 #endif
883 #if defined(CONFIG_FIT)
884 	case IMAGE_FORMAT_FIT:
885 		fit_hdr = (const void *)addr;
886 		puts ("Fit image detected...\n");
887 
888 		cnt = fit_get_size (fit_hdr);
889 		break;
890 #endif
891 	default:
892 		bootstage_error(BOOTSTAGE_ID_NAND_TYPE);
893 		puts ("** Unknown image type\n");
894 		return 1;
895 	}
896 	bootstage_mark(BOOTSTAGE_ID_NAND_TYPE);
897 
898 	r = nand_read_skip_bad(mtd, offset, &cnt, NULL, mtd->size,
899 			       (u_char *)addr);
900 	if (r) {
901 		puts("** Read error\n");
902 		bootstage_error(BOOTSTAGE_ID_NAND_READ);
903 		return 1;
904 	}
905 	bootstage_mark(BOOTSTAGE_ID_NAND_READ);
906 
907 #if defined(CONFIG_FIT)
908 	/* This cannot be done earlier, we need complete FIT image in RAM first */
909 	if (genimg_get_format ((void *)addr) == IMAGE_FORMAT_FIT) {
910 		if (!fit_check_format (fit_hdr)) {
911 			bootstage_error(BOOTSTAGE_ID_NAND_FIT_READ);
912 			puts ("** Bad FIT image format\n");
913 			return 1;
914 		}
915 		bootstage_mark(BOOTSTAGE_ID_NAND_FIT_READ_OK);
916 		fit_print_contents (fit_hdr);
917 	}
918 #endif
919 
920 	/* Loading ok, update default load address */
921 
922 	load_addr = addr;
923 
924 	return bootm_maybe_autostart(cmdtp, cmd);
925 }
926 
927 static int do_nandboot(cmd_tbl_t *cmdtp, int flag, int argc,
928 		       char * const argv[])
929 {
930 	char *boot_device = NULL;
931 	int idx;
932 	ulong addr, offset = 0;
933 #if defined(CONFIG_CMD_MTDPARTS)
934 	struct mtd_device *dev;
935 	struct part_info *part;
936 	u8 pnum;
937 
938 	if (argc >= 2) {
939 		char *p = (argc == 2) ? argv[1] : argv[2];
940 		if (!(str2long(p, &addr)) && (mtdparts_init() == 0) &&
941 		    (find_dev_and_part(p, &dev, &pnum, &part) == 0)) {
942 			if (dev->id->type != MTD_DEV_TYPE_NAND) {
943 				puts("Not a NAND device\n");
944 				return 1;
945 			}
946 			if (argc > 3)
947 				goto usage;
948 			if (argc == 3)
949 				addr = simple_strtoul(argv[1], NULL, 16);
950 			else
951 				addr = CONFIG_SYS_LOAD_ADDR;
952 			return nand_load_image(cmdtp, nand_info[dev->id->num],
953 					       part->offset, addr, argv[0]);
954 		}
955 	}
956 #endif
957 
958 	bootstage_mark(BOOTSTAGE_ID_NAND_PART);
959 	switch (argc) {
960 	case 1:
961 		addr = CONFIG_SYS_LOAD_ADDR;
962 		boot_device = getenv("bootdevice");
963 		break;
964 	case 2:
965 		addr = simple_strtoul(argv[1], NULL, 16);
966 		boot_device = getenv("bootdevice");
967 		break;
968 	case 3:
969 		addr = simple_strtoul(argv[1], NULL, 16);
970 		boot_device = argv[2];
971 		break;
972 	case 4:
973 		addr = simple_strtoul(argv[1], NULL, 16);
974 		boot_device = argv[2];
975 		offset = simple_strtoul(argv[3], NULL, 16);
976 		break;
977 	default:
978 #if defined(CONFIG_CMD_MTDPARTS)
979 usage:
980 #endif
981 		bootstage_error(BOOTSTAGE_ID_NAND_SUFFIX);
982 		return CMD_RET_USAGE;
983 	}
984 	bootstage_mark(BOOTSTAGE_ID_NAND_SUFFIX);
985 
986 	if (!boot_device) {
987 		puts("\n** No boot device **\n");
988 		bootstage_error(BOOTSTAGE_ID_NAND_BOOT_DEVICE);
989 		return 1;
990 	}
991 	bootstage_mark(BOOTSTAGE_ID_NAND_BOOT_DEVICE);
992 
993 	idx = simple_strtoul(boot_device, NULL, 16);
994 
995 	if (idx < 0 || idx >= CONFIG_SYS_MAX_NAND_DEVICE || !nand_info[idx]->name) {
996 		printf("\n** Device %d not available\n", idx);
997 		bootstage_error(BOOTSTAGE_ID_NAND_AVAILABLE);
998 		return 1;
999 	}
1000 	bootstage_mark(BOOTSTAGE_ID_NAND_AVAILABLE);
1001 
1002 	return nand_load_image(cmdtp, nand_info[idx], offset, addr, argv[0]);
1003 }
1004 
1005 U_BOOT_CMD(nboot, 4, 1, do_nandboot,
1006 	"boot from NAND device",
1007 	"[partition] | [[[loadAddr] dev] offset]"
1008 );
1009