From 4e68b68d5a799300bcbbfb3fdff0ea584239bcb0 Mon Sep 17 00:00:00 2001 From: gdisirio Date: Sun, 6 Feb 2011 09:51:16 +0000 Subject: [PATCH] USB rework, step 2. git-svn-id: svn://svn.code.sf.net/p/chibios/svn/trunk@2714 35acf78f-673a-0410-8e92-d51de3d6d3f4 --- os/hal/include/usb.h | 17 +- os/hal/platforms/STM32/usb_lld.c | 254 +++++++++++++----- os/hal/platforms/STM32/usb_lld.h | 132 +++++----- os/hal/src/usb.c | 427 +++++++++++++++++-------------- testhal/STM32/USB_CDC/halconf.h | 2 +- testhal/STM32/USB_CDC/main.c | 66 ++++- 6 files changed, 568 insertions(+), 330 deletions(-) diff --git a/os/hal/include/usb.h b/os/hal/include/usb.h index 9f0d95837..e5f309bd3 100644 --- a/os/hal/include/usb.h +++ b/os/hal/include/usb.h @@ -73,6 +73,9 @@ #define USB_FEATURE_DEVICE_REMOTE_WAKEUP 1 #define USB_FEATURE_TEST_MODE 2 +#define USB_EARLY_SET_ADDRESS 0 +#define USB_LATE_SET_ADDRESS 1 + /*===========================================================================*/ /* Driver pre-compile time settings. */ /*===========================================================================*/ @@ -296,10 +299,9 @@ typedef const USBDescriptor * (*usbgetdescriptor_t)(USBDriver *usbp, * * @api */ -#define usbSetupTransfer(usbp, buf, n, endcb) { \ - (usbp)->usb_ep0next = (buf); \ - (usbp)->usb_ep0n = (n); \ - (usbp)->usb_ep0endcb = (endcb); \ +#define usbSetupTransfer(usbp, buf, n) { \ + (usbp)->ep0next = (buf); \ + (usbp)->ep0n = (n); \ } /*===========================================================================*/ @@ -315,6 +317,13 @@ extern "C" { void usbStop(USBDriver *usbp); void usbInitEndpointI(USBDriver *usbp, usbep_t ep, USBEndpointState *epp, const USBEndpointConfig *epcp); + void usbDisableEndpointsI(USBDriver *usbp); + bool_t usbStartReceiveI(USBDriver *usbp, usbep_t ep, + uint8_t *buf, size_t n); + bool_t usbStartTransmitI(USBDriver *usbp, usbep_t ep, + const uint8_t *buf, size_t n); + bool_t usbStallReceiveI(USBDriver *usbp, usbep_t ep); + bool_t usbStallTransmitI(USBDriver *usbp, usbep_t ep); void _usb_reset(USBDriver *usbp); void _usb_ep0in(USBDriver *usbp, usbep_t ep); void _usb_ep0out(USBDriver *usbp, usbep_t ep); diff --git a/os/hal/platforms/STM32/usb_lld.c b/os/hal/platforms/STM32/usb_lld.c index 3fe6771ea..c55251d9b 100644 --- a/os/hal/platforms/STM32/usb_lld.c +++ b/os/hal/platforms/STM32/usb_lld.c @@ -62,7 +62,7 @@ static const USBEndpointConfig ep0config = { _usb_ep0out, 0x40, 0x40, - EPR_EP_TYPE_CONTROL | EPR_STAT_TX_STALL | EPR_STAT_RX_VALID, + EPR_EP_TYPE_CONTROL | EPR_STAT_TX_NAK | EPR_STAT_RX_VALID, 0x40, 0x80 }; @@ -71,6 +71,58 @@ static const USBEndpointConfig ep0config = { /* Driver local functions. */ /*===========================================================================*/ +/** + * @brief Copies a packet from memory into a packet buffer. + * + * @param[in] ep endpoint number + * @param[in] buf buffer where to fetch the endpoint data + * @param[in] n maximum number of bytes to copy + */ +static void write_packet(usbep_t ep, const uint8_t *buf, size_t n){ + uint32_t *pmap; + stm32_usb_descriptor_t *udp; + size_t count; + + udp = USB_GET_DESCRIPTOR(ep); + pmap = USB_ADDR2PTR(udp->TXADDR); + udp->TXCOUNT = n; + count = (n + 1) / 2; + while (count) { + *pmap++ = *(uint16_t *)buf; + buf += 2; + count--; + } + EPR_SET_STAT_TX(ep, EPR_STAT_TX_VALID); +} + +/** + * @brief Copies a packet from a packet buffer into memory. + * + * @param[in] ep endpoint number + * @param[in] buf buffer where to copy the endpoint data + * @param[in] n maximum number of bytes to copy + * @return The packet size. + * @retval 0 Special case, zero sized packet. + */ +static size_t read_packet(usbep_t ep, uint8_t *buf, size_t n){ + uint32_t *pmap; + stm32_usb_descriptor_t *udp; + size_t count; + + udp = USB_GET_DESCRIPTOR(ep); + pmap = USB_ADDR2PTR(udp->RXADDR); + count = udp->RXCOUNT & RXCOUNT_COUNT_MASK; + if (n > count) + n = count; + count = (n + 1) / 2; + while (count) { + *(uint16_t *)buf = (uint16_t)*pmap++; + buf += 2; + count--; + } + return n; +} + /*===========================================================================*/ /* Driver interrupt handlers. */ /*===========================================================================*/ @@ -95,6 +147,7 @@ CH_IRQ_HANDLER(USB_HP_IRQHandler) { */ CH_IRQ_HANDLER(USB_LP_IRQHandler) { uint32_t istr; + size_t n; USBDriver *usbp = &USBD1; CH_IRQ_PROLOGUE(); @@ -104,15 +157,15 @@ CH_IRQ_HANDLER(USB_LP_IRQHandler) { /* USB bus reset condition handling.*/ if (istr & ISTR_RESET) { _usb_reset(usbp); - if (usbp->usb_config->uc_event_cb) - usbp->usb_config->uc_event_cb(usbp, USB_EVENT_RESET); + if (usbp->config->event_cb) + usbp->config->event_cb(usbp, USB_EVENT_RESET); STM32_USB->ISTR = ~ISTR_RESET; } /* SOF handling.*/ if (istr & ISTR_SOF) { - if (usbp->usb_config->uc_sof_cb) - usbp->usb_config->uc_sof_cb(usbp); + if (usbp->config->sof_cb) + usbp->config->sof_cb(usbp); STM32_USB->ISTR = ~ISTR_SOF; } @@ -120,19 +173,55 @@ CH_IRQ_HANDLER(USB_LP_IRQHandler) { while (istr & ISTR_CTR) { uint32_t ep; uint32_t epr = STM32_USB->EPR[ep = istr & ISTR_EP_ID_MASK]; - const USBEndpointConfig *epcp = usbp->usb_ep[ep]->uep_config; + const USBEndpointConfig *epcp = usbp->ep[ep]->config; if (epr & EPR_CTR_TX) { /* IN endpoint, transmission.*/ EPR_CLEAR_CTR_TX(ep); - if (epcp->uepc_in_cb) - epcp->uepc_in_cb(usbp, ep); + n = USB_GET_DESCRIPTOR(ep)->TXCOUNT; + usbp->ep[ep]->txbuf += n; + usbp->ep[ep]->txcnt += n; + usbp->ep[ep]->txsize -= n; + if (usbp->ep[ep]->txsize > 0) { + /* Transfer not completed, there are more packets to send.*/ + if (usbp->ep[ep]->txsize > epcp->in_maxsize) + n = epcp->in_maxsize; + else + n = usbp->ep[ep]->txsize; + write_packet(ep, usbp->ep[ep]->txbuf, n); + } + else { + /* Transfer completed, invoking the callback, if defined.*/ + if (epcp->in_cb) + epcp->in_cb(usbp, ep); + } } if (epr & EPR_CTR_RX) { - /* OUT endpoint, receive.*/ EPR_CLEAR_CTR_RX(ep); - if (epcp->uepc_out_cb) - epcp->uepc_out_cb(usbp, ep); + /* OUT endpoint, receive.*/ + if ((epr & EPR_SETUP) && (ep == 0)) { + /* Special case, setup packet for EP0, enforcing a reset of the + EP0 state machine for robustness.*/ + usbp->ep0state = USB_EP0_WAITING_SETUP; + read_packet(0, usbp->setup, 8); + epcp->out_cb(usbp, ep); + } + else { + n = read_packet(ep, usbp->ep[ep]->rxbuf, usbp->ep[ep]->rxsize); + usbp->ep[ep]->rxbuf += n; + usbp->ep[ep]->rxcnt += n; + usbp->ep[ep]->rxsize -= n; + usbp->ep[ep]->rxpkts -= 1; + if (usbp->ep[ep]->rxpkts > 0) { + /* Transfer not completed, there are more packets to receive.*/ + EPR_SET_STAT_RX(ep, EPR_STAT_RX_VALID); + } + else { + /* Transfer completed, invoking the callback, if defined.*/ + if (epcp->out_cb) + epcp->out_cb(usbp, ep); + } + } } istr = STM32_USB->ISTR; } @@ -169,7 +258,7 @@ void usb_lld_init(void) { */ void usb_lld_start(USBDriver *usbp) { - if (usbp->usb_state == USB_STOP) { + if (usbp->state == USB_STOP) { /* Clock activation.*/ #if STM32_USB_USE_USB1 if (&USBD1 == usbp) { @@ -202,7 +291,7 @@ void usb_lld_start(USBDriver *usbp) { void usb_lld_stop(USBDriver *usbp) { /* If in ready state then disables the USB clock.*/ - if (usbp->usb_state == USB_STOP) { + if (usbp->state == USB_STOP) { #if STM32_ADC_USE_ADC1 if (&USBD1 == usbp) { NVICDisableVector(USB_HP_CAN1_TX_IRQn); @@ -234,14 +323,14 @@ void usb_lld_reset(USBDriver *usbp) { /*CNTR_WKUPM | CNTR_ERRM | CNTR_PMAOVRM |*/ CNTR_CTRM; /* The SOF interrupt is only enabled if a callback is defined for this service because it is an high rate source.*/ - if (usbp->usb_config->uc_sof_cb != NULL) + if (usbp->config->sof_cb != NULL) cntr |= CNTR_SOFM; STM32_USB->CNTR = cntr; /* EP0 initialization.*/ memset(&ep0state, 0, sizeof ep0state); - ep0state.uep_config = &ep0config; - usbp->usb_ep[0] = &ep0state; + ep0state.config = &ep0config; + usbp->ep[0] = &ep0state; usb_lld_init_endpoint(usbp, 0); } @@ -249,14 +338,12 @@ void usb_lld_reset(USBDriver *usbp) { * @brief Sets the USB address. * * @param[in] usbp pointer to the @p USBDriver object - * @param[in] addr the USB address * * @notapi */ -void usb_lld_set_address(USBDriver *usbp, uint8_t addr) { +void usb_lld_set_address(USBDriver *usbp) { - (void)usbp; - STM32_USB->DADDR = (uint32_t)addr | DADDR_EF; + STM32_USB->DADDR = (uint32_t)(usbp->address) | DADDR_EF; } /** @@ -270,23 +357,23 @@ void usb_lld_set_address(USBDriver *usbp, uint8_t addr) { void usb_lld_init_endpoint(USBDriver *usbp, usbep_t ep) { uint16_t nblocks; stm32_usb_descriptor_t *dp; - const USBEndpointConfig *epcp = usbp->usb_ep[ep]->uep_config; + const USBEndpointConfig *epcp = usbp->ep[ep]->config; /* EPxR register setup.*/ - EPR_SET(ep, epcp->uepc_epr | ep); - EPR_TOGGLE(ep, epcp->uepc_epr); + EPR_SET(ep, epcp->epr | ep); + EPR_TOGGLE(ep, epcp->epr); /* Endpoint size and address initialization.*/ - if (epcp->uepc_out_maxsize > 62) - nblocks = (((((epcp->uepc_out_maxsize - 1) | 0x1f) + 1) / 32) << 10) | + if (epcp->out_maxsize > 62) + nblocks = (((((epcp->out_maxsize - 1) | 0x1f) + 1) / 32) << 10) | 0x8000; else - nblocks = ((((epcp->uepc_out_maxsize - 1) | 1) + 1) / 2) << 10; + nblocks = ((((epcp->out_maxsize - 1) | 1) + 1) / 2) << 10; dp = USB_GET_DESCRIPTOR(ep); dp->TXCOUNT = 0; dp->RXCOUNT = nblocks; - dp->TXADDR = epcp->uepc_inaddr; - dp->RXADDR = epcp->uepc_outaddr; + dp->TXADDR = epcp->inaddr; + dp->RXADDR = epcp->outaddr; } /** @@ -379,7 +466,7 @@ size_t usb_lld_get_writeable(USBDriver *usbp, usbep_t ep) { if ((STM32_USB->EPR[ep] & EPR_STAT_TX_MASK) != EPR_STAT_TX_NAK) return 0; - return (size_t)usbp->usb_ep[ep]->uep_config->uepc_in_maxsize; + return (size_t)usbp->ep[ep]->config->in_maxsize; } /** @@ -421,27 +508,6 @@ size_t usb_lld_write(USBDriver *usbp, usbep_t ep, return n; } -/** - * @brief Returns the status of an IN endpoint. - * - * @param[in] usbp pointer to the @p USBDriver object - * @param[in] ep endpoint number - * - * @notapi - */ -usbepstatus_t usb_lld_get_status_in(USBDriver *usbp, usbep_t ep) { - - (void)usbp; - switch (STM32_USB->EPR[ep] & EPR_STAT_TX_MASK) { - case EPR_STAT_TX_DIS: - return EP_STATUS_DISABLED; - case EPR_STAT_TX_STALL: - return EP_STATUS_STALLED; - default: - return EP_STATUS_ACTIVE; - } -} - /** * @brief Returns the status of an OUT endpoint. * @@ -464,17 +530,71 @@ usbepstatus_t usb_lld_get_status_out(USBDriver *usbp, usbep_t ep) { } /** - * @brief Brings an IN endpoint in the stalled state. + * @brief Returns the status of an IN endpoint. * * @param[in] usbp pointer to the @p USBDriver object * @param[in] ep endpoint number * * @notapi */ -void usb_lld_stall_in(USBDriver *usbp, usbep_t ep) { +usbepstatus_t usb_lld_get_status_in(USBDriver *usbp, usbep_t ep) { (void)usbp; - EPR_SET_STAT_TX(ep, EPR_STAT_TX_STALL); + switch (STM32_USB->EPR[ep] & EPR_STAT_TX_MASK) { + case EPR_STAT_TX_DIS: + return EP_STATUS_DISABLED; + case EPR_STAT_TX_STALL: + return EP_STATUS_STALLED; + default: + return EP_STATUS_ACTIVE; + } +} + +/** + * @brief Starts a receive operation on an OUT endpoint. + * + * @param[in] usbp pointer to the @p USBDriver object + * @param[in] ep endpoint number + * @param[out] buf buffer where to copy the endpoint data + * @param[in] n maximum number of bytes to copy in the buffer + * + * @notapi + */ +void usb_lld_start_out(USBDriver *usbp, usbep_t ep, + uint8_t *buf, size_t n) { + USBEndpointState *uesp = usbp->ep[ep]; + + uesp->rxbuf = buf; + uesp->rxsize = n; + uesp->rxcnt = 0; + if (uesp->rxsize == 0) /* Special case for zero sized packets.*/ + uesp->rxpkts = 1; + else + uesp->rxpkts = (uint16_t)((n + uesp->config->out_maxsize - 1) / + uesp->config->out_maxsize); + EPR_SET_STAT_RX(ep, EPR_STAT_RX_VALID); +} + +/** + * @brief Starts a transmit operation on an IN endpoint. + * + * @param[in] usbp pointer to the @p USBDriver object + * @param[in] ep endpoint number + * @param[in] buf buffer where to fetch the endpoint data + * @param[in] n maximum number of bytes to copy + * + * @notapi + */ +void usb_lld_start_in(USBDriver *usbp, usbep_t ep, + const uint8_t *buf, size_t n) { + USBEndpointState *uesp = usbp->ep[ep]; + + uesp->txbuf = buf; + uesp->txsize = n; + uesp->txcnt = 0; + if (n > (size_t)uesp->config->in_maxsize) + n = (size_t)uesp->config->in_maxsize; + write_packet(ep, buf, n); } /** @@ -492,21 +612,17 @@ void usb_lld_stall_out(USBDriver *usbp, usbep_t ep) { } /** - * @brief Brings an IN endpoint in the active state. + * @brief Brings an IN endpoint in the stalled state. * * @param[in] usbp pointer to the @p USBDriver object * @param[in] ep endpoint number * * @notapi */ -void usb_lld_clear_in(USBDriver *usbp, usbep_t ep) { +void usb_lld_stall_in(USBDriver *usbp, usbep_t ep) { (void)usbp; - - /* Makes sure to not put to NAK an endpoint that is already - transferring.*/ - if ((STM32_USB->EPR[ep] & EPR_STAT_TX_MASK) != EPR_STAT_TX_VALID) - EPR_SET_STAT_TX(ep, EPR_STAT_TX_NAK); + EPR_SET_STAT_TX(ep, EPR_STAT_TX_STALL); } /** @@ -527,6 +643,24 @@ void usb_lld_clear_out(USBDriver *usbp, usbep_t ep) { EPR_SET_STAT_TX(ep, EPR_STAT_RX_NAK); } +/** + * @brief Brings an IN endpoint in the active state. + * + * @param[in] usbp pointer to the @p USBDriver object + * @param[in] ep endpoint number + * + * @notapi + */ +void usb_lld_clear_in(USBDriver *usbp, usbep_t ep) { + + (void)usbp; + + /* Makes sure to not put to NAK an endpoint that is already + transferring.*/ + if ((STM32_USB->EPR[ep] & EPR_STAT_TX_MASK) != EPR_STAT_TX_VALID) + EPR_SET_STAT_TX(ep, EPR_STAT_TX_NAK); +} + #endif /* HAL_USE_USB */ /** @} */ diff --git a/os/hal/platforms/STM32/usb_lld.h b/os/hal/platforms/STM32/usb_lld.h index e21bbecd2..7947e22fc 100644 --- a/os/hal/platforms/STM32/usb_lld.h +++ b/os/hal/platforms/STM32/usb_lld.h @@ -41,6 +41,11 @@ */ #define USB_MAX_ENDPOINTS USB_ENDOPOINTS_NUMBER +/** + * @brief This device requires the address change after the status packet. + */ +#define USB_SET_ADDRESS_MODE USB_LATE_SET_ADDRESS + /*===========================================================================*/ /* Driver pre-compile time settings. */ /*===========================================================================*/ @@ -89,40 +94,40 @@ /*===========================================================================*/ /** - * @brief Type of an USB Endpoint configuration structure. + * @brief Type of an USB endpoint configuration structure. * @note Platform specific restrictions may apply to endpoints. */ typedef struct { /** * @brief IN endpoint notification callback. */ - usbepcallback_t uepc_in_cb; + usbepcallback_t in_cb; /** * @brief OUT endpoint notification callback. */ - usbepcallback_t uepc_out_cb; + usbepcallback_t out_cb; /** * @brief IN endpoint maximum packet size. */ - uint16_t uepc_in_maxsize; + uint16_t in_maxsize; /** * @brief OUT endpoint maximum packet size. */ - uint16_t uepc_out_maxsize; + uint16_t out_maxsize; /* End of the mandatory fields.*/ /** * @brief EPxR register initialization value. * @note Do not specify the EA field, leave it to zero. */ - uint16_t uepc_epr; + uint16_t epr; /** * @brief Endpoint IN buffer address as offset in the PMA. */ - uint16_t uepc_inaddr; + uint16_t inaddr; /** * @brief Endpoint OUT buffer address as offset in the PMA. */ - uint16_t uepc_outaddr; + uint16_t outaddr; } USBEndpointConfig; @@ -133,39 +138,44 @@ typedef struct { /** * @brief Configuration associated to the endpoint. */ - const USBEndpointConfig *uep_config; - /** - * @brief Pointer to the transmission buffer. - */ - const uint8_t *uep_txbuf; - /** - * @brief Pointer to the receive buffer. - */ - uint8_t *uep_rxbuf; - /** - * @brief Requested transmit transfer size. - */ - size_t uep_txsize; - /** - * @brief Requested receive transfer size. - */ - size_t uep_rxsize; - /** - * @brief Transmitted bytes so far. - */ - size_t uep_txcnt; - /** - * @brief Received bytes so far. - */ - size_t uep_rxcnt; + const USBEndpointConfig *config; /** * @brief @p TRUE if transmitting else @p FALSE. */ - uint8_t uep_transmitting; + uint8_t transmitting; /** * @brief @p TRUE if receiving else @p FALSE. */ - uint8_t uep_receiving; + uint8_t receiving; + /* End of the mandatory fields.*/ + /** + * @brief Number of packets to receive. + */ + uint16_t rxpkts; + /** + * @brief Pointer to the transmission buffer. + */ + const uint8_t *txbuf; + /** + * @brief Pointer to the receive buffer. + */ + uint8_t *rxbuf; + /** + * @brief Requested transmit transfer size. + */ + size_t txsize; + /** + * @brief Requested receive transfer size. + */ + size_t rxsize; + /** + * @brief Transmitted bytes so far. + */ + size_t txcnt; + /** + * @brief Received bytes so far. + */ + size_t rxcnt; } USBEndpointState; /** @@ -176,22 +186,22 @@ typedef struct { * @brief USB events callback. * @details This callback is invoked when an USB driver event is registered. */ - usbeventcb_t uc_event_cb; + usbeventcb_t event_cb; /** * @brief Device GET_DESCRIPTOR request callback. * @note This callback is mandatory and cannot be set to @p NULL. */ - usbgetdescriptor_t uc_get_descriptor_cb; + usbgetdescriptor_t get_descriptor_cb; /** * @brief Requests hook callback. * @details This hook allows to be notified of standard requests or to * handle non standard requests. */ - usbreqhandler_t uc_requests_hook_cb; + usbreqhandler_t requests_hook_cb; /** * @brief Start Of Frame callback. */ - usbcallback_t uc_sof_cb; + usbcallback_t sof_cb; /* End of the mandatory fields.*/ } USBConfig; @@ -202,60 +212,52 @@ struct USBDriver { /** * @brief Driver state. */ - usbstate_t usb_state; + usbstate_t state; /** * @brief Current configuration data. */ - const USBConfig *usb_config; + const USBConfig *config; /** * @brief Field available to user, it can be used to associate an * application-defined handler to the USB driver. */ - void *usb_param; + void *param; /** * @brief Active endpoints configurations. */ - USBEndpointState *usb_ep[USB_MAX_ENDPOINTS + 1]; + USBEndpointState *ep[USB_MAX_ENDPOINTS + 1]; /** * @brief Endpoint 0 state. */ - usbep0state_t usb_ep0state; + usbep0state_t ep0state; /** * @brief Next position in the buffer to be transferred through endpoint 0. */ - uint8_t *usb_ep0next; + uint8_t *ep0next; /** - * @brief Maximum number of bytes to be tranferred through endpoint 0. + * @brief Maximum number of bytes to be transferred through endpoint 0. */ - size_t usb_ep0max; + size_t ep0max; /** - * @brief Number of bytes yet to be tranferred through endpoint 0. + * @brief Number of bytes yet to be transferred through endpoint 0. */ - size_t usb_ep0n; - /** - * @brief Size of the last packet transferred through endpoint 0. - */ - size_t usb_ep0lastsize; - /** - * @brief Endpoint 0 end transaction callback. - */ - usbcallback_t usb_ep0endcb; + size_t ep0n; /** * @brief Setup packet buffer. */ - uint8_t usb_setup[8]; + uint8_t setup[8]; /** * @brief Current USB device status. */ - uint16_t usb_status; + uint16_t status; /** * @brief Assigned USB address. */ - uint8_t usb_address; + uint8_t address; /** * @brief Current USB device configuration. */ - uint8_t usb_configuration; + uint8_t configuration; /* End of the mandatory fields.*/ }; @@ -305,7 +307,7 @@ extern "C" { void usb_lld_start(USBDriver *usbp); void usb_lld_stop(USBDriver *usbp); void usb_lld_reset(USBDriver *usbp); - void usb_lld_set_address(USBDriver *usbp, uint8_t addr); + void usb_lld_set_address(USBDriver *usbp); void usb_lld_init_endpoint(USBDriver *usbp, usbep_t ep); void usb_lld_disable_endpoints(USBDriver *usbp); size_t usb_lld_get_readable(USBDriver *usbp, usbep_t ep); @@ -315,10 +317,14 @@ extern "C" { const uint8_t *buf, size_t n); usbepstatus_t usb_lld_get_status_in(USBDriver *usbp, usbep_t ep); usbepstatus_t usb_lld_get_status_out(USBDriver *usbp, usbep_t ep); + void usb_lld_start_out(USBDriver *usbp, usbep_t ep, + uint8_t *buf, size_t n); + void usb_lld_start_in(USBDriver *usbp, usbep_t ep, + const uint8_t *buf, size_t n); void usb_lld_stall_in(USBDriver *usbp, usbep_t ep); void usb_lld_stall_out(USBDriver *usbp, usbep_t ep); - void usb_lld_clear_in(USBDriver *usbp, usbep_t ep); void usb_lld_clear_out(USBDriver *usbp, usbep_t ep); + void usb_lld_clear_in(USBDriver *usbp, usbep_t ep); #ifdef __cplusplus } #endif diff --git a/os/hal/src/usb.c b/os/hal/src/usb.c index 3cc076443..d0db0ed5c 100644 --- a/os/hal/src/usb.c +++ b/os/hal/src/usb.c @@ -56,72 +56,18 @@ static const uint8_t halted_status[] = {0x01, 0x00}; */ void set_address(USBDriver *usbp) { - usbp->usb_address = usbp->usb_setup[2]; - usb_lld_set_address(usbp, usbp->usb_address); - if (usbp->usb_config->uc_event_cb) - usbp->usb_config->uc_event_cb(usbp, USB_EVENT_ADDRESS); - usbp->usb_state = USB_SELECTED; -} - -/** - * @brief Starts a receive phase on the endpoint zero. - * - * @param[in] usbp pointer to the @p USBDriver object - */ -static void start_rx_ep0(USBDriver *usbp) { - - if (usbp->usb_ep0n > 0) { - /* The received data cannot exceed the available amount.*/ - if (usbp->usb_ep0n > usbp->usb_ep0max) - usbp->usb_ep0n = usbp->usb_ep0max; - - /* Determines the maximum amount that can be received using a - single packet.*/ - if (usbp->usb_ep0n > usbp->usb_ep[0]->uep_config->uepc_out_maxsize) - usbp->usb_ep0lastsize = usbp->usb_ep[0]->uep_config->uepc_out_maxsize; - else - usbp->usb_ep0lastsize = usbp->usb_ep0n; - usbp->usb_ep0state = USB_EP0_RX; - } - else { - /* Sending zero sized status packet.*/ - usb_lld_write(usbp, 0, NULL, 0); - usbp->usb_ep0state = USB_EP0_SENDING_STS; - } -} - -/** - * @brief Starts a transmission phase on the endpoint zero. - * - * @param[in] usbp pointer to the @p USBDriver object - */ -static void start_tx_ep0(USBDriver *usbp) { - - if (usbp->usb_ep0n > 0) { - /* The transmitted data cannot exceed the requested amount.*/ - if (usbp->usb_ep0n > usbp->usb_ep0max) - usbp->usb_ep0n = usbp->usb_ep0max; - - /* Determines the maximum amount that can be transmitted using a - single packet.*/ - if (usbp->usb_ep0n > usbp->usb_ep[0]->uep_config->uepc_in_maxsize) - usbp->usb_ep0lastsize = usbp->usb_ep[0]->uep_config->uepc_in_maxsize; - else - usbp->usb_ep0lastsize = usbp->usb_ep0n; - - /* Starts transmission.*/ - usb_lld_write(usbp, 0, usbp->usb_ep0next, usbp->usb_ep0lastsize); - usbp->usb_ep0state = USB_EP0_TX; - } - else - usbp->usb_ep0state = USB_EP0_WAITING_STS; + usbp->address = usbp->setup[2]; + usb_lld_set_address(usbp); + if (usbp->config->event_cb) + usbp->config->event_cb(usbp, USB_EVENT_ADDRESS); + usbp->state = USB_SELECTED; } /** * @brief Standard requests handler. * @details This is the standard requests default handler, most standard * requests are handled here, the user can override the standard - * handling using the @p uc_requests_hook_cb hook in the + * handling using the @p requests_hook_cb hook in the * @p USBConfig structure. * * @param[in] usbp pointer to the @p USBDriver object @@ -133,87 +79,93 @@ static bool_t default_handler(USBDriver *usbp) { const USBDescriptor *dp; /* Decoding the request.*/ - switch (((usbp->usb_setup[0] & (USB_RTYPE_RECIPIENT_MASK | - USB_RTYPE_TYPE_MASK)) | - (usbp->usb_setup[1] << 8))) { + switch (((usbp->setup[0] & (USB_RTYPE_RECIPIENT_MASK | + USB_RTYPE_TYPE_MASK)) | + (usbp->setup[1] << 8))) { case USB_RTYPE_RECIPIENT_DEVICE | (USB_REQ_GET_STATUS << 8): /* Just returns the current status word.*/ - usbSetupTransfer(usbp, (uint8_t *)&usbp->usb_status, 2, NULL); + usbSetupTransfer(usbp, (uint8_t *)&usbp->status, 2); return TRUE; case USB_RTYPE_RECIPIENT_DEVICE | (USB_REQ_CLEAR_FEATURE << 8): /* Only the DEVICE_REMOTE_WAKEUP is handled here, any other feature number is handled as an error.*/ - if (usbp->usb_setup[2] == USB_FEATURE_DEVICE_REMOTE_WAKEUP) { - usbp->usb_status &= ~2; - usbSetupTransfer(usbp, NULL, 0, NULL); + if (usbp->setup[2] == USB_FEATURE_DEVICE_REMOTE_WAKEUP) { + usbp->status &= ~2; + usbSetupTransfer(usbp, NULL, 0); return TRUE; } return FALSE; case USB_RTYPE_RECIPIENT_DEVICE | (USB_REQ_SET_FEATURE << 8): /* Only the DEVICE_REMOTE_WAKEUP is handled here, any other feature number is handled as an error.*/ - if (usbp->usb_setup[2] == USB_FEATURE_DEVICE_REMOTE_WAKEUP) { - usbp->usb_status |= 2; - usbSetupTransfer(usbp, NULL, 0, NULL); + if (usbp->setup[2] == USB_FEATURE_DEVICE_REMOTE_WAKEUP) { + usbp->status |= 2; + usbSetupTransfer(usbp, NULL, 0); return TRUE; } return FALSE; case USB_RTYPE_RECIPIENT_DEVICE | (USB_REQ_SET_ADDRESS << 8): - /* The handling is posponed to after the status phase in order to allow - the proper completion of the transaction.*/ - usbSetupTransfer(usbp, NULL, 0, set_address); + /* The SET_ADDRESS handling can be performed here or postponed after + the status packed depending on the USB_SET_ADDRESS_MODE low + driver setting.*/ +#if USB_SET_ADDRESS_MODE == USB_EARLY_SET_ADDRESS + if ((usbp->setup[0] == USB_RTYPE_RECIPIENT_DEVICE) && + (usbp->setup[1] == USB_REQ_SET_ADDRESS)) + set_address(usbp); +#endif + usbSetupTransfer(usbp, NULL, 0); return TRUE; case USB_RTYPE_RECIPIENT_DEVICE | (USB_REQ_GET_DESCRIPTOR << 8): /* Handling descriptor requests from the host.*/ - dp = usbp->usb_config->uc_get_descriptor_cb( - usbp, usbp->usb_setup[3], usbp->usb_setup[2], - usb_lld_fetch_word(&usbp->usb_setup[4])); + dp = usbp->config->get_descriptor_cb( + usbp, usbp->setup[3], usbp->setup[2], + usb_lld_fetch_word(&usbp->setup[4])); if (dp == NULL) return FALSE; - usbSetupTransfer(usbp, (uint8_t *)dp->ud_string, dp->ud_size, NULL); + usbSetupTransfer(usbp, (uint8_t *)dp->ud_string, dp->ud_size); return TRUE; case USB_RTYPE_RECIPIENT_DEVICE | (USB_REQ_GET_CONFIGURATION << 8): /* Returning the last selected configuration.*/ - usbSetupTransfer(usbp, &usbp->usb_configuration, 1, NULL); + usbSetupTransfer(usbp, &usbp->configuration, 1); return TRUE; case USB_RTYPE_RECIPIENT_DEVICE | (USB_REQ_SET_CONFIGURATION << 8): /* Handling configuration selection from the host.*/ - usbp->usb_configuration = usbp->usb_setup[2]; - if (usbp->usb_configuration == 0) - usbp->usb_state = USB_SELECTED; + usbp->configuration = usbp->setup[2]; + if (usbp->configuration == 0) + usbp->state = USB_SELECTED; else - usbp->usb_state = USB_ACTIVE; - if (usbp->usb_config->uc_event_cb) - usbp->usb_config->uc_event_cb(usbp, USB_EVENT_CONFIGURED); - usbSetupTransfer(usbp, NULL, 0, NULL); + usbp->state = USB_ACTIVE; + if (usbp->config->event_cb) + usbp->config->event_cb(usbp, USB_EVENT_CONFIGURED); + usbSetupTransfer(usbp, NULL, 0); return TRUE; case USB_RTYPE_RECIPIENT_INTERFACE | (USB_REQ_GET_STATUS << 8): case USB_RTYPE_RECIPIENT_ENDPOINT | (USB_REQ_SYNCH_FRAME << 8): /* Just sending two zero bytes, the application can change the behavior using a hook..*/ - usbSetupTransfer(usbp, (uint8_t *)zero_status, 2, NULL); + usbSetupTransfer(usbp, (uint8_t *)zero_status, 2); return TRUE; case USB_RTYPE_RECIPIENT_ENDPOINT | (USB_REQ_GET_STATUS << 8): /* Sending the EP status.*/ - if (usbp->usb_setup[4] & 0x80) { - switch (usb_lld_get_status_in(usbp, usbp->usb_setup[4] & 0x0F)) { + if (usbp->setup[4] & 0x80) { + switch (usb_lld_get_status_in(usbp, usbp->setup[4] & 0x0F)) { case EP_STATUS_STALLED: - usbSetupTransfer(usbp, (uint8_t *)halted_status, 2, NULL); + usbSetupTransfer(usbp, (uint8_t *)halted_status, 2); return TRUE; case EP_STATUS_ACTIVE: - usbSetupTransfer(usbp, (uint8_t *)active_status, 2, NULL); + usbSetupTransfer(usbp, (uint8_t *)active_status, 2); return TRUE; default: return FALSE; } } else { - switch (usb_lld_get_status_out(usbp, usbp->usb_setup[4] & 0x0F)) { + switch (usb_lld_get_status_out(usbp, usbp->setup[4] & 0x0F)) { case EP_STATUS_STALLED: - usbSetupTransfer(usbp, (uint8_t *)halted_status, 2, NULL); + usbSetupTransfer(usbp, (uint8_t *)halted_status, 2); return TRUE; case EP_STATUS_ACTIVE: - usbSetupTransfer(usbp, (uint8_t *)active_status, 2, NULL); + usbSetupTransfer(usbp, (uint8_t *)active_status, 2); return TRUE; default: return FALSE; @@ -221,29 +173,29 @@ static bool_t default_handler(USBDriver *usbp) { } case USB_RTYPE_RECIPIENT_ENDPOINT | (USB_REQ_CLEAR_FEATURE << 8): /* Only ENDPOINT_HALT is handled as feature.*/ - if (usbp->usb_setup[2] != USB_FEATURE_ENDPOINT_HALT) + if (usbp->setup[2] != USB_FEATURE_ENDPOINT_HALT) return FALSE; /* Clearing the EP status, not valid for EP0, it is ignored in that case.*/ - if ((usbp->usb_setup[4] & 0x0F) > 0) { - if (usbp->usb_setup[4] & 0x80) - usb_lld_clear_in(usbp, usbp->usb_setup[4] & 0x0F); + if ((usbp->setup[4] & 0x0F) > 0) { + if (usbp->setup[4] & 0x80) + usb_lld_clear_in(usbp, usbp->setup[4] & 0x0F); else - usb_lld_clear_out(usbp, usbp->usb_setup[4] & 0x0F); + usb_lld_clear_out(usbp, usbp->setup[4] & 0x0F); } - usbSetupTransfer(usbp, NULL, 0, NULL); + usbSetupTransfer(usbp, NULL, 0); return TRUE; case USB_RTYPE_RECIPIENT_ENDPOINT | (USB_REQ_SET_FEATURE << 8): /* Only ENDPOINT_HALT is handled as feature.*/ - if (usbp->usb_setup[2] != USB_FEATURE_ENDPOINT_HALT) + if (usbp->setup[2] != USB_FEATURE_ENDPOINT_HALT) return FALSE; /* Stalling the EP, not valid for EP0, it is ignored in that case.*/ - if ((usbp->usb_setup[4] & 0x0F) > 0) { - if (usbp->usb_setup[4] & 0x80) - usb_lld_stall_in(usbp, usbp->usb_setup[4] & 0x0F); + if ((usbp->setup[4] & 0x0F) > 0) { + if (usbp->setup[4] & 0x80) + usb_lld_stall_in(usbp, usbp->setup[4] & 0x0F); else - usb_lld_stall_out(usbp, usbp->usb_setup[4] & 0x0F); + usb_lld_stall_out(usbp, usbp->setup[4] & 0x0F); } - usbSetupTransfer(usbp, NULL, 0, NULL); + usbSetupTransfer(usbp, NULL, 0); return TRUE; case USB_RTYPE_RECIPIENT_DEVICE | (USB_REQ_SET_DESCRIPTOR << 8): case USB_RTYPE_RECIPIENT_INTERFACE | (USB_REQ_CLEAR_FEATURE << 8): @@ -282,9 +234,9 @@ void usbInit(void) { */ void usbObjectInit(USBDriver *usbp) { - usbp->usb_state = USB_STOP; - usbp->usb_config = NULL; - usbp->usb_param = NULL; + usbp->state = USB_STOP; + usbp->config = NULL; + usbp->param = NULL; } /** @@ -301,13 +253,13 @@ void usbStart(USBDriver *usbp, const USBConfig *config) { chDbgCheck((usbp != NULL) && (config != NULL), "usbStart"); chSysLock(); - chDbgAssert((usbp->usb_state == USB_STOP) || (usbp->usb_state == USB_READY), + chDbgAssert((usbp->state == USB_STOP) || (usbp->state == USB_READY), "usbStart(), #1", "invalid state"); - usbp->usb_config = config; + usbp->config = config; for (i = 0; i <= USB_MAX_ENDPOINTS; i++) - usbp->usb_ep[i] = NULL; + usbp->ep[i] = NULL; usb_lld_start(usbp); - usbp->usb_state = USB_READY; + usbp->state = USB_READY; chSysUnlock(); } @@ -323,11 +275,10 @@ void usbStop(USBDriver *usbp) { chDbgCheck(usbp != NULL, "usbStop"); chSysLock(); - chDbgAssert((usbp->usb_state == USB_STOP) || (usbp->usb_state == USB_READY), - "usbStop(), #1", - "invalid state"); + chDbgAssert((usbp->state == USB_STOP) || (usbp->state == USB_READY), + "usbStop(), #1", "invalid state"); usb_lld_stop(usbp); - usbp->usb_state = USB_STOP; + usbp->state = USB_STOP; chSysUnlock(); } @@ -348,15 +299,15 @@ void usbStop(USBDriver *usbp) { void usbInitEndpointI(USBDriver *usbp, usbep_t ep, USBEndpointState *epp, const USBEndpointConfig *epcp) { - chDbgAssert(usbp->usb_state == USB_ACTIVE, + chDbgAssert(usbp->state == USB_ACTIVE, "usbEnableEndpointI(), #1", "invalid state"); - chDbgAssert(usbp->usb_ep[ep] != NULL, + chDbgAssert(usbp->ep[ep] != NULL, "usbEnableEndpointI(), #2", "already initialized"); /* Logically enabling the endpoint in the USBDriver structure.*/ memset(epp, 0, sizeof(USBEndpointState)); - epp->uep_config = epcp; - usbp->usb_ep[ep] = epp; + epp->config = epcp; + usbp->ep[ep] = epp; /* Low level endpoint activation.*/ usb_lld_init_endpoint(usbp, ep); @@ -376,16 +327,100 @@ void usbInitEndpointI(USBDriver *usbp, usbep_t ep, USBEndpointState *epp, void usbDisableEndpointsI(USBDriver *usbp) { unsigned i; - chDbgAssert(usbp->usb_state == USB_SELECTED, + chDbgAssert(usbp->state == USB_SELECTED, "usbDisableEndpointsI(), #1", "invalid state"); for (i = 1; i <= USB_MAX_ENDPOINTS; i++) - usbp->usb_ep[i] = NULL; + usbp->ep[i] = NULL; /* Low level endpoints deactivation.*/ usb_lld_disable_endpoints(usbp); } +/** + * @brief Starts a receive operation on an OUT endpoint. + * + * @param[in] usbp pointer to the @p USBDriver object + * @param[in] ep endpoint number + * @param[out] buf buffer where to copy the endpoint data + * @param[in] n maximum number of bytes to copy in the buffer + * @return The operation status. + * @retval FALSE Receive operation started. + * @retval TRUE Endpoint already receiving. + * + * @iclass + */ +bool_t usbStartReceiveI(USBDriver *usbp, usbep_t ep, + uint8_t *buf, size_t n) { + + if (usbp->ep[ep]->receiving) + return TRUE; + usbp->ep[ep]->receiving = TRUE; + usb_lld_start_out(usbp, ep, buf, n); + return FALSE; +} + +/** + * @brief Starts a transmit operation on an IN endpoint. + * + * @param[in] usbp pointer to the @p USBDriver object + * @param[in] ep endpoint number + * @param[in] buf buffer where to fetch the endpoint data + * @param[in] n maximum number of bytes to copy + * @return The operation status. + * @retval FALSE Transmit operation started. + * @retval TRUE Endpoint already transmitting. + * + * @iclass + */ +bool_t usbStartTransmitI(USBDriver *usbp, usbep_t ep, + const uint8_t *buf, size_t n) { + + if (usbp->ep[ep]->transmitting) + return TRUE; + usbp->ep[ep]->transmitting = TRUE; + usb_lld_start_in(usbp, ep, buf, n); + return FALSE; +} + +/** + * @brief Stalls an OUT endpoint. + * + * @param[in] usbp pointer to the @p USBDriver object + * @param[in] ep endpoint number + * @return The operation status. + * @retval FALSE Endpoint stalled. + * @retval TRUE The endpoint was within a transaction, not stalled. + * + * @iclass + */ +bool_t usbStallReceiveI(USBDriver *usbp, usbep_t ep) { + + if (usbp->ep[ep]->receiving) + return TRUE; + usb_lld_stall_out(usbp, ep); + return FALSE; +} + +/** + * @brief Stalls an IN endpoint. + * + * @param[in] usbp pointer to the @p USBDriver object + * @param[in] ep endpoint number + * @return The operation status. + * @retval FALSE Endpoint stalled. + * @retval TRUE The endpoint was within a transaction, not stalled. + * + * @iclass + */ +bool_t usbStallTransmitI(USBDriver *usbp, usbep_t ep) { + + if (usbp->ep[ep]->transmitting) + return TRUE; + usb_lld_stall_in(usbp, ep); + return FALSE; +} + /** * @brief USB reset routine. * @@ -396,24 +431,20 @@ void usbDisableEndpointsI(USBDriver *usbp) { void _usb_reset(USBDriver *usbp) { unsigned i; - usbp->usb_state = USB_READY; - usbp->usb_status = 0; - usbp->usb_address = 0; - usbp->usb_configuration = 0; + usbp->state = USB_READY; + usbp->status = 0; + usbp->address = 0; + usbp->configuration = 0; /* Invalidates all endpoints into the USBDriver structure.*/ for (i = 0; i <= USB_MAX_ENDPOINTS; i++) - usbp->usb_ep[i] = NULL; + usbp->ep[i] = NULL; /* EP0 state machine initialization.*/ - usbp->usb_ep0state = USB_EP0_WAITING_SETUP; + usbp->ep0state = USB_EP0_WAITING_SETUP; /* Low level reset.*/ usb_lld_reset(usbp); - - /* Endpoint zero initialization.*/ -/* usbp->usb_ep[0].uep_config = &usb_lld_ep0config; - usb_lld_init_endpoint(usbp, 0, &usb_lld_ep0config);*/ } /** @@ -427,33 +458,30 @@ void _usb_reset(USBDriver *usbp) { * @notapi */ void _usb_ep0in(USBDriver *usbp, usbep_t ep) { + size_t max; (void)ep; - switch (usbp->usb_ep0state) { + switch (usbp->ep0state) { case USB_EP0_TX: - usbp->usb_ep0next += usbp->usb_ep0lastsize; - usbp->usb_ep0max -= usbp->usb_ep0lastsize; - usbp->usb_ep0n -= usbp->usb_ep0lastsize; - - /* The final condition is when the requested size has been transmitted or - when a packet has been sent with size less than the maximum packet - size.*/ - if ((usbp->usb_ep0max == 0) || - (usbp->usb_ep0lastsize < usbp->usb_ep[0]->uep_config->uepc_in_maxsize)) - usbp->usb_ep0state = USB_EP0_WAITING_STS; - else { - usbp->usb_ep0lastsize = - usbp->usb_ep0n > usbp->usb_ep[0]->uep_config->uepc_in_maxsize ? - usbp->usb_ep[0]->uep_config->uepc_in_maxsize : - usbp->usb_ep0n; - usb_lld_write(usbp, 0, usbp->usb_ep0next, usbp->usb_ep0lastsize); - } + max = usb_lld_fetch_word(&usbp->setup[6]); + /* If the transmitted size is less than the requested size and it is a + multiple of the maximum packet size then a zero size packet must be + transmitted.*/ + if ((usbp->ep0n < max) && + ((usbp->ep0n % usbp->ep[0]->config->in_maxsize) == 0)) { + usb_lld_start_in(usbp, 0, NULL, 0); + return; + } + usbp->ep0state = USB_EP0_WAITING_STS; + usb_lld_start_out(usbp, 0, NULL, 0); return; case USB_EP0_SENDING_STS: - if (usbp->usb_ep0endcb) - usbp->usb_ep0endcb(usbp); - - usbp->usb_ep0state = USB_EP0_WAITING_SETUP; +#if USB_SET_ADDRESS_MODE == USB_LATE_SET_ADDRESS + if ((usbp->setup[0] == USB_RTYPE_RECIPIENT_DEVICE) && + (usbp->setup[1] == USB_REQ_SET_ADDRESS)) + set_address(usbp); +#endif + usbp->ep0state = USB_EP0_WAITING_SETUP; return; default: ; @@ -461,9 +489,9 @@ void _usb_ep0in(USBDriver *usbp, usbep_t ep) { /* Error response.*/ usb_lld_stall_in(usbp, 0); usb_lld_stall_out(usbp, 0); - if (usbp->usb_config->uc_event_cb) - usbp->usb_config->uc_event_cb(usbp, USB_EVENT_STALLED); - usbp->usb_ep0state = USB_EP0_WAITING_SETUP; + if (usbp->config->event_cb) + usbp->config->event_cb(usbp, USB_EVENT_STALLED); + usbp->ep0state = USB_EP0_WAITING_SETUP; } /** @@ -477,62 +505,67 @@ void _usb_ep0in(USBDriver *usbp, usbep_t ep) { * @notapi */ void _usb_ep0out(USBDriver *usbp, usbep_t ep) { - size_t n, size; - uint8_t buf[1]; + size_t n, max; (void)ep; - switch (usbp->usb_ep0state) { + switch (usbp->ep0state) { case USB_EP0_WAITING_SETUP: - /* SETUP packet handling.*/ - n = usb_lld_read(usbp, 0, usbp->usb_setup, 8); - if (n != 8) - break; - - /* First verify if the application has an handler installed for this + /* SETUP packet handling. + First verify if the application has an handler installed for this request.*/ - if (!(usbp->usb_config->uc_requests_hook_cb) || - !(usbp->usb_config->uc_requests_hook_cb(usbp))) { + if (!(usbp->config->requests_hook_cb) || + !(usbp->config->requests_hook_cb(usbp))) { /* Invoking the default handler, if this fails then stalls the endpoint zero as error.*/ - if (((usbp->usb_setup[0] & USB_RTYPE_TYPE_MASK) != USB_RTYPE_TYPE_STD) || + if (((usbp->setup[0] & USB_RTYPE_TYPE_MASK) != USB_RTYPE_TYPE_STD) || !default_handler(usbp)) break; } /* Transfer preparation. The request handler must have populated - correctly the fields usb_ep0next, usb_ep0n and usb_ep0endcb using + correctly the fields ep0next, ep0n and ep0endcb using the macro usbSetupTransfer().*/ - usbp->usb_ep0max = usb_lld_fetch_word(&usbp->usb_setup[6]); - if ((usbp->usb_setup[0] & USB_RTYPE_DIR_MASK) == USB_RTYPE_DIR_DEV2HOST) - start_tx_ep0(usbp); - else - start_rx_ep0(usbp); + max = usb_lld_fetch_word(&usbp->setup[6]); + /* The transfer size cannot exceed the specified amount.*/ + if (usbp->ep0n > max) + usbp->ep0n = max; + if ((usbp->setup[0] & USB_RTYPE_DIR_MASK) == USB_RTYPE_DIR_DEV2HOST) { + /* IN phase.*/ + if (usbp->ep0n > 0) { + /* Starts transmission.*/ + usbp->ep0state = USB_EP0_TX; + usb_lld_start_in(usbp, 0, usbp->ep0next, usbp->ep0n); + } + else { + /* Receiving the zero sized status packet.*/ + usbp->ep0state = USB_EP0_WAITING_STS; + usb_lld_start_out(usbp, 0, NULL, 0); + } + } + else { + /* OUT phase.*/ + if (usbp->ep0n > 0) { + /* Starts reception.*/ + usbp->ep0state = USB_EP0_RX; + usb_lld_start_out(usbp, 0, usbp->ep0next, usbp->ep0n); + } + else { + /* Sending zero sized status packet.*/ + usbp->ep0state = USB_EP0_SENDING_STS; + usb_lld_start_in(usbp, 0, NULL, 0); + } + } return; case USB_EP0_RX: - /* Check for buffer overflow.*/ - n = size = usb_lld_get_readable(usbp, 0); - if (n > usbp->usb_ep0n) - n = usbp->usb_ep0n; - /* Fetching received data packet.*/ - n = usb_lld_read(usbp, 0, usbp->usb_ep0next, n); - if (n > usbp->usb_ep0max) - break; - usbp->usb_ep0max -= size; - usbp->usb_ep0n -= n; - usbp->usb_ep0next += n; - if (usbp->usb_ep0max == 0) { - usb_lld_write(usbp, 0, NULL, 0); - usbp->usb_ep0state = USB_EP0_SENDING_STS; - } + usbp->ep0state = USB_EP0_SENDING_STS; + usb_lld_start_in(usbp, 0, NULL, 0); return; case USB_EP0_WAITING_STS: /* STATUS received packet handling, it must be zero sized.*/ - n = usb_lld_read(usbp, 0, buf, 1); + n = usbp->ep[0]->rxsize; if (n != 0) break; - if (usbp->usb_ep0endcb) - usbp->usb_ep0endcb(usbp); - usbp->usb_ep0state = USB_EP0_WAITING_SETUP; + usbp->ep0state = USB_EP0_WAITING_SETUP; return; default: ; @@ -540,9 +573,9 @@ void _usb_ep0out(USBDriver *usbp, usbep_t ep) { /* Error response.*/ usb_lld_stall_in(usbp, 0); usb_lld_stall_out(usbp, 0); - if (usbp->usb_config->uc_event_cb) - usbp->usb_config->uc_event_cb(usbp, USB_EVENT_STALLED); - usbp->usb_ep0state = USB_EP0_WAITING_SETUP; + if (usbp->config->event_cb) + usbp->config->event_cb(usbp, USB_EVENT_STALLED); + usbp->ep0state = USB_EP0_WAITING_SETUP; } #endif /* HAL_USE_USB */ diff --git a/testhal/STM32/USB_CDC/halconf.h b/testhal/STM32/USB_CDC/halconf.h index 0a957f0b9..6700bcad5 100644 --- a/testhal/STM32/USB_CDC/halconf.h +++ b/testhal/STM32/USB_CDC/halconf.h @@ -93,7 +93,7 @@ * @brief Enables the SERIAL over USB subsystem. */ #if !defined(HAL_USE_SERIAL_USB) || defined(__DOXYGEN__) -#define HAL_USE_SERIAL_USB TRUE +#define HAL_USE_SERIAL_USB FALSE #endif /** diff --git a/testhal/STM32/USB_CDC/main.c b/testhal/STM32/USB_CDC/main.c index 70a27a8f2..697740526 100644 --- a/testhal/STM32/USB_CDC/main.c +++ b/testhal/STM32/USB_CDC/main.c @@ -32,7 +32,7 @@ /* * USB driver structure. */ -static SerialUSBDriver SDU1; +//static SerialUSBDriver SDU1; /* * USB Device Descriptor. @@ -247,6 +247,24 @@ USBEndpointState ep2state; */ USBEndpointState ep3state; +void sduDataRequest(USBDriver *usbp, usbep_t ep) { + + (void)usbp; + (void)ep; +} + +void sduInterruptRequest(USBDriver *usbp, usbep_t ep) { + + (void)usbp; + (void)ep; +} + +void sduDataAvailable(USBDriver *usbp, usbep_t ep) { + + (void)usbp; + (void)ep; +} + /** * @brief EP1 initialization structure (IN only). */ @@ -317,6 +335,7 @@ static void usb_event(USBDriver *usbp, usbevent_t event) { /* * Serial over USB driver configuration. */ +#if 0 static const SerialUSBConfig serusbcfg = { &USBD1, { @@ -329,6 +348,40 @@ static const SerialUSBConfig serusbcfg = { DATA_AVAILABLE_EP, INTERRUPT_REQUEST_EP }; +#endif + +#include "usb_cdc.h" +static cdc_linecoding_t linecoding = { + {0x00, 0x96, 0x00, 0x00}, /* 38400. */ + LC_STOP_1, LC_PARITY_NONE, 8 +}; +bool_t sduRequestsHook(USBDriver *usbp) { + + if ((usbp->setup[0] & USB_RTYPE_TYPE_MASK) == USB_RTYPE_TYPE_CLASS) { + switch (usbp->setup[1]) { + case CDC_GET_LINE_CODING: + usbSetupTransfer(usbp, (uint8_t *)&linecoding, sizeof(linecoding)); + return TRUE; + case CDC_SET_LINE_CODING: + usbSetupTransfer(usbp, (uint8_t *)&linecoding, sizeof(linecoding)); + return TRUE; + case CDC_SET_CONTROL_LINE_STATE: + /* Nothing to do, there are no control lines.*/ + usbSetupTransfer(usbp, NULL, 0); + return TRUE; + default: + return FALSE; + } + } + return FALSE; +} + +USBConfig usbconfig = { + usb_event, + get_descriptor, + sduRequestsHook, + NULL +}; /*===========================================================================*/ /* Generic code. */ @@ -352,6 +405,7 @@ static msg_t Thread1(void *arg) { /* * USB CDC loopback thread. */ +#if 0 static WORKING_AREA(waThread2, 256); static msg_t Thread2(void *arg) { SerialUSBDriver *sdup = arg; @@ -368,6 +422,7 @@ static msg_t Thread2(void *arg) { } } } +#endif /* * Application entry point. @@ -385,11 +440,12 @@ int main(void) { chSysInit(); /* - * Activates the USB bus and then the USB driver. + * Activates the USB driver and then the USB bus pull-up on D+. */ + usbStart(&USBD1, &usbconfig); palClearPad(GPIOC, GPIOC_USB_DISC); - sduObjectInit(&SDU1); - sduStart(&SDU1, &serusbcfg); +// sduObjectInit(&SDU1); +// sduStart(&SDU1, &serusbcfg); /* * Activates the serial driver 2 using the driver default configuration. @@ -404,7 +460,7 @@ int main(void) { /* * Creates the USB CDC loopback thread. */ - chThdCreateStatic(waThread2, sizeof(waThread2), NORMALPRIO, Thread2, &SDU1); +// chThdCreateStatic(waThread2, sizeof(waThread2), NORMALPRIO, Thread2, &SDU1); /* * Normal main() thread activity, in this demo it does nothing except