Maxim Integrated
USBDevice with MAX32620HSP platform support
Fork of
USBDevice
by 
mbed official
Diff: USBDevice/TARGET_Silicon_Labs/src/em_usbd.c
- Revision:
- 59:2af474687369
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/USBDevice/TARGET_Silicon_Labs/src/em_usbd.c Thu Aug 13 15:46:06 2015 +0100
@@ -0,0 +1,1438 @@
+/**************************************************************************//**
+ * @file em_usbd.c
+ * @brief USB protocol stack library, device API.
+ * @version 3.20.14
+ ******************************************************************************
+ * @section License
+ * <b>(C) Copyright 2014 Silicon Labs, http://www.silabs.com</b>
+ *******************************************************************************
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ ******************************************************************************/
+
+#include "em_device.h"
+#if defined( USB_PRESENT ) && ( USB_COUNT == 1 )
+#include "em_usb.h"
+#if defined( USB_DEVICE )
+
+#include "em_cmu.h"
+#include "em_usbtypes.h"
+#include "em_usbhal.h"
+#include "em_usbd.h"
+
+/** @cond DO_NOT_INCLUDE_WITH_DOXYGEN */
+
+static USBD_Device_TypeDef device;
+USBD_Device_TypeDef *dev = &device;
+
+static uint32_t totalRxFifoSize = 0, totalTxFifoSize = 0;
+static int numEps = 0;
+static int txFifoNum = 1;
+
+static void USBD_ResetEndpoints(void);
+extern USB_Status_TypeDef USBDHAL_ReconfigureFifos( uint32_t totalRxFifoSize,
+ uint32_t totalTxFifoSize );
+#ifndef __MBED__
+static const char *stateNames[] =
+{
+ [ USBD_STATE_NONE ] = "NONE ",
+ [ USBD_STATE_ATTACHED ] = "ATTACHED ",
+ [ USBD_STATE_POWERED ] = "POWERED ",
+ [ USBD_STATE_DEFAULT ] = "DEFAULT ",
+ [ USBD_STATE_ADDRESSED ] = "ADDRESSED ",
+ [ USBD_STATE_CONFIGURED ] = "CONFIGURED",
+ [ USBD_STATE_SUSPENDED ] = "SUSPENDED ",
+ [ USBD_STATE_LASTMARKER ] = "UNDEFINED "
+};
+#endif
+
+/** @endcond */
+
+/***************************************************************************//**
+ * @brief
+ * Abort all pending transfers.
+ *
+ * @details
+ * Aborts transfers for all endpoints currently in use. Pending
+ * transfers on the default endpoint (EP0) are not aborted.
+ ******************************************************************************/
+void USBD_AbortAllTransfers( void )
+{
+ INT_Disable();
+ USBDHAL_AbortAllTransfers( USB_STATUS_EP_ABORTED );
+ INT_Enable();
+}
+
+/***************************************************************************//**
+ * @brief
+ * Abort a pending transfer on a specific endpoint.
+ *
+ * @param[in] epAddr
+ * The address of the endpoint to abort.
+ ******************************************************************************/
+int USBD_AbortTransfer( int epAddr )
+{
+ USB_XferCompleteCb_TypeDef callback;
+ USBD_Ep_TypeDef *ep = USBD_GetEpFromAddr( epAddr );
+
+ if ( ep == NULL )
+ {
+ DEBUG_USB_API_PUTS( "\nUSBD_AbortTransfer(), Illegal endpoint" );
+ EFM_ASSERT( false );
+ return USB_STATUS_ILLEGAL;
+ }
+
+ if ( ep->num == 0 )
+ {
+ DEBUG_USB_API_PUTS( "\nUSBD_AbortTransfer(), Illegal endpoint" );
+ EFM_ASSERT( false );
+ return USB_STATUS_ILLEGAL;
+ }
+
+ INT_Disable();
+ if ( ep->state == D_EP_IDLE )
+ {
+ INT_Enable();
+ return USB_STATUS_OK;
+ }
+
+ USBD_AbortEp( ep );
+
+ ep->state = D_EP_IDLE;
+ if ( ep->xferCompleteCb )
+ {
+ callback = ep->xferCompleteCb;
+ ep->xferCompleteCb = NULL;
+
+ if ( ( dev->lastState == USBD_STATE_CONFIGURED ) &&
+ ( dev->state == USBD_STATE_ADDRESSED ) )
+ {
+ USBDHAL_DeactivateEp( ep );
+ }
+
+ DEBUG_TRACE_ABORT( USB_STATUS_EP_ABORTED );
+ callback( USB_STATUS_EP_ABORTED, ep->xferred, ep->remaining );
+ }
+
+ INT_Enable();
+ return USB_STATUS_OK;
+}
+
+/***************************************************************************//**
+ * @brief
+ * Start USB device operation.
+ *
+ * @details
+ * Device operation is started by connecting a pullup resistor on the
+ * appropriate USB data line.
+ ******************************************************************************/
+void USBD_Connect( void )
+{
+ INT_Disable();
+ USBDHAL_Connect();
+ INT_Enable();
+}
+
+/***************************************************************************//**
+ * @brief
+ * Stop USB device operation.
+ *
+ * @details
+ * Device operation is stopped by disconnecting the pullup resistor from the
+ * appropriate USB data line. Often referred to as a "soft" disconnect.
+ ******************************************************************************/
+void USBD_Disconnect( void )
+{
+ INT_Disable();
+ USBDHAL_Disconnect();
+ INT_Enable();
+}
+
+/***************************************************************************//**
+ * @brief
+ * Check if an endpoint is busy doing a transfer.
+ *
+ * @param[in] epAddr
+ * The address of the endpoint to check.
+ *
+ * @return
+ * True if endpoint is busy, false otherwise.
+ ******************************************************************************/
+bool USBD_EpIsBusy( int epAddr )
+{
+ USBD_Ep_TypeDef *ep = USBD_GetEpFromAddr( epAddr );
+
+ if ( ep == NULL )
+ {
+ DEBUG_USB_API_PUTS( "\nUSBD_EpIsBusy(), Illegal endpoint" );
+ EFM_ASSERT( false );
+ return USB_STATUS_ILLEGAL;
+ }
+
+ if ( ep->state == D_EP_IDLE )
+ return false;
+
+ return true;
+}
+
+/***************************************************************************//**
+ * @brief
+ * Get current USB device state.
+ *
+ * @return
+ * Device USB state. See @ref USBD_State_TypeDef.
+ ******************************************************************************/
+USBD_State_TypeDef USBD_GetUsbState( void )
+{
+ return dev->state;
+}
+
+/***************************************************************************//**
+ * @brief
+ * Get a string naming a device USB state.
+ *
+ * @param[in] state
+ * Device USB state. See @ref USBD_State_TypeDef.
+ *
+ * @return
+ * State name string pointer.
+ ******************************************************************************/
+const char *USBD_GetUsbStateName( USBD_State_TypeDef state )
+{
+ if ( state > USBD_STATE_LASTMARKER )
+ state = USBD_STATE_LASTMARKER;
+
+#ifndef __MBED__
+ return stateNames[ state ];
+#else
+ return NULL;
+#endif
+}
+
+/***************************************************************************//**
+ * @brief
+ * Initializes USB device hardware and internal protocol stack data structures,
+ * then connects the data-line (D+ or D-) pullup resistor to signal host that
+ * enumeration can begin.
+ *
+ * @note
+ * You may later use @ref USBD_Disconnect() and @ref USBD_Connect() to force
+ * reenumeration.
+ *
+ * @param[in] p
+ * Pointer to device initialization struct. See @ref USBD_Init_TypeDef.
+ *
+ * @return
+ * @ref USB_STATUS_OK on success, else an appropriate error code.
+ ******************************************************************************/
+int USBD_Init( const USBD_Init_TypeDef *p )
+{
+ USBD_Ep_TypeDef *ep;
+
+#if !defined( USB_CORECLK_HFRCO ) || !defined( CMU_OSCENCMD_USHFRCOEN )
+ /* Devices supporting crystal-less USB can use HFRCO or HFXO as core clock. */
+ /* All other devices must use HFXO as core clock. */
+ if ( CMU_ClockSelectGet( cmuClock_HF ) != cmuSelect_HFXO )
+ {
+ CMU_ClockSelectSet( cmuClock_HF, cmuSelect_HFXO );
+ }
+#endif
+
+#if !defined( CMU_OSCENCMD_USHFRCOEN )
+#if ( USB_USBC_32kHz_CLK == USB_USBC_32kHz_CLK_LFXO )
+ CMU_OscillatorEnable(cmuOsc_LFXO, true, false);
+#else
+ CMU_OscillatorEnable(cmuOsc_LFRCO, true, false);
+#endif
+
+#else
+ CMU_ClockEnable(cmuClock_CORELE, true);
+ /* LFC clock is needed to detect USB suspend when LEMIDLE is activated. */
+#if ( USB_USBC_32kHz_CLK == USB_USBC_32kHz_CLK_LFXO )
+ CMU_ClockSelectSet(cmuClock_LFC, cmuSelect_LFXO);
+#else
+ CMU_ClockSelectSet(cmuClock_LFC, cmuSelect_LFRCO);
+#endif
+ CMU_ClockEnable(cmuClock_USBLE, true);
+#endif
+
+ USBTIMER_Init();
+
+ memset( dev, 0, sizeof( USBD_Device_TypeDef ) );
+
+ dev->setup = dev->setupPkt;
+ dev->state = USBD_STATE_LASTMARKER;
+ dev->savedState = USBD_STATE_NONE;
+ dev->lastState = USBD_STATE_NONE;
+ dev->callbacks = p->callbacks;
+ dev->remoteWakeupEnabled = false;
+
+ /* Initialize EP0 */
+
+ ep = &dev->ep[ 0 ];
+ ep->in = false;
+ ep->buf = NULL;
+ ep->num = 0;
+ ep->mask = 1;
+ ep->addr = 0;
+ ep->type = USB_EPTYPE_CTRL;
+ ep->txFifoNum = 0;
+
+ /* FIXME! */
+ ep->packetSize = 64;
+ dev->ep0MpsCode = _USB_DOEP0CTL_MPS_64B;
+
+ ep->remaining = 0;
+ ep->xferred = 0;
+ ep->state = D_EP_IDLE;
+ ep->xferCompleteCb = NULL;
+ ep->fifoSize = ep->packetSize / 4;
+
+ totalTxFifoSize = ep->fifoSize * p->bufferingMultiplier[ 0 ];
+ totalRxFifoSize = (ep->fifoSize + 1) * p->bufferingMultiplier[ 0 ];
+
+ /* Rx-FIFO size: SETUP packets : 4*n + 6 n=#CTRL EP's
+ * GOTNAK : 1
+ * Status info : 2*n n=#OUT EP's (EP0 included) in HW
+ */
+ totalRxFifoSize += 10 + 1 + ( 2 * (MAX_NUM_OUT_EPS + 1) );
+
+ INT_Disable();
+
+ /* Enable USB clock */
+ CMU->HFCORECLKEN0 |= CMU_HFCORECLKEN0_USB | CMU_HFCORECLKEN0_USBC;
+
+#if defined( CMU_OSCENCMD_USHFRCOEN )
+ CMU->USHFRCOCONF = CMU_USHFRCOCONF_BAND_48MHZ;
+ CMU_ClockSelectSet( cmuClock_USBC, cmuSelect_USHFRCO );
+
+ /* Enable USHFRCO Clock Recovery mode. */
+ CMU->USBCRCTRL |= CMU_USBCRCTRL_EN;
+
+ /* Turn on Low Energy Mode (LEM) features. */
+ USB->CTRL = USB_CTRL_LEMOSCCTRL_GATE
+ | USB_CTRL_LEMIDLEEN
+ | USB_CTRL_LEMPHYCTRL;
+#else
+ CMU_ClockSelectSet( cmuClock_USBC, cmuSelect_HFCLK );
+#endif
+
+ USBHAL_DisableGlobalInt();
+
+ if ( USBDHAL_CoreInit( totalRxFifoSize, totalTxFifoSize ) == USB_STATUS_OK )
+ {
+ USBDHAL_EnableUsbResetAndSuspendInt();
+ USBHAL_EnableGlobalInt();
+ NVIC_ClearPendingIRQ( USB_IRQn );
+ NVIC_EnableIRQ( USB_IRQn );
+ }
+ else
+ {
+ INT_Enable();
+ DEBUG_USB_API_PUTS( "\nUSBD_Init(), FIFO setup error" );
+ EFM_ASSERT( false );
+ return USB_STATUS_ILLEGAL;
+ }
+
+#if ( USB_PWRSAVE_MODE & USB_PWRSAVE_MODE_ONVBUSOFF )
+ if ( USBHAL_VbusIsOn() )
+ {
+ USBD_SetUsbState( USBD_STATE_POWERED );
+ }
+ else
+#endif
+ {
+ USBD_SetUsbState( USBD_STATE_NONE );
+ }
+
+ INT_Enable();
+ return USB_STATUS_OK;
+}
+
+/***************************************************************************//**
+ * @brief
+ * Start a read (OUT) transfer on an endpoint.
+ *
+ * @note
+ * The transfer buffer length must be a multiple of 4 bytes in length and
+ * WORD (4 byte) aligned. When allocating the buffer, round buffer length up.
+ * If it is possible that the host will send more data than your device
+ * expects, round buffer size up to the next multiple of maxpacket size.
+ *
+ * @param[in] epAddr
+ * Endpoint address.
+ *
+ * @param[in] data
+ * Pointer to transfer data buffer.
+ *
+ * @param[in] byteCount
+ * Transfer length.
+ *
+ * @param[in] callback
+ * Function to be called on transfer completion. Supply NULL if no callback
+ * is needed. See @ref USB_XferCompleteCb_TypeDef.
+ *
+ * @return
+ * @ref USB_STATUS_OK on success, else an appropriate error code.
+ ******************************************************************************/
+int USBD_Read( int epAddr, void *data, int byteCount,
+ USB_XferCompleteCb_TypeDef callback )
+{
+ USBD_Ep_TypeDef *ep = USBD_GetEpFromAddr( epAddr );
+
+ USB_PRINTF("USBD: Read addr %x, data %p, size %d, cb 0x%lx\n",
+ epAddr, data, byteCount, (uint32_t)callback);
+
+ if ( ep == NULL )
+ {
+ DEBUG_USB_API_PUTS( "\nUSBD_Read(), Illegal endpoint" );
+ EFM_ASSERT( false );
+ return USB_STATUS_ILLEGAL;
+ }
+
+ if ( ( byteCount > MAX_XFER_LEN ) ||
+ ( ( byteCount / ep->packetSize ) > MAX_PACKETS_PR_XFER ) )
+ {
+ DEBUG_USB_API_PUTS( "\nUSBD_Read(), Illegal transfer size" );
+ EFM_ASSERT( false );
+ return USB_STATUS_ILLEGAL;
+ }
+
+ if ( (uint32_t)data & 3 )
+ {
+ DEBUG_USB_API_PUTS( "\nUSBD_Read(), Misaligned data buffer" );
+ EFM_ASSERT( false );
+ return USB_STATUS_ILLEGAL;
+ }
+
+ INT_Disable();
+ if ( USBDHAL_EpIsStalled( ep ) )
+ {
+ INT_Enable();
+ DEBUG_USB_API_PUTS( "\nUSBD_Read(), Endpoint is halted" );
+ return USB_STATUS_EP_STALLED;
+ }
+
+ if ( ep->state != D_EP_IDLE )
+ {
+ INT_Enable();
+ DEBUG_USB_API_PUTS( "\nUSBD_Read(), Endpoint is busy" );
+ return USB_STATUS_EP_BUSY;
+ }
+
+ if ( ( ep->num > 0 ) && ( USBD_GetUsbState() != USBD_STATE_CONFIGURED ) )
+ {
+ INT_Enable();
+ DEBUG_USB_API_PUTS( "\nUSBD_Read(), Device not configured" );
+ return USB_STATUS_DEVICE_UNCONFIGURED;
+ }
+
+ ep->buf = (uint8_t*)data;
+ ep->remaining = byteCount;
+ ep->xferred = 0;
+
+ if ( ep->num == 0 )
+ {
+ ep->in = false;
+ }
+ else if ( ep->in != false )
+ {
+ INT_Enable();
+ DEBUG_USB_API_PUTS( "\nUSBD_Read(), Illegal EP direction" );
+ EFM_ASSERT( false );
+ return USB_STATUS_ILLEGAL;
+ }
+
+ ep->state = D_EP_RECEIVING;
+ ep->xferCompleteCb = callback;
+
+ USBD_ArmEp( ep );
+ INT_Enable();
+ return USB_STATUS_OK;
+}
+
+/***************************************************************************//**
+ * @brief
+ * Perform a remote wakeup signalling sequence.
+ *
+ * @note
+ * It is the responsibility of the application to ensure that remote wakeup
+ * is not attempted before the device has been suspended for at least 5
+ * miliseconds. This function should not be called from within an interrupt
+ * handler.
+ *
+ * @return
+ * @ref USB_STATUS_OK on success, else an appropriate error code.
+ ******************************************************************************/
+int USBD_RemoteWakeup( void )
+{
+ INT_Disable();
+
+ if ( ( dev->state != USBD_STATE_SUSPENDED ) ||
+ ( dev->remoteWakeupEnabled == false ) )
+ {
+ INT_Enable();
+ DEBUG_USB_API_PUTS( "\nUSBD_RemoteWakeup(), Illegal remote wakeup" );
+ return USB_STATUS_ILLEGAL;
+ }
+
+ USBDHAL_SetRemoteWakeup();
+ INT_Enable();
+ USBTIMER_DelayMs( 10 );
+ INT_Disable();
+ USBDHAL_ClearRemoteWakeup();
+ INT_Enable();
+ return USB_STATUS_OK;
+}
+
+/***************************************************************************//**
+ * @brief
+ * Check if it is ok to enter energy mode EM2.
+ *
+ * @note
+ * Before entering EM2 both the USB hardware and the USB stack must be in a
+ * certain state, this function checks if all conditions for entering EM2
+ * is met.
+ * Refer to the @ref usb_device_powersave section for more information.
+ *
+ * @return
+ * True if ok to enter EM2, false otherwise.
+ ******************************************************************************/
+bool USBD_SafeToEnterEM2( void )
+{
+#if ( USB_PWRSAVE_MODE )
+ return USBD_poweredDown ? true : false;
+#else
+ return false;
+#endif
+}
+
+/** @cond DO_NOT_INCLUDE_WITH_DOXYGEN */
+
+void USBD_SetUsbState( USBD_State_TypeDef newState )
+{
+ USBD_State_TypeDef currentState;
+
+ currentState = dev->state;
+ if ( newState == USBD_STATE_SUSPENDED )
+ {
+ dev->savedState = currentState;
+ }
+
+ dev->lastState = dev->state;
+ dev->state = newState;
+
+ if ( ( dev->callbacks->usbStateChange ) &&
+ ( currentState != newState ) )
+ {
+ /* When we transition to a state "lower" than CONFIGURED
+ * we must reset the endpoint data
+ */
+ if ( (dev->lastState == USBD_STATE_CONFIGURED ||
+ dev->lastState == USBD_STATE_SUSPENDED ) &&
+ dev->state < USBD_STATE_CONFIGURED )
+ {
+ USBD_ResetEndpoints();
+ }
+
+ dev->callbacks->usbStateChange( currentState, newState );
+ }
+}
+
+/** @endcond */
+
+/***************************************************************************//**
+ * @brief
+ * Set an endpoint in the stalled (halted) state.
+ *
+ * @param[in] epAddr
+ * The address of the endpoint to stall.
+ *
+ * @return
+ * @ref USB_STATUS_OK on success, else an appropriate error code.
+ ******************************************************************************/
+int USBD_StallEp( int epAddr )
+{
+ USB_Status_TypeDef retVal;
+ USBD_Ep_TypeDef *ep = USBD_GetEpFromAddr( epAddr );
+
+ if ( ep == NULL )
+ {
+ DEBUG_USB_API_PUTS( "\nUSBD_StallEp(), Illegal request" );
+ EFM_ASSERT( false );
+ return USB_STATUS_ILLEGAL;
+ }
+
+ if ( ep->num == 0 )
+ {
+ DEBUG_USB_API_PUTS( "\nUSBD_StallEp(), Illegal endpoint" );
+ EFM_ASSERT( false );
+ return USB_STATUS_ILLEGAL;
+ }
+
+ INT_Disable();
+ retVal = USBDHAL_StallEp( ep );
+ INT_Enable();
+
+ if ( retVal != USB_STATUS_OK )
+ {
+ retVal = USB_STATUS_ILLEGAL;
+ }
+
+ return retVal;
+}
+
+/***************************************************************************//**
+ * @brief
+ * Stop USB device stack operation.
+ *
+ * @details
+ * The data-line pullup resistor is turned off, USB interrupts are disabled,
+ * and finally the USB pins are disabled.
+ ******************************************************************************/
+void USBD_Stop( void )
+{
+ USBD_Disconnect();
+ NVIC_DisableIRQ( USB_IRQn );
+ USBHAL_DisableGlobalInt();
+ USBHAL_DisableUsbInt();
+ USBHAL_DisablePhyPins();
+ USBD_SetUsbState( USBD_STATE_NONE );
+ /* Turn off USB clocks. */
+ CMU->HFCORECLKEN0 &= ~(CMU_HFCORECLKEN0_USB | CMU_HFCORECLKEN0_USBC);
+}
+
+/***************************************************************************//**
+ * @brief
+ * Reset stall state on a stalled (halted) endpoint.
+ *
+ * @param[in] epAddr
+ * The address of the endpoint to un-stall.
+ *
+ * @return
+ * @ref USB_STATUS_OK on success, else an appropriate error code.
+ ******************************************************************************/
+int USBD_UnStallEp( int epAddr )
+{
+ USB_Status_TypeDef retVal;
+ USBD_Ep_TypeDef *ep = USBD_GetEpFromAddr( epAddr );
+
+ if ( ep == NULL )
+ {
+ DEBUG_USB_API_PUTS( "\nUSBD_UnStallEp(), Illegal request" );
+ EFM_ASSERT( false );
+ return USB_STATUS_ILLEGAL;
+ }
+
+ if ( ep->num == 0 )
+ {
+ DEBUG_USB_API_PUTS( "\nUSBD_UnStallEp(), Illegal endpoint" );
+ EFM_ASSERT( false );
+ return USB_STATUS_ILLEGAL;
+ }
+
+ INT_Disable();
+ retVal = USBDHAL_UnStallEp( ep );
+ INT_Enable();
+
+ if ( retVal != USB_STATUS_OK )
+ {
+ retVal = USB_STATUS_ILLEGAL;
+ }
+
+ return retVal;
+}
+
+/***************************************************************************//**
+ * @brief
+ * Start a write (IN) transfer on an endpoint.
+ *
+ * @param[in] epAddr
+ * Endpoint address.
+ *
+ * @param[in] data
+ * Pointer to transfer data buffer. This buffer must be WORD (4 byte) aligned.
+ *
+ * @param[in] byteCount
+ * Transfer length.
+ *
+ * @param[in] callback
+ * Function to be called on transfer completion. Supply NULL if no callback
+ * is needed. See @ref USB_XferCompleteCb_TypeDef.
+ *
+ * @return
+ * @ref USB_STATUS_OK on success, else an appropriate error code.
+ ******************************************************************************/
+int USBD_Write( int epAddr, void *data, int byteCount,
+ USB_XferCompleteCb_TypeDef callback )
+{
+ USBD_Ep_TypeDef *ep = USBD_GetEpFromAddr( epAddr );
+
+ USB_PRINTF("USBD: Write addr %x, data %p, size %d, cb 0x%lx\n",
+ epAddr, data, byteCount, (uint32_t)callback);
+
+ if ( ep == NULL )
+ {
+ DEBUG_USB_API_PUTS( "\nUSBD_Write(), Illegal endpoint" );
+ EFM_ASSERT( false );
+ return USB_STATUS_ILLEGAL;
+ }
+
+ if ( ( byteCount > MAX_XFER_LEN ) ||
+ ( ( byteCount / ep->packetSize ) > MAX_PACKETS_PR_XFER ) )
+ {
+ DEBUG_USB_API_PUTS( "\nUSBD_Write(), Illegal transfer size" );
+ EFM_ASSERT( false );
+ return USB_STATUS_ILLEGAL;
+ }
+
+ if ( (uint32_t)data & 3 )
+ {
+ DEBUG_USB_API_PUTS( "\nUSBD_Write(), Misaligned data buffer" );
+ EFM_ASSERT( false );
+ return USB_STATUS_ILLEGAL;
+ }
+
+ INT_Disable();
+ if ( USBDHAL_EpIsStalled( ep ) )
+ {
+ INT_Enable();
+ DEBUG_USB_API_PUTS( "\nUSBD_Write(), Endpoint is halted" );
+ return USB_STATUS_EP_STALLED;
+ }
+
+ if ( ep->state != D_EP_IDLE )
+ {
+ INT_Enable();
+ DEBUG_USB_API_PUTS( "\nUSBD_Write(), Endpoint is busy" );
+ return USB_STATUS_EP_BUSY;
+ }
+
+ if ( ( ep->num > 0 ) && ( USBD_GetUsbState() != USBD_STATE_CONFIGURED ) )
+ {
+ INT_Enable();
+ DEBUG_USB_API_PUTS( "\nUSBD_Write(), Device not configured" );
+ return USB_STATUS_DEVICE_UNCONFIGURED;
+ }
+
+ ep->buf = (uint8_t*)data;
+ ep->remaining = byteCount;
+ ep->xferred = 0;
+
+ if ( ep->num == 0 )
+ {
+ ep->in = true;
+ }
+ else if ( ep->in != true )
+ {
+ INT_Enable();
+ DEBUG_USB_API_PUTS( "\nUSBD_Write(), Illegal EP direction" );
+ EFM_ASSERT( false );
+ return USB_STATUS_ILLEGAL;
+ }
+
+ ep->state = D_EP_TRANSMITTING;
+ ep->xferCompleteCb = callback;
+
+ USBD_ArmEp( ep );
+ INT_Enable();
+ return USB_STATUS_OK;
+}
+
+int USBD_SetAddress(uint8_t addr)
+{
+ int retVal = USB_STATUS_REQ_ERR;
+
+ if ( dev->state == USBD_STATE_DEFAULT )
+ {
+ if ( addr != 0 )
+ {
+ USBD_SetUsbState( USBD_STATE_ADDRESSED );
+ }
+ USBDHAL_SetAddr( addr );
+ retVal = USB_STATUS_OK;
+ }
+ else if ( dev->state == USBD_STATE_ADDRESSED )
+ {
+ if ( addr == 0 )
+ {
+ USBD_SetUsbState( USBD_STATE_DEFAULT );
+ }
+ USBDHAL_SetAddr( addr );
+ retVal = USB_STATUS_OK;
+ }
+
+ return retVal;
+}
+
+/***************************************************************************//**
+ * @brief
+ * Query the stall state of an endpoint
+ *
+ * @param[in] epAddr
+ * The address of the endpoint to query.
+ *
+ * @return
+ * True if endpoint is stalled, false otherwise
+ ******************************************************************************/
+int USBD_EpIsStalled(int epAddr)
+{
+ USBD_Ep_TypeDef *ep = USBD_GetEpFromAddr( epAddr );
+
+ if( !ep )
+ {
+ return false;
+ }
+
+ return USBDHAL_EpIsStalled(ep);
+}
+
+/***************************************************************************//**
+ * @brief
+ * Reset (remove) all client endpoints
+ *
+ * @details
+ * Removes client endpoints, and resets the RX/TX fifos. No endpoints
+ * other than EP0 can be used until added with @ref USBD_AddEndpoint.
+ ******************************************************************************/
+static void USBD_ResetEndpoints(void)
+{
+ USBD_Ep_TypeDef *ep = &dev->ep[0];
+
+ numEps = 0;
+ txFifoNum = 1;
+
+ totalTxFifoSize = ep->fifoSize * 1;
+ totalRxFifoSize = (ep->fifoSize + 1) * 1;
+ totalRxFifoSize += 10 + 1 + ( 2 * (MAX_NUM_OUT_EPS + 1) );
+}
+
+/***************************************************************************//**
+ * @brief
+ * Add a new endpoint
+ *
+ * @param[in] epAddr
+ * Endpoint address
+ *
+ * @param[in] transferType
+ * Endpoint type, one of @ref USB_EPTYPE_BULK, @ref USB_EPTYPE_INTR or
+ * @ref USB_EPTYPE_ISOC.
+ *
+ * @param[in] maxPacketSize
+ * Maximum packet size of the new endpoint, in bytes
+ *
+ * @param[in] bufferMult
+ * FIFO buffer size multiplier
+ *
+ * @return
+ * @ref USB_STATUS_OK on success, else an appropriate error code.
+ ******************************************************************************/
+int USBD_AddEndpoint(int epAddr, int transferType,
+ int maxPacketSize, int bufferMult)
+{
+ USBD_Ep_TypeDef *ep;
+
+ numEps++;
+
+ ep = &dev->ep[ numEps ];
+ ep->in = ( epAddr & USB_SETUP_DIR_MASK ) != 0;
+ ep->buf = NULL;
+ ep->addr = epAddr;
+ ep->num = ep->addr & USB_EPNUM_MASK;
+ ep->mask = 1 << ep->num;
+ ep->type = transferType;
+ ep->packetSize = maxPacketSize;
+ ep->remaining = 0;
+ ep->xferred = 0;
+ ep->state = D_EP_IDLE;
+ ep->xferCompleteCb = NULL;
+
+ if ( ep->in )
+ {
+ ep->txFifoNum = txFifoNum++;
+ ep->fifoSize = ( ( ep->packetSize + 3 ) / 4 ) * bufferMult;
+ dev->inEpAddr2EpIndex[ ep->num ] = numEps;
+ totalTxFifoSize += ep->fifoSize;
+
+ if ( ep->num > MAX_NUM_IN_EPS )
+ {
+ DEBUG_USB_API_PUTS( "\nUSBD_AddEndpoint(), Illegal IN EP address" );
+ EFM_ASSERT( false );
+ return USB_STATUS_ILLEGAL;
+ }
+ }
+ else
+ {
+ ep->fifoSize = ( ( ( ep->packetSize + 3 ) / 4 ) + 1 ) * bufferMult;
+ dev->outEpAddr2EpIndex[ ep->num ] = numEps;
+ totalRxFifoSize += ep->fifoSize;
+
+ if ( ep->num > MAX_NUM_OUT_EPS )
+ {
+ DEBUG_USB_API_PUTS( "\nUSBD_AddEndpoint(), Illegal OUT EP address" );
+ EFM_ASSERT( false );
+ return USB_STATUS_ILLEGAL;
+ }
+ }
+
+ USB_PRINTF("USBD: Added endpoint %d to slot %d, in %d, addr 0x%x, type %d, ps %d, fifo %ld (total tx %ld, rx %ld)\n",
+ ep->num, numEps, ep->in, ep->addr, ep->type, ep->packetSize, ep->fifoSize,
+ totalTxFifoSize, totalRxFifoSize);
+
+ INT_Disable();
+#if defined( CMU_OSCENCMD_USHFRCOEN )
+ /* Happy Gecko workaround: disable LEM GATE mode if using ISOC endpoints. */
+ if ( transferType == USB_EPTYPE_ISOC )
+ {
+ USB->CTRL = (USB->CTRL & ~_USB_CTRL_LEMOSCCTRL_MASK) | USB_CTRL_LEMOSCCTRL_NONE;
+ }
+#endif
+
+ int ret = USBDHAL_ReconfigureFifos(totalRxFifoSize, totalTxFifoSize);
+ INT_Enable();
+
+ if( ret != USB_STATUS_OK ) {
+ return ret;
+ }
+
+ USBDHAL_ActivateEp(ep, false);
+
+ return USB_STATUS_OK;
+}
+
+
+/***************************************************************************//**
+ * @brief
+ * Set an endpoint0 in the stalled (halted) state.
+ *
+ * @details
+ * Temporarily stalls endpoint 0. Used to signal a failure to respond to
+ * the host's setup packet.
+ ******************************************************************************/
+void USBD_StallEp0()
+{
+ int const epAddr = 0;
+ USBD_Ep_TypeDef *ep = USBD_GetEpFromAddr( epAddr );
+ ep->in = true;
+ USBDHAL_StallEp( ep ); /* Stall Ep0 IN */
+ ep->in = false; /* OUT for next SETUP */
+ USBDHAL_StallEp( ep ); /* Stall Ep0 OUT */
+#if !defined( USB_DOEP0INT_STUPPKTRCVD )
+ USBDHAL_ReenableEp0Setup( dev ); /* Prepare for next SETUP pkt. */
+#else
+ USBDHAL_StartEp0Setup( dev );
+#endif
+ ep->state = D_EP_IDLE;
+}
+
+/******** THE REST OF THE FILE IS DOCUMENTATION ONLY !**********************//**
+ * @{
+
+@page usb_device USB device stack library
+
+ The source files for the USB device stack resides in the usb directory
+ and follows the naming convention: em_usbd<em>nnn</em>.c/h.
+
+ @li @ref usb_device_intro
+ @li @ref usb_device_api
+ @li @ref usb_device_conf
+ @li @ref usb_device_powersave
+ @li @ref usb_device_example1
+
+
+@n @section usb_device_intro Introduction
+
+ The USB device protocol stack provides an API which makes it possible to
+ create USB devices with a minimum of effort. The device stack supports control,
+ bulk and interrupt transfers.
+
+ The stack is highly configurable to suit various needs, it does also contain
+ useful debugging features together with several demonstration projects to
+ get you started fast.
+
+ We recommend that you read through this documentation, then proceed to build
+ and test a few example projects before you start designing your own device.
+
+@n @section usb_device_api The device stack API
+
+ This section contains brief descriptions of the functions in the API. You will
+ find detailed information on input and output parameters and return values by
+ clicking on the hyperlinked function names. It is also a good idea to study
+ the code in the USB demonstration projects.
+
+ Your application code must include one header file: @em em_usb.h.
+
+ All functions defined in the API can be called from within interrupt handlers.
+
+ The USB stack use a hardware timer to keep track of time. TIMER0 is the
+ default choice, refer to @ref usb_device_conf for other possibilities.
+ Your application must not use the selected timer.
+
+ <b>Pitfalls:</b>@n
+ The USB peripheral will fill your receive buffers in quantities of WORD's
+ (4 bytes). Transmit and receive buffers must be WORD aligned, in
+ addition when allocating storage for receive buffers, round size up to
+ next WORD boundary. If it is possible that the host will send more data
+ than your device expects, round buffer size up to the next multiple of
+ maxpacket size for the relevant endpoint to avoid data corruption.
+
+ Transmit buffers passed to @htmlonly USBD_Write() @endhtmlonly must be
+ statically allocated because @htmlonly USBD_Write() @endhtmlonly only
+ initiates the transfer. When the host decide to actually perform the
+ transfer, your data must be available.
+
+ @n @ref USBD_Init() @n
+ This function is called to register your device and all its properties with
+ the device stack. The application must fill in a @ref USBD_Init_TypeDef
+ structure prior to calling. Refer to @ref DeviceInitCallbacks for the
+ optional callback functions defined within this structure. When this
+ function has been called your device is ready to be enumerated by the USB
+ host.
+
+ @ref USBD_Read(), @ref USBD_Write() @n
+ These functions initiate data transfers.
+ @n @htmlonly USBD_Read() @endhtmlonly initiate a transfer of data @em
+ from host @em to device (an @em OUT transfer in USB terminology).
+ @n @htmlonly USBD_Write() @endhtmlonly initiate a transfer of data @em from
+ device @em to host (an @em IN transfer).
+
+ When the USB host actually performs the transfer, your application will be
+ notified by means of a callback function which you provide (optionally).
+ Refer to @ref TransferCallback for details of the callback functionality.
+
+ @ref USBD_AbortTransfer(), @ref USBD_AbortAllTransfers() @n
+ These functions terminate transfers that are initiated, but has not yet
+ taken place. If a transfer is initiated with @htmlonly USBD_Read()
+ or USBD_Write(), @endhtmlonly but the USB host never actually peform
+ the transfers, these functions will deactivate the transfer setup to make
+ the USB device endpoint hardware ready for new (and potentially) different
+ transfers.
+
+ @ref USBD_Connect(), @ref USBD_Disconnect() @n
+ These functions turns the data-line (D+ or D-) pullup on or off. They can be
+ used to force reenumeration. It's good practice to delay at least one second
+ between @htmlonly USBD_Disconnect() and USBD_Connect() @endhtmlonly
+ to allow the USB host to unload the currently active device driver.
+
+ @ref USBD_EpIsBusy() @n
+ Check if an endpoint is busy.
+
+ @ref USBD_StallEp(), @ref USBD_UnStallEp() @n
+ These functions stalls or un-stalls an endpoint. This functionality may not
+ be needed by your application, but the USB device stack use them in response
+ to standard setup commands SET_FEATURE and CLEAR_FEATURE. They may be useful
+ when implementing some USB classes, e.g. a mass storage device use them
+ extensively.
+
+ @ref USBD_RemoteWakeup() @n
+ Used in SUSPENDED state (see @ref USB_Status_TypeDef) to signal resume to
+ host. It's the applications responsibility to adhere to the USB standard
+ which states that a device can not signal resume before it has been
+ SUSPENDED for at least 5 ms. The function will also check the configuration
+ descriptor defined by the application to see if it is legal for the device
+ to signal resume.
+
+ @ref USBD_GetUsbState() @n
+ Returns the device USB state (see @ref USBD_State_TypeDef). Refer to
+ Figure 9-1. "Device State Diagram" in the USB revision 2.0 specification.
+
+ @ref USBD_GetUsbStateName() @n
+ Returns a text string naming a given USB device state.
+
+ @ref USBD_SafeToEnterEM2() @n
+ Check if it is ok to enter energy mode EM2. Refer to the
+ @ref usb_device_powersave section for more information.
+
+ @n @anchor TransferCallback <b>The transfer complete callback function:</b> @n
+ @n USB_XferCompleteCb_TypeDef() is called when a transfer completes. It is
+ called with three parameters, the status of the transfer, the number of
+ bytes transferred and the number of bytes remaining. It may not always be
+ needed to have a callback on transfer completion, but you should keep in
+ mind that a transfer may be aborted when you least expect it. A transfer
+ will be aborted if host stalls the endpoint, if host resets your device, if
+ host unconfigures your device or if you unplug your device cable and the
+ device is selfpowered.
+ @htmlonly USB_XferCompleteCb_TypeDef() @endhtmlonly is also called if your
+ application use @htmlonly USBD_AbortTransfer() or USBD_AbortAllTransfers()
+ @endhtmlonly calls.
+ @note This callback is called from within an interrupt handler with
+ interrupts disabled.
+
+ @n @anchor DeviceInitCallbacks <b>Optional callbacks passed to the stack via
+ the @ref USBD_Init() function:</b> @n
+ @n These callbacks are all optional, and it is up to the application
+ programmer to decide if the application needs the functionality they
+ provide.
+ @note These callbacks are all called from within an interrupt handler
+ with interrupts disabled.
+
+ USBD_UsbResetCb_TypeDef() is called each time reset signalling is sensed on
+ the USB wire.
+
+ @n USBD_SofIntCb_TypeDef() is called with framenumber as a parameter on
+ each SOF interrupt.
+
+ @n USBD_DeviceStateChangeCb_TypeDef() is called whenever the device state
+ change. Useful for detecting e.g. SUSPENDED state change in order to reduce
+ current consumption of buspowered devices. The USB HID keyboard example
+ project has a good example on how to use this callback.
+
+ @n USBD_IsSelfPoweredCb_TypeDef() is called by the device stack when host
+ queries the device with a standard setup GET_STATUS command to check if the
+ device is currently selfpowered or buspowered. This feature is only
+ applicable on selfpowered devices which also works when only buspower is
+ available.
+
+ @n USBD_SetupCmdCb_TypeDef() is called each time a setup command is
+ received from host. Use this callback to override or extend the default
+ handling of standard setup commands, and to implement class or vendor
+ specific setup commands. The USB HID keyboard example project has a good
+ example on how to use this callback.
+
+ @n <b>Utility functions:</b> @n
+ @n USB_PUTCHAR() Transmit a single char on the debug serial port.
+ @n @n USB_PUTS() Transmit a zero terminated string on the debug serial port.
+ @n @n USB_PRINTF() Transmit "printf" formated data on the debug serial port.
+ @n @n USB_GetErrorMsgString() Return an error message string for a given
+ error code.
+ @n @n USB_PrintErrorMsgString() Format and print a text string given an
+ error code, prepends an optional user supplied leader string.
+ @n @n USBTIMER_DelayMs() Active wait millisecond delay function. Can also be
+ used inside interrupt handlers.
+ @n @n USBTIMER_DelayUs() Active wait microsecond delay function. Can also be
+ used inside interrupt handlers.
+ @n @n USBTIMER_Init() Initialize the timer system. Called by @htmlonly
+ USBD_Init(), @endhtmlonly but your application must call it again to
+ reinitialize whenever you change the HFPERCLK frequency.
+ @n @n USBTIMER_Start() Start a timer. You can configure the USB device stack
+ to provide any number of timers. The timers have 1 ms resolution, your
+ application is notified of timeout by means of a callback.
+ @n @n USBTIMER_Stop() Stop a timer.
+
+@n @section usb_device_conf Configuring the device stack
+
+ Your application must provide a header file named @em usbconfig.h. This file
+ must contain the following \#define's:@n @n
+ @verbatim
+#define USB_DEVICE // Compile the stack for device mode.
+#define NUM_EP_USED n // Your application use 'n' endpoints in
+ // addition to endpoint 0. @endverbatim
+
+ @n @em usbconfig.h may define the following items: @n @n
+ @verbatim
+#define NUM_APP_TIMERS n // Your application needs 'n' timers
+
+#define DEBUG_USB_API // Turn on API debug diagnostics.
+
+// Some utility functions in the API needs printf. These
+// functions have "print" in their name. This macro enables
+// these functions.
+#define USB_USE_PRINTF // Enable utility print functions.
+
+// Define a function for transmitting a single char on the serial port.
+extern int RETARGET_WriteChar(char c);
+#define USER_PUTCHAR RETARGET_WriteChar
+
+#define USB_TIMER USB_TIMERn // Select which hardware timer the USB stack
+ // is allowed to use. Valid values are n=0,1,2...
+ // corresponding to TIMER0, TIMER1, ...
+ // If not specified, TIMER0 is used
+
+#define USB_VBUS_SWITCH_NOT_PRESENT // Hardware does not have a VBUS switch
+
+#define USB_CORECLK_HFRCO // Devices supporting crystal-less USB can use
+ // HFRCO as core clock, default is HFXO
+@endverbatim
+
+ @n You are strongly encouraged to start application development with DEBUG_USB_API
+ turned on. When DEBUG_USB_API is turned on and USER_PUTCHAR is defined, useful
+ debugging information will be output on the development kit serial port.
+ Compiling with the DEBUG_EFM_USER flag will also enable all asserts
+ in both @em emlib and in the USB stack. If asserts are enabled and
+ USER_PUTCHAR defined, assert texts will be output on the serial port.
+
+ You application must include @em retargetserial.c if DEBUG_USB_API is defined
+ and @em retargetio.c if USB_USE_PRINTF is defined.
+ These files reside in the @em drivers
+ directory in the software package for your development board. Refer to
+ @ref usb_device_powersave for energy-saving mode configurations.
+
+@n @section usb_device_powersave Energy-saving modes
+
+ The device stack provides two energy saving levels. The first level is to
+ set the USB peripheral in energy saving mode, the next level is to enter
+ Energy Mode 2 (EM2). These energy saving modes can be applied when the device
+ is suspended by the USB host, or when when the device is not connected to a
+ USB host.
+ In addition to this an application can use energy modes EM1 and EM2. There
+ are no restrictions on when EM1 can be entered, EM2 can only be entered
+ when the USB device is suspended or detached from host.
+
+ Energy-saving modes are selected with a \#define in @em usbconfig.h, default
+ selection is to not use any energy saving modes.@n @n
+ @verbatim
+#define USB_PWRSAVE_MODE (USB_PWRSAVE_MODE_ONSUSPEND | USB_PWRSAVE_MODE_ENTEREM2)@endverbatim
+
+ There are three flags available, the flags can be or'ed together as shown above.
+
+ <b>\#define USB_PWRSAVE_MODE_ONSUSPEND</b>@n Set USB peripheral in low power
+ mode on suspend.
+
+ <b>\#define USB_PWRSAVE_MODE_ONVBUSOFF</b>@n Set USB peripheral in low power
+ mode when not attached to a host. This mode assumes that the internal voltage
+ regulator is used and that the VREGI pin of the chip is connected to VBUS.
+ This option can not be used with bus-powered devices.
+
+ <b>\#define USB_PWRSAVE_MODE_ENTEREM2</b>@n Enter EM2 when USB peripheral is
+ in low power mode.
+
+ When the USB peripheral is set in low power mode, it must be clocked by a 32kHz
+ clock. Both LFXO and LFRCO can be used, but only LFXO guarantee USB specification
+ compliance. Selection is done with a \#define in @em usbconfig.h.@n @n
+ @verbatim
+#define USB_USBC_32kHz_CLK USB_USBC_32kHz_CLK_LFXO @endverbatim
+ Two flags are available, <b>USB_USBC_32kHz_CLK_LFXO</b> and
+ <b>USB_USBC_32kHz_CLK_LFRCO</b>. <b>USB_USBC_32kHz_CLK_LFXO</b> is selected
+ by default.
+
+ The USB HID keyboard and Mass Storage device example projects demonstrate
+ different energy-saving modes.
+
+ <b>Example 1:</b>
+ Leave all energy saving to the stack, the device enters EM2 on suspend and
+ when detached from host. @n
+ @verbatim
+In usbconfig.h:
+
+#define USB_PWRSAVE_MODE (USB_PWRSAVE_MODE_ONSUSPEND | USB_PWRSAVE_MODE_ONVBUSOFF | USB_PWRSAVE_MODE_ENTEREM2)
+ @endverbatim
+
+ @n <b>Example 2:</b>
+ Let the stack control energy saving in the USB periheral but let your
+ application control energy modes EM1 and EM2. @n
+ @verbatim
+In usbconfig.h:
+
+#define USB_PWRSAVE_MODE (USB_PWRSAVE_MODE_ONSUSPEND | USB_PWRSAVE_MODE_ONVBUSOFF)
+
+In application code:
+
+if ( USBD_SafeToEnterEM2() )
+ EMU_EnterEM2(true);
+else
+ EMU_EnterEM1(); @endverbatim
+
+@n @section usb_device_example1 Vendor unique device example application
+
+ This example represents the most simple USB device imaginable. It's purpose
+ is to turn user LED's on or off under control of vendor unique setup commands.
+ The device will rely on @em libusb device driver on the host, a host
+ application @em EFM32-LedApp.exe is bundled with the example.
+
+ The main() is really simple ! @n @n
+ @verbatim
+#include "em_usb.h"
+
+#include "descriptors.h"
+
+int main( void )
+{
+ BSP_Init(BSP_INIT_DEFAULT); // Initialize DK board register access
+ CMU_ClockSelectSet( cmuClock_HF, cmuSelect_HFXO );
+ BSP_LedsSet(0); // Turn off all LED's
+
+ ConsoleDebugInit(); // Initialize UART for debug diagnostics
+
+ USB_PUTS( "\nEFM32 USB LED Vendor Unique Device example\n" );
+
+ USBD_Init( &initstruct ); // GO !
+
+ //When using a debugger it is pratical to uncomment the following three
+ //lines to force host to re-enumerate the device.
+
+ //USBD_Disconnect();
+ //USBTIMER_DelayMs( 1000 );
+ //USBD_Connect();
+
+ for (;;) {}
+} @endverbatim
+
+ @n Configure the device stack in <em>usbconfig.h</em>: @n @n
+ @verbatim
+#define USB_DEVICE // Compile stack for device mode.
+
+// **************************************************************************
+** **
+** Specify number of endpoints used (in addition to EP0). **
+** **
+*****************************************************************************
+#define NUM_EP_USED 0 // EP0 is the only endpoint used.
+
+// **************************************************************************
+** **
+** Configure serial port debug output. **
+** **
+*****************************************************************************
+// Prototype a function for transmitting a single char on the serial port.
+extern int RETARGET_WriteChar(char c);
+#define USER_PUTCHAR RETARGET_WriteChar
+
+// Enable debug diagnostics from API functions (illegal input params etc.)
+#define DEBUG_USB_API @endverbatim
+
+ @n Define device properties and fill in USB initstruct in
+ <em>descriptors.h</em>: @n @n
+ @verbatim
+EFM32_ALIGN(4)
+static const USB_DeviceDescriptor_TypeDef deviceDesc __attribute__ ((aligned(4))) =
+{
+ .bLength = USB_DEVICE_DESCSIZE,
+ .bDescriptorType = USB_DEVICE_DESCRIPTOR,
+ .bcdUSB = 0x0200,
+ .bDeviceClass = 0xFF,
+ .bDeviceSubClass = 0,
+ .bDeviceProtocol = 0,
+ .bMaxPacketSize0 = USB_FS_CTRL_EP_MAXSIZE,
+ .idVendor = 0x10C4,
+ .idProduct = 0x0001,
+ .bcdDevice = 0x0000,
+ .iManufacturer = 1,
+ .iProduct = 2,
+ .iSerialNumber = 3,
+ .bNumConfigurations = 1
+};
+
+EFM32_ALIGN(4)
+static const uint8_t configDesc[] __attribute__ ((aligned(4)))=
+{
+ // *** Configuration descriptor ***
+ USB_CONFIG_DESCSIZE, // bLength
+ USB_CONFIG_DESCRIPTOR, // bDescriptorType
+ USB_CONFIG_DESCSIZE + // wTotalLength (LSB)
+ USB_INTERFACE_DESCSIZE,
+ (USB_CONFIG_DESCSIZE + // wTotalLength (MSB)
+ USB_INTERFACE_DESCSIZE)>>8,
+ 1, // bNumInterfaces
+ 1, // bConfigurationValue
+ 0, // iConfiguration
+ CONFIG_DESC_BM_RESERVED_D7 | // bmAttrib: Self powered
+ CONFIG_DESC_BM_SELFPOWERED,
+ CONFIG_DESC_MAXPOWER_mA( 100 ), // bMaxPower: 100 mA
+
+ // *** Interface descriptor ***
+ USB_INTERFACE_DESCSIZE, // bLength
+ USB_INTERFACE_DESCRIPTOR, // bDescriptorType
+ 0, // bInterfaceNumber
+ 0, // bAlternateSetting
+ NUM_EP_USED, // bNumEndpoints
+ 0xFF, // bInterfaceClass
+ 0, // bInterfaceSubClass
+ 0, // bInterfaceProtocol
+ 0, // iInterface
+};
+
+STATIC_CONST_STRING_DESC_LANGID( langID, 0x04, 0x09 );
+STATIC_CONST_STRING_DESC( iManufacturer, 'E','n','e','r','g','y',' ', \
+ 'M','i','c','r','o',' ','A','S' );
+STATIC_CONST_STRING_DESC( iProduct , 'V','e','n','d','o','r',' ', \
+ 'U','n','i','q','u','e',' ', \
+ 'L','E','D',' ', \
+ 'D','e','v','i','c','e' );
+STATIC_CONST_STRING_DESC( iSerialNumber, '0','0','0','0','0','0', \
+ '0','0','1','2','3','4' );
+
+static const void * const strings[] =
+{
+ &langID,
+ &iManufacturer,
+ &iProduct,
+ &iSerialNumber
+};
+
+// Endpoint buffer sizes
+// 1 = single buffer, 2 = double buffering, 3 = tripple buffering ...
+static const uint8_t bufferingMultiplier[ NUM_EP_USED + 1 ] = { 1 };
+
+static const USBD_Callbacks_TypeDef callbacks =
+{
+ .usbReset = NULL,
+ .usbStateChange = NULL,
+ .setupCmd = SetupCmd,
+ .isSelfPowered = NULL,
+ .sofInt = NULL
+};
+
+static const USBD_Init_TypeDef initstruct =
+{
+ .deviceDescriptor = &deviceDesc,
+ .configDescriptor = configDesc,
+ .stringDescriptors = strings,
+ .numberOfStrings = sizeof(strings)/sizeof(void*),
+ .callbacks = &callbacks,
+ .bufferingMultiplier = bufferingMultiplier
+}; @endverbatim
+
+ @n Now we have to implement vendor unique USB setup commands to control the
+ LED's (see callbacks variable above). Notice that the buffer variable below is
+ statically allocated because @htmlonly USBD_Write() @endhtmlonly only
+ initiates the transfer. When the host actually performs the transfer, the
+ SetupCmd() function will have returned ! @n @n
+
+ @verbatim
+#define VND_GET_LEDS 0x10
+#define VND_SET_LED 0x11
+
+static int SetupCmd( const USB_Setup_TypeDef *setup )
+{
+ int retVal;
+ uint16_t leds;
+ static uint32_t buffer;
+ uint8_t *pBuffer = (uint8_t*)&buffer;
+
+ retVal = USB_STATUS_REQ_UNHANDLED;
+
+ if ( setup->Type == USB_SETUP_TYPE_VENDOR )
+ {
+ switch ( setup->bRequest )
+ {
+ case VND_GET_LEDS:
+ // ********************
+ *pBuffer = BSP_LedsGet() & 0x1F;
+ retVal = USBD_Write( 0, pBuffer, setup->wLength, NULL );
+ break;
+
+ case VND_SET_LED:
+ // ********************
+ leds = DVK_getLEDs() & 0x1F;
+ if ( setup->wValue )
+ {
+ leds |= LED0 << setup->wIndex;
+ }
+ else
+ {
+ leds &= ~( LED0 << setup->wIndex );
+ }
+ BSP_LedsSet( leds );
+ retVal = USB_STATUS_OK;
+ break;
+ }
+ }
+
+ return retVal;
+}@endverbatim
+
+ * @}**************************************************************************/
+
+#endif /* defined( USB_DEVICE ) */
+#endif /* defined( USB_PRESENT ) && ( USB_COUNT == 1 ) */