andy/tinyUSB
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Merge pull request #2500 from hathach/add-tuh-hid-abort

Browse Source 
Add tuh hid abort
This commit is contained in:
Ha Thach
2024-03-04 15:48:44 +07:00
committed by GitHub
parent 2720392a15 4f5d80d397
commit 6a9bca9ed3
4 changed files with 251 additions and 324 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
examples/build_system/cmake/toolchain/arm_gcc.cmake
View File

@@ -1,8 +1,14 @@
set(CMAKE_SYSTEM_NAME Generic) set(CMAKE_SYSTEM_NAME Generic)
if (NOT DEFINED CMAKE_C_COMPILER)
set(CMAKE_C_COMPILER "arm-none-eabi-gcc") set(CMAKE_C_COMPILER "arm-none-eabi-gcc")
endif ()
if (NOT DEFINED CMAKE_CXX_COMPILER)
set(CMAKE_CXX_COMPILER "arm-none-eabi-g++") set(CMAKE_CXX_COMPILER "arm-none-eabi-g++")
set(CMAKE_ASM_COMPILER "arm-none-eabi-gcc") endif ()
set(CMAKE_ASM_COMPILER ${CMAKE_C_COMPILER})
set(CMAKE_SIZE "arm-none-eabi-size" CACHE FILEPATH "") set(CMAKE_SIZE "arm-none-eabi-size" CACHE FILEPATH "")
set(CMAKE_OBJCOPY "arm-none-eabi-objcopy" CACHE FILEPATH "") set(CMAKE_OBJCOPY "arm-none-eabi-objcopy" CACHE FILEPATH "")

280
src/class/hid/hid_host.c
View File

