linux/drivers/gpu/drm/tests/drm_connector_test.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Kunit test for drm_modes functions
 */

#include <linux/i2c.h>

#include <drm/drm_atomic_state_helper.h>
#include <drm/drm_connector.h>
#include <drm/drm_drv.h>
#include <drm/drm_edid.h>
#include <drm/drm_file.h>
#include <drm/drm_kunit_helpers.h>
#include <drm/drm_modes.h>

#include <drm/display/drm_hdmi_helper.h>

#include <kunit/test.h>

#include "../drm_crtc_internal.h"

struct drm_connector_init_priv {
	struct drm_device drm;
	struct drm_connector connector;
	struct i2c_adapter ddc;
};

static const struct drm_connector_hdmi_funcs dummy_hdmi_funcs = {
};

static const struct drm_connector_funcs dummy_funcs = {
	.atomic_destroy_state	= drm_atomic_helper_connector_destroy_state,
	.atomic_duplicate_state	= drm_atomic_helper_connector_duplicate_state,
	.reset			= drm_atomic_helper_connector_reset,
};

static int dummy_ddc_xfer(struct i2c_adapter *adapter,
			  struct i2c_msg *msgs, int num)
{
	return num;
}

static u32 dummy_ddc_func(struct i2c_adapter *adapter)
{
	return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL;
}

static const struct i2c_algorithm dummy_ddc_algorithm = {
	.master_xfer = dummy_ddc_xfer,
	.functionality = dummy_ddc_func,
};

static void i2c_del_adapter_wrapper(void *ptr)
{
	struct i2c_adapter *adap = ptr;

	i2c_del_adapter(adap);
}

static int drm_test_connector_init(struct kunit *test)
{
	struct drm_connector_init_priv *priv;
	struct device *dev;
	int ret;

	dev = drm_kunit_helper_alloc_device(test);
	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dev);

	priv = drm_kunit_helper_alloc_drm_device(test, dev,
						 struct drm_connector_init_priv, drm,
						 DRIVER_MODESET | DRIVER_ATOMIC);
	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, priv);

	strscpy(priv->ddc.name, "dummy-connector-ddc", sizeof(priv->ddc.name));
	priv->ddc.owner = THIS_MODULE;
	priv->ddc.algo = &dummy_ddc_algorithm;
	priv->ddc.dev.parent = dev;

	ret = i2c_add_adapter(&priv->ddc);
	KUNIT_ASSERT_EQ(test, ret, 0);

	ret = kunit_add_action_or_reset(test, i2c_del_adapter_wrapper, &priv->ddc);
	KUNIT_ASSERT_EQ(test, ret, 0);

	test->priv = priv;
	return 0;
}

/*
 * Test that the registration of a bog standard connector works as
 * expected and doesn't report any error.
 */
static void drm_test_drmm_connector_init(struct kunit *test)
{
	struct drm_connector_init_priv *priv = test->priv;
	int ret;

	ret = drmm_connector_init(&priv->drm, &priv->connector,
				  &dummy_funcs,
				  DRM_MODE_CONNECTOR_HDMIA,
				  &priv->ddc);
	KUNIT_EXPECT_EQ(test, ret, 0);
}

/*
 * Test that the registration of a connector without a DDC adapter
 * doesn't report any error.
 */
static void drm_test_drmm_connector_init_null_ddc(struct kunit *test)
{
	struct drm_connector_init_priv *priv = test->priv;
	int ret;

	ret = drmm_connector_init(&priv->drm, &priv->connector,
				  &dummy_funcs,
				  DRM_MODE_CONNECTOR_HDMIA,
				  NULL);
	KUNIT_EXPECT_EQ(test, ret, 0);
}

/*
 * Test that the registration of a connector succeeds for all possible
 * connector types.
 */
static void drm_test_drmm_connector_init_type_valid(struct kunit *test)
{
	struct drm_connector_init_priv *priv = test->priv;
	unsigned int connector_type = *(unsigned int *)test->param_value;
	int ret;

	ret = drmm_connector_init(&priv->drm, &priv->connector,
				  &dummy_funcs,
				  connector_type,
				  &priv->ddc);
	KUNIT_EXPECT_EQ(test, ret, 0);
}

static const unsigned int drm_connector_init_type_valid_tests[] = {
	DRM_MODE_CONNECTOR_Unknown,
	DRM_MODE_CONNECTOR_VGA,
	DRM_MODE_CONNECTOR_DVII,
	DRM_MODE_CONNECTOR_DVID,
	DRM_MODE_CONNECTOR_DVIA,
	DRM_MODE_CONNECTOR_Composite,
	DRM_MODE_CONNECTOR_SVIDEO,
	DRM_MODE_CONNECTOR_LVDS,
	DRM_MODE_CONNECTOR_Component,
	DRM_MODE_CONNECTOR_9PinDIN,
	DRM_MODE_CONNECTOR_DisplayPort,
	DRM_MODE_CONNECTOR_HDMIA,
	DRM_MODE_CONNECTOR_HDMIB,
	DRM_MODE_CONNECTOR_TV,
	DRM_MODE_CONNECTOR_eDP,
	DRM_MODE_CONNECTOR_VIRTUAL,
	DRM_MODE_CONNECTOR_DSI,
	DRM_MODE_CONNECTOR_DPI,
	DRM_MODE_CONNECTOR_WRITEBACK,
	DRM_MODE_CONNECTOR_SPI,
	DRM_MODE_CONNECTOR_USB,
};

static void drm_connector_init_type_desc(const unsigned int *type, char *desc)
{
	sprintf(desc, "%s", drm_get_connector_type_name(*type));
}

KUNIT_ARRAY_PARAM(drm_connector_init_type_valid,
		  drm_connector_init_type_valid_tests,
		  drm_connector_init_type_desc);

static struct kunit_case drmm_connector_init_tests[] = {
	KUNIT_CASE(drm_test_drmm_connector_init),
	KUNIT_CASE(drm_test_drmm_connector_init_null_ddc),
	KUNIT_CASE_PARAM(drm_test_drmm_connector_init_type_valid,
			 drm_connector_init_type_valid_gen_params),
	{ }
};

static struct kunit_suite drmm_connector_init_test_suite = {
	.name = "drmm_connector_init",
	.init = drm_test_connector_init,
	.test_cases = drmm_connector_init_tests,
};

static const struct drm_connector_funcs dummy_dynamic_init_funcs = {
	.atomic_destroy_state	= drm_atomic_helper_connector_destroy_state,
	.atomic_duplicate_state	= drm_atomic_helper_connector_duplicate_state,
	.reset			= drm_atomic_helper_connector_reset,
	.destroy		= drm_connector_cleanup,
};

/*
 * Test that the initialization of a bog standard dynamic connector works
 * as expected and doesn't report any error.
 */
static void drm_test_drm_connector_dynamic_init(struct kunit *test)
{
	struct drm_connector_init_priv *priv = test->priv;
	struct drm_connector *connector = &priv->connector;
	int ret;

	ret = drm_connector_dynamic_init(&priv->drm, connector,
					 &dummy_dynamic_init_funcs,
					 DRM_MODE_CONNECTOR_DisplayPort,
					 &priv->ddc);
	KUNIT_ASSERT_EQ(test, ret, 0);
}

static void drm_test_connector_dynamic_init_cleanup(struct kunit *test)
{
	struct drm_connector_init_priv *priv = test->priv;
	struct drm_connector *connector = &priv->connector;

	drm_connector_cleanup(connector);
}

/*
 * Test that the initialization of a dynamic connector without a DDC adapter
 * doesn't report any error.
 */
static void drm_test_drm_connector_dynamic_init_null_ddc(struct kunit *test)
{
	struct drm_connector_init_priv *priv = test->priv;
	struct drm_connector *connector = &priv->connector;
	int ret;

	ret = drm_connector_dynamic_init(&priv->drm, connector,
					 &dummy_dynamic_init_funcs,
					 DRM_MODE_CONNECTOR_DisplayPort,
					 NULL);
	KUNIT_ASSERT_EQ(test, ret, 0);
}

/*
 * Test that the initialization of a dynamic connector doesn't add the
 * connector to the connector list.
 */
static void drm_test_drm_connector_dynamic_init_not_added(struct kunit *test)
{
	struct drm_connector_init_priv *priv = test->priv;
	struct drm_connector *connector = &priv->connector;
	int ret;

	ret = drm_connector_dynamic_init(&priv->drm, connector,
					 &dummy_dynamic_init_funcs,
					 DRM_MODE_CONNECTOR_DisplayPort,
					 &priv->ddc);
	KUNIT_ASSERT_EQ(test, ret, 0);
	KUNIT_ASSERT_PTR_EQ(test, connector->head.next, &connector->head);
}

static void test_connector_property(struct kunit *test,
				    struct drm_connector *connector,
				    const struct drm_property *expected_prop)
{
	struct drm_property *prop;
	uint64_t val;
	int ret;

	KUNIT_ASSERT_NOT_NULL(test, expected_prop);
	prop = drm_mode_obj_find_prop_id(&connector->base, expected_prop->base.id);
	KUNIT_ASSERT_PTR_EQ_MSG(test, prop, expected_prop,
				"Can't find property %s", expected_prop->name);

	ret = drm_object_property_get_default_value(&connector->base, prop, &val);
	KUNIT_EXPECT_EQ(test, ret, 0);
	KUNIT_EXPECT_EQ(test, val, 0);

	/* TODO: Check property value in the connector state. */
}

