Commit 3b4b3235 authored by Mika Westerberg's avatar Mika Westerberg
Browse files

thunderbolt: Add XDomain UUID exchange support 



Currently ICM has been handling XDomain UUID exchange so there was no
need to have it in the driver yet. However, since now we are going to
add the same capabilities to the software connection manager it needs to
be handled properly.

For this reason modify the driver XDomain protocol handling so that if
the remote domain UUID is not filled in the core will query it first and
only then start the normal property exchange flow.

Signed-off-by: default avatarMika Westerberg <mika.westerberg@linux.intel.com>
parent 559c1e1e

drivers/thunderbolt/tb_msgs.h

+11 −0
Original line number Diff line number Diff line
@@ -492,6 +492,17 @@ struct tb_xdp_header { 
	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_header hdr;

	uuid_t src_uuid;

drivers/thunderbolt/xdomain.c

+126 −10
Original line number Diff line number Diff line
@@ -18,6 +18,7 @@ 
#include "tb.h"



#define XDOMAIN_DEFAULT_TIMEOUT			5000 /* ms */

#define XDOMAIN_UUID_RETRIES			10

#define XDOMAIN_PROPERTIES_RETRIES		60

#define XDOMAIN_PROPERTIES_CHANGED_RETRIES	10
@@ -222,6 +223,50 @@ static int tb_xdp_handle_error(const struct tb_xdp_header *hdr) 
	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,

				 enum tb_xdp_error error)

{
@@ -512,7 +557,14 @@ static void tb_xdp_handle_request(struct work_struct *work) 
		break;

	}



	case UUID_REQUEST_OLD:

	case UUID_REQUEST:

		ret = tb_xdp_uuid_response(ctl, route, sequence, uuid);

		break;



	default:

		tb_xdp_error_response(ctl, route, sequence,

				      ERROR_NOT_SUPPORTED);

		break;

	}
@@ -839,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)

{

	struct tb_xdomain *xd = container_of(work, typeof(*xd),
@@ -1045,21 +1146,29 @@ static void tb_xdomain_release(struct device *dev) 


static void start_handshake(struct tb_xdomain *xd)

{

	xd->uuid_retries = XDOMAIN_UUID_RETRIES;

	xd->properties_retries = XDOMAIN_PROPERTIES_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 */

		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 stop_handshake(struct tb_xdomain *xd)

{

	xd->uuid_retries = 0;

	xd->properties_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->properties_changed_work);

}
@@ -1102,7 +1211,7 @@ EXPORT_SYMBOL_GPL(tb_xdomain_type); 
 *	    other domain is reached).

 * @route: Route string used to reach the other domain

 * @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

 * object must be released by calling tb_xdomain_put().
@@ -1121,6 +1230,7 @@ struct tb_xdomain *tb_xdomain_alloc(struct tb *tb, struct device *parent, 
	xd->route = route;

	ida_init(&xd->service_ids);

	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->properties_changed_work,

			  tb_xdomain_properties_changed);
@@ -1129,9 +1239,14 @@ struct tb_xdomain *tb_xdomain_alloc(struct tb *tb, struct device *parent, 
	if (!xd->local_uuid)

		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)

			goto err_free_local_uuid;

	} else {

		xd->needs_uuid = true;

	}



	device_initialize(&xd->dev);

	xd->dev.parent = get_device(parent);
@@ -1299,7 +1414,8 @@ static struct tb_xdomain *switch_find_xdomain(struct tb_switch *sw, 
			xd = port->xdomain;



			if (lookup->uuid) {

				if (uuid_equal(xd->remote_uuid, lookup->uuid))

				if (xd->remote_uuid &&

				    uuid_equal(xd->remote_uuid, lookup->uuid))

					return xd;

			} else if (lookup->link &&

				   lookup->link == xd->link &&

include/linux/thunderbolt.h

+8 −0
Original line number Diff line number Diff line
@@ -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)

 * @is_unplugged: The XDomain is unplugged

 * @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_ring: Local ring (hop) where outgoing packets are pushed

 * @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

 * @property_block_gen: Generation of @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

 * @properties_retries: Number of times left to read properties

 * @properties_changed_work: Work used to notify the remote domain that
@@ -220,6 +225,7 @@ struct tb_xdomain { 
	const char *device_name;

	bool is_unplugged;

	bool resume;

	bool needs_uuid;

	u16 transmit_path;

	u16 transmit_ring;

	u16 receive_path;
@@ -227,6 +233,8 @@ struct tb_xdomain { 
	struct ida service_ids;

	struct tb_property_dir *properties;

	u32 property_block_gen;

	struct delayed_work get_uuid_work;

	int uuid_retries;

	struct delayed_work get_properties_work;

	int properties_retries;

	struct delayed_work properties_changed_work;

CRA Git | Maintained and supported by SUSTech CRA and CCSE