?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
dontask.patch
[u-boot-openmoko/mini2440.git] / common / cmd_nand.c
blobc5807f3688e041b2844fcc75f4bb0792de2ca2fe
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 * Added 16-bit nand support
8 * (C) 2004 Texas Instruments
9 */
10
11 #include <common.h>
12
13
14 #ifndef CFG_NAND_LEGACY
15 /*
16 *
17 * New NAND support
18 *
19 */
20 #include <common.h>
21
22 #if defined(CONFIG_CMD_NAND)
23
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_JFFS2) && defined(CONFIG_JFFS2_CMDLINE)
32
33 /* parition handling routines */
34 int mtdparts_init(void);
35 int id_parse(const char *id, const char **ret_id, u8 *dev_type, u8 *dev_num);
36 int find_dev_and_part(const char *id, struct mtd_device **dev,
37 u8 *part_num, struct part_info **part);
38 #endif
39
40 extern nand_info_t nand_info[]; /* info for NAND chips */
41
42 static int nand_dump_oob(nand_info_t *nand, ulong off)
43 {
44 return 0;
45 }
46
47 static int nand_dump(nand_info_t *nand, ulong off)
48 {
49 int i;
50 u_char *buf, *p;
51
52 buf = malloc(nand->oobblock + nand->oobsize);
53 if (!buf) {
54 puts("No memory for page buffer\n");
55 return 1;
56 }
57 off &= ~(nand->oobblock - 1);
58 i = nand_read_raw(nand, buf, off, nand->oobblock, nand->oobsize);
59 if (i < 0) {
60 printf("Error (%d) reading page %08x\n", i, off);
61 free(buf);
62 return 1;
63 }
64 printf("Page %08x dump:\n", off);
65 i = nand->oobblock >> 4; p = buf;
66 while (i--) {
67 printf( "\t%02x %02x %02x %02x %02x %02x %02x %02x"
68 " %02x %02x %02x %02x %02x %02x %02x %02x\n",
69 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7],
70 p[8], p[9], p[10], p[11], p[12], p[13], p[14], p[15]);
71 p += 16;
72 }
73 puts("OOB:\n");
74 i = nand->oobsize >> 3;
75 while (i--) {
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]);
78 p += 8;
79 }
80 free(buf);
81
82 return 0;
83 }
84
85 /* ------------------------------------------------------------------------- */
86
87 static inline int str2long(char *p, ulong *num)
88 {
89 char *endptr;
90
91 *num = simple_strtoul(p, &endptr, 16);
92 return (*p != '\0' && *endptr == '\0') ? 1 : 0;
93 }
94
95 int
96 arg_off_size(int argc, char *argv[], nand_info_t *nand, ulong *off, ulong *size, int net)
97 {
98 int idx = nand_curr_device;
99 #if defined(CONFIG_CMD_JFFS2) && defined(CONFIG_JFFS2_CMDLINE)
100 struct mtd_device *dev;
101 struct part_info *part;
102 u8 pnum;
103
104 if (argc >= 1 && !(str2long(argv[0], off))) {
105 if ((mtdparts_init() == 0) &&
106 (find_dev_and_part(argv[0], &dev, &pnum, &part) == 0)) {
107 if (dev->id->type != MTD_DEV_TYPE_NAND) {
108 puts("not a NAND device\n");
109 return -1;
110 }
111 *off = part->offset;
112 if (argc >= 2) {
113 if (!(str2long(argv[1], size))) {
114 printf("'%s' is not a number\n", argv[1]);
115 return -1;
116 }
117 if (*size > part->size) {
118 if (net)
119 *size = nand_net_part_size(part);
120 else
121 *size = part->size;
122 }
123 } else {
124 if (net)
125 *size = nand_net_part_size(part);
126 else
127 *size = part->size;
128 }
129 idx = dev->id->num;
130 *nand = nand_info[idx];
131 goto out;
132 }
133 }
134 #endif
135
136 if (argc >= 1) {
137 if (!(str2long(argv[0], off))) {
138 printf("'%s' is not a number\n", argv[0]);
139 return -1;
140 }
141 } else {
142 *off = 0;
143 }
144
145 if (argc >= 2) {
146 if (!(str2long(argv[1], size))) {
147 printf("'%s' is not a number\n", argv[1]);
148 return -1;
149 }
150 } else {
151 *size = nand->size - *off;
152 }
153
154 #if defined(CONFIG_CMD_JFFS2) && defined(CONFIG_JFFS2_CMDLINE)
155 out:
156 #endif
157 printf("device %d ", idx);
158 if (*size == nand->size)
159 puts("whole chip\n");
160 else
161 printf("offset 0x%x, size 0x%x\n", *off, *size);
162 return 0;
163 }
164
165 static int yes(void)
166 {
167 char *s;
168 char c;
169
170 s = getenv("dontask");
171 if (s && (s[0] =='y' || s[0] == 'Y') && !s[1])
172 return 1;
173 c = getc();
174 if (c != 'y' && c != 'Y')
175 return 0;
176 c = getc();
177 return c == '\r' || c == '\n';
178 }
179
180 int do_nand(cmd_tbl_t * cmdtp, int flag, int argc, char *argv[])
181 {
182 int i, dev, ret;
183 ulong addr, off, size;
184 char *cmd, *s;
185 nand_info_t *nand;
186 #ifdef CFG_NAND_QUIET
187 int quiet = CFG_NAND_QUIET;
188 #else
189 int quiet = 0;
190 #endif
191 const char *quiet_str = getenv("quiet");
192
193 /* at least two arguments please */
194 if (argc < 2)
195 goto usage;
196
197 if (quiet_str)
198 quiet = simple_strtoul(quiet_str, NULL, 0) != 0;
199
200 cmd = argv[1];
201
202 if (strcmp(cmd, "info") == 0) {
203
204 putc('\n');
205 for (i = 0; i < CFG_MAX_NAND_DEVICE; i++) {
206 if (nand_info[i].name)
207 printf("Device %d: %s, sector size %lu KiB\n",
208 i, nand_info[i].name,
209 nand_info[i].erasesize >> 10);
210 }
211 return 0;
212 }
213
214 if (strcmp(cmd, "device") == 0) {
215
216 if (argc < 3) {
217 if ((nand_curr_device < 0) ||
218 (nand_curr_device >= CFG_MAX_NAND_DEVICE))
219 puts("\nno devices available\n");
220 else
221 printf("\nDevice %d: %s\n", nand_curr_device,
222 nand_info[nand_curr_device].name);
223 return 0;
224 }
225 dev = (int)simple_strtoul(argv[2], NULL, 10);
226 if (dev < 0 || dev >= CFG_MAX_NAND_DEVICE || !nand_info[dev].name) {
227 puts("No such device\n");
228 return 1;
229 }
230 printf("Device %d: %s", dev, nand_info[dev].name);
231 puts("... is now current device\n");
232 nand_curr_device = dev;
233
234 #ifdef CFG_NAND_SELECT_DEVICE
235 /*
236 * Select the chip in the board/cpu specific driver
237 */
238 board_nand_select_device(nand_info[dev].priv, dev);
239 #endif
240
241 return 0;
242 }
243
244 if (strcmp(cmd, "bad") != 0 && strcmp(cmd, "erase") != 0 &&
245 strncmp(cmd, "dump", 4) != 0 &&
246 strncmp(cmd, "read", 4) != 0 && strncmp(cmd, "write", 5) != 0 &&
247 strcmp(cmd, "scrub") != 0 && strcmp(cmd, "markbad") != 0 &&
248 strcmp(cmd, "biterr") != 0 &&
249 strcmp(cmd, "lock") != 0 && strcmp(cmd, "unlock") != 0 &&
250 strcmp(cmd, "createbbt") != 0 )
251 goto usage;
252
253 /* the following commands operate on the current device */
254 if (nand_curr_device < 0 || nand_curr_device >= CFG_MAX_NAND_DEVICE ||
255 !nand_info[nand_curr_device].name) {
256 puts("\nno devices available\n");
257 return 1;
258 }
259 nand = &nand_info[nand_curr_device];
260
261 if (strcmp(cmd, "bad") == 0) {
262 printf("\nDevice %d bad blocks:\n", nand_curr_device);
263 for (off = 0; off < nand->size; off += nand->erasesize)
264 if (nand_block_isbad(nand, off))
265 printf(" %08x\n", off);
266 return 0;
267 }
268
269 /*
270 * Syntax is:
271 * 0 1 2 3 4
272 * nand erase [clean] [off size]
273 */
274 if (strcmp(cmd, "erase") == 0 || strcmp(cmd, "scrub") == 0) {
275 nand_erase_options_t opts;
276 /* "clean" at index 2 means request to write cleanmarker */
277 int clean = argc > 2 && !strcmp("clean", argv[2]);
278 int o = clean ? 3 : 2;
279 int scrub = !strcmp(cmd, "scrub");
280
281 printf("\nNAND %s: ", scrub ? "scrub" : "erase");
282 /* skip first two or three arguments, look for offset and size */
283 if (arg_off_size(argc - o, argv + o, nand, &off, &size, 0) != 0)
284 return 1;
285
286 memset(&opts, 0, sizeof(opts));
287 opts.offset = off;
288 opts.length = size;
289 opts.jffs2 = clean;
290 opts.quiet = quiet;
291
292 if (scrub) {
293 puts("Warning: "
294 "scrub option will erase all factory set "
295 "bad blocks!\n"
296 " "
297 "There is no reliable way to recover them.\n"
298 " "
299 "Use this command only for testing purposes "
300 "if you\n"
301 " "
302 "are sure of what you are doing!\n"
303 "\nReally scrub this NAND flash? <y/N>\n");
304
305 if (yes()) {
306 opts.scrub = 1;
307 } else {
308 puts("scrub aborted\n");
309 return -1;
310 }
311 }
312 else {
313 if (opts.length == nand->size) {
314 puts("Really erase everything ? <y/N>\n");
315 if (!yes()) {
316 puts("erase aborted\n");
317 return -1;
318 }
319 }
320 }
321
322 ret = nand_erase_opts(nand, &opts);
323 printf("%s\n", ret ? "ERROR" : "OK");
324
325 return ret == 0 ? 0 : 1;
326 }
327
328 if (strncmp(cmd, "dump", 4) == 0) {
329 if (argc < 3)
330 goto usage;
331
332 s = strchr(cmd, '.');
333 off = (int)simple_strtoul(argv[2], NULL, 16);
334
335 if (s != NULL && strcmp(s, ".oob") == 0)
336 ret = nand_dump_oob(nand, off);
337 else
338 ret = nand_dump(nand, off);
339
340 return ret == 0 ? 1 : 0;
341
342 }
343
344 /* read write */
345 if (strncmp(cmd, "read", 4) == 0 || strncmp(cmd, "write", 5) == 0) {
346 int read;
347
348 if (argc < 4)
349 goto usage;
350
351 addr = (ulong)simple_strtoul(argv[2], NULL, 16);
352
353 read = strncmp(cmd, "read", 4) == 0; /* 1 = read, 0 = write */
354 printf("\nNAND %s: ", read ? "read" : "write");
355 if (arg_off_size(argc - 3, argv + 3, nand, &off, &size, 1) != 0)
356 return 1;
357
358 s = strchr(cmd, '.');
359 if (s != NULL &&
360 (!strcmp(s, ".jffs2") || !strcmp(s, ".e") || !strcmp(s, ".i"))) {
361 if (read) {
362 /* read */
363 nand_read_options_t opts;
364 memset(&opts, 0, sizeof(opts));
365 opts.buffer = (u_char*) addr;
366 opts.length = size;
367 opts.offset = off;
368 opts.quiet = quiet;
369 ret = nand_read_opts(nand, &opts);
370 } else {
371 /* write */
372 nand_write_options_t opts;
373 memset(&opts, 0, sizeof(opts));
374 opts.buffer = (u_char*) addr;
375 opts.length = size;
376 opts.offset = off;
377 /* opts.forcejffs2 = 1; */
378 opts.pad = 1;
379 opts.blockalign = 1;
380 opts.quiet = quiet;
381 ret = nand_write_opts(nand, &opts);
382 }
383 } else if (s != NULL && !strcmp(s, ".oob")) {
384 /* read out-of-band data */
385 if (read)
386 ret = nand->read_oob(nand, off, size, (size_t *) &size,
387 (u_char *) addr);
388 else
389 ret = nand->write_oob(nand, off, size, (size_t *) &size,
390 (u_char *) addr);
391 } else {
392 if (read)
393 ret = nand_read(nand, off, &size, (u_char *)addr);
394 else
395 ret = nand_write(nand, off, &size, (u_char *)addr);
396 }
397
398 printf(" %d bytes %s: %s\n", size,
399 read ? "read" : "written", ret ? "ERROR" : "OK");
400
401 return ret == 0 ? 0 : 1;
402 }
403
404 if (strcmp(cmd, "markbad") == 0) {
405 addr = (ulong)simple_strtoul(argv[2], NULL, 16);
406
407 int ret = nand->block_markbad(nand, addr);
408 if (ret == 0) {
409 printf("block 0x%08lx successfully marked as bad\n",
410 (ulong) addr);
411 return 0;
412 } else {
413 printf("block 0x%08lx NOT marked as bad! ERROR %d\n",
414 (ulong) addr, ret);
415 }
416 return 1;
417 }
418 if (strcmp(cmd, "biterr") == 0) {
419 /* todo */
420 return 1;
421 }
422
423 if (strcmp(cmd, "lock") == 0) {
424 int tight = 0;
425 int status = 0;
426 if (argc == 3) {
427 if (!strcmp("tight", argv[2]))
428 tight = 1;
429 if (!strcmp("status", argv[2]))
430 status = 1;
431 }
432
433 if (status) {
434 ulong block_start = 0;
435 ulong off;
436 int last_status = -1;
437
438 struct nand_chip *nand_chip = nand->priv;
439 /* check the WP bit */
440 nand_chip->cmdfunc (nand, NAND_CMD_STATUS, -1, -1);
441 printf("device is %swrite protected\n",
442 (nand_chip->read_byte(nand) & 0x80 ?
443 "NOT " : "" ) );
444
445 for (off = 0; off < nand->size; off += nand->oobblock) {
446 int s = nand_get_lock_status(nand, off);
447
448 /* print message only if status has changed
449 * or at end of chip
450 */
451 if (off == nand->size - nand->oobblock
452 || (s != last_status && off != 0)) {
453
454 printf("%08x - %08x: %8d pages %s%s%s\n",
455 block_start,
456 off-1,
457 (off-block_start)/nand->oobblock,
458 ((last_status & NAND_LOCK_STATUS_TIGHT) ? "TIGHT " : ""),
459 ((last_status & NAND_LOCK_STATUS_LOCK) ? "LOCK " : ""),
460 ((last_status & NAND_LOCK_STATUS_UNLOCK) ? "UNLOCK " : ""));
461 }
462
463 last_status = s;
464 }
465 } else {
466 if (!nand_lock(nand, tight)) {
467 puts("NAND flash successfully locked\n");
468 } else {
469 puts("Error locking NAND flash\n");
470 return 1;
471 }
472 }
473 return 0;
474 }
475
476 if (strcmp(cmd, "unlock") == 0) {
477 if (arg_off_size(argc - 2, argv + 2, nand, &off, &size, 0) < 0)
478 return 1;
479
480 if (!nand_unlock(nand, off, size)) {
481 puts("NAND flash successfully unlocked\n");
482 } else {
483 puts("Error unlocking NAND flash, "
484 "write and erase will probably fail\n");
485 return 1;
486 }
487 return 0;
488 }
489
490 if (strcmp(cmd, "createbbt") == 0) {
491 struct nand_chip *nand_chip = nand->priv;
492 nand_erase_options_t opts;
493
494 puts("Create BBT and erase everything ? <y/N>\n");
495 if (!yes()) {
496 puts("createbbt aborted\n");
497 return -1;
498 }
499 memset(&opts, 0, sizeof(opts));
500 opts.length = nand->size;
501 if (nand_erase_opts(nand, &opts)) {
502 puts("Erase failed\n");
503 return 1;
504 }
505 nand_chip->options &= ~NAND_DONT_CREATE_BBT;
506 puts("Creating BBT. Please wait ...");
507 if (nand_default_bbt(nand)) {
508 puts("\nFailed\n");
509 return 1;
510 }
511 else {
512 puts("\n");
513 return 0;
514 }
515 }
516
517 usage:
518 printf("Usage:\n%s\n", cmdtp->usage);
519 return 1;
520 }
521
522 U_BOOT_CMD(nand, 5, 1, do_nand,
523 "nand - NAND sub-system\n",
524 "info - show available NAND devices\n"
525 "nand device [dev] - show or set current device\n"
526 "nand read[.jffs2] - addr off|partition size\n"
527 "nand write[.jffs2] - addr off|partition size - read/write `size' bytes starting\n"
528 " at offset `off' to/from memory address `addr'\n"
529 "nand erase [clean] [off size] - erase `size' bytes from\n"
530 " offset `off' (entire device if not specified)\n"
531 "nand bad - show bad blocks\n"
532 "nand dump[.oob] off - dump page\n"
533 "nand scrub - really clean NAND erasing bad blocks (UNSAFE)\n"
534 "nand markbad off - mark bad block at offset (UNSAFE)\n"
535 "nand biterr off - make a bit error at offset (UNSAFE)\n"
536 "nand lock [tight] [status] - bring nand to lock state or display locked pages\n"
537 "nand unlock [offset] [size] - unlock section\n"
538 "nand createbbt - create bad block table\n");
539
540 static int nand_load_image(cmd_tbl_t *cmdtp, nand_info_t *nand,
541 ulong offset, ulong addr, char *cmd)
542 {
543 int r;
544 char *ep, *s;
545 ulong cnt;
546 image_header_t *hdr;
547 int jffs2 = 0;
548 #if defined(CONFIG_FIT)
549 const void *fit_hdr;
550 #endif
551
552 s = strchr(cmd, '.');
553 if (s != NULL &&
554 (!strcmp(s, ".jffs2") || !strcmp(s, ".e") || !strcmp(s, ".i")))
555 jffs2 = 1;
556
557 printf("\nLoading from %s, offset 0x%lx\n", nand->name, offset);
558
559 cnt = nand->oobblock;
560 if (jffs2) {
561 nand_read_options_t opts;
562 memset(&opts, 0, sizeof(opts));
563 opts.buffer = (u_char*) addr;
564 opts.length = cnt;
565 opts.offset = offset;
566 opts.quiet = 1;
567 r = nand_read_opts(nand, &opts);
568 } else {
569 r = nand_read(nand, offset, &cnt, (u_char *) addr);
570 }
571
572 if (r) {
573 puts("** Read error\n");
574 show_boot_progress (-56);
575 return 1;
576 }
577 show_boot_progress (56);
578
579 switch (genimg_get_format ((void *)addr)) {
580 case IMAGE_FORMAT_LEGACY:
581 hdr = (image_header_t *)addr;
582
583 show_boot_progress (57);
584 image_print_contents (hdr);
585
586 cnt = image_get_image_size (hdr);
587 break;
588 #if defined(CONFIG_FIT)
589 case IMAGE_FORMAT_FIT:
590 fit_hdr = (const void *)addr;
591 if (!fit_check_format (fit_hdr)) {
592 show_boot_progress (-150);
593 puts ("** Bad FIT image format\n");
594 return 1;
595 }
596 show_boot_progress (151);
597 puts ("Fit image detected...\n");
598
599 cnt = fit_get_size (fit_hdr);
600 break;
601 #endif
602 default:
603 show_boot_progress (-57);
604 puts ("** Unknown image type\n");
605 return 1;
606 }
607
608 if (jffs2) {
609 nand_read_options_t opts;
610 memset(&opts, 0, sizeof(opts));
611 opts.buffer = (u_char*) addr;
612 opts.length = cnt;
613 opts.offset = offset;
614 opts.quiet = 1;
615 r = nand_read_opts(nand, &opts);
616 } else {
617 r = nand_read(nand, offset, &cnt, (u_char *) addr);
618 }
619
620 if (r) {
621 puts("** Read error\n");
622 show_boot_progress (-58);
623 return 1;
624 }
625 show_boot_progress (58);
626
627 #if defined(CONFIG_FIT)
628 /* This cannot be done earlier, we need complete FIT image in RAM first */
629 if (genimg_get_format ((void *)addr) == IMAGE_FORMAT_FIT)
630 fit_print_contents ((const void *)addr);
631 #endif
632
633 /* Loading ok, update default load address */
634
635 load_addr = addr;
636
637 /* Check if we should attempt an auto-start */
638 if (((ep = getenv("autostart")) != NULL) && (strcmp(ep, "yes") == 0)) {
639 char *local_args[2];
640 extern int do_bootm(cmd_tbl_t *, int, int, char *[]);
641
642 local_args[0] = cmd;
643 local_args[1] = NULL;
644
645 printf("Automatic boot of image at addr 0x%08lx ...\n", addr);
646
647 do_bootm(cmdtp, 0, 1, local_args);
648 return 1;
649 }
650 return 0;
651 }
652
653 int do_nandboot(cmd_tbl_t * cmdtp, int flag, int argc, char *argv[])
654 {
655 char *boot_device = NULL;
656 int idx;
657 ulong addr, offset = 0;
658 #if defined(CONFIG_CMD_JFFS2) && defined(CONFIG_JFFS2_CMDLINE)
659 struct mtd_device *dev;
660 struct part_info *part;
661 u8 pnum;
662
663 if (argc >= 2) {
664 char *p = (argc == 2) ? argv[1] : argv[2];
665 if (!(str2long(p, &addr)) && (mtdparts_init() == 0) &&
666 (find_dev_and_part(p, &dev, &pnum, &part) == 0)) {
667 if (dev->id->type != MTD_DEV_TYPE_NAND) {
668 puts("Not a NAND device\n");
669 return 1;
670 }
671 if (argc > 3)
672 goto usage;
673 if (argc == 3)
674 addr = simple_strtoul(argv[1], NULL, 16);
675 else
676 addr = CFG_LOAD_ADDR;
677 return nand_load_image(cmdtp, &nand_info[dev->id->num],
678 part->offset, addr, argv[0]);
679 }
680 }
681 #endif
682
683 show_boot_progress(52);
684 switch (argc) {
685 case 1:
686 addr = CFG_LOAD_ADDR;
687 boot_device = getenv("bootdevice");
688 break;
689 case 2:
690 addr = simple_strtoul(argv[1], NULL, 16);
691 boot_device = getenv("bootdevice");
692 break;
693 case 3:
694 addr = simple_strtoul(argv[1], NULL, 16);
695 boot_device = argv[2];
696 break;
697 case 4:
698 addr = simple_strtoul(argv[1], NULL, 16);
699 boot_device = argv[2];
700 offset = simple_strtoul(argv[3], NULL, 16);
701 break;
702 default:
703 #if defined(CONFIG_CMD_JFFS2) && defined(CONFIG_JFFS2_CMDLINE)
704 usage:
705 #endif
706 printf("Usage:\n%s\n", cmdtp->usage);
707 show_boot_progress(-53);
708 return 1;
709 }
710
711 show_boot_progress(53);
712 if (!boot_device) {
713 puts("\n** No boot device **\n");
714 show_boot_progress(-54);
715 return 1;
716 }
717 show_boot_progress(54);
718
719 idx = simple_strtoul(boot_device, NULL, 16);
720
721 if (idx < 0 || idx >= CFG_MAX_NAND_DEVICE || !nand_info[idx].name) {
722 printf("\n** Device %d not available\n", idx);
723 show_boot_progress(-55);
724 return 1;
725 }
726 show_boot_progress(55);
727
728 return nand_load_image(cmdtp, &nand_info[idx], offset, addr, argv[0]);
729 }
730
731 U_BOOT_CMD(nboot, 4, 1, do_nandboot,
732 "nboot - boot from NAND device\n",
733 "[.jffs2] [partition] | [[[loadAddr] dev] offset]\n");
734
735 #endif
736
737 #else /* CFG_NAND_LEGACY */
738 /*
739 *
740 * Legacy NAND support - to be phased out
741 *
742 */
743 #include <command.h>
744 #include <malloc.h>
745 #include <asm/io.h>
746 #include <watchdog.h>
747
748 #ifdef CONFIG_show_boot_progress
749 # include <status_led.h>
750 # define show_boot_progress(arg) show_boot_progress(arg)
751 #else
752 # define show_boot_progress(arg)
753 #endif
754
755 #if defined(CONFIG_CMD_NAND)
756 #include <linux/mtd/nand_legacy.h>
757 #if 0
758 #include <linux/mtd/nand_ids.h>
759 #include <jffs2/jffs2.h>
760 #endif
761
762 #ifdef CONFIG_OMAP1510
763 void archflashwp(void *archdata, int wp);
764 #endif
765
766 #define ROUND_DOWN(value,boundary) ((value) & (~((boundary)-1)))
767
768 #undef NAND_DEBUG
769 #undef PSYCHO_DEBUG
770
771 /* ****************** WARNING *********************
772 * When ALLOW_ERASE_BAD_DEBUG is non-zero the erase command will
773 * erase (or at least attempt to erase) blocks that are marked
774 * bad. This can be very handy if you are _sure_ that the block
775 * is OK, say because you marked a good block bad to test bad
776 * block handling and you are done testing, or if you have
777 * accidentally marked blocks bad.
778 *
779 * Erasing factory marked bad blocks is a _bad_ idea. If the
780 * erase succeeds there is no reliable way to find them again,
781 * and attempting to program or erase bad blocks can affect
782 * the data in _other_ (good) blocks.
783 */
784 #define ALLOW_ERASE_BAD_DEBUG 0
785
786 #define CONFIG_MTD_NAND_ECC /* enable ECC */
787 #define CONFIG_MTD_NAND_ECC_JFFS2
788
789 /* bits for nand_legacy_rw() `cmd'; or together as needed */
790 #define NANDRW_READ 0x01
791 #define NANDRW_WRITE 0x00
792 #define NANDRW_JFFS2 0x02
793 #define NANDRW_JFFS2_SKIP 0x04
794
795 /*
796 * Imports from nand_legacy.c
797 */
798 extern struct nand_chip nand_dev_desc[CFG_MAX_NAND_DEVICE];
799 extern int curr_device;
800 extern int nand_legacy_erase(struct nand_chip *nand, size_t ofs,
801 size_t len, int clean);
802 extern int nand_legacy_rw(struct nand_chip *nand, int cmd, size_t start,
803 size_t len, size_t *retlen, u_char *buf);
804 extern void nand_print(struct nand_chip *nand);
805 extern void nand_print_bad(struct nand_chip *nand);
806 extern int nand_read_oob(struct nand_chip *nand, size_t ofs,
807 size_t len, size_t *retlen, u_char *buf);
808 extern int nand_write_oob(struct nand_chip *nand, size_t ofs,
809 size_t len, size_t *retlen, const u_char *buf);
810
811
812 int do_nand (cmd_tbl_t * cmdtp, int flag, int argc, char *argv[])
813 {
814 int rcode = 0;
815
816 switch (argc) {
817 case 0:
818 case 1:
819 printf ("Usage:\n%s\n", cmdtp->usage);
820 return 1;
821 case 2:
822 if (strcmp (argv[1], "info") == 0) {
823 int i;
824
825 putc ('\n');
826
827 for (i = 0; i < CFG_MAX_NAND_DEVICE; ++i) {
828 if (nand_dev_desc[i].ChipID ==
829 NAND_ChipID_UNKNOWN)
830 continue; /* list only known devices */
831 printf ("Device %d: ", i);
832 nand_print (&nand_dev_desc[i]);
833 }
834 return 0;
835
836 } else if (strcmp (argv[1], "device") == 0) {
837 if ((curr_device < 0)
838 || (curr_device >= CFG_MAX_NAND_DEVICE)) {
839 puts ("\nno devices available\n");
840 return 1;
841 }
842 printf ("\nDevice %d: ", curr_device);
843 nand_print (&nand_dev_desc[curr_device]);
844 return 0;
845
846 } else if (strcmp (argv[1], "bad") == 0) {
847 if ((curr_device < 0)
848 || (curr_device >= CFG_MAX_NAND_DEVICE)) {
849 puts ("\nno devices available\n");
850 return 1;
851 }
852 printf ("\nDevice %d bad blocks:\n", curr_device);
853 nand_print_bad (&nand_dev_desc[curr_device]);
854 return 0;
855
856 }
857 printf ("Usage:\n%s\n", cmdtp->usage);
858 return 1;
859 case 3:
860 if (strcmp (argv[1], "device") == 0) {
861 int dev = (int) simple_strtoul (argv[2], NULL, 10);
862
863 printf ("\nDevice %d: ", dev);
864 if (dev >= CFG_MAX_NAND_DEVICE) {
865 puts ("unknown device\n");
866 return 1;
867 }
868 nand_print (&nand_dev_desc[dev]);
869 /*nand_print (dev); */
870
871 if (nand_dev_desc[dev].ChipID == NAND_ChipID_UNKNOWN) {
872 return 1;
873 }
874
875 curr_device = dev;
876
877 puts ("... is now current device\n");
878
879 return 0;
880 } else if (strcmp (argv[1], "erase") == 0
881 && strcmp (argv[2], "clean") == 0) {
882 struct nand_chip *nand = &nand_dev_desc[curr_device];
883 ulong off = 0;
884 ulong size = nand->totlen;
885 int ret;
886
887 printf ("\nNAND erase: device %d offset %ld, size %ld ... ", curr_device, off, size);
888
889 ret = nand_legacy_erase (nand, off, size, 1);
890
891 printf ("%s\n", ret ? "ERROR" : "OK");
892
893 return ret;
894 }
895
896 printf ("Usage:\n%s\n", cmdtp->usage);
897 return 1;
898 default:
899 /* at least 4 args */
900
901 if (strncmp (argv[1], "read", 4) == 0 ||
902 strncmp (argv[1], "write", 5) == 0) {
903 ulong addr = simple_strtoul (argv[2], NULL, 16);
904 ulong off = simple_strtoul (argv[3], NULL, 16);
905 ulong size = simple_strtoul (argv[4], NULL, 16);
906 int cmd = (strncmp (argv[1], "read", 4) == 0) ?
907 NANDRW_READ : NANDRW_WRITE;
908 int ret, total;
909 char *cmdtail = strchr (argv[1], '.');
910
911 if (cmdtail && !strncmp (cmdtail, ".oob", 2)) {
912 /* read out-of-band data */
913 if (cmd & NANDRW_READ) {
914 ret = nand_read_oob (nand_dev_desc + curr_device,
915 off, size, (size_t *) & total,
916 (u_char *) addr);
917 } else {
918 ret = nand_write_oob (nand_dev_desc + curr_device,
919 off, size, (size_t *) & total,
920 (u_char *) addr);
921 }
922 return ret;
923 } else if (cmdtail && !strncmp (cmdtail, ".jffs2", 2))
924 cmd |= NANDRW_JFFS2; /* skip bad blocks */
925 else if (cmdtail && !strncmp (cmdtail, ".jffs2s", 2)) {
926 cmd |= NANDRW_JFFS2; /* skip bad blocks (on read too) */
927 if (cmd & NANDRW_READ)
928 cmd |= NANDRW_JFFS2_SKIP; /* skip bad blocks (on read too) */
929 }
930 #ifdef SXNI855T
931 /* need ".e" same as ".j" for compatibility with older units */
932 else if (cmdtail && !strcmp (cmdtail, ".e"))
933 cmd |= NANDRW_JFFS2; /* skip bad blocks */
934 #endif
935 #ifdef CFG_NAND_SKIP_BAD_DOT_I
936 /* need ".i" same as ".jffs2s" for compatibility with older units (esd) */
937 /* ".i" for image -> read skips bad block (no 0xff) */
938 else if (cmdtail && !strcmp (cmdtail, ".i")) {
939 cmd |= NANDRW_JFFS2; /* skip bad blocks (on read too) */
940 if (cmd & NANDRW_READ)
941 cmd |= NANDRW_JFFS2_SKIP; /* skip bad blocks (on read too) */
942 }
943 #endif /* CFG_NAND_SKIP_BAD_DOT_I */
944 else if (cmdtail) {
945 printf ("Usage:\n%s\n", cmdtp->usage);
946 return 1;
947 }
948
949 printf ("\nNAND %s: device %d offset %ld, size %ld ...\n",
950 (cmd & NANDRW_READ) ? "read" : "write",
951 curr_device, off, size);
952
953 ret = nand_legacy_rw (nand_dev_desc + curr_device,
954 cmd, off, size,
955 (size_t *) & total,
956 (u_char *) addr);
957
958 printf (" %d bytes %s: %s\n", total,
959 (cmd & NANDRW_READ) ? "read" : "written",
960 ret ? "ERROR" : "OK");
961
962 return ret;
963 } else if (strcmp (argv[1], "erase") == 0 &&
964 (argc == 4 || strcmp ("clean", argv[2]) == 0)) {
965 int clean = argc == 5;
966 ulong off =
967 simple_strtoul (argv[2 + clean], NULL, 16);
968 ulong size =
969 simple_strtoul (argv[3 + clean], NULL, 16);
970 int ret;
971
972 printf ("\nNAND erase: device %d offset %ld, size %ld ...\n",
973 curr_device, off, size);
974
975 ret = nand_legacy_erase (nand_dev_desc + curr_device,
976 off, size, clean);
977
978 printf ("%s\n", ret ? "ERROR" : "OK");
979
980 return ret;
981 } else {
982 printf ("Usage:\n%s\n", cmdtp->usage);
983 rcode = 1;
984 }
985
986 return rcode;
987 }
988 }
989
990 U_BOOT_CMD(
991 nand, 5, 1, do_nand,
992 "nand - legacy NAND sub-system\n",
993 "info - show available NAND devices\n"
994 "nand device [dev] - show or set current device\n"
995 "nand read[.jffs2[s]] addr off size\n"
996 "nand write[.jffs2] addr off size - read/write `size' bytes starting\n"
997 " at offset `off' to/from memory address `addr'\n"
998 "nand erase [clean] [off size] - erase `size' bytes from\n"
999 " offset `off' (entire device if not specified)\n"
1000 "nand bad - show bad blocks\n"
1001 "nand read.oob addr off size - read out-of-band data\n"
1002 "nand write.oob addr off size - read out-of-band data\n"
1003 );
1004
1005 int do_nandboot (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
1006 {
1007 char *boot_device = NULL;
1008 char *ep;
1009 int dev;
1010 ulong cnt;
1011 ulong addr;
1012 ulong offset = 0;
1013 image_header_t *hdr;
1014 int rcode = 0;
1015 #if defined(CONFIG_FIT)
1016 const void *fit_hdr;
1017 #endif
1018
1019 show_boot_progress (52);
1020 switch (argc) {
1021 case 1:
1022 addr = CFG_LOAD_ADDR;
1023 boot_device = getenv ("bootdevice");
1024 break;
1025 case 2:
1026 addr = simple_strtoul(argv[1], NULL, 16);
1027 boot_device = getenv ("bootdevice");
1028 break;
1029 case 3:
1030 addr = simple_strtoul(argv[1], NULL, 16);
1031 boot_device = argv[2];
1032 break;
1033 case 4:
1034 addr = simple_strtoul(argv[1], NULL, 16);
1035 boot_device = argv[2];
1036 offset = simple_strtoul(argv[3], NULL, 16);
1037 break;
1038 default:
1039 printf ("Usage:\n%s\n", cmdtp->usage);
1040 show_boot_progress (-53);
1041 return 1;
1042 }
1043
1044 show_boot_progress (53);
1045 if (!boot_device) {
1046 puts ("\n** No boot device **\n");
1047 show_boot_progress (-54);
1048 return 1;
1049 }
1050 show_boot_progress (54);
1051
1052 dev = simple_strtoul(boot_device, &ep, 16);
1053
1054 if ((dev >= CFG_MAX_NAND_DEVICE) ||
1055 (nand_dev_desc[dev].ChipID == NAND_ChipID_UNKNOWN)) {
1056 printf ("\n** Device %d not available\n", dev);
1057 show_boot_progress (-55);
1058 return 1;
1059 }
1060 show_boot_progress (55);
1061
1062 printf ("\nLoading from device %d: %s at 0x%lx (offset 0x%lx)\n",
1063 dev, nand_dev_desc[dev].name, nand_dev_desc[dev].IO_ADDR,
1064 offset);
1065
1066 if (nand_legacy_rw (nand_dev_desc + dev, NANDRW_READ, offset,
1067 SECTORSIZE, NULL, (u_char *)addr)) {
1068 printf ("** Read error on %d\n", dev);
1069 show_boot_progress (-56);
1070 return 1;
1071 }
1072 show_boot_progress (56);
1073
1074 switch (genimg_get_format ((void *)addr)) {
1075 case IMAGE_FORMAT_LEGACY:
1076 hdr = (image_header_t *)addr;
1077 image_print_contents (hdr);
1078
1079 cnt = image_get_image_size (hdr);
1080 cnt -= SECTORSIZE;
1081 break;
1082 #if defined(CONFIG_FIT)
1083 case IMAGE_FORMAT_FIT:
1084 fit_hdr = (const void *)addr;
1085 if (!fit_check_format (fit_hdr)) {
1086 show_boot_progress (-150);
1087 puts ("** Bad FIT image format\n");
1088 return 1;
1089 }
1090 show_boot_progress (151);
1091 puts ("Fit image detected...\n");
1092
1093 cnt = fit_get_size (fit_hdr);
1094 break;
1095 #endif
1096 default:
1097 show_boot_progress (-57);
1098 puts ("** Unknown image type\n");
1099 return 1;
1100 }
1101 show_boot_progress (57);
1102
1103 if (nand_legacy_rw (nand_dev_desc + dev, NANDRW_READ,
1104 offset + SECTORSIZE, cnt, NULL,
1105 (u_char *)(addr+SECTORSIZE))) {
1106 printf ("** Read error on %d\n", dev);
1107 show_boot_progress (-58);
1108 return 1;
1109 }
1110 show_boot_progress (58);
1111
1112 #if defined(CONFIG_FIT)
1113 /* This cannot be done earlier, we need complete FIT image in RAM first */
1114 if (genimg_get_format ((void *)addr) == IMAGE_FORMAT_FIT)
1115 fit_print_contents ((const void *)addr);
1116 #endif
1117
1118 /* Loading ok, update default load address */
1119
1120 load_addr = addr;
1121
1122 /* Check if we should attempt an auto-start */
1123 if (((ep = getenv("autostart")) != NULL) && (strcmp(ep,"yes") == 0)) {
1124 char *local_args[2];
1125 extern int do_bootm (cmd_tbl_t *, int, int, char *[]);
1126
1127 local_args[0] = argv[0];
1128 local_args[1] = NULL;
1129
1130 printf ("Automatic boot of image at addr 0x%08lx ...\n", addr);
1131
1132 do_bootm (cmdtp, 0, 1, local_args);
1133 rcode = 1;
1134 }
1135 return rcode;
1136 }
1137
1138 U_BOOT_CMD(
1139 nboot, 4, 1, do_nandboot,
1140 "nboot - boot from NAND device\n",
1141 "loadAddr dev\n"
1142 );
1143
1144 #endif
1145
1146 #endif /* CFG_NAND_LEGACY */
Fork of the u-boot for for Samsung based MINI2440 board