/*
 * Test that the initialization of a dynamic connector adds all the expected
 * properties to it.
 */
static void drm_test_drm_connector_dynamic_init_properties(struct kunit *test)
{
	struct drm_connector_init_priv *priv = test->priv;
	struct drm_connector *connector = &priv->connector;
	struct drm_mode_config *config = &priv->drm.mode_config;
	const struct drm_property *props[] = {
		config->edid_property,
		config->dpms_property,
		config->link_status_property,
		config->non_desktop_property,
		config->tile_property,
		config->prop_crtc_id,
	};
	int ret;
	int i;

	ret = drm_connector_dynamic_init(&priv->drm, connector,
					 &dummy_dynamic_init_funcs,
					 DRM_MODE_CONNECTOR_DisplayPort,
					 &priv->ddc);
	KUNIT_ASSERT_EQ(test, ret, 0);

	for (i = 0; i < ARRAY_SIZE(props); i++)
		test_connector_property(test, connector, props[i]);
}

/*
 * Test that the initialization of a dynamic connector succeeds for all
 * possible connector types.
 */
static void drm_test_drm_connector_dynamic_init_type_valid(struct kunit *test)
{
	struct drm_connector_init_priv *priv = test->priv;
	struct drm_connector *connector = &priv->connector;
	unsigned int connector_type = *(unsigned int *)test->param_value;
	int ret;

	ret = drm_connector_dynamic_init(&priv->drm, connector,
					 &dummy_dynamic_init_funcs,
					 connector_type,
					 &priv->ddc);
	KUNIT_ASSERT_EQ(test, ret, 0);
}

/*
 * Test that the initialization of a dynamic connector sets the expected name
 * for it for all possible connector types.
 */
static void drm_test_drm_connector_dynamic_init_name(struct kunit *test)
{
	struct drm_connector_init_priv *priv = test->priv;
	struct drm_connector *connector = &priv->connector;
	unsigned int connector_type = *(unsigned int *)test->param_value;
	char expected_name[128];
	int ret;

	ret = drm_connector_dynamic_init(&priv->drm, connector,
					 &dummy_dynamic_init_funcs,
					 connector_type,
					 &priv->ddc);
	KUNIT_ASSERT_EQ(test, ret, 0);

	snprintf(expected_name, sizeof(expected_name), "%s-%d",
		 drm_get_connector_type_name(connector_type), connector->connector_type_id);
	KUNIT_ASSERT_STREQ(test, connector->name, expected_name);
}

static struct kunit_case drm_connector_dynamic_init_tests[] = {
	KUNIT_CASE(drm_test_drm_connector_dynamic_init),
	KUNIT_CASE(drm_test_drm_connector_dynamic_init_null_ddc),
	KUNIT_CASE(drm_test_drm_connector_dynamic_init_not_added),
	KUNIT_CASE(drm_test_drm_connector_dynamic_init_properties),
	KUNIT_CASE_PARAM(drm_test_drm_connector_dynamic_init_type_valid,
			 drm_connector_init_type_valid_gen_params),
	KUNIT_CASE_PARAM(drm_test_drm_connector_dynamic_init_name,
			 drm_connector_init_type_valid_gen_params),
	{}
};

static struct kunit_suite drm_connector_dynamic_init_test_suite = {
	.name = "drm_connector_dynamic_init",
	.init = drm_test_connector_init,
	.exit = drm_test_connector_dynamic_init_cleanup,
	.test_cases = drm_connector_dynamic_init_tests,
};

static int drm_test_connector_dynamic_register_early_init(struct kunit *test)
{
	struct drm_connector_init_priv *priv;
	int ret;

	ret = drm_test_connector_init(test);
	KUNIT_ASSERT_EQ(test, ret, 0);

	priv = test->priv;

	ret = drm_connector_dynamic_init(&priv->drm, &priv->connector,
					 &dummy_dynamic_init_funcs,
					 DRM_MODE_CONNECTOR_DisplayPort,
					 &priv->ddc);
	KUNIT_ASSERT_EQ(test, ret, 0);

	return 0;
}

static void drm_test_connector_dynamic_register_early_cleanup(struct kunit *test)
{
	struct drm_connector_init_priv *priv = test->priv;
	struct drm_connector *connector = &priv->connector;

	drm_connector_unregister(connector);
	drm_connector_put(connector);
}

/*
 * Test that registration of a dynamic connector adds it to the connector list.
 */
static void drm_test_drm_connector_dynamic_register_early_on_list(struct kunit *test)
{
	struct drm_connector_init_priv *priv = test->priv;
	struct drm_connector *connector = &priv->connector;
	int ret;

	KUNIT_ASSERT_TRUE(test, list_empty(&connector->head));

	ret = drm_connector_dynamic_register(connector);
	KUNIT_ASSERT_EQ(test, ret, 0);

	KUNIT_ASSERT_PTR_EQ(test, connector->head.next, &priv->drm.mode_config.connector_list);
}

/*
 * Test that the registration of a dynamic connector before the drm device is
 * registered results in deferring the connector's user interface registration.
 */
static void drm_test_drm_connector_dynamic_register_early_defer(struct kunit *test)
{
	struct drm_connector_init_priv *priv = test->priv;
	struct drm_connector *connector = &priv->connector;
	int ret;

	ret = drm_connector_dynamic_register(connector);
	KUNIT_ASSERT_EQ(test, ret, 0);

	KUNIT_ASSERT_EQ(test, connector->registration_state, DRM_CONNECTOR_INITIALIZING);
}

/*
 * Test that the registration of a dynamic connector fails, if this is done before
 * the connector is initialized.
 */
static void drm_test_drm_connector_dynamic_register_early_no_init(struct kunit *test)
{
	struct drm_connector *connector;
	int ret;

	connector = kunit_kzalloc(test, sizeof(*connector), GFP_KERNEL); /* auto freed */
	KUNIT_ASSERT_NOT_NULL(test, connector);

	ret = drm_connector_dynamic_register(connector);
	KUNIT_ASSERT_EQ(test, ret, -EINVAL);
}

/*
 * Test that the registration of a dynamic connector before the drm device is
 * registered results in deferring adding a mode object for the connector.
 */
static void drm_test_drm_connector_dynamic_register_early_no_mode_object(struct kunit *test)
{
	struct drm_connector_init_priv *priv = test->priv;
	struct drm_connector *connector = &priv->connector;
	struct drm_connector *tmp_connector;
	int ret;

	ret = drm_connector_dynamic_register(&priv->connector);
	KUNIT_ASSERT_EQ(test, ret, 0);

	tmp_connector = drm_connector_lookup(connector->dev, NULL, connector->base.id);
	KUNIT_ASSERT_NULL(test, tmp_connector);
}

static struct kunit_case drm_connector_dynamic_register_early_tests[] = {
	KUNIT_CASE(drm_test_drm_connector_dynamic_register_early_on_list),
	KUNIT_CASE(drm_test_drm_connector_dynamic_register_early_defer),
	KUNIT_CASE(drm_test_drm_connector_dynamic_register_early_no_init),
	KUNIT_CASE(drm_test_drm_connector_dynamic_register_early_no_mode_object),
	{ }
};

static struct kunit_suite drm_connector_dynamic_register_early_test_suite = {
	.name = "drm_connector_dynamic_register_early",
	.init = drm_test_connector_dynamic_register_early_init,
	.exit = drm_test_connector_dynamic_register_early_cleanup,
	.test_cases = drm_connector_dynamic_register_early_tests,
};

static int drm_test_connector_dynamic_register_init(struct kunit *test)
{
	struct drm_connector_init_priv *priv;
	int ret;

	ret = drm_test_connector_dynamic_register_early_init(test);
	KUNIT_ASSERT_EQ(test, ret, 0);

	priv = test->priv;

	ret = drm_dev_register(priv->connector.dev, 0);
	KUNIT_ASSERT_EQ(test, ret, 0);

	return 0;
}

static void drm_test_connector_dynamic_register_cleanup(struct kunit *test)
{
	struct drm_connector_init_priv *priv = test->priv;
	struct drm_device *dev = priv->connector.dev;

	drm_connector_unregister(&priv->connector);
	drm_connector_put(&priv->connector);

	drm_dev_unregister(dev);

	drm_test_connector_dynamic_register_early_cleanup(test);
}

static void drm_test_drm_connector_dynamic_register_on_list(struct kunit *test)
{
	struct drm_connector_init_priv *priv = test->priv;
	int ret;

	KUNIT_ASSERT_TRUE(test, list_empty(&priv->connector.head));

	ret = drm_connector_dynamic_register(&priv->connector);
	KUNIT_ASSERT_EQ(test, ret, 0);

	KUNIT_ASSERT_PTR_EQ(test, priv->connector.head.next, &priv->drm.mode_config.connector_list);
}

/*
 * Test that the registration of a dynamic connector doesn't get deferred if
 * this is done after the drm device is registered.
 */
