lib_sdh.c

Go to the documentation of this file.

/* #pragma ident "@(#)lib_sdh.c 1.16 08/05/11 EDT" */

#include "edtinc.h"
#include "edt_ocx.h"
#include "lib_sdh.h"
#include "initpcd.h"

edt_sdh_t *
edt_sdh_board_setup(int unitNo, int configure_board)
{
    EdtDev *edt_p;
    edt_sdh_t *sdh_p;
    char *rate_str;
    int tmp;


    /*
     * First, optionally cd to EDTpcd driver directory, and configure FPGAs.
     */

    if (configure_board != ATTACH_TO_CURRENT)
    {
        char *cwd = (char *) calloc(1, PATH_MAX);
        char *configFile;

        if (cwd)
        {
            if (getcwd(cwd, PATH_MAX) == NULL)
            {
                edt_perror((char *)"getcwd");
                free(cwd);
                return NULL;
            }
        }
        else
        {
            edt_perror((char *) "calloc");
            return NULL;
        }
        if (chdir("/opt/EDTpcd"))
        {
            if (chdir("c:\\edt\\pcd"))
            {
                free(cwd);
                edt_perror((char *) "cdir /opt/EDTpcd and chdir c:\\edt\\pcd failed");
                return NULL;
            }
        }

        switch (configure_board)
        {
            case STM1_RATE:
                configFile = "pcd_config/stm1_frm.cfg";
                rate_str = "STM1_RATE";
                break;
            case STM4_RATE:
                configFile = "pcd_config/stm4_frm.cfg";
                rate_str = "STM4_RATE";
                break;
            case STM16_RATE:
                configFile = "pcd_config/stm16_frm.cfg";
                rate_str = "STM16_RATE";
                break;
            case STM64_RATE:
                configFile = "pcd_config/stm64_frm.cfg";
                rate_str = "STM64_RATE";
                break;
            default:
                edt_msg(EDT_MSG_FATAL, "edt_sdh_board_setup() illegal second argument:\n\tMust be one of ATTACH_TO_CURRENT, STM1_RATE, STM4_RATE, or STM16_RATE\n");
                tmp = chdir(cwd);
                free(cwd);
                return NULL;
        }


        /*
         * Load base and mezzanine bitfies and set up demux configuration.
         */
        //if (initpcd_file((char *)"pcd_config/stm1_frm.cfg", unitNo, 0, 0))
        {
            char cmd[128];
            sprintf(cmd, "./initpcd -u %d -f %s", unitNo, configFile);
            if (edt_system(cmd))
            {
                edt_perror(configFile);
                tmp = chdir(cwd);
                free(cwd);
                return NULL;
            }
        }

        /* Chdir back to original directory */
        tmp = chdir(cwd);
    }
    else
    {
        rate_str = "ATTACH_TO_CURRENT";
    }

    if ((edt_p = edt_open((char *)"pcd", unitNo)) == NULL)
    {
        edt_perror((char *)"edt_open");
        return NULL;
    }

    /*
     * Second, allocate and populate an edt_sdh_t structure to return.
     */
    if ((sdh_p = (edt_sdh_t *) calloc(1, sizeof(edt_sdh_t))) == NULL)
    {
        edt_perror((char *) "calloc");
        return NULL;
    }

    sdh_p->edt_p = edt_p;

    /* TODO: get DMA channel and E1 configuration plus demux status */
    sdh_p->unitNo = unitNo;
    sdh_p->e1buf_version = edt_intfc_read(edt_p, 0x7C) >> 4;
    printf("e1 buffer structure version 0x%x\n", sdh_p->e1buf_version);
    sdh_p->m_numRingBufs = 8;
    sdh_p->m_ringBufSize = 32 * 1024 *
        ((sdh_p->e1buf_version == 0) ? sizeof(edt_sdh_e1_buf_t) : sizeof(edt_sdh_e1_buf_v2_t));

        

    if (configure_board)
    {
        edt_disable_channels(sdh_p->edt_p, 0xffffffff);
        edt_flush_fifo(sdh_p->edt_p);
    }

    return sdh_p;
}


int
edt_sdh_release_board(edt_sdh_t *sdh_p)
{
    if (sdh_p == NULL)
        return -1;

    if (sdh_p->edt_p != NULL)
    {
        edt_close(sdh_p->edt_p);
    }

    free(sdh_p);

    return 0;
}

