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

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

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

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

@ -43,13 +43,36 @@ typedef struct {
* @brief Endpoint zero event handler * @brief Endpoint zero event handler
*/ */
typedef struct { 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 */ * @brief inherited generic handler
usbus_control_slicer_t slicer; /**< Slicer for multipart control */
messages */ usbus_handler_t handler;
usbdev_ep_t *out; /**< EP0 out endpoint */
usbdev_ep_t *in; /**< EP0 in endpoint */ /**
* @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; } 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, static void _event_handler(usbus_t *usbus, usbus_handler_t *handler,
usbus_event_usb_t event); usbus_event_usb_t event);
static int _setup_handler(usbus_t *usbus, usbus_handler_t *handler, static int _control_handler(usbus_t *usbus, usbus_handler_t *handler,
usbus_setuprq_state_t state, usb_setup_t *setup); usbus_control_request_state_t state,
usb_setup_t *setup);
static void _transfer_handler(usbus_t *usbus, usbus_handler_t *handler, static void _transfer_handler(usbus_t *usbus, usbus_handler_t *handler,
usbdev_ep_t *ep, usbus_event_transfer_t event); usbdev_ep_t *ep, usbus_event_transfer_t event);
static void _init(usbus_t *usbus, usbus_handler_t *handler); static void _init(usbus_t *usbus, usbus_handler_t *handler);
@ -147,7 +148,7 @@ static const usbus_handler_driver_t cdcecm_driver = {
.init = _init, .init = _init,
.event_handler = _event_handler, .event_handler = _event_handler,
.transfer_handler = _transfer_handler, .transfer_handler = _transfer_handler,
.setup_handler = _setup_handler, .control_handler = _control_handler,
}; };
static void _fill_ethernet(usbus_cdcecm_device_t *cdcecm) 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); usbus_handler_set_flag(handler, USBUS_HANDLER_FLAG_RESET);
} }
static int _setup_handler(usbus_t *usbus, usbus_handler_t *handler, static int _control_handler(usbus_t *usbus, usbus_handler_t *handler,
usbus_setuprq_state_t state, usb_setup_t *setup) usbus_control_request_state_t state,
usb_setup_t *setup)
{ {
(void)usbus; (void)usbus;
(void)state; (void)state;

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

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