Subversion Repositories openrisc

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

// 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 Data Flash Device

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

// File         : $RCSfile: AT26DFxxx.v,v $

// Path         : $Source: /home/cvs/atmel_flash_dev/design_26x/AT26DFxxx.v,v $

// Author       : $ Devi Vasumathy N $

// Created on   : $ 13-03-07 $

// Revision     : $Revision: 1.8 $

// Last modified by : $Author: devivasumathy $

// Last modified on : $Date: 2007/05/10 05:15:51 $

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

// Module               : AT26DFxxx.v

// Description          : BFM for devices AT25DF041A, AT26DF081A, 

//                        AT26DF161A, AT26DF321

//

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

//

// Design hierarchy : _top.v/top_1.v/top_2.v/...

// Instantiated Modules : top_1.v, top_2.v

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

// Revision history :

// $Log: AT26DFxxx.v,v $

// Revision 1.8  2007/05/10 05:15:51  devivasumathy

// Card Memory preload

//

// Revision 1.7  2007/04/27 09:09:40  devivasumathy

// *** empty log message ***

//

// Revision 1.6  2007/04/17 10:50:59  devivasumathy

// Timing verified

//

// Revision 1.5  2007/04/16 06:24:44  devivasumathy

// *** empty log message ***

//

// Revision 1.4  2007/04/10 09:37:36  devivasumathy

// *** empty log message ***

//

// Revision 1.3  2007/04/09 12:06:09  devivasumathy

// *** empty log message ***

//

// Revision 1.2  2007/04/05 14:45:12  devivasumathy

// *** empty log message ***

//

// Revision 1.1  2007/04/05 11:32:18  devivasumathy

// AT26DFx data flash model

//

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

`timescale 1ns/10ps      //ME added

`define def_321 1        //ME added

