求助STM32读写NAND只能成功1Page

只看该作者 · 2013-11-15 08:36

第一页数据对的,第二页内容就不对了 NAND 型号是K9F1G08 已改成大页驱动

//头文件FSMC_NAND.H

#ifndef __FSMC_NAND_H
#define __FSMC_NAND_H
#define    __IO volatile

/* Includes ------------------------------------------------------------------*/
#include "stm32f10x_lib.h"

/* Exported types ------------------------------------------------------------*/
/* Includes ------------------------------------------------------------------*/

typedef unsigned short int  uint16_t;
typedef unsigned char    uint8_t;
typedef unsigned int       uint32_t;

typedef struct

{

uint8_t Maker_ID;

uint8_t Device_ID;

uint8_t Third_ID;

uint8_t Fourth_ID;

}NAND_IDTypeDef;

typedef struct

{

uint16_t Zone;

uint16_t Block;

uint16_t Page;

} NAND_ADDRESS;

/* Exported constants --------------------------------------------------------*/

/* NAND Area definitionfor STM3210E-EVAL Board RevD */

#define CMD_AREA (uint32_t)(1<<16)/* A16 = CLEhigh */

#define ADDR_AREA (uint32_t)(1<<17)/* A17 = ALE high */

#define DATA_AREA ((uint32_t)0x00000000)

/* FSMC NAND MEMORY command */

#define NAND_CMD_AREA_A ((uint8_t)0x00)

#define NAND_CMD_AREA_B ((uint8_t)0x01)

#define NAND_CMD_AREA_C ((uint8_t)0x50)

#define NAND_CMD_AREA_TRUE1 ((uint8_t)0x30)

#define NAND_CMD_WRITE0 ((uint8_t)0x80)

#define NAND_CMD_WRITE_TRUE1 ((uint8_t)0x10)

#define NAND_CMD_ERASE0 ((uint8_t)0x60)

#define NAND_CMD_ERASE1 ((uint8_t)0xD0)

#define NAND_CMD_READID ((uint8_t)0x90)

#define NAND_CMD_STATUS ((uint8_t)0x70)

#define NAND_CMD_LOCK_STATUS ((uint8_t)0x7A)

#define NAND_CMD_RESET ((uint8_t)0xFF)

/* NAND memory status */

#define NAND_VALID_ADDRESS ((uint32_t)0x00000100)

#define NAND_INVALID_ADDRESS ((uint32_t)0x00000200)

#define NAND_TIMEOUT_ERROR ((uint32_t)0x00000400)

#define NAND_BUSY ((uint32_t)0x00000000)

#define NAND_ERROR ((uint32_t)0x00000001)

#define NAND_READY ((uint32_t)0x00000040)

#define NAND_PAGE_SIZE ((uint16_t)0x0800) /* 2048 bytes per page w/o Spare Area */

#define NAND_BLOCK_SIZE ((uint16_t)0x0040) /* 64x2048 bytes pages per block */

#define NAND_ZONE_SIZE ((uint16_t)0x0400) /* 1024 Block per zone */

#define NAND_SPARE_AREA_SIZE ((uint16_t)0x0040) /* last 64 bytes as spare area */

#define NAND_MAX_ZONE ((uint16_t)0x0001) /* 1 zones of 1024 block */

/* FSMC NAND memory address computation */

#define ADDR_1st_CYCLE(ADDR) (uint8_t)((ADDR)& 0xFF) /* 1st addressing cycle */

#define ADDR_2nd_CYCLE(ADDR) (uint8_t)(((ADDR)& 0xFF00) >> 8) /* 2nd addressing cycle */

#define ADDR_3rd_CYCLE(ADDR) (uint8_t)(((ADDR)& 0xFF0000) >> 16) /* 3rd addressing cycle */

#define ADDR_4th_CYCLE(ADDR) (uint8_t)(((ADDR)& 0xFF000000) >> 24) /* 4th addressing cycle */
void FSMC_NAND_Init(void);
void FSMC_NAND_ReadID(NAND_IDTypeDef* NAND_ID);
uint32_t FSMC_NAND_WriteSmallPage(uint8_t  *pBuffer, NAND_ADDRESS Address, uint32_t  NumPageToWrite);
uint32_t FSMC_NAND_ReadSmallPage (uint8_t *pBuffer, NAND_ADDRESS Address, uint32_t NumPageToRead);
u32 FSMC_NAND_WriteSpareArea(u8 *pBuffer, NAND_ADDRESS Address, u32 NumSpareAreaTowrite);
u32 FSMC_NAND_ReadSpareArea(u8 *pBuffer, NAND_ADDRESS Address, u32 NumSpareAreaToRead);
uint32_t FSMC_NAND_EraseBlock(NAND_ADDRESS Address);
u32 FSMC_NAND_Reset(void);
uint32_t FSMC_NAND_GetStatus(void);
uint32_t FSMC_NAND_ReadStatus(void);
uint32_t FSMC_NAND_AddressIncrement(NAND_ADDRESS* Address);

