本文转自公众号,欢迎关注

Micrium全家桶之uC-CRC: 0x01 ECC (qq.com)

前言

我们这一篇来讲讲Micrium全家桶的uC-CRC。该代码库提供了CRC算法进行错误检测EDC,使用HAMMING算法实现ECC错误纠正。ECC算法在NAND的TFL中使用。

下载代码

git clone https://github.com/weston-embedded/uC-CRC.git

修改版本,去掉对uC-LIB,uC-CPU等的依赖,可以直接单独使用,方便移植。

https://github.com/qinyunti/uC-CRC.git

文件介绍

│  LICENSE
│  NOTICE
│  readme.md
│
├─Cfg
│  └─Template
│          crc_cfg.h
│
├─Ports
│  ├─ARM
│  │  └─IAR
│  │          ecc_hamming_a.asm
│  │          edc_crc_a.asm
│  │
│  └─ARM-Cortex-M3
│      └─IAR
│              ecc_hamming_a.asm
│              edc_crc_a.asm
│
└─Source
        crc_util.c
        crc_util.h
        ecc.h
        ecc_hamming.c
        ecc_hamming.h
        edc_crc.c
        edc_crc.h

添加代码到自己的工程

添加uC-CRC\\Cfg\\Template\\crc_cfg.h

uC-CRC\\Source下所有文件到自己的工程目录uC-CRC下

并配置头文件包含路径uC-CRC

依赖

修改代码

注释掉crc_util.h下的

#include < cpu.h >


#include < cpu_core.h >

改为

#include < crc_cfg.h >

注释掉ecc.h下的

#include < cpu.h >


#include < cpu_core.h >

注释掉ecc_hamming.h下的

#include < cpu.h >


#include < cpu_core.h >


#include < lib_def.h >


#include < lib_mem.h >

注释掉edc_crc.h下的

#include < cpu.h >


#include < cpu_core.h >


#include < lib_def.h >

注释掉

ecc_hamming.c下的

Mem_Clr((void *)p_ecc, HAMMING_LEN_OCTET_ECC); /* Init ECC buf for err(s) (see Note #6).               */

改为

memset((void *)p_ecc, 0, HAMMING_LEN_OCTET_ECC);

前面添加

#include < string.h >

crc_cfg.h中实现以下依赖

/*
*********************************************************************************************************
*                                                 PORT
*
* Note(s) : (1) 以下添加依赖部分移植
*               
*
*********************************************************************************************************
*/


                                                        /* ------------------ CPU WORD-ENDIAN ORDER ------------------- */
#define  CPU_ENDIAN_TYPE_NONE                      0u
#define  CPU_ENDIAN_TYPE_BIG                       1u   /* Big-   endian word order (see Note #1a).                     */
#define  CPU_ENDIAN_TYPE_LITTLE                    2u   /* Little-endian word order (see Note #1b).                     */


#define  CPU_CFG_ENDIAN_TYPE            CPU_ENDIAN_TYPE_LITTLE


typedef  unsigned  char        CPU_BOOLEAN;                     /*  8-bit boolean or logical                            */
typedef  unsigned  char        CPU_INT08U;                      /*  8-bit unsigned integer                              */
typedef  unsigned  short       CPU_INT16U;                      /* 16-bit unsigned integer                              */
typedef  unsigned  int         CPU_INT32U;                      /* 32-bit unsigned integer                              */
typedef  CPU_INT32U  CPU_ADDR;                                  /* CPU address type based on address bus size.          */
typedef  CPU_INT32U  CPU_DATA;                                  /* CPU data    type based on data    bus size.          */
typedef  CPU_ADDR    CPU_SIZE_T;                                /* Defines CPU standard 'size_t'   size.                */


#define  CPU_WORD_SIZE_32                                   4u   /* 32-bit word size (in octets).                                */




                                                                /* ----------------- BOOLEAN DEFINES ------------------ */
#define  DEF_NO                                            0u
#define  DEF_YES                                           1u
#define  DEF_DISABLED                                      0u
#define  DEF_ENABLED                                       1u
#define  DEF_INVALID                                       0u
#define  DEF_VALID                                         1u


#define  DEF_OCTET_NBR_BITS                                8u
#define  DEF_BIT(bit)                                                   (1uL < < (bit))


                                                                /* ------------------- BIT DEFINES -------------------- */
