mirror/tinyusb
1
0
Fork 0
mirror of https://github.com/hathach/tinyusb.git synced 2025-02-22 06:40:58 +00:00
Code Issues Packages Projects Releases Wiki Activity

start merge hidh_keyboard back to hidh

Browse Source
This commit is contained in:
hathach 2013-03-26 11:41:41 +07:00
parent a7e8a2ba9a
commit 54acee1fc8
7 changed files with 116 additions and 280 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

35
tests/test/host/hid/test_hid_host.c
View File

@ -45,7 +45,6 @@
#include "mock_osal.h" #include "mock_osal.h"
#include "mock_hcd.h" #include "mock_hcd.h"
#include "mock_usbh.h" #include "mock_usbh.h"
#include "mock_hid_host_keyboard.h"
#include "hid_host.h" #include "hid_host.h"
@ -64,39 +63,31 @@ void tearDown(void)
{ {
} }
void test_hidh_init_ok(void)
{
// hidh_keyboard_init_Expect();
// TODO mouse, generic expect
//------------- Code Under TEST -------------//
// hidh_init();
}
void test_hidh_open_ok(void) void test_hidh_open_ok(void)
{ {
uint16_t length=0; uint16_t length=0;
// pipe_handle_t pipe_hdl = {.dev_addr = dev_addr, .xfer_type = TUSB_XFER_INTERRUPT, .index = 2};
// hidh_keyboard_open_subtask_ExpectAndReturn(dev_addr, p_kbd_interface_desc, &length, TUSB_ERROR_NONE);
//
//------------- Code Under TEST -------------//
// hidh_open_subtask(dev_addr, (uint8_t*) p_kbd_interface_desc, &length);
// TEST_ASSERT_EQUAL(sizeof(tusb_descriptor_interface_t) + sizeof(tusb_hid_descriptor_hid_t) + sizeof(tusb_descriptor_endpoint_t), // TODO expect get HID report descriptor
// length); hcd_pipe_open_IgnoreAndReturn( pipe_hdl );
//------------- Code Under TEST -------------//
TEST_ASSERT_EQUAL(TUSB_ERROR_NONE, hidh_open_subtask(dev_addr, (uint8_t*) p_kbd_interface_desc, &length) );
TEST_ASSERT_EQUAL(sizeof(tusb_descriptor_interface_t) + sizeof(tusb_hid_descriptor_hid_t) + sizeof(tusb_descriptor_endpoint_t),
length);
} }
void test_hidh_close(void) void test_hidh_close(void)
{ {
hidh_keyboard_close_Expect(dev_addr); TEST_IGNORE();
//------------- Code Under TEST -------------// //------------- Code Under TEST -------------//
hidh_close(dev_addr); hidh_close(dev_addr);
} }
void test_hihd_isr(void) void test_hihd_isr(void)
{ {
if (!hidh_isr) TEST_IGNORE();
TEST_IGNORE(); //------------- Code Under TEST -------------//
// hidh_isr()
} }

39
tests/test/host/hid/test_hidh_keyboard.c
View File