#endif /* __FSMC_NAND_H */

/******************* (C) COPYRIGHT 2008 STMicroelectronics *****END OF FILE****/

只看该作者 · 2013-11-15 08:37

//fsmc_nand.c
#include "fsmc_nand.h"

/* Private typedef -----------------------------------------------------------*/
/* Private define ------------------------------------------------------------*/

#define FSMC_Bank_NAND    FSMC_Bank2_NAND
#define Bank_NAND_ADDR    Bank2_NAND_ADDR
#define Bank2_NAND_ADDR ((uint32_t)0x70000000)

/* Private macro -------------------------------------------------------------*/
#define ROW_ADDRESS (Address.Page + (Address.Block + (Address.Zone * NAND_ZONE_SIZE)) * NAND_BLOCK_SIZE)

#include "stm32f10x_it.h"

/*volatile unsigned long time_delay;

void delay_us(volatile unsigned long nus)
{
if(Systick_Config(SystemFrequency/1000000))
{
while(1);
}
time_delay=nus;
while(time_delay);
SysTick->CTRL=0x00;
SysTick->VAL=0x00;

}*/

/* Private variables ---------------------------------------------------------*/
/* Private function prototypes -----------------------------------------------*/
/* Private functions ---------------------------------------------------------*/
/*******************************************************************************
* Function Name  : FSMC_NAND_Init
* Description : Configures the FSMC and GPIOs to interface with the NAND memory.
*                This function must be called before any write/read operation
*                on the NAND.
* Input       : None
* Output       : None
* Return       : None
*******************************************************************************/
void FSMC_NAND_Init(void)
{
  GPIO_InitTypeDef GPIO_InitStructure;
  FSMC_NANDInitTypeDef FSMC_NANDInitStructure;
  FSMC_NAND_PCCARDTimingInitTypeDef  p;

  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD | RCC_APB2Periph_GPIOE |
                     RCC_APB2Periph_GPIOF | RCC_APB2Periph_GPIOG, ENABLE);

/*-- GPIO Configuration ------------------------------------------------------*/
/* CLE, ALE, D0->D3, NOE, NWE and NCE2  NAND pin configuration  */
  GPIO_InitStructure.GPIO_Pin =  GPIO_Pin_11 | GPIO_Pin_12 | GPIO_Pin_14 | GPIO_Pin_15 |
                              GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_4 | GPIO_Pin_5 |
                              GPIO_Pin_7;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;

  GPIO_Init(GPIOD, &GPIO_InitStructure);

/* D4->D7 NAND pin configuration  */
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7 | GPIO_Pin_8 | GPIO_Pin_9 | GPIO_Pin_10;

  GPIO_Init(GPIOE, &GPIO_InitStructure);

/* NWAIT NAND pin configuration */
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;

  GPIO_Init(GPIOD, &GPIO_InitStructure);

/* INT2 NAND pin configuration */
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;
  GPIO_Init(GPIOG, &GPIO_InitStructure);

  /*-- FSMC Configuration ------------------------------------------------------*/
  p.FSMC_SetupTime = 0x1;
  p.FSMC_WaitSetupTime = 0x3;
  p.FSMC_HoldSetupTime = 0x2;
  p.FSMC_HiZSetupTime = 0x1;

  FSMC_NANDInitStructure.FSMC_Bank = FSMC_Bank2_NAND;
  FSMC_NANDInitStructure.FSMC_Waitfeature = FSMC_Waitfeature_Enable;
  FSMC_NANDInitStructure.FSMC_MemoryDataWidth = FSMC_MemoryDataWidth_8b;
  FSMC_NANDInitStructure.FSMC_ECC = FSMC_ECC_Enable;
  FSMC_NANDInitStructure.FSMC_ECCPageSize = FSMC_ECCPageSize_2048Bytes;
  FSMC_NANDInitStructure.FSMC_AddressLowMapping = FSMC_AddressLowMapping_Direct;
  FSMC_NANDInitStructure.FSMC_TCLRSetupTime = 0x00;
  FSMC_NANDInitStructure.FSMC_TARSetupTime = 0x00;
  FSMC_NANDInitStructure.FSMC_CommonSpaceTimingStruct = &p;
  FSMC_NANDInitStructure.FSMC_AttributeSpaceTimingStruct = &p;

  FSMC_NANDInit(&FSMC_NANDInitStructure);

  /* FSMC NAND Bank Cmd Test */
  FSMC_NANDCmd(FSMC_Bank2_NAND, ENABLE);
}

