thunderbolt: Tunneling improvements
Subsystems (2)
cover thunderbolt: Tunneling improvements
Hi all,
This series improves the Thunderbolt/USB4 driver to support tree topologies that are now possible with USB4 devices (it is possible with TBT devices but there are no such devices available in the market with more than two ports).
We also take advantage of KUnit and add unit tests for path walking and tunneling (in cases where hardware is not needed). In addition we add initial support for USB3 tunnel bandwidth management so that the driver can share isochronous bandwidth between USB3 and DisplayPort.
Mika Westerberg (17):
thunderbolt: Fix path indices used in USB3 tunnel discovery
thunderbolt: Make tb_next_port_on_path() work with tree topologies
thunderbolt: Make tb_path_alloc() work with tree topologies
thunderbolt: Check that both ports are reachable when allocating path
thunderbolt: Handle incomplete PCIe/USB3 paths correctly in discovery
thunderbolt: Increase path length in discovery
thunderbolt: Add KUnit tests for path walking
thunderbolt: Add DP IN resources for all routers
thunderbolt: Do not tunnel USB3 if link is not USB4
thunderbolt: Make usb4_switch_map_usb3_down() also return enabled ports
thunderbolt: Make usb4_switch_map_pcie_down() also return enabled ports
thunderbolt: Report consumed bandwidth in both directions
thunderbolt: Increase DP DPRX wait timeout
thunderbolt: Implement USB3 bandwidth negotiation routines
thunderbolt: Make tb_port_get_link_speed() available to other files
thunderbolt: Add USB3 bandwidth management
thunderbolt: Add KUnit tests for tunneling
drivers/thunderbolt/Kconfig | 5 + drivers/thunderbolt/Makefile | 2 + drivers/thunderbolt/path.c | 38 +- drivers/thunderbolt/switch.c | 25 +- drivers/thunderbolt/tb.c | 378 ++++++-- drivers/thunderbolt/tb.h | 35 +- drivers/thunderbolt/tb_regs.h | 20 + drivers/thunderbolt/test.c | 1626 +++++++++++++++++++++++++++++++++ drivers/thunderbolt/tunnel.c | 326 ++++++- drivers/thunderbolt/tunnel.h | 37 +- drivers/thunderbolt/usb4.c | 369 +++++++- 11 files changed, 2709 insertions(+), 152 deletions(-) create mode 100644 drivers/thunderbolt/test.c
Signature · 1 line
2.27.0.rc2
PATCH 1/17 thunderbolt: Fix path indices used in USB3 tunnel discovery
The USB3 discovery used wrong indices when tunnel is discovered. It should use TB_USB3_PATH_DOWN for path that flows downstream and TB_USB3_PATH_UP when it flows upstream. This should not affect the functionality but better to fix it.
--- drivers/thunderbolt/tunnel.c | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-)
drivers/thunderbolt/tunnel.c +6 -6
@@ -913,21 +913,21 @@ struct tb_tunnel *tb_tunnel_discover_usb3(struct tb *tb, struct tb_port *down)* case. */ path =tb_path_discover (down,TB_USB3_HOPID ,NULL ,-1 , - &tunnel->dst_port,"USB3 Up" ); + &tunnel->dst_port,"USB3 Down" );if (!path) {/* Just disable the downstream port */ tb_usb3_port_enable (down, false); goto err_free; } - tunnel->paths[TB_USB3_PATH_UP ] = path; -tb_usb3_init_path (tunnel->paths[TB_USB3_PATH_UP ]); + tunnel->paths[TB_USB3_PATH_DOWN ] = path; +tb_usb3_init_path (tunnel->paths[TB_USB3_PATH_DOWN ]); path =tb_path_discover (tunnel->dst_port,-1 , down,TB_USB3_HOPID ,NULL , -"USB3 Down" ); +"USB3 Up" );if (!path) goto err_deactivate; - tunnel->paths[TB_USB3_PATH_DOWN ] = path; -tb_usb3_init_path (tunnel->paths[TB_USB3_PATH_DOWN ]); + tunnel->paths[TB_USB3_PATH_UP ] = path; +tb_usb3_init_path (tunnel->paths[TB_USB3_PATH_UP ]);/* Validate that the tunnel is complete */ if (!tb_port_is_usb3_up (tunnel->dst_port)) {
Signature · 1 line
2.27.0.rc2
Mika Westerberg
AppliedRe: [PATCH 01/17] thunderbolt: Fix path indices used in USB3 tunnel discovery
Quoted 8 lines · Mika Westerberg
The USB3 discovery used wrong indices when tunnel is discovered. It should use
TB_USB3_PATH_DOWNfor path that flows downstream andTB_USB3_PATH_UPwhen it flows upstream. This should not affect the functionality but better to fix it.Fixes e6f818585713 ("thunderbolt: Add support for USB 3.x tunnels")Signed-off-by Mika Westerberg <[email protected]>Cc [email protected] # v5.6+
Applied to thunderbolt.git/fixes.
PATCH 2/17 thunderbolt: Make tb_next_port_on_path() work with tree topologies
In reply to Mika WesterbergUSB4 makes it possible to have tree topology of devices connected in the same way than USB3. This was actually possible in Thunderbolt 1, 2 and 3 as well but all the available devices only had two ports which allows building only daisy-chains of devices.
With USB4 it is possible for example that there is DP IN adapter as part of eGPU device router and that should be tunneled over the tree topology to a DP OUT adapter. This updates the tb_next_port_on_path() to support such topologies.
--- drivers/thunderbolt/switch.c | 17 ++++++++++++----- 1 file changed, 12 insertions(+), 5 deletions(-)
drivers/thunderbolt/switch.c +12 -5
@@ -850,6 +850,13 @@ void tb_port_release_out_hopid(struct tb_port *port, int hopid)ida_simple_remove (&port->out_hopids, hopid); } +static inline bool tb_switch_is_reachable (const struct tb_switch *parent, +const struct tb_switch *sw) +{ +u64 mask = (1ULL << parent->config.depth *8 ) -1 ; +return (tb_route (parent) & mask) == (tb_route (sw) & mask); +} +/** * tb_next_port_on_path() - Return next port for given port on a path * @start: Start port of the walk
@@ -879,12 +886,12 @@ struct tb_port *tb_next_port_on_path(struct tb_port *start, struct tb_port *end,return end; } -if (start->sw->config.depth < end->sw->config.depth) { +if (tb_switch_is_reachable (prev->sw, end->sw)) { + next =tb_port_at (tb_route (end->sw), prev->sw); +/* Walk down the topology if next == prev */ if (prev->remote && - prev->remote->sw->config.depth > prev->sw->config.depth) + (next == prev || next->dual_link_port == prev)) next = prev->remote; -else - next =tb_port_at (tb_route (end->sw), prev->sw); }else {if (tb_is_upstream_port (prev)) { next = prev->remote;
@@ -901,7 +908,7 @@ struct tb_port *tb_next_port_on_path(struct tb_port *start, struct tb_port *end, } } -return next; +return next != prev ? next :NULL ; }static int tb_port_get_link_speed (struct tb_port *port)
Signature · 1 line
2.27.0.rc2
PATCH 3/17 thunderbolt: Make tb_path_alloc() work with tree topologies
In reply to Mika WesterbergWith USB4, topologies are not limited to daisy-chains anymore so when calculating how many hops are between two ports we need to walk the whole path instead.
Add helper function tb_for_each_port_on_path() that can be used to walk over each port on a path and make tb_path_alloc() to use it.
--- drivers/thunderbolt/path.c | 12 ++++++------ drivers/thunderbolt/tb.h | 12 ++++++++++++ 2 files changed, 18 insertions(+), 6 deletions(-)
drivers/thunderbolt/path.c +6 -6
@@ -239,12 +239,12 @@ struct tb_path *tb_path_alloc(struct tb *tb, struct tb_port *src, int src_hopid,if (!path)return NULL ; -/* -* Number of hops on a path is the distance between the two -* switches plus the source adapter port. -*/ - num_hops =abs (tb_route_length (tb_route (src->sw)) - -tb_route_length (tb_route (dst->sw))) +1 ; + i =0 ; +tb_for_each_port_on_path (src, dst, in_port) + i++; + +/* Each hop takes two ports */ + num_hops = i /2 ; path->hops =kcalloc (num_hops,sizeof (*path->hops),GFP_KERNEL );if (!path->hops) {
drivers/thunderbolt/tb.h +12 -0
@@ -741,6 +741,18 @@ void tb_port_release_out_hopid(struct tb_port *port, int hopid);struct tb_port *tb_next_port_on_path (struct tb_port *start,struct tb_port *end,struct tb_port *prev); +/** +* tb_for_each_port_on_path() - Iterate over each port on path +* @src: Source port +* @dst: Destination port +* @p: Port used as iterator +* +* Walks over each port on path from @src to @dst. +*/ +#define tb_for_each_port_on_path (src, dst, p) \ + for ((p) = tb_next_port_on_path((src), (dst), NULL); (p); \ + (p) = tb_next_port_on_path((src), (dst), (p))) +int tb_switch_find_vse_cap (struct tb_switch *sw,enum tb_switch_vse_cap vsec);int tb_switch_find_cap (struct tb_switch *sw,enum tb_switch_cap cap);int tb_port_find_cap (struct tb_port *port,enum tb_port_cap cap);
Signature · 1 line
2.27.0.rc2
PATCH 4/17 thunderbolt: Check that both ports are reachable when allocating path
In reply to Mika WesterbergAdd sanity check that given src and dst ports are reachable through path walk before allocating a path. If they are not then bail out early.
--- drivers/thunderbolt/path.c | 15 +++++++++++++-- 1 file changed, 13 insertions(+), 2 deletions(-)
drivers/thunderbolt/path.c +13 -2
@@ -229,7 +229,7 @@ struct tb_path *tb_path_alloc(struct tb *tb, struct tb_port *src, int src_hopid, struct tb_port *dst, int dst_hopid, int link_nr, const char *name) { - struct tb_port *in_port, *out_port; + struct tb_port *in_port, *out_port, *first_port, *last_port;int in_hopid, out_hopid;struct tb_path *path;size_t num_hops;
@@ -239,9 +239,20 @@ struct tb_path *tb_path_alloc(struct tb *tb, struct tb_port *src, int src_hopid,if (!path)return NULL ; + first_port = last_port =NULL ; i =0 ; -tb_for_each_port_on_path (src, dst, in_port) +tb_for_each_port_on_path (src, dst, in_port) { +if (!first_port) + first_port = in_port; + last_port = in_port; i++; + } + +/* Check that src and dst are reachable */ +if (first_port != src || last_port != dst) { +kfree (path); +return NULL ; + }/* Each hop takes two ports */ num_hops = i /2 ;
Signature · 1 line
2.27.0.rc2
PATCH 5/17 thunderbolt: Handle incomplete PCIe/USB3 paths correctly in discovery
In reply to Mika WesterbergIf the path is not complete when we do discovery the number of hops may be less than with the full path. As an example when this can happen is that user unloads the driver, disconnects the topology, and loads the driver back. If there is PCIe or USB3 tunnel involved this may happen.
Take this into account in tb_pcie_init_path() and tb_usb3_init_path() and prevent potential access over array limits.
--- drivers/thunderbolt/tunnel.c | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-)
drivers/thunderbolt/tunnel.c +6 -4
@@ -124,8 +124,9 @@ static void tb_pci_init_path(struct tb_path *path) path->drop_packages =0 ; path->nfc_credits =0 ; path->hops[0 ].initial_credits =7 ; - path->hops[1 ].initial_credits = -tb_initial_credits (path->hops[1 ].in_port->sw); +if (path->path_length >1 ) + path->hops[1 ].initial_credits = +tb_initial_credits (path->hops[1 ].in_port->sw); }/**
@@ -879,8 +880,9 @@ static void tb_usb3_init_path(struct tb_path *path) path->drop_packages =0 ; path->nfc_credits =0 ; path->hops[0 ].initial_credits =7 ; - path->hops[1 ].initial_credits = -tb_initial_credits (path->hops[1 ].in_port->sw); +if (path->path_length >1 ) + path->hops[1 ].initial_credits = +tb_initial_credits (path->hops[1 ].in_port->sw); }/**
Signature · 1 line
2.27.0.rc2
PATCH 6/17 thunderbolt: Increase path length in discovery
In reply to Mika WesterbergCurrently we have only supported paths that follow daisy-chain topology but USB4 also allows to build trees of devices. For this reason increase maximum path length we use for discovery to be from the lowest level to the host router and back to the same level.
--- drivers/thunderbolt/tb.h | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-)
drivers/thunderbolt/tb.h +5 -1
@@ -286,7 +286,11 @@ struct tb_path {/* HopIDs 0-7 are reserved by the Thunderbolt protocol */ #define TB_PATH_MIN_HOPID 8 -#define TB_PATH_MAX_HOPS 7 +/* +* Support paths from the farthest (depth 6) router to the host and back +* to the same level (not necessarily to the same router). +*/ +#define TB_PATH_MAX_HOPS (7 * 2)/** * struct tb_cm_ops - Connection manager specific operations vector
Signature · 1 line
2.27.0.rc2
PATCH 7/17 thunderbolt: Add KUnit tests for path walking
In reply to Mika WesterbergThis adds KUnit tests for path walking which is only dependent on software structures, so no hardware is needed to run these.
We make these available only when both KUnit and the driver itself are built into the kernel image. The reason for this is that KUnit adds its own module_init() call in kunit_test_suite() which generates linker error because the driver does the same in nhi.c. This should be fine for now because these tests are only meant to run by developers anyway.
--- drivers/thunderbolt/Kconfig | 5 + drivers/thunderbolt/Makefile | 2 + drivers/thunderbolt/test.c | 1228 ++++++++++++++++++++++++++++++++++ 3 files changed, 1235 insertions(+) create mode 100644 drivers/thunderbolt/test.c
drivers/thunderbolt/Kconfig +5 -0
@@ -15,3 +15,8 @@ menuconfig USB4 To compile this driver a module, choose M here. The module will be called thunderbolt. + +config USB4_KUNIT_TEST + bool "KUnit tests" + depends on KUNIT=y + depends on USB4=y
drivers/thunderbolt/Makefile +2 -0
@@ -2,3 +2,5 @@ obj-${CONFIG_USB4} := thunderbolt.o thunderbolt-objs := nhi.o nhi_ops.o ctl.o tb.o switch.o cap.o path.o tunnel.o eeprom.o thunderbolt-objs += domain.o dma_port.o icm.o property.o xdomain.o lc.o tmu.o usb4.o + +obj-${CONFIG_USB4_KUNIT_TEST} += test.o
drivers/thunderbolt/test.c new file +1228 -0
1,228 lines not on this page · raw message
Signature · 1 line
2.27.0.rc2
PATCH 8/17 thunderbolt: Add DP IN resources for all routers
In reply to Mika WesterbergUSB4 spec allows DP tunneling from any router that has DP IN adapter, not just from host router. The driver currently only added the DP IN resources for the host router because Thunderbolt 1, 2 and 3 devices do not have DP IN adapters. However, USB4 allows device routers to have DP IN adapter as well so update the driver to add DP IN resources for each device that has one. One example would be an eGPU enclosure where the eGPU output is forwarded to DP IN port and then tunneled over the USB4 fabric.
Only limitation we add now is that the DP IN and DP OUT that gets paired for tunnel creation should both be under the same topology starting from host router downstream port. In other words we do not create DP tunnels across host router at this time even though that is possible as well but it complicates the bandwidth management and there is no real use-case for this anyway.
--- drivers/thunderbolt/tb.c | 50 ++++++++++++++++++++++++++++++++++++---- 1 file changed, 46 insertions(+), 4 deletions(-)
drivers/thunderbolt/tb.c +46 -4
@@ -404,6 +404,7 @@ static void tb_scan_port(struct tb_port *port)if (tcm->hotplug_active &&tb_tunnel_usb3 (sw->tb, sw))tb_sw_warn (sw,"USB3 tunnel creation failed\n" ); +tb_add_dp_resources (sw);tb_scan_switch (sw); }
@@ -573,6 +574,43 @@ static int tb_available_bw(struct tb_cm *tcm, struct tb_port *in,return available_bw; } +static struct tb_port *tb_find_dp_out (struct tb *tb,struct tb_port *in) +{ +struct tb_port *host_port, *port; +struct tb_cm *tcm =tb_priv (tb); + + host_port =tb_route (in->sw) ? +tb_port_at (tb_route (in->sw), tb->root_switch) :NULL ; + +list_for_each_entry (port, &tcm->dp_resources, list) { +if (!tb_port_is_dpout (port)) +continue ; + +if (tb_port_is_enabled (port)) { +tb_port_dbg (port,"in use\n" ); +continue ; + } + +tb_port_dbg (port,"DP OUT available\n" ); + +/* +* Keep the DP tunnel under the topology starting from +* the same host router downstream port. +*/ +if (host_port &&tb_route (port->sw)) { +struct tb_port *p; + + p =tb_port_at (tb_route (port->sw), tb->root_switch); +if (p != host_port) +continue ; + } + +return port; + } + +return NULL ; +} +static void tb_tunnel_dp (struct tb *tb) {struct tb_cm *tcm =tb_priv (tb);
@@ -589,17 +627,21 @@ static void tb_tunnel_dp(struct tb *tb) in =NULL ; out =NULL ;list_for_each_entry (port, &tcm->dp_resources, list) { +if (!tb_port_is_dpin (port)) +continue ; +if (tb_port_is_enabled (port)) {tb_port_dbg (port,"in use\n" );continue ; } -tb_port_dbg (port,"available\n" ); +tb_port_dbg (port,"DP IN available\n" ); -if (!in &&tb_port_is_dpin (port)) + out =tb_find_dp_out (tb, port); +if (out) { in = port; -else if (!out &&tb_port_is_dpout (port)) - out = port; +break ; + } }if (!in) {
Signature · 1 line
2.27.0.rc2
PATCH 9/17 thunderbolt: Do not tunnel USB3 if link is not USB4
In reply to Mika WesterbergUSB3 tunneling is possible only over USB4 link so don't create USB3 tunnels if that's not the case.
--- drivers/thunderbolt/tb.c | 3 +++ drivers/thunderbolt/tb.h | 2 ++ drivers/thunderbolt/tb_regs.h | 1 + drivers/thunderbolt/usb4.c | 24 +++++++++++++++++++++--- 4 files changed, 27 insertions(+), 3 deletions(-)
drivers/thunderbolt/tb.c +3 -0
@@ -235,6 +235,9 @@ static int tb_tunnel_usb3(struct tb *tb, struct tb_switch *sw)if (!up)return 0 ; +if (!sw->link_usb4) +return 0 ; +/* * Look up available down port. Since we are chaining it should * be found right above this switch.
drivers/thunderbolt/tb.h +2 -0
@@ -97,6 +97,7 @@ struct tb_switch_tmu {* @device_name: Name of the device (or %NULL if not known) * @link_speed: Speed of the link in Gb/s * @link_width: Width of the link (1 or 2) +* @link_usb4: Upstream link is USB4 * @generation: Switch Thunderbolt generation * @cap_plug_events: Offset to the plug events capability (%0 if not found) * @cap_lc: Offset to the link controller capability (%0 if not found)
@@ -136,6 +137,7 @@ struct tb_switch {const char *device_name;unsigned int link_speed;unsigned int link_width; +bool link_usb4;unsigned int generation;int cap_plug_events;int cap_lc;
drivers/thunderbolt/tb_regs.h +1 -0
@@ -290,6 +290,7 @@ struct tb_regs_port_header {/* USB4 port registers */ #define PORT_CS_18 0x12#define PORT_CS_18_BE BIT(8) +#define PORT_CS_18_TCM BIT(9)#define PORT_CS_19 0x13#define PORT_CS_19_PC BIT(3)
drivers/thunderbolt/usb4.c +21 -3
@@ -192,6 +192,20 @@ static int usb4_switch_op(struct tb_switch *sw, u16 opcode, u8 *status)return 0 ; } +static bool link_is_usb4 (struct tb_port *port) +{ +u32 val; + +if (!port->cap_usb4) +return false; + +if (tb_port_read (port, &val,TB_CFG_PORT , + port->cap_usb4 +PORT_CS_18 ,1 )) +return false; + +return !(val &PORT_CS_18_TCM ); +} +/** * usb4_switch_setup() - Additional setup for USB4 device * @sw: USB4 router to setup
@@ -205,6 +219,7 @@ static int usb4_switch_op(struct tb_switch *sw, u16 opcode, u8 *status)*/ int usb4_switch_setup (struct tb_switch *sw) { +struct tb_port *downstream_port;struct tb_switch *parent;bool tbt3, xhci;u32 val =0 ;
@@ -217,6 +232,11 @@ int usb4_switch_setup(struct tb_switch *sw)if (ret)return ret; + parent =tb_switch_parent (sw); + downstream_port =tb_port_at (tb_route (sw), parent); + sw->link_usb4 =link_is_usb4 (downstream_port); +tb_sw_dbg (sw,"link: %s\n" , sw->link_usb4 ?"USB4" :"TBT3" ); + xhci = val &ROUTER_CS_6_HCI ; tbt3 = !(val &ROUTER_CS_6_TNS );
@@ -227,9 +247,7 @@ int usb4_switch_setup(struct tb_switch *sw)if (ret)return ret; - parent =tb_switch_parent (sw); - -if (tb_switch_find_port (parent,TB_TYPE_USB3_DOWN )) { +if (sw->link_usb4 &&tb_switch_find_port (parent,TB_TYPE_USB3_DOWN )) { val |=ROUTER_CS_5_UTO ; xhci = false; }
Signature · 1 line
2.27.0.rc2
Re: [PATCH 09/17] thunderbolt: Do not tunnel USB3 if link is not USB4
Hi Mika,
Sorry for the late comment..
Quoted 16 lines · Mika Westerberg
USB3 tunneling is possible only over USB4 link so don't create USB3 tunnels if that's not the case.
Signed-off-by Mika Westerberg <[email protected]>--- drivers/thunderbolt/tb.c | 3 +++ drivers/thunderbolt/tb.h | 2 ++ drivers/thunderbolt/tb_regs.h | 1 + drivers/thunderbolt/usb4.c | 24 +++++++++++++++++++++--- 4 files changed, 27 insertions(+), 3 deletions(-)drivers/thunderbolt/tb.c +0
-0
drivers/thunderbolt/tb.c static int tb_tunnel_usb3(struct tb *tb, struct tb_switch *sw) · line 239
Quoted 5 lines
drivers/thunderbolt/tb.c +2
-0@@ -235,6 +235,9 @@ static int tb_tunnel_usb3(struct tb *tb, struct tb_switch *sw)if (!up)return 0 ; +if (!sw->link_usb4) +return 0 ;
On both here and the previous "up" check; should we be returning 0? Wouldn't it be better to return an appropriate error code? It sounds like 0 is considered a success....
Best regards,
-Prashant
Quoted 3 lines
drivers/thunderbolt/tb.c +1
-0+/*
Re: [PATCH 09/17] thunderbolt: Do not tunnel USB3 if link is not USB4
Quoted 3 lines · Prashant Malani
Hi Mika,
Sorry for the late comment..
Sorry for the late reply, was on vacation ;-)
Quoted 20 lines · Mika Westerberg
Quoted 19 lines
USB3 tunneling is possible only over USB4 link so don't create USB3 tunnels if that's not the case.
Signed-off-by Mika Westerberg <[email protected]>--- drivers/thunderbolt/tb.c | 3 +++ drivers/thunderbolt/tb.h | 2 ++ drivers/thunderbolt/tb_regs.h | 1 + drivers/thunderbolt/usb4.c | 24 +++++++++++++++++++++--- 4 files changed, 27 insertions(+), 3 deletions(-)drivers/thunderbolt/tb.c +0
-0@@ -235,6 +235,9 @@ static int tb_tunnel_usb3(struct tb *tb, struct tb_switch *sw)if (!up)return 0 ;
Quoted 5 lines
drivers/thunderbolt/tb.c static int tb_tunnel_usb3(struct tb *tb, struct tb_switch *sw) · line 239
Quoted 2 lines
drivers/thunderbolt/tb.c +2
-0+if (!sw->link_usb4) +return 0 ;On both here and the previous "up" check; should we be returning 0? Wouldn't it be better to return an appropriate error code? It sounds like 0 is considered a success....
The idea here is that you can call this function for every type of router (can be one without USB3 adapters so TBT 3,1,2) and it creates the tunnel if conditions for USB3 tunneling are met. It is not considered an error.
However, if the operations fail for some reason we return appropriate error code.
Re: [PATCH 09/17] thunderbolt: Do not tunnel USB3 if link is not USB4
Hi Mika,
Quoted 34 lines · Mika Westerberg
Quoted 3 lines · Prashant Malani
Hi Mika,
Sorry for the late comment..
Sorry for the late reply, was on vacation ;-)
Quoted 20 lines · Mika Westerberg
Quoted 19 lines
USB3 tunneling is possible only over USB4 link so don't create USB3 tunnels if that's not the case.
Signed-off-by Mika Westerberg <[email protected]>--- drivers/thunderbolt/tb.c | 3 +++ drivers/thunderbolt/tb.h | 2 ++ drivers/thunderbolt/tb_regs.h | 1 + drivers/thunderbolt/usb4.c | 24 +++++++++++++++++++++--- 4 files changed, 27 insertions(+), 3 deletions(-)drivers/thunderbolt/tb.c +0
-0@@ -235,6 +235,9 @@ static int tb_tunnel_usb3(struct tb *tb, struct tb_switch *sw)if (!up)return 0 ;Quoted 5 lines
drivers/thunderbolt/tb.c static int tb_tunnel_usb3(struct tb *tb, struct tb_switch *sw) · line 239
Quoted 2 lines
drivers/thunderbolt/tb.c +2
-0+if (!sw->link_usb4) +return 0 ;On both here and the previous "up" check; should we be returning 0? Wouldn't it be better to return an appropriate error code? It sounds like 0 is considered a success....
Quoted 7 lines
The idea here is that you can call this function for every type of router (can be one without USB3 adapters so TBT 3,1,2) and it creates the tunnel if conditions for USB3 tunneling are met. It is not considered an error.
However, if the operations fail for some reason we return appropriate error code.
Got it. Thanks for the explanation!
BR,
-Prashant
PATCH 10/17 thunderbolt: Make usb4_switch_map_usb3_down() also return enabled ports
In reply to Mika WesterbergWe need to call this on enabled ports in order to find the mapping from host router USB4 port to a USB 3.x downstream adapter, so make the function return enabled ports as well.
While there fix parameter alignment in tb_find_usb3_down().
--- drivers/thunderbolt/tb.c | 14 +++----------- drivers/thunderbolt/usb4.c | 2 +- 2 files changed, 4 insertions(+), 12 deletions(-)
drivers/thunderbolt/tb.c +3 -11
@@ -206,22 +206,14 @@ static struct tb_port *tb_find_unused_port(struct tb_switch *sw, }static struct tb_port *tb_find_usb3_down (struct tb_switch *sw, -const struct tb_port *port) +const struct tb_port *port) {struct tb_port *down; down =usb4_switch_map_usb3_down (sw, port); -if (down) { -if (WARN_ON (!tb_port_is_usb3_down (down))) - goto out; -if (WARN_ON (tb_usb3_port_is_enabled (down))) - goto out; - +if (down && !tb_usb3_port_is_enabled (down))return down; - } - -out: -return tb_find_unused_port (sw,TB_TYPE_USB3_DOWN ); +return NULL ; }static int tb_tunnel_usb3 (struct tb *tb,struct tb_switch *sw)
drivers/thunderbolt/usb4.c +1 -1
@@ -759,7 +759,7 @@ struct tb_port *usb4_switch_map_usb3_down(struct tb_switch *sw,if (!tb_port_is_usb3_down (p))continue ; -if (usb_idx == usb4_idx && !tb_usb3_port_is_enabled (p)) +if (usb_idx == usb4_idx)return p; usb_idx++;
Signature · 1 line
2.27.0.rc2
PATCH 11/17 thunderbolt: Make usb4_switch_map_pcie_down() also return enabled ports
In reply to Mika WesterbergJust for symmetry with the usb4_switch_map_usb3_down() make this one also return ports that are enabled.
--- drivers/thunderbolt/tb.c | 2 +- drivers/thunderbolt/usb4.c | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-)
drivers/thunderbolt/tb.c +1 -1
@@ -520,7 +520,7 @@ static struct tb_port *tb_find_pcie_down(struct tb_switch *sw,if (down) {if (WARN_ON (!tb_port_is_pcie_down (down))) goto out; -if (WARN_ON (tb_pci_port_is_enabled (down))) +if (tb_pci_port_is_enabled (down)) goto out;return down;
drivers/thunderbolt/usb4.c +1 -1
@@ -728,7 +728,7 @@ struct tb_port *usb4_switch_map_pcie_down(struct tb_switch *sw,if (!tb_port_is_pcie_down (p))continue ; -if (pcie_idx == usb4_idx && !tb_pci_port_is_enabled (p)) +if (pcie_idx == usb4_idx)return p; pcie_idx++;
Signature · 1 line
2.27.0.rc2
PATCH 12/17 thunderbolt: Report consumed bandwidth in both directions
In reply to Mika WesterbergWhereas DisplayPort bandwidth is consumed only in one direction (from DP IN adapter to DP OUT adapter), USB3 adds separate bandwidth for both upstream and downstream directions.
For this reason extend the tunnel consumed bandwidth routines to support both directions and implement this for DP.
--- drivers/thunderbolt/tb.c | 9 ++++--- drivers/thunderbolt/tunnel.c | 47 +++++++++++++++++++++++++++++------- drivers/thunderbolt/tunnel.h | 6 +++-- 3 files changed, 47 insertions(+), 15 deletions(-)
drivers/thunderbolt/tb.c +5 -4
@@ -535,7 +535,7 @@ static int tb_available_bw(struct tb_cm *tcm, struct tb_port *in, {struct tb_switch *sw = out->sw;struct tb_tunnel *tunnel; -int bw, available_bw =40000 ; +int ret, bw, available_bw =40000 ;while (sw && sw != in->sw) { bw = sw->link_speed * sw->link_width *1000 ;/* Mb/s */
@@ -553,9 +553,10 @@ static int tb_available_bw(struct tb_cm *tcm, struct tb_port *in,if (!tb_tunnel_switch_on_path (tunnel, sw))continue ; - consumed_bw =tb_tunnel_consumed_bandwidth (tunnel); -if (consumed_bw <0 ) -return consumed_bw; + ret =tb_tunnel_consumed_bandwidth (tunnel,NULL , + &consumed_bw); +if (ret) +return ret; bw -= consumed_bw; }
drivers/thunderbolt/tunnel.c +38 -9
76 lines not on this page · raw message
drivers/thunderbolt/tunnel.h +4 -2
@@ -42,7 +42,8 @@ struct tb_tunnel {size_t npaths;int (*init)(struct tb_tunnel *tunnel);int (*activate)(struct tb_tunnel *tunnel,bool activate); -int (*consumed_bandwidth)(struct tb_tunnel *tunnel); +int (*consumed_bandwidth)(struct tb_tunnel *tunnel,int *consumed_up, +int *consumed_down);struct list_head list;enum tb_tunnel_type type;unsigned int max_bw;
@@ -69,7 +70,8 @@ void tb_tunnel_deactivate(struct tb_tunnel *tunnel);bool tb_tunnel_is_invalid (struct tb_tunnel *tunnel);bool tb_tunnel_switch_on_path (const struct tb_tunnel *tunnel,const struct tb_switch *sw); -int tb_tunnel_consumed_bandwidth (struct tb_tunnel *tunnel); +int tb_tunnel_consumed_bandwidth (struct tb_tunnel *tunnel,int *consumed_up, +int *consumed_down);static inline bool tb_tunnel_is_pci (const struct tb_tunnel *tunnel) {
Signature · 1 line
2.27.0.rc2
PATCH 13/17 thunderbolt: Increase DP DPRX wait timeout
In reply to Mika WesterbergSometimes it takes longer for DPRX to be set so increase the timeout to cope with this.
--- drivers/thunderbolt/tunnel.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/thunderbolt/tunnel.c +1 -1
@@ -545,7 +545,7 @@ static int tb_dp_consumed_bandwidth(struct tb_tunnel *tunnel, int *consumed_up,int ret;if (tb_dp_is_usb4 (sw)) { -int timeout =10 ; +int timeout =20 ;/* * Wait for DPRX done. Normally it should be already set
Signature · 1 line
2.27.0.rc2
PATCH 14/17 thunderbolt: Implement USB3 bandwidth negotiation routines
In reply to Mika WesterbergEach host router USB3 downstream adapter has a set of registers that are used to negotiate bandwidth between the connection manager and the internal xHCI controller. These registers allow dynamic bandwidth management for USB3 isochronous traffic based on what is actually consumed vs. allocated at any given time.
Implement these USB3 bandwidth negotiation routines to allow the software connection manager take advantage of these.
--- drivers/thunderbolt/tb.h | 9 + drivers/thunderbolt/tb_regs.h | 19 ++ drivers/thunderbolt/usb4.c | 341 ++++++++++++++++++++++++++++++++++ 3 files changed, 369 insertions(+)
drivers/thunderbolt/tb.h +9 -0
@@ -853,4 +853,13 @@ struct tb_port *usb4_switch_map_usb3_down(struct tb_switch *sw, const struct tb_port *port);int usb4_port_unlock (struct tb_port *port); + +int usb4_usb3_port_max_link_rate (struct tb_port *port); +int usb4_usb3_port_actual_link_rate (struct tb_port *port); +int usb4_usb3_port_allocated_bandwidth (struct tb_port *port,int *upstream_bw, +int *downstream_bw); +int usb4_usb3_port_allocate_bandwidth (struct tb_port *port,int *upstream_bw, +int *downstream_bw); +int usb4_usb3_port_release_bandwidth (struct tb_port *port,int *upstream_bw, +int *downstream_bw);#endif
drivers/thunderbolt/tb_regs.h +19 -0
@@ -338,6 +338,25 @@ struct tb_regs_port_header {#define ADP_USB3_CS_0 0x00#define ADP_USB3_CS_0_V BIT(30)#define ADP_USB3_CS_0_PE BIT(31) +#define ADP_USB3_CS_1 0x01 +#define ADP_USB3_CS_1_CUBW_MASK GENMASK(11, 0) +#define ADP_USB3_CS_1_CDBW_MASK GENMASK(23, 12) +#define ADP_USB3_CS_1_CDBW_SHIFT 12 +#define ADP_USB3_CS_1_HCA BIT(31) +#define ADP_USB3_CS_2 0x02 +#define ADP_USB3_CS_2_AUBW_MASK GENMASK(11, 0) +#define ADP_USB3_CS_2_ADBW_MASK GENMASK(23, 12) +#define ADP_USB3_CS_2_ADBW_SHIFT 12 +#define ADP_USB3_CS_2_CMR BIT(31) +#define ADP_USB3_CS_3 0x03 +#define ADP_USB3_CS_3_SCALE_MASK GENMASK(5, 0) +#define ADP_USB3_CS_4 0x04 +#define ADP_USB3_CS_4_ALR_MASK GENMASK(6, 0) +#define ADP_USB3_CS_4_ALR_20G 0x1 +#define ADP_USB3_CS_4_ULV BIT(7) +#define ADP_USB3_CS_4_MSLR_MASK GENMASK(18, 12) +#define ADP_USB3_CS_4_MSLR_SHIFT 12 +#define ADP_USB3_CS_4_MSLR_20G 0x1/* Hop register from TB_CFG_HOPS. 8 byte per entry. */ struct tb_regs_hop {
drivers/thunderbolt/usb4.c +341 -0
344 lines not on this page · raw message
Signature · 1 line
2.27.0.rc2
PATCH 15/17 thunderbolt: Make tb_port_get_link_speed() available to other files
In reply to Mika WesterbergWe need to call this from tb.c when we improve the bandwidth management to take USB3 into account.
--- drivers/thunderbolt/switch.c | 8 +++++++- drivers/thunderbolt/tb.h | 2 ++ 2 files changed, 9 insertions(+), 1 deletion(-)
drivers/thunderbolt/switch.c +7 -1
@@ -911,7 +911,13 @@ struct tb_port *tb_next_port_on_path(struct tb_port *start, struct tb_port *end,return next != prev ? next :NULL ; } -static int tb_port_get_link_speed (struct tb_port *port) +/** +* tb_port_get_link_speed() - Get current link speed +* @port: Port to check (USB4 or CIO) +* +* Returns link speed in Gb/s or negative errno in case of failure. +*/ +int tb_port_get_link_speed (struct tb_port *port) {u32 val, speed;int ret;
drivers/thunderbolt/tb.h +2 -0
@@ -759,6 +759,8 @@ struct tb_port *tb_next_port_on_path(struct tb_port *start, struct tb_port *end,for ((p) =tb_next_port_on_path ((src), (dst),NULL ); (p); \ (p) =tb_next_port_on_path ((src), (dst), (p))) +int tb_port_get_link_speed(struct tb_port *port); +int tb_switch_find_vse_cap (struct tb_switch *sw,enum tb_switch_vse_cap vsec);int tb_switch_find_cap (struct tb_switch *sw,enum tb_switch_cap cap);int tb_port_find_cap (struct tb_port *port,enum tb_port_cap cap);
Signature · 1 line
2.27.0.rc2
PATCH 16/17 thunderbolt: Add USB3 bandwidth management
In reply to Mika WesterbergUSB3 supports both isochronous and non-isochronous traffic. The former requires guaranteed bandwidth and can take up to 90% of the total bandwidth. With USB4 USB3 is tunneled over USB4 fabric which means that we need to make sure there is enough bandwidth allocated for the USB3 tunnels in addition to DisplayPort tunnels.
Whereas DisplayPort bandwidth management is static and done before the DP tunnel is established, the USB3 bandwidth management is dynamic and allows increasing and decreasing the allocated bandwidth according to what is currently consumed. This is done through host router USB3 downstream adapter registers.
This adds USB3 bandwidth management to the software connection manager so that we always try to allocate maximum bandwidth for DP tunnels and what is left is allocated for USB3.
--- drivers/thunderbolt/path.c | 13 +- drivers/thunderbolt/tb.c | 340 ++++++++++++++++++++++++++--------- drivers/thunderbolt/tb.h | 4 +- drivers/thunderbolt/tunnel.c | 255 ++++++++++++++++++++++++-- drivers/thunderbolt/tunnel.h | 31 +++- 5 files changed, 532 insertions(+), 111 deletions(-)
drivers/thunderbolt/path.c +6 -7
@@ -570,21 +570,20 @@ bool tb_path_is_invalid(struct tb_path *path) }/** -* tb_path_switch_on_path() - Does the path go through certain switch +* tb_path_port_on_path() - Does the path go through certain port * @path: Path to check -* @sw: Switch to check +* @port: Switch to check * -* Goes over all hops on path and checks if @sw is any of them. +* Goes over all hops on path and checks if @port is any of them. * Direction does not matter. */ -bool tb_path_switch_on_path (const struct tb_path *path, -const struct tb_switch *sw) +bool tb_path_port_on_path (const struct tb_path *path,const struct tb_port *port) {int i;for (i =0 ; i < path->path_length; i++) { -if (path->hops[i].in_port->sw == sw || - path->hops[i].out_port->sw == sw) +if (path->hops[i].in_port == port || + path->hops[i].out_port == port)return true; }
drivers/thunderbolt/tb.c +257 -83
415 lines not on this page · raw message
drivers/thunderbolt/tb.h +2 -2
@@ -789,8 +789,8 @@ void tb_path_free(struct tb_path *path);int tb_path_activate (struct tb_path *path);void tb_path_deactivate (struct tb_path *path);bool tb_path_is_invalid (struct tb_path *path); -bool tb_path_switch_on_path (const struct tb_path *path, -const struct tb_switch *sw); +bool tb_path_port_on_path (const struct tb_path *path, +const struct tb_port *port);int tb_drom_read (struct tb_switch *sw);int tb_drom_read_uid_only (struct tb_switch *sw,u64 *uid);
drivers/thunderbolt/tunnel.c +242 -13
351 lines not on this page · raw message
drivers/thunderbolt/tunnel.h +25 -6
@@ -29,10 +29,16 @@ enum tb_tunnel_type {* @init: Optional tunnel specific initialization * @activate: Optional tunnel specific activation/deactivation * @consumed_bandwidth: Return how much bandwidth the tunnel consumes +* @release_unused_bandwidth: Release all unused bandwidth +* @reclaim_available_bandwidth: Reclaim back available bandwidth * @list: Tunnels are linked using this field * @type: Type of the tunnel -* @max_bw: Maximum bandwidth (Mb/s) available for the tunnel (only for DP). +* @max_up: Maximum upstream bandwidth (Mb/s) available for the tunnel. * Only set if the bandwidth needs to be limited. +* @max_down: Maximum downstream bandwidth (Mb/s) available for the tunnel. +* Only set if the bandwidth needs to be limited. +* @allocated_up: Allocated upstream bandwidth (only for USB3) +* @allocated_down: Allocated downstream bandwidth (only for USB3) */ struct tb_tunnel {struct tb *tb;
@@ -44,9 +50,16 @@ struct tb_tunnel {int (*activate)(struct tb_tunnel *tunnel,bool activate);int (*consumed_bandwidth)(struct tb_tunnel *tunnel,int *consumed_up,int *consumed_down); +int (*release_unused_bandwidth)(struct tb_tunnel *tunnel); +void (*reclaim_available_bandwidth)(struct tb_tunnel *tunnel, +int *available_up, +int *available_down);struct list_head list;enum tb_tunnel_type type; -unsigned int max_bw; +int max_up; +int max_down; +int allocated_up; +int allocated_down; };struct tb_tunnel *tb_tunnel_discover_pci (struct tb *tb,struct tb_port *down);
@@ -54,24 +67,30 @@ struct tb_tunnel *tb_tunnel_alloc_pci(struct tb *tb, struct tb_port *up, struct tb_port *down);struct tb_tunnel *tb_tunnel_discover_dp (struct tb *tb,struct tb_port *in);struct tb_tunnel *tb_tunnel_alloc_dp (struct tb *tb,struct tb_port *in, -struct tb_port *out,int max_bw); +struct tb_port *out,int max_up, +int max_down);struct tb_tunnel *tb_tunnel_alloc_dma (struct tb *tb,struct tb_port *nhi,struct tb_port *dst,int transmit_ring,int transmit_path,int receive_ring,int receive_path);struct tb_tunnel *tb_tunnel_discover_usb3 (struct tb *tb,struct tb_port *down);struct tb_tunnel *tb_tunnel_alloc_usb3 (struct tb *tb,struct tb_port *up, -struct tb_port *down); +struct tb_port *down,int max_up, +int max_down);void tb_tunnel_free (struct tb_tunnel *tunnel);int tb_tunnel_activate (struct tb_tunnel *tunnel);int tb_tunnel_restart (struct tb_tunnel *tunnel);void tb_tunnel_deactivate (struct tb_tunnel *tunnel);bool tb_tunnel_is_invalid (struct tb_tunnel *tunnel); -bool tb_tunnel_switch_on_path (const struct tb_tunnel *tunnel, -const struct tb_switch *sw); +bool tb_tunnel_port_on_path (const struct tb_tunnel *tunnel, +const struct tb_port *port);int tb_tunnel_consumed_bandwidth (struct tb_tunnel *tunnel,int *consumed_up,int *consumed_down); +int tb_tunnel_release_unused_bandwidth (struct tb_tunnel *tunnel); +void tb_tunnel_reclaim_available_bandwidth (struct tb_tunnel *tunnel, +int *available_up, +int *available_down);static inline bool tb_tunnel_is_pci (const struct tb_tunnel *tunnel) {
Signature · 1 line
2.27.0.rc2
PATCH 17/17 thunderbolt: Add KUnit tests for tunneling
In reply to Mika WesterbergWe can test some parts of tunneling, like path allocation without access to test hardware so add KUnit tests for PCIe, DP and USB3 tunneling.
--- drivers/thunderbolt/test.c | 398 +++++++++++++++++++++++++++++++++++++ 1 file changed, 398 insertions(+)
drivers/thunderbolt/test.c +398 -0
@@ -10,6 +10,7 @@#include <linux/idr.h> #include "tb.h" +#include "tunnel.h" static int __ida_init (struct kunit_resource *res,void *context) {
@@ -1203,6 +1204,396 @@ static void tb_test_path_mixed_chain_reverse(struct kunit *test)tb_path_free (path); } +static void tb_test_tunnel_pcie (struct kunit *test) +{ +struct tb_switch *host, *dev1, *dev2; +struct tb_tunnel *tunnel1, *tunnel2; +struct tb_port *down, *up; + +/* +* Create PCIe tunnel between host and two devices. +* +* [Host] +* 1 | +* 1 | +* [Device #1] +* 5 | +* 1 | +* [Device #2] +*/ + host =alloc_host (test); + dev1 =alloc_dev_default (test, host,0x1 , true); + dev2 =alloc_dev_default (test, dev1,0x501 , true); + + down = &host->ports[8 ]; + up = &dev1->ports[9 ]; + tunnel1 =tb_tunnel_alloc_pci (NULL , up, down); +KUNIT_ASSERT_TRUE (test, tunnel1 !=NULL ); +KUNIT_EXPECT_EQ (test, tunnel1->type, (enum tb_tunnel_type )TB_TUNNEL_PCI ); +KUNIT_EXPECT_PTR_EQ (test, tunnel1->src_port, down); +KUNIT_EXPECT_PTR_EQ (test, tunnel1->dst_port, up); +KUNIT_ASSERT_EQ (test, tunnel1->npaths, (size_t )2 ); +KUNIT_ASSERT_EQ (test, tunnel1->paths[0 ]->path_length,2 ); +KUNIT_EXPECT_PTR_EQ (test, tunnel1->paths[0 ]->hops[0 ].in_port, down); +KUNIT_EXPECT_PTR_EQ (test, tunnel1->paths[0 ]->hops[1 ].out_port, up); +KUNIT_ASSERT_EQ (test, tunnel1->paths[1 ]->path_length,2 ); +KUNIT_EXPECT_PTR_EQ (test, tunnel1->paths[1 ]->hops[0 ].in_port, up); +KUNIT_EXPECT_PTR_EQ (test, tunnel1->paths[1 ]->hops[1 ].out_port, down); + + down = &dev1->ports[10 ]; + up = &dev2->ports[9 ]; + tunnel2 =tb_tunnel_alloc_pci (NULL , up, down); +KUNIT_ASSERT_TRUE (test, tunnel2 !=NULL ); +KUNIT_EXPECT_EQ (test, tunnel2->type, (enum tb_tunnel_type )TB_TUNNEL_PCI ); +KUNIT_EXPECT_PTR_EQ (test, tunnel2->src_port, down); +KUNIT_EXPECT_PTR_EQ (test, tunnel2->dst_port, up); +KUNIT_ASSERT_EQ (test, tunnel2->npaths, (size_t )2 ); +KUNIT_ASSERT_EQ (test, tunnel2->paths[0 ]->path_length,2 ); +KUNIT_EXPECT_PTR_EQ (test, tunnel2->paths[0 ]->hops[0 ].in_port, down); +KUNIT_EXPECT_PTR_EQ (test, tunnel2->paths[0 ]->hops[1 ].out_port, up); +KUNIT_ASSERT_EQ (test, tunnel2->paths[1 ]->path_length,2 ); +KUNIT_EXPECT_PTR_EQ (test, tunnel2->paths[1 ]->hops[0 ].in_port, up); +KUNIT_EXPECT_PTR_EQ (test, tunnel2->paths[1 ]->hops[1 ].out_port, down); + +tb_tunnel_free (tunnel2); +tb_tunnel_free (tunnel1); +} + +static void tb_test_tunnel_dp (struct kunit *test) +{ +struct tb_switch *host, *dev; +struct tb_port *in, *out; +struct tb_tunnel *tunnel; + +/* +* Create DP tunnel between Host and Device +* +* [Host] +* 1 | +* 1 | +* [Device] +*/ + host =alloc_host (test); + dev =alloc_dev_default (test, host,0x3 , true); + + in = &host->ports[5 ]; + out = &dev->ports[13 ]; + + tunnel =tb_tunnel_alloc_dp (NULL , in, out,0 ,0 ); +KUNIT_ASSERT_TRUE (test, tunnel !=NULL ); +KUNIT_EXPECT_EQ (test, tunnel->type, (enum tb_tunnel_type )TB_TUNNEL_DP ); +KUNIT_EXPECT_PTR_EQ (test, tunnel->src_port, in); +KUNIT_EXPECT_PTR_EQ (test, tunnel->dst_port, out); +KUNIT_ASSERT_EQ (test, tunnel->npaths, (size_t )3 ); +KUNIT_ASSERT_EQ (test, tunnel->paths[0 ]->path_length,2 ); +KUNIT_EXPECT_PTR_EQ (test, tunnel->paths[0 ]->hops[0 ].in_port, in); +KUNIT_EXPECT_PTR_EQ (test, tunnel->paths[0 ]->hops[1 ].out_port, out); +KUNIT_ASSERT_EQ (test, tunnel->paths[1 ]->path_length,2 ); +KUNIT_EXPECT_PTR_EQ (test, tunnel->paths[1 ]->hops[0 ].in_port, in); +KUNIT_EXPECT_PTR_EQ (test, tunnel->paths[1 ]->hops[1 ].out_port, out); +KUNIT_ASSERT_EQ (test, tunnel->paths[2 ]->path_length,2 ); +KUNIT_EXPECT_PTR_EQ (test, tunnel->paths[2 ]->hops[0 ].in_port, out); +KUNIT_EXPECT_PTR_EQ (test, tunnel->paths[2 ]->hops[1 ].out_port, in); +tb_tunnel_free (tunnel); +} + +static void tb_test_tunnel_dp_chain (struct kunit *test) +{ +struct tb_switch *host, *dev1, *dev4; +struct tb_port *in, *out; +struct tb_tunnel *tunnel; + +/* +* Create DP tunnel from Host DP IN to Device #4 DP OUT. +* +* [Host] +* 1 | +* 1 | +* [Device #1] +* 3 / | 5 \ 7 +* 1 / | \ 1 +* [Device #2] | [Device #4] +* | 1 +* [Device #3] +*/ + host =alloc_host (test); + dev1 =alloc_dev_default (test, host,0x1 , true); +alloc_dev_default (test, dev1,0x301 , true); +alloc_dev_default (test, dev1,0x501 , true); + dev4 =alloc_dev_default (test, dev1,0x701 , true); + + in = &host->ports[5 ]; + out = &dev4->ports[14 ]; + + tunnel =tb_tunnel_alloc_dp (NULL , in, out,0 ,0 ); +KUNIT_ASSERT_TRUE (test, tunnel !=NULL ); +KUNIT_EXPECT_EQ (test, tunnel->type, (enum tb_tunnel_type )TB_TUNNEL_DP ); +KUNIT_EXPECT_PTR_EQ (test, tunnel->src_port, in); +KUNIT_EXPECT_PTR_EQ (test, tunnel->dst_port, out); +KUNIT_ASSERT_EQ (test, tunnel->npaths, (size_t )3 ); +KUNIT_ASSERT_EQ (test, tunnel->paths[0 ]->path_length,3 ); +KUNIT_EXPECT_PTR_EQ (test, tunnel->paths[0 ]->hops[0 ].in_port, in); +KUNIT_EXPECT_PTR_EQ (test, tunnel->paths[0 ]->hops[2 ].out_port, out); +KUNIT_ASSERT_EQ (test, tunnel->paths[1 ]->path_length,3 ); +KUNIT_EXPECT_PTR_EQ (test, tunnel->paths[1 ]->hops[0 ].in_port, in); +KUNIT_EXPECT_PTR_EQ (test, tunnel->paths[1 ]->hops[2 ].out_port, out); +KUNIT_ASSERT_EQ (test, tunnel->paths[2 ]->path_length,3 ); +KUNIT_EXPECT_PTR_EQ (test, tunnel->paths[2 ]->hops[0 ].in_port, out); +KUNIT_EXPECT_PTR_EQ (test, tunnel->paths[2 ]->hops[2 ].out_port, in); +tb_tunnel_free (tunnel); +} + +static void tb_test_tunnel_dp_tree (struct kunit *test) +{ +struct tb_switch *host, *dev1, *dev2, *dev3, *dev5; +struct tb_port *in, *out; +struct tb_tunnel *tunnel; + +/* +* Create DP tunnel from Device #2 DP IN to Device #5 DP OUT. +* +* [Host] +* 3 | +* 1 | +* [Device #1] +* 3 / | 5 \ 7 +* 1 / | \ 1 +* [Device #2] | [Device #4] +* | 1 +* [Device #3] +* | 5 +* | 1 +* [Device #5] +*/ + host =alloc_host (test); + dev1 =alloc_dev_default (test, host,0x3 , true); + dev2 =alloc_dev_with_dpin (test, dev1,0x303 , true); + dev3 =alloc_dev_default (test, dev1,0x503 , true); +alloc_dev_default (test, dev1,0x703 , true); + dev5 =alloc_dev_default (test, dev3,0x50503 , true); + + in = &dev2->ports[13 ]; + out = &dev5->ports[13 ]; + + tunnel =tb_tunnel_alloc_dp (NULL , in, out,0 ,0 ); +KUNIT_ASSERT_TRUE (test, tunnel !=NULL ); +KUNIT_EXPECT_EQ (test, tunnel->type, (enum tb_tunnel_type )TB_TUNNEL_DP ); +KUNIT_EXPECT_PTR_EQ (test, tunnel->src_port, in); +KUNIT_EXPECT_PTR_EQ (test, tunnel->dst_port, out); +KUNIT_ASSERT_EQ (test, tunnel->npaths, (size_t )3 ); +KUNIT_ASSERT_EQ (test, tunnel->paths[0 ]->path_length,4 ); +KUNIT_EXPECT_PTR_EQ (test, tunnel->paths[0 ]->hops[0 ].in_port, in); +KUNIT_EXPECT_PTR_EQ (test, tunnel->paths[0 ]->hops[3 ].out_port, out); +KUNIT_ASSERT_EQ (test, tunnel->paths[1 ]->path_length,4 ); +KUNIT_EXPECT_PTR_EQ (test, tunnel->paths[1 ]->hops[0 ].in_port, in); +KUNIT_EXPECT_PTR_EQ (test, tunnel->paths[1 ]->hops[3 ].out_port, out); +KUNIT_ASSERT_EQ (test, tunnel->paths[2 ]->path_length,4 ); +KUNIT_EXPECT_PTR_EQ (test, tunnel->paths[2 ]->hops[0 ].in_port, out); +KUNIT_EXPECT_PTR_EQ (test, tunnel->paths[2 ]->hops[3 ].out_port, in); +tb_tunnel_free (tunnel); +} + +static void tb_test_tunnel_dp_max_length (struct kunit *test) +{ +struct tb_switch *host, *dev1, *dev2, *dev3, *dev4, *dev5, *dev6; +struct tb_switch *dev7, *dev8, *dev9, *dev10, *dev11, *dev12; +struct tb_port *in, *out; +struct tb_tunnel *tunnel; + +/* +* Creates DP tunnel from Device #6 to Device #12. +* +* [Host] +* 1 / \ 3 +* 1 / \ 1 +* [Device #1] [Device #7] +* 3 | | 3 +* 1 | | 1 +* [Device #2] [Device #8] +* 3 | | 3 +* 1 | | 1 +* [Device #3] [Device #9] +* 3 | | 3 +* 1 | | 1 +* [Device #4] [Device #10] +* 3 | | 3 +* 1 | | 1 +* [Device #5] [Device #11] +* 3 | | 3 +* 1 | | 1 +* [Device #6] [Device #12] +*/ + host =alloc_host (test); + dev1 =alloc_dev_default (test, host,0x1 , true); + dev2 =alloc_dev_default (test, dev1,0x301 , true); + dev3 =alloc_dev_default (test, dev2,0x30301 , true); + dev4 =alloc_dev_default (test, dev3,0x3030301 , true); + dev5 =alloc_dev_default (test, dev4,0x303030301 , true); + dev6 =alloc_dev_with_dpin (test, dev5,0x30303030301 , true); + dev7 =alloc_dev_default (test, host,0x3 , true); + dev8 =alloc_dev_default (test, dev7,0x303 , true); + dev9 =alloc_dev_default (test, dev8,0x30303 , true); + dev10 =alloc_dev_default (test, dev9,0x3030303 , true); + dev11 =alloc_dev_default (test, dev10,0x303030303 , true); + dev12 =alloc_dev_default (test, dev11,0x30303030303 , true); + + in = &dev6->ports[13 ]; + out = &dev12->ports[13 ]; + + tunnel =tb_tunnel_alloc_dp (NULL , in, out,0 ,0 ); +KUNIT_ASSERT_TRUE (test, tunnel !=NULL ); +KUNIT_EXPECT_EQ (test, tunnel->type, (enum tb_tunnel_type )TB_TUNNEL_DP ); +KUNIT_EXPECT_PTR_EQ (test, tunnel->src_port, in); +KUNIT_EXPECT_PTR_EQ (test, tunnel->dst_port, out); +KUNIT_ASSERT_EQ (test, tunnel->npaths, (size_t )3 ); +KUNIT_ASSERT_EQ (test, tunnel->paths[0 ]->path_length,13 ); +/* First hop */ +KUNIT_EXPECT_PTR_EQ (test, tunnel->paths[0 ]->hops[0 ].in_port, in); +/* Middle */ +KUNIT_EXPECT_PTR_EQ (test, tunnel->paths[0 ]->hops[6 ].in_port, + &host->ports[1 ]); +KUNIT_EXPECT_PTR_EQ (test, tunnel->paths[0 ]->hops[6 ].out_port, + &host->ports[3 ]); +/* Last */ +KUNIT_EXPECT_PTR_EQ (test, tunnel->paths[0 ]->hops[12 ].out_port, out); +KUNIT_ASSERT_EQ (test, tunnel->paths[1 ]->path_length,13 ); +KUNIT_EXPECT_PTR_EQ (test, tunnel->paths[1 ]->hops[0 ].in_port, in); +KUNIT_EXPECT_PTR_EQ (test, tunnel->paths[1 ]->hops[6 ].in_port, + &host->ports[1 ]); +KUNIT_EXPECT_PTR_EQ (test, tunnel->paths[1 ]->hops[6 ].out_port, + &host->ports[3 ]); +KUNIT_EXPECT_PTR_EQ (test, tunnel->paths[1 ]->hops[12 ].out_port, out); +KUNIT_ASSERT_EQ (test, tunnel->paths[2 ]->path_length,13 ); +KUNIT_EXPECT_PTR_EQ (test, tunnel->paths[2 ]->hops[0 ].in_port, out); +KUNIT_EXPECT_PTR_EQ (test, tunnel->paths[2 ]->hops[6 ].in_port, + &host->ports[3 ]); +KUNIT_EXPECT_PTR_EQ (test, tunnel->paths[2 ]->hops[6 ].out_port, + &host->ports[1 ]); +KUNIT_EXPECT_PTR_EQ (test, tunnel->paths[2 ]->hops[12 ].out_port, in); +tb_tunnel_free (tunnel); +} + +static void tb_test_tunnel_usb3 (struct kunit *test) +{ +struct tb_switch *host, *dev1, *dev2; +struct tb_tunnel *tunnel1, *tunnel2; +struct tb_port *down, *up; + +/* +* Create USB3 tunnel between host and two devices. +* +* [Host] +* 1 | +* 1 | +* [Device #1] +* \ 7 +* \ 1 +* [Device #2] +*/ + host =alloc_host (test); + dev1 =alloc_dev_default (test, host,0x1 , true); + dev2 =alloc_dev_default (test, dev1,0x701 , true); + + down = &host->ports[12 ]; + up = &dev1->ports[16 ]; + tunnel1 =tb_tunnel_alloc_usb3 (NULL , up, down,0 ,0 ); +KUNIT_ASSERT_TRUE (test, tunnel1 !=NULL ); +KUNIT_EXPECT_EQ (test, tunnel1->type, (enum tb_tunnel_type )TB_TUNNEL_USB3 ); +KUNIT_EXPECT_PTR_EQ (test, tunnel1->src_port, down); +KUNIT_EXPECT_PTR_EQ (test, tunnel1->dst_port, up); +KUNIT_ASSERT_EQ (test, tunnel1->npaths, (size_t )2 ); +KUNIT_ASSERT_EQ (test, tunnel1->paths[0 ]->path_length,2 ); +KUNIT_EXPECT_PTR_EQ (test, tunnel1->paths[0 ]->hops[0 ].in_port, down); +KUNIT_EXPECT_PTR_EQ (test, tunnel1->paths[0 ]->hops[1 ].out_port, up); +KUNIT_ASSERT_EQ (test, tunnel1->paths[1 ]->path_length,2 ); +KUNIT_EXPECT_PTR_EQ (test, tunnel1->paths[1 ]->hops[0 ].in_port, up); +KUNIT_EXPECT_PTR_EQ (test, tunnel1->paths[1 ]->hops[1 ].out_port, down); + + down = &dev1->ports[17 ]; + up = &dev2->ports[16 ]; + tunnel2 =tb_tunnel_alloc_usb3 (NULL , up, down,0 ,0 ); +KUNIT_ASSERT_TRUE (test, tunnel2 !=NULL ); +KUNIT_EXPECT_EQ (test, tunnel2->type, (enum tb_tunnel_type )TB_TUNNEL_USB3 ); +KUNIT_EXPECT_PTR_EQ (test, tunnel2->src_port, down); +KUNIT_EXPECT_PTR_EQ (test, tunnel2->dst_port, up); +KUNIT_ASSERT_EQ (test, tunnel2->npaths, (size_t )2 ); +KUNIT_ASSERT_EQ (test, tunnel2->paths[0 ]->path_length,2 ); +KUNIT_EXPECT_PTR_EQ (test, tunnel2->paths[0 ]->hops[0 ].in_port, down); +KUNIT_EXPECT_PTR_EQ (test, tunnel2->paths[0 ]->hops[1 ].out_port, up); +KUNIT_ASSERT_EQ (test, tunnel2->paths[1 ]->path_length,2 ); +KUNIT_EXPECT_PTR_EQ (test, tunnel2->paths[1 ]->hops[0 ].in_port, up); +KUNIT_EXPECT_PTR_EQ (test, tunnel2->paths[1 ]->hops[1 ].out_port, down); + +tb_tunnel_free (tunnel2); +tb_tunnel_free (tunnel1); +} + +static void tb_test_tunnel_port_on_path (struct kunit *test) +{ +struct tb_switch *host, *dev1, *dev2, *dev3, *dev4, *dev5; +struct tb_port *in, *out, *port; +struct tb_tunnel *dp_tunnel; + +/* +* [Host] +* 3 | +* 1 | +* [Device #1] +* 3 / | 5 \ 7 +* 1 / | \ 1 +* [Device #2] | [Device #4] +* | 1 +* [Device #3] +* | 5 +* | 1 +* [Device #5] +*/ + host =alloc_host (test); + dev1 =alloc_dev_default (test, host,0x3 , true); + dev2 =alloc_dev_with_dpin (test, dev1,0x303 , true); + dev3 =alloc_dev_default (test, dev1,0x503 , true); + dev4 =alloc_dev_default (test, dev1,0x703 , true); + dev5 =alloc_dev_default (test, dev3,0x50503 , true); + + in = &dev2->ports[13 ]; + out = &dev5->ports[13 ]; + + dp_tunnel =tb_tunnel_alloc_dp (NULL , in, out,0 ,0 ); +KUNIT_ASSERT_TRUE (test, dp_tunnel !=NULL ); + +KUNIT_EXPECT_TRUE (test,tb_tunnel_port_on_path (dp_tunnel, in)); +KUNIT_EXPECT_TRUE (test,tb_tunnel_port_on_path (dp_tunnel, out)); + + port = &host->ports[8 ]; +KUNIT_EXPECT_FALSE (test,tb_tunnel_port_on_path (dp_tunnel, port)); + + port = &host->ports[3 ]; +KUNIT_EXPECT_FALSE (test,tb_tunnel_port_on_path (dp_tunnel, port)); + + port = &dev1->ports[1 ]; +KUNIT_EXPECT_FALSE (test,tb_tunnel_port_on_path (dp_tunnel, port)); + + port = &dev1->ports[3 ]; +KUNIT_EXPECT_TRUE (test,tb_tunnel_port_on_path (dp_tunnel, port)); + + port = &dev1->ports[5 ]; +KUNIT_EXPECT_TRUE (test,tb_tunnel_port_on_path (dp_tunnel, port)); + + port = &dev1->ports[7 ]; +KUNIT_EXPECT_FALSE (test,tb_tunnel_port_on_path (dp_tunnel, port)); + + port = &dev3->ports[1 ]; +KUNIT_EXPECT_TRUE (test,tb_tunnel_port_on_path (dp_tunnel, port)); + + port = &dev5->ports[1 ]; +KUNIT_EXPECT_TRUE (test,tb_tunnel_port_on_path (dp_tunnel, port)); + + port = &dev4->ports[1 ]; +KUNIT_EXPECT_FALSE (test,tb_tunnel_port_on_path (dp_tunnel, port)); + +tb_tunnel_free (dp_tunnel); +} +static struct kunit_case tb_test_cases[] = {KUNIT_CASE (tb_test_path_basic),KUNIT_CASE (tb_test_path_not_connected_walk),
@@ -1218,6 +1609,13 @@ static struct kunit_case tb_test_cases[] = {KUNIT_CASE (tb_test_path_not_bonded_lane1_chain_reverse),KUNIT_CASE (tb_test_path_mixed_chain),KUNIT_CASE (tb_test_path_mixed_chain_reverse), +KUNIT_CASE (tb_test_tunnel_pcie), +KUNIT_CASE (tb_test_tunnel_dp), +KUNIT_CASE (tb_test_tunnel_dp_chain), +KUNIT_CASE (tb_test_tunnel_dp_tree), +KUNIT_CASE (tb_test_tunnel_dp_max_length), +KUNIT_CASE (tb_test_tunnel_port_on_path), + KUNIT_CASE(tb_test_tunnel_usb3), { } };
Signature · 1 line
2.27.0.rc2
Quoted 22 lines · Mika Westerberg
Hi all,
This series improves the Thunderbolt/USB4 driver to support tree topologies that are now possible with USB4 devices (it is possible with TBT devices but there are no such devices available in the market with more than two ports).
We also take advantage of KUnit and add unit tests for path walking and tunneling (in cases where hardware is not needed). In addition we add initial support for USB3 tunnel bandwidth management so that the driver can share isochronous bandwidth between USB3 and DisplayPort.
Mika Westerberg (17):
thunderbolt: Fix path indices used in USB3 tunnel discovery
thunderbolt: Maketb_next_port_on_path()work with tree topologies
thunderbolt: Maketb_path_alloc()work with tree topologies
thunderbolt: Check that both ports are reachable when allocating path
thunderbolt: Handle incomplete PCIe/USB3 paths correctly in discovery
thunderbolt: Increase path length in discovery
thunderbolt: Add KUnit tests for path walking
thunderbolt: Add DP IN resources for all routers
thunderbolt: Do not tunnel USB3 if link is not USB4
Quoted 8 lines
thunderbolt: Make
usb4_switch_map_usb3_down()also return enabled ports
thunderbolt: Makeusb4_switch_map_pcie_down()also return enabled ports
thunderbolt: Report consumed bandwidth in both directions
thunderbolt: Increase DP DPRX wait timeout
thunderbolt: Implement USB3 bandwidth negotiation routines
thunderbolt: Maketb_port_get_link_speed()available to other files
thunderbolt: Add USB3 bandwidth management
thunderbolt: Add KUnit tests for tunneling
Queued these for v5.9.