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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > DVD > 查看源码
hdd_file.c
资源名称：8202s.rar　[点击查看]
上传用户：poi891205
上传日期：2013-07-15
资源大小：9745k
文件大小：26k
源码类别：

DVD

开发平台：

C/C++

hdd_file.c：源码内容
  1. /*=================================================================
  3. hdd_fs.c: Some FileSystem Info Function for HDD
  5. 2002-04-28 10:00AM Created  by Verdure
  6. 2002-06-12 08:42AM Modified by cyue
  8. Copyright(c)2000-2002 by Worldplus Technology (ShenZhen) Co., Ltd.
  9.                    ALL RIGHTS RESERVED 
  10. =================================================================*/
  12. #include "config.h"
  13. #include "set.h"
  14. #include "global.h"
  15. #include "hdd_if.h"
  17. #include "user_init.h"
  19. #ifdef SUPPORT_HDD_ACCESS
  21. #define D printf("INFO: __%d__(%s:%s)n",__LINE__,__FILE__,__FUNCTION__);
  23. #define SUPPORT_FAT2 //MIKEY 2003.09.18 write FAT2
  24. //#define SUPPORT_BACKUP_FAT //MIKEY 2003.09.18 copy FAT1 to FAT2
  26. #define DBG_HDD_FS //MIKEY_DEBUG
  29. #ifndef DBG_HDD_FS
  30. #undef printf
  31. #define printf(f, a...)  {}
  32. #endif
  35. UINT32  keep_lba=-1;
  36. //==============================================================
  37. //
  38. //==============================================================
  39. // Global for FAT FS
  40. extern UINT8  pwb[];
  42. //UINT8 *Info_buff=pwb+0;
  43. #define NAVBUFSTART (0xa03c0000) // 0xa03c0000 40k
  44. UINT8 *Info_buff=(UINT8 *)(NAVBUFSTART+0);
  45. UINT8  HD_EXIST;
  46. HDD_INFO HDD_Info;
  47. BPB_INFO BPB;
  49. UINT32 Data_Start_Clus;
  50. UINT32 File_FDB_Lba;
  51. UINT32 Start_LBA;
  52. UINT32 Data_Curr_Clus;
  53. UINT32 Data_Next_Clus;
  55. int FS_Get_BPBPara(UINT8*);
  57. PARTITION_INFO* HDD_AddPE(HDD_INFO* HDD_Info,UINT32 MBR,PARTITION_ENTRY* pe)
  58. {
  59. PARTITION_INFO *pi=0;
  60. #ifdef PI_USE_MATRIX
  61. int j;
  62. for(j=0;j<MAX_PART_INFO;j++)
  63.      if(!HDD_Info->part[j].type) break;
  64. pi=&HDD_Info->part[j]; 
  65. #else
  66. PARTITION_INFO *hddpi;
  67. pi=(PARTITION_INFO*)malloc(sizeof(PARTITION_INFO));
  68. #endif
  69. pi->type=pe->type;
  70. pi->next=NULL;
  71. pi->startlba=MBR+(pe->secfrommbr_hi<<16|pe->secfrommbr_lo);
  72. Start_LBA=pi->startlba;
  73.         // printf("n startlba:%xn",Start_LBA);//jichuan
  74. pi->seccnt=pe->seccnt_hi<<16|pe->seccnt_lo;
  75. pi->act=pe->act; 
  76. #ifndef PI_USE_MATRIX
  77. if(HDD_Info->partition_list==NULL)
  78. HDD_Info->partition_list=pi;
  79. else {
  80. for(hddpi=HDD_Info->partition_list;hddpi->next!=NULL;hddpi=hddpi->next);
  81. hddpi->next=pi;
  82. }
  83. #endif 
  84. return pi; 
  85. }
  87. int HDD_MakeInfo(HDD_INFO *HDD_Info,UINT8* buff)
  88. {
  89. PARTITION_ENTRY *pe;
  90. UINT32 i;     
  91. UINT32 MBR=0,secfrommbr,seccnt;
  93. #ifdef PI_USE_MATRIX
  94. for(i=0;i<MAX_PART_INFO;i++)
  95. HDD_Info->part[i].type=0;
  96. #else
  97. HDD_Info->partition_list=NULL;
  98. #endif
  100. HDD_ReadSec(buff,MBR,1);
  101. //print_sector(buff);
  102. for(i=0;i<4;i++) { //Parse Primary partitions
  103. pe=(PARTITION_ENTRY*)(buff+ 0x1be +i*16);
  104. secfrommbr=pe->secfrommbr_hi<<16|pe->secfrommbr_lo;
  105. seccnt=pe->seccnt_hi<<16|pe->seccnt_lo;  
  106. printf("n--secfrommbr=%lx--n",secfrommbr);
  107. if (!pe->type)
  108. continue;
  109. if ((pe->type==0x0f)||(pe->type==0x05)) {
  110. // Extended Partition!!
  111. UINT32 MBREXT=MBR+secfrommbr;
  112. do {
  113. HDD_ReadSec(buff,MBREXT,1);
  114. printf("n Parse EXT %lu... ",MBREXT);
  115. if (*(UINT16*)(buff+510)!=0xaa55) {
  116. printf("n Fail EXT Partition!!");
  117. break;
  118. }
  119. pe=(PARTITION_ENTRY*)(buff + 0x1be);
  120. secfrommbr=pe->secfrommbr_hi<<16|pe->secfrommbr_lo;
  121. seccnt=pe->seccnt_hi<<16|pe->seccnt_lo;
  122. if (pe->type) {
  123. #ifdef MIKEY
  124. HDD_AddPE(HDD_Info,MBREXT,pe);
  125. #else
  126. printf("MIKEY: skip add EXT partition type[%x]n",pe->type);
  127. break;
  128. #endif
  129. }
  130. else
  131. break;
  132. pe=(PARTITION_ENTRY*)(buff+ 0x1be +16);
  133. if(!pe->type) {
  134. printf("nLast MBR!!");
  135. MBREXT=HDD_Info->seccnt - seccnt;
  136. }
  137. else {
  138. MBREXT=MBREXT+secfrommbr+seccnt;
  139. }
  140. }while((pe->type==0x0f)||(pe->type==0x05));
  141. } 
  142. else {
  143. HDD_AddPE(HDD_Info,MBR,pe);
  144. printf("n primary=%d n",i);
  145. }
  146. }
  147. return 0;
  148. }
  150. void HDD_Dump_Info(HDD_INFO* HDD_Info)
  151. {
  152. PARTITION_INFO *pi;
  153. int i;
  154. printf("nnHDD: C=%lu H=%lu S=%lu",HDD_Info->cyl,HDD_Info->head,HDD_Info->sec);
  155. printf("nHDD total Sectors = %lu, %lu MB ",HDD_Info->seccnt,HDD_Info->seccnt/2000);
  156. printf("nPAR  A TYPE START LBA       COUNT"); 
  157. #ifdef PI_USE_MATRIX
  158. for(i=0;i<MAX_PART_INFO;i++) {
  159. pi= &HDD_Info->part[i];
  160. if(pi->type)
  161. printf("n%2d  %02x  %02x %10lu  %10lun",i,pi->act,pi->type,pi->startlba,pi->seccnt);
  162. }
  163. #else
  164. for(i=0,pi=HDD_Info->partition_list;pi!=NULL;i++,pi=pi->next) {
  165. printf("n%2d  %02x  %02x  %10lu  %10lu",i,pi->act,pi->type,pi->startlba,pi->seccnt);
  166. }
  167. #endif
  168. }
  171. static int FS_check_SecPerClus(unsigned SecPerClus)
  172. {
  173. unsigned char log;
  175. for(log = 0; log < 8; log++) {
  176. if(SecPerClus & 1) {
  177. SecPerClus >>= 1;
  178. return (SecPerClus != 0) ? -1 : log;
  179. }
  180. SecPerClus >>= 1;
  181. }
  182. return -1;
  183. }
  185. int FS_check_BootSec(UINT8* buf)
  186. {
  187. UINT16 temp;
  189. //check Jump Code + NOP
  190. if(buf[0] == 0xE9)
  191. /* OK */;
  192. else if(buf[0] == 0xEB && buf[2] == 0x90)
  193. /* OK */;
  194. else {
  195. printf("Missing JMP/NOPn");
  196. return 1;
  197. }
  199. //check Sectors Per Cluster
  200. temp = buf[13];
  201. if(FS_check_SecPerClus(temp) < 0) {
  202. printf("Sectors per cluster (%u) is not a power of 2n",temp);
  203. return 1;
  204. }
  206. //check the Number of FATs
  207. temp = buf[16];
  208. if(temp != 1 && temp != 2) {
  209. printf("Invalid number of FATs (%u)n",temp);
  210. return 1;
  211. }
  212.     
  213. //check Sectors Per Track
  214. temp = read_le16(buf + 24);
  215. if(temp == 0 || temp > 63) {
  216. printf("Invalid number of sectors (%u)n",temp);
  217. return 1;
  218. }
  220. //check Number of Heads
  221. temp = read_le16(buf + 26);
  222. if(temp == 0 || temp > 255) {
  223. printf("Invalid number of heads (%u)n",temp);
  224. return 1;
  225. }
  226. return FS_Get_BPBPara(buf);
  227. }
  230. int FS_Get_BPBPara(UINT8* buf)
  231. {
  232. BPB.BytesPerSec=(buf[12]<<8)|buf[11];
  233. switch(BPB.BytesPerSec) {
  234. case 512: BPB.BytesPerSecPwr=9; break;
  235. case 2048: BPB.BytesPerSecPwr=11; break;
  236. case 256: BPB.BytesPerSecPwr=8; break;
  237. }
  238. printf("n## BytesPerSec:%d ",BPB.BytesPerSec);
  239.      
  240. BPB.SecPerClus=buf[13];
  241. switch(BPB.SecPerClus) {
  242. case 128: BPB.SecPerClusPwr=7; break; //64K allocation unit
  243. case  64: BPB.SecPerClusPwr=6; break; //32K allocation unit
  244. case  32: BPB.SecPerClusPwr=5; break; //16K allocation unit
  245. case  16: BPB.SecPerClusPwr=4; break; // 8K allocation unit
  246. case   8: BPB.SecPerClusPwr=3; break; // 4K allocation unit
  247. case   4: BPB.SecPerClusPwr=2; break; // 2K allocation unit
  248. }
  250. printf("n## SecPerClus:%d ",BPB.SecPerClus);
  251. printf("n## SecPerClusPwr:%d ",BPB.SecPerClusPwr);
  252.      
  253. BPB.ReserSecCnt=read_le16(buf + 14);
  254. BPB.NumFATs=buf[16];
  255. // BPB.MediaDescriptor=buf[21];
  256. // BPB.SecPerTrack=read_le16(buf + 24);
  257. // BPB.NumHeads=read_le16(buf + 26);
  258. // BPB.HiddenSecCnt=read_le32(buf + 28);
  259. // BPB.TolSec32=read_le32(buf + 32);
  261. BPB.FATSize32=read_le32(buf + 36);
  262. printf("n## FATSize32:%d ",BPB.FATSize32);
  263. BPB.CurrDirClus=BPB.RootClus=read_le32(buf + 44);
  264. BPB.FAT1_Start=Start_LBA+BPB.ReserSecCnt;
  265. printf("n## BPB.FAT1_Start:%d ",BPB.FAT1_Start);
  266. if (BPB.NumFATs==1) 
  267. BPB.FAT2_Start=0;
  268. if (BPB.NumFATs==2)
  269. BPB.FAT2_Start=BPB.FAT1_Start+BPB.FATSize32;
  271. BPB.Data_Area_Start=((BPB.RootClus-2)*BPB.SecPerClus) + BPB.FAT1_Start+BPB.FATSize32*BPB.NumFATs;
  272. printf("n## BPB.Data_Area_Start:%d n",BPB.Data_Area_Start);
  273. return 0;
  274. }
  276. UINT32 Last_FAT_Lba=0x0FFFFFFF; // cyue: Try to make a cache 2002-06-11 11:14PM
  277. UINT8 *FS_ReadInfoSec(UINT32 lba,int seccnt)
  278. {
  279. if(Last_FAT_Lba!=lba) {
  280. HDD_ReadSec(Info_buff,lba,seccnt);
  281. }
  282. return Info_buff;
  283. }
  286. void FS_flush_cache()
  287. {
  288. keep_lba=-1;
  289. }
  292. UINT32  FS_Get_NextClus(UINT32 clus) //MIKEY 2003.09.02 for speed up
  293. {
  294. UINT32 lba;
  295. UINT32 nOffset;
  296. // static UINT32  keep_lba=-1;
  297. static UINT32  keep_count=0;
  298. // extern UINT8  pwb[];
  299. // UINT8 *buff512=pwb+512;
  300. UINT8 *buff512=(UINT8 *)(NAVBUFSTART+512);
  302.     keep_lba=-1; //MIKEY disable cache
  304. nOffset=clus&0x7F;//%128;
  305. lba=(clus>>7)+BPB.FAT1_Start;
  307. if(keep_lba!=lba) { //MIKEY_CACHE
  308. keep_lba=lba;
  309. HDD_ReadSec(buff512, lba, 1);
  310. }
  311. else {
  312. keep_count++;
  313. if((keep_count % 100)==99)
  314. printf("INFO: FS_Get_NextClus keep_count(%ld)n",keep_count);
  315. }
  316. Data_Next_Clus=read_le32(buff512+(nOffset<<2))&0x0fffffff;
  317. return Data_Next_Clus;
  318. }
  320. //==============================================================
  321. //
  322. //==============================================================
  323. //extern BYTE CardReadSector();
  324. extern BYTE FSReadSector();
  325. extern BYTE CardWriteSector();
  326. extern void *memcpy();
  327. extern unsigned strlen();
  329. /* Check whether HD present */
  330. UINT8 HDD_DEV_Existence(void)
  331. {
  332. return 0;
  333. }
  335. int HDD_ReadSec(UINT8 *buff, UINT32 lba, int seccnt)
  336. {
  337. int i;
  338. int ret=0;
  339. for(i=0;i<5;i++) { // retry?
  340. // if((ret=CardReadSector(lba, seccnt, buff))==0)
  341. if((ret=FSReadSector(lba, seccnt, buff))==0)
  342. break; //OK
  343. printf("ERROR: HDD_ReadSec retry(%d)n",i+1);
  344. }
  345. return ret;
  346. } 
  348. int HDD_WriteSec(UINT8 *buff, UINT32 lba, int seccnt)
  349. {
  350. int i;
  351. int ret=0;
  352. for(i=0;i<5;i++) { // retry?
  353. if((ret=CardWriteSector(lba, seccnt, buff))==0)
  354. break; //OK
  355. printf("ERROR: HDD_WriteSec retry(%d)n",i+1);
  356. }
  357. return ret;
  358. } 
  361. UINT32 FS_LBA2Clus(UINT32 lba)
  362. {
  363. UINT32 clus;
  365. clus = (lba - BPB.Data_Area_Start)/BPB.SecPerClus + 2;
  366. return clus;
  367. }
  369. UINT32 FS_LBAinClus(UINT32 lba)
  370. {
  371. UINT32 curClus, nextClus;
  372. int i;
  373.     
  374. curClus = FS_LBA2Clus(lba);
  375. for (i=0; i<BPB.SecPerClus; i++) {
  376. nextClus = FS_LBA2Clus(lba+i+1);
  377. if (curClus != nextClus)
  378. break;
  379. }
  380. return i;
  381. }
  384. //==============================================================
  385. //
  386. //==============================================================
  387. #ifdef SUPPORT_BACKUP_FAT
  388. void  HDD_Backup_FAT(void)
  389. {
  390. UINT32 i;
  391. if(BPB.NumFATs<2)
  392. return;
  394. for(i=0; i<BPB.FATSize32; i++) {
  395. HDD_ReadSec (Info_buff, BPB.FAT1_Start+i, 1);
  396. HDD_WriteSec(Info_buff, BPB.FAT2_Start+i, 1);
  397. }
  398. }
  399. #endif //SUPPORT_BACKUP_FAT
  401. int HDD_list_clus(FILE_INFO *fp)
  402. {
  403. UINT32 st,next;
  404. // UINT32 lba_count=LBA_COUNT(fp->fsize),sec_count=BPB.SecPerClus; 
  405. int i=0;
  406. st=fp->start_clus;
  407. next=0;
  408. //printf("MIKEY: lba_count(%d)/(%d)=(%d)n",lba_count,sec_count,(lba_count+sec_count-1)/sec_count);
  409. while(1) {
  410. printf("$$ clus(%4d):[%x]n",i,st);
  411. if(st>=0x0FFFFFF8) {//End?
  412. break;
  413. }
  414. next=FS_Get_NextClus(st);
  415. st=next;
  416. i++;
  417. }
  418. return 0;
  419. }
  421. //==============================================================
  422. //
  423. //==============================================================
  424. UINT8  FS_Emu_stricmp(UINT8* s1, UINT8* s2)
  425. {
  426. UINT16 i;
  428. //MIKEY_BUG
  429. // for(i=0;(i<11)&&(*s1)&&(*s2);i++,s1++,s2++) {
  430. for(i=0;i<11;i++) {
  431. if(((s1[i])&~0x20)!=((s2[i])&~0x20))
  432.      return 1;
  433. }
  434. return 0;
  435. }
  438. UINT8  HDD_Mount(void)
  439. {
  440. UINT8 i;
  441.     
  442. if ((HD_EXIST = HDD_DEV_Existence()))
  443. return 0;
  444. HDD_MakeInfo(&HDD_Info,Info_buff);
  445. for(i=0;HDD_Info.part[i].type;i++) { /*浪代–