ssd202d-badblock-坏块检测

这边文章讲述的是坏快检测功能

思路:

1.第一次烧录固件会实现跳坏块,但是后续使用会导致坏块的产生;

于是我在uboot环境变量添加了两个变量来控制坏快

lb_badnum = //坏块个数

lb_badoff = //坏块所在位置

2.第一次开机会根据lb_badnum是否存在判断,如果不存在则保存上面坏块信息,跳过坏块功能

3.第二次开机之后会获取环境变量lb_badnum和lb_badoff;

3.1.然后检测实际坏块数,进行对比,如果有新增坏块, 则判断新坏块产生的所在分区;

3.2.然后判断所在分区坏块大小加上固件大小后是否超出划分的分区空间;

3.3.执行对应的分区还原;

commit 0ae66e0a3d1366aa90b4661b86203345f4ae02bd (HEAD -> master)
Author: longmin <1938049502@qq.com>
Date:   Tue Dec 10 16:44:44 2024 +0800add cmd_lbbad.c support bad block detection functiondiff --git a/boot/common/Kconfig b/boot/common/Kconfig
index 516a279af..11cb2c30a 100755
--- a/boot/common/Kconfig
+++ b/boot/common/Kconfig
@@ -365,4 +365,10 @@ config XZconfig MZbool "MZ"config SILENT_CONSOLE
-       bool "SILENT_CONSOLE"
\ No newline at end of file
+       bool "SILENT_CONSOLE"
+
+config CMD_LBBAD
+       bool "LBBAD"
+       help
+         This enables the command CONFIG_CMD_LBBAD power on detection of bad
+         blocks.
\ No newline at end of file
diff --git a/boot/common/Makefile b/boot/common/Makefile
index 85ba0bffd..0d54285f5 100755
--- a/boot/common/Makefile
+++ b/boot/common/Makefile
@@ -344,4 +344,5 @@ endifobj-$(CONFIG_CMD_LBCHK) += cmd_lbchk.oobj-$(CONFIG_CMD_LBFDT) += cmd_lbfdt.o
+obj-$(CONFIG_CMD_LBBAD) += cmd_lbbad.oobj-y += cmd_sar.o
diff --git a/boot/common/autoboot.c b/boot/common/autoboot.c
index 60f7b2291..927dcd18a 100755
--- a/boot/common/autoboot.c
+++ b/boot/common/autoboot.c
@@ -585,6 +585,10 @@ void autoboot_command(const char *s)boot:debug("### main_loop: bootcmd=\"%s\"\n", s ? s : "<UNDEFINED>");
+#if defined (CONFIG_CMD_LBBAD)
+      extern int run_lbbadblock(void);
+      run_lbbadblock();    /* bad block inspection */
+#endif#if defined (CONFIG_CMD_LBCHK) && defined (LONBON_CHECK_RUNCMD)extern int run_lbcheck(int cmd);run_lbcheck(LONBON_CHECK_RUNCMD);
diff --git a/boot/common/cmd_lbbad.c b/boot/common/cmd_lbbad.c
new file mode 100755
index 000000000..5bfa4890c
--- /dev/null
+++ b/boot/common/cmd_lbbad.c
@@ -0,0 +1,503 @@
+#include <common.h>^M
+#include <command.h>^M
+#include <malloc.h>^M
+#include <nand.h>^M
+#include <u-boot/md5.h>^M
+#include <asm/io.h>^M
+#include <spi.h>^M
+#include <spi_flash.h>^M
+#if (1 == CONFIG_LONBON_LED) || (1 == LONBON_CMD_CHECK_2BTN_FOR_RESTORE)^M
+#include "../drivers/mstar/gpio/infinity2m/gpio.h"^M
+#include "../drivers/mstar/gpio/drvGPIO.h"^M
+#endif^M
+^M
+//#define LB_DEBUG^M
+^M
+#ifdef LB_DEBUG^M
+#define LBCHK_DEBUG(msg...)            printf(msg)^M
+#else^M
+#define LBCHK_DEBUG(msg...)            do{}while(0)^M
+#endif^M
+^M
+typedef int BOOL;^M
+^M
+#ifndef FALSE^M
+#define FALSE  0^M
+#endif^M
+^M
+#ifndef TRUE^M
+#define TRUE   1^M
+#endif^M
+^M
+#ifdef CONFIG_YAFFS2^M
+extern void cmd_yaffs_devconfig(char *mp, int flash_dev, int start_block, int end_block);^M
+extern void cmd_yaffs_mount(char *mp);^M
+extern void cmd_yaffs_umount(char *mp);^M
+extern void cmd_yaffs_mread_file(char *fn, char *addr);^M
+#endif^M
+^M
+#define BADBLOCK_MAX 200^M
+^M
+extern int lb_nand_get_badblock_number(ulong *badblock_list);^M
+extern int lbcmd_get_imagename_by_cmd(char* imgname, unsigned char cmd);^M
+extern int lonbon_get_partitions(const char *part_name, uint *part_offset, uint *part_size);^M
+extern int lonbon_get_partitions_name(uint *off, char *part_name, uint *part_offset, uint *part_size);^M
+extern int lb_nand_flash_partition_baseAddr(const char *part_name, uint *part_offset, uint *part_size);^M
+^M
+typedef struct {^M
+       int uboot;^M
+       int kernel;^M
+       int rootfs;^M
+       int backup;^M
+       int ro;^M
+       int rw;^M
+       int ipl;^M
+       int ipl_cust;^M
+       int logo;^M
+       int factory;^M
+       int lbcmd;^M
+       int lbflash;^M
+       int lbcfg;^M
+       int env;^M
+       int key_cust;^M
+} lb_bad_partition_t;^M
+^M
+int lonbon_set_badnum(int number)^M
+{^M
+       unsigned char  badnum[2];^M
+    if(number >= 0) {^M
+               memset(badnum,0,2);^M
+               badnum[0] = number + 0x30;^M
+               setenv("lb_badnum", (const char *)badnum);^M
+               run_command("saveenv", 0);^M
+               return 0;^M
+    }^M
+       return -1;^M
+}^M
+^M
+int lonbon_get_badnum(void)^M
+{^M
+       char * lb_badnum = getenv("lb_badnum");^M
+       unsigned char  badnum[2];^M
+^M
+    if(lb_badnum) {^M
+               badnum[0] = *lb_badnum - 0x30;^M
+               printf("old bad_block number= %d\n",badnum[0]);^M
+               return badnum[0];^M
+    }else{^M
+               printf("%s lb_badnum=null\n", __func__);^M
+               return -1;^M
+       }^M
+       return 0;^M
+}^M
+^M
+int lonbon_number_exist(int all_number, ulong *badblock_list, ulong number){^M
+       int i;^M
+       for(i=0; i < all_number; i++)^M
+       {^M
+               if(*(badblock_list+i) == number)^M
+               {^M
+                       return i;^M
+               }^M
+       }^M
+       return -1;^M
+}^M
+^M
+int lonbon_new_badblock(int all_number, ulong *badblock_list, int env_number, ulong *old_badblock_list,ulong *add_badblock_list)^M
+{^M
+       int i, j, k = 0;^M
+       bool flag;^M
+       for (i=0; i < all_number; i++){^M
+               flag = false;^M
+               for (j=0; j < all_number; j++){^M
+               if( badblock_list[i] == old_badblock_list[j] )^M
+               flag = true;^M
+               }^M
+^M
+               if(flag == false){^M
+               *(add_badblock_list + k) = badblock_list[i];^M
+               k++;^M
+               }^M
+^M
+       }^M
+^M
+       return 0;^M
+}^M
+^M
+^M
+int lonbon_get_bad_offset(int all_number, ulong *badblock_list, int number)^M
+{^M
+       int i;^M
+       char *lb_badoff = getenv("lb_badoff");^M
+       char badb_offset[1024]= {0};^M
+       ulong old_badb_list[all_number];^M
+       ulong *old_badblock_list = &old_badb_list[0];^M
+       ulong add_badb_list[all_number];^M
+       ulong *add_badblock_list = &add_badb_list[0];^M
+       char *lb_bad_off;^M
+       ulong num;^M
+^M
+       if(all_number == 0){^M
+       printf("%s not badblock_list\n", __func__);^M
+       return 0;^M
+       }^M
+^M
+       if(lb_badoff){^M
+               strcpy(badb_offset,lb_badoff);^M
+               lb_bad_off = strtok(badb_offset, "-");^M
+               num = simple_strtol(lb_bad_off, NULL, 16);^M
+               old_badb_list[0] = num;^M
+               for(i=1; i < all_number;i++ ){^M
+               lb_bad_off = strtok(NULL ,"-");^M
+               num = simple_strtol(lb_bad_off, NULL, 16);^M
+               old_badb_list[i] = num;^M
+               }^M
+       }^M
+       /* determine the partition location of the new bad block */^M
+       lonbon_new_badblock(all_number, badblock_list, number, old_badblock_list, add_badblock_list);^M
+       for(i=0; i < all_number; i++){^M
+       *(badblock_list + i) = 0;^M
+       }^M
+       for(i=0; i<number;i++){^M
+       *(badblock_list + i) = add_badb_list[i];^M
+       }^M
+^M
+       return 1;^M
+}^M
+^M
+int lonbon_set_bad_offset(int number, ulong *badblock_list)^M
+{^M
+       int i;^M
+       char commandline[10] = {0};^M
+       char badb_addr[1024]= {'0'};^M
+       if(number >= 0) {^M
+               if(number > 0) {^M
+                       for(i=0;i<number;i++){^M
+                       sprintf(commandline,"%08lx-", *(badblock_list+i));^M
+                       strcat(badb_addr,commandline);^M
+                       }^M
+               }^M
+               printf("lonbon_set_bad_offset badblock_list:%s\n",badb_addr);^M
+               setenv("lb_badoff", (const char *)badb_addr);^M
+               run_command("saveenv", 0);^M
+               return number;^M
+       }^M
+       return 0;^M
+}^M
+^M
+int lonbon_set_partitions(lb_bad_partition_t *lb_part, char *part_name)^M
+{^M
+       //printf("%s %s \n",__func__,part_name);^M
+       if(strcmp(part_name, "UBOOT0") == 0||strcmp(part_name, "UBOOT1") == 0){^M
+       lb_part->uboot += 1;^M
+       }else if(strcmp(part_name, "rootfs") == 0){^M
+       lb_part->rootfs  += 1;^M
+       }else if(strcmp(part_name, "KERNEL") == 0||strcmp(part_name, "RECOVERY") == 0){^M
+       lb_part->kernel  += 1;^M
+       }else if(strcmp(part_name, "backup") == 0){^M
+       lb_part->backup  += 1;^M
+       }else if(strcmp(part_name, "ro") == 0){^M
+       lb_part->ro  += 1;^M
+       }else if(strcmp(part_name, "rw") == 0){^M
+       lb_part->rw  += 1;^M
+       }else if(strcmp(part_name, "IPL0") == 0||strcmp(part_name, "IPL1") == 0){^M
+       lb_part->ipl  += 1;^M
+       }else if(strcmp(part_name, "IPL_CUST0") == 0||strcmp(part_name, "IPL_CUST1") == 0){^M
+       lb_part->ipl_cust  += 1;^M
+       }else if(strcmp(part_name, "LOGO") == 0){^M
+       lb_part->logo  += 1;^M
+       }else if(strcmp(part_name, "factory") == 0){^M
+       lb_part->factory  += 1;^M
+       }else if(strcmp(part_name, "lbcmd") == 0){^M
+       lb_part->lbcmd  += 1;;^M
+       }else if(strcmp(part_name, "lbflash") == 0||strcmp(part_name, "lbflash2") == 0){^M
+       lb_part->lbflash  += 1;^M
+       }else if(strcmp(part_name, "lbcfg") == 0||strcmp(part_name, "lbcfg2") == 0){^M
+       lb_part->lbcfg  += 1;^M
+       }else if(strcmp(part_name, "ENV") == 0||strcmp(part_name, "ENV1") == 0){^M
+       lb_part->env  += 1;^M
+       }else if(strcmp(part_name, "KEY_CUST") == 0){^M
+       lb_part->key_cust  += 1;^M
+       }else{^M
+       return -1;^M
+       }^M
+^M
+       return 0;^M
+}^M
+^M
+void lonbon_printf_bad(int num){^M
+^M
+       switch (num)^M
+       {^M
+               case 0: printf("\n");^M
+                               printf("##############################################################################\n");^M
+                               printf("##############################################################################\n");^M
+                               printf("############################ bad block list:##################################\n");^M
+                               break;^M
+               case 1: printf("\nstart all bad block list:\n");^M
+                               break;^M
+               case 2: printf("\n");^M
+                               printf("add bad block:\n");^M
+                               printf("\n");^M
+                               break;^M
+               case 3: printf("\n");^M
+                               printf("##############################################################################\n");^M
+                               printf("##############################################################################\n");^M
+                               printf("\n");^M
+                               break;^M
+       }^M
+^M
+}^M
+^M
+uint lonbon_get_pattition_firmware_size(char *fileName){^M
+               char *mntpoint = "/factory";^M
+               uint part_offset;^M
+               uint part_size;^M
+               int start_block;^M
+               int end_block;^M
+^M
+               char filename[100] = {0};^M
+               unsigned long addr= 0x21000000;^M
+               lb_nand_flash_partition_baseAddr("factory", &part_offset, &part_size);^M
+               if(!part_offset || !part_size) {^M
+                       printf("#ERROR: No factory partition is found\n");^M
+                       return -1;^M
+               }^M
+^M
+               start_block = part_offset/(128*1024); /* Nand flash block size is 128 KB */^M
+               end_block = (part_offset+part_size)/(128*1024)-1;^M
+^M
+               cmd_yaffs_devconfig(mntpoint,0,start_block,end_block);^M
+               cmd_yaffs_mount(mntpoint);^M
+               sprintf(filename, "%s/%s", mntpoint, fileName);^M
+               cmd_yaffs_mread_file(filename, (char *)addr);^M
+               char *str_env = getenv("filesize");^M
+               ulong filesize = simple_strtoul(str_env, NULL, 16);^M
+               size_t blocksize = nand_info[0].erasesize;^M
+               ulong wsize=(filesize/blocksize+1)*blocksize;^M
+               cmd_yaffs_umount(mntpoint);^M
+               printf("longbon  filename=%s  str_env=%s filesize=%lx wsize=%lx \n",filename,str_env,filesize,wsize);^M
+       return wsize;^M
+^M
+}^M
+^M
+int lonbon_pattition_firmware_size(unsigned char cmd, char *part_name, int bad_number)^M
+{^M
+       char firmware_name[32] = {0};^M
+       char *firmware_part_name = &firmware_name[0];^M
+       uint part_offset, part_size;^M
+       ulong firmware_size, firmware_size_bad;^M
+       size_t blocksize = nand_info[0].erasesize;^M
+^M
+       /* get firmware name */^M
+       lbcmd_get_imagename_by_cmd(firmware_part_name, cmd);^M
+       /* get firmware size */^M
+       firmware_size = lonbon_get_pattition_firmware_size(firmware_part_name);^M
+       /* the size after adding the bad block */^M
+       firmware_size_bad = firmware_size +( blocksize * bad_number);^M
+       /* get partitions total size */^M
+       lonbon_get_partitions(part_name, &part_offset, &part_size);^M
+^M
+       /* partitions total size > firmware size add bad block size */^M
+       if( part_size > firmware_size_bad)^M
+       {^M
+       printf("\nlonbon %s is OK! part_size=%x firmware_size_bad=%lx \n",__func__,part_size,firmware_size_bad);^M
+       return 1;^M
+       }^M
+       else {^M
+       printf("\nlonbon %s error!! part_size=%x firmware_size_bad=%lx \n",__func__,part_size,firmware_size_bad);^M
+       return -1;^M
+       }^M
+       return 0;^M
+}^M
+^M
+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
+^M
+       int i, ret, flags = 0;^M
+       char write[20] = {' '};^M
+       char *write_t = &write[0];^M
+       char part_name[10] = {'0'};^M
+       char *part_name_t = &part_name[0];^M
+       ulong *badblock_list = bad_list;^M
+       char commandline[30] = {0};^M
+       uint lbflash_offset = 0,lbflash_size = 0;^M
+^M
+       if(new_number > 0){^M
+       lonbon_printf_bad(1);^M
+       }^M
+       for(i=0; i< number; i++){^M
+               memset(part_name,0,sizeof(part_name));^M
+               lonbon_get_partitions_name((uint *) *(badblock_list+i), part_name_t, &lbflash_offset, &lbflash_size);^M
+               printf("bad[%d]=0x%08lx name=%s off=0x%08x size=0x%08x end=0x%08x \n",^M
+                       i, *(badblock_list+i), part_name_t, lbflash_offset, lbflash_size ,(lbflash_offset +lbflash_size -1) );^M
+       }^M
+       if(new_number > 0){^M
+       lonbon_printf_bad(2);^M
+               for(i=0; i< new_number; i++){^M
+               printf(" 0x%08lx \n", *(new_bad_list + i));^M
+               }^M
+       }^M
+       if(lb_bad_partition->factory > 0){^M
+       printf("\n warn factory partition are bad blocks !!!\n\n");^M
+       }^M
+       if(lb_bad_partition->uboot > 0){^M
+       printf("\n warn uboot partition are bad blocks !!!\n\n");^M
+       ret = lonbon_pattition_firmware_size(1,"uboot",lb_bad_partition->uboot);^M
+               if(ret > 0){^M
+               strcat(write,"1 ");^M
+               flags++;^M
+               }else{^M
+               printf("\n%s error!!!uboot insufficient partition space !!!\n",__func__ );^M
+               }^M
+       }^M
+       if(lb_bad_partition->kernel > 0){^M
+       printf("\n warn kernel partition are bad blocks !!!\n\n");^M
+       ret = lonbon_pattition_firmware_size(2,"kernel",lb_bad_partition->kernel);^M
+               if(ret > 0){^M
+               strcat(write,"2 ");^M
+               flags++;^M
+               }else{^M
+               printf("\n%s error!!!kernel insufficient partition space !!!\n",__func__ );^M
+               }^M
+       }^M
+       if(lb_bad_partition->rootfs > 0){^M
+       printf("\n warn rootfs partition are bad blocks !!!\n\n");^M
+       ret = lonbon_pattition_firmware_size(3,"rootfs",lb_bad_partition->rootfs);^M
+               if(ret > 0){^M
+               strcat(write,"3 ");^M
+               flags++;^M
+               }else{^M
+               printf("\n%s error!!!rootfs insufficient partition space !!!\n",__func__ );^M
+               }^M
+       }^M
+       if(lb_bad_partition->backup > 0){^M
+       printf("\n warn backup partition are bad blocks !!!\n\n");^M
+       }^M
+       if(lb_bad_partition->ro > 0){^M
+       printf("\n warn ro partition are bad blocks !!!\n\n");^M
+       }^M
+       if(lb_bad_partition->rw > 0){^M
+       printf("\n warn rw partition are bad blocks !!!\n\n");^M
+       }^M
+       if(lb_bad_partition->ipl > 0){^M
+       printf("\n warn ipl partition are bad blocks !!!\n\n");^M
+       ret = lonbon_pattition_firmware_size(6,"ipl",lb_bad_partition->ipl);^M
+               if(ret > 0){^M
+               strcat(write,"6 ");^M
+               flags++;^M
+               }else{^M
+               printf("\n%s error!!!ipl insufficient partition space !!!\n",__func__ );^M
+               }^M
+       }^M
+       if(lb_bad_partition->ipl_cust > 0){^M
+       printf("\n warn ipl_cust partition are bad blocks !!!\n\n");^M
+       ret = lonbon_pattition_firmware_size(7,"ipl",lb_bad_partition->ipl_cust);^M
+               if(ret > 0){^M
+               strcat(write,"7 ");^M
+               flags++;^M
+               }else{^M
+               printf("\n%s error!!!ipl_cust insufficient partition space !!!\n",__func__ );^M
+               }^M
+       }^M
+       if(lb_bad_partition->logo > 0){^M
+       printf("\n warn logo partition are bad blocks !!!\n\n");^M
+       ret = lonbon_pattition_firmware_size(8,"logo",lb_bad_partition->logo);^M
+               if(ret > 0){^M
+               //run_command("lbupgrade write 8", 0);^M
+               strcat(write,"8 ");^M
+               flags++;^M
+               }else{^M
+               printf("\n%s error!!!logo insufficient partition space !!!\n",__func__ );^M
+               }^M
+       }^M
+^M
+       if (flags > 0){^M
+       sprintf(commandline,"lbupgrade write %s", write_t);^M
+       printf("\nlonbon %s run_command: %s !!!\n", __func__ , commandline);^M
+       run_command(commandline, 0);^M
+       }^M
+^M
+       lonbon_printf_bad(3);^M
+^M
+}^M
+^M
+/* bad block inspection */^M
+int run_lbbadblock(void) ^M
+{^M
+       lb_bad_partition_t lb_bad_partition ={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};^M
+       lb_bad_partition_t *lb_bad_partition_r = &lb_bad_partition;^M
+       int ret, i;^M
+       char part_name[10] = {'0'};^M
+       char *part_name_t = &part_name[0];^M
+       uint lbflash_offset = 0,lbflash_size = 0;^M
+       ulong badblock_list[BADBLOCK_MAX];^M
+       ulong *list_badblock = &badblock_list[0];^M
+       int badblock_number , lb_badnum;^M
+       bool new_badblock = false;^M
+^M
+       lonbon_printf_bad(0);^M
+       memset(badblock_list,0,sizeof(badblock_list));^M
+       badblock_number = lb_nand_get_badblock_number(list_badblock);^M
+       ulong bad_list[badblock_number];^M
+       ulong *bad_list_t = &bad_list[0];^M
+^M
+       for( i = 0; i < badblock_number; i++){^M
+       bad_list[i] = badblock_list[i];^M
+       }^M
+^M
+       if(badblock_number < 0){^M
+               printf("error! get badblock number failed! :%d\n",badblock_number);^M
+               return badblock_number;^M
+       }else{^M
+               printf("bad badblock  number: %d\n",badblock_number);^M
+       }^M
+^M
+       lb_badnum = lonbon_get_badnum();/* get lb_badnum */^M
+       if(lb_badnum < 0){ /* the first burning is not processed */^M
+^M
+               ret = lonbon_set_badnum(badblock_number);/* directly save the number of burned blocks */^M
+               if(ret < 0){^M
+               printf("error %s badblock_number=null\n",__func__);^M
+               }^M
+               printf("lonbon %s init badblock\n",__func__);^M
+               ret = lonbon_set_bad_offset(badblock_number, list_badblock);/* save bad block address*/^M
+               lonbon_printf_bad(3);^M
+               return 0;^M
+^M
+       }else{   /* after the second boot, go here */^M
+               if(badblock_number == lb_badnum){ /* equal means there are no bad blocks */^M
+                       printf("lonbon %s not new badblock\n",__func__);^M
+^M
+               }else{                            /* unequal means there are bad blocks */^M
+                       printf("%s new badblock number= %d\n",__func__, badblock_number - lb_badnum);^M
+                       ret = lonbon_set_badnum(badblock_number);^M
+                       if(ret < 0){^M
+                       printf("error %s badblock_number=null\n",__func__);^M
+                       }else{^M
+                       new_badblock = true; /* mark the newly added bad block symbol */^M
+                       }^M
+               }^M
+       }^M
+^M
+       if(new_badblock == true ){/* there are new bad blocks added */^M
+               /* Get env bad block address */^M
+               ret = lonbon_get_bad_offset(badblock_number, list_badblock ,badblock_number - lb_badnum);^M
+^M
+               for(i=0; i< badblock_number - lb_badnum; i++){^M
+                       memset(part_name,0,sizeof(part_name));^M
+                       lonbon_get_partitions_name((uint *) badblock_list[i], part_name_t, &lbflash_offset, &lbflash_size);^M
+                       ret = lonbon_set_partitions(lb_bad_partition_r, part_name_t);^M
+               }^M
+               printf("%s new_badblock=true\n",__func__);^M
+^M
+       }^M
+^M
+       lonbon_printf_bad_block(lb_bad_partition_r, badblock_number, bad_list_t, badblock_number - lb_badnum, list_badblock);^M
+^M
+       if(new_badblock == true){/* if a new bad block is added, restart and enter restore mode */^M
+               ret = lonbon_set_bad_offset(badblock_number, bad_list_t);/* save bad block address */^M
+               new_badblock = false;^M
+               run_command("reset", 0);^M
+       }^M
+       return 0;^M
+}^M
diff --git a/boot/common/cmd_mtdparts.c b/boot/common/cmd_mtdparts.c
index f6940a6f2..172750152 100755
--- a/boot/common/cmd_mtdparts.c
+++ b/boot/common/cmd_mtdparts.c
@@ -1331,6 +1331,63 @@ int lonbon_get_partitions(const char *part_name, uint *part_offset, uint *part_s}return -1;}
+
+int lonbon_strcpy_name(char *part_name,char *name)
+{
+       char str[10];
+       int len,i;
+               strcpy(str,name);
+               len = strlen(str);
+               for(i=0; i < len; i++){
+                       *(part_name+i) = str[i];
+               }
+       return 0;
+}
+/**
+* obtain the partition name of the address by passing it through.
+*/
+
+int lonbon_get_partitions_name(uint *off, char *part_name, uint *part_offset, uint *part_size)
+{
+       struct list_head *dentry, *pentry;
+       struct part_info *part;
+       struct mtd_device *dev;
+       int part_num;
+       uint *part_offset_closure;
+
+       if (!part_name) {
+               printf("the part name is empty\n");
+               //return -1;
+       }
+
+       if (list_empty(&devices)) {
+               printf("the partitions list is empty\n");
+               return -1;
+       }
+
+       if (mtdparts_init() != 0)
+               return -1;
+
+       list_for_each(dentry, &devices) {
+               dev = list_entry(dentry, struct mtd_device, link);
+               part_num = 0;
+               list_for_each(pentry, &dev->parts) {
+                       part = list_entry(pentry, struct part_info, link);
+                       //printf("%2d:%s 0x%08llx 0x%08llx\n",part_num, part->name, part->size,part->offset);
+                       part_offset_closure = part->offset + part->size;
+                       if(part_offset_closure > off){
+
+                                       lonbon_strcpy_name(part_name,part->name);
+                                       *part_offset = part->offset;
+                                       *part_size   = part->size;
+                                       return 0;
+                               }
+                               part_num++;
+               }
+       }
+       return -1;
+}
+#endif/*** Format and print out a partition list for each device from global device
diff --git a/boot/common/cmd_nand.c b/boot/common/cmd_nand.c
index 64b0bd26b..022696de3 100755
--- a/boot/common/cmd_nand.c
+++ b/boot/common/cmd_nand.c
@@ -718,10 +718,14 @@ static int do_nand(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])nand = &nand_info[dev];if (strcmp(cmd, "bad") == 0) {
-               printf("\nDevice %d bad blocks:\n", dev);
+               int j = 0;
+               //printf("\nDevice %d bad blocks:\n", dev);for (off = 0; off < nand->size; off += nand->erasesize)
-                       if (nand_block_isbad(nand, off))
+                       if (nand_block_isbad(nand, off)){printf("  %08llx\n", (unsigned long long)off);
+                               j++;
+                       }
+               printf("bad number %d blocks:\n", j);return 0;}@@ -1466,6 +1470,31 @@ static int lb_nand_erase(uint start_addr, uint part_size, uint length)return 0;}
+#define BADBLOCK_MAX 200
+int lb_nand_get_badblock_number(ulong *badblock_list)
+{
+       int j = 0;
+       ulong off,badblock_addr[BADBLOCK_MAX];
+       nand_info_t *nand = &nand_info[0];
+       char commandline[16];
+       char badb_addr[1024];
+       memset(badblock_addr,0,sizeof(badblock_addr));
+       memset(commandline,0,sizeof(commandline));
+       memset(badb_addr,0,sizeof(badb_addr));
+       printf("\n");
+       for (off = 0; off < nand->size; off += nand->erasesize)
+               if (nand_block_isbad(nand, off)){
+                       //printf("lonbon bad blocks  %08llx\n", (unsigned long long)off);
+                       badblock_addr[j] = off;
+                       j++;
+               }
+       printf("\n");
+       for(int i = 0; i < j; i++){
+       //printf("\nlonbon %08lx\n", badblock_addr[i]);
+       badblock_list[i] = badblock_addr[i];
+       }
+       return j;
+}int lb_nand_flash_partition_baseAddr(const char *part_name, uint *part_offset, uint *part_size){
@@ -1492,7 +1521,7 @@ int lb_nand_flash_partition_read(const char *part_name,char* buff,const int lengreturn -1;}-    ret=lb_nand_read(lbflash_offset,lbflash_size, length>lbflash_size?lbflash_size:len,(void *) buff);
+    ret = lb_nand_read(lbflash_offset,lbflash_size, length>lbflash_size?lbflash_size:len,(void *) buff);//_print_hex_string(buff,length); //TEST ONLYreturn ret;}
diff --git a/boot/include/configs/infinity2m.h b/boot/include/configs/infinity2m.h
index c5d5d8ea1..19a44747b 100755
--- a/boot/include/configs/infinity2m.h
+++ b/boot/include/configs/infinity2m.h
@@ -39,6 +39,7 @@#define LONBONVOIP#ifdef LONBONVOIP#define CONFIG_CMD_LBCHK
+#define CONFIG_CMD_LBBAD#define CONFIG_LB_MD5#define CONFIG_IDENT_STRING     " LonBon Technology "#define LONBONVOIP_REALM       "voip.lonbon.com"

========================================================================

第一次开机

 第二次开机

第N次开机后产生新坏块

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/889383.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

Tornado 异步编程全解析

一、Tornado 异步基础 核心概念 IOLoop&#xff1a; 是 Tornado 的核心事件循环&#xff0c;负责处理网络 I/O、定时器等事件。它不断地循环监听事件&#xff0c;一旦有事件就绪就调用相应的回调函数。可以在一个进程中创建多个 IOLoop&#xff0c;但通常一个应用使用一个主 IO…

Windows桌面系统管理2:VMware Workstation使用和管理

Windows桌面系统管理0:总目录-CSDN博客 Windows桌面系统管理1:计算机硬件组成及组装-CSDN博客 Windows桌面系统管理2:VMware Workstation使用和管理 Windows桌面系统管理3:Windows 10操作系统部署与使用-CSDN博客 Windows桌面系统管理4:Windows 10操作系统运维管理-…

鸿蒙ArkTS如何实现数据可视化:饼状图/柱状图/折线图

鸿蒙数据可视化系列 在我们鸿蒙APP开发中&#xff0c;经常需要使用到一些图表的开发&#xff0c;本文主要介绍使用 McCharts 框架绘制柱状图的方法 配套指导视频地址&#xff1a;鸿蒙数据可视化系列-McCharts使用介绍_哔哩哔哩_bilibili 1. 第三方库介绍 1.1. McCharts Mc…

基于go语言的开源调度系统整理

pink https://github.com/busgo/pink 通过Web界面管理操作简单方便&#xff0c;支持各种任务 高可用可以部署 n 台调度集群节点&#xff0c;保证没有单点故障。 部署简单、仅仅需要一个执行文件即可运行。 集成方便&#xff0c;统一语言无关的任务抽象&#xff0c;接入不同语言…

多个终端查看的history不一样,如何确保多个终端会话之间的 history 一致,减少历史记录差异

问题&#xff1a; 在使用 Linux 系统时&#xff0c;history 命令显示的历史记录通常是与当前终端会话相关的。这就意味着&#xff0c;如果你在多个终端中打开会话&#xff0c;它们显示的历史记录可能不完全相同。这个问题通常是由以下原因引起的&#xff1a; 原因&#xff1a…

yolov8 转华为昇腾om脚本

目录 yolov8 转华为昇腾 om脚本 测试ok 推理demo: yolov8 转华为昇腾 om脚本 测试ok import sys import osos.chdir(os.path.dirname(os.path.abspath(__file__)))import torchcurrent_dir = os.path.dirname(os.path.abspath(__file__))paths = [os.path.abspath(__file__)…

unity打包sdk热更新笔记

Unity3D项目Plugins目录组织 https://blog.csdn.net/linxinfa/article/details/102978005 IPreprocessBuild 继承提供打包前&#xff0c;打包后接口 BuildAssetBundles UnityWebRequest’s DownloadHandlerAssetBundle / LoadFromFile / LoadFromMemoryAsync 数据完整性校…

12.11-12.12总结(约瑟夫问题 机器翻译 滑动窗口)

12.11 刷题 《算法竞赛》这本书看了很多了&#xff0c;但是题目没咋做&#xff0c;所以今天来刷一下题 P1996约瑟夫问题 还依稀记得大一的时候被约瑟夫支配的恐惧&#xff08;哭&#xff09;&#xff0c;但是现在做就感觉很简单&#xff08;虽然也敲了一会&#xff0c;今早感…

git SSL certificate problem: unable to get local issuer certificate

Git 客户端将会验证服务器端提供的SSL证书是否由受信任的证书颁发机构&#xff08;Certification Authority&#xff0c;CA&#xff09;签发。如果Git客户端无法找到或验证本地签发者证书&#xff0c;就会出现 unable to get local issuer certificate 或类似的错误。 该问题一…

使用秘钥登录服务器

在我们测试或生产环境中&#xff0c;为了服务器安全性&#xff0c;有时可能需要以 SSH 密钥的方式登录服务器&#xff0c;接下来&#xff0c;将演示如何通过 SSH 私钥的方式来远程服务器。 一、远程服务器生成密钥对 1、首先在目标远程服务器下生成 SSH 密钥对 ssh-keygen然…

css设置透明的几种办法

在CSS中&#xff0c;有几种方法可以设置元素的透明度。以下是主要的几种方式&#xff1a; 1. 使用 opacity 属性 定义&#xff1a;opacity 属性用于设置元素的整体透明度&#xff0c;包括其内容和背景。取值范围&#xff1a;取值从0&#xff08;完全透明&#xff09;到1&…

4,双向带头循环链表

目录 1&#xff0c;双向带头循环链表的定义 2&#xff0c;双向带头循环链表的实现 A&#xff0c;函数的声明 B&#xff0c;函数的定义 1&#xff0c;双向带头循环链表的定义 带头双向循环链表&#xff1a;结构复杂&#xff0c;一般用在单独存储数据。实际中使用的链表数据…

谷粒商城—分布式基础

1. 整体介绍 1)安装vagrant 2)安装Centos7 $ vagrant init centos/7 A `Vagrantfile` has been placed in this directory. You are now ready to `vagrant up` your first virtual environment! Please read the comments in the Vagrantfile as well as documentation on…

