##########################################################################                                                              ########  distances.py                                                ########                                                              ########  This file is part of the turbo decoder IP core project      ########  http://www.opencores.org/projects/turbocodes/               ########                                                              ########  Author(s):                                                  ########      - David Brochart(dbrochart@opencores.org)               ########                                                              ########  All additional information is available in the README.txt   ########  file.                                                       ########                                                              ##############################################################################                                                              ######## Copyright (C) 2005 Authors                                   ########                                                              ######## This source file may be used and distributed without         ######## restriction provided that this copyright statement is not    ######## removed from the file and that any derivative work contains  ######## the original copyright notice and the associated disclaimer. ########                                                              ######## 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 2.1 of the License, or (at your option) any   ######## later version.                                               ########                                                              ######## This source 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; if not, download it   ######## from http://www.opencores.org/lgpl.shtml                     ########                                                              ##########################################################################from misc import opposite, adder, registerfrom myhdl import Signal, intbv, always_comb, instancesdef partDistance(a, b, y1, y2, res, ref = intbv(0, 0, 8)):    """ Partial distance from (a, b, y1, y2) = ref.    ref             -- reference to compute the distance from    a, b, y1, y2    -- in  : decoder input signals, coded with n bits    res             -- out : partial distance signal, coded with (n + 2) bits    """    while 1:#    def partDistanceLogic():        if ref[2] == 0:            bSigned = b.val        else:            bSigned = -b.val        if ref[1] == 0:            y1Signed = y1.val        else:            y1Signed = -y1.val        if ref[0] == 0:            y2Signed = y2.val        else:            y2Signed = -y2.val        res.next = a.val + bSigned + y1Signed + y2Signed        yield a, b, y1, y2#    return always_comb(partDistanceLogic)def distance(partDist, z, dist, n = 4):    """ Distance computation.    n           -- number of bits for the coding of the decoder input signals    partDist    -- in  : sum of the decoder input signals    z           -- in  : extrinsic information    dist        -- out : distance    """    def distanceLogic():        dist.next = (4 * (2 ** (n - 1) - 1) + partDist.val) / 2 + z.val    return always_comb(distanceLogic)def distances(a, b, y1, y2, z, distance16, n = 4):    """ Computes the 16 distances from the decoder input signals.    n               -- number of bits for the coding of the decoder input signals    a, b, y1, y2    -- in  : decoder input signals, coded with n bits    z               -- in  : extrinsic information signals (x4), coded with m bits    distance16      -- out : distance signals (x16)    """    partDist = [Signal(intbv(0, -(2**(n+1)), 2**(n+1))) for i in range(16)]    opposite_i = [None for i in range(8)]    distance_i = [None for i in range(16)]    partDistance_i = [None for i in range(8)]    for i in range(8):        partDistance_i[i] = partDistance(a, b, y1, y2, partDist[i], intbv(i, 0, 8))    for i in range(8):        opposite_i[i] = opposite(partDist[i], partDist[15 - i])    for i in range(16):        distance_i[i] = distance(partDist[i], z[i / 4], distance16[i], n)    return instances()def reduction(org, chd, q = 8):    """ (Reduction: if anyone's q(th) bit is set, divide everyone by 2.)        Temporary test: when everyone's q(th) bit is set, reset everyone's q(th) bit.    q   -- accumulated distance width    org -- in  : original array of 8 q-bit accumulated distances    chd -- out : reduced array of 8 q-bit accumulated distances    """#    tmp = intbv(0, 0, 2**q)    while 1:#        msb = bool(0)        msb = bool(1)        for i in range(8):#            msb = msb or org[i].val[q-1]            msb = msb and org[i].val[q - 1]        for i in range(8):            chd[i].next[q-1:0] = org[i].val[q-1:0]            chd[i].next[q - 1] = (not msb) and org[i].val[q - 1]#            if msb == 1:#                tmp[q-1:0] = org[i].val[q:1]#            else:#                tmp = org[i].val#            chd[i].next = tmp        yield org[0], org[1], org[2], org[3], org[4], org[5], org[6], org[7]def accDist(clk, rst, accDistReg, dist, accDistNew, q = 8):    """ Accumulated distances.    q           -- in  : accumulated distance width    clk, rst    -- in  : clock and negative reset    accDistReg  -- in  : original array of 8 q-bit accumulated distance registers    dist        -- in  : array of 16 distances    accDistNew  -- out : array of 32 (q+1)-bit accumulated distances    """    adder_i     = [None for i in range(32)]    register_i  = [None for i in range(8)]    accDistOld  = [Signal(intbv(0, 0, 2**q)) for i in range(8)]    accDistRed  = [Signal(intbv(0, 0, 2**q)) for i in range(8)]    accDistRegSorted    = [Signal(intbv(0, 0, 2**q)) for i in range(8)]    accDistRegDelta     = [Signal(intbv(0, 0, 2**q)) for i in range(8)]    distIndex   = [0, 7, 11, 12,   0, 7, 11, 12,   2, 5, 9, 14,   2, 5, 9, 14,    3, 4, 8, 15,   3, 4, 8, 15,   1, 6, 10, 13,   1, 6, 10, 13]    for i in range(32):        adder_i[i] = adder(accDistOld[i/4], dist[distIndex[i]], accDistNew[i])    reduction_i0 = reduction(accDistReg, accDistRed, q)    for i in range(8):        register_i[i] = register(clk, rst, accDistRed[i], accDistOld[i])    return instances()