USBD.c

Go to the documentation of this file.

/* ---------------------------------------------------------------------------- */
/*                  Atmel Microcontroller Software Support                      */
/*                       SAM Software Package License                           */
/* ---------------------------------------------------------------------------- */
/* Copyright (c) 2015, Atmel Corporation                                        */
/*                                                                              */
/* All rights reserved.                                                         */
/*                                                                              */
/* Redistribution and use in source and binary forms, with or without           */
/* modification, are permitted provided that the following condition is met:    */
/*                                                                              */
/* - Redistributions of source code must retain the above copyright notice,     */
/* this list of conditions and the disclaimer below.                            */
/*                                                                              */
/* Atmel's name may not be used to endorse or promote products derived from     */
/* this software without specific prior written permission.                     */
/*                                                                              */
/* DISCLAIMER:  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   */
/* 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.                           */
/* ---------------------------------------------------------------------------- */

/*---------------------------------------------------------------------------
 *      Headers
 *---------------------------------------------------------------------------*/

#include "USBD.h"
#include "USBD_HAL.h"

#include <USBLib_Trace.h>

/*---------------------------------------------------------------------------
 *      Definitions
 *---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------
 *      Internal variables
 *---------------------------------------------------------------------------*/

static uint8_t deviceState;
static uint8_t previousDeviceState;

uint8_t ForceFS = 0;

/*---------------------------------------------------------------------------
 *      Internal Functions
 *---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------
 *      Exported functions
 *---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------
 *      USBD: Event handlers
 *---------------------------------------------------------------------------*/

void USBD_SuspendHandler(void)
{
        /* Don't do anything if the device is already suspended */
        if (deviceState != USBD_STATE_SUSPENDED) {

                /* Switch to the Suspended state */
                previousDeviceState = deviceState;
                deviceState = USBD_STATE_SUSPENDED;

                /* Suspend HW interface */
                USBD_HAL_Suspend();

                /* Invoke the User Suspended callback (Suspend System?) */
                if (NULL != (void *)USBDCallbacks_Suspended)
                        USBDCallbacks_Suspended();
        }
}

void USBD_ResumeHandler(void)
{
        /* Don't do anything if the device was not suspended */
        if (deviceState == USBD_STATE_SUSPENDED) {
                /* Active the device */
                USBD_HAL_Activate();
                deviceState = previousDeviceState;

                if (deviceState >= USBD_STATE_DEFAULT) {
                        /* Invoke the Resume callback */
                        if (NULL != (void *)USBDCallbacks_Resumed)
                                USBDCallbacks_Resumed();
                }
        }
}

void USBD_ResetHandler()
{
        /* The device enters the Default state */
        deviceState = USBD_STATE_DEFAULT;
        /* Active the USB HW */
        USBD_HAL_Activate();
        /* Only EP0 enabled */
        USBD_HAL_ResetEPs(0xFFFFFFFF, USBD_STATUS_RESET, 0);
        USBD_ConfigureEndpoint(0);

        /* Invoke the Reset callback */
        if (NULL != (void *)USBDCallbacks_Reset)
                USBDCallbacks_Reset();
}

void USBD_RequestHandler(uint8_t bEndpoint,
                                                 const USBGenericRequest *pRequest)
{
        if (bEndpoint != 0) {
                TRACE_WARNING("EP%d request not supported, default EP only",
                                          bEndpoint);
        } else if (NULL != (void *)USBDCallbacks_RequestReceived)
                USBDCallbacks_RequestReceived(pRequest);
}

/*---------------------------------------------------------------------------
 *      USBD: Library interface
 *---------------------------------------------------------------------------*/

void USBD_ConfigureEndpoint(const USBEndpointDescriptor *pDescriptor)
{
        USBD_HAL_ConfigureEP(pDescriptor);
}

uint8_t USBD_Write(uint8_t          bEndpoint,
                                        const void       *pData,
                                        uint32_t         dLength,
                                        TransferCallback fCallback,
                                        void             *pArgument)
{
        USBD_HAL_SetTransferCallback(bEndpoint, fCallback, pArgument);
        return USBD_HAL_Write(bEndpoint, pData, dLength);
}
#if 0