int
edt_sdh_set_ring_buffer_size_number(edt_sdh_t *sdh_p, int bufsize, int numbufs)
{
    if (sdh_p == NULL)
        return -1;

    sdh_p->m_ringBufSize = bufsize;
    sdh_p->m_numRingBufs = numbufs;

    return 0;
}


int
edt_sdh_channel_disable(edt_sdh_t *sdh_p, int channel)
{
    if ((sdh_p != NULL) && (sdh_p->edt_p != NULL))
    {
        edt_disable_channel(sdh_p->edt_p, channel);
        return 0;
    }
    else
        return -1;
}

int
edt_sdh_channel_enable(edt_sdh_t *sdh_p, int channel)
{
    if ((sdh_p != NULL) && (sdh_p->edt_p != NULL))
    {
        edt_enable_channel(sdh_p->edt_p, channel);
        return 0;
    }
    else
        return -1;
}

int
edt_sdh_board_set_clock_to_system_time(edt_sdh_t *sdh_p)
{
    if ((sdh_p != NULL) && (sdh_p->edt_p != NULL))
    {
        /* New code from Steve's edt_ss_time.c */
        EdtDev *edt_p = sdh_p->edt_p;

        int         test_cal = 0;
        int     test_zero = 0;
        int     setup = 0;
        int     set_time = 1;
        int     showtimes = 0;
        int     auto_adjust = 0;
        int     adjust_value = 0;
        int     auto_measure = 0;
        int     set_adjust = 0;
        int     disable_adj = 0;
        int     enable_adj = 0;
        int     auto_secs = 5;
        int     interval = 1000;
        int     launch_checker = 0;
        int     set_time_error = 0;
        int     time_error = 1; /* seconds */
        double  stable_adj = 0;
        EdtTimeController controller;
        u_int base = EDT_SSTM_COUNTS & 0xff0000;

        memset(&controller,0,sizeof(controller));
        controller.adjustment_scalar = 2;
        controller.adjust_sample = 60;
        controller.max_error = 200;
        controller.tolerance = 20;
        controller.loops = 1;
        controller.check_interval = 600;
        controller.active = 1;

        if (edt_p->devid == PE8LX16_ID     ||
                edt_p->devid == PE8LX32_ID ||
                edt_p->devid == PE8G2V7_ID ||
                edt_p->devid == PE4AMC16_ID)
            base = 0x10ff0000;

        edt_init_time_controller(&controller, edt_p, base);

        edt_sstm_set_to_sys(&controller);

        return 0;
    }
    else
    {
        return -1;
    }
}

int
edt_sdh_start_stm1_to_e1_channel(edt_sdh_t *sdh_p, int stm1, int channel, int callbackControl, int ( *e1_callback ) ( void * e1buf, void *auxArg ), void *callbackArg, int loops)
{
    // No timeout
    edt_sdh_start_stm1_to_e1_channel_timeout(sdh_p, stm1, channel, callbackControl, e1_callback, callbackArg, loops, NULL, 0, 0);
}

