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

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

DVD

开发平台：

C/C++

hdd_fs.c：源码内容
  1. /*=================================================================
  3.   hdd_fs.c: Some FileSystem Info Function for HDD
  4.   
  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. =================================================================*/
  11. //#include <string.h>
  12. #include <math.h>
  14. #include "config.h"
  15. #include "set.h"
  16. #include "global.h"
  17. #include "hdd_if.h"
  18. #include "hdd_info.h"
  19. #include "stdlib.h"
  21. #ifdef USE_HDD // cyue: Skip code if not use hdd!!
  23. #define DBG_HDD_FS
  25. #ifndef DBG_HDD_FS
  26. #undef printf
  27. #define printf(f, a...)  {}
  28. #endif
  29. #undef print_block
  30. #define print_block(x,y) {}
  32. UINT8  FS_Emu_stricmp(UINT8* s1, UINT8* s2)
  33. {
  34.     UINT16 i;
  35. #if 1
  36.     for(i=0;(i<11);i++,s1++,s2++)
  37.     { if((!*s1)&&(!*s2))
  38. return 0;
  39. if(((*s1)&~0x20)!=((*s2)&~0x20))
  40. return 1;
  41.     }
  42.     //printf("Match: %s -- %s n",s1-11,s2-11);
  43.     return 0;
  44. #else
  45.     //while(i<11)
  46.     while(string1[i]!=''||string2[i]!='')
  47.     {
  48. if(string1[i]==string2[i])
  49. i += 1;
  50. else if((string1[i]>=0x41&&string1[i]<=0x5A)||(string1[i]>=0x61&&string1[i]<=0x7A))
  51.             if(abs(string1[i]-string2[i])==0x20) 
  52.    i += 1;
  53.    else return 1;
  54.    else return 1;
  55.     }
  57.     return 0;
  58. #endif
  59. }
  62. UINT8  HDD_Mount(void)
  63. {
  64.     //HDD_Reset(); //cyue: need reset too? 2002-07-03 11:10AM
  65.     
  66.     HD_EXIST = HDD_DEV_Existence();
  67.     if (!HD_EXIST)
  68.     {
  69. HDD_MakeInfo(&HDD_Info,Info_buff);
  70. printf("nStart_LBA:%dn",Start_LBA);
  71. FS_ReadInfoSec(Start_LBA,1);
  72. FS_check_BootSec(Info_buff);
  73. return 1;
  74.     }
  75.     return 0;
  76.     
  77. //    return 1;
  78. }
  81. void  HDD_Backup_FAT(void)
  82. {
  83.     UINT32 i=BPB.FATSize32;
  84.     UINT16 SecCnt,j;
  85.     SecCnt=sizeof(Info_buff)>>BPB.BytesPerSecPwr;
  86.     
  87.     if(BPB.NumFATs==2)
  88.     {
  89. if(i%SecCnt)
  90. {
  91. FS_ReadInfoSec(BPB.FAT1_Start,i%SecCnt);
  92. HDD_WriteSec(Info_buff,BPB.FAT2_Start,i%SecCnt);
  93. for(j=(i%SecCnt),i-=(i%SecCnt);i>0;i-=SecCnt,j+=SecCnt)
  94. {
  95. FS_ReadInfoSec(BPB.FAT1_Start+j,SecCnt);
  96. HDD_WriteSec(Info_buff,BPB.FAT2_Start+j,SecCnt);
  97. }
  98. }
  99. else for(j=0;i>0;i-=SecCnt,j+=SecCnt)
  100. {
  101. FS_ReadInfoSec(BPB.FAT1_Start+j,SecCnt);
  102. HDD_WriteSec(Info_buff,BPB.FAT2_Start+j,SecCnt);
  103. }
  104.     }
  105. }
  108. PLAY_BLOCK *HDD_BuildPlayBlock(FILE_INFO *pfdb,PLAY_BLOCK *pblock)
  109. {
  110. // Generate Cluster blocks of this file
  111. UINT32 st,next,lba_count=LBA_COUNT(pfdb->fsize),sec_count=BPB.SecPerClus; 
  112. int i;
  113. for(i=0,st=pfdb->start_clus,next=0;
  114. i<MAX_FILE_LINK_ITEM;
  115. i++)
  116. { pblock->block[i].lba=0;// End Mark first
  117. pblock->block[i].len=0;
  118. if(st>=0x0FFFFFFF)//End?
  119. { break;
  120. }
  121. pblock->block[i].lba=FS_Clus2LBA(st);
  122. do
  123. { if(lba_count>=sec_count)
  124. { pblock->block[i].len+=sec_count;
  125. lba_count-=sec_count;
  126. }
  127. else
  128. { pblock->block[i].len+=lba_count;
  129. }
  130. //printf("n$$ next clus:0x%lx ",next);
  131. next=FS_Get_NextClus(st);
  132. st++;
  133. // cyue test multiblock!! 2002-06-17 03:26PM
  134. //if(pblock->block[i].len>0x4000)
  135. // st=0;
  136. }
  137. while(next==st);
  138. st=next;
  139. }
  140. pblock->curr_blk=0; pblock->curr_lba=pblock->block[0].lba;
  142. #ifdef DBG_HDD_FS
  143. for(i=0;i<MAX_FILE_LINK_ITEM;i++)
  144. { if(!(pblock->block[i].lba)) break;
  145. printf("### Blk:%d lba:0x%lx len:0x%lxn",
  146. i,pblock->block[i].lba,pblock->block[i].len);
  147. }
  148. #endif
  149. return pblock;
  150. }
  152. FILE_INFO *GetFileInfo(FAT32_FDB *fdb,FILE_INFO *pfinfo)
  153. {
  154. UINT16 i;
  155. printf(__FUNCTION__);
  156. #if 0
  157. // copy Filename (8.3 format)
  158. { UINT8 *d,*s;
  159. for(i=0,d=pfinfo->name,s=(UINT8*)fdb
  160. ;i<11; i++,d++,s++)
  161. *d=*s;
  162. *d=0;
  163. }
  164. #endif
  165. Data_Start_Clus=pfinfo->start_clus=(UINT32)((fdb->start_hi)<<16|(fdb->start_lo));
  166. if(pfinfo->start_clus==0) //cyue: '..' to root!!
  167. {
  168. printf(" It's Root !! ");
  169. Data_Start_Clus=pfinfo->start_clus=BPB.RootClus;
  170. }
  171. pfinfo->start_lba=FS_Clus2LBA(pfinfo->start_clus);//((pfinfo->start_clus-2)<<BPB.SecPerClusPwr)+BPB.Data_Area_Start;
  172. pfinfo->fsize=fdb->fsize;
  173. pfinfo->attrib=fdb->attrib;
  174. i=BPB.BytesPerSecPwr;
  175. #ifdef DBG_HDD_FS
  176. printf("### start_lba: 0x%lxn### size: 0x%lx start_clus 0x%lxnn",
  177. pfinfo->start_lba,
  178. pfinfo->fsize,
  179. pfinfo->start_clus);
  180. #endif
  181. return pfinfo;
  182. }
  184. /*
  185. ========================================================
  186. =  FILE_INFO*  SearchFile(UINT32 dir_clus,UINT8 *name)
  187. =      Search file(or subdir) in dir_clus cluster
  188. =  ARGUMENT(S):
  189. =      UINT32  dir_clus: the start cluster of dir to search file
  190. =      UINT8   *fname: filename to play, 11 CHAR in 8.3 
  191. =                     format
  192. =  RETURN VALUE:
  193. =      FILE_INFO: info of this file.
  194. =  GLOBAL USING:
  195. =      Info_buff: buffer to read a sector (512 bytes)
  196. =      BPB: HD infos
  197. =  SIDE EFFECT:
  198. =      Info_buff: Contains Last FDB Sector that have this file
  199. =      Data_Start_Clus: first clustor of file 
  200. =  2002-06-12 08:38AM Modified by cyue
  201. =                     play continue LBAs currently 
  202. ========================================================
  203. */
  205. FILE_INFO* SearchFile(UINT32 dir_clus,UINT8 *name)
  206. {
  207. UINT32 lba;
  208. UINT32 i,offset;
  209. static FILE_INFO finfo;
  210. for(;dir_clus<0x0FFFFFFF;dir_clus=FS_Get_NextClus(dir_clus))
  211. {
  212. lba=FS_Clus2LBA(dir_clus);
  213. for(i=BPB.SecPerClus;i;i--,lba++)
  214. {
  215. printf("### DirLBA:0x%lxn",lba);
  216. FS_ReadInfoSec(lba,1);
  217. for(offset=0;offset<BPB.BytesPerSec;offset+=32)
  218. {
  219. switch(Info_buff[offset])
  220. {
  221. case 0: // free FDB, End!!
  222. printf("nNo Such File Here!! %sn",name);
  223. BPB.curr_fdb_lba=lba; // store file info location
  224. BPB.curr_fdb_offset=offset; // store file info location
  226. return NULL; 
  227. case 0xE5: //deleted FDB
  228. continue;
  229. #if 0
  230. case '.'://Parrent or this dir
  231. if(Info_buff[offset+1]=='.')
  232. { printf("n Parrent Dir(..)");
  233. }
  234. else
  235. { printf("n This Dir(.)");
  236. }
  237. continue;
  238. #endif
  239. default:
  240. if(FS_Emu_stricmp(&Info_buff[offset],name)==0)
  241. { BPB.curr_fdb_lba=lba; // store file info location
  242. BPB.curr_fdb_offset=offset; // store file info location
  243. GetFileInfo((FAT32_FDB*)(&Info_buff[offset]),&finfo);
  244. finfo.fdb_lba=lba;
  245. finfo.fdb_offset=offset;
  246. return &finfo;
  247. }
  248. }
  249. }
  250. }
  251. }
  252. return NULL;
  253. }
  255. /*
  256. ========================================================
  257. =  FILE_INFO*  HDD_SearchFile(UINT8* name_buff)
  258. =      Search file in path/path/.../fname 
  259. =  ARGUMENT(S):
  260. =      UINT8   *fname: path/../filename to search,  
  261. =                      CHAR in 8.3 format
  262. =  RETURN VALUE:
  263. =      FILE_INFO: info of files
  264. =  GLOBAL USING:
  265. =      BPB: HD infos
  266. =  SIDE EFFECT:
  267. =      Info_buff: Contains Last FDB Sector that have this file
  268. =      Data_Start_Clus: first clustor of file 
  269. =  2002-06-12 08:38AM Modified by cyue
  270. =                     play continue LBAs currently 
  271. ========================================================
  272. */
  274. FILE_INFO*  HDD_SearchFile(UINT8 *s)
  275. {
  276. FILE_INFO* ret=NULL;
  277. UINT32 clus,i;
  278. UINT8 part_name[12],*d;
  279. //printf(__FUNCTION__":n");
  280. if(*s=='/') //FROM ROOT
  281. {
  282. clus=BPB.RootClus;
  283. s++;
  284. }
  285. else //FROM CURRENT
  286. {
  287. clus=BPB.CurrDirClus;
  288. }
  289. do
  290. {
  291. // clear part_name buff;
  292. for(i=0,d=part_name;i<11;i++,d++) *d=' ';
  293. *d=0;
  294. d=part_name;
  295. // clear leading '/'
  296. if(*s=='/')s++;
  298. if(*s=='.') // self or parrent?
  299. {
  300. *(d++)='.';
  301. if(*(s+1)=='.')// parrent?
  302. {  
  303. *(d++)='.'; s++;
  304. }
  305. *d=0; s++;
  306. }
  307. else
  308. { //copy part_name
  309. while((*s!='/')&&(*s!=0))
  310. {
  311. if(*s=='.') 
  312. {
  313. d=&part_name[8];
  314. }
  315. else
  316. {
  317. *d++=*s;
  318. }
  319. s++;
  320. }
  321. *d=0;
  322. }
  324. // Get Part-File Info
  325. ret=SearchFile(clus,part_name);
  326. if(ret==NULL) return NULL;
  328. if(ret->attrib&FAT_ATTR_D) // Is this a subdir file?
  329. {
  330. if(*s==0) // End Search string => just get the dir info
  331. {
  332. printf(" CD to new dir (%s)!!",part_name);
  333. return ret;
  334. }
  335. }
  336. else // A real file finded
  337. { //printf(" Final Name: %sn",ret->name);
  338. return ret;
  339. } 
  340. clus=ret->start_clus;
  341. }while(1);
  342. }
  344. FILE_INFO*  HDD_cd(UINT8 *s)
  345. {
  346. FILE_INFO* ret;
  347. ret=HDD_SearchFile(s);
  348. if(ret==NULL) return NULL;
  349. printf("n***  BPB.CurrDirClus: 0x%lx ",BPB.CurrDirClus);
  350. if(ret->attrib&FAT_ATTR_D) // Is this a subdir file?
  351. {
  352. BPB.CurrDirClus=ret->start_clus;
  353. return ret;
  354. }
  355. return NULL; // No such dir, but such file!!
  356. }
  359. extern UINT32 Last_FAT_Lba;
  360. void HDD_dir()
  361. {
  362. UINT32 dir_clus,lba;
  363. UINT32 i,j;
  364. UINT8 name[12];
  365. printf("nDIR:n");
  366. Last_FAT_Lba=0x0FFFFFFF;
  367. for(dir_clus=BPB.CurrDirClus;
  368. dir_clus<0x0FFFFFFF;
  369. dir_clus=FS_Get_NextClus(dir_clus))
  370. {
  371. lba=FS_Clus2LBA(dir_clus);
  372. for(i=BPB.SecPerClus;i;i--,lba++)
  373. {
  374. FS_ReadInfoSec(lba,1);
  375. for(j=0;j<BPB.BytesPerSec;j+=32)
  376. {
  377. UINT8 *s;
  378. s=&Info_buff[j];
  379. if(*s==0)
  380. {
  381. printf("n");
  382. return; // No more file in dir
  383. }
  384. if(*s==0xE5) continue; // deleted file
  385. memcpy(name,s,11);
  386. name[11]=0;
  387. printf("t[ %s ]",name);
  388. }
  389. }
  390. }
  391. }
  393. #if 0
  394. void  HDD_LinkFileClus(void)
  395. {
  396.     UINT32 cluster=Data_Start_Clus;
  397.     UINT32 i;
  398.     
  399.     read_le32(Info_buff+BPB.BytesPerSec)=FS_Clus2LBA(cluster);//((cluster-2)<<BPB.SecPerClusPwr)+BPB.Data_Area_Start;
  400.     for(i=4;i<4096;i+=4)
  401.     {
  402. cluster=FS_Get_NextClus(cluster);
  403. /* save the first LBA of every cluster */
  404. read_le32(Info_buff+BPB.BytesPerSec+i)=FS_Clus2LBA(cluster);//((cluster-2)<<BPB.SecPerClusPwr)+BPB.Data_Area_Start;
  405.     }
  406.     //print_block(Info_buff+BPB.BytesPerSec,512*8);
  407. }
  408. #endif
  410. /*
  411. ========================================================
  412. = UINT32  HDD_FindFreeClus(UINT32 first_clus, UINT32 count)
  413. =      Find Free Cluster(s) (by count number)
  414. =  ARGUMENT(S):
  415. =      UINT32 first_clus: find free clusters after this 
  416. =      UINT32 count: count of free clusters needs
  417. =
  418. =  RETURN VALUE:
  419. =      0xFFFFFFFF: No such more free clusters
  420. =      otherwise: start clus of the linked clusters
  421. =  GLOBAL USING:
  422. =      BPB: HD infos
  423. =  SIDE EFFECT:
  424. =      Info_buff: Contains Last FDB Sector that have this file
  425. =      Data_Start_Clus: first clustor of file 
  426. =  2002-06-12 08:38AM Modified by cyue
  427. =                     play continue LBAs currently 
  428. ========================================================
  429. */
  431. UINT32  HDD_FindFreeClus(UINT32 first_clus, UINT32 count)
  432. {
  433. UINT32 fat_lba=BPB.FAT1_Start+(first_clus>>(BPB.BytesPerSecPwr-2));
  434. //UINT32 cluster;
  435. UINT32 offset;//clus_ret,
  436. while(fat_lba<BPB.FAT2_Start)  //at the end of FAT1
  437. {
  438. FS_ReadInfoSec(fat_lba,1);
  439. for(offset=0;offset<BPB.BytesPerSec;offset+=4)
  440. {
  441. if(read_le32(Info_buff+offset)==0)
  442. {
  443. Data_Next_Clus=(((fat_lba-BPB.FAT1_Start)<<7)+(offset>>2));
  444. read_le32(Info_buff+offset)=0xfffffff;
  445. HDD_WriteSec(Info_buff,fat_lba, 1);
  446. printf("%lx,%lx,%lxn",fat_lba,offset,Data_Next_Clus);
  447. return 1;
  448. }
  449. }
  450. fat_lba ++;
  451. }
  452. if(fat_lba==BPB.FAT2_Start)
  453. printf("The HD is Fulln");
  454. return 0;
  455. }
  458. /* Fill the empty FDB */
  459. UINT8  HDD_Set_FDB(UINT8* name_buff)
  460. {
  461.     UINT32 lba;
  462.     UINT16 offset=0;
  463.     UINT8   file_flag=0;
  464.     UINT8   i;
  466.     if(1) lba=BPB.Data_Area_Start;  //under the root directory
  467.     else {};
  468.     
  469.     while(1)
  470.     {
  471.         FS_ReadInfoSec(lba,1);
  472.         File_FDB_Lba=lba;
  473.         do
  474.         {    
  475. file_flag=Info_buff[offset];
  476. if((file_flag==0xE5)||(file_flag==0x00))
  477. {
  478. //set name
  479. for(i=0;i<11;i++)
  480. Info_buff[offset+i]=name_buff[i];
  481. Info_buff[offset+11]=0x21;
  482. //set the access cluster
  483. read_le16(Info_buff+offset+20)=(Data_Next_Clus>>16)&0xfff;
  484. read_le16(Info_buff+offset+26)=Data_Next_Clus&0xffff;
  485. HDD_WriteSec(Info_buff, lba, 1);
  486. //print_block(Info_buff,BPB.BytesPerSec);
  487. return 1;
  488. }
  489. offset += 32;
  490.         } while(offset<BPB.BytesPerSec);
  491.         lba += 1;
  492.     }
  493. }
  496. FILE_INFO *HDD_CreatFile(UINT8* name_buff)
  497. {
  498.     UINT32 clus_lba=BPB.FAT1_Start;
  499.     UINT32 data_lba;
  500.     //UINT16 offset=0;
  501.     //UINT8   file_flag=0;
  502.     //UINT8   i;
  504.     /* Creat a file in the first layer of HD */
  505.     if(HDD_FindFreeClus(0,clus_lba)!=0)
  506. HDD_Set_FDB(name_buff);
  507.     else
  508.     {
  509.         printf("Can't Creat File,HD is Fulln");
  510.         return 0;
  511.     }
  512.     
  513.     Data_Curr_Clus=Data_Next_Clus;
  514.     //while(1)
  515.     {
  516.         data_lba=FS_Clus2LBA(Data_Curr_Clus);//BPB.Data_Area_Start+((Data_Curr_Clus-2)<<BPB.SecPerClusPwr);
  517.         //HDD_WriteSec(buff,data_lba,seccnt);
  518.         //if("It is over") return 1;
  520.         clus_lba=(Data_Curr_Clus>>7)+BPB.FAT1_Start;
  521.         if(HDD_FindFreeClus(0,clus_lba)!=0)
  522.         {
  523.             FS_ReadInfoSec(clus_lba,1);
  524.             read_le32(Info_buff+ (Data_Curr_Clus>>(7-2)) )=Data_Next_Clus;
  525.             HDD_WriteSec(Info_buff,clus_lba,1);
  526.         }
  527.         else
  528.         {
  529. printf("Can't Creat File,HD is Fulln");
  530. return 0;
  531.         }
  532.         printf("%lx,%lxn",Data_Curr_Clus,Data_Next_Clus);
  533.         //print_block(Info_buff,BPB.BytesPerSec);
  534.         Data_Curr_Clus=Data_Next_Clus; return 0;
  535.     }
  536. }
  539. /* Fill the FAT Chain with zero */
  540. void  HDD_ResetFAT(void)
  541. {
  542.     Data_Curr_Clus=Data_Start_Clus;
  543.     FS_ReadInfoSec((Data_Curr_Clus>>7)+BPB.FAT1_Start,1);
  544.     
  545.     while(Data_Curr_Clus!=0x0fffffff)
  546.     {
  547. FS_Get_NextClus(Data_Curr_Clus);
  548. read_le32(Info_buff+((Data_Curr_Clus&0x7F)<<2))=0;
  549. HDD_WriteSec(Info_buff,(Data_Curr_Clus>>7)+BPB.FAT1_Start,1);
  550. if((Data_Next_Clus>>7)!=(Data_Curr_Clus>>7))
  551. FS_ReadInfoSec((Data_Next_Clus>>7)+BPB.FAT1_Start,1);
  552. Data_Curr_Clus=Data_Next_Clus;
  553.     }
  554.     read_le32(Info_buff+((Data_Curr_Clus&0x7F)<<2))=0;
  555.     HDD_WriteSec(Info_buff,(Data_Curr_Clus>>7)+BPB.FAT1_Start,1); 
  556. }
  559. UINT32  HDD_DelFile(UINT8* name_buff)
  560. {
  561.     FILE_INFO *pfinfo;
  562.     if(NULL==(pfinfo=HDD_SearchFile(name_buff))) return -1; //No File ERR
  564.     Info_buff[pfinfo->fdb_offset]=0xE5;// Mark file deleted!!
  565.     HDD_WriteSec(Info_buff,pfinfo->fdb_lba,1);
  566.     HDD_ResetFAT();//clear FAT chain
  567.     printf("File Deletedn");
  568.     
  569.     return 0; //No ERR
  570. }
  573. #endif //USE_HDD