Subversion Repositories mem_ctrl

//`timescale      1ns/1ns

//****************************************************************************

// This file contains the paramenters which define the part for the

// Smart 3 Advanced Boot Block memory model (adv_bb.v).  The '2.7V Vcc Timing'

// parameters are representative of the 28F160B3-120 operating at 2.7-3.6V Vcc.

// These parameters need to be changed if the 28F160B3-150 operating at

// 2.7-3.6V Vcc is to be modeled.  The parameters were taken from the Smart 3 

// Advanced Boot Block Flash Memory Family datasheet (Order Number 290580).

// This file must be loaded before the main model, as it contains

// definitions required by the model.

//28F160B3-B

`define BlockFileBegin  "f160b3b.bkb"   //starting addresses of each block

`define BlockFileEnd    "f160b3b.bke"   //ending addresses of each block

`define BlockFileType   "f160b3b.bkt"   //block types

//Available Vcc supported by the device.

`define VccLevels       4       //Bit 0 - 5V, Bit 1 = 3.3V, Bit 2 = 2.7V

`define AddrSize        20          //number of address pins

`define MaxAddr         `AddrSize'hFFFFF    // device ending address

`define MainArraySize   0:`MaxAddr  //array definition in bytes

                                    //include A-1 for 8 bit mode

`define MaxOutputs      16          //number of output pins

`define NumberOfBlocks  39          //number of blocks in the array

`define ID_DeviceCodeB      'h8891  //160B3 Bottom

`define ID_ManufacturerB    'h0089

// Timing parameters.  See the data sheet for definition of the parameter.

// Only the WE# controlled write timing parameters are used since their

// respective CE# controlled write timing parameters have the same value.

// The model does not differentiate between the two types of writes.

//2.7V Vcc Timing

// Changed the timings below to represent a "c3" device. --- RU 9/9/99

`define TAVAV_27            110

`define TAVQV_27            110

`define TELQV_27            110

`define TPHQV_27            150

`define TGLQV_27              0.1

`define TELQX_27              0

`define TEHQZ_27             20

`define TGLQX_27              0

`define TGHQZ_27             20

`define TOH_27                0

`define TPHWL_27            150

`define TWLWH_27             70

`define TDVWH_27             60

`define TAVWH_27             70

`define TWHDX_27              0

`define TWHAX_27              0

`define TWHWL_27             30

`define TVPWH_27            200

// The following constants control how long it take an algorithm to run

// to scale all times together (for making simulation run faster

// change the constant later listed as TimerPeriod.  The actual delays

// are TimerPeriod*xxx_Time, except for the suspend latency times.

`define TimerPeriod_        1000    //1 usec = 1000ns  requires for

                                    //following times to be accurate

// The typical values given in the datasheet are used.

// reducing the following will reduce simulation time

//2.7V Vcc, 12V Vpp

`define AC_ProgramTime_Word_27_12      8       //usecs

`define AC_EraseTime_Param_27_12       800000  //0.8secs

`define AC_EraseTime_Main_27_12        1100000 //1.1secs

 //Latency times are NOT multiplied by TimerPeriod_

`define AC_Program_Suspend_27_12       5000    //5 usecs

`define AC_Erase_Suspend_27_12         10000   //10 usecs

//2.7V Vcc 2.7V Vpp

`define AC_ProgramTime_Word_27_27      22       //usecs

`define AC_EraseTime_Param_27_27       1000000  //1sec

`define AC_EraseTime_Main_27_27        1800000  //1.8secs

 //Latency times are NOT multiplied by TimerPeriod_

`define AC_Program_Suspend_27_27       6000     //6 usecs

`define AC_Erase_Suspend_27_27         13000    //13 usecs

//generic defines for readability

`define FALSE           1'b0

`define TRUE            1'b1

`define Word            15:0

`define Byte            7:0

`define VIL             1'b0

`define VIH             1'b1

`define Ready           1'b1

`define Busy            1'b0

// These constants are the actual command codes

`define ClearCSRCmd     8'h50

`define ProgramCmd      8'h10

`define Program2Cmd     8'h40

`define EraseBlockCmd   8'h20