int
edt_sdh_start_stm1_to_e1_channel_timeout(edt_sdh_t *sdh_p, int stm1, int channel, int callbackControl, int ( *e1_callback ) ( void * e1buf, void *auxArg ), void *callbackArg, int loops, int ( *timeout_callback ) ( edt_sdh_t * sdh_p, int channel), int timeout, int timeout_ok)
{
    int loop, i, done = 0;
    // edt_sdh_e1_buf_t *e1buf;
    u_char *e1buf;
    int buffers_running;
    int e1buf_size = (sdh_p->e1buf_version == 0) ? sizeof(edt_sdh_e1_buf_t) : sizeof(edt_sdh_e1_buf_v2_t);
    int e1s_per_ringBuffer = (sdh_p->m_ringBufSize / e1buf_size);
        

    static int bufferOffset = 0, init = 1;

printf("sdh %p stm1 %x chan %d\n", sdh_p, stm1, channel);

    printf("unit %d chan %d stm1 %d numRingBufs %d ringBufSize %d\n", sdh_p->unitNo, channel, stm1, sdh_p->m_numRingBufs, sdh_p->m_ringBufSize);
    if ((sdh_p->stm1[channel].edt_p = edt_open_channel((char *)"pcd", sdh_p->unitNo, channel)) == NULL)
    {
        edt_perror((char *)"edt_open_channel");
        return -1;
    }

    // TODO
    edt_indirect_reg_write(sdh_p->stm1[channel].edt_p, (0x000086 | (channel << 12)), stm1);
    printf("stm1 map to dma channel reg %06x:  %02x\n\n", (0x000086 | (channel << 12)),
        edt_indirect_reg_read(sdh_p->stm1[channel].edt_p, (0x000086 | (channel << 12))));

    edt_set_timeout_ok(sdh_p->stm1[channel].edt_p, timeout_ok);
    edt_set_rtimeout(sdh_p->stm1[channel].edt_p, timeout);

    sdh_p->current_stm1 = stm1;
    sdh_p->current_channel = channel;
    edt_sdh_channel_disable(sdh_p, channel);
    edt_msleep(100);

    edt_configure_ring_buffers(sdh_p->stm1[channel].edt_p, sdh_p->m_ringBufSize, sdh_p->m_numRingBufs, EDT_READ, NULL);
    edt_flush_channel(sdh_p->stm1[channel].edt_p, channel) ;         /* Flush the channel burst fifo */
    edt_start_buffers(sdh_p->stm1[channel].edt_p, sdh_p->m_numRingBufs);
    buffers_running = sdh_p->m_numRingBufs;
    edt_flush_channel(sdh_p->stm1[channel].edt_p, channel) ;         /* Flush the channel burst fifo */

    printf("loops %d\n", loops);
    //edt_msleep(4000);


    sdh_p->stm1[channel].active = 1;
    edt_sdh_channel_enable(sdh_p, channel);


    for (loop = 0; !done && (sdh_p->stm1[channel].active) && (loops == 0 || loop < loops); ++loop)
    {
        if (e1buf = edt_wait_for_buffers(sdh_p->stm1[channel].edt_p, 1))
        {
            int status;
            if (timeout_callback != NULL)
                status = edt_get_wait_status(sdh_p->stm1[channel].edt_p);
            else
                status = EDT_WAIT_OK;


            switch (status)
            {
              case EDT_WAIT_TIMEOUT:
              case EDT_WAIT_OK_TIMEOUT:
                {
                    done = timeout_callback(sdh_p, channel);
                }
                break;


              case EDT_WAIT_OK:
                {
                    -- buffers_running;

                    if (callbackControl == CALLBACK_PER_E1_FRAME)
                    {
                        for (i = 0; i < e1s_per_ringBuffer; ++i)
                        {
                            //printf("e1s_per_buf %d e1_time_secs %d\n", e1s_per_ringBuffer,
                                //edt_sdh_e1_buf_time_secs(sdh_p, (e1buf + (e1buf_size * i))));
                            (void) (*e1_callback)(e1buf + (e1buf_size * i), callbackArg);
                        }
                    }
                    else if (callbackControl == CALLBACK_PER_RING_BUFFER)
                    {
                        (void) (*e1_callback)(e1buf, callbackArg);
                    }

                    edt_start_buffers(sdh_p->stm1[channel].edt_p, 1);
                    ++ buffers_running;

                }
                break;


            }
        }
    }

    while (buffers_running > 0)
    {
        (void) edt_wait_for_buffers(sdh_p->stm1[channel].edt_p, 1);
        -- buffers_running;
    }

    edt_msleep(100);

    edt_disable_ring_buffers(sdh_p->stm1[channel].edt_p);

    return 0;
}

int
edt_sdh_stop_stm1_to_e1_channel(edt_sdh_t *sdh_p, int stm1)
{

    if (sdh_p == NULL || stm1 < 0 || stm1 > 15)
        return -1;

    sdh_p->stm1[stm1].active = 0;

    return 0;
}

u_char
edt_indirect_reg_read(EdtDev *edt_p, u_int addr)
{
    return edt_reg_read(edt_p, INDREG_1BYTE | (addr & 0xffffff));
}

void
edt_indirect_reg_write(EdtDev *edt_p, u_int addr, u_char val)
{
    edt_reg_write(edt_p, INDREG_1BYTE | (addr & 0xffffff), val);
}


