All of lore.kernel.org
 help / color / mirror / Atom feed
* [PATCH v2 0/4] usb: typec: tcpm: Fixes for talking to the cable plug as a VCONN source
@ 2026-11-18  7:26 Alexey Charkov
  2026-11-18  7:26 ` [PATCH v2 1/4] usb: typec: tcpm: Keep the Soft_Reset target apart from the VDM one Alexey Charkov
                   ` (3 more replies)
  0 siblings, 4 replies; 9+ messages in thread
From: Alexey Charkov @ 2026-11-18  7:26 UTC (permalink / raw)
  To: Badhri Jagan Sridharan, Heikki Krogerus, Greg Kroah-Hartman,
	RD Babiera
  Cc: Sebastian Reichel, linux-usb, Alexey Charkov, stable

When a TCPM port is the VCONN source, its exchanges with the cable plug
on SOP' can leave state behind that later affects the port partner.

Patch 1 fixes a Soft_Reset meant for the port partner being sent to the
cable plug after any SOP' VDM, which left a source without a contract
until unplugged. It needs "usb: typec: tcpm: Stop a source from
repeating a cable Soft_Reset" [1] first: without it, the repeated
Soft_Reset after a VCONN Swap would now go to the port partner.

Patches 2 and 3 fix SRC_VDM_IDENTITY_REQUEST, which replays
Source_Capabilities after the first contract, and stalls until a Hard
Reset if the cable plug NAKs, answers BUSY or never answers.

Patch 4 is hardening rather than a fix for any known device: it keeps
messages from a cable plug that breaks the rules from reaching the port
partner's handlers.

The first three carry Fixes: tags and are meant for stable.

Tested on two FUSB302B ports (RK3576), source to sink through an
e-marked cable, plus injected cable plug answers (ACK, NAK, BUSY,
Not_Supported, none) and stray SOP' messages.

[1] https://lore.kernel.org/r/20261103-husb311-cable-comm-v1-1-6217dabc1a85@flipper.net

Signed-off-by: Alexey Charkov <alchark@flipper.net>
---
Changes in v2:
- Split the SRC_VDM_IDENTITY_REQUEST fix in two: keep upcoming_state for
  a message from the sink and clear it when leaving directly, then move
  on after a NAK, BUSY or no answer as USB PD r3.3 9.2.26.2.5.1 has it,
  keeping the timeout only as a fallback (Sashiko)
- Stop passing Reject from the cable plug, and pass its VDMs only as the
  answer to an outstanding SOP' request (Sashiko)
- Link to v1: https://patch.msgid.link/20261117-tcpm-soft-reset-sop-v1-0-c7e1543828c0@flipper.net

---
Alexey Charkov (4):
      usb: typec: tcpm: Keep the Soft_Reset target apart from the VDM one
      usb: typec: tcpm: Stop replaying Source_Capabilities after cable discovery
      usb: typec: tcpm: Leave SRC_VDM_IDENTITY_REQUEST whatever the cable answers
      usb: typec: tcpm: Keep cable plug messages away from the port partner

 drivers/usb/typec/tcpm/tcpm.c | 131 +++++++++++++++++++++++++++++++++++++-----
 1 file changed, 117 insertions(+), 14 deletions(-)
---
base-commit: 749a4de370409464cf8501ec5b2451df45c84eb4
change-id: 20261104-tcpm-soft-reset-sop-96b4a156f823
prerequisite-patch-id: 2ea442b68dfeee84c38efb27749d2f40487d2fff

Best regards,
--  
Alexey Charkov <alchark@flipper.net>


^ permalink raw reply	[flat|nested] 9+ messages in thread

* [PATCH v2 1/4] usb: typec: tcpm: Keep the Soft_Reset target apart from the VDM one
  2026-11-18  7:26 [PATCH v2 0/4] usb: typec: tcpm: Fixes for talking to the cable plug as a VCONN source Alexey Charkov
@ 2026-11-18  7:26 ` Alexey Charkov
  2026-11-18  7:32   ` sashiko-bot
  2026-11-18  7:26 ` [PATCH v2 2/4] usb: typec: tcpm: Stop replaying Source_Capabilities after cable discovery Alexey Charkov
                   ` (2 subsequent siblings)
  3 siblings, 1 reply; 9+ messages in thread
From: Alexey Charkov @ 2026-11-18  7:26 UTC (permalink / raw)
  To: Badhri Jagan Sridharan, Heikki Krogerus, Greg Kroah-Hartman,
	RD Babiera
  Cc: Sebastian Reichel, linux-usb, Alexey Charkov, stable

tx_sop_type holds the SOP* of the VDM being sent, for its retries, and
SOFT_RESET_SEND also reads it to tell a Soft_Reset for the cable plug,
after a VCONN Swap, from one for the port partner. Nothing sets it back
after a VDM, so once a VDM has gone to the cable plug, such as Discover
Identity on SOP' before the first contract, every Soft_Reset meant for
the port partner goes to the cable plug instead. The cable plug accepts
it and the port goes back to its ready state, but the port partner never
sees the Soft_Reset: a source whose Source_Capabilities got Not_Supported
is then left without a contract. The VCONN Swap, in turn, overwrites the
SOP* of a VDM that may still be pending. This left a FUSB302B-based
source without a contract until it was unplugged, after its partner
missed a message following Discover Identity to an e-marked cable.

Keep one target per context: vdm_sop_type for the VDM and its retries,
and soft_reset_sop_type for the next Soft_Reset. Point the latter at the
cable plug only for the VCONN Swap, only once, and back at SOP whenever
the protocol layer starts over or a Soft_Reset of the port partner
starts, along with the SOP' MessageID counters.

Fixes: 6bd181ba60e1 ("usb: typec: tcpm: add control message support to sop'")
Cc: stable@vger.kernel.org
Signed-off-by: Alexey Charkov <alchark@flipper.net>
---
 drivers/usb/typec/tcpm/tcpm.c | 28 +++++++++++++++++-----------
 1 file changed, 17 insertions(+), 11 deletions(-)

