nand结构
NAND Flash的数据是以bit 的方式保存在memory cell，一般来说，一个cell 中只能存储一个bit。这些cell 以8 个或者16 个为单位，连成bit line，形成所谓的byte(x8)/word(x16)，这就是NAND Device 的位宽。这些Line 会再组成Page。
Nand Flash 根据的page的大小，可以分为small page和big page, 下面以samsung的K9F1G08U0B和K9F5608U0D分别说明：
K9F5608U0D：
page = 512+16 = 528 bytes (small page), 32个page组成一个block。
block = 16K +512 = 0x40000 bytes
K9F1G08U0B
page = (2K + 64)bytes (big page)， 64个page组成一个block。
block = (128K + 4K)bytes
page是由两个部分组成的， 一个是main area， 是用来存储数据的， 另外一个叫Spare Area， 是用于存储ECC的校验值的。
Nand flash 以page为单位读写数据，而以block为单位擦除数据。按照这样的组织方式可以形成所谓的三类地址： --Block Address -- Page Address --Column Address(即为页内偏移地址)
对于NAND Flash 来讲，地址和命令只能在I/O[7:0]上传递，数据宽度是8 位。
512byte需要9bit来表示，对于528byte系列的NAND，这512byte被分成1st half和2nd half,各自的访问由地址指针命令来选择，A[7:0]就是所谓的column address。32 个page 需要5bit 来表示，占用A[13:9]，即该page 在块内的相对地址。Block的地址是由A14 以上的bit 来表示，例如512Mb 的NAND，共4096block，因此，需要12 个bit 来表示，即A[25:14]，如果是1Gbit 的528byte/page的NAND Flash，则block address用A[26:14]表示。而page address就是blcok address|page address in block, NAND Flash 的地址表示为： Block Address|Page Address in block|halfpage pointer|Column Address 地址传送顺序是Column Address,Page Address,Block Address。 由于地址只能在I/O[7:0]上传递，因此，必须采用移位的方式进行。 例如，对于512Mbit x8 的NAND flash，地址范围是0~0x3FF_FFFF，只要是这个范围内的数值表示的地址都是有效的。以NAND_ADDR 为例：第1 步是传递column address，就是NAND_ADDR[7:0]，不需移位即可传递到I/O[7:0]上，而halfpage pointer 即bit8 是由操作指令决定的，即指令决定在哪个halfpage 上进行读写。而真正的bit8 的值是don\'t care 的。 第2 步就是将NAND_ADDR 右移9 位，将NAND_ADDR[16:9]传到I/O[7:0]上 第3 步将NAND_ADDR[24:17]放到I/O 上 第4 步需要将NAND_ADDR[25]放到I/O 上 因此，整个地址传递过程需要4 步才能完成，即4-step addressing。 如果NAND Flash 的容量是256Mbit 以下，那么，block adress 最高位只到bit24，因此寻址 只需要3 步。
对于big page需要两个周期才能将column address写入到flash， 两种flash的具体写address的周期，请见下表：
small page address写入到flash中的周期：
|
I/0 0 |
I/0 1 |
I/O 2 |
I/0 3 |
I/0 4 |
I/0 5 |
I/0 6 |
I/0 7 |
| 1st Cycle |
A0 |
A1 |
A2 |
A3 |
A4 |
A5 |
A6 |
A7 |
| 2st Cycle |
A9 |
A10 |
A11 |
A12 |
A13 |
A14 |
A15 |
A16 |
| 3st Cycle |
A17 |
A18 |
A19 |
A20 |
A21 |
A22 |
A23 |
A24 |
big page address写入到flash中的周期：
|
I/0 0 |
I/0 1 |
I/O 2 |
I/0 3 |
I/0 4 |
I/0 5 |
I/0 6 |
I/0 7 |
| 1st Cycle |
A0 |
A1 |
A2 |
A3 |
A4 |
A5 |
A6 |
A7 |
| 2st Cycle |
A8 |
A9 |
A10 |
A11 |
0 |
0 |
0 |
0 |
| 3st Cycle |
A12 |
A13 |
A14 |
A15 |
A16 |
A17 |
A18 |
A19 |
| 4st Cycle |
A20 |
A21 |
A22 |
A23 |
A24 |
A25 |
A26 |
A27 |
对应周期数，会随着flash的大小变化的， 下面会对nand flash K9f1208读写擦举例，虽然这个也是samll page的，但是有4个周期。
就x16 的NAND flash 器件稍微进行一下说明。 由于一个page 的main area 的容量为256word，仍相当于512byte。但是，这个时候没有所谓 的1st halfpage 和2nd halfpage 之分了，所以，bit8就变得没有意义了，也就是这个时候 bit8 完全不用管，地址传递仍然和x8 器件相同。除了，这一点之外，x16 的NAND使用方法和 x8 的使用方法完全相同。
读写擦
nand flash指令
每个nand flash都有一定的区别:
K9F5608U0D
| function |
1st. Cycle |
2nd Cycle |
Acceptable Command during Busy |
| read |
00h/01h |
- |
|
| read 2 |
50h |
- |
|
| read ID |
90h |
- |
|
| reset |
FFh |
- |
0 |
| page program |
80h |
10h |
|
| copy back program |
00h |
8Ah |
|
| block erase |
60h |
D0h |
|
| read status |
70h |
- |
0 |
K9F1G08U0B
| function |
1st. Cycle |
2nd Cycle |
Acceptable Command during Busy |
| read 1 |
00h |
30h |
|
| read for copy back |
00h |
35h |
|
| read ID |
90h |
- |
|
| reset |
FFh |
- |
0 |
| page program |
80h |
10h |
|
| copy back program |
85h |
10h |
|
| block erase |
60h |
D0h |
|
| random data input |
85h |
- |
|
| random data output |
05h |
E0h |
|
| read status |
70h |
|
0 |
| read EDC status |
7Bh |
|
0 |
坏块查找
Nand Flash在出厂时会在每个block的0页面的space（512--527）空间中标记出坏块， small page和big page的地址还是不一样的， small page是在第5个字节处标明， big page是在第1个字节处标明，此页是否为坏块。如果为0xff则不是坏块，这个是nand flash出厂时的坏块检测方法。当nand flash在使用过程中出现了坏块，如何发现并且标记它呢？
答：通过某种坏块检测的软件算法对每一页的512个字节进行一定的判断，计算出一个ECC码，然后将其放入00B中，等若干时间后再用同样的算法对其进行检测，再次得到一个ECC码，将这个ECC码和之前计算出的ECC码进行比较，如果相等则不是坏块，如果不等则为坏块，然后就将其标记。
须掌握：如何遍历坏块:
ECC算法有两种：软件ECC算法，通用性好，每256个字节算出一个3byte的ECC码，故512个字节算出6byte的ECC码。
读
下面以small page为例，举例读写擦的过程， 对于下一节, 几乎将的都以big page为例，也有部分small page的东西。
K9f1208的寻址分为4个cycle。分别是：A[0:7]、A[9:16]、A[17:24]、A[25]。
读操作的过程为: 1、发送读取指令；2、发送第1个cycle地址；3、发送第2个cycle地址；4、发送第3个cycle地址；5、发送第4个cycle地址；6、读取数据至页末。
K9f1208提供了两个读指令，‘0x00’、‘0x01’。这两个指令区别在于‘0x00’可以将A[8]置为0，选中上半页；而‘0x01’可以将A[8]置为1，选中下半页。
虽然读写过程可以不从页边界开始，但在正式场合下还是建议从页边界开始读写至页结束。下面通过分析读取页的代码，阐述读过程。
static void ReadPage(U32 addr, U8 *buf)
//addr表示flash中的第几页，即‘flash地址>>9’
{
U16 i;
NFChipEn(); //使能NandFlash
WrNFCmd(READCMD0); //发送读指令‘0x00’，由于是整页读取，所以选用指令‘0x00’
WrNFAddr(0); //写地址的第1个cycle，即Column Address，由于是整页读取所以取0
WrNFAddr(addr); //写地址的第2个cycle，即A[9:16]
WrNFAddr(addr>>8); //写地址的第3个cycle，即A[17:24]
WrNFAddr(addr>>16); //写地址的第4个cycle，即A[25]。
WaitNFBusy(); //等待系统不忙
for(i=0; i<512; i++)
buf[i] = RdNFDat(); //循环读出1页数据
NFChipDs(); //释放NandFlash
}
写
写操作的过程为: 1、发送写开始指令；2、发送第1个cycle地址；3、发送第2个cycle地址；4、发送第3个cycle地址；5、发送第4个cycle地址；6、写入数据至页末；7、发送写结束指令
下面通过分析写入页的代码，阐述读写过程。
static void WritePage(U32 addr, U8 *buf)
//addr表示flash中的第几页，即‘flash地址>>9’
{
U32 i;
NFChipEn(); //使能NandFlash
WrNFCmd(PROGCMD0); //发送写开始指令’0x80’
WrNFAddr(0); //写地址的第1个cycle
WrNFAddr(addr); //写地址的第2个cycle
WrNFAddr(addr>>8); //写地址的第3个cycle
WrNFAddr(addr>>16); 写地址的第4个cycle
WaitNFBusy(); //等待系统不忙
for(i=0; i<512; i++)
WrNFDat(buf[i]); //循环写入1页数据
WrNFCmd(PROGCMD1); //发送写结束指令’0x10’
NFChipDs(); //释放NandFlash
}
擦
static U32 EraseBlock(U32 addr)
{
UINT8T stat;
// addr &= ~0x1f;
NFChipEn(); //芯片使能，片选拉低，Nand flash使能
WrNFCmd(ERASECMD0); //写命令0x60表示块擦除操作将开始
WrNFAddr(addr); //地址分三次传送
WrNFAddr(addr>>8); //先传a9--a16,
if(NandAddr)
WrNFAddr(addr>>16); //后传a17-a24 ,a25
WrNFCmd(ERASECMD1); //传完地址后，写命令0xd0h（按时序要求）
stat = WaitNFBusy(); //写完擦除命令后，执行等待
uart_printf(".......................!\n");
NFChipDs(); //关闭片选
if(stat == 0)
{
uart_printf("erase success!\n");
}
else
{
uart_printf("erase error!\n");
}
#ifdef ER_BAD_BLK_TEST
if(!((addr+0xe0)&0xff)) stat = 1; //just for test bad block
#endif
//printf("Erase block 0x%x %s\n", addr, stat?"fail":"ok");
uart_printf (".");
return stat;
}
ECC校验
当往NAND Flash的page中写入数据的时候，每256字节我们生成一个ECC校验和，称之为原ECC校验和，保存到PAGE的OOB（out-of-band）数据区中。
当从NAND Flash中读取数据的时候，每256字节我们生成一个ECC校验和，称之为新ECC校验和。
校验的时候，根据上述ECC生成原理不难推断：将从OOB区中读出的原ECC校验和新ECC校验和按位异或，若结果为0，则表示不存在错（或是出现了 ECC无法检测的错误）；若3个字节异或结果中存在11个比特位为1，表示存在一个比特错误，且可纠正；若3个字节异或结果中只存在1个比特位为1，表示 OOB区出错；其他情况均表示出现了无法纠正的错误。
了能检测到单个位错误，把每256字节的数据划分为一张8x256共2048位的表，使用22位校验码进行校验，16位为行校验码，进行横向校验，6位为列校验码，按进行纵向校验。下图描述了这22位校验码产生的原理：
![]()
列校验：
CP0:对所有字节的Bit 6,4,2,0进行异或操作的结果
CP1:对所有字节的Bit 7,5,3,1进行异或操作的结果
.
.
CP5:对所有字节的Bit 7,6,5,4进行异或操作的结果
行校验：
LP0:对0,2,4,6...254字节的所有位进行异或操作的结果
LP1:对1,3,5,7...255字节的所有位进行异或操作的结果
.
.
LP15:对128~255字节的所有位进行异或操作的结果
22位校验码需要三个字节保存，前两字节保存16位行校验码LP0~LP15，第三字节保存6位列校验码CP0~CP5，剩余2位置1：
![]()
把数据写入Nand Flash时，我们产生校验码并将它保存到Flash的Spare Data Area。从Flash读出数据时，产生一个新的ECC校验码，将它和Spare Data Area读出的旧校验码进行异或操作：
结果为0：数据正确
结果有11位为1：数据有1位错误（可纠正）
其他结果：数据超过1位发生错误，无法纠正
没有优化的ECC算法
下面是ECC产生算法的c++实现代码（仅满足示意用途，为了便于理解没有经过优化，在实际使用中，大量的异或运算可转为查表操作）
1. static inline void SetBit(unsigned int& dat, int bit, int v)
2. {
3. if (v)
4. dat |= (1< 5. else
6. dat &= ~(1< 7. }
8.
9.
10. static inline int GetBit(unsigned int dat, int bit)
11. {
12. if (dat & (1< 13. return 1;
14. else
15. return 0;
16. }
17.
18.
19. static inline int XorLP(unsigned char c)
20. {
21. return (GetBit(c, 7) ^ GetBit(c, 6) ^ GetBit(c, 5) ^ GetBit(c, 4)
^ GetBit(c, 3) ^ GetBit(c, 2) ^ GetBit(c, 1) ^ GetBit(c, 0) );
22. }
23.
24.
25. static inline int XorCP0(unsigned char c)
26. {
27. return (GetBit(c, 6) ^ GetBit(c, 4) ^ GetBit(c, 2) ^ GetBit(c, 0) );
28. }
29.
30. static inline int XorCP1(unsigned char c)
31. {
32. return (GetBit(c, 7) ^ GetBit(c, 5) ^ GetBit(c, 3) ^ GetBit(c, 1) );
33. }
34.
35. static inline int XorCP2(unsigned char c)
36. {
37. return (GetBit(c, 5) ^ GetBit(c, 4) ^ GetBit(c, 1) ^ GetBit(c, 0) );
38. }
39.
40. static inline int XorCP3(unsigned char c)
41. {
42. return (GetBit(c, 7) ^ GetBit(c, 6) ^ GetBit(c, 3) ^ GetBit(c, 2) );
43. }
44.
45. static inline int XorCP4(unsigned char c)
46. {
47. return (GetBit(c, 3) ^ GetBit(c, 2) ^ GetBit(c, 1) ^ GetBit(c, 0) );
48. }
49.
50. static inline int XorCP5(unsigned char c)
51. {
52. return (GetBit(c, 7) ^ GetBit(c, 6) ^ GetBit(c, 5) ^ GetBit(c, 4) );
53. }
54.
55.
56.
57. unsigned int ECC(const unsigned char* data)
58. {
59. unsigned int ecc = 0xFFFFFFFF;
60.
61. for(size_t i=0; i<256; i++)
62. {
63. unsigned char c=data[i];
64.
65. int lp = XorLP(c);
66.
67. // Bit 0
68. if (i & 0x01)
69. SetBit(ecc, 1, lp ^ GetBit(ecc, 1) );
70. else
71. SetBit(ecc, 0, lp ^ GetBit(ecc, 0) );
72.
73. // Bit 1
74. if (i & 0x02)
75. SetBit(ecc, 3, lp ^ GetBit(ecc, 3) );
76. else
77. SetBit(ecc, 2, lp ^ GetBit(ecc, 2) );
78.
79. // Bit 2
80. if (i & 0x04)
81. SetBit(ecc, 5, lp ^ GetBit(ecc, 5) );
82. else
83. SetBit(ecc, 4, lp ^ GetBit(ecc, 4) );
84.
85. // Bit 3
86. if (i & 0x08)
87. SetBit(ecc, 7, lp ^ GetBit(ecc, 7) );
88. else
89. SetBit(ecc, 6, lp ^ GetBit(ecc, 6) );
90.
91. // Bit 4
92. if (i & 0x10)
93. SetBit(ecc, 9, lp ^ GetBit(ecc, 8) );
94. else
95. SetBit(ecc, 8, lp ^ GetBit(ecc, 8) );
96.
97. // Bit 5
98. if (i & 0x20)
99. SetBit(ecc, 11, lp ^ GetBit(ecc, 11) );
100. else
101. SetBit(ecc, 10, lp ^ GetBit(ecc, 10) );
102.
103. // Bit 6
104. if (i & 0x40)
105. SetBit(ecc, 13, lp ^ GetBit(ecc, 13) );
106. else
107. SetBit(ecc, 12, lp ^ GetBit(ecc, 12) );
108.
109. // Bit 7
110. if (i & 0x80)
111. SetBit(ecc, 15, lp ^ GetBit(ecc, 15) );
112. else
113. SetBit(ecc, 14, lp ^ GetBit(ecc, 14) );
114.
115. SetBit(ecc, 18, XorCP0(c) ^ GetBit(ecc, 18) );
116. SetBit(ecc, 19, XorCP1(c) ^ GetBit(ecc, 19) );
117. SetBit(ecc, 20, XorCP2(c) ^ GetBit(ecc, 20) );
118. SetBit(ecc, 21, XorCP3(c) ^ GetBit(ecc, 21) );
119. SetBit(ecc, 22, XorCP4(c) ^ GetBit(ecc, 22) );
120. SetBit(ecc, 23, XorCP5(c) ^ GetBit(ecc, 23) );
121. }
122.
123. SetBit(ecc, 16, 1);
124. SetBit(ecc, 17, 1);
125.
126. return ecc;
127. }
使用ecc table的ECC算法的实现
static const u_char nand_ecc_precalc_table[] =
{
0x00, 0x55, 0x56, 0x03, 0x59, 0x0c, 0x0f, 0x5a, 0x5a, 0x0f, 0x0c, 0x59, 0x03, 0x56, 0x55, 0x00,
0x65, 0x30, 0x33, 0x66, 0x3c, 0x69, 0x6a, 0x3f, 0x3f, 0x6a, 0x69, 0x3c, 0x66, 0x33, 0x30, 0x65,
0x66, 0x33, 0x30, 0x65, 0x3f, 0x6a, 0x69, 0x3c, 0x3c, 0x69, 0x6a, 0x3f, 0x65, 0x30, 0x33, 0x66,
0x03, 0x56, 0x55, 0x00, 0x5a, 0x0f, 0x0c, 0x59, 0x59, 0x0c, 0x0f, 0x5a, 0x00, 0x55, 0x56, 0x03,
0x69, 0x3c, 0x3f, 0x6a, 0x30, 0x65, 0x66, 0x33, 0x33, 0x66, 0x65, 0x30, 0x6a, 0x3f, 0x3c, 0x69,
0x0c, 0x59, 0x5a, 0x0f, 0x55, 0x00, 0x03, 0x56, 0x56, 0x03, 0x00, 0x55, 0x0f, 0x5a, 0x59, 0x0c,
0x0f, 0x5a, 0x59, 0x0c, 0x56, 0x03, 0x00, 0x55, 0x55, 0x00, 0x03, 0x56, 0x0c, 0x59, 0x5a, 0x0f,
0x6a, 0x3f, 0x3c, 0x69, 0x33, 0x66, 0x65, 0x30, 0x30, 0x65, 0x66, 0x33, 0x69, 0x3c, 0x3f, 0x6a,
0x6a, 0x3f, 0x3c, 0x69, 0x33, 0x66, 0x65, 0x30, 0x30, 0x65, 0x66, 0x33, 0x69, 0x3c, 0x3f, 0x6a,
0x0f, 0x5a, 0x59, 0x0c, 0x56, 0x03, 0x00, 0x55, 0x55, 0x00, 0x03, 0x56, 0x0c, 0x59, 0x5a, 0x0f,
0x0c, 0x59, 0x5a, 0x0f, 0x55, 0x00, 0x03, 0x56, 0x56, 0x03, 0x00, 0x55, 0x0f, 0x5a, 0x59, 0x0c,
0x69, 0x3c, 0x3f, 0x6a, 0x30, 0x65, 0x66, 0x33, 0x33, 0x66, 0x65, 0x30, 0x6a, 0x3f, 0x3c, 0x69,
0x03, 0x56, 0x55, 0x00, 0x5a, 0x0f, 0x0c, 0x59, 0x59, 0x0c, 0x0f, 0x5a, 0x00, 0x55, 0x56, 0x03,
0x66, 0x33, 0x30, 0x65, 0x3f, 0x6a, 0x69, 0x3c, 0x3c, 0x69, 0x6a, 0x3f, 0x65, 0x30, 0x33, 0x66,
0x65, 0x30, 0x33, 0x66, 0x3c, 0x69, 0x6a, 0x3f, 0x3f, 0x6a, 0x69, 0x3c, 0x66, 0x33, 0x30, 0x65,
0x00, 0x55, 0x56, 0x03, 0x59, 0x0c, 0x0f, 0x5a, 0x5a, 0x0f, 0x0c, 0x59, 0x03, 0x56, 0x55, 0x00
};
//Creates non-inverted ECC code from line parity
static void nand_trans_result(u_char reg2, u_char reg3,u_char *ecc_code)
{
u_char a, b, i, tmp1, tmp2;
/* Initialize variables */
a = b = 0x80;
tmp1 = tmp2 = 0;
/* Calculate first ECC byte */
for (i = 0; i < 4; i++)
{
if (reg3 & a) /* LP15,13,11,9 --> ecc_code[0] */
tmp1 |= b;
b >>= 1;
if (reg2 & a) /* LP14,12,10,8 --> ecc_code[0] */
tmp1 |= b;
b >>= 1;
a >>= 1;
}
/* Calculate second ECC byte */
b = 0x80;
for (i = 0; i < 4; i++)
{
if (reg3 & a) /* LP7,5,3,1 --> ecc_code[1] */
tmp2 |= b;
b >>= 1;
if (reg2 & a) /* LP6,4,2,0 --> ecc_code[1] */
tmp2 |= b;
b >>= 1;
a >>= 1;
}
/* Store two of the ECC bytes */
ecc_code[0] = tmp1;
ecc_code[1] = tmp2;
}
// Calculate 3 byte ECC code for 256 byte block
void nand_calculate_ecc (const u_char *dat, u_char *ecc_code)
{
u_char idx, reg1, reg2, reg3;
int j;
/* Initialize variables */
reg1 = reg2 = reg3 = 0;
ecc_code[0] = ecc_code[1] = ecc_code[2] = 0;
/* Build up column parity */
for(j = 0; j < 256; j++)
{
/* Get CP0 - CP5 from table */
idx = nand_ecc_precalc_table[dat[j]];
reg1 ^= (idx & 0x3f);
/* All bit XOR = 1 ? */
if (idx & 0x40) {
reg3 ^= (u_char) j;
reg2 ^= ~((u_char) j);
}
}
/* Create non-inverted ECC code from line parity */
nand_trans_result(reg2, reg3, ecc_code);
/* Calculate final ECC code */
ecc_code[0] = ~ecc_code[0];
ecc_code[1] = ~ecc_code[1];
ecc_code[2] = ((~reg1) << 2) | 0x03;
}
// Detect and correct a 1 bit error for 256 byte block
int nand_correct_data (u_char *dat, u_char *read_ecc, u_char *calc_ecc)
{
u_char a, b, c, d1, d2, d3, add, bit, i;
/* Do error detection */
d1 = calc_ecc[0] ^ read_ecc[0];
d2 = calc_ecc[1] ^ read_ecc[1];
d3 = calc_ecc[2] ^ read_ecc[2];
if ((d1 | d2 | d3) == 0)
{
/* No errors */
return 0;
}
else
{
a = (d1 ^ (d1 >> 1)) & 0x55;
b = (d2 ^ (d2 >> 1)) & 0x55;
c = (d3 ^ (d3 >> 1)) & 0x54;
/* Found and will correct single bit error in the data */
if ((a == 0x55) && (b == 0x55) && (c == 0x54))
{
c = 0x80;
add = 0;
a = 0x80;
for (i=0; i<4; i++)
{
if (d1 & c)
add |= a;
c >>= 2;
a >>= 1;
}
c = 0x80;
for (i=0; i<4; i++)
{
if (d2 & c)
add |= a;
c >>= 2;
a >>= 1;
}
bit = 0;
b = 0x04;
c = 0x80;
for (i=0; i<3; i++)
{
if (d3 & c)
bit |= b;
c >>= 2;
b >>= 1;
}
b = 0x01;
a = dat[add];
a ^= (b << bit);
dat[add] = a;
return 1;
}
else
{
i = 0;
while (d1)
{
if (d1 & 0x01)
++i;
d1 >>= 1;
}
while (d2)
{
if (d2 & 0x01)
++i;
d2 >>= 1;
}
while (d3)
{
if (d3 & 0x01)
++i;
d3 >>= 1;
}
if (i == 1)
{
/* ECC Code Error Correction */
read_ecc[0] = calc_ecc[0];
read_ecc[1] = calc_ecc[1];
read_ecc[2] = calc_ecc[2];
return 2;
}
else
{
/* Uncorrectable Error */
return -1;
}
}
}
/* Should never happen */
return -1;
}
flash的烧写
这里的烧写是指打开software check ecc，如果使用nand 子指令是没有问题的，会自动跳过bad block，还会计算出ecc并写入flash中，但是前提在flash中有可用的bootcode，但是如果是空的，那就必须使用烧code机烧写 flash了， 如果使用烧code机就不一样了，需要将要烧如flash的binary处理一下，将binary中包含oob信息，这里我们自己写了两个tools来处理这件事, 两个tools分别是针对small page和big page的。
命令的使用方法：big_page/small_page [source file] [dest file] [oob file]
命令的原理：就是在适当的位置，插入oob的ECC值。
用烧code机烧flash时应注意：
erase时， access mothod中Invalid Block Management要选择Do not use, 这样擦的时候不会检测是不是坏块, Spare Area Usage选择User Data with IB Info forced。
write时，需要将Invalid Block Management改为Skip IB，写时会跳过坏块，Spare Area Usage选择User Data with IB Info forced， 选择binary中的ecc信息， 即ECC_SOFTWARE。