TimesFM(Time Series Foundation Model)安装(2)

TimesFM&#xff08;Time Series Foundation Model&#xff09;安装简介 readme TimesFM&#xff08;Time Series Foundation Model&#xff09;安装简介&#xff08;1&#xff09;-CSDN博客https://blog.csdn.net/chenchihwen/article/details/144359861?spm1001.2014.3001…

Cesium进阶教程——自定义图形、外观、绘图基础、现有着色器移植至Cesium、ShadowMapping、视频GIS、模型压平、卷帘

基础必看 https://blog.csdn.net/m0_55049655/article/details/139720401 参考路线 http://www.xt3d.online/tutorial/further/article.html 自定义图形 https://blog.csdn.net/m0_55049655/article/details/138908327 https://blog.csdn.net/m0_55049655/article/details/14…

国际荐酒师(香港)协会亮相第六届地博会助力中欧地标交流合作

国际荐酒师&#xff08;香港&#xff09;协会亮相第六届知交会暨地博会&#xff0c;助力中欧地理标志产品交流合作 12月9日&#xff0c;第六届粤港澳大湾区知识产权交易博览会暨国际地理标志产品交易博览会&#xff08;以下简称“第六届知交会暨地博会”&#xff09;在中新广州…

Apache Spark 的基本概念和在大数据分析中的应用。

