libedt_timing.c

Go to the documentation of this file.

/* #pragma ident "@(#)libedt_timing.c   1.28 04/22/11 EDT" */

#include <time.h>
//#include "libedt_timing.h"
#include "edtinc.h"

/* Timing register offsets: */
/*      Time Dist. Board:       0x60 (default) */
/*      MSDV:                   0xa4 */
/*      Net10G:                 0xac */
/*      SRXL-2:                 0x5c */
/*      CLINK:                  0x31 */


u_int
edt_spi_reg_read(EdtDev *edt_p, u_int desc)
{
    u_int adj_desc = desc;
    u_int retval;

    if (edt_p->spi_reg_base)
    {
        adj_desc &= ~0x000000ff;
        adj_desc |= edt_p->spi_reg_base + (desc & 0x0f);
    }
    retval= edt_reg_read(edt_p, adj_desc);
    return retval;
}

void
edt_spi_reg_write(EdtDev *edt_p, u_int desc, u_int val)
{
    u_int adj_desc = desc;

    if (edt_p->spi_reg_base)
    {
        adj_desc &= ~0x000000ff;
        adj_desc |= edt_p->spi_reg_base + (desc & 0x0f);
    }
    edt_reg_write(edt_p, adj_desc, val);
}

EdtDev *
edt_spi_open(char *edt_interface, int unit, u_int spi_reg_base)   /* edt_interface is "pcd" or "pdv" or "pe53b", etc. */
{
    EdtDev *edt_p = NULL;

    printf("Trying PCD unit %d\n", unit);
    edt_p = edt_open(edt_interface, unit);

    if (edt_p != NULL)
    {
        edt_p->spi_reg_base = spi_reg_base;
        if ((edt_spi_reg_read(edt_p, SPI_STAT_CTRL) & 0x80) != 0) /* Master clears this bit. */
        {
            fputs("Warning:  SPI unit is not master device; may be read-only\n", stderr);
            fflush(stderr);
        }

    }

    return edt_p;
}

int
edt_spi_close(EdtDev *edt_p)
{
    return edt_close(edt_p);
}

u_char
edt_spi_get_byte(EdtDev *edt_p)
{
    u_char ch;

    while (edt_spi_get_stat(edt_p) & FIFO_IN_EMPTY)
    {
        edt_usec_busywait(10);                                  /* Each character takes about 8 usec */
    }
    ch = edt_spi_reg_read(edt_p, SPI_DATA);
    edt_spi_reg_write(edt_p, SPI_STROBE, 0x00); /* SPI fifo must be strobed after each read */
    return ch;
}

u_char
edt_spi_get_byte_nointr(EdtDev *edt_p)
{
    u_char ch;

    while (edt_spi_get_stat(edt_p) & FIFO_IN_EMPTY)
    {
        edt_usec_busywait(10);                                  /* Each character takes about 8 usec */
    }
    ch = edt_spi_reg_read(edt_p, SPI_DATA);
    edt_spi_reg_write(edt_p, SPI_STROBE, 0x00); /* SPI fifo must be strobed after each read */
    return ch;
}

int
edt_spi_get_binary(EdtDev *edt_p, unsigned char *byte)
{
    u_char ch;

    if ((ch = edt_spi_get_byte(edt_p)) == 0)
        return -1;

    if (ch == '\\')             /* Translate \\ to '\' and \z to zero */
    {
        if ((ch = edt_spi_get_byte(edt_p)) == 0)
            return -1;

        if (ch == '\\')
        {
            *byte = ch;
        }
        else if (ch == 'z')
        {
            *byte = 0;
        }
        else
            return -1;
    }
    else
        *byte = ch;

    return 0;
}


int
edt_spi_fifo_empty(EdtDev *edt_p)
{
    if (edt_spi_get_stat(edt_p) & FIFO_IN_EMPTY)
        return 1;
    else
        return 0;
}

u_char
edt_spi_put_byte(EdtDev *edt_p, u_char ch)
{
    edt_spi_reg_write(edt_p, SPI_DATA, ch);             /* Write byte to SPI fifo */
    return ch;
}

u_char
edt_spi_get_stat(EdtDev *edt_p)
{
    return edt_spi_reg_read(edt_p, SPI_STAT_CTRL);
}

