xref: /openbmc/linux/drivers/gpu/drm/qxl/qxl_ttm.c (revision b34e08d5)
1 /*
2  * Copyright 2013 Red Hat Inc.
3  *
4  * Permission is hereby granted, free of charge, to any person obtaining a
5  * copy of this software and associated documentation files (the "Software"),
6  * to deal in the Software without restriction, including without limitation
7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8  * and/or sell copies of the Software, and to permit persons to whom the
9  * Software is furnished to do so, subject to the following conditions:
10  *
11  * The above copyright notice and this permission notice shall be included in
12  * all copies or substantial portions of the Software.
13  *
14  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
17  * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
18  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
19  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
20  * OTHER DEALINGS IN THE SOFTWARE.
21  *
22  * Authors: Dave Airlie
23  *          Alon Levy
24  */
25 
26 #include <ttm/ttm_bo_api.h>
27 #include <ttm/ttm_bo_driver.h>
28 #include <ttm/ttm_placement.h>
29 #include <ttm/ttm_page_alloc.h>
30 #include <ttm/ttm_module.h>
31 #include <drm/drmP.h>
32 #include <drm/drm.h>
33 #include <drm/qxl_drm.h>
34 #include "qxl_drv.h"
35 #include "qxl_object.h"
36 
37 #include <linux/delay.h>
38 static int qxl_ttm_debugfs_init(struct qxl_device *qdev);
39 
40 static struct qxl_device *qxl_get_qdev(struct ttm_bo_device *bdev)
41 {
42 	struct qxl_mman *mman;
43 	struct qxl_device *qdev;
44 
45 	mman = container_of(bdev, struct qxl_mman, bdev);
46 	qdev = container_of(mman, struct qxl_device, mman);
47 	return qdev;
48 }
49 
50 static int qxl_ttm_mem_global_init(struct drm_global_reference *ref)
51 {
52 	return ttm_mem_global_init(ref->object);
53 }
54 
55 static void qxl_ttm_mem_global_release(struct drm_global_reference *ref)
56 {
57 	ttm_mem_global_release(ref->object);
58 }
59 
60 static int qxl_ttm_global_init(struct qxl_device *qdev)
61 {
62 	struct drm_global_reference *global_ref;
63 	int r;
64 
65 	qdev->mman.mem_global_referenced = false;
66 	global_ref = &qdev->mman.mem_global_ref;
67 	global_ref->global_type = DRM_GLOBAL_TTM_MEM;
68 	global_ref->size = sizeof(struct ttm_mem_global);
69 	global_ref->init = &qxl_ttm_mem_global_init;
70 	global_ref->release = &qxl_ttm_mem_global_release;
71 
72 	r = drm_global_item_ref(global_ref);
73 	if (r != 0) {
74 		DRM_ERROR("Failed setting up TTM memory accounting "
75 			  "subsystem.\n");
76 		return r;
77 	}
78 
79 	qdev->mman.bo_global_ref.mem_glob =
80 		qdev->mman.mem_global_ref.object;
81 	global_ref = &qdev->mman.bo_global_ref.ref;
82 	global_ref->global_type = DRM_GLOBAL_TTM_BO;
83 	global_ref->size = sizeof(struct ttm_bo_global);
84 	global_ref->init = &ttm_bo_global_init;
85 	global_ref->release = &ttm_bo_global_release;
86 	r = drm_global_item_ref(global_ref);
87 	if (r != 0) {
88 		DRM_ERROR("Failed setting up TTM BO subsystem.\n");
89 		drm_global_item_unref(&qdev->mman.mem_global_ref);
90 		return r;
91 	}
92 
93 	qdev->mman.mem_global_referenced = true;
94 	return 0;
95 }
96 
97 static void qxl_ttm_global_fini(struct qxl_device *qdev)
98 {
99 	if (qdev->mman.mem_global_referenced) {
100 		drm_global_item_unref(&qdev->mman.bo_global_ref.ref);
101 		drm_global_item_unref(&qdev->mman.mem_global_ref);
102 		qdev->mman.mem_global_referenced = false;
103 	}
104 }
105 
106 static struct vm_operations_struct qxl_ttm_vm_ops;
107 static const struct vm_operations_struct *ttm_vm_ops;
108 
109 static int qxl_ttm_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
110 {
111 	struct ttm_buffer_object *bo;
112 	struct qxl_device *qdev;
113 	int r;
114 
115 	bo = (struct ttm_buffer_object *)vma->vm_private_data;
116 	if (bo == NULL)
117 		return VM_FAULT_NOPAGE;
118 	qdev = qxl_get_qdev(bo->bdev);
119 	r = ttm_vm_ops->fault(vma, vmf);
120 	return r;
121 }
122 
123 int qxl_mmap(struct file *filp, struct vm_area_struct *vma)
124 {
125 	struct drm_file *file_priv;
126 	struct qxl_device *qdev;
127 	int r;
128 
129 	if (unlikely(vma->vm_pgoff < DRM_FILE_PAGE_OFFSET)) {
130 		pr_info("%s: vma->vm_pgoff (%ld) < DRM_FILE_PAGE_OFFSET\n",
131 			__func__, vma->vm_pgoff);
132 		return drm_mmap(filp, vma);
133 	}
134 
135 	file_priv = filp->private_data;
136 	qdev = file_priv->minor->dev->dev_private;
137 	if (qdev == NULL) {
138 		DRM_ERROR(
139 		 "filp->private_data->minor->dev->dev_private == NULL\n");
140 		return -EINVAL;
141 	}
142 	QXL_INFO(qdev, "%s: filp->private_data = 0x%p, vma->vm_pgoff = %lx\n",
143 		 __func__, filp->private_data, vma->vm_pgoff);
144 
145 	r = ttm_bo_mmap(filp, vma, &qdev->mman.bdev);
146 	if (unlikely(r != 0))
147 		return r;
148 	if (unlikely(ttm_vm_ops == NULL)) {
149 		ttm_vm_ops = vma->vm_ops;
150 		qxl_ttm_vm_ops = *ttm_vm_ops;
151 		qxl_ttm_vm_ops.fault = &qxl_ttm_fault;
152 	}
153 	vma->vm_ops = &qxl_ttm_vm_ops;
154 	return 0;
155 }
156 
157 static int qxl_invalidate_caches(struct ttm_bo_device *bdev, uint32_t flags)
158 {
159 	return 0;
160 }
161 
162 static int qxl_init_mem_type(struct ttm_bo_device *bdev, uint32_t type,
163 			     struct ttm_mem_type_manager *man)
164 {
165 	struct qxl_device *qdev;
166 
167 	qdev = qxl_get_qdev(bdev);
168 
169 	switch (type) {
170 	case TTM_PL_SYSTEM:
171 		/* System memory */
172 		man->flags = TTM_MEMTYPE_FLAG_MAPPABLE;
173 		man->available_caching = TTM_PL_MASK_CACHING;
174 		man->default_caching = TTM_PL_FLAG_CACHED;
175 		break;
176 	case TTM_PL_VRAM:
177 	case TTM_PL_PRIV0:
178 		/* "On-card" video ram */
179 		man->func = &ttm_bo_manager_func;
180 		man->gpu_offset = 0;
181 		man->flags = TTM_MEMTYPE_FLAG_FIXED |
182 			     TTM_MEMTYPE_FLAG_MAPPABLE;
183 		man->available_caching = TTM_PL_MASK_CACHING;
184 		man->default_caching = TTM_PL_FLAG_CACHED;
185 		break;
186 	default:
187 		DRM_ERROR("Unsupported memory type %u\n", (unsigned)type);
188 		return -EINVAL;
189 	}
190 	return 0;
191 }
192 
193 static void qxl_evict_flags(struct ttm_buffer_object *bo,
194 				struct ttm_placement *placement)
195 {
196 	struct qxl_bo *qbo;
197 	static u32 placements = TTM_PL_MASK_CACHING | TTM_PL_FLAG_SYSTEM;
198 
199 	if (!qxl_ttm_bo_is_qxl_bo(bo)) {
200 		placement->fpfn = 0;
201 		placement->lpfn = 0;
202 		placement->placement = &placements;
203 		placement->busy_placement = &placements;
204 		placement->num_placement = 1;
205 		placement->num_busy_placement = 1;
206 		return;
207 	}
208 	qbo = container_of(bo, struct qxl_bo, tbo);
209 	qxl_ttm_placement_from_domain(qbo, QXL_GEM_DOMAIN_CPU, false);
210 	*placement = qbo->placement;
211 }
212 
213 static int qxl_verify_access(struct ttm_buffer_object *bo, struct file *filp)
214 {
215 	struct qxl_bo *qbo = to_qxl_bo(bo);
216 
217 	return drm_vma_node_verify_access(&qbo->gem_base.vma_node, filp);
218 }
219 
220 static int qxl_ttm_io_mem_reserve(struct ttm_bo_device *bdev,
221 				  struct ttm_mem_reg *mem)
222 {
223 	struct ttm_mem_type_manager *man = &bdev->man[mem->mem_type];
224 	struct qxl_device *qdev = qxl_get_qdev(bdev);
225 
226 	mem->bus.addr = NULL;
227 	mem->bus.offset = 0;
228 	mem->bus.size = mem->num_pages << PAGE_SHIFT;
229 	mem->bus.base = 0;
230 	mem->bus.is_iomem = false;
231 	if (!(man->flags & TTM_MEMTYPE_FLAG_MAPPABLE))
232 		return -EINVAL;
233 	switch (mem->mem_type) {
234 	case TTM_PL_SYSTEM:
235 		/* system memory */
236 		return 0;
237 	case TTM_PL_VRAM:
238 		mem->bus.is_iomem = true;
239 		mem->bus.base = qdev->vram_base;
240 		mem->bus.offset = mem->start << PAGE_SHIFT;
241 		break;
242 	case TTM_PL_PRIV0:
243 		mem->bus.is_iomem = true;
244 		mem->bus.base = qdev->surfaceram_base;
245 		mem->bus.offset = mem->start << PAGE_SHIFT;
246 		break;
247 	default:
248 		return -EINVAL;
249 	}
250 	return 0;
251 }
252 
253 static void qxl_ttm_io_mem_free(struct ttm_bo_device *bdev,
254 				struct ttm_mem_reg *mem)
255 {
256 }
257 
258 /*
259  * TTM backend functions.
260  */
261 struct qxl_ttm_tt {
262 	struct ttm_dma_tt		ttm;
263 	struct qxl_device		*qdev;
264 	u64				offset;
265 };
266 
267 static int qxl_ttm_backend_bind(struct ttm_tt *ttm,
268 				struct ttm_mem_reg *bo_mem)
269 {
270 	struct qxl_ttm_tt *gtt = (void *)ttm;
271 
272 	gtt->offset = (unsigned long)(bo_mem->start << PAGE_SHIFT);
273 	if (!ttm->num_pages) {
274 		WARN(1, "nothing to bind %lu pages for mreg %p back %p!\n",
275 		     ttm->num_pages, bo_mem, ttm);
276 	}
277 	/* Not implemented */
278 	return -1;
279 }
280 
281 static int qxl_ttm_backend_unbind(struct ttm_tt *ttm)
282 {
283 	/* Not implemented */
284 	return -1;
285 }
286 
287 static void qxl_ttm_backend_destroy(struct ttm_tt *ttm)
288 {
289 	struct qxl_ttm_tt *gtt = (void *)ttm;
290 
291 	ttm_dma_tt_fini(&gtt->ttm);
292 	kfree(gtt);
293 }
294 
295 static struct ttm_backend_func qxl_backend_func = {
296 	.bind = &qxl_ttm_backend_bind,
297 	.unbind = &qxl_ttm_backend_unbind,
298 	.destroy = &qxl_ttm_backend_destroy,
299 };
300 
301 static int qxl_ttm_tt_populate(struct ttm_tt *ttm)
302 {
303 	int r;
304 
305 	if (ttm->state != tt_unpopulated)
306 		return 0;
307 
308 	r = ttm_pool_populate(ttm);
309 	if (r)
310 		return r;
311 
312 	return 0;
313 }
314 
315 static void qxl_ttm_tt_unpopulate(struct ttm_tt *ttm)
316 {
317 	ttm_pool_unpopulate(ttm);
318 }
319 
320 static struct ttm_tt *qxl_ttm_tt_create(struct ttm_bo_device *bdev,
321 					unsigned long size, uint32_t page_flags,
322 					struct page *dummy_read_page)
323 {
324 	struct qxl_device *qdev;
325 	struct qxl_ttm_tt *gtt;
326 
327 	qdev = qxl_get_qdev(bdev);
328 	gtt = kzalloc(sizeof(struct qxl_ttm_tt), GFP_KERNEL);
329 	if (gtt == NULL)
330 		return NULL;
331 	gtt->ttm.ttm.func = &qxl_backend_func;
332 	gtt->qdev = qdev;
333 	if (ttm_dma_tt_init(&gtt->ttm, bdev, size, page_flags,
334 			    dummy_read_page)) {
335 		kfree(gtt);
336 		return NULL;
337 	}
338 	return &gtt->ttm.ttm;
339 }
340 
341 static void qxl_move_null(struct ttm_buffer_object *bo,
342 			     struct ttm_mem_reg *new_mem)
343 {
344 	struct ttm_mem_reg *old_mem = &bo->mem;
345 
346 	BUG_ON(old_mem->mm_node != NULL);
347 	*old_mem = *new_mem;
348 	new_mem->mm_node = NULL;
349 }
350 
351 static int qxl_bo_move(struct ttm_buffer_object *bo,
352 		       bool evict, bool interruptible,
353 		       bool no_wait_gpu,
354 		       struct ttm_mem_reg *new_mem)
355 {
356 	struct ttm_mem_reg *old_mem = &bo->mem;
357 	if (old_mem->mem_type == TTM_PL_SYSTEM && bo->ttm == NULL) {
358 		qxl_move_null(bo, new_mem);
359 		return 0;
360 	}
361 	return ttm_bo_move_memcpy(bo, evict, no_wait_gpu, new_mem);
362 }
363 
364 
365 static int qxl_sync_obj_wait(void *sync_obj,
366 			     bool lazy, bool interruptible)
367 {
368 	struct qxl_fence *qfence = (struct qxl_fence *)sync_obj;
369 	int count = 0, sc = 0;
370 	struct qxl_bo *bo = container_of(qfence, struct qxl_bo, fence);
371 
372 	if (qfence->num_active_releases == 0)
373 		return 0;
374 
375 retry:
376 	if (sc == 0) {
377 		if (bo->type == QXL_GEM_DOMAIN_SURFACE)
378 			qxl_update_surface(qfence->qdev, bo);
379 	} else if (sc >= 1) {
380 		qxl_io_notify_oom(qfence->qdev);
381 	}
382 
383 	sc++;
384 
385 	for (count = 0; count < 10; count++) {
386 		bool ret;
387 		ret = qxl_queue_garbage_collect(qfence->qdev, true);
388 		if (ret == false)
389 			break;
390 
391 		if (qfence->num_active_releases == 0)
392 			return 0;
393 	}
394 
395 	if (qfence->num_active_releases) {
396 		bool have_drawable_releases = false;
397 		void **slot;
398 		struct radix_tree_iter iter;
399 		int release_id;
400 
401 		radix_tree_for_each_slot(slot, &qfence->tree, &iter, 0) {
402 			struct qxl_release *release;
403 
404 			release_id = iter.index;
405 			release = qxl_release_from_id_locked(qfence->qdev, release_id);
406 			if (release == NULL)
407 				continue;
408 
409 			if (release->type == QXL_RELEASE_DRAWABLE)
410 				have_drawable_releases = true;
411 		}
412 
413 		qxl_queue_garbage_collect(qfence->qdev, true);
414 
415 		if (have_drawable_releases || sc < 4) {
416 			if (sc > 2)
417 				/* back off */
418 				usleep_range(500, 1000);
419 			if (have_drawable_releases && sc > 300) {
420 				WARN(1, "sync obj %d still has outstanding releases %d %d %d %ld %d\n", sc, bo->surface_id, bo->is_primary, bo->pin_count, (unsigned long)bo->gem_base.size, qfence->num_active_releases);
421 				return -EBUSY;
422 			}
423 			goto retry;
424 		}
425 	}
426 	return 0;
427 }
428 
429 static int qxl_sync_obj_flush(void *sync_obj)
430 {
431 	return 0;
432 }
433 
434 static void qxl_sync_obj_unref(void **sync_obj)
435 {
436 	*sync_obj = NULL;
437 }
438 
439 static void *qxl_sync_obj_ref(void *sync_obj)
440 {
441 	return sync_obj;
442 }
443 
444 static bool qxl_sync_obj_signaled(void *sync_obj)
445 {
446 	struct qxl_fence *qfence = (struct qxl_fence *)sync_obj;
447 	return (qfence->num_active_releases == 0);
448 }
449 
450 static void qxl_bo_move_notify(struct ttm_buffer_object *bo,
451 			       struct ttm_mem_reg *new_mem)
452 {
453 	struct qxl_bo *qbo;
454 	struct qxl_device *qdev;
455 
456 	if (!qxl_ttm_bo_is_qxl_bo(bo))
457 		return;
458 	qbo = container_of(bo, struct qxl_bo, tbo);
459 	qdev = qbo->gem_base.dev->dev_private;
460 
461 	if (bo->mem.mem_type == TTM_PL_PRIV0 && qbo->surface_id)
462 		qxl_surface_evict(qdev, qbo, new_mem ? true : false);
463 }
464 
465 static struct ttm_bo_driver qxl_bo_driver = {
466 	.ttm_tt_create = &qxl_ttm_tt_create,
467 	.ttm_tt_populate = &qxl_ttm_tt_populate,
468 	.ttm_tt_unpopulate = &qxl_ttm_tt_unpopulate,
469 	.invalidate_caches = &qxl_invalidate_caches,
470 	.init_mem_type = &qxl_init_mem_type,
471 	.evict_flags = &qxl_evict_flags,
472 	.move = &qxl_bo_move,
473 	.verify_access = &qxl_verify_access,
474 	.io_mem_reserve = &qxl_ttm_io_mem_reserve,
475 	.io_mem_free = &qxl_ttm_io_mem_free,
476 	.sync_obj_signaled = &qxl_sync_obj_signaled,
477 	.sync_obj_wait = &qxl_sync_obj_wait,
478 	.sync_obj_flush = &qxl_sync_obj_flush,
479 	.sync_obj_unref = &qxl_sync_obj_unref,
480 	.sync_obj_ref = &qxl_sync_obj_ref,
481 	.move_notify = &qxl_bo_move_notify,
482 };
483 
484 
485 
486 int qxl_ttm_init(struct qxl_device *qdev)
487 {
488 	int r;
489 	int num_io_pages; /* != rom->num_io_pages, we include surface0 */
490 
491 	r = qxl_ttm_global_init(qdev);
492 	if (r)
493 		return r;
494 	/* No others user of address space so set it to 0 */
495 	r = ttm_bo_device_init(&qdev->mman.bdev,
496 			       qdev->mman.bo_global_ref.ref.object,
497 			       &qxl_bo_driver,
498 			       qdev->ddev->anon_inode->i_mapping,
499 			       DRM_FILE_PAGE_OFFSET, 0);
500 	if (r) {
501 		DRM_ERROR("failed initializing buffer object driver(%d).\n", r);
502 		return r;
503 	}
504 	/* NOTE: this includes the framebuffer (aka surface 0) */
505 	num_io_pages = qdev->rom->ram_header_offset / PAGE_SIZE;
506 	r = ttm_bo_init_mm(&qdev->mman.bdev, TTM_PL_VRAM,
507 			   num_io_pages);
508 	if (r) {
509 		DRM_ERROR("Failed initializing VRAM heap.\n");
510 		return r;
511 	}
512 	r = ttm_bo_init_mm(&qdev->mman.bdev, TTM_PL_PRIV0,
513 			   qdev->surfaceram_size / PAGE_SIZE);
514 	if (r) {
515 		DRM_ERROR("Failed initializing Surfaces heap.\n");
516 		return r;
517 	}
518 	DRM_INFO("qxl: %uM of VRAM memory size\n",
519 		 (unsigned)qdev->vram_size / (1024 * 1024));
520 	DRM_INFO("qxl: %luM of IO pages memory ready (VRAM domain)\n",
521 		 ((unsigned)num_io_pages * PAGE_SIZE) / (1024 * 1024));
522 	DRM_INFO("qxl: %uM of Surface memory size\n",
523 		 (unsigned)qdev->surfaceram_size / (1024 * 1024));
524 	r = qxl_ttm_debugfs_init(qdev);
525 	if (r) {
526 		DRM_ERROR("Failed to init debugfs\n");
527 		return r;
528 	}
529 	return 0;
530 }
531 
532 void qxl_ttm_fini(struct qxl_device *qdev)
533 {
534 	ttm_bo_clean_mm(&qdev->mman.bdev, TTM_PL_VRAM);
535 	ttm_bo_clean_mm(&qdev->mman.bdev, TTM_PL_PRIV0);
536 	ttm_bo_device_release(&qdev->mman.bdev);
537 	qxl_ttm_global_fini(qdev);
538 	DRM_INFO("qxl: ttm finalized\n");
539 }
540 
541 
542 #define QXL_DEBUGFS_MEM_TYPES 2
543 
544 #if defined(CONFIG_DEBUG_FS)
545 static int qxl_mm_dump_table(struct seq_file *m, void *data)
546 {
547 	struct drm_info_node *node = (struct drm_info_node *)m->private;
548 	struct drm_mm *mm = (struct drm_mm *)node->info_ent->data;
549 	struct drm_device *dev = node->minor->dev;
550 	struct qxl_device *rdev = dev->dev_private;
551 	int ret;
552 	struct ttm_bo_global *glob = rdev->mman.bdev.glob;
553 
554 	spin_lock(&glob->lru_lock);
555 	ret = drm_mm_dump_table(m, mm);
556 	spin_unlock(&glob->lru_lock);
557 	return ret;
558 }
559 #endif
560 
561 static int qxl_ttm_debugfs_init(struct qxl_device *qdev)
562 {
563 #if defined(CONFIG_DEBUG_FS)
564 	static struct drm_info_list qxl_mem_types_list[QXL_DEBUGFS_MEM_TYPES];
565 	static char qxl_mem_types_names[QXL_DEBUGFS_MEM_TYPES][32];
566 	unsigned i;
567 
568 	for (i = 0; i < QXL_DEBUGFS_MEM_TYPES; i++) {
569 		if (i == 0)
570 			sprintf(qxl_mem_types_names[i], "qxl_mem_mm");
571 		else
572 			sprintf(qxl_mem_types_names[i], "qxl_surf_mm");
573 		qxl_mem_types_list[i].name = qxl_mem_types_names[i];
574 		qxl_mem_types_list[i].show = &qxl_mm_dump_table;
575 		qxl_mem_types_list[i].driver_features = 0;
576 		if (i == 0)
577 			qxl_mem_types_list[i].data = qdev->mman.bdev.man[TTM_PL_VRAM].priv;
578 		else
579 			qxl_mem_types_list[i].data = qdev->mman.bdev.man[TTM_PL_PRIV0].priv;
580 
581 	}
582 	return qxl_debugfs_add_files(qdev, qxl_mem_types_list, i);
583 #else
584 	return 0;
585 #endif
586 }
587