`define ReadArrayCmd    8'hFF

`define ReadCSRCmd      8'h70

`define ReadIDCmd       8'h90

`define SuspendCmd      8'hB0  //Valid for both erase

`define ResumeCmd       8'hD0  //and program suspend

`define ConfirmCmd      8'hD0

`define ReadMode_T      2:0

`define rdARRAY         3'b000

`define rdCSR           3'b011

`define rdID            3'b100

`define   Program           2'b00

`define   Erase             2'b01

// Cmd_T record

`define   Cmd_T             172:0

`define   CmdAdd_1          172:153

`define   CmdAdd_2          152:133

`define   Add               132:113

`define   CmdData_1         112:97

`define   CmdData_2         96:81

`define   Cmd               80:73

`define   Count             72:41

`define   Time              40:9

`define   Confirm           8

`define   OpBlock           7:2

`define   OpType            1:0

`define   CmdData1Fx8       104:97

`define WritePtr_T          1:0

`define NewCmd              2'b01

`define CmdField            2'b10

`define BlockType_T         1:0

`define MainBlock           2'b00

`define LockBlock           2'b01

`define ParamBlock          2'b10

`define Vcc2700             3'b100

`define Vcc3300             3'b010

`define Vcc5000             3'b001

// device specific

//module definition for Intel Advanced Boot Block Flash Memory Family

//

//vpp and vcc are are 32 bit vectors which are treated as unsigned int

//scale for vpp and vcc is millivolts.  ie. 0 = 0V, 5000 = 5V

//

module IntelAdvBoot(dq, addr, ceb, oeb, web, rpb, wpb, vpp, vcc);

inout [`MaxOutputs-1:0] dq;     //16 outputs

input [`AddrSize-1:0]   addr;   //address pins.

input                   ceb,    //CE# - chip enable bar

                        oeb,    //OE# - output enable bar

                        web,    //WE# - write enable bar

                        rpb,    //RP# - reset bar, powerdown

                        wpb;    //WP# = write protect bar

input [31:0]            vpp,    //vpp in millivolts

                        vcc;    //vcc in millivolts

reg [`Word]             MainArray[`MainArraySize];  //flash array

//  Flag to show that a Cmd has been written

//  and needs predecoding

reg       CmdValid ;

// This points to where data written to the part will

// go. By default it is to NewCmd. CmdField means the 

// chip is waiting on more data for the cmd (ie confirm)

reg [`WritePtr_T]   WriteToPtr ;

// Contains the current executing command and all its 

// support information.

reg  [`Cmd_T] Cmd;

reg  [`Cmd_T] Algorithm;

reg  [`Cmd_T] SuspendedAlg;

// Output of Data

reg [`Word]  ArrayOut ;

// Current output of the Compatible status register

reg [`Word]  CSROut ;

// Current output of the ID register

reg [`Word]  IDOut ;

//  Startup Flag phase

reg        StartUpFlag ;

//  Global Reset Flag

reg         Reset ;

//Vpp Monitoring

reg         VppFlag ;

reg         VppError ;

reg         VppErrFlag ;

reg         ClearVppFlag ;

// Internal representation of the CSR SR.1 bit

reg         BlockLockStatus;

// Internal representation of the CSR SR.4 bit

reg         ProgramError;

// Internal representation of the CSR SR.5 bit

reg         EraseError;

//  Internal representation of CUI modes

reg [`ReadMode_T] ReadMode ;

//  Current value of the CSR

wire [`Byte] CSR ;

//  Flag that determines if the chip is driving

//  the outputs

reg        DriveOutputs ;

//  Internal value of the out data.  If DriveOutputs

//  is active this value will be placed on the

//  outputs.  -1 == Unknown or XXXX

