2 * Copyright 2009 Jerome Glisse.
5 * Permission is hereby granted, free of charge, to any person obtaining a
6 * copy of this software and associated documentation files (the
7 * "Software"), to deal in the Software without restriction, including
8 * without limitation the rights to use, copy, modify, merge, publish,
9 * distribute, sub license, and/or sell copies of the Software, and to
10 * permit persons to whom the Software is furnished to do so, subject to
11 * the following conditions:
13 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
16 * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
17 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
18 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
19 * USE OR OTHER DEALINGS IN THE SOFTWARE.
21 * The above copyright notice and this permission notice (including the
22 * next paragraph) shall be included in all copies or substantial portions
28 * Jerome Glisse <glisse@freedesktop.org>
29 * Thomas Hellstrom <thomas-at-tungstengraphics-dot-com>
32 #include <linux/list.h>
34 #include "radeon_drm.h"
37 struct radeon_object {
38 struct ttm_buffer_object tobj;
39 struct list_head list;
40 struct radeon_device *rdev;
41 struct drm_gem_object *gobj;
42 struct ttm_bo_kmap_obj kmap;
47 uint32_t tiling_flags;
52 int radeon_ttm_init(struct radeon_device *rdev);
53 void radeon_ttm_fini(struct radeon_device *rdev);
56 * To exclude mutual BO access we rely on bo_reserve exclusion, as all
57 * function are calling it.
60 static int radeon_object_reserve(struct radeon_object *robj, bool interruptible)
62 return ttm_bo_reserve(&robj->tobj, interruptible, false, false, 0);
65 static void radeon_object_unreserve(struct radeon_object *robj)
67 ttm_bo_unreserve(&robj->tobj);
70 static void radeon_ttm_object_object_destroy(struct ttm_buffer_object *tobj)
72 struct radeon_object *robj;
74 robj = container_of(tobj, struct radeon_object, tobj);
75 list_del_init(&robj->list);
76 radeon_object_clear_surface_reg(robj);
80 static inline void radeon_object_gpu_addr(struct radeon_object *robj)
82 /* Default gpu address */
83 robj->gpu_addr = 0xFFFFFFFFFFFFFFFFULL;
84 if (robj->tobj.mem.mm_node == NULL) {
87 robj->gpu_addr = ((u64)robj->tobj.mem.mm_node->start) << PAGE_SHIFT;
88 switch (robj->tobj.mem.mem_type) {
90 robj->gpu_addr += (u64)robj->rdev->mc.vram_location;
93 robj->gpu_addr += (u64)robj->rdev->mc.gtt_location;
96 DRM_ERROR("Unknown placement %d\n", robj->tobj.mem.mem_type);
97 robj->gpu_addr = 0xFFFFFFFFFFFFFFFFULL;
102 static inline uint32_t radeon_object_flags_from_domain(uint32_t domain)
105 if (domain & RADEON_GEM_DOMAIN_VRAM) {
106 flags |= TTM_PL_FLAG_VRAM;
108 if (domain & RADEON_GEM_DOMAIN_GTT) {
109 flags |= TTM_PL_FLAG_TT;
111 if (domain & RADEON_GEM_DOMAIN_CPU) {
112 flags |= TTM_PL_FLAG_SYSTEM;
115 flags |= TTM_PL_FLAG_SYSTEM;
120 int radeon_object_create(struct radeon_device *rdev,
121 struct drm_gem_object *gobj,
126 struct radeon_object **robj_ptr)
128 struct radeon_object *robj;
129 enum ttm_bo_type type;
133 if (unlikely(rdev->mman.bdev.dev_mapping == NULL)) {
134 rdev->mman.bdev.dev_mapping = rdev->ddev->dev_mapping;
137 type = ttm_bo_type_kernel;
139 type = ttm_bo_type_device;
142 robj = kzalloc(sizeof(struct radeon_object), GFP_KERNEL);
148 robj->surface_reg = -1;
149 INIT_LIST_HEAD(&robj->list);
151 flags = radeon_object_flags_from_domain(domain);
152 r = ttm_buffer_object_init(&rdev->mman.bdev, &robj->tobj, size, type, flags,
153 0, 0, false, NULL, size,
154 &radeon_ttm_object_object_destroy);
155 if (unlikely(r != 0)) {
156 /* ttm call radeon_ttm_object_object_destroy if error happen */
157 DRM_ERROR("Failed to allocate TTM object (%ld, 0x%08X, %u)\n",
163 list_add_tail(&robj->list, &rdev->gem.objects);
168 int radeon_object_kmap(struct radeon_object *robj, void **ptr)
172 spin_lock(&robj->tobj.lock);
177 spin_unlock(&robj->tobj.lock);
180 spin_unlock(&robj->tobj.lock);
181 r = ttm_bo_kmap(&robj->tobj, 0, robj->tobj.num_pages, &robj->kmap);
185 spin_lock(&robj->tobj.lock);
186 robj->kptr = ttm_kmap_obj_virtual(&robj->kmap, &robj->is_iomem);
187 spin_unlock(&robj->tobj.lock);
194 void radeon_object_kunmap(struct radeon_object *robj)
196 spin_lock(&robj->tobj.lock);
197 if (robj->kptr == NULL) {
198 spin_unlock(&robj->tobj.lock);
202 spin_unlock(&robj->tobj.lock);
203 ttm_bo_kunmap(&robj->kmap);
206 void radeon_object_unref(struct radeon_object **robj)
208 struct ttm_buffer_object *tobj;
210 if ((*robj) == NULL) {
213 tobj = &((*robj)->tobj);
220 int radeon_object_mmap(struct radeon_object *robj, uint64_t *offset)
222 *offset = robj->tobj.addr_space_offset;
226 int radeon_object_pin(struct radeon_object *robj, uint32_t domain,
233 flags = radeon_object_flags_from_domain(domain);
234 spin_lock(&robj->tobj.lock);
235 if (robj->pin_count) {
237 if (gpu_addr != NULL) {
238 *gpu_addr = robj->gpu_addr;
240 spin_unlock(&robj->tobj.lock);
243 spin_unlock(&robj->tobj.lock);
244 r = radeon_object_reserve(robj, false);
245 if (unlikely(r != 0)) {
246 DRM_ERROR("radeon: failed to reserve object for pinning it.\n");
249 tmp = robj->tobj.mem.placement;
250 ttm_flag_masked(&tmp, flags, TTM_PL_MASK_MEM);
251 robj->tobj.proposed_placement = tmp | TTM_PL_FLAG_NO_EVICT | TTM_PL_MASK_CACHING;
252 r = ttm_buffer_object_validate(&robj->tobj,
253 robj->tobj.proposed_placement,
255 radeon_object_gpu_addr(robj);
256 if (gpu_addr != NULL) {
257 *gpu_addr = robj->gpu_addr;
260 if (unlikely(r != 0)) {
261 DRM_ERROR("radeon: failed to pin object.\n");
263 radeon_object_unreserve(robj);
267 void radeon_object_unpin(struct radeon_object *robj)
272 spin_lock(&robj->tobj.lock);
273 if (!robj->pin_count) {
274 spin_unlock(&robj->tobj.lock);
275 printk(KERN_WARNING "Unpin not necessary for %p !\n", robj);
279 if (robj->pin_count) {
280 spin_unlock(&robj->tobj.lock);
283 spin_unlock(&robj->tobj.lock);
284 r = radeon_object_reserve(robj, false);
285 if (unlikely(r != 0)) {
286 DRM_ERROR("radeon: failed to reserve object for unpinning it.\n");
289 flags = robj->tobj.mem.placement;
290 robj->tobj.proposed_placement = flags & ~TTM_PL_FLAG_NO_EVICT;
291 r = ttm_buffer_object_validate(&robj->tobj,
292 robj->tobj.proposed_placement,
294 if (unlikely(r != 0)) {
295 DRM_ERROR("radeon: failed to unpin buffer.\n");
297 radeon_object_unreserve(robj);
300 int radeon_object_wait(struct radeon_object *robj)
304 /* FIXME: should use block reservation instead */
305 r = radeon_object_reserve(robj, true);
306 if (unlikely(r != 0)) {
307 DRM_ERROR("radeon: failed to reserve object for waiting.\n");
310 spin_lock(&robj->tobj.lock);
311 if (robj->tobj.sync_obj) {
312 r = ttm_bo_wait(&robj->tobj, true, false, false);
314 spin_unlock(&robj->tobj.lock);
315 radeon_object_unreserve(robj);
319 int radeon_object_evict_vram(struct radeon_device *rdev)
321 if (rdev->flags & RADEON_IS_IGP) {
322 /* Useless to evict on IGP chips */
325 return ttm_bo_evict_mm(&rdev->mman.bdev, TTM_PL_VRAM);
328 void radeon_object_force_delete(struct radeon_device *rdev)
330 struct radeon_object *robj, *n;
331 struct drm_gem_object *gobj;
333 if (list_empty(&rdev->gem.objects)) {
336 DRM_ERROR("Userspace still has active objects !\n");
337 list_for_each_entry_safe(robj, n, &rdev->gem.objects, list) {
338 mutex_lock(&rdev->ddev->struct_mutex);
340 DRM_ERROR("Force free for (%p,%p,%lu,%lu)\n",
341 gobj, robj, (unsigned long)gobj->size,
342 *((unsigned long *)&gobj->refcount));
343 list_del_init(&robj->list);
344 radeon_object_unref(&robj);
345 gobj->driver_private = NULL;
346 drm_gem_object_unreference(gobj);
347 mutex_unlock(&rdev->ddev->struct_mutex);
351 int radeon_object_init(struct radeon_device *rdev)
353 return radeon_ttm_init(rdev);
356 void radeon_object_fini(struct radeon_device *rdev)
358 radeon_ttm_fini(rdev);
361 void radeon_object_list_add_object(struct radeon_object_list *lobj,
362 struct list_head *head)
365 list_add(&lobj->list, head);
367 list_add_tail(&lobj->list, head);
371 int radeon_object_list_reserve(struct list_head *head)
373 struct radeon_object_list *lobj;
377 list_for_each(i, head) {
378 lobj = list_entry(i, struct radeon_object_list, list);
379 if (!lobj->robj->pin_count) {
380 r = radeon_object_reserve(lobj->robj, true);
381 if (unlikely(r != 0)) {
382 DRM_ERROR("radeon: failed to reserve object.\n");
391 void radeon_object_list_unreserve(struct list_head *head)
393 struct radeon_object_list *lobj;
396 list_for_each(i, head) {
397 lobj = list_entry(i, struct radeon_object_list, list);
398 if (!lobj->robj->pin_count) {
399 radeon_object_unreserve(lobj->robj);
405 int radeon_object_list_validate(struct list_head *head, void *fence)
407 struct radeon_object_list *lobj;
408 struct radeon_object *robj;
409 struct radeon_fence *old_fence = NULL;
414 r = radeon_object_list_reserve(head);
415 if (unlikely(r != 0)) {
416 radeon_object_list_unreserve(head);
419 list_for_each(i, head) {
420 lobj = list_entry(i, struct radeon_object_list, list);
423 flags = radeon_object_flags_from_domain(lobj->wdomain);
424 flags |= TTM_PL_FLAG_TT;
426 flags = radeon_object_flags_from_domain(lobj->rdomain);
427 flags |= TTM_PL_FLAG_TT;
428 flags |= TTM_PL_FLAG_VRAM;
430 if (!robj->pin_count) {
431 robj->tobj.proposed_placement = flags | TTM_PL_MASK_CACHING;
432 r = ttm_buffer_object_validate(&robj->tobj,
433 robj->tobj.proposed_placement,
436 DRM_ERROR("radeon: failed to validate.\n");
439 radeon_object_gpu_addr(robj);
441 lobj->gpu_offset = robj->gpu_addr;
442 lobj->tiling_flags = robj->tiling_flags;
444 old_fence = (struct radeon_fence *)robj->tobj.sync_obj;
445 robj->tobj.sync_obj = radeon_fence_ref(fence);
446 robj->tobj.sync_obj_arg = NULL;
449 radeon_fence_unref(&old_fence);
455 void radeon_object_list_unvalidate(struct list_head *head)
457 struct radeon_object_list *lobj;
458 struct radeon_fence *old_fence = NULL;
461 list_for_each(i, head) {
462 lobj = list_entry(i, struct radeon_object_list, list);
463 old_fence = (struct radeon_fence *)lobj->robj->tobj.sync_obj;
464 lobj->robj->tobj.sync_obj = NULL;
466 radeon_fence_unref(&old_fence);
469 radeon_object_list_unreserve(head);
472 void radeon_object_list_clean(struct list_head *head)
474 radeon_object_list_unreserve(head);
477 int radeon_object_fbdev_mmap(struct radeon_object *robj,
478 struct vm_area_struct *vma)
480 return ttm_fbdev_mmap(vma, &robj->tobj);
483 unsigned long radeon_object_size(struct radeon_object *robj)
485 return robj->tobj.num_pages << PAGE_SHIFT;
488 int radeon_object_get_surface_reg(struct radeon_object *robj)
490 struct radeon_device *rdev = robj->rdev;
491 struct radeon_surface_reg *reg;
492 struct radeon_object *old_object;
496 if (!robj->tiling_flags)
499 if (robj->surface_reg >= 0) {
500 reg = &rdev->surface_regs[robj->surface_reg];
501 i = robj->surface_reg;
506 for (i = 0; i < RADEON_GEM_MAX_SURFACES; i++) {
508 reg = &rdev->surface_regs[i];
512 old_object = reg->robj;
513 if (old_object->pin_count == 0)
517 /* if we are all out */
518 if (i == RADEON_GEM_MAX_SURFACES) {
521 /* find someone with a surface reg and nuke their BO */
522 reg = &rdev->surface_regs[steal];
523 old_object = reg->robj;
524 /* blow away the mapping */
525 DRM_DEBUG("stealing surface reg %d from %p\n", steal, old_object);
526 ttm_bo_unmap_virtual(&old_object->tobj);
527 old_object->surface_reg = -1;
531 robj->surface_reg = i;
535 radeon_set_surface_reg(rdev, i, robj->tiling_flags, robj->pitch,
536 robj->tobj.mem.mm_node->start << PAGE_SHIFT,
537 robj->tobj.num_pages << PAGE_SHIFT);
541 void radeon_object_clear_surface_reg(struct radeon_object *robj)
543 struct radeon_device *rdev = robj->rdev;
544 struct radeon_surface_reg *reg;
546 if (robj->surface_reg == -1)
549 reg = &rdev->surface_regs[robj->surface_reg];
550 radeon_clear_surface_reg(rdev, robj->surface_reg);
553 robj->surface_reg = -1;
556 void radeon_object_set_tiling_flags(struct radeon_object *robj,
557 uint32_t tiling_flags, uint32_t pitch)
559 robj->tiling_flags = tiling_flags;
563 void radeon_object_get_tiling_flags(struct radeon_object *robj,
564 uint32_t *tiling_flags,
568 *tiling_flags = robj->tiling_flags;
570 *pitch = robj->pitch;
573 int radeon_object_check_tiling(struct radeon_object *robj, bool has_moved,
576 if (!(robj->tiling_flags & RADEON_TILING_SURFACE))
580 radeon_object_clear_surface_reg(robj);
584 if (robj->tobj.mem.mem_type != TTM_PL_VRAM) {
588 if (robj->surface_reg >= 0)
589 radeon_object_clear_surface_reg(robj);
593 if ((robj->surface_reg >= 0) && !has_moved)
596 return radeon_object_get_surface_reg(robj);
599 void radeon_bo_move_notify(struct ttm_buffer_object *bo,
600 struct ttm_mem_reg *mem)
602 struct radeon_object *robj = container_of(bo, struct radeon_object, tobj);
603 radeon_object_check_tiling(robj, 0, 1);
606 void radeon_bo_fault_reserve_notify(struct ttm_buffer_object *bo)
608 struct radeon_object *robj = container_of(bo, struct radeon_object, tobj);
609 radeon_object_check_tiling(robj, 0, 0);