thunderbolt: DisplayPort and bandwidth allocation mode improvements
Subsystems (2)
cover thunderbolt: DisplayPort and bandwidth allocation mode improvements
Hi all,
This series improves bandwidth allocation mode support to follow the USB4 spec more closely. In addition to that DisplayPort tunneling is made more robust so that if a tunnel does not come up properly (for example on a discrete controller the DisplayPort source from the graphics is not connected to the DisplayPort sink of the controller) we tear it down and continue pairing.
This series improves bandwidth allocation mode support and DisplayPort tunneling to follow the USB4 spec more closely.
Gil Fine (2):
thunderbolt: Calculate DisplayPort tunnel bandwidth after DPRX capabilities read
thunderbolt: Improve DisplayPort tunnel setup process to be more robust
Mika Westerberg (8):
thunderbolt: Use DP_LOCAL_CAP for maximum bandwidth calculation
thunderbolt: Re-calculate estimated bandwidth when allocation mode is enabled
thunderbolt: Handle bandwidth allocation mode disable request
thunderbolt: Log an error if DPTX request is not cleared
thunderbolt: Fail the failed bandwidth request properly
thunderbolt: Re-order bandwidth group functions
thunderbolt: Introduce tb_tunnel_direction_downstream()
thunderbolt: Reserve released DisplayPort bandwidth for a group for 10 seconds
drivers/thunderbolt/domain.c | 4 + drivers/thunderbolt/tb.c | 898 +++++++++++++++++++++-------------- drivers/thunderbolt/tb.h | 10 + drivers/thunderbolt/tunnel.c | 96 ++-- drivers/thunderbolt/tunnel.h | 6 + drivers/thunderbolt/usb4.c | 4 +- 6 files changed, 596 insertions(+), 422 deletions(-)
Signature · 1 line
2.43.0
PATCH 1/10 thunderbolt: Use DP_LOCAL_CAP for maximum bandwidth calculation
The DisplayPort IN adapter DP_LOCAL_CAP holds the aggregated capabilities and gets updated after graphics side does the DPRX capabilities read so we should use this to figure out the maximum possible bandwidth for the DisplayPort tunnel.
While there make the variable name to match better what it is used for and add kernel-doc comment to the function.
--- drivers/thunderbolt/tunnel.c | 57 ++++++++++++++++-------------------- 1 file changed, 25 insertions(+), 32 deletions(-)
drivers/thunderbolt/tunnel.c +25 -32
@@ -926,12 +926,18 @@ static int tb_dp_activate(struct tb_tunnel *tunnel, bool active)return 0 ; } -/* max_bw is rounded up to next granularity */ +/** +* tb_dp_bandwidth_mode_maximum_bandwidth() - Maximum possible bandwidth +* @tunnel: DP tunnel to check +* @max_bw_rounded: Maximum bandwidth in Mb/s rounded up to the next granularity +* +* Returns maximum possible bandwidth for this tunnel in Mb/s. +*/ static int tb_dp_bandwidth_mode_maximum_bandwidth (struct tb_tunnel *tunnel, -int *max_bw) +int *max_bw_rounded) {struct tb_port *in = tunnel->src_port; -int ret, rate, lanes, nrd_bw; +int ret, rate, lanes, max_bw;u32 cap;/*
@@ -947,32 +953,18 @@ static int tb_dp_bandwidth_mode_maximum_bandwidth(struct tb_tunnel *tunnel,return ret; rate =tb_dp_cap_get_rate_ext (cap); -if (tb_dp_is_uhbr_rate (rate)) { -/* -* When UHBR is used there is no reduction in lanes so -* we can use this directly. -*/ - lanes =tb_dp_cap_get_lanes (cap); - }else { -/* -* If there is no UHBR supported then check the -* non-reduced rate and lanes. -*/ - ret =usb4_dp_port_nrd (in, &rate, &lanes); -if (ret) -return ret; - } + lanes =tb_dp_cap_get_lanes (cap); - nrd_bw =tb_dp_bandwidth (rate, lanes); + max_bw =tb_dp_bandwidth (rate, lanes); -if (max_bw) { +if (max_bw_rounded) { ret =usb4_dp_port_granularity (in);if (ret <0 )return ret; - *max_bw =roundup (nrd_bw, ret); + *max_bw_rounded =roundup (max_bw, ret); } -return nrd_bw; +return max_bw; } static int tb_dp_bandwidth_mode_consumed_bandwidth(struct tb_tunnel *tunnel,
@@ -981,7 +973,7 @@ static int tb_dp_bandwidth_mode_consumed_bandwidth(struct tb_tunnel *tunnel, {struct tb_port *out = tunnel->dst_port;struct tb_port *in = tunnel->src_port; -int ret, allocated_bw, max_bw; +int ret, allocated_bw, max_bw_rounded;if (!usb4_dp_port_bandwidth_mode_enabled (in))return -EOPNOTSUPP ;
@@ -995,10 +987,10 @@ static int tb_dp_bandwidth_mode_consumed_bandwidth(struct tb_tunnel *tunnel,return ret; allocated_bw = ret; - ret =tb_dp_bandwidth_mode_maximum_bandwidth (tunnel, &max_bw); + ret =tb_dp_bandwidth_mode_maximum_bandwidth (tunnel, &max_bw_rounded);if (ret <0 )return ret; -if (allocated_bw == max_bw) +if (allocated_bw == max_bw_rounded) allocated_bw = ret;if (tb_port_path_direction_downstream (in, out)) {
@@ -1023,17 +1015,18 @@ static int tb_dp_allocated_bandwidth(struct tb_tunnel *tunnel, int *allocated_up* Otherwise we read it from the DPRX. */ if (usb4_dp_port_bandwidth_mode_enabled (in) && tunnel->bw_mode) { -int ret, allocated_bw, max_bw; +int ret, allocated_bw, max_bw_rounded; ret =usb4_dp_port_allocated_bandwidth (in);if (ret <0 )return ret; allocated_bw = ret; - ret =tb_dp_bandwidth_mode_maximum_bandwidth (tunnel, &max_bw); + ret =tb_dp_bandwidth_mode_maximum_bandwidth (tunnel, + &max_bw_rounded);if (ret <0 )return ret; -if (allocated_bw == max_bw) +if (allocated_bw == max_bw_rounded) allocated_bw = ret;if (tb_port_path_direction_downstream (in, out)) {
@@ -1055,24 +1048,24 @@ static int tb_dp_alloc_bandwidth(struct tb_tunnel *tunnel, int *alloc_up, {struct tb_port *out = tunnel->dst_port;struct tb_port *in = tunnel->src_port; -int max_bw, ret, tmp; +int max_bw_rounded, ret, tmp;if (!usb4_dp_port_bandwidth_mode_enabled (in))return -EOPNOTSUPP ; - ret =tb_dp_bandwidth_mode_maximum_bandwidth (tunnel, &max_bw); + ret =tb_dp_bandwidth_mode_maximum_bandwidth (tunnel, &max_bw_rounded);if (ret <0 )return ret;if (tb_port_path_direction_downstream (in, out)) { - tmp =min (*alloc_down, max_bw); + tmp =min (*alloc_down, max_bw_rounded); ret =usb4_dp_port_allocate_bandwidth (in, tmp);if (ret)return ret; *alloc_down = tmp; *alloc_up =0 ; }else { - tmp =min (*alloc_up, max_bw); + tmp =min (*alloc_up, max_bw_rounded); ret =usb4_dp_port_allocate_bandwidth (in, tmp);if (ret)return ret;
Signature · 1 line
2.43.0
PATCH 2/10 thunderbolt: Re-calculate estimated bandwidth when allocation mode is enabled
In reply to Mika WesterbergWhen we program the initial bandwidth estimation the DPTX (graphics driver) has not yet read the capabilities of the monitor so the values used are the highest possible of the involved DisplayPort IN and OUT adapters, not the actual monitor capabilities. To allow the graphics more accurate bandwidth estimation re-calculate it once we receive the bandwidth allocation mode enabled notification.
--- drivers/thunderbolt/tb.c | 15 ++++++++++++--- 1 file changed, 12 insertions(+), 3 deletions(-)
drivers/thunderbolt/tb.c +12 -3
@@ -2413,10 +2413,19 @@ static void tb_handle_dp_bandwidth_request(struct work_struct *work) ret =usb4_dp_port_requested_bandwidth (in);if (ret <0 ) { -if (ret == -ENODATA ) -tb_port_dbg (in,"no bandwidth request active\n" ); -else +if (ret == -ENODATA ) { +/* +* There is no request active so this means the +* BW allocation mode was enabled from graphics +* side. At this point we know that the graphics +* driver has read the DRPX capabilities so we +* can offer an better bandwidth estimatation. +*/ +tb_port_dbg (in,"DPTX enabled bandwidth allocation mode, updating estimated bandwidth\n" ); +tb_recalc_estimated_bandwidth (tb); + }else {tb_port_warn (in,"failed to read requested bandwidth\n" ); + } goto put_sw; } requested_bw = ret;
Signature · 1 line
2.43.0
PATCH 3/10 thunderbolt: Handle bandwidth allocation mode disable request
In reply to Mika WesterbergGraphics can disable DisplayPort bandwidth allocation mode as well so if this make sure to reset the tunnel state accordingly.
--- drivers/thunderbolt/tb.c | 22 ++++++++++++++++------ 1 file changed, 16 insertions(+), 6 deletions(-)
drivers/thunderbolt/tb.c +16 -6
@@ -2406,8 +2406,23 @@ static void tb_handle_dp_bandwidth_request(struct work_struct *work)tb_port_dbg (in,"handling bandwidth allocation request\n" ); + tunnel =tb_find_tunnel (tb,TB_TUNNEL_DP , in,NULL ); +if (!tunnel) { +tb_port_warn (in,"failed to find tunnel\n" ); + goto put_sw; + } +if (!usb4_dp_port_bandwidth_mode_enabled (in)) { -tb_port_warn (in,"bandwidth allocation mode not enabled\n" ); +if (tunnel->bw_mode) { +/* +* Reset the tunnel back to use the legacy +* allocation. +*/ + tunnel->bw_mode = false; +tb_port_dbg (in,"DPTX disabled bandwidth allocation mode\n" ); + }else { +tb_port_warn (in,"bandwidth allocation mode not enabled\n" ); + } goto put_sw; }
@@ -2432,11 +2447,6 @@ static void tb_handle_dp_bandwidth_request(struct work_struct *work)tb_port_dbg (in,"requested bandwidth %d Mb/s\n" , requested_bw); - tunnel =tb_find_tunnel (tb,TB_TUNNEL_DP , in,NULL ); -if (!tunnel) { -tb_port_warn (in,"failed to find tunnel\n" ); - goto put_sw; - } out = tunnel->dst_port;
Signature · 1 line
2.43.0
PATCH 4/10 thunderbolt: Log an error if DPTX request is not cleared
In reply to Mika WesterbergThis helps debugging issues around DisplayPort bandwidth allocation mode.
--- drivers/thunderbolt/usb4.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)
drivers/thunderbolt/usb4.c +3 -1
@@ -2858,8 +2858,10 @@ static int usb4_dp_port_wait_and_clear_cm_ack(struct tb_port *port,usleep_range (50 ,100 ); }while (ktime_before (ktime_get (), end)); -if (val &ADP_DP_CS_8_DR ) +if (val &ADP_DP_CS_8_DR ) { +tb_port_warn (port,"timeout waiting for DPTX request to clear\n" );return -ETIMEDOUT ; + } ret =tb_port_read (port, &val,TB_CFG_PORT , port->cap_adap +ADP_DP_CS_2 ,1 );
Signature · 1 line
2.43.0
PATCH 5/10 thunderbolt: Fail the failed bandwidth request properly
In reply to Mika WesterbergThe USB4 spec says that if the Connection Manager writes Allocated_BW that is smaller than Requested_BW, the DisplayPort IN adapter signals this failure back to the DPTX (graphics driver). Implement this by rewriting the same allocated bandwidth values back.
--- drivers/thunderbolt/tb.c | 23 ++++++++++++++++++----- 1 file changed, 18 insertions(+), 5 deletions(-)
drivers/thunderbolt/tb.c +18 -5
@@ -2270,11 +2270,11 @@ static int tb_alloc_dp_bandwidth(struct tb_tunnel *tunnel, int *requested_up,*/ ret =tb_tunnel_maximum_bandwidth (tunnel, &max_up, &max_down);if (ret) -return ret; + goto fail; ret =usb4_dp_port_granularity (in);if (ret <0 ) -return ret; + goto fail; granularity = ret; max_up_rounded =roundup (max_up, granularity);
@@ -2304,7 +2304,8 @@ static int tb_alloc_dp_bandwidth(struct tb_tunnel *tunnel, int *requested_up,"bandwidth request too high (%d/%d Mb/s > %d/%d Mb/s)\n" , requested_up_corrected, requested_down_corrected, max_up_rounded, max_down_rounded); -return -ENOBUFS ; + ret = -ENOBUFS ; + goto fail; } if ((*requested_up >= 0 && requested_up_corrected <= allocated_up) ||
@@ -2332,7 +2333,7 @@ static int tb_alloc_dp_bandwidth(struct tb_tunnel *tunnel, int *requested_up,*/ ret =tb_release_unused_usb3_bandwidth (tb, in, out);if (ret) -return ret; + goto fail;/* * Then go over all tunnels that cross the same USB4 ports (they
@@ -2357,7 +2358,7 @@ static int tb_alloc_dp_bandwidth(struct tb_tunnel *tunnel, int *requested_up, *requested_down);if (ret) {tb_configure_sym (tb, in, out,0 ,0 , true); -return ret; + goto fail; } ret = tb_tunnel_alloc_bandwidth(tunnel, requested_up,
@@ -2372,6 +2373,18 @@ static int tb_alloc_dp_bandwidth(struct tb_tunnel *tunnel, int *requested_up, reclaim:tb_reclaim_usb3_bandwidth (tb, in, out); +fail: +if (ret && ret != -ENODEV ) { +/* +* Write back the same allocated (so no change), this +* makes the DPTX request fail on graphics side. +*/ +tb_tunnel_dbg (tunnel, +"failing the request by rewriting allocated %d/%d Mb/s\n" , + allocated_up, allocated_down); +tb_tunnel_alloc_bandwidth (tunnel, &allocated_up, &allocated_down); + } +return ret; }
Signature · 1 line
2.43.0
PATCH 6/10 thunderbolt: Re-order bandwidth group functions
In reply to Mika WesterbergThis is needed by the following patches so that we do not have to add forward declaratations for any of these. Separating the move and the actual changes also makes it easier to review the code.
No functional changes.
--- drivers/thunderbolt/tb.c | 454 +++++++++++++++++++-------------------- 1 file changed, 225 insertions(+), 229 deletions(-)
drivers/thunderbolt/tb.c +225 -229
@@ -75,112 +75,6 @@ struct tb_hotplug_event {bool unplug; }; -static void tb_init_bandwidth_groups (struct tb_cm *tcm) -{ -int i; - -for (i =0 ; i <ARRAY_SIZE (tcm->groups); i++) { -struct tb_bandwidth_group *group = &tcm->groups[i]; - - group->tb =tcm_to_tb (tcm); - group->index = i +1 ; -INIT_LIST_HEAD (&group->ports); - } -} - -static void tb_bandwidth_group_attach_port (struct tb_bandwidth_group *group, -struct tb_port *in) -{ -if (!group ||WARN_ON (in->group)) -return ; - - in->group = group; -list_add_tail (&in->group_list, &group->ports); - -tb_port_dbg (in,"attached to bandwidth group %d\n" , group->index); -} - -static struct tb_bandwidth_group *tb_find_free_bandwidth_group (struct tb_cm *tcm) -{ -int i; - -for (i =0 ; i <ARRAY_SIZE (tcm->groups); i++) { -struct tb_bandwidth_group *group = &tcm->groups[i]; - -if (list_empty (&group->ports)) -return group; - } - -return NULL ; -} - -static struct tb_bandwidth_group * -tb_attach_bandwidth_group (struct tb_cm *tcm,struct tb_port *in, -struct tb_port *out) -{ -struct tb_bandwidth_group *group; -struct tb_tunnel *tunnel; - -/* -* Find all DP tunnels that go through all the same USB4 links -* as this one. Because we always setup tunnels the same way we -* can just check for the routers at both ends of the tunnels -* and if they are the same we have a match. -*/ -list_for_each_entry (tunnel, &tcm->tunnel_list, list) { -if (!tb_tunnel_is_dp (tunnel)) -continue ; - -if (tunnel->src_port->sw == in->sw && - tunnel->dst_port->sw == out->sw) { - group = tunnel->src_port->group; -if (group) { -tb_bandwidth_group_attach_port (group, in); -return group; - } - } - } - -/* Pick up next available group then */ - group =tb_find_free_bandwidth_group (tcm); -if (group) -tb_bandwidth_group_attach_port (group, in); -else -tb_port_warn (in,"no available bandwidth groups\n" ); - -return group; -} - -static void tb_discover_bandwidth_group (struct tb_cm *tcm,struct tb_port *in, -struct tb_port *out) -{ -if (usb4_dp_port_bandwidth_mode_enabled (in)) { -int index, i; - - index =usb4_dp_port_group_id (in); -for (i =0 ; i <ARRAY_SIZE (tcm->groups); i++) { -if (tcm->groups[i].index == index) { -tb_bandwidth_group_attach_port (&tcm->groups[i], in); -return ; - } - } - } - -tb_attach_bandwidth_group (tcm, in, out); -} - -static void tb_detach_bandwidth_group (struct tb_port *in) -{ -struct tb_bandwidth_group *group = in->group; - -if (group) { - in->group =NULL ; -list_del_init (&in->group_list); - -tb_port_dbg (in,"detached from bandwidth group %d\n" , group->index); - } -} -static void tb_handle_hotplug (struct work_struct *work);static void tb_queue_hotplug (struct tb *tb,u64 route,u8 port,bool unplug)
@@ -472,34 +366,6 @@ static void tb_switch_discover_tunnels(struct tb_switch *sw, } } -static void tb_discover_tunnels (struct tb *tb) -{ -struct tb_cm *tcm =tb_priv (tb); -struct tb_tunnel *tunnel; - -tb_switch_discover_tunnels (tb->root_switch, &tcm->tunnel_list, true); - -list_for_each_entry (tunnel, &tcm->tunnel_list, list) { -if (tb_tunnel_is_pci (tunnel)) { -struct tb_switch *parent = tunnel->dst_port->sw; - -while (parent != tunnel->src_port->sw) { - parent->boot = true; - parent =tb_switch_parent (parent); - } - }else if (tb_tunnel_is_dp (tunnel)) { -struct tb_port *in = tunnel->src_port; -struct tb_port *out = tunnel->dst_port; - -/* Keep the domain from powering down */ -pm_runtime_get_sync (&in->sw->dev); -pm_runtime_get_sync (&out->sw->dev); - -tb_discover_bandwidth_group (tcm, in, out); - } - } -} -static int tb_port_configure_xdomain (struct tb_port *port,struct tb_xdomain *xd) {if (tb_switch_is_usb4 (port->sw))
@@ -1464,6 +1330,231 @@ static void tb_scan_port(struct tb_port *port) } } +static void +tb_recalc_estimated_bandwidth_for_group (struct tb_bandwidth_group *group) +{ +struct tb_tunnel *first_tunnel; +struct tb *tb = group->tb; +struct tb_port *in; +int ret; + +tb_dbg (tb,"re-calculating bandwidth estimation for group %u\n" , + group->index); + + first_tunnel =NULL ; +list_for_each_entry (in, &group->ports, group_list) { +int estimated_bw, estimated_up, estimated_down; +struct tb_tunnel *tunnel; +struct tb_port *out; + +if (!usb4_dp_port_bandwidth_mode_enabled (in)) +continue ; + + tunnel =tb_find_tunnel (tb,TB_TUNNEL_DP , in,NULL ); +if (WARN_ON (!tunnel)) +break ; + +if (!first_tunnel) { +/* +* Since USB3 bandwidth is shared by all DP +* tunnels under the host router USB4 port, even +* if they do not begin from the host router, we +* can release USB3 bandwidth just once and not +* for each tunnel separately. +*/ + first_tunnel = tunnel; + ret =tb_release_unused_usb3_bandwidth (tb, + first_tunnel->src_port, first_tunnel->dst_port); +if (ret) { +tb_tunnel_warn (tunnel, +"failed to release unused bandwidth\n" ); +break ; + } + } + + out = tunnel->dst_port; + ret =tb_available_bandwidth (tb, in, out, &estimated_up, + &estimated_down, true); +if (ret) { +tb_tunnel_warn (tunnel, +"failed to re-calculate estimated bandwidth\n" ); +break ; + } + +/* +* Estimated bandwidth includes: +* - already allocated bandwidth for the DP tunnel +* - available bandwidth along the path +* - bandwidth allocated for USB 3.x but not used. +*/ +if (tb_port_path_direction_downstream (in, out)) + estimated_bw = estimated_down; +else + estimated_bw = estimated_up; + +if (usb4_dp_port_set_estimated_bandwidth (in, estimated_bw)) +tb_tunnel_warn (tunnel, +"failed to update estimated bandwidth\n" ); + } + +if (first_tunnel) +tb_reclaim_usb3_bandwidth (tb, first_tunnel->src_port, + first_tunnel->dst_port); + +tb_dbg (tb,"bandwidth estimation for group %u done\n" , group->index); +} + +static void tb_recalc_estimated_bandwidth (struct tb *tb) +{ +struct tb_cm *tcm =tb_priv (tb); +int i; + +tb_dbg (tb,"bandwidth consumption changed, re-calculating estimated bandwidth\n" ); + +for (i =0 ; i <ARRAY_SIZE (tcm->groups); i++) { +struct tb_bandwidth_group *group = &tcm->groups[i]; + +if (!list_empty (&group->ports)) +tb_recalc_estimated_bandwidth_for_group (group); + } + +tb_dbg (tb,"bandwidth re-calculation done\n" ); +} + +static void tb_init_bandwidth_groups (struct tb_cm *tcm) +{ +int i; + +for (i =0 ; i <ARRAY_SIZE (tcm->groups); i++) { +struct tb_bandwidth_group *group = &tcm->groups[i]; + + group->tb =tcm_to_tb (tcm); + group->index = i +1 ; +INIT_LIST_HEAD (&group->ports); + } +} + +static void tb_bandwidth_group_attach_port (struct tb_bandwidth_group *group, +struct tb_port *in) +{ +if (!group ||WARN_ON (in->group)) +return ; + + in->group = group; +list_add_tail (&in->group_list, &group->ports); + +tb_port_dbg (in,"attached to bandwidth group %d\n" , group->index); +} + +static struct tb_bandwidth_group *tb_find_free_bandwidth_group (struct tb_cm *tcm) +{ +int i; + +for (i =0 ; i <ARRAY_SIZE (tcm->groups); i++) { +struct tb_bandwidth_group *group = &tcm->groups[i]; + +if (list_empty (&group->ports)) +return group; + } + +return NULL ; +} + +static struct tb_bandwidth_group * +tb_attach_bandwidth_group (struct tb_cm *tcm,struct tb_port *in, +struct tb_port *out) +{ +struct tb_bandwidth_group *group; +struct tb_tunnel *tunnel; + +/* +* Find all DP tunnels that go through all the same USB4 links +* as this one. Because we always setup tunnels the same way we +* can just check for the routers at both ends of the tunnels +* and if they are the same we have a match. +*/ +list_for_each_entry (tunnel, &tcm->tunnel_list, list) { +if (!tb_tunnel_is_dp (tunnel)) +continue ; + +if (tunnel->src_port->sw == in->sw && + tunnel->dst_port->sw == out->sw) { + group = tunnel->src_port->group; +if (group) { +tb_bandwidth_group_attach_port (group, in); +return group; + } + } + } + +/* Pick up next available group then */ + group =tb_find_free_bandwidth_group (tcm); +if (group) +tb_bandwidth_group_attach_port (group, in); +else +tb_port_warn (in,"no available bandwidth groups\n" ); + +return group; +} + +static void tb_discover_bandwidth_group (struct tb_cm *tcm,struct tb_port *in, +struct tb_port *out) +{ +if (usb4_dp_port_bandwidth_mode_enabled (in)) { +int index, i; + + index =usb4_dp_port_group_id (in); +for (i =0 ; i <ARRAY_SIZE (tcm->groups); i++) { +if (tcm->groups[i].index == index) { +tb_bandwidth_group_attach_port (&tcm->groups[i], in); +return ; + } + } + } + +tb_attach_bandwidth_group (tcm, in, out); +} + +static void tb_detach_bandwidth_group (struct tb_port *in) +{ +struct tb_bandwidth_group *group = in->group; + +if (group) { + in->group =NULL ; +list_del_init (&in->group_list); + +tb_port_dbg (in,"detached from bandwidth group %d\n" , group->index); + } +} + +static void tb_discover_tunnels (struct tb *tb) +{ +struct tb_cm *tcm =tb_priv (tb); +struct tb_tunnel *tunnel; + +tb_switch_discover_tunnels (tb->root_switch, &tcm->tunnel_list, true); + +list_for_each_entry (tunnel, &tcm->tunnel_list, list) { +if (tb_tunnel_is_pci (tunnel)) { +struct tb_switch *parent = tunnel->dst_port->sw; + +while (parent != tunnel->src_port->sw) { + parent->boot = true; + parent =tb_switch_parent (parent); + } + }else if (tb_tunnel_is_dp (tunnel)) { +struct tb_port *in = tunnel->src_port; +struct tb_port *out = tunnel->dst_port; + +/* Keep the domain from powering down */ +pm_runtime_get_sync (&in->sw->dev); +pm_runtime_get_sync (&out->sw->dev); + +tb_discover_bandwidth_group (tcm, in, out); + } + } +} +static void tb_deactivate_and_free_tunnel (struct tb_tunnel *tunnel) {struct tb_port *src_port, *dst_port;
@@ -1605,101 +1696,6 @@ static struct tb_port *tb_find_pcie_down(struct tb_switch *sw,return tb_find_unused_port (sw,TB_TYPE_PCIE_DOWN ); } -static void -tb_recalc_estimated_bandwidth_for_group (struct tb_bandwidth_group *group) -{ -struct tb_tunnel *first_tunnel; -struct tb *tb = group->tb; -struct tb_port *in; -int ret; - -tb_dbg (tb,"re-calculating bandwidth estimation for group %u\n" , - group->index); - - first_tunnel =NULL ; -list_for_each_entry (in, &group->ports, group_list) { -int estimated_bw, estimated_up, estimated_down; -struct tb_tunnel *tunnel; -struct tb_port *out; - -if (!usb4_dp_port_bandwidth_mode_enabled (in)) -continue ; - - tunnel =tb_find_tunnel (tb,TB_TUNNEL_DP , in,NULL ); -if (WARN_ON (!tunnel)) -break ; - -if (!first_tunnel) { -/* -* Since USB3 bandwidth is shared by all DP -* tunnels under the host router USB4 port, even -* if they do not begin from the host router, we -* can release USB3 bandwidth just once and not -* for each tunnel separately. -*/ - first_tunnel = tunnel; - ret =tb_release_unused_usb3_bandwidth (tb, - first_tunnel->src_port, first_tunnel->dst_port); -if (ret) { -tb_tunnel_warn (tunnel, -"failed to release unused bandwidth\n" ); -break ; - } - } - - out = tunnel->dst_port; - ret =tb_available_bandwidth (tb, in, out, &estimated_up, - &estimated_down, true); -if (ret) { -tb_tunnel_warn (tunnel, -"failed to re-calculate estimated bandwidth\n" ); -break ; - } - -/* -* Estimated bandwidth includes: -* - already allocated bandwidth for the DP tunnel -* - available bandwidth along the path -* - bandwidth allocated for USB 3.x but not used. -*/ -tb_tunnel_dbg (tunnel, -"re-calculated estimated bandwidth %u/%u Mb/s\n" , - estimated_up, estimated_down); - -if (tb_port_path_direction_downstream (in, out)) - estimated_bw = estimated_down; -else - estimated_bw = estimated_up; - -if (usb4_dp_port_set_estimated_bandwidth (in, estimated_bw)) -tb_tunnel_warn (tunnel, -"failed to update estimated bandwidth\n" ); - } - -if (first_tunnel) -tb_reclaim_usb3_bandwidth (tb, first_tunnel->src_port, - first_tunnel->dst_port); - -tb_dbg (tb,"bandwidth estimation for group %u done\n" , group->index); -} - -static void tb_recalc_estimated_bandwidth (struct tb *tb) -{ -struct tb_cm *tcm =tb_priv (tb); -int i; - -tb_dbg (tb,"bandwidth consumption changed, re-calculating estimated bandwidth\n" ); - -for (i =0 ; i <ARRAY_SIZE (tcm->groups); i++) { -struct tb_bandwidth_group *group = &tcm->groups[i]; - -if (!list_empty (&group->ports)) -tb_recalc_estimated_bandwidth_for_group (group); - } - -tb_dbg (tb,"bandwidth re-calculation done\n" ); -} -static struct tb_port *tb_find_dp_out (struct tb *tb,struct tb_port *in) {struct tb_port *host_port, *port;
Signature · 1 line
2.43.0
PATCH 7/10 thunderbolt: Introduce tb_tunnel_direction_downstream()
In reply to Mika WesterbergThis helper takes tunnel as parameter. Convert existing code to call this where possible.
No functional changes.
--- drivers/thunderbolt/tb.c | 9 +++------ drivers/thunderbolt/tunnel.c | 23 +++++++++-------------- drivers/thunderbolt/tunnel.h | 6 ++++++ 3 files changed, 18 insertions(+), 20 deletions(-)
drivers/thunderbolt/tb.c +3 -6
@@ -1387,7 +1387,7 @@ tb_recalc_estimated_bandwidth_for_group(struct tb_bandwidth_group *group)* - available bandwidth along the path * - bandwidth allocated for USB 3.x but not used. */ -if (tb_port_path_direction_downstream (in, out)) +if (tb_tunnel_direction_downstream (tunnel)) estimated_bw = estimated_down;else estimated_bw = estimated_up;
@@ -2388,11 +2388,11 @@ static void tb_handle_dp_bandwidth_request(struct work_struct *work) {struct tb_hotplug_event *ev =container_of (work,typeof (*ev), work);int requested_bw, requested_up, requested_down, ret; -struct tb_port *in, *out;struct tb_tunnel *tunnel;struct tb *tb = ev->tb;struct tb_cm *tcm =tb_priv (tb);struct tb_switch *sw; +struct tb_port *in;pm_runtime_get_sync (&tb->dev);
@@ -2456,10 +2456,7 @@ static void tb_handle_dp_bandwidth_request(struct work_struct *work)tb_port_dbg (in,"requested bandwidth %d Mb/s\n" , requested_bw); - - out = tunnel->dst_port; - -if (tb_port_path_direction_downstream (in, out)) { +if (tb_tunnel_direction_downstream (tunnel)) { requested_up =-1 ; requested_down = requested_bw; }else {
drivers/thunderbolt/tunnel.c +9 -14
@@ -706,7 +706,7 @@ static int tb_dp_xchg_caps(struct tb_tunnel *tunnel)"DP OUT maximum supported bandwidth %u Mb/s x%u = %u Mb/s\n" , out_rate, out_lanes, bw); -if (tb_port_path_direction_downstream (in, out)) +if (tb_tunnel_direction_downstream (tunnel)) max_bw = tunnel->max_down;else max_bw = tunnel->max_up;
@@ -831,7 +831,7 @@ static int tb_dp_bandwidth_alloc_mode_enable(struct tb_tunnel *tunnel)* max_up/down fields. For discovery we just read what the * estimation was set to. */ -if (tb_port_path_direction_downstream (in, out)) +if (tb_tunnel_direction_downstream (tunnel)) estimated_bw = tunnel->max_down;else estimated_bw = tunnel->max_up;
@@ -971,7 +971,6 @@ static int tb_dp_bandwidth_mode_consumed_bandwidth(struct tb_tunnel *tunnel,int *consumed_up, int *consumed_down) { - struct tb_port *out = tunnel->dst_port; struct tb_port *in = tunnel->src_port;int ret, allocated_bw, max_bw_rounded;
@@ -993,7 +992,7 @@ static int tb_dp_bandwidth_mode_consumed_bandwidth(struct tb_tunnel *tunnel,if (allocated_bw == max_bw_rounded) allocated_bw = ret; -if (tb_port_path_direction_downstream (in, out)) { +if (tb_tunnel_direction_downstream (tunnel)) { *consumed_up =0 ; *consumed_down = allocated_bw; }else {
@@ -1007,7 +1006,6 @@ static int tb_dp_bandwidth_mode_consumed_bandwidth(struct tb_tunnel *tunnel,static int tb_dp_allocated_bandwidth (struct tb_tunnel *tunnel,int *allocated_up,int *allocated_down) { -struct tb_port *out = tunnel->dst_port;struct tb_port *in = tunnel->src_port;/*
@@ -1029,7 +1027,7 @@ static int tb_dp_allocated_bandwidth(struct tb_tunnel *tunnel, int *allocated_upif (allocated_bw == max_bw_rounded) allocated_bw = ret; -if (tb_port_path_direction_downstream (in, out)) { +if (tb_tunnel_direction_downstream (tunnel)) { *allocated_up =0 ; *allocated_down = allocated_bw; }else {
@@ -1046,7 +1044,6 @@ static int tb_dp_allocated_bandwidth(struct tb_tunnel *tunnel, int *allocated_upstatic int tb_dp_alloc_bandwidth (struct tb_tunnel *tunnel,int *alloc_up,int *alloc_down) { -struct tb_port *out = tunnel->dst_port;struct tb_port *in = tunnel->src_port;int max_bw_rounded, ret, tmp;
@@ -1057,7 +1054,7 @@ static int tb_dp_alloc_bandwidth(struct tb_tunnel *tunnel, int *alloc_up,if (ret <0 )return ret; -if (tb_port_path_direction_downstream (in, out)) { +if (tb_tunnel_direction_downstream (tunnel)) { tmp =min (*alloc_down, max_bw_rounded); ret =usb4_dp_port_allocate_bandwidth (in, tmp);if (ret)
@@ -1143,17 +1140,16 @@ static int tb_dp_read_cap(struct tb_tunnel *tunnel, unsigned int cap, u32 *rate,static int tb_dp_maximum_bandwidth (struct tb_tunnel *tunnel,int *max_up,int *max_down) { -struct tb_port *in = tunnel->src_port;int ret; -if (!usb4_dp_port_bandwidth_mode_enabled (in)) +if (!usb4_dp_port_bandwidth_mode_enabled (tunnel->src_port))return -EOPNOTSUPP ; ret =tb_dp_bandwidth_mode_maximum_bandwidth (tunnel,NULL );if (ret <0 )return ret; -if (tb_port_path_direction_downstream (in, tunnel->dst_port)) { +if (tb_tunnel_direction_downstream (tunnel)) { *max_up =0 ; *max_down = ret; }else {
@@ -1167,8 +1163,7 @@ static int tb_dp_maximum_bandwidth(struct tb_tunnel *tunnel, int *max_up,static int tb_dp_consumed_bandwidth (struct tb_tunnel *tunnel,int *consumed_up,int *consumed_down) { -struct tb_port *in = tunnel->src_port; -const struct tb_switch *sw = in->sw; +const struct tb_switch *sw = tunnel->src_port->sw;u32 rate =0 , lanes =0 ;int ret;
@@ -1214,7 +1209,7 @@ static int tb_dp_consumed_bandwidth(struct tb_tunnel *tunnel, int *consumed_up,return 0 ; } -if (tb_port_path_direction_downstream (in, tunnel->dst_port)) { +if (tb_tunnel_direction_downstream (tunnel)) { *consumed_up =0 ; *consumed_down =tb_dp_bandwidth (rate, lanes); }else {
drivers/thunderbolt/tunnel.h +6 -0
@@ -139,6 +139,12 @@ static inline bool tb_tunnel_is_usb3(const struct tb_tunnel *tunnel)return tunnel->type ==TB_TUNNEL_USB3 ; } +static inline bool tb_tunnel_direction_downstream (const struct tb_tunnel *tunnel) +{ +return tb_port_path_direction_downstream (tunnel->src_port, + tunnel->dst_port); +} +const char *tb_tunnel_type_name (const struct tb_tunnel *tunnel); #define __TB_TUNNEL_PRINT(level, tunnel, fmt, arg...) \
Signature · 1 line
2.43.0
PATCH 8/10 thunderbolt: Reserve released DisplayPort bandwidth for a group for 10 seconds
In reply to Mika WesterbergThe USB4 spec says that the Connection Manager should reserve the bandwidth that is released in the same group for 10 seconds before it can be shared with other groups. Add support for this. We also delay the symmetric transition by that same 10 seconds to avoid any unnecessary transitions (i.e if the released bandwidth is used by another DisplayPort tunnel in the same group the link can stay asymmetric the whole time).
--- drivers/thunderbolt/domain.c | 4 + drivers/thunderbolt/tb.c | 199 ++++++++++++++++++++++++++++++----- drivers/thunderbolt/tb.h | 10 ++ 3 files changed, 184 insertions(+), 29 deletions(-)
drivers/thunderbolt/domain.c +4 -0
@@ -506,6 +506,10 @@ void tb_domain_remove(struct tb *tb)mutex_unlock (&tb->lock);flush_workqueue (tb->wq); + +if (tb->cm_ops->deinit) + tb->cm_ops->deinit (tb); +device_unregister (&tb->dev); }
drivers/thunderbolt/tb.c +170 -29
340 lines not on this page · raw message
drivers/thunderbolt/tb.h +10 -0
@@ -217,6 +217,11 @@ struct tb_switch {* @tb: Pointer to the domain the group belongs to * @index: Index of the group (aka Group_ID). Valid values %1-%7 * @ports: DP IN adapters belonging to this group are linked here +* @reserved: Bandwidth released by one tunnel in the group, available +* to others. This is reported as part of estimated_bw for +* the group. +* @release_work: Worker to release the @reserved if it is not used by +* any of the tunnels. * * Any tunnel that requires isochronous bandwidth (that's DP for now) is * attached to a bandwidth group. All tunnels going through the same
@@ -227,6 +232,8 @@ struct tb_bandwidth_group {struct tb *tb;int index;struct list_head ports; +int reserved; +struct delayed_work release_work; };/**
@@ -452,6 +459,8 @@ struct tb_path {* ICM to send driver ready message to the firmware. * @start: Starts the domain * @stop: Stops the domain +* @deinit: Perform any cleanup after the domain is stopped but before +* it is unregistered. Called without @tb->lock taken. Optional. * @suspend_noirq: Connection manager specific suspend_noirq * @resume_noirq: Connection manager specific resume_noirq * @suspend: Connection manager specific suspend
@@ -485,6 +494,7 @@ struct tb_cm_ops {int (*driver_ready)(struct tb *tb);int (*start)(struct tb *tb,bool reset);void (*stop)(struct tb *tb); +void (*deinit)(struct tb *tb);int (*suspend_noirq)(struct tb *tb);int (*resume_noirq)(struct tb *tb);int (*suspend)(struct tb *tb);
Signature · 1 line
2.43.0
PATCH 9/10 thunderbolt: Calculate DisplayPort tunnel bandwidth after DPRX capabilities read
In reply to Mika WesterbergFrom: Gil Fine <[email protected]>
According to USB4 Connection Manager guide, after DisplayPort tunnel was setup, the DPRX capabilities read is performed by the DPTX. According to VESA spec, this shall be completed within 5 seconds after the DisplayPort tunnel was setup. Hence, if the bit: DPRX Capabilities Read Done, was not set to '1' by this time, we timeout and fail calculating DisplayPort tunnel consumed bandwidth.
--- drivers/thunderbolt/tunnel.c | 16 ++++++---------- 1 file changed, 6 insertions(+), 10 deletions(-)
drivers/thunderbolt/tunnel.c +6 -10
@@ -1184,17 +1184,13 @@ static int tb_dp_consumed_bandwidth(struct tb_tunnel *tunnel, int *consumed_up,/* * Then see if the DPRX negotiation is ready and if yes * return that bandwidth (it may be smaller than the -* reduced one). Otherwise return the remote (possibly -* reduced) caps. +* reduced one). According to VESA spec, the DPRX +* negotiation shall compete in 5 seconds after tunnel +* established. We give it 100ms extra just in case. */ - ret =tb_dp_wait_dprx (tunnel,150 ); -if (ret) { -if (ret == -ETIMEDOUT ) - ret =tb_dp_read_cap (tunnel,DP_REMOTE_CAP , - &rate, &lanes); -if (ret) -return ret; - } + ret =tb_dp_wait_dprx (tunnel,5100 ); +if (ret) +return ret; ret =tb_dp_read_cap (tunnel,DP_COMMON_CAP , &rate, &lanes);if (ret)return ret;
Signature · 1 line
2.43.0
PATCH 10/10 thunderbolt: Improve DisplayPort tunnel setup process to be more robust
In reply to Mika WesterbergFrom: Gil Fine <[email protected]>
After DisplayPort tunnel setup, we add verification that the DPRX capabilities read process completed. Otherwise, we bail out, teardown the tunnel, and try setup another DisplayPort tunnel using next available DP IN adapter. We do so till all DP IN adapters tried. This way, we avoid allocating DP IN adapter and (bandwidth for it) for unusable tunnel.
--- drivers/thunderbolt/tb.c | 84 ++++++++++++++++++++-------------------- 1 file changed, 43 insertions(+), 41 deletions(-)
drivers/thunderbolt/tb.c +43 -41
@@ -1821,48 +1821,14 @@ static struct tb_port *tb_find_dp_out(struct tb *tb, struct tb_port *in)return NULL ; } -static bool tb_tunnel_one_dp (struct tb *tb) +static bool tb_tunnel_one_dp (struct tb *tb,struct tb_port *in, +struct tb_port *out) {int available_up, available_down, ret, link_nr;struct tb_cm *tcm =tb_priv (tb); -struct tb_port *port, *in, *out;int consumed_up, consumed_down;struct tb_tunnel *tunnel; -/* -* Find pair of inactive DP IN and DP OUT adapters and then -* establish a DP tunnel between them. -*/ -tb_dbg (tb,"looking for DP IN <-> DP OUT pairs:\n" ); - - 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,"DP IN in use\n" ); -continue ; - } - - in = port; -tb_port_dbg (in,"DP IN available\n" ); - - out =tb_find_dp_out (tb, port); -if (out) -break ; - } - -if (!in) { -tb_dbg (tb,"no suitable DP IN adapter available, not tunneling\n" ); -return false; - } -if (!out) { -tb_dbg (tb,"no suitable DP OUT adapter available, not tunneling\n" ); -return false; - } -/* * This is only applicable to links that are not bonded (so * when Thunderbolt 1 hardware is involved somewhere in the
@@ -1923,15 +1889,19 @@ static bool tb_tunnel_one_dp(struct tb *tb) goto err_free; } +/* If fail reading tunnel's consumed bandwidth, tear it down */ + ret =tb_tunnel_consumed_bandwidth (tunnel, &consumed_up, &consumed_down); +if (ret) + goto err_deactivate; +list_add_tail (&tunnel->list, &tcm->tunnel_list); -tb_reclaim_usb3_bandwidth (tb, in, out); +tb_reclaim_usb3_bandwidth (tb, in, out);/* * Transition the links to asymmetric if the consumption exceeds * the threshold. */ -if (!tb_tunnel_consumed_bandwidth (tunnel, &consumed_up, &consumed_down)) -tb_configure_asym (tb, in, out, consumed_up, consumed_down); +tb_configure_asym (tb, in, out, consumed_up, consumed_down);/* Update the domain with the new bandwidth estimation */ tb_recalc_estimated_bandwidth (tb);
@@ -1943,6 +1913,8 @@ static bool tb_tunnel_one_dp(struct tb *tb)tb_increase_tmu_accuracy (tunnel);return true; +err_deactivate: +tb_tunnel_deactivate (tunnel); err_free:tb_tunnel_free (tunnel); err_reclaim_usb:
@@ -1962,13 +1934,43 @@ static bool tb_tunnel_one_dp(struct tb *tb)static void tb_tunnel_dp (struct tb *tb) { +struct tb_cm *tcm =tb_priv (tb); +struct tb_port *port, *in, *out; +if (!tb_acpi_may_tunnel_dp ()) {tb_dbg (tb,"DP tunneling disabled, not creating tunnel\n" );return ; } -while (tb_tunnel_one_dp (tb)) - ; +/* +* Find pair of inactive DP IN and DP OUT adapters and then +* establish a DP tunnel between them. +*/ +tb_dbg (tb,"looking for DP IN <-> DP OUT pairs:\n" ); + + 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,"DP IN in use\n" ); +continue ; + } + + in = port; +tb_port_dbg (in,"DP IN available\n" ); + + out =tb_find_dp_out (tb, port); +if (out) +tb_tunnel_one_dp (tb, in, out); +else +tb_port_dbg (in,"no suitable DP OUT adapter available, not tunneling\n" ); + } + +if (!in) +tb_dbg (tb,"no suitable DP IN adapter available, not tunneling\n" ); }static void tb_dp_resource_unavailable (struct tb *tb,struct tb_port *port)
Signature · 1 line
2.43.0
Quoted 16 lines · Mika Westerberg
Hi all,
This series improves bandwidth allocation mode support to follow the USB4 spec more closely. In addition to that DisplayPort tunneling is made more robust so that if a tunnel does not come up properly (for example on a discrete controller the DisplayPort source from the graphics is not connected to the DisplayPort sink of the controller) we tear it down and continue pairing.
This series improves bandwidth allocation mode support and DisplayPort tunneling to follow the USB4 spec more closely.
Gil Fine (2):
thunderbolt: Calculate DisplayPort tunnel bandwidth after DPRX capabilities read
thunderbolt: Improve DisplayPort tunnel setup process to be more robust
Quoted 9 lines
Mika Westerberg (8):
thunderbolt: UseDP_LOCAL_CAPfor maximum bandwidth calculation
thunderbolt: Re-calculate estimated bandwidth when allocation mode is enabled
thunderbolt: Handle bandwidth allocation mode disable request
thunderbolt: Log an error if DPTX request is not cleared
thunderbolt: Fail the failed bandwidth request properly
thunderbolt: Re-order bandwidth group functions
thunderbolt: Introducetb_tunnel_direction_downstream()
thunderbolt: Reserve released DisplayPort bandwidth for a group for 10 seconds
All applied to thunderbolt.git/next.