riot-ci/RIOT
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

usbus: rename setup request to control request

Browse Source 
This commit changes the name of the requests over the control endpoints
to control requests instead of setup requests. This is a terminology fix
to follow the USB specification more closely as technically only the
first stage of a control request is named setup which contains a setup
packet. The whole transfer is a control transfer.
This commit is contained in:
Koen Zandberg 2019-09-11 21:21:32 +02:00
parent 729ba07e9a
commit dd99cea622
No known key found for this signature in database
GPG Key ID: 0895A893E6D2985B
5 changed files with 76 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
sys/include/usb/usbus.h
View File

@ -137,17 +137,18 @@ typedef enum {
} usbus_state_t;
/**
* @brief USBUS setup request state machine
* @brief USBUS control request state machine
*/
typedef enum {
USBUS_SETUPRQ_READY, /**< Ready for new setup request */
USBUS_SETUPRQ_INDATA, /**< Request received with expected DATA IN stage */
USBUS_SETUPRQ_OUTACK, /**< Expecting a zero-length ack out request
from the host */
USBUS_SETUPRQ_OUTDATA, /**< Data OUT expected */
USBUS_SETUPRQ_INACK, /**< Expecting a zero-length ack in request
from the host */
} usbus_setuprq_state_t;
USBUS_CONTROL_REQUEST_STATE_READY, /**< Ready for new control request */
USBUS_CONTROL_REQUEST_STATE_INDATA, /**< Request received with expected
DATA IN stage */
USBUS_CONTROL_REQUEST_STATE_OUTACK, /**< Expecting a zero-length ack OUT
request from the host */
USBUS_CONTROL_REQUEST_STATE_OUTDATA, /**< Data OUT expected */
USBUS_CONTROL_REQUEST_STATE_INACK, /**< Expecting a zero-length ack IN
request from the host */
} usbus_control_request_state_t;
/**
* @brief USBUS string type
@ -314,13 +315,13 @@ typedef struct usbus_handler_driver {
usbdev_ep_t *ep, usbus_event_transfer_t event);
/**
* @brief setup request handler function
* @brief control request handler function
*
* This function receives USB setup requests from the USBUS stack.
* This function receives USB control requests from the USBUS stack.
*
* @param usbus USBUS context
* @param handler handler context
* @param state setup request state
* @param state control request state
* @param setup setup packet
*
* @return Size of the returned data when the request is handled
@ -328,8 +329,9 @@ typedef struct usbus_handler_driver {
* host
* @return zero when the request is not handled by this handler
*/
int (*setup_handler)(usbus_t * usbus, struct usbus_handler *handler,
usbus_setuprq_state_t state, usb_setup_t *request);
int (*control_handler)(usbus_t * usbus, struct usbus_handler *handler,
usbus_control_request_state_t state,
usb_setup_t *request);
} usbus_handler_driver_t;
/**

1
sys/include/usb/usbus/cdc/ecm.h
View File

@ -28,6 +28,7 @@
#include "net/ethernet/hdr.h"
#include "usb/descriptor.h"
#include "usb/usbus.h"
#include "usb/usbus/control.h"
#include "net/netdev.h"
#include "mutex.h"

37
sys/include/usb/usbus/control.h
View File

@ -43,13 +43,36 @@ typedef struct {
* @brief Endpoint zero event handler
*/
typedef struct {
usbus_handler_t handler; /**< Inherited generic handler */
usb_setup_t setup; /**< Last received setup packet */
usbus_setuprq_state_t setup_state; /**< Setup request state machine */
usbus_control_slicer_t slicer; /**< Slicer for multipart control
messages */
usbdev_ep_t *out; /**< EP0 out endpoint */
usbdev_ep_t *in; /**< EP0 in endpoint */
/**
* @brief inherited generic handler
*/
usbus_handler_t handler;
/**
* @brief Last received setup packet
*/
usb_setup_t setup;
/**
* @brief Control request state machine state
*/
usbus_control_request_state_t control_request_state;
/**
* @brief Slicer state for multipart control request messages
*/
usbus_control_slicer_t slicer;
/**
* @brief EP0 OUT endpoint
*/
usbdev_ep_t *out;
/**
* @brief EP0 IN endpoint
*/
usbdev_ep_t *in;
} usbus_control_handler_t;
/**

12
sys/usb/usbus/cdc/ecm/cdc_ecm.c
View File

@ -34,8 +34,9 @@
static void _event_handler(usbus_t *usbus, usbus_handler_t *handler,
usbus_event_usb_t event);
static int _setup_handler(usbus_t *usbus, usbus_handler_t *handler,
usbus_setuprq_state_t state, usb_setup_t *setup);
static int _control_handler(usbus_t *usbus, usbus_handler_t *handler,
usbus_control_request_state_t state,
usb_setup_t *setup);
static void _transfer_handler(usbus_t *usbus, usbus_handler_t *handler,
usbdev_ep_t *ep, usbus_event_transfer_t event);
static void _init(usbus_t *usbus, usbus_handler_t *handler);
@ -147,7 +148,7 @@ static const usbus_handler_driver_t cdcecm_driver = {
.init = _init,
.event_handler = _event_handler,
.transfer_handler = _transfer_handler,
.setup_handler = _setup_handler,
.control_handler = _control_handler,
};
static void _fill_ethernet(usbus_cdcecm_device_t *cdcecm)
@ -237,8 +238,9 @@ static void _init(usbus_t *usbus, usbus_handler_t *handler)
usbus_handler_set_flag(handler, USBUS_HANDLER_FLAG_RESET);
}
static int _setup_handler(usbus_t *usbus, usbus_handler_t *handler,
usbus_setuprq_state_t state, usb_setup_t *setup)
static int _control_handler(usbus_t *usbus, usbus_handler_t *handler,
usbus_control_request_state_t state,
usb_setup_t *setup)
{
(void)usbus;
(void)state;

41
sys/usb/usbus/usbus_control.c
View File

@ -241,9 +241,10 @@ static int _recv_interface_setup(usbus_t *usbus, usb_setup_t *pkt)
/* Find interface handler */
for (usbus_interface_t *iface = usbus->iface; iface; iface = iface->next) {
if (destination == iface->idx &&
iface->handler->driver->setup_handler) {
return iface->handler->driver->setup_handler(usbus, iface->handler,
ep0_handler->setup_state,
iface->handler->driver->control_handler) {
return iface->handler->driver->control_handler(usbus,
iface->handler,
ep0_handler->control_request_state,
pkt);
}
}
@ -257,15 +258,15 @@ static void _recv_setup(usbus_t *usbus, usbus_control_handler_t *handler)
DEBUG("usbus_control: Received setup %x %x @ %d\n", pkt->type,
pkt->request, pkt->length);
if (usb_setup_is_read(pkt)) {
handler->setup_state = USBUS_SETUPRQ_INDATA;
handler->control_request_state = USBUS_CONTROL_REQUEST_STATE_INDATA;
}
else {
if (pkt->length) {
handler->setup_state = USBUS_SETUPRQ_OUTDATA;
handler->control_request_state = USBUS_CONTROL_REQUEST_STATE_OUTDATA;
usbdev_ep_ready(handler->out, 0);
}
else {
handler->setup_state = USBUS_SETUPRQ_INACK;
handler->control_request_state = USBUS_CONTROL_REQUEST_STATE_INACK;
usbdev_ep_ready(handler->in, 0);
}
}
@ -286,7 +287,7 @@ static void _recv_setup(usbus_t *usbus, usbus_control_handler_t *handler)
static const usbopt_enable_t enable = USBOPT_ENABLE;
usbdev_ep_set(handler->in, USBOPT_EP_STALL, &enable,
sizeof(usbopt_enable_t));
handler->setup_state = USBUS_SETUPRQ_READY;
handler->control_request_state = USBUS_CONTROL_REQUEST_STATE_READY;
}
else if (res) {
usbus_control_slicer_ready(usbus);
@ -311,7 +312,7 @@ static void _init(usbus_t *usbus, usbus_handler_t *handler)
DEBUG("usbus_control: Initializing EP0\n");
usbus_control_handler_t *ep0_handler = (usbus_control_handler_t *)handler;
usbus_handler_set_flag(handler, USBUS_HANDLER_FLAG_RESET);
ep0_handler->setup_state = USBUS_SETUPRQ_READY;
ep0_handler->control_request_state = USBUS_CONTROL_REQUEST_STATE_READY;
ep0_handler->in = usbus_add_endpoint(usbus, NULL, USB_EP_TYPE_CONTROL,
USB_EP_DIR_IN, USBUS_EP0_SIZE)->ep;
@ -323,8 +324,8 @@ static int _handle_tr_complete(usbus_t *usbus,
usbus_control_handler_t *ep0_handler,
usbdev_ep_t *ep)
{
switch (ep0_handler->setup_state) {
case USBUS_SETUPRQ_INACK:
switch (ep0_handler->control_request_state) {
case USBUS_CONTROL_REQUEST_STATE_INACK:
if (ep->dir == USB_EP_DIR_IN) {
if (usbus->addr && usbus->state == USBUS_STATE_RESET) {
usbdev_set(usbus->dev, USBOPT_ADDRESS, &usbus->addr,
@ -332,32 +333,32 @@ static int _handle_tr_complete(usbus_t *usbus,
/* Address configured */
usbus->state = USBUS_STATE_ADDR;
}
ep0_handler->setup_state = USBUS_SETUPRQ_READY;
ep0_handler->control_request_state = USBUS_CONTROL_REQUEST_STATE_READY;
}
break;
case USBUS_SETUPRQ_OUTACK:
case USBUS_CONTROL_REQUEST_STATE_OUTACK:
if (ep->dir == USB_EP_DIR_OUT) {
memset(&ep0_handler->slicer, 0, sizeof(usbus_control_slicer_t));
ep0_handler->setup_state = USBUS_SETUPRQ_READY;
ep0_handler->control_request_state = USBUS_CONTROL_REQUEST_STATE_READY;
}
break;
case USBUS_SETUPRQ_INDATA:
case USBUS_CONTROL_REQUEST_STATE_INDATA:
if (ep->dir == USB_EP_DIR_IN) {
if (usbus_control_slicer_nextslice(usbus)) {
_recv_setup(usbus, ep0_handler);
ep0_handler->setup_state = USBUS_SETUPRQ_INDATA;
ep0_handler->control_request_state = USBUS_CONTROL_REQUEST_STATE_INDATA;
}
else {
/* Ready out ZLP */
usbdev_ep_ready(ep0_handler->out, 0);
ep0_handler->setup_state = USBUS_SETUPRQ_OUTACK;
ep0_handler->control_request_state = USBUS_CONTROL_REQUEST_STATE_OUTACK;
}
}
break;
case USBUS_SETUPRQ_OUTDATA:
case USBUS_CONTROL_REQUEST_STATE_OUTDATA:
if (ep->dir == USB_EP_DIR_OUT) {
/* Ready in ZLP */
ep0_handler->setup_state = USBUS_SETUPRQ_INACK;
ep0_handler->control_request_state = USBUS_CONTROL_REQUEST_STATE_INACK;
size_t len = 0;
usbdev_ep_get(ep, USBOPT_EP_AVAILABLE, &len, sizeof(size_t));
DEBUG("Expected len: %d, received: %d\n",
@ -373,7 +374,7 @@ static int _handle_tr_complete(usbus_t *usbus,
DEBUG("usbus_control: Invalid state OUTDATA with IN request\n");
}
break;
case USBUS_SETUPRQ_READY:
case USBUS_CONTROL_REQUEST_STATE_READY:
if (ep->dir == USB_EP_DIR_OUT) {
memset(&ep0_handler->slicer, 0, sizeof(usbus_control_slicer_t));
memcpy(&ep0_handler->setup, ep0_handler->out->buf,
@ -403,7 +404,7 @@ static void _handler_ep0_event(usbus_t *usbus, usbus_handler_t *handler,
switch (event) {
case USBUS_EVENT_USB_RESET:
DEBUG("usbus_control: Reset event triggered\n");
ep0_handler->setup_state = USBUS_SETUPRQ_READY;
ep0_handler->control_request_state = USBUS_CONTROL_REQUEST_STATE_READY;
_usbus_config_ep0(ep0_handler);
break;
default: