S25FL系列FLASH读写的FPGA实现

文章目录

实现思路

建议读者先对 S25FL-S 系列 FLASH 进行了解,我之前的博文中有详细介绍。

笔者的芯片具体型号为 S25FL256SAGNFI00,存储容量 256Mb,增强高性能 EHPLC,4KB 与 64KB 混合 Sector 的存储阵列,256 Byte 的 Page Programming Buffer 大小,最高支持 133MHz,无硬复位 RESET# 引脚。

为简单起见,采用 SDR 时钟模式;为了兼顾读写速度,采用 Quad mode;同时考虑到 Quad Page Programming 地址只能通过 SI 单线传输,因此读、写 FLASH 分别采用 Quad Output Read、Quad Page Programming,以实现时序格式的统一,简化编程。

由于 S25FL-S 在 SCK 上升沿锁存数据,在 SCK 下降沿转换数据,因此主控端应在 SCK 下降沿转换数据,在 SCK 上升沿锁存数据

由于写 FLASH 需要先进行写使能以及擦除操作,而擦除操作需要检查 WIP bit(SR1[0]);要使用 Quad 读写模式,需要置位 Quad bit(CR1[1]);要判断地址映射类型和四元读模式下的 Dummy 长度,需要实现读写寄存器。因此需要实现以下功能:写使能 WREN、写失能 WRDI、写寄存器 WRR、清除状态寄存器 CLSR、读状态寄存器 RDSR1/RDSR2、读配置寄存器 RDCR、擦除操作(扇区擦除 4SE、批量擦除 BE)、四元编程操作 4QPP、Quad Output Read 操作 4QOR 等。

为每一种功能单独写一个模块当然也是可行的思路,但过于繁杂;观察到在时序层面上述指令可以归类为简单的 5 种:单 8bit 指令 (如 WREN、WRDI、CLSR、BE 等)、写寄存器 (8bit 指令后跟随 1~4Byte 数据,SI 单线传输,如 WRR、ABWR、BRWR 等,甚至 8bit 指令 + 4Byte 地址的 4SE 也可归于此类)、读寄存器 (8bit 指令(SI)后跟随 1~4Byte 输出(SO),如 RDSR1、RDSR2、RDCR1、ABRD、BRRD 等)、四元写 FLASH (8bit 指令(SI)+ 32bit 地址(SI)+ 1~256Byte 数据(IO0~IO3写),如 4QPP)、四元读 FLASH (8bit 指令(SI)+ 32bit 地址(SI)+ xbit Dummy + xByte 数据(IO0~IO3读回),如 4QOR)。

因此可以首先实现以上几个基础模块,然后根据需要在上层模块中用状态机控制几个基础模块的运行。

具体实现

由于本示例实现中每个子模块都涉及 FLASH_IO 这组 inout 线的操作,因此有注意事项如下:

每个 FPGA 管脚上都要有 IBUF、OBUF 或 IOBUF,input/output 管脚上 IBUF/OBUF 会自动生成,而 inout 管脚需要用户编写,要么用 IOBUF,要么直接用 link? xx_OBUF : 1'bz 这种形式(其实后者也是生成了一个 OBUF 和一个 IBUF)。

对于每个 FPGA 管脚,只能由一个 OBUF 驱动,因此如果多个子模块要用 inout 操作同一根线,会出问题(这种情况下 vivado 会自动生成 IBUF,导致模块大部分逻辑无效化,进而在综合后整个模块被优化掉,即使强制关闭 IBUF/OBUF 自动插入功能,也会因为多个 OBUF 驱动同一管脚而综合失败)。

** 因此子模块不能再保有 inout,而是通过操作顶层模块的 IOBUF 实现数据读写**,具体实现方式为:子模块关于 FLASH_IO 的接口设计为两个单向接口(FLASH_IO_IBUF、FLASH_IO_OBUF),并给出何时使能 O_BUF 的 link 信号;顶层模块根据状态仲裁接通哪路子模块,并根据对应的 link 决定驱动方向。

子模块实现

  • 单条指令
verilog 复制代码
/* 
 * file			: flash_instruction.v
 * author		: 今朝无言
 * Lab			: WHU-EIS-LMSWE
 * date			: 2023-11-15
 * version		: v2.0
 * description	: 单条 8bit 指令,从而支持诸如 WREN、WRDI、Bulk Erase 等指令
 * Copyright © 2023 WHU-EIS-LMSWE, All Rights Reserved.
 */
`default_nettype none
module flash_instruction(
input	wire			clk,
input	wire			rst_n,

output	wire			FLASH_SCK,
output	reg				FLASH_nCS,

output	reg		[3:0]	link,
output	reg		[3:0]	FLASH_IO_OBUF,
input	wire	[3:0]	FLASH_IO_IBUF,

//usr interface
input	wire			send_en,		//上升沿有效
input	wire	[7:0]	instruction,
output	reg				busy
);

reg		FLASH_nCS	= 1'b1;
assign	FLASH_SCK	= FLASH_nCS? 1'b1 : clk;	//SPI mode 3

reg		[3:0]	link			= 4'h0;
reg		[3:0]	FLASH_IO_OBUF	= 4'hf;

//--------------------------------------------------
wire	send_en_pe;
reg		send_en_d0;
reg		send_en_d1;

always @(posedge clk) begin
	send_en_d0	<= send_en;
	send_en_d1	<= send_en_d0;
end

assign	send_en_pe	= send_en_d0 & (~send_en_d1);

//--------------------FSM---------------------------
localparam	S_IDLE		= 8'h01;
localparam	S_COMMAND	= 8'h02;
localparam	S_STOP		= 8'h04;

reg		[7:0]	state	= S_IDLE;
reg		[7:0]	next_state;

reg		[2:0]	cnt		= 3'd0;

always @(posedge clk or negedge rst_n) begin
	if(~rst_n) begin
		state	<= S_IDLE;
	end
	else begin
		state	<= next_state;
	end
end

always @(*) begin
	case(state)
	S_IDLE: begin
		if(send_en_pe) begin
			next_state	<= S_COMMAND;
		end
		else begin
			next_state	<= S_IDLE;
		end
	end
	S_COMMAND: begin
		if(cnt >= 3'd7) begin
			next_state	<= S_STOP;
		end
		else begin
			next_state	<= S_COMMAND;
		end
	end
	S_STOP: begin
		next_state	<= S_IDLE;
	end
	default: begin
		next_state	<= S_IDLE;
	end
	endcase
end

//FLASH_nCS
always @(negedge clk) begin
	case(state)
	S_COMMAND: begin
		FLASH_nCS	<= 1'b0;
	end
	default: begin
		FLASH_nCS	<= 1'b1;
	end
	endcase
end

//cnt
always @(posedge clk) begin
	case(state)
	S_IDLE: begin
		cnt		<= 3'd0;
	end
	S_COMMAND: begin
		if(~FLASH_nCS) begin
			cnt		<= cnt + 1'b1;
		end
		else begin
			cnt		<= 3'd0;
		end
	end
	S_STOP: begin
		cnt		<= 3'd0;
	end
	default: begin
		cnt		<= cnt;
	end
	endcase
end

//FLASH_IO_OBUF
always @(negedge clk) begin		//在SCK下降沿转换数据
	case(state)
	S_COMMAND: begin
		FLASH_IO_OBUF[0]	<= instruction[3'd7-cnt];	//首先移出MSB
		FLASH_IO_OBUF[3:1]	<= 3'b111;
	end
	default: begin
		FLASH_IO_OBUF	<= 4'hf;
	end
	endcase
end

//link
always @(negedge clk) begin
	case(state)
	S_COMMAND: begin
		link	<= 4'b1101;
		//指令阶段,SO应维持高阻,WP#、HOLD#应拉高;
		//而WP#、HOLD#内部有上拉电阻,因此IO1~IO3可以直接释放掉
		//不过为保险起见,这里还是强制拉高IO2/IO3,而IO1可以释放掉
	end
	default: begin
		link	<= 4'h0;
	end
	endcase
end

//busy
always @(*) begin
	case(state)
	S_IDLE: begin
		busy	<= 1'b0;
	end
	S_COMMAND, S_STOP: begin
		busy	<= 1'b1;
	end
	default: begin
		busy	<= 1'b0;
	end
	endcase
end

endmodule
  • 读寄存器
verilog 复制代码
/* 
 * file			: flash_RDR.v
 * author		: 今朝无言
 * Lab			: WHU-EIS-LMSWE
 * date			: 2023-11-15
 * version		: v2.0
 * description	: 读寄存器,支持1~4Byte读取,从而支持对SR1、SR2、CR1、ABR、BAR等寄存器的读取
 * Copyright © 2023 WHU-EIS-LMSWE, All Rights Reserved.
 */
`default_nettype none
module flash_RDR(
input	wire			clk,
input	wire			rst_n,

output	wire			FLASH_SCK,
output	reg				FLASH_nCS,

output	reg		[3:0]	link,
output	reg		[3:0]	FLASH_IO_OBUF,
input	wire	[3:0]	FLASH_IO_IBUF,

//usr interface
input	wire			read_en,		//上升沿有效
input	wire	[7:0]	instruction,

input	wire	[3:0]	Register_Len,	//寄存器长度,1/2/4 Byte
output	reg 	[31:0]	Reg,			//低位对齐。即1Byte的寄存器占用Reg[7:0],4Byte的寄存器占用Reg[31:0]

output	reg				busy
);

reg		FLASH_nCS	= 1'b1;
assign	FLASH_SCK	= FLASH_nCS? 1'b1 : clk;	//SPI mode 3

reg		[3:0]	link			= 4'h0;
reg		[3:0]	FLASH_IO_OBUF	= 4'hf;

wire	read_en_pe;
reg		read_en_d0;
reg		read_en_d1;

always @(posedge clk) begin
	read_en_d0	<= read_en;
	read_en_d1	<= read_en_d0;
