ppp.h

Go to the documentation of this file.

/*
 * Copyright (c) 2022 Trackunit Corporation
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#include <zephyr/kernel.h>
#include <zephyr/types.h>
#include <zephyr/net/net_if.h>
#include <zephyr/net/net_pkt.h>
#include <zephyr/net/ppp.h>
#include <zephyr/sys/ring_buffer.h>
#include <zephyr/sys/atomic.h>
 
#include <zephyr/modem/pipe.h>
#include <zephyr/modem/stats.h>
 
#ifndef ZEPHYR_INCLUDE_MODEM_PPP_H_
#define ZEPHYR_INCLUDE_MODEM_PPP_H_
 
#ifdef __cplusplus
extern "C" {
#endif


typedef void (*modem_ppp_init_iface)(struct net_if *iface);

 
enum modem_ppp_state {
        /* Pipe is attached */
        MODEM_PPP_STATE_ATTACHED_BIT = 0,
        /* Link is dead */
        MODEM_PPP_STATE_DEAD_BIT,
};
 
enum modem_ppp_receive_state {
        /* Searching for start of frame and header */
        MODEM_PPP_RECEIVE_STATE_HDR_SOF = 0,
        MODEM_PPP_RECEIVE_STATE_HDR_FF,
        MODEM_PPP_RECEIVE_STATE_HDR_FF_UNESCAPE,
        MODEM_PPP_RECEIVE_STATE_HDR_CTRL_UNESCAPE,
        MODEM_PPP_RECEIVE_STATE_HDR_CTRL,
        /* Writing bytes to network packet */
        MODEM_PPP_RECEIVE_STATE_WRITING,
        /* Unescaping next byte before writing to network packet */
        MODEM_PPP_RECEIVE_STATE_UNESCAPING,
        /* Receiving an unsolicited "NO CARRIER" event */
        MODEM_PPP_RECEIVE_STATE_UNSOLICITED_NO_CARRIER,
};
 
enum modem_ppp_transmit_state {
        MODEM_PPP_TRANSMIT_STATE_IDLE = 0,
        MODEM_PPP_TRANSMIT_STATE_SOF,
        MODEM_PPP_TRANSMIT_STATE_PROTOCOL,
        MODEM_PPP_TRANSMIT_STATE_DATA,
        MODEM_PPP_TRANSMIT_STATE_EOF,
};
 
struct modem_ppp {
        /* Network interface instance is bound to */
        struct net_if *iface;
 
        /* Hook for PPP L2 network interface initialization */
        modem_ppp_init_iface init_iface;
 
        atomic_t state;
 
        /* Buffers used for processing partial frames */
        uint8_t *receive_buf;
        uint8_t *transmit_buf;
        uint16_t buf_size;
 
        /* Wrapped PPP frames are sent and received through this pipe */
        struct modem_pipe *pipe;
 
        /* Receive PPP frame state */
        enum modem_ppp_receive_state receive_state;
        uint8_t receive_offset;
 
        /* Allocated network packet being created */
        struct net_pkt *rx_pkt;
 
        /* Packet being sent */
        enum modem_ppp_transmit_state transmit_state;
        struct net_pkt *tx_pkt;
        uint16_t tx_pkt_fcs;
 
        /* Ring buffer used for transmitting partial PPP frame */
        struct ring_buf transmit_rb;
 
        struct k_fifo tx_pkt_fifo;
 
        /* Work */
        struct k_work send_work;
        struct k_work process_work;
 
#if defined(CONFIG_NET_STATISTICS_PPP)
        struct net_stats_ppp stats;
#endif
 
#if CONFIG_MODEM_STATS
        struct modem_stats_buffer receive_buf_stats;
        struct modem_stats_buffer transmit_buf_stats;
#endif
};
 
struct modem_ppp_config {
        const struct device *dev;
};


int modem_ppp_attach(struct modem_ppp *ppp, struct modem_pipe *pipe);

struct net_if *modem_ppp_get_iface(struct modem_ppp *ppp);

void modem_ppp_release(struct modem_ppp *ppp);


int modem_ppp_init_internal(const struct device *dev);


#define MODEM_DEV_PPP_DEFINE(_dev, _name, _init_iface, _mtu, _buf_size)                            \
        extern const struct ppp_api modem_ppp_ppp_api;                                             \
                                                                                                   \
        static uint8_t _CONCAT(_name, _receive_buf)[_buf_size];                                    \
        static uint8_t _CONCAT(_name, _transmit_buf)[_buf_size];                                   \
                                                                                                   \
        static struct modem_ppp _name = {                                                          \
                .init_iface = _init_iface,                                                         \
                .receive_buf = _CONCAT(_name, _receive_buf),                                       \
                .transmit_buf = _CONCAT(_name, _transmit_buf),                                     \
                .buf_size = _buf_size,                                                             \
        };                                                                                         \
        static const struct modem_ppp_config _CONCAT(_name, _config) = {                           \
                .dev = _dev,                                                                       \
        };                                                                                         \
                                                                                                   \
        NET_DEVICE_INIT(_CONCAT(ppp_net_dev_, _name), "modem_ppp_" #_name,                         \
                        modem_ppp_init_internal, NULL, &_name, &_CONCAT(_name, _config),           \
                        CONFIG_KERNEL_INIT_PRIORITY_DEFAULT,                                       \
                        &modem_ppp_ppp_api, PPP_L2, NET_L2_GET_CTX_TYPE(PPP_L2), _mtu)

#define MODEM_DT_INST_PPP_DEFINE(inst, _name, _init_iface, _mtu, _buf_size)                        \
        MODEM_DEV_PPP_DEFINE(DEVICE_DT_INST_GET(inst), _name, _init_iface, _mtu, _buf_size)

#define MODEM_PPP_DEFINE(_name, _init_iface, _mtu, _buf_size)                                      \
        MODEM_DEV_PPP_DEFINE(NULL, _name, _init_iface, _mtu, _buf_size)

 
#ifdef __cplusplus
}
#endif
 
#endif /* ZEPHYR_INCLUDE_MODEM_PPP_H_ */