1// SPDX-License-Identifier: GPL-2.0
2
3#include <drm/drm_atomic.h>
4#include <drm/drm_atomic_helper.h>
5#include <drm/drm_atomic_uapi.h>
6#include <drm/drm_drv.h>
7#include <drm/drm_edid.h>
8#include <drm/drm_fourcc.h>
9#include <drm/drm_kunit_helpers.h>
10#include <drm/drm_managed.h>
11
12#include <kunit/device.h>
13#include <kunit/resource.h>
14
15#include <linux/device.h>
16#include <linux/export.h>
17#include <linux/platform_device.h>
18
19#define KUNIT_DEVICE_NAME "drm-kunit-mock-device"
20
21static const struct drm_mode_config_funcs drm_mode_config_funcs = {
22 .atomic_check = drm_atomic_helper_check,
23 .atomic_commit = drm_atomic_helper_commit,
24};
25
26/**
27 * drm_kunit_helper_alloc_device - Allocate a mock device for a KUnit test
28 * @test: The test context object
29 *
30 * This allocates a fake struct &device to create a mock for a KUnit
31 * test. The device will also be bound to a fake driver. It will thus be
32 * able to leverage the usual infrastructure and most notably the
33 * device-managed resources just like a "real" device.
34 *
35 * Resources will be cleaned up automatically, but the removal can be
36 * forced using @drm_kunit_helper_free_device.
37 *
38 * Returns:
39 * A pointer to the new device, or an ERR_PTR() otherwise.
40 */
41struct device *drm_kunit_helper_alloc_device(struct kunit *test)
42{
43 return kunit_device_register(test, KUNIT_DEVICE_NAME);
44}
45EXPORT_SYMBOL_GPL(drm_kunit_helper_alloc_device);
46
47/**
48 * drm_kunit_helper_free_device - Frees a mock device
49 * @test: The test context object
50 * @dev: The device to free
51 *
52 * Frees a device allocated with drm_kunit_helper_alloc_device().
53 */
54void drm_kunit_helper_free_device(struct kunit *test, struct device *dev)
55{
56 kunit_device_unregister(test, dev);
57}
58EXPORT_SYMBOL_GPL(drm_kunit_helper_free_device);
59
60struct drm_device *
61__drm_kunit_helper_alloc_drm_device_with_driver(struct kunit *test,
62 struct device *dev,
63 size_t size, size_t offset,
64 const struct drm_driver *driver)
65{
66 struct drm_device *drm;
67 void *container;
68 int ret;
69
70 container = __devm_drm_dev_alloc(parent: dev, driver, size, offset);
71 if (IS_ERR(ptr: container))
72 return ERR_CAST(ptr: container);
73
74 drm = container + offset;
75 drm->mode_config.funcs = &drm_mode_config_funcs;
76
77 ret = drmm_mode_config_init(dev: drm);
78 if (ret)
79 return ERR_PTR(error: ret);
80
81 return drm;
82}
83EXPORT_SYMBOL_GPL(__drm_kunit_helper_alloc_drm_device_with_driver);
84
85static void kunit_action_drm_atomic_state_put(void *ptr)
86{
87 struct drm_atomic_state *state = ptr;
88
89 drm_atomic_state_put(state);
90}
91
92/**
93 * drm_kunit_helper_atomic_state_alloc - Allocates an atomic state
94 * @test: The test context object
95 * @drm: The device to alloc the state for
96 * @ctx: Locking context for that atomic update
97 *
98 * Allocates a empty atomic state.
99 *
100 * The state is tied to the kunit test context, so we must not call
101 * drm_atomic_state_put() on it, it will be done so automatically.
102 *
103 * Returns:
104 * An ERR_PTR on error, a pointer to the newly allocated state otherwise
105 */
106struct drm_atomic_state *
107drm_kunit_helper_atomic_state_alloc(struct kunit *test,
108 struct drm_device *drm,
109 struct drm_modeset_acquire_ctx *ctx)
110{
111 struct drm_atomic_state *state;
112 int ret;
113
114 state = drm_atomic_state_alloc(dev: drm);
115 if (!state)
116 return ERR_PTR(error: -ENOMEM);
117
118 ret = kunit_add_action_or_reset(test,
119 action: kunit_action_drm_atomic_state_put,
120 ctx: state);
121 if (ret)
122 return ERR_PTR(error: ret);
123
124 state->acquire_ctx = ctx;
125
126 return state;
127}
128EXPORT_SYMBOL_GPL(drm_kunit_helper_atomic_state_alloc);
129
130static const uint32_t default_plane_formats[] = {
131 DRM_FORMAT_XRGB8888,
132};
133
134static const uint64_t default_plane_modifiers[] = {
135 DRM_FORMAT_MOD_LINEAR,
136 DRM_FORMAT_MOD_INVALID
137};
138
139static const struct drm_plane_helper_funcs default_plane_helper_funcs = {
140};
141
142static const struct drm_plane_funcs default_plane_funcs = {
143 .atomic_destroy_state = drm_atomic_helper_plane_destroy_state,
144 .atomic_duplicate_state = drm_atomic_helper_plane_duplicate_state,
145 .reset = drm_atomic_helper_plane_reset,
146};
147
148/**
149 * drm_kunit_helper_create_primary_plane - Creates a mock primary plane for a KUnit test
150 * @test: The test context object
151 * @drm: The device to alloc the plane for
152 * @funcs: Callbacks for the new plane. Optional.
153 * @helper_funcs: Helpers callbacks for the new plane. Optional.
154 * @formats: array of supported formats (DRM_FORMAT\_\*). Optional.
155 * @num_formats: number of elements in @formats
156 * @modifiers: array of struct drm_format modifiers terminated by
157 * DRM_FORMAT_MOD_INVALID. Optional.
158 *
159 * This allocates and initializes a mock struct &drm_plane meant to be
160 * part of a mock device for a KUnit test.
161 *
162 * Resources will be cleaned up automatically.
163 *
164 * @funcs will default to the default helpers implementations.
165 * @helper_funcs will default to an empty implementation. @formats will
166 * default to XRGB8888 only. @modifiers will default to a linear
167 * modifier only.
168 *
169 * Returns:
170 * A pointer to the new plane, or an ERR_PTR() otherwise.
171 */
172struct drm_plane *
173drm_kunit_helper_create_primary_plane(struct kunit *test,
174 struct drm_device *drm,
175 const struct drm_plane_funcs *funcs,
176 const struct drm_plane_helper_funcs *helper_funcs,
177 const uint32_t *formats,
178 unsigned int num_formats,
179 const uint64_t *modifiers)
180{
181 struct drm_plane *plane;
182
183 if (!funcs)
184 funcs = &default_plane_funcs;
185
186 if (!helper_funcs)
187 helper_funcs = &default_plane_helper_funcs;
188
189 if (!formats || !num_formats) {
190 formats = default_plane_formats;
191 num_formats = ARRAY_SIZE(default_plane_formats);
192 }
193
194 if (!modifiers)
195 modifiers = default_plane_modifiers;
196
197 plane = __drmm_universal_plane_alloc(dev: drm,
198 size: sizeof(struct drm_plane), offset: 0,
199 possible_crtcs: 0,
200 funcs,
201 formats,
202 format_count: num_formats,
203 format_modifiers: default_plane_modifiers,
204 plane_type: DRM_PLANE_TYPE_PRIMARY,
205 NULL);
206 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, plane);
207
208 drm_plane_helper_add(plane, funcs: helper_funcs);
209
210 return plane;
211}
212EXPORT_SYMBOL_GPL(drm_kunit_helper_create_primary_plane);
213
214static const struct drm_crtc_helper_funcs default_crtc_helper_funcs = {
215};
216
217static const struct drm_crtc_funcs default_crtc_funcs = {
218 .atomic_destroy_state = drm_atomic_helper_crtc_destroy_state,
219 .atomic_duplicate_state = drm_atomic_helper_crtc_duplicate_state,
220 .reset = drm_atomic_helper_crtc_reset,
221};
222
223/**
224 * drm_kunit_helper_create_crtc - Creates a mock CRTC for a KUnit test
225 * @test: The test context object
226 * @drm: The device to alloc the plane for
227 * @primary: Primary plane for CRTC
228 * @cursor: Cursor plane for CRTC. Optional.
229 * @funcs: Callbacks for the new plane. Optional.
230 * @helper_funcs: Helpers callbacks for the new plane. Optional.
231 *
232 * This allocates and initializes a mock struct &drm_crtc meant to be
233 * part of a mock device for a KUnit test.
234 *
235 * Resources will be cleaned up automatically.
236 *
237 * @funcs will default to the default helpers implementations.
238 * @helper_funcs will default to an empty implementation.
239 *
240 * Returns:
241 * A pointer to the new CRTC, or an ERR_PTR() otherwise.
242 */
243struct drm_crtc *
244drm_kunit_helper_create_crtc(struct kunit *test,
245 struct drm_device *drm,
246 struct drm_plane *primary,
247 struct drm_plane *cursor,
248 const struct drm_crtc_funcs *funcs,
249 const struct drm_crtc_helper_funcs *helper_funcs)
250{
251 struct drm_crtc *crtc;
252 int ret;
253
254 if (!funcs)
255 funcs = &default_crtc_funcs;
256
257 if (!helper_funcs)
258 helper_funcs = &default_crtc_helper_funcs;
259
260 crtc = drmm_kzalloc(dev: drm, size: sizeof(*crtc), GFP_KERNEL);
261 KUNIT_ASSERT_NOT_NULL(test, crtc);
262
263 ret = drmm_crtc_init_with_planes(dev: drm, crtc,
264 primary,
265 cursor,
266 funcs,
267 NULL);
268 KUNIT_ASSERT_EQ(test, ret, 0);
269
270 drm_crtc_helper_add(crtc, funcs: helper_funcs);
271
272 return crtc;
273}
274EXPORT_SYMBOL_GPL(drm_kunit_helper_create_crtc);
275
276/**
277 * drm_kunit_helper_enable_crtc_connector - Enables a CRTC -> Connector output
278 * @test: The test context object
279 * @drm: The device to alloc the plane for
280 * @crtc: The CRTC to enable
281 * @connector: The Connector to enable
282 * @mode: The display mode to configure the CRTC with
283 * @ctx: Locking context
284 *
285 * This function creates an atomic update to enable the route from @crtc
286 * to @connector, with the given @mode.
287 *
288 * Returns:
289 *
290 * A pointer to the new CRTC, or an ERR_PTR() otherwise. If the error
291 * returned is EDEADLK, the entire atomic sequence must be restarted.
292 */
293int drm_kunit_helper_enable_crtc_connector(struct kunit *test,
294 struct drm_device *drm,
295 struct drm_crtc *crtc,
296 struct drm_connector *connector,
297 const struct drm_display_mode *mode,
298 struct drm_modeset_acquire_ctx *ctx)
299{
300 struct drm_atomic_state *state;
301 struct drm_connector_state *conn_state;
302 struct drm_crtc_state *crtc_state;
303 int ret;
304
305 state = drm_kunit_helper_atomic_state_alloc(test, drm, ctx);
306 if (IS_ERR(ptr: state))
307 return PTR_ERR(ptr: state);
308
309 conn_state = drm_atomic_get_connector_state(state, connector);
310 if (IS_ERR(ptr: conn_state))
311 return PTR_ERR(ptr: conn_state);
312
313 ret = drm_atomic_set_crtc_for_connector(conn_state, crtc);
314 if (ret)
315 return ret;
316
317 crtc_state = drm_atomic_get_crtc_state(state, crtc);
318 if (IS_ERR(ptr: crtc_state))
319 return PTR_ERR(ptr: crtc_state);
320
321 ret = drm_atomic_set_mode_for_crtc(state: crtc_state, mode);
322 if (ret)
323 return ret;
324
325 crtc_state->enable = true;
326 crtc_state->active = true;
327
328 ret = drm_atomic_commit(state);
329 if (ret)
330 return ret;
331
332 return 0;
333}
334EXPORT_SYMBOL_GPL(drm_kunit_helper_enable_crtc_connector);
335
336static void kunit_action_drm_mode_destroy(void *ptr)
337{
338 struct drm_display_mode *mode = ptr;
339
340 drm_mode_destroy(NULL, mode);
341}
342
343/**
344 * drm_kunit_add_mode_destroy_action() - Add a drm_destroy_mode kunit action
345 * @test: The test context object
346 * @mode: The drm_display_mode to destroy eventually
347 *
348 * Registers a kunit action that will destroy the drm_display_mode at
349 * the end of the test.
350 *
351 * If an error occurs, the drm_display_mode will be destroyed.
352 *
353 * Returns:
354 * 0 on success, an error code otherwise.
355 */
356int drm_kunit_add_mode_destroy_action(struct kunit *test,
357 struct drm_display_mode *mode)
358{
359 return kunit_add_action_or_reset(test,
360 action: kunit_action_drm_mode_destroy,
361 ctx: mode);
362}
363EXPORT_SYMBOL_GPL(drm_kunit_add_mode_destroy_action);
364
365/**
366 * drm_kunit_display_mode_from_cea_vic() - return a mode for CEA VIC for a KUnit test
367 * @test: The test context object
368 * @dev: DRM device
369 * @video_code: CEA VIC of the mode
370 *
371 * Creates a new mode matching the specified CEA VIC for a KUnit test.
372 *
373 * Resources will be cleaned up automatically.
374 *
375 * Returns: A new drm_display_mode on success or NULL on failure
376 */
377struct drm_display_mode *
378drm_kunit_display_mode_from_cea_vic(struct kunit *test, struct drm_device *dev,
379 u8 video_code)
380{
381 struct drm_display_mode *mode;
382 int ret;
383
384 mode = drm_display_mode_from_cea_vic(dev, video_code);
385 if (!mode)
386 return NULL;
387
388 ret = kunit_add_action_or_reset(test,
389 action: kunit_action_drm_mode_destroy,
390 ctx: mode);
391 if (ret)
392 return NULL;
393
394 return mode;
395}
396EXPORT_SYMBOL_GPL(drm_kunit_display_mode_from_cea_vic);
397
398MODULE_AUTHOR("Maxime Ripard <maxime@cerno.tech>");
399MODULE_DESCRIPTION("KUnit test suite helper functions");
400MODULE_LICENSE("GPL");
401

source code of linux/drivers/gpu/drm/tests/drm_kunit_helpers.c