Writing a file to qspi memory

Question

1.00/5 (1 vote)

See more:

Hi,

I have a .bin file and I want to write it to the qspi memory.

[edit]Code block added - OriginalGriff[/edit]

What I have tried:

I'm dumping the file while debugging the program. but I'm not able to write the file into the buffer properly. Here I'm writing the code..

C++

#include "xparameters.h"	/* SDK generated parameters */
#include "xqspips.h"		/* QSPI device driver */
#include "xil_printf.h"

#define QSPI_DEVICE_ID		XPAR_XQSPIPS_0_DEVICE_ID


#define WRITE_STATUS_CMD	0x01
#define WRITE_CMD		0x02
#define READ_CMD		0x03
#define WRITE_DISABLE_CMD	0x04
#define READ_STATUS_CMD		0x05
#define WRITE_ENABLE_CMD	0x06
#define FAST_READ_CMD		0x0B
#define DUAL_READ_CMD		0x3B
#define QUAD_READ_CMD		0x6B
#define BULK_ERASE_CMD		0xC7
#define	SEC_ERASE_CMD		0xD8
#define READ_ID			0x9F


#define COMMAND_OFFSET		0 /* FLASH instruction */
#define ADDRESS_1_OFFSET	1 /* MSB byte of address to read or write */
#define ADDRESS_2_OFFSET	2 /* Middle byte of address to read or write */
#define ADDRESS_3_OFFSET	3 /* LSB byte of address to read or write */
#define DATA_OFFSET		4 /* Start of Data for Read/Write */
#define DUMMY_OFFSET		4 /* Dummy byte offset for fast, dual and quad
				     reads */
#define DUMMY_SIZE		1 /* Number of dummy bytes for fast, dual and
				     quad reads */
#define RD_ID_SIZE		4 /* Read ID command + 3 bytes ID response */
#define BULK_ERASE_SIZE		1 /* Bulk Erase command size */
#define SEC_ERASE_SIZE		4 /* Sector Erase command + Sector address */

#define OVERHEAD_SIZE		4

/*
 * The following constants specify the page size, sector size, and number of
 * pages and sectors for the FLASH.  The page size specifies a max number of
 * bytes that can be written to the FLASH with a single transfer.
 */
#define SECTOR_SIZE		0x10000
#define NUM_SECTORS		0x100
#define NUM_PAGES		0x10000
#define PAGE_SIZE		256

/*
 * Number of flash pages to be written.
 */
#define PAGE_COUNT		1611

/*
 * Flash address to which data is ot be written.
 */
#define TEST_ADDRESS		0x00000000
#define UNIQUE_VALUE		0x05
/*
 * The following constants specify the max amount of data and the size of the
 * the buffer required to hold the data and overhead to transfer the data to
 * and from the FLASH.
 */
#define MAX_DATA		PAGE_COUNT * PAGE_SIZE

/**************************** Type Definitions *******************************/

/***************** Macros (Inline Functions) Definitions *********************/

/************************** Function Prototypes ******************************/

void FlashErase(XQspiPs *QspiPtr, u32 Address, u32 ByteCount);

void FlashWrite(XQspiPs *QspiPtr, u32 Address, u32 ByteCount, u8 Command);

void FlashRead(XQspiPs *QspiPtr, u32 Address, u32 ByteCount, u8 Command);

int FlashReadID(void);

int QspiFlashPolledExample(XQspiPs *QspiInstancePtr, u16 QspiDeviceId);

/************************** Variable Definitions *****************************/

/*
 * The instances to support the device drivers are global such that they
 * are initialized to zero each time the program runs. They could be local
 * but should at least be static so they are zeroed.
 */
static XQspiPs QspiInstance;

/*
 * The following variable allows a test value to be added to the values that
 * are written to the FLASH such that unique values can be generated to
 * guarantee the writes to the FLASH were successful
 */
int Test = 5;

/*
 * The following variables are used to read and write to the flash and they
 * are global to avoid having large buffers on the stack
 */
u8 ReadBuffer[MAX_DATA + DATA_OFFSET + DUMMY_SIZE];
u8 WriteBuffer[PAGE_SIZE + DATA_OFFSET];

/*****************************************************************************/
/**
*
* Main function to call the QSPI Flash example.
*
* @param	None
*
* @return	XST_SUCCESS if successful, otherwise XST_FAILURE.
*
* @note		None
*
******************************************************************************/
int main(void)
{
	int Status;

	xil_printf("QSPI FLASH Polled Example Test \r\n");

	/*
	 * Run the Qspi Interrupt example.
	 */
	Status = QspiFlashPolledExample(&QspiInstance, QSPI_DEVICE_ID);
	if (Status != XST_SUCCESS) {
		xil_printf("QSPI FLASH Polled Example Test Failed\r\n");
		return XST_FAILURE;
	}

	xil_printf("Successfully ran QSPI FLASH Polled Example Test\r\n");
	return XST_SUCCESS;
}

