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 <e...@igel.co.jp> > --- > 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