reg [`MaxOutputs-1:0]    InternalOutput ;

//  Number of addition writes necessary to 

//  supply the current command information.

//  When it hits zero it goes to Decode

integer       DataPtr ;

//  Master internal write enable

wire       Internal_WE ;

//  Master internal output enable

wire       Internal_OE ;

wire       Internal_OE2 ;

wire       Internal_OE3 ;

//  Master internal read enable

wire       Internal_RE ;

//  Master internal boot block write enable

reg         InternalBoot_WE ;

wire        InternalBoot;

//  Internal flag to tell if an algorithm is running

reg         ReadyBusy ;

//reg        RunningAlgorithm ;  *******************************

//  Flag to represent if the chip is write suspended

reg        WriteSuspended ;

//  Flag to represent if the chip is erase suspended

reg        EraseSuspended ;

// Flag for if the chip should be suspended

reg        Suspend ;

//  Variable to hold which algorithm (program or erase)

//  is to be suspended

reg [1:0]  ToBeSuspended;

//  Algorithm Timer

reg        TimerClk ;

//  Flag to show the running algorithm is done.

reg        AlgDone ;

// Number of timer cycles remaining for the 

// current algorithm

integer    AlgTime;

// Number of timer cycles remaining for erase operation

// when erase suspended and program operation in progress

integer    TimeLeft;

// Generic temporary varible

integer    LoopCntr ;

reg        Other ;

//Block begin and end address

reg [`AddrSize-1:0] BlocksBegin[0:`NumberOfBlocks-1];

reg [`AddrSize-1:0] BlocksEnd[0:`NumberOfBlocks-1];

reg [`BlockType_T] BlocksType[0:`NumberOfBlocks-1];

reg [31:0]  BlocksEraseCount[0:`NumberOfBlocks-1];

//************************************************************************

//TIMING VALUES

//************************************************************************

time    ToOut ;

time    last_addr_time ,curr_addr_time;

time    last_oe_time, curr_oe_time;

time    last_ce_time, curr_ce_time;

time    last_rp_time, curr_rp_time;

time    last_ReadMode_time, curr_ReadMode_time ;

time    last_Internal_RE_time, curr_Internal_RE_time ;

time    last_Internal_WE_time, curr_Internal_WE_time ;

time    last_dq_time ,curr_dq_time;

time    last_rpb_time, curr_rpb_time ;

time    WriteRecovery ;

time    TempTime;

time    Program_Time_Word;

time    Param_Erase_Time;

time    Main_Erase_Time;

time    Program_Suspend_Time;  // latency time

time    Erase_Suspend_Time;    // latency time

//************************************************************************

//input configuration

parameter

    LoadOnPowerup = `FALSE,        //load array from file

    LoadFileName = "f160b3.dat",   //File to load array with

    SaveOnPowerdown = `FALSE,      //save array to file

    SaveFileName = "f160b3.dat";   //save file name

//TIMING PARAMETERS