static void drm_test_drm_connector_dynamic_register_no_defer(struct kunit *test)
{
	struct drm_connector_init_priv *priv = test->priv;
	int ret;

	KUNIT_ASSERT_EQ(test, priv->connector.registration_state, DRM_CONNECTOR_INITIALIZING);

	ret = drm_connector_dynamic_register(&priv->connector);
	KUNIT_ASSERT_EQ(test, ret, 0);

	KUNIT_ASSERT_EQ(test, priv->connector.registration_state, DRM_CONNECTOR_REGISTERED);
}

/*
 * Test that the registration of a dynamic connector fails if this is done after the
 * drm device is registered, but before the connector is initialized.
 */
static void drm_test_drm_connector_dynamic_register_no_init(struct kunit *test)
{
	struct drm_connector *connector;
	int ret;

	connector = kunit_kzalloc(test, sizeof(*connector), GFP_KERNEL); /* auto freed */
	KUNIT_ASSERT_NOT_NULL(test, connector);

	ret = drm_connector_dynamic_register(connector);
	KUNIT_ASSERT_EQ(test, ret, -EINVAL);
}

/*
 * Test that the registration of a dynamic connector after the drm device is
 * registered adds the mode object for the connector.
 */
static void drm_test_drm_connector_dynamic_register_mode_object(struct kunit *test)
{
	struct drm_connector_init_priv *priv = test->priv;
	struct drm_connector *connector = &priv->connector;
	struct drm_connector *tmp_connector;
	int ret;

	tmp_connector = drm_connector_lookup(connector->dev, NULL, connector->base.id);
	KUNIT_ASSERT_NULL(test, tmp_connector);

	ret = drm_connector_dynamic_register(&priv->connector);
	KUNIT_ASSERT_EQ(test, ret, 0);

	tmp_connector = drm_connector_lookup(connector->dev, NULL, connector->base.id);
	KUNIT_ASSERT_PTR_EQ(test, tmp_connector, connector);
}

/*
 * Test that the registration of a dynamic connector after the drm device is
 * registered adds the connector to sysfs.
 */
static void drm_test_drm_connector_dynamic_register_sysfs(struct kunit *test)
{
	struct drm_connector_init_priv *priv = test->priv;
	struct drm_connector *connector = &priv->connector;
	int ret;

	KUNIT_ASSERT_NULL(test, connector->kdev);

	ret = drm_connector_dynamic_register(connector);
	KUNIT_ASSERT_EQ(test, ret, 0);

	KUNIT_ASSERT_NOT_NULL(test, connector->kdev);
}

/*
 * Test that the registration of a dynamic connector after the drm device is
 * registered sets the connector's sysfs name as expected.
 */
static void drm_test_drm_connector_dynamic_register_sysfs_name(struct kunit *test)
{
	struct drm_connector_init_priv *priv = test->priv;
	struct drm_connector *connector = &priv->connector;
	char expected_name[128];
	int ret;

	ret = drm_connector_dynamic_register(connector);
	KUNIT_ASSERT_EQ(test, ret, 0);

	snprintf(expected_name, sizeof(expected_name), "card%d-%s",
		 connector->dev->primary->index, connector->name);

	KUNIT_ASSERT_STREQ(test, dev_name(connector->kdev), expected_name);
}

/*
 * Test that the registration of a dynamic connector after the drm device is
 * registered adds the connector to debugfs.
 */
static void drm_test_drm_connector_dynamic_register_debugfs(struct kunit *test)
{
	struct drm_connector_init_priv *priv = test->priv;
	int ret;

	KUNIT_ASSERT_NULL(test, priv->connector.debugfs_entry);

	ret = drm_connector_dynamic_register(&priv->connector);
	KUNIT_ASSERT_EQ(test, ret, 0);

	if (IS_ENABLED(CONFIG_DEBUG_FS))
		KUNIT_ASSERT_NOT_NULL(test, priv->connector.debugfs_entry);
	else
		KUNIT_ASSERT_NULL(test, priv->connector.debugfs_entry);
}

static struct kunit_case drm_connector_dynamic_register_tests[] = {
	KUNIT_CASE(drm_test_drm_connector_dynamic_register_on_list),
	KUNIT_CASE(drm_test_drm_connector_dynamic_register_no_defer),
	KUNIT_CASE(drm_test_drm_connector_dynamic_register_no_init),
	KUNIT_CASE(drm_test_drm_connector_dynamic_register_mode_object),
	KUNIT_CASE(drm_test_drm_connector_dynamic_register_sysfs),
	KUNIT_CASE(drm_test_drm_connector_dynamic_register_sysfs_name),
	KUNIT_CASE(drm_test_drm_connector_dynamic_register_debugfs),
	{ }
};

static struct kunit_suite drm_connector_dynamic_register_test_suite = {
	.name = "drm_connector_dynamic_register",
	.init = drm_test_connector_dynamic_register_init,
	.exit = drm_test_connector_dynamic_register_cleanup,
	.test_cases = drm_connector_dynamic_register_tests,
};

/*
 * Test that the registration of a bog standard connector works as
 * expected and doesn't report any error.
 */
static void drm_test_connector_hdmi_init_valid(struct kunit *test)
{
	struct drm_connector_init_priv *priv = test->priv;
	int ret;

	ret = drmm_connector_hdmi_init(&priv->drm, &priv->connector,
				       "Vendor", "Product",
				       &dummy_funcs,
				       &dummy_hdmi_funcs,
				       DRM_MODE_CONNECTOR_HDMIA,
				       &priv->ddc,
				       BIT(HDMI_COLORSPACE_RGB),
				       8);
	KUNIT_EXPECT_EQ(test, ret, 0);
}

/*
 * Test that the registration of a connector without a DDC adapter
 * doesn't report any error.
 */
static void drm_test_connector_hdmi_init_null_ddc(struct kunit *test)
{
	struct drm_connector_init_priv *priv = test->priv;
	int ret;

	ret = drmm_connector_hdmi_init(&priv->drm, &priv->connector,
				       "Vendor", "Product",
				       &dummy_funcs,
				       &dummy_hdmi_funcs,
				       DRM_MODE_CONNECTOR_HDMIA,
				       NULL,
				       BIT(HDMI_COLORSPACE_RGB),
				       8);
	KUNIT_EXPECT_EQ(test, ret, 0);
}

/*
 * Test that the registration of an HDMI connector with a NULL vendor
 * fails.
 */
static void drm_test_connector_hdmi_init_null_vendor(struct kunit *test)
{
	struct drm_connector_init_priv *priv = test->priv;
	int ret;

	ret = drmm_connector_hdmi_init(&priv->drm, &priv->connector,
				       NULL, "Product",
				       &dummy_funcs,
				       &dummy_hdmi_funcs,
				       DRM_MODE_CONNECTOR_HDMIA,
				       &priv->ddc,
				       BIT(HDMI_COLORSPACE_RGB),
				       8);
	KUNIT_EXPECT_LT(test, ret, 0);
}

/*
 * Test that the registration of an HDMI connector with a NULL product
 * fails.
 */
static void drm_test_connector_hdmi_init_null_product(struct kunit *test)
{
	struct drm_connector_init_priv *priv = test->priv;
	int ret;

	ret = drmm_connector_hdmi_init(&priv->drm, &priv->connector,
				       "Vendor", NULL,
				       &dummy_funcs,
				       &dummy_hdmi_funcs,
				       DRM_MODE_CONNECTOR_HDMIA,
				       &priv->ddc,
				       BIT(HDMI_COLORSPACE_RGB),
				       8);
	KUNIT_EXPECT_LT(test, ret, 0);
}

/*
 * Test that the registration of a connector with a valid, shorter than
 * the max length, product name succeeds, and is stored padded with 0.
 */
static void drm_test_connector_hdmi_init_product_valid(struct kunit *test)
{
	struct drm_connector_init_priv *priv = test->priv;
	const unsigned char expected_product[DRM_CONNECTOR_HDMI_PRODUCT_LEN] = {
		'P', 'r', 'o', 'd',
	};
	const char *product_name = "Prod";
	int ret;

	KUNIT_ASSERT_LT(test, strlen(product_name), DRM_CONNECTOR_HDMI_PRODUCT_LEN);

	ret = drmm_connector_hdmi_init(&priv->drm, &priv->connector,
				       "Vendor", product_name,
				       &dummy_funcs,
				       &dummy_hdmi_funcs,
				       DRM_MODE_CONNECTOR_HDMIA,
				       &priv->ddc,
				       BIT(HDMI_COLORSPACE_RGB),
				       8);
	KUNIT_EXPECT_EQ(test, ret, 0);
	KUNIT_EXPECT_MEMEQ(test,
			   priv->connector.hdmi.product,
			   expected_product,
			   sizeof(priv->connector.hdmi.product));
}

/*
 * Test that the registration of a connector with a valid, at max
 * length, product name succeeds, and is stored padded without any
 * trailing \0.
 */