Apache Spark是一个开源大数据处理框架&#xff0c;被广泛应用于大规模数据分析、机器学习和图形处理等领域。它具有以下几个基本概念&#xff1a; RDD&#xff08;Resilient Distributed Dataset&#xff09;&#xff1a;RDD是Spark中最基本的数据抽象概念&#xff0c;代表了一…

spring boot之@Import注解的应用

我们知道spring boot会通过ComponentScan定义包扫描路径进行业务定义的bean的加载&#xff0c;但是对于很多不在此包路径下定义的bean怎么办呢&#xff1f;比如其他jar包中定义的。这时候import就发挥作用了&#xff0c;通过它也可以实现bean的定义。具体是怎么做的呢&#xff…

Horovod:分布式深度学习训练库;Horovod库中DistributedOptimizer

目录 Horovod:分布式深度学习训练库 环境准备 代码示例 运行脚本 Horovod库中DistributedOptimizer DistributedOptimizer的作用 举例说明 Horovod:分布式深度学习训练库 Horovod是一个开源的分布式深度学习训练库,它能够在多个节点(机器)和多个GPU上高效地并行运行…

【Liunx篇】基础开发工具 - vim

文章目录 一.vim的基本概念1.正常/命令模式2.插入模式3.底行模式/末行模式4.视图模式5.替换模式 二.vim的基本操作1.进入vim&#xff1a;2.退出vim: 三.vim正常模式命令集1.光标定位&#xff1a;2.复制/粘贴3.撤销4.剪切/删除5. 更改 四.vim底行模式命令集1.保存/退出2.调出行号…