projects/linux·blob master · refs

1386 lines · 40.5 KiB

1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Kunit test for drm_bridge functions
4 */
5#include <linux/cleanup.h>
6#include <linux/media-bus-format.h>
7
8#include <drm/drm_atomic_helper.h>
9#include <drm/drm_atomic_state_helper.h>
10#include <drm/drm_atomic_uapi.h>
11#include <drm/drm_bridge.h>
12#include <drm/drm_bridge_connector.h>
13#include <drm/drm_bridge_helper.h>
14#include <drm/drm_edid.h>
15#include <drm/drm_kunit_helpers.h>
16#include <drm/drm_managed.h>
17
18#include <kunit/device.h>
19#include <kunit/test.h>
20
21#include "drm_kunit_edid.h"
22
23/*
24 * Mimick the typical "private" struct defined by a bridge driver, which
25 * embeds a bridge plus other fields.
26 *
27 * Having at least one member before @bridge ensures we test non-zero
28 * @bridge offset.
29 */
30struct drm_bridge_priv {
31 unsigned int enable_count;
32 unsigned int disable_count;
33 struct drm_bridge bridge;
34 void *data;
35};
36
37struct drm_bridge_init_priv {
38 struct drm_device drm;
39 /** @dev: device, only for tests not needing a whole drm_device */
40 struct device *dev;
41 struct drm_plane *plane;
42 struct drm_crtc *crtc;
43 struct drm_encoder encoder;
44 struct drm_bridge_priv *test_bridge;
45 struct drm_connector *connector;
46 bool destroyed;
47};
48
49struct drm_bridge_chain_priv {
50 struct drm_device drm;
51 struct drm_encoder encoder;
52 struct drm_plane *plane;
53 struct drm_crtc *crtc;
54 struct drm_connector *connector;
55 unsigned int num_bridges;
56
57 /**
58 * @test_bridges: array of pointers to &struct drm_bridge_priv entries
59 * of which the first @num_bridges entries are valid.
60 */
61 struct drm_bridge_priv **test_bridges;
62};
63
64static struct drm_bridge_priv *bridge_to_priv(struct drm_bridge *bridge)
65{
66 return container_of(bridge, struct drm_bridge_priv, bridge);
67}
68
69static void drm_test_bridge_priv_destroy(struct drm_bridge *bridge)
70{
71 struct drm_bridge_priv *bridge_priv = bridge_to_priv(bridge);
72 struct drm_bridge_init_priv *priv = (struct drm_bridge_init_priv *)bridge_priv->data;
73
74 priv->destroyed = true;
75}
76
77static void drm_test_bridge_atomic_enable(struct drm_bridge *bridge,
78 struct drm_atomic_commit *state)
79{
80 struct drm_bridge_priv *priv = bridge_to_priv(bridge);
81
82 priv->enable_count++;
83}
84
85static void drm_test_bridge_atomic_disable(struct drm_bridge *bridge,
86 struct drm_atomic_commit *state)
87{
88 struct drm_bridge_priv *priv = bridge_to_priv(bridge);
89
90 priv->disable_count++;
91}
92
93static const struct drm_bridge_funcs drm_test_bridge_atomic_funcs = {
94 .destroy = drm_test_bridge_priv_destroy,
95 .atomic_enable = drm_test_bridge_atomic_enable,
96 .atomic_disable = drm_test_bridge_atomic_disable,
97 .atomic_destroy_state = drm_atomic_helper_bridge_destroy_state,
98 .atomic_duplicate_state = drm_atomic_helper_bridge_duplicate_state,
99 .atomic_create_state = drm_atomic_helper_bridge_create_state,
100};
101
102static int dummy_clear_infoframe(struct drm_bridge *bridge)
103{
104 return 0;
105}
106
107static int dummy_write_infoframe(struct drm_bridge *bridge, const u8 *buffer,
108 size_t len)
109{
110 return 0;
111}
112
113static const struct drm_bridge_funcs drm_test_bridge_bus_fmts_funcs = {
114 .atomic_get_output_bus_fmts = drm_atomic_helper_bridge_get_hdmi_output_bus_fmts,
115 .atomic_destroy_state = drm_atomic_helper_bridge_destroy_state,
116 .atomic_duplicate_state = drm_atomic_helper_bridge_duplicate_state,
117 .atomic_create_state = drm_atomic_helper_bridge_create_state,
118 .hdmi_write_avi_infoframe = dummy_write_infoframe,
119 .hdmi_write_hdmi_infoframe = dummy_write_infoframe,
120 .hdmi_clear_avi_infoframe = dummy_clear_infoframe,
121 .hdmi_clear_hdmi_infoframe = dummy_clear_infoframe,
122};
123
124/**
125 * struct fmt_tuple - a tuple of input/output MEDIA_BUS_FMT_*
126 */
127struct fmt_tuple {
128 u32 in_fmt;
129 u32 out_fmt;
130};
131
132/*
133 * Format mapping that only accepts RGB888, and outputs only RGB888
134 */
135static const struct fmt_tuple rgb8_passthrough[] = {
136 { MEDIA_BUS_FMT_RGB888_1X24, MEDIA_BUS_FMT_RGB888_1X24 },
137};
138
139/*
140 * Format mapping that only accepts YUV444, and outputs only YUV444
141 */
142static const struct fmt_tuple yuv8_passthrough[] = {
143 { MEDIA_BUS_FMT_YUV8_1X24, MEDIA_BUS_FMT_YUV8_1X24 },
144};
145
146/*
147 * Format mapping where 8bpc RGB -> 8bpc YUV444, or ID(RGB) or ID(YUV444)
148 */
149static const struct fmt_tuple rgb8_to_yuv8_or_id[] = {
150 { MEDIA_BUS_FMT_RGB888_1X24, MEDIA_BUS_FMT_RGB888_1X24 },
151 { MEDIA_BUS_FMT_YUV8_1X24, MEDIA_BUS_FMT_YUV8_1X24 },
152 { MEDIA_BUS_FMT_RGB888_1X24, MEDIA_BUS_FMT_YUV8_1X24 },
153};
154
155static const struct fmt_tuple rgb8_to_id_yuv8_or_yuv8_to_yuv422_yuv420[] = {
156 { MEDIA_BUS_FMT_RGB888_1X24, MEDIA_BUS_FMT_RGB888_1X24 },
157 { MEDIA_BUS_FMT_RGB888_1X24, MEDIA_BUS_FMT_YUV8_1X24 },
158 { MEDIA_BUS_FMT_YUV8_1X24, MEDIA_BUS_FMT_UYVY8_1X16 },
159 { MEDIA_BUS_FMT_YUV8_1X24, MEDIA_BUS_FMT_UYYVYY8_0_5X24 },
160};
161
162/*
163 * Format mapping where 8bpc YUV444 -> 8bpc RGB, or ID(YUV444)
164 */
165static const struct fmt_tuple yuv8_to_rgb8_or_id[] = {
166 { MEDIA_BUS_FMT_YUV8_1X24, MEDIA_BUS_FMT_YUV8_1X24 },
167 { MEDIA_BUS_FMT_YUV8_1X24, MEDIA_BUS_FMT_RGB888_1X24 },
168};
169
170/*
171 * A format mapping that acts like a video processor that generates an RGB signal
172 */
173static const struct fmt_tuple rgb_producer[] = {
174 { MEDIA_BUS_FMT_FIXED, MEDIA_BUS_FMT_RGB888_1X24 },
175 { MEDIA_BUS_FMT_FIXED, MEDIA_BUS_FMT_RGB101010_1X30 },
176 { MEDIA_BUS_FMT_FIXED, MEDIA_BUS_FMT_RGB121212_1X36 },
177};
178
179/*
180 * A format mapping that acts like a video processor that generates an 8-bit RGB,
181 * YUV444 or YUV420 signal
182 */
183static const struct fmt_tuple rgb_yuv444_yuv420_producer[] = {
184 { MEDIA_BUS_FMT_FIXED, MEDIA_BUS_FMT_RGB888_1X24 },
185 { MEDIA_BUS_FMT_FIXED, MEDIA_BUS_FMT_YUV8_1X24 },
186 { MEDIA_BUS_FMT_FIXED, MEDIA_BUS_FMT_UYYVYY8_0_5X24 },
187};
188
189static const struct fmt_tuple rgb8_yuv444_yuv422_passthrough[] = {
190 { MEDIA_BUS_FMT_RGB888_1X24, MEDIA_BUS_FMT_RGB888_1X24 },
191 { MEDIA_BUS_FMT_YUV8_1X24, MEDIA_BUS_FMT_YUV8_1X24 },
192 { MEDIA_BUS_FMT_UYVY8_1X16, MEDIA_BUS_FMT_UYVY8_1X16 },
193};
194
195static const struct fmt_tuple yuv444_yuv422_rgb8_passthrough[] = {
196 { MEDIA_BUS_FMT_YUV8_1X24, MEDIA_BUS_FMT_YUV8_1X24 },
197 { MEDIA_BUS_FMT_UYVY8_1X16, MEDIA_BUS_FMT_UYVY8_1X16 },
198 { MEDIA_BUS_FMT_RGB888_1X24, MEDIA_BUS_FMT_RGB888_1X24 },
199};
200
201static bool fmt_in_list(const u32 fmt, const u32 *out_fmts, const size_t num_fmts)
202{
203 size_t i;
204
205 for (i = 0; i < num_fmts; i++)
206 if (out_fmts[i] == fmt)
207 return true;
208
209 return false;
210}
211
212/**
213 * get_tuples_out_fmts - Get unique output formats of a &struct fmt_tuple list
214 * @fmt_tuples: array of &struct fmt_tuple
215 * @num_fmt_tuples: number of entries in @fmt_tuples
216 * @out_fmts: target array to store the unique output bus formats
217 *
218 * Returns the number of unique output formats, i.e. the number of entries in
219 * @out_fmts that were populated with sensible values.
220 */
221static size_t get_tuples_out_fmts(const struct fmt_tuple *fmt_tuples,
222 const size_t num_fmt_tuples, u32 *out_fmts)
223{
224 size_t num_unique = 0;
225 size_t i;
226
227 for (i = 0; i < num_fmt_tuples; i++)
228 if (!fmt_in_list(fmt_tuples[i].out_fmt, out_fmts, num_unique))
229 out_fmts[num_unique++] = fmt_tuples[i].out_fmt;
230
231 return num_unique;
232}
233
234#define DEFINE_FMT_FUNCS_FROM_TUPLES(name) \
235static u32 *drm_test_bridge_ ## name ## _out_fmts(struct drm_bridge *bridge, \
236 struct drm_bridge_state *bridge_state, \
237 struct drm_crtc_state *crtc_state, \
238 struct drm_connector_state *conn_state, \
239 unsigned int *num_output_fmts) \
240{ \
241 u32 *out_fmts = kcalloc(ARRAY_SIZE((name)), sizeof(u32), GFP_KERNEL); \
242 \
243 if (out_fmts) \
244 *num_output_fmts = get_tuples_out_fmts((name), ARRAY_SIZE((name)), out_fmts); \
245 else \
246 *num_output_fmts = 0; \
247 \
248 return out_fmts; \
249} \
250 \
251static u32 *drm_test_bridge_ ## name ## _in_fmts(struct drm_bridge *bridge, \
252 struct drm_bridge_state *bridge_state, \
253 struct drm_crtc_state *crtc_state, \
254 struct drm_connector_state *conn_state, \
255 u32 output_fmt, \
256 unsigned int *num_input_fmts) \
257{ \
258 u32 *in_fmts = kcalloc(ARRAY_SIZE((name)), sizeof(u32), GFP_KERNEL); \
259 unsigned int num_fmts = 0; \
260 size_t i; \
261 \
262 if (!in_fmts) { \
263 *num_input_fmts = 0; \
264 return NULL; \
265 } \
266 \
267 for (i = 0; i < ARRAY_SIZE((name)); i++) \
268 if ((name)[i].out_fmt == output_fmt) \
269 in_fmts[num_fmts++] = (name)[i].in_fmt; \
270 \
271 *num_input_fmts = num_fmts; \
272 \
273 return in_fmts; \
274}
275
276#define DRM_BRIDGE_ATOMIC_WITH_BUS_FMT_HDMI_FUNC(ident, input_fmts_func, output_fmts_func, \
277 hdmi_write_infoframe_func, \
278 hdmi_clear_infoframe_func) \
279static const struct drm_bridge_funcs (ident) = { \
280 .atomic_enable = drm_test_bridge_atomic_enable, \
281 .atomic_disable = drm_test_bridge_atomic_disable, \
282 .atomic_destroy_state = drm_atomic_helper_bridge_destroy_state, \
283 .atomic_duplicate_state = drm_atomic_helper_bridge_duplicate_state, \
284 .atomic_create_state = drm_atomic_helper_bridge_create_state, \
285 .atomic_get_input_bus_fmts = (input_fmts_func), \
286 .atomic_get_output_bus_fmts = (output_fmts_func), \
287 .hdmi_write_avi_infoframe = (hdmi_write_infoframe_func), \
288 .hdmi_clear_avi_infoframe = (hdmi_clear_infoframe_func), \
289 .hdmi_write_hdmi_infoframe = (hdmi_write_infoframe_func), \
290 .hdmi_clear_hdmi_infoframe = (hdmi_clear_infoframe_func), \
291}
292
293#define DRM_BRIDGE_ATOMIC_WITH_BUS_FMT_FUNC(ident, input_fmts_func, output_fmts_func) \
294 DRM_BRIDGE_ATOMIC_WITH_BUS_FMT_HDMI_FUNC(ident, input_fmts_func, output_fmts_func, \
295 NULL, NULL)
296
297#define DRM_BRIDGE_ATOMIC_WITH_BUS_FMT(_name) \
298 DRM_BRIDGE_ATOMIC_WITH_BUS_FMT_FUNC(_name ## _funcs, \
299 drm_test_bridge_ ## _name ## _in_fmts, \
300 drm_test_bridge_ ## _name ## _out_fmts)
301
302static int drm_test_bridge_write_infoframe_stub(struct drm_bridge *bridge,
303 const u8 *buffer, size_t len)
304{
305 return 0;
306}
307
308static int drm_test_bridge_clear_infoframe_stub(struct drm_bridge *bridge)
309{
310 return 0;
311}
312
313#define DRM_BRIDGE_ATOMIC_WITH_BUS_FMT_HDMI(_name) \
314 DRM_BRIDGE_ATOMIC_WITH_BUS_FMT_HDMI_FUNC(_name ## _hdmi ## _funcs, \
315 drm_test_bridge_ ## _name ## _in_fmts, \
316 drm_test_bridge_ ## _name ## _out_fmts, \
317 drm_test_bridge_write_infoframe_stub, \
318 drm_test_bridge_clear_infoframe_stub)
319DEFINE_FMT_FUNCS_FROM_TUPLES(rgb8_passthrough)
320DRM_BRIDGE_ATOMIC_WITH_BUS_FMT(rgb8_passthrough);
321
322DEFINE_FMT_FUNCS_FROM_TUPLES(yuv8_passthrough)
323DRM_BRIDGE_ATOMIC_WITH_BUS_FMT(yuv8_passthrough);
324
325DEFINE_FMT_FUNCS_FROM_TUPLES(rgb8_to_yuv8_or_id)
326DRM_BRIDGE_ATOMIC_WITH_BUS_FMT(rgb8_to_yuv8_or_id);
327
328DEFINE_FMT_FUNCS_FROM_TUPLES(yuv8_to_rgb8_or_id)
329DRM_BRIDGE_ATOMIC_WITH_BUS_FMT(yuv8_to_rgb8_or_id);
330
331DEFINE_FMT_FUNCS_FROM_TUPLES(rgb_producer)
332DRM_BRIDGE_ATOMIC_WITH_BUS_FMT(rgb_producer);
333
334DEFINE_FMT_FUNCS_FROM_TUPLES(rgb_yuv444_yuv420_producer)
335DRM_BRIDGE_ATOMIC_WITH_BUS_FMT(rgb_yuv444_yuv420_producer);
336
337DEFINE_FMT_FUNCS_FROM_TUPLES(rgb8_to_id_yuv8_or_yuv8_to_yuv422_yuv420)
338DRM_BRIDGE_ATOMIC_WITH_BUS_FMT(rgb8_to_id_yuv8_or_yuv8_to_yuv422_yuv420);
339
340DEFINE_FMT_FUNCS_FROM_TUPLES(rgb8_yuv444_yuv422_passthrough)
341DRM_BRIDGE_ATOMIC_WITH_BUS_FMT(rgb8_yuv444_yuv422_passthrough);
342
343DEFINE_FMT_FUNCS_FROM_TUPLES(yuv444_yuv422_rgb8_passthrough)
344DRM_BRIDGE_ATOMIC_WITH_BUS_FMT(yuv444_yuv422_rgb8_passthrough);
345DRM_BRIDGE_ATOMIC_WITH_BUS_FMT_HDMI(yuv444_yuv422_rgb8_passthrough);
346
347KUNIT_DEFINE_ACTION_WRAPPER(drm_bridge_remove_wrapper,
348 drm_bridge_remove,
349 struct drm_bridge *);
350
351static int drm_kunit_bridge_add(struct kunit *test,
352 struct drm_bridge *bridge)
353{
354 drm_bridge_add(bridge);
355
356 return kunit_add_action_or_reset(test,
357 drm_bridge_remove_wrapper,
358 bridge);
359}
360
361static struct drm_bridge_init_priv *
362drm_test_bridge_init(struct kunit *test, const struct drm_bridge_funcs *funcs)
363{
364 struct drm_bridge_init_priv *priv;
365 struct drm_encoder *enc;
366 struct drm_bridge *bridge;
367 struct drm_device *drm;
368 struct device *dev;
369 int ret;
370
371 dev = drm_kunit_helper_alloc_device(test);
372 if (IS_ERR(dev))
373 return ERR_CAST(dev);
374
375 priv = drm_kunit_helper_alloc_drm_device(test, dev,
376 struct drm_bridge_init_priv, drm,
377 DRIVER_MODESET | DRIVER_ATOMIC);
378 if (IS_ERR(priv))
379 return ERR_CAST(priv);
380
381 priv->test_bridge = devm_drm_bridge_alloc(dev, struct drm_bridge_priv, bridge, funcs);
382 if (IS_ERR(priv->test_bridge))
383 return ERR_CAST(priv->test_bridge);
384
385 priv->test_bridge->data = priv;
386
387 drm = &priv->drm;
388 priv->plane = drm_kunit_helper_create_primary_plane(test, drm,
389 NULL,
390 NULL,
391 NULL, 0,
392 NULL);
393 if (IS_ERR(priv->plane))
394 return ERR_CAST(priv->plane);
395
396 priv->crtc = drm_kunit_helper_create_crtc(test, drm,
397 priv->plane, NULL,
398 NULL,
399 NULL);
400 if (IS_ERR(priv->crtc))
401 return ERR_CAST(priv->crtc);
402
403 enc = &priv->encoder;
404 ret = drmm_encoder_init(drm, enc, NULL, DRM_MODE_ENCODER_TMDS, NULL);
405 if (ret)
406 return ERR_PTR(ret);
407
408 enc->possible_crtcs = drm_crtc_mask(priv->crtc);
409
410 bridge = &priv->test_bridge->bridge;
411 bridge->type = DRM_MODE_CONNECTOR_VIRTUAL;
412
413 ret = drm_kunit_bridge_add(test, bridge);
414 if (ret)
415 return ERR_PTR(ret);
416
417 ret = drm_bridge_attach(enc, bridge, NULL, 0);
418 if (ret)
419 return ERR_PTR(ret);
420
421 priv->connector = drm_bridge_connector_init(drm, enc);
422 if (IS_ERR(priv->connector))
423 return ERR_CAST(priv->connector);
424
425 drm_mode_config_reset(drm);
426
427 return priv;
428}
429
430static struct drm_bridge_chain_priv *
431drm_test_bridge_chain_init(struct kunit *test, unsigned int num_bridges,
432 const struct drm_bridge_funcs **funcs)
433{
434 struct drm_bridge_chain_priv *priv;
435 const struct drm_edid *edid;
436 struct drm_bridge *prev;
437 struct drm_encoder *enc;
438 struct drm_bridge *bridge;
439 struct drm_device *drm;
440 bool has_hdmi = false;
441 struct device *dev;
442 unsigned int i;
443 int ret;
444
445 dev = drm_kunit_helper_alloc_device(test);
446 if (IS_ERR(dev))
447 return ERR_CAST(dev);
448
449 priv = drm_kunit_helper_alloc_drm_device(test, dev, struct drm_bridge_chain_priv,
450 drm, DRIVER_MODESET | DRIVER_ATOMIC);
451 if (IS_ERR(priv))
452 return ERR_CAST(priv);
453
454 drm = &priv->drm;
455
456 priv->test_bridges = drmm_kmalloc_array(drm, num_bridges, sizeof(*priv->test_bridges),
457 GFP_KERNEL);
458 if (!priv->test_bridges)
459 return ERR_PTR(-ENOMEM);
460
461 priv->num_bridges = num_bridges;
462
463 for (i = 0; i < num_bridges; i++) {
464 priv->test_bridges[i] = devm_drm_bridge_alloc(dev, struct drm_bridge_priv,
465 bridge, funcs[i]);
466 if (IS_ERR(priv->test_bridges[i]))
467 return ERR_CAST(priv->test_bridges[i]);
468
469 priv->test_bridges[i]->data = priv;
470 }
471
472 priv->plane = drm_kunit_helper_create_primary_plane(test, drm, NULL, NULL,
473 NULL, 0, NULL);
474 if (IS_ERR(priv->plane))
475 return ERR_CAST(priv->plane);
476
477 priv->crtc = drm_kunit_helper_create_crtc(test, drm, priv->plane, NULL,
478 NULL, NULL);
479 if (IS_ERR(priv->crtc))
480 return ERR_CAST(priv->crtc);
481
482 enc = &priv->encoder;
483 ret = drmm_encoder_init(drm, enc, NULL, DRM_MODE_ENCODER_TMDS, NULL);
484 if (ret)
485 return ERR_PTR(ret);
486
487 enc->possible_crtcs = drm_crtc_mask(priv->crtc);
488
489 prev = NULL;
490 for (i = 0; i < num_bridges; i++) {
491 bridge = &priv->test_bridges[i]->bridge;
492 bridge->type = DRM_MODE_CONNECTOR_VIRTUAL;
493
494 if (bridge->funcs->hdmi_write_hdmi_infoframe) {
495 has_hdmi = true;
496 bridge->ops |= DRM_BRIDGE_OP_HDMI;
497 bridge->type = DRM_MODE_CONNECTOR_HDMIA;
498 bridge->vendor = "LNX";
499 bridge->product = "KUnit";
500 bridge->supported_formats = (BIT(DRM_OUTPUT_COLOR_FORMAT_RGB444) |
501 BIT(DRM_OUTPUT_COLOR_FORMAT_YCBCR444) |
502 BIT(DRM_OUTPUT_COLOR_FORMAT_YCBCR422) |
503 BIT(DRM_OUTPUT_COLOR_FORMAT_YCBCR420));
504 }
505
506 ret = drm_kunit_bridge_add(test, bridge);
507 if (ret)
508 return ERR_PTR(ret);
509
510 ret = drm_bridge_attach(enc, bridge, prev, 0);
511 if (ret)
512 return ERR_PTR(ret);
513
514 prev = bridge;
515 }
516
517 priv->connector = drm_bridge_connector_init(drm, enc);
518 if (IS_ERR(priv->connector))
519 return ERR_CAST(priv->connector);
520
521 drm_connector_attach_encoder(priv->connector, enc);
522
523 drm_mode_config_reset(drm);
524
525 if (!has_hdmi)
526 return priv;
527
528 scoped_guard(mutex, &drm->mode_config.mutex) {
529 edid = drm_edid_alloc(test_edid_hdmi_1080p_rgb_yuv_4k_yuv420_dc_max_200mhz,
530 ARRAY_SIZE(test_edid_hdmi_1080p_rgb_yuv_4k_yuv420_dc_max_200mhz));
531 if (!edid)
532 return ERR_PTR(-EINVAL);
533
534 drm_edid_connector_update(priv->connector, edid);
535 KUNIT_ASSERT_GT(test, drm_edid_connector_add_modes(priv->connector), 0);
536
537 ret = priv->connector->funcs->fill_modes(priv->connector, 4096, 4096);
538 }
539
540 return priv;
541}
542
543static struct drm_bridge_init_priv *
544drm_test_bridge_hdmi_init(struct kunit *test, const struct drm_bridge_funcs *funcs,
545 unsigned int supported_formats, int max_bpc)
546{
547 struct drm_bridge_init_priv *priv;
548 struct drm_encoder *enc;
549 struct drm_bridge *bridge;
550 struct drm_device *drm;
551 struct device *dev;
552 int ret;
553
554 dev = drm_kunit_helper_alloc_device(test);
555 if (IS_ERR(dev))
556 return ERR_CAST(dev);
557
558 priv = drm_kunit_helper_alloc_drm_device(test, dev,
559 struct drm_bridge_init_priv, drm,
560 DRIVER_MODESET | DRIVER_ATOMIC);
561 if (IS_ERR(priv))
562 return ERR_CAST(priv);
563
564 priv->test_bridge = devm_drm_bridge_alloc(dev, struct drm_bridge_priv, bridge, funcs);
565 if (IS_ERR(priv->test_bridge))
566 return ERR_CAST(priv->test_bridge);
567
568 priv->test_bridge->data = priv;
569
570 drm = &priv->drm;
571 priv->plane = drm_kunit_helper_create_primary_plane(test, drm,
572 NULL,
573 NULL,
574 NULL, 0,
575 NULL);
576 if (IS_ERR(priv->plane))
577 return ERR_CAST(priv->plane);
578
579 priv->crtc = drm_kunit_helper_create_crtc(test, drm,
580 priv->plane, NULL,
581 NULL,
582 NULL);
583 if (IS_ERR(priv->crtc))
584 return ERR_CAST(priv->crtc);
585
586 enc = &priv->encoder;
587 ret = drmm_encoder_init(drm, enc, NULL, DRM_MODE_ENCODER_TMDS, NULL);
588 if (ret)
589 return ERR_PTR(ret);
590
591 enc->possible_crtcs = drm_crtc_mask(priv->crtc);
592
593 bridge = &priv->test_bridge->bridge;
594 bridge->type = DRM_MODE_CONNECTOR_HDMIA;
595 bridge->supported_formats = supported_formats;
596 bridge->max_bpc = max_bpc;
597 bridge->ops |= DRM_BRIDGE_OP_HDMI;
598 bridge->vendor = "LNX";
599 bridge->product = "KUnit";
600
601 ret = drm_kunit_bridge_add(test, bridge);
602 if (ret)
603 return ERR_PTR(ret);
604
605 ret = drm_bridge_attach(enc, bridge, NULL, 0);
606 if (ret)
607 return ERR_PTR(ret);
608
609 priv->connector = drm_bridge_connector_init(drm, enc);
610 if (IS_ERR(priv->connector))
611 return ERR_CAST(priv->connector);
612
613 drm_connector_attach_encoder(priv->connector, enc);
614
615 drm_mode_config_reset(drm);
616
617 return priv;
618}
619
620/*
621 * Test that drm_bridge_get_current_state() returns the last committed
622 * state for an atomic bridge.
623 */
624static void drm_test_drm_bridge_get_current_state_atomic(struct kunit *test)
625{
626 struct drm_modeset_acquire_ctx ctx;
627 struct drm_bridge_init_priv *priv;
628 struct drm_bridge_state *curr_bridge_state;
629 struct drm_bridge_state *bridge_state;
630 struct drm_atomic_commit *state;
631 struct drm_bridge *bridge;
632 struct drm_device *drm;
633 int ret;
634
635 priv = drm_test_bridge_init(test, &drm_test_bridge_atomic_funcs);
636 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, priv);
637
638 drm_modeset_acquire_init(&ctx, 0);
639
640 drm = &priv->drm;
641 state = drm_kunit_helper_atomic_state_alloc(test, drm, &ctx);
642 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, state);
643
644retry_commit:
645 bridge = &priv->test_bridge->bridge;
646 bridge_state = drm_atomic_get_bridge_state(state, bridge);
647 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, bridge_state);
648
649 ret = drm_atomic_commit(state);
650 if (ret == -EDEADLK) {
651 drm_atomic_commit_clear(state);
652 drm_modeset_backoff(&ctx);
653 goto retry_commit;
654 }
655 KUNIT_ASSERT_EQ(test, ret, 0);
656
657 drm_modeset_drop_locks(&ctx);
658 drm_modeset_acquire_fini(&ctx);
659
660 drm_modeset_acquire_init(&ctx, 0);
661
662retry_state:
663 ret = drm_modeset_lock(&bridge->base.lock, &ctx);
664 if (ret == -EDEADLK) {
665 drm_modeset_backoff(&ctx);
666 goto retry_state;
667 }
668
669 curr_bridge_state = drm_bridge_get_current_state(bridge);
670 KUNIT_EXPECT_PTR_EQ(test, curr_bridge_state, bridge_state);
671
672 drm_modeset_unlock(&bridge->base.lock);
673
674 drm_modeset_drop_locks(&ctx);
675 drm_modeset_acquire_fini(&ctx);
676}
677
678static struct kunit_case drm_bridge_get_current_state_tests[] = {
679 KUNIT_CASE(drm_test_drm_bridge_get_current_state_atomic),
680 { }
681};
682
683
684static struct kunit_suite drm_bridge_get_current_state_test_suite = {
685 .name = "drm_test_bridge_get_current_state",
686 .test_cases = drm_bridge_get_current_state_tests,
687};
688
689/*
690 * Test that an atomic bridge is properly power-cycled when calling
691 * drm_bridge_helper_reset_crtc().
692 */
693static void drm_test_drm_bridge_helper_reset_crtc_atomic(struct kunit *test)
694{
695 struct drm_modeset_acquire_ctx ctx;
696 struct drm_bridge_init_priv *priv;
697 struct drm_display_mode *mode;
698 struct drm_bridge_priv *bridge_priv;
699 int ret;
700
701 priv = drm_test_bridge_init(test, &drm_test_bridge_atomic_funcs);
702 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, priv);
703
704 mode = drm_kunit_display_mode_from_cea_vic(test, &priv->drm, 16);
705 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, mode);
706
707 drm_modeset_acquire_init(&ctx, 0);
708
709retry_commit:
710 ret = drm_kunit_helper_enable_crtc_connector(test,
711 &priv->drm, priv->crtc,
712 priv->connector,
713 mode,
714 &ctx);
715 if (ret == -EDEADLK) {
716 drm_modeset_backoff(&ctx);
717 goto retry_commit;
718 }
719 KUNIT_ASSERT_EQ(test, ret, 0);
720
721 drm_modeset_drop_locks(&ctx);
722 drm_modeset_acquire_fini(&ctx);
723
724 bridge_priv = priv->test_bridge;
725 KUNIT_ASSERT_EQ(test, bridge_priv->enable_count, 1);
726 KUNIT_ASSERT_EQ(test, bridge_priv->disable_count, 0);
727
728 drm_modeset_acquire_init(&ctx, 0);
729
730retry_reset:
731 ret = drm_bridge_helper_reset_crtc(&bridge_priv->bridge, &ctx);
732 if (ret == -EDEADLK) {
733 drm_modeset_backoff(&ctx);
734 goto retry_reset;
735 }
736 KUNIT_ASSERT_EQ(test, ret, 0);
737
738 drm_modeset_drop_locks(&ctx);
739 drm_modeset_acquire_fini(&ctx);
740
741 KUNIT_EXPECT_EQ(test, bridge_priv->enable_count, 2);
742 KUNIT_EXPECT_EQ(test, bridge_priv->disable_count, 1);
743}
744
745/*
746 * Test that calling drm_bridge_helper_reset_crtc() on a disabled atomic
747 * bridge will fail and not call the enable / disable callbacks
748 */
749static void drm_test_drm_bridge_helper_reset_crtc_atomic_disabled(struct kunit *test)
750{
751 struct drm_modeset_acquire_ctx ctx;
752 struct drm_bridge_init_priv *priv;
753 struct drm_display_mode *mode;
754 struct drm_bridge_priv *bridge_priv;
755 int ret;
756
757 priv = drm_test_bridge_init(test, &drm_test_bridge_atomic_funcs);
758 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, priv);
759
760 mode = drm_kunit_display_mode_from_cea_vic(test, &priv->drm, 16);
761 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, mode);
762
763 bridge_priv = priv->test_bridge;
764 KUNIT_ASSERT_EQ(test, bridge_priv->enable_count, 0);
765 KUNIT_ASSERT_EQ(test, bridge_priv->disable_count, 0);
766
767 drm_modeset_acquire_init(&ctx, 0);
768
769retry_reset:
770 ret = drm_bridge_helper_reset_crtc(&bridge_priv->bridge, &ctx);
771 if (ret == -EDEADLK) {
772 drm_modeset_backoff(&ctx);
773 goto retry_reset;
774 }
775 KUNIT_EXPECT_LT(test, ret, 0);
776
777 drm_modeset_drop_locks(&ctx);
778 drm_modeset_acquire_fini(&ctx);
779
780 KUNIT_EXPECT_EQ(test, bridge_priv->enable_count, 0);
781 KUNIT_EXPECT_EQ(test, bridge_priv->disable_count, 0);
782}
783
784/*
785 * Test that a bridge using the drm_atomic_helper_bridge_get_hdmi_output_bus_fmts()
786 * function for &drm_bridge_funcs.atomic_get_output_bus_fmts behaves as expected
787 * for an HDMI connector bridge. Does so by creating an HDMI bridge connector
788 * with RGB444, YCBCR444, and YCBCR420 (but not YCBCR422) as supported formats,
789 * sets the output depth to 8 bits per component, and then validates the returned
790 * list of bus formats.
791 */
792static void drm_test_drm_bridge_helper_hdmi_output_bus_fmts(struct kunit *test)
793{
794 struct drm_connector_state *conn_state;
795 struct drm_bridge_state *bridge_state;
796 struct drm_modeset_acquire_ctx ctx;
797 struct drm_bridge_init_priv *priv;
798 struct drm_crtc_state *crtc_state;
799 struct drm_atomic_commit *state;
800 struct drm_display_mode *mode;
801 unsigned int num_output_fmts;
802 struct drm_bridge *bridge;
803 u32 *out_bus_fmts;
804 int ret;
805
806 priv = drm_test_bridge_hdmi_init(test, &drm_test_bridge_bus_fmts_funcs,
807 BIT(DRM_OUTPUT_COLOR_FORMAT_RGB444) |
808 BIT(DRM_OUTPUT_COLOR_FORMAT_YCBCR444) |
809 BIT(DRM_OUTPUT_COLOR_FORMAT_YCBCR420),
810 12);
811 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, priv);
812
813 bridge = &priv->test_bridge->bridge;
814
815 drm_modeset_acquire_init(&ctx, 0);
816
817 state = drm_kunit_helper_atomic_state_alloc(test, &priv->drm, &ctx);
818 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, state);
819
820retry_commit:
821 conn_state = drm_atomic_get_connector_state(state, priv->connector);
822 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, conn_state);
823
824 conn_state->hdmi.output_bpc = 8;
825
826 mode = drm_kunit_display_mode_from_cea_vic(test, &priv->drm, 16);
827 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, mode);
828
829 ret = drm_atomic_set_crtc_for_connector(conn_state, priv->crtc);
830 if (ret == -EDEADLK) {
831 drm_modeset_backoff(&ctx);
832 goto retry_commit;
833 }
834 KUNIT_ASSERT_EQ(test, ret, 0);
835
836 crtc_state = drm_atomic_get_crtc_state(state, priv->crtc);
837 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, crtc_state);
838
839 ret = drm_atomic_set_mode_for_crtc(crtc_state, mode);
840 if (ret == -EDEADLK) {
841 drm_modeset_backoff(&ctx);
842 goto retry_commit;
843 }
844 KUNIT_ASSERT_EQ(test, ret, 0);
845
846 crtc_state->enable = true;
847 crtc_state->active = true;
848
849 bridge_state = drm_atomic_get_bridge_state(state, bridge);
850 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, bridge_state);
851
852 out_bus_fmts = bridge->funcs->atomic_get_output_bus_fmts(
853 bridge, bridge_state, crtc_state, conn_state, &num_output_fmts);
854 KUNIT_EXPECT_NOT_NULL(test, out_bus_fmts);
855 KUNIT_EXPECT_EQ(test, num_output_fmts, 3);
856
857 KUNIT_EXPECT_EQ(test, out_bus_fmts[0], MEDIA_BUS_FMT_RGB888_1X24);
858 KUNIT_EXPECT_EQ(test, out_bus_fmts[1], MEDIA_BUS_FMT_YUV8_1X24);
859 KUNIT_EXPECT_EQ(test, out_bus_fmts[2], MEDIA_BUS_FMT_UYYVYY8_0_5X24);
860
861 drm_modeset_drop_locks(&ctx);
862 drm_modeset_acquire_fini(&ctx);
863
864 kfree(out_bus_fmts);
865}
866
867static struct kunit_case drm_bridge_helper_reset_crtc_tests[] = {
868 KUNIT_CASE(drm_test_drm_bridge_helper_reset_crtc_atomic),
869 KUNIT_CASE(drm_test_drm_bridge_helper_reset_crtc_atomic_disabled),
870 KUNIT_CASE(drm_test_drm_bridge_helper_hdmi_output_bus_fmts),
871 { }
872};
873
874static struct kunit_suite drm_bridge_helper_reset_crtc_test_suite = {
875 .name = "drm_test_bridge_helper_reset_crtc",
876 .test_cases = drm_bridge_helper_reset_crtc_tests,
877};
878
879static int drm_test_bridge_alloc_init(struct kunit *test)
880{
881 struct drm_bridge_init_priv *priv;
882
883 priv = kunit_kzalloc(test, sizeof(*priv), GFP_KERNEL);
884 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, priv);
885
886 priv->dev = kunit_device_register(test, "drm-bridge-dev");
887 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, priv->dev);
888
889 test->priv = priv;
890
891 priv->test_bridge = devm_drm_bridge_alloc(priv->dev, struct drm_bridge_priv, bridge,
892 &drm_test_bridge_atomic_funcs);
893 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, priv->test_bridge);
894
895 priv->test_bridge->data = priv;
896
897 KUNIT_ASSERT_FALSE(test, priv->destroyed);
898
899 return 0;
900}
901
902/*
903 * Test that a bridge is freed when the device is destroyed in lack of
904 * other drm_bridge_get/put() operations.
905 */
906static void drm_test_drm_bridge_alloc_basic(struct kunit *test)
907{
908 struct drm_bridge_init_priv *priv = test->priv;
909
910 KUNIT_ASSERT_FALSE(test, priv->destroyed);
911
912 kunit_device_unregister(test, priv->dev);
913 KUNIT_EXPECT_TRUE(test, priv->destroyed);
914}
915
916/*
917 * Test that a bridge is not freed when the device is destroyed when there
918 * is still a reference to it, and freed when that reference is put.
919 */
920static void drm_test_drm_bridge_alloc_get_put(struct kunit *test)
921{
922 struct drm_bridge_init_priv *priv = test->priv;
923
924 KUNIT_ASSERT_FALSE(test, priv->destroyed);
925
926 drm_bridge_get(&priv->test_bridge->bridge);
927 KUNIT_EXPECT_FALSE(test, priv->destroyed);
928
929 kunit_device_unregister(test, priv->dev);
930 KUNIT_EXPECT_FALSE(test, priv->destroyed);
931
932 drm_bridge_put(&priv->test_bridge->bridge);
933 KUNIT_EXPECT_TRUE(test, priv->destroyed);
934}
935
936static struct kunit_case drm_bridge_alloc_tests[] = {
937 KUNIT_CASE(drm_test_drm_bridge_alloc_basic),
938 KUNIT_CASE(drm_test_drm_bridge_alloc_get_put),
939 { }
940};
941
942static struct kunit_suite drm_bridge_alloc_test_suite = {
943 .name = "drm_bridge_alloc",
944 .init = drm_test_bridge_alloc_init,
945 .test_cases = drm_bridge_alloc_tests,
946};
947
948/**
949 * drm_test_bridge_chain_verify_fmt - Verify bridge chain format selection
950 * @test: pointer to KUnit test object
951 * @priv: pointer to a &struct drm_bridge_chain_priv for this chain
952 * @expected: constant array of &struct fmt_tuple describing the expected
953 * input and output bus formats
954 * @num_expected: number of entries in @expected
955 *
956 * Runs the KUNIT_EXPECT clauses to verify the bridge chain format selection
957 * resulted in the expected formats. If %0 is given as a format in a
958 * &struct fmt_tuple, then it is understood to mean "any".
959 *
960 * Must be called with the modeset lock held.
961 */
962static void drm_test_bridge_chain_verify_fmt(struct kunit *test,
963 struct drm_bridge_chain_priv *priv,
964 const struct fmt_tuple *const expected,
965 const unsigned int num_expected)
966{
967 struct drm_bridge_state *bstate;
968 unsigned int i = 0;
969
970 drm_for_each_bridge_in_chain(&priv->encoder, bridge) {
971 KUNIT_ASSERT_LT(test, i, num_expected);
972
973 bstate = drm_bridge_get_current_state(bridge);
974 if (expected[i].in_fmt)
975 KUNIT_EXPECT_EQ(test, bstate->input_bus_cfg.format,
976 expected[i].in_fmt);
977 if (expected[i].out_fmt)
978 KUNIT_EXPECT_EQ(test, bstate->output_bus_cfg.format,
979 expected[i].out_fmt);
980
981 i++;
982 }
983
984 KUNIT_ASSERT_EQ_MSG(test, i, num_expected,
985 "Fewer bridges (%u) than expected (%u)\n", i, num_expected);
986}
987
988/*
989 * Test that constructs a bridge chain in which an RGB888 producer is chained to
990 * two bridges that will convert from RGB to YUV and from YUV to RGB respectively.
991 *
992 * The test requests an output color_format of RGB using the color_format property,
993 * so to satisfy this request, the bridge chain must take a detour over YUV.
994 */
995static void drm_test_bridge_rgb_yuv_rgb(struct kunit *test)
996{
997 static const struct drm_bridge_funcs *funcs[] = {
998 &rgb_producer_funcs,
999 &rgb8_to_yuv8_or_id_funcs,
1000 &yuv8_to_rgb8_or_id_funcs,
1001 };
1002 static const struct fmt_tuple expected[] = {
1003 { MEDIA_BUS_FMT_FIXED, MEDIA_BUS_FMT_RGB888_1X24 },
1004 { MEDIA_BUS_FMT_RGB888_1X24, MEDIA_BUS_FMT_YUV8_1X24 },
1005 { MEDIA_BUS_FMT_YUV8_1X24, MEDIA_BUS_FMT_RGB888_1X24 },
1006 };
1007 struct drm_connector_state *conn_state;
1008 struct drm_modeset_acquire_ctx ctx;
1009 struct drm_bridge_chain_priv *priv;
1010 struct drm_crtc_state *crtc_state;
1011 struct drm_atomic_commit *state;
1012 struct drm_display_mode *mode;
1013 int ret;
1014
1015 priv = drm_test_bridge_chain_init(test, ARRAY_SIZE(funcs), funcs);
1016 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, priv);
1017
1018 drm_modeset_acquire_init(&ctx, 0);
1019
1020 state = drm_kunit_helper_atomic_state_alloc(test, &priv->drm, &ctx);
1021 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, state);
1022
1023retry_commit:
1024 conn_state = drm_atomic_get_connector_state(state, priv->connector);
1025 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, conn_state);
1026
1027 mode = drm_kunit_display_mode_from_cea_vic(test, &priv->drm, 16);
1028 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, mode);
1029
1030 conn_state->color_format = DRM_CONNECTOR_COLOR_FORMAT_RGB444;
1031
1032 ret = drm_atomic_set_crtc_for_connector(conn_state, priv->crtc);
1033 if (ret == -EDEADLK) {
1034 drm_modeset_backoff(&ctx);
1035 goto retry_commit;
1036 }
1037 KUNIT_ASSERT_EQ(test, ret, 0);
1038
1039 crtc_state = drm_atomic_get_crtc_state(state, priv->crtc);
1040 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, crtc_state);
1041
1042 ret = drm_atomic_set_mode_for_crtc(crtc_state, mode);
1043 if (ret == -EDEADLK) {
1044 drm_modeset_backoff(&ctx);
1045 goto retry_commit;
1046 }
1047 KUNIT_ASSERT_EQ(test, ret, 0);
1048
1049 crtc_state->enable = true;
1050 crtc_state->active = true;
1051
1052 ret = drm_atomic_commit(state);
1053 if (ret == -EDEADLK) {
1054 drm_modeset_backoff(&ctx);
1055 goto retry_commit;
1056 }
1057 KUNIT_ASSERT_EQ(test, ret, 0);
1058
1059 drm_test_bridge_chain_verify_fmt(test, priv, expected, ARRAY_SIZE(expected));
1060
1061 drm_modeset_drop_locks(&ctx);
1062 drm_modeset_acquire_fini(&ctx);
1063}
1064
1065/*
1066 * Test in which a bridge capable of producing RGB, YUV444 and YUV420 has to
1067 * produce RGB and convert with a downstream bridge in the chain to reach the
1068 * requested YUV444 color format, as no direct path exists between its YUV444
1069 * and the last bridge.
1070 *
1071 * The rationale behind this test is to devise a scenario in which naively
1072 * assuming any format the video processor can output, and the connector
1073 * requests, is the right format to pick, does not work.
1074 */
1075static void drm_test_bridge_must_convert_to_yuv444(struct kunit *test)
1076{
1077 static const struct drm_bridge_funcs *funcs[] = {
1078 &rgb_yuv444_yuv420_producer_funcs,
1079 &rgb8_passthrough_funcs,
1080 &rgb8_to_id_yuv8_or_yuv8_to_yuv422_yuv420_funcs,
1081 &rgb8_yuv444_yuv422_passthrough_funcs,
1082 };
1083 static const struct fmt_tuple expected[] = {
1084 { MEDIA_BUS_FMT_FIXED, MEDIA_BUS_FMT_RGB888_1X24 },
1085 { MEDIA_BUS_FMT_RGB888_1X24, MEDIA_BUS_FMT_RGB888_1X24 },
1086 { MEDIA_BUS_FMT_RGB888_1X24, MEDIA_BUS_FMT_YUV8_1X24 },
1087 { MEDIA_BUS_FMT_YUV8_1X24, MEDIA_BUS_FMT_YUV8_1X24 },
1088 };
1089 struct drm_connector_state *conn_state;
1090 struct drm_modeset_acquire_ctx ctx;
1091 struct drm_bridge_chain_priv *priv;
1092 struct drm_crtc_state *crtc_state;
1093 struct drm_atomic_commit *state;
1094 struct drm_display_mode *mode;
1095 int ret;
1096
1097 priv = drm_test_bridge_chain_init(test, ARRAY_SIZE(funcs), funcs);
1098 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, priv);
1099
1100 drm_modeset_acquire_init(&ctx, 0);
1101
1102 state = drm_kunit_helper_atomic_state_alloc(test, &priv->drm, &ctx);
1103 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, state);
1104
1105retry_commit:
1106 conn_state = drm_atomic_get_connector_state(state, priv->connector);
1107 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, conn_state);
1108
1109 mode = drm_kunit_display_mode_from_cea_vic(test, &priv->drm, 16);
1110 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, mode);
1111
1112 conn_state->color_format = DRM_CONNECTOR_COLOR_FORMAT_YCBCR444;
1113
1114 ret = drm_atomic_set_crtc_for_connector(conn_state, priv->crtc);
1115 if (ret == -EDEADLK) {
1116 drm_modeset_backoff(&ctx);
1117 goto retry_commit;
1118 }
1119 KUNIT_ASSERT_EQ(test, ret, 0);
1120
1121 crtc_state = drm_atomic_get_crtc_state(state, priv->crtc);
1122 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, crtc_state);
1123
1124 ret = drm_atomic_set_mode_for_crtc(crtc_state, mode);
1125 if (ret == -EDEADLK) {
1126 drm_modeset_backoff(&ctx);
1127 goto retry_commit;
1128 }
1129 KUNIT_ASSERT_EQ(test, ret, 0);
1130
1131 crtc_state->enable = true;
1132 crtc_state->active = true;
1133
1134 ret = drm_atomic_commit(state);
1135 if (ret == -EDEADLK) {
1136 drm_modeset_backoff(&ctx);
1137 goto retry_commit;
1138 }
1139 KUNIT_ASSERT_EQ(test, ret, 0);
1140
1141 drm_test_bridge_chain_verify_fmt(test, priv, expected, ARRAY_SIZE(expected));
1142
1143 drm_modeset_drop_locks(&ctx);
1144 drm_modeset_acquire_fini(&ctx);
1145}
1146
1147/*
1148 * Test which checks that no matter the order of bus formats returned by an
1149 * HDMI bridge, RGB is preferred on DRM_CONNECTOR_COLOR_FORMAT_AUTO if it's
1150 * available.
1151 */
1152static void drm_test_bridge_hdmi_auto_rgb(struct kunit *test)
1153{
1154 static const struct drm_bridge_funcs *funcs[] = {
1155 &rgb_yuv444_yuv420_producer_funcs,
1156 &yuv444_yuv422_rgb8_passthrough_hdmi_funcs,
1157 };
1158 static const struct fmt_tuple expected[] = {
1159 { MEDIA_BUS_FMT_FIXED, MEDIA_BUS_FMT_RGB888_1X24 },
1160 { MEDIA_BUS_FMT_RGB888_1X24, MEDIA_BUS_FMT_RGB888_1X24 },
1161 };
1162 struct drm_connector_state *conn_state;
1163 struct drm_modeset_acquire_ctx ctx;
1164 struct drm_bridge_chain_priv *priv;
1165 struct drm_crtc_state *crtc_state;
1166 struct drm_atomic_commit *state;
1167 struct drm_display_mode *mode;
1168 int ret;
1169
1170 priv = drm_test_bridge_chain_init(test, ARRAY_SIZE(funcs), funcs);
1171 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, priv);
1172
1173 drm_modeset_acquire_init(&ctx, 0);
1174
1175 state = drm_kunit_helper_atomic_state_alloc(test, &priv->drm, &ctx);
1176 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, state);
1177
1178retry_commit:
1179 conn_state = drm_atomic_get_connector_state(state, priv->connector);
1180 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, conn_state);
1181
1182 mode = drm_kunit_display_mode_from_cea_vic(test, &priv->drm, 16);
1183 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, mode);
1184
1185 KUNIT_ASSERT_EQ(test, conn_state->color_format, DRM_CONNECTOR_COLOR_FORMAT_AUTO);
1186
1187 ret = drm_atomic_set_crtc_for_connector(conn_state, priv->crtc);
1188 if (ret == -EDEADLK) {
1189 drm_modeset_backoff(&ctx);
1190 goto retry_commit;
1191 }
1192 KUNIT_ASSERT_EQ(test, ret, 0);
1193
1194 crtc_state = drm_atomic_get_crtc_state(state, priv->crtc);
1195 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, crtc_state);
1196
1197 ret = drm_atomic_set_mode_for_crtc(crtc_state, mode);
1198 if (ret == -EDEADLK) {
1199 drm_modeset_backoff(&ctx);
1200 goto retry_commit;
1201 }
1202 KUNIT_ASSERT_EQ(test, ret, 0);
1203
1204 crtc_state->enable = true;
1205 crtc_state->active = true;
1206
1207 ret = drm_atomic_commit(state);
1208 if (ret == -EDEADLK) {
1209 drm_modeset_backoff(&ctx);
1210 goto retry_commit;
1211 }
1212 KUNIT_ASSERT_EQ(test, ret, 0);
1213
1214 KUNIT_EXPECT_EQ(test, conn_state->hdmi.output_format, DRM_OUTPUT_COLOR_FORMAT_RGB444);
1215
1216 drm_test_bridge_chain_verify_fmt(test, priv, expected, ARRAY_SIZE(expected));
1217
1218 drm_modeset_drop_locks(&ctx);
1219 drm_modeset_acquire_fini(&ctx);
1220}
1221
1222/*
1223 * Test which checks that DRM_CONNECTOR_COLOR_FORMAT_AUTO on non-HDMI connectors
1224 * will result in the first bus format on the output to be picked.
1225 */
1226static void drm_test_bridge_auto_first(struct kunit *test)
1227{
1228 static const struct drm_bridge_funcs *funcs[] = {
1229 &rgb_yuv444_yuv420_producer_funcs,
1230 &yuv444_yuv422_rgb8_passthrough_funcs,
1231 };
1232 static const struct fmt_tuple expected[] = {
1233 { MEDIA_BUS_FMT_FIXED, MEDIA_BUS_FMT_YUV8_1X24 },
1234 { MEDIA_BUS_FMT_YUV8_1X24, MEDIA_BUS_FMT_YUV8_1X24 },
1235 };
1236 struct drm_connector_state *conn_state;
1237 struct drm_modeset_acquire_ctx ctx;
1238 struct drm_bridge_chain_priv *priv;
1239 struct drm_crtc_state *crtc_state;
1240 struct drm_atomic_commit *state;
1241 struct drm_display_mode *mode;
1242 int ret;
1243
1244 priv = drm_test_bridge_chain_init(test, ARRAY_SIZE(funcs), funcs);
1245 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, priv);
1246
1247 drm_modeset_acquire_init(&ctx, 0);
1248
1249 state = drm_kunit_helper_atomic_state_alloc(test, &priv->drm, &ctx);
1250 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, state);
1251
1252retry_commit:
1253 conn_state = drm_atomic_get_connector_state(state, priv->connector);
1254 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, conn_state);
1255
1256 mode = drm_kunit_display_mode_from_cea_vic(test, &priv->drm, 16);
1257 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, mode);
1258
1259 KUNIT_ASSERT_EQ(test, conn_state->color_format, DRM_CONNECTOR_COLOR_FORMAT_AUTO);
1260
1261 ret = drm_atomic_set_crtc_for_connector(conn_state, priv->crtc);
1262 if (ret == -EDEADLK) {
1263 drm_modeset_backoff(&ctx);
1264 goto retry_commit;
1265 }
1266 KUNIT_ASSERT_EQ(test, ret, 0);
1267
1268 crtc_state = drm_atomic_get_crtc_state(state, priv->crtc);
1269 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, crtc_state);
1270
1271 ret = drm_atomic_set_mode_for_crtc(crtc_state, mode);
1272 if (ret == -EDEADLK) {
1273 drm_modeset_backoff(&ctx);
1274 goto retry_commit;
1275 }
1276 KUNIT_ASSERT_EQ(test, ret, 0);
1277
1278 crtc_state->enable = true;
1279 crtc_state->active = true;
1280
1281 ret = drm_atomic_commit(state);
1282 if (ret == -EDEADLK) {
1283 drm_modeset_backoff(&ctx);
1284 goto retry_commit;
1285 }
1286 KUNIT_ASSERT_EQ(test, ret, 0);
1287
1288 drm_test_bridge_chain_verify_fmt(test, priv, expected, ARRAY_SIZE(expected));
1289
1290 drm_modeset_drop_locks(&ctx);
1291 drm_modeset_acquire_fini(&ctx);
1292}
1293
1294/*
1295 * Test which checks that in a configuration of bridge chains where an RGB
1296 * producer is hooked to a YUV444-only pass-through, the atomic commit fails as
1297 * the bridge format selection cannot find a valid sequence of bus formats.
1298 */
1299static void drm_test_bridge_rgb_yuv_no_path(struct kunit *test)
1300{
1301 static const struct drm_bridge_funcs *funcs[] = {
1302 &rgb_producer_funcs,
1303 &yuv8_passthrough_funcs,
1304 &rgb8_yuv444_yuv422_passthrough_funcs,
1305 };
1306 struct drm_connector_state *conn_state;
1307 struct drm_modeset_acquire_ctx ctx;
1308 struct drm_bridge_chain_priv *priv;
1309 struct drm_crtc_state *crtc_state;
1310 struct drm_atomic_commit *state;
1311 struct drm_display_mode *mode;
1312 int ret;
1313
1314 priv = drm_test_bridge_chain_init(test, ARRAY_SIZE(funcs), funcs);
1315 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, priv);
1316
1317 drm_modeset_acquire_init(&ctx, 0);
1318
1319 state = drm_kunit_helper_atomic_state_alloc(test, &priv->drm, &ctx);
1320 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, state);
1321
1322retry_commit:
1323 conn_state = drm_atomic_get_connector_state(state, priv->connector);
1324 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, conn_state);
1325
1326 mode = drm_kunit_display_mode_from_cea_vic(test, &priv->drm, 16);
1327 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, mode);
1328
1329 ret = drm_atomic_set_crtc_for_connector(conn_state, priv->crtc);
1330 if (ret == -EDEADLK) {
1331 drm_modeset_backoff(&ctx);
1332 goto retry_commit;
1333 }
1334 KUNIT_ASSERT_EQ(test, ret, 0);
1335
1336 crtc_state = drm_atomic_get_crtc_state(state, priv->crtc);
1337 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, crtc_state);
1338
1339 ret = drm_atomic_set_mode_for_crtc(crtc_state, mode);
1340 if (ret == -EDEADLK) {
1341 drm_modeset_backoff(&ctx);
1342 goto retry_commit;
1343 }
1344 KUNIT_ASSERT_EQ(test, ret, 0);
1345
1346 crtc_state->enable = true;
1347 crtc_state->active = true;
1348
1349 ret = drm_atomic_commit(state);
1350 if (ret == -EDEADLK) {
1351 drm_modeset_backoff(&ctx);
1352 goto retry_commit;
1353 }
1354 KUNIT_EXPECT_EQ(test, ret, -ENOTSUPP);
1355
1356 drm_modeset_drop_locks(&ctx);
1357 drm_modeset_acquire_fini(&ctx);
1358}
1359
1360static struct kunit_case drm_bridge_bus_fmt_tests[] = {
1361 KUNIT_CASE(drm_test_bridge_rgb_yuv_rgb),
1362 KUNIT_CASE(drm_test_bridge_must_convert_to_yuv444),
1363 KUNIT_CASE(drm_test_bridge_hdmi_auto_rgb),
1364 KUNIT_CASE(drm_test_bridge_auto_first),
1365 KUNIT_CASE(drm_test_bridge_rgb_yuv_no_path),
1366 { }
1367};
1368
1369static struct kunit_suite drm_bridge_bus_fmt_test_suite = {
1370 .name = "drm_bridge_bus_fmt",
1371 .test_cases = drm_bridge_bus_fmt_tests,
1372};
1373
1374kunit_test_suites(
1375 &drm_bridge_get_current_state_test_suite,
1376 &drm_bridge_helper_reset_crtc_test_suite,
1377 &drm_bridge_alloc_test_suite,
1378 &drm_bridge_bus_fmt_test_suite,
1379);
1380
1381MODULE_AUTHOR("Maxime Ripard <[email protected]>");
1382MODULE_AUTHOR("Luca Ceresoli <[email protected]>");
1383MODULE_AUTHOR("Nicolas Frattaroli <[email protected]>");
1384
1385MODULE_DESCRIPTION("Kunit test for drm_bridge functions");
1386MODULE_LICENSE("GPL");