void
edt_spi_flush_fifo(EdtDev *edt_p)
{
    edt_spi_reg_write(edt_p, SPI_STAT_CTRL, FIFO_RESET);        /* Reset SPI fifo */
    edt_spi_reg_write(edt_p, SPI_STAT_CTRL, 0x00);
}

static int
spi_pkt_crc_fails(u_char *pkt)                                  /* Check packet CRC.  Return 0 for success, nonzero for failure. */
{
    int i;
    u_char len = pkt[1], ckl, ckh;                              /* Second byte is data length. */

    len += 2;                                                   /* Include cmd and len bytes in CRC computation. */

    ckl = pkt[0];
    ckh = pkt[1];

    for (i = 2; i < len; i += 2)
    {
        ckl ^= pkt[i];
        ckh ^= pkt[i+1];
    }

    ckl = ~ckl;
    ckh = ~ckh;

    return ((ckl ^ pkt[len]) | (ckh ^ pkt[len+1]));
}

int
edt_spi_get_pkt(EdtDev *edt_p, u_char *pkt)
{
    int i, len;
    u_char byte;

    if (edt_spi_get_binary(edt_p, &byte) == -1)                 /* Get Packet command byte */
        return -1;
    pkt[0] = byte;

    if (edt_spi_get_binary(edt_p, &byte) == -1)                 /* Get Packet data length byte */
        return -1;
    len = pkt[1] = byte;

    if (len > 60)
    {
        puts("Packet length check failed");
        puts("\nPacket dump:");
        printf("        cmd 0x%x len %d ", pkt[0], pkt[1]);
        puts("\n");

        return -1;
    }

    /* Capture the packet data and CRC bytes and check the packet against the CRC. */
    for (i = 2; i < len + 4; ++i)                               /* command byte + length byte + data bytes + two CRC bytes */
    {
        if (edt_spi_get_binary(edt_p, &byte) == -1)             /* Get Packet data or CRC byte */
            return -1;
        pkt[i] = byte;
    }

    if (spi_pkt_crc_fails(pkt))                                 /* Check packet CRC.  Return -1 if failure. */
    {
        puts("crc check failed");
        puts("\nPacket dump:");
        printf("        cmd 0x%x len %d ", pkt[0], len);
        for (i = 2; i < len + 4; ++i)                           /* command byte + length byte + data bytes + two CRC bytes */
            printf(" pkt[%d] 0x%x ", i, pkt[i]);
        puts("\n");

        return -1;
    }
    else
    {
        return len;
    }
}

uint64_t
edt_spi_get_time_pkt(EdtDev *edt_p)
{
    u_char command, len;
    uint64_t tval = 0;
    static u_char pkt[64];
    int i, retval;

    if ((retval = edt_spi_get_pkt(edt_p, pkt)) == -1)
        return 0;

    command = pkt[0];
    len     = pkt[1];

    switch (command)
    {
     case SPI_TIMECODE_PKT:
     case SPI_TIMECODE_PKT_RAW:
     {
        for (i = 0; i < len; ++i)
            tval |= pkt[i+2] << (8 * i);

        tval |= (uint64_t) command << 56;
        break;
     }
    }

    return tval;
}