parameter

    TAVAV       =   `TAVAV_27,

    TAVQV       =   `TAVQV_27,

    TELQV       =   `TELQV_27,

    TPHQV       =   `TPHQV_27,

    TGLQV       =   `TGLQV_27,

    TELQX       =   `TELQX_27,

    TEHQZ       =   `TEHQZ_27,

    TGLQX       =   `TGLQX_27,

    TGHQZ       =   `TGHQZ_27,

    TOH         =   `TOH_27  ,

    TPHWL       =   `TPHWL_27,

    TWLWH       =   `TWLWH_27,

    TDVWH       =   `TDVWH_27,

    TAVWH       =   `TAVWH_27,

    TWHDX       =   `TWHDX_27,

    TWHAX       =   `TWHAX_27,

    TWHWL       =   `TWHWL_27,

    TVPWH       =   `TVPWH_27,

    TimerPeriod =   `TimerPeriod_;

//************************************************************************

initial begin

    Other               =       `FALSE  ;

    AlgDone             =       `FALSE  ;

    Reset               =       1'hx    ;

    Reset               <=      `TRUE   ;

    StartUpFlag         =       `TRUE   ;

    StartUpFlag         <=  #2  `FALSE  ;

    DriveOutputs        =       `FALSE  ;

    ToOut               =       0       ;

    VppError            =       `FALSE  ;

    VppErrFlag          =       `FALSE  ;

    ClearVppFlag        =       `FALSE  ;

    VppFlag             =       `FALSE  ;

    WriteSuspended      =       `FALSE  ;

    EraseSuspended      =       `FALSE  ;

    Suspend             =       `FALSE  ;

    ToBeSuspended       =       `Program;

    EraseError          =       `FALSE  ;

    TimerClk            =       1'b0    ;

    ArrayOut            =       `MaxOutputs'hxxxx ;

    CSROut              =       0       ;

    IDOut               =       0       ;

    CmdValid            =       `FALSE  ;

    WriteToPtr          =       `NewCmd ;

    last_addr_time      =       0       ;

    curr_addr_time      =       0       ;

    last_ce_time      =         0       ;

    curr_ce_time      =         0       ;

    last_oe_time      =         0       ;

    curr_oe_time      =         0       ;

    last_rp_time      =         0       ;

    curr_rp_time      =         0       ;

    last_ReadMode_time  =       0       ;

    curr_ReadMode_time  =       0       ;

    last_dq_time        =       0       ;

    curr_dq_time        =       0       ;

    last_rpb_time       =       0       ;

    curr_rpb_time       =       0       ;

    WriteRecovery       =       0       ;

    last_Internal_RE_time =     0       ;

    curr_Internal_RE_time =     0       ;

    InternalOutput        =     `MaxOutputs'hx     ;

    last_Internal_WE_time = 0           ;

    curr_Internal_WE_time = 0           ;

    Program_Time_Word    = `AC_ProgramTime_Word_27_12;

    Param_Erase_Time     = `AC_EraseTime_Param_27_12;

    Main_Erase_Time      = `AC_EraseTime_Main_27_12;

    Program_Suspend_Time = `AC_Program_Suspend_27_12;

    Erase_Suspend_Time   = `AC_Erase_Suspend_27_12;

    $readmemh(`BlockFileBegin,BlocksBegin);

    $readmemh(`BlockFileEnd,BlocksEnd);

    $readmemh(`BlockFileType,BlocksType,0,`NumberOfBlocks-1);

    for (LoopCntr = 0; LoopCntr <= `NumberOfBlocks; LoopCntr = LoopCntr + 1) begin

        BlocksEraseCount [LoopCntr] = 0 ;

    end

//------------------------------------------------------------------------

// Array Init

//------------------------------------------------------------------------

//Constant condition expression: LoadOnPowerup == 1'b1

    if (LoadOnPowerup)

        LoadFromFile;

    else begin

      //$display("Initializing Memory to 'hFFFF");

      //for (LoopCntr = 0; LoopCntr <= `MaxAddr; LoopCntr = LoopCntr + 1) begin

      //  MainArray [LoopCntr] = 16'hFFFF ;

      $display("FLASH: Initializing Memory data to address value (0, 1, 2 ...)");

      for (LoopCntr = 0; LoopCntr <= 1024; LoopCntr = LoopCntr + 1) begin

        MainArray [LoopCntr] = LoopCntr ;

      end

    end

end

//------------------------------------------------------------------------

// LoadFromFile

//  This is used when the LoadOnPowerup parameter is set so that the Main 

//  array contains code at startup.  Basically it loads the array from 

//  data in a file (LoadFileName).

//------------------------------------------------------------------------

task LoadFromFile ;

begin

    $display("FLASH: Loading from file %s",LoadFileName);

    $readmemh(LoadFileName,MainArray);

end

endtask

//------------------------------------------------------------------------

// StoreToFile

//  This is used when the SaveOnPowerDown flag is set so that the Main 

//  Array stores code at powerdown.  Basically it stores the array into

//  a file (SaveFileName).

//-----------------------------------------------------------------

task  StoreToFile;

    reg [31:0]  ArrayAddr ;

    reg [31:0]  outfile ;

begin

    outfile = $fopen(SaveFileName) ;

    if (outfile == 0)

        $display("FLASH: Error, cannot open output file %s",SaveFileName) ;

    else

        $display("FLASH: Saving data to file %s",SaveFileName);

    for (ArrayAddr = 0 ; ArrayAddr <= `MaxAddr; ArrayAddr = ArrayAddr + 1) begin

        $fdisplay(outfile,"%h",MainArray[ArrayAddr]);

    end

end

endtask

//------------------------------------------------------------------------

// Program  

// -- Description: Programs new values in to the array --

//------------------------------------------------------------------------

task  Program ;

  inout  [`Word] TheArrayValue ;

  input  [`Word] DataIn;

  reg    [`Word] OldData;

  begin

    OldData = TheArrayValue;

    TheArrayValue = DataIn & OldData;

  end

