Hi, Sam
Thank you for looking at the details.
I will fix it according to your comment.
Best regards
Tomohito Esaki
On 2021/06/22 0:55, Sam Ravnborg wrote:
> Hi Tomohito
>
> On Mon, Jun 21, 2021 at 03:44:00PM +0900, Tomohito Esaki wrote:
>> Virtual DRM splits the resources of an overlay plane into multiple
>> virtual devices to allow each plane to be accessed by each process.
>>
>> This makes it possible to overlay images output from multiple processes
>> on a display. For example, one process displays the camera image without
>> compositor while another process overlays the compositor's drawing of
>> the UI.
>>
>> The virtual DRM creates standalone virtual device and make DRM planes
>> from a master device (e.g. card0) accessible via one or more virtual
>> devices. However, these plane are no longer accessible from the original
>> device.
>> Each virtual device (and plane) can be accessed via a separate
>> device file.
>>
>> Signed-off-by: Tomohito Esaki <etom@xxxxxxxxxx>
>> ---
>> drivers/gpu/drm/Kconfig | 7 +
>> drivers/gpu/drm/Makefile | 1 +
>> drivers/gpu/drm/vdrm/vdrm_api.h | 68 +++
>> drivers/gpu/drm/vdrm/vdrm_drv.c | 859 ++++++++++++++++++++++++++++++++
>> drivers/gpu/drm/vdrm/vdrm_drv.h | 80 +++
>
> Plase consider making the header files self-contained.
> So there are no hdden dependencies between the two.
>
> Use forward declarations rahter than including header files is possible.
>
> A few trivial comments in the following. I did not try to follow all the
> functionality of the driver and I expect others to comment on the idea.
>
> Sam
>
>> 5 files changed, 1015 insertions(+)
>> create mode 100644 drivers/gpu/drm/vdrm/vdrm_api.h
>> create mode 100644 drivers/gpu/drm/vdrm/vdrm_drv.c
>> create mode 100644 drivers/gpu/drm/vdrm/vdrm_drv.h
>>
>> diff --git a/drivers/gpu/drm/Kconfig b/drivers/gpu/drm/Kconfig
>> index 3c16bd1afd87..ba7f4eeab385 100644
>> --- a/drivers/gpu/drm/Kconfig
>> +++ b/drivers/gpu/drm/Kconfig
>> @@ -294,6 +294,13 @@ config DRM_VKMS
>>
>> If M is selected the module will be called vkms.
>>
>> +config DRM_VDRM
>> + tristate "Virtual DRM"
>> + depends on DRM
>> + help
>> + Virtual DRM splits the resources of an overlay plane into multiple
>> + virtual devices to allow each plane to be accessed by each process.
> Could you look into pulling a bit more info here. You made a very nice
> intro to the patch, consider using it in the help text too.
>
>
>> +
>> source "drivers/gpu/drm/exynos/Kconfig"
>>
>> source "drivers/gpu/drm/rockchip/Kconfig"
>> diff --git a/drivers/gpu/drm/Makefile b/drivers/gpu/drm/Makefile
>> index 5279db4392df..55dbf85e2579 100644
>> --- a/drivers/gpu/drm/Makefile
>> +++ b/drivers/gpu/drm/Makefile
>> @@ -82,6 +82,7 @@ obj-$(CONFIG_DRM_VMWGFX)+= vmwgfx/
>> obj-$(CONFIG_DRM_VIA) +=via/
>> obj-$(CONFIG_DRM_VGEM) += vgem/
>> obj-$(CONFIG_DRM_VKMS) += vkms/
>> +obj-$(CONFIG_DRM_VDRM) += vdrm/
> Alphabetic order (mostly) so before vgem/
>
>> obj-$(CONFIG_DRM_NOUVEAU) +=nouveau/
>> obj-$(CONFIG_DRM_EXYNOS) +=exynos/
>> obj-$(CONFIG_DRM_ROCKCHIP) +=rockchip/
>> diff --git a/drivers/gpu/drm/vdrm/vdrm_api.h b/drivers/gpu/drm/vdrm/vdrm_api.h
>> new file mode 100644
>> index 000000000000..dd4d7e774800
>> --- /dev/null
>> +++ b/drivers/gpu/drm/vdrm/vdrm_api.h
>> @@ -0,0 +1,68 @@
>> +/* SPDX-License-Identifier: GPL-2.0+ */
>> +/*
>> + * vdrm_api.h -- Virtual DRM API
>> + *
>> + * Copyright (C) 2021 Renesas Electronics Corporation
>> + */
>> +
>> +#ifndef __VDRM_API__
>> +#define __VDRM_API__
>> +
>> +#include <linux/of_device.h>
>> +#include <drm/drm_crtc.h>
>> +
>> +/**
>> + * struct vdrm_property_info - Information about the properties passed from
>> + * the DRM driver to vDRM
>> + * @prop: Parent property to pass to vDRM
>> + * @default_val: Default value for the property passed to vDRM
>> + */
>> +struct vdrm_property_info {
>> + struct drm_property *prop;
>> + uint64_t default_val;
>> +};
> It would be nice that all structs used inline comments - and then you
> are consistent too.
>
>> +
>> +/**
>> + * struct vdrm_funcs - Callbacks to parent DRM driver
>> + */
>> +struct vdrm_funcs {
>> + /**
>> + * @dumb_create:
>> + *
>> + * Called by &drm_driver.dumb_create. Please read the documentation
>> + * for the &drm_driver.dumb_create hook for more details.
>> + */
>> + int (*dumb_create)(struct drm_file *file, struct drm_device *dev,
>> + struct drm_mode_create_dumb *args);
>> +
>> + /**
>> + * @crtc_flush:
>> + *
>> + * Called by &drm_crtc_helper_funcs.atomic_flush. Please read the
>> + * documentation for the &drm_crtc_helper_funcs.atomic_flush hook for
>> + * more details.
>> + */
>> + void (*crtc_flush)(struct drm_crtc *crtc);
>> +};
>> +
>> +struct vdrm_device;
>> +struct vdrm_display;
>> +
>> +void vdrm_drv_handle_vblank(struct vdrm_display *vdisplay);
>> +void vdrm_drv_finish_page_flip(struct vdrm_display *vdisplay);
>> +struct vdrm_device *vdrm_drv_init(struct drm_device *dev,
>> + struct device_node *np, int num_props,
>> + struct vdrm_property_info *props,
>> + const struct vdrm_funcs *funcs);
>> +int vdrm_drv_plane_init(struct vdrm_device *vdrm, struct drm_plane *plane,
>> + const struct drm_plane_funcs *funcs,
>> + const struct drm_plane_helper_funcs *helper_funcs,
>> + const u32 *formats, unsigned int num_formats,
>> + int max_zpos);
>> +struct vdrm_display *vdrm_drv_display_init(struct vdrm_device *vdrm,
>> + struct drm_crtc *crtc,
>> + struct drm_plane *plane);
>> +int vdrm_drv_register(struct vdrm_device *vdrm);
>> +void vdrm_drv_fini(struct vdrm_device *vdrm);
>> +
>> +#endif /* __VDRM_API__ */
>> diff --git a/drivers/gpu/drm/vdrm/vdrm_drv.c b/drivers/gpu/drm/vdrm/vdrm_drv.c
>> new file mode 100644
>> index 000000000000..835bdecfc8e6
>> --- /dev/null
>> +++ b/drivers/gpu/drm/vdrm/vdrm_drv.c
>> @@ -0,0 +1,859 @@
>> +// SPDX-License-Identifier: GPL-2.0+
>> +/*
>> + * vdrm_drv.c -- Virtual DRM driver
>> + *
>> + * Copyright (C) 2021 Renesas Electronics Corporation
>> + *
>> + * This driver is based on drivers/gpu/drm/drm_simple_kms_helper.c.
>> + */
>> +
>> +#include <linux/of_device.h>
>> +#include <drm/drm_atomic.h>
>> +#include <drm/drm_atomic_helper.h>
>> +#include <drm/drm_atomic_uapi.h>
>> +#include <drm/drm_fb_cma_helper.h>
>> +#include <drm/drm_fb_helper.h>
>> +#include <drm/drm_drv.h>
>> +#include <drm/drm_gem_cma_helper.h>
>> +#include <drm/drm_plane_helper.h>
>> +#include <drm/drm_probe_helper.h>
>> +#include <drm/drm_vblank.h>
>> +#include <drm/drm_gem_framebuffer_helper.h>
>> +#include <video/videomode.h>
>> +
>> +#include "vdrm_drv.h"
>> +
>> +static inline struct vdrm_display *
>> +to_vdrm_display(struct drm_connector *connector)
>> +{
>> + return container_of(connector, struct vdrm_display, connector);
>> +}
>> +
>> +static inline struct vdrm_display *
>> +crtc_to_vdrm_display(struct drm_crtc *crtc)
>> +{
>> + return container_of(crtc, struct vdrm_display, crtc);
>> +}
>> +
>> +static int vdrm_dumb_create(struct drm_file *file, struct drm_device *dev,
>> + struct drm_mode_create_dumb *args)
>> +{
>> + struct vdrm_device *vdrm = to_vdrm_device(dev);
>> +
>> + return vdrm->funcs->dumb_create(file, dev, args);
>> +}
>> +
>> +struct vdrm_framebuffer {
>> + struct drm_framebuffer fb;
>> + struct drm_framebuffer *parent_fb;
>> +};
>> +
>> +static inline struct vdrm_framebuffer *
>> +to_vdrm_framebuffer(struct drm_framebuffer *fb)
>> +{
>> + return container_of(fb, struct vdrm_framebuffer, fb);
>> +}
>> +
>> +static void vdrm_fb_destroy(struct drm_framebuffer *fb)
>> +{
>> + struct vdrm_framebuffer *vfb = to_vdrm_framebuffer(fb);
>> +
>> + vfb->parent_fb->funcs->destroy(vfb->parent_fb);
>> + drm_framebuffer_cleanup(fb);
>> + kfree(vfb);
>> +}
>> +
>> +static const struct drm_framebuffer_funcs vdrm_fb_funcs = {
>> + .destroy = vdrm_fb_destroy,
>> +};
>> +
>> +static int vdrm_fb_init(struct drm_device *dev, struct vdrm_framebuffer *vfb)
>> +{
>> + vfb->fb = *vfb->parent_fb;
>> + vfb->fb.dev = dev;
>> +
>> + return drm_framebuffer_init(dev, &vfb->fb, &vdrm_fb_funcs);
>> +}
>> +
>> +static struct drm_framebuffer *
>> +vdrm_fb_create(struct drm_device *dev, struct drm_file *file_priv,
>> + const struct drm_mode_fb_cmd2 *mode_cmd)
>> +{
>> + struct vdrm_device *vdrm = to_vdrm_device(dev);
>> + const struct drm_mode_config_funcs *mode_config_funcs =
>> + vdrm->parent->mode_config.funcs;
>> + struct vdrm_framebuffer *vfb;
>> + struct drm_framebuffer *fb;
>> + int ret;
>> +
>> + vfb = kzalloc(sizeof(*vfb), GFP_KERNEL);
>> + if (!vfb)
>> + return ERR_PTR(-ENOMEM);
>> +
>> + fb = mode_config_funcs->fb_create(vdrm->parent, file_priv, mode_cmd);
>> + if (IS_ERR(fb)) {
>> + kfree(vfb);
>> + return fb;
>> + }
>> +
>> + vfb->parent_fb = fb;
>> + ret = vdrm_fb_init(dev, vfb);
>> + if (ret) {
>> + fb->funcs->destroy(fb);
>> + kfree(vfb);
>> + return ERR_PTR(ret);
>> + }
>> +
>> + return &vfb->fb;
>> +}
>> +
>> +static const struct drm_mode_config_funcs vdrm_mode_config_funcs = {
>> + .fb_create = vdrm_fb_create,
>> + .atomic_check = drm_atomic_helper_check,
>> + .atomic_commit = drm_atomic_helper_commit,
>> +};
>> +
>> +static struct drm_display_mode *vdrm_create_mode(struct vdrm_display *disp)
>> +{
>> + struct drm_display_mode *mode;
>> + struct videomode videomode;
>> +
>> + mode = drm_mode_create(&disp->dev->ddev);
>> + if (!mode)
>> + return NULL;
>> +
>> + memset(&videomode, 0, sizeof(videomode));
>> + videomode.hactive = disp->plane_info.width;
>> + videomode.vactive = disp->plane_info.height;
>> + videomode.pixelclock =
>> + disp->parent_crtc->state->adjusted_mode.crtc_clock * 1000;
>> + mode->type = DRM_MODE_TYPE_PREFERRED | DRM_MODE_TYPE_DRIVER;
>> + drm_display_mode_from_videomode(&videomode, mode);
>> +
> If you create a drm_display_mode here then you can loose the videomode
> dependency. And I do not need to tell you that a Kconfig dependency is missing
> to use videomode. Do not forget to drop the include.
>
>
>> + return mode;
>> +}
>> +
>> +static int vdrm_connector_get_mode(struct drm_connector *connector)
>> +{
>> + struct vdrm_display *disp = to_vdrm_display(connector);
>> + struct drm_display_mode *mode = vdrm_create_mode(disp);
>> +
>> + if (!mode)
>> + return 0;
>> +
>> + drm_mode_probed_add(connector, mode);
>> + return 1;
>> +}
>> +
>> +static const struct drm_connector_helper_funcs vdrm_conn_helper_funcs = {
>> + .get_modes = vdrm_connector_get_mode,
>> +};
>> +
>> +/*
>> + * TODO:
>> + * At the time this callback is called, the parent CRTC must be connected.
>> + * Since this callback will not be called when detect() callback of the
>> + * parent connector is called, vDRM driver desn't support hotplug.
>> + * In the future, it is necessary that hotplug is supported.
>> + */
>> +static enum drm_connector_status
>> +vdrm_connector_detect(struct drm_connector *connector, bool force)
>> +{
>> + struct vdrm_display *disp = to_vdrm_display(connector);
>> + struct vdrm_device *vdrm = to_vdrm_device(connector->dev);
>> + struct drm_connector *conn;
>> + struct drm_connector_list_iter conn_iter;
>> +
>> + drm_connector_list_iter_begin(vdrm->parent, &conn_iter);
>> + drm_for_each_connector_iter(conn, &conn_iter) {
>> + if (!conn->state)
>> + continue;
>> +
>> + if (conn->state->crtc == disp->parent_crtc) {
>> + drm_connector_list_iter_end(&conn_iter);
>> + return connector_status_connected;
>> + }
>> + }
>> + drm_connector_list_iter_end(&conn_iter);
>> + return connector_status_disconnected;
>> +}
>> +
>> +static const struct drm_connector_funcs vdrm_conn_funcs = {
>> + .reset = drm_atomic_helper_connector_reset,
>> + .detect = vdrm_connector_detect,
>> + .fill_modes = drm_helper_probe_single_connector_modes,
>> + .destroy = drm_connector_cleanup,
>> + .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
>> + .atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
>> +};
>> +
>> +static void vdrm_drv_finish_page_flip_internal(struct vdrm_display *disp)
>> +{
>> + struct drm_device *dev = &disp->dev->ddev;
>> + struct drm_pending_vblank_event *event;
>> + unsigned long flags;
>> +
>> + spin_lock_irqsave(&dev->event_lock, flags);
>> + event = disp->event;
>> + disp->event = NULL;
>> + spin_unlock_irqrestore(&dev->event_lock, flags);
>> +
>> + if (event == NULL)
>> + return;
>> +
>> + spin_lock_irqsave(&dev->event_lock, flags);
>> + drm_crtc_send_vblank_event(&disp->crtc, event);
>> + spin_unlock_irqrestore(&dev->event_lock, flags);
>> +
>> + if (disp->vblank_count) {
>> + drm_crtc_vblank_put(&disp->crtc);
>> + disp->vblank_count--;
>> + }
>> +}
>> +
>> +static void vdrm_plane_update(struct drm_plane *plane,
>> + struct drm_atomic_state *state)
>> +{
>> + struct drm_plane_state *old_state = drm_atomic_get_old_plane_state(state, plane);
>> + struct drm_plane_state *new_state = drm_atomic_get_new_plane_state(state, plane);
>> + struct drm_crtc *vcrtc_old_state = old_state->crtc;
>> + struct drm_crtc *vcrtc_plane_state = new_state->crtc;
>> + struct drm_crtc *crtc;
>> + struct vdrm_display *vdisplay;
>> +
>> + crtc = (old_state->crtc ? old_state->crtc : new_state->crtc);
>> + if (WARN_ON(!crtc))
>> + return;
>> +
>> + vdisplay = crtc_to_vdrm_display(crtc);
>> +
>> + old_state->crtc = vdisplay->parent_crtc;
>> + new_state->crtc = vdisplay->parent_crtc;
>> +
>> + new_state->dst.x1 += vdisplay->plane_info.x;
>> + new_state->dst.y1 += vdisplay->plane_info.y;
>> + vdisplay->parent_plane_helper_funcs->atomic_update(plane, state);
>> +
>> + old_state->crtc = vcrtc_old_state;
>> + new_state->crtc = vcrtc_plane_state;
>> +}
>> +
>> +static struct vdrm_display *
>> +vdrm_plane_find_display(struct vdrm_device *vdrm, struct drm_plane *plane)
>> +{
>> + struct vdrm_display *disp;
>> +
>> + list_for_each_entry(disp, &vdrm->disps, head) {
>> + if (disp->plane == plane)
>> + return disp;
>> + }
>> +
>> + return NULL;
>> +}
>> +
>> +static void vdrm_plane_reset(struct drm_plane *plane)
>> +{
>> + struct vdrm_device *vdrm = to_vdrm_device(plane->dev);
>> + struct vdrm_display *disp;
>> +
>> + disp = vdrm_plane_find_display(vdrm, plane);
>> + if (WARN_ON(!disp))
>> + return;
>> +
>> + disp->parent_plane_funcs->reset(plane);
>> + plane->state->zpos = disp->plane_info.z;
>> +}
>> +
>> +static struct drm_property *
>> +vdrm_find_parent_property(struct vdrm_device *vdrm, struct drm_property *prop)
>> +{
>> + int i;
>> +
>> + for (i = 0; i < vdrm->num_props; i++) {
>> + if (vdrm->props[i].prop == prop)
>> + return vdrm->props[i].parent_prop;
>> + }
>> +
>> + return NULL;
>> +}
>> +
>> +static int vdrm_plane_set_property(struct drm_plane *plane,
>> + struct drm_plane_state *state,
>> + struct drm_property *property,
>> + uint64_t val)
>> +{
>> + struct vdrm_device *vdrm = to_vdrm_device(plane->dev);
>> + struct vdrm_display *disp;
>> + struct drm_property *parent_prop;
>> +
>> + disp = vdrm_plane_find_display(vdrm, plane);
>> + if (WARN_ON(!disp))
>> + return -EINVAL;
>> +
>> + parent_prop = vdrm_find_parent_property(vdrm, property);
>> + if (parent_prop && disp->parent_plane_funcs->atomic_set_property)
>> + return disp->parent_plane_funcs->atomic_set_property(plane,
>> + state,
>> + parent_prop,
>> + val);
>> +
>> + if (vdrm->plane_props.offset_x == property) {
>> + if (val > disp->parent_crtc->mode.hdisplay)
>> + return -EINVAL;
>> + disp->plane_info.x = val;
>> + } else if (vdrm->plane_props.offset_y == property) {
>> + if (val > disp->parent_crtc->mode.vdisplay)
>> + return -EINVAL;
>> + disp->plane_info.y = val;
>> + } else if (vdrm->plane_props.width == property) {
>> + if (val > disp->parent_crtc->mode.hdisplay)
>> + return -EINVAL;
>> + disp->plane_info.width = val;
>> + } else if (vdrm->plane_props.height == property) {
>> + if (val > disp->parent_crtc->mode.vdisplay)
>> + return -EINVAL;
>> + disp->plane_info.height = val;
>> + } else {
>> + return -EINVAL;
>> + }
>> +
>> + return 0;
>> +}
>> +
>> +static int vdrm_plane_get_property(struct drm_plane *plane,
>> + const struct drm_plane_state *state,
>> + struct drm_property *property,
>> + uint64_t *val)
>> +{
>> + struct vdrm_device *vdrm = to_vdrm_device(plane->dev);
>> + struct vdrm_display *disp;
>> + struct drm_property *parent_prop;
>> +
>> + disp = vdrm_plane_find_display(vdrm, plane);
>> + if (WARN_ON(!disp))
>> + return -EINVAL;
>> +
>> + parent_prop = vdrm_find_parent_property(vdrm, property);
>> + if (parent_prop && disp->parent_plane_funcs->atomic_get_property)
>> + return disp->parent_plane_funcs->atomic_get_property(plane,
>> + state,
>> + parent_prop,
>> + val);
>> +
>> + if (vdrm->plane_props.offset_x == property)
>> + *val = disp->plane_info.x;
>> + else if (vdrm->plane_props.offset_y == property)
>> + *val = disp->plane_info.y;
>> + else if (vdrm->plane_props.width == property)
>> + *val = disp->plane_info.width;
>> + else if (vdrm->plane_props.height == property)
>> + *val = disp->plane_info.height;
>> + else
>> + return -EINVAL;
>> +
>> + return 0;
>> +}
>> +
>> +static int vdrm_crtc_check(struct drm_crtc *crtc,
>> + struct drm_atomic_state *state)
>> +{
>> + struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(state,
>> + crtc);
>> + bool has_primary = crtc_state->plane_mask &
>> + drm_plane_mask(crtc->primary);
>> +
>> + /* We always want to have an active plane with an active CRTC */
>> + if (has_primary != crtc_state->enable)
>> + return -EINVAL;
>> +
>> + return drm_atomic_add_affected_planes(state, crtc);
>> +}
>> +
>> +static void vdrm_crtc_flush(struct drm_crtc *crtc,
>> + struct drm_atomic_state *state)
>> +{
>> + struct vdrm_display *disp = crtc_to_vdrm_display(crtc);
>> + struct vdrm_device *vdrm = disp->dev;
>> +
>> + if (crtc->state->event) {
>> + struct drm_device *dev = crtc->dev;
>> + unsigned long flags;
>> +
>> + if (disp->crtc_enabled) {
>> + WARN_ON(drm_crtc_vblank_get(crtc) != 0);
>> + disp->vblank_count++;
>> + }
>> +
>> + spin_lock_irqsave(&dev->event_lock, flags);
>> + disp->event = crtc->state->event;
>> + crtc->state->event = NULL;
>> + spin_unlock_irqrestore(&dev->event_lock, flags);
>> + }
>> +
>> + if (vdrm->funcs->crtc_flush)
>> + vdrm->funcs->crtc_flush(disp->parent_crtc);
>> +}
>> +
>> +static void vdrm_crtc_enable(struct drm_crtc *crtc,
>> + struct drm_atomic_state *state)
>> +{
>> + struct vdrm_display *disp = crtc_to_vdrm_display(crtc);
>> +
>> + drm_crtc_vblank_on(crtc);
>> + disp->crtc_enabled = true;
>> +}
>> +
>> +static void vdrm_crtc_disable(struct drm_crtc *crtc,
>> + struct drm_atomic_state *state)
>> +{
>> + struct vdrm_display *disp = crtc_to_vdrm_display(crtc);
>> + unsigned long flags;
>> + bool pending;
>> +
>> + disp->crtc_enabled = false;
>> + drm_crtc_vblank_off(crtc);
>> +
>> + spin_lock_irqsave(&crtc->dev->event_lock, flags);
>> + pending = disp->event != NULL;
>> + spin_unlock_irqrestore(&crtc->dev->event_lock, flags);
>> +
>> + if (!wait_event_timeout(disp->flip_wait, !pending,
>> + msecs_to_jiffies(50))) {
>> + DRM_WARN("VDRM: page flip timeout\n");
>> + vdrm_drv_finish_page_flip_internal(disp);
>> + }
>> +
>> + spin_lock_irq(&crtc->dev->event_lock);
>> + if (crtc->state->event) {
>> + drm_crtc_send_vblank_event(crtc, crtc->state->event);
>> + crtc->state->event = NULL;
>> + }
>> + spin_unlock_irq(&crtc->dev->event_lock);
>> +}
>> +
>> +static const struct drm_crtc_helper_funcs vdrm_crtc_helper_funcs = {
>> + .atomic_check = vdrm_crtc_check,
>> + .atomic_flush = vdrm_crtc_flush,
>> + .atomic_enable = vdrm_crtc_enable,
>> + .atomic_disable = vdrm_crtc_disable,
>> +};
>> +
>> +static int vdrm_crtc_enable_vblank(struct drm_crtc *crtc)
>> +{
>> + struct vdrm_display *disp;
>> +
>> + disp = crtc_to_vdrm_display(crtc);
>> + disp->vblank_enabled = true;
>> +
>> + return 0;
>> +}
>> +
>> +static void vdrm_crtc_disable_vblank(struct drm_crtc *crtc)
>> +{
>> + struct vdrm_display *disp;
>> +
>> + disp = crtc_to_vdrm_display(crtc);
>> + disp->vblank_enabled = false;
>> +}
>> +
>> +static const struct drm_crtc_funcs vdrm_crtc_funcs = {
>> + .reset = drm_atomic_helper_crtc_reset,
>> + .destroy = drm_crtc_cleanup,
>> + .set_config = drm_atomic_helper_set_config,
>> + .page_flip = drm_atomic_helper_page_flip,
>> + .atomic_duplicate_state = drm_atomic_helper_crtc_duplicate_state,
>> + .atomic_destroy_state = drm_atomic_helper_crtc_destroy_state,
>> + .enable_vblank = vdrm_crtc_enable_vblank,
>> + .disable_vblank = vdrm_crtc_disable_vblank,
>> +};
>> +static const struct drm_encoder_funcs vdrm_encoder_funcs = {
>> + .destroy = drm_encoder_cleanup,
>> +};
>> +
>> +static int vdrm_properties_init(struct vdrm_device *vdrm, int num_props,
>> + struct vdrm_property_info *props)
>> +{
>> + int i;
>> + unsigned int w = vdrm->ddev.mode_config.max_width;
>> + unsigned int h = vdrm->ddev.mode_config.max_height;
>> +
>> + vdrm->plane_props.offset_x =
>> + drm_property_create_range(&vdrm->ddev, 0, "vdrm_offset_x", 0, w);
>> + if (!vdrm->plane_props.offset_x)
>> + return -1;
>> + vdrm->plane_props.offset_y =
>> + drm_property_create_range(&vdrm->ddev, 0, "vdrm_offset_y", 0, h);
>> + if (!vdrm->plane_props.offset_y)
>> + return -1;
>> + vdrm->plane_props.width =
>> + drm_property_create_range(&vdrm->ddev, 0, "vdrm_width", 1, w);
>> + if (!vdrm->plane_props.width)
>> + return -1;
>> + vdrm->plane_props.height =
>> + drm_property_create_range(&vdrm->ddev, 0, "vdrm_height", 1, h);
>> + if (!vdrm->plane_props.height)
>> + return -1;
>> +
>> + if (num_props == 0)
>> + return 0;
>> +
>> + vdrm->props = devm_kzalloc(vdrm->parent->dev,
>> + sizeof(*vdrm->props) * num_props,
>> + GFP_KERNEL);
>> + if (!vdrm->props)
>> + return -ENOMEM;
>> +
>> + for (i = 0; i < num_props; i++) {
>> + struct drm_property *p = props[i].prop;
>> +
>> + vdrm->props[i].prop =
>> + drm_property_create_range(&vdrm->ddev, p->flags,
>> + p->name, p->values[0],
>> + p->values[1]);
>> + if (!vdrm->props[i].prop)
>> + goto err;
>> +
>> + vdrm->props[i].parent_prop = p;
>> + vdrm->props[i].default_val = props[i].default_val;
>> + }
>> + vdrm->num_props = num_props;
>> +
>> + return 0;
>> +
>> +err:
>> + for (i--; i >= 0; i--)
>> + drm_property_destroy(&vdrm->ddev, vdrm->props[i].prop);
>> + devm_kfree(vdrm->parent->dev, vdrm->props);
>> + return -1;
>> +}
>> +
>> +static int vdrm_of_get_plane(struct device_node *np,
>> + int *x, int *y, int *width, int *height, int *z)
>> +{
>> + struct device_node *child;
>> + int ret;
>> +
>> + child = of_get_next_child(np, NULL);
>> + if (!child)
>> + return -ENODEV;
>> +
>> + ret = of_property_read_u32(child, "x", x);
>> + ret |= of_property_read_u32(child, "y", y);
>> + ret |= of_property_read_u32(child, "width", width);
>> + ret |= of_property_read_u32(child, "height", height);
>> + ret |= of_property_read_u32(child, "zpos", z);
>> +
>> + of_node_put(child);
>> + return ret;
>> +}
>> +
>> +static void vdrm_dump(struct vdrm_device *vdrm)
>> +{
>> + struct vdrm_display *disp;
>> +
>> + DRM_INFO("Virtual DRM Info:\n");
>> + list_for_each_entry(disp, &vdrm->disps, head) {
>> + DRM_INFO("\tCONNECTOR: %d\n",
>> + disp->connector.base.id);
>> + DRM_INFO("\tCRTC: %d\n",
>> + disp->crtc.base.id);
>> + DRM_INFO("\tENCODER: %d\n",
>> + disp->encoder.base.id);
>> + DRM_INFO("\tPLANE: %d\n",
>> + disp->plane->base.id);
>> + DRM_INFO("\tParent CRTC: %d\n",
>> + disp->parent_crtc->base.id);
>> + }
>> +}
>> +
>> +/**
>> + * vdrm_drv_handle_vblank - handle a vblank event for vDRM
>> + * @vdisplay: vDRM display object
>> + */
>> +void vdrm_drv_handle_vblank(struct vdrm_display *vdisplay)
>> +{
>> + if (vdisplay->vblank_enabled)
>> + drm_crtc_handle_vblank(&vdisplay->crtc);
>> +}
>> +
>> +/**
>> + * vdrm_drv_finish_page_flip - handle a page flip event for vDRM
>> + * @vdisplay: vDRM display object
>> + */
>> +void vdrm_drv_finish_page_flip(struct vdrm_display *vdisplay)
>> +{
>> + vdrm_drv_finish_page_flip_internal(vdisplay);
>> +}
>> +
>> +DEFINE_DRM_GEM_CMA_FOPS(vdrm_fops);
>> +
>> +static struct drm_driver vdrm_driver = {
>> + .driver_features = DRIVER_GEM | DRIVER_MODESET | DRIVER_ATOMIC,
>> + .dumb_create = vdrm_dumb_create,
>> + .fops = &vdrm_fops,
>> + .name = "virt-drm",
>> + .desc = "Virtual DRM driver",
>> + .date = "20201104",
>> + .major = 1,
>> + .minor = 0,
>> +};
>> +
>> +/**
>> + * vdrm_drv_init - Initialize vDRM device
>> + * @dev: parent DRM device
>> + * @np: vDRM device node in DTB
>> + * @num_props: number of parent property objects
>> + * @props: parent plane properties used in vDRM
>> + * @funcs: callbacks for vDRM
>> + *
>> + * Allocates a new vDRM device, initializes mode_config of the vDRM device
>> + * and allocates property objects. Not initialize plane, crtc, encoder and
>> + * connector. Initialization of plane must be done in vdrm_drv_plane_init()
>> + * and initialization of crtc, encoder and connector must be done by
>> + * vdrm_drv_display_init(). Also, after initializing the plane, crtc,
>> + * connector, and encoder, register vDRM device must be done by
>> + * vdrm_drv_register().
>> + *
>> + * Returns:
>> + * vDRM object (&vdrm_device) on success, error code encoded into the pointer
>> + * on failure.
>> + */
>> +struct vdrm_device *vdrm_drv_init(struct drm_device *dev,
>> + struct device_node *np, int num_props,
>> + struct vdrm_property_info *props,
>> + const struct vdrm_funcs *funcs)
>> +{
>> + struct vdrm_device *vdrm;
>> + struct vdrm_plane_info plane_info;
>> + int ret;
>> +
>> + if (!of_device_is_compatible(np, "virt-drm"))
>> + return ERR_PTR(-ENODEV);
>> +
>> + /* get plane information from device tree */
>> + ret = vdrm_of_get_plane(np, &plane_info.x, &plane_info.y,
>> + &plane_info.width, &plane_info.height,
>> + &plane_info.z);
>> + if (ret < 0) {
>> + DRM_WARN("VDRM: failed get plane node of %s\n",
>> + of_node_full_name(np));
>> + return ERR_PTR(ret);
>> + }
>> +
>> + vdrm_driver.prime_handle_to_fd = dev->driver->prime_handle_to_fd;
>> + vdrm_driver.prime_fd_to_handle = dev->driver->prime_fd_to_handle;
>> + vdrm_driver.gem_prime_import_sg_table =
>> + dev->driver->gem_prime_import_sg_table;
>> + vdrm_driver.gem_prime_mmap = dev->driver->gem_prime_mmap;
>> +
>> + vdrm = devm_drm_dev_alloc(dev->dev, &vdrm_driver, struct vdrm_device,
>> + ddev);
>> + if (IS_ERR(vdrm))
>> + return vdrm;
>> +
>> + vdrm->parent = dev;
>> + vdrm->funcs = funcs;
>> + vdrm->of_plane_info = plane_info;
>> +
>> + INIT_LIST_HEAD(&vdrm->disps);
>> +
>> + ret = drmm_mode_config_init(&vdrm->ddev);
>> + if (ret)
>> + goto failed;
>> +
>> + vdrm->ddev.mode_config.min_width = 0;
>> + vdrm->ddev.mode_config.min_height = 0;
>> + vdrm->ddev.mode_config.max_width = 8190;
>> + vdrm->ddev.mode_config.max_height = 8190;
>> + vdrm->ddev.mode_config.normalize_zpos = true;
>> + vdrm->ddev.mode_config.funcs = &vdrm_mode_config_funcs;
>> +
>> + ret = vdrm_properties_init(vdrm, num_props, props);
>> + if (ret < 0)
>> + goto failed;
>> +
>> + drm_dev_set_unique(&vdrm->ddev, of_node_full_name(np));
>> + return vdrm;
>> +
>> +failed:
>> + kfree(vdrm);
>> + return ERR_PTR(ret);
>> +}
>> +
>> +/**
>> + * vdrm_drv_plane_init - Initialize the plane used by vDRM
>> + * @vdrm: vDRM object
>> + * @plane: plane to assign to vDRM
>> + * @funcs: callbacks for the plane
>> + * @helper_funcs: helper vtable to set for plane
>> + * @formats: color formats
>> + * @num_formats: number of color formats
>> + * @max_zpos: max value for zpos property of plane
>> + *
>> + * Initializes a plane object of PRIMARY type by drm_universal_plane_init()
>> + * and initializes @plane's properties. The property passed by vdrm_drv_init()
>> + * is set to @plane.
>> + *
>> + * Returns:
>> + * Zero on success, error code on failure.
>> + */
>> +int vdrm_drv_plane_init(struct vdrm_device *vdrm, struct drm_plane *plane,
>> + const struct drm_plane_funcs *funcs,
>> + const struct drm_plane_helper_funcs *helper_funcs,
>> + const u32 *formats, unsigned int num_formats,
>> + int max_zpos)
>> +{
>> + struct vdrm_display *disp;
>> + int i, ret;
>> +
>> + disp = kzalloc(sizeof(*disp), GFP_KERNEL);
>> + if (!disp)
>> + return -ENOMEM;
>> +
>> + disp->dev = vdrm;
>> + disp->plane = plane;
>> + disp->plane_info = vdrm->of_plane_info;
>> +
>> + disp->parent_plane_funcs = funcs;
>> + disp->parent_plane_helper_funcs = helper_funcs;
>> + disp->plane_funcs = *funcs;
>> + disp->plane_helper_funcs = *helper_funcs;
>> +
>> + disp->plane_funcs.reset = vdrm_plane_reset;
>> + disp->plane_funcs.atomic_set_property = vdrm_plane_set_property;
>> + disp->plane_funcs.atomic_get_property = vdrm_plane_get_property;
>> + disp->plane_helper_funcs.atomic_update = vdrm_plane_update;
>> +
>> + drm_plane_helper_add(disp->plane, &disp->plane_helper_funcs);
>> + ret = drm_universal_plane_init(&vdrm->ddev, plane, 0,
>> + &disp->plane_funcs, formats,
>> + num_formats, NULL,
>> + DRM_PLANE_TYPE_PRIMARY, NULL);
>> + if (ret) {
>> + kfree(disp);
>> + return ret;
>> + }
>> +
>> + drm_plane_create_alpha_property(plane);
>> + drm_plane_create_zpos_property(plane, disp->plane_info.z, 0, max_zpos);
>> + drm_object_attach_property(&plane->base,
>> + vdrm->plane_props.offset_x,
>> + disp->plane_info.x);
>> + drm_object_attach_property(&plane->base,
>> + vdrm->plane_props.offset_y,
>> + disp->plane_info.y);
>> + drm_object_attach_property(&plane->base,
>> + vdrm->plane_props.width,
>> + disp->plane_info.width);
>> + drm_object_attach_property(&plane->base,
>> + vdrm->plane_props.height,
>> + disp->plane_info.height);
>> + for (i = 0; i < vdrm->num_props; i++) {
>> + drm_object_attach_property(&plane->base,
>> + vdrm->props[i].prop,
>> + vdrm->props[i].default_val);
>> + }
>> +
>> + INIT_LIST_HEAD(&disp->head);
>> + list_add_tail(&disp->head, &vdrm->disps);
>> + vdrm->num_crtcs++;
>> + return 0;
>> +}
>> +
>> +/**
>> + * vdrm_drv_display_init - Initialize the vDRM display object
>> + * @vdrm: vDRM object
>> + * @crtc: parent crtc to be linked with the vDRM crtc
>> + * @plane: plane assigned to vDRM
>> + *
>> + * Initializes crtc, connector and encorder, and links @crtc to crtc of vDRM.
>> + *
>> + * Returns:
>> + * vDRM display object on success, error code encoded into the pointer on
>> + * failure.
>> + */
>> +struct vdrm_display *vdrm_drv_display_init(struct vdrm_device *vdrm,
>> + struct drm_crtc *crtc,
>> + struct drm_plane *plane)
>> +{
>> + struct vdrm_display *disp;
>> + int ret;
>> +
>> + disp = vdrm_plane_find_display(vdrm, plane);
>> + if (!disp)
>> + return ERR_PTR(-EINVAL);
>> +
>> + drm_crtc_helper_add(&disp->crtc, &vdrm_crtc_helper_funcs);
>> + ret = drm_crtc_init_with_planes(&vdrm->ddev, &disp->crtc, plane, NULL,
>> + &vdrm_crtc_funcs, NULL);
>> + if (ret)
>> + return ERR_PTR(ret);
>> +
>> + drm_connector_helper_add(&disp->connector, &vdrm_conn_helper_funcs);
>> + ret = drm_connector_init(&vdrm->ddev, &disp->connector,
>> + &vdrm_conn_funcs, DRM_MODE_CONNECTOR_VIRTUAL);
>> + if (ret)
>> + return ERR_PTR(ret);
>> +
>> + disp->encoder.possible_crtcs = drm_crtc_mask(&disp->crtc);
>> + ret = drm_encoder_init(&vdrm->ddev, &disp->encoder, &vdrm_encoder_funcs,
>> + DRM_MODE_ENCODER_NONE, NULL);
>> + if (ret)
>> + return ERR_PTR(ret);
>> +
>> + ret = drm_connector_attach_encoder(&disp->connector, &disp->encoder);
>> + if (ret)
>> + return ERR_PTR(ret);
>> +
>> + init_waitqueue_head(&disp->flip_wait);
>> + disp->parent_crtc = crtc;
>> +
>> + return disp;
>> +}
>> +
>> +/**
>> + * vdrm_drv_register - Register vDRM device
>> + * @vdrm: vDRM object
>> + *
>> + * Returns:
>> + * Zero on success, error code on failure.
>> + */
>> +int vdrm_drv_register(struct vdrm_device *vdrm)
>> +{
>> + int ret;
>> + struct drm_device *dev = &vdrm->ddev;
>> +
>> + ret = drm_vblank_init(dev, vdrm->num_crtcs);
>> + if (ret)
>> + return ret;
>> +
>> + drm_mode_config_reset(dev);
>> +
>> + ret = drm_dev_register(dev, 0);
>> + if (ret)
>> + return ret;
>> +
>> + dev->irq_enabled = true;
>> +
>> + DRM_INFO("Virtual Device is initialized.\n");
>> +
>> + vdrm_dump(vdrm);
>> +
>> + return 0;
>> +}
>> +
>> +/**
>> + * vdrm_drv_fini - release vDRM resources
>> + * @vdrm: vDRM object
>> + */
>> +void vdrm_drv_fini(struct vdrm_device *vdrm)
>> +{
>> + struct vdrm_display *disp;
>> +
>> + if (vdrm->ddev.registered)
>> + drm_dev_unregister(&vdrm->ddev);
>> + drm_mode_config_cleanup(&vdrm->ddev);
>> +
>> + list_for_each_entry(disp, &vdrm->disps, head)
>> + kfree(disp);
>> +}
>> diff --git a/drivers/gpu/drm/vdrm/vdrm_drv.h b/drivers/gpu/drm/vdrm/vdrm_drv.h
>> new file mode 100644
>> index 000000000000..67b8e02efddf
>> --- /dev/null
>> +++ b/drivers/gpu/drm/vdrm/vdrm_drv.h
>> @@ -0,0 +1,80 @@
>> +/* SPDX-License-Identifier: GPL-2.0+ */
>> +/*
>> + * vdrm_drv.h -- Virtual DRM driver
>> + *
>> + * Copyright (C) 2021 Renesas Electronics Corporation
>> + */
>> +
>> +#ifndef __VDRM_DRV_H__
>> +#define __VDRM_DRV_H__
>> +
>> +#include <drm/drm_device.h>
>> +
>> +#include "vdrm_api.h"
>> +
>> +struct vdrm_property {
>> + struct drm_property *prop;
>> + struct drm_property *parent_prop;
>> + uint64_t default_val;
>> +};
>> +
>> +struct vdrm_plane_info {
>> + int x;
>> + int y;
>> + unsigned int width;
>> + unsigned int height;
>> + unsigned int z;
>> +};
>> +
>> +struct vdrm_device;
>> +
>> +struct vdrm_display {
>> + struct drm_connector connector;
>> + struct drm_crtc crtc;
>> + struct drm_crtc *parent_crtc;
>> + struct drm_plane *plane;
>> + struct drm_encoder encoder;
>> + struct drm_pending_vblank_event *event;
>> + struct vdrm_device *dev;
>> + bool vblank_enabled;
>> + wait_queue_head_t flip_wait;
>> + bool crtc_enabled;
>> + int vblank_count;
>> +
>> + struct list_head head;
>> +
>> + struct vdrm_plane_info plane_info;
>> +
>> + const struct drm_plane_funcs *parent_plane_funcs;
>> + const struct drm_plane_helper_funcs *parent_plane_helper_funcs;
>> + struct drm_plane_funcs plane_funcs;
>> + struct drm_plane_helper_funcs plane_helper_funcs;
>> +};
>> +
>> +struct vdrm_device {
>> + struct drm_device ddev;
>> + struct drm_device *parent;
>> +
>> + int num_crtcs;
>> + struct list_head disps;
>> +
>> + const struct vdrm_funcs *funcs;
>> + struct vdrm_property *props;
>> + int num_props;
>> +
>> + struct {
>> + struct drm_property *offset_x;
>> + struct drm_property *offset_y;
>> + struct drm_property *width;
>> + struct drm_property *height;
>> + } plane_props;
>> +
>> + struct vdrm_plane_info of_plane_info;
>> +};
>> +
>> +static inline struct vdrm_device *to_vdrm_device(struct drm_device *dev)
>> +{
>> + return container_of(dev, struct vdrm_device, ddev);
>> +}
>> +
>> +#endif /* __VDRM_DRV_H__ */
>> --
>> 2.25.1
