1// SPDX-License-Identifier: GPL-2.0
   2/*
   3 * Thunderbolt XDomain discovery protocol support
   4 *
   5 * Copyright (C) 2017, Intel Corporation
   6 * Authors: Michael Jamet <michael.jamet@intel.com>
   7 *          Mika Westerberg <mika.westerberg@linux.intel.com>
   8 */
   9
  10#include <linux/device.h>
  11#include <linux/delay.h>
  12#include <linux/kmod.h>
  13#include <linux/module.h>
  14#include <linux/pm_runtime.h>
  15#include <linux/prandom.h>
  16#include <linux/string_helpers.h>
  17#include <linux/utsname.h>
  18#include <linux/uuid.h>
  19#include <linux/workqueue.h>
  20
  21#include "tb.h"
  22
  23#define XDOMAIN_SHORT_TIMEOUT			100	/* ms */
  24#define XDOMAIN_DEFAULT_TIMEOUT			1000	/* ms */
  25#define XDOMAIN_BONDING_TIMEOUT			10000	/* ms */
  26#define XDOMAIN_RETRIES				10
  27#define XDOMAIN_DEFAULT_MAX_HOPID		15
  28
  29enum {
  30	XDOMAIN_STATE_INIT,
  31	XDOMAIN_STATE_UUID,
  32	XDOMAIN_STATE_LINK_STATUS,
  33	XDOMAIN_STATE_LINK_STATE_CHANGE,
  34	XDOMAIN_STATE_LINK_STATUS2,
  35	XDOMAIN_STATE_BONDING_UUID_LOW,
  36	XDOMAIN_STATE_BONDING_UUID_HIGH,
  37	XDOMAIN_STATE_PROPERTIES,
  38	XDOMAIN_STATE_ENUMERATED,
  39	XDOMAIN_STATE_ERROR,
  40};
  41
  42static const char * const state_names[] = {
  43	[XDOMAIN_STATE_INIT] = "INIT",
  44	[XDOMAIN_STATE_UUID] = "UUID",
  45	[XDOMAIN_STATE_LINK_STATUS] = "LINK_STATUS",
  46	[XDOMAIN_STATE_LINK_STATE_CHANGE] = "LINK_STATE_CHANGE",
  47	[XDOMAIN_STATE_LINK_STATUS2] = "LINK_STATUS2",
  48	[XDOMAIN_STATE_BONDING_UUID_LOW] = "BONDING_UUID_LOW",
  49	[XDOMAIN_STATE_BONDING_UUID_HIGH] = "BONDING_UUID_HIGH",
  50	[XDOMAIN_STATE_PROPERTIES] = "PROPERTIES",
  51	[XDOMAIN_STATE_ENUMERATED] = "ENUMERATED",
  52	[XDOMAIN_STATE_ERROR] = "ERROR",
  53};
  54
  55struct xdomain_request_work {
  56	struct work_struct work;
  57	struct tb_xdp_header *pkg;
  58	struct tb *tb;
  59};
  60
  61static bool tb_xdomain_enabled = true;
  62module_param_named(xdomain, tb_xdomain_enabled, bool, 0444);
  63MODULE_PARM_DESC(xdomain, "allow XDomain protocol (default: true)");
  64
  65/*
  66 * Serializes access to the properties and protocol handlers below. If
  67 * you need to take both this lock and the struct tb_xdomain lock, take
  68 * this one first.
  69 */
  70static DEFINE_MUTEX(xdomain_lock);
  71
  72/* Properties exposed to the remote domains */
  73static struct tb_property_dir *xdomain_property_dir;
 
 
  74static u32 xdomain_property_block_gen;
  75
  76/* Additional protocol handlers */
  77static LIST_HEAD(protocol_handlers);
  78
  79/* UUID for XDomain discovery protocol: b638d70e-42ff-40bb-97c2-90e2c0b2ff07 */
  80static const uuid_t tb_xdp_uuid =
  81	UUID_INIT(0xb638d70e, 0x42ff, 0x40bb,
  82		  0x97, 0xc2, 0x90, 0xe2, 0xc0, 0xb2, 0xff, 0x07);
  83
  84bool tb_is_xdomain_enabled(void)
  85{
  86	return tb_xdomain_enabled && tb_acpi_is_xdomain_allowed();
  87}
  88
  89static bool tb_xdomain_match(const struct tb_cfg_request *req,
  90			     const struct ctl_pkg *pkg)
  91{
  92	switch (pkg->frame.eof) {
  93	case TB_CFG_PKG_ERROR:
  94		return true;
  95
  96	case TB_CFG_PKG_XDOMAIN_RESP: {
  97		const struct tb_xdp_header *res_hdr = pkg->buffer;
  98		const struct tb_xdp_header *req_hdr = req->request;
  99
 100		if (pkg->frame.size < req->response_size / 4)
 101			return false;
 102
 103		/* Make sure route matches */
 104		if ((res_hdr->xd_hdr.route_hi & ~BIT(31)) !=
 105		     req_hdr->xd_hdr.route_hi)
 106			return false;
 107		if ((res_hdr->xd_hdr.route_lo) != req_hdr->xd_hdr.route_lo)
 108			return false;
 109
 110		/* Check that the XDomain protocol matches */
 111		if (!uuid_equal(&res_hdr->uuid, &req_hdr->uuid))
 112			return false;
 113
 114		return true;
 115	}
 116
 117	default:
 118		return false;
 119	}
 120}
 121
 122static bool tb_xdomain_copy(struct tb_cfg_request *req,
 123			    const struct ctl_pkg *pkg)
 124{
 125	memcpy(req->response, pkg->buffer, req->response_size);
 126	req->result.err = 0;
 127	return true;
 128}
 129
 130static void response_ready(void *data)
 131{
 132	tb_cfg_request_put(data);
 133}
 134
 135static int __tb_xdomain_response(struct tb_ctl *ctl, const void *response,
 136				 size_t size, enum tb_cfg_pkg_type type)
 137{
 138	struct tb_cfg_request *req;
 139
 140	req = tb_cfg_request_alloc();
 141	if (!req)
 142		return -ENOMEM;
 143
 144	req->match = tb_xdomain_match;
 145	req->copy = tb_xdomain_copy;
 146	req->request = response;
 147	req->request_size = size;
 148	req->request_type = type;
 149
 150	return tb_cfg_request(ctl, req, response_ready, req);
 151}
 152
 153/**
 154 * tb_xdomain_response() - Send a XDomain response message
 155 * @xd: XDomain to send the message
 156 * @response: Response to send
 157 * @size: Size of the response
 158 * @type: PDF type of the response
 159 *
 160 * This can be used to send a XDomain response message to the other
 161 * domain. No response for the message is expected.
 162 *
 163 * Return: %0 in case of success and negative errno in case of failure
 164 */
 165int tb_xdomain_response(struct tb_xdomain *xd, const void *response,
 166			size_t size, enum tb_cfg_pkg_type type)
 167{
 168	return __tb_xdomain_response(xd->tb->ctl, response, size, type);
 169}
 170EXPORT_SYMBOL_GPL(tb_xdomain_response);
 171
 172static int __tb_xdomain_request(struct tb_ctl *ctl, const void *request,
 173	size_t request_size, enum tb_cfg_pkg_type request_type, void *response,
 174	size_t response_size, enum tb_cfg_pkg_type response_type,
 175	unsigned int timeout_msec)
 176{
 177	struct tb_cfg_request *req;
 178	struct tb_cfg_result res;
 179
 180	req = tb_cfg_request_alloc();
 181	if (!req)
 182		return -ENOMEM;
 183
 184	req->match = tb_xdomain_match;
 185	req->copy = tb_xdomain_copy;
 186	req->request = request;
 187	req->request_size = request_size;
 188	req->request_type = request_type;
 189	req->response = response;
 190	req->response_size = response_size;
 191	req->response_type = response_type;
 192
 193	res = tb_cfg_request_sync(ctl, req, timeout_msec);
 194
 195	tb_cfg_request_put(req);
 196
 197	return res.err == 1 ? -EIO : res.err;
 198}
 199
 200/**
 201 * tb_xdomain_request() - Send a XDomain request
 202 * @xd: XDomain to send the request
 203 * @request: Request to send
 204 * @request_size: Size of the request in bytes
 205 * @request_type: PDF type of the request
 206 * @response: Response is copied here
 207 * @response_size: Expected size of the response in bytes
 208 * @response_type: Expected PDF type of the response
 209 * @timeout_msec: Timeout in milliseconds to wait for the response
 210 *
 211 * This function can be used to send XDomain control channel messages to
 212 * the other domain. The function waits until the response is received
 213 * or when timeout triggers. Whichever comes first.
 214 *
 215 * Return: %0 in case of success and negative errno in case of failure
 216 */
 217int tb_xdomain_request(struct tb_xdomain *xd, const void *request,
 218	size_t request_size, enum tb_cfg_pkg_type request_type,
 219	void *response, size_t response_size,
 220	enum tb_cfg_pkg_type response_type, unsigned int timeout_msec)
 221{
 222	return __tb_xdomain_request(xd->tb->ctl, request, request_size,
 223				    request_type, response, response_size,
 224				    response_type, timeout_msec);
 225}
 226EXPORT_SYMBOL_GPL(tb_xdomain_request);
 227
 228static inline void tb_xdp_fill_header(struct tb_xdp_header *hdr, u64 route,
 229	u8 sequence, enum tb_xdp_type type, size_t size)
 230{
 231	u32 length_sn;
 232
 233	length_sn = (size - sizeof(hdr->xd_hdr)) / 4;
 234	length_sn |= (sequence << TB_XDOMAIN_SN_SHIFT) & TB_XDOMAIN_SN_MASK;
 235
 236	hdr->xd_hdr.route_hi = upper_32_bits(route);
 237	hdr->xd_hdr.route_lo = lower_32_bits(route);
 238	hdr->xd_hdr.length_sn = length_sn;
 239	hdr->type = type;
 240	memcpy(&hdr->uuid, &tb_xdp_uuid, sizeof(tb_xdp_uuid));
 241}
 242
 243static int tb_xdp_handle_error(const struct tb_xdp_error_response *res)
 244{
 245	if (res->hdr.type != ERROR_RESPONSE)
 
 
 246		return 0;
 247
 248	switch (res->error) {
 
 
 249	case ERROR_UNKNOWN_PACKET:
 250	case ERROR_UNKNOWN_DOMAIN:
 251		return -EIO;
 252	case ERROR_NOT_SUPPORTED:
 253		return -ENOTSUPP;
 254	case ERROR_NOT_READY:
 255		return -EAGAIN;
 256	default:
 257		break;
 258	}
 259
 260	return 0;
 261}
 262
 263static int tb_xdp_uuid_request(struct tb_ctl *ctl, u64 route, int retry,
 264			       uuid_t *uuid, u64 *remote_route)
 265{
 266	struct tb_xdp_uuid_response res;
 267	struct tb_xdp_uuid req;
 268	int ret;
 269
 270	memset(&req, 0, sizeof(req));
 271	tb_xdp_fill_header(&req.hdr, route, retry % 4, UUID_REQUEST,
 272			   sizeof(req));
 273
 274	memset(&res, 0, sizeof(res));
 275	ret = __tb_xdomain_request(ctl, &req, sizeof(req),
 276				   TB_CFG_PKG_XDOMAIN_REQ, &res, sizeof(res),
 277				   TB_CFG_PKG_XDOMAIN_RESP,
 278				   XDOMAIN_DEFAULT_TIMEOUT);
 279	if (ret)
 280		return ret;
 281
 282	ret = tb_xdp_handle_error(&res.err);
 283	if (ret)
 284		return ret;
 285
 286	uuid_copy(uuid, &res.src_uuid);
 287	*remote_route = (u64)res.src_route_hi << 32 | res.src_route_lo;
 288
 289	return 0;
 290}
 291
 292static int tb_xdp_uuid_response(struct tb_ctl *ctl, u64 route, u8 sequence,
 293				const uuid_t *uuid)
 294{
 295	struct tb_xdp_uuid_response res;
 296
 297	memset(&res, 0, sizeof(res));
 298	tb_xdp_fill_header(&res.hdr, route, sequence, UUID_RESPONSE,
 299			   sizeof(res));
 300
 301	uuid_copy(&res.src_uuid, uuid);
 302	res.src_route_hi = upper_32_bits(route);
 303	res.src_route_lo = lower_32_bits(route);
 304
 305	return __tb_xdomain_response(ctl, &res, sizeof(res),
 306				     TB_CFG_PKG_XDOMAIN_RESP);
 307}
 308
 309static int tb_xdp_error_response(struct tb_ctl *ctl, u64 route, u8 sequence,
 310				 enum tb_xdp_error error)
 311{
 312	struct tb_xdp_error_response res;
 313
 314	memset(&res, 0, sizeof(res));
 315	tb_xdp_fill_header(&res.hdr, route, sequence, ERROR_RESPONSE,
 316			   sizeof(res));
 317	res.error = error;
 318
 319	return __tb_xdomain_response(ctl, &res, sizeof(res),
 320				     TB_CFG_PKG_XDOMAIN_RESP);
 321}
 322
 323static int tb_xdp_properties_request(struct tb_ctl *ctl, u64 route,
 324	const uuid_t *src_uuid, const uuid_t *dst_uuid, int retry,
 325	u32 **block, u32 *generation)
 326{
 327	struct tb_xdp_properties_response *res;
 328	struct tb_xdp_properties req;
 329	u16 data_len, len;
 330	size_t total_size;
 331	u32 *data = NULL;
 332	int ret;
 333
 334	total_size = sizeof(*res) + TB_XDP_PROPERTIES_MAX_DATA_LENGTH * 4;
 335	res = kzalloc(total_size, GFP_KERNEL);
 336	if (!res)
 337		return -ENOMEM;
 338
 339	memset(&req, 0, sizeof(req));
 340	tb_xdp_fill_header(&req.hdr, route, retry % 4, PROPERTIES_REQUEST,
 341			   sizeof(req));
 342	memcpy(&req.src_uuid, src_uuid, sizeof(*src_uuid));
 343	memcpy(&req.dst_uuid, dst_uuid, sizeof(*dst_uuid));
 344
 
 345	data_len = 0;
 346
 347	do {
 348		ret = __tb_xdomain_request(ctl, &req, sizeof(req),
 349					   TB_CFG_PKG_XDOMAIN_REQ, res,
 350					   total_size, TB_CFG_PKG_XDOMAIN_RESP,
 351					   XDOMAIN_DEFAULT_TIMEOUT);
 352		if (ret)
 353			goto err;
 354
 355		ret = tb_xdp_handle_error(&res->err);
 356		if (ret)
 357			goto err;
 358
 359		/*
 360		 * Package length includes the whole payload without the
 361		 * XDomain header. Validate first that the package is at
 362		 * least size of the response structure.
 363		 */
 364		len = res->hdr.xd_hdr.length_sn & TB_XDOMAIN_LENGTH_MASK;
 365		if (len < sizeof(*res) / 4) {
 366			ret = -EINVAL;
 367			goto err;
 368		}
 369
 370		len += sizeof(res->hdr.xd_hdr) / 4;
 371		len -= sizeof(*res) / 4;
 372
 373		if (res->offset != req.offset) {
 374			ret = -EINVAL;
 375			goto err;
 376		}
 377
 378		/*
 379		 * First time allocate block that has enough space for
 380		 * the whole properties block.
 381		 */
 382		if (!data) {
 383			data_len = res->data_length;
 384			if (data_len > TB_XDP_PROPERTIES_MAX_LENGTH) {
 385				ret = -E2BIG;
 386				goto err;
 387			}
 388
 389			data = kcalloc(data_len, sizeof(u32), GFP_KERNEL);
 390			if (!data) {
 391				ret = -ENOMEM;
 392				goto err;
 393			}
 394		}
 395
 396		memcpy(data + req.offset, res->data, len * 4);
 397		req.offset += len;
 398	} while (!data_len || req.offset < data_len);
 399
 400	*block = data;
 401	*generation = res->generation;
 402
 403	kfree(res);
 404
 405	return data_len;
 406
 407err:
 408	kfree(data);
 409	kfree(res);
 410
 411	return ret;
 412}
 413
 414static int tb_xdp_properties_response(struct tb *tb, struct tb_ctl *ctl,
 415	struct tb_xdomain *xd, u8 sequence, const struct tb_xdp_properties *req)
 
 416{
 417	struct tb_xdp_properties_response *res;
 418	size_t total_size;
 419	u16 len;
 420	int ret;
 421
 422	/*
 423	 * Currently we expect all requests to be directed to us. The
 424	 * protocol supports forwarding, though which we might add
 425	 * support later on.
 426	 */
 427	if (!uuid_equal(xd->local_uuid, &req->dst_uuid)) {
 428		tb_xdp_error_response(ctl, xd->route, sequence,
 429				      ERROR_UNKNOWN_DOMAIN);
 430		return 0;
 431	}
 432
 433	mutex_lock(&xd->lock);
 434
 435	if (req->offset >= xd->local_property_block_len) {
 436		mutex_unlock(&xd->lock);
 437		return -EINVAL;
 438	}
 439
 440	len = xd->local_property_block_len - req->offset;
 441	len = min_t(u16, len, TB_XDP_PROPERTIES_MAX_DATA_LENGTH);
 442	total_size = sizeof(*res) + len * 4;
 443
 444	res = kzalloc(total_size, GFP_KERNEL);
 445	if (!res) {
 446		mutex_unlock(&xd->lock);
 447		return -ENOMEM;
 448	}
 449
 450	tb_xdp_fill_header(&res->hdr, xd->route, sequence, PROPERTIES_RESPONSE,
 451			   total_size);
 452	res->generation = xd->local_property_block_gen;
 453	res->data_length = xd->local_property_block_len;
 454	res->offset = req->offset;
 455	uuid_copy(&res->src_uuid, xd->local_uuid);
 456	uuid_copy(&res->dst_uuid, &req->src_uuid);
 457	memcpy(res->data, &xd->local_property_block[req->offset], len * 4);
 458
 459	mutex_unlock(&xd->lock);
 460
 461	ret = __tb_xdomain_response(ctl, res, total_size,
 462				    TB_CFG_PKG_XDOMAIN_RESP);
 463
 464	kfree(res);
 465	return ret;
 466}
 467
 468static int tb_xdp_properties_changed_request(struct tb_ctl *ctl, u64 route,
 469					     int retry, const uuid_t *uuid)
 470{
 471	struct tb_xdp_properties_changed_response res;
 472	struct tb_xdp_properties_changed req;
 473	int ret;
 474
 475	memset(&req, 0, sizeof(req));
 476	tb_xdp_fill_header(&req.hdr, route, retry % 4,
 477			   PROPERTIES_CHANGED_REQUEST, sizeof(req));
 478	uuid_copy(&req.src_uuid, uuid);
 479
 480	memset(&res, 0, sizeof(res));
 481	ret = __tb_xdomain_request(ctl, &req, sizeof(req),
 482				   TB_CFG_PKG_XDOMAIN_REQ, &res, sizeof(res),
 483				   TB_CFG_PKG_XDOMAIN_RESP,
 484				   XDOMAIN_DEFAULT_TIMEOUT);
 485	if (ret)
 486		return ret;
 487
 488	return tb_xdp_handle_error(&res.err);
 489}
 490
 491static int
 492tb_xdp_properties_changed_response(struct tb_ctl *ctl, u64 route, u8 sequence)
 493{
 494	struct tb_xdp_properties_changed_response res;
 495
 496	memset(&res, 0, sizeof(res));
 497	tb_xdp_fill_header(&res.hdr, route, sequence,
 498			   PROPERTIES_CHANGED_RESPONSE, sizeof(res));
 499	return __tb_xdomain_response(ctl, &res, sizeof(res),
 500				     TB_CFG_PKG_XDOMAIN_RESP);
 501}
 502
 503static int tb_xdp_link_state_status_request(struct tb_ctl *ctl, u64 route,
 504					    u8 sequence, u8 *slw, u8 *tlw,
 505					    u8 *sls, u8 *tls)
 506{
 507	struct tb_xdp_link_state_status_response res;
 508	struct tb_xdp_link_state_status req;
 509	int ret;
 510
 511	memset(&req, 0, sizeof(req));
 512	tb_xdp_fill_header(&req.hdr, route, sequence, LINK_STATE_STATUS_REQUEST,
 513			   sizeof(req));
 514
 515	memset(&res, 0, sizeof(res));
 516	ret = __tb_xdomain_request(ctl, &req, sizeof(req), TB_CFG_PKG_XDOMAIN_REQ,
 517				   &res, sizeof(res), TB_CFG_PKG_XDOMAIN_RESP,
 518				   XDOMAIN_DEFAULT_TIMEOUT);
 519	if (ret)
 520		return ret;
 521
 522	ret = tb_xdp_handle_error(&res.err);
 523	if (ret)
 524		return ret;
 525
 526	if (res.status != 0)
 527		return -EREMOTEIO;
 528
 529	*slw = res.slw;
 530	*tlw = res.tlw;
 531	*sls = res.sls;
 532	*tls = res.tls;
 533
 534	return 0;
 535}
 536
 537static int tb_xdp_link_state_status_response(struct tb *tb, struct tb_ctl *ctl,
 538					     struct tb_xdomain *xd, u8 sequence)
 539{
 540	struct tb_xdp_link_state_status_response res;
 541	struct tb_port *port = tb_xdomain_downstream_port(xd);
 542	u32 val[2];
 543	int ret;
 544
 545	memset(&res, 0, sizeof(res));
 546	tb_xdp_fill_header(&res.hdr, xd->route, sequence,
 547			   LINK_STATE_STATUS_RESPONSE, sizeof(res));
 548
 549	ret = tb_port_read(port, val, TB_CFG_PORT,
 550			   port->cap_phy + LANE_ADP_CS_0, ARRAY_SIZE(val));
 551	if (ret)
 552		return ret;
 553
 554	res.slw = (val[0] & LANE_ADP_CS_0_SUPPORTED_WIDTH_MASK) >>
 555			LANE_ADP_CS_0_SUPPORTED_WIDTH_SHIFT;
 556	res.sls = (val[0] & LANE_ADP_CS_0_SUPPORTED_SPEED_MASK) >>
 557			LANE_ADP_CS_0_SUPPORTED_SPEED_SHIFT;
 558	res.tls = val[1] & LANE_ADP_CS_1_TARGET_SPEED_MASK;
 559	res.tlw = (val[1] & LANE_ADP_CS_1_TARGET_WIDTH_MASK) >>
 560			LANE_ADP_CS_1_TARGET_WIDTH_SHIFT;
 561
 562	return __tb_xdomain_response(ctl, &res, sizeof(res),
 563				     TB_CFG_PKG_XDOMAIN_RESP);
 564}
 565
 566static int tb_xdp_link_state_change_request(struct tb_ctl *ctl, u64 route,
 567					    u8 sequence, u8 tlw, u8 tls)
 568{
 569	struct tb_xdp_link_state_change_response res;
 570	struct tb_xdp_link_state_change req;
 571	int ret;
 572
 573	memset(&req, 0, sizeof(req));
 574	tb_xdp_fill_header(&req.hdr, route, sequence, LINK_STATE_CHANGE_REQUEST,
 575			   sizeof(req));
 576	req.tlw = tlw;
 577	req.tls = tls;
 578
 579	memset(&res, 0, sizeof(res));
 580	ret = __tb_xdomain_request(ctl, &req, sizeof(req), TB_CFG_PKG_XDOMAIN_REQ,
 581				   &res, sizeof(res), TB_CFG_PKG_XDOMAIN_RESP,
 582				   XDOMAIN_DEFAULT_TIMEOUT);
 583	if (ret)
 584		return ret;
 585
 586	ret = tb_xdp_handle_error(&res.err);
 587	if (ret)
 588		return ret;
 589
 590	return res.status != 0 ? -EREMOTEIO : 0;
 591}
 592
 593static int tb_xdp_link_state_change_response(struct tb_ctl *ctl, u64 route,
 594					     u8 sequence, u32 status)
 595{
 596	struct tb_xdp_link_state_change_response res;
 597
 598	memset(&res, 0, sizeof(res));
 599	tb_xdp_fill_header(&res.hdr, route, sequence, LINK_STATE_CHANGE_RESPONSE,
 600			   sizeof(res));
 601
 602	res.status = status;
 603
 604	return __tb_xdomain_response(ctl, &res, sizeof(res),
 605				     TB_CFG_PKG_XDOMAIN_RESP);
 606}
 607
 608/**
 609 * tb_register_protocol_handler() - Register protocol handler
 610 * @handler: Handler to register
 611 *
 612 * This allows XDomain service drivers to hook into incoming XDomain
 613 * messages. After this function is called the service driver needs to
 614 * be able to handle calls to callback whenever a package with the
 615 * registered protocol is received.
 616 */
 617int tb_register_protocol_handler(struct tb_protocol_handler *handler)
 618{
 619	if (!handler->uuid || !handler->callback)
 620		return -EINVAL;
 621	if (uuid_equal(handler->uuid, &tb_xdp_uuid))
 622		return -EINVAL;
 623
 624	mutex_lock(&xdomain_lock);
 625	list_add_tail(&handler->list, &protocol_handlers);
 626	mutex_unlock(&xdomain_lock);
 627
 628	return 0;
 629}
 630EXPORT_SYMBOL_GPL(tb_register_protocol_handler);
 631
 632/**
 633 * tb_unregister_protocol_handler() - Unregister protocol handler
 634 * @handler: Handler to unregister
 635 *
 636 * Removes the previously registered protocol handler.
 637 */
 638void tb_unregister_protocol_handler(struct tb_protocol_handler *handler)
 639{
 640	mutex_lock(&xdomain_lock);
 641	list_del_init(&handler->list);
 642	mutex_unlock(&xdomain_lock);
 643}
 644EXPORT_SYMBOL_GPL(tb_unregister_protocol_handler);
 645
 646static void update_property_block(struct tb_xdomain *xd)
 647{
 648	mutex_lock(&xdomain_lock);
 649	mutex_lock(&xd->lock);
 650	/*
 651	 * If the local property block is not up-to-date, rebuild it now
 652	 * based on the global property template.
 653	 */
 654	if (!xd->local_property_block ||
 655	    xd->local_property_block_gen < xdomain_property_block_gen) {
 656		struct tb_property_dir *dir;
 657		int ret, block_len;
 658		u32 *block;
 659
 660		dir = tb_property_copy_dir(xdomain_property_dir);
 661		if (!dir) {
 662			dev_warn(&xd->dev, "failed to copy properties\n");
 663			goto out_unlock;
 664		}
 665
 666		/* Fill in non-static properties now */
 667		tb_property_add_text(dir, "deviceid", utsname()->nodename);
 668		tb_property_add_immediate(dir, "maxhopid", xd->local_max_hopid);
 669
 670		ret = tb_property_format_dir(dir, NULL, 0);
 671		if (ret < 0) {
 672			dev_warn(&xd->dev, "local property block creation failed\n");
 673			tb_property_free_dir(dir);
 674			goto out_unlock;
 675		}
 676
 677		block_len = ret;
 678		block = kcalloc(block_len, sizeof(*block), GFP_KERNEL);
 679		if (!block) {
 680			tb_property_free_dir(dir);
 681			goto out_unlock;
 682		}
 683
 684		ret = tb_property_format_dir(dir, block, block_len);
 685		if (ret) {
 686			dev_warn(&xd->dev, "property block generation failed\n");
 687			tb_property_free_dir(dir);
 688			kfree(block);
 689			goto out_unlock;
 690		}
 691
 692		tb_property_free_dir(dir);
 693		/* Release the previous block */
 694		kfree(xd->local_property_block);
 695		/* Assign new one */
 696		xd->local_property_block = block;
 697		xd->local_property_block_len = block_len;
 698		xd->local_property_block_gen = xdomain_property_block_gen;
 699	}
 700
 701out_unlock:
 702	mutex_unlock(&xd->lock);
 703	mutex_unlock(&xdomain_lock);
 704}
 705
 706static void start_handshake(struct tb_xdomain *xd)
 707{
 708	xd->state = XDOMAIN_STATE_INIT;
 709	queue_delayed_work(xd->tb->wq, &xd->state_work,
 710			   msecs_to_jiffies(XDOMAIN_SHORT_TIMEOUT));
 711}
 712
 713/* Can be called from state_work */
 714static void __stop_handshake(struct tb_xdomain *xd)
 715{
 716	cancel_delayed_work_sync(&xd->properties_changed_work);
 717	xd->properties_changed_retries = 0;
 718	xd->state_retries = 0;
 719}
 720
 721static void stop_handshake(struct tb_xdomain *xd)
 722{
 723	cancel_delayed_work_sync(&xd->state_work);
 724	__stop_handshake(xd);
 
 
 
 
 
 
 
 
 
 
 725}
 726
 727static void tb_xdp_handle_request(struct work_struct *work)
 728{
 729	struct xdomain_request_work *xw = container_of(work, typeof(*xw), work);
 730	const struct tb_xdp_header *pkg = xw->pkg;
 731	const struct tb_xdomain_header *xhdr = &pkg->xd_hdr;
 732	struct tb *tb = xw->tb;
 733	struct tb_ctl *ctl = tb->ctl;
 734	struct tb_xdomain *xd;
 735	const uuid_t *uuid;
 736	int ret = 0;
 737	u32 sequence;
 738	u64 route;
 739
 740	route = ((u64)xhdr->route_hi << 32 | xhdr->route_lo) & ~BIT_ULL(63);
 741	sequence = xhdr->length_sn & TB_XDOMAIN_SN_MASK;
 742	sequence >>= TB_XDOMAIN_SN_SHIFT;
 743
 744	mutex_lock(&tb->lock);
 745	if (tb->root_switch)
 746		uuid = tb->root_switch->uuid;
 747	else
 748		uuid = NULL;
 749	mutex_unlock(&tb->lock);
 750
 751	if (!uuid) {
 752		tb_xdp_error_response(ctl, route, sequence, ERROR_NOT_READY);
 753		goto out;
 754	}
 755
 756	xd = tb_xdomain_find_by_route_locked(tb, route);
 757	if (xd)
 758		update_property_block(xd);
 759
 760	switch (pkg->type) {
 761	case PROPERTIES_REQUEST:
 762		tb_dbg(tb, "%llx: received XDomain properties request\n", route);
 763		if (xd) {
 764			ret = tb_xdp_properties_response(tb, ctl, xd, sequence,
 765				(const struct tb_xdp_properties *)pkg);
 766		}
 767		break;
 768
 769	case PROPERTIES_CHANGED_REQUEST:
 770		tb_dbg(tb, "%llx: received XDomain properties changed request\n",
 771		       route);
 
 772
 773		ret = tb_xdp_properties_changed_response(ctl, route, sequence);
 774
 775		/*
 776		 * Since the properties have been changed, let's update
 777		 * the xdomain related to this connection as well in
 778		 * case there is a change in services it offers.
 779		 */
 780		if (xd && device_is_registered(&xd->dev))
 781			queue_delayed_work(tb->wq, &xd->state_work,
 782					   msecs_to_jiffies(XDOMAIN_SHORT_TIMEOUT));
 
 
 
 
 783		break;
 
 784
 785	case UUID_REQUEST_OLD:
 786	case UUID_REQUEST:
 787		tb_dbg(tb, "%llx: received XDomain UUID request\n", route);
 788		ret = tb_xdp_uuid_response(ctl, route, sequence, uuid);
 789		/*
 790		 * If we've stopped the discovery with an error such as
 791		 * timing out, we will restart the handshake now that we
 792		 * received UUID request from the remote host.
 793		 */
 794		if (!ret && xd && xd->state == XDOMAIN_STATE_ERROR) {
 795			dev_dbg(&xd->dev, "restarting handshake\n");
 796			start_handshake(xd);
 797		}
 798		break;
 799
 800	case LINK_STATE_STATUS_REQUEST:
 801		tb_dbg(tb, "%llx: received XDomain link state status request\n",
 802		       route);
 803
 804		if (xd) {
 805			ret = tb_xdp_link_state_status_response(tb, ctl, xd,
 806								sequence);
 807		} else {
 808			tb_xdp_error_response(ctl, route, sequence,
 809					      ERROR_NOT_READY);
 810		}
 811		break;
 812
 813	case LINK_STATE_CHANGE_REQUEST:
 814		tb_dbg(tb, "%llx: received XDomain link state change request\n",
 815		       route);
 816
 817		if (xd && xd->state == XDOMAIN_STATE_BONDING_UUID_HIGH) {
 818			const struct tb_xdp_link_state_change *lsc =
 819				(const struct tb_xdp_link_state_change *)pkg;
 820
 821			ret = tb_xdp_link_state_change_response(ctl, route,
 822								sequence, 0);
 823			xd->target_link_width = lsc->tlw;
 824			queue_delayed_work(tb->wq, &xd->state_work,
 825					   msecs_to_jiffies(XDOMAIN_SHORT_TIMEOUT));
 826		} else {
 827			tb_xdp_error_response(ctl, route, sequence,
 828					      ERROR_NOT_READY);
 829		}
 830		break;
 831
 832	default:
 833		tb_dbg(tb, "%llx: unknown XDomain request %#x\n", route, pkg->type);
 834		tb_xdp_error_response(ctl, route, sequence,
 835				      ERROR_NOT_SUPPORTED);
 836		break;
 837	}
 838
 839	tb_xdomain_put(xd);
 840
 841	if (ret) {
 842		tb_warn(tb, "failed to send XDomain response for %#x\n",
 843			pkg->type);
 844	}
 845
 846out:
 847	kfree(xw->pkg);
 848	kfree(xw);
 849
 850	tb_domain_put(tb);
 851}
 852
 853static bool
 854tb_xdp_schedule_request(struct tb *tb, const struct tb_xdp_header *hdr,
 855			size_t size)
 856{
 857	struct xdomain_request_work *xw;
 858
 859	xw = kmalloc(sizeof(*xw), GFP_KERNEL);
 860	if (!xw)
 861		return false;
 862
 863	INIT_WORK(&xw->work, tb_xdp_handle_request);
 864	xw->pkg = kmemdup(hdr, size, GFP_KERNEL);
 865	if (!xw->pkg) {
 866		kfree(xw);
 867		return false;
 868	}
 869	xw->tb = tb_domain_get(tb);
 870
 871	schedule_work(&xw->work);
 872	return true;
 873}
 874
 875/**
 876 * tb_register_service_driver() - Register XDomain service driver
 877 * @drv: Driver to register
 878 *
 879 * Registers new service driver from @drv to the bus.
 880 */
 881int tb_register_service_driver(struct tb_service_driver *drv)
 882{
 883	drv->driver.bus = &tb_bus_type;
 884	return driver_register(&drv->driver);
 885}
 886EXPORT_SYMBOL_GPL(tb_register_service_driver);
 887
 888/**
 889 * tb_unregister_service_driver() - Unregister XDomain service driver
 890 * @drv: Driver to unregister
 891 *
 892 * Unregisters XDomain service driver from the bus.
 893 */
 894void tb_unregister_service_driver(struct tb_service_driver *drv)
 895{
 896	driver_unregister(&drv->driver);
 897}
 898EXPORT_SYMBOL_GPL(tb_unregister_service_driver);
 899
 900static ssize_t key_show(struct device *dev, struct device_attribute *attr,
 901			char *buf)
 902{
 903	struct tb_service *svc = container_of(dev, struct tb_service, dev);
 904
 905	/*
 906	 * It should be null terminated but anything else is pretty much
 907	 * allowed.
 908	 */
 909	return sysfs_emit(buf, "%*pE\n", (int)strlen(svc->key), svc->key);
 910}
 911static DEVICE_ATTR_RO(key);
 912
 913static int get_modalias(const struct tb_service *svc, char *buf, size_t size)
 914{
 915	return snprintf(buf, size, "tbsvc:k%sp%08Xv%08Xr%08X", svc->key,
 916			svc->prtcid, svc->prtcvers, svc->prtcrevs);
 917}
 918
 919static ssize_t modalias_show(struct device *dev, struct device_attribute *attr,
 920			     char *buf)
 921{
 922	struct tb_service *svc = container_of(dev, struct tb_service, dev);
 923
 924	/* Full buffer size except new line and null termination */
 925	get_modalias(svc, buf, PAGE_SIZE - 2);
 926	return strlen(strcat(buf, "\n"));
 927}
 928static DEVICE_ATTR_RO(modalias);
 929
 930static ssize_t prtcid_show(struct device *dev, struct device_attribute *attr,
 931			   char *buf)
 932{
 933	struct tb_service *svc = container_of(dev, struct tb_service, dev);
 934
 935	return sysfs_emit(buf, "%u\n", svc->prtcid);
 936}
 937static DEVICE_ATTR_RO(prtcid);
 938
 939static ssize_t prtcvers_show(struct device *dev, struct device_attribute *attr,
 940			     char *buf)
 941{
 942	struct tb_service *svc = container_of(dev, struct tb_service, dev);
 943
 944	return sysfs_emit(buf, "%u\n", svc->prtcvers);
 945}
 946static DEVICE_ATTR_RO(prtcvers);
 947
 948static ssize_t prtcrevs_show(struct device *dev, struct device_attribute *attr,
 949			     char *buf)
 950{
 951	struct tb_service *svc = container_of(dev, struct tb_service, dev);
 952
 953	return sysfs_emit(buf, "%u\n", svc->prtcrevs);
 954}
 955static DEVICE_ATTR_RO(prtcrevs);
 956
 957static ssize_t prtcstns_show(struct device *dev, struct device_attribute *attr,
 958			     char *buf)
 959{
 960	struct tb_service *svc = container_of(dev, struct tb_service, dev);
 961
 962	return sysfs_emit(buf, "0x%08x\n", svc->prtcstns);
 963}
 964static DEVICE_ATTR_RO(prtcstns);
 965
 966static struct attribute *tb_service_attrs[] = {
 967	&dev_attr_key.attr,
 968	&dev_attr_modalias.attr,
 969	&dev_attr_prtcid.attr,
 970	&dev_attr_prtcvers.attr,
 971	&dev_attr_prtcrevs.attr,
 972	&dev_attr_prtcstns.attr,
 973	NULL,
 974};
 975
 976static const struct attribute_group tb_service_attr_group = {
 977	.attrs = tb_service_attrs,
 978};
 979
 980static const struct attribute_group *tb_service_attr_groups[] = {
 981	&tb_service_attr_group,
 982	NULL,
 983};
 984
 985static int tb_service_uevent(const struct device *dev, struct kobj_uevent_env *env)
 986{
 987	const struct tb_service *svc = container_of_const(dev, struct tb_service, dev);
 988	char modalias[64];
 989
 990	get_modalias(svc, modalias, sizeof(modalias));
 991	return add_uevent_var(env, "MODALIAS=%s", modalias);
 992}
 993
 994static void tb_service_release(struct device *dev)
 995{
 996	struct tb_service *svc = container_of(dev, struct tb_service, dev);
 997	struct tb_xdomain *xd = tb_service_parent(svc);
 998
 999	tb_service_debugfs_remove(svc);
1000	ida_simple_remove(&xd->service_ids, svc->id);
1001	kfree(svc->key);
1002	kfree(svc);
1003}
1004
1005struct device_type tb_service_type = {
1006	.name = "thunderbolt_service",
1007	.groups = tb_service_attr_groups,
1008	.uevent = tb_service_uevent,
1009	.release = tb_service_release,
1010};
1011EXPORT_SYMBOL_GPL(tb_service_type);
1012
1013static int remove_missing_service(struct device *dev, void *data)
1014{
1015	struct tb_xdomain *xd = data;
1016	struct tb_service *svc;
1017
1018	svc = tb_to_service(dev);
1019	if (!svc)
1020		return 0;
1021
1022	if (!tb_property_find(xd->remote_properties, svc->key,
1023			      TB_PROPERTY_TYPE_DIRECTORY))
1024		device_unregister(dev);
1025
1026	return 0;
1027}
1028
1029static int find_service(struct device *dev, void *data)
1030{
1031	const struct tb_property *p = data;
1032	struct tb_service *svc;
1033
1034	svc = tb_to_service(dev);
1035	if (!svc)
1036		return 0;
1037
1038	return !strcmp(svc->key, p->key);
1039}
1040
1041static int populate_service(struct tb_service *svc,
1042			    struct tb_property *property)
1043{
1044	struct tb_property_dir *dir = property->value.dir;
1045	struct tb_property *p;
1046
1047	/* Fill in standard properties */
1048	p = tb_property_find(dir, "prtcid", TB_PROPERTY_TYPE_VALUE);
1049	if (p)
1050		svc->prtcid = p->value.immediate;
1051	p = tb_property_find(dir, "prtcvers", TB_PROPERTY_TYPE_VALUE);
1052	if (p)
1053		svc->prtcvers = p->value.immediate;
1054	p = tb_property_find(dir, "prtcrevs", TB_PROPERTY_TYPE_VALUE);
1055	if (p)
1056		svc->prtcrevs = p->value.immediate;
1057	p = tb_property_find(dir, "prtcstns", TB_PROPERTY_TYPE_VALUE);
1058	if (p)
1059		svc->prtcstns = p->value.immediate;
1060
1061	svc->key = kstrdup(property->key, GFP_KERNEL);
1062	if (!svc->key)
1063		return -ENOMEM;
1064
1065	return 0;
1066}
1067
1068static void enumerate_services(struct tb_xdomain *xd)
1069{
1070	struct tb_service *svc;
1071	struct tb_property *p;
1072	struct device *dev;
1073	int id;
1074
1075	/*
1076	 * First remove all services that are not available anymore in
1077	 * the updated property block.
1078	 */
1079	device_for_each_child_reverse(&xd->dev, xd, remove_missing_service);
1080
1081	/* Then re-enumerate properties creating new services as we go */
1082	tb_property_for_each(xd->remote_properties, p) {
1083		if (p->type != TB_PROPERTY_TYPE_DIRECTORY)
1084			continue;
1085
1086		/* If the service exists already we are fine */
1087		dev = device_find_child(&xd->dev, p, find_service);
1088		if (dev) {
1089			put_device(dev);
1090			continue;
1091		}
1092
1093		svc = kzalloc(sizeof(*svc), GFP_KERNEL);
1094		if (!svc)
1095			break;
1096
1097		if (populate_service(svc, p)) {
1098			kfree(svc);
1099			break;
1100		}
1101
1102		id = ida_simple_get(&xd->service_ids, 0, 0, GFP_KERNEL);
1103		if (id < 0) {
1104			kfree(svc->key);
1105			kfree(svc);
1106			break;
1107		}
1108		svc->id = id;
1109		svc->dev.bus = &tb_bus_type;
1110		svc->dev.type = &tb_service_type;
1111		svc->dev.parent = &xd->dev;
1112		dev_set_name(&svc->dev, "%s.%d", dev_name(&xd->dev), svc->id);
1113
1114		tb_service_debugfs_init(svc);
1115
1116		if (device_register(&svc->dev)) {
1117			put_device(&svc->dev);
1118			break;
1119		}
1120	}
1121}
1122
1123static int populate_properties(struct tb_xdomain *xd,
1124			       struct tb_property_dir *dir)
1125{
1126	const struct tb_property *p;
1127
1128	/* Required properties */
1129	p = tb_property_find(dir, "deviceid", TB_PROPERTY_TYPE_VALUE);
1130	if (!p)
1131		return -EINVAL;
1132	xd->device = p->value.immediate;
1133
1134	p = tb_property_find(dir, "vendorid", TB_PROPERTY_TYPE_VALUE);
1135	if (!p)
1136		return -EINVAL;
1137	xd->vendor = p->value.immediate;
1138
1139	p = tb_property_find(dir, "maxhopid", TB_PROPERTY_TYPE_VALUE);
1140	/*
1141	 * USB4 inter-domain spec suggests using 15 as HopID if the
1142	 * other end does not announce it in a property. This is for
1143	 * TBT3 compatibility.
1144	 */
1145	xd->remote_max_hopid = p ? p->value.immediate : XDOMAIN_DEFAULT_MAX_HOPID;
1146
1147	kfree(xd->device_name);
1148	xd->device_name = NULL;
1149	kfree(xd->vendor_name);
1150	xd->vendor_name = NULL;
1151
1152	/* Optional properties */
1153	p = tb_property_find(dir, "deviceid", TB_PROPERTY_TYPE_TEXT);
1154	if (p)
1155		xd->device_name = kstrdup(p->value.text, GFP_KERNEL);
1156	p = tb_property_find(dir, "vendorid", TB_PROPERTY_TYPE_TEXT);
1157	if (p)
1158		xd->vendor_name = kstrdup(p->value.text, GFP_KERNEL);
1159
1160	return 0;
1161}
1162
1163static int tb_xdomain_update_link_attributes(struct tb_xdomain *xd)
 
