Subversion Repositories psg16

`timescale 1ns / 1ps

// ============================================================================

//        __

//   \\__/ o\    (C) 2007-2017  Robert Finch, Waterloo

//    \  __ /    All rights reserved.

//     \/_//     robfinch<remove>@finitron.ca

//       ||

//

// PSG32.v

//

// 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 3 of the License, or     

// (at your option) any later version.                                      

//                                                                          

// This source file 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 General Public License for more details.                             

//                                                                          

// You should have received a copy of the GNU General Public License        

// along with this program.  If not, see <http://www.gnu.org/licenses/>.    

//                                                                          

//

//      Registers

//  00      -------- ffffffff ffffffff ffffffff     freq [23:0]

//  04      -------- -------- pppppppp pppppppp     pulse width

//      08          -------- -------- trsg-efo vvvvvv--         test, ringmod, sync, gate, filter, output, voice type

//  0C      -------- aaaaaaaa aaaaaaaa aaaaaaaa     attack

//  10      -------- dddddddd dddddddd dddddddd     decay

//  14      -------- -------- -------- ssssssss     sustain

//  18      -------- rrrrrrrr rrrrrrrr rrrrrrrr     release

//  1C      -------- -------- --aaaaaa aaaaaaa-     wave table base address

//                                                                                      vvvvv

//                                                                                      wnpst

//  20-3C   Voice #2

//  40-5C   Voice #3

//  60-7C   Voice #4

//

//      ...

//      B0      -------- -------- -------- ----vvvv   volume (0-255)

//      B4      nnnnnnnn nnnnnnnn nnnnnnnn nnnnnnnn   osc3 oscillator 3

//      B8      -------- -------- -------- nnnnnnnn   env3 envelope 3

//  BC      -------- -------- -sss-sss -sss-sss   env state

//

//  C0-DC   -------- -------- s---kkkk kkkkkkkk   filter coefficients

//  E0-FC   -------- -------- -------- --------   reserved for more filter coefficients

//

//=============================================================================

module PSG32(rst_i, clk_i, cs_i, cyc_i, stb_i, ack_o, we_i, adr_i, dat_i, dat_o,

        m_adr_o, m_dat_i, o

);

parameter pClkDivide = 37;

// WISHBONE SYSCON

input rst_i;

input clk_i;                    // system clock

// NON-WISHBONE

input cs_i;             // circuit select

// WISHBONE SLAVE

input cyc_i;                    // cycle valid

input stb_i;                    // circuit select

output ack_o;

input we_i;                             // write

input [7:0] adr_i;               // address input

input [31:0] dat_i;              // data input

output [31:0] dat_o;     // data output

// WISHBONE MASTER

output [13:0] m_adr_o;   // wave table address

input  [11:0] m_dat_i;   // wave table data input

output [17:0] o;

// I/O registers

reg [31:0] dat_o;

reg [13:0] m_adr_o;

reg [3:0] test;                          // test (enable note generator)

reg [5:0] vt [3:0];                       // voice type

reg [23:0] freq0, freq1, freq2, freq3;   // frequency control

reg [15:0] pw0, pw1, pw2, pw3;                   // pulse width control

reg [3:0] gate;

reg [23:0] attack0, attack1, attack2, attack3;

reg [23:0] decay0, decay1, decay2, decay3;

reg [7:0] sustain0, sustain1, sustain2, sustain3;

reg [23:0] relese0, relese1, relese2, relese3;

reg [13:0] wtadr0, wtadr1, wtadr2, wtadr3;

reg [3:0] sync;

reg [3:0] ringmod;

reg [3:0] outctrl;

reg [3:0] filt;                 // 1 = output goes to filter

reg [3:0] eg;                   // 1 = output goes through envelope generator

wire [31:0] acc0, acc1, acc2, acc3;

reg [3:0] volume;        // master volume

wire [11:0] tg1_o,tg2_o,tg3_o,tg4_o;    // tone generator output

wire [7:0] env;          // envelope generator output

wire [7:0] env0, env1, env2, env3;

wire [19:0] out0,out1,out2,out3;

wire [2:0] es0,es1,es2,es3;

wire [29:0] out4;

reg [21:0] sum,fsum;

reg [21:0] sum2;

wire [21:0] filtin1;     // FIR filter input

wire [37:0] filt_o;              // FIR filter output

reg [1:0] cnt;

reg [1:0] cnt1,cnt2,cnt3;

// channel select signal

wire [1:0] sel = cnt[1:0];

and(cs, cyc_i, stb_i, cs_i);

reg ack1,ack2;

always @(posedge clk_i)

        ack1 <= cs;

always @(posedge clk_i)

    ack2 <= ack1 & cs;

assign ack_o = cs ? (we_i ? 1'b1 : ack2) : 1'b0;

// Register shadow ram for register readback

reg [15:0] reg_shadow [63:0];

reg [8:0] radr;

always @(posedge clk_i)

    if (cs & we_i)  reg_shadow[adr_i[7:2]] <= dat_i[15:0];

always @(posedge clk_i)

    radr <= adr_i[7:2];

wire [15:0] reg_shadow_o = reg_shadow[radr];

// write to registers

always @(posedge clk_i)

begin

        if (rst_i) begin

                freq0 <= 0;

                freq1 <= 0;

                freq2 <= 0;

                freq3 <= 0;

                pw0 <= 0;

                pw1 <= 0;

                pw2 <= 0;

                pw3 <= 0;

                test <= 0;

                vt[0] <= 0;

                vt[1] <= 0;

                vt[2] <= 0;

                vt[3] <= 0;

                gate <= 0;

                outctrl <= 0;

                filt <= 0;

                attack0 <= 0;

                attack1 <= 0;

                attack2 <= 0;

                attack3 <= 0;

                decay0 <= 0;

                sustain0 <= 0;

                relese0 <= 0;

                decay1 <= 0;

                sustain1 <= 0;

                relese1 <= 0;

                decay2 <= 0;

                sustain2 <= 0;

                relese2 <= 0;

                decay3 <= 0;

                sustain3 <= 0;

                relese3 <= 0;

                sync <= 0;

                ringmod <= 0;

                volume <= 0;

        end

        else begin

                if (cs & we_i) begin

                        case(adr_i[7:2])

                        //---------------------------------------------------------

                        6'd00:  freq0 <= dat_i[23:0];

                        6'd01:  pw0 <= dat_i[15:0];

                        6'd02:  begin

                                                vt[0] <= dat_i[7:2];

                                                outctrl[0] <= dat_i[8];

                                                filt[0] <= dat_i[9];

                                                eg[0] <= dat_i[10];

                                                gate[0] <= dat_i[12];

                                                sync[0] <= dat_i[13];

                                                ringmod[0] <= dat_i[14];

                                                test[0] <= dat_i[15];

                                        end

                        6'd03:  attack0 <= dat_i[23:0];

                        6'd04:  decay0 <= dat_i[23:0];

                    6'd05:  sustain0 <= dat_i[7:0];

                        6'd06:  relese0 <= dat_i[23:0];

            6'd07:  wtadr0 <= {dat_i[13:1],1'b0};

                        //---------------------------------------------------------

                        6'd08:  freq1 <= dat_i[23:0];

                        6'd09:  pw1 <= dat_i[15:0];

                        6'd10:  begin

                                                vt[1] <= dat_i[7:2];

                                                outctrl[1] <= dat_i[8];

                                                filt[1] <= dat_i[9];

                                                eg[1] <= dat_i[10];

                                                gate[1] <= dat_i[12];

                                                sync[1] <= dat_i[13];

                                                ringmod[1] <= dat_i[14];

                                                test[1] <= dat_i[15];

                                        end

                        6'd11:  attack1 <= dat_i[23:0];

            6'd12:  decay1 <= dat_i[23:0];

            6'd13:  sustain1 <= dat_i[7:0];

            6'd14:  relese1 <= dat_i[23:0];

            6'd15:  wtadr1 <= {dat_i[13:1],1'b0};

                        //---------------------------------------------------------

                        6'd16:  freq2 <= dat_i[23:0];

                        6'd17:  pw2 <= dat_i[15:0];

                        6'd18:  begin

                                                vt[2] <= dat_i[7:2];

                                                outctrl[2] <= dat_i[8];

                                                filt[2] <= dat_i[9];

                                                eg[2] <= dat_i[10];

                                                gate[2] <= dat_i[12];

                                                sync[2] <= dat_i[5];

                                                outctrl[0] <= dat_i[13];

                                                ringmod[2] <= dat_i[14];

                                                test[2] <= dat_i[15];

                                        end

                        6'd19:  attack2 <= dat_i[23:0];

            6'd20:  decay2 <= dat_i[23:0];

            6'd21:  sustain2 <= dat_i[7:0];

            6'd22:  relese2 <= dat_i[23:0];

            6'd23:  wtadr2 <= {dat_i[13:1],1'b0};

                        //---------------------------------------------------------

                        6'd24:  freq3 <= dat_i[23:0];

                        6'd25:  pw3 <= dat_i[15:0];

                        6'd26:  begin

                                                vt[3] <= dat_i[7:2];

                                                outctrl[3] <= dat_i[8];

                                                filt[3] <= dat_i[9];

                                                eg[3] <= dat_i[10];

                                                gate[3] <= dat_i[12];

                                                sync[3] <= dat_i[13];

                                                ringmod[3] <= dat_i[14];

                                                test[3] <= dat_i[15];

                                        end

                        6'd27:  attack3 <= dat_i[23:0];

            6'd28:  decay3 <= dat_i[23:0];

            6'd29:  sustain3 <= dat_i[7:0];

            6'd30:  relese3 <= dat_i[23:0];

            6'd31:  wtadr3 <= {dat_i[13:1],1'b0};

                        //---------------------------------------------------------

                        6'd44:  volume <= dat_i[3:0];

                        default:        ;

                        endcase

                end

        end

end

always @(posedge clk_i)

    case(adr_i[7:2])

    6'd45:      begin

            dat_o <= acc3;

            end

    6'd46:      begin

            dat_o <= {24'h0,env3};

            end

    6'd47:  dat_o <= {17'h0,es3,1'b0,es2,1'b0,es1,1'b0,es0};

    default: begin

            dat_o <= reg_shadow_o;

            end

    endcase

wire [13:0] madr;

mux4to1 #(12) u11

(

        .e(1'b1),

        .s(cnt),

        .i0(wtadr0 + {acc0[27:17],1'b0}),

        .i1(wtadr1 + {acc1[27:17],1'b0}),

        .i2(wtadr2 + {acc2[27:17],1'b0}),

        .i3(wtadr3 + {acc3[27:17],1'b0}),

        .z(madr)

);

always @(posedge clk_i)

    m_adr_o <= madr;

wire [11:0] wave_i = m_dat_i;

// This counter controls channel multiplexing for the wave table

always @(posedge clk_i)

if (rst_i)

    cnt <= 2'd0;

else

    cnt <= cnt + 2'd1;

// note generator - multi-channel

PSGToneGenerator u1a

(

    .rst(rst_i),

    .clk(clk_i),

    .ack(cnt==2'b11),

    .test(test[0]),

    .vt(vt[0]),

    .freq(freq0),

    .pw(pw0),

    .acc(acc0),

    .prev_acc(acc3),

    .wave(wave_i),

    .sync(sync[0]),

    .ringmod(ringmod[0]),

    .o(tg1_o)

);

PSGToneGenerator u1b

(

    .rst(rst_i),

    .clk(clk_i),

    .ack(cnt==2'b00),

    .test(test[1]),

    .vt(vt[1]),

    .freq(freq1),

    .pw(pw1),

    .acc(acc1),

    .prev_acc(acc0),

    .wave(wave_i),

    .sync(sync[1]),

    .ringmod(ringmod[1]),

    .o(tg2_o)

);

PSGToneGenerator u1c

(

    .rst(rst_i),

    .clk(clk_i),

    .ack(cnt==2'b01),

    .test(test[2]),

    .vt(vt[2]),

    .freq(freq2),

    .pw(pw2),

    .acc(acc2),

    .prev_acc(acc1),

    .wave(wave_i),

    .sync(sync[2]),

    .ringmod(ringmod[2]),

    .o(tg3_o)

);

PSGToneGenerator u1d

(

    .rst(rst_i),

    .clk(clk_i),

    .ack(cnt==2'b10),

    .test(test[3]),

    .vt(vt[3]),

    .freq(freq3),

    .pw(pw3),

    .acc(acc3),

    .prev_acc(acc2),

    .wave(wave_i),

    .sync(sync[3]),

    .ringmod(ringmod[3]),

    .o(tg4_o)

);

PSGEnvelopeGenerator u2a

(

    .rst(rst_i),

    .clk(clk_i),

    .gate(gate[0]),

    .attack(attack0),

    .decay(decay0),

    .sustain(sustain0),

    .relese(relese0),

    .o(env0),

    .envState(es0)

);

PSGEnvelopeGenerator u2b

(

    .rst(rst_i),

    .clk(clk_i),

    .gate(gate[1]),

    .attack(attack1),

    .decay(decay1),

    .sustain(sustain1),

    .relese(relese1),

    .o(env1),

    .envState(es1)

);

PSGEnvelopeGenerator u2c

(

    .rst(rst_i),

    .clk(clk_i),

    .gate(gate[2]),

    .attack(attack2),

    .decay(decay2),

    .sustain(sustain2),

    .relese(relese2),

    .o(env2),

    .envState(es2)

);

PSGEnvelopeGenerator u2d

(

    .rst(rst_i),

    .clk(clk_i),

    .gate(gate[3]),

    .attack(attack3),

    .decay(decay3),

    .sustain(sustain3),

    .relese(relese3),

    .o(env3),

    .envState(es3)

);

// shape output according to envelope

PSGShaper u5a

(

        .clk_i(clk_i),

        .ce(1'b1),

        .tgi(tg1_o),

        .env(eg[0] ? env0 : 8'hFF),

        .o(out0)

);

PSGShaper u5b

(

        .clk_i(clk_i),

        .ce(1'b1),

        .tgi(tg2_o),

        .env(eg[1] ? env1 : 8'hFF),

        .o(out1)

);

PSGShaper u5c

(

        .clk_i(clk_i),

        .ce(1'b1),

        .tgi(tg3_o),

        .env(eg[2] ? env2 : 8'hFF),

        .o(out2)

);

PSGShaper u5d

(

        .clk_i(clk_i),

        .ce(1'b1),

        .tgi(tg4_o),

        .env(eg[3] ? env3 : 8'hFF),

        .o(out3)

);

always @(posedge clk_i)

        cnt1 <= cnt;

always @(posedge clk_i)

        cnt2 <= cnt1;

always @(posedge clk_i)

        cnt3 <= cnt2;

// Sum the channels not going to the filter

always @(posedge clk_i)

sum <=

    {2'd0,(out0 & {20{outctrl[0]}})} +

    {2'd0,(out1 & {20{outctrl[1]}})} +

    {2'd0,(out2 & {20{outctrl[2]}})} +

    {2'd0,(out3 & {20{outctrl[3]}})};

// Sum the channels going to the filter

always @(posedge clk_i)

fsum <=

    {2'd0,(out0 & {20{filt[0]}})} +

    {2'd0,(out1 & {20{filt[1]}})} +

    {2'd0,(out2 & {20{filt[2]}})} +

    {2'd0,(out3 & {20{filt[3]}})};

// The FIR filter

PSGFilter2 u8

(

        .rst(rst_i),

        .clk(clk_i),

        .cnt(cnt2),

        .wr(we_i && stb_i && adr_i[7:6]==3'b11),

    .adr(adr_i[5:2]),

    .din({dat_i[15],dat_i[11:0]}),

    .i(fsum),

    .o(filt_o)

);

// Sum the filtered and unfiltered output

always @(posedge clk_i)

        sum2 <= sum + filt_o[37:16];

// Last stage:

// Adjust output according to master volume

PSGVolumeControl u10

(

        .rst_i(rst_i),

        .clk_i(clk_i),

        .i(sum2),

        .volume(volume),

        .o(out4)

);

assign o = out4[29:12];

endmodule