USB endpoint transfer pipe error

[ASLI]

Hi,

I'm trying to evaluate the performance of USB and using USB MSC example to do bulk transfers in between host (PC) device (nRF52840)

I'm using libusb on PC side and sending 64 bytes of data in a loop using bulk transfer. On device side I'm using 'app_usbd_ep_transfer' function in a loop on NRF_DRV_USBD_EPOUT1  endpoint of the interface.

I see the first 64 bytes of transfer is received successfully but after that I get pipe error on libusb side and can't continue to bulk transfers. How can I call this function in a loop? Should I call another function to wait/clear some flags until/after the transfer is completed? Is there a usb device example code which would help with handling the endpoint data transfers in a loop?

Thanks and Best Regards,

Asli

[Sigurd]

Hi,

Looking at the documenation here, libusb_bulk_transfer () returning LIBUSB_ERROR_PIPE , means that the endpoint is halted. I think you might need to call libusb_clear_halt, and then try again. Take a look at this code here.

We dont't have any libusb CDC MSC driver examples, but we have a libusb USB CDC ACM driver for javascript found here.

[ASLI]

Hi Sigurd,

I'm calling libusb_clear_halt() after each bulk transfer on libusb side when there's LIBUSB_PIPE_ERROR already. On Nordic side the program is stopping at line#100 (NRF_BREAKPOINT_COND) of app_error_weak.c file  with '[00:00:00.046,417] <error> app: ASSERTION FAILED at ..\usbd\class\msc\app_usbd_msc.c:2093' . ( ASSERT(0);
ret = NRF_ERROR_NOT_SUPPORTED;)

I think I'm doing something wrong on the Nordic side. Is any of the usb examples showing how to handle the incoming data from host to device in a loop or something similar I can use? 

Thanks,

Asli

[Sigurd]

1) Have you made any changes to the usbd_msc example ?

2) Are you using a nRF52840-DK version 1.0.0 ?

3) Are you using SDK 15.2 ?

Could you try to set APP_USBD_MSC_CONFIG_LOG_ENABLED to 1 and APP_USBD_MSC_CONFIG_LOG_LEVEL to 4 in sdk_config.h , and see what the log output is ?

The endpoint_out_event_handler() should then print the internal module state.

If you want RTT logging, set NRF_LOG_BACKEND_RTT_ENABLED to 1. You might also want to set NRF_LOG_DEFAULT_LEVEL to 4.

[ASLI]

1) I just added below buffer as global to the msc main.c file

static uint8_t data_from_host[64];

NRF_DRV_USBD_TRANSFER_OUT(epOutTransfer, data_from_host, 64);

and I'm calling in the while loop, in main function

ret = app_usbd_ep_transfer(NRF_DRV_USBD_EPOUT1, &epOutTransfer);

2) I have a Rigado BMD-340 evaluation board.

3) Yes

I enabled the logging as recommended. I get below: 

[00:00:00.000,000] <info> app: Mounting volume...
[00:00:00.000,000] <error> app: Mount failed. Filesystem not found. Please format device.
[00:00:00.000,000] <info> app: USBD MSC example started.
[00:00:00.000,000] <info> app: USB power detected
[00:00:00.000,000] <info> app: Un-initializing disk 0 (QSPI)...
[00:00:00.000,000] <info> app: USB ready

[00:00:00.021,118] <debug> usbd_msc: state: 0, ep out event, status: 0
[00:00:00.021,118] <error> app: ASSERTION FAILED at ..\components\libraries\usbd\class\msc\app_usbd_msc.c:2093

Thanks,

Asli

[Sigurd]

Hi,

ASLI said:

1) I just added below buffer as global to the msc main.c file

 Could you upload the main.c you are using?

ASLI said:

[00:00:00.000,000] <error> app: Mount failed. Filesystem not found. Please format device.

 Are you able to get the filesystem to mount on the  BMD-340 with the unmodified example?

Are you using the QSPI/ external flash on the BMD-340?

[ASLI]

Hi Sigurd,

I actually moved away from using the usbd_msc example. I modified usbd example and now I can transfer data in between host and device. But I have issues with usb speed now and I need more help to debug this issue.

I'll describe the problem here but if I need to create a new ticket for this problem, I will.

The host side is using libusb-1.0, sending 16 X 64  = 1K bytes bulk data from ENDPOINTOUT1  using libusb_bulk_transfer function and after the device receiving 1 KByte data it's sending back the data to the host on ENDPOINTIN1. Data is transferred correctly but the time spent to do just 1 KByte transfer is very long and varying a lot. I measured varying rates from 2 - 100 KBytes/second. I tried various libusb drivers (winUSB, libusb-win32 and libusbK) to see any variation with data rate but didn't see any difference.

I'm  attaching the main.c for convenience.

/**
 * Copyright (c) 2016 - 2018, Nordic Semiconductor ASA
 *
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without modification,
 * are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice, this
 *    list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form, except as embedded into a Nordic
 *    Semiconductor ASA integrated circuit in a product or a software update for
 *    such product, must reproduce the above copyright notice, this list of
 *    conditions and the following disclaimer in the documentation and/or other
 *    materials provided with the distribution.
 *
 * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
 *    contributors may be used to endorse or promote products derived from this
 *    software without specific prior written permission.
 *
 * 4. This software, with or without modification, must only be used with a
 *    Nordic Semiconductor ASA integrated circuit.
 *
 * 5. Any software provided in binary form under this license must not be reverse
 *    engineered, decompiled, modified and/or disassembled.
 *
 * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
 * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 */
#include <stdint.h>
#include <stdbool.h>
#include <stddef.h>
#include "nrf.h"
#include "nrf_drv_usbd.h"
#include "nrf_drv_clock.h"
#include "nrf_gpio.h"
#include "nrf_delay.h"
#include "nrf_drv_power.h"
#include "nrf_log.h"
#include "nrf_log_ctrl.h"
#include "nrf_log_default_backends.h"
#include "app_timer.h"
#include "app_error.h"
#include "bsp.h"


