zcy
/
tinySA
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

USB rework, step 2. 

git-svn-id: svn://svn.code.sf.net/p/chibios/svn/trunk@2714 35acf78f-673a-0410-8e92-d51de3d6d3f4
master
gdisirio 2011-02-06 09:51:16 +00:00
parent 200f020df9
commit 4e68b68d5a
6 changed files with 568 additions and 330 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
os/hal/include/usb.h
View File

@ -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);

254
os/hal/platforms/STM32/usb_lld.c
View File

@ -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 */
/** @} */

132
os/hal/platforms/STM32/usb_lld.h
View File

@ -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

427
os/hal/src/usb.c
View File

@ -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 */

2
testhal/STM32/USB_CDC/halconf.h
View File

@ -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
/**

66
testhal/STM32/USB_CDC/main.c
View File

@ -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