CDCDSerialPort.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 <CDCDSerialPort.h>
#include <CDCDescriptors.h>
#include <USBLib_Trace.h>
#include <board.h>
#include "../../libchip/include/usbhs.h"
/*------------------------------------------------------------------------------
 *         Types
 *------------------------------------------------------------------------------*/

typedef struct _CDCDParseData {
        CDCDSerialPort *pCdcd;
        USBInterfaceDescriptor *pIfDesc;

} CDCDParseData;

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

static CDCLineCoding lineCoding;
/*------------------------------------------------------------------------------
 *         Internal functions
 *------------------------------------------------------------------------------*/

static uint32_t _Interfaces_Parse(USBGenericDescriptor *pDesc,
                                                                  CDCDParseData *pArg)
{
        CDCDSerialPort *pCdcd = pArg->pCdcd;

        /* Not a valid descriptor */
        if (pDesc->bLength == 0)
                return USBRC_PARAM_ERR;

        /* Find interface descriptor */
        if (pDesc->bDescriptorType == USBGenericDescriptor_INTERFACE) {
                USBInterfaceDescriptor *pIf = (USBInterfaceDescriptor *)pDesc;

                /* Obtain interface from descriptor */
                if (pCdcd->bInterfaceNdx == 0xFF) {
                        /* First interface is communication */
                        if (pIf->bInterfaceClass ==
                                CDCCommunicationInterfaceDescriptor_CLASS) {
                                pCdcd->bInterfaceNdx = pIf->bInterfaceNumber;
                                pCdcd->bNumInterface = 2;
                        }
                        /* Only data interface */
                        else if (pIf->bInterfaceClass == CDCDataInterfaceDescriptor_CLASS) {
                                pCdcd->bInterfaceNdx = pIf->bInterfaceNumber;
                                pCdcd->bNumInterface = 1;
                        }

                        pArg->pIfDesc = pIf;
                } else if (pCdcd->bInterfaceNdx <= pIf->bInterfaceNumber
                                && pCdcd->bInterfaceNdx + pCdcd->bNumInterface
                                        > pIf->bInterfaceNumber)
                        pArg->pIfDesc = pIf;
        }

        /* Parse valid interfaces */
        if (pArg->pIfDesc == 0)
                return 0;

        /* Find endpoint descriptors */
        if (pDesc->bDescriptorType == USBGenericDescriptor_ENDPOINT) {
                USBEndpointDescriptor *pEp = (USBEndpointDescriptor *)pDesc;

                switch (pEp->bmAttributes & 0x3) {
                case USBEndpointDescriptor_INTERRUPT:
                        if (pEp->bEndpointAddress & 0x80)
                                pCdcd->bIntInPIPE = pEp->bEndpointAddress & 0x7F;

                        break;

                case USBEndpointDescriptor_BULK:
                        if (pEp->bEndpointAddress & 0x80)
                                pCdcd->bBulkInPIPE = pEp->bEndpointAddress & 0x7F;
                        else
                                pCdcd->bBulkOutPIPE = pEp->bEndpointAddress;
                }
        }

        if (pCdcd->bInterfaceNdx != 0xFF
                        && pCdcd->bBulkInPIPE != 0
                        && pCdcd->bBulkOutPIPE != 0)
                return USBRC_FINISHED;

        return 0;
}

static void _SetLineCodingCallback(CDCDSerialPort *pCdcd)
{
        uint32_t exec = 1;

        if (pCdcd->fEventHandler) {
                uint32_t rc = pCdcd->fEventHandler(
                                                  CDCDSerialPortEvent_SETLINECODING,
                                                  (uint32_t)(&lineCoding),
                                                  pCdcd->pEventArg);

                if (rc == USBD_STATUS_SUCCESS) {
                        pCdcd->lineCoding.dwDTERate   = lineCoding.dwDTERate;
                        pCdcd->lineCoding.bCharFormat = lineCoding.bCharFormat;
                        pCdcd->lineCoding.bParityType = lineCoding.bParityType;
                        pCdcd->lineCoding.bDataBits   = lineCoding.bDataBits;
                } else
                        exec = 0;
        }

        if (exec)
                USBD_Write(0, 0, 0, 0, 0);
        else
                USBD_Stall(0);
}

