嵌入式 Linux下SPI NAND Flash可靠读写策略与应用层设计

typedef struct blockHeader{int crc;int headImage;char rsv[24];}blockHeader_T;static char* pWriteBlockBuf = NULL;static char* pReadBlockBuf = NULL;#define PRINT_DEBUG#ifdef PRINT_DEBUG#define  PRINT_LOG_DBG(format,arg...)			\	printf(format,## arg)#else#define  PRINT_LOG_DBG(format,arg...)#endif#define  PRINT_LOG_INFO(format,arg...)			\	printf(format,## arg)unsignedlongsimple_strtoul(constchar *cp, char **endp,unsigned int base){unsigned long result = 0;unsigned long value;if (*cp == '0') {		cp++;if ((*cp == 'x') && isxdigit(cp[1])) {			base = 16;			cp++;		}if (!base)			base = 8;	}if (!base)		base = 10;while (isxdigit(*cp) && (value = isdigit(*cp) ? *cp-'0' : (islower(*cp)	    ? toupper(*cp) : *cp)-'A'+10) < base) {		result = result*base + value;		cp++;	}if (endp)		*endp = (char *)cp;return result;}staticintcompare_buf(char *buf0, char *buf1, int len){int i;/* dump_buf(0,16,buf0); *//* dump_buf(0,16,buf1); */for(i = 0; i < len; i++)	{if(buf0[i] != buf1[i])return 1;	}return 0;}staticintnand_rwblockbuf_init(int block_size){if(pWriteBlockBuf == NULL)	{		pWriteBlockBuf = (char*)malloc(block_size);if(pWriteBlockBuf == NULL)		{printf("nand_rwbuf_init: malloc pWriteBlockBuf failed!\n");return -1;		}	}if(pReadBlockBuf == NULL)	{		pReadBlockBuf = (char*)malloc(block_size);if(pReadBlockBuf == NULL)		{printf("nand_rwbuf_init: malloc pReadBlockBuf failed!\n");return -1;		}	}return 0;}staticintnand_mark_badblock(int fd, loff_t offs){    int ret;	ret = ioctl(fd, MEMSETBADBLOCK, &offs);    if (ret < 0) {        PRINT_LOG_DBG("[%s][%d] Failed to set bad block\n",__func__, __LINE__);    }return ret;}staticintnand_is_badblock(int fd, loff_t offs){int ret;	ret = ioctl(fd, MEMGETBADBLOCK, &offs);    if (ret < 0) {        PRINT_LOG_DBG("[%s][%d] Failed get badblock\n",__func__, __LINE__);    }return ret;}staticintnand_erase_block(int fd, struct erase_info_user erase_info){int ret;	ret = ioctl(fd, MEMERASE, &erase_info);    if (ret < 0) {        PRINT_LOG_DBG("[%s][%d] Failed erase block\n",__func__, __LINE__);    }return ret;}staticintnand_is_invaliddata(char *data, int dataLen){//check nand every block data is validunsigned int pkg_crc_block = 0;int blockCrc = 0;int blockDataLen = 0;if(data == NULL || dataLen <= 0)	{return 1;	}if (*(uint32_t *)(data + CRC_LEN) != HEADIMAGE) {//PRINT_LOG_INFO("Invalid block header, %x %x error headLen:%d\n", *(uint32_t *)(data+CRC_LEN), HEADIMAGE, headLen);return 1;	}	blockCrc = *(unsigned int*)data;	blockDataLen = dataLen - CRC_LEN;crc_32_fun(data + CRC_LEN, blockDataLen, &pkg_crc_block);if(blockCrc != pkg_crc_block)	{PRINT_LOG_INFO("The block data is invalid, blockCrc:%x pkg_crc_block:%x blockDataLen:%d\n", blockCrc, pkg_crc_block, blockDataLen);return 1;	}PRINT_LOG_INFO("The block data is ok, blockCrc:%x pkg_crc_block:%x\n", blockCrc, pkg_crc_block);return 0;}intnand_read(char* nand_device, char *read_buffer, int read_size, int max_available_size, int offset){int fd = -1;int ret = -1;int len = 0;struct mtd_info_user mtd_info;loff_t offs = (loff_t)offset;int dataErr = -1;if(nand_device == NULL || read_buffer == NULL)	{        printf("inf_nand_read:nand_device or read_buffer is NULL\n");        return -1;	}//open nand device    fd = open(nand_device, O_RDWR);    if (fd < 0) {        perror("inf_nand_read: Failed to open NAND device");        return -1;    }    //get nand device info    ret = ioctl(fd, MEMGETINFO, &mtd_info);    if (ret < 0) {        perror("inf_nand_read: Failed to get MTD info");        close(fd);        return ret;    }#if 0PRINT_LOG_DBG("read nand info:\n");PRINT_LOG_DBG("mtd size: 0x%x\n",mtd_info.size);PRINT_LOG_DBG("nand erasesize: 0x%x\n",mtd_info.erasesize);PRINT_LOG_DBG("nand writesize: 0x%x\n",mtd_info.writesize);PRINT_LOG_DBG("nand oobsize: 0x%x\n",mtd_info.oobsize);#endifif(nand_rwblockbuf_init(mtd_info.erasesize) < 0)	{return -1;	}	len = read_size;lseek(fd, offs, SEEK_SET);while(len > 0) {if(offs >=  (loff_t)max_available_size)		{//PRINT_LOG_DBG("inf_nand_read: offs(0x%x) is bigger than offset + max_available_size(0x%x)\n", offs, (loff_t)(offset + max_available_size));close(fd);return dataErr;		}		ret = nand_is_badblock(fd,offs);if(ret) {PRINT_LOG_DBG("inf_nand_read: skiping bad block, addr %llx ret %d\n",offs, ret);			offs += mtd_info.erasesize;lseek(fd, offs, SEEK_SET);continue;		} else			;memset(pReadBlockBuf, 0x0, mtd_info.erasesize);if (read(fd, pReadBlockBuf, mtd_info.erasesize) != mtd_info.erasesize) {perror("inf_nand_read: Failed to read from NAND device");PRINT_LOG_DBG("inf_nand read: block addr %llx read failed, len = 0x%x\n",offs, len);close(fd);return dataErr;		}		ret = nand_is_invaliddata(pReadBlockBuf, mtd_info.erasesize);if(ret)		{//PRINT_LOG_DBG("inf_nand_read: check data is invalid, skiping the block, addr %llx ret %d\n",offs, ret);			offs += mtd_info.erasesize;lseek(fd, offs, SEEK_SET);continue;		} else			;PRINT_LOG_DBG("inf_nand read: block addr %llx read ok, len = 0x%x\n",offs, len);		offs += mtd_info.erasesize;memcpy(read_buffer, pReadBlockBuf + sizeof(blockHeader_T), mtd_info.erasesize - sizeof(blockHeader_T));		read_buffer += mtd_info.erasesize - sizeof(blockHeader_T);		len -= mtd_info.erasesize - sizeof(blockHeader_T);		dataErr = 0;	}close(fd);return dataErr;}intnand_write(char* nand_device, char *write_buffer, int write_size, int max_available_size, int offset){int fd = -1;int ret = -1;unsigned int crcnum = 0;int blockDataLen = 0;int blockHeadLen = sizeof(blockHeader_T);int remainDataSize = 0;struct mtd_info_user mtd_info;struct erase_info_user erase_info;loff_t offs = (loff_t)offset;if(nand_device == NULL || write_buffer == NULL)	{        printf("inf_nand_write: nand_device is NULL\n");        return -1;	}//open nand device    fd = open(nand_device, O_RDWR);    if (fd < 0) {        perror("inf_nand_write: Failed to open NAND device");        return -1;    }    //get nand device info    ret = ioctl(fd, MEMGETINFO, &mtd_info);    if (ret < 0) {        perror("inf_nand_write: Failed to get MTD info");        close(fd);        return ret;    }#if 0PRINT_LOG_DBG("read nand info:\n");PRINT_LOG_DBG("mtd size: 0x%x\n",mtd_info.size);PRINT_LOG_DBG("nand erasesize: 0x%x\n",mtd_info.erasesize);PRINT_LOG_DBG("nand writesize: 0x%x\n",mtd_info.writesize);PRINT_LOG_DBG("nand oobsize: 0x%x\n",mtd_info.oobsize);#endifif(nand_rwblockbuf_init(mtd_info.erasesize) < 0)	{return -1;	}//mark badblock for testing//nand_mark_badblock(fd, offs);//printf("nand_mark_badblock: set nand bad,  0x%llx \n", offs);if(write_size > CONFIG_SIZE - mtd_info.erasesize)	{return -1;	}	remainDataSize = write_size;printf("inf_nand_write: write_size:%d offset:0x%x\n", write_size, offset);lseek(fd, offs, SEEK_SET);while(remainDataSize > 0) {if(offs >= (loff_t)max_available_size)		{PRINT_LOG_INFO("inf_nand_write: offs(0x%x) is bigger than max_available_size(0x%x)", offs, max_available_size);close(fd);return -1;		}//check if it is bad fast. If so, skip this block and write it to the next block		ret = nand_is_badblock(fd,offs);if(ret) {PRINT_LOG_INFO("inf_nand_write: 1 skiping bad block, addr %llx ret %d len: %d\n",offs, ret, remainDataSize);			offs += mtd_info.erasesize;lseek(fd, offs, SEEK_SET);continue;		} else			;/* write_crc = crc32(0, write_buffer, mtd_info.erasesize); *///Before writing, erase the block first		erase_info.start = (__u32)offs;		erase_info.length = mtd_info.erasesize;		ret = nand_erase_block(fd,erase_info);if(ret) {PRINT_LOG_INFO("inf_nand_write: erase failed, skiping the block, addr %llx ret %d\n", offs, ret);			offs += mtd_info.erasesize;lseek(fd, offs, SEEK_SET);continue;		} else			;//check if it is bad fast. If so, skip this block and write it to the next block		ret = nand_is_badblock(fd,offs);if(ret) {PRINT_LOG_INFO("inf_nand_write: 2 skiping bad block, addr %llx ret %d remainDataSize: %d\n",offs, ret, remainDataSize);			offs += mtd_info.erasesize;lseek(fd, offs, SEEK_SET);continue;		} else			;//handle block header dataif(remainDataSize <= mtd_info.erasesize - blockHeadLen)		{			blockDataLen = remainDataSize;		}else		{			blockDataLen = mtd_info.erasesize - blockHeadLen;		}bzero(pReadBlockBuf, mtd_info.erasesize);bzero(pWriteBlockBuf, mtd_info.erasesize);		*(int*)(pWriteBlockBuf + CRC_LEN) = HEADIMAGE;memcpy(pWriteBlockBuf + blockHeadLen, write_buffer, blockDataLen);crc_32_fun(pWriteBlockBuf + CRC_LEN, mtd_info.erasesize - CRC_LEN, &crcnum);PRINT_LOG_INFO("crcnum:0x%x blockDataLen:%d \n", crcnum, mtd_info.erasesize - CRC_LEN);		*(int*)pWriteBlockBuf = crcnum;lseek(fd, offs, SEEK_SET);//write dataif (write(fd, pWriteBlockBuf, mtd_info.erasesize) != mtd_info.erasesize) {perror("inf_nand_write: Failed to read from NAND device");close(fd);return -1;		}//Read data for verification (sample is just a simple comparison, actual use can use CRC verification, which is more efficient)//If the data is abnormal (you can retry reading a few more times here); Mark the block as a block, skip the block and write it onto a blocklseek(fd, offs, SEEK_SET);if (read(fd, pReadBlockBuf, mtd_info.erasesize) != mtd_info.erasesize) {perror("inf_nand_write: Failed to read from NAND device");close(fd);return -1;		}/* read_crc = crc32(0, read_buffer, mtd_info.erasesize); *//* if(write_crc != read_crc) { */if(compare_buf(pReadBlockBuf, pWriteBlockBuf, mtd_info.erasesize)) {PRINT_LOG_INFO("inf_nand_write: block addr %llx, write data error,mark badblock, remainDataSize:%d\n",offs, remainDataSize);			offs += mtd_info.erasesize;lseek(fd, offs, SEEK_SET);continue;		}PRINT_LOG_DBG("inf_nand_write: block addr %llx write ok, len = 0x%x\n",offs, remainDataSize);		offs += mtd_info.erasesize;		write_buffer += mtd_info.erasesize - blockHeadLen;lseek(fd, offs, SEEK_SET);		remainDataSize -= blockDataLen;	}fsync(fd);close(fd);return 0;}#endif