veryl-std 0.20.3

A modern hardware description language
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

pub module ecc_decoder #(
    param WIDTH      : u32  = 8                                   ,
    param TYPE       : type = logic<WIDTH>                        ,
    const DATA_WIDTH : u32  = $bits(TYPE)                         ,
    const CHECK_WIDTH: u32  = ecc_pkg::get_check_width(DATA_WIDTH),
    const CODE_WIDTH : u32  = DATA_WIDTH + CHECK_WIDTH            ,
) (
    i_enable   : input  logic            ,
    i_code     : input  logic<CODE_WIDTH>,
    o_data     : output TYPE             ,
    o_corrected: output logic            ,
    o_detected : output logic            ,
) {
    var data     : logic<DATA_WIDTH> ;
    var syndrome : logic<CHECK_WIDTH>;
    var error_pos: logic<DATA_WIDTH> ;
    var corrected: logic             ;
    var detected : logic             ;

    always_comb {
        o_data      = data ^ error_pos;
        o_corrected = corrected;
        o_detected  = detected;
    }

    if CHECK_WIDTH == 5 :g {
        var code  : logic                          <hamming_11_5_pkg::CODE_WIDTH>;
        var result: hamming_11_5_pkg::decode_result                              ;

        always_comb {
            code = i_code as hamming_11_5_pkg::CODE_WIDTH;
            if i_enable {
                syndrome = hamming_11_5_pkg::calc_syndrome(code);
                result   = hamming_11_5_pkg::decode(syndrome, DATA_WIDTH);
            } else {
                syndrome = '0;
                result   = '0;
            }

            data      = code[CHECK_WIDTH+:DATA_WIDTH];
            error_pos = result.error_pos[CHECK_WIDTH+:DATA_WIDTH];
            corrected = result.corrected;
            detected  = result.detected;
        }
    } else if CHECK_WIDTH == 6 {
        var code  : logic                          <hamming_26_6_pkg::CODE_WIDTH>;
        var result: hamming_26_6_pkg::decode_result                              ;

        always_comb {
            code = i_code as hamming_26_6_pkg::CODE_WIDTH;
            if i_enable {
                syndrome = hamming_26_6_pkg::calc_syndrome(code);
                result   = hamming_26_6_pkg::decode(syndrome, DATA_WIDTH);
            } else {
                syndrome = '0;
                result   = '0;
            }

            data      = code[CHECK_WIDTH+:DATA_WIDTH];
            error_pos = result.error_pos[CHECK_WIDTH+:DATA_WIDTH];
            corrected = result.corrected;
            detected  = result.detected;
        }
    } else if CHECK_WIDTH == 7 {
        var code  : logic                          <hamming_57_7_pkg::CODE_WIDTH>;
        var result: hamming_57_7_pkg::decode_result                              ;

        always_comb {
            code = i_code as hamming_57_7_pkg::CODE_WIDTH;
            if i_enable {
                syndrome = hamming_57_7_pkg::calc_syndrome(code);
                result   = hamming_57_7_pkg::decode(syndrome, DATA_WIDTH);
            } else {
                syndrome = '0;
                result   = '0;
            }

            data      = code[CHECK_WIDTH+:DATA_WIDTH];
            error_pos = result.error_pos[CHECK_WIDTH+:DATA_WIDTH];
            corrected = result.corrected;
            detected  = result.detected;
        }
    } else if CHECK_WIDTH == 8 {
        var code  : logic                           <hamming_120_8_pkg::CODE_WIDTH>;
        var result: hamming_120_8_pkg::decode_result                               ;

        always_comb {
            code = i_code as hamming_120_8_pkg::CODE_WIDTH;
            if i_enable {
                syndrome = hamming_120_8_pkg::calc_syndrome(code);
                result   = hamming_120_8_pkg::decode(syndrome, DATA_WIDTH);
            } else {
                syndrome = '0;
                result   = '0;
            }

            data      = code[CHECK_WIDTH+:DATA_WIDTH];
            error_pos = result.error_pos[CHECK_WIDTH+:DATA_WIDTH];
            corrected = result.corrected;
            detected  = result.detected;
        }
    } else if CHECK_WIDTH == 9 {
        var code  : logic                           <hamming_247_9_pkg::CODE_WIDTH>;
        var result: hamming_247_9_pkg::decode_result                               ;

        always_comb {
            code = i_code as hamming_247_9_pkg::CODE_WIDTH;
            if i_enable {
                syndrome = hamming_247_9_pkg::calc_syndrome(code);
                result   = hamming_247_9_pkg::decode(syndrome, DATA_WIDTH);
            } else {
                syndrome = '0;
                result   = '0;
            }

            data      = code[CHECK_WIDTH+:DATA_WIDTH];
            error_pos = result.error_pos[CHECK_WIDTH+:DATA_WIDTH];
            corrected = result.corrected;
            detected  = result.detected;
        }
    } else {
        always_comb {
            data      = '0;
            syndrome  = '0;
            error_pos = '0;
            corrected = false;
            detected  = false;
        }
    }
}