Embedded/tinyusb
1
0
Fork 0
mirror of https://github.com/hathach/tinyusb.git synced 2025-01-31 05:52:55 +08:00
Code Issues Packages Projects Releases Wiki Activity

fix potential error with usbh_control_xfer_subtask in subtask_assert

Browse Source 
change back to use task_assert style in usbh_enumeraion
change test to task->subtask->subtask style in test/test_osal_none.c
This commit is contained in:
hathach 2013-04-24 12:20:56 +07:00
parent 73d5f00a40
commit d312be7006
3 changed files with 206 additions and 201 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

48
tests/test/test_osal_none.c
View File

@ -241,25 +241,47 @@ void flow_control_error_handler(void)
statements[5]++; statements[5]++;
} }
tusb_error_t sample_flow_control_subtask2(void)
{
tusb_error_t error;
OSAL_SUBTASK_BEGIN
statements[0]++;
osal_semaphore_wait(sem_hdl, OSAL_TIMEOUT_NORMAL, &error);
SUBTASK_ASSERT(TUSB_ERROR_NONE == error);
statements[1]++;
osal_semaphore_wait(sem_hdl, OSAL_TIMEOUT_NORMAL, &error);
SUBTASK_ASSERT_STATUS(error);
statements[2]++;
osal_semaphore_wait(sem_hdl, OSAL_TIMEOUT_NORMAL, &error);
SUBTASK_ASSERT_STATUS_WITH_HANDLER(error, flow_control_error_handler());
statements[3]++;
OSAL_SUBTASK_END
}
tusb_error_t sample_flow_control_subtask(void)
{
tusb_error_t error;
OSAL_SUBTASK_BEGIN
OSAL_SUBTASK_INVOKED_AND_WAIT (sample_flow_control_subtask2());
OSAL_SUBTASK_END
}
tusb_error_t sample_task_flow_control(void) tusb_error_t sample_task_flow_control(void)
{ {
tusb_error_t error; tusb_error_t error;
OSAL_TASK_LOOP_BEGIN OSAL_TASK_LOOP_BEGIN
statements[0]++; OSAL_SUBTASK_INVOKED_AND_WAIT ( sample_flow_control_subtask() );
osal_semaphore_wait(sem_hdl, OSAL_TIMEOUT_NORMAL, &error);
TASK_ASSERT(TUSB_ERROR_NONE == error);
statements[1]++;
osal_semaphore_wait(sem_hdl, OSAL_TIMEOUT_NORMAL, &error);
TASK_ASSERT_STATUS(error);
statements[2]++;
osal_semaphore_wait(sem_hdl, OSAL_TIMEOUT_NORMAL, &error);
TASK_ASSERT_STATUS_WITH_HANDLER(error, flow_control_error_handler());
statements[3]++;
OSAL_TASK_LOOP_END OSAL_TASK_LOOP_END
} }

47
tinyusb/host/usbh.c
View File

