1 // SPDX-License-Identifier: GPL-2.0 2 /* Copyright 2019 Linaro, Ltd, Rob Herring <robh@kernel.org> */ 3 4 #include <linux/err.h> 5 #include <linux/slab.h> 6 #include <linux/dma-buf.h> 7 #include <linux/dma-mapping.h> 8 9 #include <drm/panfrost_drm.h> 10 #include "panfrost_device.h" 11 #include "panfrost_gem.h" 12 #include "panfrost_mmu.h" 13 14 /* Called DRM core on the last userspace/kernel unreference of the 15 * BO. 16 */ 17 static void panfrost_gem_free_object(struct drm_gem_object *obj) 18 { 19 struct panfrost_gem_object *bo = to_panfrost_bo(obj); 20 struct panfrost_device *pfdev = obj->dev->dev_private; 21 22 if (bo->sgts) { 23 int i; 24 int n_sgt = bo->base.base.size / SZ_2M; 25 26 for (i = 0; i < n_sgt; i++) { 27 if (bo->sgts[i].sgl) { 28 dma_unmap_sg(pfdev->dev, bo->sgts[i].sgl, 29 bo->sgts[i].nents, DMA_BIDIRECTIONAL); 30 sg_free_table(&bo->sgts[i]); 31 } 32 } 33 kfree(bo->sgts); 34 } 35 36 mutex_lock(&pfdev->shrinker_lock); 37 if (!list_empty(&bo->base.madv_list)) 38 list_del(&bo->base.madv_list); 39 mutex_unlock(&pfdev->shrinker_lock); 40 41 drm_gem_shmem_free_object(obj); 42 } 43 44 static int panfrost_gem_open(struct drm_gem_object *obj, struct drm_file *file_priv) 45 { 46 int ret; 47 size_t size = obj->size; 48 u64 align; 49 struct panfrost_gem_object *bo = to_panfrost_bo(obj); 50 struct panfrost_device *pfdev = obj->dev->dev_private; 51 unsigned long color = bo->noexec ? PANFROST_BO_NOEXEC : 0; 52 53 /* 54 * Executable buffers cannot cross a 16MB boundary as the program 55 * counter is 24-bits. We assume executable buffers will be less than 56 * 16MB and aligning executable buffers to their size will avoid 57 * crossing a 16MB boundary. 58 */ 59 if (!bo->noexec) 60 align = size >> PAGE_SHIFT; 61 else 62 align = size >= SZ_2M ? SZ_2M >> PAGE_SHIFT : 0; 63 64 spin_lock(&pfdev->mm_lock); 65 ret = drm_mm_insert_node_generic(&pfdev->mm, &bo->node, 66 size >> PAGE_SHIFT, align, color, 0); 67 if (ret) 68 goto out; 69 70 if (!bo->is_heap) { 71 ret = panfrost_mmu_map(bo); 72 if (ret) 73 drm_mm_remove_node(&bo->node); 74 } 75 out: 76 spin_unlock(&pfdev->mm_lock); 77 return ret; 78 } 79 80 static void panfrost_gem_close(struct drm_gem_object *obj, struct drm_file *file_priv) 81 { 82 struct panfrost_gem_object *bo = to_panfrost_bo(obj); 83 struct panfrost_device *pfdev = obj->dev->dev_private; 84 85 if (bo->is_mapped) 86 panfrost_mmu_unmap(bo); 87 88 spin_lock(&pfdev->mm_lock); 89 if (drm_mm_node_allocated(&bo->node)) 90 drm_mm_remove_node(&bo->node); 91 spin_unlock(&pfdev->mm_lock); 92 } 93 94 static int panfrost_gem_pin(struct drm_gem_object *obj) 95 { 96 if (to_panfrost_bo(obj)->is_heap) 97 return -EINVAL; 98 99 return drm_gem_shmem_pin(obj); 100 } 101 102 static const struct drm_gem_object_funcs panfrost_gem_funcs = { 103 .free = panfrost_gem_free_object, 104 .open = panfrost_gem_open, 105 .close = panfrost_gem_close, 106 .print_info = drm_gem_shmem_print_info, 107 .pin = panfrost_gem_pin, 108 .unpin = drm_gem_shmem_unpin, 109 .get_sg_table = drm_gem_shmem_get_sg_table, 110 .vmap = drm_gem_shmem_vmap, 111 .vunmap = drm_gem_shmem_vunmap, 112 .vm_ops = &drm_gem_shmem_vm_ops, 113 }; 114 115 /** 116 * panfrost_gem_create_object - Implementation of driver->gem_create_object. 117 * @dev: DRM device 118 * @size: Size in bytes of the memory the object will reference 119 * 120 * This lets the GEM helpers allocate object structs for us, and keep 121 * our BO stats correct. 122 */ 123 struct drm_gem_object *panfrost_gem_create_object(struct drm_device *dev, size_t size) 124 { 125 struct panfrost_gem_object *obj; 126 127 obj = kzalloc(sizeof(*obj), GFP_KERNEL); 128 if (!obj) 129 return NULL; 130 131 obj->base.base.funcs = &panfrost_gem_funcs; 132 133 return &obj->base.base; 134 } 135 136 struct panfrost_gem_object * 137 panfrost_gem_create_with_handle(struct drm_file *file_priv, 138 struct drm_device *dev, size_t size, 139 u32 flags, 140 uint32_t *handle) 141 { 142 int ret; 143 struct drm_gem_shmem_object *shmem; 144 struct panfrost_gem_object *bo; 145 146 /* Round up heap allocations to 2MB to keep fault handling simple */ 147 if (flags & PANFROST_BO_HEAP) 148 size = roundup(size, SZ_2M); 149 150 shmem = drm_gem_shmem_create(dev, size); 151 if (IS_ERR(shmem)) 152 return ERR_CAST(shmem); 153 154 bo = to_panfrost_bo(&shmem->base); 155 bo->noexec = !!(flags & PANFROST_BO_NOEXEC); 156 bo->is_heap = !!(flags & PANFROST_BO_HEAP); 157 158 /* 159 * Allocate an id of idr table where the obj is registered 160 * and handle has the id what user can see. 161 */ 162 ret = drm_gem_handle_create(file_priv, &shmem->base, handle); 163 /* drop reference from allocate - handle holds it now. */ 164 drm_gem_object_put_unlocked(&shmem->base); 165 if (ret) 166 return ERR_PTR(ret); 167 168 return bo; 169 } 170 171 struct drm_gem_object * 172 panfrost_gem_prime_import_sg_table(struct drm_device *dev, 173 struct dma_buf_attachment *attach, 174 struct sg_table *sgt) 175 { 176 struct drm_gem_object *obj; 177 struct panfrost_gem_object *bo; 178 179 obj = drm_gem_shmem_prime_import_sg_table(dev, attach, sgt); 180 if (IS_ERR(obj)) 181 return ERR_CAST(obj); 182 183 bo = to_panfrost_bo(obj); 184 bo->noexec = true; 185 186 return obj; 187 } 188