void
edt_spi_display_time(EdtDev *edt_p, int loops)
{
    int loop, i, done = 0, retry = 0;
    u_char inchar[2] = {0, 0};                  /* Single char NULL terminated string */
    uint64_t irigb_lltime;                      /* irigb time in 64-bit unix-based time format */
    unsigned int irigb_time;    /* CPU word-size irigb and computer unix time format */
    time_t timevar, computer_time;
    u_char stat;                                /* SPI stat register */
    int new_timestamp_format = 0;                               /* New SPI interface from msp430? */

    for (loop = 0; !done && (loop < loops || loops == 0); /* loop incremented only upon timestamp input */ ) {
        /* Wait for SPI input fifo to become non-empty */
        if ((((stat = edt_spi_get_stat(edt_p)) & 0x02)) != 0x02) {
            irigb_lltime = 0;
            
            for (i = 0; i < 16; ++i) {          /* Capture 16 ascii-hex bytes */
                inchar[0] = edt_spi_get_byte(edt_p);

                if (inchar[0] == 0) {           /* If user had hit Control-C, break out of loop back to prompt */
                    done = 1;
                    break;
                }
                else if (inchar[0] == SPI_PKT_START) {  /* Forward compatibility (after July '08 V3.0 firmware) */
                    irigb_lltime = edt_spi_get_time_pkt(edt_p);
                    if (irigb_lltime == 0)                      /* packet reception error */
                    {
                        puts("Searching for timestamp packet version...");
                        retry = 1;
                    }

                    new_timestamp_format = 1;
                    break;
                }
                else {                                  /* Backward compatibility (before July '08 V3.0 firmware) */
                    irigb_lltime |= (uint64_t) (strtoul((const char *)inchar, NULL, 16) << (i*4));
                    new_timestamp_format = 0;
                }
            }

            if (retry)
            {
                retry = 0;
                continue;
            }
            else
            {

                    ++loop;

                    irigb_time = (unsigned int) irigb_lltime;
                    timevar = irigb_time;
                    computer_time = time(NULL);

                    if (irigb_time)
                    {
                        char *p;
                        static char computer_str[32];
                        static char irigb_str[32];
                        int timecode_format = (int) (irigb_lltime >> 56) & 0xff;

                        p = ctime((const time_t *) &computer_time);
                        strcpy(computer_str, p);

                        if ((p = ctime((const time_t *) &timevar)) == NULL)
                        {
                            puts("Flushing SPI fifo...");
                            edt_spi_flush_fifo(edt_p);
                        }
                        else
                        {
                            strcpy(irigb_str, p);

                            printf("\n\nPolling loop %d (%s spi format; press Control-C to end loop)\n\n", loop, (new_timestamp_format) ? "new" : "old");
                            if (timecode_format == SPI_TIMECODE_PKT_RAW)
                            {
                                ts_raw_t *raw_p = (ts_raw_t *) & irigb_time;

                                printf("IRIG-B BCD values:  seconds %d minutes %d hours %d day-of-year %d year %d\n",
                                    raw_p->seconds,
                                    raw_p->minutes,
                                    raw_p->hours,
                                    raw_p->days,
                                    raw_p->years);
                            }
                            else
                            {
                                printf("IRIG-B seconds:    %010d;  TZ corrected:  ", (int) irigb_time);
                                fputs(irigb_str, stdout);
                            }
                            printf("Computer seconds:  %010d;  TZ corrected:  ", (int) computer_time);
                            fputs(computer_str, stdout);
                            fflush(stdout);
                        }
                    }
            }

            if (new_timestamp_format == 0)
                edt_spi_flush_fifo(edt_p);
        }
    }
}


int
edt_spi_invoke_flash_loader(EdtDev *edt_p)
{
    int ch, ret = 0, tries = 0;

    do
    {
        puts("Attention msp430:");
        edt_spi_put_byte(edt_p, 0x80);                   /* Send flash-loader escape */
        edt_msleep(100);

        edt_spi_flush_fifo(edt_p);
        edt_msleep(100);

        /* Empty the FIFO of any leftover bytes */
        /*while ( !edt_spi_fifo_empty(edt_p) ) */
        /*{ */
            /*ch = edt_spi_get_byte(edt_p); */
        /*} */

        edt_spi_put_byte(edt_p, 0x80);                   /* Verify that flash-loader is running */
        edt_msleep(100);

        ch = edt_spi_get_byte(edt_p);

        ++ tries;                                       /* Retry 20 times */
        if (ch != 0x90)
        {
            if (ch == 0xa0)
                printf("Expected ACK (0x90) got NAK (0x%x)\n", ch);
            else
                printf("Expected ACK (0x90) got 0x%x\n", ch);
        }

    } while (ch != 0x90 && ch != 0xa0 && tries < 20);

    if (ch == 0x90)
    {
        puts("Flash programming mode started.\n");
    }
    else
    {
        puts("Flash programming mode faulted.  Insure that firmware is properly loaded.\n");
        ret = -1;
    }

    /* Empty the FIFO of any leftover bytes */
    while ( !edt_spi_fifo_empty(edt_p) )
    {
        volatile int dummy = edt_spi_get_byte(edt_p);
        printf("Flushing SPI FIFO (0x%x left in fifo)\n", dummy);
        edt_spi_flush_fifo(edt_p);
    }


    return ret;
}

char *
edt_spi_putstr(EdtDev *edt_p, char *str)
{
    char *p;

    for (p = str; *p != '\0'; ++p)
    {
        while ((edt_spi_get_stat(edt_p) & FIFO_OUT_EMPTY) == 0)         /* TODO: change this when almost-full flag is available */
            edt_usec_busywait(10);                                      /* Each character takes about 8 usec */

        edt_spi_put_byte(edt_p, *p);
    }

    return str;
}

