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_DRIVER_BASE_SV

`define HMC_DRIVER_BASE_SV

class hmc_driver_base#(parameter NUM_LANES = 16) extends uvm_driver #(hmc_packet);

        `uvm_analysis_imp_decl(_hmc_frp)

        uvm_analysis_imp_hmc_frp #(hmc_packet, hmc_driver_base#(.NUM_LANES(NUM_LANES))) hmc_frp_port;

        init_state_t next_state = RESET;

        init_state_t state = RESET;

        init_state_t last_state = LINK_UP;

        virtual interface hmc_sr_if #(.NUM_LANES(NUM_LANES)) vif;

        hmc_token_handler token_handler;

        hmc_retry_buffer  retry_buffer;

        hmc_link_status   remote_status;

        //-- The parameters for this link

        hmc_link_config link_config;

        //-- The parameters for this driver

        hmc_local_link_config local_config;

        //-- Packets to send

        hmc_packet packet_queue[$];

        typedef bit lane_queue [$];

        lane_queue lane_queues [NUM_LANES];

        event driver_clk;

        uvm_event start_clear_retry_event;

        // Timestamps for debugging

        int reset_timestamp = 0;

        int prbs_timestamp = 0;

        int null_timestamp = 0;

        int req_ts1_timestamp = 0;

        int ts1_timestamp = 0;

        // Timestamps for controlling packet flow

        int last_packet_timestamp = 0;

        int start_retry_timestamp = 0;

        //-- error propability

        int next_poisoned = 0;

        int     lng_error_prob = 0;

        int     seq_error_prob = 0;

        int     crc_error_prob = 0;

        bit recover_from_power_down = 0;

        // Count retry attempts signalled by the responder (from here)

        int retry_attempts = 0;

        // Count retry attempts from the requester

        int remote_retries_signalled = 0;

        int remote_retries_cleared = 0;

        int local_retries_signalled = 0;

        int local_retries_cleared = 0;

        // Internal state for scramblers

        bit [14:0] lfsr[NUM_LANES-1:0];

        // Internal state for packets

        bit [2:0] seq_num = 1;

        // State for tokens and frp

        bit [7:0] frp_queue [$];

        bit [7:0] last_frp = 0;

        bit [7:0] last_rrp;

        int tokens_to_send = 0;

        int used_tokens = 0;

        int sent_tokens = 0;

        bit [14:0] lfsr_seed[0:15] = {

                                        15'h4D56,

                                        15'h47FF,

                                        15'h75B8,

                                        15'h1E18,

                                        15'h2E10,

                                        15'h3EB2,

                                        15'h4302,

                                        15'h1380,

                                        15'h3EB3,

                                        15'h2769,

                                        15'h4580,

                                        15'h5665,

                                        15'h6318,

                                        15'h6014,

                                        15'h077B,

                                        15'h261F

                        };

        bit [15:8]      ts1_high                = 8'hF0;

        bit [7:4]       ts1_top_lane    = 4'hC;

        bit [7:4]       ts1_bottom_lane = 4'h3;

        bit [7:4]       ts1_middle_lane = 4'h5;

        // Configuration parameters

        bit init_continue;

        bit can_continue;

        `uvm_component_param_utils(hmc_driver_base #(.NUM_LANES(NUM_LANES)))

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

                super.new(name,parent);

        endfunction : new

        function void build_phase(uvm_phase phase);

                super.build_phase(phase);

                vif_found : assert (uvm_config_db#(virtual interface hmc_sr_if#(.NUM_LANES(NUM_LANES)))::get(this, "", "vif",this.vif));

                config_found : assert (uvm_config_db#(hmc_link_config)::get(this, "", "link_config",link_config));

        endfunction : build_phase

        virtual task run_phase(uvm_phase phase);

                super.run_phase(phase);

        endtask : run_phase

        task reset();

                vif.TXP = {$size(vif.TXP) {1'bz}};

                vif.TXN = {$size(vif.TXN) {1'bz}};

                vif.TXPS = 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 clk_gen();

                @(posedge vif.REFCLKP);

                forever begin

                        #link_config.bit_time -> driver_clk;

                end

        endtask : clk_gen

        task send_ts1(int ts1_fits);

                bit [4:0] ts1_seq_num;

                bit [NUM_LANES-1:0] fit_val;

                bit [15:0] ts1_values [NUM_LANES-1:0];

                ts1_values[0]           = {ts1_high, ts1_bottom_lane, 4'h0};

                for (int lane=1; lane < local_config.width-1; lane++)

                        ts1_values[lane]        = {ts1_high, ts1_middle_lane, 4'h0};

                ts1_values[local_config.width-1]        = {ts1_high, ts1_top_lane, 4'h0};

                //Send some (possibly incomplete) TS1 flits

                while (ts1_fits > 0) begin

                        // Cycle through all the sequence numbers

                        for (ts1_seq_num=0; ts1_seq_num < 16 && ts1_fits > 0; ts1_seq_num++) begin

                                // Add the sequence number to the ts1_values

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

                                        ts1_values[i][3:0] = ts1_seq_num;

                                end

                                // Send the fits of the ts1 values

                                for (int fit=0; fit < 16; fit++) begin

                                        for (int lane=0; lane < local_config.width; lane++) begin

                                                fit_val[lane] = ts1_values[lane][fit];

                                        end

                                        if (ts1_fits > 0) begin

                                                drive_fit(fit_val);

                                        end else begin

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

                                        end

                                        ts1_fits = ts1_fits - 1;

                                end

                        end

                end

        endtask : send_ts1

        task initial_trets();

                hmc_packet tret = new();

                //send TRET FLITs

                while (tokens_to_send > 0) begin

                        init_tret_randomization : assert (tret.randomize() with {

                                command == HMC_TRET;

                                poisoned == 0;

                                crc_error == 0;

                                packet_length == 1;

                                duplicate_length == 1;

                                return_token_count <= tokens_to_send && return_token_count > 0;

                                });

                        send_packet(tret);

                        tokens_to_send = tokens_to_send - tret.return_token_count;

                end

                next_state = LINK_UP;

        endtask : initial_trets

        task link_up();

                hmc_packet packet;

                get_packets();

                if (packet_queue.size() > 0 && token_handler.tokens_available(packet_queue[0].packet_length) && (250- retry_buffer.get_buffer_used()) > packet_queue[0].packet_length ) begin

                        packet = packet_queue.pop_front();      //-- send the first packet in the queue

                        if ((next_poisoned < local_config.poisoned_probability))

                                send_poisoned(packet);

                        else

                                send_packet(packet);

                        poisoned_propability_randomisation : assert (std::randomize(next_poisoned) with {next_poisoned > 0 && next_poisoned < 1000;});

                end else if ($time-last_packet_timestamp > local_config.send_pret_time && frp_queue.size() > 0) begin

                        `uvm_info(get_type_name(),$psprintf("sending pret, frp_queue size = %0d", frp_queue.size()), UVM_HIGH)

                        send_pret();

                end else if ($time-last_packet_timestamp > local_config.send_tret_time && (used_tokens - sent_tokens) > 0 &&(250- retry_buffer.get_buffer_used()) >1) begin

                        `uvm_info(get_type_name(),$psprintf("sending tret, (<%0d)", used_tokens-sent_tokens), UVM_HIGH)

                        send_tret();

                end else begin

                        drive_flit(128'h0);

                end

                // From here on, there are no packets being driven.  This is just logic to decide the next state.

                //-- Handle error_abort_mode on remote link

                if (remote_status.get_error_abort_mode() && $time() - start_retry_timestamp > link_config.retry_timeout_period  ) begin

                        next_state = START_RETRY_INIT;

                end

        endtask : link_up

        task start_retry_init();        //-- send start retry IRTRYs

                start_retry_timestamp = $time;

                local_retries_signalled = local_retries_signalled + 1;

                `uvm_info(get_type_name(),$psprintf("sending start retry packets"), UVM_MEDIUM)

                //send IRTRY FLITs

                for (int i=0; i < local_config.irtry_flit_count_to_send; i++)

                        send_irtry_start();

                next_state = LINK_UP;

        endtask : start_retry_init

        task clear_retry(); //-- send clear error abort mode IRTRYs

                local_retries_cleared = local_retries_cleared + 1;

                //send IRTRY FLITs

                for (int i=0; i < local_config.irtry_flit_count_to_send; i++)

                        send_irtry_clear();

                next_state = SEND_RETRY_PACKETS;

        endtask : clear_retry

        task send_retry_packets();

                hmc_packet packet;

                int spacer_flits;

                packet = retry_buffer.get_retry_packet();

                while (packet != null) begin

                        spacer_flits_randomization_succeeds : assert (std::randomize(spacer_flits) with {spacer_flits >= 0 && spacer_flits < 10;});

                        for (int i=0; i

                                drive_flit(128'h0);

                        end

                        retry_send_packet(packet);

                        packet = retry_buffer.get_retry_packet();

                end

                next_state = LINK_UP;

        endtask : send_retry_packets

        task get_packets();

                hmc_packet packet;

                if( seq_item_port.has_do_available() ) begin

                        if( packet_queue.size() == 0) begin

                                seq_item_port.get_next_item(packet);

                                packet_queue.push_back(packet);

                                seq_item_port.item_done();

                        end

                end

        endtask : get_packets

        task send_irtry_start();

                send_irtry(1,0);

        endtask : send_irtry_start

        task send_irtry_clear();

                send_irtry(0,1);

        endtask : send_irtry_clear

        task send_irtry(input bit start, input bit clear);

                hmc_packet irtry = new();

                irtry_randomization: assert (irtry.randomize() with {

                        command == HMC_IRTRY;

                        packet_length == 1;

                        duplicate_length == 1;

                        start_retry == start;

                        clear_error_abort == clear;

                });

                send_packet(irtry);

        endtask : send_irtry

        task send_tret();

                hmc_packet tret = new();

                tret_randomization: assert (tret.randomize() with {

                        command == HMC_TRET;

                        packet_length == 1;

                        duplicate_length == 1;

                });

                send_packet(tret);

        endtask : send_tret

        task send_pret();

                hmc_packet pret = new();

                pret_randomization: assert (pret.randomize() with {

                        command == HMC_PRET;

                        packet_length == 1;

                        duplicate_length == 1;

                });

                send_packet(pret);

        endtask : send_pret

        task send_poisoned(input hmc_packet pkt);

                hmc_packet poisoned = new pkt; //-- copy the pkt into a new one

                `uvm_info(get_type_name(),$psprintf("Poisoning Packet with command %s and tag %d", poisoned.command.name(), poisoned.tag),UVM_NONE)

                poisoned.poisoned = 1;

                send_packet(poisoned);

                packet_queue.push_back(pkt);//-- resent the packet later

        endtask : send_poisoned

        task send_packet(input hmc_packet pkt);

                int packet_frp;

                bit [31:0] crc;

                int bit_pos;

                int tok_cnt;

                // Save packet in Retry buffer if not IRTRY, NULL, or PRET

                // Tokens and Sequence numbers are saved in the retry buffer.

                if (pkt.command == HMC_IRTRY ||

                        pkt.command == HMC_NULL ||

                        pkt.command == HMC_PRET) begin

                        packet_frp = 0;

                        pkt.sequence_number = 0;

                        retry_send_packet(pkt);

                end else begin

                        pkt.sequence_number = seq_num;

                        if (state != INITIAL_TRETS) begin

                                if (used_tokens - sent_tokens > 0) begin

                                        // Always send tokens with TRETs

                                        if (pkt.command == HMC_TRET)

                                                tok_cnd_tret_randomization : assert (std::randomize(tok_cnt) with {(pkt.command == HMC_TRET && tok_cnt > 0)  && tok_cnt < 32 && tok_cnt <= (used_tokens - sent_tokens);});

                                        else

                                                tok_cnt_randomization_succeeds : assert (std::randomize(tok_cnt) with {(tok_cnt >= 0) && tok_cnt < 32 && tok_cnt <= (used_tokens - sent_tokens);});

                                        pkt.return_token_count = tok_cnt;

                                end else begin

                                        pkt.return_token_count = 0;

                                end

                        end

                        packet_frp = retry_buffer.add_packet(pkt);

                        if(packet_frp != -1)begin

                                seq_num++;

                                if (state != INITIAL_TRETS) begin

                                        sent_tokens += pkt.return_token_count;

                                end

                                // From now on, it's equivalent to retry

                                `uvm_info(get_type_name(), $psprintf("Sending CDM  %s with TRETS %d", pkt.command.name(), pkt.return_token_count), UVM_HIGH)

                                retry_send_packet(pkt);

                        end

                end

        endtask : send_packet

        task retry_send_packet(input hmc_packet pkt);

                bit [31:0] crc;

                int bit_pos;

                int bit_error;

                int error_type;

                int rrp_to_send;

                int pkt_lng;

                bit [2:0]seq_number;

                // Don't change the stored packet (except to clear the CRC error flag)

                hmc_packet copy = new pkt;

                // Return retry pointers are not saved.

                // Skip some retry pointers

                rrp_to_send_randomization_succeeds : assert (std::randomize(rrp_to_send) with {rrp_to_send >= 0 && rrp_to_send <= frp_queue.size();});

                if (rrp_to_send == 0) begin

                        copy.return_retry_pointer = last_rrp;

                end else begin

                        for (int i=0;i

                                copy.return_retry_pointer = frp_queue.pop_front();

                                `uvm_info(get_type_name(),$psprintf("popped %0d for frp in %s", copy.return_retry_pointer, copy.command.name()),UVM_HIGH)

                        end

                end

                last_rrp = copy.return_retry_pointer;

                //-- ERROR INJECTION

                //-- adding sequence error

                error_type_seq_error_randomization : assert (std::randomize(seq_error_prob) with {seq_error_prob > 0 && seq_error_prob < 1000;});

                if (seq_error_prob < local_config.seq_error_probability) begin

                                randcase

                                        1:      copy.sequence_number = copy.sequence_number + 1;

                                        1:      copy.sequence_number = copy.sequence_number - 1;

                                        1:      begin

                                                        random_SEQ_succeeds : assert(

                                                                        std::randomize(seq_number) with { seq_number !=copy.sequence_number;});

                                                        copy.sequence_number = seq_number;

                                                end

                                endcase

                                `uvm_info(get_type_name(),$psprintf("injecting SEQ error in CMD %s and FRP %d",copy.command.name(), copy.forward_retry_pointer), UVM_NONE)

                end

                //-- inserting Length Error

                error_type_lng_error_randomization : assert (std::randomize(lng_error_prob) with {lng_error_prob > 0 && lng_error_prob < 1000;});

                if (lng_error_prob < local_config.lng_error_probability) begin

                        randcase

                                1:      copy.packet_length = copy.packet_length + 1;

                                1:      copy.packet_length = copy.packet_length - 1;

                                1:      copy.duplicate_length = copy.duplicate_length + 1;

                                1:      copy.duplicate_length = copy.duplicate_length - 1;

                                1:      begin   random_LNG_succeeds : assert(

                                                                std::randomize(pkt_lng) with {pkt_lng >= 0 && pkt_lng < 16  && pkt_lng !=copy.packet_length;});

                                                        copy.packet_length = pkt_lng;

                                        end

                                1:      begin   random_DLN_succeeds : assert(

                                                                std::randomize(pkt_lng) with {pkt_lng >= 0 && pkt_lng < 16  && pkt_lng !=copy.duplicate_length;});

                                                        copy.duplicate_length = pkt_lng;

                                        end

                        endcase

                end

                crc = copy.calculate_crc(); //-- calculate crc for packet with valid tail

                //-- poisoning packets

                if (copy.poisoned) begin

                        `uvm_info(get_type_name(),$psprintf("XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX poisoning packet with CRC %0x and CMD %s and TAG %d", ~crc, copy.command.name(), copy.tag),UVM_LOW)

                        crc = ~crc;

                end

                //-- inserting CRC error

                error_type_crc_error_randomization : assert (std::randomize(crc_error_prob) with {crc_error_prob > 0 && crc_error_prob < 1000;});

                if (crc_error_prob < local_config.crc_error_probability * copy.packet_length) begin //-- increase the crc error probability for longer packets

                        int clear_crc_error;

                        crc_bit_error_randomization_succeeds : assert (std::randomize(bit_pos) with {bit_pos >= 0 && bit_pos < 32;});

                        `uvm_info(get_type_name(),$psprintf("inserting crc error at %0x", bit_pos),UVM_LOW)

                        crc[bit_pos] = !crc[bit_pos];

                        clear_crc_error_randomization_succeeds : assert (std::randomize(clear_crc_error) with {clear_crc_error >= 0 && clear_crc_error < 3;});

                        if (clear_crc_error == 1)

                                pkt.crc_error = 0;

                end

                copy.packet_crc = crc;

                drive_tx_packet(copy);

        endtask : retry_send_packet

        task drive_fit(input bit[NUM_LANES-1:0] new_value);

                if (link_config.scramblers_enabled) begin

                        drive_lanes(get_scrambler_value()^new_value);

                end else begin

                        drive_lanes(new_value);

                end

                @driver_clk;

                step_scramblers();

        endtask : drive_fit

        task drive_flit(input bit [127:0] flit);

                int i;

                bit [15:0] fits [16];

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

                        fits[i/local_config.width][i%local_config.width] = flit[i];

                for (int i=0; i<128/local_config.width;i++) begin

                        drive_fit(fits[i]);

                end

        endtask : drive_flit

        task drive_tx_packet(input hmc_packet pkt);

                bit bitstream[];

                bit [127:0] flits [9]; // Max packet size is 9 flits

                bit [127:0] curr_flit;

                int i;

                int bitcount;

                bitcount = pkt.pack(bitstream);

                for (int i=0; i

                        flits[i/128][i%128] = bitstream[i];

                for (int i=0; i

                        drive_flit(flits[i]);

                end

                last_packet_timestamp = $time;

        endtask : drive_tx_packet

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

                `uvm_info(get_type_name(),$psprintf("called virtual function drive_lanes!"), UVM_HIGH)

        endfunction : drive_lanes

        function void reset_lfsr();

                int i;

                for (i = 0; i < NUM_LANES; i= i+1) begin

                        if (local_config.reverse_lanes == 1)

                                lfsr[i] = lfsr_seed[NUM_LANES-1-i];

                        else

                                lfsr[i] = lfsr_seed[i];

                end

        endfunction : reset_lfsr

        function void step_scramblers();

                int i;

                if (link_config.scramblers_enabled) begin

                        for (i = 0; i < NUM_LANES; i= i+1) begin

                                lfsr[i] = {lfsr[i][1]^lfsr[i][0], lfsr[i][14:1]};

                        end

                end

        endfunction : step_scramblers

        function bit[NUM_LANES-1:0] get_scrambler_value();

                int i;

                if (link_config.scramblers_enabled) begin

                        for (i = 0; i < NUM_LANES; i= i+1) begin

                                get_scrambler_value[i] = lfsr[i][0];

                        end

                end else begin

                        for (i = 0; i < NUM_LANES; i= i+1) begin

                                get_scrambler_value = {NUM_LANES {1'b0}};

                        end

                end

        endfunction : get_scrambler_value

        // I2C or JTAG would configure the HMC during reset

        function void set_init_continue();

                tb_respects_tINIT : assert (can_continue);

                init_continue = 1;

        endfunction : set_init_continue

        virtual function void write_hmc_frp(input hmc_packet pkt);

                bit [7:0] frp;

                int random_wait;

                `uvm_info(get_type_name(),$psprintf("hmc_frp: %s with FRP %0d & size %0d",pkt.command.name(), pkt.forward_retry_pointer, pkt.packet_length),UVM_HIGH)

                // IRTRY and PRET do not have valid frp fields

                if (pkt.command != HMC_IRTRY && pkt.command != HMC_PRET) begin

                        frp = pkt.forward_retry_pointer;

                        if (frp != last_frp) begin

                                frp_queue.push_back(frp);

                                last_frp = frp;

                        end

                end

                if (pkt.get_command_type != HMC_FLOW_TYPE && !pkt.poisoned ) begin

                        used_tokens_does_not_overflow : assert ( used_tokens < used_tokens + pkt.packet_length);

                        used_tokens = used_tokens + pkt.packet_length;

                end

        endfunction : write_hmc_frp

endclass : hmc_driver_base

`endif // HMC_DRIVER_BASE_SV