kingkevin
/
espressif_tinyusb
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #2 from hathach/pigrew-ZLP_Request2 

zlp request2. PR for PR (has issues with STM32F0 FSDEV)
This commit is contained in:
Nathan Conrad 2019-11-03 17:50:41 -05:00 committed by GitHub
parent cebc066813 62f8c14fae
commit 68a53e05fc
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
11 changed files with 693 additions and 545 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
docs/porting.md
View File

@ -123,16 +123,14 @@ Also make sure to enable endpoint specific interrupts.
##### dcd_edpt_xfer ##### dcd_edpt_xfer
`dcd_edpt_xfer` is responsible for configuring the peripheral to send or receive data from the host. "xfer" is short for "transfer". **This is one of the core methods you must implement for TinyUSB to work (one other is the interrupt handler).** Data from the host is the OUT direction and data to the host is IN. In other words, direction is relative to the host. `dcd_edpt_xfer` is responsible for configuring the peripheral to send or receive data from the host. "xfer" is short for "transfer". **This is one of the core methods you must implement for TinyUSB to work (one other is the interrupt handler).** Data from the host is the OUT direction and data to the host is IN. It is used for all endpoints including the control endpoint 0. Make sure to handle the zero-length packet STATUS packet on endpoint 0 correctly. It may be a special transaction to the peripheral.
`dcd_edpt_xfer` is used for all endpoints including the control endpoint 0. Make sure to handle the zero-length packet STATUS packet on endpoint 0 correctly. It may be a special transaction to the peripheral.
Besides that, all other transactions are relatively straight-forward. The endpoint address provides the endpoint Besides that, all other transactions are relatively straight-forward. The endpoint address provides the endpoint
number and direction which usually determines where to write the buffer info. The buffer and its length are usually number and direction which usually determines where to write the buffer info. The buffer and its length are usually
written to a specific location in memory and the peripheral is told the data is valid. (Maybe by writing a 1 to a written to a specific location in memory and the peripheral is told the data is valid. (Maybe by writing a 1 to a
register or setting a counter register to 0 for OUT or length for IN.) register or setting a counter register to 0 for OUT or length for IN.)
The transmit buffer is NOT guarenteed to be word-aligned. The transmit buffer alignment is determined by `CFG_TUSB_MEM_ALIGN`.
One potential pitfall is that the buffer may be longer than the maximum endpoint size of one USB One potential pitfall is that the buffer may be longer than the maximum endpoint size of one USB
packet. Some peripherals can handle transmitting multiple USB packets for a provided buffer (like the SAMD21). packet. Some peripherals can handle transmitting multiple USB packets for a provided buffer (like the SAMD21).
@ -143,11 +141,11 @@ Once the transaction is going, the interrupt handler will notify TinyUSB of tran
During transmission, the IN data buffer is guarenteed to remain unchanged in memory until the `dcd_xfer_complete` function is called. During transmission, the IN data buffer is guarenteed to remain unchanged in memory until the `dcd_xfer_complete` function is called.
The dcd_edpt_xfer function must never add zero-length-packets (ZLP) on its own to a transfer. If a ZLP is required, The dcd_edpt_xfer function must never add zero-length-packets (ZLP) on its own to a transfer. If a ZLP is required,
then it must be explicitly sent by the module calling dcd_edpt_xfer(), by calling dcd_edpt_xfer() a second time with len=0. then it must be explicitly sent by the stack calling dcd_edpt_xfer(), by calling dcd_edpt_xfer() a second time with len=0.
For control transfers, this is automatically done in `usbd_control.c`. For control transfers, this is automatically done in `usbd_control.c`.
At the moment, only a single buffer can be transmitted at once. There is no provision for double-buffering. new dcd_edpt_xfer() will not At the moment, only a single buffer can be transmitted at once. There is no provision for double-buffering. new dcd_edpt_xfer() will not
be called again until the driver calls dcd_xfer_complete() (except in cases of USB resets). be called again on the same endpoint address until the driver calls dcd_xfer_complete() (except in cases of USB resets).
##### dcd_xfer_complete ##### dcd_xfer_complete

15
examples/make.mk
View File

@ -79,11 +79,16 @@ CFLAGS += \
# Debugging/Optimization # Debugging/Optimization
ifeq ($(DEBUG), 1) ifeq ($(DEBUG), 1)
CFLAGS += -Og -ggdb -DCFG_TUSB_DEBUG=2 CFLAGS += -Og -ggdb
else else
ifneq ($(BOARD), spresense) ifneq ($(BOARD),spresense)
CFLAGS += -flto -Os CFLAGS += -flto -Os
else else
CFLAGS += -Os CFLAGS += -Os
endif
endif endif
# TUSB Logging option
ifneq ($(LOG),)
CFLAGS += -DCFG_TUSB_DEBUG=$(LOG)
endif endif

3
hw/bsp/stm32f072disco/board.mk
View File

@ -24,7 +24,8 @@ SRC_C += \
$(ST_HAL_DRIVER)/Src/stm32f0xx_hal_cortex.c \ $(ST_HAL_DRIVER)/Src/stm32f0xx_hal_cortex.c \
$(ST_HAL_DRIVER)/Src/stm32f0xx_hal_rcc.c \ $(ST_HAL_DRIVER)/Src/stm32f0xx_hal_rcc.c \
$(ST_HAL_DRIVER)/Src/stm32f0xx_hal_rcc_ex.c \ $(ST_HAL_DRIVER)/Src/stm32f0xx_hal_rcc_ex.c \
$(ST_HAL_DRIVER)/Src/stm32f0xx_hal_gpio.c $(ST_HAL_DRIVER)/Src/stm32f0xx_hal_gpio.c \
$(ST_HAL_DRIVER)/Src/stm32f0xx_hal_uart.c
SRC_S += \ SRC_S += \
$(ST_CMSIS)/Source/Templates/gcc/startup_stm32f072xb.s $(ST_CMSIS)/Source/Templates/gcc/startup_stm32f072xb.s

50
hw/bsp/stm32f072disco/stm32f072disco.c
View File

