spi读写MT25QL01Gbflash

最新推荐文章于 2024-03-14 14:04:05 发布
最新推荐文章于 2024-03-14 14:04:05 发布
阅读量1.5k 收藏 8
点赞数
分类专栏： stm32 文章标签： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36246937/article/details/120722074
版权

flash擦除是以页扇区为单位擦除，16位的falsh是三字节模式读写，超过16位使用四字节模式读写。

#include "flashspi.h"
#include "hw_types.h"
#include "hw_cm_cefuse.h"
#include "hw_cm_device.h"
#include "hw_cm_dpll.h"
#include "hw_cm_gfx.h"
#include "hw_cm_mpu.h"
#include "hw_cm_per.h"
#include "hw_cm_rtc.h"
#include "hw_cm_wkup.h"
#include "hw_control_AM335x.h"
#include "hw_emif4d.h"
#include "soc_AM335x.h"
#include "mcspi.h"
#include "gpio_v2.h"
#include "plat_gpio.h"
#include "stdlib.h"
#include "plat_mcspi.h"

#ifdef AM335X_DRIVER
    #define printf(...)   ;
#endif

static UINT8 spiFlashTxBuf[SPIFLASH_PAGESIZE + 5];
static UINT8 spiFlashRxBuf[SPIFLASH_PAGESIZE + 5];

static UINT8 statusbuf[8];


