将文件写入qspi内存 [英] Writing a file to qspi memory

问题描述

我有一个.bin文件，我想将它写入qspi内存。



[edit]已添加代码块 - OriginalGriff [/ edit]



我尝试过：



我正在调试程序时转储文件。但是我无法正确地将文件写入缓冲区。我在这里编写代码..

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..

#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;
}

推荐答案

你无处可写数据。看似已发布的代码基于 xqspips_flash_polled_example.c <中的代码。 / a> [ ^ ]。



如果是这样，你必须将要写入的数据复制到& WriteBuffer [DATA_OFFSET] 并在页面上调用 FlashWrite（）



未经测试的例子：

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:

// 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

这篇关于将文件写入qspi内存的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！