/*****************************************************************************
*
* The purpose of this function is to illustrate how to use the XQspiPs
* device driver in polled mode. This function writes and reads data
* from a serial FLASH.
*
* @param	None.
*
* @return	XST_SUCCESS if successful, else XST_FAILURE.
*
* @note		None.
*
*****************************************************************************/
int QspiFlashPolledExample(XQspiPs *QspiInstancePtr, u16 QspiDeviceId)
{
	int Status;
	u8 *BufferPtr;
	u8 UniqueValue;
	int Count;
	int Page;
	XQspiPs_Config *QspiConfig;

	/*
	 * Initialize the QSPI driver so that it's ready to use
	 */
	QspiConfig = XQspiPs_LookupConfig(QspiDeviceId);
	if (NULL == QspiConfig) {
		return XST_FAILURE;
	}

	Status = XQspiPs_CfgInitialize(QspiInstancePtr, QspiConfig,
					QspiConfig->BaseAddress);
	if (Status != XST_SUCCESS) {
		return XST_FAILURE;
	}

	/*
	 * Perform a self-test to check hardware build
	 */
	Status = XQspiPs_SelfTest(QspiInstancePtr);
	if (Status != XST_SUCCESS) {
		return XST_FAILURE;
	}

	/*
	 * Initialize the write buffer for a pattern to write to the FLASH
	 * and the read buffer to zero so it can be verified after the read,
	 * the test value that is added to the unique value allows the value
	 * to be changed in a debug environment to guarantee
	 */
	for (UniqueValue = UNIQUE_VALUE, Count = 0; Count < PAGE_SIZE;
	     Count++, UniqueValue++) {
		WriteBuffer[DATA_OFFSET + Count] = (u8)(UniqueValue + Test);
	}
	memset(ReadBuffer, 0x00, sizeof(ReadBuffer));

	/*
	 * Set Manual Start and Manual Chip select options and drive HOLD_B
	 * pin high.
	 */
	XQspiPs_SetOptions(QspiInstancePtr, XQSPIPS_MANUAL_START_OPTION |
			XQSPIPS_FORCE_SSELECT_OPTION |
			XQSPIPS_HOLD_B_DRIVE_OPTION);

	/*
	 * Set the prescaler for QSPI clock
	 */
	XQspiPs_SetClkPrescaler(QspiInstancePtr, XQSPIPS_CLK_PRESCALE_8);

	/*
	 * Assert the FLASH chip select.
	 */
	XQspiPs_SetSlaveSelect(QspiInstancePtr);


	//FlashReadID();

	/*
	 * Erase the flash.
	 */
	//FlashErase(QspiInstancePtr, TEST_ADDRESS, MAX_DATA);

	/*
	 * Write the data in the write buffer to the serial FLASH a page at a
	 * time, starting from TEST_ADDRESS
	 */
	for (Page = 0; Page < PAGE_COUNT; Page++) {
		FlashWrite(QspiInstancePtr, (Page * PAGE_SIZE) + TEST_ADDRESS,
			   PAGE_SIZE, WRITE_CMD);
	}


	return XST_SUCCESS;
}

Posted 4-Sep-17 22:40pm

Veerendra-13142768

Updated 22-May-20 1:58am

OriginalGriff

v2

Add a Solution

Comments

CPallini 5-Sep-17 5:02am

"but I'm not able to write the file into the buffer properly."
That is rather vague. Could you please give us more info?
What kind of device are your programming? What is the QUAD SPI FLASH peripheral?

1 solution

Add a Solution

Add your solution here

Treat my content as plain text, not as HTML

Preview 0

…

Existing Members

Sign in to your account

...or Join us

Download, Vote, Comment, Publish.

Your Email
Password
Forgot your password?

Your Email
This email is in use. Do you need your password?
Optional Password

I have read and agree to the Terms of Service and Privacy Policy
Please subscribe me to the CodeProject newsletters

When answering a question please:

Read the question carefully.
Understand that English isn't everyone's first language so be lenient of bad spelling and grammar.
If a question is poorly phrased then either ask for clarification, ignore it, or edit the question and fix the problem. Insults are not welcome.
Don't tell someone to read the manual. Chances are they have and don't get it. Provide an answer or move on to the next question.

