Subversion Repositories xgate

////////////////////////////////////////////////////////////////////////////////
//
//  WISHBONE revB.2 compliant Xgate Coprocessor - Slave Bus interface
//
//  Author: Bob Hayes
//          rehayes@opencores.org
//
//  Downloaded from: http://www.opencores.org/projects/xgate.....
//
////////////////////////////////////////////////////////////////////////////////
// Copyright (c) 2009, Robert Hayes
//
// This source file is free software: 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.
//
// Supplemental terms.
//     * Redistributions of source code must retain the above copyright
//       notice, this list of conditions and the following disclaimer.
//     * Neither the name of the <organization> nor the
//       names of its contributors may be used to endorse or promote products
//       derived from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY Robert Hayes ''AS IS'' AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
// DISCLAIMED. IN NO EVENT SHALL Robert Hayes BE LIABLE FOR ANY
// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
////////////////////////////////////////////////////////////////////////////////
// 45678901234567890123456789012345678901234567890123456789012345678901234567890
 
module xgate_wbs_bus #(parameter ARST_LVL = 1'b0,    // asynchronous reset level
  		       parameter DWIDTH = 16,
                       parameter SINGLE_CYCLE = 1'b0)
  (
  // Wishbone Signals
  output reg  [DWIDTH-1:0] wbs_dat_o,     // databus output - Pseudo Register
  output                   wbs_ack_o,     // bus cycle acknowledge output
  output                   wbs_err_o,     // bus error, lost module select durning wait state
  input                    wbs_clk_i,     // master clock input
  input                    wbs_rst_i,     // synchronous active high reset
  input                    arst_i,        // asynchronous reset
  input             [ 5:1] wbs_adr_i,     // lower address bits
  input       [DWIDTH-1:0] wbs_dat_i,     // databus input
  input                    wbs_we_i,      // write enable input
  input                    wbs_stb_i,     // stobe/core select signal
  input                    wbs_cyc_i,     // valid bus cycle input
  input              [1:0] wbs_sel_i,     // Select byte in word bus transaction
  // XGATE Control Signals
  output reg               write_xgmctl, // Write Strobe for XGMCTL register
  output reg               write_xgchid, // Write Strobe for XGCHID register
  output reg               write_xgisp74,// Write Strobe for XGISP74 register
  output reg               write_xgisp30,// Write Strobe for XGISP30 register
  output reg         [1:0] write_xgvbr,  // Write Strobe for XGVBR register
  output reg         [1:0] write_xgif_7, // Write Strobe for Interrupt Flag Register 7
  output reg         [1:0] write_xgif_6, // Write Strobe for Interrupt Flag Register 6
  output reg         [1:0] write_xgif_5, // Write Strobe for Interrupt Flag Register 5
  output reg         [1:0] write_xgif_4, // Write Strobe for Interrupt Flag Register 4
  output reg         [1:0] write_xgif_3, // Write Strobe for Interrupt Flag Register 3
  output reg         [1:0] write_xgif_2, // Write Strobe for Interrupt Flag Register 2
  output reg         [1:0] write_xgif_1, // Write Strobe for Interrupt Flag Register 1
  output reg         [1:0] write_xgif_0, // Write Strobe for Interrupt Flag Register 0
  output reg               write_xgswt,  // Write Strobe for XGSWT register
  output reg               write_xgsem,  // Write Strobe for XGSEM register
  output reg               write_xgccr,  // Write Strobe for XGATE Condition Code Register
  output reg         [1:0] write_xgpc,   // Write Strobe for XGATE Program Counter
  output reg         [1:0] write_xgr7,   // Write Strobe for XGATE Data Register R7
  output reg         [1:0] write_xgr6,   // Write Strobe for XGATE Data Register R6
  output reg         [1:0] write_xgr5,   // Write Strobe for XGATE Data Register R5
  output reg         [1:0] write_xgr4,   // Write Strobe for XGATE Data Register R4
  output reg         [1:0] write_xgr3,   // Write Strobe for XGATE Data Register R3
  output reg         [1:0] write_xgr2,   // Write Strobe for XGATE Data Register R2
  output reg         [1:0] write_xgr1,   // Write Strobe for XGATE Data Register R1
  output                   async_rst_b,  //
  output                   sync_reset,   //
  input            [415:0] read_regs     // status register bits
  );
 
 
  // registers
  reg                bus_wait_state;  // Holdoff wbs_ack_o for one clock to add wait state
  reg         [4:0]  addr_latch;      // Capture WISHBONE Address 
 
  reg                write_reserv1;   // Dummy Reg decode for Reserved address
  reg                write_reserv2;   // Dummy Reg decode for Reserved address
 
  // Wires
  wire       module_sel;      // This module is selected for bus transaction
  wire       wbs_wacc;        // WISHBONE Write Strobe (Clock gating signal)
  wire       wbs_racc;        // WISHBONE Read Access (Clock gating signal)
  wire [4:0] address;         // Select either direct or latched address
 
  //
  // module body
  //
 
  // generate internal resets
  assign async_rst_b = arst_i ^ ARST_LVL;
  assign sync_reset  = wbs_rst_i;
 
  // generate wishbone signals
  assign module_sel  = wbs_cyc_i && wbs_stb_i;
  assign wbs_wacc    = module_sel && wbs_we_i && (wbs_ack_o || SINGLE_CYCLE);
  assign wbs_racc    = module_sel && !wbs_we_i;
  assign wbs_ack_o   = SINGLE_CYCLE ? module_sel : (bus_wait_state && module_sel);
  assign wbs_err_o   = !SINGLE_CYCLE && !module_sel && bus_wait_state;
  assign address     = SINGLE_CYCLE ? wbs_adr_i : addr_latch;
 
  // generate acknowledge output signal, By using register all accesses takes two cycles.
  //  Accesses in back to back clock cycles are not possable.
  always @(posedge wbs_clk_i or negedge async_rst_b)
    if (!async_rst_b)
      bus_wait_state <=  1'b0;
    else if (sync_reset)
      bus_wait_state <=  1'b0;
    else
      bus_wait_state <=  module_sel && !bus_wait_state;
 
  // Capture address in first cycle of WISHBONE Bus tranaction
  //  Only used when Wait states are enabled
  always @(posedge wbs_clk_i)
    if ( module_sel )                  // Clock gate for power saving
      addr_latch <= wbs_adr_i;
 
  // WISHBONE Read Data Mux
  always @*
      case (address) // synopsys parallel_case
	// 16 bit Bus, 16 bit Granularity
	5'b0_0000: wbs_dat_o = read_regs[ 15:  0];
	5'b0_0001: wbs_dat_o = read_regs[ 31: 16];
	5'b0_0010: wbs_dat_o = read_regs[ 47: 32];
	5'b0_0011: wbs_dat_o = read_regs[ 63: 48];
	5'b0_0100: wbs_dat_o = read_regs[ 79: 64];
	5'b0_0101: wbs_dat_o = read_regs[ 95: 80];
	5'b0_0110: wbs_dat_o = read_regs[111: 96];
	5'b0_0111: wbs_dat_o = read_regs[127:112];
	5'b0_1000: wbs_dat_o = read_regs[143:128];
	5'b0_1001: wbs_dat_o = read_regs[159:144];
	5'b0_1010: wbs_dat_o = read_regs[175:160];
	5'b0_1011: wbs_dat_o = read_regs[191:176];
	5'b0_1100: wbs_dat_o = read_regs[207:192];
	5'b0_1101: wbs_dat_o = read_regs[223:208];
	5'b0_1110: wbs_dat_o = read_regs[239:224];
	5'b0_1111: wbs_dat_o = read_regs[255:240];
	5'b1_0000: wbs_dat_o = read_regs[271:256];
	5'b1_0001: wbs_dat_o = read_regs[287:272];
	5'b1_0010: wbs_dat_o = read_regs[303:288];
	5'b1_0011: wbs_dat_o = read_regs[319:304];
	5'b1_0100: wbs_dat_o = read_regs[335:320];
	5'b1_0101: wbs_dat_o = read_regs[351:336];
	5'b1_0110: wbs_dat_o = read_regs[367:352];
	5'b1_0111: wbs_dat_o = read_regs[383:368];
	5'b1_1000: wbs_dat_o = read_regs[399:384];
	5'b1_1001: wbs_dat_o = read_regs[415:400];
	default: wbs_dat_o = 16'h0000;
      endcase
 
  // generate wishbone write register strobes
  always @*
    begin
      write_reserv1 = 1'b0;
      write_reserv2 = 1'b0;
      write_xgmctl  = 1'b0;
      write_xgchid  = 1'b0;
      write_xgisp74 = 1'b0;
      write_xgisp30 = 1'b0;
      write_xgvbr  = 2'b00;
      write_xgif_7 = 2'b00;
      write_xgif_6 = 2'b00;
      write_xgif_5 = 2'b00;
      write_xgif_4 = 2'b00;
      write_xgif_3 = 2'b00;
      write_xgif_2 = 2'b00;
      write_xgif_1 = 2'b00;
      write_xgif_0 = 2'b00;
      write_xgswt  = 1'b0;
      write_xgsem  = 1'b0;
      write_xgccr  = 1'b0;
      write_xgpc   = 2'b00;
      write_xgr7   = 2'b00;
      write_xgr6   = 2'b00;
      write_xgr5   = 2'b00;
      write_xgr4   = 2'b00;
      write_xgr3   = 2'b00;
      write_xgr2   = 2'b00;
      write_xgr1   = 2'b00;
      if (wbs_wacc)
	case (address) // synopsys parallel_case
           // 16 bit Bus, 8 bit Granularity
	   5'b0_0000 : write_xgmctl  = &wbs_sel_i;
	   5'b0_0001 : write_xgchid  = wbs_sel_i[0];
	   5'b0_0010 : write_xgisp74 = 1'b1;
	   5'b0_0011 : write_xgisp30 = 1'b1;
	   5'b0_0100 : write_xgvbr   = wbs_sel_i;
	   5'b0_0101 : write_xgif_7  = wbs_sel_i;
	   5'b0_0110 : write_xgif_6  = wbs_sel_i;
	   5'b0_0111 : write_xgif_5  = wbs_sel_i;
	   5'b0_1000 : write_xgif_4  = wbs_sel_i;
	   5'b0_1001 : write_xgif_3  = wbs_sel_i;
	   5'b0_1010 : write_xgif_2  = wbs_sel_i;
	   5'b0_1011 : write_xgif_1  = wbs_sel_i;
	   5'b0_1100 : write_xgif_0  = wbs_sel_i;
	   5'b0_1101 : write_xgswt   = &wbs_sel_i;
	   5'b0_1110 : write_xgsem   = &wbs_sel_i;
	   5'b0_1111 : write_reserv1 = 1'b1;
	   5'b1_0000 : write_xgccr   = wbs_sel_i[0];
	   5'b1_0001 : write_xgpc    = wbs_sel_i;
	   5'b1_0010 : write_reserv2 = 1'b1;
	   5'b1_0011 : write_xgr1    = wbs_sel_i;
	   5'b1_0100 : write_xgr2    = wbs_sel_i;
	   5'b1_0101 : write_xgr3    = wbs_sel_i;
	   5'b1_0110 : write_xgr4    = wbs_sel_i;
	   5'b1_0111 : write_xgr5    = wbs_sel_i;
	   5'b1_1000 : write_xgr6    = wbs_sel_i;
	   5'b1_1001 : write_xgr7    = wbs_sel_i;
	   default: ;
	endcase
    end
 
endmodule  // xgate_wbs_bus