lib_msdv.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"

#include "lib_two_wire.h"

#include "edt_bitload.h"


#define  MSDV_PORT_OFFSET 0
#define  MSDV_DATA_OFFSET 1
#define  MSDV_REFRAME_OFF 2
#define  MSDV_DISP_OFF    3
#define  MSDV_CODE_OFF    4
#define  MSDV_PSTAT_OFF   5

static int msdv_channel_base[4] = 
{
    MSDV_CH0_PORT_CONFIG,
    MSDV_CH1_PORT_CONFIG,
    MSDV_CH2_PORT_CONFIG,
    MSDV_CH3_PORT_CONFIG
};

#define MSDV_PORT_CONFIG(chan) (msdv_channel_base[chan])
#define MSDV_DATA_CONFIG(chan) (msdv_channel_base[chan]+MSDV_DATA_OFFSET)
#define MSDV_REFRAME_COUNT(chan) (msdv_channel_base[chan]+MSDV_REFRAME_OFF)
#define MSDV_DISP_ERR_COUNT(chan) (msdv_channel_base[chan]+MSDV_DISP_OFF)
#define MSDV_CODE_ERR_COUNT(chan) (msdv_channel_base[chan]+MSDV_CODE_OFF)
#define MSDV_PORT_STATUS(chan) (msdv_channel_base[chan]+MSDV_PSTAT_OFF)

static char * msdv_mode_names[8] = 

{
    "raw",
    "bit aligned",
    "decoded",
    "data only",
    "TS frames",
    "timestamp TS",
    "PRBS15",
    "test"

};


Edt2WireRegArray msdv_148p5_2[EDT_SI5326_NREGS+1] = {
    {  0, 0x14},
    {  1, 0xe4},
    {  2, 0x12},
    {  3, 0x5},
    {  4, 0x92},
    {  5, 0xed},
    {  6, 0x2d},
    {  7, 0x2a},
    {  8, 0x0},
    {  9, 0xc0},
    { 10, 0x8},
    { 11, 0x48},
    { 16, 0x0},
    { 17, 0x80},
    { 18, 0x0},
    { 19, 0x29},
    { 20, 0x3e},
    { 21, 0xff},
    { 22, 0xdf},
    { 23, 0x1f},
    { 24, 0x3f},
    { 25, 0xa0},
    { 31, 0x0},
    { 32, 0x0},
    { 33, 0x3},
    { 34, 0x0},
    { 35, 0x0},
    { 36, 0x3},
    { 40, 0xa2},
    { 41, 0x2f},
    { 42, 0x79},
    { 43, 0x0},
    { 44, 0x9},
    { 45, 0xc3},
    { 46, 0x0},
    { 47, 0x9},
    { 48, 0xc3},
    { 55, 0x0},
    {128, 0, 1},
    {129, 0, 1},
    {130, 0, 1},
    {131, 0x1f},
    {132, 0x2},
    {134, 0, 1},
    {135, 0, 1},
    {136, 0x40},
    {142, 0x0},
    {143, 0x0},
    {256,0}
};

Edt2WireRegArray msdv_148p5[EDT_SI5326_NREGS+1] = {
    {  0,0x14},
    {  1,0xe4},
    {  2,0x22},
    {  3,0x5},
    {  4,0x92},
    {  5,0xed},
    {  6,0x2d},
    {  7,0x2a},
    {  8,0x0},
    {  9,0xc0},
    { 10,0x8},
    { 11,0x48},
    { 16,0x0},
    { 17,0x80},
    { 18,0x0},
    { 19,0x29},
    { 20,0x3e},
    { 21,0xff},
    { 22,0xdf},
    { 23,0x1f},
    { 24,0x3f},
    { 25,0xa0},
    { 31,0x0},
    { 32,0x0},
    { 33,0x3},
    { 34,0x0},
    { 35,0x0},
    { 36,0x3},
    { 40,0xa1},
    { 41,0x17},
    { 42,0xbd},
    { 43,0x0},
    { 44,0x4},
    { 45,0xe1},
    { 46,0x0},
    { 47,0x4},
    { 48,0xe1},
    { 55,0x0},
    {128, 0, 1},
    {129, 0, 1},
    {130, 0, 1},
    {131,0x1f},
    {132,0x2},
    {134, 0, 1},
    {135, 0, 1},
    {136,0x40},
    {142,0x0},
    {143,0x0},
    {256,0}
};


