Add a list of planes to vkms_config and create as many planes as
configured during output initialization.
For backwards compatibility, add one primary plane and, if configured,
one cursor plane and NUM_OVERLAY_PLANES planes to the default
configuration.
Signed-off-by: Louis Chauvet <louis.chauvet@bootlin.com>
Signed-off-by: José Expósito <jose.exposito89@gmail.com>
---
drivers/gpu/drm/vkms/tests/vkms_config_test.c | 133 +++++++++++++++-
drivers/gpu/drm/vkms/vkms_config.c | 149 +++++++++++++++++-
drivers/gpu/drm/vkms/vkms_config.h | 78 ++++++++-
drivers/gpu/drm/vkms/vkms_output.c | 67 ++++----
4 files changed, 386 insertions(+), 41 deletions(-)
diff --git a/drivers/gpu/drm/vkms/tests/vkms_config_test.c b/drivers/gpu/drm/vkms/tests/vkms_config_test.c
index 66c2c6cb4a0e..7d9cb3956741 100644
--- a/drivers/gpu/drm/vkms/tests/vkms_config_test.c
+++ b/drivers/gpu/drm/vkms/tests/vkms_config_test.c
@@ -24,6 +24,10 @@ static void vkms_config_test_empty_config(struct kunit *test)
dev_name = NULL;
KUNIT_EXPECT_STREQ(test, vkms_config_get_device_name(config), "test");
+ KUNIT_EXPECT_TRUE(test, list_empty(&config->planes));
+
+ KUNIT_EXPECT_FALSE(test, vkms_config_is_valid(config));
+
vkms_config_destroy(config);
}
@@ -44,16 +48,138 @@ static void vkms_config_test_default_config(struct kunit *test)
{
const struct default_config_case *params = test->param_value;
struct vkms_config *config;
+ struct vkms_config_plane *plane_cfg;
+ int n_primaries = 0;
+ int n_cursors = 0;
+ int n_overlays = 0;
config = vkms_config_default_create(params->enable_cursor,
params->enable_writeback,
params->enable_overlay);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, config);
- KUNIT_EXPECT_EQ(test, config->cursor, params->enable_cursor);
KUNIT_EXPECT_EQ(test, config->writeback, params->enable_writeback);
- KUNIT_EXPECT_EQ(test, config->overlay, params->enable_overlay);
+ /* Planes */
+ list_for_each_entry(plane_cfg, &config->planes, link) {
+ switch (vkms_config_plane_get_type(plane_cfg)) {
+ case DRM_PLANE_TYPE_PRIMARY:
+ n_primaries++;
+ break;
+ case DRM_PLANE_TYPE_CURSOR:
+ n_cursors++;
+ break;
+ case DRM_PLANE_TYPE_OVERLAY:
+ n_overlays++;
+ break;
+ default:
+ KUNIT_FAIL_AND_ABORT(test, "Unknown plane type");
+ }
+ }
+ KUNIT_EXPECT_EQ(test, n_primaries, 1);
+ KUNIT_EXPECT_EQ(test, n_cursors, params->enable_cursor ? 1 : 0);
+ KUNIT_EXPECT_EQ(test, n_overlays, params->enable_overlay ? 8 : 0);
+
+ KUNIT_EXPECT_TRUE(test, vkms_config_is_valid(config));
+
+ vkms_config_destroy(config);
+}
+
+static void vkms_config_test_get_planes(struct kunit *test)
+{
+ struct vkms_config *config;
+ struct vkms_config_plane *plane_cfg1, *plane_cfg2;
+ struct vkms_config_plane **array;
+ size_t length;
+
+ config = vkms_config_create("test");
+ KUNIT_ASSERT_NOT_ERR_OR_NULL(test, config);
+
+ array = vkms_config_get_planes(config, &length);
+ KUNIT_ASSERT_EQ(test, length, 0);
+ KUNIT_ASSERT_NULL(test, array);
+
+ plane_cfg1 = vkms_config_add_plane(config);
+ array = vkms_config_get_planes(config, &length);
+ KUNIT_ASSERT_EQ(test, length, 1);
+ KUNIT_ASSERT_PTR_EQ(test, array[0], plane_cfg1);
+ kfree(array);
+
+ plane_cfg2 = vkms_config_add_plane(config);
+ array = vkms_config_get_planes(config, &length);
+ KUNIT_ASSERT_EQ(test, length, 2);
+ KUNIT_ASSERT_PTR_EQ(test, array[0], plane_cfg1);
+ KUNIT_ASSERT_PTR_EQ(test, array[1], plane_cfg2);
+ kfree(array);
+
+ vkms_config_destroy_plane(plane_cfg1);
+ array = vkms_config_get_planes(config, &length);
+ KUNIT_ASSERT_EQ(test, length, 1);
+ KUNIT_ASSERT_PTR_EQ(test, array[0], plane_cfg2);
+ kfree(array);
+
+ vkms_config_destroy(config);
+}
+
+static void vkms_config_test_valid_plane_number(struct kunit *test)
+{
+ struct vkms_config *config;
+ struct vkms_config_plane *plane_cfg;
+ int n;
+
+ config = vkms_config_default_create(false, false, false);
+ KUNIT_ASSERT_NOT_ERR_OR_NULL(test, config);
+
+ /* Invalid: No planes */
+ plane_cfg = list_first_entry(&config->planes, typeof(*plane_cfg), link);
+ vkms_config_destroy_plane(plane_cfg);
+ KUNIT_EXPECT_FALSE(test, vkms_config_is_valid(config));
+
+ /* Invalid: Too many planes */
+ for (n = 0; n <= 32; n++)
+ vkms_config_add_plane(config);
+
+ KUNIT_EXPECT_FALSE(test, vkms_config_is_valid(config));
+
+ vkms_config_destroy(config);
+}
+
+static void vkms_config_test_valid_plane_type(struct kunit *test)
+{
+ struct vkms_config *config;
+ struct vkms_config_plane *plane_cfg;
+
+ config = vkms_config_default_create(false, false, false);
+ KUNIT_ASSERT_NOT_ERR_OR_NULL(test, config);
+
+ plane_cfg = list_first_entry(&config->planes, typeof(*plane_cfg), link);
+ vkms_config_destroy_plane(plane_cfg);
+
+ /* Invalid: No primary plane */
+ plane_cfg = vkms_config_add_plane(config);
+ vkms_config_plane_set_type(plane_cfg, DRM_PLANE_TYPE_OVERLAY);
+ KUNIT_EXPECT_FALSE(test, vkms_config_is_valid(config));
+
+ /* Invalid: Multiple primary planes */
+ plane_cfg = vkms_config_add_plane(config);
+ vkms_config_plane_set_type(plane_cfg, DRM_PLANE_TYPE_PRIMARY);
+ plane_cfg = vkms_config_add_plane(config);
+ vkms_config_plane_set_type(plane_cfg, DRM_PLANE_TYPE_PRIMARY);
+ KUNIT_EXPECT_FALSE(test, vkms_config_is_valid(config));
+
+ /* Valid: One primary plane */
+ vkms_config_destroy_plane(plane_cfg);
+ KUNIT_EXPECT_TRUE(test, vkms_config_is_valid(config));
+
+ /* Invalid: Multiple cursor planes */
+ plane_cfg = vkms_config_add_plane(config);
+ vkms_config_plane_set_type(plane_cfg, DRM_PLANE_TYPE_CURSOR);
+ plane_cfg = vkms_config_add_plane(config);
+ vkms_config_plane_set_type(plane_cfg, DRM_PLANE_TYPE_CURSOR);
+ KUNIT_EXPECT_FALSE(test, vkms_config_is_valid(config));
+
+ /* Valid: One primary and one cursor plane */
+ vkms_config_destroy_plane(plane_cfg);
KUNIT_EXPECT_TRUE(test, vkms_config_is_valid(config));
vkms_config_destroy(config);
@@ -63,6 +189,9 @@ static struct kunit_case vkms_config_test_cases[] = {
KUNIT_CASE(vkms_config_test_empty_config),
KUNIT_CASE_PARAM(vkms_config_test_default_config,
default_config_gen_params),
+ KUNIT_CASE(vkms_config_test_get_planes),
+ KUNIT_CASE(vkms_config_test_valid_plane_number),
+ KUNIT_CASE(vkms_config_test_valid_plane_type),
{}
};
diff --git a/drivers/gpu/drm/vkms/vkms_config.c b/drivers/gpu/drm/vkms/vkms_config.c
index 67f71d29596e..a5a77612645f 100644
--- a/drivers/gpu/drm/vkms/vkms_config.c
+++ b/drivers/gpu/drm/vkms/vkms_config.c
@@ -21,6 +21,8 @@ struct vkms_config *vkms_config_create(const char *dev_name)
return ERR_PTR(-ENOMEM);
}
+ INIT_LIST_HEAD(&config->planes);
+
return config;
}
@@ -29,26 +31,139 @@ struct vkms_config *vkms_config_default_create(bool enable_cursor,
bool enable_overlay)
{
struct vkms_config *config;
+ struct vkms_config_plane *plane_cfg;
+ int n;
config = vkms_config_create(DEFAULT_DEVICE_NAME);
if (IS_ERR(config))
return config;
- config->cursor = enable_cursor;
config->writeback = enable_writeback;
- config->overlay = enable_overlay;
+
+ plane_cfg = vkms_config_add_plane(config);
+ if (IS_ERR(plane_cfg))
+ goto err_alloc;
+ vkms_config_plane_set_type(plane_cfg, DRM_PLANE_TYPE_PRIMARY);
+
+ if (enable_overlay) {
+ for (n = 0; n < NUM_OVERLAY_PLANES; n++) {
+ plane_cfg = vkms_config_add_plane(config);
+ if (IS_ERR(plane_cfg))
+ goto err_alloc;
+ vkms_config_plane_set_type(plane_cfg,
+ DRM_PLANE_TYPE_OVERLAY);
+ }
+ }
+
+ if (enable_cursor) {
+ plane_cfg = vkms_config_add_plane(config);
+ if (IS_ERR(plane_cfg))
+ goto err_alloc;
+ vkms_config_plane_set_type(plane_cfg, DRM_PLANE_TYPE_CURSOR);
+ }
return config;
+
+err_alloc:
+ vkms_config_destroy(config);
+ return ERR_PTR(-ENOMEM);
}
void vkms_config_destroy(struct vkms_config *config)
{
+ struct vkms_config_plane *plane_cfg, *plane_tmp;
+
+ list_for_each_entry_safe(plane_cfg, plane_tmp, &config->planes, link)
+ vkms_config_destroy_plane(plane_cfg);
+
kfree_const(config->dev_name);
kfree(config);
}
+struct vkms_config_plane **vkms_config_get_planes(const struct vkms_config *config,
+ size_t *out_length)
+{
+ struct vkms_config_plane **array;
+ struct vkms_config_plane *plane_cfg;
+ size_t length;
+ int n = 0;
+
+ length = list_count_nodes((struct list_head *)&config->planes);
+ if (length == 0) {
+ *out_length = length;
+ return NULL;
+ }
+
+ array = kmalloc_array(length, sizeof(*array), GFP_KERNEL);
+ if (!array)
+ return ERR_PTR(-ENOMEM);
+
+ list_for_each_entry(plane_cfg, &config->planes, link) {
+ array[n] = plane_cfg;
+ n++;
+ }
+
+ *out_length = length;
+ return array;
+}
+
+static bool valid_plane_number(struct vkms_config *config)
+{
+ size_t n_planes;
+
+ n_planes = list_count_nodes(&config->planes);
+ if (n_planes <= 0 || n_planes >= 32) {
+ pr_err("The number of planes must be between 1 and 31\n");
+ return false;
+ }
+
+ return true;
+}
+
+static bool valid_plane_type(struct vkms_config *config)
+{
+ struct vkms_config_plane *plane_cfg;
+ bool has_primary_plane = false;
+ bool has_cursor_plane = false;
+
+ list_for_each_entry(plane_cfg, &config->planes, link) {
+ enum drm_plane_type type;
+
+ type = vkms_config_plane_get_type(plane_cfg);
+
+ if (type == DRM_PLANE_TYPE_PRIMARY) {
+ if (has_primary_plane) {
+ pr_err("Multiple primary planes\n");
+ return false;
+ }
+
+ has_primary_plane = true;
+ } else if (type == DRM_PLANE_TYPE_CURSOR) {
+ if (has_cursor_plane) {
+ pr_err("Multiple cursor planes\n");
+ return false;
+ }
+
+ has_cursor_plane = true;
+ }
+ }
+
+ if (!has_primary_plane) {
+ pr_err("Primary plane not found\n");
+ return false;
+ }
+
+ return true;
+}
+
bool vkms_config_is_valid(struct vkms_config *config)
{
+ if (!valid_plane_number(config))
+ return false;
+
+ if (!valid_plane_type(config))
+ return false;
+
return true;
}
@@ -58,12 +173,17 @@ static int vkms_config_show(struct seq_file *m, void *data)
struct drm_device *dev = entry->dev;
struct vkms_device *vkmsdev = drm_device_to_vkms_device(dev);
const char *dev_name;
+ struct vkms_config_plane *plane_cfg;
dev_name = vkms_config_get_device_name((struct vkms_config *)vkmsdev->config);
seq_printf(m, "dev_name=%s\n", dev_name);
seq_printf(m, "writeback=%d\n", vkmsdev->config->writeback);
- seq_printf(m, "cursor=%d\n", vkmsdev->config->cursor);
- seq_printf(m, "overlay=%d\n", vkmsdev->config->overlay);
+
+ list_for_each_entry(plane_cfg, &vkmsdev->config->planes, link) {
+ seq_puts(m, "plane:\n");
+ seq_printf(m, "\ttype=%d\n",
+ vkms_config_plane_get_type(plane_cfg));
+ }
return 0;
}
@@ -77,3 +197,24 @@ void vkms_config_register_debugfs(struct vkms_device *vkms_device)
drm_debugfs_add_files(&vkms_device->drm, vkms_config_debugfs_list,
ARRAY_SIZE(vkms_config_debugfs_list));
}
+
+struct vkms_config_plane *vkms_config_add_plane(struct vkms_config *config)
+{
+ struct vkms_config_plane *plane_cfg;
+
+ plane_cfg = kzalloc(sizeof(*plane_cfg), GFP_KERNEL);
+ if (!plane_cfg)
+ return ERR_PTR(-ENOMEM);
+
+ vkms_config_plane_set_type(plane_cfg, DRM_PLANE_TYPE_OVERLAY);
+
+ list_add_tail(&plane_cfg->link, &config->planes);
+
+ return plane_cfg;
+}
+
+void vkms_config_destroy_plane(struct vkms_config_plane *plane_cfg)
+{
+ list_del(&plane_cfg->link);
+ kfree(plane_cfg);
+}
diff --git a/drivers/gpu/drm/vkms/vkms_config.h b/drivers/gpu/drm/vkms/vkms_config.h
index 963f22b9b4bd..d9aeba1762d1 100644
--- a/drivers/gpu/drm/vkms/vkms_config.h
+++ b/drivers/gpu/drm/vkms/vkms_config.h
@@ -3,6 +3,7 @@
#ifndef _VKMS_CONFIG_H_
#define _VKMS_CONFIG_H_
+#include <linux/list.h>
#include <linux/types.h>
#include "vkms_drv.h"
@@ -12,18 +13,36 @@
*
* @dev_name: Name of the device
* @writeback: If true, a writeback buffer can be attached to the CRTC
- * @cursor: If true, a cursor plane is created in the VKMS device
- * @overlay: If true, NUM_OVERLAY_PLANES will be created for the VKMS device
+ * @planes: List of planes configured for the device
* @dev: Used to store the current VKMS device. Only set when the device is instantiated.
*/
struct vkms_config {
const char *dev_name;
bool writeback;
- bool cursor;
- bool overlay;
+ struct list_head planes;
struct vkms_device *dev;
};
+/**
+ * struct vkms_config_plane
+ *
+ * @link: Link to the others planes in vkms_config
+ * @type: Type of the plane. The creator of configuration needs to ensures that
+ * at least one primary plane is present.
+ * @plane: Internal usage. This pointer should never be considered as valid.
+ * It can be used to store a temporary reference to a VKMS plane during
+ * device creation. This pointer is not managed by the configuration and
+ * must be managed by other means.
+ */
+struct vkms_config_plane {
+ struct list_head link;
+
+ enum drm_plane_type type;
+
+ /* Internal usage */
+ struct vkms_plane *plane;
+};
+
/**
* vkms_config_create() - Create a new VKMS configuration
* @dev_name: Name of the device
@@ -64,6 +83,19 @@ vkms_config_get_device_name(struct vkms_config *config)
return config->dev_name;
}
+/**
+ * vkms_config_planes() - Return the array of planes of the device
+ * @config: Configuration to get the planes from
+ * @out_length: Length of the returned array
+ *
+ * Returns:
+ * A list of pointers to the configurations. On success, the caller is
+ * responsible to free the returned array, but not its contents. On error,
+ * it returns an error and @out_length is invalid.
+ */
+struct vkms_config_plane **vkms_config_get_planes(const struct vkms_config *config,
+ size_t *out_length);
+
/**
* vkms_config_is_valid() - Validate a configuration
* @config: Configuration to validate
@@ -81,4 +113,42 @@ bool vkms_config_is_valid(struct vkms_config *config);
*/
void vkms_config_register_debugfs(struct vkms_device *vkms_device);
+/**
+ * vkms_config_add_plane() - Add a new plane configuration
+ * @config: Configuration to add the plane to
+ *
+ * Returns:
+ * The new plane configuration or an error. Call vkms_config_destroy_plane() to
+ * free the returned plane configuration.
+ */
+struct vkms_config_plane *vkms_config_add_plane(struct vkms_config *config);
+
+/**
+ * vkms_config_destroy_plane() - Remove and free a plane configuration
+ * @plane_cfg: Plane configuration to destroy
+ */
+void vkms_config_destroy_plane(struct vkms_config_plane *plane_cfg);
+
+/**
+ * vkms_config_plane_type() - Return the plane type
+ * @plane_cfg: Plane to get the type from
+ */
+static inline enum drm_plane_type
+vkms_config_plane_get_type(struct vkms_config_plane *plane_cfg)
+{
+ return plane_cfg->type;
+}
+
+/**
+ * vkms_config_plane_set_type() - Set the plane type
+ * @plane_cfg: Plane to set the type to
+ * @type: New plane type
+ */
+static inline void
+vkms_config_plane_set_type(struct vkms_config_plane *plane_cfg,
+ enum drm_plane_type type)
+{
+ plane_cfg->type = type;
+}
+
#endif /* _VKMS_CONFIG_H_ */
diff --git a/drivers/gpu/drm/vkms/vkms_output.c b/drivers/gpu/drm/vkms/vkms_output.c
index 068a7f87ecec..b2ae269e5827 100644
--- a/drivers/gpu/drm/vkms/vkms_output.c
+++ b/drivers/gpu/drm/vkms/vkms_output.c
@@ -11,61 +11,63 @@ int vkms_output_init(struct vkms_device *vkmsdev)
struct vkms_connector *connector;
struct drm_encoder *encoder;
struct vkms_output *output;
- struct vkms_plane *primary, *overlay, *cursor = NULL;
- int ret;
+ struct vkms_plane *primary = NULL, *cursor = NULL;
+ struct vkms_config_plane **plane_cfgs = NULL;
+ size_t n_planes;
+ int ret = 0;
int writeback;
unsigned int n;
- /*
- * Initialize used plane. One primary plane is required to perform the composition.
- *
- * The overlay and cursor planes are not mandatory, but can be used to perform complex
- * composition.
- */
- primary = vkms_plane_init(vkmsdev, DRM_PLANE_TYPE_PRIMARY);
- if (IS_ERR(primary))
- return PTR_ERR(primary);
+ plane_cfgs = vkms_config_get_planes(vkmsdev->config, &n_planes);
+ if (IS_ERR(plane_cfgs))
+ return PTR_ERR(plane_cfgs);
- if (vkmsdev->config->cursor) {
- cursor = vkms_plane_init(vkmsdev, DRM_PLANE_TYPE_CURSOR);
- if (IS_ERR(cursor))
- return PTR_ERR(cursor);
+ for (n = 0; n < n_planes; n++) {
+ struct vkms_config_plane *plane_cfg;
+ enum drm_plane_type type;
+
+ plane_cfg = plane_cfgs[n];
+ type = vkms_config_plane_get_type(plane_cfg);
+
+ plane_cfg->plane = vkms_plane_init(vkmsdev, type);
+ if (IS_ERR(plane_cfg->plane)) {
+ DRM_DEV_ERROR(dev->dev, "Failed to init vkms plane\n");
+ ret = PTR_ERR(plane_cfg->plane);
+ goto err_free;
+ }
+
+ if (type == DRM_PLANE_TYPE_PRIMARY)
+ primary = plane_cfg->plane;
+ else if (type == DRM_PLANE_TYPE_CURSOR)
+ cursor = plane_cfg->plane;
}
output = vkms_crtc_init(dev, &primary->base,
cursor ? &cursor->base : NULL);
if (IS_ERR(output)) {
DRM_ERROR("Failed to allocate CRTC\n");
- return PTR_ERR(output);
- }
-
- if (vkmsdev->config->overlay) {
- for (n = 0; n < NUM_OVERLAY_PLANES; n++) {
- overlay = vkms_plane_init(vkmsdev, DRM_PLANE_TYPE_OVERLAY);
- if (IS_ERR(overlay)) {
- DRM_DEV_ERROR(dev->dev, "Failed to init vkms plane\n");
- return PTR_ERR(overlay);
- }
- overlay->base.possible_crtcs = drm_crtc_mask(&output->crtc);
- }
+ ret = PTR_ERR(output);
+ goto err_free;
}
connector = vkms_connector_init(vkmsdev);
if (IS_ERR(connector)) {
DRM_ERROR("Failed to init connector\n");
- return PTR_ERR(connector);
+ ret = PTR_ERR(connector);
+ goto err_free;
}
encoder = drmm_kzalloc(dev, sizeof(*encoder), GFP_KERNEL);
if (!encoder) {
DRM_ERROR("Failed to allocate encoder\n");
- return -ENOMEM;
+ ret = -ENOMEM;
+ goto err_free;
}
ret = drmm_encoder_init(dev, encoder, NULL,
DRM_MODE_ENCODER_VIRTUAL, NULL);
if (ret) {
DRM_ERROR("Failed to init encoder\n");
- return ret;
+ goto err_free;
}
encoder->possible_crtcs = drm_crtc_mask(&output->crtc);
@@ -73,7 +75,7 @@ int vkms_output_init(struct vkms_device *vkmsdev)
ret = drm_connector_attach_encoder(&connector->base, encoder);
if (ret) {
DRM_ERROR("Failed to attach connector to encoder\n");
- return ret;
+ goto err_free;
}
/* Initialize the writeback component */
@@ -85,5 +87,8 @@ int vkms_output_init(struct vkms_device *vkmsdev)
drm_mode_config_reset(dev);
+err_free:
+ kfree(plane_cfgs);
+
return ret;
}
--
2.48.1
On 29/01/25 - 12:00, José Expósito wrote:
> Add a list of planes to vkms_config and create as many planes as
> configured during output initialization.
>
> For backwards compatibility, add one primary plane and, if configured,
> one cursor plane and NUM_OVERLAY_PLANES planes to the default
> configuration.
>
> Signed-off-by: Louis Chauvet <louis.chauvet@bootlin.com>
> Signed-off-by: José Expósito <jose.exposito89@gmail.com>
Co-developped-by: Louis Chauvet <louis.chauvet@bootlin.com>
Signed-off-by: Louis Chauvet <louis.chauvet@bootlin.com>
Signed-off-by: José Expósito <jose.exposito89@gmail.com>
[...]
> diff --git a/drivers/gpu/drm/vkms/tests/vkms_config_test.c b/drivers/gpu/drm/vkms/tests/vkms_config_test.c
[...]
> +static void vkms_config_test_get_planes(struct kunit *test)
> +{
> + struct vkms_config *config;
> + struct vkms_config_plane *plane_cfg1, *plane_cfg2;
> + struct vkms_config_plane **array;
> + size_t length;
> +
> + config = vkms_config_create("test");
> + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, config);
> +
> + array = vkms_config_get_planes(config, &length);
> + KUNIT_ASSERT_EQ(test, length, 0);
> + KUNIT_ASSERT_NULL(test, array);
> +
> + plane_cfg1 = vkms_config_add_plane(config);
> + array = vkms_config_get_planes(config, &length);
> + KUNIT_ASSERT_EQ(test, length, 1);
> + KUNIT_ASSERT_PTR_EQ(test, array[0], plane_cfg1);
> + kfree(array);
> +
> + plane_cfg2 = vkms_config_add_plane(config);
> + array = vkms_config_get_planes(config, &length);
> + KUNIT_ASSERT_EQ(test, length, 2);
> + KUNIT_ASSERT_PTR_EQ(test, array[0], plane_cfg1);
> + KUNIT_ASSERT_PTR_EQ(test, array[1], plane_cfg2);
> + kfree(array);
> +
> + vkms_config_destroy_plane(plane_cfg1);
> + array = vkms_config_get_planes(config, &length);
> + KUNIT_ASSERT_EQ(test, length, 1);
> + KUNIT_ASSERT_PTR_EQ(test, array[0], plane_cfg2);
> + kfree(array);
> +
> + vkms_config_destroy(config);
> +}
In this test I have the feeling that vkms_config_get_planes always returns
a predictable order. It is maybe trivial here, but I would prefer to shows
that the order is not stable, for example:
bool plane_cfg1_found = false;
bool plane_cfg2_found = false;
vkms_config_for_each_plane(config, plane_cfg) {
if (plane_cfg == plane_cfg1)
plane_cfg1_found = true;
else if (plane_cfg == plane_cfg2)
plane_cfg2_found = true;
else
KUNIT_FAILS("Unexpected plane");
}
KUNIT_ASSERT(test, plane_cfg1_found);
KUNIT_ASSERT(test, plane_cfg2_found);
[...]
> +static void vkms_config_test_valid_plane_number(struct kunit *test)
> +{
> + struct vkms_config *config;
> + struct vkms_config_plane *plane_cfg;
> + int n;
> +
> + config = vkms_config_default_create(false, false, false);
> + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, config);
> +
> + /* Invalid: No planes */
> + plane_cfg = list_first_entry(&config->planes, typeof(*plane_cfg), link);
> + vkms_config_destroy_plane(plane_cfg);
> + KUNIT_EXPECT_FALSE(test, vkms_config_is_valid(config));
> +
> + /* Invalid: Too many planes */
> + for (n = 0; n <= 32; n++)
> + vkms_config_add_plane(config);
> +
> + KUNIT_EXPECT_FALSE(test, vkms_config_is_valid(config));
> +
> + vkms_config_destroy(config);
> +}
For this function, the naming is a bit strange, it says
"valid_plane_number", but you test only invalid plane number.
Can you rename it to vkms_config_test_invalid_plane_number?
[...]
> diff --git a/drivers/gpu/drm/vkms/vkms_config.c b/drivers/gpu/drm/vkms/vkms_config.c
[...]
> +struct vkms_config_plane **vkms_config_get_planes(const struct vkms_config *config,
> + size_t *out_length)
> +{
> + struct vkms_config_plane **array;
> + struct vkms_config_plane *plane_cfg;
> + size_t length;
> + int n = 0;
> +
> + length = list_count_nodes((struct list_head *)&config->planes);
> + if (length == 0) {
> + *out_length = length;
> + return NULL;
> + }
> +
> + array = kmalloc_array(length, sizeof(*array), GFP_KERNEL);
> + if (!array)
> + return ERR_PTR(-ENOMEM);
> +
> + list_for_each_entry(plane_cfg, &config->planes, link) {
> + array[n] = plane_cfg;
> + n++;
> + }
> +
> + *out_length = length;
> + return array;
> +}
To join the comment on the test, I am not a big fan of creating a new list
to return to the caller, for three reasons:
- the caller needs to manage an other pointer;
- the caller needs to understand that the content of the array is only
valid if: the config is not freed, nobody else removed anything from the
planes;
- the caller may think this list always have the same order if he looks at
the tests.
I would prefer a simple macro to do an iteration over the config->planes
list: (I did not test this macro, but you have this idea)
#define vkms_config_iter_plane(config, plane_cfg) \
list_for_each_entry((plane_cfg), &(config).planes, link)
This way:
- no new pointer to manage;
- if one day we have concurency issue, we just have to protect config, not
config+all the planes;
- there is no expected order.
[...]
> bool vkms_config_is_valid(struct vkms_config *config)
> {
> + if (!valid_plane_number(config))
> + return false;
> +
> + if (!valid_plane_type(config))
> + return false;
> +
> return true;
> }
I really like the idea to split the validation function, way simpler!
[...]
> +void vkms_config_destroy_plane(struct vkms_config_plane *plane_cfg)
> +{
> + list_del(&plane_cfg->link);
> + kfree(plane_cfg);
> +}
I would prefer a "standard" function pair, i.e.: add/remove or
create/destroy, not add/destroy.
For me it should be create/destroy, you create the plane by using a
config, so it is clear it will be attached to it.
If you choose add/remove, you should explains in the documentation that
remove is also doing kfree.
[...]
> diff --git a/drivers/gpu/drm/vkms/vkms_output.c b/drivers/gpu/drm/vkms/vkms_output.c
[...]
> @@ -11,61 +11,63 @@ int vkms_output_init(struct vkms_device *vkmsdev)
> struct vkms_connector *connector;
> struct drm_encoder *encoder;
> struct vkms_output *output;
> - struct vkms_plane *primary, *overlay, *cursor = NULL;
> - int ret;
> + struct vkms_plane *primary = NULL, *cursor = NULL;
> + struct vkms_config_plane **plane_cfgs = NULL;
> + size_t n_planes;
> + int ret = 0;
> int writeback;
> unsigned int n;
I think it could be interesting to have a vkms_config_is_valid call here.
It will avoid raising DRM errors or create unexpected devices.
It will also garantee in a later patch that
vkms_config_crtc_get_primary_plane is a valid pointer.
> - /*
> - * Initialize used plane. One primary plane is required to perform the composition.
> - *
> - * The overlay and cursor planes are not mandatory, but can be used to perform complex
> - * composition.
> - */
> - primary = vkms_plane_init(vkmsdev, DRM_PLANE_TYPE_PRIMARY);
> - if (IS_ERR(primary))
> - return PTR_ERR(primary);
> + plane_cfgs = vkms_config_get_planes(vkmsdev->config, &n_planes);
> + if (IS_ERR(plane_cfgs))
> + return PTR_ERR(plane_cfgs);
If you agree on the iterator implementation, this code could be simplified
a lot.
> - if (vkmsdev->config->cursor) {
> - cursor = vkms_plane_init(vkmsdev, DRM_PLANE_TYPE_CURSOR);
> - if (IS_ERR(cursor))
> - return PTR_ERR(cursor);
> + for (n = 0; n < n_planes; n++) {
> + struct vkms_config_plane *plane_cfg;
> + enum drm_plane_type type;
> +
> + plane_cfg = plane_cfgs[n];
> + type = vkms_config_plane_get_type(plane_cfg);
> +
> + plane_cfg->plane = vkms_plane_init(vkmsdev, type);
Can we pass plane_cfg in vkms_plane_init? This way we don't have to
touch vkms_output_init when adding new vkms_config_plane members.
> + if (IS_ERR(plane_cfg->plane)) {
> + DRM_DEV_ERROR(dev->dev, "Failed to init vkms plane\n");
> + ret = PTR_ERR(plane_cfg->plane);
> + goto err_free;
> + }
> +
> + if (type == DRM_PLANE_TYPE_PRIMARY)
> + primary = plane_cfg->plane;
> + else if (type == DRM_PLANE_TYPE_CURSOR)
> + cursor = plane_cfg->plane;
> }
[...]
On Thu, Jan 30, 2025 at 02:48:19PM +0100, Louis Chauvet wrote:
> On 29/01/25 - 12:00, José Expósito wrote:
> > Add a list of planes to vkms_config and create as many planes as
> > configured during output initialization.
> >
> > For backwards compatibility, add one primary plane and, if configured,
> > one cursor plane and NUM_OVERLAY_PLANES planes to the default
> > configuration.
> >
> > Signed-off-by: Louis Chauvet <louis.chauvet@bootlin.com>
> > Signed-off-by: José Expósito <jose.exposito89@gmail.com>
>
> Co-developped-by: Louis Chauvet <louis.chauvet@bootlin.com>
> Signed-off-by: Louis Chauvet <louis.chauvet@bootlin.com>
> Signed-off-by: José Expósito <jose.exposito89@gmail.com>
>
> [...]
>
> > diff --git a/drivers/gpu/drm/vkms/tests/vkms_config_test.c b/drivers/gpu/drm/vkms/tests/vkms_config_test.c
>
> [...]
>
> > +static void vkms_config_test_get_planes(struct kunit *test)
> > +{
> > + struct vkms_config *config;
> > + struct vkms_config_plane *plane_cfg1, *plane_cfg2;
> > + struct vkms_config_plane **array;
> > + size_t length;
> > +
> > + config = vkms_config_create("test");
> > + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, config);
> > +
> > + array = vkms_config_get_planes(config, &length);
> > + KUNIT_ASSERT_EQ(test, length, 0);
> > + KUNIT_ASSERT_NULL(test, array);
> > +
> > + plane_cfg1 = vkms_config_add_plane(config);
> > + array = vkms_config_get_planes(config, &length);
> > + KUNIT_ASSERT_EQ(test, length, 1);
> > + KUNIT_ASSERT_PTR_EQ(test, array[0], plane_cfg1);
> > + kfree(array);
> > +
> > + plane_cfg2 = vkms_config_add_plane(config);
> > + array = vkms_config_get_planes(config, &length);
> > + KUNIT_ASSERT_EQ(test, length, 2);
> > + KUNIT_ASSERT_PTR_EQ(test, array[0], plane_cfg1);
> > + KUNIT_ASSERT_PTR_EQ(test, array[1], plane_cfg2);
> > + kfree(array);
> > +
> > + vkms_config_destroy_plane(plane_cfg1);
> > + array = vkms_config_get_planes(config, &length);
> > + KUNIT_ASSERT_EQ(test, length, 1);
> > + KUNIT_ASSERT_PTR_EQ(test, array[0], plane_cfg2);
> > + kfree(array);
> > +
> > + vkms_config_destroy(config);
> > +}
>
> In this test I have the feeling that vkms_config_get_planes always returns
> a predictable order. It is maybe trivial here, but I would prefer to shows
> that the order is not stable, for example:
>
> bool plane_cfg1_found = false;
> bool plane_cfg2_found = false;
>
> vkms_config_for_each_plane(config, plane_cfg) {
> if (plane_cfg == plane_cfg1)
> plane_cfg1_found = true;
> else if (plane_cfg == plane_cfg2)
> plane_cfg2_found = true;
> else
> KUNIT_FAILS("Unexpected plane");
> }
>
> KUNIT_ASSERT(test, plane_cfg1_found);
> KUNIT_ASSERT(test, plane_cfg2_found);
>
> [...]
>
> > +static void vkms_config_test_valid_plane_number(struct kunit *test)
> > +{
> > + struct vkms_config *config;
> > + struct vkms_config_plane *plane_cfg;
> > + int n;
> > +
> > + config = vkms_config_default_create(false, false, false);
> > + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, config);
> > +
> > + /* Invalid: No planes */
> > + plane_cfg = list_first_entry(&config->planes, typeof(*plane_cfg), link);
> > + vkms_config_destroy_plane(plane_cfg);
> > + KUNIT_EXPECT_FALSE(test, vkms_config_is_valid(config));
> > +
> > + /* Invalid: Too many planes */
> > + for (n = 0; n <= 32; n++)
> > + vkms_config_add_plane(config);
> > +
> > + KUNIT_EXPECT_FALSE(test, vkms_config_is_valid(config));
> > +
> > + vkms_config_destroy(config);
> > +}
>
> For this function, the naming is a bit strange, it says
> "valid_plane_number", but you test only invalid plane number.
The reason for this naming is that it tests the valid_plane_number()
function called by vkms_config_is_valid(). The applies for the other
valid_* tests.
However, I don't mind changing its name to so it reflects the test
rather than the tested function.
Changed in v2.
>
> Can you rename it to vkms_config_test_invalid_plane_number?
>
> [...]
>
> > diff --git a/drivers/gpu/drm/vkms/vkms_config.c b/drivers/gpu/drm/vkms/vkms_config.c
>
> [...]
>
> > +struct vkms_config_plane **vkms_config_get_planes(const struct vkms_config *config,
> > + size_t *out_length)
> > +{
> > + struct vkms_config_plane **array;
> > + struct vkms_config_plane *plane_cfg;
> > + size_t length;
> > + int n = 0;
> > +
> > + length = list_count_nodes((struct list_head *)&config->planes);
> > + if (length == 0) {
> > + *out_length = length;
> > + return NULL;
> > + }
> > +
> > + array = kmalloc_array(length, sizeof(*array), GFP_KERNEL);
> > + if (!array)
> > + return ERR_PTR(-ENOMEM);
> > +
> > + list_for_each_entry(plane_cfg, &config->planes, link) {
> > + array[n] = plane_cfg;
> > + n++;
> > + }
> > +
> > + *out_length = length;
> > + return array;
> > +}
>
> To join the comment on the test, I am not a big fan of creating a new list
> to return to the caller, for three reasons:
> - the caller needs to manage an other pointer;
> - the caller needs to understand that the content of the array is only
> valid if: the config is not freed, nobody else removed anything from the
> planes;
> - the caller may think this list always have the same order if he looks at
> the tests.
>
> I would prefer a simple macro to do an iteration over the config->planes
> list: (I did not test this macro, but you have this idea)
>
> #define vkms_config_iter_plane(config, plane_cfg) \
> list_for_each_entry((plane_cfg), &(config).planes, link)
>
> This way:
> - no new pointer to manage;
> - if one day we have concurency issue, we just have to protect config, not
> config+all the planes;
> - there is no expected order.
>
> [...]
>
> > bool vkms_config_is_valid(struct vkms_config *config)
> > {
> > + if (!valid_plane_number(config))
> > + return false;
> > +
> > + if (!valid_plane_type(config))
> > + return false;
> > +
> > return true;
> > }
>
> I really like the idea to split the validation function, way simpler!
>
> [...]
>
> > +void vkms_config_destroy_plane(struct vkms_config_plane *plane_cfg)
> > +{
> > + list_del(&plane_cfg->link);
> > + kfree(plane_cfg);
> > +}
>
> I would prefer a "standard" function pair, i.e.: add/remove or
> create/destroy, not add/destroy.
>
> For me it should be create/destroy, you create the plane by using a
> config, so it is clear it will be attached to it.
>
> If you choose add/remove, you should explains in the documentation that
> remove is also doing kfree.
>
> [...]
>
> > diff --git a/drivers/gpu/drm/vkms/vkms_output.c b/drivers/gpu/drm/vkms/vkms_output.c
>
> [...]
>
> > @@ -11,61 +11,63 @@ int vkms_output_init(struct vkms_device *vkmsdev)
> > struct vkms_connector *connector;
> > struct drm_encoder *encoder;
> > struct vkms_output *output;
> > - struct vkms_plane *primary, *overlay, *cursor = NULL;
> > - int ret;
> > + struct vkms_plane *primary = NULL, *cursor = NULL;
> > + struct vkms_config_plane **plane_cfgs = NULL;
> > + size_t n_planes;
> > + int ret = 0;
> > int writeback;
> > unsigned int n;
>
> I think it could be interesting to have a vkms_config_is_valid call here.
> It will avoid raising DRM errors or create unexpected devices.
>
> It will also garantee in a later patch that
> vkms_config_crtc_get_primary_plane is a valid pointer.
>
> > - /*
> > - * Initialize used plane. One primary plane is required to perform the composition.
> > - *
> > - * The overlay and cursor planes are not mandatory, but can be used to perform complex
> > - * composition.
> > - */
> > - primary = vkms_plane_init(vkmsdev, DRM_PLANE_TYPE_PRIMARY);
> > - if (IS_ERR(primary))
> > - return PTR_ERR(primary);
> > + plane_cfgs = vkms_config_get_planes(vkmsdev->config, &n_planes);
> > + if (IS_ERR(plane_cfgs))
> > + return PTR_ERR(plane_cfgs);
>
> If you agree on the iterator implementation, this code could be simplified
> a lot.
>
> > - if (vkmsdev->config->cursor) {
> > - cursor = vkms_plane_init(vkmsdev, DRM_PLANE_TYPE_CURSOR);
> > - if (IS_ERR(cursor))
> > - return PTR_ERR(cursor);
> > + for (n = 0; n < n_planes; n++) {
> > + struct vkms_config_plane *plane_cfg;
> > + enum drm_plane_type type;
> > +
> > + plane_cfg = plane_cfgs[n];
> > + type = vkms_config_plane_get_type(plane_cfg);
> > +
> > + plane_cfg->plane = vkms_plane_init(vkmsdev, type);
>
> Can we pass plane_cfg in vkms_plane_init? This way we don't have to
> touch vkms_output_init when adding new vkms_config_plane members.
While it'll be required once we allow to configure more parameters, I don't
think we need it right now. To keep things as simple as possible, I'd prefer to
delay it until required.
Thanks,
Jose
> > + if (IS_ERR(plane_cfg->plane)) {
> > + DRM_DEV_ERROR(dev->dev, "Failed to init vkms plane\n");
> > + ret = PTR_ERR(plane_cfg->plane);
> > + goto err_free;
> > + }
> > +
> > + if (type == DRM_PLANE_TYPE_PRIMARY)
> > + primary = plane_cfg->plane;
> > + else if (type == DRM_PLANE_TYPE_CURSOR)
> > + cursor = plane_cfg->plane;
> > }
>
> [...]
Le 11/02/2025 à 11:43, José Expósito a écrit :
> On Thu, Jan 30, 2025 at 02:48:19PM +0100, Louis Chauvet wrote:
>> On 29/01/25 - 12:00, José Expósito wrote:
>>> Add a list of planes to vkms_config and create as many planes as
>>> configured during output initialization.
>>>
>>> For backwards compatibility, add one primary plane and, if configured,
>>> one cursor plane and NUM_OVERLAY_PLANES planes to the default
>>> configuration.
>>>
>>> Signed-off-by: Louis Chauvet <louis.chauvet@bootlin.com>
>>> Signed-off-by: José Expósito <jose.exposito89@gmail.com>
>>
>> Co-developped-by: Louis Chauvet <louis.chauvet@bootlin.com>
>> Signed-off-by: Louis Chauvet <louis.chauvet@bootlin.com>
>> Signed-off-by: José Expósito <jose.exposito89@gmail.com>
>>
>> [...]
>>
>>> diff --git a/drivers/gpu/drm/vkms/tests/vkms_config_test.c b/drivers/gpu/drm/vkms/tests/vkms_config_test.c
>>
>> [...]
>>
>>> +static void vkms_config_test_get_planes(struct kunit *test)
>>> +{
>>> + struct vkms_config *config;
>>> + struct vkms_config_plane *plane_cfg1, *plane_cfg2;
>>> + struct vkms_config_plane **array;
>>> + size_t length;
>>> +
>>> + config = vkms_config_create("test");
>>> + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, config);
>>> +
>>> + array = vkms_config_get_planes(config, &length);
>>> + KUNIT_ASSERT_EQ(test, length, 0);
>>> + KUNIT_ASSERT_NULL(test, array);
>>> +
>>> + plane_cfg1 = vkms_config_add_plane(config);
>>> + array = vkms_config_get_planes(config, &length);
>>> + KUNIT_ASSERT_EQ(test, length, 1);
>>> + KUNIT_ASSERT_PTR_EQ(test, array[0], plane_cfg1);
>>> + kfree(array);
>>> +
>>> + plane_cfg2 = vkms_config_add_plane(config);
>>> + array = vkms_config_get_planes(config, &length);
>>> + KUNIT_ASSERT_EQ(test, length, 2);
>>> + KUNIT_ASSERT_PTR_EQ(test, array[0], plane_cfg1);
>>> + KUNIT_ASSERT_PTR_EQ(test, array[1], plane_cfg2);
>>> + kfree(array);
>>> +
>>> + vkms_config_destroy_plane(plane_cfg1);
>>> + array = vkms_config_get_planes(config, &length);
>>> + KUNIT_ASSERT_EQ(test, length, 1);
>>> + KUNIT_ASSERT_PTR_EQ(test, array[0], plane_cfg2);
>>> + kfree(array);
>>> +
>>> + vkms_config_destroy(config);
>>> +}
>>
>> In this test I have the feeling that vkms_config_get_planes always returns
>> a predictable order. It is maybe trivial here, but I would prefer to shows
>> that the order is not stable, for example:
>>
>> bool plane_cfg1_found = false;
>> bool plane_cfg2_found = false;
>>
>> vkms_config_for_each_plane(config, plane_cfg) {
>> if (plane_cfg == plane_cfg1)
>> plane_cfg1_found = true;
>> else if (plane_cfg == plane_cfg2)
>> plane_cfg2_found = true;
>> else
>> KUNIT_FAILS("Unexpected plane");
>> }
>>
>> KUNIT_ASSERT(test, plane_cfg1_found);
>> KUNIT_ASSERT(test, plane_cfg2_found);
>>
>> [...]
>>
>>> +static void vkms_config_test_valid_plane_number(struct kunit *test)
>>> +{
>>> + struct vkms_config *config;
>>> + struct vkms_config_plane *plane_cfg;
>>> + int n;
>>> +
>>> + config = vkms_config_default_create(false, false, false);
>>> + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, config);
>>> +
>>> + /* Invalid: No planes */
>>> + plane_cfg = list_first_entry(&config->planes, typeof(*plane_cfg), link);
>>> + vkms_config_destroy_plane(plane_cfg);
>>> + KUNIT_EXPECT_FALSE(test, vkms_config_is_valid(config));
>>> +
>>> + /* Invalid: Too many planes */
>>> + for (n = 0; n <= 32; n++)
>>> + vkms_config_add_plane(config);
>>> +
>>> + KUNIT_EXPECT_FALSE(test, vkms_config_is_valid(config));
>>> +
>>> + vkms_config_destroy(config);
>>> +}
>>
>> For this function, the naming is a bit strange, it says
>> "valid_plane_number", but you test only invalid plane number.
>
> The reason for this naming is that it tests the valid_plane_number()
> function called by vkms_config_is_valid(). The applies for the other
> valid_* tests.
Hoo, I see, okk!
> However, I don't mind changing its name to so it reflects the test
> rather than the tested function.
I prefer an "implementation independent" name, as the content of
vkms_config_is_valid may change over time.
> Changed in v2.
Perfect!
>>
>> Can you rename it to vkms_config_test_invalid_plane_number?
>>
>> [...]
>>
>>> diff --git a/drivers/gpu/drm/vkms/vkms_config.c b/drivers/gpu/drm/vkms/vkms_config.c
>>
>> [...]
>>
>>> +struct vkms_config_plane **vkms_config_get_planes(const struct vkms_config *config,
>>> + size_t *out_length)
>>> +{
>>> + struct vkms_config_plane **array;
>>> + struct vkms_config_plane *plane_cfg;
>>> + size_t length;
>>> + int n = 0;
>>> +
>>> + length = list_count_nodes((struct list_head *)&config->planes);
>>> + if (length == 0) {
>>> + *out_length = length;
>>> + return NULL;
>>> + }
>>> +
>>> + array = kmalloc_array(length, sizeof(*array), GFP_KERNEL);
>>> + if (!array)
>>> + return ERR_PTR(-ENOMEM);
>>> +
>>> + list_for_each_entry(plane_cfg, &config->planes, link) {
>>> + array[n] = plane_cfg;
>>> + n++;
>>> + }
>>> +
>>> + *out_length = length;
>>> + return array;
>>> +}
>>
>> To join the comment on the test, I am not a big fan of creating a new list
>> to return to the caller, for three reasons:
>> - the caller needs to manage an other pointer;
>> - the caller needs to understand that the content of the array is only
>> valid if: the config is not freed, nobody else removed anything from the
>> planes;
>> - the caller may think this list always have the same order if he looks at
>> the tests.
>>
>> I would prefer a simple macro to do an iteration over the config->planes
>> list: (I did not test this macro, but you have this idea)
>>
>> #define vkms_config_iter_plane(config, plane_cfg) \
>> list_for_each_entry((plane_cfg), &(config).planes, link)
>>
>> This way:
>> - no new pointer to manage;
>> - if one day we have concurency issue, we just have to protect config, not
>> config+all the planes;
>> - there is no expected order.
>>
>> [...]
>>
>>> bool vkms_config_is_valid(struct vkms_config *config)
>>> {
>>> + if (!valid_plane_number(config))
>>> + return false;
>>> +
>>> + if (!valid_plane_type(config))
>>> + return false;
>>> +
>>> return true;
>>> }
>>
>> I really like the idea to split the validation function, way simpler!
>>
>> [...]
>>
>>> +void vkms_config_destroy_plane(struct vkms_config_plane *plane_cfg)
>>> +{
>>> + list_del(&plane_cfg->link);
>>> + kfree(plane_cfg);
>>> +}
>>
>> I would prefer a "standard" function pair, i.e.: add/remove or
>> create/destroy, not add/destroy.
>>
>> For me it should be create/destroy, you create the plane by using a
>> config, so it is clear it will be attached to it.
>>
>> If you choose add/remove, you should explains in the documentation that
>> remove is also doing kfree.
>>
>> [...]
>>
>>> diff --git a/drivers/gpu/drm/vkms/vkms_output.c b/drivers/gpu/drm/vkms/vkms_output.c
>>
>> [...]
>>
>>> @@ -11,61 +11,63 @@ int vkms_output_init(struct vkms_device *vkmsdev)
>>> struct vkms_connector *connector;
>>> struct drm_encoder *encoder;
>>> struct vkms_output *output;
>>> - struct vkms_plane *primary, *overlay, *cursor = NULL;
>>> - int ret;
>>> + struct vkms_plane *primary = NULL, *cursor = NULL;
>>> + struct vkms_config_plane **plane_cfgs = NULL;
>>> + size_t n_planes;
>>> + int ret = 0;
>>> int writeback;
>>> unsigned int n;
>>
>> I think it could be interesting to have a vkms_config_is_valid call here.
>> It will avoid raising DRM errors or create unexpected devices.
>>
>> It will also garantee in a later patch that
>> vkms_config_crtc_get_primary_plane is a valid pointer.
>>
>>> - /*
>>> - * Initialize used plane. One primary plane is required to perform the composition.
>>> - *
>>> - * The overlay and cursor planes are not mandatory, but can be used to perform complex
>>> - * composition.
>>> - */
>>> - primary = vkms_plane_init(vkmsdev, DRM_PLANE_TYPE_PRIMARY);
>>> - if (IS_ERR(primary))
>>> - return PTR_ERR(primary);
>>> + plane_cfgs = vkms_config_get_planes(vkmsdev->config, &n_planes);
>>> + if (IS_ERR(plane_cfgs))
>>> + return PTR_ERR(plane_cfgs);
>>
>> If you agree on the iterator implementation, this code could be simplified
>> a lot.
>>
>>> - if (vkmsdev->config->cursor) {
>>> - cursor = vkms_plane_init(vkmsdev, DRM_PLANE_TYPE_CURSOR);
>>> - if (IS_ERR(cursor))
>>> - return PTR_ERR(cursor);
>>> + for (n = 0; n < n_planes; n++) {
>>> + struct vkms_config_plane *plane_cfg;
>>> + enum drm_plane_type type;
>>> +
>>> + plane_cfg = plane_cfgs[n];
>>> + type = vkms_config_plane_get_type(plane_cfg);
>>> +
>>> + plane_cfg->plane = vkms_plane_init(vkmsdev, type);
>>
>> Can we pass plane_cfg in vkms_plane_init? This way we don't have to
>> touch vkms_output_init when adding new vkms_config_plane members.
>
> While it'll be required once we allow to configure more parameters, I don't
> think we need it right now. To keep things as simple as possible, I'd prefer to
> delay it until required.
I understand your point, especially since your patch don't add new
parameters to vkms_plane_init.
Thanks!
> Thanks,
> Jose
>
>>> + if (IS_ERR(plane_cfg->plane)) {
>>> + DRM_DEV_ERROR(dev->dev, "Failed to init vkms plane\n");
>>> + ret = PTR_ERR(plane_cfg->plane);
>>> + goto err_free;
>>> + }
>>> +
>>> + if (type == DRM_PLANE_TYPE_PRIMARY)
>>> + primary = plane_cfg->plane;
>>> + else if (type == DRM_PLANE_TYPE_CURSOR)
>>> + cursor = plane_cfg->plane;
>>> }
>>
>> [...]
--
Louis Chauvet, Bootlin
Embedded Linux and Kernel engineering
https://bootlin.com
© 2016 - 2026 Red Hat, Inc.