开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > uCOS > 查看源码
k9k2g16.c
资源名称：mini2440_uCos2_ucgui.rar　[点击查看]
上传用户：zbk8730
上传日期：2017-08-10
资源大小：12168k
文件大小：21k
源码类别：

uCOS

开发平台：

C/C++

k9k2g16.c：源码内容
  1. //====================================================================
  2. // File Name : K9k2g16.c
  3. // Function  : S3C2440 16-bit interface Nand Test program(this program used by nand.c).
  4. // Date      : May xx, 2003
  5. // Version   : 0.0
  6. // History
  7. //   R0.0 (200305xx): Modified for 2440 from 2410. -> DonGo
  8. //====================================================================
  11. /**************** K9s1206 NAND flash ********************/
  12. // 1block=(NF8_PAGE_BYTE+16)bytes x 32pages
  13. // 4096block
  14. // Block: A[23:14], Page: [13:9]
  15. /**************** K9K2G16 NAND flash *******************/
  16. // 1block=(2048+64)bytes x 64pages
  17. // 2048block
  18. // Block: A[23:14], page: [13:9]
  19. /*****************************************************/
  21. #include <string.h>
  22. #include <stdlib.h>
  23. #include "def.h"
  24. #include "option.h"
  25. #include "2440addr.h"
  26. #include "2440lib.h"
  27. #include "2440slib.h" 
  29. #include "K9K2G16.h"
  30. #include "nand.h"
  31. #define BAD_CHECK (0)
  32. #define ECC_CHECK (0)
  34. #define C_LANG 1
  35. #define DMA 2
  36. #define TRANS_MODE16  2
  39. extern void Nand_Reset(void);
  41. extern U32 srcAddress;
  42. extern U32 targetBlock;     // Block number (0 ~ 4095)
  43. extern U32 targetSize;     // Total byte size 
  45. extern U32 downloadAddress;
  46. extern U32 downloadProgramSize;
  48. U32 NF16_Spare_Data[32/2];
  49. volatile int NFConDone16;
  52. void __irq NFCon_Int16(void);
  55. void * n16_func[][2]=
  56. {
  57. (void *)Test_NF16_Block_Erase, "Block erase         ",
  58. (void *)Test_NF16_Page_Read, "Page read           ",
  59. (void *)Test_NF16_Page_Write, "Page write          ",
  60. (void *)Test_NF16_Rw, "Nand R/W test       ",
  61. (void *)NF16_Program, "K9K2G16_Program     ",
  62. (void *)NF16_Print_Id, "Read ID             ",
  63. (void *)K9K2G16_PrintBadBlockNum, "Check bad block     ",
  64. (void *)Test_NF16_Lock,         "Nand Block lock test",
  65. (void *)Test_NF16_SoftUnLock,         "Soft Unlock test      ",
  66. 0,0
  67. };
  72. void Test_K9K2G16(void)
  73. {
  74. int i;
  75. U32 blocknum, pagenum;
  77. Uart_Printf("nK9K2G16 Nand flash test start.n");
  79. NF16_Init();
  81. while(1) {
  82. Print16SubMessage();
  83. Uart_Printf("nSelect(-1 to exit): ");
  84. i = Uart_GetIntNum();
  85. if(i==-1) break;
  87. if(i>=0 && (i<(sizeof(n16_func)/8)) ) 
  88.      ( (void (*)(void)) (n16_func[i][0]) )(); // execute selected function.
  89. }
  91. }
  93. void Print16SubMessage(void)
  94. {
  95. int i;
  97. i=0;
  98. Uart_Printf("nn");
  99. while(1)
  100. {   //display menu
  101. Uart_Printf("%2d:%s",i,n16_func[i][1]);
  102.     i++;
  103.     if((int)(n16_func[i][0])==0)
  104.     {
  105. Uart_Printf("n");
  106. break;
  107.     }
  108.     if((i%4)==0) Uart_Printf("n");
  109. }
  110. }
  114. void NF16_Print_Id(void)
  115. {
  116. U32 id;
  117. U8 maker, device, id4th;
  119. // NF16_Init();
  121. id = NF16_CheckId();
  122. device = (U8)id;
  123. maker = (U8)(id>>8);
  125. Uart_Printf("Maker:%x, Device:%xn", maker, device);
  126. }
  130. void Test_NF16_Block_Erase(void)
  131. {
  132. U32 block=0;
  134. Uart_Printf("SOP(K9K2G160UM) NAND Block erasen");
  136. Uart_Printf("Block # to erase: ");
  137. block = Uart_GetIntNum();
  139. if(NF16_EraseBlock(block)==FAIL) return;
  141. Uart_Printf("%d-block erased.n", block);
  143. }
  145. void Test_NF16_Lock(void)
  146. {
  147.        U32 num;
  148.        U32 S_block, E_block;
  149. Uart_Printf("SOP(K9K2G16U0M) NAND Lock Test !!!n");
  150. Uart_Printf("Select Lock type, Softlock(1)/Lock-tight(2) : ");
  152. num=Uart_GetIntNum();;
  154. Uart_Printf("nEnter programmable start block address ");
  155. S_block = Uart_GetIntNum();
  156. Uart_Printf("Enter programmable end block address ");
  157.        E_block = Uart_GetIntNum();
  159. rNFSBLK=(S_block<<6);
  160. rNFEBLK=(E_block<<6);
  163. if(num==1){
  164. rNFCONT|=(1<<12);
  165.               Uart_Printf("Software Lockedn ");
  166. }
  167. if(num==2){
  168. rNFCONT|=(1<<13);
  169.               Uart_Printf("Lock-tight: To clear Lock-tight, reset S3C2440!!!n ");
  170. }
  171.       Uart_Printf("%d block ~ %d block are Programmablen ", S_block, (E_block-1));
  172. }
  175. void Test_NF16_SoftUnLock(void)
  176. {
  177.        U32 S_block, E_block;
  178. Uart_Printf("SOP(K9K2G16U0M) NAND SoftUnLock Test !!!n");
  180. rNFSBLK=0x0;
  181. rNFEBLK=0x0;
  183. rNFCONT&=~(1<<12);
  184. if(rNFCONT&(1<<13)){
  185.    rNFCONT&=~(1<<13);
  186.    Uart_Printf("Lock-tightn ");
  187.    Uart_Printf("You can't unlock Protected blocks !!!n ");
  188.    Uart_Printf("%d block ~ %d block are Programmablen ", (rNFSBLK>>6), ((rNFEBLK>>6)-1));
  189. }
  190.        else Uart_Printf("All blocks are Programmablen ");
  191. }
  194. void Test_NF16_Page_Read(void)
  195. {
  196. U32 block=0, page=0;
  197. U32 i;
  199.        unsigned int * srcPt;
  200. srcPt=(unsigned int *)0x31000000;
  202. Uart_Printf("SOP(K9K2G16U0M) NAND Page Read.n");
  204. Uart_Printf("Block # to read: ");
  205. block = Uart_GetIntNum();
  206. Uart_Printf("Page # to read: ");
  207. page = Uart_GetIntNum();
  209. if(NF16_ReadPage(block, page, srcPt)==FAIL) {
  210. Uart_Printf("Read error.n");
  211. } else {
  212. Uart_Printf("Read OK.n");
  213. };
  215. // Print data.
  216. Uart_Printf("Read data(%d-block,%d-page)n", block, page);
  217. for(i=0; i<512; i++) {
  218. if((i%4)==0) Uart_Printf("n%2x: ", i);
  219. Uart_Printf("%08x ", *srcPt++);
  220. }
  221. Uart_Printf("n");
  222. Uart_Printf("Spare:");
  223. for(i=0; i<16; i++) {
  224.   Uart_Printf("%08x ", NF16_Spare_Data[i]);
  225. }
  226. Uart_Printf("n");
  228. }
  232. void Test_NF16_Page_Write(void)
  233. {
  234. U32 block=0, page=0;
  235. int i, offset;
  236. unsigned int *srcPt;
  237. srcPt=(unsigned int *)0x31100000;
  240. Uart_Printf("SOP(K9K2G16U0M) NAND Page Write.n");
  242. Uart_Printf("Block # to write: ");
  243. block = Uart_GetIntNum();
  244. Uart_Printf("Page # to write: ");
  245. page = Uart_GetIntNum();
  246. Uart_Printf("offset data(-1:random): ");
  247. offset = Uart_GetIntNum();
  249. #if ADS10==TRUE
  250. srand(0);
  251. #endif
  254. // Init wdata.
  255. for(i=0; i<512; i++) {
  256. #if ADS10==TRUE
  257. if(offset==-1) *srcPt++ = rand()%0xffffffff;
  258. #else
  259. if(offset==-1) *srcPt++ = i;
  260. #endif
  261. else *srcPt++ =i+offset;
  262. }
  263.      
  264.        srcPt=(unsigned int *)0x31100000;
  265. Uart_Printf("Write data[%d block, %d page].n", block, page);
  266. if(NF16_WritePage(block, page, srcPt)==FAIL) {
  267. Uart_Printf("Write Error.n");
  268. } else {
  269. Uart_Printf("Write OK.n");
  271. Uart_Printf("Write data is");
  272. for(i=0; i<512; i++) {
  273. if((i%4)==0) Uart_Printf("n%2x: ", i);
  274. Uart_Printf("%08x ", *srcPt++);
  275. }
  276. Uart_Printf("n");
  278. Uart_Printf("Spare:");
  279. for(i=0; i<32/2; i++) {
  280.   Uart_Printf("%08x ", NF16_Spare_Data[i]);
  281. }
  282. Uart_Printf("nn");
  283. }
  284. }
  288. void Test_NF16_Rw(void)
  289. {
  290. U32 block=0, page=0;
  291. U32 i, status=FAIL, error, offset;
  293. unsigned int *srcPt, *dstPt;
  294. srcPt=(unsigned int *)0x31100000;
  295. dstPt=(unsigned int *)0x31200000;
  297. Uart_Printf("SOP(K9K2G16U0M) NAND Flash R/W test.n");
  299. Uart_Printf("Block number: ");
  300. block = Uart_GetIntNum();
  301. Uart_Printf("Page nember: ");
  302. page = Uart_GetIntNum();
  303. Uart_Printf("offset data(-1:random): ");
  304. offset = Uart_GetIntNum();
  306. #if ADS10==TRUE 
  307. srand(0); 
  308. #endif
  310. // Init R/W data.
  311. for(i=0; i<512; i++) *dstPt++=0x0;
  313. for(i=0; i<512; i++) {
  314. #if ADS10==TRUE
  315. if(offset==-1) *srcPt++= rand()%0xffffffff;
  316. #else
  317. if(offset==-1) *srcPt++= i;
  318. #endif
  319. else *srcPt++ = i+offset;
  320. }
  322.        srcPt=(unsigned int *)0x31100000;
  323. dstPt=(unsigned int *)0x31200000;
  324. // Block erase
  325. Uart_Printf("%d block erase.n", block);
  326. if(NF16_EraseBlock(block)==FAIL) return;
  328. Uart_Printf("Write data[%d block, %d page].n", block, page);
  329. if(NF16_WritePage(block, page, srcPt)==FAIL) return;
  331. Uart_Printf("Read data.n");
  332. if(NF16_ReadPage(block, page, dstPt)==FAIL) return;
  334. Uart_Printf("Checking data.n");
  335. for(error=0, i=0; i<512; i++) {
  336. if(*srcPt++!=*dstPt++) {
  337. Uart_Printf("Error:%d[W:%x,R:%x]n", i, *srcPt, *dstPt);
  338. error++;
  339. }
  340. }
  341. if(error!=0) 
  342. Uart_Printf("Fail to R/W test(%d).n", error);
  343. else
  344. Uart_Printf("R/W test OK.n");
  345. }
  349. void NF16_Program(void)
  350. {
  351.     int i, page_num;
  352.     int programError=0;
  353.     U32 *srcPt,*saveSrcPt;
  354.     U32 blockIndex;
  356.     Uart_Printf("n[SOP(K9K2G16U0M) NAND Flash writing program]n");
  357.     Uart_Printf("The program buffer: 0x30100000~0x31ffffffn");
  359. //     NF16_Init();
  361.      rINTMSK = BIT_ALLMSK; 
  362.      srcAddress=0x30100000; 
  364.      InputTargetBlock16();
  366.      srcPt=(U32 *)srcAddress;
  367.      blockIndex=targetBlock;
  369.      while(1) {
  370.              saveSrcPt=srcPt;
  371.               
  372.       #if BAD_CHECK
  373.         if(NF16_IsBadBlock(blockIndex)==FAIL) {
  374.     blockIndex++;   // for next block
  375.     continue;
  376.   }
  377.       #endif
  379.       if(NF16_EraseBlock(blockIndex)==FAIL) {
  380.     blockIndex++;   // for next block
  381.     continue;
  382.       }
  383.     // After 1-Block erase, Write 1-Block(64 pages).
  384. for(i=0;i<64;i++) {
  385.     if(NF16_WritePage(blockIndex,i,srcPt)==FAIL) {// block num, page num, buffer
  386.         programError=1;
  387.         break;
  388.     }
  390. #if ECC_CHECK
  391.     if(NF16_ReadPage(blockIndex,i,srcPt)==FAIL) {
  392. Uart_Printf("ECC Error(block=%d,page=%d!!!n",blockIndex,i);
  393.     }
  394. #endif
  396. srcPt+=512; // Increase buffer addr one pase size
  397.      if(i==0)  Uart_Printf(".");
  398. if((U32)srcPt>=(srcAddress+targetSize)) // Check end of buffer
  399. break; // Exit for loop
  400.     }
  402. if(programError==1) {
  403.     blockIndex++;
  404.     srcPt=saveSrcPt;
  405.     programError=0;
  406.     continue;
  407. }
  409. if((U32)srcPt>=(srcAddress+targetSize)) break; // Exit while loop
  411. blockIndex++;
  413.     }
  415. }
  418. void K9K2G16_PrintBadBlockNum(void)
  419. {
  420.     int i;
  421.     U32 id;
  423.     Uart_Printf("n[SMC(K9S1208V0M) NAND Flash bad block check]n");
  424.     
  425. //    NF16_Init();
  427.     for(i=0;i<2048;i++)
  428.     {
  429. NF16_IsBadBlock(i);   // Print bad block
  430.     }
  431. }
  438. //*************************************************
  439. //*************************************************
  440. //**           H/W dependent functions           **
  441. //************************************************* 
  442. //*************************************************
  444. //The code is made for bi-endian mode
  446. // block0: reserved for boot strap
  447. // block1~4095: used for OS image
  448. // badblock SE: xx xx xx xx xx 00 ....
  449. // good block SE: ECC0 ECC1 ECC2 FF FF FF ....
  452. #define NF_MECC_UnLock()         {rNFCONT&=~(1<<5);}
  453. #define NF_MECC_Lock()         {rNFCONT|=(1<<5);}
  454. #define NF_SECC_UnLock()         {rNFCONT&=~(1<<6);}
  455. #define NF_SECC_Lock()         {rNFCONT|=(1<<6);}
  457. #define NF_CMD(cmd) {rNFCMD=cmd;}
  458. #define NF_ADDR(addr) {rNFADDR=addr;}
  459. #define NF_nFCE_L() {rNFCONT&=~(1<<1);}
  460. #define NF_nFCE_H() {rNFCONT|=(1<<1);}
  461. #define NF_RSTECC() {rNFCONT|=(1<<4);}
  462. #define NF_RDDATA()  (rNFDATA)
  463. #define NF_RDDATA16()  ((*(volatile unsigned short*)0x4E000010) )
  465. #define NF_WRDATA(data)  {rNFDATA=data;}
  467. // RnB Signal
  468. #define NF_CLEAR_RB()     {rNFSTAT |= (1<<2);} // Have write '1' to clear this bit.
  469. #define NF_DETECT_RB()     {while(!(rNFSTAT&(1<<2)));} // edge detect.
  472. #define ID_K9S1208V0M 0xec76
  473. #define ID_K9K2G16U0M 0xecca
  475. #define BAD_MARK (0x44444444)
  477. #if 1
  478. // HCLK=100Mhz
  479. #define TACLS 0 // 1-clk(0ns) 
  480. #define TWRPH0 6 // 3-clk(25ns)
  481. #define TWRPH1 0 // 1-clk(10ns)  //TACLS+TWRPH0+TWRPH1>=50ns
  482. #else
  483. // HCLK=50Mhz
  484. #define TACLS 0  //1clk(0ns)
  485. #define TWRPH0 1  //2clk(25ns)
  486. #define TWRPH1 0  //1clk(10ns)
  487. #endif
  490. static U32 se16Buf[32/2]={
  491. 0xffffffff,0xffffffff,0xffffffff,0xffffffff,
  492. 0xffffffff,0xffffffff,0xffffffff,0xffffffff,
  493. 0xffffffff,0xffffffff,0xffffffff,0xffffffff,
  494. 0xffffffff,0xffffffff,0xffffffff,0xffffffff
  495. };
  498. void InputTargetBlock16(void)
  499. {
  500. U32 no_block, no_page, no_byte;
  502. Uart_Printf("nSource size:0h~%xhn",downloadProgramSize);
  503. Uart_Printf("nAvailable target block number: 0~2048n");
  504. Uart_Printf("Input target block number:");
  505.     targetBlock=Uart_GetIntNum(); // Block number(0~4095)
  506.     if(targetSize==0)
  507.     {
  508.      #if 0
  509.      Uart_Printf("Input target size(0x4000*n):");
  510.      targetSize=Uart_GetIntNum(); // Total byte size
  511. #else
  512.     Uart_Printf("Input program file size(bytes): ");
  513.      targetSize=Uart_GetIntNum(); // Total byte size
  514.      #endif
  515.     }
  517. no_block = (U32)((targetSize/2048)/64);
  518. no_page = (U32)((targetSize/2048)%64);
  519. no_byte = (U32)(targetSize%2048);
  520. Uart_Printf("File:%d[%d-block,%d-page,%d-bytes].n", targetSize, no_block, no_page, no_byte);
  521. }
  524. static int NF16_EraseBlock(U32 block)
  525. {
  526.     U32 blockPage=(block<<6);
  527.     int i;
  529.     NFConDone16=0;
  530.     rNFCONT|=(1<<9); //Enable RnB Interrupt
  531.     rNFCONT|=(1<<10); //Enable Illegal Access Interrupt
  532.     pISR_NFCON= (unsigned)NFCon_Int16;
  533.     rSRCPND=BIT_NFCON;
  534.     rINTMSK=~(BIT_NFCON);
  536. #if BAD_CHECK
  537.     if(NF16_IsBadBlock(block))
  538. return FAIL;
  539. #endif
  541. NF_nFCE_L();
  542.     
  543. NF_CMD(0x60);   // Erase one block 1st command, Block Addr:A11-A27
  544. // Address 3-cycle
  545. NF_ADDR(blockPage&0xff);     // A[18:11]
  546. NF_ADDR((blockPage>>8)&0xff);   // A[26:19]
  547. NF_ADDR((blockPage>>16)&0xff); // A27
  550. NF_CLEAR_RB();
  551. NF_CMD(0xd0); // Erase one blcok 2nd command
  553.  while(NFConDone16==0);
  554.  rNFCONT&=~(1<<9);   // Disable RnB Interrupt
  555.  rNFCONT&=~(1<<10); // Disable Illegal Access Interrupt
  556.  if(rNFSTAT&0x8) return FAIL;
  557.  
  558. NF_CMD(0x70);   // Read status command
  560.     if (NF_RDDATA()&0x1) // Erase error
  561.     {
  562.      NF_nFCE_H();
  563. Uart_Printf("[ERASE_ERROR:block#=%d]n",block);
  564. // NF16_MarkBadBlock(block);
  565. return FAIL;
  566.     }
  567.     else 
  568.     {
  569.      NF_nFCE_H();
  570.         return OK;
  571.     }
  572. }
  574. void __irq NFCon_Int16(void)
  575. {
  576.        NFConDone16=1;
  577. rINTMSK|=BIT_NFCON;
  578. ClearPending(BIT_NFCON);
  579. if(rNFSTAT&0x8) Uart_Printf("Illegal Access is detected!!!n");
  581.   }
  585. static int NF16_IsBadBlock(U32 block)
  586. {
  587.     int i;
  588.     unsigned int blockPage;
  589.     U32 bad_block_data;
  590.     
  591.     
  592.     blockPage=(block<<6); // For 2'nd cycle I/O[7:5] 
  593.     
  594. NF_nFCE_L();
  596. NF_CLEAR_RB();
  598. NF_CMD(0x00);  // read command
  599. NF_ADDR((1024+0)&0xff); // 2060 = 0x080c
  600. NF_ADDR(((1024+0)>>8)&0xff); // A[10:8]
  601. NF_ADDR((blockPage)&0xff); // A[11;18]
  602. NF_ADDR((blockPage>>8)&0xff); // A[26:19]
  603. NF_ADDR((blockPage>>16)&0xff); // A27
  604. NF_CMD(0x30); // 2'nd command
  605. NF_DETECT_RB();  // Wait tR(max 12us)
  607.     bad_block_data=NF_RDDATA();  // mark bad block at first word of spare area
  609. NF_nFCE_H();    
  611.        if(bad_block_data!=0xffffffff)
  612.     {
  613.      Uart_Printf("[ block %d has been marked as a bad block(%x)]n",block,bad_block_data);
  614.      return FAIL;
  615.     }
  616.     else
  617.     {
  618.       return OK;
  619.     }
  620. }
  623. static int NF16_MarkBadBlock(U32 block)
  624. {
  625.      int i;
  626.      U32 blockPage=(block<<6);
  628. se16Buf[0]=BAD_MARK;   // Bad blcok mark=0x4444
  629.    
  630.     
  631. NF_nFCE_L(); 
  632. NF_CMD(0x80);   // Write 1st command
  634. NF_ADDR((1024+0)&0xff); // 2060 = 0x080c
  635. NF_ADDR(((1024+0)>>8)&0xff); // A[10:8]
  636. NF_ADDR((blockPage)&0xff); // A[11;18]
  637. NF_ADDR((blockPage>>8)&0xff); // A[26:19]
  638. NF_ADDR((blockPage>>16)&0xff); // A[27]
  640. NF_WRDATA(se16Buf[0]); // Write Bad block information
  642. NF_CLEAR_RB();
  643. NF_CMD(0x10);   // Write 2nd command
  644. NF_DETECT_RB();
  646. NF_CMD(0x70);
  647.     
  648. for(i=0;i<3;i++);  //twhr=60ns////??????
  649.     
  650.     if (NF_RDDATA()&0x1) // Spare arrray write error
  651.     {
  652.      NF_nFCE_H();
  653.      Uart_Printf("[Program error is occurred but ignored]n");
  654.     }
  655.     else 
  656.     {
  657.      NF_nFCE_H();
  658.     }
  660.     Uart_Printf("[block #%d is marked as a bad block]n",block);
  661.     return OK;
  662. }
  665. static int NF16_ReadPage(U32 block,U32 page,U32 *buffer)
  666. {
  667.     int i;
  668.     unsigned int blockPage;
  669.     U32 ecc_low,ecc_high;
  670.     U32 Mecc0, Mecc1, Secc;
  671.     U16 ecc0, ecc1, ecc2, ecc3;
  672.     U32 *bufPt=buffer;
  673.     U32 se[16];    
  674.     
  675.     blockPage=(block<<6)+page;
  677.     NF_RSTECC();    // Initialize ECC
  678.     NF_MECC_UnLock();
  679.     
  680.     NF_nFCE_L();    
  682.     NF_CLEAR_RB();
  683.     NF_CMD(0x00); // Read command
  684.     NF_ADDR(0);  // Column (A[7:0]) = 0
  685.     NF_ADDR(0); // A[10:8]
  686.     NF_ADDR((blockPage)&0xff); // A[18:11]
  687.     NF_ADDR((blockPage>>8)&0xff); // A[26:19]
  688.     NF_ADDR((blockPage>>16)&0xff);  // A27
  689.     NF_CMD(0x30); // 2'nd command
  690.     NF_DETECT_RB();
  692. #if TRANS_MODE16==C_LANG
  693.     for(i=0;i<512;i++) {
  694.      *bufPt++=NF_RDDATA(); // Read one page
  695.     }
  696. #elif TRANS_MODE16==DMA
  697. // Nand to memory dma setting
  698.     rSRCPND=BIT_DMA0; // Init DMA src pending.
  699.     rDISRC0=NFDATA;  // Nand flash data register
  700.     rDISRCC0=(0<<0) | (1<<0); //arc=AHB,src_addr=fix
  701.     rDIDST0=(unsigned)bufPt;
  702.     rDIDSTC0=(0<<1) | (0<<0); //dst=AHB,dst_addr=inc;
  703.     rDCON0=(1<<31)|(1<<30)|(1<<29)|(1<<28)|(1<<27)|(0<<23)|(1<<22)|(2<<20)|(2048/4/4);
  704. //Handshake,AHB,interrupt,(4-burst),whole,S/W,no_autoreload,word,count=128;
  706. // DMA on and start.
  707.     rDMASKTRIG0=(1<<1)|(1<<0);
  709. while(!(rSRCPND & BIT_DMA0)); // Wait until Dma transfer is done.
  710.     rSRCPND=BIT_DMA0;
  711. #endif
  713.     NF_MECC_Lock();
  716.  // ECC check by hardware
  717.    
  718.    NF16_Spare_Data[0]=NF_RDDATA();  // Bad block Information
  719.    NF_SECC_UnLock();
  720.    Mecc0=NF_RDDATA();
  721.    Mecc1=NF_RDDATA();
  722.    NF_SECC_Lock();
  723.    
  724.    rNFMECCD0=((Mecc1&0xff00)<<16)|((Mecc0&0xff00)<<8)|((Mecc1&0xff)<<8)|((Mecc0&0xff));
  725.    rNFMECCD1=(Mecc1&0xff000000)|((Mecc0&0xff000000)>>8)|((Mecc1&0xff0000)>>8)|((Mecc0&0xff0000)>>16);
  726.   
  727.    NF16_Spare_Data[1]=Mecc0;
  728.    NF16_Spare_Data[2]=Mecc1;
  729.    NF16_Spare_Data[3]=NF_RDDATA();
  731.    Secc=NF_RDDATA();
  732.    rNFSECCD=(Secc&0xff000000)|((Secc&0xff0000)>>8)|((Secc&0xff00)<<8)|(Secc&0xff);
  733.   
  734.    NF16_Spare_Data[4]=Secc;
  736.    for(i=5;i<16;i++) {
  737.      NF16_Spare_Data[i]=NF_RDDATA(); // Read spare array with 4byte width
  738.        }
  739.   
  740.     NF_nFCE_H();    
  742.    if (((rNFESTAT0&0xf) == 0x0) &&((rNFESTAT1&0xf) == 0x0)){
  743.        Uart_Printf("ECC OK !!!n");
  744.        return OK;
  745.        }
  746.     else {
  747. Uart_Printf("ECC FAIL !!!n");
  748. return FAIL;
  749.      }
  751.  
  752. }
  756. static int NF16_WritePage(U32 block,U32 page,U32 *buffer)
  757. {
  758.     int i;
  759.     U32 blockPage,Mecc0, Mecc1, Secc;
  760.     U32 *bufPt=buffer;
  762. blockPage=(block<<6)+page;
  764. NF_RSTECC(); // Initialize ECC
  765.        NF_MECC_UnLock();
  766.    
  767. NF_nFCE_L(); 
  768. NF_CMD(0x80);   // Write 1st command
  769. NF_ADDR(0);  // Column (A[7:0]) = 0
  770. NF_ADDR(0); // A[10:8]
  771. NF_ADDR((blockPage)&0xff); // A[18:11]
  772. NF_ADDR((blockPage>>8)&0xff); // A[26:19]
  773. NF_ADDR((blockPage>>16)&0xff);  // A7
  775. // Write page data.
  777. #if TRANS_MODE16==C_LANG
  778. for(i=0;i<512;i++) {
  779. NF_WRDATA(*bufPt++); // Write one page to NFM from buffer
  780. }
  781. #elif TRANS_MODE16==DMA
  782. // Memory to Nand dma setting
  783. rSRCPND=BIT_DMA0; // Init DMA src pending.
  784. rDISRC0=(unsigned)bufPt; // Nand flash data register
  785. rDISRCC0=(0<<1) | (0<<0); //arc=AHB,src_addr=inc
  786. rDIDST0=NFDATA;
  787. rDIDSTC0=(0<<1) | (1<<0); //dst=AHB,dst_addr=fix;
  788. rDCON0=(1<<31)|(1<<30)|(1<<29)|(0<<28)|(1<<27)|(0<<23)|(1<<22)|(2<<20)|(2048/4);
  789. //Handshake,AHB,interrupt,unit,whole,S/W,no_autoreload,word,count=128;
  791. // DMA on and start.
  792. rDMASKTRIG0=(1<<1)|(1<<0);
  794. while(!(rSRCPND & BIT_DMA0)); // Wait until Dma transfer is done.
  795. rSRCPND=BIT_DMA0;
  796. #endif
  798.    NF_MECC_Lock();
  800.    se16Buf[0]=0xffffffff; // Marking good block(lower 16-bit is valid)
  801.    NF_WRDATA(se16Buf[0]); // Write spare array(ECC and Mark)
  802.    NF16_Spare_Data[0]=se16Buf[0];
  804.    se16Buf[1]=rNFMECC0;
  805.    se16Buf[2]=rNFMECC1;
  806.   
  808.     
  809.   // check spare ecc
  810.     NF_SECC_UnLock();
  811.     for(i=1;i<3;i++) {
  812. NF_WRDATA(se16Buf[i]); // Write spare array(ECC and Mark)
  813. NF16_Spare_Data[i]=se16Buf[i];
  814.       }  
  815.     NF_SECC_Lock();
  816.  
  817.     Secc=rNFSECC;
  818.     se16Buf[4]=Secc;
  819.    
  820.     for(i=3;i<16;i++) {
  821. NF_WRDATA(se16Buf[i]); // Write spare array(ECC and Mark)
  822. NF16_Spare_Data[i]=se16Buf[i];
  823.       }    
  824.     NF_CLEAR_RB();
  825.     NF_CMD(0x10);  // Write 2nd command
  826. #if 1
  827.        NF_DETECT_RB();
  828. #else
  829.        while(!((rNFSTAT&0x4)||(rNFSTAT&0x8)));
  831. if(rNFSTAT&0x8){
  832. Uart_Printf("Illegal Access is detected!!!n");
  833.               return FAIL;
  834. }
  835. #endif
  836. NF_CMD(0x70);   // Read status command   
  837.     
  838. for(i=0;i<3;i++);  //twhr=60ns
  839.     
  840.     if (NF_RDDATA()&0x1) {// Page write error
  841.      NF_nFCE_H();
  842. Uart_Printf("[PROGRAM_ERROR:block#=%d]n",block);
  843. NF16_MarkBadBlock(block);
  844. return FAIL;
  845.     } else {
  846.      NF_nFCE_H();
  847. return OK;
  848. }
  851. }
  855. static U32 NF16_CheckId(void)
  856. {
  857.     int i;
  858.     U32 id;
  859.     U16 id1, id2, id3, id4;
  860.     
  861. NF_nFCE_L();
  863. NF_CLEAR_RB();
  864. NF_CMD(0x90);
  865. NF_ADDR(0x0);
  866. for (i=0; i<10; i++);
  868. //read by halfword !!!
  869. id1 = NF_RDDATA16(); // read 4byte.
  870. id2 = NF_RDDATA16();
  871. id3 = NF_RDDATA16();
  872. id4 = NF_RDDATA16();
  874. id=((id4<<24)|(id3<<16)|(id2<<8)|id1);
  876.   NF_nFCE_H();
  878.     return id;
  879. }
  883. static void NF16_Init(void)
  884. {
  885. // for S3C2440
  887. rNFCONF = (TACLS<<12)|(TWRPH0<<8)|(TWRPH1<<4)|(1<<0);
  888. // TACLS [14:12] CLE&ALE duration = HCLK*TACLS.
  889. // TWRPH0 [10:8] TWRPH0 duration = HCLK*(TWRPH0+1)
  890. // TWRPH1 [6:4] TWRPH1 duration = HCLK*(TWRPH1+1)
  891. // AdvFlash(R) [3] Advanced NAND, 0:256/512, 1:1024/2048
  892. // PageSize(R) [2] NAND memory page size
  893. // when [3]==0, 0:256, 1:512 bytes/page.
  894. // when [3]==1, 0:1024, 1:2048 bytes/page.
  895. // AddrCycle(R) [1] NAND flash addr size
  896. // when [3]==0, 0:3-addr, 1:4-addr.
  897. // when [3]==1, 0:4-addr, 1:5-addr.
  898. // BusWidth(R/W) [0] NAND bus width. 0:8-bit, 1:16-bit.
  900. rNFCONT = (0<<13)|(0<<12)|(0<<10)|(0<<9)|(0<<8)|(1<<6)|(1<<5)|(1<<4)|(1<<1)|(1<<0);
  901. // Lock-tight [13] 0:Disable lock, 1:Enable lock.
  902. // Soft Lock [12] 0:Disable lock, 1:Enable lock.
  903. // EnablillegalAcINT[10] Illegal access interupt control. 0:Disable, 1:Enable
  904. // EnbRnBINT [9] RnB interrupt. 0:Disable, 1:Enable
  905. // RnB_TrandMode[8] RnB transition detection config. 0:Low to High, 1:High to Low
  906. // SpareECCLock [6] 0:Unlock, 1:Lock
  907. // MainECCLock [5] 0:Unlock, 1:Lock
  908. // InitECC(W) [4] 1:Init ECC decoder/encoder.
  909. // Reg_nCE [1] 0:nFCE=0, 1:nFCE=1.
  910. // NANDC Enable [0] operating mode. 0:Disable, 1:Enable.
  912. // rNFSTAT = 0;
  913.     
  914. //    Nand_Reset();
  915. }