Let's work to help developers, not make them feel stupid.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Jochen Arndt · Accepted Answer · 2017-09-04T23:28:00

Solution 1

You are nowhere trying to write data. It looks like the posted code is based on the code from xqspips_flash_polled_example.c[^].

If so, you have to copy the data to be written to &WriteBuffer[DATA_OFFSET] and call FlashWrite() page wise.

Untested example:

C++

// pSrcData: Data read from file
// nSrcLen:  Number of bytes
// Assuming driver has been initialised

u32 nPage;
u32 nPages = nSrcLen / PAGE_SIZE;
u32 nLast = nSrcLen % PAGE_SIZE;
u32 nSpiAddress = 0; // Flash start address
u32 nOffset = 0;

#if 0
// Optional read and store last page here if data should be preserved
// Only necessary if nLast is not zero
u8 pPreserved[PAGE_SIZE]; 
if (nLast)
{
    FlashRead(QspiInstancePtr, nSpiAddress + nPages * PAGE_SIZE, PAGE_SIZE, READ_CMD);
    memcpy(pPreserved, &ReadBuffer[DATA_OFFSET], PAGE_SIZE);
}
#endif

// Erase flash pages to be written
u32 nMaxData = nPages * PAGE_SIZE;
if (nLast)
    nMaxData += PAGE_SIZE;
FlashErase(QspiInstancePtr, nSpiAddress, nMaxData);

for (nPage = 0; nPage < nPages; nPage++, nOffset += PAGE_SIZE) 
{
    memcpy(&WriteBuffer[DATA_OFFSET], pSrcData + nOffset, PAGE_SIZE);
    FlashWrite(QspiInstancePtr, nSpiAddress + nOffset, PAGE_SIZE, WRITE_CMD);
}
if (nLast)
{
    // Clear unused memory
    memset(&WriteBuffer[DATA_OFFSET + nLast], 0, PAGE_SIZE - nLast);
    // If the memory must be preserved, it must be read and stored before erasing
    //  and copied back here
    //memcpy(&WriteBuffer[DATA_OFFSET], pPreserved, PAGE_SIZE);
    memcpy(&WriteBuffer[DATA_OFFSET], pSrcData + nOffset, nLast);
    FlashWrite(QspiInstancePtr, nSpiAddress + nOffset, PAGE_SIZE, WRITE_CMD);
}

// Perform verification in a similar manner by reading data and comapre with pSrcData

Posted 4-Sep-17 23:28pm

Jochen Arndt

Comments

CPallini 5-Sep-17 5:55am

My 5.

Veerendra-13142768 20-Sep-17 4:38am

Hi,
Thanks for ur reply. I'm restoring file before executing flashwrite(), using write buffer address, I tried to change byte count to MAX_DATA also. But its not working....

Jochen Arndt 20-Sep-17 5:17am

It looks like you still did not understand how flash memory is written.

- You have to erase the memory before writing
- You can not write more than page size bytes at once to the flash memory
- If you have more data, you have to write page by page
- Because your FlashWrite() function uses a defined buffer (WriteBuffer), you have to copy the data to be written to that buffer before calling the function
- You have to pass the matching arguments (flash memory address)

I can not test the code because I don't have the hardware. But my example code shows how it must be done.

In the loop:

memcpy(&WriteBuffer[DATA_OFFSET], pSrcData + nOffset, PAGE_SIZE);

Copies a block of data from pSrcData to the buffer (pSrcData must contain the complete file).

FlashWrite(QspiInstancePtr, nSpiAddress + nOffset, PAGE_SIZE, WRITE_CMD);

Writes a block of data (page size) from the buffer to the flash memory.

Veerendra-13142768 20-Sep-17 6:12am

Hello,
Sorry for asking same again and again. yeah I understood that we cant write more than 1 page(256bytes) at a time, that's why we are using for loop in the code.

//for (Page = 0; Page < PAGE_COUNT; Page++)
{
FlashWrite(QspiInstancePtr, (Page * PAGE_SIZE) + TEST_ADDRESS,PAGE_SIZE, WRITE_CMD);
}
//
and u have given file pSrcData, that we are restoring completely while debugging.
And if you want hardware to test the code ,then you can come online(teamviewer) and can check on hardware....

Thank you...

Jochen Arndt 20-Sep-17 6:20am

Sorry, but I'm not going to test it for you. We are all volunteers here and have "main" jobs to earn money.

Why do you have removed the memcpy() line?
It won't work without that!

Veerendra-13142768 20-Sep-17 6:33am