static int
msdv_get_si5326_value(void *target, int device, int offset, int shift, int mask)

{
    EdtDev *edt_p = (EdtDev *) target;
    int shiftmask = (mask << shift);
    int v;

    v = edt_serial_dev_reg_read(edt_p, MSDV_SERIAL_DEV, device, offset);

    if (mask != 0xff)
    {
        v = (v & shiftmask) >> shift;
    }

    return v;

}

static int
msdv_set_si5326_value(void *target, int device, int offset, int value, int shift, int mask)

{
    EdtDev *edt_p = (EdtDev *) target;
    int invmask = ~(mask << shift);
    int v = value;

    if (mask != 0xff)
    {
        v = edt_serial_dev_reg_read(edt_p, MSDV_SERIAL_DEV, device, offset);

        v &= invmask;
        v |= (value << shift);
    }

    edt_serial_dev_reg_write(edt_p, MSDV_SERIAL_DEV, device, offset, v);

    return 0;

}

int
edt_msdv_si5326_dump(EdtDev *edt_p)

{

    int mapindex;

    for (mapindex = 0; si5326regs_map[mapindex].name != NULL ; mapindex++)
    {
        u_int v = edt_get_two_wire_value(edt_p, 
            si5326regs_map + mapindex,
            MSDV_SERIAL_DEV, 
            0);

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

    }

    return 0;

}

int
edt_msdv_si5326_load_array(EdtDev *edt_p,  Edt2WireRegArray *vec)

{
    int mapindex;
    int r;
    for (mapindex = 0; vec[mapindex].offset < 256 && mapindex < EDT_SI5326_NREGS ; mapindex++)
    {
        if (!vec[mapindex].read_only)
        {
            edt_serial_dev_reg_write(edt_p, MSDV_SERIAL_DEV, 0, vec[mapindex].offset, vec[mapindex].value);
            r = edt_serial_dev_reg_read(edt_p, MSDV_SERIAL_DEV, 0, vec[mapindex].offset);

            if (r != vec[mapindex].value)
                printf("Unable to write at offset %d value %02x != %02x\n",
                vec[mapindex].offset, vec[mapindex].value, r);


        }
    }
    return 0;

}

int
edt_msdv_set_mode(EdtDev *edt_p, int mode)

{
    int r;

    if (mode < 0 || mode > 7)
    {
        edt_msg(EDTLIB_MSG_FATAL,"MSDV mode must be in 0..7\n");
        return -1;
    }

    r = edt_reg_read(edt_p, MSDV_DATA_CONFIG(edt_p->channel_no));
    r = (r & ~0x7) | mode;
    edt_reg_write(edt_p, MSDV_DATA_CONFIG(edt_p->channel_no), r);

    return 0;
}

int
edt_msdv_get_mode(EdtDev *edt_p)

{
    int r;

    r = edt_reg_read(edt_p, MSDV_DATA_CONFIG(edt_p->channel_no));

    return (r & ~0x7);
}

int
edt_msdv_get_status(EdtDev *edt_p)

{

    return edt_reg_read(edt_p, MSDV_PORT_STATUS(edt_p->channel_no));
}

int
edt_msdv_set_direction(EdtDev *edt_p, int direction)

{
    int r;
    int channel = edt_p->channel_no;

    /* set port direction */

    r = edt_reg_read(edt_p, MSDV_PORT_CONFIG(channel));
    r = (r & ~0x1) | direction;
    edt_reg_write(edt_p, MSDV_PORT_CONFIG(channel), r);

    /* set channel direction */

    r = edt_reg_read(edt_p, SSD16_CHDIR);
    r = (r & ~(1 << channel)) | (direction)?(1 << channel):0;
    edt_reg_write(edt_p, SSD16_CHDIR, r);


    return 0;
}

int
edt_msdv_get_direction(EdtDev *edt_p)

