Arith.bsv
上传用户:aoptech
上传日期:2014-09-22
资源大小:784k
文件大小:22k
源码类别:

3G开发

开发平台:

Others

  1. //----------------------------------------------------------------------//
  2. // The MIT License 
  3. // 
  4. // Copyright (c) 2007 Alfred Man Cheuk Ng, mcn02@mit.edu 
  5. // 
  6. // Permission is hereby granted, free of charge, to any person 
  7. // obtaining a copy of this software and associated documentation 
  8. // files (the "Software"), to deal in the Software without 
  9. // restriction, including without limitation the rights to use,
  10. // copy, modify, merge, publish, distribute, sublicense, and/or sell
  11. // copies of the Software, and to permit persons to whom the
  12. // Software is furnished to do so, subject to the following conditions:
  13. // 
  14. // The above copyright notice and this permission notice shall be
  15. // included in all copies or substantial portions of the Software.
  16. // 
  17. // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  18. // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
  19. // OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  20. // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
  21. // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  22. // WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  23. // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  24. // OTHER DEALINGS IN THE SOFTWARE.
  25. //----------------------------------------------------------------------//
  26. //**********************************************************************
  27. // Galois field arithmetic
  28. //----------------------------------------------------------------------
  29. // $Id: Arith.bsv
  30. //
  31.  
  32. import Types::*;
  33. // -----------------------------------------------------------
  34. // The primitive polynomial defines the Galois field in which 
  35. // Reed-Solomon decoder operates, and all the following   
  36. // arithmetic operations are defined under.  Changing this    
  37. // value cause the whole Reed-Solomon decoder to operate   
  38. // under the new primitive polynomial.
  39. // primitive_polynomial[i] = Coefficient of x**i for i = 0:7
  40. // -----------------------------------------------------------
  41. Byte primitive_polynomial = 8'b00011101;
  42. Byte    n_param              = 8'd255;
  43. Byte    t_param              = 8'd16;
  44. // -----------------------------------------------------------
  45. (* noinline *) 
  46. function Byte gf_mult (Byte left, Byte right);
  47.    Word result = 16'b0;
  48. //    for (int i = 0; i < 8; i = i + 1)
  49. //       for (int j = 0; j < 8; j = j + 1)
  50. //   result [i + j] = result [i + j] ^ (left [j] & right [i]);
  51. //    for (int i = 15; i > 7; i = i - 1)
  52. //       if (result [i] == 1'b1)
  53. //   result = result ^ ((zeroExtend (primitive_polynomial)) << (i - 8));
  54.          
  55.    result [0] = result [0] ^ (left [0] & right [0]);
  56.    result [1] = result [1] ^ (left [1] & right [0]) ^ (left [0] & right [1]);
  57.    result [2] = result [2] ^ (left [2] & right [0]) ^ (left [1] & right [1]) ^ (left [0] & right [2]);
  58.    result [3] = result [3] ^ (left [3] & right [0]) ^ (left [2] & right [1]) ^ (left [1] & right [2]) ^ (left [0] & right [3]);
  59.    result [4] = result [4] ^ (left [4] & right [0]) ^ (left [3] & right [1]) ^ (left [2] & right [2]) ^ (left [1] & right [3]) ^ (left [0] & right [4]);
  60.    result [5] = result [5] ^ (left [5] & right [0]) ^ (left [4] & right [1]) ^ (left [3] & right [2]) ^ (left [2] & right [3]) ^ (left [1] & right [4]) ^ (left [0] & right [5]);
  61.    result [6] = result [6] ^ (left [6] & right [0]) ^ (left [5] & right [1]) ^ (left [4] & right [2]) ^ (left [3] & right [3]) ^ (left [2] & right [4]) ^ (left [1] & right [5]) ^ (left [0] & right [6]);
  62.    result [7] = result [7] ^ (left [7] & right [0]) ^ (left [6] & right [1]) ^ (left [5] & right [2]) ^ (left [4] & right [3]) ^ (left [3] & right [4]) ^ (left [2] & right [5]) ^ (left [1] & right [6]) ^ (left [0] & right [7]);
  63.    result [8] = result [8] ^ (left [7] & right [1]) ^ (left [6] & right [2]) ^ (left [5] & right [3]) ^ (left [4] & right [4]) ^ (left [3] & right [5]) ^ (left [2] & right [6]) ^ (left [1] & right [7]);
  64.    result [9] = result [9] ^ (left [7] & right [2]) ^ (left [6] & right [3]) ^ (left [5] & right [4]) ^ (left [4] & right [5]) ^ (left [3] & right [6]) ^ (left [2] & right [7]);
  65.    result [10] = result [10] ^ (left [7] & right [3]) ^ (left [6] & right [4]) ^ (left [5] & right [5]) ^ (left [4] & right [6]) ^ (left [3] & right [7]);
  66.    result [11] = result [11] ^ (left [7] & right [4]) ^ (left [6] & right [5]) ^ (left [5] & right [6]) ^ (left [4] & right [7]);
  67.    result [12] = result [12] ^ (left [7] & right [5]) ^ (left [6] & right [6]) ^ (left [5] & right [7]);
  68.    result [13] = result [13] ^ (left [7] & right [6]) ^ (left [6] & right [7]);
  69.    result [14] = result [14] ^ (left [7] & right [7]);
  70.    if (result [14] == 1'b1)
  71.       result = result ^ ((zeroExtend (primitive_polynomial)) << (6));
  72.    if (result [13] == 1'b1)
  73.       result = result ^ ((zeroExtend (primitive_polynomial)) << (5));
  74.    if (result [12] == 1'b1)
  75.       result = result ^ ((zeroExtend (primitive_polynomial)) << (4));
  76.    if (result [11] == 1'b1)
  77.       result = result ^ ((zeroExtend (primitive_polynomial)) << (3));
  78.    if (result [10] == 1'b1)
  79.       result = result ^ ((zeroExtend (primitive_polynomial)) << (2));
  80.    if (result [9] == 1'b1)
  81.       result = result ^ ((zeroExtend (primitive_polynomial)) << (1));
  82.    if (result [8] == 1'b1)
  83.       result = result ^ ((zeroExtend (primitive_polynomial)) << (0));
  84.    return (result [7:0]);
  85. endfunction
  86. // -----------------------------------------------------------
  87. function Byte gf_add (Byte left, Byte right);
  88.    return (left ^ right);
  89. endfunction
  90. // -----------------------------------------------------------
  91. // function Byte const_alpha_n (int n);
  92. //    //if (n == 0)
  93. //    //   return 1;
  94. //    Byte a_n = 2;
  95. //    for (int i = 1; i < n; i = i + 1)
  96. //       a_n = gf_mult (a_n, 2);
  97. //    return a_n;
  98. // endfunction
  99. function Byte gf_inv (Byte a);
  100.    case (a) matches
  101.         0 : return         2;
  102.         1 : return         1;
  103.         2 : return       142;
  104.         3 : return       244;
  105.         4 : return        71;
  106.         5 : return       167;
  107.         6 : return       122;
  108.         7 : return       186;
  109.         8 : return       173;
  110.         9 : return       157;
  111.        10 : return       221;
  112.        11 : return       152;
  113.        12 : return        61;
  114.        13 : return       170;
  115.        14 : return        93;
  116.        15 : return       150;
  117.        16 : return       216;
  118.        17 : return       114;
  119.        18 : return       192;
  120.        19 : return        88;
  121.        20 : return       224;
  122.        21 : return        62;
  123.        22 : return        76;
  124.        23 : return       102;
  125.        24 : return       144;
  126.        25 : return       222;
  127.        26 : return        85;
  128.        27 : return       128;
  129.        28 : return       160;
  130.        29 : return       131;
  131.        30 : return        75;
  132.        31 : return        42;
  133.        32 : return       108;
  134.        33 : return       237;
  135.        34 : return        57;
  136.        35 : return        81;
  137.        36 : return        96;
  138.        37 : return        86;
  139.        38 : return        44;
  140.        39 : return       138;
  141.        40 : return       112;
  142.        41 : return       208;
  143.        42 : return        31;
  144.        43 : return        74;
  145.        44 : return        38;
  146.        45 : return       139;
  147.        46 : return        51;
  148.        47 : return       110;
  149.        48 : return        72;
  150.        49 : return       137;
  151.        50 : return       111;
  152.        51 : return        46;
  153.        52 : return       164;
  154.        53 : return       195;
  155.        54 : return        64;
  156.        55 : return        94;
  157.        56 : return        80;
  158.        57 : return        34;
  159.        58 : return       207;
  160.        59 : return       169;
  161.        60 : return       171;
  162.        61 : return        12;
  163.        62 : return        21;
  164.        63 : return       225;
  165.        64 : return        54;
  166.        65 : return        95;
  167.        66 : return       248;
  168.        67 : return       213;
  169.        68 : return       146;
  170.        69 : return        78;
  171.        70 : return       166;
  172.        71 : return         4;
  173.        72 : return        48;
  174.        73 : return       136;
  175.        74 : return        43;
  176.        75 : return        30;
  177.        76 : return        22;
  178.        77 : return       103;
  179.        78 : return        69;
  180.        79 : return       147;
  181.        80 : return        56;
  182.        81 : return        35;
  183.        82 : return       104;
  184.        83 : return       140;
  185.        84 : return       129;
  186.        85 : return        26;
  187.        86 : return        37;
  188.        87 : return        97;
  189.        88 : return        19;
  190.        89 : return       193;
  191.        90 : return       203;
  192.        91 : return        99;
  193.        92 : return       151;
  194.        93 : return        14;
  195.        94 : return        55;
  196.        95 : return        65;
  197.        96 : return        36;
  198.        97 : return        87;
  199.        98 : return       202;
  200.        99 : return        91;
  201.       100 : return       185;
  202.       101 : return       196;
  203.       102 : return        23;
  204.       103 : return        77;
  205.       104 : return        82;
  206.       105 : return       141;
  207.       106 : return       239;
  208.       107 : return       179;
  209.       108 : return        32;
  210.       109 : return       236;
  211.       110 : return        47;
  212.       111 : return        50;
  213.       112 : return        40;
  214.       113 : return       209;
  215.       114 : return        17;
  216.       115 : return       217;
  217.       116 : return       233;
  218.       117 : return       251;
  219.       118 : return       218;
  220.       119 : return       121;
  221.       120 : return       219;
  222.       121 : return       119;
  223.       122 : return         6;
  224.       123 : return       187;
  225.       124 : return       132;
  226.       125 : return       205;
  227.       126 : return       254;
  228.       127 : return       252;
  229.       128 : return        27;
  230.       129 : return        84;
  231.       130 : return       161;
  232.       131 : return        29;
  233.       132 : return       124;
  234.       133 : return       204;
  235.       134 : return       228;
  236.       135 : return       176;
  237.       136 : return        73;
  238.       137 : return        49;
  239.       138 : return        39;
  240.       139 : return        45;
  241.       140 : return        83;
  242.       141 : return       105;
  243.       142 : return         2;
  244.       143 : return       245;
  245.       144 : return        24;
  246.       145 : return       223;
  247.       146 : return        68;
  248.       147 : return        79;
  249.       148 : return       155;
  250.       149 : return       188;
  251.       150 : return        15;
  252.       151 : return        92;
  253.       152 : return        11;
  254.       153 : return       220;
  255.       154 : return       189;
  256.       155 : return       148;
  257.       156 : return       172;
  258.       157 : return         9;
  259.       158 : return       199;
  260.       159 : return       162;
  261.       160 : return        28;
  262.       161 : return       130;
  263.       162 : return       159;
  264.       163 : return       198;
  265.       164 : return        52;
  266.       165 : return       194;
  267.       166 : return        70;
  268.       167 : return         5;
  269.       168 : return       206;
  270.       169 : return        59;
  271.       170 : return        13;
  272.       171 : return        60;
  273.       172 : return       156;
  274.       173 : return         8;
  275.       174 : return       190;
  276.       175 : return       183;
  277.       176 : return       135;
  278.       177 : return       229;
  279.       178 : return       238;
  280.       179 : return       107;
  281.       180 : return       235;
  282.       181 : return       242;
  283.       182 : return       191;
  284.       183 : return       175;
  285.       184 : return       197;
  286.       185 : return       100;
  287.       186 : return         7;
  288.       187 : return       123;
  289.       188 : return       149;
  290.       189 : return       154;
  291.       190 : return       174;
  292.       191 : return       182;
  293.       192 : return        18;
  294.       193 : return        89;
  295.       194 : return       165;
  296.       195 : return        53;
  297.       196 : return       101;
  298.       197 : return       184;
  299.       198 : return       163;
  300.       199 : return       158;
  301.       200 : return       210;
  302.       201 : return       247;
  303.       202 : return        98;
  304.       203 : return        90;
  305.       204 : return       133;
  306.       205 : return       125;
  307.       206 : return       168;
  308.       207 : return        58;
  309.       208 : return        41;
  310.       209 : return       113;
  311.       210 : return       200;
  312.       211 : return       246;
  313.       212 : return       249;
  314.       213 : return        67;
  315.       214 : return       215;
  316.       215 : return       214;
  317.       216 : return        16;
  318.       217 : return       115;
  319.       218 : return       118;
  320.       219 : return       120;
  321.       220 : return       153;
  322.       221 : return        10;
  323.       222 : return        25;
  324.       223 : return       145;
  325.       224 : return        20;
  326.       225 : return        63;
  327.       226 : return       230;
  328.       227 : return       240;
  329.       228 : return       134;
  330.       229 : return       177;
  331.       230 : return       226;
  332.       231 : return       241;
  333.       232 : return       250;
  334.       233 : return       116;
  335.       234 : return       243;
  336.       235 : return       180;
  337.       236 : return       109;
  338.       237 : return        33;
  339.       238 : return       178;
  340.       239 : return       106;
  341.       240 : return       227;
  342.       241 : return       231;
  343.       242 : return       181;
  344.       243 : return       234;
  345.       244 : return         3;
  346.       245 : return       143;
  347.       246 : return       211;
  348.       247 : return       201;
  349.       248 : return        66;
  350.       249 : return       212;
  351.       250 : return       232;
  352.       251 : return       117;
  353.       252 : return       127;
  354.       253 : return       255;
  355.       254 : return       126;
  356.       255 : return       253;
  357.    endcase
  358.          
  359. endfunction
  360. function Byte alpha_chien (Byte a);
  361.    case (a) matches
  362.         1 : return         2;
  363.         2 : return         4;
  364.         3 : return         8;
  365.         4 : return        16;
  366.         5 : return        32;
  367.         6 : return        64;
  368.         7 : return       128;
  369.         8 : return        29;
  370.         9 : return        58;
  371.        10 : return       116;
  372.        11 : return       232;
  373.        12 : return       205;
  374.        13 : return       135;
  375.        14 : return        19;
  376.        15 : return        38;
  377.        16 : return        76;
  378.        17 : return       152;
  379.        18 : return        45;
  380.        19 : return        90;
  381.        20 : return       180;
  382.        21 : return       117;
  383.        22 : return       234;
  384.        23 : return       201;
  385.        24 : return       143;
  386.        25 : return         3;
  387.        26 : return         6;
  388.        27 : return        12;
  389.        28 : return        24;
  390.        29 : return        48;
  391.        30 : return        96;
  392.        31 : return       192;
  393.        32 : return       157;
  394.    endcase
  395. endfunction
  396. function Byte alpha_inv_chien (Byte a);
  397.    case (a) matches
  398.         0 : return         1;
  399.         1 : return       142;
  400.         2 : return        71;
  401.         3 : return       173;
  402.         4 : return       216;
  403.         5 : return       108;
  404.         6 : return        54;
  405.         7 : return        27;
  406.         8 : return       131;
  407.         9 : return       207;
  408.        10 : return       233;
  409.        11 : return       250;
  410.        12 : return       125;
  411.        13 : return       176;
  412.        14 : return        88;
  413.        15 : return        44;
  414.        16 : return        22;
  415.        17 : return        11;
  416.        18 : return       139;
  417.        19 : return       203;
  418.        20 : return       235;
  419.        21 : return       251;
  420.        22 : return       243;
  421.        23 : return       247;
  422.        24 : return       245;
  423.        25 : return       244;
  424.        26 : return       122;
  425.        27 : return        61;
  426.        28 : return       144;
  427.        29 : return        72;
  428.        30 : return        36;
  429.        31 : return        18;
  430.        32 : return         9;
  431.        33 : return       138;
  432.        34 : return        69;
  433.        35 : return       172;
  434.        36 : return        86;
  435.        37 : return        43;
  436.        38 : return       155;
  437.        39 : return       195;
  438.        40 : return       239;
  439.        41 : return       249;
  440.        42 : return       242;
  441.        43 : return       121;
  442.        44 : return       178;
  443.        45 : return        89;
  444.        46 : return       162;
  445.        47 : return        81;
  446.        48 : return       166;
  447.        49 : return        83;
  448.        50 : return       167;
  449.        51 : return       221;
  450.        52 : return       224;
  451.        53 : return       112;
  452.        54 : return        56;
  453.        55 : return        28;
  454.        56 : return        14;
  455.        57 : return         7;
  456.        58 : return       141;
  457.        59 : return       200;
  458.        60 : return       100;
  459.        61 : return        50;
  460.        62 : return        25;
  461.        63 : return       130;
  462.        64 : return        65;
  463.        65 : return       174;
  464.        66 : return        87;
  465.        67 : return       165;
  466.        68 : return       220;
  467.        69 : return       110;
  468.        70 : return        55;
  469.        71 : return       149;
  470.        72 : return       196;
  471.        73 : return        98;
  472.        74 : return        49;
  473.        75 : return       150;
  474.        76 : return        75;
  475.        77 : return       171;
  476.        78 : return       219;
  477.        79 : return       227;
  478.        80 : return       255;
  479.        81 : return       241;
  480.        82 : return       246;
  481.        83 : return       123;
  482.        84 : return       179;
  483.        85 : return       215;
  484.        86 : return       229;
  485.        87 : return       252;
  486.        88 : return       126;
  487.        89 : return        63;
  488.        90 : return       145;
  489.        91 : return       198;
  490.        92 : return        99;
  491.        93 : return       191;
  492.        94 : return       209;
  493.        95 : return       230;
  494.        96 : return       115;
  495.        97 : return       183;
  496.        98 : return       213;
  497.        99 : return       228;
  498.       100 : return       114;
  499.       101 : return        57;
  500.       102 : return       146;
  501.       103 : return        73;
  502.       104 : return       170;
  503.       105 : return        85;
  504.       106 : return       164;
  505.       107 : return        82;
  506.       108 : return        41;
  507.       109 : return       154;
  508.       110 : return        77;
  509.       111 : return       168;
  510.       112 : return        84;
  511.       113 : return        42;
  512.       114 : return        21;
  513.       115 : return       132;
  514.       116 : return        66;
  515.       117 : return        33;
  516.       118 : return       158;
  517.       119 : return        79;
  518.       120 : return       169;
  519.       121 : return       218;
  520.       122 : return       109;
  521.       123 : return       184;
  522.       124 : return        92;
  523.       125 : return        46;
  524.       126 : return        23;
  525.       127 : return       133;
  526.       128 : return       204;
  527.       129 : return       102;
  528.       130 : return        51;
  529.       131 : return       151;
  530.       132 : return       197;
  531.       133 : return       236;
  532.       134 : return       118;
  533.       135 : return        59;
  534.       136 : return       147;
  535.       137 : return       199;
  536.       138 : return       237;
  537.       139 : return       248;
  538.       140 : return       124;
  539.       141 : return        62;
  540.       142 : return        31;
  541.       143 : return       129;
  542.       144 : return       206;
  543.       145 : return       103;
  544.       146 : return       189;
  545.       147 : return       208;
  546.       148 : return       104;
  547.       149 : return        52;
  548.       150 : return        26;
  549.       151 : return        13;
  550.       152 : return       136;
  551.       153 : return        68;
  552.       154 : return        34;
  553.       155 : return        17;
  554.       156 : return       134;
  555.       157 : return        67;
  556.       158 : return       175;
  557.       159 : return       217;
  558.       160 : return       226;
  559.       161 : return       113;
  560.       162 : return       182;
  561.       163 : return        91;
  562.       164 : return       163;
  563.       165 : return       223;
  564.       166 : return       225;
  565.       167 : return       254;
  566.       168 : return       127;
  567.       169 : return       177;
  568.       170 : return       214;
  569.       171 : return       107;
  570.       172 : return       187;
  571.       173 : return       211;
  572.       174 : return       231;
  573.       175 : return       253;
  574.       176 : return       240;
  575.       177 : return       120;
  576.       178 : return        60;
  577.       179 : return        30;
  578.       180 : return        15;
  579.       181 : return       137;
  580.       182 : return       202;
  581.       183 : return       101;
  582.       184 : return       188;
  583.       185 : return        94;
  584.       186 : return        47;
  585.       187 : return       153;
  586.       188 : return       194;
  587.       189 : return        97;
  588.       190 : return       190;
  589.       191 : return        95;
  590.       192 : return       161;
  591.       193 : return       222;
  592.       194 : return       111;
  593.       195 : return       185;
  594.       196 : return       210;
  595.       197 : return       105;
  596.       198 : return       186;
  597.       199 : return        93;
  598.       200 : return       160;
  599.       201 : return        80;
  600.       202 : return        40;
  601.       203 : return        20;
  602.       204 : return        10;
  603.       205 : return         5;
  604.       206 : return       140;
  605.       207 : return        70;
  606.       208 : return        35;
  607.       209 : return       159;
  608.       210 : return       193;
  609.       211 : return       238;
  610.       212 : return       119;
  611.       213 : return       181;
  612.       214 : return       212;
  613.       215 : return       106;
  614.       216 : return        53;
  615.       217 : return       148;
  616.       218 : return        74;
  617.       219 : return        37;
  618.       220 : return       156;
  619.       221 : return        78;
  620.       222 : return        39;
  621.       223 : return       157;
  622.       224 : return       192;
  623.       225 : return        96;
  624.       226 : return        48;
  625.       227 : return        24;
  626.       228 : return        12;
  627.       229 : return         6;
  628.       230 : return         3;
  629.       231 : return       143;
  630.       232 : return       201;
  631.       233 : return       234;
  632.       234 : return       117;
  633.       235 : return       180;
  634.       236 : return        90;
  635.       237 : return        45;
  636.       238 : return       152;
  637.       239 : return        76;
  638.       240 : return        38;
  639.       241 : return        19;
  640.       242 : return       135;
  641.       243 : return       205;
  642.       244 : return       232;
  643.       245 : return       116;
  644.       246 : return        58;
  645.       247 : return        29;
  646.       248 : return       128;
  647.       249 : return        64;
  648.       250 : return        32;
  649.       251 : return        16;
  650.       252 : return         8;
  651.       253 : return         4;
  652.       254 : return         2;
  653.    endcase
  654. endfunction