Subversion Repositories qaz_libs

//////////////////////////////////////////////////////////////////////
////                                                              ////
//// Copyright (C) 2015 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                     ////
////                                                              ////
//////////////////////////////////////////////////////////////////////


package axi4_arbiter_pkg;

  // --------------------------------------------------------------------
  //
  import axi4_models_pkg::*;
  import bfm_pkg::*;
  import logger_pkg::*;


  // --------------------------------------------------------------------
  //
  virtual class base_request_class #(A, N, I);

    string kind;
    int id = -1;

    //--------------------------------------------------------------------
    //
    pure virtual function void write_ax_if(axi4_channel_if_class #(A, N, I) channel);
    pure virtual function void copy_ax_if(axi4_channel_if_class #(A, N, I) channel);


  // --------------------------------------------------------------------
  //
  endclass: base_request_class


  // --------------------------------------------------------------------
  //
  class write_request_class #(A, N, I)
    extends base_request_class #(A, N, I);

    logic [(A-1):0]    awaddr;
    logic [1:0]        awburst;
    logic [(I-1):0]    awid;
    logic [7:0]        awlen;
    logic [2:0]        awsize;
    logic [3:0]        awcache;
    logic              awlock;
    logic [2:0]        awprot;
    logic [3:0]        awqos;
    logic [3:0]        awregion;


    // --------------------------------------------------------------------
    //
    function void write_ax_if(axi4_channel_if_class #(A, N, I) channel);
      axi4_aw_if_class #(A, N, I) aw_if_h;
      $cast(aw_if_h, channel);
      aw_if_h.awaddr    = awaddr;
      aw_if_h.awburst   = awburst;
      aw_if_h.awid      = awid;
      aw_if_h.awlen     = awlen;
      aw_if_h.awsize    = awsize;
      aw_if_h.awcache   = awcache;
      aw_if_h.awlock    = awlock;
      aw_if_h.awprot    = awprot;
      aw_if_h.awqos     = awqos;
      aw_if_h.awregion  = awregion;
    endfunction: write_ax_if


    // --------------------------------------------------------------------
    //
    function void copy_ax_if(axi4_channel_if_class #(A, N, I) channel);
      axi4_aw_if_class #(A, N, I) aw_if_h;
      $cast(aw_if_h, channel);
      awaddr    = aw_if_h.awaddr;
      awburst   = aw_if_h.awburst;
      awid      = aw_if_h.awid;
      awlen     = aw_if_h.awlen;
      awsize    = aw_if_h.awsize;
      awcache   = aw_if_h.awcache;
      awlock    = aw_if_h.awlock;
      awprot    = aw_if_h.awprot;
      awqos     = aw_if_h.awqos;
      awregion  = aw_if_h.awregion;
    endfunction: copy_ax_if


    //--------------------------------------------------------------------
    function new(int id);
      super.new;
      this.kind = "WRITE";
      this.id = id;
    endfunction: new


  // --------------------------------------------------------------------
  //
  endclass: write_request_class


  // --------------------------------------------------------------------
  //
  class read_request_class #(A, N, I)
    extends base_request_class #(A, N, I);

    logic [(A-1):0]    araddr;
    logic [1:0]        arburst;
    logic [(I-1):0]    arid;
    logic [7:0]        arlen;
    logic [2:0]        arsize;
    logic [3:0]        arcache;
    logic              arlock;
    logic [2:0]        arprot;
    logic [3:0]        arqos;
    logic [3:0]        arregion;

    // --------------------------------------------------------------------
    //
    function void write_ax_if(axi4_channel_if_class #(A, N, I) channel);
      axi4_ar_if_class #(A, N, I) ar_if_h;
      $cast(ar_if_h, channel);
      ar_if_h.araddr    = araddr;
      ar_if_h.arburst   = arburst;
      ar_if_h.arid      = arid;
      ar_if_h.arlen     = arlen;
      ar_if_h.arsize    = arsize;
      ar_if_h.arcache   = arcache;
      ar_if_h.arlock    = arlock;
      ar_if_h.arprot    = arprot;
      ar_if_h.arqos     = arqos;
      ar_if_h.arregion  = arregion;
    endfunction: write_ax_if


    // --------------------------------------------------------------------
    //
    function void copy_ax_if(axi4_channel_if_class #(A, N, I) channel);
      axi4_ar_if_class #(A, N, I) ar_if_h;
      $cast(ar_if_h, channel);
      araddr    = ar_if_h.araddr;
      arburst   = ar_if_h.arburst;
      arid      = ar_if_h.arid;
      arlen     = ar_if_h.arlen;
      arsize    = ar_if_h.arsize;
      arcache   = ar_if_h.arcache;
      arlock    = ar_if_h.arlock;
      arprot    = ar_if_h.arprot;
      arqos     = ar_if_h.arqos;
      arregion  = ar_if_h.arregion;
    endfunction: copy_ax_if


    //--------------------------------------------------------------------
    function new(int id);
      super.new;
      this.kind = "READ";
      this.id = id;
    endfunction: new


  // --------------------------------------------------------------------
  //
  endclass: read_request_class


  // --------------------------------------------------------------------
  //
  class requester_class #(A, N, I)
    extends axi4_slave_model_class #(A, N, I);

    mailbox #(base_request_class #(A, N, I)) q;
    semaphore read_done;
    semaphore write_done;
    int id = -1;
    logger_class log;


    // --------------------------------------------------------------------
    //
    task automatic run_read_interface;
      read_request_class #(A, N, I) r_req_h;
      read_done = new;
      forever
        @(axi4_s.cb_s)
        begin
          ar_q_h.q.get(ar_if_h);
          log.debug($sformatf("%m | start"));
          log.debug($sformatf("%m | araddr = 0x%h", ar_if_h.araddr));
          log.debug($sformatf("%m | arlen  = 0x%h", ar_if_h.arlen));
          r_req_h = new(id);
          r_req_h.copy_ax_if(ar_if_h);
          q.put(r_req_h);
          read_done.get();
          log.debug($sformatf("%m | done"));
        end
    endtask: run_read_interface


    // --------------------------------------------------------------------
    //
    task run_write_interface;
      write_request_class #(A, N, I) w_req_h;
      write_done = new;
      forever
        @(axi4_s.cb_s)
        begin
          aw_q_h.q.get(aw_if_h);
          log.debug($sformatf("%m | start"));
          log.debug($sformatf("%m | awaddr = 0x%h", aw_if_h.awaddr));
          log.debug($sformatf("%m | awlen  = 0x%h", aw_if_h.awlen));
          w_req_h = new(id);
          w_req_h.copy_ax_if(aw_if_h);
          q.put(w_req_h);
          write_done.get();
          log.debug($sformatf("%m | done"));
        end
    endtask: run_write_interface


    // --------------------------------------------------------------------
    //
    task run_model;
      wait(axi4_s.cb_s.aresetn);
      axi4_s.zero_cycle_delay();

      aw_q_h.run_q();
      w_q_h.run_q();
      b_q_h.run_q();
      ar_q_h.run_q();
      r_q_h.run_q();

      fork
        run_read_interface();
      join_none

      fork
        run_write_interface();
      join_none

    endtask: run_model


    //--------------------------------------------------------------------
    function new(int id, virtual axi4_if  #(.A(A), .N(N), .I(I)) axi4_s);
      super.new(axi4_s);
      this.aw_q_h = new(axi4_s, 2);
      this.w_q_h = new(axi4_s, 16);
      this.b_q_h = new(axi4_s, 2);
      this.ar_q_h = new(axi4_s, 2);
      this.r_q_h = new(axi4_s, 16);
      this.id = id;
      this.q = new(1);
      this.log = new();
    endfunction: new


  // --------------------------------------------------------------------
  //
  endclass: requester_class


  // --------------------------------------------------------------------
  //
  class axi4_granter_class #(A, N, I)
    extends axi4_master_model_class #(A, N, I);

    logger_class log;


    // --------------------------------------------------------------------
    //
    task run_model;
      wait(axi4_m.cb_s.aresetn);
      axi4_m.zero_cycle_delay();

      aw_q_h.run_q();
      w_q_h.run_q();
      b_q_h.run_q();
      ar_q_h.run_q();
      r_q_h.run_q();
    endtask: run_model


    //--------------------------------------------------------------------
    function new(virtual axi4_if  #(.A(A), .N(N), .I(I)) axi4_m);
      super.new(axi4_m);
      this.aw_q_h = new(axi4_m, 2);
      this.w_q_h = new(axi4_m, 16);
      this.b_q_h = new(axi4_m, 2);
      this.ar_q_h = new(axi4_m, 2);
      this.r_q_h = new(axi4_m, 16);
      this.log = new();
    endfunction: new


  // --------------------------------------------------------------------
  //
  endclass: axi4_granter_class


  // --------------------------------------------------------------------
  //
  class axi4_arbiter_class #(A, N, I);

    axi4_granter_class #(A, N, I) g_h;
    requester_class #(A, N, I) r_h[];
    mailbox #(int) grant;
    int count = -1;
    int current = 0, previous;
    logger_class log;


    // --------------------------------------------------------------------
    //
    task automatic do_read(requester_class #(A, N, I) r_h);
      int id;
      read_request_class #(A, N, I) r_req_h;
      base_request_class #(A, N, I) request;
      log.debug($sformatf("%m | read grant for %d", r_h.id));
      r_h.q.get(request);
      $cast(r_req_h, request);

      g_h.ar_if_h = new(g_h.axi4_m);
      r_req_h.write_ax_if(g_h.ar_if_h);
      g_h.ar_q_h.q.put(g_h.ar_if_h);

      for(int i = 0; i < r_h.ar_if_h.arlen + 1; i++)
      begin
        g_h.r_if_h = new(g_h.axi4_m);
        r_h.r_if_h = new(r_h.axi4_s);
        g_h.r_q_h.q.get(g_h.r_if_h);
        r_h.r_if_h.copy(g_h.r_if_h);
        r_h.r_q_h.q.put(r_h.r_if_h);
        @(r_h.axi4_s.cb_s);
      end

      r_h.read_done.put();
      grant.get(id);
      log.debug($sformatf("%m | read grant for %d done", id));
    endtask: do_read


    // --------------------------------------------------------------------
    //
    task automatic do_write(requester_class #(A, N, I) r_h);
      int id;
      write_request_class #(A, N, I) w_req_h;
      base_request_class #(A, N, I) request;
      log.debug($sformatf("%m | write grant for %d", r_h.id));
      r_h.q.get(request);
      $cast(w_req_h, request);

      g_h.aw_if_h = new(g_h.axi4_m);
      w_req_h.write_ax_if(g_h.aw_if_h);
      g_h.aw_q_h.q.put(g_h.aw_if_h);

      for(int i = 0; i < r_h.aw_if_h.awlen + 1; i++)
      begin
        r_h.w_if_h = new(r_h.axi4_s);
        g_h.w_if_h = new(g_h.axi4_m);
        r_h.w_q_h.q.get(r_h.w_if_h);
        g_h.w_if_h.copy(r_h.w_if_h);
        g_h.w_q_h.q.put(g_h.w_if_h);
        @(r_h.axi4_s.cb_s);
      end

      g_h.b_q_h.q.get(g_h.b_if_h);
      r_h.b_if_h = new(r_h.axi4_s);
      r_h.b_if_h.copy(g_h.b_if_h);
      r_h.b_q_h.q.put(r_h.b_if_h);
      r_h.write_done.put();
      grant.get(id);
      log.debug($sformatf("%m | write grant for %d done", id));
    endtask: do_write


    // --------------------------------------------------------------------
    //
    task automatic give_grant(requester_class #(A, N, I) r_h);
      base_request_class #(A, N, I) request;
      grant.put(r_h.id);
      r_h.q.peek(request);
      log.debug($sformatf("%m | %d got grant for %s", r_h.id, request.kind));

      if(request.kind.toupper == "WRITE")
        do_write(r_h);
      else if(request.kind.toupper == "READ")
        do_read(r_h);
      else
        $stop;

      current = (current + count + 1) % count;
      log.debug($sformatf("%m | new current = %d", current));
    endtask: give_grant


    // --------------------------------------------------------------------
    //
    task automatic do_arbitration;
      wait(g_h.axi4_m.cb_m.aresetn);
      g_h.axi4_m.zero_cycle_delay();
      forever
        @(g_h.axi4_m.cb_m)
        begin
          for(int i = current; i < current + count; i++)
            if(r_h[i % count].q.num > 0)
            begin
              give_grant(r_h[i % count]);
              break;
            end
        end
    endtask: do_arbitration


    //--------------------------------------------------------------------
    function void debug_enable;
      log.debug_enable();
      g_h.log.debug_enable();
      foreach(r_h[i])
        r_h[i].log.debug_enable();
    endfunction: debug_enable


    //--------------------------------------------------------------------
    function new
      (
        virtual axi4_if  #(A, N, I) axi4_s[],
        virtual axi4_if  #(.A(A), .N(N), .I(I)) axi4_m
      );
      this.grant = new(1);
      this.g_h = new(axi4_m);
      this.count = axi4_s.size;
      this.r_h = new[axi4_s.size];
      this.log = new;

      foreach(axi4_s[i])
        r_h[i] = new(i, axi4_s[i]);

      fork
        do_arbitration();
      join_none
    endfunction: new


  // --------------------------------------------------------------------
  //
  endclass: axi4_arbiter_class


// --------------------------------------------------------------------
//
endpackage: axi4_arbiter_pkg