DMAC - Register File

 

#Register File

- 임시 저장 공간

 

 

 

 

module regfile(clk, wAddr, wData, we, rAddr, rData);

 parameter addrSize = 3;
   parameter wordSize = 8;

 input  clk;
 input  [addrSize-1:0] wAddr;
 input  [wordSize-1:0] wData;
 input  we;
 input  [addrSize-1:0] rAddr;
 output [wordSize-1:0] rData;
 
 wire  [wordSize-1:0] register0;
 wire  [wordSize-1:0] register1;
 wire  [wordSize-1:0] register2;
 wire  [wordSize-1:0] register3;
 wire  [wordSize-1:0] register4;
 wire  [wordSize-1:0] register5;
 wire  [wordSize-1:0] register6;
 wire  [wordSize-1:0] register7;
 wire  [wordSize-1:0] decout;
 wire  [wordSize-1:0] en;
 
 //register
 _register8_en  U0_register8_en(.clk(clk), .en(en[0]), .d(wData), .q(register0));
 _register8_en  U1_register8_en(.clk(clk), .en(en[1]), .d(wData), .q(register1));
 _register8_en  U2_register8_en(.clk(clk), .en(en[2]), .d(wData), .q(register2));
 _register8_en  U3_register8_en(.clk(clk), .en(en[3]), .d(wData), .q(register3));
 _register8_en  U4_register8_en(.clk(clk), .en(en[4]), .d(wData), .q(register4));
 _register8_en  U5_register8_en(.clk(clk), .en(en[5]), .d(wData), .q(register5));
 _register8_en  U6_register8_en(.clk(clk), .en(en[6]), .d(wData), .q(register6));
 _register8_en U7_register8_en(.clk(clk), .en(en[7]), .d(wData), .q(register7));
 
 //write logic
 dec_3to8   U8_dec_3to8(wAddr, decout); 
 _and    U9_and (.di_a(decout[0]), .di_b(we), .dout(en[0]));
 _and    U10_and(.di_a(decout[1]), .di_b(we), .dout(en[1]));
 _and    U11_and(.di_a(decout[2]), .di_b(we), .dout(en[2]));
 _and    U12_and(.di_a(decout[3]), .di_b(we), .dout(en[3]));
 _and    U13_and(.di_a(decout[4]), .di_b(we), .dout(en[4]));
 _and    U14_and(.di_a(decout[5]), .di_b(we), .dout(en[5]));
 _and    U15_and(.di_a(decout[6]), .di_b(we), .dout(en[6]));
 _and    U16_and(.di_a(decout[7]), .di_b(we), .dout(en[7]));
 
 //read logic
 mx8_8bits  U17_mx8_8bits(.y(rData), .d0(register0), .d1(register1), .d2(register2), .d3(register3),
           .d4(register4), .d5(register5), .d6(register6), .d7(register7), .s(rAddr));
 
 
endmodule

module mx8_8bits( y, d0, d1, d2, d3, d4, d5, d6, d7, s );
  input  [7:0] d0, d1, d2, d3, d4, d5, d6, d7;
  input  [2:0] s;
  output [7:0] y;         
 
  wire [7:0] w0, w1, w2, w3, w4, w5;
 
  mx2_8bits U0_mx2_8bits(.y(w0), .d0(d0), .d1(d1), .s(s[0]));
  mx2_8bits U1_mx2_8bits(.y(w1), .d0(d2), .d1(d3), .s(s[0]));
  mx2_8bits U2_mx2_8bits(.y(w2), .d0(d4), .d1(d5), .s(s[0]));
  mx2_8bits U3_mx2_8bits(.y(w3), .d0(d6), .d1(d7), .s(s[0]));
  mx2_8bits U4_mx2_8bits(.y(w4), .d0(w0), .d1(w1), .s(s[1]));
  mx2_8bits U5_mx2_8bits(.y(w5), .d0(w2), .d1(w3), .s(s[1]));
  mx2_8bits U6_mx2_8bits(.y(y),  .d0(w4), .d1(w5), .s(s[2]));
 
endmodule

module mx2_8bits( y, d0, d1, s );
  input [7:0] d0, d1;
  input s;  
  output [7:0] y;         
 
  assign y = (s == 0) ? d0 : d1;
 
endmodule

module dec_3to8(din, dout);
 input  [2:0] din;
 output [7:0] dout;
 reg  [7:0] dout;
 always@(din)
 begin
  case(din)
   3'b000:  dout = 8'b00000001;
   3'b001:  dout = 8'b00000010;
   3'b010:  dout = 8'b00000100;
   3'b011:  dout = 8'b00001000;
   3'b100:  dout = 8'b00010000;
   3'b101:  dout = 8'b00100000;
   3'b110:  dout = 8'b01000000;
   3'b111:  dout = 8'b10000000;
   default: dout = 8'bxxxxxxxx;
  endcase 
 end
endmodule

module _register8_en(clk, en, d, q);
 input  clk;
 input  en;
 input  [7:0] d;
 output [7:0] q;
 
 _dff_en U0_dff_en(.clk(clk), .en(en), .d(d[0]), .q(q[0]));
 _dff_en U1_dff_en(.clk(clk), .en(en), .d(d[1]), .q(q[1]));
 _dff_en U2_dff_en(.clk(clk), .en(en), .d(d[2]), .q(q[2]));
 _dff_en U3_dff_en(.clk(clk), .en(en), .d(d[3]), .q(q[3]));
 _dff_en U4_dff_en(.clk(clk), .en(en), .d(d[4]), .q(q[4]));
 _dff_en U5_dff_en(.clk(clk), .en(en), .d(d[5]), .q(q[5]));
 _dff_en U6_dff_en(.clk(clk), .en(en), .d(d[6]), .q(q[6]));
 _dff_en U7_dff_en(.clk(clk), .en(en), .d(d[7]), .q(q[7]));
 
endmodule

module _dff_en(clk, en, d, q);
 input  clk, en, d;
 output  q;
 
 wire   w_d;
 
 mx2_1bit U0_mx2 (.y(w_d), .d0(q), .d1(d), .s(en));
 //_dff  U1_dff (.clk(clk), .d(w_d), .q(q), .q_bar(temp));
 _dff  U1_dff (.clk(clk), .d(w_d), .q(q));
 
endmodule
 
module mx2_1bit ( y, d0, d1, s );
  input d0, d1, s;  
  output y;         
 
  assign y = (s == 0) ? d0 : d1;
 
endmodule
module _dff(clk, d, q);
 input  clk, d;
 output reg q;
 
 always@(posedge clk)
  q<=d;
 
endmodule
module _and(di_a, di_b, dout);
 input di_a, di_b;
 output dout;
 
 assign dout = di_a & di_b;

endmodule