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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > uCOS > 查看源码
smc_log.c
资源名称：STM32-uCOS-II_UAV.rar　[点击查看]
上传用户：yj_qqy
上传日期：2017-01-28
资源大小：2911k
文件大小：37k
源码类别：

uCOS

开发平台：

C/C++

smc_log.c：源码内容
  1. /*
  2. **********************************************************************
  3. *                          Micrium, Inc.
  4. *                      949 Crestview Circle
  5. *                     Weston,  FL 33327-1848
  6. *
  7. *                            uC/FS
  8. *
  9. *             (c) Copyright 2001 - 2003, Micrium, Inc.
  10. *                      All rights reserved.
  11. *
  12. ***********************************************************************
  14. ----------------------------------------------------------------------
  15. File        : smc_log.c
  16. Purpose     : Generic logical sector read/write access module for SMC
  17. ----------------------------------------------------------------------
  18. Known problems or limitations with current version
  19. ----------------------------------------------------------------------
  20. None.
  21. ---------------------------END-OF-HEADER------------------------------
  22. */
  24. /*********************************************************************
  25. *
  26. *             #include Section
  27. *
  28. **********************************************************************
  29. */
  31. #include "fs_port.h"
  32. #include "fs_dev.h"
  33. #include "fs_conf.h"
  35. #if FS_USE_SMC_DRIVER
  37. #include "smc.h"
  40. /*********************************************************************
  41. *
  42. *             #define macros
  43. *
  44. **********************************************************************
  45. */
  47. #define Set_X_Bit(a,b)    (a[(unsigned char)((b)/8)]|= _FS_SMC_BitData[(b)%8])
  48. #define Clr_X_Bit(a,b)    (a[(unsigned char)((b)/8)]&=~_FS_SMC_BitData[(b)%8])
  49. #define Chk_X_Bit(a,b)    (a[(unsigned char)((b)/8)] & _FS_SMC_BitData[(b)%8])
  52. /*********************************************************************
  53. *
  54. *             Local Variables        
  55. *
  56. **********************************************************************
  57. */
  59. static const char     _FS_SMC_BitData[] = {0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80 };
  60. static unsigned int   _FS_SMC_ErrCode[FS_SMC_MAXUNIT];
  61. static unsigned char  _FS_SMC_SectBuf[SECTSIZE];
  62. static unsigned char  _FS_SMC_WorkBuf[SECTSIZE];
  63. static unsigned char  _FS_SMC_Redundant[REDTSIZE];
  64. static unsigned char  _FS_SMC_WorkRedund[REDTSIZE];
  65. static unsigned short _FS_SMC_Log2Phy[FS_SMC_MAXUNIT][2][MAX_LOGBLOCK];
  66. static unsigned char  _FS_SMC_Assign[FS_SMC_MAXUNIT][2][MAX_BLOCKNUM/8];
  67. static unsigned short _FS_SMC_AssignStart[FS_SMC_MAXUNIT][2];
  68. static unsigned short _FS_SMC_AssignZone[FS_SMC_MAXUNIT];
  69. static unsigned short _FS_SMC_ReadBlock[FS_SMC_MAXUNIT];
  70. static unsigned short _FS_SMC_WriteBlock[FS_SMC_MAXUNIT];
  71. static unsigned int   _FS_SMC_MediaChange[FS_SMC_MAXUNIT];
  72. static unsigned int   _FS_SMC_SectCopyMode[FS_SMC_MAXUNIT];
  75. /*********************************************************************
  76. *
  77. *             Local functions
  78. *
  79. **********************************************************************
  80. */
  82. /*********************************************************************
  83. *
  84. *             _FS_SMC_Bit_Count
  85. */
  87. static char _FS_SMC_Bit_Count(unsigned char cdata)
  88. {
  89.     char bitcount=0;
  90.     while(cdata) {
  91.         bitcount+=(cdata &0x01);
  92.         cdata   /=2;
  93.     }
  94.     return(bitcount);
  95. }
  98. /*********************************************************************
  99. *
  100. *             _FS_SMC_Bit_CountWord
  101. */
  103. static char _FS_SMC_Bit_CountWord(unsigned short cdata)
  104. {
  105.     char bitcount=0;
  106.     while(cdata) {
  107.         bitcount+=(cdata &0x01);
  108.         cdata   /=2;
  109.     }
  110.     return(bitcount);
  111. }
  113. /*********************************************************************
  114. *
  115. *             _FS_SMC_Chk_DataBlank
  116. */
  118. static int _FS_SMC_Chk_DataBlank(unsigned char *redundant)
  119. {
  120.     char i;
  121.     for(i=0; i<REDTSIZE; i++)
  122.         if(*redundant++!=0xFF)      return(ERROR);
  123.     return(SUCCESS);
  124. }
  126. /*********************************************************************
  127. *
  128. *             _FS_SMC_Chk_FailBlock
  129. */
  131. static int _FS_SMC_Chk_FailBlock(unsigned char *redundant)
  132. {
  133.     redundant+=REDT_BLOCK;
  134.     if(*redundant==0xFF)            return(SUCCESS);
  135.     if(! *redundant)                return(ERROR);
  136.     if(_FS_SMC_Bit_Count(*redundant)<7)     return(ERROR);
  137.     return(SUCCESS);
  138. }
  141. /*********************************************************************
  142. *
  143. *             _FS_SMC_Chk_CisBlock
  144. */
  146. static int _FS_SMC_Chk_CisBlock(unsigned char *redundant)
  147. {
  148.     if(! (*(redundant+REDT_ADDR1H)|*(redundant+REDT_ADDR1L)))
  149.         return(SUCCESS);
  150.     if(! (*(redundant+REDT_ADDR2H)|*(redundant+REDT_ADDR2L)))
  151.         return(SUCCESS);
  152.     return(ERROR);
  153. }
  155. /*********************************************************************
  156. *
  157. *             _FS_SMC_Chk_DataStatus
  158. */
  160. static int _FS_SMC_Chk_DataStatus(unsigned char *redundant)
  161. {
  162.     redundant+=REDT_DATA;
  163.     if(*redundant==0xFF)            return(SUCCESS);
  164.     if(! *redundant)                return(ERROR);
  165.     if(_FS_SMC_Bit_Count(*redundant)<5)     return(ERROR);
  166.     return(SUCCESS);
  167. }
  170. /*********************************************************************
  171. *
  172. *             _FS_SMC_Load_LogBlockAddr
  173. */
  175. static int _FS_SMC_Load_LogBlockAddr(FS_u32 id,unsigned char *redundant)
  176. {
  177.     unsigned short addr1,addr2;
  178.     addr1=*(redundant+REDT_ADDR1H)*0x100+*(redundant+REDT_ADDR1L);
  179.     addr2=*(redundant+REDT_ADDR2H)*0x100+*(redundant+REDT_ADDR2L);
  180.     if(addr1==addr2)
  181.         if((addr1 &0xF000)==0x1000)
  182.             { FS__SMC_cardparam[id].LogBlock=(addr1 &0x0FFF)/2; return(SUCCESS); }
  183.     if(_FS_SMC_Bit_CountWord(addr1^addr2)>1)            return(ERROR);
  184.     if((addr1 &0xF000)==0x1000)
  185.         if(! (_FS_SMC_Bit_CountWord(addr1) &0x0001))
  186.             { FS__SMC_cardparam[id].LogBlock=(addr1 &0x0FFF)/2; return(SUCCESS); }
  187.     if((addr2 &0xF000)==0x1000)
  188.         if(! (_FS_SMC_Bit_CountWord(addr2) &0x0001))
  189.             { FS__SMC_cardparam[id].LogBlock=(addr2 &0x0FFF)/2; return(SUCCESS); }
  190.     return(ERROR);
  191. }
  194. /*********************************************************************
  195. *
  196. *             _FS_SMC_Clr_RedundantData
  197. */
  199. static void _FS_SMC_Clr_RedundantData(unsigned char *redundant)
  200. {
  201.     char i;
  202.     for(i=0; i<REDTSIZE; i++)   *(redundant+i)=0xFF;
  203. }
  206. /*********************************************************************
  207. *
  208. *             _FS_SMC_Set_LogBlockAddr
  209. */
  211. static void _FS_SMC_Set_LogBlockAddr(FS_u32 id,unsigned char *redundant)
  212. {
  213.     unsigned short addr;
  214.     *(redundant+REDT_BLOCK)=0xFF;
  215.     *(redundant+REDT_DATA) =0xFF;
  216.     addr=FS__SMC_cardparam[id].LogBlock*2+0x1000;
  217.     if((_FS_SMC_Bit_CountWord(addr)%2)) addr++;
  218.     *(redundant+REDT_ADDR1H)=*(redundant+REDT_ADDR2H)=addr/0x100;
  219.     *(redundant+REDT_ADDR1L)=*(redundant+REDT_ADDR2L)=(unsigned char)addr;
  220. }
  223. /*********************************************************************
  224. *
  225. *             _FS_SMC_Set_FailBlock
  226. */
  228. static void _FS_SMC_Set_FailBlock(unsigned char *redundant)
  229. {
  230.     char i;
  231.     for(i=0; i<REDTSIZE; i++)
  232.         *redundant++=((i==REDT_BLOCK)?0xF0:0xFF);
  233. }
  235. /*********************************************************************
  236. *
  237. *             _FS_SMC_Set_DataStatus
  238. */
  240. static void _FS_SMC_Set_DataStatus(unsigned char *redundant)
  241. {
  242.     redundant+=REDT_DATA;
  243.     *redundant=0x00;
  244. }
  247. /*********************************************************************
  248. *
  249. *             _FS_SMC_Init_Media
  250. */
  252. static void _FS_SMC_Init_Media(FS_u32 id)
  253. {
  254.     _FS_SMC_ErrCode[id]=NO_ERROR;
  255.     _FS_SMC_MediaChange[id]=(unsigned int) ERROR;
  256.     _FS_SMC_SectCopyMode[id]=COMPLETED;
  257.     FS__SMC_PHY_Cnt_Reset(id);
  258. }
  261. /*********************************************************************
  262. *
  263. *             _FS_SMC_Chk_MediaPower
  264. */
  266. static int _FS_SMC_Chk_MediaPower(FS_u32 id)
  267. {
  268.     if(FS__SMC_PHY_Chk_CardStsChg(id))      _FS_SMC_MediaChange[id]=(unsigned int) ERROR;
  269.     if((! FS__SMC_PHY_Chk_CntPower(id))&&(! _FS_SMC_MediaChange[id]))          return(SUCCESS);
  270.     if(FS__SMC_PHY_Chk_CardExist(id))
  271.         { _FS_SMC_MediaChange[id]=(unsigned int) ERROR; _FS_SMC_ErrCode[id]=ERR_NoSmartMedia; return(ERROR); }
  272.     if(FS__SMC_PHY_Cnt_PowerOn(id))
  273.         { _FS_SMC_MediaChange[id]=(unsigned int) ERROR; _FS_SMC_ErrCode[id]=ERR_NoSmartMedia; return(ERROR); }
  274.     FS__SMC_PHY_Reset(id);
  275.     return(SUCCESS);
  276. }
  279. /*********************************************************************
  280. *
  281. *             _FS_SMC_Chk_MediaWP
  282. */
  284. static int _FS_SMC_Chk_MediaWP(FS_u32 id)
  285. {
  286.     if(FS__SMC_cardattrib[id].Attribute &MWP)
  287.         { _FS_SMC_ErrCode[id]=ERR_WrtProtect;   return(ERROR); }
  288.     return(SUCCESS);
  289. }
  292. /*********************************************************************
  293. *
  294. *             _FS_SMC_MarkFail_PhyOneBlock
  295. */
  297. static int _FS_SMC_MarkFail_PhyOneBlock(FS_u32 id)
  298. {
  299.     unsigned char sect;
  300.     sect=FS__SMC_cardparam[id].Sector;
  301.     _FS_SMC_Set_FailBlock(_FS_SMC_WorkRedund);
  302.     FS__SMC_PHY_WriteRedtMode(id);
  303.     for(FS__SMC_cardparam[id].Sector=0; FS__SMC_cardparam[id].Sector<FS__SMC_cardattrib[id].MaxSectors; FS__SMC_cardparam[id].Sector++)
  304.         if(FS__SMC_PHY_WriteRedtData(id,_FS_SMC_WorkRedund)) {
  305.             FS__SMC_PHY_Reset(id);
  306.             FS__SMC_cardparam[id].Sector=sect;
  307.             _FS_SMC_ErrCode[id]=ERR_HwError;
  308.             return(ERROR);
  309.         }   /* NO Status Check */
  310.     FS__SMC_PHY_Reset(id);
  311.     FS__SMC_cardparam[id].Sector=sect;
  312.     return(SUCCESS);
  313. }
  316. /*********************************************************************
  317. *
  318. *             _FS_SMC_Set_PhyFmtValue
  319. */
  321. static int _FS_SMC_Set_PhyFmtValue(FS_u32 id)
  322. {
  323.     unsigned short idcode;
  324.     FS__SMC_PHY_ReadID(id,&idcode);
  325.     if(FS__SMC_PHY_Set_Model(id,(unsigned char)idcode))
  326.         return(ERROR);
  327.     if(FS__SMC_PHY_Chk_WP(id))
  328.         FS__SMC_cardattrib[id].Attribute|=WP;
  329.     return(SUCCESS);
  330. }
  333. /*********************************************************************
  334. *
  335. *             _FS_SMC_Search_CIS
  336. */
  338. static int _FS_SMC_Search_CIS(FS_u32 id,unsigned short *pcis)
  339. {
  340.     FS__SMC_cardparam[id].Zone=0;   FS__SMC_cardparam[id].Sector=0;
  341.     for(FS__SMC_cardparam[id].PhyBlock=0; FS__SMC_cardparam[id].PhyBlock<(FS__SMC_cardattrib[id].MaxBlocks-FS__SMC_cardattrib[id].MaxLogBlocks-1); FS__SMC_cardparam[id].PhyBlock++) {
  342.         if(FS__SMC_PHY_ReadRedtData(id,_FS_SMC_Redundant))
  343.             { FS__SMC_PHY_Reset(id);        return(ERROR); }
  344.         if(! _FS_SMC_Chk_FailBlock(_FS_SMC_Redundant)) {
  345.             if(_FS_SMC_Chk_CisBlock(_FS_SMC_Redundant))
  346.                 { FS__SMC_PHY_Reset(id);    return(ERROR); }
  347.             break;
  348.         }
  349.     }
  350.     while(FS__SMC_cardparam[id].Sector<FS__SMC_cardattrib[id].MaxSectors) {
  351.         if(FS__SMC_cardparam[id].Sector)
  352.             if(FS__SMC_PHY_ReadRedtData(id,_FS_SMC_Redundant))
  353.                 { FS__SMC_PHY_Reset(id);    return(ERROR); }
  354.         if(! _FS_SMC_Chk_DataStatus(_FS_SMC_Redundant)) {
  355.             if(FS__SMC_PHY_ReadSect(id,_FS_SMC_WorkBuf,_FS_SMC_Redundant))
  356.                 { FS__SMC_PHY_Reset(id);    return(ERROR); }
  357.             if(FS__SMC_ECC_Chk_CISdata(_FS_SMC_WorkBuf,_FS_SMC_Redundant))
  358.                 { FS__SMC_PHY_Reset(id);    return(ERROR); }
  359.             *pcis=FS__SMC_cardparam[id].PhyBlock;
  360.             FS__SMC_PHY_Reset(id);
  361.             return(SUCCESS);
  362.         }
  363.         FS__SMC_cardparam[id].Sector++;
  364.     }
  365.     FS__SMC_PHY_Reset(id);
  366.     return(ERROR);
  367. }
  370. /*********************************************************************
  371. *
  372. *             _FS_SMC_Make_LogTable
  373. */
  375. static int _FS_SMC_Make_LogTable(FS_u32 id,unsigned short start)
  376. {
  377.     unsigned short block;
  378.     FS__SMC_cardparam[id].Sector=0;
  379.         /*****/
  380.         for(FS__SMC_cardparam[id].LogBlock=0; FS__SMC_cardparam[id].LogBlock<FS__SMC_cardattrib[id].MaxLogBlocks; FS__SMC_cardparam[id].LogBlock++)
  381.             _FS_SMC_Log2Phy[id][FS__SMC_cardparam[id].Zone?1:0][FS__SMC_cardparam[id].LogBlock]=NO_ASSIGN;
  382.         for(FS__SMC_cardparam[id].PhyBlock=0; FS__SMC_cardparam[id].PhyBlock<(MAX_BLOCKNUM/8); FS__SMC_cardparam[id].PhyBlock++)
  383.             _FS_SMC_Assign[id][FS__SMC_cardparam[id].Zone?1:0][FS__SMC_cardparam[id].PhyBlock]=0x00;
  384.         /*******************************************************************/
  385.         for(FS__SMC_cardparam[id].PhyBlock=0; FS__SMC_cardparam[id].PhyBlock<FS__SMC_cardattrib[id].MaxBlocks; FS__SMC_cardparam[id].PhyBlock++) {
  386.             if((! FS__SMC_cardparam[id].Zone) && (FS__SMC_cardparam[id].PhyBlock<start)) {
  387.                 Set_X_Bit(_FS_SMC_Assign[id][FS__SMC_cardparam[id].Zone?1:0],FS__SMC_cardparam[id].PhyBlock);
  388.                 continue;
  389.             }
  390.             if(FS__SMC_PHY_ReadRedtData(id,_FS_SMC_Redundant))
  391.                 { FS__SMC_PHY_Reset(id); return(ERROR); }
  392.             if(! _FS_SMC_Chk_DataBlank(_FS_SMC_Redundant))
  393.                 continue;
  394.             Set_X_Bit(_FS_SMC_Assign[id][FS__SMC_cardparam[id].Zone?1:0],FS__SMC_cardparam[id].PhyBlock);
  395.             if(_FS_SMC_Chk_FailBlock(_FS_SMC_Redundant))
  396.                 continue;
  397.             if(_FS_SMC_Load_LogBlockAddr(id,_FS_SMC_Redundant))
  398.                 continue;
  399.             if(FS__SMC_cardparam[id].LogBlock>=FS__SMC_cardattrib[id].MaxLogBlocks)
  400.                 continue;
  401.             if(_FS_SMC_Log2Phy[id][FS__SMC_cardparam[id].Zone?1:0][FS__SMC_cardparam[id].LogBlock]==NO_ASSIGN) {
  402.                 _FS_SMC_Log2Phy[id][FS__SMC_cardparam[id].Zone?1:0][FS__SMC_cardparam[id].LogBlock]=FS__SMC_cardparam[id].PhyBlock;
  403.                 continue;
  404.             }
  405.             FS__SMC_cardparam[id].Sector=FS__SMC_cardattrib[id].MaxSectors-1;
  406.             if(FS__SMC_PHY_ReadRedtData(id,_FS_SMC_Redundant))
  407.                 { FS__SMC_PHY_Reset(id); return(ERROR); }
  408.             FS__SMC_cardparam[id].Sector=0;
  409.             block=FS__SMC_cardparam[id].LogBlock;
  410.             if(! _FS_SMC_Load_LogBlockAddr(id,_FS_SMC_Redundant))
  411.                 if(FS__SMC_cardparam[id].LogBlock==block) {
  412. #ifdef L2P_ERR_ERASE    /***************************************************/
  413.                     block=_FS_SMC_Log2Phy[id][FS__SMC_cardparam[id].Zone?1:0][FS__SMC_cardparam[id].LogBlock];
  414.                     _FS_SMC_Log2Phy[id][FS__SMC_cardparam[id].Zone?1:0][FS__SMC_cardparam[id].LogBlock]=FS__SMC_cardparam[id].PhyBlock;
  415.                     FS__SMC_cardparam[id].PhyBlock=block;
  416.                     if(!(FS__SMC_cardattrib[id].Attribute &MWP)) {
  417.                         FS__SMC_PHY_Reset(id);
  418.                         if(FS__SMC_PHY_EraseBlock(id))      return(ERROR);
  419.                         if(FS__SMC_PHY_CheckStatus(id))
  420.                             { if(_FS_SMC_MarkFail_PhyOneBlock(id))    return(ERROR); }
  421.                         else Clr_X_Bit(_FS_SMC_Assign[id][FS__SMC_cardparam[id].Zone?1:0],FS__SMC_cardparam[id].PhyBlock);
  422.                     }
  423.                     FS__SMC_cardparam[id].PhyBlock=_FS_SMC_Log2Phy[id][FS__SMC_cardparam[id].Zone?1:0][FS__SMC_cardparam[id].LogBlock];
  424. #else   /*******************************************************************/
  425.                     _FS_SMC_Log2Phy[id][FS__SMC_cardparam[id].Zone?1:0][FS__SMC_cardparam[id].LogBlock]=FS__SMC_cardparam[id].PhyBlock;
  426. #endif  /*******************************************************************/
  427.                     continue;
  428.                 }
  429. #ifdef L2P_ERR_ERASE    /***************************************************/
  430.             if(!(FS__SMC_cardattrib[id].Attribute &MWP)) {
  431.                 FS__SMC_PHY_Reset(id);
  432.                 if(FS__SMC_PHY_EraseBlock(id))      return(ERROR);
  433.                 if(FS__SMC_PHY_CheckStatus(id))
  434.                     { if(_FS_SMC_MarkFail_PhyOneBlock(id))    return(ERROR); }
  435.                 else Clr_X_Bit(_FS_SMC_Assign[id][FS__SMC_cardparam[id].Zone?1:0],FS__SMC_cardparam[id].PhyBlock);
  436.             }
  437. #endif  /*******************************************************************/
  438.         }
  439.         _FS_SMC_AssignStart[id][FS__SMC_cardparam[id].Zone?1:0]=0;
  440.         /*****/
  441.     FS__SMC_PHY_Reset(id);
  442.     return(SUCCESS);
  443. }
  446. /*********************************************************************
  447. *
  448. *             _FS_SMC_Check_MediaFmt
  449. */
  451. static int _FS_SMC_Check_MediaFmt(FS_u32 id)
  452. {
  453.     unsigned short cis;
  454.     if(! _FS_SMC_MediaChange[id])               return(SUCCESS);
  455.     _FS_SMC_MediaChange[id]=(unsigned int) ERROR;
  456.     _FS_SMC_SectCopyMode[id]=COMPLETED;
  457.     if(_FS_SMC_Set_PhyFmtValue(id))
  458.         { _FS_SMC_ErrCode[id]=ERR_UnknownMedia; return(ERROR); }
  459.     if(_FS_SMC_Search_CIS(id,&cis))
  460.         { _FS_SMC_ErrCode[id]=ERR_IllegalFmt;   return(ERROR); }
  461.     _FS_SMC_AssignZone[id]=0;
  462.     FS__SMC_cardparam[id].Zone=0;
  463.     if(_FS_SMC_Make_LogTable(id,cis+1))
  464.         { _FS_SMC_ErrCode[id]=ERR_IllegalFmt;   return(ERROR); }
  465.     _FS_SMC_MediaChange[id]=SUCCESS;
  466.     return(SUCCESS);
  467. }
  470. /*********************************************************************
  471. *
  472. *             _FS_SMC_Conv_MediaAddr
  473. */
  475. static int _FS_SMC_Conv_MediaAddr(FS_u32 id,unsigned long addr)
  476. {
  477.     unsigned long temp;
  478.     unsigned short block;
  479.     unsigned char sect;
  480.     temp          =addr/FS__SMC_cardattrib[id].MaxSectors;
  481.     FS__SMC_cardparam[id].Sector  =addr%FS__SMC_cardattrib[id].MaxSectors;
  482.     FS__SMC_cardparam[id].LogBlock=temp%FS__SMC_cardattrib[id].MaxLogBlocks;
  483.     FS__SMC_cardparam[id].Zone    =temp/FS__SMC_cardattrib[id].MaxLogBlocks;
  484.     if(FS__SMC_cardparam[id].Zone<FS__SMC_cardattrib[id].MaxZones) {
  485.         if(FS__SMC_cardparam[id].Zone!=0 && FS__SMC_cardparam[id].Zone!=_FS_SMC_AssignZone[id]) {
  486.             _FS_SMC_AssignZone[id]=0;
  487.             block=FS__SMC_cardparam[id].LogBlock;
  488.             sect=FS__SMC_cardparam[id].Sector;
  489.             if(_FS_SMC_Make_LogTable(id,0))
  490.                 { _FS_SMC_ErrCode[id]=ERR_IllegalFmt;   return(ERROR); }
  491.             _FS_SMC_AssignZone[id]=FS__SMC_cardparam[id].Zone;
  492.             FS__SMC_cardparam[id].LogBlock=block;
  493.             FS__SMC_cardparam[id].Sector=sect;
  494.         }
  495.         _FS_SMC_Clr_RedundantData(_FS_SMC_Redundant);
  496.         _FS_SMC_Set_LogBlockAddr(id,_FS_SMC_Redundant);
  497.         FS__SMC_cardparam[id].PhyBlock=_FS_SMC_Log2Phy[id][FS__SMC_cardparam[id].Zone?1:0][FS__SMC_cardparam[id].LogBlock];
  498.         return(SUCCESS);
  499.     }
  500.     _FS_SMC_ErrCode[id]=ERR_OutOfLBA;
  501.     return(ERROR);
  502. }
  505. /*********************************************************************
  506. *
  507. *             _FS_SMC_Inc_MediaAddr
  508. */
  510. static int _FS_SMC_Inc_MediaAddr(FS_u32 id)
  511. {
  512.     unsigned short block;
  513.     unsigned char sect;
  514.     if(++FS__SMC_cardparam[id].Sector<FS__SMC_cardattrib[id].MaxSectors)
  515.         return(SUCCESS);
  516.     FS__SMC_cardparam[id].Sector=0;
  517.     if(++FS__SMC_cardparam[id].LogBlock<FS__SMC_cardattrib[id].MaxLogBlocks) {
  518.         _FS_SMC_Clr_RedundantData(_FS_SMC_Redundant);
  519.         _FS_SMC_Set_LogBlockAddr(id,_FS_SMC_Redundant);
  520.         FS__SMC_cardparam[id].PhyBlock=_FS_SMC_Log2Phy[id][FS__SMC_cardparam[id].Zone?1:0][FS__SMC_cardparam[id].LogBlock];
  521.         return(SUCCESS);
  522.     }
  523.     FS__SMC_cardparam[id].LogBlock=0;
  524.     if(++FS__SMC_cardparam[id].Zone<FS__SMC_cardattrib[id].MaxZones) {
  525.         if(FS__SMC_cardparam[id].Zone!=_FS_SMC_AssignZone[id]) {
  526.             _FS_SMC_AssignZone[id]=0;
  527.             block=FS__SMC_cardparam[id].LogBlock;
  528.             sect=FS__SMC_cardparam[id].Sector;
  529.             if(_FS_SMC_Make_LogTable(id,0))
  530.                 { _FS_SMC_ErrCode[id]=ERR_IllegalFmt;   return(ERROR); }
  531.             _FS_SMC_AssignZone[id]=FS__SMC_cardparam[id].Zone;
  532.             FS__SMC_cardparam[id].LogBlock=block;
  533.             FS__SMC_cardparam[id].Sector=sect;
  534.         }
  535.         _FS_SMC_Clr_RedundantData(_FS_SMC_Redundant);
  536.         _FS_SMC_Set_LogBlockAddr(id,_FS_SMC_Redundant);
  537.         FS__SMC_cardparam[id].PhyBlock=_FS_SMC_Log2Phy[id][FS__SMC_cardparam[id].Zone?1:0][FS__SMC_cardparam[id].LogBlock];
  538.         return(SUCCESS);
  539.     }
  540.     FS__SMC_cardparam[id].Zone=0;
  541.     _FS_SMC_ErrCode[id]=ERR_OutOfLBA;
  542.     return(ERROR);
  543. }
  546. /*********************************************************************
  547. *
  548. *             _FS_SMC_Chk_FirstSect
  549. */
  551. static int _FS_SMC_Chk_FirstSect(FS_u32 id)
  552. {
  553.     if(! FS__SMC_cardparam[id].Sector)
  554.         return(SUCCESS);
  555.     return(ERROR);
  556. }
  559. /*********************************************************************
  560. *
  561. *             _FS_SMC_Chk_LastSect
  562. */
  564. static int _FS_SMC_Chk_LastSect(FS_u32 id)
  565. {
  566.     if(FS__SMC_cardparam[id].Sector<(FS__SMC_cardattrib[id].MaxSectors-1))
  567.         return(ERROR);
  568.     return(SUCCESS);
  569. }
  572. /*********************************************************************
  573. *
  574. *             _FS_SMC_Copy_PhyOneSect
  575. */
  577. static int _FS_SMC_Copy_PhyOneSect(FS_u32 id)
  578. {
  579.     int i;
  580.     unsigned int err, retry;
  581.     if(_FS_SMC_ReadBlock[id]!=NO_ASSIGN) {
  582.         FS__SMC_cardparam[id].PhyBlock=_FS_SMC_ReadBlock[id];
  583.         for(retry=0; retry<2; retry++) {
  584.             err=SUCCESS;
  585.             if(FS__SMC_PHY_ReadSect(id,_FS_SMC_WorkBuf,_FS_SMC_WorkRedund))
  586.                 { _FS_SMC_ErrCode[id]=ERR_HwError;  return(ERROR); }
  587.             if(_FS_SMC_Chk_DataStatus(_FS_SMC_WorkRedund))
  588.                 { err=(unsigned int) ERROR;    break; }
  589.             err=FS__SMC_ECC_Chk_ECCdata(_FS_SMC_WorkBuf,_FS_SMC_WorkRedund);
  590.             if(err==CORRECT)    break;
  591.             if(! err)           break;
  592.             _FS_SMC_SectCopyMode[id]=REQ_FAIL;
  593.         }
  594.     } else {
  595.         err=SUCCESS;
  596.         for(i=0; i<SECTSIZE; i++)
  597.             _FS_SMC_WorkBuf[i]=DUMMY_DATA;
  598.         _FS_SMC_Clr_RedundantData(_FS_SMC_WorkRedund);
  599.     }
  600.     _FS_SMC_Set_LogBlockAddr(id,_FS_SMC_WorkRedund);
  601.     if(err==CORRECT)
  602.         FS__SMC_ECC_Set_ECCdata(_FS_SMC_WorkBuf,_FS_SMC_WorkRedund);
  603.     if(err==(unsigned int)ERROR) {
  604.         FS__SMC_ECC_Set_ECCdata(_FS_SMC_WorkBuf,_FS_SMC_WorkRedund);
  605.         _FS_SMC_Set_DataStatus(_FS_SMC_WorkRedund);
  606.     }
  607.     FS__SMC_cardparam[id].PhyBlock=_FS_SMC_WriteBlock[id];
  608.     if(FS__SMC_PHY_WriteSect(id,_FS_SMC_WorkBuf,_FS_SMC_WorkRedund))
  609.         { _FS_SMC_ErrCode[id]=ERR_HwError;      return(ERROR); }
  610.     if(FS__SMC_PHY_CheckStatus(id))
  611.         { _FS_SMC_ErrCode[id]=ERR_WriteFault;   return(ERROR); }
  612.     FS__SMC_cardparam[id].PhyBlock=_FS_SMC_ReadBlock[id];
  613.     return(SUCCESS);
  614. }
  617. /*********************************************************************
  618. *
  619. *             _FS_SMC_Read_PhyOneSect
  620. */
  622. static int _FS_SMC_Read_PhyOneSect(FS_u32 id,unsigned char *buf)
  623. {
  624.     int i;
  625.     unsigned int err, retry;
  626.     if(FS__SMC_cardparam[id].PhyBlock==NO_ASSIGN) {
  627.         for(i=0; i<SECTSIZE; i++)
  628.             *buf++=DUMMY_DATA;
  629.         return(SUCCESS);
  630.     }
  631.     for(retry=0; retry<2; retry++) {
  632.         if(FS__SMC_PHY_ReadSect(id,buf,_FS_SMC_Redundant))
  633.             { _FS_SMC_ErrCode[id]=ERR_HwError;      return(ERROR); }
  634.         if(_FS_SMC_Chk_DataStatus(_FS_SMC_Redundant))
  635.             { _FS_SMC_ErrCode[id]=ERR_DataStatus;   return(ERROR); }
  636.         if(! (err=FS__SMC_ECC_Chk_ECCdata(buf,_FS_SMC_Redundant)))
  637.             return(SUCCESS);
  638.     }
  639.     if(err==CORRECT)
  640.          _FS_SMC_ErrCode[id]=ERR_CorReadErr;
  641.     else _FS_SMC_ErrCode[id]=ERR_EccReadErr;
  642.     return(ERROR);
  643. }
  646. /*********************************************************************
  647. *
  648. *             _FS_SMC_Write_PhyOneSect
  649. */
  651. static int _FS_SMC_Write_PhyOneSect(FS_u32 id,unsigned char *buf)
  652. {
  653.     FS__SMC_ECC_Set_ECCdata(buf,_FS_SMC_Redundant);
  654.     if(FS__SMC_PHY_WriteSect(id,buf,_FS_SMC_Redundant))
  655.         { _FS_SMC_ErrCode[id]=ERR_HwError;      return(ERROR); }
  656.     if(FS__SMC_PHY_CheckStatus(id))
  657.         { _FS_SMC_ErrCode[id]=ERR_WriteFault;   return(ERROR); }
  658.     return(SUCCESS);
  659. }
  662. /*********************************************************************
  663. *
  664. *             _FS_SMC_Erase_PhyOneBlock
  665. */
  667. static int _FS_SMC_Erase_PhyOneBlock(FS_u32 id)
  668. {
  669.     if(FS__SMC_PHY_EraseBlock(id))
  670.         { _FS_SMC_ErrCode[id]=ERR_HwError;      return(ERROR); }
  671.     if(FS__SMC_PHY_CheckStatus(id))
  672.         { _FS_SMC_ErrCode[id]=ERR_WriteFault;   return(ERROR); }
  673.     return(SUCCESS);
  674. }
  677. /*********************************************************************
  678. *
  679. *             _FS_SMC_Assign_WriteBlock
  680. */
  682. static int _FS_SMC_Assign_WriteBlock(FS_u32 id)
  683. {
  684.     _FS_SMC_ReadBlock[id]=FS__SMC_cardparam[id].PhyBlock;
  685.     for(_FS_SMC_WriteBlock[id]=_FS_SMC_AssignStart[id][FS__SMC_cardparam[id].Zone?1:0]; _FS_SMC_WriteBlock[id]<FS__SMC_cardattrib[id].MaxBlocks; _FS_SMC_WriteBlock[id]++)
  686.         if(! Chk_X_Bit(_FS_SMC_Assign[id][FS__SMC_cardparam[id].Zone?1:0],_FS_SMC_WriteBlock[id])) {
  687.             Set_X_Bit(_FS_SMC_Assign[id][FS__SMC_cardparam[id].Zone?1:0],_FS_SMC_WriteBlock[id]);
  688.             _FS_SMC_AssignStart[id][FS__SMC_cardparam[id].Zone?1:0]=_FS_SMC_WriteBlock[id]+1;
  689.             FS__SMC_cardparam[id].PhyBlock=_FS_SMC_WriteBlock[id];
  690.             _FS_SMC_SectCopyMode[id]=REQ_ERASE;
  691.             return(SUCCESS);
  692.         }
  693.     for(_FS_SMC_WriteBlock[id]=0; _FS_SMC_WriteBlock[id]<_FS_SMC_AssignStart[id][FS__SMC_cardparam[id].Zone?1:0]; _FS_SMC_WriteBlock[id]++)
  694.         if(! Chk_X_Bit(_FS_SMC_Assign[id][FS__SMC_cardparam[id].Zone?1:0],_FS_SMC_WriteBlock[id])) {
  695.             Set_X_Bit(_FS_SMC_Assign[id][FS__SMC_cardparam[id].Zone?1:0],_FS_SMC_WriteBlock[id]);
  696.             _FS_SMC_AssignStart[id][FS__SMC_cardparam[id].Zone?1:0]=_FS_SMC_WriteBlock[id]+1;
  697.             FS__SMC_cardparam[id].PhyBlock=_FS_SMC_WriteBlock[id];
  698.             _FS_SMC_SectCopyMode[id]=REQ_ERASE;
  699.             return(SUCCESS);
  700.         }
  701.     _FS_SMC_WriteBlock[id]=NO_ASSIGN;
  702.     _FS_SMC_ErrCode[id]=ERR_WriteFault;
  703.     return(ERROR);
  704. }
  707. /*********************************************************************
  708. *
  709. *             _FS_SMC_Release_ReadBlock
  710. */
  712. static int _FS_SMC_Release_ReadBlock(FS_u32 id)
  713. {
  714.     unsigned int mode;
  715.     mode=_FS_SMC_SectCopyMode[id];
  716.     _FS_SMC_SectCopyMode[id]=COMPLETED;
  717.     if(mode==COMPLETED)             return(SUCCESS);
  718.     _FS_SMC_Log2Phy[id][FS__SMC_cardparam[id].Zone?1:0][FS__SMC_cardparam[id].LogBlock]=_FS_SMC_WriteBlock[id];
  719.     FS__SMC_cardparam[id].PhyBlock=_FS_SMC_ReadBlock[id];
  720.     if(FS__SMC_cardparam[id].PhyBlock==NO_ASSIGN)
  721.       { FS__SMC_cardparam[id].PhyBlock=_FS_SMC_WriteBlock[id];  return(SUCCESS); }
  722.     if(mode==REQ_ERASE) {
  723.         if(_FS_SMC_Erase_PhyOneBlock(id)) {
  724.             if(_FS_SMC_ErrCode[id]==ERR_HwError)    return(ERROR);
  725.             if(_FS_SMC_MarkFail_PhyOneBlock(id))  return(ERROR);
  726.         } else Clr_X_Bit(_FS_SMC_Assign[id][FS__SMC_cardparam[id].Zone?1:0],FS__SMC_cardparam[id].PhyBlock);
  727.     } else if(_FS_SMC_MarkFail_PhyOneBlock(id))   return(ERROR);
  728.     FS__SMC_cardparam[id].PhyBlock=_FS_SMC_WriteBlock[id];
  729.     return(SUCCESS);
  730. }
  733. /*********************************************************************
  734. *
  735. *             _FS_SMC_Release_WriteBlock
  736. */
  738. static int _FS_SMC_Release_WriteBlock(FS_u32 id)
  739. {
  740.     _FS_SMC_SectCopyMode[id]=COMPLETED;
  741.     FS__SMC_cardparam[id].PhyBlock=_FS_SMC_WriteBlock[id];
  742.     if(_FS_SMC_MarkFail_PhyOneBlock(id))      return(ERROR);
  743.     FS__SMC_cardparam[id].PhyBlock=_FS_SMC_ReadBlock[id];
  744.     return(SUCCESS);
  745. }
  748. /*********************************************************************
  749. *
  750. *             _FS_SMC_Copy_BlockAll
  751. */
  753. static int _FS_SMC_Copy_BlockAll(FS_u32 id,unsigned int mode)
  754. {
  755.     unsigned char sect;
  756.     sect=FS__SMC_cardparam[id].Sector;
  757.     if(_FS_SMC_Assign_WriteBlock(id))         return(ERROR);
  758.     if(mode==REQ_FAIL)      _FS_SMC_SectCopyMode[id]=REQ_FAIL;
  759.     for(FS__SMC_cardparam[id].Sector=0; FS__SMC_cardparam[id].Sector<FS__SMC_cardattrib[id].MaxSectors; FS__SMC_cardparam[id].Sector++)
  760.         if(_FS_SMC_Copy_PhyOneSect(id)) {
  761.             if(_FS_SMC_ErrCode[id]==ERR_HwError)    return(ERROR);
  762.             if(_FS_SMC_Release_WriteBlock(id))    return(ERROR);
  763.             _FS_SMC_ErrCode[id]=ERR_WriteFault;
  764.             FS__SMC_cardparam[id].PhyBlock=_FS_SMC_ReadBlock[id];
  765.             FS__SMC_cardparam[id].Sector=sect;
  766.             return(ERROR);
  767.         }
  768.     if(_FS_SMC_Release_ReadBlock(id))         return(ERROR);
  769.     FS__SMC_cardparam[id].PhyBlock=_FS_SMC_WriteBlock[id];
  770.     FS__SMC_cardparam[id].Sector=sect;
  771.     return(SUCCESS);
  772. }
  775. /*********************************************************************
  776. *
  777. *             _FS_SMC_Copy_BlockHead
  778. */
  780. static int _FS_SMC_Copy_BlockHead(FS_u32 id)
  781. {
  782.     unsigned char sect;
  783.     sect=FS__SMC_cardparam[id].Sector;
  784.     if(_FS_SMC_Assign_WriteBlock(id))         return(ERROR);
  785.     for(FS__SMC_cardparam[id].Sector=0; FS__SMC_cardparam[id].Sector<sect; FS__SMC_cardparam[id].Sector++)
  786.         if(_FS_SMC_Copy_PhyOneSect(id)) {
  787.             if(_FS_SMC_ErrCode[id]==ERR_HwError)    return(ERROR);
  788.             if(_FS_SMC_Release_WriteBlock(id))    return(ERROR);
  789.             _FS_SMC_ErrCode[id]=ERR_WriteFault;
  790.             FS__SMC_cardparam[id].PhyBlock=_FS_SMC_ReadBlock[id];
  791.             FS__SMC_cardparam[id].Sector=sect;
  792.             return(ERROR);
  793.         }
  794.     FS__SMC_cardparam[id].PhyBlock=_FS_SMC_WriteBlock[id];
  795.     FS__SMC_cardparam[id].Sector=sect;
  796.     return(SUCCESS);
  797. }
  800. /*********************************************************************
  801. *
  802. *             _FS_SMC_Copy_BlockTail
  803. */
  805. static int _FS_SMC_Copy_BlockTail(FS_u32 id)
  806. {
  807.     unsigned char sect;
  808.     for(sect=FS__SMC_cardparam[id].Sector; FS__SMC_cardparam[id].Sector<FS__SMC_cardattrib[id].MaxSectors; FS__SMC_cardparam[id].Sector++)
  809.         if(_FS_SMC_Copy_PhyOneSect(id)) {
  810.             if(_FS_SMC_ErrCode[id]==ERR_HwError)    return(ERROR);
  811.             FS__SMC_cardparam[id].PhyBlock=_FS_SMC_WriteBlock[id];
  812.             FS__SMC_cardparam[id].Sector=sect;
  813.             return(ERROR);
  814.         }
  815.     if(_FS_SMC_Release_ReadBlock(id))         return(ERROR);
  816.     FS__SMC_cardparam[id].PhyBlock=_FS_SMC_WriteBlock[id];
  817.     FS__SMC_cardparam[id].Sector=sect;
  818.     return(SUCCESS);
  819. }
  822. /*********************************************************************
  823. *
  824. *             _FS_SMC_Reassign_BlockHead
  825. */
  827. static int _FS_SMC_Reassign_BlockHead(FS_u32 id)
  828. {
  829.     unsigned int mode;
  830.     unsigned short block;
  831.     unsigned char sect;
  832.     mode=_FS_SMC_SectCopyMode[id];
  833.     block=_FS_SMC_ReadBlock[id];
  834.     sect=FS__SMC_cardparam[id].Sector;
  835.     if(_FS_SMC_Assign_WriteBlock(id))         return(ERROR);
  836.     _FS_SMC_SectCopyMode[id]=REQ_FAIL;
  837.     for(FS__SMC_cardparam[id].Sector=0; FS__SMC_cardparam[id].Sector<sect; FS__SMC_cardparam[id].Sector++)
  838.         if(_FS_SMC_Copy_PhyOneSect(id)) {
  839.             if(_FS_SMC_ErrCode[id]==ERR_HwError)    return(ERROR);
  840.             if(_FS_SMC_Release_WriteBlock(id))    return(ERROR);
  841.             _FS_SMC_ErrCode[id]=ERR_WriteFault;
  842.             _FS_SMC_SectCopyMode[id]=mode;
  843.             _FS_SMC_WriteBlock[id]=_FS_SMC_ReadBlock[id];
  844.             _FS_SMC_ReadBlock[id]=block;
  845.             FS__SMC_cardparam[id].Sector=sect;
  846.             FS__SMC_cardparam[id].PhyBlock=_FS_SMC_WriteBlock[id];
  847.             return(ERROR);
  848.         }
  849.     if(_FS_SMC_Release_ReadBlock(id))         return(ERROR);
  850.     _FS_SMC_SectCopyMode[id]=mode;
  851.     _FS_SMC_ReadBlock[id]=block;
  852.     FS__SMC_cardparam[id].Sector=sect;
  853.     FS__SMC_cardparam[id].PhyBlock=_FS_SMC_WriteBlock[id];
  854.     return(SUCCESS);
  855. }
  858. /*********************************************************************
  859. *
  860. *             _FS_SMC_Media_ReadOneSect
  861. */
  863. static int _FS_SMC_Media_ReadOneSect(FS_u32 id,unsigned char *buf)
  864. {
  865.     unsigned int err, retry;
  866.     if(! _FS_SMC_Read_PhyOneSect(id,buf))      return(SUCCESS);
  867.     if(_FS_SMC_ErrCode[id]==ERR_HwError)        return(ERROR);
  868.     if(_FS_SMC_ErrCode[id]==ERR_DataStatus)     return(ERROR);
  869. #ifdef RDERR_REASSIGN   /***************************************************/
  870.     if(FS__SMC_cardattrib[id].Attribute &MWP) {
  871.         if(_FS_SMC_ErrCode[id]==ERR_CorReadErr) return(SUCCESS);
  872.         return(ERROR);
  873.     }
  874.     err=_FS_SMC_ErrCode[id];
  875.     for(retry=0; retry<2; retry++) {
  876.         if(_FS_SMC_Copy_BlockAll(id,(err==ERR_EccReadErr)?REQ_FAIL:REQ_ERASE)) {
  877.             if(_FS_SMC_ErrCode[id]==ERR_HwError) return(ERROR);
  878.             continue;
  879.         }
  880.         _FS_SMC_ErrCode[id]=err;
  881.         if(_FS_SMC_ErrCode[id]==ERR_CorReadErr) return(SUCCESS);
  882.         return(ERROR);
  883.     }
  884. #else   /*******************************************************************/
  885.     if(_FS_SMC_ErrCode[id]==ERR_CorReadErr)     return(SUCCESS);
  886. #endif  /*******************************************************************/
  887.     return(ERROR);
  888. }
  891. /*********************************************************************
  892. *
  893. *             _FS_SMC_Media_WriteOneSect
  894. */
  896. static int _FS_SMC_Media_WriteOneSect(FS_u32 id,unsigned char *buf)
  897. {
  898.     unsigned int retry;
  899.     if(! _FS_SMC_Write_PhyOneSect(id,buf))     return(SUCCESS);
  900.     if(_FS_SMC_ErrCode[id]==ERR_HwError)        return(ERROR);
  901.     for(retry=1; retry<2; retry++) {
  902.         if(_FS_SMC_Reassign_BlockHead(id)) {
  903.             if(_FS_SMC_ErrCode[id]==ERR_HwError) return(ERROR);
  904.             continue;
  905.         }
  906.         if(! _FS_SMC_Write_PhyOneSect(id,buf)) return(SUCCESS);
  907.         if(_FS_SMC_ErrCode[id]==ERR_HwError)    return(ERROR);
  908.     }
  909.     if(_FS_SMC_Release_WriteBlock(id))        return(ERROR);
  910.     _FS_SMC_ErrCode[id]=ERR_WriteFault;
  911.     return(ERROR);
  912. }
  915. /*********************************************************************
  916. *
  917. *             _FS_SMC_Media_CopyBlockHead
  918. */
  920. static int _FS_SMC_Media_CopyBlockHead(FS_u32 id)
  921. {
  922.     unsigned int retry;
  923.     for(retry=0; retry<2; retry++) {
  924.         if(! _FS_SMC_Copy_BlockHead(id))      return(SUCCESS);
  925.         if(_FS_SMC_ErrCode[id]==ERR_HwError)    return(ERROR);
  926.     }
  927.     return(ERROR);
  928. }
  931. /*********************************************************************
  932. *
  933. *             _FS_SMC_Media_CopyBlockTail
  934. */
  936. static int _FS_SMC_Media_CopyBlockTail(FS_u32 id)
  937. {
  938.     unsigned int retry;
  939.     if(! _FS_SMC_Copy_BlockTail(id))          return(SUCCESS);
  940.     if(_FS_SMC_ErrCode[id]==ERR_HwError)        return(ERROR);
  941.     for(retry=1; retry<2; retry++) {
  942.         if(_FS_SMC_Reassign_BlockHead(id)) {
  943.             if(_FS_SMC_ErrCode[id]==ERR_HwError) return(ERROR);
  944.             continue;
  945.         }
  946.         if(! _FS_SMC_Copy_BlockTail(id))      return(SUCCESS);
  947.         if(_FS_SMC_ErrCode[id]==ERR_HwError)    return(ERROR);
  948.     }
  949.     if(_FS_SMC_Release_WriteBlock(id))        return(ERROR);
  950.     _FS_SMC_ErrCode[id]=ERR_WriteFault;
  951.     return(ERROR);
  952. }
  955. /*********************************************************************
  956. *
  957. *             Global functions
  958. *
  959. **********************************************************************
  960. */
  962. /*********************************************************************
  963. *
  964. *             FS__SMC_ReadSector
  965. */
  967. int FS__SMC_ReadSector(FS_u32 id,unsigned long start,unsigned short count,unsigned char *buf)
  968. {
  969.     int i;
  970.     if(_FS_SMC_Chk_MediaPower(id))          return(_FS_SMC_ErrCode[id]);
  971.     if(_FS_SMC_Check_MediaFmt(id))          return(_FS_SMC_ErrCode[id]);
  972.     if(_FS_SMC_Conv_MediaAddr(id,start))    return(_FS_SMC_ErrCode[id]);
  973.     while(1) {
  974.         if(_FS_SMC_Media_ReadOneSect(id,_FS_SMC_SectBuf))
  975.           { _FS_SMC_ErrCode[id]=ERR_EccReadErr; return(_FS_SMC_ErrCode[id]); }
  976.         for(i=0;i<SECTSIZE;i++)
  977.             *buf++=_FS_SMC_SectBuf[i];
  978.         if(--count<=0)      break;
  979.         if(_FS_SMC_Inc_MediaAddr(id))         return(_FS_SMC_ErrCode[id]);
  980.     }
  981.     return(NO_ERROR);
  982. }
  985. /*********************************************************************
  986. *
  987. *             FS__SMC_WriteSector
  988. */
  990. int FS__SMC_WriteSector(FS_u32 id,unsigned long start,unsigned short count,unsigned char *buf)
  991. {
  992.     int i;
  993.     if(_FS_SMC_Chk_MediaPower(id))          return(_FS_SMC_ErrCode[id]);
  994.     if(_FS_SMC_Check_MediaFmt(id))          return(_FS_SMC_ErrCode[id]);
  995.     if(_FS_SMC_Chk_MediaWP(id))             return(_FS_SMC_ErrCode[id]);
  996.     if(_FS_SMC_Conv_MediaAddr(id,start))    return(_FS_SMC_ErrCode[id]);
  997.     if(_FS_SMC_Chk_FirstSect(id))
  998.         if(_FS_SMC_Media_CopyBlockHead(id))
  999.           { _FS_SMC_ErrCode[id]=ERR_WriteFault; return(_FS_SMC_ErrCode[id]); }
  1000.     while(1) {
  1001.         if(! _FS_SMC_Chk_FirstSect(id))
  1002.             if(_FS_SMC_Assign_WriteBlock(id)) return(_FS_SMC_ErrCode[id]);
  1003.         for(i=0;i<SECTSIZE;i++)
  1004.             _FS_SMC_SectBuf[i]=*buf++;
  1005.         if(_FS_SMC_Media_WriteOneSect(id,_FS_SMC_SectBuf))
  1006.           { _FS_SMC_ErrCode[id]=ERR_WriteFault; return(_FS_SMC_ErrCode[id]); }
  1007.         if(! _FS_SMC_Chk_LastSect(id)) {
  1008.             if(_FS_SMC_Release_ReadBlock(id))
  1009.                 if(_FS_SMC_ErrCode[id]==ERR_HwError) {
  1010.                     _FS_SMC_ErrCode[id]=ERR_WriteFault;
  1011.                     return(_FS_SMC_ErrCode[id]);
  1012.                 }
  1013.         }
  1014.         if(--count<=0)      break;
  1015.         if(_FS_SMC_Inc_MediaAddr(id))         return(_FS_SMC_ErrCode[id]);
  1016.     }
  1017.     if(! _FS_SMC_Chk_LastSect(id))          return(NO_ERROR);
  1018.     if(_FS_SMC_Inc_MediaAddr(id))             return(_FS_SMC_ErrCode[id]);
  1019.     if(_FS_SMC_Media_CopyBlockTail(id))
  1020.         { _FS_SMC_ErrCode[id]=ERR_WriteFault;   return(_FS_SMC_ErrCode[id]); }
  1021.     return(NO_ERROR);
  1022. }
  1025. /*********************************************************************
  1026. *
  1027. *             FS__SMC_Init
  1028. */
  1030. int FS__SMC_Init(FS_u32 id)
  1031. {
  1032.     _FS_SMC_Init_Media(id);
  1033.     return(NO_ERROR);
  1034. }
  1036. #endif /* FS_USE_SMC_DRIVER */