uint8_t USBD_MblWrite(uint8_t       bEndpoint,
                                           void                *pMbl,
                                           uint16_t      wListSize,
                                           uint8_t       bCircList,
                                           uint16_t      wStartNdx,
                                           MblTransferCallback fCallback,
                                           void                *pArgument)
{
        Endpoint    *pEndpoint = &(endpoints[bEndpoint]);
        MblTransfer *pTransfer = (MblTransfer *) & (pEndpoint->transfer);
        uint16_t i;

        /* EP0 is not suitable for Mbl */

        if (bEndpoint == 0)

                return USBD_STATUS_INVALID_PARAMETER;

        /* Check that the endpoint is in Idle state */

        if (pEndpoint->state != UDP_ENDPOINT_IDLE)

                return USBD_STATUS_LOCKED;

        pEndpoint->state = UDP_ENDPOINT_SENDINGM;

        TRACE_DEBUG_WP("WriteM%d(0x%x,%d) ", bEndpoint, pMbl, wListSize);

        /* Start from first if not circled list */

        if (!bCircList) wStartNdx = 0;

        /* Setup the transfer descriptor */

        pTransfer->pMbl        = (USBDTransferBuffer *)pMbl;
        pTransfer->listSize    = wListSize;
        pTransfer->fCallback   = fCallback;
        pTransfer->pArgument   = pArgument;
        pTransfer->currBuffer  = wStartNdx;
        pTransfer->freedBuffer = 0;
        pTransfer->pLastLoaded = &(((USBDTransferBuffer *)pMbl)[wStartNdx]);
        pTransfer->circList    = bCircList;
        pTransfer->allUsed     = 0;

        /* Clear all buffer */

        for (i = 0; i < wListSize; i ++) {

                pTransfer->pMbl[i].transferred = 0;
                pTransfer->pMbl[i].buffered   = 0;
                pTransfer->pMbl[i].remaining   = pTransfer->pMbl[i].size;
        }

        /* Send the first packet */

        while ((UDP->UDP_CSR[bEndpoint]&UDP_CSR_TXPKTRDY) == UDP_CSR_TXPKTRDY);

        UDP_MblWriteFifo(bEndpoint);
        SET_CSR(bEndpoint, UDP_CSR_TXPKTRDY);

        /* If double buffering is enabled and there is data remaining, */

        /* prepare another packet */

        if ((CHIP_USB_ENDPOINTS_BANKS(bEndpoint) > 1)
                && (pTransfer->pMbl[pTransfer->currBuffer].remaining > 0))

                UDP_MblWriteFifo(bEndpoint);

        /* Enable interrupt on endpoint */

        UDP->UDP_IER = 1 << bEndpoint;

        return USBD_STATUS_SUCCESS;
}
#endif

uint8_t USBD_Read(uint8_t          bEndpoint,
                                  void             *pData,
                                  uint32_t         dLength,
                                  TransferCallback fCallback,
                                  void             *pArgument)
{
        USBD_HAL_SetTransferCallback(bEndpoint, fCallback, pArgument);
        return USBD_HAL_Read(bEndpoint, pData, dLength);
}
#if 0

