drivers/gpu/drm/vkms/vkms_writeback.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2
   3 #include <linux/iosys-map.h>
   4
   5 #include <drm/drm_atomic.h>
   6 #include <drm/drm_edid.h>
   7 #include <drm/drm_fourcc.h>
   8 #include <drm/drm_writeback.h>
   9 #include <drm/drm_probe_helper.h>
  10 #include <drm/drm_atomic_helper.h>
  11 #include <drm/drm_gem_framebuffer_helper.h>
  12 #include <drm/drm_gem_shmem_helper.h>
  13
  14 #include "vkms_drv.h"
  15 #include "vkms_formats.h"
  16
  17 static const u32 vkms_wb_formats[] = {
  18         DRM_FORMAT_XRGB8888,
  19 };
  20
  21 static const struct drm_connector_funcs vkms_wb_connector_funcs = {
  22         .fill_modes = drm_helper_probe_single_connector_modes,
  23         .destroy = drm_connector_cleanup,
  24         .reset = drm_atomic_helper_connector_reset,
  25         .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
  26         .atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
  27 };
  28
  29 static int vkms_wb_encoder_atomic_check(struct drm_encoder *encoder,
  30                                         struct drm_crtc_state *crtc_state,
  31                                         struct drm_connector_state *conn_state)
  32 {
  33         struct drm_framebuffer *fb;
  34         const struct drm_display_mode *mode = &crtc_state->mode;
  35         int ret;
  36
  37         if (!conn_state->writeback_job || !conn_state->writeback_job->fb)
  38                 return 0;
  39
  40         fb = conn_state->writeback_job->fb;
  41         if (fb->width != mode->hdisplay || fb->height != mode->vdisplay) {
  42                 DRM_DEBUG_KMS("Invalid framebuffer size %ux%u\n",
  43                               fb->width, fb->height);
  44                 return -EINVAL;
  45         }
  46
  47         ret = drm_atomic_helper_check_wb_encoder_state(encoder, conn_state);
  48         if (ret < 0)
  49                 return ret;
  50
  51         return 0;
  52 }
  53
  54 static const struct drm_encoder_helper_funcs vkms_wb_encoder_helper_funcs = {
  55         .atomic_check = vkms_wb_encoder_atomic_check,
  56 };
  57
  58 static int vkms_wb_connector_get_modes(struct drm_connector *connector)
  59 {
  60         struct drm_device *dev = connector->dev;
  61
  62         return drm_add_modes_noedid(connector, dev->mode_config.max_width,
  63                                     dev->mode_config.max_height);
  64 }
  65
  66 static int vkms_wb_prepare_job(struct drm_writeback_connector *wb_connector,
  67                                struct drm_writeback_job *job)
  68 {
  69         struct vkms_writeback_job *vkmsjob;
  70         int ret;
  71
  72         if (!job->fb)
  73                 return 0;
  74
  75         vkmsjob = kzalloc(sizeof(*vkmsjob), GFP_KERNEL);
  76         if (!vkmsjob)
  77                 return -ENOMEM;
  78
  79         ret = drm_gem_fb_vmap(job->fb, vkmsjob->wb_frame_info.map, vkmsjob->data);
  80         if (ret) {
  81                 DRM_ERROR("vmap failed: %d\n", ret);
  82                 goto err_kfree;
  83         }
  84
  85         vkmsjob->wb_frame_info.fb = job->fb;
  86         drm_framebuffer_get(vkmsjob->wb_frame_info.fb);
  87
  88         job->priv = vkmsjob;
  89
  90         return 0;
  91
  92 err_kfree:
  93         kfree(vkmsjob);
  94         return ret;
  95 }
  96
  97 static void vkms_wb_cleanup_job(struct drm_writeback_connector *connector,
  98                                 struct drm_writeback_job *job)
  99 {
 100         struct vkms_writeback_job *vkmsjob = job->priv;
 101         struct vkms_device *vkmsdev;
 102
 103         if (!job->fb)
 104                 return;
 105
 106         drm_gem_fb_vunmap(job->fb, vkmsjob->wb_frame_info.map);
 107
 108         drm_framebuffer_put(vkmsjob->wb_frame_info.fb);
 109
 110         vkmsdev = drm_device_to_vkms_device(job->fb->dev);
 111         vkms_set_composer(&vkmsdev->output, false);
 112         kfree(vkmsjob);
 113 }
 114
 115 static void vkms_wb_atomic_commit(struct drm_connector *conn,
 116                                   struct drm_atomic_state *state)
 117 {
 118         struct drm_connector_state *connector_state = drm_atomic_get_new_connector_state(state,
 119                                                                                          conn);
 120         struct vkms_device *vkmsdev = drm_device_to_vkms_device(conn->dev);
 121         struct vkms_output *output = &vkmsdev->output;
 122         struct drm_writeback_connector *wb_conn = &output->wb_connector;
 123         struct drm_connector_state *conn_state = wb_conn->base.state;
 124         struct vkms_crtc_state *crtc_state = output->composer_state;
 125         struct drm_framebuffer *fb = connector_state->writeback_job->fb;
 126         struct vkms_writeback_job *active_wb;
 127         struct vkms_frame_info *wb_frame_info;
 128         u32 wb_format = fb->format->format;
 129
 130         if (!conn_state)
 131                 return;
 132
 133         vkms_set_composer(&vkmsdev->output, true);
 134
 135         active_wb = conn_state->writeback_job->priv;
 136         wb_frame_info = &active_wb->wb_frame_info;
 137
 138         spin_lock_irq(&output->composer_lock);
 139         crtc_state->active_writeback = active_wb;
 140         wb_frame_info->offset = fb->offsets[0];
 141         wb_frame_info->pitch = fb->pitches[0];
 142         wb_frame_info->cpp = fb->format->cpp[0];
 143         crtc_state->wb_pending = true;
 144         spin_unlock_irq(&output->composer_lock);
 145         drm_writeback_queue_job(wb_conn, connector_state);
 146         active_wb->wb_write = get_line_to_frame_function(wb_format);
 147 }
 148
 149 static const struct drm_connector_helper_funcs vkms_wb_conn_helper_funcs = {
 150         .get_modes = vkms_wb_connector_get_modes,
 151         .prepare_writeback_job = vkms_wb_prepare_job,
 152         .cleanup_writeback_job = vkms_wb_cleanup_job,
 153         .atomic_commit = vkms_wb_atomic_commit,
 154 };
 155
 156 int vkms_enable_writeback_connector(struct vkms_device *vkmsdev)
 157 {
 158         struct drm_writeback_connector *wb = &vkmsdev->output.wb_connector;
 159
 160         drm_connector_helper_add(&wb->base, &vkms_wb_conn_helper_funcs);
 161
 162         return drm_writeback_connector_init(&vkmsdev->drm, wb,
 163                                             &vkms_wb_connector_funcs,
 164                                             &vkms_wb_encoder_helper_funcs,
 165                                             vkms_wb_formats,
 166                                             ARRAY_SIZE(vkms_wb_formats),
 167                                             1);
 168 }