/******************************************************************************
* Function Name  : FSMC_NAND_ReadID
* Description : Reads NAND memory's ID.
* Input       : - NAND_ID: pointer to a NAND_IDTypeDef structure which will hold
*                   the Manufacturer and Device ID.
* Output       : None
* Return       : None
*******************************************************************************/
void FSMC_NAND_ReadID(NAND_IDTypeDef* NAND_ID)
{
uint32_t data = 0;
  /*!< Send Command to the command area */
  *(__IO uint8_t *)(Bank_NAND_ADDR | CMD_AREA) = 0x90;
  *(__IO uint8_t *)(Bank_NAND_ADDR | ADDR_AREA) = 0x00;
/*!< Sequence to read ID from NAND flash */
data = *(__IO uint32_t *)(Bank_NAND_ADDR | DATA_AREA);
NAND_ID->Maker_ID = ADDR_1st_CYCLE (data);//四个周期读取四个ID
NAND_ID->Device_ID  = ADDR_2nd_CYCLE (data);
NAND_ID->Third_ID = ADDR_3rd_CYCLE (data);
NAND_ID->Fourth_ID  = ADDR_4th_CYCLE (data);
}

/******************************************************************************
* Function Name  : FSMC_NAND_WriteSmallPage
* Description : This routine is for writing one or several 512 Bytes Page size.
* Input       : - pBuffer: pointer on the Buffer containing data to be written
*                - Address: First page address
*                - NumPageToWrite: Number of page to write
* Output       : None
* Return       : New status of the NAND operation. This parameter can be:
*                - NAND_TIMEOUT_ERROR: when the previous operation generate
*                   a Timeout error
*                - NAND_READY: when memory is ready for the next operation
*                And the new status of the increment address operation. It can be:
*                - NAND_VALID_ADDRESS: When the new address is valid address
*                - NAND_INVALID_ADDRESS: When the new address is invalid address
*******************************************************************************/
uint32_t FSMC_NAND_WriteSmallPage(uint8_t *pBuffer, NAND_ADDRESS Address, uint32_t NumPageToWrite)
{
  uint32_t index = 0x00, numpagewritten = 0x00, addressstatus = NAND_VALID_ADDRESS;
  uint32_t status = NAND_READY, size = 0x00;
  while((NumPageToWrite != 0x00) && (addressstatus == NAND_VALID_ADDRESS) && (status == NAND_READY))
  {
/* Page write command and address */
*(__IO uint8_t *)(Bank_NAND_ADDR | CMD_AREA) = NAND_CMD_AREA_A;
*(__IO uint8_t *)(Bank_NAND_ADDR | CMD_AREA) = NAND_CMD_WRITE0;
*(__IO uint8_t *)(Bank_NAND_ADDR | ADDR_AREA) = 0x00;
*(__IO uint8_t *)(Bank_NAND_ADDR | ADDR_AREA) = ADDR_1st_CYCLE(ROW_ADDRESS); //
*(__IO uint8_t *)(Bank_NAND_ADDR | ADDR_AREA) = ADDR_2nd_CYCLE(ROW_ADDRESS); //
*(__IO uint8_t *)(Bank_NAND_ADDR | ADDR_AREA) = ADDR_3rd_CYCLE(ROW_ADDRESS); //更改
*(__IO uint8_t *)(Bank_NAND_ADDR | ADDR_AREA) = ADDR_4th_CYCLE(ROW_ADDRESS); //
/* Calculate the size */
size = NAND_PAGE_SIZE + (NAND_PAGE_SIZE * numpagewritten);
/* Write data */
for(; index < size; index++)
{
   *(__IO uint8_t *)(Bank_NAND_ADDR | DATA_AREA) = pBuffer[index];
}
*(__IO uint8_t *)(Bank_NAND_ADDR | CMD_AREA) = NAND_CMD_WRITE_TRUE1;
/* Check status for successful operation */
status = FSMC_NAND_GetStatus();
if(status == NAND_READY)
{
   numpagewritten++;
   NumPageToWrite--;
   /* Calculate Next small page Address */
   addressstatus = FSMC_NAND_AddressIncrement(&Address);
}
  }

  return (status | addressstatus);
}

