diff --git a/nuttx/ChangeLog b/nuttx/ChangeLog index 25b43abe3..40a012a79 100644 --- a/nuttx/ChangeLog +++ b/nuttx/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/nuttx/drivers/usbdev/Make.defs b/nuttx/drivers/usbdev/Make.defs index 6771c2fb9..4ae4a49e1 100644 --- a/nuttx/drivers/usbdev/Make.defs +++ b/nuttx/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/nuttx/drivers/usbdev/cdc_serdesc.c b/nuttx/drivers/usbdev/cdc_serdesc.c index 03bac3006..990704a1b 100644 --- a/nuttx/drivers/usbdev/cdc_serdesc.c +++ b/nuttx/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/nuttx/drivers/usbdev/cdc_serial.c b/nuttx/drivers/usbdev/cdc_serial.c index 80a61e1f0..c91b451c3 100644 --- a/nuttx/drivers/usbdev/cdc_serial.c +++ b/nuttx/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/nuttx/drivers/usbdev/usbdev_storage.c b/nuttx/drivers/usbdev/usbdev_storage.c index 029cd748e..f2bd03b02 100644 --- a/nuttx/drivers/usbdev/usbdev_storage.c +++ b/nuttx/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/nuttx/drivers/usbdev/usbdev_storage.h b/nuttx/drivers/usbdev/usbdev_storage.h index 320c78ccd..77cc0e53c 100644 --- a/nuttx/drivers/usbdev/usbdev_storage.h +++ b/nuttx/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 * * 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/nuttx/fs/fat/fs_fat32dirent.c b/nuttx/fs/fat/fs_fat32dirent.c index 0627b9bba..6dfdc2022 100644 --- a/nuttx/fs/fat/fs_fat32dirent.c +++ b/nuttx/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);