end

assign	read_en_pe	= read_en_d0 & (~read_en_d1);

//--------------------FSM---------------------------
localparam	S_IDLE		= 8'h01;
localparam	S_COMMAND	= 8'h02;
localparam	S_RDR		= 8'h04;
localparam	S_STOP		= 8'h08;

reg		[7:0]	state	= S_IDLE;
reg		[7:0]	next_state;

reg		[2:0]	cnt			= 3'd0;		//Byte内bit计数
reg		[3:0]	cnt_Byte	= 4'd0;

always @(posedge clk or negedge rst_n) begin
	if(~rst_n) begin
		state	<= S_IDLE;
	end
	else begin
		state	<= next_state;
	end
end

always @(*) begin
	case(state)
	S_IDLE: begin
		if(read_en_pe) begin
			next_state	<= S_COMMAND;
		end
		else begin
			next_state	<= S_IDLE;
		end
	end
	S_COMMAND: begin
		if(cnt >= 3'd7) begin
			next_state	<= S_RDR;
		end
		else begin
			next_state	<= S_COMMAND;
		end
	end
	S_RDR: begin
		if(cnt >= 3'd7 && cnt_Byte >= Register_Len - 1'b1) begin
			next_state	<= S_STOP;
		end
		else begin
			next_state	<= S_RDR;
		end
	end
	S_STOP: begin
		next_state	<= S_IDLE;
	end
	default: begin
		next_state	<= S_IDLE;
	end
	endcase
end

//FLASH_nCS
always @(negedge clk) begin
	case(state)
	S_COMMAND, S_RDR: begin
		FLASH_nCS	<= 1'b0;
	end
	default: begin
		FLASH_nCS	<= 1'b1;
	end
	endcase
end

//cnt
always @(posedge clk) begin
	case(state)
	S_IDLE: begin
		cnt		<= 3'd0;
	end
	S_COMMAND, S_RDR: begin		//将cnt设计为3bit位宽,可实现模8加
		if(~FLASH_nCS) begin
			cnt		<= cnt + 1'b1;
		end
		else begin
			cnt		<= 3'd0;
		end
	end
	S_STOP: begin
		cnt		<= 3'd0;
	end
	default: begin
		cnt		<= cnt;
	end
	endcase
end

//cnt_Byte
always @(posedge clk) begin
	case(state)
	S_RDR: begin
		if(cnt==3'd7) begin
			cnt_Byte	<= cnt_Byte + 1'b1;
		end
		else begin
			cnt_Byte	<= cnt_Byte;
		end
	end
	default: begin
		cnt_Byte	<= 4'd0;
	end
	endcase
end

//FLASH_IO_OBUF
always @(negedge clk) begin		//在SCK下降沿转换数据
	case(state)
	S_COMMAND: begin
		FLASH_IO_OBUF[0]	<= instruction[3'd7-cnt];	//首先移出MSB
		FLASH_IO_OBUF[3:1]	<= 3'b111;
	end
	default: begin
		FLASH_IO_OBUF	<= 4'hf;
	end
	endcase
end

//link
always @(negedge clk) begin
	case(state)
	S_COMMAND: begin
		link	<= 4'b1101;
	end
	S_RDR: begin
		link	<= 4'h0;
	end
	default: begin
		link	<= 4'h0;
	end
	endcase
end

//read reg
wire	SO	= FLASH_IO_IBUF[1];
always @(posedge clk or negedge rst_n) begin	//须在SCK上升沿锁存数据
	if(~rst_n) begin
		Reg		<= 32'd0;
	end
	else begin
		case(state)
		S_RDR: begin
			Reg		<= {Reg[30:0], SO};		//移位寄存来自SO的值
		end
		default: begin
			Reg		<= Reg;
		end
		endcase
	end
end

//busy
always @(*) begin
	case(state)
	S_IDLE: begin
		busy	<= 1'b0;
	end
	default: begin
		busy	<= 1'b1;
	end
	endcase
end

endmodule
  • 写寄存器
verilog 复制代码
/* 
 * file			: flash_WRR.v
 * author		: 今朝无言
 * Lab			: WHU-EIS-LMSWE
 * date			: 2023-11-15
 * version		: v2.0
 * description	: 写寄存器,支持 1Byte ~ 4Byte 的写入,
 * 				  从而支持对 SR1、CR1、ABR、BAR 等寄存器的写入操作,
 * 				  以及Sector Erase擦除命令
 * Copyright © 2023 WHU-EIS-LMSWE, All Rights Reserved.
 */
`default_nettype none
module flash_WRR(
input	wire			clk,
input	wire			rst_n,

output	wire			FLASH_SCK,
output	reg				FLASH_nCS,

output	reg		[3:0]	link,
output	reg		[3:0]	FLASH_IO_OBUF,
input	wire	[3:0]	FLASH_IO_IBUF,

//usr interface
input	wire			send_en,		//上升沿有效
input	wire	[7:0]	instruction,

input	wire	[3:0]	Register_Len,	//寄存器长度,1/2/4 Byte
input	wire	[7:0]	Byte1,
input	wire	[7:0]	Byte2,
input	wire	[7:0]	Byte3,
input	wire	[7:0]	Byte4,

output	reg				busy
);
//使用示例:对于单写SR1寄存器,令Reg_Len=1,并在Byte1给出要写入SR1的值;
//对于写CR1,需要用到2Byte的形式,令Reg_Len=2,Byte1=SR1,Byte2=CR1;
//对于Autiboot Reister,Len=4,Byte1~4分别为ABR[31:24]、ABR[23:16]、ABR[15:8]、ABR[7:0];
//其余写寄存器指令依此类推
//甚至对于4SE擦除操作,Byte1~4可直接用作Sector地址使用

reg		FLASH_nCS	= 1'b1;
assign	FLASH_SCK	= FLASH_nCS? 1'b1 : clk;	//SPI mode 3

reg		[3:0]	link			= 4'h0;
reg		[3:0]	FLASH_IO_OBUF	= 4'hf;

wire	send_en_pe;
reg		send_en_d0;
reg		send_en_d1;

always @(posedge clk) begin
	send_en_d0	<= send_en;
	send_en_d1	<= send_en_d0;
end

assign	send_en_pe	= send_en_d0 & (~send_en_d1);

//--------------------FSM---------------------------
localparam	S_IDLE		= 8'h01;
localparam	S_COMMAND	= 8'h02;
localparam	S_WRR		= 8'h04;
localparam	S_STOP		= 8'h08;

reg		[7:0]	state	= S_IDLE;
reg		[7:0]	next_state;

reg		[2:0]	cnt			= 3'd0;		//Byte内bit计数
reg		[3:0]	cnt_Byte	= 4'd0;

always @(posedge clk or negedge rst_n) begin
	if(~rst_n) begin
		state	<= S_IDLE;
	end
	else begin
		state	<= next_state;
	end
end

always @(*) begin
	case(state)
	S_IDLE: begin
		if(send_en_pe) begin
			next_state	<= S_COMMAND;
		end
		else begin
			next_state	<= S_IDLE;
		end
	end
	S_COMMAND: begin
		if(cnt >= 3'd7) begin
			next_state	<= S_WRR;
		end
		else begin
			next_state	<= S_COMMAND;
		end
	end
	S_WRR: begin
		if(cnt >= 3'd7 && cnt_Byte >= Register_Len - 1'b1) begin
			next_state	<= S_STOP;
		end
		else begin
			next_state	<= S_WRR;
		end
	end
	S_STOP: begin
		next_state	<= S_IDLE;
	end
	default: begin
		next_state	<= S_IDLE;
	end
	endcase
end

//FLASH_nCS
always @(negedge clk) begin
	case(state)
	S_COMMAND, S_WRR: begin
		FLASH_nCS	<= 1'b0;
	end
	default: begin
		FLASH_nCS	<= 1'b1;
	end
	endcase
end

//cnt
always @(posedge clk) begin
	case(state)
	S_IDLE: begin
		cnt		<= 3'd0;
	end
	S_COMMAND, S_WRR: begin		//将cnt设计为3bit位宽,可实现模8加
		if(~FLASH_nCS) begin
			cnt		<= cnt + 1'b1;
		end
		else begin
			cnt		<= 3'd0;
		end
	end
	S_STOP: begin
		cnt		<= 3'd0;
	end
	default: begin
		cnt		<= cnt;
	end
	endcase
end

//cnt_Byte
always @(posedge clk) begin
	case(state)
	S_WRR: begin
		if(cnt==3'd7) begin
			cnt_Byte	<= cnt_Byte + 1'b1;
		end
		else begin
			cnt_Byte	<= cnt_Byte;
		end
	end
	default: begin
		cnt_Byte	<= 4'd0;
	end
	endcase
end

//FLASH_IO_OBUF
always @(negedge clk) begin		//在SCK下降沿转换数据
	case(state)
	S_COMMAND: begin
		FLASH_IO_OBUF[0]	<= instruction[3'd7-cnt];	//首先移出MSB
		FLASH_IO_OBUF[3:1]	<= 3'b111;
	end
	S_WRR: begin
		case(cnt_Byte)
		4'd0:		FLASH_IO_OBUF[0]	<= Byte1[3'd7-cnt];
		4'd1:		FLASH_IO_OBUF[0]	<= Byte2[3'd7-cnt];
		4'd2:		FLASH_IO_OBUF[0]	<= Byte3[3'd7-cnt];
		4'd3:		FLASH_IO_OBUF[0]	<= Byte4[3'd7-cnt];
		default:	FLASH_IO_OBUF[0]	<= 1'b1;
		endcase
		FLASH_IO_OBUF[3:1]	<= 3'b111;
	end
	default: begin
		FLASH_IO_OBUF	<= 4'hf;
	end
	endcase
end

//link
always @(negedge clk) begin
	case(state)
	S_COMMAND, S_WRR: begin
		link	<= 4'b1101;
	end
	default: begin
		link	<= 4'h0;
	end
	endcase
end

//busy
always @(*) begin
	case(state)
	S_IDLE: begin
		busy	<= 1'b0;
	end
	default: begin
		busy	<= 1'b1;
	end
	endcase
end

endmodule
  • Page Programming
verilog 复制代码
/* 
 * file			: flash_4QPP.v
 * author		: 今朝无言
 * Lab			: WHU-EIS-LMSWE
 * date			: 2023-11-16
 * version		: v2.0
 * description	: 实现 4QPP 指令,32bit Addr,Quad Page Programming
 * Copyright © 2023 WHU-EIS-LMSWE, All Rights Reserved.
 */
`default_nettype none
module flash_4QPP(
input	wire			clk,			//S25FL256SAGNFI00 在 4QPP 下最大支持 80M
input	wire			rst_n,

output	wire			FLASH_SCK,
output	reg				FLASH_nCS,

output	reg		[3:0]	link,
output	reg		[3:0]	FLASH_IO_OBUF,
input	wire	[3:0]	FLASH_IO_IBUF,

//usr interface
input	wire			program_start,	//上升沿有效

input	wire	[31:0]	addr,			//起始地址,可以是任意字节地址,但建议是 Page 起始地址,S25FL256SAGNFI00 的 Page 大小为 256Byte
input	wire	[9:0]	Byte_Len,		//一次写多少字节数据,Page Programming 只能在当前 Page 内进行写入,超出的将被忽略,建议一次写一整个 Page

output	wire			data_rd_clk,	//读数据的驱动时钟,若使用FIFO请用这个时钟,是clk的二分频时钟
output	reg				data_rden,		//读数据请求,可用作 FIFO 的 rden,FIFO 应采用 First Word Fall Through
input	wire	[7:0]	data,			//字节数据

output	reg				busy
);

localparam	instruction		= 8'h34;	//4QPP的指令码为 0x34

reg		FLASH_nCS	= 1'b1;
assign	FLASH_SCK	= FLASH_nCS? 1'b1 : clk;	//SPI mode 3

reg		[3:0]	link			= 4'h0;
reg		[3:0]	FLASH_IO_OBUF	= 4'hf;

wire	program_start_pe;
reg		program_start_d0;
reg		program_start_d1;

always @(posedge clk) begin
	program_start_d0	<= program_start;
	program_start_d1	<= program_start_d0;
end

assign	program_start_pe	= program_start_d0 & (~program_start_d1);

clkdiv #(.N(2))
clkdiv_2(
	.clk_in		(clk),
	.clk_out	(data_rd_clk)
);

//--------------------FSM---------------------------
localparam	S_IDLE		= 8'h01;
localparam	S_COMMAND	= 8'h02;
localparam	S_ADDR		= 8'h04;
localparam	S_QUAD_WR	= 8'h08;
localparam	S_STOP		= 8'h10;

reg		[7:0]	state	= S_IDLE;
reg		[7:0]	next_state;

reg		[2:0]	cnt			= 3'd0;		//Byte内bit计数
reg		[9:0]	cnt_Byte	= 10'd0;

always @(posedge clk or negedge rst_n) begin
	if(~rst_n) begin
		state	<= S_IDLE;
	end
	else begin
		state	<= next_state;
	end
end

always @(*) begin
	case(state)
	S_IDLE: begin
		if(program_start_pe) begin
			next_state	<= S_COMMAND;
		end
		else begin
			next_state	<= S_IDLE;
		end
	end
	S_COMMAND: begin
		if(cnt >= 3'd7) begin
			next_state	<= S_ADDR;
		end
		else begin
			next_state	<= S_COMMAND;
		end
	end
	S_ADDR: begin
		if(cnt >= 3'd7 && cnt_Byte >= 4'd3) begin
			next_state	<= S_QUAD_WR;
		end
		else begin
			next_state	<= S_ADDR;
		end
	end
	S_QUAD_WR: begin
		if(cnt >= 3'd4 && (Byte_Len == 10'd0 || cnt_Byte >= Byte_Len - 1'b1)) begin	//Len=0时视作Len=1
			next_state	<= S_STOP;
		end
		else begin
			next_state	<= S_QUAD_WR;
		end
	end
	S_STOP: begin
		next_state	<= S_IDLE;
	end
	default: begin
		next_state	<= S_IDLE;
	end
	endcase
end

//FLASH_nCS
always @(negedge clk) begin
	case(state)
	S_COMMAND, S_ADDR, S_QUAD_WR: begin
		FLASH_nCS	<= 1'b0;
	end
	default: begin
		FLASH_nCS	<= 1'b1;
	end
	endcase
end

//cnt
always @(posedge clk) begin
	case(state)
	S_IDLE: begin
		cnt		<= 3'd0;
	end
	S_COMMAND, S_ADDR: begin
		if(~FLASH_nCS) begin
			cnt		<= cnt + 1'b1;
		end
		else begin
			cnt		<= 3'd0;
		end
	end
	S_QUAD_WR: begin
		if(~FLASH_nCS) begin
			cnt		<= cnt + 3'd4;	//Quad WR 阶段一次传送4bit
		end
		else begin
			cnt		<= 3'd0;
		end
	end
	S_STOP: begin
		cnt		<= 3'd0;
	end
	default: begin
		cnt		<= cnt;
	end
	endcase
end

//cnt_Byte
always @(posedge clk) begin
	case(state)
	S_ADDR: begin
		if(cnt==3'd7) begin
			if(cnt_Byte >= 16'd3) begin
				cnt_Byte	<= 10'd0;
			end
			else begin
				cnt_Byte	<= cnt_Byte + 1'b1;
			end
		end
		else begin
			cnt_Byte	<= cnt_Byte;
		end
	end
	S_QUAD_WR: begin
		if(cnt==3'd4) begin
			cnt_Byte	<= cnt_Byte + 1'b1;
		end
		else begin
			cnt_Byte	<= cnt_Byte;
		end
	end
	default: begin
		cnt_Byte	<= 10'd0;
	end
	endcase
end

//link
always @(negedge clk) begin
	case(state)
	S_COMMAND, S_ADDR: begin
		link	<= 4'b1101;
	end
	S_QUAD_WR: begin
		link	<= 4'b1111;
	end
	default: begin
		link	<= 4'h0;
	end
	endcase
end

//FLASH_IO_OBUF
always @(negedge clk) begin		//在SCK下降沿转换数据
	case(state)
	S_COMMAND: begin
		FLASH_IO_OBUF[0]	<= instruction[3'd7-cnt];	//首先移出MSB
		FLASH_IO_OBUF[3:1]	<= 3'b111;
	end
	S_ADDR: begin
		case(cnt_Byte[3:0])
		4'd0:		FLASH_IO_OBUF[0]	<= addr[5'd31-cnt];
		4'd1:		FLASH_IO_OBUF[0]	<= addr[5'd23-cnt];
		4'd2:		FLASH_IO_OBUF[0]	<= addr[5'd15-cnt];
		4'd3:		FLASH_IO_OBUF[0]	<= addr[5'd7-cnt];
		default:	FLASH_IO_OBUF[0]	<= 1'b1;
		endcase
		FLASH_IO_OBUF[3:1]	<= 3'b111;
	end
	S_QUAD_WR: begin
		case(cnt)
		4'd0:		FLASH_IO_OBUF[3:0]	<= data[7:4];
		4'd4:		FLASH_IO_OBUF[3:0]	<= data[3:0];
		default:	FLASH_IO_OBUF[3:0]	<= 4'hf;
		endcase
	end
	default: begin
		FLASH_IO_OBUF	<= 4'hf;
	end
	endcase
end

//data_rden
always @(posedge clk) begin
	case(state)
	S_QUAD_WR: begin
		data_rden	<= 1'b1;
	end
	default: begin
		data_rden	<= 1'b0;
	end
	endcase
end

//busy
always @(*) begin
	case(state)
	S_IDLE: begin
		busy	<= 1'b0;
	end
	default: begin
		busy	<= 1'b1;
	end
	endcase
end

endmodule
  • 读 FLASH 主存储器
verilog 复制代码
/* 
 * file			: flash_4QOR.v
 * author		: 今朝无言
 * Lab			: WHU-EIS-LMSWE
 * date			: 2023-11-17
 * version		: v2.0
 * description	: 4QOR读flash,32bit Addr,Quad Output Read
 * Copyright © 2023 WHU-EIS-LMSWE, All Rights Reserved.
 */
`default_nettype none
module flash_4QOR(
input	wire			clk,
input	wire			rst_n,

output	wire			FLASH_SCK,
output	reg				FLASH_nCS,

output	reg		[3:0]	link,
output	reg		[3:0]	FLASH_IO_OBUF,
input	wire	[3:0]	FLASH_IO_IBUF,

//usr interface
input	wire			read_start,		//上升沿有效

input	wire	[31:0]	addr,			//起始地址,可以是任意字节地址
input	wire	[31:0]	Byte_Len,		//一次读多少字节数据,读取过程中flash会自动地址+1,达到最大地址后将从0x00地址继续读取

output	wire			data_wr_clk,	//写数据的驱动时钟,若使用FIFO请用这个时钟,是clk的二分频时钟
output	reg				data_wren,		//wren,可用作 FIFO 的 wren
output	reg		[7:0]	data,			//读到的字节数据

output	reg				busy,

//LC
input	wire	[1:0]	LC				//LC bit(CR1[7:6])
);
//LC确定Dummy的长度,对于HPLC和PLC,在Quad Output Read下表现一致,
//都没有mode字段(mode len=0),除LC=11对应dummy len=0外(最大支持50MHz),其余都是dummy len=8

localparam	instruction		= 8'h6C;	//4QOR的指令码为 0x6C

reg		FLASH_nCS	= 1'b1;
assign	FLASH_SCK	= FLASH_nCS? 1'b1 : clk;	//SPI mode 3

reg		[3:0]	link			= 4'h0;
reg		[3:0]	FLASH_IO_OBUF	= 4'hf;

wire	read_start_pe;
reg		read_start_d0;
reg		read_start_d1;

always @(posedge clk) begin
	read_start_d0	<= read_start;
	read_start_d1	<= read_start_d0;
end

assign	read_start_pe	= read_start_d0 & (~read_start_d1);

clkdiv #(.N(2))
clkdiv_2(
	.clk_in		(clk),
	.clk_out	(data_wr_clk)
);

//--------------------FSM---------------------------
localparam	S_IDLE		= 8'h01;
localparam	S_COMMAND	= 8'h02;
localparam	S_ADDR		= 8'h04;
localparam	S_DUMMY		= 8'h08;
localparam	S_QUAD_RD	= 8'h10;
localparam	S_STOP		= 8'h20;

reg		[7:0]	state	= S_IDLE;
reg		[7:0]	next_state;

reg		[2:0]	cnt			= 3'd0;		//Byte内bit计数
reg		[31:0]	cnt_Byte	= 32'd0;

always @(posedge clk or negedge rst_n) begin
	if(~rst_n) begin
		state	<= S_IDLE;
	end
	else begin
		state	<= next_state;
	end
end

always @(*) begin
	case(state)
	S_IDLE: begin
		if(read_start_pe) begin
			next_state	<= S_COMMAND;
		end
		else begin
			next_state	<= S_IDLE;
		end
	end
	S_COMMAND: begin
		if(cnt >= 3'd7) begin
			next_state	<= S_ADDR;
		end
		else begin
			next_state	<= S_COMMAND;
		end
	end
	S_ADDR: begin
		if(cnt >= 3'd7 && cnt_Byte >= 4'd3) begin
			case(LC)		//根据LC判断Dummy的长度
			2'b11: begin
				next_state	<= S_QUAD_RD;
			end
			2'b00, 2'b01, 2'b10: begin
				next_state	<= S_DUMMY;
			end
			default: ;
			endcase
		end
		else begin
			next_state	<= S_ADDR;
		end
	end
	S_DUMMY: begin
		if(cnt >= 3'd7) begin
			next_state	<= S_QUAD_RD;
		end
		else begin
			next_state	<= S_DUMMY;
		end
	end
	S_QUAD_RD: begin
		if(cnt >= 3'd4 && (Byte_Len == 32'd0 || cnt_Byte >= Byte_Len - 1'b1)) begin	//Len=0时视作Len=1
			next_state	<= S_STOP;
		end
		else begin
			next_state	<= S_QUAD_RD;
		end
	end
	S_STOP: begin
		if(cnt>=1) begin	//维持在STOP两个clk,以保持data和wren保持一个wr_clk
			next_state	<= S_IDLE;
		end
		else begin
			next_state	<= S_STOP;
		end
	end
	default: begin
		next_state	<= S_IDLE;
	end
	endcase
end

//FLASH_nCS
always @(negedge clk) begin
	case(state)
	S_COMMAND, S_ADDR, S_DUMMY, S_QUAD_RD: begin
		FLASH_nCS	<= 1'b0;
	end
	default: begin
		FLASH_nCS	<= 1'b1;
	end
	endcase
end

//cnt
always @(posedge clk) begin
	case(state)
	S_IDLE: begin
		cnt		<= 3'd0;
	end
	S_COMMAND, S_ADDR: begin
		if(~FLASH_nCS) begin
			cnt		<= cnt + 1'b1;
		end
		else begin
			cnt		<= 3'd0;
		end
	end
	S_DUMMY: begin
		if(cnt >= 3'd7) begin	//这里设置Bummy长度;由于4QOR只有0/8的Dummy长度,因该case实际可以和上面合并
			cnt		<= 3'd0;
		end
		else begin
			cnt		<= cnt + 1'b1;
		end
	end
	S_QUAD_RD: begin
		cnt		<= cnt + 3'd4;	//Quad RD 阶段一次读回4bit
	end
	S_STOP: begin
		cnt		<= 3'd1;
	end
	default: begin
		cnt		<= cnt;
	end
	endcase
end

//cnt_Byte
always @(posedge clk) begin
	case(state)
	S_ADDR: begin
		if(cnt==3'd7) begin
			if(cnt_Byte >= 32'd3) begin
				cnt_Byte	<= 32'd0;
			end
			else begin
				cnt_Byte	<= cnt_Byte + 1'b1;
			end
		end
		else begin
			cnt_Byte	<= cnt_Byte;
		end
	end
	S_DUMMY: begin
		cnt_Byte		<= 32'd0;
	end
	S_QUAD_RD: begin
		if(cnt==3'd4) begin
			cnt_Byte	<= cnt_Byte + 1'b1;
		end
		else begin
			cnt_Byte	<= cnt_Byte;
		end
	end
	default: begin
		cnt_Byte		<= 32'd0;
	end
	endcase
end

//link
always @(negedge clk) begin
	case(state)
	S_COMMAND, S_ADDR: begin
		link	<= 4'b1101;
	end
	S_DUMMY, S_QUAD_RD: begin	//为防止主控端与flash端的驱动器冲突,Dummy期间主控端应释放总线
		link	<= 4'b0000;
	end
	default: begin
		link	<= 4'h0;
	end
	endcase
end

//FLASH_IO_OBUF
always @(negedge clk) begin		//在SCK下降沿转换数据
	case(state)
	S_COMMAND: begin
		FLASH_IO_OBUF[0]	<= instruction[3'd7-cnt];	//首先移出MSB
		FLASH_IO_OBUF[3:1]	<= 3'b111;
	end
	S_ADDR: begin
		case(cnt_Byte[3:0])
		4'd0:		FLASH_IO_OBUF[0]	<= addr[5'd31-cnt];
		4'd1:		FLASH_IO_OBUF[0]	<= addr[5'd23-cnt];
		4'd2:		FLASH_IO_OBUF[0]	<= addr[5'd15-cnt];
		4'd3:		FLASH_IO_OBUF[0]	<= addr[5'd7-cnt];
		default:	FLASH_IO_OBUF[0]	<= 1'b1;
		endcase
		FLASH_IO_OBUF[3:1]	<= 3'b111;
	end
	default: begin
		FLASH_IO_OBUF	<= 4'hf;
	end
	endcase
end

//data_tmp
reg		[7:0]	data_tmp;
always @(posedge clk) begin	//须在SCK上升沿锁存数据
	case(state)
	S_QUAD_RD: begin
		case(cnt)
		3'd0: begin
			data_tmp[7:4]	<= FLASH_IO_IBUF;
		end
		3'd4: begin
			data_tmp[3:0]	<= FLASH_IO_IBUF;
		end
		default: begin
			data_tmp	<= data_tmp;
		end
		endcase
	end
	default: begin
		data_tmp	<= data_tmp;
	end
	endcase
end

//data_wren & data
reg				data_wren_buf;
reg		[7:0]	data_buf;
always @(posedge clk) begin
	case(state)
	S_QUAD_RD: begin
		if(cnt==0 && cnt_Byte>=1) begin
			data_wren_buf	<= 1'b1;
			data_buf		<= data_tmp;
		end
		else begin
			data_wren_buf	<= data_wren_buf;
			data_buf		<= data_buf;
		end
	end
	S_STOP: begin		//S_STOP时锁存输出最后一个数据
		if(cnt==0) begin
			data_wren_buf	<= 1'b1;
			data_buf		<= data_tmp;
		end
		else begin
			data_wren_buf	<= data_wren_buf;
			data_buf		<= data_buf;
		end
	end
	default: begin
		data_wren_buf	<= 1'b0;
		data_buf		<= 8'd0;
	end
	endcase
end

always @(posedge data_wr_clk) begin		//同步到data_wr_clk时钟域
	data_wren	<= data_wren_buf;
	data		<= data_buf;
end

//busy
always @(*) begin
	case(state)
	S_IDLE: begin
		busy	<= 1'b0;
	end
	default: begin
		busy	<= 1'b1;
	end
	endcase
end

endmodule

top模块

  • FLASH_top.v
verilog 复制代码
/* 
 * file			: FLASH_top.v
 * author		: 今朝无言
 * Lab			: WHU-EIS-LMSWE
 * date			: 2023-11-18
 * version		: v2.0
 * description	: S25FL256SAGNFI00 的读写控制,实现 SDR 时钟模式下的 Quad 读写模式
 * Copyright © 2023 WHU-EIS-LMSWE, All Rights Reserved.
 */
`default_nettype none
module FLASH_top(
input	wire			clk,
input	wire			rst_n,

output	reg				FLASH_SCK,
output	reg				FLASH_nCS,
inout	wire	[3:0]	FLASH_IO,

//----------------user interface---------------------
//wr FLASH
input	wire			WR_req,				//Page Programming

input	wire	[31:0]	WR_addr,			//起始编程地址,对于S25FL256S,可用地址为0~1FFFFFF(25bit)
input	wire	[9:0]	WR_Byte_Len,		//编程字节数,单次只能在一个Page里进行写入(256Byte Programming Buffer Size)
// 最好一次写一个完整的Page(低8位地址为0,Len=256)

output	wire			data_rd_clk,		//读wFIFO的时钟
output	wire			data_rden,			//读wFIFO的使能信号
input	wire	[7:0]	data_PP,			//从wFIFO读到的数据,将写入FLASH

//rd FLASH
input	wire			RD_req,
input	wire	[1:0]	LC,					//LC bits, CR1[7:6]

input	wire	[31:0]	RD_addr,			//起始读取地址
input	wire	[31:0]	RD_Byte_Len,		//读取字节数

output	wire			data_wr_clk,		//写rFIFO的clk
output	wire			data_wren,			//写rFIFO的使能信号
output	wire	[7:0]	data_4QOR,			//从FLASH读到的数据

//WREN/WRDI/CLSR/RESET
input	wire			WREN_req,			//置位WEL bit
input	wire			WRDI_req,			//复位WEL bit
input	wire			CLSR_req,			//清空SR1,只复位P_ERR、E_ERR这两个bit
input	wire			RESET_req,			//软复位

//erase
input	wire			bulk_erase_req,		//批量擦除

input	wire			sector_erase_req,	//Sector擦除,一次擦除一个标准Sector(64KB)
input	wire	[31:0]	sector_erase_addr,	//低16位直接置零即可

//RD SR1/CR1/SR2/BAR/ABR
input	wire			rd_SR1_req,			//Status Register 1
output	reg		[7:0]	SR1_rd,

input	wire			rd_CR1_req,			//Configuration Register
output	reg		[7:0]	CR1_rd,

input	wire			rd_SR2_req,			//Status Register 2
output	reg		[7:0]	SR2_rd,

input	wire			rd_BAR_req,			//Bank Address Register
output	reg		[7:0]	BAR_rd,

input	wire			rd_ABR_req,			//Autoboot Register
output	reg		[31:0]	ABR_rd,

//WR SR1/CR1/BAR/ABR
input	wire			wr_SR1_req,			//发起WR_SR1只需要给入SR1
input	wire			wr_CR1_req,			//发起WR_CR1请求时,要同时给入SR1、CR1两个值
input	wire	[7:0]	SR1_wr,
input	wire	[7:0]	CR1_wr,

input	wire			wr_BAR_req,
input	wire	[7:0]	BAR_wr,

input	wire			wr_ABR_req,
input	wire	[31:0]	ABR_wr,

output	reg				busy,

//debug
output	reg		[3:0]	link,
output	reg		[3:0]	FLASH_IO_OBUF,
output	wire	[3:0]	FLASH_IO_IBUF,
output	reg		[23:0]	state
);
//注意,为避免操作冲突,所有req信号请最多同时启用一个(本模块已经做了优先编码)
//所有req高电平有效,请发起req后检测busy,若busy=H,则置低req,避免重复读写
//所有req均应在busy=L时才可发起

//---------------------------------COMMAND----------------------------------------
localparam	I_WREN	= 8'h06;		//置位WEL
localparam	I_WRDI	= 8'h04;		//复位WEL
localparam	I_CLSR	= 8'h30;		//复位P_ERR、E_ERR
localparam	I_RESET	= 8'hF0;		//软复位

localparam	I_WRR	= 8'h01;		//写SR1、CR1
localparam	I_RDSR1	= 8'h05;		//读SR1
localparam	I_RDSR2	= 8'h07;		//读SR2
localparam	I_RDCR1	= 8'h35;		//读CR1

localparam	I_RDABR	= 8'h14;		//读Autoboot Register
localparam	I_WRABR	= 8'h15;		//写ABR

localparam	I_RDBAR	= 8'h16;		//读Bank Address Register
localparam	I_WRBAR	= 8'h17;		//写BAR

localparam	I_BE	= 8'h60;		//bulk erase
localparam	I_SE	= 8'hDC;		//4SE,Erase 64KB Sector (4-byte address)

localparam	I_4QPP	= 8'h34;		//Quad Page Programming (4-byte address)
localparam	I_4QOR	= 8'h6C;		//Quad Output Read (4-byte address)
//4QPP、4QOR的指令码在子模块里写好了,这里只是罗列一下,除此之外的指令码都在本模块内用到

//----------------------------------SPI x4----------------------------------------
reg		[3:0]	link			= 4'h0;
reg		[3:0]	FLASH_IO_OBUF	= 4'hf;
wire	[3:0]	FLASH_IO_IBUF;

genvar i;
generate
	for(i=0; i<4; i=i+1) begin
		IOBUF IOBUF_FLASH_IO(				//IOBUF由一个IBUF和一个OBUF组成,
			.O		(FLASH_IO_IBUF[i]),		//O为IBUF的输出
			.IO		(FLASH_IO[i]),			//IO为OBUF的输出、IBUF的输入
			.I		(FLASH_IO_OBUF[i]),		//I为OBUF的输入
			.T		(~link[i])				//T为OBUF的三态门使能,低电平有效
		);
	end
endgenerate

assign	FLASH_IO_IBUF1	= FLASH_IO_IBUF;
assign	FLASH_IO_IBUF2	= FLASH_IO_IBUF;
assign	FLASH_IO_IBUF3	= FLASH_IO_IBUF;
assign	FLASH_IO_IBUF4	= FLASH_IO_IBUF;
assign	FLASH_IO_IBUF5	= FLASH_IO_IBUF;

//********重要**********
//注意,每个FPGA管脚上都要有IBUF、OBUF或IOBUF,input/output管脚上IBUF/OBUF会自动生成,
//而inout管脚需要用户编写,要么用IOBUF,要么直接用 link? xx_OBUF : 1'bz 这种形式(其实后者也是生成了一个OBUF和一个IBUF)
//对于每个FPGA管脚,只能由一个OBUF驱动,因此如果多个子模块要用inout操作同一根线,会出问题
//(这种情况下vivado会自动生成IBUF,导致模块大部分逻辑无效化,进而在综合后整个模块被优化掉,
//  即使强制关闭IBUF/OBUF自动插入功能,也会因为多个OBUF驱动同一管脚而综合失败)
//因此子模块不能再保有inout,而是通过操作顶层模块的IOBUF实现数据读写
//**********************

//--------------------------------几个子模块--------------------------------------
//---------------单条8bit指令发送模块---------------
wire			FLASH_SCK_1;
wire			FLASH_nCS_1;

wire	[3:0]	link1;
wire	[3:0]	FLASH_IO_OBUF1;
wire	[3:0]	FLASH_IO_IBUF1;

reg				start_1;
reg		[7:0]	instruction_1;
wire			busy_1;

flash_instruction flash_instruction_inst(
	.clk			(clk),
	.rst_n			(rst_n),

	.FLASH_SCK		(FLASH_SCK_1),
	.FLASH_nCS		(FLASH_nCS_1),
	
	.link			(link1),
	.FLASH_IO_OBUF	(FLASH_IO_OBUF1),
	.FLASH_IO_IBUF	(FLASH_IO_IBUF1),

	//usr interface
	.send_en		(start_1),
	.instruction	(instruction_1),
	.busy			(busy_1)
);

//-------------写寄存器指令,支持1~4Byte-------------
wire			FLASH_SCK_2;
wire			FLASH_nCS_2;

wire	[3:0]	link2;
wire	[3:0]	FLASH_IO_OBUF2;
wire	[3:0]	FLASH_IO_IBUF2;

reg				start_2;
reg		[7:0]	instruction_2;
wire			busy_2;

reg		[3:0]	Register_Len_WRR;
reg		[7:0]	WRR_Byte1, WRR_Byte2, WRR_Byte3, WRR_Byte4;

flash_WRR flash_WRR_inst(
	.clk			(clk),
	.rst_n			(rst_n),

	.FLASH_SCK		(FLASH_SCK_2),
	.FLASH_nCS		(FLASH_nCS_2),

	.link			(link2),
	.FLASH_IO_OBUF	(FLASH_IO_OBUF2),
	.FLASH_IO_IBUF	(FLASH_IO_IBUF2),

	//usr interface
	.send_en		(start_2),
	.instruction	(instruction_2),

	.Register_Len	(Register_Len_WRR),
	.Byte1			(WRR_Byte1),
	.Byte2			(WRR_Byte2),
	.Byte3			(WRR_Byte3),
	.Byte4			(WRR_Byte4),

	.busy			(busy_2)
);

//------------------读寄存器------------------
wire			FLASH_SCK_3;
wire			FLASH_nCS_3;

wire	[3:0]	link3;
wire	[3:0]	FLASH_IO_OBUF3;
wire	[3:0]	FLASH_IO_IBUF3;

reg				start_3;
reg		[7:0]	instruction_3;
wire			busy_3;

reg		[3:0]	Register_Len_RDR;
wire	[31:0]	RDR_Reg;

flash_RDR flash_RDR_inst(
	.clk			(clk),
	.rst_n			(rst_n),

	.FLASH_SCK		(FLASH_SCK_3),
	.FLASH_nCS		(FLASH_nCS_3),

	.link			(link3),
	.FLASH_IO_OBUF	(FLASH_IO_OBUF3),
	.FLASH_IO_IBUF	(FLASH_IO_IBUF3),

	//usr interface
	.read_en		(start_3),
	.instruction	(instruction_3),

	.Register_Len	(Register_Len_RDR),
	.Reg			(RDR_Reg),

	.busy			(busy_3)
);

//---------------Page Programming---------------
wire			FLASH_SCK_4;
wire			FLASH_nCS_4;

wire	[3:0]	link4;
wire	[3:0]	FLASH_IO_OBUF4;
wire	[3:0]	FLASH_IO_IBUF4;

reg				start_4;
wire			busy_4;

reg		[31:0]	addr_PP;
reg		[9:0]	Byte_Len_PP;

wire			data_rd_clk;
wire			data_rden;
wire	[7:0]	data_PP;

flash_4QPP flash_4QPP_inst(
	.clk			(clk),
	.rst_n			(rst_n),

	.FLASH_SCK		(FLASH_SCK_4),
	.FLASH_nCS		(FLASH_nCS_4),

	.link			(link4),
	.FLASH_IO_OBUF	(FLASH_IO_OBUF4),
	.FLASH_IO_IBUF	(FLASH_IO_IBUF4),

	//usr interface
	.program_start	(start_4),

	.addr			(addr_PP),
	.Byte_Len		(Byte_Len_PP),

	.data_rd_clk	(data_rd_clk),	//读wFIFO,将数据写入FLASH
	.data_rden		(data_rden),
	.data			(data_PP),		//从wFIFO读到的数据

	.busy			(busy_4)
);

//-------------------read flash-------------------
wire			FLASH_SCK_5;
wire			FLASH_nCS_5;

wire	[3:0]	link5;
wire	[3:0]	FLASH_IO_OBUF5;
wire	[3:0]	FLASH_IO_IBUF5;

reg				start_5;
wire			busy_5;

reg		[31:0]	addr_4QOR;
reg		[31:0]	Byte_Len_4QOR;

wire			data_wr_clk;
wire			data_wren;
wire	[7:0]	data_4QOR;

wire	[1:0]	LC;

flash_4QOR flash_4QOR_inst(
	.clk			(clk),
	.rst_n			(rst_n),

	.FLASH_SCK		(FLASH_SCK_5),
	.FLASH_nCS		(FLASH_nCS_5),

	.link			(link5),
	.FLASH_IO_OBUF	(FLASH_IO_OBUF5),
	.FLASH_IO_IBUF	(FLASH_IO_IBUF5),

	//usr interface
	.read_start		(start_5),

	.addr			(addr_4QOR),
	.Byte_Len		(Byte_Len_4QOR),

	.data_wr_clk	(data_wr_clk),	//读FLASH并将数据写入rFIFO
	.data_wren		(data_wren),
	.data			(data_4QOR),	//写到rFIFO的数据

	.busy			(busy_5),

	//LC
	.LC				(LC)			//LC bit(CR1[7:6])
);

//--------------------------------通道仲裁--------------------------------------
localparam	M_NONE			= 8'h01;
localparam	M_instruction	= 8'h02;
localparam	M_WRR			= 8'h04;
localparam	M_RDR			= 8'h08;
localparam	M_PP			= 8'h10;
localparam	M_4QOR			= 8'h20;

reg		[7:0]	module_arb	= M_NONE;
reg				submodule_busy;

always @(*) begin
	case(module_arb)
	M_NONE: begin
		submodule_busy	<= 1'b0;
		FLASH_SCK		<= 1'b1;
		FLASH_nCS		<= 1'b1;
		link			<= 4'h0;
		FLASH_IO_OBUF	<= 4'hf;
	end
	M_instruction: begin
		submodule_busy	<= busy_1;
		FLASH_SCK		<= FLASH_SCK_1;
		FLASH_nCS		<= FLASH_nCS_1;
		link			<= link1;
		FLASH_IO_OBUF	<= FLASH_IO_OBUF1;
	end
	M_WRR: begin
		submodule_busy	<= busy_2;
		FLASH_SCK		<= FLASH_SCK_2;
		FLASH_nCS		<= FLASH_nCS_2;
		link			<= link2;
		FLASH_IO_OBUF	<= FLASH_IO_OBUF2;
	end
	M_RDR: begin
		submodule_busy	<= busy_3;
		FLASH_SCK		<= FLASH_SCK_3;
		FLASH_nCS		<= FLASH_nCS_3;
		link			<= link3;
		FLASH_IO_OBUF	<= FLASH_IO_OBUF3;
	end
	M_PP: begin
		submodule_busy	<= busy_4;
		FLASH_SCK		<= FLASH_SCK_4;
		FLASH_nCS		<= FLASH_nCS_4;
		link			<= link4;
		FLASH_IO_OBUF	<= FLASH_IO_OBUF4;
	end
	M_4QOR: begin
		submodule_busy	<= busy_5;
		FLASH_SCK		<= FLASH_SCK_5;
		FLASH_nCS		<= FLASH_nCS_5;
		link			<= link5;
		FLASH_IO_OBUF	<= FLASH_IO_OBUF5;
	end
	default: begin
		submodule_busy	<= 1'b0;
		FLASH_SCK		<= 1'b1;
		FLASH_nCS		<= 1'b1;
		link			<= 4'h0;
		FLASH_IO_OBUF	<= 4'hf;
	end
	endcase
end

//----------------------------------FSM----------------------------------------
localparam	S_IDLE		= 24'h000001;
localparam	S_ARB		= 24'h000002;		//仲裁对哪一个req进行响应
localparam	S_WAIT		= 24'h000004;		//等待子模块工作完成
localparam	S_STOP		= 24'h000008;

localparam	S_WREN		= 24'h000010;		//执行WREN指令,置位WEL bit
localparam	S_WRDI		= 24'h000020;		//执行WRDI指令,复位WEL bit
localparam	S_CLSR		= 24'h000040;		//执行CLSR,复位P_ERR、E_ERR bit
localparam	S_BE		= 24'h000080;		//Bulk Erase

localparam	S_WRSR1		= 24'h000100;		//写Status Register 1
localparam	S_WRCR1		= 24'h000200;		//写Configurate Register 1
localparam	S_WRBAR		= 24'h000400;		//写Bank Address Register
localparam	S_WRABR		= 24'h000800;		//写Autoboot Register
localparam	S_SE		= 24'h001000;		//Sector Erase

localparam	S_RDSR1		= 24'h002000;		//读SR1
localparam	S_RDSR2		= 24'h004000;		//读SR2
localparam	S_RDCR1		= 24'h008000;		//读CR1
localparam	S_RDBAR		= 24'h010000;		//读Bank Address Register
localparam	S_RDABR		= 24'h020000;		//读Autoboot Register

localparam	S_4QPP		= 24'h040000;		//Page Programming
localparam	S_4QOR		= 24'h080000;		//Quad Output Read

localparam	S_RESET		= 24'h100000;		//flash software reset

reg		[23:0]	state	= S_IDLE;
reg		[23:0]	next_state;

always @(posedge clk or negedge rst_n) begin
	if(~rst_n) begin
		state	<= S_IDLE;
	end
	else begin
		state	<= next_state;
	end
end

wire	[16:0]	all_req;
reg		[16:0]	all_req_buf;
assign	all_req	= {RESET_req, WREN_req, WRDI_req, CLSR_req, bulk_erase_req, sector_erase_req,
				   rd_SR1_req, rd_CR1_req, rd_SR2_req, rd_BAR_req, rd_ABR_req,
				   wr_SR1_req, wr_CR1_req, wr_BAR_req, wr_ABR_req,
				   WR_req, RD_req};

always @(posedge clk) begin
	all_req_buf		<= all_req;
end

always @(*) begin
	case(state)
	S_IDLE: begin
		next_state	<= S_ARB;
	end
	S_ARB: begin
		casex(all_req_buf)
		17'b1_xxxx_xxxx_xxxx_xxxx: next_state	<= S_RESET;
		17'b0_1xxx_xxxx_xxxx_xxxx: next_state	<= S_WREN;
		17'b0_01xx_xxxx_xxxx_xxxx: next_state	<= S_WRDI;
		17'b0_001x_xxxx_xxxx_xxxx: next_state	<= S_CLSR;
		17'b0_0001_xxxx_xxxx_xxxx: next_state	<= S_BE;
		17'b0_0000_1xxx_xxxx_xxxx: next_state	<= S_SE;

		17'b0_0000_01xx_xxxx_xxxx: next_state	<= S_RDSR1;
		17'b0_0000_001x_xxxx_xxxx: next_state	<= S_RDCR1;
		17'b0_0000_0001_xxxx_xxxx: next_state	<= S_RDSR2;
		17'b0_0000_0000_1xxx_xxxx: next_state	<= S_RDBAR;
		17'b0_0000_0000_01xx_xxxx: next_state	<= S_RDABR;

		17'b0_0000_0000_001x_xxxx: next_state	<= S_WRSR1;
		17'b0_0000_0000_0001_xxxx: next_state	<= S_WRCR1;
		17'b0_0000_0000_0000_1xxx: next_state	<= S_WRBAR;
		17'b0_0000_0000_0000_01xx: next_state	<= S_WRABR;

		17'b0_0000_0000_0000_001x: next_state	<= S_4QPP;
		17'b0_0000_0000_0000_0001: next_state	<= S_4QOR;

		default: next_state	<= S_ARB;
		endcase
	end
	S_RESET, S_WREN, S_WRDI, S_CLSR, S_BE, S_SE,
	S_RDSR1, S_RDCR1, S_RDSR2, S_RDBAR, S_RDABR,
	S_WRSR1, S_WRCR1, S_WRBAR, S_WRABR,
	S_4QPP, S_4QOR: begin
		if(submodule_busy) begin
			next_state	<= S_WAIT;
		end
		else begin
			next_state	<= state;
		end
	end
	S_WAIT: begin
		if(~submodule_busy) begin
			next_state	<= S_STOP;
		end
		else begin
			next_state	<= S_WAIT;
		end
	end
	S_STOP: begin
		next_state	<= S_IDLE;
	end
	default: begin
		next_state	<= S_IDLE;
	end
	endcase
end

reg		[3:0]	update_register	= 4'd0;		//在RD REG操作中判断要更新哪一个Reg
//1:SR1, 2:CR1, 3:SR2, 4:BAR, 5:ABR

always @(posedge clk) begin
	case(state)
	S_IDLE: begin
		module_arb			<= M_NONE;
		start_1				<= 1'b0;
		start_2				<= 1'b0;
		start_3				<= 1'b0;
		start_4				<= 1'b0;
		start_5				<= 1'b0;
		update_register		<= 4'd0;
	end
	S_ARB: begin
		module_arb			<= M_NONE;
		start_1				<= 1'b0;
		start_2				<= 1'b0;
		start_3				<= 1'b0;
		start_4				<= 1'b0;
		start_5				<= 1'b0;
	end
	S_RESET: begin
		module_arb			<= M_instruction;
		start_1				<= 1'b1;
		instruction_1		<= I_RESET;
	end
	S_WREN: begin
		module_arb			<= M_instruction;
		start_1				<= 1'b1;
		instruction_1		<= I_WREN;
	end
	S_WRDI: begin
		module_arb			<= M_instruction;
		start_1				<= 1'b1;
		instruction_1		<= I_WRDI;
	end
	S_CLSR: begin
		module_arb			<= M_instruction;
		start_1				<= 1'b1;
		instruction_1		<= I_CLSR;
	end
	S_BE: begin
		module_arb			<= M_instruction;
		start_1				<= 1'b1;
		instruction_1		<= I_BE;
	end
	S_SE: begin
		module_arb			<= M_WRR;
		start_2				<= 1'b1;
		instruction_2		<= I_SE;

		Register_Len_WRR	<= 4'd4;
		WRR_Byte1			<= sector_erase_addr[31:24];
		WRR_Byte2			<= sector_erase_addr[23:16];
		WRR_Byte3			<= sector_erase_addr[15:8];
		WRR_Byte4			<= sector_erase_addr[7:0];
	end
	S_RDSR1: begin
		module_arb			<= M_RDR;
		start_3				<= 1'b1;
		instruction_3		<= I_RDSR1;

		Register_Len_RDR	<= 4'd1;
		update_register		<= 4'd1;
	end
	S_RDCR1: begin
		module_arb			<= M_RDR;
		start_3				<= 1'b1;
		instruction_3		<= I_RDCR1;

		Register_Len_RDR	<= 4'd1;
		update_register		<= 4'd2;
	end
	S_RDSR2: begin
		module_arb			<= M_RDR;
		start_3				<= 1'b1;
		instruction_3		<= I_RDSR2;

		Register_Len_RDR	<= 4'd1;
		update_register		<= 4'd3;
	end
	S_RDBAR: begin
		module_arb			<= M_RDR;
		start_3				<= 1'b1;
		instruction_3		<= I_RDBAR;

		Register_Len_RDR	<= 4'd1;
		update_register		<= 4'd4;
	end
	S_RDABR: begin
		module_arb			<= M_RDR;
		start_3				<= 1'b1;
		instruction_3		<= I_RDABR;

		Register_Len_RDR	<= 4'd4;
		update_register		<= 4'd5;
	end
	S_WRSR1: begin
		module_arb			<= M_WRR;
		start_2				<= 1'b1;
		instruction_2		<= I_WRR;

		Register_Len_WRR	<= 4'd1;
		WRR_Byte1			<= SR1_wr;
		WRR_Byte2			<= 8'd0;
		WRR_Byte3			<= 8'd0;
		WRR_Byte4			<= 8'd0;
	end
	S_WRCR1: begin
		module_arb			<= M_WRR;
		start_2				<= 1'b1;
		instruction_2		<= I_WRR;

		Register_Len_WRR	<= 4'd2;
		WRR_Byte1			<= SR1_wr;
		WRR_Byte2			<= CR1_wr;
		WRR_Byte3			<= 8'd0;
		WRR_Byte4			<= 8'd0;
	end
	S_WRBAR: begin
		module_arb			<= M_WRR;
		start_2				<= 1'b1;
		instruction_2		<= I_WRBAR;

		Register_Len_WRR	<= 4'd1;
		WRR_Byte1			<= BAR_wr;
		WRR_Byte2			<= 8'd0;
		WRR_Byte3			<= 8'd0;
		WRR_Byte4			<= 8'd0;
	end
	S_WRABR: begin
		module_arb			<= M_WRR;
		start_2				<= 1'b1;
		instruction_2		<= I_WRABR;

		Register_Len_WRR	<= 4'd4;
		WRR_Byte1			<= ABR_wr[31:24];
		WRR_Byte2			<= ABR_wr[23:16];
		WRR_Byte3			<= ABR_wr[15:8];
		WRR_Byte4			<= ABR_wr[7:0];
	end
	S_4QPP: begin
		module_arb		<= M_PP;
		start_4			<= 1'b1;

		addr_PP			<= WR_addr;
		Byte_Len_PP		<= WR_Byte_Len;
	end
	S_4QOR: begin
		module_arb		<= M_4QOR;
		start_5			<= 1'b1;

		addr_4QOR		<= RD_addr;
		Byte_Len_4QOR	<= RD_Byte_Len;
	end
	S_WAIT: begin
		start_1			<= 1'b0;
		start_2			<= 1'b0;
		start_3			<= 1'b0;
		start_4			<= 1'b0;
		start_5			<= 1'b0;
	end
	S_STOP: begin
		module_arb		<= M_NONE;

		case(update_register)
		4'd1: SR1_rd	<= RDR_Reg[7:0];
		4'd2: CR1_rd	<= RDR_Reg[7:0];
		4'd3: SR2_rd	<= RDR_Reg[7:0];
		4'd4: BAR_rd	<= RDR_Reg[7:0];
		4'd5: ABR_rd	<= RDR_Reg;
		default: ;
		endcase
	end
	default: begin
		module_arb		<= M_NONE;
		start_1			<= 1'b0;
		start_2			<= 1'b0;
		start_3			<= 1'b0;
		start_4			<= 1'b0;
		start_5			<= 1'b0;
	end
	endcase
end

always @(*) begin
	case(state)
	S_IDLE, S_ARB: begin
		busy	<= 1'b0;
	end
	default: begin
		busy	<= 1'b1;
	end
	endcase
end

endmodule

测试

编写测试代码如下,并下载到板子进行测试(注意,我的板子上的 FLASH 的 QUAD bit(CR1[1])已经被置位了,所以这里只执行了擦除、写入、读取流程,如果你的不是,需要多加一个 WRR 步骤)

verilog 复制代码
// FLASH 测试(主存读写测试)
`default_nettype none
module test_flash_mainMemory(
input	wire			clk_sys,	//OXCO_10M

output	wire			FLASH_nCS,
inout	wire	[3:0]	FLASH_IO,

input	wire	[3:0]	Key,
output	wire	[3:0]	LED
);

wire 	clk_100M;
wire 	clk_flash;
wire	clk_1k;
wire	clk_1Hz;

reg		rst_n	= 1'b1;

clk_wiz_0 clk_wiz(
	.clk_in1   (clk_sys),
    .clk_out1  (clk_100M),    
    .reset     (1'b0), 
    .locked    ()
);

clkdiv #(.N(3))
clkdiv_flash(
	.clk_in		(clk_100M),
    .clk_out	(clk_flash)		//测试发现50M下寄存器写操作可能出现错误,因此降为33M
);

clkdiv #(.N(1000_00))
clkdiv_1k(
	.clk_in		(clk_100M),
	.clk_out	(clk_1k)
);

clkdiv #(.N(100_000_000))
clkdiv_1Hz(
	.clk_in		(clk_100M),
	.clk_out	(clk_1Hz)
);

wire	usrdone;
set_CCLK set_CCLK_inst(
	.usrcclk	(FLASH_SCK),
	.usrdone	(usrdone),

	.cfgclk		(),
	.cfgmclk	(),
	.eos		()
);

assign	usrdone	= clk_1Hz;

//-------------------------------------FLASH------------------------------------------------------
wire			FLASH_SCK;
wire			FLASH_nCS;
wire	[3:0]	FLASH_IO;

//wr FLASH
reg				WR_req	= 1'b0;				//Page Programming

reg		[31:0]	WR_addr	= 32'd0;			//起始编程地址,对于S25FL256S,可用地址为0~1FFFFFF(25bit)
reg		[9:0]	WR_Byte_Len	= 10'd1;		//编程字节数

wire			data_rd_clk;				//读wFIFO的时钟
wire			data_rden;					//读wFIFO的使能信号
reg		[7:0]	data_PP		= 8'd0;			//从wFIFO读到的数据,将写入FLASH

//rd FLASH
reg				RD_req	= 1'b0;
reg		[1:0]	LC		= 2'b00;			//LC bits, CR1[7:6]

reg		[31:0]	RD_addr	= 32'd0;			//起始读取地址
reg		[31:0]	RD_Byte_Len	= 32'd1;		//读取字节数

wire			data_wr_clk;				//写rFIFO的clk
wire			data_wren;					//写rFIFO的使能信号
wire	[7:0]	data_4QOR;					//从FLASH读到的数据

//WREN/WRDI/CLSR/RESET
reg				WREN_req	= 1'b0;			//置位WEL bit
reg				WRDI_req	= 1'b0;			//复位WEL bit
reg				CLSR_req	= 1'b0;			//清空SR1,只复位P_ERR、E_ERR这两个bit
reg				RESET_req	= 1'b0;			//软复位

//erase
reg				bulk_erase_req	= 1'b0;		//批量擦除

reg				sector_erase_req	= 1'b0;		//Sector擦除,一次擦除一个标准Sector(64KB)
reg		[31:0]	sector_erase_addr	= 32'd0;	//低16位直接置零即可

//RD SR1/CR1/SR2/BAR/ABR
reg				rd_SR1_req	= 1'b0;			//Status Register 1
wire	[7:0]	SR1_rd;

reg				rd_CR1_req	= 1'b0;			//Configuration Register
wire	[7:0]	CR1_rd;

reg				rd_SR2_req	= 1'b0;			//Status Register 2
wire	[7:0]	SR2_rd;

reg				rd_BAR_req	= 1'b0;			//Bank Address Register
wire	[7:0]	BAR_rd;

reg				rd_ABR_req	= 1'b0;			//Autoboot Register
wire	[31:0]	ABR_rd;

//WR SR1/CR1/BAR/ABR
reg				wr_SR1_req	= 1'b0;			//发起WR_SR1只需要给入SR1
reg				wr_CR1_req	= 1'b0;			//发起WR_CR1请求时,要同时给入SR1、CR1两个值
reg		[7:0]	SR1_wr		= 8'd0;
reg		[7:0]	CR1_wr;

reg				wr_BAR_req	= 1'b0;
reg		[7:0]	BAR_wr;

reg				wr_ABR_req	= 1'b0;
reg		[31:0]	ABR_wr;

wire			busy;

FLASH_top FLASH_top_inst(
	.clk				(clk_flash),
	.rst_n				(rst_n),

	.FLASH_SCK			(FLASH_SCK),
	.FLASH_nCS			(FLASH_nCS),
	.FLASH_IO			(FLASH_IO),

	//----------------user interface---------------------
	//wr FLASH
	.WR_req				(WR_req),

	.WR_addr			(WR_addr),
	.WR_Byte_Len		(WR_Byte_Len),

	.data_rd_clk		(data_rd_clk),
	.data_rden			(data_rden),
	.data_PP			(data_PP),

	//rd FLASH
	.RD_req				(RD_req),
	.LC					(LC),

	.RD_addr			(RD_addr),
	.RD_Byte_Len		(RD_Byte_Len),

	.data_wr_clk		(data_wr_clk),
	.data_wren			(data_wren),
	.data_4QOR			(data_4QOR),

	//WREN/WRDI/CLSR/RESET
	.WREN_req			(WREN_req),
	.WRDI_req			(WRDI_req),
	.CLSR_req			(CLSR_req),
	.RESET_req			(RESET_req),

	//erase
	.bulk_erase_req		(bulk_erase_req),

	.sector_erase_req	(sector_erase_req),
	.sector_erase_addr	(sector_erase_addr),

	//RD SR1/CR1/SR2/BAR/ABR
	.rd_SR1_req			(rd_SR1_req),
	.SR1_rd				(SR1_rd),

	.rd_CR1_req			(rd_CR1_req),
	.CR1_rd				(CR1_rd),

	.rd_SR2_req			(rd_SR2_req),
	.SR2_rd				(SR2_rd),

	.rd_BAR_req			(rd_BAR_req),
	.BAR_rd				(BAR_rd),

	.rd_ABR_req			(rd_ABR_req),
	.ABR_rd				(ABR_rd),

	//WR SR1/CR1/BAR/ABR
	.wr_SR1_req			(wr_SR1_req),
	.wr_CR1_req			(wr_CR1_req),
	.SR1_wr				(SR1_wr),
	.CR1_wr				(CR1_wr),

	.wr_BAR_req			(wr_BAR_req),
	.BAR_wr				(BAR_wr),

	.wr_ABR_req			(wr_ABR_req),
	.ABR_wr				(ABR_wr),

	.busy				(busy),

	//debug
	.link				(link),
	.FLASH_IO_OBUF		(FLASH_IO_OBUF),
	.FLASH_IO_IBUF		(FLASH_IO_IBUF),
	.state				(state)
);

//debug
wire	[3:0]	link;
wire	[3:0]	FLASH_IO_OBUF;
wire	[3:0]	FLASH_IO_IBUF;
wire	[23:0]	state;

//-----------------------------test------------------------------------
wire	PPS_pe;
reg		PPS_d0;
reg		PPS_d1;

reg		PPS_pe_d1;
reg		PPS_pe_d2;

assign	PPS_pe	= PPS_d0 & (~PPS_d1);

reg		[7:0]	cnt	= 8'd0;

always @(posedge clk_flash) begin
	PPS_d0		<= clk_1k;
	PPS_d1		<= PPS_d0;

	if(PPS_pe) begin
		if(cnt==1 || cnt==11) begin
			if(SR1_rd[1]) begin		//检查WEL
				cnt		<= cnt + 1'b1;
			end
			else begin
				cnt		<= cnt;
			end
		end
		else if(cnt==3 || cnt==13) begin
			if(~SR1_rd[0]) begin	//检查WIP
				cnt		<= cnt + 1'b1;
			end
			else begin
				cnt		<= cnt;
			end
		end
		else begin
			cnt		<= cnt + 1'b1;
		end
	end

	PPS_pe_d1	<= PPS_pe;
	PPS_pe_d2	<= PPS_pe_d1;
end

localparam	WR_RD_ADDR	= 32'h0100_0000;

reg		[7:0]	data_PP_tmp	= 8'd0;
always @(posedge data_rd_clk) begin
	if(data_rden) begin
		data_PP_tmp		<= data_PP_tmp + 1'b1;
	end
	else begin
		data_PP_tmp		<= data_PP_tmp;
	end
end

always @(posedge clk_100M) begin
	case(cnt)
	//---------------erase-------------------------
	8'd0: WREN_req		<= PPS_pe_d2;
	8'd1: rd_SR1_req	<= PPS_pe_d2;

	8'd2: begin
		sector_erase_req	<= PPS_pe_d2;
		sector_erase_addr	<= WR_RD_ADDR;
	end

	8'd3: rd_SR1_req	<= PPS_pe_d2;
	8'd4: rd_CR1_req	<= PPS_pe_d2;

	//------------wr main mem----------------------
	8'd10: WREN_req		<= PPS_pe_d2;
	8'd11: rd_SR1_req	<= PPS_pe_d2;

	8'd12: begin
		WR_req			<= PPS_pe_d2;
		WR_addr			<= WR_RD_ADDR;
		WR_Byte_Len		<= 10'd16;
		data_PP			<= data_PP_tmp;
	end

	8'd13: rd_SR1_req	<= PPS_pe_d2;

	//--------------get LC--------------------------
	8'd20: rd_CR1_req	<= PPS_pe_d2;
	8'd21: LC			<= CR1_rd[7:6];

	//------------rd main mem----------------------
	8'd30: begin
		RD_req			<= PPS_pe_d2;
		RD_addr			<= WR_RD_ADDR;
		RD_Byte_Len		<= 10'd16;
	end

	default: ;
	endcase
end

//-----------------------------ILA------------------------------------
ila_test ila(
	.clk		(clk_100M),

	.probe0		(cnt),
	.probe1		(busy),

	.probe2		(FLASH_SCK),
	.probe3		(FLASH_nCS),

	.probe4		(link),
	.probe5		(FLASH_IO_IBUF),

	.probe6		(SR1_rd),
	.probe7		(CR1_rd),

	.probe8		(data_rd_clk),
	.probe9		(data_rden),
	.probe10	(data_PP),

	.probe11	(data_wr_clk),
	.probe12	(data_wren),
	.probe13	(data_4QOR)
);

endmodule

用户控制 CCLK 主要用到 STARTUPE2 原语,我这里封装为了一个代码模块,具体可看这篇博文

verilog 复制代码
/* 
 * file			: set_CCLK.v
 * author		: 今朝无言
 * Lab			: WHU-EIS-LMSWE
 * date			: 2023-11-02
 * version		: v1.0
 * description	: 使用原语设置CCLK
 * Copyright © 2023 WHU-EIS-LMSWE, All Rights Reserved.
 */
`default_nettype none
module set_CCLK(
input	wire	usrcclk,
input	wire	usrdone,

output	wire	cfgclk,
output	wire	cfgmclk,
output	wire	eos
);

//-------------------STARTUPE2---------------------
STARTUPE2 #(
	.PROG_USR		("FALSE"),
	.SIM_CCLK_FREQ	(0.0)
)
STARTUPE2_inst(
	.CFGCLK			(cfgclk),
	.CFGMCLK		(cfgmclk),
	.EOS			(eos),
	.PREQ			(),
	.CLK			(0),
	.GSR			(0),
	.GTS			(0),
	.KEYCLEARB		(1),
	.PACK			(1),
	.USRCCLKO		(usrcclk),
	.USRCCLKTS		(0),
	.USRDONEO		(usrdone),
	.USRDONETS		(0)
);

endmodule

在该测试代码中,循环向 FLASH 写入自增 1 的数据,然后观察从 FLASH 读取到的数据,如下

可以看到读取到正确的数据。

Something

在测试 FLASH 读写中踩到了好多坑,主要是写入/擦除操作方面的(写寄存器、写主存、擦除等),记录如下:

  • WREN 操作后,WEL bit 不是立即置位的,如果执行 WREN 后立即执行写寄存器、擦除、写主存等操作,都会失败(这些操作都需要写使能位 WEL 为高才能执行)。精细测量发现在执行 WREN 后约 800us ,WEL 才被置位,且这个时间不是很固定,因此强烈建议在执行 WREN 后,周期检查 WEL bit,待 WEL=1 后再执行擦除、写入操作。

  • WRR 命令执行后,若只存在把某位(某些位)从 0 置 1 的操作,则执行非常快(小于 1ms);而如果存在把某些位从 1 置 0 的操作时,设备会陷入长时间的忙碌状态(WIP=1),测试表明约 383ms。若在 WIP=1 的状态执行新的写入、擦除操作时,这些指令都会被忽略。因此在执行 WRR 后也需要检查 WIP,待 WIP=0 后才能退回空闲状态。即写寄存器应当遵循 'WREN -> check WEL -> WR Reg -> check WIP -> return IDLE' 的流程。

  • Erase、Page Program 等操作执行后时间也很长,也应当遵循 'WREN -> check WEL -> Erase/PP -> check WIP -> return IDLE' 的流程。

(完)

相关推荐
_.Switch1 分钟前
Python 自动化运维持续优化与性能调优
运维·开发语言·python·缓存·自动化·运维开发
徐*红2 分钟前
java 线程池
java·开发语言
尚学教辅学习资料2 分钟前
基于SSM的养老院管理系统+LW示例参考
java·开发语言·java毕设·养老院
1 9 J4 分钟前
Java 上机实践4(类与对象)
java·开发语言·算法
Code apprenticeship5 分钟前
Java面试题(2)
java·开发语言
J不A秃V头A7 分钟前
Python爬虫:获取国家货币编码、货币名称
开发语言·爬虫·python
SRY122404193 小时前
javaSE面试题
java·开发语言·面试
无尽的大道3 小时前
Java 泛型详解:参数化类型的强大之处
java·开发语言
ZIM学编程3 小时前
Java基础Day-Sixteen
java·开发语言·windows
放逐者-保持本心,方可放逐3 小时前
react 组件应用
开发语言·前端·javascript·react.js·前端框架