/******************************************************************************
* Function Name  : FSMC_NAND_ReadSmallPage
* Description : This routine is for sequential read from one or several
*                512 Bytes Page size.
* Input       : - pBuffer: pointer on the Buffer to fill
*                - Address: First page address
*                - NumPageToRead: Number of page to read
* Output       : None
* Return       : New status of the NAND operation. This parameter can be:
*                - NAND_TIMEOUT_ERROR: when the previous operation generate
*                   a Timeout error
*                - NAND_READY: when memory is ready for the next operation
*                And the new status of the increment address operation. It can be:
*                - NAND_VALID_ADDRESS: When the new address is valid address
*                - NAND_INVALID_ADDRESS: When the new address is invalid address
*******************************************************************************/

void delay_us(u16 time)
{
u16 i=0;
while(time--)
{
i=10;
while(i--);
}
}

uint32_t FSMC_NAND_ReadSmallPage(uint8_t *pBuffer, NAND_ADDRESS Address, uint32_t  NumPageToRead)
{
  uint32_t index = 0x00, numpageread = 0x00, addressstatus = NAND_VALID_ADDRESS;
  uint32_t status = NAND_READY, size = 0x00;
  while((NumPageToRead != 0x0) && (addressstatus == NAND_VALID_ADDRESS))
  {
/* Page Read command and page address */
*(__IO uint8_t *)(Bank_NAND_ADDR | CMD_AREA) = NAND_CMD_AREA_A; //地址
*(__IO uint8_t *)(Bank_NAND_ADDR | ADDR_AREA) = 0x00;  //命令
*(__IO uint8_t *)(Bank_NAND_ADDR | ADDR_AREA) = ADDR_1st_CYCLE(ROW_ADDRESS);
*(__IO uint8_t *)(Bank_NAND_ADDR | ADDR_AREA) = ADDR_2nd_CYCLE(ROW_ADDRESS); //访问地址
*(__IO uint8_t *)(Bank_NAND_ADDR | ADDR_AREA) = ADDR_3rd_CYCLE(ROW_ADDRESS);
*(__IO uint8_t *)(Bank_NAND_ADDR | ADDR_AREA) = ADDR_4th_CYCLE(ROW_ADDRESS);
*(__IO uint8_t *)(Bank_NAND_ADDR | CMD_AREA) = NAND_CMD_AREA_TRUE1;  //命令
delay_us(15);
/* Calculate the size */
size = NAND_PAGE_SIZE + (NAND_PAGE_SIZE * numpageread);
/* Get Data into Buffer */
for(index=0x00; index < size; index++)
{
   pBuffer[index]= *(__IO uint8_t *)(Bank_NAND_ADDR | DATA_AREA);
}
numpageread++;
NumPageToRead--;
/* Calculate page address */
addressstatus = FSMC_NAND_AddressIncrement(&Address);
  }
  status = FSMC_NAND_GetStatus();
  return (status | addressstatus);
}

/******************************************************************************
* Function Name  : FSMC_NAND_WriteSpareArea
* Description : This routine write the spare area information for the specified
*                pages addresses.
* Input       : - pBuffer: pointer on the Buffer containing data to be written
*                - Address: First page address
*                - NumSpareAreaTowrite: Number of Spare Area to write
* Output       : None
* Return       : New status of the NAND operation. This parameter can be:
*                - NAND_TIMEOUT_ERROR: when the previous operation generate
*                   a Timeout error
*                - NAND_READY: when memory is ready for the next operation
*                And the new status of the increment address operation. It can be:
*                - NAND_VALID_ADDRESS: When the new address is valid address
*                - NAND_INVALID_ADDRESS: When the new address is invalid address
*******************************************************************************/
u32 FSMC_NAND_WriteSpareArea(u8 *pBuffer, NAND_ADDRESS Address, u32 NumSpareAreaTowrite)
{
  u32 index = 0x00, numsparesreawritten = 0x00, addressstatus = NAND_VALID_ADDRESS;
  u32 status = NAND_READY, size = 0x00;

  while((NumSpareAreaTowrite != 0x00) && (addressstatus == NAND_VALID_ADDRESS) && (status == NAND_READY))
  {
/* Page write Spare area command and address */
*(vu8 *)(Bank_NAND_ADDR | CMD_AREA) = NAND_CMD_AREA_C;
*(vu8 *)(Bank_NAND_ADDR | CMD_AREA) = NAND_CMD_WRITE0;

*(vu8 *)(Bank_NAND_ADDR | ADDR_AREA) = 0x00;
*(vu8 *)(Bank_NAND_ADDR | ADDR_AREA) = ADDR_1st_CYCLE(ROW_ADDRESS);
*(vu8 *)(Bank_NAND_ADDR | ADDR_AREA) = ADDR_2nd_CYCLE(ROW_ADDRESS);
*(vu8 *)(Bank_NAND_ADDR | ADDR_AREA) = ADDR_3rd_CYCLE(ROW_ADDRESS);

/* Calculate the size */
size = NAND_SPARE_AREA_SIZE + (NAND_SPARE_AREA_SIZE * numsparesreawritten);

/* Write the data */
for(; index < size; index++)
{
   *(vu8 *)(Bank_NAND_ADDR | DATA_AREA) = pBuffer[index];
}

*(vu8 *)(Bank_NAND_ADDR | CMD_AREA) = NAND_CMD_WRITE_TRUE1;

/* Check status for successful operation */
status = FSMC_NAND_GetStatus();

if(status == NAND_READY)
{
   numsparesreawritten++;

   NumSpareAreaTowrite--;

   /* Calculate Next page Address */
   addressstatus = FSMC_NAND_AddressIncrement(&Address);
}
  }

  return (status | addressstatus);
}

