drm/tests: Drop drm_kunit_helper_acquire_ctx_alloc()

+14 -10

drivers/gpu/drm/tests/drm_atomic_state_test.c

··· 189 189 static void drm_test_check_connector_changed_modeset(struct kunit *test) 190 190 { 191 191 struct drm_atomic_test_priv *priv; 192 - struct drm_modeset_acquire_ctx *ctx; 192 + struct drm_modeset_acquire_ctx ctx; 193 193 struct drm_connector *old_conn, *new_conn; 194 194 struct drm_atomic_state *state; 195 195 struct drm_device *drm; ··· 203 203 old_conn = &priv->connectors[0]; 204 204 new_conn = &priv->connectors[1]; 205 205 206 - ctx = drm_kunit_helper_acquire_ctx_alloc(test); 207 - KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx); 206 + drm_modeset_acquire_init(&ctx, 0); 208 207 209 208 // first modeset to enable 210 - ret = set_up_atomic_state(test, priv, old_conn, ctx); 209 + ret = set_up_atomic_state(test, priv, old_conn, &ctx); 211 210 KUNIT_ASSERT_EQ(test, ret, 0); 212 211 213 - state = drm_kunit_helper_atomic_state_alloc(test, drm, ctx); 212 + state = drm_kunit_helper_atomic_state_alloc(test, drm, &ctx); 214 213 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, state); 215 214 216 215 new_conn_state = drm_atomic_get_connector_state(state, new_conn); ··· 230 231 ret = drm_atomic_commit(state); 231 232 KUNIT_ASSERT_EQ(test, ret, 0); 232 233 KUNIT_ASSERT_EQ(test, modeset_counter, initial_modeset_count + 1); 234 + 235 + drm_modeset_drop_locks(&ctx); 236 + drm_modeset_acquire_fini(&ctx); 233 237 } 234 238 235 239 /* ··· 265 263 int ret; 266 264 const struct drm_clone_mode_test *param = test->param_value; 267 265 struct drm_atomic_test_priv *priv; 268 - struct drm_modeset_acquire_ctx *ctx; 266 + struct drm_modeset_acquire_ctx ctx; 269 267 struct drm_device *drm; 270 268 struct drm_atomic_state *state; 271 269 struct drm_crtc_state *crtc_state; ··· 275 273 276 274 drm = &priv->drm; 277 275 278 - ctx = drm_kunit_helper_acquire_ctx_alloc(test); 279 - KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx); 276 + drm_modeset_acquire_init(&ctx, 0); 280 277 281 - ret = set_up_atomic_state(test, priv, NULL, ctx); 278 + ret = set_up_atomic_state(test, priv, NULL, &ctx); 282 279 KUNIT_ASSERT_EQ(test, ret, 0); 283 280 284 - state = drm_kunit_helper_atomic_state_alloc(test, drm, ctx); 281 + state = drm_kunit_helper_atomic_state_alloc(test, drm, &ctx); 285 282 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, state); 286 283 287 284 crtc_state = drm_atomic_get_crtc_state(state, priv->crtc); ··· 293 292 294 293 ret = drm_atomic_helper_check_modeset(drm, state); 295 294 KUNIT_ASSERT_EQ(test, ret, param->expected_result); 295 + 296 + drm_modeset_drop_locks(&ctx); 297 + drm_modeset_acquire_fini(&ctx); 296 298 } 297 299 298 300 static void drm_check_in_clone_mode_desc(const struct drm_clone_mode_test *t,

+150 -104

drivers/gpu/drm/tests/drm_hdmi_state_helper_test.c

