roboot/boot/xmodem.c

Go to the documentation of this file.

/* ================================================================================ *//* ================================================================================= */


#include "xmodem.h"
#include "roboot.h"
#include "roboot_if_comm.h"

// xmodem control characters
#define SOH         0x01
#define STX         0x02
#define EOT         0x04
#define ACK         0x06
#define NAK         0x15
#define CAN         0x18
#define CTRLZ       0x1A

// pointers to stream I/O functions
static void (*xmodemOut)(uint8_t c);
static int16_t (*xmodemIn)(void);

static uint8_t *packet_buf;

// xmodem CRC/checksum error checking
static uint8_t xmodemCrcCheck(const uint8_t *buffer, uint16_t size, const uint8_t *crc_buf);

// extra stream I/O functions
// get incoming character (wait for timeout), timeout expressed in 1/10 s
static int16_t xmodemInTime(uint8_t timeout);

// flush incoming character stream
static void xmodemInFlush(void);

// get len bytes with default timeout
static uint8_t xmodemGetBytes(uint8_t* dst, uint16_t len);


/**************************************************************************************************\
\**************************************************************************************************/
void xmodemInit(uint8_t *buf, void (*sendbyte_func)(uint8_t c), int16_t (*getbyte_func)(void))
{
    // assign function pointers
    xmodemOut = sendbyte_func;
    xmodemIn = getbyte_func;
    packet_buf = buf;
}


/**************************************************************************************************\
\**************************************************************************************************/
int8_t xmodemReceive(int8_t (*process_packet)(uint32_t size, uint8_t **new_buf))
{
    uint16_t pktsize;
    int16_t c;
    uint8_t header[2];      // packet header without packet start byte, only packet length
    uint8_t crc[2];
    uint8_t response;
    uint8_t seqnum;
    uint8_t retry;

    pktsize = 0;
    response = 'C';
    seqnum = 1;
    retry = XMODEM_RETRY_LIMIT;

    xmodemInFlush();


    while (retry)
    {
        // solicit a connection/packet
        xmodemOut(response);

        // wait for start of packet
        if ((c = xmodemInTime(XMODEM_TIMEOUT_DELAY)) >= 0)
        {
            switch(c)
            {
            case SOH:
                pktsize = 128;
                break;
            case STX:
                pktsize = 1024;
                break;
            case EOT:
                xmodemOut(ACK);
                xmodemInFlush();
                xmodemOut(ACK);
                // completed transmission normally
                return XMODEM_TRANSMISSION_OK;
            case CAN:
                if ((c = xmodemInTime(XMODEM_TIMEOUT_DELAY)) == CAN)
                {
                    xmodemInFlush();
                    xmodemOut(ACK);
                    // transaction cancelled by remote node
                    return XMODEM_ERROR_REMOTECANCEL;
                }
            default:
                break;
            }
        }
        else
        {
            // timed out, try again
            // no need to flush because receive buffer is already empty
            retry--;
            continue;
        }

        if (0 == pktsize)
        {
            xmodemInFlush();
            if (response != 'C')
            {
                response = NAK;
            }
            retry--;
            continue;
        }

        // got SOH/STX, start packet processing

        if ((response = xmodemGetBytes(header, sizeof(header))))
        {
            retry--;
            continue;
        }

        // try to get packet data
        if ((response = xmodemGetBytes(packet_buf, pktsize)))
        {
            retry--;
            continue;
        }

        // try to get packet CRC
        if ((response = xmodemGetBytes(crc, sizeof(crc))))
        {
            retry--;
            continue;
        }

        // got whole packet
        // check validity of the just received packet
        // header[0] - sequence number
        // header[1] - negated sequence number
        if (((uint8_t) (header[0] ^ header[1]) == (uint8_t) 0xFFU) &&       // sequence number was transmitted w/o error
            xmodemCrcCheck(packet_buf, pktsize, crc))               // packet is not corrupted
        {
            // is this the packet we were waiting for?
            if (header[0] == seqnum)
            {
                // process data
                if (process_packet(pktsize, &packet_buf) < 0)
                {
                    // transmission cancelling requested
                    // probably error detected in received content
                    xmodemInFlush();
                    xmodemOut(CAN);
                    xmodemOut(CAN);
                    xmodemOut(CAN);
                    return XMODEM_ERROR_DATAPROCESSING;
                }

                // next sequence number
                seqnum++;
                // reset retries
                retry = XMODEM_RETRY_LIMIT;
                pktsize = 0;
                // reply with ACK
                response = ACK;
                continue;
            }
            else if (header[0] == (uint8_t)(seqnum-1))
            {
                // this is a retransmission of the last packet
                // ACK and move on
                response = ACK;
                retry = XMODEM_RETRY_LIMIT;
                pktsize = 0;
                continue;
            }
            else
            {
                // we are completely out of sync
                // cancel transmission
                xmodemInFlush();
                xmodemOut(CAN);
                xmodemOut(CAN);
                xmodemOut(CAN);
                return XMODEM_ERROR_OUTOFSYNC;
            }
        }
        else
        {
            // packet was corrupt
            // NAK it and try again
            retry--;
            xmodemInFlush();
            response = NAK;
        }
    }

    // exceeded retry count
    xmodemInFlush();
    xmodemOut(CAN);
    xmodemOut(CAN);
    xmodemOut(CAN);
    return XMODEM_ERROR_RETRYEXCEED;
}


