1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Kunit test for drm_modes functions
4 */
5
6 #include <drm/drm_drv.h>
7 #include <drm/drm_kunit_helpers.h>
8 #include <drm/drm_modes.h>
9
10 #include <kunit/test.h>
11
12 #include <linux/units.h>
13
14 struct drm_test_modes_priv {
15 struct drm_device *drm;
16 struct device *dev;
17 };
18
drm_test_modes_init(struct kunit * test)19 static int drm_test_modes_init(struct kunit *test)
20 {
21 struct drm_test_modes_priv *priv;
22
23 priv = kunit_kzalloc(test, sizeof(*priv), GFP_KERNEL);
24 KUNIT_ASSERT_NOT_NULL(test, priv);
25
26 priv->dev = drm_kunit_helper_alloc_device(test);
27 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, priv->dev);
28
29 priv->drm = __drm_kunit_helper_alloc_drm_device(test, priv->dev,
30 sizeof(*priv->drm), 0,
31 DRIVER_MODESET);
32 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, priv->drm);
33
34 test->priv = priv;
35
36 return 0;
37 }
38
drm_test_modes_analog_tv_ntsc_480i(struct kunit * test)39 static void drm_test_modes_analog_tv_ntsc_480i(struct kunit *test)
40 {
41 struct drm_test_modes_priv *priv = test->priv;
42 struct drm_display_mode *mode;
43
44 mode = drm_analog_tv_mode(priv->drm,
45 DRM_MODE_TV_MODE_NTSC,
46 13500 * HZ_PER_KHZ, 720, 480,
47 true);
48 KUNIT_ASSERT_NOT_NULL(test, mode);
49
50 KUNIT_EXPECT_EQ(test, drm_mode_vrefresh(mode), 60);
51 KUNIT_EXPECT_EQ(test, mode->hdisplay, 720);
52
53 /* BT.601 defines hsync_start at 736 for 480i */
54 KUNIT_EXPECT_EQ(test, mode->hsync_start, 736);
55
56 /*
57 * The NTSC standard expects a line to take 63.556us. With a
58 * pixel clock of 13.5 MHz, a pixel takes around 74ns, so we
59 * need to have 63556ns / 74ns = 858.
60 *
61 * This is also mandated by BT.601.
62 */
63 KUNIT_EXPECT_EQ(test, mode->htotal, 858);
64
65 KUNIT_EXPECT_EQ(test, mode->vdisplay, 480);
66 KUNIT_EXPECT_EQ(test, mode->vtotal, 525);
67 }
68
drm_test_modes_analog_tv_ntsc_480i_inlined(struct kunit * test)69 static void drm_test_modes_analog_tv_ntsc_480i_inlined(struct kunit *test)
70 {
71 struct drm_test_modes_priv *priv = test->priv;
72 struct drm_display_mode *expected, *mode;
73
74 expected = drm_analog_tv_mode(priv->drm,
75 DRM_MODE_TV_MODE_NTSC,
76 13500 * HZ_PER_KHZ, 720, 480,
77 true);
78 KUNIT_ASSERT_NOT_NULL(test, expected);
79
80 mode = drm_mode_analog_ntsc_480i(priv->drm);
81 KUNIT_ASSERT_NOT_NULL(test, mode);
82
83 KUNIT_EXPECT_TRUE(test, drm_mode_equal(expected, mode));
84 }
85
drm_test_modes_analog_tv_pal_576i(struct kunit * test)86 static void drm_test_modes_analog_tv_pal_576i(struct kunit *test)
87 {
88 struct drm_test_modes_priv *priv = test->priv;
89 struct drm_display_mode *mode;
90
91 mode = drm_analog_tv_mode(priv->drm,
92 DRM_MODE_TV_MODE_PAL,
93 13500 * HZ_PER_KHZ, 720, 576,
94 true);
95 KUNIT_ASSERT_NOT_NULL(test, mode);
96
97 KUNIT_EXPECT_EQ(test, drm_mode_vrefresh(mode), 50);
98 KUNIT_EXPECT_EQ(test, mode->hdisplay, 720);
99
100 /* BT.601 defines hsync_start at 732 for 576i */
101 KUNIT_EXPECT_EQ(test, mode->hsync_start, 732);
102
103 /*
104 * The PAL standard expects a line to take 64us. With a pixel
105 * clock of 13.5 MHz, a pixel takes around 74ns, so we need to
106 * have 64000ns / 74ns = 864.
107 *
108 * This is also mandated by BT.601.
109 */
110 KUNIT_EXPECT_EQ(test, mode->htotal, 864);
111
112 KUNIT_EXPECT_EQ(test, mode->vdisplay, 576);
113 KUNIT_EXPECT_EQ(test, mode->vtotal, 625);
114 }
115
drm_test_modes_analog_tv_pal_576i_inlined(struct kunit * test)116 static void drm_test_modes_analog_tv_pal_576i_inlined(struct kunit *test)
117 {
118 struct drm_test_modes_priv *priv = test->priv;
119 struct drm_display_mode *expected, *mode;
120
121 expected = drm_analog_tv_mode(priv->drm,
122 DRM_MODE_TV_MODE_PAL,
123 13500 * HZ_PER_KHZ, 720, 576,
124 true);
125 KUNIT_ASSERT_NOT_NULL(test, expected);
126
127 mode = drm_mode_analog_pal_576i(priv->drm);
128 KUNIT_ASSERT_NOT_NULL(test, mode);
129
130 KUNIT_EXPECT_TRUE(test, drm_mode_equal(expected, mode));
131 }
132
drm_test_modes_analog_tv_mono_576i(struct kunit * test)133 static void drm_test_modes_analog_tv_mono_576i(struct kunit *test)
134 {
135 struct drm_test_modes_priv *priv = test->priv;
136 struct drm_display_mode *mode;
137
138 mode = drm_analog_tv_mode(priv->drm,
139 DRM_MODE_TV_MODE_MONOCHROME,
140 13500 * HZ_PER_KHZ, 720, 576,
141 true);
142 KUNIT_ASSERT_NOT_NULL(test, mode);
143
144 KUNIT_EXPECT_EQ(test, drm_mode_vrefresh(mode), 50);
145 KUNIT_EXPECT_EQ(test, mode->hdisplay, 720);
146
147 /* BT.601 defines hsync_start at 732 for 576i */
148 KUNIT_EXPECT_EQ(test, mode->hsync_start, 732);
149
150 /*
151 * The PAL standard expects a line to take 64us. With a pixel
152 * clock of 13.5 MHz, a pixel takes around 74ns, so we need to
153 * have 64000ns / 74ns = 864.
154 *
155 * This is also mandated by BT.601.
156 */
157 KUNIT_EXPECT_EQ(test, mode->htotal, 864);
158
159 KUNIT_EXPECT_EQ(test, mode->vdisplay, 576);
160 KUNIT_EXPECT_EQ(test, mode->vtotal, 625);
161 }
162
163 static struct kunit_case drm_modes_analog_tv_tests[] = {
164 KUNIT_CASE(drm_test_modes_analog_tv_mono_576i),
165 KUNIT_CASE(drm_test_modes_analog_tv_ntsc_480i),
166 KUNIT_CASE(drm_test_modes_analog_tv_ntsc_480i_inlined),
167 KUNIT_CASE(drm_test_modes_analog_tv_pal_576i),
168 KUNIT_CASE(drm_test_modes_analog_tv_pal_576i_inlined),
169 { }
170 };
171
172 static struct kunit_suite drm_modes_analog_tv_test_suite = {
173 .name = "drm_modes_analog_tv",
174 .init = drm_test_modes_init,
175 .test_cases = drm_modes_analog_tv_tests,
176 };
177
178 kunit_test_suite(drm_modes_analog_tv_test_suite);
179
180 MODULE_AUTHOR("Maxime Ripard <maxime@cerno.tech>");
181 MODULE_DESCRIPTION("Kunit test for drm_modes functions");
182 MODULE_LICENSE("GPL");
183