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 */ 30 struct drm_bridge_priv { 31 unsigned int enable_count; 32 unsigned int disable_count; 33 struct drm_bridge bridge; 34 void *data; 35 }; 36 37 struct 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 49 struct 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 64 static struct drm_bridge_priv *bridge_to_priv(struct drm_bridge *bridge) 65 { 66 return container_of(bridge, struct drm_bridge_priv, bridge); 67 } 68 69 static 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 77 static 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 85 static 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 93 static 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 102 static int dummy_clear_infoframe(struct drm_bridge *bridge) 103 { 104 return 0; 105 } 106 107 static int dummy_write_infoframe(struct drm_bridge *bridge, const u8 *buffer, 108 size_t len) 109 { 110 return 0; 111 } 112 113 static 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 */ 127 struct 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 */ 135 static 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 */ 142 static 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 */ 149 static 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 155 static 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 */ 165 static 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 */ 173 static 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 */ 183 static 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 189 static 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 195 static 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 201 static 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 */ 221 static 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) \ 235 static 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 \ 251 static 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) \ 279 static 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 302 static int drm_test_bridge_write_infoframe_stub(struct drm_bridge *bridge, 303 const u8 *buffer, size_t len) 304 { 305 return 0; 306 } 307 308 static 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) 319 DEFINE_FMT_FUNCS_FROM_TUPLES(rgb8_passthrough) 320 DRM_BRIDGE_ATOMIC_WITH_BUS_FMT(rgb8_passthrough); 321 322 DEFINE_FMT_FUNCS_FROM_TUPLES(yuv8_passthrough) 323 DRM_BRIDGE_ATOMIC_WITH_BUS_FMT(yuv8_passthrough); 324 325 DEFINE_FMT_FUNCS_FROM_TUPLES(rgb8_to_yuv8_or_id) 326 DRM_BRIDGE_ATOMIC_WITH_BUS_FMT(rgb8_to_yuv8_or_id); 327 328 DEFINE_FMT_FUNCS_FROM_TUPLES(yuv8_to_rgb8_or_id) 329 DRM_BRIDGE_ATOMIC_WITH_BUS_FMT(yuv8_to_rgb8_or_id); 330 331 DEFINE_FMT_FUNCS_FROM_TUPLES(rgb_producer) 332 DRM_BRIDGE_ATOMIC_WITH_BUS_FMT(rgb_producer); 333 334 DEFINE_FMT_FUNCS_FROM_TUPLES(rgb_yuv444_yuv420_producer) 335 DRM_BRIDGE_ATOMIC_WITH_BUS_FMT(rgb_yuv444_yuv420_producer); 336 337 DEFINE_FMT_FUNCS_FROM_TUPLES(rgb8_to_id_yuv8_or_yuv8_to_yuv422_yuv420) 338 DRM_BRIDGE_ATOMIC_WITH_BUS_FMT(rgb8_to_id_yuv8_or_yuv8_to_yuv422_yuv420); 339 340 DEFINE_FMT_FUNCS_FROM_TUPLES(rgb8_yuv444_yuv422_passthrough) 341 DRM_BRIDGE_ATOMIC_WITH_BUS_FMT(rgb8_yuv444_yuv422_passthrough); 342 343 DEFINE_FMT_FUNCS_FROM_TUPLES(yuv444_yuv422_rgb8_passthrough) 344 DRM_BRIDGE_ATOMIC_WITH_BUS_FMT(yuv444_yuv422_rgb8_passthrough); 345 DRM_BRIDGE_ATOMIC_WITH_BUS_FMT_HDMI(yuv444_yuv422_rgb8_passthrough); 346 347 KUNIT_DEFINE_ACTION_WRAPPER(drm_bridge_remove_wrapper, 348 drm_bridge_remove, 349 struct drm_bridge *); 350 351 static 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 361 static struct drm_bridge_init_priv * 362 drm_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 430 static struct drm_bridge_chain_priv * 431 drm_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 543 static struct drm_bridge_init_priv * 544 drm_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 */ 624 static 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 644 retry_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 662 retry_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 678 static struct kunit_case drm_bridge_get_current_state_tests[] = { 679 KUNIT_CASE(drm_test_drm_bridge_get_current_state_atomic), 680 { } 681 }; 682 683 684 static 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 */ 693 static 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 709 retry_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 730 retry_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 */ 749 static 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 769 retry_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 */ 792 static 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 820 retry_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 867 static 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 874 static 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 879 static 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 */ 906 static 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 */ 920 static 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 936 static 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 942 static 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 */ 962 static 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 */ 995 static 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 1023 retry_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 */ 1075 static 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 1105 retry_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 */ 1152 static 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 1178 retry_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 */ 1226 static 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 1252 retry_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 */ 1299 static 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 1322 retry_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 1360 static 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 1369 static 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 1374 kunit_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 1381 MODULE_AUTHOR("Maxime Ripard <mripard@kernel.org>"); 1382 MODULE_AUTHOR("Luca Ceresoli <luca.ceresoli@bootlin.com>"); 1383 MODULE_AUTHOR("Nicolas Frattaroli <nicolas.frattaroli@collabora.com>"); 1384 1385 MODULE_DESCRIPTION("Kunit test for drm_bridge functions"); 1386 MODULE_LICENSE("GPL"); 1387