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

reworking device hid class driver

Browse Source
This commit is contained in:
hathach
2018-07-23 15:25:45 +07:00
parent 141ac25e3b
commit 4342325ee1
31 changed files with 583 additions and 501 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -38,7 +38,7 @@
#include "tusb_option.h"
#if (MODE_DEVICE_SUPPORTED && DEVICE_CLASS_HID)
#if (TUSB_OPT_DEVICE_ENABLED && TUD_OPT_HID_ENABLED)
#define _TINY_USB_SOURCE_FILE_
//--------------------------------------------------------------------+
@@ -51,75 +51,53 @@
//--------------------------------------------------------------------+
// MACRO CONSTANT TYPEDEF
//--------------------------------------------------------------------+
enum {
HIDD_NUMBER_OF_SUBCLASS = 3,
HIDD_BUFFER_SIZE = 128
};
// Max report len is keyboard's one with 8 byte + 1 byte report id
#define REPORT_BUFSIZE 9
typedef struct {
uint8_t const * p_report_desc;
uint16_t report_length;
uint8_t itf_num;
uint8_t ep_in;
uint8_t idle_rate;
uint8_t edpt_addr;
uint8_t interface_number;
uint8_t report_id;
uint16_t report_len;
uint8_t const * report_desc;
// class specific control request
uint16_t (*get_report_cb) (hid_report_type_t type, uint8_t* buffer, uint16_t reqlen);
void (*set_report_cb) (hid_report_type_t type, uint8_t const* buffer, uint16_t bufsize);
CFG_TUSB_MEM_ALIGN uint8_t report_buf[REPORT_BUFSIZE];
}hidd_interface_t;
typedef struct {
hidd_interface_t * const p_interface;
void (* const xfer_cb) (uint8_t, tusb_event_t, uint32_t);
uint16_t (* const get_report_cb) (uint8_t, hid_request_report_type_t, void**, uint16_t );
void (* const set_report_cb) (uint8_t, hid_request_report_type_t, uint8_t[], uint16_t);
}hidd_class_driver_t;
#if CFG_TUD_HID_BOOT_PROTOCOL
extern ATTR_WEAK hidd_interface_t keyboardd_data;
extern ATTR_WEAK hidd_interface_t moused_data;
CFG_TUSB_ATTR_USBRAM static hidd_interface_t _kbd_itf;
CFG_TUSB_ATTR_USBRAM static hidd_interface_t _mse_itf;
static hidd_class_driver_t const hidd_class_driver[HIDD_NUMBER_OF_SUBCLASS] =
{
// [HID_PROTOCOL_NONE] = for HID Generic
#else
CFG_TUSB_ATTR_USBRAM static hidd_interface_t _composite_itf;
#if CFG_TUD_HID_KEYBOARD
[HID_PROTOCOL_KEYBOARD] =
{
.p_interface = &keyboardd_data,
.xfer_cb = tud_hid_keyboard_cb,
.get_report_cb = tud_hid_keyboard_get_report_cb,
.set_report_cb = tud_hid_keyboard_set_report_cb
},
#endif
#if CFG_TUD_HID_MOUSE
[HID_PROTOCOL_MOUSE] =
{
.p_interface = &moused_data,
.xfer_cb = tud_hid_mouse_cb,
.get_report_cb = tud_hid_mouse_get_report_cb,
.set_report_cb = tud_hid_mouse_set_report_cb
}
#endif
};
// internal buffer for transferring data
CFG_TUSB_ATTR_USBRAM STATIC_VAR uint8_t m_hid_buffer[ HIDD_BUFFER_SIZE ];
//--------------------------------------------------------------------+
// KEYBOARD APPLICATION API
//--------------------------------------------------------------------+
#if CFG_TUD_HID_KEYBOARD
STATIC_VAR hidd_interface_t keyboardd_data;
bool tud_hid_keyboard_busy(uint8_t rhport)
bool tud_hid_keyboard_busy(void)
{
return dcd_edpt_busy(rhport, keyboardd_data.edpt_addr);
return dcd_edpt_busy(TUD_OPT_RHPORT, _kbd_itf.ep_in);
}
tusb_error_t tud_hid_keyboard_send(uint8_t rhport, hid_keyboard_report_t const *p_report)
tusb_error_t tud_hid_keyboard_send(hid_keyboard_report_t const *p_report)
{
VERIFY(tud_mounted(), TUSB_ERROR_USBD_DEVICE_NOT_CONFIGURED);
hidd_interface_t * p_kbd = &keyboardd_data; // TODO &keyboardd_data[rhport];
hidd_interface_t * p_kbd = &_kbd_itf;
TU_ASSERT( dcd_edpt_xfer(rhport, p_kbd->edpt_addr, (void*) p_report, sizeof(hid_keyboard_report_t)), TUSB_ERROR_DCD_EDPT_XFER ) ;
TU_ASSERT( dcd_edpt_xfer(TUD_OPT_RHPORT, p_kbd->ep_in, (void*) p_report, sizeof(hid_keyboard_report_t)), TUSB_ERROR_DCD_EDPT_XFER ) ;
return TUSB_ERROR_NONE;
}
@@ -129,66 +107,130 @@ tusb_error_t tud_hid_keyboard_send(uint8_t rhport, hid_keyboard_report_t const *
// MOUSE APPLICATION API
//--------------------------------------------------------------------+
#if CFG_TUD_HID_MOUSE
STATIC_VAR hidd_interface_t moused_data;
bool tud_hid_mouse_is_busy(uint8_t rhport)
bool tud_hid_mouse_is_busy(void)
{
return dcd_edpt_busy(rhport, moused_data.edpt_addr);
return dcd_edpt_busy(TUD_OPT_RHPORT, _mse_itf.ep_in);
}
tusb_error_t tud_hid_mouse_send(uint8_t rhport, hid_mouse_report_t const *p_report)
tusb_error_t tud_hid_mouse_send(hid_mouse_report_t const *p_report)
{
VERIFY(tud_mounted(), TUSB_ERROR_USBD_DEVICE_NOT_CONFIGURED);
hidd_interface_t * p_mouse = &moused_data; // TODO &keyboardd_data[rhport];
hidd_interface_t * p_mouse = &_mse_itf;
TU_ASSERT( dcd_edpt_xfer(rhport, p_mouse->edpt_addr, (void*) p_report, sizeof(hid_mouse_report_t)), TUSB_ERROR_DCD_EDPT_XFER ) ;
TU_ASSERT( dcd_edpt_xfer(TUD_OPT_RHPORT, p_mouse->ep_in, (void*) p_report, sizeof(hid_mouse_report_t)), TUSB_ERROR_DCD_EDPT_XFER ) ;
return TUSB_ERROR_NONE;
}
#endif
static inline hidd_interface_t* get_interface_by_edpt(uint8_t ep_addr)
{
return ( ep_addr == _kbd_itf.ep_in ) ? &_kbd_itf :
( ep_addr == _mse_itf.ep_in ) ? &_mse_itf : NULL;
}
static inline hidd_interface_t* get_interface_by_number(uint8_t itf_num)
{
return ( itf_num == _kbd_itf.itf_num ) ? &_kbd_itf :
( itf_num == _mse_itf.itf_num ) ? &_mse_itf : NULL;
}
//--------------------------------------------------------------------+
// USBD-CLASS API
//--------------------------------------------------------------------+
static void interface_clear(hidd_interface_t * p_interface)
{
if ( p_interface != NULL )
{
memclr_(p_interface, sizeof(hidd_interface_t));
p_interface->interface_number = INTERFACE_INVALID_NUMBER;
}
}
void hidd_init(void)
{
for(uint8_t i=0; i<HIDD_NUMBER_OF_SUBCLASS; i++)
{
interface_clear( hidd_class_driver[i].p_interface );
}
hidd_reset(TUD_OPT_RHPORT);
}
void hidd_reset(uint8_t rhport)
{
for(uint8_t i=0; i<HIDD_NUMBER_OF_SUBCLASS; i++)
#if CFG_TUD_HID_MOUSE
varclr_(&_mse_itf);
#endif
#if CFG_TUD_HID_KEYBOARD
varclr_(&_kbd_itf);
#endif
}
tusb_error_t hidd_open(uint8_t rhport, tusb_desc_interface_t const * desc_itf, uint16_t *p_length)
{
uint8_t const *p_desc = (uint8_t const *) desc_itf;
//------------- HID descriptor -------------//
p_desc += p_desc[DESC_OFFSET_LEN];
tusb_hid_descriptor_hid_t const *desc_hid = (tusb_hid_descriptor_hid_t const *) p_desc;
TU_ASSERT(HID_DESC_TYPE_HID == desc_hid->bDescriptorType, TUSB_ERROR_HIDD_DESCRIPTOR_INTERFACE);
//------------- Endpoint Descriptor -------------//
p_desc += p_desc[DESC_OFFSET_LEN];
tusb_desc_endpoint_t const *desc_edpt = (tusb_desc_endpoint_t const *) p_desc;
TU_ASSERT(TUSB_DESC_ENDPOINT == desc_edpt->bDescriptorType, TUSB_ERROR_HIDD_DESCRIPTOR_INTERFACE);
if (desc_itf->bInterfaceSubClass == HID_SUBCLASS_BOOT)
{
interface_clear(hidd_class_driver[i].p_interface);
#if CFG_TUD_HID_BOOT_PROTOCOL
if ( (desc_itf->bInterfaceProtocol != HID_PROTOCOL_KEYBOARD) && (desc_itf->bInterfaceProtocol != HID_PROTOCOL_MOUSE) )
{
// unknown, unsupported protocol
return TUSB_ERROR_HIDD_DESCRIPTOR_INTERFACE;
}else
{
hidd_interface_t * p_hid = NULL;
#if CFG_TUD_HID_KEYBOARD
if (desc_itf->bInterfaceProtocol == HID_PROTOCOL_KEYBOARD)
{
p_hid = &_kbd_itf;
p_hid->report_desc = tud_desc_set.hid_report.boot_keyboard;
p_hid->get_report_cb = tud_hid_keyboard_get_report_cb;
p_hid->set_report_cb = tud_hid_keyboard_set_report_cb;
}
#endif
#if CFG_TUD_HID_MOUSE
if (desc_itf->bInterfaceProtocol == HID_PROTOCOL_MOUSE)
{
p_hid = &_mse_itf;
p_hid->report_desc = tud_desc_set.hid_report.boot_mouse;
p_hid->get_report_cb = tud_hid_mouse_get_report_cb;
p_hid->set_report_cb = tud_hid_mouse_set_report_cb;
}
#endif
TU_ASSERT(p_hid, TUSB_ERROR_HIDD_DESCRIPTOR_INTERFACE);
VERIFY(p_hid->report_desc, TUSB_ERROR_DESCRIPTOR_CORRUPTED);
TU_ASSERT( dcd_edpt_open(rhport, desc_edpt), TUSB_ERROR_DCD_FAILED );
p_hid->report_len = desc_hid->wReportLength;
p_hid->itf_num = desc_itf->bInterfaceNumber;
p_hid->ep_in = desc_edpt->bEndpointAddress;
p_hid->report_id = 0;
*p_length = sizeof(tusb_desc_interface_t) + sizeof(tusb_hid_descriptor_hid_t) + sizeof(tusb_desc_endpoint_t);
}
#else
return TUSB_ERROR_HIDD_DESCRIPTOR_INTERFACE;
#endif
}
else
{
// TODO HID generic
// TODO parse report ID for keyboard, mouse
*p_length = 0;
return TUSB_ERROR_HIDD_DESCRIPTOR_INTERFACE;
}
return TUSB_ERROR_NONE;
}
tusb_error_t hidd_control_request_st(uint8_t rhport, tusb_control_request_t const * p_request)
{
uint8_t subclass_idx;
for(subclass_idx=0; subclass_idx<HIDD_NUMBER_OF_SUBCLASS; subclass_idx++)
{
hidd_interface_t * const p_interface = hidd_class_driver[subclass_idx].p_interface;
if ( (p_interface != NULL) && (p_request->wIndex == p_interface->interface_number) ) break;
}
TU_ASSERT(subclass_idx < HIDD_NUMBER_OF_SUBCLASS, TUSB_ERROR_FAILED);
hidd_class_driver_t const * const p_driver = &hidd_class_driver[subclass_idx];
hidd_interface_t* const p_hid = p_driver->p_interface;
hidd_interface_t* p_hid = get_interface_by_number( (uint8_t) p_request->wIndex );
TU_ASSERT(p_hid, TUSB_ERROR_FAILED);
OSAL_SUBTASK_BEGIN
@@ -202,12 +244,12 @@ tusb_error_t hidd_control_request_st(uint8_t rhport, tusb_control_request_t cons
if (p_request->bRequest == TUSB_REQ_GET_DESCRIPTOR && desc_type == HID_DESC_TYPE_REPORT)
{
STASK_ASSERT ( p_hid->report_length <= HIDD_BUFFER_SIZE );
STASK_ASSERT ( p_hid->report_len <= CFG_TUD_CTRL_BUFSIZE );
// copy to allow report descriptor not to be in USBRAM
memcpy(m_hid_buffer, p_hid->p_report_desc, p_hid->report_length);
// use device control buffer (in USB SRAM)
memcpy(_usbd_ctrl_buf, p_hid->report_desc, p_hid->report_len);
usbd_control_xfer_st(rhport, p_request->bmRequestType_bit.direction, m_hid_buffer, p_hid->report_length);
usbd_control_xfer_st(rhport, p_request->bmRequestType_bit.direction, _usbd_ctrl_buf, p_hid->report_len);
}else
{
dcd_control_stall(rhport);
@@ -216,34 +258,59 @@ tusb_error_t hidd_control_request_st(uint8_t rhport, tusb_control_request_t cons
//------------- Class Specific Request -------------//
else if (p_request->bmRequestType_bit.type == TUSB_REQ_TYPE_CLASS)
{
if( (HID_REQUEST_CONTROL_GET_REPORT == p_request->bRequest) && (p_driver->get_report_cb != NULL) )
if( HID_REQ_CONTROL_GET_REPORT == p_request->bRequest )
{
// wValue = Report Type | Report ID
void* p_buffer = NULL;
uint8_t const report_type = u16_high_u8(p_request->wValue);
uint8_t const report_id = u16_low_u8(p_request->wValue);
uint16_t actual_length = p_driver->get_report_cb(rhport, (hid_request_report_type_t) u16_high_u8(p_request->wValue),
&p_buffer, p_request->wLength);
STASK_ASSERT( p_buffer != NULL && actual_length > 0 );
// Composite interface need to determine it is Keyboard, Mouse or Gamepad
if ( report_id > 0 )
{
usbd_control_xfer_st(rhport, p_request->bmRequestType_bit.direction, p_buffer, actual_length);
}
uint16_t xferlen;
if ( p_hid->get_report_cb )
{
xferlen = p_hid->get_report_cb((hid_report_type_t) report_type, p_hid->report_buf, p_request->wLength);
}else
{
xferlen = p_request->wLength;
// re-use report_buf -> report has no change
}
STASK_ASSERT( xferlen > 0 );
usbd_control_xfer_st(rhport, p_request->bmRequestType_bit.direction, p_hid->report_buf, xferlen);
}
else if ( (HID_REQUEST_CONTROL_SET_REPORT == p_request->bRequest) && (p_driver->set_report_cb != NULL) )
else if ( HID_REQ_CONTROL_SET_REPORT == p_request->bRequest )
{
// return TUSB_ERROR_DCD_CONTROL_REQUEST_NOT_SUPPORT; // TODO test STALL control out endpoint (with mouse+keyboard)
// wValue = Report Type | Report ID
usbd_control_xfer_st(rhport, p_request->bmRequestType_bit.direction, m_hid_buffer, p_request->wLength);
usbd_control_xfer_st(rhport, p_request->bmRequestType_bit.direction, _usbd_ctrl_buf, p_request->wLength);
p_driver->set_report_cb(rhport, u16_high_u8(p_request->wValue), m_hid_buffer, p_request->wLength);
if ( p_hid->set_report_cb )
{
p_hid->set_report_cb(u16_high_u8(p_request->wValue), _usbd_ctrl_buf, p_request->wLength);
}
}
else if (HID_REQUEST_CONTROL_SET_IDLE == p_request->bRequest)
else if (HID_REQ_CONTROL_SET_IDLE == p_request->bRequest)
{
// uint8_t idle_rate = u16_high_u8(p_request->wValue);
p_hid->idle_rate = u16_high_u8(p_request->wValue);
dcd_control_status(rhport, p_request->bmRequestType_bit.direction);
}else
}
else if (HID_REQ_CONTROL_GET_IDLE == p_request->bRequest)
{
// HID_REQUEST_CONTROL_GET_IDLE:
// HID_REQUEST_CONTROL_GET_PROTOCOL:
// HID_REQUEST_CONTROL_SET_PROTOCOL:
_usbd_ctrl_buf[0] = p_hid->idle_rate;
usbd_control_xfer_st(rhport, p_request->bmRequestType_bit.direction, _usbd_ctrl_buf, 1);
}
else if (HID_REQ_CONTROL_GET_PROTOCOL == p_request->bRequest )
{
_usbd_ctrl_buf[0] = 1 - CFG_TUD_HID_BOOT_PROTOCOL; // 0 is Boot, 1 is Report protocol
usbd_control_xfer_st(rhport, p_request->bmRequestType_bit.direction, _usbd_ctrl_buf, 1);
}
else
{
// HID_REQ_CONTROL_SET_PROTOCOL:
dcd_control_stall(rhport);
}
}else
@@ -254,68 +321,9 @@ tusb_error_t hidd_control_request_st(uint8_t rhport, tusb_control_request_t cons
OSAL_SUBTASK_END
}
tusb_error_t hidd_open(uint8_t rhport, tusb_desc_interface_t const * p_interface_desc, uint16_t *p_length)
{
uint8_t const *p_desc = (uint8_t const *) p_interface_desc;
//------------- HID descriptor -------------//
p_desc += p_desc[DESC_OFFSET_LEN];
tusb_hid_descriptor_hid_t const *p_desc_hid = (tusb_hid_descriptor_hid_t const *) p_desc;
TU_ASSERT(HID_DESC_TYPE_HID == p_desc_hid->bDescriptorType, TUSB_ERROR_HIDD_DESCRIPTOR_INTERFACE);
//------------- Endpoint Descriptor -------------//
p_desc += p_desc[DESC_OFFSET_LEN];
tusb_desc_endpoint_t const *p_desc_endpoint = (tusb_desc_endpoint_t const *) p_desc;
TU_ASSERT(TUSB_DESC_ENDPOINT == p_desc_endpoint->bDescriptorType, TUSB_ERROR_HIDD_DESCRIPTOR_INTERFACE);
if (p_interface_desc->bInterfaceSubClass == HID_SUBCLASS_BOOT)
{
switch(p_interface_desc->bInterfaceProtocol)
{
case HID_PROTOCOL_KEYBOARD:
case HID_PROTOCOL_MOUSE:
{
hidd_class_driver_t const * const p_driver = &hidd_class_driver[p_interface_desc->bInterfaceProtocol];
hidd_interface_t * const p_hid = p_driver->p_interface;
VERIFY(p_hid, TUSB_ERROR_FAILED);
VERIFY( dcd_edpt_open(rhport, p_desc_endpoint), TUSB_ERROR_DCD_FAILED );
p_hid->edpt_addr = p_desc_endpoint->bEndpointAddress;
p_hid->interface_number = p_interface_desc->bInterfaceNumber;
p_hid->p_report_desc = (p_interface_desc->bInterfaceProtocol == HID_PROTOCOL_KEYBOARD) ? tusbd_descriptor_pointers.p_hid_keyboard_report : tusbd_descriptor_pointers.p_hid_mouse_report;
p_hid->report_length = p_desc_hid->wReportLength;
VERIFY(p_hid->p_report_desc, TUSB_ERROR_DESCRIPTOR_CORRUPTED);
}
break;
default: // TODO unknown, unsupported protocol --> skip this interface
return TUSB_ERROR_HIDD_DESCRIPTOR_INTERFACE;
}
*p_length = sizeof(tusb_desc_interface_t) + sizeof(tusb_hid_descriptor_hid_t) + sizeof(tusb_desc_endpoint_t);
}else
{
// open generic
*p_length = 0;
return TUSB_ERROR_HIDD_DESCRIPTOR_INTERFACE;
}
return TUSB_ERROR_NONE;
}
tusb_error_t hidd_xfer_cb(uint8_t rhport, uint8_t edpt_addr, tusb_event_t event, uint32_t xferred_bytes)
{
for(uint8_t i=0; i<HIDD_NUMBER_OF_SUBCLASS; i++)
{
hidd_interface_t * const p_interface = hidd_class_driver[i].p_interface;
if ( (p_interface != NULL) && (edpt_addr == p_interface->edpt_addr) )
{
hidd_class_driver[i].xfer_cb(rhport, event, xferred_bytes);
}
}
// nothing to do
return TUSB_ERROR_NONE;
}