638 lines
23 KiB
C
638 lines
23 KiB
C
/**
|
|
* 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)
|