uint8_t USBD_MblReuse(uint8_t  bEndpoint,
                                           uint8_t  *pNewBuffer,
                                           uint16_t wNewSize)
{
        Endpoint *pEndpoint = &(endpoints[bEndpoint]);
        MblTransfer *pTransfer = (MblTransfer *)&(pEndpoint->transfer);
        USBDTransferBuffer *pBi = &(pTransfer->pMbl[pTransfer->freedBuffer]);

        TRACE_DEBUG_WP("MblReuse(%d), st%x, circ%d\n\r",
                                   bEndpoint, pEndpoint->state, pTransfer->circList);

        /* Only for Multi-buffer-circle list */

        if (bEndpoint != 0
                && (pEndpoint->state == UDP_ENDPOINT_RECEIVINGM
                        || pEndpoint->state == UDP_ENDPOINT_SENDINGM)
                && pTransfer->circList) {
        } else

                return USBD_STATUS_WRONG_STATE;

        /* Check if there is freed buffer */

        if (pTransfer->freedBuffer == pTransfer->currBuffer
                && !pTransfer->allUsed)

                return USBD_STATUS_LOCKED;

        /* Update transfer information */

        if ((++ pTransfer->freedBuffer) == pTransfer->listSize)
                pTransfer->freedBuffer = 0;

        if (pNewBuffer) {
                pBi->pBuffer = pNewBuffer;
                pBi->size    = wNewSize;
        }

        pBi->buffered    = 0;
        pBi->transferred = 0;
        pBi->remaining   = pBi->size;

        /* At least one buffer is not processed */

        pTransfer->allUsed = 0;
        return USBD_STATUS_SUCCESS;
}
#endif

void USBD_Halt(uint8_t bEndpoint)
{
        USBD_HAL_Halt(bEndpoint, 1);
}

void USBD_Unhalt(uint8_t bEndpoint)
{
        USBD_HAL_Halt(bEndpoint, 0);
}

uint8_t USBD_IsHalted(uint8_t bEndpoint)
{
        return USBD_HAL_Halt(bEndpoint, 0xFF);
}

uint8_t USBD_IsHighSpeed(void)
{
        return USBD_HAL_IsHighSpeed();
}

uint8_t USBD_Stall(uint8_t bEndpoint)

{
        return USBD_HAL_Stall(bEndpoint);
}

void USBD_SetAddress(uint8_t address)
{
        TRACE_INFO_WP("SetAddr(%d) ", address);

        USBD_HAL_SetAddress(address);

        if (address == 0)
                deviceState = USBD_STATE_DEFAULT;
        else
                deviceState = USBD_STATE_ADDRESS;
}

void USBD_SetConfiguration(uint8_t cfgnum)
{
        TRACE_INFO_WP("SetCfg(%d) ", cfgnum);

        USBD_HAL_SetConfiguration(cfgnum);

        if (cfgnum != 0)
                deviceState = USBD_STATE_CONFIGURED;
        else {
                deviceState = USBD_STATE_ADDRESS;
                /* Reset all endpoints but Control 0 */
                USBD_HAL_ResetEPs(0xFFFFFFFE, USBD_STATUS_RESET, 0);
        }
}

/*---------------------------------------------------------------------------
 *      USBD: Library API
 *---------------------------------------------------------------------------*/

void USBD_RemoteWakeUp(void)
{
        /* Device is NOT suspended */
        if (deviceState != USBD_STATE_SUSPENDED) {
                TRACE_INFO("USBD_RemoteWakeUp: Device is not suspended\n\r");
                return;
        }

        USBD_HAL_Activate();
        USBD_HAL_RemoteWakeUp();
}

void USBD_Connect(void)
{
        TRACE_INFO(" Connect -");
        USBD_HAL_Connect();
}

void USBD_Disconnect(void)
{
        TRACE_INFO(" DisConnect -");
        USBD_HAL_Disconnect();

        /* Device returns to the Powered state */

        if (deviceState > USBD_STATE_POWERED)

                deviceState = USBD_STATE_POWERED;

        if (previousDeviceState > USBD_STATE_POWERED)

                previousDeviceState = USBD_STATE_POWERED;
}

void USBD_Init(void)
{
        TRACE_INFO_WP("USBD_Init\n\r");

        /* HW Layer Initialize */
        USBD_HAL_Init();

        /* Device is in the Attached state */
        deviceState = USBD_STATE_SUSPENDED;
        previousDeviceState = USBD_STATE_POWERED;

        /* Upper Layer Initialize */
        if (NULL != (void *)USBDCallbacks_Initialized)
                USBDCallbacks_Initialized();
}

uint8_t USBD_GetState(void)
{
        return deviceState;
}

void USBD_Test(uint8_t bIndex)
{
        USBD_HAL_Test(bIndex);
}


void USBD_ForceFullSpeed(void)
{
        ForceFS = 1;
}