Loading...
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * KUnit tests
4 *
5 * Copyright (C) 2020, Intel Corporation
6 * Author: Mika Westerberg <mika.westerberg@linux.intel.com>
7 */
8
9#include <kunit/test.h>
10#include <linux/idr.h>
11
12#include "tb.h"
13#include "tunnel.h"
14
15static int __ida_init(struct kunit_resource *res, void *context)
16{
17 struct ida *ida = context;
18
19 ida_init(ida);
20 res->data = ida;
21 return 0;
22}
23
24static void __ida_destroy(struct kunit_resource *res)
25{
26 struct ida *ida = res->data;
27
28 ida_destroy(ida);
29}
30
31static void kunit_ida_init(struct kunit *test, struct ida *ida)
32{
33 kunit_alloc_resource(test, __ida_init, __ida_destroy, GFP_KERNEL, ida);
34}
35
36static struct tb_switch *alloc_switch(struct kunit *test, u64 route,
37 u8 upstream_port, u8 max_port_number)
38{
39 struct tb_switch *sw;
40 size_t size;
41 int i;
42
43 sw = kunit_kzalloc(test, sizeof(*sw), GFP_KERNEL);
44 if (!sw)
45 return NULL;
46
47 sw->config.upstream_port_number = upstream_port;
48 sw->config.depth = tb_route_length(route);
49 sw->config.route_hi = upper_32_bits(route);
50 sw->config.route_lo = lower_32_bits(route);
51 sw->config.enabled = 0;
52 sw->config.max_port_number = max_port_number;
53
54 size = (sw->config.max_port_number + 1) * sizeof(*sw->ports);
55 sw->ports = kunit_kzalloc(test, size, GFP_KERNEL);
56 if (!sw->ports)
57 return NULL;
58
59 for (i = 0; i <= sw->config.max_port_number; i++) {
60 sw->ports[i].sw = sw;
61 sw->ports[i].port = i;
62 sw->ports[i].config.port_number = i;
63 if (i) {
64 kunit_ida_init(test, &sw->ports[i].in_hopids);
65 kunit_ida_init(test, &sw->ports[i].out_hopids);
66 }
67 }
68
69 return sw;
70}
71
72static struct tb_switch *alloc_host(struct kunit *test)
73{
74 struct tb_switch *sw;
75
76 sw = alloc_switch(test, 0, 7, 13);
77 if (!sw)
78 return NULL;
79
80 sw->config.vendor_id = 0x8086;
81 sw->config.device_id = 0x9a1b;
82
83 sw->ports[0].config.type = TB_TYPE_PORT;
84 sw->ports[0].config.max_in_hop_id = 7;
85 sw->ports[0].config.max_out_hop_id = 7;
86
87 sw->ports[1].config.type = TB_TYPE_PORT;
88 sw->ports[1].config.max_in_hop_id = 19;
89 sw->ports[1].config.max_out_hop_id = 19;
90 sw->ports[1].total_credits = 60;
91 sw->ports[1].ctl_credits = 2;
92 sw->ports[1].dual_link_port = &sw->ports[2];
93
94 sw->ports[2].config.type = TB_TYPE_PORT;
95 sw->ports[2].config.max_in_hop_id = 19;
96 sw->ports[2].config.max_out_hop_id = 19;
97 sw->ports[2].total_credits = 60;
98 sw->ports[2].ctl_credits = 2;
99 sw->ports[2].dual_link_port = &sw->ports[1];
100 sw->ports[2].link_nr = 1;
101
102 sw->ports[3].config.type = TB_TYPE_PORT;
103 sw->ports[3].config.max_in_hop_id = 19;
104 sw->ports[3].config.max_out_hop_id = 19;
105 sw->ports[3].total_credits = 60;
106 sw->ports[3].ctl_credits = 2;
107 sw->ports[3].dual_link_port = &sw->ports[4];
108
109 sw->ports[4].config.type = TB_TYPE_PORT;
110 sw->ports[4].config.max_in_hop_id = 19;
111 sw->ports[4].config.max_out_hop_id = 19;
112 sw->ports[4].total_credits = 60;
113 sw->ports[4].ctl_credits = 2;
114 sw->ports[4].dual_link_port = &sw->ports[3];
115 sw->ports[4].link_nr = 1;
116
117 sw->ports[5].config.type = TB_TYPE_DP_HDMI_IN;
118 sw->ports[5].config.max_in_hop_id = 9;
119 sw->ports[5].config.max_out_hop_id = 9;
120 sw->ports[5].cap_adap = -1;
121
122 sw->ports[6].config.type = TB_TYPE_DP_HDMI_IN;
123 sw->ports[6].config.max_in_hop_id = 9;
124 sw->ports[6].config.max_out_hop_id = 9;
125 sw->ports[6].cap_adap = -1;
126
127 sw->ports[7].config.type = TB_TYPE_NHI;
128 sw->ports[7].config.max_in_hop_id = 11;
129 sw->ports[7].config.max_out_hop_id = 11;
130 sw->ports[7].config.nfc_credits = 0x41800000;
131
132 sw->ports[8].config.type = TB_TYPE_PCIE_DOWN;
133 sw->ports[8].config.max_in_hop_id = 8;
134 sw->ports[8].config.max_out_hop_id = 8;
135
136 sw->ports[9].config.type = TB_TYPE_PCIE_DOWN;
137 sw->ports[9].config.max_in_hop_id = 8;
138 sw->ports[9].config.max_out_hop_id = 8;
139
140 sw->ports[10].disabled = true;
141 sw->ports[11].disabled = true;
142
143 sw->ports[12].config.type = TB_TYPE_USB3_DOWN;
144 sw->ports[12].config.max_in_hop_id = 8;
145 sw->ports[12].config.max_out_hop_id = 8;
146
147 sw->ports[13].config.type = TB_TYPE_USB3_DOWN;
148 sw->ports[13].config.max_in_hop_id = 8;
149 sw->ports[13].config.max_out_hop_id = 8;
150
151 return sw;
152}
153
154static struct tb_switch *alloc_host_usb4(struct kunit *test)
155{
156 struct tb_switch *sw;
157
158 sw = alloc_host(test);
159 if (!sw)
160 return NULL;
161
162 sw->generation = 4;
163 sw->credit_allocation = true;
164 sw->max_usb3_credits = 32;
165 sw->min_dp_aux_credits = 1;
166 sw->min_dp_main_credits = 0;
167 sw->max_pcie_credits = 64;
168 sw->max_dma_credits = 14;
169
170 return sw;
171}
172
173static struct tb_switch *alloc_host_br(struct kunit *test)
174{
175 struct tb_switch *sw;
176
177 sw = alloc_host_usb4(test);
178 if (!sw)
179 return NULL;
180
181 sw->ports[10].config.type = TB_TYPE_DP_HDMI_IN;
182 sw->ports[10].config.max_in_hop_id = 9;
183 sw->ports[10].config.max_out_hop_id = 9;
184 sw->ports[10].cap_adap = -1;
185 sw->ports[10].disabled = false;
186
187 return sw;
188}
189
190static struct tb_switch *alloc_dev_default(struct kunit *test,
191 struct tb_switch *parent,
192 u64 route, bool bonded)
193{
194 struct tb_port *port, *upstream_port;
195 struct tb_switch *sw;
196
197 sw = alloc_switch(test, route, 1, 19);
198 if (!sw)
199 return NULL;
200
201 sw->config.vendor_id = 0x8086;
202 sw->config.device_id = 0x15ef;
203
204 sw->ports[0].config.type = TB_TYPE_PORT;
205 sw->ports[0].config.max_in_hop_id = 8;
206 sw->ports[0].config.max_out_hop_id = 8;
207
208 sw->ports[1].config.type = TB_TYPE_PORT;
209 sw->ports[1].config.max_in_hop_id = 19;
210 sw->ports[1].config.max_out_hop_id = 19;
211 sw->ports[1].total_credits = 60;
212 sw->ports[1].ctl_credits = 2;
213 sw->ports[1].dual_link_port = &sw->ports[2];
214
215 sw->ports[2].config.type = TB_TYPE_PORT;
216 sw->ports[2].config.max_in_hop_id = 19;
217 sw->ports[2].config.max_out_hop_id = 19;
218 sw->ports[2].total_credits = 60;
219 sw->ports[2].ctl_credits = 2;
220 sw->ports[2].dual_link_port = &sw->ports[1];
221 sw->ports[2].link_nr = 1;
222
223 sw->ports[3].config.type = TB_TYPE_PORT;
224 sw->ports[3].config.max_in_hop_id = 19;
225 sw->ports[3].config.max_out_hop_id = 19;
226 sw->ports[3].total_credits = 60;
227 sw->ports[3].ctl_credits = 2;
228 sw->ports[3].dual_link_port = &sw->ports[4];
229
230 sw->ports[4].config.type = TB_TYPE_PORT;
231 sw->ports[4].config.max_in_hop_id = 19;
232 sw->ports[4].config.max_out_hop_id = 19;
233 sw->ports[4].total_credits = 60;
234 sw->ports[4].ctl_credits = 2;
235 sw->ports[4].dual_link_port = &sw->ports[3];
236 sw->ports[4].link_nr = 1;
237
238 sw->ports[5].config.type = TB_TYPE_PORT;
239 sw->ports[5].config.max_in_hop_id = 19;
240 sw->ports[5].config.max_out_hop_id = 19;
241 sw->ports[5].total_credits = 60;
242 sw->ports[5].ctl_credits = 2;
243 sw->ports[5].dual_link_port = &sw->ports[6];
244
245 sw->ports[6].config.type = TB_TYPE_PORT;
246 sw->ports[6].config.max_in_hop_id = 19;
247 sw->ports[6].config.max_out_hop_id = 19;
248 sw->ports[6].total_credits = 60;
249 sw->ports[6].ctl_credits = 2;
250 sw->ports[6].dual_link_port = &sw->ports[5];
251 sw->ports[6].link_nr = 1;
252
253 sw->ports[7].config.type = TB_TYPE_PORT;
254 sw->ports[7].config.max_in_hop_id = 19;
255 sw->ports[7].config.max_out_hop_id = 19;
256 sw->ports[7].total_credits = 60;
257 sw->ports[7].ctl_credits = 2;
258 sw->ports[7].dual_link_port = &sw->ports[8];
259
260 sw->ports[8].config.type = TB_TYPE_PORT;
261 sw->ports[8].config.max_in_hop_id = 19;
262 sw->ports[8].config.max_out_hop_id = 19;
263 sw->ports[8].total_credits = 60;
264 sw->ports[8].ctl_credits = 2;
265 sw->ports[8].dual_link_port = &sw->ports[7];
266 sw->ports[8].link_nr = 1;
267
268 sw->ports[9].config.type = TB_TYPE_PCIE_UP;
269 sw->ports[9].config.max_in_hop_id = 8;
270 sw->ports[9].config.max_out_hop_id = 8;
271
272 sw->ports[10].config.type = TB_TYPE_PCIE_DOWN;
273 sw->ports[10].config.max_in_hop_id = 8;
274 sw->ports[10].config.max_out_hop_id = 8;
275
276 sw->ports[11].config.type = TB_TYPE_PCIE_DOWN;
277 sw->ports[11].config.max_in_hop_id = 8;
278 sw->ports[11].config.max_out_hop_id = 8;
279
280 sw->ports[12].config.type = TB_TYPE_PCIE_DOWN;
281 sw->ports[12].config.max_in_hop_id = 8;
282 sw->ports[12].config.max_out_hop_id = 8;
283
284 sw->ports[13].config.type = TB_TYPE_DP_HDMI_OUT;
285 sw->ports[13].config.max_in_hop_id = 9;
286 sw->ports[13].config.max_out_hop_id = 9;
287 sw->ports[13].cap_adap = -1;
288
289 sw->ports[14].config.type = TB_TYPE_DP_HDMI_OUT;
290 sw->ports[14].config.max_in_hop_id = 9;
291 sw->ports[14].config.max_out_hop_id = 9;
292 sw->ports[14].cap_adap = -1;
293
294 sw->ports[15].disabled = true;
295
296 sw->ports[16].config.type = TB_TYPE_USB3_UP;
297 sw->ports[16].config.max_in_hop_id = 8;
298 sw->ports[16].config.max_out_hop_id = 8;
299
300 sw->ports[17].config.type = TB_TYPE_USB3_DOWN;
301 sw->ports[17].config.max_in_hop_id = 8;
302 sw->ports[17].config.max_out_hop_id = 8;
303
304 sw->ports[18].config.type = TB_TYPE_USB3_DOWN;
305 sw->ports[18].config.max_in_hop_id = 8;
306 sw->ports[18].config.max_out_hop_id = 8;
307
308 sw->ports[19].config.type = TB_TYPE_USB3_DOWN;
309 sw->ports[19].config.max_in_hop_id = 8;
310 sw->ports[19].config.max_out_hop_id = 8;
311
312 if (!parent)
313 return sw;
314
315 /* Link them */
316 upstream_port = tb_upstream_port(sw);
317 port = tb_port_at(route, parent);
318 port->remote = upstream_port;
319 upstream_port->remote = port;
320 if (port->dual_link_port && upstream_port->dual_link_port) {
321 port->dual_link_port->remote = upstream_port->dual_link_port;
322 upstream_port->dual_link_port->remote = port->dual_link_port;
323
324 if (bonded) {
325 /* Bonding is used */
326 port->bonded = true;
327 port->total_credits *= 2;
328 port->dual_link_port->bonded = true;
329 port->dual_link_port->total_credits = 0;
330 upstream_port->bonded = true;
331 upstream_port->total_credits *= 2;
332 upstream_port->dual_link_port->bonded = true;
333 upstream_port->dual_link_port->total_credits = 0;
334 }
335 }
336
337 return sw;
338}
339
340static struct tb_switch *alloc_dev_with_dpin(struct kunit *test,
341 struct tb_switch *parent,
342 u64 route, bool bonded)
343{
344 struct tb_switch *sw;
345
346 sw = alloc_dev_default(test, parent, route, bonded);
347 if (!sw)
348 return NULL;
349
350 sw->ports[13].config.type = TB_TYPE_DP_HDMI_IN;
351 sw->ports[13].config.max_in_hop_id = 9;
352 sw->ports[13].config.max_out_hop_id = 9;
353
354 sw->ports[14].config.type = TB_TYPE_DP_HDMI_IN;
355 sw->ports[14].config.max_in_hop_id = 9;
356 sw->ports[14].config.max_out_hop_id = 9;
357
358 return sw;
359}
360
361static struct tb_switch *alloc_dev_without_dp(struct kunit *test,
362 struct tb_switch *parent,
363 u64 route, bool bonded)
364{
365 struct tb_switch *sw;
366 int i;
367
368 sw = alloc_dev_default(test, parent, route, bonded);
369 if (!sw)
370 return NULL;
371 /*
372 * Device with:
373 * 2x USB4 Adapters (adapters 1,2 and 3,4),
374 * 1x PCIe Upstream (adapter 9),
375 * 1x PCIe Downstream (adapter 10),
376 * 1x USB3 Upstream (adapter 16),
377 * 1x USB3 Downstream (adapter 17)
378 */
379 for (i = 5; i <= 8; i++)
380 sw->ports[i].disabled = true;
381
382 for (i = 11; i <= 14; i++)
383 sw->ports[i].disabled = true;
384
385 sw->ports[13].cap_adap = 0;
386 sw->ports[14].cap_adap = 0;
387
388 for (i = 18; i <= 19; i++)
389 sw->ports[i].disabled = true;
390
391 sw->generation = 4;
392 sw->credit_allocation = true;
393 sw->max_usb3_credits = 109;
394 sw->min_dp_aux_credits = 0;
395 sw->min_dp_main_credits = 0;
396 sw->max_pcie_credits = 30;
397 sw->max_dma_credits = 1;
398
399 return sw;
400}
401
402static struct tb_switch *alloc_dev_usb4(struct kunit *test,
403 struct tb_switch *parent,
404 u64 route, bool bonded)
405{
406 struct tb_switch *sw;
407
408 sw = alloc_dev_default(test, parent, route, bonded);
409 if (!sw)
410 return NULL;
411
412 sw->generation = 4;
413 sw->credit_allocation = true;
414 sw->max_usb3_credits = 14;
415 sw->min_dp_aux_credits = 1;
416 sw->min_dp_main_credits = 18;
417 sw->max_pcie_credits = 32;
418 sw->max_dma_credits = 14;
419
420 return sw;
421}
422
423static void tb_test_path_basic(struct kunit *test)
424{
425 struct tb_port *src_port, *dst_port, *p;
426 struct tb_switch *host;
427
428 host = alloc_host(test);
429
430 src_port = &host->ports[5];
431 dst_port = src_port;
432
433 p = tb_next_port_on_path(src_port, dst_port, NULL);
434 KUNIT_EXPECT_PTR_EQ(test, p, dst_port);
435
436 p = tb_next_port_on_path(src_port, dst_port, p);
437 KUNIT_EXPECT_TRUE(test, !p);
438}
439
440static void tb_test_path_not_connected_walk(struct kunit *test)
441{
442 struct tb_port *src_port, *dst_port, *p;
443 struct tb_switch *host, *dev;
444
445 host = alloc_host(test);
446 /* No connection between host and dev */
447 dev = alloc_dev_default(test, NULL, 3, true);
448
449 src_port = &host->ports[12];
450 dst_port = &dev->ports[16];
451
452 p = tb_next_port_on_path(src_port, dst_port, NULL);
453 KUNIT_EXPECT_PTR_EQ(test, p, src_port);
454
455 p = tb_next_port_on_path(src_port, dst_port, p);
456 KUNIT_EXPECT_PTR_EQ(test, p, &host->ports[3]);
457
458 p = tb_next_port_on_path(src_port, dst_port, p);
459 KUNIT_EXPECT_TRUE(test, !p);
460
461 /* Other direction */
462
463 p = tb_next_port_on_path(dst_port, src_port, NULL);
464 KUNIT_EXPECT_PTR_EQ(test, p, dst_port);
465
466 p = tb_next_port_on_path(dst_port, src_port, p);
467 KUNIT_EXPECT_PTR_EQ(test, p, &dev->ports[1]);
468
469 p = tb_next_port_on_path(dst_port, src_port, p);
470 KUNIT_EXPECT_TRUE(test, !p);
471}
472
473struct port_expectation {
474 u64 route;
475 u8 port;
476 enum tb_port_type type;
477};
478
479static void tb_test_path_single_hop_walk(struct kunit *test)
480{
481 /*
482 * Walks from Host PCIe downstream port to Device #1 PCIe
483 * upstream port.
484 *
485 * [Host]
486 * 1 |
487 * 1 |
488 * [Device]
489 */
490 static const struct port_expectation test_data[] = {
491 { .route = 0x0, .port = 8, .type = TB_TYPE_PCIE_DOWN },
492 { .route = 0x0, .port = 1, .type = TB_TYPE_PORT },
493 { .route = 0x1, .port = 1, .type = TB_TYPE_PORT },
494 { .route = 0x1, .port = 9, .type = TB_TYPE_PCIE_UP },
495 };
496 struct tb_port *src_port, *dst_port, *p;
497 struct tb_switch *host, *dev;
498 int i;
499
500 host = alloc_host(test);
501 dev = alloc_dev_default(test, host, 1, true);
502
503 src_port = &host->ports[8];
504 dst_port = &dev->ports[9];
505
506 /* Walk both directions */
507
508 i = 0;
509 tb_for_each_port_on_path(src_port, dst_port, p) {
510 KUNIT_EXPECT_TRUE(test, i < ARRAY_SIZE(test_data));
511 KUNIT_EXPECT_EQ(test, tb_route(p->sw), test_data[i].route);
512 KUNIT_EXPECT_EQ(test, p->port, test_data[i].port);
513 KUNIT_EXPECT_EQ(test, (enum tb_port_type)p->config.type,
514 test_data[i].type);
515 i++;
516 }
517
518 KUNIT_EXPECT_EQ(test, i, ARRAY_SIZE(test_data));
519
520 i = ARRAY_SIZE(test_data) - 1;
521 tb_for_each_port_on_path(dst_port, src_port, p) {
522 KUNIT_EXPECT_TRUE(test, i < ARRAY_SIZE(test_data));
523 KUNIT_EXPECT_EQ(test, tb_route(p->sw), test_data[i].route);
524 KUNIT_EXPECT_EQ(test, p->port, test_data[i].port);
525 KUNIT_EXPECT_EQ(test, (enum tb_port_type)p->config.type,
526 test_data[i].type);
527 i--;
528 }
529
530 KUNIT_EXPECT_EQ(test, i, -1);
531}
532
533static void tb_test_path_daisy_chain_walk(struct kunit *test)
534{
535 /*
536 * Walks from Host DP IN to Device #2 DP OUT.
537 *
538 * [Host]
539 * 1 |
540 * 1 |
541 * [Device #1]
542 * 3 /
543 * 1 /
544 * [Device #2]
545 */
546 static const struct port_expectation test_data[] = {
547 { .route = 0x0, .port = 5, .type = TB_TYPE_DP_HDMI_IN },
548 { .route = 0x0, .port = 1, .type = TB_TYPE_PORT },
549 { .route = 0x1, .port = 1, .type = TB_TYPE_PORT },
550 { .route = 0x1, .port = 3, .type = TB_TYPE_PORT },
551 { .route = 0x301, .port = 1, .type = TB_TYPE_PORT },
552 { .route = 0x301, .port = 13, .type = TB_TYPE_DP_HDMI_OUT },
553 };
554 struct tb_port *src_port, *dst_port, *p;
555 struct tb_switch *host, *dev1, *dev2;
556 int i;
557
558 host = alloc_host(test);
559 dev1 = alloc_dev_default(test, host, 0x1, true);
560 dev2 = alloc_dev_default(test, dev1, 0x301, true);
561
562 src_port = &host->ports[5];
563 dst_port = &dev2->ports[13];
564
565 /* Walk both directions */
566
567 i = 0;
568 tb_for_each_port_on_path(src_port, dst_port, p) {
569 KUNIT_EXPECT_TRUE(test, i < ARRAY_SIZE(test_data));
570 KUNIT_EXPECT_EQ(test, tb_route(p->sw), test_data[i].route);
571 KUNIT_EXPECT_EQ(test, p->port, test_data[i].port);
572 KUNIT_EXPECT_EQ(test, (enum tb_port_type)p->config.type,
573 test_data[i].type);
574 i++;
575 }
576
577 KUNIT_EXPECT_EQ(test, i, ARRAY_SIZE(test_data));
578
579 i = ARRAY_SIZE(test_data) - 1;
580 tb_for_each_port_on_path(dst_port, src_port, p) {
581 KUNIT_EXPECT_TRUE(test, i < ARRAY_SIZE(test_data));
582 KUNIT_EXPECT_EQ(test, tb_route(p->sw), test_data[i].route);
583 KUNIT_EXPECT_EQ(test, p->port, test_data[i].port);
584 KUNIT_EXPECT_EQ(test, (enum tb_port_type)p->config.type,
585 test_data[i].type);
586 i--;
587 }
588
589 KUNIT_EXPECT_EQ(test, i, -1);
590}
591
592static void tb_test_path_simple_tree_walk(struct kunit *test)
593{
594 /*
595 * Walks from Host DP IN to Device #3 DP OUT.
596 *
597 * [Host]
598 * 1 |
599 * 1 |
600 * [Device #1]
601 * 3 / | 5 \ 7
602 * 1 / | \ 1
603 * [Device #2] | [Device #4]
604 * | 1
605 * [Device #3]
606 */
607 static const struct port_expectation test_data[] = {
608 { .route = 0x0, .port = 5, .type = TB_TYPE_DP_HDMI_IN },
609 { .route = 0x0, .port = 1, .type = TB_TYPE_PORT },
610 { .route = 0x1, .port = 1, .type = TB_TYPE_PORT },
611 { .route = 0x1, .port = 5, .type = TB_TYPE_PORT },
612 { .route = 0x501, .port = 1, .type = TB_TYPE_PORT },
613 { .route = 0x501, .port = 13, .type = TB_TYPE_DP_HDMI_OUT },
614 };
615 struct tb_port *src_port, *dst_port, *p;
616 struct tb_switch *host, *dev1, *dev3;
617 int i;
618
619 host = alloc_host(test);
620 dev1 = alloc_dev_default(test, host, 0x1, true);
621 alloc_dev_default(test, dev1, 0x301, true);
622 dev3 = alloc_dev_default(test, dev1, 0x501, true);
623 alloc_dev_default(test, dev1, 0x701, true);
624
625 src_port = &host->ports[5];
626 dst_port = &dev3->ports[13];
627
628 /* Walk both directions */
629
630 i = 0;
631 tb_for_each_port_on_path(src_port, dst_port, p) {
632 KUNIT_EXPECT_TRUE(test, i < ARRAY_SIZE(test_data));
633 KUNIT_EXPECT_EQ(test, tb_route(p->sw), test_data[i].route);
634 KUNIT_EXPECT_EQ(test, p->port, test_data[i].port);
635 KUNIT_EXPECT_EQ(test, (enum tb_port_type)p->config.type,
636 test_data[i].type);
637 i++;
638 }
639
640 KUNIT_EXPECT_EQ(test, i, ARRAY_SIZE(test_data));
641
642 i = ARRAY_SIZE(test_data) - 1;
643 tb_for_each_port_on_path(dst_port, src_port, p) {
644 KUNIT_EXPECT_TRUE(test, i < ARRAY_SIZE(test_data));
645 KUNIT_EXPECT_EQ(test, tb_route(p->sw), test_data[i].route);
646 KUNIT_EXPECT_EQ(test, p->port, test_data[i].port);
647 KUNIT_EXPECT_EQ(test, (enum tb_port_type)p->config.type,
648 test_data[i].type);
649 i--;
650 }
651
652 KUNIT_EXPECT_EQ(test, i, -1);
653}
654
655static void tb_test_path_complex_tree_walk(struct kunit *test)
656{
657 /*
658 * Walks from Device #3 DP IN to Device #9 DP OUT.
659 *
660 * [Host]
661 * 1 |
662 * 1 |
663 * [Device #1]
664 * 3 / | 5 \ 7
665 * 1 / | \ 1
666 * [Device #2] | [Device #5]
667 * 5 | | 1 \ 7
668 * 1 | [Device #4] \ 1
669 * [Device #3] [Device #6]
670 * 3 /
671 * 1 /
672 * [Device #7]
673 * 3 / | 5
674 * 1 / |
675 * [Device #8] | 1
676 * [Device #9]
677 */
678 static const struct port_expectation test_data[] = {
679 { .route = 0x50301, .port = 13, .type = TB_TYPE_DP_HDMI_IN },
680 { .route = 0x50301, .port = 1, .type = TB_TYPE_PORT },
681 { .route = 0x301, .port = 5, .type = TB_TYPE_PORT },
682 { .route = 0x301, .port = 1, .type = TB_TYPE_PORT },
683 { .route = 0x1, .port = 3, .type = TB_TYPE_PORT },
684 { .route = 0x1, .port = 7, .type = TB_TYPE_PORT },
685 { .route = 0x701, .port = 1, .type = TB_TYPE_PORT },
686 { .route = 0x701, .port = 7, .type = TB_TYPE_PORT },
687 { .route = 0x70701, .port = 1, .type = TB_TYPE_PORT },
688 { .route = 0x70701, .port = 3, .type = TB_TYPE_PORT },
689 { .route = 0x3070701, .port = 1, .type = TB_TYPE_PORT },
690 { .route = 0x3070701, .port = 5, .type = TB_TYPE_PORT },
691 { .route = 0x503070701, .port = 1, .type = TB_TYPE_PORT },
692 { .route = 0x503070701, .port = 14, .type = TB_TYPE_DP_HDMI_OUT },
693 };
694 struct tb_switch *host, *dev1, *dev2, *dev3, *dev5, *dev6, *dev7, *dev9;
695 struct tb_port *src_port, *dst_port, *p;
696 int i;
697
698 host = alloc_host(test);
699 dev1 = alloc_dev_default(test, host, 0x1, true);
700 dev2 = alloc_dev_default(test, dev1, 0x301, true);
701 dev3 = alloc_dev_with_dpin(test, dev2, 0x50301, true);
702 alloc_dev_default(test, dev1, 0x501, true);
703 dev5 = alloc_dev_default(test, dev1, 0x701, true);
704 dev6 = alloc_dev_default(test, dev5, 0x70701, true);
705 dev7 = alloc_dev_default(test, dev6, 0x3070701, true);
706 alloc_dev_default(test, dev7, 0x303070701, true);
707 dev9 = alloc_dev_default(test, dev7, 0x503070701, true);
708
709 src_port = &dev3->ports[13];
710 dst_port = &dev9->ports[14];
711
712 /* Walk both directions */
713
714 i = 0;
715 tb_for_each_port_on_path(src_port, dst_port, p) {
716 KUNIT_EXPECT_TRUE(test, i < ARRAY_SIZE(test_data));
717 KUNIT_EXPECT_EQ(test, tb_route(p->sw), test_data[i].route);
718 KUNIT_EXPECT_EQ(test, p->port, test_data[i].port);
719 KUNIT_EXPECT_EQ(test, (enum tb_port_type)p->config.type,
720 test_data[i].type);
721 i++;
722 }
723
724 KUNIT_EXPECT_EQ(test, i, ARRAY_SIZE(test_data));
725
726 i = ARRAY_SIZE(test_data) - 1;
727 tb_for_each_port_on_path(dst_port, src_port, p) {
728 KUNIT_EXPECT_TRUE(test, i < ARRAY_SIZE(test_data));
729 KUNIT_EXPECT_EQ(test, tb_route(p->sw), test_data[i].route);
730 KUNIT_EXPECT_EQ(test, p->port, test_data[i].port);
731 KUNIT_EXPECT_EQ(test, (enum tb_port_type)p->config.type,
732 test_data[i].type);
733 i--;
734 }
735
736 KUNIT_EXPECT_EQ(test, i, -1);
737}
738
739static void tb_test_path_max_length_walk(struct kunit *test)
740{
741 struct tb_switch *host, *dev1, *dev2, *dev3, *dev4, *dev5, *dev6;
742 struct tb_switch *dev7, *dev8, *dev9, *dev10, *dev11, *dev12;
743 struct tb_port *src_port, *dst_port, *p;
744 int i;
745
746 /*
747 * Walks from Device #6 DP IN to Device #12 DP OUT.
748 *
749 * [Host]
750 * 1 / \ 3
751 * 1 / \ 1
752 * [Device #1] [Device #7]
753 * 3 | | 3
754 * 1 | | 1
755 * [Device #2] [Device #8]
756 * 3 | | 3
757 * 1 | | 1
758 * [Device #3] [Device #9]
759 * 3 | | 3
760 * 1 | | 1
761 * [Device #4] [Device #10]
762 * 3 | | 3
763 * 1 | | 1
764 * [Device #5] [Device #11]
765 * 3 | | 3
766 * 1 | | 1
767 * [Device #6] [Device #12]
768 */
769 static const struct port_expectation test_data[] = {
770 { .route = 0x30303030301, .port = 13, .type = TB_TYPE_DP_HDMI_IN },
771 { .route = 0x30303030301, .port = 1, .type = TB_TYPE_PORT },
772 { .route = 0x303030301, .port = 3, .type = TB_TYPE_PORT },
773 { .route = 0x303030301, .port = 1, .type = TB_TYPE_PORT },
774 { .route = 0x3030301, .port = 3, .type = TB_TYPE_PORT },
775 { .route = 0x3030301, .port = 1, .type = TB_TYPE_PORT },
776 { .route = 0x30301, .port = 3, .type = TB_TYPE_PORT },
777 { .route = 0x30301, .port = 1, .type = TB_TYPE_PORT },
778 { .route = 0x301, .port = 3, .type = TB_TYPE_PORT },
779 { .route = 0x301, .port = 1, .type = TB_TYPE_PORT },
780 { .route = 0x1, .port = 3, .type = TB_TYPE_PORT },
781 { .route = 0x1, .port = 1, .type = TB_TYPE_PORT },
782 { .route = 0x0, .port = 1, .type = TB_TYPE_PORT },
783 { .route = 0x0, .port = 3, .type = TB_TYPE_PORT },
784 { .route = 0x3, .port = 1, .type = TB_TYPE_PORT },
785 { .route = 0x3, .port = 3, .type = TB_TYPE_PORT },
786 { .route = 0x303, .port = 1, .type = TB_TYPE_PORT },
787 { .route = 0x303, .port = 3, .type = TB_TYPE_PORT },
788 { .route = 0x30303, .port = 1, .type = TB_TYPE_PORT },
789 { .route = 0x30303, .port = 3, .type = TB_TYPE_PORT },
790 { .route = 0x3030303, .port = 1, .type = TB_TYPE_PORT },
791 { .route = 0x3030303, .port = 3, .type = TB_TYPE_PORT },
792 { .route = 0x303030303, .port = 1, .type = TB_TYPE_PORT },
793 { .route = 0x303030303, .port = 3, .type = TB_TYPE_PORT },
794 { .route = 0x30303030303, .port = 1, .type = TB_TYPE_PORT },
795 { .route = 0x30303030303, .port = 13, .type = TB_TYPE_DP_HDMI_OUT },
796 };
797
798 host = alloc_host(test);
799 dev1 = alloc_dev_default(test, host, 0x1, true);
800 dev2 = alloc_dev_default(test, dev1, 0x301, true);
801 dev3 = alloc_dev_default(test, dev2, 0x30301, true);
802 dev4 = alloc_dev_default(test, dev3, 0x3030301, true);
803 dev5 = alloc_dev_default(test, dev4, 0x303030301, true);
804 dev6 = alloc_dev_with_dpin(test, dev5, 0x30303030301, true);
805 dev7 = alloc_dev_default(test, host, 0x3, true);
806 dev8 = alloc_dev_default(test, dev7, 0x303, true);
807 dev9 = alloc_dev_default(test, dev8, 0x30303, true);
808 dev10 = alloc_dev_default(test, dev9, 0x3030303, true);
809 dev11 = alloc_dev_default(test, dev10, 0x303030303, true);
810 dev12 = alloc_dev_default(test, dev11, 0x30303030303, true);
811
812 src_port = &dev6->ports[13];
813 dst_port = &dev12->ports[13];
814
815 /* Walk both directions */
816
817 i = 0;
818 tb_for_each_port_on_path(src_port, dst_port, p) {
819 KUNIT_EXPECT_TRUE(test, i < ARRAY_SIZE(test_data));
820 KUNIT_EXPECT_EQ(test, tb_route(p->sw), test_data[i].route);
821 KUNIT_EXPECT_EQ(test, p->port, test_data[i].port);
822 KUNIT_EXPECT_EQ(test, (enum tb_port_type)p->config.type,
823 test_data[i].type);
824 i++;
825 }
826
827 KUNIT_EXPECT_EQ(test, i, ARRAY_SIZE(test_data));
828
829 i = ARRAY_SIZE(test_data) - 1;
830 tb_for_each_port_on_path(dst_port, src_port, p) {
831 KUNIT_EXPECT_TRUE(test, i < ARRAY_SIZE(test_data));
832 KUNIT_EXPECT_EQ(test, tb_route(p->sw), test_data[i].route);
833 KUNIT_EXPECT_EQ(test, p->port, test_data[i].port);
834 KUNIT_EXPECT_EQ(test, (enum tb_port_type)p->config.type,
835 test_data[i].type);
836 i--;
837 }
838
839 KUNIT_EXPECT_EQ(test, i, -1);
840}
841
842static void tb_test_path_not_connected(struct kunit *test)
843{
844 struct tb_switch *host, *dev1, *dev2;
845 struct tb_port *down, *up;
846 struct tb_path *path;
847
848 host = alloc_host(test);
849 dev1 = alloc_dev_default(test, host, 0x3, false);
850 /* Not connected to anything */
851 dev2 = alloc_dev_default(test, NULL, 0x303, false);
852
853 down = &dev1->ports[10];
854 up = &dev2->ports[9];
855
856 path = tb_path_alloc(NULL, down, 8, up, 8, 0, "PCIe Down");
857 KUNIT_ASSERT_NULL(test, path);
858 path = tb_path_alloc(NULL, down, 8, up, 8, 1, "PCIe Down");
859 KUNIT_ASSERT_NULL(test, path);
860}
861
862struct hop_expectation {
863 u64 route;
864 u8 in_port;
865 enum tb_port_type in_type;
866 u8 out_port;
867 enum tb_port_type out_type;
868};
869
870static void tb_test_path_not_bonded_lane0(struct kunit *test)
871{
872 /*
873 * PCIe path from host to device using lane 0.
874 *
875 * [Host]
876 * 3 |: 4
877 * 1 |: 2
878 * [Device]
879 */
880 static const struct hop_expectation test_data[] = {
881 {
882 .route = 0x0,
883 .in_port = 9,
884 .in_type = TB_TYPE_PCIE_DOWN,
885 .out_port = 3,
886 .out_type = TB_TYPE_PORT,
887 },
888 {
889 .route = 0x3,
890 .in_port = 1,
891 .in_type = TB_TYPE_PORT,
892 .out_port = 9,
893 .out_type = TB_TYPE_PCIE_UP,
894 },
895 };
896 struct tb_switch *host, *dev;
897 struct tb_port *down, *up;
898 struct tb_path *path;
899 int i;
900
901 host = alloc_host(test);
902 dev = alloc_dev_default(test, host, 0x3, false);
903
904 down = &host->ports[9];
905 up = &dev->ports[9];
906
907 path = tb_path_alloc(NULL, down, 8, up, 8, 0, "PCIe Down");
908 KUNIT_ASSERT_NOT_NULL(test, path);
909 KUNIT_ASSERT_EQ(test, path->path_length, ARRAY_SIZE(test_data));
910 for (i = 0; i < ARRAY_SIZE(test_data); i++) {
911 const struct tb_port *in_port, *out_port;
912
913 in_port = path->hops[i].in_port;
914 out_port = path->hops[i].out_port;
915
916 KUNIT_EXPECT_EQ(test, tb_route(in_port->sw), test_data[i].route);
917 KUNIT_EXPECT_EQ(test, in_port->port, test_data[i].in_port);
918 KUNIT_EXPECT_EQ(test, (enum tb_port_type)in_port->config.type,
919 test_data[i].in_type);
920 KUNIT_EXPECT_EQ(test, tb_route(out_port->sw), test_data[i].route);
921 KUNIT_EXPECT_EQ(test, out_port->port, test_data[i].out_port);
922 KUNIT_EXPECT_EQ(test, (enum tb_port_type)out_port->config.type,
923 test_data[i].out_type);
924 }
925 tb_path_free(path);
926}
927
928static void tb_test_path_not_bonded_lane1(struct kunit *test)
929{
930 /*
931 * DP Video path from host to device using lane 1. Paths like
932 * these are only used with Thunderbolt 1 devices where lane
933 * bonding is not possible. USB4 specifically does not allow
934 * paths like this (you either use lane 0 where lane 1 is
935 * disabled or both lanes are bonded).
936 *
937 * [Host]
938 * 1 :| 2
939 * 1 :| 2
940 * [Device]
941 */
942 static const struct hop_expectation test_data[] = {
943 {
944 .route = 0x0,
945 .in_port = 5,
946 .in_type = TB_TYPE_DP_HDMI_IN,
947 .out_port = 2,
948 .out_type = TB_TYPE_PORT,
949 },
950 {
951 .route = 0x1,
952 .in_port = 2,
953 .in_type = TB_TYPE_PORT,
954 .out_port = 13,
955 .out_type = TB_TYPE_DP_HDMI_OUT,
956 },
957 };
958 struct tb_switch *host, *dev;
959 struct tb_port *in, *out;
960 struct tb_path *path;
961 int i;
962
963 host = alloc_host(test);
964 dev = alloc_dev_default(test, host, 0x1, false);
965
966 in = &host->ports[5];
967 out = &dev->ports[13];
968
969 path = tb_path_alloc(NULL, in, 9, out, 9, 1, "Video");
970 KUNIT_ASSERT_NOT_NULL(test, path);
971 KUNIT_ASSERT_EQ(test, path->path_length, ARRAY_SIZE(test_data));
972 for (i = 0; i < ARRAY_SIZE(test_data); i++) {
973 const struct tb_port *in_port, *out_port;
974
975 in_port = path->hops[i].in_port;
976 out_port = path->hops[i].out_port;
977
978 KUNIT_EXPECT_EQ(test, tb_route(in_port->sw), test_data[i].route);
979 KUNIT_EXPECT_EQ(test, in_port->port, test_data[i].in_port);
980 KUNIT_EXPECT_EQ(test, (enum tb_port_type)in_port->config.type,
981 test_data[i].in_type);
982 KUNIT_EXPECT_EQ(test, tb_route(out_port->sw), test_data[i].route);
983 KUNIT_EXPECT_EQ(test, out_port->port, test_data[i].out_port);
984 KUNIT_EXPECT_EQ(test, (enum tb_port_type)out_port->config.type,
985 test_data[i].out_type);
986 }
987 tb_path_free(path);
988}
989
990static void tb_test_path_not_bonded_lane1_chain(struct kunit *test)
991{
992 /*
993 * DP Video path from host to device 3 using lane 1.
994 *
995 * [Host]
996 * 1 :| 2
997 * 1 :| 2
998 * [Device #1]
999 * 7 :| 8
1000 * 1 :| 2
1001 * [Device #2]
1002 * 5 :| 6
1003 * 1 :| 2
1004 * [Device #3]
1005 */
1006 static const struct hop_expectation test_data[] = {
1007 {
1008 .route = 0x0,
1009 .in_port = 5,
1010 .in_type = TB_TYPE_DP_HDMI_IN,
1011 .out_port = 2,
1012 .out_type = TB_TYPE_PORT,
1013 },
1014 {
1015 .route = 0x1,
1016 .in_port = 2,
1017 .in_type = TB_TYPE_PORT,
1018 .out_port = 8,
1019 .out_type = TB_TYPE_PORT,
1020 },
1021 {
1022 .route = 0x701,
1023 .in_port = 2,
1024 .in_type = TB_TYPE_PORT,
1025 .out_port = 6,
1026 .out_type = TB_TYPE_PORT,
1027 },
1028 {
1029 .route = 0x50701,
1030 .in_port = 2,
1031 .in_type = TB_TYPE_PORT,
1032 .out_port = 13,
1033 .out_type = TB_TYPE_DP_HDMI_OUT,
1034 },
1035 };
1036 struct tb_switch *host, *dev1, *dev2, *dev3;
1037 struct tb_port *in, *out;
1038 struct tb_path *path;
1039 int i;
1040
1041 host = alloc_host(test);
1042 dev1 = alloc_dev_default(test, host, 0x1, false);
1043 dev2 = alloc_dev_default(test, dev1, 0x701, false);
1044 dev3 = alloc_dev_default(test, dev2, 0x50701, false);
1045
1046 in = &host->ports[5];
1047 out = &dev3->ports[13];
1048
1049 path = tb_path_alloc(NULL, in, 9, out, 9, 1, "Video");
1050 KUNIT_ASSERT_NOT_NULL(test, path);
1051 KUNIT_ASSERT_EQ(test, path->path_length, ARRAY_SIZE(test_data));
1052 for (i = 0; i < ARRAY_SIZE(test_data); i++) {
1053 const struct tb_port *in_port, *out_port;
1054
1055 in_port = path->hops[i].in_port;
1056 out_port = path->hops[i].out_port;
1057
1058 KUNIT_EXPECT_EQ(test, tb_route(in_port->sw), test_data[i].route);
1059 KUNIT_EXPECT_EQ(test, in_port->port, test_data[i].in_port);
1060 KUNIT_EXPECT_EQ(test, (enum tb_port_type)in_port->config.type,
1061 test_data[i].in_type);
1062 KUNIT_EXPECT_EQ(test, tb_route(out_port->sw), test_data[i].route);
1063 KUNIT_EXPECT_EQ(test, out_port->port, test_data[i].out_port);
1064 KUNIT_EXPECT_EQ(test, (enum tb_port_type)out_port->config.type,
1065 test_data[i].out_type);
1066 }
1067 tb_path_free(path);
1068}
1069
1070static void tb_test_path_not_bonded_lane1_chain_reverse(struct kunit *test)
1071{
1072 /*
1073 * DP Video path from device 3 to host using lane 1.
1074 *
1075 * [Host]
1076 * 1 :| 2
1077 * 1 :| 2
1078 * [Device #1]
1079 * 7 :| 8
1080 * 1 :| 2
1081 * [Device #2]
1082 * 5 :| 6
1083 * 1 :| 2
1084 * [Device #3]
1085 */
1086 static const struct hop_expectation test_data[] = {
1087 {
1088 .route = 0x50701,
1089 .in_port = 13,
1090 .in_type = TB_TYPE_DP_HDMI_IN,
1091 .out_port = 2,
1092 .out_type = TB_TYPE_PORT,
1093 },
1094 {
1095 .route = 0x701,
1096 .in_port = 6,
1097 .in_type = TB_TYPE_PORT,
1098 .out_port = 2,
1099 .out_type = TB_TYPE_PORT,
1100 },
1101 {
1102 .route = 0x1,
1103 .in_port = 8,
1104 .in_type = TB_TYPE_PORT,
1105 .out_port = 2,
1106 .out_type = TB_TYPE_PORT,
1107 },
1108 {
1109 .route = 0x0,
1110 .in_port = 2,
1111 .in_type = TB_TYPE_PORT,
1112 .out_port = 5,
1113 .out_type = TB_TYPE_DP_HDMI_IN,
1114 },
1115 };
1116 struct tb_switch *host, *dev1, *dev2, *dev3;
1117 struct tb_port *in, *out;
1118 struct tb_path *path;
1119 int i;
1120
1121 host = alloc_host(test);
1122 dev1 = alloc_dev_default(test, host, 0x1, false);
1123 dev2 = alloc_dev_default(test, dev1, 0x701, false);
1124 dev3 = alloc_dev_with_dpin(test, dev2, 0x50701, false);
1125
1126 in = &dev3->ports[13];
1127 out = &host->ports[5];
1128
1129 path = tb_path_alloc(NULL, in, 9, out, 9, 1, "Video");
1130 KUNIT_ASSERT_NOT_NULL(test, path);
1131 KUNIT_ASSERT_EQ(test, path->path_length, ARRAY_SIZE(test_data));
1132 for (i = 0; i < ARRAY_SIZE(test_data); i++) {
1133 const struct tb_port *in_port, *out_port;
1134
1135 in_port = path->hops[i].in_port;
1136 out_port = path->hops[i].out_port;
1137
1138 KUNIT_EXPECT_EQ(test, tb_route(in_port->sw), test_data[i].route);
1139 KUNIT_EXPECT_EQ(test, in_port->port, test_data[i].in_port);
1140 KUNIT_EXPECT_EQ(test, (enum tb_port_type)in_port->config.type,
1141 test_data[i].in_type);
1142 KUNIT_EXPECT_EQ(test, tb_route(out_port->sw), test_data[i].route);
1143 KUNIT_EXPECT_EQ(test, out_port->port, test_data[i].out_port);
1144 KUNIT_EXPECT_EQ(test, (enum tb_port_type)out_port->config.type,
1145 test_data[i].out_type);
1146 }
1147 tb_path_free(path);
1148}
1149
1150static void tb_test_path_mixed_chain(struct kunit *test)
1151{
1152 /*
1153 * DP Video path from host to device 4 where first and last link
1154 * is bonded.
1155 *
1156 * [Host]
1157 * 1 |
1158 * 1 |
1159 * [Device #1]
1160 * 7 :| 8
1161 * 1 :| 2
1162 * [Device #2]
1163 * 5 :| 6
1164 * 1 :| 2
1165 * [Device #3]
1166 * 3 |
1167 * 1 |
1168 * [Device #4]
1169 */
1170 static const struct hop_expectation test_data[] = {
1171 {
1172 .route = 0x0,
1173 .in_port = 5,
1174 .in_type = TB_TYPE_DP_HDMI_IN,
1175 .out_port = 1,
1176 .out_type = TB_TYPE_PORT,
1177 },
1178 {
1179 .route = 0x1,
1180 .in_port = 1,
1181 .in_type = TB_TYPE_PORT,
1182 .out_port = 8,
1183 .out_type = TB_TYPE_PORT,
1184 },
1185 {
1186 .route = 0x701,
1187 .in_port = 2,
1188 .in_type = TB_TYPE_PORT,
1189 .out_port = 6,
1190 .out_type = TB_TYPE_PORT,
1191 },
1192 {
1193 .route = 0x50701,
1194 .in_port = 2,
1195 .in_type = TB_TYPE_PORT,
1196 .out_port = 3,
1197 .out_type = TB_TYPE_PORT,
1198 },
1199 {
1200 .route = 0x3050701,
1201 .in_port = 1,
1202 .in_type = TB_TYPE_PORT,
1203 .out_port = 13,
1204 .out_type = TB_TYPE_DP_HDMI_OUT,
1205 },
1206 };
1207 struct tb_switch *host, *dev1, *dev2, *dev3, *dev4;
1208 struct tb_port *in, *out;
1209 struct tb_path *path;
1210 int i;
1211
1212 host = alloc_host(test);
1213 dev1 = alloc_dev_default(test, host, 0x1, true);
1214 dev2 = alloc_dev_default(test, dev1, 0x701, false);
1215 dev3 = alloc_dev_default(test, dev2, 0x50701, false);
1216 dev4 = alloc_dev_default(test, dev3, 0x3050701, true);
1217
1218 in = &host->ports[5];
1219 out = &dev4->ports[13];
1220
1221 path = tb_path_alloc(NULL, in, 9, out, 9, 1, "Video");
1222 KUNIT_ASSERT_NOT_NULL(test, path);
1223 KUNIT_ASSERT_EQ(test, path->path_length, ARRAY_SIZE(test_data));
1224 for (i = 0; i < ARRAY_SIZE(test_data); i++) {
1225 const struct tb_port *in_port, *out_port;
1226
1227 in_port = path->hops[i].in_port;
1228 out_port = path->hops[i].out_port;
1229
1230 KUNIT_EXPECT_EQ(test, tb_route(in_port->sw), test_data[i].route);
1231 KUNIT_EXPECT_EQ(test, in_port->port, test_data[i].in_port);
1232 KUNIT_EXPECT_EQ(test, (enum tb_port_type)in_port->config.type,
1233 test_data[i].in_type);
1234 KUNIT_EXPECT_EQ(test, tb_route(out_port->sw), test_data[i].route);
1235 KUNIT_EXPECT_EQ(test, out_port->port, test_data[i].out_port);
1236 KUNIT_EXPECT_EQ(test, (enum tb_port_type)out_port->config.type,
1237 test_data[i].out_type);
1238 }
1239 tb_path_free(path);
1240}
1241
1242static void tb_test_path_mixed_chain_reverse(struct kunit *test)
1243{
1244 /*
1245 * DP Video path from device 4 to host where first and last link
1246 * is bonded.
1247 *
1248 * [Host]
1249 * 1 |
1250 * 1 |
1251 * [Device #1]
1252 * 7 :| 8
1253 * 1 :| 2
1254 * [Device #2]
1255 * 5 :| 6
1256 * 1 :| 2
1257 * [Device #3]
1258 * 3 |
1259 * 1 |
1260 * [Device #4]
1261 */
1262 static const struct hop_expectation test_data[] = {
1263 {
1264 .route = 0x3050701,
1265 .in_port = 13,
1266 .in_type = TB_TYPE_DP_HDMI_OUT,
1267 .out_port = 1,
1268 .out_type = TB_TYPE_PORT,
1269 },
1270 {
1271 .route = 0x50701,
1272 .in_port = 3,
1273 .in_type = TB_TYPE_PORT,
1274 .out_port = 2,
1275 .out_type = TB_TYPE_PORT,
1276 },
1277 {
1278 .route = 0x701,
1279 .in_port = 6,
1280 .in_type = TB_TYPE_PORT,
1281 .out_port = 2,
1282 .out_type = TB_TYPE_PORT,
1283 },
1284 {
1285 .route = 0x1,
1286 .in_port = 8,
1287 .in_type = TB_TYPE_PORT,
1288 .out_port = 1,
1289 .out_type = TB_TYPE_PORT,
1290 },
1291 {
1292 .route = 0x0,
1293 .in_port = 1,
1294 .in_type = TB_TYPE_PORT,
1295 .out_port = 5,
1296 .out_type = TB_TYPE_DP_HDMI_IN,
1297 },
1298 };
1299 struct tb_switch *host, *dev1, *dev2, *dev3, *dev4;
1300 struct tb_port *in, *out;
1301 struct tb_path *path;
1302 int i;
1303
1304 host = alloc_host(test);
1305 dev1 = alloc_dev_default(test, host, 0x1, true);
1306 dev2 = alloc_dev_default(test, dev1, 0x701, false);
1307 dev3 = alloc_dev_default(test, dev2, 0x50701, false);
1308 dev4 = alloc_dev_default(test, dev3, 0x3050701, true);
1309
1310 in = &dev4->ports[13];
1311 out = &host->ports[5];
1312
1313 path = tb_path_alloc(NULL, in, 9, out, 9, 1, "Video");
1314 KUNIT_ASSERT_NOT_NULL(test, path);
1315 KUNIT_ASSERT_EQ(test, path->path_length, ARRAY_SIZE(test_data));
1316 for (i = 0; i < ARRAY_SIZE(test_data); i++) {
1317 const struct tb_port *in_port, *out_port;
1318
1319 in_port = path->hops[i].in_port;
1320 out_port = path->hops[i].out_port;
1321
1322 KUNIT_EXPECT_EQ(test, tb_route(in_port->sw), test_data[i].route);
1323 KUNIT_EXPECT_EQ(test, in_port->port, test_data[i].in_port);
1324 KUNIT_EXPECT_EQ(test, (enum tb_port_type)in_port->config.type,
1325 test_data[i].in_type);
1326 KUNIT_EXPECT_EQ(test, tb_route(out_port->sw), test_data[i].route);
1327 KUNIT_EXPECT_EQ(test, out_port->port, test_data[i].out_port);
1328 KUNIT_EXPECT_EQ(test, (enum tb_port_type)out_port->config.type,
1329 test_data[i].out_type);
1330 }
1331 tb_path_free(path);
1332}
1333
1334static void tb_test_tunnel_pcie(struct kunit *test)
1335{
1336 struct tb_switch *host, *dev1, *dev2;
1337 struct tb_tunnel *tunnel1, *tunnel2;
1338 struct tb_port *down, *up;
1339
1340 /*
1341 * Create PCIe tunnel between host and two devices.
1342 *
1343 * [Host]
1344 * 1 |
1345 * 1 |
1346 * [Device #1]
1347 * 5 |
1348 * 1 |
1349 * [Device #2]
1350 */
1351 host = alloc_host(test);
1352 dev1 = alloc_dev_default(test, host, 0x1, true);
1353 dev2 = alloc_dev_default(test, dev1, 0x501, true);
1354
1355 down = &host->ports[8];
1356 up = &dev1->ports[9];
1357 tunnel1 = tb_tunnel_alloc_pci(NULL, up, down);
1358 KUNIT_ASSERT_NOT_NULL(test, tunnel1);
1359 KUNIT_EXPECT_EQ(test, tunnel1->type, TB_TUNNEL_PCI);
1360 KUNIT_EXPECT_PTR_EQ(test, tunnel1->src_port, down);
1361 KUNIT_EXPECT_PTR_EQ(test, tunnel1->dst_port, up);
1362 KUNIT_ASSERT_EQ(test, tunnel1->npaths, 2);
1363 KUNIT_ASSERT_EQ(test, tunnel1->paths[0]->path_length, 2);
1364 KUNIT_EXPECT_PTR_EQ(test, tunnel1->paths[0]->hops[0].in_port, down);
1365 KUNIT_EXPECT_PTR_EQ(test, tunnel1->paths[0]->hops[1].out_port, up);
1366 KUNIT_ASSERT_EQ(test, tunnel1->paths[1]->path_length, 2);
1367 KUNIT_EXPECT_PTR_EQ(test, tunnel1->paths[1]->hops[0].in_port, up);
1368 KUNIT_EXPECT_PTR_EQ(test, tunnel1->paths[1]->hops[1].out_port, down);
1369
1370 down = &dev1->ports[10];
1371 up = &dev2->ports[9];
1372 tunnel2 = tb_tunnel_alloc_pci(NULL, up, down);
1373 KUNIT_ASSERT_NOT_NULL(test, tunnel2);
1374 KUNIT_EXPECT_EQ(test, tunnel2->type, TB_TUNNEL_PCI);
1375 KUNIT_EXPECT_PTR_EQ(test, tunnel2->src_port, down);
1376 KUNIT_EXPECT_PTR_EQ(test, tunnel2->dst_port, up);
1377 KUNIT_ASSERT_EQ(test, tunnel2->npaths, 2);
1378 KUNIT_ASSERT_EQ(test, tunnel2->paths[0]->path_length, 2);
1379 KUNIT_EXPECT_PTR_EQ(test, tunnel2->paths[0]->hops[0].in_port, down);
1380 KUNIT_EXPECT_PTR_EQ(test, tunnel2->paths[0]->hops[1].out_port, up);
1381 KUNIT_ASSERT_EQ(test, tunnel2->paths[1]->path_length, 2);
1382 KUNIT_EXPECT_PTR_EQ(test, tunnel2->paths[1]->hops[0].in_port, up);
1383 KUNIT_EXPECT_PTR_EQ(test, tunnel2->paths[1]->hops[1].out_port, down);
1384
1385 tb_tunnel_free(tunnel2);
1386 tb_tunnel_free(tunnel1);
1387}
1388
1389static void tb_test_tunnel_dp(struct kunit *test)
1390{
1391 struct tb_switch *host, *dev;
1392 struct tb_port *in, *out;
1393 struct tb_tunnel *tunnel;
1394
1395 /*
1396 * Create DP tunnel between Host and Device
1397 *
1398 * [Host]
1399 * 1 |
1400 * 1 |
1401 * [Device]
1402 */
1403 host = alloc_host(test);
1404 dev = alloc_dev_default(test, host, 0x3, true);
1405
1406 in = &host->ports[5];
1407 out = &dev->ports[13];
1408
1409 tunnel = tb_tunnel_alloc_dp(NULL, in, out, 1, 0, 0);
1410 KUNIT_ASSERT_NOT_NULL(test, tunnel);
1411 KUNIT_EXPECT_EQ(test, tunnel->type, TB_TUNNEL_DP);
1412 KUNIT_EXPECT_PTR_EQ(test, tunnel->src_port, in);
1413 KUNIT_EXPECT_PTR_EQ(test, tunnel->dst_port, out);
1414 KUNIT_ASSERT_EQ(test, tunnel->npaths, 3);
1415 KUNIT_ASSERT_EQ(test, tunnel->paths[0]->path_length, 2);
1416 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[0]->hops[0].in_port, in);
1417 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[0]->hops[1].out_port, out);
1418 KUNIT_ASSERT_EQ(test, tunnel->paths[1]->path_length, 2);
1419 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[1]->hops[0].in_port, in);
1420 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[1]->hops[1].out_port, out);
1421 KUNIT_ASSERT_EQ(test, tunnel->paths[2]->path_length, 2);
1422 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[2]->hops[0].in_port, out);
1423 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[2]->hops[1].out_port, in);
1424 tb_tunnel_free(tunnel);
1425}
1426
1427static void tb_test_tunnel_dp_chain(struct kunit *test)
1428{
1429 struct tb_switch *host, *dev1, *dev4;
1430 struct tb_port *in, *out;
1431 struct tb_tunnel *tunnel;
1432
1433 /*
1434 * Create DP tunnel from Host DP IN to Device #4 DP OUT.
1435 *
1436 * [Host]
1437 * 1 |
1438 * 1 |
1439 * [Device #1]
1440 * 3 / | 5 \ 7
1441 * 1 / | \ 1
1442 * [Device #2] | [Device #4]
1443 * | 1
1444 * [Device #3]
1445 */
1446 host = alloc_host(test);
1447 dev1 = alloc_dev_default(test, host, 0x1, true);
1448 alloc_dev_default(test, dev1, 0x301, true);
1449 alloc_dev_default(test, dev1, 0x501, true);
1450 dev4 = alloc_dev_default(test, dev1, 0x701, true);
1451
1452 in = &host->ports[5];
1453 out = &dev4->ports[14];
1454
1455 tunnel = tb_tunnel_alloc_dp(NULL, in, out, 1, 0, 0);
1456 KUNIT_ASSERT_NOT_NULL(test, tunnel);
1457 KUNIT_EXPECT_EQ(test, tunnel->type, TB_TUNNEL_DP);
1458 KUNIT_EXPECT_PTR_EQ(test, tunnel->src_port, in);
1459 KUNIT_EXPECT_PTR_EQ(test, tunnel->dst_port, out);
1460 KUNIT_ASSERT_EQ(test, tunnel->npaths, 3);
1461 KUNIT_ASSERT_EQ(test, tunnel->paths[0]->path_length, 3);
1462 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[0]->hops[0].in_port, in);
1463 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[0]->hops[2].out_port, out);
1464 KUNIT_ASSERT_EQ(test, tunnel->paths[1]->path_length, 3);
1465 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[1]->hops[0].in_port, in);
1466 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[1]->hops[2].out_port, out);
1467 KUNIT_ASSERT_EQ(test, tunnel->paths[2]->path_length, 3);
1468 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[2]->hops[0].in_port, out);
1469 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[2]->hops[2].out_port, in);
1470 tb_tunnel_free(tunnel);
1471}
1472
1473static void tb_test_tunnel_dp_tree(struct kunit *test)
1474{
1475 struct tb_switch *host, *dev1, *dev2, *dev3, *dev5;
1476 struct tb_port *in, *out;
1477 struct tb_tunnel *tunnel;
1478
1479 /*
1480 * Create DP tunnel from Device #2 DP IN to Device #5 DP OUT.
1481 *
1482 * [Host]
1483 * 3 |
1484 * 1 |
1485 * [Device #1]
1486 * 3 / | 5 \ 7
1487 * 1 / | \ 1
1488 * [Device #2] | [Device #4]
1489 * | 1
1490 * [Device #3]
1491 * | 5
1492 * | 1
1493 * [Device #5]
1494 */
1495 host = alloc_host(test);
1496 dev1 = alloc_dev_default(test, host, 0x3, true);
1497 dev2 = alloc_dev_with_dpin(test, dev1, 0x303, true);
1498 dev3 = alloc_dev_default(test, dev1, 0x503, true);
1499 alloc_dev_default(test, dev1, 0x703, true);
1500 dev5 = alloc_dev_default(test, dev3, 0x50503, true);
1501
1502 in = &dev2->ports[13];
1503 out = &dev5->ports[13];
1504
1505 tunnel = tb_tunnel_alloc_dp(NULL, in, out, 1, 0, 0);
1506 KUNIT_ASSERT_NOT_NULL(test, tunnel);
1507 KUNIT_EXPECT_EQ(test, tunnel->type, TB_TUNNEL_DP);
1508 KUNIT_EXPECT_PTR_EQ(test, tunnel->src_port, in);
1509 KUNIT_EXPECT_PTR_EQ(test, tunnel->dst_port, out);
1510 KUNIT_ASSERT_EQ(test, tunnel->npaths, 3);
1511 KUNIT_ASSERT_EQ(test, tunnel->paths[0]->path_length, 4);
1512 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[0]->hops[0].in_port, in);
1513 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[0]->hops[3].out_port, out);
1514 KUNIT_ASSERT_EQ(test, tunnel->paths[1]->path_length, 4);
1515 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[1]->hops[0].in_port, in);
1516 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[1]->hops[3].out_port, out);
1517 KUNIT_ASSERT_EQ(test, tunnel->paths[2]->path_length, 4);
1518 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[2]->hops[0].in_port, out);
1519 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[2]->hops[3].out_port, in);
1520 tb_tunnel_free(tunnel);
1521}
1522
1523static void tb_test_tunnel_dp_max_length(struct kunit *test)
1524{
1525 struct tb_switch *host, *dev1, *dev2, *dev3, *dev4, *dev5, *dev6;
1526 struct tb_switch *dev7, *dev8, *dev9, *dev10, *dev11, *dev12;
1527 struct tb_port *in, *out;
1528 struct tb_tunnel *tunnel;
1529
1530 /*
1531 * Creates DP tunnel from Device #6 to Device #12.
1532 *
1533 * [Host]
1534 * 1 / \ 3
1535 * 1 / \ 1
1536 * [Device #1] [Device #7]
1537 * 3 | | 3
1538 * 1 | | 1
1539 * [Device #2] [Device #8]
1540 * 3 | | 3
1541 * 1 | | 1
1542 * [Device #3] [Device #9]
1543 * 3 | | 3
1544 * 1 | | 1
1545 * [Device #4] [Device #10]
1546 * 3 | | 3
1547 * 1 | | 1
1548 * [Device #5] [Device #11]
1549 * 3 | | 3
1550 * 1 | | 1
1551 * [Device #6] [Device #12]
1552 */
1553 host = alloc_host(test);
1554 dev1 = alloc_dev_default(test, host, 0x1, true);
1555 dev2 = alloc_dev_default(test, dev1, 0x301, true);
1556 dev3 = alloc_dev_default(test, dev2, 0x30301, true);
1557 dev4 = alloc_dev_default(test, dev3, 0x3030301, true);
1558 dev5 = alloc_dev_default(test, dev4, 0x303030301, true);
1559 dev6 = alloc_dev_with_dpin(test, dev5, 0x30303030301, true);
1560 dev7 = alloc_dev_default(test, host, 0x3, true);
1561 dev8 = alloc_dev_default(test, dev7, 0x303, true);
1562 dev9 = alloc_dev_default(test, dev8, 0x30303, true);
1563 dev10 = alloc_dev_default(test, dev9, 0x3030303, true);
1564 dev11 = alloc_dev_default(test, dev10, 0x303030303, true);
1565 dev12 = alloc_dev_default(test, dev11, 0x30303030303, true);
1566
1567 in = &dev6->ports[13];
1568 out = &dev12->ports[13];
1569
1570 tunnel = tb_tunnel_alloc_dp(NULL, in, out, 1, 0, 0);
1571 KUNIT_ASSERT_NOT_NULL(test, tunnel);
1572 KUNIT_EXPECT_EQ(test, tunnel->type, TB_TUNNEL_DP);
1573 KUNIT_EXPECT_PTR_EQ(test, tunnel->src_port, in);
1574 KUNIT_EXPECT_PTR_EQ(test, tunnel->dst_port, out);
1575 KUNIT_ASSERT_EQ(test, tunnel->npaths, 3);
1576 KUNIT_ASSERT_EQ(test, tunnel->paths[0]->path_length, 13);
1577 /* First hop */
1578 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[0]->hops[0].in_port, in);
1579 /* Middle */
1580 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[0]->hops[6].in_port,
1581 &host->ports[1]);
1582 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[0]->hops[6].out_port,
1583 &host->ports[3]);
1584 /* Last */
1585 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[0]->hops[12].out_port, out);
1586 KUNIT_ASSERT_EQ(test, tunnel->paths[1]->path_length, 13);
1587 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[1]->hops[0].in_port, in);
1588 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[1]->hops[6].in_port,
1589 &host->ports[1]);
1590 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[1]->hops[6].out_port,
1591 &host->ports[3]);
1592 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[1]->hops[12].out_port, out);
1593 KUNIT_ASSERT_EQ(test, tunnel->paths[2]->path_length, 13);
1594 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[2]->hops[0].in_port, out);
1595 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[2]->hops[6].in_port,
1596 &host->ports[3]);
1597 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[2]->hops[6].out_port,
1598 &host->ports[1]);
1599 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[2]->hops[12].out_port, in);
1600 tb_tunnel_free(tunnel);
1601}
1602
1603static void tb_test_tunnel_3dp(struct kunit *test)
1604{
1605 struct tb_switch *host, *dev1, *dev2, *dev3, *dev4, *dev5;
1606 struct tb_port *in1, *in2, *in3, *out1, *out2, *out3;
1607 struct tb_tunnel *tunnel1, *tunnel2, *tunnel3;
1608
1609 /*
1610 * Create 3 DP tunnels from Host to Devices #2, #5 and #4.
1611 *
1612 * [Host]
1613 * 3 |
1614 * 1 |
1615 * [Device #1]
1616 * 3 / | 5 \ 7
1617 * 1 / | \ 1
1618 * [Device #2] | [Device #4]
1619 * | 1
1620 * [Device #3]
1621 * | 5
1622 * | 1
1623 * [Device #5]
1624 */
1625 host = alloc_host_br(test);
1626 dev1 = alloc_dev_default(test, host, 0x3, true);
1627 dev2 = alloc_dev_default(test, dev1, 0x303, true);
1628 dev3 = alloc_dev_default(test, dev1, 0x503, true);
1629 dev4 = alloc_dev_default(test, dev1, 0x703, true);
1630 dev5 = alloc_dev_default(test, dev3, 0x50503, true);
1631
1632 in1 = &host->ports[5];
1633 in2 = &host->ports[6];
1634 in3 = &host->ports[10];
1635
1636 out1 = &dev2->ports[13];
1637 out2 = &dev5->ports[13];
1638 out3 = &dev4->ports[14];
1639
1640 tunnel1 = tb_tunnel_alloc_dp(NULL, in1, out1, 1, 0, 0);
1641 KUNIT_ASSERT_TRUE(test, tunnel1 != NULL);
1642 KUNIT_EXPECT_EQ(test, tunnel1->type, TB_TUNNEL_DP);
1643 KUNIT_EXPECT_PTR_EQ(test, tunnel1->src_port, in1);
1644 KUNIT_EXPECT_PTR_EQ(test, tunnel1->dst_port, out1);
1645 KUNIT_ASSERT_EQ(test, tunnel1->npaths, 3);
1646 KUNIT_ASSERT_EQ(test, tunnel1->paths[0]->path_length, 3);
1647
1648 tunnel2 = tb_tunnel_alloc_dp(NULL, in2, out2, 1, 0, 0);
1649 KUNIT_ASSERT_TRUE(test, tunnel2 != NULL);
1650 KUNIT_EXPECT_EQ(test, tunnel2->type, TB_TUNNEL_DP);
1651 KUNIT_EXPECT_PTR_EQ(test, tunnel2->src_port, in2);
1652 KUNIT_EXPECT_PTR_EQ(test, tunnel2->dst_port, out2);
1653 KUNIT_ASSERT_EQ(test, tunnel2->npaths, 3);
1654 KUNIT_ASSERT_EQ(test, tunnel2->paths[0]->path_length, 4);
1655
1656 tunnel3 = tb_tunnel_alloc_dp(NULL, in3, out3, 1, 0, 0);
1657 KUNIT_ASSERT_TRUE(test, tunnel3 != NULL);
1658 KUNIT_EXPECT_EQ(test, tunnel3->type, TB_TUNNEL_DP);
1659 KUNIT_EXPECT_PTR_EQ(test, tunnel3->src_port, in3);
1660 KUNIT_EXPECT_PTR_EQ(test, tunnel3->dst_port, out3);
1661 KUNIT_ASSERT_EQ(test, tunnel3->npaths, 3);
1662 KUNIT_ASSERT_EQ(test, tunnel3->paths[0]->path_length, 3);
1663
1664 tb_tunnel_free(tunnel2);
1665 tb_tunnel_free(tunnel1);
1666}
1667
1668static void tb_test_tunnel_usb3(struct kunit *test)
1669{
1670 struct tb_switch *host, *dev1, *dev2;
1671 struct tb_tunnel *tunnel1, *tunnel2;
1672 struct tb_port *down, *up;
1673
1674 /*
1675 * Create USB3 tunnel between host and two devices.
1676 *
1677 * [Host]
1678 * 1 |
1679 * 1 |
1680 * [Device #1]
1681 * \ 7
1682 * \ 1
1683 * [Device #2]
1684 */
1685 host = alloc_host(test);
1686 dev1 = alloc_dev_default(test, host, 0x1, true);
1687 dev2 = alloc_dev_default(test, dev1, 0x701, true);
1688
1689 down = &host->ports[12];
1690 up = &dev1->ports[16];
1691 tunnel1 = tb_tunnel_alloc_usb3(NULL, up, down, 0, 0);
1692 KUNIT_ASSERT_NOT_NULL(test, tunnel1);
1693 KUNIT_EXPECT_EQ(test, tunnel1->type, TB_TUNNEL_USB3);
1694 KUNIT_EXPECT_PTR_EQ(test, tunnel1->src_port, down);
1695 KUNIT_EXPECT_PTR_EQ(test, tunnel1->dst_port, up);
1696 KUNIT_ASSERT_EQ(test, tunnel1->npaths, 2);
1697 KUNIT_ASSERT_EQ(test, tunnel1->paths[0]->path_length, 2);
1698 KUNIT_EXPECT_PTR_EQ(test, tunnel1->paths[0]->hops[0].in_port, down);
1699 KUNIT_EXPECT_PTR_EQ(test, tunnel1->paths[0]->hops[1].out_port, up);
1700 KUNIT_ASSERT_EQ(test, tunnel1->paths[1]->path_length, 2);
1701 KUNIT_EXPECT_PTR_EQ(test, tunnel1->paths[1]->hops[0].in_port, up);
1702 KUNIT_EXPECT_PTR_EQ(test, tunnel1->paths[1]->hops[1].out_port, down);
1703
1704 down = &dev1->ports[17];
1705 up = &dev2->ports[16];
1706 tunnel2 = tb_tunnel_alloc_usb3(NULL, up, down, 0, 0);
1707 KUNIT_ASSERT_NOT_NULL(test, tunnel2);
1708 KUNIT_EXPECT_EQ(test, tunnel2->type, TB_TUNNEL_USB3);
1709 KUNIT_EXPECT_PTR_EQ(test, tunnel2->src_port, down);
1710 KUNIT_EXPECT_PTR_EQ(test, tunnel2->dst_port, up);
1711 KUNIT_ASSERT_EQ(test, tunnel2->npaths, 2);
1712 KUNIT_ASSERT_EQ(test, tunnel2->paths[0]->path_length, 2);
1713 KUNIT_EXPECT_PTR_EQ(test, tunnel2->paths[0]->hops[0].in_port, down);
1714 KUNIT_EXPECT_PTR_EQ(test, tunnel2->paths[0]->hops[1].out_port, up);
1715 KUNIT_ASSERT_EQ(test, tunnel2->paths[1]->path_length, 2);
1716 KUNIT_EXPECT_PTR_EQ(test, tunnel2->paths[1]->hops[0].in_port, up);
1717 KUNIT_EXPECT_PTR_EQ(test, tunnel2->paths[1]->hops[1].out_port, down);
1718
1719 tb_tunnel_free(tunnel2);
1720 tb_tunnel_free(tunnel1);
1721}
1722
1723static void tb_test_tunnel_port_on_path(struct kunit *test)
1724{
1725 struct tb_switch *host, *dev1, *dev2, *dev3, *dev4, *dev5;
1726 struct tb_port *in, *out, *port;
1727 struct tb_tunnel *dp_tunnel;
1728
1729 /*
1730 * [Host]
1731 * 3 |
1732 * 1 |
1733 * [Device #1]
1734 * 3 / | 5 \ 7
1735 * 1 / | \ 1
1736 * [Device #2] | [Device #4]
1737 * | 1
1738 * [Device #3]
1739 * | 5
1740 * | 1
1741 * [Device #5]
1742 */
1743 host = alloc_host(test);
1744 dev1 = alloc_dev_default(test, host, 0x3, true);
1745 dev2 = alloc_dev_with_dpin(test, dev1, 0x303, true);
1746 dev3 = alloc_dev_default(test, dev1, 0x503, true);
1747 dev4 = alloc_dev_default(test, dev1, 0x703, true);
1748 dev5 = alloc_dev_default(test, dev3, 0x50503, true);
1749
1750 in = &dev2->ports[13];
1751 out = &dev5->ports[13];
1752
1753 dp_tunnel = tb_tunnel_alloc_dp(NULL, in, out, 1, 0, 0);
1754 KUNIT_ASSERT_NOT_NULL(test, dp_tunnel);
1755
1756 KUNIT_EXPECT_TRUE(test, tb_tunnel_port_on_path(dp_tunnel, in));
1757 KUNIT_EXPECT_TRUE(test, tb_tunnel_port_on_path(dp_tunnel, out));
1758
1759 port = &host->ports[8];
1760 KUNIT_EXPECT_FALSE(test, tb_tunnel_port_on_path(dp_tunnel, port));
1761
1762 port = &host->ports[3];
1763 KUNIT_EXPECT_FALSE(test, tb_tunnel_port_on_path(dp_tunnel, port));
1764
1765 port = &dev1->ports[1];
1766 KUNIT_EXPECT_FALSE(test, tb_tunnel_port_on_path(dp_tunnel, port));
1767
1768 port = &dev1->ports[3];
1769 KUNIT_EXPECT_TRUE(test, tb_tunnel_port_on_path(dp_tunnel, port));
1770
1771 port = &dev1->ports[5];
1772 KUNIT_EXPECT_TRUE(test, tb_tunnel_port_on_path(dp_tunnel, port));
1773
1774 port = &dev1->ports[7];
1775 KUNIT_EXPECT_FALSE(test, tb_tunnel_port_on_path(dp_tunnel, port));
1776
1777 port = &dev3->ports[1];
1778 KUNIT_EXPECT_TRUE(test, tb_tunnel_port_on_path(dp_tunnel, port));
1779
1780 port = &dev5->ports[1];
1781 KUNIT_EXPECT_TRUE(test, tb_tunnel_port_on_path(dp_tunnel, port));
1782
1783 port = &dev4->ports[1];
1784 KUNIT_EXPECT_FALSE(test, tb_tunnel_port_on_path(dp_tunnel, port));
1785
1786 tb_tunnel_free(dp_tunnel);
1787}
1788
1789static void tb_test_tunnel_dma(struct kunit *test)
1790{
1791 struct tb_port *nhi, *port;
1792 struct tb_tunnel *tunnel;
1793 struct tb_switch *host;
1794
1795 /*
1796 * Create DMA tunnel from NHI to port 1 and back.
1797 *
1798 * [Host 1]
1799 * 1 ^ In HopID 1 -> Out HopID 8
1800 * |
1801 * v In HopID 8 -> Out HopID 1
1802 * ............ Domain border
1803 * |
1804 * [Host 2]
1805 */
1806 host = alloc_host(test);
1807 nhi = &host->ports[7];
1808 port = &host->ports[1];
1809
1810 tunnel = tb_tunnel_alloc_dma(NULL, nhi, port, 8, 1, 8, 1);
1811 KUNIT_ASSERT_NOT_NULL(test, tunnel);
1812 KUNIT_EXPECT_EQ(test, tunnel->type, TB_TUNNEL_DMA);
1813 KUNIT_EXPECT_PTR_EQ(test, tunnel->src_port, nhi);
1814 KUNIT_EXPECT_PTR_EQ(test, tunnel->dst_port, port);
1815 KUNIT_ASSERT_EQ(test, tunnel->npaths, 2);
1816 /* RX path */
1817 KUNIT_ASSERT_EQ(test, tunnel->paths[0]->path_length, 1);
1818 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[0]->hops[0].in_port, port);
1819 KUNIT_EXPECT_EQ(test, tunnel->paths[0]->hops[0].in_hop_index, 8);
1820 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[0]->hops[0].out_port, nhi);
1821 KUNIT_EXPECT_EQ(test, tunnel->paths[0]->hops[0].next_hop_index, 1);
1822 /* TX path */
1823 KUNIT_ASSERT_EQ(test, tunnel->paths[1]->path_length, 1);
1824 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[1]->hops[0].in_port, nhi);
1825 KUNIT_EXPECT_EQ(test, tunnel->paths[1]->hops[0].in_hop_index, 1);
1826 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[1]->hops[0].out_port, port);
1827 KUNIT_EXPECT_EQ(test, tunnel->paths[1]->hops[0].next_hop_index, 8);
1828
1829 tb_tunnel_free(tunnel);
1830}
1831
1832static void tb_test_tunnel_dma_rx(struct kunit *test)
1833{
1834 struct tb_port *nhi, *port;
1835 struct tb_tunnel *tunnel;
1836 struct tb_switch *host;
1837
1838 /*
1839 * Create DMA RX tunnel from port 1 to NHI.
1840 *
1841 * [Host 1]
1842 * 1 ^
1843 * |
1844 * | In HopID 15 -> Out HopID 2
1845 * ............ Domain border
1846 * |
1847 * [Host 2]
1848 */
1849 host = alloc_host(test);
1850 nhi = &host->ports[7];
1851 port = &host->ports[1];
1852
1853 tunnel = tb_tunnel_alloc_dma(NULL, nhi, port, -1, -1, 15, 2);
1854 KUNIT_ASSERT_NOT_NULL(test, tunnel);
1855 KUNIT_EXPECT_EQ(test, tunnel->type, TB_TUNNEL_DMA);
1856 KUNIT_EXPECT_PTR_EQ(test, tunnel->src_port, nhi);
1857 KUNIT_EXPECT_PTR_EQ(test, tunnel->dst_port, port);
1858 KUNIT_ASSERT_EQ(test, tunnel->npaths, 1);
1859 /* RX path */
1860 KUNIT_ASSERT_EQ(test, tunnel->paths[0]->path_length, 1);
1861 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[0]->hops[0].in_port, port);
1862 KUNIT_EXPECT_EQ(test, tunnel->paths[0]->hops[0].in_hop_index, 15);
1863 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[0]->hops[0].out_port, nhi);
1864 KUNIT_EXPECT_EQ(test, tunnel->paths[0]->hops[0].next_hop_index, 2);
1865
1866 tb_tunnel_free(tunnel);
1867}
1868
1869static void tb_test_tunnel_dma_tx(struct kunit *test)
1870{
1871 struct tb_port *nhi, *port;
1872 struct tb_tunnel *tunnel;
1873 struct tb_switch *host;
1874
1875 /*
1876 * Create DMA TX tunnel from NHI to port 1.
1877 *
1878 * [Host 1]
1879 * 1 | In HopID 2 -> Out HopID 15
1880 * |
1881 * v
1882 * ............ Domain border
1883 * |
1884 * [Host 2]
1885 */
1886 host = alloc_host(test);
1887 nhi = &host->ports[7];
1888 port = &host->ports[1];
1889
1890 tunnel = tb_tunnel_alloc_dma(NULL, nhi, port, 15, 2, -1, -1);
1891 KUNIT_ASSERT_NOT_NULL(test, tunnel);
1892 KUNIT_EXPECT_EQ(test, tunnel->type, TB_TUNNEL_DMA);
1893 KUNIT_EXPECT_PTR_EQ(test, tunnel->src_port, nhi);
1894 KUNIT_EXPECT_PTR_EQ(test, tunnel->dst_port, port);
1895 KUNIT_ASSERT_EQ(test, tunnel->npaths, 1);
1896 /* TX path */
1897 KUNIT_ASSERT_EQ(test, tunnel->paths[0]->path_length, 1);
1898 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[0]->hops[0].in_port, nhi);
1899 KUNIT_EXPECT_EQ(test, tunnel->paths[0]->hops[0].in_hop_index, 2);
1900 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[0]->hops[0].out_port, port);
1901 KUNIT_EXPECT_EQ(test, tunnel->paths[0]->hops[0].next_hop_index, 15);
1902
1903 tb_tunnel_free(tunnel);
1904}
1905
1906static void tb_test_tunnel_dma_chain(struct kunit *test)
1907{
1908 struct tb_switch *host, *dev1, *dev2;
1909 struct tb_port *nhi, *port;
1910 struct tb_tunnel *tunnel;
1911
1912 /*
1913 * Create DMA tunnel from NHI to Device #2 port 3 and back.
1914 *
1915 * [Host 1]
1916 * 1 ^ In HopID 1 -> Out HopID x
1917 * |
1918 * 1 | In HopID x -> Out HopID 1
1919 * [Device #1]
1920 * 7 \
1921 * 1 \
1922 * [Device #2]
1923 * 3 | In HopID x -> Out HopID 8
1924 * |
1925 * v In HopID 8 -> Out HopID x
1926 * ............ Domain border
1927 * |
1928 * [Host 2]
1929 */
1930 host = alloc_host(test);
1931 dev1 = alloc_dev_default(test, host, 0x1, true);
1932 dev2 = alloc_dev_default(test, dev1, 0x701, true);
1933
1934 nhi = &host->ports[7];
1935 port = &dev2->ports[3];
1936 tunnel = tb_tunnel_alloc_dma(NULL, nhi, port, 8, 1, 8, 1);
1937 KUNIT_ASSERT_NOT_NULL(test, tunnel);
1938 KUNIT_EXPECT_EQ(test, tunnel->type, TB_TUNNEL_DMA);
1939 KUNIT_EXPECT_PTR_EQ(test, tunnel->src_port, nhi);
1940 KUNIT_EXPECT_PTR_EQ(test, tunnel->dst_port, port);
1941 KUNIT_ASSERT_EQ(test, tunnel->npaths, 2);
1942 /* RX path */
1943 KUNIT_ASSERT_EQ(test, tunnel->paths[0]->path_length, 3);
1944 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[0]->hops[0].in_port, port);
1945 KUNIT_EXPECT_EQ(test, tunnel->paths[0]->hops[0].in_hop_index, 8);
1946 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[0]->hops[0].out_port,
1947 &dev2->ports[1]);
1948 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[0]->hops[1].in_port,
1949 &dev1->ports[7]);
1950 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[0]->hops[1].out_port,
1951 &dev1->ports[1]);
1952 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[0]->hops[2].in_port,
1953 &host->ports[1]);
1954 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[0]->hops[2].out_port, nhi);
1955 KUNIT_EXPECT_EQ(test, tunnel->paths[0]->hops[2].next_hop_index, 1);
1956 /* TX path */
1957 KUNIT_ASSERT_EQ(test, tunnel->paths[1]->path_length, 3);
1958 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[1]->hops[0].in_port, nhi);
1959 KUNIT_EXPECT_EQ(test, tunnel->paths[1]->hops[0].in_hop_index, 1);
1960 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[1]->hops[1].in_port,
1961 &dev1->ports[1]);
1962 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[1]->hops[1].out_port,
1963 &dev1->ports[7]);
1964 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[1]->hops[2].in_port,
1965 &dev2->ports[1]);
1966 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[1]->hops[2].out_port, port);
1967 KUNIT_EXPECT_EQ(test, tunnel->paths[1]->hops[2].next_hop_index, 8);
1968
1969 tb_tunnel_free(tunnel);
1970}
1971
1972static void tb_test_tunnel_dma_match(struct kunit *test)
1973{
1974 struct tb_port *nhi, *port;
1975 struct tb_tunnel *tunnel;
1976 struct tb_switch *host;
1977
1978 host = alloc_host(test);
1979 nhi = &host->ports[7];
1980 port = &host->ports[1];
1981
1982 tunnel = tb_tunnel_alloc_dma(NULL, nhi, port, 15, 1, 15, 1);
1983 KUNIT_ASSERT_NOT_NULL(test, tunnel);
1984
1985 KUNIT_ASSERT_TRUE(test, tb_tunnel_match_dma(tunnel, 15, 1, 15, 1));
1986 KUNIT_ASSERT_FALSE(test, tb_tunnel_match_dma(tunnel, 8, 1, 15, 1));
1987 KUNIT_ASSERT_TRUE(test, tb_tunnel_match_dma(tunnel, -1, -1, 15, 1));
1988 KUNIT_ASSERT_TRUE(test, tb_tunnel_match_dma(tunnel, 15, 1, -1, -1));
1989 KUNIT_ASSERT_TRUE(test, tb_tunnel_match_dma(tunnel, 15, -1, -1, -1));
1990 KUNIT_ASSERT_TRUE(test, tb_tunnel_match_dma(tunnel, -1, 1, -1, -1));
1991 KUNIT_ASSERT_TRUE(test, tb_tunnel_match_dma(tunnel, -1, -1, 15, -1));
1992 KUNIT_ASSERT_TRUE(test, tb_tunnel_match_dma(tunnel, -1, -1, -1, 1));
1993 KUNIT_ASSERT_TRUE(test, tb_tunnel_match_dma(tunnel, -1, -1, -1, -1));
1994 KUNIT_ASSERT_FALSE(test, tb_tunnel_match_dma(tunnel, 8, -1, 8, -1));
1995
1996 tb_tunnel_free(tunnel);
1997
1998 tunnel = tb_tunnel_alloc_dma(NULL, nhi, port, 15, 1, -1, -1);
1999 KUNIT_ASSERT_NOT_NULL(test, tunnel);
2000 KUNIT_ASSERT_TRUE(test, tb_tunnel_match_dma(tunnel, 15, 1, -1, -1));
2001 KUNIT_ASSERT_TRUE(test, tb_tunnel_match_dma(tunnel, 15, -1, -1, -1));
2002 KUNIT_ASSERT_TRUE(test, tb_tunnel_match_dma(tunnel, -1, 1, -1, -1));
2003 KUNIT_ASSERT_TRUE(test, tb_tunnel_match_dma(tunnel, -1, -1, -1, -1));
2004 KUNIT_ASSERT_FALSE(test, tb_tunnel_match_dma(tunnel, 15, 1, 15, 1));
2005 KUNIT_ASSERT_FALSE(test, tb_tunnel_match_dma(tunnel, -1, -1, 15, 1));
2006 KUNIT_ASSERT_FALSE(test, tb_tunnel_match_dma(tunnel, 15, 11, -1, -1));
2007
2008 tb_tunnel_free(tunnel);
2009
2010 tunnel = tb_tunnel_alloc_dma(NULL, nhi, port, -1, -1, 15, 11);
2011 KUNIT_ASSERT_NOT_NULL(test, tunnel);
2012 KUNIT_ASSERT_TRUE(test, tb_tunnel_match_dma(tunnel, -1, -1, 15, 11));
2013 KUNIT_ASSERT_TRUE(test, tb_tunnel_match_dma(tunnel, -1, -1, 15, -1));
2014 KUNIT_ASSERT_TRUE(test, tb_tunnel_match_dma(tunnel, -1, -1, -1, 11));
2015 KUNIT_ASSERT_TRUE(test, tb_tunnel_match_dma(tunnel, -1, -1, -1, -1));
2016 KUNIT_ASSERT_FALSE(test, tb_tunnel_match_dma(tunnel, -1, -1, 15, 1));
2017 KUNIT_ASSERT_FALSE(test, tb_tunnel_match_dma(tunnel, -1, -1, 10, 11));
2018 KUNIT_ASSERT_FALSE(test, tb_tunnel_match_dma(tunnel, 15, 11, -1, -1));
2019
2020 tb_tunnel_free(tunnel);
2021}
2022
2023static void tb_test_credit_alloc_legacy_not_bonded(struct kunit *test)
2024{
2025 struct tb_switch *host, *dev;
2026 struct tb_port *up, *down;
2027 struct tb_tunnel *tunnel;
2028 struct tb_path *path;
2029
2030 host = alloc_host(test);
2031 dev = alloc_dev_default(test, host, 0x1, false);
2032
2033 down = &host->ports[8];
2034 up = &dev->ports[9];
2035 tunnel = tb_tunnel_alloc_pci(NULL, up, down);
2036 KUNIT_ASSERT_NOT_NULL(test, tunnel);
2037 KUNIT_ASSERT_EQ(test, tunnel->npaths, (size_t)2);
2038
2039 path = tunnel->paths[0];
2040 KUNIT_ASSERT_EQ(test, path->path_length, 2);
2041 KUNIT_EXPECT_EQ(test, path->hops[0].nfc_credits, 0U);
2042 KUNIT_EXPECT_EQ(test, path->hops[0].initial_credits, 7U);
2043 KUNIT_EXPECT_EQ(test, path->hops[1].nfc_credits, 0U);
2044 KUNIT_EXPECT_EQ(test, path->hops[1].initial_credits, 16U);
2045
2046 path = tunnel->paths[1];
2047 KUNIT_ASSERT_EQ(test, path->path_length, 2);
2048 KUNIT_EXPECT_EQ(test, path->hops[0].nfc_credits, 0U);
2049 KUNIT_EXPECT_EQ(test, path->hops[0].initial_credits, 7U);
2050 KUNIT_EXPECT_EQ(test, path->hops[1].nfc_credits, 0U);
2051 KUNIT_EXPECT_EQ(test, path->hops[1].initial_credits, 16U);
2052
2053 tb_tunnel_free(tunnel);
2054}
2055
2056static void tb_test_credit_alloc_legacy_bonded(struct kunit *test)
2057{
2058 struct tb_switch *host, *dev;
2059 struct tb_port *up, *down;
2060 struct tb_tunnel *tunnel;
2061 struct tb_path *path;
2062
2063 host = alloc_host(test);
2064 dev = alloc_dev_default(test, host, 0x1, true);
2065
2066 down = &host->ports[8];
2067 up = &dev->ports[9];
2068 tunnel = tb_tunnel_alloc_pci(NULL, up, down);
2069 KUNIT_ASSERT_NOT_NULL(test, tunnel);
2070 KUNIT_ASSERT_EQ(test, tunnel->npaths, (size_t)2);
2071
2072 path = tunnel->paths[0];
2073 KUNIT_ASSERT_EQ(test, path->path_length, 2);
2074 KUNIT_EXPECT_EQ(test, path->hops[0].nfc_credits, 0U);
2075 KUNIT_EXPECT_EQ(test, path->hops[0].initial_credits, 7U);
2076 KUNIT_EXPECT_EQ(test, path->hops[1].nfc_credits, 0U);
2077 KUNIT_EXPECT_EQ(test, path->hops[1].initial_credits, 32U);
2078
2079 path = tunnel->paths[1];
2080 KUNIT_ASSERT_EQ(test, path->path_length, 2);
2081 KUNIT_EXPECT_EQ(test, path->hops[0].nfc_credits, 0U);
2082 KUNIT_EXPECT_EQ(test, path->hops[0].initial_credits, 7U);
2083 KUNIT_EXPECT_EQ(test, path->hops[1].nfc_credits, 0U);
2084 KUNIT_EXPECT_EQ(test, path->hops[1].initial_credits, 32U);
2085
2086 tb_tunnel_free(tunnel);
2087}
2088
2089static void tb_test_credit_alloc_pcie(struct kunit *test)
2090{
2091 struct tb_switch *host, *dev;
2092 struct tb_port *up, *down;
2093 struct tb_tunnel *tunnel;
2094 struct tb_path *path;
2095
2096 host = alloc_host_usb4(test);
2097 dev = alloc_dev_usb4(test, host, 0x1, true);
2098
2099 down = &host->ports[8];
2100 up = &dev->ports[9];
2101 tunnel = tb_tunnel_alloc_pci(NULL, up, down);
2102 KUNIT_ASSERT_NOT_NULL(test, tunnel);
2103 KUNIT_ASSERT_EQ(test, tunnel->npaths, (size_t)2);
2104
2105 path = tunnel->paths[0];
2106 KUNIT_ASSERT_EQ(test, path->path_length, 2);
2107 KUNIT_EXPECT_EQ(test, path->hops[0].nfc_credits, 0U);
2108 KUNIT_EXPECT_EQ(test, path->hops[0].initial_credits, 7U);
2109 KUNIT_EXPECT_EQ(test, path->hops[1].nfc_credits, 0U);
2110 KUNIT_EXPECT_EQ(test, path->hops[1].initial_credits, 32U);
2111
2112 path = tunnel->paths[1];
2113 KUNIT_ASSERT_EQ(test, path->path_length, 2);
2114 KUNIT_EXPECT_EQ(test, path->hops[0].nfc_credits, 0U);
2115 KUNIT_EXPECT_EQ(test, path->hops[0].initial_credits, 7U);
2116 KUNIT_EXPECT_EQ(test, path->hops[1].nfc_credits, 0U);
2117 KUNIT_EXPECT_EQ(test, path->hops[1].initial_credits, 64U);
2118
2119 tb_tunnel_free(tunnel);
2120}
2121
2122static void tb_test_credit_alloc_without_dp(struct kunit *test)
2123{
2124 struct tb_switch *host, *dev;
2125 struct tb_port *up, *down;
2126 struct tb_tunnel *tunnel;
2127 struct tb_path *path;
2128
2129 host = alloc_host_usb4(test);
2130 dev = alloc_dev_without_dp(test, host, 0x1, true);
2131
2132 /*
2133 * The device has no DP therefore baMinDPmain = baMinDPaux = 0
2134 *
2135 * Create PCIe path with buffers less than baMaxPCIe.
2136 *
2137 * For a device with buffers configurations:
2138 * baMaxUSB3 = 109
2139 * baMinDPaux = 0
2140 * baMinDPmain = 0
2141 * baMaxPCIe = 30
2142 * baMaxHI = 1
2143 * Remaining Buffers = Total - (CP + DP) = 120 - (2 + 0) = 118
2144 * PCIe Credits = Max(6, Min(baMaxPCIe, Remaining Buffers - baMaxUSB3)
2145 * = Max(6, Min(30, 9) = 9
2146 */
2147 down = &host->ports[8];
2148 up = &dev->ports[9];
2149 tunnel = tb_tunnel_alloc_pci(NULL, up, down);
2150 KUNIT_ASSERT_TRUE(test, tunnel != NULL);
2151 KUNIT_ASSERT_EQ(test, tunnel->npaths, (size_t)2);
2152
2153 /* PCIe downstream path */
2154 path = tunnel->paths[0];
2155 KUNIT_ASSERT_EQ(test, path->path_length, 2);
2156 KUNIT_EXPECT_EQ(test, path->hops[0].nfc_credits, 0U);
2157 KUNIT_EXPECT_EQ(test, path->hops[0].initial_credits, 7U);
2158 KUNIT_EXPECT_EQ(test, path->hops[1].nfc_credits, 0U);
2159 KUNIT_EXPECT_EQ(test, path->hops[1].initial_credits, 9U);
2160
2161 /* PCIe upstream path */
2162 path = tunnel->paths[1];
2163 KUNIT_ASSERT_EQ(test, path->path_length, 2);
2164 KUNIT_EXPECT_EQ(test, path->hops[0].nfc_credits, 0U);
2165 KUNIT_EXPECT_EQ(test, path->hops[0].initial_credits, 7U);
2166 KUNIT_EXPECT_EQ(test, path->hops[1].nfc_credits, 0U);
2167 KUNIT_EXPECT_EQ(test, path->hops[1].initial_credits, 64U);
2168
2169 tb_tunnel_free(tunnel);
2170}
2171
2172static void tb_test_credit_alloc_dp(struct kunit *test)
2173{
2174 struct tb_switch *host, *dev;
2175 struct tb_port *in, *out;
2176 struct tb_tunnel *tunnel;
2177 struct tb_path *path;
2178
2179 host = alloc_host_usb4(test);
2180 dev = alloc_dev_usb4(test, host, 0x1, true);
2181
2182 in = &host->ports[5];
2183 out = &dev->ports[14];
2184
2185 tunnel = tb_tunnel_alloc_dp(NULL, in, out, 1, 0, 0);
2186 KUNIT_ASSERT_NOT_NULL(test, tunnel);
2187 KUNIT_ASSERT_EQ(test, tunnel->npaths, (size_t)3);
2188
2189 /* Video (main) path */
2190 path = tunnel->paths[0];
2191 KUNIT_ASSERT_EQ(test, path->path_length, 2);
2192 KUNIT_EXPECT_EQ(test, path->hops[0].nfc_credits, 12U);
2193 KUNIT_EXPECT_EQ(test, path->hops[0].initial_credits, 0U);
2194 KUNIT_EXPECT_EQ(test, path->hops[1].nfc_credits, 18U);
2195 KUNIT_EXPECT_EQ(test, path->hops[1].initial_credits, 0U);
2196
2197 /* AUX TX */
2198 path = tunnel->paths[1];
2199 KUNIT_ASSERT_EQ(test, path->path_length, 2);
2200 KUNIT_EXPECT_EQ(test, path->hops[0].nfc_credits, 0U);
2201 KUNIT_EXPECT_EQ(test, path->hops[0].initial_credits, 1U);
2202 KUNIT_EXPECT_EQ(test, path->hops[1].nfc_credits, 0U);
2203 KUNIT_EXPECT_EQ(test, path->hops[1].initial_credits, 1U);
2204
2205 /* AUX RX */
2206 path = tunnel->paths[2];
2207 KUNIT_ASSERT_EQ(test, path->path_length, 2);
2208 KUNIT_EXPECT_EQ(test, path->hops[0].nfc_credits, 0U);
2209 KUNIT_EXPECT_EQ(test, path->hops[0].initial_credits, 1U);
2210 KUNIT_EXPECT_EQ(test, path->hops[1].nfc_credits, 0U);
2211 KUNIT_EXPECT_EQ(test, path->hops[1].initial_credits, 1U);
2212
2213 tb_tunnel_free(tunnel);
2214}
2215
2216static void tb_test_credit_alloc_usb3(struct kunit *test)
2217{
2218 struct tb_switch *host, *dev;
2219 struct tb_port *up, *down;
2220 struct tb_tunnel *tunnel;
2221 struct tb_path *path;
2222
2223 host = alloc_host_usb4(test);
2224 dev = alloc_dev_usb4(test, host, 0x1, true);
2225
2226 down = &host->ports[12];
2227 up = &dev->ports[16];
2228 tunnel = tb_tunnel_alloc_usb3(NULL, up, down, 0, 0);
2229 KUNIT_ASSERT_NOT_NULL(test, tunnel);
2230 KUNIT_ASSERT_EQ(test, tunnel->npaths, (size_t)2);
2231
2232 path = tunnel->paths[0];
2233 KUNIT_ASSERT_EQ(test, path->path_length, 2);
2234 KUNIT_EXPECT_EQ(test, path->hops[0].nfc_credits, 0U);
2235 KUNIT_EXPECT_EQ(test, path->hops[0].initial_credits, 7U);
2236 KUNIT_EXPECT_EQ(test, path->hops[1].nfc_credits, 0U);
2237 KUNIT_EXPECT_EQ(test, path->hops[1].initial_credits, 14U);
2238
2239 path = tunnel->paths[1];
2240 KUNIT_ASSERT_EQ(test, path->path_length, 2);
2241 KUNIT_EXPECT_EQ(test, path->hops[0].nfc_credits, 0U);
2242 KUNIT_EXPECT_EQ(test, path->hops[0].initial_credits, 7U);
2243 KUNIT_EXPECT_EQ(test, path->hops[1].nfc_credits, 0U);
2244 KUNIT_EXPECT_EQ(test, path->hops[1].initial_credits, 32U);
2245
2246 tb_tunnel_free(tunnel);
2247}
2248
2249static void tb_test_credit_alloc_dma(struct kunit *test)
2250{
2251 struct tb_switch *host, *dev;
2252 struct tb_port *nhi, *port;
2253 struct tb_tunnel *tunnel;
2254 struct tb_path *path;
2255
2256 host = alloc_host_usb4(test);
2257 dev = alloc_dev_usb4(test, host, 0x1, true);
2258
2259 nhi = &host->ports[7];
2260 port = &dev->ports[3];
2261
2262 tunnel = tb_tunnel_alloc_dma(NULL, nhi, port, 8, 1, 8, 1);
2263 KUNIT_ASSERT_NOT_NULL(test, tunnel);
2264 KUNIT_ASSERT_EQ(test, tunnel->npaths, (size_t)2);
2265
2266 /* DMA RX */
2267 path = tunnel->paths[0];
2268 KUNIT_ASSERT_EQ(test, path->path_length, 2);
2269 KUNIT_EXPECT_EQ(test, path->hops[0].nfc_credits, 0U);
2270 KUNIT_EXPECT_EQ(test, path->hops[0].initial_credits, 14U);
2271 KUNIT_EXPECT_EQ(test, path->hops[1].nfc_credits, 0U);
2272 KUNIT_EXPECT_EQ(test, path->hops[1].initial_credits, 14U);
2273
2274 /* DMA TX */
2275 path = tunnel->paths[1];
2276 KUNIT_ASSERT_EQ(test, path->path_length, 2);
2277 KUNIT_EXPECT_EQ(test, path->hops[0].nfc_credits, 0U);
2278 KUNIT_EXPECT_EQ(test, path->hops[0].initial_credits, 0U);
2279 KUNIT_EXPECT_EQ(test, path->hops[1].nfc_credits, 0U);
2280 KUNIT_EXPECT_EQ(test, path->hops[1].initial_credits, 14U);
2281
2282 tb_tunnel_free(tunnel);
2283}
2284
2285static void tb_test_credit_alloc_dma_multiple(struct kunit *test)
2286{
2287 struct tb_tunnel *tunnel1, *tunnel2, *tunnel3;
2288 struct tb_switch *host, *dev;
2289 struct tb_port *nhi, *port;
2290 struct tb_path *path;
2291
2292 host = alloc_host_usb4(test);
2293 dev = alloc_dev_usb4(test, host, 0x1, true);
2294
2295 nhi = &host->ports[7];
2296 port = &dev->ports[3];
2297
2298 /*
2299 * Create three DMA tunnels through the same ports. With the
2300 * default buffers we should be able to create two and the last
2301 * one fails.
2302 *
2303 * For default host we have following buffers for DMA:
2304 *
2305 * 120 - (2 + 2 * (1 + 0) + 32 + 64 + spare) = 20
2306 *
2307 * For device we have following:
2308 *
2309 * 120 - (2 + 2 * (1 + 18) + 14 + 32 + spare) = 34
2310 *
2311 * spare = 14 + 1 = 15
2312 *
2313 * So on host the first tunnel gets 14 and the second gets the
2314 * remaining 1 and then we run out of buffers.
2315 */
2316 tunnel1 = tb_tunnel_alloc_dma(NULL, nhi, port, 8, 1, 8, 1);
2317 KUNIT_ASSERT_NOT_NULL(test, tunnel1);
2318 KUNIT_ASSERT_EQ(test, tunnel1->npaths, (size_t)2);
2319
2320 path = tunnel1->paths[0];
2321 KUNIT_ASSERT_EQ(test, path->path_length, 2);
2322 KUNIT_EXPECT_EQ(test, path->hops[0].nfc_credits, 0U);
2323 KUNIT_EXPECT_EQ(test, path->hops[0].initial_credits, 14U);
2324 KUNIT_EXPECT_EQ(test, path->hops[1].nfc_credits, 0U);
2325 KUNIT_EXPECT_EQ(test, path->hops[1].initial_credits, 14U);
2326
2327 path = tunnel1->paths[1];
2328 KUNIT_ASSERT_EQ(test, path->path_length, 2);
2329 KUNIT_EXPECT_EQ(test, path->hops[0].nfc_credits, 0U);
2330 KUNIT_EXPECT_EQ(test, path->hops[0].initial_credits, 0U);
2331 KUNIT_EXPECT_EQ(test, path->hops[1].nfc_credits, 0U);
2332 KUNIT_EXPECT_EQ(test, path->hops[1].initial_credits, 14U);
2333
2334 tunnel2 = tb_tunnel_alloc_dma(NULL, nhi, port, 9, 2, 9, 2);
2335 KUNIT_ASSERT_NOT_NULL(test, tunnel2);
2336 KUNIT_ASSERT_EQ(test, tunnel2->npaths, (size_t)2);
2337
2338 path = tunnel2->paths[0];
2339 KUNIT_ASSERT_EQ(test, path->path_length, 2);
2340 KUNIT_EXPECT_EQ(test, path->hops[0].nfc_credits, 0U);
2341 KUNIT_EXPECT_EQ(test, path->hops[0].initial_credits, 14U);
2342 KUNIT_EXPECT_EQ(test, path->hops[1].nfc_credits, 0U);
2343 KUNIT_EXPECT_EQ(test, path->hops[1].initial_credits, 1U);
2344
2345 path = tunnel2->paths[1];
2346 KUNIT_ASSERT_EQ(test, path->path_length, 2);
2347 KUNIT_EXPECT_EQ(test, path->hops[0].nfc_credits, 0U);
2348 KUNIT_EXPECT_EQ(test, path->hops[0].initial_credits, 0U);
2349 KUNIT_EXPECT_EQ(test, path->hops[1].nfc_credits, 0U);
2350 KUNIT_EXPECT_EQ(test, path->hops[1].initial_credits, 1U);
2351
2352 tunnel3 = tb_tunnel_alloc_dma(NULL, nhi, port, 10, 3, 10, 3);
2353 KUNIT_ASSERT_NULL(test, tunnel3);
2354
2355 /*
2356 * Release the first DMA tunnel. That should make 14 buffers
2357 * available for the next tunnel.
2358 */
2359 tb_tunnel_free(tunnel1);
2360
2361 tunnel3 = tb_tunnel_alloc_dma(NULL, nhi, port, 10, 3, 10, 3);
2362 KUNIT_ASSERT_NOT_NULL(test, tunnel3);
2363
2364 path = tunnel3->paths[0];
2365 KUNIT_ASSERT_EQ(test, path->path_length, 2);
2366 KUNIT_EXPECT_EQ(test, path->hops[0].nfc_credits, 0U);
2367 KUNIT_EXPECT_EQ(test, path->hops[0].initial_credits, 14U);
2368 KUNIT_EXPECT_EQ(test, path->hops[1].nfc_credits, 0U);
2369 KUNIT_EXPECT_EQ(test, path->hops[1].initial_credits, 14U);
2370
2371 path = tunnel3->paths[1];
2372 KUNIT_ASSERT_EQ(test, path->path_length, 2);
2373 KUNIT_EXPECT_EQ(test, path->hops[0].nfc_credits, 0U);
2374 KUNIT_EXPECT_EQ(test, path->hops[0].initial_credits, 0U);
2375 KUNIT_EXPECT_EQ(test, path->hops[1].nfc_credits, 0U);
2376 KUNIT_EXPECT_EQ(test, path->hops[1].initial_credits, 14U);
2377
2378 tb_tunnel_free(tunnel3);
2379 tb_tunnel_free(tunnel2);
2380}
2381
2382static struct tb_tunnel *TB_TEST_PCIE_TUNNEL(struct kunit *test,
2383 struct tb_switch *host, struct tb_switch *dev)
2384{
2385 struct tb_port *up, *down;
2386 struct tb_tunnel *pcie_tunnel;
2387 struct tb_path *path;
2388
2389 down = &host->ports[8];
2390 up = &dev->ports[9];
2391 pcie_tunnel = tb_tunnel_alloc_pci(NULL, up, down);
2392 KUNIT_ASSERT_NOT_NULL(test, pcie_tunnel);
2393 KUNIT_ASSERT_EQ(test, pcie_tunnel->npaths, (size_t)2);
2394
2395 path = pcie_tunnel->paths[0];
2396 KUNIT_ASSERT_EQ(test, path->path_length, 2);
2397 KUNIT_EXPECT_EQ(test, path->hops[0].nfc_credits, 0U);
2398 KUNIT_EXPECT_EQ(test, path->hops[0].initial_credits, 7U);
2399 KUNIT_EXPECT_EQ(test, path->hops[1].nfc_credits, 0U);
2400 KUNIT_EXPECT_EQ(test, path->hops[1].initial_credits, 32U);
2401
2402 path = pcie_tunnel->paths[1];
2403 KUNIT_ASSERT_EQ(test, path->path_length, 2);
2404 KUNIT_EXPECT_EQ(test, path->hops[0].nfc_credits, 0U);
2405 KUNIT_EXPECT_EQ(test, path->hops[0].initial_credits, 7U);
2406 KUNIT_EXPECT_EQ(test, path->hops[1].nfc_credits, 0U);
2407 KUNIT_EXPECT_EQ(test, path->hops[1].initial_credits, 64U);
2408
2409 return pcie_tunnel;
2410}
2411
2412static struct tb_tunnel *TB_TEST_DP_TUNNEL1(struct kunit *test,
2413 struct tb_switch *host, struct tb_switch *dev)
2414{
2415 struct tb_port *in, *out;
2416 struct tb_tunnel *dp_tunnel1;
2417 struct tb_path *path;
2418
2419 in = &host->ports[5];
2420 out = &dev->ports[13];
2421 dp_tunnel1 = tb_tunnel_alloc_dp(NULL, in, out, 1, 0, 0);
2422 KUNIT_ASSERT_NOT_NULL(test, dp_tunnel1);
2423 KUNIT_ASSERT_EQ(test, dp_tunnel1->npaths, (size_t)3);
2424
2425 path = dp_tunnel1->paths[0];
2426 KUNIT_ASSERT_EQ(test, path->path_length, 2);
2427 KUNIT_EXPECT_EQ(test, path->hops[0].nfc_credits, 12U);
2428 KUNIT_EXPECT_EQ(test, path->hops[0].initial_credits, 0U);
2429 KUNIT_EXPECT_EQ(test, path->hops[1].nfc_credits, 18U);
2430 KUNIT_EXPECT_EQ(test, path->hops[1].initial_credits, 0U);
2431
2432 path = dp_tunnel1->paths[1];
2433 KUNIT_ASSERT_EQ(test, path->path_length, 2);
2434 KUNIT_EXPECT_EQ(test, path->hops[0].nfc_credits, 0U);
2435 KUNIT_EXPECT_EQ(test, path->hops[0].initial_credits, 1U);
2436 KUNIT_EXPECT_EQ(test, path->hops[1].nfc_credits, 0U);
2437 KUNIT_EXPECT_EQ(test, path->hops[1].initial_credits, 1U);
2438
2439 path = dp_tunnel1->paths[2];
2440 KUNIT_ASSERT_EQ(test, path->path_length, 2);
2441 KUNIT_EXPECT_EQ(test, path->hops[0].nfc_credits, 0U);
2442 KUNIT_EXPECT_EQ(test, path->hops[0].initial_credits, 1U);
2443 KUNIT_EXPECT_EQ(test, path->hops[1].nfc_credits, 0U);
2444 KUNIT_EXPECT_EQ(test, path->hops[1].initial_credits, 1U);
2445
2446 return dp_tunnel1;
2447}
2448
2449static struct tb_tunnel *TB_TEST_DP_TUNNEL2(struct kunit *test,
2450 struct tb_switch *host, struct tb_switch *dev)
2451{
2452 struct tb_port *in, *out;
2453 struct tb_tunnel *dp_tunnel2;
2454 struct tb_path *path;
2455
2456 in = &host->ports[6];
2457 out = &dev->ports[14];
2458 dp_tunnel2 = tb_tunnel_alloc_dp(NULL, in, out, 1, 0, 0);
2459 KUNIT_ASSERT_NOT_NULL(test, dp_tunnel2);
2460 KUNIT_ASSERT_EQ(test, dp_tunnel2->npaths, (size_t)3);
2461
2462 path = dp_tunnel2->paths[0];
2463 KUNIT_ASSERT_EQ(test, path->path_length, 2);
2464 KUNIT_EXPECT_EQ(test, path->hops[0].nfc_credits, 12U);
2465 KUNIT_EXPECT_EQ(test, path->hops[0].initial_credits, 0U);
2466 KUNIT_EXPECT_EQ(test, path->hops[1].nfc_credits, 18U);
2467 KUNIT_EXPECT_EQ(test, path->hops[1].initial_credits, 0U);
2468
2469 path = dp_tunnel2->paths[1];
2470 KUNIT_ASSERT_EQ(test, path->path_length, 2);
2471 KUNIT_EXPECT_EQ(test, path->hops[0].nfc_credits, 0U);
2472 KUNIT_EXPECT_EQ(test, path->hops[0].initial_credits, 1U);
2473 KUNIT_EXPECT_EQ(test, path->hops[1].nfc_credits, 0U);
2474 KUNIT_EXPECT_EQ(test, path->hops[1].initial_credits, 1U);
2475
2476 path = dp_tunnel2->paths[2];
2477 KUNIT_ASSERT_EQ(test, path->path_length, 2);
2478 KUNIT_EXPECT_EQ(test, path->hops[0].nfc_credits, 0U);
2479 KUNIT_EXPECT_EQ(test, path->hops[0].initial_credits, 1U);
2480 KUNIT_EXPECT_EQ(test, path->hops[1].nfc_credits, 0U);
2481 KUNIT_EXPECT_EQ(test, path->hops[1].initial_credits, 1U);
2482
2483 return dp_tunnel2;
2484}
2485
2486static struct tb_tunnel *TB_TEST_USB3_TUNNEL(struct kunit *test,
2487 struct tb_switch *host, struct tb_switch *dev)
2488{
2489 struct tb_port *up, *down;
2490 struct tb_tunnel *usb3_tunnel;
2491 struct tb_path *path;
2492
2493 down = &host->ports[12];
2494 up = &dev->ports[16];
2495 usb3_tunnel = tb_tunnel_alloc_usb3(NULL, up, down, 0, 0);
2496 KUNIT_ASSERT_NOT_NULL(test, usb3_tunnel);
2497 KUNIT_ASSERT_EQ(test, usb3_tunnel->npaths, (size_t)2);
2498
2499 path = usb3_tunnel->paths[0];
2500 KUNIT_ASSERT_EQ(test, path->path_length, 2);
2501 KUNIT_EXPECT_EQ(test, path->hops[0].nfc_credits, 0U);
2502 KUNIT_EXPECT_EQ(test, path->hops[0].initial_credits, 7U);
2503 KUNIT_EXPECT_EQ(test, path->hops[1].nfc_credits, 0U);
2504 KUNIT_EXPECT_EQ(test, path->hops[1].initial_credits, 14U);
2505
2506 path = usb3_tunnel->paths[1];
2507 KUNIT_ASSERT_EQ(test, path->path_length, 2);
2508 KUNIT_EXPECT_EQ(test, path->hops[0].nfc_credits, 0U);
2509 KUNIT_EXPECT_EQ(test, path->hops[0].initial_credits, 7U);
2510 KUNIT_EXPECT_EQ(test, path->hops[1].nfc_credits, 0U);
2511 KUNIT_EXPECT_EQ(test, path->hops[1].initial_credits, 32U);
2512
2513 return usb3_tunnel;
2514}
2515
2516static struct tb_tunnel *TB_TEST_DMA_TUNNEL1(struct kunit *test,
2517 struct tb_switch *host, struct tb_switch *dev)
2518{
2519 struct tb_port *nhi, *port;
2520 struct tb_tunnel *dma_tunnel1;
2521 struct tb_path *path;
2522
2523 nhi = &host->ports[7];
2524 port = &dev->ports[3];
2525 dma_tunnel1 = tb_tunnel_alloc_dma(NULL, nhi, port, 8, 1, 8, 1);
2526 KUNIT_ASSERT_NOT_NULL(test, dma_tunnel1);
2527 KUNIT_ASSERT_EQ(test, dma_tunnel1->npaths, (size_t)2);
2528
2529 path = dma_tunnel1->paths[0];
2530 KUNIT_ASSERT_EQ(test, path->path_length, 2);
2531 KUNIT_EXPECT_EQ(test, path->hops[0].nfc_credits, 0U);
2532 KUNIT_EXPECT_EQ(test, path->hops[0].initial_credits, 14U);
2533 KUNIT_EXPECT_EQ(test, path->hops[1].nfc_credits, 0U);
2534 KUNIT_EXPECT_EQ(test, path->hops[1].initial_credits, 14U);
2535
2536 path = dma_tunnel1->paths[1];
2537 KUNIT_ASSERT_EQ(test, path->path_length, 2);
2538 KUNIT_EXPECT_EQ(test, path->hops[0].nfc_credits, 0U);
2539 KUNIT_EXPECT_EQ(test, path->hops[0].initial_credits, 0U);
2540 KUNIT_EXPECT_EQ(test, path->hops[1].nfc_credits, 0U);
2541 KUNIT_EXPECT_EQ(test, path->hops[1].initial_credits, 14U);
2542
2543 return dma_tunnel1;
2544}
2545
2546static struct tb_tunnel *TB_TEST_DMA_TUNNEL2(struct kunit *test,
2547 struct tb_switch *host, struct tb_switch *dev)
2548{
2549 struct tb_port *nhi, *port;
2550 struct tb_tunnel *dma_tunnel2;
2551 struct tb_path *path;
2552
2553 nhi = &host->ports[7];
2554 port = &dev->ports[3];
2555 dma_tunnel2 = tb_tunnel_alloc_dma(NULL, nhi, port, 9, 2, 9, 2);
2556 KUNIT_ASSERT_NOT_NULL(test, dma_tunnel2);
2557 KUNIT_ASSERT_EQ(test, dma_tunnel2->npaths, (size_t)2);
2558
2559 path = dma_tunnel2->paths[0];
2560 KUNIT_ASSERT_EQ(test, path->path_length, 2);
2561 KUNIT_EXPECT_EQ(test, path->hops[0].nfc_credits, 0U);
2562 KUNIT_EXPECT_EQ(test, path->hops[0].initial_credits, 14U);
2563 KUNIT_EXPECT_EQ(test, path->hops[1].nfc_credits, 0U);
2564 KUNIT_EXPECT_EQ(test, path->hops[1].initial_credits, 1U);
2565
2566 path = dma_tunnel2->paths[1];
2567 KUNIT_ASSERT_EQ(test, path->path_length, 2);
2568 KUNIT_EXPECT_EQ(test, path->hops[0].nfc_credits, 0U);
2569 KUNIT_EXPECT_EQ(test, path->hops[0].initial_credits, 0U);
2570 KUNIT_EXPECT_EQ(test, path->hops[1].nfc_credits, 0U);
2571 KUNIT_EXPECT_EQ(test, path->hops[1].initial_credits, 1U);
2572
2573 return dma_tunnel2;
2574}
2575
2576static void tb_test_credit_alloc_all(struct kunit *test)
2577{
2578 struct tb_tunnel *pcie_tunnel, *dp_tunnel1, *dp_tunnel2, *usb3_tunnel;
2579 struct tb_tunnel *dma_tunnel1, *dma_tunnel2;
2580 struct tb_switch *host, *dev;
2581
2582 /*
2583 * Create PCIe, 2 x DP, USB 3.x and two DMA tunnels from host to
2584 * device. Expectation is that all these can be established with
2585 * the default credit allocation found in Intel hardware.
2586 */
2587
2588 host = alloc_host_usb4(test);
2589 dev = alloc_dev_usb4(test, host, 0x1, true);
2590
2591 pcie_tunnel = TB_TEST_PCIE_TUNNEL(test, host, dev);
2592 dp_tunnel1 = TB_TEST_DP_TUNNEL1(test, host, dev);
2593 dp_tunnel2 = TB_TEST_DP_TUNNEL2(test, host, dev);
2594 usb3_tunnel = TB_TEST_USB3_TUNNEL(test, host, dev);
2595 dma_tunnel1 = TB_TEST_DMA_TUNNEL1(test, host, dev);
2596 dma_tunnel2 = TB_TEST_DMA_TUNNEL2(test, host, dev);
2597
2598 tb_tunnel_free(dma_tunnel2);
2599 tb_tunnel_free(dma_tunnel1);
2600 tb_tunnel_free(usb3_tunnel);
2601 tb_tunnel_free(dp_tunnel2);
2602 tb_tunnel_free(dp_tunnel1);
2603 tb_tunnel_free(pcie_tunnel);
2604}
2605
2606static const u32 root_directory[] = {
2607 0x55584401, /* "UXD" v1 */
2608 0x00000018, /* Root directory length */
2609 0x76656e64, /* "vend" */
2610 0x6f726964, /* "orid" */
2611 0x76000001, /* "v" R 1 */
2612 0x00000a27, /* Immediate value, ! Vendor ID */
2613 0x76656e64, /* "vend" */
2614 0x6f726964, /* "orid" */
2615 0x74000003, /* "t" R 3 */
2616 0x0000001a, /* Text leaf offset, (“Apple Inc.”) */
2617 0x64657669, /* "devi" */
2618 0x63656964, /* "ceid" */
2619 0x76000001, /* "v" R 1 */
2620 0x0000000a, /* Immediate value, ! Device ID */
2621 0x64657669, /* "devi" */
2622 0x63656964, /* "ceid" */
2623 0x74000003, /* "t" R 3 */
2624 0x0000001d, /* Text leaf offset, (“Macintosh”) */
2625 0x64657669, /* "devi" */
2626 0x63657276, /* "cerv" */
2627 0x76000001, /* "v" R 1 */
2628 0x80000100, /* Immediate value, Device Revision */
2629 0x6e657477, /* "netw" */
2630 0x6f726b00, /* "ork" */
2631 0x44000014, /* "D" R 20 */
2632 0x00000021, /* Directory data offset, (Network Directory) */
2633 0x4170706c, /* "Appl" */
2634 0x6520496e, /* "e In" */
2635 0x632e0000, /* "c." ! */
2636 0x4d616369, /* "Maci" */
2637 0x6e746f73, /* "ntos" */
2638 0x68000000, /* "h" */
2639 0x00000000, /* padding */
2640 0xca8961c6, /* Directory UUID, Network Directory */
2641 0x9541ce1c, /* Directory UUID, Network Directory */
2642 0x5949b8bd, /* Directory UUID, Network Directory */
2643 0x4f5a5f2e, /* Directory UUID, Network Directory */
2644 0x70727463, /* "prtc" */
2645 0x69640000, /* "id" */
2646 0x76000001, /* "v" R 1 */
2647 0x00000001, /* Immediate value, Network Protocol ID */
2648 0x70727463, /* "prtc" */
2649 0x76657273, /* "vers" */
2650 0x76000001, /* "v" R 1 */
2651 0x00000001, /* Immediate value, Network Protocol Version */
2652 0x70727463, /* "prtc" */
2653 0x72657673, /* "revs" */
2654 0x76000001, /* "v" R 1 */
2655 0x00000001, /* Immediate value, Network Protocol Revision */
2656 0x70727463, /* "prtc" */
2657 0x73746e73, /* "stns" */
2658 0x76000001, /* "v" R 1 */
2659 0x00000000, /* Immediate value, Network Protocol Settings */
2660};
2661
2662static const uuid_t network_dir_uuid =
2663 UUID_INIT(0xc66189ca, 0x1cce, 0x4195,
2664 0xbd, 0xb8, 0x49, 0x59, 0x2e, 0x5f, 0x5a, 0x4f);
2665
2666static void tb_test_property_parse(struct kunit *test)
2667{
2668 struct tb_property_dir *dir, *network_dir;
2669 struct tb_property *p;
2670
2671 dir = tb_property_parse_dir(root_directory, ARRAY_SIZE(root_directory));
2672 KUNIT_ASSERT_NOT_NULL(test, dir);
2673
2674 p = tb_property_find(dir, "foo", TB_PROPERTY_TYPE_TEXT);
2675 KUNIT_ASSERT_NULL(test, p);
2676
2677 p = tb_property_find(dir, "vendorid", TB_PROPERTY_TYPE_TEXT);
2678 KUNIT_ASSERT_NOT_NULL(test, p);
2679 KUNIT_EXPECT_STREQ(test, p->value.text, "Apple Inc.");
2680
2681 p = tb_property_find(dir, "vendorid", TB_PROPERTY_TYPE_VALUE);
2682 KUNIT_ASSERT_NOT_NULL(test, p);
2683 KUNIT_EXPECT_EQ(test, p->value.immediate, 0xa27);
2684
2685 p = tb_property_find(dir, "deviceid", TB_PROPERTY_TYPE_TEXT);
2686 KUNIT_ASSERT_NOT_NULL(test, p);
2687 KUNIT_EXPECT_STREQ(test, p->value.text, "Macintosh");
2688
2689 p = tb_property_find(dir, "deviceid", TB_PROPERTY_TYPE_VALUE);
2690 KUNIT_ASSERT_NOT_NULL(test, p);
2691 KUNIT_EXPECT_EQ(test, p->value.immediate, 0xa);
2692
2693 p = tb_property_find(dir, "missing", TB_PROPERTY_TYPE_DIRECTORY);
2694 KUNIT_ASSERT_NULL(test, p);
2695
2696 p = tb_property_find(dir, "network", TB_PROPERTY_TYPE_DIRECTORY);
2697 KUNIT_ASSERT_NOT_NULL(test, p);
2698
2699 network_dir = p->value.dir;
2700 KUNIT_EXPECT_TRUE(test, uuid_equal(network_dir->uuid, &network_dir_uuid));
2701
2702 p = tb_property_find(network_dir, "prtcid", TB_PROPERTY_TYPE_VALUE);
2703 KUNIT_ASSERT_NOT_NULL(test, p);
2704 KUNIT_EXPECT_EQ(test, p->value.immediate, 0x1);
2705
2706 p = tb_property_find(network_dir, "prtcvers", TB_PROPERTY_TYPE_VALUE);
2707 KUNIT_ASSERT_NOT_NULL(test, p);
2708 KUNIT_EXPECT_EQ(test, p->value.immediate, 0x1);
2709
2710 p = tb_property_find(network_dir, "prtcrevs", TB_PROPERTY_TYPE_VALUE);
2711 KUNIT_ASSERT_NOT_NULL(test, p);
2712 KUNIT_EXPECT_EQ(test, p->value.immediate, 0x1);
2713
2714 p = tb_property_find(network_dir, "prtcstns", TB_PROPERTY_TYPE_VALUE);
2715 KUNIT_ASSERT_NOT_NULL(test, p);
2716 KUNIT_EXPECT_EQ(test, p->value.immediate, 0x0);
2717
2718 p = tb_property_find(network_dir, "deviceid", TB_PROPERTY_TYPE_VALUE);
2719 KUNIT_EXPECT_TRUE(test, !p);
2720 p = tb_property_find(network_dir, "deviceid", TB_PROPERTY_TYPE_TEXT);
2721 KUNIT_EXPECT_TRUE(test, !p);
2722
2723 tb_property_free_dir(dir);
2724}
2725
2726static void tb_test_property_format(struct kunit *test)
2727{
2728 struct tb_property_dir *dir;
2729 ssize_t block_len;
2730 u32 *block;
2731 int ret, i;
2732
2733 dir = tb_property_parse_dir(root_directory, ARRAY_SIZE(root_directory));
2734 KUNIT_ASSERT_NOT_NULL(test, dir);
2735
2736 ret = tb_property_format_dir(dir, NULL, 0);
2737 KUNIT_ASSERT_EQ(test, ret, ARRAY_SIZE(root_directory));
2738
2739 block_len = ret;
2740
2741 block = kunit_kzalloc(test, block_len * sizeof(u32), GFP_KERNEL);
2742 KUNIT_ASSERT_NOT_NULL(test, block);
2743
2744 ret = tb_property_format_dir(dir, block, block_len);
2745 KUNIT_EXPECT_EQ(test, ret, 0);
2746
2747 for (i = 0; i < ARRAY_SIZE(root_directory); i++)
2748 KUNIT_EXPECT_EQ(test, root_directory[i], block[i]);
2749
2750 tb_property_free_dir(dir);
2751}
2752
2753static void compare_dirs(struct kunit *test, struct tb_property_dir *d1,
2754 struct tb_property_dir *d2)
2755{
2756 struct tb_property *p1, *p2, *tmp;
2757 int n1, n2, i;
2758
2759 if (d1->uuid) {
2760 KUNIT_ASSERT_NOT_NULL(test, d2->uuid);
2761 KUNIT_ASSERT_TRUE(test, uuid_equal(d1->uuid, d2->uuid));
2762 } else {
2763 KUNIT_ASSERT_NULL(test, d2->uuid);
2764 }
2765
2766 n1 = 0;
2767 tb_property_for_each(d1, tmp)
2768 n1++;
2769 KUNIT_ASSERT_NE(test, n1, 0);
2770
2771 n2 = 0;
2772 tb_property_for_each(d2, tmp)
2773 n2++;
2774 KUNIT_ASSERT_NE(test, n2, 0);
2775
2776 KUNIT_ASSERT_EQ(test, n1, n2);
2777
2778 p1 = NULL;
2779 p2 = NULL;
2780 for (i = 0; i < n1; i++) {
2781 p1 = tb_property_get_next(d1, p1);
2782 KUNIT_ASSERT_NOT_NULL(test, p1);
2783 p2 = tb_property_get_next(d2, p2);
2784 KUNIT_ASSERT_NOT_NULL(test, p2);
2785
2786 KUNIT_ASSERT_STREQ(test, &p1->key[0], &p2->key[0]);
2787 KUNIT_ASSERT_EQ(test, p1->type, p2->type);
2788 KUNIT_ASSERT_EQ(test, p1->length, p2->length);
2789
2790 switch (p1->type) {
2791 case TB_PROPERTY_TYPE_DIRECTORY:
2792 KUNIT_ASSERT_NOT_NULL(test, p1->value.dir);
2793 KUNIT_ASSERT_NOT_NULL(test, p2->value.dir);
2794 compare_dirs(test, p1->value.dir, p2->value.dir);
2795 break;
2796
2797 case TB_PROPERTY_TYPE_DATA:
2798 KUNIT_ASSERT_NOT_NULL(test, p1->value.data);
2799 KUNIT_ASSERT_NOT_NULL(test, p2->value.data);
2800 KUNIT_ASSERT_TRUE(test,
2801 !memcmp(p1->value.data, p2->value.data,
2802 p1->length * 4)
2803 );
2804 break;
2805
2806 case TB_PROPERTY_TYPE_TEXT:
2807 KUNIT_ASSERT_NOT_NULL(test, p1->value.text);
2808 KUNIT_ASSERT_NOT_NULL(test, p2->value.text);
2809 KUNIT_ASSERT_STREQ(test, p1->value.text, p2->value.text);
2810 break;
2811
2812 case TB_PROPERTY_TYPE_VALUE:
2813 KUNIT_ASSERT_EQ(test, p1->value.immediate,
2814 p2->value.immediate);
2815 break;
2816 default:
2817 KUNIT_FAIL(test, "unexpected property type");
2818 break;
2819 }
2820 }
2821}
2822
2823static void tb_test_property_copy(struct kunit *test)
2824{
2825 struct tb_property_dir *src, *dst;
2826 u32 *block;
2827 int ret, i;
2828
2829 src = tb_property_parse_dir(root_directory, ARRAY_SIZE(root_directory));
2830 KUNIT_ASSERT_NOT_NULL(test, src);
2831
2832 dst = tb_property_copy_dir(src);
2833 KUNIT_ASSERT_NOT_NULL(test, dst);
2834
2835 /* Compare the structures */
2836 compare_dirs(test, src, dst);
2837
2838 /* Compare the resulting property block */
2839 ret = tb_property_format_dir(dst, NULL, 0);
2840 KUNIT_ASSERT_EQ(test, ret, ARRAY_SIZE(root_directory));
2841
2842 block = kunit_kzalloc(test, sizeof(root_directory), GFP_KERNEL);
2843 KUNIT_ASSERT_NOT_NULL(test, block);
2844
2845 ret = tb_property_format_dir(dst, block, ARRAY_SIZE(root_directory));
2846 KUNIT_EXPECT_TRUE(test, !ret);
2847
2848 for (i = 0; i < ARRAY_SIZE(root_directory); i++)
2849 KUNIT_EXPECT_EQ(test, root_directory[i], block[i]);
2850
2851 tb_property_free_dir(dst);
2852 tb_property_free_dir(src);
2853}
2854
2855static struct kunit_case tb_test_cases[] = {
2856 KUNIT_CASE(tb_test_path_basic),
2857 KUNIT_CASE(tb_test_path_not_connected_walk),
2858 KUNIT_CASE(tb_test_path_single_hop_walk),
2859 KUNIT_CASE(tb_test_path_daisy_chain_walk),
2860 KUNIT_CASE(tb_test_path_simple_tree_walk),
2861 KUNIT_CASE(tb_test_path_complex_tree_walk),
2862 KUNIT_CASE(tb_test_path_max_length_walk),
2863 KUNIT_CASE(tb_test_path_not_connected),
2864 KUNIT_CASE(tb_test_path_not_bonded_lane0),
2865 KUNIT_CASE(tb_test_path_not_bonded_lane1),
2866 KUNIT_CASE(tb_test_path_not_bonded_lane1_chain),
2867 KUNIT_CASE(tb_test_path_not_bonded_lane1_chain_reverse),
2868 KUNIT_CASE(tb_test_path_mixed_chain),
2869 KUNIT_CASE(tb_test_path_mixed_chain_reverse),
2870 KUNIT_CASE(tb_test_tunnel_pcie),
2871 KUNIT_CASE(tb_test_tunnel_dp),
2872 KUNIT_CASE(tb_test_tunnel_dp_chain),
2873 KUNIT_CASE(tb_test_tunnel_dp_tree),
2874 KUNIT_CASE(tb_test_tunnel_dp_max_length),
2875 KUNIT_CASE(tb_test_tunnel_3dp),
2876 KUNIT_CASE(tb_test_tunnel_port_on_path),
2877 KUNIT_CASE(tb_test_tunnel_usb3),
2878 KUNIT_CASE(tb_test_tunnel_dma),
2879 KUNIT_CASE(tb_test_tunnel_dma_rx),
2880 KUNIT_CASE(tb_test_tunnel_dma_tx),
2881 KUNIT_CASE(tb_test_tunnel_dma_chain),
2882 KUNIT_CASE(tb_test_tunnel_dma_match),
2883 KUNIT_CASE(tb_test_credit_alloc_legacy_not_bonded),
2884 KUNIT_CASE(tb_test_credit_alloc_legacy_bonded),
2885 KUNIT_CASE(tb_test_credit_alloc_pcie),
2886 KUNIT_CASE(tb_test_credit_alloc_without_dp),
2887 KUNIT_CASE(tb_test_credit_alloc_dp),
2888 KUNIT_CASE(tb_test_credit_alloc_usb3),
2889 KUNIT_CASE(tb_test_credit_alloc_dma),
2890 KUNIT_CASE(tb_test_credit_alloc_dma_multiple),
2891 KUNIT_CASE(tb_test_credit_alloc_all),
2892 KUNIT_CASE(tb_test_property_parse),
2893 KUNIT_CASE(tb_test_property_format),
2894 KUNIT_CASE(tb_test_property_copy),
2895 { }
2896};
2897
2898static struct kunit_suite tb_test_suite = {
2899 .name = "thunderbolt",
2900 .test_cases = tb_test_cases,
2901};
2902
2903kunit_test_suite(tb_test_suite);
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * KUnit tests
4 *
5 * Copyright (C) 2020, Intel Corporation
6 * Author: Mika Westerberg <mika.westerberg@linux.intel.com>
7 */
8
9#include <kunit/test.h>
10#include <linux/idr.h>
11
12#include "tb.h"
13#include "tunnel.h"
14
15static int __ida_init(struct kunit_resource *res, void *context)
16{
17 struct ida *ida = context;
18
19 ida_init(ida);
20 res->data = ida;
21 return 0;
22}
23
24static void __ida_destroy(struct kunit_resource *res)
25{
26 struct ida *ida = res->data;
27
28 ida_destroy(ida);
29}
30
31static void kunit_ida_init(struct kunit *test, struct ida *ida)
32{
33 kunit_alloc_resource(test, __ida_init, __ida_destroy, GFP_KERNEL, ida);
34}
35
36static struct tb_switch *alloc_switch(struct kunit *test, u64 route,
37 u8 upstream_port, u8 max_port_number)
38{
39 struct tb_switch *sw;
40 size_t size;
41 int i;
42
43 sw = kunit_kzalloc(test, sizeof(*sw), GFP_KERNEL);
44 if (!sw)
45 return NULL;
46
47 sw->config.upstream_port_number = upstream_port;
48 sw->config.depth = tb_route_length(route);
49 sw->config.route_hi = upper_32_bits(route);
50 sw->config.route_lo = lower_32_bits(route);
51 sw->config.enabled = 0;
52 sw->config.max_port_number = max_port_number;
53
54 size = (sw->config.max_port_number + 1) * sizeof(*sw->ports);
55 sw->ports = kunit_kzalloc(test, size, GFP_KERNEL);
56 if (!sw->ports)
57 return NULL;
58
59 for (i = 0; i <= sw->config.max_port_number; i++) {
60 sw->ports[i].sw = sw;
61 sw->ports[i].port = i;
62 sw->ports[i].config.port_number = i;
63 if (i) {
64 kunit_ida_init(test, &sw->ports[i].in_hopids);
65 kunit_ida_init(test, &sw->ports[i].out_hopids);
66 }
67 }
68
69 return sw;
70}
71
72static struct tb_switch *alloc_host(struct kunit *test)
73{
74 struct tb_switch *sw;
75
76 sw = alloc_switch(test, 0, 7, 13);
77 if (!sw)
78 return NULL;
79
80 sw->config.vendor_id = 0x8086;
81 sw->config.device_id = 0x9a1b;
82
83 sw->ports[0].config.type = TB_TYPE_PORT;
84 sw->ports[0].config.max_in_hop_id = 7;
85 sw->ports[0].config.max_out_hop_id = 7;
86
87 sw->ports[1].config.type = TB_TYPE_PORT;
88 sw->ports[1].config.max_in_hop_id = 19;
89 sw->ports[1].config.max_out_hop_id = 19;
90 sw->ports[1].dual_link_port = &sw->ports[2];
91
92 sw->ports[2].config.type = TB_TYPE_PORT;
93 sw->ports[2].config.max_in_hop_id = 19;
94 sw->ports[2].config.max_out_hop_id = 19;
95 sw->ports[2].dual_link_port = &sw->ports[1];
96 sw->ports[2].link_nr = 1;
97
98 sw->ports[3].config.type = TB_TYPE_PORT;
99 sw->ports[3].config.max_in_hop_id = 19;
100 sw->ports[3].config.max_out_hop_id = 19;
101 sw->ports[3].dual_link_port = &sw->ports[4];
102
103 sw->ports[4].config.type = TB_TYPE_PORT;
104 sw->ports[4].config.max_in_hop_id = 19;
105 sw->ports[4].config.max_out_hop_id = 19;
106 sw->ports[4].dual_link_port = &sw->ports[3];
107 sw->ports[4].link_nr = 1;
108
109 sw->ports[5].config.type = TB_TYPE_DP_HDMI_IN;
110 sw->ports[5].config.max_in_hop_id = 9;
111 sw->ports[5].config.max_out_hop_id = 9;
112 sw->ports[5].cap_adap = -1;
113
114 sw->ports[6].config.type = TB_TYPE_DP_HDMI_IN;
115 sw->ports[6].config.max_in_hop_id = 9;
116 sw->ports[6].config.max_out_hop_id = 9;
117 sw->ports[6].cap_adap = -1;
118
119 sw->ports[7].config.type = TB_TYPE_NHI;
120 sw->ports[7].config.max_in_hop_id = 11;
121 sw->ports[7].config.max_out_hop_id = 11;
122
123 sw->ports[8].config.type = TB_TYPE_PCIE_DOWN;
124 sw->ports[8].config.max_in_hop_id = 8;
125 sw->ports[8].config.max_out_hop_id = 8;
126
127 sw->ports[9].config.type = TB_TYPE_PCIE_DOWN;
128 sw->ports[9].config.max_in_hop_id = 8;
129 sw->ports[9].config.max_out_hop_id = 8;
130
131 sw->ports[10].disabled = true;
132 sw->ports[11].disabled = true;
133
134 sw->ports[12].config.type = TB_TYPE_USB3_DOWN;
135 sw->ports[12].config.max_in_hop_id = 8;
136 sw->ports[12].config.max_out_hop_id = 8;
137
138 sw->ports[13].config.type = TB_TYPE_USB3_DOWN;
139 sw->ports[13].config.max_in_hop_id = 8;
140 sw->ports[13].config.max_out_hop_id = 8;
141
142 return sw;
143}
144
145static struct tb_switch *alloc_dev_default(struct kunit *test,
146 struct tb_switch *parent,
147 u64 route, bool bonded)
148{
149 struct tb_port *port, *upstream_port;
150 struct tb_switch *sw;
151
152 sw = alloc_switch(test, route, 1, 19);
153 if (!sw)
154 return NULL;
155
156 sw->config.vendor_id = 0x8086;
157 sw->config.device_id = 0x15ef;
158
159 sw->ports[0].config.type = TB_TYPE_PORT;
160 sw->ports[0].config.max_in_hop_id = 8;
161 sw->ports[0].config.max_out_hop_id = 8;
162
163 sw->ports[1].config.type = TB_TYPE_PORT;
164 sw->ports[1].config.max_in_hop_id = 19;
165 sw->ports[1].config.max_out_hop_id = 19;
166 sw->ports[1].dual_link_port = &sw->ports[2];
167
168 sw->ports[2].config.type = TB_TYPE_PORT;
169 sw->ports[2].config.max_in_hop_id = 19;
170 sw->ports[2].config.max_out_hop_id = 19;
171 sw->ports[2].dual_link_port = &sw->ports[1];
172 sw->ports[2].link_nr = 1;
173
174 sw->ports[3].config.type = TB_TYPE_PORT;
175 sw->ports[3].config.max_in_hop_id = 19;
176 sw->ports[3].config.max_out_hop_id = 19;
177 sw->ports[3].dual_link_port = &sw->ports[4];
178
179 sw->ports[4].config.type = TB_TYPE_PORT;
180 sw->ports[4].config.max_in_hop_id = 19;
181 sw->ports[4].config.max_out_hop_id = 19;
182 sw->ports[4].dual_link_port = &sw->ports[3];
183 sw->ports[4].link_nr = 1;
184
185 sw->ports[5].config.type = TB_TYPE_PORT;
186 sw->ports[5].config.max_in_hop_id = 19;
187 sw->ports[5].config.max_out_hop_id = 19;
188 sw->ports[5].dual_link_port = &sw->ports[6];
189
190 sw->ports[6].config.type = TB_TYPE_PORT;
191 sw->ports[6].config.max_in_hop_id = 19;
192 sw->ports[6].config.max_out_hop_id = 19;
193 sw->ports[6].dual_link_port = &sw->ports[5];
194 sw->ports[6].link_nr = 1;
195
196 sw->ports[7].config.type = TB_TYPE_PORT;
197 sw->ports[7].config.max_in_hop_id = 19;
198 sw->ports[7].config.max_out_hop_id = 19;
199 sw->ports[7].dual_link_port = &sw->ports[8];
200
201 sw->ports[8].config.type = TB_TYPE_PORT;
202 sw->ports[8].config.max_in_hop_id = 19;
203 sw->ports[8].config.max_out_hop_id = 19;
204 sw->ports[8].dual_link_port = &sw->ports[7];
205 sw->ports[8].link_nr = 1;
206
207 sw->ports[9].config.type = TB_TYPE_PCIE_UP;
208 sw->ports[9].config.max_in_hop_id = 8;
209 sw->ports[9].config.max_out_hop_id = 8;
210
211 sw->ports[10].config.type = TB_TYPE_PCIE_DOWN;
212 sw->ports[10].config.max_in_hop_id = 8;
213 sw->ports[10].config.max_out_hop_id = 8;
214
215 sw->ports[11].config.type = TB_TYPE_PCIE_DOWN;
216 sw->ports[11].config.max_in_hop_id = 8;
217 sw->ports[11].config.max_out_hop_id = 8;
218
219 sw->ports[12].config.type = TB_TYPE_PCIE_DOWN;
220 sw->ports[12].config.max_in_hop_id = 8;
221 sw->ports[12].config.max_out_hop_id = 8;
222
223 sw->ports[13].config.type = TB_TYPE_DP_HDMI_OUT;
224 sw->ports[13].config.max_in_hop_id = 9;
225 sw->ports[13].config.max_out_hop_id = 9;
226 sw->ports[13].cap_adap = -1;
227
228 sw->ports[14].config.type = TB_TYPE_DP_HDMI_OUT;
229 sw->ports[14].config.max_in_hop_id = 9;
230 sw->ports[14].config.max_out_hop_id = 9;
231 sw->ports[14].cap_adap = -1;
232
233 sw->ports[15].disabled = true;
234
235 sw->ports[16].config.type = TB_TYPE_USB3_UP;
236 sw->ports[16].config.max_in_hop_id = 8;
237 sw->ports[16].config.max_out_hop_id = 8;
238
239 sw->ports[17].config.type = TB_TYPE_USB3_DOWN;
240 sw->ports[17].config.max_in_hop_id = 8;
241 sw->ports[17].config.max_out_hop_id = 8;
242
243 sw->ports[18].config.type = TB_TYPE_USB3_DOWN;
244 sw->ports[18].config.max_in_hop_id = 8;
245 sw->ports[18].config.max_out_hop_id = 8;
246
247 sw->ports[19].config.type = TB_TYPE_USB3_DOWN;
248 sw->ports[19].config.max_in_hop_id = 8;
249 sw->ports[19].config.max_out_hop_id = 8;
250
251 if (!parent)
252 return sw;
253
254 /* Link them */
255 upstream_port = tb_upstream_port(sw);
256 port = tb_port_at(route, parent);
257 port->remote = upstream_port;
258 upstream_port->remote = port;
259 if (port->dual_link_port && upstream_port->dual_link_port) {
260 port->dual_link_port->remote = upstream_port->dual_link_port;
261 upstream_port->dual_link_port->remote = port->dual_link_port;
262 }
263
264 if (bonded) {
265 /* Bonding is used */
266 port->bonded = true;
267 port->dual_link_port->bonded = true;
268 upstream_port->bonded = true;
269 upstream_port->dual_link_port->bonded = true;
270 }
271
272 return sw;
273}
274
275static struct tb_switch *alloc_dev_with_dpin(struct kunit *test,
276 struct tb_switch *parent,
277 u64 route, bool bonded)
278{
279 struct tb_switch *sw;
280
281 sw = alloc_dev_default(test, parent, route, bonded);
282 if (!sw)
283 return NULL;
284
285 sw->ports[13].config.type = TB_TYPE_DP_HDMI_IN;
286 sw->ports[13].config.max_in_hop_id = 9;
287 sw->ports[13].config.max_out_hop_id = 9;
288
289 sw->ports[14].config.type = TB_TYPE_DP_HDMI_IN;
290 sw->ports[14].config.max_in_hop_id = 9;
291 sw->ports[14].config.max_out_hop_id = 9;
292
293 return sw;
294}
295
296static void tb_test_path_basic(struct kunit *test)
297{
298 struct tb_port *src_port, *dst_port, *p;
299 struct tb_switch *host;
300
301 host = alloc_host(test);
302
303 src_port = &host->ports[5];
304 dst_port = src_port;
305
306 p = tb_next_port_on_path(src_port, dst_port, NULL);
307 KUNIT_EXPECT_PTR_EQ(test, p, dst_port);
308
309 p = tb_next_port_on_path(src_port, dst_port, p);
310 KUNIT_EXPECT_TRUE(test, !p);
311}
312
313static void tb_test_path_not_connected_walk(struct kunit *test)
314{
315 struct tb_port *src_port, *dst_port, *p;
316 struct tb_switch *host, *dev;
317
318 host = alloc_host(test);
319 /* No connection between host and dev */
320 dev = alloc_dev_default(test, NULL, 3, true);
321
322 src_port = &host->ports[12];
323 dst_port = &dev->ports[16];
324
325 p = tb_next_port_on_path(src_port, dst_port, NULL);
326 KUNIT_EXPECT_PTR_EQ(test, p, src_port);
327
328 p = tb_next_port_on_path(src_port, dst_port, p);
329 KUNIT_EXPECT_PTR_EQ(test, p, &host->ports[3]);
330
331 p = tb_next_port_on_path(src_port, dst_port, p);
332 KUNIT_EXPECT_TRUE(test, !p);
333
334 /* Other direction */
335
336 p = tb_next_port_on_path(dst_port, src_port, NULL);
337 KUNIT_EXPECT_PTR_EQ(test, p, dst_port);
338
339 p = tb_next_port_on_path(dst_port, src_port, p);
340 KUNIT_EXPECT_PTR_EQ(test, p, &dev->ports[1]);
341
342 p = tb_next_port_on_path(dst_port, src_port, p);
343 KUNIT_EXPECT_TRUE(test, !p);
344}
345
346struct port_expectation {
347 u64 route;
348 u8 port;
349 enum tb_port_type type;
350};
351
352static void tb_test_path_single_hop_walk(struct kunit *test)
353{
354 /*
355 * Walks from Host PCIe downstream port to Device #1 PCIe
356 * upstream port.
357 *
358 * [Host]
359 * 1 |
360 * 1 |
361 * [Device]
362 */
363 static const struct port_expectation test_data[] = {
364 { .route = 0x0, .port = 8, .type = TB_TYPE_PCIE_DOWN },
365 { .route = 0x0, .port = 1, .type = TB_TYPE_PORT },
366 { .route = 0x1, .port = 1, .type = TB_TYPE_PORT },
367 { .route = 0x1, .port = 9, .type = TB_TYPE_PCIE_UP },
368 };
369 struct tb_port *src_port, *dst_port, *p;
370 struct tb_switch *host, *dev;
371 int i;
372
373 host = alloc_host(test);
374 dev = alloc_dev_default(test, host, 1, true);
375
376 src_port = &host->ports[8];
377 dst_port = &dev->ports[9];
378
379 /* Walk both directions */
380
381 i = 0;
382 tb_for_each_port_on_path(src_port, dst_port, p) {
383 KUNIT_EXPECT_TRUE(test, i < ARRAY_SIZE(test_data));
384 KUNIT_EXPECT_EQ(test, tb_route(p->sw), test_data[i].route);
385 KUNIT_EXPECT_EQ(test, p->port, test_data[i].port);
386 KUNIT_EXPECT_EQ(test, (enum tb_port_type)p->config.type,
387 test_data[i].type);
388 i++;
389 }
390
391 KUNIT_EXPECT_EQ(test, i, (int)ARRAY_SIZE(test_data));
392
393 i = ARRAY_SIZE(test_data) - 1;
394 tb_for_each_port_on_path(dst_port, src_port, p) {
395 KUNIT_EXPECT_TRUE(test, i < ARRAY_SIZE(test_data));
396 KUNIT_EXPECT_EQ(test, tb_route(p->sw), test_data[i].route);
397 KUNIT_EXPECT_EQ(test, p->port, test_data[i].port);
398 KUNIT_EXPECT_EQ(test, (enum tb_port_type)p->config.type,
399 test_data[i].type);
400 i--;
401 }
402
403 KUNIT_EXPECT_EQ(test, i, -1);
404}
405
406static void tb_test_path_daisy_chain_walk(struct kunit *test)
407{
408 /*
409 * Walks from Host DP IN to Device #2 DP OUT.
410 *
411 * [Host]
412 * 1 |
413 * 1 |
414 * [Device #1]
415 * 3 /
416 * 1 /
417 * [Device #2]
418 */
419 static const struct port_expectation test_data[] = {
420 { .route = 0x0, .port = 5, .type = TB_TYPE_DP_HDMI_IN },
421 { .route = 0x0, .port = 1, .type = TB_TYPE_PORT },
422 { .route = 0x1, .port = 1, .type = TB_TYPE_PORT },
423 { .route = 0x1, .port = 3, .type = TB_TYPE_PORT },
424 { .route = 0x301, .port = 1, .type = TB_TYPE_PORT },
425 { .route = 0x301, .port = 13, .type = TB_TYPE_DP_HDMI_OUT },
426 };
427 struct tb_port *src_port, *dst_port, *p;
428 struct tb_switch *host, *dev1, *dev2;
429 int i;
430
431 host = alloc_host(test);
432 dev1 = alloc_dev_default(test, host, 0x1, true);
433 dev2 = alloc_dev_default(test, dev1, 0x301, true);
434
435 src_port = &host->ports[5];
436 dst_port = &dev2->ports[13];
437
438 /* Walk both directions */
439
440 i = 0;
441 tb_for_each_port_on_path(src_port, dst_port, p) {
442 KUNIT_EXPECT_TRUE(test, i < ARRAY_SIZE(test_data));
443 KUNIT_EXPECT_EQ(test, tb_route(p->sw), test_data[i].route);
444 KUNIT_EXPECT_EQ(test, p->port, test_data[i].port);
445 KUNIT_EXPECT_EQ(test, (enum tb_port_type)p->config.type,
446 test_data[i].type);
447 i++;
448 }
449
450 KUNIT_EXPECT_EQ(test, i, (int)ARRAY_SIZE(test_data));
451
452 i = ARRAY_SIZE(test_data) - 1;
453 tb_for_each_port_on_path(dst_port, src_port, p) {
454 KUNIT_EXPECT_TRUE(test, i < ARRAY_SIZE(test_data));
455 KUNIT_EXPECT_EQ(test, tb_route(p->sw), test_data[i].route);
456 KUNIT_EXPECT_EQ(test, p->port, test_data[i].port);
457 KUNIT_EXPECT_EQ(test, (enum tb_port_type)p->config.type,
458 test_data[i].type);
459 i--;
460 }
461
462 KUNIT_EXPECT_EQ(test, i, -1);
463}
464
465static void tb_test_path_simple_tree_walk(struct kunit *test)
466{
467 /*
468 * Walks from Host DP IN to Device #3 DP OUT.
469 *
470 * [Host]
471 * 1 |
472 * 1 |
473 * [Device #1]
474 * 3 / | 5 \ 7
475 * 1 / | \ 1
476 * [Device #2] | [Device #4]
477 * | 1
478 * [Device #3]
479 */
480 static const struct port_expectation test_data[] = {
481 { .route = 0x0, .port = 5, .type = TB_TYPE_DP_HDMI_IN },
482 { .route = 0x0, .port = 1, .type = TB_TYPE_PORT },
483 { .route = 0x1, .port = 1, .type = TB_TYPE_PORT },
484 { .route = 0x1, .port = 5, .type = TB_TYPE_PORT },
485 { .route = 0x501, .port = 1, .type = TB_TYPE_PORT },
486 { .route = 0x501, .port = 13, .type = TB_TYPE_DP_HDMI_OUT },
487 };
488 struct tb_port *src_port, *dst_port, *p;
489 struct tb_switch *host, *dev1, *dev3;
490 int i;
491
492 host = alloc_host(test);
493 dev1 = alloc_dev_default(test, host, 0x1, true);
494 alloc_dev_default(test, dev1, 0x301, true);
495 dev3 = alloc_dev_default(test, dev1, 0x501, true);
496 alloc_dev_default(test, dev1, 0x701, true);
497
498 src_port = &host->ports[5];
499 dst_port = &dev3->ports[13];
500
501 /* Walk both directions */
502
503 i = 0;
504 tb_for_each_port_on_path(src_port, dst_port, p) {
505 KUNIT_EXPECT_TRUE(test, i < ARRAY_SIZE(test_data));
506 KUNIT_EXPECT_EQ(test, tb_route(p->sw), test_data[i].route);
507 KUNIT_EXPECT_EQ(test, p->port, test_data[i].port);
508 KUNIT_EXPECT_EQ(test, (enum tb_port_type)p->config.type,
509 test_data[i].type);
510 i++;
511 }
512
513 KUNIT_EXPECT_EQ(test, i, (int)ARRAY_SIZE(test_data));
514
515 i = ARRAY_SIZE(test_data) - 1;
516 tb_for_each_port_on_path(dst_port, src_port, p) {
517 KUNIT_EXPECT_TRUE(test, i < ARRAY_SIZE(test_data));
518 KUNIT_EXPECT_EQ(test, tb_route(p->sw), test_data[i].route);
519 KUNIT_EXPECT_EQ(test, p->port, test_data[i].port);
520 KUNIT_EXPECT_EQ(test, (enum tb_port_type)p->config.type,
521 test_data[i].type);
522 i--;
523 }
524
525 KUNIT_EXPECT_EQ(test, i, -1);
526}
527
528static void tb_test_path_complex_tree_walk(struct kunit *test)
529{
530 /*
531 * Walks from Device #3 DP IN to Device #9 DP OUT.
532 *
533 * [Host]
534 * 1 |
535 * 1 |
536 * [Device #1]
537 * 3 / | 5 \ 7
538 * 1 / | \ 1
539 * [Device #2] | [Device #5]
540 * 5 | | 1 \ 7
541 * 1 | [Device #4] \ 1
542 * [Device #3] [Device #6]
543 * 3 /
544 * 1 /
545 * [Device #7]
546 * 3 / | 5
547 * 1 / |
548 * [Device #8] | 1
549 * [Device #9]
550 */
551 static const struct port_expectation test_data[] = {
552 { .route = 0x50301, .port = 13, .type = TB_TYPE_DP_HDMI_IN },
553 { .route = 0x50301, .port = 1, .type = TB_TYPE_PORT },
554 { .route = 0x301, .port = 5, .type = TB_TYPE_PORT },
555 { .route = 0x301, .port = 1, .type = TB_TYPE_PORT },
556 { .route = 0x1, .port = 3, .type = TB_TYPE_PORT },
557 { .route = 0x1, .port = 7, .type = TB_TYPE_PORT },
558 { .route = 0x701, .port = 1, .type = TB_TYPE_PORT },
559 { .route = 0x701, .port = 7, .type = TB_TYPE_PORT },
560 { .route = 0x70701, .port = 1, .type = TB_TYPE_PORT },
561 { .route = 0x70701, .port = 3, .type = TB_TYPE_PORT },
562 { .route = 0x3070701, .port = 1, .type = TB_TYPE_PORT },
563 { .route = 0x3070701, .port = 5, .type = TB_TYPE_PORT },
564 { .route = 0x503070701, .port = 1, .type = TB_TYPE_PORT },
565 { .route = 0x503070701, .port = 14, .type = TB_TYPE_DP_HDMI_OUT },
566 };
567 struct tb_switch *host, *dev1, *dev2, *dev3, *dev5, *dev6, *dev7, *dev9;
568 struct tb_port *src_port, *dst_port, *p;
569 int i;
570
571 host = alloc_host(test);
572 dev1 = alloc_dev_default(test, host, 0x1, true);
573 dev2 = alloc_dev_default(test, dev1, 0x301, true);
574 dev3 = alloc_dev_with_dpin(test, dev2, 0x50301, true);
575 alloc_dev_default(test, dev1, 0x501, true);
576 dev5 = alloc_dev_default(test, dev1, 0x701, true);
577 dev6 = alloc_dev_default(test, dev5, 0x70701, true);
578 dev7 = alloc_dev_default(test, dev6, 0x3070701, true);
579 alloc_dev_default(test, dev7, 0x303070701, true);
580 dev9 = alloc_dev_default(test, dev7, 0x503070701, true);
581
582 src_port = &dev3->ports[13];
583 dst_port = &dev9->ports[14];
584
585 /* Walk both directions */
586
587 i = 0;
588 tb_for_each_port_on_path(src_port, dst_port, p) {
589 KUNIT_EXPECT_TRUE(test, i < ARRAY_SIZE(test_data));
590 KUNIT_EXPECT_EQ(test, tb_route(p->sw), test_data[i].route);
591 KUNIT_EXPECT_EQ(test, p->port, test_data[i].port);
592 KUNIT_EXPECT_EQ(test, (enum tb_port_type)p->config.type,
593 test_data[i].type);
594 i++;
595 }
596
597 KUNIT_EXPECT_EQ(test, i, (int)ARRAY_SIZE(test_data));
598
599 i = ARRAY_SIZE(test_data) - 1;
600 tb_for_each_port_on_path(dst_port, src_port, p) {
601 KUNIT_EXPECT_TRUE(test, i < ARRAY_SIZE(test_data));
602 KUNIT_EXPECT_EQ(test, tb_route(p->sw), test_data[i].route);
603 KUNIT_EXPECT_EQ(test, p->port, test_data[i].port);
604 KUNIT_EXPECT_EQ(test, (enum tb_port_type)p->config.type,
605 test_data[i].type);
606 i--;
607 }
608
609 KUNIT_EXPECT_EQ(test, i, -1);
610}
611
612static void tb_test_path_max_length_walk(struct kunit *test)
613{
614 struct tb_switch *host, *dev1, *dev2, *dev3, *dev4, *dev5, *dev6;
615 struct tb_switch *dev7, *dev8, *dev9, *dev10, *dev11, *dev12;
616 struct tb_port *src_port, *dst_port, *p;
617 int i;
618
619 /*
620 * Walks from Device #6 DP IN to Device #12 DP OUT.
621 *
622 * [Host]
623 * 1 / \ 3
624 * 1 / \ 1
625 * [Device #1] [Device #7]
626 * 3 | | 3
627 * 1 | | 1
628 * [Device #2] [Device #8]
629 * 3 | | 3
630 * 1 | | 1
631 * [Device #3] [Device #9]
632 * 3 | | 3
633 * 1 | | 1
634 * [Device #4] [Device #10]
635 * 3 | | 3
636 * 1 | | 1
637 * [Device #5] [Device #11]
638 * 3 | | 3
639 * 1 | | 1
640 * [Device #6] [Device #12]
641 */
642 static const struct port_expectation test_data[] = {
643 { .route = 0x30303030301, .port = 13, .type = TB_TYPE_DP_HDMI_IN },
644 { .route = 0x30303030301, .port = 1, .type = TB_TYPE_PORT },
645 { .route = 0x303030301, .port = 3, .type = TB_TYPE_PORT },
646 { .route = 0x303030301, .port = 1, .type = TB_TYPE_PORT },
647 { .route = 0x3030301, .port = 3, .type = TB_TYPE_PORT },
648 { .route = 0x3030301, .port = 1, .type = TB_TYPE_PORT },
649 { .route = 0x30301, .port = 3, .type = TB_TYPE_PORT },
650 { .route = 0x30301, .port = 1, .type = TB_TYPE_PORT },
651 { .route = 0x301, .port = 3, .type = TB_TYPE_PORT },
652 { .route = 0x301, .port = 1, .type = TB_TYPE_PORT },
653 { .route = 0x1, .port = 3, .type = TB_TYPE_PORT },
654 { .route = 0x1, .port = 1, .type = TB_TYPE_PORT },
655 { .route = 0x0, .port = 1, .type = TB_TYPE_PORT },
656 { .route = 0x0, .port = 3, .type = TB_TYPE_PORT },
657 { .route = 0x3, .port = 1, .type = TB_TYPE_PORT },
658 { .route = 0x3, .port = 3, .type = TB_TYPE_PORT },
659 { .route = 0x303, .port = 1, .type = TB_TYPE_PORT },
660 { .route = 0x303, .port = 3, .type = TB_TYPE_PORT },
661 { .route = 0x30303, .port = 1, .type = TB_TYPE_PORT },
662 { .route = 0x30303, .port = 3, .type = TB_TYPE_PORT },
663 { .route = 0x3030303, .port = 1, .type = TB_TYPE_PORT },
664 { .route = 0x3030303, .port = 3, .type = TB_TYPE_PORT },
665 { .route = 0x303030303, .port = 1, .type = TB_TYPE_PORT },
666 { .route = 0x303030303, .port = 3, .type = TB_TYPE_PORT },
667 { .route = 0x30303030303, .port = 1, .type = TB_TYPE_PORT },
668 { .route = 0x30303030303, .port = 13, .type = TB_TYPE_DP_HDMI_OUT },
669 };
670
671 host = alloc_host(test);
672 dev1 = alloc_dev_default(test, host, 0x1, true);
673 dev2 = alloc_dev_default(test, dev1, 0x301, true);
674 dev3 = alloc_dev_default(test, dev2, 0x30301, true);
675 dev4 = alloc_dev_default(test, dev3, 0x3030301, true);
676 dev5 = alloc_dev_default(test, dev4, 0x303030301, true);
677 dev6 = alloc_dev_with_dpin(test, dev5, 0x30303030301, true);
678 dev7 = alloc_dev_default(test, host, 0x3, true);
679 dev8 = alloc_dev_default(test, dev7, 0x303, true);
680 dev9 = alloc_dev_default(test, dev8, 0x30303, true);
681 dev10 = alloc_dev_default(test, dev9, 0x3030303, true);
682 dev11 = alloc_dev_default(test, dev10, 0x303030303, true);
683 dev12 = alloc_dev_default(test, dev11, 0x30303030303, true);
684
685 src_port = &dev6->ports[13];
686 dst_port = &dev12->ports[13];
687
688 /* Walk both directions */
689
690 i = 0;
691 tb_for_each_port_on_path(src_port, dst_port, p) {
692 KUNIT_EXPECT_TRUE(test, i < ARRAY_SIZE(test_data));
693 KUNIT_EXPECT_EQ(test, tb_route(p->sw), test_data[i].route);
694 KUNIT_EXPECT_EQ(test, p->port, test_data[i].port);
695 KUNIT_EXPECT_EQ(test, (enum tb_port_type)p->config.type,
696 test_data[i].type);
697 i++;
698 }
699
700 KUNIT_EXPECT_EQ(test, i, (int)ARRAY_SIZE(test_data));
701
702 i = ARRAY_SIZE(test_data) - 1;
703 tb_for_each_port_on_path(dst_port, src_port, p) {
704 KUNIT_EXPECT_TRUE(test, i < ARRAY_SIZE(test_data));
705 KUNIT_EXPECT_EQ(test, tb_route(p->sw), test_data[i].route);
706 KUNIT_EXPECT_EQ(test, p->port, test_data[i].port);
707 KUNIT_EXPECT_EQ(test, (enum tb_port_type)p->config.type,
708 test_data[i].type);
709 i--;
710 }
711
712 KUNIT_EXPECT_EQ(test, i, -1);
713}
714
715static void tb_test_path_not_connected(struct kunit *test)
716{
717 struct tb_switch *host, *dev1, *dev2;
718 struct tb_port *down, *up;
719 struct tb_path *path;
720
721 host = alloc_host(test);
722 dev1 = alloc_dev_default(test, host, 0x3, false);
723 /* Not connected to anything */
724 dev2 = alloc_dev_default(test, NULL, 0x303, false);
725
726 down = &dev1->ports[10];
727 up = &dev2->ports[9];
728
729 path = tb_path_alloc(NULL, down, 8, up, 8, 0, "PCIe Down");
730 KUNIT_ASSERT_TRUE(test, path == NULL);
731 path = tb_path_alloc(NULL, down, 8, up, 8, 1, "PCIe Down");
732 KUNIT_ASSERT_TRUE(test, path == NULL);
733}
734
735struct hop_expectation {
736 u64 route;
737 u8 in_port;
738 enum tb_port_type in_type;
739 u8 out_port;
740 enum tb_port_type out_type;
741};
742
743static void tb_test_path_not_bonded_lane0(struct kunit *test)
744{
745 /*
746 * PCIe path from host to device using lane 0.
747 *
748 * [Host]
749 * 3 |: 4
750 * 1 |: 2
751 * [Device]
752 */
753 static const struct hop_expectation test_data[] = {
754 {
755 .route = 0x0,
756 .in_port = 9,
757 .in_type = TB_TYPE_PCIE_DOWN,
758 .out_port = 3,
759 .out_type = TB_TYPE_PORT,
760 },
761 {
762 .route = 0x3,
763 .in_port = 1,
764 .in_type = TB_TYPE_PORT,
765 .out_port = 9,
766 .out_type = TB_TYPE_PCIE_UP,
767 },
768 };
769 struct tb_switch *host, *dev;
770 struct tb_port *down, *up;
771 struct tb_path *path;
772 int i;
773
774 host = alloc_host(test);
775 dev = alloc_dev_default(test, host, 0x3, false);
776
777 down = &host->ports[9];
778 up = &dev->ports[9];
779
780 path = tb_path_alloc(NULL, down, 8, up, 8, 0, "PCIe Down");
781 KUNIT_ASSERT_TRUE(test, path != NULL);
782 KUNIT_ASSERT_EQ(test, path->path_length, (int)ARRAY_SIZE(test_data));
783 for (i = 0; i < ARRAY_SIZE(test_data); i++) {
784 const struct tb_port *in_port, *out_port;
785
786 in_port = path->hops[i].in_port;
787 out_port = path->hops[i].out_port;
788
789 KUNIT_EXPECT_EQ(test, tb_route(in_port->sw), test_data[i].route);
790 KUNIT_EXPECT_EQ(test, in_port->port, test_data[i].in_port);
791 KUNIT_EXPECT_EQ(test, (enum tb_port_type)in_port->config.type,
792 test_data[i].in_type);
793 KUNIT_EXPECT_EQ(test, tb_route(out_port->sw), test_data[i].route);
794 KUNIT_EXPECT_EQ(test, out_port->port, test_data[i].out_port);
795 KUNIT_EXPECT_EQ(test, (enum tb_port_type)out_port->config.type,
796 test_data[i].out_type);
797 }
798 tb_path_free(path);
799}
800
801static void tb_test_path_not_bonded_lane1(struct kunit *test)
802{
803 /*
804 * DP Video path from host to device using lane 1. Paths like
805 * these are only used with Thunderbolt 1 devices where lane
806 * bonding is not possible. USB4 specifically does not allow
807 * paths like this (you either use lane 0 where lane 1 is
808 * disabled or both lanes are bonded).
809 *
810 * [Host]
811 * 1 :| 2
812 * 1 :| 2
813 * [Device]
814 */
815 static const struct hop_expectation test_data[] = {
816 {
817 .route = 0x0,
818 .in_port = 5,
819 .in_type = TB_TYPE_DP_HDMI_IN,
820 .out_port = 2,
821 .out_type = TB_TYPE_PORT,
822 },
823 {
824 .route = 0x1,
825 .in_port = 2,
826 .in_type = TB_TYPE_PORT,
827 .out_port = 13,
828 .out_type = TB_TYPE_DP_HDMI_OUT,
829 },
830 };
831 struct tb_switch *host, *dev;
832 struct tb_port *in, *out;
833 struct tb_path *path;
834 int i;
835
836 host = alloc_host(test);
837 dev = alloc_dev_default(test, host, 0x1, false);
838
839 in = &host->ports[5];
840 out = &dev->ports[13];
841
842 path = tb_path_alloc(NULL, in, 9, out, 9, 1, "Video");
843 KUNIT_ASSERT_TRUE(test, path != NULL);
844 KUNIT_ASSERT_EQ(test, path->path_length, (int)ARRAY_SIZE(test_data));
845 for (i = 0; i < ARRAY_SIZE(test_data); i++) {
846 const struct tb_port *in_port, *out_port;
847
848 in_port = path->hops[i].in_port;
849 out_port = path->hops[i].out_port;
850
851 KUNIT_EXPECT_EQ(test, tb_route(in_port->sw), test_data[i].route);
852 KUNIT_EXPECT_EQ(test, in_port->port, test_data[i].in_port);
853 KUNIT_EXPECT_EQ(test, (enum tb_port_type)in_port->config.type,
854 test_data[i].in_type);
855 KUNIT_EXPECT_EQ(test, tb_route(out_port->sw), test_data[i].route);
856 KUNIT_EXPECT_EQ(test, out_port->port, test_data[i].out_port);
857 KUNIT_EXPECT_EQ(test, (enum tb_port_type)out_port->config.type,
858 test_data[i].out_type);
859 }
860 tb_path_free(path);
861}
862
863static void tb_test_path_not_bonded_lane1_chain(struct kunit *test)
864{
865 /*
866 * DP Video path from host to device 3 using lane 1.
867 *
868 * [Host]
869 * 1 :| 2
870 * 1 :| 2
871 * [Device #1]
872 * 7 :| 8
873 * 1 :| 2
874 * [Device #2]
875 * 5 :| 6
876 * 1 :| 2
877 * [Device #3]
878 */
879 static const struct hop_expectation test_data[] = {
880 {
881 .route = 0x0,
882 .in_port = 5,
883 .in_type = TB_TYPE_DP_HDMI_IN,
884 .out_port = 2,
885 .out_type = TB_TYPE_PORT,
886 },
887 {
888 .route = 0x1,
889 .in_port = 2,
890 .in_type = TB_TYPE_PORT,
891 .out_port = 8,
892 .out_type = TB_TYPE_PORT,
893 },
894 {
895 .route = 0x701,
896 .in_port = 2,
897 .in_type = TB_TYPE_PORT,
898 .out_port = 6,
899 .out_type = TB_TYPE_PORT,
900 },
901 {
902 .route = 0x50701,
903 .in_port = 2,
904 .in_type = TB_TYPE_PORT,
905 .out_port = 13,
906 .out_type = TB_TYPE_DP_HDMI_OUT,
907 },
908 };
909 struct tb_switch *host, *dev1, *dev2, *dev3;
910 struct tb_port *in, *out;
911 struct tb_path *path;
912 int i;
913
914 host = alloc_host(test);
915 dev1 = alloc_dev_default(test, host, 0x1, false);
916 dev2 = alloc_dev_default(test, dev1, 0x701, false);
917 dev3 = alloc_dev_default(test, dev2, 0x50701, false);
918
919 in = &host->ports[5];
920 out = &dev3->ports[13];
921
922 path = tb_path_alloc(NULL, in, 9, out, 9, 1, "Video");
923 KUNIT_ASSERT_TRUE(test, path != NULL);
924 KUNIT_ASSERT_EQ(test, path->path_length, (int)ARRAY_SIZE(test_data));
925 for (i = 0; i < ARRAY_SIZE(test_data); i++) {
926 const struct tb_port *in_port, *out_port;
927
928 in_port = path->hops[i].in_port;
929 out_port = path->hops[i].out_port;
930
931 KUNIT_EXPECT_EQ(test, tb_route(in_port->sw), test_data[i].route);
932 KUNIT_EXPECT_EQ(test, in_port->port, test_data[i].in_port);
933 KUNIT_EXPECT_EQ(test, (enum tb_port_type)in_port->config.type,
934 test_data[i].in_type);
935 KUNIT_EXPECT_EQ(test, tb_route(out_port->sw), test_data[i].route);
936 KUNIT_EXPECT_EQ(test, out_port->port, test_data[i].out_port);
937 KUNIT_EXPECT_EQ(test, (enum tb_port_type)out_port->config.type,
938 test_data[i].out_type);
939 }
940 tb_path_free(path);
941}
942
943static void tb_test_path_not_bonded_lane1_chain_reverse(struct kunit *test)
944{
945 /*
946 * DP Video path from device 3 to host using lane 1.
947 *
948 * [Host]
949 * 1 :| 2
950 * 1 :| 2
951 * [Device #1]
952 * 7 :| 8
953 * 1 :| 2
954 * [Device #2]
955 * 5 :| 6
956 * 1 :| 2
957 * [Device #3]
958 */
959 static const struct hop_expectation test_data[] = {
960 {
961 .route = 0x50701,
962 .in_port = 13,
963 .in_type = TB_TYPE_DP_HDMI_IN,
964 .out_port = 2,
965 .out_type = TB_TYPE_PORT,
966 },
967 {
968 .route = 0x701,
969 .in_port = 6,
970 .in_type = TB_TYPE_PORT,
971 .out_port = 2,
972 .out_type = TB_TYPE_PORT,
973 },
974 {
975 .route = 0x1,
976 .in_port = 8,
977 .in_type = TB_TYPE_PORT,
978 .out_port = 2,
979 .out_type = TB_TYPE_PORT,
980 },
981 {
982 .route = 0x0,
983 .in_port = 2,
984 .in_type = TB_TYPE_PORT,
985 .out_port = 5,
986 .out_type = TB_TYPE_DP_HDMI_IN,
987 },
988 };
989 struct tb_switch *host, *dev1, *dev2, *dev3;
990 struct tb_port *in, *out;
991 struct tb_path *path;
992 int i;
993
994 host = alloc_host(test);
995 dev1 = alloc_dev_default(test, host, 0x1, false);
996 dev2 = alloc_dev_default(test, dev1, 0x701, false);
997 dev3 = alloc_dev_with_dpin(test, dev2, 0x50701, false);
998
999 in = &dev3->ports[13];
1000 out = &host->ports[5];
1001
1002 path = tb_path_alloc(NULL, in, 9, out, 9, 1, "Video");
1003 KUNIT_ASSERT_TRUE(test, path != NULL);
1004 KUNIT_ASSERT_EQ(test, path->path_length, (int)ARRAY_SIZE(test_data));
1005 for (i = 0; i < ARRAY_SIZE(test_data); i++) {
1006 const struct tb_port *in_port, *out_port;
1007
1008 in_port = path->hops[i].in_port;
1009 out_port = path->hops[i].out_port;
1010
1011 KUNIT_EXPECT_EQ(test, tb_route(in_port->sw), test_data[i].route);
1012 KUNIT_EXPECT_EQ(test, in_port->port, test_data[i].in_port);
1013 KUNIT_EXPECT_EQ(test, (enum tb_port_type)in_port->config.type,
1014 test_data[i].in_type);
1015 KUNIT_EXPECT_EQ(test, tb_route(out_port->sw), test_data[i].route);
1016 KUNIT_EXPECT_EQ(test, out_port->port, test_data[i].out_port);
1017 KUNIT_EXPECT_EQ(test, (enum tb_port_type)out_port->config.type,
1018 test_data[i].out_type);
1019 }
1020 tb_path_free(path);
1021}
1022
1023static void tb_test_path_mixed_chain(struct kunit *test)
1024{
1025 /*
1026 * DP Video path from host to device 4 where first and last link
1027 * is bonded.
1028 *
1029 * [Host]
1030 * 1 |
1031 * 1 |
1032 * [Device #1]
1033 * 7 :| 8
1034 * 1 :| 2
1035 * [Device #2]
1036 * 5 :| 6
1037 * 1 :| 2
1038 * [Device #3]
1039 * 3 |
1040 * 1 |
1041 * [Device #4]
1042 */
1043 static const struct hop_expectation test_data[] = {
1044 {
1045 .route = 0x0,
1046 .in_port = 5,
1047 .in_type = TB_TYPE_DP_HDMI_IN,
1048 .out_port = 1,
1049 .out_type = TB_TYPE_PORT,
1050 },
1051 {
1052 .route = 0x1,
1053 .in_port = 1,
1054 .in_type = TB_TYPE_PORT,
1055 .out_port = 8,
1056 .out_type = TB_TYPE_PORT,
1057 },
1058 {
1059 .route = 0x701,
1060 .in_port = 2,
1061 .in_type = TB_TYPE_PORT,
1062 .out_port = 6,
1063 .out_type = TB_TYPE_PORT,
1064 },
1065 {
1066 .route = 0x50701,
1067 .in_port = 2,
1068 .in_type = TB_TYPE_PORT,
1069 .out_port = 3,
1070 .out_type = TB_TYPE_PORT,
1071 },
1072 {
1073 .route = 0x3050701,
1074 .in_port = 1,
1075 .in_type = TB_TYPE_PORT,
1076 .out_port = 13,
1077 .out_type = TB_TYPE_DP_HDMI_OUT,
1078 },
1079 };
1080 struct tb_switch *host, *dev1, *dev2, *dev3, *dev4;
1081 struct tb_port *in, *out;
1082 struct tb_path *path;
1083 int i;
1084
1085 host = alloc_host(test);
1086 dev1 = alloc_dev_default(test, host, 0x1, true);
1087 dev2 = alloc_dev_default(test, dev1, 0x701, false);
1088 dev3 = alloc_dev_default(test, dev2, 0x50701, false);
1089 dev4 = alloc_dev_default(test, dev3, 0x3050701, true);
1090
1091 in = &host->ports[5];
1092 out = &dev4->ports[13];
1093
1094 path = tb_path_alloc(NULL, in, 9, out, 9, 1, "Video");
1095 KUNIT_ASSERT_TRUE(test, path != NULL);
1096 KUNIT_ASSERT_EQ(test, path->path_length, (int)ARRAY_SIZE(test_data));
1097 for (i = 0; i < ARRAY_SIZE(test_data); i++) {
1098 const struct tb_port *in_port, *out_port;
1099
1100 in_port = path->hops[i].in_port;
1101 out_port = path->hops[i].out_port;
1102
1103 KUNIT_EXPECT_EQ(test, tb_route(in_port->sw), test_data[i].route);
1104 KUNIT_EXPECT_EQ(test, in_port->port, test_data[i].in_port);
1105 KUNIT_EXPECT_EQ(test, (enum tb_port_type)in_port->config.type,
1106 test_data[i].in_type);
1107 KUNIT_EXPECT_EQ(test, tb_route(out_port->sw), test_data[i].route);
1108 KUNIT_EXPECT_EQ(test, out_port->port, test_data[i].out_port);
1109 KUNIT_EXPECT_EQ(test, (enum tb_port_type)out_port->config.type,
1110 test_data[i].out_type);
1111 }
1112 tb_path_free(path);
1113}
1114
1115static void tb_test_path_mixed_chain_reverse(struct kunit *test)
1116{
1117 /*
1118 * DP Video path from device 4 to host where first and last link
1119 * is bonded.
1120 *
1121 * [Host]
1122 * 1 |
1123 * 1 |
1124 * [Device #1]
1125 * 7 :| 8
1126 * 1 :| 2
1127 * [Device #2]
1128 * 5 :| 6
1129 * 1 :| 2
1130 * [Device #3]
1131 * 3 |
1132 * 1 |
1133 * [Device #4]
1134 */
1135 static const struct hop_expectation test_data[] = {
1136 {
1137 .route = 0x3050701,
1138 .in_port = 13,
1139 .in_type = TB_TYPE_DP_HDMI_OUT,
1140 .out_port = 1,
1141 .out_type = TB_TYPE_PORT,
1142 },
1143 {
1144 .route = 0x50701,
1145 .in_port = 3,
1146 .in_type = TB_TYPE_PORT,
1147 .out_port = 2,
1148 .out_type = TB_TYPE_PORT,
1149 },
1150 {
1151 .route = 0x701,
1152 .in_port = 6,
1153 .in_type = TB_TYPE_PORT,
1154 .out_port = 2,
1155 .out_type = TB_TYPE_PORT,
1156 },
1157 {
1158 .route = 0x1,
1159 .in_port = 8,
1160 .in_type = TB_TYPE_PORT,
1161 .out_port = 1,
1162 .out_type = TB_TYPE_PORT,
1163 },
1164 {
1165 .route = 0x0,
1166 .in_port = 1,
1167 .in_type = TB_TYPE_PORT,
1168 .out_port = 5,
1169 .out_type = TB_TYPE_DP_HDMI_IN,
1170 },
1171 };
1172 struct tb_switch *host, *dev1, *dev2, *dev3, *dev4;
1173 struct tb_port *in, *out;
1174 struct tb_path *path;
1175 int i;
1176
1177 host = alloc_host(test);
1178 dev1 = alloc_dev_default(test, host, 0x1, true);
1179 dev2 = alloc_dev_default(test, dev1, 0x701, false);
1180 dev3 = alloc_dev_default(test, dev2, 0x50701, false);
1181 dev4 = alloc_dev_default(test, dev3, 0x3050701, true);
1182
1183 in = &dev4->ports[13];
1184 out = &host->ports[5];
1185
1186 path = tb_path_alloc(NULL, in, 9, out, 9, 1, "Video");
1187 KUNIT_ASSERT_TRUE(test, path != NULL);
1188 KUNIT_ASSERT_EQ(test, path->path_length, (int)ARRAY_SIZE(test_data));
1189 for (i = 0; i < ARRAY_SIZE(test_data); i++) {
1190 const struct tb_port *in_port, *out_port;
1191
1192 in_port = path->hops[i].in_port;
1193 out_port = path->hops[i].out_port;
1194
1195 KUNIT_EXPECT_EQ(test, tb_route(in_port->sw), test_data[i].route);
1196 KUNIT_EXPECT_EQ(test, in_port->port, test_data[i].in_port);
1197 KUNIT_EXPECT_EQ(test, (enum tb_port_type)in_port->config.type,
1198 test_data[i].in_type);
1199 KUNIT_EXPECT_EQ(test, tb_route(out_port->sw), test_data[i].route);
1200 KUNIT_EXPECT_EQ(test, out_port->port, test_data[i].out_port);
1201 KUNIT_EXPECT_EQ(test, (enum tb_port_type)out_port->config.type,
1202 test_data[i].out_type);
1203 }
1204 tb_path_free(path);
1205}
1206
1207static void tb_test_tunnel_pcie(struct kunit *test)
1208{
1209 struct tb_switch *host, *dev1, *dev2;
1210 struct tb_tunnel *tunnel1, *tunnel2;
1211 struct tb_port *down, *up;
1212
1213 /*
1214 * Create PCIe tunnel between host and two devices.
1215 *
1216 * [Host]
1217 * 1 |
1218 * 1 |
1219 * [Device #1]
1220 * 5 |
1221 * 1 |
1222 * [Device #2]
1223 */
1224 host = alloc_host(test);
1225 dev1 = alloc_dev_default(test, host, 0x1, true);
1226 dev2 = alloc_dev_default(test, dev1, 0x501, true);
1227
1228 down = &host->ports[8];
1229 up = &dev1->ports[9];
1230 tunnel1 = tb_tunnel_alloc_pci(NULL, up, down);
1231 KUNIT_ASSERT_TRUE(test, tunnel1 != NULL);
1232 KUNIT_EXPECT_EQ(test, tunnel1->type, (enum tb_tunnel_type)TB_TUNNEL_PCI);
1233 KUNIT_EXPECT_PTR_EQ(test, tunnel1->src_port, down);
1234 KUNIT_EXPECT_PTR_EQ(test, tunnel1->dst_port, up);
1235 KUNIT_ASSERT_EQ(test, tunnel1->npaths, (size_t)2);
1236 KUNIT_ASSERT_EQ(test, tunnel1->paths[0]->path_length, 2);
1237 KUNIT_EXPECT_PTR_EQ(test, tunnel1->paths[0]->hops[0].in_port, down);
1238 KUNIT_EXPECT_PTR_EQ(test, tunnel1->paths[0]->hops[1].out_port, up);
1239 KUNIT_ASSERT_EQ(test, tunnel1->paths[1]->path_length, 2);
1240 KUNIT_EXPECT_PTR_EQ(test, tunnel1->paths[1]->hops[0].in_port, up);
1241 KUNIT_EXPECT_PTR_EQ(test, tunnel1->paths[1]->hops[1].out_port, down);
1242
1243 down = &dev1->ports[10];
1244 up = &dev2->ports[9];
1245 tunnel2 = tb_tunnel_alloc_pci(NULL, up, down);
1246 KUNIT_ASSERT_TRUE(test, tunnel2 != NULL);
1247 KUNIT_EXPECT_EQ(test, tunnel2->type, (enum tb_tunnel_type)TB_TUNNEL_PCI);
1248 KUNIT_EXPECT_PTR_EQ(test, tunnel2->src_port, down);
1249 KUNIT_EXPECT_PTR_EQ(test, tunnel2->dst_port, up);
1250 KUNIT_ASSERT_EQ(test, tunnel2->npaths, (size_t)2);
1251 KUNIT_ASSERT_EQ(test, tunnel2->paths[0]->path_length, 2);
1252 KUNIT_EXPECT_PTR_EQ(test, tunnel2->paths[0]->hops[0].in_port, down);
1253 KUNIT_EXPECT_PTR_EQ(test, tunnel2->paths[0]->hops[1].out_port, up);
1254 KUNIT_ASSERT_EQ(test, tunnel2->paths[1]->path_length, 2);
1255 KUNIT_EXPECT_PTR_EQ(test, tunnel2->paths[1]->hops[0].in_port, up);
1256 KUNIT_EXPECT_PTR_EQ(test, tunnel2->paths[1]->hops[1].out_port, down);
1257
1258 tb_tunnel_free(tunnel2);
1259 tb_tunnel_free(tunnel1);
1260}
1261
1262static void tb_test_tunnel_dp(struct kunit *test)
1263{
1264 struct tb_switch *host, *dev;
1265 struct tb_port *in, *out;
1266 struct tb_tunnel *tunnel;
1267
1268 /*
1269 * Create DP tunnel between Host and Device
1270 *
1271 * [Host]
1272 * 1 |
1273 * 1 |
1274 * [Device]
1275 */
1276 host = alloc_host(test);
1277 dev = alloc_dev_default(test, host, 0x3, true);
1278
1279 in = &host->ports[5];
1280 out = &dev->ports[13];
1281
1282 tunnel = tb_tunnel_alloc_dp(NULL, in, out, 0, 0);
1283 KUNIT_ASSERT_TRUE(test, tunnel != NULL);
1284 KUNIT_EXPECT_EQ(test, tunnel->type, (enum tb_tunnel_type)TB_TUNNEL_DP);
1285 KUNIT_EXPECT_PTR_EQ(test, tunnel->src_port, in);
1286 KUNIT_EXPECT_PTR_EQ(test, tunnel->dst_port, out);
1287 KUNIT_ASSERT_EQ(test, tunnel->npaths, (size_t)3);
1288 KUNIT_ASSERT_EQ(test, tunnel->paths[0]->path_length, 2);
1289 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[0]->hops[0].in_port, in);
1290 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[0]->hops[1].out_port, out);
1291 KUNIT_ASSERT_EQ(test, tunnel->paths[1]->path_length, 2);
1292 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[1]->hops[0].in_port, in);
1293 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[1]->hops[1].out_port, out);
1294 KUNIT_ASSERT_EQ(test, tunnel->paths[2]->path_length, 2);
1295 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[2]->hops[0].in_port, out);
1296 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[2]->hops[1].out_port, in);
1297 tb_tunnel_free(tunnel);
1298}
1299
1300static void tb_test_tunnel_dp_chain(struct kunit *test)
1301{
1302 struct tb_switch *host, *dev1, *dev4;
1303 struct tb_port *in, *out;
1304 struct tb_tunnel *tunnel;
1305
1306 /*
1307 * Create DP tunnel from Host DP IN to Device #4 DP OUT.
1308 *
1309 * [Host]
1310 * 1 |
1311 * 1 |
1312 * [Device #1]
1313 * 3 / | 5 \ 7
1314 * 1 / | \ 1
1315 * [Device #2] | [Device #4]
1316 * | 1
1317 * [Device #3]
1318 */
1319 host = alloc_host(test);
1320 dev1 = alloc_dev_default(test, host, 0x1, true);
1321 alloc_dev_default(test, dev1, 0x301, true);
1322 alloc_dev_default(test, dev1, 0x501, true);
1323 dev4 = alloc_dev_default(test, dev1, 0x701, true);
1324
1325 in = &host->ports[5];
1326 out = &dev4->ports[14];
1327
1328 tunnel = tb_tunnel_alloc_dp(NULL, in, out, 0, 0);
1329 KUNIT_ASSERT_TRUE(test, tunnel != NULL);
1330 KUNIT_EXPECT_EQ(test, tunnel->type, (enum tb_tunnel_type)TB_TUNNEL_DP);
1331 KUNIT_EXPECT_PTR_EQ(test, tunnel->src_port, in);
1332 KUNIT_EXPECT_PTR_EQ(test, tunnel->dst_port, out);
1333 KUNIT_ASSERT_EQ(test, tunnel->npaths, (size_t)3);
1334 KUNIT_ASSERT_EQ(test, tunnel->paths[0]->path_length, 3);
1335 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[0]->hops[0].in_port, in);
1336 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[0]->hops[2].out_port, out);
1337 KUNIT_ASSERT_EQ(test, tunnel->paths[1]->path_length, 3);
1338 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[1]->hops[0].in_port, in);
1339 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[1]->hops[2].out_port, out);
1340 KUNIT_ASSERT_EQ(test, tunnel->paths[2]->path_length, 3);
1341 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[2]->hops[0].in_port, out);
1342 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[2]->hops[2].out_port, in);
1343 tb_tunnel_free(tunnel);
1344}
1345
1346static void tb_test_tunnel_dp_tree(struct kunit *test)
1347{
1348 struct tb_switch *host, *dev1, *dev2, *dev3, *dev5;
1349 struct tb_port *in, *out;
1350 struct tb_tunnel *tunnel;
1351
1352 /*
1353 * Create DP tunnel from Device #2 DP IN to Device #5 DP OUT.
1354 *
1355 * [Host]
1356 * 3 |
1357 * 1 |
1358 * [Device #1]
1359 * 3 / | 5 \ 7
1360 * 1 / | \ 1
1361 * [Device #2] | [Device #4]
1362 * | 1
1363 * [Device #3]
1364 * | 5
1365 * | 1
1366 * [Device #5]
1367 */
1368 host = alloc_host(test);
1369 dev1 = alloc_dev_default(test, host, 0x3, true);
1370 dev2 = alloc_dev_with_dpin(test, dev1, 0x303, true);
1371 dev3 = alloc_dev_default(test, dev1, 0x503, true);
1372 alloc_dev_default(test, dev1, 0x703, true);
1373 dev5 = alloc_dev_default(test, dev3, 0x50503, true);
1374
1375 in = &dev2->ports[13];
1376 out = &dev5->ports[13];
1377
1378 tunnel = tb_tunnel_alloc_dp(NULL, in, out, 0, 0);
1379 KUNIT_ASSERT_TRUE(test, tunnel != NULL);
1380 KUNIT_EXPECT_EQ(test, tunnel->type, (enum tb_tunnel_type)TB_TUNNEL_DP);
1381 KUNIT_EXPECT_PTR_EQ(test, tunnel->src_port, in);
1382 KUNIT_EXPECT_PTR_EQ(test, tunnel->dst_port, out);
1383 KUNIT_ASSERT_EQ(test, tunnel->npaths, (size_t)3);
1384 KUNIT_ASSERT_EQ(test, tunnel->paths[0]->path_length, 4);
1385 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[0]->hops[0].in_port, in);
1386 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[0]->hops[3].out_port, out);
1387 KUNIT_ASSERT_EQ(test, tunnel->paths[1]->path_length, 4);
1388 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[1]->hops[0].in_port, in);
1389 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[1]->hops[3].out_port, out);
1390 KUNIT_ASSERT_EQ(test, tunnel->paths[2]->path_length, 4);
1391 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[2]->hops[0].in_port, out);
1392 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[2]->hops[3].out_port, in);
1393 tb_tunnel_free(tunnel);
1394}
1395
1396static void tb_test_tunnel_dp_max_length(struct kunit *test)
1397{
1398 struct tb_switch *host, *dev1, *dev2, *dev3, *dev4, *dev5, *dev6;
1399 struct tb_switch *dev7, *dev8, *dev9, *dev10, *dev11, *dev12;
1400 struct tb_port *in, *out;
1401 struct tb_tunnel *tunnel;
1402
1403 /*
1404 * Creates DP tunnel from Device #6 to Device #12.
1405 *
1406 * [Host]
1407 * 1 / \ 3
1408 * 1 / \ 1
1409 * [Device #1] [Device #7]
1410 * 3 | | 3
1411 * 1 | | 1
1412 * [Device #2] [Device #8]
1413 * 3 | | 3
1414 * 1 | | 1
1415 * [Device #3] [Device #9]
1416 * 3 | | 3
1417 * 1 | | 1
1418 * [Device #4] [Device #10]
1419 * 3 | | 3
1420 * 1 | | 1
1421 * [Device #5] [Device #11]
1422 * 3 | | 3
1423 * 1 | | 1
1424 * [Device #6] [Device #12]
1425 */
1426 host = alloc_host(test);
1427 dev1 = alloc_dev_default(test, host, 0x1, true);
1428 dev2 = alloc_dev_default(test, dev1, 0x301, true);
1429 dev3 = alloc_dev_default(test, dev2, 0x30301, true);
1430 dev4 = alloc_dev_default(test, dev3, 0x3030301, true);
1431 dev5 = alloc_dev_default(test, dev4, 0x303030301, true);
1432 dev6 = alloc_dev_with_dpin(test, dev5, 0x30303030301, true);
1433 dev7 = alloc_dev_default(test, host, 0x3, true);
1434 dev8 = alloc_dev_default(test, dev7, 0x303, true);
1435 dev9 = alloc_dev_default(test, dev8, 0x30303, true);
1436 dev10 = alloc_dev_default(test, dev9, 0x3030303, true);
1437 dev11 = alloc_dev_default(test, dev10, 0x303030303, true);
1438 dev12 = alloc_dev_default(test, dev11, 0x30303030303, true);
1439
1440 in = &dev6->ports[13];
1441 out = &dev12->ports[13];
1442
1443 tunnel = tb_tunnel_alloc_dp(NULL, in, out, 0, 0);
1444 KUNIT_ASSERT_TRUE(test, tunnel != NULL);
1445 KUNIT_EXPECT_EQ(test, tunnel->type, (enum tb_tunnel_type)TB_TUNNEL_DP);
1446 KUNIT_EXPECT_PTR_EQ(test, tunnel->src_port, in);
1447 KUNIT_EXPECT_PTR_EQ(test, tunnel->dst_port, out);
1448 KUNIT_ASSERT_EQ(test, tunnel->npaths, (size_t)3);
1449 KUNIT_ASSERT_EQ(test, tunnel->paths[0]->path_length, 13);
1450 /* First hop */
1451 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[0]->hops[0].in_port, in);
1452 /* Middle */
1453 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[0]->hops[6].in_port,
1454 &host->ports[1]);
1455 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[0]->hops[6].out_port,
1456 &host->ports[3]);
1457 /* Last */
1458 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[0]->hops[12].out_port, out);
1459 KUNIT_ASSERT_EQ(test, tunnel->paths[1]->path_length, 13);
1460 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[1]->hops[0].in_port, in);
1461 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[1]->hops[6].in_port,
1462 &host->ports[1]);
1463 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[1]->hops[6].out_port,
1464 &host->ports[3]);
1465 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[1]->hops[12].out_port, out);
1466 KUNIT_ASSERT_EQ(test, tunnel->paths[2]->path_length, 13);
1467 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[2]->hops[0].in_port, out);
1468 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[2]->hops[6].in_port,
1469 &host->ports[3]);
1470 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[2]->hops[6].out_port,
1471 &host->ports[1]);
1472 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[2]->hops[12].out_port, in);
1473 tb_tunnel_free(tunnel);
1474}
1475
1476static void tb_test_tunnel_usb3(struct kunit *test)
1477{
1478 struct tb_switch *host, *dev1, *dev2;
1479 struct tb_tunnel *tunnel1, *tunnel2;
1480 struct tb_port *down, *up;
1481
1482 /*
1483 * Create USB3 tunnel between host and two devices.
1484 *
1485 * [Host]
1486 * 1 |
1487 * 1 |
1488 * [Device #1]
1489 * \ 7
1490 * \ 1
1491 * [Device #2]
1492 */
1493 host = alloc_host(test);
1494 dev1 = alloc_dev_default(test, host, 0x1, true);
1495 dev2 = alloc_dev_default(test, dev1, 0x701, true);
1496
1497 down = &host->ports[12];
1498 up = &dev1->ports[16];
1499 tunnel1 = tb_tunnel_alloc_usb3(NULL, up, down, 0, 0);
1500 KUNIT_ASSERT_TRUE(test, tunnel1 != NULL);
1501 KUNIT_EXPECT_EQ(test, tunnel1->type, (enum tb_tunnel_type)TB_TUNNEL_USB3);
1502 KUNIT_EXPECT_PTR_EQ(test, tunnel1->src_port, down);
1503 KUNIT_EXPECT_PTR_EQ(test, tunnel1->dst_port, up);
1504 KUNIT_ASSERT_EQ(test, tunnel1->npaths, (size_t)2);
1505 KUNIT_ASSERT_EQ(test, tunnel1->paths[0]->path_length, 2);
1506 KUNIT_EXPECT_PTR_EQ(test, tunnel1->paths[0]->hops[0].in_port, down);
1507 KUNIT_EXPECT_PTR_EQ(test, tunnel1->paths[0]->hops[1].out_port, up);
1508 KUNIT_ASSERT_EQ(test, tunnel1->paths[1]->path_length, 2);
1509 KUNIT_EXPECT_PTR_EQ(test, tunnel1->paths[1]->hops[0].in_port, up);
1510 KUNIT_EXPECT_PTR_EQ(test, tunnel1->paths[1]->hops[1].out_port, down);
1511
1512 down = &dev1->ports[17];
1513 up = &dev2->ports[16];
1514 tunnel2 = tb_tunnel_alloc_usb3(NULL, up, down, 0, 0);
1515 KUNIT_ASSERT_TRUE(test, tunnel2 != NULL);
1516 KUNIT_EXPECT_EQ(test, tunnel2->type, (enum tb_tunnel_type)TB_TUNNEL_USB3);
1517 KUNIT_EXPECT_PTR_EQ(test, tunnel2->src_port, down);
1518 KUNIT_EXPECT_PTR_EQ(test, tunnel2->dst_port, up);
1519 KUNIT_ASSERT_EQ(test, tunnel2->npaths, (size_t)2);
1520 KUNIT_ASSERT_EQ(test, tunnel2->paths[0]->path_length, 2);
1521 KUNIT_EXPECT_PTR_EQ(test, tunnel2->paths[0]->hops[0].in_port, down);
1522 KUNIT_EXPECT_PTR_EQ(test, tunnel2->paths[0]->hops[1].out_port, up);
1523 KUNIT_ASSERT_EQ(test, tunnel2->paths[1]->path_length, 2);
1524 KUNIT_EXPECT_PTR_EQ(test, tunnel2->paths[1]->hops[0].in_port, up);
1525 KUNIT_EXPECT_PTR_EQ(test, tunnel2->paths[1]->hops[1].out_port, down);
1526
1527 tb_tunnel_free(tunnel2);
1528 tb_tunnel_free(tunnel1);
1529}
1530
1531static void tb_test_tunnel_port_on_path(struct kunit *test)
1532{
1533 struct tb_switch *host, *dev1, *dev2, *dev3, *dev4, *dev5;
1534 struct tb_port *in, *out, *port;
1535 struct tb_tunnel *dp_tunnel;
1536
1537 /*
1538 * [Host]
1539 * 3 |
1540 * 1 |
1541 * [Device #1]
1542 * 3 / | 5 \ 7
1543 * 1 / | \ 1
1544 * [Device #2] | [Device #4]
1545 * | 1
1546 * [Device #3]
1547 * | 5
1548 * | 1
1549 * [Device #5]
1550 */
1551 host = alloc_host(test);
1552 dev1 = alloc_dev_default(test, host, 0x3, true);
1553 dev2 = alloc_dev_with_dpin(test, dev1, 0x303, true);
1554 dev3 = alloc_dev_default(test, dev1, 0x503, true);
1555 dev4 = alloc_dev_default(test, dev1, 0x703, true);
1556 dev5 = alloc_dev_default(test, dev3, 0x50503, true);
1557
1558 in = &dev2->ports[13];
1559 out = &dev5->ports[13];
1560
1561 dp_tunnel = tb_tunnel_alloc_dp(NULL, in, out, 0, 0);
1562 KUNIT_ASSERT_TRUE(test, dp_tunnel != NULL);
1563
1564 KUNIT_EXPECT_TRUE(test, tb_tunnel_port_on_path(dp_tunnel, in));
1565 KUNIT_EXPECT_TRUE(test, tb_tunnel_port_on_path(dp_tunnel, out));
1566
1567 port = &host->ports[8];
1568 KUNIT_EXPECT_FALSE(test, tb_tunnel_port_on_path(dp_tunnel, port));
1569
1570 port = &host->ports[3];
1571 KUNIT_EXPECT_FALSE(test, tb_tunnel_port_on_path(dp_tunnel, port));
1572
1573 port = &dev1->ports[1];
1574 KUNIT_EXPECT_FALSE(test, tb_tunnel_port_on_path(dp_tunnel, port));
1575
1576 port = &dev1->ports[3];
1577 KUNIT_EXPECT_TRUE(test, tb_tunnel_port_on_path(dp_tunnel, port));
1578
1579 port = &dev1->ports[5];
1580 KUNIT_EXPECT_TRUE(test, tb_tunnel_port_on_path(dp_tunnel, port));
1581
1582 port = &dev1->ports[7];
1583 KUNIT_EXPECT_FALSE(test, tb_tunnel_port_on_path(dp_tunnel, port));
1584
1585 port = &dev3->ports[1];
1586 KUNIT_EXPECT_TRUE(test, tb_tunnel_port_on_path(dp_tunnel, port));
1587
1588 port = &dev5->ports[1];
1589 KUNIT_EXPECT_TRUE(test, tb_tunnel_port_on_path(dp_tunnel, port));
1590
1591 port = &dev4->ports[1];
1592 KUNIT_EXPECT_FALSE(test, tb_tunnel_port_on_path(dp_tunnel, port));
1593
1594 tb_tunnel_free(dp_tunnel);
1595}
1596
1597static struct kunit_case tb_test_cases[] = {
1598 KUNIT_CASE(tb_test_path_basic),
1599 KUNIT_CASE(tb_test_path_not_connected_walk),
1600 KUNIT_CASE(tb_test_path_single_hop_walk),
1601 KUNIT_CASE(tb_test_path_daisy_chain_walk),
1602 KUNIT_CASE(tb_test_path_simple_tree_walk),
1603 KUNIT_CASE(tb_test_path_complex_tree_walk),
1604 KUNIT_CASE(tb_test_path_max_length_walk),
1605 KUNIT_CASE(tb_test_path_not_connected),
1606 KUNIT_CASE(tb_test_path_not_bonded_lane0),
1607 KUNIT_CASE(tb_test_path_not_bonded_lane1),
1608 KUNIT_CASE(tb_test_path_not_bonded_lane1_chain),
1609 KUNIT_CASE(tb_test_path_not_bonded_lane1_chain_reverse),
1610 KUNIT_CASE(tb_test_path_mixed_chain),
1611 KUNIT_CASE(tb_test_path_mixed_chain_reverse),
1612 KUNIT_CASE(tb_test_tunnel_pcie),
1613 KUNIT_CASE(tb_test_tunnel_dp),
1614 KUNIT_CASE(tb_test_tunnel_dp_chain),
1615 KUNIT_CASE(tb_test_tunnel_dp_tree),
1616 KUNIT_CASE(tb_test_tunnel_dp_max_length),
1617 KUNIT_CASE(tb_test_tunnel_port_on_path),
1618 KUNIT_CASE(tb_test_tunnel_usb3),
1619 { }
1620};
1621
1622static struct kunit_suite tb_test_suite = {
1623 .name = "thunderbolt",
1624 .test_cases = tb_test_cases,
1625};
1626kunit_test_suite(tb_test_suite);