edt_si5326.c

/* #pragma ident "@(#)set_ss_vco.c      1.17 01/17/05 EDT" */

#include <stdio.h>
#include <math.h>

#include <string.h>

#include <stdlib.h>

#include "edtinc.h"

#include <stddef.h>

#include "edt_si5326.h"

#include "edt_msdv.h"

#include "edt_ocm.h"

/* for storing register set */




/*
*/

/*
* this array initializes a si5226 with a 
* 10.3681MHz reference clock input on clock 1 
* to yield a 148.5MHz clock out on clock 1
* the nominal output is 221 HZ high
*/



/* description of all register values */


EdtRegisterDescriptor si5326regs_map[] = {
    {0, 2, 1, "spim"},
    {0, 1, 1, "bypass_reg"},
    {0, 0, 1, "fxdly"},
    {1, 2, 2, "ck_prior2"},
    {1, 0, 2, "ck_prior1"},
    {2, 4, 4, "bwsel_reg"},
    {3, 6, 2, "cksel_reg"},
    {3, 5, 1, "dhold"},
    {3, 4, 1, "sq_ical"},
    {4, 6, 2, "autosel_reg"},
    {4, 0, 5, "hist_del"},
    {5, 6, 2, "icmos"},
    {6, 6, 1, "sleep"},
    {6, 3, 3, "sfout2_reg"},
    {6, 0, 3, "sfout1_reg"},
    {7, 0, 3, "fosrefsel"},
    {8, 6, 2, "hlog_2"},
    {8, 4, 2, "hlog_1"},
    {9, 3, 5, "hist_avg"},
    {10, 3, 1, "dsbl2_reg"},
    {10, 2, 1, "dsbl1_reg"},
    {11, 1, 1, "pd_ck2"},
    {11, 0, 1, "pd_ck1"},
    {16, 0, 8, "clat"},
    {17, 7, 1, "flat_valid"},
    {17, 0, 15, "flat"},
    {19, 7, 1, "fos_en"},
    {19, 5, 2, "fos_thr"},
    {19, 3, 2, "valtime"},
    {19, 0, 3, "lockt"},
    {20, 3, 1, "ck2_bad_pin"},
    {20, 2, 1, "ck1_bad_pin"},
    {20, 1, 1, "lol_pin"},
    {20, 0, 1, "int_pin"},
    {21, 7, 1, "incdec_pin"},
    {21, 1, 1, "ck1_actv_pin"},
    {21, 0, 1, "cksel_pin"},
    {22, 3, 1, "ck_actv_pol"},
    {22, 2, 1, "ck_bad_pol"},
    {22, 1, 1, "lol_pol"},
    {22, 0, 1, "int_pol"},
    {23, 2, 1, "los2_msk"},
    {23, 1, 1, "los1_msk"},
    {23, 0, 1, "losx_msk"},
    {24, 2, 1, "fos2_msk"},
    {24, 1, 1, "fos1_msk"},
    {24, 0, 1, "lol_msk"},
    {25, 5, 3, "n1_hs"},
    {31, 0, 20, "nc1_ls"},
    {34, 0, 20, "nc2_ls"},
    {40, 5, 3, "n2_hs"},
    {40, 0, 20, "n2_ls"},
    {43, 0, 19, "n31"},
    {46, 0, 19, "n32"},
    {55, 3, 3, "clkin2rate"},
    {55, 0, 3, "clkin1rate"},
    {128, 1, 1, "ck2_actv_reg"},
    {128, 0, 1, "ck1_actv_reg"},
    {129, 2, 1, "los2_int"},
    {129, 1, 1, "los1_int"},
    {129, 0, 1, "losx_int"},
    {130, 7, 1, "clatprogress"},
    {130, 6, 1, "digholdvalid"},
    {130, 2, 1, "fos2_int"},
    {130, 1, 1, "fos1_int"},
    {130, 0, 1, "lol_int"},
    {131, 2, 1, "los2_flg"},
    {131, 1, 1, "los1_flg"},
    {131, 0, 1, "losx_flg"},
    {132, 3, 1, "fos2_flg"},
    {132, 2, 1, "fos1_flg"},
    {132, 1, 1, "lol_flg"},
    {134, 0, 8, "nvm_rev"},
    {135, 4, 4, "partnum_ro"},
    {135, 0, 4, "revid_ro"},
    {136, 7, 1, "rst_reg"},
    {136, 6, 1, "ical"},
    {136, 0, 2, "grade_ro"},
    {142, 0, 8, "independentskew1"},
    {142, 0, 8, "independentskew2"},
    {0,0,0,NULL,0}
};

