Loading...
Note: File does not exist in v3.1.
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_drv.h>
6#include <drm/drm_fourcc.h>
7#include <drm/drm_kunit_helpers.h>
8#include <drm/drm_managed.h>
9
10#include <kunit/device.h>
11#include <kunit/resource.h>
12
13#include <linux/device.h>
14#include <linux/platform_device.h>
15
16#define KUNIT_DEVICE_NAME "drm-kunit-mock-device"
17
18static const struct drm_mode_config_funcs drm_mode_config_funcs = {
19 .atomic_check = drm_atomic_helper_check,
20 .atomic_commit = drm_atomic_helper_commit,
21};
22
23/**
24 * drm_kunit_helper_alloc_device - Allocate a mock device for a KUnit test
25 * @test: The test context object
26 *
27 * This allocates a fake struct &device to create a mock for a KUnit
28 * test. The device will also be bound to a fake driver. It will thus be
29 * able to leverage the usual infrastructure and most notably the
30 * device-managed resources just like a "real" device.
31 *
32 * Resources will be cleaned up automatically, but the removal can be
33 * forced using @drm_kunit_helper_free_device.
34 *
35 * Returns:
36 * A pointer to the new device, or an ERR_PTR() otherwise.
37 */
38struct device *drm_kunit_helper_alloc_device(struct kunit *test)
39{
40 return kunit_device_register(test, KUNIT_DEVICE_NAME);
41}
42EXPORT_SYMBOL_GPL(drm_kunit_helper_alloc_device);
43
44/**
45 * drm_kunit_helper_free_device - Frees a mock device
46 * @test: The test context object
47 * @dev: The device to free
48 *
49 * Frees a device allocated with drm_kunit_helper_alloc_device().
50 */
51void drm_kunit_helper_free_device(struct kunit *test, struct device *dev)
52{
53 kunit_device_unregister(test, dev);
54}
55EXPORT_SYMBOL_GPL(drm_kunit_helper_free_device);
56
57struct drm_device *
58__drm_kunit_helper_alloc_drm_device_with_driver(struct kunit *test,
59 struct device *dev,
60 size_t size, size_t offset,
61 const struct drm_driver *driver)
62{
63 struct drm_device *drm;
64 void *container;
65 int ret;
66
67 container = __devm_drm_dev_alloc(dev, driver, size, offset);
68 if (IS_ERR(container))
69 return ERR_CAST(container);
70
71 drm = container + offset;
72 drm->mode_config.funcs = &drm_mode_config_funcs;
73
74 ret = drmm_mode_config_init(drm);
75 if (ret)
76 return ERR_PTR(ret);
77
78 return drm;
79}
80EXPORT_SYMBOL_GPL(__drm_kunit_helper_alloc_drm_device_with_driver);
81
82static void action_drm_release_context(void *ptr)
83{
84 struct drm_modeset_acquire_ctx *ctx = ptr;
85
86 drm_modeset_drop_locks(ctx);
87 drm_modeset_acquire_fini(ctx);
88}
89
90/**
91 * drm_kunit_helper_acquire_ctx_alloc - Allocates an acquire context
92 * @test: The test context object
93 *
94 * Allocates and initializes a modeset acquire context.
95 *
96 * The context is tied to the kunit test context, so we must not call
97 * drm_modeset_acquire_fini() on it, it will be done so automatically.
98 *
99 * Returns:
100 * An ERR_PTR on error, a pointer to the newly allocated context otherwise
101 */
102struct drm_modeset_acquire_ctx *
103drm_kunit_helper_acquire_ctx_alloc(struct kunit *test)
104{
105 struct drm_modeset_acquire_ctx *ctx;
106 int ret;
107
108 ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
109 KUNIT_ASSERT_NOT_NULL(test, ctx);
110
111 drm_modeset_acquire_init(ctx, 0);
112
113 ret = kunit_add_action_or_reset(test,
114 action_drm_release_context,
115 ctx);
116 if (ret)
117 return ERR_PTR(ret);
118
119 return ctx;
120}
121EXPORT_SYMBOL_GPL(drm_kunit_helper_acquire_ctx_alloc);
122
123static void kunit_action_drm_atomic_state_put(void *ptr)
124{
125 struct drm_atomic_state *state = ptr;
126
127 drm_atomic_state_put(state);
128}
129
130/**
131 * drm_kunit_helper_atomic_state_alloc - Allocates an atomic state
132 * @test: The test context object
133 * @drm: The device to alloc the state for
134 * @ctx: Locking context for that atomic update
135 *
136 * Allocates a empty atomic state.
137 *
138 * The state is tied to the kunit test context, so we must not call
139 * drm_atomic_state_put() on it, it will be done so automatically.
140 *
141 * Returns:
142 * An ERR_PTR on error, a pointer to the newly allocated state otherwise
143 */
144struct drm_atomic_state *
145drm_kunit_helper_atomic_state_alloc(struct kunit *test,
146 struct drm_device *drm,
147 struct drm_modeset_acquire_ctx *ctx)
148{
149 struct drm_atomic_state *state;
150 int ret;
151
152 state = drm_atomic_state_alloc(drm);
153 if (!state)
154 return ERR_PTR(-ENOMEM);
155
156 ret = kunit_add_action_or_reset(test,
157 kunit_action_drm_atomic_state_put,
158 state);
159 if (ret)
160 return ERR_PTR(ret);
161
162 state->acquire_ctx = ctx;
163
164 return state;
165}
166EXPORT_SYMBOL_GPL(drm_kunit_helper_atomic_state_alloc);
167
168static const uint32_t default_plane_formats[] = {
169 DRM_FORMAT_XRGB8888,
170};
171
172static const uint64_t default_plane_modifiers[] = {
173 DRM_FORMAT_MOD_LINEAR,
174 DRM_FORMAT_MOD_INVALID
175};
176
177static const struct drm_plane_helper_funcs default_plane_helper_funcs = {
178};
179
180static const struct drm_plane_funcs default_plane_funcs = {
181 .atomic_destroy_state = drm_atomic_helper_plane_destroy_state,
182 .atomic_duplicate_state = drm_atomic_helper_plane_duplicate_state,
183 .reset = drm_atomic_helper_plane_reset,
184};
185
186/**
187 * drm_kunit_helper_create_primary_plane - Creates a mock primary plane for a KUnit test
188 * @test: The test context object
189 * @drm: The device to alloc the plane for
190 * @funcs: Callbacks for the new plane. Optional.
191 * @helper_funcs: Helpers callbacks for the new plane. Optional.
192 * @formats: array of supported formats (DRM_FORMAT\_\*). Optional.
193 * @num_formats: number of elements in @formats
194 * @modifiers: array of struct drm_format modifiers terminated by
195 * DRM_FORMAT_MOD_INVALID. Optional.
196 *
197 * This allocates and initializes a mock struct &drm_plane meant to be
198 * part of a mock device for a KUnit test.
199 *
200 * Resources will be cleaned up automatically.
201 *
202 * @funcs will default to the default helpers implementations.
203 * @helper_funcs will default to an empty implementation. @formats will
204 * default to XRGB8888 only. @modifiers will default to a linear
205 * modifier only.
206 *
207 * Returns:
208 * A pointer to the new plane, or an ERR_PTR() otherwise.
209 */
210struct drm_plane *
211drm_kunit_helper_create_primary_plane(struct kunit *test,
212 struct drm_device *drm,
213 const struct drm_plane_funcs *funcs,
214 const struct drm_plane_helper_funcs *helper_funcs,
215 const uint32_t *formats,
216 unsigned int num_formats,
217 const uint64_t *modifiers)
218{
219 struct drm_plane *plane;
220
221 if (!funcs)
222 funcs = &default_plane_funcs;
223
224 if (!helper_funcs)
225 helper_funcs = &default_plane_helper_funcs;
226
227 if (!formats || !num_formats) {
228 formats = default_plane_formats;
229 num_formats = ARRAY_SIZE(default_plane_formats);
230 }
231
232 if (!modifiers)
233 modifiers = default_plane_modifiers;
234
235 plane = __drmm_universal_plane_alloc(drm,
236 sizeof(struct drm_plane), 0,
237 0,
238 funcs,
239 formats,
240 num_formats,
241 default_plane_modifiers,
242 DRM_PLANE_TYPE_PRIMARY,
243 NULL);
244 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, plane);
245
246 drm_plane_helper_add(plane, helper_funcs);
247
248 return plane;
249}
250EXPORT_SYMBOL_GPL(drm_kunit_helper_create_primary_plane);
251
252static const struct drm_crtc_helper_funcs default_crtc_helper_funcs = {
253};
254
255static const struct drm_crtc_funcs default_crtc_funcs = {
256 .atomic_destroy_state = drm_atomic_helper_crtc_destroy_state,
257 .atomic_duplicate_state = drm_atomic_helper_crtc_duplicate_state,
258 .reset = drm_atomic_helper_crtc_reset,
259};
260
261/**
262 * drm_kunit_helper_create_crtc - Creates a mock CRTC for a KUnit test
263 * @test: The test context object
264 * @drm: The device to alloc the plane for
265 * @primary: Primary plane for CRTC
266 * @cursor: Cursor plane for CRTC. Optional.
267 * @funcs: Callbacks for the new plane. Optional.
268 * @helper_funcs: Helpers callbacks for the new plane. Optional.
269 *
270 * This allocates and initializes a mock struct &drm_crtc meant to be
271 * part of a mock device for a KUnit test.
272 *
273 * Resources will be cleaned up automatically.
274 *
275 * @funcs will default to the default helpers implementations.
276 * @helper_funcs will default to an empty implementation.
277 *
278 * Returns:
279 * A pointer to the new CRTC, or an ERR_PTR() otherwise.
280 */
281struct drm_crtc *
282drm_kunit_helper_create_crtc(struct kunit *test,
283 struct drm_device *drm,
284 struct drm_plane *primary,
285 struct drm_plane *cursor,
286 const struct drm_crtc_funcs *funcs,
287 const struct drm_crtc_helper_funcs *helper_funcs)
288{
289 struct drm_crtc *crtc;
290 int ret;
291
292 if (!funcs)
293 funcs = &default_crtc_funcs;
294
295 if (!helper_funcs)
296 helper_funcs = &default_crtc_helper_funcs;
297
298 crtc = drmm_kzalloc(drm, sizeof(*crtc), GFP_KERNEL);
299 KUNIT_ASSERT_NOT_NULL(test, crtc);
300
301 ret = drmm_crtc_init_with_planes(drm, crtc,
302 primary,
303 cursor,
304 funcs,
305 NULL);
306 KUNIT_ASSERT_EQ(test, ret, 0);
307
308 drm_crtc_helper_add(crtc, helper_funcs);
309
310 return crtc;
311}
312EXPORT_SYMBOL_GPL(drm_kunit_helper_create_crtc);
313
314MODULE_AUTHOR("Maxime Ripard <maxime@cerno.tech>");
315MODULE_LICENSE("GPL");