#define BTN_DATA_SEND               0
#define BTN_DATA_KEY_RELEASE        (bsp_event_t)(BSP_EVENT_KEY_LAST + 1)

#define RECEIVE_FRAMES              16        // number of usb frames expected from the host
#define SEND_FRAMES                 16        // number of usb frames sent to the host
#define TRANSFER_NUM                16        // number of data transfers for each bulk data of 64 bytes
#define TOTAL_BYTES                 (TRANSFER_NUM*EP1_MAXPACKETSIZE) // total bytes of data that will be transferred to usb device

//#define ENABLE_MY_PRINTS
#define BULK_ENDPOINT               2
#define INTERRUPT_ENDPOINT          3
//#define ISOCHRONOUS_ENDPOINT

/**
 * @brief Button for system OFF request
 *
 * This button would set the request for system OFF.
 */
#define BTN_SYSTEM_OFF BSP_BOARD_BUTTON_1

/**
 * @brief Configuration status LED
 *
 * This LED would blink quickly (5 Hz) when device is not configured
 * or slowly (1 Hz) when configured and working properly.
 */
#define LED_USB_STATUS BSP_BOARD_LED_0
/**
 * @brief Power detect LED
 *
 * The LED is ON when connection is detected on USB port.
 * It is turned off when connection is removed.
 */
#define LED_USB_POWER BSP_BOARD_LED_3

/**
 * @brief Running LED
 *
 * LED that turns on when USB is sending
 */
#define LED_SEND BSP_BOARD_LED_2

/**
 * @brief Active LED
 *
 * LED that turns on when USB is receiving
 */
#define LED_RECEIVE BSP_BOARD_LED_1

/**
 * @brief Enable power USB detection
 *
 * Configure if example supports USB port connection
 */
#ifndef USBD_POWER_DETECTION
#define USBD_POWER_DETECTION true
#endif

/**
 * @brief Startup delay
 *
 * Number of microseconds to start USBD after powering up.
 * Kind of port insert debouncing.
 */
#define STARTUP_DELAY 100


/** Maximum size of the packed transfered by EP0 */
#define EP0_MAXPACKETSIZE NRF_DRV_USBD_EPSIZE

/** Maximum size of the packed transfered by EP1 */
#define EP1_MAXPACKETSIZE NRF_DRV_USBD_EPSIZE

/** Device descriptor */
#define USBD_DEVICE_DESCRIPTOR \
    0x12,                        /* bLength | size of descriptor                                                  */\
    0x01,                        /* bDescriptorType | descriptor type                                             */\
    0x00, 0x02,                  /* bcdUSB | USB spec release (ver 2.0)                                           */\
    0x00,                        /* bDeviceClass ¦ class code (each interface specifies class information)        */\
    0x00,                        /* bDeviceSubClass ¦ device sub-class (must be set to 0 because class code is 0) */\
    0x00,                        /* bDeviceProtocol | device protocol (no class specific protocol)                */\
    EP0_MAXPACKETSIZE,           /* bMaxPacketSize0 | maximum packet size (64 bytes)                              */\
    0x15, 0x19,                  /* vendor ID  (0x1915 Nordic)                                                    */\
    0x0D, 0x52,                  /* product ID (0x520A nRF52 MS device nrf_drv)                                */\
    0x01, 0x01,                  /* bcdDevice | final device release number in BCD Format                         */\
    USBD_STRING_MANUFACTURER_IX, /* iManufacturer | index of manufacturer string                                  */\
    USBD_STRING_PRODUCT_IX,      /* iProduct | index of product string                                            */\
    USBD_STRING_SERIAL_IX,       /* iSerialNumber | Serial Number string                                          */\
    0x01                         /* bNumConfigurations | number of configurations                                 */

/** Configuration descriptor */
#define DEVICE_SELF_POWERED 1
#define REMOTE_WU           0

#define USBD_CONFIG_DESCRIPTOR_SIZE   9
#define USBD_CONFIG_DESCRIPTOR_FULL_SIZE   (USBD_CONFIG_DESCRIPTOR_SIZE + (9 + 7 + 7))
#define USBD_CONFIG_DESCRIPTOR  \
    0x09,         /* bLength | length of descriptor                                             */\
    0x02,         /* bDescriptorType | descriptor type (CONFIGURATION)                          */\
    USBD_CONFIG_DESCRIPTOR_FULL_SIZE, 0x00,    /* wTotalLength | total length of descriptor(s)  */\
    0x01,         /* bNumInterfaces                                                             */\
    0x01,         /* bConfigurationValue                                                        */\
    0x04,         /* index of string Configuration | configuration string index (not supported) */\
    0x80| (((DEVICE_SELF_POWERED) ? 1U:0U)<<6) | (((REMOTE_WU) ? 1U:0U)<<5), /* bmAttributes    */\
    250            /* maximum power in steps of 2mA (500mA)                                       */

#define USBD_INTERFACE0_DESCRIPTOR  \
    0x09,         /* bLength                                                                          */\
    0x04,         /* bDescriptorType | descriptor type (INTERFACE)                                    */\
    0x00,         /* bInterfaceNumber                                                                 */\
    0x00,         /* bAlternateSetting                                                                */\
    0x02,         /* bNumEndpoints | number of endpoints (1)                                          */\
    0x08,         /* bInterfaceClass | interface class (8..defined by USB spec: Mass storage device)  */\
    0x00,         /* bInterfaceSubClass |interface sub-class (0: SCI command set not reported)        */\
    0x00,         /* bInterfaceProtocol | interface protocol )                                        */\
    0x00          /* interface string index (not supported)                                           */

#define USBD_ENDPOINT1OUT_DESCRIPTOR  \
    0x07,         /* bLength | length of descriptor (7 bytes)                                     */\
    0x05,         /* bDescriptorType | descriptor type (ENDPOINT)                                 */\
    0x01,         /* bEndpointAddress | endpoint address (IN endpoint, endpoint 1)                */\
    BULK_ENDPOINT,/* bmAttributes | endpoint attributes                                           */\
    0x40,0x00,    /* bMaxPacketSizeLowByte,bMaxPacketSizeHighByte | maximum packet size(64 bytes) */\
    0x00          /* bInterval | polling interval (10ms)                                          */

#define USBD_ENDPOINT1IN_DESCRIPTOR  \
    0x07,         /* bLength | length of descriptor (7 bytes)                                     */\
    0x05,         /* bDescriptorType | descriptor type (ENDPOINT)                                 */\
    0x81,         /* bEndpointAddress | endpoint address (IN endpoint, endpoint 1)                */\
    BULK_ENDPOINT,/* bmAttributes | endpoint attributes                                           */\
    0x40,0x00,    /* bMaxPacketSizeLowByte,bMaxPacketSizeHighByte | maximum packet size(64 bytes) */\
    0x00          /* bInterval | polling interval (10ms)                                          */

/**
 * String config descriptor
 */
#define USBD_STRING_LANG_IX  0x00
#define USBD_STRING_LANG \
    0x04,         /* length of descriptor                   */\
    0x03,         /* descriptor type                        */\
    0x09,         /*                                        */\
    0x04          /* Supported LangID = 0x0409 (US-English) */

#define USBD_STRING_MANUFACTURER_IX  0x01
#define USBD_STRING_MANUFACTURER \
    42,           /* length of descriptor (? bytes)   */\
    0x03,         /* descriptor type                  */\
    'N', 0x00,    /* Define Unicode String "Nordic Semiconductor  */\
    'o', 0x00, \
    'r', 0x00, \
    'd', 0x00, \
    'i', 0x00, \
    'c', 0x00, \
    ' ', 0x00, \
    'S', 0x00, \
    'e', 0x00, \
    'm', 0x00, \
    'i', 0x00, \
    'c', 0x00, \
    'o', 0x00, \
    'n', 0x00, \
    'd', 0x00, \
    'u', 0x00, \
    'c', 0x00, \
    't', 0x00, \
    'o', 0x00, \
    'r', 0x00

#define USBD_STRING_PRODUCT_IX  0x02
#define USBD_STRING_PRODUCT \
    72,           /* length of descriptor (? bytes)         */\
    0x03,         /* descriptor type                        */\
    'n', 0x00,    /* generic unicode string for all devices */\
    'R', 0x00, \
    'F', 0x00, \
    '5', 0x00, \
    '2', 0x00, \
    ' ', 0x00, \
    'U', 0x00, \
    'S', 0x00, \
    'B', 0x00, \
    ' ', 0x00, \
    'M', 0x00, \
    'Y', 0x00, \
    ' ', 0x00, \
    'd', 0x00, \
    'e', 0x00, \
    'v', 0x00, \
    'i', 0x00, \
    'c', 0x00, \
    'e', 0x00, \
    ' ', 0x00, \
    'o', 0x00, \
    'n', 0x00, \
    ' ', 0x00, \
    'n', 0x00, \
    'r', 0x00, \
    'f', 0x00, \
    '_', 0x00, \
    'd', 0x00, \
    'r', 0x00, \
    'v', 0x00, \
    ' ', 0x00, \
    'D', 0x00, \
    'e', 0x00, \
    'm', 0x00, \
    'o', 0x00, \

#define USBD_STRING_SERIAL_IX  0x00

static const uint8_t get_descriptor_device[] = {
    USBD_DEVICE_DESCRIPTOR
};

static const uint8_t get_descriptor_configuration[] = {
    USBD_CONFIG_DESCRIPTOR,
    USBD_INTERFACE0_DESCRIPTOR,
    USBD_ENDPOINT1IN_DESCRIPTOR,
    USBD_ENDPOINT1OUT_DESCRIPTOR
};
static const uint8_t get_descriptor_string_lang[] = {
    USBD_STRING_LANG
};
static const uint8_t get_descriptor_string_manuf[] = {
    USBD_STRING_MANUFACTURER
};
static const uint8_t get_descriptor_string_prod[] = {
    USBD_STRING_PRODUCT
};

static const uint8_t get_config_resp_configured[]   = {1};
static const uint8_t get_config_resp_unconfigured[] = {0};

static const uint8_t get_status_device_resp_nrwu[] = {
    ((DEVICE_SELF_POWERED) ? 1 : 0), //LSB first: self-powered, no remoteWk
    0
};
static const uint8_t get_status_device_resp_rwu[]  = {
    ((DEVICE_SELF_POWERED) ? 1 : 0) | 2, //LSB first: self-powered, remoteWk
    0
};

static const uint8_t get_status_interface_resp[] = {0, 0};
static const uint8_t get_status_ep_halted_resp[] = {1, 0};
static const uint8_t get_status_ep_active_resp[] = {0, 0};


#define GET_CONFIG_DESC_SIZE    sizeof(get_descriptor_configuration)
#define GET_INTERFACE_DESC_SIZE 9
#define GET_ENDPOINT_DESC_SIZE  7

#define get_descriptor_interface_0 \
    &get_descriptor_configuration[GET_CONFIG_DESC_SIZE]
#define get_descriptor_endpoint_1  \
    &get_descriptor_configuration[GET_CONFIG_DESC_SIZE+GET_INTERFACE_DESC_SIZE]

volatile static int receive_cnt = 0;   // counter for number of received buffers
volatile static int send_cnt = 0;      // counter for number of sent buffers
static uint8_t receive_buffer[EP1_MAXPACKETSIZE];   // data buffer for receiving data
static uint8_t send_buffer[EP1_MAXPACKETSIZE];      // data buffer for sending data
volatile static bool send_flag = 0;
uint16_t txTestData[TOTAL_BYTES / 2];     //test counter data to be sent to the host counts from 0 to 32767
uint8_t  rxTestData[TOTAL_BYTES];         //test counter data to be received from the host which should count from 0 to 32767