static void _SetLineCoding(CDCDSerialPort *pCdcd)
{
        TRACE_INFO_WP("sLineCoding ");

        USBD_Read(0,
                          (void *) & (lineCoding),
                          sizeof(CDCLineCoding),
                          (TransferCallback)_SetLineCodingCallback,
                          (void *)pCdcd);
}

static void _GetLineCoding(CDCDSerialPort *pCdcd)
{
        TRACE_INFO_WP("gLineCoding ");

        USBD_Write(0,
                        (void *)&(pCdcd->lineCoding),
                        sizeof(CDCLineCoding),
                        0,
                        0);
}

static void _SetControlLineState(
        CDCDSerialPort *pCdcd,
        const USBGenericRequest *request)
{
#if (TRACE_LEVEL >= TRACE_LEVEL_INFO)
        uint8_t DTR, RTS;

        DTR = ((request->wValue & CDCControlLineState_DTR) > 0);
        RTS = ((request->wValue & CDCControlLineState_RTS) > 0);
        TRACE_INFO_WP("sControlLineState(%d, %d) ", DTR, RTS);
#endif

        pCdcd->bControlLineState = (uint8_t)request->wValue;
        USBD_Write(0, 0, 0, 0, 0);

        if (pCdcd->fEventHandler)
                pCdcd->fEventHandler(CDCDSerialPortEvent_SETCONTROLLINESTATE,
                                                         (uint32_t)pCdcd->bControlLineState,
                                                         pCdcd->pEventArg);
}

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

void CDCDSerialPort_Initialize(CDCDSerialPort *pCdcd,
                                USBDDriver *pUsbd,
                                CDCDSerialPortEventHandler fEventHandler,
                                void *pArg,
                                uint8_t firstInterface, uint8_t numInterface)
{
        TRACE_INFO("CDCDSerialPort_Initialize\n\r");

        /* Initialize event handler */
        pCdcd->fEventHandler = fEventHandler;
        pCdcd->pEventArg = pArg;

        /* Initialize transfer callback */
        pCdcd->fTransCLK = 0;
        pCdcd->pTansArg = 0;

        /* Initialize USB Device Driver interface */
        pCdcd->pUsbd = pUsbd;
        pCdcd->bInterfaceNdx = firstInterface;
        pCdcd->bNumInterface = numInterface;
        pCdcd->bIntInPIPE = 0;
        pCdcd->bBulkInPIPE  = 0;
        pCdcd->bBulkOutPIPE = 0;

        /* Initialize Abstract Control Model attributes */
        pCdcd->bControlLineState = 0;
        pCdcd->wSerialState = 0;
        CDCLineCoding_Initialize(&(pCdcd->lineCoding),
                                                         115200,
                                                         CDCLineCoding_ONESTOPBIT,
                                                         CDCLineCoding_NOPARITY,
                                                         8);
}

USBGenericDescriptor *CDCDSerialPort_ParseInterfaces(
        CDCDSerialPort *pCdcd,
        USBGenericDescriptor *pDescriptors,
        uint32_t dwLength)
{
        CDCDParseData parseData;

        parseData.pCdcd   = pCdcd;
        parseData.pIfDesc = 0;

        return USBGenericDescriptor_Parse(
                        pDescriptors, dwLength,
                        (USBDescriptorParseFunction)_Interfaces_Parse,
                        &parseData);
}


