/**
|
******************************************************************************
|
* @file stm32_eval_spi_flash.c
|
* @author MCD Application Team
|
* @version V4.5.0
|
* @date 07-March-2011
|
* @brief This file provides a set of functions needed to manage the SPI M25Pxxx
|
* FLASH memory mounted on STM32xx-EVAL board (refer to stm32_eval.h
|
* to know about the boards supporting this memory).
|
* It implements a high level communication layer for read and write
|
* from/to this memory. The needed STM32 hardware resources (SPI and
|
* GPIO) are defined in stm32xx_eval.h file, and the initialization is
|
* performed in sFLASH_LowLevel_Init() function declared in stm32xx_eval.c
|
* file.
|
* You can easily tailor this driver to any other development board,
|
* by just adapting the defines for hardware resources and
|
* sFLASH_LowLevel_Init() function.
|
*
|
* +-----------------------------------------------------------+
|
* | Pin assignment |
|
* +-----------------------------+---------------+-------------+
|
* | STM32 SPI Pins | sFLASH | Pin |
|
* +-----------------------------+---------------+-------------+
|
* | sFLASH_CS_PIN | ChipSelect(/S)| 1 |
|
* | sFLASH_SPI_MISO_PIN / MISO | DataOut(Q) | 2 |
|
* | | VCC | 3 (3.3 V)|
|
* | | GND | 4 (0 V) |
|
* | sFLASH_SPI_MOSI_PIN / MOSI | DataIn(D) | 5 |
|
* | sFLASH_SPI_SCK_PIN / SCLK | Clock(C) | 6 |
|
* | | VCC | 7 (3.3 V)|
|
* | | VCC | 8 (3.3 V)|
|
* +-----------------------------+---------------+-------------+
|
******************************************************************************
|
* @attention
|
*
|
* THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
|
* WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
|
* TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
|
* DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
|
* FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
|
* CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
|
*
|
* <h2><center>© COPYRIGHT 2011 STMicroelectronics</center></h2>
|
******************************************************************************
|
*/
|
|
/* Includes ------------------------------------------------------------------*/
|
#include "stm32_eval_spi_flash.h"
|
#include "stm32f10x.h"
|
/** @addtogroup Utilities
|
* @{
|
*/
|
|
/** @addtogroup STM32_EVAL
|
* @{
|
*/
|
|
/** @addtogroup Common
|
* @{
|
*/
|
|
/** @addtogroup STM32_EVAL_SPI_FLASH
|
* @brief This file includes the M25Pxxx SPI FLASH driver of STM32-EVAL boards.
|
* @{
|
*/
|
|
/** @defgroup STM32_EVAL_SPI_FLASH_Private_Types
|
* @{
|
*/
|
/**
|
* @}
|
*/
|
|
|
/** @defgroup STM32_EVAL_SPI_FLASH_Private_Defines
|
* @{
|
*/
|
/**
|
* @}
|
*/
|
|
/** @defgroup STM32_EVAL_SPI_FLASH_Private_Macros
|
* @{
|
*/
|
/**
|
* @}
|
*/
|
|
|
/** @defgroup STM32_EVAL_SPI_FLASH_Private_Variables
|
* @{
|
*/
|
/**
|
* @}
|
*/
|
|
|
/** @defgroup STM32_EVAL_SPI_FLASH_Private_Function_Prototypes
|
* @{
|
*/
|
/**
|
* @}
|
*/
|
|
|
/** @defgroup STM32_EVAL_SPI_FLASH_Private_Functions
|
* @{
|
*/
|
|
/**
|
* @brief DeInitializes the peripherals used by the SPI FLASH driver.
|
* @param None
|
* @retval None
|
*/
|
void sFLASH_DeInit(void)
|
{
|
sFLASH_LowLevel_DeInit();
|
}
|
|
/**
|
* @brief Initializes the peripherals used by the SPI FLASH driver.
|
* @param None
|
* @retval None
|
*/
|
|
SPI_InitTypeDef SPI_InitStructure;
|
void sFLASH_Init(void)
|
{
|
|
sFLASH_LowLevel_Init();
|
|
/*!< Deselect the FLASH: Chip Select high */
|
sFLASH_CS_HIGH();
|
|
/*!< SPI configuration */
|
SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
|
SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
|
SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;
|
SPI_InitStructure.SPI_CPOL = SPI_CPOL_High;
|
SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;
|
SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
|
#if defined (STM32F10X_LD_VL) || defined (STM32F10X_MD_VL) || defined (STM32F10X_HD_VL)
|
SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_2;
|
#else
|
SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_2;
|
#endif
|
|
SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
|
SPI_InitStructure.SPI_CRCPolynomial = 7;
|
SPI_Init(sFLASH_SPI, &SPI_InitStructure);
|
|
/*!< Enable the sFLASH_SPI */
|
SPI_Cmd(sFLASH_SPI, ENABLE);
|
}
|
|
/**
|
* @brief Erases the specified FLASH sector.
|
* @param SectorAddr: address of the sector to erase.
|
* @retval None
|
*/
|
void sFLASH_EraseSector(uint32_t SectorAddr)
|
{
|
/*!< Send write enable instruction */
|
sFLASH_WriteEnable();
|
|
/*!< Sector Erase */
|
/*!< Select the FLASH: Chip Select low */
|
sFLASH_CS_LOW();
|
/*!< Send Sector Erase instruction */
|
sFLASH_SendByte(sFLASH_CMD_SE);
|
/*!< Send SectorAddr high nibble address byte */
|
sFLASH_SendByte((SectorAddr & 0xFF0000) >> 16);
|
/*!< Send SectorAddr medium nibble address byte */
|
sFLASH_SendByte((SectorAddr & 0xFF00) >> 8);
|
/*!< Send SectorAddr low nibble address byte */
|
sFLASH_SendByte(SectorAddr & 0xFF);
|
/*!< Deselect the FLASH: Chip Select high */
|
sFLASH_CS_HIGH();
|
|
/*!< Wait the end of Flash writing */
|
sFLASH_WaitForWriteEnd();
|
}
|
|
/**
|
* @brief Erases the entire FLASH.
|
* @param None
|
* @retval None
|
*/
|
void sFLASH_EraseBulk(void)
|
{
|
/*!< Send write enable instruction */
|
sFLASH_WriteEnable();
|
|
/*!< Bulk Erase */
|
/*!< Select the FLASH: Chip Select low */
|
sFLASH_CS_LOW();
|
/*!< Send Bulk Erase instruction */
|
sFLASH_SendByte(sFLASH_CMD_BE);
|
/*!< Deselect the FLASH: Chip Select high */
|
sFLASH_CS_HIGH();
|
|
/*!< Wait the end of Flash writing */
|
sFLASH_WaitForWriteEnd();
|
}
|
|
/**
|
* @brief Writes more than one byte to the FLASH with a single WRITE cycle
|
* (Page WRITE sequence).
|
* @note The number of byte can't exceed the FLASH page size.
|
* @param pBuffer: pointer to the buffer containing the data to be written
|
* to the FLASH.
|
* @param WriteAddr: FLASH's internal address to write to.
|
* @param NumByteToWrite: number of bytes to write to the FLASH, must be equal
|
* or less than "sFLASH_PAGESIZE" value.
|
* @retval None
|
*/
|
void sFLASH_WritePage(uint8_t* pBuffer, uint32_t WriteAddr, uint16_t NumByteToWrite)
|
{
|
/*!< Enable the write access to the FLASH */
|
sFLASH_WriteEnable();
|
|
/*!< Select the FLASH: Chip Select low */
|
sFLASH_CS_LOW();
|
/*!< Send "Write to Memory " instruction */
|
sFLASH_SendByte(sFLASH_CMD_WRITE);
|
/*!< Send WriteAddr high nibble address byte to write to */
|
sFLASH_SendByte((WriteAddr & 0xFF0000) >> 16);
|
/*!< Send WriteAddr medium nibble address byte to write to */
|
sFLASH_SendByte((WriteAddr & 0xFF00) >> 8);
|
/*!< Send WriteAddr low nibble address byte to write to */
|
sFLASH_SendByte(WriteAddr & 0xFF);
|
|
/*!< while there is data to be written on the FLASH */
|
while (NumByteToWrite--)
|
{
|
/*!< Send the current byte */
|
sFLASH_SendByte(*pBuffer);
|
/*!< Point on the next byte to be written */
|
pBuffer++;
|
}
|
|
/*!< Deselect the FLASH: Chip Select high */
|
sFLASH_CS_HIGH();
|
|
/*!< Wait the end of Flash writing */
|
sFLASH_WaitForWriteEnd();
|
}
|
|
/**
|
* @brief Writes block of data to the FLASH. In this function, the number of
|
* WRITE cycles are reduced, using Page WRITE sequence.
|
* @param pBuffer: pointer to the buffer containing the data to be written
|
* to the FLASH.
|
* @param WriteAddr: FLASH's internal address to write to.
|
* @param NumByteToWrite: number of bytes to write to the FLASH.
|
* @retval None
|
*/
|
void sFLASH_WriteBuffer(uint8_t* pBuffer, uint32_t WriteAddr, uint16_t NumByteToWrite)
|
{
|
uint8_t NumOfPage = 0, NumOfSingle = 0, Addr = 0, count = 0, temp = 0;
|
|
Addr = WriteAddr % sFLASH_SPI_PAGESIZE;
|
count = sFLASH_SPI_PAGESIZE - Addr;
|
NumOfPage = NumByteToWrite / sFLASH_SPI_PAGESIZE;
|
NumOfSingle = NumByteToWrite % sFLASH_SPI_PAGESIZE;
|
|
if (Addr == 0) /*!< WriteAddr is sFLASH_PAGESIZE aligned */
|
{
|
if (NumOfPage == 0) /*!< NumByteToWrite < sFLASH_PAGESIZE */
|
{
|
sFLASH_WritePage(pBuffer, WriteAddr, NumByteToWrite);
|
}
|
else /*!< NumByteToWrite > sFLASH_PAGESIZE */
|
{
|
while (NumOfPage--)
|
{
|
sFLASH_WritePage(pBuffer, WriteAddr, sFLASH_SPI_PAGESIZE);
|
WriteAddr += sFLASH_SPI_PAGESIZE;
|
pBuffer += sFLASH_SPI_PAGESIZE;
|
}
|
|
sFLASH_WritePage(pBuffer, WriteAddr, NumOfSingle);
|
}
|
}
|
else /*!< WriteAddr is not sFLASH_PAGESIZE aligned */
|
{
|
if (NumOfPage == 0) /*!< NumByteToWrite < sFLASH_PAGESIZE */
|
{
|
if (NumOfSingle > count) /*!< (NumByteToWrite + WriteAddr) > sFLASH_PAGESIZE */
|
{
|
temp = NumOfSingle - count;
|
|
sFLASH_WritePage(pBuffer, WriteAddr, count);
|
WriteAddr += count;
|
pBuffer += count;
|
|
sFLASH_WritePage(pBuffer, WriteAddr, temp);
|
}
|
else
|
{
|
sFLASH_WritePage(pBuffer, WriteAddr, NumByteToWrite);
|
}
|
}
|
else /*!< NumByteToWrite > sFLASH_PAGESIZE */
|
{
|
NumByteToWrite -= count;
|
NumOfPage = NumByteToWrite / sFLASH_SPI_PAGESIZE;
|
NumOfSingle = NumByteToWrite % sFLASH_SPI_PAGESIZE;
|
|
sFLASH_WritePage(pBuffer, WriteAddr, count);
|
WriteAddr += count;
|
pBuffer += count;
|
|
while (NumOfPage--)
|
{
|
sFLASH_WritePage(pBuffer, WriteAddr, sFLASH_SPI_PAGESIZE);
|
WriteAddr += sFLASH_SPI_PAGESIZE;
|
pBuffer += sFLASH_SPI_PAGESIZE;
|
}
|
|
if (NumOfSingle != 0)
|
{
|
sFLASH_WritePage(pBuffer, WriteAddr, NumOfSingle);
|
}
|
}
|
}
|
}
|
|
/**
|
* @brief Reads a block of data from the FLASH.
|
* @param pBuffer: pointer to the buffer that receives the data read from the FLASH.
|
* @param ReadAddr: FLASH's internal address to read from.
|
* @param NumByteToRead: number of bytes to read from the FLASH.
|
* @retval None
|
*/
|
void sFLASH_ReadBuffer(uint8_t* pBuffer, uint32_t ReadAddr, uint16_t NumByteToRead)
|
{
|
/*!< Select the FLASH: Chip Select low */
|
sFLASH_CS_LOW();
|
|
/*!< Send "Read from Memory " instruction */
|
sFLASH_SendByte(sFLASH_CMD_READ);
|
|
/*!< Send ReadAddr high nibble address byte to read from */
|
sFLASH_SendByte((ReadAddr & 0xFF0000) >> 16);
|
/*!< Send ReadAddr medium nibble address byte to read from */
|
sFLASH_SendByte((ReadAddr& 0xFF00) >> 8);
|
/*!< Send ReadAddr low nibble address byte to read from */
|
sFLASH_SendByte(ReadAddr & 0xFF);
|
|
while (NumByteToRead--) /*!< while there is data to be read */
|
{
|
/*!< Read a byte from the FLASH */
|
*pBuffer = sFLASH_SendByte(sFLASH_DUMMY_BYTE);
|
/*!< Point to the next location where the byte read will be saved */
|
pBuffer++;
|
}
|
|
/*!< Deselect the FLASH: Chip Select high */
|
sFLASH_CS_HIGH();
|
}
|
u8 ext;
|
extern void display(vu8* dis,int gray);
|
extern int dis_mode;
|
extern vu8 dis_now[4080];
|
u8 FR[5]={0x0b,0x00,0x00,0x00,0xA5};
|
void sFLASH_FastRead( uint32_t ReadAddr, uint16_t NumByteToRead)
|
{
|
/*!< Select the FLASH: Chip Select low */
|
FR[1]=ReadAddr>>16;
|
FR[2]=ReadAddr>>8;
|
FR[3]=ReadAddr;
|
DMA1_Channel2->CNDTR=NumByteToRead;
|
sFLASH_CS_LOW();
|
/*!< Send "Read from Memory " instruction */
|
DMA1_Channel3->CCR |= 1 << 0 ;
|
while(DMA1->ISR!=0x0700);
|
DMA1->IFCR=0x0f00; //DMA_ClearFlag(DMA1_FLAG_GL3);
|
DMA1_Channel3->CCR &= ~(1 << 0) ;
|
DMA1_Channel3->CNDTR=0x05;
|
|
|
SPI1->CR1|=0x0400;
|
ext=SPI1->DR;
|
DMA1_Channel2->CCR |= 1 << 0 ;
|
while(DMA1->ISR!=0x0070);
|
// {if(dis_mode>100)
|
// {
|
// display(dis_now,40);
|
// }}
|
DMA1->IFCR=0x00f0;// DMA_ClearFlag(DMA1_FLAG_GL2);
|
DMA1_Channel2->CCR &= ~(1 << 0) ;
|
/*!< Deselect the FLASH: Chip Select high */
|
sFLASH_CS_HIGH();
|
SPI1->CR1&=0xfbff;
|
ext=SPI1->DR;
|
}
|
|
/**
|
* @brief Reads FLASH identification.
|
* @param None
|
* @retval FLASH identification
|
*/
|
uint32_t sFLASH_ReadID(void)
|
{
|
uint32_t Temp = 0, Temp0 = 0, Temp1 = 0, Temp2 = 0;
|
|
/*!< Select the FLASH: Chip Select low */
|
sFLASH_CS_LOW();
|
|
/*!< Send "RDID " instruction */
|
sFLASH_SendByte(0x9F);
|
|
/*!< Read a byte from the FLASH */
|
Temp0 = sFLASH_SendByte(sFLASH_DUMMY_BYTE);
|
|
/*!< Read a byte from the FLASH */
|
Temp1 = sFLASH_SendByte(sFLASH_DUMMY_BYTE);
|
|
/*!< Read a byte from the FLASH */
|
Temp2 = sFLASH_SendByte(sFLASH_DUMMY_BYTE);
|
|
/*!< Deselect the FLASH: Chip Select high */
|
sFLASH_CS_HIGH();
|
|
Temp = (Temp0 << 16) | (Temp1 << 8) | Temp2;
|
|
return Temp;
|
}
|
|
/**
|
* @brief Initiates a read data byte (READ) sequence from the Flash.
|
* This is done by driving the /CS line low to select the device, then the READ
|
* instruction is transmitted followed by 3 bytes address. This function exit
|
* and keep the /CS line low, so the Flash still being selected. With this
|
* technique the whole content of the Flash is read with a single READ instruction.
|
* @param ReadAddr: FLASH's internal address to read from.
|
* @retval None
|
*/
|
void sFLASH_StartReadSequence(uint32_t ReadAddr)
|
{
|
/*!< Select the FLASH: Chip Select low */
|
sFLASH_CS_LOW();
|
|
/*!< Send "Read from Memory " instruction */
|
sFLASH_SendByte(sFLASH_CMD_READ);
|
|
/*!< Send the 24-bit address of the address to read from -------------------*/
|
/*!< Send ReadAddr high nibble address byte */
|
sFLASH_SendByte((ReadAddr & 0xFF0000) >> 16);
|
/*!< Send ReadAddr medium nibble address byte */
|
sFLASH_SendByte((ReadAddr& 0xFF00) >> 8);
|
/*!< Send ReadAddr low nibble address byte */
|
sFLASH_SendByte(ReadAddr & 0xFF);
|
}
|
|
/**
|
* @brief Reads a byte from the SPI Flash.
|
* @note This function must be used only if the Start_Read_Sequence function
|
* has been previously called.
|
* @param None
|
* @retval Byte Read from the SPI Flash.
|
*/
|
uint8_t sFLASH_ReadByte(void)
|
{
|
return (sFLASH_SendByte(sFLASH_DUMMY_BYTE));
|
}
|
|
/**
|
* @brief Sends a byte through the SPI interface and return the byte received
|
* from the SPI bus.
|
* @param byte: byte to send.
|
* @retval The value of the received byte.
|
*/
|
uint8_t sFLASH_SendByte(uint8_t byte)
|
{
|
/*!< Loop while DR register in not emplty */
|
while (SPI_I2S_GetFlagStatus(sFLASH_SPI, SPI_I2S_FLAG_TXE) == RESET);
|
|
/*!< Send byte through the SPI1 peripheral */
|
SPI_I2S_SendData(sFLASH_SPI, byte);
|
|
/*!< Wait to receive a byte */
|
while (SPI_I2S_GetFlagStatus(sFLASH_SPI, SPI_I2S_FLAG_RXNE) == RESET);
|
|
/*!< Return the byte read from the SPI bus */
|
return SPI_I2S_ReceiveData(sFLASH_SPI);
|
}
|
|
/**
|
* @brief Sends a Half Word through the SPI interface and return the Half Word
|
* received from the SPI bus.
|
* @param HalfWord: Half Word to send.
|
* @retval The value of the received Half Word.
|
*/
|
uint16_t sFLASH_SendHalfWord(uint16_t HalfWord)
|
{
|
/*!< Loop while DR register in not emplty */
|
while (SPI_I2S_GetFlagStatus(sFLASH_SPI, SPI_I2S_FLAG_TXE) == RESET);
|
|
/*!< Send Half Word through the sFLASH peripheral */
|
SPI_I2S_SendData(sFLASH_SPI, HalfWord);
|
|
/*!< Wait to receive a Half Word */
|
while (SPI_I2S_GetFlagStatus(sFLASH_SPI, SPI_I2S_FLAG_RXNE) == RESET);
|
|
/*!< Return the Half Word read from the SPI bus */
|
return SPI_I2S_ReceiveData(sFLASH_SPI);
|
}
|
|
/**
|
* @brief Enables the write access to the FLASH.
|
* @param None
|
* @retval None
|
*/
|
void sFLASH_WriteEnable(void)
|
{
|
/*!< Select the FLASH: Chip Select low */
|
sFLASH_CS_LOW();
|
|
/*!< Send "Write Enable" instruction */
|
sFLASH_SendByte(sFLASH_CMD_WREN);
|
|
/*!< Deselect the FLASH: Chip Select high */
|
sFLASH_CS_HIGH();
|
}
|
|
/**
|
* @brief Polls the status of the Write In Progress (WIP) flag in the FLASH's
|
* status register and loop until write opertaion has completed.
|
* @param None
|
* @retval None
|
*/
|
void sFLASH_WaitForWriteEnd(void)
|
{
|
uint8_t flashstatus = 0;
|
|
/*!< Select the FLASH: Chip Select low */
|
sFLASH_CS_LOW();
|
|
/*!< Send "Read Status Register" instruction */
|
sFLASH_SendByte(sFLASH_CMD_RDSR);
|
|
/*!< Loop as long as the memory is busy with a write cycle */
|
do
|
{
|
/*!< Send a dummy byte to generate the clock needed by the FLASH
|
and put the value of the status register in FLASH_Status variable */
|
flashstatus = sFLASH_SendByte(sFLASH_DUMMY_BYTE);
|
|
}
|
while ((flashstatus & sFLASH_WIP_FLAG) == SET); /* Write in progress */
|
|
/*!< Deselect the FLASH: Chip Select high */
|
sFLASH_CS_HIGH();
|
}
|
|
/**
|
* @}
|
*/
|
|
/**
|
* @}
|
*/
|
|
/**
|
* @}
|
*/
|
|
/**
|
* @}
|
*/
|
|
/**
|
* @}
|
*/
|
|
/******************* (C) COPYRIGHT 2011 STMicroelectronics *****END OF FILE****/
|