Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
drm/tests: hdmi: check the infoframes behaviour
Verify the InfoFrames behaviour. Check that reporting InfoFrame as
unsupported doesn't result in a commit error. Also check that HDR and
Audio InfoFrames are not triggered if corresponding features are not
enabled.
Acked-by: Maxime Ripard <mripard@kernel.org>
Link: https://patch.msgid.link/20260107-limit-infoframes-2-v4-1-213d0d3bd490@oss.qualcomm.com
Signed-off-by: Dmitry Baryshkov <dmitry.baryshkov@oss.qualcomm.com>
+749
+3
drivers/gpu/drm/tests/drm_client_modeset_test.c
+3
drivers/gpu/drm/tests/drm_client_modeset_test.c
···
5
5
6
6
#include <kunit/test.h>
7
7
8
+
#include <drm/drm_atomic_state_helper.h>
8
9
#include <drm/drm_connector.h>
9
10
#include <drm/drm_edid.h>
10
11
#include <drm/drm_drv.h>
···
49
48
};
50
49
51
50
static const struct drm_connector_funcs drm_client_modeset_connector_funcs = {
51
+
.atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
52
+
.atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state
52
53
};
53
54
54
55
static int drm_client_modeset_test_init(struct kunit *test)
+627
drivers/gpu/drm/tests/drm_hdmi_state_helper_test.c
+627
drivers/gpu/drm/tests/drm_hdmi_state_helper_test.c
···
35
35
36
36
const void *current_edid;
37
37
size_t current_edid_len;
38
+
39
+
int hdmi_update_failures;
38
40
};
39
41
40
42
#define connector_to_priv(c) \
41
43
container_of_const(c, struct drm_atomic_helper_connector_hdmi_priv, connector)
44
+
45
+
#define encoder_to_priv(e) \
46
+
container_of_const(e, struct drm_atomic_helper_connector_hdmi_priv, encoder)
42
47
43
48
static struct drm_display_mode *find_preferred_mode(struct drm_connector *connector)
44
49
{
···
141
136
.atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
142
137
.fill_modes = drm_helper_probe_single_connector_modes,
143
138
.reset = dummy_hdmi_connector_reset,
139
+
};
140
+
141
+
static void test_encoder_atomic_enable(struct drm_encoder *encoder,
142
+
struct drm_atomic_state *state)
143
+
{
144
+
struct drm_atomic_helper_connector_hdmi_priv *priv =
145
+
encoder_to_priv(encoder);
146
+
int ret;
147
+
148
+
ret = drm_atomic_helper_connector_hdmi_update_infoframes(&priv->connector, state);
149
+
if (ret)
150
+
priv->hdmi_update_failures++;
151
+
}
152
+
153
+
static const struct drm_encoder_helper_funcs test_encoder_helper_funcs = {
154
+
.atomic_enable = test_encoder_atomic_enable,
144
155
};
145
156
146
157
static
···
2344
2323
.test_cases = drm_atomic_helper_connector_hdmi_mode_valid_tests,
2345
2324
};
2346
2325
2326
+
/*
2327
+
* Test that the default behaviour works without errors. We expect that
2328
+
* infoframe-related hooks are called and there are no errors raised.
2329
+
*/
2330
+
static void drm_test_check_infoframes(struct kunit *test)
2331
+
{
2332
+
struct drm_atomic_helper_connector_hdmi_priv *priv;
2333
+
struct drm_modeset_acquire_ctx ctx;
2334
+
struct drm_crtc_state *crtc_state;
2335
+
struct drm_atomic_state *state;
2336
+
struct drm_display_mode *preferred;
2337
+
struct drm_connector *conn;
2338
+
struct drm_device *drm;
2339
+
struct drm_crtc *crtc;
2340
+
int old_hdmi_update_failures;
2341
+
int ret;
2342
+
2343
+
priv = drm_kunit_helper_connector_hdmi_init_with_edid_funcs(test,
2344
+
BIT(HDMI_COLORSPACE_RGB),
2345
+
8,
2346
+
&dummy_connector_hdmi_funcs,
2347
+
test_edid_hdmi_1080p_rgb_max_200mhz);
2348
+
KUNIT_ASSERT_NOT_NULL(test, priv);
2349
+
2350
+
drm = &priv->drm;
2351
+
crtc = priv->crtc;
2352
+
conn = &priv->connector;
2353
+
2354
+
preferred = find_preferred_mode(conn);
2355
+
KUNIT_ASSERT_NOT_NULL(test, preferred);
2356
+
2357
+
drm_modeset_acquire_init(&ctx, 0);
2358
+
2359
+
retry_conn_enable:
2360
+
ret = drm_kunit_helper_enable_crtc_connector(test, drm,
2361
+
crtc, conn,
2362
+
preferred,
2363
+
&ctx);
2364
+
if (ret == -EDEADLK) {
2365
+
ret = drm_modeset_backoff(&ctx);
2366
+
if (!ret)
2367
+
goto retry_conn_enable;
2368
+
}
2369
+
KUNIT_ASSERT_EQ(test, ret, 0);
2370
+
2371
+
state = drm_kunit_helper_atomic_state_alloc(test, drm, &ctx);
2372
+
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, state);
2373
+
2374
+
retry_crtc_state:
2375
+
crtc_state = drm_atomic_get_crtc_state(state, crtc);
2376
+
if (PTR_ERR(crtc_state) == -EDEADLK) {
2377
+
drm_atomic_state_clear(state);
2378
+
ret = drm_modeset_backoff(&ctx);
2379
+
if (!ret)
2380
+
goto retry_crtc_state;
2381
+
}
2382
+
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, crtc_state);
2383
+
2384
+
crtc_state->mode_changed = true;
2385
+
2386
+
old_hdmi_update_failures = priv->hdmi_update_failures;
2387
+
2388
+
ret = drm_atomic_check_only(state);
2389
+
if (ret == -EDEADLK) {
2390
+
drm_atomic_state_clear(state);
2391
+
ret = drm_modeset_backoff(&ctx);
2392
+
if (!ret)
2393
+
goto retry_crtc_state;
2394
+
}
2395
+
KUNIT_ASSERT_EQ(test, ret, 0);
2396
+
2397
+
ret = drm_atomic_commit(state);
2398
+
if (ret == -EDEADLK) {
2399
+
drm_atomic_state_clear(state);
2400
+
ret = drm_modeset_backoff(&ctx);
2401
+
if (!ret)
2402
+
goto retry_crtc_state;
2403
+
}
2404
+
KUNIT_ASSERT_EQ(test, ret, 0);
2405
+
2406
+
KUNIT_EXPECT_GE(test, old_hdmi_update_failures, priv->hdmi_update_failures);
2407
+
2408
+
drm_modeset_drop_locks(&ctx);
2409
+
drm_modeset_acquire_fini(&ctx);
2410
+
}
2411
+
2412
+
static int reject_avi_infoframe_write_infoframe(struct drm_connector *connector,
2413
+
enum hdmi_infoframe_type type,
2414
+
const u8 *buffer, size_t len)
2415
+
{
2416
+
if (type == HDMI_INFOFRAME_TYPE_AVI)
2417
+
return -EOPNOTSUPP;
2418
+
2419
+
return 0;
2420
+
}
2421
+
2422
+
static const struct drm_connector_hdmi_funcs reject_avi_infoframe_hdmi_funcs = {
2423
+
.write_infoframe = reject_avi_infoframe_write_infoframe,
2424
+
};
2425
+
2426
+
/*
2427
+
* Test that the rejection of AVI InfoFrame results in the failure of
2428
+
* drm_atomic_helper_connector_hdmi_update_infoframes().
2429
+
*/
2430
+
static void drm_test_check_reject_avi_infoframe(struct kunit *test)
2431
+
{
2432
+
struct drm_atomic_helper_connector_hdmi_priv *priv;
2433
+
struct drm_modeset_acquire_ctx ctx;
2434
+
struct drm_atomic_state *state;
2435
+
struct drm_crtc_state *crtc_state;
2436
+
struct drm_display_mode *preferred;
2437
+
struct drm_connector *conn;
2438
+
struct drm_device *drm;
2439
+
struct drm_crtc *crtc;
2440
+
int old_hdmi_update_failures;
2441
+
int ret;
2442
+
2443
+
priv = drm_kunit_helper_connector_hdmi_init_with_edid_funcs(test,
2444
+
BIT(HDMI_COLORSPACE_RGB),
2445
+
8,
2446
+
&reject_avi_infoframe_hdmi_funcs,
2447
+
test_edid_hdmi_1080p_rgb_max_200mhz);
2448
+
KUNIT_ASSERT_NOT_NULL(test, priv);
2449
+
2450
+
drm = &priv->drm;
2451
+
crtc = priv->crtc;
2452
+
conn = &priv->connector;
2453
+
2454
+
preferred = find_preferred_mode(conn);
2455
+
KUNIT_ASSERT_NOT_NULL(test, preferred);
2456
+
2457
+
drm_modeset_acquire_init(&ctx, 0);
2458
+
2459
+
retry_conn_enable:
2460
+
ret = drm_kunit_helper_enable_crtc_connector(test, drm,
2461
+
crtc, conn,
2462
+
preferred,
2463
+
&ctx);
2464
+
if (ret == -EDEADLK) {
2465
+
ret = drm_modeset_backoff(&ctx);
2466
+
if (!ret)
2467
+
goto retry_conn_enable;
2468
+
}
2469
+
KUNIT_ASSERT_EQ(test, ret, 0);
2470
+
2471
+
drm_encoder_helper_add(&priv->encoder, &test_encoder_helper_funcs);
2472
+
2473
+
state = drm_kunit_helper_atomic_state_alloc(test, drm, &ctx);
2474
+
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, state);
2475
+
2476
+
retry_crtc_state:
2477
+
crtc_state = drm_atomic_get_crtc_state(state, crtc);
2478
+
if (PTR_ERR(crtc_state) == -EDEADLK) {
2479
+
drm_atomic_state_clear(state);
2480
+
ret = drm_modeset_backoff(&ctx);
2481
+
if (!ret)
2482
+
goto retry_crtc_state;
2483
+
}
2484
+
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, crtc_state);
2485
+
2486
+
crtc_state->mode_changed = true;
2487
+
2488
+
old_hdmi_update_failures = priv->hdmi_update_failures;
2489
+
2490
+
ret = drm_atomic_check_only(state);
2491
+
if (ret == -EDEADLK) {
2492
+
drm_atomic_state_clear(state);
2493
+
ret = drm_modeset_backoff(&ctx);
2494
+
if (!ret)
2495
+
goto retry_crtc_state;
2496
+
}
2497
+
KUNIT_ASSERT_EQ(test, ret, 0);
2498
+
2499
+
ret = drm_atomic_commit(state);
2500
+
if (ret == -EDEADLK) {
2501
+
drm_atomic_state_clear(state);
2502
+
ret = drm_modeset_backoff(&ctx);
2503
+
if (!ret)
2504
+
goto retry_crtc_state;
2505
+
}
2506
+
KUNIT_ASSERT_EQ(test, ret, 0);
2507
+
2508
+
KUNIT_EXPECT_NE(test, old_hdmi_update_failures, priv->hdmi_update_failures);
2509
+
2510
+
drm_modeset_drop_locks(&ctx);
2511
+
drm_modeset_acquire_fini(&ctx);
2512
+
}
2513
+
2514
+
static int reject_hdr_infoframe_write_infoframe(struct drm_connector *connector,
2515
+
enum hdmi_infoframe_type type,
2516
+
const u8 *buffer, size_t len)
2517
+
{
2518
+
if (type == HDMI_INFOFRAME_TYPE_DRM)
2519
+
return -EOPNOTSUPP;
2520
+
2521
+
return 0;
2522
+
}
2523
+
2524
+
static const struct drm_connector_hdmi_funcs reject_hdr_infoframe_hdmi_funcs = {
2525
+
.write_infoframe = reject_hdr_infoframe_write_infoframe,
2526
+
};
2527
+
2528
+
/*
2529
+
* Test that the HDR InfoFrame isn't programmed in
2530
+
* drm_atomic_helper_connector_hdmi_update_infoframes() if the max_bpc is 8.
2531
+
*/
2532
+
static void drm_test_check_reject_hdr_infoframe_bpc_8(struct kunit *test)
2533
+
{
2534
+
struct drm_atomic_helper_connector_hdmi_priv *priv;
2535
+
struct drm_modeset_acquire_ctx ctx;
2536
+
struct drm_atomic_state *state;
2537
+
struct drm_connector_state *new_conn_state;
2538
+
struct drm_crtc_state *crtc_state;
2539
+
struct drm_display_mode *preferred;
2540
+
struct drm_connector *conn;
2541
+
struct drm_device *drm;
2542
+
struct drm_crtc *crtc;
2543
+
int old_hdmi_update_failures;
2544
+
int ret;
2545
+
2546
+
priv = drm_kunit_helper_connector_hdmi_init_with_edid_funcs(test,
2547
+
BIT(HDMI_COLORSPACE_RGB),
2548
+
8,
2549
+
&reject_hdr_infoframe_hdmi_funcs,
2550
+
test_edid_hdmi_1080p_rgb_max_200mhz_hdr);
2551
+
KUNIT_ASSERT_NOT_NULL(test, priv);
2552
+
2553
+
drm = &priv->drm;
2554
+
crtc = priv->crtc;
2555
+
conn = &priv->connector;
2556
+
2557
+
preferred = find_preferred_mode(conn);
2558
+
KUNIT_ASSERT_NOT_NULL(test, preferred);
2559
+
2560
+
drm_modeset_acquire_init(&ctx, 0);
2561
+
2562
+
retry_conn_enable:
2563
+
ret = drm_kunit_helper_enable_crtc_connector(test, drm,
2564
+
crtc, conn,
2565
+
preferred,
2566
+
&ctx);
2567
+
if (ret == -EDEADLK) {
2568
+
ret = drm_modeset_backoff(&ctx);
2569
+
if (!ret)
2570
+
goto retry_conn_enable;
2571
+
}
2572
+
KUNIT_ASSERT_EQ(test, ret, 0);
2573
+
2574
+
drm_encoder_helper_add(&priv->encoder, &test_encoder_helper_funcs);
2575
+
2576
+
state = drm_kunit_helper_atomic_state_alloc(test, drm, &ctx);
2577
+
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, state);
2578
+
2579
+
retry_conn_state:
2580
+
new_conn_state = drm_atomic_get_connector_state(state, conn);
2581
+
if (PTR_ERR(new_conn_state) == -EDEADLK) {
2582
+
drm_atomic_state_clear(state);
2583
+
ret = drm_modeset_backoff(&ctx);
2584
+
if (!ret)
2585
+
goto retry_conn_state;
2586
+
}
2587
+
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, new_conn_state);
2588
+
2589
+
crtc_state = drm_atomic_get_crtc_state(state, crtc);
2590
+
if (PTR_ERR(crtc_state) == -EDEADLK) {
2591
+
drm_atomic_state_clear(state);
2592
+
ret = drm_modeset_backoff(&ctx);
2593
+
if (!ret)
2594
+
goto retry_conn_state;
2595
+
}
2596
+
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, crtc_state);
2597
+
2598
+
/* Verify that there is no HDR property, so "userspace" can't set it. */
2599
+
for (int i = 0; i < conn->base.properties->count; i++)
2600
+
KUNIT_ASSERT_PTR_NE(test,
2601
+
drm->mode_config.hdr_output_metadata_property,
2602
+
conn->base.properties->properties[i]);
2603
+
2604
+
crtc_state->mode_changed = true;
2605
+
2606
+
old_hdmi_update_failures = priv->hdmi_update_failures;
2607
+
2608
+
ret = drm_atomic_check_only(state);
2609
+
if (ret == -EDEADLK) {
2610
+
drm_atomic_state_clear(state);
2611
+
ret = drm_modeset_backoff(&ctx);
2612
+
if (!ret)
2613
+
goto retry_conn_state;
2614
+
}
2615
+
KUNIT_ASSERT_EQ(test, ret, 0);
2616
+
2617
+
ret = drm_atomic_commit(state);
2618
+
if (ret == -EDEADLK) {
2619
+
drm_atomic_state_clear(state);
2620
+
ret = drm_modeset_backoff(&ctx);
2621
+
if (!ret)
2622
+
goto retry_conn_state;
2623
+
}
2624
+
KUNIT_ASSERT_EQ(test, ret, 0);
2625
+
2626
+
KUNIT_EXPECT_EQ(test, old_hdmi_update_failures, priv->hdmi_update_failures);
2627
+
2628
+
new_conn_state = conn->state;
2629
+
KUNIT_ASSERT_NOT_NULL(test, new_conn_state);
2630
+
2631
+
KUNIT_ASSERT_EQ(test, new_conn_state->hdmi.output_bpc, 8);
2632
+
KUNIT_ASSERT_EQ(test, new_conn_state->hdmi.infoframes.hdr_drm.set, false);
2633
+
2634
+
drm_modeset_drop_locks(&ctx);
2635
+
drm_modeset_acquire_fini(&ctx);
2636
+
}
2637
+
2638
+
/*
2639
+
* Test that the rejection of HDR InfoFrame results in the failure of
2640
+
* drm_atomic_helper_connector_hdmi_update_infoframes() in the high bpc is
2641
+
* supported.
2642
+
*/
2643
+
static void drm_test_check_reject_hdr_infoframe_bpc_10(struct kunit *test)
2644
+
{
2645
+
struct drm_atomic_helper_connector_hdmi_priv *priv;
2646
+
struct drm_modeset_acquire_ctx ctx;
2647
+
struct drm_atomic_state *state;
2648
+
struct drm_connector_state *new_conn_state;
2649
+
struct drm_crtc_state *crtc_state;
2650
+
struct drm_display_mode *preferred;
2651
+
struct drm_connector *conn;
2652
+
struct drm_device *drm;
2653
+
struct drm_crtc *crtc;
2654
+
int old_hdmi_update_failures;
2655
+
struct hdr_output_metadata hdr_data;
2656
+
struct drm_property_blob *hdr_blob;
2657
+
bool replaced;
2658
+
int ret;
2659
+
2660
+
priv = drm_kunit_helper_connector_hdmi_init_with_edid_funcs(test,
2661
+
BIT(HDMI_COLORSPACE_RGB),
2662
+
10,
2663
+
&reject_hdr_infoframe_hdmi_funcs,
2664
+
test_edid_hdmi_1080p_rgb_max_200mhz_hdr);
2665
+
KUNIT_ASSERT_NOT_NULL(test, priv);
2666
+
2667
+
drm = &priv->drm;
2668
+
crtc = priv->crtc;
2669
+
conn = &priv->connector;
2670
+
2671
+
preferred = find_preferred_mode(conn);
2672
+
KUNIT_ASSERT_NOT_NULL(test, preferred);
2673
+
2674
+
drm_modeset_acquire_init(&ctx, 0);
2675
+
2676
+
retry_conn_enable:
2677
+
ret = drm_kunit_helper_enable_crtc_connector(test, drm,
2678
+
crtc, conn,
2679
+
preferred,
2680
+
&ctx);
2681
+
if (ret == -EDEADLK) {
2682
+
ret = drm_modeset_backoff(&ctx);
2683
+
if (!ret)
2684
+
goto retry_conn_enable;
2685
+
}
2686
+
KUNIT_ASSERT_EQ(test, ret, 0);
2687
+
2688
+
drm_encoder_helper_add(&priv->encoder, &test_encoder_helper_funcs);
2689
+
2690
+
state = drm_kunit_helper_atomic_state_alloc(test, drm, &ctx);
2691
+
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, state);
2692
+
2693
+
retry_conn_state:
2694
+
new_conn_state = drm_atomic_get_connector_state(state, conn);
2695
+
if (PTR_ERR(new_conn_state) == -EDEADLK) {
2696
+
drm_atomic_state_clear(state);
2697
+
ret = drm_modeset_backoff(&ctx);
2698
+
if (!ret)
2699
+
goto retry_conn_state;
2700
+
}
2701
+
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, new_conn_state);
2702
+
2703
+
crtc_state = drm_atomic_get_crtc_state(state, crtc);
2704
+
if (PTR_ERR(crtc_state) == -EDEADLK) {
2705
+
drm_atomic_state_clear(state);
2706
+
ret = drm_modeset_backoff(&ctx);
2707
+
if (!ret)
2708
+
goto retry_conn_state;
2709
+
}
2710
+
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, crtc_state);
2711
+
2712
+
hdr_data.metadata_type = HDMI_STATIC_METADATA_TYPE1;
2713
+
hdr_data.hdmi_metadata_type1.eotf = HDMI_EOTF_TRADITIONAL_GAMMA_SDR;
2714
+
hdr_data.hdmi_metadata_type1.metadata_type = HDMI_STATIC_METADATA_TYPE1;
2715
+
2716
+
hdr_blob = drm_property_create_blob(drm, sizeof(hdr_data), &hdr_data);
2717
+
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, hdr_blob);
2718
+
2719
+
ret = drm_property_replace_blob_from_id(drm,
2720
+
&new_conn_state->hdr_output_metadata,
2721
+
hdr_blob->base.id,
2722
+
sizeof(struct hdr_output_metadata), -1,
2723
+
&replaced);
2724
+
KUNIT_ASSERT_EQ(test, ret, 0);
2725
+
KUNIT_ASSERT_EQ(test, replaced, true);
2726
+
2727
+
crtc_state->mode_changed = true;
2728
+
2729
+
old_hdmi_update_failures = priv->hdmi_update_failures;
2730
+
2731
+
ret = drm_atomic_check_only(state);
2732
+
if (ret == -EDEADLK) {
2733
+
drm_atomic_state_clear(state);
2734
+
ret = drm_modeset_backoff(&ctx);
2735
+
if (!ret)
2736
+
goto retry_conn_state;
2737
+
}
2738
+
KUNIT_ASSERT_EQ(test, ret, 0);
2739
+
2740
+
ret = drm_atomic_commit(state);
2741
+
if (ret == -EDEADLK) {
2742
+
drm_atomic_state_clear(state);
2743
+
ret = drm_modeset_backoff(&ctx);
2744
+
if (!ret)
2745
+
goto retry_conn_state;
2746
+
}
2747
+
KUNIT_ASSERT_EQ(test, ret, 0);
2748
+
2749
+
KUNIT_EXPECT_LE(test, old_hdmi_update_failures, priv->hdmi_update_failures);
2750
+
2751
+
new_conn_state = conn->state;
2752
+
KUNIT_ASSERT_NOT_NULL(test, new_conn_state);
2753
+
2754
+
KUNIT_ASSERT_EQ(test, new_conn_state->hdmi.output_bpc, 10);
2755
+
KUNIT_ASSERT_EQ(test, new_conn_state->hdmi.infoframes.hdr_drm.set, true);
2756
+
2757
+
drm_modeset_drop_locks(&ctx);
2758
+
drm_modeset_acquire_fini(&ctx);
2759
+
}
2760
+
2761
+
static int reject_audio_infoframe_write_infoframe(struct drm_connector *connector,
2762
+
enum hdmi_infoframe_type type,
2763
+
const u8 *buffer, size_t len)
2764
+
{
2765
+
if (type == HDMI_INFOFRAME_TYPE_AUDIO)
2766
+
return -EOPNOTSUPP;
2767
+
2768
+
return 0;
2769
+
}
2770
+
2771
+
static const struct drm_connector_hdmi_funcs reject_audio_infoframe_hdmi_funcs = {
2772
+
.write_infoframe = reject_audio_infoframe_write_infoframe,
2773
+
};
2774
+
2775
+
/*
2776
+
* Test that Audio InfoFrame is only programmed if we call a corresponding API,
2777
+
* thus the drivers can safely assume that they won't get Audio InfoFrames if
2778
+
* they don't call it.
2779
+
*/
2780
+
static void drm_test_check_reject_audio_infoframe(struct kunit *test)
2781
+
{
2782
+
struct drm_atomic_helper_connector_hdmi_priv *priv;
2783
+
struct drm_modeset_acquire_ctx ctx;
2784
+
struct drm_atomic_state *state;
2785
+
struct drm_crtc_state *crtc_state;
2786
+
struct drm_display_mode *preferred;
2787
+
struct drm_connector *conn;
2788
+
struct drm_device *drm;
2789
+
struct drm_crtc *crtc;
2790
+
int old_hdmi_update_failures;
2791
+
struct hdmi_audio_infoframe cea;
2792
+
int ret;
2793
+
2794
+
priv = drm_kunit_helper_connector_hdmi_init_with_edid_funcs(test,
2795
+
BIT(HDMI_COLORSPACE_RGB),
2796
+
8,
2797
+
&reject_audio_infoframe_hdmi_funcs,
2798
+
test_edid_hdmi_1080p_rgb_max_200mhz);
2799
+
KUNIT_ASSERT_NOT_NULL(test, priv);
2800
+
2801
+
drm = &priv->drm;
2802
+
crtc = priv->crtc;
2803
+
conn = &priv->connector;
2804
+
2805
+
preferred = find_preferred_mode(conn);
2806
+
KUNIT_ASSERT_NOT_NULL(test, preferred);
2807
+
2808
+
drm_modeset_acquire_init(&ctx, 0);
2809
+
2810
+
retry_conn_enable:
2811
+
ret = drm_kunit_helper_enable_crtc_connector(test, drm,
2812
+
crtc, conn,
2813
+
preferred,
2814
+
&ctx);
2815
+
if (ret == -EDEADLK) {
2816
+
ret = drm_modeset_backoff(&ctx);
2817
+
if (!ret)
2818
+
goto retry_conn_enable;
2819
+
}
2820
+
KUNIT_ASSERT_EQ(test, ret, 0);
2821
+
2822
+
drm_encoder_helper_add(&priv->encoder, &test_encoder_helper_funcs);
2823
+
2824
+
state = drm_kunit_helper_atomic_state_alloc(test, drm, &ctx);
2825
+
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, state);
2826
+
2827
+
retry_crtc_state:
2828
+
crtc_state = drm_atomic_get_crtc_state(state, crtc);
2829
+
if (PTR_ERR(crtc_state) == -EDEADLK) {
2830
+
drm_atomic_state_clear(state);
2831
+
ret = drm_modeset_backoff(&ctx);
2832
+
if (!ret)
2833
+
goto retry_crtc_state;
2834
+
}
2835
+
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, crtc_state);
2836
+
2837
+
crtc_state->mode_changed = true;
2838
+
2839
+
old_hdmi_update_failures = priv->hdmi_update_failures;
2840
+
2841
+
ret = drm_atomic_check_only(state);
2842
+
if (ret == -EDEADLK) {
2843
+
drm_atomic_state_clear(state);
2844
+
ret = drm_modeset_backoff(&ctx);
2845
+
if (!ret)
2846
+
goto retry_crtc_state;
2847
+
}
2848
+
KUNIT_ASSERT_EQ(test, ret, 0);
2849
+
2850
+
ret = drm_atomic_commit(state);
2851
+
if (ret == -EDEADLK) {
2852
+
drm_atomic_state_clear(state);
2853
+
ret = drm_modeset_backoff(&ctx);
2854
+
if (!ret)
2855
+
goto retry_crtc_state;
2856
+
}
2857
+
KUNIT_ASSERT_EQ(test, ret, 0);
2858
+
2859
+
KUNIT_EXPECT_EQ(test, old_hdmi_update_failures, priv->hdmi_update_failures);
2860
+
2861
+
/*
2862
+
* So, it works without Audio InfoFrame, let's fail with it in place,
2863
+
* checking that writing the infofraem actually gets triggered.
2864
+
*/
2865
+
2866
+
hdmi_audio_infoframe_init(&cea);
2867
+
cea.channels = 2;
2868
+
cea.coding_type = HDMI_AUDIO_CODING_TYPE_STREAM;
2869
+
cea.sample_size = HDMI_AUDIO_SAMPLE_SIZE_STREAM;
2870
+
cea.sample_frequency = HDMI_AUDIO_SAMPLE_FREQUENCY_STREAM;
2871
+
2872
+
ret = drm_atomic_helper_connector_hdmi_update_audio_infoframe(conn, &cea);
2873
+
KUNIT_ASSERT_EQ(test, ret, -EOPNOTSUPP);
2874
+
2875
+
state = drm_kunit_helper_atomic_state_alloc(test, drm, &ctx);
2876
+
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, state);
2877
+
2878
+
retry_crtc_state_2:
2879
+
crtc_state = drm_atomic_get_crtc_state(state, crtc);
2880
+
if (PTR_ERR(crtc_state) == -EDEADLK) {
2881
+
drm_atomic_state_clear(state);
2882
+
ret = drm_modeset_backoff(&ctx);
2883
+
if (!ret)
2884
+
goto retry_crtc_state_2;
2885
+
}
2886
+
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, crtc_state);
2887
+
2888
+
crtc_state->mode_changed = true;
2889
+
2890
+
old_hdmi_update_failures = priv->hdmi_update_failures;
2891
+
2892
+
ret = drm_atomic_check_only(state);
2893
+
if (ret == -EDEADLK) {
2894
+
drm_atomic_state_clear(state);
2895
+
ret = drm_modeset_backoff(&ctx);
2896
+
if (!ret)
2897
+
goto retry_crtc_state_2;
2898
+
}
2899
+
KUNIT_ASSERT_EQ(test, ret, 0);
2900
+
2901
+
ret = drm_atomic_commit(state);
2902
+
if (ret == -EDEADLK) {
2903
+
drm_atomic_state_clear(state);
2904
+
ret = drm_modeset_backoff(&ctx);
2905
+
if (!ret)
2906
+
goto retry_crtc_state_2;
2907
+
}
2908
+
KUNIT_ASSERT_EQ(test, ret, 0);
2909
+
2910
+
KUNIT_EXPECT_LE(test, old_hdmi_update_failures, priv->hdmi_update_failures);
2911
+
2912
+
drm_modeset_drop_locks(&ctx);
2913
+
drm_modeset_acquire_fini(&ctx);
2914
+
}
2915
+
2916
+
2917
+
static struct kunit_case drm_atomic_helper_connector_hdmi_infoframes_tests[] = {
2918
+
KUNIT_CASE(drm_test_check_infoframes),
2919
+
KUNIT_CASE(drm_test_check_reject_avi_infoframe),
2920
+
KUNIT_CASE(drm_test_check_reject_hdr_infoframe_bpc_8),
2921
+
KUNIT_CASE(drm_test_check_reject_hdr_infoframe_bpc_10),
2922
+
KUNIT_CASE(drm_test_check_reject_audio_infoframe),
2923
+
{ }
2924
+
};
2925
+
2926
+
static struct kunit_suite drm_atomic_helper_connector_hdmi_infoframes_test_suite = {
2927
+
.name = "drm_atomic_helper_connector_hdmi_infoframes",
2928
+
.test_cases = drm_atomic_helper_connector_hdmi_infoframes_tests,
2929
+
};
2930
+
2347
2931
kunit_test_suites(
2348
2932
&drm_atomic_helper_connector_hdmi_check_test_suite,
2349
2933
&drm_atomic_helper_connector_hdmi_reset_test_suite,
2350
2934
&drm_atomic_helper_connector_hdmi_mode_valid_test_suite,
2935
+
&drm_atomic_helper_connector_hdmi_infoframes_test_suite,
2351
2936
);
2352
2937
2353
2938
MODULE_AUTHOR("Maxime Ripard <mripard@kernel.org>");
+119
drivers/gpu/drm/tests/drm_kunit_edid.h
+119
drivers/gpu/drm/tests/drm_kunit_edid.h
···
305
305
* 46 1e 46 0f 00 0a 20 20 20 20 20 20 00 00 00 10
306
306
* 00 00 00 00 00 00 00 00 00 00 00 00 00 00 01 92
307
307
*
308
+
* 02 03 1c 81 e3 05 c0 20 41 10 e2 00 4a 67 03 0c
309
+
* 00 12 34 00 28 e6 06 05 01 52 52 51 00 00 00 00
310
+
* 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
311
+
* 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
312
+
* 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
313
+
* 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
314
+
* 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
315
+
* 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 4e
316
+
*
317
+
* ----------------
318
+
*
319
+
* Block 0, Base EDID:
320
+
* EDID Structure Version & Revision: 1.3
321
+
* Vendor & Product Identification:
322
+
* Manufacturer: LNX
323
+
* Model: 42
324
+
* Made in: 2023
325
+
* Basic Display Parameters & Features:
326
+
* Digital display
327
+
* DFP 1.x compatible TMDS
328
+
* Maximum image size: 160 cm x 90 cm
329
+
* Gamma: 2.20
330
+
* Monochrome or grayscale display
331
+
* First detailed timing is the preferred timing
332
+
* Color Characteristics:
333
+
* Red : 0.0000, 0.0000
334
+
* Green: 0.0000, 0.0000
335
+
* Blue : 0.0000, 0.0000
336
+
* White: 0.0000, 0.0000
337
+
* Established Timings I & II:
338
+
* DMT 0x04: 640x480 59.940476 Hz 4:3 31.469 kHz 25.175000 MHz
339
+
* Standard Timings: none
340
+
* Detailed Timing Descriptors:
341
+
* DTD 1: 1920x1080 60.000000 Hz 16:9 67.500 kHz 148.500000 MHz (1600 mm x 900 mm)
342
+
* Hfront 88 Hsync 44 Hback 148 Hpol P
343
+
* Vfront 4 Vsync 5 Vback 36 Vpol P
344
+
* Display Product Name: 'Test EDID'
345
+
* Display Range Limits:
346
+
* Monitor ranges (GTF): 50-70 Hz V, 30-70 kHz H, max dotclock 150 MHz
347
+
* Dummy Descriptor:
348
+
* Extension blocks: 1
349
+
* Checksum: 0x92
350
+
*
351
+
* ----------------
352
+
*
353
+
* Block 1, CTA-861 Extension Block:
354
+
* Revision: 3
355
+
* Underscans IT Video Formats by default
356
+
* Native detailed modes: 1
357
+
* Colorimetry Data Block:
358
+
* BT2020YCC
359
+
* BT2020RGB
360
+
* sRGB
361
+
* Video Data Block:
362
+
* VIC 16: 1920x1080 60.000000 Hz 16:9 67.500 kHz 148.500000 MHz
363
+
* Video Capability Data Block:
364
+
* YCbCr quantization: No Data
365
+
* RGB quantization: Selectable (via AVI Q)
366
+
* PT scan behavior: No Data
367
+
* IT scan behavior: Always Underscanned
368
+
* CE scan behavior: Always Underscanned
369
+
* Vendor-Specific Data Block (HDMI), OUI 00-0C-03:
370
+
* Source physical address: 1.2.3.4
371
+
* Maximum TMDS clock: 200 MHz
372
+
* HDR Static Metadata Data Block:
373
+
* Electro optical transfer functions:
374
+
* Traditional gamma - SDR luminance range
375
+
* SMPTE ST2084
376
+
* Supported static metadata descriptors:
377
+
* Static metadata type 1
378
+
* Desired content max luminance: 82 (295.365 cd/m^2)
379
+
* Desired content max frame-average luminance: 82 (295.365 cd/m^2)
380
+
* Desired content min luminance: 81 (0.298 cd/m^2)
381
+
* Checksum: 0x4e Unused space in Extension Block: 99 bytes
382
+
*
383
+
* ----------------
384
+
*
385
+
* edid-decode 1.31.0-5387
386
+
* edid-decode SHA: 5508bc4301ac 2025-08-25 08:14:22
387
+
*
388
+
* EDID conformity: PASS
389
+
*/
390
+
static const unsigned char test_edid_hdmi_1080p_rgb_max_200mhz_hdr[] = {
391
+
0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x31, 0xd8, 0x2a, 0x00,
392
+
0x00, 0x00, 0x00, 0x00, 0x00, 0x21, 0x01, 0x03, 0x81, 0xa0, 0x5a, 0x78,
393
+
0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20,
394
+
0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
395
+
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x3a, 0x80, 0x18, 0x71, 0x38,
396
+
0x2d, 0x40, 0x58, 0x2c, 0x45, 0x00, 0x40, 0x84, 0x63, 0x00, 0x00, 0x1e,
397
+
0x00, 0x00, 0x00, 0xfc, 0x00, 0x54, 0x65, 0x73, 0x74, 0x20, 0x45, 0x44,
398
+
0x49, 0x44, 0x0a, 0x20, 0x20, 0x20, 0x00, 0x00, 0x00, 0xfd, 0x00, 0x32,
399
+
0x46, 0x1e, 0x46, 0x0f, 0x00, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
400
+
0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
401
+
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x92, 0x02, 0x03, 0x1c, 0x81,
402
+
0xe3, 0x05, 0xc0, 0x20, 0x41, 0x10, 0xe2, 0x00, 0x4a, 0x67, 0x03, 0x0c,
403
+
0x00, 0x12, 0x34, 0x78, 0x28, 0xe6, 0x06, 0x05, 0x01, 0x52, 0x52, 0x51,
404
+
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
405
+
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
406
+
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
407
+
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
408
+
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
409
+
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
410
+
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
411
+
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
412
+
0x00, 0x00, 0x00, 0xd6,
413
+
};
414
+
415
+
/*
416
+
* edid-decode (hex):
417
+
*
418
+
* 00 ff ff ff ff ff ff 00 31 d8 2a 00 00 00 00 00
419
+
* 00 21 01 03 81 a0 5a 78 02 00 00 00 00 00 00 00
420
+
* 00 00 00 20 00 00 01 01 01 01 01 01 01 01 01 01
421
+
* 01 01 01 01 01 01 02 3a 80 18 71 38 2d 40 58 2c
422
+
* 45 00 40 84 63 00 00 1e 00 00 00 fc 00 54 65 73
423
+
* 74 20 45 44 49 44 0a 20 20 20 00 00 00 fd 00 32
424
+
* 46 1e 46 0f 00 0a 20 20 20 20 20 20 00 00 00 10
425
+
* 00 00 00 00 00 00 00 00 00 00 00 00 00 00 01 92
426
+
*
308
427
* 02 03 15 81 e3 05 00 20 41 10 e2 00 4a 67 03 0c
309
428
* 00 12 34 00 44 00 00 00 00 00 00 00 00 00 00 00
310
429
* 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00