/************************Helper function to prepare data**************************************/
static void fillTxBuffer(void)
{
    int i = 0;
    for (i = 0; i < (TOTAL_BYTES / 2); i++)
    {
        txTestData[i] = i;
    }
    printf("First = %d , Last = %d\n", txTestData[0], txTestData[(TOTAL_BYTES / 2 -1)]);

}
static void printTxData(uint16_t *txBuff, int length)
{
    uint8_t *pTxBuff = (uint8_t*)txBuff;
    int i = 0;
    for (i = 0; i < length; i++)
    {
        printf("byte data = %x\n", *(pTxBuff++));
    }
}

/*********************************************************************************************/

/**
 * @brief USB configured flag
 *
 * The flag that is used to mark the fact that USB is configured and ready
 * to transmit data
 */
static volatile bool m_usbd_configured = false;

/**
 * @brief USB suspended
 *
 * The flag that is used to mark the fact that USB is suspended and requires wake up
 * if new data is available.
 *
 * @note This variable is changed from the main loop.
 */
static bool m_usbd_suspended = false;

/**
 * @brief Mark the fact if remote wake up is enabled
 *
 * The internal flag that marks if host enabled the remote wake up functionality in this device.
 */
static
#if REMOTE_WU
    volatile // Disallow optimization only if Remote wakeup is enabled
#endif
bool m_usbd_rwu_enabled = false;

/**
 * @brief The requested suspend state
 *
 * The currently requested suspend state based on the events
 * received from USBD library.
 * If the value here is different than the @ref m_usbd_suspended
 * the state changing would be processed inside main loop.
 */
static volatile bool m_usbd_suspend_state_req = false;

/**
 * @brief System OFF request flag
 *
 * This flag is used in button event processing and marks the fact that
 * system OFF should be activated from main loop.
 */
static volatile bool m_system_off_req = false;


/**
 * @brief Setup all the endpoints for selected configuration
 *
 * Function sets all the endpoints for specific configuration.
 *
 * @note
 * Setting the configuration index 0 means technically disabling the HID interface.
 * Such configuration should be set when device is starting or USB reset is detected.
 *
 * @param index Configuration index
 *
 * @retval NRF_ERROR_INVALID_PARAM Invalid configuration
 * @retval NRF_SUCCESS             Configuration successfully set
 */
static ret_code_t ep_configuration(uint8_t index)
{
    if ( index == 1 )
    {
        nrf_drv_usbd_ep_dtoggle_clear(NRF_DRV_USBD_EPIN1);
        nrf_drv_usbd_ep_stall_clear(NRF_DRV_USBD_EPIN1);
        nrf_drv_usbd_ep_enable(NRF_DRV_USBD_EPIN1);
        nrf_drv_usbd_ep_dtoggle_clear(NRF_DRV_USBD_EPOUT1);
        nrf_drv_usbd_ep_stall_clear(NRF_DRV_USBD_EPOUT1);
        nrf_drv_usbd_ep_enable(NRF_DRV_USBD_EPOUT1);
        m_usbd_configured = true;
        nrf_drv_usbd_setup_clear();
    }
    else if ( index == 0 )
    {
        nrf_drv_usbd_ep_disable(NRF_DRV_USBD_EPIN1);
        nrf_drv_usbd_ep_disable(NRF_DRV_USBD_EPOUT1);
        m_usbd_configured = false;
        nrf_drv_usbd_setup_clear();
    }
    else
    {
        return NRF_ERROR_INVALID_PARAM;
    }
    return NRF_SUCCESS;
}

/**
 * @name Processing setup requests
 *
 * @{
 */
/**
 * @brief Respond on ep 0
 *
 * Auxiliary function for sending respond on endpoint 0
 * @param[in] p_setup Pointer to setup data from current setup request.
 *                    It would be used to calculate the size of data to send.
 * @param[in] p_data  Pointer to the data to send.
 * @param[in] size    Number of bytes to send.
 * @note Data pointed by p_data has to be available till the USBD_EVT_BUFREADY event.
 */
static void respond_setup_data(
    nrf_drv_usbd_setup_t const * const p_setup,
    void const * p_data, size_t size)
{
    /* Check the size against required response size */
    if (size > p_setup->wLength)
    {
        size = p_setup->wLength;
    }
    ret_code_t ret;
    nrf_drv_usbd_transfer_t transfer =
    {
        .p_data = {.tx = p_data},
        .size = size
    };
    ret = nrf_drv_usbd_ep_transfer(NRF_DRV_USBD_EPIN0, &transfer);
    if (ret != NRF_SUCCESS)
    {
        NRF_LOG_ERROR("Transfer starting failed: %d", (uint32_t)ret);
    }
    ASSERT(ret == NRF_SUCCESS);
    UNUSED_VARIABLE(ret);
}


/** React to GetStatus */
static void usbd_setup_GetStatus(nrf_drv_usbd_setup_t const * const p_setup)
{
    switch (p_setup->bmRequestType)
    {
    case 0x80: // Device
        if (((p_setup->wIndex) & 0xff) == 0)
        {
            respond_setup_data(
                p_setup,
                m_usbd_rwu_enabled ? get_status_device_resp_rwu : get_status_device_resp_nrwu,
                sizeof(get_status_device_resp_nrwu));
            return;
        }
        break;
    case 0x81: // Interface
        if (m_usbd_configured) // Respond only if configured
        {
            if (((p_setup->wIndex) & 0xff) == 0) // Only interface 0 supported
            {
                respond_setup_data(
                    p_setup,
                    get_status_interface_resp,
                    sizeof(get_status_interface_resp));
                return;
            }
        }
        break;
    case 0x82: // Endpoint
        if (((p_setup->wIndex) & 0xff) == 0) // Endpoint 0
        {
            respond_setup_data(
                p_setup,
                get_status_ep_active_resp,
                sizeof(get_status_ep_active_resp));
            return;
        }
        if (m_usbd_configured) // Other endpoints responds if configured
        {
            if (((p_setup->wIndex) & 0xff) == NRF_DRV_USBD_EPIN1)
            {
                if (nrf_drv_usbd_ep_stall_check(NRF_DRV_USBD_EPIN1))
                {
                    respond_setup_data(
                        p_setup,
                        get_status_ep_halted_resp,
                        sizeof(get_status_ep_halted_resp));
                    return;
                }
                else
                {
                    respond_setup_data(
                        p_setup,
                        get_status_ep_active_resp,
                        sizeof(get_status_ep_active_resp));
                    return;
                }
            }
        }
        break;
    default:
        break; // Just go to stall
    }
    NRF_LOG_ERROR("Unknown status: 0x%2x", p_setup->bmRequestType);
    nrf_drv_usbd_setup_stall();
}

static void usbd_setup_ClearFeature(nrf_drv_usbd_setup_t const * const p_setup)
{
    if ((p_setup->bmRequestType) == 0x02) // standard request, recipient=endpoint
    {
        if ((p_setup->wValue) == 0)
        {
            if ((p_setup->wIndex) == NRF_DRV_USBD_EPIN1)
            {
                nrf_drv_usbd_ep_stall_clear(NRF_DRV_USBD_EPIN1);
                nrf_drv_usbd_setup_clear();
                return;
            }
        }
    }
    else if ((p_setup->bmRequestType) ==  0x0) // standard request, recipient=device
    {
        if (REMOTE_WU)
        {
            if ((p_setup->wValue) == 1) // Feature Wakeup
            {
                m_usbd_rwu_enabled = false;
                nrf_drv_usbd_setup_clear();
                return;
            }
        }
    }
    NRF_LOG_ERROR("Unknown feature to clear");
    nrf_drv_usbd_setup_stall();
}

static void usbd_setup_SetFeature(nrf_drv_usbd_setup_t const * const p_setup)
{
    if ((p_setup->bmRequestType) == 0x02) // standard request, recipient=endpoint
    {
        if ((p_setup->wValue) == 0) // Feature HALT
        {
            if ((p_setup->wIndex) == NRF_DRV_USBD_EPIN1)
            {
                nrf_drv_usbd_ep_stall(NRF_DRV_USBD_EPIN1);
                nrf_drv_usbd_setup_clear();
                return;
            }
        }
    }
    else if ((p_setup->bmRequestType) ==  0x0) // standard request, recipient=device
    {
        if (REMOTE_WU)
        {
            if ((p_setup->wValue) == 1) // Feature Wakeup
            {
                m_usbd_rwu_enabled = true;
                nrf_drv_usbd_setup_clear();
                return;
            }
        }
    }
    NRF_LOG_ERROR("Unknown feature to set");
    nrf_drv_usbd_setup_stall();
}

static void usbd_setup_GetDescriptor(nrf_drv_usbd_setup_t const * const p_setup)
{
    //determine which descriptor has been asked for
    switch ((p_setup->wValue) >> 8)
    {
    case 1: // Device
        if ((p_setup->bmRequestType) == 0x80)
        {
            respond_setup_data(
                p_setup,
                get_descriptor_device,
                sizeof(get_descriptor_device));
            return;
        }
        break;
    case 2: // Configuration
        if ((p_setup->bmRequestType) == 0x80)
        {
            respond_setup_data(
                p_setup,
                get_descriptor_configuration,
                GET_CONFIG_DESC_SIZE);
            return;
        }
        break;
    case 3: // String
        if ((p_setup->bmRequestType) == 0x80)
        {
            // Select the string
            switch ((p_setup->wValue) & 0xFF)
            {
            case USBD_STRING_LANG_IX:
                respond_setup_data(
                    p_setup,
                    get_descriptor_string_lang,
                    sizeof(get_descriptor_string_lang));
                return;
            case USBD_STRING_MANUFACTURER_IX:
                respond_setup_data(
                    p_setup,
                    get_descriptor_string_manuf,
                    sizeof(get_descriptor_string_manuf));
                return;
            case USBD_STRING_PRODUCT_IX:
                respond_setup_data(p_setup,
                    get_descriptor_string_prod,
                    sizeof(get_descriptor_string_prod));
                return;
            default:
                break;
            }
        }
        break;
    case 4: // Interface
        if ((p_setup->bmRequestType) == 0x80)
        {
            // Which interface?
            if ((((p_setup->wValue) & 0xFF) == 0))
            {
                respond_setup_data(
                    p_setup,
                    get_descriptor_interface_0,
                    GET_INTERFACE_DESC_SIZE);
                return;
            }
        }
        break;
    case 5: // Endpoint
        if ((p_setup->bmRequestType) == 0x80)
        {
            // Which endpoint?
            if (((p_setup->wValue) & 0xFF) == 1)
            {
                respond_setup_data(
                    p_setup,
                    get_descriptor_endpoint_1,
                    GET_ENDPOINT_DESC_SIZE);
                return;
            }
        }
        break;

    default:
        break; // Not supported - go to stall
    }

    NRF_LOG_ERROR("Unknown descriptor requested: 0x%2x, type: 0x%2x or value: 0x%2x",
        p_setup->wValue >> 8,
        p_setup->bmRequestType,
        p_setup->wValue & 0xFF);
    nrf_drv_usbd_setup_stall();
}

static void usbd_setup_GetConfig(nrf_drv_usbd_setup_t const * const p_setup)
{
    if (m_usbd_configured)
    {
        respond_setup_data(
            p_setup,
            get_config_resp_configured,
            sizeof(get_config_resp_configured));
    }
    else
    {
        respond_setup_data(
            p_setup,
            get_config_resp_unconfigured,
            sizeof(get_config_resp_unconfigured));
    }
}

static void usbd_setup_SetConfig(nrf_drv_usbd_setup_t const * const p_setup)
{
    if ((p_setup->bmRequestType) == 0x00)
    {
        // accept only 0 and 1
        if (((p_setup->wIndex) == 0) && ((p_setup->wLength) == 0) &&
            ((p_setup->wValue) <= UINT8_MAX))
        {
            if (NRF_SUCCESS == ep_configuration((uint8_t)(p_setup->wValue)))
            {
                nrf_drv_usbd_setup_clear();
                return;
            }
        }
    }
    NRF_LOG_ERROR("Wrong configuration: Index: 0x%2x, Value: 0x%2x.",
        p_setup->wIndex,
        p_setup->wValue);
    nrf_drv_usbd_setup_stall();
}

