Subversion Repositories systemc_cordic

// cordpipe.h: header file
/********************************************************************
// 
// Module:
//   Cordic Engine 12-stage Pipeline
//
// Interface:
//   This module connects the 12-stages together.
//   Registered input, non-registered output
//
//
// Authors: 	Winnie Cheng <wwcheng@stanford.edu>,
//		Peter Wu <peter5@stanford.edu>
//
 *********************************************************************/
 
#include "systemc.h"
#include "cordic.h"
#include "opcode.h"
 
SC_MODULE(cordpipe) {
 
    // Clock Declaration
    sc_in_clk clk;
 
    // Input ports Declaration
    sc_in<bool> start;	
    sc_in<bool> reset;
 
    // Input data - first stage results
    sc_in<short> in_x;
    sc_in<short> in_y;
    sc_in<short> in_acc_phase;
 
    // Input data - propagated instruction info
    sc_in<sc_uint<UNIT_SEL_WIDTH> > in_opcode;
    sc_in<short> in_desired_phase; 
 
    // Output ports Declaration
    sc_out<bool> done;
 
    // Output data - results of this stage
    sc_out<short> out_x;
    sc_out<short> out_y;
    sc_out<short> out_acc_phase;
 
    // Output data - propagated instruction info 
    sc_out<sc_uint<UNIT_SEL_WIDTH> > out_opcode;
    sc_out<short> out_desired_phase; 
 
    // constants to parametrize pipeline module on system reset
    sc_in<short> stage0;
    sc_in<short> stage1;
    sc_in<short> stage2;
    sc_in<short> stage3;
    sc_in<short> stage4;
    sc_in<short> stage5;
    sc_in<short> stage6;
    sc_in<short> stage7;
    sc_in<short> stage8;
    sc_in<short> stage9;
    sc_in<short> stage10;
    sc_in<short> stage11;
 
    sc_in<short> tablep_0;
    sc_in<short> tablep_1;
    sc_in<short> tablep_2;
    sc_in<short> tablep_3;
    sc_in<short> tablep_4;
    sc_in<short> tablep_5;
    sc_in<short> tablep_6;
    sc_in<short> tablep_7;
    sc_in<short> tablep_8;
    sc_in<short> tablep_9;
    sc_in<short> tablep_10;
    sc_in<short> tablep_11;
 
    sc_in<short> tableh_0;
    sc_in<short> tableh_1;
    sc_in<short> tableh_2;
    sc_in<short> tableh_3;
    sc_in<short> tableh_4;
    sc_in<short> tableh_5;
    sc_in<short> tableh_6;
    sc_in<short> tableh_7;
    sc_in<short> tableh_8;
    sc_in<short> tableh_9;
    sc_in<short> tableh_10;
    sc_in<short> tableh_11;
 
    // Signals
    sc_signal<short> out0_x;
    sc_signal<short> out1_x;
    sc_signal<short> out2_x;
    sc_signal<short> out3_x;
    sc_signal<short> out4_x;
    sc_signal<short> out5_x;
    sc_signal<short> out6_x;
    sc_signal<short> out7_x;
    sc_signal<short> out8_x;
    sc_signal<short> out9_x;
    sc_signal<short> out10_x;
 
    sc_signal<short> out0_y;
    sc_signal<short> out1_y;
    sc_signal<short> out2_y;
    sc_signal<short> out3_y;
    sc_signal<short> out4_y;
    sc_signal<short> out5_y;
    sc_signal<short> out6_y;
    sc_signal<short> out7_y;
    sc_signal<short> out8_y;
    sc_signal<short> out9_y;
    sc_signal<short> out10_y;
 
    sc_signal<short> out0_acc_phase;
    sc_signal<short> out1_acc_phase;
    sc_signal<short> out2_acc_phase;
    sc_signal<short> out3_acc_phase;
    sc_signal<short> out4_acc_phase;
    sc_signal<short> out5_acc_phase;
    sc_signal<short> out6_acc_phase;
    sc_signal<short> out7_acc_phase;
    sc_signal<short> out8_acc_phase;
    sc_signal<short> out9_acc_phase;
    sc_signal<short> out10_acc_phase;
 
    sc_signal<sc_uint<UNIT_SEL_WIDTH> > out0_opcode;
    sc_signal<sc_uint<UNIT_SEL_WIDTH> > out1_opcode;
    sc_signal<sc_uint<UNIT_SEL_WIDTH> > out2_opcode;
    sc_signal<sc_uint<UNIT_SEL_WIDTH> > out3_opcode;
    sc_signal<sc_uint<UNIT_SEL_WIDTH> > out4_opcode;
    sc_signal<sc_uint<UNIT_SEL_WIDTH> > out5_opcode;
    sc_signal<sc_uint<UNIT_SEL_WIDTH> > out6_opcode;
    sc_signal<sc_uint<UNIT_SEL_WIDTH> > out7_opcode;
    sc_signal<sc_uint<UNIT_SEL_WIDTH> > out8_opcode;
    sc_signal<sc_uint<UNIT_SEL_WIDTH> > out9_opcode;
    sc_signal<sc_uint<UNIT_SEL_WIDTH> > out10_opcode;
 
    sc_signal<short> out0_desired_phase;
    sc_signal<short> out1_desired_phase;
    sc_signal<short> out2_desired_phase;
    sc_signal<short> out3_desired_phase;
    sc_signal<short> out4_desired_phase;
    sc_signal<short> out5_desired_phase;
    sc_signal<short> out6_desired_phase;
    sc_signal<short> out7_desired_phase;
    sc_signal<short> out8_desired_phase;
    sc_signal<short> out9_desired_phase;
    sc_signal<short> out10_desired_phase;
 
    sc_signal<bool> stage0_done;
    sc_signal<bool> stage1_done;
    sc_signal<bool> stage2_done;
    sc_signal<bool> stage3_done;
    sc_signal<bool> stage4_done;
    sc_signal<bool> stage5_done;
    sc_signal<bool> stage6_done;
    sc_signal<bool> stage7_done;
    sc_signal<bool> stage8_done;
    sc_signal<bool> stage9_done;
    sc_signal<bool> stage10_done;
 
    // 12 stage instances
    cordic *s0_instance;
    cordic *s1_instance;
    cordic *s2_instance;
    cordic *s3_instance;
    cordic *s4_instance;
    cordic *s5_instance;
    cordic *s6_instance;
    cordic *s7_instance;
    cordic *s8_instance;
    cordic *s9_instance;
    cordic *s10_instance;
    cordic *s11_instance;
 
    // Constructor
    SC_CTOR(cordpipe)
    {
         // instantiate and connect stage 0
         s0_instance = new cordic("stage0_in_pipe");
         s0_instance->clk(clk);
         s0_instance->start(start);
         s0_instance->reset(reset);
         s0_instance->in_x(in_x);
	 s0_instance->in_y(in_y);
	 s0_instance->in_acc_phase(in_acc_phase);
	 s0_instance->in_opcode(in_opcode);
	 s0_instance->in_desired_phase(in_desired_phase);
	 s0_instance->stage_num(stage0);
	 s0_instance->tablep(tablep_0);
	 s0_instance->tableh(tableh_0);
	 s0_instance->done(stage0_done);
	 s0_instance->out_x(out0_x);
	 s0_instance->out_y(out0_y);
	 s0_instance->out_acc_phase(out0_acc_phase);
	 s0_instance->out_opcode(out0_opcode);
	 s0_instance->out_desired_phase(out0_desired_phase);
 
         // instantiate and connect stage 1
         s1_instance = new cordic("stage1_in_pipe");
         s1_instance->clk(clk);
         s1_instance->start(start);
         s1_instance->reset(reset);
         s1_instance->in_x(out0_x);
	 s1_instance->in_y(out0_y);
	 s1_instance->in_acc_phase(out0_acc_phase);
	 s1_instance->in_opcode(out0_opcode);
	 s1_instance->in_desired_phase(out0_desired_phase);
	 s1_instance->stage_num(stage1);
	 s1_instance->tablep(tablep_1);
	 s1_instance->tableh(tableh_1);
	 s1_instance->done(stage1_done);
	 s1_instance->out_x(out1_x);
	 s1_instance->out_y(out1_y);
	 s1_instance->out_acc_phase(out1_acc_phase);
	 s1_instance->out_opcode(out1_opcode);
	 s1_instance->out_desired_phase(out1_desired_phase);
 
         // instantiate and connect stage 2
         s2_instance = new cordic("stage2_in_pipe");
         s2_instance->clk(clk);
         s2_instance->start(start);
         s2_instance->reset(reset);
         s2_instance->in_x(out1_x);
	 s2_instance->in_y(out1_y);
	 s2_instance->in_acc_phase(out1_acc_phase);
	 s2_instance->in_opcode(out1_opcode);
	 s2_instance->in_desired_phase(out1_desired_phase);
	 s2_instance->stage_num(stage2);
	 s2_instance->tablep(tablep_2);
	 s2_instance->tableh(tableh_2);
	 s2_instance->done(stage2_done);
	 s2_instance->out_x(out2_x);
	 s2_instance->out_y(out2_y);
	 s2_instance->out_acc_phase(out2_acc_phase);
	 s2_instance->out_opcode(out2_opcode);
	 s2_instance->out_desired_phase(out2_desired_phase);
 
         // instantiate and connect stage 3
         s3_instance = new cordic("stage3_in_pipe");
         s3_instance->clk(clk);
         s3_instance->start(start);
         s3_instance->reset(reset);
         s3_instance->in_x(out2_x);
	 s3_instance->in_y(out2_y);
	 s3_instance->in_acc_phase(out2_acc_phase);
	 s3_instance->in_opcode(out2_opcode);
	 s3_instance->in_desired_phase(out2_desired_phase);
	 s3_instance->stage_num(stage3);
	 s3_instance->tablep(tablep_3);
	 s3_instance->tableh(tableh_3);
	 s3_instance->done(stage3_done);
	 s3_instance->out_x(out3_x);
	 s3_instance->out_y(out3_y);
	 s3_instance->out_acc_phase(out3_acc_phase);
	 s3_instance->out_opcode(out3_opcode);
	 s3_instance->out_desired_phase(out3_desired_phase);
 
         // instantiate and connect stage 4
         s4_instance = new cordic("stage4_in_pipe");
         s4_instance->clk(clk);
         s4_instance->start(start);
         s4_instance->reset(reset);
         s4_instance->in_x(out3_x);
	 s4_instance->in_y(out3_y);
	 s4_instance->in_acc_phase(out3_acc_phase);
	 s4_instance->in_opcode(out3_opcode);
	 s4_instance->in_desired_phase(out3_desired_phase);
	 s4_instance->stage_num(stage4);
	 s4_instance->tablep(tablep_4);
	 s4_instance->tableh(tableh_4);
	 s4_instance->done(stage4_done);
	 s4_instance->out_x(out4_x);
	 s4_instance->out_y(out4_y);
	 s4_instance->out_acc_phase(out4_acc_phase);
	 s4_instance->out_opcode(out4_opcode);
	 s4_instance->out_desired_phase(out4_desired_phase);
 
         // instantiate and connect stage 5
         s5_instance = new cordic("stage5_in_pipe");
         s5_instance->clk(clk);
         s5_instance->start(start);
         s5_instance->reset(reset);
         s5_instance->in_x(out4_x);
	 s5_instance->in_y(out4_y);
	 s5_instance->in_acc_phase(out4_acc_phase);
	 s5_instance->in_opcode(out4_opcode);
	 s5_instance->in_desired_phase(out4_desired_phase);
	 s5_instance->stage_num(stage5);
	 s5_instance->tablep(tablep_5);
	 s5_instance->tableh(tableh_5);
	 s5_instance->done(stage5_done);
	 s5_instance->out_x(out5_x);
	 s5_instance->out_y(out5_y);
	 s5_instance->out_acc_phase(out5_acc_phase);
	 s5_instance->out_opcode(out5_opcode);
	 s5_instance->out_desired_phase(out5_desired_phase);
 
         // instantiate and connect stage 6
         s6_instance = new cordic("stage6_in_pipe");
         s6_instance->clk(clk);
         s6_instance->start(start);
         s6_instance->reset(reset);
         s6_instance->in_x(out5_x);
	 s6_instance->in_y(out5_y);
	 s6_instance->in_acc_phase(out5_acc_phase);
	 s6_instance->in_opcode(out5_opcode);
	 s6_instance->in_desired_phase(out5_desired_phase);
	 s6_instance->stage_num(stage6);
	 s6_instance->tablep(tablep_6);
	 s6_instance->tableh(tableh_6);
	 s6_instance->done(stage6_done);
	 s6_instance->out_x(out6_x);
	 s6_instance->out_y(out6_y);
	 s6_instance->out_acc_phase(out6_acc_phase);
	 s6_instance->out_opcode(out6_opcode);
	 s6_instance->out_desired_phase(out6_desired_phase);
 
         // instantiate and connect stage 7
         s7_instance = new cordic("stage7_in_pipe");
         s7_instance->clk(clk);
         s7_instance->start(start);
         s7_instance->reset(reset);
         s7_instance->in_x(out6_x);
	 s7_instance->in_y(out6_y);
	 s7_instance->in_acc_phase(out6_acc_phase);
	 s7_instance->in_opcode(out6_opcode);
	 s7_instance->in_desired_phase(out6_desired_phase);
	 s7_instance->stage_num(stage7);
	 s7_instance->tablep(tablep_7);
	 s7_instance->tableh(tableh_7);
	 s7_instance->done(stage7_done);
	 s7_instance->out_x(out7_x);
	 s7_instance->out_y(out7_y);
	 s7_instance->out_acc_phase(out7_acc_phase);
	 s7_instance->out_opcode(out7_opcode);
	 s7_instance->out_desired_phase(out7_desired_phase);
 
         // instantiate and connect stage 8
         s8_instance = new cordic("stage8_in_pipe");
         s8_instance->clk(clk);
         s8_instance->start(start);
         s8_instance->reset(reset);
         s8_instance->in_x(out7_x);
	 s8_instance->in_y(out7_y);
	 s8_instance->in_acc_phase(out7_acc_phase);
	 s8_instance->in_opcode(out7_opcode);
	 s8_instance->in_desired_phase(out7_desired_phase);
	 s8_instance->stage_num(stage8);
	 s8_instance->tablep(tablep_8);
	 s8_instance->tableh(tableh_8);
	 s8_instance->done(stage8_done);
	 s8_instance->out_x(out8_x);
	 s8_instance->out_y(out8_y);
	 s8_instance->out_acc_phase(out8_acc_phase);
	 s8_instance->out_opcode(out8_opcode);
	 s8_instance->out_desired_phase(out8_desired_phase);
 
         // instantiate and connect stage 9
         s9_instance = new cordic("stage9_in_pipe");
         s9_instance->clk(clk);
         s9_instance->start(start);
         s9_instance->reset(reset);
         s9_instance->in_x(out8_x);
	 s9_instance->in_y(out8_y);
	 s9_instance->in_acc_phase(out8_acc_phase);
	 s9_instance->in_opcode(out8_opcode);
	 s9_instance->in_desired_phase(out8_desired_phase);
	 s9_instance->stage_num(stage9);
	 s9_instance->tablep(tablep_9);
	 s9_instance->tableh(tableh_9);
	 s9_instance->done(stage9_done);
	 s9_instance->out_x(out9_x);
	 s9_instance->out_y(out9_y);
	 s9_instance->out_acc_phase(out9_acc_phase);
	 s9_instance->out_opcode(out9_opcode);
	 s9_instance->out_desired_phase(out9_desired_phase);
 
         // instantiate and connect stage 10
         s10_instance = new cordic("stage10_in_pipe");
         s10_instance->clk(clk);
         s10_instance->start(start);
         s10_instance->reset(reset);
         s10_instance->in_x(out9_x);
	 s10_instance->in_y(out9_y);
	 s10_instance->in_acc_phase(out9_acc_phase);
	 s10_instance->in_opcode(out9_opcode);
	 s10_instance->in_desired_phase(out9_desired_phase);
	 s10_instance->stage_num(stage10);
	 s10_instance->tablep(tablep_10);
	 s10_instance->tableh(tableh_10);
	 s10_instance->done(stage10_done);
	 s10_instance->out_x(out10_x);
	 s10_instance->out_y(out10_y);
	 s10_instance->out_acc_phase(out10_acc_phase);
	 s10_instance->out_opcode(out10_opcode);
	 s10_instance->out_desired_phase(out10_desired_phase);
 
         // instantiate and connect stage 11
         s11_instance = new cordic("stage11_in_pipe");
         s11_instance->clk(clk);
         s11_instance->start(start);
         s11_instance->reset(reset);
         s11_instance->in_x(out10_x);
	 s11_instance->in_y(out10_y);
	 s11_instance->in_acc_phase(out10_acc_phase);
	 s11_instance->in_opcode(out10_opcode);
	 s11_instance->in_desired_phase(out10_desired_phase);
	 s11_instance->stage_num(stage11);
	 s11_instance->tablep(tablep_11);
	 s11_instance->tableh(tableh_11);
	 s11_instance->done(done);
	 s11_instance->out_x(out_x);
	 s11_instance->out_y(out_y);
	 s11_instance->out_acc_phase(out_acc_phase);
	 s11_instance->out_opcode(out_opcode);
	 s11_instance->out_desired_phase(out_desired_phase);
 
    }
 
}; // end module cordpipe