Sorry sir,
I'm fresher and stuck in this code from 10days.... Thanks a lot for ur replies, u r really doing great job....
If I declare pSrcData here then I cant restore while debugging the program. and here I'm not able to declare file that I want to write...
Plz can u tell me how to declare that part...

Jochen Arndt 20-Sep-17 6:51am

pSrcData must be a buffer containing the file content.

Reading a file into an allocated buffer is basic C knowledge:
- Get the file size
- Allocate the buffer
- Open the file
- Read the file content into the buffer
- Close the file
- Use the buffer
- Release the buffer

struct stat st;
stat(filename, &st);
nSrcLen = st.st_size;
char *pSrcData = malloc(nSrclen);
FILE *f = fopen(filename, "rb");
fread(pSrcData, 1, nSrcLen, f);
fclose(f);
// Write to flash here
free(pSrcData);

Veerendra-13142768 20-Sep-17 7:51am

Hi,

what all structure member here, Please describe me.

Jochen Arndt 20-Sep-17 7:56am

Which structure?

In any case: Read the documentation and/or have a look at the structure definition.

For stat:
http://pubs.opengroup.org/onlinepubs/009695399/functions/stat.html
http://pubs.opengroup.org/onlinepubs/009695399/basedefs/sys/stat.h.html

Veerendra-13142768 21-Sep-17 2:31am

Hi,

Thanks for your help.
I tried the following code which you gave, but I'm getting the error as undefined reference to '_stat'

char *filename="qqspi.txt";
FILE *filesource=fopen(filename,"r");

/*use stat.st_size if you have the library <sys stat.h="">*/
struct stat st;
stat(filename, &st);

long filesize_stat= st.st_size;

fseek(filesource,0,SEEK_END);
long filesize_ftell = ftell(filesource);
fseek(filesource,0,SEEK_SET);

char *pchar_filesource = malloc(filesize_stat);

fread(pchar_filesource, 1, filesize_stat, filesource);
fclose(filesource);

for (Page = 0; Page < PAGE_COUNT; Page++)
{
memcpy(&WriteBuffer[DATA_OFFSET], pchar_filesource + nOffset, PAGE_SIZE);
FlashWrite(QspiInstancePtr, TEST_ADDRESS + nOffset, PAGE_SIZE, WRITE_CMD);
}

free(pchar_filesource);

Jochen Arndt 21-Sep-17 2:57am

As I told you:
Read the documentation of every used function. It contains examples and information about the header files to be included.

So you have to

#include <sys/types.h>
#include <sys/stat.h>

or use a different method to get the file size like seeking.

Veerendra-13142768 21-Sep-17 3:29am

I added both headers, but result is still same I>e endup with same error.
as you told I tried to get file size using SEEK... I have written code below....

To copy to memory from buffer, what statement should I give?

char *filename="qqspi.txt";
char *source = NULL;
FILE *fptr = fopen(filename, "r");
if (fptr != NULL)
{
/* Go to the end of the file. */
if (fseek(fptr, 0L, SEEK_END) == 0)
{
/* Get the size of the file. */
long bufsize = ftell(fptr);
if (bufsize == -1)
{
xil_printf("QSPI FLASH Polled Example getting file size failed\r\n");
return XST_FAILURE;
}

/* Allocate our buffer to that size. */
source = malloc(sizeof(char) * (bufsize + 1));

/* Go back to the start of the file. */
if (fseek(fptr, 0L, SEEK_SET) != 0)
{
xil_printf("QSPI FLASH Polled Example getting back to start of file failed\r\n");
return XST_FAILURE;
}

/* Read the entire file into memory. */
size_t newLen = fread(source, sizeof(char), bufsize, fptr);
if (newLen == 0)
{
fputs("Error reading file", stderr);
}
else
{
source[++newLen] = '\0'; /* Just to be safe. */
}
}
fclose(fptr);
}

for (Page = 0; Page < PAGE_COUNT; Page++)
{
memcpy(&WriteBuffer[DATA_OFFSET], pchar_filesource + nOffset, PAGE_SIZE);
FlashWrite(QspiInstancePtr, TEST_ADDRESS + nOffset, PAGE_SIZE, WRITE_CMD);
}

free(source);

Jochen Arndt 21-Sep-17 3:41am

"To copy to memory from buffer, what statement should I give?"
Usually memcpy() but it depends on what you want to do.

Thinky about what you want to do and re-read my answer:
It calculates the number of pages from the file size but you are using PAGE_COUNT.

Veerendra-13142768 21-Sep-17 4:04am