#define  DEF_BIT_00                                     0x01u
#define  DEF_BIT_01                                     0x02u
#define  DEF_BIT_02                                     0x04u
#define  DEF_BIT_03                                     0x08u
#define  DEF_BIT_04                                     0x10u
#define  DEF_BIT_05                                     0x20u
#define  DEF_BIT_06                                     0x40u
#define  DEF_BIT_07                                     0x80u
#define  DEF_BIT_08                                   0x0100u
#define  DEF_BIT_09                                   0x0200u
#define  DEF_BIT_10                                   0x0400u
#define  DEF_BIT_11                                   0x0800u
#define  DEF_BIT_12                                   0x1000u
#define  DEF_BIT_13                                   0x2000u
#define  DEF_BIT_15                                   0x8000u
#define  DEF_BIT_17                               0x00020000u
#define  DEF_BIT_19                               0x00080000u
#define  DEF_BIT_21                               0x00200000u
#define  DEF_BIT_23                               0x00800000u
#define  DEF_BIT_25                               0x02000000u
#define  DEF_BIT_27                               0x08000000u
#define  DEF_BIT_29                               0x20000000u
#define  DEF_BIT_31                               0x80000000u




#define  DEF_BIT_SET(val, mask)                        ((val) = ((val) | (mask)))


#define  DEF_BIT_IS_SET(val, mask)                    (((((val) & (mask)) == (mask)) && ((mask) != 0u)) ? (DEF_YES) : (DEF_NO))


#define  CPU_SW_EXCEPTION(err_rtn_val)              do {                    \\
                                                        ;                    \\
                                                    } while (1)




#define  MEM_VAL_COPY_GET_INT32U(addr_dest, addr_src)   do {                                                                             \\
                                                                   CPU_INT08U  *destptr = (CPU_INT08U *)(addr_dest);                            \\
                                                                   CPU_INT08U  *srcptr  = (CPU_INT08U *)(addr_src);                             \\
                                                                   (*((destptr) + 0))   = (*((srcptr) + 0));                                    \\
                                                                   (*((destptr) + 1))   = (*((srcptr) + 1));                                    \\
                                                                   (*((destptr) + 2))   = (*((srcptr) + 2));                                    \\
                                                                   (*((destptr) + 3))   = (*((srcptr) + 3)); } while (0)                        


#define  MEM_VAL_COPY_GET_INTU(addr_dest, addr_src, val_size)    do {                                                                                  \\
                                                                            CPU_SIZE_T  _i;                                                                   \\
                                                                                                                                                              \\
                                                                            for (_i = 0; _i < (val_size); _i++) {                                             \\
                                                                                (*(((CPU_INT08U *)(addr_dest)) + _i)) = (*(((CPU_INT08U *)(addr_src)) + _i)); \\
                                                                            }                                                                                 \\
                                                                        } while (0)


#define  MEM_VAL_COPY_SET_INT32U(addr_dest, addr_src)    MEM_VAL_COPY_GET_INT32U(addr_dest, addr_src)

测试

ECC

用户代码中#include ”ecc_hamming.h”

调用以下接口

Hamming_Calc

Hamming_Chk

Hamming_Correct

详见test.c

#include < stdio.h >
#include < stdint.h >
#include "ecc_hamming.h"


typedef struct
{
  ECC_ERR err;
  char* str;
}err_str;


err_str s_err_str[]=
{
  {ECC_ERR_NONE,"No error."},
  {ECC_ERR_CORRECTABLE,"Correctable error detected in data."},
  {ECC_ERR_ECC_CORRECTABLE,"Correctable error detected in ECC."},
  {ECC_ERR_INVALID_ARG,"Argument passed invalid value. "},
  {ECC_ERR_INVALID_LEN,"Len argument passed invalid length."},
  {ECC_ERR_NULL_PTR,"Pointer argument passed NULL pointer."},
  {ECC_ERR_UNCORRECTABLE,"Uncorrectable error detected in data."}
};

uint8_t s_buffer[33];
uint8_t s_ecc[4];


