URL https://opencores.org/ocsvn/qspiflash/qspiflash/trunk

Subversion Repositories qspiflash

[/] [qspiflash/] [trunk/] [rtl/] [wbqspiflash.v] - Blame information for rev 24

Go to most recent revision | Details | Compare with Previous | View Log


////////////////////////////////////////////////////////////////////////////////
//
// Filename:    wbspiflash.v
//
// Project:     A Set of Wishbone Controlled SPI Flash Controllers
//
// Purpose:     Access a Quad SPI flash via a WISHBONE interface.  This
//              includes both read and write (and erase) commands to the SPI
//              flash.  All read/write commands are accomplished using the
//              high speed (4-bit) interface.  Further, the device will be
//              left/kept in the 4-bit read interface mode between accesses,
//              for a minimum read latency.
//
//      Wishbone Registers (See spec sheet for more detail):
//      0: local config(r) / erase commands(w) / deep power down cmds / etc.
//      R: (Write in Progress), (dirty-block), (spi_port_busy), 1'b0, 9'h00,
//              { last_erased_sector, 14'h00 } if (WIP)
//              else { current_sector_being_erased, 14'h00 }
//              current if write in progress, last if written
//      W: (1'b1 to erase), (12'h ignored), next_erased_block, 14'h ignored)
//      1: Configuration register
//      2: Status register (R/w)
//      3: Read ID (read only)
//      (19 bits): Data (R/w, but expect writes to take a while)
//              
//
// Creator:     Dan Gisselquist, Ph.D.
//              Gisselquist Technology, LLC
//
////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2015-2019, Gisselquist Technology, LLC
//
// This file is part of the set of Wishbone controlled SPI flash controllers
// project
//
// The Wishbone SPI flash controller project is free software (firmware):
// you can redistribute it and/or modify it under the terms of the GNU Lesser
// General Public License as published by the Free Software Foundation, either
// version 3 of the License, or (at your option) any later version.
//
// The Wishbone SPI flash controller project is distributed in the hope
// that it will be useful, but WITHOUT ANY WARRANTY; without even the implied
// warranty of MERCHANTIBILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with this program.  (It's in the $(ROOT)/doc directory.  Run make
// with no target there if the PDF file isn't present.)  If not, see
// <http://www.gnu.org/licenses/> for a copy.
//
// License:     LGPL, v3, as defined and found on www.gnu.org,
//              http://www.gnu.org/licenses/lgpl.html
//
//
////////////////////////////////////////////////////////////////////////////////
//
//
//
`default_nettype        none
//
`define WBQSPI_RESET            5'd0
`define WBQSPI_RESET_QUADMODE   5'd1
`define WBQSPI_IDLE             5'd2
`define WBQSPI_RDIDLE           5'd3    // Idle, but in fast read mode
`define WBQSPI_WBDECODE         5'd4
`define WBQSPI_RD_DUMMY         5'd5
`define WBQSPI_QRD_ADDRESS      5'd6
`define WBQSPI_QRD_DUMMY        5'd7
`define WBQSPI_READ_CMD         5'd8
`define WBQSPI_READ_DATA        5'd9
`define WBQSPI_WAIT_TIL_RDIDLE  5'd10
`define WBQSPI_READ_ID_CMD      5'd11
`define WBQSPI_READ_ID          5'd12
`define WBQSPI_READ_STATUS      5'd13
`define WBQSPI_READ_CONFIG      5'd14
`define WBQSPI_WAIT_TIL_IDLE    5'd15
//
//
`define WBQSPI_WAIT_WIP_CLEAR   5'd16
`define WBQSPI_CHECK_WIP_CLEAR  5'd17
`define WBQSPI_CHECK_WIP_DONE   5'd18
`define WBQSPI_WEN              5'd19
`define WBQSPI_PP               5'd20   // Program page
`define WBQSPI_QPP              5'd21   // Program page, 4 bit mode
`define WBQSPI_WR_DATA          5'd22
`define WBQSPI_WR_BUS_CYCLE     5'd23
`define WBQSPI_WRITE_STATUS     5'd24
`define WBQSPI_WRITE_CONFIG     5'd25
`define WBQSPI_ERASE_WEN        5'd26
`define WBQSPI_ERASE_CMD        5'd27
`define WBQSPI_ERASE_BLOCK      5'd28
`define WBQSPI_CLEAR_STATUS     5'd29
`define WBQSPI_IDLE_CHECK_WIP   5'd30
//
module  wbqspiflash(i_clk,
                // Internal wishbone connections
                i_wb_cyc, i_wb_data_stb, i_wb_ctrl_stb, i_wb_we,
                i_wb_addr, i_wb_data,
                // Wishbone return values
                o_wb_ack, o_wb_stall, o_wb_data,
                // Quad Spi connections to the external device
                o_qspi_sck, o_qspi_cs_n, o_qspi_mod, o_qspi_dat, i_qspi_dat,
                o_interrupt);
        parameter       ADDRESS_WIDTH=22;
        parameter [0:0]   OPT_READ_ONLY = 1'b0;
        localparam      AW = ADDRESS_WIDTH-2;
        input   wire            i_clk;
        // Wishbone, inputs first
        input   wire            i_wb_cyc, i_wb_data_stb, i_wb_ctrl_stb, i_wb_we;
        input   wire    [(AW-1):0]       i_wb_addr;
        input   wire    [31:0]   i_wb_data;
        // then outputs
        output  reg             o_wb_ack;
        output  reg             o_wb_stall;
        output  reg     [31:0]   o_wb_data;
        // Quad SPI control wires
        output  wire            o_qspi_sck, o_qspi_cs_n;
        output  wire    [1:0]    o_qspi_mod;
        output  wire    [3:0]    o_qspi_dat;
        input   wire    [3:0]    i_qspi_dat;
        // Interrupt line
        output  reg             o_interrupt;
        // output       wire    [31:0]  o_debug;
 
        reg             spi_wr, spi_hold, spi_spd, spi_dir;
        reg     [31:0]   spi_in;
        reg     [1:0]    spi_len;
        wire    [31:0]   spi_out;
        wire            spi_valid, spi_busy;
        wire            w_qspi_sck, w_qspi_cs_n;
        wire    [3:0]    w_qspi_dat;
        wire    [1:0]    w_qspi_mod;
        // wire [22:0]  spi_dbg;
        llqspi  lldriver(i_clk,
                        spi_wr, spi_hold, spi_in, spi_len, spi_spd, spi_dir,
                                spi_out, spi_valid, spi_busy,
                        w_qspi_sck, w_qspi_cs_n, w_qspi_mod, w_qspi_dat,
                                i_qspi_dat);
 
        // Erase status tracking
        reg             write_in_progress, write_protect;
        reg     [(ADDRESS_WIDTH-17):0]   erased_sector;
        reg             dirty_sector;
        initial begin
                write_in_progress = 1'b0;
                erased_sector = 0;
                dirty_sector  = 1'b1;
                write_protect = 1'b1;
        end
 
        wire    [23:0]   w_wb_addr;
        generate
        if (ADDRESS_WIDTH>=24)
                assign w_wb_addr = { i_wb_addr[21:0], 2'b00 };
        else
                assign w_wb_addr = { {(24-ADDRESS_WIDTH){1'b0}}, i_wb_addr, 2'b00 };
        endgenerate
 
        // Repeat for spif_addr
        reg     [(ADDRESS_WIDTH-3):0]    spif_addr;
        wire    [23:0]   w_spif_addr;
        generate
        if (ADDRESS_WIDTH>=24)
                assign w_spif_addr = { spif_addr[21:0], 2'b00 };
        else
                assign w_spif_addr = { {(24-ADDRESS_WIDTH){1'b0}}, spif_addr, 2'b00 };
        endgenerate
 
        reg     [7:0]    last_status;
        reg     [9:0]    reset_counter;
        reg             quad_mode_enabled;
        reg             spif_cmd, spif_override;
        reg     [31:0]   spif_data;
        reg     [4:0]    state;
        reg             spif_ctrl, spif_req;
        reg             alt_cmd, alt_ctrl;
        wire    [(ADDRESS_WIDTH-17):0]   spif_sector;
        assign  spif_sector = spif_addr[(AW-1):14];
 
        // assign       o_debug = { spi_wr, spi_spd, spi_hold, state, spi_dbg };
 
        initial state = `WBQSPI_RESET;
        initial o_wb_ack   = 1'b0;
        initial o_wb_stall = 1'b1;
        initial spi_wr     = 1'b0;
        initial spi_len    = 2'b00;
        initial quad_mode_enabled = 1'b0;
        initial o_interrupt = 1'b0;
        initial spif_override = 1'b1;
        initial spif_ctrl     = 1'b0;
        always @(posedge i_clk)
        begin
        spif_override <= 1'b0;
        alt_cmd  <= (reset_counter[9:8]==2'b10)?reset_counter[3]:1'b1; // Toggle CS_n
        alt_ctrl <= (reset_counter[9:8]==2'b10)?reset_counter[0]:1'b1; // Toggle clock too
        if (state == `WBQSPI_RESET)
        begin
                // From a reset, we should
                //      Enable the Quad I/O mode
                //      Disable the Write protection bits in the status register
                //      Chip should already be up and running, so we can start
                //      immediately ....
                o_wb_ack <= 1'b0;
                o_wb_stall <= 1'b1;
                spi_wr   <= 1'b0;
                spi_hold <= 1'b0;
                spi_spd  <= 1'b0;
                spi_dir  <= 1'b0;
                last_status <= 8'h00;
                state <= `WBQSPI_RESET_QUADMODE;
                spif_req <= 1'b0;
                spif_override <= 1'b1;
                last_status   <= 8'h00; //
                reset_counter <= 10'h3fc; //
                        // This guarantees that we aren't starting in quad
                        // I/O mode, where the FPGA configuration scripts may
                        // have left us.
        end else if (state == `WBQSPI_RESET_QUADMODE)
        begin
                // Okay, so here's the problem: we don't know whether or not
                // the Xilinx loader started us up in Quad Read I/O idle mode.
                // So, thus we need to toggle the clock and CS_n, with fewer
                // clocks than are necessary to transmit a word.
                //
                // Not ready to handle the bus yet, so stall any requests
                o_wb_ack   <= 1'b0;
                o_wb_stall <= 1'b1;
 
                // Do something ...
                if (reset_counter == 10'h00)
                begin
                        spif_override <= 1'b0;
                        state <= `WBQSPI_IDLE;
 
                        // Find out if we can use Quad I/O mode ...
                        state <= `WBQSPI_READ_CONFIG;
                        spi_wr <= 1'b1;
                        spi_len <= 2'b01;
                        spi_in <= { 8'h35, 24'h00};
 
                end else begin
                        reset_counter <= reset_counter - 10'h1;
                        spif_override <= 1'b1;
                end
        end else if (state == `WBQSPI_IDLE)
        begin
                o_interrupt <= 1'b0;
                o_wb_stall <= 1'b0;
                o_wb_ack <= 1'b0;
                spif_cmd   <= i_wb_we;
                spif_addr  <= i_wb_addr;
                spif_data  <= i_wb_data;
                spif_ctrl  <= (i_wb_ctrl_stb)&&(!i_wb_data_stb);
                spif_req   <= (i_wb_ctrl_stb)||(i_wb_data_stb);
                spi_wr <= 1'b0; // Keep the port idle, unless told otherwise
                spi_hold <= 1'b0;
                spi_spd  <= 1'b0;
                spi_dir <= 1'b0; // Write (for now, 'cause of cmd)
                // Data register access
                if (i_wb_data_stb)
                begin
 
                        if ((OPT_READ_ONLY)&&(i_wb_we)) // Write request
                        begin
                                o_wb_ack <= 1'b1;
                                o_wb_stall <= 1'b0;
                        end else if (i_wb_we) // Request to write a page
                        begin
                                if((!write_protect)&&(!write_in_progress))
                                begin // 00
                                        spi_wr <= 1'b1;
                                        spi_len <= 2'b00; // 8 bits
                                        // Send a write enable command
                                        spi_in <= { 8'h06, 24'h00 };
                                        state <= `WBQSPI_WEN;
 
                                        o_wb_ack <= 1'b0;
                                        o_wb_stall <= 1'b1;
                                end else if (write_protect)
                                begin // whether or not write-in_progress ...
                                        // Do nothing on a write protect
                                        // violation
                                        //
                                        o_wb_ack <= 1'b1;
                                        o_wb_stall <= 1'b0;
                                end else begin // write is in progress, wait
                                        // for it to complete
                                        state <= `WBQSPI_WAIT_WIP_CLEAR;
                                        o_wb_ack <= 1'b0;
                                        o_wb_stall <= 1'b1;
                                end
                        end else if (!write_in_progress)
                        begin // Read access, normal mode(s)
                                o_wb_ack   <= 1'b0;
                                o_wb_stall <= 1'b1;
                                spi_wr     <= 1'b1;     // Write cmd to device
                                if (quad_mode_enabled)
                                begin
                                        spi_in <= { 8'heb, w_wb_addr };
                                        state <= `WBQSPI_QRD_ADDRESS;
                                        spi_len    <= 2'b00; // single byte, cmd only
                                end else begin
                                        spi_in <= { 8'h0b, w_wb_addr };
                                        state <= `WBQSPI_RD_DUMMY;
                                        spi_len    <= 2'b11; // cmd+addr,32bits
                                end
                        end else if (!OPT_READ_ONLY) begin
                                // A write is in progress ... need to stall
                                // the bus until the write is complete.
                                state <= `WBQSPI_WAIT_WIP_CLEAR;
                                o_wb_ack   <= 1'b0;
                                o_wb_stall <= 1'b1;
                        end
                end else if ((OPT_READ_ONLY)&&(i_wb_ctrl_stb)&&(i_wb_we))
                begin
                        o_wb_ack   <= 1'b1;
                        o_wb_stall <= 1'b0;
                end else if ((i_wb_ctrl_stb)&&(i_wb_we))
                begin
                        o_wb_stall <= 1'b1;
                        case(i_wb_addr[1:0])
                        2'b00: begin // Erase command register
                                write_protect <= !i_wb_data[28];
                                o_wb_stall <= 1'b0;
 
                                if((i_wb_data[31])&&(!write_in_progress))
                                begin
                                        // Command an erase--ack it immediately
 
                                        o_wb_ack <= 1'b1;
                                        o_wb_stall <= 1'b0;
 
                                        if ((i_wb_data[31])&&(!write_protect))
                                        begin
                                                spi_wr <= 1'b1;
                                                spi_len <= 2'b00;
                                                // Send a write enable command
                                                spi_in <= { 8'h06, 24'h00 };
                                                state <= `WBQSPI_ERASE_CMD;
                                                o_wb_stall <= 1'b1;
                                        end
                                end else if (i_wb_data[31])
                                begin
                                        state <= `WBQSPI_WAIT_WIP_CLEAR;
                                        o_wb_ack   <= 1'b1;
                                        o_wb_stall <= 1'b1;
                                end else begin
                                        o_wb_ack   <= 1'b1;
                                        o_wb_stall <= 1'b0;
                                end end
                        2'b01: begin
                                // Write the configuration register
                                o_wb_ack <= 1'b1;
                                o_wb_stall <= 1'b1;
 
                                // Need to send a write enable command first
                                spi_wr <= 1'b1;
                                spi_len <= 2'b00; // 8 bits
                                // Send a write enable command
                                spi_in <= { 8'h06, 24'h00 };
                                state <= `WBQSPI_WRITE_CONFIG;
                                end
                        2'b10: begin
                                // Write the status register
                                o_wb_ack <= 1'b1; // Ack immediately
                                o_wb_stall <= 1'b1; // Stall other cmds
                                // Need to send a write enable command first
                                spi_wr <= 1'b1;
                                spi_len <= 2'b00; // 8 bits
                                // Send a write enable command
                                spi_in <= { 8'h06, 24'h00 };
                                state <= `WBQSPI_WRITE_STATUS;
                                end
                        2'b11: begin // Write the ID register??? makes no sense
                                o_wb_ack <= 1'b1;
                                o_wb_stall <= 1'b0;
                                end
                        endcase
                end else if (i_wb_ctrl_stb) // &&(!i_wb_we))
                begin
                        case(i_wb_addr[1:0])
                        2'b00: begin // Read local register
                                if (write_in_progress) // Read status
                                begin// register, is write still in progress?
                                        state <= `WBQSPI_READ_STATUS;
                                        spi_wr <= 1'b1;
                                        spi_len <= 2'b01;// 8 bits out, 8 bits in
                                        spi_in <= { 8'h05, 24'h00};
 
                                        o_wb_ack <= 1'b0;
                                        o_wb_stall <= 1'b1;
                                end else begin // Return w/o talking to device
                                        o_wb_ack <= 1'b1;
                                        o_wb_stall <= 1'b0;
                                        o_wb_data <= { write_in_progress,
                                                dirty_sector, spi_busy,
                                                ~write_protect,
                                                quad_mode_enabled,
                                                {(29-ADDRESS_WIDTH){1'b0}},
                                                erased_sector, 14'h000 };
                                end end
                        2'b01: begin // Read configuration register
                                state <= `WBQSPI_READ_CONFIG;
                                spi_wr <= 1'b1;
                                spi_len <= 2'b01;
                                spi_in <= { 8'h35, 24'h00};
 
                                o_wb_ack <= 1'b0;
                                o_wb_stall <= 1'b1;
                                end
                        2'b10: begin // Read status register
                                state <= `WBQSPI_READ_STATUS;
                                spi_wr <= 1'b1;
                                spi_len <= 2'b01; // 8 bits out, 8 bits in
                                spi_in <= { 8'h05, 24'h00};
 
                                o_wb_ack <= 1'b0;
                                o_wb_stall <= 1'b1;
                                end
                        2'b11: begin // Read ID register
                                state <= `WBQSPI_READ_ID_CMD;
                                spi_wr <= 1'b1;
                                spi_len <= 2'b00;
                                spi_in <= { 8'h9f, 24'h00};
 
                                o_wb_ack <= 1'b0;
                                o_wb_stall <= 1'b1;
                                end
                        endcase
                end else if ((!OPT_READ_ONLY)&&(!i_wb_cyc)&&(write_in_progress))
                begin
                        state <= `WBQSPI_IDLE_CHECK_WIP;
                        spi_wr <= 1'b1;
                        spi_len <= 2'b01; // 8 bits out, 8 bits in
                        spi_in <= { 8'h05, 24'h00};
 
                        o_wb_ack <= 1'b0;
                        o_wb_stall <= 1'b1;
                end
        end else if (state == `WBQSPI_RDIDLE)
        begin
                spi_wr <= 1'b0;
                o_wb_stall <= 1'b0;
                o_wb_ack <= 1'b0;
                spif_cmd   <= i_wb_we;
                spif_addr  <= i_wb_addr;
                spif_data  <= i_wb_data;
                spif_ctrl  <= (i_wb_ctrl_stb)&&(!i_wb_data_stb);
                spif_req   <= (i_wb_ctrl_stb)||(i_wb_data_stb);
                spi_hold <= 1'b0;
                spi_spd<= 1'b1;
                spi_dir <= 1'b0; // Write (for now)
                if ((i_wb_data_stb)&&(!i_wb_we))
                begin // Continue our read ... send the new address / mode
                        o_wb_stall <= 1'b1;
                        spi_wr <= 1'b1;
                        spi_len <= 2'b10; // Write address, but not mode byte
                        spi_in <= { w_wb_addr, 8'ha0 };
                        state <= `WBQSPI_QRD_DUMMY;
                end else if((i_wb_ctrl_stb)&&(!i_wb_we)&&(i_wb_addr[1:0] == 2'b00))
                begin
                        // A local read that doesn't touch the device, so leave
                        // the device in its current state
                        o_wb_stall <= 1'b0;
                        o_wb_ack <= 1'b1;
                        o_wb_data <= { write_in_progress,
                                        dirty_sector, spi_busy,
                                        ~write_protect,
                                        quad_mode_enabled,
                                        {(29-ADDRESS_WIDTH){1'b0}},
                                        erased_sector, 14'h000 };
                end else if(((i_wb_ctrl_stb)||(i_wb_data_stb)))
                begin // Need to release the device from quad mode for all else
                        o_wb_ack   <= 1'b0;
                        o_wb_stall <= 1'b1;
                        spi_wr <= 1'b1;
                        spi_len <= 2'b11;
                        spi_in <= 32'h00;
                        state <= `WBQSPI_WBDECODE;
                end
        end else if (state == `WBQSPI_WBDECODE)
        begin
                // We were in quad SPI read mode, and had to get out.
                // Now we've got a command (not data read) to read and
                // execute.  Accomplish what we would've done while in the
                // IDLE state here, save only that we don't have to worry
                // about data reads, and we need to operate on a stored
                // version of the bus command
                o_wb_stall <= 1'b1;
                o_wb_ack <= 1'b0;
                spi_wr <= 1'b0; // Keep the port idle, unless told otherwise
                spi_hold <= 1'b0;
                spi_spd <= 1'b0;
                spi_dir <= 1'b0;
                spif_req<= (spif_req) && (i_wb_cyc);
                if ((!spi_busy)&&(o_qspi_cs_n)&&(!spi_wr)) // only in full idle ...
                begin
                        // Data register access
                        if (!spif_ctrl)
                        begin
                                if ((OPT_READ_ONLY)&&(spif_cmd)) // Request to write a page
                                begin
                                        o_wb_ack <= spif_req;
                                        o_wb_stall <= 1'b0;
                                        state <= `WBQSPI_IDLE;
                                end else if (spif_cmd)
                                begin
                                        if((!write_protect)&&(!write_in_progress))
                                        begin // 00
                                                spi_wr <= 1'b1;
                                                spi_len <= 2'b00; // 8 bits
                                                // Send a write enable command
                                                spi_in <= { 8'h06, 24'h00 };
                                                state <= `WBQSPI_WEN;
 
                                                o_wb_ack <= 1'b0;
                                                o_wb_stall <= 1'b1;
                                        end else if (write_protect)
                                        begin // whether or not write-in_progress ...
                                                // Do nothing on a write protect
                                                // violation
                                                //
                                                o_wb_ack <= spif_req;
                                                o_wb_stall <= 1'b0;
                                                state <= `WBQSPI_IDLE;
                                        end else begin // write is in progress, wait
                                                // for it to complete
                                                state <= `WBQSPI_WAIT_WIP_CLEAR;
                                                o_wb_ack <= 1'b0;
                                                o_wb_stall <= 1'b1;
                                        end
                                // end else if (!write_in_progress) // always true
                                // but ... we wouldn't get here on a normal read access
                                end else begin
                                        // Something's wrong, we should never
                                        //   get here
                                        // Attempt to go to idle to recover
                                        state <= `WBQSPI_IDLE;
                                end
                        end else if ((OPT_READ_ONLY)&&(spif_ctrl)&&(spif_cmd))
                        begin
                                o_wb_ack   <= spif_req;
                                o_wb_stall <= 1'b0;
                                state <= `WBQSPI_IDLE;
                        end else if ((spif_ctrl)&&(spif_cmd)) begin
                                o_wb_stall <= 1'b1;
                                case(spif_addr[1:0])
                                2'b00: begin // Erase command register
                                        o_wb_ack   <= spif_req;
                                        o_wb_stall <= 1'b0;
                                        state <= `WBQSPI_IDLE;
                                        write_protect <= ~spif_data[28];
                                        // Are we commanding an erase?
                                        // We're in read mode, writes cannot
                                        // be in progress, so ...
                                        if (spif_data[31]) // Command an erase
                                        begin
                                                // Since we're not going back
                                                // to IDLE, we must stall the
                                                // bus here
                                                o_wb_stall <= 1'b1;
                                                spi_wr <= 1'b1;
                                                spi_len <= 2'b00;
                                                // Send a write enable command
                                                spi_in <= { 8'h06, 24'h00 };
                                                state <= `WBQSPI_ERASE_CMD;
                                        end end
                                2'b01: begin
                                        // Write the configuration register
                                        o_wb_ack <= spif_req;
                                        o_wb_stall <= 1'b1;
 
                                        // Need to send a write enable command first
                                        spi_wr <= 1'b1;
                                        spi_len <= 2'b00; // 8 bits
                                        // Send a write enable command
                                        spi_in <= { 8'h06, 24'h00 };
                                        state <= `WBQSPI_WRITE_CONFIG;
                                        end
                                2'b10: begin
                                        // Write the status register
                                        o_wb_ack <= spif_req; // Ack immediately
                                        o_wb_stall <= 1'b1; // Stall other cmds
                                        // Need to send a write enable command first
                                        spi_wr <= 1'b1;
                                        spi_len <= 2'b00; // 8 bits
                                        // Send a write enable command
                                        spi_in <= { 8'h06, 24'h00 };
                                        state <= `WBQSPI_WRITE_STATUS;
                                        end
                                2'b11: begin // Write the ID register??? makes no sense
                                        o_wb_ack <= spif_req;
                                        o_wb_stall <= 1'b0;
                                        state <= `WBQSPI_IDLE;
                                        end
                                endcase
                        end else begin // on (!spif_we)
                                case(spif_addr[1:0])
                                2'b00: begin // Read local register
                                        // Nonsense case--would've done this
                                        // already
                                        state <= `WBQSPI_IDLE;
                                        o_wb_ack <= spif_req;
                                        o_wb_stall <= 1'b0;
                                        end
                                2'b01: begin // Read configuration register
                                        state <= `WBQSPI_READ_CONFIG;
                                        spi_wr <= 1'b1;
                                        spi_len <= 2'b01;
                                        spi_in <= { 8'h35, 24'h00};
 
                                        o_wb_ack <= 1'b0;
                                        o_wb_stall <= 1'b1;
                                        end
                                2'b10: begin // Read status register
                                        state <= `WBQSPI_READ_STATUS;
                                        spi_wr <= 1'b1;
                                        spi_len <= 2'b01; // 8 bits out, 8 bits in
                                        spi_in <= { 8'h05, 24'h00};
 
                                        o_wb_ack <= 1'b0;
                                        o_wb_stall <= 1'b1;
                                        end
                                2'b11: begin // Read ID register
                                        state <= `WBQSPI_READ_ID_CMD;
                                        spi_wr <= 1'b1;
                                        spi_len <= 2'b00;
                                        spi_in <= { 8'h9f, 24'h00};
 
                                        o_wb_ack <= 1'b0;
                                        o_wb_stall <= 1'b1;
                                        end
                                endcase
                        end
                end
//
//
//      READ DATA section: for both data and commands
//
        end else if (state == `WBQSPI_RD_DUMMY)
        begin
                o_wb_ack   <= 1'b0;
                o_wb_stall <= 1'b1;
 
                spi_wr <= 1'b1; // Non-stop
                // Need to read one byte of dummy data,
                // just to consume 8 clocks
                spi_in <= { 8'h00, 24'h00 };
                spi_len <= 2'b00; // Read 8 bits
                spi_spd <= 1'b0;
                spi_hold <= 1'b0;
                spif_req<= (spif_req) && (i_wb_cyc);
 
                if ((!spi_busy)&&(!o_qspi_cs_n))
                        // Our command was accepted
                        state <= `WBQSPI_READ_CMD;
        end else if (state == `WBQSPI_QRD_ADDRESS)
        begin
                // We come in here immediately upon issuing a QRD read
                // command (8-bits), but we have to pause to give the
                // address (24-bits) and mode (8-bits) in quad speed.
                o_wb_ack   <= 1'b0;
                o_wb_stall <= 1'b1;
 
                spi_wr <= 1'b1; // Non-stop
                spi_in <= { w_spif_addr, 8'ha0 };
                spi_len <= 2'b10; // Write address, not mode byte
                spi_spd <= 1'b1;
                spi_dir <= 1'b0; // Still writing
                spi_hold <= 1'b0;
                spif_req<= (spif_req) && (i_wb_cyc);
 
                if ((!spi_busy)&&(spi_spd))
                        // Our command was accepted
                        state <= `WBQSPI_QRD_DUMMY;
        end else if (state == `WBQSPI_QRD_DUMMY)
        begin
                o_wb_ack   <= 1'b0;
                o_wb_stall <= 1'b1;
 
                spi_wr <= 1'b1; // Non-stop
                spi_in <= { 8'ha0, 24'h00 }; // Mode byte, then 2 bytes dummy
                spi_len <= 2'b10; // Write 24 bits
                spi_spd <= 1'b1;
                spi_dir <= 1'b0; // Still writing
                spi_hold <= 1'b0;
                spif_req<= (spif_req) && (i_wb_cyc);
 
                if ((!spi_busy)&&(spi_in[31:28] == 4'ha))
                        // Our command was accepted
                        state <= `WBQSPI_READ_CMD;
        end else if (state == `WBQSPI_READ_CMD)
        begin // Issue our first command to read 32 bits.
                o_wb_ack   <= 1'b0;
                o_wb_stall <= 1'b1;
 
                spi_wr <= 1'b1;
                spi_in <= { 8'hff, 24'h00 }; // Empty
                spi_len <= 2'b11; // Read 32 bits
                spi_dir <= 1'b1; // Now reading
                spi_hold <= 1'b0;
                spif_req<= (spif_req) && (i_wb_cyc);
                if ((spi_valid)&&(spi_len == 2'b11))
                        state <= `WBQSPI_READ_DATA;
        end else if (state == `WBQSPI_READ_DATA)
        begin
                // Pipelined read support
                spi_wr <=((i_wb_data_stb)&&(!i_wb_we)&&(i_wb_addr== (spif_addr+1)))&&(spif_req);
                spi_in <= 32'h00;
                spi_len <= 2'b11;
                // Don't adjust the speed here, it was set in the setup
                spi_dir <= 1'b1;        // Now we get to read
                // Don't let the device go to idle until the bus cycle ends.
                //      This actually prevents a *really* nasty race condition,
                //      where the strobe comes in after the lower level device
                //      has decided to stop waiting.  The write is then issued,
                //      but no one is listening.  By leaving the device open,
                //      the device is kept in a state where a valid strobe
                //      here will be useful.  Of course, we don't accept
                //      all commands, just reads.  Further, the strobe needs
                //      to be high for two clocks cycles without changing
                //      anything on the bus--one for us to notice it and pull
                //      our head out of the sand, and a second for whoever
                //      owns the bus to realize their command went through.
                spi_hold <= 1'b1;
                spif_req<= (spif_req) && (i_wb_cyc);
                if ((spi_valid)&&(!spi_in[31]))
                begin // Single pulse acknowledge and write data out
                        o_wb_ack <= spif_req;
                        o_wb_stall <= (!spi_wr);
                        // adjust endian-ness to match the PC
                        o_wb_data <= spi_out;
                        state <= (spi_wr)?`WBQSPI_READ_DATA
                                : ((spi_spd) ? `WBQSPI_WAIT_TIL_RDIDLE : `WBQSPI_WAIT_TIL_IDLE);
                        spif_req <= spi_wr;
                        spi_hold <= (!spi_wr);
                        if (spi_wr)
                                spif_addr <= i_wb_addr;
                end else if ((!spif_req)||(!i_wb_cyc))
                begin // FAIL SAFE: If the bus cycle ends, forget why we're
                        // here, just go back to idle
                        state <= ((spi_spd) ? `WBQSPI_WAIT_TIL_RDIDLE : `WBQSPI_WAIT_TIL_IDLE);
                        spi_hold <= 1'b0;
                        o_wb_ack <= 1'b0;
                        o_wb_stall <= 1'b1;
                end else begin
                        o_wb_ack <= 1'b0;
                        o_wb_stall <= 1'b1;
                end
        end else if (state == `WBQSPI_WAIT_TIL_RDIDLE)
        begin // Wait 'til idle, but then go to fast read idle instead of full
                spi_wr     <= 1'b0;     // idle
                spi_hold   <= 1'b0;
                o_wb_stall <= 1'b1;
                o_wb_ack   <= 1'b0;
                spif_req   <= 1'b0;
                if ((!spi_busy)&&(o_qspi_cs_n)&&(!spi_wr)) // Wait for a full
                begin // clearing of the SPI port before moving on
                        state <= `WBQSPI_RDIDLE;
                        o_wb_stall <= 1'b0;
                        o_wb_ack   <= 1'b0;// Shouldn't be acking anything here
                end
        end else if (state == `WBQSPI_READ_ID_CMD)
        begin // We came into here immediately after issuing a 0x9f command
                // Now we need to read 32 bits of data.  Result should be
                // 0x0102154d (8'h manufacture ID, 16'h device ID, followed
                // by the number of extended bytes available 8'h4d).
                o_wb_ack <= 1'b0;
                o_wb_stall<= 1'b1;
 
                spi_wr <= 1'b1; // No data to send, but need four bytes, since
                spi_len <= 2'b11; // 32 bits of data are ... useful
                spi_in <= 32'h00; // Irrelevant
                spi_spd <= 1'b0; // Slow speed
                spi_dir <= 1'b1; // Reading
                spi_hold <= 1'b0;
                spif_req <= (spif_req) && (i_wb_cyc);
                if ((!spi_busy)&&(!o_qspi_cs_n)&&(spi_len == 2'b11))
                        // Our command was accepted, now go read the result
                        state <= `WBQSPI_READ_ID;
        end else if (state == `WBQSPI_READ_ID)
        begin
                o_wb_ack <= 1'b0; // Assuming we're still waiting
                o_wb_stall <= 1'b1;
 
                spi_wr <= 1'b0; // No more writes, we've already written the cmd
                spi_hold <= 1'b0;
                spif_req <= (spif_req) && (i_wb_cyc);
 
                // Here, we just wait until the result comes back
                // The problem is, the result may be the previous result.
                // So we use spi_len as an indicator
                spi_len <= 2'b00;
                if((spi_valid)&&(spi_len==2'b00))
                begin // Put the results out as soon as possible
                        o_wb_data <= spi_out[31:0];
                        o_wb_ack <= spif_req;
                        spif_req <= 1'b0;
                end else if ((!spi_busy)&&(o_qspi_cs_n))
                begin
                        state <= `WBQSPI_IDLE;
                        o_wb_stall <= 1'b0;
                end
        end else if (state == `WBQSPI_READ_STATUS)
        begin // We enter after the command has been given, for now just
                // read and return
                spi_wr <= 1'b0;
                o_wb_ack <= 1'b0;
                spi_hold <= 1'b0;
                spif_req <= (spif_req) && (i_wb_cyc);
                if (spi_valid)
                begin
                        o_wb_ack <= spif_req;
                        o_wb_stall <= 1'b1;
                        spif_req <= 1'b0;
                        last_status <= spi_out[7:0];
                        write_in_progress <= spi_out[0];
                        if (spif_addr[1:0] == 2'b00) // Local read, checking
                        begin // status, 'cause we're writing
                                o_wb_data <= { spi_out[0],
                                        dirty_sector, spi_busy,
                                        ~write_protect,
                                        quad_mode_enabled,
                                        {(29-ADDRESS_WIDTH){1'b0}},
                                        erased_sector, 14'h000 };
                        end else begin
                                o_wb_data <= { 24'h00, spi_out[7:0] };
                        end
                end
 
                if ((!spi_busy)&&(!spi_wr))
                        state <= `WBQSPI_IDLE;
        end else if (state == `WBQSPI_READ_CONFIG)
        begin // We enter after the command has been given, for now just
                // read and return
                spi_wr <= 1'b0;
                o_wb_ack <= 1'b0;
                o_wb_stall <= 1'b1;
                spi_hold <= 1'b0;
                spif_req <= (spif_req) && (i_wb_cyc);
 
                if (spi_valid)
                begin
                        o_wb_data <= { 24'h00, spi_out[7:0] };
                        quad_mode_enabled <= spi_out[1];
                end
 
                if ((!spi_busy)&&(!spi_wr))
                begin
                        state <= `WBQSPI_IDLE;
                        o_wb_ack   <= spif_req;
                        o_wb_stall <= 1'b0;
                        spif_req <= 1'b0;
                end
 
//
//
//      Write/erase data section
//
        end else if ((!OPT_READ_ONLY)&&(state == `WBQSPI_WAIT_WIP_CLEAR))
        begin
                o_wb_stall <= 1'b1;
                o_wb_ack   <= 1'b0;
                spi_wr <= 1'b0;
                spif_req<= (spif_req) && (i_wb_cyc);
                if (!spi_busy)
                begin
                        spi_wr   <= 1'b1;
                        spi_in   <= { 8'h05, 24'h0000 };
                        spi_hold <= 1'b1;
                        spi_len  <= 2'b01; // 16 bits write, so we can read 8
                        state <= `WBQSPI_CHECK_WIP_CLEAR;
                        spi_spd  <= 1'b0; // Slow speed
                        spi_dir  <= 1'b0;
                end
        end else if ((!OPT_READ_ONLY)&&(state == `WBQSPI_CHECK_WIP_CLEAR))
        begin
                o_wb_stall <= 1'b1;
                o_wb_ack   <= 1'b0;
                // Repeat as often as necessary until we are clear
                spi_wr <= 1'b1;
                spi_in <= 32'h0000; // Values here are actually irrelevant
                spi_hold <= 1'b1;
                spi_len <= 2'b00; // One byte at a time
                spi_spd  <= 1'b0; // Slow speed
                spi_dir  <= 1'b0;
                spif_req<= (spif_req) && (i_wb_cyc);
                if ((spi_valid)&&(!spi_out[0]))
                begin
                        state <= `WBQSPI_CHECK_WIP_DONE;
                        spi_wr   <= 1'b0;
                        spi_hold <= 1'b0;
                        write_in_progress <= 1'b0;
                        last_status <= spi_out[7:0];
                end
        end else if ((!OPT_READ_ONLY)&&(state == `WBQSPI_CHECK_WIP_DONE))
        begin
                o_wb_stall <= 1'b1;
                o_wb_ack   <= 1'b0;
                // Let's let the SPI port come back to a full idle,
                // and the chip select line go low before continuing
                spi_wr   <= 1'b0;
                spi_len  <= 2'b00;
                spi_hold <= 1'b0;
                spi_spd  <= 1'b0; // Slow speed
                spi_dir  <= 1'b0;
                spif_req<= (spif_req) && (i_wb_cyc);
                if ((o_qspi_cs_n)&&(!spi_busy)) // Chip select line is high, we can continue
                begin
                        spi_wr   <= 1'b0;
                        spi_hold <= 1'b0;
 
                        casez({ spif_cmd, spif_ctrl, spif_addr[1:0] })
                        4'b00??: begin // Read data from ... somewhere
                                spi_wr     <= 1'b1;     // Write cmd to device
                                if (quad_mode_enabled)
                                begin
                                        spi_in <= { 8'heb, w_spif_addr };
                                        state <= `WBQSPI_QRD_ADDRESS;
                                        // spi_len    <= 2'b00; // single byte, cmd only
                                end else begin
                                        spi_in <= { 8'h0b, w_spif_addr };
                                        state <= `WBQSPI_RD_DUMMY;
                                        spi_len    <= 2'b11; // Send cmd and addr
                                end end
                        4'b10??: begin // Write data to ... anywhere
                                spi_wr <= 1'b1;
                                spi_len <= 2'b00; // 8 bits
                                // Send a write enable command
                                spi_in <= { 8'h06, 24'h00 };
                                state <= `WBQSPI_WEN;
                                end
                        4'b0110: begin // Read status register
                                state <= `WBQSPI_READ_STATUS;
                                spi_wr <= 1'b1;
                                spi_len <= 2'b01; // 8 bits out, 8 bits in
                                spi_in <= { 8'h05, 24'h00};
                                end
                        4'b0111: begin
                                state <= `WBQSPI_READ_ID_CMD;
                                spi_wr <= 1'b1;
                                spi_len <= 2'b00;
                                spi_in <= { 8'h9f, 24'h00};
                                end
                        default: begin //
                                o_wb_stall <= 1'b1;
                                o_wb_ack <= spif_req;
                                state <= `WBQSPI_WAIT_TIL_IDLE;
                                end
                        endcase
                // spif_cmd   <= i_wb_we;
                // spif_addr  <= i_wb_addr;
                // spif_data  <= i_wb_data;
                // spif_ctrl  <= (i_wb_ctrl_stb)&&(!i_wb_data_stb);
                // spi_wr <= 1'b0; // Keep the port idle, unless told otherwise
                end
        end else if ((!OPT_READ_ONLY)&&(state == `WBQSPI_WEN))
        begin // We came here after issuing a write enable command
                spi_wr <= 1'b0;
                o_wb_ack <= 1'b0;
                o_wb_stall <= 1'b1;
                spif_req<= (spif_req) && (i_wb_cyc);
                if ((!spi_busy)&&(o_qspi_cs_n)&&(!spi_wr)) // Let's come to a full stop
                        state <= (quad_mode_enabled)?`WBQSPI_QPP:`WBQSPI_PP;
                        // state <= `WBQSPI_PP;
        end else if ((!OPT_READ_ONLY)&&(state == `WBQSPI_PP))
        begin // We come here under a full stop / full port idle mode
                // Issue our command immediately
                spi_wr <= 1'b1;
                spi_in <= { 8'h02, w_spif_addr };
                spi_len <= 2'b11;
                spi_hold <= 1'b1;
                spi_spd  <= 1'b0;
                spi_dir  <= 1'b0; // Writing
                spif_req<= (spif_req) && (i_wb_cyc);
 
                // Once we get busy, move on
                if (spi_busy)
                        state <= `WBQSPI_WR_DATA;
                if (spif_sector == erased_sector)
                        dirty_sector <= 1'b1;
        end else if ((!OPT_READ_ONLY)&&(state == `WBQSPI_QPP))
        begin // We come here under a full stop / full port idle mode
                // Issue our command immediately
                spi_wr <= 1'b1;
                spi_in <= { 8'h32, w_spif_addr };
                spi_len <= 2'b11;
                spi_hold <= 1'b1;
                spi_spd  <= 1'b0;
                spi_dir  <= 1'b0; // Writing
                spif_req<= (spif_req) && (i_wb_cyc);
 
                // Once we get busy, move on
                if (spi_busy)
                begin
                        // spi_wr is irrelevant here ...
                        // Set the speed value once, but wait til we get busy
                        // to do so.
                        spi_spd <= 1'b1;
                        state <= `WBQSPI_WR_DATA;
                end
                if (spif_sector == erased_sector)
                        dirty_sector <= 1'b1;
        end else if ((!OPT_READ_ONLY)&&(state == `WBQSPI_WR_DATA))
        begin
                o_wb_stall <= 1'b1;
                o_wb_ack   <= 1'b0;
                spi_wr   <= 1'b1; // write without waiting
                spi_in   <= spif_data;
                spi_len  <= 2'b11; // Write 4 bytes
                spi_hold <= 1'b1;
                if (!spi_busy)
                begin
                        o_wb_ack <= spif_req; // Ack when command given
                        state <= `WBQSPI_WR_BUS_CYCLE;
                end
                spif_req<= (spif_req) && (i_wb_cyc);
        end else if ((!OPT_READ_ONLY)&&(state == `WBQSPI_WR_BUS_CYCLE))
        begin
                o_wb_ack <= 1'b0; // Turn off our ack and stall flags
                o_wb_stall <= 1'b1;
                spi_wr <= 1'b0;
                spi_hold <= 1'b1;
                write_in_progress <= 1'b1;
                spif_req<= (spif_req) && (i_wb_cyc);
                if (!i_wb_cyc)
                begin
                        state <= `WBQSPI_WAIT_TIL_IDLE;
                        spi_hold <= 1'b0;
                end else if (spi_wr)
                begin // Give the SPI a chance to get busy on the last write
                        // Do nothing here.
                end else if ((spif_req)&&(i_wb_data_stb)&&(i_wb_we)
                                &&(i_wb_addr == (spif_addr+1))
                                &&(i_wb_addr[(AW-1):6]==spif_addr[(AW-1):6]))
                begin
                        spif_cmd  <= 1'b1;
                        spif_data <= i_wb_data;
                        spif_addr <= i_wb_addr;
                        spif_ctrl  <= 1'b0;
                        spif_req<= 1'b1;
                        // We'll keep the bus stalled on this request
                        // for a while
                        state <= `WBQSPI_WR_DATA;
                        o_wb_ack   <= 1'b0;
                        o_wb_stall <= 1'b0;
                end else if ((i_wb_data_stb|i_wb_ctrl_stb)&&(!o_wb_ack)) // Writing out of bounds
                begin
                        spi_hold <= 1'b0;
                        spi_wr   <= 1'b0;
                        state <= `WBQSPI_WAIT_TIL_IDLE;
                end // Otherwise we stay here
        end else if ((!OPT_READ_ONLY)&&(state == `WBQSPI_WRITE_CONFIG))
        begin // We enter immediately after commanding a WEN
                o_wb_ack   <= 1'b0;
                o_wb_stall <= 1'b1;
 
                spi_len <= 2'b10;
                spi_in <= { 8'h01, last_status, spif_data[7:0], 8'h00 };
                spi_wr <= 1'b0;
                spi_hold <= 1'b0;
                spif_req <= (spif_req) && (i_wb_cyc);
                if ((!spi_busy)&&(!spi_wr))
                begin
                        spi_wr <= 1'b1;
                        state <= `WBQSPI_WAIT_TIL_IDLE;
                        write_in_progress <= 1'b1;
                        quad_mode_enabled <= spif_data[1];
                end
        end else if ((!OPT_READ_ONLY)&&(state == `WBQSPI_WRITE_STATUS))
        begin // We enter immediately after commanding a WEN
                o_wb_ack   <= 1'b0;
                o_wb_stall <= 1'b1;
 
                spi_len <= 2'b01;
                spi_in <= { 8'h01, spif_data[7:0], 16'h00 };
                // last_status <= i_wb_data[7:0]; // We'll read this in a moment
                spi_wr <= 1'b0;
                spi_hold <= 1'b0;
                spif_req <= (spif_req) && (i_wb_cyc);
                if ((!spi_busy)&&(!spi_wr))
                begin
                        spi_wr <= 1'b1;
                        last_status <= spif_data[7:0];
                        write_in_progress <= 1'b1;
                        if(((last_status[6])||(last_status[5]))
                                &&((!spif_data[6])&&(!spif_data[5])))
                                state <= `WBQSPI_CLEAR_STATUS;
                        else
                                state <= `WBQSPI_WAIT_TIL_IDLE;
                end
        end else if ((!OPT_READ_ONLY)&&(state == `WBQSPI_ERASE_CMD))
        begin // Know that WIP is clear on entry, WEN has just been commanded
                spi_wr     <= 1'b0;
                o_wb_ack   <= 1'b0;
                o_wb_stall <= 1'b1;
                spi_hold   <= 1'b0;
                spi_spd <= 1'b0;
                spi_dir <= 1'b0;
                spif_req <= (spif_req) && (i_wb_cyc);
 
                // Here's the erase command
                spi_in <= { 8'hd8, 2'h0, spif_data[19:14], 14'h000, 2'b00 };
                spi_len <= 2'b11; // 32 bit write
                // together with setting our copy of the WIP bit
                write_in_progress <= 1'b1;
                // keeping track of which sector we just erased
                erased_sector <= spif_data[(AW-1):14];
                // and marking this erase sector as no longer dirty
                dirty_sector <= 1'b0;
 
                // Wait for a full stop before issuing this command
                if ((!spi_busy)&&(!spi_wr)&&(o_qspi_cs_n))
                begin // When our command is accepted, move to the next state
                        spi_wr <= 1'b1;
                        state <= `WBQSPI_ERASE_BLOCK;
                end
        end else if ((!OPT_READ_ONLY)&&(state == `WBQSPI_ERASE_BLOCK))
        begin
                spi_wr     <= 1'b0;
                spi_hold   <= 1'b0;
                o_wb_stall <= 1'b1;
                o_wb_ack   <= 1'b0;
                spif_req <= (spif_req) && (i_wb_cyc);
                // When the port clears, we can head back to idle
                //      No ack necessary, we ackd before getting
                //      here.
                if ((!spi_busy)&&(!spi_wr))
                        state <= `WBQSPI_IDLE;
        end else if ((!OPT_READ_ONLY)&&(state == `WBQSPI_CLEAR_STATUS))
        begin // Issue a clear status command
                spi_wr <= 1'b1;
                spi_hold <= 1'b0;
                spi_len <= 2'b00; // 8 bit command
                spi_in <= { 8'h30, 24'h00 };
                spi_spd <= 1'b0;
                spi_dir <= 1'b0;
                last_status[6:5] <= 2'b00;
                spif_req <= (spif_req) && (i_wb_cyc);
                if ((spi_wr)&&(!spi_busy))
                        state <= `WBQSPI_WAIT_TIL_IDLE;
        end else if ((!OPT_READ_ONLY)&&(state == `WBQSPI_IDLE_CHECK_WIP))
        begin // We are now in read status register mode
 
                // No bus commands have (yet) been given
                o_wb_stall <= 1'b1;
                o_wb_ack   <= 1'b0;
                spif_req <= (spif_req) && (i_wb_cyc);
 
                // Stay in this mode unless/until we get a command, or
                //      the write is over
                spi_wr <= (((!i_wb_cyc)||((!i_wb_data_stb)&&(!i_wb_ctrl_stb)))
                                &&(write_in_progress));
                spi_len <= 2'b00; // 8 bit reads
                spi_spd <= 1'b0;  // SPI, not quad
                spi_dir <= 1'b1;  // Read
                if (spi_valid)
                begin
                        write_in_progress <= spi_out[0];
                        if ((!spi_out[0])&&(write_in_progress))
                                o_interrupt <= 1'b1;
                end else
                        o_interrupt <= 1'b0;
 
                if ((!spi_wr)&&(!spi_busy)&&(o_qspi_cs_n))
                begin // We can now go to idle and process a command
                        o_wb_stall <= 1'b0;
                        o_wb_ack   <= 1'b0;
                        state <= `WBQSPI_IDLE;
                end
        end else // if (state == `WBQSPI_WAIT_TIL_IDLE) or anything else
        begin
                spi_wr     <= 1'b0;
                spi_hold   <= 1'b0;
                o_wb_stall <= 1'b1;
                o_wb_ack   <= 1'b0;
                spif_req   <= 1'b0;
                if ((!spi_busy)&&(o_qspi_cs_n)&&(!spi_wr)) // Wait for a full
                begin // clearing of the SPI port before moving on
                        state <= `WBQSPI_IDLE;
                        o_wb_stall <= 1'b0;
                        o_wb_ack   <= 1'b0; // Shouldn't be acking anything here
                end
        end
        end
 
        // Command and control during the reset sequence
        assign  o_qspi_cs_n = (spif_override)?alt_cmd :w_qspi_cs_n;
        assign  o_qspi_sck  = (spif_override)?alt_ctrl:w_qspi_sck;
        assign  o_qspi_mod  = (spif_override)?  2'b01 :w_qspi_mod;
        assign  o_qspi_dat  = (spif_override)?  4'b00 :w_qspi_dat;
endmodule

Line No.	Rev	Author	Line
1	14	dgisselq	`////////////////////////////////////////////////////////////////////////////////`
2	2	dgisselq	`//`
3			`// Filename: wbspiflash.v`
4			`//`
5	22	dgisselq	`// Project: A Set of Wishbone Controlled SPI Flash Controllers`
6	2	dgisselq	`//`
7			`// Purpose: Access a Quad SPI flash via a WISHBONE interface. This`
8			`// includes both read and write (and erase) commands to the SPI`
9			`// flash. All read/write commands are accomplished using the`
10			`// high speed (4-bit) interface. Further, the device will be`
11			`// left/kept in the 4-bit read interface mode between accesses,`
12			`// for a minimum read latency.`
13			`//`
14	3	dgisselq	`// Wishbone Registers (See spec sheet for more detail):`
15	2	dgisselq	`// 0: local config(r) / erase commands(w) / deep power down cmds / etc.`
16			`// R: (Write in Progress), (dirty-block), (spi_port_busy), 1'b0, 9'h00,`
17			`// { last_erased_sector, 14'h00 } if (WIP)`
18			`// else { current_sector_being_erased, 14'h00 }`
19			`// current if write in progress, last if written`
20			`// W: (1'b1 to erase), (12'h ignored), next_erased_block, 14'h ignored)`
21	3	dgisselq	`// 1: Configuration register`
22			`// 2: Status register (R/w)`
23			`// 3: Read ID (read only)`
24	2	dgisselq	`// (19 bits): Data (R/w, but expect writes to take a while)`
25			`//`
26			`//`
27	14	dgisselq	`// Creator: Dan Gisselquist, Ph.D.`
28	8	dgisselq	`// Gisselquist Technology, LLC`
29	2	dgisselq	`//`
30	14	dgisselq	`////////////////////////////////////////////////////////////////////////////////`
31	2	dgisselq	`//`
32	22	dgisselq	`// Copyright (C) 2015-2019, Gisselquist Technology, LLC`
33	2	dgisselq	`//`
34	22	dgisselq	`// This file is part of the set of Wishbone controlled SPI flash controllers`
35			`// project`
36	3	dgisselq	`//`
37	22	dgisselq	`// The Wishbone SPI flash controller project is free software (firmware):`
38			`// you can redistribute it and/or modify it under the terms of the GNU Lesser`
39			`// General Public License as published by the Free Software Foundation, either`
40			`// version 3 of the License, or (at your option) any later version.`
41	3	dgisselq	`//`
42	22	dgisselq	`// The Wishbone SPI flash controller project is distributed in the hope`
43			`// that it will be useful, but WITHOUT ANY WARRANTY; without even the implied`
44			`// warranty of MERCHANTIBILITY or FITNESS FOR A PARTICULAR PURPOSE. See the`
45			`// GNU Lesser General Public License for more details.`
46			`//`
47			`// You should have received a copy of the GNU Lesser General Public License`
48			`// along with this program. (It's in the $(ROOT)/doc directory. Run make`
49			`// with no target there if the PDF file isn't present.) If not, see`
50	3	dgisselq	`// <http://www.gnu.org/licenses/> for a copy.`
51			`//`
52	22	dgisselq	`// License: LGPL, v3, as defined and found on www.gnu.org,`
53			`// http://www.gnu.org/licenses/lgpl.html`
54	3	dgisselq	`//`
55			`//`
56	14	dgisselq	`////////////////////////////////////////////////////////////////////////////////`
57	7	dgisselq	`//`
58	20	dgisselq	`//`
59	22	dgisselq	`//`
60	14	dgisselq	`default_nettype none
61	7	dgisselq	`//`
62	16	dgisselq	`define WBQSPI_RESET 5'd0
63			`define WBQSPI_RESET_QUADMODE 5'd1
64			`define WBQSPI_IDLE 5'd2
65			`define WBQSPI_RDIDLE 5'd3 // Idle, but in fast read mode
66			`define WBQSPI_WBDECODE 5'd4
67			`define WBQSPI_RD_DUMMY 5'd5
68			`define WBQSPI_QRD_ADDRESS 5'd6
69			`define WBQSPI_QRD_DUMMY 5'd7
70			`define WBQSPI_READ_CMD 5'd8
71			`define WBQSPI_READ_DATA 5'd9
72			`define WBQSPI_WAIT_TIL_RDIDLE 5'd10
73			`define WBQSPI_READ_ID_CMD 5'd11
74			`define WBQSPI_READ_ID 5'd12
75			`define WBQSPI_READ_STATUS 5'd13
76			`define WBQSPI_READ_CONFIG 5'd14
77			`define WBQSPI_WAIT_TIL_IDLE 5'd15
78	7	dgisselq	`//`
79			`//`
80	16	dgisselq	`define WBQSPI_WAIT_WIP_CLEAR 5'd16
81			`define WBQSPI_CHECK_WIP_CLEAR 5'd17
82			`define WBQSPI_CHECK_WIP_DONE 5'd18
83			`define WBQSPI_WEN 5'd19
84			`define WBQSPI_PP 5'd20 // Program page
85			`define WBQSPI_QPP 5'd21 // Program page, 4 bit mode
86			`define WBQSPI_WR_DATA 5'd22
87			`define WBQSPI_WR_BUS_CYCLE 5'd23
88			`define WBQSPI_WRITE_STATUS 5'd24
89			`define WBQSPI_WRITE_CONFIG 5'd25
90			`define WBQSPI_ERASE_WEN 5'd26
91			`define WBQSPI_ERASE_CMD 5'd27
92			`define WBQSPI_ERASE_BLOCK 5'd28
93			`define WBQSPI_CLEAR_STATUS 5'd29
94			`define WBQSPI_IDLE_CHECK_WIP 5'd30
95	7	dgisselq	`//`
96	16	dgisselq	`module wbqspiflash(i_clk,`
97	2	dgisselq	`// Internal wishbone connections`
98			`i_wb_cyc, i_wb_data_stb, i_wb_ctrl_stb, i_wb_we,`
99			`i_wb_addr, i_wb_data,`
100			`// Wishbone return values`
101			`o_wb_ack, o_wb_stall, o_wb_data,`
102			`// Quad Spi connections to the external device`
103			`o_qspi_sck, o_qspi_cs_n, o_qspi_mod, o_qspi_dat, i_qspi_dat,`
104	3	dgisselq	`o_interrupt);`
105	7	dgisselq	`parameter ADDRESS_WIDTH=22;`
106	22	dgisselq	`parameter [0:0] OPT_READ_ONLY = 1'b0;`
107	16	dgisselq	`localparam AW = ADDRESS_WIDTH-2;`
108			`input wire i_clk;`
109	2	dgisselq	`// Wishbone, inputs first`
110	14	dgisselq	`input wire i_wb_cyc, i_wb_data_stb, i_wb_ctrl_stb, i_wb_we;`
111	16	dgisselq	`input wire [(AW-1):0] i_wb_addr;`
112	14	dgisselq	`input wire [31:0] i_wb_data;`
113	2	dgisselq	`// then outputs`
114			`output reg o_wb_ack;`
115			`output reg o_wb_stall;`
116			`output reg [31:0] o_wb_data;`
117			`// Quad SPI control wires`
118			`output wire o_qspi_sck, o_qspi_cs_n;`
119			`output wire [1:0] o_qspi_mod;`
120			`output wire [3:0] o_qspi_dat;`
121	14	dgisselq	`input wire [3:0] i_qspi_dat;`
122	2	dgisselq	`// Interrupt line`
123			`output reg o_interrupt;`
124	7	dgisselq	`// output wire [31:0] o_debug;`
125	2	dgisselq
126			`reg spi_wr, spi_hold, spi_spd, spi_dir;`
127			`reg [31:0] spi_in;`
128			`reg [1:0] spi_len;`
129			`wire [31:0] spi_out;`
130			`wire spi_valid, spi_busy;`
131	4	dgisselq	`wire w_qspi_sck, w_qspi_cs_n;`
132			`wire [3:0] w_qspi_dat;`
133			`wire [1:0] w_qspi_mod;`
134	7	dgisselq	`// wire [22:0] spi_dbg;`
135	16	dgisselq	`llqspi lldriver(i_clk,`
136	2	dgisselq	`spi_wr, spi_hold, spi_in, spi_len, spi_spd, spi_dir,`
137			`spi_out, spi_valid, spi_busy,`
138	4	dgisselq	`w_qspi_sck, w_qspi_cs_n, w_qspi_mod, w_qspi_dat,`
139	3	dgisselq	`i_qspi_dat);`
140	2	dgisselq
141			`// Erase status tracking`
142			`reg write_in_progress, write_protect;`
143	7	dgisselq	`reg [(ADDRESS_WIDTH-17):0] erased_sector;`
144	2	dgisselq	`reg dirty_sector;`
145			`initial begin`
146			`write_in_progress = 1'b0;`
147	7	dgisselq	`erased_sector = 0;`
148	2	dgisselq	`dirty_sector = 1'b1;`
149			`write_protect = 1'b1;`
150			`end`
151
152	14	dgisselq	`wire [23:0] w_wb_addr;`
153			`generate`
154			`if (ADDRESS_WIDTH>=24)`
155			`assign w_wb_addr = { i_wb_addr[21:0], 2'b00 };`
156			`else`
157			`assign w_wb_addr = { {(24-ADDRESS_WIDTH){1'b0}}, i_wb_addr, 2'b00 };`
158			`endgenerate`
159
160			`// Repeat for spif_addr`
161			`reg [(ADDRESS_WIDTH-3):0] spif_addr;`
162			`wire [23:0] w_spif_addr;`
163			`generate`
164			`if (ADDRESS_WIDTH>=24)`
165			`assign w_spif_addr = { spif_addr[21:0], 2'b00 };`
166			`else`
167			`assign w_spif_addr = { {(24-ADDRESS_WIDTH){1'b0}}, spif_addr, 2'b00 };`
168			`endgenerate`
169
170	2	dgisselq	`reg [7:0] last_status;`
171	16	dgisselq	`reg [9:0] reset_counter;`
172	2	dgisselq	`reg quad_mode_enabled;`
173	4	dgisselq	`reg spif_cmd, spif_override;`
174	2	dgisselq	`reg [31:0] spif_data;`
175	14	dgisselq	`reg [4:0] state;`
176	2	dgisselq	`reg spif_ctrl, spif_req;`
177	16	dgisselq	`reg alt_cmd, alt_ctrl;`
178	7	dgisselq	`wire [(ADDRESS_WIDTH-17):0] spif_sector;`
179	16	dgisselq	`assign spif_sector = spif_addr[(AW-1):14];`
180	2	dgisselq
181	7	dgisselq	`// assign o_debug = { spi_wr, spi_spd, spi_hold, state, spi_dbg };`
182
183	2	dgisselq	initial state = `WBQSPI_RESET;
184			`initial o_wb_ack = 1'b0;`
185			`initial o_wb_stall = 1'b1;`
186			`initial spi_wr = 1'b0;`
187			`initial spi_len = 2'b00;`
188			`initial quad_mode_enabled = 1'b0;`
189			`initial o_interrupt = 1'b0;`
190	16	dgisselq	`initial spif_override = 1'b1;`
191			`initial spif_ctrl = 1'b0;`
192			`always @(posedge i_clk)`
193	4	dgisselq	`begin`
194			`spif_override <= 1'b0;`
195	16	dgisselq	`alt_cmd <= (reset_counter[9:8]==2'b10)?reset_counter[3]:1'b1; // Toggle CS_n`
196			`alt_ctrl <= (reset_counter[9:8]==2'b10)?reset_counter[0]:1'b1; // Toggle clock too`
197	2	dgisselq	if (state == `WBQSPI_RESET)
198			`begin`
199			`// From a reset, we should`
200			`// Enable the Quad I/O mode`
201			`// Disable the Write protection bits in the status register`
202			`// Chip should already be up and running, so we can start`
203			`// immediately ....`
204			`o_wb_ack <= 1'b0;`
205			`o_wb_stall <= 1'b1;`
206	4	dgisselq	`spi_wr <= 1'b0;`
207	2	dgisselq	`spi_hold <= 1'b0;`
208			`spi_spd <= 1'b0;`
209			`spi_dir <= 1'b0;`
210			`last_status <= 8'h00;`
211	4	dgisselq	state <= `WBQSPI_RESET_QUADMODE;
212	2	dgisselq	`spif_req <= 1'b0;`
213	4	dgisselq	`spif_override <= 1'b1;`
214	16	dgisselq	`last_status <= 8'h00; //`
215			`reset_counter <= 10'h3fc; //`
216	4	dgisselq	`// This guarantees that we aren't starting in quad`
217			`// I/O mode, where the FPGA configuration scripts may`
218			`// have left us.`
219			end else if (state == `WBQSPI_RESET_QUADMODE)
220	2	dgisselq	`begin`
221	4	dgisselq	`// Okay, so here's the problem: we don't know whether or not`
222			`// the Xilinx loader started us up in Quad Read I/O idle mode.`
223	14	dgisselq	`// So, thus we need to toggle the clock and CS_n, with fewer`
224			`// clocks than are necessary to transmit a word.`
225			`//`
226	4	dgisselq	`// Not ready to handle the bus yet, so stall any requests`
227			`o_wb_ack <= 1'b0;`
228			`o_wb_stall <= 1'b1;`
229
230			`// Do something ...`
231	16	dgisselq	`if (reset_counter == 10'h00)`
232	2	dgisselq	`begin`
233	4	dgisselq	`spif_override <= 1'b0;`
234			state <= `WBQSPI_IDLE;
235	16	dgisselq
236			`// Find out if we can use Quad I/O mode ...`
237			state <= `WBQSPI_READ_CONFIG;
238			`spi_wr <= 1'b1;`
239			`spi_len <= 2'b01;`
240			`spi_in <= { 8'h35, 24'h00};`
241
242	4	dgisselq	`end else begin`
243	16	dgisselq	`reset_counter <= reset_counter - 10'h1;`
244	4	dgisselq	`spif_override <= 1'b1;`
245	2	dgisselq	`end`
246			end else if (state == `WBQSPI_IDLE)
247			`begin`
248			`o_interrupt <= 1'b0;`
249			`o_wb_stall <= 1'b0;`
250			`o_wb_ack <= 1'b0;`
251			`spif_cmd <= i_wb_we;`
252			`spif_addr <= i_wb_addr;`
253			`spif_data <= i_wb_data;`
254	22	dgisselq	`spif_ctrl <= (i_wb_ctrl_stb)&&(!i_wb_data_stb);`
255	2	dgisselq	`spif_req <= (i_wb_ctrl_stb)\|\|(i_wb_data_stb);`
256			`spi_wr <= 1'b0; // Keep the port idle, unless told otherwise`
257			`spi_hold <= 1'b0;`
258			`spi_spd <= 1'b0;`
259			`spi_dir <= 1'b0; // Write (for now, 'cause of cmd)`
260			`// Data register access`
261	14	dgisselq	`if (i_wb_data_stb)`
262	2	dgisselq	`begin`
263
264	22	dgisselq	`if ((OPT_READ_ONLY)&&(i_wb_we)) // Write request`
265	2	dgisselq	`begin`
266	7	dgisselq	`o_wb_ack <= 1'b1;`
267			`o_wb_stall <= 1'b0;`
268	22	dgisselq	`end else if (i_wb_we) // Request to write a page`
269			`begin`
270			`if((!write_protect)&&(!write_in_progress))`
271	2	dgisselq	`begin // 00`
272			`spi_wr <= 1'b1;`
273			`spi_len <= 2'b00; // 8 bits`
274			`// Send a write enable command`
275			`spi_in <= { 8'h06, 24'h00 };`
276			state <= `WBQSPI_WEN;
277
278			`o_wb_ack <= 1'b0;`
279			`o_wb_stall <= 1'b1;`
280			`end else if (write_protect)`
281			`begin // whether or not write-in_progress ...`
282			`// Do nothing on a write protect`
283			`// violation`
284			`//`
285			`o_wb_ack <= 1'b1;`
286			`o_wb_stall <= 1'b0;`
287			`end else begin // write is in progress, wait`
288			`// for it to complete`
289			state <= `WBQSPI_WAIT_WIP_CLEAR;
290			`o_wb_ack <= 1'b0;`
291			`o_wb_stall <= 1'b1;`
292			`end`
293	22	dgisselq	`end else if (!write_in_progress)`
294	2	dgisselq	`begin // Read access, normal mode(s)`
295			`o_wb_ack <= 1'b0;`
296			`o_wb_stall <= 1'b1;`
297			`spi_wr <= 1'b1; // Write cmd to device`
298			`if (quad_mode_enabled)`
299			`begin`
300	14	dgisselq	`spi_in <= { 8'heb, w_wb_addr };`
301	2	dgisselq	state <= `WBQSPI_QRD_ADDRESS;
302			`spi_len <= 2'b00; // single byte, cmd only`
303			`end else begin`
304	14	dgisselq	`spi_in <= { 8'h0b, w_wb_addr };`
305	2	dgisselq	state <= `WBQSPI_RD_DUMMY;
306			`spi_len <= 2'b11; // cmd+addr,32bits`
307			`end`
308	22	dgisselq	`end else if (!OPT_READ_ONLY) begin`
309	2	dgisselq	`// A write is in progress ... need to stall`
310			`// the bus until the write is complete.`
311			state <= `WBQSPI_WAIT_WIP_CLEAR;
312			`o_wb_ack <= 1'b0;`
313			`o_wb_stall <= 1'b1;`
314			`end`
315	22	dgisselq	`end else if ((OPT_READ_ONLY)&&(i_wb_ctrl_stb)&&(i_wb_we))`
316	2	dgisselq	`begin`
317	7	dgisselq	`o_wb_ack <= 1'b1;`
318			`o_wb_stall <= 1'b0;`
319	22	dgisselq	`end else if ((i_wb_ctrl_stb)&&(i_wb_we))`
320			`begin`
321	2	dgisselq	`o_wb_stall <= 1'b1;`
322			`case(i_wb_addr[1:0])`
323			`2'b00: begin // Erase command register`
324	16	dgisselq	`write_protect <= !i_wb_data[28];`
325	2	dgisselq	`o_wb_stall <= 1'b0;`
326
327	16	dgisselq	`if((i_wb_data[31])&&(!write_in_progress))`
328	2	dgisselq	`begin`
329			`// Command an erase--ack it immediately`
330
331			`o_wb_ack <= 1'b1;`
332			`o_wb_stall <= 1'b0;`
333
334	22	dgisselq	`if ((i_wb_data[31])&&(!write_protect))`
335	2	dgisselq	`begin`
336			`spi_wr <= 1'b1;`
337			`spi_len <= 2'b00;`
338			`// Send a write enable command`
339			`spi_in <= { 8'h06, 24'h00 };`
340			state <= `WBQSPI_ERASE_CMD;
341			`o_wb_stall <= 1'b1;`
342			`end`
343			`end else if (i_wb_data[31])`
344			`begin`
345			state <= `WBQSPI_WAIT_WIP_CLEAR;
346			`o_wb_ack <= 1'b1;`
347			`o_wb_stall <= 1'b1;`
348	22	dgisselq	`end else begin`
349	2	dgisselq	`o_wb_ack <= 1'b1;`
350			`o_wb_stall <= 1'b0;`
351	22	dgisselq	`end end`
352	2	dgisselq	`2'b01: begin`
353			`// Write the configuration register`
354			`o_wb_ack <= 1'b1;`
355			`o_wb_stall <= 1'b1;`
356
357			`// Need to send a write enable command first`
358			`spi_wr <= 1'b1;`
359			`spi_len <= 2'b00; // 8 bits`
360			`// Send a write enable command`
361			`spi_in <= { 8'h06, 24'h00 };`
362			state <= `WBQSPI_WRITE_CONFIG;
363			`end`
364			`2'b10: begin`
365			`// Write the status register`
366			`o_wb_ack <= 1'b1; // Ack immediately`
367			`o_wb_stall <= 1'b1; // Stall other cmds`
368			`// Need to send a write enable command first`
369			`spi_wr <= 1'b1;`
370			`spi_len <= 2'b00; // 8 bits`
371			`// Send a write enable command`
372			`spi_in <= { 8'h06, 24'h00 };`
373			state <= `WBQSPI_WRITE_STATUS;
374			`end`
375			`2'b11: begin // Write the ID register??? makes no sense`
376			`o_wb_ack <= 1'b1;`
377			`o_wb_stall <= 1'b0;`
378			`end`
379			`endcase`
380	16	dgisselq	`end else if (i_wb_ctrl_stb) // &&(!i_wb_we))`
381	2	dgisselq	`begin`
382			`case(i_wb_addr[1:0])`
383			`2'b00: begin // Read local register`
384			`if (write_in_progress) // Read status`
385			`begin// register, is write still in progress?`
386			state <= `WBQSPI_READ_STATUS;
387			`spi_wr <= 1'b1;`
388			`spi_len <= 2'b01;// 8 bits out, 8 bits in`
389			`spi_in <= { 8'h05, 24'h00};`
390
391			`o_wb_ack <= 1'b0;`
392			`o_wb_stall <= 1'b1;`
393			`end else begin // Return w/o talking to device`
394			`o_wb_ack <= 1'b1;`
395			`o_wb_stall <= 1'b0;`
396			`o_wb_data <= { write_in_progress,`
397			`dirty_sector, spi_busy,`
398			`~write_protect,`
399			`quad_mode_enabled,`
400	7	dgisselq	`{(29-ADDRESS_WIDTH){1'b0}},`
401	2	dgisselq	`erased_sector, 14'h000 };`
402			`end end`
403			`2'b01: begin // Read configuration register`
404			state <= `WBQSPI_READ_CONFIG;
405			`spi_wr <= 1'b1;`
406			`spi_len <= 2'b01;`
407			`spi_in <= { 8'h35, 24'h00};`
408
409			`o_wb_ack <= 1'b0;`
410			`o_wb_stall <= 1'b1;`
411			`end`
412			`2'b10: begin // Read status register`
413			state <= `WBQSPI_READ_STATUS;
414			`spi_wr <= 1'b1;`
415			`spi_len <= 2'b01; // 8 bits out, 8 bits in`
416			`spi_in <= { 8'h05, 24'h00};`
417
418			`o_wb_ack <= 1'b0;`
419			`o_wb_stall <= 1'b1;`
420			`end`
421			`2'b11: begin // Read ID register`
422			state <= `WBQSPI_READ_ID_CMD;
423			`spi_wr <= 1'b1;`
424			`spi_len <= 2'b00;`
425			`spi_in <= { 8'h9f, 24'h00};`
426
427			`o_wb_ack <= 1'b0;`
428			`o_wb_stall <= 1'b1;`
429			`end`
430			`endcase`
431	22	dgisselq	`end else if ((!OPT_READ_ONLY)&&(!i_wb_cyc)&&(write_in_progress))`
432	2	dgisselq	`begin`
433			state <= `WBQSPI_IDLE_CHECK_WIP;
434			`spi_wr <= 1'b1;`
435			`spi_len <= 2'b01; // 8 bits out, 8 bits in`
436			`spi_in <= { 8'h05, 24'h00};`
437
438			`o_wb_ack <= 1'b0;`
439			`o_wb_stall <= 1'b1;`
440			`end`
441			end else if (state == `WBQSPI_RDIDLE)
442			`begin`
443			`spi_wr <= 1'b0;`
444			`o_wb_stall <= 1'b0;`
445			`o_wb_ack <= 1'b0;`
446			`spif_cmd <= i_wb_we;`
447			`spif_addr <= i_wb_addr;`
448			`spif_data <= i_wb_data;`
449	22	dgisselq	`spif_ctrl <= (i_wb_ctrl_stb)&&(!i_wb_data_stb);`
450	2	dgisselq	`spif_req <= (i_wb_ctrl_stb)\|\|(i_wb_data_stb);`
451			`spi_hold <= 1'b0;`
452			`spi_spd<= 1'b1;`
453			`spi_dir <= 1'b0; // Write (for now)`
454	16	dgisselq	`if ((i_wb_data_stb)&&(!i_wb_we))`
455	2	dgisselq	`begin // Continue our read ... send the new address / mode`
456			`o_wb_stall <= 1'b1;`
457			`spi_wr <= 1'b1;`
458	4	dgisselq	`spi_len <= 2'b10; // Write address, but not mode byte`
459	14	dgisselq	`spi_in <= { w_wb_addr, 8'ha0 };`
460	2	dgisselq	state <= `WBQSPI_QRD_DUMMY;
461	16	dgisselq	`end else if((i_wb_ctrl_stb)&&(!i_wb_we)&&(i_wb_addr[1:0] == 2'b00))`
462	2	dgisselq	`begin`
463			`// A local read that doesn't touch the device, so leave`
464			`// the device in its current state`
465			`o_wb_stall <= 1'b0;`
466			`o_wb_ack <= 1'b1;`
467			`o_wb_data <= { write_in_progress,`
468			`dirty_sector, spi_busy,`
469			`~write_protect,`
470			`quad_mode_enabled,`
471	7	dgisselq	`{(29-ADDRESS_WIDTH){1'b0}},`
472	2	dgisselq	`erased_sector, 14'h000 };`
473	14	dgisselq	`end else if(((i_wb_ctrl_stb)\|\|(i_wb_data_stb)))`
474	2	dgisselq	`begin // Need to release the device from quad mode for all else`
475			`o_wb_ack <= 1'b0;`
476			`o_wb_stall <= 1'b1;`
477			`spi_wr <= 1'b1;`
478			`spi_len <= 2'b11;`
479			`spi_in <= 32'h00;`
480			state <= `WBQSPI_WBDECODE;
481			`end`
482			end else if (state == `WBQSPI_WBDECODE)
483			`begin`
484			`// We were in quad SPI read mode, and had to get out.`
485			`// Now we've got a command (not data read) to read and`
486			`// execute. Accomplish what we would've done while in the`
487			`// IDLE state here, save only that we don't have to worry`
488			`// about data reads, and we need to operate on a stored`
489			`// version of the bus command`
490			`o_wb_stall <= 1'b1;`
491			`o_wb_ack <= 1'b0;`
492			`spi_wr <= 1'b0; // Keep the port idle, unless told otherwise`
493			`spi_hold <= 1'b0;`
494			`spi_spd <= 1'b0;`
495			`spi_dir <= 1'b0;`
496			`spif_req<= (spif_req) && (i_wb_cyc);`
497	22	dgisselq	`if ((!spi_busy)&&(o_qspi_cs_n)&&(!spi_wr)) // only in full idle ...`
498	2	dgisselq	`begin`
499			`// Data register access`
500	22	dgisselq	`if (!spif_ctrl)`

Browse

Tools

Subversion Repositories qspiflash

[/] [qspiflash/] [trunk/] [rtl/] [wbqspiflash.v] - Blame information for rev 24