You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1034 lines
37 KiB
1034 lines
37 KiB
/**
|
|
* \file
|
|
*
|
|
* \brief USB Device wrapper layer for compliance with common driver UDD
|
|
*
|
|
* Copyright (C) 2014-2016 Atmel Corporation. All rights reserved.
|
|
*
|
|
* \asf_license_start
|
|
*
|
|
* \page License
|
|
*
|
|
* 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 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. The name of Atmel may not be used to endorse or promote products derived
|
|
* from this software without specific prior written permission.
|
|
*
|
|
* 4. This software may only be redistributed and used in connection with an
|
|
* Atmel microcontroller product.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR IMPLIED
|
|
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE
|
|
* EXPRESSLY AND SPECIFICALLY DISCLAIMED. IN NO EVENT SHALL ATMEL 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.
|
|
*
|
|
* \asf_license_stop
|
|
*
|
|
*/
|
|
/*
|
|
* Support and FAQ: visit <a href="http://www.atmel.com/design-support/">Atmel Support</a>
|
|
*/
|
|
#include "samd51j18a.h"
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
|
|
// Get USB device configuration
|
|
#include "conf_usb.h"
|
|
#include "udd.h"
|
|
#include "usb.h"
|
|
#include "status_codes.h"
|
|
|
|
/**
|
|
* \ingroup usb_device_group
|
|
* \defgroup usb_device_udd_group USB Device Driver Implement (UDD)
|
|
* USB low-level driver for USB device mode
|
|
* @{
|
|
*/
|
|
// Check USB device configuration
|
|
#ifdef USB_DEVICE_HS_SUPPORT
|
|
# error The High speed mode is not supported on this part, please remove USB_DEVICE_HS_SUPPORT in conf_usb.h
|
|
#endif
|
|
|
|
// Note: This driver is adapted for SAMD51
|
|
|
|
#ifndef UDC_REMOTEWAKEUP_LPM_ENABLE
|
|
# define UDC_REMOTEWAKEUP_LPM_ENABLE()
|
|
#endif
|
|
#ifndef UDC_REMOTEWAKEUP_LPM_DISABLE
|
|
# define UDC_REMOTEWAKEUP_LPM_DISABLE()
|
|
#endif
|
|
#ifndef UDC_SUSPEND_LPM_EVENT
|
|
# define UDC_SUSPEND_LPM_EVENT()
|
|
#endif
|
|
|
|
/* for debug text */
|
|
#ifdef USB_DEBUG
|
|
# define dbg_print printf
|
|
#else
|
|
# define dbg_print(...)
|
|
#endif
|
|
|
|
/** Maximum size of a transfer in multi-packet mode */
|
|
#define UDD_ENDPOINT_MAX_TRANS ((8 * 1024) - 1)
|
|
|
|
/** USB software device instance structure */
|
|
struct usb_module usb_device;
|
|
|
|
/**
|
|
* \name Clock management
|
|
*
|
|
* @{
|
|
*/
|
|
|
|
#define UDD_CLOCK_GEN 0
|
|
|
|
static inline void udd_wait_clock_ready(void) {}
|
|
|
|
/**
|
|
* \name Power management
|
|
*
|
|
* @{
|
|
*/
|
|
#define udd_sleep_mode(arg)
|
|
/** @} */
|
|
|
|
/**
|
|
* \name Control endpoint low level management routine.
|
|
*
|
|
* This function performs control endpoint management.
|
|
* It handles the SETUP/DATA/HANDSHAKE phases of a control transaction.
|
|
*
|
|
* @{
|
|
*/
|
|
|
|
/**
|
|
* \brief Buffer to store the data received on control endpoint (SETUP/OUT endpoint 0)
|
|
*
|
|
* Used to avoid a RAM buffer overflow in case of the payload buffer
|
|
* is smaller than control endpoint size
|
|
*/
|
|
UDC_BSS(4)
|
|
uint8_t udd_ctrl_buffer[USB_DEVICE_EP_CTRL_SIZE];
|
|
|
|
/** Bit definitions about endpoint control state machine for udd_ep_control_state */
|
|
typedef enum {
|
|
UDD_EPCTRL_SETUP = 0, //!< Wait a SETUP packet
|
|
UDD_EPCTRL_DATA_OUT = 1, //!< Wait a OUT data packet
|
|
UDD_EPCTRL_DATA_IN = 2, //!< Wait a IN data packet
|
|
UDD_EPCTRL_HANDSHAKE_WAIT_IN_ZLP = 3, //!< Wait a IN ZLP packet
|
|
UDD_EPCTRL_HANDSHAKE_WAIT_OUT_ZLP = 4, //!< Wait a OUT ZLP packet
|
|
UDD_EPCTRL_STALL_REQ = 5, //!< STALL enabled on IN & OUT packet
|
|
} udd_ctrl_ep_state_t;
|
|
|
|
/** Global variable to give and record information of the set up request management */
|
|
udd_ctrl_request_t udd_g_ctrlreq;
|
|
|
|
/** State of the endpoint control management */
|
|
static udd_ctrl_ep_state_t udd_ep_control_state;
|
|
|
|
/** Total number of data received/sent during data packet phase with previous payload buffers */
|
|
static uint16_t udd_ctrl_prev_payload_nb_trans;
|
|
|
|
/** Number of data received/sent to/from udd_g_ctrlreq.payload buffer */
|
|
static uint16_t udd_ctrl_payload_nb_trans;
|
|
|
|
/** @} */
|
|
|
|
/**
|
|
* \name Management of bulk/interrupt/isochronous endpoints
|
|
*
|
|
* The UDD manages the data transfer on endpoints:
|
|
* - Start data transfer on endpoint with USB Device DMA
|
|
* - Send a ZLP packet if requested
|
|
* - Call callback registered to signal end of transfer
|
|
* The transfer abort and stall feature are supported.
|
|
*
|
|
* @{
|
|
*/
|
|
|
|
/**
|
|
* \brief Buffer to store the data received on bulk/interrupt endpoints
|
|
*
|
|
* Used to avoid a RAM buffer overflow in case of the user buffer
|
|
* is smaller than endpoint size
|
|
*
|
|
* \warning The protected interrupt endpoint size is 512 bytes maximum.
|
|
* \warning The isochronous and endpoint is not protected by this system and
|
|
* the user must always use a buffer corresponding at endpoint size.
|
|
*/
|
|
|
|
#if (defined USB_DEVICE_LOW_SPEED)
|
|
UDC_BSS(4) uint8_t udd_ep_out_cache_buffer[USB_DEVICE_MAX_EP][8];
|
|
#elif (defined USB_DEVICE_HS_SUPPORT)
|
|
UDC_BSS(4) uint8_t udd_ep_out_cache_buffer[USB_DEVICE_MAX_EP][512];
|
|
#else
|
|
UDC_BSS(4) uint8_t udd_ep_out_cache_buffer[USB_DEVICE_MAX_EP][64];
|
|
#endif
|
|
|
|
/** Structure definition about job registered on an endpoint */
|
|
typedef struct {
|
|
union {
|
|
//! Callback to call at the end of transfer
|
|
udd_callback_trans_t call_trans;
|
|
//! Callback to call when the endpoint halt is cleared
|
|
udd_callback_halt_cleared_t call_nohalt;
|
|
};
|
|
//! Buffer located in internal RAM to send or fill during job
|
|
uint8_t *buf;
|
|
//! Size of buffer to send or fill
|
|
iram_size_t buf_size;
|
|
//! Total number of data transferred on endpoint
|
|
iram_size_t nb_trans;
|
|
//! Endpoint size
|
|
uint16_t ep_size;
|
|
//! A job is registered on this endpoint
|
|
uint8_t busy : 1;
|
|
//! A short packet is requested for this job on endpoint IN
|
|
uint8_t b_shortpacket : 1;
|
|
//! The cache buffer is currently used on endpoint OUT
|
|
uint8_t b_use_out_cache_buffer : 1;
|
|
} udd_ep_job_t;
|
|
|
|
/** Array to register a job on bulk/interrupt/isochronous endpoint */
|
|
static udd_ep_job_t udd_ep_job[2 * USB_DEVICE_MAX_EP];
|
|
|
|
/** @} */
|
|
|
|
/**
|
|
* \brief Get the detailed job by endpoint number
|
|
* \param[in] ep Endpoint Address
|
|
* \retval pointer to an udd_ep_job_t structure instance
|
|
*/
|
|
static udd_ep_job_t *udd_ep_get_job(udd_ep_id_t ep) {
|
|
if ((ep == 0) || (ep == 0x80)) {
|
|
return NULL;
|
|
} else {
|
|
return &udd_ep_job[(2 * (ep & USB_EP_ADDR_MASK) + ((ep & USB_EP_DIR_IN) ? 1 : 0)) - 2];
|
|
}
|
|
}
|
|
|
|
/**
|
|
* \brief Endpoint IN process, continue to send packets or zero length packet
|
|
* \param[in] pointer Pointer to the endpoint transfer status parameter struct from driver layer.
|
|
*/
|
|
static void udd_ep_trans_in_next(void *pointer) {
|
|
struct usb_endpoint_callback_parameter *ep_callback_para = (struct usb_endpoint_callback_parameter *)pointer;
|
|
udd_ep_id_t ep = ep_callback_para->endpoint_address;
|
|
uint16_t ep_size, nb_trans;
|
|
uint16_t next_trans;
|
|
udd_ep_id_t ep_num;
|
|
udd_ep_job_t * ptr_job;
|
|
|
|
ptr_job = udd_ep_get_job(ep);
|
|
ep_num = ep & USB_EP_ADDR_MASK;
|
|
|
|
ep_size = ptr_job->ep_size;
|
|
/* Update number of data transferred */
|
|
nb_trans = ep_callback_para->sent_bytes;
|
|
ptr_job->nb_trans += nb_trans;
|
|
|
|
/* Need to send other data */
|
|
if (ptr_job->nb_trans != ptr_job->buf_size) {
|
|
next_trans = ptr_job->buf_size - ptr_job->nb_trans;
|
|
if (UDD_ENDPOINT_MAX_TRANS < next_trans) {
|
|
/* The USB hardware support a maximum
|
|
* transfer size of UDD_ENDPOINT_MAX_TRANS Bytes */
|
|
next_trans = UDD_ENDPOINT_MAX_TRANS - (UDD_ENDPOINT_MAX_TRANS % ep_size);
|
|
}
|
|
/* Need ZLP, if requested and last packet is not a short packet */
|
|
ptr_job->b_shortpacket = ptr_job->b_shortpacket && (0 == (next_trans % ep_size));
|
|
usb_device_endpoint_write_buffer_job(&usb_device, ep_num, &ptr_job->buf[ptr_job->nb_trans], next_trans);
|
|
return;
|
|
}
|
|
|
|
/* Need to send a ZLP after all data transfer */
|
|
if (ptr_job->b_shortpacket) {
|
|
ptr_job->b_shortpacket = false;
|
|
/* Start new transfer */
|
|
usb_device_endpoint_write_buffer_job(&usb_device, ep_num, &ptr_job->buf[ptr_job->nb_trans], 0);
|
|
return;
|
|
}
|
|
|
|
/* Job complete then call callback */
|
|
ptr_job->busy = false;
|
|
if (NULL != ptr_job->call_trans) {
|
|
ptr_job->call_trans(UDD_EP_TRANSFER_OK, ptr_job->nb_trans, ep);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* \brief Endpoint OUT process, continue to receive packets or zero length packet
|
|
* \param[in] pointer Pointer to the endpoint transfer status parameter struct from driver layer.
|
|
*/
|
|
static void udd_ep_trans_out_next(void *pointer) {
|
|
struct usb_endpoint_callback_parameter *ep_callback_para = (struct usb_endpoint_callback_parameter *)pointer;
|
|
udd_ep_id_t ep = ep_callback_para->endpoint_address;
|
|
uint16_t ep_size, nb_trans;
|
|
uint16_t next_trans;
|
|
udd_ep_id_t ep_num;
|
|
udd_ep_job_t * ptr_job;
|
|
|
|
ptr_job = udd_ep_get_job(ep);
|
|
ep_num = ep & USB_EP_ADDR_MASK;
|
|
|
|
ep_size = ptr_job->ep_size;
|
|
/* Update number of data transferred */
|
|
nb_trans = ep_callback_para->received_bytes;
|
|
|
|
/* Can be necessary to copy data receive from cache buffer to user buffer */
|
|
if (ptr_job->b_use_out_cache_buffer) {
|
|
memcpy(&ptr_job->buf[ptr_job->nb_trans], udd_ep_out_cache_buffer[ep_num - 1], ptr_job->buf_size % ep_size);
|
|
}
|
|
|
|
/* Update number of data transferred */
|
|
ptr_job->nb_trans += nb_trans;
|
|
if (ptr_job->nb_trans > ptr_job->buf_size) {
|
|
ptr_job->nb_trans = ptr_job->buf_size;
|
|
}
|
|
|
|
/* If all previous data requested are received and user buffer not full
|
|
* then need to receive other data */
|
|
if ((nb_trans == ep_callback_para->out_buffer_size) && (ptr_job->nb_trans != ptr_job->buf_size)) {
|
|
next_trans = ptr_job->buf_size - ptr_job->nb_trans;
|
|
if (UDD_ENDPOINT_MAX_TRANS < next_trans) {
|
|
/* The USB hardware support a maximum transfer size
|
|
* of UDD_ENDPOINT_MAX_TRANS Bytes */
|
|
next_trans = UDD_ENDPOINT_MAX_TRANS - (UDD_ENDPOINT_MAX_TRANS % ep_size);
|
|
} else {
|
|
next_trans -= next_trans % ep_size;
|
|
}
|
|
|
|
if (next_trans < ep_size) {
|
|
/* Use the cache buffer for Bulk or Interrupt size endpoint */
|
|
ptr_job->b_use_out_cache_buffer = true;
|
|
usb_device_endpoint_read_buffer_job(&usb_device, ep_num, udd_ep_out_cache_buffer[ep_num - 1], ep_size);
|
|
} else {
|
|
usb_device_endpoint_read_buffer_job(&usb_device, ep_num, &ptr_job->buf[ptr_job->nb_trans], next_trans);
|
|
}
|
|
return;
|
|
}
|
|
|
|
/* Job complete then call callback */
|
|
ptr_job->busy = false;
|
|
if (NULL != ptr_job->call_trans) {
|
|
ptr_job->call_trans(UDD_EP_TRANSFER_OK, ptr_job->nb_trans, ep);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* \brief Endpoint Transfer Complete callback function, to do the next transfer depends on the direction(IN or OUT)
|
|
* \param[in] module_inst Pointer to USB module instance
|
|
* \param[in] pointer Pointer to the endpoint transfer status parameter struct from driver layer.
|
|
*/
|
|
static void udd_ep_transfer_process(struct usb_module *module_inst, void *pointer) {
|
|
struct usb_endpoint_callback_parameter *ep_callback_para = (struct usb_endpoint_callback_parameter *)pointer;
|
|
udd_ep_id_t ep = ep_callback_para->endpoint_address;
|
|
|
|
if (ep & USB_EP_DIR_IN) {
|
|
udd_ep_trans_in_next(pointer);
|
|
} else {
|
|
udd_ep_trans_out_next(pointer);
|
|
}
|
|
}
|
|
|
|
void udd_ep_abort(udd_ep_id_t ep) {
|
|
udd_ep_job_t *ptr_job;
|
|
|
|
usb_device_endpoint_abort_job(&usb_device, ep);
|
|
|
|
/* Job complete then call callback */
|
|
ptr_job = udd_ep_get_job(ep);
|
|
if (!ptr_job->busy) {
|
|
return;
|
|
}
|
|
ptr_job->busy = false;
|
|
if (NULL != ptr_job->call_trans) {
|
|
/* It can be a Transfer or stall callback */
|
|
ptr_job->call_trans(UDD_EP_TRANSFER_ABORT, ptr_job->nb_trans, ep);
|
|
}
|
|
}
|
|
|
|
bool udd_is_high_speed(void) { return false; }
|
|
|
|
uint16_t udd_get_frame_number(void) { return usb_device_get_frame_number(&usb_device); }
|
|
|
|
uint16_t udd_get_micro_frame_number(void) { return usb_device_get_micro_frame_number(&usb_device); }
|
|
|
|
void udd_ep_free(udd_ep_id_t ep) {
|
|
struct usb_device_endpoint_config config_ep;
|
|
usb_device_endpoint_get_config_defaults(&config_ep);
|
|
|
|
uint8_t ep_num = ep & USB_EP_ADDR_MASK;
|
|
udd_ep_abort(ep);
|
|
|
|
config_ep.ep_address = ep;
|
|
config_ep.ep_type = USB_DEVICE_ENDPOINT_TYPE_DISABLE;
|
|
usb_device_endpoint_set_config(&usb_device, &config_ep);
|
|
usb_device_endpoint_unregister_callback(&usb_device, ep_num, USB_DEVICE_ENDPOINT_CALLBACK_TRCPT);
|
|
usb_device_endpoint_disable_callback(&usb_device, ep, USB_DEVICE_ENDPOINT_CALLBACK_TRCPT);
|
|
}
|
|
|
|
bool udd_ep_alloc(udd_ep_id_t ep, uint8_t bmAttributes, uint16_t MaxEndpointSize) {
|
|
struct usb_device_endpoint_config config_ep;
|
|
usb_device_endpoint_get_config_defaults(&config_ep);
|
|
|
|
config_ep.ep_address = ep;
|
|
|
|
if (MaxEndpointSize <= 8) {
|
|
config_ep.ep_size = USB_ENDPOINT_8_BYTE;
|
|
} else if (MaxEndpointSize <= 16) {
|
|
config_ep.ep_size = USB_ENDPOINT_16_BYTE;
|
|
} else if (MaxEndpointSize <= 32) {
|
|
config_ep.ep_size = USB_ENDPOINT_32_BYTE;
|
|
} else if (MaxEndpointSize <= 64) {
|
|
config_ep.ep_size = USB_ENDPOINT_64_BYTE;
|
|
} else if (MaxEndpointSize <= 128) {
|
|
config_ep.ep_size = USB_ENDPOINT_128_BYTE;
|
|
} else if (MaxEndpointSize <= 256) {
|
|
config_ep.ep_size = USB_ENDPOINT_256_BYTE;
|
|
} else if (MaxEndpointSize <= 512) {
|
|
config_ep.ep_size = USB_ENDPOINT_512_BYTE;
|
|
} else if (MaxEndpointSize <= 1023) {
|
|
config_ep.ep_size = USB_ENDPOINT_1023_BYTE;
|
|
} else {
|
|
return false;
|
|
}
|
|
udd_ep_job_t *ptr_job = udd_ep_get_job(ep);
|
|
ptr_job->ep_size = MaxEndpointSize;
|
|
|
|
bmAttributes = bmAttributes & USB_EP_TYPE_MASK;
|
|
|
|
/* Check endpoint type */
|
|
if (USB_EP_TYPE_ISOCHRONOUS == bmAttributes) {
|
|
config_ep.ep_type = USB_DEVICE_ENDPOINT_TYPE_ISOCHRONOUS;
|
|
} else if (USB_EP_TYPE_BULK == bmAttributes) {
|
|
config_ep.ep_type = USB_DEVICE_ENDPOINT_TYPE_BULK;
|
|
} else if (USB_EP_TYPE_INTERRUPT == bmAttributes) {
|
|
config_ep.ep_type = USB_DEVICE_ENDPOINT_TYPE_INTERRUPT;
|
|
} else {
|
|
return false;
|
|
}
|
|
|
|
uint8_t ep_num = ep & USB_EP_ADDR_MASK;
|
|
|
|
if (STATUS_OK != usb_device_endpoint_set_config(&usb_device, &config_ep)) {
|
|
return false;
|
|
}
|
|
usb_device_endpoint_register_callback(&usb_device, ep_num, USB_DEVICE_ENDPOINT_CALLBACK_TRCPT, udd_ep_transfer_process);
|
|
usb_device_endpoint_enable_callback(&usb_device, ep, USB_DEVICE_ENDPOINT_CALLBACK_TRCPT);
|
|
usb_device_endpoint_enable_callback(&usb_device, ep, USB_DEVICE_ENDPOINT_CALLBACK_TRFAIL);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool udd_ep_is_halted(udd_ep_id_t ep) { return usb_device_endpoint_is_halted(&usb_device, ep); }
|
|
|
|
bool udd_ep_set_halt(udd_ep_id_t ep) {
|
|
uint8_t ep_num = ep & USB_EP_ADDR_MASK;
|
|
|
|
if (USB_DEVICE_MAX_EP < ep_num) {
|
|
return false;
|
|
}
|
|
|
|
usb_device_endpoint_set_halt(&usb_device, ep);
|
|
|
|
udd_ep_abort(ep);
|
|
return true;
|
|
}
|
|
|
|
bool udd_ep_clear_halt(udd_ep_id_t ep) {
|
|
udd_ep_job_t *ptr_job;
|
|
uint8_t ep_num = ep & USB_EP_ADDR_MASK;
|
|
|
|
if (USB_DEVICE_MAX_EP < ep_num) {
|
|
return false;
|
|
}
|
|
ptr_job = udd_ep_get_job(ep);
|
|
|
|
usb_device_endpoint_clear_halt(&usb_device, ep);
|
|
|
|
/* If a job is register on clear halt action then execute callback */
|
|
if (ptr_job->busy == true) {
|
|
ptr_job->busy = false;
|
|
ptr_job->call_nohalt();
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool udd_ep_wait_stall_clear(udd_ep_id_t ep, udd_callback_halt_cleared_t callback) {
|
|
udd_ep_id_t ep_num;
|
|
udd_ep_job_t *ptr_job;
|
|
|
|
ep_num = ep & USB_EP_ADDR_MASK;
|
|
if (USB_DEVICE_MAX_EP < ep_num) {
|
|
return false;
|
|
}
|
|
|
|
ptr_job = udd_ep_get_job(ep);
|
|
if (ptr_job->busy == true) {
|
|
return false; /* Job already on going */
|
|
}
|
|
|
|
/* Wait clear halt endpoint */
|
|
if (usb_device_endpoint_is_halted(&usb_device, ep)) {
|
|
/* Endpoint halted then registers the callback */
|
|
ptr_job->busy = true;
|
|
ptr_job->call_nohalt = callback;
|
|
return true;
|
|
} else if (usb_device_endpoint_is_configured(&usb_device, ep)) {
|
|
callback(); /* Endpoint not halted then call directly callback */
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* \brief Control Endpoint stall sending data
|
|
*/
|
|
static void udd_ctrl_stall_data(void) {
|
|
udd_ep_control_state = UDD_EPCTRL_STALL_REQ;
|
|
|
|
usb_device_endpoint_set_halt(&usb_device, USB_EP_DIR_IN);
|
|
usb_device_endpoint_clear_halt(&usb_device, USB_EP_DIR_OUT);
|
|
}
|
|
|
|
bool udd_ep_run(udd_ep_id_t ep, bool b_shortpacket, uint8_t *buf, iram_size_t buf_size, udd_callback_trans_t callback) {
|
|
udd_ep_id_t ep_num;
|
|
udd_ep_job_t *ptr_job;
|
|
uint32_t irqflags;
|
|
|
|
ep_num = ep & USB_EP_ADDR_MASK;
|
|
|
|
if ((USB_DEVICE_MAX_EP < ep_num) || (udd_ep_is_halted(ep))) {
|
|
return false;
|
|
}
|
|
|
|
ptr_job = udd_ep_get_job(ep);
|
|
|
|
irqflags = __get_PRIMASK();
|
|
__disable_irq();
|
|
__DMB();
|
|
|
|
if (ptr_job->busy == true) {
|
|
__DMB();
|
|
__set_PRIMASK(irqflags);
|
|
return false; /* Job already on going */
|
|
}
|
|
|
|
ptr_job->busy = true;
|
|
__DMB();
|
|
__set_PRIMASK(irqflags);
|
|
|
|
/* No job running, set up a new one */
|
|
ptr_job->buf = buf;
|
|
ptr_job->buf_size = buf_size;
|
|
ptr_job->nb_trans = 0;
|
|
ptr_job->call_trans = callback;
|
|
ptr_job->b_shortpacket = b_shortpacket;
|
|
ptr_job->b_use_out_cache_buffer = false;
|
|
|
|
/* Initialize value to simulate a empty transfer */
|
|
uint16_t next_trans;
|
|
|
|
if (ep & USB_EP_DIR_IN) {
|
|
if (0 != ptr_job->buf_size) {
|
|
next_trans = ptr_job->buf_size;
|
|
if (UDD_ENDPOINT_MAX_TRANS < next_trans) {
|
|
next_trans = UDD_ENDPOINT_MAX_TRANS - (UDD_ENDPOINT_MAX_TRANS % ptr_job->ep_size);
|
|
}
|
|
ptr_job->b_shortpacket = ptr_job->b_shortpacket && (0 == (next_trans % ptr_job->ep_size));
|
|
} else if (true == ptr_job->b_shortpacket) {
|
|
ptr_job->b_shortpacket = false; /* avoid to send zero length packet again */
|
|
next_trans = 0;
|
|
} else {
|
|
ptr_job->busy = false;
|
|
if (NULL != ptr_job->call_trans) {
|
|
ptr_job->call_trans(UDD_EP_TRANSFER_OK, 0, ep);
|
|
}
|
|
return true;
|
|
}
|
|
return (STATUS_OK == usb_device_endpoint_write_buffer_job(&usb_device, ep_num, &ptr_job->buf[0], next_trans));
|
|
} else {
|
|
if (0 != ptr_job->buf_size) {
|
|
next_trans = ptr_job->buf_size;
|
|
if (UDD_ENDPOINT_MAX_TRANS < next_trans) {
|
|
/* The USB hardware support a maximum transfer size
|
|
* of UDD_ENDPOINT_MAX_TRANS Bytes */
|
|
next_trans = UDD_ENDPOINT_MAX_TRANS - (UDD_ENDPOINT_MAX_TRANS % ptr_job->ep_size);
|
|
} else {
|
|
next_trans -= next_trans % ptr_job->ep_size;
|
|
}
|
|
if (next_trans < ptr_job->ep_size) {
|
|
ptr_job->b_use_out_cache_buffer = true;
|
|
return (STATUS_OK == usb_device_endpoint_read_buffer_job(&usb_device, ep_num, udd_ep_out_cache_buffer[ep_num - 1], ptr_job->ep_size));
|
|
} else {
|
|
return (STATUS_OK == usb_device_endpoint_read_buffer_job(&usb_device, ep_num, &ptr_job->buf[0], next_trans));
|
|
}
|
|
} else {
|
|
ptr_job->busy = false;
|
|
if (NULL != ptr_job->call_trans) {
|
|
ptr_job->call_trans(UDD_EP_TRANSFER_OK, 0, ep);
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
void udd_set_address(uint8_t address) { usb_device_set_address(&usb_device, address); }
|
|
|
|
uint8_t udd_getaddress(void) { return usb_device_get_address(&usb_device); }
|
|
|
|
void udd_send_remotewakeup(void) {
|
|
uint32_t try = 5;
|
|
udd_wait_clock_ready();
|
|
udd_sleep_mode(UDD_STATE_IDLE);
|
|
while (2 != usb_get_state_machine_status(&usb_device) && try--) {
|
|
usb_device_send_remote_wake_up(&usb_device);
|
|
}
|
|
}
|
|
|
|
void udd_set_setup_payload(uint8_t *payload, uint16_t payload_size) {
|
|
udd_g_ctrlreq.payload = payload;
|
|
udd_g_ctrlreq.payload_size = payload_size;
|
|
}
|
|
|
|
/**
|
|
* \brief Control Endpoint translate the data in buffer into Device Request Struct
|
|
*/
|
|
static void udd_ctrl_fetch_ram(void) {
|
|
udd_g_ctrlreq.req.bmRequestType = udd_ctrl_buffer[0];
|
|
udd_g_ctrlreq.req.bRequest = udd_ctrl_buffer[1];
|
|
udd_g_ctrlreq.req.wValue = ((uint16_t)(udd_ctrl_buffer[3]) << 8) + udd_ctrl_buffer[2];
|
|
udd_g_ctrlreq.req.wIndex = ((uint16_t)(udd_ctrl_buffer[5]) << 8) + udd_ctrl_buffer[4];
|
|
udd_g_ctrlreq.req.wLength = ((uint16_t)(udd_ctrl_buffer[7]) << 8) + udd_ctrl_buffer[6];
|
|
}
|
|
|
|
/**
|
|
* \brief Control Endpoint send out zero length packet
|
|
*/
|
|
static void udd_ctrl_send_zlp_in(void) {
|
|
udd_ep_control_state = UDD_EPCTRL_HANDSHAKE_WAIT_IN_ZLP;
|
|
usb_device_endpoint_setup_buffer_job(&usb_device, udd_ctrl_buffer);
|
|
usb_device_endpoint_write_buffer_job(&usb_device, 0, udd_g_ctrlreq.payload, 0);
|
|
}
|
|
|
|
/**
|
|
* \brief Process control endpoint IN transaction
|
|
*/
|
|
static void udd_ctrl_in_sent(void) {
|
|
static bool b_shortpacket = false;
|
|
uint16_t nb_remain;
|
|
|
|
nb_remain = udd_g_ctrlreq.payload_size - udd_ctrl_payload_nb_trans;
|
|
|
|
if (0 == nb_remain) {
|
|
/* All content of current buffer payload are sent Update number of total data sending by previous payload buffer */
|
|
udd_ctrl_prev_payload_nb_trans += udd_ctrl_payload_nb_trans;
|
|
if ((udd_g_ctrlreq.req.wLength == udd_ctrl_prev_payload_nb_trans) || b_shortpacket) {
|
|
/* All data requested are transferred or a short packet has been sent, then it is the end of data phase.
|
|
* Generate an OUT ZLP for handshake phase */
|
|
udd_ep_control_state = UDD_EPCTRL_HANDSHAKE_WAIT_OUT_ZLP;
|
|
usb_device_endpoint_setup_buffer_job(&usb_device, udd_ctrl_buffer);
|
|
return;
|
|
}
|
|
/* Need of new buffer because the data phase is not complete */
|
|
if ((!udd_g_ctrlreq.over_under_run) || (!udd_g_ctrlreq.over_under_run())) {
|
|
/* Under run then send zlp on IN
|
|
* Here nb_remain=0, this allows to send a IN ZLP */
|
|
} else {
|
|
/* A new payload buffer is given */
|
|
udd_ctrl_payload_nb_trans = 0;
|
|
nb_remain = udd_g_ctrlreq.payload_size;
|
|
}
|
|
}
|
|
|
|
/* Continue transfer and send next data */
|
|
if (nb_remain >= USB_DEVICE_EP_CTRL_SIZE) {
|
|
nb_remain = USB_DEVICE_EP_CTRL_SIZE;
|
|
b_shortpacket = false;
|
|
} else {
|
|
b_shortpacket = true;
|
|
}
|
|
|
|
/* Link payload buffer directly on USB hardware */
|
|
usb_device_endpoint_write_buffer_job(&usb_device, 0, udd_g_ctrlreq.payload + udd_ctrl_payload_nb_trans, nb_remain);
|
|
|
|
udd_ctrl_payload_nb_trans += nb_remain;
|
|
}
|
|
|
|
/**
|
|
* \brief Process control endpoint OUT transaction
|
|
* \param[in] pointer Pointer to the endpoint transfer status parameter struct from driver layer.
|
|
*/
|
|
static void udd_ctrl_out_received(void *pointer) {
|
|
struct usb_endpoint_callback_parameter *ep_callback_para = (struct usb_endpoint_callback_parameter *)pointer;
|
|
|
|
uint16_t nb_data;
|
|
nb_data = ep_callback_para->received_bytes; /* Read data received during OUT phase */
|
|
|
|
if (udd_g_ctrlreq.payload_size < (udd_ctrl_payload_nb_trans + nb_data)) {
|
|
/* Payload buffer too small */
|
|
nb_data = udd_g_ctrlreq.payload_size - udd_ctrl_payload_nb_trans;
|
|
}
|
|
|
|
memcpy((uint8_t *)(udd_g_ctrlreq.payload + udd_ctrl_payload_nb_trans), udd_ctrl_buffer, nb_data);
|
|
udd_ctrl_payload_nb_trans += nb_data;
|
|
|
|
if ((USB_DEVICE_EP_CTRL_SIZE != nb_data) || (udd_g_ctrlreq.req.wLength <= (udd_ctrl_prev_payload_nb_trans + udd_ctrl_payload_nb_trans))) {
|
|
/* End of reception because it is a short packet
|
|
* or all data are transferred */
|
|
|
|
/* Before send ZLP, call intermediate callback
|
|
* in case of data receive generate a stall */
|
|
udd_g_ctrlreq.payload_size = udd_ctrl_payload_nb_trans;
|
|
if (NULL != udd_g_ctrlreq.over_under_run) {
|
|
if (!udd_g_ctrlreq.over_under_run()) {
|
|
/* Stall ZLP */
|
|
udd_ep_control_state = UDD_EPCTRL_STALL_REQ;
|
|
/* Stall all packets on IN & OUT control endpoint */
|
|
udd_ep_set_halt(0);
|
|
/* Ack reception of OUT to replace NAK by a STALL */
|
|
return;
|
|
}
|
|
}
|
|
/* Send IN ZLP to ACK setup request */
|
|
udd_ctrl_send_zlp_in();
|
|
return;
|
|
}
|
|
|
|
if (udd_g_ctrlreq.payload_size == udd_ctrl_payload_nb_trans) {
|
|
/* Overrun then request a new payload buffer */
|
|
if (!udd_g_ctrlreq.over_under_run) {
|
|
/* No callback available to request a new payload buffer
|
|
* Stall ZLP */
|
|
udd_ep_control_state = UDD_EPCTRL_STALL_REQ;
|
|
/* Stall all packets on IN & OUT control endpoint */
|
|
udd_ep_set_halt(0);
|
|
return;
|
|
}
|
|
if (!udd_g_ctrlreq.over_under_run()) {
|
|
/* No new payload buffer delivered
|
|
* Stall ZLP */
|
|
udd_ep_control_state = UDD_EPCTRL_STALL_REQ;
|
|
/* Stall all packets on IN & OUT control endpoint */
|
|
udd_ep_set_halt(0);
|
|
return;
|
|
}
|
|
/* New payload buffer available
|
|
* Update number of total data received */
|
|
udd_ctrl_prev_payload_nb_trans += udd_ctrl_payload_nb_trans;
|
|
|
|
/* Reinitialize reception on payload buffer */
|
|
udd_ctrl_payload_nb_trans = 0;
|
|
}
|
|
usb_device_endpoint_read_buffer_job(&usb_device, 0, udd_ctrl_buffer, USB_DEVICE_EP_CTRL_SIZE);
|
|
}
|
|
|
|
/**
|
|
* \internal
|
|
* \brief Endpoint 0 (control) SETUP received callback
|
|
* \param[in] module_inst pointer to USB module instance
|
|
* \param[in] pointer Pointer to the endpoint transfer status parameter struct from driver layer.
|
|
*/
|
|
static void _usb_ep0_on_setup(struct usb_module *module_inst, void *pointer) {
|
|
struct usb_endpoint_callback_parameter *ep_callback_para = (struct usb_endpoint_callback_parameter *)pointer;
|
|
|
|
if (UDD_EPCTRL_SETUP != udd_ep_control_state) {
|
|
if (NULL != udd_g_ctrlreq.callback) {
|
|
udd_g_ctrlreq.callback();
|
|
}
|
|
udd_ep_control_state = UDD_EPCTRL_SETUP;
|
|
}
|
|
if (8 != ep_callback_para->received_bytes) {
|
|
udd_ctrl_stall_data();
|
|
return;
|
|
} else {
|
|
udd_ctrl_fetch_ram();
|
|
if (false == udc_process_setup()) {
|
|
udd_ctrl_stall_data();
|
|
return;
|
|
} else if (Udd_setup_is_in()) {
|
|
udd_ctrl_prev_payload_nb_trans = 0;
|
|
udd_ctrl_payload_nb_trans = 0;
|
|
udd_ep_control_state = UDD_EPCTRL_DATA_IN;
|
|
usb_device_endpoint_read_buffer_job(&usb_device, 0, udd_ctrl_buffer, USB_DEVICE_EP_CTRL_SIZE);
|
|
udd_ctrl_in_sent();
|
|
} else {
|
|
if (0 == udd_g_ctrlreq.req.wLength) {
|
|
udd_ctrl_send_zlp_in();
|
|
return;
|
|
} else {
|
|
udd_ctrl_prev_payload_nb_trans = 0;
|
|
udd_ctrl_payload_nb_trans = 0;
|
|
udd_ep_control_state = UDD_EPCTRL_DATA_OUT;
|
|
/* Initialize buffer size and enable OUT bank */
|
|
usb_device_endpoint_read_buffer_job(&usb_device, 0, udd_ctrl_buffer, USB_DEVICE_EP_CTRL_SIZE);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* \brief Control Endpoint Process when underflow condition has occurred
|
|
* \param[in] pointer Pointer to the endpoint transfer status parameter struct from driver layer.
|
|
*/
|
|
static void udd_ctrl_underflow(void *pointer) {
|
|
struct usb_endpoint_callback_parameter *ep_callback_para = (struct usb_endpoint_callback_parameter *)pointer;
|
|
|
|
if (UDD_EPCTRL_DATA_OUT == udd_ep_control_state) {
|
|
/* Host want to stop OUT transaction
|
|
* then stop to wait OUT data phase and wait IN ZLP handshake */
|
|
udd_ctrl_send_zlp_in();
|
|
} else if (UDD_EPCTRL_HANDSHAKE_WAIT_OUT_ZLP == udd_ep_control_state) {
|
|
/* A OUT handshake is waiting by device,
|
|
* but host want extra IN data then stall extra IN data */
|
|
usb_device_endpoint_set_halt(&usb_device, ep_callback_para->endpoint_address);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* \brief Control Endpoint Process when overflow condition has occurred
|
|
* \param[in] pointer Pointer to the endpoint transfer status parameter struct from driver layer.
|
|
*/
|
|
static void udd_ctrl_overflow(void *pointer) {
|
|
struct usb_endpoint_callback_parameter *ep_callback_para = (struct usb_endpoint_callback_parameter *)pointer;
|
|
|
|
if (UDD_EPCTRL_DATA_IN == udd_ep_control_state) {
|
|
/* Host want to stop IN transaction
|
|
* then stop to wait IN data phase and wait OUT ZLP handshake */
|
|
udd_ep_control_state = UDD_EPCTRL_HANDSHAKE_WAIT_OUT_ZLP;
|
|
} else if (UDD_EPCTRL_HANDSHAKE_WAIT_IN_ZLP == udd_ep_control_state) {
|
|
/* A IN handshake is waiting by device,
|
|
* but host want extra OUT data then stall extra OUT data and following status stage */
|
|
usb_device_endpoint_set_halt(&usb_device, ep_callback_para->endpoint_address);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* \internal
|
|
* \brief Control endpoint transfer fail callback function
|
|
* \param[in] module_inst Pointer to USB module instance
|
|
* \param[in] pointer Pointer to the endpoint transfer status parameter struct from driver layer.
|
|
*/
|
|
static void _usb_ep0_on_tansfer_fail(struct usb_module *module_inst, void *pointer) {
|
|
struct usb_endpoint_callback_parameter *ep_callback_para = (struct usb_endpoint_callback_parameter *)pointer;
|
|
|
|
if (ep_callback_para->endpoint_address & USB_EP_DIR_IN) {
|
|
udd_ctrl_underflow(pointer);
|
|
} else {
|
|
udd_ctrl_overflow(pointer);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* \internal
|
|
* \brief Control endpoint transfer complete callback function
|
|
* \param[in] module_inst Pointer to USB module instance
|
|
* \param[in] pointer Pointer to the endpoint transfer status parameter struct from driver layer.
|
|
*/
|
|
static void _usb_ep0_on_tansfer_ok(struct usb_module *module_inst, void *pointer) {
|
|
if (UDD_EPCTRL_DATA_OUT == udd_ep_control_state) { /* handshake Out for status stage */
|
|
udd_ctrl_out_received(pointer);
|
|
} else if (UDD_EPCTRL_DATA_IN == udd_ep_control_state) { /* handshake In for status stage */
|
|
udd_ctrl_in_sent();
|
|
} else {
|
|
if (NULL != udd_g_ctrlreq.callback) {
|
|
udd_g_ctrlreq.callback();
|
|
}
|
|
udd_ep_control_state = UDD_EPCTRL_SETUP;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* \brief Enable Control Endpoint
|
|
* \param[in] module_inst Pointer to USB module instance
|
|
*/
|
|
static void udd_ctrl_ep_enable(struct usb_module *module_inst) {
|
|
/* USB Device Endpoint0 Configuration */
|
|
struct usb_device_endpoint_config config_ep0;
|
|
|
|
usb_device_endpoint_get_config_defaults(&config_ep0);
|
|
config_ep0.ep_size = (enum usb_endpoint_size)(32 - clz(((uint32_t)Min(Max(USB_DEVICE_EP_CTRL_SIZE, 8), 1024) << 1) - 1) - 1 - 3);
|
|
usb_device_endpoint_set_config(module_inst, &config_ep0);
|
|
|
|
usb_device_endpoint_setup_buffer_job(module_inst, udd_ctrl_buffer);
|
|
|
|
usb_device_endpoint_register_callback(module_inst, 0, USB_DEVICE_ENDPOINT_CALLBACK_RXSTP, _usb_ep0_on_setup);
|
|
usb_device_endpoint_register_callback(module_inst, 0, USB_DEVICE_ENDPOINT_CALLBACK_TRCPT, _usb_ep0_on_tansfer_ok);
|
|
usb_device_endpoint_register_callback(module_inst, 0, USB_DEVICE_ENDPOINT_CALLBACK_TRFAIL, _usb_ep0_on_tansfer_fail);
|
|
usb_device_endpoint_enable_callback(module_inst, 0, USB_DEVICE_ENDPOINT_CALLBACK_RXSTP);
|
|
usb_device_endpoint_enable_callback(module_inst, 0, USB_DEVICE_ENDPOINT_CALLBACK_TRCPT);
|
|
usb_device_endpoint_enable_callback(module_inst, 0, USB_DEVICE_ENDPOINT_CALLBACK_TRFAIL);
|
|
|
|
#ifdef USB_DEVICE_LPM_SUPPORT
|
|
// Enable LPM feature
|
|
usb_device_set_lpm_mode(module_inst, USB_DEVICE_LPM_ACK);
|
|
#endif
|
|
|
|
udd_ep_control_state = UDD_EPCTRL_SETUP;
|
|
}
|
|
|
|
/**
|
|
* \internal
|
|
* \brief Control endpoint Suspend callback function
|
|
* \param[in] module_inst Pointer to USB module instance
|
|
* \param[in] pointer Pointer to the callback parameter from driver layer.
|
|
*/
|
|
static void _usb_on_suspend(struct usb_module *module_inst, void *pointer) {
|
|
usb_device_disable_callback(&usb_device, USB_DEVICE_CALLBACK_SUSPEND);
|
|
usb_device_enable_callback(&usb_device, USB_DEVICE_CALLBACK_WAKEUP);
|
|
udd_sleep_mode(UDD_STATE_SUSPEND);
|
|
#ifdef UDC_SUSPEND_EVENT
|
|
UDC_SUSPEND_EVENT();
|
|
#endif
|
|
}
|
|
|
|
#ifdef USB_DEVICE_LPM_SUPPORT
|
|
static void _usb_device_lpm_suspend(struct usb_module *module_inst, void *pointer) {
|
|
dbg_print("LPM_SUSP\n");
|
|
|
|
uint32_t *lpm_wakeup_enable;
|
|
lpm_wakeup_enable = (uint32_t *)pointer;
|
|
|
|
usb_device_disable_callback(&usb_device, USB_DEVICE_CALLBACK_LPMSUSP);
|
|
usb_device_disable_callback(&usb_device, USB_DEVICE_CALLBACK_SUSPEND);
|
|
usb_device_enable_callback(&usb_device, USB_DEVICE_CALLBACK_WAKEUP);
|
|
|
|
//#warning Here the sleep mode must be choose to have a DFLL startup time < bmAttribut.HIRD
|
|
udd_sleep_mode(UDD_STATE_SUSPEND_LPM); // Enter in LPM SUSPEND mode
|
|
if ((*lpm_wakeup_enable)) {
|
|
UDC_REMOTEWAKEUP_LPM_ENABLE();
|
|
}
|
|
if (!(*lpm_wakeup_enable)) {
|
|
UDC_REMOTEWAKEUP_LPM_DISABLE();
|
|
}
|
|
UDC_SUSPEND_LPM_EVENT();
|
|
}
|
|
#endif
|
|
|
|
/**
|
|
* \internal
|
|
* \brief Control endpoint SOF callback function
|
|
* \param[in] module_inst Pointer to USB module instance
|
|
* \param[in] pointer Pointer to the callback parameter from driver layer.
|
|
*/
|
|
static void _usb_on_sof_notify(struct usb_module *module_inst, void *pointer) {
|
|
udc_sof_notify();
|
|
#ifdef UDC_SOF_EVENT
|
|
UDC_SOF_EVENT();
|
|
#endif
|
|
}
|
|
|
|
/**
|
|
* \internal
|
|
* \brief Control endpoint Reset callback function
|
|
* \param[in] module_inst Pointer to USB module instance
|
|
* \param[in] pointer Pointer to the callback parameter from driver layer.
|
|
*/
|
|
static void _usb_on_bus_reset(struct usb_module *module_inst, void *pointer) {
|
|
// Reset USB Device Stack Core
|
|
udc_reset();
|
|
usb_device_set_address(module_inst, 0);
|
|
udd_ctrl_ep_enable(module_inst);
|
|
}
|
|
|
|
/**
|
|
* \internal
|
|
* \brief Control endpoint Wakeup callback function
|
|
* \param[in] module_inst Pointer to USB module instance
|
|
* \param[in] pointer Pointer to the callback parameter from driver layer.
|
|
*/
|
|
static void _usb_on_wakeup(struct usb_module *module_inst, void *pointer) {
|
|
udd_wait_clock_ready();
|
|
|
|
usb_device_disable_callback(&usb_device, USB_DEVICE_CALLBACK_WAKEUP);
|
|
usb_device_enable_callback(&usb_device, USB_DEVICE_CALLBACK_SUSPEND);
|
|
#ifdef USB_DEVICE_LPM_SUPPORT
|
|
usb_device_register_callback(&usb_device, USB_DEVICE_CALLBACK_LPMSUSP, _usb_device_lpm_suspend);
|
|
usb_device_enable_callback(&usb_device, USB_DEVICE_CALLBACK_LPMSUSP);
|
|
#endif
|
|
udd_sleep_mode(UDD_STATE_IDLE);
|
|
#ifdef UDC_RESUME_EVENT
|
|
UDC_RESUME_EVENT();
|
|
#endif
|
|
}
|
|
|
|
void udd_detach(void) {
|
|
usb_device_detach(&usb_device);
|
|
udd_sleep_mode(UDD_STATE_SUSPEND);
|
|
}
|
|
|
|
void udd_attach(void) {
|
|
udd_sleep_mode(UDD_STATE_IDLE);
|
|
usb_device_attach(&usb_device);
|
|
|
|
usb_device_register_callback(&usb_device, USB_DEVICE_CALLBACK_SUSPEND, _usb_on_suspend);
|
|
usb_device_register_callback(&usb_device, USB_DEVICE_CALLBACK_SOF, _usb_on_sof_notify);
|
|
usb_device_register_callback(&usb_device, USB_DEVICE_CALLBACK_RESET, _usb_on_bus_reset);
|
|
usb_device_register_callback(&usb_device, USB_DEVICE_CALLBACK_WAKEUP, _usb_on_wakeup);
|
|
|
|
usb_device_enable_callback(&usb_device, USB_DEVICE_CALLBACK_SUSPEND);
|
|
usb_device_enable_callback(&usb_device, USB_DEVICE_CALLBACK_SOF);
|
|
usb_device_enable_callback(&usb_device, USB_DEVICE_CALLBACK_RESET);
|
|
usb_device_enable_callback(&usb_device, USB_DEVICE_CALLBACK_WAKEUP);
|
|
#ifdef USB_DEVICE_LPM_SUPPORT
|
|
usb_device_register_callback(&usb_device, USB_DEVICE_CALLBACK_LPMSUSP, _usb_device_lpm_suspend);
|
|
usb_device_enable_callback(&usb_device, USB_DEVICE_CALLBACK_LPMSUSP);
|
|
#endif
|
|
}
|
|
|
|
void udd_enable(void) {
|
|
uint32_t irqflags;
|
|
|
|
/* To avoid USB interrupt before end of initialization */
|
|
irqflags = __get_PRIMASK();
|
|
__disable_irq();
|
|
__DMB();
|
|
|
|
struct usb_config config_usb;
|
|
|
|
/* USB Module configuration */
|
|
usb_get_config_defaults(&config_usb);
|
|
config_usb.source_generator = UDD_CLOCK_GEN;
|
|
usb_init(&usb_device, USB, &config_usb);
|
|
|
|
/* USB Module Enable */
|
|
usb_enable(&usb_device);
|
|
|
|
/* Check clock after enable module, request the clock */
|
|
udd_wait_clock_ready();
|
|
|
|
udd_sleep_mode(UDD_STATE_SUSPEND);
|
|
|
|
// No VBus detect, assume always high
|
|
#ifndef USB_DEVICE_ATTACH_AUTO_DISABLE
|
|
udd_attach();
|
|
#endif
|
|
|
|
__DMB();
|
|
__set_PRIMASK(irqflags);
|
|
}
|
|
|
|
void udd_disable(void) {
|
|
udd_detach();
|
|
|
|
udd_sleep_mode(UDD_STATE_OFF);
|
|
}
|
|
/** @} */
|