vfs_tinyusb.c File Reference

#include <stdarg.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdio_ext.h>
#include <string.h>
#include <sys/errno.h>
#include <sys/fcntl.h>
#include <sys/lock.h>
#include <sys/param.h>
#include "esp_attr.h"
#include "esp_log.h"
#include "esp_vfs.h"
#include "esp_vfs_dev.h"
#include "tinyusb.h"
#include "tusb_cdc_acm.h"
#include "vfs_tinyusb.h"
#include "sdkconfig.h"

Include dependency graph for vfs_tinyusb.c:

Go to the source code of this file.

Data Structures
struct	vfs_tinyusb_t

Macros
#define	NONE   -1
#define	FD_CHECK(fd, ret_val)
#define	DEFAULT_TX_MODE   ESP_LINE_ENDINGS_LF
#define	DEFAULT_RX_MODE   ESP_LINE_ENDINGS_LF

Functions
static esp_err_t	apply_path (char const *path)
static esp_err_t	vfstusb_init (int cdc_intf, char const *path)
	Fill s_vfstusb.
static void	vfstusb_deinit (void)
	Clear s_vfstusb to default values.
static int	tusb_open (const char *path, int flags, int mode)
static ssize_t	tusb_write (int fd, const void *data, size_t size)
static int	tusb_close (int fd)
static ssize_t	tusb_read (int fd, void *data, size_t size)
static int	tusb_fstat (int fd, struct stat *st)
static int	tusb_fcntl (int fd, int cmd, int arg)
esp_err_t	esp_vfs_tusb_cdc_unregister (char const *path)
	Unregister TinyUSB CDC from VFS.
esp_err_t	esp_vfs_tusb_cdc_register (int cdc_intf, char const *path)
	Register TinyUSB CDC at VFS with path.

Variables
static const char *	TAG = "tusb_vfs"
static vfs_tinyusb_t	s_vfstusb

Macro Definition Documentation

DEFAULT_RX_MODE

#define DEFAULT_RX_MODE   ESP_LINE_ENDINGS_LF

Definition at line 52 of file vfs_tinyusb.c.

Referenced by vfstusb_init().

DEFAULT_TX_MODE

#define DEFAULT_TX_MODE   ESP_LINE_ENDINGS_LF

Definition at line 44 of file vfs_tinyusb.c.

Referenced by vfstusb_init().

FD_CHECK

#define FD_CHECK	(		fd,
			ret_val )

Value:

    do {                      \
    if ((fd) != 0) {    \
    errno = EBADF;      \
    return (ret_val);   \
    }                   \
} while (0)

Definition at line 30 of file vfs_tinyusb.c.

#define FD_CHECK(fd, ret_val) do {                      \
                                    if ((fd) != 0) {    \
                                    errno = EBADF;      \
                                    return (ret_val);   \
                                    }                   \
                                } while (0)

Referenced by tusb_close(), tusb_fcntl(), tusb_fstat(), tusb_read(), and tusb_write().

NONE

#define NONE   -1

Definition at line 28 of file vfs_tinyusb.c.

Referenced by tusb_read().

Function Documentation

apply_path()

esp_err_t apply_path ( char const * path )

static

Definition at line 68 of file vfs_tinyusb.c.

{
    if (path != NULL) {
        size_t path_len = strlen(path) + 1;
        if (path_len > VFS_TUSB_MAX_PATH) {
            ESP_LOGE(TAG, "The path is too long; maximum is %d characters", VFS_TUSB_MAX_PATH);
            return ESP_ERR_INVALID_ARG;
        }
        strncpy(s_vfstusb.vfs_path, path, (VFS_TUSB_MAX_PATH - 1));
    } else {
        strncpy(s_vfstusb.vfs_path,
                VFS_TUSB_PATH_DEFAULT,
                (VFS_TUSB_MAX_PATH - 1));
    }
    ESP_LOGV(TAG, "Path is set to `%s`", s_vfstusb.vfs_path);
    return ESP_OK;
}

References ESP_OK, s_vfstusb, TAG, VFS_TUSB_MAX_PATH, and VFS_TUSB_PATH_DEFAULT.

Referenced by vfstusb_init().

Here is the caller graph for this function:

esp_vfs_tusb_cdc_register()

esp_err_t esp_vfs_tusb_cdc_register	(	int	cdc_intf,
		char const *	path )

Register TinyUSB CDC at VFS with path.

Parameters

cdc_intf	- interface number of TinyUSB's CDC
path	- path where the CDC will be registered, /dev/tusb_cdc will be used if left NULL.

Returns

esp_err_t ESP_OK or ESP_FAIL

Definition at line 256 of file vfs_tinyusb.c.

