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 pcie_common_pkg;

  typedef enum
  {
    MRd,      // Memory Read Request
    MRdLk,    // Memory Read Request-Locked
    MWr,      // Memory Write Request
    IORd,     // I/O Read Request
    IOWr,     // I/O Write Request
    CfgRd0,   // Configuration Read Type
    CfgWr0,   // Configuration Write Type
    CfgRd1,   // Configuration Read Type
    CfgWr1,   // Configuration Write Type
    TCfgRd,   // Deprecated TLP Type3
    TCfgWr,   // Deprecated TLP Type3
    Msg,      // Message Request
    MsgD,     // Message Request with data payload
    Cpl,      // Completion without Data
    CplD,     // Completion with Data
    CplLk,    // Completion for Locked Memory Read without Data
    CplDLk,   // Completion for Locked Memory Read
    FetchAdd, // Fetch and Add AtomicOp Request
    Swap,     // Unconditional Swap AtomicOp Request
    CAS,      // Compare and Swap AtomicOp Request
    LPrfx,    // Local TLP Prefix
    EPrfx,    // End-End TLP Prefix
    Reserved
  } tlp_type_t;

  typedef enum
  {
    ROUTING_UNKNOWN,
    ADDRESS,
    ID,
    IMPLICIT
  } tlp_routing_t;

  typedef enum
  {
    TRANSACTION_UNKNOWN,
    REQUESTER,
    COMPLETER
  } tlp_transaction_t;


  // --------------------------------------------------------------------
  //
  class tlp_header_class;

    tlp_type_t  header_type;
    logic [7:0] fmt_type;
    logic [2:0] tc;
    logic       th;
    logic [2:0] attr;
    logic       td;
    logic       ep;
    logic [9:0] length;
    logic [7:0] header[16];
    logic       header_is_4_dw;


    // --------------------------------------------------------------------
    //
    // function logic [7:0] get_fmt_type(tlp_type_t header_type);
    function logic [7:0] get_fmt_type;
      casez(header_type)
        MRd:      get_fmt_type = 8'b000_00000;
        MRd:      get_fmt_type = 8'b001_00000;
        MRdLk:    get_fmt_type = 8'b000_00001;
        MRdLk:    get_fmt_type = 8'b001_00001;
        MWr:      get_fmt_type = 8'b010_00000;
        MWr:      get_fmt_type = 8'b011_00000;
        IORd:     get_fmt_type = 8'b000_00010;
        IOWr:     get_fmt_type = 8'b010_00010;
        CfgRd0:   get_fmt_type = 8'b000_00100;
        CfgWr0:   get_fmt_type = 8'b010_00100;
        CfgRd1:   get_fmt_type = 8'b000_00101;
        CfgWr1:   get_fmt_type = 8'b010_00101;
        TCfgRd:   get_fmt_type = 8'b000_11011;
        TCfgWr:   get_fmt_type = 8'b010_11011;
        Msg:      get_fmt_type = 8'b001_10xxx;
        MsgD:     get_fmt_type = 8'b011_10xxx;
        Cpl:      get_fmt_type = 8'b000_01010;
        CplD:     get_fmt_type = 8'b010_01010;
        CplLk:    get_fmt_type = 8'b000_01011;
        CplDLk:   get_fmt_type = 8'b010_01011;
        FetchAdd: get_fmt_type = 8'b010_01100;
        FetchAdd: get_fmt_type = 8'b011_01100;
        Swap:     get_fmt_type = 8'b010_01101;
        Swap:     get_fmt_type = 8'b011_01101;
        CAS:      get_fmt_type = 8'b010_01110;
        CAS:      get_fmt_type = 8'b011_01110;
        LPrfx:    get_fmt_type = 8'b100_0xxxx;
        EPrfx:    get_fmt_type = 8'b100_1xxxx;
        default:  get_fmt_type = Reserved;
      endcase
    endfunction: get_fmt_type


    // --------------------------------------------------------------------
    //
    function tlp_type_t get_tlp_type(logic [7:0] fmt_type);
      casez(fmt_type)
        8'b000_00000: get_tlp_type = MRd;
        8'b001_00000: get_tlp_type = MRd;
        8'b000_00001: get_tlp_type = MRdLk;
        8'b001_00001: get_tlp_type = MRdLk;
        8'b010_00000: get_tlp_type = MWr;
        8'b011_00000: get_tlp_type = MWr;
        8'b000_00010: get_tlp_type = IORd;
        8'b010_00010: get_tlp_type = IOWr;
        8'b000_00100: get_tlp_type = CfgRd0;
        8'b010_00100: get_tlp_type = CfgWr0;
        8'b000_00101: get_tlp_type = CfgRd1;
        8'b010_00101: get_tlp_type = CfgWr1;
        8'b000_11011: get_tlp_type = TCfgRd;
        8'b010_11011: get_tlp_type = TCfgWr;
        8'b001_10???: get_tlp_type = Msg;
        8'b011_10???: get_tlp_type = MsgD;
        8'b000_01010: get_tlp_type = Cpl;
        8'b010_01010: get_tlp_type = CplD;
        8'b000_01011: get_tlp_type = CplLk;
        8'b010_01011: get_tlp_type = CplDLk;
        8'b010_01100: get_tlp_type = FetchAdd;
        8'b011_01100: get_tlp_type = FetchAdd;
        8'b010_01101: get_tlp_type = Swap;
        8'b011_01101: get_tlp_type = Swap;
        8'b010_01110: get_tlp_type = CAS;
        8'b011_01110: get_tlp_type = CAS;
        8'b100_0????: get_tlp_type = LPrfx;
        8'b100_1????: get_tlp_type = EPrfx;
        default:      get_tlp_type = Reserved;
      endcase
    endfunction: get_tlp_type


    // --------------------------------------------------------------------
    //
    // function tlp_routing_t get_tlp_routing(tlp_type_t header_type);
    function tlp_routing_t get_tlp_routing;

      case(header_type)
        MRd:      get_tlp_routing = ADDRESS;
        MRdLk:    get_tlp_routing = ADDRESS;
        MWr:      get_tlp_routing = ADDRESS;
        IORd:     get_tlp_routing = ADDRESS;
        IOWr:     get_tlp_routing = ADDRESS;
        CfgRd0:   get_tlp_routing = ID;
        CfgWr0:   get_tlp_routing = ID;
        CfgRd1:   get_tlp_routing = ID;
        CfgWr1:   get_tlp_routing = ID;
        TCfgRd:   get_tlp_routing = ID;
        TCfgWr:   get_tlp_routing = ID;
        Msg:      get_tlp_routing = ROUTING_UNKNOWN;
        MsgD:     get_tlp_routing = ROUTING_UNKNOWN;
        Cpl:      get_tlp_routing = ID;
        CplD:     get_tlp_routing = ID;
        CplLk:    get_tlp_routing = ID;
        CplDLk:   get_tlp_routing = ID;
        FetchAdd: get_tlp_routing = ROUTING_UNKNOWN;
        Swap:     get_tlp_routing = ROUTING_UNKNOWN;
        CAS:      get_tlp_routing = ROUTING_UNKNOWN;
        LPrfx:    get_tlp_routing = ROUTING_UNKNOWN;
        EPrfx:    get_tlp_routing = ROUTING_UNKNOWN;
        default:  get_tlp_routing = ROUTING_UNKNOWN;
      endcase

    endfunction: get_tlp_routing


    // --------------------------------------------------------------------
    //
    // function tlp_transaction_t get_tlp_transaction(tlp_type_t header_type);
    function tlp_transaction_t get_tlp_transaction;

      case(header_type)
        MRd:      get_tlp_transaction = REQUESTER;
        MRdLk:    get_tlp_transaction = REQUESTER;
        MWr:      get_tlp_transaction = REQUESTER;
        IORd:     get_tlp_transaction = REQUESTER;
        IOWr:     get_tlp_transaction = REQUESTER;
        CfgRd0:   get_tlp_transaction = REQUESTER;
        CfgWr0:   get_tlp_transaction = REQUESTER;
        CfgRd1:   get_tlp_transaction = REQUESTER;
        CfgWr1:   get_tlp_transaction = REQUESTER;
        TCfgRd:   get_tlp_transaction = REQUESTER;
        TCfgWr:   get_tlp_transaction = REQUESTER;
        Msg:      get_tlp_transaction = REQUESTER;
        MsgD:     get_tlp_transaction = REQUESTER;
        Cpl:      get_tlp_transaction = COMPLETER;
        CplD:     get_tlp_transaction = COMPLETER;
        CplLk:    get_tlp_transaction = COMPLETER;
        CplDLk:   get_tlp_transaction = COMPLETER;
        FetchAdd: get_tlp_transaction = TRANSACTION_UNKNOWN;
        Swap:     get_tlp_transaction = TRANSACTION_UNKNOWN;
        CAS:      get_tlp_transaction = TRANSACTION_UNKNOWN;
        LPrfx:    get_tlp_transaction = TRANSACTION_UNKNOWN;
        EPrfx:    get_tlp_transaction = TRANSACTION_UNKNOWN;
        default:  get_tlp_transaction = TRANSACTION_UNKNOWN;
      endcase

    endfunction: get_tlp_transaction


    // --------------------------------------------------------------------
    //
    function void display_header(string str);
      tlp_routing_t routing_type = get_tlp_routing;    
      tlp_transaction_t transaction_type = get_tlp_transaction;

      $display("??? %16.t | .....................", $time);
      $display("??? %16.t | %s | TLP type | %s", $time, str, header_type.name);
      // $display("??? %16.t | fmt           = %b | type = %b", $time, fmt_type[7:5], fmt_type[4:0]);
      $display("??? %16.t | length = %d", $time, length);
      $display("??? %16.t | tc = %b | th = %b | attr = %b | td = %b | ep = %b",
                $time, tc, th, attr, td, ep);

      if(routing_type == ADDRESS)
        if(header_is_4_dw)
          $display("??? %16.t | address[63:0] = 0x%16.x", $time,
                    { header[8],  header[9],  header[10], header[11],
                      header[12], header[13], header[14], header[15][7:2], 2'b00});
        else
          $display("??? %16.t | address[31:0] = 0x%8.x", $time,
                    { header[8],  header[9],  header[10], header[11][7:2], 2'b00});
      else if(routing_type == ID)
          $display("??? %16.t | bus = 0x%2.x | device = 0x%x | function = 0x%x", $time,
                    header[8],  header[9][7:3],  header[9][2:0]);

      if(transaction_type == COMPLETER)
      begin
        $display("??? %16.t | Completer ID  = %b", $time, {header[4], header[5]});
        $display("??? %16.t | requester ID  = %b", $time, {header[8], header[9]});
        $display("??? %16.t | tag           = %b", $time, header[10]);
      end
      else
      begin
        $display("??? %16.t | requester ID  = %b", $time, {header[4], header[5]});
        $display("??? %16.t | tag           = %b", $time, header[6]);
        $display("??? %16.t | last DW BE = %b | first DW BE = %b",
                  $time, header[7][7:4], header[7][3:0]);
      end

      // display_tlp_type(header_type);

      $display("??? %16.t | ---------------------", $time);

    endfunction: display_header


    //--------------------------------------------------------------------
    //
    function new(tlp_type_t header_type, logic [9:0] length);
      this.header_type = header_type;
      this.fmt_type = get_fmt_type;
      this.length = length;
      this.header_is_4_dw = fmt_type[5];
      this.header[0] = fmt_type;
      this.header[3] = length[7:0];
      this.header[2][1:0] = length[9:8];
    endfunction: new


  // --------------------------------------------------------------------
  //
  endclass: tlp_header_class


// --------------------------------------------------------------------
//
endpackage: pcie_common_pkg