#include "stdio.h"
#include "w25qxx.h" 
#include "spi.h"
#include "delay.h"	   
#include "usart.h"	
//////////////////////////////////////////////////////////////////////////////////	 
//This program is for educational purposes only, without the author's permission, may not be used for any other purpose
//ALIENTEK STM32F4 Explorer Board
//W25QXX Driver code	   
//Hot Atomic @ALIENTEK
//Forum: www.openedv.com
//Date modified: 2014/5/6
//Version: V1.0
//All rights reserved pirated reserved.
//Copyright(C) Guangzhou wing electronic technology limited company 2009-2019
//All rights reserved
////////////////////////////////////////////////////////////////////////////////// 	
 
u16 W25QXX_TYPE = W25Q128;	// The default is W25Q128

// 4Kbytes to a Sector
// 16 slices for 1 Block
// W25Q40 : Capacity of 512K bytes, and a total of  16 Block,  128 Sector
// W25Q128: Capacity of  16M bytes, and a total of 128 Block, 4096 Sector
													 
//Initializes IO port SPI FLASH
void W25QXX_Init(void)
{ 
	GPIO_InitTypeDef  GPIO_InitStructure;

	RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE);	// GPIOB clock

	//SPI_NSS - GPIOB12
	GPIO_InitStructure.GPIO_Pin 	= GPIO_Pin_12;					// PB12
	GPIO_InitStructure.GPIO_Mode 	= GPIO_Mode_OUT;				// Output
	GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;				// Push-pull output
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;		// 100MHz
	GPIO_InitStructure.GPIO_PuPd 	= GPIO_PuPd_UP;					// Pull-up
	GPIO_Init(GPIOB, &GPIO_InitStructure);								// Initialize

	W25QXX_CS = 1;																				// SPI FLASH is not selected
	SPI2_Init();		   																		// Initialize the SPI
	SPI2_SetSpeed(SPI_BaudRatePrescaler_2);								// Set to 42M clock high-speed mode
	W25QXX_TYPE = W25QXX_ReadID();												// Read FLASH ID.
}  

