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