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

response with request safe5v, get passed PS_READY

Browse Source
This commit is contained in:
hathach 2023-06-12 12:14:55 +07:00
parent bb4fb0543b
commit debde4cc97
No known key found for this signature in database
GPG Key ID: F5D50C6D51D17CBA
5 changed files with 180 additions and 18 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
src/common/tusb_types.h
View File

@ -562,6 +562,16 @@ enum {
TUSB_PD_REV30 = 0x2,
};
enum {
TUSB_PD_DATA_ROLE_UFP = 0x0,
TUSB_PD_DATA_ROLE_DFP = 0x1,
};
enum {
TUSB_PD_POWER_ROLE_SINK = 0x0,
TUSB_PD_POWER_ROLE_SOURCE = 0x1,
};
typedef struct TU_ATTR_PACKED {
uint16_t msg_type : 5; // [0:4]
uint16_t data_role : 1; // [5] SOP only: 0 UFP, 1 DFP

78
src/portable/st/typec/typec_stm32.c
View File

@ -63,6 +63,9 @@ enum {
static uint8_t const* _rx_buf;
static uint8_t const* _tx_pending_buf;
static uint16_t _tx_pending_bytes;
static uint16_t _tx_xferring_bytes;
static tusb_pd_header_t _good_crc = {
.msg_type = TUSB_PD_CTRL_GOOD_CRC,
@ -141,10 +144,21 @@ TU_ATTR_ALWAYS_INLINE static inline void dma_stop(uint8_t rhport, bool is_rx) {
dma_ch->CCR &= ~DMA_CCR_EN;
}
TU_ATTR_ALWAYS_INLINE static inline bool dma_enabled(uint8_t rhport, bool is_rx) {
DMA_Channel_TypeDef* dma_ch = (DMA_Channel_TypeDef*) dma_get_addr(rhport, is_rx);
return dma_ch->CCR & DMA_CCR_EN;
}
TU_ATTR_ALWAYS_INLINE static inline void dma_tx_start(uint8_t rhport, void const* buf, uint16_t len) {
UCPD1->TX_ORDSET = PHY_ORDERED_SET_SOP;
UCPD1->TX_PAYSZ = len;
dma_start(rhport, false, buf, len);
UCPD1->CR |= UCPD_CR_TXSEND;
}
TU_ATTR_ALWAYS_INLINE static inline void dma_tx_stop(uint8_t rhport) {
dma_stop(rhport, false);
}
//--------------------------------------------------------------------+
@ -203,11 +217,23 @@ bool tcd_rx_start(uint8_t rhport, uint8_t* buffer, uint16_t total_bytes) {
return true;
}
bool tcd_tx_start(uint8_t rhport, uint8_t const* buffer, uint16_t total_bytes) {
bool tcd_msg_send(uint8_t rhport, uint8_t const* buffer, uint16_t total_bytes) {
(void) rhport;
(void) buffer;
(void) total_bytes;
return false;
if (dma_enabled(rhport, false)) {
// DMA is busy, probably sending GoodCRC, save as pending TX
_tx_pending_buf = buffer;
_tx_pending_bytes = total_bytes;
}else {
// DMA is free, start sending
_tx_pending_buf = NULL;
_tx_pending_bytes = 0;
_tx_xferring_bytes = total_bytes;
dma_tx_start(rhport, buffer, total_bytes);
}
return true;
}
void tcd_int_handler(uint8_t rhport) {
@ -275,6 +301,8 @@ void tcd_int_handler(uint8_t rhport) {
// Received full message
if (sr & UCPD_SR_RXMSGEND) {
TU_LOG3("RX MSG END\n");
// stop TX
dma_stop(rhport, true);
uint8_t result;
@ -283,7 +311,6 @@ void tcd_int_handler(uint8_t rhport) {
// response with good crc
_good_crc.msg_id = ((tusb_pd_header_t const*) _rx_buf)->msg_id;
dma_tx_start(rhport, &_good_crc, 2);
UCPD1->CR |= UCPD_CR_TXSEND;
result = XFER_RESULT_SUCCESS;
}else {
@ -305,19 +332,38 @@ void tcd_int_handler(uint8_t rhport) {
}
//------------- TX -------------//
if (sr & UCPD_SR_TXMSGSENT) {
TU_LOG3("TX MSG SENT\n");
// all byte sent
dma_stop(rhport, false);
// All tx events: complete and error
if (sr & (UCPD_SR_TXMSGSENT | (UCPD_SR_TXMSGDISC | UCPD_SR_TXMSGABT | UCPD_SR_TXUND))) {
// force TX stop
dma_tx_stop(rhport);
// ack
UCPD1->ICR = UCPD_ICR_TXMSGSENTCF;
}
uint16_t const xferred_bytes = _tx_xferring_bytes - UCPD1->TX_PAYSZ;
uint8_t result;
if (sr & (UCPD_SR_TXMSGDISC | UCPD_SR_TXMSGABT | UCPD_SR_TXUND)) {
TU_LOG3("TX Error\n");
dma_stop(rhport, false);
UCPD1->ICR = UCPD_SR_TXMSGDISC | UCPD_SR_TXMSGABT | UCPD_SR_TXUND;
if ( sr & UCPD_SR_TXMSGSENT ) {
TU_LOG3("TX MSG SENT\n");
result = XFER_RESULT_SUCCESS;
// ack
UCPD1->ICR = UCPD_ICR_TXMSGSENTCF;
}else {
TU_LOG3("TX Error\n");
result = XFER_RESULT_FAILED;
// ack
UCPD1->ICR = UCPD_SR_TXMSGDISC | UCPD_SR_TXMSGABT | UCPD_SR_TXUND;
}
// start pending TX if any
if (_tx_pending_buf && _tx_pending_bytes ) {
// Start the pending TX
dma_tx_start(rhport, _tx_pending_buf, _tx_pending_bytes);
// clear pending
_tx_pending_buf = NULL;
_tx_pending_bytes = 0;
}
// notify stack
tcd_event_tx_complete(rhport, xferred_bytes, result, true);
}
}

17
src/typec/tcd.h
View File

@ -43,6 +43,7 @@ enum {
TCD_EVENT_INVALID = 0,
TCD_EVENT_CC_CHANGED,
TCD_EVENT_RX_COMPLETE,
TCD_EVENT_TX_COMPLETE,
};
@ -84,7 +85,7 @@ void tcd_int_handler(uint8_t rhport);
//--------------------------------------------------------------------+
bool tcd_rx_start(uint8_t rhport, uint8_t* buffer, uint16_t total_bytes);
bool tcd_tx_start(uint8_t rhport, uint8_t const* buffer, uint16_t total_bytes);
bool tcd_msg_send(uint8_t rhport, uint8_t const* buffer, uint16_t total_bytes);
//--------------------------------------------------------------------+
// Event API (implemented by stack)
@ -120,4 +121,18 @@ void tcd_event_rx_complete(uint8_t rhport, uint16_t xferred_bytes, uint8_t resul
tcd_event_handler(&event, in_isr);
}
TU_ATTR_ALWAYS_INLINE static inline
void tcd_event_tx_complete(uint8_t rhport, uint16_t xferred_bytes, uint8_t result, bool in_isr) {
tcd_event_t event = {
.rhport = rhport,
.event_id = TCD_EVENT_TX_COMPLETE,
.rx_complete = {
.xferred_bytes = xferred_bytes,
.result = result
}
};
tcd_event_handler(&event, in_isr);
}
#endif

59
src/typec/utcd.c
View File

@ -53,6 +53,7 @@ static bool _port_inited[TUP_TYPEC_RHPORTS_NUM];
// Max possible PD size is 262 bytes
static uint8_t _rx_buf[262] TU_ATTR_ALIGNED(4);
static uint8_t _tx_buf[100] TU_ATTR_ALIGNED(4);
//--------------------------------------------------------------------+
//
@ -90,6 +91,19 @@ bool tuc_init(uint8_t rhport, tusb_typec_port_type_t port_type) {
//
//--------------------------------------------------------------------+
bool utcd_msg_send(uint8_t rhport, tusb_pd_header_t const* header, void const* data) {
// copy header
memcpy(_tx_buf, header, sizeof(tusb_pd_header_t));
// copy data objcet if available
uint16_t const n_data_obj = header->n_data_obj;
if (n_data_obj > 0) {
memcpy(_tx_buf + sizeof(tusb_pd_header_t), data, n_data_obj * 4);
}
return tcd_msg_send(rhport, _tx_buf, sizeof(tusb_pd_header_t) + n_data_obj * 4);
}
bool parse_message(uint8_t rhport, uint8_t const* buf, uint16_t len) {
(void) rhport;
uint8_t const* p_end = buf + len;
@ -98,10 +112,28 @@ bool parse_message(uint8_t rhport, uint8_t const* buf, uint16_t len) {
if (header->n_data_obj == 0) {
// control message
switch (header->msg_type) {
case TUSB_PD_CTRL_GOOD_CRC:
break;
case TUSB_PD_CTRL_ACCEPT:
break;
case TUSB_PD_CTRL_REJECT:
break;
case TUSB_PD_CTRL_PS_RDY:
break;
default: break;
}
} else {
// data message
switch (header->msg_type) {
case TUSB_PD_DATA_SOURCE_CAP: {
// Examine source capability and select a suitable PDO (starting from 1 with safe5v)
uint8_t obj_pos = 1;
for(size_t i=0; i<header->n_data_obj; i++) {
TU_VERIFY(ptr < p_end);
uint32_t const pdo = tu_le32toh(tu_unaligned_read32(ptr));
@ -125,6 +157,33 @@ bool parse_message(uint8_t rhport, uint8_t const* buf, uint16_t len) {
ptr += 4;
}
// Send request with selected PDO position as response to Source Cap
pd_rdo_fixed_variable_t rdo = {
.current_extremum_10ma = 50, // max 500mA
.current_operate_10ma = 30, // 300mA
.reserved = 0,
.epr_mode_capable = 0,
.unchunked_ext_msg_support = 0,
.no_usb_suspend = 0,
.usb_comm_capable = 1,
.capability_mismatch = 0,
.give_back_flag = 0, // exteremum is max
.object_position = obj_pos,
};
tusb_pd_header_t const req_header = {
.msg_type = TUSB_PD_DATA_REQUEST,
.data_role = TUSB_PD_DATA_ROLE_UFP,
.specs_rev = TUSB_PD_REV20,
.power_role = TUSB_PD_POWER_ROLE_SINK,
.msg_id = 0,
.n_data_obj = 1,
.extended = 0,
};
utcd_msg_send(rhport, &req_header, &rdo);
break;
}

34
src/typec/utcd.h
View File

@ -42,7 +42,7 @@ extern "C" {
#endif
//--------------------------------------------------------------------+
//
// Source Capability
//--------------------------------------------------------------------+
// All table references are from USBPD Specification rev3.1 version 1.8
@ -102,6 +102,38 @@ typedef struct TU_ATTR_PACKED {
} pd_pdo_apdo_t;
TU_VERIFY_STATIC(sizeof(pd_pdo_apdo_t) == 4, "Invalid size");
//--------------------------------------------------------------------+
// Request
//--------------------------------------------------------------------+
typedef struct TU_ATTR_PACKED {
uint32_t current_extremum_10ma : 10; // [9..0] Max (give back = 0) or Min (give back = 1) current in 10mA unit
uint32_t current_operate_10ma : 10; // [19..10] Operating current in 10mA unit
uint32_t reserved : 2; // [21..20] Reserved
uint32_t epr_mode_capable : 1; // [22] EPR mode capable
uint32_t unchunked_ext_msg_support : 1; // [23] UnChunked Extended Message Supported
uint32_t no_usb_suspend : 1; // [24] No USB Suspend
uint32_t usb_comm_capable : 1; // [25] USB Communications Capable
uint32_t capability_mismatch : 1; // [26] Capability Mismatch
uint32_t give_back_flag : 1; // [27] GiveBack Flag: 0 = Max, 1 = Min
uint32_t object_position : 4; // [31..28] Object Position
} pd_rdo_fixed_variable_t;
TU_VERIFY_STATIC(sizeof(pd_rdo_fixed_variable_t) == 4, "Invalid size");
typedef struct TU_ATTR_PACKED {
uint32_t power_extremum_250mw : 10; // [9..0] Max (give back = 0) or Min (give back = 1) operating power in 250mW unit
uint32_t power_operate_250mw : 10; // [19..10] Operating power in 250mW unit
uint32_t reserved : 2; // [21..20] Reserved
uint32_t epr_mode_capable : 1; // [22] EPR mode capable
uint32_t unchunked_ext_msg_support : 1; // [23] UnChunked Extended Message Supported
uint32_t no_usb_suspend : 1; // [24] No USB Suspend
uint32_t usb_comm_capable : 1; // [25] USB Communications Capable
uint32_t capability_mismatch : 1; // [26] Capability Mismatch
uint32_t give_back_flag : 1; // [27] GiveBack Flag: 0 = Max, 1 = Min
uint32_t object_position : 4; // [31..28] Object Position
} pd_rdo_battery_t;
TU_VERIFY_STATIC(sizeof(pd_rdo_battery_t) == 4, "Invalid size");
//--------------------------------------------------------------------+
// Application API
//--------------------------------------------------------------------+