mirror of
https://github.com/torvalds/linux.git
synced 2026-04-24 17:42:27 -04:00
Merge tag 'drm-next-2022-12-13' of git://anongit.freedesktop.org/drm/drm
Pull drm updates from Dave Airlie: "The biggest highlight is that the accel subsystem framework is merged. Hopefully for 6.3 we will be able to line up a driver to use it. In drivers land, i915 enables DG2 support by default now, and nouveau has a big stability refactoring and initial ampere support, AMD includes new hw IP support and should build on ARM again. There is also an ofdrm driver to take over offb on platforms it's used. Stuff outside my tree, the dma-buf patches hit a few places, the vc4 firmware changes also do, and i915 has some interactions with MEI for discrete GPUs. I think all of those should have been acked/reviewed by relevant parties. New driver: - ofdrm - replacement for offb fbdev: - add support for nomodeset fourcc: - add Vivante tiled modifier core: - atomic-helpers: CRTC primary plane test fixes, fb access hooks - connector: TV API consistency, cmdline parser improvements - send connector hotplug on cleanup - sort makefile objects tests: - sort kunit tests - improve DP-MST tests - add kunit helpers to create a device sched: - module param for scheduling policy - refcounting fix buddy: - add back random seed log ttm: - convert ttm_resource to size_t - optimize pool allocations edid: - HFVSDB parsing support fixes - logging/debug improvements - DSC quirks dma-buf: - Add unlocked vmap and attachment mapping - move drivers to common locking convention - locking improvements firmware: - new API for rPI firmware and vc4 xilinx: - zynqmp: displayport bridge support - dpsub fix bridge: - adv7533: Remove dynamic lane switching - it6505: Runtime PM support, sync improvements - ps8640: Handle AUX defer messages - tc358775: Drop soft-reset over I2C panel: - panel-edp: Add INX N116BGE-EA2 C2 and C4 support. - Jadard JD9365DA-H3 - NewVision NV3051D amdgpu: - DCN support on ARM - DCN 2.1 secure display - Sienna Cichlid mode2 reset fixes - new GC 11.x firmware versions - drop AMD specific DSC workarounds in favour of drm code - clang warning fixes - scheduler rework - SR-IOV fixes - GPUVM locking fixes - fix memory leak in CS IOCTL error path - flexible array updates - enable new GC/PSP/SMU/NBIO IP - GFX preemption support for gfx9 amdkfd: - cache size fixes - userptr fixes - enable cooperative launch on gfx 10.3 - enable GC 11.0.4 KFD support radeon: - replace kmap with kmap_local_page - ACPI ref count fix - HDA audio notifier support i915: - DG2 enabled by default - MTL enablement work - hotplug refactoring - VBT improvements - Display and watermark refactoring - ADL-P workaround - temp disable runtime_pm for discrete- - fix for A380 as a secondary GPU - Wa_18017747507 for DG2 - CS timestamp support fixes for gen5 and earlier - never purge busy TTM objects - use i915_sg_dma_sizes for all backends - demote GuC kernel contexts to normal priority - gvt: refactor for new MDEV interface - enable DC power states on eDP ports - fix gen 2/3 workarounds nouveau: - fix page fault handling - Ampere acceleration support - driver stability improvements - nva3 backlight support msm: - MSM_INFO_GET_FLAGS support - DPU: XR30 and P010 image formats - Qualcomm SM6115 support - DSI PHY support for QCM2290 - HDMI: refactored dev init path - remove exclusive-fence hack - fix speed-bin detection - enable clamp to idle on 7c3 - improved hangcheck detection vmwgfx: - fb and cursor refactoring - convert to generic hashtable - cursor improvements etnaviv: - hw workarounds - softpin MMU fixes ast: - atomic gamma LUT support - convert to SHMEM lcdif: - support YUV planes - Increase DMA burst size - FIFO threshold tuning meson: - fix return type of cvbs mode_valid mgag200: - fix PLL setup on some revisions sun4i: - A100 and D1 support udl: - modesetting improvements - hot unplug support vc4: - support PAL-M - fix regression preventing 4K @ 60Hz - fix NULL ptr deref v3d: - switch to drm managed resources renesas: - RZ/G2L DSI support - DU Kconfig cleanup mediatek: - fixup dpi and hdmi - MT8188 dpi support - MT8195 AFBC support tegra: - NVDEC hardware on Tegra234 SoC hdlcd: - switch to drm managed resources ingenic: - fix registration error path hisilicon: - convert to drm_mode_init maildp: - use managed resources mtk: - use drm_mode_init rockchip: - use drm_mode_copy" * tag 'drm-next-2022-12-13' of git://anongit.freedesktop.org/drm/drm: (1397 commits) drm/amdgpu: fix mmhub register base coding error drm/amdgpu: add tmz support for GC IP v11.0.4 drm/amdgpu: enable GFX Clock Gating control for GC IP v11.0.4 drm/amdgpu: enable GFX Power Gating for GC IP v11.0.4 drm/amdgpu: enable GFX IP v11.0.4 CG support drm/amdgpu: Make amdgpu_ring_mux functions as static drm/amdgpu: generally allow over-commit during BO allocation drm/amd/display: fix array index out of bound error in DCN32 DML drm/amd/display: 3.2.215 drm/amd/display: set optimized required for comp buf changes drm/amd/display: Add debug option to skip PSR CRTC disable drm/amd/display: correct DML calc error of UrgentLatency drm/amd/display: correct static_screen_event_mask drm/amd/display: Ensure commit_streams returns the DC return code drm/amd/display: read invalid ddc pin status cause engine busy drm/amd/display: Bypass DET swath fill check for max clocks drm/amd/display: Disable uclk pstate for subvp pipes drm/amd/display: Fix DCN2.1 default DSC clocks drm/amd/display: Enable dp_hdmi21_pcon support drm/amd/display: prevent seamless boot on displays that don't have the preferred dig ...
This commit is contained in:
Linus Torvalds
@@ -1,5 +1,14 @@
|
||||
# SPDX-License-Identifier: GPL-2.0
|
||||
|
||||
obj-$(CONFIG_DRM_KUNIT_TEST) += drm_format_helper_test.o drm_damage_helper_test.o \
|
||||
drm_cmdline_parser_test.o drm_rect_test.o drm_format_test.o drm_plane_helper_test.o \
|
||||
drm_dp_mst_helper_test.o drm_framebuffer_test.o drm_buddy_test.o drm_mm_test.o
|
||||
obj-$(CONFIG_DRM_KUNIT_TEST) += \
|
||||
drm_buddy_test.o \
|
||||
drm_cmdline_parser_test.o \
|
||||
drm_damage_helper_test.o \
|
||||
drm_dp_mst_helper_test.o \
|
||||
drm_format_helper_test.o \
|
||||
drm_format_test.o \
|
||||
drm_framebuffer_test.o \
|
||||
drm_kunit_helpers.o \
|
||||
drm_mm_test.o \
|
||||
drm_plane_helper_test.o \
|
||||
drm_rect_test.o
|
||||
|
||||
@@ -726,11 +726,13 @@ static void drm_test_buddy_alloc_limit(struct kunit *test)
|
||||
drm_buddy_fini(&mm);
|
||||
}
|
||||
|
||||
static int drm_buddy_init_test(struct kunit *test)
|
||||
static int drm_buddy_suite_init(struct kunit_suite *suite)
|
||||
{
|
||||
while (!random_seed)
|
||||
random_seed = get_random_u32();
|
||||
|
||||
kunit_info(suite, "Testing DRM buddy manager, with random_seed=0x%x\n", random_seed);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -746,7 +748,7 @@ static struct kunit_case drm_buddy_tests[] = {
|
||||
|
||||
static struct kunit_suite drm_buddy_test_suite = {
|
||||
.name = "drm_buddy",
|
||||
.init = drm_buddy_init_test,
|
||||
.suite_init = drm_buddy_suite_init,
|
||||
.test_cases = drm_buddy_tests,
|
||||
};
|
||||
|
||||
|
||||
98
drivers/gpu/drm/tests/drm_client_modeset_test.c
Normal file
98
drivers/gpu/drm/tests/drm_client_modeset_test.c
Normal file
@@ -0,0 +1,98 @@
|
||||
// SPDX-License-Identifier: GPL-2.0
|
||||
/*
|
||||
* Copyright (c) 2022 Maxime Ripard <mripard@kernel.org>
|
||||
*/
|
||||
|
||||
#include <kunit/test.h>
|
||||
|
||||
#include <drm/drm_connector.h>
|
||||
#include <drm/drm_edid.h>
|
||||
#include <drm/drm_drv.h>
|
||||
#include <drm/drm_modes.h>
|
||||
#include <drm/drm_modeset_helper_vtables.h>
|
||||
#include <drm/drm_probe_helper.h>
|
||||
|
||||
#include "drm_kunit_helpers.h"
|
||||
|
||||
struct drm_client_modeset_test_priv {
|
||||
struct drm_device *drm;
|
||||
struct drm_connector connector;
|
||||
};
|
||||
|
||||
static int drm_client_modeset_connector_get_modes(struct drm_connector *connector)
|
||||
{
|
||||
return drm_add_modes_noedid(connector, 1920, 1200);
|
||||
}
|
||||
|
||||
static const struct drm_connector_helper_funcs drm_client_modeset_connector_helper_funcs = {
|
||||
.get_modes = drm_client_modeset_connector_get_modes,
|
||||
};
|
||||
|
||||
static const struct drm_connector_funcs drm_client_modeset_connector_funcs = {
|
||||
};
|
||||
|
||||
static int drm_client_modeset_test_init(struct kunit *test)
|
||||
{
|
||||
struct drm_client_modeset_test_priv *priv;
|
||||
int ret;
|
||||
|
||||
priv = kunit_kzalloc(test, sizeof(*priv), GFP_KERNEL);
|
||||
KUNIT_ASSERT_NOT_NULL(test, priv);
|
||||
|
||||
test->priv = priv;
|
||||
|
||||
priv->drm = drm_kunit_device_init(test, DRIVER_MODESET, "drm-client-modeset-test");
|
||||
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, priv->drm);
|
||||
|
||||
ret = drmm_connector_init(priv->drm, &priv->connector,
|
||||
&drm_client_modeset_connector_funcs,
|
||||
DRM_MODE_CONNECTOR_Unknown,
|
||||
NULL);
|
||||
KUNIT_ASSERT_EQ(test, ret, 0);
|
||||
|
||||
drm_connector_helper_add(&priv->connector, &drm_client_modeset_connector_helper_funcs);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void drm_test_pick_cmdline_res_1920_1080_60(struct kunit *test)
|
||||
{
|
||||
struct drm_client_modeset_test_priv *priv = test->priv;
|
||||
struct drm_device *drm = priv->drm;
|
||||
struct drm_connector *connector = &priv->connector;
|
||||
struct drm_cmdline_mode *cmdline_mode = &connector->cmdline_mode;
|
||||
struct drm_display_mode *expected_mode, *mode;
|
||||
const char *cmdline = "1920x1080@60";
|
||||
int ret;
|
||||
|
||||
expected_mode = drm_mode_find_dmt(priv->drm, 1920, 1080, 60, false);
|
||||
KUNIT_ASSERT_NOT_NULL(test, expected_mode);
|
||||
|
||||
KUNIT_ASSERT_TRUE(test,
|
||||
drm_mode_parse_command_line_for_connector(cmdline,
|
||||
connector,
|
||||
cmdline_mode));
|
||||
|
||||
mutex_lock(&drm->mode_config.mutex);
|
||||
ret = drm_helper_probe_single_connector_modes(connector, 1920, 1080);
|
||||
mutex_unlock(&drm->mode_config.mutex);
|
||||
KUNIT_ASSERT_GT(test, ret, 0);
|
||||
|
||||
mode = drm_connector_pick_cmdline_mode(connector);
|
||||
KUNIT_ASSERT_NOT_NULL(test, mode);
|
||||
|
||||
KUNIT_EXPECT_TRUE(test, drm_mode_equal(expected_mode, mode));
|
||||
}
|
||||
|
||||
static struct kunit_case drm_test_pick_cmdline_tests[] = {
|
||||
KUNIT_CASE(drm_test_pick_cmdline_res_1920_1080_60),
|
||||
{}
|
||||
};
|
||||
|
||||
static struct kunit_suite drm_test_pick_cmdline_test_suite = {
|
||||
.name = "drm_test_pick_cmdline",
|
||||
.init = drm_client_modeset_test_init,
|
||||
.test_cases = drm_test_pick_cmdline_tests
|
||||
};
|
||||
|
||||
kunit_test_suite(drm_test_pick_cmdline_test_suite);
|
||||
@@ -5,44 +5,280 @@
|
||||
* Copyright (c) 2022 Maíra Canal <mairacanal@riseup.net>
|
||||
*/
|
||||
|
||||
#define PREFIX_STR "[drm_dp_mst_helper]"
|
||||
|
||||
#include <kunit/test.h>
|
||||
|
||||
#include <linux/random.h>
|
||||
|
||||
#include <drm/display/drm_dp_mst_helper.h>
|
||||
#include <drm/drm_print.h>
|
||||
|
||||
#include "../display/drm_dp_mst_topology_internal.h"
|
||||
|
||||
struct drm_dp_mst_calc_pbn_mode_test {
|
||||
const int clock;
|
||||
const int bpp;
|
||||
const bool dsc;
|
||||
const int expected;
|
||||
};
|
||||
|
||||
static const struct drm_dp_mst_calc_pbn_mode_test drm_dp_mst_calc_pbn_mode_cases[] = {
|
||||
{
|
||||
.clock = 154000,
|
||||
.bpp = 30,
|
||||
.dsc = false,
|
||||
.expected = 689
|
||||
},
|
||||
{
|
||||
.clock = 234000,
|
||||
.bpp = 30,
|
||||
.dsc = false,
|
||||
.expected = 1047
|
||||
},
|
||||
{
|
||||
.clock = 297000,
|
||||
.bpp = 24,
|
||||
.dsc = false,
|
||||
.expected = 1063
|
||||
},
|
||||
{
|
||||
.clock = 332880,
|
||||
.bpp = 24,
|
||||
.dsc = true,
|
||||
.expected = 50
|
||||
},
|
||||
{
|
||||
.clock = 324540,
|
||||
.bpp = 24,
|
||||
.dsc = true,
|
||||
.expected = 49
|
||||
},
|
||||
};
|
||||
|
||||
static void drm_test_dp_mst_calc_pbn_mode(struct kunit *test)
|
||||
{
|
||||
int pbn, i;
|
||||
const struct {
|
||||
int rate;
|
||||
int bpp;
|
||||
int expected;
|
||||
bool dsc;
|
||||
} test_params[] = {
|
||||
{ 154000, 30, 689, false },
|
||||
{ 234000, 30, 1047, false },
|
||||
{ 297000, 24, 1063, false },
|
||||
{ 332880, 24, 50, true },
|
||||
{ 324540, 24, 49, true },
|
||||
};
|
||||
const struct drm_dp_mst_calc_pbn_mode_test *params = test->param_value;
|
||||
|
||||
for (i = 0; i < ARRAY_SIZE(test_params); i++) {
|
||||
pbn = drm_dp_calc_pbn_mode(test_params[i].rate,
|
||||
test_params[i].bpp,
|
||||
test_params[i].dsc);
|
||||
KUNIT_EXPECT_EQ_MSG(test, pbn, test_params[i].expected,
|
||||
"Expected PBN %d for clock %d bpp %d, got %d\n",
|
||||
test_params[i].expected, test_params[i].rate,
|
||||
test_params[i].bpp, pbn);
|
||||
}
|
||||
KUNIT_EXPECT_EQ(test, drm_dp_calc_pbn_mode(params->clock, params->bpp, params->dsc),
|
||||
params->expected);
|
||||
}
|
||||
|
||||
static void dp_mst_calc_pbn_mode_desc(const struct drm_dp_mst_calc_pbn_mode_test *t, char *desc)
|
||||
{
|
||||
sprintf(desc, "Clock %d BPP %d DSC %s", t->clock, t->bpp, t->dsc ? "enabled" : "disabled");
|
||||
}
|
||||
|
||||
KUNIT_ARRAY_PARAM(drm_dp_mst_calc_pbn_mode, drm_dp_mst_calc_pbn_mode_cases,
|
||||
dp_mst_calc_pbn_mode_desc);
|
||||
|
||||
static u8 data[] = { 0xff, 0x00, 0xdd };
|
||||
|
||||
struct drm_dp_mst_sideband_msg_req_test {
|
||||
const char *desc;
|
||||
const struct drm_dp_sideband_msg_req_body in;
|
||||
};
|
||||
|
||||
static const struct drm_dp_mst_sideband_msg_req_test drm_dp_mst_sideband_msg_req_cases[] = {
|
||||
{
|
||||
.desc = "DP_ENUM_PATH_RESOURCES with port number",
|
||||
.in = {
|
||||
.req_type = DP_ENUM_PATH_RESOURCES,
|
||||
.u.port_num.port_number = 5,
|
||||
},
|
||||
},
|
||||
{
|
||||
.desc = "DP_POWER_UP_PHY with port number",
|
||||
.in = {
|
||||
.req_type = DP_POWER_UP_PHY,
|
||||
.u.port_num.port_number = 5,
|
||||
},
|
||||
},
|
||||
{
|
||||
.desc = "DP_POWER_DOWN_PHY with port number",
|
||||
.in = {
|
||||
.req_type = DP_POWER_DOWN_PHY,
|
||||
.u.port_num.port_number = 5,
|
||||
},
|
||||
},
|
||||
{
|
||||
.desc = "DP_ALLOCATE_PAYLOAD with SDP stream sinks",
|
||||
.in = {
|
||||
.req_type = DP_ALLOCATE_PAYLOAD,
|
||||
.u.allocate_payload.number_sdp_streams = 3,
|
||||
.u.allocate_payload.sdp_stream_sink = { 1, 2, 3 },
|
||||
},
|
||||
},
|
||||
{
|
||||
.desc = "DP_ALLOCATE_PAYLOAD with port number",
|
||||
.in = {
|
||||
.req_type = DP_ALLOCATE_PAYLOAD,
|
||||
.u.allocate_payload.port_number = 0xf,
|
||||
},
|
||||
},
|
||||
{
|
||||
.desc = "DP_ALLOCATE_PAYLOAD with VCPI",
|
||||
.in = {
|
||||
.req_type = DP_ALLOCATE_PAYLOAD,
|
||||
.u.allocate_payload.vcpi = 0x7f,
|
||||
},
|
||||
},
|
||||
{
|
||||
.desc = "DP_ALLOCATE_PAYLOAD with PBN",
|
||||
.in = {
|
||||
.req_type = DP_ALLOCATE_PAYLOAD,
|
||||
.u.allocate_payload.pbn = U16_MAX,
|
||||
},
|
||||
},
|
||||
{
|
||||
.desc = "DP_QUERY_PAYLOAD with port number",
|
||||
.in = {
|
||||
.req_type = DP_QUERY_PAYLOAD,
|
||||
.u.query_payload.port_number = 0xf,
|
||||
},
|
||||
},
|
||||
{
|
||||
.desc = "DP_QUERY_PAYLOAD with VCPI",
|
||||
.in = {
|
||||
.req_type = DP_QUERY_PAYLOAD,
|
||||
.u.query_payload.vcpi = 0x7f,
|
||||
},
|
||||
},
|
||||
{
|
||||
.desc = "DP_REMOTE_DPCD_READ with port number",
|
||||
.in = {
|
||||
.req_type = DP_REMOTE_DPCD_READ,
|
||||
.u.dpcd_read.port_number = 0xf,
|
||||
},
|
||||
},
|
||||
{
|
||||
.desc = "DP_REMOTE_DPCD_READ with DPCD address",
|
||||
.in = {
|
||||
.req_type = DP_REMOTE_DPCD_READ,
|
||||
.u.dpcd_read.dpcd_address = 0xfedcb,
|
||||
},
|
||||
},
|
||||
{
|
||||
.desc = "DP_REMOTE_DPCD_READ with max number of bytes",
|
||||
.in = {
|
||||
.req_type = DP_REMOTE_DPCD_READ,
|
||||
.u.dpcd_read.num_bytes = U8_MAX,
|
||||
},
|
||||
},
|
||||
{
|
||||
.desc = "DP_REMOTE_DPCD_WRITE with port number",
|
||||
.in = {
|
||||
.req_type = DP_REMOTE_DPCD_WRITE,
|
||||
.u.dpcd_write.port_number = 0xf,
|
||||
},
|
||||
},
|
||||
{
|
||||
.desc = "DP_REMOTE_DPCD_WRITE with DPCD address",
|
||||
.in = {
|
||||
.req_type = DP_REMOTE_DPCD_WRITE,
|
||||
.u.dpcd_write.dpcd_address = 0xfedcb,
|
||||
},
|
||||
},
|
||||
{
|
||||
.desc = "DP_REMOTE_DPCD_WRITE with data array",
|
||||
.in = {
|
||||
.req_type = DP_REMOTE_DPCD_WRITE,
|
||||
.u.dpcd_write.num_bytes = ARRAY_SIZE(data),
|
||||
.u.dpcd_write.bytes = data,
|
||||
},
|
||||
},
|
||||
{
|
||||
.desc = "DP_REMOTE_I2C_READ with port number",
|
||||
.in = {
|
||||
.req_type = DP_REMOTE_I2C_READ,
|
||||
.u.i2c_read.port_number = 0xf,
|
||||
},
|
||||
},
|
||||
{
|
||||
.desc = "DP_REMOTE_I2C_READ with I2C device ID",
|
||||
.in = {
|
||||
.req_type = DP_REMOTE_I2C_READ,
|
||||
.u.i2c_read.read_i2c_device_id = 0x7f,
|
||||
},
|
||||
},
|
||||
{
|
||||
.desc = "DP_REMOTE_I2C_READ with transactions array",
|
||||
.in = {
|
||||
.req_type = DP_REMOTE_I2C_READ,
|
||||
.u.i2c_read.num_transactions = 3,
|
||||
.u.i2c_read.num_bytes_read = ARRAY_SIZE(data) * 3,
|
||||
.u.i2c_read.transactions = {
|
||||
{ .bytes = data, .num_bytes = ARRAY_SIZE(data), .i2c_dev_id = 0x7f,
|
||||
.i2c_transaction_delay = 0xf, },
|
||||
{ .bytes = data, .num_bytes = ARRAY_SIZE(data), .i2c_dev_id = 0x7e,
|
||||
.i2c_transaction_delay = 0xe, },
|
||||
{ .bytes = data, .num_bytes = ARRAY_SIZE(data), .i2c_dev_id = 0x7d,
|
||||
.i2c_transaction_delay = 0xd, },
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
.desc = "DP_REMOTE_I2C_WRITE with port number",
|
||||
.in = {
|
||||
.req_type = DP_REMOTE_I2C_WRITE,
|
||||
.u.i2c_write.port_number = 0xf,
|
||||
},
|
||||
},
|
||||
{
|
||||
.desc = "DP_REMOTE_I2C_WRITE with I2C device ID",
|
||||
.in = {
|
||||
.req_type = DP_REMOTE_I2C_WRITE,
|
||||
.u.i2c_write.write_i2c_device_id = 0x7f,
|
||||
},
|
||||
},
|
||||
{
|
||||
.desc = "DP_REMOTE_I2C_WRITE with data array",
|
||||
.in = {
|
||||
.req_type = DP_REMOTE_I2C_WRITE,
|
||||
.u.i2c_write.num_bytes = ARRAY_SIZE(data),
|
||||
.u.i2c_write.bytes = data,
|
||||
},
|
||||
},
|
||||
{
|
||||
.desc = "DP_QUERY_STREAM_ENC_STATUS with stream ID",
|
||||
.in = {
|
||||
.req_type = DP_QUERY_STREAM_ENC_STATUS,
|
||||
.u.enc_status.stream_id = 1,
|
||||
},
|
||||
},
|
||||
{
|
||||
.desc = "DP_QUERY_STREAM_ENC_STATUS with client ID",
|
||||
.in = {
|
||||
.req_type = DP_QUERY_STREAM_ENC_STATUS,
|
||||
.u.enc_status.client_id = { 0x4f, 0x7f, 0xb4, 0x00, 0x8c, 0x0d, 0x67 },
|
||||
},
|
||||
},
|
||||
{
|
||||
.desc = "DP_QUERY_STREAM_ENC_STATUS with stream event",
|
||||
.in = {
|
||||
.req_type = DP_QUERY_STREAM_ENC_STATUS,
|
||||
.u.enc_status.stream_event = 3,
|
||||
},
|
||||
},
|
||||
{
|
||||
.desc = "DP_QUERY_STREAM_ENC_STATUS with valid stream event",
|
||||
.in = {
|
||||
.req_type = DP_QUERY_STREAM_ENC_STATUS,
|
||||
.u.enc_status.valid_stream_event = 0,
|
||||
},
|
||||
},
|
||||
{
|
||||
.desc = "DP_QUERY_STREAM_ENC_STATUS with stream behavior",
|
||||
.in = {
|
||||
.req_type = DP_QUERY_STREAM_ENC_STATUS,
|
||||
.u.enc_status.stream_behavior = 3,
|
||||
},
|
||||
},
|
||||
{
|
||||
.desc = "DP_QUERY_STREAM_ENC_STATUS with a valid stream behavior",
|
||||
.in = {
|
||||
.req_type = DP_QUERY_STREAM_ENC_STATUS,
|
||||
.u.enc_status.valid_stream_behavior = 1,
|
||||
}
|
||||
},
|
||||
};
|
||||
|
||||
static bool
|
||||
sideband_msg_req_equal(const struct drm_dp_sideband_msg_req_body *in,
|
||||
const struct drm_dp_sideband_msg_req_body *out)
|
||||
@@ -118,41 +354,41 @@ sideband_msg_req_equal(const struct drm_dp_sideband_msg_req_body *in,
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool
|
||||
sideband_msg_req_encode_decode(struct drm_dp_sideband_msg_req_body *in)
|
||||
static void drm_test_dp_mst_msg_printf(struct drm_printer *p, struct va_format *vaf)
|
||||
{
|
||||
struct kunit *test = p->arg;
|
||||
|
||||
kunit_err(test, "%pV", vaf);
|
||||
}
|
||||
|
||||
static void drm_test_dp_mst_sideband_msg_req_decode(struct kunit *test)
|
||||
{
|
||||
const struct drm_dp_mst_sideband_msg_req_test *params = test->param_value;
|
||||
const struct drm_dp_sideband_msg_req_body *in = ¶ms->in;
|
||||
struct drm_dp_sideband_msg_req_body *out;
|
||||
struct drm_printer p = drm_err_printer(PREFIX_STR);
|
||||
struct drm_dp_sideband_msg_tx *txmsg;
|
||||
int i, ret;
|
||||
bool result = true;
|
||||
struct drm_printer p = {
|
||||
.printfn = drm_test_dp_mst_msg_printf,
|
||||
.arg = test
|
||||
};
|
||||
int i;
|
||||
|
||||
out = kzalloc(sizeof(*out), GFP_KERNEL);
|
||||
if (!out)
|
||||
return false;
|
||||
out = kunit_kzalloc(test, sizeof(*out), GFP_KERNEL);
|
||||
KUNIT_ASSERT_NOT_NULL(test, out);
|
||||
|
||||
txmsg = kzalloc(sizeof(*txmsg), GFP_KERNEL);
|
||||
if (!txmsg) {
|
||||
kfree(out);
|
||||
return false;
|
||||
}
|
||||
txmsg = kunit_kzalloc(test, sizeof(*txmsg), GFP_KERNEL);
|
||||
KUNIT_ASSERT_NOT_NULL(test, txmsg);
|
||||
|
||||
drm_dp_encode_sideband_req(in, txmsg);
|
||||
ret = drm_dp_decode_sideband_req(txmsg, out);
|
||||
if (ret < 0) {
|
||||
drm_printf(&p, "Failed to decode sideband request: %d\n",
|
||||
ret);
|
||||
result = false;
|
||||
goto out;
|
||||
}
|
||||
KUNIT_EXPECT_GE_MSG(test, drm_dp_decode_sideband_req(txmsg, out), 0,
|
||||
"Failed to decode sideband request");
|
||||
|
||||
if (!sideband_msg_req_equal(in, out)) {
|
||||
drm_printf(&p, "Encode/decode failed, expected:\n");
|
||||
KUNIT_FAIL(test, "Encode/decode failed");
|
||||
kunit_err(test, "Expected:");
|
||||
drm_dp_dump_sideband_msg_req_body(in, 1, &p);
|
||||
drm_printf(&p, "Got:\n");
|
||||
kunit_err(test, "Got:");
|
||||
drm_dp_dump_sideband_msg_req_body(out, 1, &p);
|
||||
result = false;
|
||||
goto out;
|
||||
}
|
||||
|
||||
switch (in->req_type) {
|
||||
@@ -167,112 +403,21 @@ sideband_msg_req_encode_decode(struct drm_dp_sideband_msg_req_body *in)
|
||||
kfree(out->u.i2c_write.bytes);
|
||||
break;
|
||||
}
|
||||
|
||||
/* Clear everything but the req_type for the input */
|
||||
memset(&in->u, 0, sizeof(in->u));
|
||||
|
||||
out:
|
||||
kfree(out);
|
||||
kfree(txmsg);
|
||||
return result;
|
||||
}
|
||||
|
||||
static void drm_test_dp_mst_sideband_msg_req_decode(struct kunit *test)
|
||||
static void
|
||||
drm_dp_mst_sideband_msg_req_desc(const struct drm_dp_mst_sideband_msg_req_test *t, char *desc)
|
||||
{
|
||||
struct drm_dp_sideband_msg_req_body in = { 0 };
|
||||
u8 data[] = { 0xff, 0x0, 0xdd };
|
||||
int i;
|
||||
|
||||
in.req_type = DP_ENUM_PATH_RESOURCES;
|
||||
in.u.port_num.port_number = 5;
|
||||
KUNIT_EXPECT_TRUE(test, sideband_msg_req_encode_decode(&in));
|
||||
|
||||
in.req_type = DP_POWER_UP_PHY;
|
||||
in.u.port_num.port_number = 5;
|
||||
KUNIT_EXPECT_TRUE(test, sideband_msg_req_encode_decode(&in));
|
||||
|
||||
in.req_type = DP_POWER_DOWN_PHY;
|
||||
in.u.port_num.port_number = 5;
|
||||
KUNIT_EXPECT_TRUE(test, sideband_msg_req_encode_decode(&in));
|
||||
|
||||
in.req_type = DP_ALLOCATE_PAYLOAD;
|
||||
in.u.allocate_payload.number_sdp_streams = 3;
|
||||
for (i = 0; i < in.u.allocate_payload.number_sdp_streams; i++)
|
||||
in.u.allocate_payload.sdp_stream_sink[i] = i + 1;
|
||||
KUNIT_EXPECT_TRUE(test, sideband_msg_req_encode_decode(&in));
|
||||
in.u.allocate_payload.port_number = 0xf;
|
||||
KUNIT_EXPECT_TRUE(test, sideband_msg_req_encode_decode(&in));
|
||||
in.u.allocate_payload.vcpi = 0x7f;
|
||||
KUNIT_EXPECT_TRUE(test, sideband_msg_req_encode_decode(&in));
|
||||
in.u.allocate_payload.pbn = U16_MAX;
|
||||
KUNIT_EXPECT_TRUE(test, sideband_msg_req_encode_decode(&in));
|
||||
|
||||
in.req_type = DP_QUERY_PAYLOAD;
|
||||
in.u.query_payload.port_number = 0xf;
|
||||
KUNIT_EXPECT_TRUE(test, sideband_msg_req_encode_decode(&in));
|
||||
in.u.query_payload.vcpi = 0x7f;
|
||||
KUNIT_EXPECT_TRUE(test, sideband_msg_req_encode_decode(&in));
|
||||
|
||||
in.req_type = DP_REMOTE_DPCD_READ;
|
||||
in.u.dpcd_read.port_number = 0xf;
|
||||
KUNIT_EXPECT_TRUE(test, sideband_msg_req_encode_decode(&in));
|
||||
in.u.dpcd_read.dpcd_address = 0xfedcb;
|
||||
KUNIT_EXPECT_TRUE(test, sideband_msg_req_encode_decode(&in));
|
||||
in.u.dpcd_read.num_bytes = U8_MAX;
|
||||
KUNIT_EXPECT_TRUE(test, sideband_msg_req_encode_decode(&in));
|
||||
|
||||
in.req_type = DP_REMOTE_DPCD_WRITE;
|
||||
in.u.dpcd_write.port_number = 0xf;
|
||||
KUNIT_EXPECT_TRUE(test, sideband_msg_req_encode_decode(&in));
|
||||
in.u.dpcd_write.dpcd_address = 0xfedcb;
|
||||
KUNIT_EXPECT_TRUE(test, sideband_msg_req_encode_decode(&in));
|
||||
in.u.dpcd_write.num_bytes = ARRAY_SIZE(data);
|
||||
in.u.dpcd_write.bytes = data;
|
||||
KUNIT_EXPECT_TRUE(test, sideband_msg_req_encode_decode(&in));
|
||||
|
||||
in.req_type = DP_REMOTE_I2C_READ;
|
||||
in.u.i2c_read.port_number = 0xf;
|
||||
KUNIT_EXPECT_TRUE(test, sideband_msg_req_encode_decode(&in));
|
||||
in.u.i2c_read.read_i2c_device_id = 0x7f;
|
||||
KUNIT_EXPECT_TRUE(test, sideband_msg_req_encode_decode(&in));
|
||||
in.u.i2c_read.num_transactions = 3;
|
||||
in.u.i2c_read.num_bytes_read = ARRAY_SIZE(data) * 3;
|
||||
for (i = 0; i < in.u.i2c_read.num_transactions; i++) {
|
||||
in.u.i2c_read.transactions[i].bytes = data;
|
||||
in.u.i2c_read.transactions[i].num_bytes = ARRAY_SIZE(data);
|
||||
in.u.i2c_read.transactions[i].i2c_dev_id = 0x7f & ~i;
|
||||
in.u.i2c_read.transactions[i].i2c_transaction_delay = 0xf & ~i;
|
||||
}
|
||||
KUNIT_EXPECT_TRUE(test, sideband_msg_req_encode_decode(&in));
|
||||
|
||||
in.req_type = DP_REMOTE_I2C_WRITE;
|
||||
in.u.i2c_write.port_number = 0xf;
|
||||
KUNIT_EXPECT_TRUE(test, sideband_msg_req_encode_decode(&in));
|
||||
in.u.i2c_write.write_i2c_device_id = 0x7f;
|
||||
KUNIT_EXPECT_TRUE(test, sideband_msg_req_encode_decode(&in));
|
||||
in.u.i2c_write.num_bytes = ARRAY_SIZE(data);
|
||||
in.u.i2c_write.bytes = data;
|
||||
KUNIT_EXPECT_TRUE(test, sideband_msg_req_encode_decode(&in));
|
||||
|
||||
in.req_type = DP_QUERY_STREAM_ENC_STATUS;
|
||||
in.u.enc_status.stream_id = 1;
|
||||
KUNIT_EXPECT_TRUE(test, sideband_msg_req_encode_decode(&in));
|
||||
get_random_bytes(in.u.enc_status.client_id,
|
||||
sizeof(in.u.enc_status.client_id));
|
||||
KUNIT_EXPECT_TRUE(test, sideband_msg_req_encode_decode(&in));
|
||||
in.u.enc_status.stream_event = 3;
|
||||
KUNIT_EXPECT_TRUE(test, sideband_msg_req_encode_decode(&in));
|
||||
in.u.enc_status.valid_stream_event = 0;
|
||||
KUNIT_EXPECT_TRUE(test, sideband_msg_req_encode_decode(&in));
|
||||
in.u.enc_status.stream_behavior = 3;
|
||||
KUNIT_EXPECT_TRUE(test, sideband_msg_req_encode_decode(&in));
|
||||
in.u.enc_status.valid_stream_behavior = 1;
|
||||
KUNIT_EXPECT_TRUE(test, sideband_msg_req_encode_decode(&in));
|
||||
strcpy(desc, t->desc);
|
||||
}
|
||||
|
||||
KUNIT_ARRAY_PARAM(drm_dp_mst_sideband_msg_req, drm_dp_mst_sideband_msg_req_cases,
|
||||
drm_dp_mst_sideband_msg_req_desc);
|
||||
|
||||
static struct kunit_case drm_dp_mst_helper_tests[] = {
|
||||
KUNIT_CASE(drm_test_dp_mst_calc_pbn_mode),
|
||||
KUNIT_CASE(drm_test_dp_mst_sideband_msg_req_decode),
|
||||
KUNIT_CASE_PARAM(drm_test_dp_mst_calc_pbn_mode, drm_dp_mst_calc_pbn_mode_gen_params),
|
||||
KUNIT_CASE_PARAM(drm_test_dp_mst_sideband_msg_req_decode,
|
||||
drm_dp_mst_sideband_msg_req_gen_params),
|
||||
{ }
|
||||
};
|
||||
|
||||
|
||||
71
drivers/gpu/drm/tests/drm_kunit_helpers.c
Normal file
71
drivers/gpu/drm/tests/drm_kunit_helpers.c
Normal file
@@ -0,0 +1,71 @@
|
||||
// SPDX-License-Identifier: GPL-2.0
|
||||
|
||||
#include <drm/drm_drv.h>
|
||||
#include <drm/drm_managed.h>
|
||||
|
||||
#include <kunit/resource.h>
|
||||
|
||||
#include <linux/device.h>
|
||||
|
||||
#include "drm_kunit_helpers.h"
|
||||
|
||||
struct kunit_dev {
|
||||
struct drm_device base;
|
||||
};
|
||||
|
||||
static const struct drm_mode_config_funcs drm_mode_config_funcs = {
|
||||
};
|
||||
|
||||
static int dev_init(struct kunit_resource *res, void *ptr)
|
||||
{
|
||||
char *name = ptr;
|
||||
struct device *dev;
|
||||
|
||||
dev = root_device_register(name);
|
||||
if (IS_ERR(dev))
|
||||
return PTR_ERR(dev);
|
||||
|
||||
res->data = dev;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void dev_free(struct kunit_resource *res)
|
||||
{
|
||||
struct device *dev = res->data;
|
||||
|
||||
root_device_unregister(dev);
|
||||
}
|
||||
|
||||
struct drm_device *drm_kunit_device_init(struct kunit *test, u32 features, char *name)
|
||||
{
|
||||
struct kunit_dev *kdev;
|
||||
struct drm_device *drm;
|
||||
struct drm_driver *driver;
|
||||
struct device *dev;
|
||||
int ret;
|
||||
|
||||
dev = kunit_alloc_resource(test, dev_init, dev_free, GFP_KERNEL, name);
|
||||
if (!dev)
|
||||
return ERR_PTR(-ENOMEM);
|
||||
|
||||
driver = kunit_kzalloc(test, sizeof(*driver), GFP_KERNEL);
|
||||
if (!driver)
|
||||
return ERR_PTR(-ENOMEM);
|
||||
|
||||
driver->driver_features = features;
|
||||
kdev = devm_drm_dev_alloc(dev, driver, struct kunit_dev, base);
|
||||
if (IS_ERR(kdev))
|
||||
return ERR_CAST(kdev);
|
||||
|
||||
drm = &kdev->base;
|
||||
drm->mode_config.funcs = &drm_mode_config_funcs;
|
||||
|
||||
ret = drmm_mode_config_init(drm);
|
||||
if (ret)
|
||||
return ERR_PTR(ret);
|
||||
|
||||
return drm;
|
||||
}
|
||||
|
||||
MODULE_AUTHOR("Maxime Ripard <maxime@cerno.tech>");
|
||||
MODULE_LICENSE("GPL");
|
||||
11
drivers/gpu/drm/tests/drm_kunit_helpers.h
Normal file
11
drivers/gpu/drm/tests/drm_kunit_helpers.h
Normal file
@@ -0,0 +1,11 @@
|
||||
// SPDX-License-Identifier: GPL-2.0
|
||||
|
||||
#ifndef DRM_KUNIT_HELPERS_H_
|
||||
#define DRM_KUNIT_HELPERS_H_
|
||||
|
||||
struct drm_device;
|
||||
struct kunit;
|
||||
|
||||
struct drm_device *drm_kunit_device_init(struct kunit *test, u32 features, char *name);
|
||||
|
||||
#endif // DRM_KUNIT_HELPERS_H_
|
||||
@@ -2209,11 +2209,15 @@ err_nodes:
|
||||
vfree(nodes);
|
||||
}
|
||||
|
||||
static int drm_mm_init_test(struct kunit *test)
|
||||
static int drm_mm_suite_init(struct kunit_suite *suite)
|
||||
{
|
||||
while (!random_seed)
|
||||
random_seed = get_random_u32();
|
||||
|
||||
kunit_info(suite,
|
||||
"Testing DRM range manager, with random_seed=0x%x max_iterations=%u max_prime=%u\n",
|
||||
random_seed, max_iterations, max_prime);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -2246,7 +2250,7 @@ static struct kunit_case drm_mm_tests[] = {
|
||||
|
||||
static struct kunit_suite drm_mm_test_suite = {
|
||||
.name = "drm_mm",
|
||||
.init = drm_mm_init_test,
|
||||
.suite_init = drm_mm_suite_init,
|
||||
.test_cases = drm_mm_tests,
|
||||
};
|
||||
|
||||
|
||||
@@ -10,225 +10,306 @@
|
||||
#include <drm/drm_atomic_helper.h>
|
||||
#include <drm/drm_framebuffer.h>
|
||||
#include <drm/drm_modes.h>
|
||||
#include <drm/drm_rect.h>
|
||||
|
||||
static void set_src(struct drm_plane_state *plane_state,
|
||||
unsigned int src_x, unsigned int src_y,
|
||||
unsigned int src_w, unsigned int src_h)
|
||||
static const struct drm_crtc_state crtc_state = {
|
||||
.crtc = ZERO_SIZE_PTR,
|
||||
.enable = true,
|
||||
.active = true,
|
||||
.mode = {
|
||||
DRM_MODE("1024x768", 0, 65000, 1024, 1048,
|
||||
1184, 1344, 0, 768, 771, 777, 806, 0,
|
||||
DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC)
|
||||
},
|
||||
};
|
||||
|
||||
struct drm_check_plane_state_test {
|
||||
const char *name;
|
||||
const char *msg;
|
||||
struct {
|
||||
unsigned int x;
|
||||
unsigned int y;
|
||||
unsigned int w;
|
||||
unsigned int h;
|
||||
} src, src_expected;
|
||||
struct {
|
||||
int x;
|
||||
int y;
|
||||
unsigned int w;
|
||||
unsigned int h;
|
||||
} crtc, crtc_expected;
|
||||
unsigned int rotation;
|
||||
int min_scale;
|
||||
int max_scale;
|
||||
bool can_position;
|
||||
};
|
||||
|
||||
static int drm_plane_helper_init(struct kunit *test)
|
||||
{
|
||||
plane_state->src_x = src_x;
|
||||
plane_state->src_y = src_y;
|
||||
plane_state->src_w = src_w;
|
||||
plane_state->src_h = src_h;
|
||||
const struct drm_check_plane_state_test *params = test->param_value;
|
||||
struct drm_plane *plane;
|
||||
struct drm_framebuffer *fb;
|
||||
struct drm_plane_state *mock;
|
||||
|
||||
plane = kunit_kzalloc(test, sizeof(*plane), GFP_KERNEL);
|
||||
KUNIT_ASSERT_NOT_NULL(test, plane);
|
||||
|
||||
fb = kunit_kzalloc(test, sizeof(*fb), GFP_KERNEL);
|
||||
KUNIT_ASSERT_NOT_NULL(test, fb);
|
||||
fb->width = 2048;
|
||||
fb->height = 2048;
|
||||
|
||||
mock = kunit_kzalloc(test, sizeof(*mock), GFP_KERNEL);
|
||||
KUNIT_ASSERT_NOT_NULL(test, mock);
|
||||
mock->plane = plane;
|
||||
mock->crtc = ZERO_SIZE_PTR;
|
||||
mock->fb = fb;
|
||||
mock->rotation = params->rotation;
|
||||
mock->src_x = params->src.x;
|
||||
mock->src_y = params->src.y;
|
||||
mock->src_w = params->src.w;
|
||||
mock->src_h = params->src.h;
|
||||
mock->crtc_x = params->crtc.x;
|
||||
mock->crtc_y = params->crtc.y;
|
||||
mock->crtc_w = params->crtc.w;
|
||||
mock->crtc_h = params->crtc.h;
|
||||
|
||||
test->priv = mock;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static bool check_src_eq(struct drm_plane_state *plane_state,
|
||||
static void check_src_eq(struct kunit *test, struct drm_plane_state *plane_state,
|
||||
unsigned int src_x, unsigned int src_y,
|
||||
unsigned int src_w, unsigned int src_h)
|
||||
{
|
||||
if (plane_state->src.x1 < 0) {
|
||||
pr_err("src x coordinate %x should never be below 0.\n", plane_state->src.x1);
|
||||
drm_rect_debug_print("src: ", &plane_state->src, true);
|
||||
return false;
|
||||
}
|
||||
if (plane_state->src.y1 < 0) {
|
||||
pr_err("src y coordinate %x should never be below 0.\n", plane_state->src.y1);
|
||||
drm_rect_debug_print("src: ", &plane_state->src, true);
|
||||
return false;
|
||||
}
|
||||
struct drm_rect expected = DRM_RECT_INIT(src_x, src_y, src_w, src_h);
|
||||
|
||||
if (plane_state->src.x1 != src_x ||
|
||||
plane_state->src.y1 != src_y ||
|
||||
drm_rect_width(&plane_state->src) != src_w ||
|
||||
drm_rect_height(&plane_state->src) != src_h) {
|
||||
drm_rect_debug_print("src: ", &plane_state->src, true);
|
||||
return false;
|
||||
}
|
||||
KUNIT_ASSERT_GE_MSG(test, plane_state->src.x1, 0,
|
||||
"src x coordinate %x should never be below 0, src: " DRM_RECT_FP_FMT,
|
||||
plane_state->src.x1, DRM_RECT_FP_ARG(&plane_state->src));
|
||||
|
||||
return true;
|
||||
KUNIT_ASSERT_GE_MSG(test, plane_state->src.y1, 0,
|
||||
"src y coordinate %x should never be below 0, src: " DRM_RECT_FP_FMT,
|
||||
plane_state->src.y1, DRM_RECT_FP_ARG(&plane_state->src));
|
||||
|
||||
KUNIT_EXPECT_TRUE_MSG(test, drm_rect_equals(&plane_state->src, &expected),
|
||||
"dst: " DRM_RECT_FP_FMT ", expected: " DRM_RECT_FP_FMT,
|
||||
DRM_RECT_FP_ARG(&plane_state->src), DRM_RECT_FP_ARG(&expected));
|
||||
}
|
||||
|
||||
static void set_crtc(struct drm_plane_state *plane_state,
|
||||
int crtc_x, int crtc_y,
|
||||
unsigned int crtc_w, unsigned int crtc_h)
|
||||
{
|
||||
plane_state->crtc_x = crtc_x;
|
||||
plane_state->crtc_y = crtc_y;
|
||||
plane_state->crtc_w = crtc_w;
|
||||
plane_state->crtc_h = crtc_h;
|
||||
}
|
||||
|
||||
static bool check_crtc_eq(struct drm_plane_state *plane_state,
|
||||
static void check_crtc_eq(struct kunit *test, struct drm_plane_state *plane_state,
|
||||
int crtc_x, int crtc_y,
|
||||
unsigned int crtc_w, unsigned int crtc_h)
|
||||
{
|
||||
if (plane_state->dst.x1 != crtc_x ||
|
||||
plane_state->dst.y1 != crtc_y ||
|
||||
drm_rect_width(&plane_state->dst) != crtc_w ||
|
||||
drm_rect_height(&plane_state->dst) != crtc_h) {
|
||||
drm_rect_debug_print("dst: ", &plane_state->dst, false);
|
||||
struct drm_rect expected = DRM_RECT_INIT(crtc_x, crtc_y, crtc_w, crtc_h);
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
KUNIT_EXPECT_TRUE_MSG(test, drm_rect_equals(&plane_state->dst, &expected),
|
||||
"dst: " DRM_RECT_FMT ", expected: " DRM_RECT_FMT,
|
||||
DRM_RECT_ARG(&plane_state->dst), DRM_RECT_ARG(&expected));
|
||||
}
|
||||
|
||||
static void drm_test_check_plane_state(struct kunit *test)
|
||||
{
|
||||
int ret;
|
||||
const struct drm_check_plane_state_test *params = test->param_value;
|
||||
struct drm_plane_state *plane_state = test->priv;
|
||||
|
||||
static const struct drm_crtc_state crtc_state = {
|
||||
.crtc = ZERO_SIZE_PTR,
|
||||
.enable = true,
|
||||
.active = true,
|
||||
.mode = {
|
||||
DRM_MODE("1024x768", 0, 65000, 1024, 1048, 1184, 1344, 0, 768, 771,
|
||||
777, 806, 0, DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC)
|
||||
},
|
||||
};
|
||||
static struct drm_plane plane = {
|
||||
.dev = NULL
|
||||
};
|
||||
static struct drm_framebuffer fb = {
|
||||
.width = 2048,
|
||||
.height = 2048
|
||||
};
|
||||
static struct drm_plane_state plane_state = {
|
||||
.plane = &plane,
|
||||
.crtc = ZERO_SIZE_PTR,
|
||||
.fb = &fb,
|
||||
.rotation = DRM_MODE_ROTATE_0
|
||||
};
|
||||
|
||||
/* Simple clipping, no scaling. */
|
||||
set_src(&plane_state, 0, 0, fb.width << 16, fb.height << 16);
|
||||
set_crtc(&plane_state, 0, 0, fb.width, fb.height);
|
||||
ret = drm_atomic_helper_check_plane_state(&plane_state, &crtc_state,
|
||||
DRM_PLANE_NO_SCALING,
|
||||
DRM_PLANE_NO_SCALING,
|
||||
false, false);
|
||||
KUNIT_EXPECT_FALSE_MSG(test, ret, 0, "Simple clipping check should pass\n");
|
||||
KUNIT_EXPECT_TRUE(test, plane_state.visible);
|
||||
KUNIT_EXPECT_TRUE(test, check_src_eq(&plane_state, 0, 0, 1024 << 16, 768 << 16));
|
||||
KUNIT_EXPECT_TRUE(test, check_crtc_eq(&plane_state, 0, 0, 1024, 768));
|
||||
|
||||
/* Rotated clipping + reflection, no scaling. */
|
||||
plane_state.rotation = DRM_MODE_ROTATE_90 | DRM_MODE_REFLECT_X;
|
||||
ret = drm_atomic_helper_check_plane_state(&plane_state, &crtc_state,
|
||||
DRM_PLANE_NO_SCALING,
|
||||
DRM_PLANE_NO_SCALING,
|
||||
false, false);
|
||||
KUNIT_EXPECT_FALSE_MSG(test, ret, 0, "Rotated clipping check should pass\n");
|
||||
KUNIT_EXPECT_TRUE(test, plane_state.visible);
|
||||
KUNIT_EXPECT_TRUE(test, check_src_eq(&plane_state, 0, 0, 768 << 16, 1024 << 16));
|
||||
KUNIT_EXPECT_TRUE(test, check_crtc_eq(&plane_state, 0, 0, 1024, 768));
|
||||
plane_state.rotation = DRM_MODE_ROTATE_0;
|
||||
|
||||
/* Check whether positioning works correctly. */
|
||||
set_src(&plane_state, 0, 0, 1023 << 16, 767 << 16);
|
||||
set_crtc(&plane_state, 0, 0, 1023, 767);
|
||||
ret = drm_atomic_helper_check_plane_state(&plane_state, &crtc_state,
|
||||
DRM_PLANE_NO_SCALING,
|
||||
DRM_PLANE_NO_SCALING,
|
||||
false, false);
|
||||
KUNIT_EXPECT_TRUE_MSG(test, ret,
|
||||
"Should not be able to position on the crtc with can_position=false\n");
|
||||
|
||||
ret = drm_atomic_helper_check_plane_state(&plane_state, &crtc_state,
|
||||
DRM_PLANE_NO_SCALING,
|
||||
DRM_PLANE_NO_SCALING,
|
||||
true, false);
|
||||
KUNIT_EXPECT_FALSE_MSG(test, ret, 0, "Simple positioning should work\n");
|
||||
KUNIT_EXPECT_TRUE(test, plane_state.visible);
|
||||
KUNIT_EXPECT_TRUE(test, check_src_eq(&plane_state, 0, 0, 1023 << 16, 767 << 16));
|
||||
KUNIT_EXPECT_TRUE(test, check_crtc_eq(&plane_state, 0, 0, 1023, 767));
|
||||
|
||||
/* Simple scaling tests. */
|
||||
set_src(&plane_state, 0, 0, 512 << 16, 384 << 16);
|
||||
set_crtc(&plane_state, 0, 0, 1024, 768);
|
||||
ret = drm_atomic_helper_check_plane_state(&plane_state, &crtc_state,
|
||||
0x8001,
|
||||
DRM_PLANE_NO_SCALING,
|
||||
false, false);
|
||||
KUNIT_EXPECT_TRUE_MSG(test, ret, "Upscaling out of range should fail.\n");
|
||||
ret = drm_atomic_helper_check_plane_state(&plane_state, &crtc_state,
|
||||
0x8000,
|
||||
DRM_PLANE_NO_SCALING,
|
||||
false, false);
|
||||
KUNIT_EXPECT_FALSE_MSG(test, ret, 0, "Upscaling exactly 2x should work\n");
|
||||
KUNIT_EXPECT_TRUE(test, plane_state.visible);
|
||||
KUNIT_EXPECT_TRUE(test, check_src_eq(&plane_state, 0, 0, 512 << 16, 384 << 16));
|
||||
KUNIT_EXPECT_TRUE(test, check_crtc_eq(&plane_state, 0, 0, 1024, 768));
|
||||
|
||||
set_src(&plane_state, 0, 0, 2048 << 16, 1536 << 16);
|
||||
ret = drm_atomic_helper_check_plane_state(&plane_state, &crtc_state,
|
||||
DRM_PLANE_NO_SCALING,
|
||||
0x1ffff, false, false);
|
||||
KUNIT_EXPECT_TRUE_MSG(test, ret, "Downscaling out of range should fail.\n");
|
||||
ret = drm_atomic_helper_check_plane_state(&plane_state, &crtc_state,
|
||||
DRM_PLANE_NO_SCALING,
|
||||
0x20000, false, false);
|
||||
KUNIT_EXPECT_FALSE_MSG(test, ret, 0, "Should succeed with exact scaling limit\n");
|
||||
KUNIT_EXPECT_TRUE(test, plane_state.visible);
|
||||
KUNIT_EXPECT_TRUE(test, check_src_eq(&plane_state, 0, 0, 2048 << 16, 1536 << 16));
|
||||
KUNIT_EXPECT_TRUE(test, check_crtc_eq(&plane_state, 0, 0, 1024, 768));
|
||||
|
||||
/* Testing rounding errors. */
|
||||
set_src(&plane_state, 0, 0, 0x40001, 0x40001);
|
||||
set_crtc(&plane_state, 1022, 766, 4, 4);
|
||||
ret = drm_atomic_helper_check_plane_state(&plane_state, &crtc_state,
|
||||
DRM_PLANE_NO_SCALING,
|
||||
0x10001,
|
||||
true, false);
|
||||
KUNIT_EXPECT_FALSE_MSG(test, ret, 0, "Should succeed by clipping to exact multiple");
|
||||
KUNIT_EXPECT_TRUE(test, plane_state.visible);
|
||||
KUNIT_EXPECT_TRUE(test, check_src_eq(&plane_state, 0, 0, 2 << 16, 2 << 16));
|
||||
KUNIT_EXPECT_TRUE(test, check_crtc_eq(&plane_state, 1022, 766, 2, 2));
|
||||
|
||||
set_src(&plane_state, 0x20001, 0x20001, 0x4040001, 0x3040001);
|
||||
set_crtc(&plane_state, -2, -2, 1028, 772);
|
||||
ret = drm_atomic_helper_check_plane_state(&plane_state, &crtc_state,
|
||||
DRM_PLANE_NO_SCALING,
|
||||
0x10001,
|
||||
false, false);
|
||||
KUNIT_EXPECT_FALSE_MSG(test, ret, 0, "Should succeed by clipping to exact multiple");
|
||||
KUNIT_EXPECT_TRUE(test, plane_state.visible);
|
||||
KUNIT_EXPECT_TRUE(test, check_src_eq(&plane_state, 0x40002, 0x40002,
|
||||
1024 << 16, 768 << 16));
|
||||
KUNIT_EXPECT_TRUE(test, check_crtc_eq(&plane_state, 0, 0, 1024, 768));
|
||||
|
||||
set_src(&plane_state, 0, 0, 0x3ffff, 0x3ffff);
|
||||
set_crtc(&plane_state, 1022, 766, 4, 4);
|
||||
ret = drm_atomic_helper_check_plane_state(&plane_state, &crtc_state,
|
||||
0xffff,
|
||||
DRM_PLANE_NO_SCALING,
|
||||
true, false);
|
||||
KUNIT_EXPECT_FALSE_MSG(test, ret, 0, "Should succeed by clipping to exact multiple");
|
||||
KUNIT_EXPECT_TRUE(test, plane_state.visible);
|
||||
/* Should not be rounded to 0x20001, which would be upscaling. */
|
||||
KUNIT_EXPECT_TRUE(test, check_src_eq(&plane_state, 0, 0, 2 << 16, 2 << 16));
|
||||
KUNIT_EXPECT_TRUE(test, check_crtc_eq(&plane_state, 1022, 766, 2, 2));
|
||||
|
||||
set_src(&plane_state, 0x1ffff, 0x1ffff, 0x403ffff, 0x303ffff);
|
||||
set_crtc(&plane_state, -2, -2, 1028, 772);
|
||||
ret = drm_atomic_helper_check_plane_state(&plane_state, &crtc_state,
|
||||
0xffff,
|
||||
DRM_PLANE_NO_SCALING,
|
||||
false, false);
|
||||
KUNIT_EXPECT_FALSE_MSG(test, ret, 0, "Should succeed by clipping to exact multiple");
|
||||
KUNIT_EXPECT_TRUE(test, plane_state.visible);
|
||||
KUNIT_EXPECT_TRUE(test, check_src_eq(&plane_state, 0x3fffe, 0x3fffe,
|
||||
1024 << 16, 768 << 16));
|
||||
KUNIT_EXPECT_TRUE(test, check_crtc_eq(&plane_state, 0, 0, 1024, 768));
|
||||
KUNIT_ASSERT_EQ_MSG(test,
|
||||
drm_atomic_helper_check_plane_state(plane_state, &crtc_state,
|
||||
params->min_scale,
|
||||
params->max_scale,
|
||||
params->can_position, false),
|
||||
0, params->msg);
|
||||
KUNIT_EXPECT_TRUE(test, plane_state->visible);
|
||||
check_src_eq(test, plane_state, params->src_expected.x, params->src_expected.y,
|
||||
params->src_expected.w, params->src_expected.h);
|
||||
check_crtc_eq(test, plane_state, params->crtc_expected.x, params->crtc_expected.y,
|
||||
params->crtc_expected.w, params->crtc_expected.h);
|
||||
}
|
||||
|
||||
static void drm_check_plane_state_desc(const struct drm_check_plane_state_test *t,
|
||||
char *desc)
|
||||
{
|
||||
sprintf(desc, "%s", t->name);
|
||||
}
|
||||
|
||||
static const struct drm_check_plane_state_test drm_check_plane_state_tests[] = {
|
||||
{
|
||||
.name = "clipping_simple",
|
||||
.msg = "Simple clipping check should pass",
|
||||
.src = { 0, 0,
|
||||
2048 << 16,
|
||||
2048 << 16 },
|
||||
.crtc = { 0, 0, 2048, 2048 },
|
||||
.rotation = DRM_MODE_ROTATE_0,
|
||||
.min_scale = DRM_PLANE_NO_SCALING,
|
||||
.max_scale = DRM_PLANE_NO_SCALING,
|
||||
.can_position = false,
|
||||
.src_expected = { 0, 0, 1024 << 16, 768 << 16 },
|
||||
.crtc_expected = { 0, 0, 1024, 768 },
|
||||
},
|
||||
{
|
||||
.name = "clipping_rotate_reflect",
|
||||
.msg = "Rotated clipping check should pass",
|
||||
.src = { 0, 0,
|
||||
2048 << 16,
|
||||
2048 << 16 },
|
||||
.crtc = { 0, 0, 2048, 2048 },
|
||||
.rotation = DRM_MODE_ROTATE_90 | DRM_MODE_REFLECT_X,
|
||||
.min_scale = DRM_PLANE_NO_SCALING,
|
||||
.max_scale = DRM_PLANE_NO_SCALING,
|
||||
.can_position = false,
|
||||
.src_expected = { 0, 0, 768 << 16, 1024 << 16 },
|
||||
.crtc_expected = { 0, 0, 1024, 768 },
|
||||
},
|
||||
{
|
||||
.name = "positioning_simple",
|
||||
.msg = "Simple positioning should work",
|
||||
.src = { 0, 0, 1023 << 16, 767 << 16 },
|
||||
.crtc = { 0, 0, 1023, 767 },
|
||||
.rotation = DRM_MODE_ROTATE_0,
|
||||
.min_scale = DRM_PLANE_NO_SCALING,
|
||||
.max_scale = DRM_PLANE_NO_SCALING,
|
||||
.can_position = true,
|
||||
.src_expected = { 0, 0, 1023 << 16, 767 << 16 },
|
||||
.crtc_expected = { 0, 0, 1023, 767 },
|
||||
},
|
||||
{
|
||||
.name = "upscaling",
|
||||
.msg = "Upscaling exactly 2x should work",
|
||||
.src = { 0, 0, 512 << 16, 384 << 16 },
|
||||
.crtc = { 0, 0, 1024, 768 },
|
||||
.rotation = DRM_MODE_ROTATE_0,
|
||||
.min_scale = 0x8000,
|
||||
.max_scale = DRM_PLANE_NO_SCALING,
|
||||
.can_position = false,
|
||||
.src_expected = { 0, 0, 512 << 16, 384 << 16 },
|
||||
.crtc_expected = { 0, 0, 1024, 768 },
|
||||
},
|
||||
{
|
||||
.name = "downscaling",
|
||||
.msg = "Should succeed with exact scaling limit",
|
||||
.src = { 0, 0, 2048 << 16, 1536 << 16 },
|
||||
.crtc = { 0, 0, 1024, 768 },
|
||||
.rotation = DRM_MODE_ROTATE_0,
|
||||
.min_scale = DRM_PLANE_NO_SCALING,
|
||||
.max_scale = 0x20000,
|
||||
.can_position = false,
|
||||
.src_expected = { 0, 0, 2048 << 16, 1536 << 16 },
|
||||
.crtc_expected = { 0, 0, 1024, 768 },
|
||||
},
|
||||
{
|
||||
.name = "rounding1",
|
||||
.msg = "Should succeed by clipping to exact multiple",
|
||||
.src = { 0, 0, 0x40001, 0x40001 },
|
||||
.crtc = { 1022, 766, 4, 4 },
|
||||
.rotation = DRM_MODE_ROTATE_0,
|
||||
.min_scale = DRM_PLANE_NO_SCALING,
|
||||
.max_scale = 0x10001,
|
||||
.can_position = true,
|
||||
.src_expected = { 0, 0, 2 << 16, 2 << 16 },
|
||||
.crtc_expected = { 1022, 766, 2, 2 },
|
||||
},
|
||||
{
|
||||
.name = "rounding2",
|
||||
.msg = "Should succeed by clipping to exact multiple",
|
||||
.src = { 0x20001, 0x20001, 0x4040001, 0x3040001 },
|
||||
.crtc = { -2, -2, 1028, 772 },
|
||||
.rotation = DRM_MODE_ROTATE_0,
|
||||
.min_scale = DRM_PLANE_NO_SCALING,
|
||||
.max_scale = 0x10001,
|
||||
.can_position = false,
|
||||
.src_expected = { 0x40002, 0x40002, 1024 << 16, 768 << 16 },
|
||||
.crtc_expected = { 0, 0, 1024, 768 },
|
||||
},
|
||||
{
|
||||
.name = "rounding3",
|
||||
.msg = "Should succeed by clipping to exact multiple",
|
||||
.src = { 0, 0, 0x3ffff, 0x3ffff },
|
||||
.crtc = { 1022, 766, 4, 4 },
|
||||
.rotation = DRM_MODE_ROTATE_0,
|
||||
.min_scale = 0xffff,
|
||||
.max_scale = DRM_PLANE_NO_SCALING,
|
||||
.can_position = true,
|
||||
/* Should not be rounded to 0x20001, which would be upscaling. */
|
||||
.src_expected = { 0, 0, 2 << 16, 2 << 16 },
|
||||
.crtc_expected = { 1022, 766, 2, 2 },
|
||||
},
|
||||
{
|
||||
.name = "rounding4",
|
||||
.msg = "Should succeed by clipping to exact multiple",
|
||||
.src = { 0x1ffff, 0x1ffff, 0x403ffff, 0x303ffff },
|
||||
.crtc = { -2, -2, 1028, 772 },
|
||||
.rotation = DRM_MODE_ROTATE_0,
|
||||
.min_scale = 0xffff,
|
||||
.max_scale = DRM_PLANE_NO_SCALING,
|
||||
.can_position = false,
|
||||
.src_expected = { 0x3fffe, 0x3fffe, 1024 << 16, 768 << 16 },
|
||||
.crtc_expected = { 0, 0, 1024, 768 },
|
||||
},
|
||||
};
|
||||
|
||||
KUNIT_ARRAY_PARAM(drm_check_plane_state, drm_check_plane_state_tests, drm_check_plane_state_desc);
|
||||
|
||||
static void drm_test_check_invalid_plane_state(struct kunit *test)
|
||||
{
|
||||
const struct drm_check_plane_state_test *params = test->param_value;
|
||||
struct drm_plane_state *plane_state = test->priv;
|
||||
|
||||
KUNIT_ASSERT_LT_MSG(test,
|
||||
drm_atomic_helper_check_plane_state(plane_state, &crtc_state,
|
||||
params->min_scale,
|
||||
params->max_scale,
|
||||
params->can_position, false),
|
||||
0, params->msg);
|
||||
}
|
||||
|
||||
static const struct drm_check_plane_state_test drm_check_invalid_plane_state_tests[] = {
|
||||
{
|
||||
.name = "positioning_invalid",
|
||||
.msg = "Should not be able to position on the crtc with can_position=false",
|
||||
.src = { 0, 0, 1023 << 16, 767 << 16 },
|
||||
.crtc = { 0, 0, 1023, 767 },
|
||||
.rotation = DRM_MODE_ROTATE_0,
|
||||
.min_scale = DRM_PLANE_NO_SCALING,
|
||||
.max_scale = DRM_PLANE_NO_SCALING,
|
||||
.can_position = false,
|
||||
},
|
||||
{
|
||||
.name = "upscaling_invalid",
|
||||
.msg = "Upscaling out of range should fail",
|
||||
.src = { 0, 0, 512 << 16, 384 << 16 },
|
||||
.crtc = { 0, 0, 1024, 768 },
|
||||
.rotation = DRM_MODE_ROTATE_0,
|
||||
.min_scale = 0x8001,
|
||||
.max_scale = DRM_PLANE_NO_SCALING,
|
||||
.can_position = false,
|
||||
},
|
||||
{
|
||||
.name = "downscaling_invalid",
|
||||
.msg = "Downscaling out of range should fail",
|
||||
.src = { 0, 0, 2048 << 16, 1536 << 16 },
|
||||
.crtc = { 0, 0, 1024, 768 },
|
||||
.rotation = DRM_MODE_ROTATE_0,
|
||||
.min_scale = DRM_PLANE_NO_SCALING,
|
||||
.max_scale = 0x1ffff,
|
||||
.can_position = false,
|
||||
},
|
||||
};
|
||||
|
||||
KUNIT_ARRAY_PARAM(drm_check_invalid_plane_state, drm_check_invalid_plane_state_tests,
|
||||
drm_check_plane_state_desc);
|
||||
|
||||
static struct kunit_case drm_plane_helper_test[] = {
|
||||
KUNIT_CASE(drm_test_check_plane_state),
|
||||
KUNIT_CASE_PARAM(drm_test_check_plane_state, drm_check_plane_state_gen_params),
|
||||
KUNIT_CASE_PARAM(drm_test_check_invalid_plane_state,
|
||||
drm_check_invalid_plane_state_gen_params),
|
||||
{}
|
||||
};
|
||||
|
||||
static struct kunit_suite drm_plane_helper_test_suite = {
|
||||
.name = "drm_plane_helper",
|
||||
.init = drm_plane_helper_init,
|
||||
.test_cases = drm_plane_helper_test,
|
||||
};
|
||||
|
||||
|
||||
Reference in New Issue
Block a user