// The status register read W25QXX
// BIT7  6   5   4   3   2   1   0
// SPR   RV  TB BP2 BP1 BP0 WEL BUSY
// SPR:Default 0, the State Register protection, used with WP
// TB,BP2,BP1,BP0:FLASH write-protect setting
// WEL: write lock
// BUSY: busy flag bits (1, busy; 0, idle)
// Default:0x00
u8 W25QXX_ReadSR(void)   
{  
	u8 byte = 0;   
	W25QXX_CS = 0;                            // Enabling devices   
	SPI2_ReadWriteByte(W25X_ReadStatusReg);   // Sends a read status register command    
	byte = SPI2_ReadWriteByte(0Xff);          // Read a byte 
	W25QXX_CS = 1;                            // Cancel selected     
	
	return byte;   
} 
// Write W25QXX status register
// Only the SPR,TB,BP2,BP1,BP0(bit 7,5,4,3,2)You can write!!!
void W25QXX_Write_SR(u8 sr)   
{   
	W25QXX_CS=0;                            //Enabling devices    
	SPI2_ReadWriteByte(W25X_WriteStatusReg);   //Sending of taking the State register command   
	SPI2_ReadWriteByte(sr);               //Writes a byte  
	W25QXX_CS=1;                            //Cancel selected        	      
}   
//W25QXX write enable	
//WEL is set   
void W25QXX_Write_Enable(void)   
{
	W25QXX_CS=0;                            //Enabling devices    
	SPI2_ReadWriteByte(W25X_WriteEnable);      //Send written  
	W25QXX_CS=1;                            //Cancel selected        	      
} 
//W25QXX write protect	
//WEL reset  
void W25QXX_Write_Disable(void)   
{  
	W25QXX_CS=0;                            //Enabling devices    
	SPI2_ReadWriteByte(W25X_WriteDisable);     //Send written    
	W25QXX_CS=1;                            //Cancel selected
} 		
//Read the chip ID
//Return values are as follows:				   
//0XEF13,Chip and the model is W25Q80  
//0XEF14,Chip and the model is W25Q16    
//0XEF15,Chip and the model is W25Q32  
//0XEF16,Chip and the model is W25Q64 
//0XEF17,Chip and the model is W25Q128 	  
u16 W25QXX_ReadID(void)
{
	u16 Temp = 0;	  
	W25QXX_CS=0;				    
	SPI2_ReadWriteByte(0x90);//Send the read ID command	    
	SPI2_ReadWriteByte(0x00); 	    
	SPI2_ReadWriteByte(0x00); 	    
	SPI2_ReadWriteByte(0x00); 	 			   
	Temp|=SPI2_ReadWriteByte(0xFF)<<8;  
	Temp|=SPI2_ReadWriteByte(0xFF);	 
	W25QXX_CS=1;				    
	return Temp;
}   		    
//Read SPI FLASH  
//Starting at the specified address reads the specified length of data
//pBuffer:The data store
//ReadAddr:Read start address(24bit)
//NumByteToRead:Number of bytes to read(Max 65535)
void W25QXX_Read(u8* pBuffer,u32 ReadAddr,u16 NumByteToRead)   
{ 
 	u16 i;   										    
	W25QXX_CS=0;                            //Enabling devices   
    SPI2_ReadWriteByte(W25X_ReadData);         //Send read commands   
    SPI2_ReadWriteByte((u8)((ReadAddr)>>16));  //Send 24bit    
    SPI2_ReadWriteByte((u8)((ReadAddr)>>8));   
    SPI2_ReadWriteByte((u8)ReadAddr);   
    for(i=0;i<NumByteToRead;i++)
	{ 
        pBuffer[i]=SPI2_ReadWriteByte(0XFF);   //Cycle readings  
    }
	W25QXX_CS=1;  				    	      
}  
//SPI in one page (0~65535) written in less than 256 bytes of data
//Start write up to 256 bytes of data at the specified address
//pBuffer:The data store
//WriteAddr:Start writing the address (24bit)
//NumByteToWrite:Number of bytes to be written (up to 256), this number should not exceed the number of remaining bytes of the page!!!	 
void W25QXX_Write_Page(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite)
{
 	u16 i;  
    W25QXX_Write_Enable();                  //SET WEL 
	W25QXX_CS=0;                            //Enabling devices   
    SPI2_ReadWriteByte(W25X_PageProgram);      //Send a written page command   
    SPI2_ReadWriteByte((u8)((WriteAddr)>>16)); //Send 24bit    
    SPI2_ReadWriteByte((u8)((WriteAddr)>>8));   
    SPI2_ReadWriteByte((u8)WriteAddr);   
    for(i=0;i<NumByteToWrite;i++)SPI2_ReadWriteByte(pBuffer[i]);//Circulating wrote  
	W25QXX_CS=1;                            //Cancel selected 
	W25QXX_Wait_Busy();					   //Waiting to be written to the end
} 
//No test write SPI FLASH 
//Must ensure that writes all the data in the range of addresses to 0XFF, or write data in non-0XFF will fail!
//With automatic feed function 
//Starting at the specified address to write to the specified length of data, but make sure that the address is out of range!
//pBuffer:The data store
//WriteAddr:Start write address(24bit)
//NumByteToWrite:Number of bytes to write(Max 65535)
//CHECK OK
void W25QXX_Write_NoCheck(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite)   
{ 			 		 
	u16 pageremain;	   
	pageremain=256-WriteAddr%256; //Number of bytes remaining single page		 	    
	if(NumByteToWrite<=pageremain)pageremain=NumByteToWrite;//Less than 256 bytes
	while(1)
	{	   
		W25QXX_Write_Page(pBuffer,WriteAddr,pageremain);
		if(NumByteToWrite==pageremain)break;//Write end
	 	else //NumByteToWrite>pageremain
		{
			pBuffer+=pageremain;
			WriteAddr+=pageremain;	

			NumByteToWrite-=pageremain;			  //Minus has written a number of bytes
			if(NumByteToWrite>256)pageremain=256; //Once you can write to 256 bytes
			else pageremain=NumByteToWrite; 	  //Less than 256 bytes
		}
	};	    
} 
//Write SPI FLASH  
//Starting at the specified address to write to the specified length of data
//This function erases the operation!
//pBuffer:The data store
//WriteAddr:Start write address(24bit)						
//NumByteToWrite:Number of bytes to write(Max 65535)   
u8 W25QXX_BUFFER[4096];		 
void W25QXX_Write(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite)   
{ 
	u32 secpos;
	u16 secoff;
	u16 secremain;	   
 	u16 i;    
	u8 * W25QXX_BUF;	  
   	W25QXX_BUF=W25QXX_BUFFER;	     
 	secpos=WriteAddr/4096;//Sector address  
	secoff=WriteAddr%4096;//In the sector of migration
	secremain=4096-secoff;//Slice the remaining space   
 	//printf("ad:%X,nb:%X\r\n",WriteAddr,NumByteToWrite);//Testing
 	if(NumByteToWrite<=secremain)secremain=NumByteToWrite;//Not greater than 4,096 bytes
	while(1) 
	{	
		W25QXX_Read(W25QXX_BUF,secpos*4096,4096);//Read out the contents of an entire sector
		for(i=0;i<secremain;i++)//Calibration data
		{
			if(W25QXX_BUF[secoff+i]!=0XFF)break;//Need to erase  	  
		}
		if(i<secremain)//Need to erase
		{
			W25QXX_Erase_Sector(secpos);//Erase this sector
			for(i=0;i<secremain;i++)	   //Copy
			{
				W25QXX_BUF[i+secoff]=pBuffer[i];	  
			}
			W25QXX_Write_NoCheck(W25QXX_BUF,secpos*4096,4096);//Write the whole sector  

		}else W25QXX_Write_NoCheck(pBuffer,WriteAddr,secremain);//Writing has been erased, write directly to the sector the remaining interval.				   
		if(NumByteToWrite==secremain)break;//Write end
		else//Write over
		{
			secpos++;//Increased sector address 1
			secoff=0;//Offset is 0 	 

		   	pBuffer+=secremain;  //Offset pointer
			WriteAddr+=secremain;//Write the address offset	   
		   	NumByteToWrite-=secremain;				//Diminishing bytes
			if(NumByteToWrite>4096)secremain=4096;	//Next sector but still not finished
			else secremain=NumByteToWrite;			//Next slice to finish
		}	 
	};	 
}
//Erase the entire chip		  
//Wait for long...
void W25QXX_Erase_Chip(void)   
{                                   
    W25QXX_Write_Enable();                  //SET WEL 
    W25QXX_Wait_Busy();   
  	W25QXX_CS=0;                            //Enabling devices   
    SPI2_ReadWriteByte(W25X_ChipErase);        //Send erase command  
	W25QXX_CS=1;                            //Cancel selected     	      
	W25QXX_Wait_Busy();   				   //Wait for end of the chip erase
}   
//Erase one sector
//Dst_Addr:Sector address set according to actual capacity
//Erasing a mountain at least time: 150ms
void W25QXX_Erase_Sector(u32 Dst_Addr)   
{  
	//Monitor Falsh erasure, testing   
// 	printf("fe:%x\r\n",Dst_Addr);	  
 	Dst_Addr*=4096;
    W25QXX_Write_Enable();                  //SET WEL 	 
    W25QXX_Wait_Busy();   
  	W25QXX_CS=0;                            //Enabling devices   
    SPI2_ReadWriteByte(W25X_SectorErase);      //Send sector erase command 
    SPI2_ReadWriteByte((u8)((Dst_Addr)>>16));  //Send 24bit    
    SPI2_ReadWriteByte((u8)((Dst_Addr)>>8));   
    SPI2_ReadWriteByte((u8)Dst_Addr);  
	W25QXX_CS=1;                            //Cancel selected     	      
    W25QXX_Wait_Busy();   				   //Wait for the erase to complete
}  
//Waiting for a free
void W25QXX_Wait_Busy(void)   
{   
	while((W25QXX_ReadSR()&0x01)==0x01);   // Wait for the BUSY emptying
}  
//Enter the power off mode
void W25QXX_PowerDown(void)   
{ 
  	W25QXX_CS=0;                            //Enabling devices   
    SPI2_ReadWriteByte(W25X_PowerDown);        //Send the power command  
	W25QXX_CS=1;                            //Cancel selected     	      
    delay_us(3);                               //Wait for the TPD  
}   
//Wake up
void W25QXX_WAKEUP(void)   
{  
  	W25QXX_CS=0;                            //Enabling devices   
    SPI2_ReadWriteByte(W25X_ReleasePowerDown);   //  send W25X_PowerDown command 0xAB    
	W25QXX_CS=1;                            //Cancel selected     	      
    delay_us(3);                               //Waiting for TRES1
}