uint32_t CDCDSerialPort_RequestHandler(
        CDCDSerialPort *pCdcd,
        const USBGenericRequest *request)
{
        if (USBGenericRequest_GetType(request) != USBGenericRequest_CLASS)
                return USBRC_PARAM_ERR;

        TRACE_INFO_WP("Cdcs ");

        /* Validate interface */
        if (request->wIndex >= pCdcd->bInterfaceNdx &&
                request->wIndex < pCdcd->bInterfaceNdx + pCdcd->bNumInterface) {
        } else
                return USBRC_PARAM_ERR;

        /* Handle the request */
        switch (USBGenericRequest_GetRequest(request)) {

        case CDCGenericRequest_SETLINECODING:

                _SetLineCoding(pCdcd);
                break;

        case CDCGenericRequest_GETLINECODING:

                _GetLineCoding(pCdcd);
                break;

        case CDCGenericRequest_SETCONTROLLINESTATE:

                _SetControlLineState(pCdcd, request);
                break;

        default:

                return USBRC_PARAM_ERR;
        }

        return USBRC_SUCCESS;
}

uint32_t CDCDSerialPort_Read(const CDCDSerialPort *pCdcd,
                                                         void *pData, uint32_t dwSize,
                                                         TransferCallback fCallback, void *pArg)
{
        if (pCdcd->bBulkOutPIPE == 0)
                return USBRC_PARAM_ERR;

        return USBD_Read(pCdcd->bBulkOutPIPE,
                                         pData, dwSize,
                                         fCallback, pArg);
}


static void _UsbDataSent_ZLP(CDCDSerialPort *pCdcd)
{
        USBD_Write(pCdcd->bBulkInPIPE, 0, 0, pCdcd->fTransCLK, pCdcd->pTansArg);
}

uint32_t CDCDSerialPort_Write(CDCDSerialPort *pCdcd,
                                                          void *pData, uint32_t dwSize,
                                                          TransferCallback fCallback, void *pArg)
{
        uint32_t result;
        Usbhs *pUdp = USBHS;
        uint32_t endpointSize;

        if (pCdcd->bBulkInPIPE == 0)
                return USBRC_PARAM_ERR;

        endpointSize = USBHS_GetEpSize(pUdp, pCdcd->bBulkInPIPE);

        if (dwSize % endpointSize == 0) {
                pCdcd->fTransCLK = fCallback;
                pCdcd->pTansArg  = pArg;
                result = USBD_Write(pCdcd->bBulkInPIPE,
                                                        pData, dwSize,
                                                        (TransferCallback)_UsbDataSent_ZLP, (void *)pCdcd);
        } else {
                result = USBD_Write(pCdcd->bBulkInPIPE,
                                                        pData, dwSize,
                                                        fCallback, pArg);

        }

        return result;
}

uint8_t CDCDSerialPort_GetControlLineState(const CDCDSerialPort *pCdcd)
{
        return pCdcd->bControlLineState;
}

void CDCDSerialPort_GetLineCoding(const CDCDSerialPort *pCdcd,
                                                                  CDCLineCoding *pLineCoding)
{
        if (pLineCoding) {
                pLineCoding->dwDTERate   = pCdcd->lineCoding.dwDTERate;
                pLineCoding->bCharFormat = pCdcd->lineCoding.bCharFormat;
                pLineCoding->bParityType = pCdcd->lineCoding.bParityType;
                pLineCoding->bDataBits   = pCdcd->lineCoding.bDataBits;
        }
}

uint16_t CDCDSerialPort_GetSerialState(const CDCDSerialPort *pCdcd)
{
        return pCdcd->wSerialState;
}

void CDCDSerialPort_SetSerialState(CDCDSerialPort *pCdcd,
                                                                   uint16_t wSerialState)
{
        if (pCdcd->bIntInPIPE == 0)
                return;

        /* If new state is different from previous one, send a notification to the
           host */
        if (pCdcd->wSerialState != wSerialState) {

                pCdcd->wSerialState = wSerialState;
                USBD_Write(pCdcd->bIntInPIPE,
                                &(pCdcd->wSerialState),
                                2,
                                0,
                                0);

                /* Reset one-time flags */
                pCdcd->wSerialState &= ~(CDCSerialState_OVERRUN
                                                | CDCSerialState_PARITY
                                                | CDCSerialState_FRAMING
                                                | CDCSerialState_RINGSIGNAL
                                                | CDCSerialState_BREAK);
        }
}