stdio_base.h

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2015 Kaspar Schleiser <kaspar@schleiser.de>
 * SPDX-FileCopyrightText: 2018 Freie Universität Berlin
 * SPDX-License-Identifier: LGPL-2.1-only
 */
 
#pragma once

 
#include <unistd.h>
 
#include "compiler_hints.h"
#include "isrpipe.h"
#include "modules.h"
 
#if defined(MODULE_STDIO_DISPATCH)
#  include "xfa.h"
#endif
 
#ifdef __cplusplus
extern "C" {
#endif
 
#ifndef STDIO_RX_BUFSIZE
#  define STDIO_RX_BUFSIZE (64)
#endif
 
enum {
    STDIO_NULL,                 
    STDIO_UART,                 
    STDIO_RTT,                  
    STDIO_SEMIHOSTING,          
    STDIO_USBUS_CDC_ACM,        
    STDIO_TINYUSB_CDC_ACM,      
    STDIO_ESP32_SERIAL_JTAG,    
    STDIO_NIMBLE,               
    STDIO_UDP,                  
    STDIO_TELNET,               
    STDIO_ETHOS,                
    STDIO_SLIP,                 
};

typedef struct {
    void (*open)(void);
    void (*close)(void);
    ssize_t (*write)(const void *src, size_t len);
} stdio_provider_t;

extern isrpipe_t stdin_isrpipe;

#if IS_USED(MODULE_STDIO_NOTIFY) || DOXYGEN
int stdio_rx_write_one(uint8_t c);
#else
static inline int stdio_rx_write_one(uint8_t c)
{
    return isrpipe_write_one(&stdin_isrpipe, c);
}
#endif

#if IS_USED(MODULE_STDIO_NOTIFY) || DOXYGEN
int stdio_rx_write(const uint8_t *buf, size_t len);
#else
static inline int stdio_rx_write(const uint8_t *buf, size_t len)
{
    return isrpipe_write(&stdin_isrpipe, buf, len);
}
#endif
 
#if IS_USED(MODULE_STDIO_NOTIFY) || DOXYGEN
typedef void (*stdio_notify_cb_t)(void *arg);

void stdio_set_notify(stdio_notify_cb_t cb, void *arg);
#endif

void stdio_init(void);
 
#if IS_USED(MODULE_STDIO_AVAILABLE) || DOXYGEN
int stdio_available(void);
#endif

void stdio_clear_stdin(void);

ACCESS(write_only, 1, 2)
ssize_t stdio_read(void *buffer, size_t max_len);

ACCESS(read_only, 1, 2)
ssize_t stdio_write(const void *buffer, size_t len);

void stdio_close(void);
 
#if defined(MODULE_STDIO_DISPATCH) || DOXYGEN
#define STDIO_PROVIDER(_type, _open, _close, _write)        \
    XFA_CONST(stdio_provider_t, stdio_provider_xfa, 0) stdio_ ##_type = { \
        .open = _open,                                      \
        .close = _close,                                    \
        .write = _write,                                    \
    };
#else
#define STDIO_PROVIDER(_type, _open, _close, _write)        \
    void stdio_init(void) {                                 \
        void (*f)(void) = _open;                            \
        if (f != NULL) {                                    \
            f();                                            \
        }                                                   \
    }                                                       \
    void stdio_close(void) {                                \
        void (*f)(void) = _close;                           \
        if (f != NULL) {                                    \
            f();                                            \
        }                                                   \
    }                                                       \
    ssize_t stdio_write(const void* buffer, size_t len) {   \
        return _write(buffer, len);                         \
    }
#endif
 
#ifdef __cplusplus
}
#endif