추가적인 설명 첨부합니다.

고수님들 도와주세요!!

디버깅 메세지를 넣어서 보면 반복문에서 진행이 되지 않습니다.

실제 디버깅용 메세지를 출력하여 보면 아래와 같습니다

nand erase 명령 실행 후 step #16 에서ㄱ하여야  step#8 로 반복하여야 하는 데 안됩니다.

NAND erase: device 0 offset 0x60000, size 0x100000

Erasing at 0x60000 --  12  

위 상태에서 enter 치면 아래와 같은 메세지만 반복됩니다. 소스가 안도는 것처럼....

제 생각에는 SDRAM이 이상하지 않나 생각해 봅니다.

SD 부팅시에도 최초 4kB 읽을 때 CS 에러가 납니다

왜 소스가 수행이 안되는 걸가요?-_-;

erase.len = 262144

nanoeye step#5

erase.addr = 262144, erase_length=3932160

 NAND Type = 1

nanoeye step#8

nanoeye step#9

ret=0

nanoeye step#11

 nanoeye step#12 meminfo->erase() = 0

nanoeye step#14

 nanoeye step#15 n = 262144, erase_length=26214400

 nanoeye step#16 percent = 6, percent_complete=-1

u-boot 상의 소스

int nand_erase_opts(nand_info_t *meminfo, const nand_erase_options_t *opts)
{
 struct jffs2_unknown_node cleanmarker;
 int clmpos = 0;
 int clmlen = 8;
 erase_info_t erase;
 ulong erase_length;
 int isNAND;
 int bbtest = 1;
 int result;
 int percent_complete = -1;
 int (*nand_block_bad_old)(struct mtd_info *, loff_t, int) = NULL;
 const char *mtd_device = meminfo->name;

 /* jsgood */
 struct mtd_oob_ops oob_ops;
 memset(&cleanmarker, 0, sizeof(cleanmarker));

 memset(&erase, 0, sizeof(erase));

 erase.mtd = meminfo;
 erase.len  = meminfo->erasesize;
 printf("erase.len = %ld\n", erase.len);
 
 if (opts->offset == 0 && opts->length == 0) {
  /* erase complete chip */
  puts("nanoeye step#4\r\n");
  
  erase.addr = 0;
  erase_length = meminfo->size;
 } else {
  puts("nanoeye step#5\r\n");
 
  /* erase specified region */
  erase.addr = opts->offset;
  erase_length = opts->length;
 }

 printf("erase.addr = %ld, erase_length=%ld\n", erase.addr,erase_length);

 isNAND = meminfo->type == MTD_NANDFLASH ? 1 : 0;

 printf(" NAND Type = %d\n", isNAND);

 if (opts->jffs2) {
  
  cleanmarker.magic = cpu_to_je16 (JFFS2_MAGIC_BITMASK);
  cleanmarker.nodetype = cpu_to_je16 (JFFS2_NODETYPE_CLEANMARKER);
  if (isNAND) {
   /* org: struct nand_oobinfo *oobinfo = &meminfo->oobinfo; */
   struct nand_ecclayout *oobinfo = meminfo->ecclayout;

   /* check for autoplacement */
   if (oobinfo->useecc == MTD_NANDECC_AUTOPLACE) {
    /* get the position of the free bytes */
    if (!oobinfo->oobfree[0].length) {
     printf(" Eeep. Autoplacement selected "
            "and no empty space in oob\n");
     return -1;
    }
    clmpos = oobinfo->oobfree[0].offset;
    clmlen = oobinfo->oobfree[0].length;

    /* jsgood */
    if (clmlen > 12)
     clmlen = 12;
   } else {
   
    /* legacy mode */
    switch (meminfo->oobsize) {
    case 8:
     clmpos = 6;
     clmlen = 2;
     break;
    case 16:
     clmpos = 8;
     clmlen = 8;
     break;
    case 64:
     clmpos = 16;
     clmlen = 8;
     break;
    }
   }

   cleanmarker.totlen = cpu_to_je32(8);
  } else {
   cleanmarker.totlen =
    cpu_to_je32(sizeof(struct jffs2_unknown_node));
  }
  /* jsgood */
  /* cleanmarker.hdr_crc =  cpu_to_je32(
   crc32_no_comp(0, (unsigned char *) &cleanmarker,
          sizeof(struct jffs2_unknown_node) - 4)); */
 }

 /* scrub option allows to erase badblock. To prevent internal
  * check from erase() method, set block check method to dummy
  * and disable bad block table while erasing.
  */
 if (opts->scrub) {
  puts("nanoeye step#7\r\n");
  
  struct nand_chip *priv_nand = meminfo->priv;

  nand_block_bad_old = priv_nand->block_bad;
  priv_nand->block_bad = nand_block_bad_scrub;
  /* we don't need the bad block table anymore...
   * after scrub, there are no bad blocks left!
   */
  if (priv_nand->bbt) {
   kfree(priv_nand->bbt);
  }
  priv_nand->bbt = NULL;
 }

 for (;
 
      erase.addr < opts->offset + erase_length;
      erase.addr += meminfo->erasesize) {
  puts("nanoeye step#8\r\n");

  WATCHDOG_RESET ();

  if (!opts->scrub && bbtest) {
   puts("nanoeye step#9\r\n");
   
   int ret = meminfo->block_isbad(meminfo, erase.addr);
   printf("ret=%d\r\n", ret);
   
   if (ret > 0) {
   puts("nanoeye step#9-1\r\n");
    
    if (!opts->quiet)
     printf("\rSkipping bad block at  "
            "0x%08x                   "
            "                         \n",
            erase.addr);
    puts("nanoeye step#9-2\r\n");
           
    continue;

   } else if (ret < 0) {
   puts("nanoeye step#10\r\n");
   
    printf("\n%s: MTD get bad block failed: %d\n",
           mtd_device,
           ret);
    return -1;
   }
  }

   puts("nanoeye step#11\r\n");

  result = meminfo->erase(meminfo, &erase);
  printf(" nanoeye step#12 meminfo->erase() = %d\n", result);
  
  if (result != 0) {
   printf("\n%s: MTD Erase failure: %d\n",
          mtd_device, result);
   puts("nanoeye step#12\r\n");
         
   continue;
  }

  /* format for JFFS2 ? */
  if (opts->jffs2) {
   puts("nanoeye step#13\r\n");

   /* write cleanmarker */
   if (isNAND) {
    /* org: result = meminfo->write_oob(meminfo,
           erase.addr + clmpos,
           clmlen,
           &written,
           (unsigned char *)
           &cleanmarker); */
    oob_ops.mode = MTD_OOB_AUTO;
    oob_ops.ooboffs = 0;
    oob_ops.ooblen = clmlen;    
    oob_ops.oobbuf = (unsigned char *)&cleanmarker;
    oob_ops.datbuf = NULL;
    
    result = meminfo->write_oob(meminfo, erase.addr, &oob_ops);
   
    if (result != 0) {
     printf("\n%s: MTD writeoob failure: %d\n",
            mtd_device, result);
     continue;
    }
   } else {
    printf("\n%s: this erase routine only supports"
           " NAND devices!\n",
           mtd_device);
   }
  }

  if (!opts->quiet) {
   puts("nanoeye step#14\r\n");
   
   unsigned long long n =(unsigned long long)
     (erase.addr+meminfo->erasesize-opts->offset)
    * 100;
   int percent;
  printf(" nanoeye step#15 n = %ld, erase_length=%ld\n", n, erase_length);

   do_div(n, erase_length);
   percent = (int)n;
  printf(" nanoeye step#16 percent = %d, percent_complete=%d\n", percent , percent_complete);

   /* output progress message only at whole percent
    * steps to reduce the number of messages printed
    * on (slow) serial consoles
    */
   if (percent != percent_complete) {
    percent_complete = percent;

    printf("\r\nErasing at 0x%lx -- %3d%% complete.\r\n",
           erase.addr, percent);

  printf("\r\nnanoeye step#16-1\n");

    if (opts->jffs2 && result == 0)
     printf(" Cleanmarker written at 0x%x.",
            erase.addr);
  printf("\r\nnanoeye step#16-2\n");
           
   }
  printf("\r\nnanoeye step#17\n");
   
  }
 }
 if (!opts->quiet)
  printf("\n");

 if (nand_block_bad_old) {
  struct nand_chip *priv_nand = meminfo->priv;

  priv_nand->block_bad = nand_block_bad_old;
  priv_nand->scan_bbt(meminfo);
 }

 return 0;
}