I'm using page_count because max_data I can write is
MAX_DATA[Page_size*Page_count]

i.e. #define MAX_DATA PAGE_COUNT * PAGE_SIZE
Number of page_count times it goes in loop... it writes 256 bytes at a time, comes out of loop, for next page count again enters loop....

Jochen Arndt 21-Sep-17 4:46am

It is essential that you understand what the example code is doing. Then you have to think about what you want to do. You can use the example code as base but have to adapt it to your needs.

The example code does not handle data loaded from a file. It uses a (source) buffer of the fixed size MAX_DATA. You have to replace the usage of that buffer with the buffer containing the file data. That does include not only the buffer itself but also it's size (MAX_DATA -> your buffer's size = file size).

Veerendra-13142768 22-Sep-17 3:41am

Hello sir,
yeah I understood that need to removbe for loop. I tried the way you told, but here file is only not opening. in Xilinx sdk environment I cant use I/O options, its not accepting. so for hardware code I can only restore the code while debugging...

Jochen Arndt 22-Sep-17 4:15am

It was not clear from your question that you are using a Xilinx device. I have no experience with these. But if that is a plain device device without file system, you have to pass the data to the system using a different method.

I suggest to use the Xilinx forums because there you may get better help.

Veerendra-13142768 22-Sep-17 7:15am

Thnk you so much sir, you have done really great job...... Xilinx people are not replying for this.... so we trying outside...
Now also ddr memory writebuffer is writing 256times at a time and qspi memory is reading. after the 1st page count write in loop, in the second loop....
pointer is incrementing, testaddress is incrementing, bytecount is 256 onlt, write command is writing. but the write buffer address(ddr memory address)is still the same. may be there we are getting problem I guess.... do you know how to solve this????

Jochen Arndt 22-Sep-17 7:50am

Do your refer to the WriteBuffer?
That address should not change. It must hold the data for each page write which is ensured by calling memcpy.

The real memory address is nSpiAddress in my example. That is the start address and the increment of that adress is performed by adding nOffset which itself is incremented with each loop iteration by adding PAGE_SIZE.

Veerendra-13142768 23-Sep-17 1:07am

Hi,
In my code for the first loop of page, 256 bytes are reading from ddr memory. for the second count test address(destination address) is adding with (page_size*page_count)+testaddress....
the pointer increment is also showing, but the the data is still ths same first 256 bytes....
Don't know how to solve this.....
void FlashWrite(XQspiPs *QspiPtr, u32 Address, u32 ByteCount, u8 Command)
{
u8 WriteEnableCmd = { WRITE_ENABLE_CMD };
u8 ReadStatusCmd[] = { READ_STATUS_CMD, 0 }; /* must send 2 bytes */
u8 FlashStatus[2];

/*
* Send the write enable command to the FLASH so that it can be
* written to, this needs to be sent as a seperate transfer before
* the write
*/
XQspiPs_PolledTransfer(QspiPtr, &WriteEnableCmd, NULL,
sizeof(WriteEnableCmd));

/*
* Setup the write command with the specified address and data for the
* FLASH
*/
WriteBuffer[COMMAND_OFFSET] = Command;
WriteBuffer[ADDRESS_1_OFFSET] = (u8)((Address & 0xFF0000) >> 16);
WriteBuffer[ADDRESS_2_OFFSET] = (u8)((Address & 0xFF00) >> 8);
WriteBuffer[ADDRESS_3_OFFSET] = (u8)(Address & 0xFF);

/*
* Send the write command, address, and data to the FLASH to be
* written, no receive buffer is specified since there is nothing to
* receive
*/
XQspiPs_PolledTransfer(QspiPtr, WriteBuffer, NULL,
ByteCount + OVERHEAD_SIZE);

/*
* Wait for the write command to the FLASH to be completed, it takes
* some time for the data to be written
*/
while (1) {
/*
* Poll the status register of the FLASH to determine when it
* completes, by sending a read status command and receiving the
* status byte
*/
XQspiPs_PolledTransfer(QspiPtr, ReadStatusCmd, FlashStatus,
sizeof(ReadStatusCmd));

/*
* If the status indicates the write is done, then stop waiting,
* if a value of 0xFF in the status byte is read from the
* device and this loop never exits, the device slave select is
* possibly incorrect such that the device status is not being
* read
*/
if ((FlashStatus[1] & 0x01) == 0) {
break;
}
}
}

Jochen Arndt 26-Sep-17 2:49am

The above is just the code to write. If you pass the correct parameters and have copied the data to be written to WriteBuffer (using memcpy), the data should be written correctly.