初始版本

components/libraries/usbd/class/audio/app_usbd_audio.c

@@ -0,0 +1,861 @@
+/**
+ * Copyright (c) 2016 - 2020, 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 "sdk_common.h"
+#if NRF_MODULE_ENABLED(APP_USBD_AUDIO)
+
+#include "app_usbd_audio.h"
+#include "app_util_platform.h"
+
+/**
+ * @defgroup app_usbd_audio_internals USBD Audio internals
+ * @{
+ * @ingroup app_usbd_audio
+ * @internal
+ */
+
+STATIC_ASSERT(sizeof(app_usbd_audio_ac_iface_header_desc_t) == 8);
+STATIC_ASSERT(sizeof(app_usbd_audio_input_terminal_desc_t) == 12);
+STATIC_ASSERT(sizeof(app_usbd_audio_output_terminal_desc_t) == 9);
+STATIC_ASSERT(sizeof(app_usbd_audio_feature_unit_desc_t) == 6);
+STATIC_ASSERT(sizeof(app_usbd_audio_as_iface_desc_t) == 7);
+STATIC_ASSERT(sizeof(app_usbd_audio_as_format_type_one_desc_t) == 8);
+STATIC_ASSERT(sizeof(app_usbd_audio_as_format_type_two_desc_t) == 9);
+STATIC_ASSERT(sizeof(app_usbd_audio_as_format_type_three_desc_t) == 8);
+STATIC_ASSERT(sizeof(app_usbd_audio_as_endpoint_desc_t) == 7);
+
+#define APP_USBD_AUDIO_CONTROL_IFACE_IDX    0 /**< Audio class control interface index */
+#define APP_USBD_AUDIO_STREAMING_IFACE_IDX  1 /**< Audio class streaming interface index */
+
+#define APP_USBD_CDC_AUDIO_STREAMING_EP_IDX 0 /**< Audio streaming isochronous endpoint index */
+
+/**
+ * @brief Auxiliary function to access audio class instance data.
+ *
+ * @param[in] p_inst Class instance data.
+ * @return Audio class instance data @ref app_usbd_audio_t
+ */
+static inline app_usbd_audio_t const * audio_get(app_usbd_class_inst_t const * p_inst)
+{
+    ASSERT(p_inst != NULL);
+    return (app_usbd_audio_t const *)p_inst;
+}
+
+
+/**
+ * @brief Auxiliary function to access audio class context data.
+ *
+ * @param[in] p_audio    Audio class instance data.
+ * @return Audio class context data @ref app_usbd_audio_ctx_t
+ */
+static inline app_usbd_audio_ctx_t * audio_ctx_get(app_usbd_audio_t const * p_audio)
+{
+    ASSERT(p_audio != NULL);
+    ASSERT(p_audio->specific.p_data != NULL);
+    return &p_audio->specific.p_data->ctx;
+}
+
+
+/**
+ * @brief User event handler.
+ *
+ * @param[in] p_inst        Class instance.
+ * @param[in] event user    Event type @ref app_usbd_audio_user_event_t
+ */
+static inline void user_event_handler(
+    app_usbd_class_inst_t const * p_inst,
+    app_usbd_audio_user_event_t   event)
+{
+    app_usbd_audio_t const * p_audio = audio_get(p_inst);
+
+    if (p_audio->specific.inst.user_ev_handler != NULL)
+    {
+        p_audio->specific.inst.user_ev_handler(p_inst, event);
+    }
+}
+
+
+/**
+ * @brief Select interface.
+ *
+ * @param[in,out] p_inst    Instance of the class.
+ * @param[in]     iface_idx Index of the interface inside class structure.
+ * @param[in]     alternate Alternate setting that should be selected.
+ */
+static ret_code_t iface_select(
+    app_usbd_class_inst_t const * const p_inst,
+    uint8_t                             iface_idx,
+    uint8_t                             alternate)
+{
+    app_usbd_class_iface_conf_t const * p_iface = app_usbd_class_iface_get(p_inst, iface_idx);
+    /* Simple check if this is data interface */
+    uint8_t const ep_count = app_usbd_class_iface_ep_count_get(p_iface);
+
+    if (ep_count > 0)
+    {
+        if (alternate > 1)
+        {
+            return NRF_ERROR_INVALID_PARAM;
+        }
+        app_usbd_audio_t const * p_audio     = audio_get(p_inst);
+        app_usbd_audio_ctx_t   * p_audio_ctx = audio_ctx_get(p_audio);
+        p_audio_ctx->streaming = (alternate != 0);
+
+        uint8_t i;
+
+        for (i = 0; i < ep_count; ++i)
+        {
+            nrf_drv_usbd_ep_t ep_addr =
+                app_usbd_class_ep_address_get(app_usbd_class_iface_ep_get(p_iface, i));
+            if (alternate)
+            {
+                app_usbd_ep_enable(ep_addr);
+            }
+            else
+            {
+                app_usbd_ep_disable(ep_addr);
+            }
+        }
+        return NRF_SUCCESS;
+    }
+    return NRF_ERROR_NOT_SUPPORTED;
+}
+
+
+static void iface_deselect(
+    app_usbd_class_inst_t const * const p_inst,
+    uint8_t                             iface_idx)
+{
+    app_usbd_class_iface_conf_t const * p_iface = app_usbd_class_iface_get(p_inst, iface_idx);
+
+    /* Simple check if this is data interface */
+    if (p_iface->ep_cnt > 0)
+    {
+        app_usbd_audio_t const * p_audio     = audio_get(p_inst);
+        app_usbd_audio_ctx_t   * p_audio_ctx = audio_ctx_get(p_audio);
+        p_audio_ctx->streaming = false;
+    }
+    /* Note that all the interface endpoints would be disabled automatically after this function */
+}
+
+
+static uint8_t iface_selection_get(
+    app_usbd_class_inst_t const * const p_inst,
+    uint8_t                             iface_idx)
+{
+    app_usbd_class_iface_conf_t const * p_iface = app_usbd_class_iface_get(p_inst, iface_idx);
+    /* Simple check if this is data interface */
+    uint8_t const ep_count = app_usbd_class_iface_ep_count_get(p_iface);
+
+    if (ep_count > 0)
+    {
+        app_usbd_audio_t const * p_audio     = audio_get(p_inst);
+        app_usbd_audio_ctx_t   * p_audio_ctx = audio_ctx_get(p_audio);
+        return (p_audio_ctx->streaming) ? 1 : 0;
+    }
+    return 0;
+}
+
+
+/**
+ * @brief Internal SETUP standard IN request handler.
+ *
+ * @param[in] p_inst        Generic class instance.
+ * @param[in] p_setup_ev    Setup event.
+ *
+ * @return Standard error code.
+ * @retval NRF_SUCCESS              Request handled correctly.
+ * @retval NRF_ERROR_NOT_SUPPORTED  Request is not supported.
+ */
+static ret_code_t setup_req_std_in(app_usbd_class_inst_t const * p_inst,
+                                   app_usbd_setup_evt_t const  * p_setup_ev)
+{
+    /* Only Get Descriptor standard IN request is supported by Audio class */
+    if ((app_usbd_setup_req_rec(p_setup_ev->setup.bmRequestType) == APP_USBD_SETUP_REQREC_INTERFACE)
+        &&
+        (p_setup_ev->setup.bRequest == APP_USBD_SETUP_STDREQ_GET_DESCRIPTOR))
+    {
+        size_t dsc_len = 0;
+        size_t max_size;
+
+        uint8_t * p_trans_buff = app_usbd_core_setup_transfer_buff_get(&max_size);
+
+        /* Try to find descriptor in class internals*/
+        ret_code_t ret = app_usbd_class_descriptor_find(
+            p_inst,
+            p_setup_ev->setup.wValue.hb,
+            p_setup_ev->setup.wValue.lb,
+            p_trans_buff,
+            &dsc_len);
+
+        if (ret != NRF_ERROR_NOT_FOUND)
+        {
+            ASSERT(dsc_len < NRF_DRV_USBD_EPSIZE);
+            return app_usbd_core_setup_rsp(&(p_setup_ev->setup), p_trans_buff, dsc_len);
+        }
+    }
+
+    return NRF_ERROR_NOT_SUPPORTED;
+}
+
+
+/**
+ * @brief Internal SETUP class IN request handler.
+ *
+ * @param[in] p_inst        Generic class instance.
+ * @param[in] p_setup_ev    Setup event.
+ *
+ * @return Standard error code.
+ * @retval NRF_SUCCESS              Request handled correctly.
+ * @retval NRF_ERROR_NOT_SUPPORTED  Request is not supported.
+ */
+static ret_code_t setup_req_class_in(
+    app_usbd_class_inst_t const * p_inst,
+    app_usbd_setup_evt_t const  * p_setup_ev)
+{
+    switch (p_setup_ev->setup.bRequest)
+    {
+        case APP_USBD_AUDIO_REQ_GET_CUR:
+        case APP_USBD_AUDIO_REQ_GET_MIN:
+        case APP_USBD_AUDIO_REQ_GET_MAX:
+        case APP_USBD_AUDIO_REQ_SET_RES:
+        case APP_USBD_AUDIO_REQ_GET_MEM:
+        {
+            app_usbd_audio_t const * p_audio     = audio_get(p_inst);
+            app_usbd_audio_ctx_t   * p_audio_ctx = audio_ctx_get(p_audio);
+
+
+            p_audio_ctx->request.req_type  = (app_usbd_audio_req_type_t)p_setup_ev->setup.bRequest;
+            p_audio_ctx->request.control   = p_setup_ev->setup.wValue.hb;
+            p_audio_ctx->request.channel   = p_setup_ev->setup.wValue.lb;
+            p_audio_ctx->request.interface = p_setup_ev->setup.wIndex.hb;
+            p_audio_ctx->request.entity    = p_setup_ev->setup.wIndex.lb;
+
+            p_audio_ctx->request.length = p_setup_ev->setup.wLength.w;
+
+            p_audio_ctx->request.req_target = APP_USBD_AUDIO_CLASS_REQ_IN;
+
+            app_usbd_setup_reqrec_t rec = app_usbd_setup_req_rec(p_setup_ev->setup.bmRequestType);
+            if (rec == APP_USBD_SETUP_REQREC_ENDPOINT)
+            {
+                p_audio_ctx->request.req_target = APP_USBD_AUDIO_EP_REQ_IN;
+            }
+
+            user_event_handler((app_usbd_class_inst_t const *)p_audio,
+                               APP_USBD_AUDIO_USER_EVT_CLASS_REQ);
+
+            return app_usbd_core_setup_rsp(&p_setup_ev->setup,
+                                           p_audio_ctx->request.payload,
+                                           p_audio_ctx->request.length);
+        }
+
+        default:
+            break;
+    }
+
+    return NRF_ERROR_NOT_SUPPORTED;
+}
+
+
+static ret_code_t audio_req_out_data_cb(nrf_drv_usbd_ep_status_t status, void * p_context)
+{
+    if (status == NRF_USBD_EP_OK)
+    {
+        app_usbd_audio_t const * p_audio = p_context;
+
+        user_event_handler((app_usbd_class_inst_t const *)p_audio,
+                           APP_USBD_AUDIO_USER_EVT_CLASS_REQ);
+    }
+
+    return NRF_SUCCESS;
+}
+
+
+static ret_code_t audio_req_out(
+    app_usbd_class_inst_t const * p_inst,
+    app_usbd_setup_evt_t const  * p_setup_ev)
+{
+    app_usbd_audio_t const * p_audio     = audio_get(p_inst);
+    app_usbd_audio_ctx_t   * p_audio_ctx = audio_ctx_get(p_audio);
+
+
+    p_audio_ctx->request.req_type  = (app_usbd_audio_req_type_t)p_setup_ev->setup.bRequest;
+    p_audio_ctx->request.control   = p_setup_ev->setup.wValue.hb;
+    p_audio_ctx->request.channel   = p_setup_ev->setup.wValue.lb;
+    p_audio_ctx->request.interface = p_setup_ev->setup.wIndex.hb;
+    p_audio_ctx->request.entity    = p_setup_ev->setup.wIndex.lb;
+
+    p_audio_ctx->request.length = p_setup_ev->setup.wLength.w;
+
+    p_audio_ctx->request.req_target = APP_USBD_AUDIO_CLASS_REQ_OUT;
+    if (app_usbd_setup_req_rec(p_setup_ev->setup.bmRequestType) == APP_USBD_SETUP_REQREC_ENDPOINT)
+    {
+        p_audio_ctx->request.req_target = APP_USBD_AUDIO_EP_REQ_OUT;
+    }
+
+    /*Request setup data*/
+    NRF_DRV_USBD_TRANSFER_OUT(transfer, p_audio_ctx->request.payload, p_audio_ctx->request.length);
+    ret_code_t ret;
+    CRITICAL_REGION_ENTER();
+    ret = app_usbd_ep_transfer(NRF_DRV_USBD_EPOUT0, &transfer);
+    if (ret == NRF_SUCCESS)
+    {
+        app_usbd_core_setup_data_handler_desc_t desc = {
+            .handler   = audio_req_out_data_cb,
+            .p_context = (void *)p_audio
+        };
+
+        ret = app_usbd_core_setup_data_handler_set(NRF_DRV_USBD_EPOUT0, &desc);
+    }
+    CRITICAL_REGION_EXIT();
+
+    return ret;
+}
+
+
+/**
+ * @brief Internal SETUP class OUT request handler.
+ *
+ * @param[in] p_inst        Generic class instance.
+ * @param[in] p_setup_ev    Setup event.
+ *
+ * @return Standard error code
+ * @retval NRF_SUCCESS              Request handled correctly.
+ * @retval NRF_ERROR_NOT_SUPPORTED  Request is not supported.
+ */
+static ret_code_t setup_req_class_out(
+    app_usbd_class_inst_t const * p_inst,
+    app_usbd_setup_evt_t const  * p_setup_ev)
+{
+    switch (p_setup_ev->setup.bRequest)
+    {
+        case APP_USBD_AUDIO_REQ_SET_CUR:
+        case APP_USBD_AUDIO_REQ_SET_MIN:
+        case APP_USBD_AUDIO_REQ_SET_MAX:
+        case APP_USBD_AUDIO_REQ_SET_RES:
+        case APP_USBD_AUDIO_REQ_SET_MEM:
+            return audio_req_out(p_inst, p_setup_ev);
+
+        default:
+            break;
+    }
+
+    return NRF_ERROR_NOT_SUPPORTED;
+}
+
+
+/**
+ * @brief Control endpoint handle.
+ *
+ * @param[in] p_inst        Generic class instance.
+ * @param[in] p_setup_ev    Setup event.
+ *
+ * @return Standard error code.
+ * @retval NRF_SUCCESS              Request handled correctly.
+ * @retval NRF_ERROR_NOT_SUPPORTED  Request is not supported.
+ */
+static ret_code_t setup_event_handler(
+    app_usbd_class_inst_t const * p_inst,
+    app_usbd_setup_evt_t const  * p_setup_ev)
+{
+    ASSERT(p_inst != NULL);
+    ASSERT(p_setup_ev != NULL);
+
+    if (app_usbd_setup_req_dir(p_setup_ev->setup.bmRequestType) == APP_USBD_SETUP_REQDIR_IN)
+    {
+        switch (app_usbd_setup_req_typ(p_setup_ev->setup.bmRequestType))
+        {
+            case APP_USBD_SETUP_REQTYPE_STD:
+                return setup_req_std_in(p_inst, p_setup_ev);
+
+            case APP_USBD_SETUP_REQTYPE_CLASS:
+                return setup_req_class_in(p_inst, p_setup_ev);
+
+            default:
+                break;
+        }
+    }
+    else /*APP_USBD_SETUP_REQDIR_OUT*/
+    {
+        switch (app_usbd_setup_req_typ(p_setup_ev->setup.bmRequestType))
+        {
+            case APP_USBD_SETUP_REQTYPE_CLASS:
+                return setup_req_class_out(p_inst, p_setup_ev);
+
+            default:
+                break;
+        }
+    }
+
+    return NRF_ERROR_NOT_SUPPORTED;
+}
+
+
+/**
+ * @brief Endpoint IN event handler.
+ *
+ * @param[in] p_inst        Generic class instance.
+ *
+ * @return Standard error code.
+ * @retval NRF_SUCCESS              Request handled correctly.
+ * @retval NRF_ERROR_NOT_SUPPORTED  Request is not supported.
+ */
+static ret_code_t endpoint_in_event_handler(app_usbd_class_inst_t const * p_inst)
+{
+    user_event_handler(p_inst, APP_USBD_AUDIO_USER_EVT_TX_DONE);
+    return NRF_SUCCESS;
+}
+
+
+/**
+ * @brief Endpoint OUT event handler.
+ *
+ * @param[in] p_inst        Generic class instance.
+ *
+ * @return Standard error code.
+ * @retval NRF_SUCCESS              Request handled correctly.
+ * @retval NRF_ERROR_NOT_SUPPORTED  Request is not supported.
+ */
+static ret_code_t endpoint_out_event_handler(app_usbd_class_inst_t const * p_inst)
+{
+    user_event_handler(p_inst, APP_USBD_AUDIO_USER_EVT_RX_DONE);
+    return NRF_SUCCESS;
+}
+
+
+/**
+ * @brief Auxiliary function to access isochronous endpoint address.
+ *
+ * @param[in] p_inst Class instance data.
+ *
+ * @return ISO endpoint address.
+ */
+static inline nrf_drv_usbd_ep_t ep_iso_addr_get(app_usbd_class_inst_t const * p_inst)
+{
+    app_usbd_class_iface_conf_t const * class_iface;
+
+    class_iface = app_usbd_class_iface_get(p_inst, APP_USBD_AUDIO_STREAMING_IFACE_IDX);
+
+    app_usbd_class_ep_conf_t const * ep_cfg;
+    ep_cfg = app_usbd_class_iface_ep_get(class_iface, APP_USBD_CDC_AUDIO_STREAMING_EP_IDX);
+
+    return app_usbd_class_ep_address_get(ep_cfg);
+}
+
+
+/**
+ * @brief @ref app_usbd_class_methods_t::event_handler
+ */
+static ret_code_t audio_event_handler(
+    app_usbd_class_inst_t const  * p_inst,
+    app_usbd_complex_evt_t const * p_event)
+{
+    ASSERT(p_inst != NULL);
+    ASSERT(p_event != NULL);
+
+    ret_code_t ret = NRF_SUCCESS;
+
+    switch (p_event->app_evt.type)
+    {
+        case APP_USBD_EVT_DRV_RESET:
+            break;
+
+        case APP_USBD_EVT_DRV_SETUP:
+            ret = setup_event_handler(p_inst, (app_usbd_setup_evt_t const *)p_event);
+            break;
+
+        case APP_USBD_EVT_DRV_EPTRANSFER:
+            if (NRF_USBD_EPIN_CHECK(p_event->drv_evt.data.eptransfer.ep))
+            {
+                ret = endpoint_in_event_handler(p_inst);
+            }
+            else
+            {
+                ret = endpoint_out_event_handler(p_inst);
+            }
+            break;
+
+        case APP_USBD_EVT_DRV_SUSPEND:
+            break;
+
+        case APP_USBD_EVT_DRV_RESUME:
+            break;
+
+        case APP_USBD_EVT_INST_APPEND:
+        {
+            app_usbd_audio_t const * p_audio     = audio_get(p_inst);
+            app_usbd_audio_ctx_t   * p_audio_ctx = audio_ctx_get(p_audio);
+            if(p_audio_ctx->sof_handler != NULL)
+            {
+                ret = app_usbd_class_sof_interrupt_register(p_inst, p_audio_ctx->sof_handler);
+                APP_ERROR_CHECK(ret);
+            }
+            break;
+        }
+
+        case APP_USBD_EVT_INST_REMOVE:
+        {
+            app_usbd_audio_t const * p_audio     = audio_get(p_inst);
+            app_usbd_audio_ctx_t   * p_audio_ctx = audio_ctx_get(p_audio);
+            if(p_audio_ctx->sof_handler != NULL)
+            {
+                ret = app_usbd_class_sof_interrupt_unregister(p_inst);
+                APP_ERROR_CHECK(ret);
+            }
+            break;
+        }
+
+        case APP_USBD_EVT_STARTED:
+            break;
+
+        case APP_USBD_EVT_STOPPED:
+            break;
+
+        default:
+            ret = NRF_ERROR_NOT_SUPPORTED;
+            break;
+    }
+
+    return ret;
+}
+
+
+static size_t audio_get_format_descriptor_size(app_usbd_class_inst_t const * p_inst)
+{
+    app_usbd_audio_t const * p_audio = audio_get(p_inst);
+
+    if (p_audio->specific.inst.p_format_dsc == NULL)
+    {
+        return 0;
+    }
+
+    return p_audio->specific.inst.p_format_dsc->size;
+}
+
+
+static size_t audio_get_format_descriptor_data(app_usbd_class_inst_t const * p_inst,
+                                               uint32_t                      cur_byte)
+{
+    app_usbd_audio_t const * p_audio = audio_get(p_inst);
+
+    return p_audio->specific.inst.p_format_dsc->p_data[cur_byte];
+}
+
+
+static size_t audio_get_input_descriptor_size(app_usbd_class_inst_t const * p_inst)
+{
+    app_usbd_audio_t const * p_audio = audio_get(p_inst);
+
+    if (p_audio->specific.inst.p_input_dsc == NULL)
+    {
+        return 0;
+    }
+
+    return p_audio->specific.inst.p_input_dsc->size;
+}
+
+
+static size_t audio_get_input_descriptor_data(app_usbd_class_inst_t const * p_inst,
+                                              uint32_t                      cur_byte)
+{
+    app_usbd_audio_t const * p_audio = audio_get(p_inst);
+
+    return p_audio->specific.inst.p_input_dsc->p_data[cur_byte];
+}
+
+
+static size_t audio_get_output_descriptor_size(app_usbd_class_inst_t const * p_inst)
+{
+    app_usbd_audio_t const * p_audio = audio_get(p_inst);
+
+    if (p_audio->specific.inst.p_output_dsc == NULL)
+    {
+        return 0;
+    }
+
+    return p_audio->specific.inst.p_output_dsc->size;
+}
+
+
+static size_t audio_get_output_descriptor_data(app_usbd_class_inst_t const * p_inst,
+                                               uint32_t                      cur_byte)
+{
+    app_usbd_audio_t const * p_audio = audio_get(p_inst);
+
+    return p_audio->specific.inst.p_output_dsc->p_data[cur_byte];
+}
+
+
+static size_t audio_get_feature_descriptor_size(app_usbd_class_inst_t const * p_inst)
+{
+    app_usbd_audio_t const * p_audio = audio_get(p_inst);
+
+    if (p_audio->specific.inst.p_feature_dsc == NULL)
+    {
+        return 0;
+    }
+
+    return p_audio->specific.inst.p_feature_dsc->size;
+}
+
+
+static size_t audio_get_feature_descriptor_data(app_usbd_class_inst_t const * p_inst,
+                                                uint32_t                      cur_byte)
+{
+    app_usbd_audio_t const * p_audio = audio_get(p_inst);
+
+    return p_audio->specific.inst.p_feature_dsc->p_data[cur_byte];
+}
+
+
+static uint8_t audio_get_control_interface_number(app_usbd_class_inst_t const * p_inst)
+{
+    app_usbd_class_iface_conf_t const * ifce = 0;
+
+    ifce = app_usbd_class_iface_get(p_inst, 0);
+    return app_usbd_class_iface_number_get(ifce);
+}
+
+
+/**
+ * @brief @ref app_usbd_class_methods_t::feed_descriptors
+ */
+
+static bool audio_feed_descriptors(app_usbd_class_descriptor_ctx_t * p_ctx,
+                                   app_usbd_class_inst_t const     * p_inst,
+                                   uint8_t                         * p_buff,
+                                   size_t                            max_size)
+{
+    static uint8_t ifaces   = 0;
+    ifaces = app_usbd_class_iface_count_get(p_inst);
+    ASSERT(ifaces == 2);
+    app_usbd_audio_t const * p_audio = audio_get(p_inst);
+
+    APP_USBD_CLASS_DESCRIPTOR_BEGIN(p_ctx, p_buff, max_size);
+
+    /* CONTROL INTERFACE DESCRIPTOR */
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(0x09); // bLength
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(APP_USBD_DESCRIPTOR_INTERFACE); // bDescriptorType = Interface
+
+    static app_usbd_class_iface_conf_t const * p_cur_iface = NULL;
+    p_cur_iface = app_usbd_class_iface_get(p_inst, 0);
+
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(app_usbd_class_iface_number_get(p_cur_iface)); // bInterfaceNumber
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(0x00); // bAlternateSetting
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(app_usbd_class_iface_ep_count_get(p_cur_iface)); // bNumEndpoints
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(APP_USBD_AUDIO_CLASS); // bInterfaceClass = Audio
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(APP_USBD_AUDIO_SUBCLASS_AUDIOCONTROL); // bInterfaceSubclass (Audio Control)
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(APP_USBD_AUDIO_CLASS_PROTOCOL_UNDEFINED); // bInterfaceProtocol
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(0x00); // iInterface
+
+    /* HEADER INTERFACE */
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(0x09); // bLength
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(APP_USBD_AUDIO_DESCRIPTOR_INTERFACE); // bDescriptorType = Audio Interfaces
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(APP_USBD_AUDIO_AC_IFACE_SUBTYPE_HEADER); // bDescriptorSubtype = Header
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(LSB_16(0x0100)); // bcdADC LSB
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(MSB_16(0x0100)); // bcdADC MSB
+
+    static uint16_t header_desc_len = 0;
+    header_desc_len = 9 + audio_get_feature_descriptor_size(p_inst) +
+                      audio_get_input_descriptor_size(p_inst) + audio_get_output_descriptor_size(
+        p_inst);
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(LSB_16(header_desc_len)); // wTotalLength LSB
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(MSB_16(header_desc_len)); // wTotalLength MSB
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(0x01);                    // bInCollection
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(audio_get_control_interface_number(p_inst) + 1); // baInterfaceNr(1)
+
+    /* INPUT TERMINAL DESCRIPTOR */
+    static uint32_t cur_byte        = 0;
+    static size_t   input_desc_size = 0;
+    input_desc_size = audio_get_input_descriptor_size(p_inst);
+
+    for (cur_byte = 0; cur_byte < input_desc_size; cur_byte++)
+    {
+        APP_USBD_CLASS_DESCRIPTOR_WRITE(audio_get_input_descriptor_data(p_inst, cur_byte));
+    }
+
+    /* FEATURE UNIT DESCRIPTOR */
+    static size_t feature_desc_size = 0;
+    feature_desc_size = audio_get_feature_descriptor_size(p_inst);
+
+    for (cur_byte = 0; cur_byte < feature_desc_size; cur_byte++)
+    {
+        APP_USBD_CLASS_DESCRIPTOR_WRITE(audio_get_feature_descriptor_data(p_inst, cur_byte));
+    }
+
+    /* OUTPUT TERMINAL DESCRIPTOR */
+    static size_t output_desc_size = 0;
+    output_desc_size = audio_get_output_descriptor_size(p_inst);
+
+    for (cur_byte = 0; cur_byte < output_desc_size; cur_byte++)
+    {
+        APP_USBD_CLASS_DESCRIPTOR_WRITE(audio_get_output_descriptor_data(p_inst, cur_byte));
+    }
+
+    p_cur_iface++;
+
+    /* STREAM INTERFACE DESCRIPTOR ALT 0 */
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(0x09); // bLength
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(APP_USBD_DESCRIPTOR_INTERFACE); // bDescriptorType = Interface
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(audio_get_control_interface_number(p_inst) + 1); // bInterfaceNumber
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(0x00); // bAlternateSetting
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(0x00); // bNumEndpoints
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(APP_USBD_AUDIO_CLASS); // bInterfaceClass = Audio
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(p_audio->specific.inst.type_streaming); // bInterfaceSubclass (Audio Control)
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(APP_USBD_AUDIO_CLASS_PROTOCOL_UNDEFINED); // bInterfaceProtocol
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(0x00); // iInterface
+
+    /* STREAM INTERFACE DESCRIPTOR ALT 1 */
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(0x09); // bLength
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(APP_USBD_DESCRIPTOR_INTERFACE); // bDescriptorType = Interface
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(audio_get_control_interface_number(p_inst) + 1); // bInterfaceNumber
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(0x01); // bAlternateSetting
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(app_usbd_class_iface_ep_count_get(p_cur_iface)); // bNumEndpoints
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(APP_USBD_AUDIO_CLASS); // bInterfaceClass = Audio
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(p_audio->specific.inst.type_streaming); // bInterfaceSubclass (Audio Control)
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(APP_USBD_AUDIO_CLASS_PROTOCOL_UNDEFINED); // bInterfaceProtocol
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(0x00); // iInterface
+
+    /* AudioStreaming GENERAL DESCRIPTOR */
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(0x07); // bLength
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(APP_USBD_AUDIO_DESCRIPTOR_INTERFACE); // bDescriptorType = Audio Interface
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(APP_USBD_AUDIO_AS_IFACE_SUBTYPE_GENERAL); // bDescriptorSubtype = General
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(p_audio->specific.inst.terminal_link); // bTerminalLink
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(p_audio->specific.inst.delay); // bDelay
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(LSB_16(p_audio->specific.inst.format)); // wFormatTag LSB
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(MSB_16(p_audio->specific.inst.format)); // wFormatTag MSB
+
+    /* FORMAT DESCRIPTOR */
+    static size_t format_desc_size = 0;
+    format_desc_size = audio_get_format_descriptor_size(p_inst);
+
+    for (cur_byte = 0; cur_byte < format_desc_size; cur_byte++)
+    {
+        APP_USBD_CLASS_DESCRIPTOR_WRITE(audio_get_format_descriptor_data(p_inst, cur_byte));
+    }
+
+    /* ENDPOINT GENERAL DESCRIPTOR */
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(0x07); // bLength
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(APP_USBD_AUDIO_DESCRIPTOR_ENDPOINT); // bDescriptorType = Audio Descriptor
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(APP_USBD_AUDIO_EP_SUBTYPE_GENERAL);  // bDescriptorSubtype = EP General
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(0x00); // bmAttributes
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(0x00); // bLockDelayUnits
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(LSB_16(0x0000)); // wLockDelay LSB
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(MSB_16(0x0000)); // wLockDelay MSB
+
+    /* ENDPOINT ISO DESCRIPTOR */
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(0x09); // bLength
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(APP_USBD_DESCRIPTOR_ENDPOINT); // bDescriptorType = Endpoint
+
+    static app_usbd_class_ep_conf_t const * p_cur_ep = NULL;
+    p_cur_ep = app_usbd_class_iface_ep_get(p_cur_iface, 0);
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(app_usbd_class_ep_address_get(p_cur_ep)); // bEndpointAddress
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(APP_USBD_DESCRIPTOR_EP_ATTR_TYPE_ISOCHRONOUS); // bmAttributes
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(LSB_16(p_audio->specific.inst.ep_size)); // wMaxPacketSize LSB
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(MSB_16(p_audio->specific.inst.ep_size)); // wMaxPacketSize MSB
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(0x01); // bInterval
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(0x00); // bRefresh
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(0x00); // bSynchAddress
+
+    APP_USBD_CLASS_DESCRIPTOR_END();
+}
+
+/** @} */
+
+const app_usbd_class_methods_t app_usbd_audio_class_methods = {
+    .event_handler       = audio_event_handler,
+    .feed_descriptors    = audio_feed_descriptors,
+    .iface_select        = iface_select,
+    .iface_deselect      = iface_deselect,
+    .iface_selection_get = iface_selection_get,
+};
+
+
+size_t app_usbd_audio_class_rx_size_get(app_usbd_class_inst_t const * p_inst)
+{
+    nrf_drv_usbd_ep_t ep_addr;
+
+    ep_addr = ep_iso_addr_get(p_inst);
+    ASSERT(NRF_USBD_EPISO_CHECK(ep_addr));
+
+    return (size_t)nrf_drv_usbd_epout_size_get(ep_addr);
+}
+
+
+ret_code_t app_usbd_audio_class_rx_start(
+    app_usbd_class_inst_t const * p_inst,
+    void                        * p_buff,
+    size_t                        size)
+{
+    nrf_drv_usbd_ep_t ep_addr;
+
+    ep_addr = ep_iso_addr_get(p_inst);
+    ASSERT(NRF_USBD_EPISO_CHECK(ep_addr));
+
+    NRF_DRV_USBD_TRANSFER_OUT(transfer, p_buff, size);
+    return app_usbd_ep_transfer(ep_addr, &transfer);
+}
+
+
+ret_code_t app_usbd_audio_class_tx_start(
+    app_usbd_class_inst_t const * p_inst,
+    const void                  * p_buff,
+    size_t                        size)
+{
+    nrf_drv_usbd_ep_t ep_addr;
+
+    ep_addr = ep_iso_addr_get(p_inst);
+    ASSERT(NRF_USBD_EPISO_CHECK(ep_addr));
+
+    NRF_DRV_USBD_TRANSFER_IN(transfer, p_buff, size);
+    return app_usbd_ep_transfer(ep_addr, &transfer);
+}
+
+ret_code_t app_usbd_audio_sof_interrupt_register(app_usbd_class_inst_t const * p_inst, 
+                                                 app_usbd_sof_interrupt_handler_t handler)
+{
+    app_usbd_audio_t const * p_audio     = audio_get(p_inst);
+    app_usbd_audio_ctx_t   * p_audio_ctx = audio_ctx_get(p_audio);
+
+    p_audio_ctx->sof_handler = handler;
+
+    return NRF_SUCCESS;
+}
+
+#endif //NRF_MODULE_ENABLED(APP_USBD_AUDIO)

components/libraries/usbd/class/audio/app_usbd_audio.h

@@ -0,0 +1,346 @@
+/**
+ * Copyright (c) 2017 - 2020, 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.
+ *
+ */
+#ifndef APP_USBD_AUDIO_H__
+#define APP_USBD_AUDIO_H__
+
+#include <stdint.h>
+#include <stdbool.h>
+
+#include "nrf_drv_usbd.h"
+#include "app_usbd.h"
+#include "app_usbd_core.h"
+#include "app_usbd_class_base.h"
+#include "app_usbd_descriptor.h"
+
+#include "app_usbd_audio_types.h"
+#include "app_usbd_audio_desc.h"
+#include "app_usbd_audio_internal.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @defgroup app_usbd_audio USB AUDIO class
+ * @ingroup app_usbd
+ *
+ * @brief @tagAPI52840 Module with types, definitions, and API used by USB Audio class.
+ *
+ * @details Reference specifications:
+ * - "Universal Serial Bus Device Class Definition for Audio Devices"
+ *      Release 1.0,  March 18, 1998.
+ * - "Universal Serial Bus Device Class Definition for Audio Data Formats"
+ *      Release 1.0, March 18, 1998.
+ * - "Universal Serial Bus Device Class Definition for Terminal Types"
+ *      Release 1.0, March 18, 1998.
+ *
+ * @{
+ */
+
+
+#ifdef DOXYGEN
+/**
+ * @brief Audio class instance type
+ *
+ * @ref APP_USBD_CLASS_TYPEDEF
+ */
+typedef struct { } app_usbd_audio_t;
+#else
+/*lint -save -e10 -e26 -e123 -e505 */
+APP_USBD_CLASS_TYPEDEF(app_usbd_audio,    \
+    APP_USBD_AUDIO_CONFIG(0, 1),          \
+    APP_USBD_AUDIO_INSTANCE_SPECIFIC_DEC, \
+    APP_USBD_AUDIO_DATA_SPECIFIC_DEC      \
+);
+/*lint -restore*/
+#endif
+
+
+/*lint -save -e407 */
+
+/**
+ * @brief Events passed to user event handler
+ *
+ * @note Example prototype of user event handler:
+ *
+ * @code
+   void audio_user_ev_handler(app_usbd_class_inst_t const * p_inst,
+                              app_usbd_audio_user_event_t   event);
+ * @endcode
+ */
+typedef enum app_usbd_audio_user_event_e {
+    APP_USBD_AUDIO_USER_EVT_CLASS_REQ,   /**< User event CLASS_REQ */
+    APP_USBD_AUDIO_USER_EVT_RX_DONE,     /**< User event RX_DONE   */
+    APP_USBD_AUDIO_USER_EVT_TX_DONE,     /**< User event TX_DONE   */
+} app_usbd_audio_user_event_t;
+
+/*lint -restore*/
+
+/**
+ * @brief Global definition of app_usbd_audio_t class instance.
+ *
+ * @param instance_name             Name of global instance.
+ * @param interfaces_configs        Interfaces configurations.
+ * @param user_ev_handler           User event handler.
+ * @param format_descriptor         Audio class Format descriptor.
+ * @param input_descriptor          Audio class Input Terminal descriptor.
+ * @param output_descriptor         Audio class Output Terminal descriptor.
+ * @param feature_descriptor        Audio class Feature Unit descriptor.
+ * @param delay                     Streaming delay.
+ * @param format                    FormatTag (@ref app_usbd_audio_as_iface_format_tag_t).
+ * @param ep_size                   Endpoint size.
+ * @param type_str                  Streaming type MIDISTREAMING/AUDIOSTREAMING.
+ * @param terminal_link             Terminal link in AS Interface Descriptor.
+ *
+ * @note This macro is just simplified version of @ref APP_USBD_AUDIO_GLOBAL_DEF_INTERNAL
+ *
+ */
+#define APP_USBD_AUDIO_GLOBAL_DEF(instance_name,            \
+                                  interfaces_configs,       \
+                                  user_ev_handler,          \
+                                  format_descriptor,        \
+                                  input_descriptor,         \
+                                  output_descriptor,        \
+                                  feature_descriptor,       \
+                                  delay,                    \
+                                  format,                   \
+                                  ep_size,                  \
+                                  type_str,                 \
+                                  terminal_link)            \
+    APP_USBD_AUDIO_GLOBAL_DEF_INTERNAL(instance_name,       \
+                                       interfaces_configs,  \
+                                       user_ev_handler,     \
+                                       format_descriptor,   \
+                                       input_descriptor,    \
+                                       output_descriptor,   \
+                                       feature_descriptor,  \
+                                       delay,               \
+                                       format,              \
+                                       ep_size,             \
+                                       type_str,            \
+                                       terminal_link)
+
+
+/**
+ * @brief Initializer of Audio Format descriptor.
+ *
+ * @param name  Format descriptor name.
+ * @param ...   Format descriptor data.
+*/
+
+#define APP_USBD_AUDIO_FORMAT_DESCRIPTOR(name, ...)             \
+    static uint8_t const CONCAT_2(name,  _data)[] =             \
+    {                                                           \
+        __VA_ARGS__                                             \
+    };                                                          \
+    static const app_usbd_audio_subclass_desc_t name =          \
+    {                                                           \
+        sizeof(CONCAT_2(name, _data)),                          \
+        APP_USBD_AUDIO_AS_IFACE_SUBTYPE_FORMAT_TYPE,            \
+        CONCAT_2(name,_data)                                    \
+    }
+
+/**
+ * @brief Initializer of Audio Input descriptor.
+ *
+ * @param name  Input descriptor name.
+ * @param ...   Input descriptor data.
+*/
+
+#define APP_USBD_AUDIO_INPUT_DESCRIPTOR(name, ...)              \
+    static uint8_t const CONCAT_2(name,  _data)[] =             \
+    {                                                           \
+        __VA_ARGS__                                             \
+    };                                                          \
+    static const app_usbd_audio_subclass_desc_t name =          \
+    {                                                           \
+        sizeof(CONCAT_2(name, _data)),                          \
+        APP_USBD_AUDIO_AC_IFACE_SUBTYPE_INPUT_TERMINAL,         \
+        CONCAT_2(name,_data)                                    \
+    }
+
+/**
+ * @brief Initializer of Audio Output descriptor.
+ *
+ * @param name  Output descriptor name.
+ * @param ...   Output descriptor data.
+*/
+
+#define APP_USBD_AUDIO_OUTPUT_DESCRIPTOR(name, ...)             \
+    static uint8_t const CONCAT_2(name,  _data)[] =             \
+    {                                                           \
+        __VA_ARGS__                                             \
+    };                                                          \
+    static const app_usbd_audio_subclass_desc_t name =          \
+    {                                                           \
+        sizeof(CONCAT_2(name, _data)),                          \
+        APP_USBD_AUDIO_AC_IFACE_SUBTYPE_OUTPUT_TERMINAL,        \
+        CONCAT_2(name,_data)                                    \
+    }
+
+/**
+ * @brief Initializer of Feture Output descriptor.
+ *
+ * @param name  Feture descriptor name.
+ * @param ...   Feture descriptor data.
+*/
+
+#define APP_USBD_AUDIO_FEATURE_DESCRIPTOR(name, ...)            \
+    static uint8_t const CONCAT_2(name,  _data)[] =             \
+    {                                                           \
+        __VA_ARGS__                                             \
+    };                                                          \
+    static const app_usbd_audio_subclass_desc_t name =          \
+    {                                                           \
+        sizeof(CONCAT_2(name, _data)),                          \
+        APP_USBD_AUDIO_AC_IFACE_SUBTYPE_FEATURE_UNIT,           \
+        CONCAT_2(name,_data)                                    \
+    }
+
+/**
+ * @@brief Helper function to get class instance from Audio class.
+ *
+ * @param[in] p_audio Audio class instance (declared by @ref APP_USBD_AUDIO_GLOBAL_DEF).
+ * @return Base class instance.
+ */
+static inline app_usbd_class_inst_t const *
+app_usbd_audio_class_inst_get(app_usbd_audio_t const * p_audio)
+{
+    return &p_audio->base;
+}
+
+/**
+ * @brief Helper function to get audio specific request from audio class.
+ *
+ * @param[in] p_audio Audio class instance (declared by @ref APP_USBD_AUDIO_GLOBAL_DEF).
+ * @return Audio class specific request.
+ */
+static inline app_usbd_audio_req_t *
+app_usbd_audio_class_request_get(app_usbd_audio_t const * p_audio)
+{
+    return &p_audio->specific.p_data->ctx.request;
+}
+
+/**
+ * @brief Helper function to get audio from base class instance.
+ *
+ * @param[in] p_inst Base class instance.
+ * @return Audio class handle.
+ */
+static inline app_usbd_audio_t const *
+app_usbd_audio_class_get(app_usbd_class_inst_t const * p_inst)
+{
+    return (app_usbd_audio_t const *)p_inst;
+}
+
+/**
+ * @brief Get the size of last received transfer.
+ *
+ * @note Call this function in reaction to a SOF event to check if there is any data to process.
+ *
+ * @param p_inst Base class instance.
+ *
+ * @return Number of bytes received in the last transmission.
+ */
+size_t app_usbd_audio_class_rx_size_get(app_usbd_class_inst_t const * p_inst);
+
+/**
+ * @brief Start audio data copying from the endpoint buffer.
+ *
+ * Function to be used to copy data from an audio OUT endpoint to a given buffer.
+ * When it finishes, an @ref APP_USBD_AUDIO_USER_EVT_RX_DONE event is generated.
+ *
+ * @param p_inst Base class instance.
+ * @param p_buff Target buffer.
+ * @param size   Size of the requested data.
+ *
+ * @return Result of the endpoint transmission start.
+ *
+ * @sa app_usbd_audio_class_rx_size_get
+ *
+ * @note This function should be called in reaction to a SOF event.
+ *       Isochronous endpoints are double buffered and they are automatically switched at every SOF.
+ */
+ret_code_t app_usbd_audio_class_rx_start(
+    app_usbd_class_inst_t const * p_inst,
+    void * p_buff,
+    size_t size);
+
+/**
+ * @brief Start copying audio data to the endpoint buffer.
+ *
+ * Function to be used to copy data to an audio IN endpoint from a given buffer.
+ * When it finishes, an @ref APP_USBD_AUDIO_USER_EVT_TX_DONE event is generated.
+ *
+ * @param p_inst Base class instance.
+ * @param p_buff Source buffer.
+ * @param size   Size of the data to be sent.
+ *
+ * @return Result of the endpoint transsmision start.
+ *
+ * @note This function should be called in reaction to a SOF event.
+ *       Isochronous endpoints are double buffered and they are automatically switched at every SOF.
+ */
+ret_code_t app_usbd_audio_class_tx_start(
+    app_usbd_class_inst_t const * p_inst,
+    const void * p_buff,
+    size_t size);
+
+/**
+ * @brief Register audio instance as the one that requires SOF events in interrupt.
+ *
+ * This function should be called before appending the instance.
+ *
+ * @param p_inst  Audio instance that requires SOF event.
+ * @param handler Handler to SOF event
+ *
+ * @retval NRF_SUCCESS Instance linked into SOF processing list.
+ *
+ * @sa app_usbd_class_sof_interrupt_register
+ */
+ret_code_t app_usbd_audio_sof_interrupt_register(app_usbd_class_inst_t const * p_inst,
+                                                 app_usbd_sof_interrupt_handler_t handler);
+/** @} */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* APP_USBD_AUDIO_H__ */

components/libraries/usbd/class/audio/app_usbd_audio_desc.h

@@ -0,0 +1,318 @@
+/**
+ * Copyright (c) 2016 - 2020, 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.
+ *
+ */
+#ifndef APP_USBD_AUDIO_DESC_H__
+#define APP_USBD_AUDIO_DESC_H__
+
+#include "app_usbd_descriptor.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @defgroup app_usbd_audio_dsc USB Audio descriptors
+ * @brief @tagAPI52840 Descriptors used in the USB Audio class.
+ * @ingroup app_usbd_audio
+ * @{
+ */
+
+/**
+ * @brief Initializer of interface descriptor for AUDIO class.
+ *
+ * @param interface_number Interface number.
+ * @param alt_setting      Interface alternate setting.
+ * @param ep_num           Number of endpoints.
+ * @param subclass         Audio subclass @ref app_usbd_audio_subclass_t
+ * */
+#define APP_USBD_AUDIO_INTERFACE_DSC(interface_number, alt_setting, ep_num, subclass)   \
+    /*.bLength =            */ sizeof(app_usbd_descriptor_iface_t),                     \
+    /*.bDescriptorType =    */ APP_USBD_DESCRIPTOR_INTERFACE,                           \
+    /*.bInterfaceNumber =   */ (interface_number),                                      \
+    /*.bAlternateSetting =  */ (alt_setting),                                           \
+    /*.bNumEndpoints =      */ (ep_num),                                                \
+    /*.bInterfaceClass =    */ APP_USBD_AUDIO_CLASS,                                    \
+    /*.bInterfaceSubClass = */ (subclass),                                              \
+    /*.bInterfaceProtocol = */ APP_USBD_AUDIO_CLASS_PROTOCOL_UNDEFINED,                 \
+    /*.iInterface = 0,      */ 0x00,                                                    \
+
+/**
+ * @brief Initializer of isochronous endpoint descriptors for audio class.
+ *
+ * @param ep            ISO endpoint id: @ref NRF_DRV_USBD_EPIN8, @ref NRF_DRV_USBD_EPOUT8
+ * @param ep_size       Endpoint size (bytes).
+ * @param interval      Endpoint interval (milliseconds).
+ * @param refresh       Refresh value (usually 0).
+ * @param synch_addr    Synch address (usually 0).
+ * */
+#define APP_USBD_AUDIO_ISO_EP_DSC(ep, ep_size, interval, refresh, synch_addr)       \
+    /*.bLength =          */ sizeof(app_usbd_descriptor_ep_t) + 2,                  \
+    /*.bDescriptorType =  */ APP_USBD_DESCRIPTOR_ENDPOINT,                          \
+    /*.bEndpointAddress = */ ep,                                                    \
+    /*.bmAttributes =     */ APP_USBD_DESCRIPTOR_EP_ATTR_TYPE_ISOCHRONOUS,          \
+    /*.wMaxPacketSize =   */ APP_USBD_U16_TO_RAW_DSC(ep_size),                      \
+    /*.bInterval =        */ (interval),                                            \
+    /*.bRefresh =         */ (refresh),                                             \
+    /*.bInterval =        */ (synch_addr),                                          \
+
+/**
+ * @brief Simplified version of @ref APP_USBD_AUDIO_ISO_EP_DSC for ISO IN endpoint
+ */
+#define APP_USBD_AUDIO_ISO_EP_IN_DSC(ep_size)           \
+        APP_USBD_AUDIO_ISO_EP_DSC(NRF_DRV_USBD_EPIN8, ep_size, 1, 0, 0)
+
+/**
+ * @brief Simplified version of @ref APP_USBD_AUDIO_ISO_EP_DSC for ISO OUT endpoint
+ */
+#define APP_USBD_AUDIO_ISO_EP_OUT_DSC(ep_size)           \
+        APP_USBD_AUDIO_ISO_EP_DSC(NRF_DRV_USBD_EPOUT8, ep_size, 1, 0, 0)
+
+/**
+ * @brief Initializer of @ref app_usbd_audio_ac_iface_header_desc_t
+ *
+ * @param descriptor_list   Descriptor list following audio interface header descriptor.
+ * @param ...               List of interfaces following audio control interface.
+ * */
+#define APP_USBD_AUDIO_AC_IFACE_HEADER_DSC(descriptor_list, ...)                            \
+    /*.bLength =            */ sizeof(app_usbd_audio_ac_iface_header_desc_t) +              \
+                               (NUM_VA_ARGS(__VA_ARGS__)),                                  \
+    /*.bDescriptorType =    */ APP_USBD_AUDIO_DESCRIPTOR_INTERFACE,                         \
+    /*.bDescriptorSubtype = */ APP_USBD_AUDIO_AC_IFACE_SUBTYPE_HEADER,                      \
+    /*.bcdADC =             */ APP_USBD_U16_TO_RAW_DSC(0x0100),                             \
+    /*.wTotalLength =       */ APP_USBD_U16_TO_RAW_DSC(                                     \
+                               sizeof((uint8_t[]){BRACKET_EXTRACT(descriptor_list)}) +      \
+                               sizeof(app_usbd_audio_ac_iface_header_desc_t) +              \
+                               (NUM_VA_ARGS(__VA_ARGS__))),                                 \
+    /*.bInCollection =      */ (NUM_VA_ARGS(__VA_ARGS__)),                                  \
+    /*.baInterfaceNr[] =    */ __VA_ARGS__,                                                 \
+
+
+/**
+ * @brief Initializer of @ref app_usbd_audio_input_terminal_desc_t
+ *
+ * @param terminal_id   Terminal ID.
+ * @param terminal_type Terminal type @ref app_usbd_audio_terminal_type_t
+ * @param nr_channels   Number of channels.
+ * @param ch_config     Channel config bitmask.
+ * */
+#define APP_USBD_AUDIO_INPUT_TERMINAL_DSC(terminal_id, terminal_type, nr_channels, ch_config) \
+    /*.bLength =            */ sizeof(app_usbd_audio_input_terminal_desc_t),                  \
+    /*.bDescriptorType =    */ APP_USBD_AUDIO_DESCRIPTOR_INTERFACE,                           \
+    /*.bDescriptorSubtype = */ APP_USBD_AUDIO_AC_IFACE_SUBTYPE_INPUT_TERMINAL,                \
+    /*.bTerminalID =        */ (terminal_id),                                                 \
+    /*.wTerminalType =      */ APP_USBD_U16_TO_RAW_DSC(terminal_type),                        \
+    /*.bAssocTerminal =     */ 0,                                                             \
+    /*.bNrChannels =        */ (nr_channels),                                                 \
+    /*.wChannelConfig =     */ APP_USBD_U16_TO_RAW_DSC(ch_config),                            \
+    /*.iChannelNames =      */ 0,                                                             \
+    /*.iTerminal =          */ 0,                                                             \
+
+
+/**
+ * @brief Initializer of @ref app_usbd_audio_output_terminal_desc_t
+ *
+ * @param terminal_id   Terminal ID.
+ * @param terminal_type Terminal type @ref app_usbd_audio_terminal_type_t
+ * @param source_id     Source ID.
+ * */
+#define APP_USBD_AUDIO_OUTPUT_TERMINAL_DSC(terminal_id, terminal_type, source_id) \
+    /*.bLength =            */ sizeof(app_usbd_audio_output_terminal_desc_t),     \
+    /*.bDescriptorType =    */ APP_USBD_AUDIO_DESCRIPTOR_INTERFACE,               \
+    /*.bDescriptorSubtype = */ APP_USBD_AUDIO_AC_IFACE_SUBTYPE_OUTPUT_TERMINAL,   \
+    /*.bTerminalID =        */ (terminal_id),                                     \
+    /*.wTerminalType =      */ APP_USBD_U16_TO_RAW_DSC(terminal_type),            \
+    /*.bAssocTerminal =     */ 0,                                                 \
+    /*.bSourceID =          */ (source_id),                                       \
+    /*.iTerminal =          */ 0,                                                 \
+
+
+/**
+ * @brief Initializer of @ref app_usbd_audio_feature_unit_desc_t
+ *
+ * @param unit_id   Unit ID.
+ * @param source_id Source ID.
+ * @param ...       List of controls.
+ * */
+#define APP_USBD_AUDIO_FEATURE_UNIT_DSC(unit_id, source_id, ...)             \
+    /*.bLength =            */ sizeof(app_usbd_audio_feature_unit_desc_t) +  \
+                               1 + (NUM_VA_ARGS(__VA_ARGS__)),               \
+    /*.bDescriptorType =    */ APP_USBD_AUDIO_DESCRIPTOR_INTERFACE,          \
+    /*.bDescriptorSubtype = */ APP_USBD_AUDIO_AC_IFACE_SUBTYPE_FEATURE_UNIT, \
+    /*.bUnitID =            */ (unit_id),                                    \
+    /*.bSourceID =          */ (source_id),                                  \
+    /*.bControlSize =       */ sizeof(uint16_t),                             \
+    /*.bmaControls[] =      */ __VA_ARGS__,                                  \
+    /*.iFeature =           */ 0,                                            \
+
+
+/**
+ * @brief Initializer of @ref app_usbd_audio_as_iface_desc_t
+ *
+ * @param terminal_link Terminal link.
+ * @param delay         Delay.
+ * @param format_tag    Format TAG.
+ * */
+#define APP_USBD_AUDIO_AS_IFACE_DSC(terminal_link, delay, format_tag)   \
+    /*.bLength =            */ sizeof(app_usbd_audio_as_iface_desc_t),  \
+    /*.bDescriptorType =    */ APP_USBD_AUDIO_DESCRIPTOR_INTERFACE,     \
+    /*.bDescriptorSubtype = */ APP_USBD_AUDIO_AS_IFACE_SUBTYPE_GENERAL, \
+    /*.bTerminalLink =      */ (terminal_link),                         \
+    /*.bDelay =             */ (delay),                                 \
+    /*.wFormatTag =         */ APP_USBD_U16_TO_RAW_DSC(format_tag),     \
+
+/**
+ * @brief Initializer of @ref app_usbd_audio_as_format_type_one_desc_t
+ *
+ * @param nr_channels       Number of channels.
+ * @param subframe_size     Subframe size.
+ * @param resolution        Bit resolution.
+ * @param freq_type         Frequency type.
+ * @param ...               List of frequencies.
+ * */
+#define APP_USBD_AUDIO_AS_FORMAT_I_DSC(nr_channels, subframe_size, resolution, freq_type, ...) \
+    /*.bLength =            */ sizeof(app_usbd_audio_as_format_type_one_desc_t) +              \
+                               (NUM_VA_ARGS(__VA_ARGS__)),                                     \
+    /*.bDescriptorType =    */ APP_USBD_AUDIO_DESCRIPTOR_INTERFACE,                            \
+    /*.bDescriptorSubtype = */ APP_USBD_AUDIO_AS_IFACE_SUBTYPE_FORMAT_TYPE,                    \
+    /*.bFormatType =        */ (1),                                                            \
+    /*.bNrChannels =        */ (nr_channels),                                                  \
+    /*.bSubFrameSize =      */ (subframe_size),                                                \
+    /*.bBitResolution =     */ (resolution),                                                   \
+    /*.bSamFreqType =       */ (freq_type),                                                    \
+    /*.tSamFreq =           */ __VA_ARGS__,                                                    \
+
+/**
+ * @brief Initializer of @ref app_usbd_audio_as_format_type_two_desc_t
+ *
+ * @param max_bitrate        Maximum bitrate.
+ * @param samples_per_frame  Samples per frame.
+ * @param freq_type          Frequency type.
+ * @param ...                List of frequencies.
+ * */
+#define APP_USBD_AUDIO_AS_FORMAT_II_DSC(max_bitrate, samples_per_frame, freq_type, ...) \
+    /*.bLength =            */ sizeof(app_usbd_audio_as_format_type_two_desc_t) +       \
+                            (NUM_VA_ARGS(__VA_ARGS__)),                                 \
+    /*.bDescriptorType =    */ APP_USBD_AUDIO_DESCRIPTOR_INTERFACE,                     \
+    /*.bDescriptorSubtype = */ APP_USBD_AUDIO_AS_IFACE_SUBTYPE_FORMAT_TYPE,             \
+    /*.bFormatType =        */ (2),                                                     \
+    /*.wMaxBitRate =        */ APP_USBD_U16_TO_RAW_DSC(max_bitrate),                    \
+    /*.wSamplesPerFrame =   */ APP_USBD_U16_TO_RAW_DSC(samples_per_frame),              \
+    /*.bSamFreqType =       */ (freq_type),                                             \
+    /*.tSamFreq =           */ __VA_ARGS__,                                             \
+
+/**
+* @brief Initializer of @ref app_usbd_audio_as_format_type_three_desc_t
+ *
+ * @param nr_channels       Number of channels.
+ * @param subframe_size     Subframe size.
+ * @param resolution        Bit resolution.
+ * @param freq_type         Frequency type.
+ * @param ...               List of frequencies.
+ * */
+#define APP_USBD_AUDIO_AS_FORMAT_III_DSC(nr_channels, subframe_size, resolution, freq_type, ...) \
+    /*.bLength =            */ sizeof(app_usbd_audio_as_format_type_three_desc_t) +              \
+                            (NUM_VA_ARGS(__VA_ARGS__)),                                          \
+    /*.bDescriptorType =    */ APP_USBD_AUDIO_DESCRIPTOR_INTERFACE,                              \
+    /*.bDescriptorSubtype = */ APP_USBD_AUDIO_AS_IFACE_SUBTYPE_FORMAT_TYPE,                      \
+    /*.bFormatType =        */ (3),                                                              \
+    /*.bNrChannels =        */ (nr_channels),                                                    \
+    /*.bSubFrameSize =      */ (subframe_size),                                                  \
+    /*.bBitResolution =     */ (resolution),                                                     \
+    /*.bSamFreqType =       */ (freq_type),                                                      \
+    /*.tSamFreq =           */ __VA_ARGS__,                                                      \
+
+
+/**
+ * @brief Initializer of @ref app_usbd_audio_as_endpoint_desc_t
+ *
+ * @param attributes       Endpoint attributes.
+ * @param lock_delay_units Lock delay units.
+ * @param lock_delay       Lock delay.
+ * */
+#define APP_USBD_AUDIO_EP_GENERAL_DSC(attributes, lock_delay_units, lock_delay) \
+    /*.bLength =            */ sizeof(app_usbd_audio_as_endpoint_desc_t),       \
+    /*.bDescriptorType =    */ APP_USBD_AUDIO_DESCRIPTOR_ENDPOINT,              \
+    /*.bDescriptorSubtype = */ APP_USBD_AUDIO_EP_SUBTYPE_GENERAL,               \
+    /*.bmAttributes =       */ (attributes),                                    \
+    /*.bLockDelayUnits =    */ (lock_delay_units),                              \
+    /*.wLockDelay =         */ APP_USBD_U16_TO_RAW_DSC(lock_delay),             \
+
+/**
+ * @brief Macro to configure Audio Class control descriptor.
+ *
+ * @param interface_number  Interface number.
+ * @param descriptor_list   List of descriptors after Audio interface header descriptor.
+ * @param interface_list    List of interfaces passed to @ref APP_USBD_AUDIO_AC_IFACE_HEADER_DSC
+ * */
+#define APP_USBD_AUDIO_CONTROL_DSC(interface_number, descriptor_list, interface_list)              \
+        APP_USBD_AUDIO_INTERFACE_DSC(interface_number, 0, 0, APP_USBD_AUDIO_SUBCLASS_AUDIOCONTROL) \
+        APP_USBD_AUDIO_AC_IFACE_HEADER_DSC(descriptor_list, BRACKET_EXTRACT(interface_list))       \
+        BRACKET_EXTRACT(descriptor_list)
+
+
+/**
+ * @brief Macro to configure Audio Class streaming descriptor.
+ *
+ * @param interface_number  Interface number.
+ * @param alt_setting       Alternate interface setting.
+ * @param ep_num            Number of endpoints.
+ */
+#define APP_USBD_AUDIO_STREAMING_DSC(interface_number, alt_setting, ep_num)    \
+        APP_USBD_AUDIO_INTERFACE_DSC(interface_number, alt_setting, ep_num,    \
+                                    APP_USBD_AUDIO_SUBCLASS_AUDIOSTREAMING)
+
+/**
+ * @brief Macro to configure Audio Class MIDI streaming descriptor.
+ *
+ * @param interface_number  Interface number.
+ * @param alt_setting       Alternate interface setting.
+ * @param ep_num            Number of endpoints.
+ */
+#define APP_USBD_AUDIO_MIDI_STREAMING_DSC(interface_number, alt_setting, ep_num)  \
+        APP_USBD_AUDIO_INTERFACE_DSC(interface_number, alt_setting, ep_num,       \
+                                     APP_USBD_AUDIO_SUBCLASS_MIDISTREAMING)
+
+
+/** @} */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* APP_USBD_AUDIO_DESC_H__ */

components/libraries/usbd/class/audio/app_usbd_audio_internal.h

@@ -0,0 +1,291 @@
+/**
+ * Copyright (c) 2017 - 2020, 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.
+ *
+ */
+#ifndef APP_USBD_AUDIO_INTERNAL_H__
+#define APP_USBD_AUDIO_INTERNAL_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @defgroup app_usbd_audio_internal USB Audio internals
+ * @brief @tagAPI52840 USB Audio class internals.
+ * @ingroup app_usbd_audio
+ * @{
+ */
+
+/**
+ * @brief Forward declaration of type defined by @ref APP_USBD_CLASS_TYPEDEF in audio class.
+ *
+ */
+APP_USBD_CLASS_FORWARD(app_usbd_audio);
+
+/*lint -save -e165*/
+/**
+ * @brief Forward declaration of @ref app_usbd_audio_user_event_e
+ *
+ */
+enum app_usbd_audio_user_event_e;
+
+/*lint -restore*/
+
+/**
+ * @brief User event handler.
+ *
+ * @param[in] p_inst    Class instance.
+ * @param[in] event     User event.
+ *
+ */
+typedef void (*app_usbd_audio_user_ev_handler_t)(app_usbd_class_inst_t const *  p_inst,
+                                                 enum app_usbd_audio_user_event_e event);
+
+
+/**
+ * @brief Audio subclass descriptor.
+ */
+
+typedef struct {
+   size_t                size;
+   uint8_t               type;
+   uint8_t const * const p_data;
+} app_usbd_audio_subclass_desc_t;
+
+/**
+ * @brief Audio class part of class instance data.
+ */
+typedef struct {
+
+    app_usbd_audio_subclass_desc_t const * const p_format_dsc;  //!< Audio class Format descriptor
+    app_usbd_audio_subclass_desc_t const * const p_input_dsc;   //!< Audio class Input Terminal descriptor
+    app_usbd_audio_subclass_desc_t const * const p_output_dsc;  //!< Audio class Output Terminal descriptor
+    app_usbd_audio_subclass_desc_t const * const p_feature_dsc; //!< Audio class Feature Unit descriptor
+
+    uint8_t  delay;         //!< Streaming delay
+    uint16_t format;        //!< FormatTag (@ref app_usbd_audio_as_iface_format_tag_t)
+    uint16_t ep_size;       //!< Endpoint size
+    uint8_t  terminal_link; //!< Terminal link in AS Interface Descriptor
+
+    app_usbd_audio_subclass_t type_streaming;   //!< Streaming type MIDISTREAMING/AUDIOSTREAMING (@ref app_usbd_audio_subclass_t)
+
+    app_usbd_audio_user_ev_handler_t user_ev_handler; //!< User event handler
+} app_usbd_audio_inst_t;
+
+/**
+ * @brief Audio class request target.
+ */
+typedef enum {
+    APP_USBD_AUDIO_CLASS_REQ_IN,  /**< Audio class request IN              */
+    APP_USBD_AUDIO_CLASS_REQ_OUT, /**< Audio class request OUT             */
+    APP_USBD_AUDIO_EP_REQ_IN,     /**< Audio class endpoint request IN     */
+    APP_USBD_AUDIO_EP_REQ_OUT,    /**< Audio class endpoint request OUT    */
+} app_usbd_audio_class_req_target_t;
+
+/**
+ * @brief Audio class specific request handled via control endpoint.
+ */
+typedef struct {
+    app_usbd_audio_class_req_target_t req_target;   //!< Request target
+    app_usbd_audio_req_type_t         req_type;     //!< Request type
+
+    uint8_t  control;       //!< Request control field
+    uint8_t  channel;       //!< Channel ID
+    uint8_t  interface;     //!< Interface ID
+    uint8_t  entity;        //!< Entity ID
+    uint16_t length;        //!< Request payload length
+
+    uint8_t payload[64];    //!< Request payload
+} app_usbd_audio_req_t;
+
+
+/**
+ * @brief Audio class context.
+ *
+ */
+typedef struct {
+    app_usbd_audio_req_t                request;        //!< Audio class request
+    bool                                streaming;      //!< Streaming flag
+    app_usbd_sof_interrupt_handler_t    sof_handler;    //!< SOF event handler
+} app_usbd_audio_ctx_t;
+
+
+/**
+ * @brief Audio class configuration macro.
+ *
+ * Used by @ref APP_USBD_AUDIO_GLOBAL_DEF
+ *
+ * @param iface_control     Interface number of audio control.
+ * @param iface_stream      Interface number of audio stream.
+ */
+#define APP_USBD_AUDIO_CONFIG(iface_control, iface_stream)  \
+        ((iface_control),                                   \
+         (iface_stream, 0))
+
+/**
+ * @brief Only IN audio stream configuration.
+ *
+ * @param iface_control     Interface number of audio control.
+ * @param iface_stream_in   Interface number of audio stream on IN endpoint.
+ */
+#define APP_USBD_AUDIO_CONFIG_IN(iface_control, iface_stream_in)  \
+        ((iface_control), (iface_stream_in, NRF_DRV_USBD_EPIN8))
+
+
+/**
+ * @brief Only OUT audio stream configuration.
+ *
+ * @param iface_control     Interface number of audio control.
+ * @param iface_stream_out  Interface number of audio stream on OUT endpoint.
+ */
+#define APP_USBD_AUDIO_CONFIG_OUT(iface_control, iface_stream_out)  \
+        ((iface_control), (iface_stream_out, NRF_DRV_USBD_EPOUT8))
+
+/**
+ * @brief Specific class constant data for audio class.
+ *
+ * @ref app_usbd_audio_inst_t
+ */
+#define APP_USBD_AUDIO_INSTANCE_SPECIFIC_DEC app_usbd_audio_inst_t inst;
+
+/**
+ * @brief Configures audio class instance.
+ *
+ * @param user_event_handler        User event handler.
+ * @param format_descriptor         Audio class Format descriptor.
+ * @param input_descriptor          Audio class Input Terminal descriptor.
+ * @param output_descriptor         Audio class Output Terminal descriptor.
+ * @param feature_descriptor        Audio class Feature Unit descriptor.
+ * @param dlay                      Streaming delay.
+ * @param frmat                     FormatTag (@ref app_usbd_audio_as_iface_format_tag_t).
+ * @param ep_siz                    Endpoint size.
+ * @param type_str                  Streaming type MIDISTREAMING/AUDIOSTREAMING.
+ * @param terminal                  Terminal link in AS Interface Descriptor.
+ */
+ #define APP_USBD_AUDIO_INST_CONFIG(user_event_handler,             \
+                                    format_descriptor,              \
+                                    input_descriptor,               \
+                                    output_descriptor,              \
+                                    feature_descriptor,             \
+                                    dlay,                           \
+                                    frmat,                          \
+                                    ep_siz,                         \
+                                    type_str,                       \
+                                    terminal)                       \
+    .inst = {                                                       \
+         .user_ev_handler = user_event_handler,                     \
+         .p_format_dsc    = format_descriptor,                      \
+         .p_input_dsc     = input_descriptor,                       \
+         .p_output_dsc    = output_descriptor,                      \
+         .p_feature_dsc   = feature_descriptor,                     \
+         .delay           = dlay,                                   \
+         .format          = frmat,                                  \
+         .ep_size         = ep_siz,                                 \
+         .type_streaming  = type_str,                               \
+         .terminal_link   = terminal                                \
+    }
+
+/**
+ * @brief Specific class data for audio class.
+ *
+ * @ref app_usbd_audio_ctx_t
+ */
+#define APP_USBD_AUDIO_DATA_SPECIFIC_DEC app_usbd_audio_ctx_t ctx;
+
+
+/**
+ * @brief Audio class descriptors config macro.
+ *
+ * @param interface_number Interface number.
+ * @param ...              Extracted endpoint list.
+ */
+#define APP_USBD_AUDIO_DSC_CONFIG(interface_number, ...) {              \
+    APP_USBD_AUDIO_INTERFACE_DSC(interface_number,                      \
+                                 0,                                     \
+                                 0,                                     \
+                                 APP_USBD_AUDIO_SUBCLASS_AUDIOCONTROL)  \
+    }
+
+/**
+ * @brief Public audio class interface.
+ *
+ */
+extern const app_usbd_class_methods_t app_usbd_audio_class_methods;
+
+/**
+ * @brief Global definition of @ref app_usbd_audio_t class
+ *
+ */
+ #define APP_USBD_AUDIO_GLOBAL_DEF_INTERNAL(instance_name,          \
+                                    interfaces_configs,             \
+                                    user_ev_handler,                \
+                                    format_descriptor,              \
+                                    input_descriptor,               \
+                                    output_descriptor,              \
+                                    feature_descriptor,             \
+                                    delay,                          \
+                                    format,                         \
+                                    ep_size,                        \
+                                    type_str,                       \
+                                    terminal_link)                  \
+    APP_USBD_CLASS_INST_GLOBAL_DEF(                                 \
+        instance_name,                                              \
+        app_usbd_audio,                                             \
+        &app_usbd_audio_class_methods,                              \
+        interfaces_configs,                                         \
+        (APP_USBD_AUDIO_INST_CONFIG(user_ev_handler,                \
+                                    format_descriptor,              \
+                                    input_descriptor,               \
+                                    output_descriptor,              \
+                                    feature_descriptor,             \
+                                    delay,                          \
+                                    format,                         \
+                                    ep_size,                        \
+                                    type_str,                       \
+                                    terminal_link))                 \
+    )
+
+
+/** @} */
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* APP_USBD_AUDIO_INTERNAL_H__ */

components/libraries/usbd/class/audio/app_usbd_audio_types.h

@@ -0,0 +1,382 @@
+/**
+ * Copyright (c) 2016 - 2020, 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.
+ *
+ */
+#ifndef APP_USBD_AUDIO_TYPES_H__
+#define APP_USBD_AUDIO_TYPES_H__
+
+#include "app_util.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @defgroup app_usbd_audio_types USB Audio types
+ * @brief @tagAPI52840 Type definitions for the USB Audio class.
+ * @ingroup app_usbd_audio
+ * @{
+ */
+
+/** @brief Audio class definition in interface descriptor.
+ *
+ *  Fixed value, @ref app_usbd_descriptor_iface_t::bInterfaceClass
+ * */
+#define  APP_USBD_AUDIO_CLASS                  0x01
+
+/** @brief Audio class protocol definition in interface descriptor.
+ *
+ *  Fixed value, @ref app_usbd_descriptor_iface_t::bInterfaceProtocol
+ * */
+#define  APP_USBD_AUDIO_CLASS_PROTOCOL_UNDEFINED  0x00
+
+/**
+ * @brief Audio subclass possible values.
+ *
+ * @ref app_usbd_descriptor_iface_t::bInterfaceSubClass
+ */
+typedef enum {
+    APP_USBD_AUDIO_SUBCLASS_UNDEFINED = 0x00, /**< UNDEFINED subclass      */
+    APP_USBD_AUDIO_SUBCLASS_AUDIOCONTROL,     /**< AUDIOCONTROL subclass   */
+    APP_USBD_AUDIO_SUBCLASS_AUDIOSTREAMING,   /**< AUDIOSTREAMING subclass */
+    APP_USBD_AUDIO_SUBCLASS_MIDISTREAMING     /**< MIDISTREAMING  subclass */
+} app_usbd_audio_subclass_t;
+
+
+/**
+ * @brief Audio class specific descriptor types
+ */
+typedef enum {
+    APP_USBD_AUDIO_DESCRIPTOR_UNDEFINED     = 0x20, /**< UNDEFINED descriptor type     */
+    APP_USBD_AUDIO_DESCRIPTOR_DEVICE        = 0x21, /**< DEVICE descriptor type        */
+    APP_USBD_AUDIO_DESCRIPTOR_CONFIGURATION = 0x22, /**< CONFIGURATION descriptor type */
+    APP_USBD_AUDIO_DESCRIPTOR_STRING        = 0x23, /**< STRING descriptor type        */
+    APP_USBD_AUDIO_DESCRIPTOR_INTERFACE     = 0x24, /**< INTERFACE descriptor type     */
+    APP_USBD_AUDIO_DESCRIPTOR_ENDPOINT      = 0x25, /**< ENDPOINT descriptor type      */
+} app_usbd_audio_descriptor_type_t;
+
+
+/**
+ * @brief Audio control interface subtype
+ */
+typedef enum {
+    APP_USBD_AUDIO_AC_IFACE_SUBTYPE_UNDEFINED = 0x00, /**< Audio control interface subtype UNDEFINED       */
+    APP_USBD_AUDIO_AC_IFACE_SUBTYPE_HEADER,           /**< Audio control interface subtype HEADER          */
+    APP_USBD_AUDIO_AC_IFACE_SUBTYPE_INPUT_TERMINAL,   /**< Audio control interface subtype INPUT_TERMINAL  */
+    APP_USBD_AUDIO_AC_IFACE_SUBTYPE_OUTPUT_TERMINAL,  /**< Audio control interface subtype OUTPUT_TERMINAL */
+    APP_USBD_AUDIO_AC_IFACE_SUBTYPE_MIXER_UNIT,       /**< Audio control interface subtype MIXER_UNIT      */
+    APP_USBD_AUDIO_AC_IFACE_SUBTYPE_SELECTOR_UNIT,    /**< Audio control interface subtype SELECTOR_UNIT   */
+    APP_USBD_AUDIO_AC_IFACE_SUBTYPE_FEATURE_UNIT,     /**< Audio control interface subtype FEATURE_UNIT    */
+    APP_USBD_AUDIO_AC_IFACE_SUBTYPE_PROCESSING_UNIT,  /**< Audio control interface subtype PROCESSING_UNIT */
+    APP_USBD_AUDIO_AC_IFACE_SUBTYPE_EXTENSION_UNIT,   /**< Audio control interface subtype EXTENSION_UNIT  */
+} app_usbd_audio_ac_iface_subtype_t;
+
+/**
+ * @brief Audio streaming interface subtype
+ */
+typedef enum {
+    APP_USBD_AUDIO_AS_IFACE_SUBTYPE_UNDEFINED = 0x00, /**< Audio streaming interface subtype UNDEFINED      */
+    APP_USBD_AUDIO_AS_IFACE_SUBTYPE_GENERAL,          /**< Audio streaming interface subtype GENERAL        */
+    APP_USBD_AUDIO_AS_IFACE_SUBTYPE_FORMAT_TYPE,      /**< Audio streaming interface subtype FORMAT_TYPE    */
+    APP_USBD_AUDIO_AS_IFACE_SUBTYPE_FORMAT_SPECIFIC,  /**< Audio streaming interface subtype FORMAT_SPECIFIC*/
+} app_usbd_audio_as_iface_subtype_t;
+
+
+/**
+ * @brief Audio class specific endpoint subtypes
+ */
+typedef enum {
+    APP_USBD_AUDIO_EP_SUBTYPE_UNDEFINED = 0x00, /**< APP_USBD_AUDIO_EP_SUBTYPE_UNDEFINED */
+    APP_USBD_AUDIO_EP_SUBTYPE_GENERAL,          /**< APP_USBD_AUDIO_EP_SUBTYPE_GENERAL   */
+} app_usbd_audio_ep_subtype_t;
+
+/**
+ * @brief Audio class specific requests.
+ *
+ * @ref nrf_drv_usbd_setup_t::bmRequestType
+ */
+typedef enum {
+    APP_USBD_AUDIO_REQ_UNDEFINED = 0x00, /**< UNDEFINED request*/
+
+    APP_USBD_AUDIO_REQ_SET_CUR   = 0x01, /**< SET_CUR request  */
+    APP_USBD_AUDIO_REQ_SET_MIN   = 0x02, /**< SET_MIN request  */
+    APP_USBD_AUDIO_REQ_SET_MAX   = 0x03, /**< SET_MAX request  */
+    APP_USBD_AUDIO_REQ_SET_RES   = 0x04, /**< SET_RES request  */
+    APP_USBD_AUDIO_REQ_SET_MEM   = 0x05, /**< SET_MEM request  */
+
+    APP_USBD_AUDIO_REQ_GET_CUR   = 0x81, /**< GET_CUR request  */
+    APP_USBD_AUDIO_REQ_GET_MIN   = 0x82, /**< GET_MIN request  */
+    APP_USBD_AUDIO_REQ_GET_MAX   = 0x83, /**< GET_MAX request  */
+    APP_USBD_AUDIO_REQ_GET_RES   = 0x84, /**< GET_RES request  */
+    APP_USBD_AUDIO_REQ_GET_MEM   = 0x85, /**< GET_MEM request  */
+
+    APP_USBD_AUDIO_REQ_GET_STAT  = 0xFF, /**< GET_STAT request */
+} app_usbd_audio_req_type_t;
+
+/**
+ * @brief Audio class terminal types.
+ * */
+typedef enum {
+    /*USB terminals*/
+    APP_USBD_AUDIO_TERMINAL_USB_UNDEFINED   = 0x0100,   /**< USB_UNDEFINED*/
+    APP_USBD_AUDIO_TERMINAL_USB_STREAMING   = 0x0101,   /**< USB_STREAMING */
+    APP_USBD_AUDIO_TERMINAL_USB_VENDOR_SPEC = 0x01FF,   /**< USB_VENDOR_SPEC*/
+
+    /*Input terminals*/
+    APP_USBD_AUDIO_TERMINAL_IN_UNDEFINED      = 0x0200, /**< UNDEFINED      */
+    APP_USBD_AUDIO_TERMINAL_IN_MICROPHONE     = 0x0201, /**< MICROPHONE     */
+    APP_USBD_AUDIO_TERMINAL_IN_DESKTOP_MIC    = 0x0202, /**< DESKTOP_MIC    */
+    APP_USBD_AUDIO_TERMINAL_IN_PERSONAL_MIC   = 0x0203, /**< PERSONAL_MIC   */
+    APP_USBD_AUDIO_TERMINAL_IN_OM_DIR_MIC     = 0x0204, /**< OM_DIR_MIC     */
+    APP_USBD_AUDIO_TERMINAL_IN_MIC_ARRAY      = 0x0205, /**< MIC_ARRAY      */
+    APP_USBD_AUDIO_TERMINAL_IN_PROC_MIC_ARRAY = 0x0205, /**< PROC_MIC_ARRAY */
+
+    /*Output terminals*/
+    APP_USBD_AUDIO_TERMINAL_OUT_UNDEFINED        = 0x0300, /**< UNDEFINED        */
+    APP_USBD_AUDIO_TERMINAL_OUT_SPEAKER          = 0x0301, /**< SPEAKER          */
+    APP_USBD_AUDIO_TERMINAL_OUT_HEADPHONES       = 0x0302, /**< HEADPHONES       */
+    APP_USBD_AUDIO_TERMINAL_OUT_HEAD_AUDIO       = 0x0303, /**< HEAD_AUDIO       */
+    APP_USBD_AUDIO_TERMINAL_OUT_DESKTOP_SPEAKER  = 0x0304, /**< DESKTOP_SPEAKER  */
+    APP_USBD_AUDIO_TERMINAL_OUT_ROOM_SPEAKER     = 0x0305, /**< ROOM_SPEAKER     */
+    APP_USBD_AUDIO_TERMINAL_OUT_COMM_SPEAKER     = 0x0306, /**< COMM_SPEAKER     */
+    APP_USBD_AUDIO_TERMINAL_OUT_LOW_FREQ_SPEAKER = 0x0307, /**< LOW_FREQ_SPEAKER */
+
+    /*Input/Output terminals*/
+    APP_USBD_AUDIO_TERMINAL_IO_UNDEFINED              = 0x0400, /**< UNDEFINED              */
+    APP_USBD_AUDIO_TERMINAL_IO_HANDSET                = 0x0401, /**< HANDSET                */
+    APP_USBD_AUDIO_TERMINAL_IO_HEADSET                = 0x0402, /**< HEADSET                */
+    APP_USBD_AUDIO_TERMINAL_IO_SPEAKERPHONE_ECHO_NONE = 0x0403, /**< SPEAKERPHONE_ECHO_NONE */
+    APP_USBD_AUDIO_TERMINAL_IO_SPEAKERPHONE_ECHO_SUP  = 0x0404, /**< SPEAKERPHONE_ECHO_SUP  */
+    APP_USBD_AUDIO_TERMINAL_IO_SPEAKERPHONE_ECHO_CAN  = 0x0405, /**< SPEAKERPHONE_ECHO_CAN  */
+} app_usbd_audio_terminal_type_t;
+
+/**
+ * @brief Audio class control interface header descriptor.
+ */
+typedef struct {
+    uint8_t bLength;             //!< Length of the descriptor
+    uint8_t bDescriptorType;     //!< Descriptor type @ref APP_USBD_AUDIO_DESCRIPTOR_INTERFACE
+    uint8_t bDescriptorSubtype;  //!< Descriptor subtype @ref APP_USBD_AUDIO_AC_IFACE_SUBTYPE_HEADER
+    uint8_t bcdADC[2];           //!< BCD ADC
+    uint8_t wTotalLength[2];     //!< Total interfaces length
+    uint8_t bInCollection;       //!< Input collection
+    uint8_t baInterfaceNr[];     //!< Interface number list
+} app_usbd_audio_ac_iface_header_desc_t;
+
+
+/**
+ * @brief Possible values of input terminal channel config.
+ *
+ * @ref app_usbd_audio_input_terminal_desc_t::wChannelConfig
+ * */
+typedef enum {
+    APP_USBD_AUDIO_IN_TERM_CH_CONFIG_LEFT_FRONT         = (1u << 0),  /**< Channel config bit LEFT_FRONT      */
+    APP_USBD_AUDIO_IN_TERM_CH_CONFIG_RIGHT_FRONT        = (1u << 1),  /**< Channel config bit RIGHT_FRONT     */
+    APP_USBD_AUDIO_IN_TERM_CH_CONFIG_CENTER_FRONT       = (1u << 2),  /**< Channel config bit CENTER_FRONT    */
+    APP_USBD_AUDIO_IN_TERM_CH_CONFIG_LOW_FREQ_ENH       = (1u << 3),  /**< Channel config bit LOW_FREQ_ENH    */
+    APP_USBD_AUDIO_IN_TERM_CH_CONFIG_LEFT_SURROUND      = (1u << 4),  /**< Channel config bit LEFT_SURROUND   */
+    APP_USBD_AUDIO_IN_TERM_CH_CONFIG_RIGHT_SURROUND     = (1u << 5),  /**< Channel config bit RIGHT_SURROUND  */
+    APP_USBD_AUDIO_IN_TERM_CH_CONFIG_LEFT_OF_CENTER     = (1u << 6),  /**< Channel config bit LEFT_OF_CENTER  */
+    APP_USBD_AUDIO_IN_TERM_CH_CONFIG_RIGHT_OF_CENTER    = (1u << 7),  /**< Channel config bit RIGHT_OF_CENTER */
+    APP_USBD_AUDIO_IN_TERM_CH_CONFIG_SURROUND           = (1u << 8),  /**< Channel config bit SURROUND        */
+    APP_USBD_AUDIO_IN_TERM_CH_CONFIG_SIDE_LEFT          = (1u << 9),  /**< Channel config bit SIDE_LEFT       */
+    APP_USBD_AUDIO_IN_TERM_CH_CONFIG_SIDE_RIGHT         = (1u << 10), /**< Channel config bit SIDE_RIGHT      */
+    APP_USBD_AUDIO_IN_TERM_CH_CONFIG_TOP                = (1u << 11), /**< Channel config bit TOP             */
+} app_usbd_audio_in_term_ch_config_t;
+
+/**
+ * @brief Audio class input terminal descriptor.
+ */
+typedef struct {
+    uint8_t bLength;             //!< Length of the descriptor
+    uint8_t bDescriptorType;     //!< Descriptor type @ref APP_USBD_AUDIO_DESCRIPTOR_INTERFACE
+    uint8_t bDescriptorSubtype;  //!< Descriptor subtype @ref APP_USBD_AUDIO_AC_IFACE_SUBTYPE_INPUT_TERMINAL
+    uint8_t bTerminalID;         //!< Terminal ID
+    uint8_t wTerminalType[2];    //!< Terminal type
+    uint8_t bAssocTerminal;      //!< Association terminal
+    uint8_t bNrChannels;         //!< Number of channels
+    uint8_t wChannelConfig[2];   //!< Channel config
+    uint8_t iChannelNames;       //!< Channel names
+    uint8_t iTerminal;           //!< Terminal string ID
+} app_usbd_audio_input_terminal_desc_t;
+
+/**
+ * @brief Audio class output terminal descriptor.
+ */
+typedef struct {
+    uint8_t bLength;            //!< Length of the descriptor
+    uint8_t bDescriptorType;    //!< Descriptor type @ref APP_USBD_AUDIO_DESCRIPTOR_INTERFACE
+    uint8_t bDescriptorSubtype; //!< Descriptor subtype @ref APP_USBD_AUDIO_AC_IFACE_SUBTYPE_OUTPUT_TERMINAL
+    uint8_t bTerminalID;        //!< Terminal ID
+    uint8_t wTerminalType[2];   //!< Terminal type
+    uint8_t bAssocTerminal;     //!< Association terminal
+    uint8_t bSourceID;          //!< Source ID
+    uint8_t iTerminal;          //!< Terminal string ID
+} app_usbd_audio_output_terminal_desc_t;
+
+/**
+ * @brief Possible values of feature unit control field.
+ */
+typedef enum {
+    APP_USBD_AUDIO_FEATURE_UNIT_CONTROL_MUTE       = (1u << 0), /**< Feature unit control bit MUTE      */
+    APP_USBD_AUDIO_FEATURE_UNIT_CONTROL_VOLUME     = (1u << 1), /**< Feature unit control bit VOLUME    */
+    APP_USBD_AUDIO_FEATURE_UNIT_CONTROL_BASS       = (1u << 2), /**< Feature unit control bit BASS      */
+    APP_USBD_AUDIO_FEATURE_UNIT_CONTROL_MID        = (1u << 3), /**< Feature unit control bit MID       */
+    APP_USBD_AUDIO_FEATURE_UNIT_CONTROL_TREBLE     = (1u << 4), /**< Feature unit control bit TREBLE    */
+    APP_USBD_AUDIO_FEATURE_UNIT_CONTROL_GRAPH_EQ   = (1u << 5), /**< Feature unit control bit GRAPH_EQ  */
+    APP_USBD_AUDIO_FEATURE_UNIT_CONTROL_AUTO_GAIN  = (1u << 6), /**< Feature unit control bit AUTO_GAIN */
+    APP_USBD_AUDIO_FEATURE_UNIT_CONTROL_DELAY      = (1u << 7), /**< Feature unit control bit DELAY     */
+    APP_USBD_AUDIO_FEATURE_UNIT_CONTROL_BASS_BOOST = (1u << 8), /**< Feature unit control bit BASS_BOOST*/
+    APP_USBD_AUDIO_FEATURE_UNIT_CONTROL_LOUDNESS   = (1u << 9), /**< Feature unit control bit LOUDNESS  */
+} app_usbd_audio_feature_unit_control_t;
+
+/**
+ * @brief Audio class feature unit descriptor.
+ */
+typedef struct {
+    uint8_t bLength;                //!< Length of the descriptor
+    uint8_t bDescriptorType;        //!< Descriptor type @ref APP_USBD_AUDIO_DESCRIPTOR_INTERFACE
+    uint8_t bDescriptorSubtype;     //!< Descriptor subtype @ref APP_USBD_AUDIO_AC_IFACE_SUBTYPE_FEATURE_UNIT
+    uint8_t bUnitID;                //!< Unit ID
+    uint8_t bSourceID;              //!< Source ID
+    uint8_t bControlSize;           //!< Control size
+    uint8_t bmaControls[];          //!< Controls array
+} app_usbd_audio_feature_unit_desc_t;
+
+/**
+ * @brief   Format tag in audio streaming interface descriptor.
+ *
+ * @ref app_usbd_audio_as_iface_desc_t::wFormatTag
+ * */
+typedef enum {
+    APP_USBD_AUDIO_AS_IFACE_FORMAT_TYPE_I_UNDEFINED = 0x0000, /**< AS format TYPE_I_UNDEFINED  */
+    APP_USBD_AUDIO_AS_IFACE_FORMAT_PCM              = 0x0001, /**< AS format PCM               */
+    APP_USBD_AUDIO_AS_IFACE_FORMAT_PCM8             = 0x0002, /**< AS format PCM8              */
+    APP_USBD_AUDIO_AS_IFACE_FORMAT_IEEE_FLOAT       = 0x0003, /**< AS format IEEE_FLOAT        */
+    APP_USBD_AUDIO_AS_IFACE_FORMAT_ALAW             = 0x0004, /**< AS format ALAW              */
+    APP_USBD_AUDIO_AS_IFACE_FORMAT_MULAW            = 0x0005, /**< AS format MULAW             */
+
+    APP_USBD_AUDIO_AS_IFACE_FORMAT_TYPE_II_UNDEFINED = 0x1000, /**< AS format TYPE_II_UNDEFINED  */
+    APP_USBD_AUDIO_AS_IFACE_FORMAT_MPEG              = 0x1001, /**< AS format MPEG               */
+    APP_USBD_AUDIO_AS_IFACE_FORMAT_AC3               = 0x1002, /**< AS format AC3                */
+
+    APP_USBD_AUDIO_AS_IFACE_FORMAT_TYPE_III_UNDEFINED        = 0x2000, /**< AS format TYPE_III_UNDEFINED         */
+    APP_USBD_AUDIO_AS_IFACE_FORMAT_IEC1937_AC_3              = 0x2001, /**< AS format IEC1937_AC_3               */
+    APP_USBD_AUDIO_AS_IFACE_FORMAT_IEC1937_MPEG_1_LAYER1     = 0x2002, /**< AS format IEC1937_MPEG_1_LAYER1      */
+    APP_USBD_AUDIO_AS_IFACE_FORMAT_IEC1937_MPEG_2_NOEXT      = 0x2003, /**< AS format IEC1937_MPEG_2_NOEXT       */
+    APP_USBD_AUDIO_AS_IFACE_FORMAT_IEC1937_MPEG_2_EXT        = 0x2004, /**< AS format IEC1937_MPEG_2_EXT         */
+    APP_USBD_AUDIO_AS_IFACE_FORMAT_IEC1937_MPEG_2_LAYER1_LS  = 0x2005, /**< AS format IEC1937_MPEG_2_LAYER1_LS   */
+    APP_USBD_AUDIO_AS_IFACE_FORMAT_IEC1937_MPEG_2_LAYER23_LS = 0x2005, /**< AS format IEC1937_MPEG_2_LAYER23_LS  */
+} app_usbd_audio_as_iface_format_tag_t;
+
+/**
+ * @brief Audio class audio streaming interface descriptor.
+ */
+typedef struct {
+    uint8_t bLength;                //!< Length of the descriptor
+    uint8_t bDescriptorType;        //!< Descriptor type @ref APP_USBD_AUDIO_DESCRIPTOR_INTERFACE
+    uint8_t bDescriptorSubtype;     //!< Descriptor subtype @ref app_usbd_audio_ac_iface_subtype_t
+    uint8_t bTerminalLink;          //!< Terminal link
+    uint8_t bDelay;                 //!< Delay
+    uint8_t wFormatTag[2];          //!< Format TAG
+} app_usbd_audio_as_iface_desc_t;
+
+/**
+ * @brief Audio class audio streaming format type I descriptor.
+ */
+typedef struct {
+    uint8_t bLength;                //!< Length of the descriptor
+    uint8_t bDescriptorType;        //!< Descriptor type @ref APP_USBD_AUDIO_DESCRIPTOR_INTERFACE
+    uint8_t bDescriptorSubtype;     //!< Descriptor subtype @ref app_usbd_audio_as_iface_subtype_t
+    uint8_t bFormatType;            //!< Format type: fixed value 1
+    uint8_t bNrChannels;            //!< Number of channels
+    uint8_t bSubframeSize;          //!< Subframe size
+    uint8_t bBitResolution;         //!< Bit resolution
+    uint8_t bSamFreqType;           //!< Number of supported sampling frequencies
+    uint8_t tSamFreq[];             //!< Number of supported sampling frequencies table (24 bit entries)
+} app_usbd_audio_as_format_type_one_desc_t;
+
+
+/**
+ * @brief Audio class audio streaming format type II descriptor.
+ */
+typedef struct {
+    uint8_t bLength;                //!< Length of the descriptor
+    uint8_t bDescriptorType;        //!< Descriptor type @ref APP_USBD_AUDIO_DESCRIPTOR_INTERFACE
+    uint8_t bDescriptorSubtype;     //!< Descriptor subtype @ref app_usbd_audio_as_iface_subtype_t
+    uint8_t bFormatType;            //!< Format type: fixed value 2
+    uint8_t wMaxBitRate[2];         //!< Maximum bitrate
+    uint8_t wSamplesPerFrame[2];    //!< Samples per frame
+    uint8_t bSamFreqType;           //!< Number of supported sampling frequencies
+    uint8_t tSamFreq[];             //!< Number of supported sampling frequencies table (24 bit entries)
+} app_usbd_audio_as_format_type_two_desc_t;
+
+/**
+ * @brief Audio class audio streaming format type III descriptor.
+ */
+typedef struct {
+    uint8_t bLength;              //!< Length of the descriptor
+    uint8_t bDescriptorType;      //!< Descriptor type @ref APP_USBD_AUDIO_DESCRIPTOR_INTERFACE
+    uint8_t bDescriptorSubtype;   //!< Descriptor subtype @ref app_usbd_audio_as_iface_subtype_t
+    uint8_t bFormatType;          //!< Format type: fixed value 1
+    uint8_t bNrChannels;          //!< Number of channels
+    uint8_t bSubframeSize;        //!< Subframe size
+    uint8_t bBitResolution;       //!< Bit resolution
+    uint8_t bSamFreqType;         //!< Number of supported sampling frequencies
+    uint8_t tSamFreq[];           //!< Number of supported sampling frequencies table (24 bit entries)
+} app_usbd_audio_as_format_type_three_desc_t;
+
+/**
+ * @brief Audio class audio endpoint descriptor.
+ */
+typedef struct {
+    uint8_t bLength;                //!< Length of the descriptor
+    uint8_t bDescriptorType;        //!< Descriptor type @ref APP_USBD_AUDIO_DESCRIPTOR_ENDPOINT
+    uint8_t bDescriptorSubtype;     //!< Descriptor subtype @ref APP_USBD_AUDIO_EP_SUBTYPE_GENERAL
+    uint8_t bmAttributes;           //!< Audio endpoint attributes
+    uint8_t bLockDelayUnits;        //!< Lock delay units
+    uint8_t wLockDelay[2];          //!< Lock delay value
+} app_usbd_audio_as_endpoint_desc_t;
+
+/** @} */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* APP_USBD_AUDIO_TYPES_H__ */

components/libraries/usbd/class/cdc/acm/app_usbd_cdc_acm.h

@@ -0,0 +1,362 @@
+/**
+ * Copyright (c) 2017 - 2020, 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.
+ *
+ */
+#ifndef APP_USBD_CDC_ACM_H__
+#define APP_USBD_CDC_ACM_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+#include <stdbool.h>
+
+#include "nrf_drv_usbd.h"
+#include "app_usbd_class_base.h"
+#include "app_usbd.h"
+#include "app_usbd_core.h"
+#include "app_usbd_descriptor.h"
+
+#include "app_usbd_cdc_desc.h"
+#include "app_usbd_cdc_types.h"
+#include "app_usbd_cdc_acm_internal.h"
+
+/**
+ * @defgroup app_usbd_cdc_acm USB CDC ACM class
+ * @ingroup app_usbd
+ *
+ * @brief @tagAPI52840 Module with types, definitions and API used by CDC ACM class.
+ *
+ * @details References:
+ * - "Universal Serial Bus Class Definitions for Communications Devices"
+ *      Revision 1.2, November 3, 2010
+ * - "Universal Serial Bus Communications Class Subclass Specification for PSTN Devices"
+ *      Revision 1.2, February 9, 2007
+ *
+ * @{
+ */
+
+#ifdef DOXYGEN
+/**
+ * @brief CDC ACM class instance type.
+ *
+ * @ref APP_USBD_CLASS_TYPEDEF
+ */
+typedef struct { } app_usbd_cdc_acm_t;
+#else
+/*lint -save -e10 -e26 -e123 -e505 */
+APP_USBD_CLASS_TYPEDEF(app_usbd_cdc_acm,            \
+            APP_USBD_CDC_ACM_CONFIG(0, 0, 0, 0, 0), \
+            APP_USBD_CDC_ACM_INSTANCE_SPECIFIC_DEC, \
+            APP_USBD_CDC_ACM_DATA_SPECIFIC_DEC      \
+);
+/*lint -restore*/
+#endif
+
+
+/*lint -save -e407 */
+
+/**
+ * @brief Events passed to user event handler.
+ *
+ * @note Example prototype of user event handler:
+ *
+ * @code
+   void cdc_acm_user_ev_handler(app_usbd_class_inst_t const * p_inst,
+                              app_usbd_cdc_acm_user_event_t   event);
+ * @endcode
+ */
+typedef enum app_usbd_cdc_acm_user_event_e {
+    APP_USBD_CDC_ACM_USER_EVT_RX_DONE,     /**< User event RX_DONE.    */
+    APP_USBD_CDC_ACM_USER_EVT_TX_DONE,     /**< User event TX_DONE.    */
+
+    APP_USBD_CDC_ACM_USER_EVT_PORT_OPEN,   /**< User event PORT_OPEN.  */
+    APP_USBD_CDC_ACM_USER_EVT_PORT_CLOSE,  /**< User event PORT_CLOSE. */
+} app_usbd_cdc_acm_user_event_t;
+
+/*lint -restore*/
+
+/**
+ * @brief Default CDC ACM descriptors.
+ *
+ * @param comm_interface COMM interface number.
+ * @param comm_epin      COMM interface IN endpoint.
+ * @param data_interface DATA interface number.
+ * @param data_epin      DATA interface IN endpoint.
+ * @param data_epout     DATA interface OUT endpoint.
+ */
+#define APP_USBD_CDC_ACM_DEFAULT_DESC(comm_interface,                       \
+                                      comm_epin,                            \
+                                      data_interface,                       \
+                                      data_epin,                            \
+                                      data_epout)                           \
+    APP_USBD_CDC_IAD_DSC(comm_interface,                                    \
+                         APP_USBD_CDC_SUBCLASS_ACM,                         \
+                         APP_USBD_CDC_COMM_PROTOCOL_AT_V250)                \
+    APP_USBD_CDC_COMM_INTERFACE_DSC(comm_interface,                         \
+                                    APP_USBD_CDC_SUBCLASS_ACM,              \
+                                    APP_USBD_CDC_COMM_PROTOCOL_AT_V250)     \
+        APP_USBD_CDC_HEADER_DSC(0x0110)                                     \
+        APP_USBD_CDC_CALL_MGMT_DSC(0x03, data_interface)                    \
+        APP_USBD_CDC_ACM_DSC(0x02)                                          \
+        APP_USBD_CDC_UNION_DSC(comm_interface, data_interface)              \
+        APP_USBD_CDC_COM_EP_DSC(comm_epin, NRF_DRV_USBD_EPSIZE)             \
+    APP_USBD_CDC_DATA_INTERFACE_DSC(data_interface, 0, 0)                   \
+        APP_USBD_CDC_DATA_EP_DSC(data_epin, data_epout, NRF_DRV_USBD_EPSIZE)
+
+/**
+ * @brief Global definition of app_usbd_cdc_acm_t class instance.
+ *
+ * @param instance_name             Name of global instance.
+ * @param user_ev_handler           User event handler (optional).
+ * @param comm_ifc                  Interface number of cdc_acm control.
+ * @param data_ifc                  Interface number of cdc_acm DATA.
+ * @param comm_ein                  COMM subclass IN endpoint.
+ * @param data_ein                  DATA subclass IN endpoint.
+ * @param data_eout                 DATA subclass OUT endpoint.
+ * @param cdc_protocol              CDC protocol @ref app_usbd_cdc_comm_protocol_t
+ *
+ * @note This macro is just simplified version of @ref APP_USBD_CDC_ACM_GLOBAL_DEF_INTERNAL.
+ *
+ */
+#define APP_USBD_CDC_ACM_GLOBAL_DEF(instance_name,                              \
+                                    user_ev_handler,                            \
+                                    comm_ifc,                                   \
+                                    data_ifc,                                   \
+                                    comm_ein,                                   \
+                                    data_ein,                                   \
+                                    data_eout,                                  \
+                                    cdc_protocol)                               \
+    APP_USBD_CDC_ACM_GLOBAL_DEF_INTERNAL(instance_name,                         \
+                                         user_ev_handler,                       \
+                                         comm_ifc,                              \
+                                         data_ifc,                              \
+                                         comm_ein,                              \
+                                         data_ein,                              \
+                                         data_eout,                             \
+                                         cdc_protocol)                          \
+
+/**
+ * @brief Helper function to get class instance from CDC ACM class.
+ *
+ * @param[in] p_cdc_acm CDC ACM class instance (defined by @ref APP_USBD_CDC_ACM_GLOBAL_DEF).
+ *
+ * @return Base class instance.
+ */
+static inline app_usbd_class_inst_t const *
+app_usbd_cdc_acm_class_inst_get(app_usbd_cdc_acm_t const * p_cdc_acm)
+{
+    return &p_cdc_acm->base;
+}
+
+/**
+ * @brief Helper function to get cdc_acm specific request from cdc_acm class.
+ *
+ * @param[in] p_cdc_acm CDC ACM class instance (defined by @ref APP_USBD_CDC_ACM_GLOBAL_DEF).
+ *
+ * @return CDC ACM class specific request.
+ */
+static inline app_usbd_cdc_acm_req_t *
+app_usbd_cdc_acm_class_request_get(app_usbd_cdc_acm_t const * p_cdc_acm)
+{
+    return &p_cdc_acm->specific.p_data->ctx.request;
+}
+
+/**
+ * @brief Helper function to get cdc_acm from base class instance.
+ *
+ * @param[in] p_inst Base class instance.
+ *
+ * @return CDC ACM class handle.
+ */
+static inline app_usbd_cdc_acm_t const *
+app_usbd_cdc_acm_class_get(app_usbd_class_inst_t const * p_inst)
+{
+    return (app_usbd_cdc_acm_t const *)p_inst;
+}
+
+
+/**
+ * @brief Writes data to CDC ACM serial port.
+ *
+ * This is asynchronous call. User should wait for @ref APP_USBD_CDC_ACM_USER_EVT_TX_DONE event
+ * to be sure that all data has been sent and input buffer could be accessed again.
+ *
+ * @param[in] p_cdc_acm CDC ACM class instance (defined by @ref APP_USBD_CDC_ACM_GLOBAL_DEF).
+ * @param[in] p_buf     Input buffer.
+ * @param[in] length    Input buffer length.
+ *
+ * @return Standard error code.
+ */
+ret_code_t app_usbd_cdc_acm_write(app_usbd_cdc_acm_t const * p_cdc_acm,
+                                  const void *               p_buf,
+                                  size_t                     length);
+
+/**
+ * @brief Returns the amount of data that was read.
+ *
+ * This function should be used on @ref APP_USBD_CDC_ACM_USER_EVT_RX_DONE event to get
+ * information how many bytes have been transfered into user buffer.
+ *
+ * @param[in] p_cdc_acm CDC ACM class instance (defined by @ref APP_USBD_CDC_ACM_GLOBAL_DEF).
+ *
+ * @return Amount of data transfered.
+ */
+size_t app_usbd_cdc_acm_rx_size(app_usbd_cdc_acm_t const * p_cdc_acm);
+
+/**
+ * @brief Returns the amount of data that was stored into internal buffer
+ *
+ * This function should be used on @ref APP_USBD_CDC_ACM_USER_EVT_RX_DONE event to get
+ * information how many bytes are waiting in internal buffer.
+ *
+ * @param[in] p_cdc_acm CDC ACM class instance (defined by @ref APP_USBD_CDC_ACM_GLOBAL_DEF).
+ *
+ * @return Amount of data waiting.
+ */
+size_t app_usbd_cdc_acm_bytes_stored(app_usbd_cdc_acm_t const * p_cdc_acm);
+
+/**
+ * @brief Reads data from CDC ACM serial port.
+ *
+ * This function uses internal buffer and double buffering for continuous transmission.
+ *
+ * If there is enough data in internal buffer to fill user buffer, NRF_SUCCESS is
+ * returned and data is immediately available in the user buffer.
+ *
+ * If not, up to two user buffers can be scheduled, function returns NRF_ERROR_IO_PENDING
+ * when first buffer is filled and @ref APP_USBD_CDC_ACM_USER_EVT_RX_DONE event is generated.
+ *
+ * @sa app_usbd_cdc_acm_read_any
+ * @sa app_usbd_cdc_acm_rx_size
+ *
+ * @param[in]  p_cdc_acm CDC ACM class instance (defined by @ref APP_USBD_CDC_ACM_GLOBAL_DEF).
+ * @param[out] p_buf     Output buffer.
+ * @param[in]  length    Number of bytes to read.
+ *
+ * @retval NRF_SUCCESS          Data is stored into user buffer.
+ * @retval NRF_ERROR_IO_PENDING Awaiting transmission, when data is stored into user buffer,
+ *                              @ref APP_USBD_CDC_ACM_USER_EVT_RX_DONE event will be raised.
+ * @retval NRF_ERROR_BUSY       There are already 2 buffers queued for transfers.
+ * @retval other                Standard error code.
+ */
+ret_code_t app_usbd_cdc_acm_read(app_usbd_cdc_acm_t const * p_cdc_acm,
+                                 void *                     p_buf,
+                                 size_t                     length);
+
+/**
+ * @brief Read any data from CDC ACM port up to given buffer size
+ *
+ * This function is very similar to the @ref app_usbd_cdc_acm_read but it returns
+ * data as quick as any data is available, even if the given buffer was not totally full.
+ *
+ * @note This function cannot use double buffering.
+ * @note To check the number of bytes really read use @ref app_usbd_cdc_acm_rx_size
+ * function.
+ *
+ * @sa app_usbd_cdc_acm_read
+ * @sa app_usbd_cdc_acm_rx_size
+ *
+ * @param p_cdc_acm CDC ACM class instance (defined by @ref APP_USBD_CDC_ACM_GLOBAL_DEF).
+ * @param[out] p_buf     Output buffer.
+ * @param[in]  length    Maximum number of bytes to read.
+ *
+ * @retval NRF_SUCCESS          Data is stored into user buffer.
+ * @retval NRF_ERROR_IO_PENDING Awaiting transmission, when data is stored into user buffer,
+ *                              @ref APP_USBD_CDC_ACM_USER_EVT_RX_DONE event will be raised.
+ * @retval NRF_ERROR_BUSY       There is already buffer set for a transfer.
+ * @retval other                Standard error code.
+ */
+ret_code_t app_usbd_cdc_acm_read_any(app_usbd_cdc_acm_t const * p_cdc_acm,
+                                     void *                     p_buf,
+                                     size_t                     length);
+
+/**
+ * @brief Serial state notifications.
+ * */
+typedef enum {
+    APP_USBD_CDC_ACM_SERIAL_STATE_DCD     = (1u << 0), /**< Notification bit DCD.    */
+    APP_USBD_CDC_ACM_SERIAL_STATE_DSR     = (1u << 1), /**< Notification bit DSR.    */
+    APP_USBD_CDC_ACM_SERIAL_STATE_BREAK   = (1u << 2), /**< Notification bit BREAK.  */
+    APP_USBD_CDC_ACM_SERIAL_STATE_RING    = (1u << 3), /**< Notification bit RING.   */
+    APP_USBD_CDC_ACM_SERIAL_STATE_FRAMING = (1u << 4), /**< Notification bit FRAMING.*/
+    APP_USBD_CDC_ACM_SERIAL_STATE_PARITY  = (1u << 5), /**< Notification bit PARITY. */
+    APP_USBD_CDC_ACM_SERIAL_STATE_OVERRUN = (1u << 6), /**< Notification bit OVERRUN.*/
+} app_usbd_cdc_acm_serial_state_t;
+
+/**
+ * @brief Serial line state.
+ */
+typedef enum {
+    APP_USBD_CDC_ACM_LINE_STATE_DTR = (1u << 0),  /**< Line state bit DTR.*/
+    APP_USBD_CDC_ACM_LINE_STATE_RTS = (1u << 1),  /**< Line state bit RTS.*/
+} app_usbd_cdc_acm_line_state_t;
+
+/**
+ * @brief Serial state notification via IN interrupt endpoint.
+ *
+ * @param[in] p_cdc_acm     CDC ACM class instance (defined by @ref APP_USBD_CDC_ACM_GLOBAL_DEF).
+ * @param[in] serial_state  Serial state notification type.
+ * @param[in] value         Serial state value.
+ *
+ * @return Standard error code.
+ */
+ret_code_t app_usbd_cdc_acm_serial_state_notify(app_usbd_cdc_acm_t const *      p_cdc_acm,
+                                                app_usbd_cdc_acm_serial_state_t serial_state,
+                                                bool                            value);
+
+/**
+ * @brief Control line value get.
+ *
+ * @param[in]  p_cdc_acm   CDC ACM class instance (defined by @ref APP_USBD_CDC_ACM_GLOBAL_DEF).
+ * @param[in]  line_state  Line control value type.
+ * @param[out] value       Line control value.
+ *
+ * @return Standard error code.
+ */
+ret_code_t app_usbd_cdc_acm_line_state_get(app_usbd_cdc_acm_t const *    p_cdc_acm,
+                                           app_usbd_cdc_acm_line_state_t line_state,
+                                           uint32_t *                    value);
+
+/** @} */
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* APP_USBD_CDC_ACM_H__ */

components/libraries/usbd/class/cdc/acm/app_usbd_cdc_acm_internal.h

@@ -0,0 +1,287 @@
+/**
+ * Copyright (c) 2016 - 2020, 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.
+ *
+ */
+#ifndef APP_USBD_CDC_ACM_INTERNAL_H__
+#define APP_USBD_CDC_ACM_INTERNAL_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+#include "app_util.h"
+
+/**
+ * @defgroup app_usbd_cdc_acm_internal USB CDC ACM internals
+ * @ingroup app_usbd_cdc_acm
+ * @brief @tagAPI52840 Internals of the USB ACM class implementation.
+ * @{
+ */
+
+/**
+ * @brief Forward declaration of type defined by @ref APP_USBD_CLASS_TYPEDEF in cdc_acm class.
+ *
+ */
+APP_USBD_CLASS_FORWARD(app_usbd_cdc_acm);
+
+/*lint -save -e165*/
+/**
+ * @brief Forward declaration of @ref app_usbd_cdc_acm_user_event_e.
+ *
+ */
+enum app_usbd_cdc_acm_user_event_e;
+
+/*lint -restore*/
+
+/**
+ * @brief User event handler.
+ *
+ * @param[in] p_inst    Class instance.
+ * @param[in] event     User event.
+ *
+ */
+typedef void (*app_usbd_cdc_acm_user_ev_handler_t)(app_usbd_class_inst_t const *    p_inst,
+                                                 enum app_usbd_cdc_acm_user_event_e event);
+
+/**
+ * @brief CDC ACM class part of class instance data.
+ */
+typedef struct {
+    uint8_t comm_interface;     //!< Interface number of cdc_acm control.
+    uint8_t comm_epin;          //!< COMM subclass IN endpoint.
+    uint8_t data_interface;     //!< Interface number of cdc_acm DATA.
+    uint8_t data_epout;         //!< DATA subclass OUT endpoint.
+    uint8_t data_epin;          //!< DATA subclass IN endpoint.
+
+    app_usbd_cdc_comm_protocol_t protocol; //!< User specified CDC protocol.
+
+    app_usbd_cdc_acm_user_ev_handler_t user_ev_handler; //!< User event handler.
+
+    uint8_t * p_ep_interval; //!< Endpoint intervals.
+} app_usbd_cdc_acm_inst_t;
+
+
+/**
+ * @brief CDC ACM serial state class notify.
+ */
+typedef struct {
+    app_usbd_cdc_notify_t cdc_notify;       //!< CDC notify.
+    uint16_t              serial_state;     //!< Serial port state.
+} app_usbd_cdc_acm_notify_t;
+
+/**
+ * @brief CDC ACM class specific request handled via control endpoint.
+ */
+typedef struct {
+    uint8_t type;    //!< Request type.
+    uint8_t len;     //!< Request length.
+
+    union {
+        app_usbd_cdc_line_coding_t line_coding;  //!< CDC ACM current line coding.
+        app_usbd_cdc_acm_notify_t  notify;       //!< CDC ACM class notify.
+    } payload;
+} app_usbd_cdc_acm_req_t;
+
+/**
+ * @brief CDC ACM rx transfer buffer.
+ */
+typedef struct {
+    uint8_t * p_buf;        //!< User buffer pointer.
+    size_t    read_left;    //!< Bytes left to read into buffer.
+} cdc_rx_buffer_t;
+
+/**
+ * @brief CDC ACM class context.
+ */
+typedef struct {
+    app_usbd_cdc_acm_req_t     request;             //!< CDC ACM class request.
+    app_usbd_cdc_line_coding_t line_coding;         //!< CDC ACM current line coding.
+
+    uint16_t line_state;                            //!< CDC ACM line state bitmap, DTE side.
+    uint16_t serial_state;                          //!< CDC ACM serial state bitmap, DCE side.
+
+    cdc_rx_buffer_t rx_transfer[2];                 //!< User receive transfers.
+
+    uint8_t   internal_rx_buf[NRF_DRV_USBD_EPSIZE]; //!< Internal receive buffer.
+    uint8_t * p_copy_pos;                           //!< Current copy position from internal buffer.
+
+    size_t  bytes_left;                             //!< Bytes left in internal buffer to copy.
+    size_t  bytes_read;                             //!< Bytes currently written to user buffer.
+    size_t  last_read;                              //!< Bytes read in last transfer.
+    size_t  cur_read;                               //!< Bytes currently read to internal buffer.
+} app_usbd_cdc_acm_ctx_t;
+
+/**
+ * @brief Default interval value for comm endpoint IN
+ *
+ */
+#define APP_USBD_CDC_ACM_DEFAULT_INTERVAL   0x10
+
+/**
+ * @brief CDC ACM class configuration macro.
+ *
+ * Used by @ref APP_USBD_CDC_ACM_GLOBAL_DEF
+ *
+ * @param iface_comm  Interface number of cdc_acm control.
+ * @param epin_comm   COMM subclass IN endpoint.
+ * @param iface_data  Interface number of cdc_acm DATA.
+ * @param epin_data   DATA subclass IN endpoint.
+ * @param epout_data  DATA subclass OUT endpoint.
+ *
+ */
+#define APP_USBD_CDC_ACM_CONFIG(iface_comm, epin_comm, iface_data, epin_data, epout_data)   \
+        ((iface_comm, epin_comm),                                                           \
+         (iface_data, epin_data, epout_data))
+
+
+/**
+ * @brief Specific class constant data for cdc_acm class.
+ *
+ * @ref app_usbd_cdc_acm_inst_t
+ */
+#define APP_USBD_CDC_ACM_INSTANCE_SPECIFIC_DEC app_usbd_cdc_acm_inst_t inst;
+
+
+/**
+ * @brief Configures cdc_acm class instance.
+ *
+ * @param user_event_handler    User event handler.
+ * @param comm_ifc              Interface number of cdc_acm control.
+ * @param comm_ein              COMM subclass IN endpoint.
+ * @param data_ifc              Interface number of cdc_acm DATA.
+ * @param data_ein              DATA subclass IN endpoint.
+ * @param data_eout             DATA subclass OUT endpoint.
+ * @param cdc_protocol          CDC protocol.
+ * @param ep_list               List of endpoints and intervals
+ */
+#define APP_USBD_CDC_ACM_INST_CONFIG(user_event_handler,                                         \
+                                     comm_ifc,                                                   \
+                                     comm_ein,                                                   \
+                                     data_ifc,                                                   \
+                                     data_ein,                                                   \
+                                     data_eout,                                                  \
+                                     cdc_protocol,                                               \
+                                     ep_list)                                                    \
+        .inst = {                                                                                \
+                .user_ev_handler = user_event_handler,                                           \
+                .comm_interface  = comm_ifc,                                                     \
+                .comm_epin       = comm_ifc,                                                     \
+                .data_interface  = data_ifc,                                                     \
+                .data_epin       = data_ein,                                                     \
+                .data_epout      = data_eout,                                                    \
+                .protocol        = cdc_protocol,                                                 \
+                .p_ep_interval   = ep_list                                                       \
+        }
+
+/**
+ * @brief Specific class data for cdc_acm class.
+ *
+ * @ref app_usbd_cdc_acm_ctx_t
+ */
+#define APP_USBD_CDC_ACM_DATA_SPECIFIC_DEC app_usbd_cdc_acm_ctx_t ctx;
+
+
+/**
+ * @brief CDC ACM class descriptors config macro.
+ *
+ * @param interface_number Interface number.
+ * @param ...              Extracted endpoint list.
+ */
+#define APP_USBD_CDC_ACM_DSC_CONFIG(interface_number, ...) {                             \
+                APP_USBD_CDC_ACM_INTERFACE_DSC(interface_number,                         \
+                                               0,                                        \
+                                               0,                                        \
+                                               APP_USBD_CDC_ACM_SUBCLASS_CDC_ACMCONTROL) \
+}
+
+/**
+ * @brief Public cdc_acm class interface.
+ *
+ */
+extern const app_usbd_class_methods_t app_usbd_cdc_acm_class_methods;
+
+/**
+ * @brief Global definition of @ref app_usbd_cdc_acm_t class.
+ *
+ * @param instance_name         Name of global instance.
+ * @param user_ev_handler       User event handler.
+ * @param comm_ifc              Interface number of cdc_acm control.
+ * @param data_ifc              Interface number of cdc_acm DATA.
+ * @param comm_ein              COMM subclass IN endpoint.
+ * @param data_ein              DATA subclass IN endpoint.
+ * @param data_eout             DATA subclass OUT endpoint.
+ * @param cdc_protocol          CDC protocol @ref app_usbd_cdc_comm_protocol_t
+ */
+/*lint -save -emacro(26 64 123 505 572 651, APP_USBD_CDC_ACM_GLOBAL_DEF_INTERNAL)*/
+#define APP_USBD_CDC_ACM_GLOBAL_DEF_INTERNAL(instance_name,                                       \
+                                             user_ev_handler,                                     \
+                                             comm_ifc,                                            \
+                                             data_ifc,                                            \
+                                             comm_ein,                                            \
+                                             data_ein,                                            \
+                                             data_eout,                                           \
+                                             cdc_protocol)                                        \
+        static uint8_t CONCAT_2(instance_name, _ep) = {                                           \
+            (APP_USBD_EXTRACT_INTERVAL_FLAG(comm_ein) ? APP_USBD_EXTRACT_INTERVAL_VALUE(comm_ein) \
+             : APP_USBD_CDC_ACM_DEFAULT_INTERVAL)};                                               \
+        APP_USBD_CLASS_INST_GLOBAL_DEF(                                                           \
+                instance_name,                                                                    \
+                app_usbd_cdc_acm,                                                                 \
+                &app_usbd_cdc_acm_class_methods,                                                  \
+                APP_USBD_CDC_ACM_CONFIG(comm_ifc, comm_ein, data_ifc, data_ein, data_eout),       \
+                (APP_USBD_CDC_ACM_INST_CONFIG(user_ev_handler,                                    \
+                                              comm_ifc,                                           \
+                                              comm_ein,                                           \
+                                              data_ifc,                                           \
+                                              data_ein,                                           \
+                                              data_eout,                                          \
+                                              cdc_protocol,                                       \
+                                              &CONCAT_2(instance_name, _ep)))                     \
+                )
+/*lint -restore*/
+
+/** @} */
+
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* APP_USBD_CDC_ACM_INTERNAL_H__ */

components/libraries/usbd/class/cdc/app_usbd_cdc_desc.h

@@ -0,0 +1,208 @@
+/**
+ * Copyright (c) 2016 - 2020, 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.
+ *
+ */
+#ifndef APP_USBD_CDC_DESC_H__
+#define APP_USBD_CDC_DESC_H__
+
+#include <stdint.h>
+#include <stdbool.h>
+
+#include "app_usbd_descriptor.h"
+#include "app_usbd_cdc_types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @defgroup app_usbd_cdc_desc CDC class descriptors
+ * @brief @tagAPI52840 Descriptors used in the USB CDC class implementation.
+ * @ingroup app_usbd_cdc_acm
+ *
+ * A group of macros used to initialize CDC descriptors
+ * @{
+ */
+
+/**
+ * @brief Initializer of IAD descriptor for CDC class.
+ *
+ * @param interface_number Interface number.
+ * @param subclass         Subclass, @ref app_usbd_cdc_subclass_t.
+ * @param protocol         Protocol, @ref app_usbd_cdc_comm_protocol_t.
+ */
+#define APP_USBD_CDC_IAD_DSC(interface_number, subclass, protocol)        \
+    /*.bLength =           */ sizeof(app_usbd_descriptor_iad_t),          \
+    /*.bDescriptorType =   */ APP_USBD_DESCRIPTOR_INTERFACE_ASSOCIATION,  \
+    /*.bFirstInterface =   */ interface_number,                           \
+    /*.bInterfaceCount =   */ 2,                                          \
+    /*.bFunctionClass =    */ APP_USBD_CDC_COMM_CLASS,                    \
+    /*.bFunctionSubClass = */ subclass,                                   \
+    /*.bFunctionProtocol = */ protocol,                                   \
+    /*.iFunction =         */ 0,                                          \
+
+/**
+ * @brief Initializer of interface descriptor for CDC COMM class.
+ *
+ * @param interface_number Interface number.
+ * @param subclass         Subclass, @ref app_usbd_cdc_subclass_t.
+ * @param protocol         Protocol, @ref app_usbd_cdc_comm_protocol_t.
+ */
+#define APP_USBD_CDC_COMM_INTERFACE_DSC(interface_number, subclass, protocol)  \
+    /*.bLength =            */ sizeof(app_usbd_descriptor_iface_t),            \
+    /*.bDescriptorType =    */ APP_USBD_DESCRIPTOR_INTERFACE,                  \
+    /*.bInterfaceNumber =   */ interface_number,                               \
+    /*.bAlternateSetting =  */ 0x00,                                           \
+    /*.bNumEndpoints =      */ 1,                                              \
+    /*.bInterfaceClass =    */ APP_USBD_CDC_COMM_CLASS,                        \
+    /*.bInterfaceSubClass = */ subclass,                                       \
+    /*.bInterfaceProtocol = */ protocol,                                       \
+    /*.iInterface = 0,      */ 0x00,                                           \
+
+
+/**
+ * @brief Initializer of interface descriptor for CDC DATA class.
+ *
+ * @param interface_number Interface number.
+ * @param subclass         Subclass, @ref app_usbd_cdc_subclass_t.
+ * @param protocol         Protocol, @ref app_usbd_cdc_data_protocol_t.
+ */
+#define APP_USBD_CDC_DATA_INTERFACE_DSC(interface_number, subclass, protocol) \
+    /*.bLength =            */ sizeof(app_usbd_descriptor_iface_t),           \
+    /*.bDescriptorType =    */ APP_USBD_DESCRIPTOR_INTERFACE,                 \
+    /*.bInterfaceNumber =   */ interface_number,                              \
+    /*.bAlternateSetting =  */ 0x00,                                          \
+    /*.bNumEndpoints =      */ 2,                                             \
+    /*.bInterfaceClass =    */ APP_USBD_CDC_DATA_CLASS,                       \
+    /*.bInterfaceSubClass = */ subclass,                                      \
+    /*.bInterfaceProtocol = */ protocol,                                      \
+    /*.iInterface = 0,      */ 0x00,                                          \
+
+
+
+/**
+ * @brief Initializer of endpoint descriptor for CDC COM class.
+ *
+ * @param endpoint_in   IN endpoint.
+ * @param ep_size       Endpoint size.
+ */
+#define APP_USBD_CDC_COM_EP_DSC(endpoint_in, ep_size)                     \
+    /*.bLength =          */ sizeof(app_usbd_descriptor_ep_t),            \
+    /*.bDescriptorType =  */ APP_USBD_DESCRIPTOR_ENDPOINT,                \
+    /*.bEndpointAddress = */ endpoint_in,                                 \
+    /*.bmAttributes =     */ APP_USBD_DESCRIPTOR_EP_ATTR_TYPE_INTERRUPT,  \
+    /*.wMaxPacketSize =   */ APP_USBD_U16_TO_RAW_DSC(ep_size),            \
+    /*.bInterval =        */ 16,                                          \
+
+/**
+ * @brief Initializer of endpoint descriptors for CDC DATA class.
+ *
+ * @param endpoint_in   IN endpoint.
+ * @param endpoint_out  OUT endpoint.
+ * @param ep_size       Endpoint size.
+ */
+#define APP_USBD_CDC_DATA_EP_DSC(endpoint_in, endpoint_out, ep_size) \
+    /*.bLength =          */ sizeof(app_usbd_descriptor_ep_t),       \
+    /*.bDescriptorType =  */ APP_USBD_DESCRIPTOR_ENDPOINT,           \
+    /*.bEndpointAddress = */ endpoint_in,                            \
+    /*.bmAttributes =     */ APP_USBD_DESCRIPTOR_EP_ATTR_TYPE_BULK,  \
+    /*.wMaxPacketSize =   */ APP_USBD_U16_TO_RAW_DSC(ep_size),       \
+    /*.bInterval =        */ 0,                                      \
+    /*.bLength =          */ sizeof(app_usbd_descriptor_ep_t),       \
+    /*.bDescriptorType =  */ APP_USBD_DESCRIPTOR_ENDPOINT,           \
+    /*.bEndpointAddress = */ endpoint_out,                           \
+    /*.bmAttributes =     */ APP_USBD_DESCRIPTOR_EP_ATTR_TYPE_BULK,  \
+    /*.wMaxPacketSize =   */ APP_USBD_U16_TO_RAW_DSC(ep_size),       \
+    /*.bInterval =        */ 0,                                      \
+
+/**
+ * @brief Initializer of endpoint descriptors for CDC header descriptor.
+ *
+ * @param bcd_cdc   BCD CDC version.
+ */
+#define APP_USBD_CDC_HEADER_DSC(bcd_cdc)                           \
+    /*.bLength =            */ sizeof(app_usbd_cdc_desc_header_t), \
+    /*.bDescriptorType =    */ APP_USBD_CDC_CS_INTERFACE,          \
+    /*.bDescriptorSubtype = */ APP_USBD_CDC_SCS_HEADER,            \
+    /*.bcdCDC =             */ APP_USBD_U16_TO_RAW_DSC(bcd_cdc),   \
+
+/**
+ * @brief Initializer of endpoint descriptors for CDC call management descriptor.
+ *
+ * @param capabilities   Capabilities.
+ * @param data_interface Data interface.
+ */
+#define APP_USBD_CDC_CALL_MGMT_DSC(capabilities, data_interface)      \
+    /*.bLength =            */ sizeof(app_usbd_cdc_desc_call_mgmt_t), \
+    /*.bDescriptorType =    */ APP_USBD_CDC_CS_INTERFACE,             \
+    /*.bDescriptorSubtype = */ APP_USBD_CDC_SCS_CALL_MGMT,            \
+    /*.bmCapabilities =     */ capabilities,                          \
+    /*.bDataInterface =     */ data_interface,                        \
+
+
+/**
+ * @brief Initializer of endpoint descriptors for CDC DATA class.
+ *
+ * @param capabilities   Capabilities.
+ */
+#define APP_USBD_CDC_ACM_DSC(capabilities)                      \
+    /*.bLength =            */ sizeof(app_usbd_cdc_desc_acm_t), \
+    /*.bDescriptorType =    */ APP_USBD_CDC_CS_INTERFACE,       \
+    /*.bDescriptorSubtype = */ APP_USBD_CDC_SCS_ACM,            \
+    /*.bmCapabilities =     */ capabilities,                    \
+
+/**
+ * @brief Initializer of endpoint descriptors for CDC DATA class.
+ *
+ * @param control_interface   Control interface.
+ * @param ...                 Subordinate interfaces list.
+ */
+#define APP_USBD_CDC_UNION_DSC(control_interface, ...)                                            \
+    /*.bLength =               */ sizeof(app_usbd_cdc_desc_union_t) + (NUM_VA_ARGS(__VA_ARGS__)), \
+    /*.bDescriptorType =       */ APP_USBD_CDC_CS_INTERFACE,                                      \
+    /*.bDescriptorSubtype =    */ APP_USBD_CDC_SCS_UNION,                                         \
+    /*.bControlInterface =     */ control_interface,                                              \
+    /*.bSubordinateInterface = */ __VA_ARGS__,                                                    \
+
+/** @} */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* APP_USBD_CDC_H__ */

components/libraries/usbd/class/cdc/app_usbd_cdc_types.h

@@ -0,0 +1,360 @@
+/**
+ * Copyright (c) 2016 - 2020, 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.
+ *
+ */
+#ifndef APP_USBD_CDC_TYPES_H__
+#define APP_USBD_CDC_TYPES_H__
+
+#include <stdint.h>
+#include <stdbool.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/**
+ * @defgroup app_usbd_cdc_types CDC class types
+ * @ingroup app_usbd_cdc_acm
+ *
+ * @brief @tagAPI52840 Variable types used by the CDC class implementation.
+ * @{
+ */
+
+/**
+ * @brief Communications Interface Class code.
+ *
+ * Used for control interface in communication class.
+ * @ref app_usbd_descriptor_iface_t::bInterfaceClass
+ */
+#define APP_USBD_CDC_COMM_CLASS 0x02
+
+/**
+ * @brief Data Class Interface code.
+ *
+ * Used for data interface in communication class.
+ * @ref app_usbd_descriptor_iface_t::bInterfaceClass
+ */
+#define APP_USBD_CDC_DATA_CLASS 0x0A
+
+/**
+ * @brief CDC subclass possible values.
+ *
+ * @ref app_usbd_descriptor_iface_t::bInterfaceSubClass
+ */
+typedef enum {
+    APP_USBD_CDC_SUBCLASS_RESERVED = 0x00, /**< Reserved in documentation.         */
+    APP_USBD_CDC_SUBCLASS_DLCM     = 0x01, /**< Direct Line Control Model.         */
+    APP_USBD_CDC_SUBCLASS_ACM      = 0x02, /**< Abstract Control Model.            */
+    APP_USBD_CDC_SUBCLASS_TCM      = 0x03, /**< Telephone Control Model.           */
+    APP_USBD_CDC_SUBCLASS_MCCM     = 0x04, /**< Multi-Channel Control Model.       */
+    APP_USBD_CDC_SUBCLASS_CAPI     = 0x05, /**< CAPI Control Model.                */
+    APP_USBD_CDC_SUBCLASS_ENCM     = 0x06, /**< Ethernet Networking Control Model. */
+    APP_USBD_CDC_SUBCLASS_ATM      = 0x07, /**< ATM Networking Control Model.      */
+    APP_USBD_CDC_SUBCLASS_WHCM     = 0x08, /**< Wireless Handset Control Model.    */
+    APP_USBD_CDC_SUBCLASS_DM       = 0x09, /**< Device Management.                 */
+    APP_USBD_CDC_SUBCLASS_MDLM     = 0x0A, /**< Mobile Direct Line Model.          */
+    APP_USBD_CDC_SUBCLASS_OBEX     = 0x0B, /**< OBEX.                              */
+    APP_USBD_CDC_SUBCLASS_EEM      = 0x0C, /**< Ethernet Emulation Model.          */
+    APP_USBD_CDC_SUBCLASS_NCM      = 0x0D  /**< Network Control Model.             */
+} app_usbd_cdc_subclass_t;
+
+/**
+ * @brief CDC protocol possible values.
+ *
+ * @ref app_usbd_descriptor_iface_t::bInterfaceProtocol
+ */
+typedef enum {
+    APP_USBD_CDC_COMM_PROTOCOL_NONE              = 0x00, /**< No class specific protocol required.                                      */
+    APP_USBD_CDC_COMM_PROTOCOL_AT_V250           = 0x01, /**< AT Commands: V.250 etc.                                                   */
+    APP_USBD_CDC_COMM_PROTOCOL_AT_PCCA101        = 0x02, /**< AT Commands defined by PCCA-101.                                          */
+    APP_USBD_CDC_COMM_PROTOCOL_AT_PCCA101_ANNEXO = 0x03, /**< AT Commands defined by PCCA-101 & Annex O.                                */
+    APP_USBD_CDC_COMM_PROTOCOL_AT_GSM707         = 0x04, /**< AT Commands defined by GSM 07.07.                                         */
+    APP_USBD_CDC_COMM_PROTOCOL_AT_3GPP_27007     = 0x05, /**< AT Commands defined by 3GPP 27.007.                                       */
+    APP_USBD_CDC_COMM_PROTOCOL_AT_CDMA           = 0x06, /**< AT Commands defined by TIA for CDMA.                                      */
+    APP_USBD_CDC_COMM_PROTOCOL_EEM               = 0x07, /**< Ethernet Emulation Model.                                                 */
+    APP_USBD_CDC_COMM_PROTOCOL_EXTERNAL          = 0xFE, /**< External Protocol: Commands defined by Command Set Functional Descriptor. */
+    APP_USBD_CDC_COMM_PROTOCOL_VENDOR            = 0xFF  /**< Vendor-specific.                                                          */
+} app_usbd_cdc_comm_protocol_t;
+
+/**
+ * @brief CDC data interface protocols possible values.
+ */
+typedef enum {
+    APP_USBD_CDC_DATA_PROTOCOL_NONE        = 0x00, /**< No class specific protocol required.                   */
+    APP_USBD_CDC_DATA_PROTOCOL_NTB         = 0x01, /**< Network Transfer Block.                                */
+    APP_USBD_CDC_DATA_PROTOCOL_ISDN_BRI    = 0x30, /**< Physical interface protocol for ISDN BRI.              */
+    APP_USBD_CDC_DATA_PROTOCOL_HDLC        = 0x31, /**< HDLC.                                                  */
+    APP_USBD_CDC_DATA_PROTOCOL_TRANSPARENT = 0x32, /**< Transparent.                                           */
+    APP_USBD_CDC_DATA_PROTOCOL_Q921M       = 0x50, /**< Management protocol for Q.921 data link protocol.      */
+    APP_USBD_CDC_DATA_PROTOCOL_Q921        = 0x51, /**< Data link protocol for Q.921.                          */
+    APP_USBD_CDC_DATA_PROTOCOL_Q921TM      = 0x52, /**< TEI-multiplexor for Q.921 data link protocol.          */
+    APP_USBD_CDC_DATA_PROTOCOL_V42BIS      = 0x90, /**< Data compression procedures.                           */
+    APP_USBD_CDC_DATA_PROTOCOL_Q931        = 0x91, /**< Euro-ISDN protocol control.                            */
+    APP_USBD_CDC_DATA_PROTOCOL_V120        = 0x92, /**< V.24 rate adaptation to ISDN.                          */
+    APP_USBD_CDC_DATA_PROTOCOL_CAPI20      = 0x93, /**< CAPI Commands.                                         */
+    APP_USBD_CDC_DATA_PROTOCOL_HOST        = 0xFD, /**< Host based driver.
+                                                     *   @note This protocol code should only be used in messages
+                                                     *   between host and device to identify the host driver portion
+                                                     *   of a protocol stack.
+                                                     */
+    APP_USBD_CDC_DATA_PROTOCOL_EXTERNAL    = 0xFE, /**< The protocol(s) are described using a Protocol Unit Functional
+                                                     * Descriptors on Communications Class Interface.
+                                                     */
+    APP_USBD_CDC_DATA_PROTOCOL_VENDOR      = 0xFF  /**< Vendor-specific. */
+} app_usbd_cdc_data_protocol_t;
+
+/**
+ * @brief CDC Functional Descriptor types.
+ */
+typedef enum {
+    APP_USBD_CDC_CS_INTERFACE = 0x24, /**< Class specific interface descriptor type.*/
+    APP_USBD_CDC_CS_ENDPOINT  = 0x25  /**< Class specific endpoint descriptor type.*/
+} app_usbd_cdc_func_type_t;
+
+/**
+ * @brief CDC Functional Descriptor subtypes.
+ */
+typedef enum {
+    APP_USBD_CDC_SCS_HEADER      = 0x00, /**< Header Functional Descriptor, which marks the beginning of the concatenated set of functional descriptors for the interface. */
+    APP_USBD_CDC_SCS_CALL_MGMT   = 0x01, /**< Call Management Functional Descriptor.                                                                                       */
+    APP_USBD_CDC_SCS_ACM         = 0x02, /**< Abstract Control Management Functional Descriptor.                                                                           */
+    APP_USBD_CDC_SCS_DLM         = 0x03, /**< Direct Line Management Functional Descriptor.                                                                                */
+    APP_USBD_CDC_SCS_TEL_R       = 0x04, /**< Telephone Ringer Functional Descriptor.                                                                                      */
+    APP_USBD_CDC_SCS_TEL_CAP     = 0x05, /**< Telephone Call and Line State Reporting Capabilities Functional Descriptor.                                                  */
+    APP_USBD_CDC_SCS_UNION       = 0x06, /**< Union Functional Descriptor.                                                                                                 */
+    APP_USBD_CDC_SCS_COUNTRY_SEL = 0x07, /**< Country Selection Functional Descriptor.                                                                                     */
+    APP_USBD_CDC_SCS_TEL_OM      = 0x08, /**< Telephone Operational Modes Functional Descriptor.                                                                           */
+    APP_USBD_CDC_SCS_USB_TERM    = 0x09, /**< USB Terminal Functional Descriptor.                                                                                          */
+    APP_USBD_CDC_SCS_NCT         = 0x0A, /**< Network Channel Terminal Descriptor.                                                                                         */
+    APP_USBD_CDC_SCS_PU          = 0x0B, /**< Protocol Unit Functional Descriptor.                                                                                         */
+    APP_USBD_CDC_SCS_EU          = 0x0C, /**< Extension Unit Functional Descriptor.                                                                                        */
+    APP_USBD_CDC_SCS_MCM         = 0x0D, /**< Multi-Channel Management Functional Descriptor.                                                                              */
+    APP_USBD_CDC_SCS_CAPI        = 0x0E, /**< CAPI Control Management Functional Descriptor.                                                                               */
+    APP_USBD_CDC_SCS_ETH         = 0x0F, /**< Ethernet Networking Functional Descriptor.                                                                                   */
+    APP_USBD_CDC_SCS_ATM         = 0x10, /**< ATM Networking Functional Descriptor.                                                                                        */
+    APP_USBD_CDC_SCS_WHCM        = 0x11, /**< Wireless Handset Control Model Functional Descriptor.                                                                        */
+    APP_USBD_CDC_SCS_MDLM        = 0x12, /**< Mobile Direct Line Model Functional Descriptor.                                                                              */
+    APP_USBD_CDC_SCS_MDLM_DET    = 0x13, /**< MDLM Detail Functional Descriptor.                                                                                           */
+    APP_USBD_CDC_SCS_DMM         = 0x14, /**< Device Management Model Functional Descriptor.                                                                               */
+    APP_USBD_CDC_SCS_OBEX        = 0x15, /**< OBEX Functional Descriptor.                                                                                                  */
+    APP_USBD_CDC_SCS_CS          = 0x16, /**< Command Set Functional Descriptor.                                                                                           */
+    APP_USBD_CDC_SCS_CS_DET      = 0x17, /**< Command Set Detail Functional Descriptor.                                                                                    */
+    APP_USBD_CDC_SCS_TEL_CM      = 0x18, /**< Telephone Control Model Functional Descriptor.                                                                               */
+    APP_USBD_CDC_SCS_OBEX_SI     = 0x19, /**< OBEX Service Identifier Functional Descriptor.                                                                               */
+    APP_USBD_CDC_SCS_NCM         = 0x1A  /**< NCM Functional Descriptor.                                                                                                   */
+} app_usbd_cdc_func_subtype_t;
+
+/* Make all descriptors packed */
+#pragma pack(push, 1)
+
+/**
+ * @brief Header Functional Descriptor.
+ */
+typedef struct {
+    uint8_t bFunctionLength;    //!< Size of this descriptor in bytes.
+    uint8_t bDescriptorType;    //!< @ref APP_USBD_CDC_CS_INTERFACE descriptor type.
+    uint8_t bDescriptorSubtype; //!< Descriptor subtype @ref APP_USBD_CDC_SCS_HEADER.
+    uint8_t bcdCDC[2];          //!< USB Class Definitions for Communications Devices Specification release number in binary-coded decimal.
+} app_usbd_cdc_desc_header_t;
+
+/**
+ * @brief Call management capabilities.
+ *
+ * @ref app_usbd_cdc_desc_call_mgmt_t::bmCapabilities bit.
+ * */
+typedef enum {
+    APP_USBD_CDC_CALL_MGMT_SUPPORTED = (1 << 0),  /**< Call management capability bit 0.*/
+    APP_USBD_CDC_CALL_MGMT_OVER_DCI  = (1 << 1),  /**< Call management capability bit 1.*/
+} app_subd_cdc_call_mgmt_cap_t;
+
+/**
+ * @brief CDC Call Management Functional Descriptor.
+ */
+typedef struct {
+    uint8_t bFunctionLength;    //!< Size of this functional descriptor, in bytes.
+    uint8_t bDescriptorType;    //!< Descriptor type @ref APP_USBD_CDC_CS_INTERFACE.
+    uint8_t bDescriptorSubtype; //!< Descriptor subtype @ref APP_USBD_CDC_SCS_CALL_MGMT.
+    uint8_t bmCapabilities;     //!< Capabilities @ref app_subd_cdc_call_mgmt_cap_t.
+    uint8_t bDataInterface;     //!< Data interface number.
+} app_usbd_cdc_desc_call_mgmt_t;
+
+/**
+ * @brief ACM capabilities.
+ *
+ * @ref app_usbd_cdc_desc_acm_t::bmCapabilities bit.
+ * */
+typedef enum {
+    APP_USBD_CDC_ACM_FEATURE_REQUESTS   = (1 << 0),  /**< ACM capability bit FEATURE_REQUESTS.  */
+    APP_USBD_CDC_ACM_LINE_REQUESTS      = (1 << 1),  /**< ACM capability bit LINE_REQUESTS.     */
+    APP_USBD_CDC_ACM_SENDBREAK_REQUESTS = (1 << 2),  /**< ACM capability bit SENDBREAK_REQUESTS.*/
+    APP_USBD_CDC_ACM_NOTIFY_REQUESTS    = (1 << 3),  /**< ACM capability bit NOTIFY_REQUESTS.   */
+} app_subd_cdc_acm_cap_t;
+
+/**
+ * @brief CDC ACM Functional Descriptor.
+ */
+typedef struct {
+    uint8_t bFunctionLength;      //!< Size of this functional descriptor, in bytes.
+    uint8_t bDescriptorType;      //!< Descriptor type @ref APP_USBD_CDC_CS_INTERFACE.
+    uint8_t bDescriptorSubtype;   //!< Descriptor subtype @ref APP_USBD_CDC_SCS_ACM.
+    uint8_t bmCapabilities;       //!< Capabilities @ref app_subd_cdc_acm_cap_t.
+} app_usbd_cdc_desc_acm_t;
+
+/**
+ * @brief Union Functional Descriptor.
+ */
+typedef struct {
+    uint8_t bFunctionLength;         //!< Size of this functional descriptor, in bytes.
+    uint8_t bDescriptorType;         //!< Descriptor type @ref APP_USBD_CDC_CS_INTERFACE.
+    uint8_t bDescriptorSubtype;      //!< Descriptor subtype @ref APP_USBD_CDC_SCS_UNION.
+    uint8_t bControlInterface;       //!< The interface number of the Communications or Data Class interface, designated as the controlling interface for the union.
+    uint8_t bSubordinateInterface[]; //!< Interface number of subordinate interfaces in the union. Number of interfaced depends on descriptor size.
+} app_usbd_cdc_desc_union_t;
+
+/**
+ * @brief Country Selection Functional Descriptor.
+ */
+typedef struct {
+    uint8_t bFunctionLength;        //!< Size of this functional descriptor, in bytes.
+    uint8_t bDescriptorType;        //!< Descriptor type @ref APP_USBD_CDC_CS_INTERFACE.
+    uint8_t bDescriptorSubtype;     //!< Descriptor subtype @ref APP_USBD_CDC_SCS_COUNTRY_SEL.
+    uint8_t iCountryCodeRelDate;    //!< Index of a string giving the release date for the implemented ISO 3166 Country Codes.
+} app_usbd_cdc_desc_country_sel_t;
+
+/**
+ * @brief CDC Requests
+ *
+ */
+typedef enum {
+    /* CDC General */
+    APP_USBD_CDC_REQ_SEND_ENCAPSULATED_COMMAND = 0x00, /**< This request is used to issue a command in the format of the supported control protocol of the Communications Class interface.    */
+    APP_USBD_CDC_REQ_GET_ENCAPSULATED_RESPONSE = 0x01, /**< This request is used to request a response in the format of the supported control protocol of the Communications Class interface. */
+    /* CDC PSTN */
+    APP_USBD_CDC_REQ_SET_COMM_FEATURE          = 0x02, /**< This request controls the settings for a particular communications feature of a particular target. */
+    APP_USBD_CDC_REQ_GET_COMM_FEATURE          = 0x03, /**< This request returns the current settings for the communications feature as selected. */
+    APP_USBD_CDC_REQ_CLEAR_COMM_FEATURE        = 0x04, /**< This request controls the settings for a particular communications feature of a particular target, setting the selected feature to its default state. */
+    APP_USBD_CDC_REQ_SET_AUX_LINE_STATE        = 0x10, /**< This request is used to connect or disconnect a secondary jack to POTS circuit or CODEC, depending on hook state. */
+    APP_USBD_CDC_REQ_SET_HOOK_STATE            = 0x11, /**< This request is used to set the necessary PSTN line relay code for on-hook, off-hook, and caller ID states. */
+    APP_USBD_CDC_REQ_PULSE_SETUP               = 0x12, /**< This request is used to prepare for a pulse-dialing cycle. */
+    APP_USBD_CDC_REQ_SEND_PULSE                = 0x13, /**< This request is used to generate a specified number of make/break pulse cycles. */
+    APP_USBD_CDC_REQ_SET_PULSE_TIME            = 0x14, /**< This request sets the timing of the make and break periods for pulse dialing. */
+    APP_USBD_CDC_REQ_RING_AUX_JACK             = 0x15, /**< This request is used to generate a ring signal on a secondary phone jack. */
+    APP_USBD_CDC_REQ_SET_LINE_CODING           = 0x20, /**< This request allows the host to specify typical asynchronous line-character formatting properties. */
+    APP_USBD_CDC_REQ_GET_LINE_CODING           = 0x21, /**< This request allows the host to find out the currently configured line coding. */
+    APP_USBD_CDC_REQ_SET_CONTROL_LINE_STATE    = 0x22, /**< This request generates RS-232/V.24 style control signals. */
+    APP_USBD_CDC_REQ_SEND_BREAK                = 0x23, /**< This request sends special carrier modulation that generates an RS-232 style break. */
+    APP_USBD_CDC_REQ_SET_RINGER_PARMS          = 0x30, /**< This request configures the ringer for the communications device. */
+    APP_USBD_CDC_REQ_GET_RINGER_PARMS          = 0x31, /**< This request returns the ringer capabilities of the device and the current status of the device’s ringer. */
+    APP_USBD_CDC_REQ_SET_OPERATION_PARMS       = 0x32, /**< Sets the operational mode for the device, between a simple mode, standalone mode and a host centric mode. */
+    APP_USBD_CDC_REQ_GET_OPERATION_PARMS       = 0x33, /**< This request gets the current operational mode for the device. */
+    APP_USBD_CDC_REQ_SET_LINE_PARMS            = 0x34, /**< This request is used to change the state of the line, corresponding to the interface or master interface of a union to which the command was sent. */
+    APP_USBD_CDC_REQ_GET_LINE_PARMS            = 0x35, /**< This request is used to report the state of the line that corresponds to the interface or master interface of a union to which the command was sent. */
+    APP_USBD_CDC_REQ_DIAL_DIGITS               = 0x36, /**< This request dials the DTMF digits over the specified line. */
+} app_usbd_cdc_req_id_t;
+
+/**
+ * @brief CDC Notifications.
+ */
+typedef enum {
+    /* CDC General */
+    APP_USBD_CDC_NOTIF_NETWORK_CONNECTION      = 0x00, /**< This notification allows the device to notify the host about network connection status. */
+    APP_USBD_CDC_NOTIF_RESPONSE_AVAILABLE      = 0x01, /**< This notification allows the device to notify the host that a response is available.
+                                                        *   This response can be retrieved with a subsequent GetEncapsulatedResponse request.
+                      _                                 */
+    APP_USBD_CDC_NOTIF_CONNECTION_SPEED_CHANGE = 0x2A, /**< This notification allows the device to inform the host-networking driver
+                                                        *   that a change in either the up-link or the down-link bit rate of the connection has occurred.
+                                                        */
+    /* CDC PSTN */
+    APP_USBD_CDC_NOTIF_AUX_JACK_HOOK_STATE     = 0x08, /**< (DLM) This notification indicates the loop has changed on the auxiliary phone interface of the USB device. */
+    APP_USBD_CDC_NOTIF_RING_DETECT             = 0x09, /**< (DLM) This notification indicates ring voltage on the POTS line interface of the USB device. */
+    APP_USBD_CDC_NOTIF_SERIAL_STATE            = 0x20, /**< (ACM) This notification sends asynchronous notification of UART status. */
+    APP_USBD_CDC_NOTIF_CALL_STATE_CHANGE       = 0x28, /**< (TCM) This notification identifies that a change has occurred to the state of a call on the line corresponding to the interface or union for the line. */
+    APP_USBD_CDC_NOTIF_LINE_STATE_CHANGE       = 0x29  /**< (TCM) This notification identifies that a change has occurred to the state of the line corresponding to the interface or master interface of a union sending the notification message. */
+} app_usbd_cdc_notify_id_t;
+
+/**
+ * @brief Notification sent via CDC COMM endpoint.
+ * */
+typedef struct {
+    uint8_t  bmRequestType; //!< Request type.
+    uint8_t  bRequest;      //!< Request ID @ref app_usbd_cdc_req_id_t.
+    uint16_t wValue;        //!< Value field.
+    uint16_t wIndex;        //!< Index field.
+    uint16_t wLength;       //!< Length of payload following.
+} app_usbd_cdc_notify_t;
+
+/**
+ * @brief CDC line coding structure.
+ */
+typedef struct {
+    uint8_t dwDTERate[4];   //!< Line baudrate.
+    uint8_t bCharFormat;    //!< Character format @ref app_usbd_cdc_line_stopbit_t.
+    uint8_t bParityType;    //!< Parity bits @ref app_usbd_cdc_line_parity_t.
+    uint8_t bDataBits;      //!< Number of data bits.
+} app_usbd_cdc_line_coding_t;
+
+/**
+ * @brief Possible values of @ref app_usbd_cdc_line_coding_t::bCharFormat.
+ */
+typedef enum {
+    APP_USBD_CDC_LINE_STOPBIT_1   = 0, /**< 1 stop bit.       */
+    APP_USBD_CDC_LINE_STOPBIT_1_5 = 1, /**< 1.5 stop bits.    */
+    APP_USBD_CDC_LINE_STOPBIT_2   = 2, /**< 2 stop bits.      */
+} app_usbd_cdc_line_stopbit_t;
+
+/**
+ * @brief Possible values of @ref app_usbd_cdc_line_coding_t::bParityType.
+ */
+typedef enum {
+    APP_USBD_CDC_LINE_PARITY_NONE  = 0,  /**< No parity.                  */
+    APP_USBD_CDC_LINE_PARITY_ODD   = 1,  /**< Odd parity.                 */
+    APP_USBD_CDC_LINE_PARITY_EVEN  = 2,  /**< Even parity.                */
+    APP_USBD_CDC_LINE_PARITY_MARK  = 3,  /**< Parity forced to 0 (mark).  */
+    APP_USBD_CDC_LINE_PARITY_SPACE = 4,  /**< Parity forced to 1 (space). */
+} app_usbd_cdc_line_parity_t;
+
+
+#pragma pack(pop)
+
+/** @} */
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* APP_USBD_TYPES_H__ */

components/libraries/usbd/class/dummy/app_usbd_dummy.c

@@ -0,0 +1,115 @@
+/**
+ * Copyright (c) 2017 - 2020, 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 "sdk_common.h"
+#if NRF_MODULE_ENABLED(APP_USBD_DUMMY)
+
+#include <string.h>
+#include <ctype.h>
+#include "app_usbd.h"
+#include "app_usbd_dummy.h"
+#include "app_usbd_string_desc.h"
+#include "nrf_gpio.h"
+
+/**
+ * @defgroup app_usbd_dummy_internal USBD Dummy internals
+ * @{
+ * @ingroup app_usbd_dummy
+ * @internal
+ */
+
+#define NRF_LOG_MODULE_NAME usbd_dummy
+
+#if APP_USBD_DUMMY_CONFIG_LOG_ENABLED
+#define NRF_LOG_LEVEL       APP_USBD_DUMMY_CONFIG_LOG_LEVEL
+#define NRF_LOG_INFO_COLOR  APP_USBD_DUMMY_CONFIG_INFO_COLOR
+#define NRF_LOG_DEBUG_COLOR APP_USBD_DUMMY_CONFIG_DEBUG_COLOR
+#else //APP_USBD_DUMMY_CONFIG_LOG_ENABLED
+#define NRF_LOG_LEVEL       0
+#endif //APP_USBD_DUMMY_CONFIG_LOG_ENABLED
+#include "nrf_log.h"
+NRF_LOG_MODULE_REGISTER();
+
+/** @brief @ref app_usbd_class_methods_t::event_handler */
+static ret_code_t dummy_class_event_handler(app_usbd_class_inst_t const *  p_inst,
+                                            app_usbd_complex_evt_t const * p_event)
+{
+    if((p_event->app_evt.type  == APP_USBD_EVT_INST_APPEND) || 
+       (p_event->app_evt.type  == APP_USBD_EVT_INST_REMOVE))
+    {
+        return NRF_SUCCESS;
+    }
+    else
+    {
+        return NRF_ERROR_NOT_SUPPORTED;
+    }
+}
+
+/** @brief @ref app_usbd_class_methods_t::feed_descriptors */
+static bool dummy_class_feed_descriptors(app_usbd_class_descriptor_ctx_t * p_ctx,
+                                         app_usbd_class_inst_t const     * p_inst,
+                                         uint8_t                         * p_buff,
+                                         size_t                            max_size)
+{
+    static app_usbd_class_iface_conf_t const * p_cur_iface = 0;
+    p_cur_iface = app_usbd_class_iface_get(p_inst, 0);
+
+    APP_USBD_CLASS_DESCRIPTOR_BEGIN(p_ctx, p_buff, max_size)
+
+    /* INTERFACE DESCRIPTOR */
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(sizeof(app_usbd_descriptor_iface_t)); // bLength
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(APP_USBD_DESCRIPTOR_INTERFACE); // bDescriptorType
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(app_usbd_class_iface_number_get(p_cur_iface)); // bInterfaceNumber
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(0x00); // bAlternateSetting
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(0); // bNumEndpoints
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(APP_USBD_DUMMY_CLASS); // bInterfaceClass
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(APP_USBD_DUMMY_SUBCLASS); // bInterfaceSubClass
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(APP_USBD_DUMMY_PROTOCOL); // bInterfaceProtocol
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(0x00); // iInterface
+
+    APP_USBD_CLASS_DESCRIPTOR_END();
+}
+
+const app_usbd_class_methods_t app_usbd_dummy_class_methods = {
+    .event_handler    = dummy_class_event_handler,
+    .feed_descriptors = dummy_class_feed_descriptors,
+};
+
+
+#endif //NRF_MODULE_ENABLED(APP_USBD_DUMMY)

components/libraries/usbd/class/dummy/app_usbd_dummy.h

@@ -0,0 +1,138 @@
+/**
+ * Copyright (c) 2017 - 2020, 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.
+ *
+ */
+#ifndef APP_USBD_DUMMY_H__
+#define APP_USBD_DUMMY_H__
+
+#include <stdint.h>
+#include <stdbool.h>
+
+#include "nrf_drv_usbd.h"
+#include "nrf_block_dev.h"
+#include "app_usbd_class_base.h"
+#include "app_usbd.h"
+#include "app_usbd_core.h"
+#include "app_usbd_descriptor.h"
+
+#include "app_usbd_dummy_types.h"
+#include "app_usbd_dummy_internal.h"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @defgroup app_usbd_dummy USB Dummy class
+ * @ingroup app_usbd
+ *
+ * @brief @tagAPI52840 Module with types, definitions,
+ *                     and API used by the USB Dummy class.
+ *
+ * @note Class is used as a filler to provide correct alignement of interfaces.
+ *
+ * @{
+ */
+
+#ifdef DOXYGEN
+/**
+ * @brief Dummy class instance type.
+ *
+ * @ref APP_USBD_CLASS_TYPEDEF
+ */
+typedef struct { } app_usbd_dummy_t;
+#else
+/*lint -save -e10 -e26 -e123 -e505 */
+APP_USBD_CLASS_NO_EP_TYPEDEF(app_usbd_dummy,                                             \
+                             APP_USBD_DUMMY_CONFIG(0),                                   \
+                             APP_USBD_DUMMY_INSTANCE_SPECIFIC_DEC,                       \
+                             APP_USBD_DUMMY_DATA_SPECIFIC_DEC                            \
+);
+#endif
+
+/*lint -restore*/
+
+/**
+ * @brief Global definition of app_usbd_dummy_t class.
+ *
+ * @param instance_name         Name of global instance.
+ * @param interface_number      Unique interface number.
+ *
+ * @note This macro is just simplified version of @ref APP_USBD_DUMMY_GLOBAL_DEF_INTERNAL
+ *
+ */
+/*lint -save -emacro(26 64 123 505 651, APP_USBD_DUMMY_GLOBAL_DEF)*/
+#define APP_USBD_DUMMY_GLOBAL_DEF(instance_name, interface_number) \
+        APP_USBD_DUMMY_GLOBAL_DEF_INTERNAL(instance_name, interface_number)
+/*lint -restore*/
+
+/**
+ * @@brief Helper function to get class instance from dummy.
+ *
+ * @param[in] p_dummy Dummy instance
+ *                    (declared by @ref APP_USBD_DUMMY_GLOBAL_DEF).
+ *
+ * @return Base class instance.
+ */
+static inline app_usbd_class_inst_t const *
+app_usbd_dummy_class_inst_get(app_usbd_dummy_t const * p_dummy)
+{
+    return &p_dummy->base;
+}
+
+/**
+ * @brief Helper function to get dummy from base class instance.
+ *
+ * @param[in] p_inst Base class instance.
+ *
+ * @return Dummy class handle.
+ */
+static inline app_usbd_dummy_t const *
+app_usbd_dummy_class_get( app_usbd_class_inst_t const * p_inst)
+{
+    return (app_usbd_dummy_t const *)p_inst;
+}
+
+/** @} */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* APP_USBD_DUMMY_H__ */

components/libraries/usbd/class/dummy/app_usbd_dummy_internal.h

@@ -0,0 +1,115 @@
+/**
+ * Copyright (c) 2017 - 2020, 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.
+ *
+ */
+#ifndef APP_USBD_DUMMY_INTERNAL_H__
+#define APP_USBD_DUMMY_INTERNAL_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @defgroup app_usbd_dummy_internals USB Dummy internals
+ * @ingroup app_usbd_dummy
+ *
+ * @brief @tagAPI52840 Internals of the USB Dummy class.
+ * @{
+ */
+
+/** @brief Forward declaration of Dummy Class type */
+APP_USBD_CLASS_FORWARD(app_usbd_dummy);
+
+/** @brief Dummy part of class instance data */
+typedef struct {
+    uint8_t none;
+} app_usbd_dummy_inst_t;
+
+/** @brief Dummy context */
+typedef struct {
+    uint8_t none;
+} app_usbd_dummy_ctx_t;
+
+
+/**
+ * @brief Dummy configuration macro.
+ *
+ * Used by @ref APP_USBD_DUMMY_GLOBAL_DEF
+ *
+ * @param iface Interface number.
+ * */
+#define APP_USBD_DUMMY_CONFIG(iface) (iface)
+
+
+/**
+ * @brief Specific class constant data for Dummy.
+ *
+ * @ref app_usbd_dummy_inst_t
+ */
+#define APP_USBD_DUMMY_INSTANCE_SPECIFIC_DEC app_usbd_dummy_inst_t inst;
+
+/**
+ * @brief Specific class data for Dummy.
+ *
+ * @ref app_usbd_dummy_ctx_t
+ * */
+#define APP_USBD_DUMMY_DATA_SPECIFIC_DEC app_usbd_dummy_ctx_t ctx;
+
+
+/** @brief Public Dummy class interface */
+extern const app_usbd_class_methods_t app_usbd_dummy_class_methods;
+
+/** @brief Global definition of Dummy instance */
+#define APP_USBD_DUMMY_GLOBAL_DEF_INTERNAL(instance_name, interface_number)                        \
+    APP_USBD_CLASS_INST_NO_EP_GLOBAL_DEF(                                                          \
+        instance_name,                                                                             \
+        app_usbd_dummy,                                                                            \
+        &app_usbd_dummy_class_methods,                                                             \
+        APP_USBD_DUMMY_CONFIG((interface_number)),                                                 \
+        ()                                                                                         \
+    )
+
+
+/** @} */
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* APP_USBD_DUMMY_INTERNAL_H__ */

components/libraries/usbd/class/dummy/app_usbd_dummy_types.h

@@ -0,0 +1,75 @@
+/**
+ * Copyright (c) 2017 - 2020, 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.
+ *
+ */
+#ifndef APP_USBD_DUMMY_TYPES_H__
+#define APP_USBD_DUMMY_TYPES_H__
+
+#include "app_util.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @defgroup app_usbd_dummy_types USB Dummy types
+ * @ingroup app_usbd_dummy
+ *
+ * @brief @tagAPI52840 Types used in the USB Dummy class.
+ * @{
+ */
+
+/** @brief Dummy class definition in interface descriptor.
+ *
+ *  @ref app_usbd_descriptor_iface_t::bInterfaceClass
+ * */
+#define APP_USBD_DUMMY_CLASS 0xFF
+
+/** @brief Dummy subclass value. */
+#define APP_USBD_DUMMY_SUBCLASS 0x00
+
+/** @brief Dummy protocol value. */
+#define APP_USBD_DUMMY_PROTOCOL 0x00
+
+/** @} */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* APP_USBD_DUMMY_TYPES_H__ */

components/libraries/usbd/class/hid/app_usbd_hid.c

@@ -0,0 +1,637 @@
+/**
+ * Copyright (c) 2016 - 2020, 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 "sdk_common.h"
+#if NRF_MODULE_ENABLED(APP_USBD_HID)
+
+#include "app_usbd.h"
+#include "app_usbd_core.h"
+#include "app_usbd_hid.h"
+
+#include "nrf_log.h"
+
+/**
+ * @ingroup app_usbd_hid_internals USBD HID internals
+ * @{
+ * @ingroup app_usbd_hid
+ * @internal
+ */
+
+#define APP_USBD_HID_SOF_NOT_REQ_FLAG 0xFFFF
+
+/**
+ * @brief Test whether SOF HID transfer is required.
+ *
+ * This function handles idle period IN transfer.
+ *
+ * @param[in,out] p_hid_ctx     Internal HID context.
+ * @param[in]     framecnt      SOF event frame counter.
+ *
+ * @retval report_id                        If transfer with ID required
+ * @retval APP_USBD_HID_SOF_NOT_REQ_FLAG    If no transfer required
+ */
+static uint16_t hid_sof_required(app_usbd_hid_ctx_t * p_hid_ctx, uint16_t framecnt)
+{
+    if (!p_hid_ctx->idle_on)
+    {
+        /* Infinite idle rate */
+        return APP_USBD_HID_SOF_NOT_REQ_FLAG;
+    }
+
+    uint8_t i = 0;
+    uint16_t rate_ms[APP_USBD_HID_REPORT_IDLE_TABLE_SIZE] = {0};
+    
+    for(i = 0; i < APP_USBD_HID_REPORT_IDLE_TABLE_SIZE; i++)
+    {
+        rate_ms[i] = p_hid_ctx->idle_rate[i] * 4;
+    
+        if((framecnt == APP_USBD_SOF_MAX) && (p_hid_ctx->first_idle[i] != (APP_USBD_SOF_MAX + 1)))
+        {
+            /* SOF has only 2047 frame count maximum - adjust m_first_idle */
+            p_hid_ctx->first_idle[i] = ((p_hid_ctx->first_idle[i] + APP_USBD_SOF_MAX) % rate_ms[i]) + 1;
+        }
+        
+        if (p_hid_ctx->access_lock)
+        {
+            /* Access to internal data locked. Buffer is BUSY.
+             * Don't send anything. Clear transfer flag. Next transfer will be triggered
+             * from API context.*/
+            app_usbd_hid_state_flag_clr(p_hid_ctx, APP_USBD_HID_STATE_FLAG_TRANS_IN_PROGRESS);
+            return APP_USBD_HID_SOF_NOT_REQ_FLAG;
+        }
+
+        /* Idle transfer required if SOF is correct with an accuracy of +/-10% + 2ms*/
+        if (((framecnt + p_hid_ctx->first_idle[i]) % rate_ms[i]) < (2 + (rate_ms[i] / 10)))
+        {
+            return i;
+        }
+        
+        /* Only 0 id has set idle rate. No need to check whole table. */
+        if(!p_hid_ctx->idle_id_report)
+        {
+            return APP_USBD_HID_SOF_NOT_REQ_FLAG;
+        }
+    }
+
+    return APP_USBD_HID_SOF_NOT_REQ_FLAG;
+}
+
+/**
+ * @brief User event handler.
+ *
+ * @param[in] p_inst        Class instance.
+ * @param[in] p_hinst       HID class instance.
+ * @param[in] event user    Event type.
+ */
+static inline void user_event_handler(app_usbd_class_inst_t const * p_inst,
+                                      app_usbd_hid_inst_t const * p_hinst,
+                                      app_usbd_hid_user_event_t event)
+{
+    if (p_hinst->user_event_handler != NULL)
+    {
+        p_hinst->user_event_handler(p_inst, event);
+    }
+}
+
+/**
+ * @brief Internal SETUP standard IN request handler.
+ *
+ * @param[in]       p_inst        Generic class instance.
+ * @param[in]       p_hinst       HID class instance.
+ * @param[in,out]   p_hid_ctx     HID context.
+ * @param[in]       p_setup_ev    Setup event.
+ *
+ * @return Standard error code.
+ */
+static ret_code_t setup_req_std_in(app_usbd_class_inst_t const * p_inst,
+                                   app_usbd_hid_inst_t const * p_hinst,
+                                   app_usbd_hid_ctx_t * p_hid_ctx,
+                                   app_usbd_setup_evt_t const * p_setup_ev)
+{
+    /* Only Get Descriptor standard IN request is supported by HID class */
+    if ((app_usbd_setup_req_rec(p_setup_ev->setup.bmRequestType) == APP_USBD_SETUP_REQREC_INTERFACE)
+        &&
+        (p_setup_ev->setup.bRequest == APP_USBD_SETUP_STDREQ_GET_DESCRIPTOR))
+    {
+        size_t dsc_len = 0;
+        size_t max_size;
+        uint8_t descr_type = p_setup_ev->setup.wValue.hb;
+        uint8_t descr_idx = p_setup_ev->setup.wValue.lb;
+
+        uint8_t * p_trans_buff = app_usbd_core_setup_transfer_buff_get(&max_size);
+
+        /* Validation for Class Descriptors. Only HID and REPORT are supported */
+        if ((descr_type < APP_USBD_HID_DESCRIPTOR_HID) || (descr_type >= APP_USBD_HID_DESCRIPTOR_PHYSICAL))
+        {
+            return NRF_ERROR_NOT_SUPPORTED;
+        }
+
+        /* Try to find descriptor in class internals*/
+        ret_code_t ret = app_usbd_class_descriptor_find(
+            p_inst,
+            descr_type,
+            descr_idx,
+            p_trans_buff,
+            &dsc_len);
+
+        if (ret == NRF_SUCCESS)
+        {
+            ASSERT(dsc_len < NRF_DRV_USBD_EPSIZE);
+            return app_usbd_core_setup_rsp(&(p_setup_ev->setup), p_trans_buff, dsc_len);
+        }
+
+        /* If not found try HID specific descriptors*/
+        if (descr_idx >= p_hinst->p_hid_methods->subclass_count(p_inst) )
+        {
+            /* requested index out of range */
+            return NRF_ERROR_NOT_SUPPORTED;
+        }
+        else
+        {
+            uint32_t report_size = 
+                p_hinst->p_hid_methods->subclass_length(p_inst, descr_idx);
+            const uint8_t * p_first_byte = 
+                p_hinst->p_hid_methods->subclass_data(p_inst, descr_idx, 0);
+         
+            return app_usbd_core_setup_rsp(&p_setup_ev->setup, p_first_byte, report_size);
+        }
+    }
+
+    return NRF_ERROR_NOT_SUPPORTED;
+}
+
+/**
+ * @brief Internal SETUP standard OUT request handler.
+ *
+ * @param[in]       p_inst        Generic class instance.
+ * @param[in]       p_hinst       HID class instance.
+ * @param[in,out]   p_hid_ctx     HID context.
+ * @param[in]       p_setup_ev    Setup event.
+ *
+ * @return Standard error code.
+ */
+static ret_code_t setup_req_std_out(app_usbd_class_inst_t const * p_inst,
+                                    app_usbd_hid_inst_t const * p_hinst,
+                                    app_usbd_hid_ctx_t * p_hid_ctx,
+                                    app_usbd_setup_evt_t const * p_setup_ev)
+{
+    /*Only Set Descriptor standard OUT request is supported by HID class. However, it is optional
+     * and useless in HID cases.*/
+    return NRF_ERROR_NOT_SUPPORTED;
+}
+
+/**
+ * @brief Internal SETUP class IN request handler.
+ *
+ * @param[in]       p_inst        Generic class instance.
+ * @param[in]       p_hinst       HID class instance.
+ * @param[in,out]   p_hid_ctx     HID context.
+ * @param[in]       p_setup_ev    Setup event.
+ *
+ * @return Standard error code.
+ */
+static ret_code_t setup_req_class_in(app_usbd_class_inst_t const * p_inst,
+                                     app_usbd_hid_inst_t const * p_hinst,
+                                     app_usbd_hid_ctx_t * p_hid_ctx,
+                                     app_usbd_setup_evt_t const * p_setup_ev)
+{
+    switch (p_setup_ev->setup.bRequest)
+    {
+        case APP_USBD_HID_REQ_GET_REPORT:
+        {
+            if ((p_setup_ev->setup.wValue.hb == APP_USBD_HID_REPORT_TYPE_INPUT) ||
+                (p_setup_ev->setup.wValue.hb == APP_USBD_HID_REPORT_TYPE_OUTPUT) ||
+                (p_setup_ev->setup.wValue.hb == APP_USBD_HID_REPORT_TYPE_FEATURE))
+            {
+                return p_hinst->p_hid_methods->on_get_report(p_inst, p_setup_ev);
+            }
+            else
+            {
+                break;
+            }
+        }
+        case APP_USBD_HID_REQ_GET_IDLE:
+        {
+            return app_usbd_core_setup_rsp(&p_setup_ev->setup,
+                                           &p_hid_ctx->idle_rate[p_setup_ev->setup.wValue.lb],
+                                           sizeof(p_hid_ctx->idle_rate[p_setup_ev->setup.wValue.lb]));
+        }
+        case APP_USBD_HID_REQ_GET_PROTOCOL:
+        {
+            return app_usbd_core_setup_rsp(&p_setup_ev->setup,
+                                           &p_hid_ctx->selected_protocol,
+                                           sizeof(p_hid_ctx->selected_protocol));
+        }
+        default:
+            break;
+
+    }
+
+    return NRF_ERROR_NOT_SUPPORTED;
+}
+
+/**
+ * @brief Internal SETUP class OUT request handler.
+ *
+ * @param[in]       p_inst        Generic class instance.
+ * @param[in]       p_hinst       HID class instance.
+ * @param[in,out]   p_hid_ctx     HID context.
+ * @param[in]       p_setup_ev    Setup event.
+ *
+ * @return Standard error code.
+ */
+static ret_code_t setup_req_class_out(app_usbd_class_inst_t const * p_inst,
+                                      app_usbd_hid_inst_t const * p_hinst,
+                                      app_usbd_hid_ctx_t * p_hid_ctx,
+                                      app_usbd_setup_evt_t const * p_setup_ev)
+{
+    switch (p_setup_ev->setup.bRequest)
+    {
+        case APP_USBD_HID_REQ_SET_REPORT:
+            if (((p_setup_ev->setup.wValue.hb != APP_USBD_HID_REPORT_TYPE_OUTPUT) &&
+                 (p_setup_ev->setup.wValue.hb != APP_USBD_HID_REPORT_TYPE_FEATURE)) ||
+                p_hinst->p_hid_methods->on_set_report == NULL)
+            {
+                break;
+            }
+
+            return p_hinst->p_hid_methods->on_set_report(p_inst, p_setup_ev);
+        case APP_USBD_HID_REQ_SET_IDLE:
+            {
+                p_hid_ctx->idle_rate[p_setup_ev->setup.wValue.lb] = p_setup_ev->setup.wValue.hb;
+                p_hid_ctx->first_idle[p_setup_ev->setup.wValue.lb] = APP_USBD_SOF_MAX + 1;
+
+                /* Clear idle, high byte is interval. */
+                if(p_setup_ev->setup.wValue.hb == 0) 
+                {
+                    /* Set global idle flags according to values in channels.
+                       If only idle rate with id 0 is non 0 set idle_id_report to false. */
+                    bool clear = true;
+                    uint8_t i = 0;
+
+                    /* Loop starts at 1 to skip the "global" channel 0. */
+                    for(i=1; i < APP_USBD_HID_REPORT_IDLE_TABLE_SIZE; i++)
+                    {
+                        if(p_hid_ctx->idle_rate[i] != 0)
+                        {
+                            clear = false;
+                            break;
+                        }
+                    }
+
+                    /* If all channels 1..N have frequency 0 then switch off global handling of idle. */
+                    if(clear)
+                    {
+                        /* Distinguish between "report-specific" reports and "global" flag. */
+                        p_hid_ctx->idle_id_report = false;
+                        
+                        if(p_hid_ctx->idle_rate[0] == 0)
+                        {
+                            /* If all are 0 set m_idle_on to false. */
+                            p_hid_ctx->idle_on = false;
+                        }
+                    }
+                }
+                /* Set idle because Interval was != 0 */
+                else
+                {
+                    /* If any idle rate is not 0 set m_idle_on to true. */
+                    p_hid_ctx->idle_on = true;
+                    
+                    /* If any idle rate with id != 0 is non 0 set idle_id_report to true. */
+                    if(p_setup_ev->setup.wValue.lb != 0)
+                    {
+                        /* Separate handling when only a single report is used. */
+                        p_hid_ctx->idle_id_report = true;
+                    }
+                }
+
+                return NRF_SUCCESS;
+            }
+        case APP_USBD_HID_REQ_SET_PROTOCOL:
+            {
+                app_usbd_hid_user_event_t ev = (p_setup_ev->setup.wValue.w == APP_USBD_HID_PROTO_BOOT) ?
+                    APP_USBD_HID_USER_EVT_SET_BOOT_PROTO :
+                    APP_USBD_HID_USER_EVT_SET_REPORT_PROTO;
+
+                if (ev == APP_USBD_HID_USER_EVT_SET_BOOT_PROTO)
+                {
+                    p_hid_ctx->selected_protocol = APP_USBD_HID_PROTO_BOOT;
+                }
+                else if (ev == APP_USBD_HID_USER_EVT_SET_REPORT_PROTO)
+                {
+                    p_hid_ctx->selected_protocol = APP_USBD_HID_PROTO_REPORT;
+                }
+                else
+                {
+                    return NRF_ERROR_INVALID_PARAM;
+                }
+
+                user_event_handler(p_inst, p_hinst, ev);
+            }
+            return NRF_SUCCESS;
+        default:
+            break;
+    }
+
+    return NRF_ERROR_NOT_SUPPORTED;
+}
+
+/**
+ * @brief Internal SETUP event handler.
+ *
+ * @param[in]       p_inst        Generic class instance.
+ * @param[in]       p_hinst       HID class instance.
+ * @param[in,out]   p_hid_ctx     HID context.
+ * @param[in]       p_setup_ev    Setup event.
+ *
+ * @return Standard error code.
+ */
+static ret_code_t setup_event_handler(app_usbd_class_inst_t const * p_inst,
+                                      app_usbd_hid_inst_t const * p_hinst,
+                                      app_usbd_hid_ctx_t * p_hid_ctx,
+                                      app_usbd_setup_evt_t const * p_setup_ev)
+{
+    ASSERT(p_hinst != NULL);
+    ASSERT(p_hid_ctx != NULL);
+    ASSERT(p_setup_ev != NULL);
+
+    if (app_usbd_setup_req_dir(p_setup_ev->setup.bmRequestType) == APP_USBD_SETUP_REQDIR_IN)
+    {
+        switch (app_usbd_setup_req_typ(p_setup_ev->setup.bmRequestType))
+        {
+            case APP_USBD_SETUP_REQTYPE_STD:
+                return setup_req_std_in(p_inst, p_hinst, p_hid_ctx, p_setup_ev);
+            case APP_USBD_SETUP_REQTYPE_CLASS:
+                return setup_req_class_in(p_inst, p_hinst, p_hid_ctx, p_setup_ev);
+            default:
+                break;
+        }
+    }
+    else /*APP_USBD_SETUP_REQDIR_OUT*/
+    {
+        switch (app_usbd_setup_req_typ(p_setup_ev->setup.bmRequestType))
+        {
+            case APP_USBD_SETUP_REQTYPE_STD:
+                return setup_req_std_out(p_inst, p_hinst, p_hid_ctx, p_setup_ev);
+            case APP_USBD_SETUP_REQTYPE_CLASS:
+                return setup_req_class_out(p_inst, p_hinst, p_hid_ctx, p_setup_ev);
+            default:
+                break;
+        }
+    }
+
+    return NRF_ERROR_NOT_SUPPORTED;
+}
+
+/**
+ * @brief Endpoint IN event handler.
+ *
+ * @param[in]       p_inst        Generic class instance.
+ * @param[in]       p_hinst       HID class instance.
+ * @param[in,out]   p_hid_ctx     HID context.
+ * @param[in]       p_setup_ev    Setup event.
+ *
+ * @return Standard error code.
+ */
+static ret_code_t endpoint_in_event_handler(app_usbd_class_inst_t const * p_inst,
+                                            app_usbd_hid_inst_t const * p_hinst,
+                                            app_usbd_hid_ctx_t * p_hid_ctx,
+                                            app_usbd_complex_evt_t const * p_event)
+{
+
+    if (p_event->drv_evt.data.eptransfer.status == NRF_USBD_EP_OK)
+    {
+        /* Notify user about last successful transfer. */
+        user_event_handler(p_inst, p_hinst, APP_USBD_HID_USER_EVT_IN_REPORT_DONE);
+    }
+
+    if (app_usbd_hid_access_lock_test(p_hid_ctx))
+    {
+        /* Access to internal data locked. Buffer is BUSY.
+         * Don't send anything. Clear transfer flag. Next transfer will be triggered
+         * from main loop context. */
+        app_usbd_hid_state_flag_clr(p_hid_ctx, APP_USBD_HID_STATE_FLAG_TRANS_IN_PROGRESS);
+        return NRF_SUCCESS;
+    }
+
+    {
+        uint8_t i = 0;
+        for(i=0; i < APP_USBD_HID_REPORT_IDLE_TABLE_SIZE; i++)
+        {
+            if (p_hid_ctx->first_idle[i] == (APP_USBD_SOF_MAX + 1))
+            {
+                p_hid_ctx->lock_idle[i] = true;
+            }
+            
+            /* Only 0 id has set idle rate. No need to check whole table. */
+            if(!p_hid_ctx->idle_id_report)
+            {
+                break;
+            }
+        }
+    }
+
+    /* HID 1.11 specification states that in case the report has changed, 
+       it should be transfered immediately  even when idle is enabled. */
+    return p_hinst->p_hid_methods->ep_transfer_in(p_inst);
+}
+
+/**
+ * @brief Endpoint OUT event handler.
+ *
+ * @param[in]       p_inst        Generic class instance.
+ * @param[in]       p_hinst       HID class instance.
+ * @param[in,out]   p_hid_ctx     HID context.
+ * @param[in]       p_setup_ev    Setup event.
+ *
+ * @return Standard error code.
+ */
+static ret_code_t endpoint_out_event_handler(app_usbd_class_inst_t const * p_inst,
+                                             app_usbd_hid_inst_t const * p_hinst,
+                                             app_usbd_hid_ctx_t * p_hid_ctx,
+                                             app_usbd_complex_evt_t const * p_event)
+{
+    if (p_hinst->p_hid_methods->ep_transfer_out == NULL)
+    {
+        return NRF_ERROR_NOT_SUPPORTED;
+    }
+
+    if (p_event->drv_evt.data.eptransfer.status == NRF_USBD_EP_OK)
+    {
+        /* Notify user about last successful transfer. */
+        user_event_handler(p_inst, p_hinst, APP_USBD_HID_USER_EVT_OUT_REPORT_READY);
+    }
+
+    ASSERT(p_hinst->p_rep_buffer_out->size <= NRF_DRV_USBD_EPSIZE);
+    return p_hinst->p_hid_methods->ep_transfer_out(p_inst);
+}
+
+
+static void app_usbd_clear_idle_ctx(app_usbd_hid_ctx_t * p_hid_ctx)
+{
+    uint8_t i = 0;
+    for(i=0; i < APP_USBD_HID_REPORT_IDLE_TABLE_SIZE; i++)
+    {
+        p_hid_ctx->idle_rate[i] = APP_USBD_HID_DEFAULT_IDLE_RATE;
+        p_hid_ctx->first_idle[i] = APP_USBD_SOF_MAX + 1;
+    }
+    p_hid_ctx->idle_id_report = false;
+    p_hid_ctx->idle_on = false;
+}
+
+/** @} */
+
+
+ret_code_t app_usbd_hid_event_handler(app_usbd_class_inst_t const * p_inst,
+                                      app_usbd_hid_inst_t const * p_hinst,
+                                      app_usbd_hid_ctx_t * p_hid_ctx,
+                                      app_usbd_complex_evt_t const * p_event)
+{
+    ret_code_t ret = NRF_SUCCESS;
+    switch (p_event->app_evt.type)
+    {
+        case APP_USBD_EVT_DRV_SOF:
+        {
+            uint16_t sof_req = hid_sof_required(p_hid_ctx, p_event->drv_evt.data.sof.framecnt);
+            if (sof_req != APP_USBD_HID_SOF_NOT_REQ_FLAG)
+            {
+                uint8_t i = 0;
+                for(i=0; i < APP_USBD_HID_REPORT_IDLE_TABLE_SIZE; i++)
+                {
+                    if(p_hid_ctx->lock_idle[i])
+                    {
+                        p_hid_ctx->first_idle[i] = p_event->drv_evt.data.sof.framecnt;
+                        p_hid_ctx->lock_idle[i] = false;
+                    }
+                    /* Only 0 id has set idle rate. No need to check whole table. */
+                    if(!p_hid_ctx->idle_id_report)
+                    {
+                        break;
+                    }
+                }
+                ret = p_hinst->p_hid_methods->on_idle(p_inst, sof_req);
+            }
+            break;
+        }
+        case APP_USBD_EVT_DRV_RESET:
+        {
+            app_usbd_hid_state_flag_clr(p_hid_ctx, APP_USBD_HID_STATE_FLAG_TRANS_IN_PROGRESS);
+            p_hid_ctx->selected_protocol = APP_USBD_HID_PROTO_REPORT;
+            app_usbd_clear_idle_ctx(p_hid_ctx);
+            break;
+        }
+        case APP_USBD_EVT_DRV_SETUP:
+            ret  = setup_event_handler(p_inst, p_hinst, p_hid_ctx, &p_event->setup_evt);
+            break;
+        case APP_USBD_EVT_DRV_EPTRANSFER:
+            if (NRF_USBD_EPIN_CHECK(p_event->drv_evt.data.eptransfer.ep))
+            {
+                ret = endpoint_in_event_handler(p_inst, p_hinst, p_hid_ctx, p_event);
+            }
+            else
+            {
+                ret = endpoint_out_event_handler(p_inst, p_hinst, p_hid_ctx, p_event);
+            }
+            break;
+        case APP_USBD_EVT_DRV_SUSPEND:
+            app_usbd_hid_state_flag_set(p_hid_ctx, APP_USBD_HID_STATE_FLAG_SUSPENDED);
+            break;
+        case APP_USBD_EVT_DRV_RESUME:
+            app_usbd_hid_state_flag_clr(p_hid_ctx, APP_USBD_HID_STATE_FLAG_SUSPENDED);
+
+            /* Always try to trigger transfer on resume event*/
+            ret = p_hinst->p_hid_methods->ep_transfer_in(p_inst);
+            break;
+        case APP_USBD_EVT_INST_APPEND:
+            /*SOF register: GetIdle/SetIdle support*/
+            ret = app_usbd_class_sof_register(p_inst);
+            if (ret != NRF_SUCCESS)
+            {
+                break;
+            }
+            ret = app_usbd_class_rwu_register(p_inst);
+            if (ret != NRF_SUCCESS)
+            {
+                break;
+            }
+            app_usbd_clear_idle_ctx(p_hid_ctx);
+            app_usbd_hid_state_flag_set(p_hid_ctx, APP_USBD_HID_STATE_FLAG_APPENDED);
+            break;
+        case APP_USBD_EVT_INST_REMOVE:
+            /*SOF unregister: GetIdle/SetIdle support*/
+            ret = app_usbd_class_sof_unregister(p_inst);
+            if (ret != NRF_SUCCESS)
+            {
+                break;
+            }
+            ret = app_usbd_class_rwu_unregister(p_inst);
+            if (ret != NRF_SUCCESS)
+            {
+                break;
+            }
+            app_usbd_hid_state_flag_clr(p_hid_ctx, APP_USBD_HID_STATE_FLAG_APPENDED);
+            break;
+        case APP_USBD_EVT_STARTED:
+            app_usbd_hid_state_flag_set(p_hid_ctx, APP_USBD_HID_STATE_FLAG_STARTED);
+            break;
+        case APP_USBD_EVT_STOPPED:
+            app_usbd_hid_state_flag_clr(p_hid_ctx, APP_USBD_HID_STATE_FLAG_STARTED);
+            break;
+        default:
+            ret = NRF_ERROR_NOT_SUPPORTED;
+            break;
+    }
+
+    return ret;
+}
+
+app_usbd_hid_report_buffer_t * app_usbd_hid_rep_buff_in_get(app_usbd_hid_inst_t const * p_hinst)
+{
+    ASSERT(p_hinst);
+    return p_hinst->p_rep_buffer_in;
+}
+
+app_usbd_hid_report_buffer_t const * app_usbd_hid_rep_buff_feature_get(app_usbd_hid_inst_t const * p_hinst)
+{
+    ASSERT(p_hinst);
+    return p_hinst->p_rep_buffer_feature;
+}
+
+#endif //NRF_MODULE_ENABLED(APP_USBD_HID)

components/libraries/usbd/class/hid/app_usbd_hid.h

@@ -0,0 +1,607 @@
+/**
+ * Copyright (c) 2017 - 2020, 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.
+ *
+ */
+#ifndef APP_USBD_HID_H__
+#define APP_USBD_HID_H__
+
+#include <stdint.h>
+#include <stdbool.h>
+
+#include "sdk_common.h"
+#include "nrf_atomic.h"
+#include "app_usbd_hid_types.h"
+#include "app_usbd.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @defgroup app_usbd_hid USB HID class
+ * @ingroup app_usbd
+ *
+ * @brief @tagAPI52840 Module with generic HID event data processing.
+ * @{
+ */
+
+#define APP_USBD_HID_IFACE_IDX 0    /**< @brief HID instance interface index.   */
+#define APP_USBD_HID_EPIN_IDX  0    /**< @brief HID instance endpoint IN index. */
+#define APP_USBD_HID_EPOUT_IDX 1    /**< @brief HID instance endpoint OUT index.*/
+
+/**
+ * @brief HID context state flags.
+ *
+ * Bit numbers in @ref app_usbd_hid_ctx_t::state_flags.
+ */
+typedef enum {
+    APP_USBD_HID_STATE_FLAG_APPENDED          = 0, /**< State flag APPENDED.          */
+    APP_USBD_HID_STATE_FLAG_STARTED           = 1, /**< State flag STARTED.           */
+    APP_USBD_HID_STATE_FLAG_SUSPENDED         = 2, /**< State flag SUSPENDED.         */
+    APP_USBD_HID_STATE_FLAG_TRANS_IN_PROGRESS = 3, /**< State flag TRANS_IN_PROGRESS. */
+} app_usbd_hid_state_flag_t;
+
+/**
+ * @brief Events passed to user event handler.
+ *
+ * @note Example prototype of user event handler:
+   @code
+   void hid_user_ev_handler(app_usbd_class_inst_t const   * p_inst,
+                            app_usbd_hid_mouse_user_event_t event);
+   @endcode
+ */
+typedef enum {
+    APP_USBD_HID_USER_EVT_SET_BOOT_PROTO,           /**< Event SET_BOOT_PROTOCOL.       */
+    APP_USBD_HID_USER_EVT_SET_REPORT_PROTO,         /**< Event SET_REPORT_PROTOCOL.     */
+    APP_USBD_HID_USER_EVT_OUT_REPORT_READY,         /**< Event OUT_REPORT_READY.        */
+    APP_USBD_HID_USER_EVT_IN_REPORT_DONE,           /**< Event IN_REPORT_DONE.          */
+    APP_USBD_HID_USER_EVT_FEATURE_REPORT_READY,     /**< Event FEATURE_REPORT_READY.    */
+} app_usbd_hid_user_event_t;
+
+
+/**
+ * @brief User event handler.
+ *
+ * @param[in] p_inst Class instance.
+ * @param[in] event  User event.
+ */
+typedef void (*app_usbd_hid_user_ev_handler_t)(app_usbd_class_inst_t const * p_inst,
+                                               app_usbd_hid_user_event_t event);
+
+/**
+ * @brief Idle report handler.
+ *
+ * @param[in] p_inst        Class instance.
+ * @param[in] report_id     Number of report ID that needs idle transfer.
+ */
+typedef ret_code_t (*app_usbd_hid_idle_handler_t)(app_usbd_class_inst_t const * p_inst,
+                                                  uint8_t report_id);
+
+/**
+ * @brief HID unified interface
+ * */
+typedef struct {
+
+    /**
+     * @brief Function called on HID specific, GetReport request.
+     *
+     * This function should trigger data write to control pipe.
+     *
+     * @param[in] p_inst        Class instance.
+     * @param[in] p_setup_ev    Setup event.
+     *
+     * @return                  Standard error code.
+     */
+    ret_code_t (*on_get_report)(app_usbd_class_inst_t const * p_inst,
+                                app_usbd_setup_evt_t const * p_setup_ev);
+
+    /**
+     * @brief Function called on HID specific, SetReport request.
+     *
+     * This function should trigger data read from control pipe. This function is not required and
+     * NULL could be pinned to this handler when output report is not defined in report descriptor.
+     *
+     * @param[in] p_inst        Class instance.
+     * @param[in] p_setup_ev    Setup event.
+     *
+     * @return                  Standard error code.
+     */
+    ret_code_t (*on_set_report)(app_usbd_class_inst_t const * p_inst,
+                                app_usbd_setup_evt_t const * p_setup_ev);
+
+    /**
+     * @brief Function called on IN endpoint transfer.
+     *
+     * This function should trigger next endpoint IN transfer if required.
+     *
+     * @param[in] p_inst        Class instance.
+     *
+     * @return                  Standard error code.
+     */
+    ret_code_t (*ep_transfer_in)(app_usbd_class_inst_t const * p_inst);
+
+    /**
+     * @brief Function called on OUT endpoint transfer.
+     *
+     * This function should should read data from OUT endpoint. This function is not required and
+     * NULL could be pinned to this handler when class doesn't have OUT endpoint.
+     *
+     * @param[in] p_inst        Class instance.
+     *
+     * @return                  Standard error code.
+     */
+    ret_code_t (*ep_transfer_out)(app_usbd_class_inst_t const * p_inst);
+
+    /**
+     * @brief Function returns subclass descriptor count.
+     *
+     * @param[in] p_inst        Class instance.
+     *
+     * @return                  Count of descriptors
+     */
+    uint8_t (*subclass_count)(app_usbd_class_inst_t const * p_inst);
+
+    /**
+     * @brief Function returns subclass descriptor size.
+     *
+     * @param[in] p_inst        Class instance.
+     * @param[in] desc_num      Index of the subclass descriptor
+     *
+     * @return                  Size of descriptor
+     */
+    size_t (*subclass_length)(app_usbd_class_inst_t const * p_inst,
+                              uint8_t                       desc_num);
+
+    /**
+     * @brief Function returns pointer to subclass descriptor data.
+     *
+     * @param[in] p_inst        Class instance.
+     * @param[in] desc_num      Index of the subclass descriptor
+     * @param[in] cur_byte      Index of required byte
+     *
+     * @return                  Pointer to requested byte in subclass descriptor
+     */
+    const uint8_t * (*subclass_data)(app_usbd_class_inst_t const * p_inst,
+                                     uint8_t                       desc_num,
+                                     uint32_t                      cur_byte);
+
+    /**
+     * @brief Function called on idle transfer
+     *
+     * This function should trigger next idle transfer.
+     *
+     * @param[in,out] p_inst        Instance of the class.
+     * @param[in]     report_id     Number of report ID that needs idle transfer.
+     *
+     * @return  Standard error code.
+     */
+    ret_code_t (*on_idle)(app_usbd_class_inst_t const * p_inst, uint8_t report_id);
+    
+    ret_code_t (*set_idle_handler)(app_usbd_class_inst_t const * p_inst,
+                                   app_usbd_hid_idle_handler_t handler);
+} app_usbd_hid_methods_t;
+
+/**
+ * @brief HID report buffers.
+ */
+typedef struct {
+    uint8_t * p_buff;
+    size_t    size;
+} app_usbd_hid_report_buffer_t;
+
+
+
+/**
+ * @brief Define OUT report buffer structure @ref app_usbd_hid_report_buffer_t.
+ *
+ * @param name        Instance name.
+ * @param rep_size    Output report size.
+ */
+#define APP_USBD_HID_GENERIC_GLOBAL_OUT_REP_DEF(name, rep_size)  \
+    static uint8_t CONCAT_2(name, _buf)[(rep_size)];             \
+    const app_usbd_hid_report_buffer_t name = {                  \
+            .p_buff = CONCAT_2(name, _buf),                      \
+            .size = sizeof(CONCAT_2(name, _buf)),                \
+    }
+
+/**
+ * @brief Define FEATURE report buffer structure @ref app_usbd_hid_report_buffer_t.
+ *
+ * @param name        Instance name.
+ * @param rep_size    Feature report size.
+ */
+#define APP_USBD_HID_GENERIC_GLOBAL_FEATURE_REP_DEF(name, rep_size)  \
+    static uint8_t CONCAT_2(name, _feature_buf)[(rep_size)];         \
+    const app_usbd_hid_report_buffer_t name = {                      \
+            .p_buff = CONCAT_2(name, _feature_buf),                  \
+            .size = sizeof(CONCAT_2(name, _feature_buf)),            \
+    }
+
+
+/**
+ * @brief HID subclass descriptor.
+ */
+
+typedef struct {
+    size_t                size;
+    app_usbd_descriptor_t type;
+    uint8_t const * const p_data;
+} app_usbd_hid_subclass_desc_t;
+
+/**
+ * @brief Initializer of HID report descriptor
+ *
+ * @param name  Report descriptor name
+ * @param ...   Report descriptor data
+ */
+
+#define APP_USBD_HID_GENERIC_SUBCLASS_REPORT_DESC(name, ...)    \
+    static uint8_t const CONCAT_2(name,  _data)[] =             \
+        __VA_ARGS__                                             \
+    ;                                                           \
+    static const app_usbd_hid_subclass_desc_t name =            \
+    {                                                           \
+        sizeof(CONCAT_2(name, _data)),                          \
+        APP_USBD_DESCRIPTOR_REPORT,                             \
+        CONCAT_2(name,_data)                                    \
+    }
+
+/**
+ * @brief Initializer of HID physical descriptor
+ *
+ * @param name  Physical descriptor name
+ * @param ...   Physical descriptor data
+ */
+
+#define APP_USBD_HID_GENERIC_SUBCLASS_PHYSICAL_DESC(name, ...)  \
+    static uint8_t const CONCAT_2(name,  _data)[] =             \
+        __VA_ARGS__                                             \
+    ;                                                           \
+    static const app_usbd_hid_subclass_desc_t name =            \
+    {                                                           \
+        sizeof(CONCAT_2(name, _data)),                          \
+        APP_USBD_DESCRIPTOR_PHYSICAL,                           \
+        CONCAT_2(name,_data)                                    \
+    }
+
+
+/**
+ * @brief USB HID instance.
+ */
+typedef struct {
+    app_usbd_hid_subclass_desc_t const ** const p_subclass_desc; //!< HID subclass descriptors array.
+    size_t subclass_desc_count;                                  //!< HID subclass descriptors count.
+
+    app_usbd_hid_subclass_t subclass_boot;    //!< Boot device (see HID definition).
+    app_usbd_hid_protocol_t protocol;         //!< HID protocol (see HID definition).
+
+    app_usbd_hid_report_buffer_t       * p_rep_buffer_in;        //!< Report buffer IN.
+    app_usbd_hid_report_buffer_t const * p_rep_buffer_out;       //!< Report buffer OUT (only one instance).
+    app_usbd_hid_report_buffer_t const * p_rep_buffer_feature;   //!< Report buffer FEATURE.
+    app_usbd_hid_methods_t const       * p_hid_methods;          //!< Hid interface methods.
+    app_usbd_hid_user_ev_handler_t       user_event_handler;     //!< User event handler.
+
+    uint8_t * p_ep_interval;   //!< Endpoint intervals.
+} app_usbd_hid_inst_t;
+
+/**
+ * @brief USB HID instance initializer @ref app_usbd_hid_inst_t.
+ *
+ * @param subclass_dsc          HID subclass descriptors.
+ * @param sub_boot              Subclass boot. (@ref app_usbd_hid_subclass_t)
+ * @param protocl               HID protocol. (@ref app_usbd_hid_protocol_t)
+ * @param report_buff_in        Input report buffer list.
+ * @param report_buff_out       Output report buffer.
+ * @param report_buff_feature   Feature report buffer.
+ * @param user_ev_handler       @ref app_usbd_hid_user_ev_handler_t.
+ * @param hid_methods           @ref app_usbd_hid_methods_t.
+ * @param ep_list               List of endpoints and intervals
+ * */
+
+#define APP_USBD_HID_INST_CONFIG(subclass_dsc,               \
+                                 sub_boot,                   \
+                                 protocl,                    \
+                                 report_buff_in,             \
+                                 report_buff_out,            \
+                                 report_buff_feature,        \
+                                 user_ev_handler,            \
+                                 hid_methods,                \
+                                 ep_list)                    \
+    {                                                        \
+        .p_subclass_desc = subclass_dsc,                     \
+        .subclass_desc_count = ARRAY_SIZE(subclass_dsc),     \
+        .p_rep_buffer_in = report_buff_in,                   \
+        .p_rep_buffer_out = report_buff_out,                 \
+        .p_rep_buffer_feature = report_buff_feature,         \
+        .user_event_handler = user_ev_handler,               \
+        .p_hid_methods = hid_methods,                        \
+        .subclass_boot = sub_boot,                           \
+        .protocol = protocl,                                 \
+        .p_ep_interval = ep_list                             \
+    }
+
+/**
+ * @brief HID internal context.
+ * */
+typedef struct {
+    nrf_atomic_u32_t                state_flags;                                     //!< HID state flags @ref app_usbd_hid_state_flag_t.
+    nrf_atomic_flag_t               access_lock;                                     //!< Lock flag to internal data.
+    uint8_t                         idle_rate[APP_USBD_HID_REPORT_IDLE_TABLE_SIZE];  //!< HID idle rate (4ms units).
+    app_usbd_hid_protocol_select_t  selected_protocol;                               //!< Currently selected HID protocol.
+    app_usbd_hid_idle_handler_t     idle_handler;                                    //!< Idle report handler.
+    uint32_t                        first_idle[APP_USBD_HID_REPORT_IDLE_TABLE_SIZE]; //!< Number of frame at first idle transaction.
+    bool                            lock_idle[APP_USBD_HID_REPORT_IDLE_TABLE_SIZE];  //!< Lock flag to idle transactions.
+    bool                            idle_on;                                         //!< Idle transactions flag.
+    bool                            idle_id_report;                                  //!< Idle transactions with nonzero report id flag.
+} app_usbd_hid_ctx_t;
+
+
+/**
+ * @brief Locks internal hid context.
+ *
+ * Simple semaphore functionality to prevent concurrent access from application and
+ * interrupt to internal mouse data.
+ *
+ * @param[in] p_hid_ctx Internal hid context
+ */
+static inline void app_usbd_hid_access_lock(app_usbd_hid_ctx_t * p_hid_ctx)
+{
+    UNUSED_RETURN_VALUE(nrf_atomic_flag_set(&p_hid_ctx->access_lock));
+    __DSB();
+}
+
+
+/**
+ * @brief Unlocks internal hid context.
+ *
+ * Simple semaphore functionality to prevent concurrent access from application and
+ * interrupt to internal mouse data.
+ *
+ * @param[in] p_hid_ctx Internal hid context.
+ */
+static inline void app_usbd_hid_access_unlock(app_usbd_hid_ctx_t * p_hid_ctx)
+{
+    UNUSED_RETURN_VALUE(nrf_atomic_flag_clear(&p_hid_ctx->access_lock));
+    __DSB();
+}
+
+/**
+ * @brief Tests whether internal lock is acquired.
+ *
+ * @param[in] p_hid_ctx Internal HID context.
+ *
+ * @retval true  Locked.
+ * @retval false Unlocked.
+ */
+static inline bool app_usbd_hid_access_lock_test(app_usbd_hid_ctx_t * p_hid_ctx)
+{
+    return p_hid_ctx->access_lock != 0;
+}
+
+/**
+ * @brief Set one of the HID internal state flags.
+ *
+ * @param[in] p_hid_ctx     Internal HID context.
+ * @param[in] flag          Flag to set.
+ */
+static inline void app_usbd_hid_state_flag_set(app_usbd_hid_ctx_t * p_hid_ctx,
+                                               app_usbd_hid_state_flag_t flag)
+{
+    UNUSED_RETURN_VALUE(nrf_atomic_u32_or(&p_hid_ctx->state_flags, 1u << flag));
+}
+
+/**
+ * @brief Clear one of the HID internal state flags.
+ *
+ * @param[in] p_hid_ctx     Internal HID context.
+ * @param[in] flag          Flag to clear.
+ */
+static inline void app_usbd_hid_state_flag_clr(app_usbd_hid_ctx_t * p_hid_ctx,
+                                               app_usbd_hid_state_flag_t flag)
+{
+    UNUSED_RETURN_VALUE(nrf_atomic_u32_and(&p_hid_ctx->state_flags, ~(1u << flag)));
+}
+
+
+/**
+ * @brief Test one of the HID internal state flags.
+ *
+ * @param[in] p_hid_ctx     Internal HID context.
+ * @param[in] flag          Flag to test.
+ *
+ * @retval true  Flag is set.
+ * @retval false Flag is not set.
+ */
+static inline bool app_usbd_hid_state_flag_test(app_usbd_hid_ctx_t * p_hid_ctx,
+                                                app_usbd_hid_state_flag_t flag)
+{
+    return ((p_hid_ctx->state_flags >> flag) & 1) == 1;
+}
+
+/**
+ * @brief Checks whether HID endpoint transfer required.
+ *
+ * @param[in] p_hid_ctx     Internal HID context.
+ *
+ * @retval true  Input endpoint transfer required.
+ * @retval false Transfer in progress or not allowed.
+ */
+static inline bool app_usbd_hid_trans_required(app_usbd_hid_ctx_t * p_hid_ctx)
+{
+    if (app_usbd_hid_state_flag_test(p_hid_ctx, APP_USBD_HID_STATE_FLAG_SUSPENDED) != 0)
+    {
+        UNUSED_RETURN_VALUE(app_usbd_wakeup_req());
+        return false;
+    }
+
+    return app_usbd_hid_state_flag_test(p_hid_ctx, APP_USBD_HID_STATE_FLAG_TRANS_IN_PROGRESS) == 0;
+}
+
+/**
+ * @brief Validates internal hid state.
+ *
+ * HID Mouse has to receive some USBD events before functions from this module could be used.
+ *
+ * @param[in] p_hid_ctx Internal hid context.
+ *
+ * @retval true  State is valid.
+ * @retval false State is invalid.
+ */
+static inline bool app_usbd_hid_state_valid(app_usbd_hid_ctx_t * p_hid_ctx)
+{
+    /*Check whether internal flags allow to enable mouse*/
+    if ((app_usbd_hid_state_flag_test(p_hid_ctx, APP_USBD_HID_STATE_FLAG_APPENDED) == 0)  ||
+        (app_usbd_hid_state_flag_test(p_hid_ctx, APP_USBD_HID_STATE_FLAG_STARTED) == 0))
+    {
+        return false;
+    }
+
+    return true;
+}
+
+/**
+ * @brief HID generic event handler.
+ *
+ * This handler should process every class event after specific class handler.
+ * This approach allow to handle some events in the same way in all HID sub-classes.
+ *
+ * @param[in] p_inst        Generic class instance.
+ * @param[in] p_hinst       HID class instance.
+ * @param[in] p_hid_ctx     HID context.
+ * @param[in] p_event       Complex event structure.
+ *
+ * @return Standard error code.
+ */
+ret_code_t app_usbd_hid_event_handler(app_usbd_class_inst_t const * p_inst,
+                                      app_usbd_hid_inst_t const * p_hinst,
+                                      app_usbd_hid_ctx_t * p_hid_ctx,
+                                      app_usbd_complex_evt_t const * p_event);
+
+
+/**
+ * @brief Returns IN report buffer.
+ *
+ * @param[in] p_hinst       HID class instance.
+ *
+ * @return Report buffer handle or NULL if report doesn't exist.
+ */
+app_usbd_hid_report_buffer_t * app_usbd_hid_rep_buff_in_get(app_usbd_hid_inst_t const * p_hinst);
+
+/**
+ * @brief Returns OUT report buffer.
+ *
+ * Output reports are handled in interrupt handler so only one buffer is required. Buffer returned by
+ * this function has predefined size, which should be equal (maximum OUTPUT report size + 1). To receive
+ * OUT report this function should be called on @ref APP_USBD_HID_USER_EVT_OUT_REPORT_READY event.
+ *
+ * @param[in] p_hinst       HID class instance.
+ *
+ * @return Report buffer handle or NULL if report doesn't exist.
+ */
+static inline app_usbd_hid_report_buffer_t const *
+app_usbd_hid_rep_buff_out_get(app_usbd_hid_inst_t const * p_hinst)
+{
+    ASSERT(p_hinst);
+    return p_hinst->p_rep_buffer_out;
+}
+
+/**
+ * @brief Returns FEATURE report buffer.
+ *
+ * @param[in] p_hinst       HID class instance.
+ *
+ * @return Report buffer handle or NULL if report doesn't exist.
+ */
+app_usbd_hid_report_buffer_t const * app_usbd_hid_rep_buff_feature_get(app_usbd_hid_inst_t const * p_hinst);
+
+/**
+ * @brief Returns HID selected protocol.
+ *
+ * @param[in] p_hid_ctx     HID context.
+ *
+ * @return Currently selected protocol (@ref app_usbd_hid_protocol_select_t).
+ */
+static inline app_usbd_hid_protocol_select_t app_usbd_hid_selected_protocol_get(app_usbd_hid_ctx_t * p_hid_ctx)
+{
+    ASSERT(p_hid_ctx);
+    return p_hid_ctx->selected_protocol;
+}
+
+/**
+ * @brief Auxiliary function to access to HID IN endpoint address.
+ *
+ * @param[in] p_inst Class instance data.
+ *
+ * @return IN endpoint address.
+ */
+static inline nrf_drv_usbd_ep_t app_usbd_hid_epin_addr_get(app_usbd_class_inst_t const * p_inst)
+{
+    app_usbd_class_iface_conf_t const * class_iface;
+    class_iface = app_usbd_class_iface_get(p_inst, APP_USBD_HID_IFACE_IDX);
+
+    app_usbd_class_ep_conf_t const * ep_cfg;
+    ep_cfg = app_usbd_class_iface_ep_get(class_iface, APP_USBD_HID_EPIN_IDX);
+
+    return app_usbd_class_ep_address_get(ep_cfg);
+}
+
+/**
+ * @brief Auxiliary function to access to HID generic OUT endpoint address.
+ *
+ * @param[in] p_inst Class instance data.
+ *
+ * @return OUT endpoint address.
+ */
+static inline nrf_drv_usbd_ep_t  app_usbd_hid_epout_addr_get(app_usbd_class_inst_t const * p_inst)
+{
+    app_usbd_class_iface_conf_t const * class_iface;
+    class_iface = app_usbd_class_iface_get(p_inst, APP_USBD_HID_IFACE_IDX);
+
+    app_usbd_class_ep_conf_t const * ep_cfg;
+    ep_cfg = app_usbd_class_iface_ep_get(class_iface, APP_USBD_HID_EPOUT_IDX);
+
+    return app_usbd_class_ep_address_get(ep_cfg);
+}
+
+/** @} */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* APP_USBD_HID_H__ */

components/libraries/usbd/class/hid/app_usbd_hid_types.h

@@ -0,0 +1,298 @@
+/**
+ * Copyright (c) 2017 - 2020, 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.
+ *
+ */
+#ifndef APP_USBD_HID_TYPES_H__
+#define APP_USBD_HID_TYPES_H__
+
+#include <stdint.h>
+
+#include "app_usbd_types.h"
+#include "sdk_common.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @defgroup app_usbd_hid_types USB HID class types
+ * @ingroup app_usbd_hid
+ *
+ * @brief @tagAPI52840 Module with types and definitions used by HID modules.
+ * @{
+ */
+
+/**
+ * @brief HID class definition in interface descriptor.
+ *
+ * @ref app_usbd_descriptor_iface_t::bInterfaceClass
+ * */
+#define  APP_USBD_HID_CLASS 0x03
+
+/**
+ * @brief HID subclass definition.
+ *
+ * @see HID 1.11 specification: Chapter 4.2 Subclass.
+ * @ref app_usbd_descriptor_iface_t::bInterfaceSubClass
+ * */
+typedef enum {
+    APP_USBD_HID_SUBCLASS_NONE = 0x00, /**< Undefined subclass. */
+    APP_USBD_HID_SUBCLASS_BOOT = 0x01, /**< Boot subclass.      */
+} app_usbd_hid_subclass_t;
+
+/**
+ * @brief HID selected protocol.
+ *
+ * These values are used for Get_Protocol and Set_Protocol requests.
+ * Changing protocol is only allowed when protocol type (@ref app_usbd_hid_protocol_t)
+ * is set to @ref APP_USBD_HID_PROTO_KEYBOARD or @ref APP_USBD_HID_PROTO_MOUSE
+ * and interface uses boot subclass (@ref APP_USBD_HID_SUBCLASS_BOOT).
+ *
+ * @see HID 1.11 specification: Chapter 7.2.5 Get_Protocol Request
+ * and Chapter 7.2.6 Set_Protocol Request.
+ */
+typedef enum {
+    APP_USBD_HID_PROTO_BOOT   = 0x00, /**< Boot protocol.   */
+    APP_USBD_HID_PROTO_REPORT = 0x01  /**< Report protocol. */
+} app_usbd_hid_protocol_select_t; 
+
+
+/**
+ * @brief HID protocol types defined by specification.
+ *
+ * Value needs to be filled in interface descriptor.
+ * @ref app_usbd_descriptor_iface_t::bInterfaceProtocol
+ */
+typedef enum {
+    APP_USBD_HID_PROTO_GENERIC    = 0x00, /**< GENERIC protocol.    */
+    APP_USBD_HID_PROTO_KEYBOARD   = 0x01, /**< KEYBOARD protocol.   */
+    APP_USBD_HID_PROTO_MOUSE      = 0x02, /**< MOUSE protocol.      */
+    APP_USBD_HID_PROTO_MULTITOUCH = 0x03, /**< MULTITOUCH protocol. */
+} app_usbd_hid_protocol_t;
+
+
+/**
+ * @brief HID country code ID.
+ *
+ * Look into @ref app_usbd_hid_descriptor_t::bCountryCode.
+ */
+typedef enum {
+    APP_USBD_HID_COUNTRY_NOT_SUPPORTED     = 0 , /**< NOT_SUPPORTED        */
+    APP_USBD_HID_COUNTRY_ARABIC            = 1 , /**< ARABIC               */
+    APP_USBD_HID_COUNTRY_BELGIAN           = 2 , /**< BELGIAN              */
+    APP_USBD_HID_COUNTRY_CANADIAN_BILINGUAL= 3 , /**< CANADIAN_BILINGUAL   */
+    APP_USBD_HID_COUNTRY_CANADIAN_FRENCH   = 4 , /**< CANADIAN_FRENCH      */
+    APP_USBD_HID_COUNTRY_CZECH_REPUBLIC    = 5 , /**< CZECH_REPUBLIC       */
+    APP_USBD_HID_COUNTRY_DANISH            = 6 , /**< DANISH               */
+    APP_USBD_HID_COUNTRY_FINNISH           = 7 , /**< FINNISH              */
+    APP_USBD_HID_COUNTRY_FRENCH            = 8 , /**< FRENCH               */
+    APP_USBD_HID_COUNTRY_GERMAN            = 9 , /**< GERMAN               */
+    APP_USBD_HID_COUNTRY_GREEK             = 10, /**< GREEK                */
+    APP_USBD_HID_COUNTRY_HEBREW            = 11, /**< HEBREW               */
+    APP_USBD_HID_COUNTRY_HUNGARY           = 12, /**< HUNGARY              */
+    APP_USBD_HID_COUNTRY_INTERNATIONAL_ISO = 13, /**< INTERNATIONAL_ISO    */
+    APP_USBD_HID_COUNTRY_ITALIAN           = 14, /**< ITALIAN              */
+    APP_USBD_HID_COUNTRY_JAPAN_KATAKANA    = 15, /**< JAPAN_KATAKANA       */
+    APP_USBD_HID_COUNTRY_KOREAN            = 16, /**< KOREAN               */
+    APP_USBD_HID_COUNTRY_LATIN_AMERICAN    = 17, /**< LATIN_AMERICAN       */
+    APP_USBD_HID_COUNTRY_NETHERLANDS_DUTCH = 18, /**< NETHERLANDS_DUTCH    */
+    APP_USBD_HID_COUNTRY_NORWEGIAN         = 19, /**< NORWEGIAN            */
+    APP_USBD_HID_COUNTRY_PERSIAN_FARSI     = 20, /**< PERSIAN_FARSI        */
+    APP_USBD_HID_COUNTRY_POLAND            = 21, /**< POLAND               */
+    APP_USBD_HID_COUNTRY_PORTUGUESE        = 22, /**< PORTUGUESE           */
+    APP_USBD_HID_COUNTRY_RUSSIA            = 23, /**< RUSSIA               */
+    APP_USBD_HID_COUNTRY_SLOVAKIA          = 24, /**< SLOVAKIA             */
+    APP_USBD_HID_COUNTRY_SPANISH           = 25, /**< SPANISH              */
+    APP_USBD_HID_COUNTRY_SWEDISH           = 26, /**< SWEDISH              */
+    APP_USBD_HID_COUNTRY_SWISS_FRENCH      = 27, /**< SWISS_FRENCH         */
+    APP_USBD_HID_COUNTRY_SWISS_GERMAN      = 28, /**< SWISS_GERMAN         */
+    APP_USBD_HID_COUNTRY_SWITZERLAND       = 29, /**< SWITZERLAND          */
+    APP_USBD_HID_COUNTRY_TAIWAN            = 30, /**< TAIWAN               */
+    APP_USBD_HID_COUNTRY_TURKISH_Q         = 31, /**< TURKISH_Q            */
+    APP_USBD_HID_COUNTRY_UK                = 32, /**< UK                   */
+    APP_USBD_HID_COUNTRY_US                = 33, /**< US                   */
+    APP_USBD_HID_COUNTRY_YUGOSLAVIA        = 34, /**< YUGOSLAVIA           */
+    APP_USBD_HID_COUNTRY_TURKISH_F         = 35, /**< TURKISH_F            */
+} app_usbd_hid_country_code_t;
+
+/**
+ * @brief HID descriptor types.
+ *
+ * @ref app_usbd_hid_descriptor_t::bRDescriptorType
+ */
+typedef enum {
+    APP_USBD_HID_DESCRIPTOR_HID      = 0x21, /**< HID descriptor.      */
+    APP_USBD_HID_DESCRIPTOR_REPORT   = 0x22, /**< REPORT descriptor.   */
+    APP_USBD_HID_DESCRIPTOR_PHYSICAL = 0x23, /**< PHYSICAL descriptor. */
+} app_usbd_hid_descriptor_type_t;
+
+#pragma pack(push, 1)
+
+/**
+ * @brief HID report descriptor entry at the end of HID descriptor.
+ *
+ * @param size     Report descriptor size.
+ */
+#define APP_USBD_HID_REPORT_ITEM(size)      \
+    APP_USBD_HID_DESCRIPTOR_REPORT, ((size) & 0xFF), ((size) / 256)
+
+
+/**
+ * @brief HID physical descriptor entry at the end of HID descriptor.
+ *
+ * @param size     Physical descriptor size.
+ */
+#define APP_USBD_HID_PHYSICAL_ITEM(size)    \
+    APP_USBD_HID_DESCRIPTOR_PHYSICAL, ((size) & 0xFF), ((size) / 256)
+
+
+/**
+ * @brief HID descriptor, binary layout.
+ */
+typedef union {
+    struct  {
+        uint8_t  bLength;            //!< Length of descriptor.
+        uint8_t  bDescriptorType;    //!< Descriptor type @ref APP_USBD_HID_DESCRIPTOR_HID.
+        uint16_t bcdHID;             //!< HID release number (BCD format, little endian).
+        uint8_t  bCountryCode;       //!< Country code.
+        uint8_t  bNumDescriptors;    //!< Number of class descriptors.
+        struct {
+            uint8_t  bRDescriptorType;   //!< Class descriptor type.
+            uint16_t wDescriptorLength;  //!< Class descriptor length (little endian).
+        } reports[];
+    } raw;
+} app_usbd_hid_descriptor_t;
+
+#pragma pack(pop)
+
+
+/**
+ * @brief HID requests defined by specification.
+ */
+typedef enum {
+    APP_USBD_HID_REQ_GET_REPORT   = 0x01, /**< REPORT: device -> host (required).                     */
+    APP_USBD_HID_REQ_GET_IDLE     = 0x02, /**< IDLE: device -> host (not required).                   */
+    APP_USBD_HID_REQ_GET_PROTOCOL = 0x03, /**< PROTOCOL: device -> host (required for boot protocol). */
+    APP_USBD_HID_REQ_SET_REPORT   = 0x09, /**< REPORT: host -> device (not required).                 */
+    APP_USBD_HID_REQ_SET_IDLE     = 0x0A, /**< IDLE: no data stage (required for boot protocol).      */
+    APP_USBD_HID_REQ_SET_PROTOCOL = 0x0B, /**< PROTOCOL: no data stage (required for boot protocol).  */
+} app_usbd_hid_req_t;
+
+/**
+ *  @brief HID report type.
+ */
+typedef enum {
+    APP_USBD_HID_REPORT_TYPE_INPUT   = 0x01, /**< INPUT report type   */
+    APP_USBD_HID_REPORT_TYPE_OUTPUT  = 0x02, /**< OUTPUT report type  */
+    APP_USBD_HID_REPORT_TYPE_FEATURE = 0x03, /**< FEATURE report type */
+} app_usbd_hid_report_type_t;
+
+
+/**
+ * @brief Hid version BCD value definition.
+ *
+ * The version of the HID descriptors used.
+ */
+#define APP_USBD_HID_BCD_VER APP_USBD_BCD_VER_MAKE(1, 1, 1)
+
+/**
+ * @brief HID version BCD value definition distributed into bytes.
+ *
+ * This is a value written directly into @ref app_usbd_hid_descriptor_t::bcdHID.
+ * @sa APP_USBD_HID_BCD_VER
+ */
+#define APP_USBD_HID_BCD_VER_BYTES LSB_16(APP_USBD_HID_BCD_VER), MSB_16(APP_USBD_HID_BCD_VER)
+
+/**
+ * @brief Initializer of interface descriptor for HID classes.
+ *
+ * @param interface_number  Interface number.
+ * @param endpoints_num     Number of endpoints.
+ * @param subclass          Subclass type @ref app_usbd_hid_subclass_t.
+ * @param protocol          Protocol type @ref app_usbd_hid_protocol_t.
+ */
+#define APP_USBD_HID_INTERFACE_DSC(interface_number, endpoints_num, subclass, protocol) \
+    /*.bLength =            */ sizeof(app_usbd_descriptor_iface_t),                     \
+    /*.bDescriptorType =    */ APP_USBD_DESCRIPTOR_INTERFACE,                           \
+    /*.bInterfaceNumber =   */ interface_number,                                        \
+    /*.bAlternateSetting =  */ 0x00,                                                    \
+    /*.bNumEndpoints =      */ endpoints_num,                                           \
+    /*.bInterfaceClass =    */ APP_USBD_HID_CLASS,                                      \
+    /*.bInterfaceSubClass = */ subclass,                                                \
+    /*.bInterfaceProtocol = */ protocol,                                                \
+    /*.iInterface = 0,      */ 0x00,                                                    \
+
+
+/**
+ * @brief Initializer of HID descriptor for HID classes.
+ *
+ * @param ...   Report/physical item list.
+ */
+#define APP_USBD_HID_HID_DSC(...)                                                                  \
+    /*.bLength =           */ sizeof(app_usbd_hid_descriptor_t) + 3 * (NUM_VA_ARGS(__VA_ARGS__)),  \
+    /*.bDescriptorType =   */ APP_USBD_HID_DESCRIPTOR_HID,                                         \
+    /*.bcdHID =            */ APP_USBD_HID_BCD_VER_BYTES,                                          \
+    /*.bCountryCode =      */ APP_USBD_HID_COUNTRY_NOT_SUPPORTED,                                  \
+    /*.bNumDescriptors =   */ (NUM_VA_ARGS(__VA_ARGS__)),                                          \
+    /*.bRDescriptorType =  */ APP_USBD_HID_REPORT_ITEM(sizeof(GET_VA_ARG_1_(__VA_ARGS__))),        \
+    /*.wDescriptorLength = */
+
+/**
+ * @brief Initializer of endpoint descriptor for HID classes.
+ *
+ * @param endpoint      Endpoint number.
+ * @param ep_size       Endpoint size.
+ * @param ep_interval   Endpoint interval (milliseconds).
+ */
+#define APP_USBD_HID_EP_DSC(endpoint, ep_size, ep_interval)                \
+    /*.bLength =          */ sizeof(app_usbd_descriptor_ep_t),             \
+    /*.bDescriptorType =  */ APP_USBD_DESCRIPTOR_ENDPOINT,                 \
+    /*.bEndpointAddress = */ endpoint,                                     \
+    /*.bmAttributes =     */ APP_USBD_DESCRIPTOR_EP_ATTR_TYPE_INTERRUPT,   \
+    /*.wMaxPacketSize =   */ APP_USBD_U16_TO_RAW_DSC(ep_size),             \
+    /*.bInterval =        */ ep_interval,                                  \
+
+
+
+/** @} */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* APP_USBD_HID_TYPES_H__ */

components/libraries/usbd/class/hid/generic/app_usbd_hid_generic.c

@@ -0,0 +1,659 @@
+/**
+ * Copyright (c) 2016 - 2020, 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 "sdk_common.h"
+#if NRF_MODULE_ENABLED(APP_USBD_HID_GENERIC)
+
+#include <string.h>
+#include "app_usbd_hid_generic.h"
+#include "app_util_platform.h"
+
+
+/**
+ * @ingroup app_usbd_hid_generic
+ *
+ * Module with types, definitions and API used by HID generic.
+ * @{
+ */
+
+/**
+ * @brief Auxiliary function to access HID generic context data.
+ *
+ * @param[in] p_generic HID generic instance.
+ *
+ * @return HID generic class instance data context.
+ */
+static inline app_usbd_hid_generic_ctx_t *
+hid_generic_ctx_get(app_usbd_hid_generic_t const * p_generic)
+{
+    ASSERT(p_generic != NULL);
+    ASSERT(p_generic->specific.p_data != NULL);
+    return &p_generic->specific.p_data->ctx;
+}
+
+
+/**
+ * @brief Auxiliary function to access HID generic instance data.
+ *
+ * @param[in] p_inst Class instance data.
+ *
+ * @return HID generic class instance data.
+ */
+static inline app_usbd_hid_generic_t const *
+hid_generic_get(app_usbd_class_inst_t const * p_inst)
+{
+    ASSERT(p_inst != NULL);
+    return (app_usbd_hid_generic_t const *)p_inst;
+}
+
+
+/**
+ * @brief Returns report ID buffer descriptor.
+ *
+ * @param[in] p_generic Internal HID generic context.
+ *
+ * @return HID report buffer.
+ */
+static inline app_usbd_hid_report_buffer_t *
+hid_generic_rep_buffer_get(app_usbd_hid_generic_t const * p_generic)
+{
+    ASSERT(p_generic != NULL);
+    app_usbd_hid_inst_t const * p_hinst = &p_generic->specific.inst.hid_inst;
+
+    return app_usbd_hid_rep_buff_in_get(p_hinst);
+}
+
+
+/**
+ * @brief Auxiliary function to prepare report transfer buffer to next transfer.
+ *
+ * @param[in] p_generic HID generic instance.
+ *
+ * @retval true  Next transfer required.
+ * @retval false Next transfer not required.
+ */
+static inline bool hid_generic_transfer_next(app_usbd_hid_generic_t const * p_generic)
+{
+    nrf_queue_t const * p_rep_in_queue = p_generic->specific.inst.p_rep_in_queue;
+
+    return !nrf_queue_is_empty(p_rep_in_queue);
+}
+
+
+/**
+ * @brief Triggers IN endpoint transfer.
+ *
+ * @param[in] p_generic HID generic instance.
+ *
+ * @return Standard error code.
+ */
+static inline ret_code_t hid_generic_transfer_set(app_usbd_hid_generic_t const * p_generic)
+{
+    app_usbd_class_inst_t const * p_inst        = (app_usbd_class_inst_t const *)p_generic;
+    app_usbd_hid_generic_ctx_t  * p_generic_ctx = hid_generic_ctx_get(p_generic);
+
+    nrf_drv_usbd_ep_t ep_addr = app_usbd_hid_epin_addr_get(p_inst);
+
+    app_usbd_hid_state_flag_clr(&p_generic_ctx->hid_ctx,
+                                APP_USBD_HID_STATE_FLAG_TRANS_IN_PROGRESS);
+
+    if (!hid_generic_transfer_next(p_generic))
+    {
+        return NRF_SUCCESS;
+    }
+
+    app_usbd_hid_report_buffer_t * p_rep_buff     = hid_generic_rep_buffer_get(p_generic);
+    nrf_queue_t const            * p_rep_in_queue = p_generic->specific.inst.p_rep_in_queue;
+
+    ret_code_t ret = nrf_queue_pop(p_rep_in_queue, p_rep_buff);
+    ASSERT(ret == NRF_SUCCESS);
+
+    NRF_DRV_USBD_TRANSFER_IN(transfer, p_rep_buff->p_buff, p_rep_buff->size);
+    CRITICAL_REGION_ENTER();
+    ret = app_usbd_ep_transfer(ep_addr, &transfer);
+    if (ret == NRF_SUCCESS)
+    {
+        app_usbd_hid_state_flag_set(&p_generic_ctx->hid_ctx,
+                                    APP_USBD_HID_STATE_FLAG_TRANS_IN_PROGRESS);
+    }
+    CRITICAL_REGION_EXIT();
+
+    return ret;
+}
+
+ret_code_t hid_generic_clear_buffer(app_usbd_class_inst_t const * p_inst)
+{
+    ASSERT(p_inst != NULL);
+
+    app_usbd_hid_generic_t const *        p_generic        = hid_generic_get(p_inst);
+    app_usbd_hid_generic_ctx_t *          p_generic_ctx    = hid_generic_ctx_get(p_generic);
+    app_usbd_hid_report_buffer_t       *  p_rep_buffer     = hid_generic_rep_buffer_get(p_generic);
+    nrf_queue_t const                  *  p_rep_in_queue   = p_generic->specific.inst.p_rep_in_queue;
+    ret_code_t ret = NRF_SUCCESS;
+
+    /* Clear all queued reports */
+    while(ret != NRF_ERROR_NOT_FOUND)
+    {
+        ret = nrf_queue_pop(p_rep_in_queue, p_rep_buffer);
+    }
+
+    CRITICAL_REGION_ENTER();
+    uint8_t iface_count = app_usbd_class_iface_count_get(p_inst);
+
+    app_usbd_class_iface_conf_t const * p_iface = NULL;
+    for (uint8_t i = 0; i < iface_count; ++i)
+    {
+        p_iface = app_usbd_class_iface_get(p_inst, i);
+
+        uint8_t ep_count = app_usbd_class_iface_ep_count_get(p_iface);
+
+        for (uint8_t j = 0; j < ep_count; ++j)
+        {
+            /*Abort transfer on every IN endpoint*/
+            app_usbd_class_ep_conf_t const * p_ep = app_usbd_class_iface_ep_get(p_iface, j);
+
+            ASSERT(!NRF_USBD_EPISO_CHECK(p_ep->address));
+
+            if (NRF_USBD_EPIN_CHECK(p_ep->address))
+            {
+                nrf_drv_usbd_ep_abort(p_ep->address);
+            }
+
+        }
+    }
+
+    app_usbd_hid_state_flag_clr(&p_generic_ctx->hid_ctx, APP_USBD_HID_STATE_FLAG_TRANS_IN_PROGRESS);
+    CRITICAL_REGION_EXIT();
+
+    return ret;
+}
+
+
+ret_code_t app_usbd_hid_generic_in_report_set(app_usbd_hid_generic_t const * p_generic,
+                                              const void                   * p_buff,
+                                              size_t                         size)
+{
+    app_usbd_hid_generic_ctx_t       * p_generic_ctx  = hid_generic_ctx_get(p_generic);
+    nrf_queue_t const                * p_rep_in_queue = p_generic->specific.inst.p_rep_in_queue;
+    const app_usbd_hid_report_buffer_t rep_buff       = {
+        .p_buff = (void *)p_buff,
+        .size   = size,
+    };
+
+    if (nrf_queue_push(p_rep_in_queue, &rep_buff) != NRF_SUCCESS)
+    {
+        return NRF_ERROR_BUSY;
+    }
+
+    ret_code_t ret = NRF_SUCCESS;
+    if (app_usbd_hid_trans_required(&p_generic_ctx->hid_ctx) && 
+        !p_generic_ctx->hid_ctx.idle_on)
+    {
+        ret = hid_generic_transfer_set(p_generic);
+    }
+
+    return ret;
+}
+
+ret_code_t app_usbd_hid_generic_idle_report_set(app_usbd_hid_generic_t const * p_generic,
+                                                const void                   * p_buff,
+                                                size_t                         size)
+{
+    app_usbd_class_inst_t const  * p_inst        = (app_usbd_class_inst_t const *)p_generic;
+    app_usbd_hid_generic_ctx_t   * p_generic_ctx = hid_generic_ctx_get(p_generic);
+    ret_code_t ret;
+    nrf_drv_usbd_ep_t ep_addr = app_usbd_hid_epin_addr_get(p_inst);
+
+    app_usbd_hid_state_flag_clr(&p_generic_ctx->hid_ctx,
+                                APP_USBD_HID_STATE_FLAG_TRANS_IN_PROGRESS);
+
+    NRF_DRV_USBD_TRANSFER_IN(transfer, p_buff, size);
+
+    CRITICAL_REGION_ENTER();
+    ret = app_usbd_ep_transfer(ep_addr, &transfer);
+    if (ret == NRF_SUCCESS)
+    {
+        app_usbd_hid_state_flag_set(&p_generic_ctx->hid_ctx,
+                                    APP_USBD_HID_STATE_FLAG_TRANS_IN_PROGRESS);
+    }
+    CRITICAL_REGION_EXIT();
+
+    return ret;
+}
+
+
+const void * app_usbd_hid_generic_in_report_get(app_usbd_hid_generic_t const * p_generic,
+                                                size_t                       * p_size)
+{
+    app_usbd_hid_inst_t const * p_hinst = &p_generic->specific.inst.hid_inst;
+
+    *p_size = p_hinst->p_rep_buffer_in->size;
+    return p_hinst->p_rep_buffer_in->p_buff;
+}
+
+
+const void * app_usbd_hid_generic_out_report_get(app_usbd_hid_generic_t const * p_generic,
+                                                 size_t                       * p_size)
+{
+    app_usbd_hid_inst_t const * p_hinst = &p_generic->specific.inst.hid_inst;
+
+    *p_size = p_hinst->p_rep_buffer_out->size;
+    return p_hinst->p_rep_buffer_out->p_buff;
+}
+
+const void * app_usbd_hid_generic_feature_report_get(app_usbd_hid_generic_t const * p_generic,
+                                                     size_t                       * p_size)
+{
+    app_usbd_hid_inst_t const * p_hinst = &p_generic->specific.inst.hid_inst;
+
+    *p_size = p_hinst->p_rep_buffer_feature->size;
+    return p_hinst->p_rep_buffer_feature->p_buff;
+}
+
+/**
+ * @brief @ref app_usbd_hid_interface_t::on_get_report
+ */
+static ret_code_t hid_generic_on_get_report(app_usbd_class_inst_t const * p_inst,
+                                            app_usbd_setup_evt_t const  * p_setup_ev)
+{
+    app_usbd_hid_generic_t const * p_hinst = hid_generic_get(p_inst);
+    uint8_t const * p_rep_buffer = NULL;
+    size_t buffer_size = 0;
+
+    if (p_setup_ev->setup.wValue.hb == APP_USBD_HID_REPORT_TYPE_INPUT)
+    {
+        p_rep_buffer = app_usbd_hid_generic_in_report_get(p_hinst, &buffer_size);
+    }
+    else if (p_setup_ev->setup.wValue.hb == APP_USBD_HID_REPORT_TYPE_OUTPUT)
+    {
+        p_rep_buffer = app_usbd_hid_generic_out_report_get(p_hinst, &buffer_size);
+    }
+    else if (p_setup_ev->setup.wValue.hb == APP_USBD_HID_REPORT_TYPE_FEATURE)
+    {
+        p_rep_buffer = app_usbd_hid_generic_feature_report_get(p_hinst, &buffer_size);
+    }
+    else
+    {
+        return NRF_ERROR_NOT_SUPPORTED;
+    }
+
+    return app_usbd_core_setup_rsp(&(p_setup_ev->setup), p_rep_buffer, buffer_size);
+}
+
+
+static ret_code_t hid_generic_on_set_report_data_cb(nrf_drv_usbd_ep_status_t status,
+                                                    void                   * p_context)
+{
+    app_usbd_hid_user_ev_handler_t handler;
+    app_usbd_hid_generic_t const * p_generic = (app_usbd_hid_generic_t const *)p_context;
+
+    if (status != NRF_USBD_EP_OK)
+    {
+        return NRF_ERROR_INTERNAL;
+    }
+
+    handler = p_generic->specific.inst.hid_inst.user_event_handler;
+    handler((app_usbd_class_inst_t const *)p_generic,
+            APP_USBD_HID_USER_EVT_OUT_REPORT_READY);
+    return NRF_SUCCESS;
+}
+
+static ret_code_t hid_generic_on_set_report_feature_data_cb(nrf_drv_usbd_ep_status_t status,
+                                                            void                   * p_context)
+{
+    app_usbd_hid_user_ev_handler_t handler;
+    app_usbd_hid_generic_t const * p_generic = (app_usbd_hid_generic_t const *)p_context;
+
+    if (status != NRF_USBD_EP_OK)
+    {
+        return NRF_ERROR_INTERNAL;
+    }
+
+    handler = p_generic->specific.inst.hid_inst.user_event_handler;
+    handler((app_usbd_class_inst_t const *)p_generic,
+            APP_USBD_HID_USER_EVT_FEATURE_REPORT_READY);
+    return NRF_SUCCESS;
+}
+
+/**
+ * @brief @ref app_usbd_hid_interface_t::on_set_report
+ */
+static ret_code_t hid_generic_on_set_report(app_usbd_class_inst_t const * p_inst,
+                                            app_usbd_setup_evt_t const  * p_setup_ev)
+{
+    if (p_setup_ev->setup.wValue.hb == APP_USBD_HID_REPORT_TYPE_OUTPUT)
+    {
+        app_usbd_hid_generic_t const * p_generic = hid_generic_get(p_inst);
+
+        /*Request setup data*/
+        app_usbd_hid_report_buffer_t const * p_rep_buff;
+
+        p_rep_buff = app_usbd_hid_rep_buff_out_get(&p_generic->specific.inst.hid_inst);
+
+        p_rep_buff->p_buff[0] = p_setup_ev->setup.wValue.lb;
+        NRF_DRV_USBD_TRANSFER_OUT(transfer, p_rep_buff->p_buff + 1, p_rep_buff->size - 1);
+
+        ret_code_t ret;
+        CRITICAL_REGION_ENTER();
+        ret = app_usbd_ep_transfer(NRF_DRV_USBD_EPOUT0, &transfer);
+        if (ret == NRF_SUCCESS)
+        {
+            app_usbd_core_setup_data_handler_desc_t desc = {
+                .handler   = hid_generic_on_set_report_data_cb,
+                .p_context = (void *)p_generic
+            };
+
+            ret = app_usbd_core_setup_data_handler_set(NRF_DRV_USBD_EPOUT0, &desc);
+        }
+        CRITICAL_REGION_EXIT();
+        return ret;
+
+     }
+    else if (p_setup_ev->setup.wValue.hb == APP_USBD_HID_REPORT_TYPE_FEATURE)
+    {
+         app_usbd_hid_generic_t const * p_generic = hid_generic_get(p_inst);
+
+        /*Request setup data*/
+        app_usbd_hid_report_buffer_t const * p_rep_buff;
+
+        p_rep_buff = app_usbd_hid_rep_buff_feature_get(&p_generic->specific.inst.hid_inst);
+
+        NRF_DRV_USBD_TRANSFER_OUT(transfer, p_rep_buff->p_buff, p_rep_buff->size);
+
+        ret_code_t ret;
+        CRITICAL_REGION_ENTER();
+        ret = app_usbd_ep_transfer(NRF_DRV_USBD_EPOUT0, &transfer);
+        if (ret == NRF_SUCCESS)
+        {
+            app_usbd_core_setup_data_handler_desc_t desc = {
+                .handler   = hid_generic_on_set_report_feature_data_cb,
+                .p_context = (void *)p_generic
+            };
+
+            ret = app_usbd_core_setup_data_handler_set(NRF_DRV_USBD_EPOUT0, &desc);
+        }
+        CRITICAL_REGION_EXIT();
+        return ret;
+    }
+    return NRF_ERROR_NOT_SUPPORTED;
+}
+
+
+/**
+ * @brief @ref app_usbd_hid_interface_t::ep_transfer_in
+ */
+static ret_code_t hid_generic_ep_transfer_in(app_usbd_class_inst_t const * p_inst)
+{
+    app_usbd_hid_generic_t const * p_generic     = hid_generic_get(p_inst);
+    app_usbd_hid_generic_ctx_t   * p_generic_ctx = hid_generic_ctx_get(p_generic);
+
+    nrf_queue_t const * p_rep_in_queue = p_generic->specific.inst.p_rep_in_queue;
+
+    if (nrf_queue_is_empty(p_rep_in_queue))
+    {
+        app_usbd_hid_state_flag_clr(&p_generic_ctx->hid_ctx,
+                                    APP_USBD_HID_STATE_FLAG_TRANS_IN_PROGRESS);
+        return NRF_SUCCESS;
+    }
+
+    /* Get next report to send */
+    return hid_generic_transfer_set((app_usbd_hid_generic_t const *)p_inst);
+}
+
+
+/**
+ * @brief @ref app_usbd_hid_interface_t::ep_transfer_out
+ */
+static ret_code_t hid_generic_ep_transfer_out(app_usbd_class_inst_t const * p_inst)
+{
+
+    app_usbd_hid_generic_t const * p_generic = hid_generic_get(p_inst);
+    nrf_drv_usbd_ep_t              ep_addr   = app_usbd_hid_epout_addr_get(p_inst);
+
+    /*Request setup data*/
+    app_usbd_hid_report_buffer_t const * p_rep_buff;
+
+    p_rep_buff = app_usbd_hid_rep_buff_out_get(&p_generic->specific.inst.hid_inst);
+    NRF_DRV_USBD_TRANSFER_OUT(transfer, p_rep_buff->p_buff, p_rep_buff->size);
+
+    return app_usbd_ep_transfer(ep_addr, &transfer);
+}
+
+
+/**
+ * @brief @ref app_usbd_class_interface_t::event_handler
+ */
+static ret_code_t hid_generic_event_handler(app_usbd_class_inst_t const  * p_inst,
+                                            app_usbd_complex_evt_t const * p_event)
+{
+    ASSERT(p_inst != NULL);
+    ASSERT(p_event != NULL);
+
+    app_usbd_hid_generic_t const * p_generic     = hid_generic_get(p_inst);
+    app_usbd_hid_inst_t const    * p_hinst       = &p_generic->specific.inst.hid_inst;
+    app_usbd_hid_generic_ctx_t   * p_generic_ctx = hid_generic_ctx_get(p_generic);
+    app_usbd_hid_ctx_t           * p_hid_ctx     = &p_generic_ctx->hid_ctx;
+
+    /*Try handle event by generic HID event handler*/
+    return app_usbd_hid_event_handler(p_inst, p_hinst, p_hid_ctx, p_event);
+}
+
+
+static uint8_t hid_generic_get_class_descriptors_count(app_usbd_class_inst_t const * p_inst)
+{
+    app_usbd_hid_generic_t const * p_generic = hid_generic_get(p_inst);
+    app_usbd_hid_inst_t const    * p_hinst   = &p_generic->specific.inst.hid_inst;
+
+    return p_hinst->subclass_desc_count;
+}
+
+
+static app_usbd_descriptor_t hid_generic_get_class_descriptors_type(
+    app_usbd_class_inst_t const * p_inst,
+    uint8_t                       desc_num)
+{
+    app_usbd_hid_generic_t const * p_generic = hid_generic_get(p_inst);
+    app_usbd_hid_inst_t const    * p_hinst   = &p_generic->specific.inst.hid_inst;
+
+    return p_hinst->p_subclass_desc[desc_num]->type;
+}
+
+static size_t hid_generic_get_class_descriptors_length(app_usbd_class_inst_t const * p_inst,
+                                                       uint8_t                       desc_num)
+{
+    app_usbd_hid_generic_t const * p_generic = hid_generic_get(p_inst);
+    app_usbd_hid_inst_t const    * p_hinst   = &p_generic->specific.inst.hid_inst;
+
+    return p_hinst->p_subclass_desc[desc_num]->size;
+}
+
+
+static const uint8_t * hid_generic_get_class_descriptors_data(app_usbd_class_inst_t const * p_inst,
+                                                              uint8_t                       desc_num,
+                                                              uint32_t                      cur_byte)
+{
+    app_usbd_hid_generic_t const * p_generic = hid_generic_get(p_inst);
+    app_usbd_hid_inst_t const    * p_hinst   = &p_generic->specific.inst.hid_inst;
+    const uint8_t * p_byte = &p_hinst->p_subclass_desc[desc_num]->p_data[cur_byte];
+
+    return p_byte;
+}
+
+
+/**
+ * @brief @ref app_usbd_class_interface_t::feed_descriptors
+ */
+static bool hid_generic_feed_descriptors(app_usbd_class_descriptor_ctx_t  * p_ctx,
+                                         app_usbd_class_inst_t const      * p_inst,
+                                         uint8_t                          * p_buff,
+                                         size_t                             max_size)
+{
+    static uint8_t ifaces   = 0;
+    ifaces = app_usbd_class_iface_count_get(p_inst);
+    app_usbd_hid_generic_t const * p_generic = hid_generic_get(p_inst);
+
+    APP_USBD_CLASS_DESCRIPTOR_BEGIN(p_ctx, p_buff, max_size);
+
+    static uint8_t i = 0;
+
+    for (i = 0; i < ifaces; i++)
+    {
+        /* INTERFACE DESCRIPTOR */
+        APP_USBD_CLASS_DESCRIPTOR_WRITE(0x09); // bLength
+        APP_USBD_CLASS_DESCRIPTOR_WRITE(APP_USBD_DESCRIPTOR_INTERFACE); // bDescriptorType = Interface
+
+        static app_usbd_class_iface_conf_t const * p_cur_iface = NULL;
+        p_cur_iface = app_usbd_class_iface_get(p_inst, i);
+        APP_USBD_CLASS_DESCRIPTOR_WRITE(app_usbd_class_iface_number_get(p_cur_iface)); // bInterfaceNumber
+
+        APP_USBD_CLASS_DESCRIPTOR_WRITE(0x00); // bAlternateSetting
+        APP_USBD_CLASS_DESCRIPTOR_WRITE(app_usbd_class_iface_ep_count_get(p_cur_iface)); // bNumEndpoints
+        APP_USBD_CLASS_DESCRIPTOR_WRITE(APP_USBD_HID_CLASS); // bInterfaceClass = HID
+        APP_USBD_CLASS_DESCRIPTOR_WRITE(p_generic->specific.inst.hid_inst.subclass_boot); // bInterfaceSubclass (Boot Interface)
+        APP_USBD_CLASS_DESCRIPTOR_WRITE(p_generic->specific.inst.hid_inst.protocol); // bInterfaceProtocol
+        APP_USBD_CLASS_DESCRIPTOR_WRITE(0x00); // iInterface
+
+        /* HID DESCRIPTOR */
+        APP_USBD_CLASS_DESCRIPTOR_WRITE(0x09); // bLength
+        APP_USBD_CLASS_DESCRIPTOR_WRITE(APP_USBD_HID_DESCRIPTOR_HID);  // bDescriptorType = HID
+        APP_USBD_CLASS_DESCRIPTOR_WRITE(LSB_16(APP_USBD_HID_BCD_VER)); // bcdHID LSB
+        APP_USBD_CLASS_DESCRIPTOR_WRITE(MSB_16(APP_USBD_HID_BCD_VER)); // bcdHID MSB
+        APP_USBD_CLASS_DESCRIPTOR_WRITE(APP_USBD_HID_COUNTRY_NOT_SUPPORTED); // bCountryCode
+        APP_USBD_CLASS_DESCRIPTOR_WRITE(hid_generic_get_class_descriptors_count(p_inst)); // bNumDescriptors
+
+        static uint8_t class_desc_cnt = 0;
+        class_desc_cnt = hid_generic_get_class_descriptors_count(p_inst);
+        static uint8_t  j              = 0;
+        static uint16_t class_desc_len = 0;
+
+        for (j = 0; j < class_desc_cnt; j++)
+        {
+            APP_USBD_CLASS_DESCRIPTOR_WRITE(hid_generic_get_class_descriptors_type(p_inst, j)); // bDescriptorType
+
+            class_desc_len = hid_generic_get_class_descriptors_length(p_inst, j);
+            APP_USBD_CLASS_DESCRIPTOR_WRITE(LSB_16(class_desc_len)); // wDescriptorLength LSB
+            APP_USBD_CLASS_DESCRIPTOR_WRITE(MSB_16(class_desc_len)); // wDescriptorLength MSB
+        }
+
+        static uint8_t endpoints = 0;
+        endpoints = app_usbd_class_iface_ep_count_get(p_cur_iface);
+
+        for (j = 0; j < endpoints; j++)
+        {
+            /* ENDPOINT DESCRIPTOR */
+            APP_USBD_CLASS_DESCRIPTOR_WRITE(0x07); // bLength
+            APP_USBD_CLASS_DESCRIPTOR_WRITE(APP_USBD_DESCRIPTOR_ENDPOINT); // bDescriptorType = Endpoint
+
+            static app_usbd_class_ep_conf_t const * p_cur_ep = NULL;
+            p_cur_ep = app_usbd_class_iface_ep_get(p_cur_iface, j);
+            APP_USBD_CLASS_DESCRIPTOR_WRITE(app_usbd_class_ep_address_get(p_cur_ep)); // bEndpointAddress
+            APP_USBD_CLASS_DESCRIPTOR_WRITE(APP_USBD_DESCRIPTOR_EP_ATTR_TYPE_INTERRUPT); // bmAttributes
+            APP_USBD_CLASS_DESCRIPTOR_WRITE(LSB_16(NRF_DRV_USBD_EPSIZE)); // wMaxPacketSize LSB
+            APP_USBD_CLASS_DESCRIPTOR_WRITE(MSB_16(NRF_DRV_USBD_EPSIZE)); // wMaxPacketSize MSB
+            APP_USBD_CLASS_DESCRIPTOR_WRITE(p_generic->specific.inst.hid_inst.p_ep_interval[j]); // bInterval
+        }
+    }
+
+    APP_USBD_CLASS_DESCRIPTOR_END();
+}
+
+ret_code_t hid_generic_on_set_protocol(app_usbd_hid_generic_t const * p_generic, app_usbd_hid_user_event_t ev)
+{
+    app_usbd_hid_generic_ctx_t * p_generic_ctx = hid_generic_ctx_get(p_generic);
+    if (ev == APP_USBD_HID_USER_EVT_SET_BOOT_PROTO)
+    {
+        p_generic_ctx->hid_ctx.selected_protocol = APP_USBD_HID_PROTO_BOOT;
+    }
+    else if (ev == APP_USBD_HID_USER_EVT_SET_REPORT_PROTO)
+    {
+        p_generic_ctx->hid_ctx.selected_protocol = APP_USBD_HID_PROTO_REPORT;
+    }
+    else
+    {
+        return NRF_ERROR_NOT_SUPPORTED;
+    }
+    return NRF_SUCCESS;
+}
+
+ret_code_t hid_generic_idle_handler_set(app_usbd_class_inst_t const * p_inst,
+                                        app_usbd_hid_idle_handler_t handler)
+{
+    ASSERT(handler != NULL);
+    app_usbd_hid_generic_t const * p_generic = hid_generic_get(p_inst);
+    app_usbd_hid_generic_ctx_t   * p_generic_ctx = hid_generic_ctx_get(p_generic);
+
+    p_generic_ctx->hid_ctx.idle_handler = handler;
+    return NRF_SUCCESS;
+}
+
+static ret_code_t hid_generic_on_idle(app_usbd_class_inst_t const * p_inst, uint8_t report_id)
+{
+    app_usbd_hid_generic_t const * p_generic = hid_generic_get(p_inst);
+    app_usbd_hid_generic_ctx_t   * p_generic_ctx = hid_generic_ctx_get(p_generic);
+    
+    if(p_generic_ctx->hid_ctx.idle_handler != NULL)
+    {
+        return p_generic_ctx->hid_ctx.idle_handler(p_inst, report_id);
+    }
+    else
+    {
+        return NRF_ERROR_NOT_SUPPORTED;
+    }
+}
+
+/** @} */
+
+const app_usbd_hid_methods_t app_usbd_hid_generic_methods = {
+    .on_get_report              = hid_generic_on_get_report,
+    .on_set_report              = hid_generic_on_set_report,
+    .ep_transfer_in             = hid_generic_ep_transfer_in,
+    .ep_transfer_out            = hid_generic_ep_transfer_out,
+    .subclass_count             = hid_generic_get_class_descriptors_count,
+    .subclass_length            = hid_generic_get_class_descriptors_length,
+    .subclass_data              = hid_generic_get_class_descriptors_data,
+    .on_idle                    = hid_generic_on_idle,
+    .set_idle_handler           = hid_generic_idle_handler_set,
+};
+
+const app_usbd_class_methods_t app_usbd_generic_class_methods = {
+    .event_handler            = hid_generic_event_handler,
+    .feed_descriptors         = hid_generic_feed_descriptors,
+};
+
+#endif //NRF_MODULE_ENABLED(APP_USBD_HID_GENERIC)

components/libraries/usbd/class/hid/generic/app_usbd_hid_generic.h

@@ -0,0 +1,284 @@
+/**
+ * Copyright (c) 2017 - 2020, 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.
+ *
+ */
+#ifndef APP_USBD_HID_GENERIC_H__
+#define APP_USBD_HID_GENERIC_H__
+
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+#include <stdbool.h>
+
+#include "nrf_drv_usbd.h"
+#include "app_usbd_class_base.h"
+#include "app_usbd_hid_types.h"
+#include "app_usbd_hid.h"
+#include "app_usbd.h"
+#include "app_usbd_core.h"
+#include "app_usbd_descriptor.h"
+#include "app_usbd_hid_generic_desc.h"
+#include "app_usbd_hid_generic_internal.h"
+
+/**
+ * @defgroup app_usbd_hid_generic USB HID generic
+ * @ingroup app_usbd_hid
+ *
+ * @brief @tagAPI52840 Module with types, definitions, and API used by the HID generic class.
+ * @{
+ */
+
+
+#ifdef DOXYGEN
+/**
+ * @brief HID generic class instance type.
+ *
+ * @ref APP_USBD_CLASS_TYPEDEF
+ */
+typedef struct { } app_usbd_hid_generic_t;
+#else
+/*lint -save -e10 -e26 -e123 -e505 */
+APP_USBD_CLASS_TYPEDEF(app_usbd_hid_generic,                                           \
+            APP_USBD_HID_GENERIC_CONFIG(0, (NRF_DRV_USBD_EPIN1, NRF_DRV_USBD_EPOUT1)), \
+            APP_USBD_HID_GENERIC_INSTANCE_SPECIFIC_DEC,                                \
+            APP_USBD_HID_GENERIC_DATA_SPECIFIC_DEC                                     \
+);
+/*lint -restore*/
+#endif
+
+/**
+ * @brief Global definition of app_usbd_hid_generic_t class.
+ *
+ * @param instance_name             Name of global instance.
+ * @param interface_number          Unique interface index.
+ * @param user_ev_handler           User event handler (optional).
+ * @param endpoint_list             Input endpoint list (@ref nrf_drv_usbd_ep_t).
+ * @param subclass_descriptors      HID subclass descriptors.
+ * @param report_in_queue_size      IN report queue size.
+ * @param report_out_maxsize        Maximum output report size.
+ * @param report_feature_maxsize    Maximum feature report size.
+ * @param subclass_boot             Subclass boot (@ref app_usbd_hid_subclass_t).
+ * @param protocol                  HID protocol (@ref app_usbd_hid_protocol_t).
+ *
+ * @note This macro is just simplified version of @ref APP_USBD_HID_GENERIC_GLOBAL_DEF_INTERNAL.
+ *
+ * Example class definition:
+ * @code
+
+       APP_USBD_HID_GENERIC_SUBCLASS_REPORT_DESC(mouse_desc,APP_USBD_HID_MOUSE_REPORT_DSC_BUTTON(2));
+
+       static const app_usbd_hid_subclass_desc_t * reps[] = {&mouse_desc};
+
+       #define ENDPOINT_LIST                                        \
+       (                                                            \
+               NRF_DRV_USBD_EPIN1                                   \
+       )
+
+       #define REPORT_COUNT        1
+       #define REPORT_OUT_MAXSIZE  0
+
+       APP_USBD_HID_GENERIC_GLOBAL_DEF(m_app_hid_generic,
+                                       0,
+                                       hid_user_ev_handler,
+                                       ENDPOINT_LIST(),
+                                       reps,
+                                       REPORT_IN_QUEUE_SIZE,
+                                       REPORT_OUT_MAXSIZE,
+                                       REPORT_FEATURE_MAXSIZE,
+                                       APP_USBD_HID_SUBCLASS_BOOT,
+                                       APP_USBD_HID_PROTO_MOUSE);
+  @endcode
+ *
+ */
+/*lint -emacro( (40), APP_USBD_HID_GENERIC_GLOBAL_DEF) */
+#define APP_USBD_HID_GENERIC_GLOBAL_DEF(instance_name,                  \
+                                        interface_number,               \
+                                        user_ev_handler,                \
+                                        endpoint_list,                  \
+                                        subclass_descriptors,           \
+                                        report_in_queue_size,           \
+                                        report_out_maxsize,             \
+                                        report_feature_maxsize,         \
+                                        subclass_boot,                  \
+                                        protocol)                       \
+    APP_USBD_HID_GENERIC_GLOBAL_DEF_INTERNAL(instance_name,             \
+                                             interface_number,          \
+                                             user_ev_handler,           \
+                                             endpoint_list,             \
+                                             subclass_descriptors,      \
+                                             report_in_queue_size,      \
+                                             report_out_maxsize,        \
+                                             report_feature_maxsize,    \
+                                             subclass_boot,             \
+                                             protocol)
+
+/**
+ * @brief Helper function to get class instance from HID generic class.
+ *
+ * @param[in] p_generic HID generic class instance.
+ *
+ * @return Base class instance.
+ */
+static inline app_usbd_class_inst_t const *
+app_usbd_hid_generic_class_inst_get(app_usbd_hid_generic_t const * p_generic)
+{
+    return &p_generic->base;
+}
+
+/**
+ * @brief Helper function to get HID generic from base class instance.
+ *
+ * @param[in] p_inst Base class instance.
+ *
+ * @return HID generic class handle.
+ */
+static inline app_usbd_hid_generic_t const *
+app_usbd_hid_generic_class_get(app_usbd_class_inst_t const * p_inst)
+{
+    return (app_usbd_hid_generic_t const *)p_inst;
+}
+
+/**
+ * @brief Changes default HID idle report.
+ *
+ *
+ * @param[in] p_generic HID generic class instance.
+ * @param[in] p_buff    Report buffer.
+ * @param[in] size      Report size.
+ *
+ * @return Standard error code.
+ */
+ret_code_t hid_generic_idle_set(app_usbd_hid_generic_t const * p_generic,
+                                const void * p_buff,
+                                size_t size);
+
+/**
+ * @brief New IN report trigger.
+ *
+ *
+ * @param[in] p_generic HID generic class instance.
+ * @param[in] p_buff    Report buffer.
+ * @param[in] size      Report size.
+ *
+ * @return Standard error code.
+ */
+ret_code_t app_usbd_hid_generic_in_report_set(app_usbd_hid_generic_t const * p_generic,
+                                              const void * p_buff,
+                                              size_t size);
+
+/**
+ * @brief Returns last successful transfered IN report.
+ *
+ * @note Use this call only on @ref APP_USBD_HID_USER_EVT_IN_REPORT_DONE event.
+ *
+ * @param[in] p_generic HID generic class instance.
+ * @param[out] p_size   Last transfered IN report size.
+ *
+ * @return Last transfered report ID.
+ */
+const void * app_usbd_hid_generic_in_report_get(app_usbd_hid_generic_t const * p_generic,
+                                                size_t * p_size);
+
+/**
+ * @brief Returns last successful transfered OUT report.
+ *
+ * @warning Use this call only on @ref APP_USBD_HID_USER_EVT_OUT_REPORT_READY event.
+ *
+ * @param[in] p_generic HID generic class instance.
+ * @param[out] p_size   Last transfered OUT report size.
+ *
+ * @return Last transfered OUT report.
+ */
+const void * app_usbd_hid_generic_out_report_get(app_usbd_hid_generic_t const * p_generic,
+                                                 size_t * p_size);
+
+/**
+ * @brief Function handling SET_PROTOCOL command.
+ *
+ *
+ * @param[in] p_generic     HID generic class instance.
+ * @param[in] ev            User event.
+ *
+ * @return Standard error code.
+ */
+ret_code_t hid_generic_on_set_protocol(app_usbd_hid_generic_t const * p_generic,
+                                       app_usbd_hid_user_event_t ev);
+
+/**
+ * @brief Function that clears HID generic buffers and sends an empty report.
+ *
+ * @param[in] p_inst Base class instance.
+ *
+ * @return Standard error code.
+ */
+ret_code_t hid_generic_clear_buffer(app_usbd_class_inst_t const * p_inst);
+
+/**
+ * @brief Sets handler for idle reports.
+ *
+ * @param[in] p_inst    Base class instance.
+ * @param[in] handler   Handler.
+ *
+ * @return Standard error code.
+ */
+ret_code_t hid_generic_idle_handler_set(app_usbd_class_inst_t const * p_inst,
+                                        app_usbd_hid_idle_handler_t handler);
+
+/**
+ * @brief Sends idle reoprt.
+ *
+ * @param[in] p_generic     HID generic class instance.
+ * @param[in] p_buff        Report buffer.
+ * @param[in] size          Size of report.
+ *
+ * @return Standard error code.
+ */
+ret_code_t app_usbd_hid_generic_idle_report_set(app_usbd_hid_generic_t const * p_generic,
+                                                const void                   * p_buff,
+                                                size_t                         size);
+/** @} */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* APP_USBD_HID_GENERIC_H__ */

components/libraries/usbd/class/hid/generic/app_usbd_hid_generic_desc.h

@@ -0,0 +1,96 @@
+/**
+ * Copyright (c) 2017 - 2020, 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.
+ *
+ */
+#ifndef APP_USBD_HID_GENERIC_DESC_H__
+#define APP_USBD_HID_GENERIC_DESC_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/**
+ * @defgroup app_usbd_hid_generic_desc USB HID generic descriptors
+ * @ingroup app_usbd_hid_generic
+ *
+ * @brief @tagAPI52840 Module with descriptors used by the HID generic class.
+ * @{
+ */
+
+/**
+ * @brief Initializer of interface descriptor for HID generic class.
+ *
+ * @param interface_number  Interface number.
+ * @param endpoints_num     Number of endpoints.
+ * @param subclass          Subclass type @ref app_usbd_hid_subclass_t.
+ * @param protocol          Protocol type @ref app_usbd_hid_protocol_t.
+ */
+#define APP_USBD_HID_GENERIC_INTERFACE_DSC(interface_number,        \
+                                           endpoints_num,           \
+                                           subclass,                \
+                                           protocol)                \
+        APP_USBD_HID_INTERFACE_DSC(interface_number,                \
+                                   endpoints_num,                   \
+                                   subclass,                        \
+                                   protocol)                        \
+
+/**
+ * @brief Initializer of HID descriptor for HID generic class.
+ *
+ * @param ...   Report descriptor item.
+ */
+#define APP_USBD_HID_GENERIC_HID_DSC(...)   \
+        APP_USBD_HID_HID_DSC(__VA_ARGS__)
+/**
+ * @brief Initializer of endpoint descriptor for HID generic class.
+ *
+ * @param endpoint  Endpoint number.
+ */
+#define APP_USBD_HID_GENERIC_EP_DSC(endpoint) \
+        APP_USBD_HID_EP_DSC(endpoint, NRF_DRV_USBD_EPSIZE, 1)
+
+
+
+/** @} */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* APP_USBD_HID_GENERIC_DESC_H__ */

components/libraries/usbd/class/hid/generic/app_usbd_hid_generic_internal.h

@@ -0,0 +1,210 @@
+/**
+ * Copyright (c) 2017 - 2020, 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.
+ *
+ */
+#ifndef APP_USBD_HID_GENERIC_INTERNAL_H__
+#define APP_USBD_HID_GENERIC_INTERNAL_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "app_usbd_hid.h"
+#include "nrf_queue.h"
+
+/**
+ * @defgroup app_usbd_hid_generic_internal USB HID generic internals
+ * @ingroup app_usbd_hid_generic
+ *
+ * @brief @tagAPI52840 Module with types, definitions, and API used by the HID generic protocol.
+ * @{
+ */
+
+
+/**
+ * @brief Forward declaration of HID generic class type.
+ *
+ */
+APP_USBD_CLASS_FORWARD(app_usbd_hid_generic);
+
+/**
+ * @brief HID generic part of class instance data.
+ *
+ */
+typedef struct {
+    app_usbd_hid_inst_t hid_inst;       //!< HID instance data.
+    nrf_queue_t const * p_rep_in_queue; //!< Input report queue.
+} app_usbd_hid_generic_inst_t;
+
+/**
+ * @brief HID generic context
+ *
+ */
+typedef struct {
+    app_usbd_hid_ctx_t hid_ctx;          //!< HID class context.
+} app_usbd_hid_generic_ctx_t;
+
+
+/**
+ * @brief HID generic configuration macro.
+ *
+ * Used by @ref APP_USBD_HID_GENERIC_GLOBAL_DEF.
+ *
+ * @param iface         Interface number.
+ * @param endpoints     Endpoint list.
+ */
+#define APP_USBD_HID_GENERIC_CONFIG(iface, endpoints) ((iface, BRACKET_EXTRACT(endpoints)))
+
+
+/**
+ * @brief Specific class constant data for HID generic class.
+ */
+#define APP_USBD_HID_GENERIC_INSTANCE_SPECIFIC_DEC app_usbd_hid_generic_inst_t inst;
+
+/**
+ * @brief Specific class data for HID generic class.
+ */
+#define APP_USBD_HID_GENERIC_DATA_SPECIFIC_DEC app_usbd_hid_generic_ctx_t ctx;
+
+/**
+ * @brief Default interval value
+ *
+ */
+#define APP_USBD_HID_GENERIC_DEFAULT_INTERVAL 0x01
+
+#define APP_USBD_HID_GENERIC_INTERVAL(ep)   \
+(APP_USBD_EXTRACT_INTERVAL_FLAG(ep) ? APP_USBD_EXTRACT_INTERVAL_VALUE(ep) : APP_USBD_HID_GENERIC_DEFAULT_INTERVAL),
+
+
+/**
+ * @brief Configure internal part of HID generic instance.
+ *
+ * @param report_buff_in            Input report buffers array.
+ * @param report_buff_out           Output report buffer.
+ * @param report_buff_feature       Feature report buffer.
+ * @param user_ev_handler           User event handler.
+ * @param in_report_queue           IN report queue.
+ * @param subclass_descriptors      HID subclass descriptors.
+ * @param subclass_boot             Subclass boot (@ref app_usbd_hid_subclass_t).
+ * @param protocol                  HID protocol (@ref app_usbd_hid_protocol_t).
+ * @param endpoint_list             List of endpoints and intervals
+ */
+#define APP_USBD_HID_GENERIC_INST_CONFIG(report_buff_in,                      \
+                                         report_buff_out,                     \
+                                         report_buff_feature,                 \
+                                         user_ev_handler,                     \
+                                         in_report_queue,                     \
+                                         subclass_descriptors,                \
+                                         subclass_boot,                       \
+                                         protocol,                            \
+                                         endpoint_list)                       \
+    .inst = {                                                                 \
+         .hid_inst = APP_USBD_HID_INST_CONFIG(subclass_descriptors,           \
+                                              subclass_boot,                  \
+                                              protocol,                       \
+                                              report_buff_in,                 \
+                                              report_buff_out,                \
+                                              report_buff_feature,            \
+                                              user_ev_handler,                \
+                                              &app_usbd_hid_generic_methods,  \
+                                              endpoint_list),                 \
+        .p_rep_in_queue = in_report_queue,                                    \
+    }
+
+/**
+ * @brief Public HID generic interface.
+ */
+extern const app_usbd_hid_methods_t app_usbd_hid_generic_methods;
+
+/**
+ * @brief Public HID generic class interface.
+ */
+extern const app_usbd_class_methods_t app_usbd_generic_class_methods;
+
+/**
+ * @brief Global definition of @ref app_usbd_hid_generic_t class.
+ *
+ * @ref APP_USBD_HID_GENERIC_GLOBAL_DEF
+ */
+/*lint -esym( 40, APP_USBD_HID_GENERIC_INTERVAL) */
+#define APP_USBD_HID_GENERIC_GLOBAL_DEF_INTERNAL(instance_name,                     \
+                                                 interface_number,                  \
+                                                 user_ev_handler,                   \
+                                                 endpoint_list,                     \
+                                                 subclass_descriptors,              \
+                                                 report_in_queue_size,              \
+                                                 report_out_maxsize,                \
+                                                 report_feature_maxsize,            \
+                                                 subclass_boot,                     \
+                                                 protocol)                          \
+    static app_usbd_hid_report_buffer_t CONCAT_2(instance_name, _in);               \
+    APP_USBD_HID_GENERIC_GLOBAL_OUT_REP_DEF(CONCAT_2(instance_name, _out),          \
+                                            report_out_maxsize + 1);                \
+    APP_USBD_HID_GENERIC_GLOBAL_FEATURE_REP_DEF(CONCAT_2(instance_name, _feature),  \
+                                            report_feature_maxsize + 1);            \
+    static uint8_t CONCAT_2(instance_name, _ep)[]=                                  \
+        {MACRO_MAP(APP_USBD_HID_GENERIC_INTERVAL,BRACKET_EXTRACT(endpoint_list))};  \
+    NRF_QUEUE_DEF(app_usbd_hid_report_buffer_t,                                     \
+                  instance_name##_queue,                                            \
+                  report_in_queue_size,                                             \
+                  NRF_QUEUE_MODE_OVERFLOW);                                         \
+    APP_USBD_CLASS_INST_GLOBAL_DEF(                                                 \
+        instance_name,                                                              \
+        app_usbd_hid_generic,                                                       \
+        &app_usbd_generic_class_methods,                                            \
+        APP_USBD_HID_GENERIC_CONFIG(interface_number, endpoint_list),               \
+        (APP_USBD_HID_GENERIC_INST_CONFIG(&CONCAT_2(instance_name, _in),            \
+                                          &CONCAT_2(instance_name, _out),           \
+                                          &CONCAT_2(instance_name, _feature),       \
+                                          user_ev_handler,                          \
+                                          &instance_name##_queue,                   \
+                                          subclass_descriptors,                     \
+                                          subclass_boot,                            \
+                                          protocol,                                 \
+                                          CONCAT_2(instance_name, _ep)))            \
+    )
+
+
+/** @} */
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* APP_USBD_HID_GENERIC_INTERNAL_H__ */

components/libraries/usbd/class/hid/kbd/app_usbd_hid_kbd.c

@@ -0,0 +1,613 @@
+/**
+ * Copyright (c) 2016 - 2020, 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 "sdk_common.h"
+#if NRF_MODULE_ENABLED(APP_USBD_HID_KBD)
+
+#include <string.h>
+#include "app_usbd_hid_kbd.h"
+#include "app_util_platform.h"
+
+/**
+ * @defgroup app_usbd_hid_kbd_internals USB HID keyboard internals
+ * @{
+ * @ingroup app_usbd_hid_kbd
+ * @internal
+ */
+
+STATIC_ASSERT(sizeof(app_usbd_hid_descriptor_t) == 6);
+
+/**
+ * @brief Auxiliary function to access HID keyboard context data.
+ *
+ * @param[in] p_inst class instance data.
+ *
+ * @return HID keyboard instance data context.
+ */
+static inline app_usbd_hid_kbd_ctx_t * hid_kbd_ctx_get(app_usbd_hid_kbd_t const * p_kbd)
+{
+    ASSERT(p_kbd != NULL);
+    ASSERT(p_kbd->specific.p_data != NULL);
+    return &p_kbd->specific.p_data->ctx;
+}
+
+
+/**
+ * @brief Auxiliary function to access HID keyboard instance data.
+ *
+ * @param[in] p_inst class instance data.
+ *
+ * @return HID keyboard instance data.
+ */
+static inline app_usbd_hid_kbd_t const * hid_kbd_get(app_usbd_class_inst_t const * p_inst)
+{
+    ASSERT(p_inst != NULL);
+    return (app_usbd_hid_kbd_t const *)p_inst;
+}
+
+
+/**
+ * @brief Returns keyboard report buffer handle.
+ *
+ * @param[in] p_kbd HID keyboard instance.
+ *
+ * @return HID report buffer.
+ */
+static inline
+app_usbd_hid_report_buffer_t const * hid_kbd_rep_buffer_get(app_usbd_hid_kbd_t const * p_kbd)
+{
+    ASSERT(p_kbd != NULL);
+    app_usbd_hid_inst_t const    * p_hinst    = &p_kbd->specific.inst.hid_inst;
+    app_usbd_hid_kbd_ctx_t       * p_kbd_ctx  = hid_kbd_ctx_get(p_kbd);
+    app_usbd_hid_report_buffer_t * p_rep_buff = app_usbd_hid_rep_buff_in_get(p_hinst);
+
+    p_rep_buff->p_buff = p_kbd_ctx->report_buff;
+    p_rep_buff->size   = sizeof(p_kbd_ctx->report_buff);
+
+    /*Keyboard has only one report input/output report buffer */
+    return app_usbd_hid_rep_buff_in_get(p_hinst);
+}
+
+
+/**
+ * @brief Auxiliary function to prepare report transfer buffer to next transfer.
+ *
+ * @param[in] p_kbd HID keyboard instance.
+ *
+ * @retval true     Next transfer is required.
+ * @retval false    Next transfer is not required.
+ */
+static inline bool hid_kbd_transfer_next(app_usbd_hid_kbd_t const * p_kbd)
+{
+    /*Send report only when state has changed*/
+    app_usbd_hid_report_buffer_t const * p_rep_buffer = hid_kbd_rep_buffer_get(p_kbd);
+    app_usbd_hid_kbd_ctx_t             * p_kbd_ctx    = hid_kbd_ctx_get(p_kbd);
+
+    if (memcmp(p_rep_buffer->p_buff, &p_kbd_ctx->rep, p_rep_buffer->size))
+    {
+        memcpy(p_rep_buffer->p_buff, &p_kbd_ctx->rep, p_rep_buffer->size);
+        return true;
+    }
+
+    return false;
+}
+
+
+/**
+ * @brief Triggers IN endpoint transfer.
+ *
+ * @param[in] p_kbd HID keyboard instance.
+ *
+ * @return Standard error code.
+ */
+static inline ret_code_t hid_kbd_transfer_set(app_usbd_hid_kbd_t const * p_kbd)
+{
+    app_usbd_class_inst_t const * p_inst    = (app_usbd_class_inst_t const *)p_kbd;
+    app_usbd_hid_kbd_ctx_t      * p_kbd_ctx = hid_kbd_ctx_get(p_kbd);
+
+    nrf_drv_usbd_ep_t ep_addr = app_usbd_hid_epin_addr_get(p_inst);
+
+    app_usbd_hid_state_flag_clr(&p_kbd_ctx->hid_ctx, APP_USBD_HID_STATE_FLAG_TRANS_IN_PROGRESS);
+
+    if (!hid_kbd_transfer_next(p_kbd))
+    {
+        /* Transfer buffer hasn't changed since last transfer. No need to setup
+         * next transfer.
+         * */
+        return NRF_SUCCESS;
+    }
+
+    app_usbd_hid_report_buffer_t const * p_rep_buffer = hid_kbd_rep_buffer_get(p_kbd);
+    NRF_DRV_USBD_TRANSFER_IN(transfer, p_rep_buffer->p_buff, p_rep_buffer->size);
+
+    ret_code_t ret;
+    CRITICAL_REGION_ENTER();
+    ret = app_usbd_ep_transfer(ep_addr, &transfer);
+    if (ret == NRF_SUCCESS)
+    {
+        app_usbd_hid_state_flag_set(&p_kbd_ctx->hid_ctx, APP_USBD_HID_STATE_FLAG_TRANS_IN_PROGRESS);
+    }
+    CRITICAL_REGION_EXIT();
+
+    return ret;
+}
+
+
+ret_code_t app_usbd_hid_kbd_modifier_state_set(app_usbd_hid_kbd_t const  * p_kbd,
+                                               app_usbd_hid_kbd_modifier_t modifier,
+                                               bool                        state)
+{
+    app_usbd_hid_kbd_ctx_t * p_kbd_ctx    = hid_kbd_ctx_get(p_kbd);
+    bool                     actual_state = (p_kbd_ctx->rep.modifier & modifier) != 0;
+
+    if (actual_state == state)
+    {
+        /*Modifier has already the same state*/
+        return NRF_SUCCESS;
+    }
+
+    app_usbd_hid_access_lock(&p_kbd_ctx->hid_ctx);
+
+    if (state)
+    {
+        p_kbd_ctx->rep.modifier |= modifier;
+    }
+    else
+    {
+        p_kbd_ctx->rep.modifier &= ~modifier;
+    }
+    app_usbd_hid_access_unlock(&p_kbd_ctx->hid_ctx);
+
+    if (app_usbd_hid_trans_required(&p_kbd_ctx->hid_ctx))
+    {
+        /*New transfer need to be triggered*/
+        return hid_kbd_transfer_set(p_kbd);
+    }
+
+    return NRF_SUCCESS;
+}
+
+
+ret_code_t app_usbd_hid_kbd_key_control(app_usbd_hid_kbd_t const * p_kbd,
+                                        app_usbd_hid_kbd_codes_t   key,
+                                        bool                       press)
+{
+    app_usbd_hid_kbd_ctx_t * p_kbd_ctx   = hid_kbd_ctx_get(p_kbd);
+    uint8_t                * destination = NULL;
+
+    if (press)
+    {
+        for (size_t i = 0; i < ARRAY_SIZE(p_kbd_ctx->rep.key_table); ++i)
+        {
+            if (p_kbd_ctx->rep.key_table[i] == key)
+            {
+                /*Already pressed*/
+                return NRF_SUCCESS;
+            }
+
+            if ((destination == NULL) && (p_kbd_ctx->rep.key_table[i] == 0))
+            {
+                destination = &p_kbd_ctx->rep.key_table[i];
+            }
+        }
+
+        if (destination == NULL)
+        {
+            return NRF_ERROR_BUSY;
+        }
+    }
+    else
+    {
+        /*Find if key is pressed*/
+        for (size_t i = 0; i < ARRAY_SIZE(p_kbd_ctx->rep.key_table); ++i)
+        {
+            if (p_kbd_ctx->rep.key_table[i] == key)
+            {
+                destination = &p_kbd_ctx->rep.key_table[i];
+                break;
+            }
+        }
+
+        if (destination == NULL)
+        {
+            /*Key hasn't been pressed*/
+            return NRF_SUCCESS;
+        }
+    }
+
+    /*Save destination*/
+    app_usbd_hid_access_lock(&p_kbd_ctx->hid_ctx);
+    *destination = press ? key : 0;
+    app_usbd_hid_access_unlock(&p_kbd_ctx->hid_ctx);
+
+    if (app_usbd_hid_trans_required(&p_kbd_ctx->hid_ctx))
+    {
+        /*New transfer need to be triggered*/
+        return hid_kbd_transfer_set(p_kbd);
+    }
+
+    return NRF_SUCCESS;
+}
+
+
+bool app_usbd_hid_kbd_led_state_get(app_usbd_hid_kbd_t const * p_kbd,
+                                    app_usbd_hid_kbd_led_t     led)
+{
+    app_usbd_hid_kbd_ctx_t * p_kbd_ctx = hid_kbd_ctx_get(p_kbd);
+
+    return (p_kbd_ctx->leds_state & led) != 0;
+}
+
+const void * app_usbd_hid_kbd_in_report_get(app_usbd_hid_kbd_t const * p_kbd,
+                                            size_t * p_size)
+{
+    app_usbd_hid_inst_t const * p_kinst = &p_kbd->specific.inst.hid_inst;
+    *p_size = p_kinst->p_rep_buffer_in->size;
+    return p_kinst->p_rep_buffer_in->p_buff;
+}
+
+const void * app_usbd_hid_kbd_out_report_get(app_usbd_hid_kbd_t const * p_kbd,
+                                             size_t * p_size)
+{
+    app_usbd_hid_inst_t const * p_kinst = &p_kbd->specific.inst.hid_inst;
+    *p_size = p_kinst->p_rep_buffer_out->size;
+    return p_kinst->p_rep_buffer_out->p_buff;
+}
+
+/**
+ * @brief @ref app_usbd_hid_interface_t::on_get_report
+ */
+static ret_code_t hid_kbd_on_get_report(app_usbd_class_inst_t const * p_inst,
+                                        app_usbd_setup_evt_t const  * p_setup_ev)
+{
+    app_usbd_hid_kbd_t const * p_kinst = hid_kbd_get(p_inst);
+    uint8_t const * p_rep_buffer = NULL;
+    size_t buffer_size = 0;
+
+    if (p_setup_ev->setup.wValue.hb == APP_USBD_HID_REPORT_TYPE_INPUT)
+    {
+        p_rep_buffer = app_usbd_hid_kbd_in_report_get(p_kinst, &buffer_size);
+    }
+    else if (p_setup_ev->setup.wValue.hb == APP_USBD_HID_REPORT_TYPE_OUTPUT)
+    {
+        p_rep_buffer = app_usbd_hid_kbd_out_report_get(p_kinst, &buffer_size);
+    }
+    else
+    {
+        return NRF_ERROR_NOT_SUPPORTED;
+    }
+
+    /* Return LEDs state (only the second byte) */
+    return app_usbd_core_setup_rsp(&(p_setup_ev->setup), p_rep_buffer + 1, buffer_size - 1);
+}
+
+
+static ret_code_t hid_kbd_on_set_report_data_cb(nrf_drv_usbd_ep_status_t status, void * p_context)
+{
+    if (status != NRF_USBD_EP_OK)
+    {
+        return NRF_ERROR_INTERNAL;
+    }
+
+    app_usbd_hid_kbd_t const           * p_kbd = p_context;
+    app_usbd_hid_report_buffer_t const * p_rep_buff;
+    p_rep_buff = app_usbd_hid_rep_buff_out_get(&p_kbd->specific.inst.hid_inst);
+
+    /*Update LEDs state*/
+    app_usbd_hid_kbd_ctx_t * p_kbd_ctx = hid_kbd_ctx_get(p_kbd);
+    p_kbd_ctx->leds_state = p_rep_buff->p_buff[1];
+
+    app_usbd_hid_user_ev_handler_t handler = p_kbd->specific.inst.hid_inst.user_event_handler;
+    handler((app_usbd_class_inst_t const *)(p_kbd), APP_USBD_HID_USER_EVT_OUT_REPORT_READY);
+    return NRF_SUCCESS;
+}
+
+
+/**
+ * @brief @ref app_usbd_hid_interface_t::hid_kbd_on_set_report
+ */
+static ret_code_t hid_kbd_on_set_report(app_usbd_class_inst_t const * p_inst,
+                                        app_usbd_setup_evt_t const  * p_setup_ev)
+{
+    app_usbd_hid_kbd_t const * p_kbd = hid_kbd_get(p_inst);
+
+    /*Request setup data*/
+    app_usbd_hid_report_buffer_t const * p_rep_buff;
+
+    p_rep_buff = app_usbd_hid_rep_buff_out_get(&p_kbd->specific.inst.hid_inst);
+
+    p_rep_buff->p_buff[0] = 0;
+    NRF_DRV_USBD_TRANSFER_OUT(transfer, p_rep_buff->p_buff + 1, p_rep_buff->size - 1);
+
+    ret_code_t ret;
+    CRITICAL_REGION_ENTER();
+    ret = app_usbd_ep_transfer(NRF_DRV_USBD_EPOUT0, &transfer);
+    if (ret == NRF_SUCCESS)
+    {
+        app_usbd_core_setup_data_handler_desc_t desc = {
+            .handler   = hid_kbd_on_set_report_data_cb,
+            .p_context = (app_usbd_hid_kbd_t *)p_kbd
+        };
+
+        ret = app_usbd_core_setup_data_handler_set(NRF_DRV_USBD_EPOUT0, &desc);
+    }
+    CRITICAL_REGION_EXIT();
+
+    return ret;
+}
+
+
+/**
+ * @brief @ref app_usbd_hid_interface_t::hid_kbd_ep_transfer_in
+ */
+static ret_code_t hid_kbd_ep_transfer_in(app_usbd_class_inst_t const * p_inst)
+{
+    return hid_kbd_transfer_set((app_usbd_hid_kbd_t const *)p_inst);
+}
+
+
+/**
+ * @brief @ref app_usbd_class_interface_t::event_handler
+ */
+static ret_code_t hid_kbd_event_handler(app_usbd_class_inst_t const  * p_inst,
+                                        app_usbd_complex_evt_t const * p_event)
+{
+    ASSERT(p_inst != NULL);
+    ASSERT(p_event != NULL);
+
+    app_usbd_hid_kbd_t const  * p_kbd   = hid_kbd_get(p_inst);
+    app_usbd_hid_inst_t const * p_hinst = &p_kbd->specific.inst.hid_inst;
+
+    app_usbd_hid_kbd_ctx_t * p_kbd_ctx = hid_kbd_ctx_get(p_kbd);
+    app_usbd_hid_ctx_t     * p_hid_ctx = &p_kbd_ctx->hid_ctx;
+
+    /*Try handle event by generic HID event handler*/
+    return app_usbd_hid_event_handler(p_inst, p_hinst, p_hid_ctx, p_event);
+}
+
+ret_code_t hid_kbd_clear_buffer(app_usbd_class_inst_t const * p_inst)
+{
+    ASSERT(p_inst != NULL);
+
+    app_usbd_hid_kbd_t const *              p_kbd        = hid_kbd_get(p_inst);
+    app_usbd_hid_kbd_ctx_t *                p_kbd_ctx    = hid_kbd_ctx_get(p_kbd);
+    app_usbd_hid_report_buffer_t const *    p_rep_buffer = hid_kbd_rep_buffer_get(p_kbd);
+
+    memset(p_rep_buffer->p_buff, 0, p_rep_buffer->size);
+    memset(p_kbd_ctx->report_buff, 0, p_rep_buffer->size);
+    memset(&p_kbd_ctx->rep, 0, p_rep_buffer->size);
+    
+    CRITICAL_REGION_ENTER();
+    
+        
+    nrf_drv_usbd_ep_t ep_addr = app_usbd_hid_epin_addr_get(p_inst);
+
+    ASSERT(!NRF_USBD_EPISO_CHECK(ep_addr));
+
+    if (NRF_USBD_EPIN_CHECK(ep_addr))
+    {
+        nrf_drv_usbd_ep_abort(ep_addr);
+    }
+
+    app_usbd_hid_state_flag_clr(&p_kbd_ctx->hid_ctx, APP_USBD_HID_STATE_FLAG_TRANS_IN_PROGRESS);
+    CRITICAL_REGION_EXIT();
+    
+    return NRF_SUCCESS;
+}
+
+
+static uint8_t hid_kbd_get_class_descriptors_count(app_usbd_class_inst_t const * p_inst)
+{
+    app_usbd_hid_kbd_t const  * p_kbd   = hid_kbd_get(p_inst);
+    app_usbd_hid_inst_t const * p_hinst = &p_kbd->specific.inst.hid_inst;
+
+    return p_hinst->subclass_desc_count;
+}
+
+
+static app_usbd_descriptor_t hid_kbd_get_class_descriptors_type(
+    app_usbd_class_inst_t const * p_inst,
+    uint8_t                       desc_num)
+{
+    app_usbd_hid_kbd_t const  * p_kbd   = hid_kbd_get(p_inst);
+    app_usbd_hid_inst_t const * p_hinst = &p_kbd->specific.inst.hid_inst;
+
+    return p_hinst->p_subclass_desc[desc_num]->type;
+}
+
+
+static size_t hid_kbd_get_class_descriptors_length(app_usbd_class_inst_t const * p_inst,
+                                                   uint8_t                       desc_num)
+{
+    app_usbd_hid_kbd_t const  * p_kbd   = hid_kbd_get(p_inst);
+    app_usbd_hid_inst_t const * p_hinst = &p_kbd->specific.inst.hid_inst;
+
+    return p_hinst->p_subclass_desc[desc_num]->size;
+}
+
+
+static const uint8_t * hid_kbd_get_class_descriptors_data(app_usbd_class_inst_t const * p_inst,
+                                                          uint8_t                       desc_num,
+                                                          uint32_t                      cur_byte)
+{
+    app_usbd_hid_kbd_t const  * p_kbd   = hid_kbd_get(p_inst);
+    app_usbd_hid_inst_t const * p_hinst = &p_kbd->specific.inst.hid_inst;
+    const uint8_t * p_byte = &p_hinst->p_subclass_desc[desc_num]->p_data[cur_byte];
+
+    return p_byte;
+}
+
+
+static bool hid_kbd_feed_descriptors(app_usbd_class_descriptor_ctx_t                   * p_ctx,
+                                     app_usbd_class_inst_t const                       * p_inst,
+                                     uint8_t                                           * p_buff,
+                                     size_t                                              max_size)
+{
+    static uint8_t ifaces   = 0;
+    ifaces = app_usbd_class_iface_count_get(p_inst);
+    app_usbd_hid_kbd_t const * p_kbd = hid_kbd_get(p_inst);
+
+    APP_USBD_CLASS_DESCRIPTOR_BEGIN(p_ctx, p_buff, max_size);
+
+    static uint8_t i = 0;
+
+    for (i = 0; i < ifaces; i++)
+    {
+        /* INTERFACE DESCRIPTOR */
+        APP_USBD_CLASS_DESCRIPTOR_WRITE(0x09); // bLength
+        APP_USBD_CLASS_DESCRIPTOR_WRITE(APP_USBD_DESCRIPTOR_INTERFACE); // bDescriptorType = Interface
+
+        static app_usbd_class_iface_conf_t const * p_cur_iface = NULL;
+        p_cur_iface = app_usbd_class_iface_get(p_inst, i);
+        APP_USBD_CLASS_DESCRIPTOR_WRITE(app_usbd_class_iface_number_get(p_cur_iface)); // bInterfaceNumber
+
+        APP_USBD_CLASS_DESCRIPTOR_WRITE(0x00); // bAlternateSetting
+        APP_USBD_CLASS_DESCRIPTOR_WRITE(app_usbd_class_iface_ep_count_get(p_cur_iface)); // bNumEndpoints
+        APP_USBD_CLASS_DESCRIPTOR_WRITE(APP_USBD_HID_CLASS); // bInterfaceClass = HID
+        APP_USBD_CLASS_DESCRIPTOR_WRITE(p_kbd->specific.inst.hid_inst.subclass_boot); // bInterfaceSubclass (Boot Interface)
+        APP_USBD_CLASS_DESCRIPTOR_WRITE(p_kbd->specific.inst.hid_inst.protocol); // bInterfaceProtocol
+        APP_USBD_CLASS_DESCRIPTOR_WRITE(0x00); // iInterface
+
+        /* HID DESCRIPTOR */
+        APP_USBD_CLASS_DESCRIPTOR_WRITE(0x09); // bLength
+        APP_USBD_CLASS_DESCRIPTOR_WRITE(APP_USBD_HID_DESCRIPTOR_HID);  // bDescriptorType = HID
+        APP_USBD_CLASS_DESCRIPTOR_WRITE(LSB_16(APP_USBD_HID_BCD_VER)); // bcdHID LSB
+        APP_USBD_CLASS_DESCRIPTOR_WRITE(MSB_16(APP_USBD_HID_BCD_VER)); // bcdHID MSB
+        APP_USBD_CLASS_DESCRIPTOR_WRITE(APP_USBD_HID_COUNTRY_NOT_SUPPORTED); // bCountryCode
+        APP_USBD_CLASS_DESCRIPTOR_WRITE(hid_kbd_get_class_descriptors_count(p_inst)); // bNumDescriptors
+
+        static uint8_t class_desc_cnt = 0;
+        class_desc_cnt = hid_kbd_get_class_descriptors_count(p_inst);
+        static uint8_t  j              = 0;
+        static uint16_t class_desc_len = 0;
+
+        for (j = 0; j < class_desc_cnt; j++)
+        {
+            APP_USBD_CLASS_DESCRIPTOR_WRITE(hid_kbd_get_class_descriptors_type(p_inst, j)); // bDescriptorType
+
+            class_desc_len = hid_kbd_get_class_descriptors_length(p_inst, j);
+            APP_USBD_CLASS_DESCRIPTOR_WRITE(LSB_16(class_desc_len)); // wDescriptorLength LSB
+            APP_USBD_CLASS_DESCRIPTOR_WRITE(MSB_16(class_desc_len)); // wDescriptorLength MSB
+        }
+
+        static uint8_t endpoints = 0;
+        endpoints = app_usbd_class_iface_ep_count_get(p_cur_iface);
+
+        for (j = 0; j < endpoints; j++)
+        {
+            /* ENDPOINT DESCRIPTOR */
+            APP_USBD_CLASS_DESCRIPTOR_WRITE(0x07); // bLength
+            APP_USBD_CLASS_DESCRIPTOR_WRITE(APP_USBD_DESCRIPTOR_ENDPOINT); // bDescriptorType = Endpoint
+
+            static app_usbd_class_ep_conf_t const * p_cur_ep = NULL;
+            p_cur_ep = app_usbd_class_iface_ep_get(p_cur_iface, j);
+            APP_USBD_CLASS_DESCRIPTOR_WRITE(app_usbd_class_ep_address_get(p_cur_ep)); // bEndpointAddress
+            APP_USBD_CLASS_DESCRIPTOR_WRITE(APP_USBD_DESCRIPTOR_EP_ATTR_TYPE_INTERRUPT); // bmAttributes
+            APP_USBD_CLASS_DESCRIPTOR_WRITE(LSB_16(NRF_DRV_USBD_EPSIZE)); // wMaxPacketSize LSB
+            APP_USBD_CLASS_DESCRIPTOR_WRITE(MSB_16(NRF_DRV_USBD_EPSIZE)); // wMaxPacketSize MSB
+            APP_USBD_CLASS_DESCRIPTOR_WRITE(p_kbd->specific.inst.hid_inst.p_ep_interval[j]); // bInterval
+        }
+    }
+
+    APP_USBD_CLASS_DESCRIPTOR_END();
+}
+
+
+ret_code_t hid_kbd_on_set_protocol(app_usbd_hid_kbd_t const * p_kbd, app_usbd_hid_user_event_t ev)
+{
+    app_usbd_hid_kbd_ctx_t * p_kbd_ctx = hid_kbd_ctx_get(p_kbd);
+    if (ev == APP_USBD_HID_USER_EVT_SET_BOOT_PROTO)
+    {
+        p_kbd_ctx->hid_ctx.selected_protocol = APP_USBD_HID_PROTO_BOOT;
+    }
+    else if (ev == APP_USBD_HID_USER_EVT_SET_REPORT_PROTO)
+    {
+        p_kbd_ctx->hid_ctx.selected_protocol = APP_USBD_HID_PROTO_REPORT;
+    }
+    else
+    {
+        return NRF_ERROR_NOT_SUPPORTED;
+    }
+    return NRF_SUCCESS;
+}
+
+
+static ret_code_t hid_kbd_on_idle(app_usbd_class_inst_t const * p_inst, uint8_t report_id)
+{
+    UNUSED_PARAMETER(report_id);
+    app_usbd_hid_kbd_t const * p_kbd    = (app_usbd_hid_kbd_t const *)p_inst;
+    app_usbd_hid_kbd_ctx_t      * p_kbd_ctx = hid_kbd_ctx_get(p_kbd);
+    nrf_drv_usbd_ep_t ep_addr = app_usbd_hid_epin_addr_get(p_inst);
+    app_usbd_hid_state_flag_clr(&p_kbd_ctx->hid_ctx, APP_USBD_HID_STATE_FLAG_TRANS_IN_PROGRESS);
+
+    app_usbd_hid_report_buffer_t const * p_rep_buffer = hid_kbd_rep_buffer_get(p_kbd);
+    NRF_DRV_USBD_TRANSFER_IN(transfer, p_rep_buffer->p_buff, p_rep_buffer->size);
+    UNUSED_RETURN_VALUE(hid_kbd_transfer_next(p_kbd));
+
+    ret_code_t ret;
+    CRITICAL_REGION_ENTER();
+    ret = app_usbd_ep_transfer(ep_addr, &transfer);
+    if (ret == NRF_SUCCESS)
+    {
+        app_usbd_hid_state_flag_set(&p_kbd_ctx->hid_ctx, APP_USBD_HID_STATE_FLAG_TRANS_IN_PROGRESS);
+    }
+    CRITICAL_REGION_EXIT();
+    
+    return NRF_SUCCESS;
+}
+
+/** @} */
+
+const app_usbd_hid_methods_t app_usbd_hid_kbd_methods = {
+    .on_get_report              = hid_kbd_on_get_report,
+    .on_set_report              = hid_kbd_on_set_report,
+    .ep_transfer_in             = hid_kbd_ep_transfer_in,
+    .ep_transfer_out            = NULL,
+    .subclass_count             = hid_kbd_get_class_descriptors_count,
+    .subclass_length            = hid_kbd_get_class_descriptors_length,
+    .subclass_data              = hid_kbd_get_class_descriptors_data,
+    .on_idle                    = hid_kbd_on_idle,
+};
+
+const app_usbd_class_methods_t app_usbd_hid_kbd_class_methods = {
+    .event_handler            = hid_kbd_event_handler,
+    .feed_descriptors         = hid_kbd_feed_descriptors,
+};
+
+#endif //NRF_MODULE_ENABLED(APP_USBD_HID_KBD)

components/libraries/usbd/class/hid/kbd/app_usbd_hid_kbd.h

@@ -0,0 +1,330 @@
+/**
+ * Copyright (c) 2017 - 2020, 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.
+ *
+ */
+#ifndef APP_USBD_HID_KBD_H__
+#define APP_USBD_HID_KBD_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+#include <stdbool.h>
+
+#include "nrf_drv_usbd.h"
+#include "app_usbd_class_base.h"
+#include "app_usbd_hid_types.h"
+#include "app_usbd_hid.h"
+#include "app_usbd.h"
+#include "app_usbd_core.h"
+#include "app_usbd_descriptor.h"
+#include "app_usbd_hid_kbd_desc.h"
+#include "app_usbd_hid_kbd_internal.h"
+
+
+/**
+ * @defgroup app_usbd_hid_kbd USB HID keyboard
+ * @ingroup app_usbd_hid
+ *
+ * @brief @tagAPI52840 Module with types, definitions, and API used by the HID keyboard class.
+ * @{
+ */
+
+/**
+ * @brief HID keyboard codes.
+ */
+typedef enum {
+    APP_USBD_HID_KBD_A               = 4,  /**<KBD_A               code*/
+    APP_USBD_HID_KBD_B               = 5,  /**<KBD_B               code*/
+    APP_USBD_HID_KBD_C               = 6,  /**<KBD_C               code*/
+    APP_USBD_HID_KBD_D               = 7,  /**<KBD_D               code*/
+    APP_USBD_HID_KBD_E               = 8,  /**<KBD_E               code*/
+    APP_USBD_HID_KBD_F               = 9,  /**<KBD_F               code*/
+    APP_USBD_HID_KBD_G               = 10, /**<KBD_G               code*/
+    APP_USBD_HID_KBD_H               = 11, /**<KBD_H               code*/
+    APP_USBD_HID_KBD_I               = 12, /**<KBD_I               code*/
+    APP_USBD_HID_KBD_J               = 13, /**<KBD_J               code*/
+    APP_USBD_HID_KBD_K               = 14, /**<KBD_K               code*/
+    APP_USBD_HID_KBD_L               = 15, /**<KBD_L               code*/
+    APP_USBD_HID_KBD_M               = 16, /**<KBD_M               code*/
+    APP_USBD_HID_KBD_N               = 17, /**<KBD_N               code*/
+    APP_USBD_HID_KBD_O               = 18, /**<KBD_O               code*/
+    APP_USBD_HID_KBD_P               = 19, /**<KBD_P               code*/
+    APP_USBD_HID_KBD_Q               = 20, /**<KBD_Q               code*/
+    APP_USBD_HID_KBD_R               = 21, /**<KBD_R               code*/
+    APP_USBD_HID_KBD_S               = 22, /**<KBD_S               code*/
+    APP_USBD_HID_KBD_T               = 23, /**<KBD_T               code*/
+    APP_USBD_HID_KBD_U               = 24, /**<KBD_U               code*/
+    APP_USBD_HID_KBD_V               = 25, /**<KBD_V               code*/
+    APP_USBD_HID_KBD_W               = 26, /**<KBD_W               code*/
+    APP_USBD_HID_KBD_X               = 27, /**<KBD_X               code*/
+    APP_USBD_HID_KBD_Y               = 28, /**<KBD_Y               code*/
+    APP_USBD_HID_KBD_Z               = 29, /**<KBD_Z               code*/
+    APP_USBD_HID_KBD_1               = 30, /**<KBD_1               code*/
+    APP_USBD_HID_KBD_2               = 31, /**<KBD_2               code*/
+    APP_USBD_HID_KBD_3               = 32, /**<KBD_3               code*/
+    APP_USBD_HID_KBD_4               = 33, /**<KBD_4               code*/
+    APP_USBD_HID_KBD_5               = 34, /**<KBD_5               code*/
+    APP_USBD_HID_KBD_6               = 35, /**<KBD_6               code*/
+    APP_USBD_HID_KBD_7               = 36, /**<KBD_7               code*/
+    APP_USBD_HID_KBD_8               = 37, /**<KBD_8               code*/
+    APP_USBD_HID_KBD_9               = 38, /**<KBD_9               code*/
+    APP_USBD_HID_KBD_0               = 39, /**<KBD_0               code*/
+    APP_USBD_HID_KBD_ENTER           = 40, /**<KBD_ENTER           code*/
+    APP_USBD_HID_KBD_ESCAPE          = 41, /**<KBD_ESCAPE          code*/
+    APP_USBD_HID_KBD_BACKSPACE       = 42, /**<KBD_BACKSPACE       code*/
+    APP_USBD_HID_KBD_TAB             = 43, /**<KBD_TAB             code*/
+    APP_USBD_HID_KBD_SPACEBAR        = 44, /**<KBD_SPACEBAR        code*/
+    APP_USBD_HID_KBD_UNDERSCORE      = 45, /**<KBD_UNDERSCORE      code*/
+    APP_USBD_HID_KBD_PLUS            = 46, /**<KBD_PLUS            code*/
+    APP_USBD_HID_KBD_OPEN_BRACKET    = 47, /**<KBD_OPEN_BRACKET    code*/
+    APP_USBD_HID_KBD_CLOSE_BRACKET   = 48, /**<KBD_CLOSE_BRACKET   code*/
+    APP_USBD_HID_KBD_BACKSLASH       = 49, /**<KBD_BACKSLASH       code*/
+    APP_USBD_HID_KBD_ASH             = 50, /**<KBD_ASH             code*/
+    APP_USBD_HID_KBD_COLON           = 51, /**<KBD_COLON           code*/
+    APP_USBD_HID_KBD_QUOTE           = 52, /**<KBD_QUOTE           code*/
+    APP_USBD_HID_KBD_TILDE           = 53, /**<KBD_TILDE           code*/
+    APP_USBD_HID_KBD_COMMA           = 54, /**<KBD_COMMA           code*/
+    APP_USBD_HID_KBD_DOT             = 55, /**<KBD_DOT             code*/
+    APP_USBD_HID_KBD_SLASH           = 56, /**<KBD_SLASH           code*/
+    APP_USBD_HID_KBD_CAPS_LOCK       = 57, /**<KBD_CAPS_LOCK       code*/
+    APP_USBD_HID_KBD_F1              = 58, /**<KBD_F1              code*/
+    APP_USBD_HID_KBD_F2              = 59, /**<KBD_F2              code*/
+    APP_USBD_HID_KBD_F3              = 60, /**<KBD_F3              code*/
+    APP_USBD_HID_KBD_F4              = 61, /**<KBD_F4              code*/
+    APP_USBD_HID_KBD_F5              = 62, /**<KBD_F5              code*/
+    APP_USBD_HID_KBD_F6              = 63, /**<KBD_F6              code*/
+    APP_USBD_HID_KBD_F7              = 64, /**<KBD_F7              code*/
+    APP_USBD_HID_KBD_F8              = 65, /**<KBD_F8              code*/
+    APP_USBD_HID_KBD_F9              = 66, /**<KBD_F9              code*/
+    APP_USBD_HID_KBD_F10             = 67, /**<KBD_F10             code*/
+    APP_USBD_HID_KBD_F11             = 68, /**<KBD_F11             code*/
+    APP_USBD_HID_KBD_F12             = 69, /**<KBD_F12             code*/
+    APP_USBD_HID_KBD_PRINTSCREEN     = 70, /**<KBD_PRINTSCREEN     code*/
+    APP_USBD_HID_KBD_SCROLL_LOCK     = 71, /**<KBD_SCROLL_LOCK     code*/
+    APP_USBD_HID_KBD_PAUSE           = 72, /**<KBD_PAUSE           code*/
+    APP_USBD_HID_KBD_INSERT          = 73, /**<KBD_INSERT          code*/
+    APP_USBD_HID_KBD_HOME            = 74, /**<KBD_HOME            code*/
+    APP_USBD_HID_KBD_PAGEUP          = 75, /**<KBD_PAGEUP          code*/
+    APP_USBD_HID_KBD_DELETE          = 76, /**<KBD_DELETE          code*/
+    APP_USBD_HID_KBD_END             = 77, /**<KBD_END             code*/
+    APP_USBD_HID_KBD_PAGEDOWN        = 78, /**<KBD_PAGEDOWN        code*/
+    APP_USBD_HID_KBD_RIGHT           = 79, /**<KBD_RIGHT           code*/
+    APP_USBD_HID_KBD_LEFT            = 80, /**<KBD_LEFT            code*/
+    APP_USBD_HID_KBD_DOWN            = 81, /**<KBD_DOWN            code*/
+    APP_USBD_HID_KBD_UP              = 82, /**<KBD_UP              code*/
+    APP_USBD_HID_KBD_KEYPAD_NUM_LOCK = 83, /**<KBD_KEYPAD_NUM_LOCK code*/
+    APP_USBD_HID_KBD_KEYPAD_DIVIDE   = 84, /**<KBD_KEYPAD_DIVIDE   code*/
+    APP_USBD_HID_KBD_KEYPAD_AT       = 85, /**<KBD_KEYPAD_AT       code*/
+    APP_USBD_HID_KBD_KEYPAD_MULTIPLY = 85, /**<KBD_KEYPAD_MULTIPLY code*/
+    APP_USBD_HID_KBD_KEYPAD_MINUS    = 86, /**<KBD_KEYPAD_MINUS    code*/
+    APP_USBD_HID_KBD_KEYPAD_PLUS     = 87, /**<KBD_KEYPAD_PLUS     code*/
+    APP_USBD_HID_KBD_KEYPAD_ENTER    = 88, /**<KBD_KEYPAD_ENTER    code*/
+    APP_USBD_HID_KBD_KEYPAD_1        = 89, /**<KBD_KEYPAD_1        code*/
+    APP_USBD_HID_KBD_KEYPAD_2        = 90, /**<KBD_KEYPAD_2        code*/
+    APP_USBD_HID_KBD_KEYPAD_3        = 91, /**<KBD_KEYPAD_3        code*/
+    APP_USBD_HID_KBD_KEYPAD_4        = 92, /**<KBD_KEYPAD_4        code*/
+    APP_USBD_HID_KBD_KEYPAD_5        = 93, /**<KBD_KEYPAD_5        code*/
+    APP_USBD_HID_KBD_KEYPAD_6        = 94, /**<KBD_KEYPAD_6        code*/
+    APP_USBD_HID_KBD_KEYPAD_7        = 95, /**<KBD_KEYPAD_7        code*/
+    APP_USBD_HID_KBD_KEYPAD_8        = 96, /**<KBD_KEYPAD_8        code*/
+    APP_USBD_HID_KBD_KEYPAD_9        = 97, /**<KBD_KEYPAD_9        code*/
+    APP_USBD_HID_KBD_KEYPAD_0        = 98, /**<KBD_KEYPAD_0        code*/
+} app_usbd_hid_kbd_codes_t;
+
+/**
+ * @brief HID keyboard modifier.
+ */
+typedef enum {
+    APP_USBD_HID_KBD_MODIFIER_NONE          = 0x00,  /**< MODIFIER_NONE        bit*/
+    APP_USBD_HID_KBD_MODIFIER_LEFT_CTRL     = 0x01,  /**< MODIFIER_LEFT_CTRL   bit*/
+    APP_USBD_HID_KBD_MODIFIER_LEFT_SHIFT    = 0x02,  /**< MODIFIER_LEFT_SHIFT  bit*/
+    APP_USBD_HID_KBD_MODIFIER_LEFT_ALT      = 0x04,  /**< MODIFIER_LEFT_ALT    bit*/
+    APP_USBD_HID_KBD_MODIFIER_LEFT_UI       = 0x08,  /**< MODIFIER_LEFT_UI     bit*/
+    APP_USBD_HID_KBD_MODIFIER_RIGHT_CTRL    = 0x10,  /**< MODIFIER_RIGHT_CTRL  bit*/
+    APP_USBD_HID_KBD_MODIFIER_RIGHT_SHIFT   = 0x20,  /**< MODIFIER_RIGHT_SHIFT bit*/
+    APP_USBD_HID_KBD_MODIFIER_RIGHT_ALT     = 0x40,  /**< MODIFIER_RIGHT_ALT   bit*/
+    APP_USBD_HID_KBD_MODIFIER_RIGHT_UI      = 0x80,  /**< MODIFIER_RIGHT_UI    bit*/
+} app_usbd_hid_kbd_modifier_t;
+
+/**
+ * @brief HID keyboard LEDs.
+ */
+typedef enum {
+    APP_USBD_HID_KBD_LED_NUM_LOCK     = 0x01,  /**< LED_NUM_LOCK    id*/
+    APP_USBD_HID_KBD_LED_CAPS_LOCK    = 0x02,  /**< LED_CAPS_LOCK   id*/
+    APP_USBD_HID_KBD_LED_SCROLL_LOCK  = 0x04,  /**< LED_SCROLL_LOCK id*/
+    APP_USBD_HID_KBD_LED_COMPOSE      = 0x08,  /**< LED_COMPOSE     id*/
+    APP_USBD_HID_KBD_LED_KANA         = 0x10,  /**< LED_KANA        id*/
+} app_usbd_hid_kbd_led_t;
+
+
+
+#ifdef DOXYGEN
+/**
+ * @brief HID keyboard class instance type.
+ *
+ * @ref APP_USBD_CLASS_TYPEDEF
+ */
+typedef struct { } app_usbd_hid_kbd_t;
+#else
+/*lint -save -e10 -e26 -e123 -e505 */
+APP_USBD_CLASS_TYPEDEF(app_usbd_hid_kbd,                        \
+            APP_USBD_HID_KBD_CONFIG(0, NRF_DRV_USBD_EPIN1),     \
+            APP_USBD_HID_KBD_INSTANCE_SPECIFIC_DEC,             \
+            APP_USBD_HID_KBD_DATA_SPECIFIC_DEC                  \
+);
+/*lint -restore*/
+#endif
+
+/**
+ * @brief Global definition of app_usbd_hid_kbd_t class.
+ *
+ * @param instance_name     Name of global instance.
+ * @param interface_number  Unique interface index.
+ * @param endpoint          Input endpoint (@ref nrf_drv_usbd_ep_t).
+ * @param user_ev_handler   User event handler (optional parameter: NULL might be passed here).
+ * @param subclass_boot     Subclass boot (@ref app_usbd_hid_subclass_t).
+ *
+ * Example class definition:
+ * @code
+   APP_USBD_HID_KBD_GLOBAL_DEF(my_awesome_kbd, 0, NRF_DRV_USBD_EPIN1, NULL, APP_USBD_HID_SUBCLASS_BOOT);
+ * @endcode
+ */
+#define APP_USBD_HID_KBD_GLOBAL_DEF(instance_name, interface_number, endpoint, user_ev_handler, subclass_boot)  \
+        APP_USBD_HID_GENERIC_SUBCLASS_REPORT_DESC(keyboard_desc, APP_USBD_HID_KBD_REPORT_DSC());                \
+        static const app_usbd_hid_subclass_desc_t * keyboard_descs[] = {&keyboard_desc};                        \
+        APP_USBD_HID_KBD_GLOBAL_DEF_INTERNAL(instance_name,                                                     \
+                                             interface_number,                                                  \
+                                             endpoint,                                                          \
+                                             user_ev_handler,                                                   \
+                                             subclass_boot)
+
+/**
+ * @brief Helper function to get class instance from HID keyboard internals.
+ *
+ * @param[in] p_kbd Keyboard instance (declared by @ref APP_USBD_HID_KBD_GLOBAL_DEF).
+ *
+ * @return Base class instance.
+ */
+static inline app_usbd_class_inst_t const *
+app_usbd_hid_kbd_class_inst_get(app_usbd_hid_kbd_t const * p_kbd)
+{
+    return &p_kbd->base;
+}
+
+/**
+ * @brief Helper function to get HID keyboard from base class instance.
+ *
+ * @param[in] p_inst Base class instance.
+ *
+ * @return HID keyboard class handle.
+ */
+static inline app_usbd_hid_kbd_t const *
+app_usbd_hid_kbd_class_get(app_usbd_class_inst_t const * p_inst)
+{
+    return (app_usbd_hid_kbd_t const *)p_inst;
+}
+
+/**
+ * @brief Set HID keyboard modifier state.
+ *
+ * @param[in] p_kbd     Keyboard instance (declared by @ref APP_USBD_HID_KBD_GLOBAL_DEF).
+ * @param[in] modifier  Type of modifier.
+ * @param[in] state     State, true active, false inactive.
+ *
+ * @return Standard error code.
+ */
+ret_code_t app_usbd_hid_kbd_modifier_state_set(app_usbd_hid_kbd_t const * p_kbd,
+                                               app_usbd_hid_kbd_modifier_t modifier,
+                                               bool state);
+
+
+/**
+ * @brief Press/release HID keyboard key.
+ *
+ * @param[in] p_kbd     Keyboard instance (declared by @ref APP_USBD_HID_KBD_GLOBAL_DEF).
+ * @param[in] key       Keyboard key code.
+ * @param[in] press     True -> key press, false -> release.
+ *
+ * @return Standard error code.
+ */
+ret_code_t app_usbd_hid_kbd_key_control(app_usbd_hid_kbd_t const * p_kbd,
+                                        app_usbd_hid_kbd_codes_t key,
+                                        bool press);
+/**
+ * @brief HID Keyboard LEDs state get.
+ *
+ * @param[in] p_kbd Keyboard instance (declared by @ref APP_USBD_HID_KBD_GLOBAL_DEF).
+ * @param[in] led   LED code.
+ *
+ * @retval true     LED is set.
+ * @retval false    LED is not set.
+ */
+bool app_usbd_hid_kbd_led_state_get(app_usbd_hid_kbd_t const * p_kbd,
+                                    app_usbd_hid_kbd_led_t led);
+
+/**
+ * @brief Function handling SET_PROTOCOL command.
+ *
+ *
+ * @param[in] p_kbd         Keyboard instance.
+ * @param[in] ev            User event.
+ *
+ * @return Standard error code.
+ */
+ret_code_t hid_kbd_on_set_protocol(app_usbd_hid_kbd_t const * p_kbd,
+                                   app_usbd_hid_user_event_t ev);
+
+/**
+ * @brief Function that clears HID keyboard buffers and sends an empty report.
+ *
+ * @param[in] p_inst Base class instance.
+ *
+ * @return Standard error code.
+ */
+ret_code_t hid_kbd_clear_buffer(app_usbd_class_inst_t const * p_inst);
+
+/** @} */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* APP_USBD_HID_KBD_H__ */

components/libraries/usbd/class/hid/kbd/app_usbd_hid_kbd_desc.h

@@ -0,0 +1,128 @@
+/**
+ * Copyright (c) 2016 - 2020, 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.
+ *
+ */
+#ifndef APP_USBD_HID_KBD_DESC_H__
+#define APP_USBD_HID_KBD_DESC_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/**
+ * @defgroup app_usbd_hid_kbd_desc USB HID keyboard descriptors
+ * @ingroup app_usbd_hid_kbd
+ *
+ * @brief @tagAPI52840 Module with types, definitions, and API used by the HID keyboard class.
+ * @{
+ */
+
+/**
+ * @brief Initializer of interface descriptor for HID keyboard class.
+ *
+ * @param interface_number  Interface number.
+ */
+#define APP_USBD_HID_KBD_INTERFACE_DSC(interface_number)            \
+        APP_USBD_HID_INTERFACE_DSC(interface_number,                \
+                                   1,                               \
+                                   APP_USBD_HID_SUBCLASS_BOOT,      \
+                                   APP_USBD_HID_PROTO_KEYBOARD)
+
+/**
+ * @brief Initializer of HID descriptor for HID keyboard class.
+ *
+ * @param ...   Report descriptor item.
+ */
+#define APP_USBD_HID_KBD_HID_DSC(...)       \
+        APP_USBD_HID_HID_DSC(__VA_ARGS__)
+/**
+ * @brief Initializer of endpoint descriptor for HID keyboard class.
+ *
+ * @param endpoint  Endpoint number.
+ */
+#define APP_USBD_HID_KBD_EP_DSC(endpoint)   \
+        APP_USBD_HID_EP_DSC(endpoint, 8, 1)
+
+
+/**
+ * @brief Example of USB HID keyboard report descriptor.
+ *
+ */
+#define APP_USBD_HID_KBD_REPORT_DSC() {                                                    \
+        0x05, 0x01,                    /* USAGE_PAGE (Generic Desktop)                   */\
+        0x09, 0x06,                    /* USAGE (Keyboard)                               */\
+        0xa1, 0x01,                    /* COLLECTION (Application)                       */\
+        0x05, 0x07,                    /*   USAGE_PAGE (Keyboard)                        */\
+        0x19, 0xe0,                    /*   USAGE_MINIMUM (Keyboard LeftControl)         */\
+        0x29, 0xe7,                    /*   USAGE_MAXIMUM (Keyboard Right GUI)           */\
+        0x15, 0x00,                    /*   LOGICAL_MINIMUM (0)                          */\
+        0x25, 0x01,                    /*   LOGICAL_MAXIMUM (1)                          */\
+        0x75, 0x01,                    /*   REPORT_SIZE (1)                              */\
+        0x95, 0x08,                    /*   REPORT_COUNT (8)                             */\
+        0x81, 0x02,                    /*   INPUT (Data,Var,Abs)                         */\
+        0x95, 0x01,                    /*   REPORT_COUNT (1)                             */\
+        0x75, 0x08,                    /*   REPORT_SIZE (8)                              */\
+        0x81, 0x03,                    /*   INPUT (Cnst,Var,Abs)                         */\
+        0x95, 0x05,                    /*   REPORT_COUNT (5)                             */\
+        0x75, 0x01,                    /*   REPORT_SIZE (1)                              */\
+        0x05, 0x08,                    /*   USAGE_PAGE (LEDs)                            */\
+        0x19, 0x01,                    /*   USAGE_MINIMUM (Num Lock)                     */\
+        0x29, 0x05,                    /*   USAGE_MAXIMUM (Kana)                         */\
+        0x91, 0x02,                    /*   OUTPUT (Data,Var,Abs)                        */\
+        0x95, 0x01,                    /*   REPORT_COUNT (1)                             */\
+        0x75, 0x03,                    /*   REPORT_SIZE (3)                              */\
+        0x91, 0x03,                    /*   OUTPUT (Cnst,Var,Abs)                        */\
+        0x95, 0x06,                    /*   REPORT_COUNT (6)                             */\
+        0x75, 0x08,                    /*   REPORT_SIZE (8)                              */\
+        0x15, 0x00,                    /*   LOGICAL_MINIMUM (0)                          */\
+        0x25, 0x65,                    /*   LOGICAL_MAXIMUM (101)                        */\
+        0x05, 0x07,                    /*   USAGE_PAGE (Keyboard)                        */\
+        0x19, 0x00,                    /*   USAGE_MINIMUM (Reserved (no event indicated))*/\
+        0x29, 0x65,                    /*   USAGE_MAXIMUM (Keyboard Application)         */\
+        0x81, 0x00,                    /*   INPUT (Data,Ary,Abs)                         */\
+        0xc0                           /* END_COLLECTION                                 */\
+}
+
+/** @} */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* APP_USBD_HID_KBD_DESC_H__ */

components/libraries/usbd/class/hid/kbd/app_usbd_hid_kbd_internal.h

@@ -0,0 +1,189 @@
+/**
+ * Copyright (c) 2017 - 2020, 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.
+ *
+ */
+#ifndef APP_USBD_HID_KBD_INTERNAL_H__
+#define APP_USBD_HID_KBD_INTERNAL_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/**
+ * @defgroup app_usbd_hid_kbd_internal USB HID keyboard internals
+ * @ingroup app_usbd_hid_kbd
+ *
+ * @brief @tagAPI52840 Module with types, definitions, and API used by the HID keyboard class.
+ * @{
+ */
+
+/**
+ * @brief Forward declaration of HID keyboard class type.
+ *
+ */
+APP_USBD_CLASS_FORWARD(app_usbd_hid_kbd);
+
+
+/**
+ * @brief HID keyboard part of class instance data.
+ *
+ */
+typedef struct {
+    app_usbd_hid_inst_t hid_inst;  //!< HID instance data.
+} app_usbd_hid_kbd_inst_t;
+
+/**
+ * @brief HID keyboard context.
+ *
+ */
+typedef struct {
+    app_usbd_hid_ctx_t hid_ctx; //!< HID class context.
+
+    struct app_usbd_hid_kbd_ctx_internal_s {
+        uint8_t modifier;       //!< Keyboard modifier state @ref app_usbd_hid_kbd_modifier_t.
+        uint8_t reserved;       //!< Reserved value.
+        uint8_t key_table[6];   //!< Keyboard keys table @ref app_usbd_hid_kbd_codes_t.
+    } rep;
+
+    uint8_t report_buff[8];     //!< Raw report buffer.
+    uint8_t leds_state;         //!< Output report LEDs state.
+    uint8_t set_report;         //!< Set report flag.
+} app_usbd_hid_kbd_ctx_t;
+
+/**
+ * @brief HID keyboard configuration macro.
+ *
+ * Used by @ref APP_USBD_HID_KBD_GLOBAL_DEF.
+ *
+ *
+ */
+#define APP_USBD_HID_KBD_CONFIG(iface, ep) ((iface, ep))
+
+
+/**
+ * @brief Specific class constant data for HID keyboard class.
+ */
+#define APP_USBD_HID_KBD_INSTANCE_SPECIFIC_DEC app_usbd_hid_kbd_inst_t inst;
+
+/**
+ * @brief Specific class data for HID keyboard class.
+ */
+#define APP_USBD_HID_KBD_DATA_SPECIFIC_DEC app_usbd_hid_kbd_ctx_t ctx;
+
+/**
+ * @brief Default interval value
+ *
+ */
+#define APP_USBD_HID_KBD_DEFAULT_INTERVAL 0x01
+
+#define APP_USBD_HID_KBD_INTERVAL(ep)   \
+(APP_USBD_EXTRACT_INTERVAL_FLAG(ep) ? APP_USBD_EXTRACT_INTERVAL_VALUE(ep) : APP_USBD_HID_KBD_DEFAULT_INTERVAL)
+
+/**
+ * @brief Configure internal part of HID keyboard instance.
+ *
+ * @param report_buff_in    Input report buffers array.
+ * @param report_buff_out   Output report buffer.
+ * @param user_ev_handler   User event handler.
+ * @param subclass_boot     Subclass boot (@ref app_usbd_hid_subclass_t).
+ * @param endpoint_list     List of endpoints and intervals
+ */
+#define APP_USBD_HID_KBD_INST_CONFIG(report_buff_in,                            \
+                                     report_buff_out,                           \
+                                     user_ev_handler,                           \
+                                     subclass_boot,                             \
+                                     endpoint_list)                             \
+    .inst = {                                                                   \
+         .hid_inst = APP_USBD_HID_INST_CONFIG(keyboard_descs,                   \
+                                              subclass_boot,                    \
+                                              APP_USBD_HID_PROTO_KEYBOARD,      \
+                                              report_buff_in,                   \
+                                              report_buff_out,                  \
+                                              NULL,                             \
+                                              user_ev_handler,                  \
+                                              &app_usbd_hid_kbd_methods,        \
+                                              endpoint_list),                   \
+}
+
+
+/**
+ * @brief Public HID keyboard interface.
+ */
+extern const app_usbd_hid_methods_t app_usbd_hid_kbd_methods;
+
+/**
+ * @brief Public HID keyboard class interface.
+ */
+extern const app_usbd_class_methods_t app_usbd_hid_kbd_class_methods;
+
+/**
+ * @brief Global definition of @ref app_usbd_hid_kbd_t class.
+ *
+ * @ref  APP_USBD_HID_KBD_GLOBAL_DEF
+ */
+/*lint -esym( 40, APP_USBD_HID_KBD_INTERVAL) */
+#define APP_USBD_HID_KBD_GLOBAL_DEF_INTERNAL(instance_name,                                        \
+                                             interface_number,                                     \
+                                             endpoint,                                             \
+                                             user_ev_handler,                                      \
+                                             subclass_boot)                                        \
+    static app_usbd_hid_report_buffer_t CONCAT_2(instance_name, _in)[1];                           \
+    static uint8_t CONCAT_2(instance_name, _ep) = {MACRO_MAP(APP_USBD_HID_KBD_INTERVAL,endpoint)}; \
+    APP_USBD_HID_GENERIC_GLOBAL_OUT_REP_DEF(CONCAT_2(instance_name, _out), 1 + 1);                 \
+    APP_USBD_CLASS_INST_GLOBAL_DEF(                                                                \
+        instance_name,                                                                             \
+        app_usbd_hid_kbd,                                                                          \
+        &app_usbd_hid_kbd_class_methods,                                                           \
+        APP_USBD_HID_KBD_CONFIG(interface_number, endpoint),                                       \
+        (APP_USBD_HID_KBD_INST_CONFIG(CONCAT_2(instance_name, _in),                                \
+                                      &CONCAT_2(instance_name, _out),                              \
+                                      user_ev_handler,                                             \
+                                      subclass_boot,                                               \
+                                      &CONCAT_2(instance_name, _ep)))                              \
+    )
+
+
+/** @} */
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* APP_USBD_HID_KBD_INTERNAL_H__ */

components/libraries/usbd/class/hid/mouse/app_usbd_hid_mouse.c

@@ -0,0 +1,690 @@
+/**
+ * Copyright (c) 2016 - 2020, 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 "sdk_common.h"
+#if NRF_MODULE_ENABLED(APP_USBD_HID_MOUSE)
+
+#include <string.h>
+#include "app_usbd_hid_mouse.h"
+#include "app_util_platform.h"
+
+/**
+ * @defgroup app_usbd_hid_mouse_internal USBD HID Mouse internals
+ * @{
+ * @ingroup app_usbd_hid_mouse
+ * @internal
+ */
+
+/**
+ * @brief Auxiliary function to access HID mouse context data.
+ *
+ * @param[in] p_inst class instance data.
+ *
+ * @return HID mouse instance data context.
+ */
+static inline app_usbd_hid_mouse_ctx_t * hid_mouse_ctx_get(app_usbd_hid_mouse_t const * p_mouse)
+{
+    ASSERT(p_mouse != NULL);
+    ASSERT(p_mouse->specific.p_data != NULL);
+    return &p_mouse->specific.p_data->ctx;
+}
+
+
+/**
+ * @brief Auxiliary function to access HID mouse instance data.
+ *
+ * @param[in] p_inst class instance data.
+ *
+ * @return HID mouse instance.
+ */
+static inline app_usbd_hid_mouse_t const * hid_mouse_get(app_usbd_class_inst_t const * p_inst)
+{
+    ASSERT(p_inst != NULL);
+    return (app_usbd_hid_mouse_t const *)p_inst;
+}
+
+
+/**
+ * @brief Returns mouse report buffer handle.
+ *
+ * @param[in] p_kbd HID keyboard instance.
+ *
+ * @return HID report buffer.
+ */
+static inline
+app_usbd_hid_report_buffer_t const * hid_mouse_rep_buffer_get(app_usbd_hid_mouse_t const * p_mouse)
+{
+    ASSERT(p_mouse != NULL);
+    app_usbd_hid_inst_t const    * p_hinst     = &p_mouse->specific.inst.hid_inst;
+    app_usbd_hid_mouse_ctx_t     * p_mouse_ctx = hid_mouse_ctx_get(p_mouse);
+    app_usbd_hid_report_buffer_t * p_rep_buff  = app_usbd_hid_rep_buff_in_get(p_hinst);
+
+    p_rep_buff->p_buff = p_mouse_ctx->report_buff;
+    p_rep_buff->size   = sizeof(p_mouse_ctx->report_buff);
+
+    /*Mouse has only one report input report buffer */
+    return app_usbd_hid_rep_buff_in_get(p_hinst);
+}
+
+
+/**@brief Auxiliary function to get report value from internal accumulated value.
+ *
+ * @param[in] acc Accumulated XY axis or scroll.
+ *
+ * @return Offset value that could be written directly to report buffer.
+ */
+static inline int8_t hid_mouse_axis_acc_get(int16_t acc)
+{
+    if (acc > INT8_MAX)
+    {
+        return INT8_MAX;
+    }
+
+    if (acc < INT8_MIN)
+    {
+        return INT8_MIN;
+    }
+
+    return acc;
+}
+
+
+/**@brief Auxiliary function to prepare report transfer buffer to next transfer.
+ *
+ * @param[in] p_mouse_ctx Mouse internal context.
+ *
+ * @retval true     Next transfer is required.
+ * @retval false    Next transfer is not required.
+ */
+static inline bool hid_mouse_transfer_next(app_usbd_hid_mouse_t const * p_mouse)
+{
+
+    app_usbd_hid_mouse_ctx_t           * p_mouse_ctx  = hid_mouse_ctx_get(p_mouse);
+    app_usbd_hid_report_buffer_t const * p_rep_buffer = hid_mouse_rep_buffer_get(p_mouse);
+
+    uint8_t * p_buff = p_rep_buffer->p_buff;
+
+    /*Save last buttons state*/
+    uint8_t last_button_state = p_buff[0];
+
+    /*Button state*/
+    p_buff[0] = p_mouse_ctx->button_state;
+
+    /*Axis X*/
+    int8_t val_x = hid_mouse_axis_acc_get(p_mouse_ctx->acc_x_axis);
+    p_mouse_ctx->acc_x_axis -= val_x;
+    p_buff[1]                = val_x;
+
+    /*Axis Y*/
+    int8_t val_y = hid_mouse_axis_acc_get(p_mouse_ctx->acc_y_axis);
+    p_mouse_ctx->acc_y_axis -= val_y;
+    p_buff[2]                = val_y;
+
+    /*Scroll*/
+    int8_t val_scroll = hid_mouse_axis_acc_get(p_mouse_ctx->acc_scroll);
+    p_mouse_ctx->acc_scroll -= val_scroll;
+    p_buff[3]                = val_scroll;
+
+    if (val_x || val_y || val_scroll)
+    {
+        /*New transfer is required if any of mouse relative position is not zero*/
+        return true;
+    }
+
+    if (last_button_state != p_buff[0])
+    {
+        /*New transfer is required if button state has changed*/
+        return true;
+    }
+
+    return false;
+}
+
+
+/**
+ * @brief Triggers IN endpoint transfer.
+ *
+ * @param[in] p_mouse HID mouse instance.
+ *
+ * @return Standard error code.
+ */
+static inline ret_code_t hid_mouse_transfer_set(app_usbd_hid_mouse_t const * p_mouse)
+{
+    app_usbd_class_inst_t const * p_inst      = (app_usbd_class_inst_t const *)p_mouse;
+    app_usbd_hid_mouse_ctx_t    * p_mouse_ctx = hid_mouse_ctx_get(p_mouse);
+
+    nrf_drv_usbd_ep_t ep_addr = app_usbd_hid_epin_addr_get(p_inst);
+
+    app_usbd_hid_state_flag_clr(&p_mouse_ctx->hid_ctx, APP_USBD_HID_STATE_FLAG_TRANS_IN_PROGRESS);
+    if (!hid_mouse_transfer_next(p_mouse))
+    {
+        /* Transfer buffer hasn't changed since last transfer. No need to setup
+         * next transfer.
+         * */
+        return NRF_SUCCESS;
+    }
+
+    app_usbd_hid_report_buffer_t const * p_rep_buffer = hid_mouse_rep_buffer_get(p_mouse);
+
+    NRF_DRV_USBD_TRANSFER_IN(transfer, p_rep_buffer->p_buff, p_rep_buffer->size);
+
+    ret_code_t ret;
+    CRITICAL_REGION_ENTER();
+    ret = app_usbd_ep_transfer(ep_addr, &transfer);
+    if (ret == NRF_SUCCESS)
+    {
+        app_usbd_hid_state_flag_set(&p_mouse_ctx->hid_ctx,
+                                    APP_USBD_HID_STATE_FLAG_TRANS_IN_PROGRESS);
+    }
+    CRITICAL_REGION_EXIT();
+
+    return ret;
+}
+
+
+/**
+ * @brief Checks if adding would cause 16 bit signed integer overflow.
+ *
+ * @param[in] acc   Signed 16 bit accumulator to test.
+ * @param[in] value Value to add to accumulator.
+ *
+ * @retval true     Overflow detected.
+ * @retval false    No overflow detected.
+ */
+static inline bool hid_mouse_acc_overflow_check(int16_t acc, int8_t val)
+{
+    if (((int32_t)acc + val) > INT16_MAX)
+    {
+        return true;
+    }
+
+    if (((int32_t)acc + val) < INT16_MIN)
+    {
+        return true;
+    }
+
+    return false;
+}
+
+
+ret_code_t app_usbd_hid_mouse_x_move(app_usbd_hid_mouse_t const * p_mouse, int8_t offset)
+{
+    app_usbd_hid_mouse_ctx_t * p_mouse_ctx = hid_mouse_ctx_get(p_mouse);
+
+    if (!app_usbd_hid_state_valid(&p_mouse_ctx->hid_ctx))
+    {
+        return NRF_ERROR_INVALID_STATE;
+    }
+
+    if (offset == 0)
+    {
+        /*No position change*/
+        return NRF_SUCCESS;
+    }
+
+    if (hid_mouse_acc_overflow_check(p_mouse_ctx->acc_y_axis, offset))
+    {
+        /*Overflow detected*/
+        return NRF_ERROR_BUSY;
+    }
+
+    app_usbd_hid_access_lock(&p_mouse_ctx->hid_ctx);
+    p_mouse_ctx->acc_x_axis += offset;
+    app_usbd_hid_access_unlock(&p_mouse_ctx->hid_ctx);
+
+    if (app_usbd_hid_trans_required(&p_mouse_ctx->hid_ctx))
+    {
+        /*New transfer need to be triggered*/
+        return hid_mouse_transfer_set(p_mouse);
+    }
+
+    return NRF_SUCCESS;
+}
+
+
+ret_code_t app_usbd_hid_mouse_y_move(app_usbd_hid_mouse_t const * p_mouse, int8_t offset)
+{
+    app_usbd_hid_mouse_ctx_t * p_mouse_ctx = hid_mouse_ctx_get(p_mouse);
+
+    if (!app_usbd_hid_state_valid(&p_mouse_ctx->hid_ctx))
+    {
+        return NRF_ERROR_INVALID_STATE;
+    }
+
+    if (offset == 0)
+    {
+        /*No position change*/
+        return NRF_SUCCESS;
+    }
+
+    if (hid_mouse_acc_overflow_check(p_mouse_ctx->acc_y_axis, offset))
+    {
+        /*Overflow detected*/
+        return NRF_ERROR_BUSY;
+    }
+
+    app_usbd_hid_access_lock(&p_mouse_ctx->hid_ctx);
+    p_mouse_ctx->acc_y_axis += offset;
+    app_usbd_hid_access_unlock(&p_mouse_ctx->hid_ctx);
+
+    if (app_usbd_hid_trans_required(&p_mouse_ctx->hid_ctx))
+    {
+        /*New transfer need to be triggered*/
+        return hid_mouse_transfer_set(p_mouse);
+    }
+
+    return NRF_SUCCESS;
+}
+
+
+ret_code_t app_usbd_hid_mouse_scroll_move(app_usbd_hid_mouse_t const * p_mouse, int8_t offset)
+{
+    app_usbd_hid_mouse_ctx_t * p_mouse_ctx = hid_mouse_ctx_get(p_mouse);
+
+    if (!app_usbd_hid_state_valid(&p_mouse_ctx->hid_ctx))
+    {
+        return NRF_ERROR_INVALID_STATE;
+    }
+
+    if (offset == 0)
+    {
+        /*No position change*/
+        return NRF_SUCCESS;
+    }
+
+    if (hid_mouse_acc_overflow_check(p_mouse_ctx->acc_scroll, offset))
+    {
+        /*Overflow detected*/
+        return NRF_ERROR_BUSY;
+    }
+
+    app_usbd_hid_access_lock(&p_mouse_ctx->hid_ctx);
+    p_mouse_ctx->acc_scroll += offset;
+    app_usbd_hid_access_unlock(&p_mouse_ctx->hid_ctx);
+
+    if (app_usbd_hid_trans_required(&p_mouse_ctx->hid_ctx))
+    {
+        /*New transfer need to be triggered*/
+        return hid_mouse_transfer_set(p_mouse);
+    }
+
+    return NRF_SUCCESS;
+}
+
+
+ret_code_t app_usbd_hid_mouse_button_state(app_usbd_hid_mouse_t const * p_mouse,
+                                           uint8_t                      button_id,
+                                           bool                         state)
+{
+    ASSERT(button_id < 8);
+    app_usbd_hid_mouse_ctx_t * p_mouse_ctx = hid_mouse_ctx_get(p_mouse);
+
+    if (button_id >= p_mouse->specific.inst.button_count)
+    {
+        return NRF_ERROR_INVALID_PARAM;
+    }
+
+    if (!app_usbd_hid_state_valid(&p_mouse_ctx->hid_ctx))
+    {
+        return NRF_ERROR_INVALID_STATE;
+    }
+
+    if (IS_SET(p_mouse_ctx->button_state, button_id) == (state ? 1 : 0))
+    {
+        return NRF_SUCCESS;
+    }
+
+    app_usbd_hid_access_lock(&p_mouse_ctx->hid_ctx);
+    if (state)
+    {
+        SET_BIT(p_mouse_ctx->button_state, button_id);
+    }
+    else
+    {
+        CLR_BIT(p_mouse_ctx->button_state, button_id);
+    }
+    app_usbd_hid_access_unlock(&p_mouse_ctx->hid_ctx);
+
+    if (app_usbd_hid_trans_required(&p_mouse_ctx->hid_ctx))
+    {
+        /*New transfer need to be triggered*/
+        return hid_mouse_transfer_set(p_mouse);
+    }
+
+    return NRF_SUCCESS;
+}
+
+
+/**
+ * @brief @ref app_usbd_hid_interface_t::on_get_report
+ */
+static ret_code_t hid_mouse_on_get_report(app_usbd_class_inst_t const * p_inst,
+                                          app_usbd_setup_evt_t const  * p_setup_ev)
+{
+    if (p_setup_ev->setup.wValue.hb != APP_USBD_HID_REPORT_TYPE_INPUT)
+    {
+        return NRF_ERROR_NOT_SUPPORTED;
+    }
+
+    app_usbd_hid_mouse_t const * p_mouse = hid_mouse_get(p_inst);
+    app_usbd_hid_report_buffer_t const * p_rep_buffer = hid_mouse_rep_buffer_get(p_mouse);
+
+    return app_usbd_core_setup_rsp(&(p_setup_ev->setup), p_rep_buffer->p_buff, p_rep_buffer->size);
+}
+
+
+/**
+ * @brief @ref app_usbd_hid_interface_t::on_set_report
+ */
+static ret_code_t hid_mouse_on_set_report(app_usbd_class_inst_t const * p_inst,
+                                          app_usbd_setup_evt_t const  * p_setup_ev)
+{
+    return NRF_ERROR_NOT_SUPPORTED;
+}
+
+
+/**
+ * @brief @ref app_usbd_hid_interface_t::ep_transfer_set
+ */
+static ret_code_t hid_mouse_ep_transfer_in(app_usbd_class_inst_t const * p_inst)
+{
+    return hid_mouse_transfer_set((app_usbd_hid_mouse_t const *)p_inst);
+}
+
+
+/**
+ * @brief @ref app_usbd_class_interface_t::event_handler
+ */
+static ret_code_t hid_mouse_event_handler(app_usbd_class_inst_t const  * p_inst,
+                                          app_usbd_complex_evt_t const * p_event)
+{
+    ASSERT(p_inst != NULL);
+    ASSERT(p_event != NULL);
+
+    app_usbd_hid_mouse_t const * p_mouse = hid_mouse_get(p_inst);
+    app_usbd_hid_inst_t const  * p_hinst = &p_mouse->specific.inst.hid_inst;
+
+    app_usbd_hid_mouse_ctx_t * p_mouse_ctx = hid_mouse_ctx_get(p_mouse);
+    app_usbd_hid_ctx_t       * p_hid_ctx   = &p_mouse_ctx->hid_ctx;
+
+
+    ret_code_t ret = NRF_SUCCESS;
+
+    switch (p_event->app_evt.type)
+    {
+        default:
+            ret = NRF_ERROR_NOT_SUPPORTED;
+            break;
+    }
+
+    if (ret != NRF_ERROR_NOT_SUPPORTED)
+    {
+        /* Event was processed by specific handler */
+        return ret;
+    }
+
+    /*Try handle event by generic HID event handler*/
+    return app_usbd_hid_event_handler(p_inst, p_hinst, p_hid_ctx, p_event);
+}
+
+
+ret_code_t hid_mouse_clear_buffer(app_usbd_class_inst_t const * p_inst)
+{
+    ASSERT(p_inst != NULL);
+
+    app_usbd_hid_mouse_t const *              p_mouse        = hid_mouse_get(p_inst);
+    app_usbd_hid_mouse_ctx_t *                p_mouse_ctx    = hid_mouse_ctx_get(p_mouse);
+    app_usbd_hid_report_buffer_t const *      p_rep_buffer   = hid_mouse_rep_buffer_get(p_mouse);
+
+    memset(p_rep_buffer->p_buff, 0, p_rep_buffer->size);
+    memset(p_mouse_ctx->report_buff, 0, p_rep_buffer->size);
+    memset(&p_mouse_ctx->acc_x_axis, 0, sizeof(p_mouse_ctx->acc_x_axis));
+    memset(&p_mouse_ctx->acc_y_axis, 0, sizeof(p_mouse_ctx->acc_y_axis));
+    memset(&p_mouse_ctx->acc_scroll, 0, sizeof(p_mouse_ctx->acc_scroll));
+    memset(&p_mouse_ctx->button_state, 0, sizeof(p_mouse_ctx->button_state));
+    
+    CRITICAL_REGION_ENTER();
+    
+    nrf_drv_usbd_ep_t ep_addr = app_usbd_hid_epin_addr_get(p_inst);
+
+    ASSERT(!NRF_USBD_EPISO_CHECK(ep_addr));
+
+    if (NRF_USBD_EPIN_CHECK(ep_addr))
+    {
+        nrf_drv_usbd_ep_abort(ep_addr);
+    }
+
+    app_usbd_hid_state_flag_clr(&p_mouse_ctx->hid_ctx, APP_USBD_HID_STATE_FLAG_TRANS_IN_PROGRESS);
+    CRITICAL_REGION_EXIT();
+    
+    return NRF_SUCCESS;
+}
+
+
+static uint8_t hid_mouse_get_class_descriptors_count(app_usbd_class_inst_t const * p_inst)
+{
+    app_usbd_hid_mouse_t const * p_mouse = hid_mouse_get(p_inst);
+    app_usbd_hid_inst_t const  * p_hinst = &p_mouse->specific.inst.hid_inst;
+
+    return p_hinst->subclass_desc_count;
+}
+
+
+static app_usbd_descriptor_t hid_mouse_get_class_descriptors_type(
+    app_usbd_class_inst_t const * p_inst,
+    uint8_t                       desc_num)
+{
+    app_usbd_hid_mouse_t const * p_mouse = hid_mouse_get(p_inst);
+    app_usbd_hid_inst_t const  * p_hinst = &p_mouse->specific.inst.hid_inst;
+
+    return p_hinst->p_subclass_desc[desc_num]->type;
+}
+
+
+static size_t hid_mouse_get_class_descriptors_length(app_usbd_class_inst_t const * p_inst,
+                                                     uint8_t                       desc_num)
+{
+    app_usbd_hid_mouse_t const * p_mouse = hid_mouse_get(p_inst);
+    app_usbd_hid_inst_t const  * p_hinst = &p_mouse->specific.inst.hid_inst;
+
+    return p_hinst->p_subclass_desc[desc_num]->size;
+}
+
+
+static const uint8_t * hid_mouse_get_class_descriptors_data(app_usbd_class_inst_t const * p_inst,
+                                                            uint8_t                       desc_num,
+                                                            uint32_t                      cur_byte)
+{
+    app_usbd_hid_mouse_t const * p_mouse = hid_mouse_get(p_inst);
+    app_usbd_hid_inst_t const  * p_hinst = &p_mouse->specific.inst.hid_inst;
+    const uint8_t * p_byte = &p_hinst->p_subclass_desc[desc_num]->p_data[cur_byte];
+
+    return p_byte;
+}
+
+
+static bool hid_mouse_feed_descriptors(app_usbd_class_descriptor_ctx_t  * p_ctx,
+                                       app_usbd_class_inst_t const      * p_inst,
+                                       uint8_t                          * p_buff,
+                                       size_t                             max_size)
+{
+    static uint8_t ifaces   = 0;
+
+    ifaces = app_usbd_class_iface_count_get(p_inst);
+    app_usbd_hid_mouse_t const * p_mouse = hid_mouse_get(p_inst);
+
+    APP_USBD_CLASS_DESCRIPTOR_BEGIN(p_ctx, p_buff, max_size);
+
+    static uint8_t i = 0;
+
+    for (i = 0; i < ifaces; i++)
+    {
+        /* INTERFACE DESCRIPTOR */
+        APP_USBD_CLASS_DESCRIPTOR_WRITE(0x09); // bLength
+        APP_USBD_CLASS_DESCRIPTOR_WRITE(APP_USBD_DESCRIPTOR_INTERFACE); // bDescriptorType = Interface
+
+        static app_usbd_class_iface_conf_t const * p_cur_iface = NULL;
+        p_cur_iface = app_usbd_class_iface_get(p_inst, i);
+
+        APP_USBD_CLASS_DESCRIPTOR_WRITE(app_usbd_class_iface_number_get(p_cur_iface)); // bInterfaceNumber
+        APP_USBD_CLASS_DESCRIPTOR_WRITE(0x00); // bAlternateSetting
+        APP_USBD_CLASS_DESCRIPTOR_WRITE(app_usbd_class_iface_ep_count_get(p_cur_iface)); // bNumEndpoints
+        APP_USBD_CLASS_DESCRIPTOR_WRITE(APP_USBD_HID_CLASS); // bInterfaceClass = HID
+        APP_USBD_CLASS_DESCRIPTOR_WRITE(p_mouse->specific.inst.hid_inst.subclass_boot); // bInterfaceSubclass (Boot Interface)
+        APP_USBD_CLASS_DESCRIPTOR_WRITE(p_mouse->specific.inst.hid_inst.protocol); // bInterfaceProtocol
+        APP_USBD_CLASS_DESCRIPTOR_WRITE(0x00); // iInterface
+
+        /* HID DESCRIPTOR */
+        APP_USBD_CLASS_DESCRIPTOR_WRITE(0x09); // bLength
+        APP_USBD_CLASS_DESCRIPTOR_WRITE(APP_USBD_HID_DESCRIPTOR_HID);  // bDescriptorType = HID
+        APP_USBD_CLASS_DESCRIPTOR_WRITE(LSB_16(APP_USBD_HID_BCD_VER)); // bcdHID LSB
+        APP_USBD_CLASS_DESCRIPTOR_WRITE(MSB_16(APP_USBD_HID_BCD_VER)); // bcdHID MSB
+        APP_USBD_CLASS_DESCRIPTOR_WRITE(APP_USBD_HID_COUNTRY_NOT_SUPPORTED); // bCountryCode
+        APP_USBD_CLASS_DESCRIPTOR_WRITE(hid_mouse_get_class_descriptors_count(p_inst)); // bNumDescriptors
+
+        static uint8_t class_desc_cnt = 0;
+        class_desc_cnt = hid_mouse_get_class_descriptors_count(p_inst);
+        static uint8_t  j              = 0;
+        static uint16_t class_desc_len = 0;
+
+        for (j = 0; j < class_desc_cnt; j++)
+        {
+            APP_USBD_CLASS_DESCRIPTOR_WRITE(hid_mouse_get_class_descriptors_type(p_inst, j)); // bDescriptorType
+
+            class_desc_len = hid_mouse_get_class_descriptors_length(p_inst, j);
+            APP_USBD_CLASS_DESCRIPTOR_WRITE(LSB_16(class_desc_len)); // wDescriptorLength LSB
+            APP_USBD_CLASS_DESCRIPTOR_WRITE(MSB_16(class_desc_len)); // wDescriptorLength MSB
+        }
+
+        static uint8_t endpoints = 0;
+        endpoints = app_usbd_class_iface_ep_count_get(p_cur_iface);
+
+        for (j = 0; j < endpoints; j++)
+        {
+            /* ENDPOINT DESCRIPTOR */
+            APP_USBD_CLASS_DESCRIPTOR_WRITE(0x07); // bLength
+            APP_USBD_CLASS_DESCRIPTOR_WRITE(APP_USBD_DESCRIPTOR_ENDPOINT); // bDescriptorType = Endpoint
+
+            static app_usbd_class_ep_conf_t const * p_cur_ep = NULL;
+            p_cur_ep = app_usbd_class_iface_ep_get(p_cur_iface, j);
+            APP_USBD_CLASS_DESCRIPTOR_WRITE(app_usbd_class_ep_address_get(p_cur_ep)); // bEndpointAddress
+            APP_USBD_CLASS_DESCRIPTOR_WRITE(APP_USBD_DESCRIPTOR_EP_ATTR_TYPE_INTERRUPT); // bmAttributes
+            APP_USBD_CLASS_DESCRIPTOR_WRITE(LSB_16(NRF_DRV_USBD_EPSIZE)); // wMaxPacketSize LSB
+            APP_USBD_CLASS_DESCRIPTOR_WRITE(MSB_16(NRF_DRV_USBD_EPSIZE)); // wMaxPacketSize MSB
+            APP_USBD_CLASS_DESCRIPTOR_WRITE(p_mouse->specific.inst.hid_inst.p_ep_interval[j]); // bInterval
+        }
+    }
+
+    APP_USBD_CLASS_DESCRIPTOR_END();
+}
+
+
+ret_code_t hid_mouse_on_set_protocol(app_usbd_hid_mouse_t const * p_mouse, app_usbd_hid_user_event_t ev)
+{
+    app_usbd_hid_mouse_ctx_t * p_mouse_ctx = hid_mouse_ctx_get(p_mouse);
+    if (ev == APP_USBD_HID_USER_EVT_SET_BOOT_PROTO)
+    {
+        p_mouse_ctx->hid_ctx.selected_protocol = APP_USBD_HID_PROTO_BOOT;
+    }
+    else if (ev == APP_USBD_HID_USER_EVT_SET_REPORT_PROTO)
+    {
+        p_mouse_ctx->hid_ctx.selected_protocol = APP_USBD_HID_PROTO_REPORT;
+    }
+    else
+    {
+        return NRF_ERROR_NOT_SUPPORTED;
+    }
+    return NRF_SUCCESS;
+}
+
+
+static ret_code_t hid_mouse_on_idle(app_usbd_class_inst_t const * p_inst, uint8_t report_id)
+{
+    UNUSED_PARAMETER(report_id);
+    app_usbd_hid_mouse_t const * p_mouse = (app_usbd_hid_mouse_t const *)p_inst;
+    nrf_drv_usbd_ep_t ep_addr = app_usbd_hid_epin_addr_get(p_inst);
+    app_usbd_hid_mouse_ctx_t    * p_mouse_ctx = hid_mouse_ctx_get(p_mouse);
+    app_usbd_hid_state_flag_clr(&p_mouse_ctx->hid_ctx, APP_USBD_HID_STATE_FLAG_TRANS_IN_PROGRESS);
+
+    app_usbd_hid_report_buffer_t const * p_rep_buffer = hid_mouse_rep_buffer_get(p_mouse);
+
+    uint8_t * p_buff = p_rep_buffer->p_buff;
+
+    /* Button state */
+    p_buff[0] = p_mouse_ctx->button_state;
+
+    /* Axis movement is skipped in idle report */
+    p_buff[1] = 0;
+    p_buff[2] = 0;
+    p_buff[3] = 0;
+
+    NRF_DRV_USBD_TRANSFER_IN(transfer, p_rep_buffer->p_buff, p_rep_buffer->size);
+
+    ret_code_t ret;
+    CRITICAL_REGION_ENTER();
+    ret = app_usbd_ep_transfer(ep_addr, &transfer);
+    if (ret == NRF_SUCCESS)
+    {
+        app_usbd_hid_state_flag_set(&p_mouse_ctx->hid_ctx,
+                                    APP_USBD_HID_STATE_FLAG_TRANS_IN_PROGRESS);
+    }
+    CRITICAL_REGION_EXIT();
+    
+    return NRF_SUCCESS;
+}
+
+/** @} */
+
+const app_usbd_hid_methods_t app_usbd_hid_mouse_methods = {
+    .on_get_report              = hid_mouse_on_get_report,
+    .on_set_report              = hid_mouse_on_set_report,
+    .ep_transfer_in             = hid_mouse_ep_transfer_in,
+    .ep_transfer_out            = NULL,
+    .subclass_count             = hid_mouse_get_class_descriptors_count,
+    .subclass_length            = hid_mouse_get_class_descriptors_length,
+    .subclass_data              = hid_mouse_get_class_descriptors_data,
+    .on_idle                    = hid_mouse_on_idle,
+};
+
+const app_usbd_class_methods_t app_usbd_hid_mouse_class_methods = {
+    .event_handler            = hid_mouse_event_handler,
+    .feed_descriptors         = hid_mouse_feed_descriptors,
+};
+
+#endif //NRF_MODULE_ENABLED(APP_USBD_HID_MOUSE)

components/libraries/usbd/class/hid/mouse/app_usbd_hid_mouse.h

@@ -0,0 +1,204 @@
+/**
+ * Copyright (c) 2017 - 2020, 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.
+ *
+ */
+#ifndef APP_USBD_HID_MOUSE_H__
+#define APP_USBD_HID_MOUSE_H__
+
+#include <stdint.h>
+#include <stdbool.h>
+
+#include "nrf_drv_usbd.h"
+#include "app_usbd_class_base.h"
+#include "app_usbd_hid_types.h"
+#include "app_usbd_hid.h"
+#include "app_usbd.h"
+#include "app_usbd_core.h"
+#include "app_usbd_descriptor.h"
+#include "app_usbd_hid_mouse_desc.h"
+#include "app_usbd_hid_mouse_internal.h"
+
+/**
+ * @defgroup app_usbd_hid_mouse USB HID mouse
+ * @ingroup app_usbd_hid
+ *
+ * @brief @tagAPI52840 Module with types, definitions, and API used by the HID mouse class.
+ * @{
+ */
+
+#ifdef DOXYGEN
+/**
+ * @brief HID mouse class instance type.
+ *
+ * @ref APP_USBD_CLASS_TYPEDEF
+ */
+typedef struct { } app_usbd_hid_mouse_t;
+#else
+/*lint -save -e10 -e26 -e123 -e505 */
+APP_USBD_CLASS_TYPEDEF(app_usbd_hid_mouse,                      \
+            APP_USBD_HID_MOUSE_CONFIG(0, NRF_DRV_USBD_EPIN1),   \
+            APP_USBD_HID_MOUSE_INSTANCE_SPECIFIC_DEC,           \
+            APP_USBD_HID_MOUSE_DATA_SPECIFIC_DEC                \
+);
+/*lint -restore*/
+#endif
+
+/**
+ * @brief Global definition macro of app_usbd_hid_mouse_t class.
+ *
+ * @param instance_name     Name of global instance.
+ * @param interface_number  Unique interface number.
+ * @param endpoint          Input endpoint (@ref nrf_drv_usbd_ep_t).
+ * @param bcnt              Mouse button count (from 1 to 8).
+ * @param user_ev_handler   User event handler (optional).
+ * @param subclass_boot     Subclass boot (@ref app_usbd_hid_subclass_t).
+ *
+ * @note This macro is just simplified version of @ref APP_USBD_HID_MOUSE_GLOBAL_DEF_INTERNAL.
+ *
+ * @code
+   APP_USBD_HID_MOUSE_GLOBAL_DEF(my_awesome_mouse, 0, NRF_DRV_USBD_EPIN1, 3, NULL);
+ * @endcode
+ */
+#define APP_USBD_HID_MOUSE_GLOBAL_DEF(instance_name,                                                    \
+                                      interface_number,                                                 \
+                                      endpoint,                                                         \
+                                      bcnt,                                                             \
+                                      user_ev_handler,                                                  \
+                                      subclass_boot)                                                    \
+    APP_USBD_HID_GENERIC_SUBCLASS_REPORT_DESC(mouse_desc, APP_USBD_HID_MOUSE_REPORT_DSC_BUTTON(bcnt));  \
+    static const app_usbd_hid_subclass_desc_t * mouse_descs[] = {&mouse_desc};                          \
+    APP_USBD_HID_MOUSE_GLOBAL_DEF_INTERNAL(instance_name,                                               \
+                                           interface_number,                                            \
+                                           endpoint,                                                    \
+                                           bcnt,                                                        \
+                                           user_ev_handler,                                             \
+                                           subclass_boot)
+
+/**
+ * @brief Helper function to get class instance from HID mouse internals.
+ *
+ * @param[in] p_mouse Mouse instance (declared by @ref APP_USBD_HID_MOUSE_GLOBAL_DEF).
+ *
+ * @return Base class instance.
+ */
+static inline app_usbd_class_inst_t const *
+app_usbd_hid_mouse_class_inst_get(app_usbd_hid_mouse_t const * p_mouse)
+{
+    return &p_mouse->base;
+}
+
+/**
+ * @brief Helper function to get HID mouse from base class instance.
+ *
+ * @param[in] p_inst Base class instance.
+ *
+ * @return HID mouse class handle.
+ */
+static inline app_usbd_hid_mouse_t const *
+app_usbd_hid_mouse_class_get(app_usbd_class_inst_t const * p_inst)
+{
+    return (app_usbd_hid_mouse_t const *)p_inst;
+}
+
+/**
+ * @brief Move mouse X axis.
+ *
+ * @param[in] p_mouse Mouse instance (declared by @ref APP_USBD_HID_MOUSE_GLOBAL_DEF).
+ * @param[in] offset  Relative mouse position: allowed full int8_t range.
+ *
+ * @return Standard error code.
+ */
+ret_code_t app_usbd_hid_mouse_x_move(app_usbd_hid_mouse_t const * p_mouse, int8_t offset);
+
+/**
+ * @brief Move mouse Y axis.
+ *
+ * @param[in] p_mouse Mouse instance (declared by @ref APP_USBD_HID_MOUSE_GLOBAL_DEF).
+ * @param[in] offset  Relative mouse position: allowed full int8_t range.
+ *
+ * @return Standard error code.
+ */
+ret_code_t app_usbd_hid_mouse_y_move(app_usbd_hid_mouse_t const * p_mouse, int8_t offset);
+
+/**
+ * @brief Move mouse scroll.
+ *
+ * @param[in] p_mouse Mouse instance (declared by @ref APP_USBD_HID_MOUSE_GLOBAL_DEF).
+ * @param[in] offset  Relative mouse position: allowed full int8_t range.
+ *
+ * @return Standard error code.
+ */
+ret_code_t app_usbd_hid_mouse_scroll_move(app_usbd_hid_mouse_t const * p_mouse, int8_t offset);
+
+/**
+ * @brief Set mouse button state.
+ *
+ * @param[in] p_mouse    Mouse instance (declared by @ref APP_USBD_HID_MOUSE_GLOBAL_DEF).
+ * @param[in] button_id  Button number (0...7).
+ * @param[in] state      Button state: true -> PRESSED, false -> RELEASED.
+ *
+ * @return Standard error code.
+ */
+ret_code_t app_usbd_hid_mouse_button_state(app_usbd_hid_mouse_t const * p_mouse,
+                                           uint8_t button_id,
+                                           bool state);
+
+/**
+ * @brief Function handling SET_PROTOCOL command.
+ *
+ *
+ * @param[in] p_mouse       Mouse instance.
+ * @param[in] ev            User event.
+ *
+ * @return Standard error code.
+ */
+ret_code_t hid_mouse_on_set_protocol(app_usbd_hid_mouse_t const * p_mouse,
+                                     app_usbd_hid_user_event_t ev);
+
+/**
+ * @brief Function that clears HID mouse buffers and sends an empty report.
+ *
+ * @param[in] p_inst Base class instance.
+ *
+ * @return Standard error code.
+ */
+ret_code_t hid_mouse_clear_buffer(app_usbd_class_inst_t const * p_inst);
+
+/** @} */
+
+#endif /* APP_USBD_HID_MOUSE_H__ */

components/libraries/usbd/class/hid/mouse/app_usbd_hid_mouse_desc.h

@@ -0,0 +1,117 @@
+/**
+ * Copyright (c) 2016 - 2020, 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.
+ *
+ */
+#ifndef APP_USBD_HID_MOUSE_DESC_H__
+#define APP_USBD_HID_MOUSE_DESC_H__
+
+/**
+ * @defgroup app_usbd_hid_mouse_desc USB HID mouse descriptors
+ * @ingroup app_usbd_hid_mouse
+ *
+ * @brief @tagAPI52840 Module with types, definitions, and API used by the HID mouse class.
+ * @{
+ */
+
+/**
+ * @brief Initializer of interface descriptor for HID mouse class.
+ *
+ * @param interface_number Interface number.
+ */
+#define APP_USBD_HID_MOUSE_INTERFACE_DSC(interface_number)      \
+        APP_USBD_HID_INTERFACE_DSC(interface_number,            \
+                                   1,                           \
+                                   APP_USBD_HID_SUBCLASS_BOOT,  \
+                                   APP_USBD_HID_PROTO_MOUSE)
+
+/**
+ * @brief Initializer of HID descriptor for HID mouse class.
+ *
+ * @param ... Descriptor list.
+ */
+#define APP_USBD_HID_MOUSE_HID_DSC(...)     \
+        APP_USBD_HID_HID_DSC(__VA_ARGS__)
+
+/**
+ * @brief Initializer of endpoint descriptor for HID mouse class.
+ *
+ * @param endpoint_number Endpoint number.
+ */
+#define APP_USBD_HID_MOUSE_EP_DSC(endpoint_number)  \
+        APP_USBD_HID_EP_DSC(endpoint_number, 8, 1)
+
+
+
+/**
+ * @brief Example of USB HID mouse report descriptor for n button mouse.
+ *
+ * @param bcnt  Button count. Allowed values from 1 to 8.
+ */
+#define APP_USBD_HID_MOUSE_REPORT_DSC_BUTTON(bcnt) {                \
+    0x05, 0x01,       /* Usage Page (Generic Desktop),       */     \
+    0x09, 0x02,       /* Usage (Mouse),                      */     \
+    0xA1, 0x01,       /*  Collection (Application),          */     \
+    0x09, 0x01,       /*   Usage (Pointer),                  */     \
+    0xA1, 0x00,       /*  Collection (Physical),             */     \
+    0x05, 0x09,       /*     Usage Page (Buttons),           */     \
+    0x19, 0x01,       /*     Usage Minimum (01),             */     \
+    0x29, bcnt,       /*     Usage Maximum (bcnt),           */     \
+    0x15, 0x00,       /*     Logical Minimum (0),            */     \
+    0x25, 0x01,       /*     Logical Maximum (1),            */     \
+    0x75, 0x01,       /*     Report Size (1),                */     \
+    0x95, bcnt,       /*     Report Count (bcnt),            */     \
+    0x81, 0x02,       /*     Input (Data, Variable, Absolute)*/     \
+    0x75, (8-(bcnt)), /*     Report Size (8-(bcnt)),         */     \
+    0x95, 0x01,       /*     Report Count (1),               */     \
+    0x81, 0x01,       /*     Input (Constant),               */     \
+    0x05, 0x01,       /*     Usage Page (Generic Desktop),   */     \
+    0x09, 0x30,       /*     Usage (X),                      */     \
+    0x09, 0x31,       /*     Usage (Y),                      */     \
+    0x09, 0x38,       /*     Usage (Scroll),                 */     \
+    0x15, 0x81,       /*     Logical Minimum (-127),         */     \
+    0x25, 0x7F,       /*     Logical Maximum (127),          */     \
+    0x75, 0x08,       /*     Report Size (8),                */     \
+    0x95, 0x03,       /*     Report Count (3),               */     \
+    0x81, 0x06,       /*     Input (Data, Variable, Relative)*/     \
+    0xC0,         /*  End Collection,                        */     \
+    0xC0,         /* End Collection                          */     \
+}
+
+ /** @} */
+
+#endif /* APP_USBD_HID_MOUSE_DESC_H__ */

components/libraries/usbd/class/hid/mouse/app_usbd_hid_mouse_internal.h

@@ -0,0 +1,190 @@
+/**
+ * Copyright (c) 2017 - 2020, 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.
+ *
+ */
+#ifndef APP_USBD_HID_MOUSE_INTERNAL_H__
+#define APP_USBD_HID_MOUSE_INTERNAL_H__
+
+/**
+ * @defgroup app_usbd_hid_mouse_internals USB HID mouse internals
+ * @ingroup app_usbd_hid_mouse
+ *
+ * @brief @tagAPI52840 Module with types, definitions, and API used by the HID mouse class.
+ * @{
+ */
+
+/**
+ * @brief Forward declaration of HID mouse class type.
+ */
+APP_USBD_CLASS_FORWARD(app_usbd_hid_mouse);
+
+
+/**
+ * @brief HID mouse part of class instance data.
+ */
+typedef struct {
+    app_usbd_hid_inst_t hid_inst;      //!< HID instance data.
+    const uint8_t       button_count;  //!< Number of buttons mouse specific.
+} app_usbd_hid_mouse_inst_t;
+
+/**
+ * @brief HID mouse context.
+ */
+typedef struct {
+    app_usbd_hid_ctx_t hid_ctx; //!< HID class context.
+
+    int16_t acc_x_axis;         //!< Mouse specific. Accumulated x axis offset.
+    int16_t acc_y_axis;         //!< Mouse specific. Accumulated y axis offset.
+    int16_t acc_scroll;         //!< Mouse specific. Accumulated scroll offset.
+    uint8_t button_state;       //!< Mouse specific. Actual button state. Bitfield of maximum 8 buttons states.
+    uint8_t report_buff[4];
+} app_usbd_hid_mouse_ctx_t;
+
+
+/**
+ * @brief HID mouse configuration macro.
+ *
+ * Used by @ref APP_USBD_HID_MOUSE_GLOBAL_DEF.
+ *
+ */
+#define APP_USBD_HID_MOUSE_CONFIG(iface, ep) ((iface, ep))
+
+
+/**
+ * @brief Specific class constant data for HID mouse class.
+ */
+#define APP_USBD_HID_MOUSE_INSTANCE_SPECIFIC_DEC app_usbd_hid_mouse_inst_t inst;
+
+/**
+ * @brief Specific class data for HID mouse class.
+ */
+#define APP_USBD_HID_MOUSE_DATA_SPECIFIC_DEC app_usbd_hid_mouse_ctx_t ctx;
+
+
+/**
+ * @brief HID mouse descriptors config macro
+ *
+ * @ref app_usbd_hid_mouse_inst_t
+ *
+ */
+#define APP_USBD_HID_MOUSE_DSC_CONFIG(interface_number, endpoint, rep_desc) {  \
+        APP_USBD_HID_MOUSE_INTERFACE_DSC(interface_number)                     \
+        APP_USBD_HID_MOUSE_HID_DSC(rep_desc)                                   \
+        APP_USBD_HID_MOUSE_EP_DSC(endpoint)                                    \
+}
+
+/**
+ * @brief Default interval value
+ *
+ */
+#define APP_USBD_HID_MOUSE_DEFAULT_INTERVAL 0x01
+
+#define APP_USBD_HID_MOUSE_INTERVAL(ep)   \
+(APP_USBD_EXTRACT_INTERVAL_FLAG(ep) ? APP_USBD_EXTRACT_INTERVAL_VALUE(ep) : APP_USBD_HID_MOUSE_DEFAULT_INTERVAL)
+
+
+/**
+ * @brief Configure internal part of HID mouse instance.
+ *
+ * @param report_buff_in    Input report buffers array.
+ * @param report_buff_out   Output report buffer.
+ * @param user_ev_handler   User event handler.
+ * @param bcnt              Mouse button count.
+ * @param subclass_boot     Subclass boot (@ref app_usbd_hid_subclass_t).
+ * @param endpoint_list     List of endpoints and intervals
+ */
+#define APP_USBD_HID_MOUSE_INST_CONFIG(report_buff_in,                      \
+                                       report_buff_out,                     \
+                                       user_ev_handler,                     \
+                                       bcnt,                                \
+                                       subclass_boot,                       \
+                                       endpoint_list)                       \
+    .inst = {                                                               \
+        .hid_inst = APP_USBD_HID_INST_CONFIG(mouse_descs,                   \
+                                             subclass_boot,                 \
+                                             APP_USBD_HID_PROTO_MOUSE,      \
+                                             report_buff_in,                \
+                                             report_buff_out,               \
+                                             NULL,                          \
+                                             user_ev_handler,               \
+                                             &app_usbd_hid_mouse_methods,   \
+                                             endpoint_list),                \
+        .button_count = bcnt,                                               \
+    }
+
+/**
+ * @brief Public HID mouse interface.
+ */
+extern const app_usbd_hid_methods_t app_usbd_hid_mouse_methods;
+
+/**
+ * @brief Public HID mouse class interface.
+ */
+extern const app_usbd_class_methods_t app_usbd_hid_mouse_class_methods;
+
+/**
+ * @brief Global definition of app_usbd_hid_mouse_t class.
+ *
+ * @ref  APP_USBD_HID_MOUSE_GLOBAL_DEF
+ */
+/*lint -esym( 40, APP_USBD_HID_MOUSE_INTERVAL) */
+#define APP_USBD_HID_MOUSE_GLOBAL_DEF_INTERNAL(instance_name,                                        \
+                                               interface_number,                                     \
+                                               endpoint,                                             \
+                                               bcnt,                                                 \
+                                               user_ev_handler,                                      \
+                                               subclass_boot)                                        \
+    static app_usbd_hid_report_buffer_t  CONCAT_2(instance_name, _in)[1];                            \
+    static uint8_t CONCAT_2(instance_name, _ep) = {MACRO_MAP(APP_USBD_HID_MOUSE_INTERVAL,endpoint)}; \
+    APP_USBD_CLASS_INST_GLOBAL_DEF(                                                                  \
+        instance_name,                                                                               \
+        app_usbd_hid_mouse,                                                                          \
+        &app_usbd_hid_mouse_class_methods,                                                           \
+        APP_USBD_HID_MOUSE_CONFIG(interface_number, endpoint),                                       \
+        (APP_USBD_HID_MOUSE_INST_CONFIG(CONCAT_2(instance_name, _in),                                \
+                                        NULL,                                                        \
+                                        user_ev_handler,                                             \
+                                        bcnt,                                                        \
+                                        subclass_boot,                                               \
+                                        &CONCAT_2(instance_name, _ep)))                              \
+    )
+
+
+/** @} */
+
+#endif /* APP_USBD_HID_MOUSE_INTERNAL_H__ */

components/libraries/usbd/class/msc/app_usbd_msc.h

@@ -0,0 +1,193 @@
+/**
+ * Copyright (c) 2016 - 2020, 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.
+ *
+ */
+#ifndef APP_USBD_MSC_H__
+#define APP_USBD_MSC_H__
+
+#include <stdint.h>
+#include <stdbool.h>
+
+#include "nrf_drv_usbd.h"
+#include "nrf_block_dev.h"
+#include "app_usbd_class_base.h"
+#include "app_usbd.h"
+#include "app_usbd_core.h"
+#include "app_usbd_descriptor.h"
+
+#include "app_usbd_msc_types.h"
+#include "app_usbd_msc_desc.h"
+#include "app_usbd_msc_scsi.h"
+#include "app_usbd_msc_internal.h"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @defgroup app_usbd_msc USB MSC class
+ * @ingroup app_usbd
+ *
+ * @brief @tagAPI52840 Module with types, definitions, and API used by the USB MSC class.
+ *
+ * @details References:
+ * - "Universal Serial Bus Mass Storage Class, Specification Overview,"
+ *   Revision 1.2,  USB Implementer's Forum, June 23, 2003.
+ * - "Universal Serial Bus Mass Storage Class, Bulk-Only Transport,"
+ *   Revision 1.0, USB Implementer's Forum, September 31, 1999.
+ *
+ * @{
+ */
+
+#ifdef DOXYGEN
+/**
+ * @brief Mass storage class instance type.
+ *
+ * @ref APP_USBD_CLASS_TYPEDEF
+ */
+typedef struct { } app_usbd_msc_t;
+#else
+/*lint -save -e10 -e26 -e123 -e505 */
+APP_USBD_CLASS_TYPEDEF(app_usbd_msc,                                                   \
+            APP_USBD_MSC_CONFIG(0, (NRF_DRV_USBD_EPIN1, NRF_DRV_USBD_EPOUT1)),         \
+            APP_USBD_MSC_INSTANCE_SPECIFIC_DEC,                                        \
+            APP_USBD_MSC_DATA_SPECIFIC_DEC                                             \
+);
+#endif
+
+/*lint -restore*/
+
+
+/*lint -save -e407 */
+
+/**
+ * @brief Events passed to user event handler.
+ *
+ * @note Example prototype of user event handler:
+ *
+ * void msc_user_ev_handler(app_usbd_class_inst_t const * p_inst,
+ *                          app_usbd_msc_user_event_t     event);
+ */
+typedef enum app_usbd_msc_user_event_e {
+    APP_USBD_MSC_USER_EVT_NONE,        /**< Dummy event to satisfy compilers. */
+} app_usbd_msc_user_event_t;
+
+/*lint -restore*/
+
+/**
+ * @brief Helper macro for defining MSC endpoints.
+ *
+ * @param in_number     Input endpoint number.
+ * @param out_number    Output endpoint number.
+ * */
+#define APP_USBD_MSC_ENDPOINT_LIST(in_number, out_number) (    \
+        CONCAT_2(NRF_DRV_USBD_EPIN, in_number),                \
+        CONCAT_2(NRF_DRV_USBD_EPOUT, out_number)               \
+)
+
+/**
+ * @brief Global definition of app_usbd_msc_t class.
+ *
+ * @param instance_name             Name of global instance.
+ * @param interface_number          Unique interface number.
+ * @param user_ev_handler           User event handler (optional).
+ * @param endpoint_list             Input endpoint list (@ref nrf_drv_usbd_ep_t).
+ * @param blockdev_list             Block device list.
+ * @param workbuffer_size           Work buffer size (need to fit into all block devices from
+ *                                  block device list).
+ *
+ * @note This macro is just simplified version of @ref APP_USBD_MSC_GLOBAL_DEF_INTERNAL
+ *
+ */
+#define APP_USBD_MSC_GLOBAL_DEF(instance_name,              \
+                                interface_number,           \
+                                user_ev_handler,            \
+                                endpoint_list,              \
+                                blockdev_list,              \
+                                workbuffer_size)            \
+        APP_USBD_MSC_GLOBAL_DEF_INTERNAL(instance_name,     \
+                                         interface_number,  \
+                                         user_ev_handler,   \
+                                         endpoint_list,     \
+                                         blockdev_list,     \
+                                         workbuffer_size)
+
+
+/**
+ * @@brief Helper function to get class instance from MSC.
+ *
+ * @param[in] p_msc     MSC instance (declared by @ref APP_USBD_MSC_GLOBAL_DEF).
+ *
+ * @return Base class instance.
+ */
+static inline app_usbd_class_inst_t const *
+app_usbd_msc_class_inst_get(app_usbd_msc_t const * p_msc)
+{
+    return &p_msc->base;
+}
+
+/**
+ * @brief Helper function to get MSC from base class instance.
+ *
+ * @param[in] p_inst Base class instance.
+ *
+ * @return MSC class handle.
+ */
+static inline app_usbd_msc_t const * app_usbd_msc_class_get(app_usbd_class_inst_t const * p_inst)
+{
+    return (app_usbd_msc_t const *)p_inst;
+}
+
+/**
+ * @brief Synchronization of all block devices pined to MSC.
+ *
+ * @param[in] p_msc     MSC instance (declared by @ref APP_USBD_MSC_GLOBAL_DEF).
+ *
+ * @retval true  All block devices flushed data.
+ * @retval false At least one block device has not flushed data.
+ */
+bool app_usbd_msc_sync(app_usbd_msc_t const * p_msc);
+
+/** @} */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* APP_USBD_MSC_H__ */

components/libraries/usbd/class/msc/app_usbd_msc_desc.h

@@ -0,0 +1,104 @@
+/**
+ * Copyright (c) 2016 - 2020, 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.
+ *
+ */
+#ifndef APP_USBD_MSC_DESC_H__
+#define APP_USBD_MSC_DESC_H__
+
+#include "app_usbd_descriptor.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @defgroup app_usbd_msc_desc USB MSC descriptors
+ * @ingroup app_usbd_msc
+ *
+ * @brief @tagAPI52840 Descriptors for the USB MSC class.
+ * @{
+ */
+
+/**
+ * @brief Initializer of interface descriptor for MSC class.
+ *
+ * @param interface_number Interface number.
+ * @param subclass         Subclass, @ref app_usbd_msc_subclass_t
+ * @param protocol         Protocol, @ref app_usbd_msc_protocol_t
+ * */
+#define APP_USBD_MSC_INTERFACE_DSC(interface_number, subclass, protocol)                \
+    /*.bLength =            */ sizeof(app_usbd_descriptor_iface_t),                     \
+    /*.bDescriptorType =    */ APP_USBD_DESCRIPTOR_INTERFACE,                           \
+    /*.bInterfaceNumber =   */ interface_number,                                        \
+    /*.bAlternateSetting =  */ 0x00,                                                    \
+    /*.bNumEndpoints =      */ 2,                                                       \
+    /*.bInterfaceClass =    */ APP_USBD_MSC_CLASS,                                      \
+    /*.bInterfaceSubClass = */ subclass,                                                \
+    /*.bInterfaceProtocol = */ protocol,                                                \
+    /*.iInterface = 0,      */ 0x00,                                                    \
+
+
+/**
+ * @brief Initializer of endpoint descriptors for MSC class.
+ *
+ * @param endpoint_in   IN endpoint.
+ * @param endpoint_out  OUT endpoint.
+ * @param ep_size       Endpoint size.
+ * */
+#define APP_USBD_MSC_EP_DSC(endpoint_in, endpoint_out, ep_size)               \
+    /*.bLength =          */ sizeof(app_usbd_descriptor_ep_t),                \
+    /*.bDescriptorType =  */ APP_USBD_DESCRIPTOR_ENDPOINT,                    \
+    /*.bEndpointAddress = */ endpoint_in,                                     \
+    /*.bmAttributes =     */ APP_USBD_DESCRIPTOR_EP_ATTR_TYPE_BULK,           \
+    /*.wMaxPacketSize =   */ APP_USBD_U16_TO_RAW_DSC(ep_size),                \
+    /*.bInterval =        */ 0,                                               \
+    /*.bLength =          */ sizeof(app_usbd_descriptor_ep_t),                \
+    /*.bDescriptorType =  */ APP_USBD_DESCRIPTOR_ENDPOINT,                    \
+    /*.bEndpointAddress = */ endpoint_out,                                    \
+    /*.bmAttributes =     */ APP_USBD_DESCRIPTOR_EP_ATTR_TYPE_BULK,           \
+    /*.wMaxPacketSize =   */ APP_USBD_U16_TO_RAW_DSC(ep_size),                \
+    /*.bInterval =        */ 0,                                               \
+
+
+/** @} */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* APP_USBD_MSC_DESC_H__ */

components/libraries/usbd/class/msc/app_usbd_msc_internal.h

@@ -0,0 +1,314 @@
+/**
+ * Copyright (c) 2016 - 2020, 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.
+ *
+ */
+#ifndef APP_USBD_MSC_INTERNAL_H__
+#define APP_USBD_MSC_INTERNAL_H__
+
+#include "app_util.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @defgroup app_usbd_msc_internals USB MSC internals
+ * @ingroup app_usbd_msc
+ *
+ * @brief @tagAPI52840 Internals of the USB MSC class.
+ * @{
+ */
+
+/**
+ * @brief Minimal serial string descriptor length.
+ * */
+#define APP_USBD_MSC_MINIMAL_SERIAL_STRING_SIZE (12 + 1)
+
+/**
+ * @brief Number of block buffers
+ *
+ * Number of buffers used for the transfer.
+ * The library is designed to work with double buffering.
+ * Not tested with other configuration.
+ */
+#define APP_USBD_MSC_BUFFER_CNT 2
+
+/**
+ * @brief Create the name of the block buffer
+ *
+ * @param instance_name The name of the MSC instance
+ *
+ * @return The name of the block buffer used with the instance
+ */
+#define APP_USBD_MSC_BUFFER_NAME(instance_name) CONCAT_2(instance_name, _block)
+
+/**
+ * @brief Create the name of the block device list
+ *
+ * @param instance_name The name of the MSC instance
+ *
+ * @return The name of the block device list
+ */
+#define APP_USBD_MSC_BLKDEVS_NAME(instance_name) CONCAT_2(instance_name, _blkdevs)
+
+/**
+ * @brief Forward declaration of Mass Storage Class type.
+ *
+ */
+APP_USBD_CLASS_FORWARD(app_usbd_msc);
+
+/*lint -save -e165*/
+/**
+ * @brief Forward declaration of @ref app_usbd_msc_user_event_e
+ *
+ */
+enum app_usbd_msc_user_event_e;
+
+/*lint -restore*/
+
+/**
+ * @brief User event handler.
+ *
+ * @param[in] p_inst    Class instance.
+ * @param[in] event     User event.
+ *
+ * */
+typedef void (*app_usbd_msc_user_ev_handler_t)(app_usbd_class_inst_t const *  p_inst,
+                                               enum app_usbd_msc_user_event_e event);
+
+/**
+ * @brief MSC part of class instance data.
+ */
+typedef struct {
+    void *                         p_block_buff;     //!< Block buffer
+    size_t                         block_buff_size;  //!< Block buffer size (typically 512 bytes)
+    size_t                         block_buff_count; //!< Number of buffers (typically 2)
+
+    nrf_block_dev_t const **       pp_block_devs;    //!< Block devices list
+    size_t                         block_devs_count; //!< Block device list size
+
+    app_usbd_msc_user_ev_handler_t user_ev_handler;  //!< User event handler
+
+    app_usbd_msc_subclass_t        subclass;         //!< MSC subclass
+    app_usbd_msc_protocol_t        protocol;         //!< MSC protocol
+} app_usbd_msc_inst_t;
+
+/**
+ * @brief Internal module state.
+ */
+typedef enum {
+    APP_USBD_MSC_STATE_DISABLED,      /**< Internal module state DISABLED      */
+    APP_USBD_MSC_STATE_IDLE,          /**< Internal module state IDLE          */
+    APP_USBD_MSC_STATE_CBW,           /**< Internal module state CBW           */
+    APP_USBD_MSC_STATE_CMD_IN,        /**< Internal module state CMD_IN        */
+    APP_USBD_MSC_STATE_DATA_IN,       /**< Internal module state DATA_IN       */
+    APP_USBD_MSC_STATE_DATA_OUT,      /**< Internal module state DATA_OUT      */
+    APP_USBD_MSC_STATE_CSW,           /**< Internal module state CSW           */
+    APP_USBD_MSC_STATE_UNSUPPORTED,   /**< Internal module state UNSUPPORTED   */
+    APP_USBD_MSC_STATE_CBW_INVALID,   /**< Endpoint is stalled until
+                                       *   the command @ref APP_USBD_MSC_REQ_BULK_RESET */
+    APP_USBD_MSC_STATE_DEVICE_ERROR,  /**< Endpoint is stalled and it is required
+                                       *   to send PE error when clearing */
+} app_usbd_msc_state_t;
+
+/**
+ * @brief MSC context.
+ *
+ * */
+typedef struct {
+    app_usbd_msc_state_t state; //!< Internal module state
+
+    app_usbd_msc_cbw_t cbw;     //!< SCSI command block wrapper
+    app_usbd_msc_csw_t csw;     //!< SCSI Command status wrapper
+
+    /** @brief Currently processed command with data */
+    struct
+    {
+        /** @brief Buffer data */
+        struct
+        {
+            uint8_t rd_idx;     //!< Buffer read index
+            uint8_t d_count;    //!< Number of blocks inside the buffer ready to process
+            uint8_t a_count;    //!< Number of blocks allocated in the buffer
+        } buff;
+        /** @brief Currently transfered block */
+        struct
+        {
+            size_t   size_left;    //!< Number of bytes left to transfer
+            size_t   datalen_left; //!< Number of bytes left that was requested by the host
+            bool     pending;      //!< The flag marking the pending transfer
+            bool     abort;        //!< Something fails during reading - abort transfer and mark an error,
+                                   //!< Used for read access.
+        } transfer;
+        /** @brief The block currently processed by block device */
+        struct
+        {
+            uint8_t  lun;          //!< The logical unit for current transfer block
+            size_t   blk_size;     //!< The size of the block of the selected lun
+            size_t   size_left;    //!< Number of bytes left to be processed by block device
+            size_t   datalen_left; //!< Number of bytes left that was requested by the host
+            uint32_t blk_idx;      //!< Current block index
+            bool     pending;      //!< The flag marking the pending transfer
+            bool     abort;        //!< Something fails during transfer - abort processing and mark an error,
+                                   //!< Used for write access.
+        } process;
+    } current;
+
+    /** @brief SCSI response container*/
+    union {
+        app_usbd_scsi_cmd_inquiry_resp_t        inquiry;        //!< @ref APP_USBD_SCSI_CMD_INQUIRY response
+        app_usbd_scsi_cmd_requestsense_resp_t   requestsense;   //!< @ref APP_USBD_SCSI_CMD_REQUESTSENSE response
+        app_usbd_scsi_cmd_readcapacity10_resp_t readcapacity10; //!< @ref APP_USBD_SCSI_CMD_READCAPACITY10 response
+        app_usbd_scsi_cmd_modesense6_resp_t     modesense6;     //!< @ref APP_USBD_SCSI_CMD_MODESENSE6 response
+        app_usbd_scsi_cmd_modesense10_resp_t    modesense10;    //!< @ref APP_USBD_SCSI_CMD_MODESENSE10 response
+    } scsi_resp;
+
+    uint16_t blk_dev_init_mask;     //!< Block devices init mask
+} app_usbd_msc_ctx_t;
+
+
+/**
+ * @brief MSC configuration macro.
+ *
+ * Used by @ref APP_USBD_MSC_GLOBAL_DEF
+ *
+ * @param iface     Interface number.
+ * @param endpoints Endpoint list.
+ * */
+#define APP_USBD_MSC_CONFIG(iface, endpoints) ((iface, BRACKET_EXTRACT(endpoints)))
+
+
+/**
+ * @brief Specific class constant data for MSC.
+ *
+ * @ref app_usbd_msc_inst_t
+ */
+#define APP_USBD_MSC_INSTANCE_SPECIFIC_DEC app_usbd_msc_inst_t inst;
+
+/**
+ * @brief Configures MSC instance.
+ *
+ * @param p_devs             Block devices list that is array of pointers of @ref nrf_block_dev_t type.
+ * @param devs_cnt           Number of block devices connected.
+ * @param p_buff             Block buffer.
+ * @param block_size         Total size of the single block in the buffer.
+ * @param block_cnt          Number of available block buffers.
+ * @param user_event_handler User event handler.
+ */
+#define APP_USBD_MSC_INST_CONFIG(p_devs,                        \
+                                 devs_cnt,                      \
+                                 p_buff,                        \
+                                 block_size,                    \
+                                 block_cnt,                     \
+                                 user_event_handler)            \
+    .inst = {                                                   \
+         .pp_block_devs    = (p_devs),                          \
+         .block_devs_count = (devs_cnt),                        \
+         .p_block_buff     = (p_buff),                          \
+         .block_buff_size  = (block_size),                      \
+         .block_buff_count = (block_cnt),                       \
+         .user_ev_handler  = (user_event_handler),              \
+         .subclass         = APP_USBD_MSC_SUBCLASS_TRANSPARENT, \
+         .protocol         = APP_USBD_MSC_PROTOCOL_BULK,        \
+    }
+
+/**
+ * @brief Specific class data for MSC.
+ *
+ * @ref app_usbd_msc_ctx_t
+ * */
+#define APP_USBD_MSC_DATA_SPECIFIC_DEC app_usbd_msc_ctx_t ctx;
+
+
+/**
+ * @brief MSC descriptors config macro.
+ *
+ * @param interface_number Interface number.
+ * @param ...              Extracted endpoint list.
+ * */
+#define APP_USBD_MSC_DSC_CONFIG(interface_number, ...) {                 \
+        APP_USBD_MSC_INTERFACE_DSC(interface_number,                     \
+                                   APP_USBD_MSC_SUBCLASS_TRANSPARENT,    \
+                                   APP_USBD_MSC_PROTOCOL_BULK)           \
+        APP_USBD_MSC_EP_DSC(GET_VA_ARG_1(__VA_ARGS__),                   \
+                            GET_VA_ARG_1(GET_ARGS_AFTER_1(__VA_ARGS__)), \
+                            64)                                          \
+}
+
+/**
+ * @brief Public MSC class interface.
+ *
+ * */
+extern const app_usbd_class_methods_t app_usbd_msc_class_methods;
+
+/**
+ * @brief Global definition of mass storage class instance.
+ */
+#define APP_USBD_MSC_GLOBAL_DEF_INTERNAL(instance_name,                                 \
+                                         interface_number,                              \
+                                         user_ev_handler,                               \
+                                         endpoint_list,                                 \
+                                         blockdev_list,                                 \
+                                         workbuffer_size)                               \
+    static const nrf_block_dev_t * APP_USBD_MSC_BLKDEVS_NAME(instance_name)[] =         \
+                                   { BRACKET_EXTRACT(blockdev_list) };                  \
+    static uint32_t APP_USBD_MSC_BUFFER_NAME(instance_name)                             \
+        [APP_USBD_MSC_BUFFER_CNT * CEIL_DIV(workbuffer_size, sizeof(uint32_t))];        \
+    APP_USBD_CLASS_INST_GLOBAL_DEF(                                                     \
+        instance_name,                                                                  \
+        app_usbd_msc,                                                                   \
+        &app_usbd_msc_class_methods,                                                    \
+        APP_USBD_MSC_CONFIG(interface_number, endpoint_list),                           \
+        (APP_USBD_MSC_INST_CONFIG(APP_USBD_MSC_BLKDEVS_NAME(instance_name),             \
+                                  ARRAY_SIZE(APP_USBD_MSC_BLKDEVS_NAME(instance_name)), \
+                                  APP_USBD_MSC_BUFFER_NAME (instance_name),             \
+                                  sizeof(APP_USBD_MSC_BUFFER_NAME(instance_name))       \
+                                         / APP_USBD_MSC_BUFFER_CNT,                     \
+                                  APP_USBD_MSC_BUFFER_CNT,                              \
+                                  user_ev_handler))                                     \
+    )
+
+
+/** @} */
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* APP_USBD_MSC_INTERNAL_H__ */

components/libraries/usbd/class/msc/app_usbd_msc_scsi.h

@@ -0,0 +1,329 @@
+/**
+ * Copyright (c) 2016 - 2020, 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.
+ *
+ */
+#ifndef APP_USBD_MSC_SCSI_H__
+#define APP_USBD_MSC_SCSI_H__
+
+#include "app_util.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @defgroup app_usbd_msc_scsi USB MSC SCSI data structures
+ * @ingroup app_usbd_msc
+ *
+ * @brief @tagAPI52840 USB MSC SCSI data structures.
+ *
+ * @details Reference specifications:
+ * - "Reduced Block Commands (Revision 10a)"  American National Standard
+ *   for Information Technology, August 18, 1999
+ * - "SCSI Primary Commands - 4 (SPC-4),"  American National Standard
+ *   for Information Technology, July 19, 2008
+ * - "SCSI Block Commands -2 (SBC-2)," American National Standard
+ *   for Information Technology, November 13, 2004
+ * - NuttX source code - Real-time Operating System: http://nuttx.org/
+ *   Gregory Nutt <gnutt@nuttx.org>
+ *
+ * @{
+ */
+
+/**
+ * @brief SCSI command set.
+ *
+ * Mandatory (and some optional) commands required by SBC-2.
+ *
+ */
+typedef enum {
+    APP_USBD_SCSI_CMD_TESTUNITREADY       = 0x00, /**< Test unit ready.       */
+    APP_USBD_SCSI_CMD_REQUESTSENSE        = 0x03, /**< Request sense.         */
+    APP_USBD_SCSI_CMD_FORMAT_UNIT         = 0x04, /**< Format unit.           */
+    APP_USBD_SCSI_CMD_READ6               = 0x08, /**< Read 6.                */
+    APP_USBD_SCSI_CMD_WRITE6              = 0x0A, /**< Write 6.               */
+    APP_USBD_SCSI_CMD_INQUIRY             = 0x12, /**< Inquiry.               */
+    APP_USBD_SCSI_CMD_MODESELECT6         = 0x15, /**< Mode select 6.         */
+    APP_USBD_SCSI_CMD_MODESENSE6          = 0x1A, /**< Mode sense 6.          */
+    APP_USBD_SCSI_CMD_STARTSTOPUNIT       = 0x1B, /**< Start/stop unit.       */
+    APP_USBD_SCSI_CMD_SENDDIAGNOSTIC      = 0x1D, /**< Send diagnostic.       */
+    APP_USBD_SCSI_CMD_PREVENTMEDIAREMOVAL = 0x1E, /**< Prevent media removal. */
+    APP_USBD_SCSI_CMD_READCAPACITY10      = 0x25, /**< Read capacity 10.      */
+    APP_USBD_SCSI_CMD_READ10              = 0x28, /**< Read 10.               */
+    APP_USBD_SCSI_CMD_WRITE10             = 0x2A, /**< Write 10.              */
+    APP_USBD_SCSI_CMD_MODESELECT10        = 0x55, /**< Mode select 10.        */
+    APP_USBD_SCSI_CMD_MODESENSE10         = 0x5A, /**< Mode sense 10.         */
+} app_usbd_scsi_cmd_t;
+
+
+#pragma pack(push, 1)
+
+/**
+ * @brief Payload of @ref APP_USBD_SCSI_CMD_REQUESTSENSE command.
+ */
+typedef struct {
+    uint8_t opcode;        //!< @ref APP_USBD_SCSI_CMD_REQUESTSENSE
+    uint8_t flags;         //!< Flags
+    uint8_t reserved[2];   //!< Reserved
+    uint8_t alloclen;      //!< Allocation length
+    uint8_t control;       //!< Control
+} app_usbd_scsi_cmd_requestsense_t;
+
+#define APP_USBD_SCSI_CMD_REQSENSE_CODE_VALID          0x80 /**< @ref app_usbd_scsi_cmd_requestsense_resp_t::code */
+#define APP_USBD_SCSI_CMD_REQSENSE_CODE_CURRENT        0x70 /**< @ref app_usbd_scsi_cmd_requestsense_resp_t::code */
+#define APP_USBD_SCSI_CMD_REQSENSE_CODE_DEFERRED       0x71 /**< @ref app_usbd_scsi_cmd_requestsense_resp_t::code */
+#define APP_USBD_SCSI_CMD_REQSENSE_CODE_CURRENTDESC    0x72 /**< @ref app_usbd_scsi_cmd_requestsense_resp_t::code */
+#define APP_USBD_SCSI_CMD_REQSENSE_CODE_DEFERREDDESC   0x73 /**< @ref app_usbd_scsi_cmd_requestsense_resp_t::code */
+
+#define APP_USBD_SCSI_CMD_REQSENSE_FLAG_FILEMARK       0x80 /**< Bits 7 @ref app_usbd_scsi_cmd_requestsense_resp_t::flags */
+#define APP_USBD_SCSI_CMD_REQSENSE_FLAG_EOM            0x40 /**< Bits 6 @ref app_usbd_scsi_cmd_requestsense_resp_t::flags */
+#define APP_USBD_SCSI_CMD_REQSENSE_FLAG_ILI            0x20 /**< Bits 5 @ref app_usbd_scsi_cmd_requestsense_resp_t::flags */
+#define APP_USBD_SCSI_CMD_REQSENSE_FLAG_RESERVED       0x10 /**< Bits 4 @ref app_usbd_scsi_cmd_requestsense_resp_t::flags */
+
+#define APP_USBD_SCSI_CMD_REQSENSE_FLAG_NOSENSE        0x00 /**< Bits 3...0 @ref app_usbd_scsi_cmd_requestsense_resp_t::flags */
+#define APP_USBD_SCSI_CMD_REQSENSE_FLAG_RECOVEREDERROR 0x01 /**< Bits 3...0 @ref app_usbd_scsi_cmd_requestsense_resp_t::flags */
+#define APP_USBD_SCSI_CMD_REQSENSE_FLAG_NOTREADY       0x02 /**< Bits 3...0 @ref app_usbd_scsi_cmd_requestsense_resp_t::flags */
+#define APP_USBD_SCSI_CMD_REQSENSE_FLAG_MEDIUMERROR    0x03 /**< Bits 3...0 @ref app_usbd_scsi_cmd_requestsense_resp_t::flags */
+#define APP_USBD_SCSI_CMD_REQSENSE_FLAG_HARDWAREERROR  0x04 /**< Bits 3...0 @ref app_usbd_scsi_cmd_requestsense_resp_t::flags */
+#define APP_USBD_SCSI_CMD_REQSENSE_FLAG_ILLEGALREQUEST 0x05 /**< Bits 3...0 @ref app_usbd_scsi_cmd_requestsense_resp_t::flags */
+#define APP_USBD_SCSI_CMD_REQSENSE_FLAG_UNITATTENTION  0x06 /**< Bits 3...0 @ref app_usbd_scsi_cmd_requestsense_resp_t::flags */
+#define APP_USBD_SCSI_CMD_REQSENSE_FLAG_DATAPROTECT    0x07 /**< Bits 3...0 @ref app_usbd_scsi_cmd_requestsense_resp_t::flags */
+#define APP_USBD_SCSI_CMD_REQSENSE_FLAG_BLANKCHECK     0x08 /**< Bits 3...0 @ref app_usbd_scsi_cmd_requestsense_resp_t::flags */
+#define APP_USBD_SCSI_CMD_REQSENSE_FLAG_VENDORSPECIFIC 0x09 /**< Bits 3...0 @ref app_usbd_scsi_cmd_requestsense_resp_t::flags */
+#define APP_USBD_SCSI_CMD_REQSENSE_FLAG_ABORTEDCOMMAND 0x0B /**< Bits 3...0 @ref app_usbd_scsi_cmd_requestsense_resp_t::flags */
+
+
+#define APP_USBD_SCSI_CMD_TESTUNITREADY_LEN 6 /**< @ref APP_USBD_SCSI_CMD_TESTUNITREADY command length*/
+
+/**
+ * @brief Payload of @ref APP_USBD_SCSI_CMD_REQUESTSENSE response.
+ */
+typedef struct {
+    uint8_t code;          //!< Response code: APP_USBD_SCSI_CMD_REQSENSE_CODE_*
+    uint8_t obsolete;      //!< Obsolete
+    uint8_t flags;         //!< APP_USBD_SCSI_CMD_REQSENSE_FLAG_*
+    uint8_t info[4];       //!< Information
+    uint8_t len;           //!< Additional length
+    uint8_t cmdinfo[4];    //!< Command-specific information
+    uint8_t code2;         //!< Additional sense code
+    uint8_t qual2;         //!< Additional sense code qualifier
+    uint8_t fru;           //!< Field replacement unit code
+    uint8_t key[3];        //!< Sense key specific
+} app_usbd_scsi_cmd_requestsense_resp_t;
+
+/**
+ * @brief Payload of @ref APP_USBD_SCSI_CMD_INQUIRY command.
+ */
+typedef struct {
+    uint8_t opcode;        //!< @ref APP_USBD_SCSI_CMD_INQUIRY
+    uint8_t flags;         //!< Command flags
+    uint8_t pagecode;      //!< Page code
+    uint8_t alloclen[2];   //!< Allocation length
+    uint8_t control;       //!< Control
+} app_usbd_scsi_cmd_inquiry_t;
+
+#define  APP_USBD_MSC_SCSI_INQ_QUAL_CONNECTED   0x00   /**< Peripheral connected        */
+#define  APP_USBD_MSC_SCSI_INQ_QUAL_NOT_CONN    0x20   /**< Peripheral not connected    */
+#define  APP_USBD_MSC_SCSI_INQ_QUAL_NOT_SUPP    0x60   /**< Peripheral not supported    */
+
+#define  APP_USBD_MSC_SCSI_INQ_TYPE_DIR_ACCESS  0x00   /**< Direct Access (SBC)         */
+#define  APP_USBD_MSC_SCSI_INQ_TYPE_SEQ_ACCESS  0x01   /**< Sequential Access           */
+#define  APP_USBD_MSC_SCSI_INQ_TYPE_PRINTER     0x02   /**< Printer                     */
+#define  APP_USBD_MSC_SCSI_INQ_TYPE_PROCESSOR   0x03   /**< Processor device            */
+#define  APP_USBD_MSC_SCSI_INQ_TYPE_WRITE_ONCE  0x04   /**< Write-once device           */
+#define  APP_USBD_MSC_SCSI_INQ_TYPE_CD_DVD      0x05   /**< CD/DVD device               */
+#define  APP_USBD_MSC_SCSI_INQ_TYPE_OPTICAL     0x07   /**< Optical Memory              */
+#define  APP_USBD_MSC_SCSI_INQ_TYPE_MC          0x08   /**< Medium Changer              */
+#define  APP_USBD_MSC_SCSI_INQ_TYPE_ARRAY       0x0C   /**< Storage Array Controller    */
+#define  APP_USBD_MSC_SCSI_INQ_TYPE_ENCLOSURE   0x0D   /**< Enclosure Services          */
+#define  APP_USBD_MSC_SCSI_INQ_TYPE_RBC         0x0E   /**< Simplified Direct Access    */
+#define  APP_USBD_MSC_SCSI_INQ_TYPE_OCRW        0x0F   /**< Optical card reader/writer  */
+#define  APP_USBD_MSC_SCSI_INQ_TYPE_BCC         0x10   /**< Bridge Controller Commands  */
+#define  APP_USBD_MSC_SCSI_INQ_TYPE_OSD         0x11   /**< Object-based Storage        */
+#define  APP_USBD_MSC_SCSI_INQ_TYPE_NONE        0x1F   /**< No Peripheral               */
+
+
+#define  APP_USBD_MSC_SCSI_INQ_FLAG1_RMB        0x80   /**< Removable Medium */
+
+#define  APP_USBD_SCSI_INQ_VER_NONE       0x00   /**< No standards conformance                 */
+#define  APP_USBD_SCSI_INQ_VER_SPC        0x03   /**< SCSI Primary Commands     (link to SBC)  */
+#define  APP_USBD_SCSI_INQ_VER_SPC2       0x04   /**< SCSI Primary Commands - 2 (link to SBC-2)*/
+#define  APP_USBD_SCSI_INQ_VER_SPC3       0x05   /**< SCSI Primary Commands - 3 (link to SBC-2)*/
+#define  APP_USBD_SCSI_INQ_VER_SPC4       0x06   /**< SCSI Primary Commands - 4 (link to SBC-3)*/
+
+#define  APP_USBD_MSC_SCSI_INQ_FLAG2_NORMACA        0x20   /**< Normal ACA Supported         */
+#define  APP_USBD_MSC_SCSI_INQ_FLAG2_HISUP          0x10   /**< Hierarchal LUN addressing    */
+#define  APP_USBD_MSC_SCSI_INQ_FLAG2_RSP_SPC2       0x02   /**< SPC-2 / SPC-3 response format*/
+/**
+ * @brief Payload of @ref APP_USBD_SCSI_CMD_INQUIRY response.
+ */
+typedef struct {
+    uint8_t qualtype;      //!< Bits 5-7: Peripheral qualifier; Bits 0-4: Peripheral device type
+    uint8_t flags1;        //!< Flags 1
+    uint8_t version;       //!< Version
+    uint8_t flags2;        //!< Flags 2
+    uint8_t len;           //!< Additional length
+    uint8_t flags3;        //!< Flags 3
+    uint8_t flags4;        //!< Flags 4
+    uint8_t flags5;        //!< Flags 5
+    uint8_t vendorid[8];   //!< T10 Vendor Identification
+    uint8_t productid[16]; //!< Product Identification
+    uint8_t revision[4];   //!< Product Revision Level
+} app_usbd_scsi_cmd_inquiry_resp_t;
+
+/**
+ * @brief Payload of @ref APP_USBD_SCSI_CMD_READ6 command.
+ */
+typedef struct {
+    uint8_t opcode;        //!< @ref APP_USBD_SCSI_CMD_READ6
+    uint8_t mslba;         //!< Bits 5-7: reserved; Bits 0-6: MS Logical Block Address (LBA)
+    uint8_t lslba[2];      //!< LS Logical Block Address (LBA)
+    uint8_t xfrlen;        //!< Transfer length (in contiguous logical blocks)
+    uint8_t control;       //!< Control
+} app_usbd_scsi_cmd_read6_t;
+
+/**
+ * @brief Payload of @ref APP_USBD_SCSI_CMD_WRITE6 command.
+ */
+typedef struct {
+    uint8_t opcode;        //!< @ref APP_USBD_SCSI_CMD_WRITE6
+    uint8_t mslba;         //!< Bits 5-7: reserved; Bits 0-6: MS Logical Block Address (LBA)
+    uint8_t lslba[2];      //!< LS Logical Block Address (LBA)
+    uint8_t xfrlen;        //!< Transfer length (in contiguous logical blocks)
+    uint8_t control;       //!< Control
+} app_usbd_scsi_cmd_write6_t;
+
+/**
+ * @brief Payload of @ref APP_USBD_SCSI_CMD_MODESENSE6 command.
+ */
+typedef struct {
+    uint8_t opcode;        //!<* @ref APP_USBD_SCSI_CMD_MODESENSE6
+    uint8_t flags;         //!<* Flags
+    uint8_t pcpgcode;      //!<* Bits 6-7: PC, bits 0-5: page code
+    uint8_t subpgcode;     //!<* subpage code
+    uint8_t alloclen;      //!<* Allocation length
+    uint8_t control;       //!<* Control
+} app_usbd_scsi_cmd_modesense6_t;
+
+/**
+ * @brief Payload of @ref APP_USBD_SCSI_CMD_MODESENSE6 response.
+ */
+typedef struct {
+    uint8_t mdlen;         //!< Mode data length
+    uint8_t type;          //!< Medium type
+    uint8_t param;         //!< Device-specific parameter
+    uint8_t bdlen;         //!< Block descriptor length
+} app_usbd_scsi_cmd_modesense6_resp_t;
+
+/**
+ * @brief Payload of @ref APP_USBD_SCSI_CMD_READCAPACITY10 command.
+ */
+typedef struct {
+    uint8_t opcode;        //!< @ref APP_USBD_SCSI_CMD_READCAPACITY10
+    uint8_t reserved1;     //!< Reserved field
+    uint8_t lba[4];        //!< Logical block address (LBA)
+    uint8_t reserved2[2];  //!< Reserved field
+    uint8_t pmi;           //!< Bits 1-7 Reserved; Bit 0: PMI
+    uint8_t control;       //!< Control
+} app_usbd_scsi_cmd_readcapacity10_t;
+
+/**
+ * @brief Payload of @ref APP_USBD_SCSI_CMD_READCAPACITY10 response.
+ */
+typedef struct {
+    uint8_t lba[4];        //!< Returned logical block address (LBA)
+    uint8_t blklen[4];     //!< Logical block length (in bytes)
+} app_usbd_scsi_cmd_readcapacity10_resp_t;
+
+/**
+ * @brief Payload of @ref APP_USBD_SCSI_CMD_READ10 command.
+ */
+typedef struct {
+    uint8_t opcode;        //!< @ref APP_USBD_SCSI_CMD_READ10
+    uint8_t flags;         //!< Command flags
+    uint8_t lba[4];        //!< Logical Block Address (LBA)
+    uint8_t groupno;       //!< Bits 5-7: reserved; Bits 0-6: group number
+    uint8_t xfrlen[2];     //!< Transfer length (in contiguous logical blocks)
+    uint8_t control;       //!< Control
+} app_usbd_scsi_cmd_read10_t;
+
+/**
+ * @brief Payload of @ref APP_USBD_SCSI_CMD_WRITE10 command.
+ */
+typedef struct {
+    uint8_t opcode;        //!< @ref APP_USBD_SCSI_CMD_WRITE10
+    uint8_t flags;         //!< Command flags
+    uint8_t lba[4];        //!< Logical Block Address (LBA)
+    uint8_t groupno;       //!< Bits 5-7: reserved; Bits 0-6: group number
+    uint8_t xfrlen[2];     //!< Transfer length (in contiguous logical blocks)
+    uint8_t control;       //!< Control
+} app_usbd_scsi_cmd_write10_t;
+
+/**
+ * @brief Payload of @ref APP_USBD_SCSI_CMD_MODESENSE10 command.
+ */
+typedef struct {
+  uint8_t opcode;        //!< @ref APP_USBD_SCSI_CMD_MODESENSE10
+  uint8_t flags;         //!< Flags
+  uint8_t pcpgcode;      //!< Bits 6-7: PC, bits 0-5: page code
+  uint8_t subpgcode;     //!< Subpage code
+  uint8_t reserved[3];   //!< Reserved
+  uint8_t alloclen[2];   //!< Allocation length
+  uint8_t control;       //!< Control
+} app_usbd_scsi_cmd_modesense10_t;
+
+/**
+ * @brief Payload of @ref APP_USBD_SCSI_CMD_MODESENSE10 response.
+ */
+typedef struct {
+  uint8_t mdlen[2];      //!< Mode data length
+  uint8_t type;          //!< Medium type
+  uint8_t param;         //!< Device-specific parameter
+  uint8_t reserved[2];   //!< Reserved
+  uint8_t bdlen[2];      //!< Block descriptor length
+} app_usbd_scsi_cmd_modesense10_resp_t;
+
+#pragma pack(pop)
+
+/** @} */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* APP_USBD_MSC_SCSI_H__ */

components/libraries/usbd/class/msc/app_usbd_msc_types.h

@@ -0,0 +1,148 @@
+/**
+ * Copyright (c) 2016 - 2020, 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.
+ *
+ */
+#ifndef APP_USBD_MSC_TYPES_H__
+#define APP_USBD_MSC_TYPES_H__
+
+#include "app_util.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @defgroup app_usbd_msc_types USB MSC types
+ * @ingroup app_usbd_msc
+ *
+ * @brief @tagAPI52840 Types used in the USB MSC class.
+ * @{
+ */
+
+/** @brief MSC class definition in interface descriptor
+ *
+ *  @ref app_usbd_descriptor_iface_t::bInterfaceClass
+ * */
+#define  APP_USBD_MSC_CLASS                  0x08
+
+/**
+ * @brief MSC subclass possible value.
+ */
+typedef enum {
+    APP_USBD_MSC_SUBCLASS_NOT_REPORTED = 0x00,    /**< Command set not reported     */
+    APP_USBD_MSC_SUBCLASS_RBC          = 0x01,    /**< Reduced Block Commands       */
+    APP_USBD_MSC_SUBCLASS_ATAPI        = 0x02,    /**< CD/DVD devices               */
+    APP_USBD_MSC_SUBCLASS_QIC_157      = 0x03,    /**< Tape devices                 */
+    APP_USBD_MSC_SUBCLASS_UFI          = 0x04,    /**< Floppy disk drives           */
+    APP_USBD_MSC_SUBCLASS_SFF_8070I    = 0x05,    /**< Floppy disk drives           */
+    APP_USBD_MSC_SUBCLASS_TRANSPARENT  = 0x06,    /**< Determined by INQUIRY        */
+    APP_USBD_MSC_SUBCLASS_LSD_FS       = 0x07,    /**< LSD FS specified negitiation */
+    APP_USBD_MSC_SUBCLASS_IEEE_1667    = 0x08,    /**< IEEE 1607                    */
+    APP_USBD_MSC_SUBCLASS_VENDOR       = 0xFF,    /**< Vendor specific              */
+} app_usbd_msc_subclass_t;
+
+/**
+ * @brief MSC protocol possible value.
+ *
+ * @note The USB Mass Storage Class Control/Bulk/Interrupt (CBI) Transport specification is approved
+ *       for use only with full-speed floppy disk drives. CBI shall not be used in high-speed
+ *       capable devices.
+ */
+typedef enum {
+    APP_USBD_MSC_PROTOCOL_CBI      = 0x00,    /**< Command/Bulk/Interrupt */
+    APP_USBD_MSC_PROTOCOL_CBI_ALT  = 0x01,    /**< W/o command completion */
+    APP_USBD_MSC_PROTOCOL_BULK     = 0x50,    /**< Bulk-only              */
+    APP_USBD_MSC_PROTOCOL_UAS      = 0x62,    /**< UAS                    */
+    APP_USBD_MSC_PROTOCOL_VENDOR   = 0xFF,    /**< Vendor specific        */
+} app_usbd_msc_protocol_t;
+
+/**
+ * @brief MSC USB requests @ref nrf_drv_usbd_setup_t::bmRequestType
+ */
+typedef enum {
+    APP_USBD_MSC_REQ_ADSC        = 0x00, /**< Accept Device-Specific Command */
+    APP_USBD_MSC_REQ_GET_REQS    = 0xFC, /**< Get Requests                   */
+    APP_USBD_MSC_REQ_PUT_REQS    = 0xFD, /**< Put Requests                   */
+    APP_USBD_MSC_REQ_GET_MAX_LUN = 0xFE, /**< Get Max LUN                    */
+    APP_USBD_MSC_REQ_BULK_RESET  = 0xFF, /**< Mass Storage Reset             */
+} app_usbd_msc_req_t;
+
+#pragma pack(push, 1)
+
+#define  APP_USBD_MSC_CBW_SIGNATURE     {'U', 'S', 'B', 'C'} /**< CBW signature      */
+#define  APP_USBD_MSC_CBW_DIRECTION_IN  (1u << 7)             /**< CBW direction flag */
+
+/**
+ * @brief Command Block Wrapper (CBW).
+ */
+typedef struct {
+    uint8_t signature[4];           /**< "USBC" (hex: 0x43425355 little-endian)        */
+    uint8_t tag[4];                 /**< Unique command tag                            */
+    uint8_t datlen[4];              /**< Number of bytes that host expects to transfer */
+    uint8_t flags;                  /**< Bit 7: Direction=IN                           */
+    uint8_t lun;                    /**< Logical Unit Number, equals to @ref app_usbd_msc_inst_t :: block_devs_count*/
+    uint8_t cdb_length;             /**< Length of cdb field                           */
+    uint8_t cdb[16];                /**< Command Data Block payload                    */
+} app_usbd_msc_cbw_t;
+
+#define  APP_USBD_MSC_CSW_SIGNATURE     {'U', 'S', 'B', 'S'} /**< CSW signature              */
+
+#define  APP_USBD_MSC_CSW_STATUS_PASS   0x00                 /**< CSW status: Command Passed */
+#define  APP_USBD_MSC_CSW_STATUS_FAIL   0x01                 /**< CSW status: Command Failed */
+#define  APP_USBD_MSC_CSW_STATUS_PE     0x02                 /**< CSW status: Phase Error    */
+
+/**
+ * @brief Command Status Wrapper (CSW).
+ */
+typedef struct  {
+    uint8_t signature[4];           /**< "USBS" (hex: 0x53425355 little-endian)               */
+    uint8_t tag[4];                 /**< Unique command tag (@ref app_usbd_msc_cbw_t :: tag)  */
+    uint8_t residue[4];             /**< Amount not transferred                               */
+    uint8_t status;                 /**< Status of transfer                                   */
+} app_usbd_msc_csw_t;
+
+#pragma pack(pop)
+
+
+/** @} */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* APP_USBD_MSC_TYPES_H__ */

components/libraries/usbd/class/nrf_dfu_trigger/app_usbd_nrf_dfu_trigger.c

@@ -0,0 +1,374 @@
+/**
+ * Copyright (c) 2017 - 2020, 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 "sdk_common.h"
+#if NRF_MODULE_ENABLED(APP_USBD_NRF_DFU_TRIGGER)
+
+#include <string.h>
+#include <ctype.h>
+#include "app_usbd.h"
+#include "app_usbd_nrf_dfu_trigger.h"
+#include "app_usbd_string_desc.h"
+#include "nrf_gpio.h"
+
+/**
+ * @defgroup app_usbd_nrf_dfu_trigger_internal USBD Nordic DFU Trigger internals
+ * @{
+ * @ingroup app_usbd_nrf_dfu_trigger
+ * @internal
+ */
+
+#define NRF_LOG_MODULE_NAME usbd_nrf_dfu_trigger
+
+#if APP_USBD_NRF_DFU_TRIGGER_CONFIG_LOG_ENABLED
+#define NRF_LOG_LEVEL       APP_USBD_NRF_DFU_TRIGGER_CONFIG_LOG_LEVEL
+#define NRF_LOG_INFO_COLOR  APP_USBD_NRF_DFU_TRIGGER_CONFIG_INFO_COLOR
+#define NRF_LOG_DEBUG_COLOR APP_USBD_NRF_DFU_TRIGGER_CONFIG_DEBUG_COLOR
+#else //APP_USBD_NRF_DFU_TRIGGER_CONFIG_LOG_ENABLED
+#define NRF_LOG_LEVEL       0
+#endif //APP_USBD_NRF_DFU_TRIGGER_CONFIG_LOG_ENABLED
+#include "nrf_log.h"
+NRF_LOG_MODULE_REGISTER();
+
+/**
+ * @brief Auxiliary function to access DFU Trigger instance data.
+ *
+ * @param[in] p_inst Class instance data.
+ *
+ * @return DFU Trigger instance data @ref app_usbd_nrf_dfu_trigger_t
+ */
+static inline app_usbd_nrf_dfu_trigger_t const * nrf_dfu_trigger_get(app_usbd_class_inst_t const * p_inst)
+{
+    ASSERT(p_inst != NULL);
+    return (app_usbd_nrf_dfu_trigger_t const *)p_inst;
+}
+
+/**
+ * @brief Auxiliary function to access DFU Trigger context data.
+ *
+ * @param[in] p_dfu    DFU Trigger instance data.
+ *
+ * @return DFU Trigger context data @ref app_usbd_nrf_dfu_trigger_ctx_t
+ */
+static inline app_usbd_nrf_dfu_trigger_ctx_t * nrf_dfu_trigger_ctx_get(
+        app_usbd_nrf_dfu_trigger_t const * p_dfu)
+{
+    ASSERT(p_dfu != NULL);
+    ASSERT(p_dfu->specific.p_data != NULL);
+    return &p_dfu->specific.p_data->ctx;
+}
+
+/**
+ * @brief Internal SETUP standard IN request handler.
+ *
+ * @param[in] p_inst        Generic class instance.
+ * @param[in] p_setup_ev    Setup event.
+ *
+ * @return Standard error code.
+ * @retval NRF_SUCCESS if request handled correctly.
+ * @retval NRF_ERROR_NOT_SUPPORTED if request is not supported.
+ */
+static ret_code_t setup_req_std_in(app_usbd_class_inst_t const * p_inst,
+                                   app_usbd_setup_evt_t const *  p_setup_ev)
+{
+    /* Only Get Descriptor standard IN request is supported by DFU class */
+    if ((app_usbd_setup_req_rec(p_setup_ev->setup.bmRequestType) == APP_USBD_SETUP_REQREC_INTERFACE)
+        &&
+        (p_setup_ev->setup.bRequest == APP_USBD_SETUP_STDREQ_GET_DESCRIPTOR))
+    {
+        size_t dsc_len = 0;
+        size_t max_size;
+
+        uint8_t * p_trans_buff = app_usbd_core_setup_transfer_buff_get(&max_size);
+        /* Try to find descriptor in class internals*/
+        ret_code_t ret = app_usbd_class_descriptor_find(p_inst,
+                                                        p_setup_ev->setup.wValue.hb,
+                                                        p_setup_ev->setup.wValue.lb,
+                                                        p_trans_buff,
+                                                        &dsc_len);
+        if (ret != NRF_ERROR_NOT_FOUND)
+        {
+            ASSERT(dsc_len < NRF_DRV_USBD_EPSIZE);
+            return app_usbd_core_setup_rsp(&(p_setup_ev->setup), p_trans_buff, dsc_len);
+        }
+    }
+    return NRF_ERROR_NOT_SUPPORTED;
+}
+
+/**
+ * @brief Internal SETUP standard OUT request handler.
+ *
+ * @param[in] p_inst        Generic class instance.
+ * @param[in] p_setup_ev    Setup event.
+ *
+ * @return Standard error code.
+ * @retval NRF_SUCCESS if request handled correctly.
+ * @retval NRF_ERROR_NOT_SUPPORTED if request is not supported.
+ * @retval NRF_ERROR_FORBIDDEN if endpoint stall cannot be cleared because of internal state.
+ */
+static ret_code_t setup_req_std_out(app_usbd_class_inst_t const * p_inst,
+                                    app_usbd_setup_evt_t const *  p_setup_ev)
+{
+
+    switch (p_setup_ev->setup.bRequest)
+    {
+    default:
+        break;
+    }
+    return NRF_ERROR_NOT_SUPPORTED;
+}
+
+/**
+ * @brief User event handler.
+ *
+ * @param[in] p_inst        Class instance.
+ * @param[in] event user    Event type.
+ */
+static inline void user_event_handler(app_usbd_class_inst_t const *         p_inst,
+                                      app_usbd_nrf_dfu_trigger_user_event_t event)
+{
+    app_usbd_nrf_dfu_trigger_t const * p_dfu = nrf_dfu_trigger_get(p_inst);
+    if (p_dfu->specific.inst.user_ev_handler != NULL)
+    {
+        p_dfu->specific.inst.user_ev_handler(p_inst, event);
+    }
+}
+
+/**
+ * @brief Internal SETUP class IN request handler.
+ *
+ * @param[in] p_inst        Generic class instance.
+ * @param[in] p_setup_ev    Setup event.
+ *
+ * @return Standard error code.
+ * @retval NRF_SUCCESS if request handled correctly.
+ * @retval NRF_ERROR_NOT_SUPPORTED if request is not supported.
+ */
+static ret_code_t setup_req_class_in(app_usbd_class_inst_t const * p_inst,
+                                     app_usbd_setup_evt_t const *  p_setup_ev)
+{
+    app_usbd_nrf_dfu_trigger_t const * p_dfu = nrf_dfu_trigger_get(p_inst);
+
+    switch (p_setup_ev->setup.bRequest)
+    {
+        case APP_USBD_NRF_DFU_TRIGGER_REQ_NORDIC_INFO:
+            if (p_setup_ev->setup.wLength.w != sizeof(app_usbd_nrf_dfu_trigger_nordic_info_t))
+            {
+                return NRF_ERROR_NOT_SUPPORTED;
+            }
+            return app_usbd_core_setup_rsp(&p_setup_ev->setup,
+                                           p_dfu->specific.inst.p_dfu_info,
+                                           sizeof(app_usbd_nrf_dfu_trigger_nordic_info_t));
+
+        case APP_USBD_NRF_DFU_TRIGGER_REQ_SEM_VER:
+            return app_usbd_core_setup_rsp(&p_setup_ev->setup,
+                                           p_dfu->specific.inst.p_sem_ver,
+                                           p_dfu->specific.inst.sem_ver_size);
+
+        default:
+            break;
+    }
+
+    return NRF_ERROR_NOT_SUPPORTED;
+}
+
+/**
+ * @brief Internal SETUP class OUT request handler.
+ *
+ * @param[in] p_inst        Generic class instance.
+ * @param[in] p_setup_ev    Setup event.
+ *
+ * @return Standard error code.
+ * @retval NRF_SUCCESS if request handled correctly.
+ * @retval NRF_ERROR_NOT_SUPPORTED if request is not supported.
+ */
+static ret_code_t setup_req_class_out(app_usbd_class_inst_t const * p_inst,
+                                      app_usbd_setup_evt_t const *  p_setup_ev)
+{
+    app_usbd_nrf_dfu_trigger_t const * p_dfu     = nrf_dfu_trigger_get(p_inst);
+    app_usbd_nrf_dfu_trigger_ctx_t *   p_dfu_ctx = nrf_dfu_trigger_ctx_get(p_dfu);
+
+    switch (p_setup_ev->setup.bRequest)
+    {
+        case APP_USBD_NRF_DFU_TRIGGER_REQ_DETACH:
+        {
+            NRF_LOG_DEBUG("Entering DFU Mode");
+            p_dfu_ctx->state = APP_USBD_NRF_DFU_TRIGGER_STATE_DETACH;
+            user_event_handler(p_inst, APP_USBD_NRF_DFU_TRIGGER_USER_EVT_DETACH);
+            return NRF_SUCCESS;
+        }
+        default:
+            break;
+    }
+
+    return NRF_ERROR_NOT_SUPPORTED;
+}
+
+/**
+ * @brief Control endpoint handle.
+ *
+ * @param[in] p_inst        Generic class instance.
+ * @param[in] p_setup_ev    Setup event.
+ *
+ * @return Standard error code.
+ * @retval NRF_SUCCESS if request handled correctly.
+ * @retval NRF_ERROR_NOT_SUPPORTED if request is not supported.
+ */
+static ret_code_t setup_event_handler(app_usbd_class_inst_t const * p_inst,
+                                      app_usbd_setup_evt_t const *  p_setup_ev)
+{
+    ASSERT(p_inst     != NULL);
+    ASSERT(p_setup_ev != NULL);
+
+    if (app_usbd_setup_req_dir(p_setup_ev->setup.bmRequestType) == APP_USBD_SETUP_REQDIR_IN)
+    {
+        switch (app_usbd_setup_req_typ(p_setup_ev->setup.bmRequestType))
+        {
+            case APP_USBD_SETUP_REQTYPE_STD:
+                return setup_req_std_in(p_inst, p_setup_ev);
+            case APP_USBD_SETUP_REQTYPE_CLASS:
+                return setup_req_class_in(p_inst, p_setup_ev);
+            default:
+                break;
+        }
+    }
+    else /* APP_USBD_SETUP_REQDIR_OUT */
+    {
+        switch (app_usbd_setup_req_typ(p_setup_ev->setup.bmRequestType))
+        {
+            case APP_USBD_SETUP_REQTYPE_STD:
+                return setup_req_std_out(p_inst, p_setup_ev);
+            case APP_USBD_SETUP_REQTYPE_CLASS:
+                return setup_req_class_out(p_inst, p_setup_ev);
+            default:
+                break;
+        }
+    }
+
+    return NRF_ERROR_NOT_SUPPORTED;
+}
+
+/**
+ * @brief @ref app_usbd_class_methods_t::event_handler
+ */
+static ret_code_t nrf_dfu_trigger_event_handler(app_usbd_class_inst_t const *  p_inst,
+                                                app_usbd_complex_evt_t const * p_event)
+{
+    ASSERT(p_inst  != NULL);
+    ASSERT(p_event != NULL);
+
+    ret_code_t ret = NRF_SUCCESS;
+    switch (p_event->app_evt.type)
+    {
+        case APP_USBD_EVT_DRV_SOF:
+            break;
+        case APP_USBD_EVT_DRV_RESET:
+            break;
+        case APP_USBD_EVT_DRV_SETUP:
+            ret  = setup_event_handler(p_inst, (app_usbd_setup_evt_t const *) p_event);
+            break;
+        case APP_USBD_EVT_DRV_EPTRANSFER:
+            break;
+        case APP_USBD_EVT_DRV_SUSPEND:
+            break;
+        case APP_USBD_EVT_DRV_RESUME:
+            break;
+        case APP_USBD_EVT_INST_APPEND:
+            break;
+        case APP_USBD_EVT_INST_REMOVE:
+            break;
+        case APP_USBD_EVT_STARTED:
+            break;
+        case APP_USBD_EVT_STOPPED:
+            break;
+        default:
+            ret = NRF_ERROR_NOT_SUPPORTED;
+            break;
+    }
+
+    return ret;
+}
+
+/**
+ * @brief @ref app_usbd_class_methods_t::feed_descriptors
+ */
+static bool nrf_dfu_trigger_feed_descriptors(app_usbd_class_descriptor_ctx_t * p_ctx,
+                                             app_usbd_class_inst_t const     * p_inst,
+                                             uint8_t                         * p_buff,
+                                             size_t                            max_size)
+{
+    static app_usbd_class_iface_conf_t const * p_cur_iface = NULL;
+    p_cur_iface = app_usbd_class_iface_get(p_inst, 0);
+    app_usbd_nrf_dfu_trigger_t const * p_dfu = nrf_dfu_trigger_get(p_inst);
+
+    APP_USBD_CLASS_DESCRIPTOR_BEGIN(p_ctx, p_buff, max_size)
+
+    /* INTERFACE DESCRIPTOR */
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(sizeof(app_usbd_descriptor_iface_t)); // bLength
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(APP_USBD_DESCRIPTOR_INTERFACE); // bDescriptorType
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(app_usbd_class_iface_number_get(p_cur_iface)); // bInterfaceNumber
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(0x00); // bAlternateSetting
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(0); // bNumEndpoints
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(APP_USBD_NRF_DFU_TRIGGER_CLASS); // bInterfaceClass
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(APP_USBD_NRF_DFU_TRIGGER_SUBCLASS); // bInterfaceSubClass
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(APP_USBD_NRF_DFU_TRIGGER_PROTOCOL_RUNTIME); // bInterfaceProtocol
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(0x00); // iInterface
+
+    /* FUNCTIONAL DESCRIPTOR */
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(sizeof(app_usbd_nrf_dfu_trigger_desc_func_t)); // bFunctionLength
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(APP_USBD_NRF_DFU_TRIGGER_CS_FUNCTIONAL); // bDescriptorType
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(APP_USBD_NRF_DFU_TRIGGER_BIT_CAN_DNLOAD |
+                                    APP_USBD_NRF_DFU_TRIGGER_BIT_WILL_DETACH); // bmAttribute
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(LSB_16(p_dfu->specific.inst.detach_timeout)); // wDetachTimeOut LSB
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(MSB_16(p_dfu->specific.inst.detach_timeout)); // wDetachTimeOut MSB
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(LSB_16(p_dfu->specific.inst.transfer_size)); // wTransferSize LSB
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(MSB_16(p_dfu->specific.inst.transfer_size)); // wTransferSize MSB
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(LSB_16(p_dfu->specific.inst.bcd_dfu)); // bcdDFUVersion LSB
+    APP_USBD_CLASS_DESCRIPTOR_WRITE(MSB_16(p_dfu->specific.inst.bcd_dfu)); // bcdDFUVersion MSB
+
+    APP_USBD_CLASS_DESCRIPTOR_END();
+}
+
+const app_usbd_class_methods_t app_usbd_nrf_dfu_trigger_class_methods = {
+        .event_handler    = nrf_dfu_trigger_event_handler,
+        .feed_descriptors = nrf_dfu_trigger_feed_descriptors,
+};
+
+
+#endif //NRF_MODULE_ENABLED(APP_USBD_NRF_DFU_TRIGGER)

components/libraries/usbd/class/nrf_dfu_trigger/app_usbd_nrf_dfu_trigger.h

@@ -0,0 +1,166 @@
+/**
+ * Copyright (c) 2017 - 2020, 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.
+ *
+ */
+#ifndef APP_USBD_NRF_DFU_TRIGGER_H__
+#define APP_USBD_NRF_DFU_TRIGGER_H__
+
+#include <stdint.h>
+#include <stdbool.h>
+
+#include "nrf_drv_usbd.h"
+#include "nrf_block_dev.h"
+#include "app_usbd_class_base.h"
+#include "app_usbd.h"
+#include "app_usbd_core.h"
+#include "app_usbd_descriptor.h"
+
+#include "app_usbd_nrf_dfu_trigger_types.h"
+#include "app_usbd_nrf_dfu_trigger_internal.h"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @defgroup app_usbd_nrf_dfu_trigger USB Nordic DFU Trigger class
+ * @ingroup app_usbd
+ *
+ * @brief @tagAPI52840 Module with types, definitions,
+ *                     and API used by the USB Nordic DFU Trigger class.
+ *
+ * @{
+ */
+
+#ifdef DOXYGEN
+/**
+ * @brief Nordic DFU Trigger class instance type.
+ *
+ * @ref APP_USBD_CLASS_TYPEDEF
+ */
+typedef struct { } app_usbd_nrf_dfu_trigger_t;
+#else
+/*lint -save -e10 -e26 -e123 -e505 */
+APP_USBD_CLASS_NO_EP_TYPEDEF(app_usbd_nrf_dfu_trigger,                                             \
+                             APP_USBD_NRF_DFU_TRIGGER_CONFIG(0),                                   \
+                             APP_USBD_NRF_DFU_TRIGGER_INSTANCE_SPECIFIC_DEC,                       \
+                             APP_USBD_NRF_DFU_TRIGGER_DATA_SPECIFIC_DEC                            \
+);
+#endif
+
+/*lint -restore*/
+
+
+/*lint -save -e407 */
+
+/**
+ * @brief Events passed to user event handler.
+ *
+ * @note Example prototype of user event handler:
+ *
+ * void dfu_user_ev_handler(app_usbd_class_inst_t const *         p_inst,
+ *                          app_usbd_nrf_dfu_trigger_user_event_t event);
+ */
+typedef enum app_usbd_nrf_dfu_trigger_user_event_e {
+    APP_USBD_NRF_DFU_TRIGGER_USER_EVT_DETACH,
+} app_usbd_nrf_dfu_trigger_user_event_t;
+
+/*lint -restore*/
+
+/**
+ * @brief Global definition of app_usbd_nrf_dfu_trigger_t class.
+ *
+ * @param instance_name         Name of global instance.
+ * @param interface_number      Unique interface number.
+ * @param p_nordic_dfu          Pointer to @ref app_usbd_nrf_dfu_trigger_nordic_info_t structure.
+ * @param sem_ver_str           Semantic version string.
+ * @param user_ev_handler       User event handler (optional).
+ *
+ * @note This macro is just simplified version of @ref APP_USBD_NRF_DFU_TRIGGER_GLOBAL_DEF_INTERNAL
+ *
+ */
+/*lint -save -emacro(26 64 123 505 651, APP_USBD_NRF_DFU_TRIGGER_GLOBAL_DEF)*/
+#define APP_USBD_NRF_DFU_TRIGGER_GLOBAL_DEF(instance_name,                                         \
+                                            interface_number,                                      \
+                                            p_nordic_dfu,                                          \
+                                            sem_ver_str,                                           \
+                                            user_ev_handler)                                       \
+        APP_USBD_NRF_DFU_TRIGGER_GLOBAL_DEF_INTERNAL(instance_name,                                \
+                                                     interface_number,                             \
+                                                     0,                                            \
+                                                     0,                                            \
+                                                     p_nordic_dfu,                                 \
+                                                     sem_ver_str,                                  \
+                                                     user_ev_handler)
+/*lint -restore*/
+
+/**
+ * @brief Helper function to get class instance from Nordic DFU Trigger.
+ *
+ * @param[in] p_dfu Nordic DFU Trigger instance
+ *                  (declared by @ref APP_USBD_NRF_DFU_TRIGGER_GLOBAL_DEF)
+ *
+ * @return Base class instance
+ */
+static inline app_usbd_class_inst_t const *
+app_usbd_nrf_dfu_trigger_class_inst_get(app_usbd_nrf_dfu_trigger_t const * p_dfu)
+{
+    return &p_dfu->base;
+}
+
+/**
+ * @brief Helper function to get DFU from base class instance.
+ *
+ * @param[in] p_inst Base class instance.
+ *
+ * @return DFU class handle.
+ */
+static inline app_usbd_nrf_dfu_trigger_t const *
+app_usbd_nrf_dfu_trigger_class_get( app_usbd_class_inst_t const * p_inst)
+{
+    return (app_usbd_nrf_dfu_trigger_t const *)p_inst;
+}
+
+/** @} */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* APP_USBD_NRF_DFU_TRIGGER_H__ */

components/libraries/usbd/class/nrf_dfu_trigger/app_usbd_nrf_dfu_trigger_internal.h

@@ -0,0 +1,203 @@
+/**
+ * Copyright (c) 2017 - 2020, 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.
+ *
+ */
+#ifndef APP_USBD_NRF_DFU_TRIGGER_INTERNAL_H__
+#define APP_USBD_NRF_DFU_TRIGGER_INTERNAL_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @defgroup app_usbd_nrf_dfu_trigger_internals USB Nordic DFU Trigger internals
+ * @ingroup app_usbd_nrf_dfu_trigger
+ *
+ * @brief @tagAPI52840 Internals of the USB Nordic DFU Trigger class.
+ * @{
+ */
+
+/**
+ * @brief Forward declaration of Nordic DFU Trigger Class type.
+ *
+ */
+APP_USBD_CLASS_FORWARD(app_usbd_nrf_dfu_trigger);
+
+/*lint -save -e165*/
+/**
+ * @brief Forward declaration of @ref app_usbd_nrf_dfu_trigger_user_event_e
+ *
+ */
+enum app_usbd_nrf_dfu_trigger_user_event_e;
+
+/*lint -restore*/
+
+/**
+ * @brief User event handler.
+ *
+ * @param[in] p_inst    Class instance.
+ * @param[in] event     User event.
+ *
+ * */
+typedef void (*app_usbd_nrf_dfu_trigger_user_ev_handler_t)(
+        app_usbd_class_inst_t const *              p_inst,
+        enum app_usbd_nrf_dfu_trigger_user_event_e event);
+
+/**
+ * @brief Nordic DFU Trigger part of class instance data.
+ */
+typedef struct {
+    size_t const    sem_ver_size;   //!< Semantic string size
+    uint16_t const  detach_timeout; //!< Detach timeout in ms - for compatibility with DFU spec.
+    uint16_t const  transfer_size;  //!< Transfer size - for compatibility with DFU spec.
+    uint16_t const  bcd_dfu;        //!< DFU spec version.
+    uint8_t const * p_sem_ver;      //!< Pointer to semantic version string
+
+    app_usbd_nrf_dfu_trigger_nordic_info_t const * p_dfu_info; //!< Pointer to Nordic DFU Info
+
+    app_usbd_nrf_dfu_trigger_user_ev_handler_t user_ev_handler; //!< User event handler
+} app_usbd_nrf_dfu_trigger_inst_t;
+
+/**
+ * @brief Internal module state.
+ *
+ * @note For future compatibility with DFU class.
+ */
+typedef enum {
+    APP_USBD_NRF_DFU_TRIGGER_STATE_IDLE,          /**< Internal module state IDLE          */
+    APP_USBD_NRF_DFU_TRIGGER_STATE_DETACH,        /**< Internal module state DETACH        */
+} app_usbd_nrf_dfu_trigger_state_t;
+
+/**
+ * @brief Nordic DFU Trigger context.
+ *
+ * */
+typedef struct {
+    app_usbd_nrf_dfu_trigger_state_t state; //!< Internal module state
+} app_usbd_nrf_dfu_trigger_ctx_t;
+
+
+/**
+ * @brief Nordic DFU Trigger configuration macro.
+ *
+ * Used by @ref APP_USBD_NRF_DFU_TRIGGER_GLOBAL_DEF
+ *
+ * @param iface Interface number.
+ * */
+#define APP_USBD_NRF_DFU_TRIGGER_CONFIG(iface) (iface)
+
+
+/**
+ * @brief Specific class constant data for Nordic DFU Trigger.
+ *
+ * @ref app_usbd_nrf_dfu_trigger_inst_t
+ */
+#define APP_USBD_NRF_DFU_TRIGGER_INSTANCE_SPECIFIC_DEC app_usbd_nrf_dfu_trigger_inst_t inst;
+
+
+/**
+ * @brief Configures Nordic DFU Trigger instance.
+ *
+ * @param user_event_handler    User event handler.
+ * @param p_nordic_dfu          Pointer to @ref app_usbd_nrf_dfu_trigger_nordic_info_t structure.
+ * @param sem_ver_str           Semantic version string.
+ * @param timeout               Detach timeout in ms - left for compatibility with USB DFU spec.
+ * @param size                  Transfer size in bytes - left for compatibility with USB DFU spec.
+ * @param bcd                   USB DFU specification version.
+ */
+#define APP_USBD_NRF_DFU_TRIGGER_INST_CONFIG(user_event_handler,                                   \
+                                             p_nordic_dfu,                                         \
+                                             sem_ver_str,                                          \
+                                             timeout,                                              \
+                                             size,                                                 \
+                                             bcd)                                                  \
+    .inst = {                                                                                      \
+         .user_ev_handler   = user_event_handler,                                                  \
+         .p_dfu_info        = p_nordic_dfu,                                                        \
+         .p_sem_ver         = sem_ver_str,                                                         \
+         .sem_ver_size      = sizeof(sem_ver_str),                                                 \
+         .transfer_size     = size,                                                                \
+         .detach_timeout    = timeout,                                                             \
+         .bcd_dfu           = bcd,                                                                 \
+    }
+
+/**
+ * @brief Specific class data for Nordic DFU Trigger.
+ *
+ * @ref app_usbd_nrf_dfu_trigger_ctx_t
+ * */
+#define APP_USBD_NRF_DFU_TRIGGER_DATA_SPECIFIC_DEC app_usbd_nrf_dfu_trigger_ctx_t ctx;
+
+
+/**
+ * @brief Public Nordic DFU Trigger class interface.
+ */
+extern const app_usbd_class_methods_t app_usbd_nrf_dfu_trigger_class_methods;
+
+/**
+ * @brief Global definition of Nordic DFU Trigger instance.
+ */
+#define APP_USBD_NRF_DFU_TRIGGER_GLOBAL_DEF_INTERNAL(instance_name,                                \
+                                                     interface_number,                             \
+                                                     detach_timeout,                               \
+                                                     transfer_size,                                \
+                                                     p_nordic_dfu,                                 \
+                                                     sem_ver_str,                                  \
+                                                     user_ev_handler)                              \
+    APP_USBD_CLASS_INST_NO_EP_GLOBAL_DEF(                                                          \
+        instance_name,                                                                             \
+        app_usbd_nrf_dfu_trigger,                                                                  \
+        &app_usbd_nrf_dfu_trigger_class_methods,                                                   \
+        APP_USBD_NRF_DFU_TRIGGER_CONFIG((interface_number)),                                       \
+        (APP_USBD_NRF_DFU_TRIGGER_INST_CONFIG(user_ev_handler,                                     \
+                                              p_nordic_dfu,                                        \
+                                              sem_ver_str,                                         \
+                                              detach_timeout,                                      \
+                                              transfer_size,                                       \
+                                              0x0110))                                             \
+    )
+
+
+/** @} */
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* APP_USBD_NRF_DFU_TRIGGER_INTERNAL_H__ */

components/libraries/usbd/class/nrf_dfu_trigger/app_usbd_nrf_dfu_trigger_types.h

@@ -0,0 +1,145 @@
+/**
+ * Copyright (c) 2017 - 2020, 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.
+ *
+ */
+#ifndef APP_USBD_NRF_DFU_TRIGGER_TYPES_H__
+#define APP_USBD_NRF_DFU_TRIGGER_TYPES_H__
+
+#include "app_util.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @defgroup app_usbd_nrf_dfu_trigger_types USB Nordic DFU Trigger types
+ * @ingroup app_usbd_nrf_dfu_trigger
+ *
+ * @brief @tagAPI52840 Types used in the USB Nordic DFU Trigger class.
+ * @{
+ */
+
+/** @brief Nordic DFU Trigger class definition in interface descriptor.
+ *
+ *  @ref app_usbd_descriptor_iface_t::bInterfaceClass
+ * */
+#define APP_USBD_NRF_DFU_TRIGGER_CLASS 0xFF
+
+/**
+ * @brief Nordic DFU Trigger subclass possible value.
+ */
+typedef enum {
+    APP_USBD_NRF_DFU_TRIGGER_SUBCLASS          = 0x01,    /**< Device Firmware Upgrade Code */
+} app_usbd_nrf_dfu_trigger_subclass_t;
+
+/**
+ * @brief Nordic DFU Trigger protocol possible value.
+ *
+ * @note Only Run-time protocol is implemented, as DFU mode is covered by Nordic DFU.
+ */
+typedef enum {
+    APP_USBD_NRF_DFU_TRIGGER_PROTOCOL_RUNTIME  = 0x01,    /**< Run-time Protocol */
+} app_usbd_nrf_dfu_trigger_protocol_t;
+
+/**
+ * @brief Nordic DFU Trigger USB requests @ref nrf_drv_usbd_setup_t::bmRequestType
+ *
+ * @note Requests are limited only to @ref APP_USBD_NRF_DFU_TRIGGER_PROTOCOL_RUNTIME protocol type.
+ */
+typedef enum {
+    APP_USBD_NRF_DFU_TRIGGER_REQ_DETACH      = 0x00, /**< Switch to DFU mode */
+    APP_USBD_NRF_DFU_TRIGGER_REQ_NORDIC_INFO = 0x07, /**< Request Nordic DFU information */
+    APP_USBD_NRF_DFU_TRIGGER_REQ_SEM_VER     = 0x08, /**< Request semantic version information */
+} app_usbd_nrf_dfu_trigger_req_t;
+
+/**
+ * @brief Nordic DFU Trigger Functional Descriptor types.
+ */
+typedef enum {
+    APP_USBD_NRF_DFU_TRIGGER_CS_FUNCTIONAL = 0x21, /**< Functional descriptor type.*/
+} app_usbd_nrf_dfu_trigger_func_type_t;
+
+/**
+ * @brief Nordic DFU Trigger functional descriptor bmAttributes bit masks.
+ *
+ * @note For future compatibility with DFU class.
+ */
+typedef enum {
+    APP_USBD_NRF_DFU_TRIGGER_BIT_CAN_DNLOAD    = 0x01, /**< bitCanDnload */
+    APP_USBD_NRF_DFU_TRIGGER_BIT_CAB_UPLOAD    = 0x02, /**< bitCanUpload */
+    APP_USBD_NRF_DFU_TRIGGER_BIT_MANI_TOLERANT = 0x04, /**< bitManifestationTolerant */
+    APP_USBD_NRF_DFU_TRIGGER_BIT_WILL_DETACH   = 0x08, /**< bitWillDetach */
+} app_usbd_nrf_dfu_trigger_bm_attributes_t;
+
+#pragma pack(push, 1)
+
+/**
+ * @brief Nordic DFU Trigger Functional Descriptor.
+ */
+typedef struct {
+    uint8_t  bFunctionLength; //!< Size of this descriptor in bytes.
+    uint8_t  bDescriptorType; //!< Descriptor type.
+    uint8_t  bmAttributes;    //!< Attributes bits.
+    uint16_t wDetachTimeOut;  //!< Device detach timeout - left for compatibility with USB DFU spec.
+    uint16_t wTransferSize;   //!< Transfer size - left for compatibility with USB DFU spec.
+    uint16_t bcdDFUVersion;   //!< DFU version.
+} app_usbd_nrf_dfu_trigger_desc_func_t;
+
+/**
+ * @brief Nordic custom DFU information.
+ */
+typedef struct {
+    uint32_t wAddress;          //!< Firmware start address.
+    uint32_t wFirmwareSize;     //!< Firmware size.
+    uint16_t wVersionMajor;     //!< Firmware version major.
+    uint16_t wVersionMinor;     //!< Firmware version minor.
+    uint32_t wFirmwareID;       //!< Firmware ID.
+    uint32_t wFlashSize;        //!< Flash size.
+    uint32_t wFlashPageSize;    //!< Flash page size.
+} app_usbd_nrf_dfu_trigger_nordic_info_t;
+
+#pragma pack(pop)
+
+
+/** @} */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* APP_USBD_NRF_DFU_TRIGGER_TYPES_H__ */