static void drm_test_connector_hdmi_init_product_length_exact(struct kunit *test)
{
	struct drm_connector_init_priv *priv = test->priv;
	const unsigned char expected_product[DRM_CONNECTOR_HDMI_PRODUCT_LEN] = {
		'P', 'r', 'o', 'd', 'u', 'c', 't',
		'P', 'r', 'o', 'd', 'u', 'c', 't',
		'P', 'r',
	};
	const char *product_name = "ProductProductPr";
	int ret;

	KUNIT_ASSERT_EQ(test, strlen(product_name), DRM_CONNECTOR_HDMI_PRODUCT_LEN);

	ret = drmm_connector_hdmi_init(&priv->drm, &priv->connector,
				       "Vendor", product_name,
				       &dummy_funcs,
				       &dummy_hdmi_funcs,
				       DRM_MODE_CONNECTOR_HDMIA,
				       &priv->ddc,
				       BIT(HDMI_COLORSPACE_RGB),
				       8);
	KUNIT_EXPECT_EQ(test, ret, 0);
	KUNIT_EXPECT_MEMEQ(test,
			   priv->connector.hdmi.product,
			   expected_product,
			   sizeof(priv->connector.hdmi.product));
}

/*
 * Test that the registration of a connector with a product name larger
 * than the maximum length fails.
 */
static void drm_test_connector_hdmi_init_product_length_too_long(struct kunit *test)
{
	struct drm_connector_init_priv *priv = test->priv;
	const char *product_name = "ProductProductProduct";
	int ret;

	KUNIT_ASSERT_GT(test, strlen(product_name), DRM_CONNECTOR_HDMI_PRODUCT_LEN);

	ret = drmm_connector_hdmi_init(&priv->drm, &priv->connector,
				       "Vendor", product_name,
				       &dummy_funcs,
				       &dummy_hdmi_funcs,
				       DRM_MODE_CONNECTOR_HDMIA,
				       &priv->ddc,
				       BIT(HDMI_COLORSPACE_RGB),
				       8);
	KUNIT_EXPECT_LT(test, ret, 0);
}

/*
 * Test that the registration of a connector with a vendor name smaller
 * than the maximum length succeeds, and is stored padded with zeros.
 */
static void drm_test_connector_hdmi_init_vendor_valid(struct kunit *test)
{
	struct drm_connector_init_priv *priv = test->priv;
	const char expected_vendor[DRM_CONNECTOR_HDMI_VENDOR_LEN] = {
		'V', 'e', 'n', 'd',
	};
	const char *vendor_name = "Vend";
	int ret;

	KUNIT_ASSERT_LT(test, strlen(vendor_name), DRM_CONNECTOR_HDMI_VENDOR_LEN);

	ret = drmm_connector_hdmi_init(&priv->drm, &priv->connector,
				       vendor_name, "Product",
				       &dummy_funcs,
				       &dummy_hdmi_funcs,
				       DRM_MODE_CONNECTOR_HDMIA,
				       &priv->ddc,
				       BIT(HDMI_COLORSPACE_RGB),
				       8);
	KUNIT_EXPECT_EQ(test, ret, 0);
	KUNIT_EXPECT_MEMEQ(test,
			   priv->connector.hdmi.vendor,
			   expected_vendor,
			   sizeof(priv->connector.hdmi.vendor));
}

/*
 * Test that the registration of a connector with a vendor name at the
 * maximum length succeeds, and is stored padded without the trailing
 * zero.
 */
static void drm_test_connector_hdmi_init_vendor_length_exact(struct kunit *test)
{
	struct drm_connector_init_priv *priv = test->priv;
	const char expected_vendor[DRM_CONNECTOR_HDMI_VENDOR_LEN] = {
		'V', 'e', 'n', 'd', 'o', 'r',
		'V', 'e',
	};
	const char *vendor_name = "VendorVe";
	int ret;

	KUNIT_ASSERT_EQ(test, strlen(vendor_name), DRM_CONNECTOR_HDMI_VENDOR_LEN);

	ret = drmm_connector_hdmi_init(&priv->drm, &priv->connector,
				       vendor_name, "Product",
				       &dummy_funcs,
				       &dummy_hdmi_funcs,
				       DRM_MODE_CONNECTOR_HDMIA,
				       &priv->ddc,
				       BIT(HDMI_COLORSPACE_RGB),
				       8);
	KUNIT_EXPECT_EQ(test, ret, 0);
	KUNIT_EXPECT_MEMEQ(test,
			   priv->connector.hdmi.vendor,
			   expected_vendor,
			   sizeof(priv->connector.hdmi.vendor));
}

/*
 * Test that the registration of a connector with a vendor name larger
 * than the maximum length fails.
 */
static void drm_test_connector_hdmi_init_vendor_length_too_long(struct kunit *test)
{
	struct drm_connector_init_priv *priv = test->priv;
	const char *vendor_name = "VendorVendor";
	int ret;

	KUNIT_ASSERT_GT(test, strlen(vendor_name), DRM_CONNECTOR_HDMI_VENDOR_LEN);

	ret = drmm_connector_hdmi_init(&priv->drm, &priv->connector,
				       vendor_name, "Product",
				       &dummy_funcs,
				       &dummy_hdmi_funcs,
				       DRM_MODE_CONNECTOR_HDMIA,
				       &priv->ddc,
				       BIT(HDMI_COLORSPACE_RGB),
				       8);
	KUNIT_EXPECT_LT(test, ret, 0);
}

/*
 * Test that the registration of a connector with an invalid maximum bpc
 * count fails.
 */
static void drm_test_connector_hdmi_init_bpc_invalid(struct kunit *test)
{
	struct drm_connector_init_priv *priv = test->priv;
	int ret;

	ret = drmm_connector_hdmi_init(&priv->drm, &priv->connector,
				       "Vendor", "Product",
				       &dummy_funcs,
				       &dummy_hdmi_funcs,
				       DRM_MODE_CONNECTOR_HDMIA,
				       &priv->ddc,
				       BIT(HDMI_COLORSPACE_RGB),
				       9);
	KUNIT_EXPECT_LT(test, ret, 0);
}

/*
 * Test that the registration of a connector with a null maximum bpc
 * count fails.
 */
static void drm_test_connector_hdmi_init_bpc_null(struct kunit *test)
{
	struct drm_connector_init_priv *priv = test->priv;
	int ret;

	ret = drmm_connector_hdmi_init(&priv->drm, &priv->connector,
				       "Vendor", "Product",
				       &dummy_funcs,
				       &dummy_hdmi_funcs,
				       DRM_MODE_CONNECTOR_HDMIA,
				       &priv->ddc,
				       BIT(HDMI_COLORSPACE_RGB),
				       0);
	KUNIT_EXPECT_LT(test, ret, 0);
}

/*
 * Test that the registration of a connector with a maximum bpc count of
 * 8 succeeds, registers the max bpc property, but doesn't register the
 * HDR output metadata one.
 */
static void drm_test_connector_hdmi_init_bpc_8(struct kunit *test)
{
	struct drm_connector_init_priv *priv = test->priv;
	struct drm_connector_state *state;
	struct drm_connector *connector = &priv->connector;
	struct drm_property *prop;
	uint64_t val;
	int ret;

	ret = drmm_connector_hdmi_init(&priv->drm, connector,
				       "Vendor", "Product",
				       &dummy_funcs,
				       &dummy_hdmi_funcs,
				       DRM_MODE_CONNECTOR_HDMIA,
				       &priv->ddc,
				       BIT(HDMI_COLORSPACE_RGB),
				       8);
	KUNIT_EXPECT_EQ(test, ret, 0);

	prop = connector->max_bpc_property;
	KUNIT_ASSERT_NOT_NULL(test, prop);
	KUNIT_EXPECT_NOT_NULL(test, drm_mode_obj_find_prop_id(&connector->base, prop->base.id));

	ret = drm_object_property_get_default_value(&connector->base, prop, &val);
	KUNIT_EXPECT_EQ(test, ret, 0);
	KUNIT_EXPECT_EQ(test, val, 8);

	state = connector->state;
	KUNIT_EXPECT_EQ(test, state->max_bpc, 8);
	KUNIT_EXPECT_EQ(test, state->max_requested_bpc, 8);

	prop = priv->drm.mode_config.hdr_output_metadata_property;
	KUNIT_ASSERT_NOT_NULL(test, prop);
	KUNIT_EXPECT_NULL(test, drm_mode_obj_find_prop_id(&connector->base, prop->base.id));
}

/*
 * Test that the registration of a connector with a maximum bpc count of
 * 10 succeeds and registers the max bpc and HDR output metadata
 * properties.
 */
static void drm_test_connector_hdmi_init_bpc_10(struct kunit *test)
{
	struct drm_connector_init_priv *priv = test->priv;
	struct drm_connector_state *state;
	struct drm_connector *connector = &priv->connector;
	struct drm_property *prop;
	uint64_t val;
	int ret;

	ret = drmm_connector_hdmi_init(&priv->drm, connector,
				       "Vendor", "Product",
				       &dummy_funcs,
				       &dummy_hdmi_funcs,
				       DRM_MODE_CONNECTOR_HDMIA,
				       &priv->ddc,
				       BIT(HDMI_COLORSPACE_RGB),
				       10);
	KUNIT_EXPECT_EQ(test, ret, 0);

	prop = connector->max_bpc_property;
	KUNIT_ASSERT_NOT_NULL(test, prop);
	KUNIT_EXPECT_NOT_NULL(test, drm_mode_obj_find_prop_id(&connector->base, prop->base.id));

	ret = drm_object_property_get_default_value(&connector->base, prop, &val);
	KUNIT_EXPECT_EQ(test, ret, 0);
	KUNIT_EXPECT_EQ(test, val, 10);

	state = connector->state;
	KUNIT_EXPECT_EQ(test, state->max_bpc, 10);
	KUNIT_EXPECT_EQ(test, state->max_requested_bpc, 10);

	prop = priv->drm.mode_config.hdr_output_metadata_property;
	KUNIT_ASSERT_NOT_NULL(test, prop);
	KUNIT_EXPECT_NOT_NULL(test, drm_mode_obj_find_prop_id(&connector->base, prop->base.id));
}

