mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-09-06 19:07:52 +00:00
thunderbolt: Changes for v5.2 merge window
This improves software connection manager on older Apple systems with Thunderbolt 1 and 2 controller to support full PCIe daisy chains, Display Port tunneling and P2P networking. There are also fixes for potential NULL pointer dereferences at various places in the driver. -----BEGIN PGP SIGNATURE----- iQJUBAABCgA+FiEEVTdhRGBbNzLrSUBaAP2fSd+ZWKAFAlzCyCMgHG1pa2Eud2Vz dGVyYmVyZ0BsaW51eC5pbnRlbC5jb20ACgkQAP2fSd+ZWKA1ZhAAhNmKam9NYvYz sf632XmfBVZ/l7TMmejGX+2CbFjSXLMgdKIVhgaGUMJc4pNMGTteDLgYzGTiKjLQ UcCfGowjPJdOVJwoWku+g27Y5aKlDWyugqtFr16wLpvkoWIu+yGmtZ290tQWeUVb J/Vvp9fZ5+/fCaQzWpEoTiSeJaxH5AshFaTwhy5GbHyovvp6iaWv7GZGxEnLWQRG wFvChvCR4G1oZtVR+1ROk33MC5aC/qo3CRrhALEqScmPYFKABS7c2O2BddZGfH1P nGVdV3Hh8ThLEAjT7Iz1I37DrFBKCHIpbCbY1eibUhZtehDXf8piRmIkbuWDhCH8 afWtKck/c333YA9RMvdiweVi1iyNySLAs7ZjfHWDM+08tqPhrR6O9L/KPAdmgfy9 RGw2JxrQk26rWLZJ0pdzh7UqS/l/idi5blCk2Ap9QkNHj3DwRwA6Wdt2qmrqY0j1 5eHdldvbHQuZpCJ/wYusINsdDPzVWTqtK94ZnCD2seW/PdMTAKTLdwKrc9zAD1fk FgfZ1zC5Hhc84klqy6H86855bNaCAH7ORE4fX5P0ZwXGuleNTyfOQmeXXqodqISR GHHcmvO7LdA7gWrrwOpczKTTq5jAgMg43rONXTL6w7a0i0K5BZeWkPwqvZvIOcCD 9Tq4LYI216KEtXKPxPGEVPHlh249Kns= =nqM+ -----END PGP SIGNATURE----- Merge tag 'thunderbolt-for-v5.2' of git://git.kernel.org/pub/scm/linux/kernel/git/westeri/thunderbolt into char-misc-next Mika writes: thunderbolt: Changes for v5.2 merge window This improves software connection manager on older Apple systems with Thunderbolt 1 and 2 controller to support full PCIe daisy chains, Display Port tunneling and P2P networking. There are also fixes for potential NULL pointer dereferences at various places in the driver. * tag 'thunderbolt-for-v5.2' of git://git.kernel.org/pub/scm/linux/kernel/git/westeri/thunderbolt: (44 commits) thunderbolt: Make priority unsigned in struct tb_path thunderbolt: Start firmware on Titan Ridge Apple systems thunderbolt: Reword output of tb_dump_hop() thunderbolt: Make rest of the logging to happen at debug level thunderbolt: Make __TB_[SW|PORT]_PRINT take const parameters thunderbolt: Add support for XDomain connections thunderbolt: Make tb_switch_alloc() return ERR_PTR() thunderbolt: Add support for DMA tunnels thunderbolt: Add XDomain UUID exchange support thunderbolt: Run tb_xdp_handle_request() in system workqueue thunderbolt: Do not tear down tunnels when driver is unloaded thunderbolt: Add support for Display Port tunnels thunderbolt: Rework NFC credits handling thunderbolt: Generalize port finding routines to support all port types thunderbolt: Scan only valid NULL adapter ports in hotplug thunderbolt: Add support for full PCIe daisy chains thunderbolt: Discover preboot PCIe paths the boot firmware established thunderbolt: Deactivate all paths before restarting them thunderbolt: Extend tunnel creation to more than 2 adjacent switches thunderbolt: Add helper function to iterate from one port to another ...
This commit is contained in:
commit
c0286f5680
20 changed files with 2770 additions and 674 deletions
|
@ -1282,6 +1282,7 @@ static int __maybe_unused tbnet_suspend(struct device *dev)
|
||||||
tbnet_tear_down(net, true);
|
tbnet_tear_down(net, true);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
tb_unregister_protocol_handler(&net->handler);
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -1290,6 +1291,8 @@ static int __maybe_unused tbnet_resume(struct device *dev)
|
||||||
struct tb_service *svc = tb_to_service(dev);
|
struct tb_service *svc = tb_to_service(dev);
|
||||||
struct tbnet *net = tb_service_get_drvdata(svc);
|
struct tbnet *net = tb_service_get_drvdata(svc);
|
||||||
|
|
||||||
|
tb_register_protocol_handler(&net->handler);
|
||||||
|
|
||||||
netif_carrier_off(net->dev);
|
netif_carrier_off(net->dev);
|
||||||
if (netif_running(net->dev)) {
|
if (netif_running(net->dev)) {
|
||||||
netif_device_attach(net->dev);
|
netif_device_attach(net->dev);
|
||||||
|
|
|
@ -1,3 +1,3 @@
|
||||||
obj-${CONFIG_THUNDERBOLT} := thunderbolt.o
|
obj-${CONFIG_THUNDERBOLT} := thunderbolt.o
|
||||||
thunderbolt-objs := nhi.o ctl.o tb.o switch.o cap.o path.o tunnel_pci.o eeprom.o
|
thunderbolt-objs := nhi.o ctl.o tb.o switch.o cap.o path.o tunnel.o eeprom.o
|
||||||
thunderbolt-objs += domain.o dma_port.o icm.o property.o xdomain.o
|
thunderbolt-objs += domain.o dma_port.o icm.o property.o xdomain.o lc.o
|
||||||
|
|
|
@ -13,6 +13,7 @@
|
||||||
|
|
||||||
#define CAP_OFFSET_MAX 0xff
|
#define CAP_OFFSET_MAX 0xff
|
||||||
#define VSE_CAP_OFFSET_MAX 0xffff
|
#define VSE_CAP_OFFSET_MAX 0xffff
|
||||||
|
#define TMU_ACCESS_EN BIT(20)
|
||||||
|
|
||||||
struct tb_cap_any {
|
struct tb_cap_any {
|
||||||
union {
|
union {
|
||||||
|
@ -22,28 +23,53 @@ struct tb_cap_any {
|
||||||
};
|
};
|
||||||
} __packed;
|
} __packed;
|
||||||
|
|
||||||
/**
|
static int tb_port_enable_tmu(struct tb_port *port, bool enable)
|
||||||
* tb_port_find_cap() - Find port capability
|
|
||||||
* @port: Port to find the capability for
|
|
||||||
* @cap: Capability to look
|
|
||||||
*
|
|
||||||
* Returns offset to start of capability or %-ENOENT if no such
|
|
||||||
* capability was found. Negative errno is returned if there was an
|
|
||||||
* error.
|
|
||||||
*/
|
|
||||||
int tb_port_find_cap(struct tb_port *port, enum tb_port_cap cap)
|
|
||||||
{
|
{
|
||||||
u32 offset;
|
struct tb_switch *sw = port->sw;
|
||||||
|
u32 value, offset;
|
||||||
|
int ret;
|
||||||
|
|
||||||
/*
|
/*
|
||||||
* DP out adapters claim to implement TMU capability but in
|
* Legacy devices need to have TMU access enabled before port
|
||||||
* reality they do not so we hard code the adapter specific
|
* space can be fully accessed.
|
||||||
* capability offset here.
|
|
||||||
*/
|
*/
|
||||||
if (port->config.type == TB_TYPE_DP_HDMI_OUT)
|
if (tb_switch_is_lr(sw))
|
||||||
offset = 0x39;
|
offset = 0x26;
|
||||||
|
else if (tb_switch_is_er(sw))
|
||||||
|
offset = 0x2a;
|
||||||
else
|
else
|
||||||
offset = 0x1;
|
return 0;
|
||||||
|
|
||||||
|
ret = tb_sw_read(sw, &value, TB_CFG_SWITCH, offset, 1);
|
||||||
|
if (ret)
|
||||||
|
return ret;
|
||||||
|
|
||||||
|
if (enable)
|
||||||
|
value |= TMU_ACCESS_EN;
|
||||||
|
else
|
||||||
|
value &= ~TMU_ACCESS_EN;
|
||||||
|
|
||||||
|
return tb_sw_write(sw, &value, TB_CFG_SWITCH, offset, 1);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void tb_port_dummy_read(struct tb_port *port)
|
||||||
|
{
|
||||||
|
/*
|
||||||
|
* When reading from next capability pointer location in port
|
||||||
|
* config space the read data is not cleared on LR. To avoid
|
||||||
|
* reading stale data on next read perform one dummy read after
|
||||||
|
* port capabilities are walked.
|
||||||
|
*/
|
||||||
|
if (tb_switch_is_lr(port->sw)) {
|
||||||
|
u32 dummy;
|
||||||
|
|
||||||
|
tb_port_read(port, &dummy, TB_CFG_PORT, 0, 1);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
static int __tb_port_find_cap(struct tb_port *port, enum tb_port_cap cap)
|
||||||
|
{
|
||||||
|
u32 offset = 1;
|
||||||
|
|
||||||
do {
|
do {
|
||||||
struct tb_cap_any header;
|
struct tb_cap_any header;
|
||||||
|
@ -62,6 +88,31 @@ int tb_port_find_cap(struct tb_port *port, enum tb_port_cap cap)
|
||||||
return -ENOENT;
|
return -ENOENT;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* tb_port_find_cap() - Find port capability
|
||||||
|
* @port: Port to find the capability for
|
||||||
|
* @cap: Capability to look
|
||||||
|
*
|
||||||
|
* Returns offset to start of capability or %-ENOENT if no such
|
||||||
|
* capability was found. Negative errno is returned if there was an
|
||||||
|
* error.
|
||||||
|
*/
|
||||||
|
int tb_port_find_cap(struct tb_port *port, enum tb_port_cap cap)
|
||||||
|
{
|
||||||
|
int ret;
|
||||||
|
|
||||||
|
ret = tb_port_enable_tmu(port, true);
|
||||||
|
if (ret)
|
||||||
|
return ret;
|
||||||
|
|
||||||
|
ret = __tb_port_find_cap(port, cap);
|
||||||
|
|
||||||
|
tb_port_dummy_read(port);
|
||||||
|
tb_port_enable_tmu(port, false);
|
||||||
|
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
|
||||||
static int tb_switch_find_cap(struct tb_switch *sw, enum tb_switch_cap cap)
|
static int tb_switch_find_cap(struct tb_switch *sw, enum tb_switch_cap cap)
|
||||||
{
|
{
|
||||||
int offset = sw->config.first_cap_offset;
|
int offset = sw->config.first_cap_offset;
|
||||||
|
|
|
@ -720,7 +720,7 @@ int tb_cfg_error(struct tb_ctl *ctl, u64 route, u32 port,
|
||||||
.port = port,
|
.port = port,
|
||||||
.error = error,
|
.error = error,
|
||||||
};
|
};
|
||||||
tb_ctl_info(ctl, "resetting error on %llx:%x.\n", route, port);
|
tb_ctl_dbg(ctl, "resetting error on %llx:%x.\n", route, port);
|
||||||
return tb_ctl_tx(ctl, &pkg, sizeof(pkg), TB_CFG_PKG_ERROR);
|
return tb_ctl_tx(ctl, &pkg, sizeof(pkg), TB_CFG_PKG_ERROR);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
@ -42,7 +42,6 @@
|
||||||
#define ICM_TIMEOUT 5000 /* ms */
|
#define ICM_TIMEOUT 5000 /* ms */
|
||||||
#define ICM_APPROVE_TIMEOUT 10000 /* ms */
|
#define ICM_APPROVE_TIMEOUT 10000 /* ms */
|
||||||
#define ICM_MAX_LINK 4
|
#define ICM_MAX_LINK 4
|
||||||
#define ICM_MAX_DEPTH 6
|
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* struct icm - Internal connection manager private data
|
* struct icm - Internal connection manager private data
|
||||||
|
@ -469,10 +468,15 @@ static void add_switch(struct tb_switch *parent_sw, u64 route,
|
||||||
pm_runtime_get_sync(&parent_sw->dev);
|
pm_runtime_get_sync(&parent_sw->dev);
|
||||||
|
|
||||||
sw = tb_switch_alloc(parent_sw->tb, &parent_sw->dev, route);
|
sw = tb_switch_alloc(parent_sw->tb, &parent_sw->dev, route);
|
||||||
if (!sw)
|
if (IS_ERR(sw))
|
||||||
goto out;
|
goto out;
|
||||||
|
|
||||||
sw->uuid = kmemdup(uuid, sizeof(*uuid), GFP_KERNEL);
|
sw->uuid = kmemdup(uuid, sizeof(*uuid), GFP_KERNEL);
|
||||||
|
if (!sw->uuid) {
|
||||||
|
tb_sw_warn(sw, "cannot allocate memory for switch\n");
|
||||||
|
tb_switch_put(sw);
|
||||||
|
goto out;
|
||||||
|
}
|
||||||
sw->connection_id = connection_id;
|
sw->connection_id = connection_id;
|
||||||
sw->connection_key = connection_key;
|
sw->connection_key = connection_key;
|
||||||
sw->link = link;
|
sw->link = link;
|
||||||
|
@ -709,7 +713,7 @@ icm_fr_device_disconnected(struct tb *tb, const struct icm_pkg_header *hdr)
|
||||||
depth = (pkg->link_info & ICM_LINK_INFO_DEPTH_MASK) >>
|
depth = (pkg->link_info & ICM_LINK_INFO_DEPTH_MASK) >>
|
||||||
ICM_LINK_INFO_DEPTH_SHIFT;
|
ICM_LINK_INFO_DEPTH_SHIFT;
|
||||||
|
|
||||||
if (link > ICM_MAX_LINK || depth > ICM_MAX_DEPTH) {
|
if (link > ICM_MAX_LINK || depth > TB_SWITCH_MAX_DEPTH) {
|
||||||
tb_warn(tb, "invalid topology %u.%u, ignoring\n", link, depth);
|
tb_warn(tb, "invalid topology %u.%u, ignoring\n", link, depth);
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
@ -739,7 +743,7 @@ icm_fr_xdomain_connected(struct tb *tb, const struct icm_pkg_header *hdr)
|
||||||
depth = (pkg->link_info & ICM_LINK_INFO_DEPTH_MASK) >>
|
depth = (pkg->link_info & ICM_LINK_INFO_DEPTH_MASK) >>
|
||||||
ICM_LINK_INFO_DEPTH_SHIFT;
|
ICM_LINK_INFO_DEPTH_SHIFT;
|
||||||
|
|
||||||
if (link > ICM_MAX_LINK || depth > ICM_MAX_DEPTH) {
|
if (link > ICM_MAX_LINK || depth > TB_SWITCH_MAX_DEPTH) {
|
||||||
tb_warn(tb, "invalid topology %u.%u, ignoring\n", link, depth);
|
tb_warn(tb, "invalid topology %u.%u, ignoring\n", link, depth);
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
@ -793,9 +797,11 @@ icm_fr_xdomain_connected(struct tb *tb, const struct icm_pkg_header *hdr)
|
||||||
* connected another host to the same port, remove the switch
|
* connected another host to the same port, remove the switch
|
||||||
* first.
|
* first.
|
||||||
*/
|
*/
|
||||||
sw = get_switch_at_route(tb->root_switch, route);
|
sw = tb_switch_find_by_route(tb, route);
|
||||||
if (sw)
|
if (sw) {
|
||||||
remove_switch(sw);
|
remove_switch(sw);
|
||||||
|
tb_switch_put(sw);
|
||||||
|
}
|
||||||
|
|
||||||
sw = tb_switch_find_by_link_depth(tb, link, depth);
|
sw = tb_switch_find_by_link_depth(tb, link, depth);
|
||||||
if (!sw) {
|
if (!sw) {
|
||||||
|
@ -1138,9 +1144,11 @@ icm_tr_xdomain_connected(struct tb *tb, const struct icm_pkg_header *hdr)
|
||||||
* connected another host to the same port, remove the switch
|
* connected another host to the same port, remove the switch
|
||||||
* first.
|
* first.
|
||||||
*/
|
*/
|
||||||
sw = get_switch_at_route(tb->root_switch, route);
|
sw = tb_switch_find_by_route(tb, route);
|
||||||
if (sw)
|
if (sw) {
|
||||||
remove_switch(sw);
|
remove_switch(sw);
|
||||||
|
tb_switch_put(sw);
|
||||||
|
}
|
||||||
|
|
||||||
sw = tb_switch_find_by_route(tb, get_parent_route(route));
|
sw = tb_switch_find_by_route(tb, get_parent_route(route));
|
||||||
if (!sw) {
|
if (!sw) {
|
||||||
|
@ -1191,6 +1199,8 @@ static struct pci_dev *get_upstream_port(struct pci_dev *pdev)
|
||||||
case PCI_DEVICE_ID_INTEL_ALPINE_RIDGE_LP_BRIDGE:
|
case PCI_DEVICE_ID_INTEL_ALPINE_RIDGE_LP_BRIDGE:
|
||||||
case PCI_DEVICE_ID_INTEL_ALPINE_RIDGE_C_4C_BRIDGE:
|
case PCI_DEVICE_ID_INTEL_ALPINE_RIDGE_C_4C_BRIDGE:
|
||||||
case PCI_DEVICE_ID_INTEL_ALPINE_RIDGE_C_2C_BRIDGE:
|
case PCI_DEVICE_ID_INTEL_ALPINE_RIDGE_C_2C_BRIDGE:
|
||||||
|
case PCI_DEVICE_ID_INTEL_TITAN_RIDGE_2C_BRIDGE:
|
||||||
|
case PCI_DEVICE_ID_INTEL_TITAN_RIDGE_4C_BRIDGE:
|
||||||
return parent;
|
return parent;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -1560,7 +1570,7 @@ static int icm_firmware_start(struct tb *tb, struct tb_nhi *nhi)
|
||||||
if (val & REG_FW_STS_ICM_EN)
|
if (val & REG_FW_STS_ICM_EN)
|
||||||
return 0;
|
return 0;
|
||||||
|
|
||||||
dev_info(&nhi->pdev->dev, "starting ICM firmware\n");
|
dev_dbg(&nhi->pdev->dev, "starting ICM firmware\n");
|
||||||
|
|
||||||
ret = icm_firmware_reset(tb, nhi);
|
ret = icm_firmware_reset(tb, nhi);
|
||||||
if (ret)
|
if (ret)
|
||||||
|
@ -1753,15 +1763,9 @@ static void icm_unplug_children(struct tb_switch *sw)
|
||||||
for (i = 1; i <= sw->config.max_port_number; i++) {
|
for (i = 1; i <= sw->config.max_port_number; i++) {
|
||||||
struct tb_port *port = &sw->ports[i];
|
struct tb_port *port = &sw->ports[i];
|
||||||
|
|
||||||
if (tb_is_upstream_port(port))
|
if (port->xdomain)
|
||||||
continue;
|
|
||||||
if (port->xdomain) {
|
|
||||||
port->xdomain->is_unplugged = true;
|
port->xdomain->is_unplugged = true;
|
||||||
continue;
|
else if (tb_port_has_remote(port))
|
||||||
}
|
|
||||||
if (!port->remote)
|
|
||||||
continue;
|
|
||||||
|
|
||||||
icm_unplug_children(port->remote->sw);
|
icm_unplug_children(port->remote->sw);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -1773,18 +1777,10 @@ static void icm_free_unplugged_children(struct tb_switch *sw)
|
||||||
for (i = 1; i <= sw->config.max_port_number; i++) {
|
for (i = 1; i <= sw->config.max_port_number; i++) {
|
||||||
struct tb_port *port = &sw->ports[i];
|
struct tb_port *port = &sw->ports[i];
|
||||||
|
|
||||||
if (tb_is_upstream_port(port))
|
|
||||||
continue;
|
|
||||||
|
|
||||||
if (port->xdomain && port->xdomain->is_unplugged) {
|
if (port->xdomain && port->xdomain->is_unplugged) {
|
||||||
tb_xdomain_remove(port->xdomain);
|
tb_xdomain_remove(port->xdomain);
|
||||||
port->xdomain = NULL;
|
port->xdomain = NULL;
|
||||||
continue;
|
} else if (tb_port_has_remote(port)) {
|
||||||
}
|
|
||||||
|
|
||||||
if (!port->remote)
|
|
||||||
continue;
|
|
||||||
|
|
||||||
if (port->remote->sw->is_unplugged) {
|
if (port->remote->sw->is_unplugged) {
|
||||||
tb_switch_remove(port->remote->sw);
|
tb_switch_remove(port->remote->sw);
|
||||||
port->remote = NULL;
|
port->remote = NULL;
|
||||||
|
@ -1792,6 +1788,7 @@ static void icm_free_unplugged_children(struct tb_switch *sw)
|
||||||
icm_free_unplugged_children(port->remote->sw);
|
icm_free_unplugged_children(port->remote->sw);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
static void icm_rescan_work(struct work_struct *work)
|
static void icm_rescan_work(struct work_struct *work)
|
||||||
|
@ -1853,8 +1850,8 @@ static int icm_start(struct tb *tb)
|
||||||
tb->root_switch = tb_switch_alloc_safe_mode(tb, &tb->dev, 0);
|
tb->root_switch = tb_switch_alloc_safe_mode(tb, &tb->dev, 0);
|
||||||
else
|
else
|
||||||
tb->root_switch = tb_switch_alloc(tb, &tb->dev, 0);
|
tb->root_switch = tb_switch_alloc(tb, &tb->dev, 0);
|
||||||
if (!tb->root_switch)
|
if (IS_ERR(tb->root_switch))
|
||||||
return -ENODEV;
|
return PTR_ERR(tb->root_switch);
|
||||||
|
|
||||||
/*
|
/*
|
||||||
* NVM upgrade has not been tested on Apple systems and they
|
* NVM upgrade has not been tested on Apple systems and they
|
||||||
|
|
179
drivers/thunderbolt/lc.c
Normal file
179
drivers/thunderbolt/lc.c
Normal file
|
@ -0,0 +1,179 @@
|
||||||
|
// SPDX-License-Identifier: GPL-2.0
|
||||||
|
/*
|
||||||
|
* Thunderbolt link controller support
|
||||||
|
*
|
||||||
|
* Copyright (C) 2019, Intel Corporation
|
||||||
|
* Author: Mika Westerberg <mika.westerberg@linux.intel.com>
|
||||||
|
*/
|
||||||
|
|
||||||
|
#include "tb.h"
|
||||||
|
|
||||||
|
/**
|
||||||
|
* tb_lc_read_uuid() - Read switch UUID from link controller common register
|
||||||
|
* @sw: Switch whose UUID is read
|
||||||
|
* @uuid: UUID is placed here
|
||||||
|
*/
|
||||||
|
int tb_lc_read_uuid(struct tb_switch *sw, u32 *uuid)
|
||||||
|
{
|
||||||
|
if (!sw->cap_lc)
|
||||||
|
return -EINVAL;
|
||||||
|
return tb_sw_read(sw, uuid, TB_CFG_SWITCH, sw->cap_lc + TB_LC_FUSE, 4);
|
||||||
|
}
|
||||||
|
|
||||||
|
static int read_lc_desc(struct tb_switch *sw, u32 *desc)
|
||||||
|
{
|
||||||
|
if (!sw->cap_lc)
|
||||||
|
return -EINVAL;
|
||||||
|
return tb_sw_read(sw, desc, TB_CFG_SWITCH, sw->cap_lc + TB_LC_DESC, 1);
|
||||||
|
}
|
||||||
|
|
||||||
|
static int find_port_lc_cap(struct tb_port *port)
|
||||||
|
{
|
||||||
|
struct tb_switch *sw = port->sw;
|
||||||
|
int start, phys, ret, size;
|
||||||
|
u32 desc;
|
||||||
|
|
||||||
|
ret = read_lc_desc(sw, &desc);
|
||||||
|
if (ret)
|
||||||
|
return ret;
|
||||||
|
|
||||||
|
/* Start of port LC registers */
|
||||||
|
start = (desc & TB_LC_DESC_SIZE_MASK) >> TB_LC_DESC_SIZE_SHIFT;
|
||||||
|
size = (desc & TB_LC_DESC_PORT_SIZE_MASK) >> TB_LC_DESC_PORT_SIZE_SHIFT;
|
||||||
|
phys = tb_phy_port_from_link(port->port);
|
||||||
|
|
||||||
|
return sw->cap_lc + start + phys * size;
|
||||||
|
}
|
||||||
|
|
||||||
|
static int tb_lc_configure_lane(struct tb_port *port, bool configure)
|
||||||
|
{
|
||||||
|
bool upstream = tb_is_upstream_port(port);
|
||||||
|
struct tb_switch *sw = port->sw;
|
||||||
|
u32 ctrl, lane;
|
||||||
|
int cap, ret;
|
||||||
|
|
||||||
|
if (sw->generation < 2)
|
||||||
|
return 0;
|
||||||
|
|
||||||
|
cap = find_port_lc_cap(port);
|
||||||
|
if (cap < 0)
|
||||||
|
return cap;
|
||||||
|
|
||||||
|
ret = tb_sw_read(sw, &ctrl, TB_CFG_SWITCH, cap + TB_LC_SX_CTRL, 1);
|
||||||
|
if (ret)
|
||||||
|
return ret;
|
||||||
|
|
||||||
|
/* Resolve correct lane */
|
||||||
|
if (port->port % 2)
|
||||||
|
lane = TB_LC_SX_CTRL_L1C;
|
||||||
|
else
|
||||||
|
lane = TB_LC_SX_CTRL_L2C;
|
||||||
|
|
||||||
|
if (configure) {
|
||||||
|
ctrl |= lane;
|
||||||
|
if (upstream)
|
||||||
|
ctrl |= TB_LC_SX_CTRL_UPSTREAM;
|
||||||
|
} else {
|
||||||
|
ctrl &= ~lane;
|
||||||
|
if (upstream)
|
||||||
|
ctrl &= ~TB_LC_SX_CTRL_UPSTREAM;
|
||||||
|
}
|
||||||
|
|
||||||
|
return tb_sw_write(sw, &ctrl, TB_CFG_SWITCH, cap + TB_LC_SX_CTRL, 1);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* tb_lc_configure_link() - Let LC know about configured link
|
||||||
|
* @sw: Switch that is being added
|
||||||
|
*
|
||||||
|
* Informs LC of both parent switch and @sw that there is established
|
||||||
|
* link between the two.
|
||||||
|
*/
|
||||||
|
int tb_lc_configure_link(struct tb_switch *sw)
|
||||||
|
{
|
||||||
|
struct tb_port *up, *down;
|
||||||
|
int ret;
|
||||||
|
|
||||||
|
if (!sw->config.enabled || !tb_route(sw))
|
||||||
|
return 0;
|
||||||
|
|
||||||
|
up = tb_upstream_port(sw);
|
||||||
|
down = tb_port_at(tb_route(sw), tb_to_switch(sw->dev.parent));
|
||||||
|
|
||||||
|
/* Configure parent link toward this switch */
|
||||||
|
ret = tb_lc_configure_lane(down, true);
|
||||||
|
if (ret)
|
||||||
|
return ret;
|
||||||
|
|
||||||
|
/* Configure upstream link from this switch to the parent */
|
||||||
|
ret = tb_lc_configure_lane(up, true);
|
||||||
|
if (ret)
|
||||||
|
tb_lc_configure_lane(down, false);
|
||||||
|
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* tb_lc_unconfigure_link() - Let LC know about unconfigured link
|
||||||
|
* @sw: Switch to unconfigure
|
||||||
|
*
|
||||||
|
* Informs LC of both parent switch and @sw that the link between the
|
||||||
|
* two does not exist anymore.
|
||||||
|
*/
|
||||||
|
void tb_lc_unconfigure_link(struct tb_switch *sw)
|
||||||
|
{
|
||||||
|
struct tb_port *up, *down;
|
||||||
|
|
||||||
|
if (sw->is_unplugged || !sw->config.enabled || !tb_route(sw))
|
||||||
|
return;
|
||||||
|
|
||||||
|
up = tb_upstream_port(sw);
|
||||||
|
down = tb_port_at(tb_route(sw), tb_to_switch(sw->dev.parent));
|
||||||
|
|
||||||
|
tb_lc_configure_lane(up, false);
|
||||||
|
tb_lc_configure_lane(down, false);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* tb_lc_set_sleep() - Inform LC that the switch is going to sleep
|
||||||
|
* @sw: Switch to set sleep
|
||||||
|
*
|
||||||
|
* Let the switch link controllers know that the switch is going to
|
||||||
|
* sleep.
|
||||||
|
*/
|
||||||
|
int tb_lc_set_sleep(struct tb_switch *sw)
|
||||||
|
{
|
||||||
|
int start, size, nlc, ret, i;
|
||||||
|
u32 desc;
|
||||||
|
|
||||||
|
if (sw->generation < 2)
|
||||||
|
return 0;
|
||||||
|
|
||||||
|
ret = read_lc_desc(sw, &desc);
|
||||||
|
if (ret)
|
||||||
|
return ret;
|
||||||
|
|
||||||
|
/* Figure out number of link controllers */
|
||||||
|
nlc = desc & TB_LC_DESC_NLC_MASK;
|
||||||
|
start = (desc & TB_LC_DESC_SIZE_MASK) >> TB_LC_DESC_SIZE_SHIFT;
|
||||||
|
size = (desc & TB_LC_DESC_PORT_SIZE_MASK) >> TB_LC_DESC_PORT_SIZE_SHIFT;
|
||||||
|
|
||||||
|
/* For each link controller set sleep bit */
|
||||||
|
for (i = 0; i < nlc; i++) {
|
||||||
|
unsigned int offset = sw->cap_lc + start + i * size;
|
||||||
|
u32 ctrl;
|
||||||
|
|
||||||
|
ret = tb_sw_read(sw, &ctrl, TB_CFG_SWITCH,
|
||||||
|
offset + TB_LC_SX_CTRL, 1);
|
||||||
|
if (ret)
|
||||||
|
return ret;
|
||||||
|
|
||||||
|
ctrl |= TB_LC_SX_CTRL_SLP;
|
||||||
|
ret = tb_sw_write(sw, &ctrl, TB_CFG_SWITCH,
|
||||||
|
offset + TB_LC_SX_CTRL, 1);
|
||||||
|
if (ret)
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
|
||||||
|
return 0;
|
||||||
|
}
|
|
@ -27,8 +27,7 @@
|
||||||
* use this ring for anything else.
|
* use this ring for anything else.
|
||||||
*/
|
*/
|
||||||
#define RING_E2E_UNUSED_HOPID 2
|
#define RING_E2E_UNUSED_HOPID 2
|
||||||
/* HopIDs 0-7 are reserved by the Thunderbolt protocol */
|
#define RING_FIRST_USABLE_HOPID TB_PATH_MIN_HOPID
|
||||||
#define RING_FIRST_USABLE_HOPID 8
|
|
||||||
|
|
||||||
/*
|
/*
|
||||||
* Minimal number of vectors when we use MSI-X. Two for control channel
|
* Minimal number of vectors when we use MSI-X. Two for control channel
|
||||||
|
|
|
@ -1,62 +1,330 @@
|
||||||
// SPDX-License-Identifier: GPL-2.0
|
// SPDX-License-Identifier: GPL-2.0
|
||||||
/*
|
/*
|
||||||
* Thunderbolt Cactus Ridge driver - path/tunnel functionality
|
* Thunderbolt driver - path/tunnel functionality
|
||||||
*
|
*
|
||||||
* Copyright (c) 2014 Andreas Noever <andreas.noever@gmail.com>
|
* Copyright (c) 2014 Andreas Noever <andreas.noever@gmail.com>
|
||||||
|
* Copyright (C) 2019, Intel Corporation
|
||||||
*/
|
*/
|
||||||
|
|
||||||
#include <linux/slab.h>
|
#include <linux/slab.h>
|
||||||
#include <linux/errno.h>
|
#include <linux/errno.h>
|
||||||
|
#include <linux/delay.h>
|
||||||
|
#include <linux/ktime.h>
|
||||||
|
|
||||||
#include "tb.h"
|
#include "tb.h"
|
||||||
|
|
||||||
|
static void tb_dump_hop(const struct tb_path_hop *hop, const struct tb_regs_hop *regs)
|
||||||
static void tb_dump_hop(struct tb_port *port, struct tb_regs_hop *hop)
|
|
||||||
{
|
{
|
||||||
tb_port_dbg(port, " Hop through port %d to hop %d (%s)\n",
|
const struct tb_port *port = hop->in_port;
|
||||||
hop->out_port, hop->next_hop,
|
|
||||||
hop->enable ? "enabled" : "disabled");
|
tb_port_dbg(port, " In HopID: %d => Out port: %d Out HopID: %d\n",
|
||||||
|
hop->in_hop_index, regs->out_port, regs->next_hop);
|
||||||
tb_port_dbg(port, " Weight: %d Priority: %d Credits: %d Drop: %d\n",
|
tb_port_dbg(port, " Weight: %d Priority: %d Credits: %d Drop: %d\n",
|
||||||
hop->weight, hop->priority,
|
regs->weight, regs->priority,
|
||||||
hop->initial_credits, hop->drop_packages);
|
regs->initial_credits, regs->drop_packages);
|
||||||
tb_port_dbg(port, " Counter enabled: %d Counter index: %d\n",
|
tb_port_dbg(port, " Counter enabled: %d Counter index: %d\n",
|
||||||
hop->counter_enable, hop->counter);
|
regs->counter_enable, regs->counter);
|
||||||
tb_port_dbg(port, " Flow Control (In/Eg): %d/%d Shared Buffer (In/Eg): %d/%d\n",
|
tb_port_dbg(port, " Flow Control (In/Eg): %d/%d Shared Buffer (In/Eg): %d/%d\n",
|
||||||
hop->ingress_fc, hop->egress_fc,
|
regs->ingress_fc, regs->egress_fc,
|
||||||
hop->ingress_shared_buffer, hop->egress_shared_buffer);
|
regs->ingress_shared_buffer, regs->egress_shared_buffer);
|
||||||
tb_port_dbg(port, " Unknown1: %#x Unknown2: %#x Unknown3: %#x\n",
|
tb_port_dbg(port, " Unknown1: %#x Unknown2: %#x Unknown3: %#x\n",
|
||||||
hop->unknown1, hop->unknown2, hop->unknown3);
|
regs->unknown1, regs->unknown2, regs->unknown3);
|
||||||
|
}
|
||||||
|
|
||||||
|
static struct tb_port *tb_path_find_dst_port(struct tb_port *src, int src_hopid,
|
||||||
|
int dst_hopid)
|
||||||
|
{
|
||||||
|
struct tb_port *port, *out_port = NULL;
|
||||||
|
struct tb_regs_hop hop;
|
||||||
|
struct tb_switch *sw;
|
||||||
|
int i, ret, hopid;
|
||||||
|
|
||||||
|
hopid = src_hopid;
|
||||||
|
port = src;
|
||||||
|
|
||||||
|
for (i = 0; port && i < TB_PATH_MAX_HOPS; i++) {
|
||||||
|
sw = port->sw;
|
||||||
|
|
||||||
|
ret = tb_port_read(port, &hop, TB_CFG_HOPS, 2 * hopid, 2);
|
||||||
|
if (ret) {
|
||||||
|
tb_port_warn(port, "failed to read path at %d\n", hopid);
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!hop.enable)
|
||||||
|
return NULL;
|
||||||
|
|
||||||
|
out_port = &sw->ports[hop.out_port];
|
||||||
|
hopid = hop.next_hop;
|
||||||
|
port = out_port->remote;
|
||||||
|
}
|
||||||
|
|
||||||
|
return out_port && hopid == dst_hopid ? out_port : NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
static int tb_path_find_src_hopid(struct tb_port *src,
|
||||||
|
const struct tb_port *dst, int dst_hopid)
|
||||||
|
{
|
||||||
|
struct tb_port *out;
|
||||||
|
int i;
|
||||||
|
|
||||||
|
for (i = TB_PATH_MIN_HOPID; i <= src->config.max_in_hop_id; i++) {
|
||||||
|
out = tb_path_find_dst_port(src, i, dst_hopid);
|
||||||
|
if (out == dst)
|
||||||
|
return i;
|
||||||
|
}
|
||||||
|
|
||||||
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* tb_path_alloc() - allocate a thunderbolt path
|
* tb_path_discover() - Discover a path
|
||||||
|
* @src: First input port of a path
|
||||||
|
* @src_hopid: Starting HopID of a path (%-1 if don't care)
|
||||||
|
* @dst: Expected destination port of the path (%NULL if don't care)
|
||||||
|
* @dst_hopid: HopID to the @dst (%-1 if don't care)
|
||||||
|
* @last: Last port is filled here if not %NULL
|
||||||
|
* @name: Name of the path
|
||||||
*
|
*
|
||||||
* Return: Returns a tb_path on success or NULL on failure.
|
* Follows a path starting from @src and @src_hopid to the last output
|
||||||
|
* port of the path. Allocates HopIDs for the visited ports. Call
|
||||||
|
* tb_path_free() to release the path and allocated HopIDs when the path
|
||||||
|
* is not needed anymore.
|
||||||
|
*
|
||||||
|
* Note function discovers also incomplete paths so caller should check
|
||||||
|
* that the @dst port is the expected one. If it is not, the path can be
|
||||||
|
* cleaned up by calling tb_path_deactivate() before tb_path_free().
|
||||||
|
*
|
||||||
|
* Return: Discovered path on success, %NULL in case of failure
|
||||||
*/
|
*/
|
||||||
struct tb_path *tb_path_alloc(struct tb *tb, int num_hops)
|
struct tb_path *tb_path_discover(struct tb_port *src, int src_hopid,
|
||||||
|
struct tb_port *dst, int dst_hopid,
|
||||||
|
struct tb_port **last, const char *name)
|
||||||
{
|
{
|
||||||
struct tb_path *path = kzalloc(sizeof(*path), GFP_KERNEL);
|
struct tb_port *out_port;
|
||||||
|
struct tb_regs_hop hop;
|
||||||
|
struct tb_path *path;
|
||||||
|
struct tb_switch *sw;
|
||||||
|
struct tb_port *p;
|
||||||
|
size_t num_hops;
|
||||||
|
int ret, i, h;
|
||||||
|
|
||||||
|
if (src_hopid < 0 && dst) {
|
||||||
|
/*
|
||||||
|
* For incomplete paths the intermediate HopID can be
|
||||||
|
* different from the one used by the protocol adapter
|
||||||
|
* so in that case find a path that ends on @dst with
|
||||||
|
* matching @dst_hopid. That should give us the correct
|
||||||
|
* HopID for the @src.
|
||||||
|
*/
|
||||||
|
src_hopid = tb_path_find_src_hopid(src, dst, dst_hopid);
|
||||||
|
if (!src_hopid)
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
p = src;
|
||||||
|
h = src_hopid;
|
||||||
|
num_hops = 0;
|
||||||
|
|
||||||
|
for (i = 0; p && i < TB_PATH_MAX_HOPS; i++) {
|
||||||
|
sw = p->sw;
|
||||||
|
|
||||||
|
ret = tb_port_read(p, &hop, TB_CFG_HOPS, 2 * h, 2);
|
||||||
|
if (ret) {
|
||||||
|
tb_port_warn(p, "failed to read path at %d\n", h);
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* If the hop is not enabled we got an incomplete path */
|
||||||
|
if (!hop.enable)
|
||||||
|
break;
|
||||||
|
|
||||||
|
out_port = &sw->ports[hop.out_port];
|
||||||
|
if (last)
|
||||||
|
*last = out_port;
|
||||||
|
|
||||||
|
h = hop.next_hop;
|
||||||
|
p = out_port->remote;
|
||||||
|
num_hops++;
|
||||||
|
}
|
||||||
|
|
||||||
|
path = kzalloc(sizeof(*path), GFP_KERNEL);
|
||||||
if (!path)
|
if (!path)
|
||||||
return NULL;
|
return NULL;
|
||||||
|
|
||||||
|
path->name = name;
|
||||||
|
path->tb = src->sw->tb;
|
||||||
|
path->path_length = num_hops;
|
||||||
|
path->activated = true;
|
||||||
|
|
||||||
path->hops = kcalloc(num_hops, sizeof(*path->hops), GFP_KERNEL);
|
path->hops = kcalloc(num_hops, sizeof(*path->hops), GFP_KERNEL);
|
||||||
if (!path->hops) {
|
if (!path->hops) {
|
||||||
kfree(path);
|
kfree(path);
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
path->tb = tb;
|
|
||||||
path->path_length = num_hops;
|
p = src;
|
||||||
|
h = src_hopid;
|
||||||
|
|
||||||
|
for (i = 0; i < num_hops; i++) {
|
||||||
|
int next_hop;
|
||||||
|
|
||||||
|
sw = p->sw;
|
||||||
|
|
||||||
|
ret = tb_port_read(p, &hop, TB_CFG_HOPS, 2 * h, 2);
|
||||||
|
if (ret) {
|
||||||
|
tb_port_warn(p, "failed to read path at %d\n", h);
|
||||||
|
goto err;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (tb_port_alloc_in_hopid(p, h, h) < 0)
|
||||||
|
goto err;
|
||||||
|
|
||||||
|
out_port = &sw->ports[hop.out_port];
|
||||||
|
next_hop = hop.next_hop;
|
||||||
|
|
||||||
|
if (tb_port_alloc_out_hopid(out_port, next_hop, next_hop) < 0) {
|
||||||
|
tb_port_release_in_hopid(p, h);
|
||||||
|
goto err;
|
||||||
|
}
|
||||||
|
|
||||||
|
path->hops[i].in_port = p;
|
||||||
|
path->hops[i].in_hop_index = h;
|
||||||
|
path->hops[i].in_counter_index = -1;
|
||||||
|
path->hops[i].out_port = out_port;
|
||||||
|
path->hops[i].next_hop_index = next_hop;
|
||||||
|
|
||||||
|
h = next_hop;
|
||||||
|
p = out_port->remote;
|
||||||
|
}
|
||||||
|
|
||||||
return path;
|
return path;
|
||||||
|
|
||||||
|
err:
|
||||||
|
tb_port_warn(src, "failed to discover path starting at HopID %d\n",
|
||||||
|
src_hopid);
|
||||||
|
tb_path_free(path);
|
||||||
|
return NULL;
|
||||||
}
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* tb_path_free() - free a deactivated path
|
* tb_path_alloc() - allocate a thunderbolt path between two ports
|
||||||
|
* @tb: Domain pointer
|
||||||
|
* @src: Source port of the path
|
||||||
|
* @src_hopid: HopID used for the first ingress port in the path
|
||||||
|
* @dst: Destination port of the path
|
||||||
|
* @dst_hopid: HopID used for the last egress port in the path
|
||||||
|
* @link_nr: Preferred link if there are dual links on the path
|
||||||
|
* @name: Name of the path
|
||||||
|
*
|
||||||
|
* Creates path between two ports starting with given @src_hopid. Reserves
|
||||||
|
* HopIDs for each port (they can be different from @src_hopid depending on
|
||||||
|
* how many HopIDs each port already have reserved). If there are dual
|
||||||
|
* links on the path, prioritizes using @link_nr.
|
||||||
|
*
|
||||||
|
* Return: Returns a tb_path on success or NULL on failure.
|
||||||
|
*/
|
||||||
|
struct tb_path *tb_path_alloc(struct tb *tb, struct tb_port *src, int src_hopid,
|
||||||
|
struct tb_port *dst, int dst_hopid, int link_nr,
|
||||||
|
const char *name)
|
||||||
|
{
|
||||||
|
struct tb_port *in_port, *out_port;
|
||||||
|
int in_hopid, out_hopid;
|
||||||
|
struct tb_path *path;
|
||||||
|
size_t num_hops;
|
||||||
|
int i, ret;
|
||||||
|
|
||||||
|
path = kzalloc(sizeof(*path), GFP_KERNEL);
|
||||||
|
if (!path)
|
||||||
|
return NULL;
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Number of hops on a path is the distance between the two
|
||||||
|
* switches plus the source adapter port.
|
||||||
|
*/
|
||||||
|
num_hops = abs(tb_route_length(tb_route(src->sw)) -
|
||||||
|
tb_route_length(tb_route(dst->sw))) + 1;
|
||||||
|
|
||||||
|
path->hops = kcalloc(num_hops, sizeof(*path->hops), GFP_KERNEL);
|
||||||
|
if (!path->hops) {
|
||||||
|
kfree(path);
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
in_hopid = src_hopid;
|
||||||
|
out_port = NULL;
|
||||||
|
|
||||||
|
for (i = 0; i < num_hops; i++) {
|
||||||
|
in_port = tb_next_port_on_path(src, dst, out_port);
|
||||||
|
if (!in_port)
|
||||||
|
goto err;
|
||||||
|
|
||||||
|
if (in_port->dual_link_port && in_port->link_nr != link_nr)
|
||||||
|
in_port = in_port->dual_link_port;
|
||||||
|
|
||||||
|
ret = tb_port_alloc_in_hopid(in_port, in_hopid, in_hopid);
|
||||||
|
if (ret < 0)
|
||||||
|
goto err;
|
||||||
|
in_hopid = ret;
|
||||||
|
|
||||||
|
out_port = tb_next_port_on_path(src, dst, in_port);
|
||||||
|
if (!out_port)
|
||||||
|
goto err;
|
||||||
|
|
||||||
|
if (out_port->dual_link_port && out_port->link_nr != link_nr)
|
||||||
|
out_port = out_port->dual_link_port;
|
||||||
|
|
||||||
|
if (i == num_hops - 1)
|
||||||
|
ret = tb_port_alloc_out_hopid(out_port, dst_hopid,
|
||||||
|
dst_hopid);
|
||||||
|
else
|
||||||
|
ret = tb_port_alloc_out_hopid(out_port, -1, -1);
|
||||||
|
|
||||||
|
if (ret < 0)
|
||||||
|
goto err;
|
||||||
|
out_hopid = ret;
|
||||||
|
|
||||||
|
path->hops[i].in_hop_index = in_hopid;
|
||||||
|
path->hops[i].in_port = in_port;
|
||||||
|
path->hops[i].in_counter_index = -1;
|
||||||
|
path->hops[i].out_port = out_port;
|
||||||
|
path->hops[i].next_hop_index = out_hopid;
|
||||||
|
|
||||||
|
in_hopid = out_hopid;
|
||||||
|
}
|
||||||
|
|
||||||
|
path->tb = tb;
|
||||||
|
path->path_length = num_hops;
|
||||||
|
path->name = name;
|
||||||
|
|
||||||
|
return path;
|
||||||
|
|
||||||
|
err:
|
||||||
|
tb_path_free(path);
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* tb_path_free() - free a path
|
||||||
|
* @path: Path to free
|
||||||
|
*
|
||||||
|
* Frees a path. The path does not need to be deactivated.
|
||||||
*/
|
*/
|
||||||
void tb_path_free(struct tb_path *path)
|
void tb_path_free(struct tb_path *path)
|
||||||
{
|
{
|
||||||
if (path->activated) {
|
int i;
|
||||||
tb_WARN(path->tb, "trying to free an activated path\n")
|
|
||||||
return;
|
for (i = 0; i < path->path_length; i++) {
|
||||||
|
const struct tb_path_hop *hop = &path->hops[i];
|
||||||
|
|
||||||
|
if (hop->in_port)
|
||||||
|
tb_port_release_in_hopid(hop->in_port,
|
||||||
|
hop->in_hop_index);
|
||||||
|
if (hop->out_port)
|
||||||
|
tb_port_release_out_hopid(hop->out_port,
|
||||||
|
hop->next_hop_index);
|
||||||
}
|
}
|
||||||
|
|
||||||
kfree(path->hops);
|
kfree(path->hops);
|
||||||
kfree(path);
|
kfree(path);
|
||||||
}
|
}
|
||||||
|
@ -74,14 +342,65 @@ static void __tb_path_deallocate_nfc(struct tb_path *path, int first_hop)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
static int __tb_path_deactivate_hop(struct tb_port *port, int hop_index,
|
||||||
|
bool clear_fc)
|
||||||
|
{
|
||||||
|
struct tb_regs_hop hop;
|
||||||
|
ktime_t timeout;
|
||||||
|
int ret;
|
||||||
|
|
||||||
|
/* Disable the path */
|
||||||
|
ret = tb_port_read(port, &hop, TB_CFG_HOPS, 2 * hop_index, 2);
|
||||||
|
if (ret)
|
||||||
|
return ret;
|
||||||
|
|
||||||
|
/* Already disabled */
|
||||||
|
if (!hop.enable)
|
||||||
|
return 0;
|
||||||
|
|
||||||
|
hop.enable = 0;
|
||||||
|
|
||||||
|
ret = tb_port_write(port, &hop, TB_CFG_HOPS, 2 * hop_index, 2);
|
||||||
|
if (ret)
|
||||||
|
return ret;
|
||||||
|
|
||||||
|
/* Wait until it is drained */
|
||||||
|
timeout = ktime_add_ms(ktime_get(), 500);
|
||||||
|
do {
|
||||||
|
ret = tb_port_read(port, &hop, TB_CFG_HOPS, 2 * hop_index, 2);
|
||||||
|
if (ret)
|
||||||
|
return ret;
|
||||||
|
|
||||||
|
if (!hop.pending) {
|
||||||
|
if (clear_fc) {
|
||||||
|
/* Clear flow control */
|
||||||
|
hop.ingress_fc = 0;
|
||||||
|
hop.egress_fc = 0;
|
||||||
|
hop.ingress_shared_buffer = 0;
|
||||||
|
hop.egress_shared_buffer = 0;
|
||||||
|
|
||||||
|
return tb_port_write(port, &hop, TB_CFG_HOPS,
|
||||||
|
2 * hop_index, 2);
|
||||||
|
}
|
||||||
|
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
usleep_range(10, 20);
|
||||||
|
} while (ktime_before(ktime_get(), timeout));
|
||||||
|
|
||||||
|
return -ETIMEDOUT;
|
||||||
|
}
|
||||||
|
|
||||||
static void __tb_path_deactivate_hops(struct tb_path *path, int first_hop)
|
static void __tb_path_deactivate_hops(struct tb_path *path, int first_hop)
|
||||||
{
|
{
|
||||||
int i, res;
|
int i, res;
|
||||||
struct tb_regs_hop hop = { };
|
|
||||||
for (i = first_hop; i < path->path_length; i++) {
|
for (i = first_hop; i < path->path_length; i++) {
|
||||||
res = tb_port_write(path->hops[i].in_port, &hop, TB_CFG_HOPS,
|
res = __tb_path_deactivate_hop(path->hops[i].in_port,
|
||||||
2 * path->hops[i].in_hop_index, 2);
|
path->hops[i].in_hop_index,
|
||||||
if (res)
|
path->clear_fc);
|
||||||
|
if (res && res != -ENODEV)
|
||||||
tb_port_warn(path->hops[i].in_port,
|
tb_port_warn(path->hops[i].in_port,
|
||||||
"hop deactivation failed for hop %d, index %d\n",
|
"hop deactivation failed for hop %d, index %d\n",
|
||||||
i, path->hops[i].in_hop_index);
|
i, path->hops[i].in_hop_index);
|
||||||
|
@ -94,9 +413,9 @@ void tb_path_deactivate(struct tb_path *path)
|
||||||
tb_WARN(path->tb, "trying to deactivate an inactive path\n");
|
tb_WARN(path->tb, "trying to deactivate an inactive path\n");
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
tb_info(path->tb,
|
tb_dbg(path->tb,
|
||||||
"deactivating path from %llx:%x to %llx:%x\n",
|
"deactivating %s path from %llx:%x to %llx:%x\n",
|
||||||
tb_route(path->hops[0].in_port->sw),
|
path->name, tb_route(path->hops[0].in_port->sw),
|
||||||
path->hops[0].in_port->port,
|
path->hops[0].in_port->port,
|
||||||
tb_route(path->hops[path->path_length - 1].out_port->sw),
|
tb_route(path->hops[path->path_length - 1].out_port->sw),
|
||||||
path->hops[path->path_length - 1].out_port->port);
|
path->hops[path->path_length - 1].out_port->port);
|
||||||
|
@ -122,9 +441,9 @@ int tb_path_activate(struct tb_path *path)
|
||||||
return -EINVAL;
|
return -EINVAL;
|
||||||
}
|
}
|
||||||
|
|
||||||
tb_info(path->tb,
|
tb_dbg(path->tb,
|
||||||
"activating path from %llx:%x to %llx:%x\n",
|
"activating %s path from %llx:%x to %llx:%x\n",
|
||||||
tb_route(path->hops[0].in_port->sw),
|
path->name, tb_route(path->hops[0].in_port->sw),
|
||||||
path->hops[0].in_port->port,
|
path->hops[0].in_port->port,
|
||||||
tb_route(path->hops[path->path_length - 1].out_port->sw),
|
tb_route(path->hops[path->path_length - 1].out_port->sw),
|
||||||
path->hops[path->path_length - 1].out_port->port);
|
path->hops[path->path_length - 1].out_port->port);
|
||||||
|
@ -153,30 +472,14 @@ int tb_path_activate(struct tb_path *path)
|
||||||
for (i = path->path_length - 1; i >= 0; i--) {
|
for (i = path->path_length - 1; i >= 0; i--) {
|
||||||
struct tb_regs_hop hop = { 0 };
|
struct tb_regs_hop hop = { 0 };
|
||||||
|
|
||||||
/*
|
/* If it is left active deactivate it first */
|
||||||
* We do (currently) not tear down paths setup by the firmeware.
|
__tb_path_deactivate_hop(path->hops[i].in_port,
|
||||||
* If a firmware device is unplugged and plugged in again then
|
path->hops[i].in_hop_index, path->clear_fc);
|
||||||
* it can happen that we reuse some of the hops from the (now
|
|
||||||
* defunct) firmeware path. This causes the hotplug operation to
|
|
||||||
* fail (the pci device does not show up). Clearing the hop
|
|
||||||
* before overwriting it fixes the problem.
|
|
||||||
*
|
|
||||||
* Should be removed once we discover and tear down firmeware
|
|
||||||
* paths.
|
|
||||||
*/
|
|
||||||
res = tb_port_write(path->hops[i].in_port, &hop, TB_CFG_HOPS,
|
|
||||||
2 * path->hops[i].in_hop_index, 2);
|
|
||||||
if (res) {
|
|
||||||
__tb_path_deactivate_hops(path, i);
|
|
||||||
__tb_path_deallocate_nfc(path, 0);
|
|
||||||
goto err;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* dword 0 */
|
/* dword 0 */
|
||||||
hop.next_hop = path->hops[i].next_hop_index;
|
hop.next_hop = path->hops[i].next_hop_index;
|
||||||
hop.out_port = path->hops[i].out_port->port;
|
hop.out_port = path->hops[i].out_port->port;
|
||||||
/* TODO: figure out why these are good values */
|
hop.initial_credits = path->hops[i].initial_credits;
|
||||||
hop.initial_credits = (i == path->path_length - 1) ? 16 : 7;
|
|
||||||
hop.unknown1 = 0;
|
hop.unknown1 = 0;
|
||||||
hop.enable = 1;
|
hop.enable = 1;
|
||||||
|
|
||||||
|
@ -198,9 +501,8 @@ int tb_path_activate(struct tb_path *path)
|
||||||
& out_mask;
|
& out_mask;
|
||||||
hop.unknown3 = 0;
|
hop.unknown3 = 0;
|
||||||
|
|
||||||
tb_port_info(path->hops[i].in_port, "Writing hop %d, index %d",
|
tb_port_dbg(path->hops[i].in_port, "Writing hop %d\n", i);
|
||||||
i, path->hops[i].in_hop_index);
|
tb_dump_hop(&path->hops[i], &hop);
|
||||||
tb_dump_hop(path->hops[i].in_port, &hop);
|
|
||||||
res = tb_port_write(path->hops[i].in_port, &hop, TB_CFG_HOPS,
|
res = tb_port_write(path->hops[i].in_port, &hop, TB_CFG_HOPS,
|
||||||
2 * path->hops[i].in_hop_index, 2);
|
2 * path->hops[i].in_hop_index, 2);
|
||||||
if (res) {
|
if (res) {
|
||||||
|
@ -210,7 +512,7 @@ int tb_path_activate(struct tb_path *path)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
path->activated = true;
|
path->activated = true;
|
||||||
tb_info(path->tb, "path activation complete\n");
|
tb_dbg(path->tb, "path activation complete\n");
|
||||||
return 0;
|
return 0;
|
||||||
err:
|
err:
|
||||||
tb_WARN(path->tb, "path activation failed\n");
|
tb_WARN(path->tb, "path activation failed\n");
|
||||||
|
|
|
@ -176,6 +176,10 @@ static struct tb_property_dir *__tb_property_parse_dir(const u32 *block,
|
||||||
} else {
|
} else {
|
||||||
dir->uuid = kmemdup(&block[dir_offset], sizeof(*dir->uuid),
|
dir->uuid = kmemdup(&block[dir_offset], sizeof(*dir->uuid),
|
||||||
GFP_KERNEL);
|
GFP_KERNEL);
|
||||||
|
if (!dir->uuid) {
|
||||||
|
tb_property_free_dir(dir);
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
content_offset = dir_offset + 4;
|
content_offset = dir_offset + 4;
|
||||||
content_len = dir_len - 4; /* Length includes UUID */
|
content_len = dir_len - 4; /* Length includes UUID */
|
||||||
}
|
}
|
||||||
|
@ -548,6 +552,11 @@ int tb_property_add_data(struct tb_property_dir *parent, const char *key,
|
||||||
|
|
||||||
property->length = size / 4;
|
property->length = size / 4;
|
||||||
property->value.data = kzalloc(size, GFP_KERNEL);
|
property->value.data = kzalloc(size, GFP_KERNEL);
|
||||||
|
if (!property->value.data) {
|
||||||
|
kfree(property);
|
||||||
|
return -ENOMEM;
|
||||||
|
}
|
||||||
|
|
||||||
memcpy(property->value.data, buf, buflen);
|
memcpy(property->value.data, buf, buflen);
|
||||||
|
|
||||||
list_add_tail(&property->list, &parent->properties);
|
list_add_tail(&property->list, &parent->properties);
|
||||||
|
@ -578,7 +587,12 @@ int tb_property_add_text(struct tb_property_dir *parent, const char *key,
|
||||||
return -ENOMEM;
|
return -ENOMEM;
|
||||||
|
|
||||||
property->length = size / 4;
|
property->length = size / 4;
|
||||||
property->value.data = kzalloc(size, GFP_KERNEL);
|
property->value.text = kzalloc(size, GFP_KERNEL);
|
||||||
|
if (!property->value.text) {
|
||||||
|
kfree(property);
|
||||||
|
return -ENOMEM;
|
||||||
|
}
|
||||||
|
|
||||||
strcpy(property->value.text, text);
|
strcpy(property->value.text, text);
|
||||||
|
|
||||||
list_add_tail(&property->list, &parent->properties);
|
list_add_tail(&property->list, &parent->properties);
|
||||||
|
|
|
@ -10,15 +10,13 @@
|
||||||
#include <linux/idr.h>
|
#include <linux/idr.h>
|
||||||
#include <linux/nvmem-provider.h>
|
#include <linux/nvmem-provider.h>
|
||||||
#include <linux/pm_runtime.h>
|
#include <linux/pm_runtime.h>
|
||||||
|
#include <linux/sched/signal.h>
|
||||||
#include <linux/sizes.h>
|
#include <linux/sizes.h>
|
||||||
#include <linux/slab.h>
|
#include <linux/slab.h>
|
||||||
#include <linux/vmalloc.h>
|
#include <linux/vmalloc.h>
|
||||||
|
|
||||||
#include "tb.h"
|
#include "tb.h"
|
||||||
|
|
||||||
/* Switch authorization from userspace is serialized by this lock */
|
|
||||||
static DEFINE_MUTEX(switch_lock);
|
|
||||||
|
|
||||||
/* Switch NVM support */
|
/* Switch NVM support */
|
||||||
|
|
||||||
#define NVM_DEVID 0x05
|
#define NVM_DEVID 0x05
|
||||||
|
@ -254,8 +252,8 @@ static int tb_switch_nvm_write(void *priv, unsigned int offset, void *val,
|
||||||
struct tb_switch *sw = priv;
|
struct tb_switch *sw = priv;
|
||||||
int ret = 0;
|
int ret = 0;
|
||||||
|
|
||||||
if (mutex_lock_interruptible(&switch_lock))
|
if (!mutex_trylock(&sw->tb->lock))
|
||||||
return -ERESTARTSYS;
|
return restart_syscall();
|
||||||
|
|
||||||
/*
|
/*
|
||||||
* Since writing the NVM image might require some special steps,
|
* Since writing the NVM image might require some special steps,
|
||||||
|
@ -275,7 +273,7 @@ static int tb_switch_nvm_write(void *priv, unsigned int offset, void *val,
|
||||||
memcpy(sw->nvm->buf + offset, val, bytes);
|
memcpy(sw->nvm->buf + offset, val, bytes);
|
||||||
|
|
||||||
unlock:
|
unlock:
|
||||||
mutex_unlock(&switch_lock);
|
mutex_unlock(&sw->tb->lock);
|
||||||
|
|
||||||
return ret;
|
return ret;
|
||||||
}
|
}
|
||||||
|
@ -364,10 +362,7 @@ static int tb_switch_nvm_add(struct tb_switch *sw)
|
||||||
}
|
}
|
||||||
nvm->non_active = nvm_dev;
|
nvm->non_active = nvm_dev;
|
||||||
|
|
||||||
mutex_lock(&switch_lock);
|
|
||||||
sw->nvm = nvm;
|
sw->nvm = nvm;
|
||||||
mutex_unlock(&switch_lock);
|
|
||||||
|
|
||||||
return 0;
|
return 0;
|
||||||
|
|
||||||
err_nvm_active:
|
err_nvm_active:
|
||||||
|
@ -384,10 +379,8 @@ static void tb_switch_nvm_remove(struct tb_switch *sw)
|
||||||
{
|
{
|
||||||
struct tb_switch_nvm *nvm;
|
struct tb_switch_nvm *nvm;
|
||||||
|
|
||||||
mutex_lock(&switch_lock);
|
|
||||||
nvm = sw->nvm;
|
nvm = sw->nvm;
|
||||||
sw->nvm = NULL;
|
sw->nvm = NULL;
|
||||||
mutex_unlock(&switch_lock);
|
|
||||||
|
|
||||||
if (!nvm)
|
if (!nvm)
|
||||||
return;
|
return;
|
||||||
|
@ -500,23 +493,22 @@ int tb_wait_for_port(struct tb_port *port, bool wait_if_unplugged)
|
||||||
if (state < 0)
|
if (state < 0)
|
||||||
return state;
|
return state;
|
||||||
if (state == TB_PORT_DISABLED) {
|
if (state == TB_PORT_DISABLED) {
|
||||||
tb_port_info(port, "is disabled (state: 0)\n");
|
tb_port_dbg(port, "is disabled (state: 0)\n");
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
if (state == TB_PORT_UNPLUGGED) {
|
if (state == TB_PORT_UNPLUGGED) {
|
||||||
if (wait_if_unplugged) {
|
if (wait_if_unplugged) {
|
||||||
/* used during resume */
|
/* used during resume */
|
||||||
tb_port_info(port,
|
tb_port_dbg(port,
|
||||||
"is unplugged (state: 7), retrying...\n");
|
"is unplugged (state: 7), retrying...\n");
|
||||||
msleep(100);
|
msleep(100);
|
||||||
continue;
|
continue;
|
||||||
}
|
}
|
||||||
tb_port_info(port, "is unplugged (state: 7)\n");
|
tb_port_dbg(port, "is unplugged (state: 7)\n");
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
if (state == TB_PORT_UP) {
|
if (state == TB_PORT_UP) {
|
||||||
tb_port_info(port,
|
tb_port_dbg(port, "is connected, link is up (state: 2)\n");
|
||||||
"is connected, link is up (state: 2)\n");
|
|
||||||
return 1;
|
return 1;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -524,7 +516,7 @@ int tb_wait_for_port(struct tb_port *port, bool wait_if_unplugged)
|
||||||
* After plug-in the state is TB_PORT_CONNECTING. Give it some
|
* After plug-in the state is TB_PORT_CONNECTING. Give it some
|
||||||
* time.
|
* time.
|
||||||
*/
|
*/
|
||||||
tb_port_info(port,
|
tb_port_dbg(port,
|
||||||
"is connected, link is not up (state: %d), retrying...\n",
|
"is connected, link is not up (state: %d), retrying...\n",
|
||||||
state);
|
state);
|
||||||
msleep(100);
|
msleep(100);
|
||||||
|
@ -544,18 +536,46 @@ int tb_wait_for_port(struct tb_port *port, bool wait_if_unplugged)
|
||||||
*/
|
*/
|
||||||
int tb_port_add_nfc_credits(struct tb_port *port, int credits)
|
int tb_port_add_nfc_credits(struct tb_port *port, int credits)
|
||||||
{
|
{
|
||||||
if (credits == 0)
|
u32 nfc_credits;
|
||||||
|
|
||||||
|
if (credits == 0 || port->sw->is_unplugged)
|
||||||
return 0;
|
return 0;
|
||||||
tb_port_info(port,
|
|
||||||
"adding %#x NFC credits (%#x -> %#x)",
|
nfc_credits = port->config.nfc_credits & TB_PORT_NFC_CREDITS_MASK;
|
||||||
credits,
|
nfc_credits += credits;
|
||||||
port->config.nfc_credits,
|
|
||||||
port->config.nfc_credits + credits);
|
tb_port_dbg(port, "adding %d NFC credits to %lu",
|
||||||
port->config.nfc_credits += credits;
|
credits, port->config.nfc_credits & TB_PORT_NFC_CREDITS_MASK);
|
||||||
|
|
||||||
|
port->config.nfc_credits &= ~TB_PORT_NFC_CREDITS_MASK;
|
||||||
|
port->config.nfc_credits |= nfc_credits;
|
||||||
|
|
||||||
return tb_port_write(port, &port->config.nfc_credits,
|
return tb_port_write(port, &port->config.nfc_credits,
|
||||||
TB_CFG_PORT, 4, 1);
|
TB_CFG_PORT, 4, 1);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* tb_port_set_initial_credits() - Set initial port link credits allocated
|
||||||
|
* @port: Port to set the initial credits
|
||||||
|
* @credits: Number of credits to to allocate
|
||||||
|
*
|
||||||
|
* Set initial credits value to be used for ingress shared buffering.
|
||||||
|
*/
|
||||||
|
int tb_port_set_initial_credits(struct tb_port *port, u32 credits)
|
||||||
|
{
|
||||||
|
u32 data;
|
||||||
|
int ret;
|
||||||
|
|
||||||
|
ret = tb_port_read(port, &data, TB_CFG_PORT, 5, 1);
|
||||||
|
if (ret)
|
||||||
|
return ret;
|
||||||
|
|
||||||
|
data &= ~TB_PORT_LCA_MASK;
|
||||||
|
data |= (credits << TB_PORT_LCA_SHIFT) & TB_PORT_LCA_MASK;
|
||||||
|
|
||||||
|
return tb_port_write(port, &data, TB_CFG_PORT, 5, 1);
|
||||||
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* tb_port_clear_counter() - clear a counter in TB_CFG_COUNTER
|
* tb_port_clear_counter() - clear a counter in TB_CFG_COUNTER
|
||||||
*
|
*
|
||||||
|
@ -564,7 +584,7 @@ int tb_port_add_nfc_credits(struct tb_port *port, int credits)
|
||||||
int tb_port_clear_counter(struct tb_port *port, int counter)
|
int tb_port_clear_counter(struct tb_port *port, int counter)
|
||||||
{
|
{
|
||||||
u32 zero[3] = { 0, 0, 0 };
|
u32 zero[3] = { 0, 0, 0 };
|
||||||
tb_port_info(port, "clearing counter %d\n", counter);
|
tb_port_dbg(port, "clearing counter %d\n", counter);
|
||||||
return tb_port_write(port, zero, TB_CFG_COUNTERS, 3 * counter, 3);
|
return tb_port_write(port, zero, TB_CFG_COUNTERS, 3 * counter, 3);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -593,15 +613,304 @@ static int tb_init_port(struct tb_port *port)
|
||||||
port->cap_phy = cap;
|
port->cap_phy = cap;
|
||||||
else
|
else
|
||||||
tb_port_WARN(port, "non switch port without a PHY\n");
|
tb_port_WARN(port, "non switch port without a PHY\n");
|
||||||
|
} else if (port->port != 0) {
|
||||||
|
cap = tb_port_find_cap(port, TB_PORT_CAP_ADAP);
|
||||||
|
if (cap > 0)
|
||||||
|
port->cap_adap = cap;
|
||||||
}
|
}
|
||||||
|
|
||||||
tb_dump_port(port->sw->tb, &port->config);
|
tb_dump_port(port->sw->tb, &port->config);
|
||||||
|
|
||||||
/* TODO: Read dual link port, DP port and more from EEPROM. */
|
/* Control port does not need HopID allocation */
|
||||||
|
if (port->port) {
|
||||||
|
ida_init(&port->in_hopids);
|
||||||
|
ida_init(&port->out_hopids);
|
||||||
|
}
|
||||||
|
|
||||||
return 0;
|
return 0;
|
||||||
|
|
||||||
}
|
}
|
||||||
|
|
||||||
|
static int tb_port_alloc_hopid(struct tb_port *port, bool in, int min_hopid,
|
||||||
|
int max_hopid)
|
||||||
|
{
|
||||||
|
int port_max_hopid;
|
||||||
|
struct ida *ida;
|
||||||
|
|
||||||
|
if (in) {
|
||||||
|
port_max_hopid = port->config.max_in_hop_id;
|
||||||
|
ida = &port->in_hopids;
|
||||||
|
} else {
|
||||||
|
port_max_hopid = port->config.max_out_hop_id;
|
||||||
|
ida = &port->out_hopids;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* HopIDs 0-7 are reserved */
|
||||||
|
if (min_hopid < TB_PATH_MIN_HOPID)
|
||||||
|
min_hopid = TB_PATH_MIN_HOPID;
|
||||||
|
|
||||||
|
if (max_hopid < 0 || max_hopid > port_max_hopid)
|
||||||
|
max_hopid = port_max_hopid;
|
||||||
|
|
||||||
|
return ida_simple_get(ida, min_hopid, max_hopid + 1, GFP_KERNEL);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* tb_port_alloc_in_hopid() - Allocate input HopID from port
|
||||||
|
* @port: Port to allocate HopID for
|
||||||
|
* @min_hopid: Minimum acceptable input HopID
|
||||||
|
* @max_hopid: Maximum acceptable input HopID
|
||||||
|
*
|
||||||
|
* Return: HopID between @min_hopid and @max_hopid or negative errno in
|
||||||
|
* case of error.
|
||||||
|
*/
|
||||||
|
int tb_port_alloc_in_hopid(struct tb_port *port, int min_hopid, int max_hopid)
|
||||||
|
{
|
||||||
|
return tb_port_alloc_hopid(port, true, min_hopid, max_hopid);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* tb_port_alloc_out_hopid() - Allocate output HopID from port
|
||||||
|
* @port: Port to allocate HopID for
|
||||||
|
* @min_hopid: Minimum acceptable output HopID
|
||||||
|
* @max_hopid: Maximum acceptable output HopID
|
||||||
|
*
|
||||||
|
* Return: HopID between @min_hopid and @max_hopid or negative errno in
|
||||||
|
* case of error.
|
||||||
|
*/
|
||||||
|
int tb_port_alloc_out_hopid(struct tb_port *port, int min_hopid, int max_hopid)
|
||||||
|
{
|
||||||
|
return tb_port_alloc_hopid(port, false, min_hopid, max_hopid);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* tb_port_release_in_hopid() - Release allocated input HopID from port
|
||||||
|
* @port: Port whose HopID to release
|
||||||
|
* @hopid: HopID to release
|
||||||
|
*/
|
||||||
|
void tb_port_release_in_hopid(struct tb_port *port, int hopid)
|
||||||
|
{
|
||||||
|
ida_simple_remove(&port->in_hopids, hopid);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* tb_port_release_out_hopid() - Release allocated output HopID from port
|
||||||
|
* @port: Port whose HopID to release
|
||||||
|
* @hopid: HopID to release
|
||||||
|
*/
|
||||||
|
void tb_port_release_out_hopid(struct tb_port *port, int hopid)
|
||||||
|
{
|
||||||
|
ida_simple_remove(&port->out_hopids, hopid);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* tb_next_port_on_path() - Return next port for given port on a path
|
||||||
|
* @start: Start port of the walk
|
||||||
|
* @end: End port of the walk
|
||||||
|
* @prev: Previous port (%NULL if this is the first)
|
||||||
|
*
|
||||||
|
* This function can be used to walk from one port to another if they
|
||||||
|
* are connected through zero or more switches. If the @prev is dual
|
||||||
|
* link port, the function follows that link and returns another end on
|
||||||
|
* that same link.
|
||||||
|
*
|
||||||
|
* If the @end port has been reached, return %NULL.
|
||||||
|
*
|
||||||
|
* Domain tb->lock must be held when this function is called.
|
||||||
|
*/
|
||||||
|
struct tb_port *tb_next_port_on_path(struct tb_port *start, struct tb_port *end,
|
||||||
|
struct tb_port *prev)
|
||||||
|
{
|
||||||
|
struct tb_port *next;
|
||||||
|
|
||||||
|
if (!prev)
|
||||||
|
return start;
|
||||||
|
|
||||||
|
if (prev->sw == end->sw) {
|
||||||
|
if (prev == end)
|
||||||
|
return NULL;
|
||||||
|
return end;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (start->sw->config.depth < end->sw->config.depth) {
|
||||||
|
if (prev->remote &&
|
||||||
|
prev->remote->sw->config.depth > prev->sw->config.depth)
|
||||||
|
next = prev->remote;
|
||||||
|
else
|
||||||
|
next = tb_port_at(tb_route(end->sw), prev->sw);
|
||||||
|
} else {
|
||||||
|
if (tb_is_upstream_port(prev)) {
|
||||||
|
next = prev->remote;
|
||||||
|
} else {
|
||||||
|
next = tb_upstream_port(prev->sw);
|
||||||
|
/*
|
||||||
|
* Keep the same link if prev and next are both
|
||||||
|
* dual link ports.
|
||||||
|
*/
|
||||||
|
if (next->dual_link_port &&
|
||||||
|
next->link_nr != prev->link_nr) {
|
||||||
|
next = next->dual_link_port;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return next;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* tb_port_is_enabled() - Is the adapter port enabled
|
||||||
|
* @port: Port to check
|
||||||
|
*/
|
||||||
|
bool tb_port_is_enabled(struct tb_port *port)
|
||||||
|
{
|
||||||
|
switch (port->config.type) {
|
||||||
|
case TB_TYPE_PCIE_UP:
|
||||||
|
case TB_TYPE_PCIE_DOWN:
|
||||||
|
return tb_pci_port_is_enabled(port);
|
||||||
|
|
||||||
|
case TB_TYPE_DP_HDMI_IN:
|
||||||
|
case TB_TYPE_DP_HDMI_OUT:
|
||||||
|
return tb_dp_port_is_enabled(port);
|
||||||
|
|
||||||
|
default:
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* tb_pci_port_is_enabled() - Is the PCIe adapter port enabled
|
||||||
|
* @port: PCIe port to check
|
||||||
|
*/
|
||||||
|
bool tb_pci_port_is_enabled(struct tb_port *port)
|
||||||
|
{
|
||||||
|
u32 data;
|
||||||
|
|
||||||
|
if (tb_port_read(port, &data, TB_CFG_PORT, port->cap_adap, 1))
|
||||||
|
return false;
|
||||||
|
|
||||||
|
return !!(data & TB_PCI_EN);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* tb_pci_port_enable() - Enable PCIe adapter port
|
||||||
|
* @port: PCIe port to enable
|
||||||
|
* @enable: Enable/disable the PCIe adapter
|
||||||
|
*/
|
||||||
|
int tb_pci_port_enable(struct tb_port *port, bool enable)
|
||||||
|
{
|
||||||
|
u32 word = enable ? TB_PCI_EN : 0x0;
|
||||||
|
if (!port->cap_adap)
|
||||||
|
return -ENXIO;
|
||||||
|
return tb_port_write(port, &word, TB_CFG_PORT, port->cap_adap, 1);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* tb_dp_port_hpd_is_active() - Is HPD already active
|
||||||
|
* @port: DP out port to check
|
||||||
|
*
|
||||||
|
* Checks if the DP OUT adapter port has HDP bit already set.
|
||||||
|
*/
|
||||||
|
int tb_dp_port_hpd_is_active(struct tb_port *port)
|
||||||
|
{
|
||||||
|
u32 data;
|
||||||
|
int ret;
|
||||||
|
|
||||||
|
ret = tb_port_read(port, &data, TB_CFG_PORT, port->cap_adap + 2, 1);
|
||||||
|
if (ret)
|
||||||
|
return ret;
|
||||||
|
|
||||||
|
return !!(data & TB_DP_HDP);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* tb_dp_port_hpd_clear() - Clear HPD from DP IN port
|
||||||
|
* @port: Port to clear HPD
|
||||||
|
*
|
||||||
|
* If the DP IN port has HDP set, this function can be used to clear it.
|
||||||
|
*/
|
||||||
|
int tb_dp_port_hpd_clear(struct tb_port *port)
|
||||||
|
{
|
||||||
|
u32 data;
|
||||||
|
int ret;
|
||||||
|
|
||||||
|
ret = tb_port_read(port, &data, TB_CFG_PORT, port->cap_adap + 3, 1);
|
||||||
|
if (ret)
|
||||||
|
return ret;
|
||||||
|
|
||||||
|
data |= TB_DP_HPDC;
|
||||||
|
return tb_port_write(port, &data, TB_CFG_PORT, port->cap_adap + 3, 1);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* tb_dp_port_set_hops() - Set video/aux Hop IDs for DP port
|
||||||
|
* @port: DP IN/OUT port to set hops
|
||||||
|
* @video: Video Hop ID
|
||||||
|
* @aux_tx: AUX TX Hop ID
|
||||||
|
* @aux_rx: AUX RX Hop ID
|
||||||
|
*
|
||||||
|
* Programs specified Hop IDs for DP IN/OUT port.
|
||||||
|
*/
|
||||||
|
int tb_dp_port_set_hops(struct tb_port *port, unsigned int video,
|
||||||
|
unsigned int aux_tx, unsigned int aux_rx)
|
||||||
|
{
|
||||||
|
u32 data[2];
|
||||||
|
int ret;
|
||||||
|
|
||||||
|
ret = tb_port_read(port, data, TB_CFG_PORT, port->cap_adap,
|
||||||
|
ARRAY_SIZE(data));
|
||||||
|
if (ret)
|
||||||
|
return ret;
|
||||||
|
|
||||||
|
data[0] &= ~TB_DP_VIDEO_HOPID_MASK;
|
||||||
|
data[1] &= ~(TB_DP_AUX_RX_HOPID_MASK | TB_DP_AUX_TX_HOPID_MASK);
|
||||||
|
|
||||||
|
data[0] |= (video << TB_DP_VIDEO_HOPID_SHIFT) & TB_DP_VIDEO_HOPID_MASK;
|
||||||
|
data[1] |= aux_tx & TB_DP_AUX_TX_HOPID_MASK;
|
||||||
|
data[1] |= (aux_rx << TB_DP_AUX_RX_HOPID_SHIFT) & TB_DP_AUX_RX_HOPID_MASK;
|
||||||
|
|
||||||
|
return tb_port_write(port, data, TB_CFG_PORT, port->cap_adap,
|
||||||
|
ARRAY_SIZE(data));
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* tb_dp_port_is_enabled() - Is DP adapter port enabled
|
||||||
|
* @port: DP adapter port to check
|
||||||
|
*/
|
||||||
|
bool tb_dp_port_is_enabled(struct tb_port *port)
|
||||||
|
{
|
||||||
|
u32 data;
|
||||||
|
|
||||||
|
if (tb_port_read(port, &data, TB_CFG_PORT, port->cap_adap, 1))
|
||||||
|
return false;
|
||||||
|
|
||||||
|
return !!(data & (TB_DP_VIDEO_EN | TB_DP_AUX_EN));
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* tb_dp_port_enable() - Enables/disables DP paths of a port
|
||||||
|
* @port: DP IN/OUT port
|
||||||
|
* @enable: Enable/disable DP path
|
||||||
|
*
|
||||||
|
* Once Hop IDs are programmed DP paths can be enabled or disabled by
|
||||||
|
* calling this function.
|
||||||
|
*/
|
||||||
|
int tb_dp_port_enable(struct tb_port *port, bool enable)
|
||||||
|
{
|
||||||
|
u32 data;
|
||||||
|
int ret;
|
||||||
|
|
||||||
|
ret = tb_port_read(port, &data, TB_CFG_PORT, port->cap_adap, 1);
|
||||||
|
if (ret)
|
||||||
|
return ret;
|
||||||
|
|
||||||
|
if (enable)
|
||||||
|
data |= TB_DP_VIDEO_EN | TB_DP_AUX_EN;
|
||||||
|
else
|
||||||
|
data &= ~(TB_DP_VIDEO_EN | TB_DP_AUX_EN);
|
||||||
|
|
||||||
|
return tb_port_write(port, &data, TB_CFG_PORT, port->cap_adap, 1);
|
||||||
|
}
|
||||||
|
|
||||||
/* switch utility functions */
|
/* switch utility functions */
|
||||||
|
|
||||||
static void tb_dump_switch(struct tb *tb, struct tb_regs_switch_header *sw)
|
static void tb_dump_switch(struct tb *tb, struct tb_regs_switch_header *sw)
|
||||||
|
@ -644,24 +953,6 @@ int tb_switch_reset(struct tb *tb, u64 route)
|
||||||
return res.err;
|
return res.err;
|
||||||
}
|
}
|
||||||
|
|
||||||
struct tb_switch *get_switch_at_route(struct tb_switch *sw, u64 route)
|
|
||||||
{
|
|
||||||
u8 next_port = route; /*
|
|
||||||
* Routes use a stride of 8 bits,
|
|
||||||
* eventhough a port index has 6 bits at most.
|
|
||||||
* */
|
|
||||||
if (route == 0)
|
|
||||||
return sw;
|
|
||||||
if (next_port > sw->config.max_port_number)
|
|
||||||
return NULL;
|
|
||||||
if (tb_is_upstream_port(&sw->ports[next_port]))
|
|
||||||
return NULL;
|
|
||||||
if (!sw->ports[next_port].remote)
|
|
||||||
return NULL;
|
|
||||||
return get_switch_at_route(sw->ports[next_port].remote->sw,
|
|
||||||
route >> TB_ROUTE_SHIFT);
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* tb_plug_events_active() - enable/disable plug events on a switch
|
* tb_plug_events_active() - enable/disable plug events on a switch
|
||||||
*
|
*
|
||||||
|
@ -716,8 +1007,8 @@ static int tb_switch_set_authorized(struct tb_switch *sw, unsigned int val)
|
||||||
{
|
{
|
||||||
int ret = -EINVAL;
|
int ret = -EINVAL;
|
||||||
|
|
||||||
if (mutex_lock_interruptible(&switch_lock))
|
if (!mutex_trylock(&sw->tb->lock))
|
||||||
return -ERESTARTSYS;
|
return restart_syscall();
|
||||||
|
|
||||||
if (sw->authorized)
|
if (sw->authorized)
|
||||||
goto unlock;
|
goto unlock;
|
||||||
|
@ -760,7 +1051,7 @@ static int tb_switch_set_authorized(struct tb_switch *sw, unsigned int val)
|
||||||
}
|
}
|
||||||
|
|
||||||
unlock:
|
unlock:
|
||||||
mutex_unlock(&switch_lock);
|
mutex_unlock(&sw->tb->lock);
|
||||||
return ret;
|
return ret;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -817,15 +1108,15 @@ static ssize_t key_show(struct device *dev, struct device_attribute *attr,
|
||||||
struct tb_switch *sw = tb_to_switch(dev);
|
struct tb_switch *sw = tb_to_switch(dev);
|
||||||
ssize_t ret;
|
ssize_t ret;
|
||||||
|
|
||||||
if (mutex_lock_interruptible(&switch_lock))
|
if (!mutex_trylock(&sw->tb->lock))
|
||||||
return -ERESTARTSYS;
|
return restart_syscall();
|
||||||
|
|
||||||
if (sw->key)
|
if (sw->key)
|
||||||
ret = sprintf(buf, "%*phN\n", TB_SWITCH_KEY_SIZE, sw->key);
|
ret = sprintf(buf, "%*phN\n", TB_SWITCH_KEY_SIZE, sw->key);
|
||||||
else
|
else
|
||||||
ret = sprintf(buf, "\n");
|
ret = sprintf(buf, "\n");
|
||||||
|
|
||||||
mutex_unlock(&switch_lock);
|
mutex_unlock(&sw->tb->lock);
|
||||||
return ret;
|
return ret;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -842,8 +1133,8 @@ static ssize_t key_store(struct device *dev, struct device_attribute *attr,
|
||||||
else if (hex2bin(key, buf, sizeof(key)))
|
else if (hex2bin(key, buf, sizeof(key)))
|
||||||
return -EINVAL;
|
return -EINVAL;
|
||||||
|
|
||||||
if (mutex_lock_interruptible(&switch_lock))
|
if (!mutex_trylock(&sw->tb->lock))
|
||||||
return -ERESTARTSYS;
|
return restart_syscall();
|
||||||
|
|
||||||
if (sw->authorized) {
|
if (sw->authorized) {
|
||||||
ret = -EBUSY;
|
ret = -EBUSY;
|
||||||
|
@ -858,7 +1149,7 @@ static ssize_t key_store(struct device *dev, struct device_attribute *attr,
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
mutex_unlock(&switch_lock);
|
mutex_unlock(&sw->tb->lock);
|
||||||
return ret;
|
return ret;
|
||||||
}
|
}
|
||||||
static DEVICE_ATTR(key, 0600, key_show, key_store);
|
static DEVICE_ATTR(key, 0600, key_show, key_store);
|
||||||
|
@ -904,8 +1195,8 @@ static ssize_t nvm_authenticate_store(struct device *dev,
|
||||||
bool val;
|
bool val;
|
||||||
int ret;
|
int ret;
|
||||||
|
|
||||||
if (mutex_lock_interruptible(&switch_lock))
|
if (!mutex_trylock(&sw->tb->lock))
|
||||||
return -ERESTARTSYS;
|
return restart_syscall();
|
||||||
|
|
||||||
/* If NVMem devices are not yet added */
|
/* If NVMem devices are not yet added */
|
||||||
if (!sw->nvm) {
|
if (!sw->nvm) {
|
||||||
|
@ -953,7 +1244,7 @@ static ssize_t nvm_authenticate_store(struct device *dev,
|
||||||
}
|
}
|
||||||
|
|
||||||
exit_unlock:
|
exit_unlock:
|
||||||
mutex_unlock(&switch_lock);
|
mutex_unlock(&sw->tb->lock);
|
||||||
|
|
||||||
if (ret)
|
if (ret)
|
||||||
return ret;
|
return ret;
|
||||||
|
@ -967,8 +1258,8 @@ static ssize_t nvm_version_show(struct device *dev,
|
||||||
struct tb_switch *sw = tb_to_switch(dev);
|
struct tb_switch *sw = tb_to_switch(dev);
|
||||||
int ret;
|
int ret;
|
||||||
|
|
||||||
if (mutex_lock_interruptible(&switch_lock))
|
if (!mutex_trylock(&sw->tb->lock))
|
||||||
return -ERESTARTSYS;
|
return restart_syscall();
|
||||||
|
|
||||||
if (sw->safe_mode)
|
if (sw->safe_mode)
|
||||||
ret = -ENODATA;
|
ret = -ENODATA;
|
||||||
|
@ -977,7 +1268,7 @@ static ssize_t nvm_version_show(struct device *dev,
|
||||||
else
|
else
|
||||||
ret = sprintf(buf, "%x.%x\n", sw->nvm->major, sw->nvm->minor);
|
ret = sprintf(buf, "%x.%x\n", sw->nvm->major, sw->nvm->minor);
|
||||||
|
|
||||||
mutex_unlock(&switch_lock);
|
mutex_unlock(&sw->tb->lock);
|
||||||
|
|
||||||
return ret;
|
return ret;
|
||||||
}
|
}
|
||||||
|
@ -1063,9 +1354,17 @@ static const struct attribute_group *switch_groups[] = {
|
||||||
static void tb_switch_release(struct device *dev)
|
static void tb_switch_release(struct device *dev)
|
||||||
{
|
{
|
||||||
struct tb_switch *sw = tb_to_switch(dev);
|
struct tb_switch *sw = tb_to_switch(dev);
|
||||||
|
int i;
|
||||||
|
|
||||||
dma_port_free(sw->dma_port);
|
dma_port_free(sw->dma_port);
|
||||||
|
|
||||||
|
for (i = 1; i <= sw->config.max_port_number; i++) {
|
||||||
|
if (!sw->ports[i].disabled) {
|
||||||
|
ida_destroy(&sw->ports[i].in_hopids);
|
||||||
|
ida_destroy(&sw->ports[i].out_hopids);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
kfree(sw->uuid);
|
kfree(sw->uuid);
|
||||||
kfree(sw->device_name);
|
kfree(sw->device_name);
|
||||||
kfree(sw->vendor_name);
|
kfree(sw->vendor_name);
|
||||||
|
@ -1150,24 +1449,32 @@ static int tb_switch_get_generation(struct tb_switch *sw)
|
||||||
* separately. The returned switch should be released by calling
|
* separately. The returned switch should be released by calling
|
||||||
* tb_switch_put().
|
* tb_switch_put().
|
||||||
*
|
*
|
||||||
* Return: Pointer to the allocated switch or %NULL in case of failure
|
* Return: Pointer to the allocated switch or ERR_PTR() in case of
|
||||||
|
* failure.
|
||||||
*/
|
*/
|
||||||
struct tb_switch *tb_switch_alloc(struct tb *tb, struct device *parent,
|
struct tb_switch *tb_switch_alloc(struct tb *tb, struct device *parent,
|
||||||
u64 route)
|
u64 route)
|
||||||
{
|
{
|
||||||
int i;
|
|
||||||
int cap;
|
|
||||||
struct tb_switch *sw;
|
struct tb_switch *sw;
|
||||||
int upstream_port = tb_cfg_get_upstream_port(tb->ctl, route);
|
int upstream_port;
|
||||||
|
int i, ret, depth;
|
||||||
|
|
||||||
|
/* Make sure we do not exceed maximum topology limit */
|
||||||
|
depth = tb_route_length(route);
|
||||||
|
if (depth > TB_SWITCH_MAX_DEPTH)
|
||||||
|
return ERR_PTR(-EADDRNOTAVAIL);
|
||||||
|
|
||||||
|
upstream_port = tb_cfg_get_upstream_port(tb->ctl, route);
|
||||||
if (upstream_port < 0)
|
if (upstream_port < 0)
|
||||||
return NULL;
|
return ERR_PTR(upstream_port);
|
||||||
|
|
||||||
sw = kzalloc(sizeof(*sw), GFP_KERNEL);
|
sw = kzalloc(sizeof(*sw), GFP_KERNEL);
|
||||||
if (!sw)
|
if (!sw)
|
||||||
return NULL;
|
return ERR_PTR(-ENOMEM);
|
||||||
|
|
||||||
sw->tb = tb;
|
sw->tb = tb;
|
||||||
if (tb_cfg_read(tb->ctl, &sw->config, route, 0, TB_CFG_SWITCH, 0, 5))
|
ret = tb_cfg_read(tb->ctl, &sw->config, route, 0, TB_CFG_SWITCH, 0, 5);
|
||||||
|
if (ret)
|
||||||
goto err_free_sw_ports;
|
goto err_free_sw_ports;
|
||||||
|
|
||||||
tb_dbg(tb, "current switch config:\n");
|
tb_dbg(tb, "current switch config:\n");
|
||||||
|
@ -1175,16 +1482,18 @@ struct tb_switch *tb_switch_alloc(struct tb *tb, struct device *parent,
|
||||||
|
|
||||||
/* configure switch */
|
/* configure switch */
|
||||||
sw->config.upstream_port_number = upstream_port;
|
sw->config.upstream_port_number = upstream_port;
|
||||||
sw->config.depth = tb_route_length(route);
|
sw->config.depth = depth;
|
||||||
sw->config.route_lo = route;
|
sw->config.route_hi = upper_32_bits(route);
|
||||||
sw->config.route_hi = route >> 32;
|
sw->config.route_lo = lower_32_bits(route);
|
||||||
sw->config.enabled = 0;
|
sw->config.enabled = 0;
|
||||||
|
|
||||||
/* initialize ports */
|
/* initialize ports */
|
||||||
sw->ports = kcalloc(sw->config.max_port_number + 1, sizeof(*sw->ports),
|
sw->ports = kcalloc(sw->config.max_port_number + 1, sizeof(*sw->ports),
|
||||||
GFP_KERNEL);
|
GFP_KERNEL);
|
||||||
if (!sw->ports)
|
if (!sw->ports) {
|
||||||
|
ret = -ENOMEM;
|
||||||
goto err_free_sw_ports;
|
goto err_free_sw_ports;
|
||||||
|
}
|
||||||
|
|
||||||
for (i = 0; i <= sw->config.max_port_number; i++) {
|
for (i = 0; i <= sw->config.max_port_number; i++) {
|
||||||
/* minimum setup for tb_find_cap and tb_drom_read to work */
|
/* minimum setup for tb_find_cap and tb_drom_read to work */
|
||||||
|
@ -1194,12 +1503,16 @@ struct tb_switch *tb_switch_alloc(struct tb *tb, struct device *parent,
|
||||||
|
|
||||||
sw->generation = tb_switch_get_generation(sw);
|
sw->generation = tb_switch_get_generation(sw);
|
||||||
|
|
||||||
cap = tb_switch_find_vse_cap(sw, TB_VSE_CAP_PLUG_EVENTS);
|
ret = tb_switch_find_vse_cap(sw, TB_VSE_CAP_PLUG_EVENTS);
|
||||||
if (cap < 0) {
|
if (ret < 0) {
|
||||||
tb_sw_warn(sw, "cannot find TB_VSE_CAP_PLUG_EVENTS aborting\n");
|
tb_sw_warn(sw, "cannot find TB_VSE_CAP_PLUG_EVENTS aborting\n");
|
||||||
goto err_free_sw_ports;
|
goto err_free_sw_ports;
|
||||||
}
|
}
|
||||||
sw->cap_plug_events = cap;
|
sw->cap_plug_events = ret;
|
||||||
|
|
||||||
|
ret = tb_switch_find_vse_cap(sw, TB_VSE_CAP_LINK_CONTROLLER);
|
||||||
|
if (ret > 0)
|
||||||
|
sw->cap_lc = ret;
|
||||||
|
|
||||||
/* Root switch is always authorized */
|
/* Root switch is always authorized */
|
||||||
if (!route)
|
if (!route)
|
||||||
|
@ -1218,7 +1531,7 @@ struct tb_switch *tb_switch_alloc(struct tb *tb, struct device *parent,
|
||||||
kfree(sw->ports);
|
kfree(sw->ports);
|
||||||
kfree(sw);
|
kfree(sw);
|
||||||
|
|
||||||
return NULL;
|
return ERR_PTR(ret);
|
||||||
}
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
|
@ -1233,7 +1546,7 @@ struct tb_switch *tb_switch_alloc(struct tb *tb, struct device *parent,
|
||||||
*
|
*
|
||||||
* The returned switch must be released by calling tb_switch_put().
|
* The returned switch must be released by calling tb_switch_put().
|
||||||
*
|
*
|
||||||
* Return: Pointer to the allocated switch or %NULL in case of failure
|
* Return: Pointer to the allocated switch or ERR_PTR() in case of failure
|
||||||
*/
|
*/
|
||||||
struct tb_switch *
|
struct tb_switch *
|
||||||
tb_switch_alloc_safe_mode(struct tb *tb, struct device *parent, u64 route)
|
tb_switch_alloc_safe_mode(struct tb *tb, struct device *parent, u64 route)
|
||||||
|
@ -1242,7 +1555,7 @@ tb_switch_alloc_safe_mode(struct tb *tb, struct device *parent, u64 route)
|
||||||
|
|
||||||
sw = kzalloc(sizeof(*sw), GFP_KERNEL);
|
sw = kzalloc(sizeof(*sw), GFP_KERNEL);
|
||||||
if (!sw)
|
if (!sw)
|
||||||
return NULL;
|
return ERR_PTR(-ENOMEM);
|
||||||
|
|
||||||
sw->tb = tb;
|
sw->tb = tb;
|
||||||
sw->config.depth = tb_route_length(route);
|
sw->config.depth = tb_route_length(route);
|
||||||
|
@ -1291,25 +1604,27 @@ int tb_switch_configure(struct tb_switch *sw)
|
||||||
if (ret)
|
if (ret)
|
||||||
return ret;
|
return ret;
|
||||||
|
|
||||||
|
ret = tb_lc_configure_link(sw);
|
||||||
|
if (ret)
|
||||||
|
return ret;
|
||||||
|
|
||||||
return tb_plug_events_active(sw, true);
|
return tb_plug_events_active(sw, true);
|
||||||
}
|
}
|
||||||
|
|
||||||
static void tb_switch_set_uuid(struct tb_switch *sw)
|
static int tb_switch_set_uuid(struct tb_switch *sw)
|
||||||
{
|
{
|
||||||
u32 uuid[4];
|
u32 uuid[4];
|
||||||
int cap;
|
int ret;
|
||||||
|
|
||||||
if (sw->uuid)
|
if (sw->uuid)
|
||||||
return;
|
return 0;
|
||||||
|
|
||||||
/*
|
/*
|
||||||
* The newer controllers include fused UUID as part of link
|
* The newer controllers include fused UUID as part of link
|
||||||
* controller specific registers
|
* controller specific registers
|
||||||
*/
|
*/
|
||||||
cap = tb_switch_find_vse_cap(sw, TB_VSE_CAP_LINK_CONTROLLER);
|
ret = tb_lc_read_uuid(sw, uuid);
|
||||||
if (cap > 0) {
|
if (ret) {
|
||||||
tb_sw_read(sw, uuid, TB_CFG_SWITCH, cap + 3, 4);
|
|
||||||
} else {
|
|
||||||
/*
|
/*
|
||||||
* ICM generates UUID based on UID and fills the upper
|
* ICM generates UUID based on UID and fills the upper
|
||||||
* two words with ones. This is not strictly following
|
* two words with ones. This is not strictly following
|
||||||
|
@ -1323,6 +1638,9 @@ static void tb_switch_set_uuid(struct tb_switch *sw)
|
||||||
}
|
}
|
||||||
|
|
||||||
sw->uuid = kmemdup(uuid, sizeof(uuid), GFP_KERNEL);
|
sw->uuid = kmemdup(uuid, sizeof(uuid), GFP_KERNEL);
|
||||||
|
if (!sw->uuid)
|
||||||
|
return -ENOMEM;
|
||||||
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
static int tb_switch_add_dma_port(struct tb_switch *sw)
|
static int tb_switch_add_dma_port(struct tb_switch *sw)
|
||||||
|
@ -1372,7 +1690,9 @@ static int tb_switch_add_dma_port(struct tb_switch *sw)
|
||||||
|
|
||||||
if (status) {
|
if (status) {
|
||||||
tb_sw_info(sw, "switch flash authentication failed\n");
|
tb_sw_info(sw, "switch flash authentication failed\n");
|
||||||
tb_switch_set_uuid(sw);
|
ret = tb_switch_set_uuid(sw);
|
||||||
|
if (ret)
|
||||||
|
return ret;
|
||||||
nvm_set_auth_status(sw, status);
|
nvm_set_auth_status(sw, status);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -1422,7 +1742,9 @@ int tb_switch_add(struct tb_switch *sw)
|
||||||
}
|
}
|
||||||
tb_sw_dbg(sw, "uid: %#llx\n", sw->uid);
|
tb_sw_dbg(sw, "uid: %#llx\n", sw->uid);
|
||||||
|
|
||||||
tb_switch_set_uuid(sw);
|
ret = tb_switch_set_uuid(sw);
|
||||||
|
if (ret)
|
||||||
|
return ret;
|
||||||
|
|
||||||
for (i = 0; i <= sw->config.max_port_number; i++) {
|
for (i = 0; i <= sw->config.max_port_number; i++) {
|
||||||
if (sw->ports[i].disabled) {
|
if (sw->ports[i].disabled) {
|
||||||
|
@ -1484,18 +1806,18 @@ void tb_switch_remove(struct tb_switch *sw)
|
||||||
|
|
||||||
/* port 0 is the switch itself and never has a remote */
|
/* port 0 is the switch itself and never has a remote */
|
||||||
for (i = 1; i <= sw->config.max_port_number; i++) {
|
for (i = 1; i <= sw->config.max_port_number; i++) {
|
||||||
if (tb_is_upstream_port(&sw->ports[i]))
|
if (tb_port_has_remote(&sw->ports[i])) {
|
||||||
continue;
|
|
||||||
if (sw->ports[i].remote)
|
|
||||||
tb_switch_remove(sw->ports[i].remote->sw);
|
tb_switch_remove(sw->ports[i].remote->sw);
|
||||||
sw->ports[i].remote = NULL;
|
sw->ports[i].remote = NULL;
|
||||||
if (sw->ports[i].xdomain)
|
} else if (sw->ports[i].xdomain) {
|
||||||
tb_xdomain_remove(sw->ports[i].xdomain);
|
tb_xdomain_remove(sw->ports[i].xdomain);
|
||||||
sw->ports[i].xdomain = NULL;
|
sw->ports[i].xdomain = NULL;
|
||||||
}
|
}
|
||||||
|
}
|
||||||
|
|
||||||
if (!sw->is_unplugged)
|
if (!sw->is_unplugged)
|
||||||
tb_plug_events_active(sw, false);
|
tb_plug_events_active(sw, false);
|
||||||
|
tb_lc_unconfigure_link(sw);
|
||||||
|
|
||||||
tb_switch_nvm_remove(sw);
|
tb_switch_nvm_remove(sw);
|
||||||
|
|
||||||
|
@ -1520,8 +1842,10 @@ void tb_sw_set_unplugged(struct tb_switch *sw)
|
||||||
}
|
}
|
||||||
sw->is_unplugged = true;
|
sw->is_unplugged = true;
|
||||||
for (i = 0; i <= sw->config.max_port_number; i++) {
|
for (i = 0; i <= sw->config.max_port_number; i++) {
|
||||||
if (!tb_is_upstream_port(&sw->ports[i]) && sw->ports[i].remote)
|
if (tb_port_has_remote(&sw->ports[i]))
|
||||||
tb_sw_set_unplugged(sw->ports[i].remote->sw);
|
tb_sw_set_unplugged(sw->ports[i].remote->sw);
|
||||||
|
else if (sw->ports[i].xdomain)
|
||||||
|
sw->ports[i].xdomain->is_unplugged = true;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -1537,6 +1861,17 @@ int tb_switch_resume(struct tb_switch *sw)
|
||||||
if (tb_route(sw)) {
|
if (tb_route(sw)) {
|
||||||
u64 uid;
|
u64 uid;
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Check first that we can still read the switch config
|
||||||
|
* space. It may be that there is now another domain
|
||||||
|
* connected.
|
||||||
|
*/
|
||||||
|
err = tb_cfg_get_upstream_port(sw->tb->ctl, tb_route(sw));
|
||||||
|
if (err < 0) {
|
||||||
|
tb_sw_info(sw, "switch not present anymore\n");
|
||||||
|
return err;
|
||||||
|
}
|
||||||
|
|
||||||
err = tb_drom_read_uid_only(sw, &uid);
|
err = tb_drom_read_uid_only(sw, &uid);
|
||||||
if (err) {
|
if (err) {
|
||||||
tb_sw_warn(sw, "uid read failed\n");
|
tb_sw_warn(sw, "uid read failed\n");
|
||||||
|
@ -1555,6 +1890,10 @@ int tb_switch_resume(struct tb_switch *sw)
|
||||||
if (err)
|
if (err)
|
||||||
return err;
|
return err;
|
||||||
|
|
||||||
|
err = tb_lc_configure_link(sw);
|
||||||
|
if (err)
|
||||||
|
return err;
|
||||||
|
|
||||||
err = tb_plug_events_active(sw, true);
|
err = tb_plug_events_active(sw, true);
|
||||||
if (err)
|
if (err)
|
||||||
return err;
|
return err;
|
||||||
|
@ -1562,17 +1901,25 @@ int tb_switch_resume(struct tb_switch *sw)
|
||||||
/* check for surviving downstream switches */
|
/* check for surviving downstream switches */
|
||||||
for (i = 1; i <= sw->config.max_port_number; i++) {
|
for (i = 1; i <= sw->config.max_port_number; i++) {
|
||||||
struct tb_port *port = &sw->ports[i];
|
struct tb_port *port = &sw->ports[i];
|
||||||
if (tb_is_upstream_port(port))
|
|
||||||
|
if (!tb_port_has_remote(port) && !port->xdomain)
|
||||||
continue;
|
continue;
|
||||||
if (!port->remote)
|
|
||||||
continue;
|
if (tb_wait_for_port(port, true) <= 0) {
|
||||||
if (tb_wait_for_port(port, true) <= 0
|
tb_port_warn(port,
|
||||||
|| tb_switch_resume(port->remote->sw)) {
|
"lost during suspend, disconnecting\n");
|
||||||
|
if (tb_port_has_remote(port))
|
||||||
|
tb_sw_set_unplugged(port->remote->sw);
|
||||||
|
else if (port->xdomain)
|
||||||
|
port->xdomain->is_unplugged = true;
|
||||||
|
} else if (tb_port_has_remote(port)) {
|
||||||
|
if (tb_switch_resume(port->remote->sw)) {
|
||||||
tb_port_warn(port,
|
tb_port_warn(port,
|
||||||
"lost during suspend, disconnecting\n");
|
"lost during suspend, disconnecting\n");
|
||||||
tb_sw_set_unplugged(port->remote->sw);
|
tb_sw_set_unplugged(port->remote->sw);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
}
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -1584,13 +1931,11 @@ void tb_switch_suspend(struct tb_switch *sw)
|
||||||
return;
|
return;
|
||||||
|
|
||||||
for (i = 1; i <= sw->config.max_port_number; i++) {
|
for (i = 1; i <= sw->config.max_port_number; i++) {
|
||||||
if (!tb_is_upstream_port(&sw->ports[i]) && sw->ports[i].remote)
|
if (tb_port_has_remote(&sw->ports[i]))
|
||||||
tb_switch_suspend(sw->ports[i].remote->sw);
|
tb_switch_suspend(sw->ports[i].remote->sw);
|
||||||
}
|
}
|
||||||
/*
|
|
||||||
* TODO: invoke tb_cfg_prepare_to_sleep here? does not seem to have any
|
tb_lc_set_sleep(sw);
|
||||||
* effect?
|
|
||||||
*/
|
|
||||||
}
|
}
|
||||||
|
|
||||||
struct tb_sw_lookup {
|
struct tb_sw_lookup {
|
||||||
|
|
|
@ -1,8 +1,9 @@
|
||||||
// SPDX-License-Identifier: GPL-2.0
|
// SPDX-License-Identifier: GPL-2.0
|
||||||
/*
|
/*
|
||||||
* Thunderbolt Cactus Ridge driver - bus logic (NHI independent)
|
* Thunderbolt driver - bus logic (NHI independent)
|
||||||
*
|
*
|
||||||
* Copyright (c) 2014 Andreas Noever <andreas.noever@gmail.com>
|
* Copyright (c) 2014 Andreas Noever <andreas.noever@gmail.com>
|
||||||
|
* Copyright (C) 2019, Intel Corporation
|
||||||
*/
|
*/
|
||||||
|
|
||||||
#include <linux/slab.h>
|
#include <linux/slab.h>
|
||||||
|
@ -12,7 +13,7 @@
|
||||||
|
|
||||||
#include "tb.h"
|
#include "tb.h"
|
||||||
#include "tb_regs.h"
|
#include "tb_regs.h"
|
||||||
#include "tunnel_pci.h"
|
#include "tunnel.h"
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* struct tb_cm - Simple Thunderbolt connection manager
|
* struct tb_cm - Simple Thunderbolt connection manager
|
||||||
|
@ -27,8 +28,100 @@ struct tb_cm {
|
||||||
bool hotplug_active;
|
bool hotplug_active;
|
||||||
};
|
};
|
||||||
|
|
||||||
|
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);
|
||||||
|
}
|
||||||
|
|
||||||
/* enumeration & hot plug handling */
|
/* enumeration & hot plug handling */
|
||||||
|
|
||||||
|
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;
|
||||||
|
int i;
|
||||||
|
|
||||||
|
for (i = 1; i <= sw->config.max_port_number; i++) {
|
||||||
|
struct tb_tunnel *tunnel = NULL;
|
||||||
|
|
||||||
|
port = &sw->ports[i];
|
||||||
|
switch (port->config.type) {
|
||||||
|
case TB_TYPE_DP_HDMI_IN:
|
||||||
|
tunnel = tb_tunnel_discover_dp(tb, port);
|
||||||
|
break;
|
||||||
|
|
||||||
|
case TB_TYPE_PCIE_DOWN:
|
||||||
|
tunnel = tb_tunnel_discover_pci(tb, port);
|
||||||
|
break;
|
||||||
|
|
||||||
|
default:
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!tunnel)
|
||||||
|
continue;
|
||||||
|
|
||||||
|
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);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
list_add_tail(&tunnel->list, &tcm->tunnel_list);
|
||||||
|
}
|
||||||
|
|
||||||
|
for (i = 1; i <= sw->config.max_port_number; i++) {
|
||||||
|
if (tb_port_has_remote(&sw->ports[i]))
|
||||||
|
tb_discover_tunnels(sw->ports[i].remote->sw);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
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);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
static void tb_scan_port(struct tb_port *port);
|
static void tb_scan_port(struct tb_port *port);
|
||||||
|
|
||||||
|
@ -47,9 +140,21 @@ static void tb_scan_switch(struct tb_switch *sw)
|
||||||
*/
|
*/
|
||||||
static void tb_scan_port(struct tb_port *port)
|
static void tb_scan_port(struct tb_port *port)
|
||||||
{
|
{
|
||||||
|
struct tb_cm *tcm = tb_priv(port->sw->tb);
|
||||||
|
struct tb_port *upstream_port;
|
||||||
struct tb_switch *sw;
|
struct tb_switch *sw;
|
||||||
|
|
||||||
if (tb_is_upstream_port(port))
|
if (tb_is_upstream_port(port))
|
||||||
return;
|
return;
|
||||||
|
|
||||||
|
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;
|
||||||
|
}
|
||||||
|
|
||||||
if (port->config.type != TB_TYPE_PORT)
|
if (port->config.type != TB_TYPE_PORT)
|
||||||
return;
|
return;
|
||||||
if (port->dual_link_port && port->link_nr)
|
if (port->dual_link_port && port->link_nr)
|
||||||
|
@ -60,45 +165,95 @@ static void tb_scan_port(struct tb_port *port)
|
||||||
if (tb_wait_for_port(port, false) <= 0)
|
if (tb_wait_for_port(port, false) <= 0)
|
||||||
return;
|
return;
|
||||||
if (port->remote) {
|
if (port->remote) {
|
||||||
tb_port_WARN(port, "port already has a remote!\n");
|
tb_port_dbg(port, "port already has a remote\n");
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
sw = tb_switch_alloc(port->sw->tb, &port->sw->dev,
|
sw = tb_switch_alloc(port->sw->tb, &port->sw->dev,
|
||||||
tb_downstream_route(port));
|
tb_downstream_route(port));
|
||||||
if (!sw)
|
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);
|
||||||
return;
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
if (tb_switch_configure(sw)) {
|
if (tb_switch_configure(sw)) {
|
||||||
tb_switch_put(sw);
|
tb_switch_put(sw);
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
sw->authorized = true;
|
/*
|
||||||
|
* If there was previously another domain connected remove it
|
||||||
|
* first.
|
||||||
|
*/
|
||||||
|
if (port->xdomain) {
|
||||||
|
tb_xdomain_remove(port->xdomain);
|
||||||
|
port->xdomain = NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
/*
|
||||||
|
* 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);
|
||||||
|
|
||||||
if (tb_switch_add(sw)) {
|
if (tb_switch_add(sw)) {
|
||||||
tb_switch_put(sw);
|
tb_switch_put(sw);
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
port->remote = tb_upstream_port(sw);
|
/* Link the switches using both links if available */
|
||||||
tb_upstream_port(sw)->remote = port;
|
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;
|
||||||
|
}
|
||||||
|
|
||||||
tb_scan_switch(sw);
|
tb_scan_switch(sw);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
static int tb_free_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))) {
|
||||||
|
tb_tunnel_deactivate(tunnel);
|
||||||
|
list_del(&tunnel->list);
|
||||||
|
tb_tunnel_free(tunnel);
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return -ENODEV;
|
||||||
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* tb_free_invalid_tunnels() - destroy tunnels of devices that have gone away
|
* tb_free_invalid_tunnels() - destroy tunnels of devices that have gone away
|
||||||
*/
|
*/
|
||||||
static void tb_free_invalid_tunnels(struct tb *tb)
|
static void tb_free_invalid_tunnels(struct tb *tb)
|
||||||
{
|
{
|
||||||
struct tb_cm *tcm = tb_priv(tb);
|
struct tb_cm *tcm = tb_priv(tb);
|
||||||
struct tb_pci_tunnel *tunnel;
|
struct tb_tunnel *tunnel;
|
||||||
struct tb_pci_tunnel *n;
|
struct tb_tunnel *n;
|
||||||
|
|
||||||
list_for_each_entry_safe(tunnel, n, &tcm->tunnel_list, list) {
|
list_for_each_entry_safe(tunnel, n, &tcm->tunnel_list, list) {
|
||||||
if (tb_pci_is_invalid(tunnel)) {
|
if (tb_tunnel_is_invalid(tunnel)) {
|
||||||
tb_pci_deactivate(tunnel);
|
tb_tunnel_deactivate(tunnel);
|
||||||
list_del(&tunnel->list);
|
list_del(&tunnel->list);
|
||||||
tb_pci_free(tunnel);
|
tb_tunnel_free(tunnel);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -111,137 +266,233 @@ static void tb_free_unplugged_children(struct tb_switch *sw)
|
||||||
int i;
|
int i;
|
||||||
for (i = 1; i <= sw->config.max_port_number; i++) {
|
for (i = 1; i <= sw->config.max_port_number; i++) {
|
||||||
struct tb_port *port = &sw->ports[i];
|
struct tb_port *port = &sw->ports[i];
|
||||||
if (tb_is_upstream_port(port))
|
|
||||||
continue;
|
if (!tb_port_has_remote(port))
|
||||||
if (!port->remote)
|
|
||||||
continue;
|
continue;
|
||||||
|
|
||||||
if (port->remote->sw->is_unplugged) {
|
if (port->remote->sw->is_unplugged) {
|
||||||
tb_switch_remove(port->remote->sw);
|
tb_switch_remove(port->remote->sw);
|
||||||
port->remote = NULL;
|
port->remote = NULL;
|
||||||
|
if (port->dual_link_port)
|
||||||
|
port->dual_link_port->remote = NULL;
|
||||||
} else {
|
} else {
|
||||||
tb_free_unplugged_children(port->remote->sw);
|
tb_free_unplugged_children(port->remote->sw);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* find_pci_up_port() - return the first PCIe up port on @sw or NULL
|
* tb_find_port() - return the first port of @type on @sw or NULL
|
||||||
|
* @sw: Switch to find the port from
|
||||||
|
* @type: Port type to look for
|
||||||
*/
|
*/
|
||||||
static struct tb_port *tb_find_pci_up_port(struct tb_switch *sw)
|
static struct tb_port *tb_find_port(struct tb_switch *sw,
|
||||||
|
enum tb_port_type type)
|
||||||
{
|
{
|
||||||
int i;
|
int i;
|
||||||
for (i = 1; i <= sw->config.max_port_number; i++)
|
for (i = 1; i <= sw->config.max_port_number; i++)
|
||||||
if (sw->ports[i].config.type == TB_TYPE_PCIE_UP)
|
if (sw->ports[i].config.type == type)
|
||||||
return &sw->ports[i];
|
return &sw->ports[i];
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* find_unused_down_port() - return the first inactive PCIe down port on @sw
|
* 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_down_port(struct tb_switch *sw)
|
static struct tb_port *tb_find_unused_port(struct tb_switch *sw,
|
||||||
|
enum tb_port_type type)
|
||||||
{
|
{
|
||||||
int i;
|
int i;
|
||||||
int cap;
|
|
||||||
int res;
|
|
||||||
int data;
|
|
||||||
for (i = 1; i <= sw->config.max_port_number; i++) {
|
for (i = 1; i <= sw->config.max_port_number; i++) {
|
||||||
if (tb_is_upstream_port(&sw->ports[i]))
|
if (tb_is_upstream_port(&sw->ports[i]))
|
||||||
continue;
|
continue;
|
||||||
if (sw->ports[i].config.type != TB_TYPE_PCIE_DOWN)
|
if (sw->ports[i].config.type != type)
|
||||||
continue;
|
continue;
|
||||||
cap = tb_port_find_cap(&sw->ports[i], TB_PORT_CAP_ADAP);
|
if (!sw->ports[i].cap_adap)
|
||||||
if (cap < 0)
|
|
||||||
continue;
|
continue;
|
||||||
res = tb_port_read(&sw->ports[i], &data, TB_CFG_PORT, cap, 1);
|
if (tb_port_is_enabled(&sw->ports[i]))
|
||||||
if (res < 0)
|
|
||||||
continue;
|
|
||||||
if (data & 0x80000000)
|
|
||||||
continue;
|
continue;
|
||||||
return &sw->ports[i];
|
return &sw->ports[i];
|
||||||
}
|
}
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
|
|
||||||
/**
|
static struct tb_port *tb_find_pcie_down(struct tb_switch *sw,
|
||||||
* tb_activate_pcie_devices() - scan for and activate PCIe devices
|
const struct tb_port *port)
|
||||||
*
|
{
|
||||||
* This method is somewhat ad hoc. For now it only supports one device
|
/*
|
||||||
* per port and only devices at depth 1.
|
* To keep plugging devices consistently in the same PCIe
|
||||||
*/
|
* hierarchy, do mapping here for root switch downstream PCIe
|
||||||
static void tb_activate_pcie_devices(struct tb *tb)
|
* ports.
|
||||||
|
*/
|
||||||
|
if (!tb_route(sw)) {
|
||||||
|
int phy_port = tb_phy_port_from_link(port->port);
|
||||||
|
int index;
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Hard-coded Thunderbolt port to PCIe down port mapping
|
||||||
|
* per controller.
|
||||||
|
*/
|
||||||
|
if (tb_switch_is_cr(sw))
|
||||||
|
index = !phy_port ? 6 : 7;
|
||||||
|
else if (tb_switch_is_fr(sw))
|
||||||
|
index = !phy_port ? 6 : 8;
|
||||||
|
else
|
||||||
|
goto out;
|
||||||
|
|
||||||
|
/* Validate the hard-coding */
|
||||||
|
if (WARN_ON(index > sw->config.max_port_number))
|
||||||
|
goto out;
|
||||||
|
if (WARN_ON(!tb_port_is_pcie_down(&sw->ports[index])))
|
||||||
|
goto out;
|
||||||
|
if (WARN_ON(tb_pci_port_is_enabled(&sw->ports[index])))
|
||||||
|
goto out;
|
||||||
|
|
||||||
|
return &sw->ports[index];
|
||||||
|
}
|
||||||
|
|
||||||
|
out:
|
||||||
|
return tb_find_unused_port(sw, TB_TYPE_PCIE_DOWN);
|
||||||
|
}
|
||||||
|
|
||||||
|
static int tb_tunnel_dp(struct tb *tb, struct tb_port *out)
|
||||||
{
|
{
|
||||||
int i;
|
|
||||||
int cap;
|
|
||||||
u32 data;
|
|
||||||
struct tb_switch *sw;
|
|
||||||
struct tb_port *up_port;
|
|
||||||
struct tb_port *down_port;
|
|
||||||
struct tb_pci_tunnel *tunnel;
|
|
||||||
struct tb_cm *tcm = tb_priv(tb);
|
struct tb_cm *tcm = tb_priv(tb);
|
||||||
|
struct tb_switch *sw = out->sw;
|
||||||
|
struct tb_tunnel *tunnel;
|
||||||
|
struct tb_port *in;
|
||||||
|
|
||||||
/* scan for pcie devices at depth 1*/
|
if (tb_port_is_enabled(out))
|
||||||
for (i = 1; i <= tb->root_switch->config.max_port_number; i++) {
|
return 0;
|
||||||
if (tb_is_upstream_port(&tb->root_switch->ports[i]))
|
|
||||||
continue;
|
|
||||||
if (tb->root_switch->ports[i].config.type != TB_TYPE_PORT)
|
|
||||||
continue;
|
|
||||||
if (!tb->root_switch->ports[i].remote)
|
|
||||||
continue;
|
|
||||||
sw = tb->root_switch->ports[i].remote->sw;
|
|
||||||
up_port = tb_find_pci_up_port(sw);
|
|
||||||
if (!up_port) {
|
|
||||||
tb_sw_info(sw, "no PCIe devices found, aborting\n");
|
|
||||||
continue;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* check whether port is already activated */
|
do {
|
||||||
cap = tb_port_find_cap(up_port, TB_PORT_CAP_ADAP);
|
sw = tb_to_switch(sw->dev.parent);
|
||||||
if (cap < 0)
|
if (!sw)
|
||||||
continue;
|
return 0;
|
||||||
if (tb_port_read(up_port, &data, TB_CFG_PORT, cap, 1))
|
in = tb_find_unused_port(sw, TB_TYPE_DP_HDMI_IN);
|
||||||
continue;
|
} while (!in);
|
||||||
if (data & 0x80000000) {
|
|
||||||
tb_port_info(up_port,
|
|
||||||
"PCIe port already activated, aborting\n");
|
|
||||||
continue;
|
|
||||||
}
|
|
||||||
|
|
||||||
down_port = tb_find_unused_down_port(tb->root_switch);
|
tunnel = tb_tunnel_alloc_dp(tb, in, out);
|
||||||
if (!down_port) {
|
|
||||||
tb_port_info(up_port,
|
|
||||||
"All PCIe down ports are occupied, aborting\n");
|
|
||||||
continue;
|
|
||||||
}
|
|
||||||
tunnel = tb_pci_alloc(tb, up_port, down_port);
|
|
||||||
if (!tunnel) {
|
if (!tunnel) {
|
||||||
tb_port_info(up_port,
|
tb_port_dbg(out, "DP tunnel allocation failed\n");
|
||||||
"PCIe tunnel allocation failed, aborting\n");
|
return -ENOMEM;
|
||||||
continue;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
if (tb_pci_activate(tunnel)) {
|
if (tb_tunnel_activate(tunnel)) {
|
||||||
tb_port_info(up_port,
|
tb_port_info(out, "DP tunnel activation failed, aborting\n");
|
||||||
|
tb_tunnel_free(tunnel);
|
||||||
|
return -EIO;
|
||||||
|
}
|
||||||
|
|
||||||
|
list_add_tail(&tunnel->list, &tcm->tunnel_list);
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void tb_teardown_dp(struct tb *tb, struct tb_port *out)
|
||||||
|
{
|
||||||
|
tb_free_tunnel(tb, TB_TUNNEL_DP, NULL, out);
|
||||||
|
}
|
||||||
|
|
||||||
|
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;
|
||||||
|
|
||||||
|
up = tb_find_port(sw, TB_TYPE_PCIE_UP);
|
||||||
|
if (!up)
|
||||||
|
return 0;
|
||||||
|
|
||||||
|
/*
|
||||||
|
* 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");
|
"PCIe tunnel activation failed, aborting\n");
|
||||||
tb_pci_free(tunnel);
|
tb_tunnel_free(tunnel);
|
||||||
continue;
|
return -EIO;
|
||||||
}
|
}
|
||||||
|
|
||||||
list_add(&tunnel->list, &tcm->tunnel_list);
|
list_add_tail(&tunnel->list, &tcm->tunnel_list);
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
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);
|
||||||
|
nhi_port = tb_find_port(tb->root_switch, TB_TYPE_NHI);
|
||||||
|
|
||||||
|
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;
|
||||||
|
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.
|
||||||
|
*/
|
||||||
|
tb_free_tunnel(tb, TB_TUNNEL_DMA, NULL, dst_port);
|
||||||
|
}
|
||||||
|
|
||||||
|
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;
|
||||||
}
|
}
|
||||||
|
|
||||||
/* hotplug handling */
|
/* hotplug handling */
|
||||||
|
|
||||||
struct tb_hotplug_event {
|
|
||||||
struct work_struct work;
|
|
||||||
struct tb *tb;
|
|
||||||
u64 route;
|
|
||||||
u8 port;
|
|
||||||
bool unplug;
|
|
||||||
};
|
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* tb_handle_hotplug() - handle hotplug event
|
* tb_handle_hotplug() - handle hotplug event
|
||||||
*
|
*
|
||||||
|
@ -258,7 +509,7 @@ static void tb_handle_hotplug(struct work_struct *work)
|
||||||
if (!tcm->hotplug_active)
|
if (!tcm->hotplug_active)
|
||||||
goto out; /* during init, suspend or shutdown */
|
goto out; /* during init, suspend or shutdown */
|
||||||
|
|
||||||
sw = get_switch_at_route(tb->root_switch, ev->route);
|
sw = tb_switch_find_by_route(tb, ev->route);
|
||||||
if (!sw) {
|
if (!sw) {
|
||||||
tb_warn(tb,
|
tb_warn(tb,
|
||||||
"hotplug event from non existent switch %llx:%x (unplug: %d)\n",
|
"hotplug event from non existent switch %llx:%x (unplug: %d)\n",
|
||||||
|
@ -269,43 +520,60 @@ static void tb_handle_hotplug(struct work_struct *work)
|
||||||
tb_warn(tb,
|
tb_warn(tb,
|
||||||
"hotplug event from non existent port %llx:%x (unplug: %d)\n",
|
"hotplug event from non existent port %llx:%x (unplug: %d)\n",
|
||||||
ev->route, ev->port, ev->unplug);
|
ev->route, ev->port, ev->unplug);
|
||||||
goto out;
|
goto put_sw;
|
||||||
}
|
}
|
||||||
port = &sw->ports[ev->port];
|
port = &sw->ports[ev->port];
|
||||||
if (tb_is_upstream_port(port)) {
|
if (tb_is_upstream_port(port)) {
|
||||||
tb_warn(tb,
|
tb_dbg(tb, "hotplug event for upstream port %llx:%x (unplug: %d)\n",
|
||||||
"hotplug event for upstream port %llx:%x (unplug: %d)\n",
|
|
||||||
ev->route, ev->port, ev->unplug);
|
ev->route, ev->port, ev->unplug);
|
||||||
goto out;
|
goto put_sw;
|
||||||
}
|
}
|
||||||
if (ev->unplug) {
|
if (ev->unplug) {
|
||||||
if (port->remote) {
|
if (tb_port_has_remote(port)) {
|
||||||
tb_port_info(port, "unplugged\n");
|
tb_port_dbg(port, "switch unplugged\n");
|
||||||
tb_sw_set_unplugged(port->remote->sw);
|
tb_sw_set_unplugged(port->remote->sw);
|
||||||
tb_free_invalid_tunnels(tb);
|
tb_free_invalid_tunnels(tb);
|
||||||
tb_switch_remove(port->remote->sw);
|
tb_switch_remove(port->remote->sw);
|
||||||
port->remote = NULL;
|
port->remote = NULL;
|
||||||
|
if (port->dual_link_port)
|
||||||
|
port->dual_link_port->remote = NULL;
|
||||||
|
} 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);
|
||||||
|
} else if (tb_port_is_dpout(port)) {
|
||||||
|
tb_teardown_dp(tb, port);
|
||||||
} else {
|
} else {
|
||||||
tb_port_info(port,
|
tb_port_dbg(port,
|
||||||
"got unplug event for disconnected port, ignoring\n");
|
"got unplug event for disconnected port, ignoring\n");
|
||||||
}
|
}
|
||||||
} else if (port->remote) {
|
} else if (port->remote) {
|
||||||
tb_port_info(port,
|
tb_port_dbg(port, "got plug event for connected port, ignoring\n");
|
||||||
"got plug event for connected port, ignoring\n");
|
|
||||||
} else {
|
} else {
|
||||||
tb_port_info(port, "hotplug: scanning\n");
|
if (tb_port_is_null(port)) {
|
||||||
|
tb_port_dbg(port, "hotplug: scanning\n");
|
||||||
tb_scan_port(port);
|
tb_scan_port(port);
|
||||||
if (!port->remote) {
|
if (!port->remote)
|
||||||
tb_port_info(port, "hotplug: no switch found\n");
|
tb_port_dbg(port, "hotplug: no switch found\n");
|
||||||
} else if (port->remote->sw->config.depth > 1) {
|
} else if (tb_port_is_dpout(port)) {
|
||||||
tb_sw_warn(port->remote->sw,
|
tb_tunnel_dp(tb, port);
|
||||||
"hotplug: chaining not supported\n");
|
|
||||||
} else {
|
|
||||||
tb_sw_info(port->remote->sw,
|
|
||||||
"hotplug: activating pcie devices\n");
|
|
||||||
tb_activate_pcie_devices(tb);
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
put_sw:
|
||||||
|
tb_switch_put(sw);
|
||||||
out:
|
out:
|
||||||
mutex_unlock(&tb->lock);
|
mutex_unlock(&tb->lock);
|
||||||
kfree(ev);
|
kfree(ev);
|
||||||
|
@ -320,7 +588,6 @@ static void tb_handle_event(struct tb *tb, enum tb_cfg_pkg_type type,
|
||||||
const void *buf, size_t size)
|
const void *buf, size_t size)
|
||||||
{
|
{
|
||||||
const struct cfg_event_pkg *pkg = buf;
|
const struct cfg_event_pkg *pkg = buf;
|
||||||
struct tb_hotplug_event *ev;
|
|
||||||
u64 route;
|
u64 route;
|
||||||
|
|
||||||
if (type != TB_CFG_PKG_EVENT) {
|
if (type != TB_CFG_PKG_EVENT) {
|
||||||
|
@ -336,40 +603,59 @@ static void tb_handle_event(struct tb *tb, enum tb_cfg_pkg_type type,
|
||||||
pkg->port);
|
pkg->port);
|
||||||
}
|
}
|
||||||
|
|
||||||
ev = kmalloc(sizeof(*ev), GFP_KERNEL);
|
tb_queue_hotplug(tb, route, pkg->port, pkg->unplug);
|
||||||
if (!ev)
|
|
||||||
return;
|
|
||||||
INIT_WORK(&ev->work, tb_handle_hotplug);
|
|
||||||
ev->tb = tb;
|
|
||||||
ev->route = route;
|
|
||||||
ev->port = pkg->port;
|
|
||||||
ev->unplug = pkg->unplug;
|
|
||||||
queue_work(tb->wq, &ev->work);
|
|
||||||
}
|
}
|
||||||
|
|
||||||
static void tb_stop(struct tb *tb)
|
static void tb_stop(struct tb *tb)
|
||||||
{
|
{
|
||||||
struct tb_cm *tcm = tb_priv(tb);
|
struct tb_cm *tcm = tb_priv(tb);
|
||||||
struct tb_pci_tunnel *tunnel;
|
struct tb_tunnel *tunnel;
|
||||||
struct tb_pci_tunnel *n;
|
struct tb_tunnel *n;
|
||||||
|
|
||||||
/* tunnels are only present after everything has been initialized */
|
/* tunnels are only present after everything has been initialized */
|
||||||
list_for_each_entry_safe(tunnel, n, &tcm->tunnel_list, list) {
|
list_for_each_entry_safe(tunnel, n, &tcm->tunnel_list, list) {
|
||||||
tb_pci_deactivate(tunnel);
|
/*
|
||||||
tb_pci_free(tunnel);
|
* 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);
|
||||||
|
tb_tunnel_free(tunnel);
|
||||||
}
|
}
|
||||||
tb_switch_remove(tb->root_switch);
|
tb_switch_remove(tb->root_switch);
|
||||||
tcm->hotplug_active = false; /* signal tb_handle_hotplug to quit */
|
tcm->hotplug_active = false; /* signal tb_handle_hotplug to quit */
|
||||||
}
|
}
|
||||||
|
|
||||||
|
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;
|
||||||
|
}
|
||||||
|
|
||||||
static int tb_start(struct tb *tb)
|
static int tb_start(struct tb *tb)
|
||||||
{
|
{
|
||||||
struct tb_cm *tcm = tb_priv(tb);
|
struct tb_cm *tcm = tb_priv(tb);
|
||||||
int ret;
|
int ret;
|
||||||
|
|
||||||
tb->root_switch = tb_switch_alloc(tb, &tb->dev, 0);
|
tb->root_switch = tb_switch_alloc(tb, &tb->dev, 0);
|
||||||
if (!tb->root_switch)
|
if (IS_ERR(tb->root_switch))
|
||||||
return -ENOMEM;
|
return PTR_ERR(tb->root_switch);
|
||||||
|
|
||||||
/*
|
/*
|
||||||
* ICM firmware upgrade needs running firmware and in native
|
* ICM firmware upgrade needs running firmware and in native
|
||||||
|
@ -393,7 +679,11 @@ static int tb_start(struct tb *tb)
|
||||||
|
|
||||||
/* Full scan to discover devices added before the driver was loaded. */
|
/* Full scan to discover devices added before the driver was loaded. */
|
||||||
tb_scan_switch(tb->root_switch);
|
tb_scan_switch(tb->root_switch);
|
||||||
tb_activate_pcie_devices(tb);
|
/* Find out tunnels created by the boot firmware */
|
||||||
|
tb_discover_tunnels(tb->root_switch);
|
||||||
|
/* Make the discovered switches available to the userspace */
|
||||||
|
device_for_each_child(&tb->root_switch->dev, NULL,
|
||||||
|
tb_scan_finalize_switch);
|
||||||
|
|
||||||
/* Allow tb_handle_hotplug to progress events */
|
/* Allow tb_handle_hotplug to progress events */
|
||||||
tcm->hotplug_active = true;
|
tcm->hotplug_active = true;
|
||||||
|
@ -415,7 +705,7 @@ static int tb_suspend_noirq(struct tb *tb)
|
||||||
static int tb_resume_noirq(struct tb *tb)
|
static int tb_resume_noirq(struct tb *tb)
|
||||||
{
|
{
|
||||||
struct tb_cm *tcm = tb_priv(tb);
|
struct tb_cm *tcm = tb_priv(tb);
|
||||||
struct tb_pci_tunnel *tunnel, *n;
|
struct tb_tunnel *tunnel, *n;
|
||||||
|
|
||||||
tb_dbg(tb, "resuming...\n");
|
tb_dbg(tb, "resuming...\n");
|
||||||
|
|
||||||
|
@ -426,7 +716,7 @@ static int tb_resume_noirq(struct tb *tb)
|
||||||
tb_free_invalid_tunnels(tb);
|
tb_free_invalid_tunnels(tb);
|
||||||
tb_free_unplugged_children(tb->root_switch);
|
tb_free_unplugged_children(tb->root_switch);
|
||||||
list_for_each_entry_safe(tunnel, n, &tcm->tunnel_list, list)
|
list_for_each_entry_safe(tunnel, n, &tcm->tunnel_list, list)
|
||||||
tb_pci_restart(tunnel);
|
tb_tunnel_restart(tunnel);
|
||||||
if (!list_empty(&tcm->tunnel_list)) {
|
if (!list_empty(&tcm->tunnel_list)) {
|
||||||
/*
|
/*
|
||||||
* the pcie links need some time to get going.
|
* the pcie links need some time to get going.
|
||||||
|
@ -442,12 +732,50 @@ static int tb_resume_noirq(struct tb *tb)
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
static int tb_free_unplugged_xdomains(struct tb_switch *sw)
|
||||||
|
{
|
||||||
|
int i, ret = 0;
|
||||||
|
|
||||||
|
for (i = 1; i <= sw->config.max_port_number; i++) {
|
||||||
|
struct tb_port *port = &sw->ports[i];
|
||||||
|
|
||||||
|
if (tb_is_upstream_port(port))
|
||||||
|
continue;
|
||||||
|
if (port->xdomain && port->xdomain->is_unplugged) {
|
||||||
|
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);
|
||||||
|
}
|
||||||
|
|
||||||
static const struct tb_cm_ops tb_cm_ops = {
|
static const struct tb_cm_ops tb_cm_ops = {
|
||||||
.start = tb_start,
|
.start = tb_start,
|
||||||
.stop = tb_stop,
|
.stop = tb_stop,
|
||||||
.suspend_noirq = tb_suspend_noirq,
|
.suspend_noirq = tb_suspend_noirq,
|
||||||
.resume_noirq = tb_resume_noirq,
|
.resume_noirq = tb_resume_noirq,
|
||||||
|
.complete = tb_complete,
|
||||||
.handle_event = tb_handle_event,
|
.handle_event = tb_handle_event,
|
||||||
|
.approve_switch = tb_tunnel_pci,
|
||||||
|
.approve_xdomain_paths = tb_approve_xdomain_paths,
|
||||||
|
.disconnect_xdomain_paths = tb_disconnect_xdomain_paths,
|
||||||
};
|
};
|
||||||
|
|
||||||
struct tb *tb_probe(struct tb_nhi *nhi)
|
struct tb *tb_probe(struct tb_nhi *nhi)
|
||||||
|
@ -462,7 +790,7 @@ struct tb *tb_probe(struct tb_nhi *nhi)
|
||||||
if (!tb)
|
if (!tb)
|
||||||
return NULL;
|
return NULL;
|
||||||
|
|
||||||
tb->security_level = TB_SECURITY_NONE;
|
tb->security_level = TB_SECURITY_USER;
|
||||||
tb->cm_ops = &tb_cm_ops;
|
tb->cm_ops = &tb_cm_ops;
|
||||||
|
|
||||||
tcm = tb_priv(tb);
|
tcm = tb_priv(tb);
|
||||||
|
|
|
@ -43,6 +43,7 @@ struct tb_switch_nvm {
|
||||||
};
|
};
|
||||||
|
|
||||||
#define TB_SWITCH_KEY_SIZE 32
|
#define TB_SWITCH_KEY_SIZE 32
|
||||||
|
#define TB_SWITCH_MAX_DEPTH 6
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* struct tb_switch - a thunderbolt switch
|
* struct tb_switch - a thunderbolt switch
|
||||||
|
@ -62,6 +63,7 @@ struct tb_switch_nvm {
|
||||||
* @device_name: Name of the device (or %NULL if not known)
|
* @device_name: Name of the device (or %NULL if not known)
|
||||||
* @generation: Switch Thunderbolt generation
|
* @generation: Switch Thunderbolt generation
|
||||||
* @cap_plug_events: Offset to the plug events capability (%0 if not found)
|
* @cap_plug_events: Offset to the plug events capability (%0 if not found)
|
||||||
|
* @cap_lc: Offset to the link controller capability (%0 if not found)
|
||||||
* @is_unplugged: The switch is going away
|
* @is_unplugged: The switch is going away
|
||||||
* @drom: DROM of the switch (%NULL if not found)
|
* @drom: DROM of the switch (%NULL if not found)
|
||||||
* @nvm: Pointer to the NVM if the switch has one (%NULL otherwise)
|
* @nvm: Pointer to the NVM if the switch has one (%NULL otherwise)
|
||||||
|
@ -70,7 +72,6 @@ struct tb_switch_nvm {
|
||||||
* @boot: Whether the switch was already authorized on boot or not
|
* @boot: Whether the switch was already authorized on boot or not
|
||||||
* @rpm: The switch supports runtime PM
|
* @rpm: The switch supports runtime PM
|
||||||
* @authorized: Whether the switch is authorized by user or policy
|
* @authorized: Whether the switch is authorized by user or policy
|
||||||
* @work: Work used to automatically authorize a switch
|
|
||||||
* @security_level: Switch supported security level
|
* @security_level: Switch supported security level
|
||||||
* @key: Contains the key used to challenge the device or %NULL if not
|
* @key: Contains the key used to challenge the device or %NULL if not
|
||||||
* supported. Size of the key is %TB_SWITCH_KEY_SIZE.
|
* supported. Size of the key is %TB_SWITCH_KEY_SIZE.
|
||||||
|
@ -80,8 +81,7 @@ struct tb_switch_nvm {
|
||||||
* @depth: Depth in the chain this switch is connected (ICM only)
|
* @depth: Depth in the chain this switch is connected (ICM only)
|
||||||
*
|
*
|
||||||
* When the switch is being added or removed to the domain (other
|
* When the switch is being added or removed to the domain (other
|
||||||
* switches) you need to have domain lock held. For switch authorization
|
* switches) you need to have domain lock held.
|
||||||
* internal switch_lock is enough.
|
|
||||||
*/
|
*/
|
||||||
struct tb_switch {
|
struct tb_switch {
|
||||||
struct device dev;
|
struct device dev;
|
||||||
|
@ -97,6 +97,7 @@ struct tb_switch {
|
||||||
const char *device_name;
|
const char *device_name;
|
||||||
unsigned int generation;
|
unsigned int generation;
|
||||||
int cap_plug_events;
|
int cap_plug_events;
|
||||||
|
int cap_lc;
|
||||||
bool is_unplugged;
|
bool is_unplugged;
|
||||||
u8 *drom;
|
u8 *drom;
|
||||||
struct tb_switch_nvm *nvm;
|
struct tb_switch_nvm *nvm;
|
||||||
|
@ -105,7 +106,6 @@ struct tb_switch {
|
||||||
bool boot;
|
bool boot;
|
||||||
bool rpm;
|
bool rpm;
|
||||||
unsigned int authorized;
|
unsigned int authorized;
|
||||||
struct work_struct work;
|
|
||||||
enum tb_security_level security_level;
|
enum tb_security_level security_level;
|
||||||
u8 *key;
|
u8 *key;
|
||||||
u8 connection_id;
|
u8 connection_id;
|
||||||
|
@ -121,11 +121,14 @@ struct tb_switch {
|
||||||
* @remote: Remote port (%NULL if not connected)
|
* @remote: Remote port (%NULL if not connected)
|
||||||
* @xdomain: Remote host (%NULL if not connected)
|
* @xdomain: Remote host (%NULL if not connected)
|
||||||
* @cap_phy: Offset, zero if not found
|
* @cap_phy: Offset, zero if not found
|
||||||
|
* @cap_adap: Offset of the adapter specific capability (%0 if not present)
|
||||||
* @port: Port number on switch
|
* @port: Port number on switch
|
||||||
* @disabled: Disabled by eeprom
|
* @disabled: Disabled by eeprom
|
||||||
* @dual_link_port: If the switch is connected using two ports, points
|
* @dual_link_port: If the switch is connected using two ports, points
|
||||||
* to the other port.
|
* to the other port.
|
||||||
* @link_nr: Is this primary or secondary port on the dual_link.
|
* @link_nr: Is this primary or secondary port on the dual_link.
|
||||||
|
* @in_hopids: Currently allocated input HopIDs
|
||||||
|
* @out_hopids: Currently allocated output HopIDs
|
||||||
*/
|
*/
|
||||||
struct tb_port {
|
struct tb_port {
|
||||||
struct tb_regs_port_header config;
|
struct tb_regs_port_header config;
|
||||||
|
@ -133,19 +136,35 @@ struct tb_port {
|
||||||
struct tb_port *remote;
|
struct tb_port *remote;
|
||||||
struct tb_xdomain *xdomain;
|
struct tb_xdomain *xdomain;
|
||||||
int cap_phy;
|
int cap_phy;
|
||||||
|
int cap_adap;
|
||||||
u8 port;
|
u8 port;
|
||||||
bool disabled;
|
bool disabled;
|
||||||
struct tb_port *dual_link_port;
|
struct tb_port *dual_link_port;
|
||||||
u8 link_nr:1;
|
u8 link_nr:1;
|
||||||
|
struct ida in_hopids;
|
||||||
|
struct ida out_hopids;
|
||||||
};
|
};
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* struct tb_path_hop - routing information for a tb_path
|
* struct tb_path_hop - routing information for a tb_path
|
||||||
|
* @in_port: Ingress port of a switch
|
||||||
|
* @out_port: Egress port of a switch where the packet is routed out
|
||||||
|
* (must be on the same switch than @in_port)
|
||||||
|
* @in_hop_index: HopID where the path configuration entry is placed in
|
||||||
|
* the path config space of @in_port.
|
||||||
|
* @in_counter_index: Used counter index (not used in the driver
|
||||||
|
* currently, %-1 to disable)
|
||||||
|
* @next_hop_index: HopID of the packet when it is routed out from @out_port
|
||||||
|
* @initial_credits: Number of initial flow control credits allocated for
|
||||||
|
* the path
|
||||||
*
|
*
|
||||||
* Hop configuration is always done on the IN port of a switch.
|
* Hop configuration is always done on the IN port of a switch.
|
||||||
* in_port and out_port have to be on the same switch. Packets arriving on
|
* in_port and out_port have to be on the same switch. Packets arriving on
|
||||||
* in_port with "hop" = in_hop_index will get routed to through out_port. The
|
* in_port with "hop" = in_hop_index will get routed to through out_port. The
|
||||||
* next hop to take (on out_port->remote) is determined by next_hop_index.
|
* next hop to take (on out_port->remote) is determined by
|
||||||
|
* next_hop_index. When routing packet to another switch (out->remote is
|
||||||
|
* set) the @next_hop_index must match the @in_hop_index of that next
|
||||||
|
* hop to make routing possible.
|
||||||
*
|
*
|
||||||
* in_counter_index is the index of a counter (in TB_CFG_COUNTERS) on the in
|
* in_counter_index is the index of a counter (in TB_CFG_COUNTERS) on the in
|
||||||
* port.
|
* port.
|
||||||
|
@ -154,44 +173,71 @@ struct tb_path_hop {
|
||||||
struct tb_port *in_port;
|
struct tb_port *in_port;
|
||||||
struct tb_port *out_port;
|
struct tb_port *out_port;
|
||||||
int in_hop_index;
|
int in_hop_index;
|
||||||
int in_counter_index; /* write -1 to disable counters for this hop. */
|
int in_counter_index;
|
||||||
int next_hop_index;
|
int next_hop_index;
|
||||||
|
unsigned int initial_credits;
|
||||||
};
|
};
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* enum tb_path_port - path options mask
|
* enum tb_path_port - path options mask
|
||||||
|
* @TB_PATH_NONE: Do not activate on any hop on path
|
||||||
|
* @TB_PATH_SOURCE: Activate on the first hop (out of src)
|
||||||
|
* @TB_PATH_INTERNAL: Activate on the intermediate hops (not the first/last)
|
||||||
|
* @TB_PATH_DESTINATION: Activate on the last hop (into dst)
|
||||||
|
* @TB_PATH_ALL: Activate on all hops on the path
|
||||||
*/
|
*/
|
||||||
enum tb_path_port {
|
enum tb_path_port {
|
||||||
TB_PATH_NONE = 0,
|
TB_PATH_NONE = 0,
|
||||||
TB_PATH_SOURCE = 1, /* activate on the first hop (out of src) */
|
TB_PATH_SOURCE = 1,
|
||||||
TB_PATH_INTERNAL = 2, /* activate on other hops (not the first/last) */
|
TB_PATH_INTERNAL = 2,
|
||||||
TB_PATH_DESTINATION = 4, /* activate on the last hop (into dst) */
|
TB_PATH_DESTINATION = 4,
|
||||||
TB_PATH_ALL = 7,
|
TB_PATH_ALL = 7,
|
||||||
};
|
};
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* struct tb_path - a unidirectional path between two ports
|
* struct tb_path - a unidirectional path between two ports
|
||||||
|
* @tb: Pointer to the domain structure
|
||||||
|
* @name: Name of the path (used for debugging)
|
||||||
|
* @nfc_credits: Number of non flow controlled credits allocated for the path
|
||||||
|
* @ingress_shared_buffer: Shared buffering used for ingress ports on the path
|
||||||
|
* @egress_shared_buffer: Shared buffering used for egress ports on the path
|
||||||
|
* @ingress_fc_enable: Flow control for ingress ports on the path
|
||||||
|
* @egress_fc_enable: Flow control for egress ports on the path
|
||||||
|
* @priority: Priority group if the path
|
||||||
|
* @weight: Weight of the path inside the priority group
|
||||||
|
* @drop_packages: Drop packages from queue tail or head
|
||||||
|
* @activated: Is the path active
|
||||||
|
* @clear_fc: Clear all flow control from the path config space entries
|
||||||
|
* when deactivating this path
|
||||||
|
* @hops: Path hops
|
||||||
|
* @path_length: How many hops the path uses
|
||||||
*
|
*
|
||||||
* A path consists of a number of hops (see tb_path_hop). To establish a PCIe
|
* A path consists of a number of hops (see &struct tb_path_hop). To
|
||||||
* tunnel two paths have to be created between the two PCIe ports.
|
* establish a PCIe tunnel two paths have to be created between the two
|
||||||
*
|
* PCIe ports.
|
||||||
*/
|
*/
|
||||||
struct tb_path {
|
struct tb_path {
|
||||||
struct tb *tb;
|
struct tb *tb;
|
||||||
int nfc_credits; /* non flow controlled credits */
|
const char *name;
|
||||||
|
int nfc_credits;
|
||||||
enum tb_path_port ingress_shared_buffer;
|
enum tb_path_port ingress_shared_buffer;
|
||||||
enum tb_path_port egress_shared_buffer;
|
enum tb_path_port egress_shared_buffer;
|
||||||
enum tb_path_port ingress_fc_enable;
|
enum tb_path_port ingress_fc_enable;
|
||||||
enum tb_path_port egress_fc_enable;
|
enum tb_path_port egress_fc_enable;
|
||||||
|
|
||||||
int priority:3;
|
unsigned int priority:3;
|
||||||
int weight:4;
|
int weight:4;
|
||||||
bool drop_packages;
|
bool drop_packages;
|
||||||
bool activated;
|
bool activated;
|
||||||
|
bool clear_fc;
|
||||||
struct tb_path_hop *hops;
|
struct tb_path_hop *hops;
|
||||||
int path_length; /* number of hops */
|
int path_length;
|
||||||
};
|
};
|
||||||
|
|
||||||
|
/* HopIDs 0-7 are reserved by the Thunderbolt protocol */
|
||||||
|
#define TB_PATH_MIN_HOPID 8
|
||||||
|
#define TB_PATH_MAX_HOPS 7
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* struct tb_cm_ops - Connection manager specific operations vector
|
* struct tb_cm_ops - Connection manager specific operations vector
|
||||||
* @driver_ready: Called right after control channel is started. Used by
|
* @driver_ready: Called right after control channel is started. Used by
|
||||||
|
@ -261,7 +307,20 @@ static inline struct tb_port *tb_upstream_port(struct tb_switch *sw)
|
||||||
return &sw->ports[sw->config.upstream_port_number];
|
return &sw->ports[sw->config.upstream_port_number];
|
||||||
}
|
}
|
||||||
|
|
||||||
static inline u64 tb_route(struct tb_switch *sw)
|
/**
|
||||||
|
* tb_is_upstream_port() - Is the port upstream facing
|
||||||
|
* @port: Port to check
|
||||||
|
*
|
||||||
|
* Returns true if @port is upstream facing port. In case of dual link
|
||||||
|
* ports both return true.
|
||||||
|
*/
|
||||||
|
static inline bool tb_is_upstream_port(const struct tb_port *port)
|
||||||
|
{
|
||||||
|
const struct tb_port *upstream_port = tb_upstream_port(port->sw);
|
||||||
|
return port == upstream_port || port->dual_link_port == upstream_port;
|
||||||
|
}
|
||||||
|
|
||||||
|
static inline u64 tb_route(const struct tb_switch *sw)
|
||||||
{
|
{
|
||||||
return ((u64) sw->config.route_hi) << 32 | sw->config.route_lo;
|
return ((u64) sw->config.route_hi) << 32 | sw->config.route_lo;
|
||||||
}
|
}
|
||||||
|
@ -276,9 +335,54 @@ static inline struct tb_port *tb_port_at(u64 route, struct tb_switch *sw)
|
||||||
return &sw->ports[port];
|
return &sw->ports[port];
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* tb_port_has_remote() - Does the port have switch connected downstream
|
||||||
|
* @port: Port to check
|
||||||
|
*
|
||||||
|
* Returns true only when the port is primary port and has remote set.
|
||||||
|
*/
|
||||||
|
static inline bool tb_port_has_remote(const struct tb_port *port)
|
||||||
|
{
|
||||||
|
if (tb_is_upstream_port(port))
|
||||||
|
return false;
|
||||||
|
if (!port->remote)
|
||||||
|
return false;
|
||||||
|
if (port->dual_link_port && port->link_nr)
|
||||||
|
return false;
|
||||||
|
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
static inline bool tb_port_is_null(const struct tb_port *port)
|
||||||
|
{
|
||||||
|
return port && port->port && port->config.type == TB_TYPE_PORT;
|
||||||
|
}
|
||||||
|
|
||||||
|
static inline bool tb_port_is_pcie_down(const struct tb_port *port)
|
||||||
|
{
|
||||||
|
return port && port->config.type == TB_TYPE_PCIE_DOWN;
|
||||||
|
}
|
||||||
|
|
||||||
|
static inline bool tb_port_is_pcie_up(const struct tb_port *port)
|
||||||
|
{
|
||||||
|
return port && port->config.type == TB_TYPE_PCIE_UP;
|
||||||
|
}
|
||||||
|
|
||||||
|
static inline bool tb_port_is_dpin(const struct tb_port *port)
|
||||||
|
{
|
||||||
|
return port && port->config.type == TB_TYPE_DP_HDMI_IN;
|
||||||
|
}
|
||||||
|
|
||||||
|
static inline bool tb_port_is_dpout(const struct tb_port *port)
|
||||||
|
{
|
||||||
|
return port && port->config.type == TB_TYPE_DP_HDMI_OUT;
|
||||||
|
}
|
||||||
|
|
||||||
static inline int tb_sw_read(struct tb_switch *sw, void *buffer,
|
static inline int tb_sw_read(struct tb_switch *sw, void *buffer,
|
||||||
enum tb_cfg_space space, u32 offset, u32 length)
|
enum tb_cfg_space space, u32 offset, u32 length)
|
||||||
{
|
{
|
||||||
|
if (sw->is_unplugged)
|
||||||
|
return -ENODEV;
|
||||||
return tb_cfg_read(sw->tb->ctl,
|
return tb_cfg_read(sw->tb->ctl,
|
||||||
buffer,
|
buffer,
|
||||||
tb_route(sw),
|
tb_route(sw),
|
||||||
|
@ -291,6 +395,8 @@ static inline int tb_sw_read(struct tb_switch *sw, void *buffer,
|
||||||
static inline int tb_sw_write(struct tb_switch *sw, void *buffer,
|
static inline int tb_sw_write(struct tb_switch *sw, void *buffer,
|
||||||
enum tb_cfg_space space, u32 offset, u32 length)
|
enum tb_cfg_space space, u32 offset, u32 length)
|
||||||
{
|
{
|
||||||
|
if (sw->is_unplugged)
|
||||||
|
return -ENODEV;
|
||||||
return tb_cfg_write(sw->tb->ctl,
|
return tb_cfg_write(sw->tb->ctl,
|
||||||
buffer,
|
buffer,
|
||||||
tb_route(sw),
|
tb_route(sw),
|
||||||
|
@ -303,6 +409,8 @@ static inline int tb_sw_write(struct tb_switch *sw, void *buffer,
|
||||||
static inline int tb_port_read(struct tb_port *port, void *buffer,
|
static inline int tb_port_read(struct tb_port *port, void *buffer,
|
||||||
enum tb_cfg_space space, u32 offset, u32 length)
|
enum tb_cfg_space space, u32 offset, u32 length)
|
||||||
{
|
{
|
||||||
|
if (port->sw->is_unplugged)
|
||||||
|
return -ENODEV;
|
||||||
return tb_cfg_read(port->sw->tb->ctl,
|
return tb_cfg_read(port->sw->tb->ctl,
|
||||||
buffer,
|
buffer,
|
||||||
tb_route(port->sw),
|
tb_route(port->sw),
|
||||||
|
@ -315,6 +423,8 @@ static inline int tb_port_read(struct tb_port *port, void *buffer,
|
||||||
static inline int tb_port_write(struct tb_port *port, const void *buffer,
|
static inline int tb_port_write(struct tb_port *port, const void *buffer,
|
||||||
enum tb_cfg_space space, u32 offset, u32 length)
|
enum tb_cfg_space space, u32 offset, u32 length)
|
||||||
{
|
{
|
||||||
|
if (port->sw->is_unplugged)
|
||||||
|
return -ENODEV;
|
||||||
return tb_cfg_write(port->sw->tb->ctl,
|
return tb_cfg_write(port->sw->tb->ctl,
|
||||||
buffer,
|
buffer,
|
||||||
tb_route(port->sw),
|
tb_route(port->sw),
|
||||||
|
@ -332,7 +442,7 @@ static inline int tb_port_write(struct tb_port *port, const void *buffer,
|
||||||
|
|
||||||
#define __TB_SW_PRINT(level, sw, fmt, arg...) \
|
#define __TB_SW_PRINT(level, sw, fmt, arg...) \
|
||||||
do { \
|
do { \
|
||||||
struct tb_switch *__sw = (sw); \
|
const struct tb_switch *__sw = (sw); \
|
||||||
level(__sw->tb, "%llx: " fmt, \
|
level(__sw->tb, "%llx: " fmt, \
|
||||||
tb_route(__sw), ## arg); \
|
tb_route(__sw), ## arg); \
|
||||||
} while (0)
|
} while (0)
|
||||||
|
@ -343,7 +453,7 @@ static inline int tb_port_write(struct tb_port *port, const void *buffer,
|
||||||
|
|
||||||
#define __TB_PORT_PRINT(level, _port, fmt, arg...) \
|
#define __TB_PORT_PRINT(level, _port, fmt, arg...) \
|
||||||
do { \
|
do { \
|
||||||
struct tb_port *__port = (_port); \
|
const struct tb_port *__port = (_port); \
|
||||||
level(__port->sw->tb, "%llx:%x: " fmt, \
|
level(__port->sw->tb, "%llx:%x: " fmt, \
|
||||||
tb_route(__port->sw), __port->port, ## arg); \
|
tb_route(__port->sw), __port->port, ## arg); \
|
||||||
} while (0)
|
} while (0)
|
||||||
|
@ -385,6 +495,13 @@ int tb_domain_approve_xdomain_paths(struct tb *tb, struct tb_xdomain *xd);
|
||||||
int tb_domain_disconnect_xdomain_paths(struct tb *tb, struct tb_xdomain *xd);
|
int tb_domain_disconnect_xdomain_paths(struct tb *tb, struct tb_xdomain *xd);
|
||||||
int tb_domain_disconnect_all_paths(struct tb *tb);
|
int tb_domain_disconnect_all_paths(struct tb *tb);
|
||||||
|
|
||||||
|
static inline struct tb *tb_domain_get(struct tb *tb)
|
||||||
|
{
|
||||||
|
if (tb)
|
||||||
|
get_device(&tb->dev);
|
||||||
|
return tb;
|
||||||
|
}
|
||||||
|
|
||||||
static inline void tb_domain_put(struct tb *tb)
|
static inline void tb_domain_put(struct tb *tb)
|
||||||
{
|
{
|
||||||
put_device(&tb->dev);
|
put_device(&tb->dev);
|
||||||
|
@ -401,7 +518,6 @@ void tb_switch_suspend(struct tb_switch *sw);
|
||||||
int tb_switch_resume(struct tb_switch *sw);
|
int tb_switch_resume(struct tb_switch *sw);
|
||||||
int tb_switch_reset(struct tb *tb, u64 route);
|
int tb_switch_reset(struct tb *tb, u64 route);
|
||||||
void tb_sw_set_unplugged(struct tb_switch *sw);
|
void tb_sw_set_unplugged(struct tb_switch *sw);
|
||||||
struct tb_switch *get_switch_at_route(struct tb_switch *sw, u64 route);
|
|
||||||
struct tb_switch *tb_switch_find_by_link_depth(struct tb *tb, u8 link,
|
struct tb_switch *tb_switch_find_by_link_depth(struct tb *tb, u8 link,
|
||||||
u8 depth);
|
u8 depth);
|
||||||
struct tb_switch *tb_switch_find_by_uuid(struct tb *tb, const uuid_t *uuid);
|
struct tb_switch *tb_switch_find_by_uuid(struct tb *tb, const uuid_t *uuid);
|
||||||
|
@ -431,14 +547,74 @@ static inline struct tb_switch *tb_to_switch(struct device *dev)
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
static inline struct tb_switch *tb_switch_parent(struct tb_switch *sw)
|
||||||
|
{
|
||||||
|
return tb_to_switch(sw->dev.parent);
|
||||||
|
}
|
||||||
|
|
||||||
|
static inline bool tb_switch_is_lr(const struct tb_switch *sw)
|
||||||
|
{
|
||||||
|
return sw->config.device_id == PCI_DEVICE_ID_INTEL_LIGHT_RIDGE;
|
||||||
|
}
|
||||||
|
|
||||||
|
static inline bool tb_switch_is_er(const struct tb_switch *sw)
|
||||||
|
{
|
||||||
|
return sw->config.device_id == PCI_DEVICE_ID_INTEL_EAGLE_RIDGE;
|
||||||
|
}
|
||||||
|
|
||||||
|
static inline bool tb_switch_is_cr(const struct tb_switch *sw)
|
||||||
|
{
|
||||||
|
switch (sw->config.device_id) {
|
||||||
|
case PCI_DEVICE_ID_INTEL_CACTUS_RIDGE_2C:
|
||||||
|
case PCI_DEVICE_ID_INTEL_CACTUS_RIDGE_4C:
|
||||||
|
return true;
|
||||||
|
default:
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
static inline bool tb_switch_is_fr(const struct tb_switch *sw)
|
||||||
|
{
|
||||||
|
switch (sw->config.device_id) {
|
||||||
|
case PCI_DEVICE_ID_INTEL_FALCON_RIDGE_2C_BRIDGE:
|
||||||
|
case PCI_DEVICE_ID_INTEL_FALCON_RIDGE_4C_BRIDGE:
|
||||||
|
return true;
|
||||||
|
default:
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
int tb_wait_for_port(struct tb_port *port, bool wait_if_unplugged);
|
int tb_wait_for_port(struct tb_port *port, bool wait_if_unplugged);
|
||||||
int tb_port_add_nfc_credits(struct tb_port *port, int credits);
|
int tb_port_add_nfc_credits(struct tb_port *port, int credits);
|
||||||
|
int tb_port_set_initial_credits(struct tb_port *port, u32 credits);
|
||||||
int tb_port_clear_counter(struct tb_port *port, int counter);
|
int tb_port_clear_counter(struct tb_port *port, int counter);
|
||||||
|
int tb_port_alloc_in_hopid(struct tb_port *port, int hopid, int max_hopid);
|
||||||
|
void tb_port_release_in_hopid(struct tb_port *port, int hopid);
|
||||||
|
int tb_port_alloc_out_hopid(struct tb_port *port, int hopid, int max_hopid);
|
||||||
|
void tb_port_release_out_hopid(struct tb_port *port, int hopid);
|
||||||
|
struct tb_port *tb_next_port_on_path(struct tb_port *start, struct tb_port *end,
|
||||||
|
struct tb_port *prev);
|
||||||
|
|
||||||
int tb_switch_find_vse_cap(struct tb_switch *sw, enum tb_switch_vse_cap vsec);
|
int tb_switch_find_vse_cap(struct tb_switch *sw, enum tb_switch_vse_cap vsec);
|
||||||
int tb_port_find_cap(struct tb_port *port, enum tb_port_cap cap);
|
int tb_port_find_cap(struct tb_port *port, enum tb_port_cap cap);
|
||||||
|
bool tb_port_is_enabled(struct tb_port *port);
|
||||||
|
|
||||||
struct tb_path *tb_path_alloc(struct tb *tb, int num_hops);
|
bool tb_pci_port_is_enabled(struct tb_port *port);
|
||||||
|
int tb_pci_port_enable(struct tb_port *port, bool enable);
|
||||||
|
|
||||||
|
int tb_dp_port_hpd_is_active(struct tb_port *port);
|
||||||
|
int tb_dp_port_hpd_clear(struct tb_port *port);
|
||||||
|
int tb_dp_port_set_hops(struct tb_port *port, unsigned int video,
|
||||||
|
unsigned int aux_tx, unsigned int aux_rx);
|
||||||
|
bool tb_dp_port_is_enabled(struct tb_port *port);
|
||||||
|
int tb_dp_port_enable(struct tb_port *port, bool enable);
|
||||||
|
|
||||||
|
struct tb_path *tb_path_discover(struct tb_port *src, int src_hopid,
|
||||||
|
struct tb_port *dst, int dst_hopid,
|
||||||
|
struct tb_port **last, const char *name);
|
||||||
|
struct tb_path *tb_path_alloc(struct tb *tb, struct tb_port *src, int src_hopid,
|
||||||
|
struct tb_port *dst, int dst_hopid, int link_nr,
|
||||||
|
const char *name);
|
||||||
void tb_path_free(struct tb_path *path);
|
void tb_path_free(struct tb_path *path);
|
||||||
int tb_path_activate(struct tb_path *path);
|
int tb_path_activate(struct tb_path *path);
|
||||||
void tb_path_deactivate(struct tb_path *path);
|
void tb_path_deactivate(struct tb_path *path);
|
||||||
|
@ -447,17 +623,16 @@ bool tb_path_is_invalid(struct tb_path *path);
|
||||||
int tb_drom_read(struct tb_switch *sw);
|
int tb_drom_read(struct tb_switch *sw);
|
||||||
int tb_drom_read_uid_only(struct tb_switch *sw, u64 *uid);
|
int tb_drom_read_uid_only(struct tb_switch *sw, u64 *uid);
|
||||||
|
|
||||||
|
int tb_lc_read_uuid(struct tb_switch *sw, u32 *uuid);
|
||||||
|
int tb_lc_configure_link(struct tb_switch *sw);
|
||||||
|
void tb_lc_unconfigure_link(struct tb_switch *sw);
|
||||||
|
int tb_lc_set_sleep(struct tb_switch *sw);
|
||||||
|
|
||||||
static inline int tb_route_length(u64 route)
|
static inline int tb_route_length(u64 route)
|
||||||
{
|
{
|
||||||
return (fls64(route) + TB_ROUTE_SHIFT - 1) / TB_ROUTE_SHIFT;
|
return (fls64(route) + TB_ROUTE_SHIFT - 1) / TB_ROUTE_SHIFT;
|
||||||
}
|
}
|
||||||
|
|
||||||
static inline bool tb_is_upstream_port(struct tb_port *port)
|
|
||||||
{
|
|
||||||
return port == tb_upstream_port(port->sw);
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* tb_downstream_route() - get route to downstream switch
|
* tb_downstream_route() - get route to downstream switch
|
||||||
*
|
*
|
||||||
|
|
|
@ -492,6 +492,17 @@ struct tb_xdp_header {
|
||||||
u32 type;
|
u32 type;
|
||||||
};
|
};
|
||||||
|
|
||||||
|
struct tb_xdp_uuid {
|
||||||
|
struct tb_xdp_header hdr;
|
||||||
|
};
|
||||||
|
|
||||||
|
struct tb_xdp_uuid_response {
|
||||||
|
struct tb_xdp_header hdr;
|
||||||
|
uuid_t src_uuid;
|
||||||
|
u32 src_route_hi;
|
||||||
|
u32 src_route_lo;
|
||||||
|
};
|
||||||
|
|
||||||
struct tb_xdp_properties {
|
struct tb_xdp_properties {
|
||||||
struct tb_xdp_header hdr;
|
struct tb_xdp_header hdr;
|
||||||
uuid_t src_uuid;
|
uuid_t src_uuid;
|
||||||
|
|
|
@ -211,6 +211,38 @@ struct tb_regs_port_header {
|
||||||
|
|
||||||
} __packed;
|
} __packed;
|
||||||
|
|
||||||
|
/* DWORD 4 */
|
||||||
|
#define TB_PORT_NFC_CREDITS_MASK GENMASK(19, 0)
|
||||||
|
#define TB_PORT_MAX_CREDITS_SHIFT 20
|
||||||
|
#define TB_PORT_MAX_CREDITS_MASK GENMASK(26, 20)
|
||||||
|
/* DWORD 5 */
|
||||||
|
#define TB_PORT_LCA_SHIFT 22
|
||||||
|
#define TB_PORT_LCA_MASK GENMASK(28, 22)
|
||||||
|
|
||||||
|
/* Display Port adapter registers */
|
||||||
|
|
||||||
|
/* DWORD 0 */
|
||||||
|
#define TB_DP_VIDEO_HOPID_SHIFT 16
|
||||||
|
#define TB_DP_VIDEO_HOPID_MASK GENMASK(26, 16)
|
||||||
|
#define TB_DP_AUX_EN BIT(30)
|
||||||
|
#define TB_DP_VIDEO_EN BIT(31)
|
||||||
|
/* DWORD 1 */
|
||||||
|
#define TB_DP_AUX_TX_HOPID_MASK GENMASK(10, 0)
|
||||||
|
#define TB_DP_AUX_RX_HOPID_SHIFT 11
|
||||||
|
#define TB_DP_AUX_RX_HOPID_MASK GENMASK(21, 11)
|
||||||
|
/* DWORD 2 */
|
||||||
|
#define TB_DP_HDP BIT(6)
|
||||||
|
/* DWORD 3 */
|
||||||
|
#define TB_DP_HPDC BIT(9)
|
||||||
|
/* DWORD 4 */
|
||||||
|
#define TB_DP_LOCAL_CAP 0x4
|
||||||
|
/* DWORD 5 */
|
||||||
|
#define TB_DP_REMOTE_CAP 0x5
|
||||||
|
|
||||||
|
/* PCIe adapter registers */
|
||||||
|
|
||||||
|
#define TB_PCI_EN BIT(31)
|
||||||
|
|
||||||
/* Hop register from TB_CFG_HOPS. 8 byte per entry. */
|
/* Hop register from TB_CFG_HOPS. 8 byte per entry. */
|
||||||
struct tb_regs_hop {
|
struct tb_regs_hop {
|
||||||
/* DWORD 0 */
|
/* DWORD 0 */
|
||||||
|
@ -234,8 +266,24 @@ struct tb_regs_hop {
|
||||||
bool egress_fc:1;
|
bool egress_fc:1;
|
||||||
bool ingress_shared_buffer:1;
|
bool ingress_shared_buffer:1;
|
||||||
bool egress_shared_buffer:1;
|
bool egress_shared_buffer:1;
|
||||||
u32 unknown3:4; /* set to zero */
|
bool pending:1;
|
||||||
|
u32 unknown3:3; /* set to zero */
|
||||||
} __packed;
|
} __packed;
|
||||||
|
|
||||||
|
/* Common link controller registers */
|
||||||
|
#define TB_LC_DESC 0x02
|
||||||
|
#define TB_LC_DESC_NLC_MASK GENMASK(3, 0)
|
||||||
|
#define TB_LC_DESC_SIZE_SHIFT 8
|
||||||
|
#define TB_LC_DESC_SIZE_MASK GENMASK(15, 8)
|
||||||
|
#define TB_LC_DESC_PORT_SIZE_SHIFT 16
|
||||||
|
#define TB_LC_DESC_PORT_SIZE_MASK GENMASK(27, 16)
|
||||||
|
#define TB_LC_FUSE 0x03
|
||||||
|
|
||||||
|
/* Link controller registers */
|
||||||
|
#define TB_LC_SX_CTRL 0x96
|
||||||
|
#define TB_LC_SX_CTRL_L1C BIT(16)
|
||||||
|
#define TB_LC_SX_CTRL_L2C BIT(20)
|
||||||
|
#define TB_LC_SX_CTRL_UPSTREAM BIT(30)
|
||||||
|
#define TB_LC_SX_CTRL_SLP BIT(31)
|
||||||
|
|
||||||
#endif
|
#endif
|
||||||
|
|
691
drivers/thunderbolt/tunnel.c
Normal file
691
drivers/thunderbolt/tunnel.c
Normal file
|
@ -0,0 +1,691 @@
|
||||||
|
// SPDX-License-Identifier: GPL-2.0
|
||||||
|
/*
|
||||||
|
* Thunderbolt driver - Tunneling support
|
||||||
|
*
|
||||||
|
* Copyright (c) 2014 Andreas Noever <andreas.noever@gmail.com>
|
||||||
|
* Copyright (C) 2019, Intel Corporation
|
||||||
|
*/
|
||||||
|
|
||||||
|
#include <linux/slab.h>
|
||||||
|
#include <linux/list.h>
|
||||||
|
|
||||||
|
#include "tunnel.h"
|
||||||
|
#include "tb.h"
|
||||||
|
|
||||||
|
/* PCIe adapters use always HopID of 8 for both directions */
|
||||||
|
#define TB_PCI_HOPID 8
|
||||||
|
|
||||||
|
#define TB_PCI_PATH_DOWN 0
|
||||||
|
#define TB_PCI_PATH_UP 1
|
||||||
|
|
||||||
|
/* DP adapters use HopID 8 for AUX and 9 for Video */
|
||||||
|
#define TB_DP_AUX_TX_HOPID 8
|
||||||
|
#define TB_DP_AUX_RX_HOPID 8
|
||||||
|
#define TB_DP_VIDEO_HOPID 9
|
||||||
|
|
||||||
|
#define TB_DP_VIDEO_PATH_OUT 0
|
||||||
|
#define TB_DP_AUX_PATH_OUT 1
|
||||||
|
#define TB_DP_AUX_PATH_IN 2
|
||||||
|
|
||||||
|
#define TB_DMA_PATH_OUT 0
|
||||||
|
#define TB_DMA_PATH_IN 1
|
||||||
|
|
||||||
|
static const char * const tb_tunnel_names[] = { "PCI", "DP", "DMA" };
|
||||||
|
|
||||||
|
#define __TB_TUNNEL_PRINT(level, tunnel, fmt, arg...) \
|
||||||
|
do { \
|
||||||
|
struct tb_tunnel *__tunnel = (tunnel); \
|
||||||
|
level(__tunnel->tb, "%llx:%x <-> %llx:%x (%s): " fmt, \
|
||||||
|
tb_route(__tunnel->src_port->sw), \
|
||||||
|
__tunnel->src_port->port, \
|
||||||
|
tb_route(__tunnel->dst_port->sw), \
|
||||||
|
__tunnel->dst_port->port, \
|
||||||
|
tb_tunnel_names[__tunnel->type], \
|
||||||
|
## arg); \
|
||||||
|
} while (0)
|
||||||
|
|
||||||
|
#define tb_tunnel_WARN(tunnel, fmt, arg...) \
|
||||||
|
__TB_TUNNEL_PRINT(tb_WARN, tunnel, fmt, ##arg)
|
||||||
|
#define tb_tunnel_warn(tunnel, fmt, arg...) \
|
||||||
|
__TB_TUNNEL_PRINT(tb_warn, tunnel, fmt, ##arg)
|
||||||
|
#define tb_tunnel_info(tunnel, fmt, arg...) \
|
||||||
|
__TB_TUNNEL_PRINT(tb_info, tunnel, fmt, ##arg)
|
||||||
|
#define tb_tunnel_dbg(tunnel, fmt, arg...) \
|
||||||
|
__TB_TUNNEL_PRINT(tb_dbg, tunnel, fmt, ##arg)
|
||||||
|
|
||||||
|
static struct tb_tunnel *tb_tunnel_alloc(struct tb *tb, size_t npaths,
|
||||||
|
enum tb_tunnel_type type)
|
||||||
|
{
|
||||||
|
struct tb_tunnel *tunnel;
|
||||||
|
|
||||||
|
tunnel = kzalloc(sizeof(*tunnel), GFP_KERNEL);
|
||||||
|
if (!tunnel)
|
||||||
|
return NULL;
|
||||||
|
|
||||||
|
tunnel->paths = kcalloc(npaths, sizeof(tunnel->paths[0]), GFP_KERNEL);
|
||||||
|
if (!tunnel->paths) {
|
||||||
|
tb_tunnel_free(tunnel);
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
INIT_LIST_HEAD(&tunnel->list);
|
||||||
|
tunnel->tb = tb;
|
||||||
|
tunnel->npaths = npaths;
|
||||||
|
tunnel->type = type;
|
||||||
|
|
||||||
|
return tunnel;
|
||||||
|
}
|
||||||
|
|
||||||
|
static int tb_pci_activate(struct tb_tunnel *tunnel, bool activate)
|
||||||
|
{
|
||||||
|
int res;
|
||||||
|
|
||||||
|
res = tb_pci_port_enable(tunnel->src_port, activate);
|
||||||
|
if (res)
|
||||||
|
return res;
|
||||||
|
|
||||||
|
if (tb_port_is_pcie_up(tunnel->dst_port))
|
||||||
|
return tb_pci_port_enable(tunnel->dst_port, activate);
|
||||||
|
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void tb_pci_init_path(struct tb_path *path)
|
||||||
|
{
|
||||||
|
path->egress_fc_enable = TB_PATH_SOURCE | TB_PATH_INTERNAL;
|
||||||
|
path->egress_shared_buffer = TB_PATH_NONE;
|
||||||
|
path->ingress_fc_enable = TB_PATH_ALL;
|
||||||
|
path->ingress_shared_buffer = TB_PATH_NONE;
|
||||||
|
path->priority = 3;
|
||||||
|
path->weight = 1;
|
||||||
|
path->drop_packages = 0;
|
||||||
|
path->nfc_credits = 0;
|
||||||
|
path->hops[0].initial_credits = 7;
|
||||||
|
path->hops[1].initial_credits = 16;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* tb_tunnel_discover_pci() - Discover existing PCIe tunnels
|
||||||
|
* @tb: Pointer to the domain structure
|
||||||
|
* @down: PCIe downstream adapter
|
||||||
|
*
|
||||||
|
* If @down adapter is active, follows the tunnel to the PCIe upstream
|
||||||
|
* adapter and back. Returns the discovered tunnel or %NULL if there was
|
||||||
|
* no tunnel.
|
||||||
|
*/
|
||||||
|
struct tb_tunnel *tb_tunnel_discover_pci(struct tb *tb, struct tb_port *down)
|
||||||
|
{
|
||||||
|
struct tb_tunnel *tunnel;
|
||||||
|
struct tb_path *path;
|
||||||
|
|
||||||
|
if (!tb_pci_port_is_enabled(down))
|
||||||
|
return NULL;
|
||||||
|
|
||||||
|
tunnel = tb_tunnel_alloc(tb, 2, TB_TUNNEL_PCI);
|
||||||
|
if (!tunnel)
|
||||||
|
return NULL;
|
||||||
|
|
||||||
|
tunnel->activate = tb_pci_activate;
|
||||||
|
tunnel->src_port = down;
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Discover both paths even if they are not complete. We will
|
||||||
|
* clean them up by calling tb_tunnel_deactivate() below in that
|
||||||
|
* case.
|
||||||
|
*/
|
||||||
|
path = tb_path_discover(down, TB_PCI_HOPID, NULL, -1,
|
||||||
|
&tunnel->dst_port, "PCIe Up");
|
||||||
|
if (!path) {
|
||||||
|
/* Just disable the downstream port */
|
||||||
|
tb_pci_port_enable(down, false);
|
||||||
|
goto err_free;
|
||||||
|
}
|
||||||
|
tunnel->paths[TB_PCI_PATH_UP] = path;
|
||||||
|
tb_pci_init_path(tunnel->paths[TB_PCI_PATH_UP]);
|
||||||
|
|
||||||
|
path = tb_path_discover(tunnel->dst_port, -1, down, TB_PCI_HOPID, NULL,
|
||||||
|
"PCIe Down");
|
||||||
|
if (!path)
|
||||||
|
goto err_deactivate;
|
||||||
|
tunnel->paths[TB_PCI_PATH_DOWN] = path;
|
||||||
|
tb_pci_init_path(tunnel->paths[TB_PCI_PATH_DOWN]);
|
||||||
|
|
||||||
|
/* Validate that the tunnel is complete */
|
||||||
|
if (!tb_port_is_pcie_up(tunnel->dst_port)) {
|
||||||
|
tb_port_warn(tunnel->dst_port,
|
||||||
|
"path does not end on a PCIe adapter, cleaning up\n");
|
||||||
|
goto err_deactivate;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (down != tunnel->src_port) {
|
||||||
|
tb_tunnel_warn(tunnel, "path is not complete, cleaning up\n");
|
||||||
|
goto err_deactivate;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!tb_pci_port_is_enabled(tunnel->dst_port)) {
|
||||||
|
tb_tunnel_warn(tunnel,
|
||||||
|
"tunnel is not fully activated, cleaning up\n");
|
||||||
|
goto err_deactivate;
|
||||||
|
}
|
||||||
|
|
||||||
|
tb_tunnel_dbg(tunnel, "discovered\n");
|
||||||
|
return tunnel;
|
||||||
|
|
||||||
|
err_deactivate:
|
||||||
|
tb_tunnel_deactivate(tunnel);
|
||||||
|
err_free:
|
||||||
|
tb_tunnel_free(tunnel);
|
||||||
|
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* tb_tunnel_alloc_pci() - allocate a pci tunnel
|
||||||
|
* @tb: Pointer to the domain structure
|
||||||
|
* @up: PCIe upstream adapter port
|
||||||
|
* @down: PCIe downstream adapter port
|
||||||
|
*
|
||||||
|
* Allocate a PCI tunnel. The ports must be of type TB_TYPE_PCIE_UP and
|
||||||
|
* TB_TYPE_PCIE_DOWN.
|
||||||
|
*
|
||||||
|
* Return: Returns a tb_tunnel on success or NULL on failure.
|
||||||
|
*/
|
||||||
|
struct tb_tunnel *tb_tunnel_alloc_pci(struct tb *tb, struct tb_port *up,
|
||||||
|
struct tb_port *down)
|
||||||
|
{
|
||||||
|
struct tb_tunnel *tunnel;
|
||||||
|
struct tb_path *path;
|
||||||
|
|
||||||
|
tunnel = tb_tunnel_alloc(tb, 2, TB_TUNNEL_PCI);
|
||||||
|
if (!tunnel)
|
||||||
|
return NULL;
|
||||||
|
|
||||||
|
tunnel->activate = tb_pci_activate;
|
||||||
|
tunnel->src_port = down;
|
||||||
|
tunnel->dst_port = up;
|
||||||
|
|
||||||
|
path = tb_path_alloc(tb, down, TB_PCI_HOPID, up, TB_PCI_HOPID, 0,
|
||||||
|
"PCIe Down");
|
||||||
|
if (!path) {
|
||||||
|
tb_tunnel_free(tunnel);
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
tb_pci_init_path(path);
|
||||||
|
tunnel->paths[TB_PCI_PATH_UP] = path;
|
||||||
|
|
||||||
|
path = tb_path_alloc(tb, up, TB_PCI_HOPID, down, TB_PCI_HOPID, 0,
|
||||||
|
"PCIe Up");
|
||||||
|
if (!path) {
|
||||||
|
tb_tunnel_free(tunnel);
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
tb_pci_init_path(path);
|
||||||
|
tunnel->paths[TB_PCI_PATH_DOWN] = path;
|
||||||
|
|
||||||
|
return tunnel;
|
||||||
|
}
|
||||||
|
|
||||||
|
static int tb_dp_xchg_caps(struct tb_tunnel *tunnel)
|
||||||
|
{
|
||||||
|
struct tb_port *out = tunnel->dst_port;
|
||||||
|
struct tb_port *in = tunnel->src_port;
|
||||||
|
u32 in_dp_cap, out_dp_cap;
|
||||||
|
int ret;
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Copy DP_LOCAL_CAP register to DP_REMOTE_CAP register for
|
||||||
|
* newer generation hardware.
|
||||||
|
*/
|
||||||
|
if (in->sw->generation < 2 || out->sw->generation < 2)
|
||||||
|
return 0;
|
||||||
|
|
||||||
|
/* Read both DP_LOCAL_CAP registers */
|
||||||
|
ret = tb_port_read(in, &in_dp_cap, TB_CFG_PORT,
|
||||||
|
in->cap_adap + TB_DP_LOCAL_CAP, 1);
|
||||||
|
if (ret)
|
||||||
|
return ret;
|
||||||
|
|
||||||
|
ret = tb_port_read(out, &out_dp_cap, TB_CFG_PORT,
|
||||||
|
out->cap_adap + TB_DP_LOCAL_CAP, 1);
|
||||||
|
if (ret)
|
||||||
|
return ret;
|
||||||
|
|
||||||
|
/* Write IN local caps to OUT remote caps */
|
||||||
|
ret = tb_port_write(out, &in_dp_cap, TB_CFG_PORT,
|
||||||
|
out->cap_adap + TB_DP_REMOTE_CAP, 1);
|
||||||
|
if (ret)
|
||||||
|
return ret;
|
||||||
|
|
||||||
|
return tb_port_write(in, &out_dp_cap, TB_CFG_PORT,
|
||||||
|
in->cap_adap + TB_DP_REMOTE_CAP, 1);
|
||||||
|
}
|
||||||
|
|
||||||
|
static int tb_dp_activate(struct tb_tunnel *tunnel, bool active)
|
||||||
|
{
|
||||||
|
int ret;
|
||||||
|
|
||||||
|
if (active) {
|
||||||
|
struct tb_path **paths;
|
||||||
|
int last;
|
||||||
|
|
||||||
|
paths = tunnel->paths;
|
||||||
|
last = paths[TB_DP_VIDEO_PATH_OUT]->path_length - 1;
|
||||||
|
|
||||||
|
tb_dp_port_set_hops(tunnel->src_port,
|
||||||
|
paths[TB_DP_VIDEO_PATH_OUT]->hops[0].in_hop_index,
|
||||||
|
paths[TB_DP_AUX_PATH_OUT]->hops[0].in_hop_index,
|
||||||
|
paths[TB_DP_AUX_PATH_IN]->hops[last].next_hop_index);
|
||||||
|
|
||||||
|
tb_dp_port_set_hops(tunnel->dst_port,
|
||||||
|
paths[TB_DP_VIDEO_PATH_OUT]->hops[last].next_hop_index,
|
||||||
|
paths[TB_DP_AUX_PATH_IN]->hops[0].in_hop_index,
|
||||||
|
paths[TB_DP_AUX_PATH_OUT]->hops[last].next_hop_index);
|
||||||
|
} else {
|
||||||
|
tb_dp_port_hpd_clear(tunnel->src_port);
|
||||||
|
tb_dp_port_set_hops(tunnel->src_port, 0, 0, 0);
|
||||||
|
if (tb_port_is_dpout(tunnel->dst_port))
|
||||||
|
tb_dp_port_set_hops(tunnel->dst_port, 0, 0, 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
ret = tb_dp_port_enable(tunnel->src_port, active);
|
||||||
|
if (ret)
|
||||||
|
return ret;
|
||||||
|
|
||||||
|
if (tb_port_is_dpout(tunnel->dst_port))
|
||||||
|
return tb_dp_port_enable(tunnel->dst_port, active);
|
||||||
|
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void tb_dp_init_aux_path(struct tb_path *path)
|
||||||
|
{
|
||||||
|
int i;
|
||||||
|
|
||||||
|
path->egress_fc_enable = TB_PATH_SOURCE | TB_PATH_INTERNAL;
|
||||||
|
path->egress_shared_buffer = TB_PATH_NONE;
|
||||||
|
path->ingress_fc_enable = TB_PATH_ALL;
|
||||||
|
path->ingress_shared_buffer = TB_PATH_NONE;
|
||||||
|
path->priority = 2;
|
||||||
|
path->weight = 1;
|
||||||
|
|
||||||
|
for (i = 0; i < path->path_length; i++)
|
||||||
|
path->hops[i].initial_credits = 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void tb_dp_init_video_path(struct tb_path *path, bool discover)
|
||||||
|
{
|
||||||
|
u32 nfc_credits = path->hops[0].in_port->config.nfc_credits;
|
||||||
|
|
||||||
|
path->egress_fc_enable = TB_PATH_NONE;
|
||||||
|
path->egress_shared_buffer = TB_PATH_NONE;
|
||||||
|
path->ingress_fc_enable = TB_PATH_NONE;
|
||||||
|
path->ingress_shared_buffer = TB_PATH_NONE;
|
||||||
|
path->priority = 1;
|
||||||
|
path->weight = 1;
|
||||||
|
|
||||||
|
if (discover) {
|
||||||
|
path->nfc_credits = nfc_credits & TB_PORT_NFC_CREDITS_MASK;
|
||||||
|
} else {
|
||||||
|
u32 max_credits;
|
||||||
|
|
||||||
|
max_credits = (nfc_credits & TB_PORT_MAX_CREDITS_MASK) >>
|
||||||
|
TB_PORT_MAX_CREDITS_SHIFT;
|
||||||
|
/* Leave some credits for AUX path */
|
||||||
|
path->nfc_credits = min(max_credits - 2, 12U);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* tb_tunnel_discover_dp() - Discover existing Display Port tunnels
|
||||||
|
* @tb: Pointer to the domain structure
|
||||||
|
* @in: DP in adapter
|
||||||
|
*
|
||||||
|
* If @in adapter is active, follows the tunnel to the DP out adapter
|
||||||
|
* and back. Returns the discovered tunnel or %NULL if there was no
|
||||||
|
* tunnel.
|
||||||
|
*
|
||||||
|
* Return: DP tunnel or %NULL if no tunnel found.
|
||||||
|
*/
|
||||||
|
struct tb_tunnel *tb_tunnel_discover_dp(struct tb *tb, struct tb_port *in)
|
||||||
|
{
|
||||||
|
struct tb_tunnel *tunnel;
|
||||||
|
struct tb_port *port;
|
||||||
|
struct tb_path *path;
|
||||||
|
|
||||||
|
if (!tb_dp_port_is_enabled(in))
|
||||||
|
return NULL;
|
||||||
|
|
||||||
|
tunnel = tb_tunnel_alloc(tb, 3, TB_TUNNEL_DP);
|
||||||
|
if (!tunnel)
|
||||||
|
return NULL;
|
||||||
|
|
||||||
|
tunnel->init = tb_dp_xchg_caps;
|
||||||
|
tunnel->activate = tb_dp_activate;
|
||||||
|
tunnel->src_port = in;
|
||||||
|
|
||||||
|
path = tb_path_discover(in, TB_DP_VIDEO_HOPID, NULL, -1,
|
||||||
|
&tunnel->dst_port, "Video");
|
||||||
|
if (!path) {
|
||||||
|
/* Just disable the DP IN port */
|
||||||
|
tb_dp_port_enable(in, false);
|
||||||
|
goto err_free;
|
||||||
|
}
|
||||||
|
tunnel->paths[TB_DP_VIDEO_PATH_OUT] = path;
|
||||||
|
tb_dp_init_video_path(tunnel->paths[TB_DP_VIDEO_PATH_OUT], true);
|
||||||
|
|
||||||
|
path = tb_path_discover(in, TB_DP_AUX_TX_HOPID, NULL, -1, NULL, "AUX TX");
|
||||||
|
if (!path)
|
||||||
|
goto err_deactivate;
|
||||||
|
tunnel->paths[TB_DP_AUX_PATH_OUT] = path;
|
||||||
|
tb_dp_init_aux_path(tunnel->paths[TB_DP_AUX_PATH_OUT]);
|
||||||
|
|
||||||
|
path = tb_path_discover(tunnel->dst_port, -1, in, TB_DP_AUX_RX_HOPID,
|
||||||
|
&port, "AUX RX");
|
||||||
|
if (!path)
|
||||||
|
goto err_deactivate;
|
||||||
|
tunnel->paths[TB_DP_AUX_PATH_IN] = path;
|
||||||
|
tb_dp_init_aux_path(tunnel->paths[TB_DP_AUX_PATH_IN]);
|
||||||
|
|
||||||
|
/* Validate that the tunnel is complete */
|
||||||
|
if (!tb_port_is_dpout(tunnel->dst_port)) {
|
||||||
|
tb_port_warn(in, "path does not end on a DP adapter, cleaning up\n");
|
||||||
|
goto err_deactivate;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!tb_dp_port_is_enabled(tunnel->dst_port))
|
||||||
|
goto err_deactivate;
|
||||||
|
|
||||||
|
if (!tb_dp_port_hpd_is_active(tunnel->dst_port))
|
||||||
|
goto err_deactivate;
|
||||||
|
|
||||||
|
if (port != tunnel->src_port) {
|
||||||
|
tb_tunnel_warn(tunnel, "path is not complete, cleaning up\n");
|
||||||
|
goto err_deactivate;
|
||||||
|
}
|
||||||
|
|
||||||
|
tb_tunnel_dbg(tunnel, "discovered\n");
|
||||||
|
return tunnel;
|
||||||
|
|
||||||
|
err_deactivate:
|
||||||
|
tb_tunnel_deactivate(tunnel);
|
||||||
|
err_free:
|
||||||
|
tb_tunnel_free(tunnel);
|
||||||
|
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* tb_tunnel_alloc_dp() - allocate a Display Port tunnel
|
||||||
|
* @tb: Pointer to the domain structure
|
||||||
|
* @in: DP in adapter port
|
||||||
|
* @out: DP out adapter port
|
||||||
|
*
|
||||||
|
* Allocates a tunnel between @in and @out that is capable of tunneling
|
||||||
|
* Display Port traffic.
|
||||||
|
*
|
||||||
|
* Return: Returns a tb_tunnel on success or NULL on failure.
|
||||||
|
*/
|
||||||
|
struct tb_tunnel *tb_tunnel_alloc_dp(struct tb *tb, struct tb_port *in,
|
||||||
|
struct tb_port *out)
|
||||||
|
{
|
||||||
|
struct tb_tunnel *tunnel;
|
||||||
|
struct tb_path **paths;
|
||||||
|
struct tb_path *path;
|
||||||
|
|
||||||
|
if (WARN_ON(!in->cap_adap || !out->cap_adap))
|
||||||
|
return NULL;
|
||||||
|
|
||||||
|
tunnel = tb_tunnel_alloc(tb, 3, TB_TUNNEL_DP);
|
||||||
|
if (!tunnel)
|
||||||
|
return NULL;
|
||||||
|
|
||||||
|
tunnel->init = tb_dp_xchg_caps;
|
||||||
|
tunnel->activate = tb_dp_activate;
|
||||||
|
tunnel->src_port = in;
|
||||||
|
tunnel->dst_port = out;
|
||||||
|
|
||||||
|
paths = tunnel->paths;
|
||||||
|
|
||||||
|
path = tb_path_alloc(tb, in, TB_DP_VIDEO_HOPID, out, TB_DP_VIDEO_HOPID,
|
||||||
|
1, "Video");
|
||||||
|
if (!path)
|
||||||
|
goto err_free;
|
||||||
|
tb_dp_init_video_path(path, false);
|
||||||
|
paths[TB_DP_VIDEO_PATH_OUT] = path;
|
||||||
|
|
||||||
|
path = tb_path_alloc(tb, in, TB_DP_AUX_TX_HOPID, out,
|
||||||
|
TB_DP_AUX_TX_HOPID, 1, "AUX TX");
|
||||||
|
if (!path)
|
||||||
|
goto err_free;
|
||||||
|
tb_dp_init_aux_path(path);
|
||||||
|
paths[TB_DP_AUX_PATH_OUT] = path;
|
||||||
|
|
||||||
|
path = tb_path_alloc(tb, out, TB_DP_AUX_RX_HOPID, in,
|
||||||
|
TB_DP_AUX_RX_HOPID, 1, "AUX RX");
|
||||||
|
if (!path)
|
||||||
|
goto err_free;
|
||||||
|
tb_dp_init_aux_path(path);
|
||||||
|
paths[TB_DP_AUX_PATH_IN] = path;
|
||||||
|
|
||||||
|
return tunnel;
|
||||||
|
|
||||||
|
err_free:
|
||||||
|
tb_tunnel_free(tunnel);
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
static u32 tb_dma_credits(struct tb_port *nhi)
|
||||||
|
{
|
||||||
|
u32 max_credits;
|
||||||
|
|
||||||
|
max_credits = (nhi->config.nfc_credits & TB_PORT_MAX_CREDITS_MASK) >>
|
||||||
|
TB_PORT_MAX_CREDITS_SHIFT;
|
||||||
|
return min(max_credits, 13U);
|
||||||
|
}
|
||||||
|
|
||||||
|
static int tb_dma_activate(struct tb_tunnel *tunnel, bool active)
|
||||||
|
{
|
||||||
|
struct tb_port *nhi = tunnel->src_port;
|
||||||
|
u32 credits;
|
||||||
|
|
||||||
|
credits = active ? tb_dma_credits(nhi) : 0;
|
||||||
|
return tb_port_set_initial_credits(nhi, credits);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void tb_dma_init_path(struct tb_path *path, unsigned int isb,
|
||||||
|
unsigned int efc, u32 credits)
|
||||||
|
{
|
||||||
|
int i;
|
||||||
|
|
||||||
|
path->egress_fc_enable = efc;
|
||||||
|
path->ingress_fc_enable = TB_PATH_ALL;
|
||||||
|
path->egress_shared_buffer = TB_PATH_NONE;
|
||||||
|
path->ingress_shared_buffer = isb;
|
||||||
|
path->priority = 5;
|
||||||
|
path->weight = 1;
|
||||||
|
path->clear_fc = true;
|
||||||
|
|
||||||
|
for (i = 0; i < path->path_length; i++)
|
||||||
|
path->hops[i].initial_credits = credits;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* tb_tunnel_alloc_dma() - allocate a DMA tunnel
|
||||||
|
* @tb: Pointer to the domain structure
|
||||||
|
* @nhi: Host controller port
|
||||||
|
* @dst: Destination null port which the other domain is connected to
|
||||||
|
* @transmit_ring: NHI ring number used to send packets towards the
|
||||||
|
* other domain
|
||||||
|
* @transmit_path: HopID used for transmitting packets
|
||||||
|
* @receive_ring: NHI ring number used to receive packets from the
|
||||||
|
* other domain
|
||||||
|
* @reveive_path: HopID used for receiving packets
|
||||||
|
*
|
||||||
|
* Return: Returns a tb_tunnel on success or NULL on failure.
|
||||||
|
*/
|
||||||
|
struct tb_tunnel *tb_tunnel_alloc_dma(struct tb *tb, struct tb_port *nhi,
|
||||||
|
struct tb_port *dst, int transmit_ring,
|
||||||
|
int transmit_path, int receive_ring,
|
||||||
|
int receive_path)
|
||||||
|
{
|
||||||
|
struct tb_tunnel *tunnel;
|
||||||
|
struct tb_path *path;
|
||||||
|
u32 credits;
|
||||||
|
|
||||||
|
tunnel = tb_tunnel_alloc(tb, 2, TB_TUNNEL_DMA);
|
||||||
|
if (!tunnel)
|
||||||
|
return NULL;
|
||||||
|
|
||||||
|
tunnel->activate = tb_dma_activate;
|
||||||
|
tunnel->src_port = nhi;
|
||||||
|
tunnel->dst_port = dst;
|
||||||
|
|
||||||
|
credits = tb_dma_credits(nhi);
|
||||||
|
|
||||||
|
path = tb_path_alloc(tb, dst, receive_path, nhi, receive_ring, 0, "DMA RX");
|
||||||
|
if (!path) {
|
||||||
|
tb_tunnel_free(tunnel);
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
tb_dma_init_path(path, TB_PATH_NONE, TB_PATH_SOURCE | TB_PATH_INTERNAL,
|
||||||
|
credits);
|
||||||
|
tunnel->paths[TB_DMA_PATH_IN] = path;
|
||||||
|
|
||||||
|
path = tb_path_alloc(tb, nhi, transmit_ring, dst, transmit_path, 0, "DMA TX");
|
||||||
|
if (!path) {
|
||||||
|
tb_tunnel_free(tunnel);
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
tb_dma_init_path(path, TB_PATH_SOURCE, TB_PATH_ALL, credits);
|
||||||
|
tunnel->paths[TB_DMA_PATH_OUT] = path;
|
||||||
|
|
||||||
|
return tunnel;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* tb_tunnel_free() - free a tunnel
|
||||||
|
* @tunnel: Tunnel to be freed
|
||||||
|
*
|
||||||
|
* Frees a tunnel. The tunnel does not need to be deactivated.
|
||||||
|
*/
|
||||||
|
void tb_tunnel_free(struct tb_tunnel *tunnel)
|
||||||
|
{
|
||||||
|
int i;
|
||||||
|
|
||||||
|
if (!tunnel)
|
||||||
|
return;
|
||||||
|
|
||||||
|
for (i = 0; i < tunnel->npaths; i++) {
|
||||||
|
if (tunnel->paths[i])
|
||||||
|
tb_path_free(tunnel->paths[i]);
|
||||||
|
}
|
||||||
|
|
||||||
|
kfree(tunnel->paths);
|
||||||
|
kfree(tunnel);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* tb_tunnel_is_invalid - check whether an activated path is still valid
|
||||||
|
* @tunnel: Tunnel to check
|
||||||
|
*/
|
||||||
|
bool tb_tunnel_is_invalid(struct tb_tunnel *tunnel)
|
||||||
|
{
|
||||||
|
int i;
|
||||||
|
|
||||||
|
for (i = 0; i < tunnel->npaths; i++) {
|
||||||
|
WARN_ON(!tunnel->paths[i]->activated);
|
||||||
|
if (tb_path_is_invalid(tunnel->paths[i]))
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* tb_tunnel_restart() - activate a tunnel after a hardware reset
|
||||||
|
* @tunnel: Tunnel to restart
|
||||||
|
*
|
||||||
|
* Return: 0 on success and negative errno in case if failure
|
||||||
|
*/
|
||||||
|
int tb_tunnel_restart(struct tb_tunnel *tunnel)
|
||||||
|
{
|
||||||
|
int res, i;
|
||||||
|
|
||||||
|
tb_tunnel_dbg(tunnel, "activating\n");
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Make sure all paths are properly disabled before enabling
|
||||||
|
* them again.
|
||||||
|
*/
|
||||||
|
for (i = 0; i < tunnel->npaths; i++) {
|
||||||
|
if (tunnel->paths[i]->activated) {
|
||||||
|
tb_path_deactivate(tunnel->paths[i]);
|
||||||
|
tunnel->paths[i]->activated = false;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if (tunnel->init) {
|
||||||
|
res = tunnel->init(tunnel);
|
||||||
|
if (res)
|
||||||
|
return res;
|
||||||
|
}
|
||||||
|
|
||||||
|
for (i = 0; i < tunnel->npaths; i++) {
|
||||||
|
res = tb_path_activate(tunnel->paths[i]);
|
||||||
|
if (res)
|
||||||
|
goto err;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (tunnel->activate) {
|
||||||
|
res = tunnel->activate(tunnel, true);
|
||||||
|
if (res)
|
||||||
|
goto err;
|
||||||
|
}
|
||||||
|
|
||||||
|
return 0;
|
||||||
|
|
||||||
|
err:
|
||||||
|
tb_tunnel_warn(tunnel, "activation failed\n");
|
||||||
|
tb_tunnel_deactivate(tunnel);
|
||||||
|
return res;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* tb_tunnel_activate() - activate a tunnel
|
||||||
|
* @tunnel: Tunnel to activate
|
||||||
|
*
|
||||||
|
* Return: Returns 0 on success or an error code on failure.
|
||||||
|
*/
|
||||||
|
int tb_tunnel_activate(struct tb_tunnel *tunnel)
|
||||||
|
{
|
||||||
|
int i;
|
||||||
|
|
||||||
|
for (i = 0; i < tunnel->npaths; i++) {
|
||||||
|
if (tunnel->paths[i]->activated) {
|
||||||
|
tb_tunnel_WARN(tunnel,
|
||||||
|
"trying to activate an already activated tunnel\n");
|
||||||
|
return -EINVAL;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return tb_tunnel_restart(tunnel);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* tb_tunnel_deactivate() - deactivate a tunnel
|
||||||
|
* @tunnel: Tunnel to deactivate
|
||||||
|
*/
|
||||||
|
void tb_tunnel_deactivate(struct tb_tunnel *tunnel)
|
||||||
|
{
|
||||||
|
int i;
|
||||||
|
|
||||||
|
tb_tunnel_dbg(tunnel, "deactivating\n");
|
||||||
|
|
||||||
|
if (tunnel->activate)
|
||||||
|
tunnel->activate(tunnel, false);
|
||||||
|
|
||||||
|
for (i = 0; i < tunnel->npaths; i++) {
|
||||||
|
if (tunnel->paths[i] && tunnel->paths[i]->activated)
|
||||||
|
tb_path_deactivate(tunnel->paths[i]);
|
||||||
|
}
|
||||||
|
}
|
78
drivers/thunderbolt/tunnel.h
Normal file
78
drivers/thunderbolt/tunnel.h
Normal file
|
@ -0,0 +1,78 @@
|
||||||
|
/* SPDX-License-Identifier: GPL-2.0 */
|
||||||
|
/*
|
||||||
|
* Thunderbolt driver - Tunneling support
|
||||||
|
*
|
||||||
|
* Copyright (c) 2014 Andreas Noever <andreas.noever@gmail.com>
|
||||||
|
* Copyright (C) 2019, Intel Corporation
|
||||||
|
*/
|
||||||
|
|
||||||
|
#ifndef TB_TUNNEL_H_
|
||||||
|
#define TB_TUNNEL_H_
|
||||||
|
|
||||||
|
#include "tb.h"
|
||||||
|
|
||||||
|
enum tb_tunnel_type {
|
||||||
|
TB_TUNNEL_PCI,
|
||||||
|
TB_TUNNEL_DP,
|
||||||
|
TB_TUNNEL_DMA,
|
||||||
|
};
|
||||||
|
|
||||||
|
/**
|
||||||
|
* struct tb_tunnel - Tunnel between two ports
|
||||||
|
* @tb: Pointer to the domain
|
||||||
|
* @src_port: Source port of the tunnel
|
||||||
|
* @dst_port: Destination port of the tunnel. For discovered incomplete
|
||||||
|
* tunnels may be %NULL or null adapter port instead.
|
||||||
|
* @paths: All paths required by the tunnel
|
||||||
|
* @npaths: Number of paths in @paths
|
||||||
|
* @init: Optional tunnel specific initialization
|
||||||
|
* @activate: Optional tunnel specific activation/deactivation
|
||||||
|
* @list: Tunnels are linked using this field
|
||||||
|
* @type: Type of the tunnel
|
||||||
|
*/
|
||||||
|
struct tb_tunnel {
|
||||||
|
struct tb *tb;
|
||||||
|
struct tb_port *src_port;
|
||||||
|
struct tb_port *dst_port;
|
||||||
|
struct tb_path **paths;
|
||||||
|
size_t npaths;
|
||||||
|
int (*init)(struct tb_tunnel *tunnel);
|
||||||
|
int (*activate)(struct tb_tunnel *tunnel, bool activate);
|
||||||
|
struct list_head list;
|
||||||
|
enum tb_tunnel_type type;
|
||||||
|
};
|
||||||
|
|
||||||
|
struct tb_tunnel *tb_tunnel_discover_pci(struct tb *tb, struct tb_port *down);
|
||||||
|
struct tb_tunnel *tb_tunnel_alloc_pci(struct tb *tb, struct tb_port *up,
|
||||||
|
struct tb_port *down);
|
||||||
|
struct tb_tunnel *tb_tunnel_discover_dp(struct tb *tb, struct tb_port *in);
|
||||||
|
struct tb_tunnel *tb_tunnel_alloc_dp(struct tb *tb, struct tb_port *in,
|
||||||
|
struct tb_port *out);
|
||||||
|
struct tb_tunnel *tb_tunnel_alloc_dma(struct tb *tb, struct tb_port *nhi,
|
||||||
|
struct tb_port *dst, int transmit_ring,
|
||||||
|
int transmit_path, int receive_ring,
|
||||||
|
int receive_path);
|
||||||
|
|
||||||
|
void tb_tunnel_free(struct tb_tunnel *tunnel);
|
||||||
|
int tb_tunnel_activate(struct tb_tunnel *tunnel);
|
||||||
|
int tb_tunnel_restart(struct tb_tunnel *tunnel);
|
||||||
|
void tb_tunnel_deactivate(struct tb_tunnel *tunnel);
|
||||||
|
bool tb_tunnel_is_invalid(struct tb_tunnel *tunnel);
|
||||||
|
|
||||||
|
static inline bool tb_tunnel_is_pci(const struct tb_tunnel *tunnel)
|
||||||
|
{
|
||||||
|
return tunnel->type == TB_TUNNEL_PCI;
|
||||||
|
}
|
||||||
|
|
||||||
|
static inline bool tb_tunnel_is_dp(const struct tb_tunnel *tunnel)
|
||||||
|
{
|
||||||
|
return tunnel->type == TB_TUNNEL_DP;
|
||||||
|
}
|
||||||
|
|
||||||
|
static inline bool tb_tunnel_is_dma(const struct tb_tunnel *tunnel)
|
||||||
|
{
|
||||||
|
return tunnel->type == TB_TUNNEL_DMA;
|
||||||
|
}
|
||||||
|
|
||||||
|
#endif
|
||||||
|
|
|
@ -1,226 +0,0 @@
|
||||||
// SPDX-License-Identifier: GPL-2.0
|
|
||||||
/*
|
|
||||||
* Thunderbolt Cactus Ridge driver - PCIe tunnel
|
|
||||||
*
|
|
||||||
* Copyright (c) 2014 Andreas Noever <andreas.noever@gmail.com>
|
|
||||||
*/
|
|
||||||
|
|
||||||
#include <linux/slab.h>
|
|
||||||
#include <linux/list.h>
|
|
||||||
|
|
||||||
#include "tunnel_pci.h"
|
|
||||||
#include "tb.h"
|
|
||||||
|
|
||||||
#define __TB_TUNNEL_PRINT(level, tunnel, fmt, arg...) \
|
|
||||||
do { \
|
|
||||||
struct tb_pci_tunnel *__tunnel = (tunnel); \
|
|
||||||
level(__tunnel->tb, "%llx:%x <-> %llx:%x (PCI): " fmt, \
|
|
||||||
tb_route(__tunnel->down_port->sw), \
|
|
||||||
__tunnel->down_port->port, \
|
|
||||||
tb_route(__tunnel->up_port->sw), \
|
|
||||||
__tunnel->up_port->port, \
|
|
||||||
## arg); \
|
|
||||||
} while (0)
|
|
||||||
|
|
||||||
#define tb_tunnel_WARN(tunnel, fmt, arg...) \
|
|
||||||
__TB_TUNNEL_PRINT(tb_WARN, tunnel, fmt, ##arg)
|
|
||||||
#define tb_tunnel_warn(tunnel, fmt, arg...) \
|
|
||||||
__TB_TUNNEL_PRINT(tb_warn, tunnel, fmt, ##arg)
|
|
||||||
#define tb_tunnel_info(tunnel, fmt, arg...) \
|
|
||||||
__TB_TUNNEL_PRINT(tb_info, tunnel, fmt, ##arg)
|
|
||||||
|
|
||||||
static void tb_pci_init_path(struct tb_path *path)
|
|
||||||
{
|
|
||||||
path->egress_fc_enable = TB_PATH_SOURCE | TB_PATH_INTERNAL;
|
|
||||||
path->egress_shared_buffer = TB_PATH_NONE;
|
|
||||||
path->ingress_fc_enable = TB_PATH_ALL;
|
|
||||||
path->ingress_shared_buffer = TB_PATH_NONE;
|
|
||||||
path->priority = 3;
|
|
||||||
path->weight = 1;
|
|
||||||
path->drop_packages = 0;
|
|
||||||
path->nfc_credits = 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* tb_pci_alloc() - allocate a pci tunnel
|
|
||||||
*
|
|
||||||
* Allocate a PCI tunnel. The ports must be of type TB_TYPE_PCIE_UP and
|
|
||||||
* TB_TYPE_PCIE_DOWN.
|
|
||||||
*
|
|
||||||
* Currently only paths consisting of two hops are supported (that is the
|
|
||||||
* ports must be on "adjacent" switches).
|
|
||||||
*
|
|
||||||
* The paths are hard-coded to use hop 8 (the only working hop id available on
|
|
||||||
* my thunderbolt devices). Therefore at most ONE path per device may be
|
|
||||||
* activated.
|
|
||||||
*
|
|
||||||
* Return: Returns a tb_pci_tunnel on success or NULL on failure.
|
|
||||||
*/
|
|
||||||
struct tb_pci_tunnel *tb_pci_alloc(struct tb *tb, struct tb_port *up,
|
|
||||||
struct tb_port *down)
|
|
||||||
{
|
|
||||||
struct tb_pci_tunnel *tunnel = kzalloc(sizeof(*tunnel), GFP_KERNEL);
|
|
||||||
if (!tunnel)
|
|
||||||
goto err;
|
|
||||||
tunnel->tb = tb;
|
|
||||||
tunnel->down_port = down;
|
|
||||||
tunnel->up_port = up;
|
|
||||||
INIT_LIST_HEAD(&tunnel->list);
|
|
||||||
tunnel->path_to_up = tb_path_alloc(up->sw->tb, 2);
|
|
||||||
if (!tunnel->path_to_up)
|
|
||||||
goto err;
|
|
||||||
tunnel->path_to_down = tb_path_alloc(up->sw->tb, 2);
|
|
||||||
if (!tunnel->path_to_down)
|
|
||||||
goto err;
|
|
||||||
tb_pci_init_path(tunnel->path_to_up);
|
|
||||||
tb_pci_init_path(tunnel->path_to_down);
|
|
||||||
|
|
||||||
tunnel->path_to_up->hops[0].in_port = down;
|
|
||||||
tunnel->path_to_up->hops[0].in_hop_index = 8;
|
|
||||||
tunnel->path_to_up->hops[0].in_counter_index = -1;
|
|
||||||
tunnel->path_to_up->hops[0].out_port = tb_upstream_port(up->sw)->remote;
|
|
||||||
tunnel->path_to_up->hops[0].next_hop_index = 8;
|
|
||||||
|
|
||||||
tunnel->path_to_up->hops[1].in_port = tb_upstream_port(up->sw);
|
|
||||||
tunnel->path_to_up->hops[1].in_hop_index = 8;
|
|
||||||
tunnel->path_to_up->hops[1].in_counter_index = -1;
|
|
||||||
tunnel->path_to_up->hops[1].out_port = up;
|
|
||||||
tunnel->path_to_up->hops[1].next_hop_index = 8;
|
|
||||||
|
|
||||||
tunnel->path_to_down->hops[0].in_port = up;
|
|
||||||
tunnel->path_to_down->hops[0].in_hop_index = 8;
|
|
||||||
tunnel->path_to_down->hops[0].in_counter_index = -1;
|
|
||||||
tunnel->path_to_down->hops[0].out_port = tb_upstream_port(up->sw);
|
|
||||||
tunnel->path_to_down->hops[0].next_hop_index = 8;
|
|
||||||
|
|
||||||
tunnel->path_to_down->hops[1].in_port =
|
|
||||||
tb_upstream_port(up->sw)->remote;
|
|
||||||
tunnel->path_to_down->hops[1].in_hop_index = 8;
|
|
||||||
tunnel->path_to_down->hops[1].in_counter_index = -1;
|
|
||||||
tunnel->path_to_down->hops[1].out_port = down;
|
|
||||||
tunnel->path_to_down->hops[1].next_hop_index = 8;
|
|
||||||
return tunnel;
|
|
||||||
|
|
||||||
err:
|
|
||||||
if (tunnel) {
|
|
||||||
if (tunnel->path_to_down)
|
|
||||||
tb_path_free(tunnel->path_to_down);
|
|
||||||
if (tunnel->path_to_up)
|
|
||||||
tb_path_free(tunnel->path_to_up);
|
|
||||||
kfree(tunnel);
|
|
||||||
}
|
|
||||||
return NULL;
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* tb_pci_free() - free a tunnel
|
|
||||||
*
|
|
||||||
* The tunnel must have been deactivated.
|
|
||||||
*/
|
|
||||||
void tb_pci_free(struct tb_pci_tunnel *tunnel)
|
|
||||||
{
|
|
||||||
if (tunnel->path_to_up->activated || tunnel->path_to_down->activated) {
|
|
||||||
tb_tunnel_WARN(tunnel, "trying to free an activated tunnel\n");
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
tb_path_free(tunnel->path_to_up);
|
|
||||||
tb_path_free(tunnel->path_to_down);
|
|
||||||
kfree(tunnel);
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* tb_pci_is_invalid - check whether an activated path is still valid
|
|
||||||
*/
|
|
||||||
bool tb_pci_is_invalid(struct tb_pci_tunnel *tunnel)
|
|
||||||
{
|
|
||||||
WARN_ON(!tunnel->path_to_up->activated);
|
|
||||||
WARN_ON(!tunnel->path_to_down->activated);
|
|
||||||
|
|
||||||
return tb_path_is_invalid(tunnel->path_to_up)
|
|
||||||
|| tb_path_is_invalid(tunnel->path_to_down);
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* tb_pci_port_active() - activate/deactivate PCI capability
|
|
||||||
*
|
|
||||||
* Return: Returns 0 on success or an error code on failure.
|
|
||||||
*/
|
|
||||||
static int tb_pci_port_active(struct tb_port *port, bool active)
|
|
||||||
{
|
|
||||||
u32 word = active ? 0x80000000 : 0x0;
|
|
||||||
int cap = tb_port_find_cap(port, TB_PORT_CAP_ADAP);
|
|
||||||
if (cap < 0) {
|
|
||||||
tb_port_warn(port, "TB_PORT_CAP_ADAP not found: %d\n", cap);
|
|
||||||
return cap;
|
|
||||||
}
|
|
||||||
return tb_port_write(port, &word, TB_CFG_PORT, cap, 1);
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* tb_pci_restart() - activate a tunnel after a hardware reset
|
|
||||||
*/
|
|
||||||
int tb_pci_restart(struct tb_pci_tunnel *tunnel)
|
|
||||||
{
|
|
||||||
int res;
|
|
||||||
tunnel->path_to_up->activated = false;
|
|
||||||
tunnel->path_to_down->activated = false;
|
|
||||||
|
|
||||||
tb_tunnel_info(tunnel, "activating\n");
|
|
||||||
|
|
||||||
res = tb_path_activate(tunnel->path_to_up);
|
|
||||||
if (res)
|
|
||||||
goto err;
|
|
||||||
res = tb_path_activate(tunnel->path_to_down);
|
|
||||||
if (res)
|
|
||||||
goto err;
|
|
||||||
|
|
||||||
res = tb_pci_port_active(tunnel->down_port, true);
|
|
||||||
if (res)
|
|
||||||
goto err;
|
|
||||||
|
|
||||||
res = tb_pci_port_active(tunnel->up_port, true);
|
|
||||||
if (res)
|
|
||||||
goto err;
|
|
||||||
return 0;
|
|
||||||
err:
|
|
||||||
tb_tunnel_warn(tunnel, "activation failed\n");
|
|
||||||
tb_pci_deactivate(tunnel);
|
|
||||||
return res;
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* tb_pci_activate() - activate a tunnel
|
|
||||||
*
|
|
||||||
* Return: Returns 0 on success or an error code on failure.
|
|
||||||
*/
|
|
||||||
int tb_pci_activate(struct tb_pci_tunnel *tunnel)
|
|
||||||
{
|
|
||||||
if (tunnel->path_to_up->activated || tunnel->path_to_down->activated) {
|
|
||||||
tb_tunnel_WARN(tunnel,
|
|
||||||
"trying to activate an already activated tunnel\n");
|
|
||||||
return -EINVAL;
|
|
||||||
}
|
|
||||||
|
|
||||||
return tb_pci_restart(tunnel);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
/**
|
|
||||||
* tb_pci_deactivate() - deactivate a tunnel
|
|
||||||
*/
|
|
||||||
void tb_pci_deactivate(struct tb_pci_tunnel *tunnel)
|
|
||||||
{
|
|
||||||
tb_tunnel_info(tunnel, "deactivating\n");
|
|
||||||
/*
|
|
||||||
* TODO: enable reset by writing 0x04000000 to TB_CAP_PCIE + 1 on up
|
|
||||||
* port. Seems to have no effect?
|
|
||||||
*/
|
|
||||||
tb_pci_port_active(tunnel->up_port, false);
|
|
||||||
tb_pci_port_active(tunnel->down_port, false);
|
|
||||||
if (tunnel->path_to_down->activated)
|
|
||||||
tb_path_deactivate(tunnel->path_to_down);
|
|
||||||
if (tunnel->path_to_up->activated)
|
|
||||||
tb_path_deactivate(tunnel->path_to_up);
|
|
||||||
}
|
|
||||||
|
|
|
@ -1,31 +0,0 @@
|
||||||
/* SPDX-License-Identifier: GPL-2.0 */
|
|
||||||
/*
|
|
||||||
* Thunderbolt Cactus Ridge driver - PCIe tunnel
|
|
||||||
*
|
|
||||||
* Copyright (c) 2014 Andreas Noever <andreas.noever@gmail.com>
|
|
||||||
*/
|
|
||||||
|
|
||||||
#ifndef TB_PCI_H_
|
|
||||||
#define TB_PCI_H_
|
|
||||||
|
|
||||||
#include "tb.h"
|
|
||||||
|
|
||||||
struct tb_pci_tunnel {
|
|
||||||
struct tb *tb;
|
|
||||||
struct tb_port *up_port;
|
|
||||||
struct tb_port *down_port;
|
|
||||||
struct tb_path *path_to_up;
|
|
||||||
struct tb_path *path_to_down;
|
|
||||||
struct list_head list;
|
|
||||||
};
|
|
||||||
|
|
||||||
struct tb_pci_tunnel *tb_pci_alloc(struct tb *tb, struct tb_port *up,
|
|
||||||
struct tb_port *down);
|
|
||||||
void tb_pci_free(struct tb_pci_tunnel *tunnel);
|
|
||||||
int tb_pci_activate(struct tb_pci_tunnel *tunnel);
|
|
||||||
int tb_pci_restart(struct tb_pci_tunnel *tunnel);
|
|
||||||
void tb_pci_deactivate(struct tb_pci_tunnel *tunnel);
|
|
||||||
bool tb_pci_is_invalid(struct tb_pci_tunnel *tunnel);
|
|
||||||
|
|
||||||
#endif
|
|
||||||
|
|
|
@ -18,6 +18,7 @@
|
||||||
#include "tb.h"
|
#include "tb.h"
|
||||||
|
|
||||||
#define XDOMAIN_DEFAULT_TIMEOUT 5000 /* ms */
|
#define XDOMAIN_DEFAULT_TIMEOUT 5000 /* ms */
|
||||||
|
#define XDOMAIN_UUID_RETRIES 10
|
||||||
#define XDOMAIN_PROPERTIES_RETRIES 60
|
#define XDOMAIN_PROPERTIES_RETRIES 60
|
||||||
#define XDOMAIN_PROPERTIES_CHANGED_RETRIES 10
|
#define XDOMAIN_PROPERTIES_CHANGED_RETRIES 10
|
||||||
|
|
||||||
|
@ -222,6 +223,50 @@ static int tb_xdp_handle_error(const struct tb_xdp_header *hdr)
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
static int tb_xdp_uuid_request(struct tb_ctl *ctl, u64 route, int retry,
|
||||||
|
uuid_t *uuid)
|
||||||
|
{
|
||||||
|
struct tb_xdp_uuid_response res;
|
||||||
|
struct tb_xdp_uuid req;
|
||||||
|
int ret;
|
||||||
|
|
||||||
|
memset(&req, 0, sizeof(req));
|
||||||
|
tb_xdp_fill_header(&req.hdr, route, retry % 4, UUID_REQUEST,
|
||||||
|
sizeof(req));
|
||||||
|
|
||||||
|
memset(&res, 0, sizeof(res));
|
||||||
|
ret = __tb_xdomain_request(ctl, &req, sizeof(req),
|
||||||
|
TB_CFG_PKG_XDOMAIN_REQ, &res, sizeof(res),
|
||||||
|
TB_CFG_PKG_XDOMAIN_RESP,
|
||||||
|
XDOMAIN_DEFAULT_TIMEOUT);
|
||||||
|
if (ret)
|
||||||
|
return ret;
|
||||||
|
|
||||||
|
ret = tb_xdp_handle_error(&res.hdr);
|
||||||
|
if (ret)
|
||||||
|
return ret;
|
||||||
|
|
||||||
|
uuid_copy(uuid, &res.src_uuid);
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
static int tb_xdp_uuid_response(struct tb_ctl *ctl, u64 route, u8 sequence,
|
||||||
|
const uuid_t *uuid)
|
||||||
|
{
|
||||||
|
struct tb_xdp_uuid_response res;
|
||||||
|
|
||||||
|
memset(&res, 0, sizeof(res));
|
||||||
|
tb_xdp_fill_header(&res.hdr, route, sequence, UUID_RESPONSE,
|
||||||
|
sizeof(res));
|
||||||
|
|
||||||
|
uuid_copy(&res.src_uuid, uuid);
|
||||||
|
res.src_route_hi = upper_32_bits(route);
|
||||||
|
res.src_route_lo = lower_32_bits(route);
|
||||||
|
|
||||||
|
return __tb_xdomain_response(ctl, &res, sizeof(res),
|
||||||
|
TB_CFG_PKG_XDOMAIN_RESP);
|
||||||
|
}
|
||||||
|
|
||||||
static int tb_xdp_error_response(struct tb_ctl *ctl, u64 route, u8 sequence,
|
static int tb_xdp_error_response(struct tb_ctl *ctl, u64 route, u8 sequence,
|
||||||
enum tb_xdp_error error)
|
enum tb_xdp_error error)
|
||||||
{
|
{
|
||||||
|
@ -512,7 +557,14 @@ static void tb_xdp_handle_request(struct work_struct *work)
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
case UUID_REQUEST_OLD:
|
||||||
|
case UUID_REQUEST:
|
||||||
|
ret = tb_xdp_uuid_response(ctl, route, sequence, uuid);
|
||||||
|
break;
|
||||||
|
|
||||||
default:
|
default:
|
||||||
|
tb_xdp_error_response(ctl, route, sequence,
|
||||||
|
ERROR_NOT_SUPPORTED);
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -524,9 +576,11 @@ static void tb_xdp_handle_request(struct work_struct *work)
|
||||||
out:
|
out:
|
||||||
kfree(xw->pkg);
|
kfree(xw->pkg);
|
||||||
kfree(xw);
|
kfree(xw);
|
||||||
|
|
||||||
|
tb_domain_put(tb);
|
||||||
}
|
}
|
||||||
|
|
||||||
static void
|
static bool
|
||||||
tb_xdp_schedule_request(struct tb *tb, const struct tb_xdp_header *hdr,
|
tb_xdp_schedule_request(struct tb *tb, const struct tb_xdp_header *hdr,
|
||||||
size_t size)
|
size_t size)
|
||||||
{
|
{
|
||||||
|
@ -534,13 +588,18 @@ tb_xdp_schedule_request(struct tb *tb, const struct tb_xdp_header *hdr,
|
||||||
|
|
||||||
xw = kmalloc(sizeof(*xw), GFP_KERNEL);
|
xw = kmalloc(sizeof(*xw), GFP_KERNEL);
|
||||||
if (!xw)
|
if (!xw)
|
||||||
return;
|
return false;
|
||||||
|
|
||||||
INIT_WORK(&xw->work, tb_xdp_handle_request);
|
INIT_WORK(&xw->work, tb_xdp_handle_request);
|
||||||
xw->pkg = kmemdup(hdr, size, GFP_KERNEL);
|
xw->pkg = kmemdup(hdr, size, GFP_KERNEL);
|
||||||
xw->tb = tb;
|
if (!xw->pkg) {
|
||||||
|
kfree(xw);
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
xw->tb = tb_domain_get(tb);
|
||||||
|
|
||||||
queue_work(tb->wq, &xw->work);
|
schedule_work(&xw->work);
|
||||||
|
return true;
|
||||||
}
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
|
@ -740,6 +799,7 @@ static void enumerate_services(struct tb_xdomain *xd)
|
||||||
struct tb_service *svc;
|
struct tb_service *svc;
|
||||||
struct tb_property *p;
|
struct tb_property *p;
|
||||||
struct device *dev;
|
struct device *dev;
|
||||||
|
int id;
|
||||||
|
|
||||||
/*
|
/*
|
||||||
* First remove all services that are not available anymore in
|
* First remove all services that are not available anymore in
|
||||||
|
@ -768,7 +828,12 @@ static void enumerate_services(struct tb_xdomain *xd)
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
|
|
||||||
svc->id = ida_simple_get(&xd->service_ids, 0, 0, GFP_KERNEL);
|
id = ida_simple_get(&xd->service_ids, 0, 0, GFP_KERNEL);
|
||||||
|
if (id < 0) {
|
||||||
|
kfree(svc);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
svc->id = id;
|
||||||
svc->dev.bus = &tb_bus_type;
|
svc->dev.bus = &tb_bus_type;
|
||||||
svc->dev.type = &tb_service_type;
|
svc->dev.type = &tb_service_type;
|
||||||
svc->dev.parent = &xd->dev;
|
svc->dev.parent = &xd->dev;
|
||||||
|
@ -826,6 +891,55 @@ static void tb_xdomain_restore_paths(struct tb_xdomain *xd)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
static void tb_xdomain_get_uuid(struct work_struct *work)
|
||||||
|
{
|
||||||
|
struct tb_xdomain *xd = container_of(work, typeof(*xd),
|
||||||
|
get_uuid_work.work);
|
||||||
|
struct tb *tb = xd->tb;
|
||||||
|
uuid_t uuid;
|
||||||
|
int ret;
|
||||||
|
|
||||||
|
ret = tb_xdp_uuid_request(tb->ctl, xd->route, xd->uuid_retries, &uuid);
|
||||||
|
if (ret < 0) {
|
||||||
|
if (xd->uuid_retries-- > 0) {
|
||||||
|
queue_delayed_work(xd->tb->wq, &xd->get_uuid_work,
|
||||||
|
msecs_to_jiffies(100));
|
||||||
|
} else {
|
||||||
|
dev_dbg(&xd->dev, "failed to read remote UUID\n");
|
||||||
|
}
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (uuid_equal(&uuid, xd->local_uuid)) {
|
||||||
|
dev_dbg(&xd->dev, "intra-domain loop detected\n");
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
/*
|
||||||
|
* If the UUID is different, there is another domain connected
|
||||||
|
* so mark this one unplugged and wait for the connection
|
||||||
|
* manager to replace it.
|
||||||
|
*/
|
||||||
|
if (xd->remote_uuid && !uuid_equal(&uuid, xd->remote_uuid)) {
|
||||||
|
dev_dbg(&xd->dev, "remote UUID is different, unplugging\n");
|
||||||
|
xd->is_unplugged = true;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* First time fill in the missing UUID */
|
||||||
|
if (!xd->remote_uuid) {
|
||||||
|
xd->remote_uuid = kmemdup(&uuid, sizeof(uuid_t), GFP_KERNEL);
|
||||||
|
if (!xd->remote_uuid)
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Now we can start the normal properties exchange */
|
||||||
|
queue_delayed_work(xd->tb->wq, &xd->properties_changed_work,
|
||||||
|
msecs_to_jiffies(100));
|
||||||
|
queue_delayed_work(xd->tb->wq, &xd->get_properties_work,
|
||||||
|
msecs_to_jiffies(1000));
|
||||||
|
}
|
||||||
|
|
||||||
static void tb_xdomain_get_properties(struct work_struct *work)
|
static void tb_xdomain_get_properties(struct work_struct *work)
|
||||||
{
|
{
|
||||||
struct tb_xdomain *xd = container_of(work, typeof(*xd),
|
struct tb_xdomain *xd = container_of(work, typeof(*xd),
|
||||||
|
@ -1032,21 +1146,29 @@ static void tb_xdomain_release(struct device *dev)
|
||||||
|
|
||||||
static void start_handshake(struct tb_xdomain *xd)
|
static void start_handshake(struct tb_xdomain *xd)
|
||||||
{
|
{
|
||||||
|
xd->uuid_retries = XDOMAIN_UUID_RETRIES;
|
||||||
xd->properties_retries = XDOMAIN_PROPERTIES_RETRIES;
|
xd->properties_retries = XDOMAIN_PROPERTIES_RETRIES;
|
||||||
xd->properties_changed_retries = XDOMAIN_PROPERTIES_CHANGED_RETRIES;
|
xd->properties_changed_retries = XDOMAIN_PROPERTIES_CHANGED_RETRIES;
|
||||||
|
|
||||||
|
if (xd->needs_uuid) {
|
||||||
|
queue_delayed_work(xd->tb->wq, &xd->get_uuid_work,
|
||||||
|
msecs_to_jiffies(100));
|
||||||
|
} else {
|
||||||
/* Start exchanging properties with the other host */
|
/* Start exchanging properties with the other host */
|
||||||
queue_delayed_work(xd->tb->wq, &xd->properties_changed_work,
|
queue_delayed_work(xd->tb->wq, &xd->properties_changed_work,
|
||||||
msecs_to_jiffies(100));
|
msecs_to_jiffies(100));
|
||||||
queue_delayed_work(xd->tb->wq, &xd->get_properties_work,
|
queue_delayed_work(xd->tb->wq, &xd->get_properties_work,
|
||||||
msecs_to_jiffies(1000));
|
msecs_to_jiffies(1000));
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
static void stop_handshake(struct tb_xdomain *xd)
|
static void stop_handshake(struct tb_xdomain *xd)
|
||||||
{
|
{
|
||||||
|
xd->uuid_retries = 0;
|
||||||
xd->properties_retries = 0;
|
xd->properties_retries = 0;
|
||||||
xd->properties_changed_retries = 0;
|
xd->properties_changed_retries = 0;
|
||||||
|
|
||||||
|
cancel_delayed_work_sync(&xd->get_uuid_work);
|
||||||
cancel_delayed_work_sync(&xd->get_properties_work);
|
cancel_delayed_work_sync(&xd->get_properties_work);
|
||||||
cancel_delayed_work_sync(&xd->properties_changed_work);
|
cancel_delayed_work_sync(&xd->properties_changed_work);
|
||||||
}
|
}
|
||||||
|
@ -1089,7 +1211,7 @@ EXPORT_SYMBOL_GPL(tb_xdomain_type);
|
||||||
* other domain is reached).
|
* other domain is reached).
|
||||||
* @route: Route string used to reach the other domain
|
* @route: Route string used to reach the other domain
|
||||||
* @local_uuid: Our local domain UUID
|
* @local_uuid: Our local domain UUID
|
||||||
* @remote_uuid: UUID of the other domain
|
* @remote_uuid: UUID of the other domain (optional)
|
||||||
*
|
*
|
||||||
* Allocates new XDomain structure and returns pointer to that. The
|
* Allocates new XDomain structure and returns pointer to that. The
|
||||||
* object must be released by calling tb_xdomain_put().
|
* object must be released by calling tb_xdomain_put().
|
||||||
|
@ -1108,6 +1230,7 @@ struct tb_xdomain *tb_xdomain_alloc(struct tb *tb, struct device *parent,
|
||||||
xd->route = route;
|
xd->route = route;
|
||||||
ida_init(&xd->service_ids);
|
ida_init(&xd->service_ids);
|
||||||
mutex_init(&xd->lock);
|
mutex_init(&xd->lock);
|
||||||
|
INIT_DELAYED_WORK(&xd->get_uuid_work, tb_xdomain_get_uuid);
|
||||||
INIT_DELAYED_WORK(&xd->get_properties_work, tb_xdomain_get_properties);
|
INIT_DELAYED_WORK(&xd->get_properties_work, tb_xdomain_get_properties);
|
||||||
INIT_DELAYED_WORK(&xd->properties_changed_work,
|
INIT_DELAYED_WORK(&xd->properties_changed_work,
|
||||||
tb_xdomain_properties_changed);
|
tb_xdomain_properties_changed);
|
||||||
|
@ -1116,9 +1239,14 @@ struct tb_xdomain *tb_xdomain_alloc(struct tb *tb, struct device *parent,
|
||||||
if (!xd->local_uuid)
|
if (!xd->local_uuid)
|
||||||
goto err_free;
|
goto err_free;
|
||||||
|
|
||||||
xd->remote_uuid = kmemdup(remote_uuid, sizeof(uuid_t), GFP_KERNEL);
|
if (remote_uuid) {
|
||||||
|
xd->remote_uuid = kmemdup(remote_uuid, sizeof(uuid_t),
|
||||||
|
GFP_KERNEL);
|
||||||
if (!xd->remote_uuid)
|
if (!xd->remote_uuid)
|
||||||
goto err_free_local_uuid;
|
goto err_free_local_uuid;
|
||||||
|
} else {
|
||||||
|
xd->needs_uuid = true;
|
||||||
|
}
|
||||||
|
|
||||||
device_initialize(&xd->dev);
|
device_initialize(&xd->dev);
|
||||||
xd->dev.parent = get_device(parent);
|
xd->dev.parent = get_device(parent);
|
||||||
|
@ -1282,14 +1410,12 @@ static struct tb_xdomain *switch_find_xdomain(struct tb_switch *sw,
|
||||||
struct tb_port *port = &sw->ports[i];
|
struct tb_port *port = &sw->ports[i];
|
||||||
struct tb_xdomain *xd;
|
struct tb_xdomain *xd;
|
||||||
|
|
||||||
if (tb_is_upstream_port(port))
|
|
||||||
continue;
|
|
||||||
|
|
||||||
if (port->xdomain) {
|
if (port->xdomain) {
|
||||||
xd = port->xdomain;
|
xd = port->xdomain;
|
||||||
|
|
||||||
if (lookup->uuid) {
|
if (lookup->uuid) {
|
||||||
if (uuid_equal(xd->remote_uuid, lookup->uuid))
|
if (xd->remote_uuid &&
|
||||||
|
uuid_equal(xd->remote_uuid, lookup->uuid))
|
||||||
return xd;
|
return xd;
|
||||||
} else if (lookup->link &&
|
} else if (lookup->link &&
|
||||||
lookup->link == xd->link &&
|
lookup->link == xd->link &&
|
||||||
|
@ -1299,7 +1425,7 @@ static struct tb_xdomain *switch_find_xdomain(struct tb_switch *sw,
|
||||||
lookup->route == xd->route) {
|
lookup->route == xd->route) {
|
||||||
return xd;
|
return xd;
|
||||||
}
|
}
|
||||||
} else if (port->remote) {
|
} else if (tb_port_has_remote(port)) {
|
||||||
xd = switch_find_xdomain(port->remote->sw, lookup);
|
xd = switch_find_xdomain(port->remote->sw, lookup);
|
||||||
if (xd)
|
if (xd)
|
||||||
return xd;
|
return xd;
|
||||||
|
@ -1416,10 +1542,8 @@ bool tb_xdomain_handle_request(struct tb *tb, enum tb_cfg_pkg_type type,
|
||||||
* handlers in turn.
|
* handlers in turn.
|
||||||
*/
|
*/
|
||||||
if (uuid_equal(&hdr->uuid, &tb_xdp_uuid)) {
|
if (uuid_equal(&hdr->uuid, &tb_xdp_uuid)) {
|
||||||
if (type == TB_CFG_PKG_XDOMAIN_REQ) {
|
if (type == TB_CFG_PKG_XDOMAIN_REQ)
|
||||||
tb_xdp_schedule_request(tb, hdr, size);
|
return tb_xdp_schedule_request(tb, hdr, size);
|
||||||
return true;
|
|
||||||
}
|
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
@ -181,6 +181,8 @@ void tb_unregister_property_dir(const char *key, struct tb_property_dir *dir);
|
||||||
* @device_name: Name of the device (or %NULL if not known)
|
* @device_name: Name of the device (or %NULL if not known)
|
||||||
* @is_unplugged: The XDomain is unplugged
|
* @is_unplugged: The XDomain is unplugged
|
||||||
* @resume: The XDomain is being resumed
|
* @resume: The XDomain is being resumed
|
||||||
|
* @needs_uuid: If the XDomain does not have @remote_uuid it will be
|
||||||
|
* queried first
|
||||||
* @transmit_path: HopID which the remote end expects us to transmit
|
* @transmit_path: HopID which the remote end expects us to transmit
|
||||||
* @transmit_ring: Local ring (hop) where outgoing packets are pushed
|
* @transmit_ring: Local ring (hop) where outgoing packets are pushed
|
||||||
* @receive_path: HopID which we expect the remote end to transmit
|
* @receive_path: HopID which we expect the remote end to transmit
|
||||||
|
@ -189,6 +191,9 @@ void tb_unregister_property_dir(const char *key, struct tb_property_dir *dir);
|
||||||
* @properties: Properties exported by the remote domain
|
* @properties: Properties exported by the remote domain
|
||||||
* @property_block_gen: Generation of @properties
|
* @property_block_gen: Generation of @properties
|
||||||
* @properties_lock: Lock protecting @properties.
|
* @properties_lock: Lock protecting @properties.
|
||||||
|
* @get_uuid_work: Work used to retrieve @remote_uuid
|
||||||
|
* @uuid_retries: Number of times left @remote_uuid is requested before
|
||||||
|
* giving up
|
||||||
* @get_properties_work: Work used to get remote domain properties
|
* @get_properties_work: Work used to get remote domain properties
|
||||||
* @properties_retries: Number of times left to read properties
|
* @properties_retries: Number of times left to read properties
|
||||||
* @properties_changed_work: Work used to notify the remote domain that
|
* @properties_changed_work: Work used to notify the remote domain that
|
||||||
|
@ -220,6 +225,7 @@ struct tb_xdomain {
|
||||||
const char *device_name;
|
const char *device_name;
|
||||||
bool is_unplugged;
|
bool is_unplugged;
|
||||||
bool resume;
|
bool resume;
|
||||||
|
bool needs_uuid;
|
||||||
u16 transmit_path;
|
u16 transmit_path;
|
||||||
u16 transmit_ring;
|
u16 transmit_ring;
|
||||||
u16 receive_path;
|
u16 receive_path;
|
||||||
|
@ -227,6 +233,8 @@ struct tb_xdomain {
|
||||||
struct ida service_ids;
|
struct ida service_ids;
|
||||||
struct tb_property_dir *properties;
|
struct tb_property_dir *properties;
|
||||||
u32 property_block_gen;
|
u32 property_block_gen;
|
||||||
|
struct delayed_work get_uuid_work;
|
||||||
|
int uuid_retries;
|
||||||
struct delayed_work get_properties_work;
|
struct delayed_work get_properties_work;
|
||||||
int properties_retries;
|
int properties_retries;
|
||||||
struct delayed_work properties_changed_work;
|
struct delayed_work properties_changed_work;
|
||||||
|
|
Loading…
Reference in a new issue