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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [or1200/] [rtl/] [verilog/] [or1200_wb_biu.v] - Blame information for rev 729

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


//////////////////////////////////////////////////////////////////////
////                                                              ////
////  OR1200's WISHBONE BIU                                       ////
////                                                              ////
////  This file is part of the OpenRISC 1200 project              ////
////  http://opencores.org/project,or1k                           ////
////                                                              ////
////  Description                                                 ////
////  Implements WISHBONE interface                               ////
////                                                              ////
////  To Do:                                                      ////
////   - if biu_cyc/stb are deasserted and wb_ack_i is asserted   ////
////   and this happens even before aborted_r is asssrted,        ////
////   wb_ack_i will be delivered even though transfer is         ////
////   internally considered already aborted. However most        ////
////   wb_ack_i are externally registered and delayed. Normally   ////
////   this shouldn't cause any problems.                         ////
////                                                              ////
////  Author(s):                                                  ////
////      - Damjan Lampret, lampret@opencores.org                 ////
////                                                              ////
//////////////////////////////////////////////////////////////////////
////                                                              ////
//// Copyright (C) 2000 Authors and OPENCORES.ORG                 ////
////                                                              ////
//// This source file may be used and distributed without         ////
//// restriction provided that this copyright statement is not    ////
//// removed from the file and that any derivative work contains  ////
//// the original copyright notice and the associated disclaimer. ////
////                                                              ////
//// 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 2.1 of the License, or (at your option) any   ////
//// later version.                                               ////
////                                                              ////
//// This source is distributed in the hope that it will be       ////
//// useful, but WITHOUT ANY WARRANTY; without even the implied   ////
//// warranty of MERCHANTABILITY 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 source; if not, download it   ////
//// from http://www.opencores.org/lgpl.shtml                     ////
////                                                              ////
//////////////////////////////////////////////////////////////////////
//
//
// $Log: or1200_wb_biu.v,v $
// Revision 2.0  2010/06/30 11:00:00  ORSoC
// Major update: 
// Structure reordered and bugs fixed. 
//
 
// synopsys translate_off
`include "timescale.v"
// synopsys translate_on
`include "or1200_defines.v"
 
module or1200_wb_biu(
                     // RISC clock, reset and clock control
                     clk, rst, clmode,
 
                     // WISHBONE interface
                     wb_clk_i, wb_rst_i, wb_ack_i, wb_err_i, wb_rty_i, wb_dat_i,
                     wb_cyc_o, wb_adr_o, wb_stb_o, wb_we_o, wb_sel_o, wb_dat_o,
`ifdef OR1200_WB_CAB
                     wb_cab_o,
`endif
`ifdef OR1200_WB_B3
                     wb_cti_o, wb_bte_o,
`endif
 
                     // Internal RISC bus
                     biu_dat_i, biu_adr_i, biu_cyc_i, biu_stb_i, biu_we_i, biu_sel_i, biu_cab_i,
                     biu_dat_o, biu_ack_o, biu_err_o
                     );
 
   parameter dw = `OR1200_OPERAND_WIDTH;
   parameter aw = `OR1200_OPERAND_WIDTH;
   parameter bl = 4; /* Can currently be either 4 or 8 - the two optional line
                      sizes for the OR1200. */
 
 
   //
   // RISC clock, reset and clock control
   //
   input                                clk;            // RISC clock
   input                                rst;            // RISC reset
   input [1:0]                           clmode;         // 00 WB=RISC, 01 WB=RISC/2, 10 N/A, 11 WB=RISC/4
 
   //
   // WISHBONE interface
   //
   input                                wb_clk_i;       // clock input
   input                                wb_rst_i;       // reset input
   input                                wb_ack_i;       // normal termination
   input                                wb_err_i;       // termination w/ error
   input                                wb_rty_i;       // termination w/ retry
   input [dw-1:0]                        wb_dat_i;       // input data bus
   output                               wb_cyc_o;       // cycle valid output
   output [aw-1:0]                       wb_adr_o;       // address bus outputs
   output                               wb_stb_o;       // strobe output
   output                               wb_we_o;        // indicates write transfer
   output [3:0]                  wb_sel_o;       // byte select outputs
   output [dw-1:0]                       wb_dat_o;       // output data bus
`ifdef OR1200_WB_CAB
   output                               wb_cab_o;       // consecutive address burst
`endif
`ifdef OR1200_WB_B3
   output [2:0]                  wb_cti_o;       // cycle type identifier
   output [1:0]                  wb_bte_o;       // burst type extension
`endif
 
   //
   // Internal RISC interface
   //
   input [dw-1:0]                        biu_dat_i;      // input data bus
   input [aw-1:0]                        biu_adr_i;      // address bus
   input                                biu_cyc_i;      // WB cycle
   input                                biu_stb_i;      // WB strobe
   input                                biu_we_i;       // WB write enable
   input                                biu_cab_i;      // CAB input
   input [3:0]                           biu_sel_i;      // byte selects
   output [31:0]                         biu_dat_o;      // output data bus
   output                               biu_ack_o;      // ack output
   output                               biu_err_o;      // err output
 
   //
   // Registers
   //
   wire                                 wb_ack;         // normal termination
   reg [aw-1:0]                  wb_adr_o;       // address bus outputs
   reg                                  wb_cyc_o;       // cycle output
   reg                                  wb_stb_o;       // strobe output
   reg                                  wb_we_o;        // indicates write transfer
   reg [3:0]                             wb_sel_o;       // byte select outputs
