일반 [EM-S3C6410] NAND ERASE 문제입니다.

이솝 부트로더에서 EM-S3C6410 에서 사용하는 낸드플래쉬에 대한 지원이 되는지는 모르겠네요.

지우기 동작 수행시 체크하는 항목이나 관련된 코드를 먼저 확인하시는 것이 좋을것 같습니다.

해당 디버깅 메세지를 출력하는 부분의 코드를 확인해 보시는 것이 좋겠네요.

uboot 에서는 부트로더 파티션의 경우 소프트락을 거는 것으로 압니다만...

그냥 멈추는 증상은 다른 문제인것 같기도 하네요.

답변 감사드립니다.

aesop도 NAND BOOT 관련 지원하구요 멈추지는 않고 밑에서 두 줄만 반복합니다.

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

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

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;
}

uboot 소스에서 보면

--중략--

int ret = meminfo->block_isbad(meminfo, erase.addr);

--중략--

 } 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;       <===== 이부분을 주석처리하시면 됩니다.
   }

위의 라인부터 내용을 보시면 배드블럭일 경우 더이상 일을 하지 않고 함수를 종료합니다.

답변 감사드립니다.^^

해 보았지만 안되네요

그리고 제가 시리얼 메세지 띄운거 보시면 "nanoeye step#10" 으로는 진입을 하지 않습니다.

아래는 시리얼 메세지 입니다.

메세지를 보시면 멈춤것 처럼 보이지만 엔터키치면 같은 메세지만 반복합니다.

엔터가 아닌 다른키를 치면 프롬프트로 빠져 나옵니다.

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