/*
 * Test that the registration of a connector with a maximum bpc count of
 * 12 succeeds and registers the max bpc and HDR output metadata
 * properties.
 */
static void drm_test_connector_hdmi_init_bpc_12(struct kunit *test)
{
	struct drm_connector_init_priv *priv = test->priv;
	struct drm_connector_state *state;
	struct drm_connector *connector = &priv->connector;
	struct drm_property *prop;
	uint64_t val;
	int ret;

	ret = drmm_connector_hdmi_init(&priv->drm, connector,
				       "Vendor", "Product",
				       &dummy_funcs,
				       &dummy_hdmi_funcs,
				       DRM_MODE_CONNECTOR_HDMIA,
				       &priv->ddc,
				       BIT(HDMI_COLORSPACE_RGB),
				       12);
	KUNIT_EXPECT_EQ(test, ret, 0);

	prop = connector->max_bpc_property;
	KUNIT_ASSERT_NOT_NULL(test, prop);
	KUNIT_EXPECT_NOT_NULL(test, drm_mode_obj_find_prop_id(&connector->base, prop->base.id));

	ret = drm_object_property_get_default_value(&connector->base, prop, &val);
	KUNIT_EXPECT_EQ(test, ret, 0);
	KUNIT_EXPECT_EQ(test, val, 12);

	state = connector->state;
	KUNIT_EXPECT_EQ(test, state->max_bpc, 12);
	KUNIT_EXPECT_EQ(test, state->max_requested_bpc, 12);

	prop = priv->drm.mode_config.hdr_output_metadata_property;
	KUNIT_ASSERT_NOT_NULL(test, prop);
	KUNIT_EXPECT_NOT_NULL(test, drm_mode_obj_find_prop_id(&connector->base, prop->base.id));
}

/*
 * Test that the registration of an HDMI connector with no supported
 * format fails.
 */
static void drm_test_connector_hdmi_init_formats_empty(struct kunit *test)
{
	struct drm_connector_init_priv *priv = test->priv;
	int ret;

	ret = drmm_connector_hdmi_init(&priv->drm, &priv->connector,
				       "Vendor", "Product",
				       &dummy_funcs,
				       &dummy_hdmi_funcs,
				       DRM_MODE_CONNECTOR_HDMIA,
				       &priv->ddc,
				       0,
				       8);
	KUNIT_EXPECT_LT(test, ret, 0);
}

/*
 * Test that the registration of an HDMI connector not listing RGB as a
 * supported format fails.
 */
static void drm_test_connector_hdmi_init_formats_no_rgb(struct kunit *test)
{
	struct drm_connector_init_priv *priv = test->priv;
	int ret;

	ret = drmm_connector_hdmi_init(&priv->drm, &priv->connector,
				       "Vendor", "Product",
				       &dummy_funcs,
				       &dummy_hdmi_funcs,
				       DRM_MODE_CONNECTOR_HDMIA,
				       &priv->ddc,
				       BIT(HDMI_COLORSPACE_YUV422),
				       8);
	KUNIT_EXPECT_LT(test, ret, 0);
}

struct drm_connector_hdmi_init_formats_yuv420_allowed_test {
	unsigned long supported_formats;
	bool yuv420_allowed;
	int expected_result;
};

#define YUV420_ALLOWED_TEST(_formats, _allowed, _result)			\
	{									\
		.supported_formats = BIT(HDMI_COLORSPACE_RGB) | (_formats),	\
		.yuv420_allowed = _allowed,					\
		.expected_result = _result,					\
	}

static const struct drm_connector_hdmi_init_formats_yuv420_allowed_test
drm_connector_hdmi_init_formats_yuv420_allowed_tests[] = {
	YUV420_ALLOWED_TEST(BIT(HDMI_COLORSPACE_YUV420), true, 0),
	YUV420_ALLOWED_TEST(BIT(HDMI_COLORSPACE_YUV420), false, -EINVAL),
	YUV420_ALLOWED_TEST(BIT(HDMI_COLORSPACE_YUV422), true, -EINVAL),
	YUV420_ALLOWED_TEST(BIT(HDMI_COLORSPACE_YUV422), false, 0),
};

static void
drm_connector_hdmi_init_formats_yuv420_allowed_desc(const struct drm_connector_hdmi_init_formats_yuv420_allowed_test *t,
						    char *desc)
{
	sprintf(desc, "supported_formats=0x%lx yuv420_allowed=%d",
		t->supported_formats, t->yuv420_allowed);
}

KUNIT_ARRAY_PARAM(drm_connector_hdmi_init_formats_yuv420_allowed,
		  drm_connector_hdmi_init_formats_yuv420_allowed_tests,
		  drm_connector_hdmi_init_formats_yuv420_allowed_desc);

/*
 * Test that the registration of an HDMI connector succeeds only when
 * the presence of YUV420 in the supported formats matches the value
 * of the ycbcr_420_allowed flag.
 */
static void drm_test_connector_hdmi_init_formats_yuv420_allowed(struct kunit *test)
{
	const struct drm_connector_hdmi_init_formats_yuv420_allowed_test *params;
	struct drm_connector_init_priv *priv = test->priv;
	int ret;

	params = test->param_value;
	priv->connector.ycbcr_420_allowed = params->yuv420_allowed;

	ret = drmm_connector_hdmi_init(&priv->drm, &priv->connector,
				       "Vendor", "Product",
				       &dummy_funcs,
				       &dummy_hdmi_funcs,
				       DRM_MODE_CONNECTOR_HDMIA,
				       &priv->ddc,
				       params->supported_formats,
				       8);
	KUNIT_EXPECT_EQ(test, ret, params->expected_result);
}

/*
 * Test that the registration of an HDMI connector with an HDMI
 * connector type succeeds.
 */
static void drm_test_connector_hdmi_init_type_valid(struct kunit *test)
{
	struct drm_connector_init_priv *priv = test->priv;
	unsigned int connector_type = *(unsigned int *)test->param_value;
	int ret;

	ret = drmm_connector_hdmi_init(&priv->drm, &priv->connector,
				       "Vendor", "Product",
				       &dummy_funcs,
				       &dummy_hdmi_funcs,
				       connector_type,
				       &priv->ddc,
				       BIT(HDMI_COLORSPACE_RGB),
				       8);
	KUNIT_EXPECT_EQ(test, ret, 0);
}

static const unsigned int drm_connector_hdmi_init_type_valid_tests[] = {
	DRM_MODE_CONNECTOR_HDMIA,
	DRM_MODE_CONNECTOR_HDMIB,
};

static void drm_connector_hdmi_init_type_desc(const unsigned int *type, char *desc)
{
	sprintf(desc, "%s", drm_get_connector_type_name(*type));
}

KUNIT_ARRAY_PARAM(drm_connector_hdmi_init_type_valid,
		  drm_connector_hdmi_init_type_valid_tests,
		  drm_connector_hdmi_init_type_desc);

/*
 * Test that the registration of an HDMI connector with an !HDMI
 * connector type fails.
 */
static void drm_test_connector_hdmi_init_type_invalid(struct kunit *test)
{
	struct drm_connector_init_priv *priv = test->priv;
	unsigned int connector_type = *(unsigned int *)test->param_value;
	int ret;

	ret = drmm_connector_hdmi_init(&priv->drm, &priv->connector,
				       "Vendor", "Product",
				       &dummy_funcs,
				       &dummy_hdmi_funcs,
				       connector_type,
				       &priv->ddc,
				       BIT(HDMI_COLORSPACE_RGB),
				       8);
	KUNIT_EXPECT_LT(test, ret, 0);
}

static const unsigned int drm_connector_hdmi_init_type_invalid_tests[] = {
	DRM_MODE_CONNECTOR_Unknown,
	DRM_MODE_CONNECTOR_VGA,
	DRM_MODE_CONNECTOR_DVII,
	DRM_MODE_CONNECTOR_DVID,
	DRM_MODE_CONNECTOR_DVIA,
	DRM_MODE_CONNECTOR_Composite,
	DRM_MODE_CONNECTOR_SVIDEO,
	DRM_MODE_CONNECTOR_LVDS,
	DRM_MODE_CONNECTOR_Component,
	DRM_MODE_CONNECTOR_9PinDIN,
	DRM_MODE_CONNECTOR_DisplayPort,
	DRM_MODE_CONNECTOR_TV,
	DRM_MODE_CONNECTOR_eDP,
	DRM_MODE_CONNECTOR_VIRTUAL,
	DRM_MODE_CONNECTOR_DSI,
	DRM_MODE_CONNECTOR_DPI,
	DRM_MODE_CONNECTOR_WRITEBACK,
	DRM_MODE_CONNECTOR_SPI,
	DRM_MODE_CONNECTOR_USB,
};

