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

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

uCOS

开发平台：

C/C++

smc_phy.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_phy.c
  16. Purpose     : SMC generic physical media access
  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"
  38. #include "smc_x_hw.h"
  41. /*********************************************************************
  42. *
  43. *             #define constants
  44. *
  45. **********************************************************************
  46. */
  48. #define EVEN             0          /* Even Page for 256byte/page */
  49. #define ODD              1          /* Odd  Page for 256byte/page */
  52. /*********************************************************************
  53. *
  54. *             Global variables        
  55. *
  56. **********************************************************************
  57. */
  59. struct FS__SMC_ATTRIBTYPE FS__SMC_cardattrib[FS_SMC_MAXUNIT];
  60. struct FS__SMC_PARAMTYPE  FS__SMC_cardparam[FS_SMC_MAXUNIT];
  63. /*********************************************************************
  64. *
  65. *             Local functions
  66. *
  67. **********************************************************************
  68. */
  70. /*********************************************************************
  71. *
  72. *             _FS_SMC_Set_SsfdcCmd
  73. */
  75. static void _FS_SMC_Set_SsfdcCmd(FS_u32 id,unsigned char cmd)
  76. {
  77.     FS_SMC_HW_X_SetCmd(id);
  78.     FS_SMC_HW_X_OutData(id,cmd);
  79.     FS_SMC_HW_X_SetData(id);
  80. }
  83. /*********************************************************************
  84. *
  85. *             _FS_SMC_Set_SsfdcAddr
  86. */
  88. static void _FS_SMC_Set_SsfdcAddr(FS_u32 id,unsigned char add)
  89. {
  90.     unsigned short addr;
  91.     addr=(unsigned short)FS__SMC_cardparam[id].Zone*FS__SMC_cardattrib[id].MaxBlocks+FS__SMC_cardparam[id].PhyBlock;
  92.     addr=addr*(unsigned short)FS__SMC_cardattrib[id].MaxSectors+FS__SMC_cardparam[id].Sector;
  93.     if((FS__SMC_cardattrib[id].Attribute &MPS)==PS256)       /* for 256byte/page */
  94.         addr=addr*2+(unsigned short)add;
  95. /*-----------------------------------------------*/
  96.     FS_SMC_HW_X_SetAddr(id);
  97.     FS_SMC_HW_X_OutData(id,0x00);
  98.     FS_SMC_HW_X_OutData(id,(unsigned char)addr);
  99.     FS_SMC_HW_X_OutData(id,(unsigned char)(addr/0x0100));
  100.     if((FS__SMC_cardattrib[id].Attribute &MADC)==AD4CYC)
  101.         FS_SMC_HW_X_OutData(id,(unsigned char)(FS__SMC_cardparam[id].Zone/2)); /* Patch */
  102.     FS_SMC_HW_X_SetData(id);
  103. }
  106. /*********************************************************************
  107. *
  108. *             _FS_SMC_Set_SsfdcBlock
  109. */
  111. static void _FS_SMC_Set_SsfdcBlock(FS_u32 id)
  112. {
  113.     unsigned short addr;
  114.     addr=(unsigned short)FS__SMC_cardparam[id].Zone*FS__SMC_cardattrib[id].MaxBlocks+FS__SMC_cardparam[id].PhyBlock;
  115.     addr=addr*(unsigned short)FS__SMC_cardattrib[id].MaxSectors;
  116.     if((FS__SMC_cardattrib[id].Attribute &MPS)==PS256)       /* for 256byte/page */
  117.         addr=addr*2;
  118. /*-----------------------------------------------*/
  119.     FS_SMC_HW_X_SetAddr(id);
  120.     FS_SMC_HW_X_OutData(id,(unsigned char)addr);
  121.     FS_SMC_HW_X_OutData(id,(unsigned char)(addr/0x0100));
  122.     if((FS__SMC_cardattrib[id].Attribute &MADC)==AD4CYC)
  123.         FS_SMC_HW_X_OutData(id,(unsigned char)(FS__SMC_cardparam[id].Zone/2)); /* Patch */
  124.     FS_SMC_HW_X_SetData(id);
  125. }
  128. /*********************************************************************
  129. *
  130. *             _FS_SMC_Set_SsfdcChip
  131. */
  133. static void _FS_SMC_Set_SsfdcChip(FS_u32 id)
  134. {
  135.     FS_SMC_HW_X_SetAddr(id);
  136.     FS_SMC_HW_X_OutData(id,0x00);
  137.     FS_SMC_HW_X_SetData(id);
  138. }
  140. /*********************************************************************
  141. *
  142. *             _FS_SMC_Set_SsfdcStandby
  143. */
  145. static void _FS_SMC_Set_SsfdcStandby(FS_u32 id)
  146. {
  147.     FS_SMC_HW_X_SetStandby(id);
  148. }
  151. /*********************************************************************
  152. *
  153. *             _FS_SMC_Chk_SsfdcBusy
  154. */
  156. static int _FS_SMC_Chk_SsfdcBusy(FS_u32 id,unsigned short time)
  157. {
  158.     FS_SMC_HW_X_SetTimer(id,time);
  159.     while(FS_SMC_HW_X_ChkTimer(id))
  160.         if(! FS_SMC_HW_X_ChkBusy(id)) {
  161.             FS_SMC_HW_X_StopTimer(id);
  162.             return(SUCCESS);
  163.         }
  164.     FS_SMC_HW_X_StopTimer(id);
  165.     return(ERROR);
  166. }
  169. /*********************************************************************
  170. *
  171. *             _FS_SMC_Chk_SsfdcStatus
  172. */
  174. static int _FS_SMC_Chk_SsfdcStatus(FS_u32 id)
  175. {
  176.     if(FS_SMC_HW_X_InData(id) &WR_FAIL)   return(ERROR);
  177.     return(SUCCESS);
  178. }
  181. /*********************************************************************
  182. *
  183. *             _FS_SMC_Reset_SsfdcErr
  184. */
  186. static void _FS_SMC_Reset_SsfdcErr(FS_u32 id)
  187. {
  188.     FS_SMC_HW_X_SetCmd(id);
  189.     FS_SMC_HW_X_OutData(id,RST_CHIP);
  190.     FS_SMC_HW_X_SetData(id);
  191.     FS_SMC_HW_X_SetTimer(id,BUSY_RESET);
  192.     while(FS_SMC_HW_X_ChkTimer(id))
  193.         if(! FS_SMC_HW_X_ChkBusy(id))     break;
  194.     FS_SMC_HW_X_StopTimer(id);
  195.     FS_SMC_HW_X_SetStandby(id);
  196. }
  199. /*********************************************************************
  200. *
  201. *             _FS_SMC_Read_SsfdcBuf
  202. */
  204. static void _FS_SMC_Read_SsfdcBuf(FS_u32 id,unsigned char *databuf,unsigned char *redundant)
  205. {
  206.     int i;
  207.     for(i=0x00;i<(((FS__SMC_cardattrib[id].Attribute &MPS)==PS256)?0x100:0x200);i++)
  208.         *databuf++   =FS_SMC_HW_X_InData(id);
  209.     for(i=0x00;i<(((FS__SMC_cardattrib[id].Attribute &MPS)==PS256)?0x08:0x10);i++)
  210.         *redundant++ =FS_SMC_HW_X_InData(id);
  211. }
  214. /*********************************************************************
  215. *
  216. *             _FS_SMC_Write_SsfdcBuf
  217. */
  219. static void _FS_SMC_Write_SsfdcBuf(FS_u32 id,unsigned char *databuf,unsigned char *redundant)
  220. {
  221.     int i;
  222.     for(i=0x00;i<(((FS__SMC_cardattrib[id].Attribute &MPS)==PS256)?0x100:0x200);i++)
  223.         FS_SMC_HW_X_OutData(id,*databuf++);
  224.     for(i=0x00;i<(((FS__SMC_cardattrib[id].Attribute &MPS)==PS256)?0x08:0x10);i++)
  225.         FS_SMC_HW_X_OutData(id,*redundant++);
  226. }
  229. /*********************************************************************
  230. *
  231. *             _FS_SMC_Read_SsfdcWord
  232. */
  234. static void _FS_SMC_Read_SsfdcWord(FS_u32 id,unsigned short *pdata)
  235. {
  236.     *pdata =FS_SMC_HW_X_InData(id)*0x100;
  237.     *pdata|=(unsigned char)FS_SMC_HW_X_InData(id);
  238. }
  241. /*********************************************************************
  242. *
  243. *             _FS_SMC_ReadRedt_SsfdcBuf
  244. */
  246. static void _FS_SMC_ReadRedt_SsfdcBuf(FS_u32 id,unsigned char *redundant)
  247. {
  248.     char i;
  249.     for(i=0x00;i<(((FS__SMC_cardattrib[id].Attribute &MPS)==PS256)?0x08:0x10);i++)
  250.         redundant[i] =FS_SMC_HW_X_InData(id);
  251. }
  254. /*********************************************************************
  255. *
  256. *             _FS_SMC_WriteRedt_SsfdcBuf
  257. */
  259. static void _FS_SMC_WriteRedt_SsfdcBuf(FS_u32 id,unsigned char *redundant)
  260. {
  261.     char i;
  262.     for(i=0x00;i<(((FS__SMC_cardattrib[id].Attribute &MPS)==PS256)?0x08:0x10);i++)
  263.         FS_SMC_HW_X_OutData(id,*redundant++);
  264. }
  267. /*********************************************************************
  268. *
  269. *             _FS_SMC_Check_DevCode
  270. */
  272. static unsigned char _FS_SMC_Check_DevCode(unsigned char dcode)
  273. {
  274.     switch(dcode){
  275.         case 0x6E:
  276.         case 0xE8:
  277.         case 0xEC:  return(SSFDC1MB);       /*  8Mbit (1M) NAND */
  278.         case 0x64:
  279.         case 0xEA:  return(SSFDC2MB);       /* 16Mbit (2M) NAND */
  280.         case 0x6B:
  281.         case 0xE3:
  282.         case 0xE5:  return(SSFDC4MB);       /* 32Mbit (4M) NAND */
  283.         case 0xE6:  return(SSFDC8MB);       /* 64Mbit (8M) NAND */
  284.         case 0x73:  return(SSFDC16MB);      /*128Mbit (16M)NAND */
  285.         case 0x75:  return(SSFDC32MB);      /*256Mbit (32M)NAND */
  286.         case 0x76:  return(SSFDC64MB);      /*512Mbit (64M)NAND */
  287.         case 0x79:  return(SSFDC128MB);     /*  1Gbit(128M)NAND */
  288.         default:    return(0xff);
  289.     }
  290. }
  293. /*********************************************************************
  294. *
  295. *             Global functions
  296. *
  297. **********************************************************************
  298. */
  300. /*********************************************************************
  301. *
  302. *             FS__SMC_PHY_Reset
  303. */
  305. void FS__SMC_PHY_Reset(FS_u32 id)
  306. {
  307.     _FS_SMC_Set_SsfdcCmd(id,RST_CHIP);
  308. #if FS_SMC_HW_SUPPORT_BSYLINE_CHECK
  309.     _FS_SMC_Chk_SsfdcBusy(id,BUSY_RESET);
  310. #else
  311.     FS_SMC_HW_X_WaitTimer(id,BUSY_RESET);
  312. #endif
  313.     _FS_SMC_Set_SsfdcCmd(id,READ);
  314. #if FS_SMC_HW_SUPPORT_BSYLINE_CHECK
  315.     _FS_SMC_Chk_SsfdcBusy(id,BUSY_READ);
  316. #else
  317.     FS_SMC_HW_X_WaitTimer(id,BUSY_READ);
  318. #endif
  319.     _FS_SMC_Set_SsfdcStandby(id);
  320. }
  323. /*********************************************************************
  324. *
  325. *             FS__SMC_PHY_WriteRedtMode
  326. */
  328. void FS__SMC_PHY_WriteRedtMode(FS_u32 id)
  329. {
  330.     _FS_SMC_Set_SsfdcCmd(id,RST_CHIP);
  331. #if FS_SMC_HW_SUPPORT_BSYLINE_CHECK
  332.     _FS_SMC_Chk_SsfdcBusy(id,BUSY_RESET);
  333. #else
  334.     FS_SMC_HW_X_WaitTimer(id,BUSY_RESET);
  335. #endif
  336.     _FS_SMC_Set_SsfdcCmd(id,READ_REDT);
  337. #if FS_SMC_HW_SUPPORT_BSYLINE_CHECK
  338.     _FS_SMC_Chk_SsfdcBusy(id,BUSY_READ);
  339. #else
  340.     FS_SMC_HW_X_WaitTimer(id,BUSY_READ);
  341. #endif
  342.     _FS_SMC_Set_SsfdcStandby(id);
  343. }
  346. /*********************************************************************
  347. *
  348. *             FS__SMC_PHY_ReadID
  349. */
  351. void FS__SMC_PHY_ReadID(FS_u32 id,unsigned short *pid)
  352. {
  353.     _FS_SMC_Set_SsfdcCmd(id,READ_ID);
  354.     _FS_SMC_Set_SsfdcChip(id);
  355.     _FS_SMC_Read_SsfdcWord(id,pid);
  356.     _FS_SMC_Set_SsfdcStandby(id);
  357. }
  360. /*********************************************************************
  361. *
  362. *             FS__SMC_PHY_ReadSect
  363. */
  365. int FS__SMC_PHY_ReadSect(FS_u32 id,unsigned char *buf,unsigned char *redundant)
  366. {
  367.     _FS_SMC_Set_SsfdcCmd(id,READ);
  368.     _FS_SMC_Set_SsfdcAddr(id,EVEN);
  369. #if FS_SMC_HW_SUPPORT_BSYLINE_CHECK
  370.     if(_FS_SMC_Chk_SsfdcBusy(id,BUSY_READ))
  371.         { _FS_SMC_Reset_SsfdcErr(id);        return(ERROR); }
  372. #else
  373.     FS_SMC_HW_X_WaitTimer(id,BUSY_READ);
  374. #endif
  375.     _FS_SMC_Read_SsfdcBuf(id,buf,redundant);
  376. #if FS_SMC_HW_SUPPORT_BSYLINE_CHECK
  377.     if(_FS_SMC_Chk_SsfdcBusy(id,BUSY_READ))
  378.         { _FS_SMC_Reset_SsfdcErr(id);        return(ERROR); }
  379. #else
  380.     FS_SMC_HW_X_WaitTimer(id,BUSY_READ);
  381. #endif
  382.     if((FS__SMC_cardattrib[id].Attribute &MPS)==PS256) {
  383.         _FS_SMC_Set_SsfdcCmd(id,READ);
  384.         _FS_SMC_Set_SsfdcAddr(id,ODD);
  385. #if FS_SMC_HW_SUPPORT_BSYLINE_CHECK
  386.         if(_FS_SMC_Chk_SsfdcBusy(id,BUSY_READ))
  387.             { _FS_SMC_Reset_SsfdcErr(id);    return(ERROR); }
  388. #else
  389.         FS_SMC_HW_X_WaitTimer(id,BUSY_READ);
  390. #endif
  391.         _FS_SMC_Read_SsfdcBuf(id,buf+0x100,redundant+0x08);
  392. #if FS_SMC_HW_SUPPORT_BSYLINE_CHECK
  393.         if(_FS_SMC_Chk_SsfdcBusy(id,BUSY_READ))
  394.             { _FS_SMC_Reset_SsfdcErr(id);    return(ERROR); }
  395. #else
  396.         FS_SMC_HW_X_WaitTimer(id,BUSY_READ);
  397. #endif
  398.     }
  399.     _FS_SMC_Set_SsfdcStandby(id);
  400.     return(SUCCESS);
  401. }
  404. /*********************************************************************
  405. *
  406. *             FS__SMC_PHY_WriteSect
  407. */
  409. int FS__SMC_PHY_WriteSect(FS_u32 id,unsigned char *buf,unsigned char *redundant)
  410. {
  411.     _FS_SMC_Set_SsfdcCmd(id,WRDATA);
  412.     _FS_SMC_Set_SsfdcAddr(id,EVEN);
  413.     _FS_SMC_Write_SsfdcBuf(id,buf,redundant);
  414.     _FS_SMC_Set_SsfdcCmd(id,WRITE);
  415.     if(_FS_SMC_Chk_SsfdcBusy(id,BUSY_PROG))   
  416.         { _FS_SMC_Reset_SsfdcErr(id);        return(ERROR); }
  417.     if((FS__SMC_cardattrib[id].Attribute &MPS)==PS256) {
  418.         _FS_SMC_Set_SsfdcCmd(id,RDSTATUS);
  419.         if(_FS_SMC_Chk_SsfdcStatus(id))    
  420.             { _FS_SMC_Set_SsfdcStandby(id);  return(SUCCESS); }
  421.         _FS_SMC_Set_SsfdcCmd(id,WRDATA);
  422.         _FS_SMC_Set_SsfdcAddr(id,ODD);
  423.         _FS_SMC_Write_SsfdcBuf(id,buf+0x100,redundant+0x08);
  424.         _FS_SMC_Set_SsfdcCmd(id,WRITE);
  425.         if(_FS_SMC_Chk_SsfdcBusy(id,BUSY_PROG)) 
  426.             { _FS_SMC_Reset_SsfdcErr(id);    return(ERROR); }
  427.     }
  428.     _FS_SMC_Set_SsfdcStandby(id);
  429.     return(SUCCESS);
  430. }
  433. /*********************************************************************
  434. *
  435. *             FS__SMC_PHY_EraseBlock
  436. */
  438. int FS__SMC_PHY_EraseBlock(FS_u32 id)
  439. {
  440.     _FS_SMC_Set_SsfdcCmd(id,ERASE1);
  441.     _FS_SMC_Set_SsfdcBlock(id);
  442.     _FS_SMC_Set_SsfdcCmd(id,ERASE2);
  443.     if(_FS_SMC_Chk_SsfdcBusy(id,BUSY_ERASE))  
  444.         { _FS_SMC_Reset_SsfdcErr(id);        return(ERROR); }
  445.     _FS_SMC_Set_SsfdcStandby(id);
  446.     return(SUCCESS);
  447. }
  450. /*********************************************************************
  451. *
  452. *             FS__SMC_PHY_ReadRedtData
  453. */
  455. int FS__SMC_PHY_ReadRedtData(FS_u32 id,unsigned char *redundant)
  456. {
  457.     _FS_SMC_Set_SsfdcCmd(id,READ_REDT);
  458.     _FS_SMC_Set_SsfdcAddr(id,EVEN);
  459. #if FS_SMC_HW_SUPPORT_BSYLINE_CHECK
  460.     if(_FS_SMC_Chk_SsfdcBusy(id,BUSY_READ))
  461.         { _FS_SMC_Reset_SsfdcErr(id);        return(ERROR); }
  462. #else
  463.     FS_SMC_HW_X_WaitTimer(id,BUSY_READ);
  464. #endif
  465.     _FS_SMC_ReadRedt_SsfdcBuf(id,redundant);
  466. #if FS_SMC_HW_SUPPORT_BSYLINE_CHECK
  467.     if(_FS_SMC_Chk_SsfdcBusy(id,BUSY_READ))
  468.         { _FS_SMC_Reset_SsfdcErr(id);        return(ERROR); }
  469. #else
  470.     FS_SMC_HW_X_WaitTimer(id,BUSY_READ);
  471. #endif
  472.     if((FS__SMC_cardattrib[id].Attribute &MPS)==PS256) {
  473.         _FS_SMC_Set_SsfdcCmd(id,READ_REDT);
  474.         _FS_SMC_Set_SsfdcAddr(id,ODD);
  475. #if FS_SMC_HW_SUPPORT_BSYLINE_CHECK
  476.         if(_FS_SMC_Chk_SsfdcBusy(id,BUSY_READ))
  477.             { _FS_SMC_Reset_SsfdcErr(id);    return(ERROR); }
  478. #else
  479.         FS_SMC_HW_X_WaitTimer(id,BUSY_READ);
  480. #endif
  481.         _FS_SMC_ReadRedt_SsfdcBuf(id,redundant+0x08);
  482. #if FS_SMC_HW_SUPPORT_BSYLINE_CHECK
  483.         if(_FS_SMC_Chk_SsfdcBusy(id,BUSY_READ))
  484.             { _FS_SMC_Reset_SsfdcErr(id);    return(ERROR); }
  485. #else
  486.         FS_SMC_HW_X_WaitTimer(id,BUSY_READ);
  487. #endif
  488.     }
  489.     _FS_SMC_Set_SsfdcStandby(id);
  490.     return(SUCCESS);
  491. }
  494. /*********************************************************************
  495. *
  496. *             FS__SMC_PHY_WriteRedtData
  497. */
  499. int FS__SMC_PHY_WriteRedtData(FS_u32 id,unsigned char *redundant)
  500. {
  501.     _FS_SMC_Set_SsfdcCmd(id,WRDATA);
  502.     _FS_SMC_Set_SsfdcAddr(id,EVEN);
  503.     _FS_SMC_WriteRedt_SsfdcBuf(id,redundant);
  504.     _FS_SMC_Set_SsfdcCmd(id,WRITE);
  505.     if(_FS_SMC_Chk_SsfdcBusy(id,BUSY_PROG))     
  506.         { _FS_SMC_Reset_SsfdcErr(id);        return(ERROR); }
  507.     if((FS__SMC_cardattrib[id].Attribute &MPS)==PS256) {
  508.         _FS_SMC_Set_SsfdcCmd(id,RDSTATUS);
  509.         if(_FS_SMC_Chk_SsfdcStatus(id))        
  510.             { _FS_SMC_Set_SsfdcStandby(id);  return(SUCCESS); }
  511.         _FS_SMC_Set_SsfdcCmd(id,WRDATA);
  512.         _FS_SMC_Set_SsfdcAddr(id,ODD);
  513.         _FS_SMC_WriteRedt_SsfdcBuf(id,redundant+0x08);
  514.         _FS_SMC_Set_SsfdcCmd(id,WRITE);
  515.         if(_FS_SMC_Chk_SsfdcBusy(id,BUSY_PROG))   
  516.             { _FS_SMC_Reset_SsfdcErr(id);    return(ERROR); }
  517.     }
  518.     _FS_SMC_Set_SsfdcStandby(id);
  519.     return(SUCCESS);
  520. }
  523. /*********************************************************************
  524. *
  525. *             FS__SMC_PHY_CheckStatus
  526. */
  528. int FS__SMC_PHY_CheckStatus(FS_u32 id)
  529. {
  530.     _FS_SMC_Set_SsfdcCmd(id,RDSTATUS);
  531.     if(_FS_SMC_Chk_SsfdcStatus(id))
  532.         { _FS_SMC_Set_SsfdcStandby(id);      return(ERROR); }
  533.     _FS_SMC_Set_SsfdcStandby(id);
  534.     return(SUCCESS);
  535. }
  538. /*********************************************************************
  539. *
  540. *             FS__SMC_PHY_Set_Model
  541. */
  543. int FS__SMC_PHY_Set_Model(FS_u32 id,unsigned char dcode)
  544. {
  545.     switch(_FS_SMC_Check_DevCode(dcode))   {
  546.         case SSFDC1MB:
  547.             FS__SMC_cardattrib[id].Model        = SSFDC1MB;
  548.             FS__SMC_cardattrib[id].Attribute    = FLASH | AD3CYC | BS16 | PS256;
  549.             FS__SMC_cardattrib[id].MaxZones     = 1;
  550.             FS__SMC_cardattrib[id].MaxBlocks    = 256;
  551.             FS__SMC_cardattrib[id].MaxLogBlocks = 250;
  552.             FS__SMC_cardattrib[id].MaxSectors   = 8;
  553.             break;
  554.         case SSFDC2MB:
  555.             FS__SMC_cardattrib[id].Model        = SSFDC2MB;
  556.             FS__SMC_cardattrib[id].Attribute    = FLASH | AD3CYC | BS16 | PS256;
  557.             FS__SMC_cardattrib[id].MaxZones     = 1;
  558.             FS__SMC_cardattrib[id].MaxBlocks    = 512;
  559.             FS__SMC_cardattrib[id].MaxLogBlocks = 500;
  560.             FS__SMC_cardattrib[id].MaxSectors   = 8;
  561.             break;
  562.         case SSFDC4MB:
  563.             FS__SMC_cardattrib[id].Model        = SSFDC4MB;
  564.             FS__SMC_cardattrib[id].Attribute    = FLASH | AD3CYC | BS16 | PS512;
  565.             FS__SMC_cardattrib[id].MaxZones     = 1;
  566.             FS__SMC_cardattrib[id].MaxBlocks    = 512;
  567.             FS__SMC_cardattrib[id].MaxLogBlocks = 500;
  568.             FS__SMC_cardattrib[id].MaxSectors   = 16;
  569.             break;
  570.         case SSFDC8MB:
  571.             FS__SMC_cardattrib[id].Model        = SSFDC8MB;
  572.             FS__SMC_cardattrib[id].Attribute    = FLASH | AD3CYC | BS16 | PS512;
  573.             FS__SMC_cardattrib[id].MaxZones     = 1;
  574.             FS__SMC_cardattrib[id].MaxBlocks    = 1024;
  575.             FS__SMC_cardattrib[id].MaxLogBlocks = 1000;
  576.             FS__SMC_cardattrib[id].MaxSectors   = 16;
  577.             break;
  578.         case SSFDC16MB:
  579.             FS__SMC_cardattrib[id].Model        = SSFDC16MB;
  580.             FS__SMC_cardattrib[id].Attribute    = FLASH | AD3CYC | BS32 | PS512;
  581.             FS__SMC_cardattrib[id].MaxZones     = 1;
  582.             FS__SMC_cardattrib[id].MaxBlocks    = 1024;
  583.             FS__SMC_cardattrib[id].MaxLogBlocks = 1000;
  584.             FS__SMC_cardattrib[id].MaxSectors   = 32;
  585.             break;
  586.         case SSFDC32MB:
  587.             FS__SMC_cardattrib[id].Model        = SSFDC32MB;
  588.             FS__SMC_cardattrib[id].Attribute    = FLASH | AD3CYC | BS32 | PS512;
  589.             FS__SMC_cardattrib[id].MaxZones     = 2;
  590.             FS__SMC_cardattrib[id].MaxBlocks    = 1024;
  591.             FS__SMC_cardattrib[id].MaxLogBlocks = 1000;
  592.             FS__SMC_cardattrib[id].MaxSectors   = 32;
  593.             break;
  594.         case SSFDC64MB:
  595.             FS__SMC_cardattrib[id].Model        = SSFDC64MB;
  596.             FS__SMC_cardattrib[id].Attribute    = FLASH | AD4CYC | BS32 | PS512;
  597.             FS__SMC_cardattrib[id].MaxZones     = 4;
  598.             FS__SMC_cardattrib[id].MaxBlocks    = 1024;
  599.             FS__SMC_cardattrib[id].MaxLogBlocks = 1000;
  600.             FS__SMC_cardattrib[id].MaxSectors   = 32;
  601.             break;
  602.         case SSFDC128MB:
  603.             FS__SMC_cardattrib[id].Model        = SSFDC128MB;
  604.             FS__SMC_cardattrib[id].Attribute    = FLASH | AD4CYC | BS32 | PS512;
  605.             FS__SMC_cardattrib[id].MaxZones     = 8;
  606.             FS__SMC_cardattrib[id].MaxBlocks    = 1024;
  607.             FS__SMC_cardattrib[id].MaxLogBlocks = 1000;
  608.             FS__SMC_cardattrib[id].MaxSectors   = 32;
  609.             break;
  610.     default:
  611.             FS__SMC_cardattrib[id].Model        = NOSSFDC;
  612.             return(ERROR);
  613.     }
  614.     return(SUCCESS);
  615. }
  618. /*********************************************************************
  619. *
  620. *             FS__SMC_PHY_Cnt_Reset
  621. */
  623. void FS__SMC_PHY_Cnt_Reset(FS_u32 id)
  624. {
  625.     FS_SMC_HW_X_SetStandby(id);
  626.     FS_SMC_HW_X_VccOff(id);
  627. }
  630. /*********************************************************************
  631. *
  632. *             FS__SMC_PHY_Cnt_PowerOn
  633. */
  635. int FS__SMC_PHY_Cnt_PowerOn(FS_u32 id)
  636. {
  637.     FS_SMC_HW_X_VccOn(id);
  638.     FS_SMC_HW_X_WaitTimer(id,TIME_PON);
  639.     if(FS_SMC_HW_X_ChkPower(id))
  640.         return(SUCCESS);
  641.     FS_SMC_HW_X_VccOff(id);
  642.     return(ERROR);
  643. }
  646. /*********************************************************************
  647. *
  648. *             FS__SMC_PHY_Chk_CntPower
  649. */
  651. int FS__SMC_PHY_Chk_CntPower(FS_u32 id)
  652. {
  653.     if(FS_SMC_HW_X_ChkPower(id))
  654.         return(SUCCESS);    /* Power On */
  655.     return(ERROR);          /* Power Off */
  656. }
  659. /*********************************************************************
  660. *
  661. *             FS__SMC_PHY_Chk_CardExist
  662. */
  664. int FS__SMC_PHY_Chk_CardExist(FS_u32 id)
  665. {
  666.     char i,j,k;
  667.     if(! FS_SMC_HW_X_ChkStatus(id))                   /***** Not Status Change *****/
  668.         if(FS_SMC_HW_X_ChkCardIn(id)) return(SUCCESS);    /* Card exist in Slot */
  669.     for(i=0,j=0,k=0; i<0x10; i++) {
  670.         if(FS_SMC_HW_X_ChkCardIn(id))                 /***** Status Change *****/
  671.              { j++; k=0; }
  672.         else { j=0; k++; }
  673.         if(j>3)     return(SUCCESS);            /* Card exist in Slot */
  674.         if(k>3)     return(ERROR);              /* NO Card exist in Slot */
  675.         FS_SMC_HW_X_WaitTimer(id,TIME_CDCHK);
  676.     }
  677.     return(ERROR);
  678. }
  681. /*********************************************************************
  682. *
  683. *             FS__SMC_PHY_Chk_CardStsChg
  684. */
  686. int FS__SMC_PHY_Chk_CardStsChg(FS_u32 id)
  687. {
  688.     if(FS_SMC_HW_X_ChkStatus(id))
  689.         return(ERROR);      /* Status Change */
  690.     return(SUCCESS);        /* Not Status Change */
  691. }
  694. /*********************************************************************
  695. *
  696. *             FS__SMC_PHY_Chk_WP
  697. */
  699. int FS__SMC_PHY_Chk_WP(FS_u32 id)
  700. {   /* ERROR: WP, SUCCESS: Not WP */
  701.     char i;
  702.     for(i=0; i<0x08; i++) {
  703.         if(FS_SMC_HW_X_ChkWP(id))
  704.             return(ERROR);
  705.         FS_SMC_HW_X_WaitTimer(id,TIME_WPCHK);
  706.     }
  707.     return(SUCCESS);
  708. }
  711. #endif /* FS_USE_SMC_DRIVER */