8afe909b78
To perform proper Display Port tunneling for Thunderbolt 3 devices we need to allocate DP resources for DP IN port before they can be used. The reason for this is that the user can also connect a monitor directly to the Type-C ports in which case the Thunderbolt controller acts as re-driver for Display Port (no tunneling takes place) taking the DP sinks away from the connection manager. This allocation is done using special sink allocation registers available through the link controller. We can pair DP IN to DP OUT only if * DP IN has sink allocated via link controller * DP OUT port receives hotplug event For DP IN adapters (only for the host router) we first query whether there is DP resource available (it may be the previous instance of the driver for example already allocated it) and if it is we add it to the list. We then update the list when after each plug/unplug event to a DP IN/OUT adapter. Each time the list is updated we try to find additional DP IN <-> DP OUT pairs for tunnel establishment. This strategy also makes it possible to establish another tunnel in case there are 3 monitors connected and one gets unplugged releasing the DP IN adapter for the new tunnel. Signed-off-by: Mika Westerberg <mika.westerberg@linux.intel.com>
369 lines
8.1 KiB
C
369 lines
8.1 KiB
C
// 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 (!tb_route(sw) || tb_switch_is_icm(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 || !tb_route(sw) || tb_switch_is_icm(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;
|
|
}
|
|
|
|
/**
|
|
* tb_lc_lane_bonding_possible() - Is lane bonding possible towards switch
|
|
* @sw: Switch to check
|
|
*
|
|
* Checks whether conditions for lane bonding from parent to @sw are
|
|
* possible.
|
|
*/
|
|
bool tb_lc_lane_bonding_possible(struct tb_switch *sw)
|
|
{
|
|
struct tb_port *up;
|
|
int cap, ret;
|
|
u32 val;
|
|
|
|
if (sw->generation < 2)
|
|
return false;
|
|
|
|
up = tb_upstream_port(sw);
|
|
cap = find_port_lc_cap(up);
|
|
if (cap < 0)
|
|
return false;
|
|
|
|
ret = tb_sw_read(sw, &val, TB_CFG_SWITCH, cap + TB_LC_PORT_ATTR, 1);
|
|
if (ret)
|
|
return false;
|
|
|
|
return !!(val & TB_LC_PORT_ATTR_BE);
|
|
}
|
|
|
|
static int tb_lc_dp_sink_from_port(const struct tb_switch *sw,
|
|
struct tb_port *in)
|
|
{
|
|
struct tb_port *port;
|
|
|
|
/* The first DP IN port is sink 0 and second is sink 1 */
|
|
tb_switch_for_each_port(sw, port) {
|
|
if (tb_port_is_dpin(port))
|
|
return in != port;
|
|
}
|
|
|
|
return -EINVAL;
|
|
}
|
|
|
|
static int tb_lc_dp_sink_available(struct tb_switch *sw, int sink)
|
|
{
|
|
u32 val, alloc;
|
|
int ret;
|
|
|
|
ret = tb_sw_read(sw, &val, TB_CFG_SWITCH,
|
|
sw->cap_lc + TB_LC_SNK_ALLOCATION, 1);
|
|
if (ret)
|
|
return ret;
|
|
|
|
/*
|
|
* Sink is available for CM/SW to use if the allocation valie is
|
|
* either 0 or 1.
|
|
*/
|
|
if (!sink) {
|
|
alloc = val & TB_LC_SNK_ALLOCATION_SNK0_MASK;
|
|
if (!alloc || alloc == TB_LC_SNK_ALLOCATION_SNK0_CM)
|
|
return 0;
|
|
} else {
|
|
alloc = (val & TB_LC_SNK_ALLOCATION_SNK1_MASK) >>
|
|
TB_LC_SNK_ALLOCATION_SNK1_SHIFT;
|
|
if (!alloc || alloc == TB_LC_SNK_ALLOCATION_SNK1_CM)
|
|
return 0;
|
|
}
|
|
|
|
return -EBUSY;
|
|
}
|
|
|
|
/**
|
|
* tb_lc_dp_sink_query() - Is DP sink available for DP IN port
|
|
* @sw: Switch whose DP sink is queried
|
|
* @in: DP IN port to check
|
|
*
|
|
* Queries through LC SNK_ALLOCATION registers whether DP sink is available
|
|
* for the given DP IN port or not.
|
|
*/
|
|
bool tb_lc_dp_sink_query(struct tb_switch *sw, struct tb_port *in)
|
|
{
|
|
int sink;
|
|
|
|
/*
|
|
* For older generations sink is always available as there is no
|
|
* allocation mechanism.
|
|
*/
|
|
if (sw->generation < 3)
|
|
return true;
|
|
|
|
sink = tb_lc_dp_sink_from_port(sw, in);
|
|
if (sink < 0)
|
|
return false;
|
|
|
|
return !tb_lc_dp_sink_available(sw, sink);
|
|
}
|
|
|
|
/**
|
|
* tb_lc_dp_sink_alloc() - Allocate DP sink
|
|
* @sw: Switch whose DP sink is allocated
|
|
* @in: DP IN port the DP sink is allocated for
|
|
*
|
|
* Allocate DP sink for @in via LC SNK_ALLOCATION registers. If the
|
|
* resource is available and allocation is successful returns %0. In all
|
|
* other cases returs negative errno. In particular %-EBUSY is returned if
|
|
* the resource was not available.
|
|
*/
|
|
int tb_lc_dp_sink_alloc(struct tb_switch *sw, struct tb_port *in)
|
|
{
|
|
int ret, sink;
|
|
u32 val;
|
|
|
|
if (sw->generation < 3)
|
|
return 0;
|
|
|
|
sink = tb_lc_dp_sink_from_port(sw, in);
|
|
if (sink < 0)
|
|
return sink;
|
|
|
|
ret = tb_lc_dp_sink_available(sw, sink);
|
|
if (ret)
|
|
return ret;
|
|
|
|
ret = tb_sw_read(sw, &val, TB_CFG_SWITCH,
|
|
sw->cap_lc + TB_LC_SNK_ALLOCATION, 1);
|
|
if (ret)
|
|
return ret;
|
|
|
|
if (!sink) {
|
|
val &= ~TB_LC_SNK_ALLOCATION_SNK0_MASK;
|
|
val |= TB_LC_SNK_ALLOCATION_SNK0_CM;
|
|
} else {
|
|
val &= ~TB_LC_SNK_ALLOCATION_SNK1_MASK;
|
|
val |= TB_LC_SNK_ALLOCATION_SNK1_CM <<
|
|
TB_LC_SNK_ALLOCATION_SNK1_SHIFT;
|
|
}
|
|
|
|
ret = tb_sw_write(sw, &val, TB_CFG_SWITCH,
|
|
sw->cap_lc + TB_LC_SNK_ALLOCATION, 1);
|
|
|
|
if (ret)
|
|
return ret;
|
|
|
|
tb_port_dbg(in, "sink %d allocated\n", sink);
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* tb_lc_dp_sink_dealloc() - De-allocate DP sink
|
|
* @sw: Switch whose DP sink is de-allocated
|
|
* @in: DP IN port whose DP sink is de-allocated
|
|
*
|
|
* De-allocate DP sink from @in using LC SNK_ALLOCATION registers.
|
|
*/
|
|
int tb_lc_dp_sink_dealloc(struct tb_switch *sw, struct tb_port *in)
|
|
{
|
|
int ret, sink;
|
|
u32 val;
|
|
|
|
if (sw->generation < 3)
|
|
return 0;
|
|
|
|
sink = tb_lc_dp_sink_from_port(sw, in);
|
|
if (sink < 0)
|
|
return sink;
|
|
|
|
/* Needs to be owned by CM/SW */
|
|
ret = tb_lc_dp_sink_available(sw, sink);
|
|
if (ret)
|
|
return ret;
|
|
|
|
ret = tb_sw_read(sw, &val, TB_CFG_SWITCH,
|
|
sw->cap_lc + TB_LC_SNK_ALLOCATION, 1);
|
|
if (ret)
|
|
return ret;
|
|
|
|
if (!sink)
|
|
val &= ~TB_LC_SNK_ALLOCATION_SNK0_MASK;
|
|
else
|
|
val &= ~TB_LC_SNK_ALLOCATION_SNK1_MASK;
|
|
|
|
ret = tb_sw_write(sw, &val, TB_CFG_SWITCH,
|
|
sw->cap_lc + TB_LC_SNK_ALLOCATION, 1);
|
|
if (ret)
|
|
return ret;
|
|
|
|
tb_port_dbg(in, "sink %d de-allocated\n", sink);
|
|
return 0;
|
|
}
|