@ -37,6 +37,24 @@
#define BUTTON_PIN GPIO_PIN_0 #define BUTTON_PIN GPIO_PIN_0
#define BUTTON_STATE_ACTIVE 1 #define BUTTON_STATE_ACTIVE 1
#define UARTx USART1
#define UART_GPIO_PORT GPIOA
#define UART_GPIO_AF GPIO_AF1_USART1
#define UART_TX_PIN GPIO_PIN_9
#define UART_RX_PIN GPIO_PIN_10
UART_HandleTypeDef UartHandle;
// enable all LED, Button, Uart, USB clock
static void all_rcc_clk_enable(void)
{
__HAL_RCC_GPIOA_CLK_ENABLE(); // USB D+, D-
__HAL_RCC_GPIOC_CLK_ENABLE(); // LED
//__HAL_RCC_GPIOA_CLK_ENABLE(); // Button
//__HAL_RCC_GPIOA_CLK_ENABLE(); // Uart tx, rx
__HAL_RCC_USART1_CLK_ENABLE(); // Uart module
}
/** /**
* @brief System Clock Configuration * @brief System Clock Configuration
@ -83,12 +101,11 @@ void board_init(void)
#endif #endif
SystemClock_Config(); SystemClock_Config();
// Notify runtime of frequency change.
SystemCoreClockUpdate(); SystemCoreClockUpdate();
all_rcc_clk_enable();
// LED // LED
__HAL_RCC_GPIOC_CLK_ENABLE();
GPIO_InitTypeDef GPIO_InitStruct; GPIO_InitTypeDef GPIO_InitStruct;
GPIO_InitStruct.Pin = LED_PIN; GPIO_InitStruct.Pin = LED_PIN;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP; GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
@ -97,16 +114,32 @@ void board_init(void)
HAL_GPIO_Init(LED_PORT, &GPIO_InitStruct); HAL_GPIO_Init(LED_PORT, &GPIO_InitStruct);
// Button // Button
__HAL_RCC_GPIOA_CLK_ENABLE();
GPIO_InitStruct.Pin = BUTTON_PIN; GPIO_InitStruct.Pin = BUTTON_PIN;
GPIO_InitStruct.Mode = GPIO_MODE_INPUT; GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
GPIO_InitStruct.Pull = GPIO_PULLDOWN; GPIO_InitStruct.Pull = GPIO_PULLDOWN;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
HAL_GPIO_Init(BUTTON_PORT, &GPIO_InitStruct); HAL_GPIO_Init(BUTTON_PORT, &GPIO_InitStruct);
// Uart
GPIO_InitStruct.Pin = UART_TX_PIN | UART_RX_PIN;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_PULLUP;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
GPIO_InitStruct.Alternate = UART_GPIO_AF;
HAL_GPIO_Init(UART_GPIO_PORT, &GPIO_InitStruct);
UartHandle.Instance = UARTx;
UartHandle.Init.BaudRate = CFG_BOARD_UART_BAUDRATE;
UartHandle.Init.WordLength = UART_WORDLENGTH_8B;
UartHandle.Init.StopBits = UART_STOPBITS_1;
UartHandle.Init.Parity = UART_PARITY_NONE;
UartHandle.Init.HwFlowCtl = UART_HWCONTROL_NONE;
UartHandle.Init.Mode = UART_MODE_TX_RX;
UartHandle.Init.OverSampling = UART_OVERSAMPLING_16;
HAL_UART_Init(&UartHandle);
// USB Pins // USB Pins
// Configure USB DM and DP pins. This is optional, and maintained only for user guidance. // Configure USB DM and DP pins. This is optional, and maintained only for user guidance.
__HAL_RCC_GPIOA_CLK_ENABLE();
GPIO_InitStruct.Pin = (GPIO_PIN_11 | GPIO_PIN_12); GPIO_InitStruct.Pin = (GPIO_PIN_11 | GPIO_PIN_12);
GPIO_InitStruct.Mode = GPIO_MODE_INPUT; GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Pull = GPIO_NOPULL;
@ -139,8 +172,8 @@ int board_uart_read(uint8_t* buf, int len)
int board_uart_write(void const * buf, int len) int board_uart_write(void const * buf, int len)
{ {
(void) buf; (void) len; HAL_UART_Transmit(&UartHandle, (uint8_t*) buf, len, 0xffff);
return 0; return len;
} }
#if CFG_TUSB_OS == OPT_OS_NONE #if CFG_TUSB_OS == OPT_OS_NONE
@ -170,7 +203,8 @@ void HardFault_Handler (void)
* @retval None * @retval None
*/ */
void assert_failed(char *file, uint32_t line) void assert_failed(char *file, uint32_t line)
{ {
(void) file; (void) line;
/* USER CODE BEGIN 6 */ /* USER CODE BEGIN 6 */
/* User can add his own implementation to report the file name and line number, /* User can add his own implementation to report the file name and line number,
tex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */ tex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */

4
hw/bsp/stm32f072disco/stm32f0xx_hal_conf.h
View File

@ -66,8 +66,8 @@
/*#define HAL_RTC_MODULE_ENABLED */ /*#define HAL_RTC_MODULE_ENABLED */
/*#define HAL_SPI_MODULE_ENABLED */ /*#define HAL_SPI_MODULE_ENABLED */
/*#define HAL_TIM_MODULE_ENABLED */ /*#define HAL_TIM_MODULE_ENABLED */
/*#define HAL_UART_MODULE_ENABLED */ #define HAL_UART_MODULE_ENABLED
#define HAL_USART_MODULE_ENABLED //#define HAL_USART_MODULE_ENABLED
/*#define HAL_IRDA_MODULE_ENABLED */ /*#define HAL_IRDA_MODULE_ENABLED */
/*#define HAL_SMARTCARD_MODULE_ENABLED */ /*#define HAL_SMARTCARD_MODULE_ENABLED */
/*#define HAL_SMBUS_MODULE_ENABLED */ /*#define HAL_SMBUS_MODULE_ENABLED */

654
src/class/hid/hid_device.c
View File

@ -1,327 +1,327 @@
/* /*
* The MIT License (MIT) * The MIT License (MIT)
* *
* Copyright (c) 2019 Ha Thach (tinyusb.org) * Copyright (c) 2019 Ha Thach (tinyusb.org)
* *
* Permission is hereby granted, free of charge, to any person obtaining a copy * Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal * of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights * in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is * copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions: * furnished to do so, subject to the following conditions:
* *
* The above copyright notice and this permission notice shall be included in * The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software. * all copies or substantial portions of the Software.
* *
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE. * THE SOFTWARE.
* *
* This file is part of the TinyUSB stack. * This file is part of the TinyUSB stack.
*/ */
#include "tusb_option.h" #include "tusb_option.h"
#if (TUSB_OPT_DEVICE_ENABLED && CFG_TUD_HID) #if (TUSB_OPT_DEVICE_ENABLED && CFG_TUD_HID)
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+
// INCLUDE // INCLUDE
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+
#include "common/tusb_common.h" #include "common/tusb_common.h"
#include "hid_device.h" #include "hid_device.h"
#include "device/usbd_pvt.h" #include "device/usbd_pvt.h"
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+
// MACRO CONSTANT TYPEDEF // MACRO CONSTANT TYPEDEF
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+
typedef struct typedef struct
{ {
uint8_t itf_num; uint8_t itf_num;
uint8_t ep_in; uint8_t ep_in;
uint8_t ep_out; // optional Out endpoint uint8_t ep_out; // optional Out endpoint
uint8_t boot_protocol; // Boot mouse or keyboard uint8_t boot_protocol; // Boot mouse or keyboard
bool boot_mode; // default = false (Report) bool boot_mode; // default = false (Report)
uint8_t idle_rate; // up to application to handle idle rate uint8_t idle_rate; // up to application to handle idle rate
uint16_t report_desc_len; uint16_t report_desc_len;
CFG_TUSB_MEM_ALIGN uint8_t epin_buf[CFG_TUD_HID_BUFSIZE]; CFG_TUSB_MEM_ALIGN uint8_t epin_buf[CFG_TUD_HID_BUFSIZE];
CFG_TUSB_MEM_ALIGN uint8_t epout_buf[CFG_TUD_HID_BUFSIZE]; CFG_TUSB_MEM_ALIGN uint8_t epout_buf[CFG_TUD_HID_BUFSIZE];
tusb_hid_descriptor_hid_t const * hid_descriptor; tusb_hid_descriptor_hid_t const * hid_descriptor;
} hidd_interface_t; } hidd_interface_t;
CFG_TUSB_MEM_SECTION static hidd_interface_t _hidd_itf[CFG_TUD_HID]; CFG_TUSB_MEM_SECTION static hidd_interface_t _hidd_itf[CFG_TUD_HID];
/*------------- Helpers -------------*/ /*------------- Helpers -------------*/
static inline hidd_interface_t* get_interface_by_itfnum(uint8_t itf_num) static inline hidd_interface_t* get_interface_by_itfnum(uint8_t itf_num)
{ {
for (uint8_t i=0; i < CFG_TUD_HID; i++ ) for (uint8_t i=0; i < CFG_TUD_HID; i++ )
{ {
if ( itf_num == _hidd_itf[i].itf_num ) return &_hidd_itf[i]; if ( itf_num == _hidd_itf[i].itf_num ) return &_hidd_itf[i];
} }
return NULL; return NULL;
} }
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+
// APPLICATION API // APPLICATION API
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+
bool tud_hid_ready(void) bool tud_hid_ready(void)
{ {
uint8_t itf = 0; uint8_t itf = 0;
uint8_t const ep_in = _hidd_itf[itf].ep_in; uint8_t const ep_in = _hidd_itf[itf].ep_in;
return tud_ready() && (ep_in != 0) && usbd_edpt_ready(TUD_OPT_RHPORT, ep_in); return tud_ready() && (ep_in != 0) && usbd_edpt_ready(TUD_OPT_RHPORT, ep_in);
} }
bool tud_hid_report(uint8_t report_id, void const* report, uint8_t len) bool tud_hid_report(uint8_t report_id, void const* report, uint8_t len)
{ {
TU_VERIFY( tud_hid_ready() ); TU_VERIFY( tud_hid_ready() );
uint8_t itf = 0; uint8_t itf = 0;
hidd_interface_t * p_hid = &_hidd_itf[itf]; hidd_interface_t * p_hid = &_hidd_itf[itf];
if (report_id) if (report_id)
{ {
len = tu_min8(len, CFG_TUD_HID_BUFSIZE-1); len = tu_min8(len, CFG_TUD_HID_BUFSIZE-1);
p_hid->epin_buf[0] = report_id; p_hid->epin_buf[0] = report_id;
memcpy(p_hid->epin_buf+1, report, len); memcpy(p_hid->epin_buf+1, report, len);
len++; len++;
}else }else
{ {
// If report id = 0, skip ID field // If report id = 0, skip ID field
len = tu_min8(len, CFG_TUD_HID_BUFSIZE); len = tu_min8(len, CFG_TUD_HID_BUFSIZE);
memcpy(p_hid->epin_buf, report, len); memcpy(p_hid->epin_buf, report, len);
} }
return usbd_edpt_xfer(TUD_OPT_RHPORT, p_hid->ep_in, p_hid->epin_buf, len); return usbd_edpt_xfer(TUD_OPT_RHPORT, p_hid->ep_in, p_hid->epin_buf, len);
} }
bool tud_hid_boot_mode(void) bool tud_hid_boot_mode(void)
{ {
uint8_t itf = 0; uint8_t itf = 0;
return _hidd_itf[itf].boot_mode; return _hidd_itf[itf].boot_mode;
} }
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+
// KEYBOARD API // KEYBOARD API
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+
bool tud_hid_keyboard_report(uint8_t report_id, uint8_t modifier, uint8_t keycode[6]) bool tud_hid_keyboard_report(uint8_t report_id, uint8_t modifier, uint8_t keycode[6])
{ {
hid_keyboard_report_t report; hid_keyboard_report_t report;
report.modifier = modifier; report.modifier = modifier;
if ( keycode ) if ( keycode )
{ {
memcpy(report.keycode, keycode, 6); memcpy(report.keycode, keycode, 6);
}else }else
{ {
tu_memclr(report.keycode, 6); tu_memclr(report.keycode, 6);
} }
return tud_hid_report(report_id, &report, sizeof(report)); return tud_hid_report(report_id, &report, sizeof(report));
} }
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+
// MOUSE APPLICATION API // MOUSE APPLICATION API
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+
bool tud_hid_mouse_report(uint8_t report_id, uint8_t buttons, int8_t x, int8_t y, int8_t vertical, int8_t horizontal) bool tud_hid_mouse_report(uint8_t report_id, uint8_t buttons, int8_t x, int8_t y, int8_t vertical, int8_t horizontal)
{ {
hid_mouse_report_t report = hid_mouse_report_t report =
{ {
.buttons = buttons, .buttons = buttons,
.x = x, .x = x,
.y = y, .y = y,
.wheel = vertical, .wheel = vertical,
.pan = horizontal .pan = horizontal
}; };
return tud_hid_report(report_id, &report, sizeof(report)); return tud_hid_report(report_id, &report, sizeof(report));
} }
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+
// USBD-CLASS API // USBD-CLASS API
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+
void hidd_init(void) void hidd_init(void)
{ {
hidd_reset(TUD_OPT_RHPORT); hidd_reset(TUD_OPT_RHPORT);
} }
void hidd_reset(uint8_t rhport) void hidd_reset(uint8_t rhport)
{ {
(void) rhport; (void) rhport;
tu_memclr(_hidd_itf, sizeof(_hidd_itf)); tu_memclr(_hidd_itf, sizeof(_hidd_itf));
} }
bool hidd_open(uint8_t rhport, tusb_desc_interface_t const * desc_itf, uint16_t *p_len) bool hidd_open(uint8_t rhport, tusb_desc_interface_t const * desc_itf, uint16_t *p_len)
{ {
uint8_t const *p_desc = (uint8_t const *) desc_itf; uint8_t const *p_desc = (uint8_t const *) desc_itf;
// TODO support multiple HID interface // TODO support multiple HID interface
uint8_t const itf = 0; uint8_t const itf = 0;
hidd_interface_t * p_hid = &_hidd_itf[itf]; hidd_interface_t * p_hid = &_hidd_itf[itf];
//------------- HID descriptor -------------// //------------- HID descriptor -------------//
p_desc = tu_desc_next(p_desc); p_desc = tu_desc_next(p_desc);
p_hid->hid_descriptor = (tusb_hid_descriptor_hid_t const *) p_desc; p_hid->hid_descriptor = (tusb_hid_descriptor_hid_t const *) p_desc;
TU_ASSERT(HID_DESC_TYPE_HID == p_hid->hid_descriptor->bDescriptorType); TU_ASSERT(HID_DESC_TYPE_HID == p_hid->hid_descriptor->bDescriptorType);
//------------- Endpoint Descriptor -------------// //------------- Endpoint Descriptor -------------//
p_desc = tu_desc_next(p_desc); p_desc = tu_desc_next(p_desc);
TU_ASSERT(usbd_open_edpt_pair(rhport, p_desc, desc_itf->bNumEndpoints, TUSB_XFER_INTERRUPT, &p_hid->ep_out, &p_hid->ep_in)); TU_ASSERT(usbd_open_edpt_pair(rhport, p_desc, desc_itf->bNumEndpoints, TUSB_XFER_INTERRUPT, &p_hid->ep_out, &p_hid->ep_in));
if ( desc_itf->bInterfaceSubClass == HID_SUBCLASS_BOOT ) p_hid->boot_protocol = desc_itf->bInterfaceProtocol; if ( desc_itf->bInterfaceSubClass == HID_SUBCLASS_BOOT ) p_hid->boot_protocol = desc_itf->bInterfaceProtocol;
p_hid->boot_mode = false; // default mode is REPORT p_hid->boot_mode = false; // default mode is REPORT
p_hid->itf_num = desc_itf->bInterfaceNumber; p_hid->itf_num = desc_itf->bInterfaceNumber;
memcpy(&p_hid->report_desc_len, &(p_hid->hid_descriptor->wReportLength), 2); memcpy(&p_hid->report_desc_len, &(p_hid->hid_descriptor->wReportLength), 2);
*p_len = sizeof(tusb_desc_interface_t) + sizeof(tusb_hid_descriptor_hid_t) + desc_itf->bNumEndpoints*sizeof(tusb_desc_endpoint_t); *p_len = sizeof(tusb_desc_interface_t) + sizeof(tusb_hid_descriptor_hid_t) + desc_itf->bNumEndpoints*sizeof(tusb_desc_endpoint_t);
// Prepare for output endpoint // Prepare for output endpoint
if (p_hid->ep_out) TU_ASSERT(usbd_edpt_xfer(rhport, p_hid->ep_out, p_hid->epout_buf, sizeof(p_hid->epout_buf))); if (p_hid->ep_out) TU_ASSERT(usbd_edpt_xfer(rhport, p_hid->ep_out, p_hid->epout_buf, sizeof(p_hid->epout_buf)));
return true; return true;
} }
// Handle class control request // Handle class control request
// return false to stall control endpoint (e.g unsupported request) // return false to stall control endpoint (e.g unsupported request)
bool hidd_control_request(uint8_t rhport, tusb_control_request_t const * p_request) bool hidd_control_request(uint8_t rhport, tusb_control_request_t const * p_request)
{ {
if (p_request->bmRequestType_bit.recipient != TUSB_REQ_RCPT_INTERFACE) if (p_request->bmRequestType_bit.recipient != TUSB_REQ_RCPT_INTERFACE)
{ {
return false; return false;
} }
hidd_interface_t* p_hid = get_interface_by_itfnum( (uint8_t) p_request->wIndex ); hidd_interface_t* p_hid = get_interface_by_itfnum( (uint8_t) p_request->wIndex );
TU_ASSERT(p_hid); TU_ASSERT(p_hid);
if (p_request->bmRequestType_bit.type == TUSB_REQ_TYPE_STANDARD) if (p_request->bmRequestType_bit.type == TUSB_REQ_TYPE_STANDARD)
{ {
//------------- STD Request -------------// //------------- STD Request -------------//
uint8_t const desc_type = tu_u16_high(p_request->wValue); uint8_t const desc_type = tu_u16_high(p_request->wValue);
uint8_t const desc_index = tu_u16_low (p_request->wValue); uint8_t const desc_index = tu_u16_low (p_request->wValue);
(void) desc_index; (void) desc_index;
if (p_request->bRequest == TUSB_REQ_GET_DESCRIPTOR && desc_type == HID_DESC_TYPE_HID) if (p_request->bRequest == TUSB_REQ_GET_DESCRIPTOR && desc_type == HID_DESC_TYPE_HID)
{ {
TU_VERIFY(p_hid->hid_descriptor != NULL); TU_VERIFY(p_hid->hid_descriptor != NULL);
TU_VERIFY(tud_control_xfer(rhport, p_request, (void*) p_hid->hid_descriptor, p_hid->hid_descriptor->bLength)); TU_VERIFY(tud_control_xfer(rhport, p_request, (void*) p_hid->hid_descriptor, p_hid->hid_descriptor->bLength));
} }
else if (p_request->bRequest == TUSB_REQ_GET_DESCRIPTOR && desc_type == HID_DESC_TYPE_REPORT) else if (p_request->bRequest == TUSB_REQ_GET_DESCRIPTOR && desc_type == HID_DESC_TYPE_REPORT)
{ {
uint8_t const * desc_report = tud_hid_descriptor_report_cb(); uint8_t const * desc_report = tud_hid_descriptor_report_cb();
tud_control_xfer(rhport, p_request, (void*) desc_report, p_hid->report_desc_len); tud_control_xfer(rhport, p_request, (void*) desc_report, p_hid->report_desc_len);
} }
else else
{ {
return false; // stall unsupported request return false; // stall unsupported request
} }
} }
else if (p_request->bmRequestType_bit.type == TUSB_REQ_TYPE_CLASS) else if (p_request->bmRequestType_bit.type == TUSB_REQ_TYPE_CLASS)
{ {
//------------- Class Specific Request -------------// //------------- Class Specific Request -------------//
switch( p_request->bRequest ) switch( p_request->bRequest )
{ {
case HID_REQ_CONTROL_GET_REPORT: case HID_REQ_CONTROL_GET_REPORT:
{ {
// wValue = Report Type | Report ID // wValue = Report Type | Report ID
uint8_t const report_type = tu_u16_high(p_request->wValue); uint8_t const report_type = tu_u16_high(p_request->wValue);
uint8_t const report_id = tu_u16_low(p_request->wValue); uint8_t const report_id = tu_u16_low(p_request->wValue);
uint16_t xferlen = tud_hid_get_report_cb(report_id, (hid_report_type_t) report_type, p_hid->epin_buf, p_request->wLength); uint16_t xferlen = tud_hid_get_report_cb(report_id, (hid_report_type_t) report_type, p_hid->epin_buf, p_request->wLength);
TU_ASSERT( xferlen > 0 ); TU_ASSERT( xferlen > 0 );
tud_control_xfer(rhport, p_request, p_hid->epin_buf, xferlen); tud_control_xfer(rhport, p_request, p_hid->epin_buf, xferlen);
} }
break; break;
case HID_REQ_CONTROL_SET_REPORT: case HID_REQ_CONTROL_SET_REPORT:
TU_VERIFY(p_request->wLength <=sizeof(p_hid->epout_buf)); TU_VERIFY(p_request->wLength <= sizeof(p_hid->epout_buf));
tud_control_xfer(rhport, p_request, p_hid->epout_buf, p_request->wLength); tud_control_xfer(rhport, p_request, p_hid->epout_buf, p_request->wLength);
break; break;
case HID_REQ_CONTROL_SET_IDLE: case HID_REQ_CONTROL_SET_IDLE:
p_hid->idle_rate = tu_u16_high(p_request->wValue); p_hid->idle_rate = tu_u16_high(p_request->wValue);
if ( tud_hid_set_idle_cb ) if ( tud_hid_set_idle_cb )
{ {
// stall request if callback return false // stall request if callback return false
if ( !tud_hid_set_idle_cb(p_hid->idle_rate) ) return false; if ( !tud_hid_set_idle_cb(p_hid->idle_rate) ) return false;
} }
tud_control_status(rhport, p_request); tud_control_status(rhport, p_request);
break; break;
case HID_REQ_CONTROL_GET_IDLE: case HID_REQ_CONTROL_GET_IDLE:
// TODO idle rate of report // TODO idle rate of report
tud_control_xfer(rhport, p_request, &p_hid->idle_rate, 1); tud_control_xfer(rhport, p_request, &p_hid->idle_rate, 1);
break; break;
case HID_REQ_CONTROL_GET_PROTOCOL: case HID_REQ_CONTROL_GET_PROTOCOL:
{ {
uint8_t protocol = (uint8_t)(1-p_hid->boot_mode); // 0 is Boot, 1 is Report protocol uint8_t protocol = (uint8_t)(1-p_hid->boot_mode); // 0 is Boot, 1 is Report protocol
tud_control_xfer(rhport, p_request, &protocol, 1); tud_control_xfer(rhport, p_request, &protocol, 1);
} }
break; break;
case HID_REQ_CONTROL_SET_PROTOCOL: case HID_REQ_CONTROL_SET_PROTOCOL:
p_hid->boot_mode = 1 - p_request->wValue; // 0 is Boot, 1 is Report protocol p_hid->boot_mode = 1 - p_request->wValue; // 0 is Boot, 1 is Report protocol
if (tud_hid_boot_mode_cb) tud_hid_boot_mode_cb(p_hid->boot_mode); if (tud_hid_boot_mode_cb) tud_hid_boot_mode_cb(p_hid->boot_mode);
tud_control_status(rhport, p_request); tud_control_status(rhport, p_request);
break; break;
default: return false; // stall unsupported request default: return false; // stall unsupported request
} }
}else }else
{ {
return false; // stall unsupported request return false; // stall unsupported request
} }
return true; return true;
} }
// Invoked when class request DATA stage is finished. // Invoked when class request DATA stage is finished.
// return false to stall control endpoint (e.g Host send non-sense DATA) // return false to stall control endpoint (e.g Host send non-sense DATA)
bool hidd_control_complete(uint8_t rhport, tusb_control_request_t const * p_request) bool hidd_control_complete(uint8_t rhport, tusb_control_request_t const * p_request)
{ {
(void) rhport; (void) rhport;
hidd_interface_t* p_hid = get_interface_by_itfnum( (uint8_t) p_request->wIndex ); hidd_interface_t* p_hid = get_interface_by_itfnum( (uint8_t) p_request->wIndex );
TU_ASSERT(p_hid); TU_ASSERT(p_hid);
if (p_request->bmRequestType_bit.type == TUSB_REQ_TYPE_CLASS && if (p_request->bmRequestType_bit.type == TUSB_REQ_TYPE_CLASS &&
p_request->bRequest == HID_REQ_CONTROL_SET_REPORT) p_request->bRequest == HID_REQ_CONTROL_SET_REPORT)
{ {
// wValue = Report Type | Report ID // wValue = Report Type | Report ID
uint8_t const report_type = tu_u16_high(p_request->wValue); uint8_t const report_type = tu_u16_high(p_request->wValue);
uint8_t const report_id = tu_u16_low(p_request->wValue); uint8_t const report_id = tu_u16_low(p_request->wValue);
tud_hid_set_report_cb(report_id, (hid_report_type_t) report_type, p_hid->epout_buf, p_request->wLength); tud_hid_set_report_cb(report_id, (hid_report_type_t) report_type, p_hid->epout_buf, p_request->wLength);
} }
return true; return true;
} }
bool hidd_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t result, uint32_t xferred_bytes) bool hidd_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t result, uint32_t xferred_bytes)
{ {
(void) result; (void) result;
// TODO support multiple HID interface // TODO support multiple HID interface
uint8_t const itf = 0; uint8_t const itf = 0;
hidd_interface_t * p_hid = &_hidd_itf[itf]; hidd_interface_t * p_hid = &_hidd_itf[itf];
if (ep_addr == p_hid->ep_out) if (ep_addr == p_hid->ep_out)
{ {
tud_hid_set_report_cb(0, HID_REPORT_TYPE_INVALID, p_hid->epout_buf, xferred_bytes); tud_hid_set_report_cb(0, HID_REPORT_TYPE_INVALID, p_hid->epout_buf, xferred_bytes);
TU_ASSERT(usbd_edpt_xfer(rhport, p_hid->ep_out, p_hid->epout_buf, sizeof(p_hid->epout_buf))); TU_ASSERT(usbd_edpt_xfer(rhport, p_hid->ep_out, p_hid->epout_buf, sizeof(p_hid->epout_buf)));
} }
return true; return true;
} }
#endif #endif