int ecc_main(int argc, char* argv[])
{
  CPU_INT08U ecc[4];
  ECC_ERR_LOC err_loc[2]={{0,0},{0,0}};
  ECC_ERR err;
  for(int i=0; i< sizeof(s_buffer)/sizeof(s_buffer[0]); i++)
  {
    s_buffer[i] = i+1;
  }

  /* 打印原始数据 */
  for(int i=0; i< sizeof(s_buffer)/sizeof(s_buffer[0]); i++)
  {
    if(i % 16 == 0)
    {
      printf("\\r\\n");
    }
    printf("%#x ",s_buffer[i]);
  }
  printf("\\r\\n");

  CPU_SIZE_T len = (sizeof(s_buffer)/sizeof(s_buffer[0]));
  CPU_SIZE_T len_buf     = (len / 32)*32;
  CPU_SIZE_T len_buf_ext = len % 32;
  CPU_INT08U* p_buf_ext   = (CPU_INT08U *)s_buffer + len_buf;
  Hamming_Calc(s_buffer,len_buf,p_buf_ext,len_buf_ext,s_ecc,&err);
  if(ECC_ERR_NONE != err)
  {
    printf("Hamming_Calc err:%d\\r\\n",err);
    return -1;
  }
  printf("Hamming_Calc:ecc %#x %#x %#x %#x\\r\\n",s_ecc[0],s_ecc[1],s_ecc[2],s_ecc[3]);

/*
 *  1位数据错误
 */
  /* DATA注入错误 */
  printf("\\r\\n[DATA err test]\\r\\n");
  s_buffer[0] ^= 0x80;

  /* 打印错误数据 */
  for(int i=0; i< sizeof(s_buffer)/sizeof(s_buffer[0]); i++)
  {
    if(i % 16 == 0)
    {
      printf("\\r\\n");
    }
    printf("%#x ",s_buffer[i]);
  }
  printf("\\r\\n");

  if(ECC_FAULT == Hamming_Chk(s_buffer,len_buf,p_buf_ext,len_buf_ext,s_ecc,err_loc,sizeof(err_loc)/sizeof(err_loc[0]),&err))
  {
    printf("Hamming_Chk err:%d\\r\\n",err);
    return -2;
  }
  printf("Hamming_Chk:loc B[%d].b[%d] B[%d].b[%d]\\r\\n",err_loc[0].LocOctet,err_loc[0].LocBit,err_loc[1].LocOctet,err_loc[1].LocBit);
  printf("%s",s_err_str[err].str);

  Hamming_Correct(s_buffer,len_buf,p_buf_ext,len_buf_ext,s_ecc,&err);
  /* 打印修复后的数据 */
  for(int i=0; i< sizeof(s_buffer)/sizeof(s_buffer[0]); i++)
  {
    if(i % 16 == 0)
    {
      printf("\\r\\n");
    }
    printf("%#x ",s_buffer[i]);
  }
  printf("\\r\\n");
  printf("Hamming_Correct:ecc %#x %#x %#x %#x\\r\\n",s_ecc[0],s_ecc[1],s_ecc[2],s_ecc[3]);
  printf("%s",s_err_str[err].str);
/*
 *  1位ECC错误
 */
  /* DATA注入错误 */
  printf("\\r\\n[ECC err test]\\r\\n");
  s_ecc[1] ^= 0x02;

  /* 打印错误数据 */
  for(int i=0; i< sizeof(s_buffer)/sizeof(s_buffer[0]); i++)
  {
    if(i % 16 == 0)
    {
      printf("\\r\\n");
    }
    printf("%#x ",s_buffer[i]);
  }
  printf("\\r\\n");

  if(ECC_FAULT == Hamming_Chk(s_buffer,len_buf,p_buf_ext,len_buf_ext,s_ecc,err_loc,sizeof(err_loc)/sizeof(err_loc[0]),&err))
  {
    printf("Hamming_Chk err:%d\\r\\n",err);
    return -2;
  }
  printf("Hamming_Chk:loc B[%d].b[%d] B[%d].b[%d]\\r\\n",err_loc[0].LocOctet,err_loc[0].LocBit,err_loc[1].LocOctet,err_loc[1].LocBit);
  printf("%s",s_err_str[err].str);

  Hamming_Correct(s_buffer,len_buf,p_buf_ext,len_buf_ext,s_ecc,&err);


  /* 打印修复后的数据 */
  for(int i=0; i< sizeof(s_buffer)/sizeof(s_buffer[0]); i++)
  {
    if(i % 16 == 0)
    {
      printf("\\r\\n");
    }
    printf("%#x ",s_buffer[i]);
  }
  printf("\\r\\n");
  printf("Hamming_Correct:ecc %#x %#x %#x %#x\\r\\n",s_ecc[0],s_ecc[1],s_ecc[2],s_ecc[3]);
  printf("%s",s_err_str[err].str);
/*
 *  2位数据错误
 */
  /* DATA注入错误 */
  printf("\\r\\n[2DATA err test]\\r\\n");
  s_buffer[2] ^= 0x04;
  s_buffer[5] ^= 0x10;

  /* 打印错误数据 */
  for(int i=0; i< sizeof(s_buffer)/sizeof(s_buffer[0]); i++)
  {
    if(i % 16 == 0)
    {
      printf("\\r\\n");
    }
    printf("%#x ",s_buffer[i]);
  }
  printf("\\r\\n");

  if(ECC_FAULT == Hamming_Chk(s_buffer,len_buf,p_buf_ext,len_buf_ext,s_ecc,err_loc,sizeof(err_loc)/sizeof(err_loc[0]),&err))
  {
    printf("Hamming_Chk err:%d\\r\\n",err);
    return -2;
  }
  printf("Hamming_Chk:loc B[%d].b[%d] B[%d].b[%d]\\r\\n",err_loc[0].LocOctet,err_loc[0].LocBit,err_loc[1].LocOctet,err_loc[1].LocBit);
  printf("%s",s_err_str[err].str);

  Hamming_Correct(s_buffer,len_buf,p_buf_ext,len_buf_ext,s_ecc,&err);
  /* 打印修复后的数据 */
  for(int i=0; i< sizeof(s_buffer)/sizeof(s_buffer[0]); i++)
  {
    if(i % 16 == 0)
    {
      printf("\\r\\n");
    }
    printf("%#x ",s_buffer[i]);
  }
  printf("\\r\\n");
  printf("Hamming_Correct:ecc %#x %#x %#x %#x\\r\\n",ecc[0],ecc[1],ecc[2],ecc[3]);
  printf("%s",s_err_str[err].str);
  return 0;
}

