/* ********************************************************************************************************* * * 模块名称 : 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) *********************************/