kingkevin
/
esp32-s2_dfu
1
0
Fork 0
Code Issues Releases Activity

refractor hidh keyboard 

changing class hidh behavior
This commit is contained in:
hathach 2013-03-24 21:40:49 +07:00
parent a1b17be681
commit c7c993d6cc
9 changed files with 85 additions and 98 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
demos/host/keyboard_app.c
View File

@ -54,10 +54,9 @@
//--------------------------------------------------------------------+
void keyboard_app_task(void)
{
for (uint8_t dev_addr = 1; dev_addr <= TUSB_CFG_HOST_DEVICE_MAX; dev_addr++)
{
if ( tusbh_device_is_configured(dev_addr) )
if ( tusbh_hid_keyboard_is_supported(dev_addr) )
{
}

138
tests/test/host/test_hidh_keyboard.c
View File

@ -35,13 +35,15 @@
* This file is part of the tiny usb stack.
*/
#include "stdlib.h"
#include "unity.h"
#include "errors.h"
#include "hid_host.h"
#include "mock_osal.h"
#include "mock_usbh.h"
#include "mock_hcd.h"
extern class_hid_keyboard_info_t keyboard_data[TUSB_CFG_HOST_DEVICE_MAX];
extern hidh_keyboard_info_t keyboard_data[TUSB_CFG_HOST_DEVICE_MAX];
tusb_keyboard_report_t sample_key[2] =
{
@ -56,32 +58,42 @@ tusb_keyboard_report_t sample_key[2] =
};
uint8_t dev_addr;
tusb_descriptor_interface_t kbd_descriptor;
tusb_keyboard_report_t report;
uint8_t instance_num;
keyboard_interface_t* p_hidh_kbd_interface;
tusb_descriptor_interface_t const kbd_descriptor =
{
.bLength = sizeof(tusb_descriptor_interface_t),
.bDescriptorType = TUSB_DESC_INTERFACE,
.bInterfaceNumber = 1,
.bAlternateSetting = 0,
.bNumEndpoints = 1,
.bInterfaceClass = TUSB_CLASS_HID,
.bInterfaceSubClass = HID_SUBCLASS_BOOT,
.bInterfaceProtocol = HID_PROTOCOL_KEYBOARD,
.iInterface = 0
};
void setUp(void)
{
dev_addr = 0;
instance_num = 0;
memset(&report, 0, sizeof(tusb_keyboard_report_t));
dev_addr = RANDOM(TUSB_CFG_HOST_DEVICE_MAX)+1;
keyboard_data[0].instance_count = 0;
keyboard_data[0].instance[0].pipe_in = (pipe_handle_t) { .dev_addr = 1, .xfer_type = TUSB_XFER_INTERRUPT, .index = 1};
keyboard_data[0].instance[0].report_size = sizeof(tusb_keyboard_report_t);
memclr_(&report, sizeof(tusb_keyboard_report_t));
kbd_descriptor = ((tusb_descriptor_interface_t)
{
.bLength = sizeof(tusb_descriptor_interface_t),
.bDescriptorType = TUSB_DESC_INTERFACE,
.bInterfaceNumber = 1,
.bAlternateSetting = 0,
.bNumEndpoints = 1,
.bInterfaceClass = TUSB_CLASS_HID,
.bInterfaceSubClass = HID_SUBCLASS_BOOT,
.bInterfaceProtocol = HID_PROTOCOL_KEYBOARD,
.iInterface = 0
});
hidh_keyboard_init();
keyboard_data[dev_addr-1].instance_count = 0;
p_hidh_kbd_interface = &keyboard_data[dev_addr-1].instance[instance_num];
p_hidh_kbd_interface->report_size = sizeof(tusb_keyboard_report_t);
p_hidh_kbd_interface->pipe_in = (pipe_handle_t) {
.dev_addr = dev_addr,
.xfer_type = TUSB_XFER_INTERRUPT,
.index = 1
};
}
@ -94,8 +106,8 @@ void tearDown(void)
//--------------------------------------------------------------------+
void test_keyboard_no_instances_invalid_para(void)
{
tusbh_device_get_state_IgnoreAndReturn(0);
TEST_ASSERT_EQUAL(0, tusbh_hid_keyboard_no_instances(TUSB_CFG_HOST_DEVICE_MAX));
tusbh_device_get_state_IgnoreAndReturn(TUSB_DEVICE_STATE_UNPLUG);
TEST_ASSERT_EQUAL(0, tusbh_hid_keyboard_no_instances(dev_addr));
}
void test_keyboard_install_ok(void)
@ -110,89 +122,61 @@ void test_keyboard_install_ok(void)
void test_keyboard_init(void)
{
class_hid_keyboard_info_t keyboard_info_zero[TUSB_CFG_HOST_DEVICE_MAX];
memset(keyboard_info_zero, 0, sizeof(class_hid_keyboard_info_t)*TUSB_CFG_HOST_DEVICE_MAX);
hidh_keyboard_init();
TEST_ASSERT_EQUAL_MEMORY(keyboard_info_zero, keyboard_data, sizeof(class_hid_keyboard_info_t)*TUSB_CFG_HOST_DEVICE_MAX);
for(uint32_t i=0; i < sizeof(hidh_keyboard_info_t)*TUSB_CFG_HOST_DEVICE_MAX; i++)
TEST_ASSERT_EQUAL(0, ((uint8_t*)keyboard_data) [i]);
}
//--------------------------------------------------------------------+
// keyboard_get
//--------------------------------------------------------------------+
pipe_status_t pipe_status_get_stub(pipe_handle_t pipe_hdl, int num_call)
{
switch (num_call)
{
case 0:
memcpy(keyboard_data[0].instance[0].buffer, &sample_key[0], sizeof(tusb_keyboard_report_t));
return PIPE_STATUS_COMPLETE;
break;
case 1:
return PIPE_STATUS_READY;
break;
case 2:
return PIPE_STATUS_BUSY;
break;
case 3:
memcpy(keyboard_data[0].instance[0].buffer, &sample_key[1], sizeof(tusb_keyboard_report_t));
return PIPE_STATUS_COMPLETE;
break;
default:
return PIPE_STATUS_READY;
}
}
void test_keyboard_get_invalid_para()
void test_keyboard_get_invalid_address(void)
{
tusbh_device_get_state_IgnoreAndReturn(TUSB_DEVICE_STATE_CONFIGURED);
TEST_ASSERT_EQUAL(TUSB_ERROR_INVALID_PARA, tusbh_hid_keyboard_get(0, 0, NULL));
TEST_ASSERT_EQUAL(TUSB_ERROR_INVALID_PARA, tusbh_hid_keyboard_get(0, 0, NULL)); // invalid address
}
tusbh_device_get_state_IgnoreAndReturn(0);
TEST_ASSERT_EQUAL(TUSB_ERROR_DEVICE_NOT_READY, tusbh_hid_keyboard_get(TUSB_CFG_HOST_DEVICE_MAX, 0, &report));
void test_keyboard_get_invalid_instance(void)
{
tusbh_device_get_state_IgnoreAndReturn(TUSB_DEVICE_STATE_CONFIGURED);
TEST_ASSERT_EQUAL(TUSB_ERROR_INVALID_PARA, tusbh_hid_keyboard_get(dev_addr, TUSB_CFG_HOST_HID_KEYBOARD_NO_INSTANCES_PER_DEVICE, &report)); // invalid instance
}
tusbh_device_get_state_IgnoreAndReturn(0);
TEST_ASSERT_EQUAL(TUSB_ERROR_DEVICE_NOT_READY, tusbh_hid_keyboard_get(0, TUSB_CFG_HOST_HID_KEYBOARD_NO_INSTANCES_PER_DEVICE, &report));
void test_keyboard_get_invalid_buffer(void)
{
tusbh_device_get_state_IgnoreAndReturn(TUSB_DEVICE_STATE_CONFIGURED);
TEST_ASSERT_EQUAL(TUSB_ERROR_INVALID_PARA, tusbh_hid_keyboard_get(dev_addr, 0, NULL)); // invalid buffer
}
void test_keyboard_get_device_not_ready(void)
{
tusbh_device_get_state_IgnoreAndReturn(TUSB_DEVICE_STATE_UNPLUG);
TEST_ASSERT_EQUAL(TUSB_ERROR_DEVICE_NOT_READY, tusbh_hid_keyboard_get(dev_addr, 0, &report)); // device not mounted
}
void test_keyboard_get_class_not_supported()
{
tusbh_device_get_state_IgnoreAndReturn(TUSB_DEVICE_STATE_CONFIGURED);
keyboard_data[dev_addr].instance[0].pipe_in = (pipe_handle_t) { 0 };
p_hidh_kbd_interface->pipe_in = (pipe_handle_t) { 0 };
TEST_ASSERT_EQUAL(TUSB_ERROR_CLASS_DEVICE_DONT_SUPPORT, tusbh_hid_keyboard_get(dev_addr, instance_num, &report));
}
void test_keyboard_get_report_not_available()
void test_keyboard_get_report_xfer_failed()
{
tusbh_device_get_state_IgnoreAndReturn(TUSB_DEVICE_STATE_CONFIGURED);
usbh_pipe_status_get_IgnoreAndReturn(PIPE_STATUS_BUSY);
TEST_ASSERT_EQUAL(TUSB_ERROR_CLASS_DATA_NOT_AVAILABLE, tusbh_hid_keyboard_get(dev_addr, instance_num, &report));
hcd_pipe_xfer_ExpectAndReturn(p_hidh_kbd_interface->pipe_in, &report, p_hidh_kbd_interface->report_size, true, TUSB_ERROR_INVALID_PARA);
tusbh_device_get_state_IgnoreAndReturn(TUSB_DEVICE_STATE_CONFIGURED);
usbh_pipe_status_get_IgnoreAndReturn(PIPE_STATUS_READY);
TEST_ASSERT_EQUAL(TUSB_ERROR_CLASS_DATA_NOT_AVAILABLE, tusbh_hid_keyboard_get(dev_addr, instance_num, &report));
//------------- Code Under TEST -------------//
TEST_ASSERT_EQUAL(TUSB_ERROR_INVALID_PARA, tusbh_hid_keyboard_get(dev_addr, instance_num, &report));
}
void test_keyboard_get_ok()
{
usbh_pipe_status_get_StubWithCallback(pipe_status_get_stub);
tusbh_device_get_state_IgnoreAndReturn(TUSB_DEVICE_STATE_CONFIGURED);
hcd_pipe_xfer_ExpectAndReturn(p_hidh_kbd_interface->pipe_in, &report, p_hidh_kbd_interface->report_size, true, TUSB_ERROR_NONE);
//------------- Code Under TEST -------------//
TEST_ASSERT_EQUAL(TUSB_ERROR_NONE, tusbh_hid_keyboard_get(dev_addr, instance_num, &report));
TEST_ASSERT_EQUAL_MEMORY(&sample_key[0], &report, sizeof(tusb_keyboard_report_t));
tusbh_device_get_state_IgnoreAndReturn(TUSB_DEVICE_STATE_CONFIGURED);
TEST_ASSERT_EQUAL(TUSB_ERROR_CLASS_DATA_NOT_AVAILABLE, tusbh_hid_keyboard_get(dev_addr, instance_num, &report));
tusbh_device_get_state_IgnoreAndReturn(TUSB_DEVICE_STATE_CONFIGURED);
TEST_ASSERT_EQUAL(TUSB_ERROR_CLASS_DATA_NOT_AVAILABLE, tusbh_hid_keyboard_get(dev_addr, instance_num, &report));
tusbh_device_get_state_IgnoreAndReturn(TUSB_DEVICE_STATE_CONFIGURED);
TEST_ASSERT_EQUAL(TUSB_ERROR_NONE, tusbh_hid_keyboard_get(dev_addr, instance_num, &report));
TEST_ASSERT_EQUAL_MEMORY(&sample_key[1], &report, sizeof(tusb_keyboard_report_t));
}

4
tests/test/host/test_usbh.c
View File

@ -50,7 +50,7 @@ extern usbh_device_info_t usbh_devices[TUSB_CFG_HOST_DEVICE_MAX+1];
uint8_t dev_addr;
void setUp(void)
{
dev_addr = 0;
dev_addr = RANDOM(TUSB_CFG_HOST_DEVICE_MAX)+1;
memset(usbh_devices, 0, (TUSB_CFG_HOST_DEVICE_MAX+1)*sizeof(usbh_device_info_t));
}
@ -106,7 +106,6 @@ void test_usbh_init_enum_queue_create_failed(void)
osal_semaphore_create_IgnoreAndReturn(sem_hdl_dummy);
}
osal_task_create_IgnoreAndReturn(TUSB_ERROR_NONE);
osal_queue_create_IgnoreAndReturn(NULL);
TEST_ASSERT_EQUAL(TUSB_ERROR_OSAL_QUEUE_FAILED, usbh_init());
@ -133,7 +132,6 @@ void test_usbh_init_ok(void)
{
osal_queue_handle_t dummy = 0x1122;
usbh_device_info_t device_info_zero[TUSB_CFG_HOST_DEVICE_MAX+1];
memclr_(device_info_zero, sizeof(usbh_device_info_t)*(TUSB_CFG_HOST_DEVICE_MAX+1));

22
tinyusb/class/hid_host.c
View File

@ -55,7 +55,7 @@
//--------------------------------------------------------------------+
// INTERNAL OBJECT & FUNCTION DECLARATION
//--------------------------------------------------------------------+
STATIC_ class_hid_keyboard_info_t keyboard_data[TUSB_CFG_HOST_DEVICE_MAX];
STATIC_ hidh_keyboard_info_t keyboard_data[TUSB_CFG_HOST_DEVICE_MAX]; // does not have addr0, index = dev_address-1
//--------------------------------------------------------------------+
@ -63,28 +63,28 @@ STATIC_ class_hid_keyboard_info_t keyboard_data[TUSB_CFG_HOST_DEVICE_MAX];
//--------------------------------------------------------------------+
tusb_error_t tusbh_hid_keyboard_get(uint8_t const dev_addr, uint8_t instance_num, tusb_keyboard_report_t * const report)
{
keyboard_interface_t *p_kbd;
//------------- parameters validation -------------//
ASSERT_INT(TUSB_DEVICE_STATE_CONFIGURED, tusbh_device_get_state(dev_addr), TUSB_ERROR_DEVICE_NOT_READY);
ASSERT_PTR(report, TUSB_ERROR_INVALID_PARA);
ASSERT(instance_num < TUSB_CFG_HOST_HID_KEYBOARD_NO_INSTANCES_PER_DEVICE, TUSB_ERROR_INVALID_PARA);
p_kbd = &keyboard_data[dev_addr].instance[instance_num];
keyboard_interface_t *p_kbd;
p_kbd = &keyboard_data[dev_addr-1].instance[instance_num];
// TODO abtract class support for device
ASSERT(0 != p_kbd->pipe_in.dev_addr, TUSB_ERROR_CLASS_DEVICE_DONT_SUPPORT);
ASSERT_INT(PIPE_STATUS_COMPLETE, usbh_pipe_status_get(p_kbd->pipe_in), TUSB_ERROR_CLASS_DATA_NOT_AVAILABLE);
memcpy(report, p_kbd->buffer, p_kbd->report_size);
// TODO abtract to use hidh service
ASSERT_STATUS( hcd_pipe_xfer(p_kbd->pipe_in, report, p_kbd->report_size, 1) ) ;
return TUSB_ERROR_NONE;
}
uint8_t tusbh_hid_keyboard_no_instances(uint8_t const dev_addr)
{
ASSERT_INT(TUSB_DEVICE_STATE_CONFIGURED, tusbh_device_get_state(dev_addr), 0);
ASSERT(tusbh_device_is_configured(dev_addr), 0);
return keyboard_data[dev_addr].instance_count;
return keyboard_data[dev_addr-1].instance_count;
}
//--------------------------------------------------------------------+
@ -99,12 +99,12 @@ void hidh_init(void)
void hidh_keyboard_init(void)
{
memclr_(&keyboard_data, sizeof(class_hid_keyboard_info_t)*TUSB_CFG_HOST_DEVICE_MAX);
memclr_(&keyboard_data, sizeof(hidh_keyboard_info_t)*TUSB_CFG_HOST_DEVICE_MAX);
}
tusb_error_t hidh_keyboard_install(uint8_t const dev_addr, uint8_t const *descriptor)
{
keyboard_data[dev_addr].instance_count++;
keyboard_data[dev_addr-1].instance_count++;
return TUSB_ERROR_NONE;
}

10
tinyusb/class/hid_host.h
View File

@ -62,7 +62,13 @@
//--------------------------------------------------------------------+
// APPLICATION API
//--------------------------------------------------------------------+
uint8_t tusbh_hid_keyboard_no_instances(uint8_t const dev_addr) ATTR_WARN_UNUSED_RESULT;
uint8_t tusbh_hid_keyboard_no_instances(uint8_t const dev_addr) ATTR_PURE ATTR_WARN_UNUSED_RESULT;
static inline bool tusbh_hid_keyboard_is_supported(uint8_t const dev_addr) ATTR_ALWAYS_INLINE ATTR_WARN_UNUSED_RESULT ATTR_PURE;
static inline bool tusbh_hid_keyboard_is_supported(uint8_t const dev_addr)
{
return tusbh_hid_keyboard_no_instances(dev_addr) > 0;
}
tusb_error_t tusbh_hid_keyboard_get(uint8_t const handle, uint8_t const instance_num, tusb_keyboard_report_t * const report) ATTR_WARN_UNUSED_RESULT;
pipe_status_t tusbh_hid_keyboard_pipe_status(uint8_t const handle, uint8_t const instance_num) ATTR_WARN_UNUSED_RESULT;
@ -80,7 +86,7 @@ typedef struct {
typedef struct {
uint8_t instance_count;
keyboard_interface_t instance[TUSB_CFG_HOST_HID_KEYBOARD_NO_INSTANCES_PER_DEVICE];
} class_hid_keyboard_info_t;
} hidh_keyboard_info_t;
void hidh_keyboard_init(void);
tusb_error_t hidh_keyboard_install(uint8_t dev_addr, uint8_t const *descriptor) ATTR_WARN_UNUSED_RESULT;

2
tinyusb/common/errors.h
View File

@ -64,7 +64,7 @@
ENTRY(TUSB_ERROR_INVALID_PARA)\
ENTRY(TUSB_ERROR_DEVICE_NOT_READY)\
ENTRY(TUSB_ERROR_CLASS_DEVICE_DONT_SUPPORT)\
ENTRY(TUSB_ERROR_CLASS_DATA_NOT_AVAILABLE)\
/*ENTRY(TUSB_ERROR_CLASS_DATA_NOT_AVAILABLE)*/\
ENTRY(TUSB_ERROR_HCD_FAILED)\
ENTRY(TUSB_ERROR_USBH_MOUNT_DEVICE_NOT_RESPOND)\
ENTRY(TUSB_ERROR_USBH_MOUNT_CONFIG_DESC_TOO_LONG)\

1
tinyusb/host/hcd.h
View File

@ -75,6 +75,7 @@ void hcd_isr(uint8_t hostid);
//--------------------------------------------------------------------+
// PIPE API
//--------------------------------------------------------------------+
// TODO control xfer should be used via usbh layer
tusb_error_t hcd_pipe_control_open(uint8_t dev_addr, uint8_t max_packet_size) ATTR_WARN_UNUSED_RESULT;
tusb_error_t hcd_pipe_control_xfer(uint8_t dev_addr, tusb_std_request_t const * p_request, uint8_t data[]) ATTR_WARN_UNUSED_RESULT;
tusb_error_t hcd_pipe_control_close(uint8_t dev_addr) ATTR_WARN_UNUSED_RESULT;

2
tinyusb/host/usbh.c
View File

@ -100,7 +100,7 @@ static inline uint8_t get_configure_number_for_device(tusb_descriptor_device_t*
//--------------------------------------------------------------------+
tusb_device_state_t tusbh_device_get_state (uint8_t const dev_addr)
{
ASSERT(dev_addr <= TUSB_CFG_HOST_DEVICE_MAX, TUSB_DEVICE_STATE_INVALID_PARAMETER);
ASSERT_INT_WITHIN(1, TUSB_CFG_HOST_DEVICE_MAX, dev_addr, TUSB_DEVICE_STATE_INVALID_PARAMETER);
return usbh_devices[dev_addr].state;
}

1
tinyusb/host/usbh.h
View File

@ -113,7 +113,6 @@ void tusbh_device_mount_failed_cb(tusb_error_t error, tusb_descriptor_de
#ifdef _TINY_USB_SOURCE_FILE_
tusb_error_t usbh_init(void);
pipe_status_t usbh_pipe_status_get(pipe_handle_t pipe_hdl) ATTR_WARN_UNUSED_RESULT;
#endif