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>
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
16 #include <linux/mtd/mtd.h>
20 #include <asm/byteorder.h>
21 #include <jffs2/jffs2.h>
24 #if defined(CONFIG_CMD_MTDPARTS)
26 /* partition handling routines */
27 int mtdparts_init(void);
28 int id_parse(const char *id, const char **ret_id, u8 *dev_type, u8 *dev_num);
29 int find_dev_and_part(const char *id, struct mtd_device **dev,
30 u8 *part_num, struct part_info **part);
33 static int nand_dump(nand_info_t *nand, ulong off, int only_oob)
36 u_char *datbuf, *oobbuf, *p;
38 datbuf = malloc(nand->writesize + nand->oobsize);
39 oobbuf = malloc(nand->oobsize);
40 if (!datbuf || !oobbuf) {
41 puts("No memory for page buffer\n");
44 off &= ~(nand->writesize - 1);
45 loff_t addr = (loff_t) off;
46 struct mtd_oob_ops ops;
47 memset(&ops, 0, sizeof(ops));
49 ops.oobbuf = oobbuf; /* must exist, but oob data will be appended to ops.datbuf */
50 ops.len = nand->writesize;
51 ops.ooblen = nand->oobsize;
52 ops.mode = MTD_OOB_RAW;
53 i = nand->read_oob(nand, addr, &ops);
55 printf("Error (%d) reading page %08lx\n", i, off);
60 printf("Page %08lx dump:\n", off);
61 i = nand->writesize >> 4;
66 printf("\t%02x %02x %02x %02x %02x %02x %02x %02x"
67 " %02x %02x %02x %02x %02x %02x %02x %02x\n",
68 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7],
69 p[8], p[9], p[10], p[11], p[12], p[13], p[14],
74 i = nand->oobsize >> 3;
76 printf("\t%02x %02x %02x %02x %02x %02x %02x %02x\n",
77 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]);
86 /* ------------------------------------------------------------------------- */
88 static inline int str2long(char *p, ulong *num)
92 *num = simple_strtoul(p, &endptr, 16);
93 return (*p != '\0' && *endptr == '\0') ? 1 : 0;
97 arg_off_size(int argc, char * const argv[], nand_info_t *nand, ulong *off, size_t *size)
99 int idx = nand_curr_device;
100 #if defined(CONFIG_CMD_MTDPARTS)
101 struct mtd_device *dev;
102 struct part_info *part;
105 if (argc >= 1 && !(str2long(argv[0], off))) {
106 if ((mtdparts_init() == 0) &&
107 (find_dev_and_part(argv[0], &dev, &pnum, &part) == 0)) {
108 if (dev->id->type != MTD_DEV_TYPE_NAND) {
109 puts("not a NAND device\n");
114 if (!(str2long(argv[1], (ulong *)size))) {
115 printf("'%s' is not a number\n", argv[1]);
118 if (*size > part->size)
124 *nand = nand_info[idx];
131 if (!(str2long(argv[0], off))) {
132 printf("'%s' is not a number\n", argv[0]);
140 if (!(str2long(argv[1], (ulong *)size))) {
141 printf("'%s' is not a number\n", argv[1]);
145 *size = nand->size - *off;
148 #if defined(CONFIG_CMD_MTDPARTS)
151 printf("device %d ", idx);
152 if (*size == nand->size)
153 puts("whole chip\n");
155 printf("offset 0x%lx, size 0x%zx\n", *off, *size);
159 #ifdef CONFIG_CMD_NAND_LOCK_UNLOCK
160 static void print_status(ulong start, ulong end, ulong erasesize, int status)
162 printf("%08lx - %08lx: %08lx blocks %s%s%s\n",
165 (end - start) / erasesize,
166 ((status & NAND_LOCK_STATUS_TIGHT) ? "TIGHT " : ""),
167 ((status & NAND_LOCK_STATUS_LOCK) ? "LOCK " : ""),
168 ((status & NAND_LOCK_STATUS_UNLOCK) ? "UNLOCK " : ""));
171 static void do_nand_status(nand_info_t *nand)
173 ulong block_start = 0;
175 int last_status = -1;
177 struct nand_chip *nand_chip = nand->priv;
178 /* check the WP bit */
179 nand_chip->cmdfunc(nand, NAND_CMD_STATUS, -1, -1);
180 printf("device is %swrite protected\n",
181 (nand_chip->read_byte(nand) & 0x80 ?
184 for (off = 0; off < nand->size; off += nand->erasesize) {
185 int s = nand_get_lock_status(nand, off);
187 /* print message only if status has changed */
188 if (s != last_status && off != 0) {
189 print_status(block_start, off, nand->erasesize,
195 /* Print the last block info */
196 print_status(block_start, off, nand->erasesize, last_status);
200 #ifdef CONFIG_ENV_OFFSET_OOB
201 unsigned long nand_env_oob_offset;
203 int do_nand_env_oob(cmd_tbl_t *cmdtp, nand_info_t *nand,
204 int argc, char * const argv[])
207 uint32_t oob_buf[ENV_OFFSET_SIZE/sizeof(uint32_t)];
211 if (!strcmp(cmd, "get")) {
212 ret = get_nand_env_oob(nand, &nand_env_oob_offset);
214 printf("0x%08lx\n", nand_env_oob_offset);
217 } else if (!strcmp(cmd, "set")) {
220 struct mtd_oob_ops ops;
225 if (arg_off_size(argc-2, argv + 2, nand, &addr,
227 printf("Offset or partition name expected\n");
231 if (nand->oobavail < ENV_OFFSET_SIZE) {
232 printf("Insufficient available OOB bytes: %d OOB bytes"
233 " available but %d required for env.oob support\n",
239 if ((addr & (nand->erasesize - 1)) != 0) {
240 printf("Environment offset must be block-aligned\n");
245 ops.mode = MTD_OOB_AUTO;
247 ops.ooblen = ENV_OFFSET_SIZE;
248 ops.oobbuf = (void *) oob_buf;
250 oob_buf[0] = ENV_OOB_MARKER;
251 oob_buf[1] = addr / nand->erasesize;
253 ret = nand->write_oob(nand, ENV_OFFSET_SIZE, &ops);
255 ret = get_nand_env_oob(nand, &nand_env_oob_offset);
257 printf("Error reading env offset in OOB\n");
261 if (addr != nand_env_oob_offset) {
262 printf("Verification of env offset in OOB "
263 "failed: 0x%08lx expected but got "
264 "0x%08lx\n", addr, nand_env_oob_offset);
268 printf("Error writing OOB block 0\n");
284 static void nand_print_info(int idx)
286 nand_info_t *nand = &nand_info[idx];
287 struct nand_chip *chip = nand->priv;
288 printf("Device %d: ", idx);
289 if (chip->numchips > 1)
290 printf("%dx ", chip->numchips);
291 printf("%s, sector size %u KiB\n",
292 nand->name, nand->erasesize >> 10);
295 int do_nand(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
302 #ifdef CONFIG_SYS_NAND_QUIET
303 int quiet = CONFIG_SYS_NAND_QUIET;
307 const char *quiet_str = getenv("quiet");
309 /* at least two arguments please */
314 quiet = simple_strtoul(quiet_str, NULL, 0) != 0;
318 if (strcmp(cmd, "info") == 0) {
321 for (i = 0; i < CONFIG_SYS_MAX_NAND_DEVICE; i++) {
322 if (nand_info[i].name)
328 if (strcmp(cmd, "device") == 0) {
332 if ((nand_curr_device < 0) ||
333 (nand_curr_device >= CONFIG_SYS_MAX_NAND_DEVICE))
334 puts("no devices available\n");
336 nand_print_info(nand_curr_device);
339 dev = (int)simple_strtoul(argv[2], NULL, 10);
340 if (dev < 0 || dev >= CONFIG_SYS_MAX_NAND_DEVICE || !nand_info[dev].name) {
341 puts("No such device\n");
344 printf("Device %d: %s", dev, nand_info[dev].name);
345 puts("... is now current device\n");
346 nand_curr_device = dev;
348 #ifdef CONFIG_SYS_NAND_SELECT_DEVICE
350 * Select the chip in the board/cpu specific driver
352 board_nand_select_device(nand_info[dev].priv, dev);
358 if (strcmp(cmd, "bad") != 0 && strcmp(cmd, "erase") != 0 &&
359 strncmp(cmd, "dump", 4) != 0 &&
360 strncmp(cmd, "read", 4) != 0 && strncmp(cmd, "write", 5) != 0 &&
361 strcmp(cmd, "scrub") != 0 && strcmp(cmd, "markbad") != 0 &&
362 strcmp(cmd, "biterr") != 0 &&
363 strcmp(cmd, "lock") != 0 && strcmp(cmd, "unlock") != 0
364 #ifdef CONFIG_ENV_OFFSET_OOB
365 && strcmp(cmd, "env.oob") != 0
370 #ifdef CONFIG_ENV_OFFSET_OOB
371 /* this command operates only on the first nand device */
372 if (strcmp(cmd, "env.oob") == 0)
373 return do_nand_env_oob(cmdtp, &nand_info[0], argc - 1, argv + 1);
376 /* the following commands operate on the current device */
377 if (nand_curr_device < 0 || nand_curr_device >= CONFIG_SYS_MAX_NAND_DEVICE ||
378 !nand_info[nand_curr_device].name) {
379 puts("\nno devices available\n");
382 nand = &nand_info[nand_curr_device];
384 if (strcmp(cmd, "bad") == 0) {
385 printf("\nDevice %d bad blocks:\n", nand_curr_device);
386 for (off = 0; off < nand->size; off += nand->erasesize)
387 if (nand_block_isbad(nand, off))
388 printf(" %08lx\n", off);
395 * nand erase [clean] [off size]
397 if (strcmp(cmd, "erase") == 0 || strcmp(cmd, "scrub") == 0) {
398 nand_erase_options_t opts;
399 /* "clean" at index 2 means request to write cleanmarker */
400 int clean = argc > 2 && !strcmp("clean", argv[2]);
401 int o = clean ? 3 : 2;
402 int scrub = !strcmp(cmd, "scrub");
404 printf("\nNAND %s: ", scrub ? "scrub" : "erase");
405 /* skip first two or three arguments, look for offset and size */
406 if (arg_off_size(argc - o, argv + o, nand, &off, &size) != 0)
409 memset(&opts, 0, sizeof(opts));
417 "scrub option will erase all factory set "
420 "There is no reliable way to recover them.\n"
422 "Use this command only for testing purposes "
425 "are sure of what you are doing!\n"
426 "\nReally scrub this NAND flash? <y/N>\n");
433 puts("scrub aborted\n");
437 puts("scrub aborted\n");
441 ret = nand_erase_opts(nand, &opts);
442 printf("%s\n", ret ? "ERROR" : "OK");
444 return ret == 0 ? 0 : 1;
447 if (strncmp(cmd, "dump", 4) == 0) {
451 s = strchr(cmd, '.');
452 off = (int)simple_strtoul(argv[2], NULL, 16);
454 if (s != NULL && strcmp(s, ".oob") == 0)
455 ret = nand_dump(nand, off, 1);
457 ret = nand_dump(nand, off, 0);
459 return ret == 0 ? 1 : 0;
463 if (strncmp(cmd, "read", 4) == 0 || strncmp(cmd, "write", 5) == 0) {
469 addr = (ulong)simple_strtoul(argv[2], NULL, 16);
471 read = strncmp(cmd, "read", 4) == 0; /* 1 = read, 0 = write */
472 printf("\nNAND %s: ", read ? "read" : "write");
473 if (arg_off_size(argc - 3, argv + 3, nand, &off, &size) != 0)
476 s = strchr(cmd, '.');
477 if (!s || !strcmp(s, ".jffs2") ||
478 !strcmp(s, ".e") || !strcmp(s, ".i")) {
480 ret = nand_read_skip_bad(nand, off, &size,
483 ret = nand_write_skip_bad(nand, off, &size,
485 } else if (!strcmp(s, ".oob")) {
486 /* out-of-band data */
487 mtd_oob_ops_t ops = {
488 .oobbuf = (u8 *)addr,
494 ret = nand->read_oob(nand, off, &ops);
496 ret = nand->write_oob(nand, off, &ops);
498 printf("Unknown nand command suffix '%s'.\n", s);
502 printf(" %zu bytes %s: %s\n", size,
503 read ? "read" : "written", ret ? "ERROR" : "OK");
505 return ret == 0 ? 0 : 1;
508 if (strcmp(cmd, "markbad") == 0) {
516 addr = simple_strtoul(*argv, NULL, 16);
518 if (nand->block_markbad(nand, addr)) {
519 printf("block 0x%08lx NOT marked "
520 "as bad! ERROR %d\n",
524 printf("block 0x%08lx successfully "
534 if (strcmp(cmd, "biterr") == 0) {
539 #ifdef CONFIG_CMD_NAND_LOCK_UNLOCK
540 if (strcmp(cmd, "lock") == 0) {
544 if (!strcmp("tight", argv[2]))
546 if (!strcmp("status", argv[2]))
550 do_nand_status(nand);
552 if (!nand_lock(nand, tight)) {
553 puts("NAND flash successfully locked\n");
555 puts("Error locking NAND flash\n");
562 if (strcmp(cmd, "unlock") == 0) {
563 if (arg_off_size(argc - 2, argv + 2, nand, &off, &size) < 0)
566 if (!nand_unlock(nand, off, size)) {
567 puts("NAND flash successfully unlocked\n");
569 puts("Error unlocking NAND flash, "
570 "write and erase will probably fail\n");
582 U_BOOT_CMD(nand, CONFIG_SYS_MAXARGS, 1, do_nand,
584 "info - show available NAND devices\n"
585 "nand device [dev] - show or set current device\n"
586 "nand read - addr off|partition size\n"
587 "nand write - addr off|partition size\n"
588 " read/write 'size' bytes starting at offset 'off'\n"
589 " to/from memory address 'addr', skipping bad blocks.\n"
590 "nand erase [clean] [off size] - erase 'size' bytes from\n"
591 " offset 'off' (entire device if not specified)\n"
592 "nand bad - show bad blocks\n"
593 "nand dump[.oob] off - dump page\n"
594 "nand scrub - really clean NAND erasing bad blocks (UNSAFE)\n"
595 "nand markbad off [...] - mark bad block(s) at offset (UNSAFE)\n"
596 "nand biterr off - make a bit error at offset (UNSAFE)"
597 #ifdef CONFIG_CMD_NAND_LOCK_UNLOCK
599 "nand lock [tight] [status]\n"
600 " bring nand to lock state or display locked pages\n"
601 "nand unlock [offset] [size] - unlock section"
603 #ifdef CONFIG_ENV_OFFSET_OOB
605 "nand env.oob - environment offset in OOB of block 0 of"
607 "nand env.oob set off|partition - set enviromnent offset\n"
608 "nand env.oob get - get environment offset"
612 static int nand_load_image(cmd_tbl_t *cmdtp, nand_info_t *nand,
613 ulong offset, ulong addr, char *cmd)
619 #if defined(CONFIG_FIT)
620 const void *fit_hdr = NULL;
623 s = strchr(cmd, '.');
625 (strcmp(s, ".jffs2") && strcmp(s, ".e") && strcmp(s, ".i"))) {
626 printf("Unknown nand load suffix '%s'\n", s);
627 show_boot_progress(-53);
631 printf("\nLoading from %s, offset 0x%lx\n", nand->name, offset);
633 cnt = nand->writesize;
634 r = nand_read_skip_bad(nand, offset, &cnt, (u_char *) addr);
636 puts("** Read error\n");
637 show_boot_progress (-56);
640 show_boot_progress (56);
642 switch (genimg_get_format ((void *)addr)) {
643 case IMAGE_FORMAT_LEGACY:
644 hdr = (image_header_t *)addr;
646 show_boot_progress (57);
647 image_print_contents (hdr);
649 cnt = image_get_image_size (hdr);
651 #if defined(CONFIG_FIT)
652 case IMAGE_FORMAT_FIT:
653 fit_hdr = (const void *)addr;
654 puts ("Fit image detected...\n");
656 cnt = fit_get_size (fit_hdr);
660 show_boot_progress (-57);
661 puts ("** Unknown image type\n");
664 show_boot_progress (57);
666 r = nand_read_skip_bad(nand, offset, &cnt, (u_char *) addr);
668 puts("** Read error\n");
669 show_boot_progress (-58);
672 show_boot_progress (58);
674 #if defined(CONFIG_FIT)
675 /* This cannot be done earlier, we need complete FIT image in RAM first */
676 if (genimg_get_format ((void *)addr) == IMAGE_FORMAT_FIT) {
677 if (!fit_check_format (fit_hdr)) {
678 show_boot_progress (-150);
679 puts ("** Bad FIT image format\n");
682 show_boot_progress (151);
683 fit_print_contents (fit_hdr);
687 /* Loading ok, update default load address */
691 /* Check if we should attempt an auto-start */
692 if (((ep = getenv("autostart")) != NULL) && (strcmp(ep, "yes") == 0)) {
694 extern int do_bootm(cmd_tbl_t *, int, int, char *[]);
697 local_args[1] = NULL;
699 printf("Automatic boot of image at addr 0x%08lx ...\n", addr);
701 do_bootm(cmdtp, 0, 1, local_args);
707 int do_nandboot(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
709 char *boot_device = NULL;
711 ulong addr, offset = 0;
712 #if defined(CONFIG_CMD_MTDPARTS)
713 struct mtd_device *dev;
714 struct part_info *part;
718 char *p = (argc == 2) ? argv[1] : argv[2];
719 if (!(str2long(p, &addr)) && (mtdparts_init() == 0) &&
720 (find_dev_and_part(p, &dev, &pnum, &part) == 0)) {
721 if (dev->id->type != MTD_DEV_TYPE_NAND) {
722 puts("Not a NAND device\n");
728 addr = simple_strtoul(argv[1], NULL, 16);
730 addr = CONFIG_SYS_LOAD_ADDR;
731 return nand_load_image(cmdtp, &nand_info[dev->id->num],
732 part->offset, addr, argv[0]);
737 show_boot_progress(52);
740 addr = CONFIG_SYS_LOAD_ADDR;
741 boot_device = getenv("bootdevice");
744 addr = simple_strtoul(argv[1], NULL, 16);
745 boot_device = getenv("bootdevice");
748 addr = simple_strtoul(argv[1], NULL, 16);
749 boot_device = argv[2];
752 addr = simple_strtoul(argv[1], NULL, 16);
753 boot_device = argv[2];
754 offset = simple_strtoul(argv[3], NULL, 16);
757 #if defined(CONFIG_CMD_MTDPARTS)
761 show_boot_progress(-53);
765 show_boot_progress(53);
767 puts("\n** No boot device **\n");
768 show_boot_progress(-54);
771 show_boot_progress(54);
773 idx = simple_strtoul(boot_device, NULL, 16);
775 if (idx < 0 || idx >= CONFIG_SYS_MAX_NAND_DEVICE || !nand_info[idx].name) {
776 printf("\n** Device %d not available\n", idx);
777 show_boot_progress(-55);
780 show_boot_progress(55);
782 return nand_load_image(cmdtp, &nand_info[idx], offset, addr, argv[0]);
785 U_BOOT_CMD(nboot, 4, 1, do_nandboot,
786 "boot from NAND device",
787 "[partition] | [[[loadAddr] dev] offset]"