drm/tests: Add infoframes test

The previous patch added the generation of the infoframes matching an
HDMI connector state. Let's add a few tests to make sure it works as
expected.

Reviewed-by: Dmitry Baryshkov <dmitry.baryshkov@linaro.org>
Link: https://patchwork.freedesktop.org/patch/msgid/20240527-kms-hdmi-connector-state-v15-23-c5af16c3aae2@kernel.org
Signed-off-by: Maxime Ripard <mripard@kernel.org>

diff --git a/drivers/gpu/drm/tests/drm_connector_test.c b/drivers/gpu/drm/tests/drm_connector_test.c
index 2e63161..eda2e5d 100644 (file)
--- a/drivers/gpu/drm/tests/drm_connector_test.c
+++ b/drivers/gpu/drm/tests/drm_connector_test.c
@@ -221,6 +221,217 @@ static void drm_test_connector_hdmi_init_null_ddc(struct kunit *test)
        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.
@@ -516,6 +727,14 @@ static struct kunit_case drmm_connector_hdmi_init_tests[] = {
        KUNIT_CASE(drm_test_connector_hdmi_init_formats_empty),
        KUNIT_CASE(drm_test_connector_hdmi_init_formats_no_rgb),
        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,