ssd202d-badblock-坏块检测

这边文章报告的是坏快检测功能
思路：
1.第一次烧录固件会实现跳坏块，但是后续使用会导致坏块的产生；
于是我在uboot情况变量添加了两个变量来控制坏快
lb_badnum = //坏块个数
lb_badoff = //坏块所在位置

2.第一次开时机根据lb_badnum是否存在判断,如果不存在则生存上面坏块信息,跳过坏块功能
3.第二次开机之后会获取情况变量lb_badnum和lb_badoff;
3.1.然后检测现实坏块数,举行对比,如果有新增坏块, 则判断新坏块产生的所在分区;
3.2.然后判断所在分区坏块大小加上固件大小后是否超出分别的分区空间;
3.3.执行对应的分区还原;

1. commit 0ae66e0a3d1366aa90b4661b86203345f4ae02bd (HEAD -> master)
2. Author: longmin <1938049502@qq.com>
3. Date:   Tue Dec 10 16:44:44 2024 +0800
5.     add cmd_lbbad.c support bad block detection function
7. diff --git a/boot/common/Kconfig b/boot/common/Kconfig
8. index 516a279af..11cb2c30a 100755
9. --- a/boot/common/Kconfig
10. +++ b/boot/common/Kconfig
11. @@ -365,4 +365,10 @@ config XZ
12. config MZ
13.         bool "MZ"
14. config SILENT_CONSOLE
15. -       bool "SILENT_CONSOLE"
16. \ No newline at end of file
17. +       bool "SILENT_CONSOLE"
18. +
19. +config CMD_LBBAD
20. +       bool "LBBAD"
21. +       help
22. +         This enables the command CONFIG_CMD_LBBAD power on detection of bad
23. +         blocks.
24. \ No newline at end of file
25. diff --git a/boot/common/Makefile b/boot/common/Makefile
26. index 85ba0bffd..0d54285f5 100755
27. --- a/boot/common/Makefile
28. +++ b/boot/common/Makefile
29. @@ -344,4 +344,5 @@ endif
31. obj-$(CONFIG_CMD_LBCHK) += cmd_lbchk.o
32. obj-$(CONFIG_CMD_LBFDT) += cmd_lbfdt.o
33. +obj-$(CONFIG_CMD_LBBAD) += cmd_lbbad.o
34. obj-y += cmd_sar.o
35. diff --git a/boot/common/autoboot.c b/boot/common/autoboot.c
36. index 60f7b2291..927dcd18a 100755
37. --- a/boot/common/autoboot.c
38. +++ b/boot/common/autoboot.c
39. @@ -585,6 +585,10 @@ void autoboot_command(const char *s)
41. boot:
42.         debug("### main_loop: bootcmd="%s"\n", s ? s : "<UNDEFINED>");
43. +#if defined (CONFIG_CMD_LBBAD)
44. +      extern int run_lbbadblock(void);
45. +      run_lbbadblock();    /* bad block inspection */
46. +#endif
47. #if defined (CONFIG_CMD_LBCHK) && defined (LONBON_CHECK_RUNCMD)
48.        extern int run_lbcheck(int cmd);
49.        run_lbcheck(LONBON_CHECK_RUNCMD);
50. diff --git a/boot/common/cmd_lbbad.c b/boot/common/cmd_lbbad.c
51. new file mode 100755
52. index 000000000..5bfa4890c
53. --- /dev/null
54. +++ b/boot/common/cmd_lbbad.c
55. @@ -0,0 +1,503 @@
56. +#include <common.h>^M
57. +#include <command.h>^M
58. +#include <malloc.h>^M
59. +#include <nand.h>^M
60. +#include <u-boot/md5.h>^M
61. +#include <asm/io.h>^M
62. +#include <spi.h>^M
63. +#include <spi_flash.h>^M
64. +#if (1 == CONFIG_LONBON_LED) || (1 == LONBON_CMD_CHECK_2BTN_FOR_RESTORE)^M
65. +#include "../drivers/mstar/gpio/infinity2m/gpio.h"^M
66. +#include "../drivers/mstar/gpio/drvGPIO.h"^M
67. +#endif^M
68. +^M
69. +//#define LB_DEBUG^M
70. +^M
71. +#ifdef LB_DEBUG^M
72. +#define LBCHK_DEBUG(msg...)            printf(msg)^M
73. +#else^M
74. +#define LBCHK_DEBUG(msg...)            do{}while(0)^M
75. +#endif^M
76. +^M
77. +typedef int BOOL;^M
78. +^M
79. +#ifndef FALSE^M
80. +#define FALSE  0^M
81. +#endif^M
82. +^M
83. +#ifndef TRUE^M
84. +#define TRUE   1^M
85. +#endif^M
86. +^M
87. +#ifdef CONFIG_YAFFS2^M
88. +extern void cmd_yaffs_devconfig(char *mp, int flash_dev, int start_block, int end_block);^M
89. +extern void cmd_yaffs_mount(char *mp);^M
90. +extern void cmd_yaffs_umount(char *mp);^M
91. +extern void cmd_yaffs_mread_file(char *fn, char *addr);^M
92. +#endif^M
93. +^M
94. +#define BADBLOCK_MAX 200^M
95. +^M
96. +extern int lb_nand_get_badblock_number(ulong *badblock_list);^M
97. +extern int lbcmd_get_imagename_by_cmd(char* imgname, unsigned char cmd);^M
98. +extern int lonbon_get_partitions(const char *part_name, uint *part_offset, uint *part_size);^M
99. +extern int lonbon_get_partitions_name(uint *off, char *part_name, uint *part_offset, uint *part_size);^M
100. +extern int lb_nand_flash_partition_baseAddr(const char *part_name, uint *part_offset, uint *part_size);^M
101. +^M
102. +typedef struct {^M
103. +       int uboot;^M
104. +       int kernel;^M
105. +       int rootfs;^M
106. +       int backup;^M
107. +       int ro;^M
108. +       int rw;^M
109. +       int ipl;^M
110. +       int ipl_cust;^M
111. +       int logo;^M
112. +       int factory;^M
113. +       int lbcmd;^M
114. +       int lbflash;^M
115. +       int lbcfg;^M
116. +       int env;^M
117. +       int key_cust;^M
118. +} lb_bad_partition_t;^M
119. +^M
120. +int lonbon_set_badnum(int number)^M
121. +{^M
122. +       unsigned char  badnum[2];^M
123. +    if(number >= 0) {^M
124. +               memset(badnum,0,2);^M
125. +               badnum[0] = number + 0x30;^M
126. +               setenv("lb_badnum", (const char *)badnum);^M
127. +               run_command("saveenv", 0);^M
128. +               return 0;^M
129. +    }^M
130. +       return -1;^M
131. +}^M
132. +^M
133. +int lonbon_get_badnum(void)^M
134. +{^M
135. +       char * lb_badnum = getenv("lb_badnum");^M
136. +       unsigned char  badnum[2];^M
137. +^M
138. +    if(lb_badnum) {^M
139. +               badnum[0] = *lb_badnum - 0x30;^M
140. +               printf("old bad_block number= %d\n",badnum[0]);^M
141. +               return badnum[0];^M
142. +    }else{^M
143. +               printf("%s lb_badnum=null\n", __func__);^M
144. +               return -1;^M
145. +       }^M
146. +       return 0;^M
147. +}^M
148. +^M
149. +int lonbon_number_exist(int all_number, ulong *badblock_list, ulong number){^M
150. +       int i;^M
151. +       for(i=0; i < all_number; i++)^M
152. +       {^M
153. +               if(*(badblock_list+i) == number)^M
154. +               {^M
155. +                       return i;^M
156. +               }^M
157. +       }^M
158. +       return -1;^M
159. +}^M
160. +^M
161. +int lonbon_new_badblock(int all_number, ulong *badblock_list, int env_number, ulong *old_badblock_list,ulong *add_badblock_list)^M
162. +{^M
163. +       int i, j, k = 0;^M
164. +       bool flag;^M
165. +       for (i=0; i < all_number; i++){^M
166. +               flag = false;^M
167. +               for (j=0; j < all_number; j++){^M
168. +               if( badblock_list[i] == old_badblock_list[j] )^M
169. +               flag = true;^M
170. +               }^M
171. +^M
172. +               if(flag == false){^M
173. +               *(add_badblock_list + k) = badblock_list[i];^M
174. +               k++;^M
175. +               }^M
176. +^M
177. +       }^M
178. +^M
179. +       return 0;^M
180. +}^M
181. +^M
182. +^M
183. +int lonbon_get_bad_offset(int all_number, ulong *badblock_list, int number)^M
184. +{^M
185. +       int i;^M
186. +       char *lb_badoff = getenv("lb_badoff");^M
187. +       char badb_offset[1024]= {0};^M
188. +       ulong old_badb_list[all_number];^M
189. +       ulong *old_badblock_list = &old_badb_list[0];^M
190. +       ulong add_badb_list[all_number];^M
191. +       ulong *add_badblock_list = &add_badb_list[0];^M
192. +       char *lb_bad_off;^M
193. +       ulong num;^M
194. +^M
195. +       if(all_number == 0){^M
196. +       printf("%s not badblock_list\n", __func__);^M
197. +       return 0;^M
198. +       }^M
199. +^M
200. +       if(lb_badoff){^M
201. +               strcpy(badb_offset,lb_badoff);^M
202. +               lb_bad_off = strtok(badb_offset, "-");^M
203. +               num = simple_strtol(lb_bad_off, NULL, 16);^M
204. +               old_badb_list[0] = num;^M
205. +               for(i=1; i < all_number;i++ ){^M
206. +               lb_bad_off = strtok(NULL ,"-");^M
207. +               num = simple_strtol(lb_bad_off, NULL, 16);^M
208. +               old_badb_list[i] = num;^M
209. +               }^M
210. +       }^M
211. +       /* determine the partition location of the new bad block */^M
212. +       lonbon_new_badblock(all_number, badblock_list, number, old_badblock_list, add_badblock_list);^M
213. +       for(i=0; i < all_number; i++){^M
214. +       *(badblock_list + i) = 0;^M
215. +       }^M
216. +       for(i=0; i<number;i++){^M
217. +       *(badblock_list + i) = add_badb_list[i];^M
218. +       }^M
219. +^M
220. +       return 1;^M
221. +}^M
222. +^M
223. +int lonbon_set_bad_offset(int number, ulong *badblock_list)^M
224. +{^M
225. +       int i;^M
226. +       char commandline[10] = {0};^M
227. +       char badb_addr[1024]= {'0'};^M
228. +       if(number >= 0) {^M
229. +               if(number > 0) {^M
230. +                       for(i=0;i<number;i++){^M
231. +                       sprintf(commandline,"%08lx-", *(badblock_list+i));^M
232. +                       strcat(badb_addr,commandline);^M
233. +                       }^M
234. +               }^M
235. +               printf("lonbon_set_bad_offset badblock_list:%s\n",badb_addr);^M
236. +               setenv("lb_badoff", (const char *)badb_addr);^M
237. +               run_command("saveenv", 0);^M
238. +               return number;^M
239. +       }^M
240. +       return 0;^M
241. +}^M
242. +^M
243. +int lonbon_set_partitions(lb_bad_partition_t *lb_part, char *part_name)^M
244. +{^M
245. +       //printf("%s %s \n",__func__,part_name);^M
246. +       if(strcmp(part_name, "UBOOT0") == 0||strcmp(part_name, "UBOOT1") == 0){^M
247. +       lb_part->uboot += 1;^M
248. +       }else if(strcmp(part_name, "rootfs") == 0){^M
249. +       lb_part->rootfs  += 1;^M
250. +       }else if(strcmp(part_name, "KERNEL") == 0||strcmp(part_name, "RECOVERY") == 0){^M
251. +       lb_part->kernel  += 1;^M
252. +       }else if(strcmp(part_name, "backup") == 0){^M
253. +       lb_part->backup  += 1;^M
254. +       }else if(strcmp(part_name, "ro") == 0){^M
255. +       lb_part->ro  += 1;^M
256. +       }else if(strcmp(part_name, "rw") == 0){^M
257. +       lb_part->rw  += 1;^M
258. +       }else if(strcmp(part_name, "IPL0") == 0||strcmp(part_name, "IPL1") == 0){^M
259. +       lb_part->ipl  += 1;^M
260. +       }else if(strcmp(part_name, "IPL_CUST0") == 0||strcmp(part_name, "IPL_CUST1") == 0){^M
261. +       lb_part->ipl_cust  += 1;^M
262. +       }else if(strcmp(part_name, "LOGO") == 0){^M
263. +       lb_part->logo  += 1;^M
264. +       }else if(strcmp(part_name, "factory") == 0){^M
265. +       lb_part->factory  += 1;^M
266. +       }else if(strcmp(part_name, "lbcmd") == 0){^M
267. +       lb_part->lbcmd  += 1;;^M
268. +       }else if(strcmp(part_name, "lbflash") == 0||strcmp(part_name, "lbflash2") == 0){^M
269. +       lb_part->lbflash  += 1;^M
270. +       }else if(strcmp(part_name, "lbcfg") == 0||strcmp(part_name, "lbcfg2") == 0){^M
271. +       lb_part->lbcfg  += 1;^M
272. +       }else if(strcmp(part_name, "ENV") == 0||strcmp(part_name, "ENV1") == 0){^M
273. +       lb_part->env  += 1;^M
274. +       }else if(strcmp(part_name, "KEY_CUST") == 0){^M
275. +       lb_part->key_cust  += 1;^M
276. +       }else{^M
277. +       return -1;^M
278. +       }^M
279. +^M
280. +       return 0;^M
281. +}^M
282. +^M
283. +void lonbon_printf_bad(int num){^M
284. +^M
285. +       switch (num)^M
286. +       {^M
287. +               case 0: printf("\n");^M
288. +                               printf("##############################################################################\n");^M
289. +                               printf("##############################################################################\n");^M
290. +                               printf("############################ bad block list:##################################\n");^M
291. +                               break;^M
292. +               case 1: printf("\nstart all bad block list:\n");^M
293. +                               break;^M
294. +               case 2: printf("\n");^M
295. +                               printf("add bad block:\n");^M
296. +                               printf("\n");^M
297. +                               break;^M
298. +               case 3: printf("\n");^M
299. +                               printf("##############################################################################\n");^M
300. +                               printf("##############################################################################\n");^M
301. +                               printf("\n");^M
302. +                               break;^M
303. +       }^M
304. +^M
305. +}^M
306. +^M
307. +uint lonbon_get_pattition_firmware_size(char *fileName){^M
308. +               char *mntpoint = "/factory";^M
309. +               uint part_offset;^M
310. +               uint part_size;^M
311. +               int start_block;^M
312. +               int end_block;^M
313. +^M
314. +               char filename[100] = {0};^M
315. +               unsigned long addr= 0x21000000;^M
316. +               lb_nand_flash_partition_baseAddr("factory", &part_offset, &part_size);^M
317. +               if(!part_offset || !part_size) {^M
318. +                       printf("#ERROR: No factory partition is found\n");^M
319. +                       return -1;^M
320. +               }^M
321. +^M
322. +               start_block = part_offset/(128*1024); /* Nand flash block size is 128 KB */^M
323. +               end_block = (part_offset+part_size)/(128*1024)-1;^M
324. +^M
325. +               cmd_yaffs_devconfig(mntpoint,0,start_block,end_block);^M
326. +               cmd_yaffs_mount(mntpoint);^M
327. +               sprintf(filename, "%s/%s", mntpoint, fileName);^M
328. +               cmd_yaffs_mread_file(filename, (char *)addr);^M
329. +               char *str_env = getenv("filesize");^M
330. +               ulong filesize = simple_strtoul(str_env, NULL, 16);^M
331. +               size_t blocksize = nand_info[0].erasesize;^M
332. +               ulong wsize=(filesize/blocksize+1)*blocksize;^M
333. +               cmd_yaffs_umount(mntpoint);^M
334. +               printf("longbon  filename=%s  str_env=%s filesize=%lx wsize=%lx \n",filename,str_env,filesize,wsize);^M
335. +       return wsize;^M
336. +^M
337. +}^M
338. +^M
339. +int lonbon_pattition_firmware_size(unsigned char cmd, char *part_name, int bad_number)^M
340. +{^M
341. +       char firmware_name[32] = {0};^M
342. +       char *firmware_part_name = &firmware_name[0];^M
343. +       uint part_offset, part_size;^M
344. +       ulong firmware_size, firmware_size_bad;^M
345. +       size_t blocksize = nand_info[0].erasesize;^M
346. +^M
347. +       /* get firmware name */^M
348. +       lbcmd_get_imagename_by_cmd(firmware_part_name, cmd);^M
349. +       /* get firmware size */^M
350. +       firmware_size = lonbon_get_pattition_firmware_size(firmware_part_name);^M
351. +       /* the size after adding the bad block */^M
352. +       firmware_size_bad = firmware_size +( blocksize * bad_number);^M
353. +       /* get partitions total size */^M
354. +       lonbon_get_partitions(part_name, &part_offset, &part_size);^M
355. +^M
356. +       /* partitions total size > firmware size add bad block size */^M
357. +       if( part_size > firmware_size_bad)^M
358. +       {^M
359. +       printf("\nlonbon %s is OK! part_size=%x firmware_size_bad=%lx \n",__func__,part_size,firmware_size_bad);^M
360. +       return 1;^M
361. +       }^M
362. +       else {^M
363. +       printf("\nlonbon %s error!! part_size=%x firmware_size_bad=%lx \n",__func__,part_size,firmware_size_bad);^M
364. +       return -1;^M
365. +       }^M
366. +       return 0;^M
367. +}^M
368. +^M
369. +void lonbon_printf_bad_block(lb_bad_partition_t *lb_bad_partition, int number, ulong *bad_list, int new_number, ulong *new_bad_list){^M
370. +^M
371. +       int i, ret, flags = 0;^M
372. +       char write[20] = {' '};^M
373. +       char *write_t = &write[0];^M
374. +       char part_name[10] = {'0'};^M
375. +       char *part_name_t = &part_name[0];^M
376. +       ulong *badblock_list = bad_list;^M
377. +       char commandline[30] = {0};^M
378. +       uint lbflash_offset = 0,lbflash_size = 0;^M
379. +^M
380. +       if(new_number > 0){^M
381. +       lonbon_printf_bad(1);^M
382. +       }^M
383. +       for(i=0; i< number; i++){^M
384. +               memset(part_name,0,sizeof(part_name));^M
385. +               lonbon_get_partitions_name((uint *) *(badblock_list+i), part_name_t, &lbflash_offset, &lbflash_size);^M
386. +               printf("bad[%d]=0x%08lx name=%s off=0x%08x size=0x%08x end=0x%08x \n",^M
387. +                       i, *(badblock_list+i), part_name_t, lbflash_offset, lbflash_size ,(lbflash_offset +lbflash_size -1) );^M
388. +       }^M
389. +       if(new_number > 0){^M
390. +       lonbon_printf_bad(2);^M
391. +               for(i=0; i< new_number; i++){^M
392. +               printf(" 0x%08lx \n", *(new_bad_list + i));^M
393. +               }^M
394. +       }^M
395. +       if(lb_bad_partition->factory > 0){^M
396. +       printf("\n warn factory partition are bad blocks !!!\n\n");^M
397. +       }^M
398. +       if(lb_bad_partition->uboot > 0){^M
399. +       printf("\n warn uboot partition are bad blocks !!!\n\n");^M
400. +       ret = lonbon_pattition_firmware_size(1,"uboot",lb_bad_partition->uboot);^M
401. +               if(ret > 0){^M
402. +               strcat(write,"1 ");^M
403. +               flags++;^M
404. +               }else{^M
405. +               printf("\n%s error!!!uboot insufficient partition space !!!\n",__func__ );^M
406. +               }^M
407. +       }^M
408. +       if(lb_bad_partition->kernel > 0){^M
409. +       printf("\n warn kernel partition are bad blocks !!!\n\n");^M
410. +       ret = lonbon_pattition_firmware_size(2,"kernel",lb_bad_partition->kernel);^M
411. +               if(ret > 0){^M
412. +               strcat(write,"2 ");^M
413. +               flags++;^M
414. +               }else{^M
415. +               printf("\n%s error!!!kernel insufficient partition space !!!\n",__func__ );^M
416. +               }^M
417. +       }^M
418. +       if(lb_bad_partition->rootfs > 0){^M
419. +       printf("\n warn rootfs partition are bad blocks !!!\n\n");^M
420. +       ret = lonbon_pattition_firmware_size(3,"rootfs",lb_bad_partition->rootfs);^M
421. +               if(ret > 0){^M
422. +               strcat(write,"3 ");^M
423. +               flags++;^M
424. +               }else{^M
425. +               printf("\n%s error!!!rootfs insufficient partition space !!!\n",__func__ );^M
426. +               }^M
427. +       }^M
428. +       if(lb_bad_partition->backup > 0){^M
429. +       printf("\n warn backup partition are bad blocks !!!\n\n");^M
430. +       }^M
431. +       if(lb_bad_partition->ro > 0){^M
432. +       printf("\n warn ro partition are bad blocks !!!\n\n");^M
433. +       }^M
434. +       if(lb_bad_partition->rw > 0){^M
435. +       printf("\n warn rw partition are bad blocks !!!\n\n");^M
436. +       }^M
437. +       if(lb_bad_partition->ipl > 0){^M
438. +       printf("\n warn ipl partition are bad blocks !!!\n\n");^M
439. +       ret = lonbon_pattition_firmware_size(6,"ipl",lb_bad_partition->ipl);^M
440. +               if(ret > 0){^M
441. +               strcat(write,"6 ");^M
442. +               flags++;^M
443. +               }else{^M
444. +               printf("\n%s error!!!ipl insufficient partition space !!!\n",__func__ );^M
445. +               }^M
446. +       }^M
447. +       if(lb_bad_partition->ipl_cust > 0){^M
448. +       printf("\n warn ipl_cust partition are bad blocks !!!\n\n");^M
449. +       ret = lonbon_pattition_firmware_size(7,"ipl",lb_bad_partition->ipl_cust);^M
450. +               if(ret > 0){^M
451. +               strcat(write,"7 ");^M
452. +               flags++;^M
453. +               }else{^M
454. +               printf("\n%s error!!!ipl_cust insufficient partition space !!!\n",__func__ );^M
455. +               }^M
456. +       }^M
457. +       if(lb_bad_partition->logo > 0){^M
458. +       printf("\n warn logo partition are bad blocks !!!\n\n");^M
459. +       ret = lonbon_pattition_firmware_size(8,"logo",lb_bad_partition->logo);^M
460. +               if(ret > 0){^M
461. +               //run_command("lbupgrade write 8", 0);^M
462. +               strcat(write,"8 ");^M
463. +               flags++;^M
464. +               }else{^M
465. +               printf("\n%s error!!!logo insufficient partition space !!!\n",__func__ );^M
466. +               }^M
467. +       }^M
468. +^M
469. +       if (flags > 0){^M
470. +       sprintf(commandline,"lbupgrade write %s", write_t);^M
471. +       printf("\nlonbon %s run_command: %s !!!\n", __func__ , commandline);^M
472. +       run_command(commandline, 0);^M
473. +       }^M
474. +^M
475. +       lonbon_printf_bad(3);^M
476. +^M
477. +}^M
478. +^M
479. +/* bad block inspection */^M
480. +int run_lbbadblock(void) ^M
481. +{^M
482. +       lb_bad_partition_t lb_bad_partition ={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};^M
483. +       lb_bad_partition_t *lb_bad_partition_r = &lb_bad_partition;^M
484. +       int ret, i;^M
485. +       char part_name[10] = {'0'};^M
486. +       char *part_name_t = &part_name[0];^M
487. +       uint lbflash_offset = 0,lbflash_size = 0;^M
488. +       ulong badblock_list[BADBLOCK_MAX];^M
489. +       ulong *list_badblock = &badblock_list[0];^M
490. +       int badblock_number , lb_badnum;^M
491. +       bool new_badblock = false;^M
492. +^M
493. +       lonbon_printf_bad(0);^M
494. +       memset(badblock_list,0,sizeof(badblock_list));^M
495. +       badblock_number = lb_nand_get_badblock_number(list_badblock);^M
496. +       ulong bad_list[badblock_number];^M
497. +       ulong *bad_list_t = &bad_list[0];^M
498. +^M
499. +       for( i = 0; i < badblock_number; i++){^M
500. +       bad_list[i] = badblock_list[i];^M
501. +       }^M
502. +^M
503. +       if(badblock_number < 0){^M
504. +               printf("error! get badblock number failed! :%d\n",badblock_number);^M
505. +               return badblock_number;^M
506. +       }else{^M
507. +               printf("bad badblock  number: %d\n",badblock_number);^M
508. +       }^M
509. +^M
510. +       lb_badnum = lonbon_get_badnum();/* get lb_badnum */^M
511. +       if(lb_badnum < 0){ /* the first burning is not processed */^M
512. +^M
513. +               ret = lonbon_set_badnum(badblock_number);/* directly save the number of burned blocks */^M
514. +               if(ret < 0){^M
515. +               printf("error %s badblock_number=null\n",__func__);^M
516. +               }^M
517. +               printf("lonbon %s init badblock\n",__func__);^M
518. +               ret = lonbon_set_bad_offset(badblock_number, list_badblock);/* save bad block address*/^M
519. +               lonbon_printf_bad(3);^M
520. +               return 0;^M
521. +^M
522. +       }else{   /* after the second boot, go here */^M
523. +               if(badblock_number == lb_badnum){ /* equal means there are no bad blocks */^M
524. +                       printf("lonbon %s not new badblock\n",__func__);^M
525. +^M
526. +               }else{                            /* unequal means there are bad blocks */^M
527. +                       printf("%s new badblock number= %d\n",__func__, badblock_number - lb_badnum);^M
528. +                       ret = lonbon_set_badnum(badblock_number);^M
529. +                       if(ret < 0){^M
530. +                       printf("error %s badblock_number=null\n",__func__);^M
531. +                       }else{^M
532. +                       new_badblock = true; /* mark the newly added bad block symbol */^M
533. +                       }^M
534. +               }^M
535. +       }^M
536. +^M
537. +       if(new_badblock == true ){/* there are new bad blocks added */^M
538. +               /* Get env bad block address */^M
539. +               ret = lonbon_get_bad_offset(badblock_number, list_badblock ,badblock_number - lb_badnum);^M
540. +^M
541. +               for(i=0; i< badblock_number - lb_badnum; i++){^M
542. +                       memset(part_name,0,sizeof(part_name));^M
543. +                       lonbon_get_partitions_name((uint *) badblock_list[i], part_name_t, &lbflash_offset, &lbflash_size);^M
544. +                       ret = lonbon_set_partitions(lb_bad_partition_r, part_name_t);^M
545. +               }^M
546. +               printf("%s new_badblock=true\n",__func__);^M
547. +^M
548. +       }^M
549. +^M
550. +       lonbon_printf_bad_block(lb_bad_partition_r, badblock_number, bad_list_t, badblock_number - lb_badnum, list_badblock);^M
551. +^M
552. +       if(new_badblock == true){/* if a new bad block is added, restart and enter restore mode */^M
553. +               ret = lonbon_set_bad_offset(badblock_number, bad_list_t);/* save bad block address */^M
554. +               new_badblock = false;^M
555. +               run_command("reset", 0);^M
556. +       }^M
557. +       return 0;^M
558. +}^M
559. diff --git a/boot/common/cmd_mtdparts.c b/boot/common/cmd_mtdparts.c
560. index f6940a6f2..172750152 100755
561. --- a/boot/common/cmd_mtdparts.c
562. +++ b/boot/common/cmd_mtdparts.c
563. @@ -1331,6 +1331,63 @@ int lonbon_get_partitions(const char *part_name, uint *part_offset, uint *part_s
564.      }
565.      return -1;
566. }
567. +
568. +int lonbon_strcpy_name(char *part_name,char *name)
569. +{
570. +       char str[10];
571. +       int len,i;
572. +               strcpy(str,name);
573. +               len = strlen(str);
574. +               for(i=0; i < len; i++){
575. +                       *(part_name+i) = str[i];
576. +               }
577. +       return 0;
578. +}
579. +/**
580. +* obtain the partition name of the address by passing it through.
581. +*/
582. +
583. +int lonbon_get_partitions_name(uint *off, char *part_name, uint *part_offset, uint *part_size)
584. +{
585. +       struct list_head *dentry, *pentry;
586. +       struct part_info *part;
587. +       struct mtd_device *dev;
588. +       int part_num;
589. +       uint *part_offset_closure;
590. +
591. +       if (!part_name) {
592. +               printf("the part name is empty\n");
593. +               //return -1;
594. +       }
595. +
596. +       if (list_empty(&devices)) {
597. +               printf("the partitions list is empty\n");
598. +               return -1;
599. +       }
600. +
601. +       if (mtdparts_init() != 0)
602. +               return -1;
603. +
604. +       list_for_each(dentry, &devices) {
605. +               dev = list_entry(dentry, struct mtd_device, link);
606. +               part_num = 0;
607. +               list_for_each(pentry, &dev->parts) {
608. +                       part = list_entry(pentry, struct part_info, link);
609. +                       //printf("%2d:%s 0x%08llx 0x%08llx\n",part_num, part->name, part->size,part->offset);
610. +                       part_offset_closure = part->offset + part->size;
611. +                       if(part_offset_closure > off){
612. +
613. +                                       lonbon_strcpy_name(part_name,part->name);
614. +                                       *part_offset = part->offset;
615. +                                       *part_size   = part->size;
616. +                                       return 0;
617. +                               }
618. +                               part_num++;
619. +               }
620. +       }
621. +       return -1;
622. +}
623. +
624. #endif
625. /**
626.   * Format and print out a partition list for each device from global device
627. diff --git a/boot/common/cmd_nand.c b/boot/common/cmd_nand.c
628. index 64b0bd26b..022696de3 100755
629. --- a/boot/common/cmd_nand.c
630. +++ b/boot/common/cmd_nand.c
631. @@ -718,10 +718,14 @@ static int do_nand(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
632.         nand = &nand_info[dev];
634.         if (strcmp(cmd, "bad") == 0) {
635. -               printf("\nDevice %d bad blocks:\n", dev);
636. +               int j = 0;
637. +               //printf("\nDevice %d bad blocks:\n", dev);
638.                 for (off = 0; off < nand->size; off += nand->erasesize)
639. -                       if (nand_block_isbad(nand, off))
640. +                       if (nand_block_isbad(nand, off)){
641.                                 printf("  %08llx\n", (unsigned long long)off);
642. +                               j++;
643. +                       }
644. +               printf("bad number %d blocks:\n", j);
645.                 return 0;
646.         }
648. @@ -1466,6 +1470,31 @@ static int lb_nand_erase(uint start_addr, uint part_size, uint length)
650.      return 0;
651. }
652. +#define BADBLOCK_MAX 200
653. +int lb_nand_get_badblock_number(ulong *badblock_list)
654. +{
655. +       int j = 0;
656. +       ulong off,badblock_addr[BADBLOCK_MAX];
657. +       nand_info_t *nand = &nand_info[0];
658. +       char commandline[16];
659. +       char badb_addr[1024];
660. +       memset(badblock_addr,0,sizeof(badblock_addr));
661. +       memset(commandline,0,sizeof(commandline));
662. +       memset(badb_addr,0,sizeof(badb_addr));
663. +       printf("\n");
664. +       for (off = 0; off < nand->size; off += nand->erasesize)
665. +               if (nand_block_isbad(nand, off)){
666. +                       //printf("lonbon bad blocks  %08llx\n", (unsigned long long)off);
667. +                       badblock_addr[j] = off;
668. +                       j++;
669. +               }
670. +       printf("\n");
671. +       for(int i = 0; i < j; i++){
672. +       //printf("\nlonbon %08lx\n", badblock_addr[i]);
673. +       badblock_list[i] = badblock_addr[i];
674. +       }
675. +       return j;
676. +}
678. int lb_nand_flash_partition_baseAddr(const char *part_name, uint *part_offset, uint *part_size)
679. {
680. @@ -1492,7 +1521,7 @@ int lb_nand_flash_partition_read(const char *part_name,char* buff,const int leng
681.          return -1;
682.         }
684. -    ret=lb_nand_read(lbflash_offset,lbflash_size, length>lbflash_size?lbflash_size:len,(void *) buff);
685. +    ret = lb_nand_read(lbflash_offset,lbflash_size, length>lbflash_size?lbflash_size:len,(void *) buff);
686.      //_print_hex_string(buff,length); //TEST ONLY
687.      return ret;
688. }
689. diff --git a/boot/include/configs/infinity2m.h b/boot/include/configs/infinity2m.h
690. index c5d5d8ea1..19a44747b 100755
691. --- a/boot/include/configs/infinity2m.h
692. +++ b/boot/include/configs/infinity2m.h
693. @@ -39,6 +39,7 @@
694. #define LONBONVOIP
695. #ifdef LONBONVOIP
696. #define CONFIG_CMD_LBCHK
697. +#define CONFIG_CMD_LBBAD
698. #define CONFIG_LB_MD5
699. #define CONFIG_IDENT_STRING     " LonBon Technology "
700. #define LONBONVOIP_REALM       "voip.lonbon.com"

复制代码

========================================================================
第一次开机

 第二次开机

第N次开机后产生新坏块

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。