KUNIT_ARRAY_PARAM(drm_connector_hdmi_init_type_invalid,
		  drm_connector_hdmi_init_type_invalid_tests,
		  drm_connector_hdmi_init_type_desc);

static struct kunit_case drmm_connector_hdmi_init_tests[] = {
	KUNIT_CASE(drm_test_connector_hdmi_init_valid),
	KUNIT_CASE(drm_test_connector_hdmi_init_bpc_8),
	KUNIT_CASE(drm_test_connector_hdmi_init_bpc_10),
	KUNIT_CASE(drm_test_connector_hdmi_init_bpc_12),
	KUNIT_CASE(drm_test_connector_hdmi_init_bpc_invalid),
	KUNIT_CASE(drm_test_connector_hdmi_init_bpc_null),
	KUNIT_CASE(drm_test_connector_hdmi_init_formats_empty),
	KUNIT_CASE(drm_test_connector_hdmi_init_formats_no_rgb),
	KUNIT_CASE_PARAM(drm_test_connector_hdmi_init_formats_yuv420_allowed,
			 drm_connector_hdmi_init_formats_yuv420_allowed_gen_params),
	KUNIT_CASE(drm_test_connector_hdmi_init_null_ddc),
	KUNIT_CASE(drm_test_connector_hdmi_init_null_product),
	KUNIT_CASE(drm_test_connector_hdmi_init_null_vendor),
	KUNIT_CASE(drm_test_connector_hdmi_init_product_length_exact),
	KUNIT_CASE(drm_test_connector_hdmi_init_product_length_too_long),
	KUNIT_CASE(drm_test_connector_hdmi_init_product_valid),
	KUNIT_CASE(drm_test_connector_hdmi_init_vendor_length_exact),
	KUNIT_CASE(drm_test_connector_hdmi_init_vendor_length_too_long),
	KUNIT_CASE(drm_test_connector_hdmi_init_vendor_valid),
	KUNIT_CASE_PARAM(drm_test_connector_hdmi_init_type_valid,
			 drm_connector_hdmi_init_type_valid_gen_params),
	KUNIT_CASE_PARAM(drm_test_connector_hdmi_init_type_invalid,
			 drm_connector_hdmi_init_type_invalid_gen_params),
	{ }
};

static struct kunit_suite drmm_connector_hdmi_init_test_suite = {
	.name = "drmm_connector_hdmi_init",
	.init = drm_test_connector_init,
	.test_cases = drmm_connector_hdmi_init_tests,
};

struct drm_get_tv_mode_from_name_test {
	const char *name;
	enum drm_connector_tv_mode expected_mode;
};

#define TV_MODE_NAME(_name, _mode)		\
	{					\
		.name = _name,			\
		.expected_mode = _mode,		\
	}

static void drm_test_get_tv_mode_from_name_valid(struct kunit *test)
{
	const struct drm_get_tv_mode_from_name_test *params = test->param_value;

	KUNIT_EXPECT_EQ(test,
			drm_get_tv_mode_from_name(params->name, strlen(params->name)),
			params->expected_mode);
}

static const
struct drm_get_tv_mode_from_name_test drm_get_tv_mode_from_name_valid_tests[] = {
	TV_MODE_NAME("NTSC", DRM_MODE_TV_MODE_NTSC),
	TV_MODE_NAME("NTSC-443", DRM_MODE_TV_MODE_NTSC_443),
	TV_MODE_NAME("NTSC-J", DRM_MODE_TV_MODE_NTSC_J),
	TV_MODE_NAME("PAL", DRM_MODE_TV_MODE_PAL),
	TV_MODE_NAME("PAL-M", DRM_MODE_TV_MODE_PAL_M),
	TV_MODE_NAME("PAL-N", DRM_MODE_TV_MODE_PAL_N),
	TV_MODE_NAME("SECAM", DRM_MODE_TV_MODE_SECAM),
	TV_MODE_NAME("Mono", DRM_MODE_TV_MODE_MONOCHROME),
};

static void
drm_get_tv_mode_from_name_valid_desc(const struct drm_get_tv_mode_from_name_test *t,
				     char *desc)
{
	sprintf(desc, "%s", t->name);
}

KUNIT_ARRAY_PARAM(drm_get_tv_mode_from_name_valid,
		  drm_get_tv_mode_from_name_valid_tests,
		  drm_get_tv_mode_from_name_valid_desc);

static void drm_test_get_tv_mode_from_name_truncated(struct kunit *test)
{
	const char *name = "NTS";
	int ret;

	ret = drm_get_tv_mode_from_name(name, strlen(name));
	KUNIT_EXPECT_LT(test, ret, 0);
};

static struct kunit_case drm_get_tv_mode_from_name_tests[] = {
	KUNIT_CASE_PARAM(drm_test_get_tv_mode_from_name_valid,
			 drm_get_tv_mode_from_name_valid_gen_params),
	KUNIT_CASE(drm_test_get_tv_mode_from_name_truncated),
	{ }
};

static struct kunit_suite drm_get_tv_mode_from_name_test_suite = {
	.name = "drm_get_tv_mode_from_name",
	.test_cases = drm_get_tv_mode_from_name_tests,
};

struct drm_hdmi_connector_get_broadcast_rgb_name_test {
	unsigned int kind;
	const char *expected_name;
};

#define BROADCAST_RGB_TEST(_kind, _name)	\
	{					\
		.kind = _kind,			\
		.expected_name = _name,		\
	}

static void drm_test_drm_hdmi_connector_get_broadcast_rgb_name(struct kunit *test)
{
	const struct drm_hdmi_connector_get_broadcast_rgb_name_test *params =
		test->param_value;

	KUNIT_EXPECT_STREQ(test,
			   drm_hdmi_connector_get_broadcast_rgb_name(params->kind),
			   params->expected_name);
}

static const
struct drm_hdmi_connector_get_broadcast_rgb_name_test
drm_hdmi_connector_get_broadcast_rgb_name_valid_tests[] = {
	BROADCAST_RGB_TEST(DRM_HDMI_BROADCAST_RGB_AUTO, "Automatic"),
	BROADCAST_RGB_TEST(DRM_HDMI_BROADCAST_RGB_FULL, "Full"),
	BROADCAST_RGB_TEST(DRM_HDMI_BROADCAST_RGB_LIMITED, "Limited 16:235"),
};

static void
drm_hdmi_connector_get_broadcast_rgb_name_valid_desc(const struct drm_hdmi_connector_get_broadcast_rgb_name_test *t,
						     char *desc)
{
	sprintf(desc, "%s", t->expected_name);
}

KUNIT_ARRAY_PARAM(drm_hdmi_connector_get_broadcast_rgb_name_valid,
		  drm_hdmi_connector_get_broadcast_rgb_name_valid_tests,
		  drm_hdmi_connector_get_broadcast_rgb_name_valid_desc);

static void drm_test_drm_hdmi_connector_get_broadcast_rgb_name_invalid(struct kunit *test)
{
	KUNIT_EXPECT_NULL(test, drm_hdmi_connector_get_broadcast_rgb_name(3));
};

static struct kunit_case drm_hdmi_connector_get_broadcast_rgb_name_tests[] = {
	KUNIT_CASE_PARAM(drm_test_drm_hdmi_connector_get_broadcast_rgb_name,
			 drm_hdmi_connector_get_broadcast_rgb_name_valid_gen_params),
	KUNIT_CASE(drm_test_drm_hdmi_connector_get_broadcast_rgb_name_invalid),
	{ }
};

static struct kunit_suite drm_hdmi_connector_get_broadcast_rgb_name_test_suite = {
	.name = "drm_hdmi_connector_get_broadcast_rgb_name",
	.test_cases = drm_hdmi_connector_get_broadcast_rgb_name_tests,
};

struct drm_hdmi_connector_get_output_format_name_test {
	unsigned int kind;
	const char *expected_name;
};

#define OUTPUT_FORMAT_TEST(_kind, _name)	\
	{					\
		.kind = _kind,			\
		.expected_name = _name,		\
	}

static void drm_test_drm_hdmi_connector_get_output_format_name(struct kunit *test)
{
	const struct drm_hdmi_connector_get_output_format_name_test *params =
		test->param_value;

	KUNIT_EXPECT_STREQ(test,
			   drm_hdmi_connector_get_output_format_name(params->kind),
			   params->expected_name);
}

static const
struct drm_hdmi_connector_get_output_format_name_test
drm_hdmi_connector_get_output_format_name_valid_tests[] = {
	OUTPUT_FORMAT_TEST(HDMI_COLORSPACE_RGB, "RGB"),
	OUTPUT_FORMAT_TEST(HDMI_COLORSPACE_YUV420, "YUV 4:2:0"),
	OUTPUT_FORMAT_TEST(HDMI_COLORSPACE_YUV422, "YUV 4:2:2"),
	OUTPUT_FORMAT_TEST(HDMI_COLORSPACE_YUV444, "YUV 4:4:4"),
};