{
    int r;
    /* get port direction */

    r = edt_reg_read(edt_p, MSDV_PORT_CONFIG(edt_p->channel_no));
    return (r & ~0x1);
}

int
edt_msdv_set_definition(EdtDev *edt_p, int onoff)

{
    return edt_reg_set_bitmask(edt_p, MSDV_PORT_CONFIG(edt_p->channel_no),
        MSDV_XMIT_STDDEF, onoff);

}

int
edt_msdv_get_definition(EdtDev *edt_p)

{
    return ((edt_reg_read(edt_p, MSDV_PORT_CONFIG(edt_p->channel_no)) & 
        MSDV_XMIT_STDDEF) != 0)?1:0;
}


int
edt_msdv_set_mute(EdtDev *edt_p, int onoff)

{
    return edt_reg_set_bitmask(edt_p, MSDV_PORT_CONFIG(edt_p->channel_no),
        MSDV_MUTE_INPUT, onoff);

}

int
edt_msdv_get_mute(EdtDev *edt_p)

{
    return ((edt_reg_read(edt_p, MSDV_PORT_CONFIG(edt_p->channel_no)) & 
        MSDV_MUTE_INPUT) != 0)?1:0;

}


int
edt_msdv_set_bypass(EdtDev *edt_p, int onoff)

{
    return edt_reg_set_bitmask(edt_p, MSDV_PORT_CONFIG(edt_p->channel_no),
        MSDV_BYPASS, onoff);

}

int
edt_msdv_get_bypass(EdtDev *edt_p)

{
    return ((edt_reg_read(edt_p, MSDV_PORT_CONFIG(edt_p->channel_no)) & 
        MSDV_BYPASS) != 0)?1:0;

}


int
edt_msdv_set_error_enable(EdtDev *edt_p, int onoff)

{
    return edt_reg_set_bitmask(edt_p, MSDV_PORT_CONFIG(edt_p->channel_no),
        MSDV_ERR_COUNT_EN, onoff);
}

int
edt_msdv_get_error_enable(EdtDev *edt_p)

{
    return ((edt_reg_read(edt_p, MSDV_PORT_CONFIG(edt_p->channel_no)) & 
        MSDV_ERR_COUNT_EN) != 0)?1:0;
}


int
edt_msdv_set_invert_prbs(EdtDev *edt_p, int onoff)

{
    return edt_reg_set_bitmask(edt_p, MSDV_DATA_CONFIG(edt_p->channel_no),
        MSDV_INVERT_PRBS, onoff);
}

int
edt_msdv_get_invert_prbs(EdtDev *edt_p)

{
    return ((edt_reg_read(edt_p, MSDV_DATA_CONFIG(edt_p->channel_no)) & 
        MSDV_INVERT_PRBS) != 0)?1:0;
}


int
edt_msdv_set_filter_idle(EdtDev *edt_p, int onoff)

{
    return edt_reg_set_bitmask(edt_p, MSDV_DATA_CONFIG(edt_p->channel_no),
        MSDV_FILTER_IDLE, onoff);

}

int
edt_msdv_get_filter_idle(EdtDev *edt_p)

{
    return ((edt_reg_read(edt_p, MSDV_DATA_CONFIG(edt_p->channel_no)) & 
        MSDV_FILTER_IDLE) != 0)?1:0;

}


static char *
status_bit_string(char *s, char *fmt, int *r, int bitmask, char *onstring, char * offstring)

{
    sprintf(s, fmt, 
        (r[0] & bitmask)?onstring:offstring,
        (r[1] & bitmask)?onstring:offstring,
        (r[2] & bitmask)?onstring:offstring,
        (r[3] & bitmask)?onstring:offstring);

    return s;
}



int
edt_msdv_print_status(FILE *f, EdtDev *edt_p)

