stm32_usbd_cdc.c

#include "heivs/config.h"
#if (USE_STM32_USB_HOST_MODE || USE_STM32_USB_USE_DEVICE_MODE || USE_STM32_USB_OTG_MODE)
/**
 * \file    heivs/stm32_usbd_cdc.c
 * \see     heivs/stm32_usbd_cdc.h
 */

#include "config/usb_conf.h"
#if defined(USE_DEVICE_MODE)

#include "heivs/stm32_usbd_cdc.h"
#include "heivs/time.h"

#include "stm32/usb/usbd_cdc_core.h"
#include "stm32/usb/usb_core.h"
#include "stm32/usb/usbd_usr.h"
#include "stm32/usb/usbd_desc.h"
#include "stm32/usb/usb_dcd_int.h"
#include "stm32/usb/usb_hcd_int.h"

#include <string.h>

static uint16_t cdc_init(void)
{
    return USBD_OK;
}

static uint16_t cdc_deinit(void)
{
    return USBD_OK;
}

static uint16_t cdc_ctrl(uint32_t cmd, const uint8_t* buf, uint32_t len)
{
    (void)cmd;
    (void)buf;
    (void)len;

    return USBD_OK;
}

static status_e(*cdc_user_rx)(USB_OTG_CORE_HANDLE *dev, const uint32_t *buffer, size_t len);

static uint16_t cdc_rx(const uint32_t* buf, uint32_t len)
{
    cdc_user_rx(&USB_OTG_Core, buf, len);

    return USBD_OK;
}

enum state_e
{
    STATE_IDLE      = 0x00,
    STATE_SENDING   = 0x01,
};

static volatile enum state_e state;

static uint16_t cdc_data_tx_emtpy(void)
{
    state = STATE_IDLE;
    return USBD_OK;
}

const CDC_IF_Prop_TypeDef APP_FOPS =
{
    .pIf_Init = cdc_init,
    .pIf_DeInit = cdc_deinit,
    .pIf_Ctrl = cdc_ctrl,
    .pIf_DataRx = cdc_rx,
    .pIf_DataTxEmpty = cdc_data_tx_emtpy,
};

static void do_nothing(void)
{

}

static void do_nothing_u8(uint8_t _unused)
{
    (void)_unused;
}

static USBD_Usr_cb_TypeDef default_USR_cb =
{
    .Init               = do_nothing,
    .DeviceReset        = do_nothing_u8,
    .DeviceConfigured   = do_nothing,
    .DeviceSuspended    = do_nothing,
    .DeviceResumed      = do_nothing,

    .DeviceConnected    = do_nothing,
    .DeviceDisconnected = do_nothing,
};

status_e usbd_cdc_init(usbd_cdc_rx_t rx, USBD_Usr_cb_TypeDef *usr_cb)
{
    if (rx == NULL)
    {
        return ERROR_BAD_PARAM;
    }

    if (!usr_cb)
    {
        usr_cb = &default_USR_cb;
    }

    state = STATE_IDLE;

    cdc_user_rx = rx;

    USBD_Init(&USB_OTG_Core, USB_OTG_FS_CORE_ID, &USR_desc, &USBD_CDC_cb, usr_cb);

    return NO_ERROR;
}

const uint32_t max_size = 0x10000;
size_t usbd_cdc_tx_nowait_maxsize(void)
{
    return max_size;
}

status_e usbd_cdc_tx(const void *data, size_t len, enum usb_cdc_wait_e wait)
{
    timeout_t timeout;

    if (wait == WAIT_NO_WAIT && state != STATE_IDLE)
    {
        return ERROR_AGAIN;
    }

    timeout = time_set_timeout_ms(1000);
    while (state == STATE_SENDING)
    {
        if (time_elapsed(timeout))
        {
            return ERROR_TIMEOUT;
        }
    }

    /**
     * FIXME
     * There is somewhere in the USB stack a size limit. It should be
     * better to fix it in the USB stack, but let's workaround here.
     */
    if (len > max_size && wait == WAIT_NO_WAIT)
    {
        return ERROR_BAD_PARAM;
    }

    while (len > max_size)
    {
        state = STATE_SENDING;
        DCD_EP_Tx(&USB_OTG_Core, CDC_IN_EP, (void *)data, max_size);

        timeout = time_set_timeout_ms(1000);
        while (state == STATE_SENDING)
        {
            if (time_elapsed(timeout))
            {
                return ERROR_TIMEOUT;
            }
        }
        data += max_size;
        len -= max_size;
    }

    state = STATE_SENDING;
    DCD_EP_Tx(&USB_OTG_Core, CDC_IN_EP, (void *)data, len);
    if (!(wait & WAIT_TX_FINISHED))
    {
        return NO_ERROR;
    }

    timeout = time_set_timeout_ms(1000);
    while (state == STATE_SENDING)
    {
        if (time_elapsed(timeout))
        {
            return ERROR_TIMEOUT;
        }
    }

    return NO_ERROR;
}
#endif
#endif /* (USE_STM32_USB_HOST_MODE || USE_STM32_USB_USE_DEVICE_MODE || USE_STM32_USB_OTG_MODE) */