1164{
1165	bool change = false;
1166	struct tb_port *port;
1167	int ret;
1168
1169	port = tb_xdomain_downstream_port(xd);
1170
1171	ret = tb_port_get_link_speed(port);
1172	if (ret < 0)
1173		return ret;
1174
1175	if (xd->link_speed != ret)
1176		change = true;
1177
1178	xd->link_speed = ret;
1179
1180	ret = tb_port_get_link_width(port);
1181	if (ret < 0)
1182		return ret;
1183
1184	if (xd->link_width != ret)
1185		change = true;
1186
1187	xd->link_width = ret;
1188
1189	if (change)
1190		kobject_uevent(&xd->dev.kobj, KOBJ_CHANGE);
1191
1192	return 0;
 
 
 
 
1193}
1194
1195static int tb_xdomain_get_uuid(struct tb_xdomain *xd)
1196{
 
 
1197	struct tb *tb = xd->tb;
1198	uuid_t uuid;
1199	u64 route;
1200	int ret;
1201
1202	dev_dbg(&xd->dev, "requesting remote UUID\n");
1203
1204	ret = tb_xdp_uuid_request(tb->ctl, xd->route, xd->state_retries, &uuid,
1205				  &route);
1206	if (ret < 0) {
1207		if (xd->state_retries-- > 0) {
1208			dev_dbg(&xd->dev, "failed to request UUID, retrying\n");
1209			return -EAGAIN;
 
 
1210		}
1211		dev_dbg(&xd->dev, "failed to read remote UUID\n");
1212		return ret;
1213	}
1214
1215	dev_dbg(&xd->dev, "got remote UUID %pUb\n", &uuid);
1216
1217	if (uuid_equal(&uuid, xd->local_uuid)) {
1218		if (route == xd->route)
1219			dev_dbg(&xd->dev, "loop back detected\n");
1220		else
1221			dev_dbg(&xd->dev, "intra-domain loop detected\n");
1222
1223		/* Don't bond lanes automatically for loops */
1224		xd->bonding_possible = false;
1225	}
1226
1227	/*
1228	 * If the UUID is different, there is another domain connected
1229	 * so mark this one unplugged and wait for the connection
1230	 * manager to replace it.
1231	 */
1232	if (xd->remote_uuid && !uuid_equal(&uuid, xd->remote_uuid)) {
1233		dev_dbg(&xd->dev, "remote UUID is different, unplugging\n");
1234		xd->is_unplugged = true;
1235		return -ENODEV;
1236	}
1237
1238	/* First time fill in the missing UUID */
1239	if (!xd->remote_uuid) {
1240		xd->remote_uuid = kmemdup(&uuid, sizeof(uuid_t), GFP_KERNEL);
1241		if (!xd->remote_uuid)
1242			return -ENOMEM;
1243	}
1244
1245	return 0;
1246}
1247
1248static int tb_xdomain_get_link_status(struct tb_xdomain *xd)
1249{
1250	struct tb *tb = xd->tb;
1251	u8 slw, tlw, sls, tls;
1252	int ret;
1253
1254	dev_dbg(&xd->dev, "sending link state status request to %pUb\n",
1255		xd->remote_uuid);
1256
1257	ret = tb_xdp_link_state_status_request(tb->ctl, xd->route,
1258					       xd->state_retries, &slw, &tlw, &sls,
1259					       &tls);
1260	if (ret) {
1261		if (ret != -EOPNOTSUPP && xd->state_retries-- > 0) {
1262			dev_dbg(&xd->dev,
1263				"failed to request remote link status, retrying\n");
1264			return -EAGAIN;
1265		}
1266		dev_dbg(&xd->dev, "failed to receive remote link status\n");
1267		return ret;
1268	}
1269
1270	dev_dbg(&xd->dev, "remote link supports width %#x speed %#x\n", slw, sls);
1271
1272	if (slw < LANE_ADP_CS_0_SUPPORTED_WIDTH_DUAL) {
1273		dev_dbg(&xd->dev, "remote adapter is single lane only\n");
1274		return -EOPNOTSUPP;
1275	}
1276
1277	return 0;
1278}
1279
1280static int tb_xdomain_link_state_change(struct tb_xdomain *xd,
1281					unsigned int width)
1282{
1283	struct tb_port *port = tb_xdomain_downstream_port(xd);
1284	struct tb *tb = xd->tb;
1285	u8 tlw, tls;
1286	u32 val;
1287	int ret;
1288
1289	if (width == 2)
1290		tlw = LANE_ADP_CS_1_TARGET_WIDTH_DUAL;
1291	else if (width == 1)
1292		tlw = LANE_ADP_CS_1_TARGET_WIDTH_SINGLE;
1293	else
1294		return -EINVAL;
1295
1296	/* Use the current target speed */
1297	ret = tb_port_read(port, &val, TB_CFG_PORT, port->cap_phy + LANE_ADP_CS_1, 1);
1298	if (ret)
1299		return ret;
1300	tls = val & LANE_ADP_CS_1_TARGET_SPEED_MASK;
1301
1302	dev_dbg(&xd->dev, "sending link state change request with width %#x speed %#x\n",
1303		tlw, tls);
1304
1305	ret = tb_xdp_link_state_change_request(tb->ctl, xd->route,
1306					       xd->state_retries, tlw, tls);
1307	if (ret) {
1308		if (ret != -EOPNOTSUPP && xd->state_retries-- > 0) {
1309			dev_dbg(&xd->dev,
1310				"failed to change remote link state, retrying\n");
1311			return -EAGAIN;
1312		}
1313		dev_err(&xd->dev, "failed request link state change, aborting\n");
1314		return ret;
1315	}
1316
1317	dev_dbg(&xd->dev, "received link state change response\n");
1318	return 0;
1319}
1320
1321static int tb_xdomain_bond_lanes_uuid_high(struct tb_xdomain *xd)
1322{
1323	unsigned int width, width_mask;
1324	struct tb_port *port;
1325	int ret;
1326
1327	if (xd->target_link_width == LANE_ADP_CS_1_TARGET_WIDTH_SINGLE) {
1328		width = TB_LINK_WIDTH_SINGLE;
1329		width_mask = width;
1330	} else if (xd->target_link_width == LANE_ADP_CS_1_TARGET_WIDTH_DUAL) {
1331		width = TB_LINK_WIDTH_DUAL;
1332		width_mask = width | TB_LINK_WIDTH_ASYM_TX | TB_LINK_WIDTH_ASYM_RX;
1333	} else {
1334		if (xd->state_retries-- > 0) {
1335			dev_dbg(&xd->dev,
1336				"link state change request not received yet, retrying\n");
1337			return -EAGAIN;
1338		}
1339		dev_dbg(&xd->dev, "timeout waiting for link change request\n");
1340		return -ETIMEDOUT;
1341	}
1342
1343	port = tb_xdomain_downstream_port(xd);
1344
1345	/*
1346	 * We can't use tb_xdomain_lane_bonding_enable() here because it
1347	 * is the other side that initiates lane bonding. So here we
1348	 * just set the width to both lane adapters and wait for the
1349	 * link to transition bonded.
1350	 */
1351	ret = tb_port_set_link_width(port->dual_link_port, width);
1352	if (ret) {
1353		tb_port_warn(port->dual_link_port,
1354			     "failed to set link width to %d\n", width);
1355		return ret;
1356	}
1357
1358	ret = tb_port_set_link_width(port, width);
1359	if (ret) {
1360		tb_port_warn(port, "failed to set link width to %d\n", width);
1361		return ret;
1362	}
1363
1364	ret = tb_port_wait_for_link_width(port, width_mask,
1365					  XDOMAIN_BONDING_TIMEOUT);
1366	if (ret) {
1367		dev_warn(&xd->dev, "error waiting for link width to become %d\n",
1368			 width_mask);
1369		return ret;
1370	}
1371
1372	port->bonded = width > TB_LINK_WIDTH_SINGLE;
1373	port->dual_link_port->bonded = width > TB_LINK_WIDTH_SINGLE;
1374
1375	tb_port_update_credits(port);
1376	tb_xdomain_update_link_attributes(xd);
1377
1378	dev_dbg(&xd->dev, "lane bonding %s\n", str_enabled_disabled(width == 2));
1379	return 0;
1380}
1381
1382static int tb_xdomain_get_properties(struct tb_xdomain *xd)
1383{
 
 
1384	struct tb_property_dir *dir;
1385	struct tb *tb = xd->tb;
1386	bool update = false;
1387	u32 *block = NULL;
1388	u32 gen = 0;
1389	int ret;
1390
1391	dev_dbg(&xd->dev, "requesting remote properties\n");
1392
1393	ret = tb_xdp_properties_request(tb->ctl, xd->route, xd->local_uuid,
1394					xd->remote_uuid, xd->state_retries,
1395					&block, &gen);
1396	if (ret < 0) {
1397		if (xd->state_retries-- > 0) {
1398			dev_dbg(&xd->dev,
1399				"failed to request remote properties, retrying\n");
1400			return -EAGAIN;
 
 
 
 
1401		}
1402		/* Give up now */
1403		dev_err(&xd->dev, "failed read XDomain properties from %pUb\n",
1404			xd->remote_uuid);
1405
1406		return ret;
1407	}
1408
 
 
1409	mutex_lock(&xd->lock);
1410
1411	/* Only accept newer generation properties */
1412	if (xd->remote_properties && gen <= xd->remote_property_block_gen) {
1413		ret = 0;
 
 
 
 
 
 
1414		goto err_free_block;
1415	}
1416
1417	dir = tb_property_parse_dir(block, ret);
1418	if (!dir) {
1419		dev_err(&xd->dev, "failed to parse XDomain properties\n");
1420		ret = -ENOMEM;
1421		goto err_free_block;
1422	}
1423
1424	ret = populate_properties(xd, dir);
1425	if (ret) {
1426		dev_err(&xd->dev, "missing XDomain properties in response\n");
1427		goto err_free_dir;
1428	}
1429
1430	/* Release the existing one */
1431	if (xd->remote_properties) {
1432		tb_property_free_dir(xd->remote_properties);
1433		update = true;
1434	}
1435
1436	xd->remote_properties = dir;
1437	xd->remote_property_block_gen = gen;
1438
1439	tb_xdomain_update_link_attributes(xd);
1440
1441	mutex_unlock(&xd->lock);
1442
1443	kfree(block);
1444
1445	/*
1446	 * Now the device should be ready enough so we can add it to the
1447	 * bus and let userspace know about it. If the device is already
1448	 * registered, we notify the userspace that it has changed.
1449	 */
1450	if (!update) {
1451		/*
1452		 * Now disable lane 1 if bonding was not enabled. Do
1453		 * this only if bonding was possible at the beginning
1454		 * (that is we are the connection manager and there are
1455		 * two lanes).
1456		 */
1457		if (xd->bonding_possible) {
1458			struct tb_port *port;
1459
1460			port = tb_xdomain_downstream_port(xd);
1461			if (!port->bonded)
1462				tb_port_disable(port->dual_link_port);
1463		}
1464
1465		dev_dbg(&xd->dev, "current link speed %u.0 Gb/s\n",
1466			xd->link_speed);
1467		dev_dbg(&xd->dev, "current link width %s\n",
1468			tb_width_name(xd->link_width));
1469
1470		if (device_add(&xd->dev)) {
1471			dev_err(&xd->dev, "failed to add XDomain device\n");
1472			return -ENODEV;
1473		}
1474		dev_info(&xd->dev, "new host found, vendor=%#x device=%#x\n",
1475			 xd->vendor, xd->device);
1476		if (xd->vendor_name && xd->device_name)
1477			dev_info(&xd->dev, "%s %s\n", xd->vendor_name,
1478				 xd->device_name);
1479
1480		tb_xdomain_debugfs_init(xd);
1481	} else {
1482		kobject_uevent(&xd->dev.kobj, KOBJ_CHANGE);
1483	}
1484
1485	enumerate_services(xd);
1486	return 0;
1487
1488err_free_dir:
1489	tb_property_free_dir(dir);
1490err_free_block:
1491	kfree(block);
1492	mutex_unlock(&xd->lock);
1493
1494	return ret;
1495}
1496
1497static void tb_xdomain_queue_uuid(struct tb_xdomain *xd)
1498{
1499	xd->state = XDOMAIN_STATE_UUID;
1500	xd->state_retries = XDOMAIN_RETRIES;
1501	queue_delayed_work(xd->tb->wq, &xd->state_work,
1502			   msecs_to_jiffies(XDOMAIN_SHORT_TIMEOUT));
1503}
1504
1505static void tb_xdomain_queue_link_status(struct tb_xdomain *xd)
1506{
1507	xd->state = XDOMAIN_STATE_LINK_STATUS;
1508	xd->state_retries = XDOMAIN_RETRIES;
1509	queue_delayed_work(xd->tb->wq, &xd->state_work,
1510			   msecs_to_jiffies(XDOMAIN_DEFAULT_TIMEOUT));
1511}
1512
1513static void tb_xdomain_queue_link_status2(struct tb_xdomain *xd)
1514{
1515	xd->state = XDOMAIN_STATE_LINK_STATUS2;
1516	xd->state_retries = XDOMAIN_RETRIES;
1517	queue_delayed_work(xd->tb->wq, &xd->state_work,
1518			   msecs_to_jiffies(XDOMAIN_DEFAULT_TIMEOUT));
1519}
1520
1521static void tb_xdomain_queue_bonding(struct tb_xdomain *xd)
1522{
1523	if (memcmp(xd->local_uuid, xd->remote_uuid, UUID_SIZE) > 0) {
1524		dev_dbg(&xd->dev, "we have higher UUID, other side bonds the lanes\n");
1525		xd->state = XDOMAIN_STATE_BONDING_UUID_HIGH;
1526	} else {
1527		dev_dbg(&xd->dev, "we have lower UUID, bonding lanes\n");
1528		xd->state = XDOMAIN_STATE_LINK_STATE_CHANGE;
1529	}
1530
1531	xd->state_retries = XDOMAIN_RETRIES;
1532	queue_delayed_work(xd->tb->wq, &xd->state_work,
1533			   msecs_to_jiffies(XDOMAIN_DEFAULT_TIMEOUT));
1534}
1535
1536static void tb_xdomain_queue_bonding_uuid_low(struct tb_xdomain *xd)
1537{
1538	xd->state = XDOMAIN_STATE_BONDING_UUID_LOW;
1539	xd->state_retries = XDOMAIN_RETRIES;
1540	queue_delayed_work(xd->tb->wq, &xd->state_work,
1541			   msecs_to_jiffies(XDOMAIN_DEFAULT_TIMEOUT));
1542}
1543
1544static void tb_xdomain_queue_properties(struct tb_xdomain *xd)
1545{
1546	xd->state = XDOMAIN_STATE_PROPERTIES;
1547	xd->state_retries = XDOMAIN_RETRIES;
1548	queue_delayed_work(xd->tb->wq, &xd->state_work,
1549			   msecs_to_jiffies(XDOMAIN_DEFAULT_TIMEOUT));
1550}
1551
1552static void tb_xdomain_queue_properties_changed(struct tb_xdomain *xd)
1553{
1554	xd->properties_changed_retries = XDOMAIN_RETRIES;
1555	queue_delayed_work(xd->tb->wq, &xd->properties_changed_work,
1556			   msecs_to_jiffies(XDOMAIN_SHORT_TIMEOUT));
1557}
1558
1559static void tb_xdomain_failed(struct tb_xdomain *xd)
1560{
1561	xd->state = XDOMAIN_STATE_ERROR;
1562	queue_delayed_work(xd->tb->wq, &xd->state_work,
1563			   msecs_to_jiffies(XDOMAIN_DEFAULT_TIMEOUT));
1564}
1565
1566static void tb_xdomain_state_work(struct work_struct *work)
1567{
1568	struct tb_xdomain *xd = container_of(work, typeof(*xd), state_work.work);
1569	int ret, state = xd->state;
1570
1571	if (WARN_ON_ONCE(state < XDOMAIN_STATE_INIT ||
1572			 state > XDOMAIN_STATE_ERROR))
1573		return;
1574
1575	dev_dbg(&xd->dev, "running state %s\n", state_names[state]);
1576
1577	switch (state) {
1578	case XDOMAIN_STATE_INIT:
1579		if (xd->needs_uuid) {
1580			tb_xdomain_queue_uuid(xd);
1581		} else {
1582			tb_xdomain_queue_properties_changed(xd);
1583			tb_xdomain_queue_properties(xd);
1584		}
1585		break;
1586
1587	case XDOMAIN_STATE_UUID:
1588		ret = tb_xdomain_get_uuid(xd);
1589		if (ret) {
1590			if (ret == -EAGAIN)
1591				goto retry_state;
1592			tb_xdomain_failed(xd);
1593		} else {
1594			tb_xdomain_queue_properties_changed(xd);
1595			if (xd->bonding_possible)
1596				tb_xdomain_queue_link_status(xd);
1597			else
1598				tb_xdomain_queue_properties(xd);
1599		}
1600		break;
1601
1602	case XDOMAIN_STATE_LINK_STATUS:
1603		ret = tb_xdomain_get_link_status(xd);
1604		if (ret) {
1605			if (ret == -EAGAIN)
1606				goto retry_state;
1607
1608			/*
1609			 * If any of the lane bonding states fail we skip
1610			 * bonding completely and try to continue from
1611			 * reading properties.
1612			 */
1613			tb_xdomain_queue_properties(xd);
1614		} else {
1615			tb_xdomain_queue_bonding(xd);
1616		}
1617		break;
1618
1619	case XDOMAIN_STATE_LINK_STATE_CHANGE:
1620		ret = tb_xdomain_link_state_change(xd, 2);
1621		if (ret) {
1622			if (ret == -EAGAIN)
1623				goto retry_state;
1624			tb_xdomain_queue_properties(xd);
1625		} else {
1626			tb_xdomain_queue_link_status2(xd);
1627		}
1628		break;
1629
1630	case XDOMAIN_STATE_LINK_STATUS2:
1631		ret = tb_xdomain_get_link_status(xd);
1632		if (ret) {
1633			if (ret == -EAGAIN)
1634				goto retry_state;
1635			tb_xdomain_queue_properties(xd);
1636		} else {
1637			tb_xdomain_queue_bonding_uuid_low(xd);
1638		}
1639		break;
1640
1641	case XDOMAIN_STATE_BONDING_UUID_LOW:
1642		tb_xdomain_lane_bonding_enable(xd);
1643		tb_xdomain_queue_properties(xd);
1644		break;
1645
1646	case XDOMAIN_STATE_BONDING_UUID_HIGH:
1647		if (tb_xdomain_bond_lanes_uuid_high(xd) == -EAGAIN)
1648			goto retry_state;
1649		tb_xdomain_queue_properties(xd);
1650		break;
1651
1652	case XDOMAIN_STATE_PROPERTIES:
1653		ret = tb_xdomain_get_properties(xd);
1654		if (ret) {
1655			if (ret == -EAGAIN)
1656				goto retry_state;
1657			tb_xdomain_failed(xd);
1658		} else {
1659			xd->state = XDOMAIN_STATE_ENUMERATED;
1660		}
1661		break;
1662
1663	case XDOMAIN_STATE_ENUMERATED:
1664		tb_xdomain_queue_properties(xd);
1665		break;
1666
1667	case XDOMAIN_STATE_ERROR:
1668		dev_dbg(&xd->dev, "discovery failed, stopping handshake\n");
1669		__stop_handshake(xd);
1670		break;
1671
1672	default:
1673		dev_warn(&xd->dev, "unexpected state %d\n", state);
1674		break;
1675	}
1676
1677	return;
1678
1679retry_state:
1680	queue_delayed_work(xd->tb->wq, &xd->state_work,
1681			   msecs_to_jiffies(XDOMAIN_DEFAULT_TIMEOUT));
1682}
1683
1684static void tb_xdomain_properties_changed(struct work_struct *work)
1685{
1686	struct tb_xdomain *xd = container_of(work, typeof(*xd),
1687					     properties_changed_work.work);
1688	int ret;
1689
1690	dev_dbg(&xd->dev, "sending properties changed notification\n");
1691
1692	ret = tb_xdp_properties_changed_request(xd->tb->ctl, xd->route,
1693				xd->properties_changed_retries, xd->local_uuid);
1694	if (ret) {
1695		if (xd->properties_changed_retries-- > 0) {
1696			dev_dbg(&xd->dev,
1697				"failed to send properties changed notification, retrying\n");
1698			queue_delayed_work(xd->tb->wq,
1699					   &xd->properties_changed_work,
1700					   msecs_to_jiffies(XDOMAIN_DEFAULT_TIMEOUT));
1701		}
1702		dev_err(&xd->dev, "failed to send properties changed notification\n");
1703		return;
1704	}
1705
1706	xd->properties_changed_retries = XDOMAIN_RETRIES;
1707}
1708
1709static ssize_t device_show(struct device *dev, struct device_attribute *attr,
1710			   char *buf)
1711{
1712	struct tb_xdomain *xd = container_of(dev, struct tb_xdomain, dev);
1713
1714	return sysfs_emit(buf, "%#x\n", xd->device);
1715}
1716static DEVICE_ATTR_RO(device);
1717
1718static ssize_t
1719device_name_show(struct device *dev, struct device_attribute *attr, char *buf)
1720{
1721	struct tb_xdomain *xd = container_of(dev, struct tb_xdomain, dev);
1722	int ret;
1723
1724	if (mutex_lock_interruptible(&xd->lock))
1725		return -ERESTARTSYS;
1726	ret = sysfs_emit(buf, "%s\n", xd->device_name ?: "");
1727	mutex_unlock(&xd->lock);
1728
1729	return ret;
1730}
1731static DEVICE_ATTR_RO(device_name);
1732
1733static ssize_t maxhopid_show(struct device *dev, struct device_attribute *attr,
1734			     char *buf)
1735{
1736	struct tb_xdomain *xd = container_of(dev, struct tb_xdomain, dev);
1737
1738	return sysfs_emit(buf, "%d\n", xd->remote_max_hopid);
1739}
1740static DEVICE_ATTR_RO(maxhopid);
1741
1742static ssize_t vendor_show(struct device *dev, struct device_attribute *attr,
1743			   char *buf)
1744{
1745	struct tb_xdomain *xd = container_of(dev, struct tb_xdomain, dev);
1746
1747	return sysfs_emit(buf, "%#x\n", xd->vendor);
1748}
1749static DEVICE_ATTR_RO(vendor);
1750
1751static ssize_t
1752vendor_name_show(struct device *dev, struct device_attribute *attr, char *buf)
1753{
1754	struct tb_xdomain *xd = container_of(dev, struct tb_xdomain, dev);
1755	int ret;
1756
1757	if (mutex_lock_interruptible(&xd->lock))
1758		return -ERESTARTSYS;
1759	ret = sysfs_emit(buf, "%s\n", xd->vendor_name ?: "");
1760	mutex_unlock(&xd->lock);
1761
1762	return ret;
1763}
1764static DEVICE_ATTR_RO(vendor_name);
1765
1766static ssize_t unique_id_show(struct device *dev, struct device_attribute *attr,
1767			      char *buf)
1768{
1769	struct tb_xdomain *xd = container_of(dev, struct tb_xdomain, dev);
1770
1771	return sysfs_emit(buf, "%pUb\n", xd->remote_uuid);
1772}
1773static DEVICE_ATTR_RO(unique_id);
1774
1775static ssize_t speed_show(struct device *dev, struct device_attribute *attr,
1776			  char *buf)
1777{
1778	struct tb_xdomain *xd = container_of(dev, struct tb_xdomain, dev);
1779
1780	return sysfs_emit(buf, "%u.0 Gb/s\n", xd->link_speed);
1781}
1782
1783static DEVICE_ATTR(rx_speed, 0444, speed_show, NULL);
1784static DEVICE_ATTR(tx_speed, 0444, speed_show, NULL);
1785
1786static ssize_t rx_lanes_show(struct device *dev, struct device_attribute *attr,
1787			     char *buf)
1788{
1789	struct tb_xdomain *xd = container_of(dev, struct tb_xdomain, dev);
1790	unsigned int width;
1791
1792	switch (xd->link_width) {
1793	case TB_LINK_WIDTH_SINGLE:
1794	case TB_LINK_WIDTH_ASYM_RX:
1795		width = 1;
1796		break;
1797	case TB_LINK_WIDTH_DUAL:
1798		width = 2;
1799		break;
1800	case TB_LINK_WIDTH_ASYM_TX:
1801		width = 3;
1802		break;
1803	default:
1804		WARN_ON_ONCE(1);
1805		return -EINVAL;
1806	}
1807
1808	return sysfs_emit(buf, "%u\n", width);
1809}
1810static DEVICE_ATTR(rx_lanes, 0444, rx_lanes_show, NULL);
1811
1812static ssize_t tx_lanes_show(struct device *dev, struct device_attribute *attr,
1813			     char *buf)
1814{
1815	struct tb_xdomain *xd = container_of(dev, struct tb_xdomain, dev);
1816	unsigned int width;
1817
1818	switch (xd->link_width) {
1819	case TB_LINK_WIDTH_SINGLE:
1820	case TB_LINK_WIDTH_ASYM_TX:
1821		width = 1;
1822		break;
1823	case TB_LINK_WIDTH_DUAL:
1824		width = 2;
1825		break;
1826	case TB_LINK_WIDTH_ASYM_RX:
1827		width = 3;
1828		break;
1829	default:
1830		WARN_ON_ONCE(1);
1831		return -EINVAL;
1832	}
1833
1834	return sysfs_emit(buf, "%u\n", width);
1835}
1836static DEVICE_ATTR(tx_lanes, 0444, tx_lanes_show, NULL);
1837
1838static struct attribute *xdomain_attrs[] = {
1839	&dev_attr_device.attr,
1840	&dev_attr_device_name.attr,
1841	&dev_attr_maxhopid.attr,
1842	&dev_attr_rx_lanes.attr,
1843	&dev_attr_rx_speed.attr,
1844	&dev_attr_tx_lanes.attr,
1845	&dev_attr_tx_speed.attr,
1846	&dev_attr_unique_id.attr,
1847	&dev_attr_vendor.attr,
1848	&dev_attr_vendor_name.attr,
1849	NULL,
1850};
1851
1852static const struct attribute_group xdomain_attr_group = {
1853	.attrs = xdomain_attrs,
1854};
1855
1856static const struct attribute_group *xdomain_attr_groups[] = {
1857	&xdomain_attr_group,
1858	NULL,
1859};
1860
1861static void tb_xdomain_release(struct device *dev)
1862{
1863	struct tb_xdomain *xd = container_of(dev, struct tb_xdomain, dev);
1864
1865	put_device(xd->dev.parent);
1866
1867	kfree(xd->local_property_block);
1868	tb_property_free_dir(xd->remote_properties);
1869	ida_destroy(&xd->out_hopids);
1870	ida_destroy(&xd->in_hopids);
1871	ida_destroy(&xd->service_ids);
1872
1873	kfree(xd->local_uuid);
1874	kfree(xd->remote_uuid);
1875	kfree(xd->device_name);
1876	kfree(xd->vendor_name);
1877	kfree(xd);
1878}
1879
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1880static int __maybe_unused tb_xdomain_suspend(struct device *dev)
1881{
1882	stop_handshake(tb_to_xdomain(dev));
1883	return 0;
1884}
1885
1886static int __maybe_unused tb_xdomain_resume(struct device *dev)
1887{
1888	start_handshake(tb_to_xdomain(dev));
 
 
 
 
 
 
 
 
1889	return 0;
1890}
1891
1892static const struct dev_pm_ops tb_xdomain_pm_ops = {
1893	SET_SYSTEM_SLEEP_PM_OPS(tb_xdomain_suspend, tb_xdomain_resume)
1894};
1895
1896struct device_type tb_xdomain_type = {
1897	.name = "thunderbolt_xdomain",
1898	.release = tb_xdomain_release,
1899	.pm = &tb_xdomain_pm_ops,
1900};
1901EXPORT_SYMBOL_GPL(tb_xdomain_type);
1902
1903static void tb_xdomain_link_init(struct tb_xdomain *xd, struct tb_port *down)
1904{
1905	if (!down->dual_link_port)
1906		return;
1907
1908	/*
1909	 * Gen 4 links come up already as bonded so only update the port
1910	 * structures here.
1911	 */
1912	if (tb_port_get_link_generation(down) >= 4) {
1913		down->bonded = true;
1914		down->dual_link_port->bonded = true;
1915	} else {
1916		xd->bonding_possible = true;
1917	}
1918}
1919
1920static void tb_xdomain_link_exit(struct tb_xdomain *xd)
1921{
1922	struct tb_port *down = tb_xdomain_downstream_port(xd);
1923
1924	if (!down->dual_link_port)
1925		return;
1926
1927	if (tb_port_get_link_generation(down) >= 4) {
1928		down->bonded = false;
1929		down->dual_link_port->bonded = false;
1930	} else if (xd->link_width > TB_LINK_WIDTH_SINGLE) {
1931		/*
1932		 * Just return port structures back to way they were and
1933		 * update credits. No need to update userspace because
1934		 * the XDomain is removed soon anyway.
1935		 */
1936		tb_port_lane_bonding_disable(down);
1937		tb_port_update_credits(down);
1938	} else if (down->dual_link_port) {
1939		/*
1940		 * Re-enable the lane 1 adapter we disabled at the end
1941		 * of tb_xdomain_get_properties().
1942		 */
1943		tb_port_enable(down->dual_link_port);
1944	}
1945}
1946
1947/**
1948 * tb_xdomain_alloc() - Allocate new XDomain object
1949 * @tb: Domain where the XDomain belongs
1950 * @parent: Parent device (the switch through the connection to the
1951 *	    other domain is reached).
1952 * @route: Route string used to reach the other domain
1953 * @local_uuid: Our local domain UUID
1954 * @remote_uuid: UUID of the other domain (optional)
1955 *
1956 * Allocates new XDomain structure and returns pointer to that. The
1957 * object must be released by calling tb_xdomain_put().
1958 */
1959struct tb_xdomain *tb_xdomain_alloc(struct tb *tb, struct device *parent,
1960				    u64 route, const uuid_t *local_uuid,
1961				    const uuid_t *remote_uuid)
1962{
1963	struct tb_switch *parent_sw = tb_to_switch(parent);
1964	struct tb_xdomain *xd;
1965	struct tb_port *down;
1966
1967	/* Make sure the downstream domain is accessible */
1968	down = tb_port_at(route, parent_sw);
1969	tb_port_unlock(down);
1970
1971	xd = kzalloc(sizeof(*xd), GFP_KERNEL);
1972	if (!xd)
1973		return NULL;
1974
1975	xd->tb = tb;
1976	xd->route = route;
1977	xd->local_max_hopid = down->config.max_in_hop_id;
1978	ida_init(&xd->service_ids);
1979	ida_init(&xd->in_hopids);
1980	ida_init(&xd->out_hopids);
1981	mutex_init(&xd->lock);
1982	INIT_DELAYED_WORK(&xd->state_work, tb_xdomain_state_work);
 
1983	INIT_DELAYED_WORK(&xd->properties_changed_work,
1984			  tb_xdomain_properties_changed);
1985
1986	xd->local_uuid = kmemdup(local_uuid, sizeof(uuid_t), GFP_KERNEL);
1987	if (!xd->local_uuid)
1988		goto err_free;
1989
1990	if (remote_uuid) {
1991		xd->remote_uuid = kmemdup(remote_uuid, sizeof(uuid_t),
1992					  GFP_KERNEL);
1993		if (!xd->remote_uuid)
1994			goto err_free_local_uuid;
1995	} else {
1996		xd->needs_uuid = true;
1997
1998		tb_xdomain_link_init(xd, down);
1999	}
2000
2001	device_initialize(&xd->dev);
2002	xd->dev.parent = get_device(parent);
2003	xd->dev.bus = &tb_bus_type;
2004	xd->dev.type = &tb_xdomain_type;
2005	xd->dev.groups = xdomain_attr_groups;
2006	dev_set_name(&xd->dev, "%u-%llx", tb->index, route);
2007
2008	dev_dbg(&xd->dev, "local UUID %pUb\n", local_uuid);
2009	if (remote_uuid)
2010		dev_dbg(&xd->dev, "remote UUID %pUb\n", remote_uuid);
2011
2012	/*
2013	 * This keeps the DMA powered on as long as we have active
2014	 * connection to another host.
2015	 */
2016	pm_runtime_set_active(&xd->dev);
2017	pm_runtime_get_noresume(&xd->dev);
2018	pm_runtime_enable(&xd->dev);
2019
2020	return xd;
2021
2022err_free_local_uuid:
2023	kfree(xd->local_uuid);
2024err_free:
2025	kfree(xd);
2026
2027	return NULL;
2028}
2029
2030/**
2031 * tb_xdomain_add() - Add XDomain to the bus
2032 * @xd: XDomain to add
2033 *
2034 * This function starts XDomain discovery protocol handshake and
2035 * eventually adds the XDomain to the bus. After calling this function
2036 * the caller needs to call tb_xdomain_remove() in order to remove and
2037 * release the object regardless whether the handshake succeeded or not.
2038 */
2039void tb_xdomain_add(struct tb_xdomain *xd)
2040{
2041	/* Start exchanging properties with the other host */
2042	start_handshake(xd);
2043}
2044
2045static int unregister_service(struct device *dev, void *data)
2046{
2047	device_unregister(dev);
2048	return 0;
2049}
2050
2051/**
2052 * tb_xdomain_remove() - Remove XDomain from the bus
2053 * @xd: XDomain to remove
2054 *
2055 * This will stop all ongoing configuration work and remove the XDomain
2056 * along with any services from the bus. When the last reference to @xd
2057 * is released the object will be released as well.
2058 */
2059void tb_xdomain_remove(struct tb_xdomain *xd)
2060{
2061	tb_xdomain_debugfs_remove(xd);
2062
2063	stop_handshake(xd);
2064
2065	device_for_each_child_reverse(&xd->dev, xd, unregister_service);
2066
2067	tb_xdomain_link_exit(xd);
2068
2069	/*
2070	 * Undo runtime PM here explicitly because it is possible that
2071	 * the XDomain was never added to the bus and thus device_del()
2072	 * is not called for it (device_del() would handle this otherwise).
2073	 */
2074	pm_runtime_disable(&xd->dev);
2075	pm_runtime_put_noidle(&xd->dev);
2076	pm_runtime_set_suspended(&xd->dev);
2077
2078	if (!device_is_registered(&xd->dev)) {
2079		put_device(&xd->dev);
2080	} else {
2081		dev_info(&xd->dev, "host disconnected\n");
2082		device_unregister(&xd->dev);
2083	}
2084}
2085
2086/**
2087 * tb_xdomain_lane_bonding_enable() - Enable lane bonding on XDomain
2088 * @xd: XDomain connection
 
 
 
 
 
 
2089 *
2090 * Lane bonding is disabled by default for XDomains. This function tries
2091 * to enable bonding by first enabling the port and waiting for the CL0
2092 * state.
2093 *
2094 * Return: %0 in case of success and negative errno in case of error.
2095 */
2096int tb_xdomain_lane_bonding_enable(struct tb_xdomain *xd)
 
 
2097{
2098	unsigned int width_mask;
2099	struct tb_port *port;
2100	int ret;
2101
2102	port = tb_xdomain_downstream_port(xd);
2103	if (!port->dual_link_port)
2104		return -ENODEV;
2105
2106	ret = tb_port_enable(port->dual_link_port);
2107	if (ret)
2108		return ret;
2109
2110	ret = tb_wait_for_port(port->dual_link_port, true);
2111	if (ret < 0)
2112		return ret;
2113	if (!ret)
2114		return -ENOTCONN;
2115
2116	ret = tb_port_lane_bonding_enable(port);
2117	if (ret) {
2118		tb_port_warn(port, "failed to enable lane bonding\n");
2119		return ret;
2120	}
2121
2122	/* Any of the widths are all bonded */
2123	width_mask = TB_LINK_WIDTH_DUAL | TB_LINK_WIDTH_ASYM_TX |
2124		     TB_LINK_WIDTH_ASYM_RX;
2125
2126	ret = tb_port_wait_for_link_width(port, width_mask,
2127					  XDOMAIN_BONDING_TIMEOUT);
2128	if (ret) {
2129		tb_port_warn(port, "failed to enable lane bonding\n");
2130		return ret;
2131	}
2132
2133	tb_port_update_credits(port);
2134	tb_xdomain_update_link_attributes(xd);
2135
2136	dev_dbg(&xd->dev, "lane bonding enabled\n");
2137	return 0;
2138}
2139EXPORT_SYMBOL_GPL(tb_xdomain_lane_bonding_enable);
2140
2141/**
2142 * tb_xdomain_lane_bonding_disable() - Disable lane bonding
2143 * @xd: XDomain connection
2144 *
2145 * Lane bonding is disabled by default for XDomains. If bonding has been
2146 * enabled, this function can be used to disable it.
2147 */
2148void tb_xdomain_lane_bonding_disable(struct tb_xdomain *xd)
2149{
2150	struct tb_port *port;
2151
2152	port = tb_xdomain_downstream_port(xd);
2153	if (port->dual_link_port) {
2154		int ret;
2155
2156		tb_port_lane_bonding_disable(port);
2157		ret = tb_port_wait_for_link_width(port, TB_LINK_WIDTH_SINGLE, 100);
2158		if (ret == -ETIMEDOUT)
2159			tb_port_warn(port, "timeout disabling lane bonding\n");
2160		tb_port_disable(port->dual_link_port);
2161		tb_port_update_credits(port);
2162		tb_xdomain_update_link_attributes(xd);
2163
2164		dev_dbg(&xd->dev, "lane bonding disabled\n");
 
 
2165	}
2166}
2167EXPORT_SYMBOL_GPL(tb_xdomain_lane_bonding_disable);
2168
2169/**
2170 * tb_xdomain_alloc_in_hopid() - Allocate input HopID for tunneling
2171 * @xd: XDomain connection
2172 * @hopid: Preferred HopID or %-1 for next available
2173 *
2174 * Returns allocated HopID or negative errno. Specifically returns
2175 * %-ENOSPC if there are no more available HopIDs. Returned HopID is
2176 * guaranteed to be within range supported by the input lane adapter.
2177 * Call tb_xdomain_release_in_hopid() to release the allocated HopID.
2178 */
2179int tb_xdomain_alloc_in_hopid(struct tb_xdomain *xd, int hopid)
2180{
2181	if (hopid < 0)
2182		hopid = TB_PATH_MIN_HOPID;
2183	if (hopid < TB_PATH_MIN_HOPID || hopid > xd->local_max_hopid)
2184		return -EINVAL;
2185
2186	return ida_alloc_range(&xd->in_hopids, hopid, xd->local_max_hopid,
2187			       GFP_KERNEL);
2188}
2189EXPORT_SYMBOL_GPL(tb_xdomain_alloc_in_hopid);
2190
2191/**
2192 * tb_xdomain_alloc_out_hopid() - Allocate output HopID for tunneling
2193 * @xd: XDomain connection
2194 * @hopid: Preferred HopID or %-1 for next available
2195 *
2196 * Returns allocated HopID or negative errno. Specifically returns
2197 * %-ENOSPC if there are no more available HopIDs. Returned HopID is
2198 * guaranteed to be within range supported by the output lane adapter.
2199 * Call tb_xdomain_release_in_hopid() to release the allocated HopID.
2200 */
2201int tb_xdomain_alloc_out_hopid(struct tb_xdomain *xd, int hopid)
2202{
2203	if (hopid < 0)
2204		hopid = TB_PATH_MIN_HOPID;
2205	if (hopid < TB_PATH_MIN_HOPID || hopid > xd->remote_max_hopid)
2206		return -EINVAL;
2207
2208	return ida_alloc_range(&xd->out_hopids, hopid, xd->remote_max_hopid,
2209			       GFP_KERNEL);
2210}
2211EXPORT_SYMBOL_GPL(tb_xdomain_alloc_out_hopid);
2212
2213/**
2214 * tb_xdomain_release_in_hopid() - Release input HopID
2215 * @xd: XDomain connection
2216 * @hopid: HopID to release
2217 */
2218void tb_xdomain_release_in_hopid(struct tb_xdomain *xd, int hopid)
2219{
2220	ida_free(&xd->in_hopids, hopid);
2221}
2222EXPORT_SYMBOL_GPL(tb_xdomain_release_in_hopid);
2223
2224/**
2225 * tb_xdomain_release_out_hopid() - Release output HopID
2226 * @xd: XDomain connection
2227 * @hopid: HopID to release
2228 */
2229void tb_xdomain_release_out_hopid(struct tb_xdomain *xd, int hopid)
2230{
2231	ida_free(&xd->out_hopids, hopid);
2232}
2233EXPORT_SYMBOL_GPL(tb_xdomain_release_out_hopid);
2234
2235/**
2236 * tb_xdomain_enable_paths() - Enable DMA paths for XDomain connection
2237 * @xd: XDomain connection
2238 * @transmit_path: HopID we are using to send out packets
2239 * @transmit_ring: DMA ring used to send out packets
2240 * @receive_path: HopID the other end is using to send packets to us
2241 * @receive_ring: DMA ring used to receive packets from @receive_path
2242 *
2243 * The function enables DMA paths accordingly so that after successful
2244 * return the caller can send and receive packets using high-speed DMA
2245 * path. If a transmit or receive path is not needed, pass %-1 for those
2246 * parameters.
2247 *
2248 * Return: %0 in case of success and negative errno in case of error
2249 */
2250int tb_xdomain_enable_paths(struct tb_xdomain *xd, int transmit_path,
2251			    int transmit_ring, int receive_path,
2252			    int receive_ring)
2253{
2254	return tb_domain_approve_xdomain_paths(xd->tb, xd, transmit_path,
2255					       transmit_ring, receive_path,
2256					       receive_ring);
2257}
2258EXPORT_SYMBOL_GPL(tb_xdomain_enable_paths);
2259
2260/**
2261 * tb_xdomain_disable_paths() - Disable DMA paths for XDomain connection
2262 * @xd: XDomain connection
2263 * @transmit_path: HopID we are using to send out packets
2264 * @transmit_ring: DMA ring used to send out packets
2265 * @receive_path: HopID the other end is using to send packets to us
2266 * @receive_ring: DMA ring used to receive packets from @receive_path
2267 *
2268 * This does the opposite of tb_xdomain_enable_paths(). After call to
2269 * this the caller is not expected to use the rings anymore. Passing %-1
2270 * as path/ring parameter means don't care. Normally the callers should
2271 * pass the same values here as they do when paths are enabled.
2272 *
2273 * Return: %0 in case of success and negative errno in case of error
2274 */
2275int tb_xdomain_disable_paths(struct tb_xdomain *xd, int transmit_path,
2276			     int transmit_ring, int receive_path,
2277			     int receive_ring)
2278{
2279	return tb_domain_disconnect_xdomain_paths(xd->tb, xd, transmit_path,
2280						  transmit_ring, receive_path,
2281						  receive_ring);
 
 
 
 
 
 
 
 
 
2282}
2283EXPORT_SYMBOL_GPL(tb_xdomain_disable_paths);
2284
2285struct tb_xdomain_lookup {
2286	const uuid_t *uuid;
2287	u8 link;
2288	u8 depth;
2289	u64 route;
2290};
2291
2292static struct tb_xdomain *switch_find_xdomain(struct tb_switch *sw,
2293	const struct tb_xdomain_lookup *lookup)
2294{
2295	struct tb_port *port;
2296
2297	tb_switch_for_each_port(sw, port) {
2298		struct tb_xdomain *xd;
2299
2300		if (port->xdomain) {
2301			xd = port->xdomain;
2302
2303			if (lookup->uuid) {
2304				if (xd->remote_uuid &&
2305				    uuid_equal(xd->remote_uuid, lookup->uuid))
2306					return xd;
2307			} else {
2308				if (lookup->link && lookup->link == xd->link &&
2309				    lookup->depth == xd->depth)
2310					return xd;
2311				if (lookup->route && lookup->route == xd->route)
2312					return xd;
 
2313			}
2314		} else if (tb_port_has_remote(port)) {
2315			xd = switch_find_xdomain(port->remote->sw, lookup);
2316			if (xd)
2317				return xd;
2318		}
2319	}
2320
2321	return NULL;
2322}
2323
2324/**
2325 * tb_xdomain_find_by_uuid() - Find an XDomain by UUID
2326 * @tb: Domain where the XDomain belongs to
2327 * @uuid: UUID to look for
2328 *
2329 * Finds XDomain by walking through the Thunderbolt topology below @tb.
2330 * The returned XDomain will have its reference count increased so the
2331 * caller needs to call tb_xdomain_put() when it is done with the
2332 * object.
2333 *
2334 * This will find all XDomains including the ones that are not yet added
2335 * to the bus (handshake is still in progress).
2336 *
2337 * The caller needs to hold @tb->lock.
2338 */
2339struct tb_xdomain *tb_xdomain_find_by_uuid(struct tb *tb, const uuid_t *uuid)
2340{
2341	struct tb_xdomain_lookup lookup;
2342	struct tb_xdomain *xd;
2343
2344	memset(&lookup, 0, sizeof(lookup));
2345	lookup.uuid = uuid;
2346
2347	xd = switch_find_xdomain(tb->root_switch, &lookup);
2348	return tb_xdomain_get(xd);
2349}
2350EXPORT_SYMBOL_GPL(tb_xdomain_find_by_uuid);
2351
2352/**
2353 * tb_xdomain_find_by_link_depth() - Find an XDomain by link and depth
2354 * @tb: Domain where the XDomain belongs to
2355 * @link: Root switch link number
2356 * @depth: Depth in the link
2357 *
2358 * Finds XDomain by walking through the Thunderbolt topology below @tb.
2359 * The returned XDomain will have its reference count increased so the
2360 * caller needs to call tb_xdomain_put() when it is done with the
2361 * object.
2362 *
2363 * This will find all XDomains including the ones that are not yet added
2364 * to the bus (handshake is still in progress).
2365 *
2366 * The caller needs to hold @tb->lock.
2367 */
2368struct tb_xdomain *tb_xdomain_find_by_link_depth(struct tb *tb, u8 link,
2369						 u8 depth)
2370{
2371	struct tb_xdomain_lookup lookup;
2372	struct tb_xdomain *xd;
2373
2374	memset(&lookup, 0, sizeof(lookup));
2375	lookup.link = link;
2376	lookup.depth = depth;
2377
2378	xd = switch_find_xdomain(tb->root_switch, &lookup);
2379	return tb_xdomain_get(xd);
2380}
2381
2382/**
2383 * tb_xdomain_find_by_route() - Find an XDomain by route string
2384 * @tb: Domain where the XDomain belongs to
2385 * @route: XDomain route string
2386 *
2387 * Finds XDomain by walking through the Thunderbolt topology below @tb.
2388 * The returned XDomain will have its reference count increased so the
2389 * caller needs to call tb_xdomain_put() when it is done with the
2390 * object.
2391 *
2392 * This will find all XDomains including the ones that are not yet added
2393 * to the bus (handshake is still in progress).
2394 *
2395 * The caller needs to hold @tb->lock.
2396 */
2397struct tb_xdomain *tb_xdomain_find_by_route(struct tb *tb, u64 route)
2398{
2399	struct tb_xdomain_lookup lookup;
2400	struct tb_xdomain *xd;
2401
2402	memset(&lookup, 0, sizeof(lookup));
2403	lookup.route = route;
2404
2405	xd = switch_find_xdomain(tb->root_switch, &lookup);
2406	return tb_xdomain_get(xd);
2407}
2408EXPORT_SYMBOL_GPL(tb_xdomain_find_by_route);
2409
2410bool tb_xdomain_handle_request(struct tb *tb, enum tb_cfg_pkg_type type,
2411			       const void *buf, size_t size)
2412{
2413	const struct tb_protocol_handler *handler, *tmp;
2414	const struct tb_xdp_header *hdr = buf;
2415	unsigned int length;
2416	int ret = 0;
2417
2418	/* We expect the packet is at least size of the header */
2419	length = hdr->xd_hdr.length_sn & TB_XDOMAIN_LENGTH_MASK;
2420	if (length != size / 4 - sizeof(hdr->xd_hdr) / 4)
2421		return true;
2422	if (length < sizeof(*hdr) / 4 - sizeof(hdr->xd_hdr) / 4)
2423		return true;
2424
2425	/*
2426	 * Handle XDomain discovery protocol packets directly here. For
2427	 * other protocols (based on their UUID) we call registered
2428	 * handlers in turn.
2429	 */
2430	if (uuid_equal(&hdr->uuid, &tb_xdp_uuid)) {
2431		if (type == TB_CFG_PKG_XDOMAIN_REQ)
2432			return tb_xdp_schedule_request(tb, hdr, size);
2433		return false;
2434	}
2435
2436	mutex_lock(&xdomain_lock);
2437	list_for_each_entry_safe(handler, tmp, &protocol_handlers, list) {
2438		if (!uuid_equal(&hdr->uuid, handler->uuid))
2439			continue;
2440
2441		mutex_unlock(&xdomain_lock);
2442		ret = handler->callback(buf, size, handler->data);
2443		mutex_lock(&xdomain_lock);
2444
2445		if (ret)
2446			break;
2447	}
2448	mutex_unlock(&xdomain_lock);
2449
2450	return ret > 0;
2451}
2452
2453static int update_xdomain(struct device *dev, void *data)
2454{
2455	struct tb_xdomain *xd;
2456
2457	xd = tb_to_xdomain(dev);
2458	if (xd) {
2459		queue_delayed_work(xd->tb->wq, &xd->properties_changed_work,
2460				   msecs_to_jiffies(50));
2461	}
2462
2463	return 0;
2464}
2465
2466static void update_all_xdomains(void)
2467{
2468	bus_for_each_dev(&tb_bus_type, NULL, NULL, update_xdomain);
2469}
2470
2471static bool remove_directory(const char *key, const struct tb_property_dir *dir)
2472{
2473	struct tb_property *p;
2474
2475	p = tb_property_find(xdomain_property_dir, key,
2476			     TB_PROPERTY_TYPE_DIRECTORY);
2477	if (p && p->value.dir == dir) {
2478		tb_property_remove(p);
2479		return true;
2480	}
2481	return false;
2482}
2483
2484/**
2485 * tb_register_property_dir() - Register property directory to the host
2486 * @key: Key (name) of the directory to add
2487 * @dir: Directory to add
2488 *
2489 * Service drivers can use this function to add new property directory
2490 * to the host available properties. The other connected hosts are
2491 * notified so they can re-read properties of this host if they are
2492 * interested.
2493 *
2494 * Return: %0 on success and negative errno on failure
2495 */
2496int tb_register_property_dir(const char *key, struct tb_property_dir *dir)
2497{
2498	int ret;
2499
2500	if (WARN_ON(!xdomain_property_dir))
2501		return -EAGAIN;
2502
2503	if (!key || strlen(key) > 8)
2504		return -EINVAL;
2505
2506	mutex_lock(&xdomain_lock);
2507	if (tb_property_find(xdomain_property_dir, key,
2508			     TB_PROPERTY_TYPE_DIRECTORY)) {
2509		ret = -EEXIST;
2510		goto err_unlock;
2511	}
2512
2513	ret = tb_property_add_dir(xdomain_property_dir, key, dir);
2514	if (ret)
2515		goto err_unlock;
2516
2517	xdomain_property_block_gen++;
 
 
 
 
2518
2519	mutex_unlock(&xdomain_lock);
2520	update_all_xdomains();
2521	return 0;
2522
2523err_unlock:
2524	mutex_unlock(&xdomain_lock);
2525	return ret;
2526}
2527EXPORT_SYMBOL_GPL(tb_register_property_dir);
2528
2529/**
2530 * tb_unregister_property_dir() - Removes property directory from host
2531 * @key: Key (name) of the directory
2532 * @dir: Directory to remove
2533 *
2534 * This will remove the existing directory from this host and notify the
2535 * connected hosts about the change.
2536 */
2537void tb_unregister_property_dir(const char *key, struct tb_property_dir *dir)
2538{
2539	int ret = 0;
2540
2541	mutex_lock(&xdomain_lock);
2542	if (remove_directory(key, dir))
2543		xdomain_property_block_gen++;
2544	mutex_unlock(&xdomain_lock);
2545
2546	if (!ret)
2547		update_all_xdomains();
2548}
2549EXPORT_SYMBOL_GPL(tb_unregister_property_dir);
2550
2551int tb_xdomain_init(void)
2552{
2553	xdomain_property_dir = tb_property_create_dir(NULL);
2554	if (!xdomain_property_dir)
2555		return -ENOMEM;
2556
2557	/*
2558	 * Initialize standard set of properties without any service
2559	 * directories. Those will be added by service drivers
2560	 * themselves when they are loaded.
2561	 *
2562	 * Rest of the properties are filled dynamically based on these
2563	 * when the P2P connection is made.
2564	 */
2565	tb_property_add_immediate(xdomain_property_dir, "vendorid",
2566				  PCI_VENDOR_ID_INTEL);
2567	tb_property_add_text(xdomain_property_dir, "vendorid", "Intel Corp.");
2568	tb_property_add_immediate(xdomain_property_dir, "deviceid", 0x1);
2569	tb_property_add_immediate(xdomain_property_dir, "devicerv", 0x80000100);
2570
2571	xdomain_property_block_gen = get_random_u32();
2572	return 0;
2573}
2574
2575void tb_xdomain_exit(void)
2576{
 
2577	tb_property_free_dir(xdomain_property_dir);
2578}