| Message ID | 20201008061556.1402293-14-badhri@google.com |
|---|---|
| State | Superseded |
| Headers | show |
| Series | TCPM support for FRS and AutoDischarge Disconnect | expand |
On Wed, Oct 07, 2020 at 11:15:54PM -0700, Badhri Jagan Sridharan wrote: > TCPCI spec allows TCPC hardware to autonomously discharge the vbus > capacitance upon disconnect. The expectation is that the TCPM enables > AutoDischargeDisconnect while entering SNK/SRC_ATTACHED states. Hardware > then automously discharges vbus when the vbus falls below a certain > threshold i.e. VBUS_SINK_DISCONNECT_THRESHOLD. > > Apart from enabling the vbus discharge circuit, AutoDischargeDisconnect > is also used a flag to move TCPCI based TCPC implementations into > Attached.Snk/Attached.Src state as mentioned in > Figure 4-15. TCPC State Diagram before a Connection of the > USB Type-C Port Controller Interface Specification. > In such TCPC implementations, setting AutoDischargeDisconnect would > prevent TCPC into entering "Connection_Invalid" state as well. > > Signed-off-by: Badhri Jagan Sridharan <badhri@google.com> Reviewed-by: Heikki Krogerus <heikki.krogerus@linux.intel.com> > --- > Changes since v1: > - Changing patch version to v6 to fix version number confusion. > > Changes since v6: > - Fixed incorrect data_role error that I introduced by mistake in > the previous version. > > Changes since v7: > - Rebase on usb-next > > Changes since v8: > - Removing the call to tcpm_set_auto_vbus_discharge_threshold > in the source path. > > - Changes since v9: > - None > --- > drivers/usb/typec/tcpm/tcpm.c | 60 ++++++++++++++++++++++++++++++++--- > include/linux/usb/tcpm.h | 15 +++++++++ > 2 files changed, 71 insertions(+), 4 deletions(-) > > diff --git a/drivers/usb/typec/tcpm/tcpm.c b/drivers/usb/typec/tcpm/tcpm.c > index d5a3e2b3bea2..51a14d282109 100644 > --- a/drivers/usb/typec/tcpm/tcpm.c > +++ b/drivers/usb/typec/tcpm/tcpm.c > @@ -1701,6 +1701,24 @@ static void tcpm_handle_alert(struct tcpm_port *port, const __le32 *payload, > } > } > > +static int tcpm_set_auto_vbus_discharge_threshold(struct tcpm_port *port, > + enum typec_pwr_opmode mode, bool pps_active, > + u32 requested_vbus_voltage) > +{ > + int ret; > + > + if (!port->tcpc->set_auto_vbus_discharge_threshold) > + return 0; > + > + ret = port->tcpc->set_auto_vbus_discharge_threshold(port->tcpc, mode, pps_active, > + requested_vbus_voltage); > + tcpm_log_force(port, > + "set_auto_vbus_discharge_threshold mode:%d pps_active:%c vbus:%u ret:%d", > + mode, pps_active ? 'y' : 'n', requested_vbus_voltage, ret); > + > + return ret; > +} > + > static void tcpm_pd_data_request(struct tcpm_port *port, > const struct pd_message *msg) > { > @@ -1871,6 +1889,10 @@ static void tcpm_pd_ctrl_request(struct tcpm_port *port, > port->current_limit, > port->supply_voltage); > port->explicit_contract = true; > + tcpm_set_auto_vbus_discharge_threshold(port, > + TYPEC_PWR_MODE_PD, > + port->pps_data.active, > + port->supply_voltage); > tcpm_set_state(port, SNK_READY, 0); > } else { > /* > @@ -2785,8 +2807,12 @@ static int tcpm_src_attach(struct tcpm_port *port) > if (ret < 0) > return ret; > > - ret = tcpm_set_roles(port, true, TYPEC_SOURCE, > - tcpm_data_role_for_source(port)); > + if (port->tcpc->enable_auto_vbus_discharge) { > + ret = port->tcpc->enable_auto_vbus_discharge(port->tcpc, true); > + tcpm_log_force(port, "enable vbus discharge ret:%d", ret); > + } > + > + ret = tcpm_set_roles(port, true, TYPEC_SOURCE, tcpm_data_role_for_source(port)); > if (ret < 0) > return ret; > > @@ -2853,6 +2879,12 @@ static void tcpm_unregister_altmodes(struct tcpm_port *port) > > static void tcpm_reset_port(struct tcpm_port *port) > { > + int ret; > + > + if (port->tcpc->enable_auto_vbus_discharge) { > + ret = port->tcpc->enable_auto_vbus_discharge(port->tcpc, false); > + tcpm_log_force(port, "Disable vbus discharge ret:%d", ret); > + } > tcpm_unregister_altmodes(port); > tcpm_typec_disconnect(port); > port->attached = false; > @@ -2917,8 +2949,13 @@ static int tcpm_snk_attach(struct tcpm_port *port) > if (ret < 0) > return ret; > > - ret = tcpm_set_roles(port, true, TYPEC_SINK, > - tcpm_data_role_for_sink(port)); > + if (port->tcpc->enable_auto_vbus_discharge) { > + tcpm_set_auto_vbus_discharge_threshold(port, TYPEC_PWR_MODE_USB, false, VSAFE5V); > + ret = port->tcpc->enable_auto_vbus_discharge(port->tcpc, true); > + tcpm_log_force(port, "enable vbus discharge ret:%d", ret); > + } > + > + ret = tcpm_set_roles(port, true, TYPEC_SINK, tcpm_data_role_for_sink(port)); > if (ret < 0) > return ret; > > @@ -3502,6 +3539,8 @@ static void run_state_machine(struct tcpm_port *port) > 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) > @@ -3544,6 +3583,7 @@ static void run_state_machine(struct tcpm_port *port) > tcpm_set_charge(port, true); > } > 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; > > @@ -3645,6 +3685,10 @@ static void run_state_machine(struct tcpm_port *port) > 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 */ > @@ -3673,9 +3717,17 @@ static void run_state_machine(struct tcpm_port *port) > tcpm_set_state_cond(port, SNK_UNATTACHED, PD_T_PS_SOURCE_ON); > break; > case PR_SWAP_SRC_SNK_SINK_ON: > + /* 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); > diff --git a/include/linux/usb/tcpm.h b/include/linux/usb/tcpm.h > index 7303f518ba49..e68aaa12886f 100644 > --- a/include/linux/usb/tcpm.h > +++ b/include/linux/usb/tcpm.h > @@ -86,6 +86,18 @@ enum tcpm_transmit_type { > * @frs_sourcing_vbus: > * Optional; Called to notify that vbus is now being sourced. > * Low level drivers can perform chip specific operations, if any. > + * @enable_auto_vbus_discharge: > + * Optional; TCPCI spec based TCPC implementations can optionally > + * support hardware to autonomously dischrge vbus upon disconnecting > + * as sink or source. TCPM signals TCPC to enable the mechanism upon > + * entering connected state and signals disabling upon disconnect. > + * @set_auto_vbus_discharge_threshold: > + * Mandatory when enable_auto_vbus_discharge is implemented. TCPM > + * calls this function to allow lower levels drivers to program the > + * vbus threshold voltage below which the vbus discharge circuit > + * will be turned on. requested_vbus_voltage is set to 0 when vbus > + * is going to disappear knowingly i.e. during PR_SWAP and > + * HARD_RESET etc. > */ > struct tcpc_dev { > struct fwnode_handle *fwnode; > @@ -113,6 +125,9 @@ struct tcpc_dev { > int (*set_bist_data)(struct tcpc_dev *dev, bool on); > int (*enable_frs)(struct tcpc_dev *dev, bool enable); > void (*frs_sourcing_vbus)(struct tcpc_dev *dev); > + int (*enable_auto_vbus_discharge)(struct tcpc_dev *dev, bool enable); > + int (*set_auto_vbus_discharge_threshold)(struct tcpc_dev *dev, enum typec_pwr_opmode mode, > + bool pps_active, u32 requested_vbus_voltage); > }; > > struct tcpm_port; > -- > 2.28.0.806.g8561365e88-goog
diff --git a/drivers/usb/typec/tcpm/tcpm.c b/drivers/usb/typec/tcpm/tcpm.c index d5a3e2b3bea2..51a14d282109 100644 --- a/drivers/usb/typec/tcpm/tcpm.c +++ b/drivers/usb/typec/tcpm/tcpm.c @@ -1701,6 +1701,24 @@ static void tcpm_handle_alert(struct tcpm_port *port, const __le32 *payload, } } +static int tcpm_set_auto_vbus_discharge_threshold(struct tcpm_port *port, + enum typec_pwr_opmode mode, bool pps_active, + u32 requested_vbus_voltage) +{ + int ret; + + if (!port->tcpc->set_auto_vbus_discharge_threshold) + return 0; + + ret = port->tcpc->set_auto_vbus_discharge_threshold(port->tcpc, mode, pps_active, + requested_vbus_voltage); + tcpm_log_force(port, + "set_auto_vbus_discharge_threshold mode:%d pps_active:%c vbus:%u ret:%d", + mode, pps_active ? 'y' : 'n', requested_vbus_voltage, ret); + + return ret; +} + static void tcpm_pd_data_request(struct tcpm_port *port, const struct pd_message *msg) { @@ -1871,6 +1889,10 @@ static void tcpm_pd_ctrl_request(struct tcpm_port *port, port->current_limit, port->supply_voltage); port->explicit_contract = true; + tcpm_set_auto_vbus_discharge_threshold(port, + TYPEC_PWR_MODE_PD, + port->pps_data.active, + port->supply_voltage); tcpm_set_state(port, SNK_READY, 0); } else { /* @@ -2785,8 +2807,12 @@ static int tcpm_src_attach(struct tcpm_port *port) if (ret < 0) return ret; - ret = tcpm_set_roles(port, true, TYPEC_SOURCE, - tcpm_data_role_for_source(port)); + if (port->tcpc->enable_auto_vbus_discharge) { + ret = port->tcpc->enable_auto_vbus_discharge(port->tcpc, true); + tcpm_log_force(port, "enable vbus discharge ret:%d", ret); + } + + ret = tcpm_set_roles(port, true, TYPEC_SOURCE, tcpm_data_role_for_source(port)); if (ret < 0) return ret; @@ -2853,6 +2879,12 @@ static void tcpm_unregister_altmodes(struct tcpm_port *port) static void tcpm_reset_port(struct tcpm_port *port) { + int ret; + + if (port->tcpc->enable_auto_vbus_discharge) { + ret = port->tcpc->enable_auto_vbus_discharge(port->tcpc, false); + tcpm_log_force(port, "Disable vbus discharge ret:%d", ret); + } tcpm_unregister_altmodes(port); tcpm_typec_disconnect(port); port->attached = false; @@ -2917,8 +2949,13 @@ static int tcpm_snk_attach(struct tcpm_port *port) if (ret < 0) return ret; - ret = tcpm_set_roles(port, true, TYPEC_SINK, - tcpm_data_role_for_sink(port)); + if (port->tcpc->enable_auto_vbus_discharge) { + tcpm_set_auto_vbus_discharge_threshold(port, TYPEC_PWR_MODE_USB, false, VSAFE5V); + ret = port->tcpc->enable_auto_vbus_discharge(port->tcpc, true); + tcpm_log_force(port, "enable vbus discharge ret:%d", ret); + } + + ret = tcpm_set_roles(port, true, TYPEC_SINK, tcpm_data_role_for_sink(port)); if (ret < 0) return ret; @@ -3502,6 +3539,8 @@ static void run_state_machine(struct tcpm_port *port) 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) @@ -3544,6 +3583,7 @@ static void run_state_machine(struct tcpm_port *port) tcpm_set_charge(port, true); } 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; @@ -3645,6 +3685,10 @@ static void run_state_machine(struct tcpm_port *port) 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 */ @@ -3673,9 +3717,17 @@ static void run_state_machine(struct tcpm_port *port) tcpm_set_state_cond(port, SNK_UNATTACHED, PD_T_PS_SOURCE_ON); break; case PR_SWAP_SRC_SNK_SINK_ON: + /* 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); diff --git a/include/linux/usb/tcpm.h b/include/linux/usb/tcpm.h index 7303f518ba49..e68aaa12886f 100644 --- a/include/linux/usb/tcpm.h +++ b/include/linux/usb/tcpm.h @@ -86,6 +86,18 @@ enum tcpm_transmit_type { * @frs_sourcing_vbus: * Optional; Called to notify that vbus is now being sourced. * Low level drivers can perform chip specific operations, if any. + * @enable_auto_vbus_discharge: + * Optional; TCPCI spec based TCPC implementations can optionally + * support hardware to autonomously dischrge vbus upon disconnecting + * as sink or source. TCPM signals TCPC to enable the mechanism upon + * entering connected state and signals disabling upon disconnect. + * @set_auto_vbus_discharge_threshold: + * Mandatory when enable_auto_vbus_discharge is implemented. TCPM + * calls this function to allow lower levels drivers to program the + * vbus threshold voltage below which the vbus discharge circuit + * will be turned on. requested_vbus_voltage is set to 0 when vbus + * is going to disappear knowingly i.e. during PR_SWAP and + * HARD_RESET etc. */ struct tcpc_dev { struct fwnode_handle *fwnode; @@ -113,6 +125,9 @@ struct tcpc_dev { int (*set_bist_data)(struct tcpc_dev *dev, bool on); int (*enable_frs)(struct tcpc_dev *dev, bool enable); void (*frs_sourcing_vbus)(struct tcpc_dev *dev); + int (*enable_auto_vbus_discharge)(struct tcpc_dev *dev, bool enable); + int (*set_auto_vbus_discharge_threshold)(struct tcpc_dev *dev, enum typec_pwr_opmode mode, + bool pps_active, u32 requested_vbus_voltage); }; struct tcpm_port;
TCPCI spec allows TCPC hardware to autonomously discharge the vbus capacitance upon disconnect. The expectation is that the TCPM enables AutoDischargeDisconnect while entering SNK/SRC_ATTACHED states. Hardware then automously discharges vbus when the vbus falls below a certain threshold i.e. VBUS_SINK_DISCONNECT_THRESHOLD. Apart from enabling the vbus discharge circuit, AutoDischargeDisconnect is also used a flag to move TCPCI based TCPC implementations into Attached.Snk/Attached.Src state as mentioned in Figure 4-15. TCPC State Diagram before a Connection of the USB Type-C Port Controller Interface Specification. In such TCPC implementations, setting AutoDischargeDisconnect would prevent TCPC into entering "Connection_Invalid" state as well. Signed-off-by: Badhri Jagan Sridharan <badhri@google.com> --- Changes since v1: - Changing patch version to v6 to fix version number confusion. Changes since v6: - Fixed incorrect data_role error that I introduced by mistake in the previous version. Changes since v7: - Rebase on usb-next Changes since v8: - Removing the call to tcpm_set_auto_vbus_discharge_threshold in the source path. - Changes since v9: - None --- drivers/usb/typec/tcpm/tcpm.c | 60 ++++++++++++++++++++++++++++++++--- include/linux/usb/tcpm.h | 15 +++++++++ 2 files changed, 71 insertions(+), 4 deletions(-)