1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (c) 2022 Maxime Ripard <mripard@kernel.org> 4 */ 5 6 #include <kunit/test.h> 7 8 #include <drm/drm_connector.h> 9 #include <drm/drm_edid.h> 10 #include <drm/drm_drv.h> 11 #include <drm/drm_kunit_helpers.h> 12 #include <drm/drm_modes.h> 13 #include <drm/drm_modeset_helper_vtables.h> 14 #include <drm/drm_probe_helper.h> 15 16 struct drm_client_modeset_test_priv { 17 struct drm_device *drm; 18 struct device *dev; 19 struct drm_connector connector; 20 }; 21 22 static int drm_client_modeset_connector_get_modes(struct drm_connector *connector) 23 { 24 struct drm_display_mode *mode; 25 int count; 26 27 count = drm_add_modes_noedid(connector, 1920, 1200); 28 29 mode = drm_mode_analog_ntsc_480i(connector->dev); 30 if (!mode) 31 return count; 32 33 drm_mode_probed_add(connector, mode); 34 count += 1; 35 36 mode = drm_mode_analog_pal_576i(connector->dev); 37 if (!mode) 38 return count; 39 40 drm_mode_probed_add(connector, mode); 41 count += 1; 42 43 return count; 44 } 45 46 static const struct drm_connector_helper_funcs drm_client_modeset_connector_helper_funcs = { 47 .get_modes = drm_client_modeset_connector_get_modes, 48 }; 49 50 static const struct drm_connector_funcs drm_client_modeset_connector_funcs = { 51 }; 52 53 static int drm_client_modeset_test_init(struct kunit *test) 54 { 55 struct drm_client_modeset_test_priv *priv; 56 int ret; 57 58 priv = kunit_kzalloc(test, sizeof(*priv), GFP_KERNEL); 59 KUNIT_ASSERT_NOT_NULL(test, priv); 60 61 test->priv = priv; 62 63 priv->dev = drm_kunit_helper_alloc_device(test); 64 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, priv->dev); 65 66 priv->drm = __drm_kunit_helper_alloc_drm_device(test, priv->dev, 67 sizeof(*priv->drm), 0, 68 DRIVER_MODESET); 69 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, priv->drm); 70 71 ret = drmm_connector_init(priv->drm, &priv->connector, 72 &drm_client_modeset_connector_funcs, 73 DRM_MODE_CONNECTOR_Unknown, 74 NULL); 75 KUNIT_ASSERT_EQ(test, ret, 0); 76 77 drm_connector_helper_add(&priv->connector, &drm_client_modeset_connector_helper_funcs); 78 79 priv->connector.interlace_allowed = true; 80 priv->connector.doublescan_allowed = true; 81 82 return 0; 83 } 84 85 static void drm_test_pick_cmdline_res_1920_1080_60(struct kunit *test) 86 { 87 struct drm_client_modeset_test_priv *priv = test->priv; 88 struct drm_device *drm = priv->drm; 89 struct drm_connector *connector = &priv->connector; 90 struct drm_cmdline_mode *cmdline_mode = &connector->cmdline_mode; 91 struct drm_display_mode *expected_mode; 92 const struct drm_display_mode *mode; 93 const char *cmdline = "1920x1080@60"; 94 int ret; 95 96 expected_mode = drm_mode_find_dmt(priv->drm, 1920, 1080, 60, false); 97 KUNIT_ASSERT_NOT_NULL(test, expected_mode); 98 99 ret = drm_kunit_add_mode_destroy_action(test, expected_mode); 100 KUNIT_ASSERT_EQ(test, ret, 0); 101 102 KUNIT_ASSERT_TRUE(test, 103 drm_mode_parse_command_line_for_connector(cmdline, 104 connector, 105 cmdline_mode)); 106 107 mutex_lock(&drm->mode_config.mutex); 108 ret = drm_helper_probe_single_connector_modes(connector, 1920, 1080); 109 mutex_unlock(&drm->mode_config.mutex); 110 KUNIT_ASSERT_GT(test, ret, 0); 111 112 mode = drm_connector_pick_cmdline_mode(connector); 113 KUNIT_ASSERT_NOT_NULL(test, mode); 114 115 KUNIT_EXPECT_TRUE(test, drm_mode_equal(expected_mode, mode)); 116 } 117 118 struct drm_connector_pick_cmdline_mode_test { 119 const char *cmdline; 120 struct drm_display_mode *(*func)(struct drm_device *drm); 121 }; 122 123 #define TEST_CMDLINE(_cmdline, _fn) \ 124 { \ 125 .cmdline = _cmdline, \ 126 .func = _fn, \ 127 } 128 129 static void drm_test_pick_cmdline_named(struct kunit *test) 130 { 131 const struct drm_connector_pick_cmdline_mode_test *params = test->param_value; 132 struct drm_client_modeset_test_priv *priv = test->priv; 133 struct drm_device *drm = priv->drm; 134 struct drm_connector *connector = &priv->connector; 135 struct drm_cmdline_mode *cmdline_mode = &connector->cmdline_mode; 136 const struct drm_display_mode *mode; 137 struct drm_display_mode *expected_mode; 138 const char *cmdline = params->cmdline; 139 int ret; 140 141 KUNIT_ASSERT_TRUE(test, 142 drm_mode_parse_command_line_for_connector(cmdline, 143 connector, 144 cmdline_mode)); 145 146 mutex_lock(&drm->mode_config.mutex); 147 ret = drm_helper_probe_single_connector_modes(connector, 1920, 1080); 148 mutex_unlock(&drm->mode_config.mutex); 149 KUNIT_ASSERT_GT(test, ret, 0); 150 151 mode = drm_connector_pick_cmdline_mode(connector); 152 KUNIT_ASSERT_NOT_NULL(test, mode); 153 154 expected_mode = params->func(drm); 155 KUNIT_ASSERT_NOT_NULL(test, expected_mode); 156 157 ret = drm_kunit_add_mode_destroy_action(test, expected_mode); 158 KUNIT_ASSERT_EQ(test, ret, 0); 159 160 KUNIT_EXPECT_TRUE(test, drm_mode_equal(expected_mode, mode)); 161 } 162 163 static const 164 struct drm_connector_pick_cmdline_mode_test drm_connector_pick_cmdline_mode_tests[] = { 165 TEST_CMDLINE("NTSC", drm_mode_analog_ntsc_480i), 166 TEST_CMDLINE("NTSC-J", drm_mode_analog_ntsc_480i), 167 TEST_CMDLINE("PAL", drm_mode_analog_pal_576i), 168 TEST_CMDLINE("PAL-M", drm_mode_analog_ntsc_480i), 169 }; 170 171 static void 172 drm_connector_pick_cmdline_mode_desc(const struct drm_connector_pick_cmdline_mode_test *t, 173 char *desc) 174 { 175 sprintf(desc, "%s", t->cmdline); 176 } 177 178 KUNIT_ARRAY_PARAM(drm_connector_pick_cmdline_mode, 179 drm_connector_pick_cmdline_mode_tests, 180 drm_connector_pick_cmdline_mode_desc); 181 182 static struct kunit_case drm_test_pick_cmdline_tests[] = { 183 KUNIT_CASE(drm_test_pick_cmdline_res_1920_1080_60), 184 KUNIT_CASE_PARAM(drm_test_pick_cmdline_named, 185 drm_connector_pick_cmdline_mode_gen_params), 186 {} 187 }; 188 189 static struct kunit_suite drm_test_pick_cmdline_test_suite = { 190 .name = "drm_test_pick_cmdline", 191 .init = drm_client_modeset_test_init, 192 .test_cases = drm_test_pick_cmdline_tests 193 }; 194 195 kunit_test_suite(drm_test_pick_cmdline_test_suite); 196 197 /* 198 * This file is included directly by drm_client_modeset.c so we can't 199 * use any MODULE_* macro here. 200 */ 201