@@ -39,12 +39,11 @@
#endif #endif
#define TU_LOG_DRV(...) TU_LOG(CFG_TUH_HID_LOG_LEVEL, __VA_ARGS__) #define TU_LOG_DRV(...) TU_LOG(CFG_TUH_HID_LOG_LEVEL, __VA_ARGS__)
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+
// MACRO CONSTANT TYPEDEF // MACRO CONSTANT TYPEDEF
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+
typedef struct {
typedef struct
{
uint8_t daddr; uint8_t daddr;
uint8_t itf_num; uint8_t itf_num;
@@ -73,79 +72,57 @@ tu_static uint8_t _hidh_default_protocol = HID_PROTOCOL_BOOT;
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+
// Helper // Helper
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+
TU_ATTR_ALWAYS_INLINE static inline hidh_interface_t* get_hid_itf(uint8_t daddr, uint8_t idx) {
TU_ATTR_ALWAYS_INLINE static inline
hidh_interface_t* get_hid_itf(uint8_t daddr, uint8_t idx)
{
TU_ASSERT(daddr > 0 && idx < CFG_TUH_HID, NULL); TU_ASSERT(daddr > 0 && idx < CFG_TUH_HID, NULL);
hidh_interface_t* p_hid = &_hidh_itf[idx]; hidh_interface_t* p_hid = &_hidh_itf[idx];
return (p_hid->daddr == daddr) ? p_hid : NULL; return (p_hid->daddr == daddr) ? p_hid : NULL;
} }
// Get instance ID by endpoint address // Get instance ID by endpoint address
static uint8_t get_idx_by_epaddr(uint8_t daddr, uint8_t ep_addr) static uint8_t get_idx_by_epaddr(uint8_t daddr, uint8_t ep_addr) {
{ for (uint8_t idx = 0; idx < CFG_TUH_HID; idx++) {
for ( uint8_t idx = 0; idx < CFG_TUH_HID; idx++ )
{
hidh_interface_t const* p_hid = &_hidh_itf[idx]; hidh_interface_t const* p_hid = &_hidh_itf[idx];
if (p_hid->daddr == daddr && if (p_hid->daddr == daddr &&
(p_hid->ep_in == ep_addr || p_hid->ep_out == ep_addr) ) (p_hid->ep_in == ep_addr || p_hid->ep_out == ep_addr)) {
{
return idx; return idx;
} }
} }
return TUSB_INDEX_INVALID_8; return TUSB_INDEX_INVALID_8;
} }
static hidh_interface_t* find_new_itf(void) static hidh_interface_t* find_new_itf(void) {
{ for (uint8_t i = 0; i < CFG_TUH_HID; i++) {
for(uint8_t i=0; i<CFG_TUH_HID; i++)
{
if (_hidh_itf[i].daddr == 0) return &_hidh_itf[i]; if (_hidh_itf[i].daddr == 0) return &_hidh_itf[i];
} }
return NULL; return NULL;
} }
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+
// Interface API // Interface API
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+
uint8_t tuh_hid_itf_get_count(uint8_t daddr) {
uint8_t tuh_hid_itf_get_count(uint8_t daddr)
{
uint8_t count = 0; uint8_t count = 0;
for (uint8_t i = 0; i < CFG_TUH_HID; i++) {
for(uint8_t i=0; i<CFG_TUH_HID; i++)
{
if (_hidh_itf[i].daddr == daddr) count++; if (_hidh_itf[i].daddr == daddr) count++;
} }
return count; return count;
} }
uint8_t tuh_hid_itf_get_total_count(void) uint8_t tuh_hid_itf_get_total_count(void) {
{
uint8_t count = 0; uint8_t count = 0;
for (uint8_t i = 0; i < CFG_TUH_HID; i++) {
for(uint8_t i=0; i<CFG_TUH_HID; i++)
{
if (_hidh_itf[i].daddr != 0) count++; if (_hidh_itf[i].daddr != 0) count++;
} }
return count; return count;
} }
bool tuh_hid_mounted(uint8_t daddr, uint8_t idx) bool tuh_hid_mounted(uint8_t daddr, uint8_t idx) {
{
hidh_interface_t* p_hid = get_hid_itf(daddr, idx); hidh_interface_t* p_hid = get_hid_itf(daddr, idx);
TU_VERIFY(p_hid); TU_VERIFY(p_hid);
return p_hid->mounted; return p_hid->mounted;
} }
bool tuh_hid_itf_get_info(uint8_t daddr, uint8_t idx, tuh_itf_info_t* info) bool tuh_hid_itf_get_info(uint8_t daddr, uint8_t idx, tuh_itf_info_t* info) {
{
hidh_interface_t* p_hid = get_hid_itf(daddr, idx); hidh_interface_t* p_hid = get_hid_itf(daddr, idx);
TU_VERIFY(p_hid && info); TU_VERIFY(p_hid && info);
@@ -167,20 +144,16 @@ bool tuh_hid_itf_get_info(uint8_t daddr, uint8_t idx, tuh_itf_info_t* info)
return true; return true;
} }
uint8_t tuh_hid_itf_get_index(uint8_t daddr, uint8_t itf_num) uint8_t tuh_hid_itf_get_index(uint8_t daddr, uint8_t itf_num) {
{ for (uint8_t idx = 0; idx < CFG_TUH_HID; idx++) {
for ( uint8_t idx = 0; idx < CFG_TUH_HID; idx++ )
{
hidh_interface_t const* p_hid = &_hidh_itf[idx]; hidh_interface_t const* p_hid = &_hidh_itf[idx];
if (p_hid->daddr == daddr && p_hid->itf_num == itf_num) return idx; if (p_hid->daddr == daddr && p_hid->itf_num == itf_num) return idx;
} }
return TUSB_INDEX_INVALID_8; return TUSB_INDEX_INVALID_8;
} }
uint8_t tuh_hid_interface_protocol(uint8_t daddr, uint8_t idx) uint8_t tuh_hid_interface_protocol(uint8_t daddr, uint8_t idx) {
{
hidh_interface_t* p_hid = get_hid_itf(daddr, idx); hidh_interface_t* p_hid = get_hid_itf(daddr, idx);
return p_hid ? p_hid->itf_protocol : 0; return p_hid ? p_hid->itf_protocol : 0;
} }
@@ -188,15 +161,12 @@ uint8_t tuh_hid_interface_protocol(uint8_t daddr, uint8_t idx)
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+
// Control Endpoint API // Control Endpoint API
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+
uint8_t tuh_hid_get_protocol(uint8_t daddr, uint8_t idx) {
uint8_t tuh_hid_get_protocol(uint8_t daddr, uint8_t idx)
{
hidh_interface_t* p_hid = get_hid_itf(daddr, idx); hidh_interface_t* p_hid = get_hid_itf(daddr, idx);
return p_hid ? p_hid->protocol_mode : 0; return p_hid ? p_hid->protocol_mode : 0;
} }
static void set_protocol_complete(tuh_xfer_t* xfer) static void set_protocol_complete(tuh_xfer_t* xfer) {
{
uint8_t const itf_num = (uint8_t) tu_le16toh(xfer->setup->wIndex); uint8_t const itf_num = (uint8_t) tu_le16toh(xfer->setup->wIndex);
uint8_t const daddr = xfer->daddr; uint8_t const daddr = xfer->daddr;
uint8_t const idx = tuh_hid_itf_get_index(daddr, itf_num); uint8_t const idx = tuh_hid_itf_get_index(daddr, itf_num);
@@ -204,13 +174,11 @@ static void set_protocol_complete(tuh_xfer_t* xfer)
hidh_interface_t* p_hid = get_hid_itf(daddr, idx); hidh_interface_t* p_hid = get_hid_itf(daddr, idx);
TU_VERIFY(p_hid,); TU_VERIFY(p_hid,);
if (XFER_RESULT_SUCCESS == xfer->result) if (XFER_RESULT_SUCCESS == xfer->result) {
{
p_hid->protocol_mode = (uint8_t) tu_le16toh(xfer->setup->wValue); p_hid->protocol_mode = (uint8_t) tu_le16toh(xfer->setup->wValue);
} }
if (tuh_hid_set_protocol_complete_cb) if (tuh_hid_set_protocol_complete_cb) {
{
tuh_hid_set_protocol_complete_cb(daddr, idx, p_hid->protocol_mode); tuh_hid_set_protocol_complete_cb(daddr, idx, p_hid->protocol_mode);
} }
} }
@@ -219,14 +187,12 @@ void tuh_hid_set_default_protocol(uint8_t protocol) {
_hidh_default_protocol = protocol; _hidh_default_protocol = protocol;
} }
static bool _hidh_set_protocol(uint8_t daddr, uint8_t itf_num, uint8_t protocol, tuh_xfer_cb_t complete_cb, uintptr_t user_data) static bool _hidh_set_protocol(uint8_t daddr, uint8_t itf_num, uint8_t protocol,
{ tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
TU_LOG_DRV("HID Set Protocol = %d\r\n", protocol); TU_LOG_DRV("HID Set Protocol = %d\r\n", protocol);
tusb_control_request_t const request = tusb_control_request_t const request = {
{ .bmRequestType_bit = {
.bmRequestType_bit =
{
.recipient = TUSB_REQ_RCPT_INTERFACE, .recipient = TUSB_REQ_RCPT_INTERFACE,
.type = TUSB_REQ_TYPE_CLASS, .type = TUSB_REQ_TYPE_CLASS,
.direction = TUSB_DIR_OUT .direction = TUSB_DIR_OUT
@@ -237,8 +203,7 @@ static bool _hidh_set_protocol(uint8_t daddr, uint8_t itf_num, uint8_t protocol,
.wLength = 0 .wLength = 0
}; };
tuh_xfer_t xfer = tuh_xfer_t xfer = {
{
.daddr = daddr, .daddr = daddr,
.ep_addr = 0, .ep_addr = 0,
.setup = &request, .setup = &request,
@@ -250,20 +215,17 @@ static bool _hidh_set_protocol(uint8_t daddr, uint8_t itf_num, uint8_t protocol,
return tuh_control_xfer(&xfer); return tuh_control_xfer(&xfer);
} }
bool tuh_hid_set_protocol(uint8_t daddr, uint8_t idx, uint8_t protocol) bool tuh_hid_set_protocol(uint8_t daddr, uint8_t idx, uint8_t protocol) {
{
hidh_interface_t* p_hid = get_hid_itf(daddr, idx); hidh_interface_t* p_hid = get_hid_itf(daddr, idx);
TU_VERIFY(p_hid && p_hid->itf_protocol != HID_ITF_PROTOCOL_NONE); TU_VERIFY(p_hid && p_hid->itf_protocol != HID_ITF_PROTOCOL_NONE);
return _hidh_set_protocol(daddr, p_hid->itf_num, protocol, set_protocol_complete, 0); return _hidh_set_protocol(daddr, p_hid->itf_num, protocol, set_protocol_complete, 0);
} }
static void set_report_complete(tuh_xfer_t* xfer) static void set_report_complete(tuh_xfer_t* xfer) {
{
TU_LOG_DRV("HID Set Report complete\r\n"); TU_LOG_DRV("HID Set Report complete\r\n");
if (tuh_hid_set_report_complete_cb) if (tuh_hid_set_report_complete_cb) {
{
uint8_t const itf_num = (uint8_t) tu_le16toh(xfer->setup->wIndex); uint8_t const itf_num = (uint8_t) tu_le16toh(xfer->setup->wIndex);
uint8_t const idx = tuh_hid_itf_get_index(xfer->daddr, itf_num); uint8_t const idx = tuh_hid_itf_get_index(xfer->daddr, itf_num);
@@ -275,17 +237,13 @@ static void set_report_complete(tuh_xfer_t* xfer)
} }
} }
bool tuh_hid_set_report(uint8_t daddr, uint8_t idx, uint8_t report_id, uint8_t report_type, void* report, uint16_t len) bool tuh_hid_set_report(uint8_t daddr, uint8_t idx, uint8_t report_id, uint8_t report_type, void* report, uint16_t len) {
{
hidh_interface_t* p_hid = get_hid_itf(daddr, idx); hidh_interface_t* p_hid = get_hid_itf(daddr, idx);
TU_VERIFY(p_hid); TU_VERIFY(p_hid);
TU_LOG_DRV("HID Set Report: id = %u, type = %u, len = %u\r\n", report_id, report_type, len); TU_LOG_DRV("HID Set Report: id = %u, type = %u, len = %u\r\n", report_id, report_type, len);
tusb_control_request_t const request = tusb_control_request_t const request = {
{ .bmRequestType_bit = {
.bmRequestType_bit =
{
.recipient = TUSB_REQ_RCPT_INTERFACE, .recipient = TUSB_REQ_RCPT_INTERFACE,
.type = TUSB_REQ_TYPE_CLASS, .type = TUSB_REQ_TYPE_CLASS,
.direction = TUSB_DIR_OUT .direction = TUSB_DIR_OUT
@@ -296,8 +254,7 @@ bool tuh_hid_set_report(uint8_t daddr, uint8_t idx, uint8_t report_id, uint8_t r
.wLength = len .wLength = len
}; };
tuh_xfer_t xfer = tuh_xfer_t xfer = {
{
.daddr = daddr, .daddr = daddr,
.ep_addr = 0, .ep_addr = 0,
.setup = &request, .setup = &request,
@@ -309,15 +266,13 @@ bool tuh_hid_set_report(uint8_t daddr, uint8_t idx, uint8_t report_id, uint8_t r
return tuh_control_xfer(&xfer); return tuh_control_xfer(&xfer);
} }
static bool _hidh_set_idle(uint8_t daddr, uint8_t itf_num, uint16_t idle_rate, tuh_xfer_cb_t complete_cb, uintptr_t user_data) static bool _hidh_set_idle(uint8_t daddr, uint8_t itf_num, uint16_t idle_rate,
{ tuh_xfer_cb_t complete_cb, uintptr_t user_data) {
// SET IDLE request, device can stall if not support this request // SET IDLE request, device can stall if not support this request
TU_LOG_DRV("HID Set Idle \r\n"); TU_LOG_DRV("HID Set Idle \r\n");
tusb_control_request_t const request = tusb_control_request_t const request = {
{ .bmRequestType_bit = {
.bmRequestType_bit =
{
.recipient = TUSB_REQ_RCPT_INTERFACE, .recipient = TUSB_REQ_RCPT_INTERFACE,
.type = TUSB_REQ_TYPE_CLASS, .type = TUSB_REQ_TYPE_CLASS,
.direction = TUSB_DIR_OUT .direction = TUSB_DIR_OUT
@@ -328,8 +283,7 @@ static bool _hidh_set_idle(uint8_t daddr, uint8_t itf_num, uint16_t idle_rate, t
.wLength = 0 .wLength = 0
}; };
tuh_xfer_t xfer = tuh_xfer_t xfer = {
{
.daddr = daddr, .daddr = daddr,
.ep_addr = 0, .ep_addr = 0,
.setup = &request, .setup = &request,
@@ -346,54 +300,49 @@ static bool _hidh_set_idle(uint8_t daddr, uint8_t itf_num, uint16_t idle_rate, t
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+
// Check if HID interface is ready to receive report // Check if HID interface is ready to receive report
bool tuh_hid_receive_ready(uint8_t dev_addr, uint8_t idx) bool tuh_hid_receive_ready(uint8_t dev_addr, uint8_t idx) {
{
hidh_interface_t* p_hid = get_hid_itf(dev_addr, idx); hidh_interface_t* p_hid = get_hid_itf(dev_addr, idx);
TU_VERIFY(p_hid); TU_VERIFY(p_hid);
return !usbh_edpt_busy(dev_addr, p_hid->ep_in); return !usbh_edpt_busy(dev_addr, p_hid->ep_in);
} }
bool tuh_hid_receive_report(uint8_t daddr, uint8_t idx) bool tuh_hid_receive_report(uint8_t daddr, uint8_t idx) {
{
hidh_interface_t* p_hid = get_hid_itf(daddr, idx); hidh_interface_t* p_hid = get_hid_itf(daddr, idx);
TU_VERIFY(p_hid); TU_VERIFY(p_hid);
// claim endpoint // claim endpoint
TU_VERIFY(usbh_edpt_claim(daddr, p_hid->ep_in)); TU_VERIFY(usbh_edpt_claim(daddr, p_hid->ep_in));
if ( !usbh_edpt_xfer(daddr, p_hid->ep_in, p_hid->epin_buf, p_hid->epin_size) ) if (!usbh_edpt_xfer(daddr, p_hid->ep_in, p_hid->epin_buf, p_hid->epin_size)) {
{
usbh_edpt_release(daddr, p_hid->ep_in); usbh_edpt_release(daddr, p_hid->ep_in);
return false; return false;
} }
return true; return true;
} }
bool tuh_hid_receive_abort(uint8_t dev_addr, uint8_t idx) {
bool tuh_hid_send_ready(uint8_t dev_addr, uint8_t idx)
{
hidh_interface_t* p_hid = get_hid_itf(dev_addr, idx); hidh_interface_t* p_hid = get_hid_itf(dev_addr, idx);
TU_VERIFY(p_hid); TU_VERIFY(p_hid);
return tuh_edpt_abort_xfer(dev_addr, p_hid->ep_in);
}
bool tuh_hid_send_ready(uint8_t dev_addr, uint8_t idx) {
hidh_interface_t* p_hid = get_hid_itf(dev_addr, idx);
TU_VERIFY(p_hid);
return !usbh_edpt_busy(dev_addr, p_hid->ep_out); return !usbh_edpt_busy(dev_addr, p_hid->ep_out);
} }
bool tuh_hid_send_report(uint8_t daddr, uint8_t idx, uint8_t report_id, const void* report, uint16_t len) bool tuh_hid_send_report(uint8_t daddr, uint8_t idx, uint8_t report_id, const void* report, uint16_t len) {
{
TU_LOG_DRV("HID Send Report %d\r\n", report_id); TU_LOG_DRV("HID Send Report %d\r\n", report_id);
hidh_interface_t* p_hid = get_hid_itf(daddr, idx); hidh_interface_t* p_hid = get_hid_itf(daddr, idx);
TU_VERIFY(p_hid); TU_VERIFY(p_hid);
if (p_hid->ep_out == 0) if (p_hid->ep_out == 0) {
{
// This HID does not have an out endpoint (other than control) // This HID does not have an out endpoint (other than control)
return false; return false;
} } else if (len > CFG_TUH_HID_EPOUT_BUFSIZE ||
else if (len > CFG_TUH_HID_EPOUT_BUFSIZE || (report_id != 0 && len > (CFG_TUH_HID_EPOUT_BUFSIZE - 1))) {
(report_id != 0 && len > (CFG_TUH_HID_EPOUT_BUFSIZE - 1)))
{
// ep_out buffer is not large enough to hold contents // ep_out buffer is not large enough to hold contents
return false; return false;
} }
@@ -401,13 +350,10 @@ bool tuh_hid_send_report(uint8_t daddr, uint8_t idx, uint8_t report_id, const vo
// claim endpoint // claim endpoint
TU_VERIFY(usbh_edpt_claim(daddr, p_hid->ep_out)); TU_VERIFY(usbh_edpt_claim(daddr, p_hid->ep_out));
if (report_id == 0) if (report_id == 0) {
{
// No report ID in transmission // No report ID in transmission
memcpy(&p_hid->epout_buf[0], report, len); memcpy(&p_hid->epout_buf[0], report, len);
} } else {
else
{
p_hid->epout_buf[0] = report_id; p_hid->epout_buf[0] = report_id;
memcpy(&p_hid->epout_buf[1], report, len); memcpy(&p_hid->epout_buf[1], report, len);
++len; // 1 more byte for report_id ++len; // 1 more byte for report_id
@@ -415,8 +361,7 @@ bool tuh_hid_send_report(uint8_t daddr, uint8_t idx, uint8_t report_id, const vo
TU_LOG3_MEM(p_hid->epout_buf, len, 2); TU_LOG3_MEM(p_hid->epout_buf, len, 2);
if ( !usbh_edpt_xfer(daddr, p_hid->ep_out, p_hid->epout_buf, len) ) if (!usbh_edpt_xfer(daddr, p_hid->ep_out, p_hid->epout_buf, len)) {
{
usbh_edpt_release(daddr, p_hid->ep_out); usbh_edpt_release(daddr, p_hid->ep_out);
return false; return false;
} }
@@ -427,13 +372,11 @@ bool tuh_hid_send_report(uint8_t daddr, uint8_t idx, uint8_t report_id, const vo
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+
// USBH API // USBH API
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+
void hidh_init(void) void hidh_init(void) {
{
tu_memclr(_hidh_itf, sizeof(_hidh_itf)); tu_memclr(_hidh_itf, sizeof(_hidh_itf));
} }
bool hidh_xfer_cb(uint8_t daddr, uint8_t ep_addr, xfer_result_t result, uint32_t xferred_bytes) bool hidh_xfer_cb(uint8_t daddr, uint8_t ep_addr, xfer_result_t result, uint32_t xferred_bytes) {
{
(void) result; (void) result;
uint8_t const dir = tu_edpt_dir(ep_addr); uint8_t const dir = tu_edpt_dir(ep_addr);
@@ -442,26 +385,23 @@ bool hidh_xfer_cb(uint8_t daddr, uint8_t ep_addr, xfer_result_t result, uint32_t
hidh_interface_t* p_hid = get_hid_itf(daddr, idx); hidh_interface_t* p_hid = get_hid_itf(daddr, idx);
TU_VERIFY(p_hid); TU_VERIFY(p_hid);
if ( dir == TUSB_DIR_IN ) if (dir == TUSB_DIR_IN) {
{
TU_LOG_DRV(" Get Report callback (%u, %u)\r\n", daddr, idx); TU_LOG_DRV(" Get Report callback (%u, %u)\r\n", daddr, idx);
TU_LOG3_MEM(p_hid->epin_buf, xferred_bytes, 2); TU_LOG3_MEM(p_hid->epin_buf, xferred_bytes, 2);
tuh_hid_report_received_cb(daddr, idx, p_hid->epin_buf, (uint16_t) xferred_bytes); tuh_hid_report_received_cb(daddr, idx, p_hid->epin_buf, (uint16_t) xferred_bytes);
}else } else {
{ if (tuh_hid_report_sent_cb) {
if (tuh_hid_report_sent_cb) tuh_hid_report_sent_cb(daddr, idx, p_hid->epout_buf, (uint16_t) xferred_bytes); tuh_hid_report_sent_cb(daddr, idx, p_hid->epout_buf, (uint16_t) xferred_bytes);
}
} }
return true; return true;
} }
void hidh_close(uint8_t daddr) void hidh_close(uint8_t daddr) {
{ for (uint8_t i = 0; i < CFG_TUH_HID; i++) {
for(uint8_t i=0; i<CFG_TUH_HID; i++)
{
hidh_interface_t* p_hid = &_hidh_itf[i]; hidh_interface_t* p_hid = &_hidh_itf[i];
if (p_hid->daddr == daddr) if (p_hid->daddr == daddr) {
{
TU_LOG_DRV(" HIDh close addr = %u index = %u\r\n", daddr, i); TU_LOG_DRV(" HIDh close addr = %u index = %u\r\n", daddr, i);
if (tuh_hid_umount_cb) tuh_hid_umount_cb(daddr, i); if (tuh_hid_umount_cb) tuh_hid_umount_cb(daddr, i);
p_hid->daddr = 0; p_hid->daddr = 0;
@@ -474,20 +414,17 @@ void hidh_close(uint8_t daddr)
// Enumeration // Enumeration
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+
bool hidh_open(uint8_t rhport, uint8_t daddr, tusb_desc_interface_t const *desc_itf, uint16_t max_len) bool hidh_open(uint8_t rhport, uint8_t daddr, tusb_desc_interface_t const* desc_itf, uint16_t max_len) {
{
(void) rhport; (void) rhport;
(void) max_len; (void) max_len;
TU_VERIFY(TUSB_CLASS_HID == desc_itf->bInterfaceClass); TU_VERIFY(TUSB_CLASS_HID == desc_itf->bInterfaceClass);
TU_LOG_DRV("[%u] HID opening Interface %u\r\n", daddr, desc_itf->bInterfaceNumber); TU_LOG_DRV("[%u] HID opening Interface %u\r\n", daddr, desc_itf->bInterfaceNumber);
// len = interface + hid + n*endpoints // len = interface + hid + n*endpoints
uint16_t const drv_len = (uint16_t) (sizeof(tusb_desc_interface_t) + sizeof(tusb_hid_descriptor_hid_t) + uint16_t const drv_len = (uint16_t) (sizeof(tusb_desc_interface_t) + sizeof(tusb_hid_descriptor_hid_t) +
desc_itf->bNumEndpoints * sizeof(tusb_desc_endpoint_t)); desc_itf->bNumEndpoints * sizeof(tusb_desc_endpoint_t));
TU_ASSERT(max_len >= drv_len); TU_ASSERT(max_len >= drv_len);
uint8_t const* p_desc = (uint8_t const*) desc_itf; uint8_t const* p_desc = (uint8_t const*) desc_itf;
//------------- HID descriptor -------------// //------------- HID descriptor -------------//
@@ -503,18 +440,14 @@ bool hidh_open(uint8_t rhport, uint8_t daddr, tusb_desc_interface_t const *desc_
p_desc = tu_desc_next(p_desc); p_desc = tu_desc_next(p_desc);
tusb_desc_endpoint_t const* desc_ep = (tusb_desc_endpoint_t const*) p_desc; tusb_desc_endpoint_t const* desc_ep = (tusb_desc_endpoint_t const*) p_desc;
for(int i = 0; i < desc_itf->bNumEndpoints; i++) for (int i = 0; i < desc_itf->bNumEndpoints; i++) {
{
TU_ASSERT(TUSB_DESC_ENDPOINT == desc_ep->bDescriptorType); TU_ASSERT(TUSB_DESC_ENDPOINT == desc_ep->bDescriptorType);
TU_ASSERT(tuh_edpt_open(daddr, desc_ep)); TU_ASSERT(tuh_edpt_open(daddr, desc_ep));
if(tu_edpt_dir(desc_ep->bEndpointAddress) == TUSB_DIR_IN) if (tu_edpt_dir(desc_ep->bEndpointAddress) == TUSB_DIR_IN) {
{
p_hid->ep_in = desc_ep->bEndpointAddress; p_hid->ep_in = desc_ep->bEndpointAddress;
p_hid->epin_size = tu_edpt_packet_size(desc_ep); p_hid->epin_size = tu_edpt_packet_size(desc_ep);
} } else {
else
{
p_hid->ep_out = desc_ep->bEndpointAddress; p_hid->ep_out = desc_ep->bEndpointAddress;
p_hid->epout_size = tu_edpt_packet_size(desc_ep); p_hid->epout_size = tu_edpt_packet_size(desc_ep);
} }
@@ -531,8 +464,7 @@ bool hidh_open(uint8_t rhport, uint8_t daddr, tusb_desc_interface_t const *desc_
// Per HID Specs: default is Report protocol, though we will force Boot protocol when set_config // Per HID Specs: default is Report protocol, though we will force Boot protocol when set_config
p_hid->protocol_mode = _hidh_default_protocol; p_hid->protocol_mode = _hidh_default_protocol;
if ( HID_SUBCLASS_BOOT == desc_itf->bInterfaceSubClass ) if (HID_SUBCLASS_BOOT == desc_itf->bInterfaceSubClass) {
{
p_hid->itf_protocol = desc_itf->bInterfaceProtocol; p_hid->itf_protocol = desc_itf->bInterfaceProtocol;
} }
@@ -553,8 +485,7 @@ enum {
static void config_driver_mount_complete(uint8_t daddr, uint8_t idx, uint8_t const* desc_report, uint16_t desc_len); static void config_driver_mount_complete(uint8_t daddr, uint8_t idx, uint8_t const* desc_report, uint16_t desc_len);
static void process_set_config(tuh_xfer_t* xfer); static void process_set_config(tuh_xfer_t* xfer);
bool hidh_set_config(uint8_t daddr, uint8_t itf_num) bool hidh_set_config(uint8_t daddr, uint8_t itf_num) {
{
tusb_control_request_t request; tusb_control_request_t request;
request.wIndex = tu_htole16((uint16_t) itf_num); request.wIndex = tu_htole16((uint16_t) itf_num);
@@ -570,13 +501,11 @@ bool hidh_set_config(uint8_t daddr, uint8_t itf_num)
return true; return true;
} }
static void process_set_config(tuh_xfer_t* xfer) static void process_set_config(tuh_xfer_t* xfer) {
{
// Stall is a valid response for SET_IDLE, sometime SET_PROTOCOL as well // Stall is a valid response for SET_IDLE, sometime SET_PROTOCOL as well
// therefore we could ignore its result // therefore we could ignore its result
if (!(xfer->setup->bRequest == HID_REQ_CONTROL_SET_IDLE || if (!(xfer->setup->bRequest == HID_REQ_CONTROL_SET_IDLE ||
xfer->setup->bRequest == HID_REQ_CONTROL_SET_PROTOCOL) ) xfer->setup->bRequest == HID_REQ_CONTROL_SET_PROTOCOL)) {
{
TU_ASSERT(xfer->result == XFER_RESULT_SUCCESS,); TU_ASSERT(xfer->result == XFER_RESULT_SUCCESS,);
} }
@@ -588,16 +517,15 @@ static void process_set_config(tuh_xfer_t* xfer)
hidh_interface_t* p_hid = get_hid_itf(daddr, idx); hidh_interface_t* p_hid = get_hid_itf(daddr, idx);
TU_VERIFY(p_hid,); TU_VERIFY(p_hid,);
switch(state) switch (state) {
{ case CONFG_SET_IDLE: {
case CONFG_SET_IDLE:
{
// Idle rate = 0 mean only report when there is changes // Idle rate = 0 mean only report when there is changes
const uint16_t idle_rate = 0; const uint16_t idle_rate = 0;
const uintptr_t next_state = (p_hid->itf_protocol != HID_ITF_PROTOCOL_NONE) ? CONFIG_SET_PROTOCOL : CONFIG_GET_REPORT_DESC; const uintptr_t next_state = (p_hid->itf_protocol != HID_ITF_PROTOCOL_NONE)
? CONFIG_SET_PROTOCOL : CONFIG_GET_REPORT_DESC;
_hidh_set_idle(daddr, itf_num, idle_rate, process_set_config, next_state); _hidh_set_idle(daddr, itf_num, idle_rate, process_set_config, next_state);
}
break; break;
}
case CONFIG_SET_PROTOCOL: case CONFIG_SET_PROTOCOL:
_hidh_set_protocol(daddr, p_hid->itf_num, _hidh_default_protocol, process_set_config, CONFIG_GET_REPORT_DESC); _hidh_set_protocol(daddr, p_hid->itf_num, _hidh_default_protocol, process_set_config, CONFIG_GET_REPORT_DESC);
@@ -606,33 +534,32 @@ static void process_set_config(tuh_xfer_t* xfer)
case CONFIG_GET_REPORT_DESC: case CONFIG_GET_REPORT_DESC:
// Get Report Descriptor if possible // Get Report Descriptor if possible
// using usbh enumeration buffer since report descriptor can be very long // using usbh enumeration buffer since report descriptor can be very long
if( p_hid->report_desc_len > CFG_TUH_ENUMERATION_BUFSIZE ) if (p_hid->report_desc_len > CFG_TUH_ENUMERATION_BUFSIZE) {
{
TU_LOG_DRV("HID Skip Report Descriptor since it is too large %u bytes\r\n", p_hid->report_desc_len); TU_LOG_DRV("HID Skip Report Descriptor since it is too large %u bytes\r\n", p_hid->report_desc_len);
// Driver is mounted without report descriptor // Driver is mounted without report descriptor
config_driver_mount_complete(daddr, idx, NULL, 0); config_driver_mount_complete(daddr, idx, NULL, 0);
}else } else {
{ tuh_descriptor_get_hid_report(daddr, itf_num, p_hid->report_desc_type, 0,
tuh_descriptor_get_hid_report(daddr, itf_num, p_hid->report_desc_type, 0, usbh_get_enum_buf(), p_hid->report_desc_len, process_set_config, CONFIG_COMPLETE); usbh_get_enum_buf(), p_hid->report_desc_len,
process_set_config, CONFIG_COMPLETE);
} }
break; break;
case CONFIG_COMPLETE: case CONFIG_COMPLETE: {
{
uint8_t const* desc_report = usbh_get_enum_buf(); uint8_t const* desc_report = usbh_get_enum_buf();
uint16_t const desc_len = tu_le16toh(xfer->setup->wLength); uint16_t const desc_len = tu_le16toh(xfer->setup->wLength);
config_driver_mount_complete(daddr, idx, desc_report, desc_len); config_driver_mount_complete(daddr, idx, desc_report, desc_len);
}
break; break;
}
default: break; default:
break;
} }
} }
static void config_driver_mount_complete(uint8_t daddr, uint8_t idx, uint8_t const* desc_report, uint16_t desc_len) static void config_driver_mount_complete(uint8_t daddr, uint8_t idx, uint8_t const* desc_report, uint16_t desc_len) {
{
hidh_interface_t* p_hid = get_hid_itf(daddr, idx); hidh_interface_t* p_hid = get_hid_itf(daddr, idx);
TU_VERIFY(p_hid,); TU_VERIFY(p_hid,);
p_hid->mounted = true; p_hid->mounted = true;
@@ -648,14 +575,12 @@ static void config_driver_mount_complete(uint8_t daddr, uint8_t idx, uint8_t con
// Report Descriptor Parser // Report Descriptor Parser
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+
uint8_t tuh_hid_parse_report_descriptor(tuh_hid_report_info_t* report_info_arr, uint8_t arr_count, uint8_t const* desc_report, uint16_t desc_len) uint8_t tuh_hid_parse_report_descriptor(tuh_hid_report_info_t* report_info_arr, uint8_t arr_count,
{ uint8_t const* desc_report, uint16_t desc_len) {
// Report Item 6.2.2.2 USB HID 1.11 // Report Item 6.2.2.2 USB HID 1.11
union TU_ATTR_PACKED union TU_ATTR_PACKED {
{
uint8_t byte; uint8_t byte;
struct TU_ATTR_PACKED struct TU_ATTR_PACKED {
{
uint8_t size : 2; uint8_t size : 2;
uint8_t type : 2; uint8_t type : 2;
uint8_t tag : 4; uint8_t tag : 4;
@@ -672,9 +597,7 @@ uint8_t tuh_hid_parse_report_descriptor(tuh_hid_report_info_t* report_info_arr,
// uint8_t ri_report_size = 0; // uint8_t ri_report_size = 0;
uint8_t ri_collection_depth = 0; uint8_t ri_collection_depth = 0;
while (desc_len && report_num < arr_count) {
while(desc_len && report_num < arr_count)
{
header.byte = *desc_report++; header.byte = *desc_report++;
desc_len--; desc_len--;
@@ -688,23 +611,19 @@ uint8_t tuh_hid_parse_report_descriptor(tuh_hid_report_info_t* report_info_arr,
for (uint32_t i = 0; i < size; i++) TU_LOG(3, "%02X ", desc_report[i]); for (uint32_t i = 0; i < size; i++) TU_LOG(3, "%02X ", desc_report[i]);
TU_LOG(3, "\r\n"); TU_LOG(3, "\r\n");
switch(type) switch (type) {
{
case RI_TYPE_MAIN: case RI_TYPE_MAIN:
switch (tag) switch (tag) {
{
case RI_MAIN_INPUT: break; case RI_MAIN_INPUT: break;
case RI_MAIN_OUTPUT: break; case RI_MAIN_OUTPUT: break;
case RI_MAIN_FEATURE: break; case RI_MAIN_FEATURE: break;
case RI_MAIN_COLLECTION: case RI_MAIN_COLLECTION:
ri_collection_depth++; ri_collection_depth++;
break; break;
case RI_MAIN_COLLECTION_END: case RI_MAIN_COLLECTION_END:
ri_collection_depth--; ri_collection_depth--;
if (ri_collection_depth == 0) if (ri_collection_depth == 0) {
{
info++; info++;
report_num++; report_num++;
} }
@@ -715,8 +634,7 @@ uint8_t tuh_hid_parse_report_descriptor(tuh_hid_report_info_t* report_info_arr,
break; break;
case RI_TYPE_GLOBAL: case RI_TYPE_GLOBAL:
switch(tag) switch (tag) {
{
case RI_GLOBAL_USAGE_PAGE: case RI_GLOBAL_USAGE_PAGE:
// only take in account the "usage page" before REPORT ID // only take in account the "usage page" before REPORT ID
if (ri_collection_depth == 0) memcpy(&info->usage_page, desc_report, size); if (ri_collection_depth == 0) memcpy(&info->usage_page, desc_report, size);
@@ -749,8 +667,7 @@ uint8_t tuh_hid_parse_report_descriptor(tuh_hid_report_info_t* report_info_arr,
break; break;
case RI_TYPE_LOCAL: case RI_TYPE_LOCAL:
switch(tag) switch (tag) {
{
case RI_LOCAL_USAGE: case RI_LOCAL_USAGE:
// only take in account the "usage" before starting REPORT ID // only take in account the "usage" before starting REPORT ID
if (ri_collection_depth == 0) info->usage = data8; if (ri_collection_depth == 0) info->usage = data8;
@@ -777,8 +694,7 @@ uint8_t tuh_hid_parse_report_descriptor(tuh_hid_report_info_t* report_info_arr,
desc_len -= size; desc_len -= size;
} }
for ( uint8_t i = 0; i < report_num; i++ ) for (uint8_t i = 0; i < report_num; i++) {
{
info = report_info_arr + i; info = report_info_arr + i;
TU_LOG_DRV("%u: id = %u, usage_page = %u, usage = %u\r\n", i, info->report_id, info->usage_page, info->usage); TU_LOG_DRV("%u: id = %u, usage_page = %u, usage = %u\r\n", i, info->report_id, info->usage_page, info->usage);
} }

12
src/class/hid/hid_host.h
View File

@@ -47,8 +47,7 @@
#endif #endif
typedef struct typedef struct {
{
uint8_t report_id; uint8_t report_id;
uint8_t usage; uint8_t usage;
uint16_t usage_page; uint16_t usage_page;
@@ -86,7 +85,8 @@ bool tuh_hid_mounted(uint8_t dev_addr, uint8_t idx);
// Parse report descriptor into array of report_info struct and return number of reports. // Parse report descriptor into array of report_info struct and return number of reports.
// For complicated report, application should write its own parser. // For complicated report, application should write its own parser.
uint8_t tuh_hid_parse_report_descriptor(tuh_hid_report_info_t* reports_info_arr, uint8_t arr_count, uint8_t const* desc_report, uint16_t desc_len) TU_ATTR_UNUSED; TU_ATTR_UNUSED uint8_t tuh_hid_parse_report_descriptor(tuh_hid_report_info_t* reports_info_arr, uint8_t arr_count,
uint8_t const* desc_report, uint16_t desc_len);
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+
// Control Endpoint API // Control Endpoint API
@@ -107,7 +107,8 @@ bool tuh_hid_set_protocol(uint8_t dev_addr, uint8_t idx, uint8_t protocol);
// Set Report using control endpoint // Set Report using control endpoint
// report_type is either Input, Output or Feature, (value from hid_report_type_t) // report_type is either Input, Output or Feature, (value from hid_report_type_t)
bool tuh_hid_set_report(uint8_t dev_addr, uint8_t idx, uint8_t report_id, uint8_t report_type, void* report, uint16_t len); bool tuh_hid_set_report(uint8_t dev_addr, uint8_t idx, uint8_t report_id, uint8_t report_type,
void* report, uint16_t len);
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+
// Interrupt Endpoint API // Interrupt Endpoint API
@@ -121,6 +122,9 @@ bool tuh_hid_receive_ready(uint8_t dev_addr, uint8_t idx);
// - false if failed to queue the transfer e.g endpoint is busy // - false if failed to queue the transfer e.g endpoint is busy
bool tuh_hid_receive_report(uint8_t dev_addr, uint8_t idx); bool tuh_hid_receive_report(uint8_t dev_addr, uint8_t idx);
// Abort receiving report on Interrupt Endpoint
bool tuh_hid_receive_abort(uint8_t dev_addr, uint8_t idx);
// Check if HID interface is ready to send report // Check if HID interface is ready to send report
bool tuh_hid_send_ready(uint8_t dev_addr, uint8_t idx); bool tuh_hid_send_ready(uint8_t dev_addr, uint8_t idx);

13
test/unit-test/project.yml
View File

@@ -44,12 +44,13 @@
# in order to add common defines: # in order to add common defines:
# 1) remove the trailing [] from the :common: section # 1) remove the trailing [] from the :common: section
# 2) add entries to the :common: section (e.g. :test: has TEST defined) # 2) add entries to the :common: section (e.g. :test: has TEST defined)
:common: &common_defines :common: &common_defines []
- _UNITY_TEST_
:test: :test:
- *common_defines - _UNITY_TEST_
#- *common_defines
:test_preprocess: :test_preprocess:
- *common_defines - _UNITY_TEST_
#- *common_defines
:cmock: :cmock:
:mock_prefix: mock_ :mock_prefix: mock_
@@ -106,9 +107,9 @@
:flag: "${1}" # or "-L ${1}" for example :flag: "${1}" # or "-L ${1}" for example
:common: &common_libraries [] :common: &common_libraries []
:test: :test:
- *common_libraries #- *common_libraries
:release: :release:
- *common_libraries #- *common_libraries
:plugins: :plugins:
:load_paths: :load_paths: