499 lines · c
1// SPDX-License-Identifier: MIT2/*3 * Copyright © 2020 Intel Corporation4 */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 19static 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 36static 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 an47 * 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 72static 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 90static 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 before123 * 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 139object_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 as148 * DRM_I915_GEM_CREATE_EXT149 * @i915: i915 private150 * @size: size of the buffer, in bytes151 * @placements: possible placement regions, in priority order152 * @n_placements: number of possible placement regions153 *154 * This function is exposed primarily for selftests and does very little155 * error checking. It is assumed that the set of placement regions has156 * already been verified to be valid.157 */158struct 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 167int168i915_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 pointer221 * @data: ioctl data blob222 * @file: drm file pointer223 */224int225i915_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 242struct 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 251static 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 273static 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(®ion, 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 347out_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 368static 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 379static 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 398static 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 428static 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 0xffff435/**436 * i915_gem_create_ext_ioctl - Creates a new mm object and returns a handle to it.437 * @dev: drm device pointer438 * @data: ioctl data blob439 * @file: drm file pointer440 */441int442i915_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 we474 * 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}499