Subversion Repositories srdydrdy_lib

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

// Srdy/drdy round-robin arbiter

//

// Asserts drdy for an input and then moves to the next input.

//

// This component supports multiple round-robin modes:

//

// Mode 0 : Each input gets a single cycle, regardless of data

//          availability.  This mode functions like a TDM

//          demultiplexer.  Output flow control will cause the

//          component to stall, so that inputs do not miss their

//          turn due to flow control.

// Mode 0 fast arb : Each input gets a single grant. If the

//          output is not ready (p_drdy deasserted), then the

//          machine will hold on that particular input until it

//          receives a grant.  Once a single token has been

//          accepted the machine will round-robin arbitrate.

//          When there are no requests the machine returns to

//          its default state.

// Mode 1 : Each input can transmit for as long as it has data.

//          When input deasserts, device will begin to hunt for a

//          new input with data.

// Mode 2 : Continue to accept input until the incoming data

//          matches a particular "end pattern".  The end pattern

//          is provided on the c_rearb (re-arbitrate) input.  When

//          c_rearb is high, will hunt for new inputs on next clock.

//

// This component also supports two arbitration modes: slow and fast.

// slow rotates the grant from requestor to requestor cycle by cycle,

// so each requestor gets serviced at most once every #inputs cycles.

// This can be useful for producing a TDM-type interface, however

// requestors may be delayed waiting for the grant to come around even

// if there are no other requestors.

//

// Fast mode immediately grants the highest-priority requestor, however

// it is drdy-noncompliant (drdy will not be asserted until srdy is

// asserted).

//

// Naming convention: c = consumer, p = producer, i = internal interface

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

//  Author: Guy Hutchison

//

// This block is uncopyrighted and released into the public domain.

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

// Clocking statement for synchronous blocks.  Default is for

// posedge clocking and positive async reset

`ifndef SDLIB_CLOCKING

 `define SDLIB_CLOCKING posedge clk or posedge reset

`endif

// delay unit for nonblocking assigns, default is to #1

`ifndef SDLIB_DELAY

 `define SDLIB_DELAY #1

`endif

module sd_rrmux

  #(parameter width=8,

    parameter inputs=2,

    parameter inputs_asz=1,  // log2(inputs)

    parameter mode=0,

    parameter fast_arb=0)

  (

   input               clk,

   input               reset,

   input [(width*inputs)-1:0] c_data,

   input [inputs-1:0]      c_srdy,

   output  [inputs-1:0]    c_drdy,

   input                   c_rearb,  // for use with mode 2 only

   output     [width-1:0]  p_data,

   output [inputs-1:0]     p_grant,

   output                  p_srdy,

   input                   p_drdy

   );

  reg [inputs-1:0]    rr_state;

  reg [inputs-1:0]    nxt_rr_state;

  //wire [width-1:0]     rr_mux_grid [0:inputs-1];

  reg                  rr_locked;

  //genvar               i;

  integer              j;

  assign c_drdy = rr_state & {inputs{p_drdy}};

  assign p_grant = rr_state;

  function [inputs-1:0] nxt_grant;

    input [inputs-1:0] cur_grant;

    input [inputs-1:0] cur_req;

    reg [inputs-1:0]   msk_req;

    reg [inputs-1:0]   tmp_grant;

    begin

      msk_req = cur_req & ~((cur_grant - 1) | cur_grant);

      tmp_grant = msk_req & (~msk_req + 1);

      if (msk_req != 0)

        nxt_grant = tmp_grant;

      else

        nxt_grant = cur_req & (~cur_req + 1);

    end

  endfunction

  always @*

    begin

      data_ind = 0;

      for (j=0; j<inputs; j=j+1)

        if (rr_state[j])

          data_ind = j;

    end

  generate

/* -----\/----- EXCLUDED -----\/-----

    for (i=0; i<inputs; i=i+1)

      begin : grid_assign

        wire [width-1:0] temp;

        assign temp = c_data >> (i*width);

        assign rr_mux_grid[i] = c_data >> (i*width);

      end

 -----/\----- EXCLUDED -----/\----- */

    if (mode == 2)

      begin : tp_gen

        reg nxt_rr_locked;

        reg selected_srdy;

        always @*

          begin

/* -----\/----- EXCLUDED -----\/-----

            data_ind = 0;

            for (j=0; j<inputs; j=j+1)

              if (rr_state[j])

                data_ind = j;

 -----/\----- EXCLUDED -----/\----- */

            nxt_rr_locked = rr_locked;

            if ((c_srdy & rr_state) & (!rr_locked))

              nxt_rr_locked = 1;

            else if ((c_srdy & rr_state & c_rearb) & p_drdy )

              nxt_rr_locked = 0;

            else if ((nxt_rr_state != rr_state) && (nxt_rr_state != 0))

              nxt_rr_locked = 1;

            else

              nxt_rr_locked = rr_locked;

          end

        always @(`SDLIB_CLOCKING)

          begin

            if (reset)

              rr_locked <= `SDLIB_DELAY 0;

            else

              rr_locked <= `SDLIB_DELAY nxt_rr_locked;

          end

      end // block: tp_gen

  endgenerate

  assign p_srdy = |(rr_state & c_srdy);

  assign p_data = c_data[data_ind*width +: width];

  always @*

    begin

      if ((mode ==  1) & (c_srdy & rr_state))

        nxt_rr_state = rr_state;

      else if ((mode == 0) && !p_drdy && !fast_arb)

        nxt_rr_state = rr_state;

      else if ((mode == 0) && |(rr_state & c_srdy) && !p_drdy && fast_arb)

        nxt_rr_state = rr_state;

      else if ((mode == 2) & (rr_locked | (c_srdy & rr_state)))

        nxt_rr_state = rr_state;

      else if (fast_arb)

        nxt_rr_state = nxt_grant (rr_state, c_srdy);

      else

        nxt_rr_state = { rr_state[0], rr_state[inputs-1:1] };

    end

  always @(`SDLIB_CLOCKING)

    begin

      if (reset)

        rr_state <= `SDLIB_DELAY (fast_arb)? 0 : 1;

      else

        rr_state <= `SDLIB_DELAY nxt_rr_state;

    end

endmodule // sd_rrmux