/******************************************************************************
* Function Name  : FSMC_NAND_ReadSpareArea
* Description : This routine read the spare area information from the specified
*                pages addresses.
* Input       : - pBuffer: pointer on the Buffer to fill
*                - Address: First page address
*                - NumSpareAreaToRead: Number of Spare Area to read
* Output       : None
* Return       : New status of the NAND operation. This parameter can be:
*                - NAND_TIMEOUT_ERROR: when the previous operation generate
*                   a Timeout error
*                - NAND_READY: when memory is ready for the next operation
*                And the new status of the increment address operation. It can be:
*                - NAND_VALID_ADDRESS: When the new address is valid address
*                - NAND_INVALID_ADDRESS: When the new address is invalid address
*******************************************************************************/
u32 FSMC_NAND_ReadSpareArea(u8 *pBuffer, NAND_ADDRESS Address, u32 NumSpareAreaToRead)
{
  u32 numsparearearead = 0x00, index = 0x00, addressstatus = NAND_VALID_ADDRESS;
  u32 status = NAND_READY, size = 0x00;

  while((NumSpareAreaToRead != 0x0) && (addressstatus == NAND_VALID_ADDRESS))
  {
/* Page Read command and page address */
*(vu8 *)(Bank_NAND_ADDR | CMD_AREA) = NAND_CMD_AREA_C;

*(vu8 *)(Bank_NAND_ADDR | ADDR_AREA) = 0x00;
*(vu8 *)(Bank_NAND_ADDR | ADDR_AREA) = ADDR_1st_CYCLE(ROW_ADDRESS);
*(vu8 *)(Bank_NAND_ADDR | ADDR_AREA) = ADDR_2nd_CYCLE(ROW_ADDRESS);
*(vu8 *)(Bank_NAND_ADDR | ADDR_AREA) = ADDR_3rd_CYCLE(ROW_ADDRESS);

*(vu8 *)(Bank_NAND_ADDR | CMD_AREA) = NAND_CMD_AREA_TRUE1;

/* Data Read */
size = NAND_SPARE_AREA_SIZE +  (NAND_SPARE_AREA_SIZE * numsparearearead);

/* Get Data into Buffer */
for ( ;index < size; index++)
{
   pBuffer[index] = *(vu8 *)(Bank_NAND_ADDR | DATA_AREA);
}

numsparearearead++;

NumSpareAreaToRead--;

/* Calculate page address */
addressstatus = FSMC_NAND_AddressIncrement(&Address);
  }

  status = FSMC_NAND_GetStatus();

  return (status | addressstatus);
}

/******************************************************************************
* Function Name  : FSMC_NAND_EraseBlock
* Description : This routine erase complete block from NAND FLASH
* Input       : - Address: Any address into block to be erased
* Output       : None
* Return       : New status of the NAND operation. This parameter can be:
*                - NAND_TIMEOUT_ERROR: when the previous operation generate
*                   a Timeout error
*                - NAND_READY: when memory is ready for the next operation
*******************************************************************************/
uint32_t FSMC_NAND_EraseBlock(NAND_ADDRESS Address)
{
  *(__IO uint8_t *)(Bank_NAND_ADDR | CMD_AREA) = NAND_CMD_ERASE0;
  *(__IO uint8_t *)(Bank_NAND_ADDR | ADDR_AREA) = ADDR_3rd_CYCLE(ROW_ADDRESS);
  *(__IO uint8_t *)(Bank_NAND_ADDR | ADDR_AREA) = ADDR_4th_CYCLE(ROW_ADDRESS);
  *(__IO uint8_t *)(Bank_NAND_ADDR | CMD_AREA) = NAND_CMD_ERASE1;
  return (FSMC_NAND_GetStatus());
}

