drm/v3d/v3d_bo.c

0001 // SPDX-License-Identifier: GPL-2.0+
0002 /* Copyright (C) 2015-2018 Broadcom */
0003
0004 /**
0005  * DOC: V3D GEM BO management support
0006  *
0007  * Compared to VC4 (V3D 2.x), V3D 3.3 introduces an MMU between the
0008  * GPU and the bus, allowing us to use shmem objects for our storage
0009  * instead of CMA.
0010  *
0011  * Physically contiguous objects may still be imported to V3D, but the
0012  * driver doesn't allocate physically contiguous objects on its own.
0013  * Display engines requiring physically contiguous allocations should
0014  * look into Mesa's "renderonly" support (as used by the Mesa pl111
0015  * driver) for an example of how to integrate with V3D.
0016  *
0017  * Long term, we should support evicting pages from the MMU when under
0018  * memory pressure (thus the v3d_bo_get_pages() refcounting), but
0019  * that's not a high priority since our systems tend to not have swap.
0020  */
0021
0022 #include <linux/dma-buf.h>
0023 #include <linux/pfn_t.h>
0024
0025 #include "v3d_drv.h"
0026 #include "uapi/drm/v3d_drm.h"
0027
0028 /* Called DRM core on the last userspace/kernel unreference of the
0029  * BO.
0030  */
0031 void v3d_free_object(struct drm_gem_object *obj)
0032 {
0033     struct v3d_dev *v3d = to_v3d_dev(obj->dev);
0034     struct v3d_bo *bo = to_v3d_bo(obj);
0035
0036     v3d_mmu_remove_ptes(bo);
0037
0038     mutex_lock(&v3d->bo_lock);
0039     v3d->bo_stats.num_allocated--;
0040     v3d->bo_stats.pages_allocated -= obj->size >> PAGE_SHIFT;
0041     mutex_unlock(&v3d->bo_lock);
0042
0043     spin_lock(&v3d->mm_lock);
0044     drm_mm_remove_node(&bo->node);
0045     spin_unlock(&v3d->mm_lock);
0046
0047     /* GPU execution may have dirtied any pages in the BO. */
0048     bo->base.pages_mark_dirty_on_put = true;
0049
0050     drm_gem_shmem_free(&bo->base);
0051 }
0052
0053 static const struct drm_gem_object_funcs v3d_gem_funcs = {
0054     .free = v3d_free_object,
0055     .print_info = drm_gem_shmem_object_print_info,
0056     .pin = drm_gem_shmem_object_pin,
0057     .unpin = drm_gem_shmem_object_unpin,
0058     .get_sg_table = drm_gem_shmem_object_get_sg_table,
0059     .vmap = drm_gem_shmem_object_vmap,
0060     .vunmap = drm_gem_shmem_object_vunmap,
0061     .mmap = drm_gem_shmem_object_mmap,
0062     .vm_ops = &drm_gem_shmem_vm_ops,
0063 };
0064
0065 /* gem_create_object function for allocating a BO struct and doing
0066  * early setup.
0067  */
0068 struct drm_gem_object *v3d_create_object(struct drm_device *dev, size_t size)
0069 {
0070     struct v3d_bo *bo;
0071     struct drm_gem_object *obj;
0072
0073     if (size == 0)
0074         return ERR_PTR(-EINVAL);
0075
0076     bo = kzalloc(sizeof(*bo), GFP_KERNEL);
0077     if (!bo)
0078         return ERR_PTR(-ENOMEM);
0079     obj = &bo->base.base;
0080
0081     obj->funcs = &v3d_gem_funcs;
0082     bo->base.map_wc = true;
0083     INIT_LIST_HEAD(&bo->unref_head);
0084
0085     return &bo->base.base;
0086 }
0087
0088 static int
0089 v3d_bo_create_finish(struct drm_gem_object *obj)
0090 {
0091     struct v3d_dev *v3d = to_v3d_dev(obj->dev);
0092     struct v3d_bo *bo = to_v3d_bo(obj);
0093     struct sg_table *sgt;
0094     int ret;
0095
0096     /* So far we pin the BO in the MMU for its lifetime, so use
0097      * shmem's helper for getting a lifetime sgt.
0098      */
0099     sgt = drm_gem_shmem_get_pages_sgt(&bo->base);
0100     if (IS_ERR(sgt))
0101         return PTR_ERR(sgt);
0102
0103     spin_lock(&v3d->mm_lock);
0104     /* Allocate the object's space in the GPU's page tables.
0105      * Inserting PTEs will happen later, but the offset is for the
0106      * lifetime of the BO.
0107      */
0108     ret = drm_mm_insert_node_generic(&v3d->mm, &bo->node,
0109                      obj->size >> PAGE_SHIFT,
0110                      GMP_GRANULARITY >> PAGE_SHIFT, 0, 0);
0111     spin_unlock(&v3d->mm_lock);
0112     if (ret)
0113         return ret;
0114
0115     /* Track stats for /debug/dri/n/bo_stats. */
0116     mutex_lock(&v3d->bo_lock);
0117     v3d->bo_stats.num_allocated++;
0118     v3d->bo_stats.pages_allocated += obj->size >> PAGE_SHIFT;
0119     mutex_unlock(&v3d->bo_lock);
0120
0121     v3d_mmu_insert_ptes(bo);
0122
0123     return 0;
0124 }
0125
0126 struct v3d_bo *v3d_bo_create(struct drm_device *dev, struct drm_file *file_priv,
0127                  size_t unaligned_size)
0128 {
0129     struct drm_gem_shmem_object *shmem_obj;
0130     struct v3d_bo *bo;
0131     int ret;
0132
0133     shmem_obj = drm_gem_shmem_create(dev, unaligned_size);
0134     if (IS_ERR(shmem_obj))
0135         return ERR_CAST(shmem_obj);
0136     bo = to_v3d_bo(&shmem_obj->base);
0137
0138     ret = v3d_bo_create_finish(&shmem_obj->base);
0139     if (ret)
0140         goto free_obj;
0141
0142     return bo;
0143
0144 free_obj:
0145     drm_gem_shmem_free(shmem_obj);
0146     return ERR_PTR(ret);
0147 }
0148
0149 struct drm_gem_object *
0150 v3d_prime_import_sg_table(struct drm_device *dev,
0151               struct dma_buf_attachment *attach,
0152               struct sg_table *sgt)
0153 {
0154     struct drm_gem_object *obj;
0155     int ret;
0156
0157     obj = drm_gem_shmem_prime_import_sg_table(dev, attach, sgt);
0158     if (IS_ERR(obj))
0159         return obj;
0160
0161     ret = v3d_bo_create_finish(obj);
0162     if (ret) {
0163         drm_gem_shmem_free(&to_v3d_bo(obj)->base);
0164         return ERR_PTR(ret);
0165     }
0166
0167     return obj;
0168 }
0169
0170 int v3d_create_bo_ioctl(struct drm_device *dev, void *data,
0171             struct drm_file *file_priv)
0172 {
0173     struct drm_v3d_create_bo *args = data;
0174     struct v3d_bo *bo = NULL;
0175     int ret;
0176
0177     if (args->flags != 0) {
0178         DRM_INFO("unknown create_bo flags: %d\n", args->flags);
0179         return -EINVAL;
0180     }
0181
0182     bo = v3d_bo_create(dev, file_priv, PAGE_ALIGN(args->size));
0183     if (IS_ERR(bo))
0184         return PTR_ERR(bo);
0185
0186     args->offset = bo->node.start << PAGE_SHIFT;
0187
0188     ret = drm_gem_handle_create(file_priv, &bo->base.base, &args->handle);
0189     drm_gem_object_put(&bo->base.base);
0190
0191     return ret;
0192 }
0193
0194 int v3d_mmap_bo_ioctl(struct drm_device *dev, void *data,
0195               struct drm_file *file_priv)
0196 {
0197     struct drm_v3d_mmap_bo *args = data;
0198     struct drm_gem_object *gem_obj;
0199
0200     if (args->flags != 0) {
0201         DRM_INFO("unknown mmap_bo flags: %d\n", args->flags);
0202         return -EINVAL;
0203     }
0204
0205     gem_obj = drm_gem_object_lookup(file_priv, args->handle);
0206     if (!gem_obj) {
0207         DRM_DEBUG("Failed to look up GEM BO %d\n", args->handle);
0208         return -ENOENT;
0209     }
0210
0211     args->offset = drm_vma_node_offset_addr(&gem_obj->vma_node);
0212     drm_gem_object_put(gem_obj);
0213
0214     return 0;
0215 }
0216
0217 int v3d_get_bo_offset_ioctl(struct drm_device *dev, void *data,
0218                 struct drm_file *file_priv)
0219 {
0220     struct drm_v3d_get_bo_offset *args = data;
0221     struct drm_gem_object *gem_obj;
0222     struct v3d_bo *bo;
0223
0224     gem_obj = drm_gem_object_lookup(file_priv, args->handle);
0225     if (!gem_obj) {
0226         DRM_DEBUG("Failed to look up GEM BO %d\n", args->handle);
0227         return -ENOENT;
0228     }
0229     bo = to_v3d_bo(gem_obj);
0230
0231     args->offset = bo->node.start << PAGE_SHIFT;
0232
0233     drm_gem_object_put(gem_obj);
0234     return 0;
0235 }