3781 lines
119 KiB
VHDL
3781 lines
119 KiB
VHDL
|
-------------------------------------------------------------------------------
|
||
|
|
-- This is the property of PERFTRENDS TECHNOLOGIES PRIVATE LIMITED and
|
||
|
|
-- possession or use of file has to be with the written LICENCE AGGREMENT
|
||
|
|
-- from PERFTRENDS TECHNOLOGIES PRIVATE LIMITED.
|
||
|
|
--
|
||
|
|
-------------------------------------------------------------------------------
|
||
|
|
--
|
||
|
|
-- Project : Atmel DataFlash model
|
||
|
|
-------------------------------------------------------------------------------
|
||
|
|
-- File : $RCSfile: DataFlash2.1.vhd,v $
|
||
|
|
-- Path : $Source: /home/cvs/atmel_flash_dev/design/DataFlash2.1.vhd,v $
|
||
|
|
-- Author : E.MAGESH
|
||
|
|
-- Created on : 20-06-06
|
||
|
|
-- Revision : $Revision: 1.1 $
|
||
|
|
-- Last modified by : $Author: magesh $
|
||
|
|
-- Last modified on : $Date: 2006/07/19 13:54:54 $
|
||
|
|
-------------------------------------------------------------------------------
|
||
|
|
-- Module : FlashMemory
|
||
|
|
-- Description :
|
||
|
|
--
|
||
|
|
--
|
||
|
|
-------------------------------------------------------------------------------
|
||
|
|
--
|
||
|
|
-- Design hierarchy :
|
||
|
|
-- Instantiated Modules :
|
||
|
|
-------------------------------------------------------------------------------
|
||
|
|
-- Revision history :
|
||
|
|
-- $Log: DataFlash2.1.vhd,v $
|
||
|
|
-- Revision 1.1 2006/07/19 13:54:54 magesh
|
||
|
|
-- *** empty log message ***
|
||
|
|
--
|
||
|
|
-- Revision 1.5 2006/06/29 12:34:49 magesh
|
||
|
|
-- *** empty log message ***
|
||
|
|
--
|
||
|
|
-- Revision 1.4 2006/06/27 12:05:42 magesh
|
||
|
|
-- *** empty log message ***
|
||
|
|
--
|
||
|
|
-- Revision 1.3 2006/06/21 14:24:03 magesh
|
||
|
|
-- *** empty log message ***
|
||
|
|
--
|
||
|
|
-- Revision 1.2 2006/06/20 13:34:01 magesh
|
||
|
|
-- *** empty log message ***
|
||
|
|
--
|
||
|
|
-------------------------------------------------------------------------------
|
||
|
|
|
||
|
|
|
||
|
|
library std;
|
||
|
|
use std.textio.all;
|
||
|
|
library IEEE;
|
||
|
|
use IEEE.std_logic_1164.all;
|
||
|
|
use IEEE.std_logic_textio.all;
|
||
|
|
use ieee.std_logic_arith.all;
|
||
|
|
use IEEE.Std_logic_unsigned.all;
|
||
|
|
use IEEE.numeric_std.all;
|
||
|
|
---entity declarations--------------
|
||
|
|
entity DataFlash is
|
||
|
|
generic (
|
||
|
|
flashmemory : string := "memory.txt";
|
||
|
|
Rapid_interface : boolean := true ;
|
||
|
|
fsck : integer := 66;
|
||
|
|
DEVICE : string(1 to 10) :="AT45DB011D";
|
||
|
|
Tsck : Time := 13.6 ns);
|
||
|
|
port(
|
||
|
|
SI : in std_logic; -- Data SPI
|
||
|
|
CSB : in std_logic; -- Chip Select SPI
|
||
|
|
SCK : in std_logic; -- Clock SPI
|
||
|
|
WPB : in std_logic; -- Hard Ware Page Write protecteds Pin
|
||
|
|
RESETB : in std_logic; -- Reset Pin
|
||
|
|
SO : out std_logic; -- Serial Output
|
||
|
|
RDYBSY : out std_logic -- Ready Busy pin
|
||
|
|
);
|
||
|
|
end DataFlash ;
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
----architecture declarations------
|
||
|
|
architecture design of DataFlash is
|
||
|
|
constant t_buffer : integer := 2;
|
||
|
|
signal binary_page : std_logic := '0';
|
||
|
|
signal status2 : std_logic :='1';
|
||
|
|
signal status3 : std_logic ;
|
||
|
|
signal status4 : std_logic ;
|
||
|
|
signal status5 : std_logic ;
|
||
|
|
|
||
|
|
constant TFP : TIME := 14000000 ns;
|
||
|
|
constant TCE : TIME := 400000000 ns; -- TBD Spec. time is 5s
|
||
|
|
constant TVCSL : TIME := 30000 ns; -- ??
|
||
|
|
constant TPUW : TIME := 10000000 ns; -- ??
|
||
|
|
|
||
|
|
---- Input Times check
|
||
|
|
constant Tcar1 : Time := Tsck ;
|
||
|
|
constant Tcar2 : Time := 30 ns ; -- 33 Mhz operation
|
||
|
|
|
||
|
|
constant Twh : TIME := Tsck/2 ; -- SCK High Time
|
||
|
|
constant Twl : TIME := Tsck/2 ; -- SCK Low Time
|
||
|
|
constant Tcs : TIME := 50 ns ; -- Minimum CS! High Time
|
||
|
|
constant Tcss : TIME := 5 ns ; -- CS! setup Time
|
||
|
|
constant Tcsh : TIME := 5 ns ; -- CS! Hold Time
|
||
|
|
constant Tcsb : TIME := 100 ns ; -- Max
|
||
|
|
constant Tsu : TIME := 2 ns ; -- Data in Setup Time
|
||
|
|
constant Th : TIME := 3 ns ; -- Data in Hold Time
|
||
|
|
|
||
|
|
---- Outup delay
|
||
|
|
constant Tho : TIME := 0 ns ; -- Output Hold Time
|
||
|
|
constant Tdis : TIME := 8 ns ; -- Output Disable Time
|
||
|
|
constant Tv : TIME := 8 ns ; -- Output Valid
|
||
|
|
constant Twpe : TIME := 1 ns ; --
|
||
|
|
constant Twpd : TIME := 1 ns ; --
|
||
|
|
constant Tedpd : TIME := 3 us;
|
||
|
|
constant Trdpd : TIME := 30 us;
|
||
|
|
|
||
|
|
---- Processing Time
|
||
|
|
constant Txfr : TIME := 400 us ; -- Page to Buffer Transfer_Compare Time
|
||
|
|
constant Tcomp : TIME := 400 us;
|
||
|
|
constant Tep : TIME := 40 ms ; -- Page Erase and Programming Time
|
||
|
|
constant Tp : TIME := 6 ms; -- Page Programming Time
|
||
|
|
constant Tpe : TIME := 35 ms;
|
||
|
|
constant Tbe : TIME := 100 ms;
|
||
|
|
constant Tse : TIME := 5000 ms; -- Spec. time is 5s
|
||
|
|
constant Trst : TIME := 10 us ; -- Reset Pulse Width
|
||
|
|
constant Trec : TIME := 1 us; -- Reset Recovery Time
|
||
|
|
|
||
|
|
------------------------------------------------
|
||
|
|
signal TsckRp , TsckRw , TsckF , TcsR , TcsF , Tsckm , Tsim , TsckRh : time := 0 ns ;
|
||
|
|
|
||
|
|
------------- global signal declarations---------
|
||
|
|
|
||
|
|
-----opcode enable signal---------
|
||
|
|
|
||
|
|
|
||
|
|
signal MMCAR : std_logic;
|
||
|
|
constant binary_opt : std_logic :='1' ;
|
||
|
|
signal buffer2read : std_logic;
|
||
|
|
signal MMPTB1T : std_logic;
|
||
|
|
signal MMPTB2T : std_logic;
|
||
|
|
signal MMPTB1C : std_logic;
|
||
|
|
signal MMPTB2C : std_logic;
|
||
|
|
signal B1W : std_logic;
|
||
|
|
signal B2W : std_logic;
|
||
|
|
signal B1TMMPPWBIE : std_logic;
|
||
|
|
signal B2TMMPPWBIE : std_logic;
|
||
|
|
signal B1TMMPPWOBIE : std_logic;
|
||
|
|
signal B2TMMPPWOBIE : std_logic;
|
||
|
|
signal PE : std_logic;
|
||
|
|
signal BE : std_logic;
|
||
|
|
signal SE : std_logic;
|
||
|
|
|
||
|
|
signal CE : std_logic;
|
||
|
|
signal MMPPB1 : std_logic;
|
||
|
|
signal MMPPB2 : std_logic;
|
||
|
|
signal APRB1 : std_logic;
|
||
|
|
signal APRB2 : std_logic;
|
||
|
|
|
||
|
|
signal OP3D : std_logic;
|
||
|
|
signal BPS : std_logic;
|
||
|
|
signal PRE : std_logic;
|
||
|
|
signal PRP : std_logic;
|
||
|
|
signal LRP : std_logic;
|
||
|
|
signal SPE : std_logic;
|
||
|
|
signal SPD : std_logic;
|
||
|
|
signal PRR : std_logic;
|
||
|
|
signal LRR : std_logic;
|
||
|
|
signal OP9B : std_logic;
|
||
|
|
signal SRP : std_logic;
|
||
|
|
|
||
|
|
signal security_flag : std_logic:='0';
|
||
|
|
signal soft_prot_enabled : std_logic :='0';
|
||
|
|
signal tmp_reg1 : std_logic_vector(7 downto 0);
|
||
|
|
signal tmp_reg2 : std_logic_vector(7 downto 0);
|
||
|
|
|
||
|
|
signal less_than_33mhz : std_logic;
|
||
|
|
--signal less_than_20Mhz : std_logic;
|
||
|
|
signal locked : std_logic;
|
||
|
|
signal protecteds: std_logic;
|
||
|
|
|
||
|
|
signal protection : bit_vector(511 downto 0) := (others=>'1');
|
||
|
|
signal lockdown : bit_vector(511 downto 0) := (others=>'0');
|
||
|
|
signal security : bit_vector(511 downto 0) := (others=>'1');
|
||
|
|
signal factory : bit_vector(511 downto 0) := (others=>'1');
|
||
|
|
|
||
|
|
|
||
|
|
function device_Sel1 (DEVICE : in string(1 to 10)
|
||
|
|
) return std_logic is
|
||
|
|
variable status3 : std_logic;
|
||
|
|
begin
|
||
|
|
if (DEVICE="AT45DB041D")then
|
||
|
|
status3 := '1';
|
||
|
|
|
||
|
|
elsif(DEVICE="AT45DB081D") then
|
||
|
|
status3 := '0';
|
||
|
|
|
||
|
|
|
||
|
|
elsif(DEVICE="AT45DB161D") then
|
||
|
|
status3 := '1' ;
|
||
|
|
|
||
|
|
elsif(DEVICE="AT45DB321D") then
|
||
|
|
status3 := '0';
|
||
|
|
|
||
|
|
elsif(DEVICE="AT45DB642D") then
|
||
|
|
status3 := '1';
|
||
|
|
|
||
|
|
elsif(DEVICE="AT45DB011D") then
|
||
|
|
status3 := '1';
|
||
|
|
|
||
|
|
elsif(DEVICE="AT45DB021D") then
|
||
|
|
status3 :='1';
|
||
|
|
|
||
|
|
else
|
||
|
|
status3 := '1';
|
||
|
|
|
||
|
|
end if;
|
||
|
|
|
||
|
|
return status3;
|
||
|
|
|
||
|
|
end device_sel1;
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
function device_Sel2 (DEVICE : in string(1 to 10)
|
||
|
|
) return std_logic is
|
||
|
|
variable status4 : std_logic;
|
||
|
|
begin
|
||
|
|
if (DEVICE="AT45DB041D")then
|
||
|
|
|
||
|
|
status4 := '1';
|
||
|
|
|
||
|
|
elsif(DEVICE="AT45DB081D") then
|
||
|
|
|
||
|
|
status4 := '0';
|
||
|
|
|
||
|
|
|
||
|
|
elsif(DEVICE="AT45DB161D") then
|
||
|
|
|
||
|
|
status4 := '0' ;
|
||
|
|
|
||
|
|
elsif(DEVICE="AT45DB321D") then
|
||
|
|
|
||
|
|
status4 := '1';
|
||
|
|
|
||
|
|
elsif(DEVICE="AT45DB642D") then
|
||
|
|
|
||
|
|
status4 := '1';
|
||
|
|
|
||
|
|
elsif(DEVICE="AT45DB011D") then
|
||
|
|
|
||
|
|
status4 := '0';
|
||
|
|
|
||
|
|
elsif(DEVICE="AT45DB021D") then
|
||
|
|
|
||
|
|
status4 :='1';
|
||
|
|
|
||
|
|
else
|
||
|
|
|
||
|
|
status4 := '1';
|
||
|
|
|
||
|
|
end if;
|
||
|
|
|
||
|
|
return status4;
|
||
|
|
|
||
|
|
end device_sel2;
|
||
|
|
|
||
|
|
|
||
|
|
function device_Sel3 (DEVICE : in string(1 to 10)
|
||
|
|
) return std_logic is
|
||
|
|
variable status5 : std_logic;
|
||
|
|
begin
|
||
|
|
|
||
|
|
if (DEVICE="AT45DB041D")then
|
||
|
|
|
||
|
|
status5 := '0';
|
||
|
|
elsif(DEVICE="AT45DB081D") then
|
||
|
|
|
||
|
|
status5 := '1';
|
||
|
|
|
||
|
|
elsif(DEVICE="AT45DB161D") then
|
||
|
|
|
||
|
|
status5 := '1' ;
|
||
|
|
elsif(DEVICE="AT45DB321D") then
|
||
|
|
|
||
|
|
status5 := '1';
|
||
|
|
elsif(DEVICE="AT45DB642D") then
|
||
|
|
|
||
|
|
status5 := '1';
|
||
|
|
elsif(DEVICE="AT45DB011D") then
|
||
|
|
|
||
|
|
status5 := '0';
|
||
|
|
elsif(DEVICE="AT45DB021D") then
|
||
|
|
|
||
|
|
status5 :='0';
|
||
|
|
else
|
||
|
|
|
||
|
|
status5 := '0';
|
||
|
|
end if;
|
||
|
|
return status5;
|
||
|
|
|
||
|
|
end device_sel3;
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
function page_cal (DEVICE : in string(1 to 10)
|
||
|
|
) return integer is
|
||
|
|
variable pages : integer range 1 to 8192 := 2048;
|
||
|
|
begin
|
||
|
|
case DEVICE is
|
||
|
|
when "AT45DB041D" =>
|
||
|
|
pages := 2048;
|
||
|
|
when "AT45DB081D" =>
|
||
|
|
pages := 4096;
|
||
|
|
when "AT45DB161D" =>
|
||
|
|
pages := 4096;
|
||
|
|
when "AT45DB321D" =>
|
||
|
|
pages := 8192;
|
||
|
|
when "AT45DB642D" =>
|
||
|
|
pages := 8192;
|
||
|
|
when "AT45DB011D" =>
|
||
|
|
pages := 512;
|
||
|
|
when "AT45DB021D" =>
|
||
|
|
pages := 1024;
|
||
|
|
when OTHERS =>
|
||
|
|
pages := 2048;
|
||
|
|
end case;
|
||
|
|
|
||
|
|
return pages;
|
||
|
|
|
||
|
|
end page_cal;
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
function pageper_sector (DEVICE : in string(1 to 10)
|
||
|
|
) return integer is
|
||
|
|
variable page_per_sector : integer range 1 to 256 :=256;
|
||
|
|
|
||
|
|
begin
|
||
|
|
|
||
|
|
|
||
|
|
case DEVICE is
|
||
|
|
when "AT45DB041D" =>
|
||
|
|
page_per_sector := 256;
|
||
|
|
when "AT45DB081D" =>
|
||
|
|
page_per_sector := 256;
|
||
|
|
when "AT45DB161D" =>
|
||
|
|
page_per_sector := 256;
|
||
|
|
when "AT45DB321D" =>
|
||
|
|
page_per_sector := 128;
|
||
|
|
when "AT45DB642D" =>
|
||
|
|
page_per_sector := 256;
|
||
|
|
when "AT45DB011D" =>
|
||
|
|
page_per_sector := 128;
|
||
|
|
when "AT45DB021D" =>
|
||
|
|
page_per_sector := 128;
|
||
|
|
when OTHERS =>
|
||
|
|
page_per_sector := 256;
|
||
|
|
end case;
|
||
|
|
|
||
|
|
return page_per_sector;
|
||
|
|
|
||
|
|
|
||
|
|
end pageper_sector;
|
||
|
|
|
||
|
|
|
||
|
|
function sec_tors (DEVICE : in string(1 to 10)
|
||
|
|
) return integer is
|
||
|
|
variable sectors : integer range 1 to 64 :=8;
|
||
|
|
|
||
|
|
|
||
|
|
begin
|
||
|
|
case DEVICE is
|
||
|
|
when "AT45DB041D" =>
|
||
|
|
sectors := 8;
|
||
|
|
when "AT45DB081D" =>
|
||
|
|
sectors := 16;
|
||
|
|
when "AT45DB161D" =>
|
||
|
|
sectors := 16;
|
||
|
|
when "AT45DB321D" =>
|
||
|
|
sectors := 64;
|
||
|
|
when "AT45DB642D" =>
|
||
|
|
sectors := 32;
|
||
|
|
when "AT45DB011D" =>
|
||
|
|
sectors := 4;
|
||
|
|
when "AT45DB021D" =>
|
||
|
|
sectors := 8;
|
||
|
|
when OTHERS =>
|
||
|
|
sectors := 8;
|
||
|
|
end case;
|
||
|
|
|
||
|
|
return sectors;
|
||
|
|
|
||
|
|
end sec_tors;
|
||
|
|
|
||
|
|
function pagesize_forbuffer (DEVICE : in string(1 to 10)
|
||
|
|
) return integer is
|
||
|
|
variable page_size : integer range 1 to 1056 :=264;
|
||
|
|
|
||
|
|
|
||
|
|
begin
|
||
|
|
case DEVICE is
|
||
|
|
when "AT45DB041D" =>
|
||
|
|
page_size := 264;
|
||
|
|
when "AT45DB081D" =>
|
||
|
|
page_size := 264;
|
||
|
|
when "AT45DB161D" =>
|
||
|
|
page_size := 528;
|
||
|
|
when "AT45DB321D" =>
|
||
|
|
page_size := 528;
|
||
|
|
when "AT45DB642D" =>
|
||
|
|
page_size := 1056;
|
||
|
|
when "AT45DB011D" =>
|
||
|
|
page_size := 264;
|
||
|
|
when "AT45DB021D" =>
|
||
|
|
page_size := 264;
|
||
|
|
when OTHERS =>
|
||
|
|
page_size:= 264;
|
||
|
|
end case;
|
||
|
|
|
||
|
|
return page_size;
|
||
|
|
|
||
|
|
end pagesize_forbuffer;
|
||
|
|
|
||
|
|
|
||
|
|
function pagesize (DEVICE : in string(1 to 10);
|
||
|
|
signal binary_page : in std_logic
|
||
|
|
) return integer is
|
||
|
|
variable page_size : integer range 1 to 1056 :=264;
|
||
|
|
|
||
|
|
|
||
|
|
begin
|
||
|
|
case DEVICE is
|
||
|
|
when "AT45DB041D" =>
|
||
|
|
page_size := (264 - (conv_integer(BINARY_page) * 8));
|
||
|
|
when "AT45DB081D" =>
|
||
|
|
page_size := (264 -(conv_integer(BINARY_page) * 8));
|
||
|
|
when "AT45DB161D" =>
|
||
|
|
page_size := (528 -(conv_integer(BINARY_page) * 16));
|
||
|
|
when "AT45DB321D" =>
|
||
|
|
page_size := (528 - (conv_integer(BINARY_page) * 16));
|
||
|
|
when "AT45DB642D" =>
|
||
|
|
page_size := (1056 - (conv_integer(BINARY_page) * 32));
|
||
|
|
when "AT45DB011D" =>
|
||
|
|
|
||
|
|
page_size := (264 - (conv_integer(BINARY_page) * 8));
|
||
|
|
when "AT45DB021D" =>
|
||
|
|
|
||
|
|
page_size := (264 - (conv_integer(BINARY_page) * 8));
|
||
|
|
when OTHERS =>
|
||
|
|
|
||
|
|
page_size:= (264 - (conv_integer(BINARY_page) * 8));
|
||
|
|
end case;
|
||
|
|
|
||
|
|
return page_size;
|
||
|
|
|
||
|
|
end pagesize;
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
function memsize (page_size : in integer range 1 to 1056;
|
||
|
|
pages : in integer range 1 to 8192
|
||
|
|
) return integer is
|
||
|
|
variable mem_size : integer range 1 to 69206016;
|
||
|
|
begin
|
||
|
|
|
||
|
|
mem_size := page_size * pages;
|
||
|
|
return mem_size;
|
||
|
|
|
||
|
|
end memsize;
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
function b_address (DEVICE : in string(1 to 10);
|
||
|
|
signal binary_page : in std_logic
|
||
|
|
) return integer is
|
||
|
|
variable baddress : integer range 1 to 11 := 9;
|
||
|
|
begin
|
||
|
|
|
||
|
|
case DEVICE is
|
||
|
|
when "AT45DB041D" =>
|
||
|
|
baddress := (9 - (conv_integer(BINARY_page) * 1));
|
||
|
|
when "AT45DB081D" =>
|
||
|
|
baddress := (9 -(conv_integer(BINARY_page) * 1));
|
||
|
|
when "AT45DB161D" =>
|
||
|
|
baddress := (10 -(conv_integer(BINARY_page) * 1));
|
||
|
|
when "AT45DB321D" =>
|
||
|
|
baddress:= (10 - (conv_integer(BINARY_page) * 1));
|
||
|
|
when "AT45DB642D" =>
|
||
|
|
baddress := (11 - (conv_integer(BINARY_page) * 1));
|
||
|
|
when "AT45DB011D" =>
|
||
|
|
baddress := (9 - (conv_integer(BINARY_page) * 1));
|
||
|
|
when "AT45DB021D" =>
|
||
|
|
baddress := (9 - (conv_integer(BINARY_page) * 1));
|
||
|
|
when OTHERS =>
|
||
|
|
baddress:= (9 - (conv_integer(BINARY_page) * 1));
|
||
|
|
end case;
|
||
|
|
|
||
|
|
return baddress;
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
end b_address;
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
function p_address (DEVICE : in string(1 to 10)
|
||
|
|
) return integer is
|
||
|
|
variable paddress : integer range 1 to 14 := 11;
|
||
|
|
begin
|
||
|
|
|
||
|
|
case DEVICE is
|
||
|
|
when "AT45DB041D" =>
|
||
|
|
paddress := 11;
|
||
|
|
when "AT45DB081D" =>
|
||
|
|
paddress := 12;
|
||
|
|
when "AT45DB161D" =>
|
||
|
|
paddress := 12;
|
||
|
|
when "AT45DB321D" =>
|
||
|
|
paddress := 13;
|
||
|
|
when "AT45DB642D" =>
|
||
|
|
paddress := 13;
|
||
|
|
when "AT45DB011D" =>
|
||
|
|
paddress := 9;
|
||
|
|
when "AT45DB021D" =>
|
||
|
|
paddress := 10;
|
||
|
|
when OTHERS =>
|
||
|
|
paddress := 11;
|
||
|
|
end case;
|
||
|
|
|
||
|
|
return paddress;
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
end p_address;
|
||
|
|
|
||
|
|
|
||
|
|
function s_address (DEVICE : in string(1 to 10)
|
||
|
|
) return integer is
|
||
|
|
variable saddress : integer range 1 to 6 := 3;
|
||
|
|
begin
|
||
|
|
|
||
|
|
case DEVICE is
|
||
|
|
when "AT45DB041D" =>
|
||
|
|
saddress := 3;
|
||
|
|
when "AT45DB081D" =>
|
||
|
|
saddress := 4;
|
||
|
|
when "AT45DB161D" =>
|
||
|
|
saddress := 4;
|
||
|
|
when "AT45DB321D" =>
|
||
|
|
saddress := 6;
|
||
|
|
when "AT45DB642D" =>
|
||
|
|
saddress := 5;
|
||
|
|
when "AT45DB011D" =>
|
||
|
|
saddress := 2;
|
||
|
|
when "AT45DB021D" =>
|
||
|
|
saddress := 3;
|
||
|
|
when OTHERS =>
|
||
|
|
saddress := 3;
|
||
|
|
end case;
|
||
|
|
|
||
|
|
return saddress;
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
end s_address;
|
||
|
|
|
||
|
|
|
||
|
|
function manid (DEVICE : in string(1 to 10)
|
||
|
|
) return std_logic_vector is
|
||
|
|
variable man_id : std_logic_vector(31 downto 0);
|
||
|
|
begin
|
||
|
|
|
||
|
|
case DEVICE is
|
||
|
|
when "AT45DB041D" =>
|
||
|
|
man_id := X"1F_24_00_00";
|
||
|
|
when "AT45DB081D" =>
|
||
|
|
man_id := X"1F_25_00_00";
|
||
|
|
when "AT45DB161D" =>
|
||
|
|
man_id := X"1F_26_00_00";
|
||
|
|
when "AT45DB321D" =>
|
||
|
|
man_id := X"1F_27_00_00";
|
||
|
|
when "AT45DB642D" =>
|
||
|
|
man_id := X"1F_28_00_00";
|
||
|
|
when "AT45DB011D" =>
|
||
|
|
man_id := X"1F_22_00_00";
|
||
|
|
when "AT45DB021D" =>
|
||
|
|
man_id := X"1F_23_00_00";
|
||
|
|
when OTHERS =>
|
||
|
|
man_id := X"1F_24_01_00";
|
||
|
|
end case;
|
||
|
|
|
||
|
|
return man_id;
|
||
|
|
|
||
|
|
|
||
|
|
end manid;
|
||
|
|
--------------timing task implementation--------
|
||
|
|
|
||
|
|
procedure checkSetupCS(
|
||
|
|
signal CsSignal : in std_logic;
|
||
|
|
CsSignalName : in string;
|
||
|
|
signal TriggerSignal : in std_logic;
|
||
|
|
TriggerSignalName : in string;
|
||
|
|
ExpectedDelay : in time;
|
||
|
|
ExpectedDelayName : in string;
|
||
|
|
signal LastCsFall : inout time;
|
||
|
|
FullPathName : in string;
|
||
|
|
CheckEnabled : in boolean
|
||
|
|
) is
|
||
|
|
|
||
|
|
variable ln : Line;
|
||
|
|
begin
|
||
|
|
if ( CsSignal'event and CsSignal = '0' ) then
|
||
|
|
LastCsFall <= now;
|
||
|
|
end if ;
|
||
|
|
|
||
|
|
if TriggerSignal'event and (now - LastCsFall < ExpectedDelay ) and
|
||
|
|
(now > 0 ns) and (expectedDelay /= 0 ns) and ( lastCsFall /= 0 ns )
|
||
|
|
and checkEnabled then
|
||
|
|
write(ln, string'("Error on "));
|
||
|
|
write(ln, fullPathName);
|
||
|
|
write(ln, string'(": '"));
|
||
|
|
write(ln, string'(CsSignalName));
|
||
|
|
write(ln, string'("' to '"));
|
||
|
|
write(ln, string'(TriggerSignalName));
|
||
|
|
write(ln, string'("' Setup violation at: "));
|
||
|
|
write(ln, now);
|
||
|
|
write(ln, string'(", "));
|
||
|
|
write(ln, string'(ExpectedDelayName));
|
||
|
|
write(ln, string'(" expected: "));
|
||
|
|
write(ln, expectedDelay);
|
||
|
|
write(ln, string'(", "));
|
||
|
|
write(ln, string'(ExpectedDelayName));
|
||
|
|
write(ln, string'(" actual: "));
|
||
|
|
write(ln, now - LastCsFall );
|
||
|
|
|
||
|
|
writeline(output, ln);
|
||
|
|
end if;
|
||
|
|
|
||
|
|
|
||
|
|
end checkSetupCs ;
|
||
|
|
|
||
|
|
--------------------------------------------------------------------------
|
||
|
|
-- CsSignal __________/--------
|
||
|
|
-- TriggerSignal ======x============
|
||
|
|
-- <--->
|
||
|
|
|
||
|
|
procedure checkHoldCS(
|
||
|
|
signal CsSignal : in std_logic;
|
||
|
|
CsSignalName : in string;
|
||
|
|
signal TriggerSignal : in std_logic;
|
||
|
|
TriggerSignalName : in string;
|
||
|
|
ExpectedDelay : in time;
|
||
|
|
ExpectedDelayName : in string;
|
||
|
|
signal LastTriggerEdge : inout time ;
|
||
|
|
FullPathName : in string ;
|
||
|
|
CheckEnabled : in boolean
|
||
|
|
) is
|
||
|
|
|
||
|
|
variable ln : Line;
|
||
|
|
begin
|
||
|
|
if triggerSignal'event then
|
||
|
|
LastTriggerEdge <= now ;
|
||
|
|
end if;
|
||
|
|
|
||
|
|
if CsSignal'event and CsSignal = '1' and ( now - LastTriggerEdge < ExpectedDelay) and
|
||
|
|
(now > 0 ns) and (expectedDelay /= 0 ns) and ( LastTriggerEdge /= 0 ns )
|
||
|
|
and checkEnabled then
|
||
|
|
write(ln, string'("Error on "));
|
||
|
|
write(ln, fullPathName);
|
||
|
|
write(ln, string'(": '"));
|
||
|
|
write(ln, string'(CsSignalName));
|
||
|
|
write(ln, string'("' to '"));
|
||
|
|
write(ln, string'(triggerSignalName));
|
||
|
|
write(ln, string'("' Hold violation at: "));
|
||
|
|
write(ln, now);
|
||
|
|
write(ln, string'(", "));
|
||
|
|
write(ln, string'(expectedDelayName));
|
||
|
|
write(ln, string'(" expected: "));
|
||
|
|
write(ln, expectedDelay);
|
||
|
|
write(ln, string'(", "));
|
||
|
|
write(ln, string'(expectedDelayName));
|
||
|
|
write(ln, string'(" actual: "));
|
||
|
|
write(ln, now - LastTriggerEdge);
|
||
|
|
|
||
|
|
writeline(output, ln);
|
||
|
|
end if;
|
||
|
|
|
||
|
|
|
||
|
|
end checkHoldCs;
|
||
|
|
|
||
|
|
|
||
|
|
-----------------------------------------------------------------------
|
||
|
|
-- Trigger ___________/---------
|
||
|
|
-- Reference =====x===============
|
||
|
|
-- <----->
|
||
|
|
|
||
|
|
procedure checkSetupRise(
|
||
|
|
signal ReferenceSignal : in std_logic;
|
||
|
|
ReferenceSignalName : in string;
|
||
|
|
signal TriggerSignal : in std_logic;
|
||
|
|
TriggerSignalName : in string;
|
||
|
|
ExpectedDelay : in time;
|
||
|
|
ExpectedDelayName : in string;
|
||
|
|
signal LastReferenceMove : inout time;
|
||
|
|
FullPathName : in string ;
|
||
|
|
CheckEnabled : in boolean
|
||
|
|
) is
|
||
|
|
|
||
|
|
variable ln : Line;
|
||
|
|
|
||
|
|
begin
|
||
|
|
if referenceSignal'Event then
|
||
|
|
LastReferenceMove <= now ;
|
||
|
|
end if;
|
||
|
|
|
||
|
|
|
||
|
|
if triggerSignal'event and triggerSignal = '1' and
|
||
|
|
( now - LastReferenceMove < expectedDelay) and
|
||
|
|
(now > 0 ns) and (expectedDelay /= 0 ns) and ( LastReferenceMove /= 0 ns )
|
||
|
|
and checkEnabled then
|
||
|
|
write(ln, string'("Error on "));
|
||
|
|
write(ln, fullPathName);
|
||
|
|
write(ln, string'(": '"));
|
||
|
|
write(ln, string'(referenceSignalName));
|
||
|
|
write(ln, string'("' to '"));
|
||
|
|
write(ln, string'(triggerSignalName));
|
||
|
|
write(ln, string'("' Setup violation at: "));
|
||
|
|
write(ln, now);
|
||
|
|
write(ln, string'(", "));
|
||
|
|
write(ln, string'(expectedDelayName));
|
||
|
|
write(ln, string'(" expected: "));
|
||
|
|
write(ln, expectedDelay);
|
||
|
|
write(ln, string'(", "));
|
||
|
|
write(ln, string'(expectedDelayName));
|
||
|
|
write(ln, string'(" actual: "));
|
||
|
|
write(ln, now - LastReferenceMove);
|
||
|
|
|
||
|
|
writeline(output, ln);
|
||
|
|
|
||
|
|
end if;
|
||
|
|
|
||
|
|
|
||
|
|
end checkSetupRise;
|
||
|
|
|
||
|
|
|
||
|
|
-----------------------------------------------------------------
|
||
|
|
-- Trigger __________/----------
|
||
|
|
-- Reference ================x====
|
||
|
|
-- <----->
|
||
|
|
|
||
|
|
|
||
|
|
procedure checkHoldRise(
|
||
|
|
signal ReferenceSignal : in std_logic;
|
||
|
|
ReferenceSignalName : in string;
|
||
|
|
signal TriggerSignal : in std_logic;
|
||
|
|
TriggerSignalName : in string;
|
||
|
|
ExpectedDelay : in time;
|
||
|
|
ExpectedDelayName : in string;
|
||
|
|
signal LastTriggerRise : inout time;
|
||
|
|
FullPathName : in string ;
|
||
|
|
CheckEnabled : in boolean
|
||
|
|
) is
|
||
|
|
variable ln : Line;
|
||
|
|
begin
|
||
|
|
if TriggerSignal'event and TriggerSignal = '1' then
|
||
|
|
LastTriggerRise <= now ;
|
||
|
|
end if;
|
||
|
|
if ReferenceSignal'event and ( now - LastTriggerRise < expectedDelay) and
|
||
|
|
(now > 0 ns) and (expectedDelay /= 0 ns) and ( LastTriggerRise /= 0 ns )
|
||
|
|
and checkEnabled then
|
||
|
|
write(ln, string'("Error on "));
|
||
|
|
write(ln, fullPathName);
|
||
|
|
write(ln, string'(": '"));
|
||
|
|
write(ln, string'(referenceSignalName));
|
||
|
|
write(ln, string'("' to '"));
|
||
|
|
write(ln, string'(triggerSignalName));
|
||
|
|
write(ln, string'("' Hold violation at: "));
|
||
|
|
write(ln, now);
|
||
|
|
write(ln, string'(", "));
|
||
|
|
write(ln, string'(expectedDelayName));
|
||
|
|
write(ln, string'(" expected: "));
|
||
|
|
write(ln, expectedDelay);
|
||
|
|
write(ln, string'(", "));
|
||
|
|
write(ln, string'(expectedDelayName));
|
||
|
|
write(ln, string'(" actual: "));
|
||
|
|
write(ln, now - LastTriggerRise);
|
||
|
|
|
||
|
|
writeline(output, ln);
|
||
|
|
end if;
|
||
|
|
|
||
|
|
|
||
|
|
end checkHoldRise;
|
||
|
|
|
||
|
|
|
||
|
|
------------------------------------------------------------------------------
|
||
|
|
-- Signal ____/------\_______/----
|
||
|
|
-- <-------------->
|
||
|
|
|
||
|
|
procedure checkPeriod(
|
||
|
|
signal TestSignal : in std_logic;
|
||
|
|
TestSignalName : in string;
|
||
|
|
expectedDelay : in time;
|
||
|
|
expectedDelayName : in string;
|
||
|
|
signal LastSignalRise : inout time;
|
||
|
|
fullPathName : in string;
|
||
|
|
checkEnabled : in boolean
|
||
|
|
) is
|
||
|
|
variable ln : Line;
|
||
|
|
begin
|
||
|
|
|
||
|
|
if (TestSignal'event and TestSignal = '1') then
|
||
|
|
if (now - lastSignalRise < expectedDelay) and ( lastSignalRise /= 0 ns ) and
|
||
|
|
(now > 0 ns) and (expectedDelay /= 0 ns) and checkEnabled then
|
||
|
|
write(ln, string'("Error on "));
|
||
|
|
write(ln, fullPathName);
|
||
|
|
write(ln, string'(": '"));
|
||
|
|
write(ln, string'(TestSignalName));
|
||
|
|
write(ln, string'("' Periode violation at: "));
|
||
|
|
write(ln, now);
|
||
|
|
write(ln, string'(", "));
|
||
|
|
write(ln, string'(expectedDelayName));
|
||
|
|
write(ln, string'(" expected: "));
|
||
|
|
write(ln, expectedDelay);
|
||
|
|
write(ln, string'(", "));
|
||
|
|
write(ln, string'(expectedDelayName));
|
||
|
|
write(ln, string'(" actual: "));
|
||
|
|
write(ln, now - lastSignalRise);
|
||
|
|
|
||
|
|
writeline(output, ln);
|
||
|
|
end if;
|
||
|
|
|
||
|
|
|
||
|
|
LastSignalRise <= now;
|
||
|
|
end if;
|
||
|
|
|
||
|
|
|
||
|
|
end checkPeriod;
|
||
|
|
|
||
|
|
----------------------------------------------------------------------
|
||
|
|
-- Signal ____/---------\____
|
||
|
|
-- <--------->
|
||
|
|
|
||
|
|
|
||
|
|
procedure checkWidth1(
|
||
|
|
signal TestSignal : in std_logic;
|
||
|
|
TestSignalName : in string;
|
||
|
|
ExpectedDelay : in time;
|
||
|
|
ExpectedDelayName : in string;
|
||
|
|
signal LastSignalRise : inout time ;
|
||
|
|
FullPathName : in string ;
|
||
|
|
CheckEnabled : in boolean
|
||
|
|
) is
|
||
|
|
variable ln : Line;
|
||
|
|
begin
|
||
|
|
|
||
|
|
if (TestSignal'event and TestSignal = '1') then
|
||
|
|
LastSignalRise <= now;
|
||
|
|
end if;
|
||
|
|
|
||
|
|
if (TestSignal'event and TestSignal = '0') and
|
||
|
|
(now - lastSignalRise < expectedDelay) and
|
||
|
|
(now > 0 ns) and (expectedDelay /= 0 ns) and ( lastSignalRise /= 0 ns )
|
||
|
|
and checkEnabled then
|
||
|
|
write(ln, string'("Error on "));
|
||
|
|
write(ln, fullPathName);
|
||
|
|
write(ln, string'(": '"));
|
||
|
|
write(ln, string'(TestSignalName));
|
||
|
|
write(ln, string'("' Pulse Width violation at: "));
|
||
|
|
write(ln, now);
|
||
|
|
write(ln, string'(", "));
|
||
|
|
write(ln, string'(expectedDelayName));
|
||
|
|
write(ln, string'(" expected: "));
|
||
|
|
write(ln, expectedDelay);
|
||
|
|
write(ln, string'(", "));
|
||
|
|
write(ln, string'(expectedDelayName));
|
||
|
|
write(ln, string'(" actual: "));
|
||
|
|
write(ln, now - lastSignalRise);
|
||
|
|
|
||
|
|
writeline(output, ln);
|
||
|
|
end if;
|
||
|
|
|
||
|
|
|
||
|
|
end checkWidth1;
|
||
|
|
|
||
|
|
----------------------------------------------------------------------
|
||
|
|
-- Signal ----\_________/-----
|
||
|
|
-- <--------->
|
||
|
|
|
||
|
|
procedure checkWidth0(
|
||
|
|
signal TestSignal : in std_logic;
|
||
|
|
TestSignalName : in string;
|
||
|
|
ExpectedDelay : in time;
|
||
|
|
ExpectedDelayName : in string;
|
||
|
|
signal LastSignalFall : inout time ;
|
||
|
|
fullPathName : in string ;
|
||
|
|
checkEnabled : in boolean
|
||
|
|
) is
|
||
|
|
variable ln : Line;
|
||
|
|
begin
|
||
|
|
if (TestSignal'event and TestSignal = '0') then
|
||
|
|
lastSignalFall <= now;
|
||
|
|
end if;
|
||
|
|
|
||
|
|
if (TestSignal'event and TestSignal = '1') and
|
||
|
|
(now - lastSignalFall < expectedDelay) and ( lastSignalFall /= 0 ns ) and
|
||
|
|
(now > 0 ns) and (expectedDelay /= 0 ns) and checkEnabled then
|
||
|
|
write(ln, string'("Error on "));
|
||
|
|
write(ln, fullPathName);
|
||
|
|
write(ln, string'(": '"));
|
||
|
|
write(ln, string'(TestSignalName));
|
||
|
|
write(ln, string'("' Pulse Width violation at: "));
|
||
|
|
write(ln, now);
|
||
|
|
write(ln, string'(", "));
|
||
|
|
write(ln, string'(expectedDelayName));
|
||
|
|
write(ln, string'(" expected: "));
|
||
|
|
write(ln, expectedDelay);
|
||
|
|
write(ln, string'(", "));
|
||
|
|
write(ln, string'(expectedDelayName));
|
||
|
|
write(ln, string'(" actual: "));
|
||
|
|
write(ln, now - lastSignalFall);
|
||
|
|
|
||
|
|
writeline(output, ln);
|
||
|
|
end if;
|
||
|
|
|
||
|
|
end checkWidth0;
|
||
|
|
-------------------------------------------------------------------
|
||
|
|
-------------------------------------------------------------------
|
||
|
|
-------------------------------------------------------------------
|
||
|
|
FUNCTION integer_to_bit_vector (VAL, width : INTEGER) RETURN BIT_VECTOR IS
|
||
|
|
VARIABLE result : BIT_VECTOR (width-1 downto 0) := (OTHERS=>'0');
|
||
|
|
VARIABLE bits : INTEGER := width;
|
||
|
|
BEGIN
|
||
|
|
IF (bits > 31) THEN -- Avoid overflow errors.
|
||
|
|
bits := 31;
|
||
|
|
ELSE
|
||
|
|
ASSERT 2**bits > VAL REPORT
|
||
|
|
"Value too big FOR BIT_VECTOR width"
|
||
|
|
SEVERITY WARNING;
|
||
|
|
END IF;
|
||
|
|
|
||
|
|
FOR i IN 0 TO bits - 1 LOOP
|
||
|
|
IF ((val/(2**i)) MOD 2 = 1) THEN
|
||
|
|
result(i) := '1';
|
||
|
|
END IF;
|
||
|
|
|
||
|
|
END LOOP;
|
||
|
|
|
||
|
|
RETURN (result);
|
||
|
|
END integer_to_bit_vector ;
|
||
|
|
PROCEDURE removespace(VARIABLE l : IN line; pos : OUT integer) IS
|
||
|
|
BEGIN
|
||
|
|
pos := l'low;
|
||
|
|
FOR i IN l'low TO l'high LOOP
|
||
|
|
CASE l(i) IS
|
||
|
|
WHEN ' ' | ht =>
|
||
|
|
pos := i + 1;
|
||
|
|
WHEN OTHERS =>
|
||
|
|
EXIT;
|
||
|
|
END CASE;
|
||
|
|
END LOOP;
|
||
|
|
END;
|
||
|
|
PROCEDURE removeline(l : INOUT line; pos : integer) IS
|
||
|
|
VARIABLE tmpl : line;
|
||
|
|
BEGIN
|
||
|
|
tmpl := l;
|
||
|
|
l := NEW string'(tmpl(pos TO tmpl'high));
|
||
|
|
deallocate(tmpl);
|
||
|
|
END;
|
||
|
|
PROCEDURE hexa_to_bit_vector(l: INOUT line; u: in integer; value: OUT bit_vector) IS
|
||
|
|
CONSTANT not_digit : integer := -999;
|
||
|
|
FUNCTION digit_value(c : character) RETURN integer IS
|
||
|
|
BEGIN
|
||
|
|
IF (c >= '0') AND (c <= '9') THEN
|
||
|
|
RETURN (character'pos(c) - character'pos('0'));
|
||
|
|
ELSIF (c >= 'a') AND (c <= 'f') THEN
|
||
|
|
RETURN (character'pos(c) - character'pos('a') + 10);
|
||
|
|
ELSIF (c >= 'A') AND (c <= 'F') THEN
|
||
|
|
RETURN (character'pos(c) - character'pos('A') + 10);
|
||
|
|
ELSE
|
||
|
|
RETURN not_digit;
|
||
|
|
END IF;
|
||
|
|
END;
|
||
|
|
VARIABLE digit : bit_vector(4 downto 1);
|
||
|
|
VARIABLE digit1 : bit_vector(u downto 1);
|
||
|
|
VARIABLE digitx : integer;
|
||
|
|
VARIABLE pos : integer;
|
||
|
|
VARIABLE t : integer := u/4;
|
||
|
|
BEGIN
|
||
|
|
removespace(l, pos);
|
||
|
|
FOR i IN pos TO l'right LOOP
|
||
|
|
digitx := digit_value(l(i));
|
||
|
|
EXIT WHEN (digitx = not_digit) OR (digitx >= 16);
|
||
|
|
digit := integer_to_bit_vector(digitx,4);
|
||
|
|
if t >= 1 then
|
||
|
|
digit1 := digit1(u-4 downto 1) & digit;
|
||
|
|
t := t - 1;
|
||
|
|
else
|
||
|
|
end if;
|
||
|
|
pos := i + 1;
|
||
|
|
END LOOP;
|
||
|
|
value := digit1;
|
||
|
|
removeline(l, pos);
|
||
|
|
END;
|
||
|
|
|
||
|
|
--******************************************---
|
||
|
|
--******************************************--
|
||
|
|
|
||
|
|
signal page_status : std_logic_vector(page_cal(device)-1 downto 0);
|
||
|
|
signal temp_page_status : std_logic;
|
||
|
|
signal page : std_logic_vector(p_address(device)-1 downto 0);
|
||
|
|
signal temp_reg2 : std_logic_vector(7 downto 0);
|
||
|
|
|
||
|
|
signal temp_page : std_logic_vector(p_address(device)-1 downto 0);
|
||
|
|
|
||
|
|
signal byte : std_logic_vector(b_address(device,binary_page)-1 downto 0);
|
||
|
|
|
||
|
|
---protecteds/locked status reg-----
|
||
|
|
signal prot_status : std_logic_vector(sec_tors(device) downto 0);
|
||
|
|
signal sector : std_logic_vector(s_address(device)-1 downto 0);
|
||
|
|
|
||
|
|
type buffer1 is array(pagesize_forbuffer(device)-1 downto 0) of bit_vector(7 downto 0);
|
||
|
|
signal tbuffer1 : buffer1;
|
||
|
|
|
||
|
|
type buffer2 is array(pagesize_forbuffer(device)-1 downto 0) of bit_vector(7 downto 0);
|
||
|
|
signal tbuffer2 : buffer2;
|
||
|
|
|
||
|
|
--memory initalization--
|
||
|
|
constant N : integer range 1 to 69206016 := memsize(pagesize_forbuffer(device),page_cal(DEVICE));
|
||
|
|
constant M : integer := 8;
|
||
|
|
|
||
|
|
type memtype is array(N-1 downto 0) of bit_vector(7 downto 0);
|
||
|
|
signal memory : memtype;
|
||
|
|
|
||
|
|
--protection initialization---
|
||
|
|
constant p : integer := sec_tors(device);
|
||
|
|
type prot_type is array(p-1 downto 0) of bit_vector(7 downto 0);
|
||
|
|
signal prot_reg : prot_type;
|
||
|
|
|
||
|
|
--lock initialization--
|
||
|
|
type lock_type is array(p-1 downto 0) of bit_vector(7 downto 0);
|
||
|
|
signal lock_reg : lock_type;
|
||
|
|
|
||
|
|
--factory security ---
|
||
|
|
type factory_type is array(63 downto 0 ) of bit_vector(7 downto 0);
|
||
|
|
signal factory_reg : factory_type;
|
||
|
|
|
||
|
|
--security reg--
|
||
|
|
type security_type is array(63 downto 0) of bit_vector(7 downto 0);
|
||
|
|
signal security_reg : security_type;
|
||
|
|
--in security register 0 to 63 byte one time user programmable
|
||
|
|
---64 to 127 byte factory programmable by atmel--
|
||
|
|
|
||
|
|
|
||
|
|
----------------------op3d------
|
||
|
|
signal op3d_tmp_reg : std_logic_vector(7 downto 0):= "00000000";
|
||
|
|
----------------------opc7------
|
||
|
|
signal opc7_tmp_reg : std_logic_vector(7 downto 0):= "00000000";
|
||
|
|
----------------------MMPPB1-----------
|
||
|
|
signal MMPPB1_temp_page : std_logic_vector(p_address(device)-1 downto 0);
|
||
|
|
signal MMPPB1_page : std_logic_vector(p_address(device)-1 downto 0);
|
||
|
|
signal MMPPB1_byte : std_logic_vector(b_address(device,binary_page)-1 downto 0);
|
||
|
|
signal MMPPB1_tmp_reg : std_logic_vector(7 downto 0):= "00000000";
|
||
|
|
signal MMPPB1_tmp_reg1 : std_logic_vector(7 downto 0):= "00000000";
|
||
|
|
signal MMPPB1_tmp_reg2 : std_logic_vector(7 downto 0):= "00000000";
|
||
|
|
|
||
|
|
|
||
|
|
----------------------MMPPB2-----------
|
||
|
|
signal MMPPB2_temp_page : std_logic_vector(p_address(device)-1 downto 0);
|
||
|
|
signal MMPPB2_page : std_logic_vector(p_address(device)-1 downto 0);
|
||
|
|
signal MMPPB2_byte : std_logic_vector(b_address(device,binary_page)-1 downto 0);
|
||
|
|
signal MMPPB2_tmp_reg1 : std_logic_vector(7 downto 0):= "00000000";
|
||
|
|
signal MMPPB2_tmp_reg2 : std_logic_vector(7 downto 0):= "00000000";
|
||
|
|
|
||
|
|
---------------------
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
--------------comp page address function implementation---------------
|
||
|
|
function comp_page_addr ( paddress : in integer range 1 to 14;
|
||
|
|
signal binary_page : in std_logic;
|
||
|
|
signal page_addr0 : in std_logic_vector( 7 downto 0);
|
||
|
|
signal page_addr1 : in std_logic_vector( 7 downto 0);
|
||
|
|
man_id : in std_logic_vector(31 downto 0)
|
||
|
|
) return std_logic_vector is
|
||
|
|
variable page1 : std_logic_vector((P_ADDRESS(device))-1 DOWNTO 0);
|
||
|
|
begin
|
||
|
|
|
||
|
|
|
||
|
|
case(PADDRESS) is
|
||
|
|
--when 14 =>
|
||
|
|
--if(binary_page='1') then
|
||
|
|
--page := (page_addr0(7 downto 0)) & (page_addr1(7 downto 2));
|
||
|
|
--else --4 address bytes
|
||
|
|
--page := temp_reg2(0) & page_addr0(7 downto 0) & page_addr1(7 downto 2);
|
||
|
|
--end if;
|
||
|
|
when 13 =>
|
||
|
|
--64mb--
|
||
|
|
if(MAN_ID = X"1F280000")then
|
||
|
|
if(binary_page='1') then
|
||
|
|
page1 := page_addr0(6 downto 0) & page_addr1(7 downto 2);
|
||
|
|
else
|
||
|
|
page1 := page_addr0(7 downto 0) &page_addr1(7 downto 3);
|
||
|
|
end if;
|
||
|
|
end if;
|
||
|
|
--32 mb--
|
||
|
|
if (MAN_ID = X"1F270100") then
|
||
|
|
if (binary_page = '1') then
|
||
|
|
page1 := page_addr0(5 downto 0) & page_addr1(7 downto 1);
|
||
|
|
else
|
||
|
|
page1 := page_addr0(6 downto 0) & page_addr1(7 downto 2);
|
||
|
|
end if;
|
||
|
|
end if;
|
||
|
|
when 12=>
|
||
|
|
---16mb----
|
||
|
|
if (MAN_ID = X"1F260000") then
|
||
|
|
if (binary_page = '1') then
|
||
|
|
page1 := page_addr0(4 downto 0) & page_addr1(7 downto 1);
|
||
|
|
else
|
||
|
|
page1 := page_addr0(5 downto 0) & page_addr1(7 downto 2);
|
||
|
|
end if;
|
||
|
|
end if;
|
||
|
|
--8mb--
|
||
|
|
if (MAN_ID = X"1F250000") then
|
||
|
|
if (binary_page = '1') then
|
||
|
|
page1 := page_addr0(3 downto 0) & page_addr1(7 downto 0);
|
||
|
|
else
|
||
|
|
page1 := page_addr0(4 downto 0) & page_addr1(7 downto 1);
|
||
|
|
end if;
|
||
|
|
end if;
|
||
|
|
---4 mb---
|
||
|
|
when 11=>
|
||
|
|
if (binary_page = '1') then
|
||
|
|
page1 := page_addr0(2 downto 0) & page_addr1(7 downto 0);
|
||
|
|
else
|
||
|
|
page1 := page_addr0(3 downto 0) & page_addr1(7 downto 1);
|
||
|
|
end if;
|
||
|
|
--2mb---
|
||
|
|
when 10=>
|
||
|
|
if (binary_page = '1') then
|
||
|
|
page1 :=page_addr0(1 downto 0) & page_addr1(7 downto 0);
|
||
|
|
else
|
||
|
|
page1 :=page_addr0(2 downto 0) & page_addr1(7 downto 1);
|
||
|
|
end if;
|
||
|
|
--1mb---
|
||
|
|
when 9 =>
|
||
|
|
if (binary_page ='1') then
|
||
|
|
page1 := page_addr0(0) & page_addr1(7 downto 0);
|
||
|
|
else
|
||
|
|
page1 := page_addr0(1 downto 0) & page_addr1(7 downto 1);
|
||
|
|
end if;
|
||
|
|
|
||
|
|
when others =>
|
||
|
|
|
||
|
|
end case;
|
||
|
|
|
||
|
|
return page1;
|
||
|
|
end comp_page_addr;
|
||
|
|
|
||
|
|
----------------function compute_sector addr-------
|
||
|
|
|
||
|
|
function comp_sector_addr ( paddress : in integer range 1 to 14;
|
||
|
|
page1 : in std_logic_vector((P_ADDRESS(device))-1 DOWNTO 0)
|
||
|
|
--signal sector : in std_logic_vector((S_ADDRESS(device))-1 DOWNTO 0);
|
||
|
|
) return std_logic_vector is
|
||
|
|
variable sector1 : std_logic_vector((S_ADDRESS(device))-1 DOWNTO 0);
|
||
|
|
begin
|
||
|
|
|
||
|
|
|
||
|
|
sector1 := page1(P_ADDRESS(device)-1 downto P_ADDRESS(device)-S_ADDRESS(device));
|
||
|
|
|
||
|
|
return sector1;
|
||
|
|
end comp_sector_addr;
|
||
|
|
|
||
|
|
procedure compute_sector_address
|
||
|
|
(
|
||
|
|
paddress : in integer range 1 to 14;
|
||
|
|
signal page : in std_logic_vector((P_ADDRESS(device))-1 DOWNTO 0);
|
||
|
|
signal sector : out std_logic_vector((S_ADDRESS(device))-1 downto 0)
|
||
|
|
) is
|
||
|
|
begin
|
||
|
|
sector <= page(P_ADDRESS(device)-1 downto P_ADDRESS(device)-S_ADDRESS(device));
|
||
|
|
|
||
|
|
end compute_sector_address;
|
||
|
|
|
||
|
|
|
||
|
|
----------------------------
|
||
|
|
function comp_byte_addr
|
||
|
|
(baddress : integer range 1 to 11 ;
|
||
|
|
signal page_addr1 : in std_logic_vector( 7 downto 0);
|
||
|
|
signal byte_addr : in std_logic_vector( 7 downto 0);
|
||
|
|
signal binary_page : in std_logic
|
||
|
|
) return std_logic_vector is
|
||
|
|
variable byte : std_logic_vector((b_address(device,binary_page))-1 DOWNTO 0);
|
||
|
|
begin
|
||
|
|
report " entered into comp_byte_addr" ;
|
||
|
|
case(baddress)is
|
||
|
|
when 11 =>
|
||
|
|
byte := page_addr1(2 downto 0) & byte_addr ; --b"00000000" ;
|
||
|
|
when 10 =>
|
||
|
|
byte := page_addr1(1 downto 0) & byte_addr ; --b"00000000" ;
|
||
|
|
when 9 =>
|
||
|
|
|
||
|
|
byte := page_addr1(0) & byte_addr ; --b"00000000" ;
|
||
|
|
when others=>
|
||
|
|
|
||
|
|
byte :=byte_addr ;
|
||
|
|
end case;
|
||
|
|
|
||
|
|
return byte;
|
||
|
|
end comp_byte_addr;
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
procedure compute_address
|
||
|
|
( page : in std_logic_vector((P_ADDRESS(device))-1 DOWNTO 0);
|
||
|
|
page_size : in integer range 1 to 1056;
|
||
|
|
byte : in std_logic_vector((b_address(device,binary_page))-1 DOWNTO 0);
|
||
|
|
page_boundary_low : out integer;
|
||
|
|
page_boundary_high : out integer;
|
||
|
|
current_address : out integer;
|
||
|
|
mem_no : out integer;
|
||
|
|
signal binary_page : in std_logic
|
||
|
|
) is
|
||
|
|
|
||
|
|
variable temp_low : integer ;
|
||
|
|
begin
|
||
|
|
report "entered into compute_address";
|
||
|
|
|
||
|
|
temp_low := (conv_integer(page) * pagesize(device,binary_page));
|
||
|
|
page_boundary_low := temp_low;
|
||
|
|
page_boundary_high := temp_low + (pagesize(device,binary_page) - 1);
|
||
|
|
report "entered into byte";
|
||
|
|
current_address := temp_low + conv_integer(byte);
|
||
|
|
--memno 10 is for memory access---
|
||
|
|
mem_no := 10;
|
||
|
|
|
||
|
|
end compute_address;
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
procedure read_out
|
||
|
|
(signal SCK,CSB : in std_logic;
|
||
|
|
page_boundary_low : in integer;
|
||
|
|
page_boundary_high :in integer;
|
||
|
|
current_address : inout integer;
|
||
|
|
mem_no : in integer;
|
||
|
|
signal buf1 : in buffer1;
|
||
|
|
signal buf2 : in buffer2;
|
||
|
|
signal memory : in memtype;
|
||
|
|
--signal temp_reg1 :inout std_logic_vector(7 downto 0);
|
||
|
|
signal so_reg : out std_logic;
|
||
|
|
signal so_on1 : out std_logic
|
||
|
|
)
|
||
|
|
is
|
||
|
|
variable t_reg : std_logic_vector(7 downto 0);
|
||
|
|
begin
|
||
|
|
|
||
|
|
report " Read loop entered ";
|
||
|
|
if(mem_no=1)then
|
||
|
|
t_reg := to_stdlogicvector(buf1(current_address));
|
||
|
|
elsif(mem_no=2)then
|
||
|
|
t_reg := to_stdlogicvector(buf2(current_address));
|
||
|
|
elsif(mem_no=10)then
|
||
|
|
t_reg := to_stdlogicvector(memory(current_address));
|
||
|
|
else
|
||
|
|
end if;
|
||
|
|
|
||
|
|
read_loop : loop
|
||
|
|
for i in 7 downto 0 loop
|
||
|
|
wait until (SCK'EVENT and SCK ='0') or (CSB'EVENT and CSB='1');
|
||
|
|
report " entered into for loop of read_out";
|
||
|
|
exit read_loop when (CSB='1' ) ;
|
||
|
|
wait for Tv;
|
||
|
|
SO_reg <= t_reg(i);
|
||
|
|
so_on1 <= '1';
|
||
|
|
end loop;
|
||
|
|
|
||
|
|
current_address := current_address + 1;
|
||
|
|
report "comes out from for loop of read_out--------------------";
|
||
|
|
if(current_address > page_boundary_high) then
|
||
|
|
current_address := page_boundary_low;
|
||
|
|
end if;
|
||
|
|
if(mem_no = 1)then
|
||
|
|
t_reg := to_stdlogicvector(buf1(current_address));
|
||
|
|
elsif (mem_no = 2) then
|
||
|
|
t_reg := to_stdlogicvector(buf2(current_address));
|
||
|
|
elsif (mem_no = 10) then
|
||
|
|
t_reg := to_stdlogicvector(memory(current_address));
|
||
|
|
end if;
|
||
|
|
end loop;
|
||
|
|
wait for Tdis;
|
||
|
|
SO_reg <= '0';
|
||
|
|
so_on1 <= '0';
|
||
|
|
|
||
|
|
report " Read loop exited";
|
||
|
|
end read_out;
|
||
|
|
|
||
|
|
|
||
|
|
procedure read_out_x
|
||
|
|
(signal CSB,sck : in std_logic;
|
||
|
|
signal so_reg,so_on1 : out std_logic
|
||
|
|
) is
|
||
|
|
begin
|
||
|
|
report " Readx loop entered ";
|
||
|
|
so_on1 <='0';
|
||
|
|
read_loopx : loop
|
||
|
|
wait until (SCK'EVENT and SCK ='0') or (CSB'EVENT and CSB='1');
|
||
|
|
exit read_loopx when (CSB='1' ) ;
|
||
|
|
wait for Tv;
|
||
|
|
SO_reg <= 'X';
|
||
|
|
so_on1 <= '1';
|
||
|
|
end loop;
|
||
|
|
wait for Tdis;
|
||
|
|
SO_reg <= '0';
|
||
|
|
so_on1 <= '0';
|
||
|
|
|
||
|
|
report " Readx loop exited";
|
||
|
|
end read_out_x;
|
||
|
|
|
||
|
|
|
||
|
|
procedure read_out_array
|
||
|
|
(signal SCK,CSB : in std_logic;
|
||
|
|
page_size : in integer range 1 to 1056;
|
||
|
|
mem_size : in integer range 1 to 69206016;
|
||
|
|
page_boundary_low : in integer;
|
||
|
|
page_boundary_high :in integer;
|
||
|
|
current_address : in integer;
|
||
|
|
signal memory : in memtype;
|
||
|
|
signal so_reg : out std_logic;
|
||
|
|
signal so_on1 : out std_logic
|
||
|
|
)
|
||
|
|
is
|
||
|
|
variable t_reg_array : std_logic_vector(7 downto 0);
|
||
|
|
variable temp_high : integer;
|
||
|
|
variable temp_low : integer;
|
||
|
|
variable temp_add : integer;
|
||
|
|
|
||
|
|
|
||
|
|
begin
|
||
|
|
|
||
|
|
report " Read_array loop entered ";
|
||
|
|
|
||
|
|
temp_high := page_boundary_high;
|
||
|
|
temp_low := page_boundary_low;
|
||
|
|
temp_add := current_address;
|
||
|
|
|
||
|
|
t_reg_array := to_stdlogicvector(memory(temp_add));
|
||
|
|
|
||
|
|
read_array_loop : loop
|
||
|
|
for i in 7 downto 0 loop
|
||
|
|
wait until (SCK'EVENT and SCK ='0') or (CSB'EVENT and CSB='1');
|
||
|
|
exit read_array_loop when (CSB='1' ) ;
|
||
|
|
wait for Tv;
|
||
|
|
SO_reg <= t_reg_array(i);
|
||
|
|
so_on1 <= '1';
|
||
|
|
end loop;
|
||
|
|
report"read_array procedure----------------------------------------------------";
|
||
|
|
temp_add := temp_add + 1;
|
||
|
|
if (temp_add >= N)then
|
||
|
|
temp_add := 0; --Note that rollover occurs at end of memory,
|
||
|
|
temp_high := pagesize(device,binary_page) - 1; -- and not at the end of the page
|
||
|
|
temp_low := 0;
|
||
|
|
end if;
|
||
|
|
|
||
|
|
if (temp_add > temp_high) then-- going to next page
|
||
|
|
temp_high := temp_high + pagesize(device,binary_page);
|
||
|
|
temp_low := temp_low + pagesize(device,binary_page);
|
||
|
|
end if;
|
||
|
|
t_reg_array := to_stdlogicvector(memory(temp_add));
|
||
|
|
end loop;
|
||
|
|
wait for Tdis;
|
||
|
|
SO_reg <= '0';
|
||
|
|
so_on1 <= '0';
|
||
|
|
|
||
|
|
report " Read_array loop exited ";
|
||
|
|
end read_out_array;
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
procedure transfer_to_buffer
|
||
|
|
(
|
||
|
|
buf_type : in integer;
|
||
|
|
page_boundary_low : in integer;
|
||
|
|
signal memory : in memtype;
|
||
|
|
signal buf1 : inout buffer1;
|
||
|
|
signal buf2 : inout buffer2
|
||
|
|
) is
|
||
|
|
begin
|
||
|
|
report " transfer to buffer entered ";
|
||
|
|
if (buf_type = 1) then
|
||
|
|
for i in 0 to pagesize(device,binary_page)-1 LOOP
|
||
|
|
buf1(i) <= memory(page_boundary_low + i);
|
||
|
|
end loop;
|
||
|
|
elsif (buf_type = 2) then
|
||
|
|
for i in 0 to pagesize(device,binary_page)-1 loop
|
||
|
|
buf2(i) <= memory(page_boundary_low + i);
|
||
|
|
end loop;
|
||
|
|
else
|
||
|
|
report"Int Error 2. This message should never appear";
|
||
|
|
|
||
|
|
|
||
|
|
end if;
|
||
|
|
report " transfer to buffer exited ";
|
||
|
|
end transfer_to_buffer;
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
procedure compare_with_buffer
|
||
|
|
( buf_type : in integer;
|
||
|
|
page_boundary_low : in integer;
|
||
|
|
signal memory : in memtype;
|
||
|
|
signal buf1 : in buffer1;
|
||
|
|
signal buf2 : in buffer2;
|
||
|
|
signal status : out std_logic
|
||
|
|
) is
|
||
|
|
|
||
|
|
variable tmp1,tmp2 : bit_vector(7 downto 0);
|
||
|
|
begin
|
||
|
|
report " compare with buf entered ";
|
||
|
|
status <='0';
|
||
|
|
if(buf_type = 1) then
|
||
|
|
for i in 0 to pagesize(device,binary_page)-1 loop
|
||
|
|
tmp1 := memory(page_boundary_low + i);
|
||
|
|
tmp2 := buf1(i);
|
||
|
|
for k in 0 to 7 loop
|
||
|
|
if(tmp1(k) /= tmp2(k)) then
|
||
|
|
status <= '1';
|
||
|
|
exit;
|
||
|
|
end if;
|
||
|
|
end loop;
|
||
|
|
end loop;
|
||
|
|
elsif (buf_type = 2) then
|
||
|
|
|
||
|
|
for i in 0 to pagesize(device,binary_page)-1 loop
|
||
|
|
tmp1 := memory(page_boundary_low + i);
|
||
|
|
tmp2 := buf2(i);
|
||
|
|
for k in 0 to 7 loop
|
||
|
|
if(tmp1(k) /= tmp2(k)) then
|
||
|
|
status <= '1';
|
||
|
|
exit;
|
||
|
|
end if;
|
||
|
|
end loop;
|
||
|
|
end loop;
|
||
|
|
else
|
||
|
|
|
||
|
|
report"Int error 3. This message should never appear";
|
||
|
|
|
||
|
|
end if;
|
||
|
|
report " compare with exited ";
|
||
|
|
end compare_with_buffer;
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
-----------write_data------------
|
||
|
|
procedure write_data
|
||
|
|
( current_address : inout integer;
|
||
|
|
page_boundary_low : in integer;
|
||
|
|
page_boundary_high : in integer;
|
||
|
|
signal buf1 : inout buffer1;
|
||
|
|
signal buf2 : inout buffer2;
|
||
|
|
buf_type : in integer;
|
||
|
|
signal CSB,SCK,SI : in std_logic
|
||
|
|
) is
|
||
|
|
|
||
|
|
variable buf_temp_reg : std_logic_vector(7 downto 0);
|
||
|
|
variable temp :std_logic := '0';
|
||
|
|
begin
|
||
|
|
|
||
|
|
report "first time entering " ;
|
||
|
|
|
||
|
|
write_loop : loop
|
||
|
|
|
||
|
|
if (CSB = '0') then
|
||
|
|
|
||
|
|
for i in 7 downto 0 loop
|
||
|
|
wait until (SCK'EVENT and SCK ='1') or (CSB'EVENT and CSB='1');
|
||
|
|
exit write_loop when (CSB='1' ) ;
|
||
|
|
buf_temp_reg(i):=SI;
|
||
|
|
end loop;
|
||
|
|
|
||
|
|
|
||
|
|
if (buf_type=1) then
|
||
|
|
buf1(current_address)<= To_bitvector(buf_temp_reg,'0');
|
||
|
|
elsif(buf_type=2) then
|
||
|
|
buf2(current_address)<= To_bitvector(buf_temp_reg,'0');
|
||
|
|
end if;
|
||
|
|
current_address := current_address + 1;
|
||
|
|
wait for 1 ps;
|
||
|
|
if (current_address > page_boundary_high) then
|
||
|
|
current_address := page_boundary_low;
|
||
|
|
wait for 1 ps;
|
||
|
|
end if;
|
||
|
|
end if;
|
||
|
|
|
||
|
|
end loop;
|
||
|
|
|
||
|
|
|
||
|
|
report " loop exited";
|
||
|
|
|
||
|
|
end write_data;
|
||
|
|
|
||
|
|
------------------check_protection-------------
|
||
|
|
|
||
|
|
|
||
|
|
function check_protect(
|
||
|
|
page1 : in std_logic_vector((P_ADDRESS(device))-1 DOWNTO 0);
|
||
|
|
page_per_sector : in integer;
|
||
|
|
signal prot_status : in std_logic_vector(sec_tors(device) downto 0);
|
||
|
|
sector : in std_logic_vector(s_address(device)-1 downto 0);
|
||
|
|
WPB,soft_prot_enabled : in std_logic
|
||
|
|
) return std_logic is
|
||
|
|
|
||
|
|
variable protecteds : std_logic;
|
||
|
|
begin
|
||
|
|
protecteds := '0';
|
||
|
|
|
||
|
|
if ((WPB = '0') or (soft_prot_enabled ='1')) then
|
||
|
|
if (conv_integer(page1) < 8) then
|
||
|
|
protecteds := prot_status(0);
|
||
|
|
elsif (page1 < PAGE_PER_SECTOR) then
|
||
|
|
protecteds := prot_status(1);
|
||
|
|
else
|
||
|
|
protecteds := prot_status(conv_integer(sector) + 1);
|
||
|
|
end if;
|
||
|
|
end if;
|
||
|
|
|
||
|
|
return protecteds;
|
||
|
|
end check_protect;
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
--------------check lock down---------
|
||
|
|
|
||
|
|
|
||
|
|
function check_lockd (
|
||
|
|
page1 : in std_logic_vector((P_ADDRESS(device))-1 DOWNTO 0);
|
||
|
|
page_per_sector : in integer;
|
||
|
|
signal lock_status : in std_logic_vector(sec_tors(device) downto 0);
|
||
|
|
sector : in std_logic_vector(s_address(device)-1 downto 0)
|
||
|
|
) return std_logic is
|
||
|
|
variable locked : std_logic;
|
||
|
|
begin
|
||
|
|
locked :='0';
|
||
|
|
|
||
|
|
if (page1 < 8) then
|
||
|
|
locked := lock_status(0);
|
||
|
|
elsif (page1 < PAGE_PER_SECTOR) then
|
||
|
|
locked := lock_status(1);
|
||
|
|
else
|
||
|
|
locked := lock_status(conv_integer(sector)+1);
|
||
|
|
end if;
|
||
|
|
return locked;
|
||
|
|
end check_lockd;
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
----------write_to_memory----------
|
||
|
|
|
||
|
|
|
||
|
|
procedure write_to_memory
|
||
|
|
( buf_type : in integer;
|
||
|
|
page : in std_logic_vector((P_ADDRESS(device))-1 DOWNTO 0);
|
||
|
|
page_size : in integer range 1 to 1056;
|
||
|
|
signal buf1 : in buffer1;
|
||
|
|
signal buf2 : in buffer2;
|
||
|
|
|
||
|
|
page_boundary_low : in integer;
|
||
|
|
signal memory : inout memtype
|
||
|
|
|
||
|
|
) is
|
||
|
|
begin
|
||
|
|
|
||
|
|
report " write to memory entered ";
|
||
|
|
if (buf_type = 1) then
|
||
|
|
for i in 0 to page_size-1 loop
|
||
|
|
memory(page_boundary_low+i) <= buf1(i);
|
||
|
|
end loop;
|
||
|
|
elsif (buf_type = 2) then
|
||
|
|
for i in 0 to page_size-1 loop
|
||
|
|
memory(page_boundary_low+i) <= buf2(i);
|
||
|
|
end loop;
|
||
|
|
end if;
|
||
|
|
|
||
|
|
report " write to memory exited ";
|
||
|
|
end write_to_memory;
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
procedure erase_page
|
||
|
|
(
|
||
|
|
page : in std_logic_vector((P_ADDRESS(device))-1 DOWNTO 0);
|
||
|
|
page_size : in integer range 1 to 1056;
|
||
|
|
page_boundary_low : in integer;
|
||
|
|
signal memory : inout memtype;
|
||
|
|
signal page_status : out std_logic
|
||
|
|
|
||
|
|
) is
|
||
|
|
|
||
|
|
variable buf1 : buffer1;
|
||
|
|
variable buf2 : buffer2;
|
||
|
|
variable mem : memtype;
|
||
|
|
|
||
|
|
begin
|
||
|
|
report " erase page entered ";
|
||
|
|
for i in 0 to pagesize(device,binary_page)-1 loop
|
||
|
|
memory(page_boundary_low + i ) <= (others=>'1');
|
||
|
|
page_status <='0';
|
||
|
|
end loop;
|
||
|
|
report " erase page exited ";
|
||
|
|
end erase_page;
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
----------read_out_reg--------
|
||
|
|
procedure read_out_reg
|
||
|
|
( reg_type : in integer;
|
||
|
|
add : in integer;
|
||
|
|
high : in integer;
|
||
|
|
signal prot_reg : in prot_type ;
|
||
|
|
signal lock_reg : in lock_type ;
|
||
|
|
signal security_reg : in security_type ;
|
||
|
|
signal CSB,SCK : in std_logic;
|
||
|
|
signal so_reg : out std_logic;
|
||
|
|
signal so_on1 : out std_logic
|
||
|
|
|
||
|
|
) is
|
||
|
|
variable temp_add : integer;
|
||
|
|
variable t_reg1 : std_logic_vector(7 downto 0);
|
||
|
|
begin
|
||
|
|
report " Read out reg loop entered ";
|
||
|
|
temp_add := add;
|
||
|
|
if( reg_type= 21)then
|
||
|
|
t_reg1 := to_stdlogicvector(prot_reg(temp_add));
|
||
|
|
elsif(reg_type= 22)then
|
||
|
|
t_reg1 := to_stdlogicvector(lock_reg(temp_add));
|
||
|
|
elsif(reg_type= 23)then
|
||
|
|
t_reg1 := to_stdlogicvector(security_reg(temp_add));
|
||
|
|
end if;
|
||
|
|
|
||
|
|
|
||
|
|
read_out_reg_loop : loop
|
||
|
|
for i in 7 downto 0 loop
|
||
|
|
wait until (SCK'EVENT and SCK ='0') or (CSB'EVENT and CSB='1');
|
||
|
|
exit read_out_reg_loop when (CSB='1' ) ;
|
||
|
|
wait for Tv;
|
||
|
|
so_reg <= t_reg1(i);
|
||
|
|
so_on1 <= '1';
|
||
|
|
end loop;
|
||
|
|
temp_add := temp_add + 1;
|
||
|
|
if ( temp_add > high)then
|
||
|
|
t_reg1 := (others => 'X' );
|
||
|
|
else
|
||
|
|
if (reg_type=21) then
|
||
|
|
t_reg1 := to_stdlogicvector(prot_reg(temp_add));
|
||
|
|
elsif (reg_type=22) then
|
||
|
|
t_reg1 := to_stdlogicvector(lock_reg(temp_add));
|
||
|
|
elsif (reg_type=23) then
|
||
|
|
if (temp_add < 64) then
|
||
|
|
t_reg1 := to_stdlogicvector(security_reg(temp_add));
|
||
|
|
else
|
||
|
|
t_reg1 := to_stdlogicvector(factory_reg(temp_add-64));
|
||
|
|
end if;
|
||
|
|
end if;
|
||
|
|
end if;
|
||
|
|
end loop;
|
||
|
|
wait for Tdis;
|
||
|
|
so_reg <= '0';
|
||
|
|
so_on1 <= '0';
|
||
|
|
report " Read out reg loop exited ";
|
||
|
|
end read_out_reg;
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
function getbyte (
|
||
|
|
signal IP : in bit_vector(511 downto 0);
|
||
|
|
byte_num : in integer
|
||
|
|
) return bit_vector is
|
||
|
|
|
||
|
|
variable temp : bit_vector( 7 downto 0);
|
||
|
|
begin
|
||
|
|
|
||
|
|
for i in 0 to 7 loop
|
||
|
|
report"entering into getbyte";
|
||
|
|
temp(i) := IP((byte_num-1)*8+i);
|
||
|
|
end loop;
|
||
|
|
report"getbyte exited";
|
||
|
|
return temp;
|
||
|
|
|
||
|
|
end getbyte;
|
||
|
|
|
||
|
|
--******************************************---
|
||
|
|
--******************************************--
|
||
|
|
------shared variable declarations-----------
|
||
|
|
|
||
|
|
shared variable buf_temp_reg1 : std_logic_vector(7 downto 0);
|
||
|
|
shared variable message : string(1 to 21);
|
||
|
|
shared variable message2 : string(1 to 30);
|
||
|
|
shared variable current_address : integer;
|
||
|
|
shared variable page_boundary_low : integer;
|
||
|
|
shared variable page_boundary_high : integer;
|
||
|
|
shared variable mem_no : integer;
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
signal temp_prot_status_program : bit_vector(sec_tors(device)-2 downto 0);
|
||
|
|
signal temp_reg1 : std_logic_vector(7 downto 0);
|
||
|
|
|
||
|
|
signal reset_sig : std_logic:= '0';
|
||
|
|
signal skip : std_logic := '1';
|
||
|
|
signal skip_be : std_logic := '0';
|
||
|
|
signal skip_end : std_logic := '0';
|
||
|
|
signal opcode_temp : std_logic_vector(7 downto 0) := "00000000";
|
||
|
|
signal page_addr0 : std_logic_vector(7 downto 0) := "00000000";
|
||
|
|
signal page_addr1 : std_logic_vector(7 downto 0) := "00000000";
|
||
|
|
signal byte_addr : std_logic_vector(7 downto 0) := "00000000";
|
||
|
|
signal t : std_logic_vector(31 downto 0) := "00000000000000000000000000000000";
|
||
|
|
signal prot_temp_reg : std_logic_vector(7 downto 0) ;
|
||
|
|
signal lock_temp_reg : std_logic_vector(7 downto 0) ;
|
||
|
|
signal rd_data1 : std_logic_vector(7 downto 0);
|
||
|
|
signal less_than_60mhz : std_logic:='0';
|
||
|
|
|
||
|
|
signal buffer1read : std_logic:='0';
|
||
|
|
|
||
|
|
signal oPC7 : std_logic;
|
||
|
|
|
||
|
|
signal arr_rd_dummybyte : integer := 0;
|
||
|
|
signal buff_rd_dummybyte : integer:= 0;
|
||
|
|
|
||
|
|
signal RDPD : std_logic :='0';
|
||
|
|
signal EDPD : std_logic :='0';
|
||
|
|
signal MMPR : std_logic:='0';
|
||
|
|
|
||
|
|
signal updating_buffer1 : std_logic:='0';
|
||
|
|
signal updating_buffer2 : std_logic:='0';
|
||
|
|
---------------UPDATING MEMORY-----------
|
||
|
|
signal updating_memory : std_logic:='0';
|
||
|
|
|
||
|
|
signal comparing : std_logic:='0';
|
||
|
|
signal erasing_page : std_logic:='0';
|
||
|
|
signal erasing_block : std_logic:='0';
|
||
|
|
signal erasing_sector : std_logic:='0';
|
||
|
|
signal erasing_chip : std_logic:='0';
|
||
|
|
signal fast_mode : std_logic:='0';
|
||
|
|
signal IntCSb : std_logic ;
|
||
|
|
constant valid : Boolean := TRUE ;
|
||
|
|
signal MIR : std_logic :='0';
|
||
|
|
signal SRR : std_logic:='0';
|
||
|
|
signal mem_initialized : std_logic;
|
||
|
|
signal deep_power_down : std_logic := '0';
|
||
|
|
signal SR : std_logic:= '0';
|
||
|
|
signal RDYBSY_reg : std_logic :='1';
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
signal foreground_op_enable : std_logic :='0';
|
||
|
|
signal background_op_enable : std_logic:='0';
|
||
|
|
|
||
|
|
signal status_read : std_logic :='0';
|
||
|
|
signal so_reg : std_logic := '1';
|
||
|
|
signal so_on : std_logic :='0';
|
||
|
|
signal so_reg1 : std_logic := '1';
|
||
|
|
signal so_on1 : std_logic :='0';
|
||
|
|
signal so_reg2 : std_logic := '1';
|
||
|
|
signal so_on2 : std_logic :='0';
|
||
|
|
signal so_reg3 : std_logic := '1';
|
||
|
|
signal so_on3 : std_logic :='0';
|
||
|
|
signal status : std_logic_vector(7 downto 0)
|
||
|
|
:= ('1' & '0' & Device_sel3(DEVICE) & Device_sel2(DEVICE) & Device_sel1(DEVICE)& '1' & '0' & '0');
|
||
|
|
|
||
|
|
-----------status signal-------------
|
||
|
|
|
||
|
|
signal status_B1C_s6 : std_logic;
|
||
|
|
signal status_B2C_s6 : std_logic;
|
||
|
|
|
||
|
|
---------
|
||
|
|
signal lock_status : std_logic_vector(sec_tors(device) downto 0);
|
||
|
|
|
||
|
|
--**************** begin of Architecture **************---
|
||
|
|
|
||
|
|
|
||
|
|
begin
|
||
|
|
|
||
|
|
--comparing the opcodes--
|
||
|
|
process(SCK,SI,CSB)
|
||
|
|
begin
|
||
|
|
if ( CSB ='1') then
|
||
|
|
t <="00000000000000000000000000000000";
|
||
|
|
rd_data1 <= "00000000";
|
||
|
|
elsif(SCK = '1' and SCK'event) then
|
||
|
|
|
||
|
|
t(0) <= '1';
|
||
|
|
t(1) <= t(0);
|
||
|
|
t(2) <= t(1);
|
||
|
|
t(3) <= t(2);
|
||
|
|
t(4) <= t(3);
|
||
|
|
t(5) <= t(4);
|
||
|
|
t(6) <= t(5);
|
||
|
|
t(7) <= t(6); -- t(6) == 1 and t(7) ==0 opcode
|
||
|
|
t(8) <= t(7);
|
||
|
|
t(9) <= t(8);
|
||
|
|
t(10) <= t(9);
|
||
|
|
t(11) <= t(10);
|
||
|
|
t(12) <= t(11);
|
||
|
|
t(13) <= t(12);
|
||
|
|
t(14) <= t(13);
|
||
|
|
t(15) <= t(14); -- t(14) == 1 and t(15) ==0 page address
|
||
|
|
t(16) <= t(15);
|
||
|
|
t(17) <= t(16);
|
||
|
|
t(18) <= t(17);
|
||
|
|
t(19) <= t(18);
|
||
|
|
t(20) <= t(19);
|
||
|
|
t(21) <= t(20);
|
||
|
|
t(22) <= t(21);
|
||
|
|
t(23) <= t(22); -- t(22) == 1 and t(23) ==0 page address
|
||
|
|
t(24) <= t(23);
|
||
|
|
t(25) <= t(24);
|
||
|
|
t(26) <= t(25);
|
||
|
|
t(27) <= t(26);
|
||
|
|
t(28) <= t(27);
|
||
|
|
t(29) <= t(28);
|
||
|
|
t(30) <= t(29);
|
||
|
|
t(31) <= t(30); -- t(30) == 1 and t(31) == 0 byte address
|
||
|
|
rd_data1(0) <= SI;
|
||
|
|
rd_data1(1) <= rd_data1(0);
|
||
|
|
rd_data1(2) <= rd_data1(1);
|
||
|
|
rd_data1(3) <= rd_data1(2);
|
||
|
|
rd_data1(4) <= rd_data1(3);
|
||
|
|
rd_data1(5) <= rd_data1(4);
|
||
|
|
rd_data1(6) <= rd_data1(5);
|
||
|
|
rd_data1(7) <= rd_data1(6);
|
||
|
|
|
||
|
|
end if;
|
||
|
|
end process ;
|
||
|
|
|
||
|
|
opcode_temp <= rd_data1(6) & rd_data1(5) & rd_data1(4) & rd_data1(3) & rd_data1(2) & rd_data1(1) & rd_data1(0) & SI ;
|
||
|
|
process(SCK,opcode_temp, t)
|
||
|
|
begin
|
||
|
|
if (CSB = '1' ) then
|
||
|
|
page_addr0 <= "00000000";
|
||
|
|
page_addr1 <= "00000000";
|
||
|
|
byte_addr <= "00000000";
|
||
|
|
|
||
|
|
elsif ((SCK = '1' and SCK'event)) then
|
||
|
|
if (t(14) = '1' and t(15) = '0') then
|
||
|
|
page_addr0 <= opcode_temp;
|
||
|
|
end if;
|
||
|
|
if (t(22) = '1' and t(23) = '0') then
|
||
|
|
page_addr1 <= opcode_temp;
|
||
|
|
end if;
|
||
|
|
if (t(30) = '1' and t(31) = '0') then
|
||
|
|
byte_addr <= opcode_temp;
|
||
|
|
end if;
|
||
|
|
end if;
|
||
|
|
end process;
|
||
|
|
|
||
|
|
|
||
|
|
process(SCK,opcode_temp, t)
|
||
|
|
begin
|
||
|
|
if (CSB = '1') then
|
||
|
|
skip <='1';
|
||
|
|
arr_rd_dummybyte <= 0; --not used in their code
|
||
|
|
buff_rd_dummybyte <= 0;
|
||
|
|
MMPR <='0';
|
||
|
|
MMCAR <='0';
|
||
|
|
EDPD <='0';
|
||
|
|
buffer1read <= '0';--buffer1read legacy command
|
||
|
|
buffer2read <='0';--buffer 2 read for low frequency
|
||
|
|
MMPTB1T <='0'; --Main Memory Page To Buffer 1 Transfer
|
||
|
|
MMPTB2T<='0'; --Main Memory Page To Buffer 2 Transfer
|
||
|
|
MMPTB1C <='0';--Main Memory Page To Buffer 1 Compare
|
||
|
|
MMPTB2C <='0';--Main Memory Page To Buffer 2 Compare
|
||
|
|
B1W <='0'; -- Buffer 1 Write
|
||
|
|
B2W <='0';
|
||
|
|
B1TMMPPWBIE <= '0' ;--Buffer 1 To Main Memory Page Prog With Built-In Erase
|
||
|
|
fast_mode <= '0';
|
||
|
|
B2TMMPPWBIE <= '0';--Buffer 2 To Main Memory Page Prog With Built-In Erase
|
||
|
|
B1TMMPPWOBIE<='0';--Buffer 1 To Main Memory Page Prog Without Built-In Erase
|
||
|
|
B2TMMPPWOBIE<='0' ;--Buffer 2 To Main Memory Page Prog Without Built-In Erase
|
||
|
|
PE<='0'; -- Page Erase
|
||
|
|
BE<='0'; -- Block Erase
|
||
|
|
SE <='0'; -- Sector Erase
|
||
|
|
oPC7<='0' ; -- 4-byte command starting with C7
|
||
|
|
MMPPB1<='0'; -- Main Memory Page Prog. Through Buffer 1
|
||
|
|
MMPPB2<='0' ; -- Main Memory Page Prog. Through Buffer 2
|
||
|
|
APRB1<='0'; -- Auto Page Rewrite Through Buffer 1
|
||
|
|
APRB2<='0'; -- Auto Page Rewrite Through Buffer 2
|
||
|
|
SR<='0' ; -- Status Register Read
|
||
|
|
MIR<='0'; -- Manufecturing ID Read
|
||
|
|
oP3D<='0'; -- 4-Byte Opcode Starting From 3d
|
||
|
|
PRR<='0'; -- Protection Register Read
|
||
|
|
LRR<='0'; -- Lock_down Register Read
|
||
|
|
SRR<='0'; -- Security Register Read
|
||
|
|
OP9B<='0'; -- 4-Byte Opcode Starting From 9B
|
||
|
|
RDPD <='0';
|
||
|
|
elsif (SCK = '1' and SCK'event) then
|
||
|
|
if (t(6) = '1' and t(7) = '0' ) then
|
||
|
|
if(foreground_op_enable='0')then
|
||
|
|
message := "opcode is not allowed";
|
||
|
|
elsif (deep_power_down='1') then
|
||
|
|
if (opcode_temp = X"AB") then
|
||
|
|
RDPD <='1';
|
||
|
|
else
|
||
|
|
message := "opcode is not allowed";
|
||
|
|
end if;
|
||
|
|
else
|
||
|
|
case opcode_temp is
|
||
|
|
when X"D2" =>
|
||
|
|
if(RDYBSY_reg='1')then
|
||
|
|
skip <='0';
|
||
|
|
arr_rd_dummybyte <= 4;
|
||
|
|
MMPR <='1';
|
||
|
|
end if;
|
||
|
|
|
||
|
|
when X"52" =>
|
||
|
|
if(RDYBSY_reg='1')then
|
||
|
|
skip <='0';
|
||
|
|
arr_rd_dummybyte <= 4;
|
||
|
|
MMPR <='1';
|
||
|
|
end if;
|
||
|
|
|
||
|
|
|
||
|
|
when X"03" =>
|
||
|
|
if(RDYBSY_reg='1')then
|
||
|
|
skip <='0';
|
||
|
|
arr_rd_dummybyte <= 0;
|
||
|
|
MMCAR <='1';
|
||
|
|
end if;
|
||
|
|
when X"0B" =>
|
||
|
|
if(RDYBSY_reg='1')then
|
||
|
|
skip <='0';
|
||
|
|
arr_rd_dummybyte <= 1;
|
||
|
|
MMCAR <='1';
|
||
|
|
end if;
|
||
|
|
when X"E8" =>
|
||
|
|
if(RDYBSY_reg='1')then
|
||
|
|
skip <='0';
|
||
|
|
arr_rd_dummybyte <= 4;
|
||
|
|
MMCAR <='1';
|
||
|
|
end if;
|
||
|
|
when X"68" =>
|
||
|
|
if(RDYBSY_reg='1')then
|
||
|
|
skip <='0';
|
||
|
|
arr_rd_dummybyte <= 4;
|
||
|
|
MMCAR <='1';
|
||
|
|
end if;
|
||
|
|
when X"54" =>
|
||
|
|
skip <='0';
|
||
|
|
arr_rd_dummybyte <= 0;
|
||
|
|
buffer1read <= '1';--buffer1read legacy command
|
||
|
|
when X"D1" =>
|
||
|
|
buff_rd_dummybyte <= 0;
|
||
|
|
skip <='0';
|
||
|
|
buffer1read <='1'; --buffer1read with low frequency
|
||
|
|
when X"D4" =>
|
||
|
|
skip <='0';
|
||
|
|
buff_rd_dummybyte <= 1;
|
||
|
|
buffer1read <='1';
|
||
|
|
when X"56" =>
|
||
|
|
buffer2read <='1';
|
||
|
|
when X"D3" =>
|
||
|
|
skip <='0';
|
||
|
|
buffer2read <='1';--buffer 2 read for low frequency
|
||
|
|
buff_rd_dummybyte <= 0;
|
||
|
|
when X"D6" =>
|
||
|
|
skip <='0';
|
||
|
|
buff_rd_dummybyte <= 1 ;
|
||
|
|
buffer2read <= '1' ;
|
||
|
|
when X"53" =>
|
||
|
|
if(background_op_enable='0') then
|
||
|
|
message := "opcode is not allowed";
|
||
|
|
elsif(RDYBSY_reg='0')then
|
||
|
|
message := "opcode is not allowed";
|
||
|
|
else
|
||
|
|
MMPTB1T <='1'; --Main Memory Page To Buffer 1 Transfer
|
||
|
|
end if;
|
||
|
|
when X"55" =>
|
||
|
|
if(background_op_enable='0') then
|
||
|
|
message := "opcode is not allowed";
|
||
|
|
elsif(RDYBSY_reg='0')then
|
||
|
|
message := "opcode is not allowed";
|
||
|
|
else
|
||
|
|
MMPTB2T<='1'; --Main Memory Page To Buffer 2 Transfer
|
||
|
|
end if;
|
||
|
|
when X"60" =>
|
||
|
|
if(background_op_enable='0') then
|
||
|
|
message := "opcode is not allowed";
|
||
|
|
elsif(RDYBSY_reg='0')then
|
||
|
|
message := "opcode is not allowed";
|
||
|
|
else
|
||
|
|
MMPTB1C <='1';--Main Memory Page To Buffer 1 Compare
|
||
|
|
end if;
|
||
|
|
when X"61" =>
|
||
|
|
if(background_op_enable='0') then
|
||
|
|
message := "opcode is not allowed";
|
||
|
|
elsif(RDYBSY_reg='0')then
|
||
|
|
message := "opcode is not allowed";
|
||
|
|
else
|
||
|
|
MMPTB2C <='1';--Main Memory Page To Buffer 2 Compare
|
||
|
|
end if;
|
||
|
|
when X"84" =>
|
||
|
|
B1W <='1'; -- Buffer 1 Write
|
||
|
|
when X"87" =>
|
||
|
|
B2W <='1'; -- Buffer 2 Write
|
||
|
|
when X"83" =>
|
||
|
|
if(background_op_enable='0') then
|
||
|
|
message := "opcode is not allowed";
|
||
|
|
elsif(RDYBSY_reg='0')then
|
||
|
|
message := "opcode is not allowed";
|
||
|
|
else
|
||
|
|
B1TMMPPWBIE <= '1' ;--Buffer 1 To Main Memory Page Prog With Built-In Erase
|
||
|
|
end if;
|
||
|
|
when X"93" =>
|
||
|
|
if(background_op_enable='0') then
|
||
|
|
message := "opcode is not allowed";
|
||
|
|
elsif(RDYBSY_reg='0')then
|
||
|
|
message := "opcode is not allowed";
|
||
|
|
else
|
||
|
|
fast_mode <= '1';
|
||
|
|
B1TMMPPWBIE <= '1'; --Buffer 1 To Main Memory Page Prog With Built-In Erase
|
||
|
|
end if; -- t(14) == 1 and t(15) ==0 page address
|
||
|
|
when X"86" =>
|
||
|
|
if(background_op_enable='0') then
|
||
|
|
message := "opcode is not allowed";
|
||
|
|
elsif(RDYBSY_reg='0')then
|
||
|
|
message := "opcode is not allowed";
|
||
|
|
else
|
||
|
|
B2TMMPPWBIE <= '1';-- t(14) == 1 and t(15) ==0 page address --Buffer 2 To
|
||
|
|
-- Main Memory Page Prog With Built-In Erase
|
||
|
|
end if;
|
||
|
|
when X"96" =>
|
||
|
|
if(background_op_enable='0') then
|
||
|
|
message := "opcode is not allowed";
|
||
|
|
elsif(RDYBSY_reg='0')then
|
||
|
|
message := "opcode is not allowed";
|
||
|
|
else
|
||
|
|
fast_mode <= '1'; -- t(14) == 1 and t(15) ==0 page address
|
||
|
|
B2TMMPPWBIE <='1'; --Buffer 2 To Main Memory Page Prog With Built-In Erase
|
||
|
|
end if;
|
||
|
|
|
||
|
|
when X"88" =>
|
||
|
|
if(background_op_enable='0') then
|
||
|
|
message := "opcode is not allowed";
|
||
|
|
elsif(RDYBSY_reg='0')then
|
||
|
|
message := "opcode is not allowed";
|
||
|
|
else
|
||
|
|
B1TMMPPWOBIE<='1';--- t(14) == 1 and t(15) ==0 page address -Buffer 1 To
|
||
|
|
--Main Memory Page Prog Without Built-In Erase
|
||
|
|
end if;
|
||
|
|
when X"98" =>
|
||
|
|
if(background_op_enable='0') then
|
||
|
|
message := "opcode is not allowed";
|
||
|
|
elsif(RDYBSY_reg='0')then -- t(14) == 1 and t(15) ==0 page address hen
|
||
|
|
message := "opcode is not allowed";
|
||
|
|
else
|
||
|
|
fast_mode <= '1';
|
||
|
|
B1TMMPPWOBIE<='1' ;--Buffer 1 To Main Memory Page Prog Without Built-In Erase
|
||
|
|
-- t(14) == 1 and t(15) ==0 page address -- not in document
|
||
|
|
end if;
|
||
|
|
when X"89" =>
|
||
|
|
if(background_op_enable='0') then
|
||
|
|
message := "opcode is not allowed";
|
||
|
|
elsif(RDYBSY_reg='0')then
|
||
|
|
message := "opcode is not allowed";
|
||
|
|
else
|
||
|
|
fast_mode <= '1';
|
||
|
|
B2TMMPPWOBIE<='1' ;--Buffer 2 To Main Memory Page Prog Without Built-In Erase
|
||
|
|
end if;
|
||
|
|
when X"99" =>
|
||
|
|
if(background_op_enable='0') then
|
||
|
|
message := "opcode is not allowed";
|
||
|
|
elsif(RDYBSY_reg='0')then
|
||
|
|
message := "opcode is not allowed";
|
||
|
|
else
|
||
|
|
B2TMMPPWOBIE<='1';--Buffer 2 To Main Memory Page Prog Without Built-In Erase
|
||
|
|
-- not in document
|
||
|
|
end if;
|
||
|
|
when X"81" =>
|
||
|
|
if(background_op_enable='0') then
|
||
|
|
message := "opcode is not allowed";
|
||
|
|
elsif(RDYBSY_reg='0')then
|
||
|
|
message := "opcode is not allowed";
|
||
|
|
else
|
||
|
|
PE<='1'; -- Page Erase
|
||
|
|
end if;
|
||
|
|
when X"50" =>
|
||
|
|
if(background_op_enable='0') then
|
||
|
|
message := "opcode is not allowed";
|
||
|
|
elsif(RDYBSY_reg='0')then
|
||
|
|
message := "opcode is not allowed";
|
||
|
|
else
|
||
|
|
BE<='1'; -- Block Erase
|
||
|
|
end if;
|
||
|
|
when X"7C" =>
|
||
|
|
if(background_op_enable='0') then
|
||
|
|
message := "opcode is not allowed";
|
||
|
|
elsif(RDYBSY_reg='0')then
|
||
|
|
message := "opcode is not allowed";
|
||
|
|
else
|
||
|
|
SE <='1'; -- Sector Erase
|
||
|
|
end if;
|
||
|
|
when X"C7" =>
|
||
|
|
if(background_op_enable='0') then
|
||
|
|
message := "opcode is not allowed";
|
||
|
|
elsif(RDYBSY_reg='0')then
|
||
|
|
message := "opcode is not allowed";
|
||
|
|
else
|
||
|
|
oPC7<= '1' ; -- 4-byte command starting with C7
|
||
|
|
end if;
|
||
|
|
when X"82" =>
|
||
|
|
if(background_op_enable='0') then
|
||
|
|
message := "opcode is not allowed";
|
||
|
|
elsif(RDYBSY_reg='0')then
|
||
|
|
message := "opcode is not allowed";
|
||
|
|
else
|
||
|
|
MMPPB1<='1'; -- Main Memory Page Prog. Through Buffer 1
|
||
|
|
end if;
|
||
|
|
when X"92" =>
|
||
|
|
if(background_op_enable='0') then
|
||
|
|
message := "opcode is not allowed";
|
||
|
|
elsif(RDYBSY_reg='0')then
|
||
|
|
message := "opcode is not allowed";
|
||
|
|
else
|
||
|
|
fast_mode <= '1';
|
||
|
|
MMPPB1<='1'; -- Main Memory Page Prog. Through Buffer 1
|
||
|
|
|
||
|
|
end if;
|
||
|
|
when X"85" =>
|
||
|
|
if(background_op_enable='0') then
|
||
|
|
message := "opcode is not allowed";
|
||
|
|
elsif(RDYBSY_reg='0')then
|
||
|
|
message := "opcode is not allowed";
|
||
|
|
else
|
||
|
|
MMPPB2<='1' ; -- Main Memory Page Prog. Through Buffer 2
|
||
|
|
end if;
|
||
|
|
when X"95" =>
|
||
|
|
if(background_op_enable='0') then
|
||
|
|
message := "opcode is not allowed";
|
||
|
|
elsif(RDYBSY_reg='0')then
|
||
|
|
message := "opcode is not allowed";
|
||
|
|
else
|
||
|
|
fast_mode <= '1';
|
||
|
|
MMPPB2<='1'; -- Main Memory Page Prog. Through Buffer 2
|
||
|
|
end if;
|
||
|
|
when X"58" =>
|
||
|
|
if(background_op_enable='0') then
|
||
|
|
message := "opcode is not allowed";
|
||
|
|
elsif(RDYBSY_reg='0')then
|
||
|
|
message := "opcode is not allowed";
|
||
|
|
else
|
||
|
|
APRB1<='1'; -- Auto Page Rewrite Through Buffer 1
|
||
|
|
end if;
|
||
|
|
when X"59" =>
|
||
|
|
if(background_op_enable='0') then
|
||
|
|
message := "opcode is not allowed";
|
||
|
|
elsif(RDYBSY_reg='0')then
|
||
|
|
message := "opcode is not allowed";
|
||
|
|
else
|
||
|
|
APRB2<='1'; -- Auto Page Rewrite Through Buffer 2
|
||
|
|
end if;
|
||
|
|
when X"57" =>
|
||
|
|
SR<='1' ; -- Status Register Read
|
||
|
|
|
||
|
|
when X"D7" =>
|
||
|
|
skip <='0';
|
||
|
|
SR<='1'; -- Status Register Read
|
||
|
|
when X"9F" =>
|
||
|
|
skip <='0';
|
||
|
|
MIR<='1'; -- Manufecturing ID Read
|
||
|
|
when X"3D" =>
|
||
|
|
if(background_op_enable='0') then
|
||
|
|
message := "opcode is not allowed";
|
||
|
|
else
|
||
|
|
oP3D<='1'; -- 4-Byte Opcode Starting From 3d
|
||
|
|
end if;
|
||
|
|
when X"32" =>
|
||
|
|
if(RDYBSY_reg='1')then
|
||
|
|
PRR<='1'; -- Protection Register Read
|
||
|
|
end if;
|
||
|
|
when X"35" =>
|
||
|
|
if(RDYBSY_reg='1')then
|
||
|
|
LRR<='1'; -- Lock_down Register Read
|
||
|
|
end if;
|
||
|
|
when X"77" =>
|
||
|
|
if(RDYBSY_reg='1')then
|
||
|
|
SRR<='1'; -- Security Register Read
|
||
|
|
end if;
|
||
|
|
when X"9B" =>
|
||
|
|
if(background_op_enable='0') then
|
||
|
|
message := "opcode is not allowed";
|
||
|
|
else
|
||
|
|
oP9B<='1'; -- 4-Byte Opcode Starting From 9B
|
||
|
|
end if;
|
||
|
|
when X"B9" =>
|
||
|
|
if(background_op_enable='0') then
|
||
|
|
message := "opcode is not allowed";
|
||
|
|
else
|
||
|
|
EDPD<='1'; -- enable deep power down
|
||
|
|
end if;
|
||
|
|
when others =>
|
||
|
|
message := "Unrecognized opcode ";
|
||
|
|
end case;
|
||
|
|
|
||
|
|
end if;
|
||
|
|
|
||
|
|
end if;
|
||
|
|
|
||
|
|
end if;
|
||
|
|
end process;
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
process(SCK,CSB)
|
||
|
|
begin
|
||
|
|
|
||
|
|
if(CSB='0' and CSB'event)then
|
||
|
|
if (SCK = '0') then
|
||
|
|
skip_be <= '1';
|
||
|
|
else
|
||
|
|
skip_be <= '0';
|
||
|
|
end if;
|
||
|
|
end if;
|
||
|
|
end process ;
|
||
|
|
|
||
|
|
skip_end <= skip_be and skip;
|
||
|
|
|
||
|
|
|
||
|
|
background_op_enable <= '1' after tPUW ;
|
||
|
|
|
||
|
|
|
||
|
|
reset_sig <= '0', '1' after 1 ns;
|
||
|
|
|
||
|
|
process
|
||
|
|
|
||
|
|
variable inbuf : line;
|
||
|
|
variable outbuf : line;
|
||
|
|
--file LOAD_FILE1 : text open read_mode is "./memory.txt";
|
||
|
|
file LOAD_FILE1 : text open read_mode is flashmemory;
|
||
|
|
file OUT_FILE : text open write_mode is "./memory_out.txt";
|
||
|
|
variable numword : integer := 0;
|
||
|
|
variable word : string(1 to 8);
|
||
|
|
variable mem : memtype;
|
||
|
|
variable i : integer;
|
||
|
|
variable value : bit_vector(7 downto 0);
|
||
|
|
----------
|
||
|
|
variable inbuf1 : line;
|
||
|
|
--file LOAD_FILE2 : text open read_mode is "protection.txt";
|
||
|
|
--file LOAD_FILE2 : text open read_mode is protection;
|
||
|
|
variable numword1 : integer := 0;
|
||
|
|
variable value1 : bit_vector(7 downto 0);
|
||
|
|
variable protect : prot_type;
|
||
|
|
|
||
|
|
variable jerase : integer;
|
||
|
|
variable temp_prot : bit_vector(sec_tors(device) downto 0);
|
||
|
|
---------------
|
||
|
|
variable inbuf2 : line;
|
||
|
|
variable outbuf12 : line;
|
||
|
|
--file LOAD_FILE3 : text open read_mode is "lockdown.txt";
|
||
|
|
--file LOAD_FILE3 : text open read_mode is lockdown;
|
||
|
|
variable numword2 : integer := 0;
|
||
|
|
variable value2 : bit_vector(7 downto 0);
|
||
|
|
---------------------
|
||
|
|
|
||
|
|
variable inbuf3 : line;
|
||
|
|
--file LOAD_FILE4 : text open read_mode is "factory.txt";
|
||
|
|
--file LOAD_FILE4 : text open read_mode is factory;
|
||
|
|
variable numword3 : integer := 0;
|
||
|
|
variable value3 : bit_vector(7 downto 0);
|
||
|
|
------------------
|
||
|
|
|
||
|
|
variable locked : std_logic:='0';
|
||
|
|
variable protecteds : std_logic:='0';
|
||
|
|
variable MMPPB1_mem_page : std_logic_vector(p_address(device)-1 downto 0);
|
||
|
|
variable MMPPB1_buf_page : std_logic_vector(p_address(device)-1 downto 0);
|
||
|
|
variable MMPPB2_mem_page : std_logic_vector(p_address(device)-1 downto 0);
|
||
|
|
variable MMPPB2_buf_page : std_logic_vector(p_address(device)-1 downto 0);
|
||
|
|
variable temp_lock : bit_vector(sec_tors(device) downto 0);
|
||
|
|
variable temp_lock_reg : lock_type;
|
||
|
|
|
||
|
|
begin
|
||
|
|
if (foreground_op_enable = '0') then ---- Enable foreground op_codes
|
||
|
|
wait on reset_sig ;
|
||
|
|
report " initialization";
|
||
|
|
wait for 1 ps;
|
||
|
|
for i in 0 to (memsize(pagesize(device,binary_page),page_cal(device))-1) loop
|
||
|
|
memory(i) <= (others=>'1');
|
||
|
|
end loop;
|
||
|
|
mem_initialized <= '0';
|
||
|
|
|
||
|
|
wait for 1 ps;
|
||
|
|
|
||
|
|
while not ENDFILE(LOAD_FILE1) loop
|
||
|
|
report " memory initialization";
|
||
|
|
READLINE(LOAD_FILE1,inbuf);
|
||
|
|
hexa_to_bit_vector(inbuf, 8, value);
|
||
|
|
memory(numword) <= value;
|
||
|
|
WRITE(outbuf,memory(numword));
|
||
|
|
WRITELINE(OUT_FILE, outbuf);
|
||
|
|
numword := numword + 1;
|
||
|
|
if(numword = (N-1)) then
|
||
|
|
|
||
|
|
exit;
|
||
|
|
end if;
|
||
|
|
mem_initialized <= '1';
|
||
|
|
end loop;
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
wait for 1 ps;
|
||
|
|
|
||
|
|
if (mem_initialized = '1') then
|
||
|
|
for j in 0 to page_cal(device)-1 loop
|
||
|
|
page_status(j) <= '1'; -- memory was initialized, so, Pages are Not Erased.
|
||
|
|
end loop;
|
||
|
|
else
|
||
|
|
for j in 0 to page_cal(device)-1 loop
|
||
|
|
page_status(j) <= '0';
|
||
|
|
end loop;
|
||
|
|
|
||
|
|
end if;
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
wait for 1 ps;
|
||
|
|
------------initialization of protection reg-------------
|
||
|
|
--while not ENDFILE(LOAD_FILE2) loop
|
||
|
|
--report " protection reg initialization";
|
||
|
|
--READLINE(LOAD_FILE2,inbuf1);
|
||
|
|
--hexa_to_bit_vector(inbuf1, 8, value1);
|
||
|
|
--prot_reg(numword1) <= value1;
|
||
|
|
--numword1 := numword1 + 1;
|
||
|
|
--if(numword1 > (p-1)) then
|
||
|
|
--exit;
|
||
|
|
--end if;
|
||
|
|
--end loop;
|
||
|
|
|
||
|
|
|
||
|
|
for i in 0 to SEC_TORS(device)-1 loop
|
||
|
|
report"protection intialization";
|
||
|
|
prot_reg(i) <= getbyte(protection,i+1);
|
||
|
|
report "lockdown initialization";
|
||
|
|
lock_reg(i) <= getbyte(lockdown,i+1);
|
||
|
|
end loop;
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
wait for 1 ps;
|
||
|
|
prot_temp_reg <= To_stdlogicvector(prot_reg(0));
|
||
|
|
|
||
|
|
prot_status(0) <= prot_temp_reg(7) and prot_temp_reg(6);
|
||
|
|
prot_status(1) <= prot_temp_reg(5) and prot_temp_reg(4);
|
||
|
|
for j in 1 to SEC_TORS(device)-1 loop
|
||
|
|
temp_prot(j+1) := prot_reg(j)(0)and prot_reg(j)(1)
|
||
|
|
and prot_reg(j)(2)and prot_reg(j)(3)
|
||
|
|
and prot_reg(j)(4)and prot_reg(j)(5)
|
||
|
|
and prot_reg(j)(6)and prot_reg(j)(7);
|
||
|
|
end loop;
|
||
|
|
|
||
|
|
prot_status <= To_stdlogicvector(temp_prot);
|
||
|
|
|
||
|
|
|
||
|
|
wait for 10 ps;
|
||
|
|
-------------initialization of lock reg-----------
|
||
|
|
|
||
|
|
--while not ENDFILE(LOAD_FILE3) loop
|
||
|
|
--report " lock reg initialization";
|
||
|
|
--READLINE(LOAD_FILE3,inbuf2);
|
||
|
|
--hexa_to_bit_vector(inbuf2, 8, value2);
|
||
|
|
--lock_reg(numword2) <= value2;
|
||
|
|
--numword2 := numword2 + 1;
|
||
|
|
--if(numword2 > (p-1)) then
|
||
|
|
--exit;
|
||
|
|
--end if;
|
||
|
|
--end loop;
|
||
|
|
|
||
|
|
|
||
|
|
wait for 1 ps;
|
||
|
|
lock_temp_reg <= To_stdlogicvector(lock_reg(0));
|
||
|
|
lock_status(0) <= lock_temp_reg(7) and lock_temp_reg(6);
|
||
|
|
lock_status(1) <= lock_temp_reg(5) and lock_temp_reg(4);
|
||
|
|
for j in 1 to SEC_TORS(device)-1 loop
|
||
|
|
temp_lock(j + 1) := lock_reg(j)(0)and lock_reg(j)(1)
|
||
|
|
and lock_reg(j)(2)and lock_reg(j)(3)
|
||
|
|
and lock_reg(j)(4)and lock_reg(j)(5)
|
||
|
|
and lock_reg(j)(6)and lock_reg(j)(7);
|
||
|
|
end loop;
|
||
|
|
|
||
|
|
lock_status <= To_stdlogicvector(temp_lock);
|
||
|
|
---------------initialization of factory reg------------
|
||
|
|
|
||
|
|
wait for 1 ps;
|
||
|
|
--while not ENDFILE(LOAD_FILE4) loop
|
||
|
|
--report " factory initialization";
|
||
|
|
--READLINE(LOAD_FILE4,inbuf3);
|
||
|
|
--hexa_to_bit_vector(inbuf3, 8, value3);
|
||
|
|
--factory_reg(numword3) <= value3;
|
||
|
|
--numword3 := numword3 + 1;
|
||
|
|
--if(numword3 > 64) then
|
||
|
|
--exit;
|
||
|
|
--end if;
|
||
|
|
--end loop;
|
||
|
|
|
||
|
|
for j in 0 to 63 loop
|
||
|
|
|
||
|
|
factory_reg(j) <= getbyte(factory,j+1);
|
||
|
|
security_reg(j) <= getbyte(security,j+1);
|
||
|
|
wait for 1 ps;
|
||
|
|
security_flag <='0';
|
||
|
|
if(security_reg(j) /= X"FF")then
|
||
|
|
security_flag <= '1';
|
||
|
|
end if;
|
||
|
|
end loop;
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
wait for 1 ps;
|
||
|
|
--**************************
|
||
|
|
wait for tVCSL ;
|
||
|
|
foreground_op_enable <= '1' ; ---- Enable foreground op_codes
|
||
|
|
report " forground enable";
|
||
|
|
|
||
|
|
end if;
|
||
|
|
--**************************
|
||
|
|
|
||
|
|
wait on t(31);
|
||
|
|
report " t31 asserted";
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
if(MMPR='1' and t(31) = '1')then
|
||
|
|
|
||
|
|
report "entered into MMPR ";
|
||
|
|
message := "opcodeFis not allowed";
|
||
|
|
if (Rapid_interface = false and fsck > 50) then
|
||
|
|
report "WARNING: Frequency should be less than 50MHz for SPI interface type . Main Memory Page Read is not allowed";
|
||
|
|
end if;
|
||
|
|
compute_address(comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device)),pagesize(device,binary_page),
|
||
|
|
comp_byte_addr(b_address(device,binary_page),page_addr1,byte_addr,binary_page),
|
||
|
|
page_boundary_low,page_boundary_high,
|
||
|
|
current_address,mem_no,binary_page);
|
||
|
|
-- pass by 32 cycles or 4 bytes in the case of serial interface
|
||
|
|
wait for (Twl + Twl ) * 32;
|
||
|
|
if (Rapid_interface = false and fsck > 50) then
|
||
|
|
read_out_x(CSB,SCK,so_reg,so_on) ;
|
||
|
|
else
|
||
|
|
|
||
|
|
read_out(SCK,CSB,page_boundary_low,page_boundary_high,current_address,mem_no,tbuffer1,
|
||
|
|
tbuffer2,memory,so_reg,so_on);
|
||
|
|
end if;
|
||
|
|
|
||
|
|
report "MMPR is exited ";
|
||
|
|
elsif(MMCAR='1' and t(31) = '1')then
|
||
|
|
report "entered into MMCAR ";
|
||
|
|
|
||
|
|
if ((Rapid_interface = false) and (fSCK > 50) and (arr_rd_dummybyte /= 0)) then
|
||
|
|
report"WARNING: Frequency should be less than 50MHz for SPI interface type . Main Memory Page Read is not allowed";
|
||
|
|
|
||
|
|
end if;
|
||
|
|
compute_address(comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device)),pagesize(device,binary_page),
|
||
|
|
comp_byte_addr(b_address(device,binary_page),page_addr1,byte_addr,binary_page),
|
||
|
|
page_boundary_low,page_boundary_high,
|
||
|
|
current_address,mem_no,binary_page);
|
||
|
|
|
||
|
|
|
||
|
|
if (((arr_rd_dummybyte = 0) and (fSCK >= 20)) or ((Rapid_interface = false) and (fSCK > 50) and (arr_rd_dummybyte/= 0)))then
|
||
|
|
read_out_x(CSB,SCK,so_reg,so_on) ;
|
||
|
|
elsif(arr_rd_dummybyte = 1) then
|
||
|
|
wait for (Twl + Twh ) * 8;
|
||
|
|
read_out_array(SCK,CSB,pagesize(device,binary_page),memsize(pagesize(device,binary_page),page_cal(device)),page_boundary_low,
|
||
|
|
page_boundary_high,current_address,memory,so_reg,so_on);
|
||
|
|
|
||
|
|
else
|
||
|
|
wait for (Twl + Twh ) * 32;
|
||
|
|
read_out_array(SCK,CSB,pagesize(device,binary_page),memsize(pagesize(device,binary_page),page_cal(device)),page_boundary_low,
|
||
|
|
page_boundary_high,current_address,memory,so_reg,so_on);
|
||
|
|
end if;
|
||
|
|
|
||
|
|
report "MMCAR is exited ";
|
||
|
|
|
||
|
|
elsif(buffer1read='1'and t(31) = '1')then
|
||
|
|
report "entered into buffer1read";
|
||
|
|
if ((Rapid_interface = false) and (fSCK > 50) and (buff_rd_dummybyte /= 0)) then
|
||
|
|
report"WARNING: Frequency should be less than 50MHz for SPI interface type . Buffer1 Read is not allowed";
|
||
|
|
end if;
|
||
|
|
compute_address(comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device)),pagesize(device,binary_page),
|
||
|
|
comp_byte_addr(b_address(device,binary_page),page_addr1,byte_addr,binary_page),
|
||
|
|
page_boundary_low,page_boundary_high, current_address,mem_no,binary_page);
|
||
|
|
|
||
|
|
|
||
|
|
--if(buff_rd_dummybyte = 0 and less_than_33mhz ='0')then
|
||
|
|
if (((buff_rd_dummybyte = 0) and (fSCK >= 20)) or ((Rapid_interface = false) and (fSCK > 50) and (buff_rd_dummybyte/= 0)))then
|
||
|
|
read_out_x(CSB,SCK,so_reg,so_on) ;
|
||
|
|
else
|
||
|
|
-- pass by 8 cycles or one serial byte
|
||
|
|
wait for (Twl + Twh ) * 8;
|
||
|
|
read_out(SCK,CSB,page_boundary_low,page_boundary_high,current_address,1,
|
||
|
|
tbuffer1,tbuffer2,memory,so_reg,so_on);
|
||
|
|
end if;
|
||
|
|
report "buffer1read exited";
|
||
|
|
|
||
|
|
|
||
|
|
elsif(buffer2read='1' and t(31) = '1')then
|
||
|
|
report "entered into buffer2read";
|
||
|
|
if ((Rapid_interface = false) and (fSCK > 50) and (buff_rd_dummybyte /= 0)) then
|
||
|
|
report"WARNING: Frequency should be less than 50MHz for SPI interface type . Buffer1 Read is not allowed";
|
||
|
|
end if;
|
||
|
|
compute_address(comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device)),pagesize(device,binary_page),
|
||
|
|
comp_byte_addr(b_address(device,binary_page),page_addr1,byte_addr,binary_page),
|
||
|
|
page_boundary_low,page_boundary_high, current_address,mem_no,binary_page);
|
||
|
|
|
||
|
|
--if(buff_rd_dummybyte = 0 and less_than_33mhz ='0')then
|
||
|
|
if (((buff_rd_dummybyte = 0) and (fSCK >= 20)) or ((Rapid_interface = false) and (fSCK > 50) and (buff_rd_dummybyte/= 0)))then
|
||
|
|
read_out_x(CSB,SCK,so_reg,so_on) ;
|
||
|
|
else
|
||
|
|
-- pass by 8 cycles
|
||
|
|
wait for (Twl + Twh ) * 8;
|
||
|
|
read_out(SCK,CSB,page_boundary_low,page_boundary_high,current_address,2,tbuffer1,
|
||
|
|
tbuffer2,memory,so_reg,so_on);
|
||
|
|
end if;
|
||
|
|
report "buffer2read exited";
|
||
|
|
|
||
|
|
elsif(MMPTB1T='1'and t(31) = '1')then
|
||
|
|
report" entered into MMPTB1T";
|
||
|
|
compute_address(comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device)),pagesize(device,binary_page),
|
||
|
|
comp_byte_addr(b_address(device,binary_page),page_addr1,byte_addr,binary_page),
|
||
|
|
page_boundary_low,page_boundary_high, current_address,mem_no,binary_page);
|
||
|
|
|
||
|
|
wait until CSB'event and CSB ='1';
|
||
|
|
RDYBSY_reg <= '0'; --device is busy
|
||
|
|
status(7) <= '0';
|
||
|
|
transfer_to_buffer(1, page_boundary_low,memory,tbuffer1,tbuffer2);
|
||
|
|
updating_buffer1 <= '1';
|
||
|
|
|
||
|
|
wait for Txfr ;
|
||
|
|
RDYBSY_reg <= '1'; -- device is now ready
|
||
|
|
status(7) <= '1';
|
||
|
|
updating_buffer1 <= '0';
|
||
|
|
|
||
|
|
report " MMPTB1T exited";
|
||
|
|
|
||
|
|
elsif (MMPTB2T='1'and t(31) = '1')then
|
||
|
|
report" entered into MMPTB2T";
|
||
|
|
compute_address(comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device)),pagesize(device,binary_page),
|
||
|
|
comp_byte_addr(b_address(device,binary_page),page_addr1,byte_addr,binary_page),
|
||
|
|
page_boundary_low,page_boundary_high, current_address,mem_no,binary_page);
|
||
|
|
|
||
|
|
wait until CSB'event and CSB = '1';
|
||
|
|
RDYBSY_reg <= '0'; --device is busy
|
||
|
|
status(7) <= '0';
|
||
|
|
transfer_to_buffer (2, page_boundary_low,memory,tbuffer1,tbuffer2);
|
||
|
|
updating_buffer2 <= '1';
|
||
|
|
|
||
|
|
wait for Txfr;
|
||
|
|
RDYBSY_reg <= '1';-- after tXFR ; -- device is now ready
|
||
|
|
status(7) <= '1';
|
||
|
|
updating_buffer2 <= '0';
|
||
|
|
|
||
|
|
report " MMPTB2T exited";
|
||
|
|
|
||
|
|
elsif(MMPTB1C='1' and t(31) = '1')then
|
||
|
|
report " entered in to MMPTB1C";
|
||
|
|
compute_address(comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device)),pagesize(device,binary_page),
|
||
|
|
comp_byte_addr(b_address(device,binary_page),page_addr1,byte_addr,binary_page),
|
||
|
|
page_boundary_low,page_boundary_high, current_address,mem_no,binary_page);
|
||
|
|
|
||
|
|
wait until CSB'event and CSB = '1';
|
||
|
|
RDYBSY_reg <= '0'; --device is busy
|
||
|
|
status(7) <= '0';
|
||
|
|
compare_with_buffer(1,page_boundary_low,memory,tbuffer1,tbuffer2,status_B1C_s6);
|
||
|
|
comparing <= '1';
|
||
|
|
|
||
|
|
wait for tXFR;
|
||
|
|
RDYBSY_reg <= '1'; -- device is now ready
|
||
|
|
status(7) <= '1';
|
||
|
|
status(6) <= status_B1C_s6;
|
||
|
|
comparing <= '0';
|
||
|
|
report " MMPTB1C is exited";
|
||
|
|
|
||
|
|
elsif(MMPTB2C='1')then
|
||
|
|
report " entered in to MMPTB2C";
|
||
|
|
compute_address(comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device)),pagesize(device,binary_page),
|
||
|
|
comp_byte_addr(b_address(device,binary_page),page_addr1,byte_addr,binary_page),
|
||
|
|
page_boundary_low,page_boundary_high, current_address,mem_no,binary_page);
|
||
|
|
|
||
|
|
wait until CSB'event and CSB = '1';
|
||
|
|
RDYBSY_reg <= '0'; --device is busy
|
||
|
|
status(7) <= '0';
|
||
|
|
compare_with_buffer(2,page_boundary_low,memory,tbuffer1,tbuffer2,status_B2C_s6);
|
||
|
|
comparing <= '1';
|
||
|
|
|
||
|
|
wait for tXFR;
|
||
|
|
RDYBSY_reg <= '1'; -- device is now ready
|
||
|
|
status(7) <= '1';
|
||
|
|
status(6) <= status_B2C_s6;
|
||
|
|
comparing <= '0';
|
||
|
|
report " MMPTB2C is exited";
|
||
|
|
|
||
|
|
elsif(B1W='1' and t(31) = '1')then
|
||
|
|
report "B1write";
|
||
|
|
compute_address(comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device)),pagesize(device,binary_page),
|
||
|
|
comp_byte_addr(b_address(device,binary_page),page_addr1,byte_addr,binary_page),
|
||
|
|
page_boundary_low,page_boundary_high, current_address,mem_no,binary_page);
|
||
|
|
|
||
|
|
write_data(current_address,page_boundary_low,page_boundary_high,tbuffer1,tbuffer2,1,CSB,sck,SI);
|
||
|
|
report "B1write end";
|
||
|
|
|
||
|
|
elsif(B2W='1' and t(31) = '1')then
|
||
|
|
compute_address(comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device)),pagesize(device,binary_page),
|
||
|
|
comp_byte_addr(b_address(device,binary_page),page_addr1,byte_addr,binary_page),
|
||
|
|
page_boundary_low,page_boundary_high, current_address,mem_no,binary_page);
|
||
|
|
report "B2write";
|
||
|
|
write_data(current_address,page_boundary_low,page_boundary_high,tbuffer1,tbuffer2,2,CSB,sck,SI);
|
||
|
|
|
||
|
|
elsif(B1TMMPPWBIE='1'and t(31) = '1')then
|
||
|
|
report "B1TMMPPWBIE";
|
||
|
|
compute_address(comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device)),pagesize(device,binary_page),
|
||
|
|
comp_byte_addr(b_address(device,binary_page),page_addr1,byte_addr,binary_page),
|
||
|
|
page_boundary_low,page_boundary_high, current_address,mem_no,binary_page);
|
||
|
|
|
||
|
|
locked := check_lockd(comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device)),
|
||
|
|
pageper_sector(device),lock_status,comp_sector_addr(p_address(device),comp_page_addr(p_address(device),binary_page,
|
||
|
|
page_addr0,page_addr1,manid(device))));
|
||
|
|
protecteds := check_protect(comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device)),
|
||
|
|
pageper_sector(device),prot_status, comp_sector_addr(p_address(device),comp_page_addr(p_address(device),
|
||
|
|
binary_page,page_addr0,page_addr1,manid(device))), WPB,soft_prot_enabled);
|
||
|
|
|
||
|
|
if(check_lockd(comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device)),
|
||
|
|
pageper_sector(device),lock_status, comp_sector_addr(p_address(device),comp_page_addr(p_address(device),
|
||
|
|
binary_page,page_addr0,page_addr1,manid(device)))) ='0') then
|
||
|
|
|
||
|
|
if(check_protect(comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device)),
|
||
|
|
pageper_sector(device),prot_status, comp_sector_addr(p_address(device),comp_page_addr(p_address(device),
|
||
|
|
binary_page,page_addr0,page_addr1,manid(device))), WPB,soft_prot_enabled) ='0')then
|
||
|
|
|
||
|
|
wait until CSB ='1';
|
||
|
|
RDYBSY_reg <= '0'; -- device is busy
|
||
|
|
status(7) <= '0';
|
||
|
|
write_to_memory(1,comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device)),
|
||
|
|
pagesize(device,binary_page),tbuffer1,tbuffer2,page_boundary_low,memory);
|
||
|
|
|
||
|
|
|
||
|
|
page_status(conv_integer(comp_page_addr(p_address(device),binary_page,
|
||
|
|
page_addr0,page_addr1,manid(device)))) <= '1';
|
||
|
|
|
||
|
|
|
||
|
|
message2 :="weCan write page is not locked";
|
||
|
|
updating_memory <= '1';
|
||
|
|
|
||
|
|
wait for tEP;
|
||
|
|
RDYBSY_reg <= '1'; -- device is now ready
|
||
|
|
status(7) <= '1';
|
||
|
|
updating_memory <= '0';
|
||
|
|
|
||
|
|
else
|
||
|
|
wait until CSB ='1';
|
||
|
|
message2 :="Cannot write page is protecteds";
|
||
|
|
end if;
|
||
|
|
|
||
|
|
else
|
||
|
|
wait until CSB ='1';
|
||
|
|
message2 :=" Cannot write page is Locked ";
|
||
|
|
end if;
|
||
|
|
|
||
|
|
elsif(B2TMMPPWBIE='1'and t(31) = '1')then
|
||
|
|
report "B2TMMPPWBIE";
|
||
|
|
compute_address(comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device)),pagesize(device,binary_page),
|
||
|
|
comp_byte_addr(b_address(device,binary_page),page_addr1,byte_addr,binary_page),
|
||
|
|
page_boundary_low,page_boundary_high,
|
||
|
|
current_address,mem_no,binary_page);
|
||
|
|
|
||
|
|
|
||
|
|
locked := check_lockd(comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device)),
|
||
|
|
pageper_sector(device),lock_status,comp_sector_addr(p_address(device),comp_page_addr(p_address(device),binary_page,
|
||
|
|
page_addr0,page_addr1,manid(device))));
|
||
|
|
|
||
|
|
protecteds := check_protect(comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device)),
|
||
|
|
pageper_sector(device),prot_status, comp_sector_addr(p_address(device),comp_page_addr(p_address(device),
|
||
|
|
binary_page,page_addr0,page_addr1,manid(device))), WPB,soft_prot_enabled);
|
||
|
|
|
||
|
|
|
||
|
|
if(check_lockd(comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device)),
|
||
|
|
pageper_sector(device),lock_status, comp_sector_addr(p_address(device),comp_page_addr(p_address(device),
|
||
|
|
binary_page,page_addr0,page_addr1,manid(device)))) ='0') then
|
||
|
|
if(check_protect(comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device)),
|
||
|
|
pageper_sector(device),prot_status, comp_sector_addr(p_address(device),comp_page_addr(p_address(device),
|
||
|
|
binary_page,page_addr0,page_addr1,manid(device))), WPB,soft_prot_enabled) ='0')then
|
||
|
|
wait until CSB'event and CSB ='1';
|
||
|
|
RDYBSY_reg <= '0'; -- device is busy
|
||
|
|
status(7) <= '0';
|
||
|
|
write_to_memory(2,comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device)),
|
||
|
|
pagesize(device,binary_page),tbuffer1,tbuffer2,page_boundary_low,memory);
|
||
|
|
|
||
|
|
page_status(conv_integer(comp_page_addr(p_address(device),binary_page,
|
||
|
|
page_addr0,page_addr1,manid(device)))) <= '1';
|
||
|
|
updating_memory <= '1';
|
||
|
|
|
||
|
|
wait for tEP;
|
||
|
|
RDYBSY_reg <= '1'; -- device is now ready
|
||
|
|
status(7) <= '1';
|
||
|
|
message2 :="weCan write page is not locked";
|
||
|
|
updating_memory <= '0';
|
||
|
|
else
|
||
|
|
|
||
|
|
wait until CSB'event and CSB ='1';
|
||
|
|
message2 :=" Cannot write page isprotecteds";
|
||
|
|
end if ;
|
||
|
|
else
|
||
|
|
wait until CSB'event and CSB ='1';
|
||
|
|
message2 :=" Cannot write page is Locked ";
|
||
|
|
end if;
|
||
|
|
|
||
|
|
elsif(B1TMMPPWOBIE='1' and t(31) ='1')then
|
||
|
|
report "B1TMMPPW0BIE";
|
||
|
|
|
||
|
|
|
||
|
|
compute_address(comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device)),pagesize(device,binary_page),
|
||
|
|
comp_byte_addr(b_address(device,binary_page),page_addr1,byte_addr,binary_page),
|
||
|
|
page_boundary_low,page_boundary_high,
|
||
|
|
current_address,mem_no,binary_page);
|
||
|
|
|
||
|
|
|
||
|
|
if(check_lockd(comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device)),
|
||
|
|
pageper_sector(device),lock_status,
|
||
|
|
comp_sector_addr(p_address(device),comp_page_addr(p_address(device),binary_page,page_addr0,
|
||
|
|
page_addr1,manid(device)))) ='0') then
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
if(check_protect(comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device)),
|
||
|
|
pageper_sector(device),prot_status,
|
||
|
|
comp_sector_addr(p_address(device),comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device))),
|
||
|
|
WPB,soft_prot_enabled) ='0')then
|
||
|
|
|
||
|
|
wait until CSB'event and CSB = '1';
|
||
|
|
if (page_status(conv_integer(comp_page_addr(p_address(device),binary_page,page_addr0,
|
||
|
|
page_addr1,manid(device)))) = '0') then --page is already erased
|
||
|
|
RDYBSY_reg <= '0'; --device is busy
|
||
|
|
status(7) <= '0';
|
||
|
|
updating_memory <= '1';
|
||
|
|
write_to_memory(1,comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device)),
|
||
|
|
pagesize(device,binary_page),tbuffer1,tbuffer2,page_boundary_low,memory);
|
||
|
|
|
||
|
|
page_status(conv_integer(comp_page_addr(p_address(device),binary_page,
|
||
|
|
page_addr0,page_addr1,manid(device)))) <= '1';
|
||
|
|
|
||
|
|
if (fast_mode = '0') then
|
||
|
|
wait for tP;
|
||
|
|
RDYBSY_reg <= '1';
|
||
|
|
status(7) <= '1';
|
||
|
|
updating_memory <= '0';
|
||
|
|
else
|
||
|
|
wait for tFP;
|
||
|
|
RDYBSY_reg <= '1';
|
||
|
|
status(7) <= '1';
|
||
|
|
updating_memory <= '0';
|
||
|
|
end if;
|
||
|
|
|
||
|
|
else
|
||
|
|
message :="TryingtowriteintoPage";
|
||
|
|
end if;
|
||
|
|
|
||
|
|
else
|
||
|
|
wait until CSB'event and CSB = '1';
|
||
|
|
message2 :=" Cannot write page isprotecteds";
|
||
|
|
end if;
|
||
|
|
|
||
|
|
|
||
|
|
else
|
||
|
|
|
||
|
|
wait until CSB'event and CSB = '1';
|
||
|
|
message2 :=" Cannot write page is Locked ";
|
||
|
|
end if;
|
||
|
|
report "B1TMMPPW0BIE is exited";
|
||
|
|
|
||
|
|
elsif(B2TMMPPWOBIE='1' and t(31) ='1')then
|
||
|
|
report " entered into B2TMMPPW0BIE";
|
||
|
|
|
||
|
|
compute_address(comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device)),
|
||
|
|
pagesize(device,binary_page),comp_byte_addr(b_address(device,binary_page),page_addr1,byte_addr,binary_page),page_boundary_low,page_boundary_high,
|
||
|
|
current_address,mem_no,binary_page);
|
||
|
|
|
||
|
|
|
||
|
|
if(check_lockd(comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device)),
|
||
|
|
pageper_sector(device),lock_status,
|
||
|
|
comp_sector_addr(p_address(device),comp_page_addr(p_address(device),binary_page,page_addr0,
|
||
|
|
page_addr1,manid(device)))) ='0') then
|
||
|
|
|
||
|
|
if(check_protect(comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device)),
|
||
|
|
pageper_sector(device),prot_status,
|
||
|
|
comp_sector_addr(p_address(device),comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device))),
|
||
|
|
WPB,soft_prot_enabled) ='0')then
|
||
|
|
|
||
|
|
wait until CSB'event and CSB = '1';
|
||
|
|
if (page_status(conv_integer(comp_page_addr(p_address(device),binary_page,page_addr0,
|
||
|
|
page_addr1,manid(device)))) = '0') then --page is already erased
|
||
|
|
RDYBSY_reg <= '0'; --device is busy
|
||
|
|
status(7) <= '0';
|
||
|
|
updating_memory <= '1';
|
||
|
|
write_to_memory(2,comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device)),
|
||
|
|
pagesize(device,binary_page),tbuffer1,tbuffer2,page_boundary_low,memory);
|
||
|
|
|
||
|
|
page_status(conv_integer(comp_page_addr(p_address(device),binary_page,
|
||
|
|
page_addr0,page_addr1,manid(device)))) <= '1';
|
||
|
|
|
||
|
|
if (fast_mode = '0') then
|
||
|
|
wait for tP;
|
||
|
|
RDYBSY_reg <= '1';
|
||
|
|
status(7) <= '1';
|
||
|
|
updating_memory <= '0';
|
||
|
|
else
|
||
|
|
wait for tFP;
|
||
|
|
RDYBSY_reg <= '1';
|
||
|
|
status(7) <= '1';
|
||
|
|
updating_memory <= '0';
|
||
|
|
end if;
|
||
|
|
|
||
|
|
else
|
||
|
|
message :="TryingtowriteintoPage";
|
||
|
|
end if;
|
||
|
|
|
||
|
|
else
|
||
|
|
wait until CSB'event and CSB = '1';
|
||
|
|
message2 :=" Cannot write page isprotecteds";
|
||
|
|
end if;
|
||
|
|
|
||
|
|
|
||
|
|
else
|
||
|
|
|
||
|
|
wait until CSB'event and CSB = '1';
|
||
|
|
message2 :=" Cannot write page is Locked ";
|
||
|
|
end if;
|
||
|
|
report "B2TMMPPW0BIE is exited";
|
||
|
|
|
||
|
|
elsif(oP3D ='1' and t(31)='1' and page_addr0 = X"2A" and page_addr1 = X"7F" and byte_addr =X"A9")then
|
||
|
|
report "entered into enable sector protection ";
|
||
|
|
SPE <='1';
|
||
|
|
wait until CSB'event and CSB ='1';
|
||
|
|
soft_prot_enabled <='1';
|
||
|
|
status(1)<='1';
|
||
|
|
SPE <='0';
|
||
|
|
report "enable sector protection is exited";
|
||
|
|
|
||
|
|
elsif(oP3D ='1' and t(31)='1' and page_addr0 = X"2A" and page_addr1 = X"7F" and byte_addr =X"9A")then
|
||
|
|
report "entered into disable sector protection ";
|
||
|
|
SPD <='1';
|
||
|
|
wait until CSB'event and CSB ='1';
|
||
|
|
if(WPB = '1')then
|
||
|
|
soft_prot_enabled <='0';
|
||
|
|
status(1)<='0';
|
||
|
|
end if;
|
||
|
|
SPD <='0';
|
||
|
|
|
||
|
|
elsif(oP3D ='1' and t(31)='1' and page_addr0 = X"2A" and page_addr1 = X"7F" and byte_addr =X"CF")then
|
||
|
|
report "entered into erase sector protection register PRE";
|
||
|
|
PRE <='1';
|
||
|
|
wait until CSB'event and CSB ='1';
|
||
|
|
RDYBSY_reg <='0';--device is busy
|
||
|
|
status(7) <= '0';
|
||
|
|
prot_reg(0) <= (others=>'1');
|
||
|
|
prot_status(0)<='1';
|
||
|
|
prot_status(1)<='1';
|
||
|
|
wait for 1 ps;
|
||
|
|
for j in 1 to sec_tors(device)-1 loop
|
||
|
|
prot_reg(j) <= (others=>'1');
|
||
|
|
prot_status(j+1) <='1';
|
||
|
|
end loop;
|
||
|
|
|
||
|
|
wait for Tpe;
|
||
|
|
RDYBSY_reg <= '1';
|
||
|
|
status(7) <= '1';
|
||
|
|
PRE <='0';
|
||
|
|
|
||
|
|
elsif(oP3D ='1' and t(31)='1' and page_addr0 = X"2A" and page_addr1 = X"7F" and byte_addr =X"FC")then
|
||
|
|
report "program sector protection register PRP ";
|
||
|
|
report "entered into PRP ";
|
||
|
|
PRP <= '1';
|
||
|
|
current_address :=0;
|
||
|
|
page_boundary_low := 0;
|
||
|
|
page_boundary_high := sec_tors(device);
|
||
|
|
write_data(current_address,page_boundary_low,page_boundary_high,tbuffer1,tbuffer2,1,CSB,sck,SI);
|
||
|
|
|
||
|
|
RDYBSY_reg <= '0'; --device is busy
|
||
|
|
status(7) <= '0';
|
||
|
|
wait for 1 ps;
|
||
|
|
for j in 0 to sec_tors(device)-1 loop
|
||
|
|
prot_reg(j) <= (prot_reg(j) and tbuffer1(j));
|
||
|
|
end loop;
|
||
|
|
wait for 1 ps;
|
||
|
|
temp_reg1 <= To_stdlogicvector(prot_reg(0));
|
||
|
|
wait for 1 ps;
|
||
|
|
|
||
|
|
for j in 0 to sec_tors(device)-2 loop
|
||
|
|
temp_prot_status_program(j) <= prot_reg(j)(0) and prot_reg(j)(1)
|
||
|
|
and prot_reg(j)(2) and prot_reg(j)(3)
|
||
|
|
and prot_reg(j)(4) and prot_reg(j)(5)
|
||
|
|
and prot_reg(j)(6) and prot_reg(j)(7);
|
||
|
|
end loop;
|
||
|
|
wait for 1 ps;
|
||
|
|
|
||
|
|
prot_status <= (To_stdlogicvector(temp_prot_status_program)) & (temp_reg1(5) and temp_reg1(4)) & (temp_reg1(7) and temp_reg1(6)) ;
|
||
|
|
wait for Tp;
|
||
|
|
RDYBSY_reg <= '1'; -- device is now ready
|
||
|
|
status(7) <= '1';
|
||
|
|
wait for 1 ps;
|
||
|
|
PRP <= '0';
|
||
|
|
report "PRP is exited ";
|
||
|
|
|
||
|
|
elsif(oP3D ='1' and t(31)='1' and page_addr0 = X"2A" and page_addr1 = X"7F" and byte_addr =X"30")then
|
||
|
|
report "entered into program sector lockdown register LRP ";
|
||
|
|
LRP <='1';
|
||
|
|
wait until CSB'event and CSB ='1';
|
||
|
|
RDYBSY_reg <= '0'; -- device is busy
|
||
|
|
status(7) <= '0';
|
||
|
|
|
||
|
|
if (conv_integer(comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device))) < 8)then
|
||
|
|
case (lock_status(1)) is
|
||
|
|
when '0' => lock_reg(0) <= X"C0"; -- Sector 0a locked, 0b unlocked
|
||
|
|
when '1' => lock_reg(0) <= X"F0"; -- Sectors 0a, 0b locked
|
||
|
|
when others => message2 :="Thismessage shouldnever appear";
|
||
|
|
end case;
|
||
|
|
lock_status(0) <= '1';
|
||
|
|
elsif (conv_integer(page) < PAGEPER_SECTOR(device)) then
|
||
|
|
case (lock_status(0)) is
|
||
|
|
when '0' => lock_reg(0) <= X"30"; --Sector 0a unlocked, 0b locked
|
||
|
|
when '1' => lock_reg(0) <= X"F0"; -- Sectors 0a, 0b locked
|
||
|
|
when others => message2 :="Thismessage shouldnever appear";
|
||
|
|
end case;
|
||
|
|
lock_status(1) <= '1';
|
||
|
|
else
|
||
|
|
lock_reg(sec_tors(device)-1) <= (others=>'1');
|
||
|
|
lock_status(sec_tors(device)) <= '1';
|
||
|
|
end if;
|
||
|
|
wait for Tp;
|
||
|
|
RDYBSY_reg <= '1'; -- device is now ready
|
||
|
|
status(7) <= '1';
|
||
|
|
LRP <='0';
|
||
|
|
report "LRP is exited ";
|
||
|
|
|
||
|
|
elsif(oP3D ='1' and t(31)='1' and page_addr0 = X"2A" and page_addr1 = X"80" and byte_addr =X"A6")then
|
||
|
|
report "entered binary page setup";
|
||
|
|
BPS <='1';
|
||
|
|
wait until CSB'event and CSB = '1' ;
|
||
|
|
RDYBSY_reg <= '0'; -- device is busy
|
||
|
|
status(7) <= '0';
|
||
|
|
binary_page <= '1';
|
||
|
|
|
||
|
|
wait for Tp;
|
||
|
|
RDYBSY_reg <= '1'; --device is now ready
|
||
|
|
status(7) <= '1';
|
||
|
|
status(0) <= '1';
|
||
|
|
BPS <='0';
|
||
|
|
report "binary page setup exited";
|
||
|
|
|
||
|
|
|
||
|
|
elsif(MMPPB1='1' and t(31)='1' and RDYBSY_reg='1')then
|
||
|
|
report "MMPPB1";
|
||
|
|
MMPPB1_mem_page := comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device));
|
||
|
|
-- page value has been stored for main memory page program
|
||
|
|
MMPPB1_buf_page := (others=>'0');--buffer has zero pages
|
||
|
|
|
||
|
|
compute_address(MMPPB1_buf_page,pagesize(device,binary_page),comp_byte_addr(b_address(device,binary_page),
|
||
|
|
page_addr1,byte_addr,binary_page),page_boundary_low,page_boundary_high,current_address,mem_no,binary_page);
|
||
|
|
write_data(current_address,page_boundary_low,page_boundary_high,tbuffer1,tbuffer2,1,CSB,sck,SI);
|
||
|
|
-- this will write to buffer
|
||
|
|
-- it will proceed to next step, when, posedge of CSB.
|
||
|
|
-- This is complicated, and, hence, explained here:
|
||
|
|
-- At posedge of CSB, the write_data will get disabled.
|
||
|
|
-- At this time, writing to buffer needs to stop, and,
|
||
|
|
-- writing into memory should start.
|
||
|
|
if(check_lockd(comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device)), pageper_sector(device),
|
||
|
|
lock_status, comp_sector_addr(p_address(device),comp_page_addr(p_address(device),binary_page,page_addr0,
|
||
|
|
page_addr1,manid(device)))) ='0') then
|
||
|
|
|
||
|
|
if(check_protect(comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device)),
|
||
|
|
pageper_sector(device),prot_status, comp_sector_addr(p_address(device),comp_page_addr(p_address(device),binary_page,
|
||
|
|
page_addr0,page_addr1,manid(device))), WPB,soft_prot_enabled) ='0')then
|
||
|
|
|
||
|
|
compute_address(MMPPB1_mem_page,pagesize(device,binary_page),comp_byte_addr(b_address(device,binary_page),
|
||
|
|
page_addr1,byte_addr,binary_page),page_boundary_low,
|
||
|
|
page_boundary_high,current_address,mem_no,binary_page);
|
||
|
|
RDYBSY_reg <= '0'; -- device is busy
|
||
|
|
status(7) <='0';
|
||
|
|
write_to_memory(1,comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device)),
|
||
|
|
pagesize(device,binary_page),tbuffer1,tbuffer2,page_boundary_low,memory);
|
||
|
|
page_status(conv_integer(comp_page_addr(p_address(device),binary_page,
|
||
|
|
page_addr0,page_addr1,manid(device)))) <= '1';
|
||
|
|
|
||
|
|
updating_memory <= '1';
|
||
|
|
|
||
|
|
wait for Tep;
|
||
|
|
RDYBSY_reg <= '1'; -- device is now ready
|
||
|
|
status(7) <= '1';
|
||
|
|
updating_memory <= '0';
|
||
|
|
else
|
||
|
|
message2 :=" Cannot write page is proted ";
|
||
|
|
end if;
|
||
|
|
else
|
||
|
|
message2 :=" Cannot write page is Locked ";
|
||
|
|
end if;
|
||
|
|
|
||
|
|
report " MMPPB1 exited";
|
||
|
|
|
||
|
|
|
||
|
|
elsif(MMPPB2='1' and t(31)='1' and RDYBSY_reg='1')then
|
||
|
|
report "MMPPB2";
|
||
|
|
|
||
|
|
MMPPB2_mem_page := comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device));
|
||
|
|
-- page value has been stored for main memory page program
|
||
|
|
MMPPB2_buf_page := (others=>'0');--buffer has zero pages
|
||
|
|
|
||
|
|
compute_address(MMPPB2_buf_page,pagesize(device,binary_page),comp_byte_addr(b_address(device,binary_page),
|
||
|
|
page_addr1,byte_addr,binary_page),page_boundary_low,page_boundary_high,current_address,mem_no,binary_page);
|
||
|
|
|
||
|
|
write_data(current_address,page_boundary_low,page_boundary_high,tbuffer1,tbuffer2,2,CSB,sck,SI);
|
||
|
|
-- this will write to buffer
|
||
|
|
-- it will proceed to next step, when, posedge of CSB.
|
||
|
|
-- This is complicated, and, hence, explained here:
|
||
|
|
-- At posedge of CSB, the write_data will get disabled.
|
||
|
|
-- At this time, writing to buffer needs to stop, and,
|
||
|
|
-- writing into memory should start.
|
||
|
|
|
||
|
|
if(check_lockd(comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device)),
|
||
|
|
pageper_sector(device),lock_status,
|
||
|
|
comp_sector_addr(p_address(device),comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device)))) ='0') then
|
||
|
|
|
||
|
|
if(check_protect(comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device)),
|
||
|
|
pageper_sector(device),prot_status,
|
||
|
|
comp_sector_addr(p_address(device),comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device))),
|
||
|
|
WPB,soft_prot_enabled) ='0')then
|
||
|
|
|
||
|
|
compute_address(MMPPB2_mem_page,pagesize(device,binary_page),comp_byte_addr(b_address(device,binary_page),
|
||
|
|
page_addr1,byte_addr,binary_page),page_boundary_low,page_boundary_high,current_address,mem_no,binary_page);
|
||
|
|
RDYBSY_reg <= '0'; -- device is busy
|
||
|
|
status(7) <='0';
|
||
|
|
write_to_memory(2,comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device)),
|
||
|
|
pagesize(device,binary_page),tbuffer1,tbuffer2,page_boundary_low,memory);
|
||
|
|
page_status(conv_integer(comp_page_addr(p_address(device),binary_page,
|
||
|
|
page_addr0,page_addr1,manid(device)))) <= '1';
|
||
|
|
updating_memory <= '1';
|
||
|
|
|
||
|
|
wait for Tep;
|
||
|
|
RDYBSY_reg <= '1'; -- device is now ready
|
||
|
|
status(7)<='1';
|
||
|
|
updating_memory <= '0';
|
||
|
|
else
|
||
|
|
message2 :=" Cannot write page is proted ";
|
||
|
|
end if;
|
||
|
|
else
|
||
|
|
message2 :=" Cannot write page is Locked ";
|
||
|
|
end if;
|
||
|
|
|
||
|
|
elsif(APRB1='1' and t(31)='1')then
|
||
|
|
report "ARPB1";
|
||
|
|
compute_address(comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device)),
|
||
|
|
pagesize(device,binary_page),comp_byte_addr(b_address(device,binary_page),page_addr1,byte_addr,binary_page),
|
||
|
|
page_boundary_low,page_boundary_high,
|
||
|
|
current_address,mem_no,binary_page);
|
||
|
|
|
||
|
|
wait until CSB'event and CSB = '1';
|
||
|
|
transfer_to_buffer (1, page_boundary_low,memory,tbuffer1,tbuffer2);
|
||
|
|
updating_buffer1 <='1';
|
||
|
|
|
||
|
|
if(check_lockd(comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device)),
|
||
|
|
pageper_sector(device),lock_status,
|
||
|
|
comp_sector_addr(p_address(device),comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device)))) ='0') then
|
||
|
|
|
||
|
|
if(check_protect(comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device)),
|
||
|
|
pageper_sector(device),prot_status,
|
||
|
|
comp_sector_addr(p_address(device),comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device))),
|
||
|
|
WPB,soft_prot_enabled) ='0')then
|
||
|
|
|
||
|
|
updating_memory <='1';
|
||
|
|
RDYBSY_reg <='0';
|
||
|
|
status(7)<='0';
|
||
|
|
wait for Tep;
|
||
|
|
RDYBSY_reg <='1';
|
||
|
|
status(7)<='1';
|
||
|
|
updating_buffer1 <='0';
|
||
|
|
updating_memory <='0';
|
||
|
|
else
|
||
|
|
message2 :=" Cannot write page is proted ";
|
||
|
|
|
||
|
|
end if;
|
||
|
|
else
|
||
|
|
message2 :=" Cannot write page is Locked ";
|
||
|
|
end if;
|
||
|
|
|
||
|
|
|
||
|
|
-- NOTE:
|
||
|
|
-- We dont need to rewrite the data back into main-memory, as the
|
||
|
|
-- data is already available in the main-memory
|
||
|
|
-- This task was exactly same as MMPTB1T, except the delay-value
|
||
|
|
-- We could have easily used the same code as MMPTB1T, using
|
||
|
|
-- an if condition for delay-selection. However, still doing
|
||
|
|
-- this way, so that the code for each opcode is independent
|
||
|
|
-- of anything else.
|
||
|
|
|
||
|
|
report "APRB1 auto page rewrite is exited";
|
||
|
|
|
||
|
|
elsif(APRB2='1' and t(31)='1')then
|
||
|
|
report "entered into auto page rewrite through buffer 2 ARPB2";
|
||
|
|
compute_address(comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device)),
|
||
|
|
pagesize(device,binary_page),comp_byte_addr(b_address(device,binary_page),page_addr1,byte_addr,binary_page),
|
||
|
|
page_boundary_low,page_boundary_high,
|
||
|
|
current_address,mem_no,binary_page);
|
||
|
|
|
||
|
|
wait until CSB'event and CSB = '1';
|
||
|
|
transfer_to_buffer (2, page_boundary_low,memory,tbuffer1,tbuffer2);
|
||
|
|
updating_buffer1 <='1';
|
||
|
|
|
||
|
|
if(check_lockd(comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device)),
|
||
|
|
pageper_sector(device),lock_status,
|
||
|
|
comp_sector_addr(p_address(device),comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device)))) ='0') then
|
||
|
|
|
||
|
|
if(check_protect(comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device)),
|
||
|
|
pageper_sector(device),prot_status,
|
||
|
|
comp_sector_addr(p_address(device),comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device))),
|
||
|
|
WPB,soft_prot_enabled) ='0')then
|
||
|
|
|
||
|
|
updating_memory <='1';
|
||
|
|
RDYBSY_reg <='0';
|
||
|
|
status(7)<='0';
|
||
|
|
wait for Tep;
|
||
|
|
RDYBSY_reg <='1';
|
||
|
|
status(7)<='1';
|
||
|
|
updating_buffer1 <='0';
|
||
|
|
updating_memory <='0';
|
||
|
|
else
|
||
|
|
message2 :=" Cannot write page is proted ";
|
||
|
|
|
||
|
|
end if;
|
||
|
|
else
|
||
|
|
message2 :=" Cannot write page is Locked ";
|
||
|
|
end if;
|
||
|
|
|
||
|
|
|
||
|
|
-- NOTE:
|
||
|
|
-- We dont need to rewrite the data back into main-memory, as the
|
||
|
|
-- data is already available in the main-memory
|
||
|
|
-- This task was exactly same as MMPTB1T, except the delay-value
|
||
|
|
-- We could have easily used the same code as MMPTB1T, using
|
||
|
|
-- an if condition for delay-selection. However, still doing
|
||
|
|
-- this way, so that the code for each opcode is independent
|
||
|
|
-- of anything else.
|
||
|
|
|
||
|
|
report " auto page rewrite through buffer 2 is exited";
|
||
|
|
|
||
|
|
----------------page erase------------------
|
||
|
|
|
||
|
|
elsif (PE = '1')then
|
||
|
|
report "entered into page erase" ;
|
||
|
|
if (check_lockd(comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device)),pageper_sector(device),
|
||
|
|
lock_status,comp_sector_addr(p_address(device),comp_page_addr(p_address(device),binary_page,page_addr0,
|
||
|
|
page_addr1,manid(device)))) = '0')then
|
||
|
|
if (check_protect(comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device)),pageper_sector(device),prot_status,
|
||
|
|
comp_sector_addr(p_address(device),comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device))),
|
||
|
|
WPB,soft_prot_enabled) ='0')then
|
||
|
|
|
||
|
|
|
||
|
|
compute_address(comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device)),pagesize(device,binary_page),
|
||
|
|
comp_byte_addr(b_address(device,binary_page),page_addr1,byte_addr,binary_page),page_boundary_low,page_boundary_high,
|
||
|
|
current_address,mem_no,binary_page);
|
||
|
|
|
||
|
|
wait until CSB'event and CSB='1';
|
||
|
|
RDYBSY_reg <= '0'; --device is busy
|
||
|
|
status(7) <= '0';
|
||
|
|
erase_page(comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device)),
|
||
|
|
pagesize(device,binary_page),page_boundary_low,memory,temp_page_status);
|
||
|
|
erasing_page <= '1';
|
||
|
|
page_status(conv_integer(comp_page_addr(p_address(device),binary_page,
|
||
|
|
page_addr0,page_addr1,manid(device)))) <= temp_page_status;
|
||
|
|
|
||
|
|
wait for Tpe ;
|
||
|
|
RDYBSY_reg <= '1' ; --device is now ready
|
||
|
|
status(7) <= '1' ;
|
||
|
|
erasing_page <= '0' ;
|
||
|
|
else
|
||
|
|
message2 :=" Cannot erase page is proted ";
|
||
|
|
end if;
|
||
|
|
else
|
||
|
|
message2 :=" Cannot erase page is locked ";
|
||
|
|
end if;
|
||
|
|
|
||
|
|
report "page erase exited";
|
||
|
|
--------------------------Block Erase-------------------------
|
||
|
|
|
||
|
|
elsif (BE = '1')then
|
||
|
|
report "entered into block erase" ;
|
||
|
|
if (check_lockd(comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device)),
|
||
|
|
pageper_sector(device),lock_status,comp_sector_addr(p_address(device),comp_page_addr(p_address(device),
|
||
|
|
binary_page,page_addr0,page_addr1,manid(device)))) = '0')then
|
||
|
|
|
||
|
|
if (check_protect(comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,
|
||
|
|
manid(device)),pageper_sector(device),prot_status,comp_sector_addr(p_address(device),
|
||
|
|
comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device))),
|
||
|
|
WPB,soft_prot_enabled) ='0')then
|
||
|
|
|
||
|
|
compute_address(comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,
|
||
|
|
manid(device)),pagesize(device,binary_page),comp_byte_addr(b_address(device,binary_page),page_addr1,byte_addr,binary_page),
|
||
|
|
page_boundary_low,page_boundary_high,current_address,mem_no,binary_page);
|
||
|
|
|
||
|
|
wait until CSB'event and CSB ='1';
|
||
|
|
RDYBSY_reg <= '0'; --device is busy
|
||
|
|
status(7) <= '0';
|
||
|
|
|
||
|
|
jerase := page_boundary_low;
|
||
|
|
loop_erase: loop
|
||
|
|
if (jerase < page_boundary_low+(8*pagesize(device,binary_page))) then
|
||
|
|
erase_page(comp_page_addr(p_address(device),binary_page,page_addr0,
|
||
|
|
page_addr1,manid(device)),pagesize(device,binary_page),jerase,memory,temp_page_status); --erase 8 pages, i.e. a block
|
||
|
|
|
||
|
|
page_status(conv_integer(comp_page_addr(p_address(device),binary_page,
|
||
|
|
page_addr0,page_addr1,manid(device)))) <= temp_page_status;
|
||
|
|
|
||
|
|
jerase := jerase+pagesize(device,binary_page);
|
||
|
|
else
|
||
|
|
report "--------------------------Block Eraseexit -------------------------";
|
||
|
|
exit loop_erase;
|
||
|
|
end if;
|
||
|
|
end loop;
|
||
|
|
|
||
|
|
for j in 0 to 7 loop --erase_page will only change the status of one-page
|
||
|
|
page_status(conv_integer(comp_page_addr(p_address(device),binary_page,
|
||
|
|
page_addr0,page_addr1,manid(device)))+j) <= '0';
|
||
|
|
end loop;
|
||
|
|
erasing_block <= '1';
|
||
|
|
wait for Tbe;
|
||
|
|
RDYBSY_reg <= '1' ; --device is now ready
|
||
|
|
status(7) <= '1';
|
||
|
|
erasing_block <= '0';
|
||
|
|
else
|
||
|
|
message2 :=" Cannot erase bloc is proted ";
|
||
|
|
end if;
|
||
|
|
else
|
||
|
|
message2 :=" Cannot erase bloc is locked ";
|
||
|
|
end if;
|
||
|
|
|
||
|
|
|
||
|
|
report "block erase exited" ;
|
||
|
|
|
||
|
|
---------------------------Sector Erase -----------------------------
|
||
|
|
|
||
|
|
elsif (SE = '1')then
|
||
|
|
if (check_lockd(comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device)),pageper_sector(device),
|
||
|
|
lock_status,comp_sector_addr(p_address(device),comp_page_addr(p_address(device),
|
||
|
|
binary_page,page_addr0,page_addr1,manid(device)))) = '0')then
|
||
|
|
|
||
|
|
if (check_protect(comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device)),pageper_sector(device),
|
||
|
|
prot_status,comp_sector_addr(p_address(device),comp_page_addr(p_address(device),
|
||
|
|
binary_page,page_addr0,page_addr1,manid(device))),
|
||
|
|
WPB,soft_prot_enabled) = '0')then
|
||
|
|
|
||
|
|
compute_address(comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device)),pagesize(device,binary_page),
|
||
|
|
comp_byte_addr(b_address(device,binary_page),page_addr1,byte_addr,binary_page),page_boundary_low,
|
||
|
|
page_boundary_high,current_address,mem_no,binary_page);
|
||
|
|
|
||
|
|
wait until CSB'event and CSB = '1';
|
||
|
|
RDYBSY_reg <= '0'; --device is busy
|
||
|
|
status(7) <= '0';
|
||
|
|
--******************************--
|
||
|
|
if (conv_integer(comp_page_addr(p_address(device),binary_page,page_addr0,
|
||
|
|
page_addr1,manid(device))) < 8 ) then
|
||
|
|
page_boundary_low := 0;
|
||
|
|
|
||
|
|
jerase := page_boundary_low;
|
||
|
|
loop_sectorerase: loop
|
||
|
|
if (jerase < page_boundary_low+8*pagesize(device,binary_page) ) then
|
||
|
|
erase_page(comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device)),
|
||
|
|
pagesize(device,binary_page),jerase,memory,temp_page_status); -- erase 8 pages, i.e. a block
|
||
|
|
|
||
|
|
page_status(conv_integer(comp_page_addr(p_address(device),binary_page,
|
||
|
|
page_addr0,page_addr1,manid(device)))) <= temp_page_status;
|
||
|
|
|
||
|
|
|
||
|
|
jerase := jerase+pagesize(device,binary_page);
|
||
|
|
else
|
||
|
|
report "--------------------------sector Eraseexit -------------------------";
|
||
|
|
exit loop_sectorerase;
|
||
|
|
end if;
|
||
|
|
end loop;
|
||
|
|
|
||
|
|
for j in 0 to 7 loop -- erase_page will only change the status of one-page
|
||
|
|
page_status(j) <= '0';
|
||
|
|
end loop;
|
||
|
|
--************************************----
|
||
|
|
elsif (comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device)) < pageper_sector(device)) then
|
||
|
|
page_boundary_low := 8*pagesize(device,binary_page);
|
||
|
|
jerase := page_boundary_low;
|
||
|
|
loop_sector1erase : loop
|
||
|
|
if (jerase < page_boundary_low+((pageper_sector(device)-8)*pagesize(device,binary_page)) ) then
|
||
|
|
erase_page(comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device)),
|
||
|
|
pagesize(device,binary_page),jerase,memory,temp_page_status); --erase 248/120 pages, i.e. a block
|
||
|
|
page_status(conv_integer(comp_page_addr(p_address(device),binary_page,
|
||
|
|
page_addr0,page_addr1,manid(device)))) <= temp_page_status;
|
||
|
|
|
||
|
|
jerase := jerase+pagesize(device,binary_page);
|
||
|
|
else
|
||
|
|
report "--------------------------sector1 Eraseexit -------------------------";
|
||
|
|
exit loop_sector1erase;
|
||
|
|
end if;
|
||
|
|
end loop;
|
||
|
|
|
||
|
|
for j in 8 to pageper_sector(device)-1 loop --erase_page will only change the status of one-page
|
||
|
|
page_status(j) <= '0';
|
||
|
|
end loop;
|
||
|
|
|
||
|
|
--****************************
|
||
|
|
else
|
||
|
|
page((p_address(DEVICE)- s_address(DEVICE))-1) <= '0';
|
||
|
|
page_boundary_low :=conv_integer(page)*pagesize(device,binary_page);
|
||
|
|
jerase := page_boundary_low;
|
||
|
|
loop_sector2erase : loop
|
||
|
|
if (jerase < page_boundary_low+(pageper_sector(device)*pagesize(device,binary_page))) then
|
||
|
|
jerase := jerase+pagesize(device,binary_page);
|
||
|
|
erase_page(comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device)),
|
||
|
|
pagesize(device,binary_page),jerase,memory,temp_page_status); --erase 256/128 pages, i.e. a block
|
||
|
|
page_status(conv_integer(comp_page_addr(p_address(device),binary_page,
|
||
|
|
page_addr0,page_addr1,manid(device)))) <= temp_page_status;
|
||
|
|
jerase := jerase +pagesize(device,binary_page);
|
||
|
|
else
|
||
|
|
report "--------------------------sector2 Eraseexit -------------------------";
|
||
|
|
exit loop_sector2erase;
|
||
|
|
|
||
|
|
end if;
|
||
|
|
end loop;
|
||
|
|
|
||
|
|
for j in 0 to pageper_sector(device)-1 loop
|
||
|
|
page_status(conv_integer(comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device)))+j) <= '0';
|
||
|
|
end loop;
|
||
|
|
erasing_sector <= '1';
|
||
|
|
|
||
|
|
wait for Tse;
|
||
|
|
RDYBSY_reg <= '1' ; --device is now ready
|
||
|
|
status(7) <= '1';
|
||
|
|
erasing_sector <= '0';
|
||
|
|
end if;
|
||
|
|
|
||
|
|
|
||
|
|
else
|
||
|
|
message2 :=" Cannot erase sect is proted ";
|
||
|
|
end if;
|
||
|
|
else
|
||
|
|
message2 :=" Cannot erase sect is locked ";
|
||
|
|
end if;
|
||
|
|
|
||
|
|
|
||
|
|
----------------------------------Chip Erase-------------------------------------------
|
||
|
|
|
||
|
|
|
||
|
|
elsif(oPC7 ='1' and t(31)='1')then
|
||
|
|
report "enabling chip erase";
|
||
|
|
if (page_addr0 = X"94" and page_addr1 = X"80" and byte_addr = X"9A")then
|
||
|
|
wait until CSB'event and CSB = '1';
|
||
|
|
RDYBSY_reg <= '0'; -- device is busy
|
||
|
|
status(7) <= '0';
|
||
|
|
--sector x0A
|
||
|
|
page <= (others=>'0'); -- erase sector 0A
|
||
|
|
sector <= (others=>'0');
|
||
|
|
compute_address(page=>page,page_size=>pagesize(device,binary_page),byte=>byte,page_boundary_low=>page_boundary_low,
|
||
|
|
page_boundary_high=>page_boundary_high,current_address=>current_address,mem_no=>mem_no,binary_page=>binary_page);
|
||
|
|
|
||
|
|
if (check_lockd(comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device)),
|
||
|
|
pageper_sector(device),lock_status,comp_sector_addr(p_address(device),comp_page_addr(p_address(device),
|
||
|
|
binary_page,page_addr0,page_addr1,manid(device)))) = '0')then
|
||
|
|
if (check_protect(comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device)),
|
||
|
|
pageper_sector(device),prot_status,comp_sector_addr(p_address(device),comp_page_addr(p_address(device),
|
||
|
|
binary_page,page_addr0,page_addr1,manid(device))),WPB,soft_prot_enabled) = '0')then
|
||
|
|
|
||
|
|
jerase := page_boundary_low;
|
||
|
|
loop_chiperase: loop
|
||
|
|
if (jerase < page_boundary_low+8*pagesize(device,binary_page) ) then
|
||
|
|
erase_page(comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device)),
|
||
|
|
pagesize(device,binary_page),jerase,memory,temp_page_status); -- erase 8 pages, i.e. a block
|
||
|
|
page_status(conv_integer(comp_page_addr(p_address(device),binary_page,
|
||
|
|
page_addr0,page_addr1,manid(device)))) <= temp_page_status;
|
||
|
|
|
||
|
|
jerase := jerase+pagesize(device,binary_page);
|
||
|
|
else
|
||
|
|
report "--------------------------chip Eraseexit -------------------------";
|
||
|
|
exit loop_chiperase;
|
||
|
|
end if;
|
||
|
|
end loop;
|
||
|
|
|
||
|
|
|
||
|
|
for j in 0 to 7 loop -- erase_page will only change the status of one-page
|
||
|
|
page_status(j) <= '0';
|
||
|
|
end loop;
|
||
|
|
end if;
|
||
|
|
end if;
|
||
|
|
|
||
|
|
-- second sector x0B
|
||
|
|
page <= conv_std_logic_vector(8,p_address(DEVICE));
|
||
|
|
sector <= (others=>'0');
|
||
|
|
compute_address(page=>page,page_size=>pagesize(device,binary_page),byte=>byte,page_boundary_low=>page_boundary_low,
|
||
|
|
page_boundary_high=>page_boundary_high,current_address=>current_address,mem_no=>mem_no,binary_page=>binary_page);
|
||
|
|
--Check if sector is locked
|
||
|
|
if (check_lockd(comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device)),pageper_sector(device),
|
||
|
|
lock_status,comp_sector_addr(p_address(device),comp_page_addr(p_address(device),
|
||
|
|
binary_page,page_addr0,page_addr1,manid(device)))) = '0')then
|
||
|
|
--Check if sector is protecteds-----------------------
|
||
|
|
if (check_protect(comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device)),
|
||
|
|
pageper_sector(device),prot_status,comp_sector_addr(p_address(device),comp_page_addr(p_address(device),
|
||
|
|
binary_page,page_addr0,page_addr1,manid(device))),WPB,soft_prot_enabled) = '0') then
|
||
|
|
|
||
|
|
jerase := page_boundary_low;
|
||
|
|
loop_chip_0berase: loop
|
||
|
|
if (jerase < page_boundary_low +((pageper_sector(device)-8)*pagesize(device,binary_page))) then
|
||
|
|
erase_page(comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device)),
|
||
|
|
pagesize(device,binary_page),jerase,memory,temp_page_status); -- erase 8 pages, i.e. a block
|
||
|
|
|
||
|
|
page_status(conv_integer(comp_page_addr(p_address(device),binary_page,
|
||
|
|
page_addr0,page_addr1,manid(device)))) <= temp_page_status;
|
||
|
|
|
||
|
|
jerase := jerase+pagesize(device,binary_page);
|
||
|
|
else
|
||
|
|
report "--------------------------chip0b Eraseexit -------------------------";
|
||
|
|
exit loop_chip_0berase;
|
||
|
|
end if;
|
||
|
|
end loop;
|
||
|
|
|
||
|
|
|
||
|
|
for j in 0 to 7 loop -- erase_page will only change the status of one-page
|
||
|
|
page_status(j) <= '0';
|
||
|
|
end loop;
|
||
|
|
end if;
|
||
|
|
end if;
|
||
|
|
|
||
|
|
sector <= (others=>'1');
|
||
|
|
for page in pageper_sector(device) to (PAGE_cal(device) - pageper_sector(device))-1 loop
|
||
|
|
--Check if sector is locked
|
||
|
|
if (check_lockd(comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device)),
|
||
|
|
pageper_sector(device),lock_status,comp_sector_addr(p_address(device),comp_page_addr(p_address(device),
|
||
|
|
binary_page,page_addr0,page_addr1,manid(device)))) = '0') then
|
||
|
|
--Check if sector is protecteds-----------------------
|
||
|
|
if (check_protect(comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device)),
|
||
|
|
pageper_sector(device),prot_status,comp_sector_addr(p_address(device),comp_page_addr(p_address(device),
|
||
|
|
binary_page,page_addr0,page_addr1,manid(device))),WPB,soft_prot_enabled)= '0') then
|
||
|
|
|
||
|
|
jerase := page_boundary_low;
|
||
|
|
|
||
|
|
loop_chip_0cerase: loop
|
||
|
|
if (jerase < page_boundary_low +(pageper_sector(device)*pagesize(device,binary_page))) then
|
||
|
|
|
||
|
|
erase_page(comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device)),
|
||
|
|
pagesize(device,binary_page),jerase,memory,temp_page_status);
|
||
|
|
|
||
|
|
page_status(conv_integer(comp_page_addr(p_address(device),binary_page,
|
||
|
|
page_addr0,page_addr1,manid(device)))) <= temp_page_status;
|
||
|
|
|
||
|
|
|
||
|
|
jerase := jerase+pagesize(device,binary_page);
|
||
|
|
else
|
||
|
|
report "--------------------------chip 0cEraseexit -------------------------";
|
||
|
|
exit loop_chip_0cerase;
|
||
|
|
end if;
|
||
|
|
end loop;
|
||
|
|
for j in 0 to pageper_sector(device)-1 loop
|
||
|
|
page_status(conv_integer(comp_page_addr(p_address(device),
|
||
|
|
binary_page,page_addr0,page_addr1,manid(device)))+j) <= '0';
|
||
|
|
end loop;
|
||
|
|
end if;
|
||
|
|
else
|
||
|
|
message2 :="Cannot erase:Sector is Locked";
|
||
|
|
sector <= sector + 1;
|
||
|
|
end if;
|
||
|
|
|
||
|
|
end loop;
|
||
|
|
|
||
|
|
page <=((conv_Std_Logic_Vector(PAGE_cal(device),p_address(device))) - (conv_Std_Logic_Vector(pageper_sector(device),p_address(device))));
|
||
|
|
|
||
|
|
sector <= conv_std_logic_vector((SEC_TORS(device)- 1),S_address(device));
|
||
|
|
|
||
|
|
compute_address(page=>page,page_size=>pagesize(device,binary_page),byte=>byte,page_boundary_low=>page_boundary_low,
|
||
|
|
page_boundary_high=>page_boundary_high,current_address=>current_address,mem_no=>mem_no,binary_page=>binary_page);
|
||
|
|
--Check if sector is locked
|
||
|
|
if (check_lockd(comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device)),pageper_sector(device),
|
||
|
|
lock_status,comp_sector_addr(p_address(device),comp_page_addr(p_address(device),binary_page,
|
||
|
|
page_addr0,page_addr1,manid(device)))) = '0')then
|
||
|
|
--Check if sector is protecteds-----------------------
|
||
|
|
if (check_protect(comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device)),pageper_sector(device),
|
||
|
|
prot_status,comp_sector_addr(p_address(device),comp_page_addr(p_address(device),binary_page,
|
||
|
|
page_addr0,page_addr1,manid(device))),
|
||
|
|
WPB,soft_prot_enabled) = '0')then
|
||
|
|
|
||
|
|
jerase := page_boundary_low;
|
||
|
|
|
||
|
|
loop_chip_0derase: loop
|
||
|
|
if (jerase < page_boundary_low+(pageper_sector(device)*pagesize(device,binary_page))) then
|
||
|
|
|
||
|
|
erase_page(comp_page_addr(p_address(device),binary_page,page_addr0,page_addr1,manid(device)),
|
||
|
|
pagesize(device,binary_page),jerase,memory,temp_page_status);
|
||
|
|
|
||
|
|
page_status(conv_integer(comp_page_addr(p_address(device),binary_page,
|
||
|
|
page_addr0,page_addr1,manid(device)))) <= temp_page_status;
|
||
|
|
|
||
|
|
jerase := jerase+pagesize(device,binary_page);
|
||
|
|
|
||
|
|
else
|
||
|
|
report "--------------------------chip0d Eraseexit -------------------------";
|
||
|
|
exit loop_chip_0derase;
|
||
|
|
end if;
|
||
|
|
|
||
|
|
end loop;
|
||
|
|
|
||
|
|
for j in 0 to pageper_sector(device)-1 loop
|
||
|
|
page_status(conv_integer(comp_page_addr(p_address(device),
|
||
|
|
binary_page,page_addr0,page_addr1,manid(device)))+j) <= '0';
|
||
|
|
end loop;
|
||
|
|
|
||
|
|
else
|
||
|
|
message2 :="Cannot erase:Sectorisprotecteds";
|
||
|
|
end if;
|
||
|
|
else
|
||
|
|
message2 :="Cannot erase:Sector is Locked ";
|
||
|
|
end if;
|
||
|
|
|
||
|
|
erasing_chip <= '1';
|
||
|
|
|
||
|
|
wait for Tce;
|
||
|
|
RDYBSY_reg <= '1'; -- device is now ready
|
||
|
|
status(7) <= '1';
|
||
|
|
erasing_chip <= '0';
|
||
|
|
report "chip erase complete";
|
||
|
|
end if;
|
||
|
|
|
||
|
|
|
||
|
|
elsif(SRR='1' and t(31)='1')then
|
||
|
|
report "SRR entered";
|
||
|
|
if ((Rapid_interface = false) and (fSCK > 50)) then
|
||
|
|
report"WARNING: Frequency should be less than 50MHz for SPI interface type. Security Register Read is not allowed.";
|
||
|
|
end if;
|
||
|
|
|
||
|
|
if(rapid_interface = false and fsck > 50) then
|
||
|
|
read_out_x(CSB,SCK,so_reg,so_on) ;
|
||
|
|
else
|
||
|
|
read_out_reg(23,0,127,prot_reg,lock_reg,security_reg,CSB,SCK,so_reg,so_on);
|
||
|
|
end if;
|
||
|
|
report " SRR exited";
|
||
|
|
|
||
|
|
elsif(PRR='1' and t(31)='1')then
|
||
|
|
report "PRR entered";
|
||
|
|
if ((Rapid_interface = false) and (fSCK > 50)) then
|
||
|
|
report"WARNING: Frequency should be less than 50MHz for SPI interface type. protection Register Read is not allowed.";
|
||
|
|
end if;
|
||
|
|
|
||
|
|
if(rapid_interface = false and fsck > 50) then
|
||
|
|
read_out_x(CSB,SCK,so_reg,so_on) ;
|
||
|
|
else
|
||
|
|
read_out_reg(21,0,(sec_tors(device)-1),prot_reg,lock_reg,security_reg,CSB,SCK,so_reg,so_on);
|
||
|
|
end if;
|
||
|
|
report " PRR exited";
|
||
|
|
|
||
|
|
elsif(LRR='1' and t(31)='1')then
|
||
|
|
report " LRR entered";
|
||
|
|
|
||
|
|
if ((Rapid_interface = false) and (fSCK > 50)) then
|
||
|
|
report"WARNING: Frequency should be less than 50MHz for SPI interface type. Lockdown Register Read is not allowed.";
|
||
|
|
end if;
|
||
|
|
|
||
|
|
if(rapid_interface = false and fsck > 50) then
|
||
|
|
read_out_x(CSB,SCK,so_reg,so_on) ;
|
||
|
|
else
|
||
|
|
read_out_reg(22,0,(sec_tors(device)-1),prot_reg,lock_reg,security_reg,CSB,SCK,so_reg,so_on);
|
||
|
|
end if;
|
||
|
|
|
||
|
|
report "LRR exited";
|
||
|
|
|
||
|
|
|
||
|
|
elsif(oP9B ='1' and t(31)='1' and page_addr0 = X"00" and page_addr1 = X"00" and byte_addr = X"00")then
|
||
|
|
report" entered program security register";
|
||
|
|
SRP <= '1';
|
||
|
|
current_address :=0;
|
||
|
|
page_boundary_low :=0;
|
||
|
|
page_boundary_high := 63;
|
||
|
|
write_data(current_address,page_boundary_low,page_boundary_high,tbuffer1,tbuffer2,1,CSB,sck,SI);
|
||
|
|
|
||
|
|
-- this will write to buffer
|
||
|
|
-- it will proceed to next step, when, posedge of CSB.
|
||
|
|
-- This is complicated, and, hence, explained here:
|
||
|
|
-- At posedge of CSB, the write_data will get disabled.
|
||
|
|
-- At this time, writing to buffer needs to stop, and,
|
||
|
|
-- writing into memory should start.
|
||
|
|
RDYBSY_reg <= '0'; --device is busy
|
||
|
|
status(7) <= '0';
|
||
|
|
--writing in to security_reg
|
||
|
|
if (security_flag = '0') then --Security Register has not been programmed before
|
||
|
|
for j in 0 to 63 loop
|
||
|
|
security_reg(j) <= tbuffer1(j);
|
||
|
|
end loop;
|
||
|
|
security_flag <= '1';
|
||
|
|
wait for Tp;
|
||
|
|
RDYBSY_reg <= '1'; --device is now ready
|
||
|
|
status(7) <= '1';
|
||
|
|
else
|
||
|
|
wait for 2000 ns;
|
||
|
|
RDYBSY_reg <= '1'; --device is now ready
|
||
|
|
status(7) <= '1';
|
||
|
|
end if;
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
end if;
|
||
|
|
|
||
|
|
report "last of processd";
|
||
|
|
|
||
|
|
end process;
|
||
|
|
|
||
|
|
----------------deep power down and resume deep power down----------------
|
||
|
|
|
||
|
|
process
|
||
|
|
begin
|
||
|
|
|
||
|
|
wait on EDPD,RDPD;
|
||
|
|
if(EDPD='1') then
|
||
|
|
wait until CSB'event and CSB='1';
|
||
|
|
wait for Tedpd;
|
||
|
|
deep_power_down <= '1';
|
||
|
|
end if;
|
||
|
|
if(RDPD='1')then
|
||
|
|
wait until CSB'event and CSB ='1';
|
||
|
|
wait for Trdpd;
|
||
|
|
deep_power_down <= '0';
|
||
|
|
end if;
|
||
|
|
end process;
|
||
|
|
|
||
|
|
|
||
|
|
-----------------------status register read--------
|
||
|
|
|
||
|
|
process
|
||
|
|
variable j_tmp : integer := 8;
|
||
|
|
begin
|
||
|
|
|
||
|
|
wait on SR ;
|
||
|
|
if( SR = '1' ) then
|
||
|
|
report "SR";
|
||
|
|
if ((Rapid_interface = false) and (fSCK > 50)) then
|
||
|
|
report"WARNING: Frequency should be less than 50MHz for SPI interface type. Status Register Read is not allowed.";
|
||
|
|
end if;
|
||
|
|
status_read <='1';--reading status reg
|
||
|
|
if(fsck >= 33)then
|
||
|
|
for i in 0 to 7 loop
|
||
|
|
wait until SCK'event and SCK='0';
|
||
|
|
wait for tv;
|
||
|
|
so_reg1 <= 'X';
|
||
|
|
so_on1 <= '1';
|
||
|
|
end loop;
|
||
|
|
end if;
|
||
|
|
status_loop : loop
|
||
|
|
wait until ((SCK'event and SCK ='0') or (CSB'event and CSB='1'));
|
||
|
|
exit status_loop when CSB = '1';
|
||
|
|
if(j_tmp > 0)then
|
||
|
|
j_tmp := j_tmp - 1;
|
||
|
|
else
|
||
|
|
j_tmp := 7;
|
||
|
|
|
||
|
|
end if;
|
||
|
|
|
||
|
|
if ((Rapid_interface = false) and (fSCK > 50)) then
|
||
|
|
read_out_x(CSB,SCK,so_reg1,so_on1) ;
|
||
|
|
else
|
||
|
|
wait for tV;
|
||
|
|
so_reg1 <= status(j_tmp);
|
||
|
|
so_on1 <= '1';
|
||
|
|
end if;
|
||
|
|
|
||
|
|
end loop;
|
||
|
|
report"status register read loop exited";
|
||
|
|
wait for tDIS;
|
||
|
|
so_on1 <= '0';
|
||
|
|
status_read <='0';
|
||
|
|
end if;
|
||
|
|
|
||
|
|
|
||
|
|
end process;
|
||
|
|
------------manufacturing ID-----------
|
||
|
|
process --(MIR)--,MANID(device))
|
||
|
|
variable j : integer:= 32 ;
|
||
|
|
variable m_id : std_logic_vector(31 downto 0):= manid(device);
|
||
|
|
begin
|
||
|
|
wait on MIR;
|
||
|
|
if(MIR='1')then
|
||
|
|
report "MIR";
|
||
|
|
if ((Rapid_interface = false) and (fSCK > 50)) then
|
||
|
|
report"WARNING: Frequency should be less than 50MHz for SPI interface type. Manufacture ID Register Read is not allowed.";
|
||
|
|
end if;
|
||
|
|
MIR_loop : loop
|
||
|
|
wait until ((SCK'event and SCK ='0') or (CSB'event and CSB='1'));
|
||
|
|
exit MIR_loop when CSB = '1';
|
||
|
|
wait for Tv ;
|
||
|
|
if(J > 0)then
|
||
|
|
SO_reg2 <= m_id(j-1);
|
||
|
|
so_on2 <= '1';
|
||
|
|
J := J - 1;
|
||
|
|
if ((Rapid_interface = false) and (fSCK > 50)) then
|
||
|
|
read_out_x(CSB,SCK,so_reg2,so_on2) ;
|
||
|
|
end if;
|
||
|
|
elsif( j = 0) then
|
||
|
|
So_on2 <= '1';
|
||
|
|
So_reg2 <= 'X'; -- only if the cs extends more than available man ID
|
||
|
|
end if;
|
||
|
|
end loop;
|
||
|
|
wait for Tdis ;
|
||
|
|
so_on2 <= '0';
|
||
|
|
So_reg2 <= '0';
|
||
|
|
|
||
|
|
end if;
|
||
|
|
|
||
|
|
|
||
|
|
end process;
|
||
|
|
|
||
|
|
---------------------------
|
||
|
|
IntCSb <= CSb or not Resetb;
|
||
|
|
------------------------ SCK check
|
||
|
|
checkPeriod ( SCK , "SCk" , Tsck , "Tsck" , TsckRp , "SCK Frequency" , valid ) ;
|
||
|
|
checkWidth1 ( SCK , "SCK" , Twh , "Twh" , TsckRw , "SCK High Time" , valid ) ;
|
||
|
|
checkWidth0 ( SCK , "SCK" , Twl , "Twl" , TsckF , "SCK Low Time" , valid ) ;
|
||
|
|
------------------------ IntCSb chec
|
||
|
|
checkWidth1 ( IntCSb , "IntCSb" , Tcs , "Tcs" , TcsR , "Minimum CS High Time", valid ) ;
|
||
|
|
checkSetupCS ( IntCSb , "IntCSb" , SCK , "SCK" , Tcss , "Tcss" , TcsF , "IntCSb setup Time" , valid ) ;
|
||
|
|
checkHoldCS ( IntCSb , "IntCSb" , SCK , "SCK" , Tcsh , "Tcsh" , Tsckm , "IntCSb Hold Time" , valid ) ;
|
||
|
|
------------------------ SI check
|
||
|
|
checkSetupRise ( SI , "SI" , SCK , "SCK" , Tsu , "Tsu" , Tsim , "Data in Setup Time" , valid ) ;
|
||
|
|
checkHoldRise ( SI , "SI" , SCK , "SCK" , Th , "Th" , TsckRh, "Data in Hold Time" , valid ) ;
|
||
|
|
|
||
|
|
|
||
|
|
process(so_on1,so_reg1,so_on2,so_reg2,so_reg, so_on)
|
||
|
|
begin
|
||
|
|
if(so_on1='1')then
|
||
|
|
so <= so_reg1;
|
||
|
|
elsif(so_on2='1')then
|
||
|
|
so <= so_reg2;
|
||
|
|
elsif (so_on='1') then
|
||
|
|
so <= so_reg;
|
||
|
|
else
|
||
|
|
so <= 'Z';
|
||
|
|
end if;
|
||
|
|
end process;
|
||
|
|
|
||
|
|
process(RDYBSY_reg)
|
||
|
|
begin
|
||
|
|
if(RDYBSY_reg = '1') then
|
||
|
|
RDYBSY <= '1';
|
||
|
|
else
|
||
|
|
RDYBSY <= '0';
|
||
|
|
end if;
|
||
|
|
end process;
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
--less_than_33mhz <= lthan_66mhz & lthan_33mhz;
|
||
|
|
|
||
|
|
|
||
|
|
end design;
|