?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge tag 'regmap-fix-v5.11-rc2' of git://git.kernel.org/pub/scm/linux/kernel/git...
[linux/fpc-iii.git] / drivers / thunderbolt / test.c
blob464c2d37b992e507b0ca76a907ac8d1e4a46c8a0
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
15 static 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
24 static void __ida_destroy(struct kunit_resource *res)
25 {
26 struct ida *ida = res->data;
27
28 ida_destroy(ida);
29 }
30
31 static 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
36 static 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
72 static 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
145 static 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
275 static 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
296 static 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
313 static 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
346 struct port_expectation {
347 u64 route;
348 u8 port;
349 enum tb_port_type type;
350 };
351
352 static 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
406 static 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
465 static 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
528 static 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
612 static 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
715 static 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
735 struct 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
743 static 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
801 static 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
863 static 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
943 static 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
1023 static 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
1115 static 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
1207 static 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
1262 static 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
1300 static 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
1346 static 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
1396 static 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
1476 static 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
1531 static 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
1597 static 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
1622 static struct kunit_suite tb_test_suite = {
1623 .name = "thunderbolt",
1624 .test_cases = tb_test_cases,
1625 };
1626
1627 static struct kunit_suite *tb_test_suites[] = { &tb_test_suite, NULL };
1628
1629 int tb_test_init(void)
1630 {
1631 return __kunit_test_suites_init(tb_test_suites);
1632 }
1633
1634 void tb_test_exit(void)
1635 {
1636 return __kunit_test_suites_exit(tb_test_suites);
1637 }
Linux with added FPC-III support