module AT26DFxxx (

                CSB,

                SCK,

                SI,

                WPB,

`ifdef def_321

`else

                HOLDB,

`endif

                SO);

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

//                      Port Declaration:

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

input   CSB;            // Chip Select!

input   SCK;            // Serial Clock

input   SI;             // Serial Input

input   WPB;            // Write Protect!

`ifdef def_321

`else

input   HOLDB;          // Hold!

`endif

output  SO;             // Serial Output

`ifdef def_321

        wire  HOLDB;

`endif

parameter DEVICE = "AT25DF041A";        // Device selected

parameter PRELOAD = 1;                  // preload memory with content in MEMORY_FILE

parameter MEMORY_FILE = "flash.in";     // Memory pre-load

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

//Timing Parameters :

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

// Fixed parameters

parameter fRDLF   = 33;         // SCK Frequency for read Array (Low freq - 03h opcode)

//representation in ns

parameter tDIS    = 6;          // Output Disable time

parameter tV      = 6;          // Output Valid time

parameter tOH     = 0 ;          // Output Hold time

parameter tHLQZ   = 6 ;         // HOLD! Low to Output High-z

parameter tHHQX   = 6 ;         // HOLD! High to Output Low-z

parameter tSECP   = 20;         // Sector Protect Time

parameter tSECUP  = 20;         // Sector Unprotect Time

parameter tEDPD   = 3000;       // Chip Select high to Deep Power-down (3 us)

parameter tRDPD   = 3000;       // Chip Select high to Stand-by Mode

parameter tWRSR   = 200;        // Write Status Register Time

parameter tPP     = 5000000;    // Page Program Time

parameter tBLKE4  = 200000000;  // Block Erase Time 4-kB

parameter tBLKE32 = 600000000;  // Block Erase Time 32-kB

parameter tCHPEn  = 1000000000; // local chip erase time

// variable parameters

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

//parameter tBP     = 7000;             // Byte Program Time

//parameter tBLKE64 = 950000000;        // Block Erase Time 64-kB

//parameter tCHPE   = 3000000000;       // Chip Erase Time // this is actual;

                                        // due to simulation warning splitted into 2 parameters as tCHPE = tmult * tCHPEn

//parameter tmult   = 3;                // Multiplication factor for chip erase timing

parameter tBP =         (DEVICE == "AT25DF041A") ? 7000 :

                        (DEVICE == "AT26DF081A") ? 7000 :

                        (DEVICE == "AT26DF161A") ? 7000 :

                        (DEVICE == "AT26DF321")  ? 6000 : 7000;

parameter tBLKE64 =     (DEVICE == "AT25DF041A") ? 950000000 :

                        (DEVICE == "AT26DF081A") ? 950000000 :

                        (DEVICE == "AT26DF161A") ? 950000000 :

                        (DEVICE == "AT26DF321")  ? 1000000000 :950000000 ;

parameter tmult =       (DEVICE == "AT25DF041A") ? 3 :

                        (DEVICE == "AT26DF081A") ? 6 :

                        (DEVICE == "AT26DF161A") ? 12 :

                        (DEVICE == "AT26DF321")  ? 36 : 3;

//parameter fSCK    = 70;       // Serial clock (SCK) Frequency in MHz

//parameter tSCKH   = 6.4;      // SCK High time

//parameter tSCKL   = 6.4;      // SCK Low time

parameter fSCK =        (DEVICE == "AT25DF041A") ? 70 :

                        (DEVICE == "AT26DF081A") ? 70 :

                        (DEVICE == "AT26DF161A") ? 70 :

                        (DEVICE == "AT26DF321")  ? 66 : 70;

parameter tSCKH =       (DEVICE == "AT25DF041A") ? 6.4 :

                        (DEVICE == "AT26DF081A") ? 6.4 :

                        (DEVICE == "AT26DF161A") ? 6.4 :

                        (DEVICE == "AT26DF321")  ? 6.8 : 6.4;

parameter tSCKL =       (DEVICE == "AT25DF041A") ? 6.4 :

                        (DEVICE == "AT26DF081A") ? 6.4 :

                        (DEVICE == "AT26DF161A") ? 6.4 :

                        (DEVICE == "AT26DF321")  ? 6.8 : 6.4;

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

// ********************** Manufacturer ID ********************** //

parameter [31:0] MAN_ID = (DEVICE == "AT25DF041A") ? 32'h1F_04_00_00 :

                        (DEVICE == "AT26DF081A") ? 32'h1F_45_01_00 :

                        (DEVICE == "AT26DF161A") ? 32'h1F_46_01_00 :

                        (DEVICE == "AT26DF321")  ? 32'h1F_47_00_00 : 32'h1F_04_00_00;

// ********* Memory And Access Related Declarations ***************** //

parameter BLOCK64 =     (DEVICE == "AT25DF041A") ? 8  : // no of 64kB blocks

                        (DEVICE == "AT26DF081A") ? 16 :

                        (DEVICE == "AT26DF161A") ? 32 :

                        (DEVICE == "AT26DF321")  ? 64 : 8 ;

parameter SECTOR =      (DEVICE == "AT25DF041A") ? 11 : // no of sectors

                        (DEVICE == "AT26DF081A") ? 19 :

                        (DEVICE == "AT26DF161A") ? 32 :

                        (DEVICE == "AT26DF321")  ? 64 : 11 ;

// total memory size = no. of blocks * 64 k bits (i.e each block contains 64 KB)

parameter MEMSIZE = BLOCK64 * 64 * 1024; // total memory size

reg [7:0] memory [MEMSIZE-1:0]; // memory of selected device

reg [7:0] status_reg;            // Status register

reg [63:0] sector_reg;           // Sector protection reg

reg [7:0] int_buffer [255:0];     // internal buffer to store data in page programming mode

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

// ********* Registers to track the current operation of the device ******** //

reg deep_power_down;            // Device in Deep Power Down Mode

reg status_read;                // Status register is being read

reg erasing_block4;             // 4kB block erase

reg erasing_block32;            // 32kB block erase

reg erasing_block64;            // 64kB block erase

reg erasing_chip;               // chip erase

reg rd_dummy;                   // low/high freq read array

reg byte_prog;                  // Byte/page programming

reg seq_byte_prog;              // sequential byte programming

reg seq_byte_start;             // sequential byte programming start intimation

// ********* Events to trigger some task based on opcode *********** //

event  EDPD;            // Deep Power-down (enable)

event  RDPD;            // Resume from Deep Power-down

event  RA;              // Read Array

//event  RAL;           // Read Array (Low frequency)

event  BE4;             // Block Erase 4KB

event  BE32;            // Block Erase 32KB

event  BE64;            // Block Erase 64KB

event  CE;              // Chip Erase

event  BP;              // byte /page program

//event  SBPE;          // Sequential Byte Program Mode Erase

event  SBP;             // Sequential Byte Program

event  WE;              // Write Enable

event  WD;              // Write Disable

event  PS;              // Protect Sector

event  UPS;             // Un-Protect Sector

event  RSPR;            // Read Sector Protection Register

event  RSR;             // Read Status Register

event  WSR;             // Write Status Register

event  MIR;             // Manufacturer ID Read 

/******** Other variables/registers ******************/

reg [23:0] temp_addr;            // to store mem address temporarily

reg [23:0] current_address;      // to store mem address

reg [7:0] temp_data;             // temp read data from memory

reg [7:0] data_in;               // data in for byte programming

reg [7:0] read_data;             // register in which opcode/data is read-in

reg [7:0] read_dummy;            // register in which dont care data is stored

reg [3:0] stat_reg_temp; // WSR temp value for global protec/unprotect

reg [7:0] pp_address;            // specifies the page address for BP/PP

reg SO_reg;                     // Signal out reg

reg SO_on;                      // Signal out enable signal

reg SPRL;                       // Sector Protection Register Locked

reg SPM;                        // Sequential Program Mode Status

reg EPE;                        // Erase/Program Error

reg WPP;                        // Write Protection Pin Status

reg [1:0] SWP;                   // Software Protection Status

reg WEL;                        // Write Enable Latch Status

reg RDYnBSY;                    // Ready/Busy Status

reg lock;                       // to lock SPRL bit of status reg

reg unlock;                     // to unlock SPRL bit of status reg

reg global_protect;             // global protection

reg global_unprotect;           // global unprotect

reg protect;                    // to protect Sector reg bits

reg unprotect;                  // to unprotect Sector reg bits

reg protected;                  // check protection status of sector reg

reg SPRL_val;                   // WSR temp value for SPRL

integer i,j,k,l;                // integers for accessing memory

integer pp;                     // specifies no of bytes need to write in memory

integer pp_j;                   // holds no of bytes received for page program

integer pp_i;                   // holds no of bits received for each byte in page program

integer dummy;                  // counter for receiving 8 dummy bit from SO

integer delay;                  // waits for Chip Erase to complete

real tperiod;                   // time period - on period

real tperiod1;                  // time period - off period

reg freq_error;                 // frequency limit exceeds indication

// ****************** Initial Block **************** //

`ifdef def_321

        assign HOLDB = 1'b1;

`endif

initial

begin

// Memory Initialization

//To pre-load Memory (in Hex format), use parameter MEMORY_FILE = <filename>, 

//where <filename> is the name of the pre-load file. 

//If PRELOAD = 0, the Memory is initialized to Erased state (all data = FF).

//If PRELOAD = 1, the Memory is initialized to PreLoad state (data in pre-load file).

        for(i=0; i<BLOCK64; i=i+1)                       // Block64K access

        begin

            for(j=0; j<2; j=j+1)                 // Block32K access

            begin

                for(k=0; k<8; k=k+1)                     // Block4K access

                begin

                    for(l=0; l < 12'hfff; l=l+1)

                    begin

                        memory[l] = 8'b11111111;

                    end

                end

            end

        end

// Memory Initialization for preloading condition

if(PRELOAD==1)

begin

        $readmemh (MEMORY_FILE, memory);

end

// Status register initialization

SPRL = 1'b0;

SPM = 1'b0;

EPE = 1'b0;

WPP = 1'b0;

SWP = 2'b11;

WEL = 1'b0;

RDYnBSY = 1'b0; // device is ready

status_reg[7]   = SPRL;

status_reg[6]   = SPM;

status_reg[5]   = EPE; // reserved

status_reg[4]   = WPP;

status_reg[3:2] = SWP;

status_reg[1]   = WEL;

status_reg[0]    = RDYnBSY;

//status_reg = {1'b1,1'b0,1'b0,1'b0,2'b11,2'b0};

sector_reg = 64'hFFFFFFFFFFFFFFFF;

// Stand-by mode initialization

current_address  = 24'b0;

data_in          = 8'b0;

stat_reg_temp    = 4'b0;

deep_power_down  = 1'b0;

status_read      = 1'b0;

rd_dummy         = 1'b0;

seq_byte_start   = 1'b0;

SO_on            = 1'b0;

global_protect   = 1'b0;

global_unprotect = 1'b0;

SPRL_val         = 1'b0;

lock             = 1'b0;

unlock           = 1'b0;

dummy            = 0;

deep_power_down = 1'b0;

status_read     = 1'b0;

erasing_block4  = 1'b0;

erasing_block32 = 1'b0;

erasing_block64 = 1'b0;

erasing_chip    = 1'b0;

rd_dummy        = 1'b0;

byte_prog       = 1'b0;

seq_byte_prog   = 1'b0;

seq_byte_start  = 1'b0;

end // end of initial

// ********************** Drive SO ********************* //

bufif1 (SO, SO_reg, SO_on); //SO will be driven only if SO_on is High

// global protection and unprotection on sectors

always@(global_protect or global_unprotect)

begin

        if(global_protect==1'b1)

                sector_reg = 64'hFFFFFFFFFFFFFFFF;

        else if(global_unprotect==1'b1)

                sector_reg[SECTOR-1:0] = 'b0;

end

// ********************* Status register ********************* //

always @(WPB or lock or unlock) //SPRL bit locking & Unlocking

begin

        if(WPB==1'b1 && SPRL==1'b0 && lock==1'b1)

                SPRL = 1'b1;

        else if(WPB==1'b1 && SPRL==1'b1 && unlock==1'b1)

                SPRL = 1'b0; // S/W Locked

        else if(WPB==1'b0 && SPRL==1'b0 && lock==1'b1)

                SPRL = 1'b1;

        else if(WPB==1'b0 && SPRL==1'b1 && unlock==1'b1)

                SPRL = 1'b1; // H/W Locked

end

always @(WPB)                   // Write Protect (WP!) Pin Status

begin

        WPP = WPB;

end

always @(sector_reg)            // Software Protection Status

begin

        if(sector_reg[SECTOR-1:0]=='d0)

                SWP = 2'b00;

        else if((|sector_reg==1'b1) && (&sector_reg==1'b0))

                SWP = 2'b01;

        else if(&sector_reg==1'b1)

                SWP = 2'b11;

end

always @(SPRL or SPM or EPE or WPP or SWP or WEL or RDYnBSY)

begin

        status_reg = {SPRL,SPM,EPE,WPP,SWP,WEL,RDYnBSY};

end

// ******* to receive opcode and to switch to respective blocks ******* //

always @(negedge CSB)  // the device will now become active

begin : get_opcode_

        //@(negedge SCK);

        get_opcode;  // get opcode here

        if (deep_power_down == 1'b1) // Can be only after background has been enabled

                case (read_data)

                        8'hAB:  // Resume from Deep Power-down

                        begin

                                $display("Opcode(%h) for Resume from Deep Power-down received",read_data);

                                -> RDPD;

                        end

                        default :

                        begin

                                $display ("Opcode %h is not allowed: device in Deep Power-down", read_data);

                                disable get_opcode_;

                        end

                endcase

        else

        begin

                case (read_data)        // based on opcode, trigger an action

                8'h0B : // Read Array

                        begin

                                $display("Opcode(%h) for Read Array received",read_data);

                                rd_dummy = 1'b1;

                                -> RA;

                        end

                8'h03 : // Read Array (low freq)

                  begin

                     // Comment out this to clean up sim output

                     //$display("Opcode(%h) for Read Array (Low Freq) received",read_data);

                     rd_dummy = 1'b0;

                     -> RA;

                        end

                8'h20 : // Block erase 4 KB

                        begin

                                $display("Opcode(%h) for 4 KB Block erase received",read_data);

                                -> BE4;

                        end

                8'h52 : // Block erase 32 KB

                        begin

                                $display("Opcode(%h) for 32 KB Block erase received",read_data);

                                -> BE32;

                        end

                8'hD8 : // Block erase 64 KB

                        begin

                                $display("Opcode(%h) for 64 KB Block erase received",read_data);

                                -> BE64;

                        end

                8'h60 : // Chip erase

                        begin

                                $display("Opcode(%h) for Chip erase received",read_data);

                                -> CE;

                        end

                8'hC7 : // Chip erase

                        begin

                                $display("Opcode(%h) for Chip erase received",read_data);

                                -> CE;

                        end

                8'h02 : // Byte Program

                        begin

                                $display("Opcode(%h) Byte Program received",read_data);

                                -> BP;

                        end

                8'hAD : // Sequential Byte Program Mode Erase

                        begin

                                if(DEVICE=="AT25DF041A" || DEVICE=="AT26DF081A" || DEVICE=="AT26DF161A")

                                begin

                                        $display("Opcode(%h) Sequential Byte Program received",read_data);

                                        -> SBP;

                                end

                                else if(DEVICE=="AT26DF321")

                                        $display("Sequential Byte Program is not supported for device %s",DEVICE);

                        end

                8'hAF : // Sequential Byte Program Mode

                        begin

                                if(DEVICE=="AT25DF041A" || DEVICE=="AT26DF081A" || DEVICE=="AT26DF161A")

                                begin

                                        $display("Opcode(%h) Sequential Byte Program received",read_data);

                                        -> SBP;

                                end

                                else if(DEVICE=="AT26DF321")

                                        $display("Sequential Byte Program is not supported for device %s",DEVICE);

                        end

                8'h06 : // Write Enable

                        begin

                                $display("Opcode(%h) for Write Enable received",read_data);

                                -> WE;

                        end

                8'h04 : // Write Disable

                        begin

                                $display("Opcode(%h) for Write Disable received",read_data);

                                -> WD;

                        end

                8'h36 : // Protect Sector

                        begin

                                $display("Opcode(%h) for Protect Sector received",read_data);

                                -> PS;

                        end

                8'h39 : // Unprotect Sector

                        begin

                                $display("Opcode(%h) for Unprotect Sector received",read_data);

                                -> UPS;

                        end

                8'h3C : // Read Sector Protection Register

                        begin

                                $display("Opcode(%h) for Read Sector Protection Register received",read_data);

                                -> RSPR;

                        end

                8'h05 : // Read Status Register

                        begin

                                $display("Opcode(%h) for Status Register Read received",read_data);

                                -> RSR;

                        end

                8'h01 : // Write Status Register

                        begin

                                $display("Opcode(%h) for Write Status Register received",read_data);

                                -> WSR;

                        end

                8'h9F : // Read Manufacturer and Device ID

                        begin

                                $display("Opcode(%h) for Read Manufacturer and Device ID received",read_data);

                                -> MIR;

                        end

                8'hB9 : // Deep Power-down

                        begin

                                $display("Opcode(%h) for Deep Power-down received",read_data);

                                -> EDPD;

                        end

                default :

                begin

                        $display ("Unrecognized opcode %h", read_data);

                        disable get_opcode_;

                end

                endcase

        end

end

// *********************** TASKS / FUNCTIONS ************************** //

// get_opcode is a task to get 8 bits of opcode.

// It obtains 8 bits of data obtained on SI

task get_opcode;

integer i;

begin

        for (i=8; i>0; i = i-1)

        begin

                @(posedge SCK);

                read_data[i-1] = SI;

                if(HOLDB==1'b0)

                        wait (HOLDB);

        end

        i=7;

end

endtask

// get_data is a task to get 8 bits of data. This data could be an address,

// data or anything. It just obtains 8 bits of data obtained on SI

task get_data;

integer i;

begin

        for (i=7; i>=0; i = i-1)

        begin

                @(posedge SCK);

                read_data[i] = SI;

                if(HOLDB==1'b0)

                        wait (HOLDB);

        end

        i=7;

end

endtask

// task read_out_array is to read from main Memory

task read_out_array ;

input [23:0] read_addr;

integer i;

begin

        temp_data = memory [read_addr];

        i = 7;

        while (CSB == 1'b0) // continue transmitting, while, CSB is Low

        begin

                @(negedge SCK);

                SO_reg = 1'bx;

                if(HOLDB==1'b0)

                begin

                        #tHLQZ SO_on = 1'b0;

                        wait (HOLDB);

                        #tHHQX;

                end

                #tV SO_reg = temp_data[i];

                SO_on = 1'b1;

                if (i == 0)

                begin

                        //$display ("Data: %h read from memory location %h",temp_data,read_addr);

                        read_addr = read_addr + 1; // next byte

                        i = 7;

                        if (read_addr >= (MEMSIZE-1))

                                read_addr = 0; // Note that rollover occurs at end of memory,

                        temp_data = memory [read_addr];

                end

                else

                        i = i - 1; // next bit

        end // reading over, because CSB has gone high

end

endtask

// Sector protection

task protect_sector;

input [23:0] protect_address;

begin

        $display("Entered Protect Sector task");

    if (DEVICE == "AT26DF321" && protect==1'b1)

    begin

        if(protect_address[23:16]==8'b00111111)

                sector_reg[63] = 1'b1;

        else if(protect_address[23:16]==8'b00111110)

                sector_reg[62] = 1'b1;

        else if(protect_address[23:16]==8'b00111101)

                sector_reg[61] = 1'b1;

        else if(protect_address[23:16]==8'b00111100)

                sector_reg[60] = 1'b1;

        else if(protect_address[23:16]==8'b00111011)

                sector_reg[59] = 1'b1;

        else if(protect_address[23:16]==8'b00111010)

                sector_reg[58] = 1'b1;

        else if(protect_address[23:16]==8'b00111001)

                sector_reg[57] = 1'b1;

        else if(protect_address[23:16]==8'b00111000)

                sector_reg[56] = 1'b1;

        else if(protect_address[23:16]==8'b00110111)

                sector_reg[55] = 1'b1;

        else if(protect_address[23:16]==8'b00110110)

                sector_reg[54] = 1'b1;

        else if(protect_address[23:16]==8'b00110101)

                sector_reg[53] = 1'b1;

        else if(protect_address[23:16]==8'b00110100)

                sector_reg[52] = 1'b1;

        else if(protect_address[23:16]==8'b00110011)