drivers/gpu/drm/drm_gem_framebuffer_helper.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * drm gem framebuffer helper functions
   4  *
   5  * Copyright (C) 2017 Noralf Trønnes
   6  */
   7
   8 #include <linux/dma-buf.h>
   9 #include <linux/dma-fence.h>
  10 #include <linux/dma-resv.h>
  11 #include <linux/slab.h>
  12
  13 #include <drm/drm_atomic.h>
  14 #include <drm/drm_atomic_uapi.h>
  15 #include <drm/drm_damage_helper.h>
  16 #include <drm/drm_fb_helper.h>
  17 #include <drm/drm_fourcc.h>
  18 #include <drm/drm_framebuffer.h>
  19 #include <drm/drm_gem.h>
  20 #include <drm/drm_gem_framebuffer_helper.h>
  21 #include <drm/drm_modeset_helper.h>
  22 #include <drm/drm_simple_kms_helper.h>
  23
  24 #define AFBC_HEADER_SIZE                16
  25 #define AFBC_TH_LAYOUT_ALIGNMENT        8
  26 #define AFBC_HDR_ALIGN                  64
  27 #define AFBC_SUPERBLOCK_PIXELS          256
  28 #define AFBC_SUPERBLOCK_ALIGNMENT       128
  29 #define AFBC_TH_BODY_START_ALIGNMENT    4096
  30
  31 /**
  32  * DOC: overview
  33  *
  34  * This library provides helpers for drivers that don't subclass
  35  * &drm_framebuffer and use &drm_gem_object for their backing storage.
  36  *
  37  * Drivers without additional needs to validate framebuffers can simply use
  38  * drm_gem_fb_create() and everything is wired up automatically. Other drivers
  39  * can use all parts independently.
  40  */
  41
  42 /**
  43  * drm_gem_fb_get_obj() - Get GEM object backing the framebuffer
  44  * @fb: Framebuffer
  45  * @plane: Plane index
  46  *
  47  * No additional reference is taken beyond the one that the &drm_frambuffer
  48  * already holds.
  49  *
  50  * Returns:
  51  * Pointer to &drm_gem_object for the given framebuffer and plane index or NULL
  52  * if it does not exist.
  53  */
  54 struct drm_gem_object *drm_gem_fb_get_obj(struct drm_framebuffer *fb,
  55                                           unsigned int plane)
  56 {
  57         if (plane >= 4)
  58                 return NULL;
  59
  60         return fb->obj[plane];
  61 }
  62 EXPORT_SYMBOL_GPL(drm_gem_fb_get_obj);
  63
  64 static int
  65 drm_gem_fb_init(struct drm_device *dev,
  66                  struct drm_framebuffer *fb,
  67                  const struct drm_mode_fb_cmd2 *mode_cmd,
  68                  struct drm_gem_object **obj, unsigned int num_planes,
  69                  const struct drm_framebuffer_funcs *funcs)
  70 {
  71         int ret, i;
  72
  73         drm_helper_mode_fill_fb_struct(dev, fb, mode_cmd);
  74
  75         for (i = 0; i < num_planes; i++)
  76                 fb->obj[i] = obj[i];
  77
  78         ret = drm_framebuffer_init(dev, fb, funcs);
  79         if (ret) {
  80                 drm_err(dev, "Failed to init framebuffer: %d\n", ret);
  81                 kfree(fb);
  82         }
  83
  84         return ret;
  85 }
  86
  87 /**
  88  * drm_gem_fb_destroy - Free GEM backed framebuffer
  89  * @fb: Framebuffer
  90  *
  91  * Frees a GEM backed framebuffer with its backing buffer(s) and the structure
  92  * itself. Drivers can use this as their &drm_framebuffer_funcs->destroy
  93  * callback.
  94  */
  95 void drm_gem_fb_destroy(struct drm_framebuffer *fb)
  96 {
  97         int i;
  98
  99         for (i = 0; i < 4; i++)
 100                 drm_gem_object_put_unlocked(fb->obj[i]);
 101
 102         drm_framebuffer_cleanup(fb);
 103         kfree(fb);
 104 }
 105 EXPORT_SYMBOL(drm_gem_fb_destroy);
 106
 107 /**
 108  * drm_gem_fb_create_handle - Create handle for GEM backed framebuffer
 109  * @fb: Framebuffer
 110  * @file: DRM file to register the handle for
 111  * @handle: Pointer to return the created handle
 112  *
 113  * This function creates a handle for the GEM object backing the framebuffer.
 114  * Drivers can use this as their &drm_framebuffer_funcs->create_handle
 115  * callback. The GETFB IOCTL calls into this callback.
 116  *
 117  * Returns:
 118  * 0 on success or a negative error code on failure.
 119  */
 120 int drm_gem_fb_create_handle(struct drm_framebuffer *fb, struct drm_file *file,
 121                              unsigned int *handle)
 122 {
 123         return drm_gem_handle_create(file, fb->obj[0], handle);
 124 }
 125 EXPORT_SYMBOL(drm_gem_fb_create_handle);
 126
 127 /**
 128  * drm_gem_fb_init_with_funcs() - Helper function for implementing
 129  *                                &drm_mode_config_funcs.fb_create
 130  *                                callback in cases when the driver
 131  *                                allocates a subclass of
 132  *                                struct drm_framebuffer
 133  * @dev: DRM device
 134  * @fb: framebuffer object
 135  * @file: DRM file that holds the GEM handle(s) backing the framebuffer
 136  * @mode_cmd: Metadata from the userspace framebuffer creation request
 137  * @funcs: vtable to be used for the new framebuffer object
 138  *
 139  * This function can be used to set &drm_framebuffer_funcs for drivers that need
 140  * custom framebuffer callbacks. Use drm_gem_fb_create() if you don't need to
 141  * change &drm_framebuffer_funcs. The function does buffer size validation.
 142  * The buffer size validation is for a general case, though, so users should
 143  * pay attention to the checks being appropriate for them or, at least,
 144  * non-conflicting.
 145  *
 146  * Returns:
 147  * Zero or a negative error code.
 148  */
 149 int drm_gem_fb_init_with_funcs(struct drm_device *dev,
 150                                struct drm_framebuffer *fb,
 151                                struct drm_file *file,
 152                                const struct drm_mode_fb_cmd2 *mode_cmd,
 153                                const struct drm_framebuffer_funcs *funcs)
 154 {
 155         const struct drm_format_info *info;
 156         struct drm_gem_object *objs[4];
 157         int ret, i;
 158
 159         info = drm_get_format_info(dev, mode_cmd);
 160         if (!info)
 161                 return -EINVAL;
 162
 163         for (i = 0; i < info->num_planes; i++) {
 164                 unsigned int width = mode_cmd->width / (i ? info->hsub : 1);
 165                 unsigned int height = mode_cmd->height / (i ? info->vsub : 1);
 166                 unsigned int min_size;
 167
 168                 objs[i] = drm_gem_object_lookup(file, mode_cmd->handles[i]);
 169                 if (!objs[i]) {
 170                         drm_dbg_kms(dev, "Failed to lookup GEM object\n");
 171                         ret = -ENOENT;
 172                         goto err_gem_object_put;
 173                 }
 174
 175                 min_size = (height - 1) * mode_cmd->pitches[i]
 176                          + drm_format_info_min_pitch(info, i, width)
 177                          + mode_cmd->offsets[i];
 178
 179                 if (objs[i]->size < min_size) {
 180                         drm_gem_object_put_unlocked(objs[i]);
 181                         ret = -EINVAL;
 182                         goto err_gem_object_put;
 183                 }
 184         }
 185
 186         ret = drm_gem_fb_init(dev, fb, mode_cmd, objs, i, funcs);
 187         if (ret)
 188                 goto err_gem_object_put;
 189
 190         return 0;
 191
 192 err_gem_object_put:
 193         for (i--; i >= 0; i--)
 194                 drm_gem_object_put_unlocked(objs[i]);
 195
 196         return ret;
 197 }
 198 EXPORT_SYMBOL_GPL(drm_gem_fb_init_with_funcs);
 199
 200 /**
 201  * drm_gem_fb_create_with_funcs() - Helper function for the
 202  *                                  &drm_mode_config_funcs.fb_create
 203  *                                  callback
 204  * @dev: DRM device
 205  * @file: DRM file that holds the GEM handle(s) backing the framebuffer
 206  * @mode_cmd: Metadata from the userspace framebuffer creation request
 207  * @funcs: vtable to be used for the new framebuffer object
 208  *
 209  * This function can be used to set &drm_framebuffer_funcs for drivers that need
 210  * custom framebuffer callbacks. Use drm_gem_fb_create() if you don't need to
 211  * change &drm_framebuffer_funcs. The function does buffer size validation.
 212  *
 213  * Returns:
 214  * Pointer to a &drm_framebuffer on success or an error pointer on failure.
 215  */
 216 struct drm_framebuffer *
 217 drm_gem_fb_create_with_funcs(struct drm_device *dev, struct drm_file *file,
 218                              const struct drm_mode_fb_cmd2 *mode_cmd,
 219                              const struct drm_framebuffer_funcs *funcs)
 220 {
 221         struct drm_framebuffer *fb;
 222         int ret;
 223
 224         fb = kzalloc(sizeof(*fb), GFP_KERNEL);
 225         if (!fb)
 226                 return ERR_PTR(-ENOMEM);
 227
 228         ret = drm_gem_fb_init_with_funcs(dev, fb, file, mode_cmd, funcs);
 229         if (ret) {
 230                 kfree(fb);
 231                 return ERR_PTR(ret);
 232         }
 233
 234         return fb;
 235 }
 236 EXPORT_SYMBOL_GPL(drm_gem_fb_create_with_funcs);
 237
 238 static const struct drm_framebuffer_funcs drm_gem_fb_funcs = {
 239         .destroy        = drm_gem_fb_destroy,
 240         .create_handle  = drm_gem_fb_create_handle,
 241 };
 242
 243 /**
 244  * drm_gem_fb_create() - Helper function for the
 245  *                       &drm_mode_config_funcs.fb_create callback
 246  * @dev: DRM device
 247  * @file: DRM file that holds the GEM handle(s) backing the framebuffer
 248  * @mode_cmd: Metadata from the userspace framebuffer creation request
 249  *
 250  * This function creates a new framebuffer object described by
 251  * &drm_mode_fb_cmd2. This description includes handles for the buffer(s)
 252  * backing the framebuffer.
 253  *
 254  * If your hardware has special alignment or pitch requirements these should be
 255  * checked before calling this function. The function does buffer size
 256  * validation. Use drm_gem_fb_create_with_dirty() if you need framebuffer
 257  * flushing.
 258  *
 259  * Drivers can use this as their &drm_mode_config_funcs.fb_create callback.
 260  * The ADDFB2 IOCTL calls into this callback.
 261  *
 262  * Returns:
 263  * Pointer to a &drm_framebuffer on success or an error pointer on failure.
 264  */
 265 struct drm_framebuffer *
 266 drm_gem_fb_create(struct drm_device *dev, struct drm_file *file,
 267                   const struct drm_mode_fb_cmd2 *mode_cmd)
 268 {
 269         return drm_gem_fb_create_with_funcs(dev, file, mode_cmd,
 270                                             &drm_gem_fb_funcs);
 271 }
 272 EXPORT_SYMBOL_GPL(drm_gem_fb_create);
 273
 274 static const struct drm_framebuffer_funcs drm_gem_fb_funcs_dirtyfb = {
 275         .destroy        = drm_gem_fb_destroy,
 276         .create_handle  = drm_gem_fb_create_handle,
 277         .dirty          = drm_atomic_helper_dirtyfb,
 278 };
 279
 280 /**
 281  * drm_gem_fb_create_with_dirty() - Helper function for the
 282  *                       &drm_mode_config_funcs.fb_create callback
 283  * @dev: DRM device
 284  * @file: DRM file that holds the GEM handle(s) backing the framebuffer
 285  * @mode_cmd: Metadata from the userspace framebuffer creation request
 286  *
 287  * This function creates a new framebuffer object described by
 288  * &drm_mode_fb_cmd2. This description includes handles for the buffer(s)
 289  * backing the framebuffer. drm_atomic_helper_dirtyfb() is used for the dirty
 290  * callback giving framebuffer flushing through the atomic machinery. Use
 291  * drm_gem_fb_create() if you don't need the dirty callback.
 292  * The function does buffer size validation.
 293  *
 294  * Drivers should also call drm_plane_enable_fb_damage_clips() on all planes
 295  * to enable userspace to use damage clips also with the ATOMIC IOCTL.
 296  *
 297  * Drivers can use this as their &drm_mode_config_funcs.fb_create callback.
 298  * The ADDFB2 IOCTL calls into this callback.
 299  *
 300  * Returns:
 301  * Pointer to a &drm_framebuffer on success or an error pointer on failure.
 302  */
 303 struct drm_framebuffer *
 304 drm_gem_fb_create_with_dirty(struct drm_device *dev, struct drm_file *file,
 305                              const struct drm_mode_fb_cmd2 *mode_cmd)
 306 {
 307         return drm_gem_fb_create_with_funcs(dev, file, mode_cmd,
 308                                             &drm_gem_fb_funcs_dirtyfb);
 309 }
 310 EXPORT_SYMBOL_GPL(drm_gem_fb_create_with_dirty);
 311
 312 static __u32 drm_gem_afbc_get_bpp(struct drm_device *dev,
 313                                   const struct drm_mode_fb_cmd2 *mode_cmd)
 314 {
 315         const struct drm_format_info *info;
 316
 317         info = drm_get_format_info(dev, mode_cmd);
 318
 319         /* use whatever a driver has set */
 320         if (info->cpp[0])
 321                 return info->cpp[0] * 8;
 322
 323         /* guess otherwise */
 324         switch (info->format) {
 325         case DRM_FORMAT_YUV420_8BIT:
 326                 return 12;
 327         case DRM_FORMAT_YUV420_10BIT:
 328                 return 15;
 329         case DRM_FORMAT_VUY101010:
 330                 return 30;
 331         default:
 332                 break;
 333         }
 334
 335         /* all attempts failed */
 336         return 0;
 337 }
 338
 339 static int drm_gem_afbc_min_size(struct drm_device *dev,
 340                                  const struct drm_mode_fb_cmd2 *mode_cmd,
 341                                  struct drm_afbc_framebuffer *afbc_fb)
 342 {
 343         __u32 n_blocks, w_alignment, h_alignment, hdr_alignment;
 344         /* remove bpp when all users properly encode cpp in drm_format_info */
 345         __u32 bpp;
 346
 347         switch (mode_cmd->modifier[0] & AFBC_FORMAT_MOD_BLOCK_SIZE_MASK) {
 348         case AFBC_FORMAT_MOD_BLOCK_SIZE_16x16:
 349                 afbc_fb->block_width = 16;
 350                 afbc_fb->block_height = 16;
 351                 break;
 352         case AFBC_FORMAT_MOD_BLOCK_SIZE_32x8:
 353                 afbc_fb->block_width = 32;
 354                 afbc_fb->block_height = 8;
 355                 break;
 356         /* no user exists yet - fall through */
 357         case AFBC_FORMAT_MOD_BLOCK_SIZE_64x4:
 358         case AFBC_FORMAT_MOD_BLOCK_SIZE_32x8_64x4:
 359         default:
 360                 drm_dbg_kms(dev, "Invalid AFBC_FORMAT_MOD_BLOCK_SIZE: %lld.\n",
 361                             mode_cmd->modifier[0]
 362                             & AFBC_FORMAT_MOD_BLOCK_SIZE_MASK);
 363                 return -EINVAL;
 364         }
 365
 366         /* tiled header afbc */
 367         w_alignment = afbc_fb->block_width;
 368         h_alignment = afbc_fb->block_height;
 369         hdr_alignment = AFBC_HDR_ALIGN;
 370         if (mode_cmd->modifier[0] & AFBC_FORMAT_MOD_TILED) {
 371                 w_alignment *= AFBC_TH_LAYOUT_ALIGNMENT;
 372                 h_alignment *= AFBC_TH_LAYOUT_ALIGNMENT;
 373                 hdr_alignment = AFBC_TH_BODY_START_ALIGNMENT;
 374         }
 375
 376         afbc_fb->aligned_width = ALIGN(mode_cmd->width, w_alignment);
 377         afbc_fb->aligned_height = ALIGN(mode_cmd->height, h_alignment);
 378         afbc_fb->offset = mode_cmd->offsets[0];
 379
 380         bpp = drm_gem_afbc_get_bpp(dev, mode_cmd);
 381         if (!bpp) {
 382                 drm_dbg_kms(dev, "Invalid AFBC bpp value: %d\n", bpp);
 383                 return -EINVAL;
 384         }
 385
 386         n_blocks = (afbc_fb->aligned_width * afbc_fb->aligned_height)
 387                    / AFBC_SUPERBLOCK_PIXELS;
 388         afbc_fb->afbc_size = ALIGN(n_blocks * AFBC_HEADER_SIZE, hdr_alignment);
 389         afbc_fb->afbc_size += n_blocks * ALIGN(bpp * AFBC_SUPERBLOCK_PIXELS / 8,
 390                                                AFBC_SUPERBLOCK_ALIGNMENT);
 391
 392         return 0;
 393 }
 394
 395 /**
 396  * drm_gem_fb_afbc_init() - Helper function for drivers using afbc to
 397  *                          fill and validate all the afbc-specific
 398  *                          struct drm_afbc_framebuffer members
 399  *
 400  * @dev: DRM device
 401  * @afbc_fb: afbc-specific framebuffer
 402  * @mode_cmd: Metadata from the userspace framebuffer creation request
 403  * @afbc_fb: afbc framebuffer
 404  *
 405  * This function can be used by drivers which support afbc to complete
 406  * the preparation of struct drm_afbc_framebuffer. It must be called after
 407  * allocating the said struct and calling drm_gem_fb_init_with_funcs().
 408  * It is caller's responsibility to put afbc_fb->base.obj objects in case
 409  * the call is unsuccessful.
 410  *
 411  * Returns:
 412  * Zero on success or a negative error value on failure.
 413  */
 414 int drm_gem_fb_afbc_init(struct drm_device *dev,
 415                          const struct drm_mode_fb_cmd2 *mode_cmd,
 416                          struct drm_afbc_framebuffer *afbc_fb)
 417 {
 418         const struct drm_format_info *info;
 419         struct drm_gem_object **objs;
 420         int ret;
 421
 422         objs = afbc_fb->base.obj;
 423         info = drm_get_format_info(dev, mode_cmd);
 424         if (!info)
 425                 return -EINVAL;
 426
 427         ret = drm_gem_afbc_min_size(dev, mode_cmd, afbc_fb);
 428         if (ret < 0)
 429                 return ret;
 430
 431         if (objs[0]->size < afbc_fb->afbc_size)
 432                 return -EINVAL;
 433
 434         return 0;
 435 }
 436 EXPORT_SYMBOL_GPL(drm_gem_fb_afbc_init);
 437
 438 /**
 439  * drm_gem_fb_prepare_fb() - Prepare a GEM backed framebuffer
 440  * @plane: Plane
 441  * @state: Plane state the fence will be attached to
 442  *
 443  * This function extracts the exclusive fence from &drm_gem_object.resv and
 444  * attaches it to plane state for the atomic helper to wait on. This is
 445  * necessary to correctly implement implicit synchronization for any buffers
 446  * shared as a struct &dma_buf. This function can be used as the
 447  * &drm_plane_helper_funcs.prepare_fb callback.
 448  *
 449  * There is no need for &drm_plane_helper_funcs.cleanup_fb hook for simple
 450  * gem based framebuffer drivers which have their buffers always pinned in
 451  * memory.
 452  *
 453  * See drm_atomic_set_fence_for_plane() for a discussion of implicit and
 454  * explicit fencing in atomic modeset updates.
 455  */
 456 int drm_gem_fb_prepare_fb(struct drm_plane *plane,
 457                           struct drm_plane_state *state)
 458 {
 459         struct drm_gem_object *obj;
 460         struct dma_fence *fence;
 461
 462         if (!state->fb)
 463                 return 0;
 464
 465         obj = drm_gem_fb_get_obj(state->fb, 0);
 466         fence = dma_resv_get_excl_rcu(obj->resv);
 467         drm_atomic_set_fence_for_plane(state, fence);
 468
 469         return 0;
 470 }
 471 EXPORT_SYMBOL_GPL(drm_gem_fb_prepare_fb);
 472
 473 /**
 474  * drm_gem_fb_simple_display_pipe_prepare_fb - prepare_fb helper for
 475  *     &drm_simple_display_pipe
 476  * @pipe: Simple display pipe
 477  * @plane_state: Plane state
 478  *
 479  * This function uses drm_gem_fb_prepare_fb() to extract the exclusive fence
 480  * from &drm_gem_object.resv and attaches it to plane state for the atomic
 481  * helper to wait on. This is necessary to correctly implement implicit
 482  * synchronization for any buffers shared as a struct &dma_buf. Drivers can use
 483  * this as their &drm_simple_display_pipe_funcs.prepare_fb callback.
 484  *
 485  * See drm_atomic_set_fence_for_plane() for a discussion of implicit and
 486  * explicit fencing in atomic modeset updates.
 487  */
 488 int drm_gem_fb_simple_display_pipe_prepare_fb(struct drm_simple_display_pipe *pipe,
 489                                               struct drm_plane_state *plane_state)
 490 {
 491         return drm_gem_fb_prepare_fb(&pipe->plane, plane_state);
 492 }
 493 EXPORT_SYMBOL(drm_gem_fb_simple_display_pipe_prepare_fb);