drivers/thunderbolt/test.c

   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 }