/**************************************************************************************************\
\**************************************************************************************************/
static inline uint16_t crc_xmodem_update(uint16_t crc, uint8_t data)
{
    uint8_t i;

    crc ^= (uint16_t)data << 8;

    for (i=0; i < 8; i++)
    {
        if (crc & 0x8000)
        {
            crc = (crc << 1) ^ 0x1021;
        }
        else
        {
            crc <<= 1;
        }
    }

    return crc;
}


/**************************************************************************************************\
\**************************************************************************************************/
static uint8_t xmodemCrcCheck(const uint8_t *buffer, uint16_t size, const uint8_t *crc_buf)
{
    uint16_t crc = 0;
    uint16_t pktcrc = ((uint16_t)crc_buf[0] << 8) + (uint16_t)crc_buf[1];
    // do CRC checksum
    while (size--)
    {
        crc = crc_xmodem_update(crc, *buffer++);
    }

    // check checksum against packet
    if (crc == pktcrc)
    {
        return 1;
    }

    return 0;
}


/**************************************************************************************************\
\**************************************************************************************************/
static int16_t xmodemInTime(uint8_t timeout)
{
    while (timeout--)
    {
        uint16_t rerties;
        rerties = (uint16_t) (100000UL / (2500000UL / XMODEM_BAUD_RATE));

        // 1/10 s loop
        while (rerties--)
        {
            int16_t c;

            if ((c = xmodemIn()) >= 0)
            {
                return c;
            }

            // wait one forth  a time for one byte
            uint8_t i = (uint8_t) (250000UL / XMODEM_BAUD_RATE);
            while (i--)
            {
                MCUBusyDelay();
            }
        }
    }

    return -1;
}


/**************************************************************************************************\
\**************************************************************************************************/
static void xmodemInFlush(void)
{
    while (xmodemInTime(XMODEM_FLUSH_TIMEOUT) >= 0)
    {
        ;
    }
}

/**************************************************************************************************\
\**************************************************************************************************/
static uint8_t xmodemGetBytes(uint8_t* dst, uint16_t len)
{
    int16_t c;

    while (len--)
    {
        if ((c = xmodemInTime(XMODEM_TIMEOUT_DELAY)) >= 0)
        {
            *dst++ = c;
        }
        else
        {
            // timed out, try again
            return NAK;
        }
    }

    return 0;
}

---