RIOT/drivers/slipdev/slipdev.c

/*
 * Copyright (C) 2017 Freie Universität Berlin
 *
 * This file is subject to the terms and conditions of the GNU Lesser
 * General Public License v2.1. See the file LICENSE in the top level
 * directory for more details.
 */

/**
 * @{
 *
 * @file
 * @author  Martine Lenders <mlenders@inf.fu-berlin.de>
 */

#include <errno.h>
#include <string.h>

#include "log.h"
#include "slipdev.h"

#define ENABLE_DEBUG    (0)
#include "debug.h"

#define SLIP_END               (0xc0U)
#define SLIP_ESC               (0xdbU)
#define SLIP_END_ESC           (0xdcU)
#define SLIP_ESC_ESC           (0xddU)

static int _send(netdev_t *dev, const struct iovec *vector, unsigned count);
static int _recv(netdev_t *dev, void *buf, size_t len, void *info);
static int _init(netdev_t *dev);
static void _isr(netdev_t *dev);
static int _get(netdev_t *dev, netopt_t opt, void *value, size_t max_len);
static int _set(netdev_t *dev, netopt_t opt, const void *value,
                size_t value_len);

static const netdev_driver_t slip_driver = {
    .send = _send,
    .recv = _recv,
    .init = _init,
    .isr = _isr,
    .get = _get,
    .set = _set,
};

void slipdev_setup(slipdev_t *dev, const slipdev_params_t *params)
{
    /* set device descriptor fields */
    memcpy(&dev->config, params, sizeof(dev->config));
    dev->inbytes = 0U;
    dev->inesc = 0U;
    dev->netdev.driver = &slip_driver;
}

static inline void _add_byte_to_inbuf(slipdev_t *dev, uint8_t byte)
{
    if (ringbuffer_add_one(&dev->inbuf, byte) < 0) {
        dev->inbytes++;
    }
}

static void _slip_rx_cb(void *arg, uint8_t data)
{
    slipdev_t *dev = arg;

    if ((data == SLIP_END) && (dev->netdev.event_callback != NULL)) {
        int idx = cib_put(&dev->pktfifo_idx);
        if (idx >= 0) {
            dev->netdev.event_callback((netdev_t *)dev, NETDEV_EVENT_ISR);
            dev->pktfifo[idx] = dev->inbytes;
        }
        else {
            /* can't handover packet => dropping it */
            ringbuffer_remove(&dev->inbuf, dev->inbytes);
        }
        dev->inbytes = 0;
    }
    else if (dev->inesc) {
        dev->inesc = 0U;
        uint8_t actual = (data == SLIP_END_ESC) ? SLIP_END :
                         ((data == SLIP_ESC_ESC) ? SLIP_ESC : 0);

        switch (data) {
            case SLIP_END_ESC:
            case SLIP_ESC_ESC:
                _add_byte_to_inbuf(dev, actual);
                break;
            default:
                break;
        }
    }
    else if (data == SLIP_ESC) {
        dev->inesc = 1U;
    }
    else {
        _add_byte_to_inbuf(dev, data);
    }
}

static int _init(netdev_t *netdev)
{
    slipdev_t *dev = (slipdev_t *)netdev;

    DEBUG("slipdev: initializing device %p on UART %i with baudrate %" PRIu32 "\n",
          (void *)dev, dev->config.uart, dev->config.baudrate);
    /* initialize buffers */
    ringbuffer_init(&dev->inbuf, dev->rxmem, sizeof(dev->rxmem));
    cib_init(&dev->pktfifo_idx, SLIPDEV_PKTFIFO_SIZE);
    if (uart_init(dev->config.uart, dev->config.baudrate, _slip_rx_cb,
                  dev) != UART_OK) {
        LOG_ERROR("slipdev: error initializing UART %i with baudrate %" PRIu32 "\n",
                  dev->config.uart, dev->config.baudrate);
        return -ENODEV;
    }
    return 0;
}

static inline void _write_byte(slipdev_t *dev, uint8_t byte)
{
    uart_write(dev->config.uart, &byte, 1);
}

static int _send(netdev_t *netdev, const struct iovec *vector, unsigned count)
{
    slipdev_t *dev = (slipdev_t *)netdev;
    int bytes = 0;

    DEBUG("slipdev: sending vector of length %u\n", count);
    for (unsigned i = 0; i < count; i++) {
        uint8_t *data = vector[i].iov_base;

        for (unsigned j = 0; j < vector[i].iov_len; j++, data++) {
            switch(*data) {
                case SLIP_END:
                    /* escaping END byte*/
                    _write_byte(dev, SLIP_ESC);
                    _write_byte(dev, SLIP_END_ESC);
                    break;
                case SLIP_ESC:
                    /* escaping ESC byte*/
                    _write_byte(dev, SLIP_ESC);
                    _write_byte(dev, SLIP_ESC_ESC);
                    break;
                default:
                    _write_byte(dev, *data);
            }
            bytes++;
        }
    }
    _write_byte(dev, SLIP_END);
    return bytes;
}

static int _recv(netdev_t *netdev, void *buf, size_t len, void *info)
{
    slipdev_t *dev = (slipdev_t *)netdev;
    int res, idx = cib_peek(&dev->pktfifo_idx);

    (void)info;
    if (idx < 0) {
        return -EFAULT;
    }
    if (buf == NULL) {
        if (len > 0) {
            /* drop packet */
            cib_get(&dev->pktfifo_idx);
            /* and remove data */
            res = ringbuffer_remove(&dev->inbuf, len);
        }
        else {
            res = dev->pktfifo[idx];
        }
    }
    else if (len < dev->pktfifo[idx]) {
        res = -ENOBUFS;
    }
    else {
        size_t bytes = dev->pktfifo[cib_get(&dev->pktfifo_idx)];
        bytes = ringbuffer_get(&dev->inbuf, buf, bytes);
        res = bytes;
    }
    return res;
}

static void _isr(netdev_t *netdev)
{
    DEBUG("slipdev: handling ISR event\n");
    if (netdev->event_callback != NULL) {
        DEBUG("slipdev: event handler set, issuing RX_COMPLETE event\n");
        netdev->event_callback(netdev, NETDEV_EVENT_RX_COMPLETE);
    }
}

static int _get(netdev_t *netdev, netopt_t opt, void *value, size_t max_len)
{
    (void)netdev;
    (void)value;
    (void)max_len;
    switch (opt) {
        case NETOPT_IS_WIRED:
            return 1;
        case NETOPT_DEVICE_TYPE:
            assert(max_len == sizeof(uint16_t));
            *((uint16_t *)value) = NETDEV_TYPE_SLIP;
            return sizeof(uint16_t);
        default:
            return -ENOTSUP;
    }
}

static int _set(netdev_t *netdev, netopt_t opt, const void *value,
                size_t value_len)
{
    (void)netdev;
    (void)opt;
    (void)value;
    (void)value_len;
    return -ENOTSUP;
}

/** @} */