sergiotarxz/nuttx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
2cfa023039
nuttx/drivers/usbdev/cdcacm.c
Gregory Nutt 0fb035f76b Standardize some naming in code section comments
2016-02-21 18:09:04 -06:00

2515 lines
72 KiB
C
Raw Blame History

/****************************************************************************
* drivers/usbdev/cdcacm.c
*
* Copyright (C) 2011-2013, 2016 Gregory Nutt. All rights reserved.
* Author: Gregory Nutt <gnutt@nuttx.org>
*
* 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. Neither the name NuttX nor the names of its contributors may be
* used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#include <sys/types.h>
#include <stdint.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <semaphore.h>
#include <string.h>
#include <errno.h>
#include <queue.h>
#include <debug.h>
#include <nuttx/irq.h>
#include <nuttx/kmalloc.h>
#include <nuttx/arch.h>
#include <nuttx/serial/serial.h>
#include <nuttx/usb/usb.h>
#include <nuttx/usb/cdc.h>
#include <nuttx/usb/usbdev.h>
#include <nuttx/usb/cdcacm.h>
#include <nuttx/usb/usbdev_trace.h>
#include "cdcacm.h"
#ifdef CONFIG_USBMSC_COMPOSITE
# include <nuttx/usb/composite.h>
# include "composite.h"
#endif
/****************************************************************************
* Private Types
****************************************************************************/
/* Container to support a list of requests */
struct cdcacm_req_s
{
FAR struct cdcacm_req_s *flink; /* Implements a singly linked list */
FAR struct usbdev_req_s *req; /* The contained request */
};
/* This structure describes the internal state of the driver */
struct cdcacm_dev_s
{
FAR struct uart_dev_s serdev; /* Serial device structure */
FAR struct usbdev_s *usbdev; /* usbdev driver pointer */
uint8_t config; /* Configuration number */
uint8_t nwrq; /* Number of queue write requests (in reqlist) */
uint8_t nrdq; /* Number of queue read requests (in epbulkout) */
uint8_t minor; /* The device minor number */
bool rxenabled; /* true: UART RX "interrupts" enabled */
int16_t rxhead; /* Working head; used when rx int disabled */
uint8_t ctrlline; /* Buffered control line state */
struct cdc_linecoding_s linecoding; /* Buffered line status */
cdcacm_callback_t callback; /* Serial event callback function */
FAR struct usbdev_ep_s *epintin; /* Interrupt IN endpoint structure */
FAR struct usbdev_ep_s *epbulkin; /* Bulk IN endpoint structure */
FAR struct usbdev_ep_s *epbulkout; /* Bulk OUT endpoint structure */
FAR struct usbdev_req_s *ctrlreq; /* Allocated control request */
struct sq_queue_s reqlist; /* List of write request containers */
/* Pre-allocated write request containers. The write requests will
* be linked in a free list (reqlist), and used to send requests to
* EPBULKIN; Read requests will be queued in the EBULKOUT.
*/
struct cdcacm_req_s wrreqs[CONFIG_CDCACM_NWRREQS];
struct cdcacm_req_s rdreqs[CONFIG_CDCACM_NWRREQS];
/* Serial I/O buffers */
char rxbuffer[CONFIG_CDCACM_RXBUFSIZE];
char txbuffer[CONFIG_CDCACM_TXBUFSIZE];
};
/* The internal version of the class driver */
struct cdcacm_driver_s
{
struct usbdevclass_driver_s drvr;
FAR struct cdcacm_dev_s *dev;
};
/* This is what is allocated */
struct cdcacm_alloc_s
{
struct cdcacm_dev_s dev;
struct cdcacm_driver_s drvr;
};
/****************************************************************************
* Private Function Prototypes
****************************************************************************/
/* Transfer helpers *********************************************************/
static uint16_t cdcacm_fillrequest(FAR struct cdcacm_dev_s *priv,
uint8_t *reqbuf, uint16_t reqlen);
static int cdcacm_sndpacket(FAR struct cdcacm_dev_s *priv);
static inline int cdcacm_recvpacket(FAR struct cdcacm_dev_s *priv,
uint8_t *reqbuf, uint16_t reqlen);
/* Request helpers *********************************************************/
static struct usbdev_req_s *cdcacm_allocreq(FAR struct usbdev_ep_s *ep,
uint16_t len);
static void cdcacm_freereq(FAR struct usbdev_ep_s *ep,
FAR struct usbdev_req_s *req);
/* Configuration ***********************************************************/
static void cdcacm_resetconfig(FAR struct cdcacm_dev_s *priv);
#ifdef CONFIG_USBDEV_DUALSPEED
static int cdcacm_epconfigure(FAR struct usbdev_ep_s *ep,
enum cdcacm_epdesc_e epid, uint16_t mxpacket, bool last);
#endif
static int cdcacm_setconfig(FAR struct cdcacm_dev_s *priv,
uint8_t config);
/* Completion event handlers ***********************************************/
static void cdcacm_ep0incomplete(FAR struct usbdev_ep_s *ep,
FAR struct usbdev_req_s *req);
static void cdcacm_rdcomplete(FAR struct usbdev_ep_s *ep,
FAR struct usbdev_req_s *req);
static void cdcacm_wrcomplete(FAR struct usbdev_ep_s *ep,
FAR struct usbdev_req_s *req);
/* USB class device ********************************************************/
static int cdcacm_bind(FAR struct usbdevclass_driver_s *driver,
FAR struct usbdev_s *dev);
static void cdcacm_unbind(FAR struct usbdevclass_driver_s *driver,
FAR struct usbdev_s *dev);
static int cdcacm_setup(FAR struct usbdevclass_driver_s *driver,
FAR struct usbdev_s *dev,
FAR const struct usb_ctrlreq_s *ctrl, FAR uint8_t *dataout,
size_t outlen);
static void cdcacm_disconnect(FAR struct usbdevclass_driver_s *driver,
FAR struct usbdev_s *dev);
#ifdef CONFIG_SERIAL_REMOVABLE
static void cdcacm_suspend(FAR struct usbdevclass_driver_s *driver,
FAR struct usbdev_s *dev);
static void cdcacm_resume(FAR struct usbdevclass_driver_s *driver,
FAR struct usbdev_s *dev);
#endif
/* UART Operations **********************************************************/
static int cdcuart_setup(FAR struct uart_dev_s *dev);
static void cdcuart_shutdown(FAR struct uart_dev_s *dev);
static int cdcuart_attach(FAR struct uart_dev_s *dev);
static void cdcuart_detach(FAR struct uart_dev_s *dev);
static int cdcuart_ioctl(FAR struct file *filep, int cmd,
unsigned long arg);
static void cdcuart_rxint(FAR struct uart_dev_s *dev, bool enable);
#ifdef CONFIG_SERIAL_IFLOWCONTROL
static bool cdcuart_rxflowcontrol(FAR struct uart_dev_s *dev,
unsigned int nbuffered, bool upper);
#endif
static void cdcuart_txint(FAR struct uart_dev_s *dev, bool enable);
static bool cdcuart_txempty(FAR struct uart_dev_s *dev);
/****************************************************************************
* Private Data
****************************************************************************/
/* USB class device *********************************************************/
static const struct usbdevclass_driverops_s g_driverops =
{
cdcacm_bind, /* bind */
cdcacm_unbind, /* unbind */
cdcacm_setup, /* setup */
cdcacm_disconnect, /* disconnect */
#ifdef CONFIG_SERIAL_REMOVABLE
cdcacm_suspend, /* suspend */
cdcacm_resume, /* resume */
#else
NULL, /* suspend */
NULL, /* resume */
#endif
};
/* Serial port **************************************************************/
static const struct uart_ops_s g_uartops =
{
cdcuart_setup, /* setup */
cdcuart_shutdown, /* shutdown */
cdcuart_attach, /* attach */
cdcuart_detach, /* detach */
cdcuart_ioctl, /* ioctl */
NULL, /* receive */
cdcuart_rxint, /* rxinit */
NULL, /* rxavailable */
#ifdef CONFIG_SERIAL_IFLOWCONTROL
cdcuart_rxflowcontrol, /* rxflowcontrol */
#endif
NULL, /* send */
cdcuart_txint, /* txinit */
NULL, /* txready */
cdcuart_txempty /* txempty */
};
/****************************************************************************
* Private Functions
****************************************************************************/
/****************************************************************************
* Name: cdcacm_fillrequest
*
* Description:
* If there is data to send it is copied to the given buffer. Called
* either to initiate the first write operation, or from the completion
* interrupt handler service consecutive write operations.
*
* NOTE: The USB serial driver does not use the serial drivers
* uart_xmitchars() API. That logic is essentially duplicated here because
* unlike UART hardware, we need to be able to handle writes not byte-by-byte,
* but packet-by-packet. Unfortunately, that decision also exposes some
* internals of the serial driver in the following.
*
****************************************************************************/
static uint16_t cdcacm_fillrequest(FAR struct cdcacm_dev_s *priv, uint8_t *reqbuf,
uint16_t reqlen)
{
FAR uart_dev_t *serdev = &priv->serdev;
FAR struct uart_buffer_s *xmit = &serdev->xmit;
irqstate_t flags;
uint16_t nbytes = 0;
/* Disable interrupts */
flags = enter_critical_section();
/* Transfer bytes while we have bytes available and there is room in the request */
while (xmit->head != xmit->tail && nbytes < reqlen)
{
*reqbuf++ = xmit->buffer[xmit->tail];
nbytes++;
/* Increment the tail pointer */
if (++(xmit->tail) >= xmit->size)
{
xmit->tail = 0;
}
}
/* When all of the characters have been sent from the buffer
* disable the "TX interrupt".
*/
if (xmit->head == xmit->tail)
{
uart_disabletxint(serdev);
}
/* If any bytes were removed from the buffer, inform any waiters
* there there is space available.
*/
if (nbytes)
{
uart_datasent(serdev);
}
leave_critical_section(flags);
return nbytes;
}
/****************************************************************************
* Name: cdcacm_sndpacket
*
* Description:
* This function obtains write requests, transfers the TX data into the
* request, and submits the requests to the USB controller. This continues
* until either (1) there are no further packets available, or (2) there is
* no further data to send.
*
****************************************************************************/
static int cdcacm_sndpacket(FAR struct cdcacm_dev_s *priv)
{
FAR struct usbdev_ep_s *ep;
FAR struct usbdev_req_s *req;
FAR struct cdcacm_req_s *reqcontainer;
uint16_t reqlen;
irqstate_t flags;
int len;
int ret = OK;
#ifdef CONFIG_DEBUG
if (priv == NULL)
{
usbtrace(TRACE_CLSERROR(USBSER_TRACEERR_INVALIDARG), 0);
return -ENODEV;
}
#endif
flags = enter_critical_section();
/* Use our IN endpoint for the transfer */
ep = priv->epbulkin;
/* Loop until either (1) we run out or write requests, or (2) cdcacm_fillrequest()
* is unable to fill the request with data (i.e., until there is no more data
* to be sent).
*/
uvdbg("head=%d tail=%d nwrq=%d empty=%d\n",
priv->serdev.xmit.head, priv->serdev.xmit.tail,
priv->nwrq, sq_empty(&priv->reqlist));
/* Get the maximum number of bytes that will fit into one bulk IN request */
reqlen = MAX(CONFIG_CDCACM_BULKIN_REQLEN, ep->maxpacket);
while (!sq_empty(&priv->reqlist))
{
/* Peek at the request in the container at the head of the list */
reqcontainer = (FAR struct cdcacm_req_s *)sq_peek(&priv->reqlist);
req = reqcontainer->req;
/* Fill the request with serial TX data */
len = cdcacm_fillrequest(priv, req->buf, reqlen);
if (len > 0)
{
/* Remove the empty container from the request list */
(void)sq_remfirst(&priv->reqlist);
priv->nwrq--;
/* Then submit the request to the endpoint */
req->len = len;
req->priv = reqcontainer;
req->flags = USBDEV_REQFLAGS_NULLPKT;
ret = EP_SUBMIT(ep, req);
if (ret != OK)
{
usbtrace(TRACE_CLSERROR(USBSER_TRACEERR_SUBMITFAIL), (uint16_t)-ret);
break;
}
}
else
{
break;
}
}
leave_critical_section(flags);
return ret;
}
/****************************************************************************
* Name: cdcacm_recvpacket
*
* Description:
* A normal completion event was received by the read completion handler
* at the interrupt level (with interrupts disabled). This function handles
* the USB packet and provides the received data to the uart RX buffer.
*
* Assumptions:
* Called from the USB interrupt handler with interrupts disabled.
*
****************************************************************************/
static inline int cdcacm_recvpacket(FAR struct cdcacm_dev_s *priv,
uint8_t *reqbuf, uint16_t reqlen)
{
FAR uart_dev_t *serdev = &priv->serdev;
FAR struct uart_buffer_s *recv = &serdev->recv;
uint16_t currhead;
uint16_t nexthead;
uint16_t nbytes = 0;
uvdbg("head=%d tail=%d nrdq=%d reqlen=%d\n",
priv->serdev.recv.head, priv->serdev.recv.tail, priv->nrdq, reqlen);
/* Get the next head index. During the time that RX interrupts are disabled, the
* the serial driver will be extracting data from the circular buffer and modifying
* recv.tail. During this time, we should avoid modifying recv.head; Instead we will
* use a shadow copy of the index. When interrupts are restored, the real recv.head
* will be updated with this index.
*/
if (priv->rxenabled)
{
currhead = recv->head;
}
else
{
currhead = priv->rxhead;
}
/* Pre-calculate the head index and check for wrap around. We need to do this
* so that we can determine if the circular buffer will overrun BEFORE we
* overrun the buffer!
*/
nexthead = currhead + 1;
if (nexthead >= recv->size)
{
nexthead = 0;
}
/* Then copy data into the RX buffer until either: (1) all of the data has been
* copied, or (2) the RX buffer is full.
*
* NOTE: If the RX buffer becomes full, then we have overrun the serial driver
* and data will be lost. This is the correct behavior for a proper emulation
* of a serial link. It should not NAK, it should drop data like a physical
* serial port.
*
* If you don't like that behavior. DO NOT change it here. Instead, you should
* finish the implementation of RX flow control which is the only proper way
* to throttle a serial device.
*/
while (nexthead != recv->tail && nbytes < reqlen)
{
/* Copy one byte to the head of the circular RX buffer */
recv->buffer[currhead] = *reqbuf++;
/* Update counts and indices */
currhead = nexthead;
nbytes++;
/* Increment the head index and check for wrap around */
nexthead = currhead + 1;
if (nexthead >= recv->size)
{
nexthead = 0;
}
}
/* Write back the head pointer using the shadow index if RX "interrupts"
* are disabled.
*/
if (priv->rxenabled)
{
recv->head = currhead;
}
else
{
priv->rxhead = currhead;
}
/* If data was added to the incoming serial buffer, then wake up any
* threads is waiting for incoming data. If we are running in an interrupt
* handler, then the serial driver will not run until the interrupt handler
* returns.
*/
if (priv->rxenabled && nbytes > 0)
{
uart_datareceived(serdev);
}
/* Return an error if the entire packet could not be transferred */
if (nbytes < reqlen)
{
usbtrace(TRACE_CLSERROR(USBSER_TRACEERR_RXOVERRUN), 0);
return -ENOSPC;
}
return OK;
}
/****************************************************************************
* Name: cdcacm_allocreq
*
* Description:
* Allocate a request instance along with its buffer
*
****************************************************************************/
static struct usbdev_req_s *cdcacm_allocreq(FAR struct usbdev_ep_s *ep,
uint16_t len)
{
FAR struct usbdev_req_s *req;
req = EP_ALLOCREQ(ep);
if (req != NULL)
{
req->len = len;
req->buf = EP_ALLOCBUFFER(ep, len);
if (!req->buf)
{
EP_FREEREQ(ep, req);
req = NULL;
}
}
return req;
}
/****************************************************************************
* Name: cdcacm_freereq
*
* Description:
* Free a request instance along with its buffer
*
****************************************************************************/
static void cdcacm_freereq(FAR struct usbdev_ep_s *ep,
FAR struct usbdev_req_s *req)
{
if (ep != NULL && req != NULL)
{
if (req->buf != NULL)
{
EP_FREEBUFFER(ep, req->buf);
}
EP_FREEREQ(ep, req);
}
}
/****************************************************************************
* Name: cdcacm_resetconfig
*
* Description:
* Mark the device as not configured and disable all endpoints.
*
****************************************************************************/
static void cdcacm_resetconfig(FAR struct cdcacm_dev_s *priv)
{
/* Are we configured? */
if (priv->config != CDCACM_CONFIGIDNONE)
{
/* Yes.. but not anymore */
priv->config = CDCACM_CONFIGIDNONE;
/* Inform the "upper half" driver that there is no (functional) USB
* connection.
*/
#ifdef CONFIG_SERIAL_REMOVABLE
uart_connected(&priv->serdev, false);
#endif
/* Disable endpoints. This should force completion of all pending
* transfers.
*/
EP_DISABLE(priv->epintin);
EP_DISABLE(priv->epbulkin);
EP_DISABLE(priv->epbulkout);
}
}
/****************************************************************************
* Name: cdcacm_epconfigure
*
* Description:
* Configure one endpoint.
*
****************************************************************************/
#ifdef CONFIG_USBDEV_DUALSPEED
static int cdcacm_epconfigure(FAR struct usbdev_ep_s *ep,
enum cdcacm_epdesc_e epid, uint16_t mxpacket,
bool last)
{
struct usb_epdesc_s epdesc;
cdcacm_mkepdesc(epid, mxpacket, &epdesc);
return EP_CONFIGURE(ep, &epdesc, last);
}
#endif
/****************************************************************************
* Name: cdcacm_setconfig
*
* Description:
* Set the device configuration by allocating and configuring endpoints and
* by allocating and queue read and write requests.
*
****************************************************************************/
static int cdcacm_setconfig(FAR struct cdcacm_dev_s *priv, uint8_t config)
{
FAR struct usbdev_req_s *req;
int i;
int ret = 0;
#ifdef CONFIG_DEBUG
if (priv == NULL)
{
usbtrace(TRACE_CLSERROR(USBSER_TRACEERR_INVALIDARG), 0);
return -EIO;
}
#endif
if (config == priv->config)
{
/* Already configured -- Do nothing */
usbtrace(TRACE_CLSERROR(USBSER_TRACEERR_ALREADYCONFIGURED), 0);
return 0;
}
/* Discard the previous configuration data */
cdcacm_resetconfig(priv);
/* Was this a request to simply discard the current configuration? */
if (config == CDCACM_CONFIGIDNONE)
{
usbtrace(TRACE_CLSERROR(USBSER_TRACEERR_CONFIGNONE), 0);
return 0;
}
/* We only accept one configuration */
if (config != CDCACM_CONFIGID)
{
usbtrace(TRACE_CLSERROR(USBSER_TRACEERR_CONFIGIDBAD), 0);
return -EINVAL;
}
/* Configure the IN interrupt endpoint */
#ifdef CONFIG_USBDEV_DUALSPEED
if (priv->usbdev->speed == USB_SPEED_HIGH)
{
ret = cdcacm_epconfigure(priv->epintin, CDCACM_EPINTIN,
CONFIG_CDCACM_EPINTIN_HSSIZE, false);
}
else
#endif
{
ret = EP_CONFIGURE(priv->epintin,
cdcacm_getepdesc(CDCACM_EPINTIN), false);
}
if (ret < 0)
{
usbtrace(TRACE_CLSERROR(USBSER_TRACEERR_EPINTINCONFIGFAIL), 0);
goto errout;
}
priv->epintin->priv = priv;
/* Configure the IN bulk endpoint */
#ifdef CONFIG_USBDEV_DUALSPEED
if (priv->usbdev->speed == USB_SPEED_HIGH)
{
ret = cdcacm_epconfigure(priv->epbulkin, CDCACM_EPBULKIN,
CONFIG_CDCACM_EPBULKIN_HSSIZE, false);
}
else
#endif
{
ret = EP_CONFIGURE(priv->epbulkin,
cdcacm_getepdesc(CDCACM_EPBULKIN), false);
}
if (ret < 0)
{
usbtrace(TRACE_CLSERROR(USBSER_TRACEERR_EPBULKINCONFIGFAIL), 0);
goto errout;
}
priv->epbulkin->priv = priv;
/* Configure the OUT bulk endpoint */
#ifdef CONFIG_USBDEV_DUALSPEED
if (priv->usbdev->speed == USB_SPEED_HIGH)
{
ret = cdcacm_epconfigure(priv->epbulkout, CDCACM_EPBULKOUT,
CONFIG_CDCACM_EPBULKOUT_HSSIZE, true);
}
else
#endif
{
ret = EP_CONFIGURE(priv->epbulkout,
cdcacm_getepdesc(CDCACM_EPBULKOUT), true);
}
if (ret < 0)
{
usbtrace(TRACE_CLSERROR(USBSER_TRACEERR_EPBULKOUTCONFIGFAIL), 0);
goto errout;
}
priv->epbulkout->priv = priv;
/* Queue read requests in the bulk OUT endpoint */
DEBUGASSERT(priv->nrdq == 0);
for (i = 0; i < CONFIG_CDCACM_NRDREQS; i++)
{
req = priv->rdreqs[i].req;
req->callback = cdcacm_rdcomplete;
ret = EP_SUBMIT(priv->epbulkout, req);
if (ret != OK)
{
usbtrace(TRACE_CLSERROR(USBSER_TRACEERR_RDSUBMIT), (uint16_t)-ret);
goto errout;
}
priv->nrdq++;
}
/* We are successfully configured */
priv->config = config;
/* Inform the "upper half" driver that we are "open for business" */
#ifdef CONFIG_SERIAL_REMOVABLE
uart_connected(&priv->serdev, true);
#endif
return OK;
errout:
cdcacm_resetconfig(priv);
return ret;
}
/****************************************************************************
* Name: cdcacm_ep0incomplete
*
* Description:
* Handle completion of EP0 control operations
*
****************************************************************************/
static void cdcacm_ep0incomplete(FAR struct usbdev_ep_s *ep,
FAR struct usbdev_req_s *req)
{
if (req->result || req->xfrd != req->len)
{
usbtrace(TRACE_CLSERROR(USBSER_TRACEERR_REQRESULT), (uint16_t)-req->result);
}
}
/****************************************************************************
* Name: cdcacm_rdcomplete
*
* Description:
* Handle completion of read request on the bulk OUT endpoint. This
* is handled like the receipt of serial data on the "UART"
*
****************************************************************************/
static void cdcacm_rdcomplete(FAR struct usbdev_ep_s *ep,
FAR struct usbdev_req_s *req)
{
FAR struct cdcacm_dev_s *priv;
irqstate_t flags;
int ret;
/* Sanity check */
#ifdef CONFIG_DEBUG
if (!ep || !ep->priv || !req)
{
usbtrace(TRACE_CLSERROR(USBSER_TRACEERR_INVALIDARG), 0);
return;
}
#endif
/* Extract references to private data */
priv = (FAR struct cdcacm_dev_s *)ep->priv;
/* Process the received data unless this is some unusual condition */
flags = enter_critical_section();
switch (req->result)
{
case 0: /* Normal completion */
usbtrace(TRACE_CLASSRDCOMPLETE, priv->nrdq);
cdcacm_recvpacket(priv, req->buf, req->xfrd);
break;
case -ESHUTDOWN: /* Disconnection */
usbtrace(TRACE_CLSERROR(USBSER_TRACEERR_RDSHUTDOWN), 0);
priv->nrdq--;
leave_critical_section(flags);
return;
default: /* Some other error occurred */
usbtrace(TRACE_CLSERROR(USBSER_TRACEERR_RDUNEXPECTED), (uint16_t)-req->result);
break;
};
/* Requeue the read request */
req->len = ep->maxpacket;
ret = EP_SUBMIT(ep, req);
if (ret != OK)
{
usbtrace(TRACE_CLSERROR(USBSER_TRACEERR_RDSUBMIT), (uint16_t)-req->result);
}
leave_critical_section(flags);
}
/****************************************************************************
* Name: cdcacm_wrcomplete
*
* Description:
* Handle completion of write request. This function probably executes
* in the context of an interrupt handler.
*
****************************************************************************/
static void cdcacm_wrcomplete(FAR struct usbdev_ep_s *ep,
FAR struct usbdev_req_s *req)
{
FAR struct cdcacm_dev_s *priv;
FAR struct cdcacm_req_s *reqcontainer;
irqstate_t flags;
/* Sanity check */
#ifdef CONFIG_DEBUG
if (!ep || !ep->priv || !req || !req->priv)
{
usbtrace(TRACE_CLSERROR(USBSER_TRACEERR_INVALIDARG), 0);
return;
}
#endif
/* Extract references to our private data */
priv = (FAR struct cdcacm_dev_s *)ep->priv;
reqcontainer = (FAR struct cdcacm_req_s *)req->priv;
/* Return the write request to the free list */
flags = enter_critical_section();
sq_addlast((FAR sq_entry_t *)reqcontainer, &priv->reqlist);
priv->nwrq++;
leave_critical_section(flags);
/* Send the next packet unless this was some unusual termination
* condition
*/
switch (req->result)
{
case OK: /* Normal completion */
{
usbtrace(TRACE_CLASSWRCOMPLETE, priv->nwrq);
cdcacm_sndpacket(priv);
}
break;
case -ESHUTDOWN: /* Disconnection */
{
usbtrace(TRACE_CLSERROR(USBSER_TRACEERR_WRSHUTDOWN), priv->nwrq);
}
break;
default: /* Some other error occurred */
{
usbtrace(TRACE_CLSERROR(USBSER_TRACEERR_WRUNEXPECTED), (uint16_t)-req->result);
}
break;
}
}
/****************************************************************************
* USB Class Driver Methods
****************************************************************************/
/****************************************************************************
* Name: cdcacm_bind
*
* Description:
* Invoked when the driver is bound to a USB device driver
*
****************************************************************************/
static int cdcacm_bind(FAR struct usbdevclass_driver_s *driver,
FAR struct usbdev_s *dev)
{
FAR struct cdcacm_dev_s *priv = ((FAR struct cdcacm_driver_s *)driver)->dev;
FAR struct cdcacm_req_s *reqcontainer;
irqstate_t flags;
uint16_t reqlen;
int ret;
int i;
usbtrace(TRACE_CLASSBIND, 0);
/* Bind the structures */
priv->usbdev = dev;
/* Save the reference to our private data structure in EP0 so that it
* can be recovered in ep0 completion events (Unless we are part of
* a composite device and, in that case, the composite device owns
* EP0).
*/
#ifndef CONFIG_USBMSC_COMPOSITE
dev->ep0->priv = priv;
#endif
/* Preallocate control request */
priv->ctrlreq = cdcacm_allocreq(dev->ep0, CDCACM_MXDESCLEN);
if (priv->ctrlreq == NULL)
{
usbtrace(TRACE_CLSERROR(USBSER_TRACEERR_ALLOCCTRLREQ), 0);
ret = -ENOMEM;
goto errout;
}
priv->ctrlreq->callback = cdcacm_ep0incomplete;
/* Pre-allocate all endpoints... the endpoints will not be functional
* until the SET CONFIGURATION request is processed in cdcacm_setconfig.
* This is done here because there may be calls to kmm_malloc and the SET
* CONFIGURATION processing probably occurrs within interrupt handling
* logic where kmm_malloc calls will fail.
*/
/* Pre-allocate the IN interrupt endpoint */
priv->epintin = DEV_ALLOCEP(dev, CDCACM_EPINTIN_ADDR, true, USB_EP_ATTR_XFER_INT);
if (!priv->epintin)
{
usbtrace(TRACE_CLSERROR(USBSER_TRACEERR_EPINTINALLOCFAIL), 0);
ret = -ENODEV;
goto errout;
}
priv->epintin->priv = priv;
/* Pre-allocate the IN bulk endpoint */
priv->epbulkin = DEV_ALLOCEP(dev, CDCACM_EPINBULK_ADDR, true, USB_EP_ATTR_XFER_BULK);
if (!priv->epbulkin)
{
usbtrace(TRACE_CLSERROR(USBSER_TRACEERR_EPBULKINALLOCFAIL), 0);
ret = -ENODEV;
goto errout;
}
priv->epbulkin->priv = priv;
/* Pre-allocate the OUT bulk endpoint */
priv->epbulkout = DEV_ALLOCEP(dev, CDCACM_EPOUTBULK_ADDR, false, USB_EP_ATTR_XFER_BULK);
if (!priv->epbulkout)
{
usbtrace(TRACE_CLSERROR(USBSER_TRACEERR_EPBULKOUTALLOCFAIL), 0);
ret = -ENODEV;
goto errout;
}
priv->epbulkout->priv = priv;
/* Pre-allocate read requests. The buffer size is one full packet. */
#ifdef CONFIG_USBDEV_DUALSPEED
reqlen = CONFIG_CDCACM_EPBULKOUT_HSSIZE;
#else
reqlen = CONFIG_CDCACM_EPBULKOUT_FSSIZE;
#endif
for (i = 0; i < CONFIG_CDCACM_NRDREQS; i++)
{
reqcontainer = &priv->rdreqs[i];
reqcontainer->req = cdcacm_allocreq(priv->epbulkout, reqlen);
if (reqcontainer->req == NULL)
{
usbtrace(TRACE_CLSERROR(USBSER_TRACEERR_RDALLOCREQ), -ENOMEM);
ret = -ENOMEM;
goto errout;
}
reqcontainer->req->priv = reqcontainer;
reqcontainer->req->callback = cdcacm_rdcomplete;
}
/* Pre-allocate write request containers and put in a free list.
* The buffer size should be larger than a full packet. Otherwise,
* we will send a bogus null packet at the end of each packet.
*
* Pick the larger of the max packet size and the configured request
* size.
*/
#ifdef CONFIG_USBDEV_DUALSPEED
reqlen = CONFIG_CDCACM_EPBULKIN_HSSIZE;
#else
reqlen = CONFIG_CDCACM_EPBULKIN_FSSIZE;
#endif
if (CONFIG_CDCACM_BULKIN_REQLEN > reqlen)
{
reqlen = CONFIG_CDCACM_BULKIN_REQLEN;
}
for (i = 0; i < CONFIG_CDCACM_NWRREQS; i++)
{
reqcontainer = &priv->wrreqs[i];
reqcontainer->req = cdcacm_allocreq(priv->epbulkin, reqlen);
if (reqcontainer->req == NULL)
{
usbtrace(TRACE_CLSERROR(USBSER_TRACEERR_WRALLOCREQ), -ENOMEM);
ret = -ENOMEM;
goto errout;
}
reqcontainer->req->priv = reqcontainer;
reqcontainer->req->callback = cdcacm_wrcomplete;
flags = enter_critical_section();
sq_addlast((FAR sq_entry_t *)reqcontainer, &priv->reqlist);
priv->nwrq++; /* Count of write requests available */
leave_critical_section(flags);
}
/* Report if we are selfpowered (unless we are part of a composite device) */
#ifndef CONFIG_CDCACM_COMPOSITE
#ifdef CONFIG_USBDEV_SELFPOWERED
DEV_SETSELFPOWERED(dev);
#endif
/* And pull-up the data line for the soft connect function (unless we are
* part of a composite device)
*/
DEV_CONNECT(dev);
#endif
return OK;
errout:
cdcacm_unbind(driver, dev);
return ret;
}
/****************************************************************************
* Name: cdcacm_unbind
*
* Description:
* Invoked when the driver is unbound from a USB device driver
*
****************************************************************************/
static void cdcacm_unbind(FAR struct usbdevclass_driver_s *driver,
FAR struct usbdev_s *dev)
{
FAR struct cdcacm_dev_s *priv;
FAR struct cdcacm_req_s *reqcontainer;
irqstate_t flags;
int i;
usbtrace(TRACE_CLASSUNBIND, 0);
#ifdef CONFIG_DEBUG
if (!driver || !dev)
{
usbtrace(TRACE_CLSERROR(USBSER_TRACEERR_INVALIDARG), 0);
return;
}
#endif
/* Extract reference to private data */
priv = ((FAR struct cdcacm_driver_s *)driver)->dev;
#ifdef CONFIG_DEBUG
if (!priv)
{
usbtrace(TRACE_CLSERROR(USBSER_TRACEERR_EP0NOTBOUND), 0);
return;
}
#endif
/* Make sure that we are not already unbound */
if (priv != NULL)
{
/* Make sure that the endpoints have been unconfigured. If
* we were terminated gracefully, then the configuration should
* already have been reset. If not, then calling cdcacm_resetconfig
* should cause the endpoints to immediately terminate all
* transfers and return the requests to us (with result == -ESHUTDOWN)
*/
cdcacm_resetconfig(priv);
up_mdelay(50);
/* Free the interrupt IN endpoint */
if (priv->epintin)
{
DEV_FREEEP(dev, priv->epintin);
priv->epintin = NULL;
}
/* Free the bulk IN endpoint */
if (priv->epbulkin)
{
DEV_FREEEP(dev, priv->epbulkin);
priv->epbulkin = NULL;
}
/* Free the pre-allocated control request */
if (priv->ctrlreq != NULL)
{
cdcacm_freereq(dev->ep0, priv->ctrlreq);
priv->ctrlreq = NULL;
}
/* Free pre-allocated read requests (which should all have
* been returned to the free list at this time -- we don't check)
*/
DEBUGASSERT(priv->nrdq == 0);
for (i = 0; i < CONFIG_CDCACM_NRDREQS; i++)
{
reqcontainer = &priv->rdreqs[i];
if (reqcontainer->req)
{
cdcacm_freereq(priv->epbulkout, reqcontainer->req);
reqcontainer->req = NULL;
}
}
/* Free the bulk OUT endpoint */
if (priv->epbulkout)
{
DEV_FREEEP(dev, priv->epbulkout);
priv->epbulkout = NULL;
}
/* Free write requests that are not in use (which should be all
* of them)
*/
flags = enter_critical_section();
DEBUGASSERT(priv->nwrq == CONFIG_CDCACM_NWRREQS);
while (!sq_empty(&priv->reqlist))
{
reqcontainer = (struct cdcacm_req_s *)sq_remfirst(&priv->reqlist);
if (reqcontainer->req != NULL)
{
cdcacm_freereq(priv->epbulkin, reqcontainer->req);
priv->nwrq--; /* Number of write requests queued */
}
}
DEBUGASSERT(priv->nwrq == 0);
leave_critical_section(flags);
/* Clear out all data in the circular buffer */
priv->serdev.xmit.head = 0;
priv->serdev.xmit.tail = 0;
}
}
/****************************************************************************
* Name: cdcacm_setup
*
* Description:
* Invoked for ep0 control requests. This function probably executes
* in the context of an interrupt handler.
*
****************************************************************************/
static int cdcacm_setup(FAR struct usbdevclass_driver_s *driver,
FAR struct usbdev_s *dev,
FAR const struct usb_ctrlreq_s *ctrl,
FAR uint8_t *dataout, size_t outlen)
{
FAR struct cdcacm_dev_s *priv;
FAR struct usbdev_req_s *ctrlreq;
uint16_t value;
uint16_t index;
uint16_t len;
int ret = -EOPNOTSUPP;
#ifdef CONFIG_DEBUG
if (!driver || !dev || !ctrl)
{
usbtrace(TRACE_CLSERROR(USBSER_TRACEERR_INVALIDARG), 0);
return -EIO;
}
#endif
/* Extract reference to private data */
usbtrace(TRACE_CLASSSETUP, ctrl->req);
priv = ((FAR struct cdcacm_driver_s *)driver)->dev;
#ifdef CONFIG_DEBUG
if (!priv || !priv->ctrlreq)
{
usbtrace(TRACE_CLSERROR(USBSER_TRACEERR_EP0NOTBOUND), 0);
return -ENODEV;
}
#endif
ctrlreq = priv->ctrlreq;
/* Extract the little-endian 16-bit values to host order */
value = GETUINT16(ctrl->value);
index = GETUINT16(ctrl->index);
len = GETUINT16(ctrl->len);
uvdbg("type=%02x req=%02x value=%04x index=%04x len=%04x\n",
ctrl->type, ctrl->req, value, index, len);
if ((ctrl->type & USB_REQ_TYPE_MASK) == USB_REQ_TYPE_STANDARD)
{
/***********************************************************************
* Standard Requests
***********************************************************************/
switch (ctrl->req)
{
case USB_REQ_GETDESCRIPTOR:
{
/* The value field specifies the descriptor type in the MS byte and the
* descriptor index in the LS byte (order is little endian)
*/
switch (ctrl->value[1])
{
/* If the serial device is used in as part of a composite device,
* then the device descriptor is provided by logic in the composite
* device implementation.
*/
#ifndef CONFIG_CDCACM_COMPOSITE
case USB_DESC_TYPE_DEVICE:
{
ret = USB_SIZEOF_DEVDESC;
memcpy(ctrlreq->buf, cdcacm_getdevdesc(), ret);
}
break;
#endif
/* If the serial device is used in as part of a composite device,
* then the device qualifier descriptor is provided by logic in the
* composite device implementation.
*/
#if !defined(CONFIG_CDCACM_COMPOSITE) && defined(CONFIG_USBDEV_DUALSPEED)
case USB_DESC_TYPE_DEVICEQUALIFIER:
{
ret = USB_SIZEOF_QUALDESC;
memcpy(ctrlreq->buf, cdcacm_getqualdesc(), ret);
}
break;
case USB_DESC_TYPE_OTHERSPEEDCONFIG:
#endif
/* If the serial device is used in as part of a composite device,
* then the configuration descriptor is provided by logic in the
* composite device implementation.
*/
#ifndef CONFIG_CDCACM_COMPOSITE
case USB_DESC_TYPE_CONFIG:
{
#ifdef CONFIG_USBDEV_DUALSPEED
ret = cdcacm_mkcfgdesc(ctrlreq->buf, dev->speed, ctrl->req);
#else
ret = cdcacm_mkcfgdesc(ctrlreq->buf);
#endif
}
break;
#endif
/* If the serial device is used in as part of a composite device,
* then the language string descriptor is provided by logic in the
* composite device implementation.
*/
#ifndef CONFIG_CDCACM_COMPOSITE
case USB_DESC_TYPE_STRING:
{
/* index == language code. */
ret = cdcacm_mkstrdesc(ctrl->value[0], (struct usb_strdesc_s *)ctrlreq->buf);
}
break;
#endif
default:
{
usbtrace(TRACE_CLSERROR(USBSER_TRACEERR_GETUNKNOWNDESC), value);
}
break;
}
}
break;
case USB_REQ_SETCONFIGURATION:
{
if (ctrl->type == 0)
{
ret = cdcacm_setconfig(priv, value);
}
}
break;
/* If the serial device is used in as part of a composite device,
* then the overall composite class configuration is managed by logic
* in the composite device implementation.
*/
#ifndef CONFIG_CDCACM_COMPOSITE
case USB_REQ_GETCONFIGURATION:
{
if (ctrl->type == USB_DIR_IN)
{
*(FAR uint8_t *)ctrlreq->buf = priv->config;
ret = 1;
}
}
break;
#endif
case USB_REQ_SETINTERFACE:
{
if (ctrl->type == USB_REQ_RECIPIENT_INTERFACE &&
priv->config == CDCACM_CONFIGID)
{
if ((index == CDCACM_NOTIFID && value == CDCACM_NOTALTIFID) ||
(index == CDCACM_DATAIFID && value == CDCACM_DATAALTIFID))
{
cdcacm_resetconfig(priv);
cdcacm_setconfig(priv, priv->config);
ret = 0;
}
}
}
break;
case USB_REQ_GETINTERFACE:
{
if (ctrl->type == (USB_DIR_IN | USB_REQ_RECIPIENT_INTERFACE) &&
priv->config == CDCACM_CONFIGIDNONE)
{
if ((index == CDCACM_NOTIFID && value == CDCACM_NOTALTIFID) ||
(index == CDCACM_DATAIFID && value == CDCACM_DATAALTIFID))
{
*(FAR uint8_t *) ctrlreq->buf = value;
ret = 1;
}
else
{
ret = -EDOM;
}
}
}
break;
default:
usbtrace(TRACE_CLSERROR(USBSER_TRACEERR_UNSUPPORTEDSTDREQ), ctrl->req);
break;
}
}
else if ((ctrl->type & USB_REQ_TYPE_MASK) == USB_REQ_TYPE_CLASS)
{
/***********************************************************************
* CDC ACM-Specific Requests
***********************************************************************/
switch (ctrl->req)
{
/* ACM_GET_LINE_CODING requests current DTE rate, stop-bits, parity, and
* number-of-character bits. (Optional)
*/
case ACM_GET_LINE_CODING:
{
if (ctrl->type == (USB_DIR_IN | USB_REQ_TYPE_CLASS | USB_REQ_RECIPIENT_INTERFACE) &&
index == CDCACM_NOTIFID)
{
/* Return the current line status from the private data structure */
memcpy(ctrlreq->buf, &priv->linecoding, SIZEOF_CDC_LINECODING);
ret = SIZEOF_CDC_LINECODING;
}
else
{
usbtrace(TRACE_CLSERROR(USBSER_TRACEERR_UNSUPPORTEDCLASSREQ), ctrl->type);
}
}
break;
/* ACM_SET_LINE_CODING configures DTE rate, stop-bits, parity, and
* number-of-character bits. (Optional)
*/
case ACM_SET_LINE_CODING:
{
if (ctrl->type == (USB_DIR_OUT | USB_REQ_TYPE_CLASS | USB_REQ_RECIPIENT_INTERFACE) &&
len == SIZEOF_CDC_LINECODING && /* dataout && len == outlen && */
index == CDCACM_NOTIFID)
{
/* Save the new line coding in the private data structure. NOTE:
* that this is conditional now because not all device controller
* drivers supported provision of EP0 OUT data with the setup
* command.
*/
if (dataout && len <= SIZEOF_CDC_LINECODING) /* REVISIT */
{
memcpy(&priv->linecoding, dataout, SIZEOF_CDC_LINECODING);
}
/* Respond with a zero length packet */
ret = 0;
/* If there is a registered callback to receive line status info, then
* callout now.
*/
if (priv->callback)
{
priv->callback(CDCACM_EVENT_LINECODING);
}
}
else
{
usbtrace(TRACE_CLSERROR(USBSER_TRACEERR_UNSUPPORTEDCLASSREQ), ctrl->type);
}
}
break;
/* ACM_SET_CTRL_LINE_STATE: RS-232 signal used to tell the DCE device the
* DTE device is now present. (Optional)
*/
case ACM_SET_CTRL_LINE_STATE:
{
if (ctrl->type == (USB_DIR_OUT | USB_REQ_TYPE_CLASS | USB_REQ_RECIPIENT_INTERFACE) &&
index == CDCACM_NOTIFID)
{
/* Save the control line state in the private data structure. Only bits
* 0 and 1 have meaning. Respond with a zero length packet.
*/
priv->ctrlline = value & 3;
ret = 0;
/* If there is a registered callback to receive control line status info,
* then callout now.
*/
if (priv->callback)
{
priv->callback(CDCACM_EVENT_CTRLLINE);
}
}
else
{
usbtrace(TRACE_CLSERROR(USBSER_TRACEERR_UNSUPPORTEDCLASSREQ), ctrl->type);
}
}
break;
/* Sends special carrier */
case ACM_SEND_BREAK:
{
if (ctrl->type == (USB_DIR_OUT | USB_REQ_TYPE_CLASS | USB_REQ_RECIPIENT_INTERFACE) &&
index == CDCACM_NOTIFID)
{
/* If there is a registered callback to handle the SendBreak request,
* then callout now. Respond with a zero length packet.
*/
ret = 0;
if (priv->callback)
{
priv->callback(CDCACM_EVENT_SENDBREAK);
}
}
else
{
usbtrace(TRACE_CLSERROR(USBSER_TRACEERR_UNSUPPORTEDCLASSREQ), ctrl->type);
}
}
break;
default:
usbtrace(TRACE_CLSERROR(USBSER_TRACEERR_UNSUPPORTEDCLASSREQ), ctrl->req);
break;
}
}
else
{
usbtrace(TRACE_CLSERROR(USBSER_TRACEERR_UNSUPPORTEDTYPE), ctrl->type);
}
/* Respond to the setup command if data was returned. On an error return
* value (ret < 0), the USB driver will stall.
*/
if (ret >= 0)
{
/* Configure the response */
ctrlreq->len = MIN(len, ret);
ctrlreq->flags = USBDEV_REQFLAGS_NULLPKT;
/* Send the response -- either directly to the USB controller or
* indirectly in the case where this class is a member of a composite
* device.
*/
#ifndef CONFIG_CDCACM_COMPOSITE
ret = EP_SUBMIT(dev->ep0, ctrlreq);
#else
ret = composite_ep0submit(driver, dev, ctrlreq);
#endif
if (ret < 0)
{
usbtrace(TRACE_CLSERROR(USBSER_TRACEERR_EPRESPQ), (uint16_t)-ret);
ctrlreq->result = OK;
cdcacm_ep0incomplete(dev->ep0, ctrlreq);
}
}
/* Returning a negative value will cause a STALL */
return ret;
}
/****************************************************************************
* Name: cdcacm_disconnect
*
* Description:
* Invoked after all transfers have been stopped, when the host is
* disconnected. This function is probably called from the context of an
* interrupt handler.
*
****************************************************************************/
static void cdcacm_disconnect(FAR struct usbdevclass_driver_s *driver,
FAR struct usbdev_s *dev)
{
FAR struct cdcacm_dev_s *priv;
irqstate_t flags;
usbtrace(TRACE_CLASSDISCONNECT, 0);
#ifdef CONFIG_DEBUG
if (!driver || !dev || !dev->ep0)
{
usbtrace(TRACE_CLSERROR(USBSER_TRACEERR_INVALIDARG), 0);
return;
}
#endif
/* Extract reference to private data */
priv = ((FAR struct cdcacm_driver_s *)driver)->dev;
#ifdef CONFIG_DEBUG
if (!priv)
{
usbtrace(TRACE_CLSERROR(USBSER_TRACEERR_EP0NOTBOUND), 0);
return;
}
#endif
/* Inform the "upper half serial driver that we have lost the USB serial
* connection.
*/
flags = enter_critical_section();
#ifdef CONFIG_SERIAL_REMOVABLE
uart_connected(&priv->serdev, false);
#endif
/* Reset the configuration */
cdcacm_resetconfig(priv);
/* Clear out all outgoing data in the circular buffer */
priv->serdev.xmit.head = 0;
priv->serdev.xmit.tail = 0;
priv->rxhead = 0;
leave_critical_section(flags);
/* Perform the soft connect function so that we will we can be
* re-enumerated (unless we are part of a composite device)
*/
#ifndef CONFIG_CDCACM_COMPOSITE
DEV_CONNECT(dev);
#endif
}
/****************************************************************************
* Name: cdcacm_suspend
*
* Description:
* Handle the USB suspend event.
*
****************************************************************************/
#ifdef CONFIG_SERIAL_REMOVABLE
static void cdcacm_suspend(FAR struct usbdevclass_driver_s *driver,
FAR struct usbdev_s *dev)
{
FAR struct cdcacm_dev_s *priv;
usbtrace(TRACE_CLASSSUSPEND, 0);
#ifdef CONFIG_DEBUG
if (!driver || !dev)
{
usbtrace(TRACE_CLSERROR(USBSER_TRACEERR_INVALIDARG), 0);
return;
}
#endif
/* Extract reference to private data */
priv = ((FAR struct cdcacm_driver_s *)driver)->dev;
/* And let the "upper half" driver now that we are suspended */
uart_connected(&priv->serdev, false);
}
#endif
/****************************************************************************
* Name: cdcacm_resume
*
* Description:
* Handle the USB resume event.
*
****************************************************************************/
#ifdef CONFIG_SERIAL_REMOVABLE
static void cdcacm_resume(FAR struct usbdevclass_driver_s *driver,
FAR struct usbdev_s *dev)
{
FAR struct cdcacm_dev_s *priv;
usbtrace(TRACE_CLASSRESUME, 0);
#ifdef CONFIG_DEBUG
if (!driver || !dev)
{
usbtrace(TRACE_CLSERROR(USBSER_TRACEERR_INVALIDARG), 0);
return;
}
#endif
/* Extract reference to private data */
priv = ((FAR struct cdcacm_driver_s *)driver)->dev;
/* Are we still configured? */
if (priv->config != CDCACM_CONFIGIDNONE)
{
/* Yes.. let the "upper half" know that have resumed */
uart_connected(&priv->serdev, true);
}
}
#endif
/****************************************************************************
* Serial Device Methods
****************************************************************************/
/****************************************************************************
* Name: cdcuart_setup
*
* Description:
* This method is called the first time that the serial port is opened.
*
****************************************************************************/
static int cdcuart_setup(FAR struct uart_dev_s *dev)
{
FAR struct cdcacm_dev_s *priv;
usbtrace(CDCACM_CLASSAPI_SETUP, 0);
/* Sanity check */
#ifdef CONFIG_DEBUG
if (!dev || !dev->priv)
{
usbtrace(TRACE_CLSERROR(USBSER_TRACEERR_INVALIDARG), 0);
return -EIO;
}
#endif
/* Extract reference to private data */
priv = (FAR struct cdcacm_dev_s *)dev->priv;
/* Check if we have been configured */
if (priv->config == CDCACM_CONFIGIDNONE)
{
usbtrace(TRACE_CLSERROR(USBSER_TRACEERR_SETUPNOTCONNECTED), 0);
return -ENOTCONN;
}
return OK;
}
/****************************************************************************
* Name: cdcuart_shutdown
*
* Description:
* This method is called when the serial port is closed. This operation
* is very simple for the USB serial backend because the serial driver
* has already assured that the TX data has full drained -- it calls
* cdcuart_txempty() until that function returns true before calling this
* function.
*
****************************************************************************/
static void cdcuart_shutdown(FAR struct uart_dev_s *dev)
{
usbtrace(CDCACM_CLASSAPI_SHUTDOWN, 0);
/* Sanity check */
#ifdef CONFIG_DEBUG
if (!dev || !dev->priv)
{
usbtrace(TRACE_CLSERROR(USBSER_TRACEERR_INVALIDARG), 0);
}
#endif
}
/****************************************************************************
* Name: cdcuart_attach
*
* Description:
* Does not apply to the USB serial class device
*
****************************************************************************/
static int cdcuart_attach(FAR struct uart_dev_s *dev)
{
usbtrace(CDCACM_CLASSAPI_ATTACH, 0);
return OK;
}
/****************************************************************************
* Name: cdcuart_detach
*
* Description:
* Does not apply to the USB serial class device
*
****************************************************************************/
static void cdcuart_detach(FAR struct uart_dev_s *dev)
{
usbtrace(CDCACM_CLASSAPI_DETACH, 0);
}
/****************************************************************************
* Name: cdcuart_ioctl
*
* Description:
* All ioctl calls will be routed through this method
*
****************************************************************************/
static int cdcuart_ioctl(FAR struct file *filep, int cmd, unsigned long arg)
{
struct inode *inode = filep->f_inode;
struct cdcacm_dev_s *priv = inode->i_private;
FAR uart_dev_t *serdev = &priv->serdev;
int ret = OK;
switch (cmd)
{
/* CAICO_REGISTERCB
* Register a callback for serial event notification. Argument:
* cdcacm_callback_t. See cdcacm_callback_t type definition below.
* NOTE: The callback will most likely invoked at the interrupt level.
* The called back function should, therefore, limit its operations to
* invoking some kind of IPC to handle the serial event in some normal
* task environment.
*/
case CAIOC_REGISTERCB:
{
/* Save the new callback function */
priv->callback = (cdcacm_callback_t)((uintptr_t)arg);
}
break;
/* CAIOC_GETLINECODING
* Get current line coding. Argument: struct cdc_linecoding_s*.
* See include/nuttx/usb/cdc.h for structure definition. This IOCTL
* should be called to get the data associated with the
* CDCACM_EVENT_LINECODING event).
*/
case CAIOC_GETLINECODING:
{
FAR struct cdc_linecoding_s *ptr = (FAR struct cdc_linecoding_s *)((uintptr_t)arg);
if (ptr)
{
memcpy(ptr, &priv->linecoding, sizeof(struct cdc_linecoding_s));
}
else
{
ret = -EINVAL;
}
}
break;
/* CAIOC_GETCTRLLINE
* Get control line status bits. Argument FAR int*. See
* include/nuttx/usb/cdc.h for bit definitions. This IOCTL should be
* called to get the data associated CDCACM_EVENT_CTRLLINE event.
*/
case CAIOC_GETCTRLLINE:
{
FAR int *ptr = (FAR int *)((uintptr_t)arg);
if (ptr)
{
*ptr = priv->ctrlline;
}
else
{
ret = -EINVAL;
}
}
break;
/* CAIOC_NOTIFY
* Send a serial state to the host via the Interrupt IN endpoint.
* Argument: int. This includes the current state of the carrier detect,
* DSR, break, and ring signal. See "Table 69: UART State Bitmap Values"
* and CDC_UART_definitions in include/nuttx/usb/cdc.h.
*/
case CAIOC_NOTIFY:
{
/* Not yet implemented. I probably won't bother to implement until
* I comr up with a usage model that needs it.
*
* Here is what the needs to be done:
*
* 1. Format and send a request header with:
*
* bmRequestType:
* USB_REQ_DIR_IN | USB_REQ_TYPE_CLASS | USB_REQ_RECIPIENT_INTERFACE
* bRequest: ACM_SERIAL_STATE
* wValue: 0
* wIndex: 0
* wLength: Length of data
*
* 2. Followed by the notification data (in a separate packet)
*/
ret = -ENOSYS;
}
break;
#ifdef CONFIG_SERIAL_TERMIOS
case TCGETS:
{
struct termios *termiosp = (FAR struct termios *)arg;
if (!termiosp)
{
ret = -EINVAL;
break;
}
/* And update with flags from this layer */
termiosp->c_iflag = serdev->tc_iflag;
termiosp->c_oflag = serdev->tc_oflag;
termiosp->c_lflag = serdev->tc_lflag;
}
break;
case TCSETS:
{
struct termios *termiosp = (FAR struct termios *)arg;
if (!termiosp)
{
ret = -EINVAL;
break;
}
/* Update the flags we keep at this layer */
serdev->tc_iflag = termiosp->c_iflag;
serdev->tc_oflag = termiosp->c_oflag;
serdev->tc_lflag = termiosp->c_lflag;
}
break;
#endif
case FIONREAD:
{
int count;
irqstate_t flags = enter_critical_section();
/* Determine the number of bytes available in the buffer. */
if (serdev->recv.tail <= serdev->recv.head)
{
count = serdev->recv.head - serdev->recv.tail;
}
else
{
count = serdev->recv.size - (serdev->recv.tail - serdev->recv.head);
}
leave_critical_section(flags);
*(int *)arg = count;
ret = 0;
}
break;
case FIONWRITE:
{
int count;
irqstate_t flags = enter_critical_section();
/* Determine the number of bytes free in the buffer. */
if (serdev->xmit.head < serdev->xmit.tail)
{
count = serdev->xmit.tail - serdev->xmit.head - 1;
}
else
{
count = serdev->xmit.size - (serdev->xmit.head - serdev->xmit.tail) - 1;
}
leave_critical_section(flags);
*(int *)arg = count;
ret = 0;
}
break;
default:
ret = -ENOTTY;
break;
}
return ret;
}
/****************************************************************************
* Name: cdcuart_rxint
*
* Description:
* Called by the serial driver to enable or disable RX interrupts. We, of
* course, have no RX interrupts but must behave consistently. This method
* is called under the conditions:
*
* 1. With enable==true when the port is opened (just after cdcuart_setup
* and cdcuart_attach are called called)
* 2. With enable==false while transferring data from the RX buffer
* 2. With enable==true while waiting for more incoming data
* 3. With enable==false when the port is closed (just before cdcuart_detach
* and cdcuart_shutdown are called).
*
****************************************************************************/
static void cdcuart_rxint(FAR struct uart_dev_s *dev, bool enable)
{
FAR struct cdcacm_dev_s *priv;
FAR uart_dev_t *serdev;
irqstate_t flags;
usbtrace(CDCACM_CLASSAPI_RXINT, (uint16_t)enable);
/* Sanity check */
#ifdef CONFIG_DEBUG
if (!dev || !dev->priv)
{
usbtrace(TRACE_CLSERROR(USBSER_TRACEERR_INVALIDARG), 0);
return;
}
#endif
/* Extract reference to private data */
priv = (FAR struct cdcacm_dev_s *)dev->priv;
serdev = &priv->serdev;
/* We need exclusive access to the RX buffer and private structure
* in the following.
*/
flags = enter_critical_section();
if (enable)
{
/* RX "interrupts" are enabled. Is this a transition from disabled
* to enabled state?
*/
if (!priv->rxenabled)
{
/* Yes. During the time that RX interrupts are disabled, the
* the serial driver will be extracting data from the circular
* buffer and modifying recv.tail. During this time, we
* should avoid modifying recv.head; When interrupts are restored,
* we can update the head pointer for all of the data that we
* put into circular buffer while "interrupts" were disabled.
*/
if (priv->rxhead != serdev->recv.head)
{
serdev->recv.head = priv->rxhead;
/* Yes... signal the availability of new data */
uart_datareceived(serdev);
}
/* RX "interrupts are no longer disabled */
priv->rxenabled = true;
}
}
/* RX "interrupts" are disabled. Is this a transition from enabled
* to disabled state?
*/
else if (priv->rxenabled)
{
/* Yes. During the time that RX interrupts are disabled, the
* the serial driver will be extracting data from the circular
* buffer and modifying recv.tail. During this time, we
* should avoid modifying recv.head; When interrupts are disabled,
* we use a shadow index and continue adding data to the circular
* buffer.
*/
priv->rxhead = serdev->recv.head;
priv->rxenabled = false;
}
leave_critical_section(flags);
}
/****************************************************************************
* Name: cdcuart_rxflowcontrol
*
* Description:
* Called when Rx buffer is full (or exceeds configured watermark levels
* if CONFIG_SERIAL_IFLOWCONTROL_WATERMARKS is defined).
* Return true if UART activated RX flow control to block more incoming
* data
*
* Input parameters:
* dev - UART device instance
* nbuffered - the number of characters currently buffered
* (if CONFIG_SERIAL_IFLOWCONTROL_WATERMARKS is
* not defined the value will be 0 for an empty buffer or the
* defined buffer size for a full buffer)
* upper - true indicates the upper watermark was crossed where
* false indicates the lower watermark has been crossed
*
* Returned Value:
* true if RX flow control activated.
*
****************************************************************************/
#ifdef CONFIG_SERIAL_IFLOWCONTROL
static bool cdcuart_rxflowcontrol(FAR struct uart_dev_s *dev,
unsigned int nbuffered, bool upper)
{
#ifdef CONFIG_CDCACM_IFLOWCONTROL
/* Allocate a request */
/* Format the SerialState notification */
/* Submit the request on the Interrupt IN endpoint */
# warning Missing logic
#endif
return false;
}
#endif
/****************************************************************************
* Name: cdcuart_txint
*
* Description:
* Called by the serial driver to enable or disable TX interrupts. We, of
* course, have no TX interrupts but must behave consistently. Initially,
* TX interrupts are disabled. This method is called under the conditions:
*
* 1. With enable==false while transferring data into the TX buffer
* 2. With enable==true when data may be taken from the buffer.
* 3. With enable==false when the TX buffer is empty
*
****************************************************************************/
static void cdcuart_txint(FAR struct uart_dev_s *dev, bool enable)
{
FAR struct cdcacm_dev_s *priv;
usbtrace(CDCACM_CLASSAPI_TXINT, (uint16_t)enable);
/* Sanity checks */
#ifdef CONFIG_DEBUG
if (!dev || !dev->priv)
{
usbtrace(TRACE_CLSERROR(USBSER_TRACEERR_INVALIDARG), 0);
return;
}
#endif
/* Extract references to private data */
priv = (FAR struct cdcacm_dev_s *)dev->priv;
/* If the new state is enabled and if there is data in the XMIT buffer,
* send the next packet now.
*/
uvdbg("enable=%d head=%d tail=%d\n",
enable, priv->serdev.xmit.head, priv->serdev.xmit.tail);
if (enable && priv->serdev.xmit.head != priv->serdev.xmit.tail)
{
cdcacm_sndpacket(priv);
}
}
/****************************************************************************
* Name: cdcuart_txempty
*
* Description:
* Return true when all data has been sent. This is called from the
* serial driver when the driver is closed. It will call this API
* periodically until it reports true. NOTE that the serial driver takes
* all responsibility for flushing TX data through the hardware so we can
* be a bit sloppy about that.
*
****************************************************************************/
static bool cdcuart_txempty(FAR struct uart_dev_s *dev)
{
FAR struct cdcacm_dev_s *priv = (FAR struct cdcacm_dev_s *)dev->priv;
usbtrace(CDCACM_CLASSAPI_TXEMPTY, 0);
#ifdef CONFIG_DEBUG
if (!priv)
{
usbtrace(TRACE_CLSERROR(USBSER_TRACEERR_INVALIDARG), 0);
return true;
}
#endif
/* When all of the allocated write requests have been returned to the
* reqlist, then there is no longer any TX data in flight.
*/
return priv->nwrq >= CONFIG_CDCACM_NWRREQS;
}
/****************************************************************************
* Public Functions
****************************************************************************/
/****************************************************************************
* Name: cdcacm_classobject
*
* Description:
* Register USB serial port (and USB serial console if so configured) and
* return the class object.
*
* Input Parameter:
* minor - Device minor number. E.g., minor 0 would correspond to
* /dev/ttyACM0.
* classdev - The location to return the CDC serial class' device
* instance.
*
* Returned Value:
* A pointer to the allocated class object (NULL on failure).
*
****************************************************************************/
#ifndef CONFIG_CDCACM_COMPOSITE
static
#endif
int cdcacm_classobject(int minor, FAR struct usbdevclass_driver_s **classdev)
{
FAR struct cdcacm_alloc_s *alloc;
FAR struct cdcacm_dev_s *priv;
FAR struct cdcacm_driver_s *drvr;
char devname[CDCACM_DEVNAME_SIZE];
int ret;
/* Allocate the structures needed */
alloc = (FAR struct cdcacm_alloc_s *)kmm_malloc(sizeof(struct cdcacm_alloc_s));
if (!alloc)
{
usbtrace(TRACE_CLSERROR(USBSER_TRACEERR_ALLOCDEVSTRUCT), 0);
return -ENOMEM;
}
/* Convenience pointers into the allocated blob */
priv = &alloc->dev;
drvr = &alloc->drvr;
/* Initialize the USB serial driver structure */
memset(priv, 0, sizeof(struct cdcacm_dev_s));
sq_init(&priv->reqlist);
priv->minor = minor;
/* Fake line status */
priv->linecoding.baud[0] = (115200) & 0xff; /* Baud=115200 */
priv->linecoding.baud[1] = (115200 >> 8) & 0xff;
priv->linecoding.baud[2] = (115200 >> 16) & 0xff;
priv->linecoding.baud[3] = (115200 >> 24) & 0xff;
priv->linecoding.stop = CDC_CHFMT_STOP1; /* One stop bit */
priv->linecoding.parity = CDC_PARITY_NONE; /* No parity */
priv->linecoding.nbits = 8; /* 8 data bits */
/* Initialize the serial driver sub-structure */
/* The initial state is disconnected */
#ifdef CONFIG_SERIAL_REMOVABLE
priv->serdev.disconnected = true;
#endif
priv->serdev.recv.size = CONFIG_CDCACM_RXBUFSIZE;
priv->serdev.recv.buffer = priv->rxbuffer;
priv->serdev.xmit.size = CONFIG_CDCACM_TXBUFSIZE;
priv->serdev.xmit.buffer = priv->txbuffer;
priv->serdev.ops = &g_uartops;
priv->serdev.priv = priv;
/* Initialize the USB class driver structure */
#ifdef CONFIG_USBDEV_DUALSPEED
drvr->drvr.speed = USB_SPEED_HIGH;
#else
drvr->drvr.speed = USB_SPEED_FULL;
#endif
drvr->drvr.ops = &g_driverops;
drvr->dev = priv;
/* Register the USB serial console */
#ifdef CONFIG_CDCACM_CONSOLE
priv->serdev.isconsole = true;
ret = uart_register("/dev/console", &priv->serdev);
if (ret < 0)
{
usbtrace(TRACE_CLSERROR(USBSER_TRACEERR_CONSOLEREGISTER), (uint16_t)-ret);
goto errout_with_class;
}
#endif
/* Register the CDC/ACM TTY device */
sprintf(devname, CDCACM_DEVNAME_FORMAT, minor);
ret = uart_register(devname, &priv->serdev);
if (ret < 0)
{
usbtrace(TRACE_CLSERROR(USBSER_TRACEERR_UARTREGISTER), (uint16_t)-ret);
goto errout_with_class;
}
*classdev = &drvr->drvr;
return OK;
errout_with_class:
kmm_free(alloc);
return ret;
}
/****************************************************************************
* Name: cdcacm_initialize
*
* Description:
* Register USB serial port (and USB serial console if so configured).
*
* Input Parameter:
* minor - Device minor number. E.g., minor 0 would correspond to
* /dev/ttyACM0.
* handle - An optional opaque reference to the CDC/ACM class object that
* may subsequently be used with cdcacm_uninitialize().
*
* Returned Value:
* Zero (OK) means that the driver was successfully registered. On any
* failure, a negated errno value is returned.
*
****************************************************************************/
#ifndef CONFIG_CDCACM_COMPOSITE
int cdcacm_initialize(int minor, FAR void **handle)
{
FAR struct usbdevclass_driver_s *drvr = NULL;
int ret;
/* Get an instance of the serial driver class object */
ret = cdcacm_classobject(minor, &drvr);
if (ret == OK)
{
/* Register the USB serial class driver */
ret = usbdev_register(drvr);
if (ret < 0)
{
usbtrace(TRACE_CLSERROR(USBSER_TRACEERR_DEVREGISTER), (uint16_t)-ret);
}
}
/* Return the driver instance (if any) if the caller has requested it
* by provided a pointer to the location to return it.
*/
if (handle)
{
*handle = (FAR void *)drvr;
}
return ret;
}
#endif
/****************************************************************************
* Name: cdcacm_uninitialize
*
* Description:
* Un-initialize the USB storage class driver. This function is used
* internally by the USB composite driver to uninitialize the CDC/ACM
* driver. This same interface is available (with an untyped input
* parameter) when the CDC/ACM driver is used standalone.
*
* Input Parameters:
* There is one parameter, it differs in typing depending upon whether the
* CDC/ACM driver is an internal part of a composite device, or a standalone
* USB driver:
*
* classdev - The class object returned by board_cdcclassobject() or
* cdcacm_classobject()
* handle - The opaque handle representing the class object returned by
* a previous call to cdcacm_initialize().
*
* Returned Value:
* None
*
****************************************************************************/
#ifdef CONFIG_CDCACM_COMPOSITE
void cdcacm_uninitialize(FAR struct usbdevclass_driver_s *classdev)
#else
void cdcacm_uninitialize(FAR void *handle)
#endif
{
#ifdef CONFIG_CDCACM_COMPOSITE
FAR struct cdcacm_driver_s *drvr = (FAR struct cdcacm_driver_s *)classdev;
#else
FAR struct cdcacm_driver_s *drvr = (FAR struct cdcacm_driver_s *)handle;
#endif
FAR struct cdcacm_dev_s *priv = drvr->dev;
char devname[CDCACM_DEVNAME_SIZE];
int ret;
#ifdef CONFIG_CDCACM_COMPOSITE
/* Check for pass 2 uninitialization. We did most of the work on the
* first pass uninitialization.
*/
if (priv->minor == (uint8_t)-1)
{
/* In this second and final pass, all that remains to be done is to
* free the memory resources.
*/
kmm_free(priv);
return;
}
#endif
/* Un-register the CDC/ACM TTY device */
sprintf(devname, CDCACM_DEVNAME_FORMAT, priv->minor);
ret = unregister_driver(devname);
if (ret < 0)
{
usbtrace(TRACE_CLSERROR(USBSER_TRACEERR_UARTUNREGISTER), (uint16_t)-ret);
}
/* Unregister the driver (unless we are a part of a composite device). The
* device unregister logic will (1) return all of the requests to us then
* (2) all the unbind method.
*
* The same thing will happen in the composite case except that: (1) the
* composite driver will call usbdev_unregister() which will (2) return the
* requests for all members of the composite, and (3) call the unbind
* method in the composite device which will (4) call the unbind method
* for this device.
*/
#ifndef CONFIG_CDCACM_COMPOSITE
usbdev_unregister(&drvr->drvr);
/* And free the driver structure */
kmm_free(priv);
#else
/* For the case of the composite driver, there is a two pass
* uninitialization sequence. We cannot yet free the driver structure.
* We will do that on the second pass. We mark the fact that we have
* already uninitialized by setting the minor number to -1. If/when we
* are called again, then we will free the memory resources.
*/
priv->minor = (uint8_t)-1;
#endif
}
Reference in New Issue View Git Blame Copy Permalink