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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > Windows CE > 查看源码
fmd.cpp
资源名称：SMDK2440.rar　[点击查看]
上传用户：qiulin1960
上传日期：2013-10-16
资源大小：2844k
文件大小：38k
源码类别：

Windows CE

开发平台：

Windows_Unix

fmd.cpp：源码内容
  1. /*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2. THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
  3. ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
  4. THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
  5. PARTICULAR PURPOSE.
  6. Copyright (c) 2002  Microsoft Corporation
  8. Module Name: FMD.CPP
  10. Abstract: FLASH Media Driver Interface Samsung K9F2808UOB NAND Flash Chip
  11.                 on AT-Rise development board.
  13. Notes: Currently, *only* the CE 3.0 (and earlier) power management logic
  14. is implemented (i.e. the PowerUp() and PowerDown() APIs).
  16. Environment: As noted, this media driver works on behalf of the FAL to directly
  17. access the underlying FLASH hardware.  Consquently, this module
  18. needs to be linked with FAL.LIB to produce the device driver
  19. named FLASHDRV.DLL.
  21. -----------------------------------------------------------------------------*/
  22. #include <fmd.h>
  24. //#ifdef CEDAR_ONLY
  25. #ifndef NOSYSCALL
  26. // #include "utldrv.h"
  27. #include <nkintr.h>
  28. #include "oalintr.h"
  29. #endif
  30. //#endif // CEDAR_ONLY
  32. #ifdef NOBINFS
  33. #include "utldrv.h" // Still needed for driver->driver fast method calling in 4.x
  34. #endif
  36. #include <s2440.h>
  37. #include "cfnand.h"
  38. #include "loader.h"
  40. #ifndef NOSYSCALL
  41. #ifndef BOOT_LOADER
  42. // #define USENANDDMA 1
  43. // #define USESETKMODE 1
  44. // #define NAND_BUFFER_LENG 512
  45. #endif
  46. #endif
  48. #ifdef NOBINFS
  49. //#ifdef CEDAR_ONLY // Still needed in 4.x
  50. //  Globals
  51. HANDLE          g_hUTLObject = NULL;
  52. UTL_FASTCALL    g_tblFastCall;
  53. //#endif // CEDAR_ONLY
  54. #endif 
  56. // Globals needed for updatexip
  57. HANDLE g_hMutex = NULL;
  59. // BUGBUG: For now, we always will take the mutex
  60. BOOL g_bTakeMutex = TRUE;
  62. void GRABMUTEX();
  63. void RELEASEMUTEX();
  65. #ifdef NOSYSCALL
  66. #ifndef BOOT_LOADER
  67. // function prototypes for kernel functions
  68. extern "C"
  69. {
  70. HANDLE SC_CreateMutex(LPSECURITY_ATTRIBUTES lpsa, BOOL bInitialOwner, LPCTSTR lpName);
  71. DWORD SC_WaitForMultiple(DWORD cObjects, CONST HANDLE *lphObjects, BOOL fWaitAll, DWORD dwTimeout);
  72. BOOL SC_ReleaseMutex(HANDLE hMutex);
  73. BOOL SC_CloseHandle(HANDLE hObj);
  74. }
  75. #endif
  76. #endif
  78. //  Use Macros here to avoid extra over head for c function calls
  79. #define READ_REGISTER_BYTE(p) (*(volatile PBYTE) (p))
  80. #define WRITE_REGISTER_BYTE(p, v) (*(volatile PBYTE)(p)) = (v)
  81. #define READ_REGISTER_USHORT(p) (*(volatile PUSHORT) (p))
  82. #define WRITE_REGISTER_USHORT(p, v) (*(volatile PUSHORT)(p)) = (v)
  83. #define READ_REGISTER_ULONG(p)  (*(volatile PULONG) (p))
  84. #define WRITE_REGISTER_ULONG(p, v) (*(volatile PULONG)(p)) = (v)
  86. //  Registers
  87. volatile PUSHORT pNFReg;
  88. volatile PUSHORT pNFCONF;
  89. volatile PUSHORT pNFCONT;
  90. volatile PUSHORT pNFCMD;
  91. volatile PUSHORT pNFADDR;
  92. volatile PULONG  pNFDATA;
  93. volatile PUSHORT pNFSTAT;
  94. volatile PULONG  pNFECC;
  95. volatile CLKPWRreg *v_s2440CLKPWR;
  96. volatile DMAreg *v_pDMAregs;
  97. volatile INTreg *v_pINTregs;    
  99. #define NFDATA 0x4E000010
  101. // Event
  102. HANDLE gDMA3IntrEvent;
  103. PBYTE pDMABuffer;
  105. //  Status bit pattern
  106. #define STATUS_READY                0x40
  107. #define STATUS_ERROR                0x01
  109. // HCLK=133Mhz
  110. #define TACLS 0
  111. #define TWRPH0 6
  112. #define TWRPH1 2
  114. //  MACROS
  115. #define NF_CE_L() WRITE_REGISTER_USHORT(pNFCONT, (USHORT) (READ_REGISTER_USHORT(pNFCONT) & ~(1<<1)))
  116. #define NF_CE_H() WRITE_REGISTER_USHORT(pNFCONT, (USHORT) (READ_REGISTER_USHORT(pNFCONT) | (1<<1)))
  117. #define NF_CMD(cmd) WRITE_REGISTER_USHORT(pNFCMD, (USHORT) (cmd))
  118. #define NF_ADDR(addr) WRITE_REGISTER_USHORT(pNFADDR, (USHORT) (addr))
  119. #define NF_DATA_R() READ_REGISTER_BYTE(pNFDATA)
  120. #define NF_DATA_W(val) WRITE_REGISTER_BYTE(pNFDATA, (BYTE) (val))
  121. #define NF_DATA_R4() READ_REGISTER_ULONG(pNFDATA)
  122. #define NF_DATA_W4(val) WRITE_REGISTER_ULONG(pNFDATA, (ULONG) (val))
  123. #define NF_STAT() READ_REGISTER_USHORT(pNFSTAT)
  124. #define NF_MECC_UnLock() WRITE_REGISTER_USHORT(pNFCONT, (USHORT) (READ_REGISTER_USHORT(pNFCONT) & ~(1<<5)))
  125. #define NF_MECC_Lock() WRITE_REGISTER_USHORT(pNFCONT, (USHORT) (READ_REGISTER_USHORT(pNFCONT) | (1<<5)))
  126. #define NF_RSTECC() WRITE_REGISTER_USHORT(pNFCONT, (USHORT) (READ_REGISTER_USHORT(pNFCONT) | (1<<4)))
  127. #define NF_WAITRB() {while(!(NF_STAT() & (1<<1))) ;}
  128. #define NF_CLEAR_RB() WRITE_REGISTER_USHORT(pNFSTAT, (USHORT) (READ_REGISTER_USHORT(pNFSTAT) | (1<<2)))
  129. #define NF_DETECT_RB() {while(!(NF_STAT() & (1<<2)));}
  130. #define NF_ECC() READ_REGISTER_ULONG(pNFECC)
  132. //  External function
  133. extern "C" {
  134. BOOL ECC_CorrectData(LPBYTE pData, LPBYTE pExistingECC, LPBYTE pNewECC);
  135. }
  137. //  Flags and pointers
  138. #define BADBLOCKMARK                0x00
  139. //  VALIDADDR is 5 << 8
  140. //
  141. //  Explain:    5 means the 6th byte in spare area (517 byte in the sector)
  142. //              Shift 8 bit to the left to form the correct address for 16bit port
  143. //
  144. #define VALIDADDR   0x05
  146. #define OEMADDR 0x04 // 5th byte in spare area
  148. #ifdef CEDAR_ONLY
  149. void PowerOnCallback()
  150. {
  151.     DEBUGMSG(1, (TEXT("FlashDrv::FMD:: Come back form Power Off!n")));
  152. }
  153. #endif // CEDAR_ONLY
  155. //  Reset the chip
  156. //
  157. void NF_Reset()
  158. {
  159. int i;
  160.     GRABMUTEX();
  161.     NF_CE_L();
  163. NF_CLEAR_RB();
  164.     NF_CMD(CMD_RESET);
  165. for(i=0;i<10;i++);  //tWB = 100ns. //??????
  167.     NF_CE_H();
  168.     RELEASEMUTEX();
  169. }
  171. /*
  172.  Here is the statement from SamSung's K9F2808U0B datasheet:
  174.  All device locations are erased (FFh) except location where the invalid block(s)
  175.  information is written prior to shipping. The invalid block(s) status is defined
  176.  by the 6th byte in the spare area. Samsung makes sure that either the 1st or 2nd
  177.  page of every invalid block has non-FFh data at the column address of 517. Since
  178.  the invalid block information is also erasable in most cases, it is impossible to
  179.  recover the information once it has been erased.
  181.  Here is the logic we are taking:
  183.  If the block is invalid, non-FFh value in column address of 517, we don't use that
  184.  block anyway. Otherwise, the whole spare area is subject to use by our program. If
  185.  we found additional bad block later on, we don't necessary have to use column 517
  186.  to represent invalid block. We could use any of the 16 byte spare area.
  188.  But for simplicity, in our current implementation, we avoid to touch column 517. So
  189.  the we allocate SectorInfo as following:
  191.   - - - - - - - - - - - - - - - -
  192.  |R|R|R|R|O|V|R|R|E|E|E|E|E|E|E|E|
  193.   - - - - - - - - - - - - - - - -
  195.  Where  Rs are reserved bytes used by the FAL
  196.         O is a byte for use by the OEM
  197.         V is a byte indicating if the block is valid (a.k.a. bad)
  198.         Es are bytes used for ECC
  200.  */
  202. /*
  203.  *  NAND_ReadSectorInfo
  204.  *
  205.  *  Read SectorInfo out of the spare area. The current implementation only handles
  206.  *  one sector at a time.
  207.  */
  208. void NAND_ReadSectorInfo(SECTOR_ADDR sectorAddr, PSectorInfo pInfo)
  209. {
  210. // RETAILMSG(1, (TEXT("FlashDrv!FMD!NAND_ReadSectorInfo:  rn")));
  211.     GRABMUTEX();
  212.     
  213.     //  Chip enable
  214.     NF_CE_L();
  215. NF_CLEAR_RB();
  217.     //  Write the command
  218.     NF_CMD(CMD_READ2);
  220.     //  Write the address
  221.     NF_ADDR(0x00);
  222.     NF_ADDR(sectorAddr & 0xff);
  223.     NF_ADDR((sectorAddr >> 8) & 0xff);
  225.     if (NEED_EXT_ADDR) {
  226.         NF_ADDR((sectorAddr >> 16) & 0xff);
  227.     }
  229. // RETAILMSG(1, (TEXT("sectorAddr : %x rn"), sectorAddr));
  230.     //  Wait for the Ready bit
  231. NF_DETECT_RB();  // Wait tR(max 12us)
  233.     //  Read the SectorInfo data (we only need to read first 8 bytes)
  234.     pInfo->dwReserved1  = NF_DATA_R4();
  235. // RETAILMSG(1, (TEXT("pInfo->dwReserved1 = %xrn"), pInfo->dwReserved1));
  237.     //  OEM byte
  238.     pInfo->bOEMReserved = (BYTE) NF_DATA_R();
  239. // RETAILMSG(1, (TEXT("pInfo->bOEMReserved = %xrn"), pInfo->bOEMReserved));
  241.     //  Read the bad block mark
  242.     pInfo->bBadBlock = (BYTE) NF_DATA_R();
  243. // RETAILMSG(1, (TEXT("pInfo->bBadBlock = %xrn"), pInfo->bBadBlock));
  245.     //  Second reserved field (WORD)
  246.     pInfo->wReserved2 = ((BYTE) NF_DATA_R() << 8);
  247.     pInfo->wReserved2 |= ((BYTE) NF_DATA_R());
  248. // RETAILMSG(1, (TEXT("pInfo->wReserved2 = %xrn"), pInfo->wReserved2));
  249. // RETAILMSG(1, (TEXT("rn")));
  251.     NF_CE_H();
  253.     RELEASEMUTEX();
  254. }
  256. /*
  257.  *  NAND_WriteSectorInfo
  258.  *
  259.  *  Write SectorInfo out to the spare area. The current implementation only handles
  260.  *  one sector at a time.
  261.  */
  262. BOOL NAND_WriteSectorInfo(SECTOR_ADDR sectorAddr, PSectorInfo pInfo)
  263. {
  264.     BOOL    bRet = TRUE;
  266. // RETAILMSG(1, (TEXT("FlashDrv!FMD!NAND_WriteSectorInfo:  rn")));
  267.     GRABMUTEX();
  269.     //  Chip enable
  270.     NF_CE_L();
  271. NF_CLEAR_RB();
  273.     //  Write the command
  274.     //  First, let's point to the spare area
  275.     NF_CMD(CMD_READ2);
  276.     NF_CMD(CMD_WRITE);
  278.     //  Write the address
  279.     NF_ADDR(0x00);
  280.     NF_ADDR(sectorAddr & 0xff);
  281.     NF_ADDR((sectorAddr >> 8) & 0xff);
  283.     if (NEED_EXT_ADDR) {
  284.         NF_ADDR((sectorAddr >> 16) & 0xff);
  285.     }
  287.     //  Now let's write the SectorInfo data
  288.     //
  289.     //  Write the first reserved field (DWORD)
  290.     NF_DATA_W4( pInfo->dwReserved1 );
  292.     //  Write OEM reserved flag
  293.     NF_DATA_W( (pInfo->bOEMReserved) );
  295.     //  Write the bad block flag
  296.     NF_DATA_W( (pInfo->bBadBlock) );
  298.     //  Write the second reserved field
  299.     NF_DATA_W( (pInfo->wReserved2 >> 8) & 0xff );
  300.     NF_DATA_W( (pInfo->wReserved2) );
  302.     //  Issue the write complete command
  303.     NF_CMD(CMD_WRITE2);
  305.     //  Check ready bit
  306. NF_DETECT_RB();  // Wait tR(max 12us)
  308.     //  Check the status of program
  309.     NF_CMD(CMD_STATUS);
  311.     if(NF_DATA_R() & STATUS_ERROR) {
  312.         RETAILMSG(1, (TEXT("NAND_WriteSectorInfo() ######## Error Programming page %d!n"), sectorAddr));
  313.         bRet = FALSE;
  314.     }
  316.     NF_CE_H();
  318.     RELEASEMUTEX();
  319.     return bRet;
  320. }
  322. /*-----------------------------------------------------------------------------
  323.  *  FMD Interface functions
  324.  *
  325.  *----------------------------------------------------------------------------*/
  326. //  FMD_Init
  327. //
  328. //  Initialize the flash chip
  329. //
  330. //  Note: Presently, the Flash size characteristics are hardcoded in CFNAND.H
  331. //   and are NOT stored in the registry.  Refer to the StratFlash FMD in
  332. //   %WINCEROOT%PUBLICCOMMONOAKDRIVERSBLOCK... for an example of how
  333. //   to use the registry for storing this information.
  334. //
  335. PVOID FMD_Init(LPCTSTR lpActiveReg, PPCI_REG_INFO pRegIn, PPCI_REG_INFO pRegOut)
  336. {
  337. RETAILMSG(1, (TEXT("FMD::FMD_Initrn")));
  338.     //  0. Create the Mutex for shared access between the kernel and MSFLASH
  339. #ifndef BOOT_LOADER
  340.     if (g_hMutex == NULL)
  341.     {
  342. #ifdef NOSYSCALL
  343. #ifndef BOOT_LOADER
  344.         g_hMutex = SC_CreateMutex(NULL, FALSE, TEXT("_FLASH_MUTEX_"));
  345. #endif
  346. #else
  347.         g_hMutex = CreateMutex(NULL, FALSE, TEXT("_FLASH_MUTEX_"));
  348. #endif
  349.         // was mutex creation successful?
  350.         if (g_hMutex == NULL) 
  351.         {
  352.             RETAILMSG(1,(TEXT("FlashDrv!FMD!FMD_Init: Unable to create mutexrn")));
  353.             goto ErrExit;
  354.         }
  355.     }
  356. #endif
  357.     
  358. #ifndef NOSYSCALL
  359. #ifdef NOBINFS
  360.     DWORD dwBytes;
  362.     //  Initialize the FASTCALL structure to 0
  363.     memset(&g_tblFastCall, 0, sizeof(UTL_FASTCALL));
  365.     //  1. CreateFile to get the access to UTLDRV.
  366.     //
  367.     g_hUTLObject = CreateFile(TEXT("UTL0:"), GENERIC_READ|GENERIC_WRITE,
  368.                                 FILE_SHARE_READ|FILE_SHARE_WRITE,
  369.                                 NULL, OPEN_EXISTING, 0, 0);
  371.     if(INVALID_HANDLE_VALUE == g_hUTLObject) {
  372.         RETAILMSG(1, (TEXT("Failed CreateFile -- error = 0x%xn"), GetLastError()));
  373.         goto ErrExit;
  374.     }
  376.     //  2. Call IOCTL to get the FAST CALL function pointer.
  377.     //
  378.     if(!DeviceIoControl(g_hUTLObject,
  379.                         IOCTL_UTL_GET_FASTCALL,
  380.                         NULL, 0,
  381.                         &g_tblFastCall, sizeof(g_tblFastCall),
  382.                         &dwBytes, NULL)) {
  383.         RETAILMSG(1, (TEXT("Failed DeviceIoControl -- error = 0x%xn"), GetLastError()));
  384.         goto ErrExit;
  385.     }
  387.     //  3. Call the fast call to get the PVA for the registers
  388.     //
  389.     //  3.1 Get the register for NAND controller
  390.     if (ERROR_SUCCESS != g_tblFastCall.GetRegisterVA(g_tblFastCall.pContext, NFC_BASE,
  391.                                      32, FALSE, (DWORD *)&pNFReg) ) {
  392.         RETAILMSG(1, (TEXT("FlashDrv!FMD!FMD_Init: Failed GetRegisterVA(NFC_BASE) call!n")));
  393.         goto ErrExit;
  394.     }
  396.     //  3.2 Get the register for the CLKPWR register
  397.     if (ERROR_SUCCESS != g_tblFastCall.GetRegisterVA(g_tblFastCall.pContext, CLKPWR_BASE,
  398.                                      32, FALSE, (DWORD *)&v_s2440CLKPWR) ) {
  399.         RETAILMSG(1, (TEXT("FlashDrv!FMD!FMD_Init: Failed GetRegisterVA(CLKPWR_BASE) call!n")));
  400.         goto ErrExit;
  401.     }
  402. #ifdef CEDAR_ONLY
  403.     // ++ CE 3.0 Specific Code. Not needed for 4.x +
  405.     //  4. Register the Block driver to the Power On Monitor
  406.     //
  407.     if (ERROR_SUCCESS != g_tblFastCall.RegisterBlockDrv(g_tblFastCall.pContext,
  408.                                                         PowerOnCallback)) {
  409.         RETAILMSG(1, (TEXT("Failed RegisterStorageDrv -- error = 0x%xn"), GetLastError()));
  410.         goto ErrExit;
  411.     }
  413.     // -- CE 3.0 Specific Code. Not needed for 4.x +
  414. #endif // CEDAR_ONLY
  415. #else
  416. // RETAILMSG(1, (TEXT("FMD::FMD_Init:VirtualAlloc rn")));
  417.     pNFReg = (PUSHORT) VirtualAlloc(0, 0x1000, MEM_RESERVE, PAGE_NOACCESS);
  419.     if(!pNFReg) {
  420.         RETAILMSG(1, (TEXT("FlashDrv!FMD!FMD_Init: Failed VirtualAlloc ... Bailing out!n")));
  421.         goto ErrExit;
  422.     }
  424.     if(!VirtualCopy(pNFReg, (LPVOID) NFC_BASE, 0x1000, 
  425.                     PAGE_READWRITE|PAGE_NOCACHE)) {
  426.         RETAILMSG(1, (TEXT("FlashDrv!FMD!FMD_Init: Failed VirtualCopy for MemCtrl!n")));
  427.         goto ErrExit;
  428.     }
  430.     //  Allocate for the clock control register
  432.     //  Clock control register
  433.     v_s2440CLKPWR = (CLKPWRreg *)VirtualAlloc(NULL, 0x1000, MEM_RESERVE, PAGE_NOACCESS);
  434.     ASSERT(v_s2440CLKPWR);
  436.     if (!VirtualCopy((LPVOID) v_s2440CLKPWR, (LPVOID) CLKPWR_BASE, 0x1000,
  437.                      PAGE_READWRITE | PAGE_NOCACHE)) {
  438.         RETAILMSG(1, (TEXT("FlashDrv!FMD!FMD_Init: VirtualCopy (v_s2440CLKPWR) failed!rn")));
  439.         goto ErrExit;
  440.     }
  442. #ifdef USENANDDMA
  443. // From HMSEO
  444. // DMA Virtual alloc
  445. v_pDMAregs = (volatile DMAreg *) VirtualAlloc(0,sizeof(DMAreg),MEM_RESERVE, PAGE_NOACCESS);
  446.     ASSERT(v_pDMAregs);
  448. if(!VirtualCopy((PVOID)v_pDMAregs,(PVOID)(DMA_BASE),sizeof(DMAreg),
  449. PAGE_READWRITE | PAGE_NOCACHE )) {
  450. ERRORMSG(1,(TEXT("For s2440DMA: VirtualCopy failed!rn")));
  451.         goto ErrExit;
  452. }
  454. // Allocate DMA buffer
  455. pDMABuffer = (unsigned char *)VirtualAlloc(0, NAND_BUFFER_LENG, MEM_RESERVE, PAGE_NOACCESS);
  456.     ASSERT(pDMABuffer);
  457.                                   
  458. if(!VirtualCopy(pDMABuffer,
  459. (PVOID)NAND_DMA_BUFFER_BASE,
  460. NAND_BUFFER_LENG,
  461. PAGE_READWRITE | PAGE_NOCACHE) )
  462. {
  463. ERRORMSG(1,(TEXT("For s2440DMA: DMABuffer VirtualCopy failed!rn")));
  464.         goto ErrExit;
  465.     }
  467. #ifndef USESETKMODE
  468. // allocate the interrupt event for DMA
  469. gDMA3IntrEvent = CreateEvent(NULL, FALSE, FALSE,NULL);
  471. if (NULL == gDMA3IntrEvent) {
  472. ERRORMSG(1,(TEXT("For s2440DMA: CreateEvent failed!rn")));
  473.         goto ErrExit;
  474. }
  475.     
  476. if (!InterruptInitialize (SYSINTR_DMA3, gDMA3IntrEvent,NULL,0)) {
  477. ERRORMSG(1,(TEXT("For s2440DMA: InterruptInitialize failed!rn")));
  478.         goto ErrExit;
  479. }
  480. #else
  481.     v_pINTregs = (volatile INTreg *) VirtualAlloc(0,sizeof(INTreg),MEM_RESERVE, PAGE_NOACCESS);
  482.     ASSERT(v_pINTregs);
  484. if(!VirtualCopy((PVOID)v_pINTregs,(PVOID)(INT_BASE),sizeof(INTreg),
  485.     PAGE_READWRITE | PAGE_NOCACHE ))
  486. {
  487. ERRORMSG(1,(TEXT("For INTreg: VirtualCopy failed!rn")));
  488.         goto ErrExit;
  489.     }
  490. #endif USESETKMODE
  491. // End HMSEO
  492. #endif USENANDDMA
  493. #endif // NOBINFS
  495. #else
  496.     pNFReg = (PUSHORT) (NFC_BASE | 0x20000000);
  497.     v_s2440CLKPWR = (CLKPWRreg *) ( CLKPWR_BASE | 0x20000000 );
  498. #endif
  500.     //  Enable the clock to NAND controller
  501.     v_s2440CLKPWR->rCLKCON |= (1<<4);
  503. // RETAILMSG(1, (TEXT("FlashDrv!FMD!FMD_Init: pNFReg = %x rn"), pNFReg));
  505.     pNFCONF = pNFReg;
  506.     pNFCONT = (PUSHORT) ((PBYTE) pNFReg + 0x04);
  507.     pNFCMD  = (PUSHORT) ((PBYTE) pNFReg + 0x08);
  508.     pNFADDR = (PUSHORT) ((PBYTE) pNFReg + 0x0C);
  509.     pNFDATA = (PULONG) ((PBYTE) pNFReg + 0x10);
  510.     pNFSTAT = (PUSHORT) ((PBYTE) pNFReg + 0x20);
  511.     pNFECC  = (PULONG)  ((PBYTE) pNFReg + 0x2C);
  513.     //  Now we need enable the NAND Flash controller
  514.     GRABMUTEX();
  515.     WRITE_REGISTER_USHORT(pNFCONF, (TACLS<<12)|(TWRPH0<<8)|(TWRPH1<<4)|(0<<0));
  516.     WRITE_REGISTER_USHORT(pNFCONT, (0<<13)|(0<<12)|(0<<10)|(0<<9)|(0<<8)|(0<<6)|(0<<5)|(1<<4)|(1<<1)|(1<<0));
  517.     WRITE_REGISTER_USHORT(pNFSTAT, 0);
  518.     RELEASEMUTEX();
  520. // NF_Reset();
  522. RETAILMSG(1, (TEXT("FMD::FMD_Init Donern")));
  524.     return (PVOID)pNFCONF;
  526. ErrExit:
  527.     FMD_Deinit((PVOID)pNFCONF);
  528.     return 0;
  529. }
  531. //  FMD_Deinit
  532. //
  533. //  De-initialize the flash chip
  534. //
  535. BOOL    FMD_Deinit(PVOID hFMD)
  536. {
  537. if((DWORD)hFMD != (DWORD)pNFCONF)
  538. {
  539. return FALSE;
  540. }
  542. // destroy the mutex
  543. if (g_hMutex)
  544. {
  545. #ifdef NOSYSCALL
  546. #ifndef BOOT_LOADER
  547.         SC_CloseHandle(g_hMutex);
  548. #endif
  549. #else
  550.         CloseHandle(g_hMutex);
  551. #endif
  552. }
  554. #ifndef NOSYSCALL
  555. #ifdef NOBINFS
  556.     //  We don't have to free pNFReg and clock register.
  557. #ifdef CEDAR_ONLY
  558.     // ++ CE 3.0 Specific Code. Not needed for 4.x +
  559.     if (g_tblFastCall.UnRegisterBlockDrv) {
  560.         g_tblFastCall.UnRegisterBlockDrv(g_tblFastCall.pContext, PowerOnCallback);
  561.     }
  562.     // -- CE 3.0 Specific Code. Not needed for 4.x +
  563. #endif // CEDAR_ONLY
  565.     //  Close the handle
  566.     if (g_hUTLObject) {
  567.         CloseHandle(g_hUTLObject);
  568.     }
  569. #else
  570.     if(pNFReg) {
  571.         VirtualFree(pNFReg, 0, MEM_RELEASE);
  572.     }
  574.     if(v_s2440CLKPWR) {
  575.         VirtualFree((LPVOID)v_s2440CLKPWR, 0, MEM_RELEASE);
  576.     }
  577. #endif // NOBINFS
  579. #endif
  580.     return TRUE;
  581. }
  583. //  FMD_GetInfo
  584. //
  585. //  Return the Flash information
  586. //
  587. BOOL    FMD_GetInfo(PFlashInfo pFlashInfo)
  588. {
  589.     pFlashInfo->flashType = NAND;
  591.     //  OK, instead of reading it from the chip, we use the hardcoded
  592.     //  numbers here.
  594.     pFlashInfo->dwNumBlocks = NUM_BLOCKS;
  595.     pFlashInfo->wSectorsPerBlock = PAGES_PER_BLOCK;
  596.     pFlashInfo->wDataBytesPerSector = SECTOR_SIZE;
  598.     return TRUE;
  599. }
  601. //  FMD_ReadSector
  602. //
  603. //  Read the content of the sector.
  604. //
  605. //  startSectorAddr: Starting page address
  606. //  pSectorBuff  : Buffer for the data portion
  607. //  pSectorInfoBuff: Buffer for Sector Info structure
  608. //  dwNumSectors : Number of sectors
  609. //
  611. typedef union _ECCRegVal
  612. {
  613.     DWORD   dwECCVal;
  614.     BYTE    bECCBuf[4];
  615. } ECCRegVal;
  617. BOOL FMD_ReadSector(SECTOR_ADDR startSectorAddr, LPBYTE pSectorBuff,
  618.                         PSectorInfo pSectorInfoBuff, DWORD dwNumSectors)
  619. {
  620.     DWORD       i;
  621.     BYTE        eccBuf[8];
  622.     ECCRegVal   eccRegVal;
  624. // RETAILMSG(1, (TEXT("FlashDrv!FMD!FMD_ReadSector:  startSectorAddr = %x rn"), startSectorAddr));
  625.     //  Sanity check
  626.     if (!pSectorBuff && !pSectorInfoBuff || dwNumSectors > 1) {
  627. #ifdef BOOT_LOADER
  628.         EdbgOutputDebugString("Invalid parameters!rn");
  629. #else
  630.         RETAILMSG(1, (TEXT("Invalid parameters!n")));
  631. #endif
  632. #ifndef NOSYSCALL
  633.         SetLastError(ERROR_INVALID_PARAMETER);
  634. #endif
  635.         return FALSE;
  636.     }
  638. NF_Reset();
  640.     if(!pSectorBuff) {
  641.         //  We are reading spare only
  642.         NAND_ReadSectorInfo(startSectorAddr, pSectorInfoBuff);
  644.         //  There is no ECC for the sector info, so the read always succeed.
  645.         return TRUE;
  646.     }
  648. // RETAILMSG(1, (TEXT("FlashDrv!FMD!FMD_ReadSector:  startSectorAddr = %x rn"), startSectorAddr));
  650. GRABMUTEX();
  652. //  Initialize ECC register
  653. NF_RSTECC();
  654. NF_MECC_UnLock();
  656. //  Enable the chip
  657. NF_CE_L();
  658. NF_CLEAR_RB();
  660. //  Issue command
  661. NF_CMD(CMD_READ);
  663. //  Set up address
  664. NF_ADDR(0x00);
  665. NF_ADDR((startSectorAddr) & 0xff);
  666. NF_ADDR((startSectorAddr >> 8) & 0xff);
  668. if (NEED_EXT_ADDR) {
  669. NF_ADDR((startSectorAddr >> 16) & 0xff);
  670. }
  672. NF_DETECT_RB();  // Wait tR(max 12us)
  674. //  BUGBUG, because Media Player for Pocket PC sometimes pass us un-aligned buffer
  675. //  we have to waste cycle here to work around this problem
  676. if( ((DWORD) pSectorBuff) & 0x3) {
  677. for(i=0; i<SECTOR_SIZE; i++) {
  678. pSectorBuff[i] = (BYTE) NF_DATA_R();
  679. }
  680. }
  681. else {
  682. //  The right way.
  683. #ifndef USENANDDMA
  684. ReadPage512(pSectorBuff, pNFDATA);
  685. #else // USENANDDMA
  686. #ifdef USESETKMODE
  687. SetKMode(TRUE);
  688. v_pINTregs->rSRCPND=BIT_DMA3; // Init DMA src pending.
  689. #endif // USESETKMODE
  690. // Nand to memory dma setting
  691. v_pDMAregs->rDISRC3  = (unsigned int)NFDATA;  // Nand flash data register
  692. v_pDMAregs->rDISRCC3 = (0<<1) | (1<<0); //arc=AHB,src_addr=fix
  693. v_pDMAregs->rDIDST3  = (int)NAND_DMA_BUFFER_PHYS;
  694. v_pDMAregs->rDIDSTC3 = (0<<1) | (0<<0); //dst=AHB,dst_addr=inc;
  695. v_pDMAregs->rDCON3   = (1<<31)|(1<<30)|(1<<29)|(1<<28)|(1<<27)|(0<<23)|(1<<22)|(2<<20)|(512/4/4);
  696. //Handshake,AHB,interrupt,(4-burst),whole,S/W,no_autoreload,word,count=128;
  698. // DMA on and start.
  699. v_pDMAregs->rDMASKTRIG3 = (1<<1)|(1<<0);
  700. #ifndef USESETKMODE
  701. WaitForSingleObject(gDMA3IntrEvent, INFINITE);
  702. InterruptDone(SYSINTR_DMA3);
  703. #else // USESETKMODE
  704. while(!(v_pINTregs->rSRCPND & BIT_DMA3)); // Wait until Dma transfer is done.
  705. v_pINTregs->rSRCPND=BIT_DMA3;
  706. SetKMode(FALSE);
  707. #endif // USESETKMODE
  708. memcpy(pSectorBuff, pDMABuffer, 512);
  709. #endif // USENANDDMA
  710.     }
  712. /*
  713. for ( i = 0 ; i < 512; i++ )
  714. #ifdef BOOT_LOADER
  715.         EdbgOutputDebugString("%x ", *(pSectorBuff+i));
  716. #else
  717.         RETAILMSG(1, (TEXT("%x "), *(pSectorBuff+i)));
  718. #endif
  719. */
  721.     //  Do the ECC thing here
  722.     //  We read the ECC value from the ECC register pFNECC
  723. NF_MECC_Lock();
  724.     eccRegVal.dwECCVal = NF_ECC();
  726.     //  Read the SectorInfo data
  727.     if(pSectorInfoBuff) {
  728.         //  Read the SectorInfo data (we only need to read first 8 bytes)
  729.         pSectorInfoBuff->dwReserved1  = NF_DATA_R4();
  731.         //  OEM byte
  732.         pSectorInfoBuff->bOEMReserved = (BYTE) NF_DATA_R();
  734.         //  Read the bad block mark
  735.         pSectorInfoBuff->bBadBlock = (BYTE) NF_DATA_R();
  737.         //  Second reserved field (WORD)
  738.         pSectorInfoBuff->wReserved2 = ((BYTE) NF_DATA_R() << 8);
  739.         pSectorInfoBuff->wReserved2 |= ((BYTE) NF_DATA_R());
  740.     }
  741.     else {
  742.         //  Advance the read pointer
  743.         for(i=0; i<sizeof(SectorInfo); i++) {
  744.             eccBuf[i] = (BYTE) NF_DATA_R();
  745.         }
  746.     }
  748.     //  Verify the ECC values
  749.     //
  750.     //  Read the ECC buffer
  751.     for(i=0; i<3; i++) {
  752.         eccBuf[i] = (BYTE) NF_DATA_R();
  753.     }
  755.     NF_CE_H();
  757.     //  Copmare with the ECC generated from the HW
  759.     if(eccBuf[0] != eccRegVal.bECCBuf[0] ||
  760.        eccBuf[1] != eccRegVal.bECCBuf[1]  ||
  761.        eccBuf[2] != eccRegVal.bECCBuf[2] ) {
  763. #ifdef BOOT_LOADER
  764.         EdbgOutputDebugString("FMD: ECC ERROR - Page #: %drn", startSectorAddr);
  765.         EdbgOutputDebugString("(%x:%x %x:%x %x:%x)rn", eccBuf[0], eccRegVal.bECCBuf[0], eccBuf[1], eccRegVal.bECCBuf[1], eccBuf[2], eccRegVal.bECCBuf[2]);
  766. #else
  767.         RETAILMSG(1, (TEXT("FMD: ECC ERROR - Page #: %drn"), startSectorAddr));
  768. #endif
  770.         //  Now try to correct them
  771.         if(!ECC_CorrectData(pSectorBuff, eccBuf, eccRegVal.bECCBuf)) {
  772.             RETAILMSG(1, (TEXT("FMD: Unable to correct the ECC error - Page #: %drn"),
  773.                           startSectorAddr));
  774.             RELEASEMUTEX();
  775. return FALSE;
  776.         }
  777.     }
  779.     RELEASEMUTEX();
  780.     return TRUE;
  781. }
  783. //
  784. //  IsBlockBad
  785. //
  786. //  Check to see if the given block is bad. A block is bad if the 517th byte on
  787. //  the first or second page is not 0xff.
  788. //
  789. //  blockID:    The block address. We need to convert this to page address
  790. //
  791. //
  792. BOOL IsBlockBad(BLOCK_ID blockID)
  793. {
  794.     DWORD   dwPageID = blockID << 5;
  795.     BOOL    bRet = FALSE;
  796.     BYTE    wFlag;
  798.     GRABMUTEX();
  800.     //  Enable the chip
  801.     NF_CE_L();
  802. NF_CLEAR_RB();
  804.     //  Issue the command
  805.     NF_CMD(CMD_READ2);
  807.     //  Set up address
  808.     NF_ADDR(VALIDADDR);
  809.     NF_ADDR((dwPageID) & 0xff);
  810.     NF_ADDR((dwPageID >> 8) & 0xff);
  812.     if (NEED_EXT_ADDR) {
  813.         NF_ADDR((dwPageID >> 16) & 0xff);
  814.     }
  816.     //  Wait for Ready bit
  817. NF_DETECT_RB();  // Wait tR(max 12us)
  819.     //  Now get the byte we want
  820.     wFlag = (BYTE) NF_DATA_R();
  822.     if(wFlag != 0xff) {
  823.         bRet = TRUE;
  824.     }
  826.     //  Disable the chip
  827.     NF_CE_H();
  829.     RELEASEMUTEX();
  830.     return bRet;
  831. }
  833. //
  834. //  FMD_GetBlockStatus
  835. //
  836. //  Returns the status of a block.  The status information is stored in the spare area of the first sector for
  837. //  the respective block.
  838. //
  839. //  A block is BAD if the bBadBlock byte on the first page is not equal to 0xff.
  840. //
  841. DWORD FMD_GetBlockStatus(BLOCK_ID blockID)
  842. {
  843.     SECTOR_ADDR sectorAddr = blockID << LOG_2_PAGES_PER_BLOCK;
  844.     SectorInfo SI;
  845.     DWORD dwResult = 0;
  847. if(!FMD_ReadSector(sectorAddr, NULL, &SI, 1))
  848. {
  849.         return BLOCK_STATUS_UNKNOWN;
  850. }
  852.     if(!(SI.bOEMReserved & OEM_BLOCK_READONLY))
  853. {
  854.         dwResult |= BLOCK_STATUS_READONLY;
  855. }
  857.     if(SI.bBadBlock != 0xFF)
  858. {
  859.         dwResult |= BLOCK_STATUS_BAD;
  860. }
  862.     return dwResult;
  863. }
  868. //  FMD_EraseBlock
  869. //
  870. //  Erase the given block
  871. //
  872. BOOL FMD_EraseBlock(BLOCK_ID blockID)
  873. {
  874.     BOOL    bRet = TRUE;
  875.     DWORD   dwPageID = blockID << 5;
  877.     GRABMUTEX();
  879. #ifndef NOSYSCALL
  880. if(blockID < IMAGE_START_BLOCK)
  881. {
  882. bRet = FALSE;
  883. RELEASEMUTEX();
  884. return bRet;
  885. }
  886. #endif
  887.     //  Enable the chip
  888.     NF_CE_L();
  889. NF_CLEAR_RB();
  891.     //  Issue command
  892.     NF_CMD(CMD_ERASE);
  894.     //  Set up address
  895.     NF_ADDR((dwPageID) & 0xff);
  896.     NF_ADDR((dwPageID >> 8) & 0xff);
  898.     if (NEED_EXT_ADDR) {
  899.         NF_ADDR((dwPageID >> 16) & 0xff);
  900.     }
  902.     //  Complete erase operation
  903.     NF_CMD(CMD_ERASE2);
  905.     //  Wait for ready bit
  906. NF_DETECT_RB();  // Wait tR(max 12us)
  908.     //  Check the status
  909.     NF_CMD(CMD_STATUS);
  911.     if(NF_DATA_R() & STATUS_ERROR) {
  912.         RETAILMSG(1, (TEXT("######## Error Erasing block %d!n"), blockID));
  913.         bRet = FALSE;
  914.     }
  916.     NF_CE_H();
  918.     RELEASEMUTEX();
  920.     return bRet;
  921. }
  925. //  FMD_WriteSector
  926. //
  927. //  Write dwNumPages pages to the startSectorAddr
  928. //
  929. BOOL FMD_WriteSector(SECTOR_ADDR startSectorAddr, LPBYTE pSectorBuff, PSectorInfo pSectorInfoBuff,
  930.                         DWORD dwNumSectors)
  931. {
  932.     DWORD   i;
  933.     BOOL    bRet = TRUE;
  934.     DWORD   dwECCVal;
  935.     BYTE    eccBuf[4];
  937. // RETAILMSG(1, (TEXT("FlashDrv!FMD!FMD_WriteSector:  rn")));
  938.     //  Sanity check
  939.     //  BUGBUGBUG: I need to come back to support dwNumSectors > 1
  940.     //
  941.     if((!pSectorBuff && !pSectorInfoBuff) || dwNumSectors != 1) {
  942. #ifdef BOOT_LOADER
  943.         EdbgOutputDebugString("Invalid parameters!rn");
  944. #else
  945.         RETAILMSG(1, (TEXT("Invalid parameters!n")));
  946. #endif
  947. #ifndef NOSYSCALL
  948.         SetLastError(ERROR_INVALID_PARAMETER);
  949. #endif
  950.         return FALSE;
  951.     }
  953. NF_Reset();
  955.     if(!pSectorBuff) {
  956.         //  If we are asked just to write the SectorInfo, we will do that separately
  957.         bRet = NAND_WriteSectorInfo(startSectorAddr, pSectorInfoBuff);
  958. return bRet; // Do not write the actual sector information...
  959.     }
  961.     GRABMUTEX();
  963.     //  Initialize ECC register
  964.     NF_RSTECC();
  965. NF_MECC_UnLock();
  967.     //  Enable Chip
  968.     NF_CE_L();
  970.     //  Issue command
  971.     NF_CMD(CMD_READ);
  972.     NF_CMD(CMD_WRITE);
  974.     //  Setup address
  975.     NF_ADDR(0x00);
  976.     NF_ADDR((startSectorAddr) & 0xff);
  977.     NF_ADDR((startSectorAddr >> 8) & 0xff);
  979.     if (NEED_EXT_ADDR) {
  980.         NF_ADDR((startSectorAddr >> 16) & 0xff);
  981.     }
  983.     //  Special case to handle un-aligned buffer pointer.
  984.     //
  985.     if( ((DWORD) pSectorBuff) & 0x3) {
  986.         //  Write the data
  987.         for(i=0; i<SECTOR_SIZE; i++) {
  988.             NF_DATA_W(pSectorBuff[i]);
  989.         }
  990.     }
  991.     else {
  992. #ifndef USENANDDMA
  993.         WritePage512(pSectorBuff, pNFDATA);
  994. #else // USENANDDMA
  995. #ifdef USESETKMODE
  996. SetKMode(TRUE);
  997. v_pINTregs->rSRCPND=BIT_DMA3; // Init DMA src pending.
  998. #endif // USESETKMODE
  999. memcpy(pDMABuffer, pSectorBuff, 512);
  1000. // Nand to memory dma setting
  1001.     v_pDMAregs->rDISRC3  = (int)SDI_DMA_BUFFER_PHYS;  // Nand flash data register
  1002.     v_pDMAregs->rDISRCC3 = (0<<1) | (0<<0); //arc=AHB,src_addr=inc
  1003.     v_pDMAregs->rDIDST3  = (int)NFDATA;
  1004.     v_pDMAregs->rDIDSTC3 = (0<<1) | (1<<0); //dst=AHB,dst_addr=fix;
  1005.     v_pDMAregs->rDCON3   = (1<<31)|(1<<30)|(1<<29)|(0<<28)|(1<<27)|(0<<23)|(1<<22)|(2<<20)|(512/4);
  1006. //  only unit transfer in writing!!!!
  1007. //Handshake,AHB,interrupt,(unit),whole,S/W,no_autoreload,word,count=128;
  1009. // DMA on and start.
  1010.     v_pDMAregs->rDMASKTRIG3 = (1<<1)|(1<<0);
  1012. #ifndef USESETKMODE
  1013. WaitForSingleObject(gDMA3IntrEvent, INFINITE);
  1014. InterruptDone(SYSINTR_DMA3);
  1015. #else // USESETKMODE
  1016. while(!(v_pINTregs->rSRCPND & BIT_DMA3)); // Wait until Dma transfer is done.
  1017. v_pINTregs->rSRCPND=BIT_DMA3;
  1018. SetKMode(FALSE);
  1019. #endif // USESETKMODE
  1020. #endif // USENANDDMA
  1021.     }
  1023.     //  Read out the ECC value generated by HW
  1024. NF_MECC_Lock();
  1025.     dwECCVal = NF_ECC();
  1027. // Write the SectorInfo data to the media
  1028. // NOTE: This hardware is odd: only a byte can be written at a time and it must reside in the
  1029. //       upper byte of a USHORT.
  1030. if(pSectorInfoBuff)
  1031. {
  1032.         //  Write the first reserved field (DWORD)
  1033.         NF_DATA_W4(pSectorInfoBuff->dwReserved1);
  1035.         //  Write OEM reserved flag
  1036.         NF_DATA_W( (pSectorInfoBuff->bOEMReserved) );
  1038.         //  Write the bad block flag
  1039.         NF_DATA_W( (pSectorInfoBuff->bBadBlock) );
  1041.         //  Write the second reserved field
  1042.         NF_DATA_W( (pSectorInfoBuff->wReserved2 >> 8) & 0xff );
  1043.         NF_DATA_W( (pSectorInfoBuff->wReserved2) & 0xff );
  1045. }else
  1046. {
  1047. // Make sure we advance the Flash's write pointer (even though we aren't writing the SectorInfo data)
  1048. for(i=0; i<sizeof(SectorInfo); i++)
  1049. {
  1050.             NF_DATA_W(0xff);
  1051. }
  1052. }
  1054.     //  ECC stuff should be here
  1055.     eccBuf[0] = (BYTE) ((dwECCVal) & 0xff);
  1056.     eccBuf[1] = (BYTE) ((dwECCVal >> 8) & 0xff);
  1057.     eccBuf[2] = (BYTE) ((dwECCVal >> 16) & 0xff);
  1059.     //  Write the ECC value to the flash
  1060.     for(i=0; i<3; i++) {
  1061.         NF_DATA_W(eccBuf[i]);
  1062.     }
  1064.     for(i=0; i<5; i++) {
  1065.         NF_DATA_W(0xff);
  1066.     }
  1068. NF_CLEAR_RB();
  1069.     //  Finish up the write operation
  1070.     NF_CMD(CMD_WRITE2);
  1072.     //  Wait for RB
  1073. NF_DETECT_RB();  // Wait tR(max 12us)
  1075.     //  Check the status
  1076.     NF_CMD(CMD_STATUS);
  1078.     if(NF_DATA_R() & STATUS_ERROR) {
  1079. #ifdef BOOT_LOADER
  1080.         EdbgOutputDebugString("FMD_WriteSector() ######## Error Programming page %d!rn", startSectorAddr);
  1081. #else
  1082.         RETAILMSG(1, (TEXT("FMD_WriteSector() ######## Error Programming page %d!n"), startSectorAddr));
  1083. #endif
  1084.         bRet = FALSE;
  1085.     }
  1087.     //  Disable the chip
  1088.     NF_CE_H();
  1090.     RELEASEMUTEX();
  1091.     return bRet;
  1092. }
  1094. /*
  1095.  *  MarkBlockBad
  1096.  *
  1097.  *  Mark the block as a bad block. We need to write a 00 to the 517th byte
  1098.  */
  1100. BOOL MarkBlockBad(BLOCK_ID blockID)
  1101. {
  1102.     DWORD   dwStartPage = blockID << 5;
  1103.     BOOL    bRet = TRUE;
  1105.     GRABMUTEX();
  1107.     //  Enable chip
  1108.     NF_CE_L();
  1109. NF_CLEAR_RB();
  1111.     //  Issue command
  1112.     //  We are dealing with spare area
  1113.     NF_CMD(CMD_READ2);
  1114.     NF_CMD(CMD_WRITE);
  1116.     //  Set up address
  1117.     NF_ADDR(VALIDADDR);
  1118.     NF_ADDR((dwStartPage) & 0xff);
  1119.     NF_ADDR((dwStartPage >> 8) & 0xff);
  1120.     if (NEED_EXT_ADDR) {
  1121.         NF_ADDR((dwStartPage >> 16) & 0xff);
  1122.     }
  1124.     NF_DATA_W(BADBLOCKMARK);
  1126.     //  Copmlete the write
  1127.     NF_CMD(CMD_WRITE2);
  1129.     //  Wait for RB
  1130. NF_DETECT_RB();  // Wait tR(max 12us)
  1132.     //  Get the status
  1133.     NF_CMD(CMD_STATUS);
  1135.     if(NF_DATA_R() &  STATUS_ERROR) {
  1136.         RETAILMSG(1, (TEXT("######## Failed to mark the block bad!n")));
  1137.         bRet = FALSE;
  1138.     }
  1140.     //  Disable chip select
  1141.     NF_CE_H();
  1143.     RELEASEMUTEX();
  1144.     return bRet;
  1145. }
  1147. //
  1148. //  FMD_SetBlockStatus
  1149. //
  1150. //  Sets the status of a block.  Only implement for bad blocks for now.
  1151. //  Returns TRUE if no errors in setting.
  1152. //
  1153. BOOL FMD_SetBlockStatus(BLOCK_ID blockID, DWORD dwStatus)
  1154. {
  1155.     SECTOR_ADDR sectorAddr = blockID << LOG_2_PAGES_PER_BLOCK;
  1156. BYTE bStatus = 0;
  1158.     if(dwStatus & BLOCK_STATUS_BAD)
  1159. {
  1160.         if(!MarkBlockBad (blockID))
  1161.         {
  1162.             return FALSE;
  1163.         }
  1164.     }
  1166.     // We don't currently support setting a block to read-only, so fail if request is
  1167.     // for read-only and block is not currently read-only.
  1168.     if(dwStatus & BLOCK_STATUS_READONLY)
  1169. {
  1170.         if(!(FMD_GetBlockStatus(blockID) & BLOCK_STATUS_READONLY))
  1171.         {
  1172.             return FALSE;
  1173.         }
  1174.     }
  1176.     return TRUE;
  1177. }
  1181. #ifndef NOSYSCALL
  1182. //  We don't have to build the following interface functions for the
  1183. //  bootloader.
  1184. //
  1186. //  FMD_PowerUp
  1187. //
  1188. //  Performs any necessary powerup procedures...
  1189. //
  1190. VOID FMD_PowerUp(VOID)
  1191. {
  1192.     if (v_s2440CLKPWR && pNFCONF) {
  1193.         //  Enable the clock to NAND controller
  1194.         v_s2440CLKPWR->rCLKCON |= (1<<4);
  1196.         //  Reinit the NAND controller
  1197.         GRABMUTEX();
  1198. WRITE_REGISTER_USHORT(pNFCONF, (TACLS<<12)|(TWRPH0<<8)|(TWRPH1<<4)|(0<<0));
  1199. WRITE_REGISTER_USHORT(pNFCONT, (0<<13)|(0<<12)|(0<<10)|(0<<9)|(0<<8)|(0<<6)|(0<<5)|(1<<4)|(1<<1)|(1<<0));
  1200. WRITE_REGISTER_USHORT(pNFSTAT, 0);
  1201.         RELEASEMUTEX();
  1202.         
  1203.         //  Reset the controller
  1204.         NF_Reset();
  1205. #ifdef CEDAR_ONLY
  1206.         // ++ CE 3.0 Specific Code. Not needed for 4.x +
  1207.         SetInterruptEvent(SYSINTR_POWERON);
  1208.         // -- CE 3.0 Specific Code. Not needed for 4.x +
  1209. #endif // CEDAR_ONLY
  1210.     }
  1211. }
  1214. //  FMD_PowerDown
  1215. //
  1216. //  Performs any necessary powerdown procedures...
  1217. //
  1218. VOID FMD_PowerDown(VOID)
  1219. {
  1220.     if (v_s2440CLKPWR) {
  1221.         //  Disable the clock to NAND controller
  1222.         v_s2440CLKPWR->rCLKCON &= ~(1<<4);
  1223.     }
  1224. }
  1227. //  FMD_OEMIoControl
  1228. //
  1229. //  Used for any OEM defined IOCTL operations
  1230. //
  1231. BOOL  FMD_OEMIoControl(DWORD dwIoControlCode, PBYTE pInBuf, DWORD nInBufSize,
  1232.                        PBYTE pOutBuf, DWORD nOutBufSize, PDWORD pBytesReturned)
  1233. {
  1234.     switch(dwIoControlCode)
  1235.     {
  1236.         case IOCTL_FMD_UPDATEXIP_BEGIN:
  1237.             g_bTakeMutex = TRUE;
  1238.             break;
  1239.             
  1240.         case IOCTL_FMD_UPDATEXIP_END:
  1241.             g_bTakeMutex = FALSE;
  1242.             break;
  1243.             
  1244.         default:
  1245.         RETAILMSG(1, (TEXT("FMD::FMD_OEMIoControl = 0x%xn"), dwIoControlCode));
  1246.             return FALSE;
  1247.     }
  1248. return TRUE;
  1249. }
  1251. #endif // NOSYSCALL
  1255. //------------------------------- Private Interface (NOT used by the FAL) --------------------------
  1257. //  FMD_GetOEMReservedByte
  1258. //
  1259. //  Retrieves the OEM reserved byte (for metadata) for the specified physical sector.
  1260. //
  1261. //
  1262. BOOL FMD_GetOEMReservedByte(SECTOR_ADDR physicalSectorAddr, PBYTE pOEMReserved)
  1263. {
  1264.     GRABMUTEX();
  1265.     
  1266.     //  Enable chip select
  1267.     NF_CE_L();
  1268. NF_CLEAR_RB();
  1270.     //  Issue command
  1271.     NF_CMD(CMD_READ2);
  1273.     //  Set up address
  1274.     NF_ADDR(OEMADDR);
  1275.     NF_ADDR((physicalSectorAddr) & 0xff);
  1276.     NF_ADDR((physicalSectorAddr >> 8) & 0xff);
  1278.     if (NEED_EXT_ADDR) {
  1279.         NF_ADDR((physicalSectorAddr >> 16) & 0xff);
  1280.     }
  1282.     //  Wait for the ready bit
  1283. NF_DETECT_RB();  // Wait tR(max 12us)
  1285.     //  Read the data
  1286.     *pOEMReserved = (BYTE) NF_DATA_R();
  1288.     //  Disable chip select
  1289.     NF_CE_H();
  1291.     RELEASEMUTEX();
  1292. return TRUE;
  1294. }
  1297. //  FMD_SetOEMReservedByte
  1298. //
  1299. //  Sets the OEM reserved byte (for metadata) for the specified physical sector.
  1300. //
  1301. BOOL FMD_SetOEMReservedByte(SECTOR_ADDR physicalSectorAddr, BYTE bOEMReserved)
  1302. {
  1303.     BOOL    bRet = TRUE;
  1305.     GRABMUTEX();
  1307.     //  Enable chip select
  1308.     NF_CE_L();
  1309. NF_CLEAR_RB();
  1311.     //  Issue command
  1312.     NF_CMD(CMD_READ2);
  1313.     NF_CMD(CMD_WRITE);
  1315.     //  Set up address
  1316.     NF_ADDR(OEMADDR);
  1317.     NF_ADDR((physicalSectorAddr) & 0xff);
  1318.     NF_ADDR((physicalSectorAddr >> 8) & 0xff);
  1320.     if (NEED_EXT_ADDR) {
  1321.         NF_ADDR((physicalSectorAddr >> 16) & 0xff);
  1322.     }
  1324.     //  Write the data
  1325.     NF_DATA_W(bOEMReserved);
  1327.     //  Complete the write
  1328.     NF_CMD(CMD_WRITE2);
  1330.     //  Wait for the ready bit
  1331. NF_DETECT_RB();  // Wait tR(max 12us)
  1333.     //  Read the status
  1334.     NF_CMD(CMD_STATUS);
  1336.     //  Check the status
  1337.     if(NF_DATA_R() & STATUS_ERROR) {
  1338.         RETAILMSG(1, (TEXT("######## Failed to set OEM Reserved byte!n")));
  1339.         bRet = FALSE;
  1340.     }
  1342.     //  Disable chip select
  1343.     NF_CE_H();
  1345.     RELEASEMUTEX();
  1346.     return bRet;
  1347. }
  1349. //---------------------------------------- Helper Functions ----------------------------------------
  1351. //  Interface function for testing purpose.
  1352. //
  1353. BOOL FMD_ReadSpare(DWORD dwStartPage, LPBYTE pBuff, DWORD dwNumPages)
  1354. {
  1355.     DWORD   i, n;
  1357.     GRABMUTEX();
  1359.     //  Enable chip select
  1360.     NF_CE_L();
  1361. NF_CLEAR_RB();
  1363.     //  Issue command
  1364.     NF_CMD(CMD_READ2);
  1366.     //  Set up address
  1367.     NF_ADDR(0x00);
  1368.     NF_ADDR((dwStartPage) & 0xff);
  1369.     NF_ADDR((dwStartPage >> 8) & 0xff);
  1371.     if (NEED_EXT_ADDR) {
  1372.         NF_ADDR((dwStartPage >> 16) & 0xff);
  1373.     }
  1375.     //  Wait for Ready bit
  1376. NF_DETECT_RB();  // Wait tR(max 12us)
  1378.     //  Now read out the data
  1379.     for(n=0; n<dwNumPages; n++) {
  1380.         //  Read the spare area
  1381.         for(i=0; i<16; i++) {
  1382.             pBuff[n*16+i] = (BYTE) NF_DATA_R();
  1383.         }
  1385. NF_DETECT_RB();  // Wait tR(max 12us)
  1386.     }
  1388.     NF_CE_H();
  1390.     RELEASEMUTEX();
  1391.     return TRUE;
  1392. }
  1394. void GRABMUTEX()
  1395. {
  1396. #ifdef NOSYSCALL
  1397. #ifndef BOOT_LOADER
  1398.     // we're in the kernel - always SC_WaitForMultiple
  1399.     SC_WaitForMultiple(1, &g_hMutex, TRUE, INFINITE);
  1400. #endif
  1401. #else
  1402.     if (g_bTakeMutex) {
  1403.         // we can do a normal WaitForSingleObject
  1404.         WaitForSingleObject(g_hMutex, INFINITE);
  1405.     }
  1406. #endif
  1407. }
  1409. void RELEASEMUTEX()
  1410. {
  1411. #ifdef NOSYSCALL
  1412. #ifndef BOOT_LOADER
  1413.     SC_ReleaseMutex(g_hMutex);
  1414. #endif
  1415. #else
  1416.     if (g_bTakeMutex) {
  1417.         ReleaseMutex(g_hMutex);
  1418.     }
  1419. #endif
  1420. }