UINT32 SPIInit(INT32 spiId, UINT8 spiClockDiv, UINT8 spiDir)
{
	INT32 spiAddr;
	switch(spiId)
	{
	    case SPI_0:
	            spiAddr = MCSPI0_BASE_ADDR;
	                break;
	    case SPI_1:
	            spiAddr = MCSPI1_BASE_ADDR;
	                break;
	}

	HWREG(spiAddr + MCSPI_SYSCONFIG) |= (MCSPI_SYSCONFIG_SOFTRESET_INITIATE <<
			 MCSPI_SYSCONFIG_SOFTRESET_SHIFT);

	    /* Wait for reset to complete */
	    while(HWREG(spiAddr + MCSPI_SYSSTATUS) &
	        MCSPI_SYSSTATUS_RESETDONE_COMPLETED == 0);

	    /* Reset SPI - Bit is automatically reset by hardware*/
    HWREG(spiAddr + MCSPI_SYSCONFIG) = ((MCSPI_SYSCONFIG_AUTOIDLE_ENABLE <<
    		MCSPI_SYSCONFIG_AUTOIDLE_SHIFT) | (MCSPI_SYSCONFIG_CLOCKACTIVITY_BOTH <<
    				MCSPI_SYSCONFIG_CLOCKACTIVITY_SHIFT) |
    				(MCSPI_SYSCONFIG_SIDLEMODE_WAKEUP << MCSPI_SYSCONFIG_SIDLEMODE_SHIFT));

    /* gBoardID = 1; */		//For ICE board SPI Flash

    /* SPI System Register Configuration*/

    if (spiDir== 0)
    {
        HWREG(spiAddr + MCSPI_SYST) =
            (1 << MCSPI_SYST_SPIDATDIR0_SHIFT);
    }
    else
    {
        HWREG(spiAddr + MCSPI_SYST) =
            (1 << MCSPI_SYST_SPIDATDIR1_SHIFT);
    }

    /* Configure MCSPI Module */
    HWREG(spiAddr + MCSPI_MODULCTRL) =
    	((HWREG(spiAddr + MCSPI_MODULCTRL) &
    	~(MCSPI_MODULCTRL_SYSTEM_TEST | MCSPI_MODULCTRL_MS))
    	| ( MCSPI_MODULCTRL_SINGLE_SINGLE << MCSPI_MODULCTRL_SINGLE_SHIFT ));

    if (spiDir== 0)
    {
		HWREG ( spiAddr + MCSPI_CHCONF(0)) =
				(( MCSPI_CH0CONF_DPE0_DISABLED << MCSPI_CH0CONF_DPE0_SHIFT )
			| ( MCSPI_CH0CONF_WL_8BITS << MCSPI_CH0CONF_WL_SHIFT )
			| ( spiClockDiv << MCSPI_CH0CONF_CLKD_SHIFT )
			| ( MCSPI_CH0CONF_EPOL_ACTIVELOW << MCSPI_CH0CONF_EPOL_SHIFT )
			| ( MCSPI_CH0CONF_PHA_EVEN << MCSPI_CH0CONF_PHA_SHIFT )
			| ( MCSPI_CH0CONF_POL_ACTIVELOW << MCSPI_CH0CONF_POL_SHIFT ));
    }
    else
    {
		HWREG ( spiAddr + MCSPI_CHCONF(0)) =
				(( MCSPI_CH0CONF_DPE1_DISABLED << MCSPI_CH0CONF_DPE1_SHIFT )
			| ( MCSPI_CH0CONF_WL_8BITS << MCSPI_CH0CONF_WL_SHIFT )
			| ( MCSPI_CH0CONF_IS_LINE1 << MCSPI_CH0CONF_IS_SHIFT )
			| ( spiClockDiv << MCSPI_CH0CONF_CLKD_SHIFT )
			| ( MCSPI_CH0CONF_EPOL_ACTIVELOW << MCSPI_CH0CONF_EPOL_SHIFT )
			| ( MCSPI_CH0CONF_PHA_EVEN << MCSPI_CH0CONF_PHA_SHIFT )
			| ( MCSPI_CH0CONF_POL_ACTIVELOW << MCSPI_CH0CONF_POL_SHIFT ));
    }

    /* gBoardID = 2; */	//For ICE Board SPI Flash

    /* Configure MCSPI Channel 1 */
    HWREG ( spiAddr + MCSPI_CHCONF(1)) =
    		(( MCSPI_CH1CONF_DPE1_DISABLED << MCSPI_CH1CONF_DPE1_SHIFT )
        | ( MCSPI_CH1CONF_WL_8BITS << MCSPI_CH1CONF_WL_SHIFT )
        | ( MCSPI_CH1CONF_IS_LINE1 << MCSPI_CH1CONF_IS_SHIFT )
        | ( spiClockDiv << MCSPI_CH1CONF_CLKD_SHIFT )
        | ( MCSPI_CH1CONF_EPOL_ACTIVELOW << MCSPI_CH1CONF_EPOL_SHIFT )
        | ( MCSPI_CH1CONF_PHA_EVEN << MCSPI_CH1CONF_PHA_SHIFT )
        | ( MCSPI_CH1CONF_POL_ACTIVELOW << MCSPI_CH1CONF_POL_SHIFT ));

    /* Configure MCSPI Channel 2 */
    HWREG ( spiAddr + MCSPI_CHCONF(2)) =
    		(( MCSPI_CH2CONF_DPE1_DISABLED << MCSPI_CH2CONF_DPE1_SHIFT )
        | ( MCSPI_CH2CONF_WL_8BITS << MCSPI_CH2CONF_WL_SHIFT )
        | ( MCSPI_CH2CONF_IS_LINE1 << MCSPI_CH2CONF_IS_SHIFT )
        | ( MCSPI_CH2CONF_CLKD_DIVBY256 << MCSPI_CH2CONF_CLKD_SHIFT )
        | ( MCSPI_CH2CONF_EPOL_ACTIVELOW << MCSPI_CH2CONF_EPOL_SHIFT )
        | ( MCSPI_CH2CONF_PHA_EVEN << MCSPI_CH2CONF_PHA_SHIFT )
        | ( MCSPI_CH2CONF_POL_ACTIVELOW << MCSPI_CH2CONF_POL_SHIFT ));


    /* Configure MCSPI Channel 3 */
    HWREG ( spiAddr + MCSPI_CHCONF(3)) =
    		(( MCSPI_CH3CONF_DPE1_DISABLED << MCSPI_CH3CONF_DPE1_SHIFT )
        | ( MCSPI_CH3CONF_WL_8BITS << MCSPI_CH3CONF_WL_SHIFT )
        | ( MCSPI_CH3CONF_IS_LINE1 << MCSPI_CH3CONF_IS_SHIFT )
        | ( MCSPI_CH3CONF_CLKD_DIVBY256 << MCSPI_CH3CONF_CLKD_SHIFT )
        | ( MCSPI_CH3CONF_EPOL_ACTIVELOW << MCSPI_CH3CONF_EPOL_SHIFT )
        | ( MCSPI_CH3CONF_PHA_EVEN << MCSPI_CH3CONF_PHA_SHIFT )
        | ( MCSPI_CH3CONF_POL_ACTIVELOW << MCSPI_CH3CONF_POL_SHIFT ));

    return spiAddr;
}


