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