From 657f0d2092b325bbaec6d61cce725295e38df61e Mon Sep 17 00:00:00 2001 From: patacongo Date: Wed, 25 Jan 2012 20:17:59 +0000 Subject: Massive name change USB STRG -> USB MSC git-svn-id: svn://svn.code.sf.net/p/nuttx/code/trunk@4334 42af7a65-404d-4744-a932-0658087f49c3 --- nuttx/drivers/usbdev/Make.defs | 2 +- nuttx/drivers/usbdev/composite.h | 54 +- nuttx/drivers/usbdev/composite_descriptors.c | 2 +- nuttx/drivers/usbdev/msc.c | 484 +++++++-------- nuttx/drivers/usbdev/msc.h | 364 +++++------ nuttx/drivers/usbdev/msc_descriptors.c | 156 ++--- nuttx/drivers/usbdev/msc_scsi.c | 864 +++++++++++++-------------- nuttx/drivers/usbhost/usbhost_storage.c | 120 ++-- 8 files changed, 1023 insertions(+), 1023 deletions(-) (limited to 'nuttx/drivers') diff --git a/nuttx/drivers/usbdev/Make.defs b/nuttx/drivers/usbdev/Make.defs index 348799849..66c3b3dd5 100644 --- a/nuttx/drivers/usbdev/Make.defs +++ b/nuttx/drivers/usbdev/Make.defs @@ -45,7 +45,7 @@ ifeq ($(CONFIG_CDCSER),y) CSRCS += cdcacm.c cdcacm_descriptors.c endif -ifeq ($(CONFIG_USBSTRG),y) +ifeq ($(CONFIG_USBMSC),y) CSRCS += msc.c msc_descriptors.c msc_scsi.c endif diff --git a/nuttx/drivers/usbdev/composite.h b/nuttx/drivers/usbdev/composite.h index 14cbd9db8..93f91f180 100644 --- a/nuttx/drivers/usbdev/composite.h +++ b/nuttx/drivers/usbdev/composite.h @@ -55,7 +55,7 @@ # include "cdcacm.h" #endif -#ifdef CONFIG_USBSTRG_COMPOSITE +#ifdef CONFIG_USBMSC_COMPOSITE # include "msc.h" #endif @@ -114,18 +114,18 @@ /* Constituent devices ******************************************************/ -#undef DEV1_IS_CDCSERIAL -#undef DEV1_IS_USBSTRG +#undef DEV1_IS_CDCACM +#undef DEV1_IS_USBMSC -#undef DEV2_IS_CDCSERIAL -#undef DEV2_IS_USBSTRG +#undef DEV2_IS_CDCACM +#undef DEV2_IS_USBMSC /* Pick the first device in the composite. At present, this may only be * the CDC serial device or the mass storage device. */ #if defined(CONFIG_CDCSER_COMPOSITE) -# define DEV1_IS_CDCSERIAL 1 +# define DEV1_IS_CDCACM 1 # define DEV1_MKCFGDESC cdcser_mkcfgdesc # define DEV1_CLASSOBJECT board_cdcclassobject # define DEV1_NCONFIGS CDCSER_NCONFIGS @@ -136,16 +136,16 @@ # define DEV1_NSTRIDS (CDCSER_LASTSTRID-CONFIG_CDCSER_STRBASE) # define DEV1_CFGDESCSIZE SIZEOF_CDCSER_CFGDESC #elif defined(CONFIG_CDCSER_COMPOSITE) -# define DEV1_IS_USBSTRG 1 -# define DEV1_MKCFGDESC usbstrg_mkcfgdesc +# define DEV1_IS_USBMSC 1 +# define DEV1_MKCFGDESC usbmsc_mkcfgdesc # define DEV1_CLASSOBJECT board_mscclassobject -# define DEV1_NCONFIGS USBSTRG_NCONFIGS -# define DEV1_CONFIGID USBSTRG_CONFIGID -# define DEV1_FIRSTINTERFACE CONFIG_USBSTRG_IFNOBASE -# define DEV1_NINTERFACES USBSTRG_NINTERFACES -# define DEV1_FIRSTSTRID CONFIG_USBSTRG_IFNOBASE -# define DEV1_NSTRIDS (USBSTRG_LASTSTRID-CONFIG_USBSTRG_STRBASE) -# define DEV1_CFGDESCSIZE SIZEOF_USBSTRG_CFGDESC +# define DEV1_NCONFIGS USBMSC_NCONFIGS +# define DEV1_CONFIGID USBMSC_CONFIGID +# define DEV1_FIRSTINTERFACE CONFIG_USBMSC_IFNOBASE +# define DEV1_NINTERFACES USBMSC_NINTERFACES +# define DEV1_FIRSTSTRID CONFIG_USBMSC_IFNOBASE +# define DEV1_NSTRIDS (USBMSC_LASTSTRID-CONFIG_USBMSC_STRBASE) +# define DEV1_CFGDESCSIZE SIZEOF_USBMSC_CFGDESC #else # error "No members of the composite defined" #endif @@ -154,8 +154,8 @@ * the CDC serial device or the mass storage device. */ -#if defined(CONFIG_CDCSER_COMPOSITE) && !defined(DEV1_IS_CDCSERIAL) -# define DEV2_IS_CDCSERIAL 1 +#if defined(CONFIG_CDCSER_COMPOSITE) && !defined(DEV1_IS_CDCACM) +# define DEV2_IS_CDCACM 1 # define DEV2_MKCFGDESC cdcser_mkcfgdesc # define DEV2_CLASSOBJECT board_cdcclassobject # define DEV2_NCONFIGS CDCSER_NCONFIGS @@ -165,17 +165,17 @@ # define DEV2_FIRSTSTRID CONFIG_CDCSER_STRBASE # define DEV2_NSTRIDS (CDCSER_LASTSTRID-CONFIG_CDCSER_STRBASE) # define DEV2_CFGDESCSIZE SIZEOF_CDCSER_CFGDESC -#elif defined(CONFIG_CDCSER_COMPOSITE) && !defined(DEV1_IS_USBSTRG) -# define DEV2_IS_USBSTRG 1 -# define DEV2_MKCFGDESC usbstrg_mkcfgdesc +#elif defined(CONFIG_CDCSER_COMPOSITE) && !defined(DEV1_IS_USBMSC) +# define DEV2_IS_USBMSC 1 +# define DEV2_MKCFGDESC usbmsc_mkcfgdesc # define DEV2_CLASSOBJECT board_mscclassobject -# define DEV2_NCONFIGS USBSTRG_NCONFIGS -# define DEV2_CONFIGID USBSTRG_CONFIGID -# define DEV2_FIRSTINTERFACE CONFIG_USBSTRG_IFNOBASE -# define DEV2_NINTERFACES USBSTRG_NINTERFACES +# define DEV2_NCONFIGS USBMSC_NCONFIGS +# define DEV2_CONFIGID USBMSC_CONFIGID +# define DEV2_FIRSTINTERFACE CONFIG_USBMSC_IFNOBASE +# define DEV2_NINTERFACES USBMSC_NINTERFACES # define DEV2_FIRSTSTRID CONFIG_CDCSER_STRBASE -# define DEV2_NSTRIDS (USBSTRG_LASTSTRID-CONFIG_USBSTRG_STRBASE) -# define DEV2_CFGDESCSIZE SIZEOF_USBSTRG_CFGDESC +# define DEV2_NSTRIDS (USBMSC_LASTSTRID-CONFIG_USBMSC_STRBASE) +# define DEV2_CFGDESCSIZE SIZEOF_USBMSC_CFGDESC #else # error "Insufficient members of the composite defined" #endif @@ -253,7 +253,7 @@ extern const char g_compserialstr[]; ****************************************************************************/ /**************************************************************************** - * Name: usbstrg_mkstrdesc + * Name: usbmsc_mkstrdesc * * Description: * Construct a string descriptor diff --git a/nuttx/drivers/usbdev/composite_descriptors.c b/nuttx/drivers/usbdev/composite_descriptors.c index e49631b5b..349a54c6c 100644 --- a/nuttx/drivers/usbdev/composite_descriptors.c +++ b/nuttx/drivers/usbdev/composite_descriptors.c @@ -150,7 +150,7 @@ static const struct usb_qualdesc_s g_qualdesc = ****************************************************************************/ /**************************************************************************** - * Name: usbstrg_mkstrdesc + * Name: composite_mkstrdesc * * Description: * Construct a string descriptor diff --git a/nuttx/drivers/usbdev/msc.c b/nuttx/drivers/usbdev/msc.c index 63d6a1f5b..b70d89d44 100644 --- a/nuttx/drivers/usbdev/msc.c +++ b/nuttx/drivers/usbdev/msc.c @@ -92,18 +92,18 @@ /* The internal version of the class driver */ -struct usbstrg_driver_s +struct usbmsc_driver_s { struct usbdevclass_driver_s drvr; - FAR struct usbstrg_dev_s *dev; + FAR struct usbmsc_dev_s *dev; }; /* This is what is allocated */ -struct usbstrg_alloc_s +struct usbmsc_alloc_s { - struct usbstrg_dev_s dev; - struct usbstrg_driver_s drvr; + struct usbmsc_dev_s dev; + struct usbmsc_driver_s drvr; }; /**************************************************************************** @@ -112,25 +112,25 @@ struct usbstrg_alloc_s /* Class Driver Support *****************************************************/ -static void usbstrg_ep0incomplete(FAR struct usbdev_ep_s *ep, +static void usbmsc_ep0incomplete(FAR struct usbdev_ep_s *ep, FAR struct usbdev_req_s *req); -static struct usbdev_req_s *usbstrg_allocreq(FAR struct usbdev_ep_s *ep, +static struct usbdev_req_s *usbmsc_allocreq(FAR struct usbdev_ep_s *ep, uint16_t len); -static void usbstrg_freereq(FAR struct usbdev_ep_s *ep, +static void usbmsc_freereq(FAR struct usbdev_ep_s *ep, FAR struct usbdev_req_s *req); /* Class Driver Operations (most at interrupt level) ************************/ -static int usbstrg_bind(FAR struct usbdev_s *dev, +static int usbmsc_bind(FAR struct usbdev_s *dev, FAR struct usbdevclass_driver_s *driver); -static void usbstrg_unbind(FAR struct usbdev_s *dev); -static int usbstrg_setup(FAR struct usbdev_s *dev, +static void usbmsc_unbind(FAR struct usbdev_s *dev); +static int usbmsc_setup(FAR struct usbdev_s *dev, FAR const struct usb_ctrlreq_s *ctrl); -static void usbstrg_disconnect(FAR struct usbdev_s *dev); +static void usbmsc_disconnect(FAR struct usbdev_s *dev); /* Initialization/Uninitialization ******************************************/ -static void usbstrg_lununinitialize(struct usbstrg_lun_s *lun); +static void usbmsc_lununinitialize(struct usbmsc_lun_s *lun); /**************************************************************************** * Private Data @@ -140,12 +140,12 @@ static void usbstrg_lununinitialize(struct usbstrg_lun_s *lun); static struct usbdevclass_driverops_s g_driverops = { - usbstrg_bind, /* bind */ - usbstrg_unbind, /* unbind */ - usbstrg_setup, /* setup */ - usbstrg_disconnect, /* disconnect */ - NULL, /* suspend */ - NULL /* resume */ + usbmsc_bind, /* bind */ + usbmsc_unbind, /* unbind */ + usbmsc_setup, /* setup */ + usbmsc_disconnect, /* disconnect */ + NULL, /* suspend */ + NULL /* resume */ }; /**************************************************************************** @@ -160,33 +160,33 @@ static struct usbdevclass_driverops_s g_driverops = * Class Driver Support ****************************************************************************/ /**************************************************************************** - * Name: usbstrg_ep0incomplete + * Name: usbmsc_ep0incomplete * * Description: * Handle completion of EP0 control operations * ****************************************************************************/ -static void usbstrg_ep0incomplete(FAR struct usbdev_ep_s *ep, - FAR struct usbdev_req_s *req) +static void usbmsc_ep0incomplete(FAR struct usbdev_ep_s *ep, + FAR struct usbdev_req_s *req) { if (req->result || req->xfrd != req->len) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_REQRESULT), + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_REQRESULT), (uint16_t)-req->result); } } /**************************************************************************** - * Name: usbstrg_allocreq + * Name: usbmsc_allocreq * * Description: * Allocate a request instance along with its buffer * ****************************************************************************/ -static struct usbdev_req_s *usbstrg_allocreq(FAR struct usbdev_ep_s *ep, - uint16_t len) +static struct usbdev_req_s *usbmsc_allocreq(FAR struct usbdev_ep_s *ep, + uint16_t len) { FAR struct usbdev_req_s *req; @@ -205,14 +205,14 @@ static struct usbdev_req_s *usbstrg_allocreq(FAR struct usbdev_ep_s *ep, } /**************************************************************************** - * Name: usbstrg_freereq + * Name: usbmsc_freereq * * Description: * Free a request instance along with its buffer * ****************************************************************************/ -static void usbstrg_freereq(FAR struct usbdev_ep_s *ep, struct usbdev_req_s *req) +static void usbmsc_freereq(FAR struct usbdev_ep_s *ep, struct usbdev_req_s *req) { if (ep != NULL && req != NULL) { @@ -228,17 +228,17 @@ static void usbstrg_freereq(FAR struct usbdev_ep_s *ep, struct usbdev_req_s *req * Class Driver Interfaces ****************************************************************************/ /**************************************************************************** - * Name: usbstrg_bind + * Name: usbmsc_bind * * Description: * Invoked when the driver is bound to a USB device driver * ****************************************************************************/ -static int usbstrg_bind(FAR struct usbdev_s *dev, FAR struct usbdevclass_driver_s *driver) +static int usbmsc_bind(FAR struct usbdev_s *dev, FAR struct usbdevclass_driver_s *driver) { - FAR struct usbstrg_dev_s *priv = ((struct usbstrg_driver_s*)driver)->dev; - FAR struct usbstrg_req_s *reqcontainer; + FAR struct usbmsc_dev_s *priv = ((struct usbmsc_driver_s*)driver)->dev; + FAR struct usbmsc_req_s *reqcontainer; irqstate_t flags; int ret = OK; int i; @@ -255,21 +255,21 @@ static int usbstrg_bind(FAR struct usbdev_s *dev, FAR struct usbdevclass_driver_ * const, canned descriptors. */ - DEBUGASSERT(CONFIG_USBSTRG_EP0MAXPACKET == dev->ep0->maxpacket); + DEBUGASSERT(CONFIG_USBMSC_EP0MAXPACKET == dev->ep0->maxpacket); /* Preallocate control request */ - priv->ctrlreq = usbstrg_allocreq(dev->ep0, USBSTRG_MXDESCLEN); + priv->ctrlreq = usbmsc_allocreq(dev->ep0, USBMSC_MXDESCLEN); if (priv->ctrlreq == NULL) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_ALLOCCTRLREQ), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_ALLOCCTRLREQ), 0); ret = -ENOMEM; goto errout; } - priv->ctrlreq->callback = usbstrg_ep0incomplete; + priv->ctrlreq->callback = usbmsc_ep0incomplete; /* Pre-allocate all endpoints... the endpoints will not be functional - * until the SET CONFIGURATION request is processed in usbstrg_setconfig. + * until the SET CONFIGURATION request is processed in usbmsc_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. @@ -277,10 +277,10 @@ static int usbstrg_bind(FAR struct usbdev_s *dev, FAR struct usbdevclass_driver_ /* Pre-allocate the IN bulk endpoint */ - priv->epbulkin = DEV_ALLOCEP(dev, USBSTRG_EPINBULK_ADDR, true, USB_EP_ATTR_XFER_BULK); + priv->epbulkin = DEV_ALLOCEP(dev, USBMSC_EPINBULK_ADDR, true, USB_EP_ATTR_XFER_BULK); if (!priv->epbulkin) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_EPBULKINALLOCFAIL), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_EPBULKINALLOCFAIL), 0); ret = -ENODEV; goto errout; } @@ -288,10 +288,10 @@ static int usbstrg_bind(FAR struct usbdev_s *dev, FAR struct usbdevclass_driver_ /* Pre-allocate the OUT bulk endpoint */ - priv->epbulkout = DEV_ALLOCEP(dev, USBSTRG_EPOUTBULK_ADDR, false, USB_EP_ATTR_XFER_BULK); + priv->epbulkout = DEV_ALLOCEP(dev, USBMSC_EPOUTBULK_ADDR, false, USB_EP_ATTR_XFER_BULK); if (!priv->epbulkout) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_EPBULKOUTALLOCFAIL), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_EPBULKOUTALLOCFAIL), 0); ret = -ENODEV; goto errout; } @@ -299,36 +299,36 @@ static int usbstrg_bind(FAR struct usbdev_s *dev, FAR struct usbdevclass_driver_ /* Pre-allocate read requests */ - for (i = 0; i < CONFIG_USBSTRG_NRDREQS; i++) + for (i = 0; i < CONFIG_USBMSC_NRDREQS; i++) { reqcontainer = &priv->rdreqs[i]; - reqcontainer->req = usbstrg_allocreq(priv->epbulkout, CONFIG_USBSTRG_BULKOUTREQLEN); + reqcontainer->req = usbmsc_allocreq(priv->epbulkout, CONFIG_USBMSC_BULKOUTREQLEN); if (reqcontainer->req == NULL) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_RDALLOCREQ), + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_RDALLOCREQ), (uint16_t)-ret); ret = -ENOMEM; goto errout; } reqcontainer->req->priv = reqcontainer; - reqcontainer->req->callback = usbstrg_rdcomplete; + reqcontainer->req->callback = usbmsc_rdcomplete; } /* Pre-allocate write request containers and put in a free list */ - for (i = 0; i < CONFIG_USBSTRG_NWRREQS; i++) + for (i = 0; i < CONFIG_USBMSC_NWRREQS; i++) { reqcontainer = &priv->wrreqs[i]; - reqcontainer->req = usbstrg_allocreq(priv->epbulkin, CONFIG_USBSTRG_BULKINREQLEN); + reqcontainer->req = usbmsc_allocreq(priv->epbulkin, CONFIG_USBMSC_BULKINREQLEN); if (reqcontainer->req == NULL) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_WRALLOCREQ), + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_WRALLOCREQ), (uint16_t)-ret); ret = -ENOMEM; goto errout; } reqcontainer->req->priv = reqcontainer; - reqcontainer->req->callback = usbstrg_wrcomplete; + reqcontainer->req->callback = usbmsc_wrcomplete; flags = irqsave(); sq_addlast((sq_entry_t*)reqcontainer, &priv->wrreqlist); @@ -337,7 +337,7 @@ static int usbstrg_bind(FAR struct usbdev_s *dev, FAR struct usbdevclass_driver_ /* Report if we are selfpowered (unless we are part of a composite device) */ -#ifndef CONFIG_USBSTRG_COMPOSITE +#ifndef CONFIG_USBMSC_COMPOSITE #ifdef CONFIG_USBDEV_SELFPOWERED DEV_SETSELFPOWERED(dev); #endif @@ -351,22 +351,22 @@ static int usbstrg_bind(FAR struct usbdev_s *dev, FAR struct usbdevclass_driver_ return OK; errout: - usbstrg_unbind(dev); + usbmsc_unbind(dev); return ret; } /**************************************************************************** - * Name: usbstrg_unbind + * Name: usbmsc_unbind * * Description: * Invoked when the driver is unbound from a USB device driver * ****************************************************************************/ -static void usbstrg_unbind(FAR struct usbdev_s *dev) +static void usbmsc_unbind(FAR struct usbdev_s *dev) { - FAR struct usbstrg_dev_s *priv; - FAR struct usbstrg_req_s *reqcontainer; + FAR struct usbmsc_dev_s *priv; + FAR struct usbmsc_req_s *reqcontainer; irqstate_t flags; int i; @@ -375,19 +375,19 @@ static void usbstrg_unbind(FAR struct usbdev_s *dev) #ifdef CONFIG_DEBUG if (!dev || !dev->ep0) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_UNBINDINVALIDARGS), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_UNBINDINVALIDARGS), 0); return; } #endif /* Extract reference to private data */ - priv = (FAR struct usbstrg_dev_s *)dev->ep0->priv; + priv = (FAR struct usbmsc_dev_s *)dev->ep0->priv; #ifdef CONFIG_DEBUG if (!priv) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_EP0NOTBOUND1), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_EP0NOTBOUND1), 0); return; } #endif @@ -396,7 +396,7 @@ static void usbstrg_unbind(FAR struct usbdev_s *dev) * driver un-initialize logic. */ - DEBUGASSERT(priv->thstate == USBSTRG_STATE_TERMINATED); + DEBUGASSERT(priv->thstate == USBMSC_STATE_TERMINATED); /* Make sure that we are not already unbound */ @@ -404,19 +404,19 @@ static void usbstrg_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 usbstrg_resetconfig + * already have been reset. If not, then calling usbmsc_resetconfig * should cause the endpoints to immediately terminate all * transfers and return the requests to us (with result == -ESHUTDOWN) */ - usbstrg_resetconfig(priv); + usbmsc_resetconfig(priv); up_mdelay(50); /* Free the pre-allocated control request */ if (priv->ctrlreq != NULL) { - usbstrg_freereq(dev->ep0, priv->ctrlreq); + usbmsc_freereq(dev->ep0, priv->ctrlreq); priv->ctrlreq = NULL; } @@ -424,12 +424,12 @@ static void usbstrg_unbind(FAR struct usbdev_s *dev) * been returned to the free list at this time -- we don't check) */ - for (i = 0; i < CONFIG_USBSTRG_NRDREQS; i++) + for (i = 0; i < CONFIG_USBMSC_NRDREQS; i++) { reqcontainer = &priv->rdreqs[i]; if (reqcontainer->req) { - usbstrg_freereq(priv->epbulkout, reqcontainer->req); + usbmsc_freereq(priv->epbulkout, reqcontainer->req); reqcontainer->req = NULL; } } @@ -449,10 +449,10 @@ static void usbstrg_unbind(FAR struct usbdev_s *dev) flags = irqsave(); while (!sq_empty(&priv->wrreqlist)) { - reqcontainer = (struct usbstrg_req_s *)sq_remfirst(&priv->wrreqlist); + reqcontainer = (struct usbmsc_req_s *)sq_remfirst(&priv->wrreqlist); if (reqcontainer->req != NULL) { - usbstrg_freereq(priv->epbulkin, reqcontainer->req); + usbmsc_freereq(priv->epbulkin, reqcontainer->req); } } @@ -469,7 +469,7 @@ static void usbstrg_unbind(FAR struct usbdev_s *dev) } /**************************************************************************** - * Name: usbstrg_setup + * Name: usbmsc_setup * * Description: * Invoked for ep0 control requests. This function probably executes @@ -477,10 +477,10 @@ static void usbstrg_unbind(FAR struct usbdev_s *dev) * ****************************************************************************/ -static int usbstrg_setup(FAR struct usbdev_s *dev, - FAR const struct usb_ctrlreq_s *ctrl) +static int usbmsc_setup(FAR struct usbdev_s *dev, + FAR const struct usb_ctrlreq_s *ctrl) { - FAR struct usbstrg_dev_s *priv; + FAR struct usbmsc_dev_s *priv; FAR struct usbdev_req_s *ctrlreq; uint16_t value; uint16_t index; @@ -490,7 +490,7 @@ static int usbstrg_setup(FAR struct usbdev_s *dev, #ifdef CONFIG_DEBUG if (!dev || !dev->ep0 || !ctrl) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_SETUPINVALIDARGS), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_SETUPINVALIDARGS), 0); return -EIO; } #endif @@ -498,12 +498,12 @@ static int usbstrg_setup(FAR struct usbdev_s *dev, /* Extract reference to private data */ usbtrace(TRACE_CLASSSETUP, ctrl->req); - priv = (FAR struct usbstrg_dev_s *)dev->ep0->priv; + priv = (FAR struct usbmsc_dev_s *)dev->ep0->priv; #ifdef CONFIG_DEBUG if (!priv || !priv->ctrlreq) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_EP0NOTBOUND2), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_EP0NOTBOUND2), 0); return -ENODEV; } #endif @@ -539,11 +539,11 @@ static int usbstrg_setup(FAR struct usbdev_s *dev, * in the composite device implementation. */ -#ifndef CONFIG_USBSTRG_COMPOSITE +#ifndef CONFIG_USBMSC_COMPOSITE case USB_DESC_TYPE_DEVICE: { ret = USB_SIZEOF_DEVDESC; - memcpy(ctrlreq->buf, usbstrg_getdevdesc(), ret); + memcpy(ctrlreq->buf, usbmsc_getdevdesc(), ret); } break; #endif @@ -553,11 +553,11 @@ static int usbstrg_setup(FAR struct usbdev_s *dev, * composite device implementation. */ -#if !defined(CONFIG_USBSTRG_COMPOSITE) && defined(CONFIG_USBDEV_DUALSPEED) +#if !defined(CONFIG_USBMSC_COMPOSITE) && defined(CONFIG_USBDEV_DUALSPEED) case USB_DESC_TYPE_DEVICEQUALIFIER: { ret = USB_SIZEOF_QUALDESC; - memcpy(ctrlreq->buf, usbstrg_getqualdesc(), ret); + memcpy(ctrlreq->buf, usbmsc_getqualdesc(), ret); } break; @@ -569,13 +569,13 @@ static int usbstrg_setup(FAR struct usbdev_s *dev, * composite device implementation. */ -#ifndef CONFIG_USBSTRG_COMPOSITE +#ifndef CONFIG_USBMSC_COMPOSITE case USB_DESC_TYPE_CONFIG: { #ifdef CONFIG_USBDEV_DUALSPEED - ret = usbstrg_mkcfgdesc(ctrlreq->buf, dev->speed, ctrl->value[1]); + ret = usbmsc_mkcfgdesc(ctrlreq->buf, dev->speed, ctrl->value[1]); #else - ret = usbstrg_mkcfgdesc(ctrlreq->buf); + ret = usbmsc_mkcfgdesc(ctrlreq->buf); #endif } break; @@ -586,19 +586,19 @@ static int usbstrg_setup(FAR struct usbdev_s *dev, * composite device implementation. */ -#ifndef CONFIG_USBSTRG_COMPOSITE +#ifndef CONFIG_USBMSC_COMPOSITE case USB_DESC_TYPE_STRING: { /* index == language code. */ - ret = usbstrg_mkstrdesc(ctrl->value[0], (struct usb_strdesc_s *)ctrlreq->buf); + ret = usbmsc_mkstrdesc(ctrl->value[0], (struct usb_strdesc_s *)ctrlreq->buf); } break; #endif default: { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_GETUNKNOWNDESC), value); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_GETUNKNOWNDESC), value); } break; } @@ -611,7 +611,7 @@ static int usbstrg_setup(FAR struct usbdev_s *dev, { /* Signal the worker thread to instantiate the new configuration */ - priv->theventset |= USBSTRG_EVENT_CFGCHANGE; + priv->theventset |= USBMSC_EVENT_CFGCHANGE; priv->thvalue = value; pthread_cond_signal(&priv->cond); @@ -629,7 +629,7 @@ static int usbstrg_setup(FAR struct usbdev_s *dev, * in the composite device implementation. */ -#ifndef CONFIG_USBSTRG_COMPOSITE +#ifndef CONFIG_USBMSC_COMPOSITE case USB_REQ_GETCONFIGURATION: { if (ctrl->type == USB_DIR_IN) @@ -645,13 +645,13 @@ static int usbstrg_setup(FAR struct usbdev_s *dev, { if (ctrl->type == USB_REQ_RECIPIENT_INTERFACE) { - if (priv->config == USBSTRG_CONFIGID && - index == USBSTRG_INTERFACEID && - value == USBSTRG_ALTINTERFACEID) + if (priv->config == USBMSC_CONFIGID && + index == USBMSC_INTERFACEID && + value == USBMSC_ALTINTERFACEID) { /* Signal to instantiate the interface change */ - priv->theventset |= USBSTRG_EVENT_IFCHANGE; + priv->theventset |= USBMSC_EVENT_IFCHANGE; pthread_cond_signal(&priv->cond); /* Return here... the response will be provided later by the @@ -667,15 +667,15 @@ static int usbstrg_setup(FAR struct usbdev_s *dev, case USB_REQ_GETINTERFACE: { if (ctrl->type == (USB_DIR_IN|USB_REQ_RECIPIENT_INTERFACE) && - priv->config == USBSTRG_CONFIGIDNONE) + priv->config == USBMSC_CONFIGIDNONE) { - if (index != USBSTRG_INTERFACEID) + if (index != USBMSC_INTERFACEID) { ret = -EDOM; } else { - ctrlreq->buf[0] = USBSTRG_ALTINTERFACEID; + ctrlreq->buf[0] = USBMSC_ALTINTERFACEID; ret = 1; } } @@ -683,7 +683,7 @@ static int usbstrg_setup(FAR struct usbdev_s *dev, break; default: - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_UNSUPPORTEDSTDREQ), ctrl->req); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_UNSUPPORTEDSTDREQ), ctrl->req); break; } } @@ -697,28 +697,28 @@ static int usbstrg_setup(FAR struct usbdev_s *dev, if (!priv->config) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_NOTCONFIGURED), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_NOTCONFIGURED), 0); return ret; } switch (ctrl->req) { - case USBSTRG_REQ_MSRESET: /* Reset mass storage device and interface */ + case USBMSC_REQ_MSRESET: /* Reset mass storage device and interface */ { - if (ctrl->type == USBSTRG_TYPE_SETUPOUT && value == 0 && len == 0) + if (ctrl->type == USBMSC_TYPE_SETUPOUT && value == 0 && len == 0) { /* Only one interface is supported */ - if (index != USBSTRG_INTERFACEID) + if (index != USBMSC_INTERFACEID) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_MSRESETNDX), index); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_MSRESETNDX), index); ret = -EDOM; } else { /* Signal to stop the current operation and reinitialize state */ - priv->theventset |= USBSTRG_EVENT_RESET; + priv->theventset |= USBMSC_EVENT_RESET; pthread_cond_signal(&priv->cond); /* Return here... the response will be provided later by the @@ -731,15 +731,15 @@ static int usbstrg_setup(FAR struct usbdev_s *dev, } break; - case USBSTRG_REQ_GETMAXLUN: /* Return number LUNs supported */ + case USBMSC_REQ_GETMAXLUN: /* Return number LUNs supported */ { - if (ctrl->type == USBSTRG_TYPE_SETUPIN && value == 0 && len == 1) + if (ctrl->type == USBMSC_TYPE_SETUPIN && value == 0 && len == 1) { /* Only one interface is supported */ - if (index != USBSTRG_INTERFACEID) + if (index != USBMSC_INTERFACEID) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_GETMAXLUNNDX), index); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_GETMAXLUNNDX), index); ret = -EDOM; } else @@ -752,7 +752,7 @@ static int usbstrg_setup(FAR struct usbdev_s *dev, break; default: - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_BADREQUEST), index); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_BADREQUEST), index); break; } } @@ -768,10 +768,10 @@ static int usbstrg_setup(FAR struct usbdev_s *dev, ret = EP_SUBMIT(dev->ep0, ctrlreq); if (ret < 0) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_EPRESPQ), (uint16_t)-ret); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_EPRESPQ), (uint16_t)-ret); #if 0 /* Not necessary */ ctrlreq->result = OK; - usbstrg_ep0incomplete(dev->ep0, ctrlreq); + usbmsc_ep0incomplete(dev->ep0, ctrlreq); #endif } } @@ -780,7 +780,7 @@ static int usbstrg_setup(FAR struct usbdev_s *dev, } /**************************************************************************** - * Name: usbstrg_disconnect + * Name: usbmsc_disconnect * * Description: * Invoked after all transfers have been stopped, when the host is @@ -789,9 +789,9 @@ static int usbstrg_setup(FAR struct usbdev_s *dev, * ****************************************************************************/ -static void usbstrg_disconnect(FAR struct usbdev_s *dev) +static void usbmsc_disconnect(FAR struct usbdev_s *dev) { - struct usbstrg_dev_s *priv; + struct usbmsc_dev_s *priv; irqstate_t flags; usbtrace(TRACE_CLASSDISCONNECT, 0); @@ -799,19 +799,19 @@ static void usbstrg_disconnect(FAR struct usbdev_s *dev) #ifdef CONFIG_DEBUG if (!dev || !dev->ep0) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_DISCONNECTINVALIDARGS), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_DISCONNECTINVALIDARGS), 0); return; } #endif /* Extract reference to private data */ - priv = (FAR struct usbstrg_dev_s *)dev->ep0->priv; + priv = (FAR struct usbmsc_dev_s *)dev->ep0->priv; #ifdef CONFIG_DEBUG if (!priv) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_EP0NOTBOUND3), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_EP0NOTBOUND3), 0); return; } #endif @@ -819,11 +819,11 @@ static void usbstrg_disconnect(FAR struct usbdev_s *dev) /* Reset the configuration */ flags = irqsave(); - usbstrg_resetconfig(priv); + usbmsc_resetconfig(priv); /* Signal the worker thread */ - priv->theventset |= USBSTRG_EVENT_DISCONNECT; + priv->theventset |= USBMSC_EVENT_DISCONNECT; pthread_cond_signal(&priv->cond); irqrestore(flags); @@ -831,7 +831,7 @@ static void usbstrg_disconnect(FAR struct usbdev_s *dev) * re-enumerated (unless we are part of a composite device) */ -#ifndef CONFIG_USBSTRG_COMPOSITE +#ifndef CONFIG_USBMSC_COMPOSITE DEV_CONNECT(dev); #endif } @@ -840,10 +840,10 @@ static void usbstrg_disconnect(FAR struct usbdev_s *dev) * Initialization/Un-Initialization ****************************************************************************/ /**************************************************************************** - * Name: usbstrg_lununinitialize + * Name: usbmsc_lununinitialize ****************************************************************************/ -static void usbstrg_lununinitialize(struct usbstrg_lun_s *lun) +static void usbmsc_lununinitialize(struct usbmsc_lun_s *lun) { /* Has a block driver has been bound to the LUN? */ @@ -854,7 +854,7 @@ static void usbstrg_lununinitialize(struct usbstrg_lun_s *lun) (void)close_blockdriver(lun->inode); } - memset(lun, 0, sizeof(struct usbstrg_lun_s *)); + memset(lun, 0, sizeof(struct usbmsc_lun_s *)); } /**************************************************************************** @@ -865,7 +865,7 @@ static void usbstrg_lununinitialize(struct usbstrg_lun_s *lun) ****************************************************************************/ /**************************************************************************** - * Name: usbstrg_setconfig + * Name: usbmsc_setconfig * * Description: * Set the device configuration by allocating and configuring endpoints and @@ -873,9 +873,9 @@ static void usbstrg_lununinitialize(struct usbstrg_lun_s *lun) * ****************************************************************************/ -int usbstrg_setconfig(FAR struct usbstrg_dev_s *priv, uint8_t config) +int usbmsc_setconfig(FAR struct usbmsc_dev_s *priv, uint8_t config) { - FAR struct usbstrg_req_s *privreq; + FAR struct usbmsc_req_s *privreq; FAR struct usbdev_req_s *req; #ifdef CONFIG_USBDEV_DUALSPEED FAR const struct usb_epdesc_s *epdesc; @@ -888,7 +888,7 @@ int usbstrg_setconfig(FAR struct usbstrg_dev_s *priv, uint8_t config) #if CONFIG_DEBUG if (priv == NULL) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_SETCONFIGINVALIDARGS), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_SETCONFIGINVALIDARGS), 0); return -EIO; } #endif @@ -897,43 +897,43 @@ int usbstrg_setconfig(FAR struct usbstrg_dev_s *priv, uint8_t config) { /* Already configured -- Do nothing */ - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_ALREADYCONFIGURED), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_ALREADYCONFIGURED), 0); return OK; } /* Discard the previous configuration data */ - usbstrg_resetconfig(priv); + usbmsc_resetconfig(priv); /* Was this a request to simply discard the current configuration? */ - if (config == USBSTRG_CONFIGIDNONE) + if (config == USBMSC_CONFIGIDNONE) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_CONFIGNONE), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_CONFIGNONE), 0); return OK; } /* We only accept one configuration */ - if (config != USBSTRG_CONFIGID) + if (config != USBMSC_CONFIGID) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_CONFIGIDBAD), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_CONFIGIDBAD), 0); return -EINVAL; } /* Configure the IN bulk endpoint */ #ifdef CONFIG_USBDEV_DUALSPEED - bulkmxpacket = USBSTRG_BULKMAXPACKET(hispeed); - epdesc = USBSTRG_EPBULKINDESC(hispeed); + bulkmxpacket = USBMSC_BULKMAXPACKET(hispeed); + epdesc = USBMSC_EPBULKINDESC(hispeed); ret = EP_CONFIGURE(priv->epbulkin, epdesc, false); #else ret = EP_CONFIGURE(priv->epbulkin, - usbstrg_getepdesc(USBSTRG_EPFSBULKIN), false); + usbmsc_getepdesc(USBMSC_EPFSBULKIN), false); #endif if (ret < 0) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_EPBULKINCONFIGFAIL), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_EPBULKINCONFIGFAIL), 0); goto errout; } @@ -942,15 +942,15 @@ int usbstrg_setconfig(FAR struct usbstrg_dev_s *priv, uint8_t config) /* Configure the OUT bulk endpoint */ #ifdef CONFIG_USBDEV_DUALSPEED - epdesc = USBSTRG_EPBULKOUTDESC(hispeed); + epdesc = USBMSC_EPBULKOUTDESC(hispeed); ret = EP_CONFIGURE(priv->epbulkout, epdesc, true); #else ret = EP_CONFIGURE(priv->epbulkout, - usbstrg_getepdesc(USBSTRG_EPFSBULKOUT), true); + usbmsc_getepdesc(USBMSC_EPFSBULKOUT), true); #endif if (ret < 0) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_EPBULKOUTCONFIGFAIL), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_EPBULKOUTCONFIGFAIL), 0); goto errout; } @@ -958,17 +958,17 @@ int usbstrg_setconfig(FAR struct usbstrg_dev_s *priv, uint8_t config) /* Queue read requests in the bulk OUT endpoint */ - for (i = 0; i < CONFIG_USBSTRG_NRDREQS; i++) + for (i = 0; i < CONFIG_USBMSC_NRDREQS; i++) { privreq = &priv->rdreqs[i]; req = privreq->req; - req->len = CONFIG_USBSTRG_BULKOUTREQLEN; + req->len = CONFIG_USBMSC_BULKOUTREQLEN; req->priv = privreq; - req->callback = usbstrg_rdcomplete; + req->callback = usbmsc_rdcomplete; ret = EP_SUBMIT(priv->epbulkout, req); if (ret < 0) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_RDSUBMIT), (uint16_t)-ret); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_RDSUBMIT), (uint16_t)-ret); goto errout; } } @@ -977,27 +977,27 @@ int usbstrg_setconfig(FAR struct usbstrg_dev_s *priv, uint8_t config) return OK; errout: - usbstrg_resetconfig(priv); + usbmsc_resetconfig(priv); return ret; } /**************************************************************************** - * Name: usbstrg_resetconfig + * Name: usbmsc_resetconfig * * Description: * Mark the device as not configured and disable all endpoints. * ****************************************************************************/ -void usbstrg_resetconfig(FAR struct usbstrg_dev_s *priv) +void usbmsc_resetconfig(FAR struct usbmsc_dev_s *priv) { /* Are we configured? */ - if (priv->config != USBSTRG_CONFIGIDNONE) + if (priv->config != USBMSC_CONFIGIDNONE) { /* Yes.. but not anymore */ - priv->config = USBSTRG_CONFIGIDNONE; + priv->config = USBMSC_CONFIGIDNONE; /* Disable endpoints. This should force completion of all pending * transfers. @@ -1009,7 +1009,7 @@ void usbstrg_resetconfig(FAR struct usbstrg_dev_s *priv) } /**************************************************************************** - * Name: usbstrg_wrcomplete + * Name: usbmsc_wrcomplete * * Description: * Handle completion of write request. This function probably executes @@ -1017,10 +1017,10 @@ void usbstrg_resetconfig(FAR struct usbstrg_dev_s *priv) * ****************************************************************************/ -void usbstrg_wrcomplete(FAR struct usbdev_ep_s *ep, FAR struct usbdev_req_s *req) +void usbmsc_wrcomplete(FAR struct usbdev_ep_s *ep, FAR struct usbdev_req_s *req) { - FAR struct usbstrg_dev_s *priv; - FAR struct usbstrg_req_s *privreq; + FAR struct usbmsc_dev_s *priv; + FAR struct usbmsc_req_s *privreq; irqstate_t flags; /* Sanity check */ @@ -1028,15 +1028,15 @@ void usbstrg_wrcomplete(FAR struct usbdev_ep_s *ep, FAR struct usbdev_req_s *req #ifdef CONFIG_DEBUG if (!ep || !ep->priv || !req || !req->priv) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_WRCOMPLETEINVALIDARGS), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_WRCOMPLETEINVALIDARGS), 0); return; } #endif /* Extract references to private data */ - priv = (FAR struct usbstrg_dev_s*)ep->priv; - privreq = (FAR struct usbstrg_req_s *)req->priv; + priv = (FAR struct usbmsc_dev_s*)ep->priv; + privreq = (FAR struct usbmsc_req_s *)req->priv; /* Return the write request to the free list */ @@ -1053,23 +1053,23 @@ void usbstrg_wrcomplete(FAR struct usbdev_ep_s *ep, FAR struct usbdev_req_s *req break; case -ESHUTDOWN: /* Disconnection */ - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_WRSHUTDOWN), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_WRSHUTDOWN), 0); break; default: /* Some other error occurred */ - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_WRUNEXPECTED), + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_WRUNEXPECTED), (uint16_t)-req->result); break; }; /* Inform the worker thread that a write request has been returned */ - priv->theventset |= USBSTRG_EVENT_WRCOMPLETE; + priv->theventset |= USBMSC_EVENT_WRCOMPLETE; pthread_cond_signal(&priv->cond); } /**************************************************************************** - * Name: usbstrg_rdcomplete + * Name: usbmsc_rdcomplete * * Description: * Handle completion of read request on the bulk OUT endpoint. This @@ -1077,10 +1077,10 @@ void usbstrg_wrcomplete(FAR struct usbdev_ep_s *ep, FAR struct usbdev_req_s *req * ****************************************************************************/ -void usbstrg_rdcomplete(FAR struct usbdev_ep_s *ep, FAR struct usbdev_req_s *req) +void usbmsc_rdcomplete(FAR struct usbdev_ep_s *ep, FAR struct usbdev_req_s *req) { - FAR struct usbstrg_dev_s *priv; - FAR struct usbstrg_req_s *privreq; + FAR struct usbmsc_dev_s *priv; + FAR struct usbmsc_req_s *privreq; irqstate_t flags; int ret; @@ -1089,15 +1089,15 @@ void usbstrg_rdcomplete(FAR struct usbdev_ep_s *ep, FAR struct usbdev_req_s *req #ifdef CONFIG_DEBUG if (!ep || !ep->priv || !req || !req->priv) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_RDCOMPLETEINVALIDARGS), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_RDCOMPLETEINVALIDARGS), 0); return; } #endif /* Extract references to private data */ - priv = (FAR struct usbstrg_dev_s*)ep->priv; - privreq = (FAR struct usbstrg_req_s *)req->priv; + priv = (FAR struct usbmsc_dev_s*)ep->priv; + privreq = (FAR struct usbmsc_req_s *)req->priv; /* Process the received data unless this is some unusual condition */ @@ -1115,14 +1115,14 @@ void usbstrg_rdcomplete(FAR struct usbdev_ep_s *ep, FAR struct usbdev_req_s *req /* Signal the worker thread that there is received data to be processed */ - priv->theventset |= USBSTRG_EVENT_RDCOMPLETE; + priv->theventset |= USBMSC_EVENT_RDCOMPLETE; pthread_cond_signal(&priv->cond); } break; case -ESHUTDOWN: /* Disconnection */ { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_RDSHUTDOWN), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_RDSHUTDOWN), 0); /* Drop the read request... it will be cleaned up later */ } @@ -1130,19 +1130,19 @@ void usbstrg_rdcomplete(FAR struct usbdev_ep_s *ep, FAR struct usbdev_req_s *req default: /* Some other error occurred */ { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_RDUNEXPECTED), + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_RDUNEXPECTED), (uint16_t)-req->result); /* Return the read request to the bulk out endpoint for re-filling */ req = privreq->req; req->priv = privreq; - req->callback = usbstrg_rdcomplete; + req->callback = usbmsc_rdcomplete; ret = EP_SUBMIT(priv->epbulkout, req); if (ret != OK) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_RDCOMPLETERDSUBMIT), + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_RDCOMPLETERDSUBMIT), (uint16_t)-ret); } } @@ -1151,7 +1151,7 @@ void usbstrg_rdcomplete(FAR struct usbdev_ep_s *ep, FAR struct usbdev_req_s *req } /**************************************************************************** - * Name: usbstrg_deferredresponse + * Name: usbmsc_deferredresponse * * Description: * Some EP0 setup request cannot be responded to immediately becuase they @@ -1161,7 +1161,7 @@ void usbstrg_rdcomplete(FAR struct usbdev_ep_s *ep, FAR struct usbdev_req_s *req * * 1. USB_REQ_SETCONFIGURATION, * 2. USB_REQ_SETINTERFACE, or - * 3. USBSTRG_REQ_MSRESET + * 3. USBMSC_REQ_MSRESET * * In all cases, the success reponse is a zero-length packet; the failure * response is an EP0 stall. @@ -1172,7 +1172,7 @@ void usbstrg_rdcomplete(FAR struct usbdev_ep_s *ep, FAR struct usbdev_req_s *req * ****************************************************************************/ -void usbstrg_deferredresponse(FAR struct usbstrg_dev_s *priv, bool failed) +void usbmsc_deferredresponse(FAR struct usbmsc_dev_s *priv, bool failed) { FAR struct usbdev_s *dev; FAR struct usbdev_req_s *ctrlreq; @@ -1181,7 +1181,7 @@ void usbstrg_deferredresponse(FAR struct usbstrg_dev_s *priv, bool failed) #ifdef CONFIG_DEBUG if (!priv || !priv->usbdev || !priv->ctrlreq) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_DEFERREDRESPINVALIDARGS), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_DEFERREDRESPINVALIDARGS), 0); return; } #endif @@ -1200,11 +1200,11 @@ void usbstrg_deferredresponse(FAR struct usbstrg_dev_s *priv, bool failed) ret = EP_SUBMIT(dev->ep0, ctrlreq); if (ret < 0) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_DEFERREDRESPSUBMIT), + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_DEFERREDRESPSUBMIT), (uint16_t)-ret); #if 0 /* Not necessary */ ctrlreq->result = OK; - usbstrg_ep0incomplete(dev->ep0, ctrlreq); + usbmsc_ep0incomplete(dev->ep0, ctrlreq); #endif } } @@ -1212,7 +1212,7 @@ void usbstrg_deferredresponse(FAR struct usbstrg_dev_s *priv, bool failed) { /* On a failure, the USB driver will stall. */ - usbtrace(TRACE_DEVERROR(USBSTRG_TRACEERR_DEFERREDRESPSTALLED), 0); + usbtrace(TRACE_DEVERROR(USBMSC_TRACEERR_DEFERREDRESPSTALLED), 0); EP_STALL(dev->ep0); } } @@ -1221,16 +1221,16 @@ void usbstrg_deferredresponse(FAR struct usbstrg_dev_s *priv, bool failed) * User Interfaces ****************************************************************************/ /**************************************************************************** - * Name: usbstrg_configure + * Name: usbmsc_configure * * Description: * One-time initialization of the USB storage driver. The initialization * sequence is as follows: * - * 1. Call usbstrg_configure to perform one-time initialization specifying + * 1. Call usbmsc_configure to perform one-time initialization specifying * the number of luns. - * 2. Call usbstrg_bindlun to configure each supported LUN - * 3. Call usbstrg_exportluns when all LUNs are configured + * 2. Call usbmsc_bindlun to configure each supported LUN + * 3. Call usbmsc_exportluns when all LUNs are configured * * Input Parameters: * nluns - the number of LUNs that will be registered @@ -1241,34 +1241,34 @@ void usbstrg_deferredresponse(FAR struct usbstrg_dev_s *priv, bool failed) * ****************************************************************************/ -int usbstrg_configure(unsigned int nluns, void **handle) +int usbmsc_configure(unsigned int nluns, void **handle) { - FAR struct usbstrg_alloc_s *alloc; - FAR struct usbstrg_dev_s *priv; - FAR struct usbstrg_driver_s *drvr; + FAR struct usbmsc_alloc_s *alloc; + FAR struct usbmsc_dev_s *priv; + FAR struct usbmsc_driver_s *drvr; int ret; #ifdef CONFIG_DEBUG if (nluns > 15) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_TOOMANYLUNS), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_TOOMANYLUNS), 0); return -EDOM; } #endif /* Allocate the structures needed */ - alloc = (FAR struct usbstrg_alloc_s*)kmalloc(sizeof(struct usbstrg_alloc_s)); + alloc = (FAR struct usbmsc_alloc_s*)kmalloc(sizeof(struct usbmsc_alloc_s)); if (!alloc) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_ALLOCDEVSTRUCT), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_ALLOCDEVSTRUCT), 0); return -ENOMEM; } /* Initialize the USB storage driver structure */ priv = &alloc->dev; - memset(priv, 0, sizeof(struct usbstrg_dev_s)); + memset(priv, 0, sizeof(struct usbmsc_dev_s)); pthread_mutex_init(&priv->mutex, NULL); pthread_cond_init(&priv->cond, NULL); @@ -1278,13 +1278,13 @@ int usbstrg_configure(unsigned int nluns, void **handle) /* Allocate the LUN table */ - priv->luntab = (struct usbstrg_lun_s*)kmalloc(priv->nluns*sizeof(struct usbstrg_lun_s)); + priv->luntab = (struct usbmsc_lun_s*)kmalloc(priv->nluns*sizeof(struct usbmsc_lun_s)); if (!priv->luntab) { ret = -ENOMEM; goto errout; } - memset(priv->luntab, 0, priv->nluns * sizeof(struct usbstrg_lun_s)); + memset(priv->luntab, 0, priv->nluns * sizeof(struct usbmsc_lun_s)); /* Initialize the USB class driver structure */ @@ -1303,18 +1303,18 @@ int usbstrg_configure(unsigned int nluns, void **handle) return OK; errout: - usbstrg_uninitialize(alloc); + usbmsc_uninitialize(alloc); return ret; } /**************************************************************************** - * Name: usbstrg_bindlun + * Name: usbmsc_bindlun * * Description: * Bind the block driver specified by drvrpath to a USB storage LUN. * * Input Parameters: - * handle - The handle returned by a previous call to usbstrg_configure(). + * handle - The handle returned by a previous call to usbmsc_configure(). * drvrpath - the full path to the block driver * startsector - A sector offset into the block driver to the start of the * partition on drvrpath (0 if no partitions) @@ -1327,13 +1327,13 @@ errout: * ****************************************************************************/ -int usbstrg_bindlun(FAR void *handle, FAR const char *drvrpath, - unsigned int lunno, off_t startsector, size_t nsectors, - bool readonly) +int usbmsc_bindlun(FAR void *handle, FAR const char *drvrpath, + unsigned int lunno, off_t startsector, size_t nsectors, + bool readonly) { - FAR struct usbstrg_alloc_s *alloc = (FAR struct usbstrg_alloc_s *)handle; - FAR struct usbstrg_dev_s *priv; - FAR struct usbstrg_lun_s *lun; + FAR struct usbmsc_alloc_s *alloc = (FAR struct usbmsc_alloc_s *)handle; + FAR struct usbmsc_dev_s *priv; + FAR struct usbmsc_lun_s *lun; FAR struct inode *inode; struct geometry geo; int ret; @@ -1341,7 +1341,7 @@ int usbstrg_bindlun(FAR void *handle, FAR const char *drvrpath, #ifdef CONFIG_DEBUG if (!alloc || !drvrpath || startsector < 0 || nsectors < 0) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_BINLUNINVALIDARGS1), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_BINLUNINVALIDARGS1), 0); return -EINVAL; } #endif @@ -1351,13 +1351,13 @@ int usbstrg_bindlun(FAR void *handle, FAR const char *drvrpath, #ifdef CONFIG_DEBUG if (!priv->luntab) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_INTERNALCONFUSION1), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_INTERNALCONFUSION1), 0); return -EIO; } if (lunno > priv->nluns) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_BINDLUNINVALIDARGS2), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_BINDLUNINVALIDARGS2), 0); return -EINVAL; } #endif @@ -1367,7 +1367,7 @@ int usbstrg_bindlun(FAR void *handle, FAR const char *drvrpath, #ifdef CONFIG_DEBUG if (lun->inode != NULL) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_LUNALREADYBOUND), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_LUNALREADYBOUND), 0); return -EBUSY; } #endif @@ -1377,7 +1377,7 @@ int usbstrg_bindlun(FAR void *handle, FAR const char *drvrpath, ret = open_blockdriver(drvrpath, 0, &inode); if (ret < 0) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_BLKDRVEOPEN), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_BLKDRVEOPEN), 0); return ret; } @@ -1386,7 +1386,7 @@ int usbstrg_bindlun(FAR void *handle, FAR const char *drvrpath, if (!inode || !inode->u.i_bops || !inode->u.i_bops->geometry || inode->u.i_bops->geometry(inode, &geo) != OK || !geo.geo_available) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_NOGEOMETRY), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_NOGEOMETRY), 0); return -ENODEV; } @@ -1394,7 +1394,7 @@ int usbstrg_bindlun(FAR void *handle, FAR const char *drvrpath, if (startsector >= geo.geo_nsectors) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_BINDLUNINVALIDARGS3), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_BINDLUNINVALIDARGS3), 0); return -EDOM; } else if (nsectors == 0) @@ -1403,13 +1403,13 @@ int usbstrg_bindlun(FAR void *handle, FAR const char *drvrpath, } else if (startsector + nsectors >= geo.geo_nsectors) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_BINDLUNINVALIDARGS4), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_BINDLUNINVALIDARGS4), 0); return -EDOM; } /* Initialize the LUN structure */ - memset(lun, 0, sizeof(struct usbstrg_lun_s *)); + memset(lun, 0, sizeof(struct usbmsc_lun_s *)); /* Allocate an I/O buffer big enough to hold one hardware sector. SCSI commands * are processed one at a time so all LUNs may share a single I/O buffer. The @@ -1422,7 +1422,7 @@ int usbstrg_bindlun(FAR void *handle, FAR const char *drvrpath, priv->iobuffer = (uint8_t*)kmalloc(geo.geo_sectorsize); if (!priv->iobuffer) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_ALLOCIOBUFFER), geo.geo_sectorsize); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_ALLOCIOBUFFER), geo.geo_sectorsize); return -ENOMEM; } priv->iosize = geo.geo_sectorsize; @@ -1433,7 +1433,7 @@ int usbstrg_bindlun(FAR void *handle, FAR const char *drvrpath, tmp = (uint8_t*)realloc(priv->iobuffer, geo.geo_sectorsize); if (!tmp) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_REALLOCIOBUFFER), geo.geo_sectorsize); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_REALLOCIOBUFFER), geo.geo_sectorsize); return -ENOMEM; } @@ -1456,13 +1456,13 @@ int usbstrg_bindlun(FAR void *handle, FAR const char *drvrpath, } /**************************************************************************** - * Name: usbstrg_unbindlun + * Name: usbmsc_unbindlun * * Description: * Un-bind the block driver for the specified LUN * * Input Parameters: - * handle - The handle returned by a previous call to usbstrg_configure(). + * handle - The handle returned by a previous call to usbmsc_configure(). * lun - the LUN to unbind from * * Returned Value: @@ -1470,17 +1470,17 @@ int usbstrg_bindlun(FAR void *handle, FAR const char *drvrpath, * ****************************************************************************/ -int usbstrg_unbindlun(FAR void *handle, unsigned int lunno) +int usbmsc_unbindlun(FAR void *handle, unsigned int lunno) { - FAR struct usbstrg_alloc_s *alloc = (FAR struct usbstrg_alloc_s *)handle; - FAR struct usbstrg_dev_s *priv; - FAR struct usbstrg_lun_s *lun; + FAR struct usbmsc_alloc_s *alloc = (FAR struct usbmsc_alloc_s *)handle; + FAR struct usbmsc_dev_s *priv; + FAR struct usbmsc_lun_s *lun; int ret; #ifdef CONFIG_DEBUG if (!alloc) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_UNBINDLUNINVALIDARGS1), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_UNBINDLUNINVALIDARGS1), 0); return -EINVAL; } #endif @@ -1490,13 +1490,13 @@ int usbstrg_unbindlun(FAR void *handle, unsigned int lunno) #ifdef CONFIG_DEBUG if (!priv->luntab) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_INTERNALCONFUSION2), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_INTERNALCONFUSION2), 0); return -EIO; } if (lunno > priv->nluns) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_UNBINDLUNINVALIDARGS2), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_UNBINDLUNINVALIDARGS2), 0); return -EINVAL; } #endif @@ -1507,7 +1507,7 @@ int usbstrg_unbindlun(FAR void *handle, unsigned int lunno) #ifdef CONFIG_DEBUG if (lun->inode == NULL) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_LUNNOTBOUND), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_LUNNOTBOUND), 0); ret = -EBUSY; } else @@ -1515,7 +1515,7 @@ int usbstrg_unbindlun(FAR void *handle, unsigned int lunno) { /* Close the block driver */ - usbstrg_lununinitialize(lun); + usbmsc_lununinitialize(lun); ret = OK; } @@ -1524,25 +1524,25 @@ int usbstrg_unbindlun(FAR void *handle, unsigned int lunno) } /**************************************************************************** - * Name: usbstrg_exportluns + * Name: usbmsc_exportluns * * Description: * After all of the LUNs have been bound, this function may be called * in order to export those LUNs in the USB storage device. * * Input Parameters: - * handle - The handle returned by a previous call to usbstrg_configure(). + * handle - The handle returned by a previous call to usbmsc_configure(). * * Returned Value: * 0 on success; a negated errno on failure * ****************************************************************************/ -int usbstrg_exportluns(FAR void *handle) +int usbmsc_exportluns(FAR void *handle) { - FAR struct usbstrg_alloc_s *alloc = (FAR struct usbstrg_alloc_s *)handle; - FAR struct usbstrg_dev_s *priv; - FAR struct usbstrg_driver_s *drvr; + FAR struct usbmsc_alloc_s *alloc = (FAR struct usbmsc_alloc_s *)handle; + FAR struct usbmsc_dev_s *priv; + FAR struct usbmsc_driver_s *drvr; irqstate_t flags; #ifdef SDCC pthread_attr_t attr; @@ -1552,7 +1552,7 @@ int usbstrg_exportluns(FAR void *handle) #ifdef CONFIG_DEBUG if (!alloc) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_EXPORTLUNSINVALIDARGS), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_EXPORTLUNSINVALIDARGS), 0); return -ENXIO; } #endif @@ -1563,18 +1563,18 @@ int usbstrg_exportluns(FAR void *handle) /* Start the worker thread */ pthread_mutex_lock(&priv->mutex); - priv->thstate = USBSTRG_STATE_NOTSTARTED; - priv->theventset = USBSTRG_EVENT_NOEVENTS; + priv->thstate = USBMSC_STATE_NOTSTARTED; + priv->theventset = USBMSC_EVENT_NOEVENTS; #ifdef SDCC (void)pthread_attr_init(&attr); - ret = pthread_create(&priv->thread, &attr, usbstrg_workerthread, (pthread_addr_t)priv); + ret = pthread_create(&priv->thread, &attr, usbmsc_workerthread, (pthread_addr_t)priv); #else - ret = pthread_create(&priv->thread, NULL, usbstrg_workerthread, (pthread_addr_t)priv); + ret = pthread_create(&priv->thread, NULL, usbmsc_workerthread, (pthread_addr_t)priv); #endif if (ret != OK) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_THREADCREATE), (uint16_t)-ret); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_THREADCREATE), (uint16_t)-ret); goto errout_with_mutex; } @@ -1584,7 +1584,7 @@ int usbstrg_exportluns(FAR void *handle) ret = usbdev_register(&drvr->drvr); if (ret != OK) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_DEVREGISTER), (uint16_t)-ret); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_DEVREGISTER), (uint16_t)-ret); goto errout_with_mutex; } #endif @@ -1592,7 +1592,7 @@ int usbstrg_exportluns(FAR void *handle) /* Signal to start the thread */ flags = irqsave(); - priv->theventset |= USBSTRG_EVENT_READY; + priv->theventset |= USBMSC_EVENT_READY; pthread_cond_signal(&priv->cond); irqrestore(flags); @@ -1602,23 +1602,23 @@ errout_with_mutex: } /**************************************************************************** - * Name: usbstrg_uninitialize + * Name: usbmsc_uninitialize * * Description: * Un-initialize the USB storage class driver * * Input Parameters: - * handle - The handle returned by a previous call to usbstrg_configure(). + * handle - The handle returned by a previous call to usbmsc_configure(). * * Returned Value: * None * ****************************************************************************/ -void usbstrg_uninitialize(FAR void *handle) +void usbmsc_uninitialize(FAR void *handle) { - FAR struct usbstrg_alloc_s *alloc = (FAR struct usbstrg_alloc_s *)handle; - FAR struct usbstrg_dev_s *priv; + FAR struct usbmsc_alloc_s *alloc = (FAR struct usbmsc_alloc_s *)handle; + FAR struct usbmsc_dev_s *priv; irqstate_t flags; #ifdef SDCC pthread_addr_t result1, result2; @@ -1631,7 +1631,7 @@ void usbstrg_uninitialize(FAR void *handle) #ifdef CONFIG_DEBUG if (!handle) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_UNINITIALIZEINVALIDARGS), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_UNINITIALIZEINVALIDARGS), 0); return; } #endif @@ -1639,17 +1639,17 @@ void usbstrg_uninitialize(FAR void *handle) /* If the thread hasn't already exitted, tell it to exit now */ - if (priv->thstate != USBSTRG_STATE_NOTSTARTED) + if (priv->thstate != USBMSC_STATE_NOTSTARTED) { /* The thread was started.. Is it still running? */ pthread_mutex_lock(&priv->mutex); - if (priv->thstate != USBSTRG_STATE_TERMINATED) + if (priv->thstate != USBMSC_STATE_TERMINATED) { /* Yes.. Ask the thread to stop */ flags = irqsave(); - priv->theventset |= USBSTRG_EVENT_TERMINATEREQUEST; + priv->theventset |= USBMSC_EVENT_TERMINATEREQUEST; pthread_cond_signal(&priv->cond); irqrestore(flags); } @@ -1674,7 +1674,7 @@ void usbstrg_uninitialize(FAR void *handle) for (i = 0; i < priv->nluns; ++i) { - usbstrg_lununinitialize(&priv->luntab[i]); + usbmsc_lununinitialize(&priv->luntab[i]); } kfree(priv->luntab); diff --git a/nuttx/drivers/usbdev/msc.h b/nuttx/drivers/usbdev/msc.h index 1c23f50fd..47cca0e8a 100644 --- a/nuttx/drivers/usbdev/msc.h +++ b/nuttx/drivers/usbdev/msc.h @@ -59,140 +59,140 @@ ****************************************************************************/ /* Configuration ************************************************************/ /* If the USB mass storage device is configured as part of a composite device - * then both CONFIG_USBDEV_COMPOSITE and CONFIG_USBSTRG_COMPOSITE must be + * then both CONFIG_USBDEV_COMPOSITE and CONFIG_USBMSC_COMPOSITE must be * defined. */ #ifndef CONFIG_USBDEV_COMPOSITE -# undef CONFIG_USBSTRG_COMPOSITE +# undef CONFIG_USBMSC_COMPOSITE #endif -#if defined(CONFIG_USBSTRG_COMPOSITE) && !defined(CONFIG_USBSTRG_STRBASE) -# define CONFIG_USBSTRG_STRBASE (4) +#if defined(CONFIG_USBMSC_COMPOSITE) && !defined(CONFIG_USBMSC_STRBASE) +# define CONFIG_USBMSC_STRBASE (4) #endif /* Interface IDs. If the mass storage driver is built as a component of a * composite device, then the interface IDs may need to be offset. */ -#ifndef CONFIG_USBSTRG_COMPOSITE -# undef CONFIG_USBSTRG_IFNOBASE -# define CONFIG_USBSTRG_IFNOBASE 0 +#ifndef CONFIG_USBMSC_COMPOSITE +# undef CONFIG_USBMSC_IFNOBASE +# define CONFIG_USBMSC_IFNOBASE 0 #endif -#ifndef CONFIG_USBSTRG_IFNOBASE -# define CONFIG_USBSTRG_IFNOBASE 0 +#ifndef CONFIG_USBMSC_IFNOBASE +# define CONFIG_USBMSC_IFNOBASE 0 #endif /* Number of requests in the write queue */ -#ifndef CONFIG_USBSTRG_NWRREQS -# define CONFIG_USBSTRG_NWRREQS 4 +#ifndef CONFIG_USBMSC_NWRREQS +# define CONFIG_USBMSC_NWRREQS 4 #endif /* Number of requests in the read queue */ -#ifndef CONFIG_USBSTRG_NRDREQS -# define CONFIG_USBSTRG_NRDREQS 4 +#ifndef CONFIG_USBMSC_NRDREQS +# define CONFIG_USBMSC_NRDREQS 4 #endif /* Logical endpoint numbers / max packet sizes */ -#ifndef CONFIG_USBSTRG_EPBULKOUT +#ifndef CONFIG_USBMSC_EPBULKOUT # warning "EPBULKOUT not defined in the configuration" -# define CONFIG_USBSTRG_EPBULKOUT 2 +# define CONFIG_USBMSC_EPBULKOUT 2 #endif -#ifndef CONFIG_USBSTRG_EPBULKIN +#ifndef CONFIG_USBMSC_EPBULKIN # warning "EPBULKIN not defined in the configuration" -# define CONFIG_USBSTRG_EPBULKIN 3 +# define CONFIG_USBMSC_EPBULKIN 3 #endif /* Packet and request buffer sizes */ #ifndef CONFIG_CDCSER_COMPOSITE -# ifndef CONFIG_USBSTRG_EP0MAXPACKET -# define CONFIG_USBSTRG_EP0MAXPACKET 64 +# ifndef CONFIG_USBMSC_EP0MAXPACKET +# define CONFIG_USBMSC_EP0MAXPACKET 64 # endif #endif -#ifndef CONFIG_USBSTRG_BULKINREQLEN +#ifndef CONFIG_USBMSC_BULKINREQLEN # ifdef CONFIG_USBDEV_DUALSPEED -# define CONFIG_USBSTRG_BULKINREQLEN 512 +# define CONFIG_USBMSC_BULKINREQLEN 512 # else -# define CONFIG_USBSTRG_BULKINREQLEN 64 +# define CONFIG_USBMSC_BULKINREQLEN 64 # endif #else # ifdef CONFIG_USBDEV_DUALSPEED -# if CONFIG_USBSTRG_BULKINREQLEN < 512 +# if CONFIG_USBMSC_BULKINREQLEN < 512 # warning "Bulk in buffer size smaller than max packet" -# undef CONFIG_USBSTRG_BULKINREQLEN -# define CONFIG_USBSTRG_BULKINREQLEN 512 +# undef CONFIG_USBMSC_BULKINREQLEN +# define CONFIG_USBMSC_BULKINREQLEN 512 # endif # else -# if CONFIG_USBSTRG_BULKINREQLEN < 64 +# if CONFIG_USBMSC_BULKINREQLEN < 64 # warning "Bulk in buffer size smaller than max packet" -# undef CONFIG_USBSTRG_BULKINREQLEN -# define CONFIG_USBSTRG_BULKINREQLEN 64 +# undef CONFIG_USBMSC_BULKINREQLEN +# define CONFIG_USBMSC_BULKINREQLEN 64 # endif # endif #endif -#ifndef CONFIG_USBSTRG_BULKOUTREQLEN +#ifndef CONFIG_USBMSC_BULKOUTREQLEN # ifdef CONFIG_USBDEV_DUALSPEED -# define CONFIG_USBSTRG_BULKOUTREQLEN 512 +# define CONFIG_USBMSC_BULKOUTREQLEN 512 # else -# define CONFIG_USBSTRG_BULKOUTREQLEN 64 +# define CONFIG_USBMSC_BULKOUTREQLEN 64 # endif #else # ifdef CONFIG_USBDEV_DUALSPEED -# if CONFIG_USBSTRG_BULKOUTREQLEN < 512 +# if CONFIG_USBMSC_BULKOUTREQLEN < 512 # warning "Bulk in buffer size smaller than max packet" -# undef CONFIG_USBSTRG_BULKOUTREQLEN -# define CONFIG_USBSTRG_BULKOUTREQLEN 512 +# undef CONFIG_USBMSC_BULKOUTREQLEN +# define CONFIG_USBMSC_BULKOUTREQLEN 512 # endif # else -# if CONFIG_USBSTRG_BULKOUTREQLEN < 64 +# if CONFIG_USBMSC_BULKOUTREQLEN < 64 # warning "Bulk in buffer size smaller than max packet" -# undef CONFIG_USBSTRG_BULKOUTREQLEN -# define CONFIG_USBSTRG_BULKOUTREQLEN 64 +# undef CONFIG_USBMSC_BULKOUTREQLEN +# define CONFIG_USBMSC_BULKOUTREQLEN 64 # endif # endif #endif /* Vendor and product IDs and strings */ -#ifndef CONFIG_USBSTRG_COMPOSITE -# ifndef CONFIG_USBSTRG_VENDORID -# warning "CONFIG_USBSTRG_VENDORID not defined" -# define CONFIG_USBSTRG_VENDORID 0x584e +#ifndef CONFIG_USBMSC_COMPOSITE +# ifndef CONFIG_USBMSC_VENDORID +# warning "CONFIG_USBMSC_VENDORID not defined" +# define CONFIG_USBMSC_VENDORID 0x584e # endif -# ifndef CONFIG_USBSTRG_PRODUCTID -# warning "CONFIG_USBSTRG_PRODUCTID not defined" -# define CONFIG_USBSTRG_PRODUCTID 0x5342 +# ifndef CONFIG_USBMSC_PRODUCTID +# warning "CONFIG_USBMSC_PRODUCTID not defined" +# define CONFIG_USBMSC_PRODUCTID 0x5342 # endif -# ifndef CONFIG_USBSTRG_VERSIONNO -# define CONFIG_USBSTRG_VERSIONNO (0x0399) +# ifndef CONFIG_USBMSC_VERSIONNO +# define CONFIG_USBMSC_VERSIONNO (0x0399) # endif -# ifndef CONFIG_USBSTRG_VENDORSTR +# ifndef CONFIG_USBMSC_VENDORSTR # warning "No Vendor string specified" -# define CONFIG_USBSTRG_VENDORSTR "NuttX" +# define CONFIG_USBMSC_VENDORSTR "NuttX" # endif -# ifndef CONFIG_USBSTRG_PRODUCTSTR +# ifndef CONFIG_USBMSC_PRODUCTSTR # warning "No Product string specified" -# define CONFIG_USBSTRG_PRODUCTSTR "USBdev Storage" +# define CONFIG_USBMSC_PRODUCTSTR "USBdev Storage" # endif -# undef CONFIG_USBSTRG_SERIALSTR -# define CONFIG_USBSTRG_SERIALSTR "0101" +# undef CONFIG_USBMSC_SERIALSTR +# define CONFIG_USBMSC_SERIALSTR "0101" #endif -#undef CONFIG_USBSTRG_CONFIGSTR -#define CONFIG_USBSTRG_CONFIGSTR "Bulk" +#undef CONFIG_USBMSC_CONFIGSTR +#define CONFIG_USBMSC_CONFIGSTR "Bulk" /* Debug -- must be consistent with include/debug.h */ @@ -220,8 +220,8 @@ /* Packet and request buffer sizes */ -#ifndef CONFIG_USBSTRG_EP0MAXPACKET -# define CONFIG_USBSTRG_EP0MAXPACKET 64 +#ifndef CONFIG_USBMSC_EP0MAXPACKET +# define CONFIG_USBMSC_EP0MAXPACKET 64 #endif /* USB Controller */ @@ -244,131 +244,131 @@ /* Current state of the worker thread */ -#define USBSTRG_STATE_NOTSTARTED (0) /* Thread has not yet been started */ -#define USBSTRG_STATE_STARTED (1) /* Started, but is not yet initialized */ -#define USBSTRG_STATE_IDLE (2) /* Started and waiting for commands */ -#define USBSTRG_STATE_CMDPARSE (3) /* Processing a received command */ -#define USBSTRG_STATE_CMDREAD (4) /* Processing a SCSI read command */ -#define USBSTRG_STATE_CMDWRITE (5) /* Processing a SCSI write command */ -#define USBSTRG_STATE_CMDFINISH (6) /* Finish command processing */ -#define USBSTRG_STATE_CMDSTATUS (7) /* Processing the final status of the command */ -#define USBSTRG_STATE_TERMINATED (8) /* Thread has exitted */ +#define USBMSC_STATE_NOTSTARTED (0) /* Thread has not yet been started */ +#define USBMSC_STATE_STARTED (1) /* Started, but is not yet initialized */ +#define USBMSC_STATE_IDLE (2) /* Started and waiting for commands */ +#define USBMSC_STATE_CMDPARSE (3) /* Processing a received command */ +#define USBMSC_STATE_CMDREAD (4) /* Processing a SCSI read command */ +#define USBMSC_STATE_CMDWRITE (5) /* Processing a SCSI write command */ +#define USBMSC_STATE_CMDFINISH (6) /* Finish command processing */ +#define USBMSC_STATE_CMDSTATUS (7) /* Processing the final status of the command */ +#define USBMSC_STATE_TERMINATED (8) /* Thread has exitted */ /* Event communicated to worker thread */ -#define USBSTRG_EVENT_NOEVENTS (0) /* There are no outstanding events */ -#define USBSTRG_EVENT_READY (1 << 0) /* Initialization is complete */ -#define USBSTRG_EVENT_RDCOMPLETE (1 << 1) /* A read has completed there is data to be processed */ -#define USBSTRG_EVENT_WRCOMPLETE (1 << 2) /* A write has completed and a request is available */ -#define USBSTRG_EVENT_TERMINATEREQUEST (1 << 3) /* Shutdown requested */ -#define USBSTRG_EVENT_DISCONNECT (1 << 4) /* USB disconnect received */ -#define USBSTRG_EVENT_RESET (1 << 5) /* USB storage setup reset received */ -#define USBSTRG_EVENT_CFGCHANGE (1 << 6) /* USB setup configuration change received */ -#define USBSTRG_EVENT_IFCHANGE (1 << 7) /* USB setup interface change received */ -#define USBSTRG_EVENT_ABORTBULKOUT (1 << 8) /* SCSI receive failure */ - -/* SCSI command flags (passed to usbstrg_setupcmd()) */ - -#define USBSTRG_FLAGS_DIRMASK (0x03) /* Bits 0-1: Data direction */ -#define USBSTRG_FLAGS_DIRNONE (0x00) /* No data to send */ -#define USBSTRG_FLAGS_DIRHOST2DEVICE (0x01) /* Host-to-device */ -#define USBSTRG_FLAGS_DIRDEVICE2HOST (0x02) /* Device-to-host */ -#define USBSTRG_FLAGS_BLOCKXFR (0x04) /* Bit 2: Command is a block transfer request */ -#define USBSTRG_FLAGS_LUNNOTNEEDED (0x08) /* Bit 3: Command does not require a valid LUN */ -#define USBSTRG_FLAGS_UACOKAY (0x10) /* Bit 4: Command OK if unit attention condition */ -#define USBSTRG_FLAGS_RETAINSENSEDATA (0x20) /* Bit 5: Do not clear sense data */ +#define USBMSC_EVENT_NOEVENTS (0) /* There are no outstanding events */ +#define USBMSC_EVENT_READY (1 << 0) /* Initialization is complete */ +#define USBMSC_EVENT_RDCOMPLETE (1 << 1) /* A read has completed there is data to be processed */ +#define USBMSC_EVENT_WRCOMPLETE (1 << 2) /* A write has completed and a request is available */ +#define USBMSC_EVENT_TERMINATEREQUEST (1 << 3) /* Shutdown requested */ +#define USBMSC_EVENT_DISCONNECT (1 << 4) /* USB disconnect received */ +#define USBMSC_EVENT_RESET (1 << 5) /* USB storage setup reset received */ +#define USBMSC_EVENT_CFGCHANGE (1 << 6) /* USB setup configuration change received */ +#define USBMSC_EVENT_IFCHANGE (1 << 7) /* USB setup interface change received */ +#define USBMSC_EVENT_ABORTBULKOUT (1 << 8) /* SCSI receive failure */ + +/* SCSI command flags (passed to usbmsc_setupcmd()) */ + +#define USBMSC_FLAGS_DIRMASK (0x03) /* Bits 0-1: Data direction */ +#define USBMSC_FLAGS_DIRNONE (0x00) /* No data to send */ +#define USBMSC_FLAGS_DIRHOST2DEVICE (0x01) /* Host-to-device */ +#define USBMSC_FLAGS_DIRDEVICE2HOST (0x02) /* Device-to-host */ +#define USBMSC_FLAGS_BLOCKXFR (0x04) /* Bit 2: Command is a block transfer request */ +#define USBMSC_FLAGS_LUNNOTNEEDED (0x08) /* Bit 3: Command does not require a valid LUN */ +#define USBMSC_FLAGS_UACOKAY (0x10) /* Bit 4: Command OK if unit attention condition */ +#define USBMSC_FLAGS_RETAINSENSEDATA (0x20) /* Bit 5: Do not clear sense data */ /* Descriptors **************************************************************/ /* Big enough to hold our biggest descriptor */ -#define USBSTRG_MXDESCLEN (64) +#define USBMSC_MXDESCLEN (64) /* String language */ -#define USBSTRG_STR_LANGUAGE (0x0409) /* en-us */ +#define USBMSC_STR_LANGUAGE (0x0409) /* en-us */ /* Descriptor strings */ -#ifndef CONFIG_USBSTRG_COMPOSITE -# define USBSTRG_MANUFACTURERSTRID (1) -# define USBSTRG_PRODUCTSTRID (2) -# define USBSTRG_SERIALSTRID (3) -# define USBSTRG_CONFIGSTRID (4) -# define USBSTRG_INTERFACESTRID USBSTRG_CONFIGSTRID +#ifndef CONFIG_USBMSC_COMPOSITE +# define USBMSC_MANUFACTURERSTRID (1) +# define USBMSC_PRODUCTSTRID (2) +# define USBMSC_SERIALSTRID (3) +# define USBMSC_CONFIGSTRID (4) +# define USBMSC_INTERFACESTRID USBMSC_CONFIGSTRID -# undef CONFIG_USBSTRG_STRBASE -# define CONFIG_USBSTRG_STRBASE (4) +# undef CONFIG_USBMSC_STRBASE +# define CONFIG_USBMSC_STRBASE (4) #else -# define USBSTRG_INTERFACESTRID (CONFIG_USBSTRG_STRBASE+1) +# define USBMSC_INTERFACESTRID (CONFIG_USBMSC_STRBASE+1) #endif -#define USBSTRG_LASTSTRID USBSTRG_INTERFACESTRID +#define USBMSC_LASTSTRID USBMSC_INTERFACESTRID -#define USBSTRG_NCONFIGS (1) /* Number of configurations supported */ +#define USBMSC_NCONFIGS (1) /* Number of configurations supported */ /* Configuration Descriptor */ -#define USBSTRG_NINTERFACES (1) /* Number of interfaces in the configuration */ -#define USBSTRG_INTERFACEID (CONFIG_USBSTRG_IFNOBASE+0) -#define USBSTRG_ALTINTERFACEID USBSTRG_INTERFACEID +#define USBMSC_NINTERFACES (1) /* Number of interfaces in the configuration */ +#define USBMSC_INTERFACEID (CONFIG_USBMSC_IFNOBASE+0) +#define USBMSC_ALTINTERFACEID USBMSC_INTERFACEID -#define USBSTRG_CONFIGIDNONE (0) /* Config ID means to return to address mode */ -#define USBSTRG_CONFIGID (1) /* The only supported configuration ID */ +#define USBMSC_CONFIGIDNONE (0) /* Config ID means to return to address mode */ +#define USBMSC_CONFIGID (1) /* The only supported configuration ID */ /* Interface description */ -#define USBSTRG_NENDPOINTS (2) /* Number of endpoints in the interface */ +#define USBMSC_NENDPOINTS (2) /* Number of endpoints in the interface */ /* Endpoint configuration */ -#define USBSTRG_EPOUTBULK_ADDR (CONFIG_USBSTRG_EPBULKOUT) -#define USBSTRG_EPOUTBULK_ATTR (USB_EP_ATTR_XFER_BULK) +#define USBMSC_EPOUTBULK_ADDR (CONFIG_USBMSC_EPBULKOUT) +#define USBMSC_EPOUTBULK_ATTR (USB_EP_ATTR_XFER_BULK) -#define USBSTRG_EPINBULK_ADDR (USB_DIR_IN|CONFIG_USBSTRG_EPBULKIN) -#define USBSTRG_EPINBULK_ATTR (USB_EP_ATTR_XFER_BULK) +#define USBMSC_EPINBULK_ADDR (USB_DIR_IN|CONFIG_USBMSC_EPBULKIN) +#define USBMSC_EPINBULK_ATTR (USB_EP_ATTR_XFER_BULK) -#define USBSTRG_HSBULKMAXPACKET (512) -#define USBSTRG_HSBULKMXPKTSHIFT (9) -#define USBSTRG_HSBULKMXPKTMASK (0x000001ff) -#define USBSTRG_FSBULKMAXPACKET (64) -#define USBSTRG_FSBULKMXPKTSHIFT (6) -#define USBSTRG_FSBULKMXPKTMASK (0x0000003f) +#define USBMSC_HSBULKMAXPACKET (512) +#define USBMSC_HSBULKMXPKTSHIFT (9) +#define USBMSC_HSBULKMXPKTMASK (0x000001ff) +#define USBMSC_FSBULKMAXPACKET (64) +#define USBMSC_FSBULKMXPKTSHIFT (6) +#define USBMSC_FSBULKMXPKTMASK (0x0000003f) /* Macros for dual speed vs. full speed only operation */ #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) \ - (((d)->speed==USB_SPEED_HIGH) ? USBSTRG_HSBULKMXPKTSHIFT : USBSTRG_FSBULKMXPKTSHIFT) -# define USBSTRG_BULKMXPKTMASK(d) \ - (((d)->speed==USB_SPEED_HIGH) ? USBSTRG_HSBULKMXPKTMASK : USBSTRG_FSBULKMXPKTMASK) +# define USBMSC_EPBULKINDESC(hs) \ + usbmsc_getepdesc((hs) ? USBMSC_EPHSBULKIN : USBMSC_EPFSBULKIN) +# define USBMSC_EPBULKOUTDESC(hs) \ + usbmsc_getepdesc((hs) ? USBMSC_EPHSBULKOUT : USBMSC_EPFSBULKOUT) +# define USBMSC_BULKMAXPACKET(hs) \ + ((hs) ? USBMSC_HSBULKMAXPACKET : USBMSC_FSBULKMAXPACKET) +# define USBMSC_BULKMXPKTSHIFT(d) \ + (((d)->speed==USB_SPEED_HIGH) ? USBMSC_HSBULKMXPKTSHIFT : USBMSC_FSBULKMXPKTSHIFT) +# define USBMSC_BULKMXPKTMASK(d) \ + (((d)->speed==USB_SPEED_HIGH) ? USBMSC_HSBULKMXPKTMASK : USBMSC_FSBULKMXPKTMASK) #else -# 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 +# define USBMSC_EPBULKINDESC(d) usbmsc_getepdesc(USBMSC_EPFSBULKIN) +# define USBMSC_EPBULKOUTDESC(d) usbmsc_getepdesc(USBMSC_EPFSBULKOUT) +# define USBMSC_BULKMAXPACKET(hs) USBMSC_FSBULKMAXPACKET +# define USBMSC_BULKMXPKTSHIFT(d) USBMSC_FSBULKMXPKTSHIFT +# define USBMSC_BULKMXPKTMASK(d) USBMSC_FSBULKMXPKTMASK #endif /* Configuration descriptor size */ -#ifndef CONFIG_USBSTRG_COMPOSITE +#ifndef CONFIG_USBMSC_COMPOSITE /* Number of individual descriptors in the configuration descriptor: * (1) Configuration descriptor + (1) interface descriptor + (2) interface * descriptors. */ -# define USBSTRG_CFGGROUP_SIZE (4) +# define USBMSC_CFGGROUP_SIZE (4) /* The size of the config descriptor: (9 + 9 + 2*7) = 32 */ -# define SIZEOF_USBSTRG_CFGDESC \ +# define SIZEOF_USBMSC_CFGDESC \ (USB_SIZEOF_CFGDESC + USB_SIZEOF_IFDESC + 2*USB_SIZEOF_EPDESC) #else @@ -376,18 +376,18 @@ * (1) interface descriptor + (2) interface descriptors. */ -# define USBSTRG_CFGGROUP_SIZE (3) +# define USBMSC_CFGGROUP_SIZE (3) /* The size of the config descriptor: (9 + 2*7) = 23 */ -# define SIZEOF_USBSTRG_CFGDESC (USB_SIZEOF_IFDESC + 2*USB_SIZEOF_EPDESC) +# define SIZEOF_USBMSC_CFGDESC (USB_SIZEOF_IFDESC + 2*USB_SIZEOF_EPDESC) #endif /* Block driver helpers *****************************************************/ -#define USBSTRG_DRVR_READ(l,b,s,n) ((l)->inode->u.i_bops->read((l)->inode,b,s,n)) -#define USBSTRG_DRVR_WRITE(l,b,s,n) ((l)->inode->u.i_bops->write((l)->inode,b,s,n)) -#define USBSTRG_DRVR_GEOMETRY(l,g) ((l)->inode->u.i_bops->geometry((l)->inode,g)) +#define USBMSC_DRVR_READ(l,b,s,n) ((l)->inode->u.i_bops->read((l)->inode,b,s,n)) +#define USBMSC_DRVR_WRITE(l,b,s,n) ((l)->inode->u.i_bops->write((l)->inode,b,s,n)) +#define USBMSC_DRVR_GEOMETRY(l,g) ((l)->inode->u.i_bops->geometry((l)->inode,g)) /* Everpresent MIN/MAX macros ***********************************************/ @@ -404,28 +404,28 @@ ****************************************************************************/ /* Endpoint descriptors */ -enum usbstrg_epdesc_e +enum usbmsc_epdesc_e { - USBSTRG_EPFSBULKOUT = 0, /* Full speed bulk OUT endpoint descriptor */ - USBSTRG_EPFSBULKIN /* Full speed bulk IN endpoint descriptor */ + USBMSC_EPFSBULKOUT = 0, /* Full speed bulk OUT endpoint descriptor */ + USBMSC_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 */ + USBMSC_EPHSBULKOUT, /* High speed bulk OUT endpoint descriptor */ + USBMSC_EPHSBULKIN /* High speed bulk IN endpoint descriptor */ #endif }; /* Container to support a list of requests */ -struct usbstrg_req_s +struct usbmsc_req_s { - FAR struct usbstrg_req_s *flink; /* Implements a singly linked list */ + FAR struct usbmsc_req_s *flink; /* Implements a singly linked list */ FAR struct usbdev_req_s *req; /* The contained request */ }; /* This structure describes one LUN: */ -struct usbstrg_lun_s +struct usbmsc_lun_s { struct inode *inode; /* Inode structure of open'ed block driver */ uint8_t readonly:1; /* Media is read-only */ @@ -440,7 +440,7 @@ struct usbstrg_lun_s /* Describes the overall state of the driver */ -struct usbstrg_dev_s +struct usbmsc_dev_s { FAR struct usbdev_s *usbdev; /* usbdev driver pointer (Non-null if registered) */ @@ -466,12 +466,12 @@ struct usbstrg_dev_s /* SCSI command processing */ - struct usbstrg_lun_s *lun; /* Currently selected LUN */ - struct usbstrg_lun_s *luntab; /* Allocated table of all LUNs */ - uint8_t cdb[USBSTRG_MAXCDBLEN]; /* Command data (cdb[]) from CBW */ + struct usbmsc_lun_s *lun; /* Currently selected LUN */ + struct usbmsc_lun_s *luntab; /* Allocated table of all LUNs */ + uint8_t cdb[USBMSC_MAXCDBLEN]; /* Command data (cdb[]) from CBW */ uint8_t phaseerror:1; /* Need to send phase sensing status */ uint8_t shortpacket:1; /* Host transmission stopped unexpectedly */ - uint8_t cbwdir:2; /* Direction from CBW. See USBSTRG_FLAGS_DIR* definitions */ + uint8_t cbwdir:2; /* Direction from CBW. See USBMSC_FLAGS_DIR* definitions */ uint8_t cdblen; /* Length of cdb[] from CBW */ uint8_t cbwlun; /* LUN from the CBW */ uint16_t nsectbytes; /* Bytes buffered in iobuffer[] */ @@ -498,8 +498,8 @@ struct usbstrg_dev_s * EPBULKIN; Read requests will be queued in the EBULKOUT. */ - struct usbstrg_req_s wrreqs[CONFIG_USBSTRG_NWRREQS]; - struct usbstrg_req_s rdreqs[CONFIG_USBSTRG_NRDREQS]; + struct usbmsc_req_s wrreqs[CONFIG_USBMSC_NWRREQS]; + struct usbmsc_req_s rdreqs[CONFIG_USBMSC_NRDREQS]; }; /**************************************************************************** @@ -519,7 +519,7 @@ extern "C" /* Mass storage class vendor/product/serial number strings */ -#ifndef CONFIG_USBSTRG_COMPOSITE +#ifndef CONFIG_USBMSC_COMPOSITE EXTERN const char g_mscvendorstr[]; EXTERN const char g_mscproductstr[]; EXTERN const char g_mscserialstr[]; @@ -542,7 +542,7 @@ EXTERN const char g_compserialstr[]; ************************************************************************************/ /************************************************************************************ - * Name: usbstrg_mkstrdesc + * Name: usbmsc_mkstrdesc * * Description: * Construct a string descriptor @@ -550,22 +550,22 @@ EXTERN const char g_compserialstr[]; ************************************************************************************/ struct usb_strdesc_s; -int usbstrg_mkstrdesc(uint8_t id, struct usb_strdesc_s *strdesc); +int usbmsc_mkstrdesc(uint8_t id, struct usb_strdesc_s *strdesc); /************************************************************************************ - * Name: usbstrg_getepdesc + * Name: usbmsc_getepdesc * * Description: * Return a pointer to the raw device descriptor * ************************************************************************************/ -#ifndef CONFIG_USBSTRG_COMPOSITE -FAR const struct usb_devdesc_s *usbstrg_getdevdesc(void); +#ifndef CONFIG_USBMSC_COMPOSITE +FAR const struct usb_devdesc_s *usbmsc_getdevdesc(void); #endif /************************************************************************************ - * Name: usbstrg_getepdesc + * Name: usbmsc_getepdesc * * Description: * Return a pointer to the raw endpoint descriptor (used for configuring endpoints) @@ -573,10 +573,10 @@ FAR const struct usb_devdesc_s *usbstrg_getdevdesc(void); ************************************************************************************/ struct usb_epdesc_s; -FAR const struct usb_epdesc_s *usbstrg_getepdesc(enum usbstrg_epdesc_e epid); +FAR const struct usb_epdesc_s *usbmsc_getepdesc(enum usbmsc_epdesc_e epid); /************************************************************************************ - * Name: usbstrg_mkcfgdesc + * Name: usbmsc_mkcfgdesc * * Description: * Construct the configuration descriptor @@ -584,25 +584,25 @@ FAR const struct usb_epdesc_s *usbstrg_getepdesc(enum usbstrg_epdesc_e epid); ************************************************************************************/ #ifdef CONFIG_USBDEV_DUALSPEED -int16_t usbstrg_mkcfgdesc(FAR uint8_t *buf, uint8_t speed, uint8_t type); +int16_t usbmsc_mkcfgdesc(FAR uint8_t *buf, uint8_t speed, uint8_t type); #else -int16_t usbstrg_mkcfgdesc(FAR uint8_t *buf); +int16_t usbmsc_mkcfgdesc(FAR uint8_t *buf); #endif /************************************************************************************ - * Name: usbstrg_getqualdesc + * Name: usbmsc_getqualdesc * * Description: * Return a pointer to the raw qual descriptor * ************************************************************************************/ -#if !defined(CONFIG_USBSTRG_COMPOSITE) && defined(CONFIG_USBDEV_DUALSPEED) -FAR const struct usb_qualdesc_s *usbstrg_getqualdesc(void); +#if !defined(CONFIG_USBMSC_COMPOSITE) && defined(CONFIG_USBDEV_DUALSPEED) +FAR const struct usb_qualdesc_s *usbmsc_getqualdesc(void); #endif /**************************************************************************** - * Name: usbstrg_workerthread + * Name: usbmsc_workerthread * * Description: * This is the main function of the USB storage worker thread. It loops @@ -610,10 +610,10 @@ FAR const struct usb_qualdesc_s *usbstrg_getqualdesc(void); * ****************************************************************************/ -EXTERN void *usbstrg_workerthread(void *arg); +EXTERN void *usbmsc_workerthread(void *arg); /**************************************************************************** - * Name: usbstrg_setconfig + * Name: usbmsc_setconfig * * Description: * Set the device configuration by allocating and configuring endpoints and @@ -621,20 +621,20 @@ EXTERN void *usbstrg_workerthread(void *arg); * ****************************************************************************/ -EXTERN int usbstrg_setconfig(FAR struct usbstrg_dev_s *priv, uint8_t config); +EXTERN int usbmsc_setconfig(FAR struct usbmsc_dev_s *priv, uint8_t config); /**************************************************************************** - * Name: usbstrg_resetconfig + * Name: usbmsc_resetconfig * * Description: * Mark the device as not configured and disable all endpoints. * ****************************************************************************/ -EXTERN void usbstrg_resetconfig(FAR struct usbstrg_dev_s *priv); +EXTERN void usbmsc_resetconfig(FAR struct usbmsc_dev_s *priv); /**************************************************************************** - * Name: usbstrg_wrcomplete + * Name: usbmsc_wrcomplete * * Description: * Handle completion of write request. This function probably executes @@ -642,11 +642,11 @@ EXTERN void usbstrg_resetconfig(FAR struct usbstrg_dev_s *priv); * ****************************************************************************/ -EXTERN void usbstrg_wrcomplete(FAR struct usbdev_ep_s *ep, - FAR struct usbdev_req_s *req); +EXTERN void usbmsc_wrcomplete(FAR struct usbdev_ep_s *ep, + FAR struct usbdev_req_s *req); /**************************************************************************** - * Name: usbstrg_rdcomplete + * Name: usbmsc_rdcomplete * * Description: * Handle completion of read request on the bulk OUT endpoint. This @@ -654,11 +654,11 @@ EXTERN void usbstrg_wrcomplete(FAR struct usbdev_ep_s *ep, * ****************************************************************************/ -EXTERN void usbstrg_rdcomplete(FAR struct usbdev_ep_s *ep, - FAR struct usbdev_req_s *req); +EXTERN void usbmsc_rdcomplete(FAR struct usbdev_ep_s *ep, + FAR struct usbdev_req_s *req); /**************************************************************************** - * Name: usbstrg_deferredresponse + * Name: usbmsc_deferredresponse * * Description: * Some EP0 setup request cannot be responded to immediately becuase they @@ -668,7 +668,7 @@ EXTERN void usbstrg_rdcomplete(FAR struct usbdev_ep_s *ep, * * 1. USB_REQ_SETCONFIGURATION, * 2. USB_REQ_SETINTERFACE, or - * 3. USBSTRG_REQ_MSRESET + * 3. USBMSC_REQ_MSRESET * * In all cases, the success reponse is a zero-length packet; the failure * response is an EP0 stall. @@ -679,7 +679,7 @@ EXTERN void usbstrg_rdcomplete(FAR struct usbdev_ep_s *ep, * ****************************************************************************/ -EXTERN void usbstrg_deferredresponse(FAR struct usbstrg_dev_s *priv, bool failed); +EXTERN void usbmsc_deferredresponse(FAR struct usbmsc_dev_s *priv, bool failed); #undef EXTERN #if defined(__cplusplus) diff --git a/nuttx/drivers/usbdev/msc_descriptors.c b/nuttx/drivers/usbdev/msc_descriptors.c index 8d9e8a839..467eaced8 100644 --- a/nuttx/drivers/usbdev/msc_descriptors.c +++ b/nuttx/drivers/usbdev/msc_descriptors.c @@ -71,7 +71,7 @@ * composite device logic. */ -#ifndef CONFIG_USBSTRG_COMPOSITE +#ifndef CONFIG_USBMSC_COMPOSITE static const struct usb_devdesc_s g_devdesc = { USB_SIZEOF_DEVDESC, /* len */ @@ -80,22 +80,22 @@ static const struct usb_devdesc_s g_devdesc = USB_CLASS_PER_INTERFACE, /* class */ 0, /* subclass */ 0, /* protocol */ - CONFIG_USBSTRG_EP0MAXPACKET, /* maxpacketsize */ + CONFIG_USBMSC_EP0MAXPACKET, /* maxpacketsize */ { /* vendor */ - LSBYTE(CONFIG_USBSTRG_VENDORID), - MSBYTE(CONFIG_USBSTRG_VENDORID) + LSBYTE(CONFIG_USBMSC_VENDORID), + MSBYTE(CONFIG_USBMSC_VENDORID) }, { /* product */ - LSBYTE(CONFIG_USBSTRG_PRODUCTID), - MSBYTE(CONFIG_USBSTRG_PRODUCTID) }, + LSBYTE(CONFIG_USBMSC_PRODUCTID), + MSBYTE(CONFIG_USBMSC_PRODUCTID) }, { /* device */ - LSBYTE(CONFIG_USBSTRG_VERSIONNO), - MSBYTE(CONFIG_USBSTRG_VERSIONNO) + LSBYTE(CONFIG_USBMSC_VERSIONNO), + MSBYTE(CONFIG_USBMSC_VERSIONNO) }, - USBSTRG_MANUFACTURERSTRID, /* imfgr */ - USBSTRG_PRODUCTSTRID, /* iproduct */ - USBSTRG_SERIALSTRID, /* serno */ - USBSTRG_NCONFIGS /* nconfigs */ + USBMSC_MANUFACTURERSTRID, /* imfgr */ + USBMSC_PRODUCTSTRID, /* iproduct */ + USBMSC_SERIALSTRID, /* serno */ + USBMSC_NCONFIGS /* nconfigs */ }; #endif @@ -104,15 +104,15 @@ static const struct usb_devdesc_s g_devdesc = * composite device logic. */ -#ifndef CONFIG_USBSTRG_COMPOSITE +#ifndef CONFIG_USBMSC_COMPOSITE 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 */ + USBMSC_NINTERFACES, /* ninterfaces */ + USBMSC_CONFIGID, /* cfgvalue */ + USBMSC_CONFIGSTRID, /* icfg */ USB_CONFIG_ATTR_ONE|SELFPOWERED|REMOTEWAKEUP, /* attr */ (CONFIG_USBDEV_MAXPOWER + 1) / 2 /* mxpower */ }; @@ -124,13 +124,13 @@ 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 */ + USBMSC_INTERFACEID, /* ifno */ + USBMSC_ALTINTERFACEID, /* alt */ + USBMSC_NENDPOINTS, /* neps */ USB_CLASS_MASS_STORAGE, /* class */ - USBSTRG_SUBCLASS_SCSI, /* subclass */ - USBSTRG_PROTO_BULKONLY, /* protocol */ - USBSTRG_INTERFACESTRID /* iif */ + USBMSC_SUBCLASS_SCSI, /* subclass */ + USBMSC_PROTO_BULKONLY, /* protocol */ + USBMSC_INTERFACESTRID /* iif */ }; /* Endpoint descriptors */ @@ -139,11 +139,11 @@ 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 */ + USBMSC_EPOUTBULK_ADDR, /* addr */ + USBMSC_EPOUTBULK_ATTR, /* attr */ { /* maxpacket */ - LSBYTE(USBSTRG_FSBULKMAXPACKET), - MSBYTE(USBSTRG_FSBULKMAXPACKET) + LSBYTE(USBMSC_FSBULKMAXPACKET), + MSBYTE(USBMSC_FSBULKMAXPACKET) }, 0 /* interval */ }; @@ -152,17 +152,17 @@ 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 */ + USBMSC_EPINBULK_ADDR, /* addr */ + USBMSC_EPINBULK_ATTR, /* attr */ { /* maxpacket */ - LSBYTE(USBSTRG_FSBULKMAXPACKET), - MSBYTE(USBSTRG_FSBULKMAXPACKET) + LSBYTE(USBMSC_FSBULKMAXPACKET), + MSBYTE(USBMSC_FSBULKMAXPACKET) }, 0 /* interval */ }; #ifdef CONFIG_USBDEV_DUALSPEED -#ifndef CONFIG_USBSTRG_COMPOSITE +#ifndef CONFIG_USBMSC_COMPOSITE static const struct usb_qualdesc_s g_qualdesc = { USB_SIZEOF_QUALDESC, /* len */ @@ -174,8 +174,8 @@ static const struct usb_qualdesc_s g_qualdesc = USB_CLASS_PER_INTERFACE, /* class */ 0, /* subclass */ 0, /* protocol */ - CONFIG_USBSTRG_EP0MAXPACKET, /* mxpacketsize */ - USBSTRG_NCONFIGS, /* nconfigs */ + CONFIG_USBMSC_EP0MAXPACKET, /* mxpacketsize */ + USBMSC_NCONFIGS, /* nconfigs */ 0, /* reserved */ }; #endif @@ -184,11 +184,11 @@ 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 */ + USBMSC_EPOUTBULK_ADDR, /* addr */ + USBMSC_EPOUTBULK_ATTR, /* attr */ { /* maxpacket */ - LSBYTE(USBSTRG_HSBULKMAXPACKET), - MSBYTE(USBSTRG_HSBULKMAXPACKET) + LSBYTE(USBMSC_HSBULKMAXPACKET), + MSBYTE(USBMSC_HSBULKMAXPACKET) }, 0 /* interval */ }; @@ -197,11 +197,11 @@ 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 */ + USBMSC_EPINBULK_ADDR, /* addr */ + USBMSC_EPINBULK_ATTR, /* attr */ { /* maxpacket */ - LSBYTE(USBSTRG_HSBULKMAXPACKET), - MSBYTE(USBSTRG_HSBULKMAXPACKET) + LSBYTE(USBMSC_HSBULKMAXPACKET), + MSBYTE(USBMSC_HSBULKMAXPACKET) }, 0 /* interval */ }; @@ -212,10 +212,10 @@ static const struct usb_epdesc_s g_hsepbulkindesc = ****************************************************************************/ /* Strings ******************************************************************/ -#ifndef CONFIG_USBSTRG_COMPOSITE -const char g_msccendorstr[] = CONFIG_USBSTRG_VENDORSTR; -const char g_mscproductstr[] = CONFIG_USBSTRG_PRODUCTSTR; -const char g_mscserialstr[] = CONFIG_USBSTRG_SERIALSTR; +#ifndef CONFIG_USBMSC_COMPOSITE +const char g_msccendorstr[] = CONFIG_USBMSC_VENDORSTR; +const char g_mscproductstr[] = CONFIG_USBMSC_PRODUCTSTR; +const char g_mscserialstr[] = CONFIG_USBMSC_SERIALSTR; #endif /**************************************************************************** @@ -227,14 +227,14 @@ const char g_mscserialstr[] = CONFIG_USBSTRG_SERIALSTR; ****************************************************************************/ /**************************************************************************** - * Name: usbstrg_mkstrdesc + * Name: usbmsc_mkstrdesc * * Description: * Construct a string descriptor * ****************************************************************************/ -int usbstrg_mkstrdesc(uint8_t id, struct usb_strdesc_s *strdesc) +int usbmsc_mkstrdesc(uint8_t id, struct usb_strdesc_s *strdesc) { const char *str; int len; @@ -243,34 +243,34 @@ int usbstrg_mkstrdesc(uint8_t id, struct usb_strdesc_s *strdesc) switch (id) { -#ifndef CONFIG_USBSTRG_COMPOSITE +#ifndef CONFIG_USBMSC_COMPOSITE 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); + strdesc->data[0] = LSBYTE(USBMSC_STR_LANGUAGE); + strdesc->data[1] = MSBYTE(USBMSC_STR_LANGUAGE); return 4; } - case USBSTRG_MANUFACTURERSTRID: + case USBMSC_MANUFACTURERSTRID: str = g_vendorstr; break; - case USBSTRG_PRODUCTSTRID: + case USBMSC_PRODUCTSTRID: str = g_productstr; break; - case USBSTRG_SERIALSTRID: + case USBMSC_SERIALSTRID: str = g_serialstr; break; #endif - /* case USBSTRG_CONFIGSTRID: */ - case USBSTRG_INTERFACESTRID: - str = CONFIG_USBSTRG_CONFIGSTR; + /* case USBMSC_CONFIGSTRID: */ + case USBMSC_INTERFACESTRID: + str = CONFIG_USBMSC_CONFIGSTR; break; default: @@ -294,22 +294,22 @@ int usbstrg_mkstrdesc(uint8_t id, struct usb_strdesc_s *strdesc) } /**************************************************************************** - * Name: usbstrg_getepdesc + * Name: usbmsc_getepdesc * * Description: * Return a pointer to the raw device descriptor * ****************************************************************************/ -#ifndef CONFIG_USBSTRG_COMPOSITE -FAR const struct usb_devdesc_s *usbstrg_getdevdesc(void) +#ifndef CONFIG_USBMSC_COMPOSITE +FAR const struct usb_devdesc_s *usbmsc_getdevdesc(void) { return &g_devdesc; } #endif /**************************************************************************** - * Name: usbstrg_getepdesc + * Name: usbmsc_getepdesc * * Description: * Return a pointer to the raw endpoint descriptor (used for configuring @@ -317,21 +317,21 @@ FAR const struct usb_devdesc_s *usbstrg_getdevdesc(void) * ****************************************************************************/ -FAR const struct usb_epdesc_s *usbstrg_getepdesc(enum usbstrg_epdesc_e epid) +FAR const struct usb_epdesc_s *usbmsc_getepdesc(enum usbmsc_epdesc_e epid) { switch (epid) { - case USBSTRG_EPFSBULKOUT: /* Full speed bulk OUT endpoint descriptor */ + case USBMSC_EPFSBULKOUT: /* Full speed bulk OUT endpoint descriptor */ return &g_fsepbulkoutdesc; - case USBSTRG_EPFSBULKIN: /* Full speed bulk IN endpoint descriptor */ + case USBMSC_EPFSBULKIN: /* Full speed bulk IN endpoint descriptor */ return &g_fsepbulkindesc; #ifdef CONFIG_USBDEV_DUALSPEED - case USBSTRG_EPHSBULKOUT: /* High speed bulk OUT endpoint descriptor */ + case USBMSC_EPHSBULKOUT: /* High speed bulk OUT endpoint descriptor */ return &g_hsepbulkoutdesc; - case USBSTRG_EPHSBULKIN: /* High speed bulk IN endpoint descriptor */ + case USBMSC_EPHSBULKIN: /* High speed bulk IN endpoint descriptor */ return &g_hsepbulkindesc; #endif default: @@ -340,7 +340,7 @@ FAR const struct usb_epdesc_s *usbstrg_getepdesc(enum usbstrg_epdesc_e epid) }; /**************************************************************************** - * Name: usbstrg_mkcfgdesc + * Name: usbmsc_mkcfgdesc * * Description: * Construct the configuration descriptor @@ -348,12 +348,12 @@ FAR const struct usb_epdesc_s *usbstrg_getepdesc(enum usbstrg_epdesc_e epid) ****************************************************************************/ #ifdef CONFIG_USBDEV_DUALSPEED -int16_t usbstrg_mkcfgdesc(uint8_t *buf, uint8_t speed, uint8_t type) +int16_t usbmsc_mkcfgdesc(uint8_t *buf, uint8_t speed, uint8_t type) #else -int16_t usbstrg_mkcfgdesc(uint8_t *buf) +int16_t usbmsc_mkcfgdesc(uint8_t *buf) #endif { -#ifndef CONFIG_USBSTRG_COMPOSITE +#ifndef CONFIG_USBMSC_COMPOSITE FAR struct usb_cfgdesc_s *cfgdesc = (struct usb_cfgdesc_s*)buf; #endif #ifdef CONFIG_USBDEV_DUALSPEED @@ -367,7 +367,7 @@ int16_t usbstrg_mkcfgdesc(uint8_t *buf) * size that we will be sending now. */ - totallen = USB_SIZEOF_CFGDESC + USB_SIZEOF_IFDESC + USBSTRG_NENDPOINTS * USB_SIZEOF_EPDESC; + totallen = USB_SIZEOF_CFGDESC + USB_SIZEOF_IFDESC + USBMSC_NENDPOINTS * USB_SIZEOF_EPDESC; /* Configuration descriptor -- Copy the canned descriptor and fill in the * type (we'll also need to update the size below). If the USB mass storage @@ -375,7 +375,7 @@ int16_t usbstrg_mkcfgdesc(uint8_t *buf) * descriptor will be provided by the composite device logic. */ -#ifndef CONFIG_USBSTRG_COMPOSITE +#ifndef CONFIG_USBMSC_COMPOSITE memcpy(cfgdesc, &g_cfgdesc, USB_SIZEOF_CFGDESC); buf += USB_SIZEOF_CFGDESC; #endif @@ -396,12 +396,12 @@ int16_t usbstrg_mkcfgdesc(uint8_t *buf) hispeed = !hispeed; } - bulkmxpacket = USBSTRG_BULKMAXPACKET(hispeed); - epdesc = USBSTRG_EPBULKINDESC(hispeed); + bulkmxpacket = USBMSC_BULKMAXPACKET(hispeed); + epdesc = USBMSC_EPBULKINDESC(hispeed); memcpy(buf, epdesc, USB_SIZEOF_EPDESC); buf += USB_SIZEOF_EPDESC; - epdesc = USBSTRG_EPBULKOUTDESC(hispeed); + epdesc = USBMSC_EPBULKOUTDESC(hispeed); memcpy(buf, epdesc, USB_SIZEOF_EPDESC); #else memcpy(buf, &g_fsepbulkoutdesc, USB_SIZEOF_EPDESC); @@ -411,7 +411,7 @@ int16_t usbstrg_mkcfgdesc(uint8_t *buf) /* Finally, fill in the total size of the configuration descriptor */ -#ifndef CONFIG_USBSTRG_COMPOSITE +#ifndef CONFIG_USBMSC_COMPOSITE cfgdesc->totallen[0] = LSBYTE(totallen); cfgdesc->totallen[1] = MSBYTE(totallen); #endif @@ -419,15 +419,15 @@ int16_t usbstrg_mkcfgdesc(uint8_t *buf) } /**************************************************************************** - * Name: usbstrg_getqualdesc + * Name: usbmsc_getqualdesc * * Description: * Return a pointer to the raw qual descriptor * ****************************************************************************/ -#if !defined(CONFIG_USBSTRG_COMPOSITE) && defined(CONFIG_USBDEV_DUALSPEED) -FAR const struct usb_qualdesc_s *usbstrg_getqualdesc(void) +#if !defined(CONFIG_USBMSC_COMPOSITE) && defined(CONFIG_USBDEV_DUALSPEED) +FAR const struct usb_qualdesc_s *usbmsc_getqualdesc(void) { return &g_qualdesc; } diff --git a/nuttx/drivers/usbdev/msc_scsi.c b/nuttx/drivers/usbdev/msc_scsi.c index 6302b1a70..0af86011f 100644 --- a/nuttx/drivers/usbdev/msc_scsi.c +++ b/nuttx/drivers/usbdev/msc_scsi.c @@ -92,7 +92,7 @@ * transfer to resume it hadn't occurred." */ -#define CONFIG_USBSTRG_RACEWAR 1 +#define CONFIG_USBMSC_RACEWAR 1 /**************************************************************************** * Private Types @@ -105,68 +105,68 @@ /* Debug ********************************************************************/ #if defined(CONFIG_DEBUG_VERBOSE) && defined (CONFIG_DEBUG_USB) -static void usbstrg_dumpdata(const char *msg, const uint8_t *buf, - int buflen); +static void usbmsc_dumpdata(const char *msg, const uint8_t *buf, + int buflen); #else -# define usbstrg_dumpdata(msg, buf, len) +# define usbmsc_dumpdata(msg, buf, len) #endif /* Utility Support Functions ************************************************/ -static uint16_t usbstrg_getbe16(uint8_t *buf); -static uint32_t usbstrg_getbe32(uint8_t *buf); -static void usbstrg_putbe16(uint8_t * buf, uint16_t val); -static void usbstrg_putbe24(uint8_t *buf, uint32_t val); -static void usbstrg_putbe32(uint8_t *buf, uint32_t val); +static uint16_t usbmsc_getbe16(uint8_t *buf); +static uint32_t usbmsc_getbe32(uint8_t *buf); +static void usbmsc_putbe16(uint8_t * buf, uint16_t val); +static void usbmsc_putbe24(uint8_t *buf, uint32_t val); +static void usbmsc_putbe32(uint8_t *buf, uint32_t val); #if 0 /* not used */ -static uint16_t usbstrg_getle16(uint8_t *buf); +static uint16_t usbmsc_getle16(uint8_t *buf); #endif -static uint32_t usbstrg_getle32(uint8_t *buf); +static uint32_t usbmsc_getle32(uint8_t *buf); #if 0 /* not used */ -static void usbstrg_putle16(uint8_t * buf, uint16_t val); +static void usbmsc_putle16(uint8_t * buf, uint16_t val); #endif -static void usbstrg_putle32(uint8_t *buf, uint32_t val); +static void usbmsc_putle32(uint8_t *buf, uint32_t val); /* SCSI Command Processing **************************************************/ -static inline int usbstrg_cmdtestunitready(FAR struct usbstrg_dev_s *priv); -static inline int usbstrg_cmdrequestsense(FAR struct usbstrg_dev_s *priv, +static inline int usbmsc_cmdtestunitready(FAR struct usbmsc_dev_s *priv); +static inline int usbmsc_cmdrequestsense(FAR struct usbmsc_dev_s *priv, FAR uint8_t *buf); -static inline int usbstrg_cmdread6(FAR struct usbstrg_dev_s *priv); -static inline int usbstrg_cmdwrite6(FAR struct usbstrg_dev_s *priv); -static inline int usbstrg_cmdinquiry(FAR struct usbstrg_dev_s *priv, +static inline int usbmsc_cmdread6(FAR struct usbmsc_dev_s *priv); +static inline int usbmsc_cmdwrite6(FAR struct usbmsc_dev_s *priv); +static inline int usbmsc_cmdinquiry(FAR struct usbmsc_dev_s *priv, FAR uint8_t *buf); -static inline int usbstrg_cmdmodeselect6(FAR struct usbstrg_dev_s *priv); -static int usbstrg_modepage(FAR struct usbstrg_dev_s *priv, +static inline int usbmsc_cmdmodeselect6(FAR struct usbmsc_dev_s *priv); +static int usbmsc_modepage(FAR struct usbmsc_dev_s *priv, FAR uint8_t *buf, uint8_t pcpgcode, int *mdlen); -static inline int usbstrg_cmdmodesense6(FAR struct usbstrg_dev_s *priv, +static inline int usbmsc_cmdmodesense6(FAR struct usbmsc_dev_s *priv, FAR uint8_t *buf); -static inline int usbstrg_cmdstartstopunit(FAR struct usbstrg_dev_s *priv); -static inline int usbstrg_cmdpreventmediumremoval(FAR struct usbstrg_dev_s *priv); -static inline int usbstrg_cmdreadformatcapacity(FAR struct usbstrg_dev_s *priv, +static inline int usbmsc_cmdstartstopunit(FAR struct usbmsc_dev_s *priv); +static inline int usbmsc_cmdpreventmediumremoval(FAR struct usbmsc_dev_s *priv); +static inline int usbmsc_cmdreadformatcapacity(FAR struct usbmsc_dev_s *priv, FAR uint8_t *buf); -static inline int usbstrg_cmdreadcapacity10(FAR struct usbstrg_dev_s *priv, +static inline int usbmsc_cmdreadcapacity10(FAR struct usbmsc_dev_s *priv, FAR uint8_t *buf); -static inline int usbstrg_cmdread10(FAR struct usbstrg_dev_s *priv); -static inline int usbstrg_cmdwrite10(FAR struct usbstrg_dev_s *priv); -static inline int usbstrg_cmdverify10(FAR struct usbstrg_dev_s *priv); -static inline int usbstrg_cmdsynchronizecache10(FAR struct usbstrg_dev_s *priv); -static inline int usbstrg_cmdmodeselect10(FAR struct usbstrg_dev_s *priv); -static inline int usbstrg_cmdmodesense10(FAR struct usbstrg_dev_s *priv, +static inline int usbmsc_cmdread10(FAR struct usbmsc_dev_s *priv); +static inline int usbmsc_cmdwrite10(FAR struct usbmsc_dev_s *priv); +static inline int usbmsc_cmdverify10(FAR struct usbmsc_dev_s *priv); +static inline int usbmsc_cmdsynchronizecache10(FAR struct usbmsc_dev_s *priv); +static inline int usbmsc_cmdmodeselect10(FAR struct usbmsc_dev_s *priv); +static inline int usbmsc_cmdmodesense10(FAR struct usbmsc_dev_s *priv, FAR uint8_t *buf); -static inline int usbstrg_cmdread12(FAR struct usbstrg_dev_s *priv); -static inline int usbstrg_cmdwrite12(FAR struct usbstrg_dev_s *priv); -static inline int usbstrg_setupcmd(FAR struct usbstrg_dev_s *priv, +static inline int usbmsc_cmdread12(FAR struct usbmsc_dev_s *priv); +static inline int usbmsc_cmdwrite12(FAR struct usbmsc_dev_s *priv); +static inline int usbmsc_setupcmd(FAR struct usbmsc_dev_s *priv, uint8_t cdblen, uint8_t flags); /* SCSI Worker Thread *******************************************************/ -static int usbstrg_idlestate(FAR struct usbstrg_dev_s *priv); -static int usbstrg_cmdparsestate(FAR struct usbstrg_dev_s *priv); -static int usbstrg_cmdreadstate(FAR struct usbstrg_dev_s *priv); -static int usbstrg_cmdwritestate(FAR struct usbstrg_dev_s *priv); -static int usbstrg_cmdfinishstate(FAR struct usbstrg_dev_s *priv); -static int usbstrg_cmdstatusstate(FAR struct usbstrg_dev_s *priv); +static int usbmsc_idlestate(FAR struct usbmsc_dev_s *priv); +static int usbmsc_cmdparsestate(FAR struct usbmsc_dev_s *priv); +static int usbmsc_cmdreadstate(FAR struct usbmsc_dev_s *priv); +static int usbmsc_cmdwritestate(FAR struct usbmsc_dev_s *priv); +static int usbmsc_cmdfinishstate(FAR struct usbmsc_dev_s *priv); +static int usbmsc_cmdstatusstate(FAR struct usbmsc_dev_s *priv); /**************************************************************************** * Private Data @@ -181,11 +181,11 @@ static int usbstrg_cmdstatusstate(FAR struct usbstrg_dev_s *priv); ****************************************************************************/ /**************************************************************************** - * Name: usbstrg_dumpdata + * Name: usbmsc_dumpdata ****************************************************************************/ #if defined(CONFIG_DEBUG_VERBOSE) && defined (CONFIG_DEBUG_USB) -static void usbstrg_dumpdata(const char *msg, const uint8_t *buf, int buflen) +static void usbmsc_dumpdata(const char *msg, const uint8_t *buf, int buflen) { int i; @@ -203,34 +203,34 @@ static void usbstrg_dumpdata(const char *msg, const uint8_t *buf, int buflen) ****************************************************************************/ /**************************************************************************** - * Name: usbstrg_getbe16 + * Name: usbmsc_getbe16 * * Description: * Get a 16-bit big-endian value reference by the byte pointer * ****************************************************************************/ -static uint16_t usbstrg_getbe16(uint8_t *buf) +static uint16_t usbmsc_getbe16(uint8_t *buf) { return ((uint16_t)buf[0] << 8) | ((uint16_t)buf[1]); } /**************************************************************************** - * Name: usbstrg_getbe32 + * Name: usbmsc_getbe32 * * Description: * Get a 32-bit big-endian value reference by the byte pointer * ****************************************************************************/ -static uint32_t usbstrg_getbe32(uint8_t *buf) +static uint32_t usbmsc_getbe32(uint8_t *buf) { return ((uint32_t)buf[0] << 24) | ((uint32_t)buf[1] << 16) | ((uint32_t)buf[2] << 8) | ((uint32_t)buf[3]); } /**************************************************************************** - * Name: usbstrg_putbe16 + * Name: usbmsc_putbe16 * * Description: * Store a 16-bit value in big-endian order to the location specified by @@ -238,14 +238,14 @@ static uint32_t usbstrg_getbe32(uint8_t *buf) * ****************************************************************************/ -static void usbstrg_putbe16(uint8_t * buf, uint16_t val) +static void usbmsc_putbe16(uint8_t * buf, uint16_t val) { buf[0] = val >> 8; buf[1] = val; } /**************************************************************************** - * Name: usbstrg_putbe24 + * Name: usbmsc_putbe24 * * Description: * Store a 32-bit value in big-endian order to the location specified by @@ -253,7 +253,7 @@ static void usbstrg_putbe16(uint8_t * buf, uint16_t val) * ****************************************************************************/ -static void usbstrg_putbe24(uint8_t *buf, uint32_t val) +static void usbmsc_putbe24(uint8_t *buf, uint32_t val) { buf[0] = val >> 16; buf[1] = val >> 8; @@ -261,7 +261,7 @@ static void usbstrg_putbe24(uint8_t *buf, uint32_t val) } /**************************************************************************** - * Name: usbstrg_putbe32 + * Name: usbmsc_putbe32 * * Description: * Store a 32-bit value in big-endian order to the location specified by @@ -269,7 +269,7 @@ static void usbstrg_putbe24(uint8_t *buf, uint32_t val) * ****************************************************************************/ -static void usbstrg_putbe32(uint8_t *buf, uint32_t val) +static void usbmsc_putbe32(uint8_t *buf, uint32_t val) { buf[0] = val >> 24; buf[1] = val >> 16; @@ -278,7 +278,7 @@ static void usbstrg_putbe32(uint8_t *buf, uint32_t val) } /**************************************************************************** - * Name: usbstrg_getle16 + * Name: usbmsc_getle16 * * Description: * Get a 16-bit little-endian value reference by the byte pointer @@ -286,28 +286,28 @@ static void usbstrg_putbe32(uint8_t *buf, uint32_t val) ****************************************************************************/ #if 0 /* not used */ -static uint16_t usbstrg_getle16(uint8_t *buf) +static uint16_t usbmsc_getle16(uint8_t *buf) { return ((uint16_t)buf[1] << 8) | ((uint16_t)buf[0]); } #endif /**************************************************************************** - * Name: usbstrg_getle32 + * Name: usbmsc_getle32 * * Description: * Get a 32-bit little-endian value reference by the byte pointer * ****************************************************************************/ -static uint32_t usbstrg_getle32(uint8_t *buf) +static uint32_t usbmsc_getle32(uint8_t *buf) { return ((uint32_t)buf[3] << 24) | ((uint32_t)buf[2] << 16) | ((uint32_t)buf[1] << 8) | ((uint32_t)buf[0]); } /**************************************************************************** - * Name: usbstrg_putle16 + * Name: usbmsc_putle16 * * Description: * Store a 16-bit value in little-endian order to the location specified by @@ -316,7 +316,7 @@ static uint32_t usbstrg_getle32(uint8_t *buf) ****************************************************************************/ #if 0 /* not used */ -static void usbstrg_putle16(uint8_t * buf, uint16_t val) +static void usbmsc_putle16(uint8_t * buf, uint16_t val) { buf[0] = val; buf[1] = val >> 8; @@ -324,7 +324,7 @@ static void usbstrg_putle16(uint8_t * buf, uint16_t val) #endif /**************************************************************************** - * Name: usbstrg_putle32 + * Name: usbmsc_putle32 * * Description: * Store a 32-bit value in little-endian order to the location specified by @@ -332,7 +332,7 @@ static void usbstrg_putle16(uint8_t * buf, uint16_t val) * ****************************************************************************/ -static void usbstrg_putle32(uint8_t *buf, uint32_t val) +static void usbmsc_putle32(uint8_t *buf, uint32_t val) { buf[0] = val; buf[1] = val >> 8; @@ -345,36 +345,36 @@ static void usbstrg_putle32(uint8_t *buf, uint32_t val) ****************************************************************************/ /**************************************************************************** - * Name: usbstrg_cmdtestunitready + * Name: usbmsc_cmdtestunitready * * Description: * Handle the SCSI_CMD_TESTUNITREADY command * ****************************************************************************/ -static inline int usbstrg_cmdtestunitready(FAR struct usbstrg_dev_s *priv) +static inline int usbmsc_cmdtestunitready(FAR struct usbmsc_dev_s *priv) { int ret; priv->u.alloclen = 0; - ret = usbstrg_setupcmd(priv, 6, USBSTRG_FLAGS_DIRNONE); + ret = usbmsc_setupcmd(priv, 6, USBMSC_FLAGS_DIRNONE); return ret; } /**************************************************************************** - * Name: usbstrg_cmdrequestsense + * Name: usbmsc_cmdrequestsense * * Description: * Handle the SCSI_CMD_REQUESTSENSE command * ****************************************************************************/ -static inline int usbstrg_cmdrequestsense(FAR struct usbstrg_dev_s *priv, - FAR uint8_t *buf) +static inline int usbmsc_cmdrequestsense(FAR struct usbmsc_dev_s *priv, + FAR uint8_t *buf) { FAR struct scsicmd_requestsense_s *request = (FAR struct scsicmd_requestsense_s *)priv->cdb; FAR struct scsiresp_fixedsensedata_s *response = (FAR struct scsiresp_fixedsensedata_s *)buf; - FAR struct usbstrg_lun_s *lun; + FAR struct usbmsc_lun_s *lun; uint32_t sd; uint32_t sdinfo; uint8_t cdblen; @@ -396,9 +396,9 @@ static inline int usbstrg_cmdrequestsense(FAR struct usbstrg_dev_s *priv, cdblen = SCSICMD_REQUESTSENSE_MSSIZEOF; } - ret = usbstrg_setupcmd(priv, cdblen, - USBSTRG_FLAGS_DIRDEVICE2HOST|USBSTRG_FLAGS_LUNNOTNEEDED| - USBSTRG_FLAGS_UACOKAY|USBSTRG_FLAGS_RETAINSENSEDATA); + ret = usbmsc_setupcmd(priv, cdblen, + USBMSC_FLAGS_DIRDEVICE2HOST|USBMSC_FLAGS_LUNNOTNEEDED| + USBMSC_FLAGS_UACOKAY|USBMSC_FLAGS_RETAINSENSEDATA); if (ret == OK) { lun = priv->lun; @@ -426,7 +426,7 @@ static inline int usbstrg_cmdrequestsense(FAR struct usbstrg_dev_s *priv, response->code = SCSIRESP_SENSEDATA_RESPVALID|SCSIRESP_SENSEDATA_CURRENTFIXED; response->flags = (uint8_t)(sd >> 16); - usbstrg_putbe32(response->info, sdinfo); + usbmsc_putbe32(response->info, sdinfo); response->len = SCSIRESP_FIXEDSENSEDATA_SIZEOF - 7; response->code2 = (uint8_t)(sd >> 8); response->qual2 = (uint8_t)sd; @@ -439,17 +439,17 @@ static inline int usbstrg_cmdrequestsense(FAR struct usbstrg_dev_s *priv, } /**************************************************************************** - * Name: usbstrg_cmdread6 + * Name: usbmsc_cmdread6 * * Description: * Handle the SCSI_CMD_READ6 command * ****************************************************************************/ -static inline int usbstrg_cmdread6(FAR struct usbstrg_dev_s *priv) +static inline int usbmsc_cmdread6(FAR struct usbmsc_dev_s *priv) { FAR struct scsicmd_read6_s *read6 = (FAR struct scsicmd_read6_s*)priv->cdb; - FAR struct usbstrg_lun_s *lun = priv->lun; + FAR struct usbmsc_lun_s *lun = priv->lun; int ret; priv->u.xfrlen = (uint16_t)read6->xfrlen; @@ -458,18 +458,18 @@ static inline int usbstrg_cmdread6(FAR struct usbstrg_dev_s *priv) priv->u.xfrlen = 256; } - ret = usbstrg_setupcmd(priv, SCSICMD_READ6_SIZEOF, USBSTRG_FLAGS_DIRDEVICE2HOST|USBSTRG_FLAGS_BLOCKXFR); + ret = usbmsc_setupcmd(priv, SCSICMD_READ6_SIZEOF, USBMSC_FLAGS_DIRDEVICE2HOST|USBMSC_FLAGS_BLOCKXFR); if (ret == OK) { /* Get the Logical Block Address (LBA) from cdb[] as the starting sector */ - priv->sector = (uint32_t)(read6->mslba & SCSICMD_READ6_MSLBAMASK) << 16 | (uint32_t)usbstrg_getbe16(read6->lslba); + priv->sector = (uint32_t)(read6->mslba & SCSICMD_READ6_MSLBAMASK) << 16 | (uint32_t)usbmsc_getbe16(read6->lslba); /* Verify that a block driver has been bound to the LUN */ if (!lun->inode) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_READ6MEDIANOTPRESENT), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_READ6MEDIANOTPRESENT), 0); lun->sd = SCSI_KCQNR_MEDIANOTPRESENT; ret = -EINVAL; } @@ -478,7 +478,7 @@ static inline int usbstrg_cmdread6(FAR struct usbstrg_dev_s *priv) else if (priv->sector >= lun->nsectors) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_READ6LBARANGE), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_READ6LBARANGE), 0); lun->sd = SCSI_KCQIR_LBAOUTOFRANGE; ret = -EINVAL; } @@ -487,25 +487,25 @@ static inline int usbstrg_cmdread6(FAR struct usbstrg_dev_s *priv) else { - usbtrace(TRACE_CLASSSTATE(USBSTRG_CLASSSTATE_CMDPARSECMDREAD6), priv->cdb[0]); - priv->thstate = USBSTRG_STATE_CMDREAD; + usbtrace(TRACE_CLASSSTATE(USBMSC_CLASSSTATE_CMDPARSECMDREAD6), priv->cdb[0]); + priv->thstate = USBMSC_STATE_CMDREAD; } } return ret; } /**************************************************************************** - * Name: usbstrg_cmdwrite6 + * Name: usbmsc_cmdwrite6 * * Description: * Handle the SCSI_CMD_WRITE6 command * ****************************************************************************/ -static inline int usbstrg_cmdwrite6(FAR struct usbstrg_dev_s *priv) +static inline int usbmsc_cmdwrite6(FAR struct usbmsc_dev_s *priv) { FAR struct scsicmd_write6_s *write6 = (FAR struct scsicmd_write6_s *)priv->cdb; - FAR struct usbstrg_lun_s *lun = priv->lun; + FAR struct usbmsc_lun_s *lun = priv->lun; int ret; priv->u.xfrlen = (uint16_t)write6->xfrlen; @@ -514,18 +514,18 @@ static inline int usbstrg_cmdwrite6(FAR struct usbstrg_dev_s *priv) priv->u.xfrlen = 256; } - ret = usbstrg_setupcmd(priv, SCSICMD_WRITE6_SIZEOF, USBSTRG_FLAGS_DIRHOST2DEVICE|USBSTRG_FLAGS_BLOCKXFR); + ret = usbmsc_setupcmd(priv, SCSICMD_WRITE6_SIZEOF, USBMSC_FLAGS_DIRHOST2DEVICE|USBMSC_FLAGS_BLOCKXFR); if (ret == OK) { /* Get the Logical Block Address (LBA) from cdb[] as the starting sector */ - priv->sector = (uint32_t)(write6->mslba & SCSICMD_WRITE6_MSLBAMASK) << 16 | (uint32_t)usbstrg_getbe16(write6->lslba); + priv->sector = (uint32_t)(write6->mslba & SCSICMD_WRITE6_MSLBAMASK) << 16 | (uint32_t)usbmsc_getbe16(write6->lslba); /* Verify that a block driver has been bound to the LUN */ if (!lun->inode) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_WRITE6MEDIANOTPRESENT), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_WRITE6MEDIANOTPRESENT), 0); lun->sd = SCSI_KCQNR_MEDIANOTPRESENT; ret = -EINVAL; } @@ -534,7 +534,7 @@ static inline int usbstrg_cmdwrite6(FAR struct usbstrg_dev_s *priv) else if (lun->readonly) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_WRITE6READONLY), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_WRITE6READONLY), 0); lun->sd = SCSI_KCQWP_COMMANDNOTALLOWED; ret = -EINVAL; } @@ -543,7 +543,7 @@ static inline int usbstrg_cmdwrite6(FAR struct usbstrg_dev_s *priv) else if (priv->sector >= lun->nsectors) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_WRITE6LBARANGE), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_WRITE6LBARANGE), 0); lun->sd = SCSI_KCQIR_LBAOUTOFRANGE; ret = -EINVAL; } @@ -552,32 +552,32 @@ static inline int usbstrg_cmdwrite6(FAR struct usbstrg_dev_s *priv) else { - usbtrace(TRACE_CLASSSTATE(USBSTRG_CLASSSTATE_CMDPARSECMDWRITE6), priv->cdb[0]); - priv->thstate = USBSTRG_STATE_CMDWRITE; + usbtrace(TRACE_CLASSSTATE(USBMSC_CLASSSTATE_CMDPARSECMDWRITE6), priv->cdb[0]); + priv->thstate = USBMSC_STATE_CMDWRITE; } } return ret; } /**************************************************************************** - * Name: usbstrg_cmdinquiry + * Name: usbmsc_cmdinquiry * * Description: * Handle SCSI_CMD_INQUIRY command * ****************************************************************************/ -static inline int usbstrg_cmdinquiry(FAR struct usbstrg_dev_s *priv, - FAR uint8_t *buf) +static inline int usbmsc_cmdinquiry(FAR struct usbmsc_dev_s *priv, + FAR uint8_t *buf) { FAR struct scscicmd_inquiry_s *inquiry = (FAR struct scscicmd_inquiry_s *)priv->cdb; FAR struct scsiresp_inquiry_s *response = (FAR struct scsiresp_inquiry_s *)buf; int len; int ret; - priv->u.alloclen = usbstrg_getbe16(inquiry->alloclen); - ret = usbstrg_setupcmd(priv, SCSICMD_INQUIRY_SIZEOF, - USBSTRG_FLAGS_DIRDEVICE2HOST|USBSTRG_FLAGS_LUNNOTNEEDED|USBSTRG_FLAGS_UACOKAY); + priv->u.alloclen = usbmsc_getbe16(inquiry->alloclen); + ret = usbmsc_setupcmd(priv, SCSICMD_INQUIRY_SIZEOF, + USBMSC_FLAGS_DIRDEVICE2HOST|USBMSC_FLAGS_LUNNOTNEEDED|USBMSC_FLAGS_UACOKAY); if (ret == OK) { if (!priv->lun) @@ -586,7 +586,7 @@ static inline int usbstrg_cmdinquiry(FAR struct usbstrg_dev_s *priv, } else if ((inquiry->flags != 0) || (inquiry->pagecode != 0)) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_INQUIRYFLAGS), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_INQUIRYFLAGS), 0); priv->lun->sd = SCSI_KCQIR_INVALIDFIELDINCBA; ret = -EINVAL; } @@ -595,7 +595,7 @@ static inline int usbstrg_cmdinquiry(FAR struct usbstrg_dev_s *priv, memset(response, 0, SCSIRESP_INQUIRY_SIZEOF); priv->nreqbytes = SCSIRESP_INQUIRY_SIZEOF; -#ifdef CONFIG_USBSTRG_REMOVABLE +#ifdef CONFIG_USBMSC_REMOVABLE response->flags1 = SCSIRESP_INQUIRYFLAGS1_RMB; #endif response->version = 2; /* SCSI-2 */ @@ -624,19 +624,19 @@ static inline int usbstrg_cmdinquiry(FAR struct usbstrg_dev_s *priv, } /**************************************************************************** - * Name: usbstrg_cmdmodeselect6 + * Name: usbmsc_cmdmodeselect6 * * Description: * Handle SCSI_CMD_MODESELECT6 command * ****************************************************************************/ -static inline int usbstrg_cmdmodeselect6(FAR struct usbstrg_dev_s *priv) +static inline int usbmsc_cmdmodeselect6(FAR struct usbmsc_dev_s *priv) { FAR struct scsicmd_modeselect6_s *modeselect = (FAR struct scsicmd_modeselect6_s *)priv->cdb; priv->u.alloclen = modeselect->plen; - (void)usbstrg_setupcmd(priv, SCSICMD_MODESELECT6_SIZEOF, USBSTRG_FLAGS_DIRHOST2DEVICE); + (void)usbmsc_setupcmd(priv, SCSICMD_MODESELECT6_SIZEOF, USBMSC_FLAGS_DIRHOST2DEVICE); /* Not supported */ @@ -645,15 +645,15 @@ static inline int usbstrg_cmdmodeselect6(FAR struct usbstrg_dev_s *priv) } /**************************************************************************** - * Name: usbstrg_modepage + * Name: usbmsc_modepage * * Description: - * Common logic for usbstrg_cmdmodesense6() and usbstrg_cmdmodesense10() + * Common logic for usbmsc_cmdmodesense6() and usbmsc_cmdmodesense10() * ****************************************************************************/ -static int usbstrg_modepage(FAR struct usbstrg_dev_s *priv, FAR uint8_t *buf, - uint8_t pcpgcode, int *mdlen) +static int usbmsc_modepage(FAR struct usbmsc_dev_s *priv, FAR uint8_t *buf, + uint8_t pcpgcode, int *mdlen) { FAR struct scsiresp_cachingmodepage_s *cmp = (FAR struct scsiresp_cachingmodepage_s *)buf; @@ -661,7 +661,7 @@ static int usbstrg_modepage(FAR struct usbstrg_dev_s *priv, FAR uint8_t *buf, if ((pcpgcode & SCSICMD_MODESENSE_PCMASK) == SCSICMD_MODESENSE_PCSAVED) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_PCSAVED), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_PCSAVED), 0); priv->lun->sd = SCSI_KCQIR_SAVINGPARMSNOTSUPPORTED; return -EINVAL; } @@ -695,22 +695,22 @@ static int usbstrg_modepage(FAR struct usbstrg_dev_s *priv, FAR uint8_t *buf, } else { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_MODEPAGEFLAGS), pcpgcode); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_MODEPAGEFLAGS), pcpgcode); priv->lun->sd = SCSI_KCQIR_INVALIDFIELDINCBA; return -EINVAL; } } /**************************************************************************** - * Name: usbstrg_cmdmodesense6 + * Name: usbmsc_cmdmodesense6 * * Description: * Handle SCSI_CMD_MODESENSE6 command * ****************************************************************************/ -static int inline usbstrg_cmdmodesense6(FAR struct usbstrg_dev_s *priv, - FAR uint8_t *buf) +static int inline usbmsc_cmdmodesense6(FAR struct usbmsc_dev_s *priv, + FAR uint8_t *buf) { FAR struct scsicmd_modesense6_s *modesense = (FAR struct scsicmd_modesense6_s *)priv->cdb; FAR struct scsiresp_modeparameterhdr6_s *mph = (FAR struct scsiresp_modeparameterhdr6_s *)buf; @@ -718,12 +718,12 @@ static int inline usbstrg_cmdmodesense6(FAR struct usbstrg_dev_s *priv, int ret; priv->u.alloclen = modesense->alloclen; - ret = usbstrg_setupcmd(priv, SCSICMD_MODESENSE6_SIZEOF, USBSTRG_FLAGS_DIRDEVICE2HOST); + ret = usbmsc_setupcmd(priv, SCSICMD_MODESENSE6_SIZEOF, USBMSC_FLAGS_DIRDEVICE2HOST); if (ret == OK) { if ((modesense->flags & ~SCSICMD_MODESENSE6_DBD) != 0 || modesense->subpgcode != 0) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_MODESENSE6FLAGS), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_MODESENSE6FLAGS), 0); priv->lun->sd = SCSI_KCQIR_INVALIDFIELDINCBA; ret = -EINVAL; } @@ -742,7 +742,7 @@ static int inline usbstrg_cmdmodesense6(FAR struct usbstrg_dev_s *priv, /* There are no block descriptors, only the following mode page: */ - ret = usbstrg_modepage(priv, &buf[SCSIRESP_MODEPARAMETERHDR6_SIZEOF], modesense->pcpgcode, &mdlen); + ret = usbmsc_modepage(priv, &buf[SCSIRESP_MODEPARAMETERHDR6_SIZEOF], modesense->pcpgcode, &mdlen); if (ret == OK) { /* Store the mode data length and return the total message size */ @@ -756,25 +756,25 @@ static int inline usbstrg_cmdmodesense6(FAR struct usbstrg_dev_s *priv, } /**************************************************************************** - * Name: usbstrg_cmdstartstopunit + * Name: usbmsc_cmdstartstopunit * * Description: * Handle SCSI_CMD_STARTSTOPUNIT command * ****************************************************************************/ -static inline int usbstrg_cmdstartstopunit(FAR struct usbstrg_dev_s *priv) +static inline int usbmsc_cmdstartstopunit(FAR struct usbmsc_dev_s *priv) { int ret; priv->u.alloclen = 0; - ret = usbstrg_setupcmd(priv, SCSICMD_STARTSTOPUNIT_SIZEOF, USBSTRG_FLAGS_DIRNONE); + ret = usbmsc_setupcmd(priv, SCSICMD_STARTSTOPUNIT_SIZEOF, USBMSC_FLAGS_DIRNONE); if (ret == OK) { -#ifndef CONFIG_USBSTRG_REMOVABLE +#ifndef CONFIG_USBMSC_REMOVABLE /* This command is not valid if the media is not removable */ - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_NOTREMOVABLE), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_NOTREMOVABLE), 0); lun->sd = SCSI_KCQIR_INVALIDCOMMAND; ret = -EINVAL; #endif @@ -783,32 +783,32 @@ static inline int usbstrg_cmdstartstopunit(FAR struct usbstrg_dev_s *priv) } /**************************************************************************** - * Name: usbstrg_cmdpreventmediumremoval + * Name: usbmsc_cmdpreventmediumremoval * * Description: * Handle SCSI_CMD_PREVENTMEDIAREMOVAL command * ****************************************************************************/ -static inline int usbstrg_cmdpreventmediumremoval(FAR struct usbstrg_dev_s *priv) +static inline int usbmsc_cmdpreventmediumremoval(FAR struct usbmsc_dev_s *priv) { -#ifdef CONFIG_USBSTRG_REMOVABLE +#ifdef CONFIG_USBMSC_REMOVABLE FAR struct scsicmd_preventmediumremoval_s *pmr = (FAR struct scsicmd_preventmediumremoval_s *)priv->cdb; - FAR struct usbstrg_lun_s *lun = priv->lun; + FAR struct usbmsc_lun_s *lun = priv->lun; #endif int ret; priv->u.alloclen = 0; - ret = usbstrg_setupcmd(priv, SCSICMD_PREVENTMEDIUMREMOVAL_SIZEOF, USBSTRG_FLAGS_DIRNONE); + ret = usbmsc_setupcmd(priv, SCSICMD_PREVENTMEDIUMREMOVAL_SIZEOF, USBMSC_FLAGS_DIRNONE); if (ret == OK) { -#ifndef CONFIG_USBSTRG_REMOVABLE +#ifndef CONFIG_USBMSC_REMOVABLE lun->sd = SCSI_KCQIR_INVALIDCOMMAND; ret = -EINVAL; #else if ((pmr->prevent & ~SCSICMD_PREVENTMEDIUMREMOVAL_TRANSPORT) != 0) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_PREVENTMEDIUMREMOVALPREVENT), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_PREVENTMEDIUMREMOVALPREVENT), 0); lun->sd = SCSI_KCQIR_INVALIDFIELDINCBA; ret = -EINVAL; } @@ -820,23 +820,23 @@ static inline int usbstrg_cmdpreventmediumremoval(FAR struct usbstrg_dev_s *priv } /**************************************************************************** - * Name: usbstrg_cmdreadformatcapacity + * Name: usbmsc_cmdreadformatcapacity * * Description: * Handle SCSI_CMD_READFORMATCAPACITIES command (MMC) * ****************************************************************************/ -static inline int usbstrg_cmdreadformatcapacity(FAR struct usbstrg_dev_s *priv, - FAR uint8_t *buf) +static inline int usbmsc_cmdreadformatcapacity(FAR struct usbmsc_dev_s *priv, + FAR uint8_t *buf) { FAR struct scsicmd_readformatcapcacities_s *rfc = (FAR struct scsicmd_readformatcapcacities_s *)priv->cdb; FAR struct scsiresp_readformatcapacities_s *hdr; - FAR struct usbstrg_lun_s *lun = priv->lun; + FAR struct usbmsc_lun_s *lun = priv->lun; int ret; - priv->u.alloclen = usbstrg_getbe16(rfc->alloclen); - ret = usbstrg_setupcmd(priv, SCSICMD_READFORMATCAPACITIES_SIZEOF, USBSTRG_FLAGS_DIRDEVICE2HOST); + priv->u.alloclen = usbmsc_getbe16(rfc->alloclen); + ret = usbmsc_setupcmd(priv, SCSICMD_READFORMATCAPACITIES_SIZEOF, USBMSC_FLAGS_DIRDEVICE2HOST); if (ret == OK) { hdr = (FAR struct scsiresp_readformatcapacities_s *)buf; @@ -845,49 +845,49 @@ static inline int usbstrg_cmdreadformatcapacity(FAR struct usbstrg_dev_s *priv, /* Only the Current/Maximum Capacity Descriptor follows the header */ - usbstrg_putbe32(hdr->nblocks, lun->nsectors); + usbmsc_putbe32(hdr->nblocks, lun->nsectors); hdr->type = SCIRESP_RDFMTCAPACITIES_FORMATED; - usbstrg_putbe24(hdr->blocklen, lun->sectorsize); + usbmsc_putbe24(hdr->blocklen, lun->sectorsize); priv->nreqbytes = SCSIRESP_READFORMATCAPACITIES_SIZEOF; } return ret; } /**************************************************************************** - * Name: usbstrg_cmdreadcapacity10 + * Name: usbmsc_cmdreadcapacity10 * * Description: * Handle SCSI_CMD_READCAPACITY10 command * ****************************************************************************/ -static int inline usbstrg_cmdreadcapacity10(FAR struct usbstrg_dev_s *priv, - FAR uint8_t *buf) +static int inline usbmsc_cmdreadcapacity10(FAR struct usbmsc_dev_s *priv, + FAR uint8_t *buf) { FAR struct scsicmd_readcapacity10_s *rcc = (FAR struct scsicmd_readcapacity10_s *)priv->cdb; FAR struct scsiresp_readcapacity10_s *rcr = (FAR struct scsiresp_readcapacity10_s *)buf; - FAR struct usbstrg_lun_s *lun = priv->lun; + FAR struct usbmsc_lun_s *lun = priv->lun; uint32_t lba; int ret; priv->u.alloclen = SCSIRESP_READCAPACITY10_SIZEOF; /* Fake the allocation length */ - ret = usbstrg_setupcmd(priv, SCSICMD_READCAPACITY10_SIZEOF, USBSTRG_FLAGS_DIRDEVICE2HOST); + ret = usbmsc_setupcmd(priv, SCSICMD_READCAPACITY10_SIZEOF, USBMSC_FLAGS_DIRDEVICE2HOST); if (ret == OK) { /* Check the PMI and LBA fields */ - lba = usbstrg_getbe32(rcc->lba); + lba = usbmsc_getbe32(rcc->lba); if (rcc->pmi > 1 || (rcc->pmi == 0 && lba != 0)) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_READCAPACITYFLAGS), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_READCAPACITYFLAGS), 0); lun->sd = SCSI_KCQIR_INVALIDFIELDINCBA; ret = -EINVAL; } else { - usbstrg_putbe32(rcr->lba, lun->nsectors - 1); - usbstrg_putbe32(&buf[4], lun->sectorsize); + usbmsc_putbe32(rcr->lba, lun->nsectors - 1); + usbmsc_putbe32(&buf[4], lun->sectorsize); priv->nreqbytes = SCSIRESP_READCAPACITY10_SIZEOF; } } @@ -895,32 +895,32 @@ static int inline usbstrg_cmdreadcapacity10(FAR struct usbstrg_dev_s *priv, } /**************************************************************************** - * Name: usbstrg_cmdread10 + * Name: usbmsc_cmdread10 * * Description: * Handle SCSI_CMD_READ10 command * ****************************************************************************/ -static inline int usbstrg_cmdread10(FAR struct usbstrg_dev_s *priv) +static inline int usbmsc_cmdread10(FAR struct usbmsc_dev_s *priv) { struct scsicmd_read10_s *read10 = (struct scsicmd_read10_s*)priv->cdb; - FAR struct usbstrg_lun_s *lun = priv->lun; + FAR struct usbmsc_lun_s *lun = priv->lun; int ret; - priv->u.xfrlen = usbstrg_getbe16(read10->xfrlen); - ret = usbstrg_setupcmd(priv, SCSICMD_READ10_SIZEOF, USBSTRG_FLAGS_DIRDEVICE2HOST|USBSTRG_FLAGS_BLOCKXFR); + priv->u.xfrlen = usbmsc_getbe16(read10->xfrlen); + ret = usbmsc_setupcmd(priv, SCSICMD_READ10_SIZEOF, USBMSC_FLAGS_DIRDEVICE2HOST|USBMSC_FLAGS_BLOCKXFR); if (ret == OK) { /* Get the Logical Block Address (LBA) from cdb[] as the starting sector */ - priv->sector = usbstrg_getbe32(read10->lba); + priv->sector = usbmsc_getbe32(read10->lba); /* Verify that we can support this read command */ if ((read10->flags & ~(SCSICMD_READ10FLAGS_DPO|SCSICMD_READ10FLAGS_FUA)) != 0) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_READ10FLAGS), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_READ10FLAGS), 0); lun->sd = SCSI_KCQIR_INVALIDFIELDINCBA; ret = -EINVAL; } @@ -929,7 +929,7 @@ static inline int usbstrg_cmdread10(FAR struct usbstrg_dev_s *priv) else if (!lun->inode) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_READ10MEDIANOTPRESENT), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_READ10MEDIANOTPRESENT), 0); lun->sd = SCSI_KCQNR_MEDIANOTPRESENT; ret = -EINVAL; } @@ -938,7 +938,7 @@ static inline int usbstrg_cmdread10(FAR struct usbstrg_dev_s *priv) else if (priv->sector >= lun->nsectors) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_READ10LBARANGE), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_READ10LBARANGE), 0); lun->sd = SCSI_KCQIR_LBAOUTOFRANGE; ret = -EINVAL; } @@ -947,8 +947,8 @@ static inline int usbstrg_cmdread10(FAR struct usbstrg_dev_s *priv) else { - usbtrace(TRACE_CLASSSTATE(USBSTRG_CLASSSTATE_CMDPARSECMDREAD10), priv->cdb[0]); - priv->thstate = USBSTRG_STATE_CMDREAD; + usbtrace(TRACE_CLASSSTATE(USBMSC_CLASSSTATE_CMDPARSECMDREAD10), priv->cdb[0]); + priv->thstate = USBMSC_STATE_CMDREAD; } } @@ -956,32 +956,32 @@ static inline int usbstrg_cmdread10(FAR struct usbstrg_dev_s *priv) } /**************************************************************************** - * Name: usbstrg_cmdwrite10 + * Name: usbmsc_cmdwrite10 * * Description: * Handle SCSI_CMD_WRITE10 command * ****************************************************************************/ -static inline int usbstrg_cmdwrite10(FAR struct usbstrg_dev_s *priv) +static inline int usbmsc_cmdwrite10(FAR struct usbmsc_dev_s *priv) { struct scsicmd_write10_s *write10 = (struct scsicmd_write10_s *)priv->cdb; - FAR struct usbstrg_lun_s *lun = priv->lun; + FAR struct usbmsc_lun_s *lun = priv->lun; int ret; - priv->u.xfrlen = usbstrg_getbe16(write10->xfrlen); - ret = usbstrg_setupcmd(priv, SCSICMD_WRITE10_SIZEOF, USBSTRG_FLAGS_DIRHOST2DEVICE|USBSTRG_FLAGS_BLOCKXFR); + priv->u.xfrlen = usbmsc_getbe16(write10->xfrlen); + ret = usbmsc_setupcmd(priv, SCSICMD_WRITE10_SIZEOF, USBMSC_FLAGS_DIRHOST2DEVICE|USBMSC_FLAGS_BLOCKXFR); if (ret == OK) { /* Get the Logical Block Address (LBA) from cdb[] as the starting sector */ - priv->sector = usbstrg_getbe32(write10->lba); + priv->sector = usbmsc_getbe32(write10->lba); /* Verify that we can support this write command */ if ((write10->flags & ~(SCSICMD_WRITE10FLAGS_DPO|SCSICMD_WRITE10FLAGS_FUA)) != 0) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_WRITE10FLAGS), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_WRITE10FLAGS), 0); lun->sd = SCSI_KCQIR_INVALIDFIELDINCBA; ret = -EINVAL; } @@ -990,7 +990,7 @@ static inline int usbstrg_cmdwrite10(FAR struct usbstrg_dev_s *priv) else if (!lun->inode) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_WRITE10MEDIANOTPRESENT), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_WRITE10MEDIANOTPRESENT), 0); lun->sd = SCSI_KCQNR_MEDIANOTPRESENT; ret = -EINVAL; } @@ -999,7 +999,7 @@ static inline int usbstrg_cmdwrite10(FAR struct usbstrg_dev_s *priv) else if (lun->readonly) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_WRITE10READONLY), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_WRITE10READONLY), 0); lun->sd = SCSI_KCQWP_COMMANDNOTALLOWED; ret = -EINVAL; } @@ -1008,7 +1008,7 @@ static inline int usbstrg_cmdwrite10(FAR struct usbstrg_dev_s *priv) else if (priv->sector >= lun->nsectors) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_WRITE10LBARANGE), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_WRITE10LBARANGE), 0); lun->sd = SCSI_KCQIR_LBAOUTOFRANGE; ret = -EINVAL; } @@ -1017,25 +1017,25 @@ static inline int usbstrg_cmdwrite10(FAR struct usbstrg_dev_s *priv) else { - usbtrace(TRACE_CLASSSTATE(USBSTRG_CLASSSTATE_CMDPARSECMDWRITE10), priv->cdb[0]); - priv->thstate = USBSTRG_STATE_CMDWRITE; + usbtrace(TRACE_CLASSSTATE(USBMSC_CLASSSTATE_CMDPARSECMDWRITE10), priv->cdb[0]); + priv->thstate = USBMSC_STATE_CMDWRITE; } } return ret; } /**************************************************************************** - * Name: usbstrg_cmdverify10 + * Name: usbmsc_cmdverify10 * * Description: * Handle SCSI_CMD_VERIFY10 command * ****************************************************************************/ -static inline int usbstrg_cmdverify10(FAR struct usbstrg_dev_s *priv) +static inline int usbmsc_cmdverify10(FAR struct usbmsc_dev_s *priv) { FAR struct scsicmd_verify10_s *verf = (FAR struct scsicmd_verify10_s *)priv->cdb; - FAR struct usbstrg_lun_s *lun = priv->lun; + FAR struct usbmsc_lun_s *lun = priv->lun; uint32_t lba; uint16_t blocks; size_t sector; @@ -1044,23 +1044,23 @@ static inline int usbstrg_cmdverify10(FAR struct usbstrg_dev_s *priv) int i; priv->u.alloclen = 0; - ret = usbstrg_setupcmd(priv, SCSICMD_VERIFY10_SIZEOF, USBSTRG_FLAGS_DIRNONE); + ret = usbmsc_setupcmd(priv, SCSICMD_VERIFY10_SIZEOF, USBMSC_FLAGS_DIRNONE); if (ret == OK) { /* Verify the starting and ending LBA */ - lba = usbstrg_getbe32(verf->lba); - blocks = usbstrg_getbe16(verf->len); + lba = usbmsc_getbe32(verf->lba); + blocks = usbmsc_getbe16(verf->len); if ((verf->flags & ~SCSICMD_VERIFY10_DPO) != 0 || verf->groupno != 0) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_VERIFY10FLAGS), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_VERIFY10FLAGS), 0); lun->sd = SCSI_KCQIR_INVALIDFIELDINCBA; ret = -EINVAL; } else if (blocks == 0) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_VERIFY10NOBLOCKS), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_VERIFY10NOBLOCKS), 0); ret = -EIO; /* No reply */ } @@ -1068,7 +1068,7 @@ static inline int usbstrg_cmdverify10(FAR struct usbstrg_dev_s *priv) else if (!lun->inode) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_VERIFY10MEDIANOTPRESENT), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_VERIFY10MEDIANOTPRESENT), 0); lun->sd = SCSI_KCQNR_MEDIANOTPRESENT; ret = -EINVAL; } @@ -1077,7 +1077,7 @@ static inline int usbstrg_cmdverify10(FAR struct usbstrg_dev_s *priv) else if (lba >= lun->nsectors || lba + blocks > lun->nsectors) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_VERIFY10LBARANGE), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_VERIFY10LBARANGE), 0); lun->sd = SCSI_KCQIR_LBAOUTOFRANGE; ret = -EINVAL; } @@ -1087,10 +1087,10 @@ static inline int usbstrg_cmdverify10(FAR struct usbstrg_dev_s *priv) for (i = 0, sector = lba + lun->startsector; i < blocks; i++, sector++) { - nread = USBSTRG_DRVR_READ(lun, priv->iobuffer, sector, 1); + nread = USBMSC_DRVR_READ(lun, priv->iobuffer, sector, 1); if (nread < 0) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_VERIFY10READFAIL), i); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_VERIFY10READFAIL), i); lun->sd = SCSI_KCQME_UNRRE1; lun->sdinfo = sector; ret = -EIO; @@ -1103,14 +1103,14 @@ static inline int usbstrg_cmdverify10(FAR struct usbstrg_dev_s *priv) } /**************************************************************************** - * Name: usbstrg_cmdsynchronizecache10 + * Name: usbmsc_cmdsynchronizecache10 * * Description: * Handle SCSI_CMD_SYNCHCACHE10 command * ****************************************************************************/ -static inline int usbstrg_cmdsynchronizecache10(FAR struct usbstrg_dev_s *priv) +static inline int usbmsc_cmdsynchronizecache10(FAR struct usbmsc_dev_s *priv) { int ret; @@ -1120,31 +1120,31 @@ static inline int usbstrg_cmdsynchronizecache10(FAR struct usbstrg_dev_s *priv) if (!priv->lun->inode) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_SYNCCACHEMEDIANOTPRESENT), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_SYNCCACHEMEDIANOTPRESENT), 0); priv->lun->sd = SCSI_KCQNR_MEDIANOTPRESENT; ret = -EINVAL; } else { - ret = usbstrg_setupcmd(priv, SCSICMD_SYNCHRONIZECACHE10_SIZEOF, USBSTRG_FLAGS_DIRNONE); + ret = usbmsc_setupcmd(priv, SCSICMD_SYNCHRONIZECACHE10_SIZEOF, USBMSC_FLAGS_DIRNONE); } return ret; } /**************************************************************************** - * Name: usbstrg_cmdmodeselect10 + * Name: usbmsc_cmdmodeselect10 * * Description: * Handle SCSI_CMD_MODESELECT10 command * ****************************************************************************/ -static inline int usbstrg_cmdmodeselect10(FAR struct usbstrg_dev_s *priv) +static inline int usbmsc_cmdmodeselect10(FAR struct usbmsc_dev_s *priv) { FAR struct scsicmd_modeselect10_s *modeselect = (FAR struct scsicmd_modeselect10_s *)priv->cdb; - priv->u.alloclen = usbstrg_getbe16(modeselect->parmlen); - (void)usbstrg_setupcmd(priv, SCSICMD_MODESELECT10_SIZEOF, USBSTRG_FLAGS_DIRHOST2DEVICE); + priv->u.alloclen = usbmsc_getbe16(modeselect->parmlen); + (void)usbmsc_setupcmd(priv, SCSICMD_MODESELECT10_SIZEOF, USBMSC_FLAGS_DIRHOST2DEVICE); /* Not supported */ @@ -1153,28 +1153,28 @@ static inline int usbstrg_cmdmodeselect10(FAR struct usbstrg_dev_s *priv) } /**************************************************************************** - * Name: usbstrg_cmdmodesense10 + * Name: usbmsc_cmdmodesense10 * * Description: * Handle SCSI_CMD_MODESENSE10 command * ****************************************************************************/ -static int inline usbstrg_cmdmodesense10(FAR struct usbstrg_dev_s *priv, - FAR uint8_t *buf) +static int inline usbmsc_cmdmodesense10(FAR struct usbmsc_dev_s *priv, + FAR uint8_t *buf) { FAR struct scsicmd_modesense10_s *modesense = (FAR struct scsicmd_modesense10_s *)priv->cdb; FAR struct scsiresp_modeparameterhdr10_s *mph = (FAR struct scsiresp_modeparameterhdr10_s *)buf; int mdlen; int ret; - priv->u.alloclen = usbstrg_getbe16(modesense->alloclen); - ret = usbstrg_setupcmd(priv, SCSICMD_MODESENSE10_SIZEOF, USBSTRG_FLAGS_DIRDEVICE2HOST); + priv->u.alloclen = usbmsc_getbe16(modesense->alloclen); + ret = usbmsc_setupcmd(priv, SCSICMD_MODESENSE10_SIZEOF, USBMSC_FLAGS_DIRDEVICE2HOST); if (ret == OK) { if ((modesense->flags & ~SCSICMD_MODESENSE10_DBD) != 0 || modesense->subpgcode != 0) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_MODESENSE10FLAGS), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_MODESENSE10FLAGS), 0); priv->lun->sd = SCSI_KCQIR_INVALIDFIELDINCBA; ret = -EINVAL; } @@ -1192,12 +1192,12 @@ static int inline usbstrg_cmdmodesense10(FAR struct usbstrg_dev_s *priv, /* There are no block descriptors, only the following mode page: */ - ret = usbstrg_modepage(priv, &buf[SCSIRESP_MODEPARAMETERHDR10_SIZEOF], modesense->pcpgcode, &mdlen); + ret = usbmsc_modepage(priv, &buf[SCSIRESP_MODEPARAMETERHDR10_SIZEOF], modesense->pcpgcode, &mdlen); if (ret == OK) { /* Store the mode data length and return the total message size */ - usbstrg_putbe16(mph->mdlen, mdlen - 2); + usbmsc_putbe16(mph->mdlen, mdlen - 2); priv->nreqbytes = mdlen + SCSIRESP_MODEPARAMETERHDR10_SIZEOF; } } @@ -1206,32 +1206,32 @@ static int inline usbstrg_cmdmodesense10(FAR struct usbstrg_dev_s *priv, } /**************************************************************************** - * Name: usbstrg_cmdread12 + * Name: usbmsc_cmdread12 * * Description: * Handle SCSI_CMD_READ12 command * ****************************************************************************/ -static inline int usbstrg_cmdread12(FAR struct usbstrg_dev_s *priv) +static inline int usbmsc_cmdread12(FAR struct usbmsc_dev_s *priv) { struct scsicmd_read12_s *read12 = (struct scsicmd_read12_s*)priv->cdb; - FAR struct usbstrg_lun_s *lun = priv->lun; + FAR struct usbmsc_lun_s *lun = priv->lun; int ret; - priv->u.xfrlen = usbstrg_getbe32(read12->xfrlen); - ret = usbstrg_setupcmd(priv, SCSICMD_READ12_SIZEOF, USBSTRG_FLAGS_DIRDEVICE2HOST|USBSTRG_FLAGS_BLOCKXFR); + priv->u.xfrlen = usbmsc_getbe32(read12->xfrlen); + ret = usbmsc_setupcmd(priv, SCSICMD_READ12_SIZEOF, USBMSC_FLAGS_DIRDEVICE2HOST|USBMSC_FLAGS_BLOCKXFR); if (ret == OK) { /* Get the Logical Block Address (LBA) from cdb[] as the starting sector */ - priv->sector = usbstrg_getbe32(read12->lba); + priv->sector = usbmsc_getbe32(read12->lba); /* Verify that we can support this read command */ if ((read12->flags & ~(SCSICMD_READ12FLAGS_DPO|SCSICMD_READ12FLAGS_FUA)) != 0) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_READ12FLAGS), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_READ12FLAGS), 0); lun->sd = SCSI_KCQIR_INVALIDFIELDINCBA; ret = -EINVAL; } @@ -1240,7 +1240,7 @@ static inline int usbstrg_cmdread12(FAR struct usbstrg_dev_s *priv) else if (!lun->inode) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_READ12MEDIANOTPRESENT), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_READ12MEDIANOTPRESENT), 0); lun->sd = SCSI_KCQNR_MEDIANOTPRESENT; ret = -EINVAL; } @@ -1249,7 +1249,7 @@ static inline int usbstrg_cmdread12(FAR struct usbstrg_dev_s *priv) else if (priv->sector >= lun->nsectors) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_READ12LBARANGE), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_READ12LBARANGE), 0); lun->sd = SCSI_KCQIR_LBAOUTOFRANGE; ret = -EINVAL; } @@ -1258,40 +1258,40 @@ static inline int usbstrg_cmdread12(FAR struct usbstrg_dev_s *priv) else { - usbtrace(TRACE_CLASSSTATE(USBSTRG_CLASSSTATE_CMDPARSECMDREAD12), priv->cdb[0]); - priv->thstate = USBSTRG_STATE_CMDREAD; + usbtrace(TRACE_CLASSSTATE(USBMSC_CLASSSTATE_CMDPARSECMDREAD12), priv->cdb[0]); + priv->thstate = USBMSC_STATE_CMDREAD; } } return ret; } /**************************************************************************** - * Name: usbstrg_cmdwrite12 + * Name: usbmsc_cmdwrite12 * * Description: * Handle SCSI_CMD_WRITE12 command * ****************************************************************************/ -static inline int usbstrg_cmdwrite12(FAR struct usbstrg_dev_s *priv) +static inline int usbmsc_cmdwrite12(FAR struct usbmsc_dev_s *priv) { struct scsicmd_write12_s *write12 = (struct scsicmd_write12_s *)priv->cdb; - FAR struct usbstrg_lun_s *lun = priv->lun; + FAR struct usbmsc_lun_s *lun = priv->lun; int ret; - priv->u.xfrlen = usbstrg_getbe32(write12->xfrlen); - ret = usbstrg_setupcmd(priv, SCSICMD_WRITE12_SIZEOF, USBSTRG_FLAGS_DIRHOST2DEVICE|USBSTRG_FLAGS_BLOCKXFR); + priv->u.xfrlen = usbmsc_getbe32(write12->xfrlen); + ret = usbmsc_setupcmd(priv, SCSICMD_WRITE12_SIZEOF, USBMSC_FLAGS_DIRHOST2DEVICE|USBMSC_FLAGS_BLOCKXFR); if (ret == OK) { /* Get the Logical Block Address (LBA) from cdb[] as the starting sector */ - priv->sector = usbstrg_getbe32(write12->lba); + priv->sector = usbmsc_getbe32(write12->lba); /* Verify that we can support this write command */ if ((write12->flags & ~(SCSICMD_WRITE12FLAGS_DPO|SCSICMD_WRITE12FLAGS_FUA)) != 0) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_WRITE12FLAGS), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_WRITE12FLAGS), 0); lun->sd = SCSI_KCQIR_INVALIDFIELDINCBA; } @@ -1299,7 +1299,7 @@ static inline int usbstrg_cmdwrite12(FAR struct usbstrg_dev_s *priv) else if (!lun->inode) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_WRITE12MEDIANOTPRESENT), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_WRITE12MEDIANOTPRESENT), 0); lun->sd = SCSI_KCQNR_MEDIANOTPRESENT; ret = -EINVAL; } @@ -1308,7 +1308,7 @@ static inline int usbstrg_cmdwrite12(FAR struct usbstrg_dev_s *priv) else if (lun->readonly) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_WRITE12READONLY), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_WRITE12READONLY), 0); lun->sd = SCSI_KCQWP_COMMANDNOTALLOWED; } @@ -1316,7 +1316,7 @@ static inline int usbstrg_cmdwrite12(FAR struct usbstrg_dev_s *priv) else if (priv->sector >= lun->nsectors) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_WRITE12LBARANGE), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_WRITE12LBARANGE), 0); lun->sd = SCSI_KCQIR_LBAOUTOFRANGE; } @@ -1324,8 +1324,8 @@ static inline int usbstrg_cmdwrite12(FAR struct usbstrg_dev_s *priv) else { - usbtrace(TRACE_CLASSSTATE(USBSTRG_CLASSSTATE_CMDPARSECMDWRITE12), priv->cdb[0]); - priv->thstate = USBSTRG_STATE_CMDWRITE; + usbtrace(TRACE_CLASSSTATE(USBMSC_CLASSSTATE_CMDPARSECMDWRITE12), priv->cdb[0]); + priv->thstate = USBMSC_STATE_CMDWRITE; return OK; } } @@ -1334,7 +1334,7 @@ static inline int usbstrg_cmdwrite12(FAR struct usbstrg_dev_s *priv) } /**************************************************************************** - * Name: usbstrg_setupcmd + * Name: usbmsc_setupcmd * * Description: * Called after each SCSI command is identified in order to perform setup @@ -1349,11 +1349,11 @@ static inline int usbstrg_cmdwrite12(FAR struct usbstrg_dev_s *priv) * ****************************************************************************/ -static int inline usbstrg_setupcmd(FAR struct usbstrg_dev_s *priv, uint8_t cdblen, uint8_t flags) +static int inline usbmsc_setupcmd(FAR struct usbmsc_dev_s *priv, uint8_t cdblen, uint8_t flags) { - FAR struct usbstrg_lun_s *lun = NULL; + FAR struct usbmsc_lun_s *lun = NULL; uint32_t datlen; - uint8_t dir = flags & USBSTRG_FLAGS_DIRMASK; + uint8_t dir = flags & USBMSC_FLAGS_DIRMASK; int ret = OK; /* Verify the LUN and set up the current LUN reference in the @@ -1373,17 +1373,17 @@ static int inline usbstrg_setupcmd(FAR struct usbstrg_dev_s *priv, uint8_t cdble /* Only a few commands may specify unsupported LUNs */ - else if ((flags & USBSTRG_FLAGS_LUNNOTNEEDED) == 0) + else if ((flags & USBMSC_FLAGS_LUNNOTNEEDED) == 0) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_CMDBADLUN), priv->cbwlun); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_CMDBADLUN), priv->cbwlun); ret = -EINVAL; } /* Extract the direction and data transfer length */ - dir = flags & USBSTRG_FLAGS_DIRMASK; /* Expected data direction */ + dir = flags & USBMSC_FLAGS_DIRMASK; /* Expected data direction */ datlen = 0; - if ((flags & USBSTRG_FLAGS_BLOCKXFR) == 0) + if ((flags & USBMSC_FLAGS_BLOCKXFR) == 0) { /* Non-block transfer. Data length: Host allocation to receive data * (only for device-to-host transfers. At present, alloclen is set @@ -1408,7 +1408,7 @@ static int inline usbstrg_setupcmd(FAR struct usbstrg_dev_s *priv, uint8_t cdble { /* No data.. then direction is none */ - dir = USBSTRG_FLAGS_DIRNONE; + dir = USBMSC_FLAGS_DIRNONE; } /* Compare the expected data length in the command to the data length @@ -1419,8 +1419,8 @@ static int inline usbstrg_setupcmd(FAR struct usbstrg_dev_s *priv, uint8_t cdble { /* Clip to the length in the CBW and declare a phase error */ - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_PHASEERROR1), priv->cdb[0]); - if ((flags & USBSTRG_FLAGS_BLOCKXFR) != 0) + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_PHASEERROR1), priv->cdb[0]); + if ((flags & USBMSC_FLAGS_BLOCKXFR) != 0) { priv->u.alloclen = priv->cbwlen; } @@ -1440,7 +1440,7 @@ static int inline usbstrg_setupcmd(FAR struct usbstrg_dev_s *priv, uint8_t cdble if (priv->cbwdir != dir && datlen > 0) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_PHASEERROR2), priv->cdb[0]); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_PHASEERROR2), priv->cdb[0]); priv->phaseerror = 1; ret = -EINVAL; } @@ -1451,7 +1451,7 @@ static int inline usbstrg_setupcmd(FAR struct usbstrg_dev_s *priv, uint8_t cdble if (cdblen != priv->cdblen) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_PHASEERROR3), priv->cdb[0]); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_PHASEERROR3), priv->cdb[0]); priv->phaseerror = 1; ret = -EINVAL; } @@ -1460,7 +1460,7 @@ static int inline usbstrg_setupcmd(FAR struct usbstrg_dev_s *priv, uint8_t cdble { /* Retain the sense data for the REQUEST SENSE command */ - if ((flags & USBSTRG_FLAGS_RETAINSENSEDATA) == 0) + if ((flags & USBMSC_FLAGS_RETAINSENSEDATA) == 0) { /* Discard the sense data */ @@ -1472,11 +1472,11 @@ static int inline usbstrg_setupcmd(FAR struct usbstrg_dev_s *priv, uint8_t cdble * commands is permitted. */ - if (lun->uad != SCSI_KCQ_NOSENSE && (flags & USBSTRG_FLAGS_UACOKAY) != 0) + if (lun->uad != SCSI_KCQ_NOSENSE && (flags & USBMSC_FLAGS_UACOKAY) != 0) { /* Command not permitted */ - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_CMDUNEVIOLATION), priv->cbwlun); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_CMDUNEVIOLATION), priv->cbwlun); lun->sd = lun->uad; lun->uad = SCSI_KCQ_NOSENSE; ret = -EINVAL; @@ -1489,7 +1489,7 @@ static int inline usbstrg_setupcmd(FAR struct usbstrg_dev_s *priv, uint8_t cdble if (priv->cdb[cdblen-1] != 0) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_SCSICMDCONTROL), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_SCSICMDCONTROL), 0); if (lun) { lun->sd = SCSI_KCQIR_INVALIDFIELDINCBA; @@ -1500,56 +1500,56 @@ static int inline usbstrg_setupcmd(FAR struct usbstrg_dev_s *priv, uint8_t cdble } /**************************************************************************** - * Name: usbstrg_idlestate + * Name: usbmsc_idlestate * * Description: - * Called from the worker thread in the USBSTRG_STATE_IDLE state. Checks + * Called from the worker thread in the USBMSC_STATE_IDLE state. Checks * for the receipt of a bulk CBW. * * Returned value: * If no new, valid CBW is available, this function returns a negated errno. * Otherwise, when a new CBW is successfully parsed, this function sets - * priv->thstate to USBSTRG_STATE_CMDPARSE and returns OK. + * priv->thstate to USBMSC_STATE_CMDPARSE and returns OK. * ****************************************************************************/ -static int usbstrg_idlestate(FAR struct usbstrg_dev_s *priv) +static int usbmsc_idlestate(FAR struct usbmsc_dev_s *priv) { - FAR struct usbstrg_req_s *privreq; + FAR struct usbmsc_req_s *privreq; FAR struct usbdev_req_s *req; - FAR struct usbstrg_cbw_s *cbw; + FAR struct usbmsc_cbw_s *cbw; irqstate_t flags; int ret = -EINVAL; /* Take a request from the rdreqlist */ flags = irqsave(); - privreq = (FAR struct usbstrg_req_s *)sq_remfirst(&priv->rdreqlist); + privreq = (FAR struct usbmsc_req_s *)sq_remfirst(&priv->rdreqlist); irqrestore(flags); /* Has anything been received? If not, just return an error. * This will cause us to remain in the IDLE state. When a USB request is - * received, the worker thread will be awakened in the USBSTRG_STATE_IDLE + * received, the worker thread will be awakened in the USBMSC_STATE_IDLE * and we will be called again. */ if (!privreq) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_IDLERDREQLISTEMPTY), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_IDLERDREQLISTEMPTY), 0); return -ENOMEM; } req = privreq->req; - cbw = (FAR struct usbstrg_cbw_s *)req->buf; + cbw = (FAR struct usbmsc_cbw_s *)req->buf; /* Handle the CBW */ - usbstrg_dumpdata("SCSCI CBW", (uint8_t*)cbw, USBSTRG_CBW_SIZEOF - USBSTRG_MAXCDBLEN); - usbstrg_dumpdata(" CDB", cbw->cdb, MIN(cbw->cdblen, USBSTRG_MAXCDBLEN)); + usbmsc_dumpdata("SCSCI CBW", (uint8_t*)cbw, USBMSC_CBW_SIZEOF - USBMSC_MAXCDBLEN); + usbmsc_dumpdata(" CDB", cbw->cdb, MIN(cbw->cdblen, USBMSC_MAXCDBLEN)); /* Check for properly formatted CBW? */ - if (req->xfrd != USBSTRG_CBW_SIZEOF || + if (req->xfrd != USBMSC_CBW_SIZEOF || cbw->signature[0] != 'U' || cbw->signature[1] != 'S' || cbw->signature[2] != 'B' || @@ -1560,22 +1560,22 @@ static int usbstrg_idlestate(FAR struct usbstrg_dev_s *priv) * (2) discard data from the endpoint. */ - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_INVALIDCBWSIGNATURE), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_INVALIDCBWSIGNATURE), 0); EP_STALL(priv->epbulkout); EP_STALL(priv->epbulkin); } /* Is the CBW meaningful? */ - else if (cbw->lun >= priv->nluns || (cbw->flags & ~USBSTRG_CBWFLAG_IN) != 0 || - cbw->cdblen < 6 || cbw->cdblen > USBSTRG_MAXCDBLEN) + else if (cbw->lun >= priv->nluns || (cbw->flags & ~USBMSC_CBWFLAG_IN) != 0 || + cbw->cdblen < 6 || cbw->cdblen > USBMSC_MAXCDBLEN) { /* CBS BAD: Stall the bulk endpoints. If the CBW is bad we must stall the * bulk IN endpoint and either (1) stall the bulk OUT endpoint, or * (2) discard data from the endpoint. */ - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_INVALIDCBWCONTENT), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_INVALIDCBWCONTENT), 0); EP_STALL(priv->epbulkout); EP_STALL(priv->epbulkin); } @@ -1591,50 +1591,50 @@ static int usbstrg_idlestate(FAR struct usbstrg_dev_s *priv) /* Extract the data direction */ - if ((cbw->flags & USBSTRG_CBWFLAG_IN) != 0) + if ((cbw->flags & USBMSC_CBWFLAG_IN) != 0) { /* IN: Device-to-host */ - priv->cbwdir = USBSTRG_FLAGS_DIRDEVICE2HOST; + priv->cbwdir = USBMSC_FLAGS_DIRDEVICE2HOST; } else { /* OUT: Host-to-device */ - priv->cbwdir = USBSTRG_FLAGS_DIRHOST2DEVICE; + priv->cbwdir = USBMSC_FLAGS_DIRHOST2DEVICE; } /* Get the max size of the data response */ - priv->cbwlen = usbstrg_getle32(cbw->datlen); + priv->cbwlen = usbmsc_getle32(cbw->datlen); if (priv->cbwlen == 0) { /* No length? Then no direction either */ - priv->cbwdir = USBSTRG_FLAGS_DIRNONE; + priv->cbwdir = USBMSC_FLAGS_DIRNONE; } /* Extract and save the LUN index and TAG value */ priv->cbwlun = cbw->lun; - priv->cbwtag = usbstrg_getle32(cbw->tag); + priv->cbwtag = usbmsc_getle32(cbw->tag); /* Return the read request to the bulk out endpoint for re-filling */ req = privreq->req; - req->len = CONFIG_USBSTRG_BULKOUTREQLEN; + req->len = CONFIG_USBMSC_BULKOUTREQLEN; req->priv = privreq; - req->callback = usbstrg_rdcomplete; + req->callback = usbmsc_rdcomplete; if (EP_SUBMIT(priv->epbulkout, req) != OK) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_IDLERDSUBMIT), (uint16_t)-ret); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_IDLERDSUBMIT), (uint16_t)-ret); } /* Change to the CMDPARSE state and return success */ - usbtrace(TRACE_CLASSSTATE(USBSTRG_CLASSSTATE_IDLECMDPARSE), priv->cdb[0]); - priv->thstate = USBSTRG_STATE_CMDPARSE; + usbtrace(TRACE_CLASSSTATE(USBMSC_CLASSSTATE_IDLECMDPARSE), priv->cdb[0]); + priv->thstate = USBMSC_STATE_CMDPARSE; ret = OK; } @@ -1642,45 +1642,45 @@ static int usbstrg_idlestate(FAR struct usbstrg_dev_s *priv) } /**************************************************************************** - * Name: usbstrg_cmdparsestate + * Name: usbmsc_cmdparsestate * * Description: - * Called from the worker thread in the USBSTRG_STATE_CMDPARSE state. - * This state is entered when usbstrg_idlestate obtains a valid CBW + * Called from the worker thread in the USBMSC_STATE_CMDPARSE state. + * This state is entered when usbmsc_idlestate obtains a valid CBW * containing SCSI commands. This function processes those SCSI commands. * * Returned value: * If no write request is available or certain other errors occur, this - * function returns a negated errno and stays in the USBSTRG_STATE_CMDPARSE + * function returns a negated errno and stays in the USBMSC_STATE_CMDPARSE * state. Otherwise, when the new CBW is successfully process, this - * function sets priv->thstate to one of USBSTRG_STATE_CMDREAD, - * USBSTRG_STATE_CMDWRITE, or USBSTRG_STATE_CMDFINISH and returns OK. + * function sets priv->thstate to one of USBMSC_STATE_CMDREAD, + * USBMSC_STATE_CMDWRITE, or USBMSC_STATE_CMDFINISH and returns OK. * ****************************************************************************/ -static int usbstrg_cmdparsestate(FAR struct usbstrg_dev_s *priv) +static int usbmsc_cmdparsestate(FAR struct usbmsc_dev_s *priv) { - FAR struct usbstrg_req_s *privreq; + FAR struct usbmsc_req_s *privreq; FAR uint8_t *buf; int ret = -EINVAL; - usbstrg_dumpdata("SCSCI CDB", priv->cdb, priv->cdblen); + usbmsc_dumpdata("SCSCI CDB", priv->cdb, priv->cdblen); /* Check if there is a request in the wrreqlist that we will be able to * use for data or status. */ - privreq = (FAR struct usbstrg_req_s *)sq_peek(&priv->wrreqlist); + privreq = (FAR struct usbmsc_req_s *)sq_peek(&priv->wrreqlist); /* If there no request structures available, then just return an error. * This will cause us to remain in the CMDPARSE state. When a request is - * returned, the worker thread will be awakened in the USBSTRG_STATE_CMDPARSE + * returned, the worker thread will be awakened in the USBMSC_STATE_CMDPARSE * and we will be called again. */ if (!privreq) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_CMDPARSEWRREQLISTEMPTY), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_CMDPARSEWRREQLISTEMPTY), 0); return -ENOMEM; } DEBUGASSERT(privreq->req && privreq->req->buf); @@ -1702,14 +1702,14 @@ static int usbstrg_cmdparsestate(FAR struct usbstrg_dev_s *priv) switch (priv->cdb[0]) { case SCSI_CMD_TESTUNITREADY: /* 0x00 Mandatory */ - ret = usbstrg_cmdtestunitready(priv); + ret = usbmsc_cmdtestunitready(priv); break; /* case SCSI_CMD_REZEROUNIT: * 0x01 Obsolete * * 0x02 Vendor-specific */ case SCSI_CMD_REQUESTSENSE: /* 0x03 Mandatory */ - ret = usbstrg_cmdrequestsense(priv, buf); + ret = usbmsc_cmdrequestsense(priv, buf); break; /* case SCSI_CMD_FORMAT_UNIT: * 0x04 Mandatory, but not implemented @@ -1718,13 +1718,13 @@ static int usbstrg_cmdparsestate(FAR struct usbstrg_dev_s *priv) * case SCSI_CMD_REASSIGNBLOCKS: * 0x07 Optional */ case SCSI_CMD_READ6: /* 0x08 Mandatory */ - ret = usbstrg_cmdread6(priv); + ret = usbmsc_cmdread6(priv); break; /* * 0x09 Vendor specific */ case SCSI_CMD_WRITE6: /* 0x0a Optional */ - ret = usbstrg_cmdwrite6(priv); + ret = usbmsc_cmdwrite6(priv); break; /* case SCSI_CMD_SEEK6: * 0x0b Obsolete @@ -1732,13 +1732,13 @@ static int usbstrg_cmdparsestate(FAR struct usbstrg_dev_s *priv) * case SCSI_CMD_SPACE6: * 0x11 Vendor specific */ case SCSI_CMD_INQUIRY: /* 0x12 Mandatory */ - ret = usbstrg_cmdinquiry(priv, buf); + ret = usbmsc_cmdinquiry(priv, buf); break; /* * 0x13-0x14 Vendor specific */ case SCSI_CMD_MODESELECT6: /* 0x15 Optional */ - ret = usbstrg_cmdmodeselect6(priv); + ret = usbmsc_cmdmodeselect6(priv); break; /* case SCSI_CMD_RESERVE6: * 0x16 Obsolete @@ -1747,39 +1747,39 @@ static int usbstrg_cmdparsestate(FAR struct usbstrg_dev_s *priv) * * 0x19 Vendor specific */ case SCSI_CMD_MODESENSE6: /* 0x1a Optional */ - ret = usbstrg_cmdmodesense6(priv, buf); + ret = usbmsc_cmdmodesense6(priv, buf); break; case SCSI_CMD_STARTSTOPUNIT: /* 0x1b Optional */ - ret = usbstrg_cmdstartstopunit(priv); + ret = usbmsc_cmdstartstopunit(priv); break; /* case SCSI_CMD_RECEIVEDIAGNOSTICRESULTS: * 0x1c Optional * case SCSI_CMD_SENDDIAGNOSTIC: * 0x1d Mandatory, but not implemented */ case SCSI_CMD_PREVENTMEDIAREMOVAL: /* 0x1e Optional */ - ret = usbstrg_cmdpreventmediumremoval(priv); + ret = usbmsc_cmdpreventmediumremoval(priv); break; /* * 0x20-22 Vendor specific */ case SCSI_CMD_READFORMATCAPACITIES: /* 0x23 Vendor-specific (defined in MMC spec) */ - ret = usbstrg_cmdreadformatcapacity(priv, buf); + ret = usbmsc_cmdreadformatcapacity(priv, buf); break; /* * 0x24 Vendor specific */ case SCSI_CMD_READCAPACITY10: /* 0x25 Mandatory */ - ret = usbstrg_cmdreadcapacity10(priv, buf); + ret = usbmsc_cmdreadcapacity10(priv, buf); break; /* * 0x26-27 Vendor specific */ case SCSI_CMD_READ10: /* 0x28 Mandatory */ - ret = usbstrg_cmdread10(priv); + ret = usbmsc_cmdread10(priv); break; /* * 0x29 Vendor specific */ case SCSI_CMD_WRITE10: /* 0x2a Optional */ - ret = usbstrg_cmdwrite10(priv); + ret = usbmsc_cmdwrite10(priv); break; /* case SCSI_CMD_SEEK10: * 0x2b Obsolete @@ -1787,7 +1787,7 @@ static int usbstrg_cmdparsestate(FAR struct usbstrg_dev_s *priv) * case SCSI_CMD_WRITEANDVERIFY: * 0x2e Optional */ case SCSI_CMD_VERIFY10: /* 0x2f Optional, but needed my MS Windows */ - ret = usbstrg_cmdverify10(priv); + ret = usbmsc_cmdverify10(priv); break; /* case SCSI_CMD_SEARCHDATAHIGH: * 0x30 Obsolete @@ -1797,7 +1797,7 @@ static int usbstrg_cmdparsestate(FAR struct usbstrg_dev_s *priv) * case SCSI_CMD_PREFETCH10: * 0x34 Optional */ case SCSI_CMD_SYNCHCACHE10: /* 0x35 Optional */ - ret = usbstrg_cmdsynchronizecache10(priv); + ret = usbmsc_cmdsynchronizecache10(priv); break; /* case SCSI_CMD_LOCKCACHE: * 0x36 Obsolete @@ -1817,14 +1817,14 @@ static int usbstrg_cmdparsestate(FAR struct usbstrg_dev_s *priv) * case SCSI_CMD_XDREAD10: * 0x52 Optional */ case SCSI_CMD_MODESELECT10: /* 0x55 Optional */ - ret = usbstrg_cmdmodeselect10(priv); + ret = usbmsc_cmdmodeselect10(priv); break; /* case SCSI_CMD_RESERVE10: * 0x56 Obsolete * case SCSI_CMD_RELEASE10: * 0x57 Obsolete */ case SCSI_CMD_MODESENSE10: /* 0x5a Optional */ - ret = usbstrg_cmdmodesense10(priv, buf); + ret = usbmsc_cmdmodesense10(priv, buf); break; /* case SCSI_CMD_PERSISTENTRESERVEIN: * 0x5e Optional @@ -1855,11 +1855,11 @@ static int usbstrg_cmdparsestate(FAR struct usbstrg_dev_s *priv) * case SCSI_CMD_MOVEMEDIUMATTACHED: * 0xa7 Optional (MCHNGR==0) */ case SCSI_CMD_READ12: /* 0xa8 Optional */ - ret = usbstrg_cmdread12(priv); + ret = usbmsc_cmdread12(priv); break; case SCSI_CMD_WRITE12: /* 0xaa Optional */ - ret = usbstrg_cmdwrite12(priv); + ret = usbmsc_cmdwrite12(priv); break; /* case SCSI_CMD_READMEDIASERIALNUMBER: * 0xab Optional @@ -1889,7 +1889,7 @@ static int usbstrg_cmdparsestate(FAR struct usbstrg_dev_s *priv) /* Is a response required? (Not for read6/10/12 and write6/10/12). */ - if (priv->thstate == USBSTRG_STATE_CMDPARSE) + if (priv->thstate == USBMSC_STATE_CMDPARSE) { /* All commands come through this path (EXCEPT read6/10/12 and write6/10/12). * For all other commands, the following setup is expected for the response @@ -1921,7 +1921,7 @@ static int usbstrg_cmdparsestate(FAR struct usbstrg_dev_s *priv) * in the response: */ - if (priv->cbwdir == USBSTRG_FLAGS_DIRDEVICE2HOST) + if (priv->cbwdir == USBMSC_FLAGS_DIRDEVICE2HOST) { /* The number of bytes in the response cannot exceed the host * 'allocation length' in the command. @@ -1945,28 +1945,28 @@ static int usbstrg_cmdparsestate(FAR struct usbstrg_dev_s *priv) * 3. Return OK to continue; <0 to wait for the next event */ - usbtrace(TRACE_CLASSSTATE(USBSTRG_CLASSSTATE_CMDPARSECMDFINISH), priv->cdb[0]); - priv->thstate = USBSTRG_STATE_CMDFINISH; + usbtrace(TRACE_CLASSSTATE(USBMSC_CLASSSTATE_CMDPARSECMDFINISH), priv->cdb[0]); + priv->thstate = USBMSC_STATE_CMDFINISH; ret = OK; } return ret; } /**************************************************************************** - * Name: usbstrg_cmdreadstate + * Name: usbmsc_cmdreadstate * * Description: - * Called from the worker thread in the USBSTRG_STATE_CMDREAD state. - * The USBSTRG_STATE_CMDREAD state is entered when usbstrg_cmdparsestate + * Called from the worker thread in the USBMSC_STATE_CMDREAD state. + * The USBMSC_STATE_CMDREAD state is entered when usbmsc_cmdparsestate * obtains a valid SCSI read command. This state is really a continuation - * of the USBSTRG_STATE_CMDPARSE state that handles extended SCSI read + * of the USBMSC_STATE_CMDPARSE state that handles extended SCSI read * command handling. * * Returned value: * If no USBDEV write request is available or certain other errors occur, this - * function returns a negated errno and stays in the USBSTRG_STATE_CMDREAD + * function returns a negated errno and stays in the USBMSC_STATE_CMDREAD * state. Otherwise, when the new SCSI read command is fully processed, - * this function sets priv->thstate to USBSTRG_STATE_CMDFINISH and returns OK. + * this function sets priv->thstate to USBMSC_STATE_CMDFINISH and returns OK. * * State variables: * xfrlen - holds the number of sectors read to be read. @@ -1977,10 +1977,10 @@ static int usbstrg_cmdparsestate(FAR struct usbstrg_dev_s *priv) * ****************************************************************************/ -static int usbstrg_cmdreadstate(FAR struct usbstrg_dev_s *priv) +static int usbmsc_cmdreadstate(FAR struct usbmsc_dev_s *priv) { - FAR struct usbstrg_lun_s *lun = priv->lun; - FAR struct usbstrg_req_s *privreq; + FAR struct usbmsc_lun_s *lun = priv->lun; + FAR struct usbmsc_req_s *privreq; FAR struct usbdev_req_s *req; irqstate_t flags; ssize_t nread; @@ -1996,7 +1996,7 @@ static int usbstrg_cmdreadstate(FAR struct usbstrg_dev_s *priv) while (priv->u.xfrlen > 0 || priv->nsectbytes > 0) { - usbtrace(TRACE_CLASSSTATE(USBSTRG_CLASSSTATE_CMDREAD), priv->u.xfrlen); + usbtrace(TRACE_CLASSSTATE(USBMSC_CLASSSTATE_CMDREAD), priv->u.xfrlen); /* Is the I/O buffer empty? */ @@ -2004,10 +2004,10 @@ static int usbstrg_cmdreadstate(FAR struct usbstrg_dev_s *priv) { /* Yes.. read the next sector */ - nread = USBSTRG_DRVR_READ(lun, priv->iobuffer, priv->sector, 1); + nread = USBMSC_DRVR_READ(lun, priv->iobuffer, priv->sector, 1); if (nread < 0) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_CMDREADREADFAIL), -nread); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_CMDREADREADFAIL), -nread); lun->sd = SCSI_KCQME_UNRRE1; lun->sdinfo = priv->sector; break; @@ -2022,17 +2022,17 @@ static int usbstrg_cmdreadstate(FAR struct usbstrg_dev_s *priv) * use for data transfer. */ - privreq = (FAR struct usbstrg_req_s *)sq_peek(&priv->wrreqlist); + privreq = (FAR struct usbmsc_req_s *)sq_peek(&priv->wrreqlist); /* If there no request structures available, then just return an error. * This will cause us to remain in the CMDREAD state. When a request is - * returned, the worker thread will be awakened in the USBSTRG_STATE_CMDREAD + * returned, the worker thread will be awakened in the USBMSC_STATE_CMDREAD * and we will be called again. */ if (!privreq) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_CMDREADWRRQEMPTY), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_CMDREADWRRQEMPTY), 0); priv->nreqbytes = 0; return -ENOMEM; } @@ -2045,7 +2045,7 @@ static int usbstrg_cmdreadstate(FAR struct usbstrg_dev_s *priv) src = &priv->iobuffer[lun->sectorsize - priv->nsectbytes]; dest = &req->buf[priv->nreqbytes]; - nbytes = MIN(CONFIG_USBSTRG_BULKINREQLEN - priv->nreqbytes, priv->nsectbytes); + nbytes = MIN(CONFIG_USBMSC_BULKINREQLEN - priv->nreqbytes, priv->nsectbytes); /* Copy the data from the sector buffer to the USB request and update counts */ @@ -2057,7 +2057,7 @@ static int usbstrg_cmdreadstate(FAR struct usbstrg_dev_s *priv) * then submit the request */ - if (priv->nreqbytes >= CONFIG_USBSTRG_BULKINREQLEN || + if (priv->nreqbytes >= CONFIG_USBMSC_BULKINREQLEN || (priv->u.xfrlen <= 0 && priv->nsectbytes <= 0)) { /* Remove the request that we just filled from wrreqlist (we've already checked @@ -2065,20 +2065,20 @@ static int usbstrg_cmdreadstate(FAR struct usbstrg_dev_s *priv) */ flags = irqsave(); - privreq = (FAR struct usbstrg_req_s *)sq_remfirst(&priv->wrreqlist); + privreq = (FAR struct usbmsc_req_s *)sq_remfirst(&priv->wrreqlist); irqrestore(flags); /* And submit the request to the bulk IN endpoint */ req->len = priv->nreqbytes; req->priv = privreq; - req->callback = usbstrg_wrcomplete; + req->callback = usbmsc_wrcomplete; req->flags = 0; ret = EP_SUBMIT(priv->epbulkin, req); if (ret != OK) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_CMDREADSUBMIT), (uint16_t)-ret); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_CMDREADSUBMIT), (uint16_t)-ret); lun->sd = SCSI_KCQME_UNRRE1; lun->sdinfo = priv->sector; break; @@ -2093,26 +2093,26 @@ static int usbstrg_cmdreadstate(FAR struct usbstrg_dev_s *priv) } } - usbtrace(TRACE_CLASSSTATE(USBSTRG_CLASSSTATE_CMDREADCMDFINISH), priv->u.xfrlen); - priv->thstate = USBSTRG_STATE_CMDFINISH; + usbtrace(TRACE_CLASSSTATE(USBMSC_CLASSSTATE_CMDREADCMDFINISH), priv->u.xfrlen); + priv->thstate = USBMSC_STATE_CMDFINISH; return OK; } /**************************************************************************** - * Name: usbstrg_cmdwritestate + * Name: usbmsc_cmdwritestate * * Description: - * Called from the worker thread in the USBSTRG_STATE_CMDWRITE state. - * The USBSTRG_STATE_CMDWRITE state is entered when usbstrg_cmdparsestate + * Called from the worker thread in the USBMSC_STATE_CMDWRITE state. + * The USBMSC_STATE_CMDWRITE state is entered when usbmsc_cmdparsestate * obtains a valid SCSI write command. This state is really a continuation - * of the USBSTRG_STATE_CMDPARSE state that handles extended SCSI write + * of the USBMSC_STATE_CMDPARSE state that handles extended SCSI write * command handling. * * Returned value: * If no USBDEV write request is available or certain other errors occur, this - * function returns a negated errno and stays in the USBSTRG_STATE_CMDWRITE + * function returns a negated errno and stays in the USBMSC_STATE_CMDWRITE * state. Otherwise, when the new SCSI write command is fully processed, - * this function sets priv->thstate to USBSTRG_STATE_CMDFINISH and returns OK. + * this function sets priv->thstate to USBMSC_STATE_CMDFINISH and returns OK. * * State variables: * xfrlen - holds the number of sectors read to be written. @@ -2123,10 +2123,10 @@ static int usbstrg_cmdreadstate(FAR struct usbstrg_dev_s *priv) * ****************************************************************************/ -static int usbstrg_cmdwritestate(FAR struct usbstrg_dev_s *priv) +static int usbmsc_cmdwritestate(FAR struct usbmsc_dev_s *priv) { - FAR struct usbstrg_lun_s *lun = priv->lun; - FAR struct usbstrg_req_s *privreq; + FAR struct usbmsc_lun_s *lun = priv->lun; + FAR struct usbmsc_req_s *privreq; FAR struct usbdev_req_s *req; ssize_t nwritten; uint16_t xfrd; @@ -2142,23 +2142,23 @@ static int usbstrg_cmdwritestate(FAR struct usbstrg_dev_s *priv) while (priv->u.xfrlen > 0) { - usbtrace(TRACE_CLASSSTATE(USBSTRG_CLASSSTATE_CMDWRITE), priv->u.xfrlen); + usbtrace(TRACE_CLASSSTATE(USBMSC_CLASSSTATE_CMDWRITE), priv->u.xfrlen); /* Check if there is a request in the rdreqlist containing additional * data to be written. */ - privreq = (FAR struct usbstrg_req_s *)sq_remfirst(&priv->rdreqlist); + privreq = (FAR struct usbmsc_req_s *)sq_remfirst(&priv->rdreqlist); /* If there no request data available, then just return an error. * This will cause us to remain in the CMDWRITE state. When a filled request is - * received, the worker thread will be awakened in the USBSTRG_STATE_CMDWRITE + * received, the worker thread will be awakened in the USBMSC_STATE_CMDWRITE * and we will be called again. */ if (!privreq) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_CMDWRITERDRQEMPTY), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_CMDWRITERDRQEMPTY), 0); priv->nreqbytes = 0; return -ENOMEM; } @@ -2192,10 +2192,10 @@ static int usbstrg_cmdwritestate(FAR struct usbstrg_dev_s *priv) { /* Yes.. Write the next sector */ - nwritten = USBSTRG_DRVR_WRITE(lun, priv->iobuffer, priv->sector, 1); + nwritten = USBMSC_DRVR_WRITE(lun, priv->iobuffer, priv->sector, 1); if (nwritten < 0) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_CMDWRITEWRITEFAIL), -nwritten); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_CMDWRITEWRITEFAIL), -nwritten); lun->sd = SCSI_KCQME_WRITEFAULTAUTOREALLOCFAILED; lun->sdinfo = priv->sector; goto errout; @@ -2213,19 +2213,19 @@ static int usbstrg_cmdwritestate(FAR struct usbstrg_dev_s *priv) * to get the next read request. */ - req->len = CONFIG_USBSTRG_BULKOUTREQLEN; + req->len = CONFIG_USBMSC_BULKOUTREQLEN; req->priv = privreq; - req->callback = usbstrg_rdcomplete; + req->callback = usbmsc_rdcomplete; ret = EP_SUBMIT(priv->epbulkout, req); if (ret != OK) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_CMDWRITERDSUBMIT), (uint16_t)-ret); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_CMDWRITERDSUBMIT), (uint16_t)-ret); } /* Did the host decide to stop early? */ - if (xfrd != CONFIG_USBSTRG_BULKOUTREQLEN) + if (xfrd != CONFIG_USBMSC_BULKOUTREQLEN) { priv->shortpacket = 1; goto errout; @@ -2233,30 +2233,30 @@ static int usbstrg_cmdwritestate(FAR struct usbstrg_dev_s *priv) } errout: - usbtrace(TRACE_CLASSSTATE(USBSTRG_CLASSSTATE_CMDWRITECMDFINISH), priv->u.xfrlen); - priv->thstate = USBSTRG_STATE_CMDFINISH; + usbtrace(TRACE_CLASSSTATE(USBMSC_CLASSSTATE_CMDWRITECMDFINISH), priv->u.xfrlen); + priv->thstate = USBMSC_STATE_CMDFINISH; return OK; } /**************************************************************************** - * Name: usbstrg_cmdfinishstate + * Name: usbmsc_cmdfinishstate * * Description: - * Called from the worker thread in the USBSTRG_STATE_CMDFINISH state. - * The USBSTRG_STATE_CMDFINISH state is entered when processing of a + * Called from the worker thread in the USBMSC_STATE_CMDFINISH state. + * The USBMSC_STATE_CMDFINISH state is entered when processing of a * command has finished but before status has been returned. * * Returned value: * If no USBDEV write request is available or certain other errors occur, this - * function returns a negated errno and stays in the USBSTRG_STATE_CMDFINISH + * function returns a negated errno and stays in the USBMSC_STATE_CMDFINISH * state. Otherwise, when the command is fully processed, this function - * sets priv->thstate to USBSTRG_STATE_CMDSTATUS and returns OK. + * sets priv->thstate to USBMSC_STATE_CMDSTATUS and returns OK. * ****************************************************************************/ -static int usbstrg_cmdfinishstate(FAR struct usbstrg_dev_s *priv) +static int usbmsc_cmdfinishstate(FAR struct usbmsc_dev_s *priv) { - FAR struct usbstrg_req_s *privreq; + FAR struct usbmsc_req_s *privreq; irqstate_t flags; int ret = OK; @@ -2264,17 +2264,17 @@ static int usbstrg_cmdfinishstate(FAR struct usbstrg_dev_s *priv) * use for data transfer. */ - privreq = (FAR struct usbstrg_req_s *)sq_peek(&priv->wrreqlist); + privreq = (FAR struct usbmsc_req_s *)sq_peek(&priv->wrreqlist); /* If there no request structures available, then just return an error. * This will cause us to remain in the CMDREAD state. When a request is - * returned, the worker thread will be awakened in the USBSTRG_STATE_CMDREAD + * returned, the worker thread will be awakened in the USBMSC_STATE_CMDREAD * and we will be called again. */ if (!privreq) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_CMDFINISHRQEMPTY), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_CMDFINISHRQEMPTY), 0); return -ENOMEM; } @@ -2284,7 +2284,7 @@ static int usbstrg_cmdfinishstate(FAR struct usbstrg_dev_s *priv) { /* Device-to-host: All but the last data buffer has been sent */ - case USBSTRG_FLAGS_DIRDEVICE2HOST: + case USBMSC_FLAGS_DIRDEVICE2HOST: if (priv->cbwlen > 0) { /* On most commands (the exception is outgoing, write commands), @@ -2300,21 +2300,21 @@ static int usbstrg_cmdfinishstate(FAR struct usbstrg_dev_s *priv) */ flags = irqsave(); - privreq = (FAR struct usbstrg_req_s *)sq_remfirst(&priv->wrreqlist); + privreq = (FAR struct usbmsc_req_s *)sq_remfirst(&priv->wrreqlist); irqrestore(flags); /* Send the write request */ req = privreq->req; req->len = priv->nreqbytes; - req->callback = usbstrg_wrcomplete; + req->callback = usbmsc_wrcomplete; req->priv = privreq; req->flags = USBDEV_REQFLAGS_NULLPKT; ret = EP_SUBMIT(priv->epbulkin, privreq->req); if (ret < 0) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_CMDFINISHSUBMIT), (uint16_t)-ret); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_CMDFINISHSUBMIT), (uint16_t)-ret); } } @@ -2322,9 +2322,9 @@ static int usbstrg_cmdfinishstate(FAR struct usbstrg_dev_s *priv) if (priv->residue > 0) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_CMDFINISHRESIDUE), (uint16_t)priv->residue); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_CMDFINISHRESIDUE), (uint16_t)priv->residue); -#ifdef CONFIG_USBSTRG_RACEWAR +#ifdef CONFIG_USBMSC_RACEWAR /* (See description of the workaround at the top of the file). * First, wait for the transfer to complete, then stall the endpoint */ @@ -2344,7 +2344,7 @@ static int usbstrg_cmdfinishstate(FAR struct usbstrg_dev_s *priv) /* Host-to-device: We have processed all we want of the host data. */ - case USBSTRG_FLAGS_DIRHOST2DEVICE: + case USBMSC_FLAGS_DIRHOST2DEVICE: if (priv->residue > 0) { /* Did the host stop sending unexpectedly early? */ @@ -2352,82 +2352,82 @@ static int usbstrg_cmdfinishstate(FAR struct usbstrg_dev_s *priv) flags = irqsave(); if (priv->shortpacket) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_CMDFINISHSHORTPKT), (uint16_t)priv->residue); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_CMDFINISHSHORTPKT), (uint16_t)priv->residue); } /* Unprocessed incoming data: STALL and cancel requests. */ else { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_CMDFINSHSUBMIT), (uint16_t)priv->residue); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_CMDFINSHSUBMIT), (uint16_t)priv->residue); EP_STALL(priv->epbulkout); } - priv->theventset |= USBSTRG_EVENT_ABORTBULKOUT; + priv->theventset |= USBMSC_EVENT_ABORTBULKOUT; irqrestore(flags); } break; default: - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_CMDFINSHDIR), priv->cbwdir); - case USBSTRG_FLAGS_DIRNONE: /* Nothing to send */ + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_CMDFINSHDIR), priv->cbwdir); + case USBMSC_FLAGS_DIRNONE: /* Nothing to send */ break; } /* Return to the IDLE state */ - usbtrace(TRACE_CLASSSTATE(USBSTRG_CLASSSTATE_CMDFINISHCMDSTATUS), 0); - priv->thstate = USBSTRG_STATE_CMDSTATUS; + usbtrace(TRACE_CLASSSTATE(USBMSC_CLASSSTATE_CMDFINISHCMDSTATUS), 0); + priv->thstate = USBMSC_STATE_CMDSTATUS; return OK; } /**************************************************************************** - * Name: usbstrg_cmdstatusstate + * Name: usbmsc_cmdstatusstate * * Description: - * Called from the worker thread in the USBSTRG_STATE_CMDSTATUS state. + * Called from the worker thread in the USBMSC_STATE_CMDSTATUS state. * That state is after a CBW has been fully processed. This function sends * the concluding CSW. * * Returned value: * If no write request is available or certain other errors occur, this - * function returns a negated errno and stays in the USBSTRG_STATE_CMDSTATUS + * function returns a negated errno and stays in the USBMSC_STATE_CMDSTATUS * state. Otherwise, when the SCSI statis is successfully returned, this - * function sets priv->thstate to USBSTRG_STATE_IDLE and returns OK. + * function sets priv->thstate to USBMSC_STATE_IDLE and returns OK. * ****************************************************************************/ -static int usbstrg_cmdstatusstate(FAR struct usbstrg_dev_s *priv) +static int usbmsc_cmdstatusstate(FAR struct usbmsc_dev_s *priv) { - FAR struct usbstrg_lun_s *lun = priv->lun; - FAR struct usbstrg_req_s *privreq; + FAR struct usbmsc_lun_s *lun = priv->lun; + FAR struct usbmsc_req_s *privreq; FAR struct usbdev_req_s *req; - FAR struct usbstrg_csw_s *csw; + FAR struct usbmsc_csw_s *csw; irqstate_t flags; uint32_t sd; - uint8_t status = USBSTRG_CSWSTATUS_PASS; + uint8_t status = USBMSC_CSWSTATUS_PASS; int ret; /* Take a request from the wrreqlist */ flags = irqsave(); - privreq = (FAR struct usbstrg_req_s *)sq_remfirst(&priv->wrreqlist); + privreq = (FAR struct usbmsc_req_s *)sq_remfirst(&priv->wrreqlist); irqrestore(flags); /* If there no request structures available, then just return an error. * This will cause us to remain in the CMDSTATUS status. When a request is - * returned, the worker thread will be awakened in the USBSTRG_STATE_CMDSTATUS + * returned, the worker thread will be awakened in the USBMSC_STATE_CMDSTATUS * and we will be called again. */ if (!privreq) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_CMDSTATUSRDREQLISTEMPTY), 0); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_CMDSTATUSRDREQLISTEMPTY), 0); return -ENOMEM; } req = privreq->req; - csw = (struct usbstrg_csw_s*)req->buf; + csw = (struct usbmsc_csw_s*)req->buf; /* Extract the sense data from the LUN structure */ @@ -2444,14 +2444,14 @@ static int usbstrg_cmdstatusstate(FAR struct usbstrg_dev_s *priv) if (priv->phaseerror) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_SNDPHERROR), 0); - status = USBSTRG_CSWSTATUS_PHASEERROR; + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_SNDPHERROR), 0); + status = USBMSC_CSWSTATUS_PHASEERROR; sd = SCSI_KCQIR_INVALIDCOMMAND; } else if (sd != SCSI_KCQ_NOSENSE) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_SNDCSWFAIL), 0); - status = USBSTRG_CSWSTATUS_FAIL; + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_SNDCSWFAIL), 0); + status = USBMSC_CSWSTATUS_FAIL; } /* Format and submit the CSW */ @@ -2460,21 +2460,21 @@ static int usbstrg_cmdstatusstate(FAR struct usbstrg_dev_s *priv) csw->signature[1] = 'S'; csw->signature[2] = 'B'; csw->signature[3] = 'S'; - usbstrg_putle32(csw->tag, priv->cbwtag); - usbstrg_putle32(csw->residue, priv->residue); + usbmsc_putle32(csw->tag, priv->cbwtag); + usbmsc_putle32(csw->residue, priv->residue); csw->status = status; - usbstrg_dumpdata("SCSCI CSW", (uint8_t*)csw, USBSTRG_CSW_SIZEOF); + usbmsc_dumpdata("SCSCI CSW", (uint8_t*)csw, USBMSC_CSW_SIZEOF); - req->len = USBSTRG_CSW_SIZEOF; - req->callback = usbstrg_wrcomplete; + req->len = USBMSC_CSW_SIZEOF; + req->callback = usbmsc_wrcomplete; req->priv = privreq; req->flags = USBDEV_REQFLAGS_NULLPKT; ret = EP_SUBMIT(priv->epbulkin, req); if (ret < 0) { - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_SNDSTATUSSUBMIT), (uint16_t)-ret); + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_SNDSTATUSSUBMIT), (uint16_t)-ret); flags = irqsave(); (void)sq_addlast((sq_entry_t*)privreq, &priv->wrreqlist); irqrestore(flags); @@ -2482,8 +2482,8 @@ static int usbstrg_cmdstatusstate(FAR struct usbstrg_dev_s *priv) /* Return to the IDLE state */ - usbtrace(TRACE_CLASSSTATE(USBSTRG_CLASSSTATE_CMDSTATUSIDLE), 0); - priv->thstate = USBSTRG_STATE_IDLE; + usbtrace(TRACE_CLASSSTATE(USBMSC_CLASSSTATE_CMDSTATUSIDLE), 0); + priv->thstate = USBMSC_STATE_IDLE; return OK; } @@ -2492,7 +2492,7 @@ static int usbstrg_cmdstatusstate(FAR struct usbstrg_dev_s *priv) ****************************************************************************/ /**************************************************************************** - * Name: usbstrg_workerthread + * Name: usbmsc_workerthread * * Description: * This is the main function of the USB storage worker thread. It loops @@ -2500,9 +2500,9 @@ static int usbstrg_cmdstatusstate(FAR struct usbstrg_dev_s *priv) * ****************************************************************************/ -void *usbstrg_workerthread(void *arg) +void *usbmsc_workerthread(void *arg) { - struct usbstrg_dev_s *priv = (struct usbstrg_dev_s *)arg; + struct usbmsc_dev_s *priv = (struct usbmsc_dev_s *)arg; irqstate_t flags; uint16_t eventset; int ret; @@ -2512,23 +2512,23 @@ void *usbstrg_workerthread(void *arg) */ pthread_mutex_lock(&priv->mutex); - priv->thstate = USBSTRG_STATE_STARTED; - while ((priv->theventset & USBSTRG_EVENT_READY) != 0 && - (priv->theventset & USBSTRG_EVENT_TERMINATEREQUEST) != 0) + priv->thstate = USBMSC_STATE_STARTED; + while ((priv->theventset & USBMSC_EVENT_READY) != 0 && + (priv->theventset & USBMSC_EVENT_TERMINATEREQUEST) != 0) { pthread_cond_wait(&priv->cond, &priv->mutex); } /* Transition to the INITIALIZED/IDLE state */ - priv->thstate = USBSTRG_STATE_IDLE; + priv->thstate = USBMSC_STATE_IDLE; eventset = priv->theventset; - priv->theventset = USBSTRG_EVENT_NOEVENTS; + priv->theventset = USBMSC_EVENT_NOEVENTS; pthread_mutex_unlock(&priv->mutex); /* Then loop until we are asked to terminate */ - while ((eventset & USBSTRG_EVENT_TERMINATEREQUEST) == 0) + while ((eventset & USBMSC_EVENT_TERMINATEREQUEST) == 0) { /* Wait for some interesting event. Note that we must both take the * lock (to eliminate race conditions with other threads) and disable @@ -2537,7 +2537,7 @@ void *usbstrg_workerthread(void *arg) pthread_mutex_lock(&priv->mutex); flags = irqsave(); - if (priv->theventset == USBSTRG_EVENT_NOEVENTS) + if (priv->theventset == USBMSC_EVENT_NOEVENTS) { pthread_cond_wait(&priv->cond, &priv->mutex); } @@ -2548,25 +2548,25 @@ void *usbstrg_workerthread(void *arg) */ eventset = priv->theventset; - priv->theventset = USBSTRG_EVENT_NOEVENTS; + priv->theventset = USBMSC_EVENT_NOEVENTS; pthread_mutex_unlock(&priv->mutex); /* Were we awakened by some event that requires immediate action? * - * - The USBSTRG_EVENT_DISCONNECT is signalled from the disconnect method + * - The USBMSC_EVENT_DISCONNECT is signalled from the disconnect method * after all transfers have been stopped, when the host is disconnected. * - * - The CUSBSTRG_EVENT_RESET is signalled when the bulk-storage-specific - * USBSTRG_REQ_MSRESET EP0 setup received. We must stop the current + * - The CUSBMSC_EVENT_RESET is signalled when the bulk-storage-specific + * USBMSC_REQ_MSRESET EP0 setup received. We must stop the current * operation and reinialize state. * - * - The USBSTRG_EVENT_CFGCHANGE is signaled when the EP0 setup logic + * - The USBMSC_EVENT_CFGCHANGE is signaled when the EP0 setup logic * receives a valid USB_REQ_SETCONFIGURATION request * - * - The USBSTRG_EVENT_IFCHANGE is signaled when the EP0 setup logic + * - The USBMSC_EVENT_IFCHANGE is signaled when the EP0 setup logic * receives a valid USB_REQ_SETINTERFACE request * - * - The USBSTRG_EVENT_ABORTBULKOUT event is signalled by the CMDFINISH + * - The USBMSC_EVENT_ABORTBULKOUT event is signalled by the CMDFINISH * logic when there is a residue after processing a host-to-device * transfer. We need to discard all incoming request. * @@ -2574,33 +2574,33 @@ void *usbstrg_workerthread(void *arg) * drive the state machine. */ - if ((eventset & (USBSTRG_EVENT_DISCONNECT|USBSTRG_EVENT_RESET|USBSTRG_EVENT_CFGCHANGE| - USBSTRG_EVENT_IFCHANGE|USBSTRG_EVENT_ABORTBULKOUT)) != 0) + if ((eventset & (USBMSC_EVENT_DISCONNECT|USBMSC_EVENT_RESET|USBMSC_EVENT_CFGCHANGE| + USBMSC_EVENT_IFCHANGE|USBMSC_EVENT_ABORTBULKOUT)) != 0) { /* These events require that the current configuration be reset */ - if ((eventset & USBSTRG_EVENT_IFCHANGE) != 0) + if ((eventset & USBMSC_EVENT_IFCHANGE) != 0) { - usbstrg_resetconfig(priv); + usbmsc_resetconfig(priv); } /* These events require that a new configuration be established */ - if ((eventset & (USBSTRG_EVENT_CFGCHANGE|USBSTRG_EVENT_IFCHANGE)) != 0) + if ((eventset & (USBMSC_EVENT_CFGCHANGE|USBMSC_EVENT_IFCHANGE)) != 0) { - usbstrg_setconfig(priv, priv->thvalue); + usbmsc_setconfig(priv, priv->thvalue); } /* These events required that we send a deferred EP0 setup response */ - if ((eventset & (USBSTRG_EVENT_RESET|USBSTRG_EVENT_CFGCHANGE|USBSTRG_EVENT_IFCHANGE)) != 0) + if ((eventset & (USBMSC_EVENT_RESET|USBMSC_EVENT_CFGCHANGE|USBMSC_EVENT_IFCHANGE)) != 0) { - usbstrg_deferredresponse(priv, false); + usbmsc_deferredresponse(priv, false); } /* For all of these events... terminate any transactions in progress */ - priv->thstate = USBSTRG_STATE_IDLE; + priv->thstate = USBMSC_STATE_IDLE; } irqrestore(flags); @@ -2620,36 +2620,36 @@ void *usbstrg_workerthread(void *arg) { switch (priv->thstate) { - case USBSTRG_STATE_IDLE: /* Started and waiting for commands */ - ret = usbstrg_idlestate(priv); + case USBMSC_STATE_IDLE: /* Started and waiting for commands */ + ret = usbmsc_idlestate(priv); break; - case USBSTRG_STATE_CMDPARSE: /* Parsing the received a command */ - ret = usbstrg_cmdparsestate(priv); + case USBMSC_STATE_CMDPARSE: /* Parsing the received a command */ + ret = usbmsc_cmdparsestate(priv); break; - case USBSTRG_STATE_CMDREAD: /* Continuing to process a SCSI read command */ - ret = usbstrg_cmdreadstate(priv); + case USBMSC_STATE_CMDREAD: /* Continuing to process a SCSI read command */ + ret = usbmsc_cmdreadstate(priv); break; - case USBSTRG_STATE_CMDWRITE: /* Continuing to process a SCSI write command */ - ret = usbstrg_cmdwritestate(priv); + case USBMSC_STATE_CMDWRITE: /* Continuing to process a SCSI write command */ + ret = usbmsc_cmdwritestate(priv); break; - case USBSTRG_STATE_CMDFINISH: /* Finish command processing */ - ret = usbstrg_cmdfinishstate(priv); + case USBMSC_STATE_CMDFINISH: /* Finish command processing */ + ret = usbmsc_cmdfinishstate(priv); break; - case USBSTRG_STATE_CMDSTATUS: /* Processing the status phase of a command */ - ret = usbstrg_cmdstatusstate(priv); + case USBMSC_STATE_CMDSTATUS: /* Processing the status phase of a command */ + ret = usbmsc_cmdstatusstate(priv); break; - case USBSTRG_STATE_NOTSTARTED: /* Thread has not yet been started */ - case USBSTRG_STATE_STARTED: /* Started, but is not yet initialized */ - case USBSTRG_STATE_TERMINATED: /* Thread has exitted */ + case USBMSC_STATE_NOTSTARTED: /* Thread has not yet been started */ + case USBMSC_STATE_STARTED: /* Started, but is not yet initialized */ + case USBMSC_STATE_TERMINATED: /* Thread has exitted */ default: - usbtrace(TRACE_CLSERROR(USBSTRG_TRACEERR_INVALIDSTATE), priv->thstate); - priv->thstate = USBSTRG_STATE_IDLE; + usbtrace(TRACE_CLSERROR(USBMSC_TRACEERR_INVALIDSTATE), priv->thstate); + priv->thstate = USBMSC_STATE_IDLE; ret = OK; break; } @@ -2659,6 +2659,6 @@ void *usbstrg_workerthread(void *arg) /* Transition to the TERMINATED state and exit */ - priv->thstate = USBSTRG_STATE_TERMINATED; + priv->thstate = USBMSC_STATE_TERMINATED; return NULL; } diff --git a/nuttx/drivers/usbhost/usbhost_storage.c b/nuttx/drivers/usbhost/usbhost_storage.c index 8f5864b6d..82409eac3 100644 --- a/nuttx/drivers/usbhost/usbhost_storage.c +++ b/nuttx/drivers/usbhost/usbhost_storage.c @@ -161,8 +161,8 @@ static inline void usbhost_mkdevname(FAR struct usbhost_state_s *priv, char *dev /* CBW/CSW debug helpers */ #if defined(CONFIG_DEBUG_USB) && defined(CONFIG_DEBUG_VERBOSE) -static void usbhost_dumpcbw(FAR struct usbstrg_cbw_s *cbw); -static void usbhost_dumpcsw(FAR struct usbstrg_csw_s *csw); +static void usbhost_dumpcbw(FAR struct usbmsc_cbw_s *cbw); +static void usbhost_dumpcsw(FAR struct usbmsc_csw_s *csw); #else # define usbhost_dumpcbw(cbw); # define usbhost_dumpcsw(csw); @@ -170,16 +170,16 @@ static void usbhost_dumpcsw(FAR struct usbstrg_csw_s *csw); /* CBW helpers */ -static inline void usbhost_requestsensecbw(FAR struct usbstrg_cbw_s *cbw); -static inline void usbhost_testunitreadycbw(FAR struct usbstrg_cbw_s *cbw); -static inline void usbhost_readcapacitycbw(FAR struct usbstrg_cbw_s *cbw); -static inline void usbhost_inquirycbw (FAR struct usbstrg_cbw_s *cbw); +static inline void usbhost_requestsensecbw(FAR struct usbmsc_cbw_s *cbw); +static inline void usbhost_testunitreadycbw(FAR struct usbmsc_cbw_s *cbw); +static inline void usbhost_readcapacitycbw(FAR struct usbmsc_cbw_s *cbw); +static inline void usbhost_inquirycbw (FAR struct usbmsc_cbw_s *cbw); static inline void usbhost_readcbw (size_t startsector, uint16_t blocksize, unsigned int nsectors, - FAR struct usbstrg_cbw_s *cbw); + FAR struct usbmsc_cbw_s *cbw); static inline void usbhost_writecbw(size_t startsector, uint16_t blocksize, unsigned int nsectors, - FAR struct usbstrg_cbw_s *cbw); + FAR struct usbmsc_cbw_s *cbw); /* Command helpers */ static inline int usbhost_maxlunreq(FAR struct usbhost_state_s *priv); @@ -214,7 +214,7 @@ static void usbhost_putbe32(uint8_t *dest, uint32_t val); static inline int usbhost_talloc(FAR struct usbhost_state_s *priv); static inline int usbhost_tfree(FAR struct usbhost_state_s *priv); -static FAR struct usbstrg_cbw_s *usbhost_cbwalloc(FAR struct usbhost_state_s *priv); +static FAR struct usbmsc_cbw_s *usbhost_cbwalloc(FAR struct usbhost_state_s *priv); /* struct usbhost_registry_s methods */ @@ -256,8 +256,8 @@ static int usbhost_ioctl(FAR struct inode *inode, int cmd, static const const struct usbhost_id_s g_id = { USB_CLASS_MASS_STORAGE, /* base */ - USBSTRG_SUBCLASS_SCSI, /* subclass */ - USBSTRG_PROTO_BULKONLY, /* proto */ + USBMSC_SUBCLASS_SCSI, /* subclass */ + USBMSC_PROTO_BULKONLY, /* proto */ 0, /* vid */ 0 /* pid */ }; @@ -494,7 +494,7 @@ static inline void usbhost_mkdevname(FAR struct usbhost_state_s *priv, char *dev ****************************************************************************/ #if defined(CONFIG_DEBUG_USB) && defined(CONFIG_DEBUG_VERBOSE) -static void usbhost_dumpcbw(FAR struct usbstrg_cbw_s *cbw) +static void usbhost_dumpcbw(FAR struct usbmsc_cbw_s *cbw) { int i; @@ -515,7 +515,7 @@ static void usbhost_dumpcbw(FAR struct usbstrg_cbw_s *cbw) } } -static void usbhost_dumpcsw(FAR struct usbstrg_csw_s *csw) +static void usbhost_dumpcsw(FAR struct usbmsc_csw_s *csw) { uvdbg("CSW:\n"); uvdbg(" signature: %08x\n", usbhost_getle32(csw->signature)); @@ -539,14 +539,14 @@ static void usbhost_dumpcsw(FAR struct usbstrg_csw_s *csw) * ****************************************************************************/ -static inline void usbhost_requestsensecbw(FAR struct usbstrg_cbw_s *cbw) +static inline void usbhost_requestsensecbw(FAR struct usbmsc_cbw_s *cbw) { FAR struct scsicmd_requestsense_s *reqsense; /* Format the CBW */ usbhost_putle32(cbw->datlen, SCSIRESP_FIXEDSENSEDATA_SIZEOF); - cbw->flags = USBSTRG_CBWFLAG_IN; + cbw->flags = USBMSC_CBWFLAG_IN; cbw->cdblen = SCSICMD_REQUESTSENSE_SIZEOF; /* Format the CDB */ @@ -558,7 +558,7 @@ static inline void usbhost_requestsensecbw(FAR struct usbstrg_cbw_s *cbw) usbhost_dumpcbw(cbw); } -static inline void usbhost_testunitreadycbw(FAR struct usbstrg_cbw_s *cbw) +static inline void usbhost_testunitreadycbw(FAR struct usbmsc_cbw_s *cbw) { /* Format the CBW */ @@ -571,14 +571,14 @@ static inline void usbhost_testunitreadycbw(FAR struct usbstrg_cbw_s *cbw) usbhost_dumpcbw(cbw); } -static inline void usbhost_readcapacitycbw(FAR struct usbstrg_cbw_s *cbw) +static inline void usbhost_readcapacitycbw(FAR struct usbmsc_cbw_s *cbw) { FAR struct scsicmd_readcapacity10_s *rcap10; /* Format the CBW */ usbhost_putle32(cbw->datlen, SCSIRESP_READCAPACITY10_SIZEOF); - cbw->flags = USBSTRG_CBWFLAG_IN; + cbw->flags = USBMSC_CBWFLAG_IN; cbw->cdblen = SCSICMD_READCAPACITY10_SIZEOF; /* Format the CDB */ @@ -589,14 +589,14 @@ static inline void usbhost_readcapacitycbw(FAR struct usbstrg_cbw_s *cbw) usbhost_dumpcbw(cbw); } -static inline void usbhost_inquirycbw (FAR struct usbstrg_cbw_s *cbw) +static inline void usbhost_inquirycbw (FAR struct usbmsc_cbw_s *cbw) { FAR struct scscicmd_inquiry_s *inq; /* Format the CBW */ usbhost_putle32(cbw->datlen, SCSIRESP_INQUIRY_SIZEOF); - cbw->flags = USBSTRG_CBWFLAG_IN; + cbw->flags = USBMSC_CBWFLAG_IN; cbw->cdblen = SCSICMD_INQUIRY_SIZEOF; /* Format the CDB */ @@ -610,14 +610,14 @@ static inline void usbhost_inquirycbw (FAR struct usbstrg_cbw_s *cbw) static inline void usbhost_readcbw (size_t startsector, uint16_t blocksize, - unsigned int nsectors, FAR struct usbstrg_cbw_s *cbw) + unsigned int nsectors, FAR struct usbmsc_cbw_s *cbw) { FAR struct scsicmd_read10_s *rd10; /* Format the CBW */ usbhost_putle32(cbw->datlen, blocksize * nsectors); - cbw->flags = USBSTRG_CBWFLAG_IN; + cbw->flags = USBMSC_CBWFLAG_IN; cbw->cdblen = SCSICMD_READ10_SIZEOF; /* Format the CDB */ @@ -632,7 +632,7 @@ usbhost_readcbw (size_t startsector, uint16_t blocksize, static inline void usbhost_writecbw(size_t startsector, uint16_t blocksize, - unsigned int nsectors, FAR struct usbstrg_cbw_s *cbw) + unsigned int nsectors, FAR struct usbmsc_cbw_s *cbw) { FAR struct scsicmd_write10_s *wr10; @@ -679,7 +679,7 @@ static inline int usbhost_maxlunreq(FAR struct usbhost_state_s *priv) uvdbg("Request maximum logical unit number\n"); memset(req, 0, sizeof(struct usb_ctrlreq_s)); req->type = USB_DIR_IN|USB_REQ_TYPE_CLASS|USB_REQ_RECIPIENT_INTERFACE; - req->req = USBSTRG_REQ_GETMAXLUN; + req->req = USBMSC_REQ_GETMAXLUN; usbhost_putle16(req->len, 1); ret = DRVR_CTRLIN(priv->drvr, req, priv->tbuffer); @@ -696,7 +696,7 @@ static inline int usbhost_maxlunreq(FAR struct usbhost_state_s *priv) static inline int usbhost_testunitready(FAR struct usbhost_state_s *priv) { - FAR struct usbstrg_cbw_s *cbw; + FAR struct usbmsc_cbw_s *cbw; int result; /* Initialize a CBW (re-using the allocated transfer buffer) */ @@ -712,16 +712,16 @@ static inline int usbhost_testunitready(FAR struct usbhost_state_s *priv) usbhost_testunitreadycbw(cbw); result = DRVR_TRANSFER(priv->drvr, priv->bulkout, - (uint8_t*)cbw, USBSTRG_CBW_SIZEOF); + (uint8_t*)cbw, USBMSC_CBW_SIZEOF); if (result == OK) { /* Receive the CSW */ result = DRVR_TRANSFER(priv->drvr, priv->bulkin, - priv->tbuffer, USBSTRG_CSW_SIZEOF); + priv->tbuffer, USBMSC_CSW_SIZEOF); if (result == OK) { - usbhost_dumpcsw((FAR struct usbstrg_csw_s *)priv->tbuffer); + usbhost_dumpcsw((FAR struct usbmsc_csw_s *)priv->tbuffer); } } return result; @@ -729,7 +729,7 @@ static inline int usbhost_testunitready(FAR struct usbhost_state_s *priv) static inline int usbhost_requestsense(FAR struct usbhost_state_s *priv) { - FAR struct usbstrg_cbw_s *cbw; + FAR struct usbmsc_cbw_s *cbw; int result; /* Initialize a CBW (re-using the allocated transfer buffer) */ @@ -745,7 +745,7 @@ static inline int usbhost_requestsense(FAR struct usbhost_state_s *priv) usbhost_requestsensecbw(cbw); result = DRVR_TRANSFER(priv->drvr, priv->bulkout, - (uint8_t*)cbw, USBSTRG_CBW_SIZEOF); + (uint8_t*)cbw, USBMSC_CBW_SIZEOF); if (result == OK) { /* Receive the sense data response */ @@ -757,10 +757,10 @@ static inline int usbhost_requestsense(FAR struct usbhost_state_s *priv) /* Receive the CSW */ result = DRVR_TRANSFER(priv->drvr, priv->bulkin, - priv->tbuffer, USBSTRG_CSW_SIZEOF); + priv->tbuffer, USBMSC_CSW_SIZEOF); if (result == OK) { - usbhost_dumpcsw((FAR struct usbstrg_csw_s *)priv->tbuffer); + usbhost_dumpcsw((FAR struct usbmsc_csw_s *)priv->tbuffer); } } } @@ -770,7 +770,7 @@ static inline int usbhost_requestsense(FAR struct usbhost_state_s *priv) static inline int usbhost_readcapacity(FAR struct usbhost_state_s *priv) { - FAR struct usbstrg_cbw_s *cbw; + FAR struct usbmsc_cbw_s *cbw; FAR struct scsiresp_readcapacity10_s *resp; int result; @@ -787,7 +787,7 @@ static inline int usbhost_readcapacity(FAR struct usbhost_state_s *priv) usbhost_readcapacitycbw(cbw); result = DRVR_TRANSFER(priv->drvr, priv->bulkout, - (uint8_t*)cbw, USBSTRG_CBW_SIZEOF); + (uint8_t*)cbw, USBMSC_CBW_SIZEOF); if (result == OK) { /* Receive the read capacity CBW IN response */ @@ -805,10 +805,10 @@ static inline int usbhost_readcapacity(FAR struct usbhost_state_s *priv) /* Receive the CSW */ result = DRVR_TRANSFER(priv->drvr, priv->bulkin, - priv->tbuffer, USBSTRG_CSW_SIZEOF); + priv->tbuffer, USBMSC_CSW_SIZEOF); if (result == OK) { - usbhost_dumpcsw((FAR struct usbstrg_csw_s *)priv->tbuffer); + usbhost_dumpcsw((FAR struct usbmsc_csw_s *)priv->tbuffer); } } } @@ -818,7 +818,7 @@ static inline int usbhost_readcapacity(FAR struct usbhost_state_s *priv) static inline int usbhost_inquiry(FAR struct usbhost_state_s *priv) { - FAR struct usbstrg_cbw_s *cbw; + FAR struct usbmsc_cbw_s *cbw; FAR struct scsiresp_inquiry_s *resp; int result; @@ -835,7 +835,7 @@ static inline int usbhost_inquiry(FAR struct usbhost_state_s *priv) usbhost_inquirycbw(cbw); result = DRVR_TRANSFER(priv->drvr, priv->bulkout, - (uint8_t*)cbw, USBSTRG_CBW_SIZEOF); + (uint8_t*)cbw, USBMSC_CBW_SIZEOF); if (result == OK) { /* Receive the CBW IN response */ @@ -851,10 +851,10 @@ static inline int usbhost_inquiry(FAR struct usbhost_state_s *priv) /* Receive the CSW */ result = DRVR_TRANSFER(priv->drvr, priv->bulkin, - priv->tbuffer, USBSTRG_CSW_SIZEOF); + priv->tbuffer, USBMSC_CSW_SIZEOF); if (result == OK) { - usbhost_dumpcsw((FAR struct usbstrg_csw_s *)priv->tbuffer); + usbhost_dumpcsw((FAR struct usbmsc_csw_s *)priv->tbuffer); } } } @@ -1168,7 +1168,7 @@ static inline int usbhost_cfgdesc(FAR struct usbhost_state_s *priv, static inline int usbhost_initvolume(FAR struct usbhost_state_s *priv) { - FAR struct usbstrg_csw_s *csw; + FAR struct usbmsc_csw_s *csw; unsigned int retries; int ret = OK; @@ -1208,7 +1208,7 @@ static inline int usbhost_initvolume(FAR struct usbhost_state_s *priv) { /* Is the unit is ready */ - csw = (FAR struct usbstrg_csw_s *)priv->tbuffer; + csw = (FAR struct usbmsc_csw_s *)priv->tbuffer; if (csw->status == 0) { /* Yes... break out of the loop */ @@ -1244,7 +1244,7 @@ static inline int usbhost_initvolume(FAR struct usbhost_state_s *priv) { /* Check the CSW for errors */ - csw = (FAR struct usbstrg_csw_s *)priv->tbuffer; + csw = (FAR struct usbmsc_csw_s *)priv->tbuffer; if (csw->status != 0) { udbg("ERROR: CSW status error: %d\n", csw->status); @@ -1265,7 +1265,7 @@ static inline int usbhost_initvolume(FAR struct usbhost_state_s *priv) { /* Check the CSW for errors */ - csw = (FAR struct usbstrg_csw_s *)priv->tbuffer; + csw = (FAR struct usbmsc_csw_s *)priv->tbuffer; if (csw->status != 0) { udbg("ERROR: CSW status error: %d\n", csw->status); @@ -1563,17 +1563,17 @@ static inline int usbhost_tfree(FAR struct usbhost_state_s *priv) * ****************************************************************************/ -static FAR struct usbstrg_cbw_s *usbhost_cbwalloc(FAR struct usbhost_state_s *priv) +static FAR struct usbmsc_cbw_s *usbhost_cbwalloc(FAR struct usbhost_state_s *priv) { - FAR struct usbstrg_cbw_s *cbw = NULL; + FAR struct usbmsc_cbw_s *cbw = NULL; - DEBUGASSERT(priv->tbuffer && priv->tbuflen >= sizeof(struct usbstrg_cbw_s)) + DEBUGASSERT(priv->tbuffer && priv->tbuflen >= sizeof(struct usbmsc_cbw_s)) /* Intialize the CBW sructure */ - cbw = (FAR struct usbstrg_cbw_s *)priv->tbuffer; - memset(cbw, 0, sizeof(struct usbstrg_cbw_s)); - usbhost_putle32(cbw->signature, USBSTRG_CBW_SIGNATURE); + cbw = (FAR struct usbmsc_cbw_s *)priv->tbuffer; + memset(cbw, 0, sizeof(struct usbmsc_cbw_s)); + usbhost_putle32(cbw->signature, USBMSC_CBW_SIGNATURE); return cbw; } @@ -1936,7 +1936,7 @@ static ssize_t usbhost_read(FAR struct inode *inode, unsigned char *buffer, } else if (nsectors > 0) { - FAR struct usbstrg_cbw_s *cbw; + FAR struct usbmsc_cbw_s *cbw; usbhost_takesem(&priv->exclsem); @@ -1957,7 +1957,7 @@ static ssize_t usbhost_read(FAR struct inode *inode, unsigned char *buffer, usbhost_readcbw(startsector, priv->blocksize, nsectors, cbw); result = DRVR_TRANSFER(priv->drvr, priv->bulkout, - (uint8_t*)cbw, USBSTRG_CBW_SIZEOF); + (uint8_t*)cbw, USBMSC_CBW_SIZEOF); if (result == OK) { /* Receive the user data */ @@ -1969,14 +1969,14 @@ static ssize_t usbhost_read(FAR struct inode *inode, unsigned char *buffer, /* Receive the CSW */ result = DRVR_TRANSFER(priv->drvr, priv->bulkin, - priv->tbuffer, USBSTRG_CSW_SIZEOF); + priv->tbuffer, USBMSC_CSW_SIZEOF); if (result == OK) { - FAR struct usbstrg_csw_s *csw; + FAR struct usbmsc_csw_s *csw; /* Check the CSW status */ - csw = (FAR struct usbstrg_csw_s *)priv->tbuffer; + csw = (FAR struct usbmsc_csw_s *)priv->tbuffer; if (csw->status == 0) { ret = nsectors; @@ -2028,7 +2028,7 @@ static ssize_t usbhost_write(FAR struct inode *inode, const unsigned char *buffe } else { - FAR struct usbstrg_cbw_s *cbw; + FAR struct usbmsc_cbw_s *cbw; usbhost_takesem(&priv->exclsem); @@ -2049,7 +2049,7 @@ static ssize_t usbhost_write(FAR struct inode *inode, const unsigned char *buffe usbhost_writecbw(startsector, priv->blocksize, nsectors, cbw); result = DRVR_TRANSFER(priv->drvr, priv->bulkout, - (uint8_t*)cbw, USBSTRG_CBW_SIZEOF); + (uint8_t*)cbw, USBMSC_CBW_SIZEOF); if (result == OK) { /* Send the user data */ @@ -2061,14 +2061,14 @@ static ssize_t usbhost_write(FAR struct inode *inode, const unsigned char *buffe /* Receive the CSW */ result = DRVR_TRANSFER(priv->drvr, priv->bulkin, - priv->tbuffer, USBSTRG_CSW_SIZEOF); + priv->tbuffer, USBMSC_CSW_SIZEOF); if (result == OK) { - FAR struct usbstrg_csw_s *csw; + FAR struct usbmsc_csw_s *csw; /* Check the CSW status */ - csw = (FAR struct usbstrg_csw_s *)priv->tbuffer; + csw = (FAR struct usbmsc_csw_s *)priv->tbuffer; if (csw->status == 0) { ret = nsectors; -- cgit v1.2.3