{
    ESP_LOGD(TAG, "Registering TinyUSB CDC driver");
    int res;
    if (!tusb_cdc_acm_initialized(cdc_intf)) {
        ESP_LOGE(TAG, "TinyUSB CDC#%d is not initialized", cdc_intf);
        return ESP_ERR_INVALID_STATE;
    }
 
    res = vfstusb_init(cdc_intf, path);
    if (res != ESP_OK) {
        return res;
    }
 
    esp_vfs_t vfs = {
        .flags = ESP_VFS_FLAG_DEFAULT,
        .close = &tusb_close,
        .fcntl = &tusb_fcntl,
        .fstat = &tusb_fstat,
        .open = &tusb_open,
        .read = &tusb_read,
        .write = &tusb_write,
    };
 
    res = esp_vfs_register(s_vfstusb.vfs_path, &vfs, NULL);
    if (res != ESP_OK) {
        ESP_LOGE(TAG, "Can't register TinyUSB driver (err: %x)", res);
    } else {
        ESP_LOGD(TAG, "TinyUSB CDC registered (%s)", s_vfstusb.vfs_path);
    }
    return res;
}

References ESP_LOGD, ESP_OK, s_vfstusb, TAG, tusb_cdc_acm_initialized(), tusb_close(), tusb_fcntl(), tusb_fstat(), tusb_open(), tusb_read(), tusb_write(), and vfstusb_init().

Referenced by esp_tusb_init_console().

Here is the call graph for this function:

Here is the caller graph for this function:

esp_vfs_tusb_cdc_unregister()

esp_err_t esp_vfs_tusb_cdc_unregister

(

char const *

path

)

Unregister TinyUSB CDC from VFS.

Parameters

path	- path where the CDC will be unregistered if NULL will be used /dev/tusb_cdc

Returns

esp_err_t ESP_OK or ESP_FAIL

Definition at line 224 of file vfs_tinyusb.c.

{
    ESP_LOGD(TAG, "Unregistering TinyUSB driver");
    int res;
 
    if (path == NULL) { // NULL means using the default path for unregistering: VFS_TUSB_PATH_DEFAULT
        res = strcmp(s_vfstusb.vfs_path, VFS_TUSB_PATH_DEFAULT);
    } else {
        res = strcmp(s_vfstusb.vfs_path, path);
    }
 
    if (res) {
        res = ESP_ERR_INVALID_ARG;
        ESP_LOGE(TAG, "There is no TinyUSB driver registerred to the path '%s' (err: 0x%x)", s_vfstusb.vfs_path, res);
        return res;
    }
 
 
 
    res = esp_vfs_unregister(s_vfstusb.vfs_path);
    if (res != ESP_OK) {
        ESP_LOGE(TAG, "Can't unregister TinyUSB driver from '%s' (err: 0x%x)", s_vfstusb.vfs_path, res);
    } else {
        ESP_LOGD(TAG, "Unregistered TinyUSB driver");
        vfstusb_deinit();
    }
    return res;
}

References ESP_LOGD, ESP_OK, s_vfstusb, TAG, VFS_TUSB_PATH_DEFAULT, and vfstusb_deinit().

Referenced by esp_tusb_deinit_console().

Here is the call graph for this function:

Here is the caller graph for this function:

tusb_close()

int tusb_close ( int fd )

static

Definition at line 151 of file vfs_tinyusb.c.

{
    FD_CHECK(fd, -1);
    return 0;
}

References FD_CHECK.

Referenced by esp_vfs_tusb_cdc_register().

Here is the caller graph for this function:

tusb_fcntl()

int tusb_fcntl ( int fd, int cmd, int arg )

static

Definition at line 205 of file vfs_tinyusb.c.

{
    FD_CHECK(fd, -1);
    int result = 0;
    switch (cmd) {
    case F_GETFL:
        result = s_vfstusb.flags;
        break;
    case F_SETFL:
        s_vfstusb.flags = arg;
        break;
    default:
        result = -1;
        errno = ENOSYS;
        break;
    }
    return result;
}

References FD_CHECK, and s_vfstusb.

Referenced by esp_vfs_tusb_cdc_register().

Here is the caller graph for this function:

tusb_fstat()

int tusb_fstat ( int fd, struct stat * st )

static

Definition at line 197 of file vfs_tinyusb.c.

{
    FD_CHECK(fd, -1);
    memset(st, 0, sizeof(*st));
    st->st_mode = S_IFCHR;
    return 0;
}

References FD_CHECK.

Referenced by esp_vfs_tusb_cdc_register().

Here is the caller graph for this function:

tusb_open()

int tusb_open ( const char * path, int flags, int mode )

static

Definition at line 111 of file vfs_tinyusb.c.