endtask

assign  Internal_OE = !(ceb | oeb | !rpb) ;

assign  Internal_OE2 = Internal_OE ;

assign  Internal_OE3 = Internal_OE2 ;

assign  Internal_RE = (((ReadyBusy == `Ready) || (ReadMode != `rdARRAY)) && !ceb && !Reset) ;

assign  Internal_WE = !(ceb | web | !rpb) ;

assign  InternalBoot = wpb ;

//******************************************************************

// Determine if the algorithm engine is operating

//assign  ReadyBusy = (RunningAlgorithm & !Suspended) ? `Busy : `Ready;

//******************************************************************

// register definitions //

// Compatible Status Register

assign  CSR [7] = ReadyBusy;

assign  CSR [6] = EraseSuspended ;

assign  CSR [5] = EraseError ;

assign  CSR [4] = ProgramError ;

assign  CSR [3] = VppError ;

assign  CSR [2] = WriteSuspended;

assign  CSR [1] = BlockLockStatus;

assign  CSR [0] = 1'b0;

// Output Drivers //

assign dq = (DriveOutputs == `TRUE) ? InternalOutput : 16'hz;

always @(Reset) begin : Reset_process

    if (Reset) begin

        ClearVppFlag    <=  #1  `TRUE   ;

        ClearVppFlag    <=  #9  `FALSE  ;

        AlgDone         =       `FALSE  ;

        VppError        =       `FALSE  ;

        ReadMode        =       `rdARRAY;

        ReadyBusy       =       `Ready  ;

        WriteSuspended  =       `FALSE  ;

        EraseSuspended  =       `FALSE  ;

        Suspend         =       `FALSE  ;

        EraseError      =       `FALSE  ;

        ProgramError    =       `FALSE  ;

        BlockLockStatus =       `FALSE  ;

        AlgTime         =       0       ;

        CmdValid        =       `FALSE  ;

        WriteToPtr      =       `NewCmd ;

        CSROut          =       0       ;

        IDOut           =       0       ;

    end

end

always @(Internal_RE or ReadMode or addr) begin : array_read

  if (Internal_RE && ReadMode == `rdARRAY) begin

    ArrayOut = MainArray[addr] ;      // x16 outputs

  end

end

always @(Internal_RE or ReadMode or addr or Internal_OE2 or ArrayOut) begin

    // output mux

    // Determine and generate the access time .

    ToOut = 0;

    if ($time > TAVQV) begin

        last_addr_time = $time - curr_addr_time;

        if ((last_addr_time < TAVQV) && ((TAVQV - last_addr_time) > ToOut))

            ToOut = TAVQV - last_addr_time ;

        last_oe_time = $time - curr_oe_time;

        if ((last_oe_time < TGLQV) && ((TGLQV - last_oe_time) > ToOut))

            ToOut = TGLQV - last_oe_time ;

        last_ce_time = $time - curr_ce_time;

        if ((last_ce_time < TELQV) && ((TELQV - last_ce_time) > ToOut))

            ToOut = TELQV - last_ce_time ;

        last_rp_time = $time - curr_rp_time;

        if ((last_rp_time < TPHQV) && ((TPHQV - last_rp_time) > ToOut))

            ToOut = TPHQV - last_rp_time ;

        last_ReadMode_time = $time - curr_ReadMode_time;

        if ((last_ReadMode_time < TAVQV) && ((TAVQV - last_ReadMode_time) > ToOut))

            ToOut = TAVQV - last_ReadMode_time ;

        last_Internal_RE_time = $time - curr_Internal_RE_time ;

        if ((last_Internal_RE_time < TAVQV) && ((TAVQV - last_Internal_RE_time) > ToOut)) begin

           ToOut = TAVQV - last_Internal_RE_time ;

            end

        end

//  Output Mux with timing

    if (!StartUpFlag) begin

         case (ReadMode)

            `rdARRAY : begin

              if ( (EraseSuspended == `TRUE) && (WriteSuspended == `FALSE)

                   && (addr >= BlocksBegin[Algorithm[`OpBlock]])

                   && (addr <= BlocksEnd[Algorithm[`OpBlock]]) && (oeb == `VIL) ) begin

                $display("FLASH: Error:  Attempting to read from erase suspended block");

                InternalOutput <= `MaxOutputs'hxxxx;

              end

              else if ( (WriteSuspended == `TRUE) && (EraseSuspended == `TRUE)

                       && (addr >= BlocksBegin[SuspendedAlg[`OpBlock]])

                       && (addr <= BlocksEnd[SuspendedAlg[`OpBlock]]) && (oeb == `VIL)) begin

                $display("FLASH: Error:  Attempting to read from erase suspended block");

                InternalOutput <= `MaxOutputs'hxxxx;

              end

              else if ( (WriteSuspended == `TRUE) && (addr == Algorithm[`CmdAdd_1])

                       && (oeb == `VIL) ) begin

                $display("FLASH: Error:  Attempting to read from write suspended address");

                InternalOutput = `MaxOutputs'hxxxx;

              end

              else

                InternalOutput <= #ToOut ArrayOut ;

            end

            `rdCSR   : begin

                InternalOutput <= #ToOut CSROut ;

            end

            `rdID    :  begin

                InternalOutput <= #ToOut IDOut ;

            end

            default  :  begin

                $display("FLASH: Error: illegal readmode");

            end

        endcase

    end

end

//

// other reads 

//

always @(Internal_OE or addr) begin : other_read

    if (!Reset) begin

        if (ReadMode != `rdARRAY) begin

            CSROut = {8'h00,CSR} ;

            if (addr[0] == 1'b0)

                IDOut = `ID_ManufacturerB ;

            else

                IDOut = `ID_DeviceCodeB ;

        end

    end

end

// Handle Write to Part

always @(negedge Internal_WE) begin : handle_write

  reg [`Word]   temp ;       // temporary variable needed for double

                             // indexing CmdData.

  if (!Reset) begin

    case (WriteToPtr)                        // Where are we writting to ?

      `NewCmd : begin                       // This is a new command.

         Cmd[`Cmd] = dq[7:0];

         Cmd[`Add] = addr[`AddrSize-1:0];   //by 16 word index

         CmdValid <= `TRUE ;                // CmdValid sends it to the Predecode section

         DataPtr <= -1;

       end

      `CmdField : begin   // This is data used by another command

         if (DataPtr == 1) begin

           Cmd[`CmdData_1] = dq[`Word];

           Cmd[`CmdAdd_1] = addr[`AddrSize-1:0];

         end

         else if (DataPtr == 2) begin

           Cmd[`CmdData_2] = dq[`Word];

           Cmd[`CmdAdd_2] = addr[`AddrSize-1:0];

         end

         else

           $display("FLASH: DataPtr out of range");

         DataPtr <= #1 DataPtr - 1 ; // When DataPtr = 0 the command goes to Decode section

       end

       default : begin

         $display("FLASH: Error: Write To ? Cmd");

       end

    endcase

  end

end

//

// Predecode Command

//

always @(posedge CmdValid) begin : predecode

  reg [`Byte] temp;       // temporary variable needed for double 

                          // indexing BSR.

  if (!Reset) begin

    // Set Defaults

    Cmd [`OpType] = `Program ;

    WriteToPtr = `NewCmd ;

    DataPtr <= 0 ;

    case (Cmd [`Cmd])            // Handle the basic read mode commands

    // READ ARRAY COMMAND --

      `ReadArrayCmd  : begin     // Read Flash Array

         CmdValid <= `FALSE ;

         if (ReadyBusy == `Busy) // Can not read array when running an algorithm

           ReadMode <= `rdCSR ;

         else

           ReadMode <= `rdARRAY ;

       end

    // READ INTELLIGENT IDENTIFIER COMMAND --

      `ReadIDCmd     :  begin    // Read Intelligent ID

         if ((WriteSuspended == `TRUE) || (EraseSuspended == `TRUE))

           $display("FLASH: Invalid read ID command during suspend");

         else

           ReadMode <= `rdID ;

         CmdValid <= `FALSE ;