/******************************************************************************
* Function Name  : FSMC_NAND_Reset
* Description : This routine reset the NAND FLASH
* Input       : None
* Output       : None
* Return       : NAND_READY
*******************************************************************************/
u32 FSMC_NAND_Reset(void)
{
  *(vu8 *)(Bank_NAND_ADDR | CMD_AREA) = NAND_CMD_RESET;

  return (NAND_READY);
}

/******************************************************************************
* Function Name  : FSMC_NAND_GetStatus
* Description : Get the NAND operation status
* Input       : None
* Output       : None
* Return       : New status of the NAND operation. This parameter can be:
*                - NAND_TIMEOUT_ERROR: when the previous operation generate
*                   a Timeout error
*                - NAND_READY: when memory is ready for the next operation
*******************************************************************************/
uint32_t FSMC_NAND_GetStatus(void)
{
  __IO uint32_t timeout = 0x1000000, status = NAND_READY;

  status = FSMC_NAND_ReadStatus();

  /* Wait for a NAND operation to complete or a TIMEOUT to occur */
  while ((status != NAND_READY) &&( timeout != 0x00))
  {
   status = FSMC_NAND_ReadStatus();
   timeout --;
  }

  if(timeout == 0x00)
  {
status =  NAND_TIMEOUT_ERROR;
  }

  /* Return the operation status */
  return (status);
}
/******************************************************************************
* Function Name  : FSMC_NAND_ReadStatus
* Description : Reads the NAND memory status using the Read status command
* Input       : None
* Output       : None
* Return       : The status of the NAND memory. This parameter can be:
*                - NAND_BUSY: when memory is busy
*                - NAND_READY: when memory is ready for the next operation
*                - NAND_ERROR: when the previous operation gererates error
*******************************************************************************/
uint32_t FSMC_NAND_ReadStatus(void)
{
  uint32_t data = 0x00, status = NAND_BUSY;

  /* Read status operation ------------------------------------ */
  *(__IO uint8_t *)(Bank_NAND_ADDR | CMD_AREA) = NAND_CMD_STATUS;
  data = *(__IO uint8_t *)(Bank_NAND_ADDR);

  if((data & NAND_ERROR) == NAND_ERROR)
  {
status = NAND_ERROR;
  }
  else if((data & NAND_READY) == NAND_READY)
  {
status = NAND_READY;
  }
  else
  {
status = NAND_BUSY;
  }

  return (status);
}

/******************************************************************************
* Function Name  : NAND_AddressIncrement
* Description : Increment the NAND memory address
* Input       : - Address: address to be incremented.
* Output       : None
* Return       : The new status of the increment address operation. It can be:
*                - NAND_VALID_ADDRESS: When the new address is valid address
*                - NAND_INVALID_ADDRESS: When the new address is invalid address
*******************************************************************************/
uint32_t FSMC_NAND_AddressIncrement(NAND_ADDRESS* Address)
{
  uint32_t status = NAND_VALID_ADDRESS;

  Address->Page++;

  if(Address->Page == NAND_BLOCK_SIZE)
  {
Address->Page = 0;
Address->Block++;

if(Address->Block == NAND_ZONE_SIZE)
{
   Address->Block = 0;
   Address->Zone++;

   if(Address->Zone == NAND_MAX_ZONE)
   {
      status = NAND_INVALID_ADDRESS;
   }
}
  }

  return (status);
}

只看该作者 · 2013-11-15 08:39

/*******************************************************************************
* File Name       : main.c
* Author          : POWER AVR
* Date First Issued  : 08/08/2008
* Description       : Main program body
********************************************************************************/

/* Includes ------------------------------------------------------------------*/
#include "stm32f10x_lib.h"
#include <stdio.h>
#include "fsmc_nand.h"

