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

refactor hid, rename hid_generic to simply hid_

This commit is contained in:
hathach 2019-04-18 00:36:17 +07:00
parent 395fd54dcb
commit cc2fce31e5
No known key found for this signature in database
GPG Key ID: 2FA891220FBFD581
7 changed files with 66 additions and 170 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
examples/device/cdc_msc_hid/src/main.c
View File

@ -144,18 +144,14 @@ void usb_hid_task(void)
tud_remote_wakeup();
}
#if 0
#if 1
/*------------- Keyboard -------------*/
if ( tud_hid_keyboard_ready() )
if ( tud_hid_ready() )
{
if ( btn )
{
uint8_t keycode[6] = { 0 };
for(uint8_t i=0; i < 6; i++)
{
if ( btn & (1 << i) ) keycode[i] = HID_KEY_A + i;
}
keycode[0] = HID_KEY_A;
tud_hid_keyboard_keycode(0, keycode);
}else
@ -180,7 +176,7 @@ void usb_hid_task(void)
#endif
}
uint16_t tud_hid_generic_get_report_cb(uint8_t report_id, hid_report_type_t report_type, uint8_t* buffer, uint16_t reqlen)
uint16_t tud_hid_get_report_cb(uint8_t report_id, hid_report_type_t report_type, uint8_t* buffer, uint16_t reqlen)
{
// TODO not Implemented
(void) report_id;
@ -191,7 +187,7 @@ uint16_t tud_hid_generic_get_report_cb(uint8_t report_id, hid_report_type_t repo
return 0;
}
void tud_hid_generic_set_report_cb(uint8_t report_id, hid_report_type_t report_type, uint8_t const* buffer, uint16_t bufsize)
void tud_hid_set_report_cb(uint8_t report_id, hid_report_type_t report_type, uint8_t const* buffer, uint16_t bufsize)
{
// TODO not Implemented
(void) report_id;

7
examples/device/cdc_msc_hid/src/usb_descriptors.c
View File

@ -120,10 +120,5 @@ tud_desc_set_t tud_desc_set =
.string_arr = (uint8_t const **) string_desc_arr,
.string_count = sizeof(string_desc_arr)/sizeof(string_desc_arr[0]),
.hid_report =
{
.generic = NULL,
.boot_keyboard = NULL,
.boot_mouse = NULL
}
.hid_report = NULL,
};

4
examples/device/cdc_msc_hid_freertos/src/main.c
View File

@ -193,13 +193,13 @@ void usb_hid_task(void* params)
}
}
uint16_t tud_hid_generic_get_report_cb(uint8_t report_id, hid_report_type_t report_type, uint8_t* buffer, uint16_t reqlen)
uint16_t tud_hid_get_report_cb(uint8_t report_id, hid_report_type_t report_type, uint8_t* buffer, uint16_t reqlen)
{
// TODO not Implemented
return 0;
}
void tud_hid_generic_set_report_cb(uint8_t report_id, hid_report_type_t report_type, uint8_t const* buffer, uint16_t bufsize)
void tud_hid_set_report_cb(uint8_t report_id, hid_report_type_t report_type, uint8_t const* buffer, uint16_t bufsize)
{
// TODO not Implemented
}

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