u_char
edt_crc16_lowbyte(u_char *buf, int len)                 /* Create 16-bit CRC low byte */
{
    int i;
    u_char result;

    result = buf[0];

    for (i = 2; i < len; i += 2)
        result ^= buf[i];

    return ~result;
}

u_char
edt_crc16_highbyte(u_char *buf, int len)                        /* Create 16-bit CRC high byte */
{
    int i;
    u_char result;

    result = buf[1];

    for (i = 2; i < len; i += 2)
        result ^= buf[i+1];

    return ~result;
}

void
edt_spi_send_binary(EdtDev *edt_p, u_char val)                          /* Send binary data to SPI; escape zeros and escape character. */
{
    u_char esc_char = 0;

    if (val == '\0')                                            /* Translate zero bytes to '\' + 'z' */
    {
        val = '\\';
        esc_char = 'z';
    }
    else if (val == '\\')                                       /* Translate '\' bytes to '\' + '\' */
        esc_char = '\\';

    while ((edt_spi_get_stat(edt_p) & FIFO_OUT_FULL))           /* Wait for room in SPI output fifo      */
        edt_usec_busywait(9);                                   /* Each character takes about 8 usec */

    edt_spi_put_byte(edt_p, val);

    if (esc_char)
    {
        while ((edt_spi_get_stat(edt_p) & FIFO_OUT_FULL))       /* Wait for room in SPI output fifo */
            edt_usec_busywait(9);                               /* Each character takes about 8 usec */

        edt_spi_put_byte(edt_p, esc_char);
    }
}

void
edt_spi_send_packet(EdtDev *edt_p, u_char *cmdbuf)
{
    int i;

    u_char cmd = cmdbuf[0];
    u_char len = cmdbuf[1];

    edt_spi_send_binary(edt_p, 0x82);                                   /* Start of packet */
    edt_spi_send_binary(edt_p, cmd);
    edt_spi_send_binary(edt_p, len);

    for (i = 0; i < len; ++i)
        edt_spi_send_binary(edt_p, cmdbuf[i+2]);

    edt_spi_send_binary(edt_p, edt_crc16_lowbyte(cmdbuf, len+2));       /* 16-bit CRC low byte */
    edt_spi_send_binary(edt_p, edt_crc16_highbyte(cmdbuf,len+2));       /* 16-bit CRC high byte */
}

int
edt_get_timecode_version(EdtDev *edt_p)
{
    int retval;

    edt_set_timecode_enable(edt_p, 0);
    edt_msleep(2000);
    edt_spi_flush_fifo(edt_p);

    edt_spi_put_byte(edt_p, 0x81);
    retval = edt_spi_get_byte(edt_p);

    edt_set_timecode_enable(edt_p, 1);

    return retval & 0x7f;
}

int
edt_set_timecode_enable(EdtDev *edt_p, int enable)
{
    u_char cmdbuf[16];
    int loopcount = 0;

    cmdbuf[0] = SPI_TIMECODE_EN;
    cmdbuf[1] = 1;                              /* length = 1 data byte. */
    cmdbuf[2] = enable;                         /* Enable timestamp. */
    edt_spi_send_packet(edt_p, cmdbuf);

    while ((cmdbuf[0] = edt_spi_get_byte(edt_p)) != ACK && cmdbuf[0] != NAK)
    {
        if (++loopcount > 1000)
        {
            fprintf(stderr, "timeout waiting for ACK or NAK; edt_set_timecode_enable %d failed\n", enable);
            return -1;
        }
    }


    if (cmdbuf[0] != ACK)
    {
        fprintf(stderr, "edt_set_timecode_enable %d failed on NAK\n", enable);
        return -1;
    }
    else
        return 0;
}

void
edt_set_timecode_raw(EdtDev *edt_p, int enable)
{
    u_char cmdbuf[16];

    cmdbuf[0] = SPI_TIMECODE_RAW;
    cmdbuf[1] = 1;                              /* length = 1 data byte. */
    cmdbuf[2] = enable;                         /* Enable timestamp. */
    edt_spi_send_packet(edt_p, cmdbuf);

    while ((cmdbuf[0] = edt_spi_get_byte(edt_p)) != ACK && cmdbuf[0] != NAK)
        ;

    if (cmdbuf[0] != ACK)
        puts("Got NAK; command fault.\n");
    else
        puts("Got ACK; command succeeded.\n");

    edt_set_timecode_seconds_offset(edt_p, (enable) ? 0 : 1);
}

