Merge tag 'drm-intel-gt-next-2022-11-03' of git://anongit.freedesktop.org/drm/drm...

[J-linux.git] / drivers / gpu / drm / tests / drm_dp_mst_helper_test.c

diff --git a/drivers/gpu/drm/tests/drm_dp_mst_helper_test.c b/drivers/gpu/drm/tests/drm_dp_mst_helper_test.c
index 65c9d225b5580a12e3fdc060043cd8758b3a74c7..545beea33e8c70d0c9544528ce176cb72ddb9454 100644 (file)
--- a/drivers/gpu/drm/tests/drm_dp_mst_helper_test.c
+++ b/drivers/gpu/drm/tests/drm_dp_mst_helper_test.c
@@ -5,44 +5,280 @@
  * Copyright (c) 2022 Maíra Canal <[email protected]>
  */
 
  * Copyright (c) 2022 Maíra Canal <[email protected]>
  */
 

-#define PREFIX_STR "[drm_dp_mst_helper]"
-

 #include <kunit/test.h>
 
 #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"
 
 #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)
 {
 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)
 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;
 }
 
        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 = &params->in;

        struct drm_dp_sideband_msg_req_body *out;
        struct drm_dp_sideband_msg_req_body *out;

-       struct drm_printer p = drm_err_printer(PREFIX_STR);

        struct drm_dp_sideband_msg_tx *txmsg;
        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);
 
        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)) {
 
        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_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);
                drm_dp_dump_sideband_msg_req_body(out, 1, &p);

-               result = false;
-               goto out;

        }
 
        switch (in->req_type) {
        }
 
        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;
        }
                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[] = {
 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),

        { }
 };
 
        { }
 };