This week only. Pastebin PRO Accounts Christmas Special! Don't miss out!Want more features on Pastebin? Sign Up, it's FREE!
Guest

Untitled

By: a guest on Oct 7th, 2013  |  syntax: None  |  size: 11.05 KB  |  views: 36  |  expires: Never
download  |  raw  |  embed  |  report abuse  |  print
Text below is selected. Please press Ctrl+C to copy to your clipboard. (⌘+C on Mac)
  1. #define FLASH_SYSTEM_FDT_CACHE_COUNT    8
  2. #define FLASH_SYSTEM_DATA_CACHE_COUNT   4
  3.  
  4. #define FLASH_DATA_FAT_CACHE_COUNT    32
  5. #define FLASH_DATA_FDT_CACHE_COUNT    8
  6. #define FLASH_DATA_DATA_CACHE_COUNT   4
  7.  
  8. #define FLASH_USER_FAT_CACHE_COUNT    32
  9. #define FLASH_USER_FDT_CACHE_COUNT    8
  10. #define FLASH_USER_DATA_CACHE_COUNT   4
  11.  
  12. uint8 FlashFatCacheBuf[FLASH_SYSTEM_FAT_CACHE_COUNT][512];
  13. uint8 FlashFdtCacheBuf[FLASH_SYSTEM_FDT_CACHE_COUNT][512];
  14. uint8 FlashDataCacheBuf[FLASH_SYSTEM_DATA_CACHE_COUNT][512];
  15.  
  16. FS_CACHE_DATA FLASH_FatCacheData[FLASH_SYSTEM_FAT_CACHE_COUNT];
  17. FS_CACHE_DATA FLASH_FdtCacheData[FLASH_SYSTEM_FDT_CACHE_COUNT];
  18. FS_CACHE_DATA FLASH_DataCacheData[FLASH_SYSTEM_DATA_CACHE_COUNT];
  19.  
  20. FS_CACHE    FlashFatCache = {FLASH_FatCacheData, 0, FLASH_SYSTEM_FAT_CACHE_COUNT};
  21. FS_CACHE    FlashFdtCache = {FLASH_FdtCacheData, 0, FLASH_SYSTEM_FDT_CACHE_COUNT};
  22. FS_CACHE    FlashDataCache = {FLASH_DataCacheData, 0, FLASH_SYSTEM_DATA_CACHE_COUNT};
  23.  
  24. uint8 FlashDataFatCacheBuf[FLASH_DATA_FAT_CACHE_COUNT][512];
  25. uint8 FlashDataFdtCacheBuf[FLASH_DATA_FDT_CACHE_COUNT][512];
  26. uint8 FlashDataDataCacheBuf[FLASH_DATA_DATA_CACHE_COUNT][512];
  27.  
  28. FS_CACHE_DATA FLASH_DataFatCacheData[FLASH_DATA_FAT_CACHE_COUNT];
  29. FS_CACHE_DATA FLASH_DataFdtCacheData[FLASH_DATA_FDT_CACHE_COUNT];
  30. FS_CACHE_DATA FLASH_DataDataCacheData[FLASH_DATA_DATA_CACHE_COUNT];
  31.  
  32. FS_CACHE    FlashDataFatCache = {FLASH_DataFatCacheData, 0, FLASH_DATA_FAT_CACHE_COUNT};
  33. FS_CACHE    FlashDataFdtCache = {FLASH_DataFdtCacheData, 0, FLASH_DATA_FDT_CACHE_COUNT};
  34. FS_CACHE    FlashDataDataCache = {FLASH_DataDataCacheData, 0, FLASH_DATA_DATA_CACHE_COUNT};
  35.  
  36. uint8 FlashUFatCacheBuf[FLASH_USER_FAT_CACHE_COUNT][512];
  37. uint8 FlashUFdtCacheBuf[FLASH_USER_FDT_CACHE_COUNT][512];
  38. uint8 FlashUDataCacheBuf[FLASH_USER_DATA_CACHE_COUNT][512];
  39.  
  40. FS_CACHE_DATA FLASH_UFatCacheData[FLASH_USER_FAT_CACHE_COUNT];
  41. FS_CACHE_DATA FLASH_UFdtCacheData[FLASH_USER_FDT_CACHE_COUNT];
  42. FS_CACHE_DATA FLASH_UDataCacheData[FLASH_USER_DATA_CACHE_COUNT];
  43.  
  44. FS_CACHE    FlashUFatCache = {FLASH_UFatCacheData, 0, FLASH_USER_FAT_CACHE_COUNT};
  45. FS_CACHE    FlashUFdtCache = {FLASH_UFdtCacheData, 0, FLASH_USER_FDT_CACHE_COUNT};
  46. FS_CACHE    FlashUDataCache = {FLASH_UDataCacheData, 0, FLASH_USER_DATA_CACHE_COUNT};
  47.  
  48. #ifdef SETUP
  49. // 080324,huangsl,FOR SETUP¹¤³Ì,±ê¼ÇÊÇ·ñÐèÒªµÍ¸ñ FLASH.0:²»ÐèÒªµÍ¸ñ,1:ÐèÒªµÍ¸ñ.
  50. uint16      FtlLowFormat;
  51. #endif
  52.  
  53. int FS_FlashGetStatus(void);
  54. int FS_FlashSysReadSec(uint32 LBA, uint32 SecCount, void *buf);
  55. int FS_FlashSysWriteSec(uint32 LBA, uint32 SecCount, void *buf);
  56. int FS_FlashUserReadSec(uint32 LBA, uint32 SecCount, void *buf);
  57. int FS_FlashUserWriteSec(uint32 LBA, uint32 SecCount, void *buf);
  58. int FS_FlashDataReadSec(uint32 LBA, uint32 SecCount, void *buf);
  59. int FS_FlashDataWriteSec(uint32 LBA, uint32 SecCount, void *buf);
  60. int FS_FlashSysIoCtl(uint32 cmd, uint32 arg, void *buf);
  61. int FS_FlashUserIoCtl(uint32 cmd, uint32 arg, void *buf);
  62. int FS_FlashDataIoCtl(uint32 cmd, uint32 arg, void *buf);
  63. int FS_FlashSysMediumInit(void);
  64. int FS_FlashUserMediumInit(void);
  65. int FS_FlashDataMediumInit(void);
  66. void FlashSysCacheInit(void);
  67. void FlashUserCacheInit(void);
  68. void FlashDataCacheInit(void);
  69.  
  70. const FS_DEVICE_TYPE FS_FlashSysDevice =
  71. {
  72.     "C:\\",
  73.     "SysDisk",
  74.     FS_FlashGetStatus,
  75.     FS_FlashSysReadSec,
  76.     FS_FlashSysWriteSec,
  77.     FS_FlashSysIoCtl,
  78.     FS_FlashSysMediumInit,
  79.     &FlashFatCache,
  80.     &FlashFdtCache,
  81.     &FlashDataCache
  82. };
  83.  
  84. const FS_DEVICE_TYPE FS_FlashUserDevice =
  85. {
  86.     "D:\\",
  87.     "Flash",
  88.     FS_FlashGetStatus,
  89.     FS_FlashUserReadSec,
  90.     FS_FlashUserWriteSec,
  91.     FS_FlashUserIoCtl,
  92.     FS_FlashUserMediumInit,
  93.     &FlashUFatCache,
  94.     &FlashUFdtCache,
  95.     &FlashUDataCache
  96. };
  97.  
  98. const FS_DEVICE_TYPE FS_FlashDataDevice =
  99. {
  100.     "Z:\\",
  101.     "Data",
  102.     FS_FlashGetStatus,
  103.     FS_FlashDataReadSec,
  104.     FS_FlashDataWriteSec,
  105.     FS_FlashDataIoCtl,
  106.     FS_FlashDataMediumInit,
  107.     &FlashDataFatCache,
  108.     &FlashDataFdtCache,
  109.     &FlashDataDataCache
  110. };
  111. int FS_FlashGetStatus(void)
  112. {
  113.     return(0);
  114. }
  115.  
  116. uint8 InFLashOperate = FALSE;
  117.  
  118. #if 1
  119.  
  120. int FlashDiskRead(unsigned char LUN, unsigned int Index, unsigned int nSec, void *buf)
  121. {
  122.     int sts;
  123.     RockSemObtain(&gHwI2CSem); // zyf rtcºÍflash CS 2/3»á³åÍ»£¬ÐèÒª±£»¤
  124.     InFLashOperate = TRUE;
  125.     sts = FtlRead(LUN, Index,nSec, buf);
  126.     InFLashOperate = FALSE;
  127.     RockSemRelease(&gHwI2CSem);
  128.     return sts;
  129. }
  130.  
  131. int FS_FlashSysReadSec(uint32 LBA, uint32 SecCount, void *buf)
  132. {
  133.     return((int)FlashDiskRead(DISK_NAND_CODE, LBA,SecCount, buf));
  134. }
  135.  
  136. int FS_FlashUserReadSec(uint32 LBA, uint32 SecCount, void *buf)
  137. {
  138.     return((int)FlashDiskRead(DISK_NAND_USER, LBA,SecCount, buf));
  139. }
  140.  
  141. int FS_FlashDataReadSec(uint32 LBA, uint32 SecCount, void *buf)
  142. {
  143.     return((int)FlashDiskRead(DISK_NAND_DATA, LBA,SecCount, buf));
  144. }
  145.  
  146. int FlashDiskWrite(unsigned char LUN, unsigned int Index, unsigned int nSec, void *buf)
  147. {
  148.     int sts;
  149.     RockSemObtain(&gHwI2CSem);// zyf rtcºÍflash CS 2/3»á³åÍ»£¬ÐèÒª±£»¤
  150.     InFLashOperate = TRUE;
  151.     sts = FtlWrite(LUN, Index,nSec, buf);
  152.     InFLashOperate = FALSE;
  153.     RockSemRelease(&gHwI2CSem);
  154.     return sts;
  155. }
  156.  
  157. int FS_FlashSysWriteSec(uint32 LBA, uint32 SecCount, void *buf)
  158. {
  159.     return((int)FlashDiskWrite(DISK_NAND_CODE, LBA,SecCount, buf));
  160. }
  161.  
  162. int FS_FlashUserWriteSec(uint32 LBA, uint32 SecCount, void *buf)
  163. {
  164.     return((int)FlashDiskWrite(DISK_NAND_USER, LBA,SecCount, buf));
  165. }
  166.  
  167. int FS_FlashDataWriteSec(uint32 LBA, uint32 SecCount, void *buf)
  168. {
  169.     return((int)FlashDiskWrite(DISK_NAND_DATA, LBA,SecCount, buf));
  170. }
  171.  
  172. #else
  173. int FS_FlashSysReadSec(uint32 LBA, uint32 SecCount, void *buf)
  174. {
  175.     return((int)FtlRead(DISK_NAND_CODE, LBA,SecCount, buf));
  176. }
  177.  
  178. int FS_FlashUserReadSec(uint32 LBA, uint32 SecCount, void *buf)
  179. {
  180.     return((int)FtlRead(DISK_NAND_USER, LBA,SecCount, buf));
  181. }
  182.  
  183. int FS_FlashDataReadSec(uint32 LBA, uint32 SecCount, void *buf)
  184. {
  185.     return((int)FtlRead(DISK_NAND_DATA, LBA,SecCount, buf));
  186. }
  187. int FS_FlashSysWriteSec(uint32 LBA, uint32 SecCount, void *buf)
  188. {
  189.     return((int)FtlWrite(DISK_NAND_CODE, LBA,SecCount, buf));
  190. }
  191.  
  192. int FS_FlashUserWriteSec(uint32 LBA, uint32 SecCount, void *buf)
  193. {
  194.     return((int)FtlWrite(DISK_NAND_USER, LBA,SecCount, buf));
  195. }
  196.  
  197. int FS_FlashDataWriteSec(uint32 LBA, uint32 SecCount, void *buf)
  198. {
  199.     return((int)FtlWrite(DISK_NAND_DATA, LBA,SecCount, buf));
  200. }
  201. #endif
  202.  
  203. int FS_FlashSysIoCtl(uint32 cmd, uint32 arg, void *buf)
  204. {
  205.     uint32 *rbuf;
  206.     rbuf = (uint32 *)buf;
  207.     switch (cmd)
  208.     {
  209.         case IO_CTL_GET_CAPACITY:
  210.             *rbuf = FtlGetCapacity(DISK_NAND_CODE);
  211.             break;
  212.         case IO_CTL_GET_MEDIUM_START_SEC:
  213.             *rbuf = 0;
  214.             break;
  215.         case IO_CTL_CACHE_WRITE_BACK:
  216.             //FlashCacheCloseAll();
  217.             break;
  218.         case IO_CTL_FLUSH_CACHE:
  219.             FlashSysCacheInit();
  220.             break;
  221.         default:
  222.             break;
  223.     }
  224.     return(0);
  225. }
  226.  
  227. int FS_FlashUserIoCtl(uint32 cmd, uint32 arg, void *buf)
  228. {
  229.     uint32 *rbuf;
  230.     rbuf = (uint32 *)buf;
  231.     switch (cmd)
  232.     {
  233.         case IO_CTL_GET_CAPACITY:
  234.             *rbuf =  FtlGetCapacity(DISK_NAND_USER);
  235.             break;
  236.         case IO_CTL_GET_MEDIUM_START_SEC:
  237.             *rbuf = 0;  /* Óû§Å̵ĿªÊ¼ÎªSYSTEMÅ̵ĴóС */
  238.             break;
  239.         case IO_CTL_CACHE_WRITE_BACK:
  240.             //FlashCacheCloseAll();
  241.             break;
  242.         case IO_CTL_FLUSH_CACHE:
  243.             FlashUserCacheInit();
  244.             break;
  245.         default:
  246.             break;
  247.     }
  248.     return(0);
  249. }
  250.  
  251. int FS_FlashDataIoCtl(uint32 cmd, uint32 arg, void *buf)
  252. {
  253.     uint32 *rbuf;
  254.     rbuf = (uint32 *)buf;
  255.     switch (cmd)
  256.     {
  257.         case IO_CTL_GET_CAPACITY:
  258.             *rbuf =  FtlGetCapacity(DISK_NAND_DATA);
  259.             break;
  260.         case IO_CTL_GET_MEDIUM_START_SEC:
  261.             *rbuf = 0;  /* Óû§Å̵ĿªÊ¼ÎªSYSTEMÅ̵ĴóС */
  262.             break;
  263.         case IO_CTL_CACHE_WRITE_BACK:
  264.             //FlashCacheCloseAll();
  265.             break;
  266.         case IO_CTL_FLUSH_CACHE:
  267.             FlashDataCacheInit();
  268.             break;
  269.         default:
  270.             break;
  271.     }
  272.     return(0);
  273. }
  274.  
  275.  
  276. void FlashSysCacheInit(void)
  277. {
  278.     uint32 i;
  279.     FS_CACHE_DATA *pCache;
  280.  
  281.     pCache = FlashFatCache.pCacheData;
  282.  
  283.     for (i = 0; i < FLASH_SYSTEM_FAT_CACHE_COUNT; i++)
  284.     {
  285.         pCache->flag     = 0;
  286.         pCache->pBuffer  = &FlashFatCacheBuf[i][0];
  287.         pCache->SectorNo = 0xFFFFFFFF;
  288.         pCache++;
  289.     }
  290.  
  291.     pCache = FlashFdtCache.pCacheData;
  292.  
  293.     for (i = 0; i < FLASH_SYSTEM_FDT_CACHE_COUNT; i++)
  294.     {
  295.         pCache->flag     = 0;
  296.         pCache->pBuffer  = &FlashFdtCacheBuf[i][0];
  297.         pCache->SectorNo = 0xFFFFFFFF;
  298.         pCache++;
  299.     }
  300.  
  301.     pCache = FlashDataCache.pCacheData;
  302.  
  303.     for (i = 0; i < FLASH_SYSTEM_DATA_CACHE_COUNT; i++)
  304.     {
  305.         pCache->flag     = 0;
  306.         pCache->pBuffer  = &FlashDataCacheBuf[i][0];
  307.         pCache->SectorNo = 0xFFFFFFFF;
  308.         pCache++;
  309.     }
  310. }
  311. int FS_FlashSysMediumInit(void)
  312. {
  313.     int err = 0;
  314.     FlashSysCacheInit();
  315.    
  316. //    err=(FTLInit()>1) ? -1 : 0;
  317.  
  318.     return (err);
  319. }
  320.  
  321. void FlashUserCacheInit(void)
  322. {
  323.     uint32 i;
  324.     FS_CACHE_DATA *pCache;
  325.  
  326.     pCache = FlashUFatCache.pCacheData;
  327.  
  328.     for (i = 0; i < FLASH_USER_FAT_CACHE_COUNT; i++)
  329.     {
  330.         pCache->flag     = 0;
  331.         pCache->pBuffer  = &FlashUFatCacheBuf[i][0];
  332.         pCache->SectorNo = 0xFFFFFFFF;
  333.         pCache++;
  334.     }
  335.  
  336.     pCache = FlashUFdtCache.pCacheData;
  337.  
  338.     for (i = 0; i < FLASH_USER_FDT_CACHE_COUNT; i++)
  339.     {
  340.         pCache->flag     = 0;
  341.         pCache->pBuffer  = &FlashUFdtCacheBuf[i][0];
  342.         pCache->SectorNo = 0xFFFFFFFF;
  343.         pCache++;
  344.     }
  345.  
  346.     pCache = FlashUDataCache.pCacheData;
  347.  
  348.     for (i = 0; i < FLASH_USER_DATA_CACHE_COUNT; i++)
  349.     {
  350.         pCache->flag     = 0;
  351.         pCache->pBuffer  = &FlashUDataCacheBuf[i][0];
  352.         pCache->SectorNo = 0xFFFFFFFF;
  353.         pCache++;
  354.     }
  355. }
  356.  
  357. int FS_FlashUserMediumInit(void)
  358. {
  359.     FlashUserCacheInit();
  360.     return(0);
  361. }
  362.  
  363. void FlashDataCacheInit(void)
  364. {
  365.     uint32 i;
  366.     FS_CACHE_DATA *pCache;
  367.  
  368.     pCache = FlashDataFatCache.pCacheData;
  369.  
  370.     for (i = 0; i < FLASH_DATA_FAT_CACHE_COUNT; i++)
  371.     {
  372.         pCache->flag     = 0;
  373.         pCache->pBuffer  = &FlashDataFatCacheBuf[i][0];
  374.         pCache->SectorNo = 0xFFFFFFFF;
  375.         pCache++;
  376.     }
  377.  
  378.     pCache = FlashDataFdtCache.pCacheData;
  379.  
  380.     for (i = 0; i < FLASH_DATA_FDT_CACHE_COUNT; i++)
  381.     {
  382.         pCache->flag     = 0;
  383.         pCache->pBuffer  = &FlashDataFdtCacheBuf[i][0];
  384.         pCache->SectorNo = 0xFFFFFFFF;
  385.         pCache++;
  386.     }
  387.  
  388.     pCache = FlashDataDataCache.pCacheData;
  389.  
  390.     for (i = 0; i < FLASH_DATA_DATA_CACHE_COUNT; i++)
  391.     {
  392.         pCache->flag     = 0;
  393.         pCache->pBuffer  = &FlashDataDataCacheBuf[i][0];
  394.         pCache->SectorNo = 0xFFFFFFFF;
  395.         pCache++;
  396.     }
  397. }
  398.  
  399. int FS_FlashDataMediumInit(void)
  400. {
  401.     FlashDataCacheInit();
  402.     return(0);
  403. }
  404.  
  405. #endif
clone this paste RAW Paste Data