1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * KUnit tests 4 * 5 * Copyright (C) 2020, Intel Corporation 6 * Author: Mika Westerberg <mika.westerberg@linux.intel.com> 7 */ 8 9 #include <kunit/test.h> 10 #include <linux/idr.h> 11 12 #include "tb.h" 13 #include "tunnel.h" 14 15 static int __ida_init(struct kunit_resource *res, void *context) 16 { 17 struct ida *ida = context; 18 19 ida_init(ida); 20 res->data = ida; 21 return 0; 22 } 23 24 static void __ida_destroy(struct kunit_resource *res) 25 { 26 struct ida *ida = res->data; 27 28 ida_destroy(ida); 29 } 30 31 static void kunit_ida_init(struct kunit *test, struct ida *ida) 32 { 33 kunit_alloc_resource(test, __ida_init, __ida_destroy, GFP_KERNEL, ida); 34 } 35 36 static struct tb_switch *alloc_switch(struct kunit *test, u64 route, 37 u8 upstream_port, u8 max_port_number) 38 { 39 struct tb_switch *sw; 40 size_t size; 41 int i; 42 43 sw = kunit_kzalloc(test, sizeof(*sw), GFP_KERNEL); 44 if (!sw) 45 return NULL; 46 47 sw->config.upstream_port_number = upstream_port; 48 sw->config.depth = tb_route_length(route); 49 sw->config.route_hi = upper_32_bits(route); 50 sw->config.route_lo = lower_32_bits(route); 51 sw->config.enabled = 0; 52 sw->config.max_port_number = max_port_number; 53 54 size = (sw->config.max_port_number + 1) * sizeof(*sw->ports); 55 sw->ports = kunit_kzalloc(test, size, GFP_KERNEL); 56 if (!sw->ports) 57 return NULL; 58 59 for (i = 0; i <= sw->config.max_port_number; i++) { 60 sw->ports[i].sw = sw; 61 sw->ports[i].port = i; 62 sw->ports[i].config.port_number = i; 63 if (i) { 64 kunit_ida_init(test, &sw->ports[i].in_hopids); 65 kunit_ida_init(test, &sw->ports[i].out_hopids); 66 } 67 } 68 69 return sw; 70 } 71 72 static struct tb_switch *alloc_host(struct kunit *test) 73 { 74 struct tb_switch *sw; 75 76 sw = alloc_switch(test, 0, 7, 13); 77 if (!sw) 78 return NULL; 79 80 sw->config.vendor_id = 0x8086; 81 sw->config.device_id = 0x9a1b; 82 83 sw->ports[0].config.type = TB_TYPE_PORT; 84 sw->ports[0].config.max_in_hop_id = 7; 85 sw->ports[0].config.max_out_hop_id = 7; 86 87 sw->ports[1].config.type = TB_TYPE_PORT; 88 sw->ports[1].config.max_in_hop_id = 19; 89 sw->ports[1].config.max_out_hop_id = 19; 90 sw->ports[1].dual_link_port = &sw->ports[2]; 91 92 sw->ports[2].config.type = TB_TYPE_PORT; 93 sw->ports[2].config.max_in_hop_id = 19; 94 sw->ports[2].config.max_out_hop_id = 19; 95 sw->ports[2].dual_link_port = &sw->ports[1]; 96 sw->ports[2].link_nr = 1; 97 98 sw->ports[3].config.type = TB_TYPE_PORT; 99 sw->ports[3].config.max_in_hop_id = 19; 100 sw->ports[3].config.max_out_hop_id = 19; 101 sw->ports[3].dual_link_port = &sw->ports[4]; 102 103 sw->ports[4].config.type = TB_TYPE_PORT; 104 sw->ports[4].config.max_in_hop_id = 19; 105 sw->ports[4].config.max_out_hop_id = 19; 106 sw->ports[4].dual_link_port = &sw->ports[3]; 107 sw->ports[4].link_nr = 1; 108 109 sw->ports[5].config.type = TB_TYPE_DP_HDMI_IN; 110 sw->ports[5].config.max_in_hop_id = 9; 111 sw->ports[5].config.max_out_hop_id = 9; 112 sw->ports[5].cap_adap = -1; 113 114 sw->ports[6].config.type = TB_TYPE_DP_HDMI_IN; 115 sw->ports[6].config.max_in_hop_id = 9; 116 sw->ports[6].config.max_out_hop_id = 9; 117 sw->ports[6].cap_adap = -1; 118 119 sw->ports[7].config.type = TB_TYPE_NHI; 120 sw->ports[7].config.max_in_hop_id = 11; 121 sw->ports[7].config.max_out_hop_id = 11; 122 sw->ports[7].config.nfc_credits = 0x41800000; 123 124 sw->ports[8].config.type = TB_TYPE_PCIE_DOWN; 125 sw->ports[8].config.max_in_hop_id = 8; 126 sw->ports[8].config.max_out_hop_id = 8; 127 128 sw->ports[9].config.type = TB_TYPE_PCIE_DOWN; 129 sw->ports[9].config.max_in_hop_id = 8; 130 sw->ports[9].config.max_out_hop_id = 8; 131 132 sw->ports[10].disabled = true; 133 sw->ports[11].disabled = true; 134 135 sw->ports[12].config.type = TB_TYPE_USB3_DOWN; 136 sw->ports[12].config.max_in_hop_id = 8; 137 sw->ports[12].config.max_out_hop_id = 8; 138 139 sw->ports[13].config.type = TB_TYPE_USB3_DOWN; 140 sw->ports[13].config.max_in_hop_id = 8; 141 sw->ports[13].config.max_out_hop_id = 8; 142 143 return sw; 144 } 145 146 static struct tb_switch *alloc_dev_default(struct kunit *test, 147 struct tb_switch *parent, 148 u64 route, bool bonded) 149 { 150 struct tb_port *port, *upstream_port; 151 struct tb_switch *sw; 152 153 sw = alloc_switch(test, route, 1, 19); 154 if (!sw) 155 return NULL; 156 157 sw->config.vendor_id = 0x8086; 158 sw->config.device_id = 0x15ef; 159 160 sw->ports[0].config.type = TB_TYPE_PORT; 161 sw->ports[0].config.max_in_hop_id = 8; 162 sw->ports[0].config.max_out_hop_id = 8; 163 164 sw->ports[1].config.type = TB_TYPE_PORT; 165 sw->ports[1].config.max_in_hop_id = 19; 166 sw->ports[1].config.max_out_hop_id = 19; 167 sw->ports[1].dual_link_port = &sw->ports[2]; 168 169 sw->ports[2].config.type = TB_TYPE_PORT; 170 sw->ports[2].config.max_in_hop_id = 19; 171 sw->ports[2].config.max_out_hop_id = 19; 172 sw->ports[2].dual_link_port = &sw->ports[1]; 173 sw->ports[2].link_nr = 1; 174 175 sw->ports[3].config.type = TB_TYPE_PORT; 176 sw->ports[3].config.max_in_hop_id = 19; 177 sw->ports[3].config.max_out_hop_id = 19; 178 sw->ports[3].dual_link_port = &sw->ports[4]; 179 180 sw->ports[4].config.type = TB_TYPE_PORT; 181 sw->ports[4].config.max_in_hop_id = 19; 182 sw->ports[4].config.max_out_hop_id = 19; 183 sw->ports[4].dual_link_port = &sw->ports[3]; 184 sw->ports[4].link_nr = 1; 185 186 sw->ports[5].config.type = TB_TYPE_PORT; 187 sw->ports[5].config.max_in_hop_id = 19; 188 sw->ports[5].config.max_out_hop_id = 19; 189 sw->ports[5].dual_link_port = &sw->ports[6]; 190 191 sw->ports[6].config.type = TB_TYPE_PORT; 192 sw->ports[6].config.max_in_hop_id = 19; 193 sw->ports[6].config.max_out_hop_id = 19; 194 sw->ports[6].dual_link_port = &sw->ports[5]; 195 sw->ports[6].link_nr = 1; 196 197 sw->ports[7].config.type = TB_TYPE_PORT; 198 sw->ports[7].config.max_in_hop_id = 19; 199 sw->ports[7].config.max_out_hop_id = 19; 200 sw->ports[7].dual_link_port = &sw->ports[8]; 201 202 sw->ports[8].config.type = TB_TYPE_PORT; 203 sw->ports[8].config.max_in_hop_id = 19; 204 sw->ports[8].config.max_out_hop_id = 19; 205 sw->ports[8].dual_link_port = &sw->ports[7]; 206 sw->ports[8].link_nr = 1; 207 208 sw->ports[9].config.type = TB_TYPE_PCIE_UP; 209 sw->ports[9].config.max_in_hop_id = 8; 210 sw->ports[9].config.max_out_hop_id = 8; 211 212 sw->ports[10].config.type = TB_TYPE_PCIE_DOWN; 213 sw->ports[10].config.max_in_hop_id = 8; 214 sw->ports[10].config.max_out_hop_id = 8; 215 216 sw->ports[11].config.type = TB_TYPE_PCIE_DOWN; 217 sw->ports[11].config.max_in_hop_id = 8; 218 sw->ports[11].config.max_out_hop_id = 8; 219 220 sw->ports[12].config.type = TB_TYPE_PCIE_DOWN; 221 sw->ports[12].config.max_in_hop_id = 8; 222 sw->ports[12].config.max_out_hop_id = 8; 223 224 sw->ports[13].config.type = TB_TYPE_DP_HDMI_OUT; 225 sw->ports[13].config.max_in_hop_id = 9; 226 sw->ports[13].config.max_out_hop_id = 9; 227 sw->ports[13].cap_adap = -1; 228 229 sw->ports[14].config.type = TB_TYPE_DP_HDMI_OUT; 230 sw->ports[14].config.max_in_hop_id = 9; 231 sw->ports[14].config.max_out_hop_id = 9; 232 sw->ports[14].cap_adap = -1; 233 234 sw->ports[15].disabled = true; 235 236 sw->ports[16].config.type = TB_TYPE_USB3_UP; 237 sw->ports[16].config.max_in_hop_id = 8; 238 sw->ports[16].config.max_out_hop_id = 8; 239 240 sw->ports[17].config.type = TB_TYPE_USB3_DOWN; 241 sw->ports[17].config.max_in_hop_id = 8; 242 sw->ports[17].config.max_out_hop_id = 8; 243 244 sw->ports[18].config.type = TB_TYPE_USB3_DOWN; 245 sw->ports[18].config.max_in_hop_id = 8; 246 sw->ports[18].config.max_out_hop_id = 8; 247 248 sw->ports[19].config.type = TB_TYPE_USB3_DOWN; 249 sw->ports[19].config.max_in_hop_id = 8; 250 sw->ports[19].config.max_out_hop_id = 8; 251 252 if (!parent) 253 return sw; 254 255 /* Link them */ 256 upstream_port = tb_upstream_port(sw); 257 port = tb_port_at(route, parent); 258 port->remote = upstream_port; 259 upstream_port->remote = port; 260 if (port->dual_link_port && upstream_port->dual_link_port) { 261 port->dual_link_port->remote = upstream_port->dual_link_port; 262 upstream_port->dual_link_port->remote = port->dual_link_port; 263 } 264 265 if (bonded) { 266 /* Bonding is used */ 267 port->bonded = true; 268 port->dual_link_port->bonded = true; 269 upstream_port->bonded = true; 270 upstream_port->dual_link_port->bonded = true; 271 } 272 273 return sw; 274 } 275 276 static struct tb_switch *alloc_dev_with_dpin(struct kunit *test, 277 struct tb_switch *parent, 278 u64 route, bool bonded) 279 { 280 struct tb_switch *sw; 281 282 sw = alloc_dev_default(test, parent, route, bonded); 283 if (!sw) 284 return NULL; 285 286 sw->ports[13].config.type = TB_TYPE_DP_HDMI_IN; 287 sw->ports[13].config.max_in_hop_id = 9; 288 sw->ports[13].config.max_out_hop_id = 9; 289 290 sw->ports[14].config.type = TB_TYPE_DP_HDMI_IN; 291 sw->ports[14].config.max_in_hop_id = 9; 292 sw->ports[14].config.max_out_hop_id = 9; 293 294 return sw; 295 } 296 297 static void tb_test_path_basic(struct kunit *test) 298 { 299 struct tb_port *src_port, *dst_port, *p; 300 struct tb_switch *host; 301 302 host = alloc_host(test); 303 304 src_port = &host->ports[5]; 305 dst_port = src_port; 306 307 p = tb_next_port_on_path(src_port, dst_port, NULL); 308 KUNIT_EXPECT_PTR_EQ(test, p, dst_port); 309 310 p = tb_next_port_on_path(src_port, dst_port, p); 311 KUNIT_EXPECT_TRUE(test, !p); 312 } 313 314 static void tb_test_path_not_connected_walk(struct kunit *test) 315 { 316 struct tb_port *src_port, *dst_port, *p; 317 struct tb_switch *host, *dev; 318 319 host = alloc_host(test); 320 /* No connection between host and dev */ 321 dev = alloc_dev_default(test, NULL, 3, true); 322 323 src_port = &host->ports[12]; 324 dst_port = &dev->ports[16]; 325 326 p = tb_next_port_on_path(src_port, dst_port, NULL); 327 KUNIT_EXPECT_PTR_EQ(test, p, src_port); 328 329 p = tb_next_port_on_path(src_port, dst_port, p); 330 KUNIT_EXPECT_PTR_EQ(test, p, &host->ports[3]); 331 332 p = tb_next_port_on_path(src_port, dst_port, p); 333 KUNIT_EXPECT_TRUE(test, !p); 334 335 /* Other direction */ 336 337 p = tb_next_port_on_path(dst_port, src_port, NULL); 338 KUNIT_EXPECT_PTR_EQ(test, p, dst_port); 339 340 p = tb_next_port_on_path(dst_port, src_port, p); 341 KUNIT_EXPECT_PTR_EQ(test, p, &dev->ports[1]); 342 343 p = tb_next_port_on_path(dst_port, src_port, p); 344 KUNIT_EXPECT_TRUE(test, !p); 345 } 346 347 struct port_expectation { 348 u64 route; 349 u8 port; 350 enum tb_port_type type; 351 }; 352 353 static void tb_test_path_single_hop_walk(struct kunit *test) 354 { 355 /* 356 * Walks from Host PCIe downstream port to Device #1 PCIe 357 * upstream port. 358 * 359 * [Host] 360 * 1 | 361 * 1 | 362 * [Device] 363 */ 364 static const struct port_expectation test_data[] = { 365 { .route = 0x0, .port = 8, .type = TB_TYPE_PCIE_DOWN }, 366 { .route = 0x0, .port = 1, .type = TB_TYPE_PORT }, 367 { .route = 0x1, .port = 1, .type = TB_TYPE_PORT }, 368 { .route = 0x1, .port = 9, .type = TB_TYPE_PCIE_UP }, 369 }; 370 struct tb_port *src_port, *dst_port, *p; 371 struct tb_switch *host, *dev; 372 int i; 373 374 host = alloc_host(test); 375 dev = alloc_dev_default(test, host, 1, true); 376 377 src_port = &host->ports[8]; 378 dst_port = &dev->ports[9]; 379 380 /* Walk both directions */ 381 382 i = 0; 383 tb_for_each_port_on_path(src_port, dst_port, p) { 384 KUNIT_EXPECT_TRUE(test, i < ARRAY_SIZE(test_data)); 385 KUNIT_EXPECT_EQ(test, tb_route(p->sw), test_data[i].route); 386 KUNIT_EXPECT_EQ(test, p->port, test_data[i].port); 387 KUNIT_EXPECT_EQ(test, (enum tb_port_type)p->config.type, 388 test_data[i].type); 389 i++; 390 } 391 392 KUNIT_EXPECT_EQ(test, i, (int)ARRAY_SIZE(test_data)); 393 394 i = ARRAY_SIZE(test_data) - 1; 395 tb_for_each_port_on_path(dst_port, src_port, p) { 396 KUNIT_EXPECT_TRUE(test, i < ARRAY_SIZE(test_data)); 397 KUNIT_EXPECT_EQ(test, tb_route(p->sw), test_data[i].route); 398 KUNIT_EXPECT_EQ(test, p->port, test_data[i].port); 399 KUNIT_EXPECT_EQ(test, (enum tb_port_type)p->config.type, 400 test_data[i].type); 401 i--; 402 } 403 404 KUNIT_EXPECT_EQ(test, i, -1); 405 } 406 407 static void tb_test_path_daisy_chain_walk(struct kunit *test) 408 { 409 /* 410 * Walks from Host DP IN to Device #2 DP OUT. 411 * 412 * [Host] 413 * 1 | 414 * 1 | 415 * [Device #1] 416 * 3 / 417 * 1 / 418 * [Device #2] 419 */ 420 static const struct port_expectation test_data[] = { 421 { .route = 0x0, .port = 5, .type = TB_TYPE_DP_HDMI_IN }, 422 { .route = 0x0, .port = 1, .type = TB_TYPE_PORT }, 423 { .route = 0x1, .port = 1, .type = TB_TYPE_PORT }, 424 { .route = 0x1, .port = 3, .type = TB_TYPE_PORT }, 425 { .route = 0x301, .port = 1, .type = TB_TYPE_PORT }, 426 { .route = 0x301, .port = 13, .type = TB_TYPE_DP_HDMI_OUT }, 427 }; 428 struct tb_port *src_port, *dst_port, *p; 429 struct tb_switch *host, *dev1, *dev2; 430 int i; 431 432 host = alloc_host(test); 433 dev1 = alloc_dev_default(test, host, 0x1, true); 434 dev2 = alloc_dev_default(test, dev1, 0x301, true); 435 436 src_port = &host->ports[5]; 437 dst_port = &dev2->ports[13]; 438 439 /* Walk both directions */ 440 441 i = 0; 442 tb_for_each_port_on_path(src_port, dst_port, p) { 443 KUNIT_EXPECT_TRUE(test, i < ARRAY_SIZE(test_data)); 444 KUNIT_EXPECT_EQ(test, tb_route(p->sw), test_data[i].route); 445 KUNIT_EXPECT_EQ(test, p->port, test_data[i].port); 446 KUNIT_EXPECT_EQ(test, (enum tb_port_type)p->config.type, 447 test_data[i].type); 448 i++; 449 } 450 451 KUNIT_EXPECT_EQ(test, i, (int)ARRAY_SIZE(test_data)); 452 453 i = ARRAY_SIZE(test_data) - 1; 454 tb_for_each_port_on_path(dst_port, src_port, p) { 455 KUNIT_EXPECT_TRUE(test, i < ARRAY_SIZE(test_data)); 456 KUNIT_EXPECT_EQ(test, tb_route(p->sw), test_data[i].route); 457 KUNIT_EXPECT_EQ(test, p->port, test_data[i].port); 458 KUNIT_EXPECT_EQ(test, (enum tb_port_type)p->config.type, 459 test_data[i].type); 460 i--; 461 } 462 463 KUNIT_EXPECT_EQ(test, i, -1); 464 } 465 466 static void tb_test_path_simple_tree_walk(struct kunit *test) 467 { 468 /* 469 * Walks from Host DP IN to Device #3 DP OUT. 470 * 471 * [Host] 472 * 1 | 473 * 1 | 474 * [Device #1] 475 * 3 / | 5 \ 7 476 * 1 / | \ 1 477 * [Device #2] | [Device #4] 478 * | 1 479 * [Device #3] 480 */ 481 static const struct port_expectation test_data[] = { 482 { .route = 0x0, .port = 5, .type = TB_TYPE_DP_HDMI_IN }, 483 { .route = 0x0, .port = 1, .type = TB_TYPE_PORT }, 484 { .route = 0x1, .port = 1, .type = TB_TYPE_PORT }, 485 { .route = 0x1, .port = 5, .type = TB_TYPE_PORT }, 486 { .route = 0x501, .port = 1, .type = TB_TYPE_PORT }, 487 { .route = 0x501, .port = 13, .type = TB_TYPE_DP_HDMI_OUT }, 488 }; 489 struct tb_port *src_port, *dst_port, *p; 490 struct tb_switch *host, *dev1, *dev3; 491 int i; 492 493 host = alloc_host(test); 494 dev1 = alloc_dev_default(test, host, 0x1, true); 495 alloc_dev_default(test, dev1, 0x301, true); 496 dev3 = alloc_dev_default(test, dev1, 0x501, true); 497 alloc_dev_default(test, dev1, 0x701, true); 498 499 src_port = &host->ports[5]; 500 dst_port = &dev3->ports[13]; 501 502 /* Walk both directions */ 503 504 i = 0; 505 tb_for_each_port_on_path(src_port, dst_port, p) { 506 KUNIT_EXPECT_TRUE(test, i < ARRAY_SIZE(test_data)); 507 KUNIT_EXPECT_EQ(test, tb_route(p->sw), test_data[i].route); 508 KUNIT_EXPECT_EQ(test, p->port, test_data[i].port); 509 KUNIT_EXPECT_EQ(test, (enum tb_port_type)p->config.type, 510 test_data[i].type); 511 i++; 512 } 513 514 KUNIT_EXPECT_EQ(test, i, (int)ARRAY_SIZE(test_data)); 515 516 i = ARRAY_SIZE(test_data) - 1; 517 tb_for_each_port_on_path(dst_port, src_port, p) { 518 KUNIT_EXPECT_TRUE(test, i < ARRAY_SIZE(test_data)); 519 KUNIT_EXPECT_EQ(test, tb_route(p->sw), test_data[i].route); 520 KUNIT_EXPECT_EQ(test, p->port, test_data[i].port); 521 KUNIT_EXPECT_EQ(test, (enum tb_port_type)p->config.type, 522 test_data[i].type); 523 i--; 524 } 525 526 KUNIT_EXPECT_EQ(test, i, -1); 527 } 528 529 static void tb_test_path_complex_tree_walk(struct kunit *test) 530 { 531 /* 532 * Walks from Device #3 DP IN to Device #9 DP OUT. 533 * 534 * [Host] 535 * 1 | 536 * 1 | 537 * [Device #1] 538 * 3 / | 5 \ 7 539 * 1 / | \ 1 540 * [Device #2] | [Device #5] 541 * 5 | | 1 \ 7 542 * 1 | [Device #4] \ 1 543 * [Device #3] [Device #6] 544 * 3 / 545 * 1 / 546 * [Device #7] 547 * 3 / | 5 548 * 1 / | 549 * [Device #8] | 1 550 * [Device #9] 551 */ 552 static const struct port_expectation test_data[] = { 553 { .route = 0x50301, .port = 13, .type = TB_TYPE_DP_HDMI_IN }, 554 { .route = 0x50301, .port = 1, .type = TB_TYPE_PORT }, 555 { .route = 0x301, .port = 5, .type = TB_TYPE_PORT }, 556 { .route = 0x301, .port = 1, .type = TB_TYPE_PORT }, 557 { .route = 0x1, .port = 3, .type = TB_TYPE_PORT }, 558 { .route = 0x1, .port = 7, .type = TB_TYPE_PORT }, 559 { .route = 0x701, .port = 1, .type = TB_TYPE_PORT }, 560 { .route = 0x701, .port = 7, .type = TB_TYPE_PORT }, 561 { .route = 0x70701, .port = 1, .type = TB_TYPE_PORT }, 562 { .route = 0x70701, .port = 3, .type = TB_TYPE_PORT }, 563 { .route = 0x3070701, .port = 1, .type = TB_TYPE_PORT }, 564 { .route = 0x3070701, .port = 5, .type = TB_TYPE_PORT }, 565 { .route = 0x503070701, .port = 1, .type = TB_TYPE_PORT }, 566 { .route = 0x503070701, .port = 14, .type = TB_TYPE_DP_HDMI_OUT }, 567 }; 568 struct tb_switch *host, *dev1, *dev2, *dev3, *dev5, *dev6, *dev7, *dev9; 569 struct tb_port *src_port, *dst_port, *p; 570 int i; 571 572 host = alloc_host(test); 573 dev1 = alloc_dev_default(test, host, 0x1, true); 574 dev2 = alloc_dev_default(test, dev1, 0x301, true); 575 dev3 = alloc_dev_with_dpin(test, dev2, 0x50301, true); 576 alloc_dev_default(test, dev1, 0x501, true); 577 dev5 = alloc_dev_default(test, dev1, 0x701, true); 578 dev6 = alloc_dev_default(test, dev5, 0x70701, true); 579 dev7 = alloc_dev_default(test, dev6, 0x3070701, true); 580 alloc_dev_default(test, dev7, 0x303070701, true); 581 dev9 = alloc_dev_default(test, dev7, 0x503070701, true); 582 583 src_port = &dev3->ports[13]; 584 dst_port = &dev9->ports[14]; 585 586 /* Walk both directions */ 587 588 i = 0; 589 tb_for_each_port_on_path(src_port, dst_port, p) { 590 KUNIT_EXPECT_TRUE(test, i < ARRAY_SIZE(test_data)); 591 KUNIT_EXPECT_EQ(test, tb_route(p->sw), test_data[i].route); 592 KUNIT_EXPECT_EQ(test, p->port, test_data[i].port); 593 KUNIT_EXPECT_EQ(test, (enum tb_port_type)p->config.type, 594 test_data[i].type); 595 i++; 596 } 597 598 KUNIT_EXPECT_EQ(test, i, (int)ARRAY_SIZE(test_data)); 599 600 i = ARRAY_SIZE(test_data) - 1; 601 tb_for_each_port_on_path(dst_port, src_port, p) { 602 KUNIT_EXPECT_TRUE(test, i < ARRAY_SIZE(test_data)); 603 KUNIT_EXPECT_EQ(test, tb_route(p->sw), test_data[i].route); 604 KUNIT_EXPECT_EQ(test, p->port, test_data[i].port); 605 KUNIT_EXPECT_EQ(test, (enum tb_port_type)p->config.type, 606 test_data[i].type); 607 i--; 608 } 609 610 KUNIT_EXPECT_EQ(test, i, -1); 611 } 612 613 static void tb_test_path_max_length_walk(struct kunit *test) 614 { 615 struct tb_switch *host, *dev1, *dev2, *dev3, *dev4, *dev5, *dev6; 616 struct tb_switch *dev7, *dev8, *dev9, *dev10, *dev11, *dev12; 617 struct tb_port *src_port, *dst_port, *p; 618 int i; 619 620 /* 621 * Walks from Device #6 DP IN to Device #12 DP OUT. 622 * 623 * [Host] 624 * 1 / \ 3 625 * 1 / \ 1 626 * [Device #1] [Device #7] 627 * 3 | | 3 628 * 1 | | 1 629 * [Device #2] [Device #8] 630 * 3 | | 3 631 * 1 | | 1 632 * [Device #3] [Device #9] 633 * 3 | | 3 634 * 1 | | 1 635 * [Device #4] [Device #10] 636 * 3 | | 3 637 * 1 | | 1 638 * [Device #5] [Device #11] 639 * 3 | | 3 640 * 1 | | 1 641 * [Device #6] [Device #12] 642 */ 643 static const struct port_expectation test_data[] = { 644 { .route = 0x30303030301, .port = 13, .type = TB_TYPE_DP_HDMI_IN }, 645 { .route = 0x30303030301, .port = 1, .type = TB_TYPE_PORT }, 646 { .route = 0x303030301, .port = 3, .type = TB_TYPE_PORT }, 647 { .route = 0x303030301, .port = 1, .type = TB_TYPE_PORT }, 648 { .route = 0x3030301, .port = 3, .type = TB_TYPE_PORT }, 649 { .route = 0x3030301, .port = 1, .type = TB_TYPE_PORT }, 650 { .route = 0x30301, .port = 3, .type = TB_TYPE_PORT }, 651 { .route = 0x30301, .port = 1, .type = TB_TYPE_PORT }, 652 { .route = 0x301, .port = 3, .type = TB_TYPE_PORT }, 653 { .route = 0x301, .port = 1, .type = TB_TYPE_PORT }, 654 { .route = 0x1, .port = 3, .type = TB_TYPE_PORT }, 655 { .route = 0x1, .port = 1, .type = TB_TYPE_PORT }, 656 { .route = 0x0, .port = 1, .type = TB_TYPE_PORT }, 657 { .route = 0x0, .port = 3, .type = TB_TYPE_PORT }, 658 { .route = 0x3, .port = 1, .type = TB_TYPE_PORT }, 659 { .route = 0x3, .port = 3, .type = TB_TYPE_PORT }, 660 { .route = 0x303, .port = 1, .type = TB_TYPE_PORT }, 661 { .route = 0x303, .port = 3, .type = TB_TYPE_PORT }, 662 { .route = 0x30303, .port = 1, .type = TB_TYPE_PORT }, 663 { .route = 0x30303, .port = 3, .type = TB_TYPE_PORT }, 664 { .route = 0x3030303, .port = 1, .type = TB_TYPE_PORT }, 665 { .route = 0x3030303, .port = 3, .type = TB_TYPE_PORT }, 666 { .route = 0x303030303, .port = 1, .type = TB_TYPE_PORT }, 667 { .route = 0x303030303, .port = 3, .type = TB_TYPE_PORT }, 668 { .route = 0x30303030303, .port = 1, .type = TB_TYPE_PORT }, 669 { .route = 0x30303030303, .port = 13, .type = TB_TYPE_DP_HDMI_OUT }, 670 }; 671 672 host = alloc_host(test); 673 dev1 = alloc_dev_default(test, host, 0x1, true); 674 dev2 = alloc_dev_default(test, dev1, 0x301, true); 675 dev3 = alloc_dev_default(test, dev2, 0x30301, true); 676 dev4 = alloc_dev_default(test, dev3, 0x3030301, true); 677 dev5 = alloc_dev_default(test, dev4, 0x303030301, true); 678 dev6 = alloc_dev_with_dpin(test, dev5, 0x30303030301, true); 679 dev7 = alloc_dev_default(test, host, 0x3, true); 680 dev8 = alloc_dev_default(test, dev7, 0x303, true); 681 dev9 = alloc_dev_default(test, dev8, 0x30303, true); 682 dev10 = alloc_dev_default(test, dev9, 0x3030303, true); 683 dev11 = alloc_dev_default(test, dev10, 0x303030303, true); 684 dev12 = alloc_dev_default(test, dev11, 0x30303030303, true); 685 686 src_port = &dev6->ports[13]; 687 dst_port = &dev12->ports[13]; 688 689 /* Walk both directions */ 690 691 i = 0; 692 tb_for_each_port_on_path(src_port, dst_port, p) { 693 KUNIT_EXPECT_TRUE(test, i < ARRAY_SIZE(test_data)); 694 KUNIT_EXPECT_EQ(test, tb_route(p->sw), test_data[i].route); 695 KUNIT_EXPECT_EQ(test, p->port, test_data[i].port); 696 KUNIT_EXPECT_EQ(test, (enum tb_port_type)p->config.type, 697 test_data[i].type); 698 i++; 699 } 700 701 KUNIT_EXPECT_EQ(test, i, (int)ARRAY_SIZE(test_data)); 702 703 i = ARRAY_SIZE(test_data) - 1; 704 tb_for_each_port_on_path(dst_port, src_port, p) { 705 KUNIT_EXPECT_TRUE(test, i < ARRAY_SIZE(test_data)); 706 KUNIT_EXPECT_EQ(test, tb_route(p->sw), test_data[i].route); 707 KUNIT_EXPECT_EQ(test, p->port, test_data[i].port); 708 KUNIT_EXPECT_EQ(test, (enum tb_port_type)p->config.type, 709 test_data[i].type); 710 i--; 711 } 712 713 KUNIT_EXPECT_EQ(test, i, -1); 714 } 715 716 static void tb_test_path_not_connected(struct kunit *test) 717 { 718 struct tb_switch *host, *dev1, *dev2; 719 struct tb_port *down, *up; 720 struct tb_path *path; 721 722 host = alloc_host(test); 723 dev1 = alloc_dev_default(test, host, 0x3, false); 724 /* Not connected to anything */ 725 dev2 = alloc_dev_default(test, NULL, 0x303, false); 726 727 down = &dev1->ports[10]; 728 up = &dev2->ports[9]; 729 730 path = tb_path_alloc(NULL, down, 8, up, 8, 0, "PCIe Down"); 731 KUNIT_ASSERT_TRUE(test, path == NULL); 732 path = tb_path_alloc(NULL, down, 8, up, 8, 1, "PCIe Down"); 733 KUNIT_ASSERT_TRUE(test, path == NULL); 734 } 735 736 struct hop_expectation { 737 u64 route; 738 u8 in_port; 739 enum tb_port_type in_type; 740 u8 out_port; 741 enum tb_port_type out_type; 742 }; 743 744 static void tb_test_path_not_bonded_lane0(struct kunit *test) 745 { 746 /* 747 * PCIe path from host to device using lane 0. 748 * 749 * [Host] 750 * 3 |: 4 751 * 1 |: 2 752 * [Device] 753 */ 754 static const struct hop_expectation test_data[] = { 755 { 756 .route = 0x0, 757 .in_port = 9, 758 .in_type = TB_TYPE_PCIE_DOWN, 759 .out_port = 3, 760 .out_type = TB_TYPE_PORT, 761 }, 762 { 763 .route = 0x3, 764 .in_port = 1, 765 .in_type = TB_TYPE_PORT, 766 .out_port = 9, 767 .out_type = TB_TYPE_PCIE_UP, 768 }, 769 }; 770 struct tb_switch *host, *dev; 771 struct tb_port *down, *up; 772 struct tb_path *path; 773 int i; 774 775 host = alloc_host(test); 776 dev = alloc_dev_default(test, host, 0x3, false); 777 778 down = &host->ports[9]; 779 up = &dev->ports[9]; 780 781 path = tb_path_alloc(NULL, down, 8, up, 8, 0, "PCIe Down"); 782 KUNIT_ASSERT_TRUE(test, path != NULL); 783 KUNIT_ASSERT_EQ(test, path->path_length, (int)ARRAY_SIZE(test_data)); 784 for (i = 0; i < ARRAY_SIZE(test_data); i++) { 785 const struct tb_port *in_port, *out_port; 786 787 in_port = path->hops[i].in_port; 788 out_port = path->hops[i].out_port; 789 790 KUNIT_EXPECT_EQ(test, tb_route(in_port->sw), test_data[i].route); 791 KUNIT_EXPECT_EQ(test, in_port->port, test_data[i].in_port); 792 KUNIT_EXPECT_EQ(test, (enum tb_port_type)in_port->config.type, 793 test_data[i].in_type); 794 KUNIT_EXPECT_EQ(test, tb_route(out_port->sw), test_data[i].route); 795 KUNIT_EXPECT_EQ(test, out_port->port, test_data[i].out_port); 796 KUNIT_EXPECT_EQ(test, (enum tb_port_type)out_port->config.type, 797 test_data[i].out_type); 798 } 799 tb_path_free(path); 800 } 801 802 static void tb_test_path_not_bonded_lane1(struct kunit *test) 803 { 804 /* 805 * DP Video path from host to device using lane 1. Paths like 806 * these are only used with Thunderbolt 1 devices where lane 807 * bonding is not possible. USB4 specifically does not allow 808 * paths like this (you either use lane 0 where lane 1 is 809 * disabled or both lanes are bonded). 810 * 811 * [Host] 812 * 1 :| 2 813 * 1 :| 2 814 * [Device] 815 */ 816 static const struct hop_expectation test_data[] = { 817 { 818 .route = 0x0, 819 .in_port = 5, 820 .in_type = TB_TYPE_DP_HDMI_IN, 821 .out_port = 2, 822 .out_type = TB_TYPE_PORT, 823 }, 824 { 825 .route = 0x1, 826 .in_port = 2, 827 .in_type = TB_TYPE_PORT, 828 .out_port = 13, 829 .out_type = TB_TYPE_DP_HDMI_OUT, 830 }, 831 }; 832 struct tb_switch *host, *dev; 833 struct tb_port *in, *out; 834 struct tb_path *path; 835 int i; 836 837 host = alloc_host(test); 838 dev = alloc_dev_default(test, host, 0x1, false); 839 840 in = &host->ports[5]; 841 out = &dev->ports[13]; 842 843 path = tb_path_alloc(NULL, in, 9, out, 9, 1, "Video"); 844 KUNIT_ASSERT_TRUE(test, path != NULL); 845 KUNIT_ASSERT_EQ(test, path->path_length, (int)ARRAY_SIZE(test_data)); 846 for (i = 0; i < ARRAY_SIZE(test_data); i++) { 847 const struct tb_port *in_port, *out_port; 848 849 in_port = path->hops[i].in_port; 850 out_port = path->hops[i].out_port; 851 852 KUNIT_EXPECT_EQ(test, tb_route(in_port->sw), test_data[i].route); 853 KUNIT_EXPECT_EQ(test, in_port->port, test_data[i].in_port); 854 KUNIT_EXPECT_EQ(test, (enum tb_port_type)in_port->config.type, 855 test_data[i].in_type); 856 KUNIT_EXPECT_EQ(test, tb_route(out_port->sw), test_data[i].route); 857 KUNIT_EXPECT_EQ(test, out_port->port, test_data[i].out_port); 858 KUNIT_EXPECT_EQ(test, (enum tb_port_type)out_port->config.type, 859 test_data[i].out_type); 860 } 861 tb_path_free(path); 862 } 863 864 static void tb_test_path_not_bonded_lane1_chain(struct kunit *test) 865 { 866 /* 867 * DP Video path from host to device 3 using lane 1. 868 * 869 * [Host] 870 * 1 :| 2 871 * 1 :| 2 872 * [Device #1] 873 * 7 :| 8 874 * 1 :| 2 875 * [Device #2] 876 * 5 :| 6 877 * 1 :| 2 878 * [Device #3] 879 */ 880 static const struct hop_expectation test_data[] = { 881 { 882 .route = 0x0, 883 .in_port = 5, 884 .in_type = TB_TYPE_DP_HDMI_IN, 885 .out_port = 2, 886 .out_type = TB_TYPE_PORT, 887 }, 888 { 889 .route = 0x1, 890 .in_port = 2, 891 .in_type = TB_TYPE_PORT, 892 .out_port = 8, 893 .out_type = TB_TYPE_PORT, 894 }, 895 { 896 .route = 0x701, 897 .in_port = 2, 898 .in_type = TB_TYPE_PORT, 899 .out_port = 6, 900 .out_type = TB_TYPE_PORT, 901 }, 902 { 903 .route = 0x50701, 904 .in_port = 2, 905 .in_type = TB_TYPE_PORT, 906 .out_port = 13, 907 .out_type = TB_TYPE_DP_HDMI_OUT, 908 }, 909 }; 910 struct tb_switch *host, *dev1, *dev2, *dev3; 911 struct tb_port *in, *out; 912 struct tb_path *path; 913 int i; 914 915 host = alloc_host(test); 916 dev1 = alloc_dev_default(test, host, 0x1, false); 917 dev2 = alloc_dev_default(test, dev1, 0x701, false); 918 dev3 = alloc_dev_default(test, dev2, 0x50701, false); 919 920 in = &host->ports[5]; 921 out = &dev3->ports[13]; 922 923 path = tb_path_alloc(NULL, in, 9, out, 9, 1, "Video"); 924 KUNIT_ASSERT_TRUE(test, path != NULL); 925 KUNIT_ASSERT_EQ(test, path->path_length, (int)ARRAY_SIZE(test_data)); 926 for (i = 0; i < ARRAY_SIZE(test_data); i++) { 927 const struct tb_port *in_port, *out_port; 928 929 in_port = path->hops[i].in_port; 930 out_port = path->hops[i].out_port; 931 932 KUNIT_EXPECT_EQ(test, tb_route(in_port->sw), test_data[i].route); 933 KUNIT_EXPECT_EQ(test, in_port->port, test_data[i].in_port); 934 KUNIT_EXPECT_EQ(test, (enum tb_port_type)in_port->config.type, 935 test_data[i].in_type); 936 KUNIT_EXPECT_EQ(test, tb_route(out_port->sw), test_data[i].route); 937 KUNIT_EXPECT_EQ(test, out_port->port, test_data[i].out_port); 938 KUNIT_EXPECT_EQ(test, (enum tb_port_type)out_port->config.type, 939 test_data[i].out_type); 940 } 941 tb_path_free(path); 942 } 943 944 static void tb_test_path_not_bonded_lane1_chain_reverse(struct kunit *test) 945 { 946 /* 947 * DP Video path from device 3 to host using lane 1. 948 * 949 * [Host] 950 * 1 :| 2 951 * 1 :| 2 952 * [Device #1] 953 * 7 :| 8 954 * 1 :| 2 955 * [Device #2] 956 * 5 :| 6 957 * 1 :| 2 958 * [Device #3] 959 */ 960 static const struct hop_expectation test_data[] = { 961 { 962 .route = 0x50701, 963 .in_port = 13, 964 .in_type = TB_TYPE_DP_HDMI_IN, 965 .out_port = 2, 966 .out_type = TB_TYPE_PORT, 967 }, 968 { 969 .route = 0x701, 970 .in_port = 6, 971 .in_type = TB_TYPE_PORT, 972 .out_port = 2, 973 .out_type = TB_TYPE_PORT, 974 }, 975 { 976 .route = 0x1, 977 .in_port = 8, 978 .in_type = TB_TYPE_PORT, 979 .out_port = 2, 980 .out_type = TB_TYPE_PORT, 981 }, 982 { 983 .route = 0x0, 984 .in_port = 2, 985 .in_type = TB_TYPE_PORT, 986 .out_port = 5, 987 .out_type = TB_TYPE_DP_HDMI_IN, 988 }, 989 }; 990 struct tb_switch *host, *dev1, *dev2, *dev3; 991 struct tb_port *in, *out; 992 struct tb_path *path; 993 int i; 994 995 host = alloc_host(test); 996 dev1 = alloc_dev_default(test, host, 0x1, false); 997 dev2 = alloc_dev_default(test, dev1, 0x701, false); 998 dev3 = alloc_dev_with_dpin(test, dev2, 0x50701, false); 999 1000 in = &dev3->ports[13]; 1001 out = &host->ports[5]; 1002 1003 path = tb_path_alloc(NULL, in, 9, out, 9, 1, "Video"); 1004 KUNIT_ASSERT_TRUE(test, path != NULL); 1005 KUNIT_ASSERT_EQ(test, path->path_length, (int)ARRAY_SIZE(test_data)); 1006 for (i = 0; i < ARRAY_SIZE(test_data); i++) { 1007 const struct tb_port *in_port, *out_port; 1008 1009 in_port = path->hops[i].in_port; 1010 out_port = path->hops[i].out_port; 1011 1012 KUNIT_EXPECT_EQ(test, tb_route(in_port->sw), test_data[i].route); 1013 KUNIT_EXPECT_EQ(test, in_port->port, test_data[i].in_port); 1014 KUNIT_EXPECT_EQ(test, (enum tb_port_type)in_port->config.type, 1015 test_data[i].in_type); 1016 KUNIT_EXPECT_EQ(test, tb_route(out_port->sw), test_data[i].route); 1017 KUNIT_EXPECT_EQ(test, out_port->port, test_data[i].out_port); 1018 KUNIT_EXPECT_EQ(test, (enum tb_port_type)out_port->config.type, 1019 test_data[i].out_type); 1020 } 1021 tb_path_free(path); 1022 } 1023 1024 static void tb_test_path_mixed_chain(struct kunit *test) 1025 { 1026 /* 1027 * DP Video path from host to device 4 where first and last link 1028 * is bonded. 1029 * 1030 * [Host] 1031 * 1 | 1032 * 1 | 1033 * [Device #1] 1034 * 7 :| 8 1035 * 1 :| 2 1036 * [Device #2] 1037 * 5 :| 6 1038 * 1 :| 2 1039 * [Device #3] 1040 * 3 | 1041 * 1 | 1042 * [Device #4] 1043 */ 1044 static const struct hop_expectation test_data[] = { 1045 { 1046 .route = 0x0, 1047 .in_port = 5, 1048 .in_type = TB_TYPE_DP_HDMI_IN, 1049 .out_port = 1, 1050 .out_type = TB_TYPE_PORT, 1051 }, 1052 { 1053 .route = 0x1, 1054 .in_port = 1, 1055 .in_type = TB_TYPE_PORT, 1056 .out_port = 8, 1057 .out_type = TB_TYPE_PORT, 1058 }, 1059 { 1060 .route = 0x701, 1061 .in_port = 2, 1062 .in_type = TB_TYPE_PORT, 1063 .out_port = 6, 1064 .out_type = TB_TYPE_PORT, 1065 }, 1066 { 1067 .route = 0x50701, 1068 .in_port = 2, 1069 .in_type = TB_TYPE_PORT, 1070 .out_port = 3, 1071 .out_type = TB_TYPE_PORT, 1072 }, 1073 { 1074 .route = 0x3050701, 1075 .in_port = 1, 1076 .in_type = TB_TYPE_PORT, 1077 .out_port = 13, 1078 .out_type = TB_TYPE_DP_HDMI_OUT, 1079 }, 1080 }; 1081 struct tb_switch *host, *dev1, *dev2, *dev3, *dev4; 1082 struct tb_port *in, *out; 1083 struct tb_path *path; 1084 int i; 1085 1086 host = alloc_host(test); 1087 dev1 = alloc_dev_default(test, host, 0x1, true); 1088 dev2 = alloc_dev_default(test, dev1, 0x701, false); 1089 dev3 = alloc_dev_default(test, dev2, 0x50701, false); 1090 dev4 = alloc_dev_default(test, dev3, 0x3050701, true); 1091 1092 in = &host->ports[5]; 1093 out = &dev4->ports[13]; 1094 1095 path = tb_path_alloc(NULL, in, 9, out, 9, 1, "Video"); 1096 KUNIT_ASSERT_TRUE(test, path != NULL); 1097 KUNIT_ASSERT_EQ(test, path->path_length, (int)ARRAY_SIZE(test_data)); 1098 for (i = 0; i < ARRAY_SIZE(test_data); i++) { 1099 const struct tb_port *in_port, *out_port; 1100 1101 in_port = path->hops[i].in_port; 1102 out_port = path->hops[i].out_port; 1103 1104 KUNIT_EXPECT_EQ(test, tb_route(in_port->sw), test_data[i].route); 1105 KUNIT_EXPECT_EQ(test, in_port->port, test_data[i].in_port); 1106 KUNIT_EXPECT_EQ(test, (enum tb_port_type)in_port->config.type, 1107 test_data[i].in_type); 1108 KUNIT_EXPECT_EQ(test, tb_route(out_port->sw), test_data[i].route); 1109 KUNIT_EXPECT_EQ(test, out_port->port, test_data[i].out_port); 1110 KUNIT_EXPECT_EQ(test, (enum tb_port_type)out_port->config.type, 1111 test_data[i].out_type); 1112 } 1113 tb_path_free(path); 1114 } 1115 1116 static void tb_test_path_mixed_chain_reverse(struct kunit *test) 1117 { 1118 /* 1119 * DP Video path from device 4 to host where first and last link 1120 * is bonded. 1121 * 1122 * [Host] 1123 * 1 | 1124 * 1 | 1125 * [Device #1] 1126 * 7 :| 8 1127 * 1 :| 2 1128 * [Device #2] 1129 * 5 :| 6 1130 * 1 :| 2 1131 * [Device #3] 1132 * 3 | 1133 * 1 | 1134 * [Device #4] 1135 */ 1136 static const struct hop_expectation test_data[] = { 1137 { 1138 .route = 0x3050701, 1139 .in_port = 13, 1140 .in_type = TB_TYPE_DP_HDMI_OUT, 1141 .out_port = 1, 1142 .out_type = TB_TYPE_PORT, 1143 }, 1144 { 1145 .route = 0x50701, 1146 .in_port = 3, 1147 .in_type = TB_TYPE_PORT, 1148 .out_port = 2, 1149 .out_type = TB_TYPE_PORT, 1150 }, 1151 { 1152 .route = 0x701, 1153 .in_port = 6, 1154 .in_type = TB_TYPE_PORT, 1155 .out_port = 2, 1156 .out_type = TB_TYPE_PORT, 1157 }, 1158 { 1159 .route = 0x1, 1160 .in_port = 8, 1161 .in_type = TB_TYPE_PORT, 1162 .out_port = 1, 1163 .out_type = TB_TYPE_PORT, 1164 }, 1165 { 1166 .route = 0x0, 1167 .in_port = 1, 1168 .in_type = TB_TYPE_PORT, 1169 .out_port = 5, 1170 .out_type = TB_TYPE_DP_HDMI_IN, 1171 }, 1172 }; 1173 struct tb_switch *host, *dev1, *dev2, *dev3, *dev4; 1174 struct tb_port *in, *out; 1175 struct tb_path *path; 1176 int i; 1177 1178 host = alloc_host(test); 1179 dev1 = alloc_dev_default(test, host, 0x1, true); 1180 dev2 = alloc_dev_default(test, dev1, 0x701, false); 1181 dev3 = alloc_dev_default(test, dev2, 0x50701, false); 1182 dev4 = alloc_dev_default(test, dev3, 0x3050701, true); 1183 1184 in = &dev4->ports[13]; 1185 out = &host->ports[5]; 1186 1187 path = tb_path_alloc(NULL, in, 9, out, 9, 1, "Video"); 1188 KUNIT_ASSERT_TRUE(test, path != NULL); 1189 KUNIT_ASSERT_EQ(test, path->path_length, (int)ARRAY_SIZE(test_data)); 1190 for (i = 0; i < ARRAY_SIZE(test_data); i++) { 1191 const struct tb_port *in_port, *out_port; 1192 1193 in_port = path->hops[i].in_port; 1194 out_port = path->hops[i].out_port; 1195 1196 KUNIT_EXPECT_EQ(test, tb_route(in_port->sw), test_data[i].route); 1197 KUNIT_EXPECT_EQ(test, in_port->port, test_data[i].in_port); 1198 KUNIT_EXPECT_EQ(test, (enum tb_port_type)in_port->config.type, 1199 test_data[i].in_type); 1200 KUNIT_EXPECT_EQ(test, tb_route(out_port->sw), test_data[i].route); 1201 KUNIT_EXPECT_EQ(test, out_port->port, test_data[i].out_port); 1202 KUNIT_EXPECT_EQ(test, (enum tb_port_type)out_port->config.type, 1203 test_data[i].out_type); 1204 } 1205 tb_path_free(path); 1206 } 1207 1208 static void tb_test_tunnel_pcie(struct kunit *test) 1209 { 1210 struct tb_switch *host, *dev1, *dev2; 1211 struct tb_tunnel *tunnel1, *tunnel2; 1212 struct tb_port *down, *up; 1213 1214 /* 1215 * Create PCIe tunnel between host and two devices. 1216 * 1217 * [Host] 1218 * 1 | 1219 * 1 | 1220 * [Device #1] 1221 * 5 | 1222 * 1 | 1223 * [Device #2] 1224 */ 1225 host = alloc_host(test); 1226 dev1 = alloc_dev_default(test, host, 0x1, true); 1227 dev2 = alloc_dev_default(test, dev1, 0x501, true); 1228 1229 down = &host->ports[8]; 1230 up = &dev1->ports[9]; 1231 tunnel1 = tb_tunnel_alloc_pci(NULL, up, down); 1232 KUNIT_ASSERT_TRUE(test, tunnel1 != NULL); 1233 KUNIT_EXPECT_EQ(test, tunnel1->type, (enum tb_tunnel_type)TB_TUNNEL_PCI); 1234 KUNIT_EXPECT_PTR_EQ(test, tunnel1->src_port, down); 1235 KUNIT_EXPECT_PTR_EQ(test, tunnel1->dst_port, up); 1236 KUNIT_ASSERT_EQ(test, tunnel1->npaths, (size_t)2); 1237 KUNIT_ASSERT_EQ(test, tunnel1->paths[0]->path_length, 2); 1238 KUNIT_EXPECT_PTR_EQ(test, tunnel1->paths[0]->hops[0].in_port, down); 1239 KUNIT_EXPECT_PTR_EQ(test, tunnel1->paths[0]->hops[1].out_port, up); 1240 KUNIT_ASSERT_EQ(test, tunnel1->paths[1]->path_length, 2); 1241 KUNIT_EXPECT_PTR_EQ(test, tunnel1->paths[1]->hops[0].in_port, up); 1242 KUNIT_EXPECT_PTR_EQ(test, tunnel1->paths[1]->hops[1].out_port, down); 1243 1244 down = &dev1->ports[10]; 1245 up = &dev2->ports[9]; 1246 tunnel2 = tb_tunnel_alloc_pci(NULL, up, down); 1247 KUNIT_ASSERT_TRUE(test, tunnel2 != NULL); 1248 KUNIT_EXPECT_EQ(test, tunnel2->type, (enum tb_tunnel_type)TB_TUNNEL_PCI); 1249 KUNIT_EXPECT_PTR_EQ(test, tunnel2->src_port, down); 1250 KUNIT_EXPECT_PTR_EQ(test, tunnel2->dst_port, up); 1251 KUNIT_ASSERT_EQ(test, tunnel2->npaths, (size_t)2); 1252 KUNIT_ASSERT_EQ(test, tunnel2->paths[0]->path_length, 2); 1253 KUNIT_EXPECT_PTR_EQ(test, tunnel2->paths[0]->hops[0].in_port, down); 1254 KUNIT_EXPECT_PTR_EQ(test, tunnel2->paths[0]->hops[1].out_port, up); 1255 KUNIT_ASSERT_EQ(test, tunnel2->paths[1]->path_length, 2); 1256 KUNIT_EXPECT_PTR_EQ(test, tunnel2->paths[1]->hops[0].in_port, up); 1257 KUNIT_EXPECT_PTR_EQ(test, tunnel2->paths[1]->hops[1].out_port, down); 1258 1259 tb_tunnel_free(tunnel2); 1260 tb_tunnel_free(tunnel1); 1261 } 1262 1263 static void tb_test_tunnel_dp(struct kunit *test) 1264 { 1265 struct tb_switch *host, *dev; 1266 struct tb_port *in, *out; 1267 struct tb_tunnel *tunnel; 1268 1269 /* 1270 * Create DP tunnel between Host and Device 1271 * 1272 * [Host] 1273 * 1 | 1274 * 1 | 1275 * [Device] 1276 */ 1277 host = alloc_host(test); 1278 dev = alloc_dev_default(test, host, 0x3, true); 1279 1280 in = &host->ports[5]; 1281 out = &dev->ports[13]; 1282 1283 tunnel = tb_tunnel_alloc_dp(NULL, in, out, 0, 0); 1284 KUNIT_ASSERT_TRUE(test, tunnel != NULL); 1285 KUNIT_EXPECT_EQ(test, tunnel->type, (enum tb_tunnel_type)TB_TUNNEL_DP); 1286 KUNIT_EXPECT_PTR_EQ(test, tunnel->src_port, in); 1287 KUNIT_EXPECT_PTR_EQ(test, tunnel->dst_port, out); 1288 KUNIT_ASSERT_EQ(test, tunnel->npaths, (size_t)3); 1289 KUNIT_ASSERT_EQ(test, tunnel->paths[0]->path_length, 2); 1290 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[0]->hops[0].in_port, in); 1291 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[0]->hops[1].out_port, out); 1292 KUNIT_ASSERT_EQ(test, tunnel->paths[1]->path_length, 2); 1293 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[1]->hops[0].in_port, in); 1294 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[1]->hops[1].out_port, out); 1295 KUNIT_ASSERT_EQ(test, tunnel->paths[2]->path_length, 2); 1296 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[2]->hops[0].in_port, out); 1297 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[2]->hops[1].out_port, in); 1298 tb_tunnel_free(tunnel); 1299 } 1300 1301 static void tb_test_tunnel_dp_chain(struct kunit *test) 1302 { 1303 struct tb_switch *host, *dev1, *dev4; 1304 struct tb_port *in, *out; 1305 struct tb_tunnel *tunnel; 1306 1307 /* 1308 * Create DP tunnel from Host DP IN to Device #4 DP OUT. 1309 * 1310 * [Host] 1311 * 1 | 1312 * 1 | 1313 * [Device #1] 1314 * 3 / | 5 \ 7 1315 * 1 / | \ 1 1316 * [Device #2] | [Device #4] 1317 * | 1 1318 * [Device #3] 1319 */ 1320 host = alloc_host(test); 1321 dev1 = alloc_dev_default(test, host, 0x1, true); 1322 alloc_dev_default(test, dev1, 0x301, true); 1323 alloc_dev_default(test, dev1, 0x501, true); 1324 dev4 = alloc_dev_default(test, dev1, 0x701, true); 1325 1326 in = &host->ports[5]; 1327 out = &dev4->ports[14]; 1328 1329 tunnel = tb_tunnel_alloc_dp(NULL, in, out, 0, 0); 1330 KUNIT_ASSERT_TRUE(test, tunnel != NULL); 1331 KUNIT_EXPECT_EQ(test, tunnel->type, (enum tb_tunnel_type)TB_TUNNEL_DP); 1332 KUNIT_EXPECT_PTR_EQ(test, tunnel->src_port, in); 1333 KUNIT_EXPECT_PTR_EQ(test, tunnel->dst_port, out); 1334 KUNIT_ASSERT_EQ(test, tunnel->npaths, (size_t)3); 1335 KUNIT_ASSERT_EQ(test, tunnel->paths[0]->path_length, 3); 1336 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[0]->hops[0].in_port, in); 1337 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[0]->hops[2].out_port, out); 1338 KUNIT_ASSERT_EQ(test, tunnel->paths[1]->path_length, 3); 1339 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[1]->hops[0].in_port, in); 1340 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[1]->hops[2].out_port, out); 1341 KUNIT_ASSERT_EQ(test, tunnel->paths[2]->path_length, 3); 1342 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[2]->hops[0].in_port, out); 1343 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[2]->hops[2].out_port, in); 1344 tb_tunnel_free(tunnel); 1345 } 1346 1347 static void tb_test_tunnel_dp_tree(struct kunit *test) 1348 { 1349 struct tb_switch *host, *dev1, *dev2, *dev3, *dev5; 1350 struct tb_port *in, *out; 1351 struct tb_tunnel *tunnel; 1352 1353 /* 1354 * Create DP tunnel from Device #2 DP IN to Device #5 DP OUT. 1355 * 1356 * [Host] 1357 * 3 | 1358 * 1 | 1359 * [Device #1] 1360 * 3 / | 5 \ 7 1361 * 1 / | \ 1 1362 * [Device #2] | [Device #4] 1363 * | 1 1364 * [Device #3] 1365 * | 5 1366 * | 1 1367 * [Device #5] 1368 */ 1369 host = alloc_host(test); 1370 dev1 = alloc_dev_default(test, host, 0x3, true); 1371 dev2 = alloc_dev_with_dpin(test, dev1, 0x303, true); 1372 dev3 = alloc_dev_default(test, dev1, 0x503, true); 1373 alloc_dev_default(test, dev1, 0x703, true); 1374 dev5 = alloc_dev_default(test, dev3, 0x50503, true); 1375 1376 in = &dev2->ports[13]; 1377 out = &dev5->ports[13]; 1378 1379 tunnel = tb_tunnel_alloc_dp(NULL, in, out, 0, 0); 1380 KUNIT_ASSERT_TRUE(test, tunnel != NULL); 1381 KUNIT_EXPECT_EQ(test, tunnel->type, (enum tb_tunnel_type)TB_TUNNEL_DP); 1382 KUNIT_EXPECT_PTR_EQ(test, tunnel->src_port, in); 1383 KUNIT_EXPECT_PTR_EQ(test, tunnel->dst_port, out); 1384 KUNIT_ASSERT_EQ(test, tunnel->npaths, (size_t)3); 1385 KUNIT_ASSERT_EQ(test, tunnel->paths[0]->path_length, 4); 1386 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[0]->hops[0].in_port, in); 1387 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[0]->hops[3].out_port, out); 1388 KUNIT_ASSERT_EQ(test, tunnel->paths[1]->path_length, 4); 1389 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[1]->hops[0].in_port, in); 1390 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[1]->hops[3].out_port, out); 1391 KUNIT_ASSERT_EQ(test, tunnel->paths[2]->path_length, 4); 1392 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[2]->hops[0].in_port, out); 1393 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[2]->hops[3].out_port, in); 1394 tb_tunnel_free(tunnel); 1395 } 1396 1397 static void tb_test_tunnel_dp_max_length(struct kunit *test) 1398 { 1399 struct tb_switch *host, *dev1, *dev2, *dev3, *dev4, *dev5, *dev6; 1400 struct tb_switch *dev7, *dev8, *dev9, *dev10, *dev11, *dev12; 1401 struct tb_port *in, *out; 1402 struct tb_tunnel *tunnel; 1403 1404 /* 1405 * Creates DP tunnel from Device #6 to Device #12. 1406 * 1407 * [Host] 1408 * 1 / \ 3 1409 * 1 / \ 1 1410 * [Device #1] [Device #7] 1411 * 3 | | 3 1412 * 1 | | 1 1413 * [Device #2] [Device #8] 1414 * 3 | | 3 1415 * 1 | | 1 1416 * [Device #3] [Device #9] 1417 * 3 | | 3 1418 * 1 | | 1 1419 * [Device #4] [Device #10] 1420 * 3 | | 3 1421 * 1 | | 1 1422 * [Device #5] [Device #11] 1423 * 3 | | 3 1424 * 1 | | 1 1425 * [Device #6] [Device #12] 1426 */ 1427 host = alloc_host(test); 1428 dev1 = alloc_dev_default(test, host, 0x1, true); 1429 dev2 = alloc_dev_default(test, dev1, 0x301, true); 1430 dev3 = alloc_dev_default(test, dev2, 0x30301, true); 1431 dev4 = alloc_dev_default(test, dev3, 0x3030301, true); 1432 dev5 = alloc_dev_default(test, dev4, 0x303030301, true); 1433 dev6 = alloc_dev_with_dpin(test, dev5, 0x30303030301, true); 1434 dev7 = alloc_dev_default(test, host, 0x3, true); 1435 dev8 = alloc_dev_default(test, dev7, 0x303, true); 1436 dev9 = alloc_dev_default(test, dev8, 0x30303, true); 1437 dev10 = alloc_dev_default(test, dev9, 0x3030303, true); 1438 dev11 = alloc_dev_default(test, dev10, 0x303030303, true); 1439 dev12 = alloc_dev_default(test, dev11, 0x30303030303, true); 1440 1441 in = &dev6->ports[13]; 1442 out = &dev12->ports[13]; 1443 1444 tunnel = tb_tunnel_alloc_dp(NULL, in, out, 0, 0); 1445 KUNIT_ASSERT_TRUE(test, tunnel != NULL); 1446 KUNIT_EXPECT_EQ(test, tunnel->type, (enum tb_tunnel_type)TB_TUNNEL_DP); 1447 KUNIT_EXPECT_PTR_EQ(test, tunnel->src_port, in); 1448 KUNIT_EXPECT_PTR_EQ(test, tunnel->dst_port, out); 1449 KUNIT_ASSERT_EQ(test, tunnel->npaths, (size_t)3); 1450 KUNIT_ASSERT_EQ(test, tunnel->paths[0]->path_length, 13); 1451 /* First hop */ 1452 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[0]->hops[0].in_port, in); 1453 /* Middle */ 1454 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[0]->hops[6].in_port, 1455 &host->ports[1]); 1456 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[0]->hops[6].out_port, 1457 &host->ports[3]); 1458 /* Last */ 1459 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[0]->hops[12].out_port, out); 1460 KUNIT_ASSERT_EQ(test, tunnel->paths[1]->path_length, 13); 1461 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[1]->hops[0].in_port, in); 1462 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[1]->hops[6].in_port, 1463 &host->ports[1]); 1464 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[1]->hops[6].out_port, 1465 &host->ports[3]); 1466 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[1]->hops[12].out_port, out); 1467 KUNIT_ASSERT_EQ(test, tunnel->paths[2]->path_length, 13); 1468 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[2]->hops[0].in_port, out); 1469 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[2]->hops[6].in_port, 1470 &host->ports[3]); 1471 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[2]->hops[6].out_port, 1472 &host->ports[1]); 1473 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[2]->hops[12].out_port, in); 1474 tb_tunnel_free(tunnel); 1475 } 1476 1477 static void tb_test_tunnel_usb3(struct kunit *test) 1478 { 1479 struct tb_switch *host, *dev1, *dev2; 1480 struct tb_tunnel *tunnel1, *tunnel2; 1481 struct tb_port *down, *up; 1482 1483 /* 1484 * Create USB3 tunnel between host and two devices. 1485 * 1486 * [Host] 1487 * 1 | 1488 * 1 | 1489 * [Device #1] 1490 * \ 7 1491 * \ 1 1492 * [Device #2] 1493 */ 1494 host = alloc_host(test); 1495 dev1 = alloc_dev_default(test, host, 0x1, true); 1496 dev2 = alloc_dev_default(test, dev1, 0x701, true); 1497 1498 down = &host->ports[12]; 1499 up = &dev1->ports[16]; 1500 tunnel1 = tb_tunnel_alloc_usb3(NULL, up, down, 0, 0); 1501 KUNIT_ASSERT_TRUE(test, tunnel1 != NULL); 1502 KUNIT_EXPECT_EQ(test, tunnel1->type, (enum tb_tunnel_type)TB_TUNNEL_USB3); 1503 KUNIT_EXPECT_PTR_EQ(test, tunnel1->src_port, down); 1504 KUNIT_EXPECT_PTR_EQ(test, tunnel1->dst_port, up); 1505 KUNIT_ASSERT_EQ(test, tunnel1->npaths, (size_t)2); 1506 KUNIT_ASSERT_EQ(test, tunnel1->paths[0]->path_length, 2); 1507 KUNIT_EXPECT_PTR_EQ(test, tunnel1->paths[0]->hops[0].in_port, down); 1508 KUNIT_EXPECT_PTR_EQ(test, tunnel1->paths[0]->hops[1].out_port, up); 1509 KUNIT_ASSERT_EQ(test, tunnel1->paths[1]->path_length, 2); 1510 KUNIT_EXPECT_PTR_EQ(test, tunnel1->paths[1]->hops[0].in_port, up); 1511 KUNIT_EXPECT_PTR_EQ(test, tunnel1->paths[1]->hops[1].out_port, down); 1512 1513 down = &dev1->ports[17]; 1514 up = &dev2->ports[16]; 1515 tunnel2 = tb_tunnel_alloc_usb3(NULL, up, down, 0, 0); 1516 KUNIT_ASSERT_TRUE(test, tunnel2 != NULL); 1517 KUNIT_EXPECT_EQ(test, tunnel2->type, (enum tb_tunnel_type)TB_TUNNEL_USB3); 1518 KUNIT_EXPECT_PTR_EQ(test, tunnel2->src_port, down); 1519 KUNIT_EXPECT_PTR_EQ(test, tunnel2->dst_port, up); 1520 KUNIT_ASSERT_EQ(test, tunnel2->npaths, (size_t)2); 1521 KUNIT_ASSERT_EQ(test, tunnel2->paths[0]->path_length, 2); 1522 KUNIT_EXPECT_PTR_EQ(test, tunnel2->paths[0]->hops[0].in_port, down); 1523 KUNIT_EXPECT_PTR_EQ(test, tunnel2->paths[0]->hops[1].out_port, up); 1524 KUNIT_ASSERT_EQ(test, tunnel2->paths[1]->path_length, 2); 1525 KUNIT_EXPECT_PTR_EQ(test, tunnel2->paths[1]->hops[0].in_port, up); 1526 KUNIT_EXPECT_PTR_EQ(test, tunnel2->paths[1]->hops[1].out_port, down); 1527 1528 tb_tunnel_free(tunnel2); 1529 tb_tunnel_free(tunnel1); 1530 } 1531 1532 static void tb_test_tunnel_port_on_path(struct kunit *test) 1533 { 1534 struct tb_switch *host, *dev1, *dev2, *dev3, *dev4, *dev5; 1535 struct tb_port *in, *out, *port; 1536 struct tb_tunnel *dp_tunnel; 1537 1538 /* 1539 * [Host] 1540 * 3 | 1541 * 1 | 1542 * [Device #1] 1543 * 3 / | 5 \ 7 1544 * 1 / | \ 1 1545 * [Device #2] | [Device #4] 1546 * | 1 1547 * [Device #3] 1548 * | 5 1549 * | 1 1550 * [Device #5] 1551 */ 1552 host = alloc_host(test); 1553 dev1 = alloc_dev_default(test, host, 0x3, true); 1554 dev2 = alloc_dev_with_dpin(test, dev1, 0x303, true); 1555 dev3 = alloc_dev_default(test, dev1, 0x503, true); 1556 dev4 = alloc_dev_default(test, dev1, 0x703, true); 1557 dev5 = alloc_dev_default(test, dev3, 0x50503, true); 1558 1559 in = &dev2->ports[13]; 1560 out = &dev5->ports[13]; 1561 1562 dp_tunnel = tb_tunnel_alloc_dp(NULL, in, out, 0, 0); 1563 KUNIT_ASSERT_TRUE(test, dp_tunnel != NULL); 1564 1565 KUNIT_EXPECT_TRUE(test, tb_tunnel_port_on_path(dp_tunnel, in)); 1566 KUNIT_EXPECT_TRUE(test, tb_tunnel_port_on_path(dp_tunnel, out)); 1567 1568 port = &host->ports[8]; 1569 KUNIT_EXPECT_FALSE(test, tb_tunnel_port_on_path(dp_tunnel, port)); 1570 1571 port = &host->ports[3]; 1572 KUNIT_EXPECT_FALSE(test, tb_tunnel_port_on_path(dp_tunnel, port)); 1573 1574 port = &dev1->ports[1]; 1575 KUNIT_EXPECT_FALSE(test, tb_tunnel_port_on_path(dp_tunnel, port)); 1576 1577 port = &dev1->ports[3]; 1578 KUNIT_EXPECT_TRUE(test, tb_tunnel_port_on_path(dp_tunnel, port)); 1579 1580 port = &dev1->ports[5]; 1581 KUNIT_EXPECT_TRUE(test, tb_tunnel_port_on_path(dp_tunnel, port)); 1582 1583 port = &dev1->ports[7]; 1584 KUNIT_EXPECT_FALSE(test, tb_tunnel_port_on_path(dp_tunnel, port)); 1585 1586 port = &dev3->ports[1]; 1587 KUNIT_EXPECT_TRUE(test, tb_tunnel_port_on_path(dp_tunnel, port)); 1588 1589 port = &dev5->ports[1]; 1590 KUNIT_EXPECT_TRUE(test, tb_tunnel_port_on_path(dp_tunnel, port)); 1591 1592 port = &dev4->ports[1]; 1593 KUNIT_EXPECT_FALSE(test, tb_tunnel_port_on_path(dp_tunnel, port)); 1594 1595 tb_tunnel_free(dp_tunnel); 1596 } 1597 1598 static void tb_test_tunnel_dma(struct kunit *test) 1599 { 1600 struct tb_port *nhi, *port; 1601 struct tb_tunnel *tunnel; 1602 struct tb_switch *host; 1603 1604 /* 1605 * Create DMA tunnel from NHI to port 1 and back. 1606 * 1607 * [Host 1] 1608 * 1 ^ In HopID 1 -> Out HopID 8 1609 * | 1610 * v In HopID 8 -> Out HopID 1 1611 * ............ Domain border 1612 * | 1613 * [Host 2] 1614 */ 1615 host = alloc_host(test); 1616 nhi = &host->ports[7]; 1617 port = &host->ports[1]; 1618 1619 tunnel = tb_tunnel_alloc_dma(NULL, nhi, port, 8, 1, 8, 1); 1620 KUNIT_ASSERT_TRUE(test, tunnel != NULL); 1621 KUNIT_EXPECT_EQ(test, tunnel->type, (enum tb_tunnel_type)TB_TUNNEL_DMA); 1622 KUNIT_EXPECT_PTR_EQ(test, tunnel->src_port, nhi); 1623 KUNIT_EXPECT_PTR_EQ(test, tunnel->dst_port, port); 1624 KUNIT_ASSERT_EQ(test, tunnel->npaths, (size_t)2); 1625 /* RX path */ 1626 KUNIT_ASSERT_EQ(test, tunnel->paths[0]->path_length, 1); 1627 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[0]->hops[0].in_port, port); 1628 KUNIT_EXPECT_EQ(test, tunnel->paths[0]->hops[0].in_hop_index, 8); 1629 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[0]->hops[0].out_port, nhi); 1630 KUNIT_EXPECT_EQ(test, tunnel->paths[0]->hops[0].next_hop_index, 1); 1631 /* TX path */ 1632 KUNIT_ASSERT_EQ(test, tunnel->paths[1]->path_length, 1); 1633 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[1]->hops[0].in_port, nhi); 1634 KUNIT_EXPECT_EQ(test, tunnel->paths[1]->hops[0].in_hop_index, 1); 1635 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[1]->hops[0].out_port, port); 1636 KUNIT_EXPECT_EQ(test, tunnel->paths[1]->hops[0].next_hop_index, 8); 1637 1638 tb_tunnel_free(tunnel); 1639 } 1640 1641 static void tb_test_tunnel_dma_rx(struct kunit *test) 1642 { 1643 struct tb_port *nhi, *port; 1644 struct tb_tunnel *tunnel; 1645 struct tb_switch *host; 1646 1647 /* 1648 * Create DMA RX tunnel from port 1 to NHI. 1649 * 1650 * [Host 1] 1651 * 1 ^ 1652 * | 1653 * | In HopID 15 -> Out HopID 2 1654 * ............ Domain border 1655 * | 1656 * [Host 2] 1657 */ 1658 host = alloc_host(test); 1659 nhi = &host->ports[7]; 1660 port = &host->ports[1]; 1661 1662 tunnel = tb_tunnel_alloc_dma(NULL, nhi, port, -1, -1, 15, 2); 1663 KUNIT_ASSERT_TRUE(test, tunnel != NULL); 1664 KUNIT_EXPECT_EQ(test, tunnel->type, (enum tb_tunnel_type)TB_TUNNEL_DMA); 1665 KUNIT_EXPECT_PTR_EQ(test, tunnel->src_port, nhi); 1666 KUNIT_EXPECT_PTR_EQ(test, tunnel->dst_port, port); 1667 KUNIT_ASSERT_EQ(test, tunnel->npaths, (size_t)1); 1668 /* RX path */ 1669 KUNIT_ASSERT_EQ(test, tunnel->paths[0]->path_length, 1); 1670 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[0]->hops[0].in_port, port); 1671 KUNIT_EXPECT_EQ(test, tunnel->paths[0]->hops[0].in_hop_index, 15); 1672 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[0]->hops[0].out_port, nhi); 1673 KUNIT_EXPECT_EQ(test, tunnel->paths[0]->hops[0].next_hop_index, 2); 1674 1675 tb_tunnel_free(tunnel); 1676 } 1677 1678 static void tb_test_tunnel_dma_tx(struct kunit *test) 1679 { 1680 struct tb_port *nhi, *port; 1681 struct tb_tunnel *tunnel; 1682 struct tb_switch *host; 1683 1684 /* 1685 * Create DMA TX tunnel from NHI to port 1. 1686 * 1687 * [Host 1] 1688 * 1 | In HopID 2 -> Out HopID 15 1689 * | 1690 * v 1691 * ............ Domain border 1692 * | 1693 * [Host 2] 1694 */ 1695 host = alloc_host(test); 1696 nhi = &host->ports[7]; 1697 port = &host->ports[1]; 1698 1699 tunnel = tb_tunnel_alloc_dma(NULL, nhi, port, 15, 2, -1, -1); 1700 KUNIT_ASSERT_TRUE(test, tunnel != NULL); 1701 KUNIT_EXPECT_EQ(test, tunnel->type, (enum tb_tunnel_type)TB_TUNNEL_DMA); 1702 KUNIT_EXPECT_PTR_EQ(test, tunnel->src_port, nhi); 1703 KUNIT_EXPECT_PTR_EQ(test, tunnel->dst_port, port); 1704 KUNIT_ASSERT_EQ(test, tunnel->npaths, (size_t)1); 1705 /* TX path */ 1706 KUNIT_ASSERT_EQ(test, tunnel->paths[0]->path_length, 1); 1707 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[0]->hops[0].in_port, nhi); 1708 KUNIT_EXPECT_EQ(test, tunnel->paths[0]->hops[0].in_hop_index, 2); 1709 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[0]->hops[0].out_port, port); 1710 KUNIT_EXPECT_EQ(test, tunnel->paths[0]->hops[0].next_hop_index, 15); 1711 1712 tb_tunnel_free(tunnel); 1713 } 1714 1715 static void tb_test_tunnel_dma_chain(struct kunit *test) 1716 { 1717 struct tb_switch *host, *dev1, *dev2; 1718 struct tb_port *nhi, *port; 1719 struct tb_tunnel *tunnel; 1720 1721 /* 1722 * Create DMA tunnel from NHI to Device #2 port 3 and back. 1723 * 1724 * [Host 1] 1725 * 1 ^ In HopID 1 -> Out HopID x 1726 * | 1727 * 1 | In HopID x -> Out HopID 1 1728 * [Device #1] 1729 * 7 \ 1730 * 1 \ 1731 * [Device #2] 1732 * 3 | In HopID x -> Out HopID 8 1733 * | 1734 * v In HopID 8 -> Out HopID x 1735 * ............ Domain border 1736 * | 1737 * [Host 2] 1738 */ 1739 host = alloc_host(test); 1740 dev1 = alloc_dev_default(test, host, 0x1, true); 1741 dev2 = alloc_dev_default(test, dev1, 0x701, true); 1742 1743 nhi = &host->ports[7]; 1744 port = &dev2->ports[3]; 1745 tunnel = tb_tunnel_alloc_dma(NULL, nhi, port, 8, 1, 8, 1); 1746 KUNIT_ASSERT_TRUE(test, tunnel != NULL); 1747 KUNIT_EXPECT_EQ(test, tunnel->type, (enum tb_tunnel_type)TB_TUNNEL_DMA); 1748 KUNIT_EXPECT_PTR_EQ(test, tunnel->src_port, nhi); 1749 KUNIT_EXPECT_PTR_EQ(test, tunnel->dst_port, port); 1750 KUNIT_ASSERT_EQ(test, tunnel->npaths, (size_t)2); 1751 /* RX path */ 1752 KUNIT_ASSERT_EQ(test, tunnel->paths[0]->path_length, 3); 1753 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[0]->hops[0].in_port, port); 1754 KUNIT_EXPECT_EQ(test, tunnel->paths[0]->hops[0].in_hop_index, 8); 1755 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[0]->hops[0].out_port, 1756 &dev2->ports[1]); 1757 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[0]->hops[1].in_port, 1758 &dev1->ports[7]); 1759 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[0]->hops[1].out_port, 1760 &dev1->ports[1]); 1761 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[0]->hops[2].in_port, 1762 &host->ports[1]); 1763 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[0]->hops[2].out_port, nhi); 1764 KUNIT_EXPECT_EQ(test, tunnel->paths[0]->hops[2].next_hop_index, 1); 1765 /* TX path */ 1766 KUNIT_ASSERT_EQ(test, tunnel->paths[1]->path_length, 3); 1767 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[1]->hops[0].in_port, nhi); 1768 KUNIT_EXPECT_EQ(test, tunnel->paths[1]->hops[0].in_hop_index, 1); 1769 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[1]->hops[1].in_port, 1770 &dev1->ports[1]); 1771 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[1]->hops[1].out_port, 1772 &dev1->ports[7]); 1773 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[1]->hops[2].in_port, 1774 &dev2->ports[1]); 1775 KUNIT_EXPECT_PTR_EQ(test, tunnel->paths[1]->hops[2].out_port, port); 1776 KUNIT_EXPECT_EQ(test, tunnel->paths[1]->hops[2].next_hop_index, 8); 1777 1778 tb_tunnel_free(tunnel); 1779 } 1780 1781 static void tb_test_tunnel_dma_match(struct kunit *test) 1782 { 1783 struct tb_port *nhi, *port; 1784 struct tb_tunnel *tunnel; 1785 struct tb_switch *host; 1786 1787 host = alloc_host(test); 1788 nhi = &host->ports[7]; 1789 port = &host->ports[1]; 1790 1791 tunnel = tb_tunnel_alloc_dma(NULL, nhi, port, 15, 1, 15, 1); 1792 KUNIT_ASSERT_TRUE(test, tunnel != NULL); 1793 1794 KUNIT_ASSERT_TRUE(test, tb_tunnel_match_dma(tunnel, 15, 1, 15, 1)); 1795 KUNIT_ASSERT_FALSE(test, tb_tunnel_match_dma(tunnel, 8, 1, 15, 1)); 1796 KUNIT_ASSERT_TRUE(test, tb_tunnel_match_dma(tunnel, -1, -1, 15, 1)); 1797 KUNIT_ASSERT_TRUE(test, tb_tunnel_match_dma(tunnel, 15, 1, -1, -1)); 1798 KUNIT_ASSERT_TRUE(test, tb_tunnel_match_dma(tunnel, 15, -1, -1, -1)); 1799 KUNIT_ASSERT_TRUE(test, tb_tunnel_match_dma(tunnel, -1, 1, -1, -1)); 1800 KUNIT_ASSERT_TRUE(test, tb_tunnel_match_dma(tunnel, -1, -1, 15, -1)); 1801 KUNIT_ASSERT_TRUE(test, tb_tunnel_match_dma(tunnel, -1, -1, -1, 1)); 1802 KUNIT_ASSERT_TRUE(test, tb_tunnel_match_dma(tunnel, -1, -1, -1, -1)); 1803 KUNIT_ASSERT_FALSE(test, tb_tunnel_match_dma(tunnel, 8, -1, 8, -1)); 1804 1805 tb_tunnel_free(tunnel); 1806 1807 tunnel = tb_tunnel_alloc_dma(NULL, nhi, port, 15, 1, -1, -1); 1808 KUNIT_ASSERT_TRUE(test, tunnel != NULL); 1809 KUNIT_ASSERT_TRUE(test, tb_tunnel_match_dma(tunnel, 15, 1, -1, -1)); 1810 KUNIT_ASSERT_TRUE(test, tb_tunnel_match_dma(tunnel, 15, -1, -1, -1)); 1811 KUNIT_ASSERT_TRUE(test, tb_tunnel_match_dma(tunnel, -1, 1, -1, -1)); 1812 KUNIT_ASSERT_TRUE(test, tb_tunnel_match_dma(tunnel, -1, -1, -1, -1)); 1813 KUNIT_ASSERT_FALSE(test, tb_tunnel_match_dma(tunnel, 15, 1, 15, 1)); 1814 KUNIT_ASSERT_FALSE(test, tb_tunnel_match_dma(tunnel, -1, -1, 15, 1)); 1815 KUNIT_ASSERT_FALSE(test, tb_tunnel_match_dma(tunnel, 15, 11, -1, -1)); 1816 1817 tb_tunnel_free(tunnel); 1818 1819 tunnel = tb_tunnel_alloc_dma(NULL, nhi, port, -1, -1, 15, 11); 1820 KUNIT_ASSERT_TRUE(test, tunnel != NULL); 1821 KUNIT_ASSERT_TRUE(test, tb_tunnel_match_dma(tunnel, -1, -1, 15, 11)); 1822 KUNIT_ASSERT_TRUE(test, tb_tunnel_match_dma(tunnel, -1, -1, 15, -1)); 1823 KUNIT_ASSERT_TRUE(test, tb_tunnel_match_dma(tunnel, -1, -1, -1, 11)); 1824 KUNIT_ASSERT_TRUE(test, tb_tunnel_match_dma(tunnel, -1, -1, -1, -1)); 1825 KUNIT_ASSERT_FALSE(test, tb_tunnel_match_dma(tunnel, -1, -1, 15, 1)); 1826 KUNIT_ASSERT_FALSE(test, tb_tunnel_match_dma(tunnel, -1, -1, 10, 11)); 1827 KUNIT_ASSERT_FALSE(test, tb_tunnel_match_dma(tunnel, 15, 11, -1, -1)); 1828 1829 tb_tunnel_free(tunnel); 1830 } 1831 1832 static const u32 root_directory[] = { 1833 0x55584401, /* "UXD" v1 */ 1834 0x00000018, /* Root directory length */ 1835 0x76656e64, /* "vend" */ 1836 0x6f726964, /* "orid" */ 1837 0x76000001, /* "v" R 1 */ 1838 0x00000a27, /* Immediate value, ! Vendor ID */ 1839 0x76656e64, /* "vend" */ 1840 0x6f726964, /* "orid" */ 1841 0x74000003, /* "t" R 3 */ 1842 0x0000001a, /* Text leaf offset, (“Apple Inc.”) */ 1843 0x64657669, /* "devi" */ 1844 0x63656964, /* "ceid" */ 1845 0x76000001, /* "v" R 1 */ 1846 0x0000000a, /* Immediate value, ! Device ID */ 1847 0x64657669, /* "devi" */ 1848 0x63656964, /* "ceid" */ 1849 0x74000003, /* "t" R 3 */ 1850 0x0000001d, /* Text leaf offset, (“Macintosh”) */ 1851 0x64657669, /* "devi" */ 1852 0x63657276, /* "cerv" */ 1853 0x76000001, /* "v" R 1 */ 1854 0x80000100, /* Immediate value, Device Revision */ 1855 0x6e657477, /* "netw" */ 1856 0x6f726b00, /* "ork" */ 1857 0x44000014, /* "D" R 20 */ 1858 0x00000021, /* Directory data offset, (Network Directory) */ 1859 0x4170706c, /* "Appl" */ 1860 0x6520496e, /* "e In" */ 1861 0x632e0000, /* "c." ! */ 1862 0x4d616369, /* "Maci" */ 1863 0x6e746f73, /* "ntos" */ 1864 0x68000000, /* "h" */ 1865 0x00000000, /* padding */ 1866 0xca8961c6, /* Directory UUID, Network Directory */ 1867 0x9541ce1c, /* Directory UUID, Network Directory */ 1868 0x5949b8bd, /* Directory UUID, Network Directory */ 1869 0x4f5a5f2e, /* Directory UUID, Network Directory */ 1870 0x70727463, /* "prtc" */ 1871 0x69640000, /* "id" */ 1872 0x76000001, /* "v" R 1 */ 1873 0x00000001, /* Immediate value, Network Protocol ID */ 1874 0x70727463, /* "prtc" */ 1875 0x76657273, /* "vers" */ 1876 0x76000001, /* "v" R 1 */ 1877 0x00000001, /* Immediate value, Network Protocol Version */ 1878 0x70727463, /* "prtc" */ 1879 0x72657673, /* "revs" */ 1880 0x76000001, /* "v" R 1 */ 1881 0x00000001, /* Immediate value, Network Protocol Revision */ 1882 0x70727463, /* "prtc" */ 1883 0x73746e73, /* "stns" */ 1884 0x76000001, /* "v" R 1 */ 1885 0x00000000, /* Immediate value, Network Protocol Settings */ 1886 }; 1887 1888 static const uuid_t network_dir_uuid = 1889 UUID_INIT(0xc66189ca, 0x1cce, 0x4195, 1890 0xbd, 0xb8, 0x49, 0x59, 0x2e, 0x5f, 0x5a, 0x4f); 1891 1892 static void tb_test_property_parse(struct kunit *test) 1893 { 1894 struct tb_property_dir *dir, *network_dir; 1895 struct tb_property *p; 1896 1897 dir = tb_property_parse_dir(root_directory, ARRAY_SIZE(root_directory)); 1898 KUNIT_ASSERT_TRUE(test, dir != NULL); 1899 1900 p = tb_property_find(dir, "foo", TB_PROPERTY_TYPE_TEXT); 1901 KUNIT_ASSERT_TRUE(test, !p); 1902 1903 p = tb_property_find(dir, "vendorid", TB_PROPERTY_TYPE_TEXT); 1904 KUNIT_ASSERT_TRUE(test, p != NULL); 1905 KUNIT_EXPECT_STREQ(test, p->value.text, "Apple Inc."); 1906 1907 p = tb_property_find(dir, "vendorid", TB_PROPERTY_TYPE_VALUE); 1908 KUNIT_ASSERT_TRUE(test, p != NULL); 1909 KUNIT_EXPECT_EQ(test, p->value.immediate, (u32)0xa27); 1910 1911 p = tb_property_find(dir, "deviceid", TB_PROPERTY_TYPE_TEXT); 1912 KUNIT_ASSERT_TRUE(test, p != NULL); 1913 KUNIT_EXPECT_STREQ(test, p->value.text, "Macintosh"); 1914 1915 p = tb_property_find(dir, "deviceid", TB_PROPERTY_TYPE_VALUE); 1916 KUNIT_ASSERT_TRUE(test, p != NULL); 1917 KUNIT_EXPECT_EQ(test, p->value.immediate, (u32)0xa); 1918 1919 p = tb_property_find(dir, "missing", TB_PROPERTY_TYPE_DIRECTORY); 1920 KUNIT_ASSERT_TRUE(test, !p); 1921 1922 p = tb_property_find(dir, "network", TB_PROPERTY_TYPE_DIRECTORY); 1923 KUNIT_ASSERT_TRUE(test, p != NULL); 1924 1925 network_dir = p->value.dir; 1926 KUNIT_EXPECT_TRUE(test, uuid_equal(network_dir->uuid, &network_dir_uuid)); 1927 1928 p = tb_property_find(network_dir, "prtcid", TB_PROPERTY_TYPE_VALUE); 1929 KUNIT_ASSERT_TRUE(test, p != NULL); 1930 KUNIT_EXPECT_EQ(test, p->value.immediate, (u32)0x1); 1931 1932 p = tb_property_find(network_dir, "prtcvers", TB_PROPERTY_TYPE_VALUE); 1933 KUNIT_ASSERT_TRUE(test, p != NULL); 1934 KUNIT_EXPECT_EQ(test, p->value.immediate, (u32)0x1); 1935 1936 p = tb_property_find(network_dir, "prtcrevs", TB_PROPERTY_TYPE_VALUE); 1937 KUNIT_ASSERT_TRUE(test, p != NULL); 1938 KUNIT_EXPECT_EQ(test, p->value.immediate, (u32)0x1); 1939 1940 p = tb_property_find(network_dir, "prtcstns", TB_PROPERTY_TYPE_VALUE); 1941 KUNIT_ASSERT_TRUE(test, p != NULL); 1942 KUNIT_EXPECT_EQ(test, p->value.immediate, (u32)0x0); 1943 1944 p = tb_property_find(network_dir, "deviceid", TB_PROPERTY_TYPE_VALUE); 1945 KUNIT_EXPECT_TRUE(test, !p); 1946 p = tb_property_find(network_dir, "deviceid", TB_PROPERTY_TYPE_TEXT); 1947 KUNIT_EXPECT_TRUE(test, !p); 1948 1949 tb_property_free_dir(dir); 1950 } 1951 1952 static void tb_test_property_format(struct kunit *test) 1953 { 1954 struct tb_property_dir *dir; 1955 ssize_t block_len; 1956 u32 *block; 1957 int ret, i; 1958 1959 dir = tb_property_parse_dir(root_directory, ARRAY_SIZE(root_directory)); 1960 KUNIT_ASSERT_TRUE(test, dir != NULL); 1961 1962 ret = tb_property_format_dir(dir, NULL, 0); 1963 KUNIT_ASSERT_EQ(test, ret, (int)ARRAY_SIZE(root_directory)); 1964 1965 block_len = ret; 1966 1967 block = kunit_kzalloc(test, block_len * sizeof(u32), GFP_KERNEL); 1968 KUNIT_ASSERT_TRUE(test, block != NULL); 1969 1970 ret = tb_property_format_dir(dir, block, block_len); 1971 KUNIT_EXPECT_EQ(test, ret, 0); 1972 1973 for (i = 0; i < ARRAY_SIZE(root_directory); i++) 1974 KUNIT_EXPECT_EQ(test, root_directory[i], block[i]); 1975 1976 tb_property_free_dir(dir); 1977 } 1978 1979 static void compare_dirs(struct kunit *test, struct tb_property_dir *d1, 1980 struct tb_property_dir *d2) 1981 { 1982 struct tb_property *p1, *p2, *tmp; 1983 int n1, n2, i; 1984 1985 if (d1->uuid) { 1986 KUNIT_ASSERT_TRUE(test, d2->uuid != NULL); 1987 KUNIT_ASSERT_TRUE(test, uuid_equal(d1->uuid, d2->uuid)); 1988 } else { 1989 KUNIT_ASSERT_TRUE(test, d2->uuid == NULL); 1990 } 1991 1992 n1 = 0; 1993 tb_property_for_each(d1, tmp) 1994 n1++; 1995 KUNIT_ASSERT_NE(test, n1, 0); 1996 1997 n2 = 0; 1998 tb_property_for_each(d2, tmp) 1999 n2++; 2000 KUNIT_ASSERT_NE(test, n2, 0); 2001 2002 KUNIT_ASSERT_EQ(test, n1, n2); 2003 2004 p1 = NULL; 2005 p2 = NULL; 2006 for (i = 0; i < n1; i++) { 2007 p1 = tb_property_get_next(d1, p1); 2008 KUNIT_ASSERT_TRUE(test, p1 != NULL); 2009 p2 = tb_property_get_next(d2, p2); 2010 KUNIT_ASSERT_TRUE(test, p2 != NULL); 2011 2012 KUNIT_ASSERT_STREQ(test, &p1->key[0], &p2->key[0]); 2013 KUNIT_ASSERT_EQ(test, p1->type, p2->type); 2014 KUNIT_ASSERT_EQ(test, p1->length, p2->length); 2015 2016 switch (p1->type) { 2017 case TB_PROPERTY_TYPE_DIRECTORY: 2018 KUNIT_ASSERT_TRUE(test, p1->value.dir != NULL); 2019 KUNIT_ASSERT_TRUE(test, p2->value.dir != NULL); 2020 compare_dirs(test, p1->value.dir, p2->value.dir); 2021 break; 2022 2023 case TB_PROPERTY_TYPE_DATA: 2024 KUNIT_ASSERT_TRUE(test, p1->value.data != NULL); 2025 KUNIT_ASSERT_TRUE(test, p2->value.data != NULL); 2026 KUNIT_ASSERT_TRUE(test, 2027 !memcmp(p1->value.data, p2->value.data, 2028 p1->length * 4) 2029 ); 2030 break; 2031 2032 case TB_PROPERTY_TYPE_TEXT: 2033 KUNIT_ASSERT_TRUE(test, p1->value.text != NULL); 2034 KUNIT_ASSERT_TRUE(test, p2->value.text != NULL); 2035 KUNIT_ASSERT_STREQ(test, p1->value.text, p2->value.text); 2036 break; 2037 2038 case TB_PROPERTY_TYPE_VALUE: 2039 KUNIT_ASSERT_EQ(test, p1->value.immediate, 2040 p2->value.immediate); 2041 break; 2042 default: 2043 KUNIT_FAIL(test, "unexpected property type"); 2044 break; 2045 } 2046 } 2047 } 2048 2049 static void tb_test_property_copy(struct kunit *test) 2050 { 2051 struct tb_property_dir *src, *dst; 2052 u32 *block; 2053 int ret, i; 2054 2055 src = tb_property_parse_dir(root_directory, ARRAY_SIZE(root_directory)); 2056 KUNIT_ASSERT_TRUE(test, src != NULL); 2057 2058 dst = tb_property_copy_dir(src); 2059 KUNIT_ASSERT_TRUE(test, dst != NULL); 2060 2061 /* Compare the structures */ 2062 compare_dirs(test, src, dst); 2063 2064 /* Compare the resulting property block */ 2065 ret = tb_property_format_dir(dst, NULL, 0); 2066 KUNIT_ASSERT_EQ(test, ret, (int)ARRAY_SIZE(root_directory)); 2067 2068 block = kunit_kzalloc(test, sizeof(root_directory), GFP_KERNEL); 2069 KUNIT_ASSERT_TRUE(test, block != NULL); 2070 2071 ret = tb_property_format_dir(dst, block, ARRAY_SIZE(root_directory)); 2072 KUNIT_EXPECT_TRUE(test, !ret); 2073 2074 for (i = 0; i < ARRAY_SIZE(root_directory); i++) 2075 KUNIT_EXPECT_EQ(test, root_directory[i], block[i]); 2076 2077 tb_property_free_dir(dst); 2078 tb_property_free_dir(src); 2079 } 2080 2081 static struct kunit_case tb_test_cases[] = { 2082 KUNIT_CASE(tb_test_path_basic), 2083 KUNIT_CASE(tb_test_path_not_connected_walk), 2084 KUNIT_CASE(tb_test_path_single_hop_walk), 2085 KUNIT_CASE(tb_test_path_daisy_chain_walk), 2086 KUNIT_CASE(tb_test_path_simple_tree_walk), 2087 KUNIT_CASE(tb_test_path_complex_tree_walk), 2088 KUNIT_CASE(tb_test_path_max_length_walk), 2089 KUNIT_CASE(tb_test_path_not_connected), 2090 KUNIT_CASE(tb_test_path_not_bonded_lane0), 2091 KUNIT_CASE(tb_test_path_not_bonded_lane1), 2092 KUNIT_CASE(tb_test_path_not_bonded_lane1_chain), 2093 KUNIT_CASE(tb_test_path_not_bonded_lane1_chain_reverse), 2094 KUNIT_CASE(tb_test_path_mixed_chain), 2095 KUNIT_CASE(tb_test_path_mixed_chain_reverse), 2096 KUNIT_CASE(tb_test_tunnel_pcie), 2097 KUNIT_CASE(tb_test_tunnel_dp), 2098 KUNIT_CASE(tb_test_tunnel_dp_chain), 2099 KUNIT_CASE(tb_test_tunnel_dp_tree), 2100 KUNIT_CASE(tb_test_tunnel_dp_max_length), 2101 KUNIT_CASE(tb_test_tunnel_port_on_path), 2102 KUNIT_CASE(tb_test_tunnel_usb3), 2103 KUNIT_CASE(tb_test_tunnel_dma), 2104 KUNIT_CASE(tb_test_tunnel_dma_rx), 2105 KUNIT_CASE(tb_test_tunnel_dma_tx), 2106 KUNIT_CASE(tb_test_tunnel_dma_chain), 2107 KUNIT_CASE(tb_test_tunnel_dma_match), 2108 KUNIT_CASE(tb_test_property_parse), 2109 KUNIT_CASE(tb_test_property_format), 2110 KUNIT_CASE(tb_test_property_copy), 2111 { } 2112 }; 2113 2114 static struct kunit_suite tb_test_suite = { 2115 .name = "thunderbolt", 2116 .test_cases = tb_test_cases, 2117 }; 2118 2119 static struct kunit_suite *tb_test_suites[] = { &tb_test_suite, NULL }; 2120 2121 int tb_test_init(void) 2122 { 2123 return __kunit_test_suites_init(tb_test_suites); 2124 } 2125 2126 void tb_test_exit(void) 2127 { 2128 return __kunit_test_suites_exit(tb_test_suites); 2129 } 2130