static void
drm_hdmi_connector_get_output_format_name_valid_desc(const struct drm_hdmi_connector_get_output_format_name_test *t,
						     char *desc)
{
	sprintf(desc, "%s", t->expected_name);
}

KUNIT_ARRAY_PARAM(drm_hdmi_connector_get_output_format_name_valid,
		  drm_hdmi_connector_get_output_format_name_valid_tests,
		  drm_hdmi_connector_get_output_format_name_valid_desc);

static void drm_test_drm_hdmi_connector_get_output_format_name_invalid(struct kunit *test)
{
	KUNIT_EXPECT_NULL(test, drm_hdmi_connector_get_output_format_name(4));
};

static struct kunit_case drm_hdmi_connector_get_output_format_name_tests[] = {
	KUNIT_CASE_PARAM(drm_test_drm_hdmi_connector_get_output_format_name,
			 drm_hdmi_connector_get_output_format_name_valid_gen_params),
	KUNIT_CASE(drm_test_drm_hdmi_connector_get_output_format_name_invalid),
	{ }
};

static struct kunit_suite drm_hdmi_connector_get_output_format_name_test_suite = {
	.name = "drm_hdmi_connector_get_output_format_name",
	.test_cases = drm_hdmi_connector_get_output_format_name_tests,
};

static void drm_test_drm_connector_attach_broadcast_rgb_property(struct kunit *test)
{
	struct drm_connector_init_priv *priv = test->priv;
	struct drm_connector *connector = &priv->connector;
	struct drm_property *prop;
	int ret;

	ret = drmm_connector_init(&priv->drm, connector,
				  &dummy_funcs,
				  DRM_MODE_CONNECTOR_HDMIA,
				  &priv->ddc);
	KUNIT_ASSERT_EQ(test, ret, 0);

	ret = drm_connector_attach_broadcast_rgb_property(connector);
	KUNIT_ASSERT_EQ(test, ret, 0);

	prop = connector->broadcast_rgb_property;
	KUNIT_ASSERT_NOT_NULL(test, prop);
	KUNIT_EXPECT_NOT_NULL(test, drm_mode_obj_find_prop_id(&connector->base, prop->base.id));
}

static void drm_test_drm_connector_attach_broadcast_rgb_property_hdmi_connector(struct kunit *test)
{
	struct drm_connector_init_priv *priv = test->priv;
	struct drm_connector *connector = &priv->connector;
	struct drm_property *prop;
	int ret;

	ret = drmm_connector_hdmi_init(&priv->drm, connector,
				       "Vendor", "Product",
				       &dummy_funcs,
				       &dummy_hdmi_funcs,
				       DRM_MODE_CONNECTOR_HDMIA,
				       &priv->ddc,
				       BIT(HDMI_COLORSPACE_RGB),
				       8);
	KUNIT_EXPECT_EQ(test, ret, 0);

	ret = drm_connector_attach_broadcast_rgb_property(connector);
	KUNIT_ASSERT_EQ(test, ret, 0);

	prop = connector->broadcast_rgb_property;
	KUNIT_ASSERT_NOT_NULL(test, prop);
	KUNIT_EXPECT_NOT_NULL(test, drm_mode_obj_find_prop_id(&connector->base, prop->base.id));
}

static struct kunit_case drm_connector_attach_broadcast_rgb_property_tests[] = {
	KUNIT_CASE(drm_test_drm_connector_attach_broadcast_rgb_property),
	KUNIT_CASE(drm_test_drm_connector_attach_broadcast_rgb_property_hdmi_connector),
	{ }
};

static struct kunit_suite drm_connector_attach_broadcast_rgb_property_test_suite = {
	.name = "drm_connector_attach_broadcast_rgb_property",
	.init = drm_test_connector_init,
	.test_cases = drm_connector_attach_broadcast_rgb_property_tests,
};

/*
 * Test that for a given mode, with 8bpc and an RGB output the TMDS
 * character rate is equal to the mode pixel clock.
 */
static void drm_test_drm_hdmi_compute_mode_clock_rgb(struct kunit *test)
{
	struct drm_connector_init_priv *priv = test->priv;
	const struct drm_display_mode *mode;
	unsigned long long rate;
	struct drm_device *drm = &priv->drm;

	mode = drm_kunit_display_mode_from_cea_vic(test, drm, 16);
	KUNIT_ASSERT_NOT_NULL(test, mode);

	KUNIT_ASSERT_FALSE(test, mode->flags & DRM_MODE_FLAG_DBLCLK);

	rate = drm_hdmi_compute_mode_clock(mode, 8, HDMI_COLORSPACE_RGB);
	KUNIT_ASSERT_GT(test, rate, 0);
	KUNIT_EXPECT_EQ(test, mode->clock * 1000ULL, rate);
}

/*
 * Test that for a given mode, with 10bpc and an RGB output the TMDS
 * character rate is equal to 1.25 times the mode pixel clock.
 */
static void drm_test_drm_hdmi_compute_mode_clock_rgb_10bpc(struct kunit *test)
{
	struct drm_connector_init_priv *priv = test->priv;
	const struct drm_display_mode *mode;
	unsigned long long rate;
	struct drm_device *drm = &priv->drm;

	mode = drm_kunit_display_mode_from_cea_vic(test, drm, 16);
	KUNIT_ASSERT_NOT_NULL(test, mode);

	KUNIT_ASSERT_FALSE(test, mode->flags & DRM_MODE_FLAG_DBLCLK);

	rate = drm_hdmi_compute_mode_clock(mode, 10, HDMI_COLORSPACE_RGB);
	KUNIT_ASSERT_GT(test, rate, 0);
	KUNIT_EXPECT_EQ(test, mode->clock * 1250, rate);
}

/*
 * Test that for the VIC-1 mode, with 10bpc and an RGB output the TMDS
 * character rate computation fails.
 */
static void drm_test_drm_hdmi_compute_mode_clock_rgb_10bpc_vic_1(struct kunit *test)
{
	struct drm_connector_init_priv *priv = test->priv;
	const struct drm_display_mode *mode;
	unsigned long long rate;
	struct drm_device *drm = &priv->drm;

	mode = drm_kunit_display_mode_from_cea_vic(test, drm, 1);
	KUNIT_ASSERT_NOT_NULL(test, mode);

	rate = drm_hdmi_compute_mode_clock(mode, 10, HDMI_COLORSPACE_RGB);
	KUNIT_EXPECT_EQ(test, rate, 0);
}

/*
 * Test that for a given mode, with 12bpc and an RGB output the TMDS
 * character rate is equal to 1.5 times the mode pixel clock.
 */
static void drm_test_drm_hdmi_compute_mode_clock_rgb_12bpc(struct kunit *test)
{
	struct drm_connector_init_priv *priv = test->priv;
	const struct drm_display_mode *mode;
	unsigned long long rate;
	struct drm_device *drm = &priv->drm;

	mode = drm_kunit_display_mode_from_cea_vic(test, drm, 16);
	KUNIT_ASSERT_NOT_NULL(test, mode);

	KUNIT_ASSERT_FALSE(test, mode->flags & DRM_MODE_FLAG_DBLCLK);

	rate = drm_hdmi_compute_mode_clock(mode, 12, HDMI_COLORSPACE_RGB);
	KUNIT_ASSERT_GT(test, rate, 0);
	KUNIT_EXPECT_EQ(test, mode->clock * 1500, rate);
}

/*
 * Test that for the VIC-1 mode, with 12bpc and an RGB output the TMDS
 * character rate computation fails.
 */
static void drm_test_drm_hdmi_compute_mode_clock_rgb_12bpc_vic_1(struct kunit *test)
{
	struct drm_connector_init_priv *priv = test->priv;
	const struct drm_display_mode *mode;
	unsigned long long rate;
	struct drm_device *drm = &priv->drm;

	mode = drm_kunit_display_mode_from_cea_vic(test, drm, 1);
	KUNIT_ASSERT_NOT_NULL(test, mode);

	rate = drm_hdmi_compute_mode_clock(mode, 12, HDMI_COLORSPACE_RGB);
	KUNIT_EXPECT_EQ(test, rate, 0);
}

/*
 * Test that for a mode with the pixel repetition flag, the TMDS
 * character rate is indeed double the mode pixel clock.
 */
static void drm_test_drm_hdmi_compute_mode_clock_rgb_double(struct kunit *test)
{
	struct drm_connector_init_priv *priv = test->priv;
	const struct drm_display_mode *mode;
	unsigned long long rate;
	struct drm_device *drm = &priv->drm;

	mode = drm_kunit_display_mode_from_cea_vic(test, drm, 6);
	KUNIT_ASSERT_NOT_NULL(test, mode);

	KUNIT_ASSERT_TRUE(test, mode->flags & DRM_MODE_FLAG_DBLCLK);

	rate = drm_hdmi_compute_mode_clock(mode, 8, HDMI_COLORSPACE_RGB);
	KUNIT_ASSERT_GT(test, rate, 0);
	KUNIT_EXPECT_EQ(test, (mode->clock * 1000ULL) * 2, rate);
}

/*
 * Test that the TMDS character rate computation for the VIC modes
 * explicitly listed in the spec as supporting YUV420 succeed and return
 * half the mode pixel clock.
 */
