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                 .keep_resv = true,
 210                 .resv = attach->dmabuf->resv,
 211                 .sg = table,
 212
 213         };
 214
 215         dma_resv_lock(params.resv, NULL);
 216
 217         ret = vmw_bo_create(dev_priv, &params, &vbo);
 218         if (ret != 0)
 219                 goto out_no_bo;
 220
 221         vbo->tbo.base.funcs = &vmw_gem_object_funcs;
 222
 223         gem = &vbo->tbo.base;
 224 out_no_bo:
 225         dma_resv_unlock(params.resv);
 226         return gem;
 227 }
 228
 229 int vmw_gem_object_create_ioctl(struct drm_device *dev, void *data,
 230                                 struct drm_file *filp)
 231 {
 232         struct vmw_private *dev_priv = vmw_priv(dev);
 233         union drm_vmw_alloc_dmabuf_arg *arg =
 234             (union drm_vmw_alloc_dmabuf_arg *)data;
 235         struct drm_vmw_alloc_dmabuf_req *req = &arg->req;
 236         struct drm_vmw_dmabuf_rep *rep = &arg->rep;
 237         struct vmw_bo *vbo;
 238         uint32_t handle;
 239         int ret;
 240
 241         ret = vmw_gem_object_create_with_handle(dev_priv, filp,
 242                                                 req->size, &handle, &vbo);
 243         if (ret)
 244                 goto out_no_bo;
 245
 246         rep->handle = handle;
 247         rep->map_handle = drm_vma_node_offset_addr(&vbo->tbo.base.vma_node);
 248         rep->cur_gmr_id = handle;
 249         rep->cur_gmr_offset = 0;
 250         /* drop reference from allocate - handle holds it now */
 251         drm_gem_object_put(&vbo->tbo.base);
 252 out_no_bo:
 253         return ret;
 254 }
 255
 256 #if defined(CONFIG_DEBUG_FS)
 257
 258 static void vmw_bo_print_info(int id, struct vmw_bo *bo, struct seq_file *m)
 259 {
 260         const char *placement;
 261         const char *type;
 262
 263         switch (bo->tbo.resource->mem_type) {
 264         case TTM_PL_SYSTEM:
 265                 placement = " CPU";
 266                 break;
 267         case VMW_PL_GMR:
 268                 placement = " GMR";
 269                 break;
 270         case VMW_PL_MOB:
 271                 placement = " MOB";
 272                 break;
 273         case VMW_PL_SYSTEM:
 274                 placement = "VCPU";
 275                 break;
 276         case TTM_PL_VRAM:
 277                 placement = "VRAM";
 278                 break;
 279         default:
 280                 placement = "None";
 281                 break;
 282         }
 283
 284         switch (bo->tbo.type) {
 285         case ttm_bo_type_device:
 286                 type = "device";
 287                 break;
 288         case ttm_bo_type_kernel:
 289                 type = "kernel";
 290                 break;
 291         case ttm_bo_type_sg:
 292                 type = "sg    ";
 293                 break;
 294         default:
 295                 type = "none  ";
 296                 break;
 297         }
 298
 299         seq_printf(m, "\t\t0x%08x: %12zu bytes %s, type = %s",
 300                    id, bo->tbo.base.size, placement, type);
 301         seq_printf(m, ", priority = %u, pin_count = %u, GEM refs = %d, TTM refs = %d",
 302                    bo->tbo.priority,
 303                    bo->tbo.pin_count,
 304                    kref_read(&bo->tbo.base.refcount),
 305                    kref_read(&bo->tbo.kref));
 306         seq_puts(m, "\n");
 307 }
 308
 309 static int vmw_debugfs_gem_info_show(struct seq_file *m, void *unused)
 310 {
 311         struct vmw_private *vdev = (struct vmw_private *)m->private;
 312         struct drm_device *dev = &vdev->drm;
 313         struct drm_file *file;
 314         int r;
 315
 316         r = mutex_lock_interruptible(&dev->filelist_mutex);
 317         if (r)
 318                 return r;
 319
 320         list_for_each_entry(file, &dev->filelist, lhead) {
 321                 struct task_struct *task;
 322                 struct drm_gem_object *gobj;
 323                 struct pid *pid;
 324                 int id;
 325
 326                 /*
 327                  * Although we have a valid reference on file->pid, that does
 328                  * not guarantee that the task_struct who called get_pid() is
 329                  * still alive (e.g. get_pid(current) => fork() => exit()).
 330                  * Therefore, we need to protect this ->comm access using RCU.
 331                  */
 332                 rcu_read_lock();
 333                 pid = rcu_dereference(file->pid);
 334                 task = pid_task(pid, PIDTYPE_TGID);
 335                 seq_printf(m, "pid %8d command %s:\n", pid_nr(pid),
 336                            task ? task->comm : "<unknown>");
 337                 rcu_read_unlock();
 338
 339                 spin_lock(&file->table_lock);
 340                 idr_for_each_entry(&file->object_idr, gobj, id) {
 341                         struct vmw_bo *bo = to_vmw_bo(gobj);
 342
 343                         vmw_bo_print_info(id, bo, m);
 344                 }
 345                 spin_unlock(&file->table_lock);
 346         }
 347
 348         mutex_unlock(&dev->filelist_mutex);
 349         return 0;
 350 }
 351
 352 DEFINE_SHOW_ATTRIBUTE(vmw_debugfs_gem_info);
 353
 354 #endif
 355
 356 void vmw_debugfs_gem_init(struct vmw_private *vdev)
 357 {
 358 #if defined(CONFIG_DEBUG_FS)
 359         struct drm_minor *minor = vdev->drm.primary;
 360         struct dentry *root = minor->debugfs_root;
 361
 362         debugfs_create_file("vmwgfx_gem_info", 0444, root, vdev,
 363                             &vmw_debugfs_gem_info_fops);
 364 #endif
 365 }