void SPICycle( UINT32 spiAddr, UINT8 *buf, UINT16 len, UINT16 chNum )
{
	UINT32 i;
	/* Enable Channel */
    if (chNum > 0)
    	chNum = 1;   /*In SUBARTIC only two channels are used*/

    HWREG ( spiAddr + MCSPI_CHCTRL(chNum)) = MCSPI_CH0CTRL_EN_ACTIVE;
    GPIOCs_Write(6,0);
    forLoop();

    /* SPI access cycle */
    HWREG ( spiAddr + MCSPI_CHCONF(chNum)) |=
	    ( MCSPI_CH0CONF_FORCE_ASSERT << MCSPI_CH0CONF_FORCE_SHIFT ) ;

    /* SPI System Register Configuration*/
	HWREG(spiAddr + MCSPI_SYST) = (HWREG(spiAddr + MCSPI_SYST) &
		   ~MCSPI_SYST_SPIEN_0);

    for ( i = 0 ; i < len ; i++ )
    {

    	/* Wait for transmit empty */
        while ( ( HWREG(spiAddr + MCSPI_CHSTAT(chNum))
				& TX_EMPTY_FLAG) == 0 );

        HWREG (spiAddr + MCSPI_TX(chNum)) = buf[i]; // Write to TX buf

        /* Wait for receive data full */
        while ( (HWREG(spiAddr + MCSPI_CHSTAT(chNum))&
				RX_FULL_FLAG) == 0 );
        buf[i] = HWREG ( spiAddr + MCSPI_RX(chNum));// Read from RX buf
    }

#if 0
    for ( i = 0 ; i < len ; i++ )
    	UARTPrint1("SPI Data", buf[i]);
#endif

    HWREG ( spiAddr + MCSPI_CHCONF(chNum)) =
    		(HWREG ( spiAddr + MCSPI_CHCONF(chNum)) &
          ~( MCSPI_CH0CONF_FORCE)) ;

	HWREG(spiAddr + MCSPI_SYST) |= (1 << MCSPI_SYST_SPIEN_0_SHIFT);
	GPIOCs_Write(6,1);
	/* Disable Channel */
	HWREG ( spiAddr + MCSPI_CHCTRL(chNum)) = MCSPI_CH0CTRL_EN_INACTIVE;
	forLoop();
}


void SPIRead( UINT32 spiAddr, UINT8 *buf, UINT16 len, UINT16 chNum)
{
    SPICycle( spiAddr, buf, len, chNum);
}


void SPIWrite( UINT32 spiAddr, UINT8 *buf, UINT16 len, UINT16 chNum)
{
    SPICycle( spiAddr, buf, len, chNum);
}


void forLoop()
{
	volatile int loop;
	for(loop = 0; loop < 1000; loop++);
}


UINT8 spiFlashStatus( UINT32 spiAddr)
{
    /* Issue read status command */
    statusbuf[0] = SPIFLASH_CMD_RDSR;
    statusbuf[1] = 0;
    SPIRead(spiAddr, statusbuf, SPI_STATUS_LEN, SPI_FLASH_CH);
    return statusbuf[1];
}


