License cleanup: add SPDX GPL-2.0 license identifier to files with no license
Many source files in the tree are missing licensing information, which
makes it harder for compliance tools to determine the correct license.
By default all files without license information are under the default
license of the kernel, which is GPL version 2.
Update the files which contain no license information with the 'GPL-2.0'
SPDX license identifier. The SPDX identifier is a legally binding
shorthand, which can be used instead of the full boiler plate text.
This patch is based on work done by Thomas Gleixner and Kate Stewart and
Philippe Ombredanne.
How this work was done:
Patches were generated and checked against linux-4.14-rc6 for a subset of
the use cases:
- file had no licensing information it it.
- file was a */uapi/* one with no licensing information in it,
- file was a */uapi/* one with existing licensing information,
Further patches will be generated in subsequent months to fix up cases
where non-standard license headers were used, and references to license
had to be inferred by heuristics based on keywords.
The analysis to determine which SPDX License Identifier to be applied to
a file was done in a spreadsheet of side by side results from of the
output of two independent scanners (ScanCode & Windriver) producing SPDX
tag:value files created by Philippe Ombredanne. Philippe prepared the
base worksheet, and did an initial spot review of a few 1000 files.
The 4.13 kernel was the starting point of the analysis with 60,537 files
assessed. Kate Stewart did a file by file comparison of the scanner
results in the spreadsheet to determine which SPDX license identifier(s)
to be applied to the file. She confirmed any determination that was not
immediately clear with lawyers working with the Linux Foundation.
Criteria used to select files for SPDX license identifier tagging was:
- Files considered eligible had to be source code files.
- Make and config files were included as candidates if they contained >5
lines of source
- File already had some variant of a license header in it (even if <5
lines).
All documentation files were explicitly excluded.
The following heuristics were used to determine which SPDX license
identifiers to apply.
- when both scanners couldn't find any license traces, file was
considered to have no license information in it, and the top level
COPYING file license applied.
For non */uapi/* files that summary was:
SPDX license identifier # files
---------------------------------------------------|-------
GPL-2.0 11139
and resulted in the first patch in this series.
If that file was a */uapi/* path one, it was "GPL-2.0 WITH
Linux-syscall-note" otherwise it was "GPL-2.0". Results of that was:
SPDX license identifier # files
---------------------------------------------------|-------
GPL-2.0 WITH Linux-syscall-note 930
and resulted in the second patch in this series.
- if a file had some form of licensing information in it, and was one
of the */uapi/* ones, it was denoted with the Linux-syscall-note if
any GPL family license was found in the file or had no licensing in
it (per prior point). Results summary:
SPDX license identifier # files
---------------------------------------------------|------
GPL-2.0 WITH Linux-syscall-note 270
GPL-2.0+ WITH Linux-syscall-note 169
((GPL-2.0 WITH Linux-syscall-note) OR BSD-2-Clause) 21
((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) 17
LGPL-2.1+ WITH Linux-syscall-note 15
GPL-1.0+ WITH Linux-syscall-note 14
((GPL-2.0+ WITH Linux-syscall-note) OR BSD-3-Clause) 5
LGPL-2.0+ WITH Linux-syscall-note 4
LGPL-2.1 WITH Linux-syscall-note 3
((GPL-2.0 WITH Linux-syscall-note) OR MIT) 3
((GPL-2.0 WITH Linux-syscall-note) AND MIT) 1
and that resulted in the third patch in this series.
- when the two scanners agreed on the detected license(s), that became
the concluded license(s).
- when there was disagreement between the two scanners (one detected a
license but the other didn't, or they both detected different
licenses) a manual inspection of the file occurred.
- In most cases a manual inspection of the information in the file
resulted in a clear resolution of the license that should apply (and
which scanner probably needed to revisit its heuristics).
- When it was not immediately clear, the license identifier was
confirmed with lawyers working with the Linux Foundation.
- If there was any question as to the appropriate license identifier,
the file was flagged for further research and to be revisited later
in time.
In total, over 70 hours of logged manual review was done on the
spreadsheet to determine the SPDX license identifiers to apply to the
source files by Kate, Philippe, Thomas and, in some cases, confirmation
by lawyers working with the Linux Foundation.
Kate also obtained a third independent scan of the 4.13 code base from
FOSSology, and compared selected files where the other two scanners
disagreed against that SPDX file, to see if there was new insights. The
Windriver scanner is based on an older version of FOSSology in part, so
they are related.
Thomas did random spot checks in about 500 files from the spreadsheets
for the uapi headers and agreed with SPDX license identifier in the
files he inspected. For the non-uapi files Thomas did random spot checks
in about 15000 files.
In initial set of patches against 4.14-rc6, 3 files were found to have
copy/paste license identifier errors, and have been fixed to reflect the
correct identifier.
Additionally Philippe spent 10 hours this week doing a detailed manual
inspection and review of the 12,461 patched files from the initial patch
version early this week with:
- a full scancode scan run, collecting the matched texts, detected
license ids and scores
- reviewing anything where there was a license detected (about 500+
files) to ensure that the applied SPDX license was correct
- reviewing anything where there was no detection but the patch license
was not GPL-2.0 WITH Linux-syscall-note to ensure that the applied
SPDX license was correct
This produced a worksheet with 20 files needing minor correction. This
worksheet was then exported into 3 different .csv files for the
different types of files to be modified.
These .csv files were then reviewed by Greg. Thomas wrote a script to
parse the csv files and add the proper SPDX tag to the file, in the
format that the file expected. This script was further refined by Greg
based on the output to detect more types of files automatically and to
distinguish between header and source .c files (which need different
comment types.) Finally Greg ran the script using the .csv files to
generate the patches.
Reviewed-by: Kate Stewart <kstewart@linuxfoundation.org>
Reviewed-by: Philippe Ombredanne <pombredanne@nexb.com>
Reviewed-by: Thomas Gleixner <tglx@linutronix.de>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2017-11-01 14:07:57 +00:00
|
|
|
// SPDX-License-Identifier: GPL-2.0
|
2014-06-03 20:04:00 +00:00
|
|
|
/*
|
2018-12-30 19:34:08 +00:00
|
|
|
* Thunderbolt driver - bus logic (NHI independent)
|
2014-06-03 20:04:00 +00:00
|
|
|
*
|
|
|
|
* Copyright (c) 2014 Andreas Noever <andreas.noever@gmail.com>
|
2018-12-30 19:34:08 +00:00
|
|
|
* Copyright (C) 2019, Intel Corporation
|
2014-06-03 20:04:00 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/errno.h>
|
|
|
|
#include <linux/delay.h>
|
|
|
|
|
|
|
|
#include "tb.h"
|
2014-06-03 20:04:01 +00:00
|
|
|
#include "tb_regs.h"
|
2017-02-19 08:58:35 +00:00
|
|
|
#include "tunnel.h"
|
2014-06-03 20:04:00 +00:00
|
|
|
|
2017-06-06 12:25:00 +00:00
|
|
|
/**
|
|
|
|
* struct tb_cm - Simple Thunderbolt connection manager
|
|
|
|
* @tunnel_list: List of active tunnels
|
2019-03-26 12:52:30 +00:00
|
|
|
* @dp_resources: List of available DP resources for DP tunneling
|
2017-06-06 12:25:00 +00:00
|
|
|
* @hotplug_active: tb_handle_hotplug will stop progressing plug
|
|
|
|
* events and exit if this is not set (it needs to
|
|
|
|
* acquire the lock one more time). Used to drain wq
|
|
|
|
* after cfg has been paused.
|
|
|
|
*/
|
|
|
|
struct tb_cm {
|
|
|
|
struct list_head tunnel_list;
|
2019-03-26 12:52:30 +00:00
|
|
|
struct list_head dp_resources;
|
2017-06-06 12:25:00 +00:00
|
|
|
bool hotplug_active;
|
|
|
|
};
|
2014-06-03 20:04:05 +00:00
|
|
|
|
2018-09-17 13:30:49 +00:00
|
|
|
struct tb_hotplug_event {
|
|
|
|
struct work_struct work;
|
|
|
|
struct tb *tb;
|
|
|
|
u64 route;
|
|
|
|
u8 port;
|
|
|
|
bool unplug;
|
|
|
|
};
|
|
|
|
|
|
|
|
static void tb_handle_hotplug(struct work_struct *work);
|
|
|
|
|
|
|
|
static void tb_queue_hotplug(struct tb *tb, u64 route, u8 port, bool unplug)
|
|
|
|
{
|
|
|
|
struct tb_hotplug_event *ev;
|
|
|
|
|
|
|
|
ev = kmalloc(sizeof(*ev), GFP_KERNEL);
|
|
|
|
if (!ev)
|
|
|
|
return;
|
|
|
|
|
|
|
|
ev->tb = tb;
|
|
|
|
ev->route = route;
|
|
|
|
ev->port = port;
|
|
|
|
ev->unplug = unplug;
|
|
|
|
INIT_WORK(&ev->work, tb_handle_hotplug);
|
|
|
|
queue_work(tb->wq, &ev->work);
|
|
|
|
}
|
|
|
|
|
2014-06-03 20:04:05 +00:00
|
|
|
/* enumeration & hot plug handling */
|
|
|
|
|
2019-03-26 12:52:30 +00:00
|
|
|
static void tb_add_dp_resources(struct tb_switch *sw)
|
|
|
|
{
|
|
|
|
struct tb_cm *tcm = tb_priv(sw->tb);
|
|
|
|
struct tb_port *port;
|
|
|
|
|
|
|
|
tb_switch_for_each_port(sw, port) {
|
|
|
|
if (!tb_port_is_dpin(port))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (!tb_switch_query_dp_resource(sw, port))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
list_add_tail(&port->list, &tcm->dp_resources);
|
|
|
|
tb_port_dbg(port, "DP IN resource available\n");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void tb_remove_dp_resources(struct tb_switch *sw)
|
|
|
|
{
|
|
|
|
struct tb_cm *tcm = tb_priv(sw->tb);
|
|
|
|
struct tb_port *port, *tmp;
|
|
|
|
|
|
|
|
/* Clear children resources first */
|
|
|
|
tb_switch_for_each_port(sw, port) {
|
|
|
|
if (tb_port_has_remote(port))
|
|
|
|
tb_remove_dp_resources(port->remote->sw);
|
|
|
|
}
|
|
|
|
|
|
|
|
list_for_each_entry_safe(port, tmp, &tcm->dp_resources, list) {
|
|
|
|
if (port->sw == sw) {
|
|
|
|
tb_port_dbg(port, "DP OUT resource unavailable\n");
|
|
|
|
list_del_init(&port->list);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-19 21:43:26 +00:00
|
|
|
static void tb_discover_tunnels(struct tb_switch *sw)
|
|
|
|
{
|
|
|
|
struct tb *tb = sw->tb;
|
|
|
|
struct tb_cm *tcm = tb_priv(tb);
|
|
|
|
struct tb_port *port;
|
|
|
|
|
2019-09-30 11:07:22 +00:00
|
|
|
tb_switch_for_each_port(sw, port) {
|
2017-02-19 21:43:26 +00:00
|
|
|
struct tb_tunnel *tunnel = NULL;
|
|
|
|
|
|
|
|
switch (port->config.type) {
|
2018-09-17 13:30:49 +00:00
|
|
|
case TB_TYPE_DP_HDMI_IN:
|
|
|
|
tunnel = tb_tunnel_discover_dp(tb, port);
|
|
|
|
break;
|
|
|
|
|
2017-02-19 21:43:26 +00:00
|
|
|
case TB_TYPE_PCIE_DOWN:
|
|
|
|
tunnel = tb_tunnel_discover_pci(tb, port);
|
|
|
|
break;
|
|
|
|
|
2019-12-17 12:33:44 +00:00
|
|
|
case TB_TYPE_USB3_DOWN:
|
|
|
|
tunnel = tb_tunnel_discover_usb3(tb, port);
|
|
|
|
break;
|
|
|
|
|
2017-02-19 21:43:26 +00:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2018-09-17 13:30:49 +00:00
|
|
|
if (!tunnel)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (tb_tunnel_is_pci(tunnel)) {
|
2017-02-19 21:43:26 +00:00
|
|
|
struct tb_switch *parent = tunnel->dst_port->sw;
|
|
|
|
|
|
|
|
while (parent != tunnel->src_port->sw) {
|
|
|
|
parent->boot = true;
|
|
|
|
parent = tb_switch_parent(parent);
|
|
|
|
}
|
|
|
|
}
|
2018-09-17 13:30:49 +00:00
|
|
|
|
|
|
|
list_add_tail(&tunnel->list, &tcm->tunnel_list);
|
2017-02-19 21:43:26 +00:00
|
|
|
}
|
|
|
|
|
2019-09-30 11:07:22 +00:00
|
|
|
tb_switch_for_each_port(sw, port) {
|
|
|
|
if (tb_port_has_remote(port))
|
|
|
|
tb_discover_tunnels(port->remote->sw);
|
2017-02-19 21:43:26 +00:00
|
|
|
}
|
|
|
|
}
|
2014-06-03 20:04:05 +00:00
|
|
|
|
2018-09-28 13:41:01 +00:00
|
|
|
static void tb_scan_xdomain(struct tb_port *port)
|
|
|
|
{
|
|
|
|
struct tb_switch *sw = port->sw;
|
|
|
|
struct tb *tb = sw->tb;
|
|
|
|
struct tb_xdomain *xd;
|
|
|
|
u64 route;
|
|
|
|
|
|
|
|
route = tb_downstream_route(port);
|
|
|
|
xd = tb_xdomain_find_by_route(tb, route);
|
|
|
|
if (xd) {
|
|
|
|
tb_xdomain_put(xd);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
xd = tb_xdomain_alloc(tb, &sw->dev, route, tb->root_switch->uuid,
|
|
|
|
NULL);
|
|
|
|
if (xd) {
|
|
|
|
tb_port_at(route, sw)->xdomain = xd;
|
|
|
|
tb_xdomain_add(xd);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-12-17 12:33:43 +00:00
|
|
|
static int tb_enable_tmu(struct tb_switch *sw)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
/* If it is already enabled in correct mode, don't touch it */
|
|
|
|
if (tb_switch_tmu_is_enabled(sw))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
ret = tb_switch_tmu_disable(sw);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
ret = tb_switch_tmu_post_time(sw);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
return tb_switch_tmu_enable(sw);
|
|
|
|
}
|
|
|
|
|
2019-12-17 12:33:44 +00:00
|
|
|
/**
|
|
|
|
* tb_find_unused_port() - return the first inactive port on @sw
|
|
|
|
* @sw: Switch to find the port on
|
|
|
|
* @type: Port type to look for
|
|
|
|
*/
|
|
|
|
static struct tb_port *tb_find_unused_port(struct tb_switch *sw,
|
|
|
|
enum tb_port_type type)
|
|
|
|
{
|
|
|
|
struct tb_port *port;
|
|
|
|
|
|
|
|
tb_switch_for_each_port(sw, port) {
|
|
|
|
if (tb_is_upstream_port(port))
|
|
|
|
continue;
|
|
|
|
if (port->config.type != type)
|
|
|
|
continue;
|
|
|
|
if (!port->cap_adap)
|
|
|
|
continue;
|
|
|
|
if (tb_port_is_enabled(port))
|
|
|
|
continue;
|
|
|
|
return port;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct tb_port *tb_find_usb3_down(struct tb_switch *sw,
|
2020-03-11 13:00:46 +00:00
|
|
|
const struct tb_port *port)
|
2019-12-17 12:33:44 +00:00
|
|
|
{
|
|
|
|
struct tb_port *down;
|
|
|
|
|
|
|
|
down = usb4_switch_map_usb3_down(sw, port);
|
2020-03-11 13:00:46 +00:00
|
|
|
if (down && !tb_usb3_port_is_enabled(down))
|
2019-12-17 12:33:44 +00:00
|
|
|
return down;
|
2020-03-11 13:00:46 +00:00
|
|
|
return NULL;
|
2019-12-17 12:33:44 +00:00
|
|
|
}
|
|
|
|
|
2020-03-24 12:44:13 +00:00
|
|
|
static struct tb_tunnel *tb_find_tunnel(struct tb *tb, enum tb_tunnel_type type,
|
|
|
|
struct tb_port *src_port,
|
|
|
|
struct tb_port *dst_port)
|
|
|
|
{
|
|
|
|
struct tb_cm *tcm = tb_priv(tb);
|
|
|
|
struct tb_tunnel *tunnel;
|
|
|
|
|
|
|
|
list_for_each_entry(tunnel, &tcm->tunnel_list, list) {
|
|
|
|
if (tunnel->type == type &&
|
|
|
|
((src_port && src_port == tunnel->src_port) ||
|
|
|
|
(dst_port && dst_port == tunnel->dst_port))) {
|
|
|
|
return tunnel;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct tb_tunnel *tb_find_first_usb3_tunnel(struct tb *tb,
|
|
|
|
struct tb_port *src_port,
|
|
|
|
struct tb_port *dst_port)
|
|
|
|
{
|
|
|
|
struct tb_port *port, *usb3_down;
|
|
|
|
struct tb_switch *sw;
|
|
|
|
|
|
|
|
/* Pick the router that is deepest in the topology */
|
|
|
|
if (dst_port->sw->config.depth > src_port->sw->config.depth)
|
|
|
|
sw = dst_port->sw;
|
|
|
|
else
|
|
|
|
sw = src_port->sw;
|
|
|
|
|
|
|
|
/* Can't be the host router */
|
|
|
|
if (sw == tb->root_switch)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
/* Find the downstream USB4 port that leads to this router */
|
|
|
|
port = tb_port_at(tb_route(sw), tb->root_switch);
|
|
|
|
/* Find the corresponding host router USB3 downstream port */
|
|
|
|
usb3_down = usb4_switch_map_usb3_down(tb->root_switch, port);
|
|
|
|
if (!usb3_down)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
return tb_find_tunnel(tb, TB_TUNNEL_USB3, usb3_down, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int tb_available_bandwidth(struct tb *tb, struct tb_port *src_port,
|
|
|
|
struct tb_port *dst_port, int *available_up, int *available_down)
|
|
|
|
{
|
|
|
|
int usb3_consumed_up, usb3_consumed_down, ret;
|
|
|
|
struct tb_cm *tcm = tb_priv(tb);
|
|
|
|
struct tb_tunnel *tunnel;
|
|
|
|
struct tb_port *port;
|
|
|
|
|
|
|
|
tb_port_dbg(dst_port, "calculating available bandwidth\n");
|
|
|
|
|
|
|
|
tunnel = tb_find_first_usb3_tunnel(tb, src_port, dst_port);
|
|
|
|
if (tunnel) {
|
|
|
|
ret = tb_tunnel_consumed_bandwidth(tunnel, &usb3_consumed_up,
|
|
|
|
&usb3_consumed_down);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
} else {
|
|
|
|
usb3_consumed_up = 0;
|
|
|
|
usb3_consumed_down = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
*available_up = *available_down = 40000;
|
|
|
|
|
|
|
|
/* Find the minimum available bandwidth over all links */
|
|
|
|
tb_for_each_port_on_path(src_port, dst_port, port) {
|
|
|
|
int link_speed, link_width, up_bw, down_bw;
|
|
|
|
|
|
|
|
if (!tb_port_is_null(port))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (tb_is_upstream_port(port)) {
|
|
|
|
link_speed = port->sw->link_speed;
|
|
|
|
} else {
|
|
|
|
link_speed = tb_port_get_link_speed(port);
|
|
|
|
if (link_speed < 0)
|
|
|
|
return link_speed;
|
|
|
|
}
|
|
|
|
|
|
|
|
link_width = port->bonded ? 2 : 1;
|
|
|
|
|
|
|
|
up_bw = link_speed * link_width * 1000; /* Mb/s */
|
|
|
|
/* Leave 10% guard band */
|
|
|
|
up_bw -= up_bw / 10;
|
|
|
|
down_bw = up_bw;
|
|
|
|
|
|
|
|
tb_port_dbg(port, "link total bandwidth %d Mb/s\n", up_bw);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Find all DP tunnels that cross the port and reduce
|
|
|
|
* their consumed bandwidth from the available.
|
|
|
|
*/
|
|
|
|
list_for_each_entry(tunnel, &tcm->tunnel_list, list) {
|
|
|
|
int dp_consumed_up, dp_consumed_down;
|
|
|
|
|
|
|
|
if (!tb_tunnel_is_dp(tunnel))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (!tb_tunnel_port_on_path(tunnel, port))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
ret = tb_tunnel_consumed_bandwidth(tunnel,
|
|
|
|
&dp_consumed_up,
|
|
|
|
&dp_consumed_down);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
up_bw -= dp_consumed_up;
|
|
|
|
down_bw -= dp_consumed_down;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If USB3 is tunneled from the host router down to the
|
|
|
|
* branch leading to port we need to take USB3 consumed
|
|
|
|
* bandwidth into account regardless whether it actually
|
|
|
|
* crosses the port.
|
|
|
|
*/
|
|
|
|
up_bw -= usb3_consumed_up;
|
|
|
|
down_bw -= usb3_consumed_down;
|
|
|
|
|
|
|
|
if (up_bw < *available_up)
|
|
|
|
*available_up = up_bw;
|
|
|
|
if (down_bw < *available_down)
|
|
|
|
*available_down = down_bw;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (*available_up < 0)
|
|
|
|
*available_up = 0;
|
|
|
|
if (*available_down < 0)
|
|
|
|
*available_down = 0;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int tb_release_unused_usb3_bandwidth(struct tb *tb,
|
|
|
|
struct tb_port *src_port,
|
|
|
|
struct tb_port *dst_port)
|
|
|
|
{
|
|
|
|
struct tb_tunnel *tunnel;
|
|
|
|
|
|
|
|
tunnel = tb_find_first_usb3_tunnel(tb, src_port, dst_port);
|
|
|
|
return tunnel ? tb_tunnel_release_unused_bandwidth(tunnel) : 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void tb_reclaim_usb3_bandwidth(struct tb *tb, struct tb_port *src_port,
|
|
|
|
struct tb_port *dst_port)
|
|
|
|
{
|
|
|
|
int ret, available_up, available_down;
|
|
|
|
struct tb_tunnel *tunnel;
|
|
|
|
|
|
|
|
tunnel = tb_find_first_usb3_tunnel(tb, src_port, dst_port);
|
|
|
|
if (!tunnel)
|
|
|
|
return;
|
|
|
|
|
|
|
|
tb_dbg(tb, "reclaiming unused bandwidth for USB3\n");
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Calculate available bandwidth for the first hop USB3 tunnel.
|
|
|
|
* That determines the whole USB3 bandwidth for this branch.
|
|
|
|
*/
|
|
|
|
ret = tb_available_bandwidth(tb, tunnel->src_port, tunnel->dst_port,
|
|
|
|
&available_up, &available_down);
|
|
|
|
if (ret) {
|
|
|
|
tb_warn(tb, "failed to calculate available bandwidth\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
tb_dbg(tb, "available bandwidth for USB3 %d/%d Mb/s\n",
|
|
|
|
available_up, available_down);
|
|
|
|
|
|
|
|
tb_tunnel_reclaim_available_bandwidth(tunnel, &available_up, &available_down);
|
|
|
|
}
|
|
|
|
|
2019-12-17 12:33:44 +00:00
|
|
|
static int tb_tunnel_usb3(struct tb *tb, struct tb_switch *sw)
|
|
|
|
{
|
|
|
|
struct tb_switch *parent = tb_switch_parent(sw);
|
2020-03-24 12:44:13 +00:00
|
|
|
int ret, available_up, available_down;
|
2019-12-17 12:33:44 +00:00
|
|
|
struct tb_port *up, *down, *port;
|
|
|
|
struct tb_cm *tcm = tb_priv(tb);
|
|
|
|
struct tb_tunnel *tunnel;
|
|
|
|
|
|
|
|
up = tb_switch_find_port(sw, TB_TYPE_USB3_UP);
|
|
|
|
if (!up)
|
|
|
|
return 0;
|
|
|
|
|
2020-03-04 15:09:14 +00:00
|
|
|
if (!sw->link_usb4)
|
|
|
|
return 0;
|
|
|
|
|
2019-12-17 12:33:44 +00:00
|
|
|
/*
|
|
|
|
* Look up available down port. Since we are chaining it should
|
|
|
|
* be found right above this switch.
|
|
|
|
*/
|
|
|
|
port = tb_port_at(tb_route(sw), parent);
|
|
|
|
down = tb_find_usb3_down(parent, port);
|
|
|
|
if (!down)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (tb_route(parent)) {
|
|
|
|
struct tb_port *parent_up;
|
|
|
|
/*
|
|
|
|
* Check first that the parent switch has its upstream USB3
|
|
|
|
* port enabled. Otherwise the chain is not complete and
|
|
|
|
* there is no point setting up a new tunnel.
|
|
|
|
*/
|
|
|
|
parent_up = tb_switch_find_port(parent, TB_TYPE_USB3_UP);
|
|
|
|
if (!parent_up || !tb_port_is_enabled(parent_up))
|
|
|
|
return 0;
|
2020-03-24 12:44:13 +00:00
|
|
|
|
|
|
|
/* Make all unused bandwidth available for the new tunnel */
|
|
|
|
ret = tb_release_unused_usb3_bandwidth(tb, down, up);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2019-12-17 12:33:44 +00:00
|
|
|
}
|
|
|
|
|
2020-03-24 12:44:13 +00:00
|
|
|
ret = tb_available_bandwidth(tb, down, up, &available_up,
|
|
|
|
&available_down);
|
|
|
|
if (ret)
|
|
|
|
goto err_reclaim;
|
|
|
|
|
|
|
|
tb_port_dbg(up, "available bandwidth for new USB3 tunnel %d/%d Mb/s\n",
|
|
|
|
available_up, available_down);
|
|
|
|
|
|
|
|
tunnel = tb_tunnel_alloc_usb3(tb, up, down, available_up,
|
|
|
|
available_down);
|
|
|
|
if (!tunnel) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto err_reclaim;
|
|
|
|
}
|
2019-12-17 12:33:44 +00:00
|
|
|
|
|
|
|
if (tb_tunnel_activate(tunnel)) {
|
|
|
|
tb_port_info(up,
|
|
|
|
"USB3 tunnel activation failed, aborting\n");
|
2020-03-24 12:44:13 +00:00
|
|
|
ret = -EIO;
|
|
|
|
goto err_free;
|
2019-12-17 12:33:44 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
list_add_tail(&tunnel->list, &tcm->tunnel_list);
|
2020-03-24 12:44:13 +00:00
|
|
|
if (tb_route(parent))
|
|
|
|
tb_reclaim_usb3_bandwidth(tb, down, up);
|
|
|
|
|
2019-12-17 12:33:44 +00:00
|
|
|
return 0;
|
2020-03-24 12:44:13 +00:00
|
|
|
|
|
|
|
err_free:
|
|
|
|
tb_tunnel_free(tunnel);
|
|
|
|
err_reclaim:
|
|
|
|
if (tb_route(parent))
|
|
|
|
tb_reclaim_usb3_bandwidth(tb, down, up);
|
|
|
|
|
|
|
|
return ret;
|
2019-12-17 12:33:44 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int tb_create_usb3_tunnels(struct tb_switch *sw)
|
|
|
|
{
|
|
|
|
struct tb_port *port;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (tb_route(sw)) {
|
|
|
|
ret = tb_tunnel_usb3(sw->tb, sw);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
tb_switch_for_each_port(sw, port) {
|
|
|
|
if (!tb_port_has_remote(port))
|
|
|
|
continue;
|
|
|
|
ret = tb_create_usb3_tunnels(port->remote->sw);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-06-03 20:04:05 +00:00
|
|
|
static void tb_scan_port(struct tb_port *port);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* tb_scan_switch() - scan for and initialize downstream switches
|
|
|
|
*/
|
|
|
|
static void tb_scan_switch(struct tb_switch *sw)
|
|
|
|
{
|
2019-09-30 11:07:22 +00:00
|
|
|
struct tb_port *port;
|
|
|
|
|
|
|
|
tb_switch_for_each_port(sw, port)
|
|
|
|
tb_scan_port(port);
|
2014-06-03 20:04:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* tb_scan_port() - check for and initialize switches below port
|
|
|
|
*/
|
|
|
|
static void tb_scan_port(struct tb_port *port)
|
|
|
|
{
|
2018-12-30 19:34:08 +00:00
|
|
|
struct tb_cm *tcm = tb_priv(port->sw->tb);
|
2019-03-07 13:26:45 +00:00
|
|
|
struct tb_port *upstream_port;
|
2014-06-03 20:04:05 +00:00
|
|
|
struct tb_switch *sw;
|
2019-03-07 13:26:45 +00:00
|
|
|
|
2014-06-03 20:04:05 +00:00
|
|
|
if (tb_is_upstream_port(port))
|
|
|
|
return;
|
2018-09-17 13:30:49 +00:00
|
|
|
|
|
|
|
if (tb_port_is_dpout(port) && tb_dp_port_hpd_is_active(port) == 1 &&
|
|
|
|
!tb_dp_port_is_enabled(port)) {
|
|
|
|
tb_port_dbg(port, "DP adapter HPD set, queuing hotplug\n");
|
|
|
|
tb_queue_hotplug(port->sw->tb, tb_route(port->sw), port->port,
|
|
|
|
false);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2014-06-03 20:04:05 +00:00
|
|
|
if (port->config.type != TB_TYPE_PORT)
|
|
|
|
return;
|
2014-06-12 21:11:47 +00:00
|
|
|
if (port->dual_link_port && port->link_nr)
|
|
|
|
return; /*
|
|
|
|
* Downstream switch is reachable through two ports.
|
|
|
|
* Only scan on the primary port (link_nr == 0).
|
|
|
|
*/
|
2014-06-03 20:04:05 +00:00
|
|
|
if (tb_wait_for_port(port, false) <= 0)
|
|
|
|
return;
|
|
|
|
if (port->remote) {
|
2018-09-28 13:41:01 +00:00
|
|
|
tb_port_dbg(port, "port already has a remote\n");
|
2014-06-03 20:04:05 +00:00
|
|
|
return;
|
|
|
|
}
|
2020-03-05 14:39:58 +00:00
|
|
|
|
|
|
|
tb_retimer_scan(port);
|
|
|
|
|
2017-06-06 12:25:01 +00:00
|
|
|
sw = tb_switch_alloc(port->sw->tb, &port->sw->dev,
|
|
|
|
tb_downstream_route(port));
|
2018-09-28 13:41:01 +00:00
|
|
|
if (IS_ERR(sw)) {
|
|
|
|
/*
|
|
|
|
* If there is an error accessing the connected switch
|
|
|
|
* it may be connected to another domain. Also we allow
|
|
|
|
* the other domain to be connected to a max depth switch.
|
|
|
|
*/
|
|
|
|
if (PTR_ERR(sw) == -EIO || PTR_ERR(sw) == -EADDRNOTAVAIL)
|
|
|
|
tb_scan_xdomain(port);
|
2014-06-03 20:04:05 +00:00
|
|
|
return;
|
2018-09-28 13:41:01 +00:00
|
|
|
}
|
2017-06-06 12:25:01 +00:00
|
|
|
|
|
|
|
if (tb_switch_configure(sw)) {
|
|
|
|
tb_switch_put(sw);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2018-09-28 13:41:01 +00:00
|
|
|
/*
|
|
|
|
* If there was previously another domain connected remove it
|
|
|
|
* first.
|
|
|
|
*/
|
|
|
|
if (port->xdomain) {
|
|
|
|
tb_xdomain_remove(port->xdomain);
|
|
|
|
port->xdomain = NULL;
|
|
|
|
}
|
|
|
|
|
2018-12-30 19:34:08 +00:00
|
|
|
/*
|
|
|
|
* Do not send uevents until we have discovered all existing
|
|
|
|
* tunnels and know which switches were authorized already by
|
|
|
|
* the boot firmware.
|
|
|
|
*/
|
|
|
|
if (!tcm->hotplug_active)
|
|
|
|
dev_set_uevent_suppress(&sw->dev, true);
|
2017-06-06 12:25:16 +00:00
|
|
|
|
2017-06-06 12:25:01 +00:00
|
|
|
if (tb_switch_add(sw)) {
|
|
|
|
tb_switch_put(sw);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2019-03-07 13:26:45 +00:00
|
|
|
/* Link the switches using both links if available */
|
|
|
|
upstream_port = tb_upstream_port(sw);
|
|
|
|
port->remote = upstream_port;
|
|
|
|
upstream_port->remote = port;
|
|
|
|
if (port->dual_link_port && upstream_port->dual_link_port) {
|
|
|
|
port->dual_link_port->remote = upstream_port->dual_link_port;
|
|
|
|
upstream_port->dual_link_port->remote = port->dual_link_port;
|
|
|
|
}
|
|
|
|
|
2019-03-21 17:03:00 +00:00
|
|
|
/* Enable lane bonding if supported */
|
2020-04-02 11:28:18 +00:00
|
|
|
tb_switch_lane_bonding_enable(sw);
|
2019-03-21 17:03:00 +00:00
|
|
|
|
2019-12-17 12:33:43 +00:00
|
|
|
if (tb_enable_tmu(sw))
|
|
|
|
tb_sw_warn(sw, "failed to enable TMU\n");
|
|
|
|
|
2020-03-05 14:39:58 +00:00
|
|
|
/* Scan upstream retimers */
|
|
|
|
tb_retimer_scan(upstream_port);
|
|
|
|
|
2019-12-17 12:33:44 +00:00
|
|
|
/*
|
|
|
|
* Create USB 3.x tunnels only when the switch is plugged to the
|
|
|
|
* domain. This is because we scan the domain also during discovery
|
|
|
|
* and want to discover existing USB 3.x tunnels before we create
|
|
|
|
* any new.
|
|
|
|
*/
|
|
|
|
if (tcm->hotplug_active && tb_tunnel_usb3(sw->tb, sw))
|
|
|
|
tb_sw_warn(sw, "USB3 tunnel creation failed\n");
|
|
|
|
|
2020-04-02 09:53:14 +00:00
|
|
|
tb_add_dp_resources(sw);
|
2014-06-03 20:04:05 +00:00
|
|
|
tb_scan_switch(sw);
|
|
|
|
}
|
|
|
|
|
2019-03-26 12:52:30 +00:00
|
|
|
static void tb_deactivate_and_free_tunnel(struct tb_tunnel *tunnel)
|
|
|
|
{
|
2020-03-24 12:44:13 +00:00
|
|
|
struct tb_port *src_port, *dst_port;
|
|
|
|
struct tb *tb;
|
|
|
|
|
2019-03-26 12:52:30 +00:00
|
|
|
if (!tunnel)
|
|
|
|
return;
|
|
|
|
|
|
|
|
tb_tunnel_deactivate(tunnel);
|
|
|
|
list_del(&tunnel->list);
|
|
|
|
|
2020-03-24 12:44:13 +00:00
|
|
|
tb = tunnel->tb;
|
|
|
|
src_port = tunnel->src_port;
|
|
|
|
dst_port = tunnel->dst_port;
|
|
|
|
|
|
|
|
switch (tunnel->type) {
|
|
|
|
case TB_TUNNEL_DP:
|
|
|
|
/*
|
|
|
|
* In case of DP tunnel make sure the DP IN resource is
|
|
|
|
* deallocated properly.
|
|
|
|
*/
|
|
|
|
tb_switch_dealloc_dp_resource(src_port->sw, src_port);
|
|
|
|
fallthrough;
|
|
|
|
|
|
|
|
case TB_TUNNEL_USB3:
|
|
|
|
tb_reclaim_usb3_bandwidth(tb, src_port, dst_port);
|
|
|
|
break;
|
2019-03-26 12:52:30 +00:00
|
|
|
|
2020-03-24 12:44:13 +00:00
|
|
|
default:
|
|
|
|
/*
|
|
|
|
* PCIe and DMA tunnels do not consume guaranteed
|
|
|
|
* bandwidth.
|
|
|
|
*/
|
|
|
|
break;
|
2019-03-26 12:52:30 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
tb_tunnel_free(tunnel);
|
2018-09-17 13:30:49 +00:00
|
|
|
}
|
|
|
|
|
2014-06-03 20:04:08 +00:00
|
|
|
/**
|
|
|
|
* tb_free_invalid_tunnels() - destroy tunnels of devices that have gone away
|
|
|
|
*/
|
|
|
|
static void tb_free_invalid_tunnels(struct tb *tb)
|
|
|
|
{
|
2017-06-06 12:25:00 +00:00
|
|
|
struct tb_cm *tcm = tb_priv(tb);
|
2017-02-19 11:48:29 +00:00
|
|
|
struct tb_tunnel *tunnel;
|
|
|
|
struct tb_tunnel *n;
|
2017-06-06 12:25:00 +00:00
|
|
|
|
|
|
|
list_for_each_entry_safe(tunnel, n, &tcm->tunnel_list, list) {
|
2019-03-26 12:52:30 +00:00
|
|
|
if (tb_tunnel_is_invalid(tunnel))
|
|
|
|
tb_deactivate_and_free_tunnel(tunnel);
|
2014-06-03 20:04:08 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-06-03 20:04:12 +00:00
|
|
|
/**
|
|
|
|
* tb_free_unplugged_children() - traverse hierarchy and free unplugged switches
|
|
|
|
*/
|
|
|
|
static void tb_free_unplugged_children(struct tb_switch *sw)
|
|
|
|
{
|
2019-09-30 11:07:22 +00:00
|
|
|
struct tb_port *port;
|
2019-03-07 13:26:45 +00:00
|
|
|
|
2019-09-30 11:07:22 +00:00
|
|
|
tb_switch_for_each_port(sw, port) {
|
2019-03-07 13:26:45 +00:00
|
|
|
if (!tb_port_has_remote(port))
|
2014-06-03 20:04:12 +00:00
|
|
|
continue;
|
2019-03-07 13:26:45 +00:00
|
|
|
|
2014-06-03 20:04:12 +00:00
|
|
|
if (port->remote->sw->is_unplugged) {
|
2020-03-05 14:39:58 +00:00
|
|
|
tb_retimer_remove_all(port);
|
2019-03-26 12:52:30 +00:00
|
|
|
tb_remove_dp_resources(port->remote->sw);
|
2019-03-21 17:03:00 +00:00
|
|
|
tb_switch_lane_bonding_disable(port->remote->sw);
|
2017-06-06 12:25:01 +00:00
|
|
|
tb_switch_remove(port->remote->sw);
|
2014-06-03 20:04:12 +00:00
|
|
|
port->remote = NULL;
|
2019-03-07 13:26:45 +00:00
|
|
|
if (port->dual_link_port)
|
|
|
|
port->dual_link_port->remote = NULL;
|
2014-06-03 20:04:12 +00:00
|
|
|
} else {
|
|
|
|
tb_free_unplugged_children(port->remote->sw);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-12-30 19:34:08 +00:00
|
|
|
static struct tb_port *tb_find_pcie_down(struct tb_switch *sw,
|
|
|
|
const struct tb_port *port)
|
2014-06-03 20:04:08 +00:00
|
|
|
{
|
2019-12-17 12:33:40 +00:00
|
|
|
struct tb_port *down = NULL;
|
|
|
|
|
2018-12-30 19:34:08 +00:00
|
|
|
/*
|
|
|
|
* To keep plugging devices consistently in the same PCIe
|
2019-12-17 12:33:40 +00:00
|
|
|
* hierarchy, do mapping here for switch downstream PCIe ports.
|
2018-12-30 19:34:08 +00:00
|
|
|
*/
|
2019-12-17 12:33:40 +00:00
|
|
|
if (tb_switch_is_usb4(sw)) {
|
|
|
|
down = usb4_switch_map_pcie_down(sw, port);
|
|
|
|
} else if (!tb_route(sw)) {
|
2018-12-30 19:34:08 +00:00
|
|
|
int phy_port = tb_phy_port_from_link(port->port);
|
|
|
|
int index;
|
2017-06-06 12:25:00 +00:00
|
|
|
|
2018-12-30 19:34:08 +00:00
|
|
|
/*
|
|
|
|
* Hard-coded Thunderbolt port to PCIe down port mapping
|
|
|
|
* per controller.
|
|
|
|
*/
|
2019-03-22 13:16:53 +00:00
|
|
|
if (tb_switch_is_cactus_ridge(sw) ||
|
|
|
|
tb_switch_is_alpine_ridge(sw))
|
2018-12-30 19:34:08 +00:00
|
|
|
index = !phy_port ? 6 : 7;
|
2019-10-08 13:42:47 +00:00
|
|
|
else if (tb_switch_is_falcon_ridge(sw))
|
2018-12-30 19:34:08 +00:00
|
|
|
index = !phy_port ? 6 : 8;
|
2019-03-22 13:16:53 +00:00
|
|
|
else if (tb_switch_is_titan_ridge(sw))
|
|
|
|
index = !phy_port ? 8 : 9;
|
2018-12-30 19:34:08 +00:00
|
|
|
else
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
/* Validate the hard-coding */
|
|
|
|
if (WARN_ON(index > sw->config.max_port_number))
|
|
|
|
goto out;
|
2019-12-17 12:33:40 +00:00
|
|
|
|
|
|
|
down = &sw->ports[index];
|
|
|
|
}
|
|
|
|
|
|
|
|
if (down) {
|
|
|
|
if (WARN_ON(!tb_port_is_pcie_down(down)))
|
2018-12-30 19:34:08 +00:00
|
|
|
goto out;
|
2020-03-11 13:12:50 +00:00
|
|
|
if (tb_pci_port_is_enabled(down))
|
2018-12-30 19:34:08 +00:00
|
|
|
goto out;
|
|
|
|
|
2019-12-17 12:33:40 +00:00
|
|
|
return down;
|
2018-12-30 19:34:08 +00:00
|
|
|
}
|
2014-06-03 20:04:08 +00:00
|
|
|
|
2018-12-30 19:34:08 +00:00
|
|
|
out:
|
2017-10-12 13:45:50 +00:00
|
|
|
return tb_find_unused_port(sw, TB_TYPE_PCIE_DOWN);
|
2018-12-30 19:34:08 +00:00
|
|
|
}
|
2014-06-03 20:04:08 +00:00
|
|
|
|
2020-04-02 09:53:14 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2019-03-26 12:52:30 +00:00
|
|
|
static void tb_tunnel_dp(struct tb *tb)
|
2018-09-17 13:30:49 +00:00
|
|
|
{
|
2020-03-24 12:44:13 +00:00
|
|
|
int available_up, available_down, ret;
|
2018-09-17 13:30:49 +00:00
|
|
|
struct tb_cm *tcm = tb_priv(tb);
|
2019-03-26 12:52:30 +00:00
|
|
|
struct tb_port *port, *in, *out;
|
2018-09-17 13:30:49 +00:00
|
|
|
struct tb_tunnel *tunnel;
|
|
|
|
|
2019-03-26 12:52:30 +00:00
|
|
|
/*
|
|
|
|
* 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) {
|
2020-04-02 09:53:14 +00:00
|
|
|
if (!tb_port_is_dpin(port))
|
|
|
|
continue;
|
|
|
|
|
2019-03-26 12:52:30 +00:00
|
|
|
if (tb_port_is_enabled(port)) {
|
|
|
|
tb_port_dbg(port, "in use\n");
|
|
|
|
continue;
|
|
|
|
}
|
2018-09-17 13:30:49 +00:00
|
|
|
|
2020-04-02 09:53:14 +00:00
|
|
|
tb_port_dbg(port, "DP IN available\n");
|
2019-03-26 12:52:30 +00:00
|
|
|
|
2020-04-02 09:53:14 +00:00
|
|
|
out = tb_find_dp_out(tb, port);
|
|
|
|
if (out) {
|
2019-03-26 12:52:30 +00:00
|
|
|
in = port;
|
2020-04-02 09:53:14 +00:00
|
|
|
break;
|
|
|
|
}
|
2019-03-26 12:52:30 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!in) {
|
|
|
|
tb_dbg(tb, "no suitable DP IN adapter available, not tunneling\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (!out) {
|
|
|
|
tb_dbg(tb, "no suitable DP OUT adapter available, not tunneling\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (tb_switch_alloc_dp_resource(in->sw, in)) {
|
|
|
|
tb_port_dbg(in, "no resource available for DP IN, not tunneling\n");
|
|
|
|
return;
|
|
|
|
}
|
2018-09-17 13:30:49 +00:00
|
|
|
|
2020-03-24 12:44:13 +00:00
|
|
|
/* Make all unused USB3 bandwidth available for the new DP tunnel */
|
|
|
|
ret = tb_release_unused_usb3_bandwidth(tb, in, out);
|
|
|
|
if (ret) {
|
|
|
|
tb_warn(tb, "failed to release unused bandwidth\n");
|
|
|
|
goto err_dealloc_dp;
|
2019-03-26 13:03:48 +00:00
|
|
|
}
|
|
|
|
|
2020-03-24 12:44:13 +00:00
|
|
|
ret = tb_available_bandwidth(tb, in, out, &available_up,
|
|
|
|
&available_down);
|
|
|
|
if (ret)
|
|
|
|
goto err_reclaim;
|
|
|
|
|
|
|
|
tb_dbg(tb, "available bandwidth for new DP tunnel %u/%u Mb/s\n",
|
|
|
|
available_up, available_down);
|
2019-03-26 13:03:48 +00:00
|
|
|
|
2020-03-24 12:44:13 +00:00
|
|
|
tunnel = tb_tunnel_alloc_dp(tb, in, out, available_up, available_down);
|
2018-09-17 13:30:49 +00:00
|
|
|
if (!tunnel) {
|
2019-03-26 12:52:30 +00:00
|
|
|
tb_port_dbg(out, "could not allocate DP tunnel\n");
|
2020-03-24 12:44:13 +00:00
|
|
|
goto err_reclaim;
|
2018-09-17 13:30:49 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (tb_tunnel_activate(tunnel)) {
|
|
|
|
tb_port_info(out, "DP tunnel activation failed, aborting\n");
|
2020-03-24 12:44:13 +00:00
|
|
|
goto err_free;
|
2018-09-17 13:30:49 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
list_add_tail(&tunnel->list, &tcm->tunnel_list);
|
2020-03-24 12:44:13 +00:00
|
|
|
tb_reclaim_usb3_bandwidth(tb, in, out);
|
2019-03-26 12:52:30 +00:00
|
|
|
return;
|
|
|
|
|
2020-03-24 12:44:13 +00:00
|
|
|
err_free:
|
|
|
|
tb_tunnel_free(tunnel);
|
|
|
|
err_reclaim:
|
|
|
|
tb_reclaim_usb3_bandwidth(tb, in, out);
|
|
|
|
err_dealloc_dp:
|
2019-03-26 12:52:30 +00:00
|
|
|
tb_switch_dealloc_dp_resource(in->sw, in);
|
2018-09-17 13:30:49 +00:00
|
|
|
}
|
|
|
|
|
2019-03-26 12:52:30 +00:00
|
|
|
static void tb_dp_resource_unavailable(struct tb *tb, struct tb_port *port)
|
2018-09-17 13:30:49 +00:00
|
|
|
{
|
2019-03-26 12:52:30 +00:00
|
|
|
struct tb_port *in, *out;
|
|
|
|
struct tb_tunnel *tunnel;
|
|
|
|
|
|
|
|
if (tb_port_is_dpin(port)) {
|
|
|
|
tb_port_dbg(port, "DP IN resource unavailable\n");
|
|
|
|
in = port;
|
|
|
|
out = NULL;
|
|
|
|
} else {
|
|
|
|
tb_port_dbg(port, "DP OUT resource unavailable\n");
|
|
|
|
in = NULL;
|
|
|
|
out = port;
|
|
|
|
}
|
|
|
|
|
|
|
|
tunnel = tb_find_tunnel(tb, TB_TUNNEL_DP, in, out);
|
|
|
|
tb_deactivate_and_free_tunnel(tunnel);
|
|
|
|
list_del_init(&port->list);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* See if there is another DP OUT port that can be used for
|
|
|
|
* to create another tunnel.
|
|
|
|
*/
|
|
|
|
tb_tunnel_dp(tb);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void tb_dp_resource_available(struct tb *tb, struct tb_port *port)
|
|
|
|
{
|
|
|
|
struct tb_cm *tcm = tb_priv(tb);
|
|
|
|
struct tb_port *p;
|
|
|
|
|
|
|
|
if (tb_port_is_enabled(port))
|
|
|
|
return;
|
|
|
|
|
|
|
|
list_for_each_entry(p, &tcm->dp_resources, list) {
|
|
|
|
if (p == port)
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
tb_port_dbg(port, "DP %s resource available\n",
|
|
|
|
tb_port_is_dpin(port) ? "IN" : "OUT");
|
|
|
|
list_add_tail(&port->list, &tcm->dp_resources);
|
|
|
|
|
|
|
|
/* Look for suitable DP IN <-> DP OUT pairs now */
|
|
|
|
tb_tunnel_dp(tb);
|
2018-09-17 13:30:49 +00:00
|
|
|
}
|
|
|
|
|
2018-12-30 19:34:08 +00:00
|
|
|
static int tb_tunnel_pci(struct tb *tb, struct tb_switch *sw)
|
|
|
|
{
|
|
|
|
struct tb_port *up, *down, *port;
|
|
|
|
struct tb_cm *tcm = tb_priv(tb);
|
|
|
|
struct tb_switch *parent_sw;
|
|
|
|
struct tb_tunnel *tunnel;
|
2014-06-03 20:04:08 +00:00
|
|
|
|
2019-12-17 12:33:37 +00:00
|
|
|
up = tb_switch_find_port(sw, TB_TYPE_PCIE_UP);
|
2018-12-30 19:34:08 +00:00
|
|
|
if (!up)
|
|
|
|
return 0;
|
2014-06-03 20:04:08 +00:00
|
|
|
|
2018-12-30 19:34:08 +00:00
|
|
|
/*
|
|
|
|
* Look up available down port. Since we are chaining it should
|
|
|
|
* be found right above this switch.
|
|
|
|
*/
|
|
|
|
parent_sw = tb_to_switch(sw->dev.parent);
|
|
|
|
port = tb_port_at(tb_route(sw), parent_sw);
|
|
|
|
down = tb_find_pcie_down(parent_sw, port);
|
|
|
|
if (!down)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
tunnel = tb_tunnel_alloc_pci(tb, up, down);
|
|
|
|
if (!tunnel)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
if (tb_tunnel_activate(tunnel)) {
|
|
|
|
tb_port_info(up,
|
|
|
|
"PCIe tunnel activation failed, aborting\n");
|
|
|
|
tb_tunnel_free(tunnel);
|
|
|
|
return -EIO;
|
2014-06-03 20:04:08 +00:00
|
|
|
}
|
2018-12-30 19:34:08 +00:00
|
|
|
|
|
|
|
list_add_tail(&tunnel->list, &tcm->tunnel_list);
|
|
|
|
return 0;
|
2014-06-03 20:04:08 +00:00
|
|
|
}
|
2014-06-03 20:04:05 +00:00
|
|
|
|
2018-09-28 13:41:01 +00:00
|
|
|
static int tb_approve_xdomain_paths(struct tb *tb, struct tb_xdomain *xd)
|
|
|
|
{
|
|
|
|
struct tb_cm *tcm = tb_priv(tb);
|
|
|
|
struct tb_port *nhi_port, *dst_port;
|
|
|
|
struct tb_tunnel *tunnel;
|
|
|
|
struct tb_switch *sw;
|
|
|
|
|
|
|
|
sw = tb_to_switch(xd->dev.parent);
|
|
|
|
dst_port = tb_port_at(xd->route, sw);
|
2019-12-17 12:33:37 +00:00
|
|
|
nhi_port = tb_switch_find_port(tb->root_switch, TB_TYPE_NHI);
|
2018-09-28 13:41:01 +00:00
|
|
|
|
|
|
|
mutex_lock(&tb->lock);
|
|
|
|
tunnel = tb_tunnel_alloc_dma(tb, nhi_port, dst_port, xd->transmit_ring,
|
|
|
|
xd->transmit_path, xd->receive_ring,
|
|
|
|
xd->receive_path);
|
|
|
|
if (!tunnel) {
|
|
|
|
mutex_unlock(&tb->lock);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (tb_tunnel_activate(tunnel)) {
|
|
|
|
tb_port_info(nhi_port,
|
|
|
|
"DMA tunnel activation failed, aborting\n");
|
|
|
|
tb_tunnel_free(tunnel);
|
|
|
|
mutex_unlock(&tb->lock);
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
list_add_tail(&tunnel->list, &tcm->tunnel_list);
|
|
|
|
mutex_unlock(&tb->lock);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __tb_disconnect_xdomain_paths(struct tb *tb, struct tb_xdomain *xd)
|
|
|
|
{
|
|
|
|
struct tb_port *dst_port;
|
2019-03-26 12:52:30 +00:00
|
|
|
struct tb_tunnel *tunnel;
|
2018-09-28 13:41:01 +00:00
|
|
|
struct tb_switch *sw;
|
|
|
|
|
|
|
|
sw = tb_to_switch(xd->dev.parent);
|
|
|
|
dst_port = tb_port_at(xd->route, sw);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* It is possible that the tunnel was already teared down (in
|
|
|
|
* case of cable disconnect) so it is fine if we cannot find it
|
|
|
|
* here anymore.
|
|
|
|
*/
|
2019-03-26 12:52:30 +00:00
|
|
|
tunnel = tb_find_tunnel(tb, TB_TUNNEL_DMA, NULL, dst_port);
|
|
|
|
tb_deactivate_and_free_tunnel(tunnel);
|
2018-09-28 13:41:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int tb_disconnect_xdomain_paths(struct tb *tb, struct tb_xdomain *xd)
|
|
|
|
{
|
|
|
|
if (!xd->is_unplugged) {
|
|
|
|
mutex_lock(&tb->lock);
|
|
|
|
__tb_disconnect_xdomain_paths(tb, xd);
|
|
|
|
mutex_unlock(&tb->lock);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-06-03 20:04:00 +00:00
|
|
|
/* hotplug handling */
|
|
|
|
|
|
|
|
/**
|
|
|
|
* tb_handle_hotplug() - handle hotplug event
|
|
|
|
*
|
|
|
|
* Executes on tb->wq.
|
|
|
|
*/
|
|
|
|
static void tb_handle_hotplug(struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct tb_hotplug_event *ev = container_of(work, typeof(*ev), work);
|
|
|
|
struct tb *tb = ev->tb;
|
2017-06-06 12:25:00 +00:00
|
|
|
struct tb_cm *tcm = tb_priv(tb);
|
2014-06-03 20:04:06 +00:00
|
|
|
struct tb_switch *sw;
|
|
|
|
struct tb_port *port;
|
2014-06-03 20:04:00 +00:00
|
|
|
mutex_lock(&tb->lock);
|
2017-06-06 12:25:00 +00:00
|
|
|
if (!tcm->hotplug_active)
|
2014-06-03 20:04:00 +00:00
|
|
|
goto out; /* during init, suspend or shutdown */
|
|
|
|
|
2019-03-15 12:56:21 +00:00
|
|
|
sw = tb_switch_find_by_route(tb, ev->route);
|
2014-06-03 20:04:06 +00:00
|
|
|
if (!sw) {
|
|
|
|
tb_warn(tb,
|
|
|
|
"hotplug event from non existent switch %llx:%x (unplug: %d)\n",
|
|
|
|
ev->route, ev->port, ev->unplug);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
if (ev->port > sw->config.max_port_number) {
|
|
|
|
tb_warn(tb,
|
|
|
|
"hotplug event from non existent port %llx:%x (unplug: %d)\n",
|
|
|
|
ev->route, ev->port, ev->unplug);
|
2019-03-15 12:56:21 +00:00
|
|
|
goto put_sw;
|
2014-06-03 20:04:06 +00:00
|
|
|
}
|
|
|
|
port = &sw->ports[ev->port];
|
|
|
|
if (tb_is_upstream_port(port)) {
|
2019-03-07 13:26:45 +00:00
|
|
|
tb_dbg(tb, "hotplug event for upstream port %llx:%x (unplug: %d)\n",
|
|
|
|
ev->route, ev->port, ev->unplug);
|
2019-03-15 12:56:21 +00:00
|
|
|
goto put_sw;
|
2014-06-03 20:04:06 +00:00
|
|
|
}
|
|
|
|
if (ev->unplug) {
|
2020-03-05 14:39:58 +00:00
|
|
|
tb_retimer_remove_all(port);
|
|
|
|
|
2019-03-07 13:26:45 +00:00
|
|
|
if (tb_port_has_remote(port)) {
|
2018-09-28 13:41:01 +00:00
|
|
|
tb_port_dbg(port, "switch unplugged\n");
|
2016-03-20 12:57:20 +00:00
|
|
|
tb_sw_set_unplugged(port->remote->sw);
|
2014-06-03 20:04:08 +00:00
|
|
|
tb_free_invalid_tunnels(tb);
|
2019-03-26 12:52:30 +00:00
|
|
|
tb_remove_dp_resources(port->remote->sw);
|
2019-12-17 12:33:43 +00:00
|
|
|
tb_switch_tmu_disable(port->remote->sw);
|
2019-03-21 17:03:00 +00:00
|
|
|
tb_switch_lane_bonding_disable(port->remote->sw);
|
2017-06-06 12:25:01 +00:00
|
|
|
tb_switch_remove(port->remote->sw);
|
2014-06-03 20:04:06 +00:00
|
|
|
port->remote = NULL;
|
2019-03-07 13:26:45 +00:00
|
|
|
if (port->dual_link_port)
|
|
|
|
port->dual_link_port->remote = NULL;
|
2019-03-26 12:52:30 +00:00
|
|
|
/* Maybe we can create another DP tunnel */
|
|
|
|
tb_tunnel_dp(tb);
|
2018-09-28 13:41:01 +00:00
|
|
|
} else if (port->xdomain) {
|
|
|
|
struct tb_xdomain *xd = tb_xdomain_get(port->xdomain);
|
|
|
|
|
|
|
|
tb_port_dbg(port, "xdomain unplugged\n");
|
|
|
|
/*
|
|
|
|
* Service drivers are unbound during
|
|
|
|
* tb_xdomain_remove() so setting XDomain as
|
|
|
|
* unplugged here prevents deadlock if they call
|
|
|
|
* tb_xdomain_disable_paths(). We will tear down
|
|
|
|
* the path below.
|
|
|
|
*/
|
|
|
|
xd->is_unplugged = true;
|
|
|
|
tb_xdomain_remove(xd);
|
|
|
|
port->xdomain = NULL;
|
|
|
|
__tb_disconnect_xdomain_paths(tb, xd);
|
|
|
|
tb_xdomain_put(xd);
|
2019-03-26 12:52:30 +00:00
|
|
|
} else if (tb_port_is_dpout(port) || tb_port_is_dpin(port)) {
|
|
|
|
tb_dp_resource_unavailable(tb, port);
|
2014-06-03 20:04:06 +00:00
|
|
|
} else {
|
2018-09-17 13:32:13 +00:00
|
|
|
tb_port_dbg(port,
|
|
|
|
"got unplug event for disconnected port, ignoring\n");
|
2014-06-03 20:04:06 +00:00
|
|
|
}
|
|
|
|
} else if (port->remote) {
|
2018-09-17 13:32:13 +00:00
|
|
|
tb_port_dbg(port, "got plug event for connected port, ignoring\n");
|
2014-06-03 20:04:06 +00:00
|
|
|
} else {
|
2017-10-11 14:19:54 +00:00
|
|
|
if (tb_port_is_null(port)) {
|
2018-09-17 13:32:13 +00:00
|
|
|
tb_port_dbg(port, "hotplug: scanning\n");
|
2017-10-11 14:19:54 +00:00
|
|
|
tb_scan_port(port);
|
|
|
|
if (!port->remote)
|
2018-09-17 13:32:13 +00:00
|
|
|
tb_port_dbg(port, "hotplug: no switch found\n");
|
2019-03-26 12:52:30 +00:00
|
|
|
} else if (tb_port_is_dpout(port) || tb_port_is_dpin(port)) {
|
|
|
|
tb_dp_resource_available(tb, port);
|
2017-10-11 14:19:54 +00:00
|
|
|
}
|
2014-06-03 20:04:06 +00:00
|
|
|
}
|
2019-03-15 12:56:21 +00:00
|
|
|
|
|
|
|
put_sw:
|
|
|
|
tb_switch_put(sw);
|
2014-06-03 20:04:00 +00:00
|
|
|
out:
|
|
|
|
mutex_unlock(&tb->lock);
|
|
|
|
kfree(ev);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* tb_schedule_hotplug_handler() - callback function for the control channel
|
|
|
|
*
|
|
|
|
* Delegates to tb_handle_hotplug.
|
|
|
|
*/
|
2017-06-06 12:25:09 +00:00
|
|
|
static void tb_handle_event(struct tb *tb, enum tb_cfg_pkg_type type,
|
|
|
|
const void *buf, size_t size)
|
2014-06-03 20:04:00 +00:00
|
|
|
{
|
2017-06-06 12:25:09 +00:00
|
|
|
const struct cfg_event_pkg *pkg = buf;
|
|
|
|
u64 route;
|
|
|
|
|
|
|
|
if (type != TB_CFG_PKG_EVENT) {
|
|
|
|
tb_warn(tb, "unexpected event %#x, ignoring\n", type);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
route = tb_cfg_get_route(&pkg->header);
|
|
|
|
|
2019-12-17 12:33:39 +00:00
|
|
|
if (tb_cfg_ack_plug(tb->ctl, route, pkg->port, pkg->unplug)) {
|
2017-06-06 12:25:09 +00:00
|
|
|
tb_warn(tb, "could not ack plug event on %llx:%x\n", route,
|
|
|
|
pkg->port);
|
|
|
|
}
|
|
|
|
|
2018-09-17 13:30:49 +00:00
|
|
|
tb_queue_hotplug(tb, route, pkg->port, pkg->unplug);
|
2014-06-03 20:04:00 +00:00
|
|
|
}
|
|
|
|
|
2017-06-06 12:25:00 +00:00
|
|
|
static void tb_stop(struct tb *tb)
|
2014-06-03 20:04:00 +00:00
|
|
|
{
|
2017-06-06 12:25:00 +00:00
|
|
|
struct tb_cm *tcm = tb_priv(tb);
|
2017-02-19 11:48:29 +00:00
|
|
|
struct tb_tunnel *tunnel;
|
|
|
|
struct tb_tunnel *n;
|
2014-06-03 20:04:08 +00:00
|
|
|
|
|
|
|
/* tunnels are only present after everything has been initialized */
|
2018-09-28 13:41:01 +00:00
|
|
|
list_for_each_entry_safe(tunnel, n, &tcm->tunnel_list, list) {
|
|
|
|
/*
|
|
|
|
* DMA tunnels require the driver to be functional so we
|
|
|
|
* tear them down. Other protocol tunnels can be left
|
|
|
|
* intact.
|
|
|
|
*/
|
|
|
|
if (tb_tunnel_is_dma(tunnel))
|
|
|
|
tb_tunnel_deactivate(tunnel);
|
2017-02-19 11:48:29 +00:00
|
|
|
tb_tunnel_free(tunnel);
|
2018-09-28 13:41:01 +00:00
|
|
|
}
|
2017-06-06 12:25:01 +00:00
|
|
|
tb_switch_remove(tb->root_switch);
|
2017-06-06 12:25:00 +00:00
|
|
|
tcm->hotplug_active = false; /* signal tb_handle_hotplug to quit */
|
2014-06-03 20:04:00 +00:00
|
|
|
}
|
|
|
|
|
2018-12-30 19:34:08 +00:00
|
|
|
static int tb_scan_finalize_switch(struct device *dev, void *data)
|
|
|
|
{
|
|
|
|
if (tb_is_switch(dev)) {
|
|
|
|
struct tb_switch *sw = tb_to_switch(dev);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we found that the switch was already setup by the
|
|
|
|
* boot firmware, mark it as authorized now before we
|
|
|
|
* send uevent to userspace.
|
|
|
|
*/
|
|
|
|
if (sw->boot)
|
|
|
|
sw->authorized = 1;
|
|
|
|
|
|
|
|
dev_set_uevent_suppress(dev, false);
|
|
|
|
kobject_uevent(&dev->kobj, KOBJ_ADD);
|
|
|
|
device_for_each_child(dev, NULL, tb_scan_finalize_switch);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-06-06 12:25:00 +00:00
|
|
|
static int tb_start(struct tb *tb)
|
2014-06-03 20:04:00 +00:00
|
|
|
{
|
2017-06-06 12:25:00 +00:00
|
|
|
struct tb_cm *tcm = tb_priv(tb);
|
2017-06-06 12:25:01 +00:00
|
|
|
int ret;
|
2014-06-03 20:04:00 +00:00
|
|
|
|
2017-06-06 12:25:01 +00:00
|
|
|
tb->root_switch = tb_switch_alloc(tb, &tb->dev, 0);
|
2018-12-30 10:17:52 +00:00
|
|
|
if (IS_ERR(tb->root_switch))
|
|
|
|
return PTR_ERR(tb->root_switch);
|
2014-06-03 20:04:02 +00:00
|
|
|
|
2017-06-06 12:25:17 +00:00
|
|
|
/*
|
|
|
|
* ICM firmware upgrade needs running firmware and in native
|
|
|
|
* mode that is not available so disable firmware upgrade of the
|
|
|
|
* root switch.
|
|
|
|
*/
|
|
|
|
tb->root_switch->no_nvm_upgrade = true;
|
|
|
|
|
2017-06-06 12:25:01 +00:00
|
|
|
ret = tb_switch_configure(tb->root_switch);
|
|
|
|
if (ret) {
|
|
|
|
tb_switch_put(tb->root_switch);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Announce the switch to the world */
|
|
|
|
ret = tb_switch_add(tb->root_switch);
|
|
|
|
if (ret) {
|
|
|
|
tb_switch_put(tb->root_switch);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2019-12-17 12:33:43 +00:00
|
|
|
/* Enable TMU if it is off */
|
|
|
|
tb_switch_tmu_enable(tb->root_switch);
|
2014-06-03 20:04:05 +00:00
|
|
|
/* Full scan to discover devices added before the driver was loaded. */
|
|
|
|
tb_scan_switch(tb->root_switch);
|
2017-02-19 21:43:26 +00:00
|
|
|
/* Find out tunnels created by the boot firmware */
|
|
|
|
tb_discover_tunnels(tb->root_switch);
|
2019-12-17 12:33:44 +00:00
|
|
|
/*
|
|
|
|
* If the boot firmware did not create USB 3.x tunnels create them
|
|
|
|
* now for the whole topology.
|
|
|
|
*/
|
|
|
|
tb_create_usb3_tunnels(tb->root_switch);
|
2019-03-26 12:52:30 +00:00
|
|
|
/* Add DP IN resources for the root switch */
|
|
|
|
tb_add_dp_resources(tb->root_switch);
|
2018-12-30 19:34:08 +00:00
|
|
|
/* Make the discovered switches available to the userspace */
|
|
|
|
device_for_each_child(&tb->root_switch->dev, NULL,
|
|
|
|
tb_scan_finalize_switch);
|
2014-06-03 20:04:05 +00:00
|
|
|
|
2014-06-03 20:04:00 +00:00
|
|
|
/* Allow tb_handle_hotplug to progress events */
|
2017-06-06 12:25:00 +00:00
|
|
|
tcm->hotplug_active = true;
|
|
|
|
return 0;
|
2014-06-03 20:04:00 +00:00
|
|
|
}
|
|
|
|
|
2017-06-06 12:25:00 +00:00
|
|
|
static int tb_suspend_noirq(struct tb *tb)
|
2014-06-03 20:04:12 +00:00
|
|
|
{
|
2017-06-06 12:25:00 +00:00
|
|
|
struct tb_cm *tcm = tb_priv(tb);
|
|
|
|
|
2018-10-01 09:31:19 +00:00
|
|
|
tb_dbg(tb, "suspending...\n");
|
2014-06-03 20:04:12 +00:00
|
|
|
tb_switch_suspend(tb->root_switch);
|
2017-06-06 12:25:00 +00:00
|
|
|
tcm->hotplug_active = false; /* signal tb_handle_hotplug to quit */
|
2018-10-01 09:31:19 +00:00
|
|
|
tb_dbg(tb, "suspend finished\n");
|
2017-06-06 12:25:00 +00:00
|
|
|
|
|
|
|
return 0;
|
2014-06-03 20:04:12 +00:00
|
|
|
}
|
|
|
|
|
2019-03-21 17:03:00 +00:00
|
|
|
static void tb_restore_children(struct tb_switch *sw)
|
|
|
|
{
|
|
|
|
struct tb_port *port;
|
|
|
|
|
2019-12-17 12:33:43 +00:00
|
|
|
if (tb_enable_tmu(sw))
|
|
|
|
tb_sw_warn(sw, "failed to restore TMU configuration\n");
|
|
|
|
|
2019-03-21 17:03:00 +00:00
|
|
|
tb_switch_for_each_port(sw, port) {
|
|
|
|
if (!tb_port_has_remote(port))
|
|
|
|
continue;
|
|
|
|
|
2020-04-02 11:28:18 +00:00
|
|
|
tb_switch_lane_bonding_enable(port->remote->sw);
|
2019-03-21 17:03:00 +00:00
|
|
|
|
|
|
|
tb_restore_children(port->remote->sw);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-06-06 12:25:00 +00:00
|
|
|
static int tb_resume_noirq(struct tb *tb)
|
2014-06-03 20:04:12 +00:00
|
|
|
{
|
2017-06-06 12:25:00 +00:00
|
|
|
struct tb_cm *tcm = tb_priv(tb);
|
2017-02-19 11:48:29 +00:00
|
|
|
struct tb_tunnel *tunnel, *n;
|
2017-06-06 12:25:00 +00:00
|
|
|
|
2018-10-01 09:31:19 +00:00
|
|
|
tb_dbg(tb, "resuming...\n");
|
2014-06-03 20:04:12 +00:00
|
|
|
|
|
|
|
/* remove any pci devices the firmware might have setup */
|
|
|
|
tb_switch_reset(tb, 0);
|
|
|
|
|
|
|
|
tb_switch_resume(tb->root_switch);
|
|
|
|
tb_free_invalid_tunnels(tb);
|
|
|
|
tb_free_unplugged_children(tb->root_switch);
|
2019-03-21 17:03:00 +00:00
|
|
|
tb_restore_children(tb->root_switch);
|
2017-06-06 12:25:00 +00:00
|
|
|
list_for_each_entry_safe(tunnel, n, &tcm->tunnel_list, list)
|
2017-02-19 11:48:29 +00:00
|
|
|
tb_tunnel_restart(tunnel);
|
2017-06-06 12:25:00 +00:00
|
|
|
if (!list_empty(&tcm->tunnel_list)) {
|
2014-06-03 20:04:12 +00:00
|
|
|
/*
|
|
|
|
* the pcie links need some time to get going.
|
|
|
|
* 100ms works for me...
|
|
|
|
*/
|
2018-10-01 09:31:19 +00:00
|
|
|
tb_dbg(tb, "tunnels restarted, sleeping for 100ms\n");
|
2014-06-03 20:04:12 +00:00
|
|
|
msleep(100);
|
|
|
|
}
|
|
|
|
/* Allow tb_handle_hotplug to progress events */
|
2017-06-06 12:25:00 +00:00
|
|
|
tcm->hotplug_active = true;
|
2018-10-01 09:31:19 +00:00
|
|
|
tb_dbg(tb, "resume finished\n");
|
2017-06-06 12:25:00 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2018-09-28 13:41:01 +00:00
|
|
|
static int tb_free_unplugged_xdomains(struct tb_switch *sw)
|
|
|
|
{
|
2019-09-30 11:07:22 +00:00
|
|
|
struct tb_port *port;
|
|
|
|
int ret = 0;
|
2018-09-28 13:41:01 +00:00
|
|
|
|
2019-09-30 11:07:22 +00:00
|
|
|
tb_switch_for_each_port(sw, port) {
|
2018-09-28 13:41:01 +00:00
|
|
|
if (tb_is_upstream_port(port))
|
|
|
|
continue;
|
|
|
|
if (port->xdomain && port->xdomain->is_unplugged) {
|
2020-03-05 14:39:58 +00:00
|
|
|
tb_retimer_remove_all(port);
|
2018-09-28 13:41:01 +00:00
|
|
|
tb_xdomain_remove(port->xdomain);
|
|
|
|
port->xdomain = NULL;
|
|
|
|
ret++;
|
|
|
|
} else if (port->remote) {
|
|
|
|
ret += tb_free_unplugged_xdomains(port->remote->sw);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void tb_complete(struct tb *tb)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Release any unplugged XDomains and if there is a case where
|
|
|
|
* another domain is swapped in place of unplugged XDomain we
|
|
|
|
* need to run another rescan.
|
|
|
|
*/
|
|
|
|
mutex_lock(&tb->lock);
|
|
|
|
if (tb_free_unplugged_xdomains(tb->root_switch))
|
|
|
|
tb_scan_switch(tb->root_switch);
|
|
|
|
mutex_unlock(&tb->lock);
|
|
|
|
}
|
|
|
|
|
2017-06-06 12:25:00 +00:00
|
|
|
static const struct tb_cm_ops tb_cm_ops = {
|
|
|
|
.start = tb_start,
|
|
|
|
.stop = tb_stop,
|
|
|
|
.suspend_noirq = tb_suspend_noirq,
|
|
|
|
.resume_noirq = tb_resume_noirq,
|
2018-09-28 13:41:01 +00:00
|
|
|
.complete = tb_complete,
|
2017-06-06 12:25:09 +00:00
|
|
|
.handle_event = tb_handle_event,
|
2018-12-30 19:34:08 +00:00
|
|
|
.approve_switch = tb_tunnel_pci,
|
2018-09-28 13:41:01 +00:00
|
|
|
.approve_xdomain_paths = tb_approve_xdomain_paths,
|
|
|
|
.disconnect_xdomain_paths = tb_disconnect_xdomain_paths,
|
2017-06-06 12:25:00 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
struct tb *tb_probe(struct tb_nhi *nhi)
|
|
|
|
{
|
|
|
|
struct tb_cm *tcm;
|
|
|
|
struct tb *tb;
|
|
|
|
|
|
|
|
tb = tb_domain_alloc(nhi, sizeof(*tcm));
|
|
|
|
if (!tb)
|
|
|
|
return NULL;
|
|
|
|
|
2018-12-30 19:34:08 +00:00
|
|
|
tb->security_level = TB_SECURITY_USER;
|
2017-06-06 12:25:00 +00:00
|
|
|
tb->cm_ops = &tb_cm_ops;
|
|
|
|
|
|
|
|
tcm = tb_priv(tb);
|
|
|
|
INIT_LIST_HEAD(&tcm->tunnel_list);
|
2019-03-26 12:52:30 +00:00
|
|
|
INIT_LIST_HEAD(&tcm->dp_resources);
|
2017-06-06 12:25:00 +00:00
|
|
|
|
|
|
|
return tb;
|
2014-06-03 20:04:12 +00:00
|
|
|
}
|