/** | |
* 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_H__ | |
#define APP_USBD_H__ | |
#include "nrf_drv_usbd.h" | |
#include "app_usbd_types.h" | |
#include "app_usbd_class_base.h" | |
#ifdef __cplusplus | |
extern "C" { | |
#endif | |
/** | |
* @defgroup app_usbd USB Device high level library | |
* @ingroup app_common | |
* | |
* @brief @tagAPI52840 Module for easy support for any USB device configuration. | |
* | |
* This module manages class instances that would create the USB device, | |
* manages endpoints and interfaces transactions. | |
* @{ | |
*/ | |
/** | |
* @brief Highest value of Frame Number in SOF packets. | |
*/ | |
#define APP_USBD_SOF_MAX 2047 | |
/** | |
* @brief True if SOF timestamping is really provided. | |
* | |
* SOF timestamping is really provided if it was requested and if the logger is enabled. | |
*/ | |
#if ((APP_USBD_CONFIG_SOF_TIMESTAMP_PROVIDE) && (NRF_LOG_ENABLED)) | |
#define APP_USBD_PROVIDE_SOF_TIMESTAMP 1 | |
#else | |
#define APP_USBD_PROVIDE_SOF_TIMESTAMP 0 | |
#endif | |
/** | |
* @brief SOF event handling modes. | |
*/ | |
#define APP_USBD_SOF_HANDLING_NORMAL_QUEUE 0 //!< Push SOF events into event queue. | |
#define APP_USBD_SOF_HANDLING_COMPRESS_QUEUE 1 //!< Compress SOF events. | |
#define APP_USBD_SOF_HANDLING_INTERRUPT 2 //!< Handle SOF events in interrupt. | |
/** | |
* @brief Configuration passed to @ref app_usbd_init. | |
*/ | |
typedef struct { | |
#if (!(APP_USBD_CONFIG_EVENT_QUEUE_ENABLE)) || defined(__SDK_DOXYGEN__) | |
/** | |
* @brief User defined event handler. | |
* | |
* This function is called on every event from the interrupt. | |
* It is prepared for external user function that would queue events to be processed | |
* from the main context. | |
* It should be used with operating systems with its own implementation of the queue. | |
* | |
* @param p_event The event structure pointer. | |
* | |
* @note This field is available only when USB internal queue is disabled | |
* (see @ref APP_USBD_CONFIG_EVENT_QUEUE_ENABLE). | |
*/ | |
void (*ev_handler)(app_usbd_internal_evt_t const * const p_event); | |
#endif | |
#if (APP_USBD_CONFIG_EVENT_QUEUE_ENABLE) || defined(__SDK_DOXYGEN__) | |
/** | |
* @brief User defined event handler. | |
* | |
* This function is called on every event from the interrupt. | |
* | |
* @param p_event The event structure pointer. | |
* @param queued The event is visible in the queue. | |
* If queue conflict is detected the event might not be accessible inside queue | |
* until all write operations finish. | |
* See @ref nrf_atfifo for more details. | |
* | |
* @note This field is available only when USBD internal queue is configured | |
* (see @ref APP_USBD_CONFIG_EVENT_QUEUE_ENABLE). | |
* | |
* @note If is set to NULL no event would be called from interrupt. | |
* @note This function is called before event is processed. | |
* It means that if the event type is @ref APP_USBD_EVT_DRV_SETUP, | |
* there would not be setup field present in the event structure. | |
*/ | |
void (*ev_isr_handler)(app_usbd_internal_evt_t const * const p_event, bool queued); | |
#endif | |
/** | |
* @brief User defined event processor | |
* | |
* This function is called while state event is processed. | |
* | |
* * @note This field is available only when USBD internal queue is configured | |
* (see @ref APP_USBD_CONFIG_EVENT_QUEUE_ENABLE). | |
* | |
* @param event Event type. | |
* Only following events are sent into this function: | |
* - APP_USBD_EVT_DRV_SOF | |
* - APP_USBD_EVT_DRV_RESET - Note that it also exits suspend | |
* - APP_USBD_EVT_DRV_SUSPEND | |
* - APP_USBD_EVT_DRV_RESUME - It is also generated when remote wakeup is generated | |
* - APP_USBD_EVT_START | |
* - APP_USBD_EVT_STOP | |
* - APP_USBD_EVT_STATE_CHANGED | |
* - APP_USBD_EVT_POWER_DETECTED | |
* - APP_USBD_EVT_POWER_REMOVED | |
* - APP_USBD_EVT_POWER_READY | |
*/ | |
void (*ev_state_proc)(app_usbd_event_type_t event); | |
/** | |
* @brief SOF processing required by the user event processing. | |
* | |
* This flag would enable SOF processing for the user events regardless of the fact if any | |
* of the implemented class requires SOF event. | |
* | |
* @note SOF event would be enabled anyway if any of the appended class requires SOF processing. | |
*/ | |
bool enable_sof; | |
} app_usbd_config_t; | |
#if (APP_USBD_PROVIDE_SOF_TIMESTAMP) || defined(__SDK_DOXYGEN__) | |
/** | |
* @brief Timestamp function for the logger. | |
* | |
* @return Current frame number taken directly from the last processed SOF. | |
*/ | |
uint32_t app_usbd_sof_timestamp_get(void); | |
#endif | |
/** | |
* @brief USB library initialization. | |
* | |
* Call this function before any configuration or class attachment. | |
* USBD peripheral would be ready to accept commands, and library would be ready, | |
* but it would not be connected to the bus. | |
* Call @ref app_usbd_enable to enable USBD communication with the host. | |
* | |
* @param p_config Configuration. NULL pointer might be passed here and default | |
* configuration will be applied then. | |
*/ | |
ret_code_t app_usbd_init(app_usbd_config_t const * p_config); | |
/** | |
* @brief USB library un-initialization. | |
* | |
* @note Currently not supported. | |
*/ | |
ret_code_t app_usbd_uninit(void); | |
#if (APP_USBD_CONFIG_POWER_EVENTS_PROCESS) || defined(__SDK_DOXYGEN__) | |
/** | |
* @brief Function to start USB related power events processing. | |
* | |
* This function should be called after @ref app_usbd_init and after all the | |
* required classes were appended (@ref app_usbd_class_append). | |
* | |
* @retval NRF_SUCCESS Power events successfully initialized. | |
* @retval NRF_ERROR_INVALID_STATE The state of the driver does not allow to enable | |
* the power events processing. | |
*/ | |
ret_code_t app_usbd_power_events_enable(void); | |
#endif | |
/** | |
* @brief Enable USBD. | |
* | |
* USBD is enabled. | |
* Since now the high frequency clock may be requested when USB RESET would be detected. | |
*/ | |
void app_usbd_enable(void); | |
/** | |
* @brief Disable USBD. | |
* | |
* Disabled USDB peripheral cannot be accessed but also stops requesting | |
* High Frequency clock and releases power regulator. | |
* | |
* @note This function cannot be called when USB is started. Stop it first. | |
*/ | |
void app_usbd_disable(void); | |
/** | |
* @brief Request USBD to start. | |
* | |
* The function sends start request to the event queue. | |
* If the queue is enabled (@ref APP_USBD_CONFIG_EVENT_QUEUE_ENABLE) it would be processed | |
* when the queue is processed. | |
* If queue is disabled it would be processed immediately inside this function. | |
* It means that if queue is disabled this function cannot be called from interrupt with priority | |
* higher than USB interrupt. | |
* | |
* When start is processed it would: | |
* 1. Start library. | |
* 2. Enable interrupts. | |
* 3. Enable USB pull-ups. | |
* | |
* @note | |
* In some specific circumstances the library can be left not started and this function would | |
* silently exit. | |
* This may happen if some glitches appears on USB power line or if the plug was disconnected before | |
* whole starting process finishes. | |
* User would get the event from POWER peripheral then. | |
* Also no @ref APP_USBD_EVT_STARTED event would be generated to the classes and user event handler. | |
* For the safe code it is recommended to wait for @ref APP_USBD_EVT_STARTED event if anything | |
* has to be initialized after USB driver is started (just before enabling the interrupts). | |
* If library is properly started the @ref APP_USBD_EVT_STARTED event passed to the user handler | |
* from this function body. | |
*/ | |
void app_usbd_start(void); | |
/** | |
* @brief Stop USB. | |
* | |
* The function sends stop request to the event queue. | |
* If the queue is enabled (@ref APP_USBD_CONFIG_EVENT_QUEUE_ENABLE) it would be processed | |
* when the queue is processed. | |
* If queue is disabled it would be processed immediately inside this function. | |
* It means that if queue is disabled this function cannot be called from interrupt with priority | |
* higher than USB interrupt. | |
* | |
* When the event is processed interrupts and USB pull-ups are disabled. | |
* The peripheral itself is left enabled so it can be programmed, | |
* but a HOST sees it as a peripheral disconnection. | |
* | |
* @note | |
* If the library is not started when this function is called it exits silently - also | |
* no @ref APP_USBD_EVT_STOPPED is generated. | |
*/ | |
void app_usbd_stop(void); | |
/** | |
* @brief Request library to suspend. | |
* | |
* This function send suspend request to the event queue. | |
* | |
* @note This function should only be called after @ref APP_USBD_EVT_DRV_SUSPEND os received. | |
* Internal suspend request processing would give no effect if the bus is not in suspend state. | |
*/ | |
void app_usbd_suspend_req(void); | |
/** | |
* @brief Request library to wake-up. | |
* | |
* This function send wakeup request to the event queue. | |
* | |
* @note Calling this function does not mean that peripheral is active - the wakeup request is sent | |
* into message queue and needs to be processed. | |
* | |
* @retval true Wakeup generation has been started. | |
* @retval false No wakeup would be generated becouse it is disabled by the host. | |
*/ | |
bool app_usbd_wakeup_req(void); | |
/** | |
* @brief Get information whether there is an active connection. | |
* | |
* Function to check if the communication with the bus is possible. | |
* | |
* @retval true The bus is active. | |
* @retval false There is no connection or bus is suspended. | |
*/ | |
bool app_usbd_active_check(void); | |
/** | |
* @brief USBD event processor. | |
* | |
* Function to be called on each event to be processed by the library. | |
*/ | |
void app_usbd_event_execute(app_usbd_internal_evt_t const * const p_event); | |
#if (APP_USBD_CONFIG_EVENT_QUEUE_ENABLE) || defined(__SDK_DOXYGEN__) | |
/** | |
* @brief Function that process events from the queue. | |
* | |
* @note This function calls @ref app_usbd_event_execute internally. | |
* | |
* @retval true Event was processed. | |
* @retval false The event queue is empty. | |
*/ | |
bool app_usbd_event_queue_process(void); | |
#endif | |
/** | |
* @brief Add class instance. | |
* | |
* This function connects given instance into internal class instance chain and | |
* into all required endpoints. | |
* The instance event handler would be connected into endpoint by default, | |
* but this can be overwritten by @ref app_usbd_ep_handler_set. | |
* | |
* After successful attachment @ref APP_USBD_EVT_INST_APPEND would be passed to class instance. | |
* | |
* @note This function can only be called after USBD library is initialized but still disabled. | |
* Assertion would be generated otherwise. | |
* | |
* @param[in,out] p_cinst Instance to connect. Chain data would be written into writable instance data. | |
* | |
* @retval NRF_SUCCESS Instance successfully added. | |
* @retval NRF_ERROR_BUSY Endpoint(s) not available. | |
*/ | |
ret_code_t app_usbd_class_append(app_usbd_class_inst_t const * p_cinst); | |
/** | |
* @brief Remove class instance. | |
* | |
* Instance is removed from instance chain. | |
* Instance and event handlers are removed also from endpoints. | |
* Endpoints used by by the class instance are left disabled. | |
* | |
* @note This function can only be called after USBD library is initialized but still disabled. | |
* Assertion would be generated otherwise. | |
* | |
* @param p_cinst Instance pointer to remove. | |
* | |
* @retval NRF_SUCCESS Instance successfully removed. | |
* @retval NRF_ERROR_NOT_FOUND Instance not found in the instance chain. | |
*/ | |
ret_code_t app_usbd_class_remove(app_usbd_class_inst_t const * p_cinst); | |
/** | |
* @brief Remove all class instances. | |
* | |
* This function basically calls @ref app_usbd_class_remove | |
* on instances chain as long as there is any element left. | |
* | |
* @note This function can only be called after USBD library is initialized but still disabled. | |
* Assertion would be generated otherwise. | |
* | |
* @sa app_usbd_class_remove | |
* | |
* @return Is should always return @ref NRF_SUCCESS. | |
* Any error value returned would mean there is an error inside the library. | |
*/ | |
ret_code_t app_usbd_class_remove_all(void); | |
/** | |
* @brief Change endpoint handler. | |
* | |
* This function may be called for the endpoint only if the class instance is | |
* already properly attached by the @ref app_usbd_class_append function. | |
* | |
* The endpoint event handler function can be only overwritten by the class instance | |
* that was connected into the endpoint. | |
* | |
* @note This function can only be called after USBD library is initialized but still disabled. | |
* Assertion would be generated otherwise. | |
* | |
* @param[in] p_cinst Instance of a class that wish to set new event handler. | |
* It has to match currently configured instance for the selected endpoint. | |
* In other situation error would be returned. | |
* @param[in] ep Endpoint address to configure. | |
* @param[in] handler Event handler function to set. | |
* | |
* @retval NRF_SUCCESS New handler successfully set | |
* @retval NRF_ERROR_INVALID_PARAM p_cinst is not the same as currently set for the endpoint | |
*/ | |
ret_code_t app_usbd_ep_handler_set(app_usbd_class_inst_t const * p_cinst, | |
nrf_drv_usbd_ep_t ep, | |
app_usbd_ep_event_handler_t handler); | |
/** | |
* @brief Register class instance as the one that requires SOF events. | |
* | |
* This function should be called in reaction on APP_USBD_EVT_INST_APPEND event. | |
* Connect the class instance to the list of instances that requires SOF processing. | |
* If none of the appended instances requires SOF event - it is disabled. | |
* | |
* @param p_cinst Instance that requires SOF event. | |
* | |
* @retval NRF_SUCCESS Instance linked into SOF processing list. | |
* | |
* @sa app_usbd_class_sof_unregister | |
*/ | |
ret_code_t app_usbd_class_sof_register(app_usbd_class_inst_t const * p_cinst); | |
/** | |
* @brief Unregister class instance from SOF processing instances list. | |
* | |
* Every class that calls @ref app_usbd_class_sof_register have to call also unregistering function | |
* in reaction to @ref APP_USBD_EVT_INST_REMOVE event. | |
* | |
* @param p_cinst Instance to be unregistered from SOF event processing list. | |
* | |
* @retval NRF_SUCCESS Instance linked into SOF processing list. | |
* @retval NRF_ERROR_NOT_FOUND Instance not found in the SOF processing list. | |
* | |
* @sa app_usbd_class_sof_register | |
*/ | |
ret_code_t app_usbd_class_sof_unregister(app_usbd_class_inst_t const * p_cinst); | |
/** | |
* @brief Register class instance as the one that requires SOF events in interrupt. | |
* | |
* This function should be called in reaction on APP_USBD_EVT_INST_APPEND event. | |
* Connect the class instance to the list of instances that requires SOF processing. | |
* If none of the appended instances requires SOF event - it is disabled. | |
* | |
* @param p_cinst Instance that requires SOF event. | |
* @param handler Handler to SOF event | |
* | |
* @retval NRF_SUCCESS Instance linked into SOF processing list. | |
* | |
* @sa app_usbd_class_sof_interrupt_unregister | |
*/ | |
ret_code_t app_usbd_class_sof_interrupt_register(app_usbd_class_inst_t const * p_cinst, | |
app_usbd_sof_interrupt_handler_t handler); | |
/** | |
* @brief Unregister class instance from SOF processing in interrupt instances list. | |
* | |
* Every class that calls @ref app_usbd_class_sof_interrupt_register have to call | |
* also unregistering function in reaction to @ref APP_USBD_EVT_INST_REMOVE event. | |
* | |
* @param p_cinst Instance to be unregistered from SOF processing in interrupt list. | |
* | |
* @retval NRF_SUCCESS Instance linked into SOF processing in interrupt list. | |
* @retval NRF_ERROR_NOT_FOUND Instance not found in the SOF processing in interrupt list. | |
* | |
* @sa app_usbd_class_sof_interrupt_register | |
*/ | |
ret_code_t app_usbd_class_sof_interrupt_unregister(app_usbd_class_inst_t const * p_cinst); | |
/** | |
* @brief Register class on remote wake-up feature. | |
* | |
* @param[in] p_inst Instance of the class. | |
* | |
* @retval NRF_SUCCESS Instance that requires remote wake-up registered. | |
*/ | |
ret_code_t app_usbd_class_rwu_register(app_usbd_class_inst_t const * const p_inst); | |
/** | |
* @brief Unregister class from remote wake-up feature. | |
* | |
* @param[in] p_inst Instance of the class. | |
* | |
* @retval NRF_SUCCESS Instance that requires remote wake-up removed. | |
*/ | |
ret_code_t app_usbd_class_rwu_unregister(app_usbd_class_inst_t const * const p_inst); | |
/** | |
* @brief Check if there is any class with remote wakeup. | |
* | |
* The function checks internal registered class with remote wakeup counter. | |
* | |
* @sa app_usbd_class_rwu_register, app_usbd_class_rwu_unregister | |
* | |
* @retval true The remote wakeup functionality is required by some class instance. | |
* @retval false There is no class instance that requires wakeup functionality. | |
*/ | |
bool app_usbd_class_rwu_enabled_check(void); | |
/** | |
* @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); | |
/** | |
* @brief Standard set interface request handle. | |
* | |
* This function should be called when processing SET_INTERFACE request. | |
* | |
* @param[in] p_cinst Instance of a class. | |
* @param[in] iface Interface number. | |
* | |
* @return Standard error code. | |
* | |
* @note Selected interface to reset has to be part of given class. | |
* */ | |
ret_code_t app_usbd_interface_ep_reset(app_usbd_class_inst_t const * const p_cinst, | |
uint8_t iface); | |
/** | |
* @brief Enable selected endpoint. | |
* | |
* Selected endpoint is enabled and cleared. | |
* | |
* @param ep Endpoint number. | |
*/ | |
void app_usbd_ep_enable(nrf_drv_usbd_ep_t ep); | |
/** | |
* @brief Disable selected endpoint. | |
* | |
* @param ep Endpoint number. | |
*/ | |
void app_usbd_ep_disable(nrf_drv_usbd_ep_t ep); | |
/** | |
* @name Iterate through classes lists | |
* | |
* Functions that helps to iterate through internally chained classes. | |
* @{ | |
*/ | |
/** | |
* @brief Get first class instance in the list. | |
* | |
* Get first instance from the list of active class instances. | |
* That instance may be used then in @ref app_usbd_class_next_get function. | |
* | |
* @return First instance in the list or NULL if there are no instances available. | |
*/ | |
app_usbd_class_inst_t const * app_usbd_class_first_get(void); | |
/** | |
* @brief Get next instance in the list. | |
* | |
* Get the next instance from the list of active instances. | |
* Used to iterate through all instances. | |
* | |
* @param[in] p_cinst The current instance from with next one is required. | |
* | |
* @return Next instance to the given one or NULL if there is no more instances in the list. | |
*/ | |
static inline app_usbd_class_inst_t const * app_usbd_class_next_get( | |
app_usbd_class_inst_t const * const p_cinst) | |
{ | |
ASSERT(NULL != p_cinst); | |
return app_usbd_class_data_access(p_cinst)->p_next; | |
} | |
/** | |
* @brief Get first instance in SOF list. | |
* | |
* Start iteration through the list of instances that require SOF event processing. | |
* | |
* @return First instance in the list or NULL if the list is empty. | |
* | |
* @sa app_usbd_class_first_get | |
*/ | |
app_usbd_class_inst_t const * app_usbd_class_sof_first_get(void); | |
/** | |
* @brief Get next instance in the SOF list. | |
* | |
* Get the next instance from the list of instances requiring SOF event processing. | |
* Used to iterate through all SOF instances. | |
* | |
* @param p_cinst The current instance from with next one is required. | |
* | |
* @return Next instance to the given one or NULL if there is no more instances in the list. | |
*/ | |
static inline app_usbd_class_inst_t const * app_usbd_class_sof_next_get( | |
app_usbd_class_inst_t const * const p_cinst) | |
{ | |
ASSERT(NULL != p_cinst); | |
return app_usbd_class_data_access(p_cinst)->p_sof_next; | |
} | |
/** | |
* @brief Get first instance in SOF interrupt list. | |
* | |
* Start iteration through the list of instances that require SOF processing in interrupt. | |
* | |
* @return First instance in the list or NULL if the list is empty. | |
* | |
* @sa app_usbd_class_first_get | |
*/ | |
app_usbd_class_inst_t const * app_usbd_class_sof_interrupt_first_get(void); | |
/** | |
* @brief Get next instance in the SOF interrupt list. | |
* | |
* Get the next instance from the list of instances requiring SOF processing in interrupt. | |
* Used to iterate through all SOF instances that have SOF handlers. | |
* | |
* @param p_cinst The current instance from with next one is required. | |
* | |
* @return Next instance to the given one or NULL if there is no more instances in the list. | |
*/ | |
static inline app_usbd_class_inst_t const * app_usbd_class_sof_interrupt_next_get( | |
app_usbd_class_inst_t const * const p_cinst) | |
{ | |
ASSERT(NULL != p_cinst); | |
return app_usbd_class_data_access(p_cinst)->p_sof_next; | |
} | |
/** @} */ | |
/** | |
* @brief Search for selected interface. | |
* | |
* Function searches for the given interface number and returns the class that contains it. | |
* Optionally it can return interface index inside class instance. | |
* | |
* @param[in] iface Interface number. | |
* @param[out] p_iface_idx Pointer to a variable that would hold interface index inside returned | |
* class instance. | |
* | |
* @return Pointer to the class structure that cointain given interface or NULL if not found. | |
*/ | |
app_usbd_class_inst_t const * app_usbd_iface_find(uint8_t iface, uint8_t * p_iface_idx); | |
/** | |
* @name Communicate with interfaces, endpoints and instances inside usbd library | |
* | |
* @{ | |
*/ | |
/** | |
* @brief Call interface event handler. | |
* | |
* Call event handler for selected interface. | |
* @param[in,out] p_class_inst Class instance that holds selected interface. | |
* @param[in] iface_idx Index of the interface in class structure. | |
* @param[in] p_event Event structure to be processed. | |
* | |
* @return Operation status. | |
*/ | |
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); | |
/** | |
* @brief Call endpoint event handler. | |
* | |
* Call event handler for the selected endpoint. | |
* @param[in] ep Endpoint number. | |
* @param[in] p_event Event structure to send. | |
* | |
* @return Operation status. | |
*/ | |
ret_code_t app_usbd_ep_call(nrf_drv_usbd_ep_t ep, app_usbd_complex_evt_t const * const p_event); | |
/** | |
* @brief Auxiliary function that process event by every instance in the list. | |
* | |
* This function ignores the result of called handler. | |
* | |
* @param p_event Event to pass to every instance. | |
*/ | |
void app_usbd_all_call(app_usbd_complex_evt_t const * const p_event); | |
/** | |
* @brief Call interface event handlers and stop when served. | |
* | |
* Call event handlers from instances as long as we get result different than @ref NRF_ERROR_NOT_SUPPORTED | |
* @param[in] p_event Event structure to send. | |
* | |
* @return Operation status or @ref NRF_ERROR_NOT_SUPPORTED if none of instances in the list can support given event. | |
*/ | |
ret_code_t app_usbd_all_until_served_call(app_usbd_complex_evt_t const * const p_event); | |
/** @} */ | |
/** | |
* @brief Endpoint transfer. | |
* | |
* @param ep Endpoint number. | |
* @param p_transfer Description of the transfer to be performed. | |
* The direction of the transfer is determined by the | |
* endpoint number. | |
* | |
* @retval NRF_ERROR_INVALID_STATE The state of the USB device does not allow | |
* data transfer on the endpoint. | |
* @return Values returned by @ref nrf_drv_usbd_ep_transfer. | |
* | |
* @sa app_usbd_ep_handled_transfer | |
*/ | |
ret_code_t app_usbd_ep_transfer( | |
nrf_drv_usbd_ep_t ep, | |
nrf_drv_usbd_transfer_t const * const p_transfer); | |
/** | |
* @brief Set up an endpoint handled transfer. | |
* | |
* Configures a transfer handled by the feedback function. | |
* | |
* @param ep Endpoint number. | |
* @param p_handler Function called when the next chunk of data is requested. | |
* | |
* @retval NRF_ERROR_INVALID_STATE The state of the USB device does not allow | |
* data transfer on the endpoint. | |
* @return Values returned by @ref nrf_drv_usbd_ep_handled_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); | |
/** | |
* @brief Select interface | |
* | |
* Select the given interface. | |
* This function calls class interface selection function or default | |
* interface selection function. | |
* | |
* After calling this function interface should be functional. | |
* | |
* @param[in,out] p_inst Instance of the class. | |
* @param[in] iface_idx Index of the interface inside class structure. | |
* @param[in] alternate Alternate setting that should be selected. | |
* | |
* @return Standard error code. | |
*/ | |
ret_code_t app_usbd_iface_select( | |
app_usbd_class_inst_t const * const p_inst, | |
uint8_t iface_idx, | |
uint8_t alternate); | |
/** | |
* @brief Deselect interface. | |
* | |
* Disable the given interface. | |
* This function calls class interface deselection function or | |
* default interface selection function. | |
* | |
* After calling this function all the endpoints from the interface | |
* have to be disabled. | |
* | |
* @param[in,out] p_inst Instance of the class. | |
* @param[in] iface_idx Index of the interface inside class structure. | |
*/ | |
void app_usbd_iface_deselect( | |
app_usbd_class_inst_t const * const p_inst, | |
uint8_t iface_idx); | |
/** | |
* @brief Get selected interface. | |
* | |
* Function retieves currently selected interface. | |
* If the class contains @ref app_usbd_class_methods_t::iface_selection_get it is called. | |
* It it does not contain this function this function would return default, 0 value. | |
* | |
* @param[in] p_inst Instance of the class. | |
* @param[in] iface_idx Index of the interface inside class structure. | |
* | |
* @return Selected alternate interface setting. | |
*/ | |
uint8_t app_usbd_iface_selection_get( | |
app_usbd_class_inst_t const * const p_inst, | |
uint8_t iface_idx); | |
/** | |
* @brief Select alternate configuration 0 for all interfaces. | |
* | |
* Auxiliary function that clears settings for all interfaces leaving them enabled. | |
*/ | |
void app_usbd_all_iface_select_0(void); | |
/** | |
* @brief Deselect all interfaces. | |
* | |
* Auxiliary function to disable all interfaces. | |
*/ | |
void app_usbd_all_iface_deselect(void); | |
/** @} */ | |
#ifdef __cplusplus | |
} | |
#endif | |
#endif /* APP_USBD_H__ */ |