FLASH_W25Q64 驱动简介

W25Q64FV是一款FLASH存储芯片，由32768页组成的存储芯片，其中每一页有256字节。

每次最多可以一次写入256字节（一页）；擦除则可以按扇区进行擦除(一个扇区16页，4KB字节），或者可以按128个页进行擦除（32KB），或者可以按256个页（64KB）进行擦除，以及整个芯片擦除方式进行擦除。

W25Q64FV支持标准的同步串行通信协议（SPI），下面简单举例介绍其常用的驱动程序：

数据定义：

#ifndef __W25Q64Driver_H
#define __W25Q64Driver_H

//ID
#define W25Q64                          0xEF16

// W25Q64 Registors
#define W25Q64_WRITE_ENABLE_CMD         0X06
#define W25Q64_WRITE_DISABLE_CMD            0x04
#define W25Q64_rSTATUS_REG_CMD          0x05
#define  W25Q64_wSTATUS_REG_CMD         0x01
#define W25Q64_READ_DARA_CMD            0x03
#define W25Q64_FAST_READ_DATA_CMD       0x0B
#define W25Q64_FAST_READ_DUAL_CMD       0x3B
#define W25Q64_PAGE_WRITE_CMD           0x02
#define W25Q64_BLOCK_ERASE_CMD          0xD8
#define W25Q64_SECTOR_ERASE_CMD         0x20
#define W25Q64_CHIP_ERASE_CMD           0xC7
#define W25Q64_PWR_DOWN_CMD             0xB9
#define W25Q64_RELEASE_PWR_DOWN_CMD     0xAB

#define W25Q64_DEVICE_ID                0xAB
#define W25Q64_MANUFACT_ID              0x90
#define W25Q64_JEDEC_DEVICE_ID          0x9F




//Block0 64K 
#define Block0_Header_Addr      0x000000
#define Block0_Tail_Addr           0x00FFFF

//... Block N ...

//Block127 64K 
#define Block127_Header_Addr      0x7F0000
#define Block127_Tail_Addr           0x7FFFFF


void SPI_Interface_Init(void);
unsigned char WReadSPI2(unsigned char byinput);
void W25Q64_PageRead(unsigned char *pOutBuf,unsigned long Addr,unsigned int NumByte);
void W25Q64_PageWrite(unsigned char *pInputBuf,unsigned long Addr,unsigned int NumBytes);
void W25Q64_nPageWrite(unsigned char *pInputbuf,unsigned long Addr,unsigned int NumBytes);
void W25Q64_Sector_Erase(unsigned long Addr);
void W25Q64_Block_Erase(unsigned long Addr);


#endif

功能函数实现：

#include"stdio.h"  
#include"string.h"

#include"IO_Port.h"
#include"W25Q64Driver.h"


void SPI_Interface_Init(void)
{
  P3SEL |=  BIT1+BIT2+BIT3;           //option select. P3.1Master out;P3.2Master in ;P3.3Master CLK out
                                      
  UCB0CTL1 |= UCSWRST;                // **Put state machine in reset**
  UCB0IE=0X00;
  
  UCB0CTL0 |= UCMST+UCSYNC+UCCKPH+UCMSB;    //3-pin, 8-bit SPI master clk polarity select the inactive state is low
            /*
                /---------------------------// SPI master
                       /--------------------//Synchronous mode
                              /-------------//date captured on the first UCLK edge change flow edge
                                      /-----//MSB first
          */ 
  UCB0CTL1 |= UCSSEL_2;                     //SMCLK Sourse
  UCB0BR0 = 0x02;                           // /2
  UCB0BR1 = 0;                              // No modulation
                           
  UCB0CTL1 &= ~UCSWRST;                //Initialize USCI state machine;clearing this bit releases the USCI for opertion
  
  //EE_WP_High;              //release write protect;LOW ACTIVE
  EE_CS_Low;               //LOW ACTIVE
}
/*--------------------------------------------------
*read SPI2               
*parameter: data to write  
*return: data to read      
//-------------------------------------------------*/
unsigned char WReadSPI2(unsigned char byinput)
{ 
  unsigned char i;
  while(!(UCB0IFG&UCTXIFG));        //TXBUF Ready?  
  UCB0TXBUF=byinput;                //TXIFG automatically reset when a character is writen the the txbuf
  while(!(UCB0IFG&UCRXIFG));        //wait data has mvoed to TX shift register.
  i=UCB0RXBUF;
  return i;
}
/*
 7   6  5  4   3   2   1   0
SPR RV TB BP2 BP1 BP0 WEL BUSY
SPR:
TB BP2 BP1 BP0：FLASH
WEL：
BUSY：
*/
unsigned char W25Q64_ReadSR(void)
{
  unsigned char status=0;
  EE_CS_Low;
  WReadSPI2(W25Q64_rSTATUS_REG_CMD);//05
  status=WReadSPI2(0xFF);
  EE_CS_High;
  return status;
}
//SPR TB BP2 BP1 BP0 (bit,5,4,3,2)
void W25Q64_WriteSR(unsigned char SetReg)
{
  EE_CS_Low;
  WReadSPI2(W25Q64_wSTATUS_REG_CMD);
  WReadSPI2(SetReg);
  EE_CS_Low;
}
//WEL
void W25Q64_WriteEnable(void)
{
  EE_CS_Low;
  WReadSPI2(W25Q64_WRITE_ENABLE_CMD);
  EE_CS_High;
}
//WEL
void W25Q64_WriteDisable(void)
{
  EE_CS_Low;
  WReadSPI2(W25Q64_WRITE_DISABLE_CMD);
  EE_CS_High;
}
void W25Q64_Wait_Busy(void)
{
  while((W25Q64_ReadSR()&0x01)==0x01);
}
//pOutBuf：buffer
//Addr：24bit）
//NumByte：
void W25Q64_PageRead(unsigned char *pOutBuf,unsigned long Addr,unsigned int NumByte)
{
  EE_CS_Low;
  //$03 this cmd allows one or more data bytes to be sequentially read from the memory.
  WReadSPI2(W25Q64_READ_DARA_CMD);
  WReadSPI2((Addr&0x00ff0000)>>16);
  WReadSPI2((Addr&0x0000ff00)>>8);
  WReadSPI2(Addr&0x000000ff);
  while(NumByte--)
  {
    *pOutBuf++ = WReadSPI2(0xFF);
  }
  EE_CS_High;
}
//pInputBuf:
//Addr：
//NumBytes:
void W25Q64_PageWrite(unsigned char *pInputBuf,unsigned long Addr,unsigned int NumBytes)
{
  W25Q64_WriteEnable(); //WEL=1
  EE_CS_Low;
  //$02 this cmd allows one byte or 256 bytes(a page) 0f data to be programmed 
  //    at previously erased memory locations.
  WReadSPI2(W25Q64_PAGE_WRITE_CMD);
  WReadSPI2((Addr&0x00ff0000)>>16);
  WReadSPI2((Addr&0x0000ff00)>>8);
  WReadSPI2(Addr&0x000000ff);
  while(NumBytes--)
  {
    WReadSPI2(*pInputBuf++);
  }
  EE_CS_High;
  W25Q64_Wait_Busy();
}
//pInputBuf:
//Addr：
//NumBytes:
void W25Q64_nPageWrite(unsigned char *pInputbuf,unsigned long Addr,unsigned int NumBytes)
{
  unsigned int PageRestCount;
  PageRestCount=256-Addr%256; 
  if(NumBytes<=PageRestCount)
    PageRestCount=NumBytes;
  while(1)
  {
    W25Q64_PageWrite(pInputbuf,Addr,PageRestCount);
    if(NumBytes==PageRestCount)
      break;
    else 
    {
      pInputbuf += PageRestCount;
      Addr += PageRestCount;
      NumBytes-=PageRestCount;
      if(NumBytes > 256)
      {
        PageRestCount=256;
      }
      else
      {
        PageRestCount=NumBytes;
      }
    }
  }
}
//Addr
//erase a sector(4K )
void W25Q64_Sector_Erase(unsigned long Addr)
{
  W25Q64_WriteEnable(); //WEL=1
  W25Q64_Wait_Busy();
  Addr<<=12;
  EE_CS_Low;
  
  WReadSPI2(W25Q64_SECTOR_ERASE_CMD);
  WReadSPI2((Addr&0x00ff0000)>>16);
  WReadSPI2((Addr&0x0000ff00)>>8);
  WReadSPI2(Addr&0x000000ff);
  EE_CS_High;
  W25Q64_Wait_Busy();
}
//BLOCK区
//Addr 
//vBlock: Block 
//erase a block(64K  )
void W25Q64_Block_Erase(unsigned long Addr)
{
  W25Q64_WriteEnable(); //WEL=1
  W25Q64_Wait_Busy();
  Addr<<=16;
  EE_CS_Low;
  
  WReadSPI2(W25Q64_BLOCK_ERASE_CMD);
  WReadSPI2((Addr&0x00ff0000)>>16);
  WReadSPI2((Addr&0x0000ff00)>>8);
  WReadSPI2(Addr&0x000000ff);
  EE_CS_High;
  W25Q64_Wait_Busy();
}


//about 1 min
void W25Q64_ChipErase(void)
{
  W25Q64_WriteEnable(); //WEL=1
  W25Q64_Wait_Busy();
  EE_CS_Low;
  //$c7 The instruction sets all memory within the device to the erased state of all FFh
  WReadSPI2(W25Q64_CHIP_ERASE_CMD);
  EE_CS_High;
  
  W25Q64_Wait_Busy();
}
//Power Down mode
void W25Q64_Power_Down()
{
  EE_CS_Low;
  WReadSPI2(W25Q64_PWR_DOWN_CMD);
  EE_CS_High;
}
//Weka up Mode
void W25Q64_ReleasePowerDown(void)
{
  EE_CS_Low;
  WReadSPI2(W25Q64_RELEASE_PWR_DOWN_CMD);
  EE_CS_High;
}
//ID
unsigned int W25Q64_ReadID(void)
{
  unsigned int tmp=0;
  EE_CS_Low;
  WReadSPI2(0x90);
  WReadSPI2(0x00);
  WReadSPI2(0x00);
  WReadSPI2(0x00);
  tmp|=WReadSPI2(0xFF)<<8;
  tmp|=WReadSPI2(0xFF);
  EE_CS_High;
  return tmp;
}

//------------------------------- End-------------------------------------------

仅供参考，谢谢！