int
edt_sdh_loss_of_light(edt_sdh_t *sdh_p)
{
    int chanStatusReg = 0x22;
    int lol = edt_intfc_read(sdh_p->edt_p, chanStatusReg);

    return (lol & 0x10);
}
int
edt_sdh_loss_of_light_input_0(edt_sdh_t *sdh_p)
{
    int chanStatusReg = 0x22;
    int lol = edt_intfc_read(sdh_p->edt_p, chanStatusReg);

    return (lol & 0x10);
}
int
edt_sdh_loss_of_light_input_1(edt_sdh_t *sdh_p)
{
    int chanStatusReg = 0x32;
    int lol = edt_intfc_read(sdh_p->edt_p, chanStatusReg);

    return (lol & 0x10);
}


int
edt_sdh_stm_is_framed(edt_sdh_t *sdh_p)
{
    int chanReceiveStatusReg = 0x94;
    int framed = edt_intfc_read(sdh_p->edt_p, chanReceiveStatusReg);

    return (framed & 0x01);
}
int
edt_sdh_stm_is_framed_input_0(edt_sdh_t *sdh_p)
{
    int chanReceiveStatusReg = 0x94;
    int framed = edt_intfc_read(sdh_p->edt_p, chanReceiveStatusReg);

    return (framed & 0x01);
}
int
edt_sdh_stm_is_framed_input_1(edt_sdh_t *sdh_p)
{
    int chanReceiveStatusReg = 0xD4;
    int framed = edt_intfc_read(sdh_p->edt_p, chanReceiveStatusReg);

    return (framed & 0x01);
}


int
edt_sdh_reg_read_stm1_status(edt_sdh_t *sdh_p, u_char *result)
{
    u_char stm1;

    if (sdh_p == NULL || result == NULL)
        return -1;

    for (stm1 = 0; stm1 < 16; ++stm1)
        result[stm1] = edt_indirect_reg_read(sdh_p->edt_p, 0x000080 | (stm1 << 12));

    return 0;
}

u_char
edt_sdh_reg_read_vc4vc3_b3_error_count(edt_sdh_t *sdh_p, int channel, u_short *result)
{
    int vc4vc3;
    int au43pl;

    memset(result, 0, sizeof(u_short) * 3);

    /* Get the second AU4/3 Pointer Low Register to determine 1 * VC4 or 3 * VC3 */
    au43pl  =  edt_indirect_reg_read(sdh_p->edt_p, 0x000108 | (channel << 12));

    for (vc4vc3 = 0; vc4vc3 < 3; ++vc4vc3)
    {
        result[vc4vc3]  =  edt_indirect_reg_read(sdh_p->edt_p, 0x000182 | (channel << 12) | (vc4vc3 << 3));
        result[vc4vc3] |= (edt_indirect_reg_read(sdh_p->edt_p, 0x000183 | (channel << 12) | (vc4vc3 << 3)) << 8);

        if (au43pl == 0xff)  /* Single VC4, so done */
            break;
    }

    return au43pl;
}

u_char
edt_sdh_reg_read_vc4vc3_MF_indicator(edt_sdh_t *sdh_p, int channel, u_char *result)
{
    int vc4vc3;
    int au43pl;

    memset(result, 0, sizeof(u_char) * 3);

    /* Get the second AU4/3 Pointer Low Register to determine 1 * VC4 or 3 * VC3 */
    au43pl  =  edt_indirect_reg_read(sdh_p->edt_p, 0x000108 | (channel << 12));

    for (vc4vc3 = 0; vc4vc3 < 3; ++vc4vc3)
    {
        result[vc4vc3]  =  edt_indirect_reg_read(sdh_p->edt_p, 0x000185 | (channel << 12) | (vc4vc3 << 3));

        if (au43pl == 0xff)  /* Single VC4, so done */
            break;
    }

    return au43pl;
}

int
edt_sdh_reg_read_E4_frame_status(edt_sdh_t *sdh_p, u_char *result)
{
    u_char channel;

    if (sdh_p == NULL || result == NULL)
        return -1;

    memset(result, 0, sizeof(u_char) * 16);

    for (channel = 0; channel < 16; ++channel)
        result[channel] = edt_indirect_reg_read(sdh_p->edt_p, 0x000200 | (channel << 12));

    return 0;
}

