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
 14struct drm_test_modes_priv {
 15	struct drm_device *drm;
 16	struct device *dev;
 17};
 18
 19static 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
 39static 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
 69static 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
 86static 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
116static 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
133static 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
163static 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
172static 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
178kunit_test_suite(drm_modes_analog_tv_test_suite);
179
180MODULE_AUTHOR("Maxime Ripard <maxime@cerno.tech>");
181MODULE_DESCRIPTION("Kunit test for drm_modes functions");
182MODULE_LICENSE("GPL");