drivers/gpu/drm/i915/gem/i915_gem_create.c

   1 // SPDX-License-Identifier: MIT
   2 /*
   3  * Copyright © 2020 Intel Corporation
   4  */
   5
   6 #include <drm/drm_fourcc.h>
   7
   8 #include "display/intel_display.h"
   9 #include "gem/i915_gem_ioctls.h"
  10 #include "gem/i915_gem_lmem.h"
  11 #include "gem/i915_gem_region.h"
  12 #include "pxp/intel_pxp.h"
  13
  14 #include "i915_drv.h"
  15 #include "i915_gem_create.h"
  16 #include "i915_trace.h"
  17 #include "i915_user_extensions.h"
  18
  19 static u32 object_max_page_size(struct intel_memory_region **placements,
  20                                 unsigned int n_placements)
  21 {
  22         u32 max_page_size = 0;
  23         int i;
  24
  25         for (i = 0; i < n_placements; i++) {
  26                 struct intel_memory_region *mr = placements[i];
  27
  28                 GEM_BUG_ON(!is_power_of_2(mr->min_page_size));
  29                 max_page_size = max_t(u32, max_page_size, mr->min_page_size);
  30         }
  31
  32         GEM_BUG_ON(!max_page_size);
  33         return max_page_size;
  34 }
  35
  36 static int object_set_placements(struct drm_i915_gem_object *obj,
  37                                  struct intel_memory_region **placements,
  38                                  unsigned int n_placements)
  39 {
  40         struct intel_memory_region **arr;
  41         unsigned int i;
  42
  43         GEM_BUG_ON(!n_placements);
  44
  45         /*
  46          * For the common case of one memory region, skip storing an
  47          * allocated array and just point at the region directly.
  48          */
  49         if (n_placements == 1) {
  50                 struct intel_memory_region *mr = placements[0];
  51                 struct drm_i915_private *i915 = mr->i915;
  52
  53                 obj->mm.placements = &i915->mm.regions[mr->id];
  54                 obj->mm.n_placements = 1;
  55         } else {
  56                 arr = kmalloc_array(n_placements,
  57                                     sizeof(struct intel_memory_region *),
  58                                     GFP_KERNEL);
  59                 if (!arr)
  60                         return -ENOMEM;
  61
  62                 for (i = 0; i < n_placements; i++)
  63                         arr[i] = placements[i];
  64
  65                 obj->mm.placements = arr;
  66                 obj->mm.n_placements = n_placements;
  67         }
  68
  69         return 0;
  70 }
  71
  72 static int i915_gem_publish(struct drm_i915_gem_object *obj,
  73                             struct drm_file *file,
  74                             u64 *size_p,
  75                             u32 *handle_p)
  76 {
  77         u64 size = obj->base.size;
  78         int ret;
  79
  80         ret = drm_gem_handle_create(file, &obj->base, handle_p);
  81         /* drop reference from allocate - handle holds it now */
  82         i915_gem_object_put(obj);
  83         if (ret)
  84                 return ret;
  85
  86         *size_p = size;
  87         return 0;
  88 }
  89
  90 static struct drm_i915_gem_object *
  91 __i915_gem_object_create_user_ext(struct drm_i915_private *i915, u64 size,
  92                                   struct intel_memory_region **placements,
  93                                   unsigned int n_placements,
  94                                   unsigned int ext_flags)
  95 {
  96         struct intel_memory_region *mr = placements[0];
  97         struct drm_i915_gem_object *obj;
  98         unsigned int flags;
  99         int ret;
 100
 101         i915_gem_flush_free_objects(i915);
 102
 103         size = round_up(size, object_max_page_size(placements, n_placements));
 104         if (size == 0)
 105                 return ERR_PTR(-EINVAL);
 106
 107         /* For most of the ABI (e.g. mmap) we think in system pages */
 108         GEM_BUG_ON(!IS_ALIGNED(size, PAGE_SIZE));
 109
 110         if (i915_gem_object_size_2big(size))
 111                 return ERR_PTR(-E2BIG);
 112
 113         obj = i915_gem_object_alloc();
 114         if (!obj)
 115                 return ERR_PTR(-ENOMEM);
 116
 117         ret = object_set_placements(obj, placements, n_placements);
 118         if (ret)
 119                 goto object_free;
 120
 121         /*
 122          * I915_BO_ALLOC_USER will make sure the object is cleared before
 123          * any user access.
 124          */
 125         flags = I915_BO_ALLOC_USER;
 126
 127         ret = mr->ops->init_object(mr, obj, I915_BO_INVALID_OFFSET, size, 0, flags);
 128         if (ret)
 129                 goto object_free;
 130
 131         GEM_BUG_ON(size != obj->base.size);
 132
 133         /* Add any flag set by create_ext options */
 134         obj->flags |= ext_flags;
 135
 136         trace_i915_gem_object_create(obj);
 137         return obj;
 138
 139 object_free:
 140         if (obj->mm.n_placements > 1)
 141                 kfree(obj->mm.placements);
 142         i915_gem_object_free(obj);
 143         return ERR_PTR(ret);
 144 }
 145
 146 /**
 147  * __i915_gem_object_create_user - Creates a new object using the same path as
 148  *                                 DRM_I915_GEM_CREATE_EXT
 149  * @i915: i915 private
 150  * @size: size of the buffer, in bytes
 151  * @placements: possible placement regions, in priority order
 152  * @n_placements: number of possible placement regions
 153  *
 154  * This function is exposed primarily for selftests and does very little
 155  * error checking.  It is assumed that the set of placement regions has
 156  * already been verified to be valid.
 157  */
 158 struct drm_i915_gem_object *
 159 __i915_gem_object_create_user(struct drm_i915_private *i915, u64 size,
 160                               struct intel_memory_region **placements,
 161                               unsigned int n_placements)
 162 {
 163         return __i915_gem_object_create_user_ext(i915, size, placements,
 164                                                  n_placements, 0);
 165 }
 166
 167 int
 168 i915_gem_dumb_create(struct drm_file *file,
 169                      struct drm_device *dev,
 170                      struct drm_mode_create_dumb *args)
 171 {
 172         struct drm_i915_gem_object *obj;
 173         struct intel_memory_region *mr;
 174         enum intel_memory_type mem_type;
 175         int cpp = DIV_ROUND_UP(args->bpp, 8);
 176         u32 format;
 177
 178         switch (cpp) {
 179         case 1:
 180                 format = DRM_FORMAT_C8;
 181                 break;
 182         case 2:
 183                 format = DRM_FORMAT_RGB565;
 184                 break;
 185         case 4:
 186                 format = DRM_FORMAT_XRGB8888;
 187                 break;
 188         default:
 189                 return -EINVAL;
 190         }
 191
 192         /* have to work out size/pitch and return them */
 193         args->pitch = ALIGN(args->width * cpp, 64);
 194
 195         /* align stride to page size so that we can remap */
 196         if (args->pitch > intel_plane_fb_max_stride(to_i915(dev), format,
 197                                                     DRM_FORMAT_MOD_LINEAR))
 198                 args->pitch = ALIGN(args->pitch, 4096);
 199
 200         if (args->pitch < args->width)
 201                 return -EINVAL;
 202
 203         args->size = mul_u32_u32(args->pitch, args->height);
 204
 205         mem_type = INTEL_MEMORY_SYSTEM;
 206         if (HAS_LMEM(to_i915(dev)))
 207                 mem_type = INTEL_MEMORY_LOCAL;
 208
 209         mr = intel_memory_region_by_type(to_i915(dev), mem_type);
 210
 211         obj = __i915_gem_object_create_user(to_i915(dev), args->size, &mr, 1);
 212         if (IS_ERR(obj))
 213                 return PTR_ERR(obj);
 214
 215         return i915_gem_publish(obj, file, &args->size, &args->handle);
 216 }
 217
 218 /**
 219  * i915_gem_create_ioctl - Creates a new mm object and returns a handle to it.
 220  * @dev: drm device pointer
 221  * @data: ioctl data blob
 222  * @file: drm file pointer
 223  */
 224 int
 225 i915_gem_create_ioctl(struct drm_device *dev, void *data,
 226                       struct drm_file *file)
 227 {
 228         struct drm_i915_private *i915 = to_i915(dev);
 229         struct drm_i915_gem_create *args = data;
 230         struct drm_i915_gem_object *obj;
 231         struct intel_memory_region *mr;
 232
 233         mr = intel_memory_region_by_type(i915, INTEL_MEMORY_SYSTEM);
 234
 235         obj = __i915_gem_object_create_user(i915, args->size, &mr, 1);
 236         if (IS_ERR(obj))
 237                 return PTR_ERR(obj);
 238
 239         return i915_gem_publish(obj, file, &args->size, &args->handle);
 240 }
 241
 242 struct create_ext {
 243         struct drm_i915_private *i915;
 244         struct intel_memory_region *placements[INTEL_REGION_UNKNOWN];
 245         unsigned int n_placements;
 246         unsigned int placement_mask;
 247         unsigned long flags;
 248         unsigned int pat_index;
 249 };
 250
 251 static void repr_placements(char *buf, size_t size,
 252                             struct intel_memory_region **placements,
 253                             int n_placements)
 254 {
 255         int i;
 256
 257         buf[0] = '\0';
 258
 259         for (i = 0; i < n_placements; i++) {
 260                 struct intel_memory_region *mr = placements[i];
 261                 int r;
 262
 263                 r = snprintf(buf, size, "\n  %s -> { class: %d, inst: %d }",
 264                              mr->name, mr->type, mr->instance);
 265                 if (r >= size)
 266                         return;
 267
 268                 buf += r;
 269                 size -= r;
 270         }
 271 }
 272
 273 static int set_placements(struct drm_i915_gem_create_ext_memory_regions *args,
 274                           struct create_ext *ext_data)
 275 {
 276         struct drm_i915_private *i915 = ext_data->i915;
 277         struct drm_i915_gem_memory_class_instance __user *uregions =
 278                 u64_to_user_ptr(args->regions);
 279         struct intel_memory_region *placements[INTEL_REGION_UNKNOWN];
 280         u32 mask;
 281         int i, ret = 0;
 282
 283         if (args->pad) {
 284                 drm_dbg(&i915->drm, "pad should be zero\n");
 285                 ret = -EINVAL;
 286         }
 287
 288         if (!args->num_regions) {
 289                 drm_dbg(&i915->drm, "num_regions is zero\n");
 290                 ret = -EINVAL;
 291         }
 292
 293         BUILD_BUG_ON(ARRAY_SIZE(i915->mm.regions) != ARRAY_SIZE(placements));
 294         BUILD_BUG_ON(ARRAY_SIZE(ext_data->placements) != ARRAY_SIZE(placements));
 295         if (args->num_regions > ARRAY_SIZE(i915->mm.regions)) {
 296                 drm_dbg(&i915->drm, "num_regions is too large\n");
 297                 ret = -EINVAL;
 298         }
 299
 300         if (ret)
 301                 return ret;
 302
 303         mask = 0;
 304         for (i = 0; i < args->num_regions; i++) {
 305                 struct drm_i915_gem_memory_class_instance region;
 306                 struct intel_memory_region *mr;
 307
 308                 if (copy_from_user(&region, uregions, sizeof(region)))
 309                         return -EFAULT;
 310
 311                 mr = intel_memory_region_lookup(i915,
 312                                                 region.memory_class,
 313                                                 region.memory_instance);
 314                 if (!mr || mr->private) {
 315                         drm_dbg(&i915->drm, "Device is missing region { class: %d, inst: %d } at index = %d\n",
 316                                 region.memory_class, region.memory_instance, i);
 317                         ret = -EINVAL;
 318                         goto out_dump;
 319                 }
 320
 321                 if (mask & BIT(mr->id)) {
 322                         drm_dbg(&i915->drm, "Found duplicate placement %s -> { class: %d, inst: %d } at index = %d\n",
 323                                 mr->name, region.memory_class,
 324                                 region.memory_instance, i);
 325                         ret = -EINVAL;
 326                         goto out_dump;
 327                 }
 328
 329                 placements[i] = mr;
 330                 mask |= BIT(mr->id);
 331
 332                 ++uregions;
 333         }
 334
 335         if (ext_data->n_placements) {
 336                 ret = -EINVAL;
 337                 goto out_dump;
 338         }
 339
 340         ext_data->n_placements = args->num_regions;
 341         for (i = 0; i < args->num_regions; i++)
 342                 ext_data->placements[i] = placements[i];
 343
 344         ext_data->placement_mask = mask;
 345         return 0;
 346
 347 out_dump:
 348         if (1) {
 349                 char buf[256];
 350
 351                 if (ext_data->n_placements) {
 352                         repr_placements(buf,
 353                                         sizeof(buf),
 354                                         ext_data->placements,
 355                                         ext_data->n_placements);
 356                         drm_dbg(&i915->drm,
 357                                 "Placements were already set in previous EXT. Existing placements: %s\n",
 358                                 buf);
 359                 }
 360
 361                 repr_placements(buf, sizeof(buf), placements, i);
 362                 drm_dbg(&i915->drm, "New placements(so far validated): %s\n", buf);
 363         }
 364
 365         return ret;
 366 }
 367
 368 static int ext_set_placements(struct i915_user_extension __user *base,
 369                               void *data)
 370 {
 371         struct drm_i915_gem_create_ext_memory_regions ext;
 372
 373         if (copy_from_user(&ext, base, sizeof(ext)))
 374                 return -EFAULT;
 375
 376         return set_placements(&ext, data);
 377 }
 378
 379 static int ext_set_protected(struct i915_user_extension __user *base, void *data)
 380 {
 381         struct drm_i915_gem_create_ext_protected_content ext;
 382         struct create_ext *ext_data = data;
 383
 384         if (copy_from_user(&ext, base, sizeof(ext)))
 385                 return -EFAULT;
 386
 387         if (ext.flags)
 388                 return -EINVAL;
 389
 390         if (!intel_pxp_is_enabled(ext_data->i915->pxp))
 391                 return -ENODEV;
 392
 393         ext_data->flags |= I915_BO_PROTECTED;
 394
 395         return 0;
 396 }
 397
 398 static int ext_set_pat(struct i915_user_extension __user *base, void *data)
 399 {
 400         struct create_ext *ext_data = data;
 401         struct drm_i915_private *i915 = ext_data->i915;
 402         struct drm_i915_gem_create_ext_set_pat ext;
 403         unsigned int max_pat_index;
 404
 405         BUILD_BUG_ON(sizeof(struct drm_i915_gem_create_ext_set_pat) !=
 406                      offsetofend(struct drm_i915_gem_create_ext_set_pat, rsvd));
 407
 408         /* Limiting the extension only to Xe_LPG and beyond */
 409         if (GRAPHICS_VER_FULL(i915) < IP_VER(12, 70))
 410                 return -ENODEV;
 411
 412         if (copy_from_user(&ext, base, sizeof(ext)))
 413                 return -EFAULT;
 414
 415         max_pat_index = INTEL_INFO(i915)->max_pat_index;
 416
 417         if (ext.pat_index > max_pat_index) {
 418                 drm_dbg(&i915->drm, "PAT index is invalid: %u\n",
 419                         ext.pat_index);
 420                 return -EINVAL;
 421         }
 422
 423         ext_data->pat_index = ext.pat_index;
 424
 425         return 0;
 426 }
 427
 428 static const i915_user_extension_fn create_extensions[] = {
 429         [I915_GEM_CREATE_EXT_MEMORY_REGIONS] = ext_set_placements,
 430         [I915_GEM_CREATE_EXT_PROTECTED_CONTENT] = ext_set_protected,
 431         [I915_GEM_CREATE_EXT_SET_PAT] = ext_set_pat,
 432 };
 433
 434 #define PAT_INDEX_NOT_SET       0xffff
 435 /**
 436  * i915_gem_create_ext_ioctl - Creates a new mm object and returns a handle to it.
 437  * @dev: drm device pointer
 438  * @data: ioctl data blob
 439  * @file: drm file pointer
 440  */
 441 int
 442 i915_gem_create_ext_ioctl(struct drm_device *dev, void *data,
 443                           struct drm_file *file)
 444 {
 445         struct drm_i915_private *i915 = to_i915(dev);
 446         struct drm_i915_gem_create_ext *args = data;
 447         struct create_ext ext_data = { .i915 = i915 };
 448         struct drm_i915_gem_object *obj;
 449         int ret;
 450
 451         if (args->flags & ~I915_GEM_CREATE_EXT_FLAG_NEEDS_CPU_ACCESS)
 452                 return -EINVAL;
 453
 454         ext_data.pat_index = PAT_INDEX_NOT_SET;
 455         ret = i915_user_extensions(u64_to_user_ptr(args->extensions),
 456                                    create_extensions,
 457                                    ARRAY_SIZE(create_extensions),
 458                                    &ext_data);
 459         if (ret)
 460                 return ret;
 461
 462         if (!ext_data.n_placements) {
 463                 ext_data.placements[0] =
 464                         intel_memory_region_by_type(i915, INTEL_MEMORY_SYSTEM);
 465                 ext_data.n_placements = 1;
 466         }
 467
 468         if (args->flags & I915_GEM_CREATE_EXT_FLAG_NEEDS_CPU_ACCESS) {
 469                 if (ext_data.n_placements == 1)
 470                         return -EINVAL;
 471
 472                 /*
 473                  * We always need to be able to spill to system memory, if we
 474                  * can't place in the mappable part of LMEM.
 475                  */
 476                 if (!(ext_data.placement_mask & BIT(INTEL_REGION_SMEM)))
 477                         return -EINVAL;
 478         } else {
 479                 if (ext_data.n_placements > 1 ||
 480                     ext_data.placements[0]->type != INTEL_MEMORY_SYSTEM)
 481                         ext_data.flags |= I915_BO_ALLOC_GPU_ONLY;
 482         }
 483
 484         obj = __i915_gem_object_create_user_ext(i915, args->size,
 485                                                 ext_data.placements,
 486                                                 ext_data.n_placements,
 487                                                 ext_data.flags);
 488         if (IS_ERR(obj))
 489                 return PTR_ERR(obj);
 490
 491         if (ext_data.pat_index != PAT_INDEX_NOT_SET) {
 492                 i915_gem_object_set_pat_index(obj, ext_data.pat_index);
 493                 /* Mark pat_index is set by UMD */
 494                 obj->pat_set_by_user = true;
 495         }
 496
 497         return i915_gem_publish(obj, file, &args->size, &args->handle);
 498 }