API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Oct 7th, 2013
134
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 11.05 KB | None | 0 0
raw download clone embed print report
  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
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!