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, ¶ms, 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, ¶ms, &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 } 365