测试结果如下可以看到,1位的数据错误校正过来了,ECC编码本身的1位错误认为是不可校正错误,两位数据错误也是不可校正错误

CRC

接口如下,下篇再单讲

CRC_Open_16Bit
CRC_WrBlock_16Bit
CRC_WrOctet_16Bit
CRC_Close_16Bit


CRC_Open_32Bit
CRC_WrBlock_32Bit
CRC_WrOctet_32Bit
CRC_Close_32Bit


CRC_Reflect_08Bit
CRC_Reflect_16Bit
CRC_Reflect_32Bit


CRC_ChkSumCalc_16Bit
CRC_ChkSumCalc_32Bit

汉明码

冗余位

假设有m位数据,至少要添加n位冗余位才能检测出错误(只考虑只有1个bit错误的情况)。

m位数据,n位冗余数据错1位的情况有m+n种,还有一种情况是无错。

需要用n位冗余位去标志是哪一位错了,所以要满足2^n >= m+n+1。

奇偶校验

奇校验:数据和校验位一起,1的个数为奇数

偶校验:数据和校验位一起,1的个数为偶数

奇偶校验只能发现奇数个位翻转,因为偶数个位翻转奇偶性不变。

汉明码

即奇偶校验的升级,组合。

先根据2^n >= m+n+1计算需要多少个校验位,

然后确认校验位的位置在2^n索引位上(索引从1开始)。

比如7位数据需要4位校验位,2^4 >= 7+4+1,一共11位,从1~11编号索引

写为二进制

0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011

将bit0是1的划分为一组 0001 0011 0101 0111 1001 1011

即1 3 5 7 9 11, 将对应数据位奇校验,放在2^0校验位

将bit1是1的划分为一组 0010 0011 0110 0111 1010 1011

即2 3 6 7 10 11, 将对应数据位奇校验,放在2^1校验位

将bit2是1的划分为一组 0100 0101 0110 0111

即4 5 6 7, 将对应数据位奇校验,放在2^2校验位

将bit3是1的划分为一组 0100 0101 0110 0111

