diff --git a/ChangeLog b/ChangeLog
index 25b43abe3901b2b90436f1b5fa43e6cd86bfd10c..40a012a791b07ccb2b5d9ae2a5576349f2be76fe 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -2107,4 +2107,7 @@
potential crash when using mq_timedreceived() and mq_timedsend().
* sched/mq_sndinternal.c: Related to the above, the send logic was incrementing
the wrong counter when it waited as part of the mq_timedsend.c logic.
+ * fs/fat: Fix an error in the long file name logic: If the long file name
+ is an even multiple of 13 bytes in length, then it should not include a
+ NULL terminating character. Fix contributed by Kaushal Parikh.
diff --git a/drivers/usbdev/Make.defs b/drivers/usbdev/Make.defs
index 6771c2fb91850590e966224da353701952f9b852..4ae4a49e1300819d39d8a6ab031267cd5e86cf2c 100644
--- a/drivers/usbdev/Make.defs
+++ b/drivers/usbdev/Make.defs
@@ -46,7 +46,11 @@ ifeq ($(CONFIG_CDCSER),y)
endif
ifeq ($(CONFIG_USBSTRG),y)
- CSRCS += usbdev_storage.c usbdev_scsi.c
+ CSRCS += usbdev_storage.c usbdev_stordesc.c usbdev_scsi.c
+endif
+
+ifeq ($(CONFIG_USBDEV_COMPOSITE),y)
+ CSRCS += usbdev_composite.c
endif
CSRCS += usbdev_trace.c usbdev_trprintf.c
diff --git a/drivers/usbdev/cdc_serdesc.c b/drivers/usbdev/cdc_serdesc.c
index 03bac3006f2cc28ea3b7182a74acc8966ca023c4..990704a1bbd547a3d47a99dbe7800b81c3ceee1f 100644
--- a/drivers/usbdev/cdc_serdesc.c
+++ b/drivers/usbdev/cdc_serdesc.c
@@ -365,14 +365,14 @@ static const struct usb_qualdesc_s g_qualdesc =
****************************************************************************/
/****************************************************************************
- * Name: usbclass_mkstrdesc
+ * Name: cdcser_mkstrdesc
*
* Description:
* Construct a string descriptor
*
****************************************************************************/
-int usbclass_mkstrdesc(uint8_t id, struct usb_strdesc_s *strdesc)
+int cdcser_mkstrdesc(uint8_t id, struct usb_strdesc_s *strdesc)
{
const char *str;
int len;
@@ -441,20 +441,20 @@ int usbclass_mkstrdesc(uint8_t id, struct usb_strdesc_s *strdesc)
}
/****************************************************************************
- * Name: usbclass_getepdesc
+ * Name: cdcser_getepdesc
*
* Description:
* Return a pointer to the raw device descriptor
*
****************************************************************************/
-FAR const struct usb_devdesc_s *usbclass_getdevdesc(void)
+FAR const struct usb_devdesc_s *cdcser_getdevdesc(void)
{
return &g_devdesc;
}
/****************************************************************************
- * Name: usbclass_getepdesc
+ * Name: cdcser_getepdesc
*
* Description:
* Return a pointer to the raw endpoint struct (used for configuring
@@ -462,7 +462,7 @@ FAR const struct usb_devdesc_s *usbclass_getdevdesc(void)
*
****************************************************************************/
-FAR const struct usb_epdesc_s *usbclass_getepdesc(enum cdcser_epdesc_e epid)
+FAR const struct usb_epdesc_s *cdcser_getepdesc(enum cdcser_epdesc_e epid)
{
switch (epid)
{
@@ -481,7 +481,7 @@ FAR const struct usb_epdesc_s *usbclass_getepdesc(enum cdcser_epdesc_e epid)
}
/****************************************************************************
- * Name: usbclass_mkepdesc
+ * Name: cdcser_mkepdesc
*
* Description:
* Construct the endpoint descriptor using the correct max packet size.
@@ -489,15 +489,14 @@ FAR const struct usb_epdesc_s *usbclass_getepdesc(enum cdcser_epdesc_e epid)
****************************************************************************/
#ifdef CONFIG_USBDEV_DUALSPEED
-void usbclass_mkepdesc(num cdcser_epdesc_e epid,
- uint16_t mxpacket,
- FAR struct usb_epdesc_s *outdesc)
+void cdcser_mkepdesc(num cdcser_epdesc_e epid, uint16_t mxpacket,
+ FAR struct usb_epdesc_s *outdesc)
{
FAR const struct usb_epdesc_s *indesc;
/* Copy the "canned" descriptor */
- indesc = usbclass_getepdesc(epid)
+ indesc = cdcser_getepdesc(epid)
memcpy(outdesc, indesc, USB_SIZEOF_EPDESC);
/* Then add the correct max packet size */
@@ -508,7 +507,7 @@ void usbclass_mkepdesc(num cdcser_epdesc_e epid,
#endif
/****************************************************************************
- * Name: usbclass_mkcfgdesc
+ * Name: cdcser_mkcfgdesc
*
* Description:
* Construct the configuration descriptor
@@ -516,9 +515,9 @@ void usbclass_mkepdesc(num cdcser_epdesc_e epid,
****************************************************************************/
#ifdef CONFIG_USBDEV_DUALSPEED
-int16_t usbclass_mkcfgdesc(FAR uint8_t *buf, uint8_t speed, uint8_t type)
+int16_t cdcser_mkcfgdesc(FAR uint8_t *buf, uint8_t speed, uint8_t type)
#else
-int16_t usbclass_mkcfgdesc(FAR uint8_t *buf)
+int16_t cdcser_mkcfgdesc(FAR uint8_t *buf)
#endif
{
FAR const struct cfgdecsc_group_s *group;
@@ -554,7 +553,7 @@ int16_t usbclass_mkcfgdesc(FAR uint8_t *buf)
#ifdef CONFIG_USBDEV_DUALSPEED
if (highspeed && group->hsepsize != 0)
{
- usbclass_mkepdesc(group->desc, group->hsepsize,
+ cdcser_mkepdesc(group->desc, group->hsepsize,
(FAR struct usb_epdesc_s*)dest);
}
else
@@ -576,7 +575,7 @@ int16_t usbclass_mkcfgdesc(FAR uint8_t *buf)
}
/****************************************************************************
- * Name: usbclass_getqualdesc
+ * Name: cdcser_getqualdesc
*
* Description:
* Return a pointer to the raw qual descriptor
@@ -584,7 +583,7 @@ int16_t usbclass_mkcfgdesc(FAR uint8_t *buf)
****************************************************************************/
#ifdef CONFIG_USBDEV_DUALSPEED
-FAR const struct usb_qualdesc_s *usbclass_getqualdesc(void)
+FAR const struct usb_qualdesc_s *cdcser_getqualdesc(void)
{
return &g_qualdesc;
}
diff --git a/drivers/usbdev/cdc_serial.c b/drivers/usbdev/cdc_serial.c
index 80a61e1f04e97c7b13f40642a775e437ebbe8408..c91b451c3b2c5ad6c3b8541651ba6cf44a0e23e4 100644
--- a/drivers/usbdev/cdc_serial.c
+++ b/drivers/usbdev/cdc_serial.c
@@ -73,15 +73,15 @@
/* Container to support a list of requests */
-struct usbser_req_s
+struct cdcser_req_s
{
- FAR struct usbser_req_s *flink; /* Implements a singly linked list */
+ FAR struct cdcser_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 usbser_dev_s
+struct cdcser_dev_s
{
FAR struct uart_dev_s serdev; /* Serial device structure */
FAR struct usbdev_s *usbdev; /* usbdev driver pointer */
@@ -107,8 +107,8 @@ struct usbser_dev_s
* EPBULKIN; Read requests will be queued in the EBULKOUT.
*/
- struct usbser_req_s wrreqs[CONFIG_CDCSER_NWRREQS];
- struct usbser_req_s rdreqs[CONFIG_CDCSER_NWRREQS];
+ struct cdcser_req_s wrreqs[CONFIG_CDCSER_NWRREQS];
+ struct cdcser_req_s rdreqs[CONFIG_CDCSER_NWRREQS];
/* Serial I/O buffers */
@@ -118,18 +118,18 @@ struct usbser_dev_s
/* The internal version of the class driver */
-struct usbser_driver_s
+struct cdcser_driver_s
{
struct usbdevclass_driver_s drvr;
- FAR struct usbser_dev_s *dev;
+ FAR struct cdcser_dev_s *dev;
};
/* This is what is allocated */
-struct usbser_alloc_s
+struct cdcser_alloc_s
{
- struct usbser_dev_s dev;
- struct usbser_driver_s drvr;
+ struct cdcser_dev_s dev;
+ struct cdcser_driver_s drvr;
};
/****************************************************************************
@@ -138,114 +138,113 @@ struct usbser_alloc_s
/* Transfer helpers *********************************************************/
-static uint16_t usbclass_fillrequest(FAR struct usbser_dev_s *priv,
+static uint16_t cdcser_fillrequest(FAR struct cdcser_dev_s *priv,
uint8_t *reqbuf, uint16_t reqlen);
-static int usbclass_sndpacket(FAR struct usbser_dev_s *priv);
-static inline int usbclass_recvpacket(FAR struct usbser_dev_s *priv,
+static int cdcser_sndpacket(FAR struct cdcser_dev_s *priv);
+static inline int cdcser_recvpacket(FAR struct cdcser_dev_s *priv,
uint8_t *reqbuf, uint16_t reqlen);
/* Request helpers *********************************************************/
-static struct usbdev_req_s *usbclass_allocreq(FAR struct usbdev_ep_s *ep,
+static struct usbdev_req_s *cdcser_allocreq(FAR struct usbdev_ep_s *ep,
uint16_t len);
-static void usbclass_freereq(FAR struct usbdev_ep_s *ep,
+static void cdcser_freereq(FAR struct usbdev_ep_s *ep,
FAR struct usbdev_req_s *req);
/* Configuration ***********************************************************/
-static void usbclass_resetconfig(FAR struct usbser_dev_s *priv);
+static void cdcser_resetconfig(FAR struct cdcser_dev_s *priv);
#ifdef CONFIG_USBDEV_DUALSPEED
-static int usbclass_epconfigure(FAR struct usbdev_ep_s *ep,
+static int cdcser_epconfigure(FAR struct usbdev_ep_s *ep,
enum cdcser_epdesc_e epid, uint16_t mxpacket, bool last);
#endif
-static int usbclass_setconfig(FAR struct usbser_dev_s *priv,
+static int cdcser_setconfig(FAR struct cdcser_dev_s *priv,
uint8_t config);
/* Completion event handlers ***********************************************/
-static void usbclass_ep0incomplete(FAR struct usbdev_ep_s *ep,
+static void cdcser_ep0incomplete(FAR struct usbdev_ep_s *ep,
FAR struct usbdev_req_s *req);
-static void usbclass_rdcomplete(FAR struct usbdev_ep_s *ep,
+static void cdcser_rdcomplete(FAR struct usbdev_ep_s *ep,
FAR struct usbdev_req_s *req);
-static void usbclass_wrcomplete(FAR struct usbdev_ep_s *ep,
+static void cdcser_wrcomplete(FAR struct usbdev_ep_s *ep,
FAR struct usbdev_req_s *req);
/* USB class device ********************************************************/
-static int usbclass_bind(FAR struct usbdev_s *dev,
+static int cdcser_bind(FAR struct usbdev_s *dev,
FAR struct usbdevclass_driver_s *driver);
-static void usbclass_unbind(FAR struct usbdev_s *dev);
-static int usbclass_setup(FAR struct usbdev_s *dev,
+static void cdcser_unbind(FAR struct usbdev_s *dev);
+static int cdcser_setup(FAR struct usbdev_s *dev,
const struct usb_ctrlreq_s *ctrl);
-static void usbclass_disconnect(FAR struct usbdev_s *dev);
+static void cdcser_disconnect(FAR struct usbdev_s *dev);
-/* Serial port *************************************************************/
+/* UART Operationt **********************************************************/
-static int usbser_setup(FAR struct uart_dev_s *dev);
-static void usbser_shutdown(FAR struct uart_dev_s *dev);
-static int usbser_attach(FAR struct uart_dev_s *dev);
-static void usbser_detach(FAR struct uart_dev_s *dev);
-static int usbser_ioctl(FAR struct file *filep,int cmd,unsigned long arg);
-static void usbser_rxint(FAR struct uart_dev_s *dev, bool enable);
-static void usbser_txint(FAR struct uart_dev_s *dev, bool enable);
-static bool usbser_txempty(FAR struct uart_dev_s *dev);
+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);
+static void cdcuart_txint(FAR struct uart_dev_s *dev, bool enable);
+static bool cdcuart_txempty(FAR struct uart_dev_s *dev);
/****************************************************************************
* Private Variables
****************************************************************************/
-
-/* USB class device ********************************************************/
+/* USB class device *********************************************************/
static const struct usbdevclass_driverops_s g_driverops =
{
- usbclass_bind, /* bind */
- usbclass_unbind, /* unbind */
- usbclass_setup, /* setup */
- usbclass_disconnect, /* disconnect */
+ cdcser_bind, /* bind */
+ cdcser_unbind, /* unbind */
+ cdcser_setup, /* setup */
+ cdcser_disconnect, /* disconnect */
NULL, /* suspend */
NULL, /* resume */
};
-/* Serial port *************************************************************/
+/* Serial port **************************************************************/
static const struct uart_ops_s g_uartops =
{
- usbser_setup, /* setup */
- usbser_shutdown, /* shutdown */
- usbser_attach, /* attach */
- usbser_detach, /* detach */
- usbser_ioctl, /* ioctl */
+ cdcuart_setup, /* setup */
+ cdcuart_shutdown, /* shutdown */
+ cdcuart_attach, /* attach */
+ cdcuart_detach, /* detach */
+ cdcuart_ioctl, /* ioctl */
NULL, /* receive */
- usbser_rxint, /* rxinit */
+ cdcuart_rxint, /* rxinit */
NULL, /* rxavailable */
NULL, /* send */
- usbser_txint, /* txinit */
+ cdcuart_txint, /* txinit */
NULL, /* txready */
- usbser_txempty /* txempty */
+ cdcuart_txempty /* txempty */
};
/****************************************************************************
* Private Functions
****************************************************************************/
-/************************************************************************************
- * Name: usbclass_fillrequest
+/****************************************************************************
+ * Name: cdcser_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.
+ * 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.
+ * 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 usbclass_fillrequest(FAR struct usbser_dev_s *priv, uint8_t *reqbuf,
- uint16_t reqlen)
+static uint16_t cdcser_fillrequest(FAR struct cdcser_dev_s *priv, uint8_t *reqbuf,
+ uint16_t reqlen)
{
FAR uart_dev_t *serdev = &priv->serdev;
FAR struct uart_buffer_s *xmit = &serdev->xmit;
@@ -293,22 +292,22 @@ static uint16_t usbclass_fillrequest(FAR struct usbser_dev_s *priv, uint8_t *req
return nbytes;
}
-/************************************************************************************
- * Name: usbclass_sndpacket
+/****************************************************************************
+ * Name: cdcser_sndpacket
*
* Description:
- * This function obtains write requests, transfers the TX data into the request,
- * and submits the requests to the USB controller. This continues untils either
- * (1) there are no further packets available, or (2) thre is not further data
- * to send.
+ * This function obtains write requests, transfers the TX data into the
+ * request, and submits the requests to the USB controller. This continues
+ * untils either (1) there are no further packets available, or (2) thre is
+ * no further data to send.
*
- ************************************************************************************/
+ ****************************************************************************/
-static int usbclass_sndpacket(FAR struct usbser_dev_s *priv)
+static int cdcser_sndpacket(FAR struct cdcser_dev_s *priv)
{
FAR struct usbdev_ep_s *ep;
FAR struct usbdev_req_s *req;
- FAR struct usbser_req_s *reqcontainer;
+ FAR struct cdcser_req_s *reqcontainer;
irqstate_t flags;
int len;
int ret = OK;
@@ -327,7 +326,7 @@ static int usbclass_sndpacket(FAR struct usbser_dev_s *priv)
ep = priv->epbulkin;
- /* Loop until either (1) we run out or write requests, or (2) usbclass_fillrequest()
+ /* Loop until either (1) we run out or write requests, or (2) cdcser_fillrequest()
* is unable to fill the request with data (i.e., untilthere is no more data
* to be sent).
*/
@@ -340,12 +339,12 @@ static int usbclass_sndpacket(FAR struct usbser_dev_s *priv)
{
/* Peek at the request in the container at the head of the list */
- reqcontainer = (struct usbser_req_s *)sq_peek(&priv->reqlist);
+ reqcontainer = (struct cdcser_req_s *)sq_peek(&priv->reqlist);
req = reqcontainer->req;
/* Fill the request with serial TX data */
- len = usbclass_fillrequest(priv, req->buf, req->len);
+ len = cdcser_fillrequest(priv, req->buf, req->len);
if (len > 0)
{
/* Remove the empty container from the request list */
@@ -375,21 +374,21 @@ static int usbclass_sndpacket(FAR struct usbser_dev_s *priv)
return ret;
}
-/************************************************************************************
- * Name: usbclass_recvpacket
+/****************************************************************************
+ * Name: cdcser_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.
+ * 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 usbclass_recvpacket(FAR struct usbser_dev_s *priv,
- uint8_t *reqbuf, uint16_t reqlen)
+static inline int cdcser_recvpacket(FAR struct cdcser_dev_s *priv,
+ uint8_t *reqbuf, uint16_t reqlen)
{
FAR uart_dev_t *serdev = &priv->serdev;
FAR struct uart_buffer_s *recv = &serdev->recv;
@@ -487,15 +486,15 @@ static inline int usbclass_recvpacket(FAR struct usbser_dev_s *priv,
}
/****************************************************************************
- * Name: usbclass_allocreq
+ * Name: cdcser_allocreq
*
* Description:
* Allocate a request instance along with its buffer
*
****************************************************************************/
-static struct usbdev_req_s *usbclass_allocreq(FAR struct usbdev_ep_s *ep,
- uint16_t len)
+static struct usbdev_req_s *cdcser_allocreq(FAR struct usbdev_ep_s *ep,
+ uint16_t len)
{
FAR struct usbdev_req_s *req;
@@ -514,15 +513,15 @@ static struct usbdev_req_s *usbclass_allocreq(FAR struct usbdev_ep_s *ep,
}
/****************************************************************************
- * Name: usbclass_freereq
+ * Name: cdcser_freereq
*
* Description:
* Free a request instance along with its buffer
*
****************************************************************************/
-static void usbclass_freereq(FAR struct usbdev_ep_s *ep,
- FAR struct usbdev_req_s *req)
+static void cdcser_freereq(FAR struct usbdev_ep_s *ep,
+ FAR struct usbdev_req_s *req)
{
if (ep != NULL && req != NULL)
{
@@ -535,14 +534,14 @@ static void usbclass_freereq(FAR struct usbdev_ep_s *ep,
}
/****************************************************************************
- * Name: usbclass_resetconfig
+ * Name: cdcser_resetconfig
*
* Description:
* Mark the device as not configured and disable all endpoints.
*
****************************************************************************/
-static void usbclass_resetconfig(FAR struct usbser_dev_s *priv)
+static void cdcser_resetconfig(FAR struct cdcser_dev_s *priv)
{
/* Are we configured? */
@@ -563,7 +562,7 @@ static void usbclass_resetconfig(FAR struct usbser_dev_s *priv)
}
/****************************************************************************
- * Name: usbclass_epconfigure
+ * Name: cdcser_epconfigure
*
* Description:
* Configure one endpoint.
@@ -571,18 +570,18 @@ static void usbclass_resetconfig(FAR struct usbser_dev_s *priv)
****************************************************************************/
#ifdef CONFIG_USBDEV_DUALSPEED
-static int usbclass_epconfigure(FAR struct usbdev_ep_s *ep,
- enum cdcser_epdesc_e epid, uint16_t mxpacket,
- bool last)
+static int cdcser_epconfigure(FAR struct usbdev_ep_s *ep,
+ enum cdcser_epdesc_e epid, uint16_t mxpacket,
+ bool last)
{
struct usb_epdesc_s epdesc;
- usbclass_mkepdesc(epid, mxpacket, &epdesc);
+ cdcser_mkepdesc(epid, mxpacket, &epdesc);
return EP_CONFIGURE(ep, &epdesc, last);
}
#endif
/****************************************************************************
- * Name: usbclass_setconfig
+ * Name: cdcser_setconfig
*
* Description:
* Set the device configuration by allocating and configuring endpoints and
@@ -590,7 +589,7 @@ static int usbclass_epconfigure(FAR struct usbdev_ep_s *ep,
*
****************************************************************************/
-static int usbclass_setconfig(FAR struct usbser_dev_s *priv, uint8_t config)
+static int cdcser_setconfig(FAR struct cdcser_dev_s *priv, uint8_t config)
{
FAR struct usbdev_req_s *req;
int i;
@@ -614,7 +613,7 @@ static int usbclass_setconfig(FAR struct usbser_dev_s *priv, uint8_t config)
/* Discard the previous configuration data */
- usbclass_resetconfig(priv);
+ cdcser_resetconfig(priv);
/* Was this a request to simply discard the current configuration? */
@@ -637,14 +636,14 @@ static int usbclass_setconfig(FAR struct usbser_dev_s *priv, uint8_t config)
#ifdef CONFIG_USBDEV_DUALSPEED
if (priv->usbdev->speed == USB_SPEED_HIGH)
{
- ret = usbclass_epconfigure(priv->epintin, CDCSER_EPINTIN,
- CONFIG_CDCSER_EPINTIN_HSSIZE, false);
+ ret = cdcser_epconfigure(priv->epintin, CDCSER_EPINTIN,
+ CONFIG_CDCSER_EPINTIN_HSSIZE, false);
}
else
#endif
{
ret = EP_CONFIGURE(priv->epintin,
- usbclass_getepdesc(CDCSER_EPINTIN), false);
+ cdcser_getepdesc(CDCSER_EPINTIN), false);
}
if (ret < 0)
@@ -659,14 +658,14 @@ static int usbclass_setconfig(FAR struct usbser_dev_s *priv, uint8_t config)
#ifdef CONFIG_USBDEV_DUALSPEED
if (priv->usbdev->speed == USB_SPEED_HIGH)
{
- ret = usbclass_epconfigure(priv->epbulkin, CDCSER_EPBULKIN,
- CONFIG_CDCSER_EPBULKIN_HSSIZE, false);
+ ret = cdcser_epconfigure(priv->epbulkin, CDCSER_EPBULKIN,
+ CONFIG_CDCSER_EPBULKIN_HSSIZE, false);
}
else
#endif
{
ret = EP_CONFIGURE(priv->epbulkin,
- usbclass_getepdesc(CDCSER_EPBULKIN), false);
+ cdcser_getepdesc(CDCSER_EPBULKIN), false);
}
if (ret < 0)
@@ -682,14 +681,14 @@ static int usbclass_setconfig(FAR struct usbser_dev_s *priv, uint8_t config)
#ifdef CONFIG_USBDEV_DUALSPEED
if (priv->usbdev->speed == USB_SPEED_HIGH)
{
- ret = usbclass_epconfigure(priv->epbulkout, CDCSER_EPBULKOUT,
- CONFIG_CDCSER_EPBULKOUT_HSSIZE, true);
+ ret = cdcser_epconfigure(priv->epbulkout, CDCSER_EPBULKOUT,
+ CONFIG_CDCSER_EPBULKOUT_HSSIZE, true);
}
else
#endif
{
ret = EP_CONFIGURE(priv->epbulkout,
- usbclass_getepdesc(CDCSER_EPBULKOUT), true);
+ cdcser_getepdesc(CDCSER_EPBULKOUT), true);
}
if (ret < 0)
@@ -706,7 +705,7 @@ static int usbclass_setconfig(FAR struct usbser_dev_s *priv, uint8_t config)
for (i = 0; i < CONFIG_CDCSER_NRDREQS; i++)
{
req = priv->rdreqs[i].req;
- req->callback = usbclass_rdcomplete;
+ req->callback = cdcser_rdcomplete;
ret = EP_SUBMIT(priv->epbulkout, req);
if (ret != OK)
{
@@ -720,19 +719,19 @@ static int usbclass_setconfig(FAR struct usbser_dev_s *priv, uint8_t config)
return OK;
errout:
- usbclass_resetconfig(priv);
+ cdcser_resetconfig(priv);
return ret;
}
/****************************************************************************
- * Name: usbclass_ep0incomplete
+ * Name: cdcser_ep0incomplete
*
* Description:
* Handle completion of EP0 control operations
*
****************************************************************************/
-static void usbclass_ep0incomplete(FAR struct usbdev_ep_s *ep,
+static void cdcser_ep0incomplete(FAR struct usbdev_ep_s *ep,
FAR struct usbdev_req_s *req)
{
if (req->result || req->xfrd != req->len)
@@ -742,7 +741,7 @@ static void usbclass_ep0incomplete(FAR struct usbdev_ep_s *ep,
}
/****************************************************************************
- * Name: usbclass_rdcomplete
+ * Name: cdcser_rdcomplete
*
* Description:
* Handle completion of read request on the bulk OUT endpoint. This
@@ -750,10 +749,10 @@ static void usbclass_ep0incomplete(FAR struct usbdev_ep_s *ep,
*
****************************************************************************/
-static void usbclass_rdcomplete(FAR struct usbdev_ep_s *ep,
- FAR struct usbdev_req_s *req)
+static void cdcser_rdcomplete(FAR struct usbdev_ep_s *ep,
+ FAR struct usbdev_req_s *req)
{
- FAR struct usbser_dev_s *priv;
+ FAR struct cdcser_dev_s *priv;
irqstate_t flags;
int ret;
@@ -769,7 +768,7 @@ static void usbclass_rdcomplete(FAR struct usbdev_ep_s *ep,
/* Extract references to private data */
- priv = (FAR struct usbser_dev_s*)ep->priv;
+ priv = (FAR struct cdcser_dev_s*)ep->priv;
/* Process the received data unless this is some unusual condition */
@@ -778,7 +777,7 @@ static void usbclass_rdcomplete(FAR struct usbdev_ep_s *ep,
{
case 0: /* Normal completion */
usbtrace(TRACE_CLASSRDCOMPLETE, priv->nrdq);
- usbclass_recvpacket(priv, req->buf, req->xfrd);
+ cdcser_recvpacket(priv, req->buf, req->xfrd);
break;
case -ESHUTDOWN: /* Disconnection */
@@ -809,7 +808,7 @@ static void usbclass_rdcomplete(FAR struct usbdev_ep_s *ep,
}
/****************************************************************************
- * Name: usbclass_wrcomplete
+ * Name: cdcser_wrcomplete
*
* Description:
* Handle completion of write request. This function probably executes
@@ -817,11 +816,11 @@ static void usbclass_rdcomplete(FAR struct usbdev_ep_s *ep,
*
****************************************************************************/
-static void usbclass_wrcomplete(FAR struct usbdev_ep_s *ep,
- FAR struct usbdev_req_s *req)
+static void cdcser_wrcomplete(FAR struct usbdev_ep_s *ep,
+ FAR struct usbdev_req_s *req)
{
- FAR struct usbser_dev_s *priv;
- FAR struct usbser_req_s *reqcontainer;
+ FAR struct cdcser_dev_s *priv;
+ FAR struct cdcser_req_s *reqcontainer;
irqstate_t flags;
/* Sanity check */
@@ -836,8 +835,8 @@ static void usbclass_wrcomplete(FAR struct usbdev_ep_s *ep,
/* Extract references to our private data */
- priv = (FAR struct usbser_dev_s *)ep->priv;
- reqcontainer = (FAR struct usbser_req_s *)req->priv;
+ priv = (FAR struct cdcser_dev_s *)ep->priv;
+ reqcontainer = (FAR struct cdcser_req_s *)req->priv;
/* Return the write request to the free list */
@@ -854,7 +853,7 @@ static void usbclass_wrcomplete(FAR struct usbdev_ep_s *ep,
{
case OK: /* Normal completion */
usbtrace(TRACE_CLASSWRCOMPLETE, priv->nwrq);
- usbclass_sndpacket(priv);
+ cdcser_sndpacket(priv);
break;
case -ESHUTDOWN: /* Disconnection */
@@ -872,17 +871,17 @@ static void usbclass_wrcomplete(FAR struct usbdev_ep_s *ep,
****************************************************************************/
/****************************************************************************
- * Name: usbclass_bind
+ * Name: cdcser_bind
*
* Description:
* Invoked when the driver is bound to a USB device driver
*
****************************************************************************/
-static int usbclass_bind(FAR struct usbdev_s *dev, FAR struct usbdevclass_driver_s *driver)
+static int cdcser_bind(FAR struct usbdev_s *dev, FAR struct usbdevclass_driver_s *driver)
{
- FAR struct usbser_dev_s *priv = ((struct usbser_driver_s*)driver)->dev;
- FAR struct usbser_req_s *reqcontainer;
+ FAR struct cdcser_dev_s *priv = ((struct cdcser_driver_s*)driver)->dev;
+ FAR struct cdcser_req_s *reqcontainer;
irqstate_t flags;
uint16_t reqlen;
int ret;
@@ -897,17 +896,17 @@ static int usbclass_bind(FAR struct usbdev_s *dev, FAR struct usbdevclass_driver
/* Preallocate control request */
- priv->ctrlreq = usbclass_allocreq(dev->ep0, CDCSER_MXDESCLEN);
+ priv->ctrlreq = cdcser_allocreq(dev->ep0, CDCSER_MXDESCLEN);
if (priv->ctrlreq == NULL)
{
usbtrace(TRACE_CLSERROR(USBSER_TRACEERR_ALLOCCTRLREQ), 0);
ret = -ENOMEM;
goto errout;
}
- priv->ctrlreq->callback = usbclass_ep0incomplete;
+ priv->ctrlreq->callback = cdcser_ep0incomplete;
/* Pre-allocate all endpoints... the endpoints will not be functional
- * until the SET CONFIGURATION request is processed in usbclass_setconfig.
+ * until the SET CONFIGURATION request is processed in cdcser_setconfig.
* This is done here because there may be calls to kmalloc and the SET
* CONFIGURATION processing probably occurrs within interrupt handling
* logic where kmalloc calls will fail.
@@ -957,7 +956,7 @@ static int usbclass_bind(FAR struct usbdev_s *dev, FAR struct usbdevclass_driver
for (i = 0; i < CONFIG_CDCSER_NRDREQS; i++)
{
reqcontainer = &priv->rdreqs[i];
- reqcontainer->req = usbclass_allocreq(priv->epbulkout, reqlen);
+ reqcontainer->req = cdcser_allocreq(priv->epbulkout, reqlen);
if (reqcontainer->req == NULL)
{
usbtrace(TRACE_CLSERROR(USBSER_TRACEERR_RDALLOCREQ), -ENOMEM);
@@ -965,7 +964,7 @@ static int usbclass_bind(FAR struct usbdev_s *dev, FAR struct usbdevclass_driver
goto errout;
}
reqcontainer->req->priv = reqcontainer;
- reqcontainer->req->callback = usbclass_rdcomplete;
+ reqcontainer->req->callback = cdcser_rdcomplete;
}
/* Pre-allocate write request containers and put in a free list */
@@ -979,7 +978,7 @@ static int usbclass_bind(FAR struct usbdev_s *dev, FAR struct usbdevclass_driver
for (i = 0; i < CONFIG_CDCSER_NWRREQS; i++)
{
reqcontainer = &priv->wrreqs[i];
- reqcontainer->req = usbclass_allocreq(priv->epbulkin, reqlen);
+ reqcontainer->req = cdcser_allocreq(priv->epbulkin, reqlen);
if (reqcontainer->req == NULL)
{
usbtrace(TRACE_CLSERROR(USBSER_TRACEERR_WRALLOCREQ), -ENOMEM);
@@ -987,7 +986,7 @@ static int usbclass_bind(FAR struct usbdev_s *dev, FAR struct usbdevclass_driver
goto errout;
}
reqcontainer->req->priv = reqcontainer;
- reqcontainer->req->callback = usbclass_wrcomplete;
+ reqcontainer->req->callback = cdcser_wrcomplete;
flags = irqsave();
sq_addlast((sq_entry_t*)reqcontainer, &priv->reqlist);
@@ -1007,22 +1006,22 @@ static int usbclass_bind(FAR struct usbdev_s *dev, FAR struct usbdevclass_driver
return OK;
errout:
- usbclass_unbind(dev);
+ cdcser_unbind(dev);
return ret;
}
/****************************************************************************
- * Name: usbclass_unbind
+ * Name: cdcser_unbind
*
* Description:
* Invoked when the driver is unbound from a USB device driver
*
****************************************************************************/
-static void usbclass_unbind(FAR struct usbdev_s *dev)
+static void cdcser_unbind(FAR struct usbdev_s *dev)
{
- FAR struct usbser_dev_s *priv;
- FAR struct usbser_req_s *reqcontainer;
+ FAR struct cdcser_dev_s *priv;
+ FAR struct cdcser_req_s *reqcontainer;
irqstate_t flags;
int i;
@@ -1038,7 +1037,7 @@ static void usbclass_unbind(FAR struct usbdev_s *dev)
/* Extract reference to private data */
- priv = (FAR struct usbser_dev_s *)dev->ep0->priv;
+ priv = (FAR struct cdcser_dev_s *)dev->ep0->priv;
#ifdef CONFIG_DEBUG
if (!priv)
@@ -1054,12 +1053,12 @@ static void usbclass_unbind(FAR struct usbdev_s *dev)
{
/* 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 usbclass_resetconfig
+ * already have been reset. If not, then calling cdcser_resetconfig
* should cause the endpoints to immediately terminate all
* transfers and return the requests to us (with result == -ESHUTDOWN)
*/
- usbclass_resetconfig(priv);
+ cdcser_resetconfig(priv);
up_mdelay(50);
/* Free the interrupt IN endpoint */
@@ -1082,7 +1081,7 @@ static void usbclass_unbind(FAR struct usbdev_s *dev)
if (priv->ctrlreq != NULL)
{
- usbclass_freereq(dev->ep0, priv->ctrlreq);
+ cdcser_freereq(dev->ep0, priv->ctrlreq);
priv->ctrlreq = NULL;
}
@@ -1096,7 +1095,7 @@ static void usbclass_unbind(FAR struct usbdev_s *dev)
reqcontainer = &priv->rdreqs[i];
if (reqcontainer->req)
{
- usbclass_freereq(priv->epbulkout, reqcontainer->req);
+ cdcser_freereq(priv->epbulkout, reqcontainer->req);
reqcontainer->req = NULL;
}
}
@@ -1117,10 +1116,10 @@ static void usbclass_unbind(FAR struct usbdev_s *dev)
DEBUGASSERT(priv->nwrq == CONFIG_CDCSER_NWRREQS);
while (!sq_empty(&priv->reqlist))
{
- reqcontainer = (struct usbser_req_s *)sq_remfirst(&priv->reqlist);
+ reqcontainer = (struct cdcser_req_s *)sq_remfirst(&priv->reqlist);
if (reqcontainer->req != NULL)
{
- usbclass_freereq(priv->epbulkin, reqcontainer->req);
+ cdcser_freereq(priv->epbulkin, reqcontainer->req);
priv->nwrq--; /* Number of write requests queued */
}
}
@@ -1135,7 +1134,7 @@ static void usbclass_unbind(FAR struct usbdev_s *dev)
}
/****************************************************************************
- * Name: usbclass_setup
+ * Name: cdcser_setup
*
* Description:
* Invoked for ep0 control requests. This function probably executes
@@ -1143,9 +1142,9 @@ static void usbclass_unbind(FAR struct usbdev_s *dev)
*
****************************************************************************/
-static int usbclass_setup(FAR struct usbdev_s *dev, const struct usb_ctrlreq_s *ctrl)
+static int cdcser_setup(FAR struct usbdev_s *dev, const struct usb_ctrlreq_s *ctrl)
{
- FAR struct usbser_dev_s *priv;
+ FAR struct cdcser_dev_s *priv;
FAR struct usbdev_req_s *ctrlreq;
uint16_t value;
uint16_t index;
@@ -1163,7 +1162,7 @@ static int usbclass_setup(FAR struct usbdev_s *dev, const struct usb_ctrlreq_s *
/* Extract reference to private data */
usbtrace(TRACE_CLASSSETUP, ctrl->req);
- priv = (FAR struct usbser_dev_s *)dev->ep0->priv;
+ priv = (FAR struct cdcser_dev_s *)dev->ep0->priv;
#ifdef CONFIG_DEBUG
if (!priv || !priv->ctrlreq)
@@ -1204,7 +1203,7 @@ static int usbclass_setup(FAR struct usbdev_s *dev, const struct usb_ctrlreq_s *
case USB_DESC_TYPE_DEVICE:
{
ret = USB_SIZEOF_DEVDESC;
- memcpy(ctrlreq->buf, usbclass_getdevdesc(), ret);
+ memcpy(ctrlreq->buf, cdcser_getdevdesc(), ret);
}
break;
@@ -1212,7 +1211,7 @@ static int usbclass_setup(FAR struct usbdev_s *dev, const struct usb_ctrlreq_s *
case USB_DESC_TYPE_DEVICEQUALIFIER:
{
ret = USB_SIZEOF_QUALDESC;
- memcpy(ctrlreq->buf, usbclass_getqualdesc(), ret);
+ memcpy(ctrlreq->buf, cdcser_getqualdesc(), ret);
}
break;
@@ -1222,9 +1221,9 @@ static int usbclass_setup(FAR struct usbdev_s *dev, const struct usb_ctrlreq_s *
case USB_DESC_TYPE_CONFIG:
{
#ifdef CONFIG_USBDEV_DUALSPEED
- ret = usbclass_mkcfgdesc(ctrlreq->buf, dev->speed, ctrl->req);
+ ret = cdcser_mkcfgdesc(ctrlreq->buf, dev->speed, ctrl->req);
#else
- ret = usbclass_mkcfgdesc(ctrlreq->buf);
+ ret = cdcser_mkcfgdesc(ctrlreq->buf);
#endif
}
break;
@@ -1233,7 +1232,7 @@ static int usbclass_setup(FAR struct usbdev_s *dev, const struct usb_ctrlreq_s *
{
/* index == language code. */
- ret = usbclass_mkstrdesc(ctrl->value[0], (struct usb_strdesc_s *)ctrlreq->buf);
+ ret = cdcser_mkstrdesc(ctrl->value[0], (struct usb_strdesc_s *)ctrlreq->buf);
}
break;
@@ -1250,7 +1249,7 @@ static int usbclass_setup(FAR struct usbdev_s *dev, const struct usb_ctrlreq_s *
{
if (ctrl->type == 0)
{
- ret = usbclass_setconfig(priv, value);
+ ret = cdcser_setconfig(priv, value);
}
}
break;
@@ -1273,8 +1272,8 @@ static int usbclass_setup(FAR struct usbdev_s *dev, const struct usb_ctrlreq_s *
index == CDCSER_INTERFACEID &&
value == CDCSER_ALTINTERFACEID)
{
- usbclass_resetconfig(priv);
- usbclass_setconfig(priv, priv->config);
+ cdcser_resetconfig(priv);
+ cdcser_setconfig(priv, priv->config);
ret = 0;
}
}
@@ -1431,14 +1430,14 @@ static int usbclass_setup(FAR struct usbdev_s *dev, const struct usb_ctrlreq_s *
{
usbtrace(TRACE_CLSERROR(USBSER_TRACEERR_EPRESPQ), (uint16_t)-ret);
ctrlreq->result = OK;
- usbclass_ep0incomplete(dev->ep0, ctrlreq);
+ cdcser_ep0incomplete(dev->ep0, ctrlreq);
}
}
return ret;
}
/****************************************************************************
- * Name: usbclass_disconnect
+ * Name: cdcser_disconnect
*
* Description:
* Invoked after all transfers have been stopped, when the host is
@@ -1447,9 +1446,9 @@ static int usbclass_setup(FAR struct usbdev_s *dev, const struct usb_ctrlreq_s *
*
****************************************************************************/
-static void usbclass_disconnect(FAR struct usbdev_s *dev)
+static void cdcser_disconnect(FAR struct usbdev_s *dev)
{
- FAR struct usbser_dev_s *priv;
+ FAR struct cdcser_dev_s *priv;
irqstate_t flags;
usbtrace(TRACE_CLASSDISCONNECT, 0);
@@ -1464,7 +1463,7 @@ static void usbclass_disconnect(FAR struct usbdev_s *dev)
/* Extract reference to private data */
- priv = (FAR struct usbser_dev_s *)dev->ep0->priv;
+ priv = (FAR struct cdcser_dev_s *)dev->ep0->priv;
#ifdef CONFIG_DEBUG
if (!priv)
@@ -1477,7 +1476,7 @@ static void usbclass_disconnect(FAR struct usbdev_s *dev)
/* Reset the configuration */
flags = irqsave();
- usbclass_resetconfig(priv);
+ cdcser_resetconfig(priv);
/* Clear out all data in the circular buffer */
@@ -1497,16 +1496,16 @@ static void usbclass_disconnect(FAR struct usbdev_s *dev)
****************************************************************************/
/****************************************************************************
- * Name: usbser_setup
+ * Name: cdcuart_setup
*
* Description:
* This method is called the first time that the serial port is opened.
*
****************************************************************************/
-static int usbser_setup(FAR struct uart_dev_s *dev)
+static int cdcuart_setup(FAR struct uart_dev_s *dev)
{
- FAR struct usbser_dev_s *priv;
+ FAR struct cdcser_dev_s *priv;
usbtrace(CDCSER_CLASSAPI_SETUP, 0);
@@ -1522,7 +1521,7 @@ static int usbser_setup(FAR struct uart_dev_s *dev)
/* Extract reference to private data */
- priv = (FAR struct usbser_dev_s*)dev->priv;
+ priv = (FAR struct cdcser_dev_s*)dev->priv;
/* Check if we have been configured */
@@ -1536,18 +1535,18 @@ static int usbser_setup(FAR struct uart_dev_s *dev)
}
/****************************************************************************
- * Name: usbser_shutdown
+ * 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
- * usbser_txempty() until that function returns true before calling this
+ * cdcuart_txempty() until that function returns true before calling this
* function.
*
****************************************************************************/
-static void usbser_shutdown(FAR struct uart_dev_s *dev)
+static void cdcuart_shutdown(FAR struct uart_dev_s *dev)
{
usbtrace(CDCSER_CLASSAPI_SHUTDOWN, 0);
@@ -1562,44 +1561,44 @@ static void usbser_shutdown(FAR struct uart_dev_s *dev)
}
/****************************************************************************
- * Name: usbser_attach
+ * Name: cdcuart_attach
*
* Description:
* Does not apply to the USB serial class device
*
****************************************************************************/
-static int usbser_attach(FAR struct uart_dev_s *dev)
+static int cdcuart_attach(FAR struct uart_dev_s *dev)
{
usbtrace(CDCSER_CLASSAPI_ATTACH, 0);
return OK;
}
/****************************************************************************
- * Name: usbser_detach
+ * Name: cdcuart_detach
*
* Description:
* Does not apply to the USB serial class device
*
****************************************************************************/
-static void usbser_detach(FAR struct uart_dev_s *dev)
+static void cdcuart_detach(FAR struct uart_dev_s *dev)
{
usbtrace(CDCSER_CLASSAPI_DETACH, 0);
}
/****************************************************************************
- * Name: usbser_ioctl
+ * Name: cdcuart_ioctl
*
* Description:
* All ioctl calls will be routed through this method
*
****************************************************************************/
-static int usbser_ioctl(FAR struct file *filep,int cmd,unsigned long arg)
+static int cdcuart_ioctl(FAR struct file *filep,int cmd,unsigned long arg)
{
struct inode *inode = filep->f_inode;
- struct usbser_dev_s *priv = inode->i_private;
+ struct cdcser_dev_s *priv = inode->i_private;
int ret = OK;
switch (cmd)
@@ -1701,25 +1700,25 @@ static int usbser_ioctl(FAR struct file *filep,int cmd,unsigned long arg)
}
/****************************************************************************
- * Name: usbser_rxint
+ * 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 usbser_setup
- * and usbser_attach are called called)
+ * 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 usbser_detach
- * and usbser_shutdown are called).
+ * 3. With enable==false when the port is closed (just before cdcuart_detach
+ * and cdcuart_shutdown are called).
*
****************************************************************************/
-static void usbser_rxint(FAR struct uart_dev_s *dev, bool enable)
+static void cdcuart_rxint(FAR struct uart_dev_s *dev, bool enable)
{
- FAR struct usbser_dev_s *priv;
+ FAR struct cdcser_dev_s *priv;
FAR uart_dev_t *serdev;
irqstate_t flags;
@@ -1737,7 +1736,7 @@ static void usbser_rxint(FAR struct uart_dev_s *dev, bool enable)
/* Extract reference to private data */
- priv = (FAR struct usbser_dev_s*)dev->priv;
+ priv = (FAR struct cdcser_dev_s*)dev->priv;
serdev = &priv->serdev;
/* We need exclusive access to the RX buffer and private structure
@@ -1797,7 +1796,7 @@ static void usbser_rxint(FAR struct uart_dev_s *dev, bool enable)
}
/****************************************************************************
- * Name: usbser_txint
+ * Name: cdcuart_txint
*
* Description:
* Called by the serial driver to enable or disable TX interrupts. We, of
@@ -1810,9 +1809,9 @@ static void usbser_rxint(FAR struct uart_dev_s *dev, bool enable)
*
****************************************************************************/
-static void usbser_txint(FAR struct uart_dev_s *dev, bool enable)
+static void cdcuart_txint(FAR struct uart_dev_s *dev, bool enable)
{
- FAR struct usbser_dev_s *priv;
+ FAR struct cdcser_dev_s *priv;
usbtrace(CDCSER_CLASSAPI_TXINT, (uint16_t)enable);
@@ -1828,7 +1827,7 @@ static void usbser_txint(FAR struct uart_dev_s *dev, bool enable)
/* Extract references to private data */
- priv = (FAR struct usbser_dev_s*)dev->priv;
+ priv = (FAR struct cdcser_dev_s*)dev->priv;
/* If the new state is enabled and if there is data in the XMIT buffer,
* send the next packet now.
@@ -1839,12 +1838,12 @@ static void usbser_txint(FAR struct uart_dev_s *dev, bool enable)
if (enable && priv->serdev.xmit.head != priv->serdev.xmit.tail)
{
- usbclass_sndpacket(priv);
+ cdcser_sndpacket(priv);
}
}
/****************************************************************************
- * Name: usbser_txempty
+ * Name: cdcuart_txempty
*
* Description:
* Return true when all data has been sent. This is called from the
@@ -1855,9 +1854,9 @@ static void usbser_txint(FAR struct uart_dev_s *dev, bool enable)
*
****************************************************************************/
-static bool usbser_txempty(FAR struct uart_dev_s *dev)
+static bool cdcuart_txempty(FAR struct uart_dev_s *dev)
{
- FAR struct usbser_dev_s *priv = (FAR struct usbser_dev_s*)dev->priv;
+ FAR struct cdcser_dev_s *priv = (FAR struct cdcser_dev_s*)dev->priv;
usbtrace(CDCSER_CLASSAPI_TXEMPTY, 0);
@@ -1897,15 +1896,15 @@ static bool usbser_txempty(FAR struct uart_dev_s *dev)
int cdcser_initialize(int minor)
{
- FAR struct usbser_alloc_s *alloc;
- FAR struct usbser_dev_s *priv;
- FAR struct usbser_driver_s *drvr;
+ FAR struct cdcser_alloc_s *alloc;
+ FAR struct cdcser_dev_s *priv;
+ FAR struct cdcser_driver_s *drvr;
char devname[16];
int ret;
/* Allocate the structures needed */
- alloc = (FAR struct usbser_alloc_s*)kmalloc(sizeof(struct usbser_alloc_s));
+ alloc = (FAR struct cdcser_alloc_s*)kmalloc(sizeof(struct cdcser_alloc_s));
if (!alloc)
{
usbtrace(TRACE_CLSERROR(USBSER_TRACEERR_ALLOCDEVSTRUCT), 0);
@@ -1919,7 +1918,7 @@ int cdcser_initialize(int minor)
/* Initialize the USB serial driver structure */
- memset(priv, 0, sizeof(struct usbser_dev_s));
+ memset(priv, 0, sizeof(struct cdcser_dev_s));
sq_init(&priv->reqlist);
/* Fake line status */
diff --git a/drivers/usbdev/usbdev_storage.c b/drivers/usbdev/usbdev_storage.c
index 029cd748e9436d2e12358edf73735b497021c5e9..f2bd03b02bd106ba9048e49253e3ff220dd6bb75 100644
--- a/drivers/usbdev/usbdev_storage.c
+++ b/drivers/usbdev/usbdev_storage.c
@@ -118,12 +118,6 @@ static struct usbdev_req_s *usbstrg_allocreq(FAR struct usbdev_ep_s *ep,
uint16_t len);
static void usbstrg_freereq(FAR struct usbdev_ep_s *ep,
FAR struct usbdev_req_s *req);
-static int usbstrg_mkstrdesc(uint8_t id, struct usb_strdesc_s *strdesc);
-#ifdef CONFIG_USBDEV_DUALSPEED
-static int16_t usbstrg_mkcfgdesc(uint8_t *buf, uint8_t speed, uint8_t type);
-#else
-static int16_t usbstrg_mkcfgdesc(uint8_t *buf);
-#endif
/* Class Driver Operations (most at interrupt level) ************************/
@@ -154,125 +148,9 @@ static struct usbdevclass_driverops_s g_driverops =
NULL /* resume */
};
-/* Descriptors **************************************************************/
-
-/* Device descriptor */
-
-static const struct usb_devdesc_s g_devdesc =
-{
- USB_SIZEOF_DEVDESC, /* len */
- USB_DESC_TYPE_DEVICE, /* type */
- {LSBYTE(0x0200), MSBYTE(0x0200)}, /* usb */
- USB_CLASS_PER_INTERFACE, /* class */
- 0, /* subclass */
- 0, /* protocol */
- CONFIG_USBSTRG_EP0MAXPACKET, /* maxpacketsize */
- { LSBYTE(CONFIG_USBSTRG_VENDORID), /* vendor */
- MSBYTE(CONFIG_USBSTRG_VENDORID) },
- { LSBYTE(CONFIG_USBSTRG_PRODUCTID), /* product */
- MSBYTE(CONFIG_USBSTRG_PRODUCTID) },
- { LSBYTE(CONFIG_USBSTRG_VERSIONNO), /* device */
- MSBYTE(CONFIG_USBSTRG_VERSIONNO) },
- USBSTRG_MANUFACTURERSTRID, /* imfgr */
- USBSTRG_PRODUCTSTRID, /* iproduct */
- USBSTRG_SERIALSTRID, /* serno */
- USBSTRG_NCONFIGS /* nconfigs */
-};
-
-/* Configuration descriptor */
-
-static const struct usb_cfgdesc_s g_cfgdesc =
-{
- USB_SIZEOF_CFGDESC, /* len */
- USB_DESC_TYPE_CONFIG, /* type */
- {0, 0}, /* totallen -- to be provided */
- USBSTRG_NINTERFACES, /* ninterfaces */
- USBSTRG_CONFIGID, /* cfgvalue */
- USBSTRG_CONFIGSTRID, /* icfg */
- USB_CONFIG_ATTR_ONE|SELFPOWERED|REMOTEWAKEUP, /* attr */
- (CONFIG_USBDEV_MAXPOWER + 1) / 2 /* mxpower */
-};
-
-/* Single interface descriptor */
-
-static const struct usb_ifdesc_s g_ifdesc =
-{
- USB_SIZEOF_IFDESC, /* len */
- USB_DESC_TYPE_INTERFACE, /* type */
- USBSTRG_INTERFACEID, /* ifno */
- USBSTRG_ALTINTERFACEID, /* alt */
- USBSTRG_NENDPOINTS, /* neps */
- USB_CLASS_MASS_STORAGE, /* class */
- USBSTRG_SUBCLASS_SCSI, /* subclass */
- USBSTRG_PROTO_BULKONLY, /* protocol */
- USBSTRG_CONFIGSTRID /* iif */
-};
-
-/* Endpoint descriptors */
-
-static const struct usb_epdesc_s g_fsepbulkoutdesc =
-{
- USB_SIZEOF_EPDESC, /* len */
- USB_DESC_TYPE_ENDPOINT, /* type */
- USBSTRG_EPOUTBULK_ADDR, /* addr */
- USBSTRG_EPOUTBULK_ATTR, /* attr */
- { LSBYTE(USBSTRG_FSBULKMAXPACKET), /* maxpacket */
- MSBYTE(USBSTRG_FSBULKMAXPACKET) },
- 0 /* interval */
-};
-
-static const struct usb_epdesc_s g_fsepbulkindesc =
-{
- USB_SIZEOF_EPDESC, /* len */
- USB_DESC_TYPE_ENDPOINT, /* type */
- USBSTRG_EPINBULK_ADDR, /* addr */
- USBSTRG_EPINBULK_ATTR, /* attr */
- { LSBYTE(USBSTRG_FSBULKMAXPACKET), /* maxpacket */
- MSBYTE(USBSTRG_FSBULKMAXPACKET) },
- 0 /* interval */
-};
-
-#ifdef CONFIG_USBDEV_DUALSPEED
-static const struct usb_qualdesc_s g_qualdesc =
-{
- USB_SIZEOF_QUALDESC, /* len */
- USB_DESC_TYPE_DEVICEQUALIFIER, /* type */
- {LSBYTE(0x0200), MSBYTE(0x0200) }, /* USB */
- USB_CLASS_PER_INTERFACE, /* class */
- 0, /* subclass */
- 0, /* protocol */
- CONFIG_USBSTRG_EP0MAXPACKET, /* mxpacketsize */
- USBSTRG_NCONFIGS, /* nconfigs */
- 0, /* reserved */
-};
-
-static const struct usb_epdesc_s g_hsepbulkoutdesc =
-{
- USB_SIZEOF_EPDESC, /* len */
- USB_DESC_TYPE_ENDPOINT, /* type */
- USBSTRG_EPOUTBULK_ADDR, /* addr */
- USBSTRG_EPOUTBULK_ATTR, /* attr */
- { LSBYTE(USBSTRG_HSBULKMAXPACKET), /* maxpacket */
- MSBYTE(USBSTRG_HSBULKMAXPACKET) },
- 0 /* interval */
-};
-
-static const struct usb_epdesc_s g_hsepbulkindesc =
-{
- USB_SIZEOF_EPDESC, /* len */
- USB_DESC_TYPE_ENDPOINT, /* type */
- USBSTRG_EPINBULK_ADDR, /* addr */
- USBSTRG_EPINBULK_ATTR, /* attr */
- { LSBYTE(USBSTRG_HSBULKMAXPACKET), /* maxpacket */
- MSBYTE(USBSTRG_HSBULKMAXPACKET) },
- 0 /* interval */
-};
-#endif
-
/****************************************************************************
* Public Data
****************************************************************************/
-
/* String *******************************************************************/
const char g_vendorstr[] = CONFIG_USBSTRG_VENDORSTR;
@@ -351,141 +229,6 @@ static void usbstrg_freereq(FAR struct usbdev_ep_s *ep, struct usbdev_req_s *req
}
}
-/****************************************************************************
- * Name: usbstrg_mkstrdesc
- *
- * Description:
- * Construct a string descriptor
- *
- ****************************************************************************/
-
-static int usbstrg_mkstrdesc(uint8_t id, struct usb_strdesc_s *strdesc)
-{
- const char *str;
- int len;
- int ndata;
- int i;
-
- switch (id)
- {
- case 0:
- {
- /* Descriptor 0 is the language id */
-
- strdesc->len = 4;
- strdesc->type = USB_DESC_TYPE_STRING;
- strdesc->data[0] = LSBYTE(USBSTRG_STR_LANGUAGE);
- strdesc->data[1] = MSBYTE(USBSTRG_STR_LANGUAGE);
- return 4;
- }
-
- case USBSTRG_MANUFACTURERSTRID:
- str = g_vendorstr;
- break;
-
- case USBSTRG_PRODUCTSTRID:
- str = g_productstr;
- break;
-
- case USBSTRG_SERIALSTRID:
- str = g_serialstr;
- break;
-
- case USBSTRG_CONFIGSTRID:
- str = CONFIG_USBSTRG_CONFIGSTR;
- break;
-
- default:
- return -EINVAL;
- }
-
- /* The string is utf16-le. The poor man's utf-8 to utf16-le
- * conversion below will only handle 7-bit en-us ascii
- */
-
- len = strlen(str);
- for (i = 0, ndata = 0; i < len; i++, ndata += 2)
- {
- strdesc->data[ndata] = str[i];
- strdesc->data[ndata+1] = 0;
- }
-
- strdesc->len = ndata+2;
- strdesc->type = USB_DESC_TYPE_STRING;
- return strdesc->len;
-}
-
-/****************************************************************************
- * Name: usbstrg_mkcfgdesc
- *
- * Description:
- * Construct the configuration descriptor
- *
- ****************************************************************************/
-
-#ifdef CONFIG_USBDEV_DUALSPEED
-static int16_t usbstrg_mkcfgdesc(uint8_t *buf, uint8_t speed, uint8_t type)
-#else
-static int16_t usbstrg_mkcfgdesc(uint8_t *buf)
-#endif
-{
- FAR struct usb_cfgdesc_s *cfgdesc = (struct usb_cfgdesc_s*)buf;
-#ifdef CONFIG_USBDEV_DUALSPEED
- FAR const struct usb_epdesc_s *epdesc;
- bool hispeed = (speed == USB_SPEED_HIGH);
- uint16_t bulkmxpacket;
-#endif
- uint16_t totallen;
-
- /* This is the total length of the configuration (not necessarily the
- * size that we will be sending now.
- */
-
- totallen = USB_SIZEOF_CFGDESC + USB_SIZEOF_IFDESC + USBSTRG_NENDPOINTS * USB_SIZEOF_EPDESC;
-
- /* Configuration descriptor -- Copy the canned descriptor and fill in the
- * type (we'll also need to update the size below
- */
-
- memcpy(cfgdesc, &g_cfgdesc, USB_SIZEOF_CFGDESC);
- buf += USB_SIZEOF_CFGDESC;
-
- /* Copy the canned interface descriptor */
-
- memcpy(buf, &g_ifdesc, USB_SIZEOF_IFDESC);
- buf += USB_SIZEOF_IFDESC;
-
- /* Make the two endpoint configurations */
-
-#ifdef CONFIG_USBDEV_DUALSPEED
- /* Check for switches between high and full speed */
-
- hispeed = (speed == USB_SPEED_HIGH);
- if (type == USB_DESC_TYPE_OTHERSPEEDCONFIG)
- {
- hispeed = !hispeed;
- }
-
- bulkmxpacket = USBSTRG_BULKMAXPACKET(hispeed);
- epdesc = USBSTRG_EPBULKINDESC(hispeed);
- memcpy(buf, epdesc, USB_SIZEOF_EPDESC);
- buf += USB_SIZEOF_EPDESC;
-
- epdesc = USBSTRG_EPBULKOUTDESC(hispeed);
- memcpy(buf, epdesc, USB_SIZEOF_EPDESC);
-#else
- memcpy(buf, &g_fsepbulkoutdesc, USB_SIZEOF_EPDESC);
- buf += USB_SIZEOF_EPDESC;
- memcpy(buf, &g_fsepbulkindesc, USB_SIZEOF_EPDESC);
-#endif
-
- /* Finally, fill in the total size of the configuration descriptor */
-
- cfgdesc->totallen[0] = LSBYTE(totallen);
- cfgdesc->totallen[1] = MSBYTE(totallen);
- return totallen;
-}
-
/****************************************************************************
* Class Driver Interfaces
****************************************************************************/
@@ -795,7 +538,7 @@ static int usbstrg_setup(FAR struct usbdev_s *dev,
case USB_DESC_TYPE_DEVICE:
{
ret = USB_SIZEOF_DEVDESC;
- memcpy(ctrlreq->buf, &g_devdesc, ret);
+ memcpy(ctrlreq->buf, usbstrg_getdevdesc(), ret);
}
break;
@@ -803,7 +546,7 @@ static int usbstrg_setup(FAR struct usbdev_s *dev,
case USB_DESC_TYPE_DEVICEQUALIFIER:
{
ret = USB_SIZEOF_QUALDESC;
- memcpy(ctrlreq->buf, &g_qualdesc, ret);
+ memcpy(ctrlreq->buf, usbstrg_getqualdesc(), ret);
}
break;
@@ -1151,7 +894,8 @@ int usbstrg_setconfig(FAR struct usbstrg_dev_s *priv, uint8_t config)
epdesc = USBSTRG_EPBULKINDESC(hispeed);
ret = EP_CONFIGURE(priv->epbulkin, epdesc, false);
#else
- ret = EP_CONFIGURE(priv->epbulkin, &g_fsepbulkindesc, false);
+ ret = EP_CONFIGURE(priv->epbulkin,
+ usbstrg_getepdesc(USBSTRG_EPFSBULKIN), false);
#endif
if (ret < 0)
{
@@ -1167,7 +911,8 @@ int usbstrg_setconfig(FAR struct usbstrg_dev_s *priv, uint8_t config)
epdesc = USBSTRG_EPBULKOUTDESC(hispeed);
ret = EP_CONFIGURE(priv->epbulkout, epdesc, true);
#else
- ret = EP_CONFIGURE(priv->epbulkout, &g_fsepbulkoutdesc, true);
+ ret = EP_CONFIGURE(priv->epbulkout,
+ usbstrg_getepdesc(USBSTRG_EPFSBULKOUT), true);
#endif
if (ret < 0)
{
diff --git a/drivers/usbdev/usbdev_storage.h b/drivers/usbdev/usbdev_storage.h
index 320c78ccde3b50e8d68abb3b28d59e8b50c72ab4..77cc0e53c92cfa9fdc83df0b7c92f5740275da0d 100644
--- a/drivers/usbdev/usbdev_storage.h
+++ b/drivers/usbdev/usbdev_storage.h
@@ -1,7 +1,7 @@
/****************************************************************************
* drivers/usbdev/usbdev_storage.h
*
- * Copyright (C) 2008-2010 Gregory Nutt. All rights reserved.
+ * Copyright (C) 2008-2011 Gregory Nutt. All rights reserved.
* Author: Gregory Nutt <spudmonkey@racsa.co.cr>
*
* Mass storage class device. Bulk-only with SCSI subclass.
@@ -57,9 +57,7 @@
/****************************************************************************
* Definitions
****************************************************************************/
-
/* Configuration ************************************************************/
-
/* Number of requests in the write queue */
#ifndef CONFIG_USBSTRG_NWRREQS
@@ -303,9 +301,11 @@
/* Macros for dual speed vs. full speed only operation */
-#ifdef CONFIG_USBDEV_DUALSPEED
-# define USBSTRG_EPBULKINDESC(hs) ((hs) ? (&g_hsepbulkindesc) : (&g_fsepbulkindesc))
-# define USBSTRG_EPBULKOUTDESC(hs) ((hs) ? (&g_hsepbulkoutdesc) : (&g_fsepbulkoutdesc))
+#ifdef CONFIG_USBDEV_DUALSPEED
+# define USBSTRG_EPBULKINDESC(hs) \
+ usbstrg_getepdesc((hs) ? USBSTRG_EPHSBULKIN : USBSTRG_EPFSBULKIN)
+# define USBSTRG_EPBULKOUTDESC(hs) \
+ usbstrg_getepdesc((hs) ? USBSTRG_EPHSBULKOUT : USBSTRG_EPFSBULKOUT)
# define USBSTRG_BULKMAXPACKET(hs) \
((hs) ? USBSTRG_HSBULKMAXPACKET : USBSTRG_FSBULKMAXPACKET)
# define USBSTRG_BULKMXPKTSHIFT(d) \
@@ -313,8 +313,8 @@
# define USBSTRG_BULKMXPKTMASK(d) \
(((d)->speed==USB_SPEED_HIGH) ? USBSTRG_HSBULKMXPKTMASK : USBSTRG_FSBULKMXPKTMASK)
#else
-# define USBSTRG_EPBULKINDESC(d) (g_fsepbulkindesc))
-# define USBSTRG_EPBULKOUTDESC(d) (g_fsepbulkoutdesc))
+# define USBSTRG_EPBULKINDESC(d) usbstrg_getepdesc(USBSTRG_EPFSBULKIN)
+# define USBSTRG_EPBULKOUTDESC(d) usbstrg_getepdesc(USBSTRG_EPFSBULKOUT)
# define USBSTRG_BULKMAXPACKET(hs) USBSTRG_FSBULKMAXPACKET
# define USBSTRG_BULKMXPKTSHIFT(d) USBSTRG_FSBULKMXPKTSHIFT
# define USBSTRG_BULKMXPKTMASK(d) USBSTRG_FSBULKMXPKTMASK
@@ -339,6 +339,18 @@
/****************************************************************************
* Public Types
****************************************************************************/
+/* Endpoint descriptors */
+
+enum usbstrg_epdesc_e
+{
+ USBSTRG_EPFSBULKOUT = 0, /* Full speed bulk OUT endpoint descriptor */
+ USBSTRG_EPFSBULKIN /* Full speed bulk IN endpoint descriptor */
+#ifdef CONFIG_USBDEV_DUALSPEED
+ ,
+ USBSTRG_EPHSBULKOUT, /* High speed bulk OUT endpoint descriptor */
+ USBSTRG_EPHSBULKIN /* High speed bulk IN endpoint descriptor */
+#endif
+};
/* Container to support a list of requests */
@@ -450,6 +462,64 @@ EXTERN const char g_serialstr[];
* Public Function Prototypes
************************************************************************************/
+/************************************************************************************
+ * Name: usbstrg_mkstrdesc
+ *
+ * Description:
+ * Construct a string descriptor
+ *
+ ************************************************************************************/
+
+struct usb_strdesc_s;
+int usbstrg_mkstrdesc(uint8_t id, struct usb_strdesc_s *strdesc);
+
+/************************************************************************************
+ * Name: usbstrg_getepdesc
+ *
+ * Description:
+ * Return a pointer to the raw device descriptor
+ *
+ ************************************************************************************/
+
+FAR const struct usb_devdesc_s *usbstrg_getdevdesc(void);
+
+/************************************************************************************
+ * Name: usbstrg_getepdesc
+ *
+ * Description:
+ * Return a pointer to the raw endpoint descriptor (used for configuring endpoints)
+ *
+ ************************************************************************************/
+
+struct usb_epdesc_s;
+FAR const struct usb_epdesc_s *usbstrg_getepdesc(enum usbstrg_epdesc_e epid);
+
+/************************************************************************************
+ * Name: usbstrg_mkcfgdesc
+ *
+ * Description:
+ * Construct the configuration descriptor
+ *
+ ************************************************************************************/
+
+#ifdef CONFIG_USBDEV_DUALSPEED
+int16_t usbstrg_mkcfgdesc(FAR uint8_t *buf, uint8_t speed, uint8_t type);
+#else
+int16_t usbstrg_mkcfgdesc(FAR uint8_t *buf);
+#endif
+
+/************************************************************************************
+ * Name: usbstrg_getqualdesc
+ *
+ * Description:
+ * Return a pointer to the raw qual descriptor
+ *
+ ************************************************************************************/
+
+#ifdef CONFIG_USBDEV_DUALSPEED
+FAR const struct usb_qualdesc_s *usbstrg_getqualdesc(void);
+#endif
+
/****************************************************************************
* Name: usbstrg_workerthread
*
diff --git a/fs/fat/fs_fat32dirent.c b/fs/fat/fs_fat32dirent.c
index 0627b9bba648759788df1b138f7551fad9410b4a..6dfdc2022d748eb7290a2d1578fa76df27b3d1ae 100644
--- a/fs/fat/fs_fat32dirent.c
+++ b/fs/fat/fs_fat32dirent.c
@@ -1123,25 +1123,31 @@ static bool fat_cmplfname(const uint8_t *direntry, const uint8_t *substr)
int len;
bool match;
- /* How much of string do we have to compare? (including the NUL
- * terminator).
- */
+ /* How much of string do we have to compare? */
- len = strlen((char*)substr) + 1;
+ len = strlen((char*)substr);
/* Check bytes 1-5 */
chunk = LDIR_PTRWCHAR1_5(direntry);
match = fat_cmplfnchunk(chunk, substr, 5);
- if (match && len > 5)
+ if (match && len >= 5)
{
- /* Check bytes 6-11 */
+ /* Check bytes 6-11. Note that len == 5, the substring passed to
+ * fat_cmplfnchunk() will point to the NUL terminator of substr.
+ * In this case, fat_cmplfnchunk() will only verify that the
+ * directory entry is also NUL terminated.
+ */
chunk = LDIR_PTRWCHAR6_11(direntry);
match = fat_cmplfnchunk(chunk, &substr[5], 6);
- if (match && len > 11)
+ if (match && len >= 11)
{
- /* Check bytes 12-13 */
+ /* Check bytes 12-13. Note that len == 11, the substring passed to
+ * fat_cmplfnchunk() will point to the NUL terminator of substr.
+ * In this case, fat_cmplfnchunk() will only verify that the
+ * directory entry is also NUL terminated.
+ */
chunk = LDIR_PTRWCHAR12_13(direntry);
match = fat_cmplfnchunk(chunk, &substr[11], 2);
@@ -1181,11 +1187,9 @@ static inline int fat_findlfnentry(struct fat_mountpt_s *fs,
/* Get the length of the long file name (size of the fd_lfname array is
* LDIR_MAXFNAME+1 we do not have to check the length of the string).
- * NOTE that the name length is incremented to include the NUL terminating
- * character that must also be written to the directory entry.
*/
- namelen = strlen((char*)dirinfo->fd_lfname) + 1;
+ namelen = strlen((char*)dirinfo->fd_lfname);
DEBUGASSERT(namelen <= LDIR_MAXFNAME+1);
/* How many LFN directory entries are we expecting? */
@@ -1483,11 +1487,9 @@ static inline int fat_allocatelfnentry(struct fat_mountpt_s *fs,
/* Get the length of the long file name (size of the fd_lfname array is
* LDIR_MAXFNAME+1 we do not have to check the length of the string).
- * NOTE that the name length is incremented to include the NUL terminating
- * character that must also be written to the directory entry.
*/
- namelen = strlen((char *)dirinfo->fd_lfname) + 1;
+ namelen = strlen((char *)dirinfo->fd_lfname);
DEBUGASSERT(namelen <= LDIR_MAXFNAME+1);
/* How many LFN directory entries are we expecting? */
@@ -2018,11 +2020,13 @@ static int fat_putlfname(struct fat_mountpt_s *fs, struct fat_dirinfo_s *dirinfo
/* Get the length of the long file name (size of the fd_lfname array is
* LDIR_MAXFNAME+1 we do not have to check the length of the string).
- * NOTE that the name length is incremented to include the NUL terminating
- * character that must also be written to the directory entry.
+ * NOTE that remainder is conditionally incremented to include the NUL
+ * terminating character that may also need be written to the directory
+ * entry. NUL terminating is not required if length is multiple of
+ * LDIR_MAXLFNCHARS (13).
*/
- namelen = strlen((char*)dirinfo->fd_lfname) + 1;
+ namelen = strlen((char*)dirinfo->fd_lfname);
DEBUGASSERT(namelen <= LDIR_MAXFNAME+1);
/* How many LFN directory entries do we need to write? */
@@ -2033,6 +2037,7 @@ static int fat_putlfname(struct fat_mountpt_s *fs, struct fat_dirinfo_s *dirinfo
if (remainder > 0)
{
nentries++;
+ remainder++;
}
DEBUGASSERT(nentries > 0 && nentries <= LDIR_MAXLFNS);