URL https://opencores.org/ocsvn/ac97/ac97/trunk

Subversion Repositories ac97

[/] [ac97/] [trunk/] [bench/] [verilog/] [ac97_codec_top.v] - Blame information for rev 7

Go to most recent revision | Details | Compare with Previous | View Log


/////////////////////////////////////////////////////////////////////
////                                                             ////
////  WISHBONE AC 97 Codec Top Level                             ////
////                                                             ////
////                                                             ////
////  Author: Rudolf Usselmann                                   ////
////          rudi@asics.ws                                      ////
////                                                             ////
////                                                             ////
////  Downloaded from: http://www.opencores.org/cores/ac97_ctrl/ ////
////                                                             ////
/////////////////////////////////////////////////////////////////////
////                                                             ////
//// Copyright (C) 2000 Rudolf Usselmann                         ////
////                    rudi@asics.ws                            ////
////                                                             ////
//// 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 SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY     ////
//// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED   ////
//// TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS   ////
//// FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL THE AUTHOR      ////
//// OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,         ////
//// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES    ////
//// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE   ////
//// GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR        ////
//// BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF  ////
//// LIABILITY, WHETHER IN  CONTRACT, STRICT LIABILITY, OR TORT  ////
//// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT  ////
//// OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE         ////
//// POSSIBILITY OF SUCH DAMAGE.                                 ////
////                                                             ////
/////////////////////////////////////////////////////////////////////
 
//  CVS Log
//
//  $Id: ac97_codec_top.v,v 1.1 2002-02-13 08:22:32 rudi Exp $
//
//  $Date: 2002-02-13 08:22:32 $
//  $Revision: 1.1 $
//  $Author: rudi $
//  $Locker:  $
//  $State: Exp $
//
// Change History:
//               $Log: not supported by cvs2svn $
//
//
//
 
