[yes 8]

есть дизайн, который очень хорошо разбивается на модули обеспечивающие соединения и функциональные узлы, которые в структуру этих соединений должны вставлятся

 

казалось бы, что generic interface port как раз для этого и предназначено

поддерживает ли современные средства синтеза такую конструкцию?

 

делал ли кто-нибудь так? можете показать пример синтезируемого кода?

 

--------

 

сейчас приходится описывать в структуре соединений сигналы, которые могут использоваться любым типом модулей, что вызывает большой размер кода и трудность отладки описания соединений (как статических, так и коммутируемых)

 

у меня есть пример, довольно громоздский (могу выложить UPD : выложил, может кто-то осилит многа букав), чтобы как-то придать смысл, но пресижин валится с внутренней ошибкой (симулятор ок)

UPD: ну после некой возни с примером (и утраты части интересующих фич), пресижином начало синтезироваться, но выбрасывает всю начинку нафиг....

 

 

---------------

 

теоретический вопрос:

 

при сборке этой структуры соединений невозможно задавать modport-ы, то есть при подключении такой структуры возможно ошибка направления сигналов

можно ли при описании модуля с generic interface портом указывать модпорт этого обобщенного интерфейса (ну то есть я создаю много интерфейсов, но в них есть обязательно modport master и modport slave) - или это строго запрещено стандартом?

 

 

=======================

если не лень посмотреть, и указать на ошибки:

 

typedef struct packed {
                       logic [7:0]        data;
                       logic                rd;
                       logic                wr;
                       } trans;
//-------------------------------------------------------------------------
interface test;
   logic [7:0]                                 data_in;
   logic                                        rd_req_in;
   logic                                        wr_req_in;
   logic [7:0]                                 out_data;
   logic                                        out_rd_ack;
   logic                                        out_wr_ack;
   modport master(output  data_in,rd_req_in,wr_req_in,
                  input out_data,out_rd_ack,out_wr_ack
                  );
   modport slave(input  data_in,rd_req_in,wr_req_in,
                 output out_data,out_rd_ack,out_wr_ack
                 );
endinterface

//-------------------------------------------------------------------------
module bi(interface mtr, slva, slvb, input logic clk);
   //it is desiriable:
   // implement for abstract assignmrnt
   // modport usage for data protection

   trans i,o;

   //non abstract funcionality (probably in sub-modules)
   //from master(s) to slave(s)
   //a
   always_ff @(posedge clk)
     begin
        i.data<=mtr.data_in;
        i.rd<=mtr.rd_req_in;
        i.wr<=mtr.wr_req_in;
     end
   assign slva.data_in=i.data;
   assign slva.rd_req_in=i.rd;
   assign slva.wr_req_in=i.wr;
   //b
   assign slvb.data_in=i.data;
   assign slvb.rd_req_in=i.rd;
   assign slvb.wr_req_in=i.wr;
   //from slaves to master
   always_ff @(posedge clk)
     begin
        o.data<=slva.out_data|slvb.out_data;
        o.rd<=slva.out_rd_ack|slvb.out_rd_ack;
        o.wr<=slva.out_wr_ack|slvb.out_wr_ack;
     end
   assign mtr.out_data=o.data;
   assign mtr.out_rd_ack=o.rd;
   assign mtr.out_wr_ack=o.wr;
endmodule // node