#define BUFFER_SIZE  0x800
/* Private typedef -----------------------------------------------------------*/
/* Private define ------------------------------------------------------------*/
/* Private macro -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/

uint8_t  lastblock=10,Flag=0x0,BUF[2][BUFFER_SIZE];//声明全局变量，此处不能够赋值
u16 PageNumber=0,RXId=0x0,WId=0x0,USART_RX_STA=0x0;//声明全局变量，此处不能够赋值

/* Private macro -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
NAND_IDTypeDef NAND_ID;
GPIO_InitTypeDef GPIO_InitStructure;
NAND_ADDRESS WriteReadAddr;

ErrorStatus HSEStartUpStatus;
__IO uint32_t status= 0,status1=0;

/* Private function prototypes -----------------------------------------------*/
void RCC_Configuration(void);
void NVIC_Configuration(void);
void GPIO_Configuration(void);
void USART_Configuration(void);

/* Private functions ---------------------------------------------------------*/

/*******************************************************************************
* Function Name  : main
* Description : Main program.
* Input       : None
* Output       : None
* Return       : None
*******************************************************************************/
int main(void)
{
uint16_t i=0,h=0;

#ifdef DEBUG
  debug();
#endif

  /* Configure the system clocks */
  RCC_Configuration();

  /* NVIC Configuration */
  NVIC_Configuration();

  /* Configure the GPIOs */
  GPIO_Configuration();

  /* Configure the USART1 */
  USART_Configuration();

/* PF.06, PF.07 and PF.08  config to drive LD1, LD2 and LD3 *****************/
  /* Enable GPIOF clock */
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOF, ENABLE);

  /* Configure PF.06, PF.07 and PF.08 as Output push-pull */
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6 | GPIO_Pin_7 | GPIO_Pin_8;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
  GPIO_Init(GPIOF, &GPIO_InitStructure);
  GPIO_SetBits(GPIOF,GPIO_Pin_6 | GPIO_Pin_7 | GPIO_Pin_8);

  /* Enable the FSMC Clock */
  RCC_AHBPeriphClockCmd(RCC_AHBPeriph_FSMC, ENABLE);

  FSMC_NAND_Init();

  /* NAND read ID command */
  FSMC_NAND_ReadID(&NAND_ID);

  printf("\r\n Start \r\n");

  while(1)
  {
if (Flag==1)
{ Flag=0;
      GPIO_ResetBits(GPIOF, GPIO_Pin_7);
      h=PageNumber/64;
i=PageNumber-(PageNumber*h);

      WriteReadAddr.Zone = 0x00;
      WriteReadAddr.Block = h;
WriteReadAddr.Page = i;

if(lastblock!=h)
{
lastblock=h;
//GPIO_ResetBits(GPIOF, GPIO_Pin_6);
status = FSMC_NAND_EraseBlock(WriteReadAddr);
//printf("Erase %d: %d \r\n",status);
//GPIO_SetBits(GPIOF, GPIO_Pin_6);
}
WriteReadAddr.Zone = 0x00;
      WriteReadAddr.Block = h;
      WriteReadAddr.Page = 0;

status1 = FSMC_NAND_WriteSmallPage(BUF[0], WriteReadAddr, 1);
WriteReadAddr.Zone = 0x00;
      WriteReadAddr.Block = h;
      WriteReadAddr.Page = 1;
status1 = FSMC_NAND_WriteSmallPage(BUF[1], WriteReadAddr, 1);
//printf("%d,%d\r\n",status,status1);
PageNumber++;
if(PageNumber==2048)
printf("\r\n Ok \r\n");
GPIO_SetBits(GPIOF, GPIO_Pin_7);
}
  }

}

#ifdef  DEBUG
/*******************************************************************************
* Function Name  : assert_failed
* Description : Reports the name of the source file and the source line number
*                where the assert error has occurred.
* Input       : - file: pointer to the source file name
*                - line: assert error line source number
* Output       : None
* Return       : None
*******************************************************************************/
void assert_failed(u8* file, u32 line)
{
  /* User can add his own implementation to report the file name and line number */

  printf("\n\r Wrong parameter value detected on\r\n");
  printf("    file  %s\r\n", file);
  printf("    line  %d\r\n", line);

  /* Infinite loop */
  /* while (1)
  {
  } */
}
#endif

