blob: 17e3081f55ab6aff6e4a66bbec22dd85816d9bff [file] [log] [blame]
/*
* Copyright (c) 2022 Trackunit Corporation
*
* SPDX-License-Identifier: Apache-2.0
*/
#include <zephyr/net/ppp.h>
#include <zephyr/sys/crc.h>
#include <zephyr/modem/ppp.h>
#include <string.h>
#include <zephyr/logging/log.h>
LOG_MODULE_REGISTER(modem_ppp, CONFIG_MODEM_MODULES_LOG_LEVEL);
#define MODEM_PPP_STATE_ATTACHED_BIT (0)
#define MODEM_PPP_FRAME_TAIL_SIZE (2)
#define MODEM_PPP_CODE_DELIMITER (0x7E)
#define MODEM_PPP_CODE_ESCAPE (0x7D)
#define MODEM_PPP_VALUE_ESCAPE (0x20)
static uint16_t modem_ppp_fcs_init(uint8_t byte)
{
return crc16_ccitt(0xFFFF, &byte, 1);
}
static uint16_t modem_ppp_fcs_update(uint16_t fcs, uint8_t byte)
{
return crc16_ccitt(fcs, &byte, 1);
}
static uint16_t modem_ppp_fcs_final(uint16_t fcs)
{
return fcs ^ 0xFFFF;
}
static uint16_t modem_ppp_ppp_protocol(struct net_pkt *pkt)
{
if (net_pkt_family(pkt) == AF_INET) {
return PPP_IP;
}
if (net_pkt_family(pkt) == AF_INET6) {
return PPP_IPV6;
}
LOG_WRN("Unsupported protocol");
return 0;
}
static uint8_t modem_ppp_wrap_net_pkt_byte(struct modem_ppp *ppp)
{
uint8_t byte;
switch (ppp->transmit_state) {
case MODEM_PPP_TRANSMIT_STATE_IDLE:
LOG_WRN("Invalid transmit state");
return 0;
/* Writing header */
case MODEM_PPP_TRANSMIT_STATE_SOF:
ppp->transmit_state = MODEM_PPP_TRANSMIT_STATE_HDR_FF;
return MODEM_PPP_CODE_DELIMITER;
case MODEM_PPP_TRANSMIT_STATE_HDR_FF:
net_pkt_cursor_init(ppp->tx_pkt);
ppp->tx_pkt_fcs = modem_ppp_fcs_init(0xFF);
ppp->transmit_state = MODEM_PPP_TRANSMIT_STATE_HDR_7D;
return 0xFF;
case MODEM_PPP_TRANSMIT_STATE_HDR_7D:
ppp->tx_pkt_fcs = modem_ppp_fcs_update(ppp->tx_pkt_fcs, 0x03);
ppp->transmit_state = MODEM_PPP_TRANSMIT_STATE_HDR_23;
return MODEM_PPP_CODE_ESCAPE;
case MODEM_PPP_TRANSMIT_STATE_HDR_23:
if (net_pkt_is_ppp(ppp->tx_pkt) == true) {
ppp->transmit_state = MODEM_PPP_TRANSMIT_STATE_DATA;
} else {
ppp->tx_pkt_protocol = modem_ppp_ppp_protocol(ppp->tx_pkt);
ppp->transmit_state = MODEM_PPP_TRANSMIT_STATE_PROTOCOL_HIGH;
}
return 0x23;
/* Writing protocol */
case MODEM_PPP_TRANSMIT_STATE_PROTOCOL_HIGH:
byte = (ppp->tx_pkt_protocol >> 8) & 0xFF;
ppp->tx_pkt_fcs = modem_ppp_fcs_update(ppp->tx_pkt_fcs, byte);
if ((byte == MODEM_PPP_CODE_DELIMITER) || (byte == MODEM_PPP_CODE_ESCAPE) ||
(byte < MODEM_PPP_VALUE_ESCAPE)) {
ppp->tx_pkt_escaped = byte ^ MODEM_PPP_VALUE_ESCAPE;
ppp->transmit_state = MODEM_PPP_TRANSMIT_STATE_ESCAPING_PROTOCOL_HIGH;
return MODEM_PPP_CODE_ESCAPE;
}
ppp->transmit_state = MODEM_PPP_TRANSMIT_STATE_PROTOCOL_LOW;
return byte;
case MODEM_PPP_TRANSMIT_STATE_ESCAPING_PROTOCOL_HIGH:
ppp->transmit_state = MODEM_PPP_TRANSMIT_STATE_PROTOCOL_LOW;
return ppp->tx_pkt_escaped;
case MODEM_PPP_TRANSMIT_STATE_PROTOCOL_LOW:
byte = ppp->tx_pkt_protocol & 0xFF;
ppp->tx_pkt_fcs = modem_ppp_fcs_update(ppp->tx_pkt_fcs, byte);
if ((byte == MODEM_PPP_CODE_DELIMITER) || (byte == MODEM_PPP_CODE_ESCAPE) ||
(byte < MODEM_PPP_VALUE_ESCAPE)) {
ppp->tx_pkt_escaped = byte ^ MODEM_PPP_VALUE_ESCAPE;
ppp->transmit_state = MODEM_PPP_TRANSMIT_STATE_ESCAPING_PROTOCOL_LOW;
return MODEM_PPP_CODE_ESCAPE;
}
ppp->transmit_state = MODEM_PPP_TRANSMIT_STATE_DATA;
return byte;
case MODEM_PPP_TRANSMIT_STATE_ESCAPING_PROTOCOL_LOW:
ppp->transmit_state = MODEM_PPP_TRANSMIT_STATE_DATA;
return ppp->tx_pkt_escaped;
/* Writing data */
case MODEM_PPP_TRANSMIT_STATE_DATA:
net_pkt_read_u8(ppp->tx_pkt, &byte);
ppp->tx_pkt_fcs = modem_ppp_fcs_update(ppp->tx_pkt_fcs, byte);
if ((byte == MODEM_PPP_CODE_DELIMITER) || (byte == MODEM_PPP_CODE_ESCAPE) ||
(byte < MODEM_PPP_VALUE_ESCAPE)) {
ppp->tx_pkt_escaped = byte ^ MODEM_PPP_VALUE_ESCAPE;
ppp->transmit_state = MODEM_PPP_TRANSMIT_STATE_ESCAPING_DATA;
return MODEM_PPP_CODE_ESCAPE;
}
if (net_pkt_remaining_data(ppp->tx_pkt) == 0) {
ppp->transmit_state = MODEM_PPP_TRANSMIT_STATE_FCS_LOW;
}
return byte;
case MODEM_PPP_TRANSMIT_STATE_ESCAPING_DATA:
if (net_pkt_remaining_data(ppp->tx_pkt) == 0) {
ppp->transmit_state = MODEM_PPP_TRANSMIT_STATE_FCS_LOW;
} else {
ppp->transmit_state = MODEM_PPP_TRANSMIT_STATE_DATA;
}
return ppp->tx_pkt_escaped;
/* Writing FCS */
case MODEM_PPP_TRANSMIT_STATE_FCS_LOW:
ppp->tx_pkt_fcs = modem_ppp_fcs_final(ppp->tx_pkt_fcs);
byte = ppp->tx_pkt_fcs & 0xFF;
if ((byte == MODEM_PPP_CODE_DELIMITER) || (byte == MODEM_PPP_CODE_ESCAPE) ||
(byte < MODEM_PPP_VALUE_ESCAPE)) {
ppp->tx_pkt_escaped = byte ^ MODEM_PPP_VALUE_ESCAPE;
ppp->transmit_state = MODEM_PPP_TRANSMIT_STATE_ESCAPING_FCS_LOW;
return MODEM_PPP_CODE_ESCAPE;
}
ppp->transmit_state = MODEM_PPP_TRANSMIT_STATE_FCS_HIGH;
return byte;
case MODEM_PPP_TRANSMIT_STATE_ESCAPING_FCS_LOW:
ppp->transmit_state = MODEM_PPP_TRANSMIT_STATE_FCS_HIGH;
return ppp->tx_pkt_escaped;
case MODEM_PPP_TRANSMIT_STATE_FCS_HIGH:
byte = (ppp->tx_pkt_fcs >> 8) & 0xFF;
if ((byte == MODEM_PPP_CODE_DELIMITER) || (byte == MODEM_PPP_CODE_ESCAPE) ||
(byte < MODEM_PPP_VALUE_ESCAPE)) {
ppp->tx_pkt_escaped = byte ^ MODEM_PPP_VALUE_ESCAPE;
ppp->transmit_state = MODEM_PPP_TRANSMIT_STATE_ESCAPING_FCS_HIGH;
return MODEM_PPP_CODE_ESCAPE;
}
ppp->transmit_state = MODEM_PPP_TRANSMIT_STATE_EOF;
return byte;
case MODEM_PPP_TRANSMIT_STATE_ESCAPING_FCS_HIGH:
ppp->transmit_state = MODEM_PPP_TRANSMIT_STATE_EOF;
return ppp->tx_pkt_escaped;
/* Writing end of frame */
case MODEM_PPP_TRANSMIT_STATE_EOF:
ppp->transmit_state = MODEM_PPP_TRANSMIT_STATE_IDLE;
return MODEM_PPP_CODE_DELIMITER;
}
return 0;
}
static bool modem_ppp_is_byte_expected(uint8_t byte, uint8_t expected_byte)
{
if (byte == expected_byte) {
return true;
}
LOG_DBG("Dropping byte 0x%02hhx because 0x%02hhx was expected.", byte, expected_byte);
return false;
}
static void modem_ppp_process_received_byte(struct modem_ppp *ppp, uint8_t byte)
{
switch (ppp->receive_state) {
case MODEM_PPP_RECEIVE_STATE_HDR_SOF:
if (modem_ppp_is_byte_expected(byte, MODEM_PPP_CODE_DELIMITER)) {
ppp->receive_state = MODEM_PPP_RECEIVE_STATE_HDR_FF;
}
break;
case MODEM_PPP_RECEIVE_STATE_HDR_FF:
if (byte == MODEM_PPP_CODE_DELIMITER) {
break;
}
if (modem_ppp_is_byte_expected(byte, 0xFF)) {
ppp->receive_state = MODEM_PPP_RECEIVE_STATE_HDR_7D;
} else {
ppp->receive_state = MODEM_PPP_RECEIVE_STATE_HDR_SOF;
}
break;
case MODEM_PPP_RECEIVE_STATE_HDR_7D:
if (modem_ppp_is_byte_expected(byte, MODEM_PPP_CODE_ESCAPE)) {
ppp->receive_state = MODEM_PPP_RECEIVE_STATE_HDR_23;
} else {
ppp->receive_state = MODEM_PPP_RECEIVE_STATE_HDR_SOF;
}
break;
case MODEM_PPP_RECEIVE_STATE_HDR_23:
if (modem_ppp_is_byte_expected(byte, 0x23)) {
ppp->rx_pkt = net_pkt_rx_alloc_with_buffer(ppp->iface,
CONFIG_MODEM_PPP_NET_BUF_FRAG_SIZE, AF_UNSPEC, 0, K_NO_WAIT);
if (ppp->rx_pkt == NULL) {
LOG_WRN("Dropped frame, no net_pkt available");
ppp->receive_state = MODEM_PPP_RECEIVE_STATE_HDR_SOF;
break;
}
LOG_DBG("Receiving PPP frame");
ppp->receive_state = MODEM_PPP_RECEIVE_STATE_WRITING;
net_pkt_cursor_init(ppp->rx_pkt);
} else {
ppp->receive_state = MODEM_PPP_RECEIVE_STATE_HDR_SOF;
}
break;
case MODEM_PPP_RECEIVE_STATE_WRITING:
if (byte == MODEM_PPP_CODE_DELIMITER) {
LOG_DBG("Received PPP frame (len %zu)", net_pkt_get_len(ppp->rx_pkt));
/* Remove FCS */
net_pkt_remove_tail(ppp->rx_pkt, MODEM_PPP_FRAME_TAIL_SIZE);
net_pkt_set_ppp(ppp->rx_pkt, true);
if (net_recv_data(ppp->iface, ppp->rx_pkt) < 0) {
LOG_WRN("Net pkt could not be processed");
net_pkt_unref(ppp->rx_pkt);
}
ppp->rx_pkt = NULL;
/* Skip SOF because the delimiter may be omitted for successive frames. */
ppp->receive_state = MODEM_PPP_RECEIVE_STATE_HDR_FF;
break;
}
if (net_pkt_available_buffer(ppp->rx_pkt) == 1) {
if (net_pkt_alloc_buffer(ppp->rx_pkt, CONFIG_MODEM_PPP_NET_BUF_FRAG_SIZE,
AF_INET, K_NO_WAIT) < 0) {
LOG_WRN("Failed to alloc buffer");
net_pkt_unref(ppp->rx_pkt);
ppp->rx_pkt = NULL;
ppp->receive_state = MODEM_PPP_RECEIVE_STATE_HDR_SOF;
break;
}
}
if (byte == MODEM_PPP_CODE_ESCAPE) {
ppp->receive_state = MODEM_PPP_RECEIVE_STATE_UNESCAPING;
break;
}
if (net_pkt_write_u8(ppp->rx_pkt, byte) < 0) {
LOG_WRN("Dropped PPP frame");
net_pkt_unref(ppp->rx_pkt);
ppp->rx_pkt = NULL;
ppp->receive_state = MODEM_PPP_RECEIVE_STATE_HDR_SOF;
#if defined(CONFIG_NET_STATISTICS_PPP)
ppp->stats.drop++;
#endif
}
break;
case MODEM_PPP_RECEIVE_STATE_UNESCAPING:
if (net_pkt_write_u8(ppp->rx_pkt, (byte ^ MODEM_PPP_VALUE_ESCAPE)) < 0) {
LOG_WRN("Dropped PPP frame");
net_pkt_unref(ppp->rx_pkt);
ppp->rx_pkt = NULL;
ppp->receive_state = MODEM_PPP_RECEIVE_STATE_HDR_SOF;
#if defined(CONFIG_NET_STATISTICS_PPP)
ppp->stats.drop++;
#endif
break;
}
ppp->receive_state = MODEM_PPP_RECEIVE_STATE_WRITING;
break;
}
}
#if CONFIG_MODEM_STATS
static uint32_t get_transmit_buf_length(struct modem_ppp *ppp)
{
return ring_buf_size_get(&ppp->transmit_rb);
}
static void advertise_transmit_buf_stats(struct modem_ppp *ppp)
{
uint32_t length;
length = get_transmit_buf_length(ppp);
modem_stats_buffer_advertise_length(&ppp->transmit_buf_stats, length);
}
static void advertise_receive_buf_stats(struct modem_ppp *ppp, uint32_t length)
{
modem_stats_buffer_advertise_length(&ppp->receive_buf_stats, length);
}
#endif
static void modem_ppp_pipe_callback(struct modem_pipe *pipe, enum modem_pipe_event event,
void *user_data)
{
struct modem_ppp *ppp = (struct modem_ppp *)user_data;
switch (event) {
case MODEM_PIPE_EVENT_RECEIVE_READY:
k_work_submit(&ppp->process_work);
break;
case MODEM_PIPE_EVENT_OPENED:
case MODEM_PIPE_EVENT_TRANSMIT_IDLE:
k_work_submit(&ppp->send_work);
break;
default:
break;
}
}
static void modem_ppp_send_handler(struct k_work *item)
{
struct modem_ppp *ppp = CONTAINER_OF(item, struct modem_ppp, send_work);
uint8_t byte;
uint8_t *reserved;
uint32_t reserved_size;
int ret;
if (ppp->tx_pkt == NULL) {
ppp->tx_pkt = k_fifo_get(&ppp->tx_pkt_fifo, K_NO_WAIT);
}
if (ppp->tx_pkt != NULL) {
/* Initialize wrap */
if (ppp->transmit_state == MODEM_PPP_TRANSMIT_STATE_IDLE) {
ppp->transmit_state = MODEM_PPP_TRANSMIT_STATE_SOF;
}
/* Fill transmit ring buffer */
while (ring_buf_space_get(&ppp->transmit_rb) > 0) {
byte = modem_ppp_wrap_net_pkt_byte(ppp);
ring_buf_put(&ppp->transmit_rb, &byte, 1);
if (ppp->transmit_state == MODEM_PPP_TRANSMIT_STATE_IDLE) {
net_pkt_unref(ppp->tx_pkt);
ppp->tx_pkt = k_fifo_get(&ppp->tx_pkt_fifo, K_NO_WAIT);
break;
}
}
}
#if CONFIG_MODEM_STATS
advertise_transmit_buf_stats(ppp);
#endif
while (!ring_buf_is_empty(&ppp->transmit_rb)) {
reserved_size = ring_buf_get_claim(&ppp->transmit_rb, &reserved, UINT32_MAX);
ret = modem_pipe_transmit(ppp->pipe, reserved, reserved_size);
if (ret < 0) {
ring_buf_get_finish(&ppp->transmit_rb, 0);
break;
}
ring_buf_get_finish(&ppp->transmit_rb, (uint32_t)ret);
if (ret < reserved_size) {
break;
}
}
}
static void modem_ppp_process_handler(struct k_work *item)
{
struct modem_ppp *ppp = CONTAINER_OF(item, struct modem_ppp, process_work);
int ret;
ret = modem_pipe_receive(ppp->pipe, ppp->receive_buf, ppp->buf_size);
if (ret < 1) {
return;
}
#if CONFIG_MODEM_STATS
advertise_receive_buf_stats(ppp, ret);
#endif
for (int i = 0; i < ret; i++) {
modem_ppp_process_received_byte(ppp, ppp->receive_buf[i]);
}
k_work_submit(&ppp->process_work);
}
static void modem_ppp_ppp_api_init(struct net_if *iface)
{
const struct device *dev = net_if_get_device(iface);
struct modem_ppp *ppp = (struct modem_ppp *)dev->data;
net_ppp_init(iface);
net_if_flag_set(iface, NET_IF_NO_AUTO_START);
net_if_carrier_off(iface);
if (ppp->init_iface != NULL) {
ppp->init_iface(iface);
}
ppp->iface = iface;
}
static int modem_ppp_ppp_api_start(const struct device *dev)
{
return 0;
}
static int modem_ppp_ppp_api_stop(const struct device *dev)
{
return 0;
}
static int modem_ppp_ppp_api_send(const struct device *dev, struct net_pkt *pkt)
{
struct modem_ppp *ppp = (struct modem_ppp *)dev->data;
if (atomic_test_bit(&ppp->state, MODEM_PPP_STATE_ATTACHED_BIT) == false) {
return -EPERM;
}
/* Validate packet protocol */
if ((net_pkt_is_ppp(pkt) == false) && (net_pkt_family(pkt) != AF_INET) &&
(net_pkt_family(pkt) != AF_INET6)) {
return -EPROTONOSUPPORT;
}
/* Validate packet data length */
if (((net_pkt_get_len(pkt) < 2) && (net_pkt_is_ppp(pkt) == true)) ||
((net_pkt_get_len(pkt) < 1))) {
return -ENODATA;
}
net_pkt_ref(pkt);
k_fifo_put(&ppp->tx_pkt_fifo, pkt);
k_work_submit(&ppp->send_work);
return 0;
}
#if defined(CONFIG_NET_STATISTICS_PPP)
static struct net_stats_ppp *modem_ppp_ppp_get_stats(const struct device *dev)
{
struct modem_ppp *ppp = (struct modem_ppp *)dev->data;
return &ppp->stats;
}
#endif
#if CONFIG_MODEM_STATS
static uint32_t get_buf_size(struct modem_ppp *ppp)
{
return ppp->buf_size;
}
static void init_buf_stats(struct modem_ppp *ppp)
{
char iface_name[CONFIG_MODEM_STATS_BUFFER_NAME_SIZE - sizeof("_xx")];
char name[CONFIG_MODEM_STATS_BUFFER_NAME_SIZE];
int ret;
uint32_t size;
ret = net_if_get_name(ppp->iface, iface_name, sizeof(iface_name));
if (ret < 0) {
snprintk(iface_name, sizeof(iface_name), "ppp");
}
size = get_buf_size(ppp);
snprintk(name, sizeof(name), "%s_rx", iface_name);
modem_stats_buffer_init(&ppp->receive_buf_stats, name, size);
snprintk(name, sizeof(name), "%s_tx", iface_name);
modem_stats_buffer_init(&ppp->transmit_buf_stats, name, size);
}
#endif
const struct ppp_api modem_ppp_ppp_api = {
.iface_api.init = modem_ppp_ppp_api_init,
.start = modem_ppp_ppp_api_start,
.stop = modem_ppp_ppp_api_stop,
.send = modem_ppp_ppp_api_send,
#if defined(CONFIG_NET_STATISTICS_PPP)
.get_stats = modem_ppp_ppp_get_stats,
#endif
};
int modem_ppp_attach(struct modem_ppp *ppp, struct modem_pipe *pipe)
{
if (atomic_test_bit(&ppp->state, MODEM_PPP_STATE_ATTACHED_BIT) == true) {
return 0;
}
ppp->pipe = pipe;
modem_pipe_attach(pipe, modem_ppp_pipe_callback, ppp);
atomic_set_bit(&ppp->state, MODEM_PPP_STATE_ATTACHED_BIT);
return 0;
}
struct net_if *modem_ppp_get_iface(struct modem_ppp *ppp)
{
return ppp->iface;
}
void modem_ppp_release(struct modem_ppp *ppp)
{
struct k_work_sync sync;
struct net_pkt *pkt;
if (atomic_test_and_clear_bit(&ppp->state, MODEM_PPP_STATE_ATTACHED_BIT) == false) {
return;
}
modem_pipe_release(ppp->pipe);
k_work_cancel_sync(&ppp->send_work, &sync);
k_work_cancel_sync(&ppp->process_work, &sync);
ppp->pipe = NULL;
ppp->receive_state = MODEM_PPP_RECEIVE_STATE_HDR_SOF;
if (ppp->rx_pkt != NULL) {
net_pkt_unref(ppp->rx_pkt);
ppp->rx_pkt = NULL;
}
ppp->transmit_state = MODEM_PPP_TRANSMIT_STATE_IDLE;
if (ppp->tx_pkt != NULL) {
net_pkt_unref(ppp->tx_pkt);
ppp->tx_pkt = NULL;
}
while (1) {
pkt = k_fifo_get(&ppp->tx_pkt_fifo, K_NO_WAIT);
if (pkt == NULL) {
break;
}
net_pkt_unref(pkt);
}
}
int modem_ppp_init_internal(const struct device *dev)
{
struct modem_ppp *ppp = (struct modem_ppp *)dev->data;
atomic_set(&ppp->state, 0);
ring_buf_init(&ppp->transmit_rb, ppp->buf_size, ppp->transmit_buf);
k_work_init(&ppp->send_work, modem_ppp_send_handler);
k_work_init(&ppp->process_work, modem_ppp_process_handler);
k_fifo_init(&ppp->tx_pkt_fifo);
#if CONFIG_MODEM_STATS
init_buf_stats(ppp);
#endif
return 0;
}