//-------------------------------------------------------------------------
//not good for precision
/*
module con_lr(test.master in, test.slave out);
//abstraction resovled here
   assign in.out_data=out.out_data;
   assign in.out_rd_ack=out.out_rd_ack;
   assign in.out_wr_ack=out.out_wr_ack;
   assign out.data_in=in.data_in;
   assign out.rd_req_in=in.rd_req_in;
   assign out.wr_req_in=in.wr_req_in;
endmodule
module con_rl(test.slave in, test.master out);
   //abstraction resovled here
   assign in.data_in=out.data_in;
   assign in.rd_req_in=out.rd_req_in;
   assign in.wr_req_in=out.wr_req_in;
   assign out.out_data=in.out_data;
   assign out.out_rd_ack=in.out_rd_ack;
   assign out.out_wr_ack=in.out_wr_ack;
endmodule
*/
//-------------------------------------------------------------------------
//abstract connections here
module tree
  #(parameter int NLOG=3)
    (
     test.master root_node,
     test.slave cherry[2**NLOG],
     //not good for precision
     /*
     interface root_node,
     interface cherry[2**NLOG],
     */
     input logic clk
     );
   //root is slave modport
   //cherry are master modports

   //it is desiriable:
   // implement for abstract assignmrnt
   // modport usage for data protection

   test i[2**(NLOG+1):1]();

   genvar  stage, node, c;
   generate for(stage=1; stage<=NLOG; stage++)
     begin : stages
        for(node=0; node<2**(stage-1); node++)
          begin : nodes
             bi nd(i[2**(stage-1)+node].master, i[2**stage+node].slave, i[2**stage+node+2**(stage-1)].slave, clk);
          end
     end
   endgenerate

   //it is desiriable:
   //incapsulate following assignments into iface
   //root
   assign root_node.out_data=i[1].out_data;
   assign root_node.out_rd_ack=i[1].out_rd_ack;
   assign root_node.out_wr_ack=i[1].out_wr_ack;
   assign i[1].data_in=root_node.data_in;
   assign i[1].rd_req_in=root_node.rd_req_in;
   assign i[1].wr_req_in=root_node.wr_req_in;

   //cherries
   generate for(c=0; c<2**NLOG; c++)
     begin : out_assign
        assign cherry[c].data_in=i[2**NLOG+c].data_in;
        assign cherry[c].rd_req_in=i[2**NLOG+c].rd_req_in;
        assign cherry[c].wr_req_in=i[2**NLOG+c].wr_req_in;
        assign i[2**NLOG+c].out_data=cherry[c].out_data;
        assign i[2**NLOG+c].out_rd_ack=cherry[c].out_rd_ack;
        assign i[2**NLOG+c].out_wr_ack=cherry[c].out_wr_ack;
     end
   endgenerate

   /*
   //it is desiriable:
   //incapsulated
   //root
   con_lr r(root_node, i[1]);

   //cherries
   generate for(c=0; c<2**NLOG; c++)
     begin : out_assign
        con_rl o(cherry[c],i[2**NLOG+c]);
     end
   endgenerate

   */

endmodule //

//-------------------------------------------------------------------------
module tree_wo_if
  #(
    parameter int NLOG=3
    )
    (
     input trans rt_in,
     output trans rt_out,
     input trans [2**NLOG-1:0] cr_in,
     output trans [2**NLOG-1:0] cr_out,
     input logic clk
     );

   genvar   c;

   test rt();
   test ch[2**NLOG]();

   tree tr(rt, ch, clk);

   assign    rt.data_in=rt_in.data;
   assign    rt.rd_req_in=rt_in.rd;
   assign    rt.wr_req_in=rt_in.wr;
   assign    rt_out.data=rt.out_data;
   assign    rt_out.rd=rt.out_rd_ack;
   assign    rt_out.wr=rt.out_wr_ack;

   generate for(c=0; c<2**NLOG; c++)
     begin : out_assign
        assign cr_out[c].data=ch[c].data_in;
        assign cr_out[c].rd=ch[c].rd_req_in;
        assign cr_out[c].wr=ch[c].wr_req_in;
        assign ch[c].out_data=cr_in[c].data;
        assign ch[c].out_rd_ack=cr_in[c].rd;
        assign ch[c].out_wr_ack=cr_in[c].wr;
     end
   endgenerate

endmodule

//--simulation

/*
module node_dummy
  (
   input trans i,
   output trans o,
   input logic en,
   input logic clk
   );

   always_ff @(posedge clk)
     if(en)
       begin
          o.data<=i.data;
          o.rd<=i.rd;
          o.wr<=i.wr;
       end
     else
       begin
          o.data<=0;
          o.rd<=0;
          o.wr<=0;
       end
endmodule // node_dummy

/*
module top_test;

   parameter int NLOG=3;

   trans in_r=0, out_r;
   trans [2**NLOG-1:0]  in_c, out_c;

   logic     clk=0;
   logic [2**NLOG-1:0] en=0;

   tree_wo_if dut(in_r, out_r, in_c, out_c, clk);

   generate  for(genvar i=0; i<2**NLOG; i++)
     begin : out_dummy
        node_dummy io(out_c[i], in_c[i], en[i], clk);
     end
   endgenerate

   always #5 clk=~clk;

   initial
     begin
        @(posedge clk);
        in_r.data=123;
        in_r.wr=1;
        @(posedge clk);
        in_r.data=222;
        in_r.wr=0;
        in_r.rd=1;
        en=1;
        @(posedge clk);
        in_r.data=0;
        in_r.wr=0;
        in_r.rd=0;
        en=2;
        @(posedge clk);
        in_r.data=123;
        in_r.wr=1;
        @(posedge clk);
        in_r.data=222;
        in_r.wr=0;
        in_r.rd=1;
        en=1;
        @(posedge clk);
        in_r.data=0;
        in_r.wr=0;
        in_r.rd=0;
        en=0;
        @(posedge clk);
        in_r.data=0;
        in_r.wr=0;
        in_r.rd=0;
        @(posedge clk);
        in_r.data=0;
        in_r.wr=0;
        in_r.rd=0;

        repeat (16) @(posedge clk);

        $stop;
     end // initial begin

endmodule
*/