void setFlash4Byte(UINT32 spiAddr)
{
	spiFlashTxBuf[0] = CMD_ENTER_4_BYTE;
	SPIWrite(spiAddr, spiFlashTxBuf, SPI_WPEN_LEN, SPI_FLASH_CH);
}


INT32 SPI_FlashReadID (UINT32 spiAddr)
{
    statusbuf[0] = SPIFLASH_CMD_READID;
    statusbuf[1] = 0x00;
    statusbuf[2] = 0x00;
    statusbuf[3] = 0x00;

    SPIRead(spiAddr, statusbuf, MFID_DEVID_LEN, SPI_FLASH_CH);

    printf ("ID read is 0x%x.\r\n", statusbuf[1]);
    printf ("ID read is 0x%x.\r\n", statusbuf[2]);
    printf ("ID read is 0x%x.\r\n", statusbuf[3]);

    return (0);
}


void SPI_FlashRead( UINT32 src, UINT32 *dst, UINT32 length, UINT32 spiAddr )
{
    INT32 i, j = 0;
    unsigned int allLen = 0, readLen = 0;
    // Setup command

    for (allLen = 0; allLen < length; allLen += SPIFLASH_PAGESIZE)
    {
    	readLen = (length -  allLen) >  SPIFLASH_PAGESIZE ? SPIFLASH_PAGESIZE:(length -  allLen);

    	spiFlashRxBuf[0] = SPIFLASH_CMD_READPAGE;
		spiFlashTxBuf[1] = ( src >> SHIFT_24BIT);
		spiFlashRxBuf[2] = ( src >> SHIFT_WORD );
		spiFlashRxBuf[3] = ( src >> SHIFT_BYTE );
		spiFlashRxBuf[4] = ( src >> 0 );

		// Execute SPIFLASH read cycle
		SPIRead(spiAddr, spiFlashRxBuf, readLen + 5, SPI_FLASH_CH);

		for ( i = 0 ; i < length ; i++ )
		{
			dst[j] = spiFlashRxBuf[5+i];
			j++;
		}
		src += readLen;
    }

    return;
}


UINT8 SPI_FlashErase(UINT32 offset, UINT32 length, UINT32 spiAddr )
{
	UINT16 quitLoop = 0;
	UINT32 itr;

	printf("Flash erase offset = %d , length = %d \n",offset, length);
	if (offset % SPIFLASH_SECTORSIZE || length % SPIFLASH_SECTORSIZE) {
		printf("SF: Erase offset/length not multiple of sector size\n");
		return 0xFF;
	}
	length /= SPIFLASH_SECTORSIZE;
    /* Issue WPEN */
	for (itr = 0; itr < length; itr++)
	{
		//printf("Erasing sector @ %d \n",offset);
		if((spiFlashStatus( spiAddr )& FLASH_WEL_STATUS) != FLASH_WEL_STATUS)
		{
			spiFlashTxBuf[0] = SPIFLASH_CMD_WREN;
			SPIWrite(spiAddr, spiFlashTxBuf, SPI_WPEN_LEN, SPI_FLASH_CH);
			while(( spiFlashStatus( spiAddr ) & FLASH_WEL_STATUS ) != FLASH_WEL_STATUS )
			{
				quitLoop = quitLoop + 1;
				if(quitLoop > 200)
					break;
			}
		}

		/* Issue Erase */
		spiFlashTxBuf[0] = SPIFLASH_CMD_SCTR_ERASE;//SPIFLASH_CMD_ERASE;
		spiFlashTxBuf[1] = ( UINT8 )( offset >> SHIFT_24BIT);
		spiFlashTxBuf[2] = ( UINT8 )( offset >> SHIFT_WORD );
		spiFlashTxBuf[3] = ( UINT8 )( offset >> SHIFT_BYTE );
		spiFlashTxBuf[4] = ( UINT8 )( offset );
		SPIWrite(spiAddr, spiFlashTxBuf, SPI_ERASE_LEN, SPI_FLASH_CH);

		while( ( spiFlashStatus( spiAddr) & FLASH_STATUS ) );

	#ifdef VERIFY_SECTOR_ERASE
		verifyErasedSector(offset,spiAddr);
	#endif

		offset += SPIFLASH_SECTORSIZE;
	}
	return 0;
}


