pipe.h

Go to the documentation of this file.

/*
 * Copyright (c) 2022 Trackunit Corporation
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#include <zephyr/types.h>
#include <zephyr/kernel.h>
 
#ifndef ZEPHYR_INCLUDE_MODEM_PIPE_H_
#define ZEPHYR_INCLUDE_MODEM_PIPE_H_
 
#ifdef __cplusplus
extern "C" {
#endif


enum modem_pipe_event {
        MODEM_PIPE_EVENT_OPENED = 0,
        MODEM_PIPE_EVENT_RECEIVE_READY,
        MODEM_PIPE_EVENT_TRANSMIT_IDLE,
        MODEM_PIPE_EVENT_CLOSED,
};

struct modem_pipe_data_fragment {
        const uint8_t *data;
        size_t size;
};

 
struct modem_pipe;

 
typedef void (*modem_pipe_api_callback)(struct modem_pipe *pipe, enum modem_pipe_event event,
                                        void *user_data);

 
typedef int (*modem_pipe_api_open)(void *data);
 
typedef int (*modem_pipe_api_transmit)(void *data, const uint8_t *buf, size_t size);
 
typedef int (*modem_pipe_api_transmit_chain)(void *data,
                                             const struct modem_pipe_data_fragment *frags,
                                             size_t num_frags);
 
typedef int (*modem_pipe_api_receive)(void *data, uint8_t *buf, size_t size);
 
typedef int (*modem_pipe_api_close)(void *data);
 
struct modem_pipe_api {
        modem_pipe_api_open open;
        /* Only one of 'transmit' and 'transmit_chain' needs to be implemented */
        modem_pipe_api_transmit transmit;
        modem_pipe_api_transmit_chain transmit_chain;
        modem_pipe_api_receive receive;
        modem_pipe_api_close close;
};
 
struct modem_pipe {
        void *data;
        const struct modem_pipe_api *api;
        modem_pipe_api_callback callback;
        void *user_data;
        struct k_spinlock spinlock;
        struct k_event event;
};

void modem_pipe_init(struct modem_pipe *pipe, void *data, const struct modem_pipe_api *api);


int modem_pipe_open(struct modem_pipe *pipe, k_timeout_t timeout);

int modem_pipe_open_async(struct modem_pipe *pipe);

void modem_pipe_attach(struct modem_pipe *pipe, modem_pipe_api_callback callback, void *user_data);

int modem_pipe_transmit_chain(struct modem_pipe *pipe, const struct modem_pipe_data_fragment *frags,
                              size_t num_frags);

static inline int modem_pipe_transmit(struct modem_pipe *pipe, const uint8_t *buf, size_t size)
{
        const struct modem_pipe_data_fragment frag = {
                .data = buf,
                .size = size,
        };
 
        return modem_pipe_transmit_chain(pipe, &frag, 1);
}

int modem_pipe_receive(struct modem_pipe *pipe, uint8_t *buf, size_t size);

void modem_pipe_release(struct modem_pipe *pipe);

int modem_pipe_close(struct modem_pipe *pipe, k_timeout_t timeout);

int modem_pipe_close_async(struct modem_pipe *pipe);


void modem_pipe_notify_opened(struct modem_pipe *pipe);

void modem_pipe_notify_closed(struct modem_pipe *pipe);

void modem_pipe_notify_receive_ready(struct modem_pipe *pipe);

void modem_pipe_notify_transmit_idle(struct modem_pipe *pipe);


 
#ifdef __cplusplus
}
#endif
 
#endif /* ZEPHYR_INCLUDE_MODEM_PIPE_H_ */