Subversion Repositories openhmc

/*

 *                              .--------------. .----------------. .------------.

 *                             | .------------. | .--------------. | .----------. |

 *                             | | ____  ____ | | | ____    ____ | | |   ______ | |

 *                             | ||_   ||   _|| | ||_   \  /   _|| | | .' ___  || |

 *       ___  _ __   ___ _ __  | |  | |__| |  | | |  |   \/   |  | | |/ .'   \_|| |

 *      / _ \| '_ \ / _ \ '_ \ | |  |  __  |  | | |  | |\  /| |  | | || |       | |

 *       (_) | |_) |  __/ | | || | _| |  | |_ | | | _| |_\/_| |_ | | |\ `.___.'\| |

 *      \___/| .__/ \___|_| |_|| ||____||____|| | ||_____||_____|| | | `._____.'| |

 *           | |               | |            | | |              | | |          | |

 *           |_|               | '------------' | '--------------' | '----------' |

 *                              '--------------' '----------------' '------------'

 *

 *  openHMC - An Open Source Hybrid Memory Cube Controller

 *  (C) Copyright 2014 Computer Architecture Group - University of Heidelberg

 *  www.ziti.uni-heidelberg.de

 *  B6, 26

 *  68159 Mannheim

 *  Germany

 *

 *  Contact: openhmc@ziti.uni-heidelberg.de

 *  http://ra.ziti.uni-heidelberg.de/openhmc

 *

 *   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 Lesser General Public License for more details.

 *

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

 *   along with this source file.  If not, see .

 *

 *

 */

`ifndef HMC_RESPONDER_DRIVER_SV

`define HMC_RESPONDER_DRIVER_SV

class hmc_responder_driver#(parameter NUM_LANES=16) extends hmc_driver_base#(NUM_LANES);

        bit clear_error = 0;

        `uvm_component_param_utils(hmc_responder_driver#(.NUM_LANES(NUM_LANES)))

        function new(string name="hmc_responder_driver", uvm_component parent);

                super.new(name,parent);

                hmc_frp_port    = new("hmc_frp_port", this);

        endfunction : new

        function void build_phase(uvm_phase phase);

                super.build_phase(phase);

                start_clear_retry_event = new("start_retry_event");

                local_config = link_config.responder;

                if (!local_config.requester) begin

                tokens_to_send = link_config.hmc_tokens;

                `uvm_info(get_type_name(),$psprintf("initial_trets token_count = %0d", link_config.hmc_tokens), UVM_NONE)

                end else begin

                        tokens_to_send = link_config.rx_tokens;

                        `uvm_info(get_type_name(),$psprintf("initial_trets token_count = %0d", link_config.rx_tokens), UVM_NONE)

                end

                token_count_not_zero : assert (tokens_to_send > 0);

        endfunction : build_phase

        task run_phase(uvm_phase phase);

                super.run_phase(phase);

                forever begin

                        if(vif.P_RST_N !== 1) begin

                                next_state = RESET;

                        end

                        fork

                                forever begin

                                        if (next_state != state) begin

                                                `uvm_info(get_type_name(),$psprintf("in state %s", next_state.name()), UVM_HIGH)

                                        end

                                        last_state = state;

                                        state = next_state;

                                        case (state)

                                                RESET: reset();

                                                POWER_DOWN: power_down();

                                                INIT: init();

                                                PRBS: prbs();

                                                NULL_FLITS: null_flits();

                                                TS1: ts1();

                                                NULL_FLITS_2: null_flits_2();

                                                INITIAL_TRETS: initial_trets();

                                                LINK_UP: link_up();

                                                START_RETRY_INIT: start_retry_init();

                                                CLEAR_RETRY: clear_retry();

                                                SEND_RETRY_PACKETS: send_retry_packets();

                                        endcase

                                        clear_error = 0;

                                end

                                begin

                                        @(negedge vif.P_RST_N);

                                end

                                forever begin

                                        start_clear_retry_event.wait_ptrigger();

                                        start_clear_retry_event.reset(0);

                                        next_state = CLEAR_RETRY;

                                        `uvm_info(get_type_name(), "start retry event was triggered", UVM_HIGH)

                                        clear_error = 1;

                                end

                                begin

                                        time wait_time;

                                        @(negedge vif.RXPS);

                                        power_down_time_success : assert (std::randomize(wait_time) with { wait_time>0 && wait_time <= link_config.t_PST + 3*link_config.t_SS;});

                                        #wait_time;

                                        vif.TXPS = 0;

                                        link_down_time_success : assert (std::randomize(wait_time) with { wait_time>0 && wait_time <= link_config.t_SME;});

                                        #wait_time;

                                        next_state = POWER_DOWN;

                                end

                                clk_gen();

                        join_any;

                        disable fork;

                end

        endtask : run_phase

        task reset();

                vif.TXP = {NUM_LANES {1'bz}};

                vif.TXN = {NUM_LANES {1'bz}};

                vif.TXPS = 1'bz;

                vif.FERR_N = 1'bz;

                seq_num = 1;

                last_rrp = 0;

                init_continue = 0;

                can_continue = 0;

                retry_buffer.reset();

                //wait for reset signal

                @(posedge vif.P_RST_N);

                reset_timestamp = $time;

                next_state = INIT;

        endtask : reset

        task power_down();

                time wait_time;

                clear_lanes();

                vif.TXP = {NUM_LANES {1'bz}};

                vif.TXN = {NUM_LANES {1'bz}};

                recover_from_power_down = 1;

                @(posedge vif.RXPS)

                //-- wait some time < t_pst

                power_up_time_success : assert (std::randomize(wait_time) with { wait_time>0 && wait_time <= link_config.t_PST + 3*link_config.t_SS;});

                #wait_time;

                vif.TXPS = 1;

                //-- wait some time < t_sme

                link_up_time_success : assert (std::randomize(wait_time) with { wait_time>0 && wait_time <= link_config.t_SME;});

                #wait_time;

                next_state = PRBS;

        endtask : power_down

        task init();

                //wait for tINIT to pass

                while ($time < reset_timestamp + link_config.tINIT)

                        @(posedge vif.REFCLKP);

                can_continue = 1;

                // TODO: Think of the "right" place to do this.

                // The problem is that it should happen in the sideband.

                // In our case, the sideband is software-controlled, not part of the controller.

                set_init_continue();

                `uvm_info(get_type_name(),$psprintf("active = %0d retry prob = %0d", local_config.active, local_config.random_retry_probability), UVM_HIGH)

                //wait for init_continue to be set

                while (!init_continue)

                        @(posedge vif.REFCLKP);

                //Set TXPS high

                vif.TXPS = 1'b1;

                //@(posedge vif.REFCLKP);

                next_state = PRBS;

        endtask : init

        task prbs();

                int prbs_time;

                prbs_timestamp = $time;

                // send PRBS at least until Requester locks

                while (!(remote_status.current_state > PRBS))

                        for (int i=0; i < 4; i++)

                                drive_fit({NUM_LANES/2 {i[1:0]}});

                // Randomize PRBS length

                prbs_time_randomization_succeeds : assert (std::randomize(prbs_time) with {prbs_time > 0ns && prbs_time < link_config.tRESP1;});

                `uvm_info(get_type_name(),$psprintf("prbs_time = %0d (between %0d and %0d)", prbs_time, 0ns, link_config.tRESP1), UVM_HIGH)

                for (int i=0; i < prbs_time/link_config.bit_time; i++) begin

                        drive_fit({NUM_LANES/2 {i[1:0]}});

                end

                next_state = NULL_FLITS;

        endtask : prbs

        task null_flits();

                int null_time;

                null_timestamp = $time;

                reset_lfsr();

                //wait for Requester to send TS1

                while (!(remote_status.current_state >NULL_FLITS))

                        drive_fit({NUM_LANES {1'b0}});

                req_ts1_timestamp = $time;

                //wait at most tRESP2

                null_time_randomization_succeeds : assert (std::randomize(null_time) with {null_time > 0ns && null_time < link_config.tRESP2;});

                `uvm_info(get_type_name(),$psprintf("null time = %0d ", null_time), UVM_HIGH)

                for (int i=0; i

                        drive_fit({NUM_LANES {1'b0}});

                end

                next_state = TS1;

        endtask : null_flits

        task ts1();

                int ts1_fits = 0;

                // Save the timestamp

                ts1_timestamp = $time;

                `uvm_info(get_type_name(), $psprintf("Sending TS1 Sequences"),UVM_MEDIUM)

                //wait for Requester to send NULL FLITs

                while (!(remote_status.current_state>TS1))

                        send_ts1(256); // 16 fits per sequence number, 16 sequence numbers

                next_state = NULL_FLITS_2;

        endtask : ts1

        task null_flits_2();

                int null_flit_count;

                null_flit_count_randomization_succeeds : assert (std::randomize(null_flit_count) with {null_flit_count >= 32 && null_flit_count < 512;});

                //send NULL FLITs

                for (int i=0; i < null_flit_count; i++)

                        drive_flit(128'h0);

                next_state = INITIAL_TRETS;

        endtask : null_flits_2

        function void drive_lanes(input bit[NUM_LANES-1:0] new_value);

                int i;

                bit[NUM_LANES-1:0] lanes_reordered;

                if (local_config.reverse_lanes) begin

                        for (i = 0; i < local_config.width; i= i+1) begin

                                lanes_reordered[i] = new_value[local_config.width-i-1];

                        end

                end else begin

                        lanes_reordered = new_value;

                end

                for (i = 0; i < local_config.width; i= i+1) begin

                        bit set;

                        lane_queues[i].push_back(lanes_reordered[i]  ^ local_config.reverse_polarity[i]);

                        if (local_config.lane_delays[i] <= lane_queues[i].size()) begin

                                set = lane_queues[i].pop_front();

                                vif.TXP[i] = set;

                                vif.TXN[i] = ~set;

                        end

                end

        endfunction : drive_lanes

        task clear_lanes();

                //-- while lane_queues.size >0

                int i;

                bit empty = 1;

                while(empty) begin

                        empty =0;

                        @driver_clk;

                        for (i = 0; i < local_config.width; i= i+1) begin

                                        logic set;

                                if (lane_queues[i].size>0) begin

                                        empty = 1;

                                        set = lane_queues[i].pop_front();

                                        vif.TXP[i] = set;

                                        vif.TXN[i] = ~set;

                                end     else begin

                                        vif.TXP[i] = 1'bz;

                                        vif.TXN[i] = 1'bz;

                                end

                        end

                end

        endtask : clear_lanes

endclass : hmc_responder_driver

`endif // HMC_RESPONDER_DRIVER_SV