11
src/device/usbd.c
View File

@ -376,7 +376,7 @@ void tud_task (void)
case DCD_EVENT_SETUP_RECEIVED: case DCD_EVENT_SETUP_RECEIVED:
TU_LOG2(" "); TU_LOG2(" ");
TU_LOG2_MEM(&event.setup_received, 1, 8); TU_LOG1_MEM(&event.setup_received, 1, 8);
// Mark as connected after receiving 1st setup packet. // Mark as connected after receiving 1st setup packet.
// But it is easier to set it every time instead of wasting time to check then set // But it is easier to set it every time instead of wasting time to check then set
@ -385,6 +385,7 @@ void tud_task (void)
// Process control request // Process control request
if ( !process_control_request(event.rhport, &event.setup_received) ) if ( !process_control_request(event.rhport, &event.setup_received) )
{ {
TU_LOG1(" Stall EP0\r\n");
// Failed -> stall both control endpoint IN and OUT // Failed -> stall both control endpoint IN and OUT
dcd_edpt_stall(event.rhport, 0); dcd_edpt_stall(event.rhport, 0);
dcd_edpt_stall(event.rhport, 0 | TUSB_DIR_IN_MASK); dcd_edpt_stall(event.rhport, 0 | TUSB_DIR_IN_MASK);
@ -404,7 +405,7 @@ void tud_task (void)
if ( 0 == epnum ) if ( 0 == epnum )
{ {
// control transfer DATA stage callback TU_LOG1(" EP Addr = 0x%02X, len = %ld\r\n", ep_addr, event.xfer_complete.len);
usbd_control_xfer_cb(event.rhport, ep_addr, event.xfer_complete.result, event.xfer_complete.len); usbd_control_xfer_cb(event.rhport, ep_addr, event.xfer_complete.result, event.xfer_complete.len);
} }
else else
@ -785,6 +786,8 @@ static bool process_get_descriptor(uint8_t rhport, tusb_control_request_t const
case TUSB_DESC_CONFIGURATION: case TUSB_DESC_CONFIGURATION:
{ {
tusb_desc_configuration_t const* desc_config = (tusb_desc_configuration_t const*) tud_descriptor_configuration_cb(desc_index); tusb_desc_configuration_t const* desc_config = (tusb_desc_configuration_t const*) tud_descriptor_configuration_cb(desc_index);
TU_ASSERT(desc_config);
uint16_t total_len; uint16_t total_len;
memcpy(&total_len, &desc_config->wTotalLength, 2); // possibly mis-aligned memory memcpy(&total_len, &desc_config->wTotalLength, 2); // possibly mis-aligned memory
@ -867,10 +870,6 @@ void dcd_event_handler(dcd_event_t const * event, bool in_isr)
break; break;
case DCD_EVENT_XFER_COMPLETE: case DCD_EVENT_XFER_COMPLETE:
// skip zero-length control status complete event, should DCD notify us.
// TODO could cause issue with actual zero length data used by class such as DFU
if ( (0 == tu_edpt_number(event->xfer_complete.ep_addr)) && (event->xfer_complete.len == 0) ) break;
osal_queue_send(_usbd_q, event, in_isr); osal_queue_send(_usbd_q, event, in_isr);
TU_ASSERT(event->xfer_complete.result == XFER_RESULT_SUCCESS,); TU_ASSERT(event->xfer_complete.result == XFER_RESULT_SUCCESS,);
break; break;

345
src/device/usbd_control.c
View File

@ -1,167 +1,178 @@
/* /*
* The MIT License (MIT) * The MIT License (MIT)
* *
* Copyright (c) 2019 Ha Thach (tinyusb.org) * Copyright (c) 2019 Ha Thach (tinyusb.org)
* *
* Permission is hereby granted, free of charge, to any person obtaining a copy * Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal * of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights * in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is * copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions: * furnished to do so, subject to the following conditions:
* *
* The above copyright notice and this permission notice shall be included in * The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software. * all copies or substantial portions of the Software.
* *
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE. * THE SOFTWARE.
* *
* This file is part of the TinyUSB stack. * This file is part of the TinyUSB stack.
*/ */
#include "tusb_option.h" #include "tusb_option.h"
#if TUSB_OPT_DEVICE_ENABLED #if TUSB_OPT_DEVICE_ENABLED
#include "tusb.h" #include "tusb.h"
#include "device/usbd_pvt.h" #include "device/usbd_pvt.h"
#include "dcd.h" #include "dcd.h"
enum enum
{ {
EDPT_CTRL_OUT = 0x00, EDPT_CTRL_OUT = 0x00,
EDPT_CTRL_IN = 0x80 EDPT_CTRL_IN = 0x80
}; };
typedef struct typedef struct
{ {
tusb_control_request_t request; tusb_control_request_t request;
void* buffer; uint8_t* buffer;
uint16_t len; uint16_t data_len;
uint16_t total_transferred; uint16_t total_xferred;
uint16_t requested_len;
bool (*complete_cb) (uint8_t, tusb_control_request_t const *);
bool (*complete_cb) (uint8_t, tusb_control_request_t const *); } usbd_control_xfer_t;
} usbd_control_xfer_t;
static usbd_control_xfer_t _ctrl_xfer;
static usbd_control_xfer_t _control_state;
CFG_TUSB_MEM_SECTION CFG_TUSB_MEM_ALIGN static uint8_t _usbd_ctrl_buf[CFG_TUD_ENDPOINT0_SIZE];
CFG_TUSB_MEM_SECTION CFG_TUSB_MEM_ALIGN uint8_t _usbd_ctrl_buf[CFG_TUD_ENDPOINT0_SIZE];
void usbd_control_reset (uint8_t rhport) //--------------------------------------------------------------------+
{ // Application API
(void) rhport; //--------------------------------------------------------------------+
tu_varclr(&_control_state);
} bool tud_control_status(uint8_t rhport, tusb_control_request_t const * request)
{
bool tud_control_status(uint8_t rhport, tusb_control_request_t const * request) // status direction is reversed to one in the setup packet
{ return dcd_edpt_xfer(rhport, request->bmRequestType_bit.direction ? EDPT_CTRL_OUT : EDPT_CTRL_IN, NULL, 0);
// status direction is reversed to one in the setup packet }
return dcd_edpt_xfer(rhport, request->bmRequestType_bit.direction ? EDPT_CTRL_OUT : EDPT_CTRL_IN, NULL, 0);
} // Transfer an transaction in Data Stage
// Each transaction has up to Endpoint0's max packet size.
// Each transaction is up to endpoint0's max packet size // This function can also transfer an zero-length packet
static bool start_control_data_xact(uint8_t rhport) static bool _data_stage_xact(uint8_t rhport)
{ {
uint16_t const xact_len = tu_min16(_control_state.len - _control_state.total_transferred, CFG_TUD_ENDPOINT0_SIZE); uint16_t const xact_len = tu_min16(_ctrl_xfer.data_len - _ctrl_xfer.total_xferred, CFG_TUD_ENDPOINT0_SIZE);
uint8_t ep_addr = EDPT_CTRL_OUT; uint8_t ep_addr = EDPT_CTRL_OUT;
if ( _control_state.request.bmRequestType_bit.direction == TUSB_DIR_IN ) if ( _ctrl_xfer.request.bmRequestType_bit.direction == TUSB_DIR_IN )
{ {
ep_addr = EDPT_CTRL_IN; ep_addr = EDPT_CTRL_IN;
memcpy(_usbd_ctrl_buf, _control_state.buffer, xact_len); if ( xact_len ) memcpy(_usbd_ctrl_buf, _ctrl_xfer.buffer, xact_len);
} }
return dcd_edpt_xfer(rhport, ep_addr, _usbd_ctrl_buf, xact_len); return dcd_edpt_xfer(rhport, ep_addr, xact_len ? _usbd_ctrl_buf : NULL, xact_len);
} }
// TODO may find a better way bool tud_control_xfer(uint8_t rhport, tusb_control_request_t const * request, void* buffer, uint16_t len)
void usbd_control_set_complete_callback( bool (*fp) (uint8_t, tusb_control_request_t const * ) ) {
{ _ctrl_xfer.request = (*request);
_control_state.complete_cb = fp; _ctrl_xfer.buffer = (uint8_t*) buffer;
} _ctrl_xfer.total_xferred = 0;
_ctrl_xfer.data_len = tu_min16(len, request->wLength);
bool tud_control_xfer(uint8_t rhport, tusb_control_request_t const * request, void* buffer, uint16_t len)
{ if ( _ctrl_xfer.data_len )
// transmitted length must be <= requested length (USB 2.0 spec: 8.5.3.1 ) {
// FIXME: Should logic be here or in place that calls this function? TU_ASSERT(buffer);
if(len > request->wLength)
len = request->wLength; // Data stage
TU_ASSERT( _data_stage_xact(rhport) );
_control_state.request = (*request); }else
_control_state.buffer = buffer; {
_control_state.total_transferred = 0; // Status stage
_control_state.requested_len = request->wLength; TU_ASSERT( tud_control_status(rhport, request) );
_control_state.len = len; }
if ( len ) return true;
{ }
TU_ASSERT(buffer);
//--------------------------------------------------------------------+
// Data stage // USBD API
TU_ASSERT( start_control_data_xact(rhport) ); //--------------------------------------------------------------------+
}else
{ void usbd_control_reset (uint8_t rhport)
// Status stage {
TU_ASSERT( tud_control_status(rhport, request) ); (void) rhport;
} tu_varclr(&_ctrl_xfer);
}
return true;
} // TODO may find a better way
void usbd_control_set_complete_callback( bool (*fp) (uint8_t, tusb_control_request_t const * ) )
// callback when a transaction complete on DATA stage of control endpoint {
bool usbd_control_xfer_cb (uint8_t rhport, uint8_t ep_addr, xfer_result_t result, uint32_t xferred_bytes) _ctrl_xfer.complete_cb = fp;
{ }
(void) result;
(void) ep_addr; // callback when a transaction complete on DATA stage of control endpoint
bool usbd_control_xfer_cb (uint8_t rhport, uint8_t ep_addr, xfer_result_t result, uint32_t xferred_bytes)
if ( _control_state.request.bmRequestType_bit.direction == TUSB_DIR_OUT ) {
{ (void) result;
TU_VERIFY(_control_state.buffer);
memcpy(_control_state.buffer, _usbd_ctrl_buf, xferred_bytes); // Endpoint Address is opposite to direction bit, this is Status Stage complete event
} if ( tu_edpt_dir(ep_addr) != _ctrl_xfer.request.bmRequestType_bit.direction )
{
_control_state.total_transferred += xferred_bytes; TU_ASSERT(0 == xferred_bytes);
_control_state.buffer = ((uint8_t*)_control_state.buffer) + xferred_bytes; return true;
}
if ( (_control_state.requested_len == _control_state.total_transferred) || xferred_bytes < CFG_TUD_ENDPOINT0_SIZE )
if ( _ctrl_xfer.request.bmRequestType_bit.direction == TUSB_DIR_OUT )
{ {
// DATA stage is complete TU_VERIFY(_ctrl_xfer.buffer);
bool is_ok = true; memcpy(_ctrl_xfer.buffer, _usbd_ctrl_buf, xferred_bytes);
}
// invoke complete callback if set
// callback can still stall control in status phase e.g out data does not make sense _ctrl_xfer.total_xferred += xferred_bytes;
if ( _control_state.complete_cb ) _ctrl_xfer.buffer += xferred_bytes;
{
is_ok = _control_state.complete_cb(rhport, &_control_state.request); // Data Stage is complete when all request's length are transferred or
} // a short packet is sent including zero-length packet.
if ( (_ctrl_xfer.request.wLength == _ctrl_xfer.total_xferred) || xferred_bytes < CFG_TUD_ENDPOINT0_SIZE )
if ( is_ok ) {
{ // DATA stage is complete
// Send status bool is_ok = true;
TU_ASSERT( tud_control_status(rhport, &_control_state.request) );
}else // invoke complete callback if set
{ // callback can still stall control in status phase e.g out data does not make sense
// Stall both IN and OUT control endpoint if ( _ctrl_xfer.complete_cb )
dcd_edpt_stall(rhport, EDPT_CTRL_OUT); {
dcd_edpt_stall(rhport, EDPT_CTRL_IN); is_ok = _ctrl_xfer.complete_cb(rhport, &_ctrl_xfer.request);
} }
}
else if ( is_ok )
{ {
// More data to transfer // Send status
TU_ASSERT( start_control_data_xact(rhport) ); TU_ASSERT( tud_control_status(rhport, &_ctrl_xfer.request) );
} }else
{
return true; // Stall both IN and OUT control endpoint
} dcd_edpt_stall(rhport, EDPT_CTRL_OUT);
dcd_edpt_stall(rhport, EDPT_CTRL_IN);
#endif }
}
else
{
// More data to transfer
TU_ASSERT( _data_stage_xact(rhport) );
}
return true;
}
#endif

2
src/osal/osal_none.h
View File

@ -198,6 +198,8 @@ static inline bool osal_queue_send(osal_queue_t const qhdl, void const * data, b
_osal_q_unlock(qhdl); _osal_q_unlock(qhdl);
} }
TU_ASSERT(success);
return success; return success;
} }

123
test/test/device/usbd/test_usbd.c
View File

@ -38,9 +38,15 @@ TEST_FILE("usbd_control.c")
// MACRO TYPEDEF CONSTANT ENUM DECLARATION // MACRO TYPEDEF CONSTANT ENUM DECLARATION
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+
enum
{
EDPT_CTRL_OUT = 0x00,
EDPT_CTRL_IN = 0x80
};
uint8_t const rhport = 0; uint8_t const rhport = 0;
tusb_desc_device_t const desc_device = tusb_desc_device_t const data_desc_device =
{ {
.bLength = sizeof(tusb_desc_device_t), .bLength = sizeof(tusb_desc_device_t),
.bDescriptorType = TUSB_DESC_DEVICE, .bDescriptorType = TUSB_DESC_DEVICE,
@ -65,6 +71,12 @@ tusb_desc_device_t const desc_device =
.bNumConfigurations = 0x01 .bNumConfigurations = 0x01
}; };
uint8_t const data_desc_configuration[] =
{
// Interface count, string index, total length, attribute, power in mA
TUD_CONFIG_DESCRIPTOR(0, 0, TUD_CONFIG_DESC_LEN, TUSB_DESC_CONFIG_ATT_REMOTE_WAKEUP, 100),
};
tusb_control_request_t const req_get_desc_device = tusb_control_request_t const req_get_desc_device =
{ {
.bmRequestType = 0x80, .bmRequestType = 0x80,
@ -74,20 +86,29 @@ tusb_control_request_t const req_get_desc_device =
.wLength = 64 .wLength = 64
}; };
tusb_control_request_t const req_get_desc_configuration =
{
.bmRequestType = 0x80,
.bRequest = TUSB_REQ_GET_DESCRIPTOR,
.wValue = (TUSB_DESC_CONFIGURATION << 8),
.wIndex = 0x0000,
.wLength = 256
};
uint8_t const* desc_device;
uint8_t const* desc_configuration;
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+
// //
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+
uint8_t const * ptr_desc_device;
uint8_t const * tud_descriptor_device_cb(void) uint8_t const * tud_descriptor_device_cb(void)
{ {
return ptr_desc_device; return desc_device;
} }
uint8_t const * tud_descriptor_configuration_cb(uint8_t index) uint8_t const * tud_descriptor_configuration_cb(uint8_t index)
{ {
TEST_FAIL(); return desc_configuration;
return NULL;
} }
uint16_t const* tud_descriptor_string_cb(uint8_t index) uint16_t const* tud_descriptor_string_cb(uint8_t index)
@ -105,8 +126,6 @@ void setUp(void)
dcd_init_Expect(rhport); dcd_init_Expect(rhport);
tusb_init(); tusb_init();
} }
ptr_desc_device = (uint8_t const *) &desc_device;
} }
void tearDown(void) void tearDown(void)
@ -114,25 +133,103 @@ void tearDown(void)
} }
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+
// // Get Descriptor
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+
//------------- Device -------------//
void test_usbd_get_device_descriptor(void) void test_usbd_get_device_descriptor(void)
{ {
desc_device = (uint8_t const *) &data_desc_device;
dcd_event_setup_received(rhport, (uint8_t*) &req_get_desc_device, false); dcd_event_setup_received(rhport, (uint8_t*) &req_get_desc_device, false);
dcd_edpt_xfer_ExpectWithArrayAndReturn(rhport, 0x80, (uint8_t*)&desc_device, sizeof(tusb_desc_device_t), sizeof(tusb_desc_device_t), true); // data
dcd_edpt_xfer_ExpectWithArrayAndReturn(rhport, 0x80, (uint8_t*)&data_desc_device, sizeof(tusb_desc_device_t), sizeof(tusb_desc_device_t), true);
dcd_event_xfer_complete(rhport, EDPT_CTRL_IN, sizeof(tusb_desc_device_t), 0, false);
// status
dcd_edpt_xfer_ExpectAndReturn(rhport, EDPT_CTRL_OUT, NULL, 0, true);
tud_task(); tud_task();
} }
void test_usbd_get_device_descriptor_null(void) void test_usbd_get_device_descriptor_null(void)
{ {
ptr_desc_device = NULL; desc_device = NULL;
dcd_event_setup_received(rhport, (uint8_t*) &req_get_desc_device, false); dcd_event_setup_received(rhport, (uint8_t*) &req_get_desc_device, false);
dcd_edpt_stall_Expect(rhport, 0); dcd_edpt_stall_Expect(rhport, EDPT_CTRL_OUT);
dcd_edpt_stall_Expect(rhport, 0x80); dcd_edpt_stall_Expect(rhport, EDPT_CTRL_IN);
tud_task();
}
//------------- Configuration -------------//
void test_usbd_get_configuration_descriptor(void)
{
desc_configuration = data_desc_configuration;
uint16_t total_len = ((tusb_desc_configuration_t const*) data_desc_configuration)->wTotalLength;
dcd_event_setup_received(rhport, (uint8_t*) &req_get_desc_configuration, false);
// data
dcd_edpt_xfer_ExpectWithArrayAndReturn(rhport, 0x80, (uint8_t*) data_desc_configuration, total_len, total_len, true);
dcd_event_xfer_complete(rhport, EDPT_CTRL_IN, total_len, 0, false);
// status
dcd_edpt_xfer_ExpectAndReturn(rhport, EDPT_CTRL_OUT, NULL, 0, true);
tud_task();
}
void test_usbd_get_configuration_descriptor_null(void)
{
desc_configuration = NULL;
dcd_event_setup_received(rhport, (uint8_t*) &req_get_desc_configuration, false);
dcd_edpt_stall_Expect(rhport, EDPT_CTRL_OUT);
dcd_edpt_stall_Expect(rhport, EDPT_CTRL_IN);
tud_task();
}
//--------------------------------------------------------------------+
// Control ZLP
//--------------------------------------------------------------------+
void test_usbd_control_in_zlp(void)
{
// 128 byte total len, with EP0 size = 64, and request length = 256
// ZLP must be return
uint8_t zlp_desc_configuration[CFG_TUD_ENDOINT0_SIZE*2] =
{
// Interface count, string index, total length, attribute, power in mA
TUD_CONFIG_DESCRIPTOR(0, 0, CFG_TUD_ENDOINT0_SIZE*2, TUSB_DESC_CONFIG_ATT_REMOTE_WAKEUP, 100),
};
desc_configuration = zlp_desc_configuration;
// request, then 1st, 2nd xact + ZLP + status
dcd_event_setup_received(rhport, (uint8_t*) &req_get_desc_configuration, false);
// 1st transaction
dcd_edpt_xfer_ExpectWithArrayAndReturn(rhport, EDPT_CTRL_IN,
zlp_desc_configuration, CFG_TUD_ENDOINT0_SIZE, CFG_TUD_ENDOINT0_SIZE, true);
dcd_event_xfer_complete(rhport, EDPT_CTRL_IN, CFG_TUD_ENDOINT0_SIZE, 0, false);
// 2nd transaction
dcd_edpt_xfer_ExpectWithArrayAndReturn(rhport, EDPT_CTRL_IN,
zlp_desc_configuration + CFG_TUD_ENDOINT0_SIZE, CFG_TUD_ENDOINT0_SIZE, CFG_TUD_ENDOINT0_SIZE, true);
dcd_event_xfer_complete(rhport, EDPT_CTRL_IN, CFG_TUD_ENDOINT0_SIZE, 0, false);
// Expect Zero length Packet
dcd_edpt_xfer_ExpectAndReturn(rhport, EDPT_CTRL_IN, NULL, 0, true);
dcd_event_xfer_complete(rhport, EDPT_CTRL_IN, 0, 0, false);
// Status
dcd_edpt_xfer_ExpectAndReturn(rhport, EDPT_CTRL_OUT, NULL, 0, true);
dcd_event_xfer_complete(rhport, EDPT_CTRL_OUT, 0, 0, false);
tud_task(); tud_task();
} }

21
test/test/support/tusb_config.h
View File

@ -41,15 +41,15 @@
#endif #endif
#if CFG_TUSB_MCU == OPT_MCU_LPC43XX || CFG_TUSB_MCU == OPT_MCU_LPC18XX #if CFG_TUSB_MCU == OPT_MCU_LPC43XX || CFG_TUSB_MCU == OPT_MCU_LPC18XX
#define CFG_TUSB_RHPORT0_MODE (OPT_MODE_DEVICE | OPT_MODE_HIGH_SPEED) #define CFG_TUSB_RHPORT0_MODE (OPT_MODE_DEVICE | OPT_MODE_HIGH_SPEED)
#else #else
#define CFG_TUSB_RHPORT0_MODE OPT_MODE_DEVICE #define CFG_TUSB_RHPORT0_MODE OPT_MODE_DEVICE
#endif #endif
#define CFG_TUSB_OS OPT_OS_NONE #define CFG_TUSB_OS OPT_OS_NONE
// CFG_TUSB_DEBUG is defined by compiler in DEBUG build // CFG_TUSB_DEBUG is defined by compiler in DEBUG build
// #define CFG_TUSB_DEBUG 0 #define CFG_TUSB_DEBUG 0
/* USB DMA on some MCUs can only access a specific SRAM region with restriction on alignment. /* USB DMA on some MCUs can only access a specific SRAM region with restriction on alignment.
* Tinyusb use follows macros to declare transferring memory so that they can be put * Tinyusb use follows macros to declare transferring memory so that they can be put
@ -63,21 +63,22 @@
#endif #endif
#ifndef CFG_TUSB_MEM_ALIGN #ifndef CFG_TUSB_MEM_ALIGN
#define CFG_TUSB_MEM_ALIGN __attribute__ ((aligned(4))) #define CFG_TUSB_MEM_ALIGN __attribute__ ((aligned(4)))
#endif #endif
//-------------------------------------------------------------------- //--------------------------------------------------------------------
// DEVICE CONFIGURATION // DEVICE CONFIGURATION
//-------------------------------------------------------------------- //--------------------------------------------------------------------
#define CFG_TUD_TASK_QUEUE_SZ 100
#define CFG_TUD_ENDOINT0_SIZE 64 #define CFG_TUD_ENDOINT0_SIZE 64
//------------- CLASS -------------// //------------- CLASS -------------//
#define CFG_TUD_CDC 0 //#define CFG_TUD_CDC 0
#define CFG_TUD_MSC 0 //#define CFG_TUD_MSC 0
#define CFG_TUD_HID 0 //#define CFG_TUD_HID 0
#define CFG_TUD_MIDI 0 //#define CFG_TUD_MIDI 0
#define CFG_TUD_VENDOR 0 //#define CFG_TUD_VENDOR 0
//------------- CDC -------------// //------------- CDC -------------//