z_flash_W25QXXX.c

/*********************************************
 * @file Z_FLASH_W25QXXX.c
 * @author mauro
 * @date: 01 august 2023
 * @version V.1.0.0
 * 
 * Licensing: https://github.com/maudeve-it/W25Qxxx_SPI_FLASH_STM32/blob/main/LICENSE
 *
 *********************************************
 * this version of library uses just polling 
 * mode transmission
 * this version of library uses standard SPI
 *********************************************
 * configure below STEP1 and STEP4.
 * Do not change STEP2 and STEP3 in this version
 ********************************************
 *
 * Install and use this library following instruction on: https://github.com/maudeve-it/W25Qxxx_SPI_FLASH_STM32
 *
 * Put init function in you main() USER CODE BEGIN 2:
 *
 *  if (!Flash_Init()) {};
 *
 *  that's all
 *
 */


#include "main.h"
#include "z_flash_W25QXXX.h"

#define SPI_IS_BUSY 	(HAL_GPIO_ReadPin(FLASH_CS_GPIO_Port, FLASH_CS_Pin)==GPIO_PIN_RESET)

extern SPI_HandleTypeDef FLASH_SPI_PORT;




/******************************************
 * @brief	enable Flash SPI port
 * 			any command on Flash, any transmission, must start with
 * 			a Chip Select and terminate with a Chip Unselect.
 * 			So testing CS pin let understand if a
 * 			transmission is still running:
 * 			before selecting chip a test over the same CS let
 * 			understand if previous transmission terminated
 ******************************************/
void Flash_Select(void) {
		while (SPI_IS_BUSY) {}
		HAL_GPIO_WritePin(FLASH_CS_GPIO_Port, FLASH_CS_Pin, GPIO_PIN_RESET);
}




/******************************************
 * @brief	disable Flash SPI
 * 			verifying that there is no a running data transfer
 ******************************************/
void Flash_UnSelect(void) {
	// CS pin must be low (selected flash) until previous transmission is completed
#ifdef	EXT_FLASH_SPI_POLLING_MODE
	HAL_GPIO_WritePin(FLASH_CS_GPIO_Port, FLASH_CS_Pin, GPIO_PIN_SET);	//unselect
#endif  // FLASH_SPI_POLLING_MODE
}




void Flash_Receive(uint8_t* data, uint16_t dataSize){
	HAL_SPI_Receive (&FLASH_SPI_PORT , data, dataSize, HAL_MAX_DELAY);
}



/**********************************************************************
 * @BRIEF	engages SPI port tranferring data to Flash
 * 			just using Polling mode (TouchGFX requires this function)
 * @PARAM	data		buffer data to send
 * 			dataSize	number of bytes in "data" to be sent
 *********************************************************************/
void Flash_Polling_Transmit(uint8_t* data, uint16_t dataSize){
	HAL_SPI_Transmit(&FLASH_SPI_PORT , data, dataSize, HAL_MAX_DELAY);
}




/**************************
 * @BRIEF	engages SPI port tranferring data to Flash
 * 			Macro parameter DISPL_DMA_CUTOFF defines if transmission is Poling or DMA
 * 			you need to set this macro even using TouchGFX (having its own configuration parameter:
 * 			set DISPL_DMA_CUTOFF and CubeMX parameter to the same value)
 * @PARAM	data		buffer data to send
 * 			dataSize	number of bytes in "data" to be sent
 **************************/
void Flash_Transmit(uint8_t* data, uint16_t dataSize){
#ifndef	EXT_FLASH_SPI_POLLING_MODE
	if (dataSize<EXT_FLASH_DMA_CUTOFF) {
#endif //FLASH_SPI_POLLING_MODE
		HAL_SPI_Transmit(&FLASH_SPI_PORT , data, dataSize, HAL_MAX_DELAY);
#ifndef	EXT_FLASH_SPI_POLLING_MODE
	} else {
		HAL_SPI_Transmit_DMA(&EXT_FLASH_SPI_PORT , data, dataSize);
	}
#endif  //FLASH_SPI_POLLING_MODE
}


/**************************
 **************************/
uint8_t Flash_ReadSR(uint8_t buffer){
	Flash_Select();
	Flash_Transmit(&buffer, 1);
	Flash_Receive(&buffer, 1);  //SR1 is repeteadly sent until Flash is selected
	Flash_UnSelect();
	return buffer;
}




/**************************
 * @BRIEF	keeps looping inside this function until "BUSY" bit in SR1 register
 * 			becomes 0, meaning that the runnin data operation (writing or erasing)
 * 			on the chip, ended
 **************************/
void Flash_WaitForWritingComplete(){
uint8_t buffer[1];
	Flash_Select();
	buffer[0] = W25_R_SR1;
	Flash_Transmit(buffer, 1);
	do {
		Flash_Receive(buffer, 1);  //SR1 is repeteadly sent until Flash is selected
	} while (buffer[0] & SR1_BIT_BUSY);
	Flash_UnSelect();
}





/**************************
 * @BRIEF	reads from Flash Eeprom
 * 			using "communication mode" selected by
 * 			command doesn't check for the BUSY flag in SR1
 * 			that must be done before calling this function
 * 			current version of library doesn't need it
 * @PARAM	addr		EEPROM address to start reading
 *  		data		buffer to fill with read data
 * 			dataSize	number of bytes to read
 **************************/
void Flash_Read(uint32_t addr, uint8_t* data, uint32_t dataSize){
uint16_t data_to_transfer;
uint8_t buffer[5];

	buffer[0] = FLASH_READ_COMMAND;
	buffer[1] = (addr >> 16) & 0xFF;
	buffer[2] = (addr >> 8) & 0xFF;
	buffer[3] = addr & 0xFF;
	buffer[4] = W25_DUMMY;
	Flash_Select();
	Flash_Transmit(buffer, (FLASH_READ_COMMAND == W25_READ ? 4 : 5));  // "normal/slow" read command doesn't need sending dummy byte

	// dataSize is 32 bit, HAL_SPI_Receive handles 16bit transfers, so I have to loop...
	while (dataSize) {
		data_to_transfer = ((dataSize>EXT_FLASH_READING_PAGE) ? (uint16_t)EXT_FLASH_READING_PAGE : (uint16_t)dataSize);
		Flash_Receive(data, data_to_transfer);
		data+=(uint32_t)data_to_transfer;
		dataSize-=(uint32_t)data_to_transfer;
	}
	Flash_UnSelect();
}








/***********************************************************************
 * @BRIEF	it writes into a single FLASH page
 * 			function doesn't check for the BUSY flag in SR1
 * 			function doesn't check for the EEPROM writing enabled
 * 			function doesn't wait for the writing complete
 * 			function doesn't check for the EEPROM page boundary override
 * @PARAM	addr		EEPROM address to start writing
 *  		data		buffer containing data to write into EEPROM
 * 			dataSize	number of bytes to write
 ***********************************************************************/
void Flash_SimpleWriteAPage(uint32_t addr, uint8_t* data, uint16_t dataSize){
uint8_t buffer[4];
	buffer[0] = W25_PAGE_P;
	buffer[1] = (addr >> 16) & 0xFF;
	buffer[2] = (addr >> 8) & 0xFF;
	buffer[3] = addr & 0xFF;
	Flash_Select();
	Flash_Transmit(buffer, 4);
	Flash_Transmit(data, dataSize);
	Flash_UnSelect();
}






/***********************************************************************
 * @BRIEF	function writing into EEPROM
 * 			Handling "write enable" commands
 * 			It splits (if needed) received data into the single pages,
 * 			lounching writing sessions for each page
 * 			and waiting the writing complete each time
 * @PARAM	addr		EEPROM address to start writing
 *  		data		buffer containing data to write into EEPROM
 * 			dataSize	number of bytes to write
 ***********************************************************************/