void SPI_FlashWrite( UINT32 src, UINT32 dst, UINT32 length, UINT32 spiAddr )
{
    INT32 i;
    INT32 bytesLeft;
    INT32 bytesToProgram;
    UINT8 *psrc;
    UINT16 quitLoop;
    volatile int loop;

    /* Establish source */
    psrc = ( UINT8 * )src;
    bytesLeft = length;

    while ( bytesLeft > 0 )
    {
    	bytesToProgram = bytesLeft;

        /* Most to program is SPIFLASH_CMD_BLOCKSIZE */
        if ( bytesToProgram > SPIFLASH_PAGESIZE )
             bytesToProgram = SPIFLASH_PAGESIZE;

        /* Make sure you don't run off the end of a block */
        if ( ( dst & SPIFLASH_PAGEMASK ) != ( ( dst + bytesToProgram )
            & SPIFLASH_PAGEMASK ) )

            bytesToProgram -= ( dst + bytesToProgram ) -
                ( ( dst + bytesToProgram ) & SPIFLASH_PAGEMASK );

        /* Issue WPEN */
        quitLoop = 0;
        if((spiFlashStatus( spiAddr)& FLASH_WEL_STATUS) != FLASH_WEL_STATUS)
        {
            spiFlashTxBuf[0] = SPIFLASH_CMD_WREN;
            SPIWrite(spiAddr, spiFlashTxBuf, SPI_WPEN_LEN, SPI_FLASH_CH);

            while( ( spiFlashStatus( spiAddr) & FLASH_WEL_STATUS ) != FLASH_WEL_STATUS)
            {
				 quitLoop = quitLoop + 1;
				 if(quitLoop > 200)
					 break;
            }
        }

        /* Create command block for program operation */
        spiFlashTxBuf[0] = SPIFLASH_CMD_WRITE;
        spiFlashTxBuf[1] = ( UINT8 )( dst >> SHIFT_24BIT);
        spiFlashTxBuf[2] = ( UINT8 )( dst >> SHIFT_WORD );
        spiFlashTxBuf[3] = ( UINT8 )( dst >> SHIFT_BYTE );
        spiFlashTxBuf[4] = ( UINT8 )( dst );
        forLoop();

        for ( i = 0 ; i < bytesToProgram ; i++ )
            spiFlashTxBuf[5+i] = *psrc++;


        /* Execute write command */
	    SPIWrite(spiAddr, spiFlashTxBuf, bytesToProgram + 5, SPI_FLASH_CH);
        /* Wait while busy */
        //while( ( spiFlashStatus( spiAddr) & FLASH_STATUS ) );

        /* Get ready for next iteration */
        bytesLeft -= bytesToProgram;
        dst += bytesToProgram;
    }
}



#ifndef _FLASHSPI_H_
#define _FLASHSPI_H_
#include "userType.h"

#define SPIFLASH_PAGESIZE         256    //  一个页大小
#define SPIFLASH_SECTORSIZE       4096   //  扇区大小
#define FPGA_SIZE   64*1024*1024

#define SPI_0  0
#define SPI_1  1
#define MCSPI0_BASE_ADDR  SOC_SPI_0_REGS
#define MCSPI1_BASE_ADDR  SOC_SPI_1_REGS
#define TX_EMPTY_FLAG	  0x02
#define RX_FULL_FLAG	  0x01