static void usbd_setup_SetIdle(nrf_drv_usbd_setup_t const * const p_setup)
{
    if (p_setup->bmRequestType == 0x21)
    {
        //accept any value
        nrf_drv_usbd_setup_clear();
        return;
    }
    NRF_LOG_ERROR("Set Idle wrong type: 0x%2x.", p_setup->bmRequestType);
    nrf_drv_usbd_setup_stall();
}

static void usbd_setup_SetInterface(
    nrf_drv_usbd_setup_t const * const p_setup)
{
    //no alternate setting is supported - STALL always
    NRF_LOG_ERROR("No alternate interfaces supported.");
    nrf_drv_usbd_setup_stall();
}

static void usbd_setup_SetProtocol(
    nrf_drv_usbd_setup_t const * const p_setup)
{
    if (p_setup->bmRequestType == 0x21)
    {
        //accept any value
        nrf_drv_usbd_setup_clear();
        return;
    }
    NRF_LOG_ERROR("Set Protocol wrong type: 0x%2x.", p_setup->bmRequestType);
    nrf_drv_usbd_setup_stall();
}

/** @} */ /* End of processing setup requests functions */


static void usbd_event_handler(nrf_drv_usbd_evt_t const * const p_event)
{
    switch (p_event->type)
    {
    case NRF_DRV_USBD_EVT_SUSPEND:
        NRF_LOG_INFO("SUSPEND state detected");
        m_usbd_suspend_state_req = true;
        break;
    case NRF_DRV_USBD_EVT_RESUME:
        NRF_LOG_INFO("RESUMING from suspend");
        m_usbd_suspend_state_req = false;
        break;
    case NRF_DRV_USBD_EVT_WUREQ:
        NRF_LOG_INFO("RemoteWU initiated");
        m_usbd_suspend_state_req = false;
        break;
    case NRF_DRV_USBD_EVT_RESET:
        {
            ret_code_t ret = ep_configuration(0);
            ASSERT(ret == NRF_SUCCESS);
            UNUSED_VARIABLE(ret);
            m_usbd_suspend_state_req = false;
            break;
        }
    case NRF_DRV_USBD_EVT_SOF:
        {
            static uint32_t cycle = 0;
            ++cycle;
            if ((cycle % (m_usbd_configured ? 500 : 100)) == 0)
            {
                bsp_board_led_invert(LED_USB_STATUS);
            }
            break;
        }
    case NRF_DRV_USBD_EVT_EPTRANSFER:
     	if (NRF_DRV_USBD_EPOUT1 == p_event->data.eptransfer.ep) 
        {
            bsp_board_led_off(LED_RECEIVE);
            static nrf_drv_usbd_transfer_t usb_rx_transfer;
            if (NRF_USBD_EP_WAITING == p_event->data.eptransfer.status) 
            {
                usb_rx_transfer.p_data.rx = &rxTestData[(receive_cnt*EP1_MAXPACKETSIZE)];
                usb_rx_transfer.size = EP1_MAXPACKETSIZE;
                int ret = nrf_drv_usbd_ep_transfer(NRF_DRV_USBD_EPOUT1, &usb_rx_transfer);
            } 
            else if (NRF_USBD_EP_OK == p_event->data.eptransfer.status) 
            {
               /* If errata 154 is present the data transfer is acknowledged by the hardware. */
                if (!nrf_drv_usbd_errata_154())
                {
                    /* Transfer ok - allow status stage */
                    nrf_drv_usbd_setup_clear();
                }
#ifdef  ENABLE_MY_PRINTS               
                size_t size = 0;
                nrf_drv_usbd_ep_status_get(p_event->data.eptransfer.ep, &size);
                printf("Received %d bytes %dth times:\n", size, receive_cnt);
                for (int i = 0; i < size; i++) printf("0x%02X ", rxTestData[i+(receive_cnt*EP1_MAXPACKETSIZE)]);
                printf("\n");
#endif
                receive_cnt++;
                send_flag = 1;
                bsp_board_led_on(LED_RECEIVE);

 
            }
            else if (NRF_USBD_EP_ABORTED == p_event->data.eptransfer.status)
            {
                /* Just ignore */
                NRF_LOG_INFO("Transfer aborted event on EPOUT1");
            }
            else
            {
                NRF_LOG_ERROR("Transfer failed on EPOUT1: %d", p_event->data.eptransfer.status);
                nrf_drv_usbd_setup_stall();
            }
    	}
        else if (NRF_DRV_USBD_EPIN1 == p_event->data.eptransfer.ep) 
        {
            if (NRF_USBD_EP_OK == p_event->data.eptransfer.status) 
            {
                   //* If errata 154 is present the data transfer is acknowledged by the hardware. */
                    if (!nrf_drv_usbd_errata_154())
                    {
                        /* Transfer ok - allow status stage */
                        nrf_drv_usbd_setup_clear();
                    }
                    send_cnt++;
                    
                  //bsp_board_led_off(LED_SEND);

                   send_flag = 0;

            }
            else if (NRF_USBD_EP_ABORTED == p_event->data.eptransfer.status)
            {
                /* Just ignore */
                NRF_LOG_INFO("Transfer aborted event on EPIN1");
            }
            else
            {
                NRF_LOG_ERROR("Transfer failed on EPIN1: %d", p_event->data.eptransfer.status);
                nrf_drv_usbd_setup_stall();
            }
    	}
        if (NRF_DRV_USBD_EPIN0 == p_event->data.eptransfer.ep)
        {
            if (NRF_USBD_EP_OK == p_event->data.eptransfer.status)
            {
                if (!nrf_drv_usbd_errata_154())
                {
                    /* Transfer ok - allow status stage */
                    nrf_drv_usbd_setup_clear();
                }
            }
            else if (NRF_USBD_EP_ABORTED == p_event->data.eptransfer.status)
            {
                /* Just ignore */
                NRF_LOG_INFO("Transfer aborted event on EPIN0");
            }
            else
            {
                NRF_LOG_ERROR("Transfer failed on EPIN0: %d", p_event->data.eptransfer.status);
                nrf_drv_usbd_setup_stall();
            }
        }
        else
        if (NRF_DRV_USBD_EPOUT0 == p_event->data.eptransfer.ep)
        {
            /* NOTE: No EPOUT0 data transfers are used.
             * The code is here as a pattern how to support such a transfer. */
            if (NRF_USBD_EP_OK == p_event->data.eptransfer.status)
            {
                /* NOTE: Data values or size may be tested here to decide if clear or stall.
                 * If errata 154 is present the data transfer is acknowledged by the hardware. */
                if (!nrf_drv_usbd_errata_154())
                {
                    /* Transfer ok - allow status stage */
                    nrf_drv_usbd_setup_clear();
                }
            }
            else if (NRF_USBD_EP_ABORTED == p_event->data.eptransfer.status)
            {
                /* Just ignore */
                NRF_LOG_INFO("Transfer aborted event on EPOUT0");
            }
            else
            {
                NRF_LOG_ERROR("Transfer failed on EPOUT0: %d", p_event->data.eptransfer.status);
                nrf_drv_usbd_setup_stall();
            }
        }
        else
        {
            /* Nothing to do */
        }
        break;
    case NRF_DRV_USBD_EVT_SETUP:
        {
            nrf_drv_usbd_setup_t setup;
            nrf_drv_usbd_setup_get(&setup);
            switch (setup.bmRequest)
            {
            case 0x00: // GetStatus
                usbd_setup_GetStatus(&setup);
                break;
            case 0x01: // CleartFeature
                usbd_setup_ClearFeature(&setup);
                break;
            case 0x03: // SetFeature
                usbd_setup_SetFeature(&setup);
                break;
            case 0x05: // SetAddress
                //nothing to do, handled by hardware; but don't STALL
                break;
            case 0x06: // GetDescriptor
                usbd_setup_GetDescriptor(&setup);
                break;
            case 0x08: // GetConfig
                usbd_setup_GetConfig(&setup);
                break;
            case 0x09: // SetConfig
                usbd_setup_SetConfig(&setup);
                break;
            //HID class
            case 0x0A: // SetIdle
                usbd_setup_SetIdle(&setup);
                break;
            case 0x0B: // SetProtocol or SetInterface
                if (setup.bmRequestType == 0x01) // standard request, recipient=interface
                {
                    usbd_setup_SetInterface(&setup);
                }
                else if (setup.bmRequestType == 0x21) // class request, recipient=interface
                {
                    usbd_setup_SetProtocol(&setup);
                }
                else
                {
                    NRF_LOG_ERROR("Command 0xB. Unknown request: 0x%2x", setup.bmRequestType);
                    nrf_drv_usbd_setup_stall();
                }
                break;
            default:
                NRF_LOG_ERROR("Unknown request: 0x%2x", setup.bmRequest);
                nrf_drv_usbd_setup_stall();
                return;
            }
            break;
        }
    default:
        break;
    }
}


