Line data Source code
1 : // SPDX-License-Identifier: GPL-2.0
2 : /*
3 : * Kunit test for drm_probe_helper functions
4 : */
5 :
6 : #include <drm/drm_atomic_state_helper.h>
7 : #include <drm/drm_connector.h>
8 : #include <drm/drm_device.h>
9 : #include <drm/drm_drv.h>
10 : #include <drm/drm_kunit_helpers.h>
11 : #include <drm/drm_mode.h>
12 : #include <drm/drm_modes.h>
13 : #include <drm/drm_modeset_helper_vtables.h>
14 : #include <drm/drm_probe_helper.h>
15 :
16 : #include <kunit/test.h>
17 :
18 : struct drm_probe_helper_test_priv {
19 : struct drm_device *drm;
20 : struct device *dev;
21 : struct drm_connector connector;
22 : };
23 :
24 : static const struct drm_connector_helper_funcs drm_probe_helper_connector_helper_funcs = {
25 : };
26 :
27 : static const struct drm_connector_funcs drm_probe_helper_connector_funcs = {
28 : .atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
29 : .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
30 : .reset = drm_atomic_helper_connector_reset,
31 : };
32 :
33 0 : static int drm_probe_helper_test_init(struct kunit *test)
34 : {
35 : struct drm_probe_helper_test_priv *priv;
36 : struct drm_connector *connector;
37 : int ret;
38 :
39 0 : priv = kunit_kzalloc(test, sizeof(*priv), GFP_KERNEL);
40 0 : KUNIT_ASSERT_NOT_NULL(test, priv);
41 0 : test->priv = priv;
42 :
43 0 : priv->dev = drm_kunit_helper_alloc_device(test);
44 0 : KUNIT_ASSERT_NOT_ERR_OR_NULL(test, priv->dev);
45 :
46 0 : priv->drm = __drm_kunit_helper_alloc_drm_device(test, priv->dev,
47 : sizeof(*priv->drm), 0,
48 : DRIVER_MODESET | DRIVER_ATOMIC);
49 0 : KUNIT_ASSERT_NOT_ERR_OR_NULL(test, priv->drm);
50 :
51 0 : connector = &priv->connector;
52 0 : ret = drmm_connector_init(priv->drm, connector,
53 : &drm_probe_helper_connector_funcs,
54 : DRM_MODE_CONNECTOR_Unknown,
55 : NULL);
56 0 : KUNIT_ASSERT_EQ(test, ret, 0);
57 :
58 0 : drm_connector_helper_add(connector, &drm_probe_helper_connector_helper_funcs);
59 :
60 0 : return 0;
61 : }
62 :
63 : typedef struct drm_display_mode *(*expected_mode_func_t)(struct drm_device *);
64 :
65 : struct drm_connector_helper_tv_get_modes_test {
66 : const char *name;
67 : unsigned int supported_tv_modes;
68 : enum drm_connector_tv_mode default_mode;
69 : bool cmdline;
70 : enum drm_connector_tv_mode cmdline_mode;
71 : expected_mode_func_t *expected_modes;
72 : unsigned int num_expected_modes;
73 : };
74 :
75 : #define _TV_MODE_TEST(_name, _supported, _default, _cmdline, _cmdline_mode, ...) \
76 : { \
77 : .name = _name, \
78 : .supported_tv_modes = _supported, \
79 : .default_mode = _default, \
80 : .cmdline = _cmdline, \
81 : .cmdline_mode = _cmdline_mode, \
82 : .expected_modes = (expected_mode_func_t[]) { __VA_ARGS__ }, \
83 : .num_expected_modes = sizeof((expected_mode_func_t[]) { __VA_ARGS__ }) / \
84 : (sizeof(expected_mode_func_t)), \
85 : }
86 :
87 : #define TV_MODE_TEST(_name, _supported, _default, ...) \
88 : _TV_MODE_TEST(_name, _supported, _default, false, 0, __VA_ARGS__)
89 :
90 : #define TV_MODE_TEST_CMDLINE(_name, _supported, _default, _cmdline, ...) \
91 : _TV_MODE_TEST(_name, _supported, _default, true, _cmdline, __VA_ARGS__)
92 :
93 : static void
94 0 : drm_test_connector_helper_tv_get_modes_check(struct kunit *test)
95 : {
96 0 : const struct drm_connector_helper_tv_get_modes_test *params = test->param_value;
97 0 : struct drm_probe_helper_test_priv *priv = test->priv;
98 0 : struct drm_connector *connector = &priv->connector;
99 0 : struct drm_cmdline_mode *cmdline = &connector->cmdline_mode;
100 : struct drm_display_mode *mode;
101 : const struct drm_display_mode *expected;
102 : size_t len;
103 : int ret;
104 :
105 0 : if (params->cmdline) {
106 0 : cmdline->tv_mode_specified = true;
107 0 : cmdline->tv_mode = params->cmdline_mode;
108 : }
109 :
110 0 : ret = drm_mode_create_tv_properties(priv->drm, params->supported_tv_modes);
111 0 : KUNIT_ASSERT_EQ(test, ret, 0);
112 :
113 0 : drm_object_attach_property(&connector->base,
114 0 : priv->drm->mode_config.tv_mode_property,
115 0 : params->default_mode);
116 :
117 0 : mutex_lock(&priv->drm->mode_config.mutex);
118 :
119 0 : ret = drm_connector_helper_tv_get_modes(connector);
120 0 : KUNIT_EXPECT_EQ(test, ret, params->num_expected_modes);
121 :
122 0 : len = 0;
123 0 : list_for_each_entry(mode, &connector->probed_modes, head)
124 0 : len++;
125 0 : KUNIT_EXPECT_EQ(test, len, params->num_expected_modes);
126 :
127 0 : if (params->num_expected_modes >= 1) {
128 0 : mode = list_first_entry_or_null(&connector->probed_modes,
129 : struct drm_display_mode, head);
130 0 : KUNIT_ASSERT_NOT_NULL(test, mode);
131 :
132 0 : expected = params->expected_modes[0](priv->drm);
133 0 : KUNIT_ASSERT_NOT_NULL(test, expected);
134 :
135 0 : KUNIT_EXPECT_TRUE(test, drm_mode_equal(mode, expected));
136 0 : KUNIT_EXPECT_TRUE(test, mode->type & DRM_MODE_TYPE_PREFERRED);
137 : }
138 :
139 0 : if (params->num_expected_modes >= 2) {
140 0 : mode = list_next_entry(mode, head);
141 0 : KUNIT_ASSERT_NOT_NULL(test, mode);
142 :
143 0 : expected = params->expected_modes[1](priv->drm);
144 0 : KUNIT_ASSERT_NOT_NULL(test, expected);
145 :
146 0 : KUNIT_EXPECT_TRUE(test, drm_mode_equal(mode, expected));
147 0 : KUNIT_EXPECT_FALSE(test, mode->type & DRM_MODE_TYPE_PREFERRED);
148 : }
149 :
150 0 : mutex_unlock(&priv->drm->mode_config.mutex);
151 0 : }
152 :
153 : static const
154 : struct drm_connector_helper_tv_get_modes_test drm_connector_helper_tv_get_modes_tests[] = {
155 : { .name = "None" },
156 : TV_MODE_TEST("PAL",
157 : BIT(DRM_MODE_TV_MODE_PAL),
158 : DRM_MODE_TV_MODE_PAL,
159 : drm_mode_analog_pal_576i),
160 : TV_MODE_TEST("NTSC",
161 : BIT(DRM_MODE_TV_MODE_NTSC),
162 : DRM_MODE_TV_MODE_NTSC,
163 : drm_mode_analog_ntsc_480i),
164 : TV_MODE_TEST("Both, NTSC Default",
165 : BIT(DRM_MODE_TV_MODE_NTSC) | BIT(DRM_MODE_TV_MODE_PAL),
166 : DRM_MODE_TV_MODE_NTSC,
167 : drm_mode_analog_ntsc_480i, drm_mode_analog_pal_576i),
168 : TV_MODE_TEST("Both, PAL Default",
169 : BIT(DRM_MODE_TV_MODE_NTSC) | BIT(DRM_MODE_TV_MODE_PAL),
170 : DRM_MODE_TV_MODE_PAL,
171 : drm_mode_analog_pal_576i, drm_mode_analog_ntsc_480i),
172 : TV_MODE_TEST_CMDLINE("Both, NTSC Default, with PAL on command-line",
173 : BIT(DRM_MODE_TV_MODE_NTSC) | BIT(DRM_MODE_TV_MODE_PAL),
174 : DRM_MODE_TV_MODE_NTSC,
175 : DRM_MODE_TV_MODE_PAL,
176 : drm_mode_analog_pal_576i, drm_mode_analog_ntsc_480i),
177 : TV_MODE_TEST_CMDLINE("Both, PAL Default, with NTSC on command-line",
178 : BIT(DRM_MODE_TV_MODE_NTSC) | BIT(DRM_MODE_TV_MODE_PAL),
179 : DRM_MODE_TV_MODE_PAL,
180 : DRM_MODE_TV_MODE_NTSC,
181 : drm_mode_analog_ntsc_480i, drm_mode_analog_pal_576i),
182 : };
183 :
184 : static void
185 0 : drm_connector_helper_tv_get_modes_desc(const struct drm_connector_helper_tv_get_modes_test *t,
186 : char *desc)
187 : {
188 0 : sprintf(desc, "%s", t->name);
189 0 : }
190 :
191 0 : KUNIT_ARRAY_PARAM(drm_connector_helper_tv_get_modes,
192 : drm_connector_helper_tv_get_modes_tests,
193 : drm_connector_helper_tv_get_modes_desc);
194 :
195 : static struct kunit_case drm_test_connector_helper_tv_get_modes_tests[] = {
196 : KUNIT_CASE_PARAM(drm_test_connector_helper_tv_get_modes_check,
197 : drm_connector_helper_tv_get_modes_gen_params),
198 : { }
199 : };
200 :
201 : static struct kunit_suite drm_test_connector_helper_tv_get_modes_suite = {
202 : .name = "drm_connector_helper_tv_get_modes",
203 : .init = drm_probe_helper_test_init,
204 : .test_cases = drm_test_connector_helper_tv_get_modes_tests,
205 : };
206 :
207 : kunit_test_suite(drm_test_connector_helper_tv_get_modes_suite);
208 :
209 : MODULE_AUTHOR("Maxime Ripard <maxime@cerno.tech>");
210 : MODULE_LICENSE("GPL");
|