@ -155,12 +155,8 @@ tusb_error_t usbh_control_xfer_subtask(uint8_t dev_addr, tusb_std_request_t cons
osal_semaphore_wait(usbh_devices[dev_addr].control.sem_hdl, OSAL_TIMEOUT_NORMAL, &error); // careful of local variable without static osal_semaphore_wait(usbh_devices[dev_addr].control.sem_hdl, OSAL_TIMEOUT_NORMAL, &error); // careful of local variable without static
// TODO make handler for this function general purpose // TODO make handler for this function general purpose
SUBTASK_ASSERT_STATUS_WITH_HANDLER(error || usbh_devices[dev_addr].control.pipe_status == TUSB_INTERFACE_STATUS_ERROR, SUBTASK_ASSERT_WITH_HANDLER(TUSB_ERROR_NONE == error && usbh_devices[dev_addr].control.pipe_status != TUSB_INTERFACE_STATUS_ERROR,
tusbh_device_mount_failed_cb(TUSB_ERROR_USBH_MOUNT_DEVICE_NOT_RESPOND, NULL) ); tusbh_device_mount_failed_cb(TUSB_ERROR_USBH_MOUNT_DEVICE_NOT_RESPOND, NULL) );
// if ( TUSB_ERROR_NONE != error || usbh_devices[dev_addr].control.pipe_status == TUSB_INTERFACE_STATUS_ERROR)
// {
// tusbh_device_mount_failed_cb(TUSB_ERROR_USBH_MOUNT_DEVICE_NOT_RESPOND, NULL);
// }
OSAL_SUBTASK_END OSAL_SUBTASK_END
} }
@ -267,15 +263,13 @@ OSAL_TASK_FUNCTION(usbh_enumeration_task)
osal_queue_receive(enum_queue_hdl, &enum_entry, OSAL_TIMEOUT_WAIT_FOREVER, &error); osal_queue_receive(enum_queue_hdl, &enum_entry, OSAL_TIMEOUT_WAIT_FOREVER, &error);
if( hcd_port_connect_status(enum_entry.core_id) ) // ensure device is still plugged SUBTASK_ASSERT( hcd_port_connect_status(enum_entry.core_id) ); // ensure device is still plugged
{
usbh_devices[0].core_id = enum_entry.core_id; // TODO refractor integrate to device_pool usbh_devices[0].core_id = enum_entry.core_id; // TODO refractor integrate to device_pool
usbh_devices[0].hub_addr = enum_entry.hub_addr; usbh_devices[0].hub_addr = enum_entry.hub_addr;
usbh_devices[0].hub_port = enum_entry.hub_port; usbh_devices[0].hub_port = enum_entry.hub_port;
usbh_devices[0].speed = enum_entry.speed; usbh_devices[0].speed = enum_entry.speed;
if( TUSB_ERROR_NONE == usbh_pipe_control_open(0, 8) ) SUBTASK_ASSERT_STATUS( usbh_pipe_control_open(0, 8) );
{
usbh_devices[0].state = TUSB_DEVICE_STATE_ADDRESSED; usbh_devices[0].state = TUSB_DEVICE_STATE_ADDRESSED;
#ifndef _TEST_ #ifndef _TEST_
@ -304,8 +298,8 @@ OSAL_TASK_FUNCTION(usbh_enumeration_task)
//------------- Set new address -------------// //------------- Set new address -------------//
new_addr = get_new_address(); new_addr = get_new_address();
if (new_addr <= TUSB_CFG_HOST_DEVICE_MAX) // TODO notify application we reach max devices SUBTASK_ASSERT(new_addr <= TUSB_CFG_HOST_DEVICE_MAX); // TODO notify application we reach max devices
{
OSAL_SUBTASK_INVOKED_AND_WAIT( OSAL_SUBTASK_INVOKED_AND_WAIT(
usbh_control_xfer_subtask( usbh_control_xfer_subtask(
0, 0,
@ -330,8 +324,8 @@ OSAL_TASK_FUNCTION(usbh_enumeration_task)
usbh_devices[0].state = TUSB_DEVICE_STATE_UNPLUG; usbh_devices[0].state = TUSB_DEVICE_STATE_UNPLUG;
// open control pipe for new address // open control pipe for new address
if ( TUSB_ERROR_NONE == usbh_pipe_control_open(new_addr, ((tusb_descriptor_device_t*) enum_data_buffer)->bMaxPacketSize0 ) ) SUBTASK_ASSERT_STATUS ( usbh_pipe_control_open(new_addr, ((tusb_descriptor_device_t*) enum_data_buffer)->bMaxPacketSize0 ) );
{
//------------- Get full device descriptor -------------// //------------- Get full device descriptor -------------//
OSAL_SUBTASK_INVOKED_AND_WAIT( OSAL_SUBTASK_INVOKED_AND_WAIT(
usbh_control_xfer_subtask( usbh_control_xfer_subtask(
@ -353,8 +347,8 @@ OSAL_TASK_FUNCTION(usbh_enumeration_task)
usbh_devices[new_addr].configure_count = ((tusb_descriptor_device_t*) enum_data_buffer)->bNumConfigurations; usbh_devices[new_addr].configure_count = ((tusb_descriptor_device_t*) enum_data_buffer)->bNumConfigurations;
configure_selected = get_configure_number_for_device((tusb_descriptor_device_t*) enum_data_buffer); configure_selected = get_configure_number_for_device((tusb_descriptor_device_t*) enum_data_buffer);
if(configure_selected <= usbh_devices[new_addr].configure_count) // TODO notify application when invalid configuration SUBTASK_ASSERT(configure_selected <= usbh_devices[new_addr].configure_count); // TODO notify application when invalid configuration
{
//------------- Get 9 bytes of configuration descriptor -------------// //------------- Get 9 bytes of configuration descriptor -------------//
OSAL_SUBTASK_INVOKED_AND_WAIT( OSAL_SUBTASK_INVOKED_AND_WAIT(
usbh_control_xfer_subtask( usbh_control_xfer_subtask(
@ -369,12 +363,9 @@ OSAL_TASK_FUNCTION(usbh_enumeration_task)
enum_data_buffer enum_data_buffer
) )
); );
SUBTASK_ASSERT_WITH_HANDLER( TUSB_CFG_HOST_ENUM_BUFFER_SIZE > ((tusb_descriptor_configuration_t*)enum_data_buffer)->wTotalLength,
tusbh_device_mount_failed_cb(TUSB_ERROR_USBH_MOUNT_CONFIG_DESC_TOO_LONG, NULL) );
if ( TUSB_CFG_HOST_ENUM_BUFFER_SIZE <= ((tusb_descriptor_configuration_t*)enum_data_buffer)->wTotalLength )
{
tusbh_device_mount_failed_cb(TUSB_ERROR_USBH_MOUNT_CONFIG_DESC_TOO_LONG, NULL);
}else
{
//------------- Get full configuration descriptor -------------// //------------- Get full configuration descriptor -------------//
OSAL_SUBTASK_INVOKED_AND_WAIT( OSAL_SUBTASK_INVOKED_AND_WAIT(
usbh_control_xfer_subtask( usbh_control_xfer_subtask(
@ -422,15 +413,19 @@ OSAL_TASK_FUNCTION(usbh_enumeration_task)
}else }else
{ {
uint8_t class_code = ((tusb_descriptor_interface_t*) p_desc)->bInterfaceClass; uint8_t class_code = ((tusb_descriptor_interface_t*) p_desc)->bInterfaceClass;
if (class_code == 0)
// supported class TODO add custom class {
if ( 0 < class_code && class_code < TUSB_CLASS_MAX_CONSEC_NUMBER && usbh_class_drivers[class_code].open_subtask) SUBTASK_ASSERT( false ); // corrupted data, abort enumeration
}
// supported class TODO custom class
else if ( class_code < TUSB_CLASS_MAX_CONSEC_NUMBER && usbh_class_drivers[class_code].open_subtask)
{ {
uint16_t length=0; uint16_t length=0;
OSAL_SUBTASK_INVOKED_AND_WAIT ( // parameters in task/sub_task must be static storage (static or global) OSAL_SUBTASK_INVOKED_AND_WAIT ( // parameters in task/sub_task must be static storage (static or global)
usbh_class_drivers[ ((tusb_descriptor_interface_t*) p_desc)->bInterfaceClass ].open_subtask( usbh_class_drivers[ ((tusb_descriptor_interface_t*) p_desc)->bInterfaceClass ].open_subtask(
new_addr, (tusb_descriptor_interface_t*) p_desc, &length) ); new_addr, (tusb_descriptor_interface_t*) p_desc, &length) );
// TODO check class_open_subtask status
if (length == 0) // Interface open failed, for example a subclass is not supported if (length == 0) // Interface open failed, for example a subclass is not supported
{ {
p_desc += p_desc[DESCRIPTOR_OFFSET_LENGTH]; // skip this interface, the rest will be skipped by the above loop p_desc += p_desc[DESCRIPTOR_OFFSET_LENGTH]; // skip this interface, the rest will be skipped by the above loop
@ -448,12 +443,6 @@ OSAL_TASK_FUNCTION(usbh_enumeration_task)
} }
tusbh_device_mount_succeed_cb(new_addr); tusbh_device_mount_succeed_cb(new_addr);
}
}
}
}
}
}
OSAL_TASK_LOOP_END OSAL_TASK_LOOP_END
} }

14
tinyusb/osal/osal_none.h
View File

@ -129,28 +129,22 @@ static inline volatile uint32_t osal_tick_get(void)
#define _TASK_ASSERT_ERROR_HANDLER(error, func_call) \ #define _TASK_ASSERT_ERROR_HANDLER(error, func_call) \
func_call; TASK_RESTART; return error func_call; TASK_RESTART; return error
#define TASK_ASSERT_STATUS(sts) \ #define SUBTASK_ASSERT_STATUS(sts) \
ASSERT_DEFINE_WITH_HANDLER(_TASK_ASSERT_ERROR_HANDLER, , tusb_error_t status = (tusb_error_t)(sts),\ ASSERT_DEFINE_WITH_HANDLER(_TASK_ASSERT_ERROR_HANDLER, , tusb_error_t status = (tusb_error_t)(sts),\
TUSB_ERROR_NONE == status, status, "%s", TUSB_ErrorStr[status]) TUSB_ERROR_NONE == status, status, "%s", TUSB_ErrorStr[status])
#define TASK_ASSERT_STATUS_WITH_HANDLER(sts, func_call) \ #define SUBTASK_ASSERT_STATUS_WITH_HANDLER(sts, func_call) \
ASSERT_DEFINE_WITH_HANDLER(_TASK_ASSERT_ERROR_HANDLER, func_call, tusb_error_t status = (tusb_error_t)(sts),\ ASSERT_DEFINE_WITH_HANDLER(_TASK_ASSERT_ERROR_HANDLER, func_call, tusb_error_t status = (tusb_error_t)(sts),\
TUSB_ERROR_NONE == status, status, "%s", TUSB_ErrorStr[status]) TUSB_ERROR_NONE == status, status, "%s", TUSB_ErrorStr[status])
#define TASK_ASSERT(condition) \ #define SUBTASK_ASSERT(condition) \
ASSERT_DEFINE_WITH_HANDLER(_TASK_ASSERT_ERROR_HANDLER, , , \ ASSERT_DEFINE_WITH_HANDLER(_TASK_ASSERT_ERROR_HANDLER, , , \
(condition), TUSB_ERROR_OSAL_TASK_FAILED, "%s", "evaluated to false") (condition), TUSB_ERROR_OSAL_TASK_FAILED, "%s", "evaluated to false")
#define TASK_ASSERT_WITH_HANDLER(condition, func_call) \ #define SUBTASK_ASSERT_WITH_HANDLER(condition, func_call) \
ASSERT_DEFINE_WITH_HANDLER(_TASK_ASSERT_ERROR_HANDLER, func_call, ,\ ASSERT_DEFINE_WITH_HANDLER(_TASK_ASSERT_ERROR_HANDLER, func_call, ,\
condition, TUSB_ERROR_OSAL_TASK_FAILED, "%s", "evaluated to false") condition, TUSB_ERROR_OSAL_TASK_FAILED, "%s", "evaluated to false")
//------------- Sub Task Assert -------------//
#define SUBTASK_ASSERT_STATUS TASK_ASSERT_STATUS
#define SUBTASK_ASSERT_STATUS_WITH_HANDLER TASK_ASSERT_STATUS_WITH_HANDLER
#define SUBTASK_ASSERT TASK_ASSERT
#define SUBTASK_ASSERT_WITH_HANDLER TASK_ASSERT_WITH_HANDLER
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+
// Semaphore API // Semaphore API
//--------------------------------------------------------------------+ //--------------------------------------------------------------------+