//  READLEN
#define SPI_WPEN_LEN	  1
#define SPI_STATUS_LEN	  2
#define SPI_ERASE_LEN	  5
#define MFID_DEVID_LEN	  8
#define	SHIFT_BYTE		  8
#define	SHIFT_WORD		  16
#define SHIFT_24BIT       24

#define SPIFLASH_MANUF_ID	  0xEF

#define SPI_FLASH_CH 0

#define SPIFLASH_PAGEMASK         0xffffffc0

//  CMD

#define SPIFLASH_CMD_WREN         0x06
#define SPIFLASH_CMD_READ         0x03
#define SPIFLASH_CMD_WRDI         0x04
#define SPIFLASH_CMD_RDSR         0x05
#define SPIFLASH_CMD_WRITE        0x12
#define SPIFLASH_CMD_READPAGE     0x13
#define SPIFLASH_CMD_READID		  0x9E
#define SPIFLASH_CMD_ERASE		  0xD8
#define SPIFLASH_CMD_SCTR_ERASE	  0x20
#define CMD_ENTER_4_BYTE          0xb7

#define FLASH_STATUS		    0x01
#define FLASH_WEL_STATUS		0x02

UINT32 SPIInit(INT32 spiId, UINT8 spiClockDiv, UINT8 spiDir);

void SPICycle( UINT32 spiAddr, UINT8 *buf, UINT16 len, UINT16 chNum);

void SPIRead( UINT32 spiAddr, UINT8 *buf, UINT16 len, UINT16 chNum);

void SPIWrite( UINT32 spiAddr, UINT8 *buf, UINT16 len, UINT16 chNum);

INT32 SPI_FlashReadID (UINT32 spiAddr);

UINT8 SPI_FlashErase(UINT32 offset, UINT32 length, UINT32 spiAddr );

void SPI_FlashRead( UINT32 src, UINT32 *dst, UINT32 length, UINT32 spiAddr );

void SPI_FlashWrite( UINT32 src, UINT32 dst, UINT32 length, UINT32 spiAddr );

void forLoop();

void setFlash4Byte(UINT32 spiAddr);