@ -37,9 +37,9 @@
#include "stdlib.h" #include "stdlib.h"
#include "unity.h" #include "unity.h"
#include "type_helper.h"
#include "errors.h" #include "errors.h"
#include "hid_host.h" #include "hid_host.h"
#include "hid_host_keyboard.h"
#include "mock_osal.h" #include "mock_osal.h"
#include "mock_usbh.h" #include "mock_usbh.h"
#include "mock_hcd.h" #include "mock_hcd.h"
@ -71,7 +71,7 @@ void setUp(void)
memclr_(&report, sizeof(tusb_keyboard_report_t)); memclr_(&report, sizeof(tusb_keyboard_report_t));
dev_addr = RANDOM(TUSB_CFG_HOST_DEVICE_MAX)+1; dev_addr = RANDOM(TUSB_CFG_HOST_DEVICE_MAX)+1;
hidh_keyboard_init(); hidh_init();
p_hidh_kbd = &keyboard_data[dev_addr-1]; p_hidh_kbd = &keyboard_data[dev_addr-1];
@ -88,28 +88,25 @@ void tearDown(void)
{ {
} }
//--------------------------------------------------------------------+ void test_keyboard_init(void)
// keyboard_install, keyboard_no_instances, keybaord_init
//--------------------------------------------------------------------+
void TEST_ASSERT_PIPE_HANDLE(pipe_handle_t x, pipe_handle_t y)
{ {
TEST_ASSERT_EQUAL(x.dev_addr , y.dev_addr); hidh_init();
TEST_ASSERT_EQUAL(x.xfer_type , y.xfer_type);
TEST_ASSERT_EQUAL(x.index , y.index); TEST_ASSERT_MEM_ZERO(keyboard_data, sizeof(hidh_keyboard_info_t)*TUSB_CFG_HOST_DEVICE_MAX);
} }
void test_keyboard_is_supported_fail(void) void test_keyboard_is_supported_fail_unplug(void)
{ {
hidh_init();
tusbh_device_get_state_IgnoreAndReturn(TUSB_DEVICE_STATE_UNPLUG); tusbh_device_get_state_IgnoreAndReturn(TUSB_DEVICE_STATE_UNPLUG);
TEST_ASSERT_FALSE( tusbh_hid_keyboard_is_supported(dev_addr) ); TEST_ASSERT_FALSE( tusbh_hid_keyboard_is_supported(dev_addr) );
} }
void test_keyboard_init(void) void test_keyboard_is_supported_fail_not_opened(void)
{ {
hidh_keyboard_init(); hidh_init();
tusbh_device_get_state_IgnoreAndReturn(TUSB_DEVICE_STATE_CONFIGURED);
for(uint32_t i=0; i < sizeof(hidh_keyboard_info_t)*TUSB_CFG_HOST_DEVICE_MAX; i++) TEST_ASSERT_FALSE( tusbh_hid_keyboard_is_supported(dev_addr) );
TEST_ASSERT_EQUAL(0, ((uint8_t*)keyboard_data) [i]);
} }
void test_keyboard_open_ok(void) void test_keyboard_open_ok(void)
@ -121,7 +118,7 @@ void test_keyboard_open_ok(void)
hcd_pipe_open_ExpectAndReturn(dev_addr, p_kdb_endpoint_desc, TUSB_CLASS_HID, pipe_hdl); hcd_pipe_open_ExpectAndReturn(dev_addr, p_kdb_endpoint_desc, TUSB_CLASS_HID, pipe_hdl);
//------------- Code Under TEST -------------// //------------- Code Under TEST -------------//
TEST_ASSERT_EQUAL(TUSB_ERROR_NONE, hidh_keyboard_open_subtask(dev_addr, (uint8_t*) p_kbd_interface_desc, &length)); TEST_ASSERT_EQUAL(TUSB_ERROR_NONE, hidh_open_subtask(dev_addr, (uint8_t*) p_kbd_interface_desc, &length));
TEST_ASSERT_PIPE_HANDLE(pipe_hdl, p_hidh_kbd->pipe_hdl); TEST_ASSERT_PIPE_HANDLE(pipe_hdl, p_hidh_kbd->pipe_hdl);
TEST_ASSERT_EQUAL(8, p_hidh_kbd->report_size); TEST_ASSERT_EQUAL(8, p_hidh_kbd->report_size);
@ -143,19 +140,19 @@ void test_keyboard_close(void)
void test_keyboard_get_invalid_address(void) void test_keyboard_get_invalid_address(void)
{ {
tusbh_device_get_state_IgnoreAndReturn(TUSB_DEVICE_STATE_CONFIGURED); tusbh_device_get_state_IgnoreAndReturn(TUSB_DEVICE_STATE_CONFIGURED);
TEST_ASSERT_EQUAL(TUSB_ERROR_INVALID_PARA, tusbh_hid_keyboard_get(0, 0, NULL)); // invalid address TEST_ASSERT_EQUAL(TUSB_ERROR_INVALID_PARA, tusbh_hid_keyboard_get_report(0, 0, NULL)); // invalid address
} }
void test_keyboard_get_invalid_buffer(void) void test_keyboard_get_invalid_buffer(void)
{ {
tusbh_device_get_state_IgnoreAndReturn(TUSB_DEVICE_STATE_CONFIGURED); 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 TEST_ASSERT_EQUAL(TUSB_ERROR_INVALID_PARA, tusbh_hid_keyboard_get_report(dev_addr, 0, NULL)); // invalid buffer
} }
void test_keyboard_get_device_not_ready(void) void test_keyboard_get_device_not_ready(void)
{ {
tusbh_device_get_state_IgnoreAndReturn(TUSB_DEVICE_STATE_UNPLUG); 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 TEST_ASSERT_EQUAL(TUSB_ERROR_DEVICE_NOT_READY, tusbh_hid_keyboard_get_report(dev_addr, 0, &report)); // device not mounted
} }
void test_keyboard_get_report_xfer_failed() void test_keyboard_get_report_xfer_failed()
@ -164,7 +161,7 @@ void test_keyboard_get_report_xfer_failed()
hcd_pipe_xfer_ExpectAndReturn(p_hidh_kbd->pipe_hdl, (uint8_t*) &report, p_hidh_kbd->report_size, true, TUSB_ERROR_INVALID_PARA); hcd_pipe_xfer_ExpectAndReturn(p_hidh_kbd->pipe_hdl, (uint8_t*) &report, p_hidh_kbd->report_size, true, TUSB_ERROR_INVALID_PARA);
//------------- Code Under TEST -------------// //------------- Code Under TEST -------------//
TEST_ASSERT_EQUAL(TUSB_ERROR_INVALID_PARA, tusbh_hid_keyboard_get(dev_addr, 0, &report)); TEST_ASSERT_EQUAL(TUSB_ERROR_INVALID_PARA, tusbh_hid_keyboard_get_report(dev_addr, 0, &report));
} }
void test_keyboard_get_ok() void test_keyboard_get_ok()
@ -173,6 +170,6 @@ void test_keyboard_get_ok()
hcd_pipe_xfer_ExpectAndReturn(p_hidh_kbd->pipe_hdl, (uint8_t*) &report, p_hidh_kbd->report_size, true, TUSB_ERROR_NONE); hcd_pipe_xfer_ExpectAndReturn(p_hidh_kbd->pipe_hdl, (uint8_t*) &report, p_hidh_kbd->report_size, true, TUSB_ERROR_NONE);
//------------- Code Under TEST -------------// //------------- Code Under TEST -------------//
TEST_ASSERT_EQUAL(TUSB_ERROR_NONE, tusbh_hid_keyboard_get(dev_addr, 0, &report)); TEST_ASSERT_EQUAL(TUSB_ERROR_NONE, tusbh_hid_keyboard_get_report(dev_addr, 0, &report));
} }