void Flash_Write(uint32_t addr, uint8_t* data, uint32_t dataSize){
uint8_t buffer[4];
uint32_t quota; // counter of the transferred data in a multi-page writing request
uint32_t inpage_addr;

	if (dataSize==0)
		return;

	// quota is the data size trasferred until now
	quota=0;

	// define the starting write position inside the first Flash page to write...
	inpage_addr=addr & (EXT_FLASH_PAGE_SIZE-1);

	// ... so I can detect if more than 1 Flash page has still to be written
	while ((dataSize-quota+inpage_addr)>EXT_FLASH_PAGE_SIZE){
	//loop here inside, while more than 1 Flash page need to be written...

		Flash_Select();
		buffer[0] = W25_W_ENABLE;
		Flash_Transmit(buffer, 1);
		Flash_UnSelect();
		Flash_SimpleWriteAPage(addr+quota,data+quota,(EXT_FLASH_PAGE_SIZE-inpage_addr));
		quota+=(EXT_FLASH_PAGE_SIZE-inpage_addr);
		// having aligned data to page border on the first writing
		// next writings start from 0 position inside a page
		inpage_addr=0;
//		HAL_Delay(1);
		Flash_WaitForWritingComplete();
	}
	// now just the final Flash page...
	if (dataSize-quota) {
		Flash_Select();
		buffer[0] = W25_W_ENABLE;
		Flash_Transmit(buffer, 1);
		Flash_UnSelect();
		Flash_SimpleWriteAPage(addr+quota,data+quota,dataSize-quota);
//		HAL_Delay(1);
		Flash_WaitForWritingComplete();
	}
}





/**********************************
 * @BRIEF	Erase to 0XFF all bytes in a 4k block
 * 			4k block bounary is 0x1000, that means:
 * 			0x1000, 0x2000, 0x3000, ...
 * 			waiting the writing complete in each page
 * @PARAM	addr	starting erase address
 * 					(it must be a 4k sector boundary)
 *********************************/
void Flash_SErase4k(uint32_t addr){
uint8_t buffer[4];
	Flash_Select();
	buffer[0] = W25_W_ENABLE;
	Flash_Transmit(buffer, 1);
	Flash_UnSelect();

	buffer[0] = W25_S_ERASE4K;
	buffer[1] = (addr >> 16) & 0xFF;
	buffer[2] = (addr >> 8) & 0xFF;
	buffer[3] = addr & 0xFF;
	Flash_Select();
	Flash_Transmit(buffer, 4);
	Flash_UnSelect();
	Flash_WaitForWritingComplete();
}




/**********************************
 * @BRIEF	Erase to 0XFF all bytes in a 32k block
 * 			32k block bounary is 0x08000, that means:
 * 			0x008000, 0x010000, 0x018000, ...
 * 			waiting the writing complete in each page
 * @PARAM	addr	starting erase address
 * 					(it must be a 32k block boundary)
 *********************************/
void Flash_BErase32k(uint32_t addr){
uint8_t buffer[4];
	Flash_Select();
	buffer[0] = W25_W_ENABLE;
	Flash_Transmit(buffer, 1);
	Flash_UnSelect();

	buffer[0] = W25_B_ERASE32K;
	buffer[1] = (addr >> 16) & 0xFF;
	buffer[2] = (addr >> 8) & 0xFF;
	buffer[3] = addr & 0xFF;
	Flash_Select();
	Flash_Transmit(buffer, 4);
	Flash_UnSelect();
	Flash_WaitForWritingComplete();
}


void Flash_WriteEnable(){
uint8_t buffer[1];
	Flash_Select();
	buffer[0] = W25_W_ENABLE;
	Flash_Transmit(buffer, 1);
	Flash_UnSelect();
}



/**********************************
 * @BRIEF	Erase to 0XFF all bytes in a 64k block
 * 			64k block bounary is 0x08000, that means:
 * 			0x010000, 0x020000, 0x030000, ...
 * 			waiting the writing complete in each page
 * @PARAM	addr	starting erase address
 * 					(it must be a 64k block boundary)
 *********************************/
void Flash_BErase64k(uint32_t addr){
uint8_t buffer[4];
	Flash_Select();
	buffer[0] = W25_W_ENABLE;
	Flash_Transmit(buffer, 1);
	Flash_UnSelect();

	buffer[0] = W25_B_ERASE64K;
	buffer[1] = (addr >> 16) & 0xFF;
	buffer[2] = (addr >> 8) & 0xFF;
	buffer[3] = addr & 0xFF;
	Flash_Select();
	Flash_Transmit(buffer, 4);
	Flash_UnSelect();
	Flash_WaitForWritingComplete();
}




/**********************************
 * @BRIEF	Full chip erase to 0XFF
 * 			Chip Erase may need up to 100s
 * 			(typ. 20s)
 * 			waiting the writing complete in each page
 *********************************/
void Flash_ChipErase(){
uint8_t buffer[4];
	Flash_Select();
	buffer[0] = W25_W_ENABLE;
	Flash_Transmit(buffer, 1);
	Flash_UnSelect();

	buffer[0] = W25_CH_ERASE;
	Flash_Select();
	Flash_Transmit(buffer, 1);
	Flash_UnSelect();

	Flash_WaitForWritingComplete();
}




/**********************************
 * @BRIEF	Initiates a powerdown
 * 			after a powerDown only accepted a porweUp command
 * 			opwerDown operation is 3us long
 *********************************/
void Flash_PowerDown(){
uint8_t buffer[4];

	buffer[0] = W25_POWERDOWN;
	Flash_Select();
	Flash_Transmit(buffer, 1);
	Flash_UnSelect();
}







/**********************************
 * @BRIEF	Release from powerdown (3 us to restart) or read device ID
 *********************************/
void Flash_PowerUp(){
uint8_t buffer[4];

	buffer[0] = W25_POWERUP_ID;
	Flash_Select();
	Flash_Transmit(buffer, 1);
	Flash_UnSelect();
	HAL_Delay(1);
}



/**********************************
 * @BRIEF	Resets the Block protecting
 * 			bits in SR1 register
 *********************************/
void Flash_ResetSR1(){
uint8_t buffer[2];

	Flash_Select();
	buffer[0] = W25_W_ENABLE;
	Flash_Transmit(buffer, 1);
	Flash_UnSelect();

	buffer[0] = W25_W_SR1;
	buffer[1] = 0;
	Flash_Select();
	Flash_Transmit(buffer, 2);
	Flash_UnSelect();

	Flash_WaitForWritingComplete();
}










/**********************************
 * @BRIEF	read device id from chip
 * @RETURN	device id
 *********************************/
uint8_t Flash_ReadDevID(){
uint8_t buffer[4];
uint8_t data;

	buffer[0] = W25_POWERUP_ID;
	buffer[1] = W25_DUMMY;
	buffer[2] = W25_DUMMY;
	buffer[3] = W25_DUMMY;
	Flash_Select();
	Flash_Transmit(buffer, 4);
	Flash_Receive(&data, 1);
	Flash_UnSelect();
	return data;
}





uint16_t Flash_ReadManufactutrerAndDevID() {
uint8_t buffer[4];
uint16_t data;

	buffer[0] = W25_POWERUP_ID;
	buffer[1] = W25_DUMMY;
	buffer[2] = W25_DUMMY;
	buffer[3] = W25_DUMMY;
	Flash_Select();
	Flash_Transmit(buffer, 4);
	Flash_Receive((uint8_t*)&data, 2);
	Flash_UnSelect();
	return data;
}




