| /** |
| * Copyright (c) 2016 - 2019, 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) |
| |
| #include "app_usbd.h" |
| #include "app_usbd_core.h" |
| #include "app_usbd_request.h" |
| #include "nrf_power.h" |
| #include "nrf_drv_clock.h" |
| #include "nrf_drv_power.h" |
| #if APP_USBD_CONFIG_EVENT_QUEUE_ENABLE |
| #include "nrf_atfifo.h" |
| #include "nrf_atomic.h" |
| #endif |
| |
| #define NRF_LOG_MODULE_NAME app_usbd |
| |
| #if APP_USBD_CONFIG_LOG_ENABLED |
| #define NRF_LOG_LEVEL APP_USBD_CONFIG_LOG_LEVEL |
| #define NRF_LOG_INFO_COLOR APP_USBD_CONFIG_INFO_COLOR |
| #define NRF_LOG_DEBUG_COLOR APP_USBD_CONFIG_DEBUG_COLOR |
| #else //APP_USBD_CONFIG_LOG_ENABLED |
| #define NRF_LOG_LEVEL 0 |
| #endif //APP_USBD_CONFIG_LOG_ENABLED |
| #include "nrf_log.h" |
| NRF_LOG_MODULE_REGISTER(); |
| |
| |
| /* Base variables tests */ |
| |
| /* Check event of app_usbd_event_type_t enumerator */ |
| STATIC_ASSERT((int32_t)APP_USBD_EVT_FIRST_POWER == (int32_t)NRF_DRV_USBD_EVT_CNT); |
| STATIC_ASSERT(sizeof(app_usbd_event_type_t) == sizeof(nrf_drv_usbd_event_type_t)); |
| |
| STATIC_ASSERT(sizeof(app_usbd_descriptor_header_t) == 2); |
| STATIC_ASSERT(sizeof(app_usbd_descriptor_device_t) == 18); |
| STATIC_ASSERT(sizeof(app_usbd_descriptor_configuration_t) == 9); |
| STATIC_ASSERT(sizeof(app_usbd_descriptor_iface_t) == 9); |
| STATIC_ASSERT(sizeof(app_usbd_descriptor_ep_t) == 7); |
| STATIC_ASSERT(sizeof(app_usbd_descriptor_iad_t) == 8); |
| |
| STATIC_ASSERT(sizeof(app_usbd_setup_t) == sizeof(nrf_drv_usbd_setup_t)); |
| |
| /** |
| * @internal |
| * @defgroup app_usbd_internals USBD library internals |
| * @ingroup app_usbd |
| * |
| * Internal variables, auxiliary macros and functions of USBD library. |
| * @{ |
| */ |
| |
| #if (APP_USBD_PROVIDE_SOF_TIMESTAMP) || defined(__SDK_DOXYGEN__) |
| /** |
| * @brief The last received frame number. |
| */ |
| static uint16_t m_last_frame; |
| #endif |
| |
| /** |
| * @brief Variable type for endpoint configuration. |
| * |
| * Each endpoint would have assigned this type of configuration structure. |
| */ |
| typedef struct |
| { |
| /** |
| * @brief The class instance. |
| * |
| * The pointer to the class instance that is connected to the endpoint. |
| */ |
| app_usbd_class_inst_t const * p_cinst; |
| |
| /** |
| * @brief Endpoint event handler. |
| * |
| * Event handler for the endpoint. |
| * It is set to event handler for the class instance during connection by default, |
| * but it can be then updated for as a reaction for @ref APP_USBD_EVT_ATTACHED event. |
| * This way we can speed up the interpretation of endpoint related events. |
| */ |
| app_usbd_ep_event_handler_t event_handler; |
| }app_usbd_ep_conf_t; |
| |
| |
| /** |
| * @brief Internal event with SOF counter. |
| */ |
| typedef struct |
| { |
| app_usbd_internal_evt_t evt; //!< Internal event type |
| |
| #if (APP_USBD_CONFIG_SOF_HANDLING_MODE == APP_USBD_SOF_HANDLING_COMPRESS_QUEUE) \ |
| || defined(__SDK_DOXYGEN__) |
| uint16_t sof_cnt; //!< Number of the SOF events that appears before current event |
| uint16_t start_frame; //!< Number of the SOF frame that starts this event |
| #endif // (APP_USBD_CONFIG_SOF_HANDLING_MODE == APP_USBD_SOF_HANDLING_COMPRESS_QUEUE) |
| |
| } app_usbd_internal_queue_evt_t; |
| |
| #if (APP_USBD_CONFIG_EVENT_QUEUE_ENABLE) || defined(__SDK_DOXYGEN__) |
| /** |
| * @brief Event queue. |
| * |
| * The queue with events to be processed. |
| */ |
| NRF_ATFIFO_DEF(m_event_queue, app_usbd_internal_queue_evt_t, APP_USBD_CONFIG_EVENT_QUEUE_SIZE); |
| |
| #if (APP_USBD_CONFIG_SOF_HANDLING_MODE == APP_USBD_SOF_HANDLING_COMPRESS_QUEUE) \ |
| || defined(__SDK_DOXYGEN__) |
| |
| /** @brief SOF events counter */ |
| static nrf_atomic_u32_t m_sof_events_cnt; |
| |
| /** @brief SOF Frame counter */ |
| static uint16_t m_event_frame; |
| |
| /* Limit of SOF events stacked until warning message. */ |
| #define APP_USBD_SOF_WARNING_LIMIT 500 |
| #endif // (APP_USBD_CONFIG_SOF_HANDLING_MODE == APP_USBD_SOF_HANDLING_COMPRESS_QUEUE) |
| // || defined(__SDK_DOXYGEN__) |
| |
| #endif |
| |
| /** |
| * @brief Instances connected with IN endpoints. |
| * |
| * Array of instance pointers connected with every IN endpoint. |
| * @sa m_epout_instances |
| */ |
| static app_usbd_ep_conf_t m_epin_conf[NRF_USBD_EPIN_CNT]; |
| |
| /** |
| * @brief Instances connected with OUT endpoints. |
| * |
| * Array of instance pointers connected with every OUT endpoint. |
| * @sa m_epin_instances |
| */ |
| static app_usbd_ep_conf_t m_epout_conf[NRF_USBD_EPIN_CNT]; |
| |
| /** |
| * @brief Beginning of classes list. |
| * |
| * All enabled in current configuration instances are connected into |
| * a single linked list chain. |
| * This variable points to first element. |
| * Core class instance (connected to endpoint 0) is not listed here. |
| */ |
| static app_usbd_class_inst_t const * m_p_first_cinst; |
| |
| /** |
| * @brief Classes list that requires SOF events. |
| * |
| * Pointer to first class that requires SOF events. |
| */ |
| static app_usbd_class_inst_t const * m_p_first_sof_cinst; |
| |
| /** |
| * @brief Classes list that require SOF events in interrupt. |
| * |
| * Pointer to first class that requires SOF events in interrupt. |
| */ |
| static app_usbd_class_inst_t const * m_p_first_sof_interrupt_cinst; |
| |
| /** |
| * @brief Default configuration (when NULL is passed to @ref app_usbd_init). |
| */ |
| static const app_usbd_config_t m_default_conf = { |
| #if (!(APP_USBD_CONFIG_EVENT_QUEUE_ENABLE)) || defined(__SDK_DOXYGEN__) |
| .ev_handler = app_usbd_event_execute, |
| #endif |
| #if (APP_USBD_CONFIG_EVENT_QUEUE_ENABLE) || defined(__SDK_DOXYGEN__) |
| .ev_isr_handler = NULL, |
| #endif |
| .ev_state_proc = NULL, |
| .enable_sof = false |
| }; |
| |
| /** |
| * @brief SUSPEND state machine states. |
| * |
| * The enumeration of internal SUSPEND state machine states. |
| */ |
| typedef enum |
| { |
| SUSTATE_STOPPED, /**< The USB driver was not started */ |
| SUSTATE_STARTED, /**< The USB driver was started - waiting for USB RESET */ |
| SUSTATE_ACTIVE, /**< Active state */ |
| SUSTATE_SUSPENDING, /**< Suspending - waiting for the user to acknowledge */ |
| SUSTATE_SUSPEND, /**< Suspended */ |
| SUSTATE_RESUMING, /**< Resuming - waiting for clock */ |
| SUSTATE_WAKINGUP_WAITING_HFCLK_WREQ, /**< Waking up - waiting for clock and WUREQ from driver */ |
| SUSTATE_WAKINGUP_WAITING_HFCLK, /**< Waking up - waiting for HFCLK (WUREQ detected) */ |
| SUSTATE_WAKINGUP_WAITING_WREQ, /**< Waking up - waiting for WREQ (HFCLK active) */ |
| }app_usbd_sustate_t; |
| |
| /** |
| * @brief Current suspend state. |
| * |
| * The state of the suspend state machine. |
| */ |
| static app_usbd_sustate_t m_sustate; |
| |
| /** |
| * @brief Remote wake-up register/unregister. |
| * |
| * Counter incremented when appended instance required remote wake-up functionality. |
| * It should be decremented when the class is removed. |
| * When this counter is not zero, remote wake-up functionality is activated inside core. |
| */ |
| static uint8_t m_rwu_registered_counter; |
| |
| /** |
| * @brief Current configuration. |
| */ |
| static app_usbd_config_t m_current_conf; |
| |
| /** |
| * @brief Class interface call: event handler |
| * |
| * @ref app_usbd_class_interface_t::event_handler |
| * |
| * @param[in] p_cinst Class instance. |
| * @param[in] p_event Event passed to class instance. |
| * |
| * @return Standard error code @ref ret_code_t |
| * @retval NRF_SUCCESS event handled successfully. |
| * @retval NRF_ERROR_NOT_SUPPORTED unsupported event. |
| * */ |
| static inline ret_code_t class_event_handler(app_usbd_class_inst_t const * const p_cinst, |
| app_usbd_complex_evt_t const * const p_event) |
| { |
| ASSERT(p_cinst != NULL); |
| ASSERT(p_cinst->p_class_methods != NULL); |
| ASSERT(p_cinst->p_class_methods->event_handler != NULL); |
| return p_cinst->p_class_methods->event_handler(p_cinst, p_event); |
| } |
| |
| #if (APP_USBD_CONFIG_EVENT_QUEUE_ENABLE) || defined(__SDK_DOXYGEN__) |
| static inline void class_sof_interrupt_handler(app_usbd_class_inst_t const * const p_cinst, |
| app_usbd_complex_evt_t const * const p_event) |
| { |
| ASSERT(p_cinst != NULL); |
| ASSERT(p_cinst->p_data != NULL); |
| ASSERT(p_cinst->p_data->sof_handler != NULL); |
| p_cinst->p_data->sof_handler(p_event->drv_evt.data.sof.framecnt); |
| } |
| |
| /** |
| * @brief User event handler call (passed via configuration). |
| * |
| * @param p_event Handler of an event that is going to be added into queue. |
| * @param queued The event is visible in the queue. |
| */ |
| static inline void user_event_handler(app_usbd_internal_evt_t const * const p_event, bool queued) |
| { |
| if ((m_current_conf.ev_isr_handler) != NULL) |
| { |
| m_current_conf.ev_isr_handler(p_event, queued); |
| } |
| } |
| #endif |
| |
| /** |
| * @brief User event processor call (passed via configuration). |
| * |
| * @param event Event type. |
| */ |
| static inline void user_event_state_proc(app_usbd_event_type_t event) |
| { |
| if ((m_current_conf.ev_state_proc) != NULL) |
| { |
| m_current_conf.ev_state_proc(event); |
| } |
| } |
| |
| /** |
| * @brief Find a specified descriptor. |
| * |
| * @param[in] p_cinst Class instance. |
| * @param[in] desc_type Descriptor type @ref app_usbd_descriptor_t |
| * @param[in] desc_index Descriptor index. |
| * @param[out] p_desc Pointer to escriptor. |
| * @param[out] p_desc_len Length of descriptor. |
| * |
| * @return Standard error code @ref ret_code_t |
| * @retval NRF_SUCCESS Descriptor successfully found. |
| * @retval NRF_ERROR_NOT_FOUND Descriptor not found. |
| * */ |
| ret_code_t app_usbd_class_descriptor_find(app_usbd_class_inst_t const * const p_cinst, |
| uint8_t desc_type, |
| uint8_t desc_index, |
| uint8_t * p_desc, |
| size_t * p_desc_len) |
| { |
| app_usbd_class_descriptor_ctx_t siz; |
| APP_USBD_CLASS_DESCRIPTOR_INIT(&siz); |
| uint32_t total_size = 0; |
| while(p_cinst->p_class_methods->feed_descriptors(&siz, p_cinst, NULL, sizeof(uint8_t))) |
| { |
| total_size++; |
| } |
| |
| uint8_t cur_len = 0; |
| uint32_t cur_size = 0; |
| |
| uint8_t index = 0; |
| app_usbd_class_descriptor_ctx_t descr; |
| APP_USBD_CLASS_DESCRIPTOR_INIT(&descr); |
| |
| while(cur_size < total_size) |
| { |
| /* First byte of a descriptor is its size */ |
| UNUSED_RETURN_VALUE(p_cinst->p_class_methods->feed_descriptors(&descr, |
| p_cinst, |
| &cur_len, |
| sizeof(uint8_t))); |
| |
| /* Second byte is type of the descriptor */ |
| uint8_t type; |
| UNUSED_RETURN_VALUE(p_cinst->p_class_methods->feed_descriptors(&descr, |
| p_cinst, |
| &type, |
| sizeof(uint8_t))); |
| |
| if(type == desc_type) |
| { |
| if(index == desc_index) |
| { |
| /* Copy the length of descriptor to *p_desc_len */ |
| *p_desc_len = cur_len; |
| /* Two first bytes of descriptor have already been fed - copy them to *p_desc */ |
| *p_desc++ = cur_len; |
| *p_desc++ = desc_type; |
| /* Copy the rest of descriptor to *p_desc */ |
| UNUSED_RETURN_VALUE(p_cinst->p_class_methods->feed_descriptors(&descr, |
| p_cinst, |
| p_desc, |
| cur_len-2)); |
| return NRF_SUCCESS; |
| } |
| else |
| { |
| index++; |
| } |
| } |
| /* Fast-forward through unmatched descriptor */ |
| UNUSED_RETURN_VALUE(p_cinst->p_class_methods->feed_descriptors(&descr, |
| p_cinst, |
| NULL, |
| cur_len-2)); |
| cur_size += cur_len; |
| } |
| return NRF_ERROR_NOT_FOUND; |
| } |
| |
| /** |
| * @brief Access into selected endpoint configuration structure. |
| * |
| * @param ep Endpoint address. |
| * @return A pointer to the endpoint configuration structure. |
| * |
| * @note This function would assert when endpoint number is not correct and debugging is enabled. |
| */ |
| static app_usbd_ep_conf_t * app_usbd_ep_conf_access(nrf_drv_usbd_ep_t ep) |
| { |
| if (NRF_USBD_EPIN_CHECK(ep)) |
| { |
| uint8_t nr = NRF_USBD_EP_NR_GET(ep); |
| ASSERT(nr < NRF_USBD_EPIN_CNT); |
| return &m_epin_conf[nr]; |
| } |
| else |
| { |
| uint8_t nr = NRF_USBD_EP_NR_GET(ep); |
| ASSERT(nr < NRF_USBD_EPOUT_CNT); |
| return &m_epout_conf[nr]; |
| } |
| } |
| |
| /** |
| * @brief Accessing instance connected with selected endpoint. |
| * |
| * @param ep Endpoint number. |
| * |
| * @return The pointer to the instance connected with endpoint. |
| */ |
| static inline app_usbd_class_inst_t const * app_usbd_ep_instance_get(nrf_drv_usbd_ep_t ep) |
| { |
| return app_usbd_ep_conf_access(ep)->p_cinst; |
| } |
| |
| /** |
| * @brief Connect instance with selected endpoint. |
| * |
| * This function configures instance connected to endpoint but also sets |
| * default event handler function pointer. |
| * |
| * @param ep Endpoint number. |
| * @param p_cinst The instance to connect into the selected endpoint. |
| * NULL if endpoint is going to be disconnected. |
| * |
| * @note Disconnecting EP0 is not allowed and protected by assertion. |
| */ |
| static void app_usbd_ep_instance_set(nrf_drv_usbd_ep_t ep, app_usbd_class_inst_t const * p_cinst) |
| { |
| app_usbd_ep_conf_t * p_ep_conf = app_usbd_ep_conf_access(ep); |
| /* Set instance and default event handler */ |
| p_ep_conf->p_cinst = p_cinst; |
| if (p_cinst == NULL) |
| { |
| ASSERT((ep != NRF_DRV_USBD_EPOUT0) && (ep != NRF_DRV_USBD_EPIN0)); /* EP0 should never be disconnected */ |
| p_ep_conf->event_handler = NULL; |
| } |
| else |
| { |
| p_ep_conf->event_handler = p_cinst->p_class_methods->event_handler; |
| } |
| } |
| |
| /** |
| * @brief Call the core handler. |
| * |
| * Core instance is special kind of instance that is connected only to endpoint 0. |
| * It is not present in instance list. |
| * This auxiliary function makes future changes easier. |
| * Just call the event instance for core module here. |
| */ |
| static inline ret_code_t app_usbd_core_handler_call(app_usbd_internal_evt_t const * const p_event) |
| { |
| return m_epout_conf[0].event_handler( |
| m_epout_conf[0].p_cinst, |
| (app_usbd_complex_evt_t const *)p_event); |
| } |
| |
| |
| |
| /** |
| * @brief Add event for execution. |
| * |
| * Dependent on configuration event would be executed in place or would be added into queue |
| * to be executed later. |
| * |
| * @param p_event_input Event to be executed. |
| */ |
| static inline void app_usbd_event_add(app_usbd_internal_evt_t const * const p_event_input) |
| { |
| app_usbd_internal_evt_t const * p_event = p_event_input; |
| |
| |
| if (p_event->type == APP_USBD_EVT_DRV_SETUP) |
| { |
| uint8_t bRequest = nrf_usbd_setup_brequest_get(); |
| uint8_t bmRequestType = nrf_usbd_setup_bmrequesttype_get(); |
| |
| if ((bmRequestType == app_usbd_setup_req_val( |
| APP_USBD_SETUP_REQREC_DEVICE, |
| APP_USBD_SETUP_REQTYPE_STD, |
| APP_USBD_SETUP_REQDIR_OUT)) |
| && (bRequest == APP_USBD_SETUP_STDREQ_SET_ADDRESS)) |
| { |
| static const app_usbd_internal_evt_t event_setaddress = |
| { |
| .type = APP_USBD_EVT_SETUP_SETADDRESS, |
| }; |
| p_event = &event_setaddress; |
| } |
| } |
| |
| #if (APP_USBD_CONFIG_EVENT_QUEUE_ENABLE) |
| |
| if (p_event->app_evt.type == APP_USBD_EVT_DRV_SOF) |
| { |
| /* Propagate SOF event to classes that need it in interrupt */ |
| app_usbd_class_inst_t const * p_inst = app_usbd_class_sof_interrupt_first_get(); |
| while (NULL != p_inst) |
| { |
| class_sof_interrupt_handler(p_inst, (app_usbd_complex_evt_t const *)p_event); |
| p_inst = app_usbd_class_sof_interrupt_next_get(p_inst); |
| } |
| |
| #if (APP_USBD_CONFIG_SOF_HANDLING_MODE == APP_USBD_SOF_HANDLING_COMPRESS_QUEUE) |
| CRITICAL_REGION_ENTER(); |
| if (m_sof_events_cnt == 0) |
| { |
| m_event_frame = p_event->drv_evt.data.sof.framecnt; |
| } |
| UNUSED_RETURN_VALUE(nrf_atomic_u32_add(&m_sof_events_cnt, 1)); |
| CRITICAL_REGION_EXIT(); |
| |
| user_event_handler(p_event, true); |
| if (m_sof_events_cnt == APP_USBD_SOF_WARNING_LIMIT) |
| { |
| NRF_LOG_WARNING("Stacked over %d SOF events.", APP_USBD_SOF_WARNING_LIMIT); |
| } |
| return; |
| |
| #endif // (APP_USBD_CONFIG_SOF_HANDLING_MODE == APP_USBD_SOF_HANDLING_COMPRESS_QUEUE) |
| |
| #if (APP_USBD_CONFIG_SOF_HANDLING_MODE == APP_USBD_SOF_HANDLING_INTERRUPT) |
| |
| user_event_handler(p_event, false); |
| app_usbd_event_execute(p_event); |
| return; |
| |
| #endif // (APP_USBD_CONFIG_SOF_HANDLING_MODE == APP_USBD_SOF_HANDLING_INTERRUPT) |
| } |
| |
| nrf_atfifo_item_put_t cx; |
| app_usbd_internal_queue_evt_t * p_event_item = nrf_atfifo_item_alloc(m_event_queue, &cx); |
| |
| if (NULL != p_event_item) |
| { |
| bool visible; |
| p_event_item->evt = *p_event; |
| |
| #if (APP_USBD_CONFIG_SOF_HANDLING_MODE == APP_USBD_SOF_HANDLING_COMPRESS_QUEUE) |
| CRITICAL_REGION_ENTER(); |
| p_event_item->start_frame = m_event_frame - m_sof_events_cnt + 1; |
| p_event_item->sof_cnt = nrf_atomic_u32_fetch_store(&m_sof_events_cnt, 0); |
| CRITICAL_REGION_EXIT(); |
| #endif // (APP_USBD_CONFIG_SOF_HANDLING_MODE == APP_USBD_SOF_HANDLING_COMPRESS_QUEUE) |
| |
| visible = nrf_atfifo_item_put(m_event_queue, &cx); |
| user_event_handler(p_event, visible); |
| } |
| else |
| { |
| NRF_LOG_ERROR("Event queue full."); |
| } |
| #else |
| m_current_conf.ev_handler(p_event); |
| #endif |
| } |
| |
| /** |
| * @brief Power event handler. |
| * |
| * The function that pushes power events into the queue. |
| * @param p_event Event from power driver to map into APP_USBD_EVT_POWER_ event. |
| */ |
| #if APP_USBD_CONFIG_POWER_EVENTS_PROCESS |
| static void app_usbd_power_event_handler(nrf_drv_power_usb_evt_t event) |
| { |
| switch(event) |
| { |
| case NRF_DRV_POWER_USB_EVT_DETECTED: |
| { |
| static const app_usbd_internal_evt_t ev = { |
| .type = APP_USBD_EVT_POWER_DETECTED |
| }; |
| app_usbd_event_add(&ev); |
| break; |
| } |
| case NRF_DRV_POWER_USB_EVT_REMOVED: |
| { |
| static const app_usbd_internal_evt_t ev = { |
| .type = APP_USBD_EVT_POWER_REMOVED |
| }; |
| app_usbd_event_add(&ev); |
| break; |
| } |
| case NRF_DRV_POWER_USB_EVT_READY: |
| { |
| static const app_usbd_internal_evt_t ev = { |
| .type = APP_USBD_EVT_POWER_READY |
| }; |
| app_usbd_event_add(&ev); |
| break; |
| } |
| default: |
| ASSERT(false); |
| } |
| } |
| #endif |
| |
| /** |
| * @brief Event handler. |
| * |
| * The function that pushes the event into the queue. |
| * @param p_event Event to push. |
| */ |
| static void app_usbd_event_handler(nrf_drv_usbd_evt_t const * const p_event) |
| { |
| app_usbd_event_add((app_usbd_internal_evt_t const *)p_event); |
| } |
| |
| /** |
| * @brief HF clock ready event handler. |
| * |
| * Function that is called when high frequency clock is started. |
| * |
| * @param event Event type that comes from clock driver. |
| */ |
| static void app_usbd_hfclk_ready(nrf_drv_clock_evt_type_t event) |
| { |
| ASSERT(NRF_DRV_CLOCK_EVT_HFCLK_STARTED == event); |
| static const app_usbd_evt_t evt_data = { |
| .type = APP_USBD_EVT_HFCLK_READY |
| }; |
| app_usbd_event_add((app_usbd_internal_evt_t const * )&evt_data); |
| } |
| |
| /** |
| * @brief Check if the HFCLK was requested in selected suspend state machine state. |
| * |
| * |
| * @param sustate State to be checked. |
| * |
| * @retval true High frequency clock was requested in selected state. |
| * @retval false High frequency clock was released in selected state. |
| */ |
| static inline bool app_usbd_sustate_with_requested_hfclk(app_usbd_sustate_t sustate) |
| { |
| switch(sustate) |
| { |
| case SUSTATE_STOPPED: return false; |
| case SUSTATE_STARTED: return false; |
| case SUSTATE_ACTIVE: return true; |
| case SUSTATE_SUSPENDING: return false; |
| case SUSTATE_SUSPEND: return false; |
| case SUSTATE_RESUMING: return true; |
| case SUSTATE_WAKINGUP_WAITING_HFCLK_WREQ: return true; |
| case SUSTATE_WAKINGUP_WAITING_HFCLK: return true; |
| case SUSTATE_WAKINGUP_WAITING_WREQ: return true; |
| default: |
| return false; |
| } |
| } |
| |
| /** |
| * @brief Check it the HFCLK is running in selected suspend state machine state. |
| * |
| * @param sustate State to be checked. |
| * |
| * @retval true High frequency clock is running in selected state. |
| * @retval false High frequency clock is released in selected state. |
| */ |
| static inline bool app_usbd_sustate_with_running_hfclk(app_usbd_sustate_t sustate) |
| { |
| switch(sustate) |
| { |
| case SUSTATE_STOPPED: return false; |
| case SUSTATE_STARTED: return false; |
| case SUSTATE_ACTIVE: return true; |
| case SUSTATE_SUSPENDING: return false; |
| case SUSTATE_SUSPEND: return false; |
| case SUSTATE_RESUMING: return false; |
| case SUSTATE_WAKINGUP_WAITING_HFCLK_WREQ: return false; |
| case SUSTATE_WAKINGUP_WAITING_HFCLK: return false; |
| case SUSTATE_WAKINGUP_WAITING_WREQ: return true; |
| default: |
| return false; |
| } |
| } |
| |
| /** |
| * @brief Get current suspend state machine state. |
| * |
| * @return The state of the suspend state machine. |
| */ |
| static inline app_usbd_sustate_t sustate_get(void) |
| { |
| return m_sustate; |
| } |
| |
| /** |
| * @brief Set current suspend state machine state. |
| * |
| * @param sustate The requested state of the state machine. |
| */ |
| static inline void sustate_set(app_usbd_sustate_t sustate) |
| { |
| if (app_usbd_sustate_with_requested_hfclk(sustate) != app_usbd_sustate_with_requested_hfclk(m_sustate)) |
| { |
| if (app_usbd_sustate_with_requested_hfclk(sustate)) |
| { |
| static nrf_drv_clock_handler_item_t clock_handler_item = |
| { |
| .event_handler = app_usbd_hfclk_ready |
| }; |
| nrf_drv_clock_hfclk_request(&clock_handler_item); |
| } |
| else |
| { |
| nrf_drv_clock_hfclk_release(); |
| } |
| } |
| if (app_usbd_sustate_with_running_hfclk(sustate) != app_usbd_sustate_with_running_hfclk(m_sustate)) |
| { |
| if (app_usbd_sustate_with_running_hfclk(sustate)) |
| { |
| nrf_drv_usbd_active_irq_config(); |
| } |
| else |
| { |
| nrf_drv_usbd_suspend_irq_config(); |
| } |
| } |
| m_sustate = sustate; |
| } |
| |
| /** |
| * @brief Default selection function for interface. |
| * |
| * This function just enables and clears interface endpoints. |
| * |
| * @param[in] p_inst Class instance. |
| * @param[in] iface_idx Interface index. |
| * @param[in] alternate Interface alternate setting. |
| * |
| * @note Currently only alternate setting 0 is supported. |
| * |
| * @return Standard error code @ref ret_code_t |
| * @retval NRF_SUCCESS Endpoints enabled and cleared. |
| * @retval NRF_ERROR_INVALID_PARAM Unsupported alternate selected. |
| */ |
| static inline ret_code_t default_iface_select( |
| app_usbd_class_inst_t const * const p_inst, |
| uint8_t iface_idx, |
| uint8_t alternate) |
| { |
| ASSERT(iface_idx <= app_usbd_class_iface_count_get(p_inst)); |
| |
| if (alternate != 0) |
| { |
| return NRF_ERROR_INVALID_PARAM; |
| } |
| |
| app_usbd_class_iface_conf_t const * p_iface = app_usbd_class_iface_get(p_inst, iface_idx); |
| uint8_t ep_count = app_usbd_class_iface_ep_count_get(p_iface); |
| |
| for (uint8_t i = 0; i < ep_count; ++i) |
| { |
| /* Enable every endpoint */ |
| app_usbd_class_ep_conf_t const * p_ep = app_usbd_class_iface_ep_get(p_iface, i); |
| app_usbd_ep_enable(p_ep->address); |
| } |
| return NRF_SUCCESS; |
| } |
| |
| /** |
| * @brief Default deselection function for interface. |
| * |
| * This function just disables all interface endpoints. |
| * |
| * @param[in] p_inst Class instance. |
| * @param[in] iface_idx Interface index. |
| */ |
| static inline void default_iface_deselect( |
| app_usbd_class_inst_t const * const p_inst, |
| uint8_t iface_idx) |
| { |
| ASSERT(iface_idx <= app_usbd_class_iface_count_get(p_inst)); |
| |
| app_usbd_class_iface_conf_t const * p_iface = app_usbd_class_iface_get(p_inst, iface_idx); |
| uint8_t ep_count = app_usbd_class_iface_ep_count_get(p_iface); |
| |
| for (uint8_t i = 0; i < ep_count; ++i) |
| { |
| /* Disable every endpoint */ |
| app_usbd_class_ep_conf_t const * p_ep = app_usbd_class_iface_ep_get(p_iface, i); |
| app_usbd_ep_disable(p_ep->address); |
| } |
| } |
| |
| |
| /** @} */ |
| |
| #if (APP_USBD_PROVIDE_SOF_TIMESTAMP) || defined(__SDK_DOXYGEN__) |
| uint32_t app_usbd_sof_timestamp_get(void) |
| { |
| return m_last_frame; |
| } |
| #endif |
| |
| ret_code_t app_usbd_init(app_usbd_config_t const * p_config) |
| { |
| ASSERT(nrf_drv_clock_init_check()); |
| ret_code_t ret; |
| |
| #if (APP_USBD_CONFIG_EVENT_QUEUE_ENABLE) || defined(__SDK_DOXYGEN__) |
| ret = NRF_ATFIFO_INIT(m_event_queue); |
| if (NRF_SUCCESS != ret) |
| { |
| return NRF_ERROR_INTERNAL; |
| } |
| #endif |
| |
| /* This is called at the beginning to secure multiple calls to init function */ |
| ret = nrf_drv_usbd_init(app_usbd_event_handler); |
| if (NRF_SUCCESS != ret) |
| { |
| return ret; |
| } |
| |
| /* Clear the variables */ |
| m_sustate = SUSTATE_STOPPED; |
| m_p_first_cinst = NULL; |
| m_p_first_sof_cinst = NULL; |
| memset(m_epin_conf , 0, sizeof(m_epin_conf )); |
| memset(m_epout_conf, 0, sizeof(m_epout_conf)); |
| /* Save the new configuration */ |
| if (p_config == NULL) |
| { |
| m_current_conf = m_default_conf; |
| } |
| else |
| { |
| m_current_conf = *p_config; |
| } |
| |
| #if (!(APP_USBD_CONFIG_EVENT_QUEUE_ENABLE)) |
| if(m_current_conf.ev_handler == NULL) |
| { |
| m_current_conf.ev_handler = m_default_conf.ev_handler; |
| } |
| #endif |
| |
| #if APP_USBD_CONFIG_POWER_EVENTS_PROCESS |
| ret = nrf_drv_power_init(NULL); |
| if ((ret != NRF_SUCCESS) && (ret != NRF_ERROR_MODULE_ALREADY_INITIALIZED)) |
| { |
| /* This should never happen */ |
| APP_ERROR_HANDLER(ret); |
| } |
| #endif |
| |
| /*Pin core class to required endpoints*/ |
| uint8_t iface_idx; |
| app_usbd_class_iface_conf_t const * p_iface; |
| app_usbd_class_inst_t const * const p_inst = app_usbd_core_instance_access(); |
| iface_idx = 0; |
| while ((p_iface = app_usbd_class_iface_get(p_inst, iface_idx++)) != NULL) |
| { |
| uint8_t ep_idx = 0; |
| app_usbd_class_ep_conf_t const * p_ep; |
| while ((p_ep = app_usbd_class_iface_ep_get(p_iface, ep_idx++)) != NULL) |
| { |
| app_usbd_ep_instance_set(app_usbd_class_ep_address_get(p_ep), p_inst); |
| } |
| } |
| |
| /* Successfully attached */ |
| const app_usbd_evt_t evt_data = { |
| .type = APP_USBD_EVT_INST_APPEND |
| }; |
| |
| ret = class_event_handler(p_inst, (app_usbd_complex_evt_t const *)(&evt_data)); |
| if (NRF_SUCCESS != ret) |
| { |
| UNUSED_RETURN_VALUE(nrf_drv_usbd_uninit()); |
| return ret; |
| } |
| |
| return NRF_SUCCESS; |
| } |
| |
| |
| ret_code_t app_usbd_uninit(void) |
| { |
| #if APP_USBD_CONFIG_POWER_EVENTS_PROCESS |
| nrf_drv_power_usbevt_uninit(); |
| #endif |
| |
| /* We get this error at very beginning but it would be used at the end of the function */ |
| const ret_code_t ret = nrf_drv_usbd_uninit(); |
| |
| /* Unchain instance list */ |
| app_usbd_class_inst_t const * * pp_inst; |
| pp_inst = &m_p_first_cinst; |
| while (NULL != (*pp_inst)) |
| { |
| app_usbd_class_inst_t const * * pp_next = &app_usbd_class_data_access(*pp_inst)->p_next; |
| (*pp_inst) = NULL; |
| pp_inst = pp_next; |
| } |
| |
| /* Unchain SOF list */ |
| pp_inst = &m_p_first_sof_cinst; |
| while (NULL != (*pp_inst)) |
| { |
| app_usbd_class_inst_t const * * pp_next = &app_usbd_class_data_access(*pp_inst)->p_sof_next; |
| (*pp_inst) = NULL; |
| pp_inst = pp_next; |
| } |
| |
| /* Unchain SOF interrupt list */ |
| pp_inst = &m_p_first_sof_interrupt_cinst; |
| while (NULL != (*pp_inst)) |
| { |
| app_usbd_class_inst_t const * * pp_next = &app_usbd_class_data_access(*pp_inst)->p_sof_next; |
| (*pp_inst) = NULL; |
| pp_inst = pp_next; |
| } |
| |
| /* Clear all endpoints configurations */ |
| memset(m_epin_conf , 0, sizeof(m_epin_conf )); |
| memset(m_epout_conf, 0, sizeof(m_epout_conf)); |
| /* Clear current configuration */ |
| memset(&m_current_conf, 0, sizeof(m_current_conf)); |
| |
| return ret; |
| } |
| |
| |
| #if APP_USBD_CONFIG_POWER_EVENTS_PROCESS |
| ret_code_t app_usbd_power_events_enable(void) |
| { |
| if (!nrf_drv_usbd_is_initialized() || nrf_drv_usbd_is_enabled()) |
| { |
| return NRF_ERROR_INVALID_STATE; |
| } |
| |
| ASSERT((!APP_USBD_CONFIG_EVENT_QUEUE_ENABLE) || (USBD_CONFIG_IRQ_PRIORITY == POWER_CONFIG_IRQ_PRIORITY)); |
| |
| ret_code_t ret; |
| static const nrf_drv_power_usbevt_config_t config = |
| { |
| .handler = app_usbd_power_event_handler |
| }; |
| |
| ret = nrf_drv_power_usbevt_init(&config); |
| APP_ERROR_CHECK(ret); |
| |
| return NRF_SUCCESS; |
| } |
| #endif /* APP_USBD_CONFIG_POWER_EVENTS_PROCESS */ |
| |
| |
| void app_usbd_enable(void) |
| { |
| nrf_drv_usbd_enable(); |
| } |
| |
| |
| void app_usbd_disable(void) |
| { |
| ASSERT(!nrf_drv_usbd_is_started()); |
| nrf_drv_usbd_disable(); |
| } |
| |
| |
| void app_usbd_start(void) |
| { |
| ASSERT(nrf_drv_usbd_is_enabled()); |
| |
| /* Check if interface numbers are in correct order */ |
| if (APP_USBD_CONFIG_LOG_ENABLED) |
| { |
| uint8_t next_iface = 0; |
| for (app_usbd_class_inst_t const * * pp_inst = &m_p_first_cinst; |
| (*pp_inst) != NULL; |
| pp_inst = &(app_usbd_class_data_access(*pp_inst)->p_next)) |
| { |
| uint8_t iface_idx = 0; |
| app_usbd_class_iface_conf_t const * p_iface; |
| while (NULL != (p_iface = app_usbd_class_iface_get(*pp_inst, iface_idx++))) |
| { |
| if (p_iface->number != next_iface) |
| { |
| NRF_LOG_WARNING("Unexpected interface number, expected %d, got %d", |
| next_iface, |
| p_iface->number); |
| } |
| ++next_iface; |
| } |
| } |
| } |
| |
| /* Power should be already enabled - wait just in case if user calls |
| * app_usbd_start just after app_usbd_enable without waiting for the event. */ |
| while (!nrf_power_usbregstatus_outrdy_get()) |
| { |
| /* Wait for the power but terminate the function if USBD power disappears */ |
| if (!nrf_power_usbregstatus_vbusdet_get()) |
| return; |
| } |
| |
| static const app_usbd_evt_t evt_data = { |
| .type = APP_USBD_EVT_START_REQ |
| }; |
| app_usbd_event_add((app_usbd_internal_evt_t const * )&evt_data); |
| } |
| |
| |
| void app_usbd_stop(void) |
| { |
| const app_usbd_evt_t evt_data = { |
| .type = APP_USBD_EVT_STOP_REQ |
| }; |
| app_usbd_event_add((app_usbd_internal_evt_t const * )&evt_data); |
| } |
| |
| void app_usbd_suspend_req(void) |
| { |
| const app_usbd_evt_t evt_data = { |
| .type = APP_USBD_EVT_SUSPEND_REQ |
| }; |
| app_usbd_event_add((app_usbd_internal_evt_t const * )&evt_data); |
| } |
| |
| bool app_usbd_wakeup_req(void) |
| { |
| ASSERT(app_usbd_class_rwu_enabled_check()); |
| if (!app_usbd_core_feature_state_get(APP_USBD_SETUP_STDFEATURE_DEVICE_REMOTE_WAKEUP)) |
| return false; |
| |
| const app_usbd_evt_t evt_data = { |
| .type = APP_USBD_EVT_WAKEUP_REQ |
| }; |
| app_usbd_event_add((app_usbd_internal_evt_t const * )&evt_data); |
| return true; |
| } |
| |
| bool app_usbd_active_check(void) |
| { |
| return (sustate_get() == SUSTATE_ACTIVE); |
| } |
| |
| void app_usbd_event_execute(app_usbd_internal_evt_t const * const p_event) |
| { |
| ASSERT(NULL != m_p_first_cinst); |
| /* If no event queue is implemented, it has to be ensured that this function is never called |
| * from the context higher than USB interrupt level |
| * If queue is implemented it would be called always from Thread level |
| * if the library is used correctly. |
| * NOTE: Higher interrupt level -> lower priority value. |
| */ |
| ASSERT(USBD_CONFIG_IRQ_PRIORITY <= current_int_priority_get()); |
| |
| /* Note - there should never be situation that event is generated on disconnected endpoint */ |
| switch (p_event->type) |
| { |
| case APP_USBD_EVT_START_REQ: |
| { |
| static const app_usbd_evt_t evt_data = { |
| .type = APP_USBD_EVT_STARTED |
| }; |
| |
| /* Send event to all classes */ |
| UNUSED_RETURN_VALUE(app_usbd_core_handler_call((app_usbd_internal_evt_t const * )&evt_data)); |
| app_usbd_all_call((app_usbd_complex_evt_t const *)&evt_data); |
| user_event_state_proc(APP_USBD_EVT_STARTED); |
| |
| app_usbd_all_iface_deselect(); |
| app_usbd_core_ep0_disable(); |
| nrf_drv_usbd_start((NULL != m_p_first_sof_cinst) || (m_current_conf.enable_sof) || (APP_USBD_PROVIDE_SOF_TIMESTAMP)); |
| sustate_set(SUSTATE_STARTED); |
| break; |
| } |
| case APP_USBD_EVT_STOP_REQ: |
| { |
| static const app_usbd_evt_t evt_data = { |
| .type = APP_USBD_EVT_STOPPED |
| }; |
| |
| app_usbd_all_iface_deselect(); |
| nrf_drv_usbd_stop(); |
| sustate_set(SUSTATE_STOPPED); |
| |
| /* Send event to all classes */ |
| app_usbd_all_call((app_usbd_complex_evt_t const * )&evt_data); |
| UNUSED_RETURN_VALUE(app_usbd_core_handler_call((app_usbd_internal_evt_t const *)&evt_data)); |
| user_event_state_proc(APP_USBD_EVT_STOPPED); |
| if (app_usbd_sustate_with_requested_hfclk(sustate_get())) |
| { |
| nrf_drv_clock_hfclk_release(); |
| } |
| |
| break; |
| } |
| case APP_USBD_EVT_HFCLK_READY: |
| { |
| switch(sustate_get()) |
| { |
| case SUSTATE_RESUMING: |
| { |
| sustate_set(SUSTATE_ACTIVE); |
| break; |
| } |
| case SUSTATE_WAKINGUP_WAITING_HFCLK_WREQ: |
| { |
| sustate_set(SUSTATE_WAKINGUP_WAITING_WREQ); |
| break; |
| } |
| case SUSTATE_WAKINGUP_WAITING_HFCLK: |
| { |
| sustate_set(SUSTATE_ACTIVE); |
| break; |
| } |
| default: |
| break; // Just ignore - it can happen in specific situation |
| } |
| break; |
| } |
| case APP_USBD_EVT_SUSPEND_REQ: |
| { |
| /* Suspend request can be only processed when we are in suspending state */ |
| if (SUSTATE_SUSPENDING == sustate_get()) |
| { |
| if (nrf_drv_usbd_suspend()) |
| { |
| sustate_set(SUSTATE_SUSPEND); |
| } |
| } |
| break; |
| } |
| case APP_USBD_EVT_WAKEUP_REQ: |
| { |
| /* Suspend temporary if no suspend function was called from the application. |
| * This makes it possible to generate APP_USBD_EVT_DRV_WUREQ event from the driver */ |
| if (sustate_get() == SUSTATE_SUSPENDING) |
| { |
| if (nrf_drv_usbd_suspend()) |
| { |
| sustate_set(SUSTATE_SUSPEND); |
| } |
| } |
| if (nrf_drv_usbd_wakeup_req()) |
| { |
| sustate_set(SUSTATE_WAKINGUP_WAITING_HFCLK_WREQ); |
| } |
| break; |
| } |
| |
| case APP_USBD_EVT_DRV_SOF: |
| { |
| #if (APP_USBD_PROVIDE_SOF_TIMESTAMP) || defined(__SDK_DOXYGEN__) |
| m_last_frame = p_event->drv_evt.data.sof.framecnt; |
| #endif |
| /* Wake up if suspended */ |
| if ((sustate_get() == SUSTATE_SUSPENDING) || (sustate_get() == SUSTATE_WAKINGUP_WAITING_WREQ)) |
| { |
| static const app_usbd_evt_t evt_data = { |
| .type = APP_USBD_EVT_DRV_RESUME |
| }; |
| app_usbd_event_execute((app_usbd_internal_evt_t *)&evt_data); |
| } |
| |
| user_event_state_proc(APP_USBD_EVT_DRV_SOF); |
| |
| app_usbd_class_inst_t const * p_inst = app_usbd_class_sof_first_get(); |
| while (NULL != p_inst) |
| { |
| ret_code_t r = class_event_handler(p_inst, (app_usbd_complex_evt_t const *)p_event); |
| UNUSED_VARIABLE(r); |
| p_inst = app_usbd_class_sof_next_get(p_inst); |
| } |
| break; |
| } |
| |
| case APP_USBD_EVT_DRV_RESET: |
| { |
| app_usbd_all_iface_deselect(); |
| app_usbd_core_ep0_enable(); |
| sustate_set(SUSTATE_ACTIVE); |
| user_event_state_proc(APP_USBD_EVT_DRV_RESET); |
| /* Processing core interface (connected only to EP0) and then all instances from the list */ |
| UNUSED_RETURN_VALUE(app_usbd_core_handler_call(p_event)); |
| app_usbd_all_call((app_usbd_complex_evt_t const *)p_event); |
| break; |
| } |
| case APP_USBD_EVT_DRV_RESUME: |
| { |
| if (sustate_get() == SUSTATE_WAKINGUP_WAITING_WREQ) |
| { |
| sustate_set(SUSTATE_ACTIVE); |
| nrf_drv_usbd_force_bus_wakeup(); |
| } |
| else |
| { |
| sustate_set(SUSTATE_RESUMING); |
| } |
| user_event_state_proc(APP_USBD_EVT_DRV_RESUME); |
| /* Processing core interface (connected only to EP0) and then all instances from the list */ |
| UNUSED_RETURN_VALUE(app_usbd_core_handler_call(p_event)); |
| app_usbd_all_call((app_usbd_complex_evt_t const *)p_event); |
| break; |
| } |
| case APP_USBD_EVT_DRV_WUREQ: |
| { |
| static const app_usbd_evt_t evt_data = { |
| .type = APP_USBD_EVT_DRV_RESUME |
| }; |
| user_event_state_proc(APP_USBD_EVT_DRV_RESUME); |
| /* Processing core interface (connected only to EP0) and then all instances from the list */ |
| UNUSED_RETURN_VALUE(app_usbd_core_handler_call((app_usbd_internal_evt_t const *)&evt_data)); |
| app_usbd_all_call((app_usbd_complex_evt_t const *)&evt_data); |
| |
| switch(sustate_get()) |
| { |
| case SUSTATE_WAKINGUP_WAITING_HFCLK_WREQ: |
| sustate_set(SUSTATE_WAKINGUP_WAITING_HFCLK); |
| break; |
| case SUSTATE_WAKINGUP_WAITING_WREQ: |
| sustate_set(SUSTATE_ACTIVE); |
| break; |
| default: |
| { |
| /* This should not happen - but try to recover by setting directly active state */ |
| NRF_LOG_WARNING("Unexpected state on WUREQ event (%u)", sustate_get()); |
| sustate_set(SUSTATE_ACTIVE); |
| } |
| } |
| break; |
| } |
| case APP_USBD_EVT_DRV_SUSPEND: |
| { |
| sustate_set(SUSTATE_SUSPENDING); |
| |
| user_event_state_proc(APP_USBD_EVT_DRV_SUSPEND); |
| |
| /* Processing all instances from the list and then core interface (connected only to EP0) */ |
| app_usbd_all_call((app_usbd_complex_evt_t const *)p_event); |
| UNUSED_RETURN_VALUE(app_usbd_core_handler_call(p_event)); |
| break; |
| } |
| |
| case APP_USBD_EVT_STATE_CHANGED: |
| { |
| user_event_state_proc(APP_USBD_EVT_STATE_CHANGED); |
| /* Processing all instances from the list and then core interface (connected only to EP0) */ |
| app_usbd_all_call((app_usbd_complex_evt_t const *)p_event); |
| break; |
| } |
| |
| case APP_USBD_EVT_DRV_SETUP: |
| { |
| UNUSED_RETURN_VALUE(app_usbd_core_handler_call(p_event)); |
| break; |
| } |
| |
| case APP_USBD_EVT_SETUP_SETADDRESS: |
| { |
| UNUSED_RETURN_VALUE(app_usbd_core_handler_call(p_event)); |
| break; |
| } |
| |
| case APP_USBD_EVT_DRV_EPTRANSFER: |
| { |
| app_usbd_ep_conf_t const * p_ep_conf = |
| app_usbd_ep_conf_access(p_event->drv_evt.data.eptransfer.ep); |
| ASSERT(NULL != p_ep_conf->p_cinst); |
| ASSERT(NULL != p_ep_conf->event_handler); |
| |
| if (NRF_SUCCESS != p_ep_conf->event_handler(p_ep_conf->p_cinst, |
| (app_usbd_complex_evt_t const *)p_event)) |
| { |
| /* If error returned, every bulk/interrupt endpoint would be stalled */ |
| if (!(0 == NRF_USBD_EP_NR_GET(p_event->drv_evt.data.eptransfer.ep) || |
| NRF_USBD_EPISO_CHECK(p_event->drv_evt.data.eptransfer.ep))) |
| { |
| nrf_drv_usbd_ep_stall(p_event->drv_evt.data.eptransfer.ep); |
| } |
| } |
| break; |
| } |
| #if APP_USBD_CONFIG_POWER_EVENTS_PROCESS |
| case APP_USBD_EVT_POWER_DETECTED: |
| { |
| user_event_state_proc(APP_USBD_EVT_POWER_DETECTED); |
| app_usbd_all_call((app_usbd_complex_evt_t const *)p_event); |
| break; |
| } |
| case APP_USBD_EVT_POWER_REMOVED: |
| { |
| user_event_state_proc(APP_USBD_EVT_POWER_REMOVED); |
| app_usbd_all_call((app_usbd_complex_evt_t const *)p_event); |
| break; |
| } |
| case APP_USBD_EVT_POWER_READY: |
| { |
| user_event_state_proc(APP_USBD_EVT_POWER_READY); |
| app_usbd_all_call((app_usbd_complex_evt_t const *)p_event); |
| break; |
| } |
| #endif |
| default: |
| ASSERT(0); |
| break; |
| } |
| } |
| |
| |
| #if (APP_USBD_CONFIG_EVENT_QUEUE_ENABLE) || defined(__SDK_DOXYGEN__) |
| bool app_usbd_event_queue_process(void) |
| { |
| #if (APP_USBD_CONFIG_SOF_HANDLING_MODE == APP_USBD_SOF_HANDLING_COMPRESS_QUEUE) |
| app_usbd_internal_evt_t sof_event = { |
| .app_evt.type = APP_USBD_EVT_DRV_SOF |
| }; |
| #endif // (APP_USBD_CONFIG_SOF_HANDLING_MODE == APP_USBD_SOF_HANDLING_COMPRESS_QUEUE) |
| static nrf_atfifo_item_get_t cx; |
| static app_usbd_internal_queue_evt_t * p_event_item = NULL; |
| if (NULL == p_event_item) |
| { |
| p_event_item = nrf_atfifo_item_get(m_event_queue, &cx); |
| } |
| |
| if (NULL != p_event_item) |
| { |
| |
| #if (APP_USBD_CONFIG_SOF_HANDLING_MODE == APP_USBD_SOF_HANDLING_COMPRESS_QUEUE) |
| if (p_event_item->sof_cnt > 0) |
| { |
| if (p_event_item->start_frame > USBD_FRAMECNTR_FRAMECNTR_Msk) |
| { |
| p_event_item->start_frame = 0; |
| } |
| sof_event.drv_evt.data.sof.framecnt = (p_event_item->start_frame)++; |
| --(p_event_item->sof_cnt); |
| app_usbd_event_execute(&sof_event); |
| return true; |
| } |
| #endif // (APP_USBD_CONFIG_SOF_HANDLING_MODE == APP_USBD_SOF_HANDLING_COMPRESS_QUEUE) |
| |
| app_usbd_event_execute(&(p_event_item->evt)); |
| UNUSED_RETURN_VALUE(nrf_atfifo_item_free(m_event_queue, &cx)); |
| p_event_item = NULL; |
| return true; |
| } |
| #if (APP_USBD_CONFIG_SOF_HANDLING_MODE == APP_USBD_SOF_HANDLING_COMPRESS_QUEUE) |
| else if (m_sof_events_cnt > 0) |
| { |
| CRITICAL_REGION_ENTER(); |
| if (m_event_frame > USBD_FRAMECNTR_FRAMECNTR_Msk) |
| { |
| m_event_frame = 0; |
| } |
| sof_event.drv_evt.data.sof.framecnt = m_event_frame++; |
| UNUSED_RETURN_VALUE(nrf_atomic_u32_sub_hs(&m_sof_events_cnt, 1)); |
| CRITICAL_REGION_EXIT(); |
| app_usbd_event_execute(&sof_event); |
| return true; |
| } |
| #endif // (APP_USBD_CONFIG_SOF_HANDLING_MODE == APP_USBD_SOF_HANDLING_COMPRESS_QUEUE) |
| else |
| { |
| return false; |
| } |
| } |
| #endif |
| |
| |
| ret_code_t app_usbd_class_append(app_usbd_class_inst_t const * p_cinst) |
| { |
| ASSERT(NULL != p_cinst); |
| ASSERT(NULL != p_cinst->p_class_methods); |
| ASSERT(NULL != p_cinst->p_class_methods->event_handler); |
| ASSERT(NULL == app_usbd_class_data_access(p_cinst)->p_next); |
| |
| /* This should be only called if USBD is disabled |
| * We simply assume that USBD is enabled if its interrupts are */ |
| ASSERT(!nrf_drv_usbd_is_enabled() && nrf_drv_usbd_is_initialized()); |
| |
| /* Check if all required endpoints are available |
| * Checking is splitted from setting to avoid situation that anything |
| * is modified and then operation finishes with error */ |
| uint8_t iface_idx; |
| app_usbd_class_iface_conf_t const * p_iface; |
| |
| iface_idx = 0; |
| while (NULL != (p_iface = app_usbd_class_iface_get(p_cinst, iface_idx++))) |
| { |
| uint8_t ep_idx = 0; |
| app_usbd_class_ep_conf_t const * p_ep; |
| while (NULL != (p_ep = app_usbd_class_iface_ep_get(p_iface, ep_idx++))) |
| { |
| if (NULL != app_usbd_ep_instance_get(app_usbd_class_ep_address_get(p_ep))) |
| { |
| return NRF_ERROR_BUSY; |
| } |
| } |
| } |
| |
| /* Connecting all required endpoints */ |
| iface_idx = 0; |
| while (NULL != (p_iface = app_usbd_class_iface_get(p_cinst, iface_idx++))) |
| { |
| uint8_t ep_idx = 0; |
| app_usbd_class_ep_conf_t const * p_ep; |
| while (NULL != (p_ep = app_usbd_class_iface_ep_get(p_iface, ep_idx++))) |
| { |
| app_usbd_ep_instance_set(app_usbd_class_ep_address_get(p_ep), p_cinst); |
| } |
| } |
| |
| /* Adding pointer to this instance to the end of the chain */ |
| app_usbd_class_inst_t const * * pp_last = &m_p_first_cinst; |
| while (NULL != (*pp_last)) |
| { |
| ASSERT((*pp_last) != p_cinst); |
| pp_last = &(app_usbd_class_data_access(*pp_last)->p_next); |
| } |
| (*pp_last) = p_cinst; |
| |
| /* Successfully attached */ |
| const app_usbd_evt_t evt_data = {.type = APP_USBD_EVT_INST_APPEND }; |
| return class_event_handler(p_cinst, (app_usbd_complex_evt_t const *)(&evt_data)); |
| } |
| |
| |
| ret_code_t app_usbd_class_remove(app_usbd_class_inst_t const * p_cinst) |
| { |
| ASSERT(NULL != p_cinst); |
| ASSERT(NULL != p_cinst->p_class_methods); |
| ASSERT(NULL != p_cinst->p_class_methods->event_handler); |
| /* This function should be only called if USBD is disabled */ |
| ASSERT(!nrf_drv_usbd_is_enabled() && nrf_drv_usbd_is_initialized()); |
| ret_code_t ret; |
| /* Remove this class from the chain */ |
| app_usbd_class_inst_t const * * pp_last = &m_p_first_cinst; |
| while (NULL != (*pp_last)) |
| { |
| if ((*pp_last) == p_cinst) |
| { |
| /* Inform class instance that removing process is going to be started */ |
| const app_usbd_evt_t evt_data = { |
| .type = APP_USBD_EVT_INST_REMOVE |
| }; |
| ret = class_event_handler(p_cinst, (app_usbd_complex_evt_t const *)(&evt_data)); |
| if (ret != NRF_SUCCESS) |
| { |
| return ret; |
| } |
| |
| /* Breaking chain */ |
| (*pp_last) = (app_usbd_class_data_access(p_cinst)->p_next); |
| app_usbd_class_data_access(p_cinst)->p_next = NULL; |
| |
| /* Disconnecting endpoints */ |
| uint8_t ep_idx; |
| for (ep_idx = 0; ep_idx < NRF_USBD_EPIN_CNT; ++ep_idx) |
| { |
| nrf_drv_usbd_ep_t ep = NRF_DRV_USBD_EPIN(ep_idx); |
| if (app_usbd_ep_instance_get(ep) == p_cinst) |
| { |
| app_usbd_ep_instance_set(ep, NULL); |
| } |
| } |
| for (ep_idx = 0; ep_idx < NRF_USBD_EPOUT_CNT; ++ep_idx) |
| { |
| nrf_drv_usbd_ep_t ep = NRF_DRV_USBD_EPOUT(ep_idx); |
| if (app_usbd_ep_instance_get(ep) == p_cinst) |
| { |
| app_usbd_ep_instance_set(ep, NULL); |
| } |
| } |
| |
| return NRF_SUCCESS; |
| } |
| pp_last = &(app_usbd_class_data_access(*pp_last)->p_next); |
| } |
| |
| return NRF_ERROR_NOT_FOUND; |
| } |
| |
| |
| ret_code_t app_usbd_class_remove_all(void) |
| { |
| ret_code_t ret = NRF_SUCCESS; |
| while (NULL != m_p_first_cinst) |
| { |
| ret = app_usbd_class_remove(m_p_first_cinst); |
| if (ret != NRF_SUCCESS) |
| { |
| break; |
| } |
| } |
| |
| return ret; |
| } |
| |
| |
| ret_code_t app_usbd_ep_handler_set(app_usbd_class_inst_t const * const p_cinst, |
| nrf_drv_usbd_ep_t ep, |
| app_usbd_ep_event_handler_t handler) |
| { |
| ASSERT(NULL != p_cinst); |
| ASSERT(NULL != handler); |
| /* This function should be only called if USBD is disabled */ |
| ASSERT(!nrf_drv_usbd_is_enabled() && nrf_drv_usbd_is_initialized()); |
| |
| if (p_cinst != app_usbd_ep_instance_get(ep)) |
| { |
| return NRF_ERROR_INVALID_PARAM; |
| } |
| |
| (app_usbd_ep_conf_access(ep))->event_handler = handler; |
| return NRF_SUCCESS; |
| } |
| |
| |
| ret_code_t app_usbd_class_sof_register(app_usbd_class_inst_t const * p_cinst) |
| { |
| ASSERT(NULL != p_cinst); |
| ASSERT(NULL != p_cinst->p_class_methods); |
| ASSERT(NULL != p_cinst->p_class_methods->event_handler); |
| /* This function should be only called if USBD is disabled */ |
| ASSERT(!nrf_drv_usbd_is_enabled() && nrf_drv_usbd_is_initialized()); |
| |
| /* Make sure it's not in interrupt SOF list */ |
| app_usbd_class_inst_t const * * pp_last = &m_p_first_sof_interrupt_cinst; |
| while (NULL != (*pp_last)) |
| { |
| ASSERT((*pp_last) != p_cinst); |
| pp_last = &(app_usbd_class_data_access(*pp_last)->p_sof_next); |
| } |
| |
| /* Next SOF event requiring instance has to be NULL now */ |
| ASSERT(NULL == (app_usbd_class_data_access(p_cinst)->p_sof_next)); |
| |
| /* Adding pointer to this instance to the end of the chain */ |
| pp_last = &m_p_first_sof_cinst; |
| while (NULL != (*pp_last)) |
| { |
| ASSERT((*pp_last) != p_cinst); |
| pp_last = &(app_usbd_class_data_access(*pp_last)->p_sof_next); |
| } |
| (*pp_last) = p_cinst; |
| |
| return NRF_SUCCESS; |
| } |
| |
| |
| ret_code_t app_usbd_class_sof_unregister(app_usbd_class_inst_t const * p_cinst) |
| { |
| ASSERT(NULL != p_cinst); |
| /** This function should be only called if USBD is disabled */ |
| ASSERT(!nrf_drv_usbd_is_enabled() && nrf_drv_usbd_is_initialized()); |
| |
| app_usbd_class_inst_t const * * pp_last = &m_p_first_sof_cinst; |
| while (NULL != (*pp_last)) |
| { |
| if ((*pp_last) == p_cinst) |
| { |
| /* Breaking chain */ |
| (*pp_last) = (app_usbd_class_data_access(p_cinst)->p_sof_next); |
| app_usbd_class_data_access(p_cinst)->p_sof_next = NULL; |
| |
| return NRF_SUCCESS; |
| } |
| pp_last = &(app_usbd_class_data_access(*pp_last)->p_sof_next); |
| } |
| return NRF_ERROR_NOT_FOUND; |
| } |
| |
| ret_code_t app_usbd_class_sof_interrupt_register(app_usbd_class_inst_t const * p_cinst, app_usbd_sof_interrupt_handler_t handler) |
| { |
| ASSERT(NULL != p_cinst); |
| ASSERT(NULL != p_cinst->p_class_methods); |
| ASSERT(NULL != handler); |
| /* This function should be only called if USBD is disabled */ |
| ASSERT(!nrf_drv_usbd_is_enabled() && nrf_drv_usbd_is_initialized()); |
| |
| /* Next SOF event requiring instance has to be NULL now */ |
| ASSERT(NULL == (app_usbd_class_data_access(p_cinst)->p_sof_next)); |
| |
| app_usbd_class_data_access(p_cinst)->sof_handler = handler; |
| |
| /* Make sure it's not in normal SOF list */ |
| app_usbd_class_inst_t const * * pp_last = &m_p_first_sof_cinst; |
| while (NULL != (*pp_last)) |
| { |
| ASSERT((*pp_last) != p_cinst); |
| pp_last = &(app_usbd_class_data_access(*pp_last)->p_sof_next); |
| } |
| |
| /* Adding pointer to this instance to the end of the interrupt chain */ |
| pp_last = &m_p_first_sof_interrupt_cinst; |
| while (NULL != (*pp_last)) |
| { |
| |
| ASSERT((*pp_last) != p_cinst); |
| pp_last = &(app_usbd_class_data_access(*pp_last)->p_sof_next); |
| } |
| (*pp_last) = p_cinst; |
| |
| return NRF_SUCCESS; |
| } |
| |
| |
| ret_code_t app_usbd_class_sof_interrupt_unregister(app_usbd_class_inst_t const * p_cinst) |
| { |
| ASSERT(NULL != p_cinst); |
| /** This function should be only called if USBD is disabled */ |
| ASSERT(!nrf_drv_usbd_is_enabled() && nrf_drv_usbd_is_initialized()); |
| |
| app_usbd_class_inst_t const * * pp_last = &m_p_first_sof_interrupt_cinst; |
| while (NULL != (*pp_last)) |
| { |
| if ((*pp_last) == p_cinst) |
| { |
| /* Breaking chain */ |
| (*pp_last) = (app_usbd_class_data_access(p_cinst)->p_sof_next); |
| app_usbd_class_data_access(p_cinst)->p_sof_next = NULL; |
| |
| return NRF_SUCCESS; |
| } |
| pp_last = &(app_usbd_class_data_access(*pp_last)->p_sof_next); |
| } |
| return NRF_ERROR_NOT_FOUND; |
| } |
| |
| ret_code_t app_usbd_class_rwu_register(app_usbd_class_inst_t const * const p_inst) |
| { |
| ASSERT(p_inst != NULL); |
| ++m_rwu_registered_counter; |
| /*Overflow check*/ |
| ASSERT(m_rwu_registered_counter != 0); |
| |
| return NRF_SUCCESS; |
| } |
| |
| |
| ret_code_t app_usbd_class_rwu_unregister(app_usbd_class_inst_t const * const p_inst) |
| { |
| ASSERT(p_inst != NULL); |
| /* Usage validation. If counter is 0 unregister is not possible.*/ |
| ASSERT(m_rwu_registered_counter != 0); |
| --m_rwu_registered_counter; |
| |
| return NRF_SUCCESS; |
| } |
| |
| bool app_usbd_class_rwu_enabled_check(void) |
| { |
| return (m_rwu_registered_counter != 0); |
| } |
| |
| ret_code_t app_usbd_interface_ep_reset(app_usbd_class_inst_t const * const p_cinst, |
| uint8_t iface) |
| { |
| uint8_t iface_count = app_usbd_class_iface_count_get(p_cinst); |
| |
| app_usbd_class_iface_conf_t const * p_iface = NULL; |
| for (uint8_t j = 0; j < iface_count; ++j) |
| { |
| p_iface = app_usbd_class_iface_get(p_cinst, j); |
| if (app_usbd_class_iface_number_get(p_iface) == iface) |
| { |
| break; |
| } |
| } |
| |
| if (p_iface == NULL) |
| { |
| return NRF_ERROR_NOT_SUPPORTED; |
| } |
| |
| uint8_t ep_count = app_usbd_class_iface_ep_count_get(p_iface); |
| |
| for (uint8_t j = 0; j < ep_count; ++j) |
| { |
| /*Clear stall for every endpoint*/ |
| app_usbd_class_ep_conf_t const * p_ep = app_usbd_class_iface_ep_get(p_iface, j); |
| |
| if (!NRF_USBD_EPISO_CHECK(p_ep->address)) |
| { |
| nrf_drv_usbd_ep_dtoggle_clear(p_ep->address); |
| nrf_drv_usbd_ep_stall_clear(p_ep->address); |
| } |
| |
| } |
| |
| return NRF_SUCCESS; |
| } |
| |
| void app_usbd_ep_enable(nrf_drv_usbd_ep_t ep) |
| { |
| if (!NRF_USBD_EPISO_CHECK(ep)) |
| { |
| nrf_drv_usbd_ep_dtoggle_clear(ep); |
| nrf_drv_usbd_ep_stall_clear(ep); |
| } |
| nrf_drv_usbd_ep_enable(ep); |
| } |
| |
| void app_usbd_ep_disable(nrf_drv_usbd_ep_t ep) |
| { |
| nrf_drv_usbd_ep_disable(ep); |
| } |
| |
| |
| app_usbd_class_inst_t const * app_usbd_class_first_get(void) |
| { |
| return m_p_first_cinst; |
| } |
| |
| app_usbd_class_inst_t const * app_usbd_class_sof_first_get(void) |
| { |
| return m_p_first_sof_cinst; |
| } |
| |
| app_usbd_class_inst_t const * app_usbd_class_sof_interrupt_first_get(void) |
| { |
| return m_p_first_sof_interrupt_cinst; |
| } |
| |
| app_usbd_class_inst_t const * app_usbd_iface_find(uint8_t iface, uint8_t * p_iface_idx) |
| { |
| app_usbd_class_inst_t const * p_inst = app_usbd_class_first_get(); |
| while (p_inst != NULL) |
| { |
| uint8_t iface_count = app_usbd_class_iface_count_get(p_inst); |
| /* Iterate over interfaces */ |
| for (uint8_t i = 0; i < iface_count; ++i) |
| { |
| app_usbd_class_iface_conf_t const * p_iface; |
| p_iface = app_usbd_class_iface_get(p_inst, i); |
| if (app_usbd_class_iface_number_get(p_iface) == iface) |
| { |
| if (p_iface_idx != NULL) |
| { |
| (*p_iface_idx) = i; |
| } |
| return p_inst; |
| } |
| } |
| p_inst = app_usbd_class_next_get(p_inst); |
| } |
| return NULL; |
| } |
| |
| ret_code_t app_usbd_iface_call( |
| app_usbd_class_inst_t const * const p_class_inst, |
| uint8_t iface_idx, |
| app_usbd_complex_evt_t const * const p_event) |
| { |
| UNUSED_PARAMETER(iface_idx); |
| return class_event_handler(p_class_inst, p_event); |
| } |
| |
| ret_code_t app_usbd_ep_call(nrf_drv_usbd_ep_t ep, app_usbd_complex_evt_t const * const p_event) |
| { |
| if (NRF_USBD_EP_VALIDATE(ep)) |
| { |
| app_usbd_class_inst_t const * p_inst = app_usbd_ep_conf_access(ep)->p_cinst; |
| if (p_inst != NULL) |
| { |
| return class_event_handler(p_inst, p_event); |
| } |
| } |
| return NRF_ERROR_INVALID_ADDR; |
| } |
| |
| void app_usbd_all_call(app_usbd_complex_evt_t const * const p_event) |
| { |
| app_usbd_class_inst_t const * p_inst; |
| for (p_inst = app_usbd_class_first_get(); NULL != p_inst; |
| p_inst = app_usbd_class_next_get(p_inst)) |
| { |
| UNUSED_RETURN_VALUE(class_event_handler(p_inst, p_event)); |
| } |
| } |
| |
| ret_code_t app_usbd_all_until_served_call(app_usbd_complex_evt_t const * const p_event) |
| { |
| app_usbd_class_inst_t const * p_inst; |
| ret_code_t ret = NRF_ERROR_NOT_SUPPORTED; |
| /* Try to process via every instance */ |
| for (p_inst = app_usbd_class_first_get(); NULL != p_inst; |
| p_inst = app_usbd_class_next_get(p_inst)) |
| { |
| |
| ret = class_event_handler(p_inst, p_event); |
| if (NRF_ERROR_NOT_SUPPORTED != ret) |
| { |
| /* Processing finished */ |
| break; |
| } |
| } |
| |
| return ret; |
| } |
| |
| ret_code_t app_usbd_ep_transfer( |
| nrf_drv_usbd_ep_t ep, |
| nrf_drv_usbd_transfer_t const * const p_transfer) |
| { |
| if (!nrf_drv_usbd_ep_enable_check(ep)) |
| { |
| return NRF_ERROR_INVALID_STATE; |
| } |
| if (m_sustate != SUSTATE_ACTIVE) |
| { |
| return NRF_ERROR_INVALID_STATE; |
| } |
| return nrf_drv_usbd_ep_transfer(ep, p_transfer); |
| } |
| |
| ret_code_t app_usbd_ep_handled_transfer( |
| nrf_drv_usbd_ep_t ep, |
| nrf_drv_usbd_handler_desc_t const * const p_handler) |
| { |
| if (!nrf_drv_usbd_ep_enable_check(ep)) |
| { |
| return NRF_ERROR_INVALID_STATE; |
| } |
| if (m_sustate != SUSTATE_ACTIVE) |
| { |
| return NRF_ERROR_INVALID_STATE; |
| } |
| return nrf_drv_usbd_ep_handled_transfer(ep, p_handler); |
| } |
| |
| ret_code_t app_usbd_iface_select( |
| app_usbd_class_inst_t const * const p_inst, |
| uint8_t iface_idx, |
| uint8_t alternate) |
| { |
| ret_code_t ret = NRF_ERROR_NOT_SUPPORTED; |
| |
| if (p_inst->p_class_methods->iface_select != NULL) |
| { |
| ret = p_inst->p_class_methods->iface_select(p_inst, iface_idx, alternate); |
| } |
| |
| if(ret == NRF_ERROR_NOT_SUPPORTED) |
| { |
| ret = default_iface_select(p_inst, iface_idx, alternate); |
| } |
| return ret; |
| } |
| |
| void app_usbd_iface_deselect( |
| app_usbd_class_inst_t const * const p_inst, |
| uint8_t iface_idx) |
| { |
| if (p_inst->p_class_methods->iface_deselect != NULL) |
| { |
| p_inst->p_class_methods->iface_deselect(p_inst, iface_idx); |
| } |
| default_iface_deselect(p_inst, iface_idx); |
| } |
| |
| uint8_t app_usbd_iface_selection_get( |
| app_usbd_class_inst_t const * const p_inst, |
| uint8_t iface_idx) |
| { |
| uint8_t alt = 0; |
| if (p_inst->p_class_methods->iface_selection_get != NULL) |
| { |
| alt = p_inst->p_class_methods->iface_selection_get(p_inst, iface_idx); |
| } |
| return alt; |
| } |
| |
| void app_usbd_all_iface_select_0(void) |
| { |
| app_usbd_class_inst_t const * p_inst = app_usbd_class_first_get(); |
| while (p_inst != NULL) |
| { |
| uint8_t iface_count = app_usbd_class_iface_count_get(p_inst); |
| for (uint8_t i = 0; i < iface_count; ++i) |
| { |
| ret_code_t ret; |
| ret = app_usbd_iface_select(p_inst, i, 0); |
| ASSERT(ret == NRF_SUCCESS); |
| UNUSED_VARIABLE(ret); |
| } |
| p_inst = app_usbd_class_next_get(p_inst); |
| } |
| } |
| |
| void app_usbd_all_iface_deselect(void) |
| { |
| app_usbd_class_inst_t const * p_inst = app_usbd_class_first_get(); |
| while (p_inst != NULL) |
| { |
| uint8_t iface_count = app_usbd_class_iface_count_get(p_inst); |
| for (uint8_t i = 0; i < iface_count; ++i) |
| { |
| app_usbd_iface_deselect(p_inst, i); |
| } |
| p_inst = app_usbd_class_next_get(p_inst); |
| } |
| } |
| |
| #endif //NRF_MODULE_ENABLED(APP_USBD) |