70
tinyusb/class/hid_host.c
View File

@ -54,6 +54,13 @@
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+
// INTERNAL OBJECT & FUNCTION DECLARATION // INTERNAL OBJECT & FUNCTION DECLARATION
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+
STATIC_ hidh_keyboard_info_t keyboard_data[TUSB_CFG_HOST_DEVICE_MAX]; // does not have addr0, index = dev_address-1
static inline hidh_keyboard_info_t* get_kbd_data(uint8_t dev_addr) ATTR_PURE ATTR_ALWAYS_INLINE ATTR_WARN_UNUSED_RESULT;
static inline hidh_keyboard_info_t* get_kbd_data(uint8_t dev_addr)
{
return &keyboard_data[dev_addr-1];
}
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+
// CLASS-USBD API (don't require to verify parameters) // CLASS-USBD API (don't require to verify parameters)
@ -61,7 +68,7 @@
void hidh_init(void) void hidh_init(void)
{ {
#if TUSB_CFG_HOST_HID_KEYBOARD #if TUSB_CFG_HOST_HID_KEYBOARD
hidh_keyboard_init(); memclr_(&keyboard_data, sizeof(hidh_keyboard_info_t)*TUSB_CFG_HOST_DEVICE_MAX);
#endif #endif
#if TUSB_CFG_HOST_HID_MOUSE #if TUSB_CFG_HOST_HID_MOUSE
@ -73,6 +80,36 @@ void hidh_init(void)
#endif #endif
} }
tusb_error_t hidh_keyboard_open_subtask(uint8_t dev_addr, uint8_t const *descriptor, uint16_t *p_length)
{
hidh_keyboard_info_t *p_keyboard = get_kbd_data(dev_addr);
uint8_t const *p_desc = descriptor;
p_desc += p_desc[DESCRIPTOR_OFFSET_LENGTH]; // skip interface
(*p_length) = p_desc - descriptor; // set ASAP, in case of error, p_length has to be not zero to prevent infinite re-open
//------------- HID descriptor -------------//
tusb_hid_descriptor_hid_t* const p_desc_hid = (tusb_hid_descriptor_hid_t* const) p_desc;
ASSERT_INT(HID_DESC_HID, p_desc_hid->bDescriptorType, TUSB_ERROR_INVALID_PARA);
p_desc += p_desc[DESCRIPTOR_OFFSET_LENGTH]; // TODO skip HID, only support std keyboard
(*p_length) = p_desc - descriptor;
//------------- Endpoint Descriptor -------------//
ASSERT_INT(TUSB_DESC_ENDPOINT, p_desc[DESCRIPTOR_OFFSET_TYPE], TUSB_ERROR_INVALID_PARA);
p_keyboard->pipe_hdl = hcd_pipe_open(dev_addr, (tusb_descriptor_endpoint_t*) p_desc, TUSB_CLASS_HID);
p_keyboard->report_size = ( ((tusb_descriptor_endpoint_t*) p_desc)->wMaxPacketSize & (BIT_(12)-1) );
p_desc += p_desc[DESCRIPTOR_OFFSET_LENGTH]; // advance endpoint descriptor
(*p_length) = p_desc - descriptor;
ASSERT (pipehandle_is_valid(p_keyboard->pipe_hdl), TUSB_ERROR_HCD_FAILED);
return TUSB_ERROR_NONE;
}
tusb_error_t hidh_open_subtask(uint8_t dev_addr, uint8_t const *descriptor, uint16_t *p_length) tusb_error_t hidh_open_subtask(uint8_t dev_addr, uint8_t const *descriptor, uint16_t *p_length)
{ {
tusb_descriptor_interface_t* p_interface = (tusb_descriptor_interface_t*) descriptor; tusb_descriptor_interface_t* p_interface = (tusb_descriptor_interface_t*) descriptor;
@ -82,6 +119,7 @@ tusb_error_t hidh_open_subtask(uint8_t dev_addr, uint8_t const *descriptor, uint
{ {
#if TUSB_CFG_HOST_HID_KEYBOARD #if TUSB_CFG_HOST_HID_KEYBOARD
case HID_PROTOCOL_KEYBOARD: case HID_PROTOCOL_KEYBOARD:
return hidh_keyboard_open_subtask(dev_addr, descriptor, p_length); return hidh_keyboard_open_subtask(dev_addr, descriptor, p_length);
break; break;
#endif #endif
@ -112,7 +150,7 @@ void hidh_isr(pipe_handle_t pipe_hdl, tusb_bus_event_t event)
void hidh_close(uint8_t dev_addr) void hidh_close(uint8_t dev_addr)
{ {
#if TUSB_CFG_HOST_HID_KEYBOARD #if TUSB_CFG_HOST_HID_KEYBOARD
hidh_keyboard_close(dev_addr); // hidh_keyboard_close(dev_addr);
#endif #endif
#if TUSB_CFG_HOST_HID_MOUSE #if TUSB_CFG_HOST_HID_MOUSE
@ -124,4 +162,32 @@ void hidh_close(uint8_t dev_addr)
#endif #endif
} }
//--------------------------------------------------------------------+
// KEYBOARD PUBLIC API (parameter validation required)
//--------------------------------------------------------------------+
#if TUSB_CFG_HOST_HID_KEYBOARD
bool tusbh_hid_keyboard_is_supported(uint8_t dev_addr)
{
return tusbh_device_is_configured(dev_addr) && pipehandle_is_valid(keyboard_data[dev_addr-1].pipe_hdl);
}
tusb_error_t tusbh_hid_keyboard_get_report(uint8_t dev_addr, uint8_t instance_num, tusb_keyboard_report_t * const report)
{
//------------- 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);
(void) instance_num;
hidh_keyboard_info_t *p_keyboard = get_kbd_data(dev_addr);
// TODO abstract to use hidh service
ASSERT_STATUS( hcd_pipe_xfer(p_keyboard->pipe_hdl, (uint8_t*) report, p_keyboard->report_size, true) ) ;
return TUSB_ERROR_NONE;
}
#endif
#endif #endif

24
tinyusb/class/hid_host.h
View File

@ -59,20 +59,28 @@
#include "host/usbh.h" #include "host/usbh.h"
#include "hid.h" #include "hid.h"
#if TUSB_CFG_HOST_HID_KEYBOARD //--------------------------------------------------------------------+
#include "hid_host_keyboard.h" // KEYBOARD Public API
#endif //--------------------------------------------------------------------+
typedef struct {
pipe_handle_t pipe_hdl;
uint16_t report_size;
}hidh_keyboard_info_t;
#if TUSB_CFG_HOST_HID_MOUSE bool tusbh_hid_keyboard_is_supported(uint8_t dev_addr) ATTR_PURE ATTR_WARN_UNUSED_RESULT;
#include "hid_host_mouse.h" tusb_error_t tusbh_hid_keyboard_get_report(uint8_t dev_addr, uint8_t instance_num, tusb_keyboard_report_t * const report) ATTR_WARN_UNUSED_RESULT;
#endif pipe_status_t tusbh_hid_keyboard_status(uint8_t dev_addr, uint8_t instance_num) ATTR_WARN_UNUSED_RESULT;
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+
// APPLICATION API // MOUSE Public API
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+
// CLASS DRIVER FUNCTION // GENERIC Public API
//--------------------------------------------------------------------+
//--------------------------------------------------------------------+
// USBH-CLASS DRIVER API
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+
#ifdef _TINY_USB_SOURCE_FILE_ #ifdef _TINY_USB_SOURCE_FILE_

135
tinyusb/class/hid_host_keyboard.c
View File

@ -1,135 +0,0 @@
/*
* hid_host_keyboard.c
*
* Created on: Mar 25, 2013
* Author: hathach
*/
/*
* Software License Agreement (BSD License)
* Copyright (c) 2012, hathach (tinyusb.net)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
* SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
* OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
* OF SUCH DAMAGE.
*
* This file is part of the tiny usb stack.
*/
#include "tusb_option.h"
#if (MODE_HOST_SUPPORTED && TUSB_CFG_HOST_HID_KEYBOARD)
#define _TINY_USB_SOURCE_FILE_
//--------------------------------------------------------------------+
// INCLUDE
//--------------------------------------------------------------------+
#include "common/common.h"
#include "hid_host.h"
//--------------------------------------------------------------------+
// MACRO CONSTANT TYPEDEF
//--------------------------------------------------------------------+
//--------------------------------------------------------------------+
// INTERNAL OBJECT & FUNCTION DECLARATION
//--------------------------------------------------------------------+
STATIC_ hidh_keyboard_info_t keyboard_data[TUSB_CFG_HOST_DEVICE_MAX]; // does not have addr0, index = dev_address-1
static inline hidh_keyboard_info_t* get_kbd_data(uint8_t dev_addr) ATTR_PURE ATTR_ALWAYS_INLINE ATTR_WARN_UNUSED_RESULT;
static inline hidh_keyboard_info_t* get_kbd_data(uint8_t dev_addr)
{
return &keyboard_data[dev_addr-1];
}
//--------------------------------------------------------------------+
// IMPLEMENTATION
//--------------------------------------------------------------------+
//--------------------------------------------------------------------+
// PUBLIC API (parameter validation required)
//--------------------------------------------------------------------+
bool tusbh_hid_keyboard_is_supported(uint8_t dev_addr)
{
return tusbh_device_is_configured(dev_addr) && pipehandle_is_valid(keyboard_data[dev_addr-1].pipe_hdl);
}
tusb_error_t tusbh_hid_keyboard_get(uint8_t dev_addr, uint8_t instance_num, tusb_keyboard_report_t * const report)
{
//------------- 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);
(void) instance_num;
hidh_keyboard_info_t *p_keyboard = get_kbd_data(dev_addr);
// TODO abstract to use hidh service
ASSERT_STATUS( hcd_pipe_xfer(p_keyboard->pipe_hdl, (uint8_t*) report, p_keyboard->report_size, true) ) ;
return TUSB_ERROR_NONE;
}
//--------------------------------------------------------------------+
// INTERNAL API (no need for parameter validation)
//--------------------------------------------------------------------+
void hidh_keyboard_init(void)
{
memclr_(&keyboard_data, sizeof(hidh_keyboard_info_t)*TUSB_CFG_HOST_DEVICE_MAX);
}
tusb_error_t hidh_keyboard_open_subtask(uint8_t dev_addr, uint8_t const *descriptor, uint16_t *p_length)
{
hidh_keyboard_info_t *p_keyboard = get_kbd_data(dev_addr);
uint8_t const *p_desc = descriptor;
p_desc += p_desc[DESCRIPTOR_OFFSET_LENGTH]; // skip interface
(*p_length) = p_desc - descriptor; // set ASAP, in case of error, p_length has to be not zero to prevent infinite re-open
//------------- HID descriptor -------------//
tusb_hid_descriptor_hid_t* const p_desc_hid = (tusb_hid_descriptor_hid_t* const) p_desc;
ASSERT_INT(HID_DESC_HID, p_desc_hid->bDescriptorType, TUSB_ERROR_INVALID_PARA);
p_desc += p_desc[DESCRIPTOR_OFFSET_LENGTH]; // TODO skip HID, only support std keyboard
(*p_length) = p_desc - descriptor;
//------------- Endpoint Descriptor -------------//
ASSERT_INT(TUSB_DESC_ENDPOINT, p_desc[DESCRIPTOR_OFFSET_TYPE], TUSB_ERROR_INVALID_PARA);
p_keyboard->pipe_hdl = hcd_pipe_open(dev_addr, (tusb_descriptor_endpoint_t*) p_desc, TUSB_CLASS_HID);
p_keyboard->report_size = ( ((tusb_descriptor_endpoint_t*) p_desc)->wMaxPacketSize & (BIT_(12)-1) );
p_desc += p_desc[DESCRIPTOR_OFFSET_LENGTH]; // advance endpoint descriptor
(*p_length) = p_desc - descriptor;
ASSERT (pipehandle_is_valid(p_keyboard->pipe_hdl), TUSB_ERROR_HCD_FAILED);
return TUSB_ERROR_NONE;
}
void hidh_keyboard_close(uint8_t dev_addr)
{
}
#endif

91
tinyusb/class/hid_host_keyboard.h
View File

@ -1,91 +0,0 @@
/*
* hid_host_keyboard.h
*
* Created on: Mar 25, 2013
* Author: hathach
*/
/*
* Software License Agreement (BSD License)
* Copyright (c) 2012, hathach (tinyusb.net)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
* SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
* OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
* OF SUCH DAMAGE.
*
* This file is part of the tiny usb stack.
*/
/** \file
* \brief TBD
*
* \note TBD
*/
/** \ingroup TBD
* \defgroup TBD
* \brief TBD
*
* @{
*/
#ifndef _TUSB_HID_HOST_KEYBOARD_H_
#define _TUSB_HID_HOST_KEYBOARD_H_
#include "common/common.h"
#include "host/usbh.h" // TODO refractor
#include "hid.h"
#ifdef __cplusplus
extern "C" {
#endif
//--------------------------------------------------------------------+
// PUBLIC API (parameter validation required)
//--------------------------------------------------------------------+
bool tusbh_hid_keyboard_is_supported(uint8_t dev_addr) ATTR_PURE ATTR_WARN_UNUSED_RESULT;
tusb_error_t tusbh_hid_keyboard_get(uint8_t dev_addr, uint8_t instance_num, tusb_keyboard_report_t * const report) ATTR_WARN_UNUSED_RESULT;
pipe_status_t tusbh_hid_keyboard_pipe_status(uint8_t dev_addr, uint8_t instance_num) ATTR_WARN_UNUSED_RESULT;
//--------------------------------------------------------------------+
// INTERNAL API (no need for parameter validation)
//--------------------------------------------------------------------+
#ifdef _TINY_USB_SOURCE_FILE_
typedef struct {
pipe_handle_t pipe_hdl;
uint16_t report_size;
}hidh_keyboard_info_t;
void hidh_keyboard_init(void);
tusb_error_t hidh_keyboard_open_subtask(uint8_t dev_addr, uint8_t const *descriptor, uint16_t *p_length) ATTR_WARN_UNUSED_RESULT;
void hidh_keyboard_close(uint8_t dev_addr);
#endif
#ifdef __cplusplus
}
#endif
#endif /* _TUSB_HID_HOST_KEYBOARD_H_ */
/** @} */

2
tinyusb/host/usbh.c
View File

@ -317,7 +317,7 @@ OSAL_TASK_DECLARE(usbh_enumeration_task)
usbh_pipe_control_close(0); usbh_pipe_control_close(0);
usbh_devices[0].state = TUSB_DEVICE_STATE_UNPLUG; usbh_devices[0].state = TUSB_DEVICE_STATE_UNPLUG;
// hcd_port_reset( usbh_device_info_pool[new_addr].core_id ); TODO verified // hcd_port_reset( usbh_device_info_pool[new_addr].core_id ); TODO may need to reset device after set address
// open control pipe for new address // open control pipe for new address
TASK_ASSERT_STATUS ( usbh_pipe_control_open(new_addr, ((tusb_descriptor_device_t*) enum_data_buffer)->bMaxPacketSize0 ) ); TASK_ASSERT_STATUS ( usbh_pipe_control_open(new_addr, ((tusb_descriptor_device_t*) enum_data_buffer)->bMaxPacketSize0 ) );