cmd_nand.c.l

嵌入式试验箱S3C2410的bootloader源代码

340                 ret = nand_read_opts(nand, &opts);
341             } else {
342                 /* write */
343                 nand_write_options_t opts;
344                 memset(&opts, 0, sizeof(opts));
345                 opts.buffer = (u_char*) addr;
346                 opts.length = size;
347                 opts.offset = off;
348                 /* opts.forcejffs2 = 1; */
349                 opts.pad    = 1;
350                 opts.blockalign = 1;
351                 opts.quiet      = quiet;
352                 ret = nand_write_opts(nand, &opts);
353             }
354         }else if (  s != NULL && !strcmp(s, ".yaffs")){
355             if (read) {
356                 /* read */
357                 nand_read_options_t opts;
358                 memset(&opts, 0, sizeof(opts));
359                 opts.buffer = (u_char*) addr;
360                 opts.length = size;
361                 opts.offset = off;
362                 opts.readoob = 1;
363                 opts.quiet      = quiet;
364                 ret = nand_read_opts(nand, &opts);
365             } else {
366                 /* write */
367                 nand_write_options_t opts;
368                 memset(&opts, 0, sizeof(opts));
369                 opts.buffer = (u_char*) addr;
370                 opts.length = size;
371                 opts.offset = off;
372                 /* opts.forceyaffs = 1; */
373                 opts.noecc = 1;
374                 opts.writeoob = 1;
375                 opts.blockalign = 1;
376                 opts.quiet      = quiet;
377                 opts.skipfirstblk = 1;
378                 ret = nand_write_opts(nand, &opts);
379             }
380         } else {
381             if (read)
382                 ret = nand_read(nand, off, &size, (u_char *)addr);
383             else
384                 ret = nand_write(nand, off, &size, (u_char *)addr);
385         }
386 
387         printf(" %d bytes %s: %s\n", size,
388                read ? "read" : "written", ret ? "ERROR" : "OK");
389 
390         return ret == 0 ? 0 : 1;
391     }
392 
393     if (strcmp(cmd, "markbad") == 0) {
394         addr = (ulong)simple_strtoul(argv[2], NULL, 16);
395 
396         int ret = nand->block_markbad(nand, addr);
397         if (ret == 0) {
398             printf("block 0x%08lx successfully marked as bad\n",
399                    (ulong) addr);
400             return 0;
401         } else {
402             printf("block 0x%08lx NOT marked as bad! ERROR %d\n",
403                    (ulong) addr, ret);
404         }
405         return 1;
406     }
407     if (strcmp(cmd, "biterr") == 0) {
408         /* todo */
409         return 1;
410     }
411 
412     if (strcmp(cmd, "lock") == 0) {
413         int tight  = 0;
414         int status = 0;
415         if (argc == 3) {
416             if (!strcmp("tight", argv[2]))
417                 tight = 1;
418             if (!strcmp("status", argv[2]))
419                 status = 1;
420         }
421 
422         if (status) {
423             ulong block_start = 0;
424             ulong off;
425             int last_status = -1;
426 
427             struct nand_chip *nand_chip = nand->priv;
428             /* check the WP bit */
429             nand_chip->cmdfunc (nand, NAND_CMD_STATUS, -1, -1);
430             printf("device is %swrite protected\n",
431                    (nand_chip->read_byte(nand) & 0x80 ?
432                 "NOT " : "" ) );
433 
434             for (off = 0; off < nand->size; off += nand->oobblock) {
435                 int s = nand_get_lock_status(nand, off);
436 
437                 /* print message only if status has changed
438                  * or at end of chip
439                  */
440                 if (off == nand->size - nand->oobblock
441                     || (s != last_status && off != 0))  {
442 
443                     printf("%08x - %08x: %8d pages %s%s%s\n",
444                            block_start,
445                            off-1,
446                            (off-block_start)/nand->oobblock,
447                            ((last_status & NAND_LOCK_STATUS_TIGHT) ? "TIGHT " : ""),
448                            ((last_status & NAND_LOCK_STATUS_LOCK) ? "LOCK " : ""),
449                            ((last_status & NAND_LOCK_STATUS_UNLOCK) ? "UNLOCK " : ""));
450                 }
451 
452                 last_status = s;
453                }
454         } else {
455             if (!nand_lock(nand, tight)) {
456                 puts("NAND flash successfully locked\n");
457             } else {
458                 puts("Error locking NAND flash\n");
459                 return 1;
460             }
461         }
462         return 0;
463     }
464 
465     if (strcmp(cmd, "unlock") == 0) {
466         if (arg_off_size(argc - 2, argv + 2, nand, &off, &size) < 0)
467             return 1;
468 
469         if (!nand_unlock(nand, off, size)) {
470             puts("NAND flash successfully unlocked\n");
471         } else {
472             puts("Error unlocking NAND flash, "
473                  "write and erase will probably fail\n");
474             return 1;
475         }
476         return 0;
477     }
478 
479 usage:
480     printf("Usage:\n%s\n", cmdtp->usage);
481     return 1;
482 }
483 
484 U_BOOT_CMD(nand, 5, 1, do_nand,
485     "nand    - NAND sub-system\n",
486     "info                  - show available NAND devices\n"
487     "nand device [dev]     - show or set current device\n"
488     "nand read[.jffs2]     - addr off|partition size\n"
489     "nand write[.jffs2]    - addr off|partiton size - read/write `size' bytes starting\n"
490     "    at offset `off' to/from memory address `addr'\n"
491     "nand read.yaffs addr off size - read the `size' byte yaffs image starting\n"
492     "    at offset `off' to memory address `addr'\n"
493     "nand write.yaffs addr off size - write the `size' byte yaffs image starting\n"
494     "    at offset `off' from memory address `addr'\n"
495     "nand erase [clean] [off size] - erase `size' bytes from\n"
496     "    offset `off' (entire device if not specified)\n"
497     "nand bad - show bad blocks\n"
498     "nand dump[.oob] off - dump page\n"
499     "nand scrub - really clean NAND erasing bad blocks (UNSAFE)\n"
500     "nand markbad off - mark bad block at offset (UNSAFE)\n"
501     "nand biterr off - make a bit error at offset (UNSAFE)\n"
502     "nand lock [tight] [status] - bring nand to lock state or display locked pages\n"
503     "nand unlock [offset] [size] - unlock section\n");
504 
505 static int nand_load_image(cmd_tbl_t *cmdtp, nand_info_t *nand,
506                ulong offset, ulong addr, char *cmd)
507 {
508     int r;
509     char *ep;
510     ulong cnt;
511     image_header_t *hdr;
512 
513     printf("\nLoading from %s, offset 0x%lx\n", nand->name, offset);
514 
515     cnt = nand->oobblock;
516     r = nand_read(nand, offset, &cnt, (u_char *) addr);
517     if (r) {
518         puts("** Read error\n");
519         SHOW_BOOT_PROGRESS(-1);
520         return 1;
521     }
522 
523     hdr = (image_header_t *) addr;
524 
525     if (ntohl(hdr->ih_magic) != IH_MAGIC) {
526         printf("\n** Bad Magic Number 0x%x **\n", hdr->ih_magic);
527         SHOW_BOOT_PROGRESS(-1);
528         return 1;
529     }
530 
531     print_image_hdr(hdr);
532 
533     cnt = (ntohl(hdr->ih_size) + sizeof (image_header_t));
534 
535     r = nand_read(nand, offset, &cnt, (u_char *) addr);
536     if (r) {
537         puts("** Read error\n");
538         SHOW_BOOT_PROGRESS(-1);
539         return 1;
540     }
541 
542     /* Loading ok, update default load address */
543 
544     load_addr = addr;
545 
546     /* Check if we should attempt an auto-start */
547     if (((ep = getenv("autostart")) != NULL) && (strcmp(ep, "yes") == 0)) {
548         char *local_args[2];
549         extern int do_bootm(cmd_tbl_t *, int, int, char *[]);
550 
551         local_args[0] = cmd;
552         local_args[1] = NULL;
553 
554         printf("Automatic boot of image at addr 0x%08lx ...\n", addr);
555 
556         do_bootm(cmdtp, 0, 1, local_args);
557         return 1;
558     }
559     return 0;
560 }
561 
562 int do_nandboot(cmd_tbl_t * cmdtp, int flag, int argc, char *argv[])
563 {
564     char *boot_device = NULL;
565     int idx;
566     ulong addr, offset = 0;
567 #if (CONFIG_COMMANDS & CFG_CMD_JFFS2) && defined(CONFIG_JFFS2_CMDLINE)
568     struct mtd_device *dev;
569     struct part_info *part;
570     u8 pnum;
571 
572     if (argc >= 2) {
573         char *p = (argc == 2) ? argv[1] : argv[2];
574         if (!(str2long(p, &addr)) && (mtdparts_init() == 0) &&
575             (find_dev_and_part(p, &dev, &pnum, &part) == 0)) {
576             if (dev->id->type != MTD_DEV_TYPE_NAND) {
577                 puts("Not a NAND device\n");
578                 return 1;
579             }
580             if (argc > 3)
581                 goto usage;
582             if (argc == 3)
583                 addr = simple_strtoul(argv[2], NULL, 16);
584             else
585                 addr = CFG_LOAD_ADDR;
586             return nand_load_image(cmdtp, &nand_info[dev->id->num],
587                            part->offset, addr, argv[0]);
588         }
589     }
590 #endif
591 
592     switch (argc) {
593     case 1:
594         addr = CFG_LOAD_ADDR;
595         boot_device = getenv("bootdevice");
596         break;
597     case 2:
598         addr = simple_strtoul(argv[1], NULL, 16);
599         boot_device = getenv("bootdevice");
600         break;
601     case 3:
602         addr = simple_strtoul(argv[1], NULL, 16);
603         boot_device = argv[2];
604         break;
605     case 4:
606         addr = simple_strtoul(argv[1], NULL, 16);
607         boot_device = argv[2];
608         offset = simple_strtoul(argv[3], NULL, 16);
609         break;
610     default:
611 #if (CONFIG_COMMANDS & CFG_CMD_JFFS2) && defined(CONFIG_JFFS2_CMDLINE)
612 usage:
613 #endif
614         printf("Usage:\n%s\n", cmdtp->usage);
615         SHOW_BOOT_PROGRESS(-1);
616         return 1;
617     }
618 
619     if (!boot_device) {
620         puts("\n** No boot device **\n");
621         SHOW_BOOT_PROGRESS(-1);
622         return 1;
623     }
624 
625     idx = simple_strtoul(boot_device, NULL, 16);
626 
627     if (idx < 0 || idx >= CFG_MAX_NAND_DEVICE || !nand_info[idx].name) {
628         printf("\n** Device %d not available\n", idx);
629         SHOW_BOOT_PROGRESS(-1);
630         return 1;
631     }
632 
633     return nand_load_image(cmdtp, &nand_info[idx], offset, addr, argv[0]);
634 }
635 
636 U_BOOT_CMD(nboot, 4, 1, do_nandboot,
637     "nboot   - boot from NAND device\n",
638     "[partition] | [[[loadAddr] dev] offset]\n");
639 
640 #endif              /* (CONFIG_COMMANDS & CFG_CMD_NAND) */
641 
642 #else /* CFG_NAND_LEGACY */
643 /*
644  *
645  * Legacy NAND support - to be phased out
646  *
647  */
648 #include <command.h>
649 #include <malloc.h>
650 #include <asm/io.h>
651 #include <watchdog.h>
652 
653 #ifdef CONFIG_SHOW_BOOT_PROGRESS
654 # include <status_led.h>
655 # define SHOW_BOOT_PROGRESS(arg)    show_boot_progress(arg)
656 #else
657 # define SHOW_BOOT_PROGRESS(arg)
658 #endif
659 
660 #if (CONFIG_COMMANDS & CFG_CMD_NAND)
661 #include <linux/mtd/nand_legacy.h>
662 #if 0
663 #include <linux/mtd/nand_ids.h>
664 #include <jffs2/jffs2.h>
665 #endif
666 
667 #ifdef CONFIG_OMAP1510
668 void archflashwp(void *archdata, int wp);
669 #endif
670 
671 #define ROUND_DOWN(value,boundary)      ((value) & (~((boundary)-1)))
672 
673 #undef  NAND_DEBUG
674 #undef  PSYCHO_DEBUG
675 
676 /* ****************** WARNING *********************
677  * When ALLOW_ERASE_BAD_DEBUG is non-zero the erase command will
678  * erase (or at least attempt to erase) blocks that are marked