#if 0
int
get_SIReg_value(void *target, int offset, int shift, int mask)

{
    EdtSIRegArray *vector = (EdtSIRegArray *) target;
    int shiftmask = (mask << shift);
    int vindex = 0;
    int v;

    while (vector[vindex].offset < offset && vindex < EDT_SI5326_NREGS)
        vindex++;

    if (vector[vindex].offset != offset)
    {
        printf("Unable to find offset %d in vector\n", offset);
        return -1;
    }

    if (mask == 0xff)
    {
        v = vector[vindex].value;
    }
    else
    {
        v = (vector[vindex].value & shiftmask) >> shift;
    }

    return v;

}

int
set_SIReg_value(void *target, int offset, int value, int shift, int mask)

{
    EdtSIRegArray *vector = (EdtSIRegArray *) target;
    int invmask = ~(mask << shift);
    int vindex = 0;

    while (vector[vindex].offset < offset && vindex < EDT_SI5326_NREGS)
        vindex++;

    if (vector[vindex].offset != offset)
    {
        printf("Unable to find offset %d in vector\n", offset);
        return -1;
    }

    if (mask == 0xff)
    {
        vector[vindex].value = value;
    }
    else
    {
        vector[vindex].value &= invmask;
        vector[vindex].value |= (value << shift);
    }

    return 0;

}

EdtRegisterDescriptor *
edt_si5326_map_lookup(EdtRegisterDescriptor *map, char *name)

{
    int i;
    for (i=0;map[i].name != NULL; i++)
        if (!strcmp(name,map[i].name))
            return map + i;

    return NULL;

}

int
edt_si5326_read_reg_array(EdtRegisterDescriptor *map, char *name, EdtSIRegArray *vector)

{
    /* lookup name in map */
    EdtRegisterDescriptor * p;

    p = edt_si5326_map_lookup(map, name);

    if (p)
    {
        return edt_get_two_wire_value(vector, p, get_SIReg_value);
    }
    else
    {
        return -1;
    }

}

int
edt_si5326_write_reg_array(EdtRegisterDescriptor *map, char *name, EdtSIRegArray *vector, u_int value)

{
    /* lookup name in map */
    /* lookup name in map */
    EdtRegisterDescriptor * p;

    p = edt_si5326_map_lookup(map, name);

    if (p)
    {
        return edt_set_two_wire_value(vector, p, value,set_SIReg_value );
    }
    else
    {
        return -1;
    }
}


void
edt_si5326_print_regarray(EdtRegisterDescriptor *map, EdtSIRegArray *vector)

{
    int mapindex;

    for (mapindex = 0; map[mapindex].name != NULL ; mapindex++)
    {
        u_int v = edt_get_two_wire_value(vector, map + mapindex, get_SIReg_value);

        printf("%-20s: %02x\n", map[mapindex].name, v);

    }
}

#endif
/*****************************************/
/*****************************************/

/* explore parameter space for optimal settings */


#define N_HS_VALUES 8

int n1n2_hs_values[N_HS_VALUES] = {
    11,10,9,8,7,6,5,4
};

int n1n2_ls_max = 0x100000;

int n1n2_min = 4 * 2;
int n1n2_max = 11 * 0x100000;

int n3_max_possible = 0x80000;

double fosc_min = 4850000000;
double fosc_max = 5670000000;

double fbw_min = 60;
double fbw_max = 8400;

typedef struct n1_possibles {
    int n1;
    int n1_ls;
    int n1_hs;
    double fosc;
} N1Possibles;

typedef struct n2_possibles {
    int n2;
    int n2_ls;
    int n2_hs;
    double fosc;
    int n3;
} N2Possibles;

double edt_si5326_compute_fbw(int n2, double fosc, int bwsel)

{
    int i;
    double f3;
    double fbw;
    double a,b,c,d;
    int two = 1;

    for (i=0;i<bwsel;i++)
        two*= 2;

    f3 = fosc/n2;

    a = (f3/(16.84*two));
    b = (1.0/sqrt(1.0-(1.0/(3.35 * two))));
    c = (1.0/sqrt(1.0-(4276/(n2 * two))));
    d = (6500000000.0 / fosc);

    d = d*d;

    fbw = a* b * c * d;

    return fbw;

}

/* return valid bwsel */
/* return 0 if not OK */

int edt_si5326_bwsel(int n2, double fosc)

{
    int bwsel;
    double fbw;

    for (bwsel = 1; bwsel <= 10; bwsel++)
    {
        fbw = edt_si5326_compute_fbw(n2, fosc, bwsel);

        if (fbw >= fbw_min && fbw <= fbw_max)
            return bwsel;
    }
    return 0;
}

