|
/******************************************************************************
|
* Copyright (C) 2014-2015 HangZhou SiZhu Co.,LTD.
|
*
|
*-----------------------------------------------------------------------------
|
* File: w25x40bv.c
|
* Description: FLASH operation code
|
* Author: Lishoujian (867693272@qq.com)
|
* Date: Jan 8, 2015
|
*****************************************************************************/
|
|
/* ----------------------- Platform includes --------------------------------*/
|
|
#include "w25x40bv.h"
|
#include "spi.h"
|
#include "delay.h"
|
|
|
/******************************************
|
* func: Flash_ReadSR
|
* desc: read 1 byte status data from flash
|
* input: none
|
* output: none
|
* return: 1 byte status data read from flash
|
*****************************************/
|
u8 Flash_ReadSR(void)
|
{
|
u8 byte=0;
|
FLASH_CS_LOW;
|
FLASH_ReadWriteByte(FLASH_RDSR); //send read status register instructon
|
byte=FLASH_ReadWriteByte(0Xff);
|
FLASH_CS_HIGH;
|
return byte;
|
}
|
|
/******************************************
|
* func: FLASH_Write_SR
|
* desc: write 1 byte status data to flash
|
* input:
|
* data - 1 byte state data to fram status register
|
* output: none
|
* return: none
|
*****************************************/
|
void FLASH_Write_SR(u8 sr)
|
{
|
FLASH_Write_Enable();
|
FLASH_CS_LOW;
|
FLASH_ReadWriteByte(FLASH_WRSR); //send write status register instructon
|
FLASH_ReadWriteByte(sr);
|
FLASH_CS_HIGH;
|
}
|
|
/******************************************
|
* func: FLASH_Write_Enable
|
* desc: write enable flash.
|
* input: none
|
* output: none
|
* return: none
|
*****************************************/
|
void FLASH_Write_Enable(void)
|
{
|
FLASH_CS_LOW;
|
FLASH_ReadWriteByte(FLASH_WREN); //send write enable instruction
|
FLASH_CS_HIGH;
|
}
|
|
/******************************************
|
* func: FLASH_Write_Disable
|
* desc: write disable flash
|
* input: none
|
* output: none
|
* return: none
|
*****************************************/
|
void FLASH_Write_Disable(void)
|
{
|
FLASH_CS_LOW;
|
FLASH_ReadWriteByte(FLASH_WRDI); //send write disable instruction
|
FLASH_CS_HIGH;
|
}
|
|
/******************************************
|
* func: Flash_ReadID
|
* desc: read 16bit ID from flash
|
* input: none
|
* output: none
|
* return: ID - 16bit Manufacturer ID/Device ID
|
*****************************************/
|
u16 Flash_ReadID(void)
|
{
|
u16 ID = 0;
|
FLASH_CS_LOW;
|
FLASH_ReadWriteByte(FLASH_RDID);//send
|
FLASH_ReadWriteByte(0x00);
|
FLASH_ReadWriteByte(0x00);
|
FLASH_ReadWriteByte(0x00);
|
ID|=FLASH_ReadWriteByte(0xFF)<<8;
|
ID|=FLASH_ReadWriteByte(0xFF);
|
FLASH_CS_HIGH;
|
return ID;
|
}
|
|
/******************************************
|
* func: Flash_Read
|
* desc: read one or one more data bytes from flash
|
* input: pBuffer-data read from flash
|
ReadAddr-32bit input address,just send the front 24bit
|
NumByteToRead-decide how many bytes to read
|
* output: none
|
* return: none
|
*****************************************/
|
void Flash_Read(uint8* pBuffer,uint32 ReadAddr,uint16 NumByteToRead)
|
{
|
u16 i;
|
FLASH_CS_LOW;
|
FLASH_ReadWriteByte(FLASH_READ); //send read command
|
FLASH_ReadWriteByte((u8)((ReadAddr)>>16)); //send 24bit address
|
FLASH_ReadWriteByte((u8)((ReadAddr)>>8));
|
FLASH_ReadWriteByte((u8)ReadAddr);
|
for(i=0;i<NumByteToRead;i++)
|
{
|
pBuffer[i]=FLASH_ReadWriteByte(0XFF);
|
}
|
FLASH_CS_HIGH;
|
}
|
|
|
|
/******************************************
|
* func: Flash_Write
|
* desc: write data into flash,can write more than 256 bytes,and can executed sector erase operation.
|
* input: pBuffer-data write into flash
|
ReadAddr-32bit input address,just send the front 24bit
|
NumByteToRead-decide how many bytes to write
|
* output: none
|
* return: none
|
*****************************************/
|
/*u8 FLASH_BUF[4096];
|
void Flash_Write(uint8* pBuffer,uint32 WriteAddr,uint16 NumByteToWrite)
|
{
|
u32 secpos;
|
u16 secoff;
|
u16 secremain;
|
u16 i;
|
|
secpos=WriteAddr/4096; //sector address 0~127 for w25x40bv
|
secoff=WriteAddr%4096; //sector offset
|
secremain=4096-secoff; //remaining space of sector
|
|
if(NumByteToWrite<=secremain)secremain=NumByteToWrite;//no more than 4096 bytes
|
while(1)
|
{
|
Flash_Read(FLASH_BUF,secpos*4096,4096); //read all data from sector
|
for(i=0;i<secremain;i++) //check data
|
{
|
if(FLASH_BUF[secoff+i]!=0XFF)break;
|
}
|
if(i<secremain)
|
{
|
Flash_Erase_Sector(secpos); //sector erase
|
for(i=0;i<secremain;i++) //write data
|
{
|
FLASH_BUF[i+secoff]=pBuffer[i];
|
}
|
Flash_Write_NoCheck(FLASH_BUF,secpos*4096,4096); //write data into sector
|
|
}
|
else Flash_Write_NoCheck(pBuffer,WriteAddr,secremain);
|
if(NumByteToWrite==secremain)break; //write finish
|
else //write unfinish
|
{
|
secpos++; //sector address add 1
|
secoff=0; //sector offset 0
|
|
pBuffer+=secremain; //pointer offset
|
WriteAddr+=secremain; //write address offset
|
NumByteToWrite-=secremain; //the number of bytes reduce
|
if(NumByteToWrite>4096)secremain=4096; //write operation can't be finished in next sector
|
else secremain=NumByteToWrite; //write operation can be finished in next sector
|
}
|
};
|
}*/
|
|
/******************************************
|
* func: Flash_Write_NoCheck
|
* desc: write data into flash,can write more than 256 bytes.(we must delete the precious data before write)
|
* input: pBuffer-data write into flash
|
ReadAddr-32bit input address,just send the front 24bit
|
NumByteToRead-decide how many bytes to write
|
* output: none
|
* return: none
|
*****************************************/
|
void Flash_Write_NoCheck(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite)
|
{
|
u16 pageremain;
|
pageremain=256-WriteAddr%256; //remaining space of page
|
if(NumByteToWrite<=pageremain)pageremain=NumByteToWrite;//no more than 256B
|
while(1)
|
{
|
Flash_Write_Page(pBuffer,WriteAddr,pageremain);
|
if(NumByteToWrite==pageremain)break; //write finish
|
else //NumByteToWrite>pageremain
|
{
|
pBuffer+=pageremain;
|
WriteAddr+=pageremain;
|
|
NumByteToWrite-=pageremain;
|
if(NumByteToWrite>256)pageremain=256; //write operation can't be finished in next page
|
else pageremain=NumByteToWrite; //write operation can be finished in next page
|
}
|
}
|
}
|
|
/******************************************
|
* func: Flash_Write_Page
|
* desc: write data less than 256 bytes into flash.(we must delete the precious data before write)
|
* input: pBuffer-data write into flash
|
ReadAddr-32bit input address,just send the front 24bit
|
NumByteToRead-decide how many bytes to write
|
* output: none
|
* return: none
|
*****************************************/
|
void Flash_Write_Page(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite)
|
{
|
u16 i;
|
FLASH_Write_Enable(); //write enable
|
FLASH_CS_LOW;
|
FLASH_ReadWriteByte(FLASH_WRITE); //send write command
|
FLASH_ReadWriteByte((u8)((WriteAddr)>>16)); //send 24bit address
|
FLASH_ReadWriteByte((u8)((WriteAddr)>>8));
|
FLASH_ReadWriteByte((u8)WriteAddr);
|
for(i=0;i<NumByteToWrite;i++)
|
FLASH_ReadWriteByte(pBuffer[i]);
|
FLASH_CS_HIGH;
|
Flash_Wait_Busy(); //wait write finish
|
}
|
|
|
/******************************************
|
* func: Flash_Erase_Chip
|
* desc: erase all data.
|
* input: none
|
* output: none
|
* return: none
|
*****************************************/
|
void Flash_Erase_Chip(void)
|
{
|
FLASH_Write_Enable();
|
Flash_Wait_Busy();
|
FLASH_CS_LOW;
|
FLASH_ReadWriteByte(FLASH_ChipErase); //send chip erase instruction
|
FLASH_CS_HIGH;
|
Flash_Wait_Busy(); //wait erase finish
|
}
|
|
|
/******************************************
|
* func: Flash_Erase_Sector
|
* desc: sector erase operation.
|
* input: Dst_Addr - sector address.
|
* output: none
|
* return: none
|
*****************************************/
|
void Flash_Erase_Sector(u32 Dst_Addr)
|
{
|
Dst_Addr*=4096;
|
FLASH_Write_Enable(); //write enable
|
Flash_Wait_Busy();
|
FLASH_CS_LOW;
|
FLASH_ReadWriteByte(FLASH_SectorErase); //send sector erase instruction
|
FLASH_ReadWriteByte((u8)((Dst_Addr)>>16));
|
FLASH_ReadWriteByte((u8)((Dst_Addr)>>8));
|
FLASH_ReadWriteByte((u8)Dst_Addr);
|
FLASH_CS_HIGH;
|
Flash_Wait_Busy();
|
}
|
|
|
/******************************************
|
* func: Flash_Wait_Busy
|
* desc: wait write or erase operation finish.
|
* input: none
|
* output: none
|
* return: none
|
*****************************************/
|
void Flash_Wait_Busy(void)
|
{
|
while ((Flash_ReadSR()&0x01)==0x01); //wait BUSY=0
|
}
|
|
|
/******************************************
|
* func: Flash_PowerDown
|
* desc: take flash into power-down mode.
|
* input: none
|
* output: none
|
* return: none
|
*****************************************/
|
void Flash_PowerDown(void)
|
{
|
FLASH_CS_LOW;
|
FLASH_ReadWriteByte(FLASH_POWERDOWN); //send power-down instruction
|
FLASH_CS_HIGH;
|
delay_us(3); //wait TPD
|
}
|
|
|
/******************************************
|
* func: Flash_WAKEUP
|
* desc: release flash from power-down mode.
|
* input: none
|
* output: none
|
* return: none
|
*****************************************/
|
void Flash_WAKEUP(void)
|
{
|
FLASH_CS_LOW;
|
FLASH_ReadWriteByte(FLASH_WKUP); //send wake up command 0xAB
|
FLASH_CS_HIGH;
|
delay_us(3); //wait TRES1
|
}
|
