drivers/gpu/drm/drm_gem_framebuffer_helper.c

   1 /*
   2  * drm gem framebuffer helper functions
   3  *
   4  * Copyright (C) 2017 Noralf Trønnes
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  */
  11
  12 #include <linux/dma-buf.h>
  13 #include <linux/dma-fence.h>
  14 #include <linux/reservation.h>
  15 #include <linux/slab.h>
  16
  17 #include <drm/drmP.h>
  18 #include <drm/drm_atomic.h>
  19 #include <drm/drm_fb_helper.h>
  20 #include <drm/drm_fourcc.h>
  21 #include <drm/drm_framebuffer.h>
  22 #include <drm/drm_gem.h>
  23 #include <drm/drm_gem_framebuffer_helper.h>
  24 #include <drm/drm_modeset_helper.h>
  25
  26 /**
  27  * DOC: overview
  28  *
  29  * This library provides helpers for drivers that don't subclass
  30  * &drm_framebuffer and and use &drm_gem_object for their backing storage.
  31  *
  32  * Drivers without additional needs to validate framebuffers can simply use
  33  * drm_gem_fb_create() and everything is wired up automatically. But all
  34  * parts can be used individually.
  35  */
  36
  37 /**
  38  * drm_gem_fb_get_obj() - Get GEM object for framebuffer
  39  * @fb: The framebuffer
  40  * @plane: Which plane
  41  *
  42  * Returns the GEM object for given framebuffer.
  43  */
  44 struct drm_gem_object *drm_gem_fb_get_obj(struct drm_framebuffer *fb,
  45                                           unsigned int plane)
  46 {
  47         if (plane >= 4)
  48                 return NULL;
  49
  50         return fb->obj[plane];
  51 }
  52 EXPORT_SYMBOL_GPL(drm_gem_fb_get_obj);
  53
  54 static struct drm_framebuffer *
  55 drm_gem_fb_alloc(struct drm_device *dev,
  56                  const struct drm_mode_fb_cmd2 *mode_cmd,
  57                  struct drm_gem_object **obj, unsigned int num_planes,
  58                  const struct drm_framebuffer_funcs *funcs)
  59 {
  60         struct drm_framebuffer *fb;
  61         int ret, i;
  62
  63         fb = kzalloc(sizeof(*fb), GFP_KERNEL);
  64         if (!fb)
  65                 return ERR_PTR(-ENOMEM);
  66
  67         drm_helper_mode_fill_fb_struct(dev, fb, mode_cmd);
  68
  69         for (i = 0; i < num_planes; i++)
  70                 fb->obj[i] = obj[i];
  71
  72         ret = drm_framebuffer_init(dev, fb, funcs);
  73         if (ret) {
  74                 DRM_DEV_ERROR(dev->dev, "Failed to init framebuffer: %d\n",
  75                               ret);
  76                 kfree(fb);
  77                 return ERR_PTR(ret);
  78         }
  79
  80         return fb;
  81 }
  82
  83 /**
  84  * drm_gem_fb_destroy - Free GEM backed framebuffer
  85  * @fb: DRM framebuffer
  86  *
  87  * Frees a GEM backed framebuffer with its backing buffer(s) and the structure
  88  * itself. Drivers can use this as their &drm_framebuffer_funcs->destroy
  89  * callback.
  90  */
  91 void drm_gem_fb_destroy(struct drm_framebuffer *fb)
  92 {
  93         int i;
  94
  95         for (i = 0; i < 4; i++)
  96                 drm_gem_object_put_unlocked(fb->obj[i]);
  97
  98         drm_framebuffer_cleanup(fb);
  99         kfree(fb);
 100 }
 101 EXPORT_SYMBOL(drm_gem_fb_destroy);
 102
 103 /**
 104  * drm_gem_fb_create_handle - Create handle for GEM backed framebuffer
 105  * @fb: DRM framebuffer
 106  * @file: drm file
 107  * @handle: handle created
 108  *
 109  * Drivers can use this as their &drm_framebuffer_funcs->create_handle
 110  * callback.
 111  *
 112  * Returns:
 113  * 0 on success or a negative error code on failure.
 114  */
 115 int drm_gem_fb_create_handle(struct drm_framebuffer *fb, struct drm_file *file,
 116                              unsigned int *handle)
 117 {
 118         return drm_gem_handle_create(file, fb->obj[0], handle);
 119 }
 120 EXPORT_SYMBOL(drm_gem_fb_create_handle);
 121
 122 /**
 123  * drm_gem_fb_create_with_funcs() - helper function for the
 124  *                                  &drm_mode_config_funcs.fb_create
 125  *                                  callback
 126  * @dev: DRM device
 127  * @file: drm file for the ioctl call
 128  * @mode_cmd: metadata from the userspace fb creation request
 129  * @funcs: vtable to be used for the new framebuffer object
 130  *
 131  * This can be used to set &drm_framebuffer_funcs for drivers that need the
 132  * &drm_framebuffer_funcs.dirty callback. Use drm_gem_fb_create() if you don't
 133  * need to change &drm_framebuffer_funcs.
 134  * The function does buffer size validation.
 135  */
 136 struct drm_framebuffer *
 137 drm_gem_fb_create_with_funcs(struct drm_device *dev, struct drm_file *file,
 138                              const struct drm_mode_fb_cmd2 *mode_cmd,
 139                              const struct drm_framebuffer_funcs *funcs)
 140 {
 141         const struct drm_format_info *info;
 142         struct drm_gem_object *objs[4];
 143         struct drm_framebuffer *fb;
 144         int ret, i;
 145
 146         info = drm_get_format_info(dev, mode_cmd);
 147         if (!info)
 148                 return ERR_PTR(-EINVAL);
 149
 150         for (i = 0; i < info->num_planes; i++) {
 151                 unsigned int width = mode_cmd->width / (i ? info->hsub : 1);
 152                 unsigned int height = mode_cmd->height / (i ? info->vsub : 1);
 153                 unsigned int min_size;
 154
 155                 objs[i] = drm_gem_object_lookup(file, mode_cmd->handles[i]);
 156                 if (!objs[i]) {
 157                         DRM_DEV_ERROR(dev->dev, "Failed to lookup GEM\n");
 158                         ret = -ENOENT;
 159                         goto err_gem_object_put;
 160                 }
 161
 162                 min_size = (height - 1) * mode_cmd->pitches[i]
 163                          + width * info->cpp[i]
 164                          + mode_cmd->offsets[i];
 165
 166                 if (objs[i]->size < min_size) {
 167                         drm_gem_object_put_unlocked(objs[i]);
 168                         ret = -EINVAL;
 169                         goto err_gem_object_put;
 170                 }
 171         }
 172
 173         fb = drm_gem_fb_alloc(dev, mode_cmd, objs, i, funcs);
 174         if (IS_ERR(fb)) {
 175                 ret = PTR_ERR(fb);
 176                 goto err_gem_object_put;
 177         }
 178
 179         return fb;
 180
 181 err_gem_object_put:
 182         for (i--; i >= 0; i--)
 183                 drm_gem_object_put_unlocked(objs[i]);
 184
 185         return ERR_PTR(ret);
 186 }
 187 EXPORT_SYMBOL_GPL(drm_gem_fb_create_with_funcs);
 188
 189 static const struct drm_framebuffer_funcs drm_gem_fb_funcs = {
 190         .destroy        = drm_gem_fb_destroy,
 191         .create_handle  = drm_gem_fb_create_handle,
 192 };
 193
 194 /**
 195  * drm_gem_fb_create() - &drm_mode_config_funcs.fb_create callback function
 196  * @dev: DRM device
 197  * @file: drm file for the ioctl call
 198  * @mode_cmd: metadata from the userspace fb creation request
 199  *
 200  * If your hardware has special alignment or pitch requirements these should be
 201  * checked before calling this function. The function does buffer size
 202  * validation. Use drm_gem_fb_create_with_funcs() if you need to set
 203  * &drm_framebuffer_funcs.dirty.
 204  */
 205 struct drm_framebuffer *
 206 drm_gem_fb_create(struct drm_device *dev, struct drm_file *file,
 207                   const struct drm_mode_fb_cmd2 *mode_cmd)
 208 {
 209         return drm_gem_fb_create_with_funcs(dev, file, mode_cmd,
 210                                             &drm_gem_fb_funcs);
 211 }
 212 EXPORT_SYMBOL_GPL(drm_gem_fb_create);
 213
 214 /**
 215  * drm_gem_fb_prepare_fb() - Prepare gem framebuffer
 216  * @plane: Which plane
 217  * @state: Plane state attach fence to
 218  *
 219  * This can be used as the &drm_plane_helper_funcs.prepare_fb hook.
 220  *
 221  * This function checks if the plane FB has an dma-buf attached, extracts
 222  * the exclusive fence and attaches it to plane state for the atomic helper
 223  * to wait on.
 224  *
 225  * There is no need for &drm_plane_helper_funcs.cleanup_fb hook for simple
 226  * gem based framebuffer drivers which have their buffers always pinned in
 227  * memory.
 228  */
 229 int drm_gem_fb_prepare_fb(struct drm_plane *plane,
 230                           struct drm_plane_state *state)
 231 {
 232         struct dma_buf *dma_buf;
 233         struct dma_fence *fence;
 234
 235         if ((plane->state->fb == state->fb) || !state->fb)
 236                 return 0;
 237
 238         dma_buf = drm_gem_fb_get_obj(state->fb, 0)->dma_buf;
 239         if (dma_buf) {
 240                 fence = reservation_object_get_excl_rcu(dma_buf->resv);
 241                 drm_atomic_set_fence_for_plane(state, fence);
 242         }
 243
 244         return 0;
 245 }
 246 EXPORT_SYMBOL_GPL(drm_gem_fb_prepare_fb);
 247
 248 /**
 249  * drm_gem_fbdev_fb_create - Create a drm_framebuffer for fbdev emulation
 250  * @dev: DRM device
 251  * @sizes: fbdev size description
 252  * @pitch_align: optional pitch alignment
 253  * @obj: GEM object backing the framebuffer
 254  * @funcs: vtable to be used for the new framebuffer object
 255  *
 256  * This function creates a framebuffer for use with fbdev emulation.
 257  *
 258  * Returns:
 259  * Pointer to a drm_framebuffer on success or an error pointer on failure.
 260  */
 261 struct drm_framebuffer *
 262 drm_gem_fbdev_fb_create(struct drm_device *dev,
 263                         struct drm_fb_helper_surface_size *sizes,
 264                         unsigned int pitch_align, struct drm_gem_object *obj,
 265                         const struct drm_framebuffer_funcs *funcs)
 266 {
 267         struct drm_mode_fb_cmd2 mode_cmd = { 0 };
 268
 269         mode_cmd.width = sizes->surface_width;
 270         mode_cmd.height = sizes->surface_height;
 271         mode_cmd.pitches[0] = sizes->surface_width *
 272                               DIV_ROUND_UP(sizes->surface_bpp, 8);
 273         if (pitch_align)
 274                 mode_cmd.pitches[0] = roundup(mode_cmd.pitches[0],
 275                                               pitch_align);
 276         mode_cmd.pixel_format = drm_mode_legacy_fb_format(sizes->surface_bpp,
 277                                                         sizes->surface_depth);
 278         if (obj->size < mode_cmd.pitches[0] * mode_cmd.height)
 279                 return ERR_PTR(-EINVAL);
 280
 281         return drm_gem_fb_alloc(dev, &mode_cmd, &obj, 1, funcs);
 282 }
 283 EXPORT_SYMBOL(drm_gem_fbdev_fb_create);