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