* [PATCH v9 1/3] dt-bindings: usb: snps,dwc3: two connectors are two endpoints of one port
2026-11-17 5:21 [PATCH v9 0/3] usb: dwc3: support two connectors sharing one HS data bus Qianhui Xu
@ 2026-11-17 5:21 ` Qianhui Xu
2026-11-17 5:40 ` sashiko-bot
2026-11-17 5:21 ` [PATCH v9 2/3] usb: roles: look up role switches attached to a graph endpoint Qianhui Xu
2026-11-17 5:21 ` [PATCH v9 3/3] usb: dwc3: select the shared HS data bus with a mux controller Qianhui Xu
2 siblings, 1 reply; 6+ messages in thread
From: Qianhui Xu @ 2026-11-17 5:21 UTC (permalink / raw)
To: Greg Kroah-Hartman, Thinh Nguyen, Rob Herring,
Krzysztof Kozlowski, Conor Dooley
Cc: linux-usb, devicetree, linux-arm-msm, linux-kernel
Rework of the v8 binding per Rob Herring's review of
2026-11-10 16:36Z (<20261110163640.GA85824-robh@kernel.org>):
"ports are for separate data streams. Endpoints are for mux'ed data
streams. This looks like the latter, so port@0 should have 2 endpoints
and port@2 dropped."
and, for the GPIO property:
"Use the gpio mux binding."
Two connectors sharing one High Speed D+/D- pair are two mux'ed data
streams of one port, so they become endpoint@0 and endpoint@1 of port@0
(the Super Speed lane stays port@1). The GPIO that selects between them
is no longer described by a private "port-select-gpios" property but by a
"gpio-mux" controller referenced from "mux-controls", and the endpoint of
each connector carries the mux state that reaches it.
*** AI-assistance disclosure ***
This patch was prepared with the help of an LLM coding assistant. The
author reviewed every line and ran the gates quoted in the series notes.
Signed-off-by: Qianhui Xu <xiaqinghuan@mail.ustc.edu.cn>
---
DRAFT: driver (3/3) still uses a GPIO and must be ported to mux_control_*
in the same series; DTS (2/3 equivalent) must be rewritten to the new
shape. See README.md in this directory.
--- a/Documentation/devicetree/bindings/usb/snps,dwc3-common.yaml
+++ b/Documentation/devicetree/bindings/usb/snps,dwc3-common.yaml
@@ -13,6 +13,84 @@ description:
Defines the properties of the DWC3 core as being embedded in either an
vendor-specific implementation or as a standalone component.
+$defs:
+ hs-endpoint:
+ $ref: /schemas/graph.yaml#/$defs/endpoint-base
+ unevaluatedProperties: false
+
+ properties:
+ usb-role-switch:
+ type: boolean
+ description:
+ This connector endpoint has its own USB role switch. The switch is
+ registered against this endpoint and looked up with
+ usb_role_switch_at_endpoint().
+
+ mux-state:
+ $ref: /schemas/types.yaml#/definitions/uint32
+ enum: [0, 1]
+ description:
+ State of the High Speed data bus multiplexer which connects this
+ connector to the controller. The two connectors of one controller
+ must use different states; the driver rejects a device tree where
+ two connectors claim the same one.
+
+ dependentRequired:
+ usb-role-switch: [mux-state]
+ mux-state: [usb-role-switch]
+
+ hs-port:
+ $ref: /schemas/graph.yaml#/$defs/port-base
+ unevaluatedProperties: false
+
+ # The two connectors are two mux'ed data streams of the same High Speed
+ # bus, so they are two endpoints of one port, not two ports: "ports"
+ # describes the controller's own data streams (HS in port@0, SS in
+ # port@1), and an endpoint describes one stream multiplexed onto a port.
+ properties:
+ '#address-cells':
+ const: 1
+
+ '#size-cells':
+ const: 0
+
+ endpoint@0:
+ $ref: '#/$defs/hs-endpoint'
+ required: [reg]
+
+ endpoint@1:
+ $ref: '#/$defs/hs-endpoint'
+ required: [reg]
+
+ required: ['#address-cells', '#size-cells', endpoint@0, endpoint@1]
+
+ # The two connectors must claim opposite mux states; requiring both
+ # endpoints in every branch is what makes the two cases mutually
+ # exclusive for oneOf.
+ oneOf:
+ - properties:
+ endpoint@0:
+ properties:
+ mux-state:
+ $ref: /schemas/types.yaml#/definitions/uint32
+ const: 0
+ endpoint@1:
+ properties:
+ mux-state:
+ $ref: /schemas/types.yaml#/definitions/uint32
+ const: 1
+ - properties:
+ endpoint@0:
+ properties:
+ mux-state:
+ $ref: /schemas/types.yaml#/definitions/uint32
+ const: 1
+ endpoint@1:
+ properties:
+ mux-state:
+ $ref: /schemas/types.yaml#/definitions/uint32
+ const: 0
+
allOf:
- $ref: usb-drd.yaml#
- if:
@@ -26,8 +104,47 @@ allOf:
$ref: usb.yaml#
else:
$ref: usb-xhci.yaml#
+ - if:
+ required: [mux-controls]
+ then:
+ # The mux path is only taken when the controller itself carries
+ # "usb-role-switch": dwc3_get_dr_mode() forces dr_mode back to
+ # peripheral, dwc3_get_extcon() skips the role-switch branch and
+ # dwc3_drd_init() never sets the mux up without it.
+ required: [dr_mode, ports, usb-role-switch]
+ properties:
+ dr_mode:
+ const: otg
+ ports:
+ required: [port@0]
+ properties:
+ port@0:
+ $ref: '#/$defs/hs-port'
+ else:
+ properties:
+ ports:
+ properties:
+ port@0:
+ properties:
+ endpoint@0:
+ properties:
+ usb-role-switch: false
+ mux-state: false
+ endpoint@1:
+ properties:
+ usb-role-switch: false
+ mux-state: false
properties:
+ mux-controls:
+ maxItems: 1
+ description:
+ Phandle to the multiplexer that selects which of the two connectors
+ drives the controller's shared High Speed data bus, e.g. a
+ "gpio-mux" controller. Each connector is described by the endpoint@0
+ or endpoint@1 of "port@0", and the endpoint of that connector carries
+ its own role-switch input and the "mux-state" it is reached in.
+
extcon:
maxItems: 1
deprecated: true
@@ -411,7 +528,7 @@ properties:
properties:
port@0:
- $ref: /schemas/graph.yaml#/properties/port
+ $ref: '#/$defs/hs-port'
description: High Speed (HS) data bus.
port@1:
@@ -429,4 +546,3 @@ required:
additionalProperties: true
...
-
^ permalink raw reply [flat|nested] 6+ messages in thread* [PATCH v9 2/3] usb: roles: look up role switches attached to a graph endpoint
2026-11-17 5:21 [PATCH v9 0/3] usb: dwc3: support two connectors sharing one HS data bus Qianhui Xu
2026-11-17 5:21 ` [PATCH v9 1/3] dt-bindings: usb: snps,dwc3: two connectors are two endpoints of one port Qianhui Xu
@ 2026-11-17 5:21 ` Qianhui Xu
2026-11-17 5:21 ` [PATCH v9 3/3] usb: dwc3: select the shared HS data bus with a mux controller Qianhui Xu
2 siblings, 0 replies; 6+ messages in thread
From: Qianhui Xu @ 2026-11-17 5:21 UTC (permalink / raw)
To: Greg Kroah-Hartman, Thinh Nguyen, Rob Herring,
Krzysztof Kozlowski, Conor Dooley
Cc: linux-usb, devicetree, linux-arm-msm, linux-kernel
usb_role_switch_get() and fwnode_usb_role_switch_get() look for a switch
on the caller's parent device node or through device_connection. That does
not work when one controller exposes a role switch per connector endpoint:
the switch is registered against the remote graph endpoint and the
consumer, the connector, has no phandle to it.
Add usb_role_switch_at_endpoint(), which walks the caller's OF graph
endpoints and matches a switch registered on the remote endpoint, and try
it after the existing parent lookup. A switch that is described by the
graph but not registered yet comes back as -EPROBE_DEFER, as the rest of
the role-switch API does, so the caller retries instead of concluding that
the connector has no role switch at all. There is no behaviour change for
existing users: if nothing is registered against an endpoint the lookup
falls through to the previous paths.
This is needed by DWC3 designs where two Type-C receptacles share one High
Speed data bus.
Signed-off-by: Qianhui Xu <xiaqinghuan@mail.ustc.edu.cn>
---
drivers/usb/roles/class.c | 45 +++++++++++++++++++++++++++++++++++++++
1 file changed, 45 insertions(+)
diff --git a/drivers/usb/roles/class.c b/drivers/usb/roles/class.c
index edec139b68..ee186d542a 100644
--- a/drivers/usb/roles/class.c
+++ b/drivers/usb/roles/class.c
@@ -157,6 +157,47 @@ usb_role_switch_is_parent(struct fwnode_handle *fwnode)
return dev ? to_role_switch(dev) : ERR_PTR(-EPROBE_DEFER);
}
+/*
+ * Look up a role switch registered against the remote endpoint of one of the
+ * caller's OF graph endpoints. This is how a connector endpoint that shares a
+ * USB data bus with another connector (for example two Type-C receptacles on a
+ * single DWC3 controller, selected by a GPIO mux) finds its own role switch.
+ */
+static struct usb_role_switch *
+usb_role_switch_at_endpoint(struct fwnode_handle *fwnode)
+{
+ struct fwnode_handle *ep, *remote, *parent;
+ struct usb_role_switch *sw;
+ bool available;
+
+ fwnode_graph_for_each_endpoint(fwnode, ep) {
+ parent = fwnode_graph_get_remote_port_parent(ep);
+ if (!parent)
+ continue;
+ available = fwnode_device_is_available(parent);
+ fwnode_handle_put(parent);
+ if (!available)
+ continue;
+
+ remote = fwnode_graph_get_remote_endpoint(ep);
+ if (!remote)
+ continue;
+ sw = usb_role_switch_match(remote, "usb-role-switch", NULL);
+ fwnode_handle_put(remote);
+ /*
+ * ERR_PTR(-EPROBE_DEFER) means the switch is described by the graph
+ * but not registered yet: pass it up so the caller defers instead of
+ * concluding that this connector has no role switch at all.
+ */
+ if (sw) {
+ fwnode_handle_put(ep);
+ return sw;
+ }
+ }
+
+ return NULL;
+}
+
/**
* usb_role_switch_get - Find USB role switch linked with the caller
* @dev: The caller device
@@ -169,6 +210,8 @@ struct usb_role_switch *usb_role_switch_get(struct device *dev)
struct usb_role_switch *sw;
sw = usb_role_switch_is_parent(dev_fwnode(dev));
+ if (!sw)
+ sw = usb_role_switch_at_endpoint(dev_fwnode(dev));
if (!sw)
sw = device_connection_find_match(dev, "usb-role-switch", NULL,
usb_role_switch_match);
@@ -192,6 +235,8 @@ struct usb_role_switch *fwnode_usb_role_switch_get(struct fwnode_handle *fwnode)
struct usb_role_switch *sw;
sw = usb_role_switch_is_parent(fwnode);
+ if (!sw)
+ sw = usb_role_switch_at_endpoint(fwnode);
if (!sw)
sw = fwnode_connection_find_match(fwnode, "usb-role-switch",
NULL, usb_role_switch_match);
^ permalink raw reply related [flat|nested] 6+ messages in thread* [PATCH v9 3/3] usb: dwc3: select the shared HS data bus with a mux controller
2026-11-17 5:21 [PATCH v9 0/3] usb: dwc3: support two connectors sharing one HS data bus Qianhui Xu
2026-11-17 5:21 ` [PATCH v9 1/3] dt-bindings: usb: snps,dwc3: two connectors are two endpoints of one port Qianhui Xu
2026-11-17 5:21 ` [PATCH v9 2/3] usb: roles: look up role switches attached to a graph endpoint Qianhui Xu
@ 2026-11-17 5:21 ` Qianhui Xu
2026-11-17 5:37 ` sashiko-bot
2 siblings, 1 reply; 6+ messages in thread
From: Qianhui Xu @ 2026-11-17 5:21 UTC (permalink / raw)
To: Greg Kroah-Hartman, Thinh Nguyen, Rob Herring,
Krzysztof Kozlowski, Conor Dooley
Cc: linux-usb, devicetree, linux-arm-msm, linux-kernel
Respond to Rob's review of v8: drop the private "port-select-gpios"
property and drive the shared High Speed data path through a mux
controller instead ("Use the gpio mux binding").
The connector to drive is still published per endpoint via "mux-state";
dwc3_role_mux_init() now requires the "mux-controls" property and gets
the controller with devm_mux_control_get(). A mux controller cannot be
read back, so the boot-time connector can no longer be detected: the
initial mode request claims the mux for state 0 instead, which is the
first mode request that reaches __dwc3_set_mode() after probe.
mux_control_select() sleeps while waiting for the controller, and
mux_control_deselect() may sleep as well. Both are only ever called
from __dwc3_set_mode(), which runs as a work item on
system_freezable_wq; the role-switch set() callback keeps recording the
request and never touches the mux directly. The mux is kept selected
between switches, since the controller always drives exactly one of the
two connectors.
This rework does not change the arbitration, the publication ordering
or the teardown rules introduced in v7/v8.
Signed-off-by: Qianhui Xu <xiaqinghuan@mail.ustc.edu.cn>
---
diff --git a/drivers/usb/dwc3/core.c b/drivers/usb/dwc3/core.c
index fd5c2cd..fe8e97d 100644
--- a/drivers/usb/dwc3/core.c
+++ b/drivers/usb/dwc3/core.c
@@ -21,6 +21,7 @@
#include <linux/io.h>
#include <linux/list.h>
#include <linux/delay.h>
+#include <linux/mux/consumer.h>
#include <linux/dma-mapping.h>
#include <linux/of.h>
#include <linux/of_graph.h>
@@ -165,7 +166,10 @@ EXPORT_SYMBOL_GPL(dwc3_set_prtcap);
static void __dwc3_set_mode(struct work_struct *work)
{
struct dwc3 *dwc = work_to_dwc(work);
+ struct dwc3_role_mux *mux = dwc->role_mux;
unsigned long flags;
+ bool pending, port_switch;
+ int mux_port = 0;
int ret;
u32 reg;
u32 desired_dr_role;
@@ -174,6 +178,8 @@ static void __dwc3_set_mode(struct work_struct *work)
mutex_lock(&dwc->mutex);
spin_lock_irqsave(&dwc->lock, flags);
desired_dr_role = dwc->desired_dr_role;
+ if (mux)
+ mux_port = mux->desired_port;
spin_unlock_irqrestore(&dwc->lock, flags);
pm_runtime_get_sync(dwc->dev);
@@ -184,7 +190,14 @@ static void __dwc3_set_mode(struct work_struct *work)
if (!desired_dr_role)
goto out;
- if (desired_dr_role == dwc->current_dr_role)
+ /*
+ * Moving the shared data path to the other connector is a mode switch even
+ * when the role does not change: the running host or gadget instance has to
+ * be torn down while its own data lines are still selected.
+ */
+ port_switch = mux && mux_port != mux->active_port;
+
+ if (desired_dr_role == dwc->current_dr_role && !port_switch)
goto out;
if (desired_dr_role == DWC3_GCTL_PRTCAP_OTG && dwc->edev)
@@ -233,8 +246,47 @@ static void __dwc3_set_mode(struct work_struct *work)
dwc3_writel(dwc, DWC3_GCTL, reg);
}
+ /*
+ * The previous host or gadget instance has been torn down above, so the
+ * shared High Speed data path can now be moved to the requesting
+ * connector. A failure here must not abort the mode change half-way:
+ * the controller would be left with a torn-down role and a stale
+ * current_dr_role, which the next request would tear down a second time.
+ */
+ if (port_switch) {
+ /*
+ * mux_control_select() sleeps while waiting for the controller, so
+ * the switch is only done here, in the mode worker. The mux is kept
+ * selected between switches: dwc3 is its only consumer and always
+ * drives one of the two connectors.
+ */
+ mux_control_deselect(mux->ctrl);
+ ret = mux_control_select(mux->ctrl, mux_port);
+ if (ret)
+ dev_err_ratelimited(dwc->dev,
+ "failed to select USB port %d: %d\n",
+ mux_port, ret);
+
+ spin_lock_irqsave(&dwc->lock, flags);
+ if (ret)
+ mux->ports[mux_port].errors++;
+ else
+ mux->active_port = mux_port;
+ spin_unlock_irqrestore(&dwc->lock, flags);
+ }
+
spin_lock_irqsave(&dwc->lock, flags);
+ /*
+ * dwc3_set_prtcap() only clears GUSB3PIPECTL.SUSPENDENABLE and
+ * GUSB2PHYCFG.SUSPHY when PRTCAP actually changes, but a same-role port
+ * switch reinitialises the controller too and must start from the same
+ * state: the instance created below would otherwise inherit the SUSPHY
+ * setting of the one torn down above.
+ */
+ if (port_switch)
+ dwc3_enable_susphy(dwc, false);
+
dwc3_set_prtcap(dwc, desired_dr_role, false);
spin_unlock_irqrestore(&dwc->lock, flags);
@@ -283,24 +335,68 @@ static void __dwc3_set_mode(struct work_struct *work)
}
out:
+ /*
+ * A request that arrived while this work was running did not re-queue it:
+ * queue_work() returns false for a work item that is already running. Pick
+ * such a request up here instead of waiting for the next connector event.
+ * The pair is compared with the snapshot taken above, so a data-path switch
+ * that failed is not retried in a loop.
+ */
+ if (mux) {
+ spin_lock_irqsave(&dwc->lock, flags);
+ pending = dwc->desired_dr_role != desired_dr_role ||
+ mux->desired_port != mux_port;
+ spin_unlock_irqrestore(&dwc->lock, flags);
+ if (pending)
+ queue_work(system_freezable_wq, &dwc->drd_work);
+ }
+
pm_runtime_put_autosuspend(dwc->dev);
mutex_unlock(&dwc->mutex);
}
-void dwc3_set_mode(struct dwc3 *dwc, u32 mode)
+static void dwc3_queue_mode(struct dwc3 *dwc, u32 mode, int port)
{
unsigned long flags;
if (dwc->dr_mode != USB_DR_MODE_OTG)
return;
+ /*
+ * The connector that owns the shared data path is published together with
+ * the mode request: __dwc3_set_mode() snapshots both under dwc->lock, and
+ * a torn pair would move the data path for the connector that asked last
+ * while bringing up the role requested by the one before it.
+ */
spin_lock_irqsave(&dwc->lock, flags);
dwc->desired_dr_role = mode;
+ if (dwc->role_mux && port >= 0)
+ dwc->role_mux->desired_port = port;
spin_unlock_irqrestore(&dwc->lock, flags);
queue_work(system_freezable_wq, &dwc->drd_work);
}
+void dwc3_set_mode(struct dwc3 *dwc, u32 mode)
+{
+ dwc3_queue_mode(dwc, mode, -1);
+}
+
+/**
+ * dwc3_set_mode_port - request a mode and the connector that owns the data path
+ * @dwc: pointer to our controller context structure
+ * @mode: mode to be requested
+ * @port: index of the connector that should drive the shared data path
+ *
+ * Same as dwc3_set_mode(), except that the data-path selection is published
+ * atomically with the mode request, so the mode worker never pairs the new
+ * connector with the previous role.
+ */
+void dwc3_set_mode_port(struct dwc3 *dwc, u32 mode, int port)
+{
+ dwc3_queue_mode(dwc, mode, port);
+}
+
u32 dwc3_core_fifo_space(struct dwc3_ep *dep, u8 type)
{
struct dwc3 *dwc = dep->dwc;
diff --git a/drivers/usb/dwc3/core.h b/drivers/usb/dwc3/core.h
index f3dabb3..e6cf7b2 100644
--- a/drivers/usb/dwc3/core.h
+++ b/drivers/usb/dwc3/core.h
@@ -1008,6 +1008,46 @@ struct dwc3_glue_ops {
void (*pre_run_stop)(struct dwc3 *dwc, bool is_on);
};
+/* Per-connector state of the optional shared-HS-data-bus mux. */
+struct dwc3_role_port {
+ struct dwc3 *dwc;
+ struct usb_role_switch *sw;
+ struct fwnode_handle *fwnode;
+ enum usb_role role;
+ unsigned int state;
+ /* request order, see dwc3_role_mux.seq */
+ u64 seq;
+ /* data-path switch failures, for diagnostics only */
+ unsigned int errors;
+};
+
+/**
+ * struct dwc3_role_mux - optional data-path mux between two connectors
+ * @ctrl: mux controller selecting which connector drives the shared HS data lines
+ * @lock: serialises role requests coming from both connectors
+ * @ready: both switches registered and the initial mode request issued
+ * @ports: per-connector state, indexed by the endpoint's "mux-state"
+ * @desired_port: index of the connector that currently wins
+ * @active_port: index of the connector currently driving the data lines
+ * @seq: monotonic request counter used to order pending requests
+ *
+ * Two connectors can share the High Speed data lines of one controller while
+ * keeping their Super Speed lanes separate. Each connector then needs its own
+ * role-switch input, and the shared data path has to be moved before the
+ * controller is reinitialised for the requested role.
+ */
+struct dwc3_role_mux {
+ struct mux_control *ctrl;
+ /* serialises role requests coming from both connectors */
+ struct mutex lock;
+ /* false until both switches are registered and the mode was requested */
+ bool ready;
+ struct dwc3_role_port ports[2];
+ int desired_port;
+ int active_port;
+ u64 seq;
+};
+
/**
* struct dwc3 - representation of our controller
* @drd_work: workqueue used for role swapping
@@ -1064,6 +1104,7 @@ struct dwc3_glue_ops {
* - USBPHY_INTERFACE_MODE_UTMI
* - USBPHY_INTERFACE_MODE_UTMIW
* @role_sw: usb_role_switch handle
+ * @role_mux: optional shared data-path mux plus per-connector role switches
* @role_switch_default_mode: default operation mode of controller while
* usb role is USB_ROLE_NONE.
* @usb_psy: pointer to power supply interface.
@@ -1265,6 +1306,7 @@ struct dwc3 {
struct notifier_block edev_nb;
enum usb_phy_interface hsphy_mode;
struct usb_role_switch *role_sw;
+ struct dwc3_role_mux *role_mux;
enum usb_dr_mode role_switch_default_mode;
struct power_supply *usb_psy;
@@ -1614,6 +1656,7 @@ struct dwc3_gadget_ep_cmd_params {
/* prototypes */
void dwc3_set_prtcap(struct dwc3 *dwc, u32 mode, bool ignore_susphy);
void dwc3_set_mode(struct dwc3 *dwc, u32 mode);
+void dwc3_set_mode_port(struct dwc3 *dwc, u32 mode, int port);
u32 dwc3_core_fifo_space(struct dwc3_ep *dep, u8 type);
#define DWC3_IP_IS(_ip) \
diff --git a/drivers/usb/dwc3/debugfs.c b/drivers/usb/dwc3/debugfs.c
index 01ebd73..82e7a33 100644
--- a/drivers/usb/dwc3/debugfs.c
+++ b/drivers/usb/dwc3/debugfs.c
@@ -434,6 +434,10 @@ static ssize_t dwc3_mode_write(struct file *file,
u32 mode = 0;
char buf[32];
+ /* The connector providers own both the role and the data-path selection. */
+ if (dwc->role_mux)
+ return -EBUSY;
+
if (copy_from_user(&buf, ubuf, min_t(size_t, sizeof(buf) - 1, count)))
return -EFAULT;
diff --git a/drivers/usb/dwc3/drd.c b/drivers/usb/dwc3/drd.c
index f3e37d3..b6ca11e 100644
--- a/drivers/usb/dwc3/drd.c
+++ b/drivers/usb/dwc3/drd.c
@@ -8,6 +8,7 @@
*/
#include <linux/extcon.h>
+#include <linux/mux/consumer.h>
#include <linux/of_platform.h>
#include <linux/platform_device.h>
#include <linux/property.h>
@@ -501,10 +502,294 @@ static enum usb_role dwc3_usb_role_switch_get(struct usb_role_switch *sw)
return role;
}
+/*
+ * Index of the connector that should own the shared data path: the oldest
+ * pending request wins, and the last selection is kept when neither connector
+ * requests a role. Requests are ordered by a monotonic counter rather than by
+ * a timestamp, so a wrapped counter cannot be mistaken for an old request.
+ */
+static int dwc3_role_mux_pick(struct dwc3_role_mux *mux)
+{
+ int sel = mux->desired_port;
+ int i;
+
+ for (i = 0; i < ARRAY_SIZE(mux->ports); i++) {
+ if (mux->ports[i].role == USB_ROLE_NONE)
+ continue;
+ if (mux->ports[sel].role == USB_ROLE_NONE ||
+ mux->ports[i].seq < mux->ports[sel].seq)
+ sel = i;
+ }
+
+ return sel;
+}
+
+static u32 dwc3_role_mux_mode(struct dwc3 *dwc, enum usb_role role)
+{
+ if (role == USB_ROLE_HOST)
+ return DWC3_GCTL_PRTCAP_HOST;
+ if (role == USB_ROLE_DEVICE)
+ return DWC3_GCTL_PRTCAP_DEVICE;
+ if (dwc->role_switch_default_mode == USB_DR_MODE_HOST)
+ return DWC3_GCTL_PRTCAP_HOST;
+
+ return DWC3_GCTL_PRTCAP_DEVICE;
+}
+
+static int dwc3_mux_role_set(struct usb_role_switch *sw, enum usb_role role)
+{
+ struct dwc3_role_port *port = usb_role_switch_get_drvdata(sw);
+ struct dwc3 *dwc = port->dwc;
+ struct dwc3_role_mux *mux = dwc->role_mux;
+ unsigned long flags;
+ enum usb_role selected_role;
+ int selected;
+
+ if (role > USB_ROLE_DEVICE)
+ return -EINVAL;
+
+ mutex_lock(&mux->lock);
+
+ /*
+ * The switches are registered before the initial mode request is issued and
+ * before mux->ready is set, so a connector can find its switch while the
+ * mux is still being set up. Refusing the request keeps it from racing
+ * with the initial mode request and from queueing work that the error path
+ * would then have to undo.
+ */
+ if (!mux->ready) {
+ mutex_unlock(&mux->lock);
+ return -ENODEV;
+ }
+
+ spin_lock_irqsave(&dwc->lock, flags);
+ /*
+ * A role change between two non-NONE roles of the same connector must not
+ * give that connector a new request ticket: it would otherwise steal the
+ * data path from the connector that asked first.
+ */
+ if (port->role == USB_ROLE_NONE && role != USB_ROLE_NONE)
+ port->seq = ++mux->seq;
+ port->role = role;
+ selected = dwc3_role_mux_pick(mux);
+ selected_role = mux->ports[selected].role;
+ spin_unlock_irqrestore(&dwc->lock, flags);
+
+ /*
+ * Notify the glue layer before touching the controller, in the same order
+ * as the single-connector path. It may sleep (the Qualcomm glue calls
+ * pm_runtime_resume_and_get()), so it runs outside of dwc->lock -
+ * dwc3_set_mode() takes that lock itself and a recursive take deadlocks
+ * the controller on the very first role change.
+ *
+ * Pairing with the selection above is provided by mux->lock: a second
+ * connector blocks in mutex_lock() until this request has been issued.
+ *
+ * Same asynchronous semantics as the single-connector role switch: the
+ * data path and the controller are reprogrammed from __dwc3_set_mode().
+ */
+ dwc3_pre_set_role(dwc, selected_role);
+ /*
+ * The selected connector and the mode are published by one call, under
+ * dwc->lock, so __dwc3_set_mode() cannot observe the new connector together
+ * with the role of the previous request. Publishing happens after
+ * dwc3_pre_set_role() so the work cannot start before the glue layer has
+ * been notified.
+ */
+ dwc3_set_mode_port(dwc, dwc3_role_mux_mode(dwc, selected_role), selected);
+
+ mutex_unlock(&mux->lock);
+
+ /*
+ * A data-path switch failure is reported through the console and counted
+ * per connector; it is not returned here. This call has already updated
+ * the request state, so a stale error from another connector must not be
+ * reported as the result of this (successful) request.
+ */
+ return 0;
+}
+
+static enum usb_role dwc3_mux_role_get(struct usb_role_switch *sw)
+{
+ struct dwc3_role_port *port = usb_role_switch_get_drvdata(sw);
+ struct dwc3 *dwc = port->dwc;
+ unsigned long flags;
+ enum usb_role role;
+
+ /*
+ * Report the role this connector itself requested, whether or not it owns
+ * the shared data path right now. Hiding a pending request behind
+ * active_port makes connector drivers read back USB_ROLE_NONE, so they
+ * never send the set_role(USB_ROLE_NONE) that would release it; the stale
+ * request then keeps winning dwc3_role_mux_pick() after the connector has
+ * been unplugged and starves the other one.
+ */
+ spin_lock_irqsave(&dwc->lock, flags);
+ role = port->role;
+ spin_unlock_irqrestore(&dwc->lock, flags);
+
+ return role;
+}
+
+static void dwc3_role_mux_exit(struct dwc3 *dwc)
+{
+ struct dwc3_role_mux *mux = dwc->role_mux;
+ unsigned int i;
+
+ if (!mux)
+ return;
+
+ /*
+ * Refuse new requests first. dwc3_mux_role_set() takes this lock for its
+ * whole duration, so once it is held no request is in flight, and every
+ * later one returns before it can queue a mode request. The work itself
+ * is drained by the caller, which is the only way to keep a request from
+ * being queued after the drain.
+ */
+ mutex_lock(&mux->lock);
+ mux->ready = false;
+ mutex_unlock(&mux->lock);
+
+ for (i = 0; i < ARRAY_SIZE(mux->ports); i++) {
+ if (mux->ports[i].sw)
+ usb_role_switch_unregister(mux->ports[i].sw);
+ mux->ports[i].sw = NULL;
+ fwnode_handle_put(mux->ports[i].fwnode);
+ mux->ports[i].fwnode = NULL;
+ }
+}
+
+/* Returns 1 when the optional two-connector mux has been set up. */
+static int dwc3_role_mux_init(struct dwc3 *dwc, u32 mode)
+{
+ struct usb_role_switch_desc desc = {};
+ struct dwc3_role_mux *mux;
+ struct fwnode_handle *ep;
+ char name[64];
+ u32 state;
+ int ret, i;
+
+ if (!fwnode_property_present(dev_fwnode(dwc->dev), "mux-controls"))
+ return 0;
+
+ mux = devm_kzalloc(dwc->dev, sizeof(*mux), GFP_KERNEL);
+ if (!mux)
+ return -ENOMEM;
+
+ mux->ctrl = devm_mux_control_get(dwc->dev, NULL);
+ if (IS_ERR(mux->ctrl))
+ return PTR_ERR(mux->ctrl);
+
+ /*
+ * Both connectors must be addressable states of the mux controller.
+ */
+ if (mux_control_states(mux->ctrl) < ARRAY_SIZE(mux->ports))
+ return -EINVAL;
+
+ /*
+ * The current position of a mux controller cannot be read back, so the
+ * boot-time connector cannot be detected here. The first mode request
+ * selects state 0 instead (the mode worker sees active_port == -1 and
+ * claims the mux for endpoint 0).
+ */
+ mux->desired_port = 0;
+ mux->active_port = -1;
+ mutex_init(&mux->lock);
+
+ /*
+ * Publish the mux before the first endpoint reference is taken:
+ * dwc3_role_mux_exit() is a no-op while dwc->role_mux is NULL, so every
+ * error path below would otherwise leak the fwnode references already
+ * acquired.
+ */
+ dwc->role_mux = mux;
+
+ fwnode_graph_for_each_endpoint(dev_fwnode(dwc->dev), ep) {
+ if (!fwnode_property_present(ep, "usb-role-switch"))
+ continue;
+
+ ret = fwnode_property_read_u32(ep, "mux-state", &state);
+ if (ret || state >= ARRAY_SIZE(mux->ports)) {
+ ret = -EINVAL;
+ goto err_put_ep;
+ }
+ if (mux->ports[state].fwnode) {
+ ret = -EINVAL;
+ goto err_put_ep;
+ }
+
+ mux->ports[state].fwnode = fwnode_handle_get(ep);
+ mux->ports[state].state = state;
+ mux->ports[state].dwc = dwc;
+ }
+
+ for (i = 0; i < ARRAY_SIZE(mux->ports); i++) {
+ if (!mux->ports[i].fwnode) {
+ ret = -EINVAL;
+ goto err;
+ }
+ }
+
+ /*
+ * Registering the switches makes them reachable from the connector
+ * drivers, so the initial mode request has to be issued inside the same
+ * critical section: a set() arriving in between would be silently
+ * overwritten by it while port->role keeps the requested value.
+ * dwc3_mux_role_set() serialises on the same lock.
+ */
+ mutex_lock(&mux->lock);
+
+ for (i = 0; i < ARRAY_SIZE(mux->ports); i++) {
+ snprintf(name, sizeof(name), "%s-port%u", dev_name(dwc->dev), i);
+ desc.name = name;
+ desc.fwnode = mux->ports[i].fwnode;
+ desc.set = dwc3_mux_role_set;
+ desc.get = dwc3_mux_role_get;
+ desc.driver_data = &mux->ports[i];
+ mux->ports[i].sw = usb_role_switch_register(dwc->dev, &desc);
+ if (IS_ERR(mux->ports[i].sw)) {
+ ret = PTR_ERR(mux->ports[i].sw);
+ mux->ports[i].sw = NULL;
+ mutex_unlock(&mux->lock);
+ goto err;
+ }
+ }
+
+ /*
+ * The controller is only started in its default role once both switches
+ * are registered: before that a connector driver cannot request a role,
+ * so nothing can race with this initial mode request.
+ */
+ dwc3_set_mode(dwc, mode);
+ mux->ready = true;
+
+ mutex_unlock(&mux->lock);
+
+ return 1;
+
+err:
+ /*
+ * Unregister the switches before draining the work: dwc3_role_mux_exit()
+ * refuses every further request, and a request that was already past that
+ * check has queued its work by the time the lock is released, so the drain
+ * below cannot miss it. The reverse order would let a blocked request
+ * queue the work after the drain and run it on a half-torn-down mux.
+ * dwc->role_mux is left in place: it is devm-managed and freeing it here
+ * would only turn a late request into a NULL dereference.
+ */
+ dwc3_role_mux_exit(dwc);
+ cancel_work_sync(&dwc->drd_work);
+ return ret;
+err_put_ep:
+ fwnode_handle_put(ep);
+ goto err;
+}
+
static int dwc3_setup_role_switch(struct dwc3 *dwc)
{
struct usb_role_switch_desc dwc3_role_switch = {NULL};
u32 mode;
+ int ret;
dwc->role_switch_default_mode = usb_get_role_switch_default_mode(dwc->dev);
if (dwc->role_switch_default_mode == USB_DR_MODE_HOST) {
@@ -513,6 +798,11 @@ static int dwc3_setup_role_switch(struct dwc3 *dwc)
dwc->role_switch_default_mode = USB_DR_MODE_PERIPHERAL;
mode = DWC3_GCTL_PRTCAP_DEVICE;
}
+
+ ret = dwc3_role_mux_init(dwc, mode);
+ if (ret)
+ return ret < 0 ? ret : 0;
+
dwc3_set_mode(dwc, mode);
dwc3_role_switch.fwnode = dev_fwnode(dwc->dev);
@@ -526,7 +816,7 @@ static int dwc3_setup_role_switch(struct dwc3 *dwc)
if (dwc->dev->of_node) {
/* populate connector entry */
- int ret = devm_of_platform_populate(dwc->dev);
+ ret = devm_of_platform_populate(dwc->dev);
if (ret) {
usb_role_switch_unregister(dwc->role_sw);
@@ -541,6 +831,7 @@ static int dwc3_setup_role_switch(struct dwc3 *dwc)
#else
#define ROLE_SWITCH 0
#define dwc3_setup_role_switch(x) 0
+static inline void dwc3_role_mux_exit(struct dwc3 *dwc) {}
#endif
int dwc3_drd_init(struct dwc3 *dwc)
@@ -597,6 +888,7 @@ void dwc3_drd_exit(struct dwc3 *dwc)
{
unsigned long flags;
+ dwc3_role_mux_exit(dwc);
if (dwc->role_sw)
usb_role_switch_unregister(dwc->role_sw);
^ permalink raw reply related [flat|nested] 6+ messages in thread