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

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

uCOS

开发平台：

C/C++

smc_ecc.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_ecc.c
  16. Purpose     : ECC functions for SMC driver
  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. #ifndef FS_FARCHARPTR
  33. #define FS_FARCHARPTR char *
  34. #endif
  35. #include "fs_dev.h"
  36. #include "fs_conf.h"
  38. #if FS_USE_SMC_DRIVER
  40. #include "smc.h"
  43. /*********************************************************************
  44. *
  45. *             #define constants
  46. *
  47. **********************************************************************
  48. */
  50. #define SUCCESS          0          /* SUCCESS     */
  51. #define ERROR           -1          /* ERROR       */
  52. #define CORRECT          1          /* CORRECTABLE */
  54. #define    BIT7    0x80
  55. #define    BIT6    0x40
  56. #define    BIT5    0x20
  57. #define    BIT4    0x10
  58. #define    BIT3    0x08
  59. #define    BIT2    0x04
  60. #define    BIT1    0x02
  61. #define    BIT0    0x01
  63. #define    BIT1BIT0    0x03
  64. #define    BIT23       0x00800000L
  65. #define    MASK_CPS    0x3f
  66. #define    CORRECTABLE 0x00555554L
  69. /*********************************************************************
  70. *
  71. *             Local Variables        
  72. *
  73. **********************************************************************
  74. */
  76. static const unsigned char _FS_SMC_ecctable[256] = {
  77.     0x00,0x55,0x56,0x03,0x59,0x0C,0x0F,0x5A,0x5A,0x0F,0x0C,0x59,0x03,0x56,0x55,0x00,
  78.     0x65,0x30,0x33,0x66,0x3C,0x69,0x6A,0x3F,0x3F,0x6A,0x69,0x3C,0x66,0x33,0x30,0x65,
  79.     0x66,0x33,0x30,0x65,0x3F,0x6A,0x69,0x3C,0x3C,0x69,0x6A,0x3F,0x65,0x30,0x33,0x66,
  80.     0x03,0x56,0x55,0x00,0x5A,0x0F,0x0C,0x59,0x59,0x0C,0x0F,0x5A,0x00,0x55,0x56,0x03,
  81.     0x69,0x3C,0x3F,0x6A,0x30,0x65,0x66,0x33,0x33,0x66,0x65,0x30,0x6A,0x3F,0x3C,0x69,
  82.     0x0C,0x59,0x5A,0x0F,0x55,0x00,0x03,0x56,0x56,0x03,0x00,0x55,0x0F,0x5A,0x59,0x0C,
  83.     0x0F,0x5A,0x59,0x0C,0x56,0x03,0x00,0x55,0x55,0x00,0x03,0x56,0x0C,0x59,0x5A,0x0F,
  84.     0x6A,0x3F,0x3C,0x69,0x33,0x66,0x65,0x30,0x30,0x65,0x66,0x33,0x69,0x3C,0x3F,0x6A,
  85.     0x6A,0x3F,0x3C,0x69,0x33,0x66,0x65,0x30,0x30,0x65,0x66,0x33,0x69,0x3C,0x3F,0x6A,
  86.     0x0F,0x5A,0x59,0x0C,0x56,0x03,0x00,0x55,0x55,0x00,0x03,0x56,0x0C,0x59,0x5A,0x0F,
  87.     0x0C,0x59,0x5A,0x0F,0x55,0x00,0x03,0x56,0x56,0x03,0x00,0x55,0x0F,0x5A,0x59,0x0C,
  88.     0x69,0x3C,0x3F,0x6A,0x30,0x65,0x66,0x33,0x33,0x66,0x65,0x30,0x6A,0x3F,0x3C,0x69,
  89.     0x03,0x56,0x55,0x00,0x5A,0x0F,0x0C,0x59,0x59,0x0C,0x0F,0x5A,0x00,0x55,0x56,0x03,
  90.     0x66,0x33,0x30,0x65,0x3F,0x6A,0x69,0x3C,0x3C,0x69,0x6A,0x3F,0x65,0x30,0x33,0x66,
  91.     0x65,0x30,0x33,0x66,0x3C,0x69,0x6A,0x3F,0x3F,0x6A,0x69,0x3C,0x66,0x33,0x30,0x65,
  92.     0x00,0x55,0x56,0x03,0x59,0x0C,0x0F,0x5A,0x5A,0x0F,0x0C,0x59,0x03,0x56,0x55,0x00
  93. };
  96. static const unsigned char _FS_SMC_cis[]={ 0x01,0x03,0xD9,0x01,0xFF,0x18,0x02,0xDF,0x01,0x20 };
  100. /*********************************************************************
  101. *
  102. *             Local functions
  103. *
  104. **********************************************************************
  105. */
  107. /*********************************************************************
  108. *
  109. *             _FS_SMC_StringCmp
  110. */
  112. static int _FS_SMC_StringCmp(FS_FARCHARPTR stringA, FS_FARCHARPTR stringB, int count)
  113. {
  114.     int i;
  115.     for (i=0;i<count;i++)
  116.         if (*stringA++ != *stringB++)   return(ERROR);
  117.     return(SUCCESS);
  118. }
  120. /*********************************************************************
  121. *
  122. *             _FS_SMC_trans_result
  123. *
  124.     Transfer result
  125.     LP14,12,10,... & LP15,13,11,... -> LP15,14,13,... & LP7,6,5,..
  126. */
  128. static void _FS_SMC_trans_result(unsigned char reg2,unsigned char reg3,
  129.                                   unsigned char *ecc1,unsigned char *ecc2)
  130. {
  131.     unsigned char a;                          /* Working for reg2,reg3        */
  132.     unsigned char b;                          /* Working for ecc1,ecc2        */
  133.     unsigned char i;                          /* For counting                 */
  135.     a=BIT7; b=BIT7;                           /* 80h=10000000b                */
  136.     *ecc1=*ecc2=0;                            /* Clear ecc1,ecc2              */
  137.     for(i=0; i<4; ++i) {
  138.         if ((reg3&a)!=0) *ecc1|=b;            /* LP15,13,11,9 -> ecc1         */
  139.         b=b>>1;                               /* Right shift                  */
  140.         if ((reg2&a)!=0) *ecc1|=b;            /* LP14,12,10,8 -> ecc1         */
  141.         b=b>>1;                               /* Right shift                  */
  142.         a=a>>1;                               /* Right shift                  */
  143.     }
  144.     b=BIT7;                                   /* 80h=10000000b                */
  145.     for(i=0; i<4; ++i) {
  146.         if ((reg3&a)!=0) *ecc2|=b;            /* LP7,5,3,1 -> ecc2            */
  147.         b=b>>1;                               /* Right shift                  */
  148.         if ((reg2&a)!=0) *ecc2|=b;            /* LP6,4,2,0 -> ecc2            */
  149.         b=b>>1;                               /* Right shift                  */
  150.         a=a>>1;                               /* Right shift                  */
  151.     }
  152. }
  155. /*********************************************************************
  156. *
  157. *             _FS_SMC_calculate_ecc
  158. *
  159.     Calculating ECC
  160.     data[0-255] -> ecc1,ecc2,ecc3 using CP0-CP5 code table[0-255]
  161. */
  163. static void _FS_SMC_calculate_ecc(const unsigned char *table,unsigned char *data,
  164.                                     unsigned char *ecc1,unsigned char *ecc2,
  165.                                     unsigned char *ecc3)
  166. {
  167.     unsigned int i;                           /* For counting                 */
  168.     unsigned char a;                          /* Working for table            */
  169.     unsigned char reg1;                       /* D-all,CP5,CP4,CP3,...        */
  170.     unsigned char reg2;                       /* LP14,LP12,L10,...            */
  171.     unsigned char reg3;                       /* LP15,LP13,L11,...            */
  173.     reg1=reg2=reg3=0;                         /* Clear parameter              */
  175.     for(i=0; i<256; ++i) {
  176.         a=table[data[i]];                     /* Get CP0-CP5 code from table  */
  177.         reg1^=(a&MASK_CPS);                   /* XOR with a                   */
  178.         if ((a&BIT6)!=0) {                    /* If D_all(all bit XOR) = 1    */
  179.             reg3^=(unsigned char)i;           /* XOR with counter             */
  180.             reg2^=~((unsigned char)i);        /* XOR with inv. of counter     */
  181.         }
  182.     }
  184.     /* Trans LP14,12,10,... & LP15,13,11,... -> LP15,14,13,... & LP7,6,5,..   */
  185.     _FS_SMC_trans_result(reg2,reg3,ecc1,ecc2);
  187.     *ecc1=~(*ecc1); *ecc2=~(*ecc2);           /* Inv. ecc2 & ecc3             */
  188.     *ecc3=((~reg1)<<2)|BIT1BIT0;              /* Make TEL format              */
  189. }
  192. /*********************************************************************
  193. *
  194. *             _FS_SMC_correct_data
  195. */
  196.                              
  197. static unsigned char _FS_SMC_correct_data(unsigned char *data,unsigned char *eccdata,
  198.                                             unsigned char ecc1,unsigned char ecc2,
  199.                                             unsigned char ecc3)
  200. {
  201.     unsigned long l;                          /* Working to check d           */
  202.     unsigned long d;                          /* Result of comparison         */
  203.     unsigned int i;                           /* For counting                 */
  204.     unsigned char d1,d2,d3;                   /* Result of comparison         */
  205.     unsigned char a;                          /* Working for add              */
  206.     unsigned char add;                        /* Byte address of cor. DATA    */
  207.     unsigned char b;                          /* Working for bit              */
  208.     unsigned char bit;                        /* Bit address of cor. DATA     */
  210.     d1=ecc1^eccdata[1]; d2=ecc2^eccdata[0];   /* Compare LP's                 */
  211.     d3=ecc3^eccdata[2];                       /* Comapre CP's                 */
  212.     d=((unsigned long)d1<<16)                 /* Result of comparison         */
  213.         +((unsigned long)d2<<8)
  214.         +(unsigned long)d3;
  216.     if (d==0) return(0);                      /* If No error, return          */
  217.     if (((d^(d>>1))&CORRECTABLE)==CORRECTABLE) {    /* If correctable         */
  218.         l=BIT23;
  219.         add=0;                                /* Clear parameter              */
  220.         a=BIT7;
  221.         for(i=0; i<8; ++i) {                  /* Checking 8 bit               */
  222.             if ((d&l)!=0) add|=a;             /* Make byte address from LP's  */
  223.             l>>=2; a>>=1;                     /* Right Shift                  */
  224.         }
  225.         bit=0;                                /* Clear parameter              */
  226.         b=BIT2;
  227.         for(i=0; i<3; ++i) {                  /* Checking 3 bit               */
  228.             if ((d&l)!=0) bit|=b;             /* Make bit address from CP's   */
  229.             l>>=2; b>>=1;                     /* Right shift                  */
  230.         }
  231.         b=BIT0;
  232.         data[add]^=(b<<bit);                  /* Put corrected data           */
  233.         return(1);
  234.     }
  235.     i=0;                                      /* Clear count                  */
  236.     d&=0x00ffffffL;                           /* Masking                      */
  237.     while(d) {                                /* If d=0 finish counting       */
  238.         if (d&BIT0) ++i;                      /* Count number of 1 bit        */
  239.         d>>=1;                                /* Right shift                  */
  240.     }
  241.     if (i==1) {                               /* If ECC error                 */
  242.         eccdata[1]=ecc1; eccdata[0]=ecc2;    /* Put right ECC code           */
  243.         eccdata[2]=ecc3;
  244.         return(2);
  245.     }
  246.     return(3);                                /* Uncorrectable error          */
  247. }
  250. /*********************************************************************
  251. *
  252. *             Global functions
  253. *
  254. **********************************************************************
  255. */
  257. /*********************************************************************
  258. *
  259. *             FS__SMC_ECC_Chk_CISdata
  260. */
  262. int FS__SMC_ECC_Chk_CISdata(unsigned char *buf, unsigned char *redundant)
  263. {
  264.     unsigned char ecc1,ecc2,ecc3;
  265.     unsigned int err;
  266.     _FS_SMC_calculate_ecc(_FS_SMC_ecctable,buf,&ecc1,&ecc2,&ecc3);
  267.     err=_FS_SMC_correct_data(buf,redundant+0x0D,ecc1,ecc2,ecc3);
  268.     if(err==0 || err==1 || err==2)
  269.         return(_FS_SMC_StringCmp((FS_FARCHARPTR)buf,(FS_FARCHARPTR)_FS_SMC_cis,10));
  270.     buf+=0x100;
  271.     _FS_SMC_calculate_ecc(_FS_SMC_ecctable,buf,&ecc1,&ecc2,&ecc3);
  272.     err=_FS_SMC_correct_data(buf,redundant+0x08,ecc1,ecc2,ecc3);
  273.     if(err==0 || err==1 || err==2)
  274.         return(_FS_SMC_StringCmp((FS_FARCHARPTR)buf,(FS_FARCHARPTR)_FS_SMC_cis,10));
  275.     return(ERROR);
  276. }
  279. /*********************************************************************
  280. *
  281. *             FS__SMC_ECC_Chk_ECCdata
  282. */
  284. int FS__SMC_ECC_Chk_ECCdata(unsigned char *buf, unsigned char *redundant)
  285. {
  286.     unsigned char ecc1,ecc2,ecc3;
  287.     unsigned int err, corr=SUCCESS;
  288.     _FS_SMC_calculate_ecc(_FS_SMC_ecctable,buf,&ecc1,&ecc2,&ecc3);
  289.     err=_FS_SMC_correct_data(buf,redundant+0x0D,ecc1,ecc2,ecc3);
  290.     if(err==1 || err==2)    corr=CORRECT;
  291.     else if(err)            return(ERROR);
  292.     buf+=0x100;
  293.     _FS_SMC_calculate_ecc(_FS_SMC_ecctable,buf,&ecc1,&ecc2,&ecc3);
  294.     err=_FS_SMC_correct_data(buf,redundant+0x08,ecc1,ecc2,ecc3);
  295.     if(err==1 || err==2)    corr=CORRECT;
  296.     else if(err)            return(ERROR);
  297.     return(corr);
  298. }
  301. /*********************************************************************
  302. *
  303. *             FS__SMC_ECC_Set_ECCdata
  304. */
  306. void FS__SMC_ECC_Set_ECCdata(unsigned char *buf, unsigned char *redundant)
  307. {
  308.     _FS_SMC_calculate_ecc(_FS_SMC_ecctable,buf,redundant+0x0E,redundant+0x0D,redundant+0x0F);
  309.     buf+=0x100;
  310.     _FS_SMC_calculate_ecc(_FS_SMC_ecctable,buf,redundant+0x09,redundant+0x08,redundant+0x0A);
  311. }
  313. #endif /* FS_USE_SMC_DRIVER */