`include "ac97_defines.v"
 
module ac97_codec_top(clk, rst,
        sync,
        sdata_out,
        sdata_in
        );
 
input           clk, rst;
 
// --------------------------------------
// AC97 Codec Interface
input           sync;
output          sdata_out;
input           sdata_in;
 
////////////////////////////////////////////////////////////////////
//
// Local Wires
//
 
wire    [15:0]   out_slt0;
wire    [19:0]   out_slt1;
wire    [19:0]   out_slt2;
wire    [19:0]   out_slt3;
wire    [19:0]   out_slt4;
wire    [19:0]   out_slt5;
wire    [19:0]   out_slt6;
wire    [19:0]   out_slt7;
wire    [19:0]   out_slt8;
wire    [19:0]   out_slt9;
wire    [19:0]   out_slt10;
wire    [19:0]   out_slt11;
wire    [19:0]   out_slt12;
 
wire    [15:0]   in_slt0;
wire    [19:0]   in_slt1;
reg     [19:0]   in_slt2;
reg     [19:0]   in_slt3;
reg     [19:0]   in_slt4;
reg     [19:0]   in_slt5;
reg     [19:0]   in_slt6;
reg     [19:0]   in_slt7;
reg     [19:0]   in_slt8;
reg     [19:0]   in_slt9;
reg     [19:0]   in_slt10;
reg     [19:0]   in_slt11;
reg     [19:0]   in_slt12;
 
reg     [19:0]   smem[0:32];
reg     [19:0]   rmem[0:32];
 
reg     [15:0]   s0;
reg     [19:0]   s1;
 
integer         rs1_ptr, rs2_ptr;
integer         rs3_ptr, rs4_ptr, rs5_ptr, rs6_ptr, rs7_ptr;
integer         rs8_ptr, rs9_ptr, rs10_ptr, rs11_ptr, rs12_ptr;
integer         is2_ptr, is3_ptr, is4_ptr, is5_ptr, is6_ptr, is7_ptr;
integer         is8_ptr, is9_ptr, is10_ptr, is11_ptr, is12_ptr;
 
reg     [19:0]   rslt0;
reg     [19:0]   rslt1;
reg     [19:0]   rslt2;
reg     [19:0]   rs1_mem[0:256];
reg     [19:0]   rs2_mem[0:256];
reg     [19:0]   rs3_mem[0:256];
reg     [19:0]   rs4_mem[0:256];
reg     [19:0]   rs5_mem[0:256];
reg     [19:0]   rs6_mem[0:256];
reg     [19:0]   rs7_mem[0:256];
reg     [19:0]   rs8_mem[0:256];
reg     [19:0]   rs9_mem[0:256];
reg     [19:0]   rs10_mem[0:256];
reg     [19:0]   rs11_mem[0:256];
reg     [19:0]   rs12_mem[0:256];
 
reg     [19:0]   is2_mem[0:256];
reg     [19:0]   is3_mem[0:256];
reg     [19:0]   is4_mem[0:256];
reg     [19:0]   is5_mem[0:256];
reg     [19:0]   is6_mem[0:256];
reg     [19:0]   is7_mem[0:256];
reg     [19:0]   is8_mem[0:256];
reg     [19:0]   is9_mem[0:256];
reg     [19:0]   is10_mem[0:256];
reg     [19:0]   is11_mem[0:256];
reg     [19:0]   is12_mem[0:256];
 
////////////////////////////////////////////////////////////////////
//
// Misc Logic
//
 
task init;
input   mode;
 
integer mode;
begin
 
fill_mem(mode);
clr_ptrs;
 
end
endtask
 
task fill_mem;
input   mode;
 
integer mode;
integer n;
 
begin
 
if(mode==0)
for(n=0;n<256;n=n+1)
   begin
        is2_mem[n] = { 4'h0, n[11:0], 4'h0 };
        is3_mem[n] = { 4'h1, n[11:0], 4'h0 };
        is4_mem[n] = { 4'h2, n[11:0], 4'h0 };
        is5_mem[n] = { 4'h3, n[11:0], 4'h0 };
        is6_mem[n] = { 4'h4, n[11:0], 4'h0 };
        is7_mem[n] = { 4'h5, n[11:0], 4'h0 };
        is8_mem[n] = { 4'h6, n[11:0], 4'h0 };
        is9_mem[n] = { 4'h7, n[11:0], 4'h0 };
        is10_mem[n] = { 4'h8, n[11:0], 4'h0 };
        is11_mem[n] = { 4'h9, n[11:0], 4'h0 };
        is12_mem[n] = { 4'ha, n[11:0], 4'h0 };
   end
else
for(n=0;n<256;n=n+1)
   begin
        is2_mem[n] = $random;
        is3_mem[n] = $random;
        is4_mem[n] = $random;
        is5_mem[n] = $random;
        is6_mem[n] = $random;
        is7_mem[n] = $random;
        is8_mem[n] = $random;
        is9_mem[n] = $random;
        is10_mem[n] = $random;
        is11_mem[n] = $random;
        is12_mem[n] = $random;
   end
 
end
endtask
 
always @(posedge clk)
        if(!rst)        s0 = 0;
 
always @(posedge clk)
        if(!rst)        s1 = 0;
 
assign in_slt0  = s0;
assign in_slt1  = s1;
 
 
//always @(posedge sync)
always @(rslt0 or rslt1 or s0)
        if(s0[13] | (rslt0[14] & rslt1[19]) )
           begin
                in_slt2 = #1 is2_mem[is2_ptr];
                is2_ptr = is2_ptr + 1;
           end
 
always @(posedge sync)
        if(s0[12])
           begin
                in_slt3 = #1 is3_mem[is3_ptr];
                is3_ptr = is3_ptr + 1;
           end
 
always @(posedge sync)
        if(s0[11])
           begin
                in_slt4 = #1 is4_mem[is4_ptr];
                is4_ptr = is4_ptr + 1;
           end
 
always @(posedge sync)
        if(s0[10])
           begin
                in_slt5 = #1 is5_mem[is5_ptr];
                is5_ptr = is5_ptr + 1;
           end
 
always @(posedge sync)
        if(s0[9])
           begin
                in_slt6 = #1 is6_mem[is6_ptr];
                is6_ptr = is6_ptr + 1;
           end
 
always @(posedge sync)
        if(s0[8])
           begin
                in_slt7 = #1 is7_mem[is7_ptr];
                is7_ptr = is7_ptr + 1;
           end
 
always @(posedge sync)
        if(s0[7])
           begin
                in_slt8 = #1 is8_mem[is8_ptr];
                is8_ptr = is8_ptr + 1;
           end
 
always @(posedge sync)
        if(s0[6])
           begin
                in_slt9 = #1 is9_mem[is9_ptr];
                is9_ptr = is9_ptr + 1;
           end
 
always @(posedge sync)
        if(s0[5])
           begin
                in_slt10 = #1 is10_mem[is10_ptr];
                is10_ptr = is10_ptr + 1;
           end
 
always @(posedge sync)
        if(s0[4])
           begin
                in_slt11 = #1 is11_mem[is11_ptr];
                is11_ptr = is11_ptr + 1;
           end
 
always @(posedge sync)
        if(s0[3])
           begin
                in_slt12 = #1 is12_mem[is12_ptr];
                is12_ptr = is12_ptr + 1;
           end
 
always @(posedge sync)
   begin
        rslt0 <= #2 out_slt0;
        rslt1 <= #2 out_slt1;
        rslt2 <= #2 out_slt2;
   end
 
always @(posedge sync)
        if(out_slt0[15] & out_slt0[14])
           begin
                rs1_mem[rs1_ptr] = #1 out_slt1;
                rs1_ptr = rs1_ptr + 1;
                //$display("INFO: Codec Register Addr: %h (%t)", out_slt1, $time);
           end
 
always @(posedge sync)
        if(out_slt0[15] & out_slt0[13])
           begin
                rs2_mem[rs2_ptr] = #1 out_slt2;
                rs2_ptr = rs2_ptr + 1;
                //$display("INFO: Codec Register Data: %h (%t)", out_slt2, $time);
           end
 
always @(posedge sync)
        if(out_slt0[15] & out_slt0[12])
           begin
                rs3_mem[rs3_ptr] = #1 out_slt3;
                rs3_ptr = rs3_ptr + 1;
           end
 
always @(posedge sync)
        if(out_slt0[15] & out_slt0[11])
           begin
                rs4_mem[rs4_ptr] = #1 out_slt4;
                rs4_ptr = rs4_ptr + 1;
           end
 
always @(posedge sync)
        if(out_slt0[15] & out_slt0[10])
           begin
                rs5_mem[rs5_ptr] = #1 out_slt5;
                rs5_ptr = rs5_ptr + 1;
           end
 
always @(posedge sync)
        if(out_slt0[15] & out_slt0[9])
           begin
                rs6_mem[rs6_ptr] = #1 out_slt6;
                rs6_ptr = rs6_ptr + 1;
           end
 
always @(posedge sync)
        if(out_slt0[15] & out_slt0[8])
           begin
                rs7_mem[rs7_ptr] = #1 out_slt7;
                rs7_ptr = rs7_ptr + 1;
           end
 
always @(posedge sync)
        if(out_slt0[15] & out_slt0[7])
           begin
                rs8_mem[rs8_ptr] = #1 out_slt8;
                rs8_ptr = rs8_ptr + 1;
           end
 
always @(posedge sync)
        if(out_slt0[15] & out_slt0[6])
           begin
                rs9_mem[rs9_ptr] = #1 out_slt9;
                rs9_ptr = rs9_ptr + 1;
           end
 
always @(posedge sync)
        if(out_slt0[15] & out_slt0[5])
           begin
                rs10_mem[rs10_ptr] = #1 out_slt10;
                rs10_ptr = rs10_ptr + 1;
           end
 
always @(posedge sync)
        if(out_slt0[15] & out_slt0[4])
           begin
                rs11_mem[rs11_ptr] = #1 out_slt11;
                rs11_ptr = rs11_ptr + 1;
           end
 
always @(posedge sync)
        if(out_slt0[15] & out_slt0[3])
           begin
                rs12_mem[rs12_ptr] = #1 out_slt12;
                rs12_ptr = rs12_ptr + 1;
           end
 
 
task clr_ptrs;
 
begin
 
rs1_ptr = 0;
rs2_ptr = 0;
rs3_ptr = 0;
rs4_ptr = 0;
rs5_ptr = 0;
rs6_ptr = 0;
rs7_ptr = 0;
rs8_ptr = 0;
rs9_ptr = 0;
rs10_ptr = 0;
rs11_ptr = 0;
rs12_ptr = 0;
 
is2_ptr = 0;
is3_ptr = 0;
is4_ptr = 0;
is5_ptr = 0;
is6_ptr = 0;
is7_ptr = 0;
is8_ptr = 0;
is9_ptr = 0;
is10_ptr = 0;
is11_ptr = 0;
is12_ptr = 0;
 
end
endtask
 
 
task set_tag;
input           cr;
input   [11:0]   tag;
 
// s0 - 16 bits
// 15 - Codec Ready
// 14:3 - Slot 1-12 Valid bits
// 2:0 - RESERVED (stuffed with 0)
begin
s0 = {cr, tag, 3'h0};
end
endtask
 
 
task set_req;
input   [9:0]    req;
 
reg     [6:0]    idx;
begin
 
idx = out_slt1[18:12];
s1 = {1'b0, idx, ~req, 2'h0};
 
end
endtask
 
 
task tx1;
input   fcnt_max;       // Total number fo frames
input   rdy_del;        // How many frames before codec is ready
input   ovalid;         // Out Channels valid (Surround Sound)
input   ivalid;         // In Channels Valid (Mic & Line In)
input   oint;           // Output Intervals
input   iint;           // input Intervals
 
integer         fcnt_max, f;
integer         rdy_del;
reg     [9:0]    ovalid, ivalid;
reg     [19:0]   oint, iint;
 
reg             och0_v;
reg     [1:0]    och0_cnt;
reg             och1_v;
reg     [1:0]    och1_cnt;
reg             och2_v;
reg     [1:0]    och2_cnt;
reg             och3_v;
reg     [1:0]    och3_cnt;
reg             och4_v;
reg     [1:0]    och4_cnt;
reg             och5_v;
reg     [1:0]    och5_cnt;
reg             och6_v;
reg     [1:0]    och6_cnt;
reg             och7_v;
reg     [1:0]    och7_cnt;
reg             och8_v;
reg     [1:0]    och8_cnt;
reg             och9_v;
reg     [1:0]    och9_cnt;
reg             ich0_v;
reg     [1:0]    ich0_cnt;
reg             ich1_v;
reg     [1:0]    ich1_cnt;
reg             ich2_v;
reg     [1:0]    ich2_cnt;
reg             ich3_v;
reg     [1:0]    ich3_cnt;
reg             ich4_v;
reg     [1:0]    ich4_cnt;
reg             ich5_v;
reg     [1:0]    ich5_cnt;
reg             ich6_v;
reg     [1:0]    ich6_cnt;
reg             ich7_v;
reg     [1:0]    ich7_cnt;
reg             ich8_v;
reg     [1:0]    ich8_cnt;
reg             ich9_v;
reg     [1:0]    ich9_cnt;
 
begin
 
och0_cnt = 0;
och1_cnt = 0;
och2_cnt = 0;
och3_cnt = 0;
och4_cnt = 0;
och5_cnt = 0;
och6_cnt = 0;
och7_cnt = 0;
och8_cnt = 0;
och9_cnt = 0;
 
ich0_cnt = 0;
ich1_cnt = 0;
ich2_cnt = 0;
ich3_cnt = 0;
ich4_cnt = 0;
ich5_cnt = 0;
ich6_cnt = 0;
ich7_cnt = 0;
ich8_cnt = 0;
ich9_cnt = 0;
 
for(f=0;f<fcnt_max;f=f+1)
   begin
        while(!sync)    @(posedge clk);
        if(f>rdy_del)
           begin
 
                och0_v = ovalid[9] & (och0_cnt == oint[19:18]);
                if(och0_v)      och0_cnt = 0;
                else            och0_cnt = och0_cnt + 1;
                och1_v = ovalid[8] & (och1_cnt == oint[17:16]);
                if(och1_v)      och1_cnt = 0;
                else            och1_cnt = och1_cnt + 1;
                och2_v = ovalid[7] & (och2_cnt == oint[15:14]);
                if(och2_v)      och2_cnt = 0;
                else            och2_cnt = och2_cnt + 1;
                och3_v = ovalid[6] & (och3_cnt == oint[13:12]);
                if(och3_v)      och3_cnt = 0;
                else            och3_cnt = och3_cnt + 1;
                och4_v = ovalid[5] & (och4_cnt == oint[11:10]);
                if(och4_v)      och4_cnt = 0;
                else            och4_cnt = och4_cnt + 1;
                och5_v = ovalid[4] & (och5_cnt == oint[9:8]);
                if(och5_v)      och5_cnt = 0;
                else            och5_cnt = och5_cnt + 1;
                och6_v = ovalid[3] & (och6_cnt == oint[7:6]);
                if(och6_v)      och6_cnt = 0;
                else            och6_cnt = och6_cnt + 1;
                och7_v = ovalid[2] & (och7_cnt == oint[5:4]);
                if(och7_v)      och7_cnt = 0;
                else            och7_cnt = och7_cnt + 1;
                och8_v = ovalid[1] & (och8_cnt == oint[3:2]);
                if(och8_v)      och8_cnt = 0;
                else            och8_cnt = och8_cnt + 1;
                och9_v = ovalid[0] & (och9_cnt == oint[1:0]);
                if(och9_v)      och9_cnt = 0;
                else            och9_cnt = och9_cnt + 1;
 
                ich0_v = ivalid[9] & (ich0_cnt == iint[19:18]);
                if(ich0_v)      ich0_cnt = 0;
                else            ich0_cnt = ich0_cnt + 1;
                ich1_v = ivalid[8] & (ich1_cnt == iint[17:16]);
                if(ich1_v)      ich1_cnt = 0;
                else            ich1_cnt = ich1_cnt + 1;
                ich2_v = ivalid[7] & (ich2_cnt == iint[15:14]);
                if(ich2_v)      ich2_cnt = 0;
                else            ich2_cnt = ich2_cnt + 1;
                ich3_v = ivalid[6] & (ich3_cnt == iint[13:12]);
                if(ich3_v)      ich3_cnt = 0;
                else            ich3_cnt = ich3_cnt + 1;
                ich4_v = ivalid[5] & (ich4_cnt == iint[11:10]);
                if(ich4_v)      ich4_cnt = 0;
                else            ich4_cnt = ich4_cnt + 1;
                ich5_v = ivalid[4] & (ich5_cnt == iint[9:8]);
                if(ich5_v)      ich5_cnt = 0;
                else            ich5_cnt = ich5_cnt + 1;
                ich6_v = ivalid[3] & (ich6_cnt == iint[7:6]);
                if(ich6_v)      ich6_cnt = 0;
                else            ich6_cnt = ich6_cnt + 1;
                ich7_v = ivalid[2] & (ich7_cnt == iint[5:4]);
                if(ich7_v)      ich7_cnt = 0;
                else            ich7_cnt = ich7_cnt + 1;
                ich8_v = ivalid[1] & (ich8_cnt == iint[3:2]);
                if(ich8_v)      ich8_cnt = 0;
                else            ich8_cnt = ich8_cnt + 1;
                ich9_v = ivalid[0] & (ich9_cnt == iint[1:0]);
                if(ich9_v)      ich9_cnt = 0;
                else            ich9_cnt = ich9_cnt + 1;
 
                set_tag(1'b1, { 1'b0,           // Slot 1
                                1'b0,           // Slot 2
                                ich0_v, ich1_v, ich2_v, ich3_v, ich4_v,
                                ich5_v, ich6_v, ich7_v, ich8_v, ich9_v} );
 
                set_req( {      och0_v, och1_v, och2_v, och3_v, och4_v,
                                och5_v, och6_v, och7_v, och8_v, och9_v} );
 
           end
        while(sync)     @(posedge clk);
   end
end
endtask
 
////////////////////////////////////////////////////////////////////
//
// Modules
//
 
ac97_codec_sin  u0(
                .clk(           clk             ),
                .rst(           rst             ),
                .sync(          sync            ),
                .slt0(          out_slt0        ),
                .slt1(          out_slt1        ),
                .slt2(          out_slt2        ),
                .slt3(          out_slt3        ),
                .slt4(          out_slt4        ),
                .slt5(          out_slt5        ),
                .slt6(          out_slt6        ),
                .slt7(          out_slt7        ),
                .slt8(          out_slt8        ),
                .slt9(          out_slt9        ),
                .slt10(         out_slt10       ),
                .slt11(         out_slt11       ),
                .slt12(         out_slt12       ),
                .sdata_in(      sdata_in        )
                );
 
ac97_codec_sout u1(
                .clk(           clk             ),
                .rst(           rst             ),
                .sync(          sync            ),
                .slt0(          in_slt0         ),
                .slt1(          in_slt1         ),
                .slt2(          in_slt2         ),
                .slt3(          in_slt3         ),
                .slt4(          in_slt4         ),
                .slt5(          in_slt5         ),
                .slt6(          in_slt6         ),
                .slt7(          in_slt7         ),
                .slt8(          in_slt8         ),
                .slt9(          in_slt9         ),
                .slt10(         in_slt10        ),
                .slt11(         in_slt11        ),
                .slt12(         in_slt12        ),
                .sdata_out(     sdata_out       )
                );
 
endmodule
 
 

Browse

Tools

Subversion Repositories ac97

[/] [ac97/] [trunk/] [bench/] [verilog/] [ac97_codec_top.v] - Blame information for rev 7

Line No.	Rev	Author	Line
1	7	rudi	`/////////////////////////////////////////////////////////////////////`
2			`//// ////`
3			`//// WISHBONE AC 97 Codec Top Level ////`
4			`//// ////`
5			`//// ////`
6			`//// Author: Rudolf Usselmann ////`
7			`//// rudi@asics.ws ////`
8			`//// ////`
9			`//// ////`
10			`//// Downloaded from: http://www.opencores.org/cores/ac97_ctrl/ ////`
11			`//// ////`
12			`/////////////////////////////////////////////////////////////////////`
13			`//// ////`
14			`//// Copyright (C) 2000 Rudolf Usselmann ////`
15			`//// rudi@asics.ws ////`
16			`//// ////`
17			`//// This source file may be used and distributed without ////`
18			`//// restriction provided that this copyright statement is not ////`
19			`//// removed from the file and that any derivative work contains ////`
20			`//// the original copyright notice and the associated disclaimer.////`
21			`//// ////`
22			//// THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY ////
23			`//// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED ////`
24			`//// TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS ////`
25			`//// FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL THE AUTHOR ////`
26			`//// OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, ////`
27			`//// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES ////`
28			`//// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE ////`
29			`//// GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR ////`
30			`//// BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF ////`
31			`//// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT ////`
32			`//// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT ////`
33			`//// OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE ////`
34			`//// POSSIBILITY OF SUCH DAMAGE. ////`
35			`//// ////`
36			`/////////////////////////////////////////////////////////////////////`
37
38			`// CVS Log`
39			`//`
40			`// $Id: ac97_codec_top.v,v 1.1 2002-02-13 08:22:32 rudi Exp $`
41			`//`
42			`// $Date: 2002-02-13 08:22:32 $`
43			`// $Revision: 1.1 $`
44			`// $Author: rudi $`
45			`// $Locker: $`
46			`// $State: Exp $`
47			`//`
48			`// Change History:`
49			`// $Log: not supported by cvs2svn $`
50			`//`
51			`//`
52			`//`
53
54			`include "ac97_defines.v"
55
56			`module ac97_codec_top(clk, rst,`
57			`sync,`
58			`sdata_out,`
59			`sdata_in`
60			`);`
61
62			`input clk, rst;`
63
64			`// --------------------------------------`
65			`// AC97 Codec Interface`
66			`input sync;`
67			`output sdata_out;`
68			`input sdata_in;`
69
70			`////////////////////////////////////////////////////////////////////`
71			`//`
72			`// Local Wires`
73			`//`
74
75			`wire [15:0] out_slt0;`
76			`wire [19:0] out_slt1;`
77			`wire [19:0] out_slt2;`
78			`wire [19:0] out_slt3;`
79			`wire [19:0] out_slt4;`
80			`wire [19:0] out_slt5;`
81			`wire [19:0] out_slt6;`
82			`wire [19:0] out_slt7;`
83			`wire [19:0] out_slt8;`
84			`wire [19:0] out_slt9;`
85			`wire [19:0] out_slt10;`
86			`wire [19:0] out_slt11;`
87			`wire [19:0] out_slt12;`
88
89			`wire [15:0] in_slt0;`
90			`wire [19:0] in_slt1;`
91			`reg [19:0] in_slt2;`
92			`reg [19:0] in_slt3;`
93			`reg [19:0] in_slt4;`
94			`reg [19:0] in_slt5;`
95			`reg [19:0] in_slt6;`
96			`reg [19:0] in_slt7;`
97			`reg [19:0] in_slt8;`
98			`reg [19:0] in_slt9;`
99			`reg [19:0] in_slt10;`
100			`reg [19:0] in_slt11;`
101			`reg [19:0] in_slt12;`
102
103			`reg [19:0] smem[0:32];`
104			`reg [19:0] rmem[0:32];`
105
106			`reg [15:0] s0;`
107			`reg [19:0] s1;`
108
109			`integer rs1_ptr, rs2_ptr;`
110			`integer rs3_ptr, rs4_ptr, rs5_ptr, rs6_ptr, rs7_ptr;`
111			`integer rs8_ptr, rs9_ptr, rs10_ptr, rs11_ptr, rs12_ptr;`
112			`integer is2_ptr, is3_ptr, is4_ptr, is5_ptr, is6_ptr, is7_ptr;`
113			`integer is8_ptr, is9_ptr, is10_ptr, is11_ptr, is12_ptr;`
114
115			`reg [19:0] rslt0;`
116			`reg [19:0] rslt1;`
117			`reg [19:0] rslt2;`
118			`reg [19:0] rs1_mem[0:256];`
119			`reg [19:0] rs2_mem[0:256];`
120			`reg [19:0] rs3_mem[0:256];`
121			`reg [19:0] rs4_mem[0:256];`
122			`reg [19:0] rs5_mem[0:256];`
123			`reg [19:0] rs6_mem[0:256];`
124			`reg [19:0] rs7_mem[0:256];`
125			`reg [19:0] rs8_mem[0:256];`
126			`reg [19:0] rs9_mem[0:256];`
127			`reg [19:0] rs10_mem[0:256];`
128			`reg [19:0] rs11_mem[0:256];`
129			`reg [19:0] rs12_mem[0:256];`
130
131			`reg [19:0] is2_mem[0:256];`
132			`reg [19:0] is3_mem[0:256];`
133			`reg [19:0] is4_mem[0:256];`
134			`reg [19:0] is5_mem[0:256];`
135			`reg [19:0] is6_mem[0:256];`
136			`reg [19:0] is7_mem[0:256];`
137			`reg [19:0] is8_mem[0:256];`
138			`reg [19:0] is9_mem[0:256];`
139			`reg [19:0] is10_mem[0:256];`
140			`reg [19:0] is11_mem[0:256];`
141			`reg [19:0] is12_mem[0:256];`
142
143			`////////////////////////////////////////////////////////////////////`
144			`//`
145			`// Misc Logic`
146			`//`
147
148			`task init;`
149			`input mode;`
150
151			`integer mode;`
152			`begin`
153
154			`fill_mem(mode);`
155			`clr_ptrs;`
156
157			`end`
158			`endtask`
159
160			`task fill_mem;`
161			`input mode;`
162
163			`integer mode;`
164			`integer n;`
165
166			`begin`
167
168			`if(mode==0)`
169			`for(n=0;n<256;n=n+1)`
170			`begin`
171			`is2_mem[n] = { 4'h0, n[11:0], 4'h0 };`
172			`is3_mem[n] = { 4'h1, n[11:0], 4'h0 };`
173			`is4_mem[n] = { 4'h2, n[11:0], 4'h0 };`
174			`is5_mem[n] = { 4'h3, n[11:0], 4'h0 };`
175			`is6_mem[n] = { 4'h4, n[11:0], 4'h0 };`
176			`is7_mem[n] = { 4'h5, n[11:0], 4'h0 };`
177			`is8_mem[n] = { 4'h6, n[11:0], 4'h0 };`
178			`is9_mem[n] = { 4'h7, n[11:0], 4'h0 };`
179			`is10_mem[n] = { 4'h8, n[11:0], 4'h0 };`
180			`is11_mem[n] = { 4'h9, n[11:0], 4'h0 };`
181			`is12_mem[n] = { 4'ha, n[11:0], 4'h0 };`
182			`end`
183			`else`
184			`for(n=0;n<256;n=n+1)`
185			`begin`
186			`is2_mem[n] = $random;`
187			`is3_mem[n] = $random;`
188			`is4_mem[n] = $random;`
189			`is5_mem[n] = $random;`
190			`is6_mem[n] = $random;`
191			`is7_mem[n] = $random;`
192			`is8_mem[n] = $random;`
193			`is9_mem[n] = $random;`
194			`is10_mem[n] = $random;`
195			`is11_mem[n] = $random;`
196			`is12_mem[n] = $random;`
197			`end`
198
199			`end`
200			`endtask`
201
202			`always @(posedge clk)`
203			`if(!rst) s0 = 0;`
204
205			`always @(posedge clk)`
206			`if(!rst) s1 = 0;`
207
208			`assign in_slt0 = s0;`
209			`assign in_slt1 = s1;`
210
211
212			`//always @(posedge sync)`
213			`always @(rslt0 or rslt1 or s0)`
214			`if(s0[13] \| (rslt0[14] & rslt1[19]) )`
215			`begin`
216			`in_slt2 = #1 is2_mem[is2_ptr];`
217			`is2_ptr = is2_ptr + 1;`
218			`end`
219
220			`always @(posedge sync)`
221			`if(s0[12])`
222			`begin`
223			`in_slt3 = #1 is3_mem[is3_ptr];`
224			`is3_ptr = is3_ptr + 1;`
225			`end`
226
227			`always @(posedge sync)`
228			`if(s0[11])`
229			`begin`
230			`in_slt4 = #1 is4_mem[is4_ptr];`
231			`is4_ptr = is4_ptr + 1;`
232			`end`
233
234			`always @(posedge sync)`
235			`if(s0[10])`
236			`begin`
237			`in_slt5 = #1 is5_mem[is5_ptr];`
238			`is5_ptr = is5_ptr + 1;`
239			`end`
240
241			`always @(posedge sync)`
242			`if(s0[9])`
243			`begin`
244			`in_slt6 = #1 is6_mem[is6_ptr];`
245			`is6_ptr = is6_ptr + 1;`
246			`end`
247
248			`always @(posedge sync)`
249			`if(s0[8])`
250			`begin`
251			`in_slt7 = #1 is7_mem[is7_ptr];`
252			`is7_ptr = is7_ptr + 1;`
253			`end`
254
255			`always @(posedge sync)`
256			`if(s0[7])`
257			`begin`
258			`in_slt8 = #1 is8_mem[is8_ptr];`
259			`is8_ptr = is8_ptr + 1;`
260			`end`
261
262			`always @(posedge sync)`
263			`if(s0[6])`
264			`begin`
265			`in_slt9 = #1 is9_mem[is9_ptr];`
266			`is9_ptr = is9_ptr + 1;`
267			`end`
268
269			`always @(posedge sync)`
270			`if(s0[5])`
271			`begin`
272			`in_slt10 = #1 is10_mem[is10_ptr];`
273			`is10_ptr = is10_ptr + 1;`
274			`end`
275
276			`always @(posedge sync)`
277			`if(s0[4])`
278			`begin`
279			`in_slt11 = #1 is11_mem[is11_ptr];`
280			`is11_ptr = is11_ptr + 1;`
281			`end`
282
283			`always @(posedge sync)`
284			`if(s0[3])`
285			`begin`
286			`in_slt12 = #1 is12_mem[is12_ptr];`
287			`is12_ptr = is12_ptr + 1;`
288			`end`
289
290			`always @(posedge sync)`
291			`begin`
292			`rslt0 <= #2 out_slt0;`
293			`rslt1 <= #2 out_slt1;`
294			`rslt2 <= #2 out_slt2;`
295			`end`
296
297			`always @(posedge sync)`
298			`if(out_slt0[15] & out_slt0[14])`
299			`begin`
300			`rs1_mem[rs1_ptr] = #1 out_slt1;`
301			`rs1_ptr = rs1_ptr + 1;`
302			`//$display("INFO: Codec Register Addr: %h (%t)", out_slt1, $time);`
303			`end`
304
305			`always @(posedge sync)`
306			`if(out_slt0[15] & out_slt0[13])`
307			`begin`
308			`rs2_mem[rs2_ptr] = #1 out_slt2;`
309			`rs2_ptr = rs2_ptr + 1;`
310			`//$display("INFO: Codec Register Data: %h (%t)", out_slt2, $time);`
311			`end`
312
313			`always @(posedge sync)`
314			`if(out_slt0[15] & out_slt0[12])`
315			`begin`
316			`rs3_mem[rs3_ptr] = #1 out_slt3;`
317			`rs3_ptr = rs3_ptr + 1;`
318			`end`
319
320			`always @(posedge sync)`
321			`if(out_slt0[15] & out_slt0[11])`
322			`begin`
323			`rs4_mem[rs4_ptr] = #1 out_slt4;`
324			`rs4_ptr = rs4_ptr + 1;`
325			`end`
326
327			`always @(posedge sync)`
328			`if(out_slt0[15] & out_slt0[10])`
329			`begin`
330			`rs5_mem[rs5_ptr] = #1 out_slt5;`
331			`rs5_ptr = rs5_ptr + 1;`
332			`end`
333
334			`always @(posedge sync)`
335			`if(out_slt0[15] & out_slt0[9])`
336			`begin`
337			`rs6_mem[rs6_ptr] = #1 out_slt6;`
338			`rs6_ptr = rs6_ptr + 1;`
339			`end`
340
341			`always @(posedge sync)`
342			`if(out_slt0[15] & out_slt0[8])`
343			`begin`
344			`rs7_mem[rs7_ptr] = #1 out_slt7;`
345			`rs7_ptr = rs7_ptr + 1;`
346			`end`
347
348			`always @(posedge sync)`
349			`if(out_slt0[15] & out_slt0[7])`
350			`begin`
351			`rs8_mem[rs8_ptr] = #1 out_slt8;`
352			`rs8_ptr = rs8_ptr + 1;`
353			`end`
354
355			`always @(posedge sync)`
356			`if(out_slt0[15] & out_slt0[6])`
357			`begin`
358			`rs9_mem[rs9_ptr] = #1 out_slt9;`
359			`rs9_ptr = rs9_ptr + 1;`
360			`end`
361
362			`always @(posedge sync)`
363			`if(out_slt0[15] & out_slt0[5])`
364			`begin`
365			`rs10_mem[rs10_ptr] = #1 out_slt10;`
366			`rs10_ptr = rs10_ptr + 1;`
367			`end`
368
369			`always @(posedge sync)`
370			`if(out_slt0[15] & out_slt0[4])`
371			`begin`
372			`rs11_mem[rs11_ptr] = #1 out_slt11;`
373			`rs11_ptr = rs11_ptr + 1;`
374			`end`
375
376			`always @(posedge sync)`
377			`if(out_slt0[15] & out_slt0[3])`
378			`begin`
379			`rs12_mem[rs12_ptr] = #1 out_slt12;`
380			`rs12_ptr = rs12_ptr + 1;`
381			`end`
382
383
384			`task clr_ptrs;`
385
386			`begin`
387
388			`rs1_ptr = 0;`
389			`rs2_ptr = 0;`
390			`rs3_ptr = 0;`
391			`rs4_ptr = 0;`
392			`rs5_ptr = 0;`
393			`rs6_ptr = 0;`
394			`rs7_ptr = 0;`
395			`rs8_ptr = 0;`
396			`rs9_ptr = 0;`
397			`rs10_ptr = 0;`
398			`rs11_ptr = 0;`
399			`rs12_ptr = 0;`
400
401			`is2_ptr = 0;`
402			`is3_ptr = 0;`
403			`is4_ptr = 0;`
404			`is5_ptr = 0;`
405			`is6_ptr = 0;`
406			`is7_ptr = 0;`
407			`is8_ptr = 0;`
408			`is9_ptr = 0;`
409			`is10_ptr = 0;`
410			`is11_ptr = 0;`
411			`is12_ptr = 0;`
412
413			`end`
414			`endtask`
415
416
417			`task set_tag;`
418			`input cr;`
419			`input [11:0] tag;`
420
421			`// s0 - 16 bits`
422			`// 15 - Codec Ready`
423			`// 14:3 - Slot 1-12 Valid bits`
424			`// 2:0 - RESERVED (stuffed with 0)`
425			`begin`
426			`s0 = {cr, tag, 3'h0};`
427			`end`
428			`endtask`
429
430
431			`task set_req;`
432			`input [9:0] req;`
433
434			`reg [6:0] idx;`
435			`begin`
436
437			`idx = out_slt1[18:12];`
438			`s1 = {1'b0, idx, ~req, 2'h0};`
439
440			`end`
441			`endtask`
442
443
444			`task tx1;`
445			`input fcnt_max; // Total number fo frames`
446			`input rdy_del; // How many frames before codec is ready`
447			`input ovalid; // Out Channels valid (Surround Sound)`
448			`input ivalid; // In Channels Valid (Mic & Line In)`
449			`input oint; // Output Intervals`
450			`input iint; // input Intervals`
451
452			`integer fcnt_max, f;`
453			`integer rdy_del;`
454			`reg [9:0] ovalid, ivalid;`
455			`reg [19:0] oint, iint;`
456
457			`reg och0_v;`
458			`reg [1:0] och0_cnt;`
459			`reg och1_v;`
460			`reg [1:0] och1_cnt;`
461			`reg och2_v;`
462			`reg [1:0] och2_cnt;`
463			`reg och3_v;`
464			`reg [1:0] och3_cnt;`
465			`reg och4_v;`
466			`reg [1:0] och4_cnt;`
467			`reg och5_v;`
468			`reg [1:0] och5_cnt;`
469			`reg och6_v;`
470			`reg [1:0] och6_cnt;`
471			`reg och7_v;`
472			`reg [1:0] och7_cnt;`
473			`reg och8_v;`
474			`reg [1:0] och8_cnt;`
475			`reg och9_v;`
476			`reg [1:0] och9_cnt;`
477			`reg ich0_v;`
478			`reg [1:0] ich0_cnt;`
479			`reg ich1_v;`
480			`reg [1:0] ich1_cnt;`
481			`reg ich2_v;`
482			`reg [1:0] ich2_cnt;`
483			`reg ich3_v;`
484			`reg [1:0] ich3_cnt;`
485			`reg ich4_v;`
486			`reg [1:0] ich4_cnt;`
487			`reg ich5_v;`
488			`reg [1:0] ich5_cnt;`
489			`reg ich6_v;`
490			`reg [1:0] ich6_cnt;`
491			`reg ich7_v;`
492			`reg [1:0] ich7_cnt;`
493			`reg ich8_v;`
494			`reg [1:0] ich8_cnt;`
495			`reg ich9_v;`
496			`reg [1:0] ich9_cnt;`
497
498			`begin`
499
500			`och0_cnt = 0;`
501			`och1_cnt = 0;`
502			`och2_cnt = 0;`
503			`och3_cnt = 0;`
504			`och4_cnt = 0;`
505			`och5_cnt = 0;`
506			`och6_cnt = 0;`
507			`och7_cnt = 0;`
508			`och8_cnt = 0;`
509			`och9_cnt = 0;`
510
511			`ich0_cnt = 0;`
512			`ich1_cnt = 0;`
513			`ich2_cnt = 0;`
514			`ich3_cnt = 0;`
515			`ich4_cnt = 0;`
516			`ich5_cnt = 0;`
517			`ich6_cnt = 0;`
518			`ich7_cnt = 0;`
519			`ich8_cnt = 0;`
520			`ich9_cnt = 0;`
521
522			`for(f=0;f<fcnt_max;f=f+1)`
523			`begin`
524			`while(!sync) @(posedge clk);`
525			`if(f>rdy_del)`
526			`begin`
527
528			`och0_v = ovalid[9] & (och0_cnt == oint[19:18]);`
529			`if(och0_v) och0_cnt = 0;`
530			`else och0_cnt = och0_cnt + 1;`
531			`och1_v = ovalid[8] & (och1_cnt == oint[17:16]);`
532			`if(och1_v) och1_cnt = 0;`
533			`else och1_cnt = och1_cnt + 1;`
534			`och2_v = ovalid[7] & (och2_cnt == oint[15:14]);`
535			`if(och2_v) och2_cnt = 0;`
536			`else och2_cnt = och2_cnt + 1;`
537			`och3_v = ovalid[6] & (och3_cnt == oint[13:12]);`
538			`if(och3_v) och3_cnt = 0;`
539			`else och3_cnt = och3_cnt + 1;`
540			`och4_v = ovalid[5] & (och4_cnt == oint[11:10]);`
541			`if(och4_v) och4_cnt = 0;`
542			`else och4_cnt = och4_cnt + 1;`
543			`och5_v = ovalid[4] & (och5_cnt == oint[9:8]);`
544			`if(och5_v) och5_cnt = 0;`
545			`else och5_cnt = och5_cnt + 1;`
546			`och6_v = ovalid[3] & (och6_cnt == oint[7:6]);`
547			`if(och6_v) och6_cnt = 0;`
548			`else och6_cnt = och6_cnt + 1;`
549			`och7_v = ovalid[2] & (och7_cnt == oint[5:4]);`
550			`if(och7_v) och7_cnt = 0;`
551			`else och7_cnt = och7_cnt + 1;`
552			`och8_v = ovalid[1] & (och8_cnt == oint[3:2]);`
553			`if(och8_v) och8_cnt = 0;`
554			`else och8_cnt = och8_cnt + 1;`
555			`och9_v = ovalid[0] & (och9_cnt == oint[1:0]);`
556			`if(och9_v) och9_cnt = 0;`
557			`else och9_cnt = och9_cnt + 1;`
558
559			`ich0_v = ivalid[9] & (ich0_cnt == iint[19:18]);`
560			`if(ich0_v) ich0_cnt = 0;`
561			`else ich0_cnt = ich0_cnt + 1;`
562			`ich1_v = ivalid[8] & (ich1_cnt == iint[17:16]);`
563			`if(ich1_v) ich1_cnt = 0;`
564			`else ich1_cnt = ich1_cnt + 1;`
565			`ich2_v = ivalid[7] & (ich2_cnt == iint[15:14]);`
566			`if(ich2_v) ich2_cnt = 0;`
567			`else ich2_cnt = ich2_cnt + 1;`
568			`ich3_v = ivalid[6] & (ich3_cnt == iint[13:12]);`
569			`if(ich3_v) ich3_cnt = 0;`
570			`else ich3_cnt = ich3_cnt + 1;`
571			`ich4_v = ivalid[5] & (ich4_cnt == iint[11:10]);`
572			`if(ich4_v) ich4_cnt = 0;`
573			`else ich4_cnt = ich4_cnt + 1;`
574			`ich5_v = ivalid[4] & (ich5_cnt == iint[9:8]);`
575			`if(ich5_v) ich5_cnt = 0;`
576			`else ich5_cnt = ich5_cnt + 1;`
577			`ich6_v = ivalid[3] & (ich6_cnt == iint[7:6]);`
578			`if(ich6_v) ich6_cnt = 0;`
579			`else ich6_cnt = ich6_cnt + 1;`
580			`ich7_v = ivalid[2] & (ich7_cnt == iint[5:4]);`
581			`if(ich7_v) ich7_cnt = 0;`
582			`else ich7_cnt = ich7_cnt + 1;`
583			`ich8_v = ivalid[1] & (ich8_cnt == iint[3:2]);`
584			`if(ich8_v) ich8_cnt = 0;`
585			`else ich8_cnt = ich8_cnt + 1;`
586			`ich9_v = ivalid[0] & (ich9_cnt == iint[1:0]);`
587			`if(ich9_v) ich9_cnt = 0;`
588			`else ich9_cnt = ich9_cnt + 1;`
589
590			`set_tag(1'b1, { 1'b0, // Slot 1`
591			`1'b0, // Slot 2`
592			`ich0_v, ich1_v, ich2_v, ich3_v, ich4_v,`
593			`ich5_v, ich6_v, ich7_v, ich8_v, ich9_v} );`
594
595			`set_req( { och0_v, och1_v, och2_v, och3_v, och4_v,`
596			`och5_v, och6_v, och7_v, och8_v, och9_v} );`
597
598			`end`
599			`while(sync) @(posedge clk);`
600			`end`
601			`end`
602			`endtask`
603
604			`////////////////////////////////////////////////////////////////////`
605			`//`
606			`// Modules`
607			`//`
608
609			`ac97_codec_sin u0(`
610			`.clk( clk ),`
611			`.rst( rst ),`
612			`.sync( sync ),`
613			`.slt0( out_slt0 ),`
614			`.slt1( out_slt1 ),`
615			`.slt2( out_slt2 ),`
616			`.slt3( out_slt3 ),`
617			`.slt4( out_slt4 ),`
618			`.slt5( out_slt5 ),`
619			`.slt6( out_slt6 ),`
620			`.slt7( out_slt7 ),`
621			`.slt8( out_slt8 ),`
622			`.slt9( out_slt9 ),`
623			`.slt10( out_slt10 ),`
624			`.slt11( out_slt11 ),`
625			`.slt12( out_slt12 ),`
626			`.sdata_in( sdata_in )`
627			`);`
628
629			`ac97_codec_sout u1(`
630			`.clk( clk ),`
631			`.rst( rst ),`
632			`.sync( sync ),`
633			`.slt0( in_slt0 ),`
634			`.slt1( in_slt1 ),`
635			`.slt2( in_slt2 ),`
636			`.slt3( in_slt3 ),`
637			`.slt4( in_slt4 ),`
638			`.slt5( in_slt5 ),`
639			`.slt6( in_slt6 ),`
640			`.slt7( in_slt7 ),`
641			`.slt8( in_slt8 ),`
642			`.slt9( in_slt9 ),`
643			`.slt10( in_slt10 ),`
644			`.slt11( in_slt11 ),`
645			`.slt12( in_slt12 ),`
646			`.sdata_out( sdata_out )`
647			`);`
648
649			`endmodule`
650
651