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