weak atrribute work around removed from CCRX_Port
This commit is contained in:
Wini-Buh
parent
5a554508ca
commit
1c23462b43
|
|
@ -215,8 +215,9 @@ typedef enum
|
|||
// Class Specific Functional Descriptor (Communication Interface)
|
||||
//--------------------------------------------------------------------+
|
||||
|
||||
TU_PACK_STRUCT_BEGIN // Start of definition of packed structs (used by the CCRX toolchain)
|
||||
|
||||
/// Header Functional Descriptor (Communication Interface)
|
||||
TU_PACK_STRUCT_BEGIN
|
||||
typedef struct TU_ATTR_PACKED
|
||||
{
|
||||
uint8_t bLength ; ///< Size of this descriptor in bytes.
|
||||
|
|
@ -224,10 +225,8 @@ typedef struct TU_ATTR_PACKED
|
|||
uint8_t bDescriptorSubType ; ///< Descriptor SubType one of above CDC_FUNC_DESC_
|
||||
uint16_t bcdCDC ; ///< CDC release number in Binary-Coded Decimal
|
||||
}cdc_desc_func_header_t;
|
||||
TU_PACK_STRUCT_END
|
||||
|
||||
/// Union Functional Descriptor (Communication Interface)
|
||||
TU_PACK_STRUCT_BEGIN
|
||||
typedef struct TU_ATTR_PACKED
|
||||
{
|
||||
uint8_t bLength ; ///< Size of this descriptor in bytes.
|
||||
|
|
@ -236,7 +235,8 @@ typedef struct TU_ATTR_PACKED
|
|||
uint8_t bControlInterface ; ///< Interface number of Communication Interface
|
||||
uint8_t bSubordinateInterface ; ///< Array of Interface number of Data Interface
|
||||
}cdc_desc_func_union_t;
|
||||
TU_PACK_STRUCT_END
|
||||
|
||||
TU_PACK_STRUCT_END // End of definition of packed structs (used by the CCRX toolchain)
|
||||
|
||||
#define cdc_desc_func_union_n_t(no_slave)\
|
||||
TU_PACK_STRUCT_BEGIN \
|
||||
|
|
@ -249,8 +249,10 @@ TU_PACK_STRUCT_END
|
|||
} \
|
||||
TU_PACK_STRUCT_END
|
||||
|
||||
|
||||
TU_PACK_STRUCT_BEGIN // Start of definition of packed structs (used by the CCRX toolchain)
|
||||
|
||||
/// Country Selection Functional Descriptor (Communication Interface)
|
||||
TU_PACK_STRUCT_BEGIN
|
||||
typedef struct TU_ATTR_PACKED
|
||||
{
|
||||
uint8_t bLength ; ///< Size of this descriptor in bytes.
|
||||
|
|
@ -259,7 +261,8 @@ typedef struct TU_ATTR_PACKED
|
|||
uint8_t iCountryCodeRelDate ; ///< Index of a string giving the release date for the implemented ISO 3166 Country Codes.
|
||||
uint16_t wCountryCode ; ///< Country code in the format as defined in [ISO3166], release date as specified inoffset 3 for the first supported country.
|
||||
}cdc_desc_func_country_selection_t;
|
||||
TU_PACK_STRUCT_END
|
||||
|
||||
TU_PACK_STRUCT_END // End of definition of packed structs (used by the CCRX toolchain)
|
||||
|
||||
#define cdc_desc_func_country_selection_n_t(no_country) \
|
||||
TU_PACK_STRUCT_BEGIN \
|
||||
|
|
@ -276,29 +279,28 @@ TU_PACK_STRUCT_END
|
|||
// PUBLIC SWITCHED TELEPHONE NETWORK (PSTN) SUBCLASS
|
||||
//--------------------------------------------------------------------+
|
||||
|
||||
TU_PACK_STRUCT_BEGIN // Start of definition of packed structs (used by the CCRX toolchain)
|
||||
|
||||
/// \brief Call Management Functional Descriptor
|
||||
/// \details This functional descriptor describes the processing of calls for the Communications Class interface.
|
||||
TU_PACK_STRUCT_BEGIN
|
||||
TU_BIT_FIELD_ORDER_BEGIN
|
||||
typedef struct TU_ATTR_PACKED
|
||||
{
|
||||
uint8_t bLength ; ///< Size of this descriptor in bytes.
|
||||
uint8_t bDescriptorType ; ///< Descriptor Type, must be Class-Specific
|
||||
uint8_t bDescriptorSubType ; ///< Descriptor SubType one of above CDC_FUCN_DESC_
|
||||
|
||||
TU_BIT_FIELD_ORDER_BEGIN
|
||||
struct {
|
||||
uint8_t handle_call : 1; ///< 0 - Device sends/receives call management information only over the Communications Class interface. 1 - Device can send/receive call management information over a Data Class interface.
|
||||
uint8_t send_recv_call : 1; ///< 0 - Device does not handle call management itself. 1 - Device handles call management itself.
|
||||
uint8_t TU_RESERVED : 6;
|
||||
} bmCapabilities;
|
||||
TU_BIT_FIELD_ORDER_END
|
||||
|
||||
uint8_t bDataInterface;
|
||||
}cdc_desc_func_call_management_t;
|
||||
TU_PACK_STRUCT_END
|
||||
TU_BIT_FIELD_ORDER_END
|
||||
|
||||
|
||||
TU_PACK_STRUCT_BEGIN
|
||||
TU_BIT_FIELD_ORDER_BEGIN
|
||||
typedef struct TU_ATTR_PACKED
|
||||
{
|
||||
|
|
@ -309,13 +311,11 @@ typedef struct TU_ATTR_PACKED
|
|||
uint8_t TU_RESERVED : 4;
|
||||
}cdc_acm_capability_t;
|
||||
TU_BIT_FIELD_ORDER_END
|
||||
TU_PACK_STRUCT_END
|
||||
|
||||
TU_VERIFY_STATIC(sizeof(cdc_acm_capability_t) == 1, "mostly problem with compiler");
|
||||
|
||||
/// \brief Abstract Control Management Functional Descriptor
|
||||
/// \details This functional descriptor describes the commands supported by by the Communications Class interface with SubClass code of \ref CDC_COMM_SUBCLASS_ABSTRACT_CONTROL_MODEL
|
||||
TU_PACK_STRUCT_BEGIN
|
||||
typedef struct TU_ATTR_PACKED
|
||||
{
|
||||
uint8_t bLength ; ///< Size of this descriptor in bytes.
|
||||
|
|
@ -323,31 +323,27 @@ typedef struct TU_ATTR_PACKED
|
|||
uint8_t bDescriptorSubType ; ///< Descriptor SubType one of above CDC_FUCN_DESC_
|
||||
cdc_acm_capability_t bmCapabilities ;
|
||||
}cdc_desc_func_acm_t;
|
||||
TU_PACK_STRUCT_END
|
||||
|
||||
/// \brief Direct Line Management Functional Descriptor
|
||||
/// \details This functional descriptor describes the commands supported by the Communications Class interface with SubClass code of \ref CDC_FUNC_DESC_DIRECT_LINE_MANAGEMENT
|
||||
TU_PACK_STRUCT_BEGIN
|
||||
TU_BIT_FIELD_ORDER_BEGIN
|
||||
typedef struct TU_ATTR_PACKED
|
||||
{
|
||||
uint8_t bLength ; ///< Size of this descriptor in bytes.
|
||||
uint8_t bDescriptorType ; ///< Descriptor Type, must be Class-Specific
|
||||
uint8_t bDescriptorSubType ; ///< Descriptor SubType one of above CDC_FUCN_DESC_
|
||||
TU_BIT_FIELD_ORDER_BEGIN
|
||||
struct {
|
||||
uint8_t require_pulse_setup : 1; ///< Device requires extra Pulse_Setup request during pulse dialing sequence to disengage holding circuit.
|
||||
uint8_t support_aux_request : 1; ///< Device supports the request combination of Set_Aux_Line_State, Ring_Aux_Jack, and notification Aux_Jack_Hook_State.
|
||||
uint8_t support_pulse_request : 1; ///< Device supports the request combination of Pulse_Setup, Send_Pulse, and Set_Pulse_Time.
|
||||
uint8_t TU_RESERVED : 5;
|
||||
} bmCapabilities;
|
||||
TU_BIT_FIELD_ORDER_END
|
||||
}cdc_desc_func_direct_line_management_t;
|
||||
TU_PACK_STRUCT_END
|
||||
TU_BIT_FIELD_ORDER_END
|
||||
|
||||
/// \brief Telephone Ringer Functional Descriptor
|
||||
/// \details The Telephone Ringer functional descriptor describes the ringer capabilities supported by the Communications Class interface,
|
||||
/// with the SubClass code of \ref CDC_COMM_SUBCLASS_TELEPHONE_CONTROL_MODEL
|
||||
TU_PACK_STRUCT_BEGIN
|
||||
typedef struct TU_ATTR_PACKED
|
||||
{
|
||||
uint8_t bLength ; ///< Size of this descriptor in bytes.
|
||||
|
|
@ -356,38 +352,34 @@ typedef struct TU_ATTR_PACKED
|
|||
uint8_t bRingerVolSteps ;
|
||||
uint8_t bNumRingerPatterns ;
|
||||
}cdc_desc_func_telephone_ringer_t;
|
||||
TU_PACK_STRUCT_END
|
||||
|
||||
/// \brief Telephone Operational Modes Functional Descriptor
|
||||
/// \details The Telephone Operational Modes functional descriptor describes the operational modes supported by
|
||||
/// the Communications Class interface, with the SubClass code of \ref CDC_COMM_SUBCLASS_TELEPHONE_CONTROL_MODEL
|
||||
TU_PACK_STRUCT_BEGIN
|
||||
TU_BIT_FIELD_ORDER_BEGIN
|
||||
typedef struct TU_ATTR_PACKED
|
||||
{
|
||||
uint8_t bLength ; ///< Size of this descriptor in bytes.
|
||||
uint8_t bDescriptorType ; ///< Descriptor Type, must be Class-Specific
|
||||
uint8_t bDescriptorSubType ; ///< Descriptor SubType one of above CDC_FUCN_DESC_
|
||||
TU_BIT_FIELD_ORDER_BEGIN
|
||||
struct {
|
||||
uint8_t simple_mode : 1;
|
||||
uint8_t standalone_mode : 1;
|
||||
uint8_t computer_centric_mode : 1;
|
||||
uint8_t TU_RESERVED : 5;
|
||||
} bmCapabilities;
|
||||
TU_BIT_FIELD_ORDER_END
|
||||
}cdc_desc_func_telephone_operational_modes_t;
|
||||
TU_PACK_STRUCT_END
|
||||
TU_BIT_FIELD_ORDER_END
|
||||
|
||||
/// \brief Telephone Call and Line State Reporting Capabilities Descriptor
|
||||
/// \details The Telephone Call and Line State Reporting Capabilities functional descriptor describes the abilities of a
|
||||
/// telephone device to report optional call and line states.
|
||||
TU_PACK_STRUCT_BEGIN
|
||||
TU_BIT_FIELD_ORDER_BEGIN
|
||||
typedef struct TU_ATTR_PACKED
|
||||
{
|
||||
uint8_t bLength ; ///< Size of this descriptor in bytes.
|
||||
uint8_t bDescriptorType ; ///< Descriptor Type, must be Class-Specific
|
||||
uint8_t bDescriptorSubType ; ///< Descriptor SubType one of above CDC_FUCN_DESC_
|
||||
TU_BIT_FIELD_ORDER_BEGIN
|
||||
struct {
|
||||
uint32_t interrupted_dialtone : 1; ///< 0 : Reports only dialtone (does not differentiate between normal and interrupted dialtone). 1 : Reports interrupted dialtone in addition to normal dialtone
|
||||
uint32_t ringback_busy_fastbusy : 1; ///< 0 : Reports only dialing state. 1 : Reports ringback, busy, and fast busy states.
|
||||
|
|
@ -397,9 +389,8 @@ typedef struct TU_ATTR_PACKED
|
|||
uint32_t line_state_change : 1; ///< 0 : Does not support line state change notification. 1 : Does support line state change notification
|
||||
uint32_t TU_RESERVED : 26;
|
||||
} bmCapabilities;
|
||||
TU_BIT_FIELD_ORDER_END
|
||||
}cdc_desc_func_telephone_call_state_reporting_capabilities_t;
|
||||
TU_PACK_STRUCT_END
|
||||
TU_BIT_FIELD_ORDER_END
|
||||
|
||||
static inline uint8_t cdc_functional_desc_typeof(uint8_t const * p_desc)
|
||||
{
|
||||
|
|
@ -409,7 +400,6 @@ static inline uint8_t cdc_functional_desc_typeof(uint8_t const * p_desc)
|
|||
//--------------------------------------------------------------------+
|
||||
// Requests
|
||||
//--------------------------------------------------------------------+
|
||||
TU_PACK_STRUCT_BEGIN
|
||||
typedef struct TU_ATTR_PACKED
|
||||
{
|
||||
uint32_t bit_rate;
|
||||
|
|
@ -417,11 +407,9 @@ typedef struct TU_ATTR_PACKED
|
|||
uint8_t parity; ///< 0: None - 1: Odd - 2: Even - 3: Mark - 4: Space
|
||||
uint8_t data_bits; ///< can be 5, 6, 7, 8 or 16
|
||||
} cdc_line_coding_t;
|
||||
TU_PACK_STRUCT_END
|
||||
|
||||
TU_VERIFY_STATIC(sizeof(cdc_line_coding_t) == 7, "size is not correct");
|
||||
|
||||
TU_PACK_STRUCT_BEGIN
|
||||
TU_BIT_FIELD_ORDER_BEGIN
|
||||
typedef struct TU_ATTR_PACKED
|
||||
{
|
||||
|
|
@ -430,7 +418,9 @@ typedef struct TU_ATTR_PACKED
|
|||
uint16_t : 14;
|
||||
} cdc_line_control_state_t;
|
||||
TU_BIT_FIELD_ORDER_END
|
||||
TU_PACK_STRUCT_END
|
||||
|
||||
TU_PACK_STRUCT_END // End of definition of packed structs (used by the CCRX toolchain)
|
||||
|
||||
|
||||
TU_VERIFY_STATIC(sizeof(cdc_line_control_state_t) == 2, "size is not correct");
|
||||
|
||||
|
|
|
|||
|
|
@ -33,15 +33,6 @@
|
|||
|
||||
#include "cdc_device.h"
|
||||
|
||||
#if defined(TU_HAS_NO_ATTR_WEAK)
|
||||
static void (*const MAKE_WEAK_FUNC(tud_cdc_rx_cb))(uint8_t) = TUD_CDC_RX_CB;
|
||||
static void (*const MAKE_WEAK_FUNC(tud_cdc_rx_wanted_cb))(uint8_t, char) = TUD_CDC_RX_WANTED_CB;
|
||||
static void (*const MAKE_WEAK_FUNC(tud_cdc_tx_complete_cb))(uint8_t) = TUD_CDC_TX_COMPLETE_CB;
|
||||
static void (*const MAKE_WEAK_FUNC(tud_cdc_line_state_cb))(uint8_t, bool, bool) = TUD_CDC_LINE_STATE_CB;
|
||||
static void (*const MAKE_WEAK_FUNC(tud_cdc_line_coding_cb))(uint8_t, cdc_line_coding_t const*) = TUD_CDC_LINE_CODING_CB;
|
||||
static void (*const MAKE_WEAK_FUNC(tud_cdc_send_break_cb))(uint8_t, uint16_t) = TUD_CDC_SEND_BREAK_CB;
|
||||
#endif
|
||||
|
||||
//--------------------------------------------------------------------+
|
||||
// MACRO CONSTANT TYPEDEF
|
||||
//--------------------------------------------------------------------+
|
||||
|
|
@ -370,7 +361,7 @@ bool cdcd_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb_control_request_t
|
|||
}
|
||||
else if ( stage == CONTROL_STAGE_ACK)
|
||||
{
|
||||
if ( MAKE_WEAK_FUNC(tud_cdc_line_coding_cb) ) MAKE_WEAK_FUNC(tud_cdc_line_coding_cb)(itf, &p_cdc->line_coding);
|
||||
if ( tud_cdc_line_coding_cb ) tud_cdc_line_coding_cb(itf, &p_cdc->line_coding);
|
||||
}
|
||||
break;
|
||||
|
||||
|
|
@ -405,7 +396,7 @@ bool cdcd_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb_control_request_t
|
|||
TU_LOG2(" Set Control Line State: DTR = %d, RTS = %d\r\n", dtr, rts);
|
||||
|
||||
// Invoke callback
|
||||
if ( MAKE_WEAK_FUNC(tud_cdc_line_state_cb) ) MAKE_WEAK_FUNC(tud_cdc_line_state_cb)(itf, dtr, rts);
|
||||
if ( tud_cdc_line_state_cb ) tud_cdc_line_state_cb(itf, dtr, rts);
|
||||
}
|
||||
break;
|
||||
case CDC_REQUEST_SEND_BREAK:
|
||||
|
|
@ -416,7 +407,7 @@ bool cdcd_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb_control_request_t
|
|||
else if (stage == CONTROL_STAGE_ACK)
|
||||
{
|
||||
TU_LOG2(" Send Break\r\n");
|
||||
if ( MAKE_WEAK_FUNC(tud_cdc_send_break_cb) ) MAKE_WEAK_FUNC(tud_cdc_send_break_cb)(itf, request->wValue);
|
||||
if ( tud_cdc_send_break_cb ) tud_cdc_send_break_cb(itf, request->wValue);
|
||||
}
|
||||
break;
|
||||
|
||||
|
|
@ -447,19 +438,19 @@ bool cdcd_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t result, uint32_
|
|||
tu_fifo_write_n(&p_cdc->rx_ff, &p_cdc->epout_buf, xferred_bytes);
|
||||
|
||||
// Check for wanted char and invoke callback if needed
|
||||
if ( MAKE_WEAK_FUNC(tud_cdc_rx_wanted_cb) && (((signed char) p_cdc->wanted_char) != -1) )
|
||||
if ( tud_cdc_rx_wanted_cb && (((signed char) p_cdc->wanted_char) != -1) )
|
||||
{
|
||||
for ( uint32_t i = 0; i < xferred_bytes; i++ )
|
||||
{
|
||||
if ( (p_cdc->wanted_char == p_cdc->epout_buf[i]) && !tu_fifo_empty(&p_cdc->rx_ff) )
|
||||
{
|
||||
MAKE_WEAK_FUNC(tud_cdc_rx_wanted_cb)(itf, p_cdc->wanted_char);
|
||||
tud_cdc_rx_wanted_cb(itf, p_cdc->wanted_char);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// invoke receive callback (if there is still data)
|
||||
if (MAKE_WEAK_FUNC(tud_cdc_rx_cb) && !tu_fifo_empty(&p_cdc->rx_ff) ) MAKE_WEAK_FUNC(tud_cdc_rx_cb)(itf);
|
||||
if (tud_cdc_rx_cb && !tu_fifo_empty(&p_cdc->rx_ff) ) tud_cdc_rx_cb(itf);
|
||||
|
||||
// prepare for OUT transaction
|
||||
_prep_out_transaction(p_cdc);
|
||||
|
|
@ -471,7 +462,7 @@ bool cdcd_xfer_cb(uint8_t rhport, uint8_t ep_addr, xfer_result_t result, uint32_
|
|||
if ( ep_addr == p_cdc->ep_in )
|
||||
{
|
||||
// invoke transmit callback to possibly refill tx fifo
|
||||
if ( MAKE_WEAK_FUNC(tud_cdc_tx_complete_cb) ) MAKE_WEAK_FUNC(tud_cdc_tx_complete_cb)(itf);
|
||||
if ( tud_cdc_tx_complete_cb ) tud_cdc_tx_complete_cb(itf);
|
||||
|
||||
if ( 0 == tud_cdc_n_write_flush(itf) )
|
||||
{
|
||||
|
|
|
|||
|
|
@ -129,7 +129,6 @@ static inline bool tud_cdc_write_clear (void);
|
|||
// Application Callback API (weak is optional)
|
||||
//--------------------------------------------------------------------+
|
||||
|
||||
#if !defined(TU_HAS_NO_ATTR_WEAK)
|
||||
// Invoked when received new data
|
||||
TU_ATTR_WEAK void tud_cdc_rx_cb(uint8_t itf);
|
||||
|
||||
|
|
@ -148,62 +147,6 @@ TU_ATTR_WEAK void tud_cdc_line_coding_cb(uint8_t itf, cdc_line_coding_t const* p
|
|||
// Invoked when received send break
|
||||
TU_ATTR_WEAK void tud_cdc_send_break_cb(uint8_t itf, uint16_t duration_ms);
|
||||
|
||||
#else
|
||||
#if ADD_WEAK_FUNC_TUD_CDC_RX_CB
|
||||
#define TUD_CDC_RX_CB tud_cdc_rx_cb
|
||||
#endif
|
||||
#ifndef TUD_CDC_RX_CB
|
||||
#define TUD_CDC_RX_CB NULL
|
||||
#else
|
||||
extern void TUD_CDC_RX_CB(uint8_t itf);
|
||||
#endif
|
||||
|
||||
#if ADD_WEAK_FUNC_TUD_CDC_RX_WANTED_CB
|
||||
#define TUD_CDC_RX_WANTED_CB tud_cdc_rx_wanted_cb
|
||||
#endif
|
||||
#ifndef TUD_CDC_RX_WANTED_CB
|
||||
#define TUD_CDC_RX_WANTED_CB NULL
|
||||
#else
|
||||
extern void TUD_CDC_RX_WANTED_CB(uint8_t itf, char wanted_char);
|
||||
#endif
|
||||
|
||||
#if ADD_WEAK_FUNC_TUD_CDC_TX_COMPLETE_CB
|
||||
#define TUD_CDC_TX_COMPLETE_CB tud_cdc_tx_complete_cb
|
||||
#endif
|
||||
#ifndef TUD_CDC_TX_COMPLETE_CB
|
||||
#define TUD_CDC_TX_COMPLETE_CB NULL
|
||||
#else
|
||||
extern void TUD_CDC_TX_COMPLETE_CB(uint8_t itf);
|
||||
#endif
|
||||
|
||||
#if ADD_WEAK_FUNC_TUD_CDC_LINE_STATE_CB
|
||||
#define TUD_CDC_LINE_STATE_CB tud_cdc_line_state_cb
|
||||
#endif
|
||||
#ifndef TUD_CDC_LINE_STATE_CB
|
||||
#define TUD_CDC_LINE_STATE_CB NULL
|
||||
#else
|
||||
extern void TUD_CDC_LINE_STATE_CB(uint8_t itf, bool dtr, bool rts);
|
||||
#endif
|
||||
|
||||
#if ADD_WEAK_FUNC_TUD_CDC_LINE_CODING_CB
|
||||
#define TUD_CDC_LINE_CODING_CB tud_cdc_line_coding_cb
|
||||
#endif
|
||||
#ifndef TUD_CDC_LINE_CODING_CB
|
||||
#define TUD_CDC_LINE_CODING_CB NULL
|
||||
#else
|
||||
extern void TUD_CDC_LINE_CODING_CB(uint8_t itf, cdc_line_coding_t const* p_line_coding);
|
||||
#endif
|
||||
|
||||
#if ADD_WEAK_FUNC_TUD_CDC_SEND_BREAK_CB
|
||||
#define TUD_CDC_SEND_BREAK_CB tud_cdc_send_break_cb
|
||||
#endif
|
||||
#ifndef TUD_CDC_SEND_BREAK_CB
|
||||
#define TUD_CDC_SEND_BREAK_CB NULL
|
||||
#else
|
||||
extern void TUD_CDC_SEND_BREAK_CB(uint8_t itf, uint16_t duration_ms);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
//--------------------------------------------------------------------+
|
||||
// Inline Functions
|
||||
//--------------------------------------------------------------------+
|
||||
|
|
|
|||
|
|
@ -64,9 +64,6 @@
|
|||
// Compiler porting with Attribute and Endian
|
||||
//--------------------------------------------------------------------+
|
||||
|
||||
// define the standard definition of this macro to construct a "weak" function name
|
||||
#define MAKE_WEAK_FUNC(func_name) func_name
|
||||
|
||||
// TODO refactor since __attribute__ is supported across many compiler
|
||||
#if defined(__GNUC__)
|
||||
#define TU_ATTR_ALIGNED(Bytes) __attribute__ ((aligned(Bytes)))
|
||||
|
|
@ -171,42 +168,6 @@
|
|||
the aligned attribute (or something similar yet) */
|
||||
#define TU_HAS_NO_ATTR_ALIGNED
|
||||
|
||||
/* activate the "weak" function emulation, because this toolchain does not
|
||||
know the weak attribute (or something similar yet) */
|
||||
#define TU_HAS_NO_ATTR_WEAK
|
||||
|
||||
// make sure to define away the standard definition of this macro
|
||||
#undef MAKE_WEAK_FUNC
|
||||
// Helper macro to construct a "weak" function name
|
||||
#define MAKE_WEAK_FUNC(func_name) weak_ ## func_name
|
||||
|
||||
#if defined(TU_HAS_NO_ATTR_WEAK)
|
||||
// "Weak function" emulation defined in cdc_device.h
|
||||
#define ADD_WEAK_FUNC_TUD_CDC_RX_CB 0
|
||||
#define ADD_WEAK_FUNC_TUD_CDC_RX_WANTED_CB 0
|
||||
#define ADD_WEAK_FUNC_TUD_CDC_TX_COMPLETE_CB 0
|
||||
#define ADD_WEAK_FUNC_TUD_CDC_LINE_STATE_CB 0
|
||||
#define ADD_WEAK_FUNC_TUD_CDC_LINE_CODING_CB 0
|
||||
#define ADD_WEAK_FUNC_TUD_CDC_SEND_BREAK_CB 0
|
||||
|
||||
// "Weak function" emulation defined in usbd_pvt.h
|
||||
#define ADD_WEAK_FUNC_USBD_APP_DRIVER_GET_CB 0
|
||||
|
||||
// "Weak function" emulation defined in usbd.h
|
||||
#define ADD_WEAK_FUNC_TUD_DESCRIPTOR_BOS_CB 0
|
||||
#define ADD_WEAK_FUNC_TUD_DESCRIPTOR_DEVICE_QUALIFIER_CB 0
|
||||
#define ADD_WEAK_FUNC_TUD_MOUNT_CB 0
|
||||
#define ADD_WEAK_FUNC_TUD_UMOUNT_CB 0
|
||||
#define ADD_WEAK_FUNC_TUD_SUSPEND_CB 0
|
||||
#define ADD_WEAK_FUNC_TUD_RESUME_CB 0
|
||||
#define ADD_WEAK_FUNC_TUD_VENDOR_CONTROL_XFER_CB 0
|
||||
|
||||
// "Weak function" emulation defined in dcd.h
|
||||
#define ADD_WEAK_FUNC_DCD_EDPT0_STATUS_COMPLETE 0
|
||||
#define ADD_WEAK_FUNC_DCD_EDPT_CLOSE 0
|
||||
#define ADD_WEAK_FUNC_DCD_EDPT_XFER_FIFO 0
|
||||
#endif
|
||||
|
||||
#else
|
||||
#error "Compiler attribute porting is required"
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -262,8 +262,9 @@ enum
|
|||
// USB Descriptors
|
||||
//--------------------------------------------------------------------+
|
||||
|
||||
TU_PACK_STRUCT_BEGIN // Start of definition of packed structs (used by the CCRX toolchain)
|
||||
|
||||
/// USB Device Descriptor
|
||||
TU_PACK_STRUCT_BEGIN
|
||||
typedef struct TU_ATTR_PACKED
|
||||
{
|
||||
uint8_t bLength ; ///< Size of this descriptor in bytes.
|
||||
|
|
@ -284,12 +285,10 @@ typedef struct TU_ATTR_PACKED
|
|||
|
||||
uint8_t bNumConfigurations ; ///< Number of possible configurations.
|
||||
} tusb_desc_device_t;
|
||||
TU_PACK_STRUCT_END
|
||||
|
||||
TU_VERIFY_STATIC( sizeof(tusb_desc_device_t) == 18, "size is not correct");
|
||||
|
||||
// USB Binary Device Object Store (BOS) Descriptor
|
||||
TU_PACK_STRUCT_BEGIN
|
||||
typedef struct TU_ATTR_PACKED
|
||||
{
|
||||
uint8_t bLength ; ///< Size of this descriptor in bytes
|
||||
|
|
@ -297,10 +296,8 @@ typedef struct TU_ATTR_PACKED
|
|||
uint16_t wTotalLength ; ///< Total length of data returned for this descriptor
|
||||
uint8_t bNumDeviceCaps ; ///< Number of device capability descriptors in the BOS
|
||||
} tusb_desc_bos_t;
|
||||
TU_PACK_STRUCT_END
|
||||
|
||||
/// USB Configuration Descriptor
|
||||
TU_PACK_STRUCT_BEGIN
|
||||
typedef struct TU_ATTR_PACKED
|
||||
{
|
||||
uint8_t bLength ; ///< Size of this descriptor in bytes
|
||||
|
|
@ -313,10 +310,8 @@ typedef struct TU_ATTR_PACKED
|
|||
uint8_t bmAttributes ; ///< Configuration characteristics \n D7: Reserved (set to one)\n D6: Self-powered \n D5: Remote Wakeup \n D4...0: Reserved (reset to zero) \n D7 is reserved and must be set to one for historical reasons. \n A device configuration that uses power from the bus and a local source reports a non-zero value in bMaxPower to indicate the amount of bus power required and sets D6. The actual power source at runtime may be determined using the GetStatus(DEVICE) request (see USB 2.0 spec Section 9.4.5). \n If a device configuration supports remote wakeup, D5 is set to one.
|
||||
uint8_t bMaxPower ; ///< Maximum power consumption of the USB device from the bus in this specific configuration when the device is fully operational. Expressed in 2 mA units (i.e., 50 = 100 mA).
|
||||
} tusb_desc_configuration_t;
|
||||
TU_PACK_STRUCT_END
|
||||
|
||||
/// USB Interface Descriptor
|
||||
TU_PACK_STRUCT_BEGIN
|
||||
typedef struct TU_ATTR_PACKED
|
||||
{
|
||||
uint8_t bLength ; ///< Size of this descriptor in bytes
|
||||
|
|
@ -330,10 +325,9 @@ typedef struct TU_ATTR_PACKED
|
|||
uint8_t bInterfaceProtocol ; ///< Protocol code (assigned by the USB). \n These codes are qualified by the value of the bInterfaceClass and the bInterfaceSubClass fields. If an interface supports class-specific requests, this code identifies the protocols that the device uses as defined by the specification of the device class. \li If this field is reset to zero, the device does not use a class-specific protocol on this interface. \li If this field is set to FFH, the device uses a vendor-specific protocol for this interface.
|
||||
uint8_t iInterface ; ///< Index of string descriptor describing this interface
|
||||
} tusb_desc_interface_t;
|
||||
TU_PACK_STRUCT_END
|
||||
|
||||
/// USB Endpoint Descriptor
|
||||
TU_PACK_STRUCT_BEGIN
|
||||
TU_BIT_FIELD_ORDER_BEGIN
|
||||
typedef struct TU_ATTR_PACKED
|
||||
{
|
||||
uint8_t bLength ; ///< Size of this descriptor in bytes
|
||||
|
|
@ -341,14 +335,12 @@ typedef struct TU_ATTR_PACKED
|
|||
|
||||
uint8_t bEndpointAddress ; ///< The address of the endpoint on the USB device described by this descriptor. The address is encoded as follows: \n Bit 3...0: The endpoint number \n Bit 6...4: Reserved, reset to zero \n Bit 7: Direction, ignored for control endpoints 0 = OUT endpoint 1 = IN endpoint.
|
||||
|
||||
TU_BIT_FIELD_ORDER_BEGIN
|
||||
struct TU_ATTR_PACKED {
|
||||
uint8_t xfer : 2;
|
||||
uint8_t sync : 2;
|
||||
uint8_t usage : 2;
|
||||
uint8_t : 2;
|
||||
} bmAttributes ; ///< This field describes the endpoint's attributes when it is configured using the bConfigurationValue. \n Bits 1..0: Transfer Type \n- 00 = Control \n- 01 = Isochronous \n- 10 = Bulk \n- 11 = Interrupt \n If not an isochronous endpoint, bits 5..2 are reserved and must be set to zero. If isochronous, they are defined as follows: \n Bits 3..2: Synchronization Type \n- 00 = No Synchronization \n- 01 = Asynchronous \n- 10 = Adaptive \n- 11 = Synchronous \n Bits 5..4: Usage Type \n- 00 = Data endpoint \n- 01 = Feedback endpoint \n- 10 = Implicit feedback Data endpoint \n- 11 = Reserved \n Refer to Chapter 5 of USB 2.0 specification for more information. \n All other bits are reserved and must be reset to zero. Reserved bits must be ignored by the host.
|
||||
TU_BIT_FIELD_ORDER_END
|
||||
|
||||
struct TU_ATTR_PACKED {
|
||||
#if defined(__CCRX__)
|
||||
|
|
@ -363,10 +355,9 @@ typedef struct TU_ATTR_PACKED
|
|||
|
||||
uint8_t bInterval ; ///< Interval for polling endpoint for data transfers. Expressed in frames or microframes depending on the device operating speed (i.e., either 1 millisecond or 125 us units). \n- For full-/high-speed isochronous endpoints, this value must be in the range from 1 to 16. The bInterval value is used as the exponent for a \f$ 2^(bInterval-1) \f$ value; e.g., a bInterval of 4 means a period of 8 (\f$ 2^(4-1) \f$). \n- For full-/low-speed interrupt endpoints, the value of this field may be from 1 to 255. \n- For high-speed interrupt endpoints, the bInterval value is used as the exponent for a \f$ 2^(bInterval-1) \f$ value; e.g., a bInterval of 4 means a period of 8 (\f$ 2^(4-1) \f$) . This value must be from 1 to 16. \n- For high-speed bulk/control OUT endpoints, the bInterval must specify the maximum NAK rate of the endpoint. A value of 0 indicates the endpoint never NAKs. Other values indicate at most 1 NAK each bInterval number of microframes. This value must be in the range from 0 to 255. \n Refer to Chapter 5 of USB 2.0 specification for more information.
|
||||
} tusb_desc_endpoint_t;
|
||||
TU_PACK_STRUCT_END
|
||||
TU_BIT_FIELD_ORDER_END
|
||||
|
||||
/// USB Other Speed Configuration Descriptor
|
||||
TU_PACK_STRUCT_BEGIN
|
||||
typedef struct TU_ATTR_PACKED
|
||||
{
|
||||
uint8_t bLength ; ///< Size of descriptor
|
||||
|
|
@ -379,10 +370,8 @@ typedef struct TU_ATTR_PACKED
|
|||
uint8_t bmAttributes ; ///< Same as Configuration descriptor
|
||||
uint8_t bMaxPower ; ///< Same as Configuration descriptor
|
||||
} tusb_desc_other_speed_t;
|
||||
TU_PACK_STRUCT_END
|
||||
|
||||
/// USB Device Qualifier Descriptor
|
||||
TU_PACK_STRUCT_BEGIN
|
||||
typedef struct TU_ATTR_PACKED
|
||||
{
|
||||
uint8_t bLength ; ///< Size of descriptor
|
||||
|
|
@ -396,10 +385,8 @@ typedef struct TU_ATTR_PACKED
|
|||
uint8_t bNumConfigurations ; ///< Number of Other-speed Configurations
|
||||
uint8_t bReserved ; ///< Reserved for future use, must be zero
|
||||
} tusb_desc_device_qualifier_t;
|
||||
TU_PACK_STRUCT_END
|
||||
|
||||
/// USB Interface Association Descriptor (IAD ECN)
|
||||
TU_PACK_STRUCT_BEGIN
|
||||
typedef struct TU_ATTR_PACKED
|
||||
{
|
||||
uint8_t bLength ; ///< Size of descriptor
|
||||
|
|
@ -414,20 +401,16 @@ typedef struct TU_ATTR_PACKED
|
|||
|
||||
uint8_t iFunction ; ///< Index of the string descriptor describing the interface association.
|
||||
} tusb_desc_interface_assoc_t;
|
||||
TU_PACK_STRUCT_END
|
||||
|
||||
// USB String Descriptor
|
||||
TU_PACK_STRUCT_BEGIN
|
||||
typedef struct TU_ATTR_PACKED
|
||||
{
|
||||
uint8_t bLength ; ///< Size of this descriptor in bytes
|
||||
uint8_t bDescriptorType ; ///< Descriptor Type
|
||||
uint16_t unicode_string[];
|
||||
} tusb_desc_string_t;
|
||||
TU_PACK_STRUCT_END
|
||||
|
||||
// USB Binary Device Object Store (BOS)
|
||||
TU_PACK_STRUCT_BEGIN
|
||||
typedef struct TU_ATTR_PACKED
|
||||
{
|
||||
uint8_t bLength;
|
||||
|
|
@ -437,10 +420,8 @@ typedef struct TU_ATTR_PACKED
|
|||
uint8_t PlatformCapabilityUUID[16];
|
||||
uint8_t CapabilityData[];
|
||||
} tusb_desc_bos_platform_t;
|
||||
TU_PACK_STRUCT_END
|
||||
|
||||
// USB WebuSB URL Descriptor
|
||||
TU_PACK_STRUCT_BEGIN
|
||||
typedef struct TU_ATTR_PACKED
|
||||
{
|
||||
uint8_t bLength;
|
||||
|
|
@ -448,17 +429,15 @@ typedef struct TU_ATTR_PACKED
|
|||
uint8_t bScheme;
|
||||
char url[];
|
||||
} tusb_desc_webusb_url_t;
|
||||
TU_PACK_STRUCT_END
|
||||
|
||||
// DFU Functional Descriptor
|
||||
TU_PACK_STRUCT_BEGIN
|
||||
TU_BIT_FIELD_ORDER_BEGIN
|
||||
typedef struct TU_ATTR_PACKED
|
||||
{
|
||||
uint8_t bLength;
|
||||
uint8_t bDescriptorType;
|
||||
|
||||
union {
|
||||
TU_BIT_FIELD_ORDER_BEGIN
|
||||
struct TU_ATTR_PACKED {
|
||||
uint8_t bitCanDnload : 1;
|
||||
uint8_t bitCanUpload : 1;
|
||||
|
|
@ -466,7 +445,6 @@ typedef struct TU_ATTR_PACKED
|
|||
uint8_t bitWillDetach : 1;
|
||||
uint8_t reserved : 4;
|
||||
} bmAttributes;
|
||||
TU_BIT_FIELD_ORDER_END
|
||||
|
||||
uint8_t bAttributes;
|
||||
};
|
||||
|
|
@ -475,21 +453,19 @@ typedef struct TU_ATTR_PACKED
|
|||
uint16_t wTransferSize;
|
||||
uint16_t bcdDFUVersion;
|
||||
} tusb_desc_dfu_functional_t;
|
||||
TU_PACK_STRUCT_END
|
||||
TU_BIT_FIELD_ORDER_END
|
||||
|
||||
/*------------------------------------------------------------------*/
|
||||
/* Types
|
||||
*------------------------------------------------------------------*/
|
||||
TU_PACK_STRUCT_BEGIN
|
||||
TU_BIT_FIELD_ORDER_BEGIN
|
||||
typedef struct TU_ATTR_PACKED{
|
||||
union {
|
||||
TU_BIT_FIELD_ORDER_BEGIN
|
||||
struct TU_ATTR_PACKED {
|
||||
uint8_t recipient : 5; ///< Recipient type tusb_request_recipient_t.
|
||||
uint8_t type : 2; ///< Request type tusb_request_type_t.
|
||||
uint8_t direction : 1; ///< Direction type. tusb_dir_t
|
||||
} bmRequestType_bit;
|
||||
TU_BIT_FIELD_ORDER_END
|
||||
|
||||
uint8_t bmRequestType;
|
||||
};
|
||||
|
|
@ -499,7 +475,9 @@ typedef struct TU_ATTR_PACKED{
|
|||
uint16_t wIndex;
|
||||
uint16_t wLength;
|
||||
} tusb_control_request_t;
|
||||
TU_PACK_STRUCT_END
|
||||
TU_BIT_FIELD_ORDER_END
|
||||
|
||||
TU_PACK_STRUCT_END // End of definition of packed structs (used by the CCRX toolchain)
|
||||
|
||||
TU_VERIFY_STATIC( sizeof(tusb_control_request_t) == 8, "size is not correct");
|
||||
|
||||
|
|
|
|||
|
|
@ -117,7 +117,6 @@ void dcd_disconnect(uint8_t rhport) TU_ATTR_WEAK;
|
|||
// Endpoint API
|
||||
//--------------------------------------------------------------------+
|
||||
|
||||
#if !defined(TU_HAS_NO_ATTR_WEAK)
|
||||
// Invoked when a control transfer's status stage is complete.
|
||||
// May help DCD to prepare for next control transfer, this API is optional.
|
||||
void dcd_edpt0_status_complete(uint8_t rhport, tusb_control_request_t const * request) TU_ATTR_WEAK;
|
||||
|
|
@ -130,35 +129,6 @@ void dcd_edpt_close (uint8_t rhport, uint8_t ep_addr) TU_ATTR_WEAK;
|
|||
// This API is optional, may be useful for register-based for transferring data.
|
||||
bool dcd_edpt_xfer_fifo (uint8_t rhport, uint8_t ep_addr, tu_fifo_t * ff, uint16_t total_bytes) TU_ATTR_WEAK;
|
||||
|
||||
#else
|
||||
#if ADD_WEAK_FUNC_DCD_EDPT0_STATUS_COMPLETE
|
||||
#define DCD_EDPT0_STATUS_COMPLETE dcd_edpt0_status_complete
|
||||
#endif
|
||||
#ifndef DCD_EDPT0_STATUS_COMPLETE
|
||||
#define DCD_EDPT0_STATUS_COMPLETE NULL
|
||||
#else
|
||||
extern void DCD_EDPT0_STATUS_COMPLETE(uint8_t rhport, tusb_control_request_t const * request);
|
||||
#endif
|
||||
|
||||
#if ADD_WEAK_FUNC_DCD_EDPT_CLOSE
|
||||
#define DCD_EDPT_CLOSE dcd_edpt_close
|
||||
#endif
|
||||
#ifndef DCD_EDPT_CLOSE
|
||||
#define DCD_EDPT_CLOSE NULL
|
||||
#else
|
||||
extern void DCD_EDPT_CLOSE(uint8_t rhport, uint8_t ep_addr);
|
||||
#endif
|
||||
|
||||
#if ADD_WEAK_FUNC_DCD_EDPT_XFER_FIFO
|
||||
#define DCD_EDPT_XFER_FIFO dcd_edpt_xfer_fifo
|
||||
#endif
|
||||
#ifndef DCD_EDPT_XFER_FIFO
|
||||
#define DCD_EDPT_XFER_FIFO NULL
|
||||
#else
|
||||
extern void DCD_EDPT_XFER_FIFO(uint8_t rhport, uint8_t ep_addr, tu_fifo_t * ff, uint16_t total_bytes);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// Configure endpoint's registers according to descriptor
|
||||
bool dcd_edpt_open (uint8_t rhport, tusb_desc_endpoint_t const * p_endpoint_desc);
|
||||
|
||||
|
|
|
|||
|
|
@ -33,19 +33,6 @@
|
|||
#include "device/usbd_pvt.h"
|
||||
#include "device/dcd.h"
|
||||
|
||||
#if defined(TU_HAS_NO_ATTR_WEAK)
|
||||
static uint8_t const* (*const MAKE_WEAK_FUNC(tud_descriptor_bos_cb))(void) = TUD_DESCRIPTOR_BOS_CB;
|
||||
static uint8_t const* (*const MAKE_WEAK_FUNC(tud_descriptor_device_qualifier_cb))(void) = TUD_DESCRIPTOR_DEVICE_QUALIFIER_CB;
|
||||
static void (*const MAKE_WEAK_FUNC(tud_mount_cb))(void) = TUD_MOUNT_CB;
|
||||
static void (*const MAKE_WEAK_FUNC(tud_umount_cb))(void) = TUD_UMOUNT_CB;
|
||||
static void (*const MAKE_WEAK_FUNC(tud_suspend_cb))(_Bool) = TUD_SUSPEND_CB;
|
||||
static void (*const MAKE_WEAK_FUNC(tud_resume_cb))(void) = TUD_RESUME_CB;
|
||||
static _Bool (*const MAKE_WEAK_FUNC(tud_vendor_control_xfer_cb))(uint8_t, uint8_t, tusb_control_request_t const *) = TUD_RESUME_CB;
|
||||
static usbd_class_driver_t const* (*const MAKE_WEAK_FUNC(usbd_app_driver_get_cb))(uint8_t*) = USBD_APP_DRIVER_GET_CB;
|
||||
static bool (*const MAKE_WEAK_FUNC(dcd_edpt_xfer_fifo))(uint8_t, uint8_t, tu_fifo_t *, uint16_t) = DCD_EDPT_XFER_FIFO;
|
||||
static void (*const MAKE_WEAK_FUNC(dcd_edpt_close))(uint8_t, uint8_t) = DCD_EDPT_CLOSE;
|
||||
#endif
|
||||
|
||||
#ifndef CFG_TUD_TASK_QUEUE_SZ
|
||||
#define CFG_TUD_TASK_QUEUE_SZ 16
|
||||
#endif
|
||||
|
|
@ -61,10 +48,11 @@ static void (*const MAKE_WEAK_FUNC(dcd_edpt_close))(uint8_t, uint8_t) = DCD_EDPT
|
|||
// Invalid driver ID in itf2drv[] ep2drv[][] mapping
|
||||
enum { DRVID_INVALID = 0xFFu };
|
||||
|
||||
TU_PACK_STRUCT_BEGIN // Start of definition of packed structs (used by the CCRX toolchain)
|
||||
|
||||
TU_BIT_FIELD_ORDER_BEGIN
|
||||
typedef struct
|
||||
{
|
||||
TU_PACK_STRUCT_BEGIN
|
||||
TU_BIT_FIELD_ORDER_BEGIN
|
||||
struct TU_ATTR_PACKED
|
||||
{
|
||||
volatile uint8_t connected : 1;
|
||||
|
|
@ -75,8 +63,6 @@ typedef struct
|
|||
uint8_t remote_wakeup_support : 1; // configuration descriptor's attribute
|
||||
uint8_t self_powered : 1; // configuration descriptor's attribute
|
||||
};
|
||||
TU_BIT_FIELD_ORDER_END
|
||||
TU_PACK_STRUCT_END
|
||||
|
||||
volatile uint8_t cfg_num; // current active configuration (0x00 is not configured)
|
||||
uint8_t speed;
|
||||
|
|
@ -84,8 +70,6 @@ typedef struct
|
|||
uint8_t itf2drv[16]; // map interface number to driver (0xff is invalid)
|
||||
uint8_t ep2drv[CFG_TUD_EP_MAX][2]; // map endpoint to driver ( 0xff is invalid )
|
||||
|
||||
TU_PACK_STRUCT_BEGIN
|
||||
TU_BIT_FIELD_ORDER_BEGIN
|
||||
struct TU_ATTR_PACKED
|
||||
{
|
||||
volatile bool busy : 1;
|
||||
|
|
@ -94,10 +78,11 @@ typedef struct
|
|||
|
||||
// TODO merge ep2drv here, 4-bit should be sufficient
|
||||
}ep_status[CFG_TUD_EP_MAX][2];
|
||||
TU_BIT_FIELD_ORDER_END
|
||||
TU_PACK_STRUCT_END
|
||||
|
||||
}usbd_device_t;
|
||||
TU_BIT_FIELD_ORDER_END
|
||||
|
||||
TU_PACK_STRUCT_END // End of definition of packed structs (used by the CCRX toolchain)
|
||||
|
||||
static usbd_device_t _usbd_dev;
|
||||
|
||||
|
|
@ -257,7 +242,7 @@ static uint8_t _app_driver_count = 0;
|
|||
static inline usbd_class_driver_t const * get_driver(uint8_t drvid)
|
||||
{
|
||||
// Application drivers
|
||||
if ( MAKE_WEAK_FUNC(usbd_app_driver_get_cb) )
|
||||
if ( usbd_app_driver_get_cb )
|
||||
{
|
||||
if ( drvid < _app_driver_count ) return &_app_driver[drvid];
|
||||
drvid -= _app_driver_count;
|
||||
|
|
@ -429,9 +414,9 @@ bool tud_init (uint8_t rhport)
|
|||
TU_ASSERT(_usbd_q);
|
||||
|
||||
// Get application driver if available
|
||||
if ( MAKE_WEAK_FUNC(usbd_app_driver_get_cb) )
|
||||
if ( usbd_app_driver_get_cb )
|
||||
{
|
||||
_app_driver = MAKE_WEAK_FUNC(usbd_app_driver_get_cb)(&_app_driver_count);
|
||||
_app_driver = usbd_app_driver_get_cb(&_app_driver_count);
|
||||
}
|
||||
|
||||
// Init class drivers
|
||||
|
|
@ -522,7 +507,7 @@ void tud_task (void)
|
|||
usbd_reset(event.rhport);
|
||||
|
||||
// invoke callback
|
||||
if (MAKE_WEAK_FUNC(tud_umount_cb)) MAKE_WEAK_FUNC(tud_umount_cb)();
|
||||
if (tud_umount_cb) tud_umount_cb();
|
||||
break;
|
||||
|
||||
case DCD_EVENT_SETUP_RECEIVED:
|
||||
|
|
@ -578,12 +563,12 @@ void tud_task (void)
|
|||
|
||||
case DCD_EVENT_SUSPEND:
|
||||
TU_LOG2("\r\n");
|
||||
if (MAKE_WEAK_FUNC(tud_suspend_cb)) MAKE_WEAK_FUNC(tud_suspend_cb)(_usbd_dev.remote_wakeup_en);
|
||||
if (tud_suspend_cb) tud_suspend_cb(_usbd_dev.remote_wakeup_en);
|
||||
break;
|
||||
|
||||
case DCD_EVENT_RESUME:
|
||||
TU_LOG2("\r\n");
|
||||
if (MAKE_WEAK_FUNC(tud_resume_cb)) MAKE_WEAK_FUNC(tud_resume_cb)();
|
||||
if (tud_resume_cb) tud_resume_cb();
|
||||
break;
|
||||
|
||||
case DCD_EVENT_SOF:
|
||||
|
|
@ -630,10 +615,10 @@ static bool process_control_request(uint8_t rhport, tusb_control_request_t const
|
|||
// Vendor request
|
||||
if ( p_request->bmRequestType_bit.type == TUSB_REQ_TYPE_VENDOR )
|
||||
{
|
||||
TU_VERIFY(MAKE_WEAK_FUNC(tud_vendor_control_xfer_cb));
|
||||
TU_VERIFY(tud_vendor_control_xfer_cb);
|
||||
|
||||
usbd_control_set_complete_callback(MAKE_WEAK_FUNC(tud_vendor_control_xfer_cb));
|
||||
return MAKE_WEAK_FUNC(tud_vendor_control_xfer_cb)(rhport, CONTROL_STAGE_SETUP, p_request);
|
||||
usbd_control_set_complete_callback(tud_vendor_control_xfer_cb);
|
||||
return tud_vendor_control_xfer_cb(rhport, CONTROL_STAGE_SETUP, p_request);
|
||||
}
|
||||
|
||||
#if CFG_TUSB_DEBUG >= 2
|
||||
|
|
@ -913,7 +898,7 @@ static bool process_set_config(uint8_t rhport, uint8_t cfg_num)
|
|||
}
|
||||
|
||||
// invoke callback
|
||||
if (MAKE_WEAK_FUNC(tud_mount_cb)) MAKE_WEAK_FUNC(tud_mount_cb)();
|
||||
if (tud_mount_cb) tud_mount_cb();
|
||||
|
||||
return true;
|
||||
}
|
||||
|
|
@ -970,9 +955,9 @@ static bool process_get_descriptor(uint8_t rhport, tusb_control_request_t const
|
|||
TU_LOG2(" BOS\r\n");
|
||||
|
||||
// requested by host if USB > 2.0 ( i.e 2.1 or 3.x )
|
||||
if (!MAKE_WEAK_FUNC(tud_descriptor_bos_cb)) return false;
|
||||
if (!tud_descriptor_bos_cb) return false;
|
||||
|
||||
tusb_desc_bos_t const* desc_bos = (tusb_desc_bos_t const*)MAKE_WEAK_FUNC(tud_descriptor_bos_cb)();
|
||||
tusb_desc_bos_t const* desc_bos = (tusb_desc_bos_t const*)tud_descriptor_bos_cb();
|
||||
|
||||
uint16_t total_len;
|
||||
// Use offsetof to avoid pointer to the odd/misaligned address
|
||||
|
|
@ -1016,9 +1001,9 @@ static bool process_get_descriptor(uint8_t rhport, tusb_control_request_t const
|
|||
// Host sends this request to ask why our device with USB BCD from 2.0
|
||||
// but is running at Full/Low Speed. If not highspeed capable stall this request,
|
||||
// otherwise return the descriptor that could work in highspeed mode
|
||||
if (MAKE_WEAK_FUNC(tud_descriptor_device_qualifier_cb))
|
||||
if (tud_descriptor_device_qualifier_cb)
|
||||
{
|
||||
uint8_t const* desc_qualifier = MAKE_WEAK_FUNC(tud_descriptor_device_qualifier_cb)();
|
||||
uint8_t const* desc_qualifier = tud_descriptor_device_qualifier_cb();
|
||||
TU_ASSERT(desc_qualifier);
|
||||
|
||||
// first byte of descriptor is its size
|
||||
|
|
@ -1306,7 +1291,7 @@ bool usbd_edpt_xfer_fifo(uint8_t rhport, uint8_t ep_addr, tu_fifo_t * ff, uint16
|
|||
// and usbd task can preempt and clear the busy
|
||||
_usbd_dev.ep_status[epnum][dir].busy = true;
|
||||
|
||||
if (MAKE_WEAK_FUNC(dcd_edpt_xfer_fifo)(rhport, ep_addr, ff, total_bytes))
|
||||
if (dcd_edpt_xfer_fifo(rhport, ep_addr, ff, total_bytes))
|
||||
{
|
||||
TU_LOG2("OK\r\n");
|
||||
return true;
|
||||
|
|
@ -1369,10 +1354,10 @@ bool usbd_edpt_stalled(uint8_t rhport, uint8_t ep_addr)
|
|||
*/
|
||||
void usbd_edpt_close(uint8_t rhport, uint8_t ep_addr)
|
||||
{
|
||||
TU_ASSERT(MAKE_WEAK_FUNC(dcd_edpt_close), /**/);
|
||||
TU_ASSERT(dcd_edpt_close, /**/);
|
||||
TU_LOG2(" CLOSING Endpoint: 0x%02X\r\n", ep_addr);
|
||||
|
||||
MAKE_WEAK_FUNC(dcd_edpt_close(rhport, ep_addr));
|
||||
dcd_edpt_close(rhport, ep_addr);
|
||||
|
||||
return;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -111,7 +111,6 @@ uint8_t const * tud_descriptor_configuration_cb(uint8_t index);
|
|||
// Application return pointer to descriptor, whose contents must exist long enough for transfer to complete
|
||||
uint16_t const* tud_descriptor_string_cb(uint8_t index, uint16_t langid);
|
||||
|
||||
#if !defined(TU_HAS_NO_ATTR_WEAK)
|
||||
// Invoked when received GET BOS DESCRIPTOR request
|
||||
// Application return pointer to descriptor
|
||||
TU_ATTR_WEAK uint8_t const * tud_descriptor_bos_cb(void);
|
||||
|
|
@ -136,71 +135,6 @@ TU_ATTR_WEAK void tud_resume_cb(void);
|
|||
// Invoked when received control request with VENDOR TYPE
|
||||
TU_ATTR_WEAK bool tud_vendor_control_xfer_cb(uint8_t rhport, uint8_t stage, tusb_control_request_t const * request);
|
||||
|
||||
#else
|
||||
#if ADD_WEAK_FUNC_TUD_DESCRIPTOR_BOS_CB
|
||||
#define TUD_DESCRIPTOR_BOS_CB tud_descriptor_bos_cb
|
||||
#endif
|
||||
#ifndef TUD_DESCRIPTOR_BOS_CB
|
||||
#define TUD_DESCRIPTOR_BOS_CB NULL
|
||||
#else
|
||||
extern uint8_t const* TUD_DESCRIPTOR_BOS_CB(void);
|
||||
#endif
|
||||
|
||||
#if ADD_WEAK_FUNC_TUD_DESCRIPTOR_DEVICE_QUALIFIER_CB
|
||||
#define TUD_DESCRIPTOR_DEVICE_QUALIFIER_CB tud_descriptor_device_qualifier_cb
|
||||
#endif
|
||||
#ifndef TUD_DESCRIPTOR_DEVICE_QUALIFIER_CB
|
||||
#define TUD_DESCRIPTOR_DEVICE_QUALIFIER_CB NULL
|
||||
#else
|
||||
extern uint8_t const* TUD_DESCRIPTOR_DEVICE_QUALIFIER_CB(void);
|
||||
#endif
|
||||
|
||||
#if ADD_WEAK_FUNC_TUD_MOUNT_CB
|
||||
#define TUD_MOUNT_CB tud_mount_cb
|
||||
#endif
|
||||
#ifndef TUD_MOUNT_CB
|
||||
#define TUD_MOUNT_CB NULL
|
||||
#else
|
||||
extern void TUD_MOUNT_CB(void);
|
||||
#endif
|
||||
|
||||
#if ADD_WEAK_FUNC_TUD_UMOUNT_CB
|
||||
#define TUD_UMOUNT_CB tud_umount_cb
|
||||
#endif
|
||||
#ifndef TUD_UMOUNT_CB
|
||||
#define TUD_UMOUNT_CB NULL
|
||||
#else
|
||||
extern void TUD_UMOUNT_CB(void);
|
||||
#endif
|
||||
|
||||
#if ADD_WEAK_FUNC_TUD_SUSPEND_CB
|
||||
#define TUD_SUSPEND_CB tud_suspend_cb
|
||||
#endif
|
||||
#ifndef TUD_SUSPEND_CB
|
||||
#define TUD_SUSPEND_CB NULL
|
||||
#else
|
||||
extern void TUD_SUSPEND_CB(bool remote_wakeup_en);
|
||||
#endif
|
||||
|
||||
#if ADD_WEAK_FUNC_TUD_RESUME_CB
|
||||
#define TUD_RESUME_CB tud_resume_cb
|
||||
#endif
|
||||
#ifndef TUD_RESUME_CB
|
||||
#define TUD_RESUME_CB NULL
|
||||
#else
|
||||
extern void TUD_RESUME_CB(void);
|
||||
#endif
|
||||
|
||||
#if ADD_WEAK_FUNC_TUD_VENDOR_CONTROL_XFER_CB
|
||||
#define TUD_VENDOR_CONTROL_XFER_CB tud_vendor_control_xfer_cb
|
||||
#endif
|
||||
#ifndef TUD_VENDOR_CONTROL_XFER_CB
|
||||
#define TUD_VENDOR_CONTROL_XFER_CB NULL
|
||||
#else
|
||||
extern bool TUD_VENDOR_CONTROL_XFER_CB(uint8_t rhport, uint8_t stage, tusb_control_request_t const * request);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
//--------------------------------------------------------------------+
|
||||
// Binary Device Object Store (BOS) Descriptor Templates
|
||||
//--------------------------------------------------------------------+
|
||||
|
|
|
|||
|
|
@ -36,10 +36,6 @@
|
|||
extern void usbd_driver_print_control_complete_name(usbd_control_xfer_cb_t callback);
|
||||
#endif
|
||||
|
||||
#if defined(TU_HAS_NO_ATTR_WEAK)
|
||||
static void (*const MAKE_WEAK_FUNC(dcd_edpt0_status_complete))(uint8_t, tusb_control_request_t const *) = DCD_EDPT0_STATUS_COMPLETE;
|
||||
#endif
|
||||
|
||||
enum
|
||||
{
|
||||
EDPT_CTRL_OUT = 0x00,
|
||||
|
|
@ -184,7 +180,7 @@ bool usbd_control_xfer_cb (uint8_t rhport, uint8_t ep_addr, xfer_result_t result
|
|||
TU_ASSERT(0 == xferred_bytes);
|
||||
|
||||
// invoke optional dcd hook if available
|
||||
if (MAKE_WEAK_FUNC(dcd_edpt0_status_complete)) MAKE_WEAK_FUNC(dcd_edpt0_status_complete)(rhport, &_ctrl_xfer.request);
|
||||
if (dcd_edpt0_status_complete) dcd_edpt0_status_complete(rhport, &_ctrl_xfer.request);
|
||||
|
||||
if (_ctrl_xfer.complete_cb)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -51,22 +51,10 @@ typedef struct
|
|||
void (* sof ) (uint8_t rhport); /* optional */
|
||||
} usbd_class_driver_t;
|
||||
|
||||
#if !defined(TU_HAS_NO_ATTR_WEAK)
|
||||
// Invoked when initializing device stack to get additional class drivers.
|
||||
// Can optionally implemented by application to extend/overwrite class driver support.
|
||||
// Note: The drivers array must be accessible at all time when stack is active
|
||||
usbd_class_driver_t const* usbd_app_driver_get_cb(uint8_t* driver_count) TU_ATTR_WEAK;
|
||||
#else
|
||||
#if ADD_WEAK_FUNC_USBD_APP_DRIVER_GET_CB
|
||||
#define USBD_APP_DRIVER_GET_CB usbd_app_driver_get_cb
|
||||
#endif
|
||||
#ifndef USBD_APP_DRIVER_GET_CB
|
||||
#define USBD_APP_DRIVER_GET_CB NULL
|
||||
#else
|
||||
extern usbd_class_driver_t const* USBD_APP_DRIVER_GET_CB(uint8_t* driver_count);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
typedef bool (*usbd_control_xfer_cb_t)(uint8_t rhport, uint8_t stage, tusb_control_request_t const * request);
|
||||
|
||||
|
|
|
|||
|
|
@ -90,45 +90,47 @@
|
|||
#define FIFO_REQ_CLR (1u)
|
||||
#define FIFO_COMPLETE (1u<<1)
|
||||
|
||||
TU_BIT_FIELD_ORDER_BEGIN
|
||||
typedef struct {
|
||||
union {
|
||||
TU_BIT_FIELD_ORDER_BEGIN
|
||||
struct {
|
||||
uint16_t : 8;
|
||||
uint16_t TRCLR: 1;
|
||||
uint16_t TRENB: 1;
|
||||
uint16_t : 0;
|
||||
};
|
||||
TU_BIT_FIELD_ORDER_END
|
||||
uint16_t TRE;
|
||||
};
|
||||
uint16_t TRN;
|
||||
} reg_pipetre_t;
|
||||
TU_BIT_FIELD_ORDER_END
|
||||
|
||||
TU_BIT_FIELD_ORDER_BEGIN
|
||||
typedef union {
|
||||
TU_BIT_FIELD_ORDER_BEGIN
|
||||
struct {
|
||||
volatile uint16_t u8: 8;
|
||||
volatile uint16_t : 0;
|
||||
};
|
||||
TU_BIT_FIELD_ORDER_END
|
||||
volatile uint16_t u16;
|
||||
} hw_fifo_t;
|
||||
TU_BIT_FIELD_ORDER_END
|
||||
|
||||
TU_PACK_STRUCT_BEGIN
|
||||
TU_PACK_STRUCT_BEGIN // Start of definition of packed structs (used by the CCRX toolchain)
|
||||
|
||||
TU_BIT_FIELD_ORDER_BEGIN
|
||||
typedef struct TU_ATTR_PACKED
|
||||
{
|
||||
uintptr_t addr; /* the start address of a transfer data buffer */
|
||||
uint16_t length; /* the number of bytes in the buffer */
|
||||
uint16_t remaining; /* the number of bytes remaining in the buffer */
|
||||
TU_BIT_FIELD_ORDER_BEGIN
|
||||
struct {
|
||||
uint32_t ep : 8; /* an assigned endpoint address */
|
||||
uint32_t : 0;
|
||||
};
|
||||
TU_BIT_FIELD_ORDER_END
|
||||
} pipe_state_t;
|
||||
TU_PACK_STRUCT_END
|
||||
TU_BIT_FIELD_ORDER_END
|
||||
|
||||
TU_PACK_STRUCT_END // End of definition of packed structs (used by the CCRX toolchain)
|
||||
|
||||
typedef struct
|
||||
{
|
||||
|
|
@ -259,12 +261,6 @@ static int fifo_write(volatile void *fifo, pipe_state_t* pipe, unsigned mps)
|
|||
|
||||
hw_fifo_t *reg = (hw_fifo_t*)fifo;
|
||||
uintptr_t addr = pipe->addr + pipe->length - rem;
|
||||
if (addr & 1u) {
|
||||
/* addr is not 2-byte aligned */
|
||||
reg->u8 = *(const uint8_t *)addr;
|
||||
++addr;
|
||||
--len;
|
||||
}
|
||||
while (len >= 2) {
|
||||
reg->u16 = *(const uint16_t *)addr;
|
||||
addr += 2;
|
||||
|
|
@ -306,17 +302,10 @@ static void process_setup_packet(uint8_t rhport)
|
|||
uint16_t setup_packet[4];
|
||||
if (0 == (USB0.INTSTS0.WORD & USB_IS0_VALID)) return;
|
||||
USB0.CFIFOCTR.WORD = USB_FIFOCTR_BCLR;
|
||||
setup_packet[0] = USB0.USBREQ.WORD;
|
||||
setup_packet[0] = tu_le16toh(USB0.USBREQ.WORD);
|
||||
setup_packet[1] = USB0.USBVAL;
|
||||
setup_packet[2] = USB0.USBINDX;
|
||||
setup_packet[3] = USB0.USBLENG;
|
||||
#if TU_BYTE_ORDER==TU_BIG_ENDIAN
|
||||
#if defined(__CCRX__)
|
||||
setup_packet[0] = tu_le16toh(setup_packet[0]);
|
||||
#else
|
||||
//FIXME needs to implemented for other tool chains
|
||||
#endif
|
||||
#endif
|
||||
USB0.INTSTS0.WORD = ~USB_IS0_VALID;
|
||||
dcd_event_setup_received(rhport, (const uint8_t*)&setup_packet[0], true);
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in New Issue