/******************************************************************
 * @RETURN	32bit value divided in 4 bytes:
 * 			(1)MSB	dummy
 * 			(2)		Jedec Manufacturer ID
 * 			(3)		Memory Type
 * 			(4)		Capacity
 ******************************************************************
 * Memory Capacity code:
 * 			10H ->	 5Mb		11H ->  10Mb		12H ->  20Mb
 * 			13H ->  40Mb		14H ->  80Mb		15H ->  16Mb
 * 			16H ->  32Mb		17H ->  64Mb		18H -> 128Mb
 * 			19H -> 256Mb		20H -> 512Mb		21H ->   1Gb
 ******************************************************************/
uint32_t Flash_ReadJedecID() {
uint8_t buffer[4];
uint8_t data[3];
uint32_t result;

	buffer[0] = W25_JEDEC_ID;
	Flash_Select();
	Flash_Transmit(buffer, 1);
	Flash_Receive(data, 3);
	Flash_UnSelect();
	result=((data[0]<<16) | (data[1] <<8) | data[2]);
	return result;
}




/*********************************
 * @RETURN	256byte SFDP register content:
 *********************************/
void Flash_ReadSFDP(uint8_t* data) {
uint8_t buffer[5];
	buffer[0] = W25_R_SFPD_REG;
	for (uint8_t k=1;k<5;k++)
		buffer[k]=0;
	Flash_Select();
	Flash_Transmit(buffer, 5);
	Flash_Receive(data, 256);
	Flash_UnSelect();
}





/*********************************
 * @BRIEF	testing chip alive and kicking reading SFDP
 * 	 		record ("Serial Flash Discoverable Parameter"
 * 			as per Jedec standard), it must return a
 * 			string beginning with "SFDP"
 * @RETURN	1 	test passed
 * 			0	no
 *********************************/
uint8_t Flash_TestAvailability() {
uint8_t data[256];
uint8_t test=0;

	for (uint8_t k=0;k!=3;k++)
		data[k]=0xFF;
	Flash_ReadSFDP(data);
	if (data[0]=='S')
		if (data[1]=='F')
			if (data[2]=='D')
				if (data[3]=='P')
					test=1;
	return test;
}




/******************************************************************
 * @BRIEF	reading manufacutrer and device ID
 * 			checking if connected device is a Winbond Flash
 * @RETURN	1 	init OK (error is 0)
 * 			0	Winbond Flash not found (error==1 means there is no a I2C Jedec device, error==2 there is a device but it is no a winbond memory)
 ******************************************************************/
uint8_t Flash_Init(uint8_t *error){
uint32_t JedecID;
	HAL_Delay(6);							// if init is called on system startup: 5 ms (tPUW) required after power-up to be fully available
	Flash_Reset();							// try to reset the device, even if not yet tested presence
	HAL_Delay(6);							// if init is called on system startup: 5 ms (tPUW) required after power-up to be fully available
	*error=0;
	if (!Flash_TestAvailability())			// is there a serial flash? if not
		*error=1;
	JedecID=Flash_ReadJedecID() ;			//select the memSize byte
	if (((JedecID >> 16) & 0XFF) != 0xEF)  	// is it a Winbond device? if not
		*error=2;
	return (!(*error));  								//everything OK
}





/******************************************************************
 * @BRIEF	sends a reset command sequence over SPI
 ******************************************************************/
void Flash_Reset(){
uint8_t command;
	command = W25_RESET_EN;
	Flash_Select();
	Flash_Transmit(&command, 1);
	Flash_UnSelect();
	command = W25_RESET;
	Flash_Select();
	Flash_Transmit(&command, 1);
	Flash_UnSelect();
	HAL_Delay(1);	// 30us needed by resetting
}







void DataReader_WaitForReceiveDone(){
// nothing to do, being reading always in polling mode
	return;
}

void DataReader_ReadData(uint32_t address24, uint8_t* buffer, uint32_t length){
	Flash_Read(address24, buffer, length);
}


void DataReader_StartDMAReadData(uint32_t address24, uint8_t* buffer, uint32_t length){
//currently using polling mode even if requested DMA
	Flash_Read(address24, buffer, length);
}