{
    (void) mode;
    (void) path;
    s_vfstusb.flags = flags | O_NONBLOCK; // for now only non-blocking mode is implemented
    return 0;
}

References s_vfstusb.

Referenced by esp_vfs_tusb_cdc_register().

Here is the caller graph for this function:

tusb_read()

ssize_t tusb_read ( int fd, void * data, size_t size )

static

Definition at line 157 of file vfs_tinyusb.c.

{
    FD_CHECK(fd, -1);
    char *data_c = (char *) data;
    size_t received = 0;
    _lock_acquire(&(s_vfstusb.read_lock));
    int cm1 = NONE;
    int c = NONE;
 
    while (received < size) {
        cm1 = c; // store the old char
        int c = tud_cdc_n_read_char(0); // get a new one
        if (s_vfstusb.rx_mode == ESP_LINE_ENDINGS_CR) {
            if (c == '\r') {
                c = '\n';
            }
        } else if (s_vfstusb.rx_mode == ESP_LINE_ENDINGS_CR) {
            if ((c == '\n') & (cm1 == '\r')) {
                --received; // step back
                c = '\n';
            }
        }
        if ( c == NONE) { // if data ends
            break;
        }
        data_c[received] = (char) c;
        ++received;
        if (c == '\n') {
            break;
        }
    }
    _lock_release(&(s_vfstusb.read_lock));
    if (received > 0) {
        return received;
    }
    errno = EWOULDBLOCK;
    return -1;
}

References data, FD_CHECK, NONE, and s_vfstusb.

Referenced by esp_vfs_tusb_cdc_register().

Here is the caller graph for this function:

tusb_write()

ssize_t tusb_write ( int fd, const void * data, size_t size )

static

Definition at line 119 of file vfs_tinyusb.c.

{
    FD_CHECK(fd, -1);
    size_t written_sz = 0;
    const char *data_c = (const char *)data;
    _lock_acquire(&(s_vfstusb.write_lock));
    for (size_t i = 0; i < size; i++) {
        int c = data_c[i];
        /* handling the EOL */
        if (c == '\n' && s_vfstusb.tx_mode != ESP_LINE_ENDINGS_LF) {
            if (tinyusb_cdcacm_write_queue_char(s_vfstusb.cdc_intf, '\r')) {
                written_sz++;
            } else {
                break; // can't write anymore
            }
            if (s_vfstusb.tx_mode == ESP_LINE_ENDINGS_CR) {
                continue;
            }
        }
        /* write a char */
        if (tinyusb_cdcacm_write_queue_char(s_vfstusb.cdc_intf, c)) {
            written_sz++;
        } else {
            break; // can't write anymore
        }
 
    }
    tud_cdc_n_write_flush(s_vfstusb.cdc_intf);
    _lock_release(&(s_vfstusb.write_lock));
    return written_sz;
}

References data, FD_CHECK, s_vfstusb, and tinyusb_cdcacm_write_queue_char().

Referenced by esp_vfs_tusb_cdc_register().

Here is the call graph for this function:

Here is the caller graph for this function:

vfstusb_deinit()

void vfstusb_deinit ( void )

static

Clear s_vfstusb to default values.

Definition at line 105 of file vfs_tinyusb.c.

{
    memset(&s_vfstusb, 0, sizeof(s_vfstusb));
}

References s_vfstusb.

Referenced by esp_vfs_tusb_cdc_unregister().

Here is the caller graph for this function:

vfstusb_init()

esp_err_t vfstusb_init ( int cdc_intf, char const * path )

static

Fill s_vfstusb.

Parameters

cdc_intf	- interface of tusb for registration
path	- a path where the CDC will be registered

Returns

esp_err_t ESP_OK or ESP_ERR_INVALID_ARG

Definition at line 93 of file vfs_tinyusb.c.

{
    s_vfstusb.cdc_intf = cdc_intf;
    s_vfstusb.tx_mode = DEFAULT_TX_MODE;
    s_vfstusb.rx_mode = DEFAULT_RX_MODE;
 
    return apply_path(path);
}

References apply_path(), DEFAULT_RX_MODE, DEFAULT_TX_MODE, and s_vfstusb.

Referenced by esp_vfs_tusb_cdc_register().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

s_vfstusb

vfs_tinyusb_t s_vfstusb

static

Definition at line 65 of file vfs_tinyusb.c.

Referenced by apply_path(), esp_vfs_tusb_cdc_register(), esp_vfs_tusb_cdc_unregister(), tusb_fcntl(), tusb_open(), tusb_read(), tusb_write(), vfstusb_deinit(), and vfstusb_init().

TAG

const char* TAG = "tusb_vfs"

static

Definition at line 25 of file vfs_tinyusb.c.