|
|
@@ -0,0 +1,1632 @@
|
|
|
+/*
|
|
|
+*********************************************************************************************************
|
|
|
+*
|
|
|
+* 模块名称 : NAND Flash驱动模块
|
|
|
+* 文件名称 : bsp_nand.c
|
|
|
+* 版 本 : V1.0
|
|
|
+* 说 明 : 提供NAND Flash (HY27UF081G2A， 8bit 128K字节 大页)的底层接口函数。【安富莱原创】
|
|
|
+*
|
|
|
+* 修改记录 :
|
|
|
+* 版本号 日期 作者 说明
|
|
|
+* V1.0 2013-02-01 armfly 正式发布
|
|
|
+*
|
|
|
+* Copyright (C), 2013-2014, 安富莱电子 www.armfly.com
|
|
|
+*
|
|
|
+*********************************************************************************************************
|
|
|
+*/
|
|
|
+#include "nand_flash.h"
|
|
|
+
|
|
|
+/*
|
|
|
+ 如果在IAR或KEIL的编辑器中阅读，请将编辑器的字体设置为新宋体（9号/五号），缩进的TAB设置为4。
|
|
|
+ 否则，方框处出现不对齐的问题。
|
|
|
+
|
|
|
+ 【待完善的地方】
|
|
|
+ （1）在操作NAND Flash时，如下语句是一个死循环。如果硬件出现异常，将导致软件死机
|
|
|
+ while( GPIO_ReadInputDataBit(GPIOG, GPIO_Pin_6) == 0 )
|
|
|
+
|
|
|
+ （2）没有增加ECC校验功能。ECC可以检查1个或2个bit错误，如果只有1个bit错误，则可以修复这个bit。如果
|
|
|
+ 多余2个bit错误，则可能检测不到。
|
|
|
+
|
|
|
+ （3）正常写文件操作时，会导致重建LUT。目前，重建LUT的代码执行效率还不够高，有待完善。
|
|
|
+
|
|
|
+ 【硬件说明】
|
|
|
+ 安富莱STM32F103ZE-EK开发板配置的NAND Flahs为海力士的HY27UF081G2A
|
|
|
+ （1）NAND Flash的片选信号连接到CPU的FSMC_NCE2，这决定了NAND Flash的地址空间为 0x70000000（见CPU的数据
|
|
|
+ 手册的FSMC章节)
|
|
|
+ （2）有FSMC总线上有多个总线设备（如TFT、SRAM、CH374T、NOR），因此必须确保其他总线设备的片选处于禁止
|
|
|
+ 状态，否则将出现总线冲突问题 （参见本文件初始化FSMC GPIO的函数）
|
|
|
+
|
|
|
+
|
|
|
+ 【NAND Flash 结构定义】
|
|
|
+ 备用区有16x4字节，每page 1024字节，每512字节一个扇区，每个扇区对应16自己的备用区：
|
|
|
+
|
|
|
+ 每个PAGE的逻辑结构，前面512Bx4是主数据区，后面16Bx4是备用区
|
|
|
+ ┌──────┐┌──────┐┌──────┐┌──────┐┌──────┐┌──────┐┌──────┐┌──────┐
|
|
|
+ │ Main area ││ Main area ││ Main area ││Main area ││ Spare area ││ Spare area ││ Spare area ││Spare area │
|
|
|
+ │ ││ ││ ││ ││ ││ ││ ││ │
|
|
|
+ │ 512B ││ 512B ││ 512B ││ 512B ││ 16B ││ 16B ││ 16B ││ 16B │
|
|
|
+ └──────┘└──────┘└──────┘└──────┘└──────┘└──────┘└──────┘└──────┘
|
|
|
+
|
|
|
+ 每16B的备用区的逻辑结构如下:(三星推荐标准）
|
|
|
+ ┌───┐┌───┐┌──┐┌──┐┌──┐┌───┐┌───┐┌───┐┌──┐┌──┐┌──┐┌──┐┌───┐┌───┐┌───┐┌───┐┌───┐
|
|
|
+ │ BI ││RESER ││LSN0││LSN1││LSN2││RESER ││RESER ││RESER ││ECC0││ECC1││ECC2││ECC0││S-ECC1││S-ECC0││RESER ││RESER ││RESER │
|
|
|
+ │ ││ VED ││ ││ ││ ││ VED ││ VED ││ VED ││ ││ ││ ││ ││ ││ ││ VED ││ VED ││ VED │
|
|
|
+ └───┘└───┘└──┘└──┘└──┘└───┘└───┘└───┘└──┘└──┘└──┘└──┘└───┘└───┘└───┘└───┘└───┘
|
|
|
+
|
|
|
+ K9F1G08U0A 和 HY27UF081G2A 是兼容的。芯片出厂时，厂商保证芯片的第1个块是好块。如果是坏块，则在该块的第1个PAGE的第1个字节
|
|
|
+ 或者第2个PAGE（当第1个PAGE坏了无法标记为0xFF时）的第1个字节写入非0xFF值。坏块标记值是随机的，软件直接判断是否等于0xFF即可。
|
|
|
+
|
|
|
+ 注意：网上有些资料说NAND Flash厂商的默认做法是将坏块标记定在第1个PAGE的第6个字节处。这个说法是错误。坏块标记在第6个字节仅针对部分小扇区（512字节）的NAND Flash
|
|
|
+ 并不是所有的NAND Flash都是这个标准。大家在更换NAND Flash时，请仔细阅读芯片的数据手册。
|
|
|
+
|
|
|
+
|
|
|
+ 为了便于在NAND Flash 上移植Fat文件系统，我们对16B的备用区采用以下分配方案:
|
|
|
+ ┌──┐┌──┐┌──┐┌──┐┌──┐┌──┐┌──┐┌──┐┌──┐┌──┐┌───┐┌───┐┌──┐┌──┐┌──┐┌──┐
|
|
|
+ │ BI ││USED││LBN0││LBN1││ECC0││ECC1││ECC2││ECC3││ECC4││ECC5││S-ECC1││S-ECC0││RSVD││RSVD││RSVD││RSVD│
|
|
|
+ │ ││ ││ ││ ││ ││ ││ ││ ││ ││ ││ ││ ││ ││ ││ ││ │
|
|
|
+ └──┘└──┘└──┘└──┘└──┘└──┘└──┘└──┘└──┘└──┘└───┘└───┘└──┘└──┘└──┘└──┘
|
|
|
+ - BI : 坏块标志(Bad Block Identifier)。每个BLOCK的第1个PAGE或者第2个PAGE的第1个字节指示该块是否坏块。0xFF表示好块，不是0xFF表示坏块。
|
|
|
+ - USED : 该块使用标志。0xFF表示空闲块；0xF0表示已用块。
|
|
|
+ - LBN0 LBN1 : 逻辑块号(Logic Block No) 。从0开始编码。只在每个BLOCK的第1个PAGE有效，其它PAGE该字段固定为0xFF FF
|
|
|
+ - ECC0 ~ ECC6 : 512B主数据区的ECC校验 （按照三星提供ECC算法，256字节对应3个字节的ECC)
|
|
|
+ - S-ECC1 S-ECC0 : LSN0和LSN2的ECC校验
|
|
|
+ - RSVD : 保留字节，Reserved
|
|
|
+
|
|
|
+ 【坏块管理 & 磨损平衡】
|
|
|
+ (1) 内部全局数组s_usLUT[]按次序保存物理块号。用于物理块和逻辑块的地址映射。
|
|
|
+ (2) 格式化时，将98%的好块用于主数据存储。剩余的2%用于备用区（坏块替换）。
|
|
|
+ (3) 写扇区（512B)时，如果扇区内容为空，则直接写入，减少不必要的块擦除操作。有效提高NAND Flash的寿命和读写性能。
|
|
|
+ (4) 写扇区时，如果扇区内容不为空，则从末尾开始查找一个空闲块替换掉旧块，替换并改写数据完成后，将旧块擦除，并标注为空闲，之后重建LUT。
|
|
|
+ (5) 块复制时，充分利用NAND Flash硬件的Copy-Back功能，无需读源页到内存再写入目标页。这样可显著提高读写效率。
|
|
|
+ (6) 磨损平衡还存在缺陷，效果不好。ECC校验暂未实现。
|
|
|
+
|
|
|
+*/
|
|
|
+
|
|
|
+/* 定义NAND Flash的物理地址。这个是由硬件决定的 */
|
|
|
+#define Bank2_NAND_ADDR ((uint32_t)0x70000000)
|
|
|
+#define Bank_NAND_ADDR Bank2_NAND_ADDR
|
|
|
+
|
|
|
+/* 定义操作NAND Flash用到3个宏 */
|
|
|
+#define NAND_CMD_AREA *(__IO uint8_t *)(Bank_NAND_ADDR | CMD_AREA)
|
|
|
+#define NAND_ADDR_AREA *(__IO uint8_t *)(Bank_NAND_ADDR | ADDR_AREA)
|
|
|
+#define NAND_DATA_AREA *(__IO uint8_t *)(Bank_NAND_ADDR | DATA_AREA)
|
|
|
+
|
|
|
+/* 逻辑块号映射表。好块总数的2%用于备份区，因此数组维数低于1024。 LUT = Look Up Table */
|
|
|
+static uint16_t s_usLUT[NAND_BLOCK_COUNT];
|
|
|
+
|
|
|
+static uint16_t s_usValidDataBlockCount; /* 有效的数据块个数 */
|
|
|
+
|
|
|
+static uint8_t s_ucTempBuf[NAND_PAGE_TOTAL_SIZE]; /* 大缓冲区，2112字节. 用于读出比较 */
|
|
|
+
|
|
|
+static uint8_t NAND_BuildLUT(void);
|
|
|
+static uint8_t FSMC_NAND_GetStatus(void);
|
|
|
+static uint16_t NAND_FindFreeBlock(void);
|
|
|
+static uint8_t NAND_MarkUsedBlock(uint32_t _ulBlockNo);
|
|
|
+static void NAND_MarkBadBlock(uint32_t _ulBlockNo);
|
|
|
+static uint16_t NAND_AddrToPhyBlockNo(uint32_t _ulMemAddr);
|
|
|
+static uint8_t NAND_IsBufOk(uint8_t *_pBuf, uint32_t _ulLen, uint8_t _ucValue);
|
|
|
+uint8_t NAND_WriteToNewBlock(uint32_t _ulPhyPageNo, uint8_t *_pWriteBuf, uint16_t _usOffset, uint16_t _usSize);
|
|
|
+static uint8_t NAND_IsFreeBlock(uint32_t _ulBlockNo);
|
|
|
+
|
|
|
+static uint16_t NAND_LBNtoPBN(uint32_t _uiLBN);
|
|
|
+
|
|
|
+/*
|
|
|
+*********************************************************************************************************
|
|
|
+* 函 数 名: FSMC_NAND_Init
|
|
|
+* 功能说明: 配置FSMC和GPIO用于NAND Flash接口。这个函数必须在读写nand flash前被调用一次。
|
|
|
+* 形 参: 无
|
|
|
+* 返 回 值: 无
|
|
|
+*********************************************************************************************************
|
|
|
+*/
|
|
|
+static void FSMC_NAND_Init(void)
|
|
|
+{
|
|
|
+ FSMC_NANDInitTypeDef FSMC_NANDInitStructure;
|
|
|
+ FSMC_NAND_PCCARDTimingInitTypeDef p;
|
|
|
+
|
|
|
+ /*--NAND Flash GPIOs 配置 ------
|
|
|
+ PD0/FSMC_D2
|
|
|
+ PD1/FSMC_D3
|
|
|
+ PD4/FSMC_NOE
|
|
|
+ PD5/FSMC_NWE
|
|
|
+ PD7/FSMC_NCE2
|
|
|
+ PD11/FSMC_A16
|
|
|
+ PD12/FSMC_A17
|
|
|
+ PD14/FSMC_D0
|
|
|
+ PD15/FSMC_D1
|
|
|
+
|
|
|
+ PE7/FSMC_D4
|
|
|
+ PE8/FSMC_D5
|
|
|
+ PE9/FSMC_D6
|
|
|
+ PE10/FSMC_D7
|
|
|
+
|
|
|
+ PG6/FSMC_INT2 (本例程用查询方式判忙，此口线作为普通GPIO输入功能使用)
|
|
|
+ */
|
|
|
+
|
|
|
+ /* 配置GPIOG, PG6作为忙信息，配置为输入 */
|
|
|
+
|
|
|
+ /* INT2 引脚配置为内部上来输入，用于忙信号 */
|
|
|
+
|
|
|
+ /* 配置 FSMC 时序 */
|
|
|
+ /*
|
|
|
+ Defines the number of HCLK cycles to setup address before the command assertion for NAND-Flash
|
|
|
+ read or write access to common/Attribute or I/O memory space (depending on the memory space
|
|
|
+ timing to be configured).This parameter can be a value between 0 and 0xFF.
|
|
|
+ */
|
|
|
+ // p.FSMC_SetupTime = 0x01;
|
|
|
+ p.FSMC_SetupTime = 0x1;
|
|
|
+
|
|
|
+ /*
|
|
|
+ Defines the minimum number of HCLK cycles to assert the command for NAND-Flash read or write
|
|
|
+ access to common/Attribute or I/O memory space (depending on the memory space timing to be
|
|
|
+ configured). This parameter can be a number between 0x00 and 0xFF
|
|
|
+ */
|
|
|
+ // p.FSMC_WaitSetupTime = 0x03;
|
|
|
+ p.FSMC_WaitSetupTime = 0x3;
|
|
|
+
|
|
|
+ /*
|
|
|
+ Defines the number of HCLK clock cycles to hold address (and data for write access) after the
|
|
|
+ command deassertion for NAND-Flash read or write access to common/Attribute or I/O memory space
|
|
|
+ (depending on the memory space timing to be configured).
|
|
|
+ This parameter can be a number between 0x00 and 0xFF
|
|
|
+ */
|
|
|
+ // p.FSMC_HoldSetupTime = 0x02;
|
|
|
+ p.FSMC_HoldSetupTime = 0x2;
|
|
|
+
|
|
|
+ /*
|
|
|
+ Defines the number of HCLK clock cycles during which the databus is kept in HiZ after the start
|
|
|
+ of a NAND-Flash write access to common/Attribute or I/O memory space (depending on the memory
|
|
|
+ space timing to be configured). This parameter can be a number between 0x00 and 0xFF
|
|
|
+ */
|
|
|
+ // p.FSMC_HiZSetupTime = 0x01;
|
|
|
+ p.FSMC_HiZSetupTime = 0x1;
|
|
|
+
|
|
|
+ FSMC_NANDInitStructure.FSMC_Bank = FSMC_Bank2_NAND; /* 定义FSMC NAND BANK 号 */
|
|
|
+ FSMC_NANDInitStructure.FSMC_Waitfeature = FSMC_Waitfeature_Disable; /* 插入等待时序使能 */
|
|
|
+ FSMC_NANDInitStructure.FSMC_MemoryDataWidth = FSMC_MemoryDataWidth_8b; /* 数据宽度 8bit */
|
|
|
+ FSMC_NANDInitStructure.FSMC_ECC = FSMC_ECC_Enable; /* ECC错误检查和纠正功能使能 */
|
|
|
+ FSMC_NANDInitStructure.FSMC_ECCPageSize = FSMC_ECCPageSize_2048Bytes; /* ECC 页面大小 */
|
|
|
+ FSMC_NANDInitStructure.FSMC_TCLRSetupTime = 0x01; /* CLE低和RE低之间的延迟，HCLK周期数 */
|
|
|
+ FSMC_NANDInitStructure.FSMC_TARSetupTime = 0x01; /* ALE低和RE低之间的延迟，HCLK周期数 */
|
|
|
+ FSMC_NANDInitStructure.FSMC_CommonSpaceTimingStruct = &p; /* FSMC Common Space Timing */
|
|
|
+ FSMC_NANDInitStructure.FSMC_AttributeSpaceTimingStruct = &p; /* FSMC Attribute Space Timing */
|
|
|
+
|
|
|
+ FSMC_NANDInit(&FSMC_NANDInitStructure);
|
|
|
+
|
|
|
+ /* FSMC NAND Bank 使能 */
|
|
|
+ FSMC_NANDCmd(FSMC_Bank2_NAND, ENABLE);
|
|
|
+}
|
|
|
+
|
|
|
+/*
|
|
|
+*********************************************************************************************************
|
|
|
+* 函 数 名: NAND_ReadID
|
|
|
+* 功能说明: 读NAND Flash的ID。ID存储到形参指定的结构体变量中。
|
|
|
+* 形 参: 无
|
|
|
+* 返 回 值: 32bit的NAND Flash ID
|
|
|
+*********************************************************************************************************
|
|
|
+*/
|
|
|
+uint32_t NAND_ReadID(void)
|
|
|
+{
|
|
|
+ uint32_t data = 0;
|
|
|
+
|
|
|
+ /* 发送命令 Command to the command area */
|
|
|
+ NAND_CMD_AREA = 0x90;
|
|
|
+ NAND_ADDR_AREA = 0x00;
|
|
|
+
|
|
|
+ /* 顺序读取NAND Flash的ID */
|
|
|
+ data = *(__IO uint32_t *)(Bank_NAND_ADDR | DATA_AREA);
|
|
|
+ data = ((data << 24) & 0xFF000000) |
|
|
|
+ ((data << 8) & 0x00FF0000) |
|
|
|
+ ((data >> 8) & 0x0000FF00) |
|
|
|
+ ((data >> 24) & 0x000000FF);
|
|
|
+ return data;
|
|
|
+}
|
|
|
+
|
|
|
+/*
|
|
|
+*********************************************************************************************************
|
|
|
+* 函 数 名: FSMC_NAND_PageCopyBack
|
|
|
+* 功能说明: 将一页数据复制到另外一个页。源页和目标页必须同为偶数页或同为奇数页。
|
|
|
+* 形 参: - _ulSrcPageNo: 源页号
|
|
|
+* - _ulTarPageNo: 目标页号
|
|
|
+* 返 回 值: 执行结果：
|
|
|
+* - NAND_FAIL 表示失败
|
|
|
+* - NAND_OK 表示成功
|
|
|
+*
|
|
|
+* 说 明：数据手册推荐：在页复制之前，先校验源页的位校验，否则可能会积累位错误。本函数未实现。
|
|
|
+*
|
|
|
+*********************************************************************************************************
|
|
|
+*/
|
|
|
+static uint8_t FSMC_NAND_PageCopyBack(uint32_t _ulSrcPageNo, uint32_t _ulTarPageNo)
|
|
|
+{
|
|
|
+ uint8_t i;
|
|
|
+
|
|
|
+ NAND_CMD_AREA = NAND_CMD_COPYBACK_A;
|
|
|
+
|
|
|
+ /* 发送源页地址 ， 对于 HY27UF081G2A
|
|
|
+ Bit7 Bit6 Bit5 Bit4 Bit3 Bit2 Bit1 Bit0
|
|
|
+ 第1字节： A7 A6 A5 A4 A3 A2 A1 A0 (_usPageAddr 的bit7 - bit0)
|
|
|
+ 第2字节： 0 0 0 0 A11 A10 A9 A8 (_usPageAddr 的bit11 - bit8, 高4bit必须是0)
|
|
|
+ 第3字节： A19 A18 A17 A16 A15 A14 A13 A12
|
|
|
+ 第4字节： A27 A26 A25 A24 A23 A22 A21 A20
|
|
|
+ */
|
|
|
+ NAND_ADDR_AREA = 0;
|
|
|
+ NAND_ADDR_AREA = 0;
|
|
|
+ NAND_ADDR_AREA = _ulSrcPageNo;
|
|
|
+ NAND_ADDR_AREA = (_ulSrcPageNo & 0xFF00) >> 8;
|
|
|
+
|
|
|
+ NAND_CMD_AREA = NAND_CMD_COPYBACK_B;
|
|
|
+
|
|
|
+ /* 必须等待，否则读出数据异常, 此处应该判断超时 */
|
|
|
+ for (i = 0; i < 20; i++)
|
|
|
+ ;
|
|
|
+ while (GPIO_ReadInputDataBit(GPIOG, GPIO_Pin_6) == 0)
|
|
|
+ ;
|
|
|
+
|
|
|
+ NAND_CMD_AREA = NAND_CMD_COPYBACK_C;
|
|
|
+
|
|
|
+ /* 发送目标页地址 ， 对于 HY27UF081G2A
|
|
|
+ Bit7 Bit6 Bit5 Bit4 Bit3 Bit2 Bit1 Bit0
|
|
|
+ 第1字节： A7 A6 A5 A4 A3 A2 A1 A0 (_usPageAddr 的bit7 - bit0)
|
|
|
+ 第2字节： 0 0 0 0 A11 A10 A9 A8 (_usPageAddr 的bit11 - bit8, 高4bit必须是0)
|
|
|
+ 第3字节： A19 A18 A17 A16 A15 A14 A13 A12
|
|
|
+ 第4字节： A27 A26 A25 A24 A23 A22 A21 A20
|
|
|
+ */
|
|
|
+ NAND_ADDR_AREA = 0;
|
|
|
+ NAND_ADDR_AREA = 0;
|
|
|
+ NAND_ADDR_AREA = _ulTarPageNo;
|
|
|
+ NAND_ADDR_AREA = (_ulTarPageNo & 0xFF00) >> 8;
|
|
|
+
|
|
|
+ NAND_CMD_AREA = NAND_CMD_COPYBACK_D;
|
|
|
+
|
|
|
+ /* 检查操作状态 */
|
|
|
+ if (FSMC_NAND_GetStatus() == NAND_READY)
|
|
|
+ {
|
|
|
+ return NAND_OK;
|
|
|
+ }
|
|
|
+ return NAND_FAIL;
|
|
|
+}
|
|
|
+
|
|
|
+/*
|
|
|
+*********************************************************************************************************
|
|
|
+* 函 数 名: FSMC_NAND_PageCopyBackEx
|
|
|
+* 功能说明: 将一页数据复制到另外一个页,并更新目标页中的部分数据。源页和目标页必须同为偶数页或同为奇数页。
|
|
|
+* 形 参: - _ulSrcPageNo: 源页号
|
|
|
+* - _ulTarPageNo: 目标页号
|
|
|
+* - _usOffset: 页内偏移地址，pBuf的内容将写入这个地址开始单元
|
|
|
+* - _pBuf: 数据缓冲区
|
|
|
+* - _usSize: 数据大小
|
|
|
+* 返 回 值: 执行结果：
|
|
|
+* - NAND_FAIL 表示失败
|
|
|
+* - NAND_OK 表示成功
|
|
|
+*
|
|
|
+* 说 明：数据手册推荐：在页复制之前，先校验源页的位校验，否则可能会积累位错误。本函数未实现。
|
|
|
+*
|
|
|
+*********************************************************************************************************
|
|
|
+*/
|
|
|
+static uint8_t FSMC_NAND_PageCopyBackEx(uint32_t _ulSrcPageNo, uint32_t _ulTarPageNo, uint8_t *_pBuf, uint16_t _usOffset, uint16_t _usSize)
|
|
|
+{
|
|
|
+ uint16_t i;
|
|
|
+
|
|
|
+ NAND_CMD_AREA = NAND_CMD_COPYBACK_A;
|
|
|
+
|
|
|
+ /* 发送源页地址 ， 对于 HY27UF081G2A
|
|
|
+ Bit7 Bit6 Bit5 Bit4 Bit3 Bit2 Bit1 Bit0
|
|
|
+ 第1字节： A7 A6 A5 A4 A3 A2 A1 A0 (_usPageAddr 的bit7 - bit0)
|
|
|
+ 第2字节： 0 0 0 0 A11 A10 A9 A8 (_usPageAddr 的bit11 - bit8, 高4bit必须是0)
|
|
|
+ 第3字节： A19 A18 A17 A16 A15 A14 A13 A12
|
|
|
+ 第4字节： A27 A26 A25 A24 A23 A22 A21 A20
|
|
|
+ */
|
|
|
+ NAND_ADDR_AREA = 0;
|
|
|
+ NAND_ADDR_AREA = 0;
|
|
|
+ NAND_ADDR_AREA = _ulSrcPageNo;
|
|
|
+ NAND_ADDR_AREA = (_ulSrcPageNo & 0xFF00) >> 8;
|
|
|
+
|
|
|
+ NAND_CMD_AREA = NAND_CMD_COPYBACK_B;
|
|
|
+
|
|
|
+ /* 必须等待，否则读出数据异常, 此处应该判断超时 */
|
|
|
+ for (i = 0; i < 20; i++)
|
|
|
+ ;
|
|
|
+ while (GPIO_ReadInputDataBit(GPIOG, GPIO_Pin_6) == 0)
|
|
|
+ ;
|
|
|
+
|
|
|
+ NAND_CMD_AREA = NAND_CMD_COPYBACK_C;
|
|
|
+
|
|
|
+ /* 发送目标页地址 ， 对于 HY27UF081G2A
|
|
|
+ Bit7 Bit6 Bit5 Bit4 Bit3 Bit2 Bit1 Bit0
|
|
|
+ 第1字节： A7 A6 A5 A4 A3 A2 A1 A0 (_usPageAddr 的bit7 - bit0)
|
|
|
+ 第2字节： 0 0 0 0 A11 A10 A9 A8 (_usPageAddr 的bit11 - bit8, 高4bit必须是0)
|
|
|
+ 第3字节： A19 A18 A17 A16 A15 A14 A13 A12
|
|
|
+ 第4字节： A27 A26 A25 A24 A23 A22 A21 A20
|
|
|
+ */
|
|
|
+ NAND_ADDR_AREA = 0;
|
|
|
+ NAND_ADDR_AREA = 0;
|
|
|
+ NAND_ADDR_AREA = _ulTarPageNo;
|
|
|
+ NAND_ADDR_AREA = (_ulTarPageNo & 0xFF00) >> 8;
|
|
|
+
|
|
|
+ /* 中间无需带数据, 也无需等待 */
|
|
|
+
|
|
|
+ NAND_CMD_AREA = NAND_CMD_COPYBACK_C;
|
|
|
+
|
|
|
+ NAND_ADDR_AREA = _usOffset;
|
|
|
+ NAND_ADDR_AREA = _usOffset >> 8;
|
|
|
+
|
|
|
+ /* 发送数据 */
|
|
|
+ for (i = 0; i < _usSize; i++)
|
|
|
+ {
|
|
|
+ NAND_DATA_AREA = _pBuf[i];
|
|
|
+ }
|
|
|
+
|
|
|
+ NAND_CMD_AREA = NAND_CMD_COPYBACK_D;
|
|
|
+
|
|
|
+ /* 检查操作状态 */
|
|
|
+ if (FSMC_NAND_GetStatus() == NAND_READY)
|
|
|
+ {
|
|
|
+ return NAND_OK;
|
|
|
+ }
|
|
|
+ return NAND_FAIL;
|
|
|
+}
|
|
|
+
|
|
|
+/*
|
|
|
+*********************************************************************************************************
|
|
|
+* 函 数 名: FSMC_NAND_WritePage
|
|
|
+* 功能说明: 写一组数据至NandFlash指定页面的指定位置，写入的数据长度不大于一页的大小。
|
|
|
+* 形 参: - _pBuffer: 指向包含待写数据的缓冲区
|
|
|
+* - _ulPageNo: 页号，所有的页统一编码，范围为：0 - 65535
|
|
|
+* - _usAddrInPage : 页内地址，范围为：0-2111
|
|
|
+* - _usByteCount: 写入的字节个数
|
|
|
+* 返 回 值: 执行结果：
|
|
|
+* - NAND_FAIL 表示失败
|
|
|
+* - NAND_OK 表示成功
|
|
|
+*********************************************************************************************************
|
|
|
+*/
|
|
|
+static uint8_t FSMC_NAND_WritePage(uint8_t *_pBuffer, uint32_t _ulPageNo, uint16_t _usAddrInPage, uint16_t _usByteCount)
|
|
|
+{
|
|
|
+ uint16_t i;
|
|
|
+
|
|
|
+ /* 发送页写命令 */
|
|
|
+ NAND_CMD_AREA = NAND_CMD_WRITE0;
|
|
|
+
|
|
|
+ /* 发送页内地址 ， 对于 HY27UF081G2A
|
|
|
+ Bit7 Bit6 Bit5 Bit4 Bit3 Bit2 Bit1 Bit0
|
|
|
+ 第1字节： A7 A6 A5 A4 A3 A2 A1 A0 (_usPageAddr 的bit7 - bit0)
|
|
|
+ 第2字节： 0 0 0 0 A11 A10 A9 A8 (_usPageAddr 的bit11 - bit8, 高4bit必须是0)
|
|
|
+ 第3字节： A19 A18 A17 A16 A15 A14 A13 A12
|
|
|
+ 第4字节： A27 A26 A25 A24 A23 A22 A21 A20
|
|
|
+ */
|
|
|
+ NAND_ADDR_AREA = _usAddrInPage;
|
|
|
+ NAND_ADDR_AREA = _usAddrInPage >> 8;
|
|
|
+ NAND_ADDR_AREA = _ulPageNo;
|
|
|
+ NAND_ADDR_AREA = (_ulPageNo & 0xFF00) >> 8;
|
|
|
+
|
|
|
+ /* 写数据 */
|
|
|
+ for (i = 0; i < _usByteCount; i++)
|
|
|
+ {
|
|
|
+ NAND_DATA_AREA = _pBuffer[i];
|
|
|
+ }
|
|
|
+ NAND_CMD_AREA = NAND_CMD_WRITE_TRUE1;
|
|
|
+
|
|
|
+ /* 检查操作状态 */
|
|
|
+ if (FSMC_NAND_GetStatus() == NAND_READY)
|
|
|
+ {
|
|
|
+ return NAND_OK;
|
|
|
+ }
|
|
|
+ return NAND_FAIL;
|
|
|
+}
|
|
|
+
|
|
|
+/*
|
|
|
+*********************************************************************************************************
|
|
|
+* 函 数 名: FSMC_NAND_ReadPage
|
|
|
+* 功能说明: 从NandFlash指定页面的指定位置读一组数据，读出的数据长度不大于一页的大小。
|
|
|
+* 形 参: - _pBuffer: 指向包含待写数据的缓冲区
|
|
|
+* - _ulPageNo: 页号，所有的页统一编码，范围为：0 - 65535
|
|
|
+* - _usAddrInPage : 页内地址，范围为：0-2111
|
|
|
+* - _usByteCount: 字节个数
|
|
|
+* 返 回 值: 执行结果：
|
|
|
+* - NAND_FAIL 表示失败
|
|
|
+* - NAND_OK 表示成功
|
|
|
+*********************************************************************************************************
|
|
|
+*/
|
|
|
+static uint8_t FSMC_NAND_ReadPage(uint8_t *_pBuffer, uint32_t _ulPageNo, uint16_t _usAddrInPage, uint16_t _usByteCount)
|
|
|
+{
|
|
|
+ uint16_t i;
|
|
|
+
|
|
|
+ /* 发送页面读命令 */
|
|
|
+ NAND_CMD_AREA = NAND_CMD_AREA_A;
|
|
|
+
|
|
|
+ /* 发送页内地址 ， 对于 HY27UF081G2A
|
|
|
+ Bit7 Bit6 Bit5 Bit4 Bit3 Bit2 Bit1 Bit0
|
|
|
+ 第1字节： A7 A6 A5 A4 A3 A2 A1 A0 (_usPageAddr 的bit7 - bit0)
|
|
|
+ 第2字节： 0 0 0 0 A11 A10 A9 A8 (_usPageAddr 的bit11 - bit8, 高4bit必须是0)
|
|
|
+ 第3字节： A19 A18 A17 A16 A15 A14 A13 A12
|
|
|
+ 第4字节： A27 A26 A25 A24 A23 A22 A21 A20
|
|
|
+ */
|
|
|
+ NAND_ADDR_AREA = _usAddrInPage;
|
|
|
+ NAND_ADDR_AREA = _usAddrInPage >> 8;
|
|
|
+ NAND_ADDR_AREA = _ulPageNo;
|
|
|
+ NAND_ADDR_AREA = (_ulPageNo & 0xFF00) >> 8;
|
|
|
+
|
|
|
+ NAND_CMD_AREA = NAND_CMD_AREA_TRUE1;
|
|
|
+
|
|
|
+ /* 必须等待，否则读出数据异常, 此处应该判断超时 */
|
|
|
+ for (i = 0; i < 20; i++)
|
|
|
+ ;
|
|
|
+ while (GPIO_ReadInputDataBit(GPIOG, GPIO_Pin_6) == 0)
|
|
|
+ ;
|
|
|
+
|
|
|
+ /* 读数据到缓冲区pBuffer */
|
|
|
+ for (i = 0; i < _usByteCount; i++)
|
|
|
+ {
|
|
|
+ _pBuffer[i] = NAND_DATA_AREA;
|
|
|
+ }
|
|
|
+
|
|
|
+ return NAND_OK;
|
|
|
+}
|
|
|
+
|
|
|
+/*
|
|
|
+*********************************************************************************************************
|
|
|
+* 函 数 名: FSMC_NAND_WriteSpare
|
|
|
+* 功能说明: 向1个PAGE的Spare区写入数据
|
|
|
+* 形 参: - _pBuffer: 指向包含待写数据的缓冲区
|
|
|
+* - _ulPageNo: 页号，所有的页统一编码，范围为：0 - 65535
|
|
|
+* - _usAddrInSpare : 页内备用区的偏移地址，范围为：0-63
|
|
|
+* - _usByteCount: 写入的字节个数
|
|
|
+* 返 回 值: 执行结果：
|
|
|
+* - NAND_FAIL 表示失败
|
|
|
+* - NAND_OK 表示成功
|
|
|
+*********************************************************************************************************
|
|
|
+*/
|
|
|
+static uint8_t FSMC_NAND_WriteSpare(uint8_t *_pBuffer, uint32_t _ulPageNo, uint16_t _usAddrInSpare, uint16_t _usByteCount)
|
|
|
+{
|
|
|
+ if (_usByteCount > NAND_SPARE_AREA_SIZE)
|
|
|
+ {
|
|
|
+ return NAND_FAIL;
|
|
|
+ }
|
|
|
+
|
|
|
+ return FSMC_NAND_WritePage(_pBuffer, _ulPageNo, NAND_PAGE_SIZE + _usAddrInSpare, _usByteCount);
|
|
|
+}
|
|
|
+
|
|
|
+/*
|
|
|
+*********************************************************************************************************
|
|
|
+* 函 数 名: FSMC_NAND_ReadSpare
|
|
|
+* 功能说明: 读1个PAGE的Spare区的数据
|
|
|
+* 形 参: - _pBuffer: 指向包含待写数据的缓冲区
|
|
|
+* - _ulPageNo: 页号，所有的页统一编码，范围为：0 - 65535
|
|
|
+* - _usAddrInSpare : 页内备用区的偏移地址，范围为：0-63
|
|
|
+* - _usByteCount: 写入的字节个数
|
|
|
+* 返 回 值: 执行结果：
|
|
|
+* - NAND_FAIL 表示失败
|
|
|
+* - NAND_OK 表示成功
|
|
|
+*********************************************************************************************************
|
|
|
+*/
|
|
|
+static uint8_t FSMC_NAND_ReadSpare(uint8_t *_pBuffer, uint32_t _ulPageNo, uint16_t _usAddrInSpare, uint16_t _usByteCount)
|
|
|
+{
|
|
|
+ if (_usByteCount > NAND_SPARE_AREA_SIZE)
|
|
|
+ {
|
|
|
+ return NAND_FAIL;
|
|
|
+ }
|
|
|
+
|
|
|
+ return FSMC_NAND_ReadPage(_pBuffer, _ulPageNo, NAND_PAGE_SIZE + _usAddrInSpare, _usByteCount);
|
|
|
+}
|
|
|
+
|
|
|
+/*
|
|
|
+*********************************************************************************************************
|
|
|
+* 函 数 名: FSMC_NAND_WriteData
|
|
|
+* 功能说明: 向1个PAGE的主数据区写入数据
|
|
|
+* 形 参: - _pBuffer: 指向包含待写数据的缓冲区
|
|
|
+* - _ulPageNo: 页号，所有的页统一编码，范围为：0 - 65535
|
|
|
+* - _usAddrInPage : 页内数据区的偏移地址，范围为：0-2047
|
|
|
+* - _usByteCount: 写入的字节个数
|
|
|
+* 返 回 值: 执行结果：
|
|
|
+* - NAND_FAIL 表示失败
|
|
|
+* - NAND_OK 表示成功
|
|
|
+*********************************************************************************************************
|
|
|
+*/
|
|
|
+static uint8_t FSMC_NAND_WriteData(uint8_t *_pBuffer, uint32_t _ulPageNo, uint16_t _usAddrInPage, uint16_t _usByteCount)
|
|
|
+{
|
|
|
+ if (_usByteCount > NAND_PAGE_SIZE)
|
|
|
+ {
|
|
|
+ return NAND_FAIL;
|
|
|
+ }
|
|
|
+
|
|
|
+ return FSMC_NAND_WritePage(_pBuffer, _ulPageNo, _usAddrInPage, _usByteCount);
|
|
|
+}
|
|
|
+
|
|
|
+/*
|
|
|
+*********************************************************************************************************
|
|
|
+* 函 数 名: FSMC_NAND_ReadData
|
|
|
+* 功能说明: 读1个PAGE的主数据的数据
|
|
|
+* 形 参: - _pBuffer: 指向包含待写数据的缓冲区
|
|
|
+* - _ulPageNo: 页号，所有的页统一编码，范围为：0 - 65535
|
|
|
+* - _usAddrInPage : 页内数据区的偏移地址，范围为：0-2047
|
|
|
+* - _usByteCount: 写入的字节个数
|
|
|
+* 返 回 值: 执行结果：
|
|
|
+* - NAND_FAIL 表示失败
|
|
|
+* - NAND_OK 表示成功
|
|
|
+*********************************************************************************************************
|
|
|
+*/
|
|
|
+static uint8_t FSMC_NAND_ReadData(uint8_t *_pBuffer, uint32_t _ulPageNo, uint16_t _usAddrInPage, uint16_t _usByteCount)
|
|
|
+{
|
|
|
+ if (_usByteCount > NAND_PAGE_SIZE)
|
|
|
+ {
|
|
|
+ return NAND_FAIL;
|
|
|
+ }
|
|
|
+
|
|
|
+ return FSMC_NAND_ReadPage(_pBuffer, _ulPageNo, _usAddrInPage, _usByteCount);
|
|
|
+}
|
|
|
+
|
|
|
+/*
|
|
|
+*********************************************************************************************************
|
|
|
+* 函 数 名: FSMC_NAND_EraseBlock
|
|
|
+* 功能说明: 擦除NAND Flash一个块（block）
|
|
|
+* 形 参: - _ulBlockNo: 块号，范围为：0 - 1023
|
|
|
+* 返 回 值: NAND操作状态，有如下几种值：
|
|
|
+* - NAND_TIMEOUT_ERROR : 超时错误
|
|
|
+* - NAND_READY : 操作成功
|
|
|
+*********************************************************************************************************
|
|
|
+*/
|
|
|
+static uint8_t FSMC_NAND_EraseBlock(uint32_t _ulBlockNo)
|
|
|
+{
|
|
|
+ /* 发送擦除命令 */
|
|
|
+ NAND_CMD_AREA = NAND_CMD_ERASE0;
|
|
|
+
|
|
|
+ _ulBlockNo <<= 6; /* 块号转换为页编号 */
|
|
|
+ NAND_ADDR_AREA = _ulBlockNo;
|
|
|
+ NAND_ADDR_AREA = _ulBlockNo >> 8;
|
|
|
+
|
|
|
+ NAND_CMD_AREA = NAND_CMD_ERASE1;
|
|
|
+
|
|
|
+ return (FSMC_NAND_GetStatus());
|
|
|
+}
|
|
|
+
|
|
|
+/*
|
|
|
+*********************************************************************************************************
|
|
|
+* 函 数 名: FSMC_NAND_Reset
|
|
|
+* 功能说明: 复位NAND Flash
|
|
|
+* 形 参: 无
|
|
|
+* 返 回 值: 无
|
|
|
+*********************************************************************************************************
|
|
|
+*/
|
|
|
+static uint8_t FSMC_NAND_Reset(void)
|
|
|
+{
|
|
|
+ NAND_CMD_AREA = NAND_CMD_RESET;
|
|
|
+
|
|
|
+ /* 检查操作状态 */
|
|
|
+ if (FSMC_NAND_GetStatus() == NAND_READY)
|
|
|
+ {
|
|
|
+ return NAND_OK;
|
|
|
+ }
|
|
|
+
|
|
|
+ return NAND_FAIL;
|
|
|
+}
|
|
|
+
|
|
|
+/*
|
|
|
+*********************************************************************************************************
|
|
|
+* 函 数 名: FSMC_NAND_ReadStatus
|
|
|
+* 功能说明: 使用Read statuc 命令读NAND Flash内部状态
|
|
|
+* 形 参: - Address: 被擦除的快内任意地址
|
|
|
+* 返 回 值: NAND操作状态，有如下几种值：
|
|
|
+* - NAND_BUSY: 内部正忙
|
|
|
+* - NAND_READY: 内部空闲，可以进行下步操作
|
|
|
+* - NAND_ERROR: 先前的命令执行失败
|
|
|
+*********************************************************************************************************
|
|
|
+*/
|
|
|
+static uint8_t FSMC_NAND_ReadStatus(void)
|
|
|
+{
|
|
|
+ uint8_t ucData;
|
|
|
+ uint8_t ucStatus = NAND_BUSY;
|
|
|
+
|
|
|
+ /* 读状态操作 */
|
|
|
+ NAND_CMD_AREA = NAND_CMD_STATUS;
|
|
|
+ ucData = *(__IO uint8_t *)(Bank_NAND_ADDR);
|
|
|
+
|
|
|
+ if ((ucData & NAND_ERROR) == NAND_ERROR)
|
|
|
+ {
|
|
|
+ ucStatus = NAND_ERROR;
|
|
|
+ }
|
|
|
+ else if ((ucData & NAND_READY) == NAND_READY)
|
|
|
+ {
|
|
|
+ ucStatus = NAND_READY;
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ ucStatus = NAND_BUSY;
|
|
|
+ }
|
|
|
+
|
|
|
+ return (ucStatus);
|
|
|
+}
|
|
|
+
|
|
|
+/*
|
|
|
+*********************************************************************************************************
|
|
|
+* 函 数 名: FSMC_NAND_GetStatus
|
|
|
+* 功能说明: 获取NAND Flash操作状态
|
|
|
+* 形 参: - Address: 被擦除的快内任意地址
|
|
|
+* 返 回 值: NAND操作状态，有如下几种值：
|
|
|
+* - NAND_TIMEOUT_ERROR : 超时错误
|
|
|
+* - NAND_READY : 操作成功
|
|
|
+*********************************************************************************************************
|
|
|
+*/
|
|
|
+static uint8_t FSMC_NAND_GetStatus(void)
|
|
|
+{
|
|
|
+ uint32_t ulTimeout = 0x10000;
|
|
|
+ uint8_t ucStatus = NAND_READY;
|
|
|
+
|
|
|
+ ucStatus = FSMC_NAND_ReadStatus();
|
|
|
+
|
|
|
+ /* 等待NAND操作结束，超时后会退出 */
|
|
|
+ while ((ucStatus != NAND_READY) && (ulTimeout != 0x00))
|
|
|
+ {
|
|
|
+ ucStatus = FSMC_NAND_ReadStatus();
|
|
|
+ ulTimeout--;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (ulTimeout == 0x00)
|
|
|
+ {
|
|
|
+ ucStatus = NAND_TIMEOUT_ERROR;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* 返回操作状态 */
|
|
|
+ return (ucStatus);
|
|
|
+}
|
|
|
+
|
|
|
+/*
|
|
|
+*********************************************************************************************************
|
|
|
+* 函 数 名: nand_flash_init
|
|
|
+* 功能说明: 初始化NAND Flash接口
|
|
|
+* 形 参: 无
|
|
|
+* 返 回 值: 执行结果：
|
|
|
+* - NAND_FAIL 表示失败
|
|
|
+* - NAND_OK 表示成功
|
|
|
+*********************************************************************************************************
|
|
|
+*/
|
|
|
+uint8_t nand_flash_init(void)
|
|
|
+{
|
|
|
+ uint8_t Status;
|
|
|
+
|
|
|
+ FSMC_NAND_Init(); /* 配置FSMC和GPIO用于NAND Flash接口 */
|
|
|
+
|
|
|
+ FSMC_NAND_Reset(); /* 通过复位命令复位NAND Flash到读状态 */
|
|
|
+
|
|
|
+ Status = NAND_BuildLUT(); /* 建立块管理表 LUT = Look up table */
|
|
|
+ return Status;
|
|
|
+}
|
|
|
+
|
|
|
+/*
|
|
|
+*********************************************************************************************************
|
|
|
+* 函 数 名: NAND_WriteToNewBlock
|
|
|
+* 功能说明: 将旧块的数据复制到新块，并将新的数据段写入这个新块
|
|
|
+* 形 参: _ulPhyPageNo : 源页号
|
|
|
+* _pWriteBuf ： 数据缓冲区
|
|
|
+* _usOffset ： 页内偏移地址
|
|
|
+* _usSize ：数据长度，必须是4字节的整数倍
|
|
|
+* 返 回 值: 执行结果：
|
|
|
+* - NAND_FAIL 表示失败
|
|
|
+* - NAND_OK 表示成功
|
|
|
+*********************************************************************************************************
|
|
|
+*/
|
|
|
+uint8_t NAND_WriteToNewBlock(uint32_t _ulPhyPageNo, uint8_t *_pWriteBuf, uint16_t _usOffset, uint16_t _usSize)
|
|
|
+{
|
|
|
+ uint16_t n, i;
|
|
|
+ uint16_t usNewBlock;
|
|
|
+ uint16_t ulSrcBlock;
|
|
|
+ uint16_t usOffsetPageNo;
|
|
|
+
|
|
|
+ ulSrcBlock = _ulPhyPageNo / NAND_BLOCK_SIZE; /* 根据物理页号反推块号 */
|
|
|
+ usOffsetPageNo = _ulPhyPageNo % NAND_BLOCK_SIZE; /* 根据物理页号计算物理页号在块内偏移页号 */
|
|
|
+ /* 增加循环的目的是处理目标块为坏块的情况 */
|
|
|
+ for (n = 0; n < 10; n++)
|
|
|
+ {
|
|
|
+ /* 如果不是全0xFF， 则需要寻找一个空闲可用块，并将页内的数据全部移到新块中，然后擦除这个块 */
|
|
|
+ usNewBlock = NAND_FindFreeBlock(); /* 从最后一个Block开始，搜寻一个可用块 */
|
|
|
+ if (usNewBlock >= NAND_BLOCK_COUNT)
|
|
|
+ {
|
|
|
+ return NAND_FAIL; /* 查找空闲块失败 */
|
|
|
+ }
|
|
|
+
|
|
|
+ /* 使用page-copy功能，将当前块（usPBN）的数据全部搬移到新块（usNewBlock） */
|
|
|
+ for (i = 0; i < NAND_BLOCK_SIZE; i++)
|
|
|
+ {
|
|
|
+ if (i == usOffsetPageNo)
|
|
|
+ {
|
|
|
+ /* 如果写入的数据在当前页，则需要使用带随机数据的Copy-Back命令 */
|
|
|
+ if (FSMC_NAND_PageCopyBackEx(ulSrcBlock * NAND_BLOCK_SIZE + i, usNewBlock * NAND_BLOCK_SIZE + i,
|
|
|
+ _pWriteBuf, _usOffset, _usSize) == NAND_FAIL)
|
|
|
+ {
|
|
|
+ NAND_MarkBadBlock(usNewBlock); /* 将新块标记为坏块 */
|
|
|
+ NAND_BuildLUT(); /* 重建LUT表 */
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ /* 使用NAND Flash 提供的整页Copy-Back功能，可以显著提高操作效率 */
|
|
|
+ if (FSMC_NAND_PageCopyBack(ulSrcBlock * NAND_BLOCK_SIZE + i,
|
|
|
+ usNewBlock * NAND_BLOCK_SIZE + i) == NAND_FAIL)
|
|
|
+ {
|
|
|
+ NAND_MarkBadBlock(usNewBlock); /* 将新块标记为坏块 */
|
|
|
+ NAND_BuildLUT(); /* 重建LUT表 */
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ /* 目标块更新成功 */
|
|
|
+ if (i == NAND_BLOCK_SIZE)
|
|
|
+ {
|
|
|
+ /* 标记新块为已用块 */
|
|
|
+ if (NAND_MarkUsedBlock(usNewBlock) == NAND_FAIL)
|
|
|
+ {
|
|
|
+ NAND_MarkBadBlock(usNewBlock); /* 将新块标记为坏块 */
|
|
|
+ NAND_BuildLUT(); /* 重建LUT表 */
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* 擦除源BLOCK */
|
|
|
+ if (FSMC_NAND_EraseBlock(ulSrcBlock) != NAND_READY)
|
|
|
+ {
|
|
|
+ NAND_MarkBadBlock(ulSrcBlock); /* 将源块标记为坏块 */
|
|
|
+ NAND_BuildLUT(); /* 重建LUT表 */
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ NAND_BuildLUT(); /* 重建LUT表 */
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return NAND_OK; /* 写入成功 */
|
|
|
+}
|
|
|
+
|
|
|
+/*
|
|
|
+*********************************************************************************************************
|
|
|
+* 函 数 名: NAND_Write
|
|
|
+* 功能说明: 写一个扇区
|
|
|
+* 形 参: _MemAddr : 内存单元偏移地址
|
|
|
+* _pReadbuff ：存放待写数据的缓冲区的指针
|
|
|
+* _usSize ：数据长度，必须是4字节的整数倍
|
|
|
+* 返 回 值: 执行结果：
|
|
|
+* - NAND_FAIL 表示失败
|
|
|
+* - NAND_OK 表示成功
|
|
|
+*********************************************************************************************************
|
|
|
+*/
|
|
|
+uint8_t NAND_Write(uint32_t _ulMemAddr, uint32_t *_pWriteBuf, uint16_t _usSize)
|
|
|
+{
|
|
|
+ uint16_t usPBN; /* 物理块号 */
|
|
|
+ uint32_t ulPhyPageNo; /* 物理页号 */
|
|
|
+ uint16_t usAddrInPage; /* 页内偏移地址 */
|
|
|
+ uint32_t ulTemp;
|
|
|
+
|
|
|
+ /* 数据长度必须是4字节整数倍 */
|
|
|
+ if ((_usSize % 4) != 0)
|
|
|
+ {
|
|
|
+ return NAND_FAIL;
|
|
|
+ }
|
|
|
+ /* 数据长度不能超过512字节(遵循 Fat格式) */
|
|
|
+ if (_usSize > 512)
|
|
|
+ {
|
|
|
+ // return NAND_FAIL;
|
|
|
+ }
|
|
|
+
|
|
|
+ usPBN = NAND_AddrToPhyBlockNo(_ulMemAddr); /* 查询LUT表获得物理块号 */
|
|
|
+
|
|
|
+ ulTemp = _ulMemAddr % (NAND_BLOCK_SIZE * NAND_PAGE_SIZE);
|
|
|
+ ulPhyPageNo = usPBN * NAND_BLOCK_SIZE + ulTemp / NAND_PAGE_SIZE; /* 计算物理页号 */
|
|
|
+ usAddrInPage = ulTemp % NAND_PAGE_SIZE; /* 计算页内偏移地址 */
|
|
|
+
|
|
|
+ /* 读出扇区的内容，判断是否全FF */
|
|
|
+ if (FSMC_NAND_ReadData(s_ucTempBuf, ulPhyPageNo, usAddrInPage, _usSize) == NAND_FAIL)
|
|
|
+ {
|
|
|
+ return NAND_FAIL; /* 读NAND Flash失败 */
|
|
|
+ }
|
|
|
+ /* 如果是全0xFF, 则可以直接写入，无需擦除 */
|
|
|
+ if (NAND_IsBufOk(s_ucTempBuf, _usSize, 0xFF))
|
|
|
+ {
|
|
|
+ if (FSMC_NAND_WriteData((uint8_t *)_pWriteBuf, ulPhyPageNo, usAddrInPage, _usSize) == NAND_FAIL)
|
|
|
+ {
|
|
|
+ /* 将数据写入到另外一个块（空闲块） */
|
|
|
+ return NAND_WriteToNewBlock(ulPhyPageNo, (uint8_t *)_pWriteBuf, usAddrInPage, _usSize);
|
|
|
+ }
|
|
|
+
|
|
|
+ /* 标记该块已用 */
|
|
|
+ if (NAND_MarkUsedBlock(ulPhyPageNo) == NAND_FAIL)
|
|
|
+ {
|
|
|
+ /* 标记失败，将数据写入到另外一个块（空闲块） */
|
|
|
+ return NAND_WriteToNewBlock(ulPhyPageNo, (uint8_t *)_pWriteBuf, usAddrInPage, _usSize);
|
|
|
+ }
|
|
|
+ return NAND_OK; /* 写入成功 */
|
|
|
+ }
|
|
|
+
|
|
|
+ /* 将数据写入到另外一个块（空闲块） */
|
|
|
+ return NAND_WriteToNewBlock(ulPhyPageNo, (uint8_t *)_pWriteBuf, usAddrInPage, _usSize);
|
|
|
+}
|
|
|
+
|
|
|
+/*
|
|
|
+*********************************************************************************************************
|
|
|
+* 函 数 名: NAND_Read
|
|
|
+* 功能说明: 读一个扇区
|
|
|
+* 形 参: _MemAddr : 内存单元偏移地址
|
|
|
+* _pReadbuff ：存放读出数据的缓冲区的指针
|
|
|
+* _usSize ：数据长度，必须是4字节的整数倍
|
|
|
+* 返 回 值: 执行结果：
|
|
|
+* - NAND_FAIL 表示失败
|
|
|
+* - NAND_OK 表示成功
|
|
|
+*********************************************************************************************************
|
|
|
+*/
|
|
|
+uint8_t NAND_Read(uint32_t _ulMemAddr, uint32_t *_pReadBuf, uint16_t _usSize)
|
|
|
+{
|
|
|
+ uint16_t usPBN; /* 物理块号 */
|
|
|
+ uint32_t ulPhyPageNo; /* 物理页号 */
|
|
|
+ uint16_t usAddrInPage; /* 页内偏移地址 */
|
|
|
+ uint32_t ulTemp;
|
|
|
+
|
|
|
+ /* 数据长度必须是4字节整数倍 */
|
|
|
+ if ((_usSize % 4) != 0)
|
|
|
+ {
|
|
|
+ return NAND_FAIL;
|
|
|
+ }
|
|
|
+
|
|
|
+ usPBN = NAND_AddrToPhyBlockNo(_ulMemAddr); /* 查询LUT表获得物理块号 */
|
|
|
+ if (usPBN >= NAND_BLOCK_COUNT)
|
|
|
+ {
|
|
|
+ /* 没有格式化，usPBN = 0xFFFF */
|
|
|
+ return NAND_FAIL;
|
|
|
+ }
|
|
|
+
|
|
|
+ ulTemp = _ulMemAddr % (NAND_BLOCK_SIZE * NAND_PAGE_SIZE);
|
|
|
+ ulPhyPageNo = usPBN * NAND_BLOCK_SIZE + ulTemp / NAND_PAGE_SIZE; /* 计算物理页号 */
|
|
|
+ usAddrInPage = ulTemp % NAND_PAGE_SIZE; /* 计算页内偏移地址 */
|
|
|
+
|
|
|
+ if (FSMC_NAND_ReadData((uint8_t *)_pReadBuf, ulPhyPageNo, usAddrInPage, _usSize) == NAND_FAIL)
|
|
|
+ {
|
|
|
+ return NAND_FAIL; /* 读NAND Flash失败 */
|
|
|
+ }
|
|
|
+
|
|
|
+ /* 成功 */
|
|
|
+ return NAND_OK;
|
|
|
+}
|
|
|
+
|
|
|
+/*
|
|
|
+*********************************************************************************************************
|
|
|
+* 函 数 名: NAND_WriteMultiSectors
|
|
|
+* 功能说明: 该函数用于文件系统，连续写多个扇区数据。扇区大小可以是512字节或2048字节
|
|
|
+* 形 参: _pBuf : 存放数据的缓冲区的指针
|
|
|
+* _SectorNo ：扇区号
|
|
|
+* _SectorSize ：每个扇区的大小
|
|
|
+* _SectorCount : 扇区个数
|
|
|
+* 返 回 值: 执行结果：
|
|
|
+* - NAND_FAIL 表示失败
|
|
|
+* - NAND_OK 表示成功
|
|
|
+*********************************************************************************************************
|
|
|
+*/
|
|
|
+uint8_t NAND_WriteMultiSectors(uint8_t *_pBuf, uint32_t _SectorNo, uint16_t _SectorSize, uint32_t _SectorCount)
|
|
|
+{
|
|
|
+ uint32_t i;
|
|
|
+ uint32_t usLBN; /* 逻辑块号 */
|
|
|
+ uint32_t usPBN; /* 物理块号 */
|
|
|
+ uint32_t uiPhyPageNo; /* 物理页号 */
|
|
|
+ uint16_t usAddrInPage; /* 页内偏移地址 */
|
|
|
+ uint32_t ulTemp;
|
|
|
+ uint8_t ucReturn;
|
|
|
+
|
|
|
+ /*
|
|
|
+ HY27UF081G2A = 128M Flash. 有 1024个BLOCK, 每个BLOCK包含64个PAGE， 每个PAGE包含2048+64字节，
|
|
|
+ 擦除最小单位是BLOCK， 编程最小单位是字节。
|
|
|
+
|
|
|
+ 每个PAGE在逻辑上可以分为4个512字节扇区。
|
|
|
+ */
|
|
|
+
|
|
|
+ for (i = 0; i < _SectorCount; i++)
|
|
|
+ {
|
|
|
+ /* 根据逻辑扇区号和扇区大小计算逻辑块号 */
|
|
|
+ // usLBN = (_SectorNo * _SectorSize) / (NAND_BLOCK_SIZE * NAND_PAGE_SIZE);
|
|
|
+ /* (_SectorNo * _SectorSize) 乘积可能大于32位，因此换下面这种写法 */
|
|
|
+ usLBN = (_SectorNo + i) / (NAND_BLOCK_SIZE * (NAND_PAGE_SIZE / _SectorSize));
|
|
|
+ usPBN = NAND_LBNtoPBN(usLBN); /* 查询LUT表获得物理块号 */
|
|
|
+ if (usPBN >= NAND_BLOCK_COUNT)
|
|
|
+ {
|
|
|
+ /* 没有格式化，usPBN = 0xFFFF */
|
|
|
+ return NAND_FAIL;
|
|
|
+ }
|
|
|
+
|
|
|
+ // ulTemp = ((uint64_t)(_SectorNo + i) * _SectorSize) % (NAND_BLOCK_SIZE * NAND_PAGE_SIZE);
|
|
|
+ ulTemp = ((_SectorNo + i) % (NAND_BLOCK_SIZE * (NAND_PAGE_SIZE / _SectorSize))) * _SectorSize;
|
|
|
+ uiPhyPageNo = usPBN * NAND_BLOCK_SIZE + ulTemp / NAND_PAGE_SIZE; /* 计算物理页号 */
|
|
|
+ usAddrInPage = ulTemp % NAND_PAGE_SIZE; /* 计算页内偏移地址 */
|
|
|
+
|
|
|
+ /* 如果 _SectorCount > 0, 并且是页面首地址，则可以进行优化 */
|
|
|
+ if (usAddrInPage == 0)
|
|
|
+ {
|
|
|
+ /* 暂未处理 */
|
|
|
+ }
|
|
|
+
|
|
|
+ /* 读出扇区的内容，判断是否全FF */
|
|
|
+ if (FSMC_NAND_ReadData(s_ucTempBuf, uiPhyPageNo, usAddrInPage, _SectorSize) == NAND_FAIL)
|
|
|
+ {
|
|
|
+ return NAND_FAIL; /* 失败 */
|
|
|
+ }
|
|
|
+
|
|
|
+ /* 如果是全0xFF, 则可以直接写入，无需擦除 */
|
|
|
+ if (NAND_IsBufOk(s_ucTempBuf, _SectorSize, 0xFF))
|
|
|
+ {
|
|
|
+ if (FSMC_NAND_WriteData(&_pBuf[i * _SectorSize], uiPhyPageNo, usAddrInPage, _SectorSize) == NAND_FAIL)
|
|
|
+ {
|
|
|
+ /* 将数据写入到另外一个块（空闲块） */
|
|
|
+ ucReturn = NAND_WriteToNewBlock(uiPhyPageNo, &_pBuf[i * _SectorSize], usAddrInPage, _SectorSize);
|
|
|
+ if (ucReturn != NAND_OK)
|
|
|
+ {
|
|
|
+ return NAND_FAIL; /* 失败 */
|
|
|
+ }
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* 标记该块已用 */
|
|
|
+ if (NAND_MarkUsedBlock(uiPhyPageNo) == NAND_FAIL)
|
|
|
+ {
|
|
|
+ /* 标记失败，将数据写入到另外一个块（空闲块） */
|
|
|
+ ucReturn = NAND_WriteToNewBlock(uiPhyPageNo, &_pBuf[i * _SectorSize], usAddrInPage, _SectorSize);
|
|
|
+ if (ucReturn != NAND_OK)
|
|
|
+ {
|
|
|
+ return NAND_FAIL; /* 失败 */
|
|
|
+ }
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ else /* 目标区域已经有数据，不是全FF, 则直接将数据写入另外一个空闲块 */
|
|
|
+ {
|
|
|
+ /* 将数据写入到另外一个块（空闲块） */
|
|
|
+ ucReturn = NAND_WriteToNewBlock(uiPhyPageNo, &_pBuf[i * _SectorSize], usAddrInPage, _SectorSize);
|
|
|
+ if (ucReturn != NAND_OK)
|
|
|
+ {
|
|
|
+ return NAND_FAIL; /* 失败 */
|
|
|
+ }
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return NAND_OK; /* 成功 */
|
|
|
+}
|
|
|
+
|
|
|
+/*
|
|
|
+*********************************************************************************************************
|
|
|
+* 函 数 名: NAND_ReadMultiSectors
|
|
|
+* 功能说明: 该函数用于文件系统，按扇区读数据。读1个或多个扇区，扇区大小可以是512字节或2048字节
|
|
|
+* 形 参: _pBuf : 存放读出数据的缓冲区的指针
|
|
|
+* _SectorNo ：扇区号
|
|
|
+* _SectorSize ：每个扇区的大小
|
|
|
+* _SectorCount : 扇区个数
|
|
|
+* 返 回 值: 执行结果：
|
|
|
+* - NAND_FAIL 表示失败
|
|
|
+* - NAND_OK 表示成功
|
|
|
+*********************************************************************************************************
|
|
|
+*/
|
|
|
+uint8_t NAND_ReadMultiSectors(uint8_t *_pBuf, uint32_t _SectorNo, uint16_t _SectorSize, uint32_t _SectorCount)
|
|
|
+{
|
|
|
+ uint32_t i;
|
|
|
+ uint32_t usLBN; /* 逻辑块号 */
|
|
|
+ uint32_t usPBN; /* 物理块号 */
|
|
|
+ uint32_t uiPhyPageNo; /* 物理页号 */
|
|
|
+ uint16_t usAddrInPage; /* 页内偏移地址 */
|
|
|
+ uint32_t ulTemp;
|
|
|
+
|
|
|
+ /*
|
|
|
+ HY27UF081G2A = 128M Flash. 有 1024个BLOCK, 每个BLOCK包含64个PAGE， 每个PAGE包含2048+64字节，
|
|
|
+ 擦除最小单位是BLOCK， 编程最小单位是字节。
|
|
|
+
|
|
|
+ 每个PAGE在逻辑上可以分为4个512字节扇区。
|
|
|
+ */
|
|
|
+
|
|
|
+ for (i = 0; i < _SectorCount; i++)
|
|
|
+ {
|
|
|
+ /* 根据逻辑扇区号和扇区大小计算逻辑块号 */
|
|
|
+ // usLBN = (_SectorNo * _SectorSize) / (NAND_BLOCK_SIZE * NAND_PAGE_SIZE);
|
|
|
+ /* (_SectorNo * _SectorSize) 乘积可能大于32位，因此换下面这种写法 */
|
|
|
+ usLBN = (_SectorNo + i) / (NAND_BLOCK_SIZE * (NAND_PAGE_SIZE / _SectorSize));
|
|
|
+ usPBN = NAND_LBNtoPBN(usLBN); /* 查询LUT表获得物理块号 */
|
|
|
+ if (usPBN >= NAND_BLOCK_COUNT)
|
|
|
+ {
|
|
|
+ /* 没有格式化，usPBN = 0xFFFF */
|
|
|
+ return NAND_FAIL;
|
|
|
+ }
|
|
|
+
|
|
|
+ ulTemp = ((uint64_t)(_SectorNo + i) * _SectorSize) % (NAND_BLOCK_SIZE * NAND_PAGE_SIZE);
|
|
|
+ uiPhyPageNo = usPBN * NAND_BLOCK_SIZE + ulTemp / NAND_PAGE_SIZE; /* 计算物理页号 */
|
|
|
+ usAddrInPage = ulTemp % NAND_PAGE_SIZE; /* 计算页内偏移地址 */
|
|
|
+
|
|
|
+ if (FSMC_NAND_ReadData((uint8_t *)&_pBuf[i * _SectorSize], uiPhyPageNo, usAddrInPage, _SectorSize) == NAND_FAIL)
|
|
|
+ {
|
|
|
+ return NAND_FAIL; /* 读NAND Flash失败 */
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /* 成功 */
|
|
|
+ return NAND_OK;
|
|
|
+}
|
|
|
+
|
|
|
+/*
|
|
|
+*********************************************************************************************************
|
|
|
+* 函 数 名: NAND_BuildLUT
|
|
|
+* 功能说明: 在内存中创建坏块管理表
|
|
|
+* 形 参: ZoneNbr ：区号
|
|
|
+* 返 回 值: NAND_OK： 成功； NAND_FAIL：失败
|
|
|
+*********************************************************************************************************
|
|
|
+*/
|
|
|
+static uint8_t NAND_BuildLUT(void)
|
|
|
+{
|
|
|
+ uint16_t i;
|
|
|
+ uint8_t buf[VALID_SPARE_SIZE];
|
|
|
+ uint16_t usLBN; /* 逻辑块号 */
|
|
|
+
|
|
|
+ /* */
|
|
|
+ for (i = 0; i < NAND_BLOCK_COUNT; i++)
|
|
|
+ {
|
|
|
+ s_usLUT[i] = 0xFFFF; /* 填充无效值，用于重建LUT后，判断LUT是否合理 */
|
|
|
+ }
|
|
|
+ for (i = 0; i < NAND_BLOCK_COUNT; i++)
|
|
|
+ {
|
|
|
+ /* 读每个块的第1个PAGE，偏移地址为LBN0_OFFSET的数据 */
|
|
|
+ FSMC_NAND_ReadSpare(buf, i * NAND_BLOCK_SIZE, 0, VALID_SPARE_SIZE);
|
|
|
+
|
|
|
+ /* 如果是好块，则记录LBN0 LBN1 */
|
|
|
+ if (buf[BI_OFFSET] == 0xFF)
|
|
|
+ {
|
|
|
+ usLBN = buf[LBN0_OFFSET] + buf[LBN1_OFFSET] * 256; /* 计算读出的逻辑块号 */
|
|
|
+ if (usLBN < NAND_BLOCK_COUNT)
|
|
|
+ {
|
|
|
+ /* 如果已经登记过了，则判定为异常 */
|
|
|
+ if (s_usLUT[usLBN] != 0xFFFF)
|
|
|
+ {
|
|
|
+ return NAND_FAIL;
|
|
|
+ }
|
|
|
+
|
|
|
+ s_usLUT[usLBN] = i; /* 更新LUT表 */
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /* LUT建立完毕，检查是否合理 */
|
|
|
+ for (i = 0; i < NAND_BLOCK_COUNT; i++)
|
|
|
+ {
|
|
|
+ if (s_usLUT[i] >= NAND_BLOCK_COUNT)
|
|
|
+ {
|
|
|
+ s_usValidDataBlockCount = i;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (s_usValidDataBlockCount < 100)
|
|
|
+ {
|
|
|
+ /* 错误： 最大的有效逻辑块号小于100。可能是没有格式化 */
|
|
|
+ return NAND_FAIL;
|
|
|
+ }
|
|
|
+ for (; i < s_usValidDataBlockCount; i++)
|
|
|
+ {
|
|
|
+ if (s_usLUT[i] != 0xFFFF)
|
|
|
+ {
|
|
|
+ return NAND_FAIL; /* 错误：LUT表逻辑块号存在跳跃现象，可能是没有格式化 */
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /* 重建LUT正常 */
|
|
|
+ return NAND_OK;
|
|
|
+}
|
|
|
+
|
|
|
+/*
|
|
|
+*********************************************************************************************************
|
|
|
+* 函 数 名: NAND_AddrToPhyBlockNo
|
|
|
+* 功能说明: 内存逻辑地址转换为物理块号
|
|
|
+* 形 参: _ulMemAddr：逻辑内存地址
|
|
|
+* 返 回 值: 物理页号， 如果是 0xFFFFFFFF 则表示错误
|
|
|
+*********************************************************************************************************
|
|
|
+*/
|
|
|
+static uint16_t NAND_AddrToPhyBlockNo(uint32_t _ulMemAddr)
|
|
|
+{
|
|
|
+ uint16_t usLBN; /* 逻辑块号 */
|
|
|
+ uint16_t usPBN; /* 物理块号 */
|
|
|
+
|
|
|
+ usLBN = _ulMemAddr / (NAND_BLOCK_SIZE * NAND_PAGE_SIZE); /* 计算逻辑块号 */
|
|
|
+ /* 如果逻辑块号大于有效的数据块个数则固定返回0xFFFF, 调用该函数的代码应该检查出这种错误 */
|
|
|
+ if (usLBN >= s_usValidDataBlockCount)
|
|
|
+ {
|
|
|
+ return 0xFFFF;
|
|
|
+ }
|
|
|
+ /* 查询LUT表，获得物理块号 */
|
|
|
+ usPBN = s_usLUT[usLBN];
|
|
|
+ return usPBN;
|
|
|
+}
|
|
|
+
|
|
|
+/*
|
|
|
+*********************************************************************************************************
|
|
|
+* 函 数 名: NAND_LBNtoPBN
|
|
|
+* 功能说明: 逻辑块号转换为物理块号
|
|
|
+* 形 参: _uiLBN : 逻辑块号 Logic Block No
|
|
|
+* 返 回 值: 物理块号， 如果是 0xFFFFFFFF 则表示错误
|
|
|
+*********************************************************************************************************
|
|
|
+*/
|
|
|
+static uint16_t NAND_LBNtoPBN(uint32_t _uiLBN)
|
|
|
+{
|
|
|
+ uint16_t usPBN; /* 物理块号 */
|
|
|
+
|
|
|
+ /* 如果逻辑块号大于有效的数据块个数则固定返回0xFFFF, 调用该函数的代码应该检查出这种错误 */
|
|
|
+ if (_uiLBN >= s_usValidDataBlockCount)
|
|
|
+ {
|
|
|
+ return 0xFFFF;
|
|
|
+ }
|
|
|
+ /* 查询LUT表，获得物理块号 */
|
|
|
+ usPBN = s_usLUT[_uiLBN];
|
|
|
+ return usPBN;
|
|
|
+}
|
|
|
+
|
|
|
+/*
|
|
|
+*********************************************************************************************************
|
|
|
+* 函 数 名: NAND_FindFreeBlock
|
|
|
+* 功能说明: 从最后一个块开始，查找一个可用的块。
|
|
|
+* 形 参: ZoneNbr ：区号
|
|
|
+* 返 回 值: 块号，如果是0xFFFF表示失败
|
|
|
+*********************************************************************************************************
|
|
|
+*/
|
|
|
+static uint16_t NAND_FindFreeBlock(void)
|
|
|
+{
|
|
|
+ uint16_t i;
|
|
|
+ uint16_t n;
|
|
|
+
|
|
|
+ n = NAND_BLOCK_COUNT - 1;
|
|
|
+ for (i = 0; i < NAND_BLOCK_COUNT; i++)
|
|
|
+ {
|
|
|
+ if (NAND_IsFreeBlock(n))
|
|
|
+ {
|
|
|
+ return n;
|
|
|
+ }
|
|
|
+ n--;
|
|
|
+ }
|
|
|
+ return 0xFFFF;
|
|
|
+}
|
|
|
+
|
|
|
+/*
|
|
|
+*********************************************************************************************************
|
|
|
+* 函 数 名: NAND_IsBufOk
|
|
|
+* 功能说明: 判断内存缓冲区的数据是否全部为指定值
|
|
|
+* 形 参: - _pBuf : 输入缓冲区
|
|
|
+* - _ulLen : 缓冲区长度
|
|
|
+* - __ucValue : 缓冲区每个单元的正确数值
|
|
|
+* 返 回 值: 1 ：全部正确； 0 ：不正确
|
|
|
+*********************************************************************************************************
|
|
|
+*/
|
|
|
+static uint8_t NAND_IsBufOk(uint8_t *_pBuf, uint32_t _ulLen, uint8_t _ucValue)
|
|
|
+{
|
|
|
+ uint32_t i;
|
|
|
+
|
|
|
+ for (i = 0; i < _ulLen; i++)
|
|
|
+ {
|
|
|
+ if (_pBuf[i] != _ucValue)
|
|
|
+ {
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return 1;
|
|
|
+}
|
|
|
+
|
|
|
+/*
|
|
|
+*********************************************************************************************************
|
|
|
+* 函 数 名: NAND_IsBadBlock
|
|
|
+* 功能说明: 根据坏块标记检测NAND Flash指定的块是否坏块
|
|
|
+* 形 参: _ulBlockNo ：块号 0 - 1023 （对于128M字节，2K Page的NAND Flash，有1024个块）
|
|
|
+* 返 回 值: 0 ：该块可用； 1 ：该块是坏块
|
|
|
+*********************************************************************************************************
|
|
|
+*/
|
|
|
+uint8_t NAND_IsBadBlock(uint32_t _ulBlockNo)
|
|
|
+{
|
|
|
+ uint8_t ucFlag;
|
|
|
+
|
|
|
+ /* 如果NAND Flash出厂前已经标注为坏块了，则就认为是坏块 */
|
|
|
+ FSMC_NAND_ReadSpare(&ucFlag, _ulBlockNo * NAND_BLOCK_SIZE, BI_OFFSET, 1);
|
|
|
+ if (ucFlag != 0xFF)
|
|
|
+ {
|
|
|
+ return 1;
|
|
|
+ }
|
|
|
+
|
|
|
+ FSMC_NAND_ReadSpare(&ucFlag, _ulBlockNo * NAND_BLOCK_SIZE + 1, BI_OFFSET, 1);
|
|
|
+ if (ucFlag != 0xFF)
|
|
|
+ {
|
|
|
+ return 1;
|
|
|
+ }
|
|
|
+ return 0; /* 是好块 */
|
|
|
+}
|
|
|
+
|
|
|
+/*
|
|
|
+*********************************************************************************************************
|
|
|
+* 函 数 名: NAND_IsFreeBlock
|
|
|
+* 功能说明: 根据坏块标记和USED标志检测是否可用块
|
|
|
+* 形 参: _ulBlockNo ：块号 0 - 1023 （对于128M字节，2K Page的NAND Flash，有1024个块）
|
|
|
+* 返 回 值: 1 ：该块可用； 0 ：该块是坏块或者已占用
|
|
|
+*********************************************************************************************************
|
|
|
+*/
|
|
|
+static uint8_t NAND_IsFreeBlock(uint32_t _ulBlockNo)
|
|
|
+{
|
|
|
+ uint8_t ucFlag;
|
|
|
+
|
|
|
+ /* 如果NAND Flash出厂前已经标注为坏块了，则就认为是坏块 */
|
|
|
+ if (NAND_IsBadBlock(_ulBlockNo))
|
|
|
+ {
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ FSMC_NAND_ReadPage(&ucFlag, _ulBlockNo * NAND_BLOCK_SIZE, USED_OFFSET, 1);
|
|
|
+ if (ucFlag == 0xFF)
|
|
|
+ {
|
|
|
+ return 1;
|
|
|
+ }
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+/*
|
|
|
+*********************************************************************************************************
|
|
|
+* 函 数 名: NAND_ScanBlock
|
|
|
+* 功能说明: 扫描测试NAND Flash指定的块
|
|
|
+* 【扫描测试算法】
|
|
|
+* 1) 第1个块（包括主数据区和备用数据区），擦除后检测是否全0xFF, 正确的话继续测试改块，否则该块
|
|
|
+ 是坏块,函数返回
|
|
|
+* 2) 当前块写入全 0x00，然后读取检测，正确的话继续测试改块，否则退出
|
|
|
+* 3) 重复第（2）步；如果循环次数达50次都没有发生错误，那么该块正常,函数返回，否则该块是坏块，
|
|
|
+* 函数返回
|
|
|
+* 【注意】
|
|
|
+* 1) 该函数测试完毕后，会删除块内所有数据，即变为全0xFF;
|
|
|
+* 2) 该函数除了测试主数据区外，也对备用数据区进行测试。
|
|
|
+* 3) 擦写测试循环次数可以宏指定。#define BAD_BALOK_TEST_CYCLE 50
|
|
|
+* 形 参: _ulPageNo ：页号 0 - 65535 （对于128M字节，2K Page的NAND Flash，有1024个块）
|
|
|
+* 返 回 值: NAND_OK ：该块可用； NAND_FAIL ：该块是坏块
|
|
|
+*********************************************************************************************************
|
|
|
+*/
|
|
|
+uint8_t NAND_ScanBlock(uint32_t _ulBlockNo)
|
|
|
+{
|
|
|
+ uint32_t i, k;
|
|
|
+ uint32_t ulPageNo;
|
|
|
+
|
|
|
+#if 1
|
|
|
+ /* 如果NAND Flash出厂前已经标注为坏块了，则就认为是坏块 */
|
|
|
+ if (NAND_IsBadBlock(_ulBlockNo))
|
|
|
+ {
|
|
|
+ return NAND_FAIL;
|
|
|
+ }
|
|
|
+#endif
|
|
|
+
|
|
|
+ /* 下面的代码将通过反复擦除、编程的方式来测试NAND Flash每个块的可靠性 */
|
|
|
+ memset(s_ucTempBuf, 0x00, NAND_PAGE_TOTAL_SIZE);
|
|
|
+ for (i = 0; i < BAD_BALOK_TEST_CYCLE; i++)
|
|
|
+ {
|
|
|
+ /* 第1步：擦除这个块 */
|
|
|
+ if (FSMC_NAND_EraseBlock(_ulBlockNo) != NAND_READY)
|
|
|
+ {
|
|
|
+ return NAND_FAIL;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* 第2步：读出块内每个page的数据，并判断是否全0xFF */
|
|
|
+ ulPageNo = _ulBlockNo * NAND_BLOCK_SIZE; /* 计算该块第1个页的页号 */
|
|
|
+ for (k = 0; k < NAND_BLOCK_SIZE; k++)
|
|
|
+ {
|
|
|
+ /* 读出整页数据 */
|
|
|
+ FSMC_NAND_ReadPage(s_ucTempBuf, ulPageNo, 0, NAND_PAGE_TOTAL_SIZE);
|
|
|
+
|
|
|
+ /* 判断存储单元是不是全0xFF */
|
|
|
+ if (NAND_IsBufOk(s_ucTempBuf, NAND_PAGE_TOTAL_SIZE, 0xFF) != NAND_OK)
|
|
|
+ {
|
|
|
+ return NAND_FAIL;
|
|
|
+ }
|
|
|
+
|
|
|
+ ulPageNo++; /* 继续写下一个页 */
|
|
|
+ }
|
|
|
+
|
|
|
+ /* 第2步：写全0，并读回判断是否全0 */
|
|
|
+ ulPageNo = _ulBlockNo * NAND_BLOCK_SIZE; /* 计算该块第1个页的页号 */
|
|
|
+ for (k = 0; k < NAND_BLOCK_SIZE; k++)
|
|
|
+ {
|
|
|
+ /* 填充buf[]缓冲区为全0,并写入NAND Flash */
|
|
|
+ memset(s_ucTempBuf, 0x00, NAND_PAGE_TOTAL_SIZE);
|
|
|
+ if (FSMC_NAND_WritePage(s_ucTempBuf, ulPageNo, 0, NAND_PAGE_TOTAL_SIZE) != NAND_OK)
|
|
|
+ {
|
|
|
+ return NAND_FAIL;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* 读出整页数据, 判断存储单元是不是全0x00 */
|
|
|
+ FSMC_NAND_ReadPage(s_ucTempBuf, ulPageNo, 0, NAND_PAGE_TOTAL_SIZE);
|
|
|
+ if (NAND_IsBufOk(s_ucTempBuf, NAND_PAGE_TOTAL_SIZE, 0x00) != NAND_OK)
|
|
|
+ {
|
|
|
+ return NAND_FAIL;
|
|
|
+ }
|
|
|
+
|
|
|
+ ulPageNo++; /* 继续一个页 */
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /* 最后一步：擦除整个块 */
|
|
|
+ if (FSMC_NAND_EraseBlock(_ulBlockNo) != NAND_READY)
|
|
|
+ {
|
|
|
+ return NAND_FAIL;
|
|
|
+ }
|
|
|
+ ulPageNo = _ulBlockNo * NAND_BLOCK_SIZE; /* 计算该块第1个页的页号 */
|
|
|
+ for (k = 0; k < NAND_BLOCK_SIZE; k++)
|
|
|
+ {
|
|
|
+ /* 读出整页数据 */
|
|
|
+ FSMC_NAND_ReadPage(s_ucTempBuf, ulPageNo, 0, NAND_PAGE_TOTAL_SIZE);
|
|
|
+
|
|
|
+ /* 判断存储单元是不是全0xFF */
|
|
|
+ if (NAND_IsBufOk(s_ucTempBuf, NAND_PAGE_TOTAL_SIZE, 0xFF) != NAND_OK)
|
|
|
+ {
|
|
|
+ return NAND_FAIL;
|
|
|
+ }
|
|
|
+
|
|
|
+ ulPageNo++; /* 继续写下一个页 */
|
|
|
+ }
|
|
|
+
|
|
|
+ return NAND_OK;
|
|
|
+}
|
|
|
+
|
|
|
+/*
|
|
|
+*********************************************************************************************************
|
|
|
+* 函 数 名: NAND_MarkUsedBlock
|
|
|
+* 功能说明: 标记NAND Flash指定的块为已用块
|
|
|
+* 形 参: _ulBlockNo ：块号 0 - 1023 （对于128M字节，2K Page的NAND Flash，有1024个块）
|
|
|
+* 返 回 值: NAND_OK:标记成功； NAND_FAIL：标记失败，上级软件应该进行坏块处理。
|
|
|
+*********************************************************************************************************
|
|
|
+*/
|
|
|
+static uint8_t NAND_MarkUsedBlock(uint32_t _ulBlockNo)
|
|
|
+{
|
|
|
+ uint32_t ulPageNo;
|
|
|
+ uint8_t ucFlag;
|
|
|
+
|
|
|
+ /* 计算块的第1个页号 */
|
|
|
+ ulPageNo = _ulBlockNo * NAND_BLOCK_SIZE; /* 计算该块第1个页的页号 */
|
|
|
+
|
|
|
+ /* 块内第1个page备用区的第6个字节写入非0xFF数据表示坏块 */
|
|
|
+ ucFlag = NAND_USED_BLOCK_FLAG;
|
|
|
+ if (FSMC_NAND_WriteSpare(&ucFlag, ulPageNo, USED_OFFSET, 1) == NAND_FAIL)
|
|
|
+ {
|
|
|
+ /* 如果标记失败，则需要标注这个块为坏块 */
|
|
|
+ return NAND_FAIL;
|
|
|
+ }
|
|
|
+ return NAND_OK;
|
|
|
+}
|
|
|
+
|
|
|
+/*
|
|
|
+*********************************************************************************************************
|
|
|
+* 函 数 名: NAND_MarkBadBlock
|
|
|
+* 功能说明: 标记NAND Flash指定的块为坏块
|
|
|
+* 形 参: _ulBlockNo ：块号 0 - 1023 （对于128M字节，2K Page的NAND Flash，有1024个块）
|
|
|
+* 返 回 值: 固定NAND_OK
|
|
|
+*********************************************************************************************************
|
|
|
+*/
|
|
|
+static void NAND_MarkBadBlock(uint32_t _ulBlockNo)
|
|
|
+{
|
|
|
+ uint32_t ulPageNo;
|
|
|
+ uint8_t ucFlag;
|
|
|
+
|
|
|
+ /* 计算块的第1个页号 */
|
|
|
+ ulPageNo = _ulBlockNo * NAND_BLOCK_SIZE; /* 计算该块第1个页的页号 */
|
|
|
+
|
|
|
+ /* 块内第1个page备用区的第6个字节写入非0xFF数据表示坏块 */
|
|
|
+ ucFlag = NAND_BAD_BLOCK_FLAG;
|
|
|
+ if (FSMC_NAND_WriteSpare(&ucFlag, ulPageNo, BI_OFFSET, 1) == NAND_FAIL)
|
|
|
+ {
|
|
|
+ /* 如果第1个页标记失败，则在第2个页标记 */
|
|
|
+ FSMC_NAND_WriteSpare(&ucFlag, ulPageNo + 1, BI_OFFSET, 1);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*
|
|
|
+*********************************************************************************************************
|
|
|
+* 函 数 名: NAND_Format
|
|
|
+* 功能说明: NAND Flash格式化，擦除所有的数据，重建LUT
|
|
|
+* 形 参: 无
|
|
|
+* 返 回 值: NAND_OK : 成功； NAND_Fail ：失败（一般是坏块数量过多导致）
|
|
|
+*********************************************************************************************************
|
|
|
+*/
|
|
|
+uint8_t NAND_Format(void)
|
|
|
+{
|
|
|
+ uint16_t i, n;
|
|
|
+ uint16_t usGoodBlockCount;
|
|
|
+
|
|
|
+ /* 擦除每个块 */
|
|
|
+ usGoodBlockCount = 0;
|
|
|
+ for (i = 0; i < NAND_BLOCK_COUNT; i++)
|
|
|
+ {
|
|
|
+ /* 如果是好块，则擦除 */
|
|
|
+ if (!NAND_IsBadBlock(i))
|
|
|
+ {
|
|
|
+ FSMC_NAND_EraseBlock(i);
|
|
|
+ usGoodBlockCount++;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /* 如果好块的数量少于100，则NAND Flash报废 */
|
|
|
+ if (usGoodBlockCount < 100)
|
|
|
+ {
|
|
|
+ return NAND_FAIL;
|
|
|
+ }
|
|
|
+
|
|
|
+ usGoodBlockCount = (usGoodBlockCount * 98) / 100; /* 98%的好块用于存储数据 */
|
|
|
+
|
|
|
+ /* 重新搜索一次 */
|
|
|
+ n = 0; /* 统计已标注的好块 */
|
|
|
+ for (i = 0; i < NAND_BLOCK_COUNT; i++)
|
|
|
+ {
|
|
|
+ if (!NAND_IsBadBlock(i))
|
|
|
+ {
|
|
|
+ /* 如果是好块，则在该块的第1个PAGE的LBN0 LBN1处写入n值 (前面已经执行了块擦除） */
|
|
|
+ FSMC_NAND_WriteSpare((uint8_t *)&n, i * NAND_BLOCK_SIZE, LBN0_OFFSET, 2);
|
|
|
+ n++;
|
|
|
+
|
|
|
+ /* 计算并写入每个扇区的ECC值 （暂时未作）*/
|
|
|
+
|
|
|
+ if (n == usGoodBlockCount)
|
|
|
+ {
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ NAND_BuildLUT(); /* 初始化LUT表 */
|
|
|
+ return NAND_OK;
|
|
|
+}
|
|
|
+
|
|
|
+/*
|
|
|
+*********************************************************************************************************
|
|
|
+* 函 数 名: NAND_FormatCapacity
|
|
|
+* 功能说明: NAND Flash格式化后的有效容量
|
|
|
+* 形 参: 无
|
|
|
+* 返 回 值: NAND_OK : 成功； NAND_Fail ：失败（一般是坏块数量过多导致）
|
|
|
+*********************************************************************************************************
|
|
|
+*/
|
|
|
+uint32_t NAND_FormatCapacity(void)
|
|
|
+{
|
|
|
+ uint16_t usCount;
|
|
|
+
|
|
|
+ /* 计算用于存储数据的数据块个数，按照总有效块数的98%来计算 */
|
|
|
+ usCount = (s_usValidDataBlockCount * DATA_BLOCK_PERCENT) / 100;
|
|
|
+
|
|
|
+ return (usCount * NAND_BLOCK_SIZE * NAND_PAGE_SIZE);
|
|
|
+}
|
|
|
+
|
|
|
+/*
|
|
|
+*********************************************************************************************************
|
|
|
+* 函 数 名: NAND_DispBadBlockInfo
|
|
|
+* 功能说明: 通过串口打印出NAND Flash的坏块信息
|
|
|
+* 形 参: 无
|
|
|
+* 返 回 值: 无
|
|
|
+*********************************************************************************************************
|
|
|
+*/
|
|
|
+void NAND_DispBadBlockInfo(void)
|
|
|
+{
|
|
|
+ uint32_t id;
|
|
|
+ uint32_t i;
|
|
|
+ uint32_t n;
|
|
|
+
|
|
|
+ FSMC_NAND_Init(); /* 初始化FSMC */
|
|
|
+
|
|
|
+ id = NAND_ReadID();
|
|
|
+
|
|
|
+ printf("NAND Flash ID = 0x%04X, Type = ", id);
|
|
|
+ if (id == HY27UF081G2A)
|
|
|
+ {
|
|
|
+ printf("HY27UF081G2A\r\n 1024 Blocks, 64 pages per block, 2048 + 64 bytes per page\r\n");
|
|
|
+ }
|
|
|
+ else if (id == K9F1G08U0A)
|
|
|
+ {
|
|
|
+ printf("K9F1G08U0A\r\n 1024 Blocks, 64 pages per block, 2048 + 64 bytes per page\r\n");
|
|
|
+ }
|
|
|
+ else if (id == K9F1G08U0B)
|
|
|
+ {
|
|
|
+ printf("K9F1G08U0B\r\n 1024 Blocks, 64 pages per block, 2048 + 64 bytes per page\r\n");
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ printf("unkonow\r\n");
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ printf("Block Info : 0 is OK, * is Bad\r\n");
|
|
|
+ n = 0; /* 坏块统计 */
|
|
|
+ for (i = 0; i < NAND_BLOCK_COUNT; i++)
|
|
|
+ {
|
|
|
+ if (NAND_IsBadBlock(i))
|
|
|
+ {
|
|
|
+ printf("*");
|
|
|
+ n++;
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ printf("0");
|
|
|
+ }
|
|
|
+
|
|
|
+ if (((i + 1) % 8) == 0)
|
|
|
+ {
|
|
|
+ printf(" ");
|
|
|
+ }
|
|
|
+
|
|
|
+ if (((i + 1) % 64) == 0)
|
|
|
+ {
|
|
|
+ printf("\r\n");
|
|
|
+ }
|
|
|
+ }
|
|
|
+ printf("Bad Block Count = %d\r\n", n);
|
|
|
+}
|
|
|
+
|
|
|
+/*
|
|
|
+*********************************************************************************************************
|
|
|
+* 函 数 名: NAND_DispPhyPageData
|
|
|
+* 功能说明: 通过串口打印出指定页的数据（2048+64）
|
|
|
+* 形 参: _uiPhyPageNo ： 物理页号
|
|
|
+* 返 回 值: 无
|
|
|
+*********************************************************************************************************
|
|
|
+*/
|
|
|
+void NAND_DispPhyPageData(uint32_t _uiPhyPageNo)
|
|
|
+{
|
|
|
+ uint32_t i, n;
|
|
|
+ uint32_t ulBlockNo;
|
|
|
+ uint16_t usOffsetPageNo;
|
|
|
+
|
|
|
+ ulBlockNo = _uiPhyPageNo / NAND_BLOCK_SIZE; /* 根据物理页号反推块号 */
|
|
|
+ usOffsetPageNo = _uiPhyPageNo % NAND_BLOCK_SIZE; /* 根据物理页号计算物理页号在块内偏移页号 */
|
|
|
+
|
|
|
+ if (NAND_OK != FSMC_NAND_ReadPage(s_ucTempBuf, _uiPhyPageNo, 0, NAND_PAGE_TOTAL_SIZE))
|
|
|
+ {
|
|
|
+ printf("FSMC_NAND_ReadPage Failed() \r\n");
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ printf("Block = %d, Page = %d\r\n", ulBlockNo, usOffsetPageNo);
|
|
|
+
|
|
|
+ /* 打印前面 2048字节数据，每512字节空一行 */
|
|
|
+ for (n = 0; n < 4; n++)
|
|
|
+ {
|
|
|
+ for (i = 0; i < 512; i++)
|
|
|
+ {
|
|
|
+ printf(" %02X", s_ucTempBuf[i + n * 512]);
|
|
|
+
|
|
|
+ if ((i & 31) == 31)
|
|
|
+ {
|
|
|
+ printf("\r\n"); /* 每行显示32字节数据 */
|
|
|
+ }
|
|
|
+ else if ((i & 31) == 15)
|
|
|
+ {
|
|
|
+ printf(" - ");
|
|
|
+ }
|
|
|
+ }
|
|
|
+ printf("\r\n");
|
|
|
+ }
|
|
|
+
|
|
|
+ /* 打印前面 2048字节数据，每512字节空一行 */
|
|
|
+ for (i = 0; i < 64; i++)
|
|
|
+ {
|
|
|
+ printf(" %02X", s_ucTempBuf[i + 2048]);
|
|
|
+
|
|
|
+ if ((i & 15) == 15)
|
|
|
+ {
|
|
|
+ printf("\r\n"); /* 每行显示32字节数据 */
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/*
|
|
|
+*********************************************************************************************************
|
|
|
+* 函 数 名: NAND_DispLogicPageData
|
|
|
+* 功能说明: 通过串口打印出指定页的数据（2048+64）
|
|
|
+* 形 参: _uiLogicPageNo ： 逻辑页号
|
|
|
+* 返 回 值: 无
|
|
|
+*********************************************************************************************************
|
|
|
+*/
|
|
|
+void NAND_DispLogicPageData(uint32_t _uiLogicPageNo)
|
|
|
+{
|
|
|
+ uint32_t uiPhyPageNo;
|
|
|
+ uint16_t usLBN; /* 逻辑块号 */
|
|
|
+ uint16_t usPBN; /* 物理块号 */
|
|
|
+
|
|
|
+ usLBN = _uiLogicPageNo / NAND_BLOCK_SIZE;
|
|
|
+ usPBN = NAND_LBNtoPBN(usLBN); /* 查询LUT表获得物理块号 */
|
|
|
+ if (usPBN >= NAND_BLOCK_COUNT)
|
|
|
+ {
|
|
|
+ /* 没有格式化，usPBN = 0xFFFF */
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ printf("LogicBlock = %d, PhyBlock = %d\r\n", _uiLogicPageNo, usPBN);
|
|
|
+
|
|
|
+ /* 计算物理页号 */
|
|
|
+ uiPhyPageNo = usPBN * NAND_BLOCK_SIZE + _uiLogicPageNo % NAND_BLOCK_SIZE;
|
|
|
+ NAND_DispPhyPageData(uiPhyPageNo); /* 显示指定页数据 */
|
|
|
+}
|
|
|
+
|
|
|
+/***************************** 安富莱电子 www.armfly.com (END OF FILE) *********************************/
|
