2014-03-12 08:01:38 +01:00
/**************************************************************************/
/*!
@ file usbd . c
@ author hathach ( tinyusb . org )
@ section LICENSE
Software License Agreement ( BSD License )
Copyright ( c ) 2013 , hathach ( tinyusb . org )
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. Neither the name of the copyright holders nor the
names of its contributors may be used to endorse or promote products
derived from this software without specific prior written permission .
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ' ' 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 COPYRIGHT HOLDER 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 tinyusb stack .
*/
/**************************************************************************/
# include "tusb_option.h"
# if MODE_DEVICE_SUPPORTED
# define _TINY_USB_SOURCE_FILE_
//--------------------------------------------------------------------+
// INCLUDE
//--------------------------------------------------------------------+
# include "tusb.h"
2018-03-11 06:31:24 +01:00
# include "usbd.h"
2014-03-12 08:01:38 +01:00
//--------------------------------------------------------------------+
// MACRO CONSTANT TYPEDEF
//--------------------------------------------------------------------+
usbd_device_info_t usbd_devices [ CONTROLLER_DEVICE_NUMBER ] ;
2014-03-23 04:15:32 +01:00
TUSB_CFG_ATTR_USBRAM uint8_t usbd_enum_buffer [ TUSB_CFG_DEVICE_ENUM_BUFFER_SIZE ] ;
2014-03-12 08:01:38 +01:00
2014-03-14 11:18:05 +01:00
static usbd_class_driver_t const usbd_class_drivers [ ] =
2014-03-12 08:01:38 +01:00
{
2014-03-14 11:18:05 +01:00
# if DEVICE_CLASS_HID
2014-03-12 08:01:38 +01:00
[ TUSB_CLASS_HID ] =
{
. init = hidd_init ,
. open = hidd_open ,
. control_request_subtask = hidd_control_request_subtask ,
. xfer_cb = hidd_xfer_cb ,
2018-03-08 08:38:06 +01:00
// .routine = NULL,
. sof = NULL ,
2014-03-12 08:01:38 +01:00
. close = hidd_close
} ,
2014-03-14 11:18:05 +01:00
# endif
2014-03-12 08:01:38 +01:00
2014-03-14 11:18:05 +01:00
# if TUSB_CFG_DEVICE_MSC
2014-03-12 08:01:38 +01:00
[ TUSB_CLASS_MSC ] =
{
. init = mscd_init ,
. open = mscd_open ,
. control_request_subtask = mscd_control_request_subtask ,
. xfer_cb = mscd_xfer_cb ,
2018-03-08 08:38:06 +01:00
// .routine = NULL,
. sof = NULL ,
2014-03-12 08:01:38 +01:00
. close = mscd_close
} ,
2014-03-14 11:18:05 +01:00
# endif
2014-03-12 08:01:38 +01:00
2014-03-14 11:18:05 +01:00
# if TUSB_CFG_DEVICE_CDC
2014-03-12 08:01:38 +01:00
[ TUSB_CLASS_CDC ] =
{
. init = cdcd_init ,
. open = cdcd_open ,
. control_request_subtask = cdcd_control_request_subtask ,
. xfer_cb = cdcd_xfer_cb ,
2018-03-08 08:38:06 +01:00
// .routine = NULL,
. sof = cdcd_sof ,
2014-03-12 08:01:38 +01:00
. close = cdcd_close
} ,
2014-03-14 11:18:05 +01:00
# endif
2014-03-12 08:01:38 +01:00
} ;
2014-03-18 10:58:24 +01:00
enum { USBD_CLASS_DRIVER_COUNT = sizeof ( usbd_class_drivers ) / sizeof ( usbd_class_driver_t ) } ;
2014-03-14 11:18:05 +01:00
2014-03-12 08:01:38 +01:00
//--------------------------------------------------------------------+
// INTERNAL OBJECT & FUNCTION DECLARATION
//--------------------------------------------------------------------+
2018-03-09 08:29:23 +01:00
static tusb_error_t usbd_set_configure_received ( uint8_t port , uint8_t config_number ) ;
static tusb_error_t get_descriptor ( uint8_t port , tusb_control_request_t const * const p_request , uint8_t const * * pp_buffer , uint16_t * p_length ) ;
2014-03-12 08:01:38 +01:00
//--------------------------------------------------------------------+
// APPLICATION INTERFACE
//--------------------------------------------------------------------+
2018-03-11 13:37:21 +01:00
bool tud_n_mounted ( uint8_t port )
2014-03-12 08:01:38 +01:00
{
2018-03-11 13:37:21 +01:00
return usbd_devices [ port ] . state = = TUSB_DEVICE_STATE_CONFIGURED ;
2014-03-12 08:01:38 +01:00
}
//--------------------------------------------------------------------+
// IMPLEMENTATION
//--------------------------------------------------------------------+
//------------- OSAL Task -------------//
2014-04-24 18:40:28 +02:00
enum { USBD_TASK_QUEUE_DEPTH = 16 } ;
2014-03-12 08:01:38 +01:00
2015-05-01 13:45:22 +02:00
typedef enum
{
2014-03-12 08:01:38 +01:00
USBD_EVENTID_SETUP_RECEIVED = 1 ,
2018-03-08 08:38:06 +01:00
USBD_EVENTID_XFER_DONE ,
USBD_EVENTID_SOF
2014-03-12 08:01:38 +01:00
} usbd_eventid_t ;
typedef struct ATTR_ALIGNED ( 4 )
{
2018-03-09 08:29:23 +01:00
uint8_t port ;
2014-03-12 08:01:38 +01:00
uint8_t event_id ;
uint8_t sub_event_id ;
uint8_t reserved ;
union {
2018-03-08 08:38:06 +01:00
tusb_control_request_t setup_received ;
2014-03-12 08:01:38 +01:00
struct { // USBD_EVENTID_XFER_DONE
2018-03-11 09:20:27 +01:00
uint8_t edpt_addr ;
2014-03-12 08:01:38 +01:00
uint32_t xferred_byte ;
} xfer_done ;
} ;
2014-03-14 11:18:05 +01:00
} usbd_task_event_t ;
2014-03-12 08:01:38 +01:00
STATIC_ASSERT ( sizeof ( usbd_task_event_t ) < = 12 , " size is not correct " ) ;
2018-02-28 08:21:31 +01:00
# ifndef TUC_DEVICE_STACKSIZE
# define TUC_DEVICE_STACKSIZE 150
# endif
# ifndef TUSB_CFG_OS_TASK_PRIO
# define TUSB_CFG_OS_TASK_PRIO 0
# endif
2014-03-12 08:01:38 +01:00
2018-02-28 10:45:54 +01:00
static osal_queue_t usbd_queue_hdl ;
2018-03-01 05:17:11 +01:00
/*static*/ osal_semaphore_t usbd_control_xfer_sem_hdl ; // TODO may need to change to static with wrapper function
2014-03-12 08:01:38 +01:00
2014-03-31 08:12:51 +02:00
//--------------------------------------------------------------------+
// IMPLEMENTATION
//--------------------------------------------------------------------+
2018-03-09 08:29:23 +01:00
tusb_error_t usbd_control_request_subtask ( uint8_t port , tusb_control_request_t const * const p_request ) ;
2014-03-31 08:12:51 +02:00
static tusb_error_t usbd_body_subtask ( void ) ;
tusb_error_t usbd_init ( void )
{
2018-03-02 16:46:36 +01:00
# if (TUSB_CFG_CONTROLLER_0_MODE & TUSB_MODE_DEVICE)
2018-03-11 07:13:04 +01:00
tusb_dcd_init ( 0 ) ;
2018-03-02 16:46:36 +01:00
# endif
# if (TUSB_CFG_CONTROLLER_1_MODE & TUSB_MODE_DEVICE)
2018-03-11 07:13:04 +01:00
tusb_dcd_init ( 1 ) ;
2018-03-02 16:46:36 +01:00
# endif
2014-03-31 08:12:51 +02:00
//------------- Task init -------------//
2018-02-28 10:45:54 +01:00
usbd_queue_hdl = osal_queue_create ( USBD_TASK_QUEUE_DEPTH , sizeof ( usbd_task_event_t ) ) ;
2018-03-06 11:22:40 +01:00
VERIFY ( usbd_queue_hdl , TUSB_ERROR_OSAL_QUEUE_FAILED ) ;
2014-03-31 08:12:51 +02:00
2018-03-01 05:17:11 +01:00
usbd_control_xfer_sem_hdl = osal_semaphore_create ( 1 , 0 ) ;
2018-03-06 11:22:40 +01:00
VERIFY ( usbd_queue_hdl , TUSB_ERROR_OSAL_SEMAPHORE_FAILED ) ;
2014-03-31 08:12:51 +02:00
2018-03-01 05:28:26 +01:00
osal_task_create ( usbd_task , " usbd " , TUC_DEVICE_STACKSIZE , NULL , TUSB_CFG_OS_TASK_PRIO ) ;
2018-02-28 08:21:31 +01:00
2014-03-31 08:12:51 +02:00
//------------- Descriptor Check -------------//
ASSERT ( tusbd_descriptor_pointers . p_device ! = NULL & & tusbd_descriptor_pointers . p_configuration ! = NULL , TUSB_ERROR_DESCRIPTOR_CORRUPTED ) ;
//------------- class init -------------//
for ( uint8_t class_code = TUSB_CLASS_AUDIO ; class_code < USBD_CLASS_DRIVER_COUNT ; class_code + + )
{
if ( usbd_class_drivers [ class_code ] . init )
{
usbd_class_drivers [ class_code ] . init ( ) ;
}
}
return TUSB_ERROR_NONE ;
}
// To enable the TASK_ASSERT style (quick return on false condition) in a real RTOS, a task must act as a wrapper
// and is used mainly to call subtasks. Within a subtask return statement can be called freely, the task with
// forever loop cannot have any return at all.
2018-02-28 08:21:31 +01:00
void usbd_task ( void * param )
2014-03-31 08:12:51 +02:00
{
2018-02-28 08:21:31 +01:00
( void ) param ;
2014-03-31 08:12:51 +02:00
2018-03-01 06:14:44 +01:00
OSAL_TASK_BEGIN
2014-03-31 08:12:51 +02:00
usbd_body_subtask ( ) ;
2018-03-01 06:14:44 +01:00
OSAL_TASK_END
2014-03-31 08:12:51 +02:00
}
static tusb_error_t usbd_body_subtask ( void )
{
2014-04-09 17:29:38 +02:00
static usbd_task_event_t event ;
2014-03-31 08:12:51 +02:00
OSAL_SUBTASK_BEGIN
tusb_error_t error ;
error = TUSB_ERROR_NONE ;
2014-04-24 18:40:28 +02:00
memclr_ ( & event , sizeof ( usbd_task_event_t ) ) ;
2018-03-08 08:38:06 +01:00
# if 1
2014-03-31 08:12:51 +02:00
osal_queue_receive ( usbd_queue_hdl , & event , OSAL_TIMEOUT_WAIT_FOREVER , & error ) ;
SUBTASK_ASSERT_STATUS ( error ) ;
2018-03-08 08:38:06 +01:00
# else
enum { ROUTINE_INTERVAL_MS = 10 } ;
osal_queue_receive ( usbd_queue_hdl , & event , ROUTINE_INTERVAL_MS , & error ) ;
if ( error ! = TUSB_ERROR_NONE )
{
// time out, run class routine then
if ( error = = TUSB_ERROR_OSAL_TIMEOUT )
{
for ( uint8_t class_code = TUSB_CLASS_AUDIO ; class_code < USBD_CLASS_DRIVER_COUNT ; class_code + + )
{
if ( usbd_class_drivers [ class_code ] . routine ) usbd_class_drivers [ class_code ] . routine ( ) ;
}
}
SUBTASK_RETURN ( error ) ;
}
# endif
2014-03-31 08:12:51 +02:00
if ( USBD_EVENTID_SETUP_RECEIVED = = event . event_id )
{
2018-03-09 08:29:23 +01:00
OSAL_SUBTASK_INVOKED_AND_WAIT ( usbd_control_request_subtask ( event . port , & event . setup_received ) , error ) ;
2014-04-24 18:40:28 +02:00
} else if ( USBD_EVENTID_XFER_DONE = = event . event_id )
2014-03-31 08:12:51 +02:00
{
2018-03-06 10:50:50 +01:00
// Call class handling function, Class that endpoint not belong to should check and return
for ( uint8_t class_code = TUSB_CLASS_AUDIO ; class_code < USBD_CLASS_DRIVER_COUNT ; class_code + + )
{
2018-03-07 09:30:32 +01:00
if ( usbd_class_drivers [ class_code ] . xfer_cb )
{
2018-03-11 09:20:27 +01:00
usbd_class_drivers [ class_code ] . xfer_cb ( event . port , event . xfer_done . edpt_addr , ( tusb_event_t ) event . sub_event_id , event . xfer_done . xferred_byte ) ;
2018-03-07 09:30:32 +01:00
}
2018-03-06 10:50:50 +01:00
}
2018-03-08 08:38:06 +01:00
} else if ( USBD_EVENTID_SOF = = event . event_id )
{
for ( uint8_t class_code = TUSB_CLASS_AUDIO ; class_code < USBD_CLASS_DRIVER_COUNT ; class_code + + )
{
if ( usbd_class_drivers [ class_code ] . sof )
{
2018-03-09 08:29:23 +01:00
usbd_class_drivers [ class_code ] . sof ( event . port ) ;
2018-03-08 08:38:06 +01:00
}
}
}
else
2014-04-24 18:40:28 +02:00
{
SUBTASK_ASSERT ( false ) ;
2014-03-31 08:12:51 +02:00
}
OSAL_SUBTASK_END
}
//--------------------------------------------------------------------+
// CONTROL REQUEST
//--------------------------------------------------------------------+
2018-03-09 08:29:23 +01:00
tusb_error_t usbd_control_request_subtask ( uint8_t port , tusb_control_request_t const * const p_request )
2014-03-12 08:01:38 +01:00
{
OSAL_SUBTASK_BEGIN
2014-03-14 11:18:05 +01:00
tusb_error_t error ;
error = TUSB_ERROR_NONE ;
2014-03-12 08:01:38 +01:00
2018-03-07 05:01:23 +01:00
//------------- Standard Control e.g in enumeration -------------//
2018-03-11 15:05:27 +01:00
if ( TUSB_REQ_RCPT_DEVICE = = p_request - > bmRequestType_bit . recipient & &
TUSB_REQ_TYPE_STANDARD = = p_request - > bmRequestType_bit . type )
2014-03-12 08:01:38 +01:00
{
if ( TUSB_REQUEST_GET_DESCRIPTOR = = p_request - > bRequest )
{
2014-03-23 08:14:00 +01:00
uint8_t const * p_buffer = NULL ;
2014-03-12 08:01:38 +01:00
uint16_t length = 0 ;
2018-03-09 08:29:23 +01:00
error = get_descriptor ( port , p_request , & p_buffer , & length ) ;
2014-03-12 08:01:38 +01:00
if ( TUSB_ERROR_NONE = = error )
{
2018-03-11 14:16:39 +01:00
tusb_dcd_control_xfer ( port , ( tusb_dir_t ) p_request - > bmRequestType_bit . direction , ( uint8_t * ) p_buffer , length , false ) ;
2014-03-12 08:01:38 +01:00
}
}
else if ( TUSB_REQUEST_SET_ADDRESS = = p_request - > bRequest )
{
2018-03-11 07:13:04 +01:00
tusb_dcd_set_address ( port , ( uint8_t ) p_request - > wValue ) ;
2018-03-09 08:29:23 +01:00
usbd_devices [ port ] . state = TUSB_DEVICE_STATE_ADDRESSED ;
2014-03-12 08:01:38 +01:00
}
else if ( TUSB_REQUEST_SET_CONFIGURATION = = p_request - > bRequest )
{
2018-03-09 08:29:23 +01:00
usbd_set_configure_received ( port , ( uint8_t ) p_request - > wValue ) ;
2014-03-12 08:01:38 +01:00
} else
{
error = TUSB_ERROR_DCD_CONTROL_REQUEST_NOT_SUPPORT ;
}
}
//------------- Class/Interface Specific Request -------------//
2018-03-11 15:05:27 +01:00
else if ( TUSB_REQ_RCPT_INTERFACE = = p_request - > bmRequestType_bit . recipient )
2014-03-12 08:01:38 +01:00
{
2014-04-09 17:29:38 +02:00
static uint8_t class_code ;
2014-03-12 08:01:38 +01:00
2018-03-09 08:29:23 +01:00
class_code = usbd_devices [ port ] . interface2class [ u16_low_u8 ( p_request - > wIndex ) ] ;
2014-03-12 08:01:38 +01:00
2014-03-14 11:18:05 +01:00
// TODO [Custom] TUSB_CLASS_DIAGNOSTIC, vendor etc ...
if ( ( class_code > 0 ) & & ( class_code < USBD_CLASS_DRIVER_COUNT ) & &
2014-03-12 08:01:38 +01:00
usbd_class_drivers [ class_code ] . control_request_subtask )
{
2018-03-09 08:29:23 +01:00
OSAL_SUBTASK_INVOKED_AND_WAIT ( usbd_class_drivers [ class_code ] . control_request_subtask ( port , p_request ) , error ) ;
2014-03-12 08:01:38 +01:00
} else
{
error = TUSB_ERROR_DCD_CONTROL_REQUEST_NOT_SUPPORT ;
}
}
//------------- Endpoint Request -------------//
2018-03-11 15:05:27 +01:00
else if ( TUSB_REQ_RCPT_ENDPOINT = = p_request - > bmRequestType_bit . recipient & &
TUSB_REQ_TYPE_STANDARD = = p_request - > bmRequestType_bit . type & &
2014-03-12 08:01:38 +01:00
TUSB_REQUEST_CLEAR_FEATURE = = p_request - > bRequest )
{
2018-03-11 08:22:04 +01:00
tusb_dcd_edpt_clear_stall ( port , u16_low_u8 ( p_request - > wIndex ) ) ;
2014-03-12 08:01:38 +01:00
} else
{
error = TUSB_ERROR_DCD_CONTROL_REQUEST_NOT_SUPPORT ;
}
if ( TUSB_ERROR_NONE ! = error )
{ // Response with Protocol Stall if request is not supported
2018-03-11 07:13:04 +01:00
tusb_dcd_control_stall ( port ) ;
2014-03-12 08:01:38 +01:00
// ASSERT(error == TUSB_ERROR_NONE, VOID_RETURN);
} else if ( p_request - > wLength = = 0 )
{
2018-03-11 14:16:39 +01:00
tusb_dcd_control_xfer ( port , ( tusb_dir_t ) p_request - > bmRequestType_bit . direction , NULL , 0 , false ) ; // zero length for non-data
2014-03-12 08:01:38 +01:00
}
OSAL_SUBTASK_END
}
// TODO Host (windows) can get HID report descriptor before set configured
2014-03-23 09:39:55 +01:00
// may need to open interface before set configured
2018-03-09 08:29:23 +01:00
static tusb_error_t usbd_set_configure_received ( uint8_t port , uint8_t config_number )
2014-03-12 08:01:38 +01:00
{
2018-03-11 07:13:04 +01:00
tusb_dcd_set_config ( port , config_number ) ;
2018-03-09 08:29:23 +01:00
usbd_devices [ port ] . state = TUSB_DEVICE_STATE_CONFIGURED ;
2014-03-12 08:01:38 +01:00
//------------- parse configuration & open drivers -------------//
2014-03-23 09:39:55 +01:00
uint8_t const * p_desc_config = tusbd_descriptor_pointers . p_configuration ;
uint8_t const * p_desc = p_desc_config + sizeof ( tusb_descriptor_configuration_t ) ;
2014-03-12 08:01:38 +01:00
2014-03-23 09:39:55 +01:00
uint16_t const config_total_length = ( ( tusb_descriptor_configuration_t * ) p_desc_config ) - > wTotalLength ;
while ( p_desc < p_desc_config + config_total_length )
2014-03-12 08:01:38 +01:00
{
2018-03-11 15:16:51 +01:00
if ( TUSB_DESC_INTERFACE_ASSOCIATION = = p_desc [ DESCRIPTOR_OFFSET_TYPE ] )
2014-03-12 08:01:38 +01:00
{
2014-03-18 12:38:15 +01:00
p_desc + = p_desc [ DESCRIPTOR_OFFSET_LENGTH ] ; // ignore Interface Association
2014-03-12 08:01:38 +01:00
} else
{
2018-03-11 15:16:51 +01:00
ASSERT ( TUSB_DESC_INTERFACE = = p_desc [ DESCRIPTOR_OFFSET_TYPE ] , TUSB_ERROR_NOT_SUPPORTED_YET ) ;
2014-03-12 08:01:38 +01:00
uint8_t class_index ;
tusb_descriptor_interface_t * p_desc_interface = ( tusb_descriptor_interface_t * ) p_desc ;
class_index = p_desc_interface - > bInterfaceClass ;
2014-03-14 11:32:01 +01:00
ASSERT ( class_index ! = 0 & & class_index < USBD_CLASS_DRIVER_COUNT & & usbd_class_drivers [ class_index ] . open ! = NULL , TUSB_ERROR_NOT_SUPPORTED_YET ) ;
2018-03-09 08:29:23 +01:00
ASSERT ( 0 = = usbd_devices [ port ] . interface2class [ p_desc_interface - > bInterfaceNumber ] , TUSB_ERROR_FAILED ) ; // duplicate interface number TODO alternate setting
2014-03-12 08:01:38 +01:00
2018-03-09 08:29:23 +01:00
usbd_devices [ port ] . interface2class [ p_desc_interface - > bInterfaceNumber ] = class_index ;
2014-03-12 08:01:38 +01:00
uint16_t length = 0 ;
2018-03-09 08:29:23 +01:00
ASSERT_STATUS ( usbd_class_drivers [ class_index ] . open ( port , p_desc_interface , & length ) ) ;
2014-03-12 08:01:38 +01:00
ASSERT ( length > = sizeof ( tusb_descriptor_interface_t ) , TUSB_ERROR_FAILED ) ;
p_desc + = length ;
}
}
2018-03-07 10:39:33 +01:00
// invoke callback
2018-03-09 08:29:23 +01:00
tud_mount_cb ( port ) ;
2018-03-07 10:39:33 +01:00
2014-03-12 08:01:38 +01:00
return TUSB_ERROR_NONE ;
}
2018-03-09 08:29:23 +01:00
static tusb_error_t get_descriptor ( uint8_t port , tusb_control_request_t const * const p_request , uint8_t const * * pp_buffer , uint16_t * p_length )
2014-03-12 08:01:38 +01:00
{
2018-03-12 16:37:12 +01:00
tusb_desc_type_t const desc_type = ( tusb_desc_type_t ) u16_high_u8 ( p_request - > wValue ) ;
2014-03-12 08:01:38 +01:00
uint8_t const desc_index = u16_low_u8 ( p_request - > wValue ) ;
2014-03-23 09:39:55 +01:00
uint8_t const * p_data = NULL ;
2014-03-12 08:01:38 +01:00
2014-03-23 09:39:55 +01:00
switch ( desc_type )
2014-03-12 08:01:38 +01:00
{
2018-03-11 15:16:51 +01:00
case TUSB_DESC_DEVICE :
2014-03-23 09:39:55 +01:00
p_data = tusbd_descriptor_pointers . p_device ;
( * p_length ) = sizeof ( tusb_descriptor_device_t ) ;
break ;
2018-03-11 15:16:51 +01:00
case TUSB_DESC_CONFIGURATION :
2014-03-23 09:39:55 +01:00
p_data = tusbd_descriptor_pointers . p_configuration ;
( * p_length ) = ( ( tusb_descriptor_configuration_t * ) tusbd_descriptor_pointers . p_configuration ) - > wTotalLength ;
break ;
2018-03-11 15:16:51 +01:00
case TUSB_DESC_STRING :
2014-03-23 09:39:55 +01:00
if ( ! ( desc_index < 100 ) ) return TUSB_ERROR_DCD_CONTROL_REQUEST_NOT_SUPPORT ; // windows sometimes ask for string at index 238 !!!
p_data = tusbd_descriptor_pointers . p_string_arr [ desc_index ] ;
ASSERT ( p_data ! = NULL , TUSB_ERROR_FAILED ) ;
( * p_length ) = p_data [ 0 ] ; // first byte of descriptor is its size
break ;
2017-08-03 16:45:16 +02:00
// TODO Report Descriptor (HID Generic)
// TODO HID Descriptor
2014-03-23 09:39:55 +01:00
default : return TUSB_ERROR_DCD_CONTROL_REQUEST_NOT_SUPPORT ;
2014-03-12 08:01:38 +01:00
}
( * p_length ) = min16_of ( p_request - > wLength , ( * p_length ) ) ; // cannot return more than hosts requires
2014-03-23 09:39:55 +01:00
ASSERT ( ( * p_length ) < = TUSB_CFG_DEVICE_ENUM_BUFFER_SIZE , TUSB_ERROR_NOT_ENOUGH_MEMORY ) ;
memcpy ( usbd_enum_buffer , p_data , ( * p_length ) ) ;
( * pp_buffer ) = usbd_enum_buffer ;
2014-03-12 08:01:38 +01:00
return TUSB_ERROR_NONE ;
}
//--------------------------------------------------------------------+
// USBD-CLASS API
//--------------------------------------------------------------------+
//--------------------------------------------------------------------+
// USBD-DCD Callback API
//--------------------------------------------------------------------+
2018-03-11 07:13:04 +01:00
void tusb_dcd_bus_event ( uint8_t port , usbd_bus_event_type_t bus_event )
2014-03-12 08:01:38 +01:00
{
switch ( bus_event )
{
case USBD_BUS_EVENT_RESET :
2018-03-09 08:29:23 +01:00
memclr_ ( & usbd_devices [ port ] , sizeof ( usbd_device_info_t ) ) ;
2014-04-24 18:40:28 +02:00
osal_queue_flush ( usbd_queue_hdl ) ;
2014-04-04 07:22:33 +02:00
osal_semaphore_reset ( usbd_control_xfer_sem_hdl ) ;
2014-03-14 11:32:01 +01:00
for ( uint8_t class_code = TUSB_CLASS_AUDIO ; class_code < USBD_CLASS_DRIVER_COUNT ; class_code + + )
2014-03-12 08:01:38 +01:00
{
2018-03-09 08:29:23 +01:00
if ( usbd_class_drivers [ class_code ] . close ) usbd_class_drivers [ class_code ] . close ( port ) ;
2014-03-12 08:01:38 +01:00
}
2018-03-07 10:39:33 +01:00
// invoke callback
2018-03-09 08:29:23 +01:00
tud_umount_cb ( port ) ;
2014-03-12 08:01:38 +01:00
break ;
2018-03-08 08:38:06 +01:00
case USBD_BUS_EVENT_SOF :
{
usbd_task_event_t task_event =
{
2018-03-09 08:29:23 +01:00
. port = port ,
2018-03-08 08:38:06 +01:00
. event_id = USBD_EVENTID_SOF ,
} ;
osal_queue_send ( usbd_queue_hdl , & task_event ) ;
}
break ;
2018-03-03 10:24:43 +01:00
case USBD_BUS_EVENT_UNPLUGGED : break ;
2014-03-12 08:01:38 +01:00
case USBD_BUS_EVENT_SUSPENDED :
2018-03-09 08:29:23 +01:00
usbd_devices [ port ] . state = TUSB_DEVICE_STATE_SUSPENDED ;
2014-03-12 08:01:38 +01:00
break ;
default : break ;
}
}
2018-03-11 07:13:04 +01:00
void tusb_dcd_setup_received ( uint8_t port , uint8_t const * p_request )
2014-03-12 08:01:38 +01:00
{
usbd_task_event_t task_event =
{
2018-03-09 08:29:23 +01:00
. port = port ,
2014-03-12 08:01:38 +01:00
. event_id = USBD_EVENTID_SETUP_RECEIVED ,
} ;
2018-03-03 08:45:29 +01:00
memcpy ( & task_event . setup_received , p_request , sizeof ( tusb_control_request_t ) ) ;
2018-03-01 06:20:35 +01:00
osal_queue_send ( usbd_queue_hdl , & task_event ) ;
2014-03-12 08:01:38 +01:00
}
2018-03-11 09:20:27 +01:00
void tusb_dcd_xfer_complete ( uint8_t port , uint8_t edpt_addr , uint32_t xferred_bytes , bool succeeded )
2014-03-12 08:01:38 +01:00
{
2018-03-11 09:20:27 +01:00
if ( edpt_addr = = 0 )
2014-03-12 08:01:38 +01:00
{
2018-03-06 10:50:50 +01:00
// Control Transfer
2018-03-01 05:42:13 +01:00
osal_semaphore_post ( usbd_control_xfer_sem_hdl ) ;
2014-03-12 08:01:38 +01:00
} else
{
usbd_task_event_t task_event =
{
2018-03-11 09:20:27 +01:00
. port = port ,
2014-03-12 08:01:38 +01:00
. event_id = USBD_EVENTID_XFER_DONE ,
2018-03-11 07:59:37 +01:00
. sub_event_id = succeeded ? TUSB_EVENT_XFER_COMPLETE : TUSB_EVENT_XFER_ERROR
2014-03-12 08:01:38 +01:00
} ;
2018-03-11 09:20:27 +01:00
task_event . xfer_done . edpt_addr = edpt_addr ;
2014-03-12 08:01:38 +01:00
task_event . xfer_done . xferred_byte = xferred_bytes ;
2018-03-01 06:20:35 +01:00
osal_queue_send ( usbd_queue_hdl , & task_event ) ;
2014-03-12 08:01:38 +01:00
}
}
//--------------------------------------------------------------------+
// HELPER
//--------------------------------------------------------------------+
# endif