From nobody Mon Feb 9 16:45:49 2026 Received: from mail-wr1-f52.google.com (mail-wr1-f52.google.com [209.85.221.52]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id A49CC1D90D7 for ; Wed, 29 Jan 2025 11:01:15 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.221.52 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1738148478; cv=none; b=GxeiShcFe2/YsizUOhPWXC+z4ozg/D4noOfES2Fcxm0jUiY9/DVeXsdqlYsCuQt/qKf9I6WY3iWI/rvp9oyJ+qgSMWgBg+xHHAlTT+8ZAxuADGMbl4O2Algo3HXFCeXpvNBgpO2UmnTkLKy7HEG+nM7LLY4G2WHeJCxgBwsjtwc= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1738148478; c=relaxed/simple; bh=M94wVIQzNE/XQ6qK4XXtXGje4JwIlwziNCm0Q4og/yM=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=PyhtzSKdc02Z0gwV5QAfInM5TRAWuOFig3odyD4Gdaf0u0gMyrK+47I1devdHfyOXwI48yVoUisfay8bXBHbDhPzsFiSnsm4OsrdxYNFeJr0l9ldP4KNa7eQD3k5H9tz6iTDsGU895lfLMSL7a3LBV/l9VQTnQ42tsM0keCE9rA= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=S7JxHliG; arc=none smtp.client-ip=209.85.221.52 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="S7JxHliG" Received: by mail-wr1-f52.google.com with SMTP id ffacd0b85a97d-3862a921123so4543996f8f.3 for ; Wed, 29 Jan 2025 03:01:15 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1738148474; x=1738753274; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=vojZaZ8F+NK/iPnjUpn4N9qYryOnpEU70w91WMVOaic=; b=S7JxHliGRRqDKTKsIei/axg+ownLhZxnU4XSKyu6J+uvtv+7mU+ewLqEHgN/MxHsOg CmKwFYJeLnditzxQu8cZeqTKzMeXyHFpPN2bKZc5sQQOIS5mfD/NMyRJ8UPa5QPFp46Y 01NFPxkjdfSraKdTt+gCjAEmr1eP/xFlOEe9Kp21+4gC9WQhyHsAbyXerlLrsgBc/o3l UHdUt12/h60Niya8PZm8B81VwlQyhYxxyYFZ7xx/7Mvc4azhEM+kXPkN7hcM4gJp5hms 2sSz+s4TgaoKYSMAoEb6yRlR7x4ZFkedn2HbAuHZGauheTLrs0TGvwAGH4NoC0mngk4V xQ/A== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1738148474; x=1738753274; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=vojZaZ8F+NK/iPnjUpn4N9qYryOnpEU70w91WMVOaic=; b=j1UlIa032YoPUARVlgLRmQbqX3qv+yhg/bkk+GYNe9riy7pLng0Zs1cmnlfIMCKtnW ELOz7LicIA4SXoRTe2uPhbMDtATS5YGXFKudOj6HiRwYc2hNbZnoQM2dqjPirH5Wo9aN bJXAUkOb1qsEsu2exl3lI9XjURcznqnLiN20rpvJ0h8yNqSbQEO3WGlx9ENIipfEt3ar ciObmSatBcPte3QhahZd8LBcqeFQ+R1jbm+YDRVsjFiqvY8nhzE40oWTW2z+nHWhhIjR qNqnEQrklD2c7FDSnmkvXTRpIgolFPJCKWlMPLPBQ9z3m6+At+ChCjKaPQ/Jm9TvRT+7 uuzw== X-Forwarded-Encrypted: i=1; AJvYcCUDijlllOk2ZOQ9Vrwe5urQfxa7ErHHGBkUys7XHnC28hkx3WGqCN8dGAq+Nnhcz+F4rduFQSBCQ4i5NAA=@vger.kernel.org X-Gm-Message-State: AOJu0YxePaMcaqvsBbbvOajqMR4XH+M4+s6Y3pXHIpNV81axPZxjIyOD ltjzdNUnLEaQ/LlxKlAcARngBX0PwrmwbL+CLwizIr7ItmlNu3uM X-Gm-Gg: ASbGncvEdz25C1pxfalyFUANbSg/rmlCS9dx73yZygUWrHH2nFfduSOW4z1Xe7a4C6U R/hj2cP+Otonny6lrEij1RFh+cN7bb+pH4qDIBggIMhKV+mK2LoAw4hia3a2yeHUzCu/iaEPKAU 9HMc2HhyAgq19aQtSwAqQb6LldmoRmow0YEiF8f6AVXWIyZ3RPTEc3qj5slEr4L3k4btJtBabDv jiq/RAUQmtf0QEPAUe/udAbsHc7TPdAQ0wxQstdrNLzwAEQX6hv1bqyS4PahM99CASVc2N7P+YU xcbRwxxzeL9FGtI6 X-Google-Smtp-Source: AGHT+IGlv8nmLgUmiKojqFWxzvaUL7Lfp9PLXTfmvbPvfCDgXUEhyDos5aI69wAbNCN9hEyXOrofYw== X-Received: by 2002:a5d:6c66:0:b0:38b:d7d2:12f6 with SMTP id ffacd0b85a97d-38c51932163mr2081326f8f.2.1738148473606; Wed, 29 Jan 2025 03:01:13 -0800 (PST) Received: from fedora.. ([94.73.37.161]) by smtp.gmail.com with ESMTPSA id ffacd0b85a97d-38c2a176434sm16947113f8f.13.2025.01.29.03.01.12 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 29 Jan 2025 03:01:12 -0800 (PST) From: =?UTF-8?q?Jos=C3=A9=20Exp=C3=B3sito?= To: louis.chauvet@bootlin.com Cc: hamohammed.sa@gmail.com, simona@ffwll.ch, melissa.srw@gmail.com, maarten.lankhorst@linux.intel.com, mripard@kernel.org, tzimmermann@suse.de, airlied@gmail.com, dri-devel@lists.freedesktop.org, linux-kernel@vger.kernel.org, =?UTF-8?q?Jos=C3=A9=20Exp=C3=B3sito?= Subject: [PATCH 07/13] drm/vkms: Allow to configure multiple planes Date: Wed, 29 Jan 2025 12:00:53 +0100 Message-ID: <20250129110059.12199-8-jose.exposito89@gmail.com> X-Mailer: git-send-email 2.48.1 In-Reply-To: <20250129110059.12199-1-jose.exposito89@gmail.com> References: <20250129110059.12199-1-jose.exposito89@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable 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 Signed-off-by: Jos=C3=A9 Exp=C3=B3sito --- 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/dr= m/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 =3D NULL; KUNIT_EXPECT_STREQ(test, vkms_config_get_device_name(config), "test"); =20 + KUNIT_EXPECT_TRUE(test, list_empty(&config->planes)); + + KUNIT_EXPECT_FALSE(test, vkms_config_is_valid(config)); + vkms_config_destroy(config); } =20 @@ -44,16 +48,138 @@ static void vkms_config_test_default_config(struct kun= it *test) { const struct default_config_case *params =3D test->param_value; struct vkms_config *config; + struct vkms_config_plane *plane_cfg; + int n_primaries =3D 0; + int n_cursors =3D 0; + int n_overlays =3D 0; =20 config =3D vkms_config_default_create(params->enable_cursor, params->enable_writeback, params->enable_overlay); KUNIT_ASSERT_NOT_ERR_OR_NULL(test, config); =20 - 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); =20 + /* 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 =3D vkms_config_create("test"); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, config); + + array =3D vkms_config_get_planes(config, &length); + KUNIT_ASSERT_EQ(test, length, 0); + KUNIT_ASSERT_NULL(test, array); + + plane_cfg1 =3D vkms_config_add_plane(config); + array =3D 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 =3D vkms_config_add_plane(config); + array =3D 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 =3D 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 =3D vkms_config_default_create(false, false, false); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, config); + + /* Invalid: No planes */ + plane_cfg =3D 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 =3D 0; n <=3D 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 =3D vkms_config_default_create(false, false, false); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, config); + + plane_cfg =3D list_first_entry(&config->planes, typeof(*plane_cfg), link); + vkms_config_destroy_plane(plane_cfg); + + /* Invalid: No primary plane */ + plane_cfg =3D 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 =3D vkms_config_add_plane(config); + vkms_config_plane_set_type(plane_cfg, DRM_PLANE_TYPE_PRIMARY); + plane_cfg =3D 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 =3D vkms_config_add_plane(config); + vkms_config_plane_set_type(plane_cfg, DRM_PLANE_TYPE_CURSOR); + plane_cfg =3D 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)); =20 vkms_config_destroy(config); @@ -63,6 +189,9 @@ static struct kunit_case vkms_config_test_cases[] =3D { 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), {} }; =20 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_na= me) return ERR_PTR(-ENOMEM); } =20 + INIT_LIST_HEAD(&config->planes); + return config; } =20 @@ -29,26 +31,139 @@ struct vkms_config *vkms_config_default_create(bool en= able_cursor, bool enable_overlay) { struct vkms_config *config; + struct vkms_config_plane *plane_cfg; + int n; =20 config =3D vkms_config_create(DEFAULT_DEVICE_NAME); if (IS_ERR(config)) return config; =20 - config->cursor =3D enable_cursor; config->writeback =3D enable_writeback; - config->overlay =3D enable_overlay; + + plane_cfg =3D 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 =3D 0; n < NUM_OVERLAY_PLANES; n++) { + plane_cfg =3D 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 =3D vkms_config_add_plane(config); + if (IS_ERR(plane_cfg)) + goto err_alloc; + vkms_config_plane_set_type(plane_cfg, DRM_PLANE_TYPE_CURSOR); + } =20 return config; + +err_alloc: + vkms_config_destroy(config); + return ERR_PTR(-ENOMEM); } =20 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); } =20 +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 =3D 0; + + length =3D list_count_nodes((struct list_head *)&config->planes); + if (length =3D=3D 0) { + *out_length =3D length; + return NULL; + } + + array =3D kmalloc_array(length, sizeof(*array), GFP_KERNEL); + if (!array) + return ERR_PTR(-ENOMEM); + + list_for_each_entry(plane_cfg, &config->planes, link) { + array[n] =3D plane_cfg; + n++; + } + + *out_length =3D length; + return array; +} + +static bool valid_plane_number(struct vkms_config *config) +{ + size_t n_planes; + + n_planes =3D list_count_nodes(&config->planes); + if (n_planes <=3D 0 || n_planes >=3D 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 =3D false; + bool has_cursor_plane =3D false; + + list_for_each_entry(plane_cfg, &config->planes, link) { + enum drm_plane_type type; + + type =3D vkms_config_plane_get_type(plane_cfg); + + if (type =3D=3D DRM_PLANE_TYPE_PRIMARY) { + if (has_primary_plane) { + pr_err("Multiple primary planes\n"); + return false; + } + + has_primary_plane =3D true; + } else if (type =3D=3D DRM_PLANE_TYPE_CURSOR) { + if (has_cursor_plane) { + pr_err("Multiple cursor planes\n"); + return false; + } + + has_cursor_plane =3D 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; } =20 @@ -58,12 +173,17 @@ static int vkms_config_show(struct seq_file *m, void *= data) struct drm_device *dev =3D entry->dev; struct vkms_device *vkmsdev =3D drm_device_to_vkms_device(dev); const char *dev_name; + struct vkms_config_plane *plane_cfg; =20 dev_name =3D vkms_config_get_device_name((struct vkms_config *)vkmsdev->c= onfig); seq_printf(m, "dev_name=3D%s\n", dev_name); seq_printf(m, "writeback=3D%d\n", vkmsdev->config->writeback); - seq_printf(m, "cursor=3D%d\n", vkmsdev->config->cursor); - seq_printf(m, "overlay=3D%d\n", vkmsdev->config->overlay); + + list_for_each_entry(plane_cfg, &vkmsdev->config->planes, link) { + seq_puts(m, "plane:\n"); + seq_printf(m, "\ttype=3D%d\n", + vkms_config_plane_get_type(plane_cfg)); + } =20 return 0; } @@ -77,3 +197,24 @@ void vkms_config_register_debugfs(struct vkms_device *v= kms_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 =3D 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_ =20 +#include #include =20 #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 devi= ce + * @planes: List of planes configured for the device * @dev: Used to store the current VKMS device. Only set when the device i= s instantiated. */ struct vkms_config { const char *dev_name; bool writeback; - bool cursor; - bool overlay; + struct list_head planes; struct vkms_device *dev; }; =20 +/** + * 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 vali= d. + * It can be used to store a temporary reference to a VKMS plane d= uring + * device creation. This pointer is not managed by the configurati= on 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; } =20 +/** + * 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); =20 +/** + * 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 =3D 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 =3D NULL; - int ret; + struct vkms_plane *primary =3D NULL, *cursor =3D NULL; + struct vkms_config_plane **plane_cfgs =3D NULL; + size_t n_planes; + int ret =3D 0; int writeback; unsigned int n; =20 - /* - * Initialize used plane. One primary plane is required to perform the co= mposition. - * - * The overlay and cursor planes are not mandatory, but can be used to pe= rform complex - * composition. - */ - primary =3D vkms_plane_init(vkmsdev, DRM_PLANE_TYPE_PRIMARY); - if (IS_ERR(primary)) - return PTR_ERR(primary); + plane_cfgs =3D vkms_config_get_planes(vkmsdev->config, &n_planes); + if (IS_ERR(plane_cfgs)) + return PTR_ERR(plane_cfgs); =20 - if (vkmsdev->config->cursor) { - cursor =3D vkms_plane_init(vkmsdev, DRM_PLANE_TYPE_CURSOR); - if (IS_ERR(cursor)) - return PTR_ERR(cursor); + for (n =3D 0; n < n_planes; n++) { + struct vkms_config_plane *plane_cfg; + enum drm_plane_type type; + + plane_cfg =3D plane_cfgs[n]; + type =3D vkms_config_plane_get_type(plane_cfg); + + plane_cfg->plane =3D vkms_plane_init(vkmsdev, type); + if (IS_ERR(plane_cfg->plane)) { + DRM_DEV_ERROR(dev->dev, "Failed to init vkms plane\n"); + ret =3D PTR_ERR(plane_cfg->plane); + goto err_free; + } + + if (type =3D=3D DRM_PLANE_TYPE_PRIMARY) + primary =3D plane_cfg->plane; + else if (type =3D=3D DRM_PLANE_TYPE_CURSOR) + cursor =3D plane_cfg->plane; } =20 output =3D 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 =3D 0; n < NUM_OVERLAY_PLANES; n++) { - overlay =3D 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 =3D drm_crtc_mask(&output->crtc); - } + ret =3D PTR_ERR(output); + goto err_free; } =20 connector =3D vkms_connector_init(vkmsdev); if (IS_ERR(connector)) { DRM_ERROR("Failed to init connector\n"); - return PTR_ERR(connector); + ret =3D PTR_ERR(connector); + goto err_free; } =20 encoder =3D drmm_kzalloc(dev, sizeof(*encoder), GFP_KERNEL); if (!encoder) { DRM_ERROR("Failed to allocate encoder\n"); - return -ENOMEM; + ret =3D -ENOMEM; + goto err_free; } ret =3D 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 =3D drm_crtc_mask(&output->crtc); =20 @@ -73,7 +75,7 @@ int vkms_output_init(struct vkms_device *vkmsdev) ret =3D drm_connector_attach_encoder(&connector->base, encoder); if (ret) { DRM_ERROR("Failed to attach connector to encoder\n"); - return ret; + goto err_free; } =20 /* Initialize the writeback component */ @@ -85,5 +87,8 @@ int vkms_output_init(struct vkms_device *vkmsdev) =20 drm_mode_config_reset(dev); =20 +err_free: + kfree(plane_cfgs); + return ret; } --=20 2.48.1