/**
 * 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)
