1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Kunit test for drm_modes functions 4 */ 5 6 #include <linux/i2c.h> 7 8 #include <drm/drm_atomic_state_helper.h> 9 #include <drm/drm_connector.h> 10 #include <drm/drm_drv.h> 11 #include <drm/drm_edid.h> 12 #include <drm/drm_file.h> 13 #include <drm/drm_kunit_helpers.h> 14 #include <drm/drm_modes.h> 15 16 #include <drm/display/drm_hdmi_helper.h> 17 18 #include <kunit/test.h> 19 20 #include "../drm_crtc_internal.h" 21 22 struct drm_connector_init_priv { 23 struct drm_device drm; 24 struct drm_connector connector; 25 struct i2c_adapter ddc; 26 }; 27 28 static int accept_infoframe_clear_infoframe(struct drm_connector *connector) 29 { 30 return 0; 31 } 32 33 static int accept_infoframe_write_infoframe(struct drm_connector *connector, 34 const u8 *buffer, size_t len) 35 { 36 return 0; 37 } 38 39 static const struct drm_connector_hdmi_funcs dummy_hdmi_funcs = { 40 .avi = { 41 .clear_infoframe = accept_infoframe_clear_infoframe, 42 .write_infoframe = accept_infoframe_write_infoframe, 43 }, 44 .hdmi = { 45 .clear_infoframe = accept_infoframe_clear_infoframe, 46 .write_infoframe = accept_infoframe_write_infoframe, 47 }, 48 }; 49 50 static const struct drm_connector_funcs dummy_funcs = { 51 .atomic_destroy_state = drm_atomic_helper_connector_destroy_state, 52 .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state, 53 .reset = drm_atomic_helper_connector_reset, 54 }; 55 56 static int dummy_ddc_xfer(struct i2c_adapter *adapter, 57 struct i2c_msg *msgs, int num) 58 { 59 return num; 60 } 61 62 static u32 dummy_ddc_func(struct i2c_adapter *adapter) 63 { 64 return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL; 65 } 66 67 static const struct i2c_algorithm dummy_ddc_algorithm = { 68 .master_xfer = dummy_ddc_xfer, 69 .functionality = dummy_ddc_func, 70 }; 71 72 static void i2c_del_adapter_wrapper(void *ptr) 73 { 74 struct i2c_adapter *adap = ptr; 75 76 i2c_del_adapter(adap); 77 } 78 79 static int drm_test_connector_init(struct kunit *test) 80 { 81 struct drm_connector_init_priv *priv; 82 struct device *dev; 83 int ret; 84 85 dev = drm_kunit_helper_alloc_device(test); 86 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dev); 87 88 priv = drm_kunit_helper_alloc_drm_device(test, dev, 89 struct drm_connector_init_priv, drm, 90 DRIVER_MODESET | DRIVER_ATOMIC); 91 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, priv); 92 93 strscpy(priv->ddc.name, "dummy-connector-ddc", sizeof(priv->ddc.name)); 94 priv->ddc.owner = THIS_MODULE; 95 priv->ddc.algo = &dummy_ddc_algorithm; 96 priv->ddc.dev.parent = dev; 97 98 ret = i2c_add_adapter(&priv->ddc); 99 KUNIT_ASSERT_EQ(test, ret, 0); 100 101 ret = kunit_add_action_or_reset(test, i2c_del_adapter_wrapper, &priv->ddc); 102 KUNIT_ASSERT_EQ(test, ret, 0); 103 104 test->priv = priv; 105 return 0; 106 } 107 108 /* 109 * Test that the registration of a bog standard connector works as 110 * expected and doesn't report any error. 111 */ 112 static void drm_test_drmm_connector_init(struct kunit *test) 113 { 114 struct drm_connector_init_priv *priv = test->priv; 115 int ret; 116 117 ret = drmm_connector_init(&priv->drm, &priv->connector, 118 &dummy_funcs, 119 DRM_MODE_CONNECTOR_HDMIA, 120 &priv->ddc); 121 KUNIT_EXPECT_EQ(test, ret, 0); 122 } 123 124 /* 125 * Test that the registration of a connector without a DDC adapter 126 * doesn't report any error. 127 */ 128 static void drm_test_drmm_connector_init_null_ddc(struct kunit *test) 129 { 130 struct drm_connector_init_priv *priv = test->priv; 131 int ret; 132 133 ret = drmm_connector_init(&priv->drm, &priv->connector, 134 &dummy_funcs, 135 DRM_MODE_CONNECTOR_HDMIA, 136 NULL); 137 KUNIT_EXPECT_EQ(test, ret, 0); 138 } 139 140 /* 141 * Test that the registration of a connector succeeds for all possible 142 * connector types. 143 */ 144 static void drm_test_drmm_connector_init_type_valid(struct kunit *test) 145 { 146 struct drm_connector_init_priv *priv = test->priv; 147 unsigned int connector_type = *(unsigned int *)test->param_value; 148 int ret; 149 150 ret = drmm_connector_init(&priv->drm, &priv->connector, 151 &dummy_funcs, 152 connector_type, 153 &priv->ddc); 154 KUNIT_EXPECT_EQ(test, ret, 0); 155 } 156 157 static const unsigned int drm_connector_init_type_valid_tests[] = { 158 DRM_MODE_CONNECTOR_Unknown, 159 DRM_MODE_CONNECTOR_VGA, 160 DRM_MODE_CONNECTOR_DVII, 161 DRM_MODE_CONNECTOR_DVID, 162 DRM_MODE_CONNECTOR_DVIA, 163 DRM_MODE_CONNECTOR_Composite, 164 DRM_MODE_CONNECTOR_SVIDEO, 165 DRM_MODE_CONNECTOR_LVDS, 166 DRM_MODE_CONNECTOR_Component, 167 DRM_MODE_CONNECTOR_9PinDIN, 168 DRM_MODE_CONNECTOR_DisplayPort, 169 DRM_MODE_CONNECTOR_HDMIA, 170 DRM_MODE_CONNECTOR_HDMIB, 171 DRM_MODE_CONNECTOR_TV, 172 DRM_MODE_CONNECTOR_eDP, 173 DRM_MODE_CONNECTOR_VIRTUAL, 174 DRM_MODE_CONNECTOR_DSI, 175 DRM_MODE_CONNECTOR_DPI, 176 DRM_MODE_CONNECTOR_WRITEBACK, 177 DRM_MODE_CONNECTOR_SPI, 178 DRM_MODE_CONNECTOR_USB, 179 }; 180 181 static void drm_connector_init_type_desc(const unsigned int *type, char *desc) 182 { 183 sprintf(desc, "%s", drm_get_connector_type_name(*type)); 184 } 185 186 KUNIT_ARRAY_PARAM(drm_connector_init_type_valid, 187 drm_connector_init_type_valid_tests, 188 drm_connector_init_type_desc); 189 190 static struct kunit_case drmm_connector_init_tests[] = { 191 KUNIT_CASE(drm_test_drmm_connector_init), 192 KUNIT_CASE(drm_test_drmm_connector_init_null_ddc), 193 KUNIT_CASE_PARAM(drm_test_drmm_connector_init_type_valid, 194 drm_connector_init_type_valid_gen_params), 195 { } 196 }; 197 198 static struct kunit_suite drmm_connector_init_test_suite = { 199 .name = "drmm_connector_init", 200 .init = drm_test_connector_init, 201 .test_cases = drmm_connector_init_tests, 202 }; 203 204 static const struct drm_connector_funcs dummy_dynamic_init_funcs = { 205 .atomic_destroy_state = drm_atomic_helper_connector_destroy_state, 206 .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state, 207 .reset = drm_atomic_helper_connector_reset, 208 .destroy = drm_connector_cleanup, 209 }; 210 211 /* 212 * Test that the initialization of a bog standard dynamic connector works 213 * as expected and doesn't report any error. 214 */ 215 static void drm_test_drm_connector_dynamic_init(struct kunit *test) 216 { 217 struct drm_connector_init_priv *priv = test->priv; 218 struct drm_connector *connector = &priv->connector; 219 int ret; 220 221 ret = drm_connector_dynamic_init(&priv->drm, connector, 222 &dummy_dynamic_init_funcs, 223 DRM_MODE_CONNECTOR_DisplayPort, 224 &priv->ddc); 225 KUNIT_ASSERT_EQ(test, ret, 0); 226 } 227 228 static void drm_test_connector_dynamic_init_cleanup(struct kunit *test) 229 { 230 struct drm_connector_init_priv *priv = test->priv; 231 struct drm_connector *connector = &priv->connector; 232 233 drm_connector_cleanup(connector); 234 } 235 236 /* 237 * Test that the initialization of a dynamic connector without a DDC adapter 238 * doesn't report any error. 239 */ 240 static void drm_test_drm_connector_dynamic_init_null_ddc(struct kunit *test) 241 { 242 struct drm_connector_init_priv *priv = test->priv; 243 struct drm_connector *connector = &priv->connector; 244 int ret; 245 246 ret = drm_connector_dynamic_init(&priv->drm, connector, 247 &dummy_dynamic_init_funcs, 248 DRM_MODE_CONNECTOR_DisplayPort, 249 NULL); 250 KUNIT_ASSERT_EQ(test, ret, 0); 251 } 252 253 /* 254 * Test that the initialization of a dynamic connector doesn't add the 255 * connector to the connector list. 256 */ 257 static void drm_test_drm_connector_dynamic_init_not_added(struct kunit *test) 258 { 259 struct drm_connector_init_priv *priv = test->priv; 260 struct drm_connector *connector = &priv->connector; 261 int ret; 262 263 ret = drm_connector_dynamic_init(&priv->drm, connector, 264 &dummy_dynamic_init_funcs, 265 DRM_MODE_CONNECTOR_DisplayPort, 266 &priv->ddc); 267 KUNIT_ASSERT_EQ(test, ret, 0); 268 KUNIT_ASSERT_PTR_EQ(test, connector->head.next, &connector->head); 269 } 270 271 static void test_connector_property(struct kunit *test, 272 struct drm_connector *connector, 273 const struct drm_property *expected_prop) 274 { 275 struct drm_property *prop; 276 uint64_t val; 277 int ret; 278 279 KUNIT_ASSERT_NOT_NULL(test, expected_prop); 280 prop = drm_mode_obj_find_prop_id(&connector->base, expected_prop->base.id); 281 KUNIT_ASSERT_PTR_EQ_MSG(test, prop, expected_prop, 282 "Can't find property %s", expected_prop->name); 283 284 ret = drm_object_property_get_default_value(&connector->base, prop, &val); 285 KUNIT_EXPECT_EQ(test, ret, 0); 286 KUNIT_EXPECT_EQ(test, val, 0); 287 288 /* TODO: Check property value in the connector state. */ 289 } 290 291 /* 292 * Test that the initialization of a dynamic connector adds all the expected 293 * properties to it. 294 */ 295 static void drm_test_drm_connector_dynamic_init_properties(struct kunit *test) 296 { 297 struct drm_connector_init_priv *priv = test->priv; 298 struct drm_connector *connector = &priv->connector; 299 struct drm_mode_config *config = &priv->drm.mode_config; 300 const struct drm_property *props[] = { 301 config->edid_property, 302 config->dpms_property, 303 config->link_status_property, 304 config->non_desktop_property, 305 config->tile_property, 306 config->prop_crtc_id, 307 }; 308 int ret; 309 int i; 310 311 ret = drm_connector_dynamic_init(&priv->drm, connector, 312 &dummy_dynamic_init_funcs, 313 DRM_MODE_CONNECTOR_DisplayPort, 314 &priv->ddc); 315 KUNIT_ASSERT_EQ(test, ret, 0); 316 317 for (i = 0; i < ARRAY_SIZE(props); i++) 318 test_connector_property(test, connector, props[i]); 319 } 320 321 /* 322 * Test that the initialization of a dynamic connector succeeds for all 323 * possible connector types. 324 */ 325 static void drm_test_drm_connector_dynamic_init_type_valid(struct kunit *test) 326 { 327 struct drm_connector_init_priv *priv = test->priv; 328 struct drm_connector *connector = &priv->connector; 329 unsigned int connector_type = *(unsigned int *)test->param_value; 330 int ret; 331 332 ret = drm_connector_dynamic_init(&priv->drm, connector, 333 &dummy_dynamic_init_funcs, 334 connector_type, 335 &priv->ddc); 336 KUNIT_ASSERT_EQ(test, ret, 0); 337 } 338 339 /* 340 * Test that the initialization of a dynamic connector sets the expected name 341 * for it for all possible connector types. 342 */ 343 static void drm_test_drm_connector_dynamic_init_name(struct kunit *test) 344 { 345 struct drm_connector_init_priv *priv = test->priv; 346 struct drm_connector *connector = &priv->connector; 347 unsigned int connector_type = *(unsigned int *)test->param_value; 348 char expected_name[128]; 349 int ret; 350 351 ret = drm_connector_dynamic_init(&priv->drm, connector, 352 &dummy_dynamic_init_funcs, 353 connector_type, 354 &priv->ddc); 355 KUNIT_ASSERT_EQ(test, ret, 0); 356 357 snprintf(expected_name, sizeof(expected_name), "%s-%d", 358 drm_get_connector_type_name(connector_type), connector->connector_type_id); 359 KUNIT_ASSERT_STREQ(test, connector->name, expected_name); 360 } 361 362 static struct kunit_case drm_connector_dynamic_init_tests[] = { 363 KUNIT_CASE(drm_test_drm_connector_dynamic_init), 364 KUNIT_CASE(drm_test_drm_connector_dynamic_init_null_ddc), 365 KUNIT_CASE(drm_test_drm_connector_dynamic_init_not_added), 366 KUNIT_CASE(drm_test_drm_connector_dynamic_init_properties), 367 KUNIT_CASE_PARAM(drm_test_drm_connector_dynamic_init_type_valid, 368 drm_connector_init_type_valid_gen_params), 369 KUNIT_CASE_PARAM(drm_test_drm_connector_dynamic_init_name, 370 drm_connector_init_type_valid_gen_params), 371 {} 372 }; 373 374 static struct kunit_suite drm_connector_dynamic_init_test_suite = { 375 .name = "drm_connector_dynamic_init", 376 .init = drm_test_connector_init, 377 .exit = drm_test_connector_dynamic_init_cleanup, 378 .test_cases = drm_connector_dynamic_init_tests, 379 }; 380 381 static int drm_test_connector_dynamic_register_early_init(struct kunit *test) 382 { 383 struct drm_connector_init_priv *priv; 384 int ret; 385 386 ret = drm_test_connector_init(test); 387 KUNIT_ASSERT_EQ(test, ret, 0); 388 389 priv = test->priv; 390 391 ret = drm_connector_dynamic_init(&priv->drm, &priv->connector, 392 &dummy_dynamic_init_funcs, 393 DRM_MODE_CONNECTOR_DisplayPort, 394 &priv->ddc); 395 KUNIT_ASSERT_EQ(test, ret, 0); 396 397 return 0; 398 } 399 400 static void drm_test_connector_dynamic_register_early_cleanup(struct kunit *test) 401 { 402 struct drm_connector_init_priv *priv = test->priv; 403 struct drm_connector *connector = &priv->connector; 404 405 drm_connector_unregister(connector); 406 drm_connector_put(connector); 407 } 408 409 /* 410 * Test that registration of a dynamic connector adds it to the connector list. 411 */ 412 static void drm_test_drm_connector_dynamic_register_early_on_list(struct kunit *test) 413 { 414 struct drm_connector_init_priv *priv = test->priv; 415 struct drm_connector *connector = &priv->connector; 416 int ret; 417 418 KUNIT_ASSERT_TRUE(test, list_empty(&connector->head)); 419 420 ret = drm_connector_dynamic_register(connector); 421 KUNIT_ASSERT_EQ(test, ret, 0); 422 423 KUNIT_ASSERT_PTR_EQ(test, connector->head.next, &priv->drm.mode_config.connector_list); 424 } 425 426 /* 427 * Test that the registration of a dynamic connector before the drm device is 428 * registered results in deferring the connector's user interface registration. 429 */ 430 static void drm_test_drm_connector_dynamic_register_early_defer(struct kunit *test) 431 { 432 struct drm_connector_init_priv *priv = test->priv; 433 struct drm_connector *connector = &priv->connector; 434 int ret; 435 436 ret = drm_connector_dynamic_register(connector); 437 KUNIT_ASSERT_EQ(test, ret, 0); 438 439 KUNIT_ASSERT_EQ(test, connector->registration_state, DRM_CONNECTOR_INITIALIZING); 440 } 441 442 /* 443 * Test that the registration of a dynamic connector fails, if this is done before 444 * the connector is initialized. 445 */ 446 static void drm_test_drm_connector_dynamic_register_early_no_init(struct kunit *test) 447 { 448 struct drm_connector *connector; 449 int ret; 450 451 connector = kunit_kzalloc(test, sizeof(*connector), GFP_KERNEL); /* auto freed */ 452 KUNIT_ASSERT_NOT_NULL(test, connector); 453 454 ret = drm_connector_dynamic_register(connector); 455 KUNIT_ASSERT_EQ(test, ret, -EINVAL); 456 } 457 458 /* 459 * Test that the registration of a dynamic connector before the drm device is 460 * registered results in deferring adding a mode object for the connector. 461 */ 462 static void drm_test_drm_connector_dynamic_register_early_no_mode_object(struct kunit *test) 463 { 464 struct drm_connector_init_priv *priv = test->priv; 465 struct drm_connector *connector = &priv->connector; 466 struct drm_connector *tmp_connector; 467 int ret; 468 469 ret = drm_connector_dynamic_register(&priv->connector); 470 KUNIT_ASSERT_EQ(test, ret, 0); 471 472 tmp_connector = drm_connector_lookup(connector->dev, NULL, connector->base.id); 473 KUNIT_ASSERT_NULL(test, tmp_connector); 474 } 475 476 static struct kunit_case drm_connector_dynamic_register_early_tests[] = { 477 KUNIT_CASE(drm_test_drm_connector_dynamic_register_early_on_list), 478 KUNIT_CASE(drm_test_drm_connector_dynamic_register_early_defer), 479 KUNIT_CASE(drm_test_drm_connector_dynamic_register_early_no_init), 480 KUNIT_CASE(drm_test_drm_connector_dynamic_register_early_no_mode_object), 481 { } 482 }; 483 484 static struct kunit_suite drm_connector_dynamic_register_early_test_suite = { 485 .name = "drm_connector_dynamic_register_early", 486 .init = drm_test_connector_dynamic_register_early_init, 487 .exit = drm_test_connector_dynamic_register_early_cleanup, 488 .test_cases = drm_connector_dynamic_register_early_tests, 489 }; 490 491 static int drm_test_connector_dynamic_register_init(struct kunit *test) 492 { 493 struct drm_connector_init_priv *priv; 494 int ret; 495 496 ret = drm_test_connector_dynamic_register_early_init(test); 497 KUNIT_ASSERT_EQ(test, ret, 0); 498 499 priv = test->priv; 500 501 ret = drm_dev_register(priv->connector.dev, 0); 502 KUNIT_ASSERT_EQ(test, ret, 0); 503 504 return 0; 505 } 506 507 static void drm_test_connector_dynamic_register_cleanup(struct kunit *test) 508 { 509 struct drm_connector_init_priv *priv = test->priv; 510 struct drm_device *dev = priv->connector.dev; 511 512 drm_connector_unregister(&priv->connector); 513 drm_connector_put(&priv->connector); 514 515 drm_dev_unregister(dev); 516 517 drm_test_connector_dynamic_register_early_cleanup(test); 518 } 519 520 static void drm_test_drm_connector_dynamic_register_on_list(struct kunit *test) 521 { 522 struct drm_connector_init_priv *priv = test->priv; 523 int ret; 524 525 KUNIT_ASSERT_TRUE(test, list_empty(&priv->connector.head)); 526 527 ret = drm_connector_dynamic_register(&priv->connector); 528 KUNIT_ASSERT_EQ(test, ret, 0); 529 530 KUNIT_ASSERT_PTR_EQ(test, priv->connector.head.next, &priv->drm.mode_config.connector_list); 531 } 532 533 /* 534 * Test that the registration of a dynamic connector doesn't get deferred if 535 * this is done after the drm device is registered. 536 */ 537 static void drm_test_drm_connector_dynamic_register_no_defer(struct kunit *test) 538 { 539 struct drm_connector_init_priv *priv = test->priv; 540 int ret; 541 542 KUNIT_ASSERT_EQ(test, priv->connector.registration_state, DRM_CONNECTOR_INITIALIZING); 543 544 ret = drm_connector_dynamic_register(&priv->connector); 545 KUNIT_ASSERT_EQ(test, ret, 0); 546 547 KUNIT_ASSERT_EQ(test, priv->connector.registration_state, DRM_CONNECTOR_REGISTERED); 548 } 549 550 /* 551 * Test that the registration of a dynamic connector fails if this is done after the 552 * drm device is registered, but before the connector is initialized. 553 */ 554 static void drm_test_drm_connector_dynamic_register_no_init(struct kunit *test) 555 { 556 struct drm_connector *connector; 557 int ret; 558 559 connector = kunit_kzalloc(test, sizeof(*connector), GFP_KERNEL); /* auto freed */ 560 KUNIT_ASSERT_NOT_NULL(test, connector); 561 562 ret = drm_connector_dynamic_register(connector); 563 KUNIT_ASSERT_EQ(test, ret, -EINVAL); 564 } 565 566 /* 567 * Test that the registration of a dynamic connector after the drm device is 568 * registered adds the mode object for the connector. 569 */ 570 static void drm_test_drm_connector_dynamic_register_mode_object(struct kunit *test) 571 { 572 struct drm_connector_init_priv *priv = test->priv; 573 struct drm_connector *connector = &priv->connector; 574 struct drm_connector *tmp_connector; 575 int ret; 576 577 tmp_connector = drm_connector_lookup(connector->dev, NULL, connector->base.id); 578 KUNIT_ASSERT_NULL(test, tmp_connector); 579 580 ret = drm_connector_dynamic_register(&priv->connector); 581 KUNIT_ASSERT_EQ(test, ret, 0); 582 583 tmp_connector = drm_connector_lookup(connector->dev, NULL, connector->base.id); 584 KUNIT_ASSERT_PTR_EQ(test, tmp_connector, connector); 585 } 586 587 /* 588 * Test that the registration of a dynamic connector after the drm device is 589 * registered adds the connector to sysfs. 590 */ 591 static void drm_test_drm_connector_dynamic_register_sysfs(struct kunit *test) 592 { 593 struct drm_connector_init_priv *priv = test->priv; 594 struct drm_connector *connector = &priv->connector; 595 int ret; 596 597 KUNIT_ASSERT_NULL(test, connector->kdev); 598 599 ret = drm_connector_dynamic_register(connector); 600 KUNIT_ASSERT_EQ(test, ret, 0); 601 602 KUNIT_ASSERT_NOT_NULL(test, connector->kdev); 603 } 604 605 /* 606 * Test that the registration of a dynamic connector after the drm device is 607 * registered sets the connector's sysfs name as expected. 608 */ 609 static void drm_test_drm_connector_dynamic_register_sysfs_name(struct kunit *test) 610 { 611 struct drm_connector_init_priv *priv = test->priv; 612 struct drm_connector *connector = &priv->connector; 613 char expected_name[128]; 614 int ret; 615 616 ret = drm_connector_dynamic_register(connector); 617 KUNIT_ASSERT_EQ(test, ret, 0); 618 619 snprintf(expected_name, sizeof(expected_name), "card%d-%s", 620 connector->dev->primary->index, connector->name); 621 622 KUNIT_ASSERT_STREQ(test, dev_name(connector->kdev), expected_name); 623 } 624 625 /* 626 * Test that the registration of a dynamic connector after the drm device is 627 * registered adds the connector to debugfs. 628 */ 629 static void drm_test_drm_connector_dynamic_register_debugfs(struct kunit *test) 630 { 631 struct drm_connector_init_priv *priv = test->priv; 632 int ret; 633 634 KUNIT_ASSERT_NULL(test, priv->connector.debugfs_entry); 635 636 ret = drm_connector_dynamic_register(&priv->connector); 637 KUNIT_ASSERT_EQ(test, ret, 0); 638 639 if (IS_ENABLED(CONFIG_DEBUG_FS)) 640 KUNIT_ASSERT_NOT_NULL(test, priv->connector.debugfs_entry); 641 else 642 KUNIT_ASSERT_NULL(test, priv->connector.debugfs_entry); 643 } 644 645 static struct kunit_case drm_connector_dynamic_register_tests[] = { 646 KUNIT_CASE(drm_test_drm_connector_dynamic_register_on_list), 647 KUNIT_CASE(drm_test_drm_connector_dynamic_register_no_defer), 648 KUNIT_CASE(drm_test_drm_connector_dynamic_register_no_init), 649 KUNIT_CASE(drm_test_drm_connector_dynamic_register_mode_object), 650 KUNIT_CASE(drm_test_drm_connector_dynamic_register_sysfs), 651 KUNIT_CASE(drm_test_drm_connector_dynamic_register_sysfs_name), 652 KUNIT_CASE(drm_test_drm_connector_dynamic_register_debugfs), 653 { } 654 }; 655 656 static struct kunit_suite drm_connector_dynamic_register_test_suite = { 657 .name = "drm_connector_dynamic_register", 658 .init = drm_test_connector_dynamic_register_init, 659 .exit = drm_test_connector_dynamic_register_cleanup, 660 .test_cases = drm_connector_dynamic_register_tests, 661 }; 662 663 /* 664 * Test that the registration of a bog standard connector works as 665 * expected and doesn't report any error. 666 */ 667 static void drm_test_connector_hdmi_init_valid(struct kunit *test) 668 { 669 struct drm_connector_init_priv *priv = test->priv; 670 int ret; 671 672 ret = drmm_connector_hdmi_init(&priv->drm, &priv->connector, 673 "Vendor", "Product", 674 &dummy_funcs, 675 &dummy_hdmi_funcs, 676 DRM_MODE_CONNECTOR_HDMIA, 677 &priv->ddc, 678 BIT(HDMI_COLORSPACE_RGB), 679 8); 680 KUNIT_EXPECT_EQ(test, ret, 0); 681 } 682 683 /* 684 * Test that the registration of a connector without a DDC adapter 685 * doesn't report any error. 686 */ 687 static void drm_test_connector_hdmi_init_null_ddc(struct kunit *test) 688 { 689 struct drm_connector_init_priv *priv = test->priv; 690 int ret; 691 692 ret = drmm_connector_hdmi_init(&priv->drm, &priv->connector, 693 "Vendor", "Product", 694 &dummy_funcs, 695 &dummy_hdmi_funcs, 696 DRM_MODE_CONNECTOR_HDMIA, 697 NULL, 698 BIT(HDMI_COLORSPACE_RGB), 699 8); 700 KUNIT_EXPECT_EQ(test, ret, 0); 701 } 702 703 /* 704 * Test that the registration of an HDMI connector with a NULL vendor 705 * fails. 706 */ 707 static void drm_test_connector_hdmi_init_null_vendor(struct kunit *test) 708 { 709 struct drm_connector_init_priv *priv = test->priv; 710 int ret; 711 712 ret = drmm_connector_hdmi_init(&priv->drm, &priv->connector, 713 NULL, "Product", 714 &dummy_funcs, 715 &dummy_hdmi_funcs, 716 DRM_MODE_CONNECTOR_HDMIA, 717 &priv->ddc, 718 BIT(HDMI_COLORSPACE_RGB), 719 8); 720 KUNIT_EXPECT_LT(test, ret, 0); 721 } 722 723 /* 724 * Test that the registration of an HDMI connector with a NULL product 725 * fails. 726 */ 727 static void drm_test_connector_hdmi_init_null_product(struct kunit *test) 728 { 729 struct drm_connector_init_priv *priv = test->priv; 730 int ret; 731 732 ret = drmm_connector_hdmi_init(&priv->drm, &priv->connector, 733 "Vendor", NULL, 734 &dummy_funcs, 735 &dummy_hdmi_funcs, 736 DRM_MODE_CONNECTOR_HDMIA, 737 &priv->ddc, 738 BIT(HDMI_COLORSPACE_RGB), 739 8); 740 KUNIT_EXPECT_LT(test, ret, 0); 741 } 742 743 /* 744 * Test that the registration of a connector with a valid, shorter than 745 * the max length, product name succeeds, and is stored padded with 0. 746 */ 747 static void drm_test_connector_hdmi_init_product_valid(struct kunit *test) 748 { 749 struct drm_connector_init_priv *priv = test->priv; 750 const unsigned char expected_product[DRM_CONNECTOR_HDMI_PRODUCT_LEN] = { 751 'P', 'r', 'o', 'd', 752 }; 753 const char *product_name = "Prod"; 754 int ret; 755 756 KUNIT_ASSERT_LT(test, strlen(product_name), DRM_CONNECTOR_HDMI_PRODUCT_LEN); 757 758 ret = drmm_connector_hdmi_init(&priv->drm, &priv->connector, 759 "Vendor", product_name, 760 &dummy_funcs, 761 &dummy_hdmi_funcs, 762 DRM_MODE_CONNECTOR_HDMIA, 763 &priv->ddc, 764 BIT(HDMI_COLORSPACE_RGB), 765 8); 766 KUNIT_EXPECT_EQ(test, ret, 0); 767 KUNIT_EXPECT_MEMEQ(test, 768 priv->connector.hdmi.product, 769 expected_product, 770 sizeof(priv->connector.hdmi.product)); 771 } 772 773 /* 774 * Test that the registration of a connector with a valid, at max 775 * length, product name succeeds, and is stored padded without any 776 * trailing \0. 777 */ 778 static void drm_test_connector_hdmi_init_product_length_exact(struct kunit *test) 779 { 780 struct drm_connector_init_priv *priv = test->priv; 781 const unsigned char expected_product[DRM_CONNECTOR_HDMI_PRODUCT_LEN] = { 782 'P', 'r', 'o', 'd', 'u', 'c', 't', 783 'P', 'r', 'o', 'd', 'u', 'c', 't', 784 'P', 'r', 785 }; 786 const char *product_name = "ProductProductPr"; 787 int ret; 788 789 KUNIT_ASSERT_EQ(test, strlen(product_name), DRM_CONNECTOR_HDMI_PRODUCT_LEN); 790 791 ret = drmm_connector_hdmi_init(&priv->drm, &priv->connector, 792 "Vendor", product_name, 793 &dummy_funcs, 794 &dummy_hdmi_funcs, 795 DRM_MODE_CONNECTOR_HDMIA, 796 &priv->ddc, 797 BIT(HDMI_COLORSPACE_RGB), 798 8); 799 KUNIT_EXPECT_EQ(test, ret, 0); 800 KUNIT_EXPECT_MEMEQ(test, 801 priv->connector.hdmi.product, 802 expected_product, 803 sizeof(priv->connector.hdmi.product)); 804 } 805 806 /* 807 * Test that the registration of a connector with a product name larger 808 * than the maximum length fails. 809 */ 810 static void drm_test_connector_hdmi_init_product_length_too_long(struct kunit *test) 811 { 812 struct drm_connector_init_priv *priv = test->priv; 813 const char *product_name = "ProductProductProduct"; 814 int ret; 815 816 KUNIT_ASSERT_GT(test, strlen(product_name), DRM_CONNECTOR_HDMI_PRODUCT_LEN); 817 818 ret = drmm_connector_hdmi_init(&priv->drm, &priv->connector, 819 "Vendor", product_name, 820 &dummy_funcs, 821 &dummy_hdmi_funcs, 822 DRM_MODE_CONNECTOR_HDMIA, 823 &priv->ddc, 824 BIT(HDMI_COLORSPACE_RGB), 825 8); 826 KUNIT_EXPECT_LT(test, ret, 0); 827 } 828 829 /* 830 * Test that the registration of a connector with a vendor name smaller 831 * than the maximum length succeeds, and is stored padded with zeros. 832 */ 833 static void drm_test_connector_hdmi_init_vendor_valid(struct kunit *test) 834 { 835 struct drm_connector_init_priv *priv = test->priv; 836 const char expected_vendor[DRM_CONNECTOR_HDMI_VENDOR_LEN] = { 837 'V', 'e', 'n', 'd', 838 }; 839 const char *vendor_name = "Vend"; 840 int ret; 841 842 KUNIT_ASSERT_LT(test, strlen(vendor_name), DRM_CONNECTOR_HDMI_VENDOR_LEN); 843 844 ret = drmm_connector_hdmi_init(&priv->drm, &priv->connector, 845 vendor_name, "Product", 846 &dummy_funcs, 847 &dummy_hdmi_funcs, 848 DRM_MODE_CONNECTOR_HDMIA, 849 &priv->ddc, 850 BIT(HDMI_COLORSPACE_RGB), 851 8); 852 KUNIT_EXPECT_EQ(test, ret, 0); 853 KUNIT_EXPECT_MEMEQ(test, 854 priv->connector.hdmi.vendor, 855 expected_vendor, 856 sizeof(priv->connector.hdmi.vendor)); 857 } 858 859 /* 860 * Test that the registration of a connector with a vendor name at the 861 * maximum length succeeds, and is stored padded without the trailing 862 * zero. 863 */ 864 static void drm_test_connector_hdmi_init_vendor_length_exact(struct kunit *test) 865 { 866 struct drm_connector_init_priv *priv = test->priv; 867 const char expected_vendor[DRM_CONNECTOR_HDMI_VENDOR_LEN] = { 868 'V', 'e', 'n', 'd', 'o', 'r', 869 'V', 'e', 870 }; 871 const char *vendor_name = "VendorVe"; 872 int ret; 873 874 KUNIT_ASSERT_EQ(test, strlen(vendor_name), DRM_CONNECTOR_HDMI_VENDOR_LEN); 875 876 ret = drmm_connector_hdmi_init(&priv->drm, &priv->connector, 877 vendor_name, "Product", 878 &dummy_funcs, 879 &dummy_hdmi_funcs, 880 DRM_MODE_CONNECTOR_HDMIA, 881 &priv->ddc, 882 BIT(HDMI_COLORSPACE_RGB), 883 8); 884 KUNIT_EXPECT_EQ(test, ret, 0); 885 KUNIT_EXPECT_MEMEQ(test, 886 priv->connector.hdmi.vendor, 887 expected_vendor, 888 sizeof(priv->connector.hdmi.vendor)); 889 } 890 891 /* 892 * Test that the registration of a connector with a vendor name larger 893 * than the maximum length fails. 894 */ 895 static void drm_test_connector_hdmi_init_vendor_length_too_long(struct kunit *test) 896 { 897 struct drm_connector_init_priv *priv = test->priv; 898 const char *vendor_name = "VendorVendor"; 899 int ret; 900 901 KUNIT_ASSERT_GT(test, strlen(vendor_name), DRM_CONNECTOR_HDMI_VENDOR_LEN); 902 903 ret = drmm_connector_hdmi_init(&priv->drm, &priv->connector, 904 vendor_name, "Product", 905 &dummy_funcs, 906 &dummy_hdmi_funcs, 907 DRM_MODE_CONNECTOR_HDMIA, 908 &priv->ddc, 909 BIT(HDMI_COLORSPACE_RGB), 910 8); 911 KUNIT_EXPECT_LT(test, ret, 0); 912 } 913 914 /* 915 * Test that the registration of a connector with an invalid maximum bpc 916 * count fails. 917 */ 918 static void drm_test_connector_hdmi_init_bpc_invalid(struct kunit *test) 919 { 920 struct drm_connector_init_priv *priv = test->priv; 921 int ret; 922 923 ret = drmm_connector_hdmi_init(&priv->drm, &priv->connector, 924 "Vendor", "Product", 925 &dummy_funcs, 926 &dummy_hdmi_funcs, 927 DRM_MODE_CONNECTOR_HDMIA, 928 &priv->ddc, 929 BIT(HDMI_COLORSPACE_RGB), 930 9); 931 KUNIT_EXPECT_LT(test, ret, 0); 932 } 933 934 /* 935 * Test that the registration of a connector with a null maximum bpc 936 * count fails. 937 */ 938 static void drm_test_connector_hdmi_init_bpc_null(struct kunit *test) 939 { 940 struct drm_connector_init_priv *priv = test->priv; 941 int ret; 942 943 ret = drmm_connector_hdmi_init(&priv->drm, &priv->connector, 944 "Vendor", "Product", 945 &dummy_funcs, 946 &dummy_hdmi_funcs, 947 DRM_MODE_CONNECTOR_HDMIA, 948 &priv->ddc, 949 BIT(HDMI_COLORSPACE_RGB), 950 0); 951 KUNIT_EXPECT_LT(test, ret, 0); 952 } 953 954 /* 955 * Test that the registration of a connector with a maximum bpc count of 956 * 8 succeeds, registers the max bpc property, but doesn't register the 957 * HDR output metadata one. 958 */ 959 static void drm_test_connector_hdmi_init_bpc_8(struct kunit *test) 960 { 961 struct drm_connector_init_priv *priv = test->priv; 962 struct drm_connector_state *state; 963 struct drm_connector *connector = &priv->connector; 964 struct drm_property *prop; 965 uint64_t val; 966 int ret; 967 968 ret = drmm_connector_hdmi_init(&priv->drm, connector, 969 "Vendor", "Product", 970 &dummy_funcs, 971 &dummy_hdmi_funcs, 972 DRM_MODE_CONNECTOR_HDMIA, 973 &priv->ddc, 974 BIT(HDMI_COLORSPACE_RGB), 975 8); 976 KUNIT_EXPECT_EQ(test, ret, 0); 977 978 prop = connector->max_bpc_property; 979 KUNIT_ASSERT_NOT_NULL(test, prop); 980 KUNIT_EXPECT_NOT_NULL(test, drm_mode_obj_find_prop_id(&connector->base, prop->base.id)); 981 982 ret = drm_object_property_get_default_value(&connector->base, prop, &val); 983 KUNIT_EXPECT_EQ(test, ret, 0); 984 KUNIT_EXPECT_EQ(test, val, 8); 985 986 state = connector->state; 987 KUNIT_EXPECT_EQ(test, state->max_bpc, 8); 988 KUNIT_EXPECT_EQ(test, state->max_requested_bpc, 8); 989 990 prop = priv->drm.mode_config.hdr_output_metadata_property; 991 KUNIT_ASSERT_NOT_NULL(test, prop); 992 KUNIT_EXPECT_NULL(test, drm_mode_obj_find_prop_id(&connector->base, prop->base.id)); 993 } 994 995 /* 996 * Test that the registration of a connector with a maximum bpc count of 997 * 10 succeeds and registers the max bpc and HDR output metadata 998 * properties. 999 */ 1000 static void drm_test_connector_hdmi_init_bpc_10(struct kunit *test) 1001 { 1002 struct drm_connector_init_priv *priv = test->priv; 1003 struct drm_connector_state *state; 1004 struct drm_connector *connector = &priv->connector; 1005 struct drm_property *prop; 1006 uint64_t val; 1007 int ret; 1008 1009 ret = drmm_connector_hdmi_init(&priv->drm, connector, 1010 "Vendor", "Product", 1011 &dummy_funcs, 1012 &dummy_hdmi_funcs, 1013 DRM_MODE_CONNECTOR_HDMIA, 1014 &priv->ddc, 1015 BIT(HDMI_COLORSPACE_RGB), 1016 10); 1017 KUNIT_EXPECT_EQ(test, ret, 0); 1018 1019 prop = connector->max_bpc_property; 1020 KUNIT_ASSERT_NOT_NULL(test, prop); 1021 KUNIT_EXPECT_NOT_NULL(test, drm_mode_obj_find_prop_id(&connector->base, prop->base.id)); 1022 1023 ret = drm_object_property_get_default_value(&connector->base, prop, &val); 1024 KUNIT_EXPECT_EQ(test, ret, 0); 1025 KUNIT_EXPECT_EQ(test, val, 10); 1026 1027 state = connector->state; 1028 KUNIT_EXPECT_EQ(test, state->max_bpc, 10); 1029 KUNIT_EXPECT_EQ(test, state->max_requested_bpc, 10); 1030 1031 prop = priv->drm.mode_config.hdr_output_metadata_property; 1032 KUNIT_ASSERT_NOT_NULL(test, prop); 1033 KUNIT_EXPECT_NOT_NULL(test, drm_mode_obj_find_prop_id(&connector->base, prop->base.id)); 1034 } 1035 1036 /* 1037 * Test that the registration of a connector with a maximum bpc count of 1038 * 12 succeeds and registers the max bpc and HDR output metadata 1039 * properties. 1040 */ 1041 static void drm_test_connector_hdmi_init_bpc_12(struct kunit *test) 1042 { 1043 struct drm_connector_init_priv *priv = test->priv; 1044 struct drm_connector_state *state; 1045 struct drm_connector *connector = &priv->connector; 1046 struct drm_property *prop; 1047 uint64_t val; 1048 int ret; 1049 1050 ret = drmm_connector_hdmi_init(&priv->drm, connector, 1051 "Vendor", "Product", 1052 &dummy_funcs, 1053 &dummy_hdmi_funcs, 1054 DRM_MODE_CONNECTOR_HDMIA, 1055 &priv->ddc, 1056 BIT(HDMI_COLORSPACE_RGB), 1057 12); 1058 KUNIT_EXPECT_EQ(test, ret, 0); 1059 1060 prop = connector->max_bpc_property; 1061 KUNIT_ASSERT_NOT_NULL(test, prop); 1062 KUNIT_EXPECT_NOT_NULL(test, drm_mode_obj_find_prop_id(&connector->base, prop->base.id)); 1063 1064 ret = drm_object_property_get_default_value(&connector->base, prop, &val); 1065 KUNIT_EXPECT_EQ(test, ret, 0); 1066 KUNIT_EXPECT_EQ(test, val, 12); 1067 1068 state = connector->state; 1069 KUNIT_EXPECT_EQ(test, state->max_bpc, 12); 1070 KUNIT_EXPECT_EQ(test, state->max_requested_bpc, 12); 1071 1072 prop = priv->drm.mode_config.hdr_output_metadata_property; 1073 KUNIT_ASSERT_NOT_NULL(test, prop); 1074 KUNIT_EXPECT_NOT_NULL(test, drm_mode_obj_find_prop_id(&connector->base, prop->base.id)); 1075 } 1076 1077 /* 1078 * Test that the registration of an HDMI connector with no supported 1079 * format fails. 1080 */ 1081 static void drm_test_connector_hdmi_init_formats_empty(struct kunit *test) 1082 { 1083 struct drm_connector_init_priv *priv = test->priv; 1084 int ret; 1085 1086 ret = drmm_connector_hdmi_init(&priv->drm, &priv->connector, 1087 "Vendor", "Product", 1088 &dummy_funcs, 1089 &dummy_hdmi_funcs, 1090 DRM_MODE_CONNECTOR_HDMIA, 1091 &priv->ddc, 1092 0, 1093 8); 1094 KUNIT_EXPECT_LT(test, ret, 0); 1095 } 1096 1097 /* 1098 * Test that the registration of an HDMI connector not listing RGB as a 1099 * supported format fails. 1100 */ 1101 static void drm_test_connector_hdmi_init_formats_no_rgb(struct kunit *test) 1102 { 1103 struct drm_connector_init_priv *priv = test->priv; 1104 int ret; 1105 1106 ret = drmm_connector_hdmi_init(&priv->drm, &priv->connector, 1107 "Vendor", "Product", 1108 &dummy_funcs, 1109 &dummy_hdmi_funcs, 1110 DRM_MODE_CONNECTOR_HDMIA, 1111 &priv->ddc, 1112 BIT(HDMI_COLORSPACE_YUV422), 1113 8); 1114 KUNIT_EXPECT_LT(test, ret, 0); 1115 } 1116 1117 struct drm_connector_hdmi_init_formats_yuv420_allowed_test { 1118 unsigned long supported_formats; 1119 bool yuv420_allowed; 1120 int expected_result; 1121 }; 1122 1123 #define YUV420_ALLOWED_TEST(_formats, _allowed, _result) \ 1124 { \ 1125 .supported_formats = BIT(HDMI_COLORSPACE_RGB) | (_formats), \ 1126 .yuv420_allowed = _allowed, \ 1127 .expected_result = _result, \ 1128 } 1129 1130 static const struct drm_connector_hdmi_init_formats_yuv420_allowed_test 1131 drm_connector_hdmi_init_formats_yuv420_allowed_tests[] = { 1132 YUV420_ALLOWED_TEST(BIT(HDMI_COLORSPACE_YUV420), true, 0), 1133 YUV420_ALLOWED_TEST(BIT(HDMI_COLORSPACE_YUV420), false, -EINVAL), 1134 YUV420_ALLOWED_TEST(BIT(HDMI_COLORSPACE_YUV422), true, -EINVAL), 1135 YUV420_ALLOWED_TEST(BIT(HDMI_COLORSPACE_YUV422), false, 0), 1136 }; 1137 1138 static void 1139 drm_connector_hdmi_init_formats_yuv420_allowed_desc(const struct drm_connector_hdmi_init_formats_yuv420_allowed_test *t, 1140 char *desc) 1141 { 1142 sprintf(desc, "supported_formats=0x%lx yuv420_allowed=%d", 1143 t->supported_formats, t->yuv420_allowed); 1144 } 1145 1146 KUNIT_ARRAY_PARAM(drm_connector_hdmi_init_formats_yuv420_allowed, 1147 drm_connector_hdmi_init_formats_yuv420_allowed_tests, 1148 drm_connector_hdmi_init_formats_yuv420_allowed_desc); 1149 1150 /* 1151 * Test that the registration of an HDMI connector succeeds only when 1152 * the presence of YUV420 in the supported formats matches the value 1153 * of the ycbcr_420_allowed flag. 1154 */ 1155 static void drm_test_connector_hdmi_init_formats_yuv420_allowed(struct kunit *test) 1156 { 1157 const struct drm_connector_hdmi_init_formats_yuv420_allowed_test *params; 1158 struct drm_connector_init_priv *priv = test->priv; 1159 int ret; 1160 1161 params = test->param_value; 1162 priv->connector.ycbcr_420_allowed = params->yuv420_allowed; 1163 1164 ret = drmm_connector_hdmi_init(&priv->drm, &priv->connector, 1165 "Vendor", "Product", 1166 &dummy_funcs, 1167 &dummy_hdmi_funcs, 1168 DRM_MODE_CONNECTOR_HDMIA, 1169 &priv->ddc, 1170 params->supported_formats, 1171 8); 1172 KUNIT_EXPECT_EQ(test, ret, params->expected_result); 1173 } 1174 1175 /* 1176 * Test that the registration of an HDMI connector with an HDMI 1177 * connector type succeeds. 1178 */ 1179 static void drm_test_connector_hdmi_init_type_valid(struct kunit *test) 1180 { 1181 struct drm_connector_init_priv *priv = test->priv; 1182 unsigned int connector_type = *(unsigned int *)test->param_value; 1183 int ret; 1184 1185 ret = drmm_connector_hdmi_init(&priv->drm, &priv->connector, 1186 "Vendor", "Product", 1187 &dummy_funcs, 1188 &dummy_hdmi_funcs, 1189 connector_type, 1190 &priv->ddc, 1191 BIT(HDMI_COLORSPACE_RGB), 1192 8); 1193 KUNIT_EXPECT_EQ(test, ret, 0); 1194 } 1195 1196 static const unsigned int drm_connector_hdmi_init_type_valid_tests[] = { 1197 DRM_MODE_CONNECTOR_HDMIA, 1198 DRM_MODE_CONNECTOR_HDMIB, 1199 }; 1200 1201 static void drm_connector_hdmi_init_type_desc(const unsigned int *type, char *desc) 1202 { 1203 sprintf(desc, "%s", drm_get_connector_type_name(*type)); 1204 } 1205 1206 KUNIT_ARRAY_PARAM(drm_connector_hdmi_init_type_valid, 1207 drm_connector_hdmi_init_type_valid_tests, 1208 drm_connector_hdmi_init_type_desc); 1209 1210 /* 1211 * Test that the registration of an HDMI connector with an !HDMI 1212 * connector type fails. 1213 */ 1214 static void drm_test_connector_hdmi_init_type_invalid(struct kunit *test) 1215 { 1216 struct drm_connector_init_priv *priv = test->priv; 1217 unsigned int connector_type = *(unsigned int *)test->param_value; 1218 int ret; 1219 1220 ret = drmm_connector_hdmi_init(&priv->drm, &priv->connector, 1221 "Vendor", "Product", 1222 &dummy_funcs, 1223 &dummy_hdmi_funcs, 1224 connector_type, 1225 &priv->ddc, 1226 BIT(HDMI_COLORSPACE_RGB), 1227 8); 1228 KUNIT_EXPECT_LT(test, ret, 0); 1229 } 1230 1231 static const unsigned int drm_connector_hdmi_init_type_invalid_tests[] = { 1232 DRM_MODE_CONNECTOR_Unknown, 1233 DRM_MODE_CONNECTOR_VGA, 1234 DRM_MODE_CONNECTOR_DVII, 1235 DRM_MODE_CONNECTOR_DVID, 1236 DRM_MODE_CONNECTOR_DVIA, 1237 DRM_MODE_CONNECTOR_Composite, 1238 DRM_MODE_CONNECTOR_SVIDEO, 1239 DRM_MODE_CONNECTOR_LVDS, 1240 DRM_MODE_CONNECTOR_Component, 1241 DRM_MODE_CONNECTOR_9PinDIN, 1242 DRM_MODE_CONNECTOR_DisplayPort, 1243 DRM_MODE_CONNECTOR_TV, 1244 DRM_MODE_CONNECTOR_eDP, 1245 DRM_MODE_CONNECTOR_VIRTUAL, 1246 DRM_MODE_CONNECTOR_DSI, 1247 DRM_MODE_CONNECTOR_DPI, 1248 DRM_MODE_CONNECTOR_WRITEBACK, 1249 DRM_MODE_CONNECTOR_SPI, 1250 DRM_MODE_CONNECTOR_USB, 1251 }; 1252 1253 KUNIT_ARRAY_PARAM(drm_connector_hdmi_init_type_invalid, 1254 drm_connector_hdmi_init_type_invalid_tests, 1255 drm_connector_hdmi_init_type_desc); 1256 1257 static struct kunit_case drmm_connector_hdmi_init_tests[] = { 1258 KUNIT_CASE(drm_test_connector_hdmi_init_valid), 1259 KUNIT_CASE(drm_test_connector_hdmi_init_bpc_8), 1260 KUNIT_CASE(drm_test_connector_hdmi_init_bpc_10), 1261 KUNIT_CASE(drm_test_connector_hdmi_init_bpc_12), 1262 KUNIT_CASE(drm_test_connector_hdmi_init_bpc_invalid), 1263 KUNIT_CASE(drm_test_connector_hdmi_init_bpc_null), 1264 KUNIT_CASE(drm_test_connector_hdmi_init_formats_empty), 1265 KUNIT_CASE(drm_test_connector_hdmi_init_formats_no_rgb), 1266 KUNIT_CASE_PARAM(drm_test_connector_hdmi_init_formats_yuv420_allowed, 1267 drm_connector_hdmi_init_formats_yuv420_allowed_gen_params), 1268 KUNIT_CASE(drm_test_connector_hdmi_init_null_ddc), 1269 KUNIT_CASE(drm_test_connector_hdmi_init_null_product), 1270 KUNIT_CASE(drm_test_connector_hdmi_init_null_vendor), 1271 KUNIT_CASE(drm_test_connector_hdmi_init_product_length_exact), 1272 KUNIT_CASE(drm_test_connector_hdmi_init_product_length_too_long), 1273 KUNIT_CASE(drm_test_connector_hdmi_init_product_valid), 1274 KUNIT_CASE(drm_test_connector_hdmi_init_vendor_length_exact), 1275 KUNIT_CASE(drm_test_connector_hdmi_init_vendor_length_too_long), 1276 KUNIT_CASE(drm_test_connector_hdmi_init_vendor_valid), 1277 KUNIT_CASE_PARAM(drm_test_connector_hdmi_init_type_valid, 1278 drm_connector_hdmi_init_type_valid_gen_params), 1279 KUNIT_CASE_PARAM(drm_test_connector_hdmi_init_type_invalid, 1280 drm_connector_hdmi_init_type_invalid_gen_params), 1281 { } 1282 }; 1283 1284 static struct kunit_suite drmm_connector_hdmi_init_test_suite = { 1285 .name = "drmm_connector_hdmi_init", 1286 .init = drm_test_connector_init, 1287 .test_cases = drmm_connector_hdmi_init_tests, 1288 }; 1289 1290 struct drm_get_tv_mode_from_name_test { 1291 const char *name; 1292 enum drm_connector_tv_mode expected_mode; 1293 }; 1294 1295 #define TV_MODE_NAME(_name, _mode) \ 1296 { \ 1297 .name = _name, \ 1298 .expected_mode = _mode, \ 1299 } 1300 1301 static void drm_test_get_tv_mode_from_name_valid(struct kunit *test) 1302 { 1303 const struct drm_get_tv_mode_from_name_test *params = test->param_value; 1304 1305 KUNIT_EXPECT_EQ(test, 1306 drm_get_tv_mode_from_name(params->name, strlen(params->name)), 1307 params->expected_mode); 1308 } 1309 1310 static const 1311 struct drm_get_tv_mode_from_name_test drm_get_tv_mode_from_name_valid_tests[] = { 1312 TV_MODE_NAME("NTSC", DRM_MODE_TV_MODE_NTSC), 1313 TV_MODE_NAME("NTSC-443", DRM_MODE_TV_MODE_NTSC_443), 1314 TV_MODE_NAME("NTSC-J", DRM_MODE_TV_MODE_NTSC_J), 1315 TV_MODE_NAME("PAL", DRM_MODE_TV_MODE_PAL), 1316 TV_MODE_NAME("PAL-M", DRM_MODE_TV_MODE_PAL_M), 1317 TV_MODE_NAME("PAL-N", DRM_MODE_TV_MODE_PAL_N), 1318 TV_MODE_NAME("SECAM", DRM_MODE_TV_MODE_SECAM), 1319 TV_MODE_NAME("Mono", DRM_MODE_TV_MODE_MONOCHROME), 1320 }; 1321 1322 static void 1323 drm_get_tv_mode_from_name_valid_desc(const struct drm_get_tv_mode_from_name_test *t, 1324 char *desc) 1325 { 1326 sprintf(desc, "%s", t->name); 1327 } 1328 1329 KUNIT_ARRAY_PARAM(drm_get_tv_mode_from_name_valid, 1330 drm_get_tv_mode_from_name_valid_tests, 1331 drm_get_tv_mode_from_name_valid_desc); 1332 1333 static void drm_test_get_tv_mode_from_name_truncated(struct kunit *test) 1334 { 1335 const char *name = "NTS"; 1336 int ret; 1337 1338 ret = drm_get_tv_mode_from_name(name, strlen(name)); 1339 KUNIT_EXPECT_LT(test, ret, 0); 1340 }; 1341 1342 static struct kunit_case drm_get_tv_mode_from_name_tests[] = { 1343 KUNIT_CASE_PARAM(drm_test_get_tv_mode_from_name_valid, 1344 drm_get_tv_mode_from_name_valid_gen_params), 1345 KUNIT_CASE(drm_test_get_tv_mode_from_name_truncated), 1346 { } 1347 }; 1348 1349 static struct kunit_suite drm_get_tv_mode_from_name_test_suite = { 1350 .name = "drm_get_tv_mode_from_name", 1351 .test_cases = drm_get_tv_mode_from_name_tests, 1352 }; 1353 1354 struct drm_hdmi_connector_get_broadcast_rgb_name_test { 1355 unsigned int kind; 1356 const char *expected_name; 1357 }; 1358 1359 #define BROADCAST_RGB_TEST(_kind, _name) \ 1360 { \ 1361 .kind = _kind, \ 1362 .expected_name = _name, \ 1363 } 1364 1365 static void drm_test_drm_hdmi_connector_get_broadcast_rgb_name(struct kunit *test) 1366 { 1367 const struct drm_hdmi_connector_get_broadcast_rgb_name_test *params = 1368 test->param_value; 1369 1370 KUNIT_EXPECT_STREQ(test, 1371 drm_hdmi_connector_get_broadcast_rgb_name(params->kind), 1372 params->expected_name); 1373 } 1374 1375 static const 1376 struct drm_hdmi_connector_get_broadcast_rgb_name_test 1377 drm_hdmi_connector_get_broadcast_rgb_name_valid_tests[] = { 1378 BROADCAST_RGB_TEST(DRM_HDMI_BROADCAST_RGB_AUTO, "Automatic"), 1379 BROADCAST_RGB_TEST(DRM_HDMI_BROADCAST_RGB_FULL, "Full"), 1380 BROADCAST_RGB_TEST(DRM_HDMI_BROADCAST_RGB_LIMITED, "Limited 16:235"), 1381 }; 1382 1383 static void 1384 drm_hdmi_connector_get_broadcast_rgb_name_valid_desc(const struct drm_hdmi_connector_get_broadcast_rgb_name_test *t, 1385 char *desc) 1386 { 1387 sprintf(desc, "%s", t->expected_name); 1388 } 1389 1390 KUNIT_ARRAY_PARAM(drm_hdmi_connector_get_broadcast_rgb_name_valid, 1391 drm_hdmi_connector_get_broadcast_rgb_name_valid_tests, 1392 drm_hdmi_connector_get_broadcast_rgb_name_valid_desc); 1393 1394 static void drm_test_drm_hdmi_connector_get_broadcast_rgb_name_invalid(struct kunit *test) 1395 { 1396 KUNIT_EXPECT_NULL(test, drm_hdmi_connector_get_broadcast_rgb_name(3)); 1397 }; 1398 1399 static struct kunit_case drm_hdmi_connector_get_broadcast_rgb_name_tests[] = { 1400 KUNIT_CASE_PARAM(drm_test_drm_hdmi_connector_get_broadcast_rgb_name, 1401 drm_hdmi_connector_get_broadcast_rgb_name_valid_gen_params), 1402 KUNIT_CASE(drm_test_drm_hdmi_connector_get_broadcast_rgb_name_invalid), 1403 { } 1404 }; 1405 1406 static struct kunit_suite drm_hdmi_connector_get_broadcast_rgb_name_test_suite = { 1407 .name = "drm_hdmi_connector_get_broadcast_rgb_name", 1408 .test_cases = drm_hdmi_connector_get_broadcast_rgb_name_tests, 1409 }; 1410 1411 struct drm_hdmi_connector_get_output_format_name_test { 1412 unsigned int kind; 1413 const char *expected_name; 1414 }; 1415 1416 #define OUTPUT_FORMAT_TEST(_kind, _name) \ 1417 { \ 1418 .kind = _kind, \ 1419 .expected_name = _name, \ 1420 } 1421 1422 static void drm_test_drm_hdmi_connector_get_output_format_name(struct kunit *test) 1423 { 1424 const struct drm_hdmi_connector_get_output_format_name_test *params = 1425 test->param_value; 1426 1427 KUNIT_EXPECT_STREQ(test, 1428 drm_hdmi_connector_get_output_format_name(params->kind), 1429 params->expected_name); 1430 } 1431 1432 static const 1433 struct drm_hdmi_connector_get_output_format_name_test 1434 drm_hdmi_connector_get_output_format_name_valid_tests[] = { 1435 OUTPUT_FORMAT_TEST(HDMI_COLORSPACE_RGB, "RGB"), 1436 OUTPUT_FORMAT_TEST(HDMI_COLORSPACE_YUV420, "YUV 4:2:0"), 1437 OUTPUT_FORMAT_TEST(HDMI_COLORSPACE_YUV422, "YUV 4:2:2"), 1438 OUTPUT_FORMAT_TEST(HDMI_COLORSPACE_YUV444, "YUV 4:4:4"), 1439 }; 1440 1441 static void 1442 drm_hdmi_connector_get_output_format_name_valid_desc(const struct drm_hdmi_connector_get_output_format_name_test *t, 1443 char *desc) 1444 { 1445 sprintf(desc, "%s", t->expected_name); 1446 } 1447 1448 KUNIT_ARRAY_PARAM(drm_hdmi_connector_get_output_format_name_valid, 1449 drm_hdmi_connector_get_output_format_name_valid_tests, 1450 drm_hdmi_connector_get_output_format_name_valid_desc); 1451 1452 static void drm_test_drm_hdmi_connector_get_output_format_name_invalid(struct kunit *test) 1453 { 1454 KUNIT_EXPECT_NULL(test, drm_hdmi_connector_get_output_format_name(4)); 1455 }; 1456 1457 static struct kunit_case drm_hdmi_connector_get_output_format_name_tests[] = { 1458 KUNIT_CASE_PARAM(drm_test_drm_hdmi_connector_get_output_format_name, 1459 drm_hdmi_connector_get_output_format_name_valid_gen_params), 1460 KUNIT_CASE(drm_test_drm_hdmi_connector_get_output_format_name_invalid), 1461 { } 1462 }; 1463 1464 static struct kunit_suite drm_hdmi_connector_get_output_format_name_test_suite = { 1465 .name = "drm_hdmi_connector_get_output_format_name", 1466 .test_cases = drm_hdmi_connector_get_output_format_name_tests, 1467 }; 1468 1469 static void drm_test_drm_connector_attach_broadcast_rgb_property(struct kunit *test) 1470 { 1471 struct drm_connector_init_priv *priv = test->priv; 1472 struct drm_connector *connector = &priv->connector; 1473 struct drm_property *prop; 1474 int ret; 1475 1476 ret = drmm_connector_init(&priv->drm, connector, 1477 &dummy_funcs, 1478 DRM_MODE_CONNECTOR_HDMIA, 1479 &priv->ddc); 1480 KUNIT_ASSERT_EQ(test, ret, 0); 1481 1482 ret = drm_connector_attach_broadcast_rgb_property(connector); 1483 KUNIT_ASSERT_EQ(test, ret, 0); 1484 1485 prop = connector->broadcast_rgb_property; 1486 KUNIT_ASSERT_NOT_NULL(test, prop); 1487 KUNIT_EXPECT_NOT_NULL(test, drm_mode_obj_find_prop_id(&connector->base, prop->base.id)); 1488 } 1489 1490 static void drm_test_drm_connector_attach_broadcast_rgb_property_hdmi_connector(struct kunit *test) 1491 { 1492 struct drm_connector_init_priv *priv = test->priv; 1493 struct drm_connector *connector = &priv->connector; 1494 struct drm_property *prop; 1495 int ret; 1496 1497 ret = drmm_connector_hdmi_init(&priv->drm, connector, 1498 "Vendor", "Product", 1499 &dummy_funcs, 1500 &dummy_hdmi_funcs, 1501 DRM_MODE_CONNECTOR_HDMIA, 1502 &priv->ddc, 1503 BIT(HDMI_COLORSPACE_RGB), 1504 8); 1505 KUNIT_EXPECT_EQ(test, ret, 0); 1506 1507 ret = drm_connector_attach_broadcast_rgb_property(connector); 1508 KUNIT_ASSERT_EQ(test, ret, 0); 1509 1510 prop = connector->broadcast_rgb_property; 1511 KUNIT_ASSERT_NOT_NULL(test, prop); 1512 KUNIT_EXPECT_NOT_NULL(test, drm_mode_obj_find_prop_id(&connector->base, prop->base.id)); 1513 } 1514 1515 static struct kunit_case drm_connector_attach_broadcast_rgb_property_tests[] = { 1516 KUNIT_CASE(drm_test_drm_connector_attach_broadcast_rgb_property), 1517 KUNIT_CASE(drm_test_drm_connector_attach_broadcast_rgb_property_hdmi_connector), 1518 { } 1519 }; 1520 1521 static struct kunit_suite drm_connector_attach_broadcast_rgb_property_test_suite = { 1522 .name = "drm_connector_attach_broadcast_rgb_property", 1523 .init = drm_test_connector_init, 1524 .test_cases = drm_connector_attach_broadcast_rgb_property_tests, 1525 }; 1526 1527 /* 1528 * Test that for a given mode, with 8bpc and an RGB output the TMDS 1529 * character rate is equal to the mode pixel clock. 1530 */ 1531 static void drm_test_drm_hdmi_compute_mode_clock_rgb(struct kunit *test) 1532 { 1533 struct drm_connector_init_priv *priv = test->priv; 1534 const struct drm_display_mode *mode; 1535 unsigned long long rate; 1536 struct drm_device *drm = &priv->drm; 1537 1538 mode = drm_kunit_display_mode_from_cea_vic(test, drm, 16); 1539 KUNIT_ASSERT_NOT_NULL(test, mode); 1540 1541 KUNIT_ASSERT_FALSE(test, mode->flags & DRM_MODE_FLAG_DBLCLK); 1542 1543 rate = drm_hdmi_compute_mode_clock(mode, 8, HDMI_COLORSPACE_RGB); 1544 KUNIT_ASSERT_GT(test, rate, 0); 1545 KUNIT_EXPECT_EQ(test, mode->clock * 1000ULL, rate); 1546 } 1547 1548 /* 1549 * Test that for a given mode, with 10bpc and an RGB output the TMDS 1550 * character rate is equal to 1.25 times the mode pixel clock. 1551 */ 1552 static void drm_test_drm_hdmi_compute_mode_clock_rgb_10bpc(struct kunit *test) 1553 { 1554 struct drm_connector_init_priv *priv = test->priv; 1555 const struct drm_display_mode *mode; 1556 unsigned long long rate; 1557 struct drm_device *drm = &priv->drm; 1558 1559 mode = drm_kunit_display_mode_from_cea_vic(test, drm, 16); 1560 KUNIT_ASSERT_NOT_NULL(test, mode); 1561 1562 KUNIT_ASSERT_FALSE(test, mode->flags & DRM_MODE_FLAG_DBLCLK); 1563 1564 rate = drm_hdmi_compute_mode_clock(mode, 10, HDMI_COLORSPACE_RGB); 1565 KUNIT_ASSERT_GT(test, rate, 0); 1566 KUNIT_EXPECT_EQ(test, mode->clock * 1250, rate); 1567 } 1568 1569 /* 1570 * Test that for the VIC-1 mode, with 10bpc and an RGB output the TMDS 1571 * character rate computation fails. 1572 */ 1573 static void drm_test_drm_hdmi_compute_mode_clock_rgb_10bpc_vic_1(struct kunit *test) 1574 { 1575 struct drm_connector_init_priv *priv = test->priv; 1576 const struct drm_display_mode *mode; 1577 unsigned long long rate; 1578 struct drm_device *drm = &priv->drm; 1579 1580 mode = drm_kunit_display_mode_from_cea_vic(test, drm, 1); 1581 KUNIT_ASSERT_NOT_NULL(test, mode); 1582 1583 rate = drm_hdmi_compute_mode_clock(mode, 10, HDMI_COLORSPACE_RGB); 1584 KUNIT_EXPECT_EQ(test, rate, 0); 1585 } 1586 1587 /* 1588 * Test that for a given mode, with 12bpc and an RGB output the TMDS 1589 * character rate is equal to 1.5 times the mode pixel clock. 1590 */ 1591 static void drm_test_drm_hdmi_compute_mode_clock_rgb_12bpc(struct kunit *test) 1592 { 1593 struct drm_connector_init_priv *priv = test->priv; 1594 const struct drm_display_mode *mode; 1595 unsigned long long rate; 1596 struct drm_device *drm = &priv->drm; 1597 1598 mode = drm_kunit_display_mode_from_cea_vic(test, drm, 16); 1599 KUNIT_ASSERT_NOT_NULL(test, mode); 1600 1601 KUNIT_ASSERT_FALSE(test, mode->flags & DRM_MODE_FLAG_DBLCLK); 1602 1603 rate = drm_hdmi_compute_mode_clock(mode, 12, HDMI_COLORSPACE_RGB); 1604 KUNIT_ASSERT_GT(test, rate, 0); 1605 KUNIT_EXPECT_EQ(test, mode->clock * 1500, rate); 1606 } 1607 1608 /* 1609 * Test that for the VIC-1 mode, with 12bpc and an RGB output the TMDS 1610 * character rate computation fails. 1611 */ 1612 static void drm_test_drm_hdmi_compute_mode_clock_rgb_12bpc_vic_1(struct kunit *test) 1613 { 1614 struct drm_connector_init_priv *priv = test->priv; 1615 const struct drm_display_mode *mode; 1616 unsigned long long rate; 1617 struct drm_device *drm = &priv->drm; 1618 1619 mode = drm_kunit_display_mode_from_cea_vic(test, drm, 1); 1620 KUNIT_ASSERT_NOT_NULL(test, mode); 1621 1622 rate = drm_hdmi_compute_mode_clock(mode, 12, HDMI_COLORSPACE_RGB); 1623 KUNIT_EXPECT_EQ(test, rate, 0); 1624 } 1625 1626 /* 1627 * Test that for a mode with the pixel repetition flag, the TMDS 1628 * character rate is indeed double the mode pixel clock. 1629 */ 1630 static void drm_test_drm_hdmi_compute_mode_clock_rgb_double(struct kunit *test) 1631 { 1632 struct drm_connector_init_priv *priv = test->priv; 1633 const struct drm_display_mode *mode; 1634 unsigned long long rate; 1635 struct drm_device *drm = &priv->drm; 1636 1637 mode = drm_kunit_display_mode_from_cea_vic(test, drm, 6); 1638 KUNIT_ASSERT_NOT_NULL(test, mode); 1639 1640 KUNIT_ASSERT_TRUE(test, mode->flags & DRM_MODE_FLAG_DBLCLK); 1641 1642 rate = drm_hdmi_compute_mode_clock(mode, 8, HDMI_COLORSPACE_RGB); 1643 KUNIT_ASSERT_GT(test, rate, 0); 1644 KUNIT_EXPECT_EQ(test, (mode->clock * 1000ULL) * 2, rate); 1645 } 1646 1647 /* 1648 * Test that the TMDS character rate computation for the VIC modes 1649 * explicitly listed in the spec as supporting YUV420 succeed and return 1650 * half the mode pixel clock. 1651 */ 1652 static void drm_test_connector_hdmi_compute_mode_clock_yuv420_valid(struct kunit *test) 1653 { 1654 struct drm_connector_init_priv *priv = test->priv; 1655 const struct drm_display_mode *mode; 1656 struct drm_device *drm = &priv->drm; 1657 unsigned long long rate; 1658 unsigned int vic = *(unsigned int *)test->param_value; 1659 1660 mode = drm_kunit_display_mode_from_cea_vic(test, drm, vic); 1661 KUNIT_ASSERT_NOT_NULL(test, mode); 1662 1663 KUNIT_ASSERT_FALSE(test, mode->flags & DRM_MODE_FLAG_DBLCLK); 1664 1665 rate = drm_hdmi_compute_mode_clock(mode, 8, HDMI_COLORSPACE_YUV420); 1666 KUNIT_ASSERT_GT(test, rate, 0); 1667 KUNIT_EXPECT_EQ(test, (mode->clock * 1000ULL) / 2, rate); 1668 } 1669 1670 static const unsigned int drm_hdmi_compute_mode_clock_yuv420_vic_valid_tests[] = { 1671 96, 97, 101, 102, 106, 107, 1672 }; 1673 1674 static void drm_hdmi_compute_mode_clock_yuv420_vic_desc(const unsigned int *vic, char *desc) 1675 { 1676 sprintf(desc, "VIC %u", *vic); 1677 } 1678 1679 KUNIT_ARRAY_PARAM(drm_hdmi_compute_mode_clock_yuv420_valid, 1680 drm_hdmi_compute_mode_clock_yuv420_vic_valid_tests, 1681 drm_hdmi_compute_mode_clock_yuv420_vic_desc); 1682 1683 /* 1684 * Test that for a given mode listed supporting it and an YUV420 output 1685 * with 10bpc, the TMDS character rate is equal to 0.625 times the mode 1686 * pixel clock. 1687 */ 1688 static void drm_test_connector_hdmi_compute_mode_clock_yuv420_10_bpc(struct kunit *test) 1689 { 1690 struct drm_connector_init_priv *priv = test->priv; 1691 const struct drm_display_mode *mode; 1692 struct drm_device *drm = &priv->drm; 1693 unsigned int vic = 1694 drm_hdmi_compute_mode_clock_yuv420_vic_valid_tests[0]; 1695 unsigned long long rate; 1696 1697 mode = drm_kunit_display_mode_from_cea_vic(test, drm, vic); 1698 KUNIT_ASSERT_NOT_NULL(test, mode); 1699 1700 KUNIT_ASSERT_FALSE(test, mode->flags & DRM_MODE_FLAG_DBLCLK); 1701 1702 rate = drm_hdmi_compute_mode_clock(mode, 10, HDMI_COLORSPACE_YUV420); 1703 KUNIT_ASSERT_GT(test, rate, 0); 1704 1705 KUNIT_EXPECT_EQ(test, mode->clock * 625, rate); 1706 } 1707 1708 /* 1709 * Test that for a given mode listed supporting it and an YUV420 output 1710 * with 12bpc, the TMDS character rate is equal to 0.75 times the mode 1711 * pixel clock. 1712 */ 1713 static void drm_test_connector_hdmi_compute_mode_clock_yuv420_12_bpc(struct kunit *test) 1714 { 1715 struct drm_connector_init_priv *priv = test->priv; 1716 const struct drm_display_mode *mode; 1717 struct drm_device *drm = &priv->drm; 1718 unsigned int vic = 1719 drm_hdmi_compute_mode_clock_yuv420_vic_valid_tests[0]; 1720 unsigned long long rate; 1721 1722 mode = drm_kunit_display_mode_from_cea_vic(test, drm, vic); 1723 KUNIT_ASSERT_NOT_NULL(test, mode); 1724 1725 KUNIT_ASSERT_FALSE(test, mode->flags & DRM_MODE_FLAG_DBLCLK); 1726 1727 rate = drm_hdmi_compute_mode_clock(mode, 12, HDMI_COLORSPACE_YUV420); 1728 KUNIT_ASSERT_GT(test, rate, 0); 1729 1730 KUNIT_EXPECT_EQ(test, mode->clock * 750, rate); 1731 } 1732 1733 /* 1734 * Test that for a given mode, the computation of the TMDS character 1735 * rate with 8bpc and a YUV422 output succeeds and returns a rate equal 1736 * to the mode pixel clock. 1737 */ 1738 static void drm_test_connector_hdmi_compute_mode_clock_yuv422_8_bpc(struct kunit *test) 1739 { 1740 struct drm_connector_init_priv *priv = test->priv; 1741 const struct drm_display_mode *mode; 1742 struct drm_device *drm = &priv->drm; 1743 unsigned long long rate; 1744 1745 mode = drm_kunit_display_mode_from_cea_vic(test, drm, 16); 1746 KUNIT_ASSERT_NOT_NULL(test, mode); 1747 1748 KUNIT_ASSERT_FALSE(test, mode->flags & DRM_MODE_FLAG_DBLCLK); 1749 1750 rate = drm_hdmi_compute_mode_clock(mode, 8, HDMI_COLORSPACE_YUV422); 1751 KUNIT_ASSERT_GT(test, rate, 0); 1752 KUNIT_EXPECT_EQ(test, mode->clock * 1000, rate); 1753 } 1754 1755 /* 1756 * Test that for a given mode, the computation of the TMDS character 1757 * rate with 10bpc and a YUV422 output succeeds and returns a rate equal 1758 * to the mode pixel clock. 1759 */ 1760 static void drm_test_connector_hdmi_compute_mode_clock_yuv422_10_bpc(struct kunit *test) 1761 { 1762 struct drm_connector_init_priv *priv = test->priv; 1763 const struct drm_display_mode *mode; 1764 struct drm_device *drm = &priv->drm; 1765 unsigned long long rate; 1766 1767 mode = drm_kunit_display_mode_from_cea_vic(test, drm, 16); 1768 KUNIT_ASSERT_NOT_NULL(test, mode); 1769 1770 KUNIT_ASSERT_FALSE(test, mode->flags & DRM_MODE_FLAG_DBLCLK); 1771 1772 rate = drm_hdmi_compute_mode_clock(mode, 10, HDMI_COLORSPACE_YUV422); 1773 KUNIT_ASSERT_GT(test, rate, 0); 1774 KUNIT_EXPECT_EQ(test, mode->clock * 1000, rate); 1775 } 1776 1777 /* 1778 * Test that for a given mode, the computation of the TMDS character 1779 * rate with 12bpc and a YUV422 output succeeds and returns a rate equal 1780 * to the mode pixel clock. 1781 */ 1782 static void drm_test_connector_hdmi_compute_mode_clock_yuv422_12_bpc(struct kunit *test) 1783 { 1784 struct drm_connector_init_priv *priv = test->priv; 1785 const struct drm_display_mode *mode; 1786 struct drm_device *drm = &priv->drm; 1787 unsigned long long rate; 1788 1789 mode = drm_kunit_display_mode_from_cea_vic(test, drm, 16); 1790 KUNIT_ASSERT_NOT_NULL(test, mode); 1791 1792 KUNIT_ASSERT_FALSE(test, mode->flags & DRM_MODE_FLAG_DBLCLK); 1793 1794 rate = drm_hdmi_compute_mode_clock(mode, 12, HDMI_COLORSPACE_YUV422); 1795 KUNIT_ASSERT_GT(test, rate, 0); 1796 KUNIT_EXPECT_EQ(test, mode->clock * 1000, rate); 1797 } 1798 1799 static struct kunit_case drm_hdmi_compute_mode_clock_tests[] = { 1800 KUNIT_CASE(drm_test_drm_hdmi_compute_mode_clock_rgb), 1801 KUNIT_CASE(drm_test_drm_hdmi_compute_mode_clock_rgb_10bpc), 1802 KUNIT_CASE(drm_test_drm_hdmi_compute_mode_clock_rgb_10bpc_vic_1), 1803 KUNIT_CASE(drm_test_drm_hdmi_compute_mode_clock_rgb_12bpc), 1804 KUNIT_CASE(drm_test_drm_hdmi_compute_mode_clock_rgb_12bpc_vic_1), 1805 KUNIT_CASE(drm_test_drm_hdmi_compute_mode_clock_rgb_double), 1806 KUNIT_CASE_PARAM(drm_test_connector_hdmi_compute_mode_clock_yuv420_valid, 1807 drm_hdmi_compute_mode_clock_yuv420_valid_gen_params), 1808 KUNIT_CASE(drm_test_connector_hdmi_compute_mode_clock_yuv420_10_bpc), 1809 KUNIT_CASE(drm_test_connector_hdmi_compute_mode_clock_yuv420_12_bpc), 1810 KUNIT_CASE(drm_test_connector_hdmi_compute_mode_clock_yuv422_8_bpc), 1811 KUNIT_CASE(drm_test_connector_hdmi_compute_mode_clock_yuv422_10_bpc), 1812 KUNIT_CASE(drm_test_connector_hdmi_compute_mode_clock_yuv422_12_bpc), 1813 { } 1814 }; 1815 1816 static struct kunit_suite drm_hdmi_compute_mode_clock_test_suite = { 1817 .name = "drm_test_connector_hdmi_compute_mode_clock", 1818 .init = drm_test_connector_init, 1819 .test_cases = drm_hdmi_compute_mode_clock_tests, 1820 }; 1821 1822 kunit_test_suites( 1823 &drmm_connector_hdmi_init_test_suite, 1824 &drmm_connector_init_test_suite, 1825 &drm_connector_dynamic_init_test_suite, 1826 &drm_connector_dynamic_register_early_test_suite, 1827 &drm_connector_dynamic_register_test_suite, 1828 &drm_connector_attach_broadcast_rgb_property_test_suite, 1829 &drm_get_tv_mode_from_name_test_suite, 1830 &drm_hdmi_compute_mode_clock_test_suite, 1831 &drm_hdmi_connector_get_broadcast_rgb_name_test_suite, 1832 &drm_hdmi_connector_get_output_format_name_test_suite 1833 ); 1834 1835 MODULE_AUTHOR("Maxime Ripard <maxime@cerno.tech>"); 1836 MODULE_DESCRIPTION("Kunit test for drm_modes functions"); 1837 MODULE_LICENSE("GPL"); 1838