{
    int channel;
    char s[80];
    int ch;
    int r[4];

    if (f == NULL)
        f = stdout;

    fprintf(f,"MSDV Status\n\n");

    ch = edt_reg_read(edt_p, SSD16_CHEN);
    for (channel=0;channel<4;channel++)
        r[channel] = (ch & (1 << channel));

    fprintf(f,"Channel Enable   = %s\n", status_bit_string(s, "%12s%12s%12s%12s",r,0xf,"on","off"));

    for (channel = 0;channel<4;channel++)
        r[channel] = edt_reg_read(edt_p, MSDV_PORT_CONFIG(channel));


    fprintf(f,"Port Config     \n");
    fprintf(f,"    direction    = %s\n",status_bit_string(s, "%12s%12s%12s%12s",r, 1,"output","input"));
    fprintf(f,"    definition   = %s\n",status_bit_string(s, "%12s%12s%12s%12s",r, 4,"std","hidef"));
    fprintf(f,"    mute         = %s\n",status_bit_string(s, "%12s%12s%12s%12s",r, 8,"on","off"));
    fprintf(f,"    bypass       = %s\n",status_bit_string(s, "%12s%12s%12s%12s",r, 0x10,"on","off"));
    fprintf(f,"    error count  = %s\n",status_bit_string(s, "%12s%12s%12s%12s",r, 0x80,"enabled","disabled"));


    for (channel = 0;channel<4;channel++)
        r[channel] = edt_reg_read(edt_p, MSDV_DATA_CONFIG(channel));

    fprintf(f,"\nData Config\n");
    sprintf(s,"%12s%12s%12s%12s",
        msdv_mode_names[(r[0]&7)],
        msdv_mode_names[(r[1]&7)],
        msdv_mode_names[(r[2]&7)],
        msdv_mode_names[(r[3]&7)]);

    fprintf(f,"    mode         = %s\n",s);
    fprintf(f,"    invert prbs  = %s\n",status_bit_string(s, "%12s%12s%12s%12s",r, 8,"on","off"));
    fprintf(f,"    filter idle  = %s\n",status_bit_string(s, "%12s%12s%12s%12s",r, 0x10,"on","off"));

    for (channel = 0;channel<4;channel++)
        r[channel] = edt_reg_read(edt_p, MSDV_PORT_STATUS(channel));

    fprintf(f, "\nPort Status\n");
    fprintf(f,"    carrier det  = %s\n",status_bit_string(s, "%12s%12s%12s%12s",r, 1,"on","off"));
    fprintf(f,"    reset        = %s\n",status_bit_string(s, "%12s%12s%12s%12s",r, 2,"on","off"));
    fprintf(f,"    lock         = %s\n",status_bit_string(s, "%12s%12s%12s%12s",r, 4,"on","off"));
    fprintf(f,"    bit align    = %s\n",status_bit_string(s, "%12s%12s%12s%12s",r, 8,"on","off"));
    fprintf(f,"    TS frame     = %s\n",status_bit_string(s, "%12s%12s%12s%12s",r, 0x10,"on","off")); 
    fprintf(f,"    TS 206       = %s\n",status_bit_string(s, "%12s%12s%12s%12s",r, 0x20,"on","off"));


    for (channel = 0;channel<4;channel++)
        r[channel] = edt_reg_read(edt_p, MSDV_REFRAME_COUNT(channel));

    fprintf(f, "\nReframe Count    = %12d%12d%12d%12d\n",r[0],r[1],r[2],r[3]);


    for (channel = 0;channel<4;channel++)
        r[channel] = edt_reg_read(edt_p, MSDV_CODE_ERR_COUNT(channel));

    fprintf(f, "Coder Errors     = %12d%12d%12d%12d\n",r[0],r[1],r[2],r[3]);

    for (channel = 0;channel<4;channel++)
        r[channel] = edt_reg_read(edt_p, MSDV_DISP_ERR_COUNT(channel));

    fprintf(f, "Disparity Errors = %12d%12d%12d%12d\n",r[0],r[1],r[2],r[3]);

    return 0;
}

int
edt_msdv_configure(EdtDev *edt_p, int mode)

{
    edt_reg_write(edt_p, MSDV_CLK0_CFG_STAT, SI532X_ENABLE);

    /* initialize msdv clock to 148.5 */

    edt_msdv_si5326_load_array(edt_p, msdv_148p5);

    edt_msdv_set_mode(edt_p, mode);

    return 0;

}

---