1// SPDX-License-Identifier: GPL-2.0
   2/*
   3 * Thunderbolt driver - switch/port utility functions
   4 *
   5 * Copyright (c) 2014 Andreas Noever <andreas.noever@gmail.com>
   6 * Copyright (C) 2018, Intel Corporation
   7 */
   8
   9#include <linux/delay.h>
  10#include <linux/idr.h>
  11#include <linux/module.h>
  12#include <linux/nvmem-provider.h>
  13#include <linux/pm_runtime.h>
  14#include <linux/sched/signal.h>
  15#include <linux/sizes.h>
  16#include <linux/slab.h>
  17#include <linux/string_helpers.h>
  18
  19#include "tb.h"
  20
 
 
 
  21/* Switch NVM support */
  22
 
 
 
 
 
 
 
 
 
 
  23struct nvm_auth_status {
  24	struct list_head list;
  25	uuid_t uuid;
  26	u32 status;
  27};
  28
  29/*
  30 * Hold NVM authentication failure status per switch This information
  31 * needs to stay around even when the switch gets power cycled so we
  32 * keep it separately.
  33 */
  34static LIST_HEAD(nvm_auth_status_cache);
  35static DEFINE_MUTEX(nvm_auth_status_lock);
  36
  37static struct nvm_auth_status *__nvm_get_auth_status(const struct tb_switch *sw)
  38{
  39	struct nvm_auth_status *st;
  40
  41	list_for_each_entry(st, &nvm_auth_status_cache, list) {
  42		if (uuid_equal(&st->uuid, sw->uuid))
  43			return st;
  44	}
  45
  46	return NULL;
  47}
  48
  49static void nvm_get_auth_status(const struct tb_switch *sw, u32 *status)
  50{
  51	struct nvm_auth_status *st;
  52
  53	mutex_lock(&nvm_auth_status_lock);
  54	st = __nvm_get_auth_status(sw);
  55	mutex_unlock(&nvm_auth_status_lock);
  56
  57	*status = st ? st->status : 0;
  58}
  59
  60static void nvm_set_auth_status(const struct tb_switch *sw, u32 status)
  61{
  62	struct nvm_auth_status *st;
  63
  64	if (WARN_ON(!sw->uuid))
  65		return;
  66
  67	mutex_lock(&nvm_auth_status_lock);
  68	st = __nvm_get_auth_status(sw);
  69
  70	if (!st) {
  71		st = kzalloc(sizeof(*st), GFP_KERNEL);
  72		if (!st)
  73			goto unlock;
  74
  75		memcpy(&st->uuid, sw->uuid, sizeof(st->uuid));
  76		INIT_LIST_HEAD(&st->list);
  77		list_add_tail(&st->list, &nvm_auth_status_cache);
  78	}
  79
  80	st->status = status;
  81unlock:
  82	mutex_unlock(&nvm_auth_status_lock);
  83}
  84
  85static void nvm_clear_auth_status(const struct tb_switch *sw)
  86{
  87	struct nvm_auth_status *st;
  88
  89	mutex_lock(&nvm_auth_status_lock);
  90	st = __nvm_get_auth_status(sw);
  91	if (st) {
  92		list_del(&st->list);
  93		kfree(st);
  94	}
  95	mutex_unlock(&nvm_auth_status_lock);
  96}
  97
  98static int nvm_validate_and_write(struct tb_switch *sw)
  99{
 100	unsigned int image_size;
 101	const u8 *buf;
 
 102	int ret;
 103
 104	ret = tb_nvm_validate(sw->nvm);
 105	if (ret)
 106		return ret;
 107
 108	ret = tb_nvm_write_headers(sw->nvm);
 109	if (ret)
 110		return ret;
 111
 112	buf = sw->nvm->buf_data_start;
 113	image_size = sw->nvm->buf_data_size;
 
 
 114
 115	if (tb_switch_is_usb4(sw))
 116		ret = usb4_switch_nvm_write(sw, 0, buf, image_size);
 117	else
 118		ret = dma_port_flash_write(sw->dma_port, 0, buf, image_size);
 119	if (ret)
 120		return ret;
 
 121
 122	sw->nvm->flushed = true;
 123	return 0;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 124}
 125
 126static int nvm_authenticate_host_dma_port(struct tb_switch *sw)
 127{
 128	int ret = 0;
 129
 130	/*
 131	 * Root switch NVM upgrade requires that we disconnect the
 132	 * existing paths first (in case it is not in safe mode
 133	 * already).
 134	 */
 135	if (!sw->safe_mode) {
 136		u32 status;
 137
 138		ret = tb_domain_disconnect_all_paths(sw->tb);
 139		if (ret)
 140			return ret;
 141		/*
 142		 * The host controller goes away pretty soon after this if
 143		 * everything goes well so getting timeout is expected.
 144		 */
 145		ret = dma_port_flash_update_auth(sw->dma_port);
 146		if (!ret || ret == -ETIMEDOUT)
 147			return 0;
 148
 149		/*
 150		 * Any error from update auth operation requires power
 151		 * cycling of the host router.
 152		 */
 153		tb_sw_warn(sw, "failed to authenticate NVM, power cycling\n");
 154		if (dma_port_flash_update_auth_status(sw->dma_port, &status) > 0)
 155			nvm_set_auth_status(sw, status);
 156	}
 157
 158	/*
 159	 * From safe mode we can get out by just power cycling the
 160	 * switch.
 161	 */
 162	dma_port_power_cycle(sw->dma_port);
 163	return ret;
 164}
 165
 166static int nvm_authenticate_device_dma_port(struct tb_switch *sw)
 167{
 168	int ret, retries = 10;
 169
 170	ret = dma_port_flash_update_auth(sw->dma_port);
 171	switch (ret) {
 172	case 0:
 173	case -ETIMEDOUT:
 174	case -EACCES:
 175	case -EINVAL:
 176		/* Power cycle is required */
 177		break;
 178	default:
 179		return ret;
 180	}
 181
 182	/*
 183	 * Poll here for the authentication status. It takes some time
 184	 * for the device to respond (we get timeout for a while). Once
 185	 * we get response the device needs to be power cycled in order
 186	 * to the new NVM to be taken into use.
 187	 */
 188	do {
 189		u32 status;
 190
 191		ret = dma_port_flash_update_auth_status(sw->dma_port, &status);
 192		if (ret < 0 && ret != -ETIMEDOUT)
 193			return ret;
 194		if (ret > 0) {
 195			if (status) {
 196				tb_sw_warn(sw, "failed to authenticate NVM\n");
 197				nvm_set_auth_status(sw, status);
 198			}
 199
 200			tb_sw_info(sw, "power cycling the switch now\n");
 201			dma_port_power_cycle(sw->dma_port);
 202			return 0;
 203		}
 204
 205		msleep(500);
 206	} while (--retries);
 207
 208	return -ETIMEDOUT;
 209}
 210
 211static void nvm_authenticate_start_dma_port(struct tb_switch *sw)
 212{
 213	struct pci_dev *root_port;
 214
 215	/*
 216	 * During host router NVM upgrade we should not allow root port to
 217	 * go into D3cold because some root ports cannot trigger PME
 218	 * itself. To be on the safe side keep the root port in D0 during
 219	 * the whole upgrade process.
 220	 */
 221	root_port = pcie_find_root_port(sw->tb->nhi->pdev);
 222	if (root_port)
 223		pm_runtime_get_noresume(&root_port->dev);
 224}
 225
 226static void nvm_authenticate_complete_dma_port(struct tb_switch *sw)
 227{
 228	struct pci_dev *root_port;
 229
 230	root_port = pcie_find_root_port(sw->tb->nhi->pdev);
 231	if (root_port)
 232		pm_runtime_put(&root_port->dev);
 233}
 234
 235static inline bool nvm_readable(struct tb_switch *sw)
 236{
 237	if (tb_switch_is_usb4(sw)) {
 238		/*
 239		 * USB4 devices must support NVM operations but it is
 240		 * optional for hosts. Therefore we query the NVM sector
 241		 * size here and if it is supported assume NVM
 242		 * operations are implemented.
 243		 */
 244		return usb4_switch_nvm_sector_size(sw) > 0;
 245	}
 246
 247	/* Thunderbolt 2 and 3 devices support NVM through DMA port */
 248	return !!sw->dma_port;
 249}
 250
 251static inline bool nvm_upgradeable(struct tb_switch *sw)
 
 252{
 253	if (sw->no_nvm_upgrade)
 254		return false;
 255	return nvm_readable(sw);
 256}
 257
 258static int nvm_authenticate(struct tb_switch *sw, bool auth_only)
 259{
 260	int ret;
 261
 262	if (tb_switch_is_usb4(sw)) {
 263		if (auth_only) {
 264			ret = usb4_switch_nvm_set_offset(sw, 0);
 265			if (ret)
 266				return ret;
 
 
 
 
 
 
 267		}
 268		sw->nvm->authenticating = true;
 269		return usb4_switch_nvm_authenticate(sw);
 270	}
 271	if (auth_only)
 272		return -EOPNOTSUPP;
 273
 274	sw->nvm->authenticating = true;
 275	if (!tb_route(sw)) {
 276		nvm_authenticate_start_dma_port(sw);
 277		ret = nvm_authenticate_host_dma_port(sw);
 278	} else {
 279		ret = nvm_authenticate_device_dma_port(sw);
 280	}
 281
 282	return ret;
 283}
 284
 285/**
 286 * tb_switch_nvm_read() - Read router NVM
 287 * @sw: Router whose NVM to read
 288 * @address: Start address on the NVM
 289 * @buf: Buffer where the read data is copied
 290 * @size: Size of the buffer in bytes
 291 *
 292 * Reads from router NVM and returns the requested data in @buf. Locking
 293 * is up to the caller. Returns %0 in success and negative errno in case
 294 * of failure.
 295 */
 296int tb_switch_nvm_read(struct tb_switch *sw, unsigned int address, void *buf,
 297		       size_t size)
 298{
 299	if (tb_switch_is_usb4(sw))
 300		return usb4_switch_nvm_read(sw, address, buf, size);
 301	return dma_port_flash_read(sw->dma_port, address, buf, size);
 302}
 303
 304static int nvm_read(void *priv, unsigned int offset, void *val, size_t bytes)
 
 305{
 306	struct tb_nvm *nvm = priv;
 307	struct tb_switch *sw = tb_to_switch(nvm->dev);
 308	int ret;
 309
 310	pm_runtime_get_sync(&sw->dev);
 311
 312	if (!mutex_trylock(&sw->tb->lock)) {
 313		ret = restart_syscall();
 314		goto out;
 
 
 
 
 
 315	}
 316
 317	ret = tb_switch_nvm_read(sw, offset, val, bytes);
 318	mutex_unlock(&sw->tb->lock);
 319
 320out:
 321	pm_runtime_mark_last_busy(&sw->dev);
 322	pm_runtime_put_autosuspend(&sw->dev);
 
 323
 324	return ret;
 325}
 326
 327static int nvm_write(void *priv, unsigned int offset, void *val, size_t bytes)
 328{
 329	struct tb_nvm *nvm = priv;
 330	struct tb_switch *sw = tb_to_switch(nvm->dev);
 331	int ret;
 332
 333	if (!mutex_trylock(&sw->tb->lock))
 334		return restart_syscall();
 335
 336	/*
 337	 * Since writing the NVM image might require some special steps,
 338	 * for example when CSS headers are written, we cache the image
 339	 * locally here and handle the special cases when the user asks
 340	 * us to authenticate the image.
 341	 */
 342	ret = tb_nvm_write_buf(nvm, offset, val, bytes);
 343	mutex_unlock(&sw->tb->lock);
 344
 345	return ret;
 346}
 347
 348static int tb_switch_nvm_add(struct tb_switch *sw)
 349{
 350	struct tb_nvm *nvm;
 
 
 351	int ret;
 352
 353	if (!nvm_readable(sw))
 354		return 0;
 355
 356	nvm = tb_nvm_alloc(&sw->dev);
 357	if (IS_ERR(nvm)) {
 358		ret = PTR_ERR(nvm) == -EOPNOTSUPP ? 0 : PTR_ERR(nvm);
 359		goto err_nvm;
 360	}
 361
 362	ret = tb_nvm_read_version(nvm);
 363	if (ret)
 364		goto err_nvm;
 365
 366	/*
 367	 * If the switch is in safe-mode the only accessible portion of
 368	 * the NVM is the non-active one where userspace is expected to
 369	 * write new functional NVM.
 370	 */
 371	if (!sw->safe_mode) {
 372		ret = tb_nvm_add_active(nvm, nvm_read);
 
 
 
 373		if (ret)
 374			goto err_nvm;
 375		tb_sw_dbg(sw, "NVM version %x.%x\n", nvm->major, nvm->minor);
 376	}
 377
 378	if (!sw->no_nvm_upgrade) {
 379		ret = tb_nvm_add_non_active(nvm, nvm_write);
 
 
 
 
 380		if (ret)
 381			goto err_nvm;
 
 
 
 
 
 
 
 
 
 
 382	}
 383
 
 
 
 
 
 
 
 
 384	sw->nvm = nvm;
 
 
 385	return 0;
 386
 387err_nvm:
 388	tb_sw_dbg(sw, "NVM upgrade disabled\n");
 389	sw->no_nvm_upgrade = true;
 390	if (!IS_ERR(nvm))
 391		tb_nvm_free(nvm);
 
 392
 393	return ret;
 394}
 395
 396static void tb_switch_nvm_remove(struct tb_switch *sw)
 397{
 398	struct tb_nvm *nvm;
 399
 
 400	nvm = sw->nvm;
 401	sw->nvm = NULL;
 
 402
 403	if (!nvm)
 404		return;
 405
 406	/* Remove authentication status in case the switch is unplugged */
 407	if (!nvm->authenticating)
 408		nvm_clear_auth_status(sw);
 409
 410	tb_nvm_free(nvm);
 
 
 
 
 
 411}
 412
 413/* port utility functions */
 414
 415static const char *tb_port_type(const struct tb_regs_port_header *port)
 416{
 417	switch (port->type >> 16) {
 418	case 0:
 419		switch ((u8) port->type) {
 420		case 0:
 421			return "Inactive";
 422		case 1:
 423			return "Port";
 424		case 2:
 425			return "NHI";
 426		default:
 427			return "unknown";
 428		}
 429	case 0x2:
 430		return "Ethernet";
 431	case 0x8:
 432		return "SATA";
 433	case 0xe:
 434		return "DP/HDMI";
 435	case 0x10:
 436		return "PCIe";
 437	case 0x20:
 438		return "USB";
 439	default:
 440		return "unknown";
 441	}
 442}
 443
 444static void tb_dump_port(struct tb *tb, const struct tb_port *port)
 445{
 446	const struct tb_regs_port_header *regs = &port->config;
 447
 448	tb_dbg(tb,
 449	       " Port %d: %x:%x (Revision: %d, TB Version: %d, Type: %s (%#x))\n",
 450	       regs->port_number, regs->vendor_id, regs->device_id,
 451	       regs->revision, regs->thunderbolt_version, tb_port_type(regs),
 452	       regs->type);
 453	tb_dbg(tb, "  Max hop id (in/out): %d/%d\n",
 454	       regs->max_in_hop_id, regs->max_out_hop_id);
 455	tb_dbg(tb, "  Max counters: %d\n", regs->max_counters);
 456	tb_dbg(tb, "  NFC Credits: %#x\n", regs->nfc_credits);
 457	tb_dbg(tb, "  Credits (total/control): %u/%u\n", port->total_credits,
 458	       port->ctl_credits);
 459}
 460
 461/**
 462 * tb_port_state() - get connectedness state of a port
 463 * @port: the port to check
 464 *
 465 * The port must have a TB_CAP_PHY (i.e. it should be a real port).
 466 *
 467 * Return: Returns an enum tb_port_state on success or an error code on failure.
 468 */
 469int tb_port_state(struct tb_port *port)
 470{
 471	struct tb_cap_phy phy;
 472	int res;
 473	if (port->cap_phy == 0) {
 474		tb_port_WARN(port, "does not have a PHY\n");
 475		return -EINVAL;
 476	}
 477	res = tb_port_read(port, &phy, TB_CFG_PORT, port->cap_phy, 2);
 478	if (res)
 479		return res;
 480	return phy.state;
 481}
 482
 483/**
 484 * tb_wait_for_port() - wait for a port to become ready
 485 * @port: Port to wait
 486 * @wait_if_unplugged: Wait also when port is unplugged
 487 *
 488 * Wait up to 1 second for a port to reach state TB_PORT_UP. If
 489 * wait_if_unplugged is set then we also wait if the port is in state
 490 * TB_PORT_UNPLUGGED (it takes a while for the device to be registered after
 491 * switch resume). Otherwise we only wait if a device is registered but the link
 492 * has not yet been established.
 493 *
 494 * Return: Returns an error code on failure. Returns 0 if the port is not
 495 * connected or failed to reach state TB_PORT_UP within one second. Returns 1
 496 * if the port is connected and in state TB_PORT_UP.
 497 */
 498int tb_wait_for_port(struct tb_port *port, bool wait_if_unplugged)
 499{
 500	int retries = 10;
 501	int state;
 502	if (!port->cap_phy) {
 503		tb_port_WARN(port, "does not have PHY\n");
 504		return -EINVAL;
 505	}
 506	if (tb_is_upstream_port(port)) {
 507		tb_port_WARN(port, "is the upstream port\n");
 508		return -EINVAL;
 509	}
 510
 511	while (retries--) {
 512		state = tb_port_state(port);
 513		switch (state) {
 514		case TB_PORT_DISABLED:
 515			tb_port_dbg(port, "is disabled (state: 0)\n");
 
 516			return 0;
 517
 518		case TB_PORT_UNPLUGGED:
 519			if (wait_if_unplugged) {
 520				/* used during resume */
 521				tb_port_dbg(port,
 522					    "is unplugged (state: 7), retrying...\n");
 523				msleep(100);
 524				break;
 525			}
 526			tb_port_dbg(port, "is unplugged (state: 7)\n");
 527			return 0;
 528
 529		case TB_PORT_UP:
 530		case TB_PORT_TX_CL0S:
 531		case TB_PORT_RX_CL0S:
 532		case TB_PORT_CL1:
 533		case TB_PORT_CL2:
 534			tb_port_dbg(port, "is connected, link is up (state: %d)\n", state);
 535			return 1;
 536
 537		default:
 538			if (state < 0)
 539				return state;
 540
 541			/*
 542			 * After plug-in the state is TB_PORT_CONNECTING. Give it some
 543			 * time.
 544			 */
 545			tb_port_dbg(port,
 546				    "is connected, link is not up (state: %d), retrying...\n",
 547				    state);
 548			msleep(100);
 549		}
 550
 
 
 
 
 
 
 
 
 551	}
 552	tb_port_warn(port,
 553		     "failed to reach state TB_PORT_UP. Ignoring port...\n");
 554	return 0;
 555}
 556
 557/**
 558 * tb_port_add_nfc_credits() - add/remove non flow controlled credits to port
 559 * @port: Port to add/remove NFC credits
 560 * @credits: Credits to add/remove
 561 *
 562 * Change the number of NFC credits allocated to @port by @credits. To remove
 563 * NFC credits pass a negative amount of credits.
 564 *
 565 * Return: Returns 0 on success or an error code on failure.
 566 */
 567int tb_port_add_nfc_credits(struct tb_port *port, int credits)
 568{
 569	u32 nfc_credits;
 570
 571	if (credits == 0 || port->sw->is_unplugged)
 572		return 0;
 573
 574	/*
 575	 * USB4 restricts programming NFC buffers to lane adapters only
 576	 * so skip other ports.
 577	 */
 578	if (tb_switch_is_usb4(port->sw) && !tb_port_is_null(port))
 579		return 0;
 580
 581	nfc_credits = port->config.nfc_credits & ADP_CS_4_NFC_BUFFERS_MASK;
 582	if (credits < 0)
 583		credits = max_t(int, -nfc_credits, credits);
 584
 585	nfc_credits += credits;
 586
 587	tb_port_dbg(port, "adding %d NFC credits to %lu", credits,
 588		    port->config.nfc_credits & ADP_CS_4_NFC_BUFFERS_MASK);
 589
 590	port->config.nfc_credits &= ~ADP_CS_4_NFC_BUFFERS_MASK;
 591	port->config.nfc_credits |= nfc_credits;
 592
 593	return tb_port_write(port, &port->config.nfc_credits,
 594			     TB_CFG_PORT, ADP_CS_4, 1);
 595}
 596
 597/**
 598 * tb_port_clear_counter() - clear a counter in TB_CFG_COUNTER
 599 * @port: Port whose counters to clear
 600 * @counter: Counter index to clear
 601 *
 602 * Return: Returns 0 on success or an error code on failure.
 603 */
 604int tb_port_clear_counter(struct tb_port *port, int counter)
 605{
 606	u32 zero[3] = { 0, 0, 0 };
 607	tb_port_dbg(port, "clearing counter %d\n", counter);
 608	return tb_port_write(port, zero, TB_CFG_COUNTERS, 3 * counter, 3);
 609}
 610
 611/**
 612 * tb_port_unlock() - Unlock downstream port
 613 * @port: Port to unlock
 614 *
 615 * Needed for USB4 but can be called for any CIO/USB4 ports. Makes the
 616 * downstream router accessible for CM.
 617 */
 618int tb_port_unlock(struct tb_port *port)
 619{
 620	if (tb_switch_is_icm(port->sw))
 621		return 0;
 622	if (!tb_port_is_null(port))
 623		return -EINVAL;
 624	if (tb_switch_is_usb4(port->sw))
 625		return usb4_port_unlock(port);
 626	return 0;
 627}
 628
 629static int __tb_port_enable(struct tb_port *port, bool enable)
 630{
 631	int ret;
 632	u32 phy;
 633
 634	if (!tb_port_is_null(port))
 635		return -EINVAL;
 636
 637	ret = tb_port_read(port, &phy, TB_CFG_PORT,
 638			   port->cap_phy + LANE_ADP_CS_1, 1);
 639	if (ret)
 640		return ret;
 641
 642	if (enable)
 643		phy &= ~LANE_ADP_CS_1_LD;
 644	else
 645		phy |= LANE_ADP_CS_1_LD;
 646
 647
 648	ret = tb_port_write(port, &phy, TB_CFG_PORT,
 649			    port->cap_phy + LANE_ADP_CS_1, 1);
 650	if (ret)
 651		return ret;
 652
 653	tb_port_dbg(port, "lane %s\n", str_enabled_disabled(enable));
 654	return 0;
 655}
 656
 657/**
 658 * tb_port_enable() - Enable lane adapter
 659 * @port: Port to enable (can be %NULL)
 660 *
 661 * This is used for lane 0 and 1 adapters to enable it.
 662 */
 663int tb_port_enable(struct tb_port *port)
 664{
 665	return __tb_port_enable(port, true);
 666}
 667
 668/**
 669 * tb_port_disable() - Disable lane adapter
 670 * @port: Port to disable (can be %NULL)
 671 *
 672 * This is used for lane 0 and 1 adapters to disable it.
 673 */
 674int tb_port_disable(struct tb_port *port)
 675{
 676	return __tb_port_enable(port, false);
 677}
 678
 679/*
 680 * tb_init_port() - initialize a port
 681 *
 682 * This is a helper method for tb_switch_alloc. Does not check or initialize
 683 * any downstream switches.
 684 *
 685 * Return: Returns 0 on success or an error code on failure.
 686 */
 687static int tb_init_port(struct tb_port *port)
 688{
 689	int res;
 690	int cap;
 691
 692	INIT_LIST_HEAD(&port->list);
 693
 694	/* Control adapter does not have configuration space */
 695	if (!port->port)
 696		return 0;
 697
 698	res = tb_port_read(port, &port->config, TB_CFG_PORT, 0, 8);
 699	if (res) {
 700		if (res == -ENODEV) {
 701			tb_dbg(port->sw->tb, " Port %d: not implemented\n",
 702			       port->port);
 703			port->disabled = true;
 704			return 0;
 705		}
 706		return res;
 707	}
 708
 709	/* Port 0 is the switch itself and has no PHY. */
 710	if (port->config.type == TB_TYPE_PORT) {
 711		cap = tb_port_find_cap(port, TB_PORT_CAP_PHY);
 712
 713		if (cap > 0)
 714			port->cap_phy = cap;
 715		else
 716			tb_port_WARN(port, "non switch port without a PHY\n");
 717
 718		cap = tb_port_find_cap(port, TB_PORT_CAP_USB4);
 719		if (cap > 0)
 720			port->cap_usb4 = cap;
 721
 722		/*
 723		 * USB4 ports the buffers allocated for the control path
 724		 * can be read from the path config space. Legacy
 725		 * devices we use hard-coded value.
 726		 */
 727		if (port->cap_usb4) {
 728			struct tb_regs_hop hop;
 729
 730			if (!tb_port_read(port, &hop, TB_CFG_HOPS, 0, 2))
 731				port->ctl_credits = hop.initial_credits;
 732		}
 733		if (!port->ctl_credits)
 734			port->ctl_credits = 2;
 735
 736	} else {
 737		cap = tb_port_find_cap(port, TB_PORT_CAP_ADAP);
 738		if (cap > 0)
 739			port->cap_adap = cap;
 740	}
 741
 742	port->total_credits =
 743		(port->config.nfc_credits & ADP_CS_4_TOTAL_BUFFERS_MASK) >>
 744		ADP_CS_4_TOTAL_BUFFERS_SHIFT;
 745
 746	tb_dump_port(port->sw->tb, port);
 747	return 0;
 748}
 749
 750static int tb_port_alloc_hopid(struct tb_port *port, bool in, int min_hopid,
 751			       int max_hopid)
 752{
 753	int port_max_hopid;
 754	struct ida *ida;
 755
 756	if (in) {
 757		port_max_hopid = port->config.max_in_hop_id;
 758		ida = &port->in_hopids;
 759	} else {
 760		port_max_hopid = port->config.max_out_hop_id;
 761		ida = &port->out_hopids;
 762	}
 763
 764	/*
 765	 * NHI can use HopIDs 1-max for other adapters HopIDs 0-7 are
 766	 * reserved.
 767	 */
 768	if (!tb_port_is_nhi(port) && min_hopid < TB_PATH_MIN_HOPID)
 769		min_hopid = TB_PATH_MIN_HOPID;
 770
 771	if (max_hopid < 0 || max_hopid > port_max_hopid)
 772		max_hopid = port_max_hopid;
 773
 774	return ida_simple_get(ida, min_hopid, max_hopid + 1, GFP_KERNEL);
 775}
 776
 777/**
 778 * tb_port_alloc_in_hopid() - Allocate input HopID from port
 779 * @port: Port to allocate HopID for
 780 * @min_hopid: Minimum acceptable input HopID
 781 * @max_hopid: Maximum acceptable input HopID
 782 *
 783 * Return: HopID between @min_hopid and @max_hopid or negative errno in
 784 * case of error.
 785 */
 786int tb_port_alloc_in_hopid(struct tb_port *port, int min_hopid, int max_hopid)
 787{
 788	return tb_port_alloc_hopid(port, true, min_hopid, max_hopid);
 789}
 790
 791/**
 792 * tb_port_alloc_out_hopid() - Allocate output HopID from port
 793 * @port: Port to allocate HopID for
 794 * @min_hopid: Minimum acceptable output HopID
 795 * @max_hopid: Maximum acceptable output HopID
 796 *
 797 * Return: HopID between @min_hopid and @max_hopid or negative errno in
 798 * case of error.
 799 */
 800int tb_port_alloc_out_hopid(struct tb_port *port, int min_hopid, int max_hopid)
 801{
 802	return tb_port_alloc_hopid(port, false, min_hopid, max_hopid);
 803}
 804
 805/**
 806 * tb_port_release_in_hopid() - Release allocated input HopID from port
 807 * @port: Port whose HopID to release
 808 * @hopid: HopID to release
 809 */
 810void tb_port_release_in_hopid(struct tb_port *port, int hopid)
 811{
 812	ida_simple_remove(&port->in_hopids, hopid);
 813}
 814
 815/**
 816 * tb_port_release_out_hopid() - Release allocated output HopID from port
 817 * @port: Port whose HopID to release
 818 * @hopid: HopID to release
 819 */
 820void tb_port_release_out_hopid(struct tb_port *port, int hopid)
 821{
 822	ida_simple_remove(&port->out_hopids, hopid);
 823}
 824
 825static inline bool tb_switch_is_reachable(const struct tb_switch *parent,
 826					  const struct tb_switch *sw)
 827{
 828	u64 mask = (1ULL << parent->config.depth * 8) - 1;
 829	return (tb_route(parent) & mask) == (tb_route(sw) & mask);
 830}
 831
 832/**
 833 * tb_next_port_on_path() - Return next port for given port on a path
 834 * @start: Start port of the walk
 835 * @end: End port of the walk
 836 * @prev: Previous port (%NULL if this is the first)
 837 *
 838 * This function can be used to walk from one port to another if they
 839 * are connected through zero or more switches. If the @prev is dual
 840 * link port, the function follows that link and returns another end on
 841 * that same link.
 842 *
 843 * If the @end port has been reached, return %NULL.
 844 *
 845 * Domain tb->lock must be held when this function is called.
 846 */
 847struct tb_port *tb_next_port_on_path(struct tb_port *start, struct tb_port *end,
 848				     struct tb_port *prev)
 849{
 850	struct tb_port *next;
 851
 852	if (!prev)
 853		return start;
 854
 855	if (prev->sw == end->sw) {
 856		if (prev == end)
 857			return NULL;
 858		return end;
 859	}
 860
 861	if (tb_switch_is_reachable(prev->sw, end->sw)) {
 862		next = tb_port_at(tb_route(end->sw), prev->sw);
 863		/* Walk down the topology if next == prev */
 864		if (prev->remote &&
 865		    (next == prev || next->dual_link_port == prev))
 866			next = prev->remote;
 867	} else {
 868		if (tb_is_upstream_port(prev)) {
 869			next = prev->remote;
 870		} else {
 871			next = tb_upstream_port(prev->sw);
 872			/*
 873			 * Keep the same link if prev and next are both
 874			 * dual link ports.
 875			 */
 876			if (next->dual_link_port &&
 877			    next->link_nr != prev->link_nr) {
 878				next = next->dual_link_port;
 879			}
 880		}
 881	}
 882
 883	return next != prev ? next : NULL;
 884}
 885
 886/**
 887 * tb_port_get_link_speed() - Get current link speed
 888 * @port: Port to check (USB4 or CIO)
 889 *
 890 * Returns link speed in Gb/s or negative errno in case of failure.
 891 */
 892int tb_port_get_link_speed(struct tb_port *port)
 893{
 894	u32 val, speed;
 895	int ret;
 896
 897	if (!port->cap_phy)
 898		return -EINVAL;
 899
 900	ret = tb_port_read(port, &val, TB_CFG_PORT,
 901			   port->cap_phy + LANE_ADP_CS_1, 1);
 902	if (ret)
 903		return ret;
 904
 905	speed = (val & LANE_ADP_CS_1_CURRENT_SPEED_MASK) >>
 906		LANE_ADP_CS_1_CURRENT_SPEED_SHIFT;
 907
 908	switch (speed) {
 909	case LANE_ADP_CS_1_CURRENT_SPEED_GEN4:
 910		return 40;
 911	case LANE_ADP_CS_1_CURRENT_SPEED_GEN3:
 912		return 20;
 913	default:
 914		return 10;
 915	}
 916}
 917
 918/**
 919 * tb_port_get_link_generation() - Returns link generation
 920 * @port: Lane adapter
 921 *
 922 * Returns link generation as number or negative errno in case of
 923 * failure. Does not distinguish between Thunderbolt 1 and Thunderbolt 2
 924 * links so for those always returns 2.
 925 */
 926int tb_port_get_link_generation(struct tb_port *port)
 927{
 928	int ret;
 929
 930	ret = tb_port_get_link_speed(port);
 931	if (ret < 0)
 932		return ret;
 933
 934	switch (ret) {
 935	case 40:
 936		return 4;
 937	case 20:
 938		return 3;
 939	default:
 940		return 2;
 941	}
 942}
 943
 944/**
 945 * tb_port_get_link_width() - Get current link width
 946 * @port: Port to check (USB4 or CIO)
 947 *
 948 * Returns link width. Return the link width as encoded in &enum
 949 * tb_link_width or negative errno in case of failure.
 950 */
 951int tb_port_get_link_width(struct tb_port *port)
 952{
 953	u32 val;
 954	int ret;
 955
 956	if (!port->cap_phy)
 957		return -EINVAL;
 958
 959	ret = tb_port_read(port, &val, TB_CFG_PORT,
 960			   port->cap_phy + LANE_ADP_CS_1, 1);
 961	if (ret)
 962		return ret;
 963
 964	/* Matches the values in enum tb_link_width */
 965	return (val & LANE_ADP_CS_1_CURRENT_WIDTH_MASK) >>
 966		LANE_ADP_CS_1_CURRENT_WIDTH_SHIFT;
 967}
 968
 969/**
 970 * tb_port_width_supported() - Is the given link width supported
 971 * @port: Port to check
 972 * @width: Widths to check (bitmask)
 973 *
 974 * Can be called to any lane adapter. Checks if given @width is
 975 * supported by the hardware and returns %true if it is.
 976 */
 977bool tb_port_width_supported(struct tb_port *port, unsigned int width)
 978{
 979	u32 phy, widths;
 980	int ret;
 981
 982	if (!port->cap_phy)
 983		return false;
 984
 985	if (width & (TB_LINK_WIDTH_ASYM_TX | TB_LINK_WIDTH_ASYM_RX)) {
 986		if (tb_port_get_link_generation(port) < 4 ||
 987		    !usb4_port_asym_supported(port))
 988			return false;
 989	}
 990
 991	ret = tb_port_read(port, &phy, TB_CFG_PORT,
 992			   port->cap_phy + LANE_ADP_CS_0, 1);
 993	if (ret)
 994		return false;
 995
 996	/*
 997	 * The field encoding is the same as &enum tb_link_width (which is
 998	 * passed to @width).
 999	 */
1000	widths = FIELD_GET(LANE_ADP_CS_0_SUPPORTED_WIDTH_MASK, phy);
1001	return widths & width;
1002}
1003
1004/**
1005 * tb_port_set_link_width() - Set target link width of the lane adapter
1006 * @port: Lane adapter
1007 * @width: Target link width
1008 *
1009 * Sets the target link width of the lane adapter to @width. Does not
1010 * enable/disable lane bonding. For that call tb_port_set_lane_bonding().
1011 *
1012 * Return: %0 in case of success and negative errno in case of error
1013 */
1014int tb_port_set_link_width(struct tb_port *port, enum tb_link_width width)
1015{
1016	u32 val;
1017	int ret;
1018
1019	if (!port->cap_phy)
1020		return -EINVAL;
1021
1022	ret = tb_port_read(port, &val, TB_CFG_PORT,
1023			   port->cap_phy + LANE_ADP_CS_1, 1);
1024	if (ret)
1025		return ret;
1026
1027	val &= ~LANE_ADP_CS_1_TARGET_WIDTH_MASK;
1028	switch (width) {
1029	case TB_LINK_WIDTH_SINGLE:
1030		/* Gen 4 link cannot be single */
1031		if (tb_port_get_link_generation(port) >= 4)
1032			return -EOPNOTSUPP;
1033		val |= LANE_ADP_CS_1_TARGET_WIDTH_SINGLE <<
1034			LANE_ADP_CS_1_TARGET_WIDTH_SHIFT;
1035		break;
1036
1037	case TB_LINK_WIDTH_DUAL:
1038		if (tb_port_get_link_generation(port) >= 4)
1039			return usb4_port_asym_set_link_width(port, width);
1040		val |= LANE_ADP_CS_1_TARGET_WIDTH_DUAL <<
1041			LANE_ADP_CS_1_TARGET_WIDTH_SHIFT;
1042		break;
1043
1044	case TB_LINK_WIDTH_ASYM_TX:
1045	case TB_LINK_WIDTH_ASYM_RX:
1046		return usb4_port_asym_set_link_width(port, width);
1047
1048	default:
1049		return -EINVAL;
1050	}
1051
1052	return tb_port_write(port, &val, TB_CFG_PORT,
1053			     port->cap_phy + LANE_ADP_CS_1, 1);
1054}
1055
1056/**
1057 * tb_port_set_lane_bonding() - Enable/disable lane bonding
1058 * @port: Lane adapter
1059 * @bonding: enable/disable bonding
1060 *
1061 * Enables or disables lane bonding. This should be called after target
1062 * link width has been set (tb_port_set_link_width()). Note in most
1063 * cases one should use tb_port_lane_bonding_enable() instead to enable
1064 * lane bonding.
1065 *
1066 * Return: %0 in case of success and negative errno in case of error
1067 */
1068static int tb_port_set_lane_bonding(struct tb_port *port, bool bonding)
1069{
1070	u32 val;
1071	int ret;
1072
1073	if (!port->cap_phy)
1074		return -EINVAL;
1075
1076	ret = tb_port_read(port, &val, TB_CFG_PORT,
1077			   port->cap_phy + LANE_ADP_CS_1, 1);
1078	if (ret)
1079		return ret;
1080
1081	if (bonding)
1082		val |= LANE_ADP_CS_1_LB;
1083	else
1084		val &= ~LANE_ADP_CS_1_LB;
1085
1086	return tb_port_write(port, &val, TB_CFG_PORT,
1087			     port->cap_phy + LANE_ADP_CS_1, 1);
1088}
1089
1090/**
1091 * tb_port_lane_bonding_enable() - Enable bonding on port
1092 * @port: port to enable
1093 *
1094 * Enable bonding by setting the link width of the port and the other
1095 * port in case of dual link port. Does not wait for the link to
1096 * actually reach the bonded state so caller needs to call
1097 * tb_port_wait_for_link_width() before enabling any paths through the
1098 * link to make sure the link is in expected state.
1099 *
1100 * Return: %0 in case of success and negative errno in case of error
1101 */
1102int tb_port_lane_bonding_enable(struct tb_port *port)
1103{
1104	enum tb_link_width width;
1105	int ret;
1106
1107	/*
1108	 * Enable lane bonding for both links if not already enabled by
1109	 * for example the boot firmware.
1110	 */
1111	width = tb_port_get_link_width(port);
1112	if (width == TB_LINK_WIDTH_SINGLE) {
1113		ret = tb_port_set_link_width(port, TB_LINK_WIDTH_DUAL);
1114		if (ret)
1115			goto err_lane0;
1116	}
1117
1118	width = tb_port_get_link_width(port->dual_link_port);
1119	if (width == TB_LINK_WIDTH_SINGLE) {
1120		ret = tb_port_set_link_width(port->dual_link_port,
1121					     TB_LINK_WIDTH_DUAL);
1122		if (ret)
1123			goto err_lane0;
1124	}
1125
1126	/*
1127	 * Only set bonding if the link was not already bonded. This
1128	 * avoids the lane adapter to re-enter bonding state.
1129	 */
1130	if (width == TB_LINK_WIDTH_SINGLE && !tb_is_upstream_port(port)) {
1131		ret = tb_port_set_lane_bonding(port, true);
1132		if (ret)
1133			goto err_lane1;
1134	}
1135
1136	/*
1137	 * When lane 0 bonding is set it will affect lane 1 too so
1138	 * update both.
1139	 */
1140	port->bonded = true;
1141	port->dual_link_port->bonded = true;
1142
1143	return 0;
1144
1145err_lane1:
1146	tb_port_set_link_width(port->dual_link_port, TB_LINK_WIDTH_SINGLE);
1147err_lane0:
1148	tb_port_set_link_width(port, TB_LINK_WIDTH_SINGLE);
1149
1150	return ret;
1151}
1152
1153/**
1154 * tb_port_lane_bonding_disable() - Disable bonding on port
1155 * @port: port to disable
1156 *
1157 * Disable bonding by setting the link width of the port and the
1158 * other port in case of dual link port.
1159 */
1160void tb_port_lane_bonding_disable(struct tb_port *port)
1161{
1162	tb_port_set_lane_bonding(port, false);
1163	tb_port_set_link_width(port->dual_link_port, TB_LINK_WIDTH_SINGLE);
1164	tb_port_set_link_width(port, TB_LINK_WIDTH_SINGLE);
1165	port->dual_link_port->bonded = false;
1166	port->bonded = false;
1167}
1168
1169/**
1170 * tb_port_wait_for_link_width() - Wait until link reaches specific width
1171 * @port: Port to wait for
1172 * @width: Expected link width (bitmask)
1173 * @timeout_msec: Timeout in ms how long to wait
1174 *
1175 * Should be used after both ends of the link have been bonded (or
1176 * bonding has been disabled) to wait until the link actually reaches
1177 * the expected state. Returns %-ETIMEDOUT if the width was not reached
1178 * within the given timeout, %0 if it did. Can be passed a mask of
1179 * expected widths and succeeds if any of the widths is reached.
1180 */
1181int tb_port_wait_for_link_width(struct tb_port *port, unsigned int width,
1182				int timeout_msec)
1183{
1184	ktime_t timeout = ktime_add_ms(ktime_get(), timeout_msec);
1185	int ret;
1186
1187	/* Gen 4 link does not support single lane */
1188	if ((width & TB_LINK_WIDTH_SINGLE) &&
1189	    tb_port_get_link_generation(port) >= 4)
1190		return -EOPNOTSUPP;
1191
1192	do {
1193		ret = tb_port_get_link_width(port);
1194		if (ret < 0) {
1195			/*
1196			 * Sometimes we get port locked error when
1197			 * polling the lanes so we can ignore it and
1198			 * retry.
1199			 */
1200			if (ret != -EACCES)
1201				return ret;
1202		} else if (ret & width) {
1203			return 0;
1204		}
1205
1206		usleep_range(1000, 2000);
1207	} while (ktime_before(ktime_get(), timeout));
1208
1209	return -ETIMEDOUT;
1210}
1211
1212static int tb_port_do_update_credits(struct tb_port *port)
1213{
1214	u32 nfc_credits;
1215	int ret;
1216
1217	ret = tb_port_read(port, &nfc_credits, TB_CFG_PORT, ADP_CS_4, 1);
1218	if (ret)
1219		return ret;
1220
1221	if (nfc_credits != port->config.nfc_credits) {
1222		u32 total;
1223
1224		total = (nfc_credits & ADP_CS_4_TOTAL_BUFFERS_MASK) >>
1225			ADP_CS_4_TOTAL_BUFFERS_SHIFT;
1226
1227		tb_port_dbg(port, "total credits changed %u -> %u\n",
1228			    port->total_credits, total);
1229
1230		port->config.nfc_credits = nfc_credits;
1231		port->total_credits = total;
1232	}
1233
 
1234	return 0;
1235}
1236
1237/**
1238 * tb_port_update_credits() - Re-read port total credits
1239 * @port: Port to update
1240 *
1241 * After the link is bonded (or bonding was disabled) the port total
1242 * credits may change, so this function needs to be called to re-read
1243 * the credits. Updates also the second lane adapter.
1244 */
1245int tb_port_update_credits(struct tb_port *port)
1246{
1247	int ret;
1248
1249	ret = tb_port_do_update_credits(port);
1250	if (ret)
1251		return ret;
1252
1253	if (!port->dual_link_port)
1254		return 0;
1255	return tb_port_do_update_credits(port->dual_link_port);
1256}
1257
1258static int tb_port_start_lane_initialization(struct tb_port *port)
1259{
1260	int ret;
1261
1262	if (tb_switch_is_usb4(port->sw))
1263		return 0;
1264
1265	ret = tb_lc_start_lane_initialization(port);
1266	return ret == -EINVAL ? 0 : ret;
1267}
1268
1269/*
1270 * Returns true if the port had something (router, XDomain) connected
1271 * before suspend.
1272 */
1273static bool tb_port_resume(struct tb_port *port)
1274{
1275	bool has_remote = tb_port_has_remote(port);
1276
1277	if (port->usb4) {
1278		usb4_port_device_resume(port->usb4);
1279	} else if (!has_remote) {
1280		/*
1281		 * For disconnected downstream lane adapters start lane
1282		 * initialization now so we detect future connects.
1283		 *
1284		 * For XDomain start the lane initialzation now so the
1285		 * link gets re-established.
1286		 *
1287		 * This is only needed for non-USB4 ports.
1288		 */
1289		if (!tb_is_upstream_port(port) || port->xdomain)
1290			tb_port_start_lane_initialization(port);
1291	}
1292
1293	return has_remote || port->xdomain;
1294}
1295
1296/**
1297 * tb_port_is_enabled() - Is the adapter port enabled
1298 * @port: Port to check
1299 */
1300bool tb_port_is_enabled(struct tb_port *port)
1301{
1302	switch (port->config.type) {
1303	case TB_TYPE_PCIE_UP:
1304	case TB_TYPE_PCIE_DOWN:
1305		return tb_pci_port_is_enabled(port);
1306
1307	case TB_TYPE_DP_HDMI_IN:
1308	case TB_TYPE_DP_HDMI_OUT:
1309		return tb_dp_port_is_enabled(port);
1310
1311	case TB_TYPE_USB3_UP:
1312	case TB_TYPE_USB3_DOWN:
1313		return tb_usb3_port_is_enabled(port);
1314
1315	default:
1316		return false;
1317	}
1318}
1319
1320/**
1321 * tb_usb3_port_is_enabled() - Is the USB3 adapter port enabled
1322 * @port: USB3 adapter port to check
1323 */
1324bool tb_usb3_port_is_enabled(struct tb_port *port)
1325{
1326	u32 data;
1327
1328	if (tb_port_read(port, &data, TB_CFG_PORT,
1329			 port->cap_adap + ADP_USB3_CS_0, 1))
1330		return false;
1331
1332	return !!(data & ADP_USB3_CS_0_PE);
1333}
1334
1335/**
1336 * tb_usb3_port_enable() - Enable USB3 adapter port
1337 * @port: USB3 adapter port to enable
1338 * @enable: Enable/disable the USB3 adapter
1339 */
1340int tb_usb3_port_enable(struct tb_port *port, bool enable)
1341{
1342	u32 word = enable ? (ADP_USB3_CS_0_PE | ADP_USB3_CS_0_V)
1343			  : ADP_USB3_CS_0_V;
1344
1345	if (!port->cap_adap)
1346		return -ENXIO;
1347	return tb_port_write(port, &word, TB_CFG_PORT,
1348			     port->cap_adap + ADP_USB3_CS_0, 1);
1349}
1350
1351/**
1352 * tb_pci_port_is_enabled() - Is the PCIe adapter port enabled
1353 * @port: PCIe port to check
1354 */
1355bool tb_pci_port_is_enabled(struct tb_port *port)
1356{
1357	u32 data;
1358
1359	if (tb_port_read(port, &data, TB_CFG_PORT,
1360			 port->cap_adap + ADP_PCIE_CS_0, 1))
1361		return false;
1362
1363	return !!(data & ADP_PCIE_CS_0_PE);
1364}
1365
1366/**
1367 * tb_pci_port_enable() - Enable PCIe adapter port
1368 * @port: PCIe port to enable
1369 * @enable: Enable/disable the PCIe adapter
1370 */
1371int tb_pci_port_enable(struct tb_port *port, bool enable)
1372{
1373	u32 word = enable ? ADP_PCIE_CS_0_PE : 0x0;
1374	if (!port->cap_adap)
1375		return -ENXIO;
1376	return tb_port_write(port, &word, TB_CFG_PORT,
1377			     port->cap_adap + ADP_PCIE_CS_0, 1);
1378}
1379
1380/**
1381 * tb_dp_port_hpd_is_active() - Is HPD already active
1382 * @port: DP out port to check
1383 *
1384 * Checks if the DP OUT adapter port has HPD bit already set.
1385 */
1386int tb_dp_port_hpd_is_active(struct tb_port *port)
1387{
1388	u32 data;
1389	int ret;
1390
1391	ret = tb_port_read(port, &data, TB_CFG_PORT,
1392			   port->cap_adap + ADP_DP_CS_2, 1);
1393	if (ret)
1394		return ret;
1395
1396	return !!(data & ADP_DP_CS_2_HPD);
1397}
1398
1399/**
1400 * tb_dp_port_hpd_clear() - Clear HPD from DP IN port
1401 * @port: Port to clear HPD
1402 *
1403 * If the DP IN port has HPD set, this function can be used to clear it.
1404 */
1405int tb_dp_port_hpd_clear(struct tb_port *port)
1406{
1407	u32 data;
1408	int ret;
1409
1410	ret = tb_port_read(port, &data, TB_CFG_PORT,
1411			   port->cap_adap + ADP_DP_CS_3, 1);
1412	if (ret)
1413		return ret;
1414
1415	data |= ADP_DP_CS_3_HPDC;
1416	return tb_port_write(port, &data, TB_CFG_PORT,
1417			     port->cap_adap + ADP_DP_CS_3, 1);
1418}
1419
1420/**
1421 * tb_dp_port_set_hops() - Set video/aux Hop IDs for DP port
1422 * @port: DP IN/OUT port to set hops
1423 * @video: Video Hop ID
1424 * @aux_tx: AUX TX Hop ID
1425 * @aux_rx: AUX RX Hop ID
1426 *
1427 * Programs specified Hop IDs for DP IN/OUT port. Can be called for USB4
1428 * router DP adapters too but does not program the values as the fields
1429 * are read-only.
1430 */
1431int tb_dp_port_set_hops(struct tb_port *port, unsigned int video,
1432			unsigned int aux_tx, unsigned int aux_rx)
1433{
1434	u32 data[2];
1435	int ret;
1436
1437	if (tb_switch_is_usb4(port->sw))
1438		return 0;
1439
1440	ret = tb_port_read(port, data, TB_CFG_PORT,
1441			   port->cap_adap + ADP_DP_CS_0, ARRAY_SIZE(data));
1442	if (ret)
1443		return ret;
1444
1445	data[0] &= ~ADP_DP_CS_0_VIDEO_HOPID_MASK;
1446	data[1] &= ~ADP_DP_CS_1_AUX_RX_HOPID_MASK;
1447	data[1] &= ~ADP_DP_CS_1_AUX_RX_HOPID_MASK;
1448
1449	data[0] |= (video << ADP_DP_CS_0_VIDEO_HOPID_SHIFT) &
1450		ADP_DP_CS_0_VIDEO_HOPID_MASK;
1451	data[1] |= aux_tx & ADP_DP_CS_1_AUX_TX_HOPID_MASK;
1452	data[1] |= (aux_rx << ADP_DP_CS_1_AUX_RX_HOPID_SHIFT) &
1453		ADP_DP_CS_1_AUX_RX_HOPID_MASK;
1454
1455	return tb_port_write(port, data, TB_CFG_PORT,
1456			     port->cap_adap + ADP_DP_CS_0, ARRAY_SIZE(data));
1457}
1458
1459/**
1460 * tb_dp_port_is_enabled() - Is DP adapter port enabled
1461 * @port: DP adapter port to check
1462 */
1463bool tb_dp_port_is_enabled(struct tb_port *port)
1464{
1465	u32 data[2];
1466
1467	if (tb_port_read(port, data, TB_CFG_PORT, port->cap_adap + ADP_DP_CS_0,
1468			 ARRAY_SIZE(data)))
1469		return false;
1470
1471	return !!(data[0] & (ADP_DP_CS_0_VE | ADP_DP_CS_0_AE));
1472}
1473
1474/**
1475 * tb_dp_port_enable() - Enables/disables DP paths of a port
1476 * @port: DP IN/OUT port
1477 * @enable: Enable/disable DP path
1478 *
1479 * Once Hop IDs are programmed DP paths can be enabled or disabled by
1480 * calling this function.
1481 */
1482int tb_dp_port_enable(struct tb_port *port, bool enable)
1483{
1484	u32 data[2];
1485	int ret;
1486
1487	ret = tb_port_read(port, data, TB_CFG_PORT,
1488			  port->cap_adap + ADP_DP_CS_0, ARRAY_SIZE(data));
1489	if (ret)
1490		return ret;
1491
1492	if (enable)
1493		data[0] |= ADP_DP_CS_0_VE | ADP_DP_CS_0_AE;
1494	else
1495		data[0] &= ~(ADP_DP_CS_0_VE | ADP_DP_CS_0_AE);
1496
1497	return tb_port_write(port, data, TB_CFG_PORT,
1498			     port->cap_adap + ADP_DP_CS_0, ARRAY_SIZE(data));
1499}
1500
1501/* switch utility functions */
1502
1503static const char *tb_switch_generation_name(const struct tb_switch *sw)
1504{
1505	switch (sw->generation) {
1506	case 1:
1507		return "Thunderbolt 1";
1508	case 2:
1509		return "Thunderbolt 2";
1510	case 3:
1511		return "Thunderbolt 3";
1512	case 4:
1513		return "USB4";
1514	default:
1515		return "Unknown";
1516	}
1517}
1518
1519static void tb_dump_switch(const struct tb *tb, const struct tb_switch *sw)
1520{
1521	const struct tb_regs_switch_header *regs = &sw->config;
1522
1523	tb_dbg(tb, " %s Switch: %x:%x (Revision: %d, TB Version: %d)\n",
1524	       tb_switch_generation_name(sw), regs->vendor_id, regs->device_id,
1525	       regs->revision, regs->thunderbolt_version);
1526	tb_dbg(tb, "  Max Port Number: %d\n", regs->max_port_number);
1527	tb_dbg(tb, "  Config:\n");
1528	tb_dbg(tb,
1529		"   Upstream Port Number: %d Depth: %d Route String: %#llx Enabled: %d, PlugEventsDelay: %dms\n",
1530	       regs->upstream_port_number, regs->depth,
1531	       (((u64) regs->route_hi) << 32) | regs->route_lo,
1532	       regs->enabled, regs->plug_events_delay);
1533	tb_dbg(tb, "   unknown1: %#x unknown4: %#x\n",
1534	       regs->__unknown1, regs->__unknown4);
 
1535}
1536
1537/**
1538 * tb_switch_reset() - reconfigure route, enable and send TB_CFG_PKG_RESET
1539 * @sw: Switch to reset
1540 *
1541 * Return: Returns 0 on success or an error code on failure.
1542 */
1543int tb_switch_reset(struct tb_switch *sw)
1544{
1545	struct tb_cfg_result res;
1546
1547	if (sw->generation > 1)
1548		return 0;
1549
1550	tb_sw_dbg(sw, "resetting switch\n");
1551
1552	res.err = tb_sw_write(sw, ((u32 *) &sw->config) + 2,
1553			      TB_CFG_SWITCH, 2, 2);
1554	if (res.err)
1555		return res.err;
1556	res = tb_cfg_reset(sw->tb->ctl, tb_route(sw));
1557	if (res.err > 0)
1558		return -EIO;
1559	return res.err;
1560}
1561
1562/**
1563 * tb_switch_wait_for_bit() - Wait for specified value of bits in offset
1564 * @sw: Router to read the offset value from
1565 * @offset: Offset in the router config space to read from
1566 * @bit: Bit mask in the offset to wait for
1567 * @value: Value of the bits to wait for
1568 * @timeout_msec: Timeout in ms how long to wait
1569 *
1570 * Wait till the specified bits in specified offset reach specified value.
1571 * Returns %0 in case of success, %-ETIMEDOUT if the @value was not reached
1572 * within the given timeout or a negative errno in case of failure.
1573 */
1574int tb_switch_wait_for_bit(struct tb_switch *sw, u32 offset, u32 bit,
1575			   u32 value, int timeout_msec)
1576{
1577	ktime_t timeout = ktime_add_ms(ktime_get(), timeout_msec);
1578
1579	do {
1580		u32 val;
1581		int ret;
1582
1583		ret = tb_sw_read(sw, &val, TB_CFG_SWITCH, offset, 1);
1584		if (ret)
1585			return ret;
1586
1587		if ((val & bit) == value)
1588			return 0;
1589
1590		usleep_range(50, 100);
1591	} while (ktime_before(ktime_get(), timeout));
1592
1593	return -ETIMEDOUT;
1594}
1595
1596/*
1597 * tb_plug_events_active() - enable/disable plug events on a switch
1598 *
1599 * Also configures a sane plug_events_delay of 255ms.
1600 *
1601 * Return: Returns 0 on success or an error code on failure.
1602 */
1603static int tb_plug_events_active(struct tb_switch *sw, bool active)
1604{
1605	u32 data;
1606	int res;
1607
1608	if (tb_switch_is_icm(sw) || tb_switch_is_usb4(sw))
1609		return 0;
1610
1611	sw->config.plug_events_delay = 0xff;
1612	res = tb_sw_write(sw, ((u32 *) &sw->config) + 4, TB_CFG_SWITCH, 4, 1);
1613	if (res)
1614		return res;
1615
1616	res = tb_sw_read(sw, &data, TB_CFG_SWITCH, sw->cap_plug_events + 1, 1);
1617	if (res)
1618		return res;
1619
1620	if (active) {
1621		data = data & 0xFFFFFF83;
1622		switch (sw->config.device_id) {
1623		case PCI_DEVICE_ID_INTEL_LIGHT_RIDGE:
1624		case PCI_DEVICE_ID_INTEL_EAGLE_RIDGE:
1625		case PCI_DEVICE_ID_INTEL_PORT_RIDGE:
1626			break;
1627		default:
1628			/*
1629			 * Skip Alpine Ridge, it needs to have vendor
1630			 * specific USB hotplug event enabled for the
1631			 * internal xHCI to work.
1632			 */
1633			if (!tb_switch_is_alpine_ridge(sw))
1634				data |= TB_PLUG_EVENTS_USB_DISABLE;
1635		}
1636	} else {
1637		data = data | 0x7c;
1638	}
1639	return tb_sw_write(sw, &data, TB_CFG_SWITCH,
1640			   sw->cap_plug_events + 1, 1);
1641}
1642
1643static ssize_t authorized_show(struct device *dev,
1644			       struct device_attribute *attr,
1645			       char *buf)
1646{
1647	struct tb_switch *sw = tb_to_switch(dev);
1648
1649	return sysfs_emit(buf, "%u\n", sw->authorized);
1650}
1651
1652static int disapprove_switch(struct device *dev, void *not_used)
1653{
1654	char *envp[] = { "AUTHORIZED=0", NULL };
1655	struct tb_switch *sw;
1656
1657	sw = tb_to_switch(dev);
1658	if (sw && sw->authorized) {
1659		int ret;
1660
1661		/* First children */
1662		ret = device_for_each_child_reverse(&sw->dev, NULL, disapprove_switch);
1663		if (ret)
1664			return ret;
1665
1666		ret = tb_domain_disapprove_switch(sw->tb, sw);
1667		if (ret)
1668			return ret;
1669
1670		sw->authorized = 0;
1671		kobject_uevent_env(&sw->dev.kobj, KOBJ_CHANGE, envp);
1672	}
1673
1674	return 0;
1675}
1676
1677static int tb_switch_set_authorized(struct tb_switch *sw, unsigned int val)
1678{
1679	char envp_string[13];
1680	int ret = -EINVAL;
1681	char *envp[] = { envp_string, NULL };
1682
1683	if (!mutex_trylock(&sw->tb->lock))
1684		return restart_syscall();
1685
1686	if (!!sw->authorized == !!val)
1687		goto unlock;
1688
1689	switch (val) {
1690	/* Disapprove switch */
1691	case 0:
1692		if (tb_route(sw)) {
1693			ret = disapprove_switch(&sw->dev, NULL);
1694			goto unlock;
1695		}
1696		break;
1697
 
1698	/* Approve switch */
1699	case 1:
1700		if (sw->key)
1701			ret = tb_domain_approve_switch_key(sw->tb, sw);
1702		else
1703			ret = tb_domain_approve_switch(sw->tb, sw);
1704		break;
1705
1706	/* Challenge switch */
1707	case 2:
1708		if (sw->key)
1709			ret = tb_domain_challenge_switch_key(sw->tb, sw);
1710		break;
1711
1712	default:
1713		break;
1714	}
1715
 
 
1716	if (!ret) {
1717		sw->authorized = val;
1718		/*
1719		 * Notify status change to the userspace, informing the new
1720		 * value of /sys/bus/thunderbolt/devices/.../authorized.
1721		 */
1722		sprintf(envp_string, "AUTHORIZED=%u", sw->authorized);
1723		kobject_uevent_env(&sw->dev.kobj, KOBJ_CHANGE, envp);
1724	}
1725
1726unlock:
1727	mutex_unlock(&sw->tb->lock);
1728	return ret;
1729}
1730
1731static ssize_t authorized_store(struct device *dev,
1732				struct device_attribute *attr,
1733				const char *buf, size_t count)
1734{
1735	struct tb_switch *sw = tb_to_switch(dev);
1736	unsigned int val;
1737	ssize_t ret;
1738
1739	ret = kstrtouint(buf, 0, &val);
1740	if (ret)
1741		return ret;
1742	if (val > 2)
1743		return -EINVAL;
1744
1745	pm_runtime_get_sync(&sw->dev);
1746	ret = tb_switch_set_authorized(sw, val);
1747	pm_runtime_mark_last_busy(&sw->dev);
1748	pm_runtime_put_autosuspend(&sw->dev);
1749
1750	return ret ? ret : count;
1751}
1752static DEVICE_ATTR_RW(authorized);
1753
1754static ssize_t boot_show(struct device *dev, struct device_attribute *attr,
1755			 char *buf)
1756{
1757	struct tb_switch *sw = tb_to_switch(dev);
1758
1759	return sysfs_emit(buf, "%u\n", sw->boot);
1760}
1761static DEVICE_ATTR_RO(boot);
1762
1763static ssize_t device_show(struct device *dev, struct device_attribute *attr,
1764			   char *buf)
1765{
1766	struct tb_switch *sw = tb_to_switch(dev);
1767
1768	return sysfs_emit(buf, "%#x\n", sw->device);
1769}
1770static DEVICE_ATTR_RO(device);
1771
1772static ssize_t
1773device_name_show(struct device *dev, struct device_attribute *attr, char *buf)
1774{
1775	struct tb_switch *sw = tb_to_switch(dev);
1776
1777	return sysfs_emit(buf, "%s\n", sw->device_name ?: "");
1778}
1779static DEVICE_ATTR_RO(device_name);
1780
1781static ssize_t
1782generation_show(struct device *dev, struct device_attribute *attr, char *buf)
1783{
1784	struct tb_switch *sw = tb_to_switch(dev);
1785
1786	return sysfs_emit(buf, "%u\n", sw->generation);
1787}
1788static DEVICE_ATTR_RO(generation);
1789
1790static ssize_t key_show(struct device *dev, struct device_attribute *attr,
1791			char *buf)
1792{
1793	struct tb_switch *sw = tb_to_switch(dev);
1794	ssize_t ret;
1795
1796	if (!mutex_trylock(&sw->tb->lock))
1797		return restart_syscall();
1798
1799	if (sw->key)
1800		ret = sysfs_emit(buf, "%*phN\n", TB_SWITCH_KEY_SIZE, sw->key);
1801	else
1802		ret = sysfs_emit(buf, "\n");
1803
1804	mutex_unlock(&sw->tb->lock);
1805	return ret;
1806}
1807
1808static ssize_t key_store(struct device *dev, struct device_attribute *attr,
1809			 const char *buf, size_t count)
1810{
1811	struct tb_switch *sw = tb_to_switch(dev);
1812	u8 key[TB_SWITCH_KEY_SIZE];
1813	ssize_t ret = count;
1814	bool clear = false;
1815
1816	if (!strcmp(buf, "\n"))
1817		clear = true;
1818	else if (hex2bin(key, buf, sizeof(key)))
1819		return -EINVAL;
1820
1821	if (!mutex_trylock(&sw->tb->lock))
1822		return restart_syscall();
1823
1824	if (sw->authorized) {
1825		ret = -EBUSY;
1826	} else {
1827		kfree(sw->key);
1828		if (clear) {
1829			sw->key = NULL;
1830		} else {
1831			sw->key = kmemdup(key, sizeof(key), GFP_KERNEL);
1832			if (!sw->key)
1833				ret = -ENOMEM;
1834		}
1835	}
1836
1837	mutex_unlock(&sw->tb->lock);
1838	return ret;
1839}
1840static DEVICE_ATTR(key, 0600, key_show, key_store);
1841
1842static ssize_t speed_show(struct device *dev, struct device_attribute *attr,
1843			  char *buf)
1844{
1845	struct tb_switch *sw = tb_to_switch(dev);
1846
1847	return sysfs_emit(buf, "%u.0 Gb/s\n", sw->link_speed);
1848}
1849
1850/*
1851 * Currently all lanes must run at the same speed but we expose here
1852 * both directions to allow possible asymmetric links in the future.
1853 */
1854static DEVICE_ATTR(rx_speed, 0444, speed_show, NULL);
1855static DEVICE_ATTR(tx_speed, 0444, speed_show, NULL);
1856
1857static ssize_t rx_lanes_show(struct device *dev, struct device_attribute *attr,
1858			     char *buf)
1859{
1860	struct tb_switch *sw = tb_to_switch(dev);
1861	unsigned int width;
1862
1863	switch (sw->link_width) {
1864	case TB_LINK_WIDTH_SINGLE:
1865	case TB_LINK_WIDTH_ASYM_TX:
1866		width = 1;
1867		break;
1868	case TB_LINK_WIDTH_DUAL:
1869		width = 2;
1870		break;
1871	case TB_LINK_WIDTH_ASYM_RX:
1872		width = 3;
1873		break;
1874	default:
1875		WARN_ON_ONCE(1);
1876		return -EINVAL;
1877	}
1878
1879	return sysfs_emit(buf, "%u\n", width);
1880}
1881static DEVICE_ATTR(rx_lanes, 0444, rx_lanes_show, NULL);
1882
1883static ssize_t tx_lanes_show(struct device *dev, struct device_attribute *attr,
1884			     char *buf)
1885{
1886	struct tb_switch *sw = tb_to_switch(dev);
1887	unsigned int width;
1888
1889	switch (sw->link_width) {
1890	case TB_LINK_WIDTH_SINGLE:
1891	case TB_LINK_WIDTH_ASYM_RX:
1892		width = 1;
1893		break;
1894	case TB_LINK_WIDTH_DUAL:
1895		width = 2;
1896		break;
1897	case TB_LINK_WIDTH_ASYM_TX:
1898		width = 3;
1899		break;
1900	default:
1901		WARN_ON_ONCE(1);
1902		return -EINVAL;
1903	}
1904
1905	return sysfs_emit(buf, "%u\n", width);
1906}
1907static DEVICE_ATTR(tx_lanes, 0444, tx_lanes_show, NULL);
1908
1909static ssize_t nvm_authenticate_show(struct device *dev,
1910	struct device_attribute *attr, char *buf)
1911{
1912	struct tb_switch *sw = tb_to_switch(dev);
1913	u32 status;
1914
1915	nvm_get_auth_status(sw, &status);
1916	return sysfs_emit(buf, "%#x\n", status);
1917}
1918
1919static ssize_t nvm_authenticate_sysfs(struct device *dev, const char *buf,
1920				      bool disconnect)
1921{
1922	struct tb_switch *sw = tb_to_switch(dev);
1923	int val, ret;
1924
1925	pm_runtime_get_sync(&sw->dev);
1926
1927	if (!mutex_trylock(&sw->tb->lock)) {
1928		ret = restart_syscall();
1929		goto exit_rpm;
1930	}
1931
1932	if (sw->no_nvm_upgrade) {
1933		ret = -EOPNOTSUPP;
1934		goto exit_unlock;
1935	}
1936
1937	/* If NVMem devices are not yet added */
1938	if (!sw->nvm) {
1939		ret = -EAGAIN;
1940		goto exit_unlock;
1941	}
1942
1943	ret = kstrtoint(buf, 10, &val);
1944	if (ret)
1945		goto exit_unlock;
1946
1947	/* Always clear the authentication status */
1948	nvm_clear_auth_status(sw);
1949
1950	if (val > 0) {
1951		if (val == AUTHENTICATE_ONLY) {
1952			if (disconnect)
1953				ret = -EINVAL;
1954			else
1955				ret = nvm_authenticate(sw, true);
1956		} else {
1957			if (!sw->nvm->flushed) {
1958				if (!sw->nvm->buf) {
1959					ret = -EINVAL;
1960					goto exit_unlock;
1961				}
1962
1963				ret = nvm_validate_and_write(sw);
1964				if (ret || val == WRITE_ONLY)
1965					goto exit_unlock;
1966			}
1967			if (val == WRITE_AND_AUTHENTICATE) {
1968				if (disconnect)
1969					ret = tb_lc_force_power(sw);
1970				else
1971					ret = nvm_authenticate(sw, false);
1972			}
1973		}
1974	}
1975
1976exit_unlock:
1977	mutex_unlock(&sw->tb->lock);
1978exit_rpm:
1979	pm_runtime_mark_last_busy(&sw->dev);
1980	pm_runtime_put_autosuspend(&sw->dev);
1981
1982	return ret;
1983}
1984
1985static ssize_t nvm_authenticate_store(struct device *dev,
1986	struct device_attribute *attr, const char *buf, size_t count)
1987{
1988	int ret = nvm_authenticate_sysfs(dev, buf, false);
1989	if (ret)
1990		return ret;
1991	return count;
1992}
1993static DEVICE_ATTR_RW(nvm_authenticate);
1994
1995static ssize_t nvm_authenticate_on_disconnect_show(struct device *dev,
1996	struct device_attribute *attr, char *buf)
1997{
1998	return nvm_authenticate_show(dev, attr, buf);
1999}
2000
2001static ssize_t nvm_authenticate_on_disconnect_store(struct device *dev,
2002	struct device_attribute *attr, const char *buf, size_t count)
2003{
2004	int ret;
2005
2006	ret = nvm_authenticate_sysfs(dev, buf, true);
2007	return ret ? ret : count;
2008}
2009static DEVICE_ATTR_RW(nvm_authenticate_on_disconnect);
2010
2011static ssize_t nvm_version_show(struct device *dev,
2012				struct device_attribute *attr, char *buf)
2013{
2014	struct tb_switch *sw = tb_to_switch(dev);
2015	int ret;
2016
2017	if (!mutex_trylock(&sw->tb->lock))
2018		return restart_syscall();
2019
2020	if (sw->safe_mode)
2021		ret = -ENODATA;
2022	else if (!sw->nvm)
2023		ret = -EAGAIN;
2024	else
2025		ret = sysfs_emit(buf, "%x.%x\n", sw->nvm->major, sw->nvm->minor);
2026
2027	mutex_unlock(&sw->tb->lock);
2028
2029	return ret;
2030}
2031static DEVICE_ATTR_RO(nvm_version);
2032
2033static ssize_t vendor_show(struct device *dev, struct device_attribute *attr,
2034			   char *buf)
2035{
2036	struct tb_switch *sw = tb_to_switch(dev);
2037
2038	return sysfs_emit(buf, "%#x\n", sw->vendor);
2039}
2040static DEVICE_ATTR_RO(vendor);
2041
2042static ssize_t
2043vendor_name_show(struct device *dev, struct device_attribute *attr, char *buf)
2044{
2045	struct tb_switch *sw = tb_to_switch(dev);
2046
2047	return sysfs_emit(buf, "%s\n", sw->vendor_name ?: "");
2048}
2049static DEVICE_ATTR_RO(vendor_name);
2050
2051static ssize_t unique_id_show(struct device *dev, struct device_attribute *attr,
2052			      char *buf)
2053{
2054	struct tb_switch *sw = tb_to_switch(dev);
2055
2056	return sysfs_emit(buf, "%pUb\n", sw->uuid);
2057}
2058static DEVICE_ATTR_RO(unique_id);
2059
2060static struct attribute *switch_attrs[] = {
2061	&dev_attr_authorized.attr,
2062	&dev_attr_boot.attr,
2063	&dev_attr_device.attr,
2064	&dev_attr_device_name.attr,
2065	&dev_attr_generation.attr,
2066	&dev_attr_key.attr,
2067	&dev_attr_nvm_authenticate.attr,
2068	&dev_attr_nvm_authenticate_on_disconnect.attr,
2069	&dev_attr_nvm_version.attr,
2070	&dev_attr_rx_speed.attr,
2071	&dev_attr_rx_lanes.attr,
2072	&dev_attr_tx_speed.attr,
2073	&dev_attr_tx_lanes.attr,
2074	&dev_attr_vendor.attr,
2075	&dev_attr_vendor_name.attr,
2076	&dev_attr_unique_id.attr,
2077	NULL,
2078};
2079
2080static umode_t switch_attr_is_visible(struct kobject *kobj,
2081				      struct attribute *attr, int n)
2082{
2083	struct device *dev = kobj_to_dev(kobj);
2084	struct tb_switch *sw = tb_to_switch(dev);
2085
2086	if (attr == &dev_attr_authorized.attr) {
2087		if (sw->tb->security_level == TB_SECURITY_NOPCIE ||
2088		    sw->tb->security_level == TB_SECURITY_DPONLY)
2089			return 0;
2090	} else if (attr == &dev_attr_device.attr) {
2091		if (!sw->device)
2092			return 0;
2093	} else if (attr == &dev_attr_device_name.attr) {
2094		if (!sw->device_name)
2095			return 0;
2096	} else if (attr == &dev_attr_vendor.attr)  {
2097		if (!sw->vendor)
2098			return 0;
2099	} else if (attr == &dev_attr_vendor_name.attr)  {
2100		if (!sw->vendor_name)
2101			return 0;
2102	} else if (attr == &dev_attr_key.attr) {
2103		if (tb_route(sw) &&
2104		    sw->tb->security_level == TB_SECURITY_SECURE &&
2105		    sw->security_level == TB_SECURITY_SECURE)
2106			return attr->mode;
2107		return 0;
2108	} else if (attr == &dev_attr_rx_speed.attr ||
2109		   attr == &dev_attr_rx_lanes.attr ||
2110		   attr == &dev_attr_tx_speed.attr ||
2111		   attr == &dev_attr_tx_lanes.attr) {
2112		if (tb_route(sw))
2113			return attr->mode;
2114		return 0;
2115	} else if (attr == &dev_attr_nvm_authenticate.attr) {
2116		if (nvm_upgradeable(sw))
2117			return attr->mode;
2118		return 0;
2119	} else if (attr == &dev_attr_nvm_version.attr) {
2120		if (nvm_readable(sw))
2121			return attr->mode;
2122		return 0;
2123	} else if (attr == &dev_attr_boot.attr) {
2124		if (tb_route(sw))
2125			return attr->mode;
2126		return 0;
2127	} else if (attr == &dev_attr_nvm_authenticate_on_disconnect.attr) {
2128		if (sw->quirks & QUIRK_FORCE_POWER_LINK_CONTROLLER)
2129			return attr->mode;
2130		return 0;
2131	}
2132
2133	return sw->safe_mode ? 0 : attr->mode;
2134}
2135
2136static const struct attribute_group switch_group = {
2137	.is_visible = switch_attr_is_visible,
2138	.attrs = switch_attrs,
2139};
2140
2141static const struct attribute_group *switch_groups[] = {
2142	&switch_group,
2143	NULL,
2144};
2145
2146static void tb_switch_release(struct device *dev)
2147{
2148	struct tb_switch *sw = tb_to_switch(dev);
2149	struct tb_port *port;
2150
2151	dma_port_free(sw->dma_port);
2152
2153	tb_switch_for_each_port(sw, port) {
2154		ida_destroy(&port->in_hopids);
2155		ida_destroy(&port->out_hopids);
2156	}
2157
2158	kfree(sw->uuid);
2159	kfree(sw->device_name);
2160	kfree(sw->vendor_name);
2161	kfree(sw->ports);
2162	kfree(sw->drom);
2163	kfree(sw->key);
2164	kfree(sw);
2165}
2166
2167static int tb_switch_uevent(const struct device *dev, struct kobj_uevent_env *env)
2168{
2169	const struct tb_switch *sw = tb_to_switch(dev);
2170	const char *type;
2171
2172	if (tb_switch_is_usb4(sw)) {
2173		if (add_uevent_var(env, "USB4_VERSION=%u.0",
2174				   usb4_switch_version(sw)))
2175			return -ENOMEM;
2176	}
2177
2178	if (!tb_route(sw)) {
2179		type = "host";
2180	} else {
2181		const struct tb_port *port;
2182		bool hub = false;
2183
2184		/* Device is hub if it has any downstream ports */
2185		tb_switch_for_each_port(sw, port) {
2186			if (!port->disabled && !tb_is_upstream_port(port) &&
2187			     tb_port_is_null(port)) {
2188				hub = true;
2189				break;
2190			}
2191		}
2192
2193		type = hub ? "hub" : "device";
2194	}
2195
2196	if (add_uevent_var(env, "USB4_TYPE=%s", type))
2197		return -ENOMEM;
2198	return 0;
2199}
2200
2201/*
2202 * Currently only need to provide the callbacks. Everything else is handled
2203 * in the connection manager.
2204 */
2205static int __maybe_unused tb_switch_runtime_suspend(struct device *dev)
2206{
2207	struct tb_switch *sw = tb_to_switch(dev);
2208	const struct tb_cm_ops *cm_ops = sw->tb->cm_ops;
2209
2210	if (cm_ops->runtime_suspend_switch)
2211		return cm_ops->runtime_suspend_switch(sw);
2212
2213	return 0;
2214}
2215
2216static int __maybe_unused tb_switch_runtime_resume(struct device *dev)
2217{
2218	struct tb_switch *sw = tb_to_switch(dev);
2219	const struct tb_cm_ops *cm_ops = sw->tb->cm_ops;
2220
2221	if (cm_ops->runtime_resume_switch)
2222		return cm_ops->runtime_resume_switch(sw);
2223	return 0;
2224}
2225
2226static const struct dev_pm_ops tb_switch_pm_ops = {
2227	SET_RUNTIME_PM_OPS(tb_switch_runtime_suspend, tb_switch_runtime_resume,
2228			   NULL)
2229};
2230
2231struct device_type tb_switch_type = {
2232	.name = "thunderbolt_device",
2233	.release = tb_switch_release,
2234	.uevent = tb_switch_uevent,
2235	.pm = &tb_switch_pm_ops,
2236};
2237
2238static int tb_switch_get_generation(struct tb_switch *sw)
2239{
2240	if (tb_switch_is_usb4(sw))
2241		return 4;
 
 
 
 
 
 
 
 
 
 
 
 
 
2242
2243	if (sw->config.vendor_id == PCI_VENDOR_ID_INTEL) {
2244		switch (sw->config.device_id) {
2245		case PCI_DEVICE_ID_INTEL_LIGHT_RIDGE:
2246		case PCI_DEVICE_ID_INTEL_EAGLE_RIDGE:
2247		case PCI_DEVICE_ID_INTEL_LIGHT_PEAK:
2248		case PCI_DEVICE_ID_INTEL_CACTUS_RIDGE_2C:
2249		case PCI_DEVICE_ID_INTEL_CACTUS_RIDGE_4C:
2250		case PCI_DEVICE_ID_INTEL_PORT_RIDGE:
2251		case PCI_DEVICE_ID_INTEL_REDWOOD_RIDGE_2C_BRIDGE:
2252		case PCI_DEVICE_ID_INTEL_REDWOOD_RIDGE_4C_BRIDGE:
2253			return 1;
2254
2255		case PCI_DEVICE_ID_INTEL_WIN_RIDGE_2C_BRIDGE:
2256		case PCI_DEVICE_ID_INTEL_FALCON_RIDGE_2C_BRIDGE:
2257		case PCI_DEVICE_ID_INTEL_FALCON_RIDGE_4C_BRIDGE:
2258			return 2;
2259
2260		case PCI_DEVICE_ID_INTEL_ALPINE_RIDGE_LP_BRIDGE:
2261		case PCI_DEVICE_ID_INTEL_ALPINE_RIDGE_2C_BRIDGE:
2262		case PCI_DEVICE_ID_INTEL_ALPINE_RIDGE_4C_BRIDGE:
2263		case PCI_DEVICE_ID_INTEL_ALPINE_RIDGE_C_2C_BRIDGE:
2264		case PCI_DEVICE_ID_INTEL_ALPINE_RIDGE_C_4C_BRIDGE:
2265		case PCI_DEVICE_ID_INTEL_TITAN_RIDGE_2C_BRIDGE:
2266		case PCI_DEVICE_ID_INTEL_TITAN_RIDGE_4C_BRIDGE:
2267		case PCI_DEVICE_ID_INTEL_TITAN_RIDGE_DD_BRIDGE:
2268		case PCI_DEVICE_ID_INTEL_ICL_NHI0:
2269		case PCI_DEVICE_ID_INTEL_ICL_NHI1:
2270			return 3;
2271		}
2272	}
2273
2274	/*
2275	 * For unknown switches assume generation to be 1 to be on the
2276	 * safe side.
2277	 */
2278	tb_sw_warn(sw, "unsupported switch device id %#x\n",
2279		   sw->config.device_id);
2280	return 1;
2281}
2282
2283static bool tb_switch_exceeds_max_depth(const struct tb_switch *sw, int depth)
2284{
2285	int max_depth;
2286
2287	if (tb_switch_is_usb4(sw) ||
2288	    (sw->tb->root_switch && tb_switch_is_usb4(sw->tb->root_switch)))
2289		max_depth = USB4_SWITCH_MAX_DEPTH;
2290	else
2291		max_depth = TB_SWITCH_MAX_DEPTH;
2292
2293	return depth > max_depth;
2294}
2295
2296/**
2297 * tb_switch_alloc() - allocate a switch
2298 * @tb: Pointer to the owning domain
2299 * @parent: Parent device for this switch
2300 * @route: Route string for this switch
2301 *
2302 * Allocates and initializes a switch. Will not upload configuration to
2303 * the switch. For that you need to call tb_switch_configure()
2304 * separately. The returned switch should be released by calling
2305 * tb_switch_put().
2306 *
2307 * Return: Pointer to the allocated switch or ERR_PTR() in case of
2308 * failure.
2309 */
2310struct tb_switch *tb_switch_alloc(struct tb *tb, struct device *parent,
2311				  u64 route)
2312{
 
 
2313	struct tb_switch *sw;
2314	int upstream_port;
2315	int i, ret, depth;
2316
2317	/* Unlock the downstream port so we can access the switch below */
2318	if (route) {
2319		struct tb_switch *parent_sw = tb_to_switch(parent);
2320		struct tb_port *down;
2321
2322		down = tb_port_at(route, parent_sw);
2323		tb_port_unlock(down);
2324	}
2325
2326	depth = tb_route_length(route);
2327
2328	upstream_port = tb_cfg_get_upstream_port(tb->ctl, route);
2329	if (upstream_port < 0)
2330		return ERR_PTR(upstream_port);
2331
2332	sw = kzalloc(sizeof(*sw), GFP_KERNEL);
2333	if (!sw)
2334		return ERR_PTR(-ENOMEM);
2335
2336	sw->tb = tb;
2337	ret = tb_cfg_read(tb->ctl, &sw->config, route, 0, TB_CFG_SWITCH, 0, 5);
2338	if (ret)
2339		goto err_free_sw_ports;
2340
2341	sw->generation = tb_switch_get_generation(sw);
2342
2343	tb_dbg(tb, "current switch config:\n");
2344	tb_dump_switch(tb, sw);
2345
2346	/* configure switch */
2347	sw->config.upstream_port_number = upstream_port;
2348	sw->config.depth = depth;
2349	sw->config.route_hi = upper_32_bits(route);
2350	sw->config.route_lo = lower_32_bits(route);
2351	sw->config.enabled = 0;
2352
2353	/* Make sure we do not exceed maximum topology limit */
2354	if (tb_switch_exceeds_max_depth(sw, depth)) {
2355		ret = -EADDRNOTAVAIL;
2356		goto err_free_sw_ports;
2357	}
2358
2359	/* initialize ports */
2360	sw->ports = kcalloc(sw->config.max_port_number + 1, sizeof(*sw->ports),
2361				GFP_KERNEL);
2362	if (!sw->ports) {
2363		ret = -ENOMEM;
2364		goto err_free_sw_ports;
2365	}
2366
2367	for (i = 0; i <= sw->config.max_port_number; i++) {
2368		/* minimum setup for tb_find_cap and tb_drom_read to work */
2369		sw->ports[i].sw = sw;
2370		sw->ports[i].port = i;
2371
2372		/* Control port does not need HopID allocation */
2373		if (i) {
2374			ida_init(&sw->ports[i].in_hopids);
2375			ida_init(&sw->ports[i].out_hopids);
2376		}
2377	}
2378
2379	ret = tb_switch_find_vse_cap(sw, TB_VSE_CAP_PLUG_EVENTS);
2380	if (ret > 0)
2381		sw->cap_plug_events = ret;
2382
2383	ret = tb_switch_find_vse_cap(sw, TB_VSE_CAP_TIME2);
2384	if (ret > 0)
2385		sw->cap_vsec_tmu = ret;
2386
2387	ret = tb_switch_find_vse_cap(sw, TB_VSE_CAP_LINK_CONTROLLER);
2388	if (ret > 0)
2389		sw->cap_lc = ret;
2390
2391	ret = tb_switch_find_vse_cap(sw, TB_VSE_CAP_CP_LP);
2392	if (ret > 0)
2393		sw->cap_lp = ret;
2394
2395	/* Root switch is always authorized */
2396	if (!route)
2397		sw->authorized = true;
2398
2399	device_initialize(&sw->dev);
2400	sw->dev.parent = parent;
2401	sw->dev.bus = &tb_bus_type;
2402	sw->dev.type = &tb_switch_type;
2403	sw->dev.groups = switch_groups;
2404	dev_set_name(&sw->dev, "%u-%llx", tb->index, tb_route(sw));
2405
2406	return sw;
2407
2408err_free_sw_ports:
2409	kfree(sw->ports);
2410	kfree(sw);
2411
2412	return ERR_PTR(ret);
2413}
2414
2415/**
2416 * tb_switch_alloc_safe_mode() - allocate a switch that is in safe mode
2417 * @tb: Pointer to the owning domain
2418 * @parent: Parent device for this switch
2419 * @route: Route string for this switch
2420 *
2421 * This creates a switch in safe mode. This means the switch pretty much
2422 * lacks all capabilities except DMA configuration port before it is
2423 * flashed with a valid NVM firmware.
2424 *
2425 * The returned switch must be released by calling tb_switch_put().
2426 *
2427 * Return: Pointer to the allocated switch or ERR_PTR() in case of failure
2428 */
2429struct tb_switch *
2430tb_switch_alloc_safe_mode(struct tb *tb, struct device *parent, u64 route)
2431{
2432	struct tb_switch *sw;
2433
2434	sw = kzalloc(sizeof(*sw), GFP_KERNEL);
2435	if (!sw)
2436		return ERR_PTR(-ENOMEM);
2437
2438	sw->tb = tb;
2439	sw->config.depth = tb_route_length(route);
2440	sw->config.route_hi = upper_32_bits(route);
2441	sw->config.route_lo = lower_32_bits(route);
2442	sw->safe_mode = true;
2443
2444	device_initialize(&sw->dev);
2445	sw->dev.parent = parent;
2446	sw->dev.bus = &tb_bus_type;
2447	sw->dev.type = &tb_switch_type;
2448	sw->dev.groups = switch_groups;
2449	dev_set_name(&sw->dev, "%u-%llx", tb->index, tb_route(sw));
2450
2451	return sw;
2452}
2453
2454/**
2455 * tb_switch_configure() - Uploads configuration to the switch
2456 * @sw: Switch to configure
2457 *
2458 * Call this function before the switch is added to the system. It will
2459 * upload configuration to the switch and makes it available for the
2460 * connection manager to use. Can be called to the switch again after
2461 * resume from low power states to re-initialize it.
2462 *
2463 * Return: %0 in case of success and negative errno in case of failure
2464 */
2465int tb_switch_configure(struct tb_switch *sw)
2466{
2467	struct tb *tb = sw->tb;
2468	u64 route;
2469	int ret;
2470
2471	route = tb_route(sw);
2472
2473	tb_dbg(tb, "%s Switch at %#llx (depth: %d, up port: %d)\n",
2474	       sw->config.enabled ? "restoring" : "initializing", route,
2475	       tb_route_length(route), sw->config.upstream_port_number);
 
 
 
2476
2477	sw->config.enabled = 1;
2478
2479	if (tb_switch_is_usb4(sw)) {
2480		/*
2481		 * For USB4 devices, we need to program the CM version
2482		 * accordingly so that it knows to expose all the
2483		 * additional capabilities. Program it according to USB4
2484		 * version to avoid changing existing (v1) routers behaviour.
2485		 */
2486		if (usb4_switch_version(sw) < 2)
2487			sw->config.cmuv = ROUTER_CS_4_CMUV_V1;
2488		else
2489			sw->config.cmuv = ROUTER_CS_4_CMUV_V2;
2490		sw->config.plug_events_delay = 0xa;
2491
2492		/* Enumerate the switch */
2493		ret = tb_sw_write(sw, (u32 *)&sw->config + 1, TB_CFG_SWITCH,
2494				  ROUTER_CS_1, 4);
2495		if (ret)
2496			return ret;
2497
2498		ret = usb4_switch_setup(sw);
2499	} else {
2500		if (sw->config.vendor_id != PCI_VENDOR_ID_INTEL)
2501			tb_sw_warn(sw, "unknown switch vendor id %#x\n",
2502				   sw->config.vendor_id);
2503
2504		if (!sw->cap_plug_events) {
2505			tb_sw_warn(sw, "cannot find TB_VSE_CAP_PLUG_EVENTS aborting\n");
2506			return -ENODEV;
2507		}
2508
2509		/* Enumerate the switch */
2510		ret = tb_sw_write(sw, (u32 *)&sw->config + 1, TB_CFG_SWITCH,
2511				  ROUTER_CS_1, 3);
2512	}
2513	if (ret)
2514		return ret;
2515
2516	return tb_plug_events_active(sw, true);
2517}
2518
2519/**
2520 * tb_switch_configuration_valid() - Set the tunneling configuration to be valid
2521 * @sw: Router to configure
2522 *
2523 * Needs to be called before any tunnels can be setup through the
2524 * router. Can be called to any router.
2525 *
2526 * Returns %0 in success and negative errno otherwise.
2527 */
2528int tb_switch_configuration_valid(struct tb_switch *sw)
2529{
2530	if (tb_switch_is_usb4(sw))
2531		return usb4_switch_configuration_valid(sw);
2532	return 0;
2533}
2534
2535static int tb_switch_set_uuid(struct tb_switch *sw)
2536{
2537	bool uid = false;
2538	u32 uuid[4];
2539	int ret;
2540
2541	if (sw->uuid)
2542		return 0;
2543
2544	if (tb_switch_is_usb4(sw)) {
2545		ret = usb4_switch_read_uid(sw, &sw->uid);
2546		if (ret)
2547			return ret;
2548		uid = true;
 
 
2549	} else {
2550		/*
2551		 * The newer controllers include fused UUID as part of
2552		 * link controller specific registers
2553		 */
2554		ret = tb_lc_read_uuid(sw, uuid);
2555		if (ret) {
2556			if (ret != -EINVAL)
2557				return ret;
2558			uid = true;
2559		}
2560	}
2561
2562	if (uid) {
2563		/*
2564		 * ICM generates UUID based on UID and fills the upper
2565		 * two words with ones. This is not strictly following
2566		 * UUID format but we want to be compatible with it so
2567		 * we do the same here.
2568		 */
2569		uuid[0] = sw->uid & 0xffffffff;
2570		uuid[1] = (sw->uid >> 32) & 0xffffffff;
2571		uuid[2] = 0xffffffff;
2572		uuid[3] = 0xffffffff;
2573	}
2574
2575	sw->uuid = kmemdup(uuid, sizeof(uuid), GFP_KERNEL);
2576	if (!sw->uuid)
2577		return -ENOMEM;
2578	return 0;
2579}
2580
2581static int tb_switch_add_dma_port(struct tb_switch *sw)
2582{
2583	u32 status;
2584	int ret;
2585
2586	switch (sw->generation) {
 
 
 
2587	case 2:
2588		/* Only root switch can be upgraded */
2589		if (tb_route(sw))
2590			return 0;
2591
2592		fallthrough;
2593	case 3:
2594	case 4:
2595		ret = tb_switch_set_uuid(sw);
2596		if (ret)
2597			return ret;
2598		break;
2599
2600	default:
2601		/*
2602		 * DMA port is the only thing available when the switch
2603		 * is in safe mode.
2604		 */
2605		if (!sw->safe_mode)
2606			return 0;
2607		break;
2608	}
2609
2610	if (sw->no_nvm_upgrade)
2611		return 0;
2612
2613	if (tb_switch_is_usb4(sw)) {
2614		ret = usb4_switch_nvm_authenticate_status(sw, &status);
2615		if (ret)
2616			return ret;
2617
2618		if (status) {
2619			tb_sw_info(sw, "switch flash authentication failed\n");
2620			nvm_set_auth_status(sw, status);
2621		}
2622
2623		return 0;
2624	}
2625
2626	/* Root switch DMA port requires running firmware */
2627	if (!tb_route(sw) && !tb_switch_is_icm(sw))
2628		return 0;
2629
2630	sw->dma_port = dma_port_alloc(sw);
2631	if (!sw->dma_port)
2632		return 0;
2633
2634	/*
2635	 * If there is status already set then authentication failed
2636	 * when the dma_port_flash_update_auth() returned. Power cycling
2637	 * is not needed (it was done already) so only thing we do here
2638	 * is to unblock runtime PM of the root port.
2639	 */
2640	nvm_get_auth_status(sw, &status);
2641	if (status) {
2642		if (!tb_route(sw))
2643			nvm_authenticate_complete_dma_port(sw);
2644		return 0;
2645	}
2646
2647	/*
2648	 * Check status of the previous flash authentication. If there
2649	 * is one we need to power cycle the switch in any case to make
2650	 * it functional again.
2651	 */
2652	ret = dma_port_flash_update_auth_status(sw->dma_port, &status);
2653	if (ret <= 0)
2654		return ret;
2655
2656	/* Now we can allow root port to suspend again */
2657	if (!tb_route(sw))
2658		nvm_authenticate_complete_dma_port(sw);
2659
2660	if (status) {
2661		tb_sw_info(sw, "switch flash authentication failed\n");
 
2662		nvm_set_auth_status(sw, status);
2663	}
2664
2665	tb_sw_info(sw, "power cycling the switch now\n");
2666	dma_port_power_cycle(sw->dma_port);
2667
2668	/*
2669	 * We return error here which causes the switch adding failure.
2670	 * It should appear back after power cycle is complete.
2671	 */
2672	return -ESHUTDOWN;
2673}
2674
2675static void tb_switch_default_link_ports(struct tb_switch *sw)
2676{
2677	int i;
2678
2679	for (i = 1; i <= sw->config.max_port_number; i++) {
2680		struct tb_port *port = &sw->ports[i];
2681		struct tb_port *subordinate;
2682
2683		if (!tb_port_is_null(port))
2684			continue;
2685
2686		/* Check for the subordinate port */
2687		if (i == sw->config.max_port_number ||
2688		    !tb_port_is_null(&sw->ports[i + 1]))
2689			continue;
2690
2691		/* Link them if not already done so (by DROM) */
2692		subordinate = &sw->ports[i + 1];
2693		if (!port->dual_link_port && !subordinate->dual_link_port) {
2694			port->link_nr = 0;
2695			port->dual_link_port = subordinate;
2696			subordinate->link_nr = 1;
2697			subordinate->dual_link_port = port;
2698
2699			tb_sw_dbg(sw, "linked ports %d <-> %d\n",
2700				  port->port, subordinate->port);
2701		}
2702	}
2703}
2704
2705static bool tb_switch_lane_bonding_possible(struct tb_switch *sw)
2706{
2707	const struct tb_port *up = tb_upstream_port(sw);
2708
2709	if (!up->dual_link_port || !up->dual_link_port->remote)
2710		return false;
2711
2712	if (tb_switch_is_usb4(sw))
2713		return usb4_switch_lane_bonding_possible(sw);
2714	return tb_lc_lane_bonding_possible(sw);
2715}
2716
2717static int tb_switch_update_link_attributes(struct tb_switch *sw)
2718{
2719	struct tb_port *up;
2720	bool change = false;
2721	int ret;
2722
2723	if (!tb_route(sw) || tb_switch_is_icm(sw))
2724		return 0;
2725
2726	up = tb_upstream_port(sw);
2727
2728	ret = tb_port_get_link_speed(up);
2729	if (ret < 0)
2730		return ret;
2731	if (sw->link_speed != ret)
2732		change = true;
2733	sw->link_speed = ret;
2734
2735	ret = tb_port_get_link_width(up);
2736	if (ret < 0)
2737		return ret;
2738	if (sw->link_width != ret)
2739		change = true;
2740	sw->link_width = ret;
2741
2742	/* Notify userspace that there is possible link attribute change */
2743	if (device_is_registered(&sw->dev) && change)
2744		kobject_uevent(&sw->dev.kobj, KOBJ_CHANGE);
2745
2746	return 0;
2747}
2748
2749/* Must be called after tb_switch_update_link_attributes() */
2750static void tb_switch_link_init(struct tb_switch *sw)
2751{
2752	struct tb_port *up, *down;
2753	bool bonded;
2754
2755	if (!tb_route(sw) || tb_switch_is_icm(sw))
2756		return;
2757
2758	tb_sw_dbg(sw, "current link speed %u.0 Gb/s\n", sw->link_speed);
2759	tb_sw_dbg(sw, "current link width %s\n", tb_width_name(sw->link_width));
2760
2761	bonded = sw->link_width >= TB_LINK_WIDTH_DUAL;
2762
2763	/*
2764	 * Gen 4 links come up as bonded so update the port structures
2765	 * accordingly.
2766	 */
2767	up = tb_upstream_port(sw);
2768	down = tb_switch_downstream_port(sw);
2769
2770	up->bonded = bonded;
2771	if (up->dual_link_port)
2772		up->dual_link_port->bonded = bonded;
2773	tb_port_update_credits(up);
2774
2775	down->bonded = bonded;
2776	if (down->dual_link_port)
2777		down->dual_link_port->bonded = bonded;
2778	tb_port_update_credits(down);
2779
2780	if (tb_port_get_link_generation(up) < 4)
2781		return;
2782
2783	/*
2784	 * Set the Gen 4 preferred link width. This is what the router
2785	 * prefers when the link is brought up. If the router does not
2786	 * support asymmetric link configuration, this also will be set
2787	 * to TB_LINK_WIDTH_DUAL.
2788	 */
2789	sw->preferred_link_width = sw->link_width;
2790	tb_sw_dbg(sw, "preferred link width %s\n",
2791		  tb_width_name(sw->preferred_link_width));
2792}
2793
2794/**
2795 * tb_switch_lane_bonding_enable() - Enable lane bonding
2796 * @sw: Switch to enable lane bonding
2797 *
2798 * Connection manager can call this function to enable lane bonding of a
2799 * switch. If conditions are correct and both switches support the feature,
2800 * lanes are bonded. It is safe to call this to any switch.
2801 */
2802static int tb_switch_lane_bonding_enable(struct tb_switch *sw)
2803{
2804	struct tb_port *up, *down;
2805	unsigned int width;
2806	int ret;
2807
2808	if (!tb_switch_lane_bonding_possible(sw))
2809		return 0;
2810
2811	up = tb_upstream_port(sw);
2812	down = tb_switch_downstream_port(sw);
2813
2814	if (!tb_port_width_supported(up, TB_LINK_WIDTH_DUAL) ||
2815	    !tb_port_width_supported(down, TB_LINK_WIDTH_DUAL))
2816		return 0;
2817
2818	/*
2819	 * Both lanes need to be in CL0. Here we assume lane 0 already be in
2820	 * CL0 and check just for lane 1.
2821	 */
2822	if (tb_wait_for_port(down->dual_link_port, false) <= 0)
2823		return -ENOTCONN;
2824
2825	ret = tb_port_lane_bonding_enable(up);
2826	if (ret) {
2827		tb_port_warn(up, "failed to enable lane bonding\n");
2828		return ret;
2829	}
2830
2831	ret = tb_port_lane_bonding_enable(down);
2832	if (ret) {
2833		tb_port_warn(down, "failed to enable lane bonding\n");
2834		tb_port_lane_bonding_disable(up);
2835		return ret;
2836	}
2837
2838	/* Any of the widths are all bonded */
2839	width = TB_LINK_WIDTH_DUAL | TB_LINK_WIDTH_ASYM_TX |
2840		TB_LINK_WIDTH_ASYM_RX;
2841
2842	return tb_port_wait_for_link_width(down, width, 100);
2843}
2844
2845/**
2846 * tb_switch_lane_bonding_disable() - Disable lane bonding
2847 * @sw: Switch whose lane bonding to disable
2848 *
2849 * Disables lane bonding between @sw and parent. This can be called even
2850 * if lanes were not bonded originally.
2851 */
2852static int tb_switch_lane_bonding_disable(struct tb_switch *sw)
2853{
2854	struct tb_port *up, *down;
2855	int ret;
2856
2857	up = tb_upstream_port(sw);
2858	if (!up->bonded)
2859		return 0;
2860
2861	/*
2862	 * If the link is Gen 4 there is no way to switch the link to
2863	 * two single lane links so avoid that here. Also don't bother
2864	 * if the link is not up anymore (sw is unplugged).
2865	 */
2866	ret = tb_port_get_link_generation(up);
2867	if (ret < 0)
2868		return ret;
2869	if (ret >= 4)
2870		return -EOPNOTSUPP;
2871
2872	down = tb_switch_downstream_port(sw);
2873	tb_port_lane_bonding_disable(up);
2874	tb_port_lane_bonding_disable(down);
2875
2876	/*
2877	 * It is fine if we get other errors as the router might have
2878	 * been unplugged.
2879	 */
2880	return tb_port_wait_for_link_width(down, TB_LINK_WIDTH_SINGLE, 100);
2881}
2882
2883/* Note updating sw->link_width done in tb_switch_update_link_attributes() */
2884static int tb_switch_asym_enable(struct tb_switch *sw, enum tb_link_width width)
2885{
2886	struct tb_port *up, *down, *port;
2887	enum tb_link_width down_width;
2888	int ret;
2889
2890	up = tb_upstream_port(sw);
2891	down = tb_switch_downstream_port(sw);
2892
2893	if (width == TB_LINK_WIDTH_ASYM_TX) {
2894		down_width = TB_LINK_WIDTH_ASYM_RX;
2895		port = down;
2896	} else {
2897		down_width = TB_LINK_WIDTH_ASYM_TX;
2898		port = up;
2899	}
2900
2901	ret = tb_port_set_link_width(up, width);
2902	if (ret)
2903		return ret;
2904
2905	ret = tb_port_set_link_width(down, down_width);
2906	if (ret)
2907		return ret;
2908
2909	/*
2910	 * Initiate the change in the router that one of its TX lanes is
2911	 * changing to RX but do so only if there is an actual change.
2912	 */
2913	if (sw->link_width != width) {
2914		ret = usb4_port_asym_start(port);
2915		if (ret)
2916			return ret;
2917
2918		ret = tb_port_wait_for_link_width(up, width, 100);
2919		if (ret)
2920			return ret;
2921	}
2922
2923	return 0;
2924}
2925
2926/* Note updating sw->link_width done in tb_switch_update_link_attributes() */
2927static int tb_switch_asym_disable(struct tb_switch *sw)
2928{
2929	struct tb_port *up, *down;
2930	int ret;
2931
2932	up = tb_upstream_port(sw);
2933	down = tb_switch_downstream_port(sw);
2934
2935	ret = tb_port_set_link_width(up, TB_LINK_WIDTH_DUAL);
2936	if (ret)
2937		return ret;
2938
2939	ret = tb_port_set_link_width(down, TB_LINK_WIDTH_DUAL);
2940	if (ret)
2941		return ret;
2942
2943	/*
2944	 * Initiate the change in the router that has three TX lanes and
2945	 * is changing one of its TX lanes to RX but only if there is a
2946	 * change in the link width.
2947	 */
2948	if (sw->link_width > TB_LINK_WIDTH_DUAL) {
2949		if (sw->link_width == TB_LINK_WIDTH_ASYM_TX)
2950			ret = usb4_port_asym_start(up);
2951		else
2952			ret = usb4_port_asym_start(down);
2953		if (ret)
2954			return ret;
2955
2956		ret = tb_port_wait_for_link_width(up, TB_LINK_WIDTH_DUAL, 100);
2957		if (ret)
2958			return ret;
2959	}
2960
2961	return 0;
2962}
2963
2964/**
2965 * tb_switch_set_link_width() - Configure router link width
2966 * @sw: Router to configure
2967 * @width: The new link width
2968 *
2969 * Set device router link width to @width from router upstream port
2970 * perspective. Supports also asymmetric links if the routers boths side
2971 * of the link supports it.
2972 *
2973 * Does nothing for host router.
2974 *
2975 * Returns %0 in case of success, negative errno otherwise.
2976 */
2977int tb_switch_set_link_width(struct tb_switch *sw, enum tb_link_width width)
2978{
2979	struct tb_port *up, *down;
2980	int ret = 0;
2981
2982	if (!tb_route(sw))
2983		return 0;
2984
2985	up = tb_upstream_port(sw);
2986	down = tb_switch_downstream_port(sw);
2987
2988	switch (width) {
2989	case TB_LINK_WIDTH_SINGLE:
2990		ret = tb_switch_lane_bonding_disable(sw);
2991		break;
2992
2993	case TB_LINK_WIDTH_DUAL:
2994		if (sw->link_width == TB_LINK_WIDTH_ASYM_TX ||
2995		    sw->link_width == TB_LINK_WIDTH_ASYM_RX) {
2996			ret = tb_switch_asym_disable(sw);
2997			if (ret)
2998				break;
2999		}
3000		ret = tb_switch_lane_bonding_enable(sw);
3001		break;
3002
3003	case TB_LINK_WIDTH_ASYM_TX:
3004	case TB_LINK_WIDTH_ASYM_RX:
3005		ret = tb_switch_asym_enable(sw, width);
3006		break;
3007	}
3008
3009	switch (ret) {
3010	case 0:
3011		break;
3012
3013	case -ETIMEDOUT:
3014		tb_sw_warn(sw, "timeout changing link width\n");
3015		return ret;
3016
3017	case -ENOTCONN:
3018	case -EOPNOTSUPP:
3019	case -ENODEV:
3020		return ret;
3021
3022	default:
3023		tb_sw_dbg(sw, "failed to change link width: %d\n", ret);
3024		return ret;
3025	}
3026
3027	tb_port_update_credits(down);
3028	tb_port_update_credits(up);
3029
3030	tb_switch_update_link_attributes(sw);
3031
3032	tb_sw_dbg(sw, "link width set to %s\n", tb_width_name(width));
3033	return ret;
3034}
3035
3036/**
3037 * tb_switch_configure_link() - Set link configured
3038 * @sw: Switch whose link is configured
3039 *
3040 * Sets the link upstream from @sw configured (from both ends) so that
3041 * it will not be disconnected when the domain exits sleep. Can be
3042 * called for any switch.
3043 *
3044 * It is recommended that this is called after lane bonding is enabled.
3045 *
3046 * Returns %0 on success and negative errno in case of error.
3047 */
3048int tb_switch_configure_link(struct tb_switch *sw)
3049{
3050	struct tb_port *up, *down;
3051	int ret;
3052
3053	if (!tb_route(sw) || tb_switch_is_icm(sw))
3054		return 0;
3055
3056	up = tb_upstream_port(sw);
3057	if (tb_switch_is_usb4(up->sw))
3058		ret = usb4_port_configure(up);
3059	else
3060		ret = tb_lc_configure_port(up);
3061	if (ret)
3062		return ret;
3063
3064	down = up->remote;
3065	if (tb_switch_is_usb4(down->sw))
3066		return usb4_port_configure(down);
3067	return tb_lc_configure_port(down);
3068}
3069
3070/**
3071 * tb_switch_unconfigure_link() - Unconfigure link
3072 * @sw: Switch whose link is unconfigured
3073 *
3074 * Sets the link unconfigured so the @sw will be disconnected if the
3075 * domain exists sleep.
3076 */
3077void tb_switch_unconfigure_link(struct tb_switch *sw)
3078{
3079	struct tb_port *up, *down;
3080
3081	if (sw->is_unplugged)
3082		return;
3083	if (!tb_route(sw) || tb_switch_is_icm(sw))
3084		return;
3085
3086	up = tb_upstream_port(sw);
3087	if (tb_switch_is_usb4(up->sw))
3088		usb4_port_unconfigure(up);
3089	else
3090		tb_lc_unconfigure_port(up);
3091
3092	down = up->remote;
3093	if (tb_switch_is_usb4(down->sw))
3094		usb4_port_unconfigure(down);
3095	else
3096		tb_lc_unconfigure_port(down);
3097}
3098
3099static void tb_switch_credits_init(struct tb_switch *sw)
3100{
3101	if (tb_switch_is_icm(sw))
3102		return;
3103	if (!tb_switch_is_usb4(sw))
3104		return;
3105	if (usb4_switch_credits_init(sw))
3106		tb_sw_info(sw, "failed to determine preferred buffer allocation, using defaults\n");
3107}
3108
3109static int tb_switch_port_hotplug_enable(struct tb_switch *sw)
3110{
3111	struct tb_port *port;
3112
3113	if (tb_switch_is_icm(sw))
3114		return 0;
3115
3116	tb_switch_for_each_port(sw, port) {
3117		int res;
3118
3119		if (!port->cap_usb4)
3120			continue;
3121
3122		res = usb4_port_hotplug_enable(port);
3123		if (res)
3124			return res;
3125	}
3126	return 0;
3127}
3128
3129/**
3130 * tb_switch_add() - Add a switch to the domain
3131 * @sw: Switch to add
3132 *
3133 * This is the last step in adding switch to the domain. It will read
3134 * identification information from DROM and initializes ports so that
3135 * they can be used to connect other switches. The switch will be
3136 * exposed to the userspace when this function successfully returns. To
3137 * remove and release the switch, call tb_switch_remove().
3138 *
3139 * Return: %0 in case of success and negative errno in case of failure
3140 */
3141int tb_switch_add(struct tb_switch *sw)
3142{
3143	int i, ret;
3144
3145	/*
3146	 * Initialize DMA control port now before we read DROM. Recent
3147	 * host controllers have more complete DROM on NVM that includes
3148	 * vendor and model identification strings which we then expose
3149	 * to the userspace. NVM can be accessed through DMA
3150	 * configuration based mailbox.
3151	 */
3152	ret = tb_switch_add_dma_port(sw);
3153	if (ret) {
3154		dev_err(&sw->dev, "failed to add DMA port\n");
3155		return ret;
3156	}
3157
3158	if (!sw->safe_mode) {
3159		tb_switch_credits_init(sw);
3160
3161		/* read drom */
3162		ret = tb_drom_read(sw);
3163		if (ret)
3164			dev_warn(&sw->dev, "reading DROM failed: %d\n", ret);
3165		tb_sw_dbg(sw, "uid: %#llx\n", sw->uid);
3166
3167		ret = tb_switch_set_uuid(sw);
3168		if (ret) {
3169			dev_err(&sw->dev, "failed to set UUID\n");
3170			return ret;
3171		}
 
 
 
3172
3173		for (i = 0; i <= sw->config.max_port_number; i++) {
3174			if (sw->ports[i].disabled) {
3175				tb_port_dbg(&sw->ports[i], "disabled by eeprom\n");
3176				continue;
3177			}
3178			ret = tb_init_port(&sw->ports[i]);
3179			if (ret) {
3180				dev_err(&sw->dev, "failed to initialize port %d\n", i);
3181				return ret;
3182			}
3183		}
3184
3185		tb_check_quirks(sw);
3186
3187		tb_switch_default_link_ports(sw);
3188
3189		ret = tb_switch_update_link_attributes(sw);
3190		if (ret)
3191			return ret;
3192
3193		tb_switch_link_init(sw);
3194
3195		ret = tb_switch_clx_init(sw);
3196		if (ret)
3197			return ret;
3198
3199		ret = tb_switch_tmu_init(sw);
3200		if (ret)
3201			return ret;
3202	}
3203
3204	ret = tb_switch_port_hotplug_enable(sw);
3205	if (ret)
3206		return ret;
3207
3208	ret = device_add(&sw->dev);
3209	if (ret) {
3210		dev_err(&sw->dev, "failed to add device: %d\n", ret);
3211		return ret;
3212	}
3213
3214	if (tb_route(sw)) {
3215		dev_info(&sw->dev, "new device found, vendor=%#x device=%#x\n",
3216			 sw->vendor, sw->device);
3217		if (sw->vendor_name && sw->device_name)
3218			dev_info(&sw->dev, "%s %s\n", sw->vendor_name,
3219				 sw->device_name);
3220	}
3221
3222	ret = usb4_switch_add_ports(sw);
3223	if (ret) {
3224		dev_err(&sw->dev, "failed to add USB4 ports\n");
3225		goto err_del;
3226	}
3227
3228	ret = tb_switch_nvm_add(sw);
3229	if (ret) {
3230		dev_err(&sw->dev, "failed to add NVM devices\n");
3231		goto err_ports;
3232	}
3233
3234	/*
3235	 * Thunderbolt routers do not generate wakeups themselves but
3236	 * they forward wakeups from tunneled protocols, so enable it
3237	 * here.
3238	 */
3239	device_init_wakeup(&sw->dev, true);
3240
3241	pm_runtime_set_active(&sw->dev);
3242	if (sw->rpm) {
3243		pm_runtime_set_autosuspend_delay(&sw->dev, TB_AUTOSUSPEND_DELAY);
3244		pm_runtime_use_autosuspend(&sw->dev);
3245		pm_runtime_mark_last_busy(&sw->dev);
3246		pm_runtime_enable(&sw->dev);
3247		pm_request_autosuspend(&sw->dev);
3248	}
3249
3250	tb_switch_debugfs_init(sw);
3251	return 0;
3252
3253err_ports:
3254	usb4_switch_remove_ports(sw);
3255err_del:
3256	device_del(&sw->dev);
3257
3258	return ret;
3259}
3260
3261/**
3262 * tb_switch_remove() - Remove and release a switch
3263 * @sw: Switch to remove
3264 *
3265 * This will remove the switch from the domain and release it after last
3266 * reference count drops to zero. If there are switches connected below
3267 * this switch, they will be removed as well.
3268 */
3269void tb_switch_remove(struct tb_switch *sw)
3270{
3271	struct tb_port *port;
3272
3273	tb_switch_debugfs_remove(sw);
3274
3275	if (sw->rpm) {
3276		pm_runtime_get_sync(&sw->dev);
3277		pm_runtime_disable(&sw->dev);
3278	}
3279
3280	/* port 0 is the switch itself and never has a remote */
3281	tb_switch_for_each_port(sw, port) {
3282		if (tb_port_has_remote(port)) {
3283			tb_switch_remove(port->remote->sw);
3284			port->remote = NULL;
3285		} else if (port->xdomain) {
3286			tb_xdomain_remove(port->xdomain);
3287			port->xdomain = NULL;
3288		}
3289
3290		/* Remove any downstream retimers */
3291		tb_retimer_remove_all(port);
3292	}
3293
3294	if (!sw->is_unplugged)
3295		tb_plug_events_active(sw, false);
3296
3297	tb_switch_nvm_remove(sw);
3298	usb4_switch_remove_ports(sw);
3299
3300	if (tb_route(sw))
3301		dev_info(&sw->dev, "device disconnected\n");
3302	device_unregister(&sw->dev);
3303}
3304
3305/**
3306 * tb_sw_set_unplugged() - set is_unplugged on switch and downstream switches
3307 * @sw: Router to mark unplugged
3308 */
3309void tb_sw_set_unplugged(struct tb_switch *sw)
3310{
3311	struct tb_port *port;
3312
3313	if (sw == sw->tb->root_switch) {
3314		tb_sw_WARN(sw, "cannot unplug root switch\n");
3315		return;
3316	}
3317	if (sw->is_unplugged) {
3318		tb_sw_WARN(sw, "is_unplugged already set\n");
3319		return;
3320	}
3321	sw->is_unplugged = true;
3322	tb_switch_for_each_port(sw, port) {
3323		if (tb_port_has_remote(port))
3324			tb_sw_set_unplugged(port->remote->sw);
3325		else if (port->xdomain)
3326			port->xdomain->is_unplugged = true;
3327	}
3328}
3329
3330static int tb_switch_set_wake(struct tb_switch *sw, unsigned int flags)
3331{
3332	if (flags)
3333		tb_sw_dbg(sw, "enabling wakeup: %#x\n", flags);
3334	else
3335		tb_sw_dbg(sw, "disabling wakeup\n");
3336
3337	if (tb_switch_is_usb4(sw))
3338		return usb4_switch_set_wake(sw, flags);
3339	return tb_lc_set_wake(sw, flags);
3340}
3341
3342int tb_switch_resume(struct tb_switch *sw)
3343{
3344	struct tb_port *port;
3345	int err;
3346
3347	tb_sw_dbg(sw, "resuming switch\n");
3348
3349	/*
3350	 * Check for UID of the connected switches except for root
3351	 * switch which we assume cannot be removed.
3352	 */
3353	if (tb_route(sw)) {
3354		u64 uid;
3355
3356		/*
3357		 * Check first that we can still read the switch config
3358		 * space. It may be that there is now another domain
3359		 * connected.
3360		 */
3361		err = tb_cfg_get_upstream_port(sw->tb->ctl, tb_route(sw));
3362		if (err < 0) {
3363			tb_sw_info(sw, "switch not present anymore\n");
3364			return err;
3365		}
3366
3367		/* We don't have any way to confirm this was the same device */
3368		if (!sw->uid)
3369			return -ENODEV;
3370
3371		if (tb_switch_is_usb4(sw))
3372			err = usb4_switch_read_uid(sw, &uid);
3373		else
3374			err = tb_drom_read_uid_only(sw, &uid);
3375		if (err) {
3376			tb_sw_warn(sw, "uid read failed\n");
3377			return err;
3378		}
3379		if (sw->uid != uid) {
3380			tb_sw_info(sw,
3381				"changed while suspended (uid %#llx -> %#llx)\n",
3382				sw->uid, uid);
3383			return -ENODEV;
3384		}
3385	}
3386
3387	err = tb_switch_configure(sw);
 
3388	if (err)
3389		return err;
3390
3391	/* Disable wakes */
3392	tb_switch_set_wake(sw, 0);
3393
3394	err = tb_switch_tmu_init(sw);
3395	if (err)
3396		return err;
3397
3398	/* check for surviving downstream switches */
3399	tb_switch_for_each_port(sw, port) {
3400		if (!tb_port_is_null(port))
 
3401			continue;
3402
3403		if (!tb_port_resume(port))
3404			continue;
3405
3406		if (tb_wait_for_port(port, true) <= 0) {
3407			tb_port_warn(port,
3408				     "lost during suspend, disconnecting\n");
3409			if (tb_port_has_remote(port))
3410				tb_sw_set_unplugged(port->remote->sw);
3411			else if (port->xdomain)
3412				port->xdomain->is_unplugged = true;
3413		} else {
3414			/*
3415			 * Always unlock the port so the downstream
3416			 * switch/domain is accessible.
3417			 */
3418			if (tb_port_unlock(port))
3419				tb_port_warn(port, "failed to unlock port\n");
3420			if (port->remote && tb_switch_resume(port->remote->sw)) {
3421				tb_port_warn(port,
3422					     "lost during suspend, disconnecting\n");
3423				tb_sw_set_unplugged(port->remote->sw);
3424			}
3425		}
3426	}
3427	return 0;
3428}
3429
3430/**
3431 * tb_switch_suspend() - Put a switch to sleep
3432 * @sw: Switch to suspend
3433 * @runtime: Is this runtime suspend or system sleep
3434 *
3435 * Suspends router and all its children. Enables wakes according to
3436 * value of @runtime and then sets sleep bit for the router. If @sw is
3437 * host router the domain is ready to go to sleep once this function
3438 * returns.
3439 */
3440void tb_switch_suspend(struct tb_switch *sw, bool runtime)
3441{
3442	unsigned int flags = 0;
3443	struct tb_port *port;
3444	int err;
3445
3446	tb_sw_dbg(sw, "suspending switch\n");
3447
3448	/*
3449	 * Actually only needed for Titan Ridge but for simplicity can be
3450	 * done for USB4 device too as CLx is re-enabled at resume.
3451	 */
3452	tb_switch_clx_disable(sw);
3453
3454	err = tb_plug_events_active(sw, false);
3455	if (err)
3456		return;
3457
3458	tb_switch_for_each_port(sw, port) {
3459		if (tb_port_has_remote(port))
3460			tb_switch_suspend(port->remote->sw, runtime);
3461	}
3462
3463	if (runtime) {
3464		/* Trigger wake when something is plugged in/out */
3465		flags |= TB_WAKE_ON_CONNECT | TB_WAKE_ON_DISCONNECT;
3466		flags |= TB_WAKE_ON_USB4;
3467		flags |= TB_WAKE_ON_USB3 | TB_WAKE_ON_PCIE | TB_WAKE_ON_DP;
3468	} else if (device_may_wakeup(&sw->dev)) {
3469		flags |= TB_WAKE_ON_USB4 | TB_WAKE_ON_USB3 | TB_WAKE_ON_PCIE;
3470	}
3471
3472	tb_switch_set_wake(sw, flags);
3473
3474	if (tb_switch_is_usb4(sw))
3475		usb4_switch_set_sleep(sw);
3476	else
3477		tb_lc_set_sleep(sw);
3478}
3479
3480/**
3481 * tb_switch_query_dp_resource() - Query availability of DP resource
3482 * @sw: Switch whose DP resource is queried
3483 * @in: DP IN port
3484 *
3485 * Queries availability of DP resource for DP tunneling using switch
3486 * specific means. Returns %true if resource is available.
3487 */
3488bool tb_switch_query_dp_resource(struct tb_switch *sw, struct tb_port *in)
3489{
3490	if (tb_switch_is_usb4(sw))
3491		return usb4_switch_query_dp_resource(sw, in);
3492	return tb_lc_dp_sink_query(sw, in);
3493}
3494
3495/**
3496 * tb_switch_alloc_dp_resource() - Allocate available DP resource
3497 * @sw: Switch whose DP resource is allocated
3498 * @in: DP IN port
3499 *
3500 * Allocates DP resource for DP tunneling. The resource must be
3501 * available for this to succeed (see tb_switch_query_dp_resource()).
3502 * Returns %0 in success and negative errno otherwise.
3503 */
3504int tb_switch_alloc_dp_resource(struct tb_switch *sw, struct tb_port *in)
3505{
3506	int ret;
3507
3508	if (tb_switch_is_usb4(sw))
3509		ret = usb4_switch_alloc_dp_resource(sw, in);
3510	else
3511		ret = tb_lc_dp_sink_alloc(sw, in);
3512
3513	if (ret)
3514		tb_sw_warn(sw, "failed to allocate DP resource for port %d\n",
3515			   in->port);
3516	else
3517		tb_sw_dbg(sw, "allocated DP resource for port %d\n", in->port);
3518
3519	return ret;
3520}
3521
3522/**
3523 * tb_switch_dealloc_dp_resource() - De-allocate DP resource
3524 * @sw: Switch whose DP resource is de-allocated
3525 * @in: DP IN port
3526 *
3527 * De-allocates DP resource that was previously allocated for DP
3528 * tunneling.
3529 */
3530void tb_switch_dealloc_dp_resource(struct tb_switch *sw, struct tb_port *in)
3531{
3532	int ret;
3533
3534	if (tb_switch_is_usb4(sw))
3535		ret = usb4_switch_dealloc_dp_resource(sw, in);
3536	else
3537		ret = tb_lc_dp_sink_dealloc(sw, in);
3538
3539	if (ret)
3540		tb_sw_warn(sw, "failed to de-allocate DP resource for port %d\n",
3541			   in->port);
3542	else
3543		tb_sw_dbg(sw, "released DP resource for port %d\n", in->port);
3544}
3545
3546struct tb_sw_lookup {
3547	struct tb *tb;
3548	u8 link;
3549	u8 depth;
3550	const uuid_t *uuid;
3551	u64 route;
3552};
3553
3554static int tb_switch_match(struct device *dev, const void *data)
3555{
3556	struct tb_switch *sw = tb_to_switch(dev);
3557	const struct tb_sw_lookup *lookup = data;
3558
3559	if (!sw)
3560		return 0;
3561	if (sw->tb != lookup->tb)
3562		return 0;
3563
3564	if (lookup->uuid)
3565		return !memcmp(sw->uuid, lookup->uuid, sizeof(*lookup->uuid));
3566
3567	if (lookup->route) {
3568		return sw->config.route_lo == lower_32_bits(lookup->route) &&
3569		       sw->config.route_hi == upper_32_bits(lookup->route);
3570	}
3571
3572	/* Root switch is matched only by depth */
3573	if (!lookup->depth)
3574		return !sw->depth;
3575
3576	return sw->link == lookup->link && sw->depth == lookup->depth;
3577}
3578
3579/**
3580 * tb_switch_find_by_link_depth() - Find switch by link and depth
3581 * @tb: Domain the switch belongs
3582 * @link: Link number the switch is connected
3583 * @depth: Depth of the switch in link
3584 *
3585 * Returned switch has reference count increased so the caller needs to
3586 * call tb_switch_put() when done with the switch.
3587 */
3588struct tb_switch *tb_switch_find_by_link_depth(struct tb *tb, u8 link, u8 depth)
3589{
3590	struct tb_sw_lookup lookup;
3591	struct device *dev;
3592
3593	memset(&lookup, 0, sizeof(lookup));
3594	lookup.tb = tb;
3595	lookup.link = link;
3596	lookup.depth = depth;
3597
3598	dev = bus_find_device(&tb_bus_type, NULL, &lookup, tb_switch_match);
3599	if (dev)
3600		return tb_to_switch(dev);
3601
3602	return NULL;
3603}
3604
3605/**
3606 * tb_switch_find_by_uuid() - Find switch by UUID
3607 * @tb: Domain the switch belongs
3608 * @uuid: UUID to look for
3609 *
3610 * Returned switch has reference count increased so the caller needs to
3611 * call tb_switch_put() when done with the switch.
3612 */
3613struct tb_switch *tb_switch_find_by_uuid(struct tb *tb, const uuid_t *uuid)
3614{
3615	struct tb_sw_lookup lookup;
3616	struct device *dev;
3617
3618	memset(&lookup, 0, sizeof(lookup));
3619	lookup.tb = tb;
3620	lookup.uuid = uuid;
3621
3622	dev = bus_find_device(&tb_bus_type, NULL, &lookup, tb_switch_match);
3623	if (dev)
3624		return tb_to_switch(dev);
3625
3626	return NULL;
3627}
3628
3629/**
3630 * tb_switch_find_by_route() - Find switch by route string
3631 * @tb: Domain the switch belongs
3632 * @route: Route string to look for
3633 *
3634 * Returned switch has reference count increased so the caller needs to
3635 * call tb_switch_put() when done with the switch.
3636 */
3637struct tb_switch *tb_switch_find_by_route(struct tb *tb, u64 route)
3638{
3639	struct tb_sw_lookup lookup;
3640	struct device *dev;
3641
3642	if (!route)
3643		return tb_switch_get(tb->root_switch);
3644
3645	memset(&lookup, 0, sizeof(lookup));
3646	lookup.tb = tb;
3647	lookup.route = route;
3648
3649	dev = bus_find_device(&tb_bus_type, NULL, &lookup, tb_switch_match);
3650	if (dev)
3651		return tb_to_switch(dev);
3652
3653	return NULL;
3654}
3655
3656/**
3657 * tb_switch_find_port() - return the first port of @type on @sw or NULL
3658 * @sw: Switch to find the port from
3659 * @type: Port type to look for
3660 */
3661struct tb_port *tb_switch_find_port(struct tb_switch *sw,
3662				    enum tb_port_type type)
3663{
3664	struct tb_port *port;
3665
3666	tb_switch_for_each_port(sw, port) {
3667		if (port->config.type == type)
3668			return port;
3669	}
3670
3671	return NULL;
3672}
3673
3674/*
3675 * Can be used for read/write a specified PCIe bridge for any Thunderbolt 3
3676 * device. For now used only for Titan Ridge.
3677 */
3678static int tb_switch_pcie_bridge_write(struct tb_switch *sw, unsigned int bridge,
3679				       unsigned int pcie_offset, u32 value)
3680{
3681	u32 offset, command, val;
3682	int ret;
3683
3684	if (sw->generation != 3)
3685		return -EOPNOTSUPP;
3686
3687	offset = sw->cap_plug_events + TB_PLUG_EVENTS_PCIE_WR_DATA;
3688	ret = tb_sw_write(sw, &value, TB_CFG_SWITCH, offset, 1);
3689	if (ret)
3690		return ret;
3691
3692	command = pcie_offset & TB_PLUG_EVENTS_PCIE_CMD_DW_OFFSET_MASK;
3693	command |= BIT(bridge + TB_PLUG_EVENTS_PCIE_CMD_BR_SHIFT);
3694	command |= TB_PLUG_EVENTS_PCIE_CMD_RD_WR_MASK;
3695	command |= TB_PLUG_EVENTS_PCIE_CMD_COMMAND_VAL
3696			<< TB_PLUG_EVENTS_PCIE_CMD_COMMAND_SHIFT;
3697	command |= TB_PLUG_EVENTS_PCIE_CMD_REQ_ACK_MASK;
3698
3699	offset = sw->cap_plug_events + TB_PLUG_EVENTS_PCIE_CMD;
3700
3701	ret = tb_sw_write(sw, &command, TB_CFG_SWITCH, offset, 1);
3702	if (ret)
3703		return ret;
3704
3705	ret = tb_switch_wait_for_bit(sw, offset,
3706				     TB_PLUG_EVENTS_PCIE_CMD_REQ_ACK_MASK, 0, 100);
3707	if (ret)
3708		return ret;
3709
3710	ret = tb_sw_read(sw, &val, TB_CFG_SWITCH, offset, 1);
3711	if (ret)
3712		return ret;
3713
3714	if (val & TB_PLUG_EVENTS_PCIE_CMD_TIMEOUT_MASK)
3715		return -ETIMEDOUT;
3716
3717	return 0;
3718}
3719
3720/**
3721 * tb_switch_pcie_l1_enable() - Enable PCIe link to enter L1 state
3722 * @sw: Router to enable PCIe L1
3723 *
3724 * For Titan Ridge switch to enter CLx state, its PCIe bridges shall enable
3725 * entry to PCIe L1 state. Shall be called after the upstream PCIe tunnel
3726 * was configured. Due to Intel platforms limitation, shall be called only
3727 * for first hop switch.
3728 */
3729int tb_switch_pcie_l1_enable(struct tb_switch *sw)
3730{
3731	struct tb_switch *parent = tb_switch_parent(sw);
3732	int ret;
3733
3734	if (!tb_route(sw))
3735		return 0;
3736
3737	if (!tb_switch_is_titan_ridge(sw))
3738		return 0;
3739
3740	/* Enable PCIe L1 enable only for first hop router (depth = 1) */
3741	if (tb_route(parent))
3742		return 0;
3743
3744	/* Write to downstream PCIe bridge #5 aka Dn4 */
3745	ret = tb_switch_pcie_bridge_write(sw, 5, 0x143, 0x0c7806b1);
3746	if (ret)
3747		return ret;
3748
3749	/* Write to Upstream PCIe bridge #0 aka Up0 */
3750	return tb_switch_pcie_bridge_write(sw, 0, 0x143, 0x0c5806b1);
3751}
3752
3753/**
3754 * tb_switch_xhci_connect() - Connect internal xHCI
3755 * @sw: Router whose xHCI to connect
3756 *
3757 * Can be called to any router. For Alpine Ridge and Titan Ridge
3758 * performs special flows that bring the xHCI functional for any device
3759 * connected to the type-C port. Call only after PCIe tunnel has been
3760 * established. The function only does the connect if not done already
3761 * so can be called several times for the same router.
3762 */
3763int tb_switch_xhci_connect(struct tb_switch *sw)
3764{
3765	struct tb_port *port1, *port3;
3766	int ret;
3767
3768	if (sw->generation != 3)
3769		return 0;
3770
3771	port1 = &sw->ports[1];
3772	port3 = &sw->ports[3];
3773
3774	if (tb_switch_is_alpine_ridge(sw)) {
3775		bool usb_port1, usb_port3, xhci_port1, xhci_port3;
3776
3777		usb_port1 = tb_lc_is_usb_plugged(port1);
3778		usb_port3 = tb_lc_is_usb_plugged(port3);
3779		xhci_port1 = tb_lc_is_xhci_connected(port1);
3780		xhci_port3 = tb_lc_is_xhci_connected(port3);
3781
3782		/* Figure out correct USB port to connect */
3783		if (usb_port1 && !xhci_port1) {
3784			ret = tb_lc_xhci_connect(port1);
3785			if (ret)
3786				return ret;
3787		}
3788		if (usb_port3 && !xhci_port3)
3789			return tb_lc_xhci_connect(port3);
3790	} else if (tb_switch_is_titan_ridge(sw)) {
3791		ret = tb_lc_xhci_connect(port1);
3792		if (ret)
3793			return ret;
3794		return tb_lc_xhci_connect(port3);
3795	}
3796
3797	return 0;
3798}
3799
3800/**
3801 * tb_switch_xhci_disconnect() - Disconnect internal xHCI
3802 * @sw: Router whose xHCI to disconnect
3803 *
3804 * The opposite of tb_switch_xhci_connect(). Disconnects xHCI on both
3805 * ports.
3806 */
3807void tb_switch_xhci_disconnect(struct tb_switch *sw)
3808{
3809	if (sw->generation == 3) {
3810		struct tb_port *port1 = &sw->ports[1];
3811		struct tb_port *port3 = &sw->ports[3];
3812
3813		tb_lc_xhci_disconnect(port1);
3814		tb_port_dbg(port1, "disconnected xHCI\n");
3815		tb_lc_xhci_disconnect(port3);
3816		tb_port_dbg(port3, "disconnected xHCI\n");
3817	}
3818}