diff --git a/drivers/usb/typec/tcpm/tcpm.c b/drivers/usb/typec/tcpm/tcpm.c
index bb90211660ca..8c5be904d772 100644
--- a/drivers/usb/typec/tcpm/tcpm.c
+++ b/drivers/usb/typec/tcpm/tcpm.c
@@ -675,12 +675,13 @@ struct tcpm_port {
 
 	/* SOP* Related Fields */
 	/*
-	 * tx_sop_type determines which SOP* a message is being sent on.
-	 * For messages that are queued and not sent immediately such as in
-	 * tcpm_queue_message or messages that send after state changes,
-	 * the tx_sop_type is set accordingly.
+	 * Messages that are not sent right away carry their SOP* separately,
+	 * one per context so that one cannot redirect another:
+	 * vdm_sop_type for the VDM being sent, including its retries, and
+	 * soft_reset_sop_type for the next Soft_Reset.
 	 */
-	enum tcpm_transmit_type tx_sop_type;
+	enum tcpm_transmit_type vdm_sop_type;
+	enum tcpm_transmit_type soft_reset_sop_type;
 	/*
 	 * Prior to discovering the port partner's Specification Revision, the
 	 * Vconn source and cable plug will use the lower of their two revisions.
@@ -2003,7 +2004,7 @@ static void tcpm_queue_vdm(struct tcpm_port *port, const u32 header,
 	port->vdm_state = VDM_STATE_READY;
 	port->vdm_sm_running = true;
 
-	port->tx_sop_type = tx_sop_type;
+	port->vdm_sop_type = tx_sop_type;
 
 	mod_vdm_delayed_work(port, 0);
 }
@@ -3065,7 +3066,7 @@ static void vdm_run_state_machine(struct tcpm_port *port)
 		} else {
 			tcpm_ams_finish(port);
 			port->vdo_data[0] = 0;
-			if (port->tx_sop_type == TCPC_TX_SOP)
+			if (port->vdm_sop_type == TCPC_TX_SOP)
 				break;
 			/* Handle SOP' Transmission Errors */
 			switch (PD_VDO_CMD(vdo_hdr)) {
@@ -3102,7 +3103,7 @@ static void vdm_run_state_machine(struct tcpm_port *port)
 	case VDM_STATE_SEND_MESSAGE:
 		/* Prepare and send VDM */
 		memset(&msg, 0, sizeof(msg));
-		if (port->tx_sop_type == TCPC_TX_SOP_PRIME) {
+		if (port->vdm_sop_type == TCPC_TX_SOP_PRIME) {
 			msg.header = PD_HEADER_LE(PD_DATA_VENDOR_DEF,
 						  0,	/* Cable Plug Indicator for DFP/UFP */
 						  0,	/* Reserved */
@@ -3119,7 +3120,7 @@ static void vdm_run_state_machine(struct tcpm_port *port)
 		}
 		for (i = 0; i < port->vdo_count; i++)
 			msg.payload[i] = cpu_to_le32(port->vdo_data[i]);
-		res = tcpm_pd_transmit(port, port->tx_sop_type, &msg);
+		res = tcpm_pd_transmit(port, port->vdm_sop_type, &msg);
 		if (res < 0) {
 			port->vdm_state = VDM_STATE_ERR_SEND;
 		} else {
@@ -5529,6 +5530,7 @@ static void run_state_machine(struct tcpm_port *port)
 		port->message_id_prime = 0;
 		port->rx_msgid = -1;
 		port->rx_msgid_prime = -1;
+		port->soft_reset_sop_type = TCPC_TX_SOP;
 		port->explicit_contract = false;
 		/* SNK -> SRC POWER/FAST_ROLE_SWAP finished */
 		if (port->ams == POWER_ROLE_SWAP ||
@@ -5801,6 +5803,7 @@ static void run_state_machine(struct tcpm_port *port)
 		port->message_id_prime = 0;
 		port->rx_msgid = -1;
 		port->rx_msgid_prime = -1;
+		port->soft_reset_sop_type = TCPC_TX_SOP;
 		port->explicit_contract = false;
 
 		if (port->ams == POWER_ROLE_SWAP ||
@@ -6193,6 +6196,7 @@ static void run_state_machine(struct tcpm_port *port)
 	case SOFT_RESET:
 		port->message_id = 0;
 		port->rx_msgid = -1;
+		port->soft_reset_sop_type = TCPC_TX_SOP;
 		/* remove existing capabilities */
 		tcpm_partner_source_caps_reset(port);
 		tcpm_pd_send_control(port, PD_CTRL_ACCEPT, TCPC_TX_SOP);
@@ -6210,6 +6214,7 @@ static void run_state_machine(struct tcpm_port *port)
 	case SNK_SOFT_RESET:
 		if (port->ams != NONE_AMS)
 			tcpm_ams_finish(port);
+		port->soft_reset_sop_type = TCPC_TX_SOP;
 		port->upcoming_state = SOFT_RESET_SEND;
 		tcpm_ams_start(port, SOFT_RESET_AMS);
 		break;
@@ -6220,7 +6225,8 @@ static void run_state_machine(struct tcpm_port *port)
 		 * A Soft_Reset Message Shall be targeted at a specific entity
 		 * depending on the type of SOP* packet used.
 		 */
-		if (port->tx_sop_type == TCPC_TX_SOP_PRIME) {
+		if (port->soft_reset_sop_type == TCPC_TX_SOP_PRIME) {
+			port->soft_reset_sop_type = TCPC_TX_SOP;
 			port->message_id_prime = 0;
 			port->rx_msgid_prime = -1;
 			tcpm_pd_send_control(port, PD_CTRL_SOFT_RESET, TCPC_TX_SOP_PRIME);
@@ -6439,7 +6445,7 @@ static void run_state_machine(struct tcpm_port *port)
 	case VCONN_SWAP_SEND_SOFT_RESET:
 		tcpm_swap_complete(port, port->swap_status);
 		if (tcpm_can_communicate_sop_prime(port)) {
-			port->tx_sop_type = TCPC_TX_SOP_PRIME;
+			port->soft_reset_sop_type = TCPC_TX_SOP_PRIME;
 			port->upcoming_state = SOFT_RESET_SEND;
 			tcpm_ams_start(port, SOFT_RESET_AMS);
 		} else {

-- 
2.56.0


^ permalink raw reply related	[flat|nested] 9+ messages in thread

* [PATCH v2 2/4] usb: typec: tcpm: Stop replaying Source_Capabilities after cable discovery
  2026-11-18  7:26 [PATCH v2 0/4] usb: typec: tcpm: Fixes for talking to the cable plug as a VCONN source Alexey Charkov
  2026-11-18  7:26 ` [PATCH v2 1/4] usb: typec: tcpm: Keep the Soft_Reset target apart from the VDM one Alexey Charkov
@ 2026-11-18  7:26 ` Alexey Charkov
  2026-11-18  7:39   ` sashiko-bot
  2026-11-18  7:26 ` [PATCH v2 3/4] usb: typec: tcpm: Leave SRC_VDM_IDENTITY_REQUEST whatever the cable answers Alexey Charkov
  2026-11-18  7:26 ` [PATCH v2 4/4] usb: typec: tcpm: Keep cable plug messages away from the port partner Alexey Charkov
  3 siblings, 1 reply; 9+ messages in thread
From: Alexey Charkov @ 2026-11-18  7:26 UTC (permalink / raw)
  To: Badhri Jagan Sridharan, Heikki Krogerus, Greg Kroah-Hartman,
	RD Babiera
  Cc: Sebastian Reichel, linux-usb, Alexey Charkov, stable

When its first Source_Capabilities goes unacknowledged, a source that is
the VCONN source asks the cable plug for its identity in
SRC_VDM_IDENTITY_REQUEST. Entering that state sets upcoming_state to
SRC_SEND_CAPABILITIES, for a message from the sink that interrupts it
through SRC_READY. The ACK and send error paths go to
SRC_SEND_CAPABILITIES directly and leave upcoming_state set, so the
first SRC_READY after the contract sends Source_Capabilities again. The
second negotiation can cut into the sink's own Discover Identity, and
once ended in a Hard Reset between two FUSB302B ports.

Clear upcoming_state when SRC_SEND_CAPABILITIES follows
SRC_VDM_IDENTITY_REQUEST directly.

Fixes: af8b627046bc ("usb: typec: tcpm: add state machine support for SRC_VDM_IDENTITY_REQUEST")
Cc: stable@vger.kernel.org
Signed-off-by: Alexey Charkov <alchark@flipper.net>
---
 drivers/usb/typec/tcpm/tcpm.c | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/drivers/usb/typec/tcpm/tcpm.c b/drivers/usb/typec/tcpm/tcpm.c
index 8c5be904d772..b9146658f6e5 100644
--- a/drivers/usb/typec/tcpm/tcpm.c
+++ b/drivers/usb/typec/tcpm/tcpm.c
@@ -5544,6 +5544,12 @@ static void run_state_machine(struct tcpm_port *port)
 		tcpm_ams_start(port, POWER_NEGOTIATION);
 		break;
 	case SRC_SEND_CAPABILITIES:
+		/*
+		 * Straight from Discover Identity to the cable plug, rather
+		 * than back through SRC_READY after a message from the sink
+		 */
+		if (port->prev_state == SRC_VDM_IDENTITY_REQUEST)
+			port->upcoming_state = INVALID_STATE;
 		port->caps_count++;
 		if (port->caps_count > PD_N_CAPS_COUNT) {
 			tcpm_set_state(port, SRC_READY, 0);

-- 
2.56.0


^ permalink raw reply related	[flat|nested] 9+ messages in thread

* [PATCH v2 3/4] usb: typec: tcpm: Leave SRC_VDM_IDENTITY_REQUEST whatever the cable answers
  2026-11-18  7:26 [PATCH v2 0/4] usb: typec: tcpm: Fixes for talking to the cable plug as a VCONN source Alexey Charkov
  2026-11-18  7:26 ` [PATCH v2 1/4] usb: typec: tcpm: Keep the Soft_Reset target apart from the VDM one Alexey Charkov
  2026-11-18  7:26 ` [PATCH v2 2/4] usb: typec: tcpm: Stop replaying Source_Capabilities after cable discovery Alexey Charkov
@ 2026-11-18  7:26 ` Alexey Charkov
  2026-11-18  8:08   ` sashiko-bot
  2026-11-18  7:26 ` [PATCH v2 4/4] usb: typec: tcpm: Keep cable plug messages away from the port partner Alexey Charkov
  3 siblings, 1 reply; 9+ messages in thread
From: Alexey Charkov @ 2026-11-18  7:26 UTC (permalink / raw)
  To: Badhri Jagan Sridharan, Heikki Krogerus, Greg Kroah-Hartman,
	RD Babiera
  Cc: Sebastian Reichel, linux-usb, Alexey Charkov, stable

Only an ACK from the cable plug or a failure to send Discover Identity
takes SRC_VDM_IDENTITY_REQUEST on to SRC_SEND_CAPABILITIES. A NAK marks
discovery complete as if it came from the port partner, a BUSY retries
the request, and no answer leaves the state as it is. The source then
sends no Source_Capabilities until the sink gives up with a Hard Reset,
which cycles VBUS, and after a NAK it never discovers the port partner.
USB PD r3.3 section 9.2.26.2.5.1 goes back to Source_Capabilities on a
NAK, a BUSY or no answer in time, just as on an ACK.

Move on in each of those cases, and after tTypeCSendSourceCap in any
case, so that a request which never goes out cannot stall the source
either. Drop a request still waiting on the cable plug, and its AMS,
when moving on.

Fixes: af8b627046bc ("usb: typec: tcpm: add state machine support for SRC_VDM_IDENTITY_REQUEST")
Cc: stable@vger.kernel.org
Signed-off-by: Alexey Charkov <alchark@flipper.net>
---
 drivers/usb/typec/tcpm/tcpm.c | 27 ++++++++++++++++++++++++++-
 1 file changed, 26 insertions(+), 1 deletion(-)

diff --git a/drivers/usb/typec/tcpm/tcpm.c b/drivers/usb/typec/tcpm/tcpm.c
index b9146658f6e5..ab7ec5334564 100644
--- a/drivers/usb/typec/tcpm/tcpm.c
+++ b/drivers/usb/typec/tcpm/tcpm.c
@@ -2745,6 +2745,12 @@ static int tcpm_pd_svdm(struct tcpm_port *port, struct typec_altmode *adev,
 		break;
 	case CMDT_RSP_NAK:
 		tcpm_ams_finish(port);
+		/* Go on with Source_Capabilities, as after an ACK */
+		if (port->state == SRC_VDM_IDENTITY_REQUEST &&
+		    rx_sop_type == TCPC_TX_SOP_PRIME) {
+			tcpm_set_state(port, SRC_SEND_CAPABILITIES, 0);
+			return 0;
+		}
 		switch (cmd) {
 		/*
 		 * The cable is not allowed to respond with NAK so this must've happened over SOP
@@ -2812,6 +2818,11 @@ static void tcpm_handle_vdm_request(struct tcpm_port *port,
 	if (port->vdm_state == VDM_STATE_BUSY) {
 		/* If UFP responded busy retry after timeout */
 		if (PD_VDO_CMDT(p[0]) == CMDT_RSP_BUSY) {
+			/* No retry before the first contract */
+			if (port->state == SRC_VDM_IDENTITY_REQUEST) {
+				tcpm_set_state(port, SRC_SEND_CAPABILITIES, 0);
+				return;
+			}
 			port->vdm_state = VDM_STATE_WAIT_RSP_BUSY;
 			port->vdo_retry = (p[0] & ~VDO_CMDT_MASK) |
 				CMDT_INIT;
@@ -3039,6 +3050,8 @@ static void vdm_run_state_machine(struct tcpm_port *port)
 		port->vdm_state = VDM_STATE_ERR_TMOUT;
 		if (port->ams != NONE_AMS)
 			tcpm_ams_finish(port);
+		if (port->state == SRC_VDM_IDENTITY_REQUEST)
+			tcpm_set_state(port, SRC_SEND_CAPABILITIES, 0);
 		break;
 	case VDM_STATE_ERR_SEND:
 		/*
@@ -5548,8 +5561,18 @@ static void run_state_machine(struct tcpm_port *port)
 		 * Straight from Discover Identity to the cable plug, rather
 		 * than back through SRC_READY after a message from the sink
 		 */
-		if (port->prev_state == SRC_VDM_IDENTITY_REQUEST)
+		if (port->prev_state == SRC_VDM_IDENTITY_REQUEST) {
 			port->upcoming_state = INVALID_STATE;
+			/* Forget the request if still waiting on the cable plug */
+			if (port->vdm_sop_type == TCPC_TX_SOP_PRIME &&
+			    port->vdm_state > VDM_STATE_DONE) {
+				port->vdm_state = VDM_STATE_DONE;
+				port->vdo_data[0] = 0;
+				mod_vdm_delayed_work(port, 0);
+			}
+			if (port->ams == DISCOVER_IDENTITY)
+				tcpm_ams_finish(port);
+		}
 		port->caps_count++;
 		if (port->caps_count > PD_N_CAPS_COUNT) {
 			tcpm_set_state(port, SRC_READY, 0);
@@ -6560,6 +6583,8 @@ static void run_state_machine(struct tcpm_port *port)
 	case SRC_VDM_IDENTITY_REQUEST:
 		mod_vdm_discovery_delayed_work(port, 0);
 		port->upcoming_state = SRC_SEND_CAPABILITIES;
+		/* Go on even if Discover Identity never goes out */
+		tcpm_set_state(port, SRC_SEND_CAPABILITIES, PD_T_SEND_SOURCE_CAP);
 		break;
 
 	default:

-- 
2.56.0


^ permalink raw reply related	[flat|nested] 9+ messages in thread

* [PATCH v2 4/4] usb: typec: tcpm: Keep cable plug messages away from the port partner
  2026-11-18  7:26 [PATCH v2 0/4] usb: typec: tcpm: Fixes for talking to the cable plug as a VCONN source Alexey Charkov
                   ` (2 preceding siblings ...)
  2026-11-18  7:26 ` [PATCH v2 3/4] usb: typec: tcpm: Leave SRC_VDM_IDENTITY_REQUEST whatever the cable answers Alexey Charkov
@ 2026-11-18  7:26 ` Alexey Charkov
  2026-11-18  7:51   ` sashiko-bot
  3 siblings, 1 reply; 9+ messages in thread
From: Alexey Charkov @ 2026-11-18  7:26 UTC (permalink / raw)
  To: Badhri Jagan Sridharan, Heikki Krogerus, Greg Kroah-Hartman,
	RD Babiera
  Cc: Sebastian Reichel, linux-usb, Alexey Charkov

When the port is the VCONN source, messages from the cable plug on SOP'
go through the port partner's handlers, which act on them and answer on
SOP: an unrecognized message gets Not_Supported on SOP, which the partner
answers with a Soft_Reset, and an unexpected Accept or Reject soft resets
the partner. SOP'' and the debug SOP* types, which TCPM does not support,
take the same path and shadow the partner's last MessageID.

A cable plug only answers the VCONN source and never starts an AMS (USB
PD r3.3, section 8.5 and table 7.5). Pass on its answer to a VDM still
waiting for one, its Accept to a Soft_Reset sent to it, and its
Not_Supported to a VDM in the ready state, the only one that takes it as
the VDM's answer. Drop anything else on SOP', and drop other SOP* types
before they touch the MessageID tracking.

This hardens TCPM against cable plugs that break the rules: it was found
with a port posing as a cable plug, and no cable or TCPC driver is known
to trigger it.

Signed-off-by: Alexey Charkov <alchark@flipper.net>
---
 drivers/usb/typec/tcpm/tcpm.c | 74 ++++++++++++++++++++++++++++++++++++++++---
 1 file changed, 70 insertions(+), 4 deletions(-)

diff --git a/drivers/usb/typec/tcpm/tcpm.c b/drivers/usb/typec/tcpm/tcpm.c
index ab7ec5334564..f9fb915d98c1 100644
--- a/drivers/usb/typec/tcpm/tcpm.c
+++ b/drivers/usb/typec/tcpm/tcpm.c
@@ -682,6 +682,8 @@ struct tcpm_port {
 	 */
 	enum tcpm_transmit_type vdm_sop_type;
 	enum tcpm_transmit_type soft_reset_sop_type;
+	/* The Soft_Reset in SOFT_RESET_SEND went to the cable plug */
+	bool soft_reset_sent_prime;
 	/*
 	 * Prior to discovering the port partner's Specification Revision, the
 	 * Vconn source and cable plug will use the lower of their two revisions.
@@ -4177,6 +4179,64 @@ static void tcpm_pd_ext_msg_request(struct tcpm_port *port,
 	}
 }
 
+/* Whether a cable plug control message responds to what the port sent it */
+static bool tcpm_cable_ctrl_msg_expected(struct tcpm_port *port,
+					 enum pd_ctrl_msg_type type)
+{
+	switch (type) {
+	case PD_CTRL_ACCEPT:
+		/* the Soft_Reset after a VCONN Swap */
+		return port->state == SOFT_RESET_SEND &&
+		       port->soft_reset_sent_prime;
+	case PD_CTRL_NOT_SUPP:
+		/* a VDM, in the ready state, which takes it as the answer */
+		return port->vdm_sop_type == TCPC_TX_SOP_PRIME &&
+		       port->vdm_state > VDM_STATE_READY &&
+		       port->state == ready_state(port);
+	default:
+		return false;
+	}
+}
+
+/* Whether a cable plug VDM answers the one the port is waiting on */
+static bool tcpm_cable_vdm_expected(struct tcpm_port *port,
+				    const struct pd_message *msg)
+{
+	u32 vdo = le32_to_cpu(msg->payload[0]);
+
+	return port->vdm_sop_type == TCPC_TX_SOP_PRIME &&
+	       port->vdm_state == VDM_STATE_BUSY &&
+	       PD_VDO_SVDM(vdo) && PD_VDO_CMDT(vdo) != CMDT_INIT;
+}
+
+/*
+ * A cable plug only responds to the VCONN source: to its VDMs, and to its
+ * Soft_Reset. Hand those responses to the usual handlers, which tell SOP'
+ * apart where it matters, and drop anything else on SOP': it comes from a
+ * cable plug that breaks the rules, and no sequence has the port answer a
+ * cable plug.
+ */
+static void tcpm_pd_cable_msg_request(struct tcpm_port *port,
+				      const struct pd_message *msg)
+{
+	unsigned int type = pd_header_type_le(msg->header);
+	bool ext = le16_to_cpu(msg->header) & PD_HEADER_EXT_HDR;
+	bool ctrl = !ext && !pd_header_cnt_le(msg->header);
+
+	if (!ext && !ctrl && type == PD_DATA_VENDOR_DEF &&
+	    tcpm_cable_vdm_expected(port, msg)) {
+		tcpm_pd_data_request(port, msg, TCPC_TX_SOP_PRIME);
+		return;
+	}
+	if (ctrl && tcpm_cable_ctrl_msg_expected(port, type)) {
+		tcpm_pd_ctrl_request(port, msg, TCPC_TX_SOP_PRIME);
+		return;
+	}
+
+	tcpm_log(port, "Dropping unexpected SOP' message, header: %#x",
+		 le16_to_cpu(msg->header));
+}
+
 static void tcpm_pd_rx_handler(struct kthread_work *work)
 {
 	struct pd_rx_event *event = container_of(work,
@@ -4217,13 +4277,17 @@ static void tcpm_pd_rx_handler(struct kthread_work *work)
 			if (msgid == port->rx_msgid_prime)
 				goto done;
 			port->rx_msgid_prime = msgid;
-			break;
+			tcpm_pd_cable_msg_request(port, msg);
+			goto done;
 		case TCPC_TX_SOP:
-		default:
 			if (msgid == port->rx_msgid && type != PD_CTRL_SOFT_RESET)
 				goto done;
 			port->rx_msgid = msgid;
 			break;
+		default:
+			/* Neither for the port partner nor for a supported cable plug */
+			tcpm_log(port, "Dropping message on SOP* type %d", rx_sop_type);
+			goto done;
 		}
 
 		/*
@@ -4231,7 +4295,7 @@ static void tcpm_pd_rx_handler(struct kthread_work *work)
 		 * mismatch.
 		 */
 		if (!!(le16_to_cpu(msg->header) & PD_HEADER_DATA_ROLE) ==
-		    (port->data_role == TYPEC_HOST) && rx_sop_type == TCPC_TX_SOP) {
+		    (port->data_role == TYPEC_HOST)) {
 			tcpm_log(port,
 				 "Data role mismatch, initiating error recovery");
 			tcpm_set_state(port, ERROR_RECOVERY, 0);
@@ -6254,7 +6318,9 @@ static void run_state_machine(struct tcpm_port *port)
 		 * A Soft_Reset Message Shall be targeted at a specific entity
 		 * depending on the type of SOP* packet used.
 		 */
-		if (port->soft_reset_sop_type == TCPC_TX_SOP_PRIME) {
+		port->soft_reset_sent_prime =
+			port->soft_reset_sop_type == TCPC_TX_SOP_PRIME;
+		if (port->soft_reset_sent_prime) {
 			port->soft_reset_sop_type = TCPC_TX_SOP;
 			port->message_id_prime = 0;
 			port->rx_msgid_prime = -1;

-- 
2.56.0


^ permalink raw reply related	[flat|nested] 9+ messages in thread

* Re: [PATCH v2 1/4] usb: typec: tcpm: Keep the Soft_Reset target apart from the VDM one
  2026-11-18  7:26 ` [PATCH v2 1/4] usb: typec: tcpm: Keep the Soft_Reset target apart from the VDM one Alexey Charkov
@ 2026-11-18  7:32   ` sashiko-bot
  0 siblings, 0 replies; 9+ messages in thread
From: sashiko-bot @ 2026-11-18  7:32 UTC (permalink / raw)
  To: Alexey Charkov; +Cc: linux-usb

> tx_sop_type holds the SOP* of the VDM being sent, for its retries, and
> SOFT_RESET_SEND also reads it to tell a Soft_Reset for the cable plug,
> after a VCONN Swap, from one for the port partner. Nothing sets it back
> after a VDM, so once a VDM has gone to the cable plug, such as Discover
> Identity on SOP' before the first contract, every Soft_Reset meant for
> the port partner goes to the cable plug instead. The cable plug accepts
> it and the port goes back to its ready state, but the port partner never
> sees the Soft_Reset: a source whose Source_Capabilities got Not_Supported
> is then left without a contract. The VCONN Swap, in turn, overwrites the
> SOP* of a VDM that may still be pending. This left a FUSB302B-based
> source without a contract until it was unplugged, after its partner
> missed a message following Discover Identity to an e-marked cable.
> 
> Keep one target per context: vdm_sop_type for the VDM and its retries,
> and soft_reset_sop_type for the next Soft_Reset. Point the latter at the
> cable plug only for the VCONN Swap, only once, and back at SOP whenever
> the protocol layer starts over or a Soft_Reset of the port partner
> starts, along with the SOP' MessageID counters.
> 
> Fixes: 6bd181ba60e1 ("usb: typec: tcpm: add control message support to sop'")
> Cc: stable@vger.kernel.org
> Signed-off-by: Alexey Charkov <alchark@flipper.net>

Sashiko has reviewed this patch and found no issues.

-- 
Sashiko AI review · https://sashiko.dev/#/patchset/20261118-tcpm-soft-reset-sop-v2-0-b6decdc95e66@flipper.net?part=1


^ permalink raw reply	[flat|nested] 9+ messages in thread

* Re: [PATCH v2 2/4] usb: typec: tcpm: Stop replaying Source_Capabilities after cable discovery
  2026-11-18  7:26 ` [PATCH v2 2/4] usb: typec: tcpm: Stop replaying Source_Capabilities after cable discovery Alexey Charkov
@ 2026-11-18  7:39   ` sashiko-bot
  0 siblings, 0 replies; 9+ messages in thread
From: sashiko-bot @ 2026-11-18  7:39 UTC (permalink / raw)
  To: Alexey Charkov; +Cc: linux-usb

> When its first Source_Capabilities goes unacknowledged, a source that is
> the VCONN source asks the cable plug for its identity in
> SRC_VDM_IDENTITY_REQUEST. Entering that state sets upcoming_state to
> SRC_SEND_CAPABILITIES, for a message from the sink that interrupts it
> through SRC_READY. The ACK and send error paths go to
> SRC_SEND_CAPABILITIES directly and leave upcoming_state set, so the
> first SRC_READY after the contract sends Source_Capabilities again. The
> second negotiation can cut into the sink's own Discover Identity, and
> once ended in a Hard Reset between two FUSB302B ports.
> 
> Clear upcoming_state when SRC_SEND_CAPABILITIES follows
> SRC_VDM_IDENTITY_REQUEST directly.
> 
> Fixes: af8b627046bc ("usb: typec: tcpm: add state machine support for SRC_VDM_IDENTITY_REQUEST")
> Cc: stable@vger.kernel.org
> Signed-off-by: Alexey Charkov <alchark@flipper.net>

Sashiko has reviewed this patch and found no issues.

-- 
Sashiko AI review · https://sashiko.dev/#/patchset/20261118-tcpm-soft-reset-sop-v2-0-b6decdc95e66@flipper.net?part=2


^ permalink raw reply	[flat|nested] 9+ messages in thread

* Re: [PATCH v2 4/4] usb: typec: tcpm: Keep cable plug messages away from the port partner
  2026-11-18  7:26 ` [PATCH v2 4/4] usb: typec: tcpm: Keep cable plug messages away from the port partner Alexey Charkov
@ 2026-11-18  7:51   ` sashiko-bot
  0 siblings, 0 replies; 9+ messages in thread
From: sashiko-bot @ 2026-11-18  7:51 UTC (permalink / raw)
  To: Alexey Charkov; +Cc: linux-usb

Thank you for your contribution! Sashiko AI review found 3 potential
issues to consider:
- [Medium] usb: typec: tcpm: SOP' SVDMs in tcpm_cable_vdm_expected()
  still affect SOP
- [Medium] usb: typec: tcpm: tcpm_cable_ctrl_msg_expected() aborts
  unsent SOP' VDMs
- [Low] usb: typec: tcpm: stale soft_reset_sent_prime before
  run_state_machine()
--

commit 4c61156df43ba909af0892d17e05a01aa528ddf2
Author: Alexey Charkov <alchark@flipper.net>

usb: typec: tcpm: Keep cable plug messages away from the port partner

This commit filters incoming SOP' messages so that only expected VDM and
control responses from a cable plug are passed to the protocol handlers, and
drops messages on unsupported SOP* types before updating MessageID state.

> diff --git a/drivers/usb/typec/tcpm/tcpm.c b/drivers/usb/typec/tcpm/tcpm.c
> index cea9e6fc39c00..530186b51092f 100644
> --- a/drivers/usb/typec/tcpm/tcpm.c
> +++ b/drivers/usb/typec/tcpm/tcpm.c
> @@ -682,6 +682,8 @@ struct tcpm_port {
>  	 */
>  	enum tcpm_transmit_type vdm_sop_type;
>  	enum tcpm_transmit_type soft_reset_sop_type;
> +	/* The Soft_Reset in SOFT_RESET_SEND went to the cable plug */
> +	bool soft_reset_sent_prime;
>  	/*
>  	 * Prior to discovering the port partner's Specification Revision, the
>  	 * Vconn source and cable plug will use the lower of their two revisions.
> @@ -4179,6 +4181,64 @@ static void tcpm_pd_ext_msg_request(struct tcpm_port *port,
>  	}
>  }
>  
> +/* Whether a cable plug control message responds to what the port sent it */
> +static bool tcpm_cable_ctrl_msg_expected(struct tcpm_port *port,
> +					 enum pd_ctrl_msg_type type)
> +{
> +	switch (type) {
> +	case PD_CTRL_ACCEPT:
> +		/* the Soft_Reset after a VCONN Swap */
> +		return port->state == SOFT_RESET_SEND &&
> +		       port->soft_reset_sent_prime;
> +	case PD_CTRL_NOT_SUPP:
> +		/* a VDM, in the ready state, which takes it as the answer */
> +		return port->vdm_sop_type == TCPC_TX_SOP_PRIME &&
> +		       port->vdm_state > VDM_STATE_READY &&
> +		       port->state == ready_state(port);

[Severity: Medium]
Does checking port->vdm_state > VDM_STATE_READY allow an unsolicited SOP'
PD_CTRL_NOT_SUPP to cancel a VDM that has not been sent yet?

In enum vdm_states, VDM_STATE_WAIT_RSP_BUSY and VDM_STATE_SEND_MESSAGE are
both greater than VDM_STATE_READY.  When a PD 3.0 source queues an SOP' SVDM
in SRC_READY, vdm_run_state_machine() waits PD_T_SINK_TX in
VDM_STATE_SEND_MESSAGE before transmitting the message and clearing
port->vdo_data[0].  An unsolicited SOP' PD_CTRL_NOT_SUPP during that window
passes this check and reaches tcpm_pd_ctrl_request(), which sets
port->vdm_state to VDM_STATE_DONE, finishes the AMS without sending the VDM
or running the VDM_STATE_ERR_SEND fallback to partner discovery, and leaves
port->vdo_data[0] non-zero.

Checking port->vdm_state == VDM_STATE_BUSY, as tcpm_cable_vdm_expected()
does, would only accept Not_Supported while waiting for a response to a VDM
already on the wire.

> +	default:
> +		return false;
> +	}
> +}
> +
> +/* Whether a cable plug VDM answers the one the port is waiting on */
> +static bool tcpm_cable_vdm_expected(struct tcpm_port *port,
> +				    const struct pd_message *msg)
> +{
> +	u32 vdo = le32_to_cpu(msg->payload[0]);
> +
> +	return port->vdm_sop_type == TCPC_TX_SOP_PRIME &&
> +	       port->vdm_state == VDM_STATE_BUSY &&
> +	       PD_VDO_SVDM(vdo) && PD_VDO_CMDT(vdo) != CMDT_INIT;
> +}

[Severity: Medium]
Can a malformed SOP' SVDM response that passes tcpm_cable_vdm_expected()
still trigger transmissions to the port partner on SOP or corrupt partner
discovery state?

tcpm_cable_vdm_expected() checks neither the command nor the SVID against
 the pending SOP' request.  Once passed to tcpm_handle_vdm_request() ->
tcpm_pd_svdm(), response_tx_sop_type defaults to TCPC_TX_SOP:

drivers/usb/typec/tcpm/tcpm.c:tcpm_pd_svdm() {
    ...
		default:
			/* Unrecognized SVDM */
			response[0] = p[0] | VDO_CMDT(CMDT_RSP_NAK);
			rlen = 1;
			response[0] = (response[0] & ~VDO_SVDM_VERS_MASK) |
				      (VDO_SVDM_VERS(svdm_version));
			break;
		}
		break;
	case CMDT_RSP_NAK:
		tcpm_ams_finish(port);
		/* Go on with Source_Capabilities, as after an ACK */
		if (port->state == SRC_VDM_IDENTITY_REQUEST &&
		    rx_sop_type == TCPC_TX_SOP_PRIME) {
			tcpm_set_state(port, SRC_SEND_CAPABILITIES, 0);
			return 0;
		}
		switch (cmd) {
		/*
		 * The cable is not allowed to respond with NAK so this must've happened over SOP
		 */
		case CMD_DISCOVER_IDENT:
		case CMD_DISCOVER_SVID:
			tcpm_update_vdm_discovery_state(port, VDM_DISCOVERY_COMPLETE);
			break;
    ...
}

If the cable plug replies on SOP' with an unrecognized command (such as
CMD_ATTENTION with CMDT_RSP_ACK or CMD_EXIT_MODE with CMDT_RSP_NAK), the
default branches set rlen = 1 without updating response_tx_sop_type, so
tcpm_handle_vdm_request() queues a VDM NAK on TCPC_TX_SOP to the port
partner.  Similarly, if tcpm_vdm_ams(port) is false when the SOP' VDM
arrives (for instance, after a partner AMS interrupted port->ams), the else
branch in tcpm_handle_vdm_request() sends PD_MSG_CTRL_NOT_SUPP on SOP.

In addition, a CMDT_RSP_NAK on SOP' for CMD_DISCOVER_IDENT or
CMD_DISCOVER_SVID in SRC_READY/SNK_READY marks VDM_DISCOVERY_COMPLETE and
skips partner SVID discovery or partner altmode registration, and an
unexpected CMD_DISCOVER_MODES ACK on SOP' before CMD_DISCOVER_IDENT
registers port->plug_prime reaches tcpm_register_plug_altmodes() with
port->plug_prime == NULL.

[ ... ]

> @@ -6256,7 +6320,9 @@ static void run_state_machine(struct tcpm_port *port)
>  		 * A Soft_Reset Message Shall be targeted at a specific entity
>  		 * depending on the type of SOP* packet used.
>  		 */
> -		if (port->soft_reset_sop_type == TCPC_TX_SOP_PRIME) {
> +		port->soft_reset_sent_prime =
> +			port->soft_reset_sop_type == TCPC_TX_SOP_PRIME;
> +		if (port->soft_reset_sent_prime) {
>  			port->soft_reset_sop_type = TCPC_TX_SOP;
>  			port->message_id_prime = 0;
>  			port->rx_msgid_prime = -1;

[Severity: Low]
Can a stale port->soft_reset_sent_prime allow an unsolicited SOP'
PD_CTRL_ACCEPT to cancel a later SOP SOFT_RESET_SEND before
run_state_machine() runs?

After an SOP' Soft_Reset following a VCONN swap, port->soft_reset_sent_prime
remains true until the next time run_state_machine() executes
SOFT_RESET_SEND.  If tcpm_pd_ext_msg_request() later calls
tcpm_set_state(port, SOFT_RESET_SEND, 0) for a malformed SOP
PD_EXT_GET_BATT_STATUS or PD_EXT_GET_BATT_CAP message, port->state becomes
SOFT_RESET_SEND immediately while port->state_machine is queued on port->wq.
An SOP' PD_CTRL_ACCEPT already queued ahead of it on port->wq will then pass
tcpm_cable_ctrl_msg_expected() and transition the port back to
ready_state(port) before the SOP Soft_Reset is sent.

-- 
Sashiko AI review · https://sashiko.dev/#/patchset/20261118-tcpm-soft-reset-sop-v2-0-b6decdc95e66@flipper.net?part=4

^ permalink raw reply	[flat|nested] 9+ messages in thread

* Re: [PATCH v2 3/4] usb: typec: tcpm: Leave SRC_VDM_IDENTITY_REQUEST whatever the cable answers
  2026-11-18  7:26 ` [PATCH v2 3/4] usb: typec: tcpm: Leave SRC_VDM_IDENTITY_REQUEST whatever the cable answers Alexey Charkov
@ 2026-11-18  8:08   ` sashiko-bot
  0 siblings, 0 replies; 9+ messages in thread
From: sashiko-bot @ 2026-11-18  8:08 UTC (permalink / raw)
  To: Alexey Charkov; +Cc: linux-usb

Thank you for your contribution! Sashiko AI review found 2 potential
issues to consider:
- [Medium] usb: typec: tcpm: partner SVID discovery aborted on SOP' NAK
  or timeout
- [Low] usb: typec: tcpm: incomplete SOP' VDM cleanup in
  run_state_machine()
--

commit b9c2fd6cef3c4af3dcadaf4f8b5d0a17a94ce0f2
Author: Alexey Charkov <alchark@flipper.net>

usb: typec: tcpm: Leave SRC_VDM_IDENTITY_REQUEST whatever the cable answers

This commit transitions the state machine from SRC_VDM_IDENTITY_REQUEST to
SRC_SEND_CAPABILITIES on a cable plug NAK, BUSY, response timeout, or
tTypeCSendSourceCap timeout, and cleans up any pending SOP' VDM request
when entering SRC_SEND_CAPABILITIES.

> diff --git a/drivers/usb/typec/tcpm/tcpm.c b/drivers/usb/typec/tcpm/tcpm.c
> index eb30b6efa5a14..cea9e6fc39c00 100644
> --- a/drivers/usb/typec/tcpm/tcpm.c
> +++ b/drivers/usb/typec/tcpm.c
> @@ -2747,6 +2747,12 @@ static int tcpm_pd_svdm(struct tcpm_port *port, struct typec_altmode *adev,
>  		break;
>  	case CMDT_RSP_NAK:
>  		tcpm_ams_finish(port);
> +		/* Go on with Source_Capabilities, as after an ACK */
> +		if (port->state == SRC_VDM_IDENTITY_REQUEST &&
> +		    rx_sop_type == TCPC_TX_SOP_PRIME) {
> +			tcpm_set_state(port, SRC_SEND_CAPABILITIES, 0);
> +			return 0;
> +		}
>  		switch (cmd) {
>  		/*
>  		 * The cable is not allowed to respond with NAK so this must've happened over SOP

[ ... ]

> @@ -3041,6 +3052,8 @@ static void vdm_run_state_machine(struct tcpm_port *port)
>  		port->vdm_state = VDM_STATE_ERR_TMOUT;
>  		if (port->ams != NONE_AMS)
>  			tcpm_ams_finish(port);
> +		if (port->state == SRC_VDM_IDENTITY_REQUEST)
> +			tcpm_set_state(port, SRC_SEND_CAPABILITIES, 0);
>  		break;
>  	case VDM_STATE_ERR_SEND:
>  		/*

[Severity: Medium]
Does partner SVID and alternate mode discovery still get aborted when a
cable plug replies with CMDT_RSP_NAK or times out in VDM_STATE_BUSY?

Moving to SRC_SEND_CAPABILITIES here leaves port->cable as NULL. Once the
explicit contract is established in SRC_READY and the port partner ACKs
CMD_DISCOVER_IDENT over TCPC_TX_SOP, tcpm_pd_svdm() sees
IS_ERR_OR_NULL(port->cable) and sends CMD_DISCOVER_IDENT on
TCPC_TX_SOP_PRIME again while port->state is SRC_READY:

drivers/usb/typec/tcpm/tcpm.c:tcpm_pd_svdm() {
    ...
				if (IS_ERR_OR_NULL(port->cable) &&
				    tcpm_can_communicate_sop_prime(port)) {
					*response_tx_sop_type = TCPC_TX_SOP_PRIME;
					response[0] = VDO(USB_SID_PD, 1,
							  typec_get_negotiated_svdm_version(typec),
							  CMD_DISCOVER_IDENT);
					rlen = 1;
				}
    ...
}

When that second SOP' request receives CMDT_RSP_NAK in SRC_READY,
port->state == SRC_VDM_IDENTITY_REQUEST is false, so tcpm_pd_svdm() falls
through to case CMD_DISCOVER_IDENT and sets VDM_DISCOVERY_COMPLETE without
sending CMD_DISCOVER_SVID to the partner. Likewise, if that SOP' request
times out in VDM_STATE_BUSY in SRC_READY, vdm_run_state_machine() sets
VDM_STATE_ERR_TMOUT without advancing to VDM_DISCOVERY_CABLE_IDENT or
queueing CMD_DISCOVER_SVID on TCPC_TX_SOP (unlike VDM_STATE_ERR_SEND).

[ ... ]

> @@ -5550,8 +5563,18 @@ static void run_state_machine(struct tcpm_port *port)
>  		 * Straight from Discover Identity to the cable plug, rather
>  		 * than back through SRC_READY after a message from the sink
>  		 */
> -		if (port->prev_state == SRC_VDM_IDENTITY_REQUEST)
> +		if (port->prev_state == SRC_VDM_IDENTITY_REQUEST) {
>  			port->upcoming_state = INVALID_STATE;
> +			/* Forget the request if still waiting on the cable plug */
> +			if (port->vdm_sop_type == TCPC_TX_SOP_PRIME &&
> +			    port->vdm_state > VDM_STATE_DONE) {
> +				port->vdm_state = VDM_STATE_DONE;
> +				port->vdo_data[0] = 0;
> +				mod_vdm_delayed_work(port, 0);
> +			}
> +			if (port->ams == DISCOVER_IDENTITY)
> +				tcpm_ams_finish(port);
> +		}
>  		port->caps_count++;
>  		if (port->caps_count > PD_N_CAPS_COUNT) {
>  			tcpm_set_state(port, SRC_READY, 0);

[Severity: Low]
Can gating this cleanup on port->prev_state == SRC_VDM_IDENTITY_REQUEST
skip cancelling a pending SOP' VDM when an incoming SOP message from the
sink interrupts SRC_VDM_IDENTITY_REQUEST?

In that case tcpm_pd_handle_msg() transitions SRC_VDM_IDENTITY_REQUEST ->
SRC_READY -> SRC_SEND_CAPABILITIES, so port->prev_state is SRC_READY. For
example, if an unstructured VDM arrives on SOP while vdm_state is waiting
in VDM_STATE_SEND_MESSAGE (PD_T_SINK_TX), tcpm_handle_vdm_request() calls
tcpm_pd_handle_msg(port, PD_MSG_CTRL_NOT_SUPP, NONE_AMS) without resetting
vdm_state, leaving the SOP' VDM timer armed and port->vdo_data[0] set
when SRC_SEND_CAPABILITIES is entered via SRC_READY.

-- 
Sashiko AI review · https://sashiko.dev/#/patchset/20261118-tcpm-soft-reset-sop-v2-0-b6decdc95e66@flipper.net?part=3

^ permalink raw reply	[flat|nested] 9+ messages in thread

end of thread, other threads:[~2026-11-18  8:08 UTC | newest]

Thread overview: 9+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2026-11-18  7:26 [PATCH v2 0/4] usb: typec: tcpm: Fixes for talking to the cable plug as a VCONN source Alexey Charkov
2026-11-18  7:26 ` [PATCH v2 1/4] usb: typec: tcpm: Keep the Soft_Reset target apart from the VDM one Alexey Charkov
2026-11-18  7:32   ` sashiko-bot
2026-11-18  7:26 ` [PATCH v2 2/4] usb: typec: tcpm: Stop replaying Source_Capabilities after cable discovery Alexey Charkov
2026-11-18  7:39   ` sashiko-bot
2026-11-18  7:26 ` [PATCH v2 3/4] usb: typec: tcpm: Leave SRC_VDM_IDENTITY_REQUEST whatever the cable answers Alexey Charkov
2026-11-18  8:08   ` sashiko-bot
2026-11-18  7:26 ` [PATCH v2 4/4] usb: typec: tcpm: Keep cable plug messages away from the port partner Alexey Charkov
2026-11-18  7:51   ` sashiko-bot

This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.