zrzk
/
px4_autopilot
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

Update STM32 USB OTG FS host driver -- the driver is now marginally functional 

git-svn-id: https://nuttx.svn.sourceforge.net/svnroot/nuttx/trunk@5051 7fd9a85b-ad96-42d3-883c-3090e2eb8679
sbg
patacongo 13 years ago
parent
2ac3898301
commit
20c7cf9db9
5 changed files with 120 additions and 77 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 4
      nuttx/ChangeLog
  2. 8
      nuttx/arch/arm/src/lpc17xx/lpc17_usbhost.c
  3. 64
      nuttx/arch/arm/src/stm32/stm32_otgfshost.c
  4. 113
      nuttx/drivers/usbhost/usbhost_storage.c
  5. 8
      nuttx/include/nuttx/usb/usbhost.h

4
nuttx/ChangeLog
Unescape View File

@ -3173,3 +3173,7 @@
* arch/arm/src/stm32/stm32_otgfshost.c: Renamed from stm32_usbhost.c. * arch/arm/src/stm32/stm32_otgfshost.c: Renamed from stm32_usbhost.c.
This is nearly code complete and, with any luck, will be available This is nearly code complete and, with any luck, will be available
in NuttX-6.22. in NuttX-6.22.
* configs/*/defconfig: Update all defconfig files to remove syntax
that is incompatible with the mconf configuration tool.
* arch/arm/src/stm32/stm32_otgfshost.c: This driver now appears to be
functional (although more testing is necesary).

8
nuttx/arch/arm/src/lpc17xx/lpc17_usbhost.c
Unescape View File

@ -2194,7 +2194,13 @@ static int lpc17_ctrlout(FAR struct usbhost_driver_s *drvr,
* *
* Returned Values: * Returned Values:
* On success, zero (OK) is returned. On a failure, a negated errno value is * On success, zero (OK) is returned. On a failure, a negated errno value is
* returned indicating the nature of the failure * returned indicating the nature of the failure:
*
* EAGAIN - If devices NAKs the transfer (or NYET or other error where
* it may be appropriate to restart the entire transaction).
* EPERM - If the endpoint stalls
* EIO - On a TX or data toggle error
* EPIPE - Overrun errors
* *
* Assumptions: * Assumptions:
* - Only a single class bound to a single device is supported. * - Only a single class bound to a single device is supported.

64
nuttx/arch/arm/src/stm32/stm32_otgfshost.c
Unescape View File

@ -201,6 +201,7 @@ struct stm32_chan_s
uint8_t epno; /* Device endpoint number (0-127) */ uint8_t epno; /* Device endpoint number (0-127) */
uint8_t eptype; /* See OTGFS_EPTYPE_* definitions */ uint8_t eptype; /* See OTGFS_EPTYPE_* definitions */
uint8_t pid; /* Data PID */ uint8_t pid; /* Data PID */
uint8_t npackets; /* Number of packets (for data toggle) */
bool inuse; /* True: This channel is "in use" */ bool inuse; /* True: This channel is "in use" */
volatile bool indata1; /* IN data toggle. True: DATA01 (Bulk and INTR only) */ volatile bool indata1; /* IN data toggle. True: DATA01 (Bulk and INTR only) */
volatile bool outdata1; /* OUT data toggle. True: DATA01 */ volatile bool outdata1; /* OUT data toggle. True: DATA01 */
@ -1057,6 +1058,13 @@ static void stm32_transfer_start(FAR struct stm32_usbhost_s *priv, int chidx)
} }
#endif #endif
/* Save the number of packets in the transfer. We will need this in
* order to set the next data toggle correctly when the transfer
* completes.
*/
chan->npackets = (uint8_t)npackets;
/* Setup the HCTSIZn register */ /* Setup the HCTSIZn register */
regval = ((uint32_t)chan->buflen << OTGFS_HCTSIZ_XFRSIZ_SHIFT) | regval = ((uint32_t)chan->buflen << OTGFS_HCTSIZ_XFRSIZ_SHIFT) |
@ -1387,7 +1395,7 @@ static void stm32_gint_wrpacket(FAR struct stm32_usbhost_s *priv,
* OK - Transfer completed successfully * OK - Transfer completed successfully
* EAGAIN - If devices NAKs the transfer or NYET occurs * EAGAIN - If devices NAKs the transfer or NYET occurs
* EPERM - If the endpoint stalls * EPERM - If the endpoint stalls
* EIO - On a TX or data error * EIO - On a TX or data toggle error
* EPIPE - Frame overrun * EPIPE - Frame overrun
* *
* EBUSY in the result field indicates that the transfer has not completed. * EBUSY in the result field indicates that the transfer has not completed.
@ -1405,8 +1413,8 @@ static inline void stm32_gint_hcinisr(FAR struct stm32_usbhost_s *priv,
* HCINTMSK register to get the set of enabled HC interrupts. * HCINTMSK register to get the set of enabled HC interrupts.
*/ */
pending = stm32_getreg(STM32_OTGFS_HCINT(chidx)); pending = stm32_getreg(STM32_OTGFS_HCINT(chidx));
regval = stm32_getreg(STM32_OTGFS_HCINTMSK(chidx)); regval = stm32_getreg(STM32_OTGFS_HCINTMSK(chidx));
/* AND the two to get the set of enabled, pending HC interrupts */ /* AND the two to get the set of enabled, pending HC interrupts */
@ -1588,11 +1596,18 @@ static inline void stm32_gint_hcinisr(FAR struct stm32_usbhost_s *priv,
else if ((pending & OTGFS_HCINT_NAK) != 0) else if ((pending & OTGFS_HCINT_NAK) != 0)
{ {
/* For a BULK tranfer, the hardware is capable of retrying
* automatically on a NAK. However, this is not always
* what we need to do. So we always halt the transfer and
* return control to high level logic in the even of a NAK.
*/
#if 0
/* Halt the interrupt channel */ /* Halt the interrupt channel */
if (chan->eptype == OTGFS_EPTYPE_CTRL) if (chan->eptype == OTGFS_EPTYPE_CTRL)
{ {
/* Halt the channel -- the CHH interrrupt is expected next */ /* Halt the channel -- the CHH interrrupt is expected next */
stm32_chan_halt(priv, chidx, CHREASON_NAK); stm32_chan_halt(priv, chidx, CHREASON_NAK);
} }
@ -1611,7 +1626,11 @@ static inline void stm32_gint_hcinisr(FAR struct stm32_usbhost_s *priv,
regval &= ~OTGFS_HCCHAR_CHDIS; regval &= ~OTGFS_HCCHAR_CHDIS;
stm32_putreg(STM32_OTGFS_HCCHAR(chidx), regval); stm32_putreg(STM32_OTGFS_HCCHAR(chidx), regval);
} }
#else
/* Halt all transfers on the NAK -- the CHH interrrupt is expected next */
stm32_chan_halt(priv, chidx, CHREASON_NAK);
#endif
/* Clear the NAK condition */ /* Clear the NAK condition */
stm32_putreg(STM32_OTGFS_HCINT(chidx), OTGFS_HCINT_NAK); stm32_putreg(STM32_OTGFS_HCINT(chidx), OTGFS_HCINT_NAK);
@ -1634,7 +1653,7 @@ static inline void stm32_gint_hcinisr(FAR struct stm32_usbhost_s *priv,
* OK - Transfer completed successfully * OK - Transfer completed successfully
* EAGAIN - If devices NAKs the transfer or NYET occurs * EAGAIN - If devices NAKs the transfer or NYET occurs
* EPERM - If the endpoint stalls * EPERM - If the endpoint stalls
* EIO - On a TX or data error * EIO - On a TX or data toggle error
* EPIPE - Frame overrun * EPIPE - Frame overrun
* *
* EBUSY in the result field indicates that the transfer has not completed. * EBUSY in the result field indicates that the transfer has not completed.
@ -1652,8 +1671,8 @@ static inline void stm32_gint_hcoutisr(FAR struct stm32_usbhost_s *priv,
* HCINTMSK register to get the set of enabled HC interrupts. * HCINTMSK register to get the set of enabled HC interrupts.
*/ */
pending = stm32_getreg(STM32_OTGFS_HCINT(chidx)); pending = stm32_getreg(STM32_OTGFS_HCINT(chidx));
regval = stm32_getreg(STM32_OTGFS_HCINTMSK(chidx)); regval = stm32_getreg(STM32_OTGFS_HCINTMSK(chidx));
/* AND the two to get the set of enabled, pending HC interrupts */ /* AND the two to get the set of enabled, pending HC interrupts */
@ -1798,11 +1817,14 @@ static inline void stm32_gint_hcoutisr(FAR struct stm32_usbhost_s *priv,
regval = stm32_getreg(STM32_OTGFS_HCCHAR(chidx)); regval = stm32_getreg(STM32_OTGFS_HCCHAR(chidx));
/* Is it a bulk endpoint */ /* Is it a bulk endpoint? Were an odd number of packets
* transferred?
*/
if ((regval & OTGFS_HCCHAR_EPTYP_MASK) == OTGFS_HCCHAR_EPTYP_BULK) if ((regval & OTGFS_HCCHAR_EPTYP_MASK) == OTGFS_HCCHAR_EPTYP_BULK &&
(chan->npackets & 1) != 0)
{ {
/* Yes... toggle the data out PID */ /* Yes to both... toggle the data out PID */
chan->outdata1 ^= true; chan->outdata1 ^= true;
} }
@ -3405,7 +3427,13 @@ static int stm32_ctrlout(FAR struct usbhost_driver_s *drvr,
* *
* Returned Values: * Returned Values:
* On success, zero (OK) is returned. On a failure, a negated errno value is * On success, zero (OK) is returned. On a failure, a negated errno value is
* returned indicating the nature of the failure * returned indicating the nature of the failure:
*
* EAGAIN - If devices NAKs the transfer (or NYET or other error where
* it may be appropriate to restart the entire transaction).
* EPERM - If the endpoint stalls
* EIO - On a TX or data toggle error
* EPIPE - Overrun errors
* *
* Assumptions: * Assumptions:
* - Only a single class bound to a single device is supported. * - Only a single class bound to a single device is supported.
@ -3528,22 +3556,14 @@ static int stm32_transfer(FAR struct usbhost_driver_s *drvr, usbhost_ep_t ep,
ret = stm32_chan_wait(priv, chan); ret = stm32_chan_wait(priv, chan);
/* EGAIN indicates that the device NAKed the transfer and we need /* EAGAIN indicates that the device NAKed the transfer and we need
* do try again. Anything else (success or other errors) will * do try again. Anything else (success or other errors) will
* cause use to return * cause use to return
*/ */
if (ret != -EAGAIN) if (ret != OK)
{ {
/* Output some debug info on an error */ udbg("Transfer failed: %d\n", ret);
if (ret < 0)
{
udbg("Transfer failed: %d\n", ret);
}
/* Break out and return this result */
break; break;
} }
} }

113
nuttx/drivers/usbhost/usbhost_storage.c
Unescape View File

@ -1,8 +1,8 @@
/**************************************************************************** /****************************************************************************
* drivers/usbhost/usbhost_storage.c * drivers/usbhost/usbhost_storage.c
* *
* Copyright (C) 2010-2011 Gregory Nutt. All rights reserved. * Copyright (C) 2010-2012 Gregory Nutt. All rights reserved.
* Author: Gregory Nutt <spudmonkey@racsa.co.cr> * Author: Gregory Nutt <gnutt@nuttx.org>
* *
* Redistribution and use in source and binary forms, with or without * Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions * modification, are permitted provided that the following conditions
@ -123,7 +123,7 @@ struct usbhost_state_s
struct usbhost_driver_s *drvr; struct usbhost_driver_s *drvr;
/* The remainder of the fields are provide to the mass storage class */ /* The remainder of the fields are provide to the mass storage class */
char sdchar; /* Character identifying the /dev/sd[n] device */ char sdchar; /* Character identifying the /dev/sd[n] device */
volatile bool disconnected; /* TRUE: Device has been disconnected */ volatile bool disconnected; /* TRUE: Device has been disconnected */
uint8_t ifno; /* Interface number */ uint8_t ifno; /* Interface number */
@ -217,7 +217,7 @@ static inline int usbhost_tfree(FAR struct usbhost_state_s *priv);
static FAR struct usbmsc_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 */ /* struct usbhost_registry_s methods */
static struct usbhost_class_s *usbhost_create(FAR struct usbhost_driver_s *drvr, static struct usbhost_class_s *usbhost_create(FAR struct usbhost_driver_s *drvr,
FAR const struct usbhost_id_s *id); FAR const struct usbhost_id_s *id);
@ -248,7 +248,7 @@ static int usbhost_ioctl(FAR struct inode *inode, int cmd,
* Private Data * Private Data
****************************************************************************/ ****************************************************************************/
/* This structure provides the registry entry ID informatino that will be /* This structure provides the registry entry ID informatino that will be
* used to associate the USB host mass storage class to a connected USB * used to associate the USB host mass storage class to a connected USB
* device. * device.
*/ */
@ -416,7 +416,7 @@ static inline void usbhost_freeclass(FAR struct usbhost_state_s *class)
flags = irqsave(); flags = irqsave();
class->class.flink = g_freelist; class->class.flink = g_freelist;
g_freelist = class; g_freelist = class;
irqrestore(flags); irqrestore(flags);
} }
#else #else
static inline void usbhost_freeclass(FAR struct usbhost_state_s *class) static inline void usbhost_freeclass(FAR struct usbhost_state_s *class)
@ -700,16 +700,16 @@ static inline int usbhost_testunitready(FAR struct usbhost_state_s *priv)
int result; int result;
/* Initialize a CBW (re-using the allocated transfer buffer) */ /* Initialize a CBW (re-using the allocated transfer buffer) */
cbw = usbhost_cbwalloc(priv); cbw = usbhost_cbwalloc(priv);
if (!cbw) if (!cbw)
{ {
udbg("ERROR: Failed to create CBW\n"); udbg("ERROR: Failed to create CBW\n");
return -ENOMEM; return -ENOMEM;
} }
/* Construct and send the CBW */ /* Construct and send the CBW */
usbhost_testunitreadycbw(cbw); usbhost_testunitreadycbw(cbw);
result = DRVR_TRANSFER(priv->drvr, priv->bulkout, result = DRVR_TRANSFER(priv->drvr, priv->bulkout,
(uint8_t*)cbw, USBMSC_CBW_SIZEOF); (uint8_t*)cbw, USBMSC_CBW_SIZEOF);
@ -733,7 +733,7 @@ static inline int usbhost_requestsense(FAR struct usbhost_state_s *priv)
int result; int result;
/* Initialize a CBW (re-using the allocated transfer buffer) */ /* Initialize a CBW (re-using the allocated transfer buffer) */
cbw = usbhost_cbwalloc(priv); cbw = usbhost_cbwalloc(priv);
if (!cbw) if (!cbw)
{ {
@ -742,7 +742,7 @@ static inline int usbhost_requestsense(FAR struct usbhost_state_s *priv)
} }
/* Construct and send the CBW */ /* Construct and send the CBW */
usbhost_requestsensecbw(cbw); usbhost_requestsensecbw(cbw);
result = DRVR_TRANSFER(priv->drvr, priv->bulkout, result = DRVR_TRANSFER(priv->drvr, priv->bulkout,
(uint8_t*)cbw, USBMSC_CBW_SIZEOF); (uint8_t*)cbw, USBMSC_CBW_SIZEOF);
@ -775,7 +775,7 @@ static inline int usbhost_readcapacity(FAR struct usbhost_state_s *priv)
int result; int result;
/* Initialize a CBW (re-using the allocated transfer buffer) */ /* Initialize a CBW (re-using the allocated transfer buffer) */
cbw = usbhost_cbwalloc(priv); cbw = usbhost_cbwalloc(priv);
if (!cbw) if (!cbw)
{ {
@ -784,7 +784,7 @@ static inline int usbhost_readcapacity(FAR struct usbhost_state_s *priv)
} }
/* Construct and send the CBW */ /* Construct and send the CBW */
usbhost_readcapacitycbw(cbw); usbhost_readcapacitycbw(cbw);
result = DRVR_TRANSFER(priv->drvr, priv->bulkout, result = DRVR_TRANSFER(priv->drvr, priv->bulkout,
(uint8_t*)cbw, USBMSC_CBW_SIZEOF); (uint8_t*)cbw, USBMSC_CBW_SIZEOF);
@ -823,7 +823,7 @@ static inline int usbhost_inquiry(FAR struct usbhost_state_s *priv)
int result; int result;
/* Initialize a CBW (re-using the allocated transfer buffer) */ /* Initialize a CBW (re-using the allocated transfer buffer) */
cbw = usbhost_cbwalloc(priv); cbw = usbhost_cbwalloc(priv);
if (!cbw) if (!cbw)
{ {
@ -832,7 +832,7 @@ static inline int usbhost_inquiry(FAR struct usbhost_state_s *priv)
} }
/* Construct and send the CBW */ /* Construct and send the CBW */
usbhost_inquirycbw(cbw); usbhost_inquirycbw(cbw);
result = DRVR_TRANSFER(priv->drvr, priv->bulkout, result = DRVR_TRANSFER(priv->drvr, priv->bulkout,
(uint8_t*)cbw, USBMSC_CBW_SIZEOF); (uint8_t*)cbw, USBMSC_CBW_SIZEOF);
@ -885,7 +885,7 @@ static void usbhost_destroy(FAR void *arg)
DEBUGASSERT(priv != NULL); DEBUGASSERT(priv != NULL);
uvdbg("crefs: %d\n", priv->crefs); uvdbg("crefs: %d\n", priv->crefs);
/* Unregister the block driver */ /* Unregister the block driver */
usbhost_mkdevname(priv, devname); usbhost_mkdevname(priv, devname);
@ -965,10 +965,10 @@ static inline int usbhost_cfgdesc(FAR struct usbhost_state_s *priv,
uint8_t found = 0; uint8_t found = 0;
int ret; int ret;
DEBUGASSERT(priv != NULL && DEBUGASSERT(priv != NULL &&
configdesc != NULL && configdesc != NULL &&
desclen >= sizeof(struct usb_cfgdesc_s)); desclen >= sizeof(struct usb_cfgdesc_s));
/* Verify that we were passed a configuration descriptor */ /* Verify that we were passed a configuration descriptor */
cfgdesc = (FAR struct usb_cfgdesc_s *)configdesc; cfgdesc = (FAR struct usb_cfgdesc_s *)configdesc;
@ -1004,7 +1004,7 @@ static inline int usbhost_cfgdesc(FAR struct usbhost_state_s *priv,
case USB_DESC_TYPE_INTERFACE: case USB_DESC_TYPE_INTERFACE:
{ {
FAR struct usb_ifdesc_s *ifdesc = (FAR struct usb_ifdesc_s *)configdesc; FAR struct usb_ifdesc_s *ifdesc = (FAR struct usb_ifdesc_s *)configdesc;
uvdbg("Interface descriptor\n"); uvdbg("Interface descriptor\n");
DEBUGASSERT(remaining >= USB_SIZEOF_IFDESC); DEBUGASSERT(remaining >= USB_SIZEOF_IFDESC);
@ -1078,7 +1078,7 @@ static inline int usbhost_cfgdesc(FAR struct usbhost_state_s *priv,
found |= USBHOST_BINFOUND; found |= USBHOST_BINFOUND;
/* Save the bulk IN endpoint information */ /* Save the bulk IN endpoint information */
bindesc.addr = epdesc->addr & USB_EP_ADDR_NUMBER_MASK; bindesc.addr = epdesc->addr & USB_EP_ADDR_NUMBER_MASK;
bindesc.in = 1; bindesc.in = 1;
bindesc.funcaddr = funcaddr; bindesc.funcaddr = funcaddr;
@ -1108,7 +1108,7 @@ static inline int usbhost_cfgdesc(FAR struct usbhost_state_s *priv,
} }
/* Increment the address of the next descriptor */ /* Increment the address of the next descriptor */
configdesc += desc->len; configdesc += desc->len;
remaining -= desc->len; remaining -= desc->len;
} }
@ -1116,7 +1116,7 @@ static inline int usbhost_cfgdesc(FAR struct usbhost_state_s *priv,
/* Sanity checking... did we find all of things that we need? Hmmm.. I wonder.. /* Sanity checking... did we find all of things that we need? Hmmm.. I wonder..
* can we work read-only or write-only if only one bulk endpoint found? * can we work read-only or write-only if only one bulk endpoint found?
*/ */
if (found != USBHOST_ALLFOUND) if (found != USBHOST_ALLFOUND)
{ {
ulldbg("ERROR: Found IF:%s BIN:%s BOUT:%s\n", ulldbg("ERROR: Found IF:%s BIN:%s BOUT:%s\n",
@ -1202,7 +1202,7 @@ static inline int usbhost_initvolume(FAR struct usbhost_state_s *priv)
uvdbg("Test unit ready, retries=%d\n", retries); uvdbg("Test unit ready, retries=%d\n", retries);
/* Send TESTUNITREADY to see the unit is ready */ /* Send TESTUNITREADY to see the unit is ready */
ret = usbhost_testunitready(priv); ret = usbhost_testunitready(priv);
if (ret == OK) if (ret == OK)
{ {
@ -1585,7 +1585,7 @@ static FAR struct usbmsc_cbw_s *usbhost_cbwalloc(FAR struct usbhost_state_s *pri
* Name: usbhost_create * Name: usbhost_create
* *
* Description: * Description:
* This function implements the create() method of struct usbhost_registry_s. * This function implements the create() method of struct usbhost_registry_s.
* The create() method is a callback into the class implementation. It is * The create() method is a callback into the class implementation. It is
* used to (1) create a new instance of the USB host class state and to (2) * used to (1) create a new instance of the USB host class state and to (2)
* bind a USB host driver "session" to the class instance. Use of this * bind a USB host driver "session" to the class instance. Use of this
@ -1644,9 +1644,9 @@ static FAR struct usbhost_class_s *usbhost_create(FAR struct usbhost_driver_s *d
priv->drvr = drvr; priv->drvr = drvr;
/* NOTE: We do not yet know the geometry of the USB mass storage device */ /* NOTE: We do not yet know the geometry of the USB mass storage device */
/* Return the instance of the USB mass storage class */ /* Return the instance of the USB mass storage class */
return &priv->class; return &priv->class;
} }
} }
@ -1701,7 +1701,7 @@ static int usbhost_connect(FAR struct usbhost_class_s *class,
FAR struct usbhost_state_s *priv = (FAR struct usbhost_state_s *)class; FAR struct usbhost_state_s *priv = (FAR struct usbhost_state_s *)class;
int ret; int ret;
DEBUGASSERT(priv != NULL && DEBUGASSERT(priv != NULL &&
configdesc != NULL && configdesc != NULL &&
desclen >= sizeof(struct usb_cfgdesc_s)); desclen >= sizeof(struct usb_cfgdesc_s));
@ -1722,7 +1722,7 @@ static int usbhost_connect(FAR struct usbhost_class_s *class,
udbg("usbhost_initvolume() failed: %d\n", ret); udbg("usbhost_initvolume() failed: %d\n", ret);
} }
} }
return ret; return ret;
} }
@ -1792,7 +1792,7 @@ static int usbhost_disconnected(struct usbhost_class_s *class)
} }
} }
irqrestore(flags); irqrestore(flags);
return OK; return OK;
} }
@ -1945,45 +1945,52 @@ static ssize_t usbhost_read(FAR struct inode *inode, unsigned char *buffer,
ret = -ENOMEM; ret = -ENOMEM;
/* Initialize a CBW (re-using the allocated transfer buffer) */ /* Initialize a CBW (re-using the allocated transfer buffer) */
cbw = usbhost_cbwalloc(priv); cbw = usbhost_cbwalloc(priv);
if (cbw) if (cbw)
{ {
/* Assume some device failure */ /* Loop in the event that EAGAIN is returned (mean that the
* transaction was NAKed and we should try again.
ret = -ENODEV; */
/* Construct and send the CBW */ do
usbhost_readcbw(startsector, priv->blocksize, nsectors, cbw);
result = DRVR_TRANSFER(priv->drvr, priv->bulkout,
(uint8_t*)cbw, USBMSC_CBW_SIZEOF);
if (result == OK)
{ {
/* Receive the user data */ /* Assume some device failure */
ret = -ENODEV;
result = DRVR_TRANSFER(priv->drvr, priv->bulkin, /* Construct and send the CBW */
buffer, priv->blocksize * nsectors);
usbhost_readcbw(startsector, priv->blocksize, nsectors, cbw);
result = DRVR_TRANSFER(priv->drvr, priv->bulkout,
(uint8_t*)cbw, USBMSC_CBW_SIZEOF);
if (result == OK) if (result == OK)
{ {
/* Receive the CSW */ /* Receive the user data */
result = DRVR_TRANSFER(priv->drvr, priv->bulkin, result = DRVR_TRANSFER(priv->drvr, priv->bulkin,
priv->tbuffer, USBMSC_CSW_SIZEOF); buffer, priv->blocksize * nsectors);
if (result == OK) if (result == OK)
{ {
FAR struct usbmsc_csw_s *csw; /* Receive the CSW */
/* Check the CSW status */
csw = (FAR struct usbmsc_csw_s *)priv->tbuffer; result = DRVR_TRANSFER(priv->drvr, priv->bulkin,
if (csw->status == 0) priv->tbuffer, USBMSC_CSW_SIZEOF);
if (result == OK)
{ {
ret = nsectors; FAR struct usbmsc_csw_s *csw;
/* Check the CSW status */
csw = (FAR struct usbmsc_csw_s *)priv->tbuffer;
if (csw->status == 0)
{
ret = nsectors;
}
} }
} }
} }
} } while (result == -EAGAIN);
} }
usbhost_givesem(&priv->exclsem); usbhost_givesem(&priv->exclsem);
@ -2037,7 +2044,7 @@ static ssize_t usbhost_write(FAR struct inode *inode, const unsigned char *buffe
ret = -ENOMEM; ret = -ENOMEM;
/* Initialize a CBW (re-using the allocated transfer buffer) */ /* Initialize a CBW (re-using the allocated transfer buffer) */
cbw = usbhost_cbwalloc(priv); cbw = usbhost_cbwalloc(priv);
if (cbw) if (cbw)
{ {
@ -2046,7 +2053,7 @@ static ssize_t usbhost_write(FAR struct inode *inode, const unsigned char *buffe
ret = -ENODEV; ret = -ENODEV;
/* Construct and send the CBW */ /* Construct and send the CBW */
usbhost_writecbw(startsector, priv->blocksize, nsectors, cbw); usbhost_writecbw(startsector, priv->blocksize, nsectors, cbw);
result = DRVR_TRANSFER(priv->drvr, priv->bulkout, result = DRVR_TRANSFER(priv->drvr, priv->bulkout,
(uint8_t*)cbw, USBMSC_CBW_SIZEOF); (uint8_t*)cbw, USBMSC_CBW_SIZEOF);

8
nuttx/include/nuttx/usb/usbhost.h
Unescape View File

@ -448,7 +448,13 @@
* *
* Returned Values: * Returned Values:
* On success, zero (OK) is returned. On a failure, a negated errno value is * On success, zero (OK) is returned. On a failure, a negated errno value is
* returned indicating the nature of the failure * returned indicating the nature of the failure:
*
* EAGAIN - If devices NAKs the transfer (or NYET or other error where
* it may be appropriate to restart the entire transaction).
* EPERM - If the endpoint stalls
* EIO - On a TX or data toggle error
* EPIPE - Overrun errors
* *
* Assumptions: * Assumptions:
* This function will *not* be called from an interrupt handler. * This function will *not* be called from an interrupt handler.

Write Preview
Loading…
Cancel
Save