即8 9 10 11, 将对应数据位奇校验,放在2^3校验位

纠错,如果2^0校验位不对bit0写1,如果2^1校验位不对bit1写1,得到的二进制数就是出错位的的索引。

比如以上如果bit5翻转了,索引5是在2^0和2^2组的所以,是101,即索引5的数据有错。

汉明距离

在一个码组集合中，任意两个码字之间对应位上码元取值不同的位的数目定义为这两个码字之间的汉明距离d。例如：(00)与(01)的距离是1，(110)和(101)的距离是2。在一个码组集合中，任意两个编码之间汉明距离的最小值称为这个码组的最小汉明距离。最小汉明距离越大，码组越具有抗干扰能力,即差异越大,冗余越多。即编码只用了一部分,剩余的空着,如果出现了错误则肯定是变成了空着的编码。

比如两位的编码实际可以编码为00 01 10 11,但是我们只用00代表A,10代表B,

那么收到01后,我们知道出错了,那么是哪个出错了呢，00变为01需要变化1位,10变为01需要变化2位,所以所以我们更倾向于是00变化了一位即是A出错了,

所以我们可以认为00和01都代表A

10 11 都代表B

这样实际就是用冗余来提高抗干扰能力,我们粗暴的发两次也是冗余,但是冗余太多了浪费空间,所以可以选择不冗余这么多,这个汉明距离d就是冗余的多少,d越大冗余越大,d越小冗余越小。

l当码组用于检测错误时，设可检测e个位的错误，则d ≥ e + 1

l若码组用于纠错，设可纠错t个位的错误，则 d ≥ 2 ∗ t + 1

即AB之间的距离至少是1才能区分AB, 剩余的空间2t划分一半,靠近A的一半t认为是A,靠近B的一半t认为是B。

l如果码组用于纠正t个错，检测e个错，则d ≥ e + t + 1

NAND中的硬件ECC

这里以W25N01GVZEIG芯片为例,不同芯片略有差异

一个PAGE大大小是2112字节其中用户区域2048字节+额外区域64字节

将PAGE的用户区域和额外区域都分成4份即Sector,

则512字节用户区域对应16字节额外区域。

16字节额外区域如上图

0- 1 :2字节位坏块标记

2- 3 :2字节用户数据II

4-7 : 4字节用户数据I

8-D: 6字节前面Sector数据的ECC校验值

E-F:4-D对应的10字节的ECC校验值

问题:ECC for Sector 0本身有误码可以通过ECC for Spare检测出来,但是如果ECC for Spare本身有误码呢?

芯片自带的ECC校验使能通过寄存器配置(有些型号是默认使能的)

写数据时自动计算ECC并更新到64字节额外区域,读数据时自动校验ECC并进行校正,返回校正完后的正确值。

读数据时可以读状态寄存器确认ECC状态

NAND中的软件ECC

256字节2048位,检测1位错误理论上只需要12位校验位即可,

2^12 >= 2048 + 12 + 1。

但是实际一半是纠正1位错误,检测2位错误

所以d ≥ e + t + 1=4

汉明距离至少要是4.

NAND实际应用中是按照行列分别校验的

按照一个字节8位x256字节

组成256x8,256行8列的矩阵

256行 16个校验位

8列 6个校验位

总共22位,3个字节,剩余两个bit未用放在高位

如下所示

参考

tn2963_ecc_in_slc_nand.pdf

samsung_ecc_algorithm_for_256b.pdf

Linux中的实现

参考以下链接,不再详述

http://lxr.linux.no/linux+v2.6.27/drivers/mtd/nand/nand_ecc.c#L103

https://www.kernel.org/doc/html/latest/driver-api/mtd/nand_ecc.html

待办

以上Micrium和Linux的实现实际都没有实现检测ECC码自身错误的情况,都只能校正数据的1位错误,对于ECC码本身错误一位认为是不可校正错误,这里后续可以考虑优化。

总结

以上介绍了Micrium全家桶的uC-CRC组件,并修改成无其他依赖,比较好移植使用。其中的ECC在NAND中使用,所以重点进行了介绍。不仅仅介绍代码库的使用,同时也分析了原理,只有理论结合实践才能真的用好。CRC部分下次可以单独再讲讲。

审核编辑：汤梓红