in typec/tcpm/tcpm.c [3833:4797]
static void run_state_machine(struct tcpm_port *port)
{
int ret;
enum typec_pwr_opmode opmode;
unsigned int msecs;
enum tcpm_state upcoming_state;
port->enter_state = port->state;
switch (port->state) {
case TOGGLING:
break;
/* SRC states */
case SRC_UNATTACHED:
if (!port->non_pd_role_swap)
tcpm_swap_complete(port, -ENOTCONN);
tcpm_src_detach(port);
if (tcpm_start_toggling(port, tcpm_rp_cc(port))) {
tcpm_set_state(port, TOGGLING, 0);
break;
}
tcpm_set_cc(port, tcpm_rp_cc(port));
if (port->port_type == TYPEC_PORT_DRP)
tcpm_set_state(port, SNK_UNATTACHED, PD_T_DRP_SNK);
break;
case SRC_ATTACH_WAIT:
if (tcpm_port_is_debug(port))
tcpm_set_state(port, DEBUG_ACC_ATTACHED,
PD_T_CC_DEBOUNCE);
else if (tcpm_port_is_audio(port))
tcpm_set_state(port, AUDIO_ACC_ATTACHED,
PD_T_CC_DEBOUNCE);
else if (tcpm_port_is_source(port) && port->vbus_vsafe0v)
tcpm_set_state(port,
tcpm_try_snk(port) ? SNK_TRY
: SRC_ATTACHED,
PD_T_CC_DEBOUNCE);
break;
case SNK_TRY:
port->try_snk_count++;
/*
* Requirements:
* - Do not drive vconn or vbus
* - Terminate CC pins (both) to Rd
* Action:
* - Wait for tDRPTry (PD_T_DRP_TRY).
* Until then, ignore any state changes.
*/
tcpm_set_cc(port, TYPEC_CC_RD);
tcpm_set_state(port, SNK_TRY_WAIT, PD_T_DRP_TRY);
break;
case SNK_TRY_WAIT:
if (tcpm_port_is_sink(port)) {
tcpm_set_state(port, SNK_TRY_WAIT_DEBOUNCE, 0);
} else {
tcpm_set_state(port, SRC_TRYWAIT, 0);
port->max_wait = 0;
}
break;
case SNK_TRY_WAIT_DEBOUNCE:
tcpm_set_state(port, SNK_TRY_WAIT_DEBOUNCE_CHECK_VBUS,
PD_T_TRY_CC_DEBOUNCE);
break;
case SNK_TRY_WAIT_DEBOUNCE_CHECK_VBUS:
if (port->vbus_present && tcpm_port_is_sink(port))
tcpm_set_state(port, SNK_ATTACHED, 0);
else
port->max_wait = 0;
break;
case SRC_TRYWAIT:
tcpm_set_cc(port, tcpm_rp_cc(port));
if (port->max_wait == 0) {
port->max_wait = jiffies +
msecs_to_jiffies(PD_T_DRP_TRY);
tcpm_set_state(port, SRC_TRYWAIT_UNATTACHED,
PD_T_DRP_TRY);
} else {
if (time_is_after_jiffies(port->max_wait))
tcpm_set_state(port, SRC_TRYWAIT_UNATTACHED,
jiffies_to_msecs(port->max_wait -
jiffies));
else
tcpm_set_state(port, SNK_UNATTACHED, 0);
}
break;
case SRC_TRYWAIT_DEBOUNCE:
tcpm_set_state(port, SRC_ATTACHED, PD_T_CC_DEBOUNCE);
break;
case SRC_TRYWAIT_UNATTACHED:
tcpm_set_state(port, SNK_UNATTACHED, 0);
break;
case SRC_ATTACHED:
ret = tcpm_src_attach(port);
tcpm_set_state(port, SRC_UNATTACHED,
ret < 0 ? 0 : PD_T_PS_SOURCE_ON);
break;
case SRC_STARTUP:
opmode = tcpm_get_pwr_opmode(tcpm_rp_cc(port));
typec_set_pwr_opmode(port->typec_port, opmode);
port->pwr_opmode = TYPEC_PWR_MODE_USB;
port->caps_count = 0;
port->negotiated_rev = PD_MAX_REV;
port->message_id = 0;
port->rx_msgid = -1;
port->explicit_contract = false;
/* SNK -> SRC POWER/FAST_ROLE_SWAP finished */
if (port->ams == POWER_ROLE_SWAP ||
port->ams == FAST_ROLE_SWAP)
tcpm_ams_finish(port);
if (!port->pd_supported) {
tcpm_set_state(port, SRC_READY, 0);
break;
}
port->upcoming_state = SRC_SEND_CAPABILITIES;
tcpm_ams_start(port, POWER_NEGOTIATION);
break;
case SRC_SEND_CAPABILITIES:
port->caps_count++;
if (port->caps_count > PD_N_CAPS_COUNT) {
tcpm_set_state(port, SRC_READY, 0);
break;
}
ret = tcpm_pd_send_source_caps(port);
if (ret < 0) {
tcpm_set_state(port, SRC_SEND_CAPABILITIES,
PD_T_SEND_SOURCE_CAP);
} else {
/*
* Per standard, we should clear the reset counter here.
* However, that can result in state machine hang-ups.
* Reset it only in READY state to improve stability.
*/
/* port->hard_reset_count = 0; */
port->caps_count = 0;
port->pd_capable = true;
tcpm_set_state_cond(port, SRC_SEND_CAPABILITIES_TIMEOUT,
PD_T_SEND_SOURCE_CAP);
}
break;
case SRC_SEND_CAPABILITIES_TIMEOUT:
/*
* Error recovery for a PD_DATA_SOURCE_CAP reply timeout.
*
* PD 2.0 sinks are supposed to accept src-capabilities with a
* 3.0 header and simply ignore any src PDOs which the sink does
* not understand such as PPS but some 2.0 sinks instead ignore
* the entire PD_DATA_SOURCE_CAP message, causing contract
* negotiation to fail.
*
* After PD_N_HARD_RESET_COUNT hard-reset attempts, we try
* sending src-capabilities with a lower PD revision to
* make these broken sinks work.
*/
if (port->hard_reset_count < PD_N_HARD_RESET_COUNT) {
tcpm_set_state(port, HARD_RESET_SEND, 0);
} else if (port->negotiated_rev > PD_REV20) {
port->negotiated_rev--;
port->hard_reset_count = 0;
tcpm_set_state(port, SRC_SEND_CAPABILITIES, 0);
} else {
tcpm_set_state(port, hard_reset_state(port), 0);
}
break;
case SRC_NEGOTIATE_CAPABILITIES:
ret = tcpm_pd_check_request(port);
if (ret < 0) {
tcpm_pd_send_control(port, PD_CTRL_REJECT);
if (!port->explicit_contract) {
tcpm_set_state(port,
SRC_WAIT_NEW_CAPABILITIES, 0);
} else {
tcpm_set_state(port, SRC_READY, 0);
}
} else {
tcpm_pd_send_control(port, PD_CTRL_ACCEPT);
tcpm_set_partner_usb_comm_capable(port,
!!(port->sink_request & RDO_USB_COMM));
tcpm_set_state(port, SRC_TRANSITION_SUPPLY,
PD_T_SRC_TRANSITION);
}
break;
case SRC_TRANSITION_SUPPLY:
/* XXX: regulator_set_voltage(vbus, ...) */
tcpm_pd_send_control(port, PD_CTRL_PS_RDY);
port->explicit_contract = true;
typec_set_pwr_opmode(port->typec_port, TYPEC_PWR_MODE_PD);
port->pwr_opmode = TYPEC_PWR_MODE_PD;
tcpm_set_state_cond(port, SRC_READY, 0);
break;
case SRC_READY:
#if 1
port->hard_reset_count = 0;
#endif
port->try_src_count = 0;
tcpm_swap_complete(port, 0);
tcpm_typec_connect(port);
if (port->ams != NONE_AMS)
tcpm_ams_finish(port);
if (port->next_ams != NONE_AMS) {
port->ams = port->next_ams;
port->next_ams = NONE_AMS;
}
/*
* If previous AMS is interrupted, switch to the upcoming
* state.
*/
if (port->upcoming_state != INVALID_STATE) {
upcoming_state = port->upcoming_state;
port->upcoming_state = INVALID_STATE;
tcpm_set_state(port, upcoming_state, 0);
break;
}
/*
* 6.4.4.3.1 Discover Identity
* "The Discover Identity Command Shall only be sent to SOP when there is an
* Explicit Contract."
* For now, this driver only supports SOP for DISCOVER_IDENTITY, thus using
* port->explicit_contract to decide whether to send the command.
*/
if (port->explicit_contract)
mod_send_discover_delayed_work(port, 0);
else
port->send_discover = false;
/*
* 6.3.5
* Sending ping messages is not necessary if
* - the source operates at vSafe5V
* or
* - The system is not operating in PD mode
* or
* - Both partners are connected using a Type-C connector
*
* There is no actual need to send PD messages since the local
* port type-c and the spec does not clearly say whether PD is
* possible when type-c is connected to Type-A/B
*/
break;
case SRC_WAIT_NEW_CAPABILITIES:
/* Nothing to do... */
break;
/* SNK states */
case SNK_UNATTACHED:
if (!port->non_pd_role_swap)
tcpm_swap_complete(port, -ENOTCONN);
tcpm_pps_complete(port, -ENOTCONN);
tcpm_snk_detach(port);
if (tcpm_start_toggling(port, TYPEC_CC_RD)) {
tcpm_set_state(port, TOGGLING, 0);
break;
}
tcpm_set_cc(port, TYPEC_CC_RD);
if (port->port_type == TYPEC_PORT_DRP)
tcpm_set_state(port, SRC_UNATTACHED, PD_T_DRP_SRC);
break;
case SNK_ATTACH_WAIT:
if ((port->cc1 == TYPEC_CC_OPEN &&
port->cc2 != TYPEC_CC_OPEN) ||
(port->cc1 != TYPEC_CC_OPEN &&
port->cc2 == TYPEC_CC_OPEN))
tcpm_set_state(port, SNK_DEBOUNCED,
PD_T_CC_DEBOUNCE);
else if (tcpm_port_is_disconnected(port))
tcpm_set_state(port, SNK_UNATTACHED,
PD_T_PD_DEBOUNCE);
break;
case SNK_DEBOUNCED:
if (tcpm_port_is_disconnected(port))
tcpm_set_state(port, SNK_UNATTACHED,
PD_T_PD_DEBOUNCE);
else if (port->vbus_present)
tcpm_set_state(port,
tcpm_try_src(port) ? SRC_TRY
: SNK_ATTACHED,
0);
break;
case SRC_TRY:
port->try_src_count++;
tcpm_set_cc(port, tcpm_rp_cc(port));
port->max_wait = 0;
tcpm_set_state(port, SRC_TRY_WAIT, 0);
break;
case SRC_TRY_WAIT:
if (port->max_wait == 0) {
port->max_wait = jiffies +
msecs_to_jiffies(PD_T_DRP_TRY);
msecs = PD_T_DRP_TRY;
} else {
if (time_is_after_jiffies(port->max_wait))
msecs = jiffies_to_msecs(port->max_wait -
jiffies);
else
msecs = 0;
}
tcpm_set_state(port, SNK_TRYWAIT, msecs);
break;
case SRC_TRY_DEBOUNCE:
tcpm_set_state(port, SRC_ATTACHED, PD_T_PD_DEBOUNCE);
break;
case SNK_TRYWAIT:
tcpm_set_cc(port, TYPEC_CC_RD);
tcpm_set_state(port, SNK_TRYWAIT_VBUS, PD_T_CC_DEBOUNCE);
break;
case SNK_TRYWAIT_VBUS:
/*
* TCPM stays in this state indefinitely until VBUS
* is detected as long as Rp is not detected for
* more than a time period of tPDDebounce.
*/
if (port->vbus_present && tcpm_port_is_sink(port)) {
tcpm_set_state(port, SNK_ATTACHED, 0);
break;
}
if (!tcpm_port_is_sink(port))
tcpm_set_state(port, SNK_TRYWAIT_DEBOUNCE, 0);
break;
case SNK_TRYWAIT_DEBOUNCE:
tcpm_set_state(port, SNK_UNATTACHED, PD_T_PD_DEBOUNCE);
break;
case SNK_ATTACHED:
ret = tcpm_snk_attach(port);
if (ret < 0)
tcpm_set_state(port, SNK_UNATTACHED, 0);
else
tcpm_set_state(port, SNK_STARTUP, 0);
break;
case SNK_STARTUP:
opmode = tcpm_get_pwr_opmode(port->polarity ?
port->cc2 : port->cc1);
typec_set_pwr_opmode(port->typec_port, opmode);
port->pwr_opmode = TYPEC_PWR_MODE_USB;
port->negotiated_rev = PD_MAX_REV;
port->message_id = 0;
port->rx_msgid = -1;
port->explicit_contract = false;
if (port->ams == POWER_ROLE_SWAP ||
port->ams == FAST_ROLE_SWAP)
/* SRC -> SNK POWER/FAST_ROLE_SWAP finished */
tcpm_ams_finish(port);
tcpm_set_state(port, SNK_DISCOVERY, 0);
break;
case SNK_DISCOVERY:
if (port->vbus_present) {
u32 current_lim = tcpm_get_current_limit(port);
if (port->slow_charger_loop && (current_lim > PD_P_SNK_STDBY_MW / 5))
current_lim = PD_P_SNK_STDBY_MW / 5;
tcpm_set_current_limit(port, current_lim, 5000);
tcpm_set_charge(port, true);
if (!port->pd_supported)
tcpm_set_state(port, SNK_READY, 0);
else
tcpm_set_state(port, SNK_WAIT_CAPABILITIES, 0);
break;
}
/*
* For DRP, timeouts differ. Also, handling is supposed to be
* different and much more complex (dead battery detection;
* see USB power delivery specification, section 8.3.3.6.1.5.1).
*/
tcpm_set_state(port, hard_reset_state(port),
port->port_type == TYPEC_PORT_DRP ?
PD_T_DB_DETECT : PD_T_NO_RESPONSE);
break;
case SNK_DISCOVERY_DEBOUNCE:
tcpm_set_state(port, SNK_DISCOVERY_DEBOUNCE_DONE,
PD_T_CC_DEBOUNCE);
break;
case SNK_DISCOVERY_DEBOUNCE_DONE:
if (!tcpm_port_is_disconnected(port) &&
tcpm_port_is_sink(port) &&
ktime_after(port->delayed_runtime, ktime_get())) {
tcpm_set_state(port, SNK_DISCOVERY,
ktime_to_ms(ktime_sub(port->delayed_runtime, ktime_get())));
break;
}
tcpm_set_state(port, unattached_state(port), 0);
break;
case SNK_WAIT_CAPABILITIES:
ret = port->tcpc->set_pd_rx(port->tcpc, true);
if (ret < 0) {
tcpm_set_state(port, SNK_READY, 0);
break;
}
/*
* If VBUS has never been low, and we time out waiting
* for source cap, try a soft reset first, in case we
* were already in a stable contract before this boot.
* Do this only once.
*/
if (port->vbus_never_low) {
port->vbus_never_low = false;
tcpm_set_state(port, SNK_SOFT_RESET,
PD_T_SINK_WAIT_CAP);
} else {
tcpm_set_state(port, hard_reset_state(port),
PD_T_SINK_WAIT_CAP);
}
break;
case SNK_NEGOTIATE_CAPABILITIES:
port->pd_capable = true;
tcpm_set_partner_usb_comm_capable(port,
!!(port->source_caps[0] & PDO_FIXED_USB_COMM));
port->hard_reset_count = 0;
ret = tcpm_pd_send_request(port);
if (ret < 0) {
/* Restore back to the original state */
tcpm_set_auto_vbus_discharge_threshold(port, TYPEC_PWR_MODE_PD,
port->pps_data.active,
port->supply_voltage);
/* Let the Source send capabilities again. */
tcpm_set_state(port, SNK_WAIT_CAPABILITIES, 0);
} else {
tcpm_set_state_cond(port, hard_reset_state(port),
PD_T_SENDER_RESPONSE);
}
break;
case SNK_NEGOTIATE_PPS_CAPABILITIES:
ret = tcpm_pd_send_pps_request(port);
if (ret < 0) {
/* Restore back to the original state */
tcpm_set_auto_vbus_discharge_threshold(port, TYPEC_PWR_MODE_PD,
port->pps_data.active,
port->supply_voltage);
port->pps_status = ret;
/*
* If this was called due to updates to sink
* capabilities, and pps is no longer valid, we should
* safely fall back to a standard PDO.
*/
if (port->update_sink_caps)
tcpm_set_state(port, SNK_NEGOTIATE_CAPABILITIES, 0);
else
tcpm_set_state(port, SNK_READY, 0);
} else {
tcpm_set_state_cond(port, hard_reset_state(port),
PD_T_SENDER_RESPONSE);
}
break;
case SNK_TRANSITION_SINK:
/* From the USB PD spec:
* "The Sink Shall transition to Sink Standby before a positive or
* negative voltage transition of VBUS. During Sink Standby
* the Sink Shall reduce its power draw to pSnkStdby."
*
* This is not applicable to PPS though as the port can continue
* to draw negotiated power without switching to standby.
*/
if (port->supply_voltage != port->req_supply_voltage && !port->pps_data.active &&
port->current_limit * port->supply_voltage / 1000 > PD_P_SNK_STDBY_MW) {
u32 stdby_ma = PD_P_SNK_STDBY_MW * 1000 / port->supply_voltage;
tcpm_log(port, "Setting standby current %u mV @ %u mA",
port->supply_voltage, stdby_ma);
tcpm_set_current_limit(port, stdby_ma, port->supply_voltage);
}
fallthrough;
case SNK_TRANSITION_SINK_VBUS:
tcpm_set_state(port, hard_reset_state(port),
PD_T_PS_TRANSITION);
break;
case SNK_READY:
port->try_snk_count = 0;
port->update_sink_caps = false;
if (port->explicit_contract) {
typec_set_pwr_opmode(port->typec_port,
TYPEC_PWR_MODE_PD);
port->pwr_opmode = TYPEC_PWR_MODE_PD;
}
if (!port->pd_capable && port->slow_charger_loop)
tcpm_set_current_limit(port, tcpm_get_current_limit(port), 5000);
tcpm_swap_complete(port, 0);
tcpm_typec_connect(port);
mod_enable_frs_delayed_work(port, 0);
tcpm_pps_complete(port, port->pps_status);
if (port->ams != NONE_AMS)
tcpm_ams_finish(port);
if (port->next_ams != NONE_AMS) {
port->ams = port->next_ams;
port->next_ams = NONE_AMS;
}
/*
* If previous AMS is interrupted, switch to the upcoming
* state.
*/
if (port->upcoming_state != INVALID_STATE) {
upcoming_state = port->upcoming_state;
port->upcoming_state = INVALID_STATE;
tcpm_set_state(port, upcoming_state, 0);
break;
}
/*
* 6.4.4.3.1 Discover Identity
* "The Discover Identity Command Shall only be sent to SOP when there is an
* Explicit Contract."
* For now, this driver only supports SOP for DISCOVER_IDENTITY, thus using
* port->explicit_contract.
*/
if (port->explicit_contract)
mod_send_discover_delayed_work(port, 0);
else
port->send_discover = false;
power_supply_changed(port->psy);
break;
/* Accessory states */
case ACC_UNATTACHED:
tcpm_acc_detach(port);
tcpm_set_state(port, SRC_UNATTACHED, 0);
break;
case DEBUG_ACC_ATTACHED:
case AUDIO_ACC_ATTACHED:
ret = tcpm_acc_attach(port);
if (ret < 0)
tcpm_set_state(port, ACC_UNATTACHED, 0);
break;
case AUDIO_ACC_DEBOUNCE:
tcpm_set_state(port, ACC_UNATTACHED, PD_T_CC_DEBOUNCE);
break;
/* Hard_Reset states */
case HARD_RESET_SEND:
if (port->ams != NONE_AMS)
tcpm_ams_finish(port);
/*
* State machine will be directed to HARD_RESET_START,
* thus set upcoming_state to INVALID_STATE.
*/
port->upcoming_state = INVALID_STATE;
tcpm_ams_start(port, HARD_RESET);
break;
case HARD_RESET_START:
port->sink_cap_done = false;
if (port->tcpc->enable_frs)
port->tcpc->enable_frs(port->tcpc, false);
port->hard_reset_count++;
port->tcpc->set_pd_rx(port->tcpc, false);
tcpm_unregister_altmodes(port);
port->nr_sink_caps = 0;
port->send_discover = true;
if (port->pwr_role == TYPEC_SOURCE)
tcpm_set_state(port, SRC_HARD_RESET_VBUS_OFF,
PD_T_PS_HARD_RESET);
else
tcpm_set_state(port, SNK_HARD_RESET_SINK_OFF, 0);
break;
case SRC_HARD_RESET_VBUS_OFF:
/*
* 7.1.5 Response to Hard Resets
* Hard Reset Signaling indicates a communication failure has occurred and the
* Source Shall stop driving VCONN, Shall remove Rp from the VCONN pin and Shall
* drive VBUS to vSafe0V as shown in Figure 7-9.
*/
tcpm_set_vconn(port, false);
tcpm_set_vbus(port, false);
tcpm_set_roles(port, port->self_powered, TYPEC_SOURCE,
tcpm_data_role_for_source(port));
/*
* If tcpc fails to notify vbus off, TCPM will wait for PD_T_SAFE_0V +
* PD_T_SRC_RECOVER before turning vbus back on.
* From Table 7-12 Sequence Description for a Source Initiated Hard Reset:
* 4. Policy Engine waits tPSHardReset after sending Hard Reset Signaling and then
* tells the Device Policy Manager to instruct the power supply to perform a
* Hard Reset. The transition to vSafe0V Shall occur within tSafe0V (t2).
* 5. After tSrcRecover the Source applies power to VBUS in an attempt to
* re-establish communication with the Sink and resume USB Default Operation.
* The transition to vSafe5V Shall occur within tSrcTurnOn(t4).
*/
tcpm_set_state(port, SRC_HARD_RESET_VBUS_ON, PD_T_SAFE_0V + PD_T_SRC_RECOVER);
break;
case SRC_HARD_RESET_VBUS_ON:
tcpm_set_vconn(port, true);
tcpm_set_vbus(port, true);
if (port->ams == HARD_RESET)
tcpm_ams_finish(port);
if (port->pd_supported)
port->tcpc->set_pd_rx(port->tcpc, true);
tcpm_set_attached_state(port, true);
tcpm_set_state(port, SRC_UNATTACHED, PD_T_PS_SOURCE_ON);
break;
case SNK_HARD_RESET_SINK_OFF:
/* Do not discharge/disconnect during hard reseet */
tcpm_set_auto_vbus_discharge_threshold(port, TYPEC_PWR_MODE_USB, false, 0);
memset(&port->pps_data, 0, sizeof(port->pps_data));
tcpm_set_vconn(port, false);
if (port->pd_capable)
tcpm_set_charge(port, false);
tcpm_set_roles(port, port->self_powered, TYPEC_SINK,
tcpm_data_role_for_sink(port));
/*
* VBUS may or may not toggle, depending on the adapter.
* If it doesn't toggle, transition to SNK_HARD_RESET_SINK_ON
* directly after timeout.
*/
tcpm_set_state(port, SNK_HARD_RESET_SINK_ON, PD_T_SAFE_0V);
break;
case SNK_HARD_RESET_WAIT_VBUS:
if (port->ams == HARD_RESET)
tcpm_ams_finish(port);
/* Assume we're disconnected if VBUS doesn't come back. */
tcpm_set_state(port, SNK_UNATTACHED,
PD_T_SRC_RECOVER_MAX + PD_T_SRC_TURN_ON);
break;
case SNK_HARD_RESET_SINK_ON:
/* Note: There is no guarantee that VBUS is on in this state */
/*
* XXX:
* The specification suggests that dual mode ports in sink
* mode should transition to state PE_SRC_Transition_to_default.
* See USB power delivery specification chapter 8.3.3.6.1.3.
* This would mean to to
* - turn off VCONN, reset power supply
* - request hardware reset
* - turn on VCONN
* - Transition to state PE_Src_Startup
* SNK only ports shall transition to state Snk_Startup
* (see chapter 8.3.3.3.8).
* Similar, dual-mode ports in source mode should transition
* to PE_SNK_Transition_to_default.
*/
if (port->pd_capable) {
tcpm_set_current_limit(port,
tcpm_get_current_limit(port),
5000);
tcpm_set_charge(port, true);
}
if (port->ams == HARD_RESET)
tcpm_ams_finish(port);
tcpm_set_attached_state(port, true);
tcpm_set_auto_vbus_discharge_threshold(port, TYPEC_PWR_MODE_USB, false, VSAFE5V);
tcpm_set_state(port, SNK_STARTUP, 0);
break;
/* Soft_Reset states */
case SOFT_RESET:
port->message_id = 0;
port->rx_msgid = -1;
tcpm_pd_send_control(port, PD_CTRL_ACCEPT);
tcpm_ams_finish(port);
if (port->pwr_role == TYPEC_SOURCE) {
port->upcoming_state = SRC_SEND_CAPABILITIES;
tcpm_ams_start(port, POWER_NEGOTIATION);
} else {
tcpm_set_state(port, SNK_WAIT_CAPABILITIES, 0);
}
break;
case SRC_SOFT_RESET_WAIT_SNK_TX:
case SNK_SOFT_RESET:
if (port->ams != NONE_AMS)
tcpm_ams_finish(port);
port->upcoming_state = SOFT_RESET_SEND;
tcpm_ams_start(port, SOFT_RESET_AMS);
break;
case SOFT_RESET_SEND:
port->message_id = 0;
port->rx_msgid = -1;
if (tcpm_pd_send_control(port, PD_CTRL_SOFT_RESET))
tcpm_set_state_cond(port, hard_reset_state(port), 0);
else
tcpm_set_state_cond(port, hard_reset_state(port),
PD_T_SENDER_RESPONSE);
break;
/* DR_Swap states */
case DR_SWAP_SEND:
tcpm_pd_send_control(port, PD_CTRL_DR_SWAP);
if (port->data_role == TYPEC_DEVICE || port->negotiated_rev > PD_REV20)
port->send_discover = true;
tcpm_set_state_cond(port, DR_SWAP_SEND_TIMEOUT,
PD_T_SENDER_RESPONSE);
break;
case DR_SWAP_ACCEPT:
tcpm_pd_send_control(port, PD_CTRL_ACCEPT);
if (port->data_role == TYPEC_DEVICE || port->negotiated_rev > PD_REV20)
port->send_discover = true;
tcpm_set_state_cond(port, DR_SWAP_CHANGE_DR, 0);
break;
case DR_SWAP_SEND_TIMEOUT:
tcpm_swap_complete(port, -ETIMEDOUT);
port->send_discover = false;
tcpm_ams_finish(port);
tcpm_set_state(port, ready_state(port), 0);
break;
case DR_SWAP_CHANGE_DR:
if (port->data_role == TYPEC_HOST) {
tcpm_unregister_altmodes(port);
tcpm_set_roles(port, true, port->pwr_role,
TYPEC_DEVICE);
} else {
tcpm_set_roles(port, true, port->pwr_role,
TYPEC_HOST);
}
tcpm_ams_finish(port);
tcpm_set_state(port, ready_state(port), 0);
break;
case FR_SWAP_SEND:
if (tcpm_pd_send_control(port, PD_CTRL_FR_SWAP)) {
tcpm_set_state(port, ERROR_RECOVERY, 0);
break;
}
tcpm_set_state_cond(port, FR_SWAP_SEND_TIMEOUT, PD_T_SENDER_RESPONSE);
break;
case FR_SWAP_SEND_TIMEOUT:
tcpm_set_state(port, ERROR_RECOVERY, 0);
break;
case FR_SWAP_SNK_SRC_TRANSITION_TO_OFF:
tcpm_set_state(port, ERROR_RECOVERY, PD_T_PS_SOURCE_OFF);
break;
case FR_SWAP_SNK_SRC_NEW_SINK_READY:
if (port->vbus_source)
tcpm_set_state(port, FR_SWAP_SNK_SRC_SOURCE_VBUS_APPLIED, 0);
else
tcpm_set_state(port, ERROR_RECOVERY, PD_T_RECEIVER_RESPONSE);
break;
case FR_SWAP_SNK_SRC_SOURCE_VBUS_APPLIED:
tcpm_set_pwr_role(port, TYPEC_SOURCE);
if (tcpm_pd_send_control(port, PD_CTRL_PS_RDY)) {
tcpm_set_state(port, ERROR_RECOVERY, 0);
break;
}
tcpm_set_cc(port, tcpm_rp_cc(port));
tcpm_set_state(port, SRC_STARTUP, PD_T_SWAP_SRC_START);
break;
/* PR_Swap states */
case PR_SWAP_ACCEPT:
tcpm_pd_send_control(port, PD_CTRL_ACCEPT);
tcpm_set_state(port, PR_SWAP_START, 0);
break;
case PR_SWAP_SEND:
tcpm_pd_send_control(port, PD_CTRL_PR_SWAP);
tcpm_set_state_cond(port, PR_SWAP_SEND_TIMEOUT,
PD_T_SENDER_RESPONSE);
break;
case PR_SWAP_SEND_TIMEOUT:
tcpm_swap_complete(port, -ETIMEDOUT);
tcpm_set_state(port, ready_state(port), 0);
break;
case PR_SWAP_START:
tcpm_apply_rc(port);
if (port->pwr_role == TYPEC_SOURCE)
tcpm_set_state(port, PR_SWAP_SRC_SNK_TRANSITION_OFF,
PD_T_SRC_TRANSITION);
else
tcpm_set_state(port, PR_SWAP_SNK_SRC_SINK_OFF, 0);
break;
case PR_SWAP_SRC_SNK_TRANSITION_OFF:
/*
* Prevent vbus discharge circuit from turning on during PR_SWAP
* as this is not a disconnect.
*/
tcpm_set_vbus(port, false);
port->explicit_contract = false;
/* allow time for Vbus discharge, must be < tSrcSwapStdby */
tcpm_set_state(port, PR_SWAP_SRC_SNK_SOURCE_OFF,
PD_T_SRCSWAPSTDBY);
break;
case PR_SWAP_SRC_SNK_SOURCE_OFF:
tcpm_set_cc(port, TYPEC_CC_RD);
/* allow CC debounce */
tcpm_set_state(port, PR_SWAP_SRC_SNK_SOURCE_OFF_CC_DEBOUNCED,
PD_T_CC_DEBOUNCE);
break;
case PR_SWAP_SRC_SNK_SOURCE_OFF_CC_DEBOUNCED:
/*
* USB-PD standard, 6.2.1.4, Port Power Role:
* "During the Power Role Swap Sequence, for the initial Source
* Port, the Port Power Role field shall be set to Sink in the
* PS_RDY Message indicating that the initial Source’s power
* supply is turned off"
*/
tcpm_set_pwr_role(port, TYPEC_SINK);
if (tcpm_pd_send_control(port, PD_CTRL_PS_RDY)) {
tcpm_set_state(port, ERROR_RECOVERY, 0);
break;
}
tcpm_set_state(port, ERROR_RECOVERY, PD_T_PS_SOURCE_ON_PRS);
break;
case PR_SWAP_SRC_SNK_SINK_ON:
tcpm_enable_auto_vbus_discharge(port, true);
/* Set the vbus disconnect threshold for implicit contract */
tcpm_set_auto_vbus_discharge_threshold(port, TYPEC_PWR_MODE_USB, false, VSAFE5V);
tcpm_set_state(port, SNK_STARTUP, 0);
break;
case PR_SWAP_SNK_SRC_SINK_OFF:
/*
* Prevent vbus discharge circuit from turning on during PR_SWAP
* as this is not a disconnect.
*/
tcpm_set_auto_vbus_discharge_threshold(port, TYPEC_PWR_MODE_USB,
port->pps_data.active, 0);
tcpm_set_charge(port, false);
tcpm_set_state(port, hard_reset_state(port),
PD_T_PS_SOURCE_OFF);
break;
case PR_SWAP_SNK_SRC_SOURCE_ON:
tcpm_enable_auto_vbus_discharge(port, true);
tcpm_set_cc(port, tcpm_rp_cc(port));
tcpm_set_vbus(port, true);
/*
* allow time VBUS ramp-up, must be < tNewSrc
* Also, this window overlaps with CC debounce as well.
* So, Wait for the max of two which is PD_T_NEWSRC
*/
tcpm_set_state(port, PR_SWAP_SNK_SRC_SOURCE_ON_VBUS_RAMPED_UP,
PD_T_NEWSRC);
break;
case PR_SWAP_SNK_SRC_SOURCE_ON_VBUS_RAMPED_UP:
/*
* USB PD standard, 6.2.1.4:
* "Subsequent Messages initiated by the Policy Engine,
* such as the PS_RDY Message sent to indicate that Vbus
* is ready, will have the Port Power Role field set to
* Source."
*/
tcpm_set_pwr_role(port, TYPEC_SOURCE);
tcpm_pd_send_control(port, PD_CTRL_PS_RDY);
tcpm_set_state(port, SRC_STARTUP, PD_T_SWAP_SRC_START);
break;
case VCONN_SWAP_ACCEPT:
tcpm_pd_send_control(port, PD_CTRL_ACCEPT);
tcpm_ams_finish(port);
tcpm_set_state(port, VCONN_SWAP_START, 0);
break;
case VCONN_SWAP_SEND:
tcpm_pd_send_control(port, PD_CTRL_VCONN_SWAP);
tcpm_set_state(port, VCONN_SWAP_SEND_TIMEOUT,
PD_T_SENDER_RESPONSE);
break;
case VCONN_SWAP_SEND_TIMEOUT:
tcpm_swap_complete(port, -ETIMEDOUT);
tcpm_set_state(port, ready_state(port), 0);
break;
case VCONN_SWAP_START:
if (port->vconn_role == TYPEC_SOURCE)
tcpm_set_state(port, VCONN_SWAP_WAIT_FOR_VCONN, 0);
else
tcpm_set_state(port, VCONN_SWAP_TURN_ON_VCONN, 0);
break;
case VCONN_SWAP_WAIT_FOR_VCONN:
tcpm_set_state(port, hard_reset_state(port),
PD_T_VCONN_SOURCE_ON);
break;
case VCONN_SWAP_TURN_ON_VCONN:
tcpm_set_vconn(port, true);
tcpm_pd_send_control(port, PD_CTRL_PS_RDY);
tcpm_set_state(port, ready_state(port), 0);
break;
case VCONN_SWAP_TURN_OFF_VCONN:
tcpm_set_vconn(port, false);
tcpm_set_state(port, ready_state(port), 0);
break;
case DR_SWAP_CANCEL:
case PR_SWAP_CANCEL:
case VCONN_SWAP_CANCEL:
tcpm_swap_complete(port, port->swap_status);
if (port->pwr_role == TYPEC_SOURCE)
tcpm_set_state(port, SRC_READY, 0);
else
tcpm_set_state(port, SNK_READY, 0);
break;
case FR_SWAP_CANCEL:
if (port->pwr_role == TYPEC_SOURCE)
tcpm_set_state(port, SRC_READY, 0);
else
tcpm_set_state(port, SNK_READY, 0);
break;
case BIST_RX:
switch (BDO_MODE_MASK(port->bist_request)) {
case BDO_MODE_CARRIER2:
tcpm_pd_transmit(port, TCPC_TX_BIST_MODE_2, NULL);
tcpm_set_state(port, unattached_state(port),
PD_T_BIST_CONT_MODE);
break;
case BDO_MODE_TESTDATA:
if (port->tcpc->set_bist_data) {
tcpm_log(port, "Enable BIST MODE TESTDATA");
port->tcpc->set_bist_data(port->tcpc, true);
}
break;
default:
break;
}
break;
case GET_STATUS_SEND:
tcpm_pd_send_control(port, PD_CTRL_GET_STATUS);
tcpm_set_state(port, GET_STATUS_SEND_TIMEOUT,
PD_T_SENDER_RESPONSE);
break;
case GET_STATUS_SEND_TIMEOUT:
tcpm_set_state(port, ready_state(port), 0);
break;
case GET_PPS_STATUS_SEND:
tcpm_pd_send_control(port, PD_CTRL_GET_PPS_STATUS);
tcpm_set_state(port, GET_PPS_STATUS_SEND_TIMEOUT,
PD_T_SENDER_RESPONSE);
break;
case GET_PPS_STATUS_SEND_TIMEOUT:
tcpm_set_state(port, ready_state(port), 0);
break;
case GET_SINK_CAP:
tcpm_pd_send_control(port, PD_CTRL_GET_SINK_CAP);
tcpm_set_state(port, GET_SINK_CAP_TIMEOUT, PD_T_SENDER_RESPONSE);
break;
case GET_SINK_CAP_TIMEOUT:
port->sink_cap_done = true;
tcpm_set_state(port, ready_state(port), 0);
break;
case ERROR_RECOVERY:
tcpm_swap_complete(port, -EPROTO);
tcpm_pps_complete(port, -EPROTO);
tcpm_set_state(port, PORT_RESET, 0);
break;
case PORT_RESET:
tcpm_reset_port(port);
tcpm_set_cc(port, TYPEC_CC_OPEN);
tcpm_set_state(port, PORT_RESET_WAIT_OFF,
PD_T_ERROR_RECOVERY);
break;
case PORT_RESET_WAIT_OFF:
tcpm_set_state(port,
tcpm_default_state(port),
port->vbus_present ? PD_T_PS_SOURCE_OFF : 0);
break;
/* AMS intermediate state */
case AMS_START:
if (port->upcoming_state == INVALID_STATE) {
tcpm_set_state(port, port->pwr_role == TYPEC_SOURCE ?
SRC_READY : SNK_READY, 0);
break;
}
upcoming_state = port->upcoming_state;
port->upcoming_state = INVALID_STATE;
tcpm_set_state(port, upcoming_state, 0);
break;
/* Chunk state */
case CHUNK_NOT_SUPP:
tcpm_pd_send_control(port, PD_CTRL_NOT_SUPP);
tcpm_set_state(port, port->pwr_role == TYPEC_SOURCE ? SRC_READY : SNK_READY, 0);
break;
default:
WARN(1, "Unexpected port state %d\n", port->state);
break;
}
}