Baud rate calculator for Freescale DSPI

#!/usr/bin/python -tt
# -*- coding: UTF-8 -*-
# vim: ts=4 sw=4 et ai si

import sys
import os
import operator

import math
import fractions

__author__ = "Andy Shevchenko"
__license__ = "GPL v2"

PROG = os.path.basename(sys.argv[0])

FSYS = 64000000

#
# Fssp = Fsys / PBR
# Baud rate = Fsclk = Fssp * (1 + DBR) / BR)
#

# Baud rate, DDS_CLK_RATE, SCR
TABLE = [
    [50000000,  8388608,    0],
    [40020000,  -1,         -1],
    [40000000,  6710886,    0],
    [39980000,  -1,         -1],
    [25000000,  4194304,    0],
    [20000000,  6710886,    1],
    [16667000,  8388608,    2],
    [13333000,  6710886,    2],
    [12500000,  2097152,    0],
    [10000000,  8388608,    4],
    [8000000,   6710886,    4],
    [6250000,   4194304,    3],
    [5000000,   4194304,    4],
    [4350000,   -1,         -1],
    [4000000,   6710886,    9],
    [3333000,   -1,         -1],
    [3140500,   524288,     -1],
    [3125000,   524288,     0],
    [3109500,   524288,     -1],
    [2500000,   4194304,    9],
    [2000000,   6710886,    19],
    [1563000,   262144,     0],
    [1250000,   2097152,    9],
    [1006000,   -1,         -1],
    [1000000,   4194304,    24],
    [994000,    -1,         -1],
    [800000,    6710886,    49],
    [781250,    131072,     0],
    [625000,    2097152,    19],
    [500000,    4194304,    49],
    [400000,    6710886,    99],
    [390625,    65536,      0],
    [250000,    4194304,    99],
    [200000,    6710886,    199],
    [205313,    32768,      -1],
    [195313,    32768,      0],
    [185313,    32768,      -1],
    [125000,    1048576,    49],
    [100700,    -1,         -1],
    [100000,    2097152,    124],
    [99300,     -1,         -1],
    [50000,     1048576,    124],
    [25000,     524288,     124],
    [10066,     131072,     -1],
    [10016,     131072,     77],
    [9966,      131072,     -1],
    [5065,      131072,     -1],
    [5040,      131072,     154],
    [5015,      131072,     -1],
    [1007,      32768,      -1],
    [1002,      32768,      194],
    [997,       32768,      -1],
]

PBR_TBL = [
    2, 3, 5, 7
]

BRS = [
    2,      4,      6,      8,
    16,     32,     64,     128,
    256,    512,    1024,   2048,
    4096,   8192,   16384,  32768,
]

def orig_go(clkrate, speed_hz):
    minscale = 2**31 - 1;
    scale_needed = clkrate / speed_hz
    for i,br in enumerate(BRS):
        for j,pbr in enumerate(PBR_TBL):
            scale = br * pbr
            if scale >= scale_needed:
                if scale < minscale:
                    minscale = scale
                    ibr = i
                    jpbr = j
                break
    if minscale == 2**31 - 1:
        print "Can not find valid baud rate"
        ibr = len(BRS) - 1
        jpbr = len(PBR_TBL) - 1

    br = BRS[ibr]
    pbr = PBR_TBL[jpbr]
    est = clkrate / pbr / br
    print "%-8d %d %-2d %-5d %d %d %d %d" % (speed_hz, 0, ibr, br, jpbr, pbr, est, abs(est - speed_hz))

def orig_go_mod1(clkrate, speed_hz):
    r = 2**31 - 1;
    for i,br in enumerate(BRS):
        for j,pbr in enumerate(PBR_TBL):
            tmp = abs(clkrate / pbr / br - speed_hz)
            if tmp < r:
                r = tmp
                ibr = i
                jpbr = j
    if r == 2**31 - 1:
        print "Can not find valid baud rate"
        ibr = len(BRS) - 1
        jpbr = len(PBR_TBL) - 1

    br = BRS[ibr]
    pbr = PBR_TBL[jpbr]
    est = clkrate / pbr / br
    print "%-8d %d %-2d %-5d %d %d %d %d" % (speed_hz, 0, ibr, br, jpbr, pbr, est, abs(est - speed_hz))

def orig_go_mod2(clkrate, speed_hz):
    minscale = 2**31 - 1;
    for dbr in (0, 1):
        for i,br in enumerate(BRS):
            for j,pbr in enumerate(PBR_TBL):
                r = abs(clkrate / pbr * (1 + dbr) / br - speed_hz)
                if r < minscale:
                    minscale = r
                    ibr = i
                    jpbr = j
                    k = dbr
    if minscale == 2**31 - 1:
        print "Can not find valid baud rate"
        ibr = len(BRS) - 1
        jpbr = len(PBR_TBL) - 1
        k = 0

    br = BRS[ibr]
    pbr = PBR_TBL[jpbr]
    est = clkrate / pbr * (1 + k) / br
    print "%-8d %d %-2d %-5d %d %d %d %d" % (speed_hz, k, ibr, br, jpbr, pbr, est, abs(est - speed_hz))

def go(fref, baud):
    dsd = dict()
    for dbr in (0, 1):
        for i,br in enumerate(BRS):
            for j,pbr in enumerate(PBR_TBL):
                scale = br * pbr / (dbr + 1)
                if scale not in dsd:
                    dsd[scale] = (dbr, i, j)

    ss = sorted(dsd.keys())

    prev = ss[0]
    for scale in ss:
        if scale * baud >= fref:
            break
        prev = scale

    r1 = abs(fref / prev - baud)
    r2 = abs(fref / scale - baud)

    if r2 >= r1:
        scale = prev

    dbr, ibr, jpbr = dsd[scale]

    br = BRS[ibr]
    pbr = PBR_TBL[jpbr]
    est = fref / pbr * (1 + dbr) / br

    print "%-8d %d %-2d %-5d %d %d %d %d" % (baud, dbr, ibr, br, jpbr, pbr, est, abs(est - baud))

def usage():
    sys.stdout.write("Usage %s [ALGO [CUSTOM_BAUD_RATE]]\n" % PROG)

def toint(value):
    try:
        return int(value)
    except ValueError:
        usage()
        raise SystemExit("Invalid argument")

ALGORITHMS = [
    orig_go,
    orig_go_mod1,
    orig_go_mod2,
    go,
]

def main(argv):
    algo = 0
    if len(argv) > 1:
        algo = toint(argv[1])

    custom = 0
    if len(argv) > 2:
        custom = toint(argv[2])

    try:
        func = ALGORITHMS[algo]
    except IndexError:
        usage()
        raise SystemExit("Invalid argument")

    if custom:
        func(FSYS, custom)
    else:
        for item in TABLE:
            func(FSYS, operator.itemgetter(0)(item))

if __name__ == "__main__":
    sys.exit(main(sys.argv))