int
edt_sdh_reg_set_E4_frame_disable(edt_sdh_t *sdh_p, int channel, int disable)
{
    int arg = (disable) ? 1 : 0;

    if (sdh_p == NULL || channel < 0 || channel > 15)
        return -1;

    edt_indirect_reg_write(sdh_p->edt_p, 0x000210 | (channel << 12), arg);

    return 0;
}

int
edt_sdh_reg_read_E3_frame_status(edt_sdh_t *sdh_p, int channel, u_char *result)
{
    int e3;

    if (sdh_p == NULL || result == NULL || channel < 0 || channel > 15)
        return -1;

    memset(result, 0, sizeof(u_char) * 4);

    for (e3 = 0; e3 < 4; ++e3)
        result[e3] = edt_indirect_reg_read(sdh_p->edt_p, 0x000280 | (channel << 12) | (e3 << 5));

    return 0;
}

int
edt_sdh_reg_read_E2_frame_status(edt_sdh_t *sdh_p, int channel, u_char *result)
{
    int e3, e2;

    if (sdh_p == NULL || result == NULL || channel < 0 || channel > 15)
        return -1;

    memset(result, 0, sizeof(u_char) * 16);

    for (e3 = 0; e3 < 4; ++e3)
    {
        for (e2 = 0; e2 < 4; ++e2)
        {
            result[(e3 << 2) | e2] = edt_indirect_reg_read(sdh_p->edt_p, 0x000300 | (channel << 12) | (e3 << 5) | (e2 << 2));
        }
    }

    return 0;
}

u_char
edt_sdh_reg_read_E1_frame_status(edt_sdh_t *sdh_p, int channel, u_char *result)
{
    int e3, e2, e1;
    int tug3, tug2, vc12;
    u_char e3_frame_stat;

    memset(result, 0, sizeof(u_char) * 64);

    /* Read the lowest numbered E3 frame status register to determine E4/3 path or TUG2 path */
    e3_frame_stat = edt_indirect_reg_read(sdh_p->edt_p, 0x000280 | (channel << 12));

    if (e3_frame_stat & 1)
    {
        /* E4/3 path */

        for (e3 = 0; e3 < 4; ++e3)
        {
            for (e2 = 0; e2 < 4; ++e2)
            {
                for (e1 = 0; e1 < 4; ++e1)
                {
                    int e321 = (e3 << 5) | (e2 << 2) | e1;
                    int e321_index = (e3 * 16) + (e2 * 4) + e1;

                    result[e321_index] = 
                        edt_indirect_reg_read(sdh_p->edt_p, 0x000380 | (channel << 12) | e321);
                }
            }
        }
    }
    else
    {
        /* TUG2 path */

        for (tug3 = 0; tug3 < 3; ++tug3)
        {
            for (tug2 = 0; tug2 < 7; ++tug2)
            {
                for (vc12 = 0; vc12 < 3; ++vc12)
                {
                    int tug3_2vc12 = (tug3 << 5) | (tug2 << 2) | vc12;
                    int tug3_2vc12_index = (tug3 * 21) + (tug2 * 3) + vc12;

                    result[tug3_2vc12_index] = 
                        edt_indirect_reg_read(sdh_p->edt_p, 0x000380 | (channel << 12) | tug3_2vc12);
                }
            }
        }
    }
        
    return e3_frame_stat;
}

int
edt_sdh_reg_set_E1_frame_disable(edt_sdh_t *sdh_p, int channel, int disable)
{
    int arg = (disable) ? 1 : 0;
    int i;

    if (sdh_p == NULL || channel < 0 || channel > 15)
        return -1;

    for (i = 0; i < 128; ++i)
        edt_indirect_reg_write(sdh_p->edt_p, 0x000400 | (channel << 12) | i, arg);

    return 0;
}


int
edt_sdh_reg_read_vc3_b3_error_count(edt_sdh_t *sdh_p, int channel, u_short *result)
{
    int vc3;

    if (sdh_p == NULL || result == NULL || channel < 0 || channel > 15)
        return -1;

    memset(result, 0, sizeof(u_short) * 3);

    for (vc3 = 0; vc3 < 3; ++vc3)
    {
        result[vc3]  =  edt_indirect_reg_read(sdh_p->edt_p, 0x000582 | (channel << 12) | (vc3 << 3));
        result[vc3] |= (edt_indirect_reg_read(sdh_p->edt_p, 0x000583 | (channel << 12) | (vc3 << 3)) << 8);
    }

    return 0;
}

