drivers/gpu/drm/panthor/panthor_gem.c

   1 // SPDX-License-Identifier: GPL-2.0 or MIT
   2 /* Copyright 2019 Linaro, Ltd, Rob Herring <[email protected]> */
   3 /* Copyright 2023 Collabora ltd. */
   4
   5 #include <linux/dma-buf.h>
   6 #include <linux/dma-mapping.h>
   7 #include <linux/err.h>
   8 #include <linux/slab.h>
   9
  10 #include <drm/panthor_drm.h>
  11
  12 #include "panthor_device.h"
  13 #include "panthor_gem.h"
  14 #include "panthor_mmu.h"
  15
  16 static void panthor_gem_free_object(struct drm_gem_object *obj)
  17 {
  18         struct panthor_gem_object *bo = to_panthor_bo(obj);
  19         struct drm_gem_object *vm_root_gem = bo->exclusive_vm_root_gem;
  20
  21         drm_gem_free_mmap_offset(&bo->base.base);
  22         mutex_destroy(&bo->gpuva_list_lock);
  23         drm_gem_shmem_free(&bo->base);
  24         drm_gem_object_put(vm_root_gem);
  25 }
  26
  27 /**
  28  * panthor_kernel_bo_destroy() - Destroy a kernel buffer object
  29  * @vm: The VM this BO was mapped to.
  30  * @bo: Kernel buffer object to destroy. If NULL or an ERR_PTR(), the destruction
  31  * is skipped.
  32  */
  33 void panthor_kernel_bo_destroy(struct panthor_vm *vm,
  34                                struct panthor_kernel_bo *bo)
  35 {
  36         int ret;
  37
  38         if (IS_ERR_OR_NULL(bo))
  39                 return;
  40
  41         panthor_kernel_bo_vunmap(bo);
  42
  43         if (drm_WARN_ON(bo->obj->dev,
  44                         to_panthor_bo(bo->obj)->exclusive_vm_root_gem != panthor_vm_root_gem(vm)))
  45                 goto out_free_bo;
  46
  47         ret = panthor_vm_unmap_range(vm, bo->va_node.start,
  48                                      panthor_kernel_bo_size(bo));
  49         if (ret)
  50                 goto out_free_bo;
  51
  52         panthor_vm_free_va(vm, &bo->va_node);
  53         drm_gem_object_put(bo->obj);
  54
  55 out_free_bo:
  56         kfree(bo);
  57 }
  58
  59 /**
  60  * panthor_kernel_bo_create() - Create and map a GEM object to a VM
  61  * @ptdev: Device.
  62  * @vm: VM to map the GEM to. If NULL, the kernel object is not GPU mapped.
  63  * @size: Size of the buffer object.
  64  * @bo_flags: Combination of drm_panthor_bo_flags flags.
  65  * @vm_map_flags: Combination of drm_panthor_vm_bind_op_flags (only those
  66  * that are related to map operations).
  67  * @gpu_va: GPU address assigned when mapping to the VM.
  68  * If gpu_va == PANTHOR_VM_KERNEL_AUTO_VA, the virtual address will be
  69  * automatically allocated.
  70  *
  71  * Return: A valid pointer in case of success, an ERR_PTR() otherwise.
  72  */
  73 struct panthor_kernel_bo *
  74 panthor_kernel_bo_create(struct panthor_device *ptdev, struct panthor_vm *vm,
  75                          size_t size, u32 bo_flags, u32 vm_map_flags,
  76                          u64 gpu_va)
  77 {
  78         struct drm_gem_shmem_object *obj;
  79         struct panthor_kernel_bo *kbo;
  80         struct panthor_gem_object *bo;
  81         int ret;
  82
  83         if (drm_WARN_ON(&ptdev->base, !vm))
  84                 return ERR_PTR(-EINVAL);
  85
  86         kbo = kzalloc(sizeof(*kbo), GFP_KERNEL);
  87         if (!kbo)
  88                 return ERR_PTR(-ENOMEM);
  89
  90         obj = drm_gem_shmem_create(&ptdev->base, size);
  91         if (IS_ERR(obj)) {
  92                 ret = PTR_ERR(obj);
  93                 goto err_free_bo;
  94         }
  95
  96         bo = to_panthor_bo(&obj->base);
  97         size = obj->base.size;
  98         kbo->obj = &obj->base;
  99         bo->flags = bo_flags;
 100
 101         ret = panthor_vm_alloc_va(vm, gpu_va, size, &kbo->va_node);
 102         if (ret)
 103                 goto err_put_obj;
 104
 105         ret = panthor_vm_map_bo_range(vm, bo, 0, size, kbo->va_node.start, vm_map_flags);
 106         if (ret)
 107                 goto err_free_va;
 108
 109         bo->exclusive_vm_root_gem = panthor_vm_root_gem(vm);
 110         drm_gem_object_get(bo->exclusive_vm_root_gem);
 111         bo->base.base.resv = bo->exclusive_vm_root_gem->resv;
 112         return kbo;
 113
 114 err_free_va:
 115         panthor_vm_free_va(vm, &kbo->va_node);
 116
 117 err_put_obj:
 118         drm_gem_object_put(&obj->base);
 119
 120 err_free_bo:
 121         kfree(kbo);
 122         return ERR_PTR(ret);
 123 }
 124
 125 static int panthor_gem_mmap(struct drm_gem_object *obj, struct vm_area_struct *vma)
 126 {
 127         struct panthor_gem_object *bo = to_panthor_bo(obj);
 128
 129         /* Don't allow mmap on objects that have the NO_MMAP flag set. */
 130         if (bo->flags & DRM_PANTHOR_BO_NO_MMAP)
 131                 return -EINVAL;
 132
 133         return drm_gem_shmem_object_mmap(obj, vma);
 134 }
 135
 136 static struct dma_buf *
 137 panthor_gem_prime_export(struct drm_gem_object *obj, int flags)
 138 {
 139         /* We can't export GEMs that have an exclusive VM. */
 140         if (to_panthor_bo(obj)->exclusive_vm_root_gem)
 141                 return ERR_PTR(-EINVAL);
 142
 143         return drm_gem_prime_export(obj, flags);
 144 }
 145
 146 static const struct drm_gem_object_funcs panthor_gem_funcs = {
 147         .free = panthor_gem_free_object,
 148         .print_info = drm_gem_shmem_object_print_info,
 149         .pin = drm_gem_shmem_object_pin,
 150         .unpin = drm_gem_shmem_object_unpin,
 151         .get_sg_table = drm_gem_shmem_object_get_sg_table,
 152         .vmap = drm_gem_shmem_object_vmap,
 153         .vunmap = drm_gem_shmem_object_vunmap,
 154         .mmap = panthor_gem_mmap,
 155         .export = panthor_gem_prime_export,
 156         .vm_ops = &drm_gem_shmem_vm_ops,
 157 };
 158
 159 /**
 160  * panthor_gem_create_object - Implementation of driver->gem_create_object.
 161  * @ddev: DRM device
 162  * @size: Size in bytes of the memory the object will reference
 163  *
 164  * This lets the GEM helpers allocate object structs for us, and keep
 165  * our BO stats correct.
 166  */
 167 struct drm_gem_object *panthor_gem_create_object(struct drm_device *ddev, size_t size)
 168 {
 169         struct panthor_device *ptdev = container_of(ddev, struct panthor_device, base);
 170         struct panthor_gem_object *obj;
 171
 172         obj = kzalloc(sizeof(*obj), GFP_KERNEL);
 173         if (!obj)
 174                 return ERR_PTR(-ENOMEM);
 175
 176         obj->base.base.funcs = &panthor_gem_funcs;
 177         obj->base.map_wc = !ptdev->coherent;
 178         mutex_init(&obj->gpuva_list_lock);
 179         drm_gem_gpuva_set_lock(&obj->base.base, &obj->gpuva_list_lock);
 180
 181         return &obj->base.base;
 182 }
 183
 184 /**
 185  * panthor_gem_create_with_handle() - Create a GEM object and attach it to a handle.
 186  * @file: DRM file.
 187  * @ddev: DRM device.
 188  * @exclusive_vm: Exclusive VM. Not NULL if the GEM object can't be shared.
 189  * @size: Size of the GEM object to allocate.
 190  * @flags: Combination of drm_panthor_bo_flags flags.
 191  * @handle: Pointer holding the handle pointing to the new GEM object.
 192  *
 193  * Return: Zero on success
 194  */
 195 int
 196 panthor_gem_create_with_handle(struct drm_file *file,
 197                                struct drm_device *ddev,
 198                                struct panthor_vm *exclusive_vm,
 199                                u64 *size, u32 flags, u32 *handle)
 200 {
 201         int ret;
 202         struct drm_gem_shmem_object *shmem;
 203         struct panthor_gem_object *bo;
 204
 205         shmem = drm_gem_shmem_create(ddev, *size);
 206         if (IS_ERR(shmem))
 207                 return PTR_ERR(shmem);
 208
 209         bo = to_panthor_bo(&shmem->base);
 210         bo->flags = flags;
 211
 212         if (exclusive_vm) {
 213                 bo->exclusive_vm_root_gem = panthor_vm_root_gem(exclusive_vm);
 214                 drm_gem_object_get(bo->exclusive_vm_root_gem);
 215                 bo->base.base.resv = bo->exclusive_vm_root_gem->resv;
 216         }
 217
 218         /*
 219          * Allocate an id of idr table where the obj is registered
 220          * and handle has the id what user can see.
 221          */
 222         ret = drm_gem_handle_create(file, &shmem->base, handle);
 223         if (!ret)
 224                 *size = bo->base.base.size;
 225
 226         /* drop reference from allocate - handle holds it now. */
 227         drm_gem_object_put(&shmem->base);
 228
 229         return ret;
 230 }