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 WB_RD_DEFAULT = 0,  // WISHBONE Read Bus default state
                       parameter SINGLE_CYCLE  = 1'b0)
  (
  // Wishbone Signals
  output      [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             [ 6: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 reg         [1:0] write_irw_en_7, // Write Strobe for Interrupt Bypass Control Register 7
  output reg         [1:0] write_irw_en_6, // Write Strobe for Interrupt Bypass Control Register 6
  output reg         [1:0] write_irw_en_5, // Write Strobe for Interrupt Bypass Control Register 5
  output reg         [1:0] write_irw_en_4, // Write Strobe for Interrupt Bypass Control Register 4
  output reg         [1:0] write_irw_en_3, // Write Strobe for Interrupt Bypass Control Register 3
  output reg         [1:0] write_irw_en_2, // Write Strobe for Interrupt Bypass Control Register 2
  output reg         [1:0] write_irw_en_1, // Write Strobe for Interrupt Bypass Control Register 1
  output reg         [1:0] write_irw_en_0, // Write Strobe for Interrupt Bypass Control Register 0
  output                   async_rst_b,    //
  output                   sync_reset,     //
  input            [415:0] read_risc_regs, // status register bits for WISHBONE Read bus
  input            [127:1] irq_bypass      // IRQ status bits WISHBONE Read bus
  );
 
 
  // registers
  reg                bus_wait_state;  // Holdoff wbs_ack_o for one clock to add wait state
  reg         [5:0]  addr_latch;      // Capture WISHBONE Address
 
  reg                write_reserv1;   // Dummy Reg decode for Reserved address
  reg                write_reserv2;   // Dummy Reg decode for Reserved address
 
  reg  [DWIDTH-1:0]  read_mux_irq;    // Psudo register for WISHBONE IRQ read data bus mux
 
  // 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 [5:0] address;         // Select either direct or latched address
 
  reg [DWIDTH-1:0] read_mux_risc;  // Pseudo regester for WISHBONE RISC read data bus mux
 
  //
  // 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;
 
  assign wbs_dat_o   = read_mux_risc | read_mux_irq;
 
  // generate acknowledge output signal, By using register all accesses takes two cycles.
  //  Accesses in back to back clock cycles are not possible.
  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 for RISC status and control registers
  always @*
      case ({wbs_racc, address}) // synopsys parallel_case
        // 16 bit Bus, 16 bit Granularity
        7'b100_0000: read_mux_risc = read_risc_regs[ 15:  0];
        7'b100_0001: read_mux_risc = read_risc_regs[ 31: 16];
        7'b100_0010: read_mux_risc = read_risc_regs[ 47: 32];
        7'b100_0011: read_mux_risc = read_risc_regs[ 63: 48];
        7'b100_0100: read_mux_risc = read_risc_regs[ 79: 64];
        7'b100_0101: read_mux_risc = read_risc_regs[ 95: 80];
        7'b100_0110: read_mux_risc = read_risc_regs[111: 96];
        7'b100_0111: read_mux_risc = read_risc_regs[127:112];
        7'b100_1000: read_mux_risc = read_risc_regs[143:128];
        7'b100_1001: read_mux_risc = read_risc_regs[159:144];
        7'b100_1010: read_mux_risc = read_risc_regs[175:160];
        7'b100_1011: read_mux_risc = read_risc_regs[191:176];
        7'b100_1100: read_mux_risc = read_risc_regs[207:192];
        7'b100_1101: read_mux_risc = read_risc_regs[223:208];
        7'b100_1110: read_mux_risc = read_risc_regs[239:224];
        7'b100_1111: read_mux_risc = read_risc_regs[255:240];
        7'b101_0000: read_mux_risc = read_risc_regs[271:256];
        7'b101_0001: read_mux_risc = read_risc_regs[287:272];
        7'b101_0010: read_mux_risc = read_risc_regs[303:288];
        7'b101_0011: read_mux_risc = read_risc_regs[319:304];
        7'b101_0100: read_mux_risc = read_risc_regs[335:320];
        7'b101_0101: read_mux_risc = read_risc_regs[351:336];
        7'b101_0110: read_mux_risc = read_risc_regs[367:352];
        7'b101_0111: read_mux_risc = read_risc_regs[383:368];
        7'b101_1000: read_mux_risc = read_risc_regs[399:384];
        7'b101_1001: read_mux_risc = read_risc_regs[415:400];
        default: read_mux_risc = {DWIDTH{WB_RD_DEFAULT}};
      endcase
 
  // generate wishbone write register strobes for Xgate RISC
  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
           6'b00_0000 : write_xgmctl  = &wbs_sel_i;
           6'b00_0001 : write_xgchid  = wbs_sel_i[0];
           6'b00_0010 : write_xgisp74 = 1'b1;
           6'b00_0011 : write_xgisp30 = 1'b1;
           6'b00_0100 : write_xgvbr   = wbs_sel_i;
           6'b00_0101 : write_xgif_7  = wbs_sel_i;
           6'b00_0110 : write_xgif_6  = wbs_sel_i;
           6'b00_0111 : write_xgif_5  = wbs_sel_i;
           6'b00_1000 : write_xgif_4  = wbs_sel_i;
           6'b00_1001 : write_xgif_3  = wbs_sel_i;
           6'b00_1010 : write_xgif_2  = wbs_sel_i;
           6'b00_1011 : write_xgif_1  = wbs_sel_i;
           6'b00_1100 : write_xgif_0  = wbs_sel_i;
           6'b00_1101 : write_xgswt   = &wbs_sel_i;
           6'b00_1110 : write_xgsem   = &wbs_sel_i;
           6'b00_1111 : write_reserv1 = 1'b1;
           6'b01_0000 : write_xgccr   = wbs_sel_i[0];
           6'b01_0001 : write_xgpc    = wbs_sel_i;
           6'b01_0010 : write_reserv2 = 1'b1;
           6'b01_0011 : write_xgr1    = wbs_sel_i;
           6'b01_0100 : write_xgr2    = wbs_sel_i;
           6'b01_0101 : write_xgr3    = wbs_sel_i;
           6'b01_0110 : write_xgr4    = wbs_sel_i;
           6'b01_0111 : write_xgr5    = wbs_sel_i;
           6'b01_1000 : write_xgr6    = wbs_sel_i;
           6'b01_1001 : write_xgr7    = wbs_sel_i;
           default: ;
        endcase
    end
 
  // WISHBONE Read Data Mux for IRQ control registers
  always @*
      case ({wbs_racc, address}) // synopsys parallel_case
        // 16 bit Bus, 16 bit Granularity
        7'b110_0000: read_mux_irq = {irq_bypass[ 15:  1], 1'b0};
        7'b110_0001: read_mux_irq = irq_bypass[ 31: 16];
        7'b110_0010: read_mux_irq = irq_bypass[ 47: 32];
        7'b110_0011: read_mux_irq = irq_bypass[ 63: 48];
        7'b110_0100: read_mux_irq = irq_bypass[ 79: 64];
        7'b110_0101: read_mux_irq = irq_bypass[ 95: 80];
        7'b110_0110: read_mux_irq = irq_bypass[111: 96];
        7'b110_0111: read_mux_irq = irq_bypass[127:112];
        default: read_mux_irq = {DWIDTH{WB_RD_DEFAULT}};
      endcase
 
  // generate wishbone write register strobes for interrupt control
  always @*
    begin
      write_irw_en_7 = 2'b00;
      write_irw_en_6 = 2'b00;
      write_irw_en_5 = 2'b00;
      write_irw_en_4 = 2'b00;
      write_irw_en_3 = 2'b00;
      write_irw_en_2 = 2'b00;
      write_irw_en_1 = 2'b00;
      write_irw_en_0 = 2'b00;
      if (wbs_wacc)
        case (address) // synopsys parallel_case
           // 16 bit Bus, 8 bit Granularity
           6'b10_0000 : write_irw_en_0  = wbs_sel_i;
           6'b10_0001 : write_irw_en_1  = wbs_sel_i;
           6'b10_0010 : write_irw_en_2  = wbs_sel_i;
           6'b10_0011 : write_irw_en_3  = wbs_sel_i;
           6'b10_0100 : write_irw_en_4  = wbs_sel_i;
           6'b10_0101 : write_irw_en_5  = wbs_sel_i;
           6'b10_0110 : write_irw_en_6  = wbs_sel_i;
           6'b10_0111 : write_irw_en_7  = wbs_sel_i;
           default: ;
        endcase
    end
 
endmodule  // xgate_wbs_bus