int
edt_sdh_reg_read_vc3_signal_label(edt_sdh_t *sdh_p, int channel, u_char *result)
{
    int vc3;

    if (sdh_p == NULL || result == NULL || channel < 0 || channel > 15)
        return -1;

    memset(result, 0, sizeof(u_char) * 3);

    for (vc3 = 0; vc3 < 3; ++vc3)
    {
        result[vc3]  =  edt_indirect_reg_read(sdh_p->edt_p, 0x000584 | (channel << 12) | (vc3 << 3));
    }

    return 0;
}

u_char
edt_sdh_reg_read_vc4vc3_path_overhead(edt_sdh_t *sdh_p, int channel, u_char *result)
{
    int vc4vc3, poh;
    int au43pl;

    memset(result, 0, sizeof(u_char) * 27);

    /* Get the second AU4/3 Pointer Low Register to determine 1 * VC4 or 3 * VC3 */
    au43pl  =  edt_indirect_reg_read(sdh_p->edt_p, 0x000108 | (channel << 12));

    for (vc4vc3 = 0; vc4vc3 < 3; ++vc4vc3)
    {
        for (poh = 0; poh < 9; ++poh)
        {
            result[(vc4vc3*9) + poh]  =  edt_indirect_reg_read(sdh_p->edt_p, 0x000800 | (channel << 12) | (vc4vc3 << 4) | poh);

            if (au43pl == 0xff)  /* Single VC4, so done */
                break;
        }
    }

    return au43pl;
}

int
edt_sdh_reg_read_tu3vc3_path_overhead(edt_sdh_t *sdh_p, int channel, u_char *result)
{
    int vc3, poh;

    if (sdh_p == NULL || result == NULL || channel < 0 || channel > 15)
        return -1;

    memset(result, 0, sizeof(u_char) * 27);

    for (vc3 = 0; vc3 < 3; ++vc3)
    {
        for (poh = 0; poh < 9; ++poh)
        {
            result[(vc3*9) + poh]  =  edt_indirect_reg_read(sdh_p->edt_p, 0x000880 | (channel << 12) | (vc3 << 4) | poh);
        }
    }

    return 0;
}

int
edt_sdh_reg_read_vc12_path_overhead(edt_sdh_t *sdh_p, int channel, u_char *result)
{
    int tug3vc3, tug2, vc12, poh;

    if (sdh_p == NULL || result == NULL || channel < 0 || channel > 15)
        return -1;

    memset(result, 0, sizeof(u_char) * 252);

    for (tug3vc3 = 0; tug3vc3 < 3; ++tug3vc3)
    {
        for (tug2 = 0; tug2 < 7; ++tug2)
        {
            for (vc12 = 0; vc12 < 3; ++vc12)
            {
                for (poh = 0; poh < 4; ++poh)
                {
                    result[(tug3vc3*84) + (tug2*12) + (vc12*3) + poh] = 
                        edt_indirect_reg_read(sdh_p->edt_p, 0x000A00 | (channel << 12) | (tug3vc3 << 7) | (tug2 << 4) | (vc12 << 2) | poh);
                }
            }
        }
    }

    return 0;
}

// e1 buf access routines which select v1 vs. v2 e1 data formats
u_int
edt_sdh_e1_buf_time_secs(edt_sdh_t *sdh_p, void *e1buf_p)
{
    if (sdh_p->e1buf_version == 0)
    {
        edt_sdh_e1_buf_t *p = (edt_sdh_e1_buf_t *) e1buf_p;
        return p->e1_status.time_secs;
        
    }
    else if (sdh_p->e1buf_version == 1)
    {
        edt_sdh_e1_buf_v2_t *p = (edt_sdh_e1_buf_v2_t *) e1buf_p;
        return p->e1_status.time_secs;
    }
    else
        return -1;
}