/*******************************************************************************
* Function Name  : RCC_Configuration
* Description : Configures the different system clocks.
* Input       : None
* Output       : None
* Return       : None
*******************************************************************************/
void RCC_Configuration(void)
{
  /* RCC system reset(for debug purpose) */
  RCC_DeInit();

  /* Enable HSE */
  RCC_HSEConfig(RCC_HSE_ON);

  /* Wait till HSE is ready */
  HSEStartUpStatus = RCC_WaitForHSEStartUp();

  if(HSEStartUpStatus == SUCCESS)
  {
/* HCLK = SYSCLK */
RCC_HCLKConfig(RCC_SYSCLK_Div1);

/* PCLK2 = HCLK */
RCC_PCLK2Config(RCC_HCLK_Div1);

/* PCLK1 = HCLK/2 */
RCC_PCLK1Config(RCC_HCLK_Div2);

/* Flash 2 wait state */
FLASH_SetLatency(FLASH_Latency_2);
/* Enable Prefetch Buffer */
FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable);

/* PLLCLK = 8MHz * 9 = 72 MHz */
RCC_PLLConfig(RCC_PLLSource_HSE_Div1, RCC_PLLMul_9);

/* Enable PLL */
RCC_PLLCmd(ENABLE);

/* Wait till PLL is ready */
while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET)
{
}

/* Select PLL as system clock source */
RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);

/* Wait till PLL is used as system clock source */
while(RCC_GetSYSCLKSource() != 0x08)
{
}
  }

  /* Enable USART1 and GPIOA clock */
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1 | RCC_APB2Periph_GPIOA, ENABLE);
}

/*******************************************************************************
* Function Name  : NVIC_Configuration
* Description : Configures Vector Table base location.
* Input       : None
* Output       : None
* Return       : None
*******************************************************************************/
void NVIC_Configuration(void)
{
  NVIC_InitTypeDef NVIC_InitStructure;
  NVIC_PriorityGroupConfig(NVIC_PriorityGroup_0);//选择分组方式0

  NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQChannel;
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  NVIC_Init(&NVIC_InitStructure);
}

/*******************************************************************************
* Function Name  : GPIO_Configuration
* Description : Configures the different GPIO ports.
* Input       : None
* Output       : None
* Return       : None
*******************************************************************************/
void GPIO_Configuration(void)
{
  GPIO_InitTypeDef GPIO_InitStructure;

  /* Configure USART1 Tx (PA.09) as alternate function push-pull */
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_Init(GPIOA, &GPIO_InitStructure);

  /* Configure USART1 Rx (PA.10) as input floating */
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
  GPIO_Init(GPIOA, &GPIO_InitStructure);
}

/*******************************************************************************
* Function Name  : USART_Configuration
* Description : Configures the USART1.
* Input       : None
* Output       : None
* Return       : None
*******************************************************************************/
void USART_Configuration(void)
{
  USART_InitTypeDef USART_InitStructure;
  USART_ClockInitTypeDef  USART_ClockInitStructure;
/* USART1 configuration -----------------------------------------------

-------*/
  /* USART1 configured as follow:
      - BaudRate = 115200 baud
      - Word Length = 8 Bits
      - One Stop Bit
      - No parity
      - Hardware flow control disabled (RTS and CTS signals)
      - Receive and transmit enabled
      - USART Clock disabled
      - USART CPOL: Clock is active low
      - USART CPHA: Data is captured on the middle
      - USART LastBit: The clock pulse of the last data bit is not

output to
                     the SCLK pin
  */
USART_ClockInitStructure.USART_Clock = USART_Clock_Disable;
USART_ClockInitStructure.USART_CPOL = USART_CPOL_Low;
USART_ClockInitStructure.USART_CPHA = USART_CPHA_2Edge;
USART_ClockInitStructure.USART_LastBit = USART_LastBit_Disable;
/* Configure the USART1 synchronous paramters */
USART_ClockInit(USART1, &USART_ClockInitStructure);

USART_InitStructure.USART_BaudRate = 9600;
USART_InitStructure.USART_WordLength = USART_WordLength_8b;
USART_InitStructure.USART_StopBits = USART_StopBits_1;
USART_InitStructure.USART_Parity = USART_Parity_No ;
USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
/* Configure USART1 basic and asynchronous paramters */
USART_Init(USART1, &USART_InitStructure);

  /* Enable USART1 */

USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);
USART_Cmd(USART1, ENABLE);
}

/*******************************************************************************
* Function Name  : fputc
* Description : Retargets the C library printf function to the USART.
* Input       : None
* Output       : None
* Return       : None
*******************************************************************************/
int fputc(int ch, FILE *f)
{
  /* Place your implementation of fputc here */
  /* e.g. write a character to the USART */
  USART_SendData(USART1, (u8) ch);

  /* Loop until the end of transmission */
  while(USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET)
  {
  }

  return ch;
}

/******************* (C) COPYRIGHT 2007 STMicroelectronics *****END OF FILE****/

只看该作者 · 2013-11-20 15:28

我的哥哥，建议看数据手册，比你发真些代码强多了

求助STM32读写NAND只能成功1Page

相关下载

相关帖子

技术高手奖章

常驻人口