blob: b3be338d64d6e61f1259a42292de880ac0ffa1cf [file] [log] [blame]
/* Copyright 2014 The Chromium OS Authors. All rights reserved.
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "atomic.h"
#include "battery.h"
#include "battery_smart.h"
#include "board.h"
#include "charge_manager.h"
#include "charge_state.h"
#include "chipset.h"
#include "common.h"
#include "console.h"
#include "ec_commands.h"
#include "gpio.h"
#include "hooks.h"
#include "host_command.h"
#include "printf.h"
#include "registers.h"
#include "system.h"
#include "task.h"
#include "tcpci.h"
#include "tcpm.h"
#include "timer.h"
#include "util.h"
#include "usb_charge.h"
#include "usb_common.h"
#include "usb_mux.h"
#include "usb_pd.h"
#include "usb_pd_tcpm.h"
#include "usb_pd_tcpc.h"
#include "usbc_ppc.h"
#include "version.h"
#include "vboot.h"
/* Flags to clear on a disconnect */
#define PD_FLAGS_RESET_ON_DISCONNECT_MASK (PD_FLAGS_PARTNER_DR_POWER | \
PD_FLAGS_PARTNER_DR_DATA | \
PD_FLAGS_CHECK_IDENTITY | \
PD_FLAGS_SNK_CAP_RECVD | \
PD_FLAGS_TCPC_DRP_TOGGLE | \
PD_FLAGS_EXPLICIT_CONTRACT | \
PD_FLAGS_PREVIOUS_PD_CONN | \
PD_FLAGS_CHECK_PR_ROLE | \
PD_FLAGS_CHECK_DR_ROLE | \
PD_FLAGS_PARTNER_UNCONSTR | \
PD_FLAGS_VCONN_ON | \
PD_FLAGS_TRY_SRC | \
PD_FLAGS_PARTNER_USB_COMM | \
PD_FLAGS_UPDATE_SRC_CAPS | \
PD_FLAGS_TS_DTS_PARTNER | \
PD_FLAGS_SNK_WAITING_BATT | \
PD_FLAGS_CHECK_VCONN_STATE)
#ifdef CONFIG_COMMON_RUNTIME
#define CPRINTF(format, args...) cprintf(CC_USBPD, format, ## args)
#define CPRINTS(format, args...) cprints(CC_USBPD, format, ## args)
static int tcpc_prints(const char *string, int port)
{
return CPRINTS("TCPC p%d %s", port, string);
}
BUILD_ASSERT(CONFIG_USB_PD_PORT_MAX_COUNT <= EC_USB_PD_MAX_PORTS);
/*
* Debug log level - higher number == more log
* Level 0: Log state transitions
* Level 1: Level 0, plus state name
* Level 2: Level 1, plus packet info
* Level 3: Level 2, plus ping packet and packet dump on error
*
* Note that higher log level causes timing changes and thus may affect
* performance.
*
* Can be limited to constant debug_level by CONFIG_USB_PD_DEBUG_LEVEL
*/
#ifdef CONFIG_USB_PD_DEBUG_LEVEL
static const int debug_level = CONFIG_USB_PD_DEBUG_LEVEL;
#else
static int debug_level;
#endif
/*
* PD communication enabled flag. When false, PD state machine still
* detects source/sink connection and disconnection, and will still
* provide VBUS, but never sends any PD communication.
*/
static uint8_t pd_comm_enabled[CONFIG_USB_PD_PORT_MAX_COUNT];
#else /* CONFIG_COMMON_RUNTIME */
#define CPRINTF(format, args...)
#define CPRINTS(format, args...)
#define tcpc_prints(string, port)
static const int debug_level;
#endif
#ifdef CONFIG_USB_PD_DUAL_ROLE
#define DUAL_ROLE_IF_ELSE(port, sink_clause, src_clause) \
(pd[port].power_role == PD_ROLE_SINK ? (sink_clause) : (src_clause))
#else
#define DUAL_ROLE_IF_ELSE(port, sink_clause, src_clause) (src_clause)
#endif
#define READY_RETURN_STATE(port) DUAL_ROLE_IF_ELSE(port, PD_STATE_SNK_READY, \
PD_STATE_SRC_READY)
/* Type C supply voltage (mV) */
#define TYPE_C_VOLTAGE 5000 /* mV */
/* PD counter definitions */
#define PD_MESSAGE_ID_COUNT 7
#define PD_HARD_RESET_COUNT 2
#define PD_CAPS_COUNT 50
#define PD_SNK_CAP_RETRIES 3
/*
* The time that we allow the port partner to send any messages after an
* explicit contract is established. 200ms was chosen somewhat arbitrarily as
* it should be long enough for sources to decide to send a message if they were
* going to, but not so long that a "low power charger connected" notification
* would be shown in the chrome OS UI.
*/
#define SNK_READY_HOLD_OFF_US (200 * MSEC)
/*
* For the same purpose as SNK_READY_HOLD_OFF_US, but this delay can be longer
* since the concern over "low power charger" is not relevant when connected as
* a source and the additional delay avoids a race condition where the partner
* port sends a power role swap request close to when the VDM discover identity
* message gets sent.
*/
#define SRC_READY_HOLD_OFF_US (400 * MSEC)
enum ams_seq {
AMS_START,
AMS_RESPONSE,
};
enum vdm_states {
VDM_STATE_ERR_BUSY = -3,
VDM_STATE_ERR_SEND = -2,
VDM_STATE_ERR_TMOUT = -1,
VDM_STATE_DONE = 0,
/* Anything >0 represents an active state */
VDM_STATE_READY = 1,
VDM_STATE_BUSY = 2,
VDM_STATE_WAIT_RSP_BUSY = 3,
};
#ifdef CONFIG_USB_PD_DUAL_ROLE
/* Port dual-role state */
enum pd_dual_role_states drp_state[CONFIG_USB_PD_PORT_MAX_COUNT] = {
[0 ... (CONFIG_USB_PD_PORT_MAX_COUNT - 1)] =
CONFIG_USB_PD_INITIAL_DRP_STATE};
/* Enable variable for Try.SRC states */
static bool pd_try_src_enable;
#endif
#ifdef CONFIG_USB_PD_REV30
/*
* The spec. revision is the argument for this macro.
* Rev 0 (PD 1.0) - return PD_CTRL_REJECT
* Rev 1 (PD 2.0) - return PD_CTRL_REJECT
* Rev 2 (PD 3.0) - return PD_CTRL_NOT_SUPPORTED
*
* Note: this should only be used in locations where responding on a lower
* revision with a Reject is valid (ex. a source refusing a PR_Swap). For
* other uses of Not_Supported, use PD_CTRL_NOT_SUPPORTED directly.
*/
#define NOT_SUPPORTED(r) (r < 2 ? PD_CTRL_REJECT : PD_CTRL_NOT_SUPPORTED)
#else
#define NOT_SUPPORTED(r) PD_CTRL_REJECT
#endif
#ifdef CONFIG_USB_PD_REV30
/*
* The spec. revision is used to index into this array.
* Rev 0 (VDO 1.0) - return VDM_VER10
* Rev 1 (VDO 1.0) - return VDM_VER10
* Rev 2 (VDO 2.0) - return VDM_VER20
*/
static const uint8_t vdo_ver[] = {
VDM_VER10, VDM_VER10, VDM_VER20};
#define VDO_VER(v) vdo_ver[v]
#else
#define VDO_VER(v) VDM_VER10
#endif
static struct pd_protocol {
/* current port power role (SOURCE or SINK) */
enum pd_power_role power_role;
/* current port data role (DFP or UFP) */
enum pd_data_role data_role;
/* 3-bit rolling message ID counter */
uint8_t msg_id;
/* port polarity */
enum tcpc_cc_polarity polarity;
/* PD state for port */
enum pd_states task_state;
/* PD state when we run state handler the last time */
enum pd_states last_state;
/* bool: request state change to SUSPENDED */
uint8_t req_suspend_state;
/* The state to go to after timeout */
enum pd_states timeout_state;
/* port flags, see PD_FLAGS_* */
uint32_t flags;
/* Timeout for the current state. Set to 0 for no timeout. */
uint64_t timeout;
/* Time for source recovery after hard reset */
uint64_t src_recover;
/* Time for CC debounce end */
uint64_t cc_debounce;
/* The cc state */
enum pd_cc_states cc_state;
/* status of last transmit */
uint8_t tx_status;
/* Last received */
uint8_t last_msg_id;
/* last requested voltage PDO index */
int requested_idx;
#ifdef CONFIG_USB_PD_DUAL_ROLE
/* Current limit / voltage based on the last request message */
uint32_t curr_limit;
uint32_t supply_voltage;
/* Signal charging update that affects the port */
int new_power_request;
/* Store previously requested voltage request */
int prev_request_mv;
/* Time for Try.SRC states */
uint64_t try_src_marker;
uint64_t try_timeout;
#endif
#ifdef CONFIG_USB_PD_TCPC_LOW_POWER
/* Time to enter low power mode */
uint64_t low_power_time;
/* Time to debounce exit low power mode */
uint64_t low_power_exit_time;
/* Tasks to notify after TCPC has been reset */
int tasks_waiting_on_reset;
/* Tasks preventing TCPC from entering low power mode */
int tasks_preventing_lpm;
#endif
#ifdef CONFIG_USB_PD_DUAL_ROLE_AUTO_TOGGLE
/*
* Timer for handling TOGGLE_OFF/FORCE_SINK mode when auto-toggle
* enabled. See drp_auto_toggle_next_state() for details.
*/
uint64_t drp_sink_time;
#endif
/*
* Time to ignore Vbus absence due to external IC debounce detection
* logic immediately after a power role swap.
*/
uint64_t vbus_debounce_time;
/* PD state for Vendor Defined Messages */
enum vdm_states vdm_state;
/* Timeout for the current vdm state. Set to 0 for no timeout. */
timestamp_t vdm_timeout;
/* next Vendor Defined Message to send */
uint32_t vdo_data[VDO_MAX_SIZE];
/* type of transmit message (SOP/SOP'/SOP'') */
enum tcpm_transmit_type xmit_type;
uint8_t vdo_count;
/* VDO to retry if UFP responder replied busy. */
uint32_t vdo_retry;
/* Attached ChromeOS device id, RW hash, and current RO / RW image */
uint16_t dev_id;
uint32_t dev_rw_hash[PD_RW_HASH_SIZE/4];
enum ec_image current_image;
#ifdef CONFIG_USB_PD_REV30
/* protocol revision */
uint8_t rev;
#endif
/*
* Some port partners are really chatty after an explicit contract is
* established. Therefore, we allow this time for the port partner to
* send any messages in order to avoid a collision of sending messages
* of our own.
*/
uint64_t ready_state_holdoff_timer;
/*
* PD 2.0 spec, section 6.5.11.1
* When we can give up on a HARD_RESET transmission.
*/
uint64_t hard_reset_complete_timer;
} pd[CONFIG_USB_PD_PORT_MAX_COUNT];
#ifdef CONFIG_USB_PD_TCPMV1_DEBUG
static const char * const pd_state_names[] = {
"DISABLED", "SUSPENDED",
"SNK_DISCONNECTED", "SNK_DISCONNECTED_DEBOUNCE",
"SNK_HARD_RESET_RECOVER",
"SNK_DISCOVERY", "SNK_REQUESTED", "SNK_TRANSITION", "SNK_READY",
"SNK_SWAP_INIT", "SNK_SWAP_SNK_DISABLE",
"SNK_SWAP_SRC_DISABLE", "SNK_SWAP_STANDBY", "SNK_SWAP_COMPLETE",
"SRC_DISCONNECTED", "SRC_DISCONNECTED_DEBOUNCE",
"SRC_HARD_RESET_RECOVER", "SRC_STARTUP",
"SRC_DISCOVERY", "SRC_NEGOCIATE", "SRC_ACCEPTED", "SRC_POWERED",
"SRC_TRANSITION", "SRC_READY", "SRC_GET_SNK_CAP", "DR_SWAP",
"SRC_SWAP_INIT", "SRC_SWAP_SNK_DISABLE", "SRC_SWAP_SRC_DISABLE",
"SRC_SWAP_STANDBY",
"VCONN_SWAP_SEND", "VCONN_SWAP_INIT", "VCONN_SWAP_READY",
"SOFT_RESET", "HARD_RESET_SEND", "HARD_RESET_EXECUTE", "BIST_RX",
"BIST_TX",
"DRP_AUTO_TOGGLE",
"ENTER_USB",
};
BUILD_ASSERT(ARRAY_SIZE(pd_state_names) == PD_STATE_COUNT);
#endif
int pd_comm_is_enabled(int port)
{
#ifdef CONFIG_COMMON_RUNTIME
return pd_comm_enabled[port];
#else
return 1;
#endif
}
bool pd_alt_mode_capable(int port)
{
/*
* PD is alternate mode capable only if PD communication is enabled and
* the port is not suspended.
*/
return pd_comm_is_enabled(port) &&
!(pd[port].task_state == PD_STATE_SUSPENDED);
}
static inline void set_state_timeout(int port,
uint64_t timeout,
enum pd_states timeout_state)
{
pd[port].timeout = timeout;
pd[port].timeout_state = timeout_state;
}
#ifdef CONFIG_USB_PD_REV30
int pd_get_rev(int port)
{
return pd[port].rev;
}
int pd_get_vdo_ver(int port, enum tcpm_transmit_type type)
{
if (type == TCPC_TX_SOP_PRIME)
return get_usb_pd_cable_revision(port);
return vdo_ver[pd[port].rev];
}
#else
int pd_get_rev(int port)
{
return PD_REV20;
}
int pd_get_vdo_ver(int port, enum tcpm_transmit_type type)
{
return VDM_VER10;
}
#endif
/* Return flag for pd state is connected */
int pd_is_connected(int port)
{
if (pd[port].task_state == PD_STATE_DISABLED)
return 0;
#ifdef CONFIG_USB_PD_DUAL_ROLE_AUTO_TOGGLE
if (pd[port].task_state == PD_STATE_DRP_AUTO_TOGGLE)
return 0;
#endif
return DUAL_ROLE_IF_ELSE(port,
/* sink */
pd[port].task_state != PD_STATE_SNK_DISCONNECTED &&
pd[port].task_state != PD_STATE_SNK_DISCONNECTED_DEBOUNCE,
/* source */
pd[port].task_state != PD_STATE_SRC_DISCONNECTED &&
pd[port].task_state != PD_STATE_SRC_DISCONNECTED_DEBOUNCE);
}
/*
* Return true if partner port is a DTS or TS capable of entering debug
* mode (eg. is presenting Rp/Rp or Rd/Rd).
*/
int pd_ts_dts_plugged(int port)
{
return pd[port].flags & PD_FLAGS_TS_DTS_PARTNER;
}
/* Return true if partner port is known to be PD capable. */
bool pd_capable(int port)
{
return !!(pd[port].flags & PD_FLAGS_PREVIOUS_PD_CONN);
}
/*
* Return true if partner port is capable of communication over USB data
* lines.
*/
bool pd_get_partner_usb_comm_capable(int port)
{
return !!(pd[port].flags & PD_FLAGS_PARTNER_USB_COMM);
}
#ifdef CONFIG_USB_PD_DUAL_ROLE
void pd_vbus_low(int port)
{
pd[port].flags &= ~PD_FLAGS_VBUS_NEVER_LOW;
}
#endif
#ifdef CONFIG_USBC_VCONN
static void set_vconn(int port, int enable)
{
/*
* We always need to tell the TCPC to enable Vconn first, otherwise some
* TCPCs get confused when a PPC sets secondary CC line to 5V and TCPC
* immediately disconnect. If there is a PPC, both devices will
* potentially source Vconn, but that should be okay since Vconn has
* "make before break" electrical requirements when swapping anyway.
*/
tcpm_set_vconn(port, enable);
#ifdef CONFIG_USBC_PPC_VCONN
ppc_set_vconn(port, enable);
#endif
}
#endif /* defined(CONFIG_USBC_VCONN) */
#ifdef CONFIG_USB_PD_REV30
/* Note: rp should be set to either SINK_TX_OK or SINK_TX_NG */
static void sink_can_xmit(int port, int rp)
{
tcpm_select_rp_value(port, rp);
tcpm_set_cc(port, TYPEC_CC_RP);
/* We must wait tSinkTx before sending a message */
if (rp == SINK_TX_NG)
usleep(PD_T_SINK_TX);
}
#endif
#ifdef CONFIG_USB_PD_TCPC_LOW_POWER
/* 10 ms is enough time for any TCPC transaction to complete. */
#define PD_LPM_DEBOUNCE_US (10 * MSEC)
/* 25 ms on LPM exit to ensure TCPC is settled */
#define PD_LPM_EXIT_DEBOUNCE_US (25 * MSEC)
/* This is only called from the PD tasks that owns the port. */
static void handle_device_access(int port)
{
/* This should only be called from the PD task */
assert(port == TASK_ID_TO_PD_PORT(task_get_current()));
pd[port].low_power_time = get_time().val + PD_LPM_DEBOUNCE_US;
if (pd[port].flags & PD_FLAGS_LPM_ENGAGED) {
tcpc_prints("Exit Low Power Mode", port);
pd[port].flags &= ~(PD_FLAGS_LPM_ENGAGED |
PD_FLAGS_LPM_REQUESTED);
pd[port].flags |= PD_FLAGS_LPM_EXIT;
pd[port].low_power_exit_time = get_time().val
+ PD_LPM_EXIT_DEBOUNCE_US;
/*
* Wake to ensure we make another pass through the main task
* loop after clearing the flags.
*/
task_wake(PD_PORT_TO_TASK_ID(port));
}
}
static int pd_device_in_low_power(int port)
{
/*
* If we are actively waking the device up in the PD task, do not
* let TCPC operation wait or retry because we are in low power mode.
*/
if (port == TASK_ID_TO_PD_PORT(task_get_current()) &&
(pd[port].flags & PD_FLAGS_LPM_TRANSITION))
return 0;
return pd[port].flags & PD_FLAGS_LPM_ENGAGED;
}
static int reset_device_and_notify(int port)
{
int rv;
int task, waiting_tasks;
/* This should only be called from the PD task */
assert(port == TASK_ID_TO_PD_PORT(task_get_current()));
pd[port].flags |= PD_FLAGS_LPM_TRANSITION;
rv = tcpm_init(port);
pd[port].flags &= ~PD_FLAGS_LPM_TRANSITION;
if (rv == EC_SUCCESS)
tcpc_prints("init ready", port);
else
tcpc_prints("init failed!", port);
/*
* Before getting the other tasks that are waiting, clear the reset
* event from this PD task to prevent multiple reset/init events
* occurring.
*
* The double reset event happens when the higher priority PD interrupt
* task gets an interrupt during the above tcpm_init function. When that
* occurs, the higher priority task waits correctly for us to finish
* waking the TCPC, but it has also set PD_EVENT_TCPC_RESET again, which
* would result in a second, unnecessary init.
*/
atomic_clear(task_get_event_bitmap(task_get_current()),
PD_EVENT_TCPC_RESET);
waiting_tasks = atomic_read_clear(&pd[port].tasks_waiting_on_reset);
/*
* Now that we are done waking up the device, handle device access
* manually because we ignored it while waking up device.
*/
handle_device_access(port);
/* Clear SW LPM state; the state machine will set it again if needed */
pd[port].flags &= ~PD_FLAGS_LPM_REQUESTED;
/* Wake up all waiting tasks. */
while (waiting_tasks) {
task = __fls(waiting_tasks);
waiting_tasks &= ~BIT(task);
task_set_event(task, TASK_EVENT_PD_AWAKE, 0);
}
return rv;
}
static void pd_wait_for_wakeup(int port)
{
if (port == TASK_ID_TO_PD_PORT(task_get_current())) {
/* If we are in the PD task, we can directly reset */
reset_device_and_notify(port);
} else {
/* Otherwise, we need to wait for the TCPC reset to complete */
atomic_or(&pd[port].tasks_waiting_on_reset,
1 << task_get_current());
/*
* NOTE: We could be sending the PD task the reset event while
* it is already processing the reset event. If that occurs,
* then we will reset the TCPC multiple times, which is
* undesirable but most likely benign. Empirically, this doesn't
* happen much, but it if starts occurring, we can add a guard
* to prevent/reduce it.
*/
task_set_event(PD_PORT_TO_TASK_ID(port),
PD_EVENT_TCPC_RESET, 0);
task_wait_event_mask(TASK_EVENT_PD_AWAKE, -1);
}
}
void pd_wait_exit_low_power(int port)
{
if (pd_device_in_low_power(port))
pd_wait_for_wakeup(port);
}
/*
* This can be called from any task. If we are in the PD task, we can handle
* immediately. Otherwise, we need to notify the PD task via event.
*/
void pd_device_accessed(int port)
{
if (port == TASK_ID_TO_PD_PORT(task_get_current())) {
/* Ignore any access to device while it is waking up */
if (pd[port].flags & PD_FLAGS_LPM_TRANSITION)
return;
handle_device_access(port);
} else {
task_set_event(PD_PORT_TO_TASK_ID(port),
PD_EVENT_DEVICE_ACCESSED, 0);
}
}
void pd_prevent_low_power_mode(int port, int prevent)
{
const int current_task_mask = (1 << task_get_current());
if (prevent)
atomic_or(&pd[port].tasks_preventing_lpm, current_task_mask);
else
atomic_clear(&pd[port].tasks_preventing_lpm, current_task_mask);
}
/* This is only called from the PD tasks that owns the port. */
static void exit_low_power_mode(int port)
{
if (pd[port].flags & PD_FLAGS_LPM_ENGAGED)
reset_device_and_notify(port);
else
pd[port].flags &= ~PD_FLAGS_LPM_REQUESTED;
}
#else /* !CONFIG_USB_PD_TCPC_LOW_POWER */
/* We don't need to notify anyone if low power mode isn't involved. */
static int reset_device_and_notify(int port)
{
const int rv = tcpm_init(port);
if (rv == EC_SUCCESS)
tcpc_prints("init ready", port);
else
tcpc_prints("init failed!", port);
return rv;
}
#endif /* CONFIG_USB_PD_TCPC_LOW_POWER */
/**
* Invalidate last message received at the port when the port gets disconnected
* or reset(soft/hard). This is used to identify and handle the duplicate
* messages.
*
* @param port USB PD TCPC port number
*/
static void invalidate_last_message_id(int port)
{
pd[port].last_msg_id = INVALID_MSG_ID_COUNTER;
}
static bool consume_sop_repeat_message(int port, uint8_t msg_id)
{
if (pd[port].last_msg_id != msg_id) {
pd[port].last_msg_id = msg_id;
return false;
}
CPRINTF("C%d Repeat msg_id %d\n", port, msg_id);
return true;
}
/**
* Identify and drop any duplicate messages received at the port.
*
* @param port USB PD TCPC port number
* @param msg_header Message Header containing the RX message ID
* @return True if the received message is a duplicate one, False otherwise.
*
* From USB PD version 1.3 section 6.7.1, the port which communicates
* using SOP* Packets Shall maintain copies of the last MessageID for
* each type of SOP* it uses.
*/
static bool consume_repeat_message(int port, uint32_t msg_header)
{
uint8_t msg_id = PD_HEADER_ID(msg_header);
enum tcpm_transmit_type sop = PD_HEADER_GET_SOP(msg_header);
/* If repeat message ignore, except softreset control request. */
if (PD_HEADER_TYPE(msg_header) == PD_CTRL_SOFT_RESET &&
PD_HEADER_CNT(msg_header) == 0) {
return false;
} else if (sop == TCPC_TX_SOP_PRIME) {
return consume_sop_prime_repeat_msg(port, msg_id);
} else if (sop == TCPC_TX_SOP_PRIME_PRIME) {
return consume_sop_prime_prime_repeat_msg(port, msg_id);
} else {
return consume_sop_repeat_message(port, msg_id);
}
}
/**
* Returns true if the port is currently in the try src state.
*/
static inline int is_try_src(int port)
{
return pd[port].flags & PD_FLAGS_TRY_SRC;
}
static inline void set_state(int port, enum pd_states next_state)
{
enum pd_states last_state = pd[port].task_state;
#if defined(CONFIG_LOW_POWER_IDLE) && !defined(CONFIG_USB_PD_TCPC_ON_CHIP)
int i;
#endif
int not_auto_toggling = 1;
set_state_timeout(port, 0, 0);
pd[port].task_state = next_state;
if (last_state == next_state)
return;
#if defined(CONFIG_USBC_PPC) && defined(CONFIG_USB_PD_DUAL_ROLE_AUTO_TOGGLE)
/* If we're entering DRP_AUTO_TOGGLE, there is no sink connected. */
if (next_state == PD_STATE_DRP_AUTO_TOGGLE) {
ppc_sink_is_connected(port, 0);
/*
* Clear the overcurrent event counter
* since we've detected a disconnect.
*/
ppc_clear_oc_event_counter(port);
/* Disable Auto Discharge Disconnect */
tcpm_enable_auto_discharge_disconnect(port, 0);
}
#endif /* CONFIG_USBC_PPC && CONFIG_USB_PD_DUAL_ROLE_AUTO_TOGGLE */
#ifdef CONFIG_USB_PD_DUAL_ROLE
#ifdef CONFIG_USB_PD_DUAL_ROLE_AUTO_TOGGLE
if (last_state != PD_STATE_DRP_AUTO_TOGGLE)
/* Clear flag to allow DRP auto toggle when possible */
pd[port].flags &= ~PD_FLAGS_TCPC_DRP_TOGGLE;
else
/* This is an auto toggle instead of disconnect */
not_auto_toggling = 0;
#endif
/* Ignore dual-role toggling between sink and source */
if ((last_state == PD_STATE_SNK_DISCONNECTED &&
next_state == PD_STATE_SRC_DISCONNECTED) ||
(last_state == PD_STATE_SRC_DISCONNECTED &&
next_state == PD_STATE_SNK_DISCONNECTED))
return;
if (next_state == PD_STATE_SRC_DISCONNECTED ||
next_state == PD_STATE_SNK_DISCONNECTED) {
#ifdef CONFIG_USBC_PPC
enum tcpc_cc_voltage_status cc1, cc2;
tcpm_get_cc(port, &cc1, &cc2);
/*
* Neither a debug accessory nor UFP attached.
* Tell the PPC module that there is no sink connected.
*/
if (!cc_is_at_least_one_rd(cc1, cc2)) {
ppc_sink_is_connected(port, 0);
/*
* Clear the overcurrent event counter
* since we've detected a disconnect.
*/
ppc_clear_oc_event_counter(port);
}
#endif /* CONFIG_USBC_PPC */
/* Clear the holdoff timer since the port is disconnected. */
pd[port].ready_state_holdoff_timer = 0;
/*
* We should not clear any flags when transitioning back to the
* disconnected state from the debounce state as the two states
* here are really the same states in the state diagram.
*/
if (last_state != PD_STATE_SNK_DISCONNECTED_DEBOUNCE &&
last_state != PD_STATE_SRC_DISCONNECTED_DEBOUNCE) {
pd[port].flags &= ~PD_FLAGS_RESET_ON_DISCONNECT_MASK;
reset_pd_cable(port);
}
/* Clear the input current limit */
pd_set_input_current_limit(port, 0, 0);
#ifdef CONFIG_CHARGE_MANAGER
typec_set_input_current_limit(port, 0, 0);
charge_manager_set_ceil(port,
CEIL_REQUESTOR_PD,
CHARGE_CEIL_NONE);
#endif
#ifdef CONFIG_BC12_DETECT_DATA_ROLE_TRIGGER
/*
* When data role set events are used to enable BC1.2, then CC
* detach events are used to notify BC1.2 that it can be powered
* down.
*/
task_set_event(USB_CHG_PORT_TO_TASK_ID(port),
USB_CHG_EVENT_CC_OPEN, 0);
#endif /* CONFIG_BC12_DETECT_DATA_ROLE_TRIGGER */
#ifdef CONFIG_USBC_VCONN
set_vconn(port, 0);
#endif /* defined(CONFIG_USBC_VCONN) */
pd_update_saved_port_flags(port, PD_BBRMFLG_EXPLICIT_CONTRACT,
0);
#else /* CONFIG_USB_PD_DUAL_ROLE */
if (next_state == PD_STATE_SRC_DISCONNECTED) {
#ifdef CONFIG_USBC_VCONN
set_vconn(port, 0);
#endif /* CONFIG_USBC_VCONN */
#endif /* !CONFIG_USB_PD_DUAL_ROLE */
/* If we are source, make sure VBUS is off and restore RP */
if (pd[port].power_role == PD_ROLE_SOURCE) {
/* Restore non-active ports to CONFIG_USB_PD_PULLUP */
pd_power_supply_reset(port);
tcpm_set_cc(port, TYPEC_CC_RP);
}
#ifdef CONFIG_USB_PD_REV30
/* Adjust rev to highest level*/
pd[port].rev = PD_REV30;
#endif
pd[port].dev_id = 0;
#ifdef CONFIG_CHARGE_MANAGER
charge_manager_update_dualrole(port, CAP_UNKNOWN);
#endif
#ifdef CONFIG_USB_PD_ALT_MODE_DFP
pd_dfp_exit_mode(port, TCPC_TX_SOP, 0, 0);
#endif
/*
* Indicate that the port is disconnected by setting role to
* DFP as SoCs have special signals when they are the UFP ports
* (e.g. OTG signals)
*/
pd_execute_data_swap(port, PD_ROLE_DFP);
#ifdef CONFIG_USBC_SS_MUX
usb_mux_set(port, USB_PD_MUX_NONE, USB_SWITCH_DISCONNECT,
pd[port].polarity);
#endif
/* Disable TCPC RX */
tcpm_set_rx_enable(port, 0);
/* Invalidate message IDs. */
invalidate_last_message_id(port);
if (not_auto_toggling)
/* Disable Auto Discharge Disconnect */
tcpm_enable_auto_discharge_disconnect(port, 0);
/* detect USB PD cc disconnect */
if (IS_ENABLED(CONFIG_COMMON_RUNTIME))
hook_notify(HOOK_USB_PD_DISCONNECT);
}
#ifdef CONFIG_USB_PD_REV30
/* Upon entering SRC_READY, it is safe for the sink to transmit */
if (next_state == PD_STATE_SRC_READY) {
if (pd[port].rev == PD_REV30 &&
pd[port].flags & PD_FLAGS_EXPLICIT_CONTRACT)
sink_can_xmit(port, SINK_TX_OK);
}
#endif
#if defined(CONFIG_LOW_POWER_IDLE) && !defined(CONFIG_USB_PD_TCPC_ON_CHIP)
/* If a PD device is attached then disable deep sleep */
for (i = 0; i < board_get_usb_pd_port_count(); i++) {
if (pd_capable(i))
break;
}
if (i == board_get_usb_pd_port_count())
enable_sleep(SLEEP_MASK_USB_PD);
else
disable_sleep(SLEEP_MASK_USB_PD);
#endif
#ifdef CONFIG_USB_PD_TCPMV1_DEBUG
if (debug_level > 0)
CPRINTF("C%d st%d %s\n", port, next_state,
pd_state_names[next_state]);
else
#endif
CPRINTF("C%d st%d\n", port, next_state);
}
/* increment message ID counter */
static void inc_id(int port)
{
pd[port].msg_id = (pd[port].msg_id + 1) & PD_MESSAGE_ID_COUNT;
}
void pd_transmit_complete(int port, int status)
{
if (status == TCPC_TX_COMPLETE_SUCCESS)
inc_id(port);
pd[port].tx_status = status;
task_set_event(PD_PORT_TO_TASK_ID(port), PD_EVENT_TX, 0);
}
static int pd_transmit(int port, enum tcpm_transmit_type type,
uint16_t header, const uint32_t *data, enum ams_seq ams)
{
int evt;
int res;
#ifdef CONFIG_USB_PD_REV30
int sink_ng = 0;
#endif
/* If comms are disabled, do not transmit, return error */
if (!pd_comm_is_enabled(port))
return -1;
/* Don't try to transmit anything until we have processed
* all RX messages.
*/
if (tcpm_has_pending_message(port))
return -1;
#ifdef CONFIG_USB_PD_REV30
/* Source-coordinated collision avoidance */
/*
* USB PD Rev 3.0, Version 2.0: Section 2.7.3.2
* Collision Avoidance - Protocol Layer
*
* In order to avoid message collisions due to asynchronous Messaging
* sent from the Sink, the Source sets Rp to SinkTxOk (3A) to indicate
* to the Sink that it is ok to initiate an AMS. When the Source wishes
* to initiate an AMS, it sets Rp to SinkTxNG (1.5A).
* When the Sink detects that Rp is set to SinkTxOk, it May initiate an
* AMS. When the Sink detects that Rp is set to SinkTxNG it Shall Not
* initiate an AMS and Shall only send Messages that are part of an AMS
* the Source has initiated.
* Note that this restriction applies to SOP* AMS’s i.e. for both Port
* to Port and Port to Cable Plug communications.
*
* This starts after an Explicit Contract is in place (see section 2.5.2
* SOP* Collision Avoidance).
*
* Note: a Sink can still send Hard Reset signaling at any time.
*/
if ((pd[port].rev == PD_REV30) && ams == AMS_START &&
(pd[port].flags & PD_FLAGS_EXPLICIT_CONTRACT)) {
if (pd[port].power_role == PD_ROLE_SOURCE) {
/*
* Inform Sink that it can't transmit. If a sink
* transmission is in progress and a collision occurs,
* a reset is generated. This should be rare because
* all extended messages are chunked. This effectively
* defaults to PD REV 2.0 collision avoidance.
*/
sink_can_xmit(port, SINK_TX_NG);
sink_ng = 1;
} else if (type != TCPC_TX_HARD_RESET) {
enum tcpc_cc_voltage_status cc1, cc2;
tcpm_get_cc(port, &cc1, &cc2);
if (cc1 == TYPEC_CC_VOLT_RP_1_5 ||
cc2 == TYPEC_CC_VOLT_RP_1_5) {
/* Sink can't transmit now. */
/* Return failure, pd_task can retry later */
return -1;
}
}
}
#endif
tcpm_transmit(port, type, header, data);
/* Wait until TX is complete */
evt = task_wait_event_mask(PD_EVENT_TX, PD_T_TCPC_TX_TIMEOUT);
if (evt & TASK_EVENT_TIMER)
return -1;
/* TODO: give different error condition for failed vs discarded */
res = pd[port].tx_status == TCPC_TX_COMPLETE_SUCCESS ? 1 : -1;
#ifdef CONFIG_USB_PD_REV30
/* If the AMS transaction failed to start, reset CC to OK */
if (res < 0 && sink_ng)
sink_can_xmit(port, SINK_TX_OK);
#endif
return res;
}
static void pd_update_roles(int port)
{
/* Notify TCPC of role update */
tcpm_set_msg_header(port, pd[port].power_role, pd[port].data_role);
}
static int send_control(int port, int type)
{
int bit_len;
uint16_t header = PD_HEADER(type, pd[port].power_role,
pd[port].data_role, pd[port].msg_id, 0,
pd_get_rev(port), 0);
/*
* For PD 3.0, collision avoidance logic needs to know if this message
* will begin a new Atomic Message Sequence (AMS)
*/
enum ams_seq ams = ((1 << type) & PD_CTRL_AMS_START_MASK)
? AMS_START : AMS_RESPONSE;
bit_len = pd_transmit(port, TCPC_TX_SOP, header, NULL, ams);
if (debug_level >= 2)
CPRINTF("C%d CTRL[%d]>%d\n", port, type, bit_len);
return bit_len;
}
/*
* Note: Source capabilities may either be in an existing AMS (ex. as a
* response to Get_Source_Cap), or the beginning of an AMS for a power
* negotiation.
*/
static int send_source_cap(int port, enum ams_seq ams)
{
int bit_len;
#if defined(CONFIG_USB_PD_DYNAMIC_SRC_CAP) || \
defined(CONFIG_USB_PD_MAX_SINGLE_SOURCE_CURRENT)
const uint32_t *src_pdo;
const int src_pdo_cnt = charge_manager_get_source_pdo(&src_pdo, port);
#else
const uint32_t *src_pdo = pd_src_pdo;
const int src_pdo_cnt = pd_src_pdo_cnt;
#endif
uint16_t header;
if (src_pdo_cnt == 0)
/* No source capabilities defined, sink only */
header = PD_HEADER(PD_CTRL_REJECT, pd[port].power_role,
pd[port].data_role, pd[port].msg_id, 0,
pd_get_rev(port), 0);
else
header = PD_HEADER(PD_DATA_SOURCE_CAP, pd[port].power_role,
pd[port].data_role, pd[port].msg_id, src_pdo_cnt,
pd_get_rev(port), 0);
bit_len = pd_transmit(port, TCPC_TX_SOP, header, src_pdo, ams);
if (debug_level >= 2)
CPRINTF("C%d srcCAP>%d\n", port, bit_len);
return bit_len;
}
#ifdef CONFIG_USB_PD_REV30
static int send_battery_cap(int port, uint32_t *payload)
{
int bit_len;
uint16_t msg[6] = {0, 0, 0, 0, 0, 0};
uint16_t header = PD_HEADER(PD_EXT_BATTERY_CAP,
pd[port].power_role,
pd[port].data_role,
pd[port].msg_id,
3, /* Number of Data Objects */
pd[port].rev,
1 /* This is an exteded message */
);
/* Set extended header */
msg[0] = PD_EXT_HEADER(0, /* Chunk Number */
0, /* Request Chunk */
9 /* Data Size in bytes */
);
/* Set VID */
msg[1] = USB_VID_GOOGLE;
/* Set PID */
msg[2] = CONFIG_USB_PID;
if (battery_is_present()) {
/*
* We only have one fixed battery,
* so make sure batt cap ref is 0.
*/
if (BATT_CAP_REF(payload[0]) != 0) {
/* Invalid battery reference */
msg[5] = 1;
} else {
uint32_t v;
uint32_t c;
/*
* The Battery Design Capacity field shall return the
* Battery’s design capacity in tenths of Wh. If the
* Battery is Hot Swappable and is not present, the
* Battery Design Capacity field shall be set to 0. If
* the Battery is unable to report its Design Capacity,
* it shall return 0xFFFF
*/
msg[3] = 0xffff;
/*
* The Battery Last Full Charge Capacity field shall
* return the Battery’s last full charge capacity in
* tenths of Wh. If the Battery is Hot Swappable and
* is not present, the Battery Last Full Charge Capacity
* field shall be set to 0. If the Battery is unable to
* report its Design Capacity, the Battery Last Full
* Charge Capacity field shall be set to 0xFFFF.
*/
msg[4] = 0xffff;
if (battery_design_voltage(&v) == 0) {
if (battery_design_capacity(&c) == 0) {
/*
* Wh = (c * v) / 1000000
* 10th of a Wh = Wh * 10
*/
msg[3] = DIV_ROUND_NEAREST((c * v),
100000);
}
if (battery_full_charge_capacity(&c) == 0) {
/*
* Wh = (c * v) / 1000000
* 10th of a Wh = Wh * 10
*/
msg[4] = DIV_ROUND_NEAREST((c * v),
100000);
}
}
}
}
bit_len = pd_transmit(port, TCPC_TX_SOP, header, (uint32_t *)msg,
AMS_RESPONSE);
if (debug_level >= 2)
CPRINTF("C%d batCap>%d\n", port, bit_len);
return bit_len;
}
static int send_battery_status(int port, uint32_t *payload)
{
int bit_len;
uint32_t msg = 0;
uint16_t header = PD_HEADER(PD_DATA_BATTERY_STATUS,
pd[port].power_role,
pd[port].data_role,
pd[port].msg_id,
1, /* Number of Data Objects */
pd[port].rev,
0 /* This is NOT an extended message */
);
if (battery_is_present()) {
/*
* We only have one fixed battery,
* so make sure batt cap ref is 0.
*/
if (BATT_CAP_REF(payload[0]) != 0) {
/* Invalid battery reference */
msg |= BSDO_INVALID;
} else {
uint32_t v;
uint32_t c;
if (battery_design_voltage(&v) != 0 ||
battery_remaining_capacity(&c) != 0) {
msg |= BSDO_CAP(BSDO_CAP_UNKNOWN);
} else {
/*
* Wh = (c * v) / 1000000
* 10th of a Wh = Wh * 10
*/
msg |= BSDO_CAP(DIV_ROUND_NEAREST((c * v),
100000));
}
/* Battery is present */
msg |= BSDO_PRESENT;
/*
* For drivers that are not smart battery compliant,
* battery_status() returns EC_ERROR_UNIMPLEMENTED and
* the battery is assumed to be idle.
*/
if (battery_status(&c) != 0) {
msg |= BSDO_IDLE; /* assume idle */
} else {
if (c & STATUS_FULLY_CHARGED)
/* Fully charged */
msg |= BSDO_IDLE;
else if (c & STATUS_DISCHARGING)
/* Discharging */
msg |= BSDO_DISCHARGING;
/* else battery is charging.*/
}
}
} else {
msg = BSDO_CAP(BSDO_CAP_UNKNOWN);
}
bit_len = pd_transmit(port, TCPC_TX_SOP, header, &msg, AMS_RESPONSE);
if (debug_level >= 2)
CPRINTF("C%d batStat>%d\n", port, bit_len);
return bit_len;
}
#endif
#ifdef CONFIG_USB_PD_DUAL_ROLE
static void send_sink_cap(int port)
{
int bit_len;
uint16_t header = PD_HEADER(PD_DATA_SINK_CAP, pd[port].power_role,
pd[port].data_role, pd[port].msg_id, pd_snk_pdo_cnt,
pd_get_rev(port), 0);
bit_len = pd_transmit(port, TCPC_TX_SOP, header, pd_snk_pdo,
AMS_RESPONSE);
if (debug_level >= 2)
CPRINTF("C%d snkCAP>%d\n", port, bit_len);
}
static int send_request(int port, uint32_t rdo)
{
int bit_len;
uint16_t header = PD_HEADER(PD_DATA_REQUEST, pd[port].power_role,
pd[port].data_role, pd[port].msg_id, 1,
pd_get_rev(port), 0);
/* Note: ams will need to be AMS_START if used for PPS keep alive */
bit_len = pd_transmit(port, TCPC_TX_SOP, header, &rdo, AMS_RESPONSE);
if (debug_level >= 2)
CPRINTF("C%d REQ>%d\n", port, bit_len);
return bit_len;
}
#endif /* CONFIG_USB_PD_DUAL_ROLE */
#ifdef CONFIG_COMMON_RUNTIME
static int send_bist_cmd(int port)
{
/* currently only support sending bist carrier 2 */
uint32_t bdo = BDO(BDO_MODE_CARRIER2, 0);
int bit_len;
uint16_t header = PD_HEADER(PD_DATA_BIST, pd[port].power_role,
pd[port].data_role, pd[port].msg_id, 1,
pd_get_rev(port), 0);
bit_len = pd_transmit(port, TCPC_TX_SOP, header, &bdo, AMS_START);
CPRINTF("C%d BIST>%d\n", port, bit_len);
return bit_len;
}
#endif
static void queue_vdm(int port, uint32_t *header, const uint32_t *data,
int data_cnt, enum tcpm_transmit_type type)
{
pd[port].vdo_count = data_cnt + 1;
pd[port].vdo_data[0] = header[0];
pd[port].xmit_type = type;
memcpy(&pd[port].vdo_data[1], data,
sizeof(uint32_t) * data_cnt);
/* Set ready, pd task will actually send */
pd[port].vdm_state = VDM_STATE_READY;
}
static void handle_vdm_request(int port, int cnt, uint32_t *payload,
uint32_t head)
{
int rlen = 0;
uint32_t *rdata;
enum tcpm_transmit_type rtype = TCPC_TX_SOP;
if (pd[port].vdm_state == VDM_STATE_BUSY) {
/* If UFP responded busy retry after timeout */
if (PD_VDO_CMDT(payload[0]) == CMDT_RSP_BUSY) {
pd[port].vdm_timeout.val = get_time().val +
PD_T_VDM_BUSY;
pd[port].vdm_state = VDM_STATE_WAIT_RSP_BUSY;
pd[port].vdo_retry = (payload[0] & ~VDO_CMDT_MASK) |
CMDT_INIT;
return;
} else {
pd[port].vdm_state = VDM_STATE_DONE;
#ifdef CONFIG_USB_PD_REV30
if (pd[port].rev == PD_REV30 &&
pd[port].power_role == PD_ROLE_SOURCE &&
pd[port].flags & PD_FLAGS_EXPLICIT_CONTRACT)
sink_can_xmit(port, SINK_TX_OK);
#endif
}
}
if (PD_VDO_SVDM(payload[0]))
rlen = pd_svdm(port, cnt, payload, &rdata, head, &rtype);
else
rlen = pd_custom_vdm(port, cnt, payload, &rdata);
if (rlen > 0) {
queue_vdm(port, rdata, &rdata[1], rlen - 1, rtype);
return;
}
if (debug_level >= 2)
CPRINTF("C%d Unhandled VDM VID %04x CMD %04x\n",
port, PD_VDO_VID(payload[0]), payload[0] & 0xFFFF);
}
bool pd_is_disconnected(int port)
{
return pd[port].task_state == PD_STATE_SRC_DISCONNECTED
#ifdef CONFIG_USB_PD_DUAL_ROLE
|| pd[port].task_state == PD_STATE_SNK_DISCONNECTED
#endif
;
}
static void pd_set_data_role(int port, enum pd_data_role role)
{
pd[port].data_role = role;
#ifdef CONFIG_USB_PD_DUAL_ROLE
pd_update_saved_port_flags(port, PD_BBRMFLG_DATA_ROLE, role);
#endif /* defined(CONFIG_USB_PD_DUAL_ROLE) */
pd_execute_data_swap(port, role);
set_usb_mux_with_current_data_role(port);
pd_update_roles(port);
#ifdef CONFIG_BC12_DETECT_DATA_ROLE_TRIGGER
/*
* For BC1.2 detection that is triggered on data role change events
* instead of VBUS changes, need to set an event to wake up the USB_CHG
* task and indicate the current data role.
*/
if (role == PD_ROLE_UFP)
task_set_event(USB_CHG_PORT_TO_TASK_ID(port),
USB_CHG_EVENT_DR_UFP, 0);
else if (role == PD_ROLE_DFP)
task_set_event(USB_CHG_PORT_TO_TASK_ID(port),
USB_CHG_EVENT_DR_DFP, 0);
#endif /* CONFIG_BC12_DETECT_DATA_ROLE_TRIGGER */
}
#ifdef CONFIG_USBC_VCONN
static void pd_set_vconn_role(int port, int role)
{
if (role == PD_ROLE_VCONN_ON)
pd[port].flags |= PD_FLAGS_VCONN_ON;
else
pd[port].flags &= ~PD_FLAGS_VCONN_ON;
#ifdef CONFIG_USB_PD_DUAL_ROLE
pd_update_saved_port_flags(port, PD_BBRMFLG_VCONN_ROLE, role);
#endif
}
#endif /* CONFIG_USBC_VCONN */
void pd_execute_hard_reset(int port)
{
int hard_rst_tx = pd[port].last_state == PD_STATE_HARD_RESET_SEND;
CPRINTF("C%d HARD RST %cX\n", port, hard_rst_tx ? 'T' : 'R');
pd[port].msg_id = 0;
invalidate_last_message_id(port);
tcpm_set_rx_enable(port, 0);
#ifdef CONFIG_USB_PD_ALT_MODE_DFP
pd_dfp_exit_mode(port, TCPC_TX_SOP, 0, 0);
#endif
#ifdef CONFIG_USB_PD_REV30
pd[port].rev = PD_REV30;
#endif
/*
* Fake set last state to hard reset to make sure that the next
* state to run knows that we just did a hard reset.
*/
pd[port].last_state = PD_STATE_HARD_RESET_EXECUTE;
#ifdef CONFIG_USB_PD_DUAL_ROLE
/*
* If we are swapping to a source and have changed to Rp, restore back
* to Rd and turn off vbus to match our power_role.
*/
if (pd[port].task_state == PD_STATE_SNK_SWAP_STANDBY ||
pd[port].task_state == PD_STATE_SNK_SWAP_COMPLETE) {
tcpm_set_cc(port, TYPEC_CC_RD);
pd_power_supply_reset(port);
}
if (pd[port].power_role == PD_ROLE_SINK) {
/* Initial data role for sink is UFP */
pd_set_data_role(port, PD_ROLE_UFP);
/* Clear the input current limit */
pd_set_input_current_limit(port, 0, 0);
#ifdef CONFIG_CHARGE_MANAGER
charge_manager_set_ceil(port,
CEIL_REQUESTOR_PD,
CHARGE_CEIL_NONE);
#endif /* CONFIG_CHARGE_MANAGER */
#ifdef CONFIG_USBC_VCONN
/*
* Sink must turn off Vconn after a hard reset if it was being
* sourced previously
*/
if (pd[port].flags & PD_FLAGS_VCONN_ON) {
set_vconn(port, 0);
pd_set_vconn_role(port, PD_ROLE_VCONN_OFF);
}
#endif
set_state(port, PD_STATE_SNK_HARD_RESET_RECOVER);
return;
} else {
/* Initial data role for source is DFP */
pd_set_data_role(port, PD_ROLE_DFP);
}
#endif /* CONFIG_USB_PD_DUAL_ROLE */
if (!hard_rst_tx)
usleep(PD_T_PS_HARD_RESET);
/* We are a source, cut power */
pd_power_supply_reset(port);
pd[port].src_recover = get_time().val + PD_T_SRC_RECOVER;
#ifdef CONFIG_USBC_VCONN
set_vconn(port, 0);
#endif
set_state(port, PD_STATE_SRC_HARD_RESET_RECOVER);
}
static void execute_soft_reset(int port)
{
invalidate_last_message_id(port);
set_state(port, DUAL_ROLE_IF_ELSE(port, PD_STATE_SNK_DISCOVERY,
PD_STATE_SRC_DISCOVERY));
CPRINTF("C%d Soft Rst\n", port);
}
void pd_soft_reset(void)
{
int i;
for (i = 0; i < board_get_usb_pd_port_count(); ++i)
if (pd_is_connected(i)) {
set_state(i, PD_STATE_SOFT_RESET);
task_wake(PD_PORT_TO_TASK_ID(i));
}
}
#ifdef CONFIG_USB_PD_DUAL_ROLE
/*
* Request desired charge voltage from source.
* Returns EC_SUCCESS on success or non-zero on failure.
*/
static int pd_send_request_msg(int port, int always_send_request)
{
uint32_t rdo, curr_limit, supply_voltage;
int res;
/* Clear new power request */
pd[port].new_power_request = 0;
/* Build and send request RDO */
pd_build_request(0, &rdo, &curr_limit, &supply_voltage, port);
if (!always_send_request) {
/* Don't re-request the same voltage */
if (pd[port].prev_request_mv == supply_voltage)
return EC_SUCCESS;
#ifdef CONFIG_CHARGE_MANAGER
/* Limit current to PD_MIN_MA during transition */
else
charge_manager_force_ceil(port, PD_MIN_MA);
#endif
}
CPRINTF("C%d Req [%d] %dmV %dmA", port, RDO_POS(rdo),
supply_voltage, curr_limit);
if (rdo & RDO_CAP_MISMATCH)
CPRINTF(" Mismatch");
CPRINTF("\n");
pd[port].curr_limit = curr_limit;
pd[port].supply_voltage = supply_voltage;
pd[port].prev_request_mv = supply_voltage;
res = send_request(port, rdo);
if (res < 0)
return res;
set_state(port, PD_STATE_SNK_REQUESTED);
return EC_SUCCESS;
}
#endif
static void pd_update_pdo_flags(int port, uint32_t pdo)
{
#ifdef CONFIG_CHARGE_MANAGER
#ifdef CONFIG_USB_PD_ALT_MODE_DFP
int charge_allowlisted =
(pd[port].power_role == PD_ROLE_SINK &&
pd_charge_from_device(pd_get_identity_vid(port),
pd_get_identity_pid(port)));
#else
const int charge_allowlisted = 0;
#endif
#endif
/* can only parse PDO flags if type is fixed */
if ((pdo & PDO_TYPE_MASK) != PDO_TYPE_FIXED)
return;
#ifdef CONFIG_USB_PD_DUAL_ROLE
if (pdo & PDO_FIXED_DUAL_ROLE)
pd[port].flags |= PD_FLAGS_PARTNER_DR_POWER;
else
pd[port].flags &= ~PD_FLAGS_PARTNER_DR_POWER;
if (pdo & PDO_FIXED_UNCONSTRAINED)
pd[port].flags |= PD_FLAGS_PARTNER_UNCONSTR;
else
pd[port].flags &= ~PD_FLAGS_PARTNER_UNCONSTR;
if (pdo & PDO_FIXED_COMM_CAP)
pd[port].flags |= PD_FLAGS_PARTNER_USB_COMM;
else
pd[port].flags &= ~PD_FLAGS_PARTNER_USB_COMM;
#endif
if (pdo & PDO_FIXED_DATA_SWAP)
pd[port].flags |= PD_FLAGS_PARTNER_DR_DATA;
else
pd[port].flags &= ~PD_FLAGS_PARTNER_DR_DATA;
#ifdef CONFIG_CHARGE_MANAGER
/*
* Treat device as a dedicated charger (meaning we should charge
* from it) if it does not support power swap, or has unconstrained
* power, or if we are a sink and the device identity matches a
* charging allow-list.
*/
if (!(pd[port].flags & PD_FLAGS_PARTNER_DR_POWER) ||
(pd[port].flags & PD_FLAGS_PARTNER_UNCONSTR) ||
charge_allowlisted)
charge_manager_update_dualrole(port, CAP_DEDICATED);
else
charge_manager_update_dualrole(port, CAP_DUALROLE);
#endif
}
static void handle_data_request(int port, uint32_t head,
uint32_t *payload)
{
int type = PD_HEADER_TYPE(head);
int cnt = PD_HEADER_CNT(head);
switch (type) {
#ifdef CONFIG_USB_PD_DUAL_ROLE
case PD_DATA_SOURCE_CAP:
if ((pd[port].task_state == PD_STATE_SNK_DISCOVERY)
|| (pd[port].task_state == PD_STATE_SNK_TRANSITION)
|| (pd[port].task_state == PD_STATE_SNK_REQUESTED)
#ifdef CONFIG_USB_PD_VBUS_DETECT_NONE
|| (pd[port].task_state ==
PD_STATE_SNK_HARD_RESET_RECOVER)
#endif
|| (pd[port].task_state == PD_STATE_SNK_READY)) {
#ifdef CONFIG_USB_PD_REV30
/*
* Only adjust sink rev if source rev is higher.
*/
if (PD_HEADER_REV(head) < pd[port].rev)
pd[port].rev = PD_HEADER_REV(head);
#endif
/* Port partner is now known to be PD capable */
pd[port].flags |= PD_FLAGS_PREVIOUS_PD_CONN;
/* src cap 0 should be fixed PDO */
pd_update_pdo_flags(port, payload[0]);
pd_process_source_cap(port, cnt, payload);
/* Source will resend source cap on failure */
pd_send_request_msg(port, 1);
}
break;
#endif /* CONFIG_USB_PD_DUAL_ROLE */
case PD_DATA_REQUEST:
if ((pd[port].power_role == PD_ROLE_SOURCE) && (cnt == 1)) {
#ifdef CONFIG_USB_PD_REV30
/*
* Adjust the rev level to what the sink supports. If
* they're equal, no harm done.
*/
pd[port].rev = PD_HEADER_REV(head);
#endif
if (!pd_check_requested_voltage(payload[0], port)) {
if (send_control(port, PD_CTRL_ACCEPT) < 0)
/*
* if we fail to send accept, do
* nothing and let sink timeout and
* send hard reset
*/
return;
/* explicit contract is now in place */
pd[port].flags |= PD_FLAGS_EXPLICIT_CONTRACT;
#ifdef CONFIG_USB_PD_DUAL_ROLE
pd_update_saved_port_flags(
port, PD_BBRMFLG_EXPLICIT_CONTRACT, 1);
#endif /* CONFIG_USB_PD_DUAL_ROLE */
pd[port].requested_idx = RDO_POS(payload[0]);
set_state(port, PD_STATE_SRC_ACCEPTED);
return;
}
}
/* the message was incorrect or cannot be satisfied */
send_control(port, PD_CTRL_REJECT);
/* keep last contract in place (whether implicit or explicit) */
set_state(port, PD_STATE_SRC_READY);
break;
case PD_DATA_BIST:
/* If not in READY state, then don't start BIST */
if (DUAL_ROLE_IF_ELSE(port,
pd[port].task_state == PD_STATE_SNK_READY,
pd[port].task_state == PD_STATE_SRC_READY)) {
/* currently only support sending bist carrier mode 2 */
if ((payload[0] >> 28) == 5) {
/* bist data object mode is 2 */
pd_transmit(port, TCPC_TX_BIST_MODE_2, 0,
NULL, AMS_RESPONSE);
/* Set to appropriate port disconnected state */
set_state(port, DUAL_ROLE_IF_ELSE(port,
PD_STATE_SNK_DISCONNECTED,
PD_STATE_SRC_DISCONNECTED));
}
}
break;
case PD_DATA_SINK_CAP:
pd[port].flags |= PD_FLAGS_SNK_CAP_RECVD;
/* snk cap 0 should be fixed PDO */
pd_update_pdo_flags(port, payload[0]);
if (pd[port].task_state == PD_STATE_SRC_GET_SINK_CAP)
set_state(port, PD_STATE_SRC_READY);
break;
#ifdef CONFIG_USB_PD_REV30
case PD_DATA_BATTERY_STATUS:
break;
/* TODO : Add case PD_DATA_RESET for exiting USB4 */
/*
* TODO : Add case PD_DATA_ENTER_USB to accept or reject
* Enter_USB request from port partner.
*/
#endif
case PD_DATA_VENDOR_DEF:
handle_vdm_request(port, cnt, payload, head);
break;
default:
CPRINTF("C%d Unhandled data message type %d\n", port, type);
}
}
#ifdef CONFIG_USB_PD_DUAL_ROLE
void pd_request_power_swap(int port)
{
if (pd[port].task_state == PD_STATE_SRC_READY)
set_state(port, PD_STATE_SRC_SWAP_INIT);
else if (pd[port].task_state == PD_STATE_SNK_READY)
set_state(port, PD_STATE_SNK_SWAP_INIT);
task_wake(PD_PORT_TO_TASK_ID(port));
}
#ifdef CONFIG_USBC_VCONN_SWAP
void pd_request_vconn_swap(int port)
{
if (pd[port].task_state == PD_STATE_SRC_READY ||
pd[port].task_state == PD_STATE_SNK_READY)
set_state(port, PD_STATE_VCONN_SWAP_SEND);
task_wake(PD_PORT_TO_TASK_ID(port));
}
void pd_try_vconn_src(int port)
{
/*
* If we don't currently provide vconn, and we can supply it, send
* a vconn swap request.
*/
if (!(pd[port].flags & PD_FLAGS_VCONN_ON)) {
if (pd_check_vconn_swap(port))
pd_request_vconn_swap(port);
}
}
#endif
#endif /* CONFIG_USB_PD_DUAL_ROLE */
void pd_request_data_swap(int port)
{
if (DUAL_ROLE_IF_ELSE(port,
pd[port].task_state == PD_STATE_SNK_READY,
pd[port].task_state == PD_STATE_SRC_READY))
set_state(port, PD_STATE_DR_SWAP);
task_wake(PD_PORT_TO_TASK_ID(port));
}
static void pd_set_power_role(int port, enum pd_power_role role)
{
pd[port].power_role = role;
#ifdef CONFIG_USB_PD_DUAL_ROLE
pd_update_saved_port_flags(port, PD_BBRMFLG_POWER_ROLE, role);
#endif /* defined(CONFIG_USB_PD_DUAL_ROLE) */
}
static void pd_dr_swap(int port)
{
pd_set_data_role(port, !pd[port].data_role);
pd[port].flags |= PD_FLAGS_CHECK_IDENTITY;
}
static void handle_ctrl_request(int port, uint32_t head,
uint32_t *payload)
{
int type = PD_HEADER_TYPE(head);
int res;
switch (type) {
case PD_CTRL_GOOD_CRC:
/* should not get it */
break;
case PD_CTRL_PING:
/* Nothing else to do */
break;
case PD_CTRL_GET_SOURCE_CAP:
if (pd[port].task_state == PD_STATE_SRC_READY)
set_state(port, PD_STATE_SRC_DISCOVERY);
else {
res = send_source_cap(port, AMS_RESPONSE);
if ((res >= 0) &&
(pd[port].task_state == PD_STATE_SRC_DISCOVERY))
set_state(port, PD_STATE_SRC_NEGOCIATE);
}
break;
case PD_CTRL_GET_SINK_CAP:
#ifdef CONFIG_USB_PD_DUAL_ROLE
send_sink_cap(port);
#else
send_control(port, NOT_SUPPORTED(pd[port].rev));
#endif
break;
#ifdef CONFIG_USB_PD_DUAL_ROLE
case PD_CTRL_GOTO_MIN:
#ifdef CONFIG_USB_PD_GIVE_BACK
if (pd[port].task_state == PD_STATE_SNK_READY) {
/*
* Reduce power consumption now!
*
* The source will restore power to this sink
* by sending a new source cap message at a
* later time.
*/
pd_snk_give_back(port, &pd[port].curr_limit,
&pd[port].supply_voltage);
set_state(port, PD_STATE_SNK_TRANSITION);
}
#endif
break;
case PD_CTRL_PS_RDY:
if (pd[port].task_state == PD_STATE_SNK_SWAP_SRC_DISABLE) {
set_state(port, PD_STATE_SNK_SWAP_STANDBY);
} else if (pd[port].task_state == PD_STATE_SRC_SWAP_STANDBY) {
/* reset message ID and swap roles */
pd[port].msg_id = 0;
invalidate_last_message_id(port);
pd_set_power_role(port, PD_ROLE_SINK);
pd_update_roles(port);
/*
* Give the state machine time to read VBUS as high.
* Note: This is empirically determined, not strictly
* part of the USB PD spec.
*/
pd[port].vbus_debounce_time =
get_time().val + PD_T_DEBOUNCE;
set_state(port, PD_STATE_SNK_DISCOVERY);
#ifdef CONFIG_USBC_VCONN_SWAP
} else if (pd[port].task_state == PD_STATE_VCONN_SWAP_INIT) {
/*
* If VCONN is on, then this PS_RDY tells us it's
* ok to turn VCONN off
*/
if (pd[port].flags & PD_FLAGS_VCONN_ON)
set_state(port, PD_STATE_VCONN_SWAP_READY);
#endif
} else if (pd[port].task_state == PD_STATE_SNK_DISCOVERY) {
/* Don't know what power source is ready. Reset. */
set_state(port, PD_STATE_HARD_RESET_SEND);
} else if (pd[port].task_state == PD_STATE_SNK_SWAP_STANDBY) {
/* Do nothing, assume this is a redundant PD_RDY */
} else if (pd[port].power_role == PD_ROLE_SINK) {
/*
* Give the source some time to send any messages before
* we start our interrogation. Add some jitter of up to
* ~192ms to prevent multiple collisions.
*/
if (pd[port].task_state == PD_STATE_SNK_TRANSITION)
pd[port].ready_state_holdoff_timer =
get_time().val + SNK_READY_HOLD_OFF_US
+ (get_time().le.lo & 0xf) * 12 * MSEC;
set_state(port, PD_STATE_SNK_READY);
pd_set_input_current_limit(port, pd[port].curr_limit,
pd[port].supply_voltage);
#ifdef CONFIG_CHARGE_MANAGER
/* Set ceiling based on what's negotiated */
charge_manager_set_ceil(port,
CEIL_REQUESTOR_PD,
pd[port].curr_limit);
#endif
}
break;
#endif
case PD_CTRL_REJECT:
if (pd[port].task_state == PD_STATE_ENTER_USB) {
if (!IS_ENABLED(CONFIG_USBC_SS_MUX))
break;
/*
* Since Enter USB sets the mux state to SAFE mode,
* resetting the mux state back to USB mode on
* recieveing a NACK.
*/
usb_mux_set(port, USB_PD_MUX_USB_ENABLED,
USB_SWITCH_CONNECT, pd[port].polarity);
set_state(port, READY_RETURN_STATE(port));
break;
}
case PD_CTRL_WAIT:
if (pd[port].task_state == PD_STATE_DR_SWAP) {
if (type == PD_CTRL_WAIT) /* try again ... */
pd[port].flags |= PD_FLAGS_CHECK_DR_ROLE;
set_state(port, READY_RETURN_STATE(port));
}
#ifdef CONFIG_USBC_VCONN_SWAP
else if (pd[port].task_state == PD_STATE_VCONN_SWAP_SEND)
set_state(port, READY_RETURN_STATE(port));
#endif
#ifdef CONFIG_USB_PD_DUAL_ROLE
else if (pd[port].task_state == PD_STATE_SRC_SWAP_INIT)
set_state(port, PD_STATE_SRC_READY);
else if (pd[port].task_state == PD_STATE_SNK_SWAP_INIT)
set_state(port, PD_STATE_SNK_READY);
else if (pd[port].task_state == PD_STATE_SNK_REQUESTED) {
/*
* On reception of a WAIT message, transition to
* PD_STATE_SNK_READY after PD_T_SINK_REQUEST ms to
* send another request.
*
* On reception of a REJECT message, transition to
* PD_STATE_SNK_READY but don't resend the request if
* we already have a contract in place.
*
* On reception of a REJECT message without a contract,
* transition to PD_STATE_SNK_DISCOVERY instead.
*/
if (type == PD_CTRL_WAIT) {
/*
* Trigger a new power request when
* we enter PD_STATE_SNK_READY
*/
pd[port].new_power_request = 1;
/*
* After the request is triggered,
* make sure the request is sent.
*/
pd[port].prev_request_mv = 0;
/*
* Transition to PD_STATE_SNK_READY
* after PD_T_SINK_REQUEST ms.
*/
set_state_timeout(port,
get_time().val +
PD_T_SINK_REQUEST,
PD_STATE_SNK_READY);
} else {
/* The request was rejected */
const int in_contract =
pd[port].flags &
PD_FLAGS_EXPLICIT_CONTRACT;
set_state(port,
in_contract ? PD_STATE_SNK_READY
: PD_STATE_SNK_DISCOVERY);
}
}
#endif
break;
case PD_CTRL_ACCEPT:
if (pd[port].task_state == PD_STATE_ENTER_USB) {
if (!IS_ENABLED(CONFIG_USBC_SS_MUX))
break;
/* Connect the SBU and USB lines to the connector */
if (IS_ENABLED(CONFIG_USBC_PPC_SBU))
ppc_set_sbu(port, 1);
/* Set usb mux to USB4 mode */
usb_mux_set(port, USB_PD_MUX_USB4_ENABLED,
USB_SWITCH_CONNECT, pd[port].polarity);
set_state(port, READY_RETURN_STATE(port));
} else if (pd[port].task_state == PD_STATE_SOFT_RESET) {
/*
* For the case that we sent soft reset in SNK_DISCOVERY
* on startup due to VBUS never low, clear the flag.
*/
pd[port].flags &= ~PD_FLAGS_VBUS_NEVER_LOW;
execute_soft_reset(port);
} else if (pd[port].task_state == PD_STATE_DR_SWAP) {
/* switch data role */
pd_dr_swap(port);
set_state(port, READY_RETURN_STATE(port));
#ifdef CONFIG_USB_PD_DUAL_ROLE
#ifdef CONFIG_USBC_VCONN_SWAP
} else if (pd[port].task_state == PD_STATE_VCONN_SWAP_SEND) {
/* switch vconn */
set_state(port, PD_STATE_VCONN_SWAP_INIT);
#endif
} else if (pd[port].task_state == PD_STATE_SRC_SWAP_INIT) {
/* explicit contract goes away for power swap */
pd[port].flags &= ~PD_FLAGS_EXPLICIT_CONTRACT;
pd_update_saved_port_flags(port,
PD_BBRMFLG_EXPLICIT_CONTRACT,
0);
set_state(port, PD_STATE_SRC_SWAP_SNK_DISABLE);
} else if (pd[port].task_state == PD_STATE_SNK_SWAP_INIT) {
/* explicit contract goes away for power swap */
pd[port].flags &= ~PD_FLAGS_EXPLICIT_CONTRACT;
pd_update_saved_port_flags(port,
PD_BBRMFLG_EXPLICIT_CONTRACT,
0);
set_state(port, PD_STATE_SNK_SWAP_SNK_DISABLE);
} else if (pd[port].task_state == PD_STATE_SNK_REQUESTED) {
/* explicit contract is now in place */
pd[port].flags |= PD_FLAGS_EXPLICIT_CONTRACT;
pd_update_saved_port_flags(port,
PD_BBRMFLG_EXPLICIT_CONTRACT,
1);
set_state(port, PD_STATE_SNK_TRANSITION);
#endif
}
break;
case PD_CTRL_SOFT_RESET:
execute_soft_reset(port);
pd[port].msg_id = 0;
/* We are done, acknowledge with an Accept packet */
send_control(port, PD_CTRL_ACCEPT);
break;
case PD_CTRL_PR_SWAP:
#ifdef CONFIG_USB_PD_DUAL_ROLE
if (pd_check_power_swap(port)) {
send_control(port, PD_CTRL_ACCEPT);
/*
* Clear flag for checking power role to avoid
* immediately requesting another swap.
*/
pd[port].flags &= ~PD_FLAGS_CHECK_PR_ROLE;
set_state(port,
DUAL_ROLE_IF_ELSE(port,
PD_STATE_SNK_SWAP_SNK_DISABLE,
PD_STATE_SRC_SWAP_SNK_DISABLE));
} else {
send_control(port, PD_CTRL_REJECT);
}
#else
send_control(port, NOT_SUPPORTED(pd[port].rev));
#endif
break;
case PD_CTRL_DR_SWAP:
if (pd_check_data_swap(port, pd[port].data_role)) {
/*
* Accept switch and perform data swap. Clear
* flag for checking data role to avoid
* immediately requesting another swap.
*/
pd[port].flags &= ~PD_FLAGS_CHECK_DR_ROLE;
if (send_control(port, PD_CTRL_ACCEPT) >= 0)
pd_dr_swap(port);
} else {
send_control(port, PD_CTRL_REJECT);
}
break;
case PD_CTRL_VCONN_SWAP:
#ifdef CONFIG_USBC_VCONN_SWAP
if (pd[port].task_state == PD_STATE_SRC_READY ||
pd[port].task_state == PD_STATE_SNK_READY) {
if (pd_check_vconn_swap(port)) {
if (send_control(port, PD_CTRL_ACCEPT) > 0)
set_state(port,
PD_STATE_VCONN_SWAP_INIT);
} else {
send_control(port, PD_CTRL_REJECT);
}
}
#else
send_control(port, NOT_SUPPORTED(pd[port].rev));
#endif
break;
default:
#ifdef CONFIG_USB_PD_REV30
send_control(port, PD_CTRL_NOT_SUPPORTED);
#endif
CPRINTF("C%d Unhandled ctrl message type %d\n", port, type);
}
}
#ifdef CONFIG_USB_PD_REV30
static void handle_ext_request(int port, uint16_t head, uint32_t *payload)
{
int type = PD_HEADER_TYPE(head);
switch (type) {
case PD_EXT_GET_BATTERY_CAP:
send_battery_cap(port, payload);
break;
case PD_EXT_GET_BATTERY_STATUS:
send_battery_status(port, payload);
break;
case PD_EXT_BATTERY_CAP:
break;
default:
send_control(port, PD_CTRL_NOT_SUPPORTED);
}
}
#endif
static void handle_request(int port, uint32_t head,
uint32_t *payload)
{
int cnt = PD_HEADER_CNT(head);
int data_role = PD_HEADER_DROLE(head);
int p;
/* dump received packet content (only dump ping at debug level 3) */
if ((debug_level == 2 && PD_HEADER_TYPE(head) != PD_CTRL_PING) ||
debug_level >= 3) {
CPRINTF("C%d RECV %04x/%d ", port, head, cnt);
for (p = 0; p < cnt; p++)
CPRINTF("[%d]%08x ", p, payload[p]);
CPRINTF("\n");
}
/*
* If we are in disconnected state, we shouldn't get a request. Do
* a hard reset if we get one.
*/
if (!pd_is_connected(port))
set_state(port, PD_STATE_HARD_RESET_SEND);
/*
* When a data role conflict is detected, USB-C ErrorRecovery
* actions shall be performed, and transitioning to unattached state
* is one such legal action.
*/
if (pd[port].data_role == data_role) {
/*
* If the port doesn't support removing the terminations, just
* go to the unattached state.
*/
if (tcpm_set_cc(port, TYPEC_CC_OPEN) == EC_SUCCESS) {
/* Do not drive VBUS or VCONN. */
pd_power_supply_reset(port);
#ifdef CONFIG_USBC_VCONN
set_vconn(port, 0);
#endif /* defined(CONFIG_USBC_VCONN) */
usleep(PD_T_ERROR_RECOVERY);
/* Restore terminations. */
tcpm_set_cc(port, DUAL_ROLE_IF_ELSE(port, TYPEC_CC_RD,
TYPEC_CC_RP));
}
set_state(port,
DUAL_ROLE_IF_ELSE(port,
PD_STATE_SNK_DISCONNECTED,
PD_STATE_SRC_DISCONNECTED));
return;
}
#ifdef CONFIG_USB_PD_REV30
/* Check if this is an extended chunked data message. */
if (pd[port].rev == PD_REV30 && PD_HEADER_EXT(head)) {
handle_ext_request(port, head, payload);
return;
}
#endif
if (cnt)
handle_data_request(port, head, payload);
else
handle_ctrl_request(port, head, payload);
}
void pd_send_vdm(int port, uint32_t vid, int cmd, const uint32_t *data,
int count)
{
if (count > VDO_MAX_SIZE - 1) {
CPRINTF("C%d VDM over max size\n", port);
return;
}
/* set VDM header with VID & CMD */
pd[port].vdo_data[0] = VDO(vid, ((vid & USB_SID_PD) == USB_SID_PD) ?
1 : (PD_VDO_CMD(cmd) <= CMD_ATTENTION), cmd);
#ifdef CONFIG_USB_PD_REV30
pd[port].vdo_data[0] |= VDO_SVDM_VERS(vdo_ver[pd[port].rev]);
#endif
queue_vdm(port, pd[port].vdo_data, data, count, TCPC_TX_SOP);
task_wake(PD_PORT_TO_TASK_ID(port));
}
static inline int pdo_busy(int port)
{
/*
* Note, main PDO state machine (pd_task) uses READY state exclusively
* to denote port partners have successfully negociated a contract. All
* other protocol actions force state transitions.
*/
int rv = (pd[port].task_state != PD_STATE_SRC_READY);
#ifdef CONFIG_USB_PD_DUAL_ROLE
rv &= (pd[port].task_state != PD_STATE_SNK_READY);
#endif
return rv;
}
static uint64_t vdm_get_ready_timeout(uint32_t vdm_hdr)
{
uint64_t timeout;
int cmd = PD_VDO_CMD(vdm_hdr);
/* its not a structured VDM command */
if (!PD_VDO_SVDM(vdm_hdr))
return 500*MSEC;
switch (PD_VDO_CMDT(vdm_hdr)) {
case CMDT_INIT:
if ((cmd == CMD_ENTER_MODE) || (cmd == CMD_EXIT_MODE))
timeout = PD_T_VDM_WAIT_MODE_E;
else
timeout = PD_T_VDM_SNDR_RSP;
break;
default:
if ((cmd == CMD_ENTER_MODE) || (cmd == CMD_EXIT_MODE))
timeout = PD_T_VDM_E_MODE;
else
timeout = PD_T_VDM_RCVR_RSP;
break;
}
return timeout;
}
static void exit_tbt_mode_sop_prime(int port)
{
/* Exit Thunderbolt-Compatible mode SOP' */
uint16_t header;
int opos;
if (!IS_ENABLED(CONFIG_USB_PD_TBT_COMPAT_MODE))
return;
opos = pd_alt_mode(port, TCPC_TX_SOP, USB_VID_INTEL);
if (opos <= 0)
return;
CPRINTS("C%d Cable exiting TBT Compat mode", port);
/*
* Note: TCPMv2 contemplates separate discovery structures for each SOP
* type. TCPMv1 only uses one discovery structure, so all accesses
* specify TCPC_TX_SOP.
*/
if (!pd_dfp_exit_mode(port, TCPC_TX_SOP, USB_VID_INTEL, opos))
return;
header = PD_HEADER(PD_DATA_VENDOR_DEF, pd[port].power_role,
pd[port].data_role, pd[port].msg_id,
(int)pd[port].vdo_count, pd_get_rev(port), 0);
pd[port].vdo_data[0] = VDO(USB_VID_INTEL, 1,
CMD_EXIT_MODE | VDO_OPOS(opos));
pd_transmit(port, TCPC_TX_SOP_PRIME, header, pd[port].vdo_data,
AMS_START);
usb_mux_set(port, USB_PD_MUX_USB_ENABLED, USB_SWITCH_CONNECT,
pd_get_polarity(port));
}
static void pd_vdm_send_state_machine(int port)
{
int res;
uint16_t header;
enum tcpm_transmit_type msg_type = pd[port].xmit_type;
switch (pd[port].vdm_state) {
case VDM_STATE_READY:
/* Only transmit VDM if connected. */
if (!pd_is_connected(port)) {
pd[port].vdm_state = VDM_STATE_ERR_BUSY;
break;
}
/*
* if there's traffic or we're not in PDO ready state don't send
* a VDM.
*/
if (pdo_busy(port))
break;
/*
* To communicate with the cable plug, an explicit contract
* should be established, VCONN should be enabled and data role
* that can communicate with the cable plug should be in place.
* For USB3.0, UFP/DFP can communicate whereas in case of
* USB2.0 only DFP can talk to the cable plug.
*
* For communication between USB2.0 UFP and cable plug,
* data role swap takes place during source and sink
* negotiation and in case of failure, a soft reset is issued.
*/
if ((msg_type == TCPC_TX_SOP_PRIME) ||
(msg_type == TCPC_TX_SOP_PRIME_PRIME)) {
/* Prepare SOP'/SOP'' header and send VDM */
header = PD_HEADER(
PD_DATA_VENDOR_DEF,
PD_PLUG_FROM_DFP_UFP,
0,
pd[port].msg_id,
(int)pd[port].vdo_count,
pd_get_rev(port),
0);
res = pd_transmit(port, msg_type, header,
pd[port].vdo_data, AMS_START);
/*
* In the case of SOP', if there is no response from
* the cable, it's a non-emark cable and therefore the
* pd flow should continue irrespective of cable
* response, sending discover_identity so the pd flow
* remains intact.
*
* In the case of SOP'', if there is no response from
* the cable, exit Thunderbolt-Compatible mode
* discovery, reset the mux state since, the mux will
* be set to a safe state before entering
* Thunderbolt-Compatible mode and enter the default
* mode.
*/
if (res < 0) {
header = PD_HEADER(PD_DATA_VENDOR_DEF,
pd[port].power_role,
pd[port].data_role,
pd[port].msg_id,
(int)pd[port].vdo_count,
pd_get_rev(port), 0);
if ((msg_type == TCPC_TX_SOP_PRIME_PRIME) &&
IS_ENABLED(CONFIG_USBC_SS_MUX)) {
exit_tbt_mode_sop_prime(port);
} else if (msg_type == TCPC_TX_SOP_PRIME) {
pd[port].vdo_data[0] = VDO(USB_SID_PD,
1, CMD_DISCOVER_SVID);
}
res = pd_transmit(port, TCPC_TX_SOP, header,
pd[port].vdo_data, AMS_START);
reset_pd_cable(port);
}
} else {
/* Prepare SOP header and send VDM */
header = PD_HEADER(PD_DATA_VENDOR_DEF,
pd[port].power_role,
pd[port].data_role,
pd[port].msg_id,
(int)pd[port].vdo_count,
pd_get_rev(port), 0);
res = pd_transmit(port, TCPC_TX_SOP, header,
pd[port].vdo_data, AMS_START);
}
if (res < 0) {
pd[port].vdm_state = VDM_STATE_ERR_SEND;
} else {
pd[port].vdm_state = VDM_STATE_BUSY;
pd[port].vdm_timeout.val = get_time().val +
vdm_get_ready_timeout(pd[port].vdo_data[0]);
}
break;
case VDM_STATE_WAIT_RSP_BUSY:
/* wait and then initiate request again */
if (get_time().val > pd[port].vdm_timeout.val) {
pd[port].vdo_data[0] = pd[port].vdo_retry;
pd[port].vdo_count = 1;
pd[port].vdm_state = VDM_STATE_READY;
}
break;
case VDM_STATE_BUSY:
/* Wait for VDM response or timeout */
if (pd[port].vdm_timeout.val &&
(get_time().val > pd[port].vdm_timeout.val)) {
pd[port].vdm_state = VDM_STATE_ERR_TMOUT;
}
break;
case VDM_STATE_ERR_SEND:
/* Sending the VDM failed, so try again. */
CPRINTF("C%d VDMretry\n", port);
pd[port].vdm_state = VDM_STATE_READY;
break;
default:
break;
}
}
#ifdef CONFIG_CMD_PD_DEV_DUMP_INFO
static inline void pd_dev_dump_info(uint16_t dev_id, uint8_t *hash)
{
int j;
ccprintf("DevId:%d.%d Hash:", HW_DEV_ID_MAJ(dev_id),
HW_DEV_ID_MIN(dev_id));
for (j = 0; j < PD_RW_HASH_SIZE; j += 4) {
ccprintf(" 0x%02x%02x%02x%02x", hash[j + 3], hash[j + 2],
hash[j + 1], hash[j]);
}
ccprintf("\n");
}
#endif /* CONFIG_CMD_PD_DEV_DUMP_INFO */
int pd_dev_store_rw_hash(int port, uint16_t dev_id, uint32_t *rw_hash,
uint32_t current_image)
{
#ifdef CONFIG_COMMON_RUNTIME
int i;
#endif
pd[port].dev_id = dev_id;
memcpy(pd[port].dev_rw_hash, rw_hash, PD_RW_HASH_SIZE);
#ifdef CONFIG_CMD_PD_DEV_DUMP_INFO
if (debug_level >= 2)
pd_dev_dump_info(dev_id, (uint8_t *)rw_hash);
#endif
pd[port].current_image = current_image;
#ifdef CONFIG_COMMON_RUNTIME
/* Search table for matching device / hash */
for (i = 0; i < RW_HASH_ENTRIES; i++)
if (dev_id == rw_hash_table[i].dev_id)
return !memcmp(rw_hash,
rw_hash_table[i].dev_rw_hash,
PD_RW_HASH_SIZE);
#endif
return 0;
}
void pd_dev_get_rw_hash(int port, uint16_t *dev_id, uint8_t *rw_hash,
uint32_t *current_image)
{
*dev_id = pd[port].dev_id;
*current_image = pd[port].current_image;
if (*dev_id)
memcpy(rw_hash, pd[port].dev_rw_hash, PD_RW_HASH_SIZE);
}
__maybe_unused static void exit_supported_alt_mode(int port)
{
int i;
if (!IS_ENABLED(CONFIG_USB_PD_ALT_MODE_DFP))
return;
for (i = 0; i < supported_modes_cnt; i++) {
int opos = pd_alt_mode(port, TCPC_TX_SOP,
supported_modes[i].svid);
if (opos > 0 &&
pd_dfp_exit_mode(
port, TCPC_TX_SOP, supported_modes[i].svid, opos)) {
CPRINTS("C%d Exiting ALT mode with SVID = 0x%x", port,
supported_modes[i].svid);
pd_send_vdm(port, supported_modes[i].svid,
CMD_EXIT_MODE | VDO_OPOS(opos), NULL, 0);
/* Wait for an ACK from port-partner */
pd_vdm_send_state_machine(port);
}
}
}
#ifdef CONFIG_POWER_COMMON
static void handle_new_power_state(int port)
{
if (chipset_in_or_transitioning_to_state(CHIPSET_STATE_ANY_OFF)) {
/*
* The SoC will negotiate the alternate mode again when
* it boots up.
*/
exit_supported_alt_mode(port);
}
#ifdef CONFIG_USBC_VCONN_SWAP
else {
/* Request for Vconn Swap */
pd_try_vconn_src(port);
}
#endif
/* Ensure mux is set properly after chipset transition */
set_usb_mux_with_current_data_role(port);
}
#endif /* CONFIG_POWER_COMMON */
#ifdef CONFIG_USB_PD_DUAL_ROLE
enum pd_dual_role_states pd_get_dual_role(int port)
{
return drp_state[port];
}
#ifdef CONFIG_USB_PD_TRY_SRC
static void pd_update_try_source(void)
{
int i;
pd_try_src_enable = pd_is_try_source_capable();
/*
* Clear this flag to cover case where a TrySrc
* mode went from enabled to disabled and trying_source
* was active at that time.
*/
for (i = 0; i < board_get_usb_pd_port_count(); i++)
pd[i].flags &= ~PD_FLAGS_TRY_SRC;
}
#endif /* CONFIG_USB_PD_TRY_SRC */
#ifdef CONFIG_USB_PD_RESET_MIN_BATT_SOC
static void pd_update_snk_reset(void)
{
int i;
int batt_soc = usb_get_battery_soc();
if (batt_soc < CONFIG_USB_PD_RESET_MIN_BATT_SOC ||
battery_get_disconnect_state() != BATTERY_NOT_DISCONNECTED)
return;
for (i = 0; i < board_get_usb_pd_port_count(); i++) {
if (pd[i].flags & PD_FLAGS_SNK_WAITING_BATT) {
/*
* Battery has gained sufficient charge to kick off PD
* negotiation and withstand a hard reset. Clear the
* flag and let reset begin if task is waiting in
* SNK_DISCOVERY.
*/
pd[i].flags &= ~PD_FLAGS_SNK_WAITING_BATT;
if (pd[i].task_state == PD_STATE_SNK_DISCOVERY) {
CPRINTS("C%d: Starting soft reset timer", i);
set_state_timeout(i,
get_time().val + PD_T_SINK_WAIT_CAP,
PD_STATE_SOFT_RESET);
}
}
}
}
#endif
#if defined(CONFIG_USB_PD_TRY_SRC) || defined(CONFIG_USB_PD_RESET_MIN_BATT_SOC)
static void pd_update_battery_soc_change(void)
{
#ifdef CONFIG_USB_PD_TRY_SRC
pd_update_try_source();
#endif
#ifdef CONFIG_USB_PD_RESET_MIN_BATT_SOC
pd_update_snk_reset();
#endif
}
DECLARE_HOOK(HOOK_BATTERY_SOC_CHANGE, pd_update_battery_soc_change,
HOOK_PRIO_DEFAULT);
#endif /* CONFIG_USB_PD_TRY_SRC || CONFIG_USB_PD_RESET_MIN_BATT_SOC */
static inline void pd_set_dual_role_no_wakeup(int port,
enum pd_dual_role_states state)
{
drp_state[port] = state;
#ifdef CONFIG_USB_PD_TRY_SRC
pd_update_try_source();
#endif
}
void pd_set_dual_role(int port, enum pd_dual_role_states state)
{
pd_set_dual_role_no_wakeup(port, state);
/* Wake task up to process change */
task_set_event(PD_PORT_TO_TASK_ID(port),
PD_EVENT_UPDATE_DUAL_ROLE, 0);
}
/* This must only be called from the PD task */
static void pd_update_dual_role_config(int port)
{
/*
* Change to sink if port is currently a source AND (new DRP
* state is force sink OR new DRP state is either toggle off
* or debug accessory toggle only and we are in the source
* disconnected state).
*/
if (pd[port].power_role == PD_ROLE_SOURCE &&
((drp_state[port] == PD_DRP_FORCE_SINK && !pd_ts_dts_plugged(port))
|| (drp_state[port] == PD_DRP_TOGGLE_OFF
&& pd[port].task_state == PD_STATE_SRC_DISCONNECTED))) {
pd_set_power_role(port, PD_ROLE_SINK);
set_state(port, PD_STATE_SNK_DISCONNECTED);
tcpm_set_cc(port, TYPEC_CC_RD);
/* Make sure we're not sourcing VBUS. */
pd_power_supply_reset(port);
}
/*
* Change to source if port is currently a sink and the
* new DRP state is force source.
*/
if (pd[port].power_role == PD_ROLE_SINK &&
drp_state[port] == PD_DRP_FORCE_SOURCE) {
pd_set_power_role(port, PD_ROLE_SOURCE);
set_state(port, PD_STATE_SRC_DISCONNECTED);
tcpm_set_cc(port, TYPEC_CC_RP);
}
}
static int pd_is_power_swapping(int port)
{
/* return true if in the act of swapping power roles */
return pd[port].task_state == PD_STATE_SNK_SWAP_SNK_DISABLE ||
pd[port].task_state == PD_STATE_SNK_SWAP_SRC_DISABLE ||
pd[port].task_state == PD_STATE_SNK_SWAP_STANDBY ||
pd[port].task_state == PD_STATE_SNK_SWAP_COMPLETE ||
pd[port].task_state == PD_STATE_SRC_SWAP_SNK_DISABLE ||
pd[port].task_state == PD_STATE_SRC_SWAP_SRC_DISABLE ||
pd[port].task_state == PD_STATE_SRC_SWAP_STANDBY;
}
/*
* Provide Rp to ensure the partner port is in a known state (eg. not
* PD negotiated, not sourcing 20V).
*/
static void pd_partner_port_reset(int port)
{
uint64_t timeout;
uint8_t flags;
/*
* If there is no contract in place (or if we fail to read the BBRAM
* flags), there is no need to reset the partner.
*/
if (pd_get_saved_port_flags(port, &flags) != EC_SUCCESS ||
!(flags & PD_BBRMFLG_EXPLICIT_CONTRACT))
return;
/*
* If we reach here, an explicit contract is in place.
*
* If PD communications are allowed, don't apply Rp. We'll issue a
* SoftReset later on and renegotiate our contract. This particular
* condition only applies to unlocked RO images with an explicit
* contract in place.
*/
if (pd_comm_is_enabled(port))
return;
/* If we just lost power, don't apply Rp. */
if (system_get_reset_flags() &
(EC_RESET_FLAG_BROWNOUT | EC_RESET_FLAG_POWER_ON))
return;
/*
* Clear the active contract bit before we apply Rp in case we
* intentionally brown out because we cut off our only power supply.
*/
pd_update_saved_port_flags(port, PD_BBRMFLG_EXPLICIT_CONTRACT, 0);
/* Provide Rp for 200 msec. or until we no longer have VBUS. */
CPRINTF("C%d Apply Rp!\n", port);
cflush();
tcpm_set_cc(port, TYPEC_CC_RP);
timeout = get_time().val + 200 * MSEC;
while (get_time().val < timeout && pd_is_vbus_present(port))
msleep(10);
}
#endif /* CONFIG_USB_PD_DUAL_ROLE */
enum pd_power_role pd_get_power_role(int port)
{
return pd[port].power_role;
}
enum pd_data_role pd_get_data_role(int port)
{
return pd[port].data_role;
}
enum pd_cc_states pd_get_task_cc_state(int port)
{
return pd[port].cc_state;
}
uint8_t pd_get_task_state(int port)
{
return pd[port].task_state;
}
const char *pd_get_task_state_name(int port)
{
#ifdef CONFIG_USB_PD_TCPMV1_DEBUG
if (debug_level > 0)
return pd_state_names[pd[port].task_state];
#endif
return "";
}
bool pd_get_vconn_state(int port)
{
return !!(pd[port].flags & PD_FLAGS_VCONN_ON);
}
bool pd_get_partner_dual_role_power(int port)
{
return !!(pd[port].flags & PD_FLAGS_PARTNER_DR_POWER);
}
bool pd_get_partner_unconstr_power(int port)
{
return !!(pd[port].flags & PD_FLAGS_PARTNER_UNCONSTR);
}
enum tcpc_cc_polarity pd_get_polarity(int port)
{
return pd[port].polarity;
}
bool pd_get_partner_data_swap_capable(int port)
{
/* return data swap capable status of port partner */
return !!(pd[port].flags & PD_FLAGS_PARTNER_DR_DATA);
}
#ifdef CONFIG_COMMON_RUNTIME
void pd_comm_enable(int port, int enable)
{
/* We don't check port >= CONFIG_USB_PD_PORT_MAX_COUNT deliberately */
pd_comm_enabled[port] = enable;
/* If type-C connection, then update the TCPC RX enable */
if (pd_is_connected(port))
tcpm_set_rx_enable(port, enable);
#ifdef CONFIG_USB_PD_DUAL_ROLE
/*
* If communications are enabled, start hard reset timer for
* any port in PD_SNK_DISCOVERY.
*/
if (enable && pd[port].task_state == PD_STATE_SNK_DISCOVERY)
set_state_timeout(port,
get_time().val + PD_T_SINK_WAIT_CAP,
PD_STATE_HARD_RESET_SEND);
#endif
}
#endif
void pd_ping_enable(int port, int enable)
{
if (enable)
pd[port].flags |= PD_FLAGS_PING_ENABLED;
else
pd[port].flags &= ~PD_FLAGS_PING_ENABLED;
}
__overridable uint8_t board_get_src_dts_polarity(int port)
{
/*
* If the port in SRC DTS, the polarity is determined by the board,
* i.e. what Rp impedance the CC lines are pulled. If this function
* is not overridden, assume CC1 is primary.
*/
return 0;
}
#if defined(CONFIG_CHARGE_MANAGER)
/**
* Signal power request to indicate a charger update that affects the port.
*/
void pd_set_new_power_request(int port)
{
pd[port].new_power_request = 1;
task_wake(PD_PORT_TO_TASK_ID(port));
}
#endif /* CONFIG_CHARGE_MANAGER */
#if defined(CONFIG_USBC_BACKWARDS_COMPATIBLE_DFP) && defined(CONFIG_USBC_SS_MUX)
/*
* Backwards compatible DFP does not support USB SS because it applies VBUS
* before debouncing CC and setting USB SS muxes, but SS detection will fail
* before we are done debouncing CC.
*/
#error "Backwards compatible DFP does not support USB"
#endif
#ifdef CONFIG_COMMON_RUNTIME
/* Initialize globals based on system state. */
static void pd_init_tasks(void)
{
static int initialized;
int enable = 1;
int i;
/* Initialize globals once, for all PD tasks. */
if (initialized)
return;
#if defined(HAS_TASK_CHIPSET) && defined(CONFIG_USB_PD_DUAL_ROLE)
/* Set dual-role state based on chipset power state */
if (chipset_in_state(CHIPSET_STATE_ANY_OFF))
for (i = 0; i < board_get_usb_pd_port_count(); i++)
drp_state[i] = PD_DRP_FORCE_SINK;
else if (chipset_in_state(CHIPSET_STATE_ANY_SUSPEND))
for (i = 0; i < board_get_usb_pd_port_count(); i++)
drp_state[i] = PD_DRP_TOGGLE_OFF;
else /* CHIPSET_STATE_ON */
for (i = 0; i < board_get_usb_pd_port_count(); i++)
drp_state[i] = PD_DRP_TOGGLE_ON;
#endif
#if defined(CONFIG_USB_PD_COMM_DISABLED)
enable = 0;
#elif defined(CONFIG_USB_PD_COMM_LOCKED)
/* Disable PD communication if we're in RO, WP is enabled, and EFS
* didn't register NO_BOOT. */
if (!system_is_in_rw() && system_is_locked() && !vboot_allow_usb_pd())
enable = 0;
#endif
for (i = 0; i < board_get_usb_pd_port_count(); i++)
pd_comm_enabled[i] = enable;
CPRINTS("PD comm %sabled", enable ? "en" : "dis");
initialized = 1;
}
#endif /* CONFIG_COMMON_RUNTIME */
#if !defined(CONFIG_USB_PD_TCPC) && defined(CONFIG_USB_PD_DUAL_ROLE)
static int pd_restart_tcpc(int port)
{
if (board_set_tcpc_power_mode) {
/* force chip reset */
board_set_tcpc_power_mode(port, 0);
}
return tcpm_init(port);
}
#endif
/* High-priority interrupt tasks implementations */
#if defined(HAS_TASK_PD_INT_C0) || defined(HAS_TASK_PD_INT_C1) || \
defined(HAS_TASK_PD_INT_C2)
/* Used to conditionally compile code in main pd task. */
#define HAS_DEFFERED_INTERRUPT_HANDLER
/* Events for pd_interrupt_handler_task */
#define PD_PROCESS_INTERRUPT BIT(0)
static uint8_t pd_int_task_id[CONFIG_USB_PD_PORT_MAX_COUNT];
void schedule_deferred_pd_interrupt(const int port)
{
task_set_event(pd_int_task_id[port], PD_PROCESS_INTERRUPT, 0);
}
/*
* Theoretically, we may need to support up to 480 USB-PD packets per second for
* intensive operations such as FW update over PD. This value has tested well
* preventing watchdog resets with a single bad port partner plugged in.
*/
#define ALERT_STORM_MAX_COUNT 480
#define ALERT_STORM_INTERVAL SECOND
/**
* Main task entry point that handles PD interrupts for a single port
*
* @param p The PD port number for which to handle interrupts (pointer is
* reinterpreted as an integer directly).
*/
void pd_interrupt_handler_task(void *p)
{
const int port = (int) ((intptr_t) p);
const int port_mask = (PD_STATUS_TCPC_ALERT_0 << port);
struct {
int count;
timestamp_t time;
} storm_tracker[CONFIG_USB_PD_PORT_MAX_COUNT] = {};
ASSERT(port >= 0 && port < CONFIG_USB_PD_PORT_MAX_COUNT);
pd_int_task_id[port] = task_get_current();
while (1) {
const int evt = task_wait_event(-1);
if (evt & PD_PROCESS_INTERRUPT) {
/*
* While the interrupt signal is asserted; we have more
* work to do. This effectively makes the interrupt a
* level-interrupt instead of an edge-interrupt without
* having to enable/disable a real level-interrupt in
* multiple locations.
*
* Also, if the port is disabled do not process
* interrupts. Upon existing suspend, we schedule a
* PD_PROCESS_INTERRUPT to check if we missed anything.
*/
while ((tcpc_get_alert_status() & port_mask) &&
pd_is_port_enabled(port)) {
timestamp_t now;
tcpc_alert(port);
now = get_time();
if (timestamp_expired(
storm_tracker[port].time, &now)) {
/* Reset timer into future */
storm_tracker[port].time.val =
now.val + ALERT_STORM_INTERVAL;
/*
* Start at 1 since we are processing
* an interrupt now
*/
storm_tracker[port].count = 1;
} else if (++storm_tracker[port].count >
ALERT_STORM_MAX_COUNT) {
CPRINTS("C%d Interrupt storm detected. "
"Disabling port for 5 seconds.",
port);
pd_set_suspend(port, 1);
pd_deferred_resume(port);
}
}
}
}
}
#endif /* HAS_TASK_PD_INT_C0 || HAS_TASK_PD_INT_C1 || HAS_TASK_PD_INT_C2 */
static void pd_send_enter_usb(int port, int *timeout)
{
uint32_t usb4_payload;
uint16_t header;
int res;
/*
* TODO: Enable Enter USB for cables (SOP').
* This is needed for active cables
*/
if (!IS_ENABLED(CONFIG_USBC_SS_MUX) ||
!IS_ENABLED(CONFIG_USB_PD_USB4) ||
!IS_ENABLED(CONFIG_USB_PD_ALT_MODE_DFP))
return;
usb4_payload = get_enter_usb_msg_payload(port);
header = PD_HEADER(PD_DATA_ENTER_USB,
pd[port].power_role,
pd[port].data_role,
pd[port].msg_id,
1,
PD_REV30,
0);
res = pd_transmit(port, TCPC_TX_SOP, header, &usb4_payload, AMS_START);
if (res < 0) {
*timeout = 10*MSEC;
/*
* If failed to get goodCRC, send soft reset, otherwise ignore
* failure.
*/
set_state(port, res == -1 ?
PD_STATE_SOFT_RESET :
READY_RETURN_STATE(port));
return;
}
/* Disable Enter USB4 mode prevent re-entry */
disable_enter_usb4_mode(port);
set_state(port, PD_STATE_ENTER_USB);
}
void pd_task(void *u)
{
uint32_t head;
int port = TASK_ID_TO_PD_PORT(task_get_current());
uint32_t payload[7];
int timeout = 10*MSEC;
enum tcpc_cc_voltage_status cc1, cc2;
int res, incoming_packet = 0;
int hard_reset_count = 0;
#ifdef CONFIG_USB_PD_DUAL_ROLE
uint64_t next_role_swap = PD_T_DRP_SNK;
uint8_t saved_flgs = 0;
#ifndef CONFIG_USB_PD_VBUS_DETECT_NONE
int snk_hard_reset_vbus_off = 0;
#endif
#ifdef CONFIG_USB_PD_DUAL_ROLE_AUTO_TOGGLE
const int auto_toggle_supported = tcpm_auto_toggle_supported(port);
#endif
#if defined(CONFIG_CHARGE_MANAGER)
typec_current_t typec_curr = 0, typec_curr_change = 0;
#endif /* CONFIG_CHARGE_MANAGER */
#endif /* CONFIG_USB_PD_DUAL_ROLE */
enum pd_states this_state;
enum pd_cc_states new_cc_state;
timestamp_t now;
uint64_t next_src_cap = 0;
int caps_count = 0, hard_reset_sent = 0;
int snk_cap_count = 0;
int evt;
#ifdef CONFIG_USB_PD_TCPC_LOW_POWER
/*
* Set the ports in Low Power Mode so that other tasks wait until
* TCPC is initialized and ready.
*/
pd[port].flags |= PD_FLAGS_LPM_ENGAGED;
#endif
#ifdef CONFIG_COMMON_RUNTIME
pd_init_tasks();
#endif