static void power_usb_event_handler(nrf_drv_power_usb_evt_t event)
{
    switch (event)
    {
    case NRF_DRV_POWER_USB_EVT_DETECTED:
        NRF_LOG_INFO("USB power detected");
        if (!nrf_drv_usbd_is_enabled())
        {
            nrf_drv_usbd_enable();
        }
        break;
    case NRF_DRV_POWER_USB_EVT_REMOVED:
        NRF_LOG_INFO("USB power removed");
        m_usbd_configured = false;
        if (nrf_drv_usbd_is_started())
        {
            nrf_drv_usbd_stop();
        }
        if (nrf_drv_usbd_is_enabled())
        {
            nrf_drv_usbd_disable();
        }
        /* Turn OFF LEDs */
        bsp_board_led_off(LED_USB_STATUS);
        bsp_board_led_off(LED_USB_POWER);
        bsp_board_led_on(LED_SEND);     
        bsp_board_led_on(LED_RECEIVE);
        break;
    case NRF_DRV_POWER_USB_EVT_READY:
        NRF_LOG_INFO("USB ready");
        bsp_board_led_on(LED_USB_POWER);
        bsp_board_led_on(LED_SEND);
        bsp_board_led_on(LED_RECEIVE);
        if (!nrf_drv_usbd_is_started())
        {
            nrf_drv_usbd_start(true);
        }
        break;
    default:
        ASSERT(false);
    }
}
static void clock_init(void)
{
    ret_code_t err_code = nrf_drv_clock_init();
    ASSERT((err_code == NRF_SUCCESS) || (err_code == NRF_ERROR_MODULE_ALREADY_INITIALIZED));
    nrfx_clock_hfclk_start();
    nrfx_clock_lfclk_start();

    nrf_drv_clock_hfclk_request(NULL);
    while (!nrf_drv_clock_hfclk_is_running())
    {
        // spin lock
    }
    nrf_drv_clock_lfclk_request(NULL);
    while (!nrf_drv_clock_lfclk_is_running())
    {
        // spin lock
    }
}
static void init_power_clock(void)
{
    ret_code_t ret;
    /* Initializing power and clock */
    APP_ERROR_CHECK(ret);
    ret = nrf_drv_power_init(NULL);
    APP_ERROR_CHECK(ret);
    
    clock_init();
    
    ret = app_timer_init();
    APP_ERROR_CHECK(ret);

    /* Avoid warnings if assertion is disabled */
    UNUSED_VARIABLE(ret);
}

static void bsp_evt_handler(bsp_event_t evt)
{
    switch ((unsigned int)evt)
    {
    case BSP_EVENT_SYSOFF:
    {
        m_system_off_req = true;
        break;
    }
    default:
        return;
    }
}

