drivers/thunderbolt/test.c

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