··· 273 273 static void drm_test_check_broadcast_rgb_crtc_mode_changed(struct kunit *test) 274 274 { 275 275 struct drm_atomic_helper_connector_hdmi_priv *priv; 276 - struct drm_modeset_acquire_ctx *ctx; 276 + struct drm_modeset_acquire_ctx ctx; 277 277 struct drm_connector_state *old_conn_state; 278 278 struct drm_connector_state *new_conn_state; 279 279 struct drm_crtc_state *crtc_state; ··· 296 296 preferred = find_preferred_mode(conn); 297 297 KUNIT_ASSERT_NOT_NULL(test, preferred); 298 298 299 - ctx = drm_kunit_helper_acquire_ctx_alloc(test); 300 - KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx); 299 + drm_modeset_acquire_init(&ctx, 0); 301 300 302 - ret = light_up_connector(test, drm, crtc, conn, preferred, ctx); 301 + ret = light_up_connector(test, drm, crtc, conn, preferred, &ctx); 303 302 KUNIT_ASSERT_EQ(test, ret, 0); 304 303 305 - state = drm_kunit_helper_atomic_state_alloc(test, drm, ctx); 304 + state = drm_kunit_helper_atomic_state_alloc(test, drm, &ctx); 306 305 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, state); 307 306 308 307 new_conn_state = drm_atomic_get_connector_state(state, conn); ··· 326 327 crtc_state = drm_atomic_get_new_crtc_state(state, crtc); 327 328 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, crtc_state); 328 329 KUNIT_EXPECT_TRUE(test, crtc_state->mode_changed); 330 + 331 + drm_modeset_drop_locks(&ctx); 332 + drm_modeset_acquire_fini(&ctx); 329 333 } 330 334 331 335 /* ··· 339 337 static void drm_test_check_broadcast_rgb_crtc_mode_not_changed(struct kunit *test) 340 338 { 341 339 struct drm_atomic_helper_connector_hdmi_priv *priv; 342 - struct drm_modeset_acquire_ctx *ctx; 340 + struct drm_modeset_acquire_ctx ctx; 343 341 struct drm_connector_state *old_conn_state; 344 342 struct drm_connector_state *new_conn_state; 345 343 struct drm_crtc_state *crtc_state; ··· 362 360 preferred = find_preferred_mode(conn); 363 361 KUNIT_ASSERT_NOT_NULL(test, preferred); 364 362 365 - ctx = drm_kunit_helper_acquire_ctx_alloc(test); 366 - KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx); 363 + drm_modeset_acquire_init(&ctx, 0); 367 364 368 - ret = light_up_connector(test, drm, crtc, conn, preferred, ctx); 365 + ret = light_up_connector(test, drm, crtc, conn, preferred, &ctx); 369 366 KUNIT_ASSERT_EQ(test, ret, 0); 370 367 371 - state = drm_kunit_helper_atomic_state_alloc(test, drm, ctx); 368 + state = drm_kunit_helper_atomic_state_alloc(test, drm, &ctx); 372 369 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, state); 373 370 374 371 new_conn_state = drm_atomic_get_connector_state(state, conn); ··· 394 393 crtc_state = drm_atomic_get_new_crtc_state(state, crtc); 395 394 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, crtc_state); 396 395 KUNIT_EXPECT_FALSE(test, crtc_state->mode_changed); 396 + 397 + drm_modeset_drop_locks(&ctx); 398 + drm_modeset_acquire_fini(&ctx); 397 399 } 398 400 399 401 /* ··· 407 403 static void drm_test_check_broadcast_rgb_auto_cea_mode(struct kunit *test) 408 404 { 409 405 struct drm_atomic_helper_connector_hdmi_priv *priv; 410 - struct drm_modeset_acquire_ctx *ctx; 406 + struct drm_modeset_acquire_ctx ctx; 411 407 struct drm_connector_state *conn_state; 412 408 struct drm_atomic_state *state; 413 409 struct drm_display_mode *preferred; ··· 430 426 KUNIT_ASSERT_NOT_NULL(test, preferred); 431 427 KUNIT_ASSERT_NE(test, drm_match_cea_mode(preferred), 1); 432 428 433 - ctx = drm_kunit_helper_acquire_ctx_alloc(test); 434 - KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx); 429 + drm_modeset_acquire_init(&ctx, 0); 435 430 436 - ret = light_up_connector(test, drm, crtc, conn, preferred, ctx); 431 + ret = light_up_connector(test, drm, crtc, conn, preferred, &ctx); 437 432 KUNIT_ASSERT_EQ(test, ret, 0); 438 433 439 - state = drm_kunit_helper_atomic_state_alloc(test, drm, ctx); 434 + state = drm_kunit_helper_atomic_state_alloc(test, drm, &ctx); 440 435 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, state); 441 436 442 437 conn_state = drm_atomic_get_connector_state(state, conn); ··· 452 449 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, conn_state); 453 450 454 451 KUNIT_EXPECT_TRUE(test, conn_state->hdmi.is_limited_range); 452 + 453 + drm_modeset_drop_locks(&ctx); 454 + drm_modeset_acquire_fini(&ctx); 455 455 } 456 456 457 457 /* ··· 465 459 static void drm_test_check_broadcast_rgb_auto_cea_mode_vic_1(struct kunit *test) 466 460 { 467 461 struct drm_atomic_helper_connector_hdmi_priv *priv; 468 - struct drm_modeset_acquire_ctx *ctx; 462 + struct drm_modeset_acquire_ctx ctx; 469 463 struct drm_connector_state *conn_state; 470 464 struct drm_atomic_state *state; 471 465 struct drm_display_mode *mode; ··· 483 477 conn = &priv->connector; 484 478 KUNIT_ASSERT_TRUE(test, conn->display_info.is_hdmi); 485 479 486 - ctx = drm_kunit_helper_acquire_ctx_alloc(test); 487 - KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx); 480 + drm_modeset_acquire_init(&ctx, 0); 488 481 489 482 mode = drm_kunit_display_mode_from_cea_vic(test, drm, 1); 490 483 KUNIT_ASSERT_NOT_NULL(test, mode); 491 484 492 485 crtc = priv->crtc; 493 - ret = light_up_connector(test, drm, crtc, conn, mode, ctx); 486 + ret = light_up_connector(test, drm, crtc, conn, mode, &ctx); 494 487 KUNIT_ASSERT_EQ(test, ret, 0); 495 488 496 - state = drm_kunit_helper_atomic_state_alloc(test, drm, ctx); 489 + state = drm_kunit_helper_atomic_state_alloc(test, drm, &ctx); 497 490 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, state); 498 491 499 492 conn_state = drm_atomic_get_connector_state(state, conn); ··· 509 504 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, conn_state); 510 505 511 506 KUNIT_EXPECT_FALSE(test, conn_state->hdmi.is_limited_range); 507 + 508 + drm_modeset_drop_locks(&ctx); 509 + drm_modeset_acquire_fini(&ctx); 512 510 } 513 511 514 512 /* ··· 522 514 static void drm_test_check_broadcast_rgb_full_cea_mode(struct kunit *test) 523 515 { 524 516 struct drm_atomic_helper_connector_hdmi_priv *priv; 525 - struct drm_modeset_acquire_ctx *ctx; 517 + struct drm_modeset_acquire_ctx ctx; 526 518 struct drm_connector_state *conn_state; 527 519 struct drm_atomic_state *state; 528 520 struct drm_display_mode *preferred; ··· 545 537 KUNIT_ASSERT_NOT_NULL(test, preferred); 546 538 KUNIT_ASSERT_NE(test, drm_match_cea_mode(preferred), 1); 547 539 548 - ctx = drm_kunit_helper_acquire_ctx_alloc(test); 549 - KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx); 540 + drm_modeset_acquire_init(&ctx, 0); 550 541 551 - ret = light_up_connector(test, drm, crtc, conn, preferred, ctx); 542 + ret = light_up_connector(test, drm, crtc, conn, preferred, &ctx); 552 543 KUNIT_ASSERT_EQ(test, ret, 0); 553 544 554 - state = drm_kunit_helper_atomic_state_alloc(test, drm, ctx); 545 + state = drm_kunit_helper_atomic_state_alloc(test, drm, &ctx); 555 546 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, state); 556 547 557 548 conn_state = drm_atomic_get_connector_state(state, conn); ··· 569 562 DRM_HDMI_BROADCAST_RGB_FULL); 570 563 571 564 KUNIT_EXPECT_FALSE(test, conn_state->hdmi.is_limited_range); 565 + 566 + drm_modeset_drop_locks(&ctx); 567 + drm_modeset_acquire_fini(&ctx); 572 568 } 573 569 574 570 /* ··· 582 572 static void drm_test_check_broadcast_rgb_full_cea_mode_vic_1(struct kunit *test) 583 573 { 584 574 struct drm_atomic_helper_connector_hdmi_priv *priv; 585 - struct drm_modeset_acquire_ctx *ctx; 575 + struct drm_modeset_acquire_ctx ctx; 586 576 struct drm_connector_state *conn_state; 587 577 struct drm_atomic_state *state; 588 578 struct drm_display_mode *mode; ··· 600 590 conn = &priv->connector; 601 591 KUNIT_ASSERT_TRUE(test, conn->display_info.is_hdmi); 602 592 603 - ctx = drm_kunit_helper_acquire_ctx_alloc(test); 604 - KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx); 593 + drm_modeset_acquire_init(&ctx, 0); 605 594 606 595 mode = drm_kunit_display_mode_from_cea_vic(test, drm, 1); 607 596 KUNIT_ASSERT_NOT_NULL(test, mode); 608 597 609 598 crtc = priv->crtc; 610 - ret = light_up_connector(test, drm, crtc, conn, mode, ctx); 599 + ret = light_up_connector(test, drm, crtc, conn, mode, &ctx); 611 600 KUNIT_ASSERT_EQ(test, ret, 0); 612 601 613 - state = drm_kunit_helper_atomic_state_alloc(test, drm, ctx); 602 + state = drm_kunit_helper_atomic_state_alloc(test, drm, &ctx); 614 603 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, state); 615 604 616 605 conn_state = drm_atomic_get_connector_state(state, conn); ··· 628 619 DRM_HDMI_BROADCAST_RGB_FULL); 629 620 630 621 KUNIT_EXPECT_FALSE(test, conn_state->hdmi.is_limited_range); 622 + 623 + drm_modeset_drop_locks(&ctx); 624 + drm_modeset_acquire_fini(&ctx); 631 625 } 632 626 633 627 /* ··· 641 629 static void drm_test_check_broadcast_rgb_limited_cea_mode(struct kunit *test) 642 630 { 643 631 struct drm_atomic_helper_connector_hdmi_priv *priv; 644 - struct drm_modeset_acquire_ctx *ctx; 632 + struct drm_modeset_acquire_ctx ctx; 645 633 struct drm_connector_state *conn_state; 646 634 struct drm_atomic_state *state; 647 635 struct drm_display_mode *preferred; ··· 664 652 KUNIT_ASSERT_NOT_NULL(test, preferred); 665 653 KUNIT_ASSERT_NE(test, drm_match_cea_mode(preferred), 1); 666 654 667 - ctx = drm_kunit_helper_acquire_ctx_alloc(test); 668 - KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx); 655 + drm_modeset_acquire_init(&ctx, 0); 669 656 670 - ret = light_up_connector(test, drm, crtc, conn, preferred, ctx); 657 + ret = light_up_connector(test, drm, crtc, conn, preferred, &ctx); 671 658 KUNIT_ASSERT_EQ(test, ret, 0); 672 659 673 - state = drm_kunit_helper_atomic_state_alloc(test, drm, ctx); 660 + state = drm_kunit_helper_atomic_state_alloc(test, drm, &ctx); 674 661 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, state); 675 662 676 663 conn_state = drm_atomic_get_connector_state(state, conn); ··· 688 677 DRM_HDMI_BROADCAST_RGB_LIMITED); 689 678 690 679 KUNIT_EXPECT_TRUE(test, conn_state->hdmi.is_limited_range); 680 + 681 + drm_modeset_drop_locks(&ctx); 682 + drm_modeset_acquire_fini(&ctx); 691 683 } 692 684 693 685 /* ··· 701 687 static void drm_test_check_broadcast_rgb_limited_cea_mode_vic_1(struct kunit *test) 702 688 { 703 689 struct drm_atomic_helper_connector_hdmi_priv *priv; 704 - struct drm_modeset_acquire_ctx *ctx; 690 + struct drm_modeset_acquire_ctx ctx; 705 691 struct drm_connector_state *conn_state; 706 692 struct drm_atomic_state *state; 707 693 struct drm_display_mode *mode; ··· 719 705 conn = &priv->connector; 720 706 KUNIT_ASSERT_TRUE(test, conn->display_info.is_hdmi); 721 707 722 - ctx = drm_kunit_helper_acquire_ctx_alloc(test); 723 - KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx); 708 + drm_modeset_acquire_init(&ctx, 0); 724 709 725 710 mode = drm_kunit_display_mode_from_cea_vic(test, drm, 1); 726 711 KUNIT_ASSERT_NOT_NULL(test, mode); 727 712 728 713 crtc = priv->crtc; 729 - ret = light_up_connector(test, drm, crtc, conn, mode, ctx); 714 + ret = light_up_connector(test, drm, crtc, conn, mode, &ctx); 730 715 KUNIT_ASSERT_EQ(test, ret, 0); 731 716 732 - state = drm_kunit_helper_atomic_state_alloc(test, drm, ctx); 717 + state = drm_kunit_helper_atomic_state_alloc(test, drm, &ctx); 733 718 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, state); 734 719 735 720 conn_state = drm_atomic_get_connector_state(state, conn); ··· 747 734 DRM_HDMI_BROADCAST_RGB_LIMITED); 748 735 749 736 KUNIT_EXPECT_TRUE(test, conn_state->hdmi.is_limited_range); 737 + 738 + drm_modeset_drop_locks(&ctx); 739 + drm_modeset_acquire_fini(&ctx); 750 740 } 751 741 752 742 /* ··· 760 744 static void drm_test_check_output_bpc_crtc_mode_changed(struct kunit *test) 761 745 { 762 746 struct drm_atomic_helper_connector_hdmi_priv *priv; 763 - struct drm_modeset_acquire_ctx *ctx; 747 + struct drm_modeset_acquire_ctx ctx; 764 748 struct drm_connector_state *old_conn_state; 765 749 struct drm_connector_state *new_conn_state; 766 750 struct drm_crtc_state *crtc_state; ··· 787 771 preferred = find_preferred_mode(conn); 788 772 KUNIT_ASSERT_NOT_NULL(test, preferred); 789 773 790 - ctx = drm_kunit_helper_acquire_ctx_alloc(test); 791 - KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx); 774 + drm_modeset_acquire_init(&ctx, 0); 792 775 793 - ret = light_up_connector(test, drm, crtc, conn, preferred, ctx); 776 + ret = light_up_connector(test, drm, crtc, conn, preferred, &ctx); 794 777 KUNIT_ASSERT_EQ(test, ret, 0); 795 778 796 - state = drm_kunit_helper_atomic_state_alloc(test, drm, ctx); 779 + state = drm_kunit_helper_atomic_state_alloc(test, drm, &ctx); 797 780 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, state); 798 781 799 782 new_conn_state = drm_atomic_get_connector_state(state, conn); ··· 823 808 crtc_state = drm_atomic_get_new_crtc_state(state, crtc); 824 809 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, crtc_state); 825 810 KUNIT_EXPECT_TRUE(test, crtc_state->mode_changed); 811 + 812 + drm_modeset_drop_locks(&ctx); 813 + drm_modeset_acquire_fini(&ctx); 826 814 } 827 815 828 816 /* ··· 836 818 static void drm_test_check_output_bpc_crtc_mode_not_changed(struct kunit *test) 837 819 { 838 820 struct drm_atomic_helper_connector_hdmi_priv *priv; 839 - struct drm_modeset_acquire_ctx *ctx; 821 + struct drm_modeset_acquire_ctx ctx; 840 822 struct drm_connector_state *old_conn_state; 841 823 struct drm_connector_state *new_conn_state; 842 824 struct drm_crtc_state *crtc_state; ··· 863 845 preferred = find_preferred_mode(conn); 864 846 KUNIT_ASSERT_NOT_NULL(test, preferred); 865 847 866 - ctx = drm_kunit_helper_acquire_ctx_alloc(test); 867 - KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx); 848 + drm_modeset_acquire_init(&ctx, 0); 868 849 869 - ret = light_up_connector(test, drm, crtc, conn, preferred, ctx); 850 + ret = light_up_connector(test, drm, crtc, conn, preferred, &ctx); 870 851 KUNIT_ASSERT_EQ(test, ret, 0); 871 852 872 - state = drm_kunit_helper_atomic_state_alloc(test, drm, ctx); 853 + state = drm_kunit_helper_atomic_state_alloc(test, drm, &ctx); 873 854 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, state); 874 855 875 856 new_conn_state = drm_atomic_get_connector_state(state, conn); ··· 897 880 crtc_state = drm_atomic_get_new_crtc_state(state, crtc); 898 881 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, crtc_state); 899 882 KUNIT_EXPECT_FALSE(test, crtc_state->mode_changed); 883 + 884 + drm_modeset_drop_locks(&ctx); 885 + drm_modeset_acquire_fini(&ctx); 900 886 } 901 887 902 888 /* ··· 909 889 static void drm_test_check_output_bpc_dvi(struct kunit *test) 910 890 { 911 891 struct drm_atomic_helper_connector_hdmi_priv *priv; 912 - struct drm_modeset_acquire_ctx *ctx; 892 + struct drm_modeset_acquire_ctx ctx; 913 893 struct drm_connector_state *conn_state; 914 894 struct drm_display_info *info; 915 895 struct drm_display_mode *preferred; ··· 939 919 preferred = find_preferred_mode(conn); 940 920 KUNIT_ASSERT_NOT_NULL(test, preferred); 941 921 942 - ctx = drm_kunit_helper_acquire_ctx_alloc(test); 943 - KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx); 922 + drm_modeset_acquire_init(&ctx, 0); 944 923 945 - ret = light_up_connector(test, drm, crtc, conn, preferred, ctx); 924 + ret = light_up_connector(test, drm, crtc, conn, preferred, &ctx); 946 925 KUNIT_ASSERT_EQ(test, ret, 0); 947 926 948 927 conn_state = conn->state; ··· 949 930 950 931 KUNIT_EXPECT_EQ(test, conn_state->hdmi.output_bpc, 8); 951 932 KUNIT_EXPECT_EQ(test, conn_state->hdmi.output_format, HDMI_COLORSPACE_RGB); 933 + 934 + drm_modeset_drop_locks(&ctx); 935 + drm_modeset_acquire_fini(&ctx); 952 936 } 953 937 954 938 /* ··· 961 939 static void drm_test_check_tmds_char_rate_rgb_8bpc(struct kunit *test) 962 940 { 963 941 struct drm_atomic_helper_connector_hdmi_priv *priv; 964 - struct drm_modeset_acquire_ctx *ctx; 942 + struct drm_modeset_acquire_ctx ctx; 965 943 struct drm_connector_state *conn_state; 966 944 struct drm_display_mode *preferred; 967 945 struct drm_connector *conn; ··· 986 964 KUNIT_ASSERT_NOT_NULL(test, preferred); 987 965 KUNIT_ASSERT_FALSE(test, preferred->flags & DRM_MODE_FLAG_DBLCLK); 988 966 989 - ctx = drm_kunit_helper_acquire_ctx_alloc(test); 990 - KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx); 967 + drm_modeset_acquire_init(&ctx, 0); 991 968 992 - ret = light_up_connector(test, drm, crtc, conn, preferred, ctx); 969 + ret = light_up_connector(test, drm, crtc, conn, preferred, &ctx); 993 970 KUNIT_ASSERT_EQ(test, ret, 0); 994 971 995 972 conn_state = conn->state; ··· 997 976 KUNIT_ASSERT_EQ(test, conn_state->hdmi.output_bpc, 8); 998 977 KUNIT_ASSERT_EQ(test, conn_state->hdmi.output_format, HDMI_COLORSPACE_RGB); 999 978 KUNIT_EXPECT_EQ(test, conn_state->hdmi.tmds_char_rate, preferred->clock * 1000); 979 + 980 + drm_modeset_drop_locks(&ctx); 981 + drm_modeset_acquire_fini(&ctx); 1000 982 } 1001 983 1002 984 /* ··· 1010 986 static void drm_test_check_tmds_char_rate_rgb_10bpc(struct kunit *test) 1011 987 { 1012 988 struct drm_atomic_helper_connector_hdmi_priv *priv; 1013 - struct drm_modeset_acquire_ctx *ctx; 989 + struct drm_modeset_acquire_ctx ctx; 1014 990 struct drm_connector_state *conn_state; 1015 991 struct drm_display_mode *preferred; 1016 992 struct drm_connector *conn; ··· 1035 1011 KUNIT_ASSERT_NOT_NULL(test, preferred); 1036 1012 KUNIT_ASSERT_FALSE(test, preferred->flags & DRM_MODE_FLAG_DBLCLK); 1037 1013 1038 - ctx = drm_kunit_helper_acquire_ctx_alloc(test); 1039 - KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx); 1014 + drm_modeset_acquire_init(&ctx, 0); 1040 1015 1041 - ret = light_up_connector(test, drm, crtc, conn, preferred, ctx); 1016 + ret = light_up_connector(test, drm, crtc, conn, preferred, &ctx); 1042 1017 KUNIT_ASSERT_EQ(test, ret, 0); 1043 1018 1044 1019 conn_state = conn->state; ··· 1046 1023 KUNIT_ASSERT_EQ(test, conn_state->hdmi.output_bpc, 10); 1047 1024 KUNIT_ASSERT_EQ(test, conn_state->hdmi.output_format, HDMI_COLORSPACE_RGB); 1048 1025 KUNIT_EXPECT_EQ(test, conn_state->hdmi.tmds_char_rate, preferred->clock * 1250); 1026 + 1027 + drm_modeset_drop_locks(&ctx); 1028 + drm_modeset_acquire_fini(&ctx); 1049 1029 } 1050 1030 1051 1031 /* ··· 1059 1033 static void drm_test_check_tmds_char_rate_rgb_12bpc(struct kunit *test) 1060 1034 { 1061 1035 struct drm_atomic_helper_connector_hdmi_priv *priv; 1062 - struct drm_modeset_acquire_ctx *ctx; 1036 + struct drm_modeset_acquire_ctx ctx; 1063 1037 struct drm_connector_state *conn_state; 1064 1038 struct drm_display_mode *preferred; 1065 1039 struct drm_connector *conn; ··· 1084 1058 KUNIT_ASSERT_NOT_NULL(test, preferred); 1085 1059 KUNIT_ASSERT_FALSE(test, preferred->flags & DRM_MODE_FLAG_DBLCLK); 1086 1060 1087 - ctx = drm_kunit_helper_acquire_ctx_alloc(test); 1088 - KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx); 1061 + drm_modeset_acquire_init(&ctx, 0); 1089 1062 1090 - ret = light_up_connector(test, drm, crtc, conn, preferred, ctx); 1063 + ret = light_up_connector(test, drm, crtc, conn, preferred, &ctx); 1091 1064 KUNIT_ASSERT_EQ(test, ret, 0); 1092 1065 1093 1066 conn_state = conn->state; ··· 1095 1070 KUNIT_ASSERT_EQ(test, conn_state->hdmi.output_bpc, 12); 1096 1071 KUNIT_ASSERT_EQ(test, conn_state->hdmi.output_format, HDMI_COLORSPACE_RGB); 1097 1072 KUNIT_EXPECT_EQ(test, conn_state->hdmi.tmds_char_rate, preferred->clock * 1500); 1073 + 1074 + drm_modeset_drop_locks(&ctx); 1075 + drm_modeset_acquire_fini(&ctx); 1098 1076 } 1099 1077 1100 1078 /* ··· 1111 1083 static void drm_test_check_hdmi_funcs_reject_rate(struct kunit *test) 1112 1084 { 1113 1085 struct drm_atomic_helper_connector_hdmi_priv *priv; 1114 - struct drm_modeset_acquire_ctx *ctx; 1086 + struct drm_modeset_acquire_ctx ctx; 1115 1087 struct drm_atomic_state *state; 1116 1088 struct drm_display_mode *preferred; 1117 1089 struct drm_crtc_state *crtc_state; ··· 1132 1104 preferred = find_preferred_mode(conn); 1133 1105 KUNIT_ASSERT_NOT_NULL(test, preferred); 1134 1106 1135 - ctx = drm_kunit_helper_acquire_ctx_alloc(test); 1136 - KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx); 1107 + drm_modeset_acquire_init(&ctx, 0); 1137 1108 1138 - ret = light_up_connector(test, drm, crtc, conn, preferred, ctx); 1109 + ret = light_up_connector(test, drm, crtc, conn, preferred, &ctx); 1139 1110 KUNIT_ASSERT_EQ(test, ret, 0); 1140 1111 1141 1112 /* You shouldn't be doing that at home. */ 1142 1113 conn->hdmi.funcs = &reject_connector_hdmi_funcs; 1143 1114 1144 - state = drm_kunit_helper_atomic_state_alloc(test, drm, ctx); 1115 + state = drm_kunit_helper_atomic_state_alloc(test, drm, &ctx); 1145 1116 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, state); 1146 1117 1147 1118 crtc_state = drm_atomic_get_crtc_state(state, crtc); ··· 1150 1123 1151 1124 ret = drm_atomic_check_only(state); 1152 1125 KUNIT_EXPECT_LT(test, ret, 0); 1126 + 1127 + drm_modeset_drop_locks(&ctx); 1128 + drm_modeset_acquire_fini(&ctx); 1153 1129 } 1154 1130 1155 1131 /* ··· 1169 1139 static void drm_test_check_max_tmds_rate_bpc_fallback(struct kunit *test) 1170 1140 { 1171 1141 struct drm_atomic_helper_connector_hdmi_priv *priv; 1172 - struct drm_modeset_acquire_ctx *ctx; 1142 + struct drm_modeset_acquire_ctx ctx; 1173 1143 struct drm_connector_state *conn_state; 1174 1144 struct drm_display_info *info; 1175 1145 struct drm_display_mode *preferred; ··· 1206 1176 rate = drm_hdmi_compute_mode_clock(preferred, 10, HDMI_COLORSPACE_RGB); 1207 1177 KUNIT_ASSERT_LT(test, rate, info->max_tmds_clock * 1000); 1208 1178 1209 - ctx = drm_kunit_helper_acquire_ctx_alloc(test); 1210 - KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx); 1179 + drm_modeset_acquire_init(&ctx, 0); 1211 1180 1212 - ret = light_up_connector(test, drm, crtc, conn, preferred, ctx); 1181 + ret = light_up_connector(test, drm, crtc, conn, preferred, &ctx); 1213 1182 KUNIT_EXPECT_EQ(test, ret, 0); 1214 1183 1215 1184 conn_state = conn->state; ··· 1217 1188 KUNIT_EXPECT_EQ(test, conn_state->hdmi.output_bpc, 10); 1218 1189 KUNIT_EXPECT_EQ(test, conn_state->hdmi.output_format, HDMI_COLORSPACE_RGB); 1219 1190 KUNIT_EXPECT_EQ(test, conn_state->hdmi.tmds_char_rate, preferred->clock * 1250); 1191 + 1192 + drm_modeset_drop_locks(&ctx); 1193 + drm_modeset_acquire_fini(&ctx); 1220 1194 } 1221 1195 1222 1196 /* ··· 1238 1206 static void drm_test_check_max_tmds_rate_format_fallback(struct kunit *test) 1239 1207 { 1240 1208 struct drm_atomic_helper_connector_hdmi_priv *priv; 1241 - struct drm_modeset_acquire_ctx *ctx; 1209 + struct drm_modeset_acquire_ctx ctx; 1242 1210 struct drm_connector_state *conn_state; 1243 1211 struct drm_display_info *info; 1244 1212 struct drm_display_mode *preferred; ··· 1280 1248 rate = drm_hdmi_compute_mode_clock(preferred, 12, HDMI_COLORSPACE_YUV422); 1281 1249 KUNIT_ASSERT_LT(test, rate, info->max_tmds_clock * 1000); 1282 1250 1283 - ctx = drm_kunit_helper_acquire_ctx_alloc(test); 1284 - KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx); 1251 + drm_modeset_acquire_init(&ctx, 0); 1285 1252 1286 - ret = light_up_connector(test, drm, crtc, conn, preferred, ctx); 1253 + ret = light_up_connector(test, drm, crtc, conn, preferred, &ctx); 1287 1254 KUNIT_EXPECT_EQ(test, ret, 0); 1288 1255 1289 1256 conn_state = conn->state; ··· 1290 1259 1291 1260 KUNIT_EXPECT_EQ(test, conn_state->hdmi.output_bpc, 10); 1292 1261 KUNIT_EXPECT_EQ(test, conn_state->hdmi.output_format, HDMI_COLORSPACE_RGB); 1262 + 1263 + drm_modeset_drop_locks(&ctx); 1264 + drm_modeset_acquire_fini(&ctx); 1293 1265 } 1294 1266 1295 1267 /* ··· 1303 1269 static void drm_test_check_output_bpc_format_vic_1(struct kunit *test) 1304 1270 { 1305 1271 struct drm_atomic_helper_connector_hdmi_priv *priv; 1306 - struct drm_modeset_acquire_ctx *ctx; 1272 + struct drm_modeset_acquire_ctx ctx; 1307 1273 struct drm_connector_state *conn_state; 1308 1274 struct drm_display_info *info; 1309 1275 struct drm_display_mode *mode; ··· 1344 1310 rate = mode->clock * 1500; 1345 1311 KUNIT_ASSERT_LT(test, rate, info->max_tmds_clock * 1000); 1346 1312 1347 - ctx = drm_kunit_helper_acquire_ctx_alloc(test); 1348 - KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx); 1313 + drm_modeset_acquire_init(&ctx, 0); 1349 1314 1350 1315 crtc = priv->crtc; 1351 - ret = light_up_connector(test, drm, crtc, conn, mode, ctx); 1316 + ret = light_up_connector(test, drm, crtc, conn, mode, &ctx); 1352 1317 KUNIT_EXPECT_EQ(test, ret, 0); 1353 1318 1354 1319 conn_state = conn->state; ··· 1355 1322 1356 1323 KUNIT_EXPECT_EQ(test, conn_state->hdmi.output_bpc, 8); 1357 1324 KUNIT_EXPECT_EQ(test, conn_state->hdmi.output_format, HDMI_COLORSPACE_RGB); 1325 + 1326 + drm_modeset_drop_locks(&ctx); 1327 + drm_modeset_acquire_fini(&ctx); 1358 1328 } 1359 1329 1360 1330 /* ··· 1367 1331 static void drm_test_check_output_bpc_format_driver_rgb_only(struct kunit *test) 1368 1332 { 1369 1333 struct drm_atomic_helper_connector_hdmi_priv *priv; 1370 - struct drm_modeset_acquire_ctx *ctx; 1334 + struct drm_modeset_acquire_ctx ctx; 1371 1335 struct drm_connector_state *conn_state; 1372 1336 struct drm_display_info *info; 1373 1337 struct drm_display_mode *preferred; ··· 1412 1376 rate = drm_hdmi_compute_mode_clock(preferred, 12, HDMI_COLORSPACE_YUV422); 1413 1377 KUNIT_ASSERT_LT(test, rate, info->max_tmds_clock * 1000); 1414 1378 1415 - ctx = drm_kunit_helper_acquire_ctx_alloc(test); 1416 - KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx); 1379 + drm_modeset_acquire_init(&ctx, 0); 1417 1380 1418 - ret = light_up_connector(test, drm, crtc, conn, preferred, ctx); 1381 + ret = light_up_connector(test, drm, crtc, conn, preferred, &ctx); 1419 1382 KUNIT_EXPECT_EQ(test, ret, 0); 1420 1383 1421 1384 conn_state = conn->state; ··· 1422 1387 1423 1388 KUNIT_EXPECT_LT(test, conn_state->hdmi.output_bpc, 12); 1424 1389 KUNIT_EXPECT_EQ(test, conn_state->hdmi.output_format, HDMI_COLORSPACE_RGB); 1390 + 1391 + drm_modeset_drop_locks(&ctx); 1392 + drm_modeset_acquire_fini(&ctx); 1425 1393 } 1426 1394 1427 1395 /* ··· 1434 1396 static void drm_test_check_output_bpc_format_display_rgb_only(struct kunit *test) 1435 1397 { 1436 1398 struct drm_atomic_helper_connector_hdmi_priv *priv; 1437 - struct drm_modeset_acquire_ctx *ctx; 1399 + struct drm_modeset_acquire_ctx ctx; 1438 1400 struct drm_connector_state *conn_state; 1439 1401 struct drm_display_info *info; 1440 1402 struct drm_display_mode *preferred; ··· 1481 1443 rate = drm_hdmi_compute_mode_clock(preferred, 12, HDMI_COLORSPACE_YUV422); 1482 1444 KUNIT_ASSERT_LT(test, rate, info->max_tmds_clock * 1000); 1483 1445 1484 - ctx = drm_kunit_helper_acquire_ctx_alloc(test); 1485 - KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx); 1446 + drm_modeset_acquire_init(&ctx, 0); 1486 1447 1487 - ret = light_up_connector(test, drm, crtc, conn, preferred, ctx); 1448 + ret = light_up_connector(test, drm, crtc, conn, preferred, &ctx); 1488 1449 KUNIT_EXPECT_EQ(test, ret, 0); 1489 1450 1490 1451 conn_state = conn->state; ··· 1491 1454 1492 1455 KUNIT_EXPECT_LT(test, conn_state->hdmi.output_bpc, 12); 1493 1456 KUNIT_EXPECT_EQ(test, conn_state->hdmi.output_format, HDMI_COLORSPACE_RGB); 1457 + 1458 + drm_modeset_drop_locks(&ctx); 1459 + drm_modeset_acquire_fini(&ctx); 1494 1460 } 1495 1461 1496 1462 /* ··· 1504 1464 static void drm_test_check_output_bpc_format_driver_8bpc_only(struct kunit *test) 1505 1465 { 1506 1466 struct drm_atomic_helper_connector_hdmi_priv *priv; 1507 - struct drm_modeset_acquire_ctx *ctx; 1467 + struct drm_modeset_acquire_ctx ctx; 1508 1468 struct drm_connector_state *conn_state; 1509 1469 struct drm_display_info *info; 1510 1470 struct drm_display_mode *preferred; ··· 1541 1501 rate = drm_hdmi_compute_mode_clock(preferred, 12, HDMI_COLORSPACE_RGB); 1542 1502 KUNIT_ASSERT_LT(test, rate, info->max_tmds_clock * 1000); 1543 1503 1544 - ctx = drm_kunit_helper_acquire_ctx_alloc(test); 1545 - KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx); 1504 + drm_modeset_acquire_init(&ctx, 0); 1546 1505 1547 - ret = light_up_connector(test, drm, crtc, conn, preferred, ctx); 1506 + ret = light_up_connector(test, drm, crtc, conn, preferred, &ctx); 1548 1507 KUNIT_EXPECT_EQ(test, ret, 0); 1549 1508 1550 1509 conn_state = conn->state; ··· 1551 1512 1552 1513 KUNIT_EXPECT_EQ(test, conn_state->hdmi.output_bpc, 8); 1553 1514 KUNIT_EXPECT_EQ(test, conn_state->hdmi.output_format, HDMI_COLORSPACE_RGB); 1515 + 1516 + drm_modeset_drop_locks(&ctx); 1517 + drm_modeset_acquire_fini(&ctx); 1554 1518 } 1555 1519 1556 1520 /* ··· 1564 1522 static void drm_test_check_output_bpc_format_display_8bpc_only(struct kunit *test) 1565 1523 { 1566 1524 struct drm_atomic_helper_connector_hdmi_priv *priv; 1567 - struct drm_modeset_acquire_ctx *ctx; 1525 + struct drm_modeset_acquire_ctx ctx; 1568 1526 struct drm_connector_state *conn_state; 1569 1527 struct drm_display_info *info; 1570 1528 struct drm_display_mode *preferred; ··· 1603 1561 rate = drm_hdmi_compute_mode_clock(preferred, 12, HDMI_COLORSPACE_RGB); 1604 1562 KUNIT_ASSERT_LT(test, rate, info->max_tmds_clock * 1000); 1605 1563 1606 - ctx = drm_kunit_helper_acquire_ctx_alloc(test); 1607 - KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx); 1564 + drm_modeset_acquire_init(&ctx, 0); 1608 1565 1609 - ret = light_up_connector(test, drm, crtc, conn, preferred, ctx); 1566 + ret = light_up_connector(test, drm, crtc, conn, preferred, &ctx); 1610 1567 KUNIT_EXPECT_EQ(test, ret, 0); 1611 1568 1612 1569 conn_state = conn->state; ··· 1613 1572 1614 1573 KUNIT_EXPECT_EQ(test, conn_state->hdmi.output_bpc, 8); 1615 1574 KUNIT_EXPECT_EQ(test, conn_state->hdmi.output_format, HDMI_COLORSPACE_RGB); 1575 + 1576 + drm_modeset_drop_locks(&ctx); 1577 + drm_modeset_acquire_fini(&ctx); 1616 1578 } 1617 1579 1618 1580 /* Test that atomic check succeeds when disabling a connector. */ 1619 1581 static void drm_test_check_disable_connector(struct kunit *test) 1620 1582 { 1621 1583 struct drm_atomic_helper_connector_hdmi_priv *priv; 1622 - struct drm_modeset_acquire_ctx *ctx; 1584 + struct drm_modeset_acquire_ctx ctx; 1623 1585 struct drm_connector_state *conn_state; 1624 1586 struct drm_crtc_state *crtc_state; 1625 1587 struct drm_atomic_state *state; ··· 1637 1593 8); 1638 1594 KUNIT_ASSERT_NOT_NULL(test, priv); 1639 1595 1640 - ctx = drm_kunit_helper_acquire_ctx_alloc(test); 1641 - KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx); 1596 + drm_modeset_acquire_init(&ctx, 0); 1642 1597 1643 1598 conn = &priv->connector; 1644 1599 preferred = find_preferred_mode(conn); ··· 1645 1602 1646 1603 drm = &priv->drm; 1647 1604 crtc = priv->crtc; 1648 - ret = light_up_connector(test, drm, crtc, conn, preferred, ctx); 1605 + ret = light_up_connector(test, drm, crtc, conn, preferred, &ctx); 1649 1606 KUNIT_ASSERT_EQ(test, ret, 0); 1650 1607 1651 - state = drm_kunit_helper_atomic_state_alloc(test, drm, ctx); 1608 + state = drm_kunit_helper_atomic_state_alloc(test, drm, &ctx); 1652 1609 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, state); 1653 1610 1654 1611 crtc_state = drm_atomic_get_crtc_state(state, crtc); ··· 1666 1623 1667 1624 ret = drm_atomic_check_only(state); 1668 1625 KUNIT_ASSERT_EQ(test, ret, 0); 1626 + 1627 + drm_modeset_drop_locks(&ctx); 1628 + drm_modeset_acquire_fini(&ctx); 1669 1629 } 1670 1630 1671 1631 static struct kunit_case drm_atomic_helper_connector_hdmi_check_tests[] = {

-41

drivers/gpu/drm/tests/drm_kunit_helpers.c

··· 80 80 } 81 81 EXPORT_SYMBOL_GPL(__drm_kunit_helper_alloc_drm_device_with_driver); 82 82 83 - static void action_drm_release_context(void *ptr) 84 - { 85 - struct drm_modeset_acquire_ctx *ctx = ptr; 86 - 87 - drm_modeset_drop_locks(ctx); 88 - drm_modeset_acquire_fini(ctx); 89 - } 90 - 91 - /** 92 - * drm_kunit_helper_acquire_ctx_alloc - Allocates an acquire context 93 - * @test: The test context object 94 - * 95 - * Allocates and initializes a modeset acquire context. 96 - * 97 - * The context is tied to the kunit test context, so we must not call 98 - * drm_modeset_acquire_fini() on it, it will be done so automatically. 99 - * 100 - * Returns: 101 - * An ERR_PTR on error, a pointer to the newly allocated context otherwise 102 - */ 103 - struct drm_modeset_acquire_ctx * 104 - drm_kunit_helper_acquire_ctx_alloc(struct kunit *test) 105 - { 106 - struct drm_modeset_acquire_ctx *ctx; 107 - int ret; 108 - 109 - ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL); 110 - KUNIT_ASSERT_NOT_NULL(test, ctx); 111 - 112 - drm_modeset_acquire_init(ctx, 0); 113 - 114 - ret = kunit_add_action_or_reset(test, 115 - action_drm_release_context, 116 - ctx); 117 - if (ret) 118 - return ERR_PTR(ret); 119 - 120 - return ctx; 121 - } 122 - EXPORT_SYMBOL_GPL(drm_kunit_helper_acquire_ctx_alloc); 123 - 124 83 static void kunit_action_drm_atomic_state_put(void *ptr) 125 84 { 126 85 struct drm_atomic_state *state = ptr;

+27 -19

drivers/gpu/drm/vc4/tests/vc4_test_pv_muxing.c

··· 724 724 static int vc4_pv_muxing_test_init(struct kunit *test) 725 725 { 726 726 const struct pv_muxing_param *params = test->param_value; 727 - struct drm_modeset_acquire_ctx *ctx; 727 + struct drm_modeset_acquire_ctx ctx; 728 728 struct pv_muxing_priv *priv; 729 729 struct drm_device *drm; 730 730 struct vc4_dev *vc4; ··· 737 737 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, vc4); 738 738 priv->vc4 = vc4; 739 739 740 - ctx = drm_kunit_helper_acquire_ctx_alloc(test); 741 - KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx); 740 + drm_modeset_acquire_init(&ctx, 0); 742 741 743 742 drm = &vc4->base; 744 - priv->state = drm_kunit_helper_atomic_state_alloc(test, drm, ctx); 743 + priv->state = drm_kunit_helper_atomic_state_alloc(test, drm, &ctx); 745 744 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, priv->state); 745 + 746 + drm_modeset_drop_locks(&ctx); 747 + drm_modeset_acquire_fini(&ctx); 746 748 747 749 return 0; 748 750 } ··· 784 782 */ 785 783 static void drm_test_vc5_pv_muxing_bugs_subsequent_crtc_enable(struct kunit *test) 786 784 { 787 - struct drm_modeset_acquire_ctx *ctx; 785 + struct drm_modeset_acquire_ctx ctx; 788 786 struct drm_atomic_state *state; 789 787 struct vc4_crtc_state *new_vc4_crtc_state; 790 788 struct vc4_hvs_state *new_hvs_state; ··· 797 795 vc4 = vc5_mock_device(test); 798 796 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, vc4); 799 797 800 - ctx = drm_kunit_helper_acquire_ctx_alloc(test); 801 - KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx); 798 + drm_modeset_acquire_init(&ctx, 0); 802 799 803 800 drm = &vc4->base; 804 - state = drm_kunit_helper_atomic_state_alloc(test, drm, ctx); 801 + state = drm_kunit_helper_atomic_state_alloc(test, drm, &ctx); 805 802 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, state); 806 803 807 804 ret = vc4_mock_atomic_add_output(test, state, VC4_ENCODER_TYPE_HDMI0); ··· 823 822 ret = drm_atomic_helper_swap_state(state, false); 824 823 KUNIT_ASSERT_EQ(test, ret, 0); 825 824 826 - state = drm_kunit_helper_atomic_state_alloc(test, drm, ctx); 825 + state = drm_kunit_helper_atomic_state_alloc(test, drm, &ctx); 827 826 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, state); 828 827 829 828 ret = vc4_mock_atomic_add_output(test, state, VC4_ENCODER_TYPE_HDMI1); ··· 844 843 KUNIT_ASSERT_TRUE(test, new_hvs_state->fifo_state[hdmi1_channel].in_use); 845 844 846 845 KUNIT_EXPECT_NE(test, hdmi0_channel, hdmi1_channel); 846 + 847 + drm_modeset_drop_locks(&ctx); 848 + drm_modeset_acquire_fini(&ctx); 847 849 } 848 850 849 851 /* ··· 858 854 */ 859 855 static void drm_test_vc5_pv_muxing_bugs_stable_fifo(struct kunit *test) 860 856 { 861 - struct drm_modeset_acquire_ctx *ctx; 857 + struct drm_modeset_acquire_ctx ctx; 862 858 struct drm_atomic_state *state; 863 859 struct vc4_crtc_state *new_vc4_crtc_state; 864 860 struct vc4_hvs_state *new_hvs_state; ··· 871 867 vc4 = vc5_mock_device(test); 872 868 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, vc4); 873 869 874 - ctx = drm_kunit_helper_acquire_ctx_alloc(test); 875 - KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx); 870 + drm_modeset_acquire_init(&ctx, 0); 876 871 877 872 drm = &vc4->base; 878 - state = drm_kunit_helper_atomic_state_alloc(test, drm, ctx); 873 + state = drm_kunit_helper_atomic_state_alloc(test, drm, &ctx); 879 874 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, state); 880 875 881 876 ret = vc4_mock_atomic_add_output(test, state, VC4_ENCODER_TYPE_HDMI0); ··· 908 905 ret = drm_atomic_helper_swap_state(state, false); 909 906 KUNIT_ASSERT_EQ(test, ret, 0); 910 907 911 - state = drm_kunit_helper_atomic_state_alloc(test, drm, ctx); 908 + state = drm_kunit_helper_atomic_state_alloc(test, drm, &ctx); 912 909 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, state); 913 910 914 911 ret = vc4_mock_atomic_del_output(test, state, VC4_ENCODER_TYPE_HDMI0); ··· 932 929 933 930 KUNIT_EXPECT_EQ(test, old_hdmi1_channel, hdmi1_channel); 934 931 } 932 + 933 + drm_modeset_drop_locks(&ctx); 934 + drm_modeset_acquire_fini(&ctx); 935 935 } 936 936 937 937 /* ··· 955 949 static void 956 950 drm_test_vc5_pv_muxing_bugs_subsequent_crtc_enable_too_many_crtc_state(struct kunit *test) 957 951 { 958 - struct drm_modeset_acquire_ctx *ctx; 952 + struct drm_modeset_acquire_ctx ctx; 959 953 struct drm_atomic_state *state; 960 954 struct vc4_crtc_state *new_vc4_crtc_state; 961 955 struct drm_device *drm; ··· 965 959 vc4 = vc5_mock_device(test); 966 960 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, vc4); 967 961 968 - ctx = drm_kunit_helper_acquire_ctx_alloc(test); 969 - KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx); 962 + drm_modeset_acquire_init(&ctx, 0); 970 963 971 964 drm = &vc4->base; 972 - state = drm_kunit_helper_atomic_state_alloc(test, drm, ctx); 965 + state = drm_kunit_helper_atomic_state_alloc(test, drm, &ctx); 973 966 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, state); 974 967 975 968 ret = vc4_mock_atomic_add_output(test, state, VC4_ENCODER_TYPE_HDMI0); ··· 980 975 ret = drm_atomic_helper_swap_state(state, false); 981 976 KUNIT_ASSERT_EQ(test, ret, 0); 982 977 983 - state = drm_kunit_helper_atomic_state_alloc(test, drm, ctx); 978 + state = drm_kunit_helper_atomic_state_alloc(test, drm, &ctx); 984 979 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, state); 985 980 986 981 ret = vc4_mock_atomic_add_output(test, state, VC4_ENCODER_TYPE_HDMI1); ··· 992 987 new_vc4_crtc_state = get_vc4_crtc_state_for_encoder(test, state, 993 988 VC4_ENCODER_TYPE_HDMI0); 994 989 KUNIT_EXPECT_NULL(test, new_vc4_crtc_state); 990 + 991 + drm_modeset_drop_locks(&ctx); 992 + drm_modeset_acquire_fini(&ctx); 995 993 } 996 994 997 995 static struct kunit_case vc5_pv_muxing_bugs_tests[] = {

-2

include/drm/drm_kunit_helpers.h

··· 95 95 sizeof(_type), \ 96 96 offsetof(_type, _member), \ 97 97 _feat)) 98 - struct drm_modeset_acquire_ctx * 99 - drm_kunit_helper_acquire_ctx_alloc(struct kunit *test); 100 98 101 99 struct drm_atomic_state * 102 100 drm_kunit_helper_atomic_state_alloc(struct kunit *test,