void
edt_set_timecode_seconds_offset(EdtDev *edt_p, u_int seconds)
{
    u_char cmdbuf[16];

    cmdbuf[0] = SPI_TIMECODE_ADD_SECONDS;
    cmdbuf[1] = 1;                              /* length = 1 data byte. */
    cmdbuf[2] = seconds;                        /* Seconds to offset timestamp */
    edt_spi_send_packet(edt_p, cmdbuf);

    while ((cmdbuf[0] = edt_spi_get_byte(edt_p)) != ACK && cmdbuf[0] != NAK)
        ;

    if (cmdbuf[0] != ACK)
        puts("Got NAK; command fault.\n");
}

void
edt_set_msp430_clock(EdtDev *edt_p, int clock_sel, int clock_hz)
{
    u_char cmdbuf[16];

    printf("\nSet msp430 clock source to %d and hz rate to %d:\n\n", clock_sel, clock_hz);

    if (clock_sel != 0 && clock_sel != 1)
    {
        puts("Illegal clock_sel value: must be 0 for internal or 1 for external clock.\n");
        return;
    }

    cmdbuf[0] = SPI_CLK_SELECT;
    cmdbuf[1] = 5;                                      /* Length: 5 data bytes:  byte(1) clock select value; bytes[2-5] integer32 clock hz value */
    cmdbuf[2] = clock_sel;                              /* Select internal or external clock */

    if (clock_sel == 0 && clock_hz != 1000000 && clock_hz != 8000000
                       && clock_hz != 12000000 && clock_hz != 16000000)
    {
        puts("Illegal internal clock_hz value.  Must be one of:");
        puts("1000000, 8000000, 12000000 or 16000000.\n");
        return;

    }

    cmdbuf[3] = clock_hz & 0xff;
    cmdbuf[4] = (clock_hz >> 8) & 0xff;
    cmdbuf[5] = (clock_hz >> 16) & 0xff;
    cmdbuf[6] = (clock_hz >> 24) & 0xff;

    edt_set_timecode_enable(edt_p, 0);                  /* Disable 1 Hz timecode */
    edt_spi_send_packet(edt_p, cmdbuf);

    while ((cmdbuf[0] = edt_spi_get_byte(edt_p)) != ACK && cmdbuf[0] != NAK)
        printf("Waiting for ACK/NAK got %x\n", cmdbuf[0]);

    if (cmdbuf[0] != ACK)
        puts("Got NAK; command fault.\n");
    else
        puts("Got ACK; command succeeded.\n");

    edt_set_timecode_enable(edt_p, 1);                  /* Enable 1 Hz timecode */

    edt_spi_flush_fifo(edt_p);
}

void
edt_enable_timecode_programmable_year(EdtDev *edt_p, u_short year)
{
    u_char cmdbuf[16];

    cmdbuf[0] = SPI_ENABLE_PROGRAMMED_YEAR;
    cmdbuf[1] = 2;                              /* length = 2 data bytes. */
    cmdbuf[2] = year & 0xff;                    /* LSByte of year */
    cmdbuf[3] = (year >> 8) & 0xff;             /* MSByte of year */
    edt_spi_send_packet(edt_p, cmdbuf);

    while ((cmdbuf[0] = edt_spi_get_byte(edt_p)) != ACK && cmdbuf[0] != NAK)
        ;

    if (cmdbuf[0] != ACK)
        puts("Got NAK; command fault.\n");
}

void
edt_disable_timecode_programmable_year(EdtDev *edt_p)
{
    u_char cmdbuf[16];

    cmdbuf[0] = SPI_DISABLE_PROGRAMMED_YEAR;
    cmdbuf[1] = 0;                              /* No data */
    edt_spi_send_packet(edt_p, cmdbuf);

    while ((cmdbuf[0] = edt_spi_get_byte(edt_p)) != ACK && cmdbuf[0] != NAK)
        ;

    if (cmdbuf[0] != ACK)
        puts("Got NAK; command fault.\n");
}

---