UINT8 spiFlashStatus( UINT32 spiAddr);
#endif
raindrops.
关注
  • 0
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
软件模拟SPI时序实现25Q64读写操作
zhangyl001的博客
12-01 7269
软件模拟SPI时序实现25Q64读写操作 单片机采用SPI/IIC通讯协议访问外围电子模块如：显示屏、EEPROM、FLASH、各种电子传感器等等越来越多，掌握SPI/IIC通讯协议访问外设非常有必要。 Aarduino是我比较喜欢的平台，虽然它有硬件SPI接口，有封装的函数，但为了更深入了解SPI协议和读写25Q64，还是选择软件模拟比较好。 第一部分SPI简介 SPI是英语Serial Peripheral Interface的缩写，顾名思义就是串行外围设备接口。SPI是一种高速的、全双工、同步通信总.
Linux的SPI应用（四）----访问Nor Flash（MT25QL01GBBB）
CLL的博客
03-14 5350
SPI FLASH的一些主要的命令的时序：读，写，擦除，写使能，读寄存器等。 Flash的特性是，写数据只能将1写为0，0不能写为1。擦除数据是将所有数据都写为1，因此如果想在已经数据的Flash上写入新的数据，则必须先擦除。 以MT25为例来讲解QSPI FLASH的一些主要的命令的时序。这里只讨论Extended SPI，Dual SPI和Qual SPI就不讨论了,这三种模式的差异仅仅体...
STM32103 SPI FLASH
11-15
STM32103 SPI 读写FLASH 用了DMA 大块搬运数据，芯片支持W25Q系列跟SST25V16系列
ATO(韩商爱拓)1Gbit SPI NAND Flash领先全球
芯片旅行号
09-29 2352
NAND Flash设计公司ATO Solution(CEO: Park, Chan-Woong)日前宣布，继256Mb、512Mbit与1Gbit SLC NAND flash之后，该公司开发自有设计之1Gbit NAND SPI(Serial Peripheral Interface) Flash。现行市场之SPI Flash Memories普遍是以NOR Flash技术架构为主，但AT
MT25QL256数据手册
07-06
MT25QL256系列数据手册
FPGA 外置Flash的读写，用户数据存储
qsj_csdn的博客
03-29 1万+
FPGA 外置Flash的读写，用户数据存储前言一，该功能验证平台及参考文章1，Xilinx xc7k325tffg676-22，vivado 2017.43，验证的flash芯片：MT25QL2563，参考文章：MT25QL256_datasheet二、实现的功能1，read Device ID2，设置4-byte模式5，flash的数据读写三，部分代码总结 前言 大多数FPGA内部不具有掉电存储程序的功能，所以都是外置flash存储器来存储程序，上电后加载flash中的程序到FPGA中，在运行。外置f
【NOR闪存】MT25TL256BBA8ESF-0AAT 256Mbit、MT25TL01GBBB8ESF-0AAT 1Gbit 16-SOP
06-13 483
Micron串行NOR闪存可满足消费电子、工业、有线通信以及计算应用的需求。
vivado下MT25qu02g Flash 固化
jiguangshen的博客
08-05 1951
方法一：二进制bin文件固化 1.在Vivado 软件中找到Setting设置，进入，点击Bitstream选项，将bin_file勾选上，点击ok. 2.点击 generate bitstream，生成bit文件和 bin文件. 3.点击 Open Hardware Manager， 连接到板子. 4.在 Hardware面板中点击 (xc7vx290t)，选择 Add Configuration Memery Device. 5.找到Flash存储型号，点击ok，开发板的Flash型号时（.
MT25QL256ABA_v2p6p1_mt25qu256开发_MT25Ql256A驱动_mt25ql_MT25QL256ABA
09-28
MT25QL详细资料，驱动代码编写参考，
基于FPGA读写MT25QL FLASH芯片
最新发布
m0_66360845的博客
03-14 1841
FLASH存储器又称闪存，是一种长寿命的非易失性存储器，一般用来保存一些重要的设置信息或者程序等等。本文将在介绍FLASH有关的基础知识后，说明如何配置MT25QL128ABA这块FLASH芯片，包含对相关指令的解析和读写操作需要注意的点，当然，仿真图必不可少了，文中也有给出相应的仿真图。
基于 MT28EW的FLASH控制原理
weixin_44482267的博客
04-08 1120
基于 MT28EW的FLASH控制原理 本设计是基于MT28EW_QLLP_01G_ABA_0SIT-1287008的控制器 FLASH控制原理及命令
利用ZYNQ102 106 SDK中的SPI demo，对mt28ew01ga QSPI Flash 读写操作超过32MB的方法
Deep_win的博客
08-18 1207
关键字：ZYNQ、 Xilinx、FPGA、QSPI FLASH Qspi Flash 操作基础扫盲： 1.支持擦除单位：一个扇区，64KB 子扇区 4KB 2.写操作单位：一页，256byte 3.默认情况下Flash操作地址为3个字节，对于超过16MB的Flash，需要使能4字节地址 4.任何写操作执行之前都必须先执行写使能操作 FLASH的芯片手册上描述了 write extended address register详细的操作说明 对该寄存器设置一个值(value)，那么片内操作的.
MT25QL128/MTQL256_FLASH驱动——基于华大单片机
weixin_47041339的博客
07-10 3334
MT25QL256驱动，基于华大单片机的驱动，SPI_FLASH
第24章 QSPI—读写串行FLASH
xqhrs232的专栏
12-24 5175
原文地址::https://www.cnblogs.com/firege/p/9435349.html 本章参考资料：《STM32F76xxx参考手册》、《STM32F76xxx规格书》、库帮助文档《STM32F779xx_User_Manual.chm》及《SPI总线协议介绍》。 若对SPI通讯协议不了解，可先阅读《SPI总线协议介绍》文档的内容学习。 关于FLASH存储器，请参考“常用存储器介绍”章节，实验中FLASH芯片的具体参数，请参考其规格书《W25Q128》来了解。 24.1 Q..
STM32存储左右互搏 QSPI总线读写FLASH W25QXX
Pegasus的软件博客
02-01 1227
W25QXX的SOIC封装如下所示，在采用QUAL SPI而不是SPI时，管脚定义为：即由片选(/CS), 时钟(CLK), 双向4根输入输出线(IO0, IO1, IO2, IO3)组成6线QSPI信号接口。VCC和GND提供电源和接地连接。例程采用STM32H750VBT6芯片, FLASH可以选择为8/16/32/64/128/256/512/1024 Mbit的W25Q型号。
STM32F7QSPI学习笔记——读写N25Q128
热门推荐
分享嵌入式Linux技术知识
10-06 1万+
一、QSPI接口介绍 QUADSPI 是一种专用的通信接口，连接单、双或四（条数据线）SPI Flash 存储介质。该接口可以在以下三种模式下工作：  间接模式：使用 QUADSPI 寄存器执行全部操作，支持对FALSH进行读、写、擦除、锁定等操作。  状态轮询模式：周期性读取外部 Flash 状态寄存器，而且标志位置 1 时会产生中断（如擦除或烧写完成，会产生中断）  内存映射模式...
教程：AT32F435 QSPI 读写W25Q256
liliquan2的博客
05-21 4599
3 字节地址模式，当 ADS=1 的时候，表示当前是 4 字节地址模式，我们需要使用 4 字节地址模。不可以写 1 的特性，所以在写入数据的时候，一般需要先擦除（归 1），再写。位，表示 W25Q256 当前的地址模式，是一个只读位，当 ADS=0 的时候，表示当前是。位，用于表示擦除/编程操作是否正在进行，当擦除/编程操作正在进行时，此位为 1，指令，用于读取 FLASH 数据，在发送完该指令以后，就可以读取 W25Q256。指令，用于编程 FLASH（写入数据到 FLASH），该指令发送完成后，最。
uboot笔记--SF: unrecognized JEDEC id bytes: 20, ba, 20 解决
中华田园巨龙
07-06 6564
介绍   在移植开发板过程中，启动过程遇到了一个报错 SF: unrecognized JEDEC id bytes: 20, ba, 20   查看说明是由于无法识别flash的ID导致。下面详细说下解决过程。 解决步骤 （1）添加INFO到driver下面的源文件中 首先用source insight查看uboot源代码，发现在driver/mtd/spi/spi_flash.c下面出现的这句报错： 是由于识别到的flash ID与系统中的ID不匹配，系统中ID在spi_flash_ids.c这个文
Uboot spi-nor 设备信息定义及3地址模式和4地址模式的理解
恍恍惚惚的大穷猫的博客
09-08 2414
Uboot spi nor flash 设备的使用和测试以及调试，部分代码的讲解。
MT25QL256ABA1EW9-0SIT性能指标和作用
06-03
MT25QL256ABA1EW9-0SIT是一款QSPI接口的闪存存储器件，具有以下主要性能指标： 1. 存储密度：256Mb (32MB) 2. 读取速度：100MHz QSPI时钟频率下，最高读取速度可以达到533MB/s 3. 写入速度：100MHz QSPI时钟频率下，最高写入速度可以达到65MB/s 4. 工作电压：2.7V ~ 3.6V 5. 工作温度范围：-40°C ~ 85°C MT25QL256ABA1EW9-0SIT可以用于嵌入式系统中的代码和数据存储，具有以下作用： 1. 加载嵌入式系统的引导程序 2. 存储嵌入式系统的代码和数据 3. 存储嵌入式系统的配置文件和参数 4. 用于嵌入式系统的升级和更新 5. 用于数据记录和存储，如传感器数据等。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值