thunderbolt: Add support for XDomain lane bonding
Subsystems (2)
cover thunderbolt: Add support for XDomain lane bonding
Hi all,
So far connecting two Thunderbolt/USB4 domains (hosts) the high-speed link has been using a single lane. The reason for this was simplicity and also the fact that the host DMA was not able to go over the 20 Gbit/s even if the lanes were bonded. However, Intel Alder Lake and beyond actually can go higher than that so now it makes more sense to take advantage of the lane bonding. The USB4 Inter-Domain Service specification describes the protocol and this patch series implements it for the Linux Thunderbolt/USB4 driver.
If both sides (hosts) of the link announce supporting this, we will establish bonded link. This is only possible on systems with software based connection manager (so Intel Alder Lake and beyond).
Mika Westerberg (5):
thunderbolt: Add debug logging when lane is enabled/disabled
thunderbolt: Move tb_port_state() prototype to correct place
thunderbolt: Split setting link width and lane bonding into own functions
thunderbolt: Ignore port locked error in tb_port_wait_for_link_width()
thunderbolt: Add support for XDomain lane bonding
drivers/thunderbolt/switch.c | 109 ++++-- drivers/thunderbolt/tb.c | 6 - drivers/thunderbolt/tb.h | 4 +- drivers/thunderbolt/tb_msgs.h | 39 +++ drivers/thunderbolt/tb_regs.h | 5 + drivers/thunderbolt/xdomain.c | 609 ++++++++++++++++++++++++++++++---- include/linux/thunderbolt.h | 19 +- 7 files changed, 688 insertions(+), 103 deletions(-)
Signature · 1 line
2.35.1
PATCH 1/5 thunderbolt: Add debug logging when lane is enabled/disabled
This is useful when debugging possible issues.
--- drivers/thunderbolt/switch.c | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-)
drivers/thunderbolt/switch.c +8 -2
@@ -693,8 +693,14 @@ static int __tb_port_enable(struct tb_port *port, bool enable)else phy |=LANE_ADP_CS_1_LD ; -return tb_port_write (port, &phy,TB_CFG_PORT , - port->cap_phy +LANE_ADP_CS_1 ,1 ); + + ret =tb_port_write (port, &phy,TB_CFG_PORT , + port->cap_phy +LANE_ADP_CS_1 ,1 ); +if (ret) +return ret; + +tb_port_dbg (port,"lane %sabled\n" , enable ?"en" :"dis" ); +return 0 ; }/**
Signature · 1 line
2.35.1
PATCH 2/5 thunderbolt: Move tb_port_state() prototype to correct place
In reply to Mika WesterbergThis should be before tb_wait_for_port() following how the functions in switch.c are organized.
--- drivers/thunderbolt/tb.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/thunderbolt/tb.h +1 -1
@@ -991,6 +991,7 @@ int tb_switch_pcie_l1_enable(struct tb_switch *sw);int tb_switch_xhci_connect (struct tb_switch *sw);void tb_switch_xhci_disconnect (struct tb_switch *sw); +int tb_port_state (struct tb_port *port);int tb_wait_for_port (struct tb_port *port,bool wait_if_unplugged);int tb_port_add_nfc_credits (struct tb_port *port,int credits);int tb_port_clear_counter (struct tb_port *port,int counter);
@@ -1023,7 +1024,6 @@ static inline bool tb_port_use_credit_allocation(const struct tb_port *port)int tb_port_get_link_speed (struct tb_port *port);int tb_port_get_link_width (struct tb_port *port); -int tb_port_state (struct tb_port *port);int tb_port_lane_bonding_enable (struct tb_port *port);void tb_port_lane_bonding_disable (struct tb_port *port); int tb_port_wait_for_link_width(struct tb_port *port, int width,
Signature · 1 line
2.35.1
PATCH 3/5 thunderbolt: Split setting link width and lane bonding into own functions
In reply to Mika WesterbergWhen bonding lanes over XDomain the host that has "higher" UUID triggers link re-train for bonding, and the host that has "lower" UUID just waits for this to happen. To support this split setting the link width and triggering the actual bonding a separate functions that can be called as needed.
While there remove duplicated empty line in the kernel-doc comment of tb_port_lane_bonding_disable().
--- drivers/thunderbolt/switch.c | 86 ++++++++++++++++++++++++++++++------ drivers/thunderbolt/tb.h | 2 + 2 files changed, 74 insertions(+), 14 deletions(-)
drivers/thunderbolt/switch.c +72 -14
@@ -999,7 +999,17 @@ static bool tb_port_is_width_supported(struct tb_port *port, int width)return !!(widths & width); } -static int tb_port_set_link_width (struct tb_port *port,unsigned int width) +/** +* tb_port_set_link_width() - Set target link width of the lane adapter +* @port: Lane adapter +* @width: Target link width (%1 or %2) +* +* Sets the target link width of the lane adapter to @width. Does not +* enable/disable lane bonding. For that call tb_port_set_lane_bonding(). +* +* Return: %0 in case of success and negative errno in case of error +*/ +int tb_port_set_link_width (struct tb_port *port,unsigned int width) {u32 val;int ret;
@@ -1026,12 +1036,58 @@ static int tb_port_set_link_width(struct tb_port *port, unsigned int width)return -EINVAL ; } - val |=LANE_ADP_CS_1_LB ; -return tb_port_write (port, &val,TB_CFG_PORT , port->cap_phy +LANE_ADP_CS_1 ,1 ); } +/** +* tb_port_set_lane_bonding() - Enable/disable lane bonding +* @port: Lane adapter +* @bonding: enable/disable bonding +* +* Enables or disables lane bonding. This should be called after target +* link width has been set (tb_port_set_link_width()). Note in most +* cases one should use tb_port_lane_bonding_enable() instead to enable +* lane bonding. +* +* As a side effect sets @port->bonding accordingly (and does the same +* for lane 1 too). +* +* Return: %0 in case of success and negative errno in case of error +*/ +int tb_port_set_lane_bonding (struct tb_port *port,bool bonding) +{ +u32 val; +int ret; + +if (!port->cap_phy) +return -EINVAL ; + + ret =tb_port_read (port, &val,TB_CFG_PORT , + port->cap_phy +LANE_ADP_CS_1 ,1 ); +if (ret) +return ret; + +if (bonding) + val |=LANE_ADP_CS_1_LB ; +else + val &= ~LANE_ADP_CS_1_LB ; + + ret =tb_port_write (port, &val,TB_CFG_PORT , + port->cap_phy +LANE_ADP_CS_1 ,1 ); +if (ret) +return ret; + +/* +* When lane 0 bonding is set it will affect lane 1 too so +* update both. +*/ + port->bonded = bonding; + port->dual_link_port->bonded = bonding; + +return 0 ; +} +/** * tb_port_lane_bonding_enable() - Enable bonding on port * @port: port to enable
@@ -1056,22 +1112,27 @@ int tb_port_lane_bonding_enable(struct tb_port *port)if (ret ==1 ) { ret =tb_port_set_link_width (port,2 );if (ret) -return ret; + goto err_lane0; } ret =tb_port_get_link_width (port->dual_link_port);if (ret ==1 ) { ret =tb_port_set_link_width (port->dual_link_port,2 ); -if (ret) { -tb_port_set_link_width (port,1 ); -return ret; - } +if (ret) + goto err_lane0; } - port->bonded = true; - port->dual_link_port->bonded = true; + ret =tb_port_set_lane_bonding (port, true); +if (ret) + goto err_lane1;return 0 ; + +err_lane1: +tb_port_set_link_width (port->dual_link_port,1 ); +err_lane0: +tb_port_set_link_width (port,1 ); +return ret; }/**
@@ -1080,13 +1141,10 @@ int tb_port_lane_bonding_enable(struct tb_port *port)* * Disable bonding by setting the link width of the port and the * other port in case of dual link port. -* */ void tb_port_lane_bonding_disable (struct tb_port *port) { - port->dual_link_port->bonded = false; - port->bonded = false; - +tb_port_set_lane_bonding (port, false);tb_port_set_link_width (port->dual_link_port,1 );tb_port_set_link_width (port,1 ); }
drivers/thunderbolt/tb.h +2 -0
@@ -1024,6 +1024,8 @@ static inline bool tb_port_use_credit_allocation(const struct tb_port *port)int tb_port_get_link_speed (struct tb_port *port);int tb_port_get_link_width (struct tb_port *port); +int tb_port_set_link_width (struct tb_port *port,unsigned int width); +int tb_port_set_lane_bonding (struct tb_port *port,bool bonding);int tb_port_lane_bonding_enable (struct tb_port *port);void tb_port_lane_bonding_disable (struct tb_port *port); int tb_port_wait_for_link_width(struct tb_port *port, int width,
Signature · 1 line
2.35.1
PATCH 4/5 thunderbolt: Ignore port locked error in tb_port_wait_for_link_width()
In reply to Mika WesterbergSometimes when polling for the port after target link width is changed we get back port locked notification (because the link actually was reset and then re-trained). Instead of bailing out we can ignore these when polling for the width change as this is expected.
--- drivers/thunderbolt/switch.c | 13 ++++++++++--- 1 file changed, 10 insertions(+), 3 deletions(-)
drivers/thunderbolt/switch.c +10 -3
@@ -1168,10 +1168,17 @@ int tb_port_wait_for_link_width(struct tb_port *port, int width,do { ret =tb_port_get_link_width (port); -if (ret <0 ) -return ret; -else if (ret == width) +if (ret <0 ) { +/* +* Sometimes we get port locked error when +* polling the lanes so we can ignore it and +* retry. +*/ +if (ret != -EACCES ) +return ret; + }else if (ret == width) {return 0 ; + }usleep_range (1000 ,2000 ); }while (ktime_before (ktime_get (), timeout));
Signature · 1 line
2.35.1
PATCH 5/5 thunderbolt: Add support for XDomain lane bonding
In reply to Mika WesterbergThe USB4 Inter-Domain Service specification defines a protocol that can be used to establish lane bonding between two USB4 domains (hosts). So far we have not implemented it because the host controller DMA was not fast enough to be able to go over 20 Gbits/s even if lanes were bonded. However, starting from Intel Alder Lake CPUs the DMA can go over 20 Gbits/s so now it makes more sense to add this support to the driver.
Because both ends need to negotiate the bonding we add a simple state machine that tracks the connection state and does the necessary steps described by the USB4 Inter-Domain Service specification. We only establish lane bonding when both sides of the link support it. Otherwise we default to use the single lane. Also this is only done when software connection manager is used. On systems with firmware based connection manager, it handles the high-speed tunneling so bonding lanes is specific to the implementation (Intel firmware based connection manager does not support lane bonding).
--- drivers/thunderbolt/tb.c | 6 - drivers/thunderbolt/tb_msgs.h | 39 +++ drivers/thunderbolt/tb_regs.h | 5 + drivers/thunderbolt/xdomain.c | 609 ++++++++++++++++++++++++++++++---- include/linux/thunderbolt.h | 19 +- 5 files changed, 595 insertions(+), 83 deletions(-)
drivers/thunderbolt/tb.c +0 -6
@@ -169,12 +169,6 @@ static void tb_discover_tunnels(struct tb *tb)static int tb_port_configure_xdomain (struct tb_port *port) { -/* -* XDomain paths currently only support single lane so we must -* disable the other lane according to USB4 spec. -*/ -tb_port_disable (port->dual_link_port); -if (tb_switch_is_usb4 (port->sw))return usb4_port_configure_xdomain (port);return tb_lc_configure_xdomain (port);
drivers/thunderbolt/tb_msgs.h +39 -0
@@ -527,6 +527,10 @@ enum tb_xdp_type {PROPERTIES_CHANGED_RESPONSE ,ERROR_RESPONSE ,UUID_REQUEST =12 , +LINK_STATE_STATUS_REQUEST =15 , +LINK_STATE_STATUS_RESPONSE , +LINK_STATE_CHANGE_REQUEST , + LINK_STATE_CHANGE_RESPONSE, }; struct tb_xdp_header {
@@ -540,6 +544,41 @@ struct tb_xdp_error_response {u32 error; }; +struct tb_xdp_link_state_status { +struct tb_xdp_header hdr; +}; + +struct tb_xdp_link_state_status_response { +union { +struct tb_xdp_error_response err; +struct { +struct tb_xdp_header hdr; +u32 status; +u8 slw; +u8 tlw; +u8 sls; +u8 tls; + }; + }; +}; + +struct tb_xdp_link_state_change { +struct tb_xdp_header hdr; +u8 tlw; +u8 tls; +u16 reserved; +}; + +struct tb_xdp_link_state_change_response { +union { +struct tb_xdp_error_response err; +struct { +struct tb_xdp_header hdr; +u32 status; + }; + }; +}; +struct tb_xdp_uuid {struct tb_xdp_header hdr; };
drivers/thunderbolt/tb_regs.h +5 -0
@@ -311,11 +311,16 @@ struct tb_regs_port_header {/* Lane adapter registers */ #define LANE_ADP_CS_0 0x00 +#define LANE_ADP_CS_0_SUPPORTED_SPEED_MASK GENMASK(19, 16) +#define LANE_ADP_CS_0_SUPPORTED_SPEED_SHIFT 16#define LANE_ADP_CS_0_SUPPORTED_WIDTH_MASK GENMASK(25, 20)#define LANE_ADP_CS_0_SUPPORTED_WIDTH_SHIFT 20 +#define LANE_ADP_CS_0_SUPPORTED_WIDTH_DUAL 0x2#define LANE_ADP_CS_0_CL0S_SUPPORT BIT(26)#define LANE_ADP_CS_0_CL1_SUPPORT BIT(27)#define LANE_ADP_CS_1 0x01 +#define LANE_ADP_CS_1_TARGET_SPEED_MASK GENMASK(3, 0) +#define LANE_ADP_CS_1_TARGET_SPEED_GEN3 0xc#define LANE_ADP_CS_1_TARGET_WIDTH_MASK GENMASK(9, 4)#define LANE_ADP_CS_1_TARGET_WIDTH_SHIFT 4#define LANE_ADP_CS_1_TARGET_WIDTH_SINGLE 0x1
drivers/thunderbolt/xdomain.c +541 -68
793 lines not on this page · raw message
include/linux/thunderbolt.h +10 -9
@@ -198,15 +198,15 @@ void tb_unregister_property_dir(const char *key, struct tb_property_dir *dir);* @local_property_block_len: Length of the @local_property_block in dwords * @remote_properties: Properties exported by the remote domain * @remote_property_block_gen: Generation of @remote_properties -* @get_uuid_work: Work used to retrieve @remote_uuid -* @uuid_retries: Number of times left @remote_uuid is requested before -* giving up -* @get_properties_work: Work used to get remote domain properties -* @properties_retries: Number of times left to read properties +* @state: Next XDomain discovery state to run +* @state_work: Work used to run the next state +* @state_retries: Number of retries remain for the state * @properties_changed_work: Work used to notify the remote domain that * our properties have changed * @properties_changed_retries: Number of times left to send properties * changed notification +* @bonding_possible: True if lane bonding is possible on local side +* @target_link_width: Target link width from the remote host * @link: Root switch link the remote domain is connected (ICM only) * @depth: Depth in the chain the remote domain is connected (ICM only) *
@@ -244,12 +244,13 @@ struct tb_xdomain {u32 local_property_block_len;struct tb_property_dir *remote_properties;u32 remote_property_block_gen; -struct delayed_work get_uuid_work; -int uuid_retries; -struct delayed_work get_properties_work; -int properties_retries; +int state; +struct delayed_work state_work; +int state_retries;struct delayed_work properties_changed_work;int properties_changed_retries; +bool bonding_possible; +u8 target_link_width;u8 link;u8 depth; };
Signature · 1 line
2.35.1
Quoted 15 lines · Mika Westerberg
Hi all,
So far connecting two Thunderbolt/USB4 domains (hosts) the high-speed link has been using a single lane. The reason for this was simplicity and also the fact that the host DMA was not able to go over the 20 Gbit/s even if the lanes were bonded. However, Intel Alder Lake and beyond actually can go higher than that so now it makes more sense to take advantage of the lane bonding. The USB4 Inter-Domain Service specification describes the protocol and this patch series implements it for the Linux Thunderbolt/USB4 driver.
If both sides (hosts) of the link announce supporting this, we will establish bonded link. This is only possible on systems with software based connection manager (so Intel Alder Lake and beyond).
Quoted 6 lines
Mika Westerberg (5):
thunderbolt: Add debug logging when lane is enabled/disabled
thunderbolt: Movetb_port_state()prototype to correct place
thunderbolt: Split setting link width and lane bonding into own functions
thunderbolt: Ignore port locked error intb_port_wait_for_link_width()
thunderbolt: Add support for XDomain lane bonding
Series applied to thunderbolt.git/next.