u_int
edt_sdh_e1_buf_time_fsecs(edt_sdh_t *sdh_p, void *e1buf_p)
{
    if (sdh_p->e1buf_version == 0)
    {
        edt_sdh_e1_buf_t *p = (edt_sdh_e1_buf_t *) e1buf_p;
        return p->e1_status.time_fsecs;
        
    }
    else if (sdh_p->e1buf_version == 1)
    {
        edt_sdh_e1_buf_v2_t *p = (edt_sdh_e1_buf_v2_t *) e1buf_p;
        return p->e1_status.time_fsecs;
    }
    else
        return -1;
}

u_int
edt_sdh_e1_buf_e1_number(edt_sdh_t *sdh_p, void *e1buf_p)
{
    if (sdh_p->e1buf_version == 0)
    {
        edt_sdh_e1_buf_t *p = (edt_sdh_e1_buf_t *) e1buf_p;
        return p->e1_status.e1_number;
        
    }
    else if (sdh_p->e1buf_version == 1)
    {
        edt_sdh_e1_buf_v2_t *p = (edt_sdh_e1_buf_v2_t *) e1buf_p;
        return p->e1_status.e1_number;
    }
    else
        return -1;
}

u_int
edt_sdh_e1_buf_odd_frame(edt_sdh_t *sdh_p, void *e1buf_p)
{
    if (sdh_p->e1buf_version == 0)
    {
        edt_sdh_e1_buf_t *p = (edt_sdh_e1_buf_t *) e1buf_p;
        return p->e1_status.odd_frame;
        
    }
    else if (sdh_p->e1buf_version == 1)
    {
        edt_sdh_e1_buf_v2_t *p = (edt_sdh_e1_buf_v2_t *) e1buf_p;
        return p->e1_status.odd_frame;
    }
    else
        return -1;
}

u_int
edt_sdh_e1_buf_frame_lock(edt_sdh_t *sdh_p, void *e1buf_p)
{
    if (sdh_p->e1buf_version == 0)
    {
        edt_sdh_e1_buf_t *p = (edt_sdh_e1_buf_t *) e1buf_p;
        return p->e1_status.frame_lock;
        
    }
    else if (sdh_p->e1buf_version == 1)
    {
        edt_sdh_e1_buf_v2_t *p = (edt_sdh_e1_buf_v2_t *) e1buf_p;
        return p->e1_status.frame_lock;
    }
    else
        return -1;
}

u_int
edt_sdh_e1_buf_length(edt_sdh_t *sdh_p, void *e1buf_p)
{
    if (sdh_p->e1buf_version == 0)
    {
        return -1;
    }
    else if (sdh_p->e1buf_version == 1)
    {
        edt_sdh_e1_buf_v2_t *p = (edt_sdh_e1_buf_v2_t *) e1buf_p;
        return p->e1_status.length;
    }
    else
        return -1;
}

u_int
edt_sdh_e1_buf_e1_tag(edt_sdh_t *sdh_p, void *e1buf_p)
{
    if (sdh_p->e1buf_version == 0)
    {
        return -1;
    }
    else if (sdh_p->e1buf_version == 1)
    {
        edt_sdh_e1_buf_v2_t *p = (edt_sdh_e1_buf_v2_t *) e1buf_p;
        return p->e1_status.e1_tag;
    }
    else
        return -1;
}

u_int
edt_sdh_e1_buf_vc12_buf(edt_sdh_t *sdh_p, void *e1buf_p)
{
    if (sdh_p->e1buf_version == 0)
    {
        return -1;
        
    }
    else if (sdh_p->e1buf_version == 1)
    {
        edt_sdh_e1_buf_v2_t *p = (edt_sdh_e1_buf_v2_t *) e1buf_p;
        return p->e1_status.vc12_buf;
    }
    else
        return -1;
}

u_char *
edt_sdh_e1_buf(edt_sdh_t *sdh_p, void *e1buf_p)
{
    if (sdh_p->e1buf_version == 0)
    {
        edt_sdh_e1_buf_t *p = (edt_sdh_e1_buf_t *) e1buf_p;
        return p->e1_buf;
        
    }
    else if (sdh_p->e1buf_version == 1)
    {
        edt_sdh_e1_buf_v2_t *p = (edt_sdh_e1_buf_v2_t *) e1buf_p;
        return p->e1_buf;
    }
    else
        return NULL;
}

---