static void init_bsp(void)
{
    ret_code_t ret;
    ret = bsp_init(BSP_INIT_BUTTONS, bsp_evt_handler);
    APP_ERROR_CHECK(ret);

    ret = bsp_event_to_button_action_assign(
        BTN_SYSTEM_OFF,
        BSP_BUTTON_ACTION_RELEASE,
        BSP_EVENT_SYSOFF);
    APP_ERROR_CHECK(ret);
    ret = bsp_event_to_button_action_assign(BTN_DATA_SEND,
                                            BSP_BUTTON_ACTION_RELEASE,
                                            BTN_DATA_KEY_RELEASE);
    APP_ERROR_CHECK(ret);
    /* Avoid warnings if assertion is disabled */
    UNUSED_VARIABLE(ret);
}


int main(void)
{
    ret_code_t ret, ret_ep;
    UNUSED_RETURN_VALUE(NRF_LOG_INIT(NULL));
    
    init_power_clock();
    //init_bsp();

    NRF_LOG_INFO("USDB example started.");
    if (NRF_DRV_USBD_ERRATA_ENABLE)
    {
        NRF_LOG_INFO("USB errata 104 %s", (uint32_t)(nrf_drv_usbd_errata_104() ? "enabled" : "disabled"));
        NRF_LOG_INFO("USB errata 154 %s", (uint32_t)(nrf_drv_usbd_errata_154() ? "enabled" : "disabled"));
    }


    /* USB work starts right here */
    ret = nrf_drv_usbd_init(usbd_event_handler);
    APP_ERROR_CHECK(ret);

    /* Configure LED and button */
    bsp_board_init(BSP_INIT_LEDS);
    bsp_board_led_on(LED_RECEIVE);
    bsp_board_led_on(LED_SEND);
    
    
    if (USBD_POWER_DETECTION)
    {
        static const nrf_drv_power_usbevt_config_t config =
        {
            .handler = power_usb_event_handler
        };
        ret = nrf_drv_power_usbevt_init(&config);
        APP_ERROR_CHECK(ret);
    }
    else
    {
        NRF_LOG_INFO("No USB power detection enabled\r\nStarting USB now");
        nrf_delay_us(STARTUP_DELAY);
        if (!nrf_drv_usbd_is_enabled())
        {
            nrf_drv_usbd_enable();
            ret = ep_configuration(0);
            APP_ERROR_CHECK(ret);
        }
        /* Wait for regulator power up */
        while (NRF_DRV_POWER_USB_STATE_CONNECTED == nrf_drv_power_usbstatus_get())
        {
            /* Just waiting */
        }

        if (NRF_DRV_POWER_USB_STATE_READY == nrf_drv_power_usbstatus_get())
        {
            if (!nrf_drv_usbd_is_started())
            {
                nrf_drv_usbd_start(true);
            }
        }
        else
        {
            nrf_drv_usbd_disable();
        }
    }

     while (true)
    {

       if (receive_cnt == RECEIVE_FRAMES  && send_cnt < SEND_FRAMES)
       {
           nrf_drv_usbd_transfer_t transfer;
           transfer.p_data.tx = &rxTestData[send_cnt*EP1_MAXPACKETSIZE];
           transfer.size = EP1_MAXPACKETSIZE;
           
           bsp_board_led_off(LED_SEND);
           while(nrf_drv_usbd_ep_is_busy(NRF_DRV_USBD_EPIN1)); 
           ret = nrf_drv_usbd_ep_transfer(NRF_DRV_USBD_EPIN1, &transfer);
           bsp_board_led_on(LED_SEND);

#ifdef ENABLE_MY_PRINTS
           if (ret == NRF_SUCCESS)
           {
              printf("sent %d frames\n", send_cnt);
              printf("Sent %d bytes %dth times:\n", EP1_MAXPACKETSIZE, send_cnt);
              for (uint8_t i = 0; i < transfer.size; i++) printf("0x%02X ", *(rxTestData+(send_cnt*EP1_MAXPACKETSIZE+i)));
              printf("\n");

           }
           else
           {
              printf("ERROR = %d\n", ret);
           }
#endif           
       }
       else if (receive_cnt == RECEIVE_FRAMES  && send_cnt > SEND_FRAMES)
       {
            // led test points are inverted somehow
            bsp_board_led_on(LED_SEND);
            bsp_board_led_on(LED_RECEIVE);
            break;

       }
     

        UNUSED_RETURN_VALUE(NRF_LOG_PROCESS());
        /* Sleep CPU only if there was no interrupt since last loop processing */
        __WFE();
    }

}

I'm measuring the time spent to send and receive data on the usb device toggling LED's and measuring those using a logic analyzer.  

Using LED_SEND to measure time spent on ENDPOINTIN1 and using LED_RECEIVE to measure time on ENDPOINTOUT1. 

My understanding from the nRF52840_PS_v1.0.pdf,  usb has to run with the high frequency clock (which is 64 MHz ?) However even I don't start hfclk in clock_init function (I comment out all clock start and request functions, from line#1030 to line#1040) I don't see any differences with the speed. It varies but it is very slow compared to expected bulk transfer rates.  At this point I don't know how to debug this speed issue further. I'm attaching two captures showing the SEND and RECEIVE times with and without hflck enabled. Can you please help with this?

Thank you and Best Regards,

Asli

[Sigurd]

Hi,

ASLI said:

I'll describe the problem here but if I need to create a new ticket for this problem, I will.

 I'm leaving for vacation, so I will unfortunately not be able to follow up your question. I would therefore recommend that you create a new ticket for this USB speed issue.

Edit: For anyone else reading this case, the new case for the speed issue can be found here.

[ratnakar1978]

Hi ,

  I am also trying to setup communication from BLE chipset through USB 2.0 port to Host Ubuntu PC(USB Port) or on external CPU EVK on USB port. Can you please suggest me this application will work with UBUNTU Host PC ?

[Sigurd]

Hi ratnakar1978,

Please create a new support case for your question.