You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

349 lines
8.6 KiB

/*
* Copyright (C) 2016 Kaspar Schleiser <kaspar@schleiser.de>
*
* 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.
*/
/**
* @ingroup driver_ethos
* @{
*
* @file
* @brief Implementation of a simple ethernet-over-serial driver
*
* @author Kaspar Schleiser <kaspar@schleiser.de>
*
* @}
*/
#include <assert.h>
#include <errno.h>
#include <string.h>
#include "random.h"
#include "ethos.h"
#include "periph/uart.h"
#include "tsrb.h"
#include "net/netdev2.h"
#include "net/netdev2_eth.h"
#include "net/eui64.h"
#include "net/ethernet.h"
#ifdef USE_ETHOS_FOR_STDIO
#include "uart_stdio.h"
#endif
#define ENABLE_DEBUG (0)
#include "debug.h"
static void _get_mac_addr(netdev2_t *dev, uint8_t* buf);
static void ethos_isr(void *arg, char c);
const static netdev2_driver_t netdev2_driver_ethos;
static const uint8_t _esc_esc[] = {ETHOS_ESC_CHAR, (ETHOS_ESC_CHAR ^ 0x20)};
static const uint8_t _esc_delim[] = {ETHOS_ESC_CHAR, (ETHOS_FRAME_DELIMITER ^ 0x20)};
void ethos_setup(ethos_t *dev, uart_t uart, uint32_t baudrate, uint8_t *buf, size_t bufsize)
{
dev->netdev.driver = &netdev2_driver_ethos;
dev->uart = uart;
dev->state = WAIT_FRAMESTART;
dev->framesize = 0;
dev->frametype = 0;
dev->last_framesize = 0;
tsrb_init(&dev->inbuf, (char*)buf, bufsize);
mutex_init(&dev->out_mutex);
uint32_t a = random_uint32();
memcpy(dev->mac_addr, (char*)&a, 4);
a = random_uint32();
memcpy(dev->mac_addr+4, (char*)&a, 2);
dev->mac_addr[0] &= (0x2); /* unset globally unique bit */
dev->mac_addr[0] &= ~(0x1); /* set unicast bit*/
uart_init(uart, baudrate, ethos_isr, (void*)dev);
uint8_t frame_delim = ETHOS_FRAME_DELIMITER;
uart_write(dev->uart, &frame_delim, 1);
ethos_send_frame(dev, dev->mac_addr, 6, ETHOS_FRAME_TYPE_HELLO);
}
static void _reset_state(ethos_t *dev)
{
dev->state = WAIT_FRAMESTART;
dev->frametype = 0;
dev->framesize = 0;
}
static void _handle_char(ethos_t *dev, char c)
{
switch (dev->frametype) {
case ETHOS_FRAME_TYPE_DATA:
case ETHOS_FRAME_TYPE_HELLO:
case ETHOS_FRAME_TYPE_HELLO_REPLY:
if (tsrb_add_one(&dev->inbuf, c) == 0) {
dev->framesize++;
} else {
//puts("lost frame");
dev->inbuf.reads = 0;
dev->inbuf.writes = 0;
_reset_state(dev);
}
break;
#ifdef USE_ETHOS_FOR_STDIO
case ETHOS_FRAME_TYPE_TEXT:
dev->framesize++;
uart_stdio_rx_cb(NULL, c);
#endif
}
}
static void _end_of_frame(ethos_t *dev)
{
switch(dev->frametype) {
case ETHOS_FRAME_TYPE_DATA:
if (dev->framesize) {
dev->last_framesize = dev->framesize;
dev->netdev.event_callback((netdev2_t*) dev, NETDEV2_EVENT_ISR, dev->netdev.isr_arg);
}
break;
case ETHOS_FRAME_TYPE_HELLO:
ethos_send_frame(dev, dev->mac_addr, 6, ETHOS_FRAME_TYPE_HELLO_REPLY);
/* fall through */
case ETHOS_FRAME_TYPE_HELLO_REPLY:
if (dev->framesize == 6) {
tsrb_get(&dev->inbuf, (char*)dev->remote_mac_addr, 6);
}
break;
}
_reset_state(dev);
}
static void ethos_isr(void *arg, char c)
{
ethos_t *dev = (ethos_t *) arg;
switch (dev->state) {
case WAIT_FRAMESTART:
if (c == ETHOS_FRAME_DELIMITER) {
_reset_state(dev);
dev->state = IN_FRAME;
}
break;
case IN_FRAME:
if (c == ETHOS_ESC_CHAR) {
dev->state = IN_ESCAPE;
}
else if (c == ETHOS_FRAME_DELIMITER) {
if (dev->framesize) {
_end_of_frame(dev);
}
}
else {
_handle_char(dev, c);
}
break;
case IN_ESCAPE:
switch (c) {
case (ETHOS_FRAME_DELIMITER ^ 0x20):
_handle_char(dev, ETHOS_FRAME_DELIMITER);
break;
case (ETHOS_ESC_CHAR ^ 0x20):
_handle_char(dev, ETHOS_ESC_CHAR);
break;
case (ETHOS_FRAME_TYPE_TEXT ^ 0x20):
dev->frametype = ETHOS_FRAME_TYPE_TEXT;
break;
case (ETHOS_FRAME_TYPE_HELLO ^ 0x20):
dev->frametype = ETHOS_FRAME_TYPE_HELLO;
break;
case (ETHOS_FRAME_TYPE_HELLO_REPLY ^ 0x20):
dev->frametype = ETHOS_FRAME_TYPE_HELLO_REPLY;
break;
}
dev->state = IN_FRAME;
break;
}
}
static void _isr(netdev2_t *netdev)
{
ethos_t *dev = (ethos_t *) netdev;
dev->netdev.event_callback((netdev2_t*) dev, NETDEV2_EVENT_RX_COMPLETE, NULL);
}
static int _init(netdev2_t *encdev)
{
ethos_t *dev = (ethos_t *) encdev;
(void)dev;
return 0;
}
static size_t iovec_count_total(const struct iovec *vector, int count)
{
size_t result = 0;
while(count--) {
result += vector->iov_len;
vector++;
}
return result;
}
static void _write_escaped(uart_t uart, uint8_t c)
{
uint8_t *out;
int n;
switch(c) {
case ETHOS_FRAME_DELIMITER:
out = (uint8_t*)_esc_delim;
n = 2;
break;
case ETHOS_ESC_CHAR:
out = (uint8_t*)_esc_esc;
n = 2;
break;
default:
out = &c;
n = 1;
}
uart_write(uart, out, n);
}
void ethos_send_frame(ethos_t *dev, const uint8_t *data, size_t len, unsigned frame_type)
{
uint8_t frame_delim = ETHOS_FRAME_DELIMITER;
if (!inISR()) {
mutex_lock(&dev->out_mutex);
}
else {
/* Send frame delimiter. This cancels the current frame,
* but enables in-ISR writes. */
uart_write(dev->uart, &frame_delim, 1);
}
/* send frame delimiter */
uart_write(dev->uart, &frame_delim, 1);
/* set frame type */
if (frame_type) {
uint8_t out[2] = { ETHOS_ESC_CHAR, (frame_type ^ 0x20) };
uart_write(dev->uart, out, 2);
}
/* send frame content */
while(len--) {
_write_escaped(dev->uart, *(uint8_t*)data++);
}
/* end of frame */
uart_write(dev->uart, &frame_delim, 1);
if (!inISR()) {
mutex_unlock(&dev->out_mutex);
}
}
static int _send(netdev2_t *netdev, const struct iovec *vector, int count)
{
ethos_t * dev = (ethos_t *) netdev;
(void)dev;
/* count total packet length */
size_t pktlen = iovec_count_total(vector, count);
/* lock line in order to prevent multiple writes */
mutex_lock(&dev->out_mutex);
/* send start-frame-delimiter */
uint8_t frame_delim = ETHOS_FRAME_DELIMITER;
uart_write(dev->uart, &frame_delim, 1);
/* send iovec */
while(count--) {
size_t n = vector->iov_len;
uint8_t *ptr = vector->iov_base;
while(n--) {
_write_escaped(dev->uart, *ptr++);
}
vector++;
}
uart_write(dev->uart, &frame_delim, 1);
mutex_unlock(&dev->out_mutex);
return pktlen;
}
static void _get_mac_addr(netdev2_t *encdev, uint8_t* buf)
{
ethos_t * dev = (ethos_t *) encdev;
memcpy(buf, dev->mac_addr, 6);
}
static int _recv(netdev2_t *netdev, char* buf, int len, void* info)
{
(void) info;
ethos_t * dev = (ethos_t *) netdev;
if (buf) {
if (len != dev->last_framesize) {
DEBUG("ethos _recv(): unmatched receive buffer size.");
return -1;
}
dev->last_framesize = 0;
if ((tsrb_get(&dev->inbuf, buf, len) != len)) {
DEBUG("ethos _recv(): inbuf doesn't contain enough bytes.");
return -1;
}
return len;
}
else {
return dev->last_framesize;
}
}
int _get(netdev2_t *dev, netopt_t opt, void *value, size_t max_len)
{
int res = 0;
switch (opt) {
case NETOPT_ADDRESS:
if (max_len < ETHERNET_ADDR_LEN) {
res = -EINVAL;
}
else {
_get_mac_addr(dev, (uint8_t*)value);
res = ETHERNET_ADDR_LEN;
}
break;
default:
res = netdev2_eth_get(dev, opt, value, max_len);
break;
}
return res;
}
/* netdev2 interface */
const static netdev2_driver_t netdev2_driver_ethos = {
.send = _send,
.recv = _recv,
.init = _init,
.isr = _isr,
.get = _get,
.set = netdev2_eth_set
};