diff options
Diffstat (limited to 'thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/usbd/class/hid/generic')
4 files changed, 1011 insertions, 0 deletions
diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/usbd/class/hid/generic/app_usbd_hid_generic.c b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/usbd/class/hid/generic/app_usbd_hid_generic.c new file mode 100644 index 0000000..61dea15 --- /dev/null +++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/usbd/class/hid/generic/app_usbd_hid_generic.c @@ -0,0 +1,506 @@ +/** + * Copyright (c) 2016 - 2018, Nordic Semiconductor ASA + * + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form, except as embedded into a Nordic + * Semiconductor ASA integrated circuit in a product or a software update for + * such product, must reproduce the above copyright notice, this list of + * conditions and the following disclaimer in the documentation and/or other + * materials provided with the distribution. + * + * 3. Neither the name of Nordic Semiconductor ASA nor the names of its + * contributors may be used to endorse or promote products derived from this + * software without specific prior written permission. + * + * 4. This software, with or without modification, must only be used with a + * Nordic Semiconductor ASA integrated circuit. + * + * 5. Any software provided in binary form under this license must not be reverse + * engineered, decompiled, modified and/or disassembled. + * + * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS + * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE + * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ +#include "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 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)) + { + ret = hid_generic_transfer_set(p_generic); + } + + 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; +} + + +/** + * @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 + { + 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; +} + + +/** + * @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) +{ + 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; +} + + +/** + * @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 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; + + return p_hinst->p_subclass_desc[desc_num]->p_data[cur_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); // bLengths + 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, i); + 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(0x01); // bInterval + } + } + + APP_USBD_CLASS_DESCRIPTOR_END(); +} + +/** + * @brief @ref app_usbd_hid_interface_t::feed_subclass_descriptor + */ + +static bool hid_generic_feed_subclass_descriptor(app_usbd_class_descriptor_ctx_t * p_ctx, + app_usbd_class_inst_t const * p_inst, + uint8_t * p_buff, + size_t max_size, + uint8_t index) +{ + APP_USBD_CLASS_DESCRIPTOR_BEGIN(p_ctx, p_buff, max_size); + + /* PHYSICAL AND REPORT DESCRIPTORS */ + static uint32_t cur_byte = 0; + static size_t sub_desc_size = 0; + sub_desc_size = hid_generic_get_class_descriptors_length(p_inst, index); + + for (cur_byte = 0; cur_byte < sub_desc_size; cur_byte++) + { + APP_USBD_CLASS_DESCRIPTOR_WRITE(hid_generic_get_class_descriptors_data(p_inst, index, + cur_byte)); + } + + APP_USBD_CLASS_DESCRIPTOR_END(); +} + + +/** @} */ + +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, + .feed_subclass_descriptor = hid_generic_feed_subclass_descriptor, +}; + +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) diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/usbd/class/hid/generic/app_usbd_hid_generic.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/usbd/class/hid/generic/app_usbd_hid_generic.h new file mode 100644 index 0000000..3642b16 --- /dev/null +++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/usbd/class/hid/generic/app_usbd_hid_generic.h @@ -0,0 +1,223 @@ +/** + * Copyright (c) 2017 - 2018, Nordic Semiconductor ASA + * + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form, except as embedded into a Nordic + * Semiconductor ASA integrated circuit in a product or a software update for + * such product, must reproduce the above copyright notice, this list of + * conditions and the following disclaimer in the documentation and/or other + * materials provided with the distribution. + * + * 3. Neither the name of Nordic Semiconductor ASA nor the names of its + * contributors may be used to endorse or promote products derived from this + * software without specific prior written permission. + * + * 4. This software, with or without modification, must only be used with a + * Nordic Semiconductor ASA integrated circuit. + * + * 5. Any software provided in binary form under this license must not be reverse + * engineered, decompiled, modified and/or disassembled. + * + * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS + * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE + * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ +#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 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, + APP_USBD_HID_SUBCLASS_BOOT, + APP_USBD_HID_PROTO_MOUSE); + @endcode + * + */ +#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, \ + 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, \ + 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 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); + + +/** @} */ + +#ifdef __cplusplus +} +#endif + +#endif /* APP_USBD_HID_GENERIC_H__ */ diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/usbd/class/hid/generic/app_usbd_hid_generic_desc.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/usbd/class/hid/generic/app_usbd_hid_generic_desc.h new file mode 100644 index 0000000..1ff4487 --- /dev/null +++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/usbd/class/hid/generic/app_usbd_hid_generic_desc.h @@ -0,0 +1,96 @@ +/** + * Copyright (c) 2017 - 2018, Nordic Semiconductor ASA + * + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form, except as embedded into a Nordic + * Semiconductor ASA integrated circuit in a product or a software update for + * such product, must reproduce the above copyright notice, this list of + * conditions and the following disclaimer in the documentation and/or other + * materials provided with the distribution. + * + * 3. Neither the name of Nordic Semiconductor ASA nor the names of its + * contributors may be used to endorse or promote products derived from this + * software without specific prior written permission. + * + * 4. This software, with or without modification, must only be used with a + * Nordic Semiconductor ASA integrated circuit. + * + * 5. Any software provided in binary form under this license must not be reverse + * engineered, decompiled, modified and/or disassembled. + * + * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS + * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE + * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ +#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__ */ diff --git a/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/usbd/class/hid/generic/app_usbd_hid_generic_internal.h b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/usbd/class/hid/generic/app_usbd_hid_generic_internal.h new file mode 100644 index 0000000..4844fde --- /dev/null +++ b/thirdparty/nRF5_SDK_15.0.0_a53641a/components/libraries/usbd/class/hid/generic/app_usbd_hid_generic_internal.h @@ -0,0 +1,186 @@ +/** + * Copyright (c) 2017 - 2018, Nordic Semiconductor ASA + * + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form, except as embedded into a Nordic + * Semiconductor ASA integrated circuit in a product or a software update for + * such product, must reproduce the above copyright notice, this list of + * conditions and the following disclaimer in the documentation and/or other + * materials provided with the distribution. + * + * 3. Neither the name of Nordic Semiconductor ASA nor the names of its + * contributors may be used to endorse or promote products derived from this + * software without specific prior written permission. + * + * 4. This software, with or without modification, must only be used with a + * Nordic Semiconductor ASA integrated circuit. + * + * 5. Any software provided in binary form under this license must not be reverse + * engineered, decompiled, modified and/or disassembled. + * + * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS + * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE + * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ +#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 Configure internal part of HID generic instance. + * + * @param report_buff_in Input report buffers array. + * @param report_buff_out Output 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) + */ +#define APP_USBD_HID_GENERIC_INST_CONFIG(report_buff_in, \ + report_buff_out, \ + user_ev_handler, \ + in_report_queue, \ + subclass_descriptors, \ + subclass_boot, \ + protocol) \ + .inst = { \ + .hid_inst = APP_USBD_HID_INST_CONFIG(subclass_descriptors, \ + subclass_boot, \ + protocol, \ + report_buff_in, \ + report_buff_out, \ + user_ev_handler, \ + &app_usbd_hid_generic_methods), \ + .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 + */ +#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, \ + 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); \ + 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), \ + user_ev_handler, \ + &instance_name##_queue, \ + subclass_descriptors, \ + subclass_boot, \ + protocol)) \ + ) + + +/** @} */ + + +#ifdef __cplusplus +} +#endif + +#endif /* APP_USBD_HID_GENERIC_INTERNAL_H__ */ |