static void drm_test_connector_hdmi_compute_mode_clock_yuv420_valid(struct kunit *test)
{
	struct drm_connector_init_priv *priv = test->priv;
	const struct drm_display_mode *mode;
	struct drm_device *drm = &priv->drm;
	unsigned long long rate;
	unsigned int vic = *(unsigned int *)test->param_value;

	mode = drm_kunit_display_mode_from_cea_vic(test, drm, vic);
	KUNIT_ASSERT_NOT_NULL(test, mode);

	KUNIT_ASSERT_FALSE(test, mode->flags & DRM_MODE_FLAG_DBLCLK);

	rate = drm_hdmi_compute_mode_clock(mode, 8, HDMI_COLORSPACE_YUV420);
	KUNIT_ASSERT_GT(test, rate, 0);
	KUNIT_EXPECT_EQ(test, (mode->clock * 1000ULL) / 2, rate);
}

static const unsigned int drm_hdmi_compute_mode_clock_yuv420_vic_valid_tests[] = {
	96, 97, 101, 102, 106, 107,
};

static void drm_hdmi_compute_mode_clock_yuv420_vic_desc(const unsigned int *vic, char *desc)
{
	sprintf(desc, "VIC %u", *vic);
}

KUNIT_ARRAY_PARAM(drm_hdmi_compute_mode_clock_yuv420_valid,
		  drm_hdmi_compute_mode_clock_yuv420_vic_valid_tests,
		  drm_hdmi_compute_mode_clock_yuv420_vic_desc);

/*
 * Test that for a given mode listed supporting it and an YUV420 output
 * with 10bpc, the TMDS character rate is equal to 0.625 times the mode
 * pixel clock.
 */
static void drm_test_connector_hdmi_compute_mode_clock_yuv420_10_bpc(struct kunit *test)
{
	struct drm_connector_init_priv *priv = test->priv;
	const struct drm_display_mode *mode;
	struct drm_device *drm = &priv->drm;
	unsigned int vic =
		drm_hdmi_compute_mode_clock_yuv420_vic_valid_tests[0];
	unsigned long long rate;

	mode = drm_kunit_display_mode_from_cea_vic(test, drm, vic);
	KUNIT_ASSERT_NOT_NULL(test, mode);

	KUNIT_ASSERT_FALSE(test, mode->flags & DRM_MODE_FLAG_DBLCLK);

	rate = drm_hdmi_compute_mode_clock(mode, 10, HDMI_COLORSPACE_YUV420);
	KUNIT_ASSERT_GT(test, rate, 0);

	KUNIT_EXPECT_EQ(test, mode->clock * 625, rate);
}

/*
 * Test that for a given mode listed supporting it and an YUV420 output
 * with 12bpc, the TMDS character rate is equal to 0.75 times the mode
 * pixel clock.
 */
static void drm_test_connector_hdmi_compute_mode_clock_yuv420_12_bpc(struct kunit *test)
{
	struct drm_connector_init_priv *priv = test->priv;
	const struct drm_display_mode *mode;
	struct drm_device *drm = &priv->drm;
	unsigned int vic =
		drm_hdmi_compute_mode_clock_yuv420_vic_valid_tests[0];
	unsigned long long rate;

	mode = drm_kunit_display_mode_from_cea_vic(test, drm, vic);
	KUNIT_ASSERT_NOT_NULL(test, mode);

	KUNIT_ASSERT_FALSE(test, mode->flags & DRM_MODE_FLAG_DBLCLK);

	rate = drm_hdmi_compute_mode_clock(mode, 12, HDMI_COLORSPACE_YUV420);
	KUNIT_ASSERT_GT(test, rate, 0);

	KUNIT_EXPECT_EQ(test, mode->clock * 750, rate);
}

/*
 * Test that for a given mode, the computation of the TMDS character
 * rate with 8bpc and a YUV422 output succeeds and returns a rate equal
 * to the mode pixel clock.
 */
static void drm_test_connector_hdmi_compute_mode_clock_yuv422_8_bpc(struct kunit *test)
{
	struct drm_connector_init_priv *priv = test->priv;
	const struct drm_display_mode *mode;
	struct drm_device *drm = &priv->drm;
	unsigned long long rate;

	mode = drm_kunit_display_mode_from_cea_vic(test, drm, 16);
	KUNIT_ASSERT_NOT_NULL(test, mode);

	KUNIT_ASSERT_FALSE(test, mode->flags & DRM_MODE_FLAG_DBLCLK);

	rate = drm_hdmi_compute_mode_clock(mode, 8, HDMI_COLORSPACE_YUV422);
	KUNIT_ASSERT_GT(test, rate, 0);
	KUNIT_EXPECT_EQ(test, mode->clock * 1000, rate);
}

/*
 * Test that for a given mode, the computation of the TMDS character
 * rate with 10bpc and a YUV422 output succeeds and returns a rate equal
 * to the mode pixel clock.
 */
static void drm_test_connector_hdmi_compute_mode_clock_yuv422_10_bpc(struct kunit *test)
{
	struct drm_connector_init_priv *priv = test->priv;
	const struct drm_display_mode *mode;
	struct drm_device *drm = &priv->drm;
	unsigned long long rate;

	mode = drm_kunit_display_mode_from_cea_vic(test, drm, 16);
	KUNIT_ASSERT_NOT_NULL(test, mode);

	KUNIT_ASSERT_FALSE(test, mode->flags & DRM_MODE_FLAG_DBLCLK);

	rate = drm_hdmi_compute_mode_clock(mode, 10, HDMI_COLORSPACE_YUV422);
	KUNIT_ASSERT_GT(test, rate, 0);
	KUNIT_EXPECT_EQ(test, mode->clock * 1000, rate);
}

/*
 * Test that for a given mode, the computation of the TMDS character
 * rate with 12bpc and a YUV422 output succeeds and returns a rate equal
 * to the mode pixel clock.
 */
static void drm_test_connector_hdmi_compute_mode_clock_yuv422_12_bpc(struct kunit *test)
{
	struct drm_connector_init_priv *priv = test->priv;
	const struct drm_display_mode *mode;
	struct drm_device *drm = &priv->drm;
	unsigned long long rate;

	mode = drm_kunit_display_mode_from_cea_vic(test, drm, 16);
	KUNIT_ASSERT_NOT_NULL(test, mode);

	KUNIT_ASSERT_FALSE(test, mode->flags & DRM_MODE_FLAG_DBLCLK);

	rate = drm_hdmi_compute_mode_clock(mode, 12, HDMI_COLORSPACE_YUV422);
	KUNIT_ASSERT_GT(test, rate, 0);
	KUNIT_EXPECT_EQ(test, mode->clock * 1000, rate);
}

static struct kunit_case drm_hdmi_compute_mode_clock_tests[] = {
	KUNIT_CASE(drm_test_drm_hdmi_compute_mode_clock_rgb),
	KUNIT_CASE(drm_test_drm_hdmi_compute_mode_clock_rgb_10bpc),
	KUNIT_CASE(drm_test_drm_hdmi_compute_mode_clock_rgb_10bpc_vic_1),
	KUNIT_CASE(drm_test_drm_hdmi_compute_mode_clock_rgb_12bpc),
	KUNIT_CASE(drm_test_drm_hdmi_compute_mode_clock_rgb_12bpc_vic_1),
	KUNIT_CASE(drm_test_drm_hdmi_compute_mode_clock_rgb_double),
	KUNIT_CASE_PARAM(drm_test_connector_hdmi_compute_mode_clock_yuv420_valid,
			 drm_hdmi_compute_mode_clock_yuv420_valid_gen_params),
	KUNIT_CASE(drm_test_connector_hdmi_compute_mode_clock_yuv420_10_bpc),
	KUNIT_CASE(drm_test_connector_hdmi_compute_mode_clock_yuv420_12_bpc),
	KUNIT_CASE(drm_test_connector_hdmi_compute_mode_clock_yuv422_8_bpc),
	KUNIT_CASE(drm_test_connector_hdmi_compute_mode_clock_yuv422_10_bpc),
	KUNIT_CASE(drm_test_connector_hdmi_compute_mode_clock_yuv422_12_bpc),
	{ }
};

static struct kunit_suite drm_hdmi_compute_mode_clock_test_suite = {
	.name = "drm_test_connector_hdmi_compute_mode_clock",
	.init = drm_test_connector_init,
	.test_cases = drm_hdmi_compute_mode_clock_tests,
};

kunit_test_suites(
	&drmm_connector_hdmi_init_test_suite,
	&drmm_connector_init_test_suite,
	&drm_connector_dynamic_init_test_suite,
	&drm_connector_dynamic_register_early_test_suite,
	&drm_connector_dynamic_register_test_suite,
	&drm_connector_attach_broadcast_rgb_property_test_suite,
	&drm_get_tv_mode_from_name_test_suite,
	&drm_hdmi_compute_mode_clock_test_suite,
	&drm_hdmi_connector_get_broadcast_rgb_name_test_suite,
	&drm_hdmi_connector_get_output_format_name_test_suite
);

MODULE_AUTHOR("Maxime Ripard <maxime@cerno.tech>");
MODULE_DESCRIPTION("Kunit test for drm_modes functions");
MODULE_LICENSE("GPL");