`ifdef OR1200_WB_CAB
   reg                                  wb_cab_o;       // CAB output
`endif
`ifdef OR1200_WB_B3
   reg [2:0]                             wb_cti_o;       // cycle type identifier
   reg [1:0]                             wb_bte_o;       // burst type extension
`endif
`ifdef OR1200_NO_DC
   reg [dw-1:0]                  wb_dat_o;       // output data bus
`else
   assign wb_dat_o = biu_dat_i;    // No register on this - straight from DCRAM
`endif
 
`ifdef OR1200_WB_RETRY
   reg [`OR1200_WB_RETRY-1:0]            retry_cnt;      // Retry counter
`else
   wire                                 retry_cnt;
   assign retry_cnt = 1'b0;
`endif
`ifdef OR1200_WB_B3
   reg [3:0]                             burst_len;      // burst counter
`endif
 
   reg                                  biu_stb_reg;    // WB strobe
   wire                                 biu_stb;        // WB strobe
   reg                                  wb_cyc_nxt;     // next WB cycle value
   reg                                  wb_stb_nxt;     // next WB strobe value
   reg [2:0]                             wb_cti_nxt;     // next cycle type identifier value
 
   reg                                  wb_ack_cnt;     // WB ack toggle counter
   reg                                  wb_err_cnt;     // WB err toggle counter
   reg                                  wb_rty_cnt;     // WB rty toggle counter
   reg                                  biu_ack_cnt;    // BIU ack toggle counter
   reg                                  biu_err_cnt;    // BIU err toggle counter
   reg                                  biu_rty_cnt;    // BIU rty toggle counter
   wire                                 biu_rty;        // BIU rty indicator
 
   reg [1:0]                             wb_fsm_state_cur;       // WB FSM - surrent state
   reg [1:0]                             wb_fsm_state_nxt;       // WB FSM - next state
   wire [1:0]                            wb_fsm_idle     = 2'h0; // WB FSM state - IDLE
   wire [1:0]                            wb_fsm_trans    = 2'h1; // WB FSM state - normal TRANSFER
   wire [1:0]                            wb_fsm_last     = 2'h2; // EB FSM state - LAST transfer
 
   //
   // WISHBONE I/F <-> Internal RISC I/F conversion
   //
   //assign wb_ack = wb_ack_i;
   assign wb_ack = wb_ack_i & !wb_err_i & !wb_rty_i;
 
   //
   // WB FSM - register part
   // 
   always @(posedge wb_clk_i or `OR1200_RST_EVENT wb_rst_i) begin
      if (wb_rst_i == `OR1200_RST_VALUE)
        wb_fsm_state_cur <=  wb_fsm_idle;
      else
        wb_fsm_state_cur <=  wb_fsm_state_nxt;
   end
 
   //
   // WB burst tength counter
   // 
   always @(posedge wb_clk_i or `OR1200_RST_EVENT wb_rst_i) begin
      if (wb_rst_i == `OR1200_RST_VALUE) begin
         burst_len <= 0;
      end
      else begin
         // burst counter
         if (wb_fsm_state_cur == wb_fsm_idle)
           burst_len <=  bl[3:0] - 2;
         else if (wb_stb_o & wb_ack)
           burst_len <=  burst_len - 1;
      end
   end
 
   // 
   // WB FSM - combinatorial part
   // 
   always @(wb_fsm_state_cur or burst_len or wb_err_i or wb_rty_i or wb_ack or
            wb_cti_o or wb_sel_o or wb_stb_o or wb_we_o or biu_cyc_i or
            biu_stb or biu_cab_i or biu_sel_i or biu_we_i) begin
      // States of WISHBONE Finite State Machine
      case(wb_fsm_state_cur)
        // IDLE 
        wb_fsm_idle : begin
           wb_cyc_nxt = biu_cyc_i & biu_stb;
           wb_stb_nxt = biu_cyc_i & biu_stb;
           wb_cti_nxt = {!biu_cab_i, 1'b1, !biu_cab_i};
           if (biu_cyc_i & biu_stb)
             wb_fsm_state_nxt = wb_fsm_trans;
           else
             wb_fsm_state_nxt = wb_fsm_idle;
        end
        // normal TRANSFER
        wb_fsm_trans : begin
           wb_cyc_nxt = !wb_stb_o | !wb_err_i & !wb_rty_i &
                        !(wb_ack & wb_cti_o == 3'b111);
 
           wb_stb_nxt = !wb_stb_o | !wb_err_i & !wb_rty_i & !wb_ack |
                        !wb_err_i & !wb_rty_i & wb_cti_o == 3'b010 ;
           wb_cti_nxt[2] = wb_stb_o & wb_ack & burst_len == 'h0 | wb_cti_o[2];
           wb_cti_nxt[1] = 1'b1  ;
           wb_cti_nxt[0] = wb_stb_o & wb_ack & burst_len == 'h0 | wb_cti_o[0];
 
           if ((!biu_cyc_i | !biu_stb | !biu_cab_i | biu_sel_i != wb_sel_o |
                biu_we_i != wb_we_o) & wb_cti_o == 3'b010)
             wb_fsm_state_nxt = wb_fsm_last;
           else if ((wb_err_i | wb_rty_i | wb_ack & wb_cti_o==3'b111) &
                    wb_stb_o)
             wb_fsm_state_nxt = wb_fsm_idle;
           else
             wb_fsm_state_nxt = wb_fsm_trans;
        end
        // LAST transfer
        wb_fsm_last : begin
           wb_cyc_nxt = !wb_stb_o | !wb_err_i & !wb_rty_i &
                        !(wb_ack & wb_cti_o == 3'b111);
           wb_stb_nxt = !wb_stb_o | !wb_err_i & !wb_rty_i &
                        !(wb_ack & wb_cti_o == 3'b111);
           wb_cti_nxt[2] = wb_ack & wb_stb_o | wb_cti_o[2];
           wb_cti_nxt[1] = 1'b1                  ;
           wb_cti_nxt[0] = wb_ack & wb_stb_o | wb_cti_o[0];
           if ((wb_err_i | wb_rty_i | wb_ack & wb_cti_o == 3'b111) & wb_stb_o)
             wb_fsm_state_nxt = wb_fsm_idle;
           else
             wb_fsm_state_nxt = wb_fsm_last;
        end
        // default state
        default:begin
           wb_cyc_nxt = 1'bx;
           wb_stb_nxt = 1'bx;
           wb_cti_nxt = 3'bxxx;
           wb_fsm_state_nxt = 2'bxx;
        end
      endcase
   end
 
   //
   // WB FSM - output signals
   // 
   always @(posedge wb_clk_i or `OR1200_RST_EVENT wb_rst_i) begin
      if (wb_rst_i == `OR1200_RST_VALUE) begin
         wb_cyc_o       <=  1'b0;
         wb_stb_o       <=  1'b0;
         wb_cti_o       <=  3'b111;
         wb_bte_o       <=  (bl==8) ? 2'b10 : (bl==4) ? 2'b01 : 2'b00;
`ifdef OR1200_WB_CAB
         wb_cab_o       <=  1'b0;
`endif
         wb_we_o                <=  1'b0;
         wb_sel_o       <=  4'hf;
         wb_adr_o       <=  {aw{1'b0}};
`ifdef OR1200_NO_DC
         wb_dat_o       <=  {dw{1'b0}};
`endif
      end
      else begin
         wb_cyc_o       <=  wb_cyc_nxt;
 
         if (wb_ack & wb_cti_o == 3'b111)
           wb_stb_o        <=  1'b0;
         else
           wb_stb_o        <=  wb_stb_nxt;
`ifndef OR1200_NO_BURSTS
         wb_cti_o       <=  wb_cti_nxt;
`endif
         wb_bte_o       <=  (bl==8) ? 2'b10 : (bl==4) ? 2'b01 : 2'b00;
`ifdef OR1200_WB_CAB
         wb_cab_o       <=  biu_cab_i;
`endif
         // we and sel - set at beginning of access 
         if (wb_fsm_state_cur == wb_fsm_idle) begin
            wb_we_o             <=  biu_we_i;
            wb_sel_o    <=  biu_sel_i;
         end
         // adr - set at beginning of access and changed at every termination 
         if (wb_fsm_state_cur == wb_fsm_idle) begin
            wb_adr_o    <=  biu_adr_i;
         end
         else if (wb_stb_o & wb_ack) begin
            if (bl==4) begin
               wb_adr_o[3:2]    <=  wb_adr_o[3:2] + 1;
            end
            if (bl==8) begin
               wb_adr_o[4:2]    <=  wb_adr_o[4:2] + 1;
            end
         end
`ifdef OR1200_NO_DC
         // dat - write data changed after avery subsequent write access
         if (!wb_stb_o) begin
            wb_dat_o    <=  biu_dat_i;
         end
`endif
      end
   end
 
   //
   // WB & BIU termination toggle counters
   // 
   always @(posedge wb_clk_i or `OR1200_RST_EVENT wb_rst_i) begin
      if (wb_rst_i == `OR1200_RST_VALUE) begin
         wb_ack_cnt     <=  1'b0;
         wb_err_cnt     <=  1'b0;
         wb_rty_cnt     <=  1'b0;
      end
      else begin
         // WB ack toggle counter
         if (wb_fsm_state_cur == wb_fsm_idle | !(|clmode))
           wb_ack_cnt   <=  1'b0;
         else if (wb_stb_o & wb_ack)
           wb_ack_cnt   <=  !wb_ack_cnt;
         // WB err toggle counter
         if (wb_fsm_state_cur == wb_fsm_idle | !(|clmode))
           wb_err_cnt   <=  1'b0;
         else if (wb_stb_o & wb_err_i)
           wb_err_cnt   <=  !wb_err_cnt;
         // WB rty toggle counter
         if (wb_fsm_state_cur == wb_fsm_idle | !(|clmode))
           wb_rty_cnt   <=  1'b0;
         else if (wb_stb_o & wb_rty_i)
           wb_rty_cnt   <=  !wb_rty_cnt;
      end
   end
 
   always @(posedge clk or `OR1200_RST_EVENT rst) begin
      if (rst == `OR1200_RST_VALUE) begin
         biu_stb_reg    <=  1'b0;
         biu_ack_cnt    <=  1'b0;
         biu_err_cnt    <=  1'b0;
         biu_rty_cnt    <=  1'b0;
`ifdef OR1200_WB_RETRY
         retry_cnt      <= {`OR1200_WB_RETRY{1'b0}};
`endif
      end
      else begin
         // BIU strobe
         if (biu_stb_i & !biu_cab_i & biu_ack_o)
           biu_stb_reg  <=  1'b0;
         else
           biu_stb_reg  <=  biu_stb_i;
         // BIU ack toggle counter
         if (wb_fsm_state_cur == wb_fsm_idle | !(|clmode))
           biu_ack_cnt  <=  1'b0 ;
         else if (biu_ack_o)
           biu_ack_cnt  <=  !biu_ack_cnt ;
         // BIU err toggle counter
         if (wb_fsm_state_cur == wb_fsm_idle | !(|clmode))
           biu_err_cnt  <=  1'b0 ;
         else if (wb_err_i & biu_err_o)
           biu_err_cnt  <=  !biu_err_cnt ;
         // BIU rty toggle counter
         if (wb_fsm_state_cur == wb_fsm_idle | !(|clmode))
           biu_rty_cnt  <=  1'b0 ;
         else if (biu_rty)
           biu_rty_cnt  <=  !biu_rty_cnt ;
`ifdef OR1200_WB_RETRY
         if (biu_ack_o | biu_err_o)
           retry_cnt    <=  {`OR1200_WB_RETRY{1'b0}};
         else if (biu_rty)
           retry_cnt    <=  retry_cnt + 1'b1;
`endif
      end
   end
 
   assign biu_stb = biu_stb_i & biu_stb_reg;
 
   //
   // Input BIU data bus
   //
   assign       biu_dat_o       = wb_dat_i;
 
   //
   // Input BIU termination signals 
   //
   assign       biu_rty         = (wb_fsm_state_cur == wb_fsm_trans) & wb_rty_i & wb_stb_o & (wb_rty_cnt ~^ biu_rty_cnt);
   assign       biu_ack_o       = (wb_fsm_state_cur == wb_fsm_trans) & wb_ack & wb_stb_o & (wb_ack_cnt ~^ biu_ack_cnt);
   assign       biu_err_o       = (wb_fsm_state_cur == wb_fsm_trans) & wb_err_i & wb_stb_o & (wb_err_cnt ~^ biu_err_cnt)
`ifdef OR1200_WB_RETRY
     | biu_rty & retry_cnt[`OR1200_WB_RETRY-1];
`else
   ;
`endif
 
 
endmodule

Line No.	Rev	Author	Line
1	10	unneback	`//////////////////////////////////////////////////////////////////////`
2			`//// ////`
3			`//// OR1200's WISHBONE BIU ////`
4			`//// ////`
5			`//// This file is part of the OpenRISC 1200 project ////`
6	258	julius	`//// http://opencores.org/project,or1k ////`
7	10	unneback	`//// ////`
8			`//// Description ////`
9			`//// Implements WISHBONE interface ////`
10			`//// ////`
11			`//// To Do: ////`
12			`//// - if biu_cyc/stb are deasserted and wb_ack_i is asserted ////`
13			`//// and this happens even before aborted_r is asssrted, ////`
14			`//// wb_ack_i will be delivered even though transfer is ////`
15			`//// internally considered already aborted. However most ////`
16			`//// wb_ack_i are externally registered and delayed. Normally ////`
17			`//// this shouldn't cause any problems. ////`
18			`//// ////`
19			`//// Author(s): ////`
20			`//// - Damjan Lampret, lampret@opencores.org ////`
21			`//// ////`
22			`//////////////////////////////////////////////////////////////////////`
23			`//// ////`
24			`//// Copyright (C) 2000 Authors and OPENCORES.ORG ////`
25			`//// ////`
26			`//// This source file may be used and distributed without ////`
27			`//// restriction provided that this copyright statement is not ////`
28			`//// removed from the file and that any derivative work contains ////`
29			`//// the original copyright notice and the associated disclaimer. ////`
30			`//// ////`
31			`//// This source file is free software; you can redistribute it ////`
32			`//// and/or modify it under the terms of the GNU Lesser General ////`
33			`//// Public License as published by the Free Software Foundation; ////`
34			`//// either version 2.1 of the License, or (at your option) any ////`
35			`//// later version. ////`
36			`//// ////`
37			`//// This source is distributed in the hope that it will be ////`
38			`//// useful, but WITHOUT ANY WARRANTY; without even the implied ////`
39			`//// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR ////`
40			`//// PURPOSE. See the GNU Lesser General Public License for more ////`
41			`//// details. ////`
42			`//// ////`
43			`//// You should have received a copy of the GNU Lesser General ////`
44			`//// Public License along with this source; if not, download it ////`
45			`//// from http://www.opencores.org/lgpl.shtml ////`
46			`//// ////`
47			`//////////////////////////////////////////////////////////////////////`
48			`//`
49			`//`
50	142	marcus.erl	`// $Log: or1200_wb_biu.v,v $`
51			`// Revision 2.0 2010/06/30 11:00:00 ORSoC`
52			`// Major update:`
53			`// Structure reordered and bugs fixed.`
54			`//`
55	10	unneback
56			`// synopsys translate_off`
57			`include "timescale.v"
58			`// synopsys translate_on`
59			`include "or1200_defines.v"
60
61			`module or1200_wb_biu(`
62	258	julius	`// RISC clock, reset and clock control`
63			`clk, rst, clmode,`
64	10	unneback
65	258	julius	`// WISHBONE interface`
66			`wb_clk_i, wb_rst_i, wb_ack_i, wb_err_i, wb_rty_i, wb_dat_i,`
67			`wb_cyc_o, wb_adr_o, wb_stb_o, wb_we_o, wb_sel_o, wb_dat_o,`
68	10	unneback	`ifdef OR1200_WB_CAB
69	258	julius	`wb_cab_o,`
70	10	unneback	`endif
71			`ifdef OR1200_WB_B3
72	258	julius	`wb_cti_o, wb_bte_o,`
73	10	unneback	`endif
74
75	258	julius	`// Internal RISC bus`
76			`biu_dat_i, biu_adr_i, biu_cyc_i, biu_stb_i, biu_we_i, biu_sel_i, biu_cab_i,`
77			`biu_dat_o, biu_ack_o, biu_err_o`
78			`);`
79	10	unneback
80	258	julius	parameter dw = `OR1200_OPERAND_WIDTH;
81			parameter aw = `OR1200_OPERAND_WIDTH;
82	481	julius	`parameter bl = 4; /* Can currently be either 4 or 8 - the two optional line`
83			`sizes for the OR1200. */`
84
85
86	258	julius	`//`
87			`// RISC clock, reset and clock control`
88			`//`
89			`input clk; // RISC clock`
90			`input rst; // RISC reset`
91			`input [1:0] clmode; // 00 WB=RISC, 01 WB=RISC/2, 10 N/A, 11 WB=RISC/4`
92	10	unneback
93	258	julius	`//`
94			`// WISHBONE interface`
95			`//`
96			`input wb_clk_i; // clock input`
97			`input wb_rst_i; // reset input`
98			`input wb_ack_i; // normal termination`
99			`input wb_err_i; // termination w/ error`
100			`input wb_rty_i; // termination w/ retry`
101			`input [dw-1:0] wb_dat_i; // input data bus`
102			`output wb_cyc_o; // cycle valid output`
103			`output [aw-1:0] wb_adr_o; // address bus outputs`
104			`output wb_stb_o; // strobe output`
105			`output wb_we_o; // indicates write transfer`
106			`output [3:0] wb_sel_o; // byte select outputs`
107			`output [dw-1:0] wb_dat_o; // output data bus`
108	10	unneback	`ifdef OR1200_WB_CAB
109	258	julius	`output wb_cab_o; // consecutive address burst`
110	10	unneback	`endif
111			`ifdef OR1200_WB_B3
112	258	julius	`output [2:0] wb_cti_o; // cycle type identifier`
113			`output [1:0] wb_bte_o; // burst type extension`
114	10	unneback	`endif
115
116	258	julius	`//`
117			`// Internal RISC interface`
118			`//`
119			`input [dw-1:0] biu_dat_i; // input data bus`
120			`input [aw-1:0] biu_adr_i; // address bus`
121			`input biu_cyc_i; // WB cycle`
122			`input biu_stb_i; // WB strobe`
123			`input biu_we_i; // WB write enable`
124			`input biu_cab_i; // CAB input`
125			`input [3:0] biu_sel_i; // byte selects`
126			`output [31:0] biu_dat_o; // output data bus`
127			`output biu_ack_o; // ack output`
128			`output biu_err_o; // err output`
129	10	unneback
130	258	julius	`//`
131			`// Registers`
132			`//`
133			`wire wb_ack; // normal termination`
134			`reg [aw-1:0] wb_adr_o; // address bus outputs`
135			`reg wb_cyc_o; // cycle output`
136			`reg wb_stb_o; // strobe output`
137			`reg wb_we_o; // indicates write transfer`
138			`reg [3:0] wb_sel_o; // byte select outputs`
139	10	unneback	`ifdef OR1200_WB_CAB
140	258	julius	`reg wb_cab_o; // CAB output`
141	10	unneback	`endif
142			`ifdef OR1200_WB_B3
143	258	julius	`reg [2:0] wb_cti_o; // cycle type identifier`
144			`reg [1:0] wb_bte_o; // burst type extension`
145	10	unneback	`endif
146	258	julius	`ifdef OR1200_NO_DC
147			`reg [dw-1:0] wb_dat_o; // output data bus`
148			`else
149			`assign wb_dat_o = biu_dat_i; // No register on this - straight from DCRAM`
150			`endif
151
152	10	unneback	`ifdef OR1200_WB_RETRY
153	258	julius	reg [`OR1200_WB_RETRY-1:0] retry_cnt; // Retry counter
154	10	unneback	`else
155	258	julius	`wire retry_cnt;`
156			`assign retry_cnt = 1'b0;`
157	10	unneback	`endif
158	142	marcus.erl	`ifdef OR1200_WB_B3
159	481	julius	`reg [3:0] burst_len; // burst counter`
160	10	unneback	`endif
161
162	258	julius	`reg biu_stb_reg; // WB strobe`
163			`wire biu_stb; // WB strobe`
164			`reg wb_cyc_nxt; // next WB cycle value`
165			`reg wb_stb_nxt; // next WB strobe value`
166			`reg [2:0] wb_cti_nxt; // next cycle type identifier value`
167	10	unneback
168	258	julius	`reg wb_ack_cnt; // WB ack toggle counter`
169			`reg wb_err_cnt; // WB err toggle counter`
170			`reg wb_rty_cnt; // WB rty toggle counter`
171			`reg biu_ack_cnt; // BIU ack toggle counter`
172			`reg biu_err_cnt; // BIU err toggle counter`
173			`reg biu_rty_cnt; // BIU rty toggle counter`
174			`wire biu_rty; // BIU rty indicator`
175	10	unneback
176	258	julius	`reg [1:0] wb_fsm_state_cur; // WB FSM - surrent state`
177			`reg [1:0] wb_fsm_state_nxt; // WB FSM - next state`
178			`wire [1:0] wb_fsm_idle = 2'h0; // WB FSM state - IDLE`
179			`wire [1:0] wb_fsm_trans = 2'h1; // WB FSM state - normal TRANSFER`
180			`wire [1:0] wb_fsm_last = 2'h2; // EB FSM state - LAST transfer`
181	10	unneback
182	258	julius	`//`
183			`// WISHBONE I/F <-> Internal RISC I/F conversion`
184			`//`
185			`//assign wb_ack = wb_ack_i;`
186			`assign wb_ack = wb_ack_i & !wb_err_i & !wb_rty_i;`
187	10	unneback
188	258	julius	`//`
189			`// WB FSM - register part`
190			`//`
191	358	julius	always @(posedge wb_clk_i or `OR1200_RST_EVENT wb_rst_i) begin
192			if (wb_rst_i == `OR1200_RST_VALUE)
193	258	julius	`wb_fsm_state_cur <= wb_fsm_idle;`
194			`else`
195			`wb_fsm_state_cur <= wb_fsm_state_nxt;`
196			`end`
197	10	unneback
198	258	julius	`//`
199			`// WB burst tength counter`
200			`//`
201	358	julius	always @(posedge wb_clk_i or `OR1200_RST_EVENT wb_rst_i) begin
202			if (wb_rst_i == `OR1200_RST_VALUE) begin
203	481	julius	`burst_len <= 0;`
204	258	julius	`end`
205			`else begin`
206			`// burst counter`
207			`if (wb_fsm_state_cur == wb_fsm_idle)`
208	481	julius	`burst_len <= bl[3:0] - 2;`
209	258	julius	`else if (wb_stb_o & wb_ack)`
210	481	julius	`burst_len <= burst_len - 1;`
211	258	julius	`end`
212			`end`
213	10	unneback
214	258	julius	`//`
215			`// WB FSM - combinatorial part`
216			`//`
217			`always @(wb_fsm_state_cur or burst_len or wb_err_i or wb_rty_i or wb_ack or`
218			`wb_cti_o or wb_sel_o or wb_stb_o or wb_we_o or biu_cyc_i or`
219			`biu_stb or biu_cab_i or biu_sel_i or biu_we_i) begin`
220			`// States of WISHBONE Finite State Machine`
221			`case(wb_fsm_state_cur)`
222	142	marcus.erl	`// IDLE`
223			`wb_fsm_idle : begin`
224	258	julius	`wb_cyc_nxt = biu_cyc_i & biu_stb;`
225			`wb_stb_nxt = biu_cyc_i & biu_stb;`
226			`wb_cti_nxt = {!biu_cab_i, 1'b1, !biu_cab_i};`
227			`if (biu_cyc_i & biu_stb)`
228			`wb_fsm_state_nxt = wb_fsm_trans;`
229			`else`
230			`wb_fsm_state_nxt = wb_fsm_idle;`
231	142	marcus.erl	`end`
232			`// normal TRANSFER`
233			`wb_fsm_trans : begin`
234	258	julius	`wb_cyc_nxt = !wb_stb_o \| !wb_err_i & !wb_rty_i &`
235			`!(wb_ack & wb_cti_o == 3'b111);`
236
237			`wb_stb_nxt = !wb_stb_o \| !wb_err_i & !wb_rty_i & !wb_ack \|`
238	481	julius	`!wb_err_i & !wb_rty_i & wb_cti_o == 3'b010 ;`
239	258	julius	`wb_cti_nxt[2] = wb_stb_o & wb_ack & burst_len == 'h0 \| wb_cti_o[2];`
240			`wb_cti_nxt[1] = 1'b1 ;`
241			`wb_cti_nxt[0] = wb_stb_o & wb_ack & burst_len == 'h0 \| wb_cti_o[0];`
242	481	julius
243	258	julius	`if ((!biu_cyc_i \| !biu_stb \| !biu_cab_i \| biu_sel_i != wb_sel_o \|`
244			`biu_we_i != wb_we_o) & wb_cti_o == 3'b010)`
245			`wb_fsm_state_nxt = wb_fsm_last;`
246			`else if ((wb_err_i \| wb_rty_i \| wb_ack & wb_cti_o==3'b111) &`
247			`wb_stb_o)`
248			`wb_fsm_state_nxt = wb_fsm_idle;`
249			`else`
250			`wb_fsm_state_nxt = wb_fsm_trans;`
251	142	marcus.erl	`end`
252			`// LAST transfer`
253			`wb_fsm_last : begin`
254	258	julius	`wb_cyc_nxt = !wb_stb_o \| !wb_err_i & !wb_rty_i &`
255			`!(wb_ack & wb_cti_o == 3'b111);`
256			`wb_stb_nxt = !wb_stb_o \| !wb_err_i & !wb_rty_i &`
257			`!(wb_ack & wb_cti_o == 3'b111);`
258			`wb_cti_nxt[2] = wb_ack & wb_stb_o \| wb_cti_o[2];`
259			`wb_cti_nxt[1] = 1'b1 ;`
260			`wb_cti_nxt[0] = wb_ack & wb_stb_o \| wb_cti_o[0];`
261			`if ((wb_err_i \| wb_rty_i \| wb_ack & wb_cti_o == 3'b111) & wb_stb_o)`
262			`wb_fsm_state_nxt = wb_fsm_idle;`
263			`else`
264			`wb_fsm_state_nxt = wb_fsm_last;`
265	142	marcus.erl	`end`
266			`// default state`
267			`default:begin`
268	258	julius	`wb_cyc_nxt = 1'bx;`
269			`wb_stb_nxt = 1'bx;`
270			`wb_cti_nxt = 3'bxxx;`
271			`wb_fsm_state_nxt = 2'bxx;`
272	142	marcus.erl	`end`
273	258	julius	`endcase`
274			`end`
275	10	unneback
276	258	julius	`//`
277			`// WB FSM - output signals`
278			`//`
279	358	julius	always @(posedge wb_clk_i or `OR1200_RST_EVENT wb_rst_i) begin
280			if (wb_rst_i == `OR1200_RST_VALUE) begin
281	258	julius	`wb_cyc_o <= 1'b0;`
282			`wb_stb_o <= 1'b0;`
283			`wb_cti_o <= 3'b111;`
284	481	julius	`wb_bte_o <= (bl==8) ? 2'b10 : (bl==4) ? 2'b01 : 2'b00;`
285	142	marcus.erl	`ifdef OR1200_WB_CAB
286	258	julius	`wb_cab_o <= 1'b0;`
287	10	unneback	`endif
288	258	julius	`wb_we_o <= 1'b0;`
289			`wb_sel_o <= 4'hf;`
290			`wb_adr_o <= {aw{1'b0}};`
291			`ifdef OR1200_NO_DC
292			`wb_dat_o <= {dw{1'b0}};`
293			`endif
294			`end`
295			`else begin`
296			`wb_cyc_o <= wb_cyc_nxt;`
297	481	julius
298	258	julius	`if (wb_ack & wb_cti_o == 3'b111)`
299			`wb_stb_o <= 1'b0;`
300			`else`
301			`wb_stb_o <= wb_stb_nxt;`
302	481	julius	`ifndef OR1200_NO_BURSTS
303	258	julius	`wb_cti_o <= wb_cti_nxt;`
304	481	julius	`endif
305			`wb_bte_o <= (bl==8) ? 2'b10 : (bl==4) ? 2'b01 : 2'b00;`
306	142	marcus.erl	`ifdef OR1200_WB_CAB
307	258	julius	`wb_cab_o <= biu_cab_i;`
308	10	unneback	`endif
309	258	julius	`// we and sel - set at beginning of access`
310			`if (wb_fsm_state_cur == wb_fsm_idle) begin`
311			`wb_we_o <= biu_we_i;`
312			`wb_sel_o <= biu_sel_i;`
313			`end`
314			`// adr - set at beginning of access and changed at every termination`
315			`if (wb_fsm_state_cur == wb_fsm_idle) begin`
316			`wb_adr_o <= biu_adr_i;`
317			`end`
318			`else if (wb_stb_o & wb_ack) begin`
319	481	julius	`if (bl==4) begin`
320			`wb_adr_o[3:2] <= wb_adr_o[3:2] + 1;`
321			`end`
322			`if (bl==8) begin`
323			`wb_adr_o[4:2] <= wb_adr_o[4:2] + 1;`
324			`end`
325	258	julius	`end`
326			`ifdef OR1200_NO_DC
327			`// dat - write data changed after avery subsequent write access`
328			`if (!wb_stb_o) begin`
329			`wb_dat_o <= biu_dat_i;`
330			`end`
331			`endif
332			`end`
333			`end`
334	10	unneback
335	258	julius	`//`
336			`// WB & BIU termination toggle counters`
337			`//`
338	358	julius	always @(posedge wb_clk_i or `OR1200_RST_EVENT wb_rst_i) begin
339			if (wb_rst_i == `OR1200_RST_VALUE) begin
340	258	julius	`wb_ack_cnt <= 1'b0;`
341			`wb_err_cnt <= 1'b0;`
342			`wb_rty_cnt <= 1'b0;`
343			`end`
344			`else begin`
345			`// WB ack toggle counter`
346	364	julius	`if (wb_fsm_state_cur == wb_fsm_idle \| !(\|clmode))`
347	258	julius	`wb_ack_cnt <= 1'b0;`
348			`else if (wb_stb_o & wb_ack)`
349			`wb_ack_cnt <= !wb_ack_cnt;`
350			`// WB err toggle counter`
351	364	julius	`if (wb_fsm_state_cur == wb_fsm_idle \| !(\|clmode))`
352	258	julius	`wb_err_cnt <= 1'b0;`
353			`else if (wb_stb_o & wb_err_i)`
354			`wb_err_cnt <= !wb_err_cnt;`
355			`// WB rty toggle counter`
356	364	julius	`if (wb_fsm_state_cur == wb_fsm_idle \| !(\|clmode))`
357	258	julius	`wb_rty_cnt <= 1'b0;`
358			`else if (wb_stb_o & wb_rty_i)`
359			`wb_rty_cnt <= !wb_rty_cnt;`
360			`end`
361			`end`
362	10	unneback
363	358	julius	always @(posedge clk or `OR1200_RST_EVENT rst) begin
364			if (rst == `OR1200_RST_VALUE) begin
365	258	julius	`biu_stb_reg <= 1'b0;`
366			`biu_ack_cnt <= 1'b0;`
367			`biu_err_cnt <= 1'b0;`
368			`biu_rty_cnt <= 1'b0;`
369	142	marcus.erl	`ifdef OR1200_WB_RETRY
370	258	julius	retry_cnt <= {`OR1200_WB_RETRY{1'b0}};
371	10	unneback	`endif
372	258	julius	`end`
373			`else begin`
374			`// BIU strobe`
375			`if (biu_stb_i & !biu_cab_i & biu_ack_o)`
376			`biu_stb_reg <= 1'b0;`
377			`else`
378			`biu_stb_reg <= biu_stb_i;`
379			`// BIU ack toggle counter`
380	364	julius	`if (wb_fsm_state_cur == wb_fsm_idle \| !(\|clmode))`
381	258	julius	`biu_ack_cnt <= 1'b0 ;`
382			`else if (biu_ack_o)`
383			`biu_ack_cnt <= !biu_ack_cnt ;`
384			`// BIU err toggle counter`
385	364	julius	`if (wb_fsm_state_cur == wb_fsm_idle \| !(\|clmode))`
386	258	julius	`biu_err_cnt <= 1'b0 ;`
387			`else if (wb_err_i & biu_err_o)`
388			`biu_err_cnt <= !biu_err_cnt ;`
389			`// BIU rty toggle counter`
390	364	julius	`if (wb_fsm_state_cur == wb_fsm_idle \| !(\|clmode))`
391	258	julius	`biu_rty_cnt <= 1'b0 ;`
392			`else if (biu_rty)`
393			`biu_rty_cnt <= !biu_rty_cnt ;`
394	142	marcus.erl	`ifdef OR1200_WB_RETRY
395	258	julius	`if (biu_ack_o \| biu_err_o)`
396			retry_cnt <= {`OR1200_WB_RETRY{1'b0}};
397			`else if (biu_rty)`
398			`retry_cnt <= retry_cnt + 1'b1;`
399	10	unneback	`endif
400	258	julius	`end`
401			`end`
402	10	unneback
403	258	julius	`assign biu_stb = biu_stb_i & biu_stb_reg;`
404	10	unneback
405	258	julius	`//`
406			`// Input BIU data bus`
407			`//`
408			`assign biu_dat_o = wb_dat_i;`
409	10	unneback
410	258	julius	`//`
411			`// Input BIU termination signals`
412			`//`
413			`assign biu_rty = (wb_fsm_state_cur == wb_fsm_trans) & wb_rty_i & wb_stb_o & (wb_rty_cnt ~^ biu_rty_cnt);`
414			`assign biu_ack_o = (wb_fsm_state_cur == wb_fsm_trans) & wb_ack & wb_stb_o & (wb_ack_cnt ~^ biu_ack_cnt);`
415			`assign biu_err_o = (wb_fsm_state_cur == wb_fsm_trans) & wb_err_i & wb_stb_o & (wb_err_cnt ~^ biu_err_cnt)`
416	142	marcus.erl	`ifdef OR1200_WB_RETRY
417	258	julius	\| biu_rty & retry_cnt[`OR1200_WB_RETRY-1];
418	10	unneback	`else
419	258	julius	`;`
420	10	unneback	`endif
421
422
423			`endmodule`

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [or1200/] [rtl/] [verilog/] [or1200_wb_biu.v] - Blame information for rev 729