void 
edt_vco_si5326_print(EdtSI53xx *sip)
{
    printf("n1_ls=%6d n1_hs=%2d n2_ls=%6d n2_hs=%2d n3=%6d output=%f\n",
        sip->n1_ls,
        sip->n1_hs,
        sip->n2_ls,
        sip->n2_hs,
        sip->n3,
        sip->output);

    printf("n1_ls=%6x n1_hs=%2x n2_ls=%6x n2_hs=%2x n3=%6x output=%f\n",
        sip->n1_ls,
        sip->n1_hs,
        sip->n2_ls,
        sip->n2_hs,
        sip->n3,
        sip->output);

    printf("n1_ls=%6x n1_hs=%2x n2_ls=%6x n2_hs=%2x n3=%6x bwsel=%2d output=%f\n",
        sip->n1_ls-1,
        sip->n1_hs-4,
        sip->n2_ls-1,
        sip->n2_hs-4,
        sip->n3-1,
        sip->bwsel,
        sip->output);
}

void
edt_vco_si5326_set_speedreg(EdtDev *edt_p,
                            u_int base_desc, 
                            u_int device, 
                            EdtSI53xx *sip,
                            int clkin)

{

    edt_set_two_wire_value(edt_p, si5326regs_map+48, base_desc, device, sip->n1_ls-1);
    edt_set_two_wire_value(edt_p, si5326regs_map+47, base_desc, device, sip->n1_hs-4);
    edt_set_two_wire_value(edt_p, si5326regs_map+51, base_desc, device, sip->n2_ls-1);
    edt_set_two_wire_value(edt_p, si5326regs_map+50, base_desc, device, sip->n2_hs-4);
    edt_set_two_wire_value(edt_p, si5326regs_map+52, base_desc, device, sip->n3-1);
    edt_set_two_wire_value(edt_p, si5326regs_map+5, base_desc, device, sip->bwsel);

}


double edt_vco_si5326_compute(double xtal, double target, EdtSI53xx *sip)

{
    double ratio;
    double actual = 0;
    int n1_min, n1_max;
    int n2_min, n2_max;
    int n1;
    int which;
    int n1_hs;
    int n1_ls;
    int pindex = 0;
    N1Possibles *possibles;
    int psize;
    int pgrain = 16;
    int visit = 0;
    int n3_max;
    int n3_min;
    double curdelta = 1000000000;

    if (xtal == 0)
    {
        edt_msg(EDTLIB_MSG_FATAL,"Ref frequency of 0 passed to edt_vco_si5326_compute, returning 0\n");
        return 0.0;
    }

    ratio = target/xtal;

    n1_min = (int) ceil(fosc_min / target);
    n1_max = (int) floor(fosc_max/target);

    psize = pgrain;
    possibles = (N1Possibles *) malloc(sizeof(N1Possibles) * psize);
    for (n1=n1_min;n1 <= n1_max;n1++)
    {
        for (which = 0; which < N_HS_VALUES;which++)
        {
            n1_hs = n1n2_hs_values[which];

            n1_ls = n1/n1_hs;


            if (((n1 % n1_hs) == 0) && n1_ls && (n1_ls & 1) == 0 && (n1_ls <= n1n2_ls_max))
            {
                int already = 0;
                int i;

                for (i=0;i<pindex;i++)
                    if (n1 == possibles[i].n1)
                    {
                        already = 1;
                        break;
                    }

                    if (!already)
                    {
                        possibles[pindex].n1 = n1;
                        possibles[pindex].n1_ls = n1_ls;
                        possibles[pindex].n1_hs = n1_hs;
                        possibles[pindex].fosc = (double) (target * n1_ls * n1_hs);
                        pindex++;
                        if (pindex >= psize)
                        {
                            psize += pgrain;
                            possibles = (N1Possibles *)realloc(possibles, sizeof(N1Possibles) * psize);
                        }
                    }

            }
        }
    }

    psize = pindex;
    printf("%d possible n1 values\n", pindex);

    for (pindex = 0; pindex < psize;pindex ++)
    {
        printf("%3d: %8d %5d %2d: %f\n", pindex,                
            possibles[pindex].n1,
            possibles[pindex].n1_ls,
            possibles[pindex].n1_hs,
            possibles[pindex].fosc);
    }

    /* scan over all possible n3/n2 combinations */

    n3_max = (int) floor(xtal / 2000.0);
    n3_min = (int) ceil(xtal/ 2000000.0);

    for (pindex = 0; pindex < psize;pindex ++)
    {

        int n3;
        int n2;
        n1 = possibles[pindex].n1;

        n2_min = n1n2_min;
        n2_max = n1n2_max;

        for (n3 = n3_min;n3 <= n3_max;n3++)
        {
            int n2_low = (int) floor(n3 * ratio * possibles[pindex].n1);
            int n2_high = (int) ceil(n3 * ratio * possibles[pindex].n1);
            int n2n3_high = n2_high;
            int n2n3_low  = n2_low;

            if (n2n3_high > n2_max)
                n2n3_high = n2_max;

            if (n2n3_low < n2_min)
                n2n3_low = n2_min;

            if (n2n3_low > n2_max)
                break;

            for (n2 = n2n3_low; n2 <= n2n3_high;n2++)
            {
                for (which = 0; which < N_HS_VALUES;which++)
                {
                    int n2_hs = n1n2_hs_values[which];
                    int n2_ls = n2/n2_hs;

                    if (n2_ls >= 2 && n2_ls <= n1n2_ls_max)
                    {
                        /* compute actual fout */
                        double actual_n2, test, delta;

                        n2_ls &= 0xffffffe;

                        actual_n2 = n2_ls * n2_hs;

                        test = ((xtal / (double) n3) * actual_n2) / n1;

                        delta = fabs(test - target);


                        if (delta < curdelta)
                        {
                            int bwsel = edt_si5326_bwsel(n2, possibles[pindex].fosc);
                            if (bwsel != 0)
                            {
                                curdelta = delta;
                                actual = test;
                                sip->n2_ls = n2_ls;
                                sip->n2_hs = n2_hs;
                                sip->n1_ls = possibles[pindex].n1_ls;
                                sip->n1_hs = possibles[pindex].n1_hs;
                                sip->n3 = n3;
                                sip->bwsel = bwsel;
                                sip->output = test;
                            }
                        }
                    }

                    visit++;

                }
            }      
        }
    }

    printf("loops = %d\n",visit);

    free(possibles);

    return actual;

}


double edt_vco_si5326_compute2(double xtal, 
                               double target, 
                               double target2, 
                               EdtSI53xx *sip, 
                               EdtSI53xx *sip2,
                               int direction /* -1 below, 0 either, 1 above */)

{
    double ratio;
    double ratio2;
    double actual = 0;
    int n1_min, n1_max;
    int n2_min, n2_max;
    int n1;
    int which;
    int pindex = 0;
    N1Possibles *possibles;
    int psize;
    int pgrain = 16;
    int visit = 0;
    int n3_max;
    int n3_min;
    double curdelta = 1000000000;
    double curdelta2 = 1000000000;

    int max_n_possible;
    int i;

    if (xtal == 0)
    {
        edt_msg(EDTLIB_MSG_FATAL,"Ref frequency of 0 passed to edt_vco_si5326_compute, returning 0\n");
        return 0.0;
    }

    ratio = target/xtal;
    ratio2 = target/target2;

    n1_min = (int) ceil(fosc_min / target);
    n1_max = (int) floor(fosc_max/target);

    if (n1_min > 11)
        n1_min &= ~1;
    if (n1_max > 11)
        n1_max &= ~1;

    max_n_possible = (n1_max - n1_min + 1);
    if (max_n_possible <= 0)
        return 0.0;

    possibles = (N1Possibles *) edt_alloc(max_n_possible * sizeof(N1Possibles));

    for (i=n1_min;i<= n1_max;i++)
    {
        if (i <= 11 || (i&1) == 0)
        {
            for (which = 0; which < N_HS_VALUES;which++)
            {
                int hs = n1n2_hs_values[which];
                int ls = i / hs;

                if (i % hs == 0 && ((ls & 1) == 0))
                {
                    possibles[pindex].n1_hs = hs;
                    possibles[pindex].n1_ls = i / hs;
                    possibles[pindex].n1 = i;
                    possibles[pindex].fosc = (double) (target * i );
                    pindex++;
                }
            }
        }
    }

    /* scan over all possible n3/n2 combinations */

    n3_max = (int) floor(xtal / 2000.0);
    n3_min = (int) ceil(xtal/ 2000000.0);


    psize = pindex;

    for (pindex = 0; pindex < psize;pindex ++)
    {

        int n3;
        int n2;

        int n1_hs = possibles[pindex].n1_hs;
        int n1_ls = possibles[pindex].n1_ls;

        n1 = possibles[pindex].n1;

        n2_min = n1n2_min;
        n2_max = n1n2_max;

        for (n3 = n3_min;n3 <= n3_max;n3++)
        {
            int n2_low = (int) floor(n3 * ratio * possibles[pindex].n1);
            int n2_high = (int) ceil(n3 * ratio * possibles[pindex].n1);
            int n2n3_high = n2_high;
            int n2n3_low  = n2_low;

            if (n2n3_high > n2_max)
                n2n3_high = n2_max;

            if (n2n3_low < n2_min)
                n2n3_low = n2_min;

            if (n2n3_low > n2_max)
                break;

            for (n2 = n2n3_low; n2 <= n2n3_high;n2++)
            {
                for (which = 0; which < N_HS_VALUES;which++)
                {
                    int n2_hs = n1n2_hs_values[which];
                    int n2_ls = n2/n2_hs;
                    int n1_ls_target2;
                    int n1_ls_target2_2;


                    if (n2_ls >= 2 && n2_ls <= n1n2_ls_max)
                    {
                        /* compute actual fout */
                        double actual_n2, test, delta;
                        double test2 = 0;
                        double test3 = 0;
                        u_char ok1 = TRUE;
                        u_char ok2 = TRUE;
                        double delta2;
                        double delta3;

                        n2_ls &= 0xffffffe;

                        actual_n2 = n2_ls * n2_hs;

                        test = ((xtal / (double) n3) * actual_n2) / n1;

                        delta = fabs(test - target);

                        // find the closest n1_ls for target 2

                        n1_ls_target2 =  (int) (ratio2 * n1_ls);
                        if (n1_ls_target2 > 1)
                            n1_ls_target2 &= ~1;

                        if (n1_ls_target2 >= 1 && n1_ls_target2 <n1n2_ls_max)
                        {
                            test2 = ((xtal / (double) n3) * actual_n2) / (n1_hs * n1_ls_target2);
                        }
                        else 
                            ok1 = FALSE;

                        if (n1_ls_target2 == 1)
                            n1_ls_target2_2 = 2;
                        else
                            n1_ls_target2_2 = n1_ls_target2 + 2;

                        if (n1_ls_target2_2 >= 1 && n1_ls_target2_2 <n1n2_ls_max)
                            test3=((xtal / (double) n3) * actual_n2) / (n1_hs * n1_ls_target2_2);
                        else
                        {
                            if (ok1)
                                test3 = test2;
                            ok2 = FALSE;
                        }
                        if (!ok1 && ok2)
                            test2 = test3;

                        if (ok1 || ok2)
                        {
                            delta2 = fabs(test2-target2);
                            delta3 = fabs(test3-target2);

                            if (direction < 0) /* constrained to be below target */
                            {
                                if (test2 > target2)
                                {
                                    ok1 = FALSE;
                                }

                                if (test3 > target2)
                                {
                                    ok2 = FALSE;
                                }

                            }
                            else if (direction > 1)/* constrained to be above target */
                            {
                                if (test2 < target2)
                                {
                                    ok1 = FALSE;
                                }

                                if (test3 < target2)
                                {
                                    ok2 = FALSE;
                                }
                            }

                            if (ok1)
                            {
                                if (ok2)
                                {
                                    if (delta2 > delta3)
                                    {
                                        delta2 = delta3;
                                        n1_ls_target2 = n1_ls_target2_2;
                                        test2 = test3;
                                    }
                                }
                            }
                            else if (ok2)
                            {
                                delta2 = delta3;
                                n1_ls_target2 = n1_ls_target2_2;
                                test2 = test3;
                            }

                            if ((ok1 || ok2) && n1_ls_target2 >= 2 && n1_ls_target2 <= n1n2_ls_max)
                            {


                                int bwsel = edt_si5326_bwsel(n2, possibles[pindex].fosc);

                                if (delta <= curdelta && bwsel != 0)
                                {
                                    if (delta < curdelta ||
                                        (delta == curdelta && delta2 < curdelta2))
                                    {
                                        curdelta = delta;
                                        curdelta2 = delta2;
                                        actual = test;
                                        sip->n2_ls = n2_ls;
                                        sip->n2_hs = n2_hs;
                                        sip->n1_ls = possibles[pindex].n1_ls;
                                        sip->n1_hs = possibles[pindex].n1_hs;
                                        sip->n3 = n3;
                                        sip->bwsel = bwsel;
                                        sip->output = test;
                                        sip2->n2_hs = n2_hs;
                                        sip2->n1_ls = n1_ls_target2;
                                        sip2->n1_hs = possibles[pindex].n1_hs;
                                        sip2->n3 = n3;
                                        sip2->bwsel = bwsel;
                                        sip2->output = test2;
                                        sip2->n2_ls = n2_ls;
                                    }
                                }
                            }

                        }
                        visit++;

                    }
                }
            }      
        }
    }

    edt_free((u_char *) possibles);

    return actual;


}

---