drivers/gpu/drm/vmwgfx/vmwgfx_gem.c

   1 /* SPDX-License-Identifier: GPL-2.0 OR MIT */
   2 /*
   3  * Copyright (c) 2021-2024 Broadcom. All Rights Reserved. The term
   4  * “Broadcom” refers to Broadcom Inc. and/or its subsidiaries.
   5  *
   6  * Permission is hereby granted, free of charge, to any person
   7  * obtaining a copy of this software and associated documentation
   8  * files (the "Software"), to deal in the Software without
   9  * restriction, including without limitation the rights to use, copy,
  10  * modify, merge, publish, distribute, sublicense, and/or sell copies
  11  * of the Software, and to permit persons to whom the Software is
  12  * furnished to do so, subject to the following conditions:
  13  *
  14  * The above copyright notice and this permission notice shall be
  15  * included in all copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  18  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  19  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  20  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  21  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  22  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  23  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  24  * SOFTWARE.
  25  *
  26  */
  27
  28 #include "vmwgfx_bo.h"
  29 #include "vmwgfx_drv.h"
  30
  31 #include "drm/drm_prime.h"
  32 #include "drm/drm_gem_ttm_helper.h"
  33
  34 #include <linux/debugfs.h>
  35
  36 static void vmw_gem_object_free(struct drm_gem_object *gobj)
  37 {
  38         struct ttm_buffer_object *bo = drm_gem_ttm_of_gem(gobj);
  39         if (bo)
  40                 ttm_bo_put(bo);
  41 }
  42
  43 static int vmw_gem_object_open(struct drm_gem_object *obj,
  44                                struct drm_file *file_priv)
  45 {
  46         return 0;
  47 }
  48
  49 static void vmw_gem_object_close(struct drm_gem_object *obj,
  50                                  struct drm_file *file_priv)
  51 {
  52 }
  53
  54 static int vmw_gem_object_pin(struct drm_gem_object *obj)
  55 {
  56         struct vmw_bo *vbo = to_vmw_bo(obj);
  57
  58         vmw_bo_pin_reserved(vbo, true);
  59
  60         return 0;
  61 }
  62
  63 static void vmw_gem_object_unpin(struct drm_gem_object *obj)
  64 {
  65         struct vmw_bo *vbo = to_vmw_bo(obj);
  66
  67         vmw_bo_pin_reserved(vbo, false);
  68 }
  69
  70 static struct sg_table *vmw_gem_object_get_sg_table(struct drm_gem_object *obj)
  71 {
  72         struct ttm_buffer_object *bo = drm_gem_ttm_of_gem(obj);
  73         struct vmw_ttm_tt *vmw_tt =
  74                 container_of(bo->ttm, struct vmw_ttm_tt, dma_ttm);
  75
  76         if (vmw_tt->vsgt.sgt)
  77                 return vmw_tt->vsgt.sgt;
  78
  79         return drm_prime_pages_to_sg(obj->dev, vmw_tt->dma_ttm.pages, vmw_tt->dma_ttm.num_pages);
  80 }
  81
  82 static int vmw_gem_vmap(struct drm_gem_object *obj, struct iosys_map *map)
  83 {
  84         struct ttm_buffer_object *bo = drm_gem_ttm_of_gem(obj);
  85         int ret;
  86
  87         if (obj->import_attach) {
  88                 ret = dma_buf_vmap(obj->import_attach->dmabuf, map);
  89                 if (!ret) {
  90                         if (drm_WARN_ON(obj->dev, map->is_iomem)) {
  91                                 dma_buf_vunmap(obj->import_attach->dmabuf, map);
  92                                 return -EIO;
  93                         }
  94                 }
  95         } else {
  96                 ret = ttm_bo_vmap(bo, map);
  97         }
  98
  99         return ret;
 100 }
 101
 102 static void vmw_gem_vunmap(struct drm_gem_object *obj, struct iosys_map *map)
 103 {
 104         if (obj->import_attach)
 105                 dma_buf_vunmap(obj->import_attach->dmabuf, map);
 106         else
 107                 drm_gem_ttm_vunmap(obj, map);
 108 }
 109
 110 static int vmw_gem_mmap(struct drm_gem_object *obj, struct vm_area_struct *vma)
 111 {
 112         int ret;
 113
 114         if (obj->import_attach) {
 115                 /*
 116                  * Reset both vm_ops and vm_private_data, so we don't end up with
 117                  * vm_ops pointing to our implementation if the dma-buf backend
 118                  * doesn't set those fields.
 119                  */
 120                 vma->vm_private_data = NULL;
 121                 vma->vm_ops = NULL;
 122
 123                 ret = dma_buf_mmap(obj->dma_buf, vma, 0);
 124
 125                 /* Drop the reference drm_gem_mmap_obj() acquired.*/
 126                 if (!ret)
 127                         drm_gem_object_put(obj);
 128
 129                 return ret;
 130         }
 131
 132         return drm_gem_ttm_mmap(obj, vma);
 133 }
 134
 135 static const struct vm_operations_struct vmw_vm_ops = {
 136         .pfn_mkwrite = vmw_bo_vm_mkwrite,
 137         .page_mkwrite = vmw_bo_vm_mkwrite,
 138         .fault = vmw_bo_vm_fault,
 139         .open = ttm_bo_vm_open,
 140         .close = ttm_bo_vm_close,
 141 };
 142
 143 static const struct drm_gem_object_funcs vmw_gem_object_funcs = {
 144         .free = vmw_gem_object_free,
 145         .open = vmw_gem_object_open,
 146         .close = vmw_gem_object_close,
 147         .print_info = drm_gem_ttm_print_info,
 148         .pin = vmw_gem_object_pin,
 149         .unpin = vmw_gem_object_unpin,
 150         .get_sg_table = vmw_gem_object_get_sg_table,
 151         .vmap = vmw_gem_vmap,
 152         .vunmap = vmw_gem_vunmap,
 153         .mmap = vmw_gem_mmap,
 154         .vm_ops = &vmw_vm_ops,
 155 };
 156
 157 int vmw_gem_object_create(struct vmw_private *vmw,
 158                           struct vmw_bo_params *params,
 159                           struct vmw_bo **p_vbo)
 160 {
 161         int ret = vmw_bo_create(vmw, params, p_vbo);
 162
 163         if (ret != 0)
 164                 goto out_no_bo;
 165
 166         (*p_vbo)->tbo.base.funcs = &vmw_gem_object_funcs;
 167 out_no_bo:
 168         return ret;
 169 }
 170
 171 int vmw_gem_object_create_with_handle(struct vmw_private *dev_priv,
 172                                       struct drm_file *filp,
 173                                       uint32_t size,
 174                                       uint32_t *handle,
 175                                       struct vmw_bo **p_vbo)
 176 {
 177         int ret;
 178         struct vmw_bo_params params = {
 179                 .domain = (dev_priv->has_mob) ? VMW_BO_DOMAIN_SYS : VMW_BO_DOMAIN_VRAM,
 180                 .busy_domain = VMW_BO_DOMAIN_SYS,
 181                 .bo_type = ttm_bo_type_device,
 182                 .size = size,
 183                 .pin = false
 184         };
 185
 186         ret = vmw_gem_object_create(dev_priv, &params, p_vbo);
 187         if (ret != 0)
 188                 goto out_no_bo;
 189
 190         ret = drm_gem_handle_create(filp, &(*p_vbo)->tbo.base, handle);
 191 out_no_bo:
 192         return ret;
 193 }
 194
 195 struct drm_gem_object *vmw_prime_import_sg_table(struct drm_device *dev,
 196                                                  struct dma_buf_attachment *attach,
 197                                                  struct sg_table *table)
 198 {
 199         int ret;
 200         struct vmw_private *dev_priv = vmw_priv(dev);
 201         struct drm_gem_object *gem = NULL;
 202         struct vmw_bo *vbo;
 203         struct vmw_bo_params params = {
 204                 .domain = (dev_priv->has_mob) ? VMW_BO_DOMAIN_SYS : VMW_BO_DOMAIN_VRAM,
 205                 .busy_domain = VMW_BO_DOMAIN_SYS,
 206                 .bo_type = ttm_bo_type_sg,
 207                 .size = attach->dmabuf->size,
 208                 .pin = false,
 209                 .resv = attach->dmabuf->resv,
 210                 .sg = table,
 211
 212         };
 213
 214         dma_resv_lock(params.resv, NULL);
 215
 216         ret = vmw_bo_create(dev_priv, &params, &vbo);
 217         if (ret != 0)
 218                 goto out_no_bo;
 219
 220         vbo->tbo.base.funcs = &vmw_gem_object_funcs;
 221
 222         gem = &vbo->tbo.base;
 223 out_no_bo:
 224         dma_resv_unlock(params.resv);
 225         return gem;
 226 }
 227
 228 int vmw_gem_object_create_ioctl(struct drm_device *dev, void *data,
 229                                 struct drm_file *filp)
 230 {
 231         struct vmw_private *dev_priv = vmw_priv(dev);
 232         union drm_vmw_alloc_dmabuf_arg *arg =
 233             (union drm_vmw_alloc_dmabuf_arg *)data;
 234         struct drm_vmw_alloc_dmabuf_req *req = &arg->req;
 235         struct drm_vmw_dmabuf_rep *rep = &arg->rep;
 236         struct vmw_bo *vbo;
 237         uint32_t handle;
 238         int ret;
 239
 240         ret = vmw_gem_object_create_with_handle(dev_priv, filp,
 241                                                 req->size, &handle, &vbo);
 242         if (ret)
 243                 goto out_no_bo;
 244
 245         rep->handle = handle;
 246         rep->map_handle = drm_vma_node_offset_addr(&vbo->tbo.base.vma_node);
 247         rep->cur_gmr_id = handle;
 248         rep->cur_gmr_offset = 0;
 249         /* drop reference from allocate - handle holds it now */
 250         drm_gem_object_put(&vbo->tbo.base);
 251 out_no_bo:
 252         return ret;
 253 }
 254
 255 #if defined(CONFIG_DEBUG_FS)
 256
 257 static void vmw_bo_print_info(int id, struct vmw_bo *bo, struct seq_file *m)
 258 {
 259         const char *placement;
 260         const char *type;
 261
 262         switch (bo->tbo.resource->mem_type) {
 263         case TTM_PL_SYSTEM:
 264                 placement = " CPU";
 265                 break;
 266         case VMW_PL_GMR:
 267                 placement = " GMR";
 268                 break;
 269         case VMW_PL_MOB:
 270                 placement = " MOB";
 271                 break;
 272         case VMW_PL_SYSTEM:
 273                 placement = "VCPU";
 274                 break;
 275         case TTM_PL_VRAM:
 276                 placement = "VRAM";
 277                 break;
 278         default:
 279                 placement = "None";
 280                 break;
 281         }
 282
 283         switch (bo->tbo.type) {
 284         case ttm_bo_type_device:
 285                 type = "device";
 286                 break;
 287         case ttm_bo_type_kernel:
 288                 type = "kernel";
 289                 break;
 290         case ttm_bo_type_sg:
 291                 type = "sg    ";
 292                 break;
 293         default:
 294                 type = "none  ";
 295                 break;
 296         }
 297
 298         seq_printf(m, "\t\t0x%08x: %12zu bytes %s, type = %s",
 299                    id, bo->tbo.base.size, placement, type);
 300         seq_printf(m, ", priority = %u, pin_count = %u, GEM refs = %d, TTM refs = %d",
 301                    bo->tbo.priority,
 302                    bo->tbo.pin_count,
 303                    kref_read(&bo->tbo.base.refcount),
 304                    kref_read(&bo->tbo.kref));
 305         seq_puts(m, "\n");
 306 }
 307
 308 static int vmw_debugfs_gem_info_show(struct seq_file *m, void *unused)
 309 {
 310         struct vmw_private *vdev = (struct vmw_private *)m->private;
 311         struct drm_device *dev = &vdev->drm;
 312         struct drm_file *file;
 313         int r;
 314
 315         r = mutex_lock_interruptible(&dev->filelist_mutex);
 316         if (r)
 317                 return r;
 318
 319         list_for_each_entry(file, &dev->filelist, lhead) {
 320                 struct task_struct *task;
 321                 struct drm_gem_object *gobj;
 322                 struct pid *pid;
 323                 int id;
 324
 325                 /*
 326                  * Although we have a valid reference on file->pid, that does
 327                  * not guarantee that the task_struct who called get_pid() is
 328                  * still alive (e.g. get_pid(current) => fork() => exit()).
 329                  * Therefore, we need to protect this ->comm access using RCU.
 330                  */
 331                 rcu_read_lock();
 332                 pid = rcu_dereference(file->pid);
 333                 task = pid_task(pid, PIDTYPE_TGID);
 334                 seq_printf(m, "pid %8d command %s:\n", pid_nr(pid),
 335                            task ? task->comm : "<unknown>");
 336                 rcu_read_unlock();
 337
 338                 spin_lock(&file->table_lock);
 339                 idr_for_each_entry(&file->object_idr, gobj, id) {
 340                         struct vmw_bo *bo = to_vmw_bo(gobj);
 341
 342                         vmw_bo_print_info(id, bo, m);
 343                 }
 344                 spin_unlock(&file->table_lock);
 345         }
 346
 347         mutex_unlock(&dev->filelist_mutex);
 348         return 0;
 349 }
 350
 351 DEFINE_SHOW_ATTRIBUTE(vmw_debugfs_gem_info);
 352
 353 #endif
 354
 355 void vmw_debugfs_gem_init(struct vmw_private *vdev)
 356 {
 357 #if defined(CONFIG_DEBUG_FS)
 358         struct drm_minor *minor = vdev->drm.primary;
 359         struct dentry *root = minor->debugfs_root;
 360
 361         debugfs_create_file("vmwgfx_gem_info", 0444, root, vdev,
 362                             &vmw_debugfs_gem_info_fops);
 363 #endif
 364 }