@ -43,57 +43,32 @@
#define REPORT_BUFSIZE 12
#define ITF_IDX_BOOT_KBD 0
#define ITF_IDX_BOOT_MSE ( ITF_IDX_BOOT_KBD + (CFG_TUD_HID_KEYBOARD && CFG_TUD_HID_KEYBOARD_BOOT) )
#define ITF_IDX_GENERIC ( ITF_IDX_BOOT_MSE + (CFG_TUD_HID_MOUSE && CFG_TUD_HID_MOUSE_BOOT) )
#define ITF_COUNT ( ITF_IDX_GENERIC + 1 )
#define ITF_IDX_BOOT_MSE 0 // ( ITF_IDX_BOOT_KBD + (CFG_TUD_HID_KEYBOARD && CFG_TUD_HID_KEYBOARD_BOOT) )
#define ITF_IDX_GENERIC 0 // ( ITF_IDX_BOOT_MSE + (CFG_TUD_HID_MOUSE && CFG_TUD_HID_MOUSE_BOOT) )
typedef struct
{
uint8_t itf_num;
uint8_t ep_in;
uint8_t idle_rate; // in unit of 4 ms TODO removed
uint8_t idle_rate; // Idle Rate = 0 : only send report if there is changes, i.e skip duplication
// Idle Rate > 0 : skip duplication, but send at least 1 report every idle rate (in unit of 4 ms).
// If idle time is less than interrupt polling then use the polling.
uint8_t boot_device;
bool boot_protocol;
uint16_t desc_len;
uint8_t const * desc_report;
CFG_TUSB_MEM_ALIGN uint8_t report_buf[REPORT_BUFSIZE];
// callbacks
uint16_t (*get_report_cb) (uint8_t report_id, hid_report_type_t type, uint8_t* buffer, uint16_t reqlen);
void (*set_report_cb) (uint8_t report_id, hid_report_type_t type, uint8_t const* buffer, uint16_t bufsize);
}hidd_interface_t;
typedef struct
{
uint8_t usage; // HID_USAGE_*
uint8_t idle_rate; // Idle Rate = 0 : only send report if there is changes, i.e skip duplication
// Idle Rate > 0 : skip duplication, but send at least 1 report every idle rate (in unit of 4 ms).
// If idle time is less than interrupt polling then use the polling.
uint8_t report_id;
uint8_t report_len;
hidd_interface_t* itf;
} hidd_report_t ;
CFG_TUSB_MEM_SECTION static hidd_interface_t _hidd_itf[ITF_COUNT] = { { 0 } };
#if CFG_TUD_HID_KEYBOARD
static hidd_report_t _kbd_rpt;
#endif
#if CFG_TUD_HID_MOUSE
static hidd_report_t _mse_rpt;
#endif
CFG_TUSB_MEM_SECTION static hidd_interface_t _hidd_itf[CFG_TUD_HID];
/*------------- Helpers -------------*/
static inline hidd_interface_t* get_interface_by_itfnum(uint8_t itf_num)
{
for (uint8_t i=0; i < ITF_COUNT; i++ )
for (uint8_t i=0; i < CFG_TUD_HID; i++ )
{
if ( itf_num == _hidd_itf[i].itf_num ) return &_hidd_itf[i];
}
@ -101,18 +76,17 @@ static inline hidd_interface_t* get_interface_by_itfnum(uint8_t itf_num)
return NULL;
}
//--------------------------------------------------------------------+
// HID GENERIC API
//--------------------------------------------------------------------+
bool tud_hid_generic_ready(void)
bool tud_hid_ready(void)
{
return tud_ready() && (_hidd_itf[ITF_IDX_GENERIC].ep_in != 0) && !dcd_edpt_busy(TUD_OPT_RHPORT, _hidd_itf[ITF_IDX_GENERIC].ep_in);
}
bool tud_hid_generic_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_generic_ready() && (len < REPORT_BUFSIZE) );
TU_VERIFY( tud_hid_ready() && (len < REPORT_BUFSIZE) );
hidd_interface_t * p_hid = &_hidd_itf[ITF_IDX_GENERIC];
@ -134,21 +108,10 @@ bool tud_hid_generic_report(uint8_t report_id, void const* report, uint8_t len)
// KEYBOARD APPLICATION API
//--------------------------------------------------------------------+
#if CFG_TUD_HID_KEYBOARD
bool tud_hid_keyboard_ready(void)
{
return (_kbd_rpt.itf != NULL) && !dcd_edpt_busy(TUD_OPT_RHPORT, _kbd_rpt.itf->ep_in);
}
bool tud_hid_keyboard_is_boot_protocol(void)
{
return (_kbd_rpt.itf != NULL) && _kbd_rpt.itf->boot_protocol;
}
static bool hidd_kbd_report(hid_keyboard_report_t const *p_report)
{
TU_VERIFY( tud_hid_keyboard_ready() );
hidd_interface_t * p_hid = _kbd_rpt.itf;
TU_VERIFY( tud_hid_ready() );
hidd_interface_t * p_hid = &_hidd_itf[ITF_IDX_GENERIC];
// only send report if there is changes, i.e skip duplication
// if ( _kbd_rpt.idle_rate == 0 )
@ -198,11 +161,6 @@ bool tud_hid_keyboard_key_press(char ch)
//--------------------------------------------------------------------+
#if CFG_TUD_HID_MOUSE
bool tud_hid_mouse_ready(void)
{
return (_mse_rpt.itf != NULL) && !dcd_edpt_busy(TUD_OPT_RHPORT, _mse_rpt.itf->ep_in);
}
bool tud_hid_mouse_is_boot_protocol(void)
{
return (_mse_rpt.itf != NULL) && _mse_rpt.itf->boot_protocol;
@ -267,14 +225,6 @@ void hidd_reset(uint8_t rhport)
{
(void) rhport;
tu_memclr(_hidd_itf, sizeof(_hidd_itf));
#if CFG_TUD_HID_KEYBOARD
tu_varclr(&_kbd_rpt);
#endif
#if CFG_TUD_HID_MOUSE
tu_varclr(&_mse_rpt);
#endif
}
bool hidd_open(uint8_t rhport, tusb_desc_interface_t const * desc_itf, uint16_t *p_len)
@ -284,6 +234,11 @@ bool hidd_open(uint8_t rhport, tusb_desc_interface_t const * desc_itf, uint16_t
// TODO support HID OUT Endpoint
TU_ASSERT(desc_itf->bNumEndpoints == 1);
// TODO support multiple HID interface
hidd_interface_t * p_hid = &_hidd_itf[0];
if ( desc_itf->bInterfaceSubClass == HID_SUBCLASS_BOOT ) p_hid->boot_device = desc_itf->bInterfaceProtocol;
//------------- HID descriptor -------------//
p_desc = tu_desc_next(p_desc);
tusb_hid_descriptor_hid_t const *desc_hid = (tusb_hid_descriptor_hid_t const *) p_desc;
@ -294,9 +249,8 @@ bool hidd_open(uint8_t rhport, tusb_desc_interface_t const * desc_itf, uint16_t
tusb_desc_endpoint_t const *desc_edpt = (tusb_desc_endpoint_t const *) p_desc;
TU_ASSERT(TUSB_DESC_ENDPOINT == desc_edpt->bDescriptorType);
hidd_interface_t * p_hid = NULL;
/*------------- Boot protocol only keyboard & mouse -------------*/
#if 0
if (desc_itf->bInterfaceSubClass == HID_SUBCLASS_BOOT)
{
TU_ASSERT(desc_itf->bInterfaceProtocol == HID_PROTOCOL_KEYBOARD || desc_itf->bInterfaceProtocol == HID_PROTOCOL_MOUSE);
@ -338,13 +292,12 @@ bool hidd_open(uint8_t rhport, tusb_desc_interface_t const * desc_itf, uint16_t
}
/*------------- Generic (multiple report) -------------*/
else
#endif
{
// TODO parse report ID for keyboard, mouse
p_hid = &_hidd_itf[ITF_IDX_GENERIC];
// p_hid = &_hidd_itf[ITF_IDX_GENERIC];
p_hid->desc_report = usbd_desc_set->hid_report.generic;
p_hid->get_report_cb = tud_hid_generic_get_report_cb;
p_hid->set_report_cb = tud_hid_generic_set_report_cb;
p_hid->desc_report = usbd_desc_set->hid_report;
}
TU_ASSERT(p_hid->desc_report);
@ -392,17 +345,9 @@ bool hidd_control_request(uint8_t rhport, tusb_control_request_t const * p_reque
uint8_t const report_type = tu_u16_high(p_request->wValue);
uint8_t const report_id = tu_u16_low(p_request->wValue);
uint16_t xferlen;
if ( p_hid->get_report_cb )
{
xferlen = p_hid->get_report_cb(report_id, (hid_report_type_t) report_type, p_hid->report_buf, p_request->wLength);
}else
{
// For boot Interface only: re-use report_buf -> report has no change
xferlen = p_request->wLength;
}
uint16_t xferlen = tud_hid_get_report_cb(report_id, (hid_report_type_t) report_type, p_hid->report_buf, p_request->wLength);
TU_ASSERT( xferlen > 0 );
usbd_control_xfer(rhport, p_request, p_hid->report_buf, xferlen);
}
break;
@ -459,10 +404,7 @@ bool hidd_control_request_complete(uint8_t rhport, tusb_control_request_t const
uint8_t const report_type = tu_u16_high(p_request->wValue);
uint8_t const report_id = tu_u16_low(p_request->wValue);
if ( p_hid->set_report_cb )
{
p_hid->set_report_cb(report_id, (hid_report_type_t) report_type, p_hid->report_buf, p_request->wLength);
}
tud_hid_set_report_cb(report_id, (hid_report_type_t) report_type, p_hid->report_buf, p_request->wLength);
}
return true;

93
src/class/hid/hid_device.h
View File

@ -54,12 +54,36 @@
//--------------------------------------------------------------------+
// HID GENERIC API
//--------------------------------------------------------------------+
bool tud_hid_generic_ready(void);
bool tud_hid_generic_report(uint8_t report_id, void const* report, uint8_t len);
/** Check if the interface is ready to use
* \returns true if ready, otherwise interface may not be mounted or still busy transferring data
* \note Application must not perform any action if the interface is not ready
*/
bool tud_hid_ready(void);
bool tud_hid_report(uint8_t report_id, void const* report, uint8_t len);
/*------------- Callbacks (Weak is optional) -------------*/
uint16_t tud_hid_generic_get_report_cb(uint8_t report_id, hid_report_type_t report_type, uint8_t* buffer, uint16_t reqlen);
void tud_hid_generic_set_report_cb(uint8_t report_id, hid_report_type_t report_type, uint8_t const* buffer, uint16_t bufsize);
/** Callback invoked when USB host request \ref HID_REQ_CONTROL_GET_REPORT.
* \param[in] report_type specify which report (INPUT, OUTPUT, FEATURE) that host requests
* \param[out] buffer data that application need to update, value must be accessible by USB controller (see \ref CFG_TUSB_MEM_SECTION)
* \param[in] reqlen number of bytes that host requested
* \retval non-zero Actual number of bytes in the response's buffer.
* \retval zero indicates the current request is not supported. Tinyusb device stack will reject the request by
* sending STALL in the data phase.
* \note After this callback, the request is silently executed by the tinyusb stack, thus
* the completion of this control request will not be reported to application.
* For Keyboard, USB host often uses this to turn on/off the LED for CAPLOCKS, NUMLOCK (\ref hid_keyboard_led_bm_t)
*/
uint16_t tud_hid_get_report_cb(uint8_t report_id, hid_report_type_t report_type, uint8_t* buffer, uint16_t reqlen);
/** Callback invoked when USB host request \ref HID_REQ_CONTROL_SET_REPORT.
* \param[in] report_type specify which report (INPUT, OUTPUT, FEATURE) that host requests
* \param[in] buffer containing the report's data
* \param[in] bufsize number of bytes in the \a buffer
* \note By the time this callback is invoked, the USB control transfer is already completed in the hardware side.
* Application are free to handle data at its own will.
*/
void tud_hid_set_report_cb(uint8_t report_id, hid_report_type_t report_type, uint8_t const* buffer, uint16_t bufsize);
//--------------------------------------------------------------------+
// KEYBOARD API
@ -70,13 +94,6 @@ void tud_hid_generic_set_report_cb(uint8_t report_id, hid_report_type_t repo
/** \defgroup Keyboard_Device Device
* @{ */
/** Check if the interface is ready to use
* \returns true if ready, otherwise interface may not be mounted or still busy transferring data
* \note Application must not perform any action if the interface is not ready
*/
bool tud_hid_keyboard_ready(void);
bool tud_hid_keyboard_is_boot_protocol(void);
bool tud_hid_keyboard_keycode(uint8_t modifier, uint8_t keycode[6]);
static inline bool tud_hid_keyboard_key_release(void) { return tud_hid_keyboard_keycode(0, NULL); }
@ -95,29 +112,6 @@ extern const hid_ascii_to_keycode_entry_t HID_ASCII_TO_KEYCODE[128];
/*------------- Callbacks (Weak is optional) -------------*/
/** Callback invoked when USB host request \ref HID_REQ_CONTROL_GET_REPORT.
* \param[in] report_type specify which report (INPUT, OUTPUT, FEATURE) that host requests
* \param[out] buffer data that application need to update, value must be accessible by USB controller (see \ref CFG_TUSB_MEM_SECTION)
* \param[in] reqlen number of bytes that host requested
* \retval non-zero Actual number of bytes in the response's buffer.
* \retval zero indicates the current request is not supported. Tinyusb device stack will reject the request by
* sending STALL in the data phase.
* \note After this callback, the request is silently executed by the tinyusb stack, thus
* the completion of this control request will not be reported to application.
* For Keyboard, USB host often uses this to turn on/off the LED for CAPLOCKS, NUMLOCK (\ref hid_keyboard_led_bm_t)
*/
ATTR_WEAK uint16_t tud_hid_keyboard_get_report_cb(uint8_t report_id, hid_report_type_t report_type, uint8_t* buffer, uint16_t reqlen);
/** Callback invoked when USB host request \ref HID_REQ_CONTROL_SET_REPORT.
* \param[in] report_type specify which report (INPUT, OUTPUT, FEATURE) that host requests
* \param[in] buffer containing the report's data
* \param[in] bufsize number of bytes in the \a buffer
* \note By the time this callback is invoked, the USB control transfer is already completed in the hardware side.
* Application are free to handle data at its own will.
*/
ATTR_WEAK void tud_hid_keyboard_set_report_cb(uint8_t report_id, hid_report_type_t report_type, uint8_t const* buffer, uint16_t bufsize);
//ATTR_WEAK void tud_hid_keyboard_set_protocol_cb(bool boot_protocol);
/** @} */
@ -132,12 +126,6 @@ ATTR_WEAK void tud_hid_keyboard_set_report_cb(uint8_t report_id, hid_report_type
/** \defgroup Mouse_Device Device
* @{ */
/** \brief Check if the interface is currently busy or not
* \retval true if the interface is busy meaning the stack is still transferring/waiting data from/to host
* \retval false if the interface is not busy meaning the stack successfully transferred data from/to host
* \note This function is primarily used for polling/waiting result after \ref tusbd_hid_mouse_send.
*/
bool tud_hid_mouse_ready(void);
bool tud_hid_mouse_is_boot_protocol(void);
bool tud_hid_mouse_data(uint8_t buttons, int8_t x, int8_t y, int8_t scroll, int8_t pan);
@ -155,31 +143,6 @@ static inline bool tud_hid_mouse_button_release(void)
return tud_hid_mouse_data(0, 0, 0, 0, 0);
}
/*------------- Callbacks (Weak is optional) -------------*/
/**
* Callback function that is invoked when USB host request \ref HID_REQ_CONTROL_GET_REPORT.
* \param[in] report_type specify which report (INPUT, OUTPUT, FEATURE) that host requests
* \param[out] buffer buffer that application need to update, value must be accessible by USB controller (see \ref CFG_TUSB_MEM_SECTION)
* \param[in] reqlen number of bytes that host requested
* \retval non-zero Actual number of bytes in the response's buffer.
* \retval zero indicates the current request is not supported. Tinyusb device stack will reject the request by
* sending STALL in the data phase.
* \note After this callback, the request is silently executed by the tinyusb stack, thus
* the completion of this control request will not be reported to application
*/
ATTR_WEAK uint16_t tud_hid_mouse_get_report_cb(uint8_t report_id, hid_report_type_t report_type, uint8_t* buffer, uint16_t reqlen);
/**
* Callback function that is invoked when USB host request \ref HID_REQ_CONTROL_SET_REPORT.
* \param[in] report_type specify which report (INPUT, OUTPUT, FEATURE) that host requests
* \param[in] buffer buffer containing the report's data
* \param[in] bufsize number of bytes in the \a p_report_data
* \note By the time this callback is invoked, the USB control transfer is already completed in the hardware side.
* Application are free to handle data at its own will.
*/
ATTR_WEAK void tud_hid_mouse_set_report_cb(uint8_t report_id, hid_report_type_t report_type, uint8_t const* buffer, uint16_t bufsize);
//ATTR_WEAK void tud_hid_mouse_set_protocol_cb(bool boot_protocol);
#endif

6
src/device/usbd.h
View File

@ -45,11 +45,7 @@ typedef struct {
uint8_t const** string_arr; ///< a array of pointers to string descriptors
uint16_t string_count;
struct {
uint8_t const* generic;
uint8_t const* boot_keyboard;
uint8_t const* boot_mouse;
} hid_report;
uint8_t const* hid_report;
}tud_desc_set_t;

4
src/device/usbd_auto_desc.c
View File

@ -562,6 +562,9 @@ tud_desc_set_t const _usbd_auto_desc_set =
.device = NULL, // no auto device
.config = &_desc_auto_config_struct,
.hid_report = _desc_auto_hid_boot_kbd_report
#if 0
.hid_report =
{
#if AUTO_DESC_HID_GENERIC
@ -578,6 +581,7 @@ tud_desc_set_t const _usbd_auto_desc_set =
.boot_mouse = _desc_auto_hid_boot_mse_report
#endif
}
#endif
};
#endif