diff options
| -rw-r--r-- | linux-core/Makefile | 2 | ||||
| -rw-r--r-- | linux-core/Makefile.kernel | 7 | ||||
| -rw-r--r-- | linux-core/drmP.h | 21 | ||||
| -rw-r--r-- | linux-core/drm_agpsupport.c | 171 | ||||
| -rw-r--r-- | linux-core/drm_bo.c | 2730 | ||||
| -rw-r--r-- | linux-core/drm_bo_lock.c | 189 | ||||
| -rw-r--r-- | linux-core/drm_bo_move.c | 614 | ||||
| -rw-r--r-- | linux-core/drm_compat.c | 99 | ||||
| -rw-r--r-- | linux-core/drm_drv.c | 36 | ||||
| -rw-r--r-- | linux-core/drm_fence.c | 829 | ||||
| -rw-r--r-- | linux-core/drm_fops.c | 35 | ||||
| -rw-r--r-- | linux-core/drm_object.c | 294 | ||||
| -rw-r--r-- | linux-core/drm_objects.h | 821 | ||||
| -rw-r--r-- | linux-core/drm_proc.c | 102 | ||||
| -rw-r--r-- | linux-core/drm_stub.c | 14 | ||||
| -rw-r--r-- | linux-core/drm_ttm.c | 512 | ||||
| -rw-r--r-- | linux-core/drm_vm.c | 198 | ||||
| -rw-r--r-- | linux-core/via_buffer.c | 163 | ||||
| -rw-r--r-- | linux-core/via_fence.c | 169 | ||||
| -rw-r--r-- | linux-core/xgi_cmdlist.c | 3 | ||||
| -rw-r--r-- | linux-core/xgi_drv.c | 11 | ||||
| -rw-r--r-- | linux-core/xgi_drv.h | 12 | ||||
| -rw-r--r-- | linux-core/xgi_fence.c | 87 | ||||
| -rw-r--r-- | shared-core/drm.h | 318 | ||||
| -rw-r--r-- | shared-core/via_drv.c | 40 | ||||
| -rw-r--r-- | shared-core/via_drv.h | 14 | ||||
| -rw-r--r-- | shared-core/via_map.c | 10 |
27 files changed, 4 insertions, 7497 deletions
diff --git a/linux-core/Makefile b/linux-core/Makefile index 9257a49b..591b6cfa 100644 --- a/linux-core/Makefile +++ b/linux-core/Makefile @@ -58,7 +58,7 @@ endif # Modules for all architectures MODULE_LIST := drm.o tdfx.o r128.o radeon.o mga.o sis.o savage.o via.o \ - mach64.o nouveau.o xgi.o + mach64.o xgi.o # Modules only for ix86 architectures ifneq (,$(findstring 86,$(MACHINE))) diff --git a/linux-core/Makefile.kernel b/linux-core/Makefile.kernel index 0bea35dd..e83f15c7 100644 --- a/linux-core/Makefile.kernel +++ b/linux-core/Makefile.kernel @@ -12,9 +12,8 @@ drm-objs := drm_auth.o drm_bufs.o drm_context.o drm_dma.o drm_drawable.o \ drm_lock.o drm_memory.o drm_proc.o drm_stub.o drm_vm.o \ drm_sysfs.o drm_pci.o drm_agpsupport.o drm_scatter.o \ drm_memory_debug.o ati_pcigart.o drm_sman.o \ - drm_hashtab.o drm_mm.o drm_object.o drm_compat.o \ - drm_fence.o drm_ttm.o drm_bo.o drm_bo_move.o drm_bo_lock.o \ - drm_regman.o drm_vm_nopage_compat.o drm_gem.o + drm_hashtab.o drm_mm.o drm_compat.o \ + drm_vm_nopage_compat.o drm_gem.o tdfx-objs := tdfx_drv.o r128-objs := r128_drv.o r128_cce.o r128_state.o r128_irq.o mga-objs := mga_drv.o mga_dma.o mga_state.o mga_warp.o mga_irq.o @@ -35,7 +34,7 @@ sis-objs := sis_drv.o sis_mm.o ffb-objs := ffb_drv.o ffb_context.o savage-objs := savage_drv.o savage_bci.o savage_state.o via-objs := via_irq.o via_drv.o via_map.o via_mm.o via_dma.o via_verifier.o \ - via_video.o via_dmablit.o via_fence.o via_buffer.o + via_video.o via_dmablit.o mach64-objs := mach64_drv.o mach64_dma.o mach64_irq.o mach64_state.o xgi-objs := xgi_cmdlist.o xgi_drv.o xgi_fb.o xgi_misc.o xgi_pcie.o \ xgi_fence.o diff --git a/linux-core/drmP.h b/linux-core/drmP.h index 67702825..9b4b071c 100644 --- a/linux-core/drmP.h +++ b/linux-core/drmP.h @@ -155,8 +155,6 @@ typedef unsigned long uintptr_t; #define DRM_MEM_MM 22 #define DRM_MEM_HASHTAB 23 #define DRM_MEM_OBJECTS 24 -#define DRM_MEM_FENCE 25 -#define DRM_MEM_TTM 26 #define DRM_MEM_BUFOBJ 27 #define DRM_MAX_CTXBITMAP (PAGE_SIZE * 8) @@ -660,8 +658,6 @@ struct drm_gem_object { void *driver_private; }; -#include "drm_objects.h" - /** * DRM driver structure. This structure represent the common code for * a family of cards. There will one drm_device for each card present @@ -855,10 +851,6 @@ struct drm_device { struct list_head maplist; /**< Linked list of regions */ int map_count; /**< Number of mappable regions */ struct drm_open_hash map_hash; /**< User token hash table for maps */ - struct drm_mm offset_manager; /**< User token manager */ - struct drm_open_hash object_hash; /**< User token hash table for objects */ - struct address_space *dev_mapping; /**< For unmap_mapping_range() */ - struct page *ttm_dummy_page; /** \name Context handle management */ /*@{ */ @@ -953,9 +945,6 @@ struct drm_device { unsigned int agp_buffer_token; struct drm_minor *primary; /**< render type primary screen head */ - struct drm_fence_manager fm; - struct drm_buffer_manager bm; - /** \name Drawable information */ /*@{ */ spinlock_t drw_lock; @@ -978,15 +967,6 @@ struct drm_device { /*@} */ }; -#if __OS_HAS_AGP -struct drm_agp_ttm_backend { - struct drm_ttm_backend backend; - DRM_AGP_MEM *mem; - struct agp_bridge_data *bridge; - int populated; -}; -#endif - static __inline__ int drm_core_check_feature(struct drm_device *dev, int feature) @@ -1279,7 +1259,6 @@ extern DRM_AGP_MEM *drm_agp_allocate_memory(struct agp_bridge_data *bridge, size extern int drm_agp_free_memory(DRM_AGP_MEM * handle); extern int drm_agp_bind_memory(DRM_AGP_MEM * handle, off_t start); extern int drm_agp_unbind_memory(DRM_AGP_MEM * handle); -extern struct drm_ttm_backend *drm_agp_init_ttm(struct drm_device *dev); extern void drm_agp_chipset_flush(struct drm_device *dev); /* Stub support (drm_stub.h) */ extern int drm_get_dev(struct pci_dev *pdev, const struct pci_device_id *ent, diff --git a/linux-core/drm_agpsupport.c b/linux-core/drm_agpsupport.c index 2abfac6e..9f746a32 100644 --- a/linux-core/drm_agpsupport.c +++ b/linux-core/drm_agpsupport.c @@ -498,177 +498,6 @@ drm_agp_bind_pages(struct drm_device *dev, } EXPORT_SYMBOL(drm_agp_bind_pages); -/* - * AGP ttm backend interface. - */ - -#ifndef AGP_USER_TYPES -#define AGP_USER_TYPES (1 << 16) -#define AGP_USER_MEMORY (AGP_USER_TYPES) -#define AGP_USER_CACHED_MEMORY (AGP_USER_TYPES + 1) -#endif -#define AGP_REQUIRED_MAJOR 0 -#define AGP_REQUIRED_MINOR 102 - -static int drm_agp_needs_unbind_cache_adjust(struct drm_ttm_backend *backend) -{ - return ((backend->flags & DRM_BE_FLAG_BOUND_CACHED) ? 0 : 1); -} - - -static int drm_agp_populate(struct drm_ttm_backend *backend, - unsigned long num_pages, struct page **pages, - struct page *dummy_read_page) -{ - struct drm_agp_ttm_backend *agp_be = - container_of(backend, struct drm_agp_ttm_backend, backend); - struct page **cur_page, **last_page = pages + num_pages; - DRM_AGP_MEM *mem; - int dummy_page_count = 0; - - if (drm_alloc_memctl(num_pages * sizeof(void *))) - return -1; - - DRM_DEBUG("drm_agp_populate_ttm\n"); - mem = drm_agp_allocate_memory(agp_be->bridge, num_pages, AGP_USER_MEMORY); - if (!mem) { - drm_free_memctl(num_pages * sizeof(void *)); - return -1; - } - - DRM_DEBUG("Current page count is %ld\n", (long) mem->page_count); - mem->page_count = 0; - for (cur_page = pages; cur_page < last_page; ++cur_page) { - struct page *page = *cur_page; - if (!page) { - page = dummy_read_page; - ++dummy_page_count; - } - mem->memory[mem->page_count++] = phys_to_gart(page_to_phys(page)); - } - if (dummy_page_count) - DRM_DEBUG("Mapped %d dummy pages\n", dummy_page_count); - agp_be->mem = mem; - return 0; -} - -static int drm_agp_bind_ttm(struct drm_ttm_backend *backend, - struct drm_bo_mem_reg *bo_mem) -{ - struct drm_agp_ttm_backend *agp_be = - container_of(backend, struct drm_agp_ttm_backend, backend); - DRM_AGP_MEM *mem = agp_be->mem; - int ret; - int snooped = (bo_mem->flags & DRM_BO_FLAG_CACHED) && !(bo_mem->flags & DRM_BO_FLAG_CACHED_MAPPED); - - DRM_DEBUG("drm_agp_bind_ttm\n"); - mem->is_flushed = true; - mem->type = AGP_USER_MEMORY; - /* CACHED MAPPED implies not snooped memory */ - if (snooped) - mem->type = AGP_USER_CACHED_MEMORY; - - ret = drm_agp_bind_memory(mem, bo_mem->mm_node->start); - if (ret) - DRM_ERROR("AGP Bind memory failed\n"); - - DRM_FLAG_MASKED(backend->flags, (bo_mem->flags & DRM_BO_FLAG_CACHED) ? - DRM_BE_FLAG_BOUND_CACHED : 0, - DRM_BE_FLAG_BOUND_CACHED); - return ret; -} - -static int drm_agp_unbind_ttm(struct drm_ttm_backend *backend) -{ - struct drm_agp_ttm_backend *agp_be = - container_of(backend, struct drm_agp_ttm_backend, backend); - - DRM_DEBUG("drm_agp_unbind_ttm\n"); - if (agp_be->mem->is_bound) - return drm_agp_unbind_memory(agp_be->mem); - else - return 0; -} - -static void drm_agp_clear_ttm(struct drm_ttm_backend *backend) -{ - struct drm_agp_ttm_backend *agp_be = - container_of(backend, struct drm_agp_ttm_backend, backend); - DRM_AGP_MEM *mem = agp_be->mem; - - DRM_DEBUG("drm_agp_clear_ttm\n"); - if (mem) { - unsigned long num_pages = mem->page_count; - backend->func->unbind(backend); - agp_free_memory(mem); - drm_free_memctl(num_pages * sizeof(void *)); - } - agp_be->mem = NULL; -} - -static void drm_agp_destroy_ttm(struct drm_ttm_backend *backend) -{ - struct drm_agp_ttm_backend *agp_be; - - if (backend) { - DRM_DEBUG("drm_agp_destroy_ttm\n"); - agp_be = container_of(backend, struct drm_agp_ttm_backend, backend); - if (agp_be) { - if (agp_be->mem) - backend->func->clear(backend); - drm_ctl_free(agp_be, sizeof(*agp_be), DRM_MEM_TTM); - } - } -} - -static struct drm_ttm_backend_func agp_ttm_backend = { - .needs_ub_cache_adjust = drm_agp_needs_unbind_cache_adjust, - .populate = drm_agp_populate, - .clear = drm_agp_clear_ttm, - .bind = drm_agp_bind_ttm, - .unbind = drm_agp_unbind_ttm, - .destroy = drm_agp_destroy_ttm, -}; - -struct drm_ttm_backend *drm_agp_init_ttm(struct drm_device *dev) -{ - - struct drm_agp_ttm_backend *agp_be; - struct agp_kern_info *info; - - if (!dev->agp) { - DRM_ERROR("AGP is not initialized.\n"); - return NULL; - } - info = &dev->agp->agp_info; - - if (info->version.major != AGP_REQUIRED_MAJOR || - info->version.minor < AGP_REQUIRED_MINOR) { - DRM_ERROR("Wrong agpgart version %d.%d\n" - "\tYou need at least version %d.%d.\n", - info->version.major, - info->version.minor, - AGP_REQUIRED_MAJOR, - AGP_REQUIRED_MINOR); - return NULL; - } - - - agp_be = drm_ctl_calloc(1, sizeof(*agp_be), DRM_MEM_TTM); - if (!agp_be) - return NULL; - - agp_be->mem = NULL; - - agp_be->bridge = dev->agp->bridge; - agp_be->populated = false; - agp_be->backend.func = &agp_ttm_backend; - agp_be->backend.dev = dev; - - return &agp_be->backend; -} -EXPORT_SYMBOL(drm_agp_init_ttm); - #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,25) void drm_agp_chipset_flush(struct drm_device *dev) { diff --git a/linux-core/drm_bo.c b/linux-core/drm_bo.c deleted file mode 100644 index f43480c5..00000000 --- a/linux-core/drm_bo.c +++ /dev/null @@ -1,2730 +0,0 @@ -/************************************************************************** - * - * Copyright (c) 2006-2007 Tungsten Graphics, Inc., Cedar Park, TX., USA - * All Rights Reserved. - * - * Permission is hereby granted, free of charge, to any person obtaining a - * copy of this software and associated documentation files (the - * "Software"), to deal in the Software without restriction, including - * without limitation the rights to use, copy, modify, merge, publish, - * distribute, sub license, and/or sell copies of the Software, and to - * permit persons to whom the Software is furnished to do so, subject to - * the following conditions: - * - * The above copyright notice and this permission notice (including the - * next paragraph) shall be included in all copies or substantial portions - * of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL - * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, - * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR - * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE - * USE OR OTHER DEALINGS IN THE SOFTWARE. - * - **************************************************************************/ -/* - * Authors: Thomas Hellström <thomas-at-tungstengraphics-dot-com> - */ - -#include "drmP.h" - -/* - * Locking may look a bit complicated but isn't really: - * - * The buffer usage atomic_t needs to be protected by dev->struct_mutex - * when there is a chance that it can be zero before or after the operation. - * - * dev->struct_mutex also protects all lists and list heads, - * Hash tables and hash heads. - * - * bo->mutex protects the buffer object itself excluding the usage field. - * bo->mutex does also protect the buffer list heads, so to manipulate those, - * we need both the bo->mutex and the dev->struct_mutex. - * - * Locking order is bo->mutex, dev->struct_mutex. Therefore list traversal - * is a bit complicated. When dev->struct_mutex is released to grab bo->mutex, - * the list traversal will, in general, need to be restarted. - * - */ - -static void drm_bo_destroy_locked(struct drm_buffer_object *bo); -static int drm_bo_setup_vm_locked(struct drm_buffer_object *bo); -static void drm_bo_takedown_vm_locked(struct drm_buffer_object *bo); -static void drm_bo_unmap_virtual(struct drm_buffer_object *bo); - -static inline uint64_t drm_bo_type_flags(unsigned type) -{ - return (1ULL << (24 + type)); -} - -/* - * bo locked. dev->struct_mutex locked. - */ - -void drm_bo_add_to_pinned_lru(struct drm_buffer_object *bo) -{ - struct drm_mem_type_manager *man; - - DRM_ASSERT_LOCKED(&bo->dev->struct_mutex); - DRM_ASSERT_LOCKED(&bo->mutex); - - man = &bo->dev->bm.man[bo->pinned_mem_type]; - list_add_tail(&bo->pinned_lru, &man->pinned); -} - -void drm_bo_add_to_lru(struct drm_buffer_object *bo) -{ - struct drm_mem_type_manager *man; - - DRM_ASSERT_LOCKED(&bo->dev->struct_mutex); - - if (!(bo->mem.proposed_flags & (DRM_BO_FLAG_NO_MOVE | DRM_BO_FLAG_NO_EVICT)) - || bo->mem.mem_type != bo->pinned_mem_type) { - man = &bo->dev->bm.man[bo->mem.mem_type]; - list_add_tail(&bo->lru, &man->lru); - } else { - INIT_LIST_HEAD(&bo->lru); - } -} - -static int drm_bo_vm_pre_move(struct drm_buffer_object *bo, int old_is_pci) -{ - if (!bo->map_list.map) - return 0; - - drm_bo_unmap_virtual(bo); - return 0; -} - -/* - * Call bo->mutex locked. - */ - -static int drm_bo_add_ttm(struct drm_buffer_object *bo) -{ - struct drm_device *dev = bo->dev; - int ret = 0; - uint32_t page_flags = 0; - - DRM_ASSERT_LOCKED(&bo->mutex); - bo->ttm = NULL; - - if (bo->mem.proposed_flags & DRM_BO_FLAG_WRITE) - page_flags |= DRM_TTM_PAGE_WRITE; - - switch (bo->type) { - case drm_bo_type_device: - case drm_bo_type_kernel: - bo->ttm = drm_ttm_create(dev, bo->num_pages << PAGE_SHIFT, - page_flags, dev->bm.dummy_read_page); - if (!bo->ttm) - ret = -ENOMEM; - break; - case drm_bo_type_user: - bo->ttm = drm_ttm_create(dev, bo->num_pages << PAGE_SHIFT, - page_flags | DRM_TTM_PAGE_USER, - dev->bm.dummy_read_page); - if (!bo->ttm) - ret = -ENOMEM; - - ret = drm_ttm_set_user(bo->ttm, current, - bo->buffer_start, - bo->num_pages); - if (ret) - return ret; - - break; - default: - DRM_ERROR("Illegal buffer object type\n"); - ret = -EINVAL; - break; - } - - return ret; -} - -static int drm_bo_handle_move_mem(struct drm_buffer_object *bo, - struct drm_bo_mem_reg *mem, - int evict, int no_wait) -{ - struct drm_device *dev = bo->dev; - struct drm_buffer_manager *bm = &dev->bm; - int old_is_pci = drm_mem_reg_is_pci(dev, &bo->mem); - int new_is_pci = drm_mem_reg_is_pci(dev, mem); - struct drm_mem_type_manager *old_man = &bm->man[bo->mem.mem_type]; - struct drm_mem_type_manager *new_man = &bm->man[mem->mem_type]; - int ret = 0; - - if (old_is_pci || new_is_pci || - ((mem->flags ^ bo->mem.flags) & DRM_BO_FLAG_CACHED)) - ret = drm_bo_vm_pre_move(bo, old_is_pci); - if (ret) - return ret; - - /* - * Create and bind a ttm if required. - */ - - if (!(new_man->flags & _DRM_FLAG_MEMTYPE_FIXED) && (bo->ttm == NULL)) { - ret = drm_bo_add_ttm(bo); - if (ret) - goto out_err; - - if (mem->mem_type != DRM_BO_MEM_LOCAL) { - ret = drm_ttm_bind(bo->ttm, mem); - if (ret) - goto out_err; - } - - if (bo->mem.mem_type == DRM_BO_MEM_LOCAL) { - - struct drm_bo_mem_reg *old_mem = &bo->mem; - uint64_t save_flags = old_mem->flags; - uint64_t save_proposed_flags = old_mem->proposed_flags; - - *old_mem = *mem; - mem->mm_node = NULL; - old_mem->proposed_flags = save_proposed_flags; - DRM_FLAG_MASKED(save_flags, mem->flags, - DRM_BO_MASK_MEMTYPE); - goto moved; - } - - } - - if (!(old_man->flags & _DRM_FLAG_MEMTYPE_FIXED) && - !(new_man->flags & _DRM_FLAG_MEMTYPE_FIXED)) - ret = drm_bo_move_ttm(bo, evict, no_wait, mem); - else if (dev->driver->bo_driver->move) - ret = dev->driver->bo_driver->move(bo, evict, no_wait, mem); - else - ret = drm_bo_move_memcpy(bo, evict, no_wait, mem); - - if (ret) - goto out_err; - -moved: - if (bo->priv_flags & _DRM_BO_FLAG_EVICTED) { - ret = - dev->driver->bo_driver->invalidate_caches(dev, - bo->mem.flags); - if (ret) - DRM_ERROR("Can not flush read caches\n"); - } - - DRM_FLAG_MASKED(bo->priv_flags, - (evict) ? _DRM_BO_FLAG_EVICTED : 0, - _DRM_BO_FLAG_EVICTED); - - if (bo->mem.mm_node) - bo->offset = (bo->mem.mm_node->start << PAGE_SHIFT) + - bm->man[bo->mem.mem_type].gpu_offset; - - - return 0; - -out_err: - new_man = &bm->man[bo->mem.mem_type]; - if ((new_man->flags & _DRM_FLAG_MEMTYPE_FIXED) && bo->ttm) { - drm_ttm_unbind(bo->ttm); - drm_ttm_destroy(bo->ttm); - bo->ttm = NULL; - } - - return ret; -} - -/* - * Call bo->mutex locked. - * Returns -EBUSY if the buffer is currently rendered to or from. 0 otherwise. - */ - -static int drm_bo_busy(struct drm_buffer_object *bo, int check_unfenced) -{ - struct drm_fence_object *fence = bo->fence; - - if (check_unfenced && (bo->priv_flags & _DRM_BO_FLAG_UNFENCED)) - return -EBUSY; - - if (fence) { - if (drm_fence_object_signaled(fence, bo->fence_type)) { - drm_fence_usage_deref_unlocked(&bo->fence); - return 0; - } - drm_fence_object_flush(fence, DRM_FENCE_TYPE_EXE); - if (drm_fence_object_signaled(fence, bo->fence_type)) { - drm_fence_usage_deref_unlocked(&bo->fence); - return 0; - } - return -EBUSY; - } - return 0; -} - -static int drm_bo_check_unfenced(struct drm_buffer_object *bo) -{ - int ret; - - mutex_lock(&bo->mutex); - ret = (bo->priv_flags & _DRM_BO_FLAG_UNFENCED); - mutex_unlock(&bo->mutex); - return ret; -} - - -/* - * Call bo->mutex locked. - * Wait until the buffer is idle. - */ - -int drm_bo_wait(struct drm_buffer_object *bo, int lazy, int interruptible, - int no_wait, int check_unfenced) -{ - int ret; - - DRM_ASSERT_LOCKED(&bo->mutex); - while(unlikely(drm_bo_busy(bo, check_unfenced))) { - if (no_wait) - return -EBUSY; - - if (check_unfenced && (bo->priv_flags & _DRM_BO_FLAG_UNFENCED)) { - mutex_unlock(&bo->mutex); - wait_event(bo->event_queue, !drm_bo_check_unfenced(bo)); - mutex_lock(&bo->mutex); - bo->priv_flags |= _DRM_BO_FLAG_UNLOCKED; - } - - if (bo->fence) { - struct drm_fence_object *fence; - uint32_t fence_type = bo->fence_type; - - drm_fence_reference_unlocked(&fence, bo->fence); - mutex_unlock(&bo->mutex); - - ret = drm_fence_object_wait(fence, lazy, !interruptible, - fence_type); - - drm_fence_usage_deref_unlocked(&fence); - mutex_lock(&bo->mutex); - bo->priv_flags |= _DRM_BO_FLAG_UNLOCKED; - if (ret) - return ret; - } - - } - return 0; -} -EXPORT_SYMBOL(drm_bo_wait); - -static int drm_bo_expire_fence(struct drm_buffer_object *bo, int allow_errors) -{ - struct drm_device *dev = bo->dev; - struct drm_buffer_manager *bm = &dev->bm; - - if (bo->fence) { - if (bm->nice_mode) { - unsigned long _end = jiffies + 3 * DRM_HZ; - int ret; - do { - ret = drm_bo_wait(bo, 0, 0, 0, 0); - if (ret && allow_errors) - return ret; - - } while (ret && !time_after_eq(jiffies, _end)); - - if (bo->fence) { - bm->nice_mode = 0; - DRM_ERROR("Detected GPU lockup or " - "fence driver was taken down. " - "Evicting buffer.\n"); - } - } - if (bo->fence) - drm_fence_usage_deref_unlocked(&bo->fence); - } - return 0; -} - -/* - * Call dev->struct_mutex locked. - * Attempts to remove all private references to a buffer by expiring its - * fence object and removing from lru lists and memory managers. - */ - -static void drm_bo_cleanup_refs(struct drm_buffer_object *bo, int remove_all) -{ - struct drm_device *dev = bo->dev; - struct drm_buffer_manager *bm = &dev->bm; - - DRM_ASSERT_LOCKED(&dev->struct_mutex); - - atomic_inc(&bo->usage); - mutex_unlock(&dev->struct_mutex); - mutex_lock(&bo->mutex); - - DRM_FLAG_MASKED(bo->priv_flags, 0, _DRM_BO_FLAG_UNFENCED); - - if (bo->fence && drm_fence_object_signaled(bo->fence, - bo->fence_type)) - drm_fence_usage_deref_unlocked(&bo->fence); - - if (bo->fence && remove_all) - (void)drm_bo_expire_fence(bo, 0); - - mutex_lock(&dev->struct_mutex); - - if (!atomic_dec_and_test(&bo->usage)) - goto out; - - if (!bo->fence) { - list_del_init(&bo->lru); - if (bo->mem.mm_node) { - drm_mm_put_block(bo->mem.mm_node); - if (bo->pinned_node == bo->mem.mm_node) - bo->pinned_node = NULL; - bo->mem.mm_node = NULL; - } - list_del_init(&bo->pinned_lru); - if (bo->pinned_node) { - drm_mm_put_block(bo->pinned_node); - bo->pinned_node = NULL; - } - list_del_init(&bo->ddestroy); - mutex_unlock(&bo->mutex); - drm_bo_destroy_locked(bo); - return; - } - - if (list_empty(&bo->ddestroy)) { - drm_fence_object_flush(bo->fence, bo->fence_type); - list_add_tail(&bo->ddestroy, &bm->ddestroy); - schedule_delayed_work(&bm->wq, - ((DRM_HZ / 100) < 1) ? 1 : DRM_HZ / 100); - } - -out: - mutex_unlock(&bo->mutex); - return; -} - -/* - * Verify that refcount is 0 and that there are no internal references - * to the buffer object. Then destroy it. - */ - -static void drm_bo_destroy_locked(struct drm_buffer_object *bo) -{ - struct drm_device *dev = bo->dev; - struct drm_buffer_manager *bm = &dev->bm; - - DRM_ASSERT_LOCKED(&dev->struct_mutex); - - if (list_empty(&bo->lru) && bo->mem.mm_node == NULL && - list_empty(&bo->pinned_lru) && bo->pinned_node == NULL && - list_empty(&bo->ddestroy) && atomic_read(&bo->usage) == 0) { - if (bo->fence != NULL) { - DRM_ERROR("Fence was non-zero.\n"); - drm_bo_cleanup_refs(bo, 0); - return; - } - - if (bo->ttm) { - drm_ttm_unbind(bo->ttm); - drm_ttm_destroy(bo->ttm); - bo->ttm = NULL; - } - - atomic_dec(&bm->count); - - drm_ctl_free(bo, sizeof(*bo), DRM_MEM_BUFOBJ); - - return; - } - - /* - * Some stuff is still trying to reference the buffer object. - * Get rid of those references. - */ - - drm_bo_cleanup_refs(bo, 0); - - return; -} - -/* - * Call dev->struct_mutex locked. - */ - -static void drm_bo_delayed_delete(struct drm_device *dev, int remove_all) -{ - struct drm_buffer_manager *bm = &dev->bm; - - struct drm_buffer_object *entry, *nentry; - struct list_head *list, *next; - - list_for_each_safe(list, next, &bm->ddestroy) { - entry = list_entry(list, struct drm_buffer_object, ddestroy); - - nentry = NULL; - if (next != &bm->ddestroy) { - nentry = list_entry(next, struct drm_buffer_object, - ddestroy); - atomic_inc(&nentry->usage); - } - - drm_bo_cleanup_refs(entry, remove_all); - - if (nentry) - atomic_dec(&nentry->usage); - } -} - -static void drm_bo_delayed_workqueue(struct work_struct *work) -{ - struct drm_buffer_manager *bm = - container_of(work, struct drm_buffer_manager, wq.work); - struct drm_device *dev = container_of(bm, struct drm_device, bm); - - DRM_DEBUG("Delayed delete Worker\n"); - - mutex_lock(&dev->struct_mutex); - if (!bm->initialized) { - mutex_unlock(&dev->struct_mutex); - return; - } - drm_bo_delayed_delete(dev, 0); - if (bm->initialized && !list_empty(&bm->ddestroy)) { - schedule_delayed_work(&bm->wq, - ((DRM_HZ / 100) < 1) ? 1 : DRM_HZ / 100); - } - mutex_unlock(&dev->struct_mutex); -} - -void drm_bo_usage_deref_locked(struct drm_buffer_object **bo) -{ - struct drm_buffer_object *tmp_bo = *bo; - bo = NULL; - - DRM_ASSERT_LOCKED(&tmp_bo->dev->struct_mutex); - - if (atomic_dec_and_test(&tmp_bo->usage)) - drm_bo_destroy_locked(tmp_bo); -} -EXPORT_SYMBOL(drm_bo_usage_deref_locked); - -static void drm_bo_base_deref_locked(struct drm_file *file_priv, - struct drm_user_object *uo) -{ - struct drm_buffer_object *bo = - drm_user_object_entry(uo, struct drm_buffer_object, base); - - DRM_ASSERT_LOCKED(&bo->dev->struct_mutex); - - drm_bo_takedown_vm_locked(bo); - drm_bo_usage_deref_locked(&bo); -} - -void drm_bo_usage_deref_unlocked(struct drm_buffer_object **bo) -{ - struct drm_buffer_object *tmp_bo = *bo; - struct drm_device *dev = tmp_bo->dev; - - *bo = NULL; - if (atomic_dec_and_test(&tmp_bo->usage)) { - mutex_lock(&dev->struct_mutex); - if (atomic_read(&tmp_bo->usage) == 0) - drm_bo_destroy_locked(tmp_bo); - mutex_unlock(&dev->struct_mutex); - } -} -EXPORT_SYMBOL(drm_bo_usage_deref_unlocked); - -void drm_putback_buffer_objects(struct drm_device *dev) -{ - struct drm_buffer_manager *bm = &dev->bm; - struct list_head *list = &bm->unfenced; - struct drm_buffer_object *entry, *next; - - mutex_lock(&dev->struct_mutex); - list_for_each_entry_safe(entry, next, list, lru) { - atomic_inc(&entry->usage); - mutex_unlock(&dev->struct_mutex); - - mutex_lock(&entry->mutex); - BUG_ON(!(entry->priv_flags & _DRM_BO_FLAG_UNFENCED)); - mutex_lock(&dev->struct_mutex); - - list_del_init(&entry->lru); - DRM_FLAG_MASKED(entry->priv_flags, 0, _DRM_BO_FLAG_UNFENCED); - wake_up_all(&entry->event_queue); - - /* - * FIXME: Might want to put back on head of list - * instead of tail here. - */ - - drm_bo_add_to_lru(entry); - mutex_unlock(&entry->mutex); - drm_bo_usage_deref_locked(&entry); - } - mutex_unlock(&dev->struct_mutex); -} -EXPORT_SYMBOL(drm_putback_buffer_objects); - - -/* - * Note. The caller has to register (if applicable) - * and deregister fence object usage. - */ - -int drm_fence_buffer_objects(struct drm_device *dev, - struct list_head *list, - uint32_t fence_flags, - struct drm_fence_object *fence, - struct drm_fence_object **used_fence) -{ - struct drm_buffer_manager *bm = &dev->bm; - struct drm_buffer_object *entry; - uint32_t fence_type = 0; - uint32_t fence_class = ~0; - int count = 0; - int ret = 0; - struct list_head *l; - - mutex_lock(&dev->struct_mutex); - - if (!list) - list = &bm->unfenced; - - if (fence) - fence_class = fence->fence_class; - - list_for_each_entry(entry, list, lru) { - BUG_ON(!(entry->priv_flags & _DRM_BO_FLAG_UNFENCED)); - fence_type |= entry->new_fence_type; - if (fence_class == ~0) - fence_class = entry->new_fence_class; - else if (entry->new_fence_class != fence_class) { - DRM_ERROR("Unmatching fence classes on unfenced list: " - "%d and %d.\n", - fence_class, - entry->new_fence_class); - ret = -EINVAL; - goto out; - } - count++; - } - - if (!count) { - ret = -EINVAL; - goto out; - } - - if (fence) { - if ((fence_type & fence->type) != fence_type || - (fence->fence_class != fence_class)) { - DRM_ERROR("Given fence doesn't match buffers " - "on unfenced list.\n"); - ret = -EINVAL; - goto out; - } - } else { - mutex_unlock(&dev->struct_mutex); - ret = drm_fence_object_create(dev, fence_class, fence_type, - fence_flags | DRM_FENCE_FLAG_EMIT, - &fence); - mutex_lock(&dev->struct_mutex); - if (ret) - goto out; - } - - count = 0; - l = list->next; - while (l != list) { - prefetch(l->next); - entry = list_entry(l, struct drm_buffer_object, lru); - atomic_inc(&entry->usage); - mutex_unlock(&dev->struct_mutex); - mutex_lock(&entry->mutex); - mutex_lock(&dev->struct_mutex); - list_del_init(l); - if (entry->priv_flags & _DRM_BO_FLAG_UNFENCED) { - count++; - if (entry->fence) - drm_fence_usage_deref_locked(&entry->fence); - entry->fence = drm_fence_reference_locked(fence); - entry->fence_class = entry->new_fence_class; - entry->fence_type = entry->new_fence_type; - DRM_FLAG_MASKED(entry->priv_flags, 0, - _DRM_BO_FLAG_UNFENCED); - wake_up_all(&entry->event_queue); - drm_bo_add_to_lru(entry); - } - mutex_unlock(&entry->mutex); - drm_bo_usage_deref_locked(&entry); - l = list->next; - } - DRM_DEBUG("Fenced %d buffers\n", count); -out: - mutex_unlock(&dev->struct_mutex); - *used_fence = fence; - return ret; -} -EXPORT_SYMBOL(drm_fence_buffer_objects); - -/* - * bo->mutex locked - */ - -static int drm_bo_evict(struct drm_buffer_object *bo, unsigned mem_type, - int no_wait) -{ - int ret = 0; - struct drm_device *dev = bo->dev; - struct drm_bo_mem_reg evict_mem; - - /* - * Someone might have modified the buffer before we took the - * buffer mutex. - */ - - do { - bo->priv_flags &= ~_DRM_BO_FLAG_UNLOCKED; - - if (unlikely(bo->mem.flags & - (DRM_BO_FLAG_NO_MOVE | DRM_BO_FLAG_NO_EVICT))) - goto out_unlock; - if (unlikely(bo->priv_flags & _DRM_BO_FLAG_UNFENCED)) - goto out_unlock; - if (unlikely(bo->mem.mem_type != mem_type)) - goto out_unlock; - ret = drm_bo_wait(bo, 0, 1, no_wait, 0); - if (ret) - goto out_unlock; - - } while(bo->priv_flags & _DRM_BO_FLAG_UNLOCKED); - - evict_mem = bo->mem; - evict_mem.mm_node = NULL; - - evict_mem = bo->mem; - evict_mem.proposed_flags = dev->driver->bo_driver->evict_flags(bo); - - mutex_lock(&dev->struct_mutex); - list_del_init(&bo->lru); - mutex_unlock(&dev->struct_mutex); - - ret = drm_bo_mem_space(bo, &evict_mem, no_wait); - - if (ret) { - if (ret != -EAGAIN) - DRM_ERROR("Failed to find memory space for " - "buffer 0x%p eviction.\n", bo); - goto out; - } - - ret = drm_bo_handle_move_mem(bo, &evict_mem, 1, no_wait); - - if (ret) { - if (ret != -EAGAIN) - DRM_ERROR("Buffer eviction failed\n"); - goto out; - } - - DRM_FLAG_MASKED(bo->priv_flags, _DRM_BO_FLAG_EVICTED, - _DRM_BO_FLAG_EVICTED); - -out: - mutex_lock(&dev->struct_mutex); - if (evict_mem.mm_node) { - if (evict_mem.mm_node != bo->pinned_node) - drm_mm_put_block(evict_mem.mm_node); - evict_mem.mm_node = NULL; - } - drm_bo_add_to_lru(bo); - BUG_ON(bo->priv_flags & _DRM_BO_FLAG_UNLOCKED); -out_unlock: - mutex_unlock(&dev->struct_mutex); - - return ret; -} - -/** - * Repeatedly evict memory from the LRU for @mem_type until we create enough - * space, or we've evicted everything and there isn't enough space. - */ -static int drm_bo_mem_force_space(struct drm_device *dev, - struct drm_bo_mem_reg *mem, - uint32_t mem_type, int no_wait) -{ - struct drm_mm_node *node; - struct drm_buffer_manager *bm = &dev->bm; - struct drm_buffer_object *entry; - struct drm_mem_type_manager *man = &bm->man[mem_type]; - struct list_head *lru; - unsigned long num_pages = mem->num_pages; - int ret; - - mutex_lock(&dev->struct_mutex); - do { - node = drm_mm_search_free(&man->manager, num_pages, - mem->page_alignment, 1); - if (node) - break; - - lru = &man->lru; - if (lru->next == lru) - break; - - entry = list_entry(lru->next, struct drm_buffer_object, lru); - atomic_inc(&entry->usage); - mutex_unlock(&dev->struct_mutex); - mutex_lock(&entry->mutex); - ret = drm_bo_evict(entry, mem_type, no_wait); - mutex_unlock(&entry->mutex); - drm_bo_usage_deref_unlocked(&entry); - if (ret) - return ret; - mutex_lock(&dev->struct_mutex); - } while (1); - - if (!node) { - mutex_unlock(&dev->struct_mutex); - return -ENOMEM; - } - - node = drm_mm_get_block(node, num_pages, mem->page_alignment); - if (unlikely(!node)) { - mutex_unlock(&dev->struct_mutex); - return -ENOMEM; - } - - mutex_unlock(&dev->struct_mutex); - mem->mm_node = node; - mem->mem_type = mem_type; - return 0; -} - -static int drm_bo_mt_compatible(struct drm_mem_type_manager *man, - int disallow_fixed, - uint32_t mem_type, - uint64_t mask, uint32_t *res_mask) -{ - uint64_t cur_flags = drm_bo_type_flags(mem_type); - uint64_t flag_diff; - - if ((man->flags & _DRM_FLAG_MEMTYPE_FIXED) && disallow_fixed) - return 0; - if (man->flags & _DRM_FLAG_MEMTYPE_CACHED) - cur_flags |= DRM_BO_FLAG_CACHED; - if (man->flags & _DRM_FLAG_MEMTYPE_MAPPABLE) - cur_flags |= DRM_BO_FLAG_MAPPABLE; - if (man->flags & _DRM_FLAG_MEMTYPE_CSELECT) - DRM_FLAG_MASKED(cur_flags, mask, DRM_BO_FLAG_CACHED); - - if ((cur_flags & mask & DRM_BO_MASK_MEM) == 0) - return 0; - - if (mem_type == DRM_BO_MEM_LOCAL) { - *res_mask = cur_flags; - return 1; - } - - flag_diff = (mask ^ cur_flags); - if (flag_diff & DRM_BO_FLAG_CACHED_MAPPED) - cur_flags |= DRM_BO_FLAG_CACHED_MAPPED; - - if ((flag_diff & DRM_BO_FLAG_CACHED) && - (!(mask & DRM_BO_FLAG_CACHED) || - (mask & DRM_BO_FLAG_FORCE_CACHING))) - return 0; - - if ((flag_diff & DRM_BO_FLAG_MAPPABLE) && - ((mask & DRM_BO_FLAG_MAPPABLE) || - (mask & DRM_BO_FLAG_FORCE_MAPPABLE))) - return 0; - - *res_mask = cur_flags; - return 1; -} - -/** - * Creates space for memory region @mem according to its type. - * - * This function first searches for free space in compatible memory types in - * the priority order defined by the driver. If free space isn't found, then - * drm_bo_mem_force_space is attempted in priority order to evict and find - * space. - */ -int drm_bo_mem_space(struct drm_buffer_object *bo, - struct drm_bo_mem_reg *mem, int no_wait) -{ - struct drm_device *dev = bo->dev; - struct drm_buffer_manager *bm = &dev->bm; - struct drm_mem_type_manager *man; - - uint32_t num_prios = dev->driver->bo_driver->num_mem_type_prio; - const uint32_t *prios = dev->driver->bo_driver->mem_type_prio; - uint32_t i; - uint32_t mem_type = DRM_BO_MEM_LOCAL; - uint32_t cur_flags; - int type_found = 0; - int type_ok = 0; - int has_eagain = 0; - struct drm_mm_node *node = NULL; - int ret; - - mem->mm_node = NULL; - for (i = 0; i < num_prios; ++i) { - mem_type = prios[i]; - man = &bm->man[mem_type]; - - type_ok = drm_bo_mt_compatible(man, - bo->type == drm_bo_type_user, - mem_type, mem->proposed_flags, - &cur_flags); - - if (!type_ok) - continue; - - if (mem_type == DRM_BO_MEM_LOCAL) - break; - - if ((mem_type == bo->pinned_mem_type) && - (bo->pinned_node != NULL)) { - node = bo->pinned_node; - break; - } - - mutex_lock(&dev->struct_mutex); - if (man->has_type && man->use_type) { - type_found = 1; - node = drm_mm_search_free(&man->manager, mem->num_pages, - mem->page_alignment, 1); - if (node) - node = drm_mm_get_block(node, mem->num_pages, - mem->page_alignment); - } - mutex_unlock(&dev->struct_mutex); - if (node) - break; - } - - if ((type_ok && (mem_type == DRM_BO_MEM_LOCAL)) || node) { - mem->mm_node = node; - mem->mem_type = mem_type; - mem->flags = cur_flags; - return 0; - } - - if (!type_found) - return -EINVAL; - - num_prios = dev->driver->bo_driver->num_mem_busy_prio; - prios = dev->driver->bo_driver->mem_busy_prio; - - for (i = 0; i < num_prios; ++i) { - mem_type = prios[i]; - man = &bm->man[mem_type]; - - if (!man->has_type) - continue; - - if (!drm_bo_mt_compatible(man, - bo->type == drm_bo_type_user, - mem_type, - mem->proposed_flags, - &cur_flags)) - continue; - - ret = drm_bo_mem_force_space(dev, mem, mem_type, no_wait); - - if (ret == 0 && mem->mm_node) { - mem->flags = cur_flags; - return 0; - } - - if (ret == -EAGAIN) - has_eagain = 1; - } - - ret = (has_eagain) ? -EAGAIN : -ENOMEM; - return ret; -} -EXPORT_SYMBOL(drm_bo_mem_space); - -/* - * drm_bo_propose_flags: - * - * @bo: the buffer object getting new flags - * - * @new_flags: the new set of proposed flag bits - * - * @new_mask: the mask of bits changed in new_flags - * - * Modify the proposed_flag bits in @bo - */ -static int drm_bo_modify_proposed_flags (struct drm_buffer_object *bo, - uint64_t new_flags, uint64_t new_mask) -{ - uint32_t new_access; - - /* Copy unchanging bits from existing proposed_flags */ - DRM_FLAG_MASKED(new_flags, bo->mem.proposed_flags, ~new_mask); - - if (bo->type == drm_bo_type_user && - ((new_flags & (DRM_BO_FLAG_CACHED | DRM_BO_FLAG_FORCE_CACHING)) != - (DRM_BO_FLAG_CACHED | DRM_BO_FLAG_FORCE_CACHING))) { - DRM_ERROR("User buffers require cache-coherent memory.\n"); - return -EINVAL; - } - - if (bo->type != drm_bo_type_kernel && (new_mask & DRM_BO_FLAG_NO_EVICT) && !DRM_SUSER(DRM_CURPROC)) { - DRM_ERROR("DRM_BO_FLAG_NO_EVICT is only available to priviliged processes.\n"); - return -EPERM; - } - - if (likely(new_mask & DRM_BO_MASK_MEM) && - (bo->mem.flags & DRM_BO_FLAG_NO_EVICT) && - !DRM_SUSER(DRM_CURPROC)) { - if (likely(bo->mem.flags & new_flags & new_mask & - DRM_BO_MASK_MEM)) - new_flags = (new_flags & ~DRM_BO_MASK_MEM) | - (bo->mem.flags & DRM_BO_MASK_MEM); - else { - DRM_ERROR("Incompatible memory type specification " - "for NO_EVICT buffer.\n"); - return -EPERM; - } - } - - if ((new_flags & DRM_BO_FLAG_NO_MOVE)) { - DRM_ERROR("DRM_BO_FLAG_NO_MOVE is not properly implemented yet.\n"); - return -EPERM; - } - - new_access = new_flags & (DRM_BO_FLAG_EXE | DRM_BO_FLAG_WRITE | - DRM_BO_FLAG_READ); - - if (new_access == 0) { - DRM_ERROR("Invalid buffer object rwx properties\n"); - return -EINVAL; - } - - bo->mem.proposed_flags = new_flags; - return 0; -} - -/* - * Call dev->struct_mutex locked. - */ - -struct drm_buffer_object *drm_lookup_buffer_object(struct drm_file *file_priv, - uint32_t handle, int check_owner) -{ - struct drm_user_object *uo; - struct drm_buffer_object *bo; - - uo = drm_lookup_user_object(file_priv, handle); - - if (!uo || (uo->type != drm_buffer_type)) { - DRM_ERROR("Could not find buffer object 0x%08x\n", handle); - return NULL; - } - - if (check_owner && file_priv != uo->owner) { - if (!drm_lookup_ref_object(file_priv, uo, _DRM_REF_USE)) - return NULL; - } - - bo = drm_user_object_entry(uo, struct drm_buffer_object, base); - atomic_inc(&bo->usage); - return bo; -} -EXPORT_SYMBOL(drm_lookup_buffer_object); - -/* - * Call bo->mutex locked. - * Returns -EBUSY if the buffer is currently rendered to or from. 0 otherwise. - * Doesn't do any fence flushing as opposed to the drm_bo_busy function. - */ - -static int drm_bo_quick_busy(struct drm_buffer_object *bo, int check_unfenced) -{ - struct drm_fence_object *fence = bo->fence; - - if (check_unfenced && (bo->priv_flags & _DRM_BO_FLAG_UNFENCED)) - return -EBUSY; - - if (fence) { - if (drm_fence_object_signaled(fence, bo->fence_type)) { - drm_fence_usage_deref_unlocked(&bo->fence); - return 0; - } - return -EBUSY; - } - return 0; -} - -int drm_bo_evict_cached(struct drm_buffer_object *bo) -{ - int ret = 0; - - BUG_ON(bo->priv_flags & _DRM_BO_FLAG_UNFENCED); - if (bo->mem.mm_node) - ret = drm_bo_evict(bo, DRM_BO_MEM_TT, 1); - return ret; -} - -EXPORT_SYMBOL(drm_bo_evict_cached); -/* - * Wait until a buffer is unmapped. - */ - -static int drm_bo_wait_unmapped(struct drm_buffer_object *bo, int no_wait) -{ - int ret = 0; - - if (likely(atomic_read(&bo->mapped)) == 0) - return 0; - - if (unlikely(no_wait)) - return -EBUSY; - - do { - mutex_unlock(&bo->mutex); - ret = wait_event_interruptible(bo->event_queue, - atomic_read(&bo->mapped) == 0); - mutex_lock(&bo->mutex); - bo->priv_flags |= _DRM_BO_FLAG_UNLOCKED; - - if (ret == -ERESTARTSYS) - ret = -EAGAIN; - } while((ret == 0) && atomic_read(&bo->mapped) > 0); - - return ret; -} - -/* - * Fill in the ioctl reply argument with buffer info. - * Bo locked. - */ - -void drm_bo_fill_rep_arg(struct drm_buffer_object *bo, - struct drm_bo_info_rep *rep) -{ - if (!rep) - return; - - rep->handle = bo->base.hash.key; - rep->flags = bo->mem.flags; - rep->size = bo->num_pages * PAGE_SIZE; - rep->offset = bo->offset; - - /* - * drm_bo_type_device buffers have user-visible - * handles which can be used to share across - * processes. Hand that back to the application - */ - if (bo->type == drm_bo_type_device) - rep->arg_handle = bo->map_list.user_token; - else - rep->arg_handle = 0; - - rep->proposed_flags = bo->mem.proposed_flags; - rep->buffer_start = bo->buffer_start; - rep->fence_flags = bo->fence_type; - rep->rep_flags = 0; - rep->page_alignment = bo->mem.page_alignment; - - if ((bo->priv_flags & _DRM_BO_FLAG_UNFENCED) || drm_bo_quick_busy(bo, 1)) { - DRM_FLAG_MASKED(rep->rep_flags, DRM_BO_REP_BUSY, - DRM_BO_REP_BUSY); - } -} -EXPORT_SYMBOL(drm_bo_fill_rep_arg); - -/* - * Wait for buffer idle and register that we've mapped the buffer. - * Mapping is registered as a drm_ref_object with type _DRM_REF_TYPE1, - * so that if the client dies, the mapping is automatically - * unregistered. - */ - -static int drm_buffer_object_map(struct drm_file *file_priv, uint32_t handle, - uint32_t map_flags, unsigned hint, - struct drm_bo_info_rep *rep) -{ - struct drm_buffer_object *bo; - struct drm_device *dev = file_priv->minor->dev; - int ret = 0; - int no_wait = hint & DRM_BO_HINT_DONT_BLOCK; - - mutex_lock(&dev->struct_mutex); - bo = drm_lookup_buffer_object(file_priv, handle, 1); - mutex_unlock(&dev->struct_mutex); - - if (!bo) - return -EINVAL; - - mutex_lock(&bo->mutex); - do { - bo->priv_flags &= ~_DRM_BO_FLAG_UNLOCKED; - - ret = drm_bo_wait(bo, 0, 1, no_wait, 1); - if (unlikely(ret)) - goto out; - - if (bo->mem.flags & DRM_BO_FLAG_CACHED_MAPPED) - drm_bo_evict_cached(bo); - - } while (unlikely(bo->priv_flags & _DRM_BO_FLAG_UNLOCKED)); - - atomic_inc(&bo->mapped); - mutex_lock(&dev->struct_mutex); - ret = drm_add_ref_object(file_priv, &bo->base, _DRM_REF_TYPE1); - mutex_unlock(&dev->struct_mutex); - if (ret) { - if (atomic_dec_and_test(&bo->mapped)) - wake_up_all(&bo->event_queue); - - } else - drm_bo_fill_rep_arg(bo, rep); - - out: - mutex_unlock(&bo->mutex); - drm_bo_usage_deref_unlocked(&bo); - - return ret; -} - -static int drm_buffer_object_unmap(struct drm_file *file_priv, uint32_t handle) -{ - struct drm_device *dev = file_priv->minor->dev; - struct drm_buffer_object *bo; - struct drm_ref_object *ro; - int ret = 0; - - mutex_lock(&dev->struct_mutex); - - bo = drm_lookup_buffer_object(file_priv, handle, 1); - if (!bo) { - ret = -EINVAL; - goto out; - } - - ro = drm_lookup_ref_object(file_priv, &bo->base, _DRM_REF_TYPE1); - if (!ro) { - ret = -EINVAL; - goto out; - } - - drm_remove_ref_object(file_priv, ro); - drm_bo_usage_deref_locked(&bo); -out: - mutex_unlock(&dev->struct_mutex); - return ret; -} - -/* - * Call struct-sem locked. - */ - -static void drm_buffer_user_object_unmap(struct drm_file *file_priv, - struct drm_user_object *uo, - enum drm_ref_type action) -{ - struct drm_buffer_object *bo = - drm_user_object_entry(uo, struct drm_buffer_object, base); - - /* - * We DON'T want to take the bo->lock here, because we want to - * hold it when we wait for unmapped buffer. - */ - - BUG_ON(action != _DRM_REF_TYPE1); - - if (atomic_dec_and_test(&bo->mapped)) - wake_up_all(&bo->event_queue); -} - -/* - * bo->mutex locked. - * Note that new_mem_flags are NOT transferred to the bo->mem.proposed_flags. - */ - -int drm_bo_move_buffer(struct drm_buffer_object *bo, uint64_t new_mem_flags, - int no_wait, int move_unfenced) -{ - struct drm_device *dev = bo->dev; - struct drm_buffer_manager *bm = &dev->bm; - int ret = 0; - struct drm_bo_mem_reg mem; - - BUG_ON(bo->fence != NULL); - - mem.num_pages = bo->num_pages; - mem.size = mem.num_pages << PAGE_SHIFT; - mem.proposed_flags = new_mem_flags; - mem.page_alignment = bo->mem.page_alignment; - - mutex_lock(&bm->evict_mutex); - mutex_lock(&dev->struct_mutex); - list_del_init(&bo->lru); - mutex_unlock(&dev->struct_mutex); - - /* - * Determine where to move the buffer. - */ - ret = drm_bo_mem_space(bo, &mem, no_wait); - if (ret) - goto out_unlock; - - ret = drm_bo_handle_move_mem(bo, &mem, 0, no_wait); - -out_unlock: - mutex_lock(&dev->struct_mutex); - if (ret || !move_unfenced) { - if (mem.mm_node) { - if (mem.mm_node != bo->pinned_node) - drm_mm_put_block(mem.mm_node); - mem.mm_node = NULL; - } - drm_bo_add_to_lru(bo); - if (bo->priv_flags & _DRM_BO_FLAG_UNFENCED) { - wake_up_all(&bo->event_queue); - DRM_FLAG_MASKED(bo->priv_flags, 0, - _DRM_BO_FLAG_UNFENCED); - } - } else { - list_add_tail(&bo->lru, &bm->unfenced); - DRM_FLAG_MASKED(bo->priv_flags, _DRM_BO_FLAG_UNFENCED, - _DRM_BO_FLAG_UNFENCED); - } - mutex_unlock(&dev->struct_mutex); - mutex_unlock(&bm->evict_mutex); - return ret; -} - -static int drm_bo_mem_compat(struct drm_bo_mem_reg *mem) -{ - uint32_t flag_diff = (mem->proposed_flags ^ mem->flags); - - if ((mem->proposed_flags & mem->flags & DRM_BO_MASK_MEM) == 0) - return 0; - if ((flag_diff & DRM_BO_FLAG_CACHED) && - (/* !(mem->proposed_flags & DRM_BO_FLAG_CACHED) ||*/ - (mem->proposed_flags & DRM_BO_FLAG_FORCE_CACHING))) - return 0; - - if ((flag_diff & DRM_BO_FLAG_MAPPABLE) && - ((mem->proposed_flags & DRM_BO_FLAG_MAPPABLE) || - (mem->proposed_flags & DRM_BO_FLAG_FORCE_MAPPABLE))) - return 0; - return 1; -} - -/** - * drm_buffer_object_validate: - * - * @bo: the buffer object to modify - * - * @fence_class: the new fence class covering this buffer - * - * @move_unfenced: a boolean indicating whether switching the - * memory space of this buffer should cause the buffer to - * be placed on the unfenced list. - * - * @no_wait: whether this function should return -EBUSY instead - * of waiting. - * - * Change buffer access parameters. This can involve moving - * the buffer to the correct memory type, pinning the buffer - * or changing the class/type of fence covering this buffer - * - * Must be called with bo locked. - */ - -static int drm_buffer_object_validate(struct drm_buffer_object *bo, - uint32_t fence_class, - int move_unfenced, int no_wait, - int move_buffer) -{ - struct drm_device *dev = bo->dev; - struct drm_buffer_manager *bm = &dev->bm; - int ret; - - if (move_buffer) { - ret = drm_bo_move_buffer(bo, bo->mem.proposed_flags, no_wait, - move_unfenced); - if (ret) { - if (ret != -EAGAIN) - DRM_ERROR("Failed moving buffer.\n"); - if (ret == -ENOMEM) - DRM_ERROR("Out of aperture space or " - "DRM memory quota.\n"); - return ret; - } - } - - /* - * Pinned buffers. - */ - - if (bo->mem.proposed_flags & (DRM_BO_FLAG_NO_EVICT | DRM_BO_FLAG_NO_MOVE)) { - bo->pinned_mem_type = bo->mem.mem_type; - mutex_lock(&dev->struct_mutex); - list_del_init(&bo->pinned_lru); - drm_bo_add_to_pinned_lru(bo); - - if (bo->pinned_node != bo->mem.mm_node) { - if (bo->pinned_node != NULL) - drm_mm_put_block(bo->pinned_node); - bo->pinned_node = bo->mem.mm_node; - } - - mutex_unlock(&dev->struct_mutex); - - } else if (bo->pinned_node != NULL) { - - mutex_lock(&dev->struct_mutex); - - if (bo->pinned_node != bo->mem.mm_node) - drm_mm_put_block(bo->pinned_node); - - list_del_init(&bo->pinned_lru); - bo->pinned_node = NULL; - mutex_unlock(&dev->struct_mutex); - - } - - /* - * We might need to add a TTM. - */ - - if (bo->mem.mem_type == DRM_BO_MEM_LOCAL && bo->ttm == NULL) { - ret = drm_bo_add_ttm(bo); - if (ret) - return ret; - } - /* - * Validation has succeeded, move the access and other - * non-mapping-related flag bits from the proposed flags to - * the active flags - */ - - DRM_FLAG_MASKED(bo->mem.flags, bo->mem.proposed_flags, ~DRM_BO_MASK_MEMTYPE); - - /* - * Finally, adjust lru to be sure. - */ - - mutex_lock(&dev->struct_mutex); - list_del(&bo->lru); - if (move_unfenced) { - list_add_tail(&bo->lru, &bm->unfenced); - DRM_FLAG_MASKED(bo->priv_flags, _DRM_BO_FLAG_UNFENCED, - _DRM_BO_FLAG_UNFENCED); - } else { - drm_bo_add_to_lru(bo); - if (bo->priv_flags & _DRM_BO_FLAG_UNFENCED) { - wake_up_all(&bo->event_queue); - DRM_FLAG_MASKED(bo->priv_flags, 0, - _DRM_BO_FLAG_UNFENCED); - } - } - mutex_unlock(&dev->struct_mutex); - - return 0; -} - -/* - * This function is called with bo->mutex locked, but may release it - * temporarily to wait for events. - */ - -static int drm_bo_prepare_for_validate(struct drm_buffer_object *bo, - uint64_t flags, - uint64_t mask, - uint32_t hint, - uint32_t fence_class, - int no_wait, - int *move_buffer) -{ - struct drm_device *dev = bo->dev; - struct drm_bo_driver *driver = dev->driver->bo_driver; - uint32_t ftype; - - int ret; - - DRM_DEBUG("Proposed flags 0x%016llx, Old flags 0x%016llx\n", - (unsigned long long) bo->mem.proposed_flags, - (unsigned long long) bo->mem.flags); - - ret = drm_bo_modify_proposed_flags (bo, flags, mask); - if (ret) - return ret; - - ret = drm_bo_wait_unmapped(bo, no_wait); - if (ret) - return ret; - - ret = driver->fence_type(bo, &fence_class, &ftype); - - if (ret) { - DRM_ERROR("Driver did not support given buffer permissions.\n"); - return ret; - } - - /* - * We're switching command submission mechanism, - * or cannot simply rely on the hardware serializing for us. - * Insert a driver-dependant barrier or wait for buffer idle. - */ - - if ((fence_class != bo->fence_class) || - ((ftype ^ bo->fence_type) & bo->fence_type)) { - - ret = -EINVAL; - if (driver->command_stream_barrier) { - ret = driver->command_stream_barrier(bo, - fence_class, - ftype, - no_wait); - } - if (ret && ret != -EAGAIN) - ret = drm_bo_wait(bo, 0, 1, no_wait, 1); - - if (ret) - return ret; - } - - bo->new_fence_class = fence_class; - bo->new_fence_type = ftype; - - /* - * Check whether we need to move buffer. - */ - - *move_buffer = 0; - if (!drm_bo_mem_compat(&bo->mem)) { - *move_buffer = 1; - ret = drm_bo_wait(bo, 0, 1, no_wait, 1); - } - - return ret; -} - -/** - * drm_bo_do_validate: - * - * @bo: the buffer object - * - * @flags: access rights, mapping parameters and cacheability. See - * the DRM_BO_FLAG_* values in drm.h - * - * @mask: Which flag values to change; this allows callers to modify - * things without knowing the current state of other flags. - * - * @hint: changes the proceedure for this operation, see the DRM_BO_HINT_* - * values in drm.h. - * - * @fence_class: a driver-specific way of doing fences. Presumably, - * this would be used if the driver had more than one submission and - * fencing mechanism. At this point, there isn't any use of this - * from the user mode code. - * - * @rep: To be stuffed with the reply from validation - * - * 'validate' a buffer object. This changes where the buffer is - * located, along with changing access modes. - */ - -int drm_bo_do_validate(struct drm_buffer_object *bo, - uint64_t flags, uint64_t mask, uint32_t hint, - uint32_t fence_class, - struct drm_bo_info_rep *rep) -{ - int ret; - int no_wait = (hint & DRM_BO_HINT_DONT_BLOCK) != 0; - int move_buffer; - - mutex_lock(&bo->mutex); - - do { - bo->priv_flags &= ~_DRM_BO_FLAG_UNLOCKED; - - ret = drm_bo_prepare_for_validate(bo, flags, mask, hint, - fence_class, no_wait, - &move_buffer); - if (ret) - goto out; - - } while(unlikely(bo->priv_flags & _DRM_BO_FLAG_UNLOCKED)); - - ret = drm_buffer_object_validate(bo, - fence_class, - !(hint & DRM_BO_HINT_DONT_FENCE), - no_wait, - move_buffer); - - BUG_ON(bo->priv_flags & _DRM_BO_FLAG_UNLOCKED); -out: - if (rep) - drm_bo_fill_rep_arg(bo, rep); - - mutex_unlock(&bo->mutex); - - return ret; -} -EXPORT_SYMBOL(drm_bo_do_validate); - -/** - * drm_bo_handle_validate - * - * @file_priv: the drm file private, used to get a handle to the user context - * - * @handle: the buffer object handle - * - * @flags: access rights, mapping parameters and cacheability. See - * the DRM_BO_FLAG_* values in drm.h - * - * @mask: Which flag values to change; this allows callers to modify - * things without knowing the current state of other flags. - * - * @hint: changes the proceedure for this operation, see the DRM_BO_HINT_* - * values in drm.h. - * - * @fence_class: a driver-specific way of doing fences. Presumably, - * this would be used if the driver had more than one submission and - * fencing mechanism. At this point, there isn't any use of this - * from the user mode code. - * - * @rep: To be stuffed with the reply from validation - * - * @bp_rep: To be stuffed with the buffer object pointer - * - * Perform drm_bo_do_validate on a buffer referenced by a user-space handle instead - * of a pointer to a buffer object. Optionally return a pointer to the buffer object. - * This is a convenience wrapper only. - */ - -int drm_bo_handle_validate(struct drm_file *file_priv, uint32_t handle, - uint64_t flags, uint64_t mask, - uint32_t hint, - uint32_t fence_class, - struct drm_bo_info_rep *rep, - struct drm_buffer_object **bo_rep) -{ - struct drm_device *dev = file_priv->minor->dev; - struct drm_buffer_object *bo; - int ret; - - mutex_lock(&dev->struct_mutex); - bo = drm_lookup_buffer_object(file_priv, handle, 1); - mutex_unlock(&dev->struct_mutex); - - if (!bo) - return -EINVAL; - - if (bo->base.owner != file_priv) - mask &= ~(DRM_BO_FLAG_NO_EVICT | DRM_BO_FLAG_NO_MOVE); - - ret = drm_bo_do_validate(bo, flags, mask, hint, fence_class, rep); - - if (!ret && bo_rep) - *bo_rep = bo; - else - drm_bo_usage_deref_unlocked(&bo); - - return ret; -} -EXPORT_SYMBOL(drm_bo_handle_validate); - - -static int drm_bo_handle_info(struct drm_file *file_priv, uint32_t handle, - struct drm_bo_info_rep *rep) -{ - struct drm_device *dev = file_priv->minor->dev; - struct drm_buffer_object *bo; - - mutex_lock(&dev->struct_mutex); - bo = drm_lookup_buffer_object(file_priv, handle, 1); - mutex_unlock(&dev->struct_mutex); - - if (!bo) - return -EINVAL; - - mutex_lock(&bo->mutex); - - /* - * FIXME: Quick busy here? - */ - - drm_bo_busy(bo, 1); - drm_bo_fill_rep_arg(bo, rep); - mutex_unlock(&bo->mutex); - drm_bo_usage_deref_unlocked(&bo); - return 0; -} - -static int drm_bo_handle_wait(struct drm_file *file_priv, uint32_t handle, - uint32_t hint, - struct drm_bo_info_rep *rep) -{ - struct drm_device *dev = file_priv->minor->dev; - struct drm_buffer_object *bo; - int no_wait = hint & DRM_BO_HINT_DONT_BLOCK; - int ret; - - mutex_lock(&dev->struct_mutex); - bo = drm_lookup_buffer_object(file_priv, handle, 1); - mutex_unlock(&dev->struct_mutex); - - if (!bo) - return -EINVAL; - - mutex_lock(&bo->mutex); - ret = drm_bo_wait(bo, hint & DRM_BO_HINT_WAIT_LAZY, 1, no_wait, 1); - if (ret) - goto out; - - drm_bo_fill_rep_arg(bo, rep); -out: - mutex_unlock(&bo->mutex); - drm_bo_usage_deref_unlocked(&bo); - return ret; -} - -int drm_buffer_object_create(struct drm_device *dev, - unsigned long size, - enum drm_bo_type type, - uint64_t flags, - uint32_t hint, - uint32_t page_alignment, - unsigned long buffer_start, - struct drm_buffer_object **buf_obj) -{ - struct drm_buffer_manager *bm = &dev->bm; - struct drm_buffer_object *bo; - int ret = 0; - unsigned long num_pages; - - size += buffer_start & ~PAGE_MASK; - num_pages = (size + PAGE_SIZE - 1) >> PAGE_SHIFT; - if (num_pages == 0) { - DRM_ERROR("Illegal buffer object size.\n"); - return -EINVAL; - } - - bo = drm_ctl_calloc(1, sizeof(*bo), DRM_MEM_BUFOBJ); - - if (!bo) - return -ENOMEM; - - mutex_init(&bo->mutex); - mutex_lock(&bo->mutex); - - atomic_set(&bo->usage, 1); - atomic_set(&bo->mapped, 0); - DRM_INIT_WAITQUEUE(&bo->event_queue); - INIT_LIST_HEAD(&bo->lru); - INIT_LIST_HEAD(&bo->pinned_lru); - INIT_LIST_HEAD(&bo->ddestroy); - bo->dev = dev; - bo->type = type; - bo->num_pages = num_pages; - bo->mem.mem_type = DRM_BO_MEM_LOCAL; - bo->mem.num_pages = bo->num_pages; - bo->mem.mm_node = NULL; - bo->mem.page_alignment = page_alignment; - bo->buffer_start = buffer_start & PAGE_MASK; - bo->priv_flags = 0; - bo->mem.flags = (DRM_BO_FLAG_MEM_LOCAL | DRM_BO_FLAG_CACHED | - DRM_BO_FLAG_MAPPABLE); - bo->mem.proposed_flags = 0; - atomic_inc(&bm->count); - /* - * Use drm_bo_modify_proposed_flags to error-check the proposed flags - */ - ret = drm_bo_modify_proposed_flags (bo, flags, flags); - if (ret) - goto out_err; - - /* - * For drm_bo_type_device buffers, allocate - * address space from the device so that applications - * can mmap the buffer from there - */ - if (bo->type == drm_bo_type_device) { - mutex_lock(&dev->struct_mutex); - ret = drm_bo_setup_vm_locked(bo); - mutex_unlock(&dev->struct_mutex); - if (ret) - goto out_err; - } - - mutex_unlock(&bo->mutex); - ret = drm_bo_do_validate(bo, 0, 0, hint | DRM_BO_HINT_DONT_FENCE, - 0, NULL); - if (ret) - goto out_err_unlocked; - - *buf_obj = bo; - return 0; - -out_err: - mutex_unlock(&bo->mutex); -out_err_unlocked: - drm_bo_usage_deref_unlocked(&bo); - return ret; -} -EXPORT_SYMBOL(drm_buffer_object_create); - - -static int drm_bo_add_user_object(struct drm_file *file_priv, - struct drm_buffer_object *bo, int shareable) -{ - struct drm_device *dev = file_priv->minor->dev; - int ret; - - mutex_lock(&dev->struct_mutex); - ret = drm_add_user_object(file_priv, &bo->base, shareable); - if (ret) - goto out; - - bo->base.remove = drm_bo_base_deref_locked; - bo->base.type = drm_buffer_type; - bo->base.ref_struct_locked = NULL; - bo->base.unref = drm_buffer_user_object_unmap; - -out: - mutex_unlock(&dev->struct_mutex); - return ret; -} - -int drm_bo_create_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv) -{ - struct drm_bo_create_arg *arg = data; - struct drm_bo_create_req *req = &arg->d.req; - struct drm_bo_info_rep *rep = &arg->d.rep; - struct drm_buffer_object *entry; - enum drm_bo_type bo_type; - int ret = 0; - - DRM_DEBUG("drm_bo_create_ioctl: %dkb, %dkb align\n", - (int)(req->size / 1024), req->page_alignment * 4); - - if (!dev->bm.initialized) { - DRM_ERROR("Buffer object manager is not initialized.\n"); - return -EINVAL; - } - - /* - * If the buffer creation request comes in with a starting address, - * that points at the desired user pages to map. Otherwise, create - * a drm_bo_type_device buffer, which uses pages allocated from the kernel - */ - bo_type = (req->buffer_start) ? drm_bo_type_user : drm_bo_type_device; - - /* - * User buffers cannot be shared - */ - if (bo_type == drm_bo_type_user) - req->flags &= ~DRM_BO_FLAG_SHAREABLE; - - ret = drm_buffer_object_create(file_priv->minor->dev, - req->size, bo_type, req->flags, - req->hint, req->page_alignment, - req->buffer_start, &entry); - if (ret) - goto out; - - ret = drm_bo_add_user_object(file_priv, entry, - req->flags & DRM_BO_FLAG_SHAREABLE); - if (ret) { - drm_bo_usage_deref_unlocked(&entry); - goto out; - } - - mutex_lock(&entry->mutex); - drm_bo_fill_rep_arg(entry, rep); - mutex_unlock(&entry->mutex); - -out: - return ret; -} - -int drm_bo_setstatus_ioctl(struct drm_device *dev, - void *data, struct drm_file *file_priv) -{ - struct drm_bo_map_wait_idle_arg *arg = data; - struct drm_bo_info_req *req = &arg->d.req; - struct drm_bo_info_rep *rep = &arg->d.rep; - struct drm_buffer_object *bo; - int ret; - - if (!dev->bm.initialized) { - DRM_ERROR("Buffer object manager is not initialized.\n"); - return -EINVAL; - } - - ret = drm_bo_read_lock(&dev->bm.bm_lock, 1); - if (ret) - return ret; - - mutex_lock(&dev->struct_mutex); - bo = drm_lookup_buffer_object(file_priv, req->handle, 1); - mutex_unlock(&dev->struct_mutex); - - if (!bo) - return -EINVAL; - - if (bo->base.owner != file_priv) - req->mask &= ~(DRM_BO_FLAG_NO_EVICT | DRM_BO_FLAG_NO_MOVE); - - ret = drm_bo_do_validate(bo, req->flags, req->mask, - req->hint | DRM_BO_HINT_DONT_FENCE, - bo->fence_class, rep); - - drm_bo_usage_deref_unlocked(&bo); - - (void) drm_bo_read_unlock(&dev->bm.bm_lock); - - return ret; -} - -int drm_bo_map_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv) -{ - struct drm_bo_map_wait_idle_arg *arg = data; - struct drm_bo_info_req *req = &arg->d.req; - struct drm_bo_info_rep *rep = &arg->d.rep; - int ret; - if (!dev->bm.initialized) { - DRM_ERROR("Buffer object manager is not initialized.\n"); - return -EINVAL; - } - - ret = drm_buffer_object_map(file_priv, req->handle, req->mask, - req->hint, rep); - if (ret) - return ret; - - return 0; -} - -int drm_bo_unmap_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv) -{ - struct drm_bo_handle_arg *arg = data; - int ret; - if (!dev->bm.initialized) { - DRM_ERROR("Buffer object manager is not initialized.\n"); - return -EINVAL; - } - - ret = drm_buffer_object_unmap(file_priv, arg->handle); - return ret; -} - - -int drm_bo_reference_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv) -{ - struct drm_bo_reference_info_arg *arg = data; - struct drm_bo_handle_arg *req = &arg->d.req; - struct drm_bo_info_rep *rep = &arg->d.rep; - struct drm_user_object *uo; - int ret; - - if (!dev->bm.initialized) { - DRM_ERROR("Buffer object manager is not initialized.\n"); - return -EINVAL; - } - - ret = drm_user_object_ref(file_priv, req->handle, - drm_buffer_type, &uo); - if (ret) - return ret; - - ret = drm_bo_handle_info(file_priv, req->handle, rep); - if (ret) - return ret; - - return 0; -} - -int drm_bo_unreference_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv) -{ - struct drm_bo_handle_arg *arg = data; - int ret = 0; - - if (!dev->bm.initialized) { - DRM_ERROR("Buffer object manager is not initialized.\n"); - return -EINVAL; - } - - ret = drm_user_object_unref(file_priv, arg->handle, drm_buffer_type); - return ret; -} - -int drm_bo_info_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv) -{ - struct drm_bo_reference_info_arg *arg = data; - struct drm_bo_handle_arg *req = &arg->d.req; - struct drm_bo_info_rep *rep = &arg->d.rep; - int ret; - - if (!dev->bm.initialized) { - DRM_ERROR("Buffer object manager is not initialized.\n"); - return -EINVAL; - } - - ret = drm_bo_handle_info(file_priv, req->handle, rep); - if (ret) - return ret; - - return 0; -} - -int drm_bo_wait_idle_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv) -{ - struct drm_bo_map_wait_idle_arg *arg = data; - struct drm_bo_info_req *req = &arg->d.req; - struct drm_bo_info_rep *rep = &arg->d.rep; - int ret; - if (!dev->bm.initialized) { - DRM_ERROR("Buffer object manager is not initialized.\n"); - return -EINVAL; - } - - ret = drm_bo_handle_wait(file_priv, req->handle, - req->hint, rep); - if (ret) - return ret; - - return 0; -} - -static int drm_bo_leave_list(struct drm_buffer_object *bo, - uint32_t mem_type, - int free_pinned, - int allow_errors) -{ - struct drm_device *dev = bo->dev; - int ret = 0; - - mutex_lock(&bo->mutex); - - ret = drm_bo_expire_fence(bo, allow_errors); - if (ret) - goto out; - - if (free_pinned) { - DRM_FLAG_MASKED(bo->mem.flags, 0, DRM_BO_FLAG_NO_MOVE); - mutex_lock(&dev->struct_mutex); - list_del_init(&bo->pinned_lru); - if (bo->pinned_node == bo->mem.mm_node) - bo->pinned_node = NULL; - if (bo->pinned_node != NULL) { - drm_mm_put_block(bo->pinned_node); - bo->pinned_node = NULL; - } - mutex_unlock(&dev->struct_mutex); - } - - if (bo->mem.flags & DRM_BO_FLAG_NO_EVICT) { - DRM_ERROR("A DRM_BO_NO_EVICT buffer present at " - "cleanup. Removing flag and evicting.\n"); - bo->mem.flags &= ~DRM_BO_FLAG_NO_EVICT; - bo->mem.proposed_flags &= ~DRM_BO_FLAG_NO_EVICT; - } - - if (bo->mem.mem_type == mem_type) - ret = drm_bo_evict(bo, mem_type, 0); - - if (ret) { - if (allow_errors) { - goto out; - } else { - ret = 0; - DRM_ERROR("Cleanup eviction failed\n"); - } - } - -out: - mutex_unlock(&bo->mutex); - return ret; -} - - -static struct drm_buffer_object *drm_bo_entry(struct list_head *list, - int pinned_list) -{ - if (pinned_list) - return list_entry(list, struct drm_buffer_object, pinned_lru); - else - return list_entry(list, struct drm_buffer_object, lru); -} - -/* - * dev->struct_mutex locked. - */ - -static int drm_bo_force_list_clean(struct drm_device *dev, - struct list_head *head, - unsigned mem_type, - int free_pinned, - int allow_errors, - int pinned_list) -{ - struct list_head *list, *next, *prev; - struct drm_buffer_object *entry, *nentry; - int ret; - int do_restart; - - /* - * The list traversal is a bit odd here, because an item may - * disappear from the list when we release the struct_mutex or - * when we decrease the usage count. Also we're not guaranteed - * to drain pinned lists, so we can't always restart. - */ - -restart: - nentry = NULL; - list_for_each_safe(list, next, head) { - prev = list->prev; - - entry = (nentry != NULL) ? nentry: drm_bo_entry(list, pinned_list); - atomic_inc(&entry->usage); - if (nentry) { - atomic_dec(&nentry->usage); - nentry = NULL; - } - - /* - * Protect the next item from destruction, so we can check - * its list pointers later on. - */ - - if (next != head) { - nentry = drm_bo_entry(next, pinned_list); - atomic_inc(&nentry->usage); - } - mutex_unlock(&dev->struct_mutex); - - ret = drm_bo_leave_list(entry, mem_type, free_pinned, - allow_errors); - mutex_lock(&dev->struct_mutex); - - drm_bo_usage_deref_locked(&entry); - if (ret) - return ret; - - /* - * Has the next item disappeared from the list? - */ - - do_restart = ((next->prev != list) && (next->prev != prev)); - - if (nentry != NULL && do_restart) - drm_bo_usage_deref_locked(&nentry); - - if (do_restart) - goto restart; - } - return 0; -} - -int drm_bo_clean_mm(struct drm_device *dev, unsigned mem_type, int kern_clean) -{ - struct drm_buffer_manager *bm = &dev->bm; - struct drm_mem_type_manager *man = &bm->man[mem_type]; - int ret = -EINVAL; - - if (mem_type >= DRM_BO_MEM_TYPES) { - DRM_ERROR("Illegal memory type %d\n", mem_type); - return ret; - } - - if (!man->has_type) { - DRM_ERROR("Trying to take down uninitialized " - "memory manager type %u\n", mem_type); - return ret; - } - - if ((man->kern_init_type) && (kern_clean == 0)) { - DRM_ERROR("Trying to take down kernel initialized " - "memory manager type %u\n", mem_type); - return -EPERM; - } - - man->use_type = 0; - man->has_type = 0; - - ret = 0; - if (mem_type > 0) { - BUG_ON(!list_empty(&bm->unfenced)); - drm_bo_force_list_clean(dev, &man->lru, mem_type, 1, 0, 0); - drm_bo_force_list_clean(dev, &man->pinned, mem_type, 1, 0, 1); - - if (drm_mm_clean(&man->manager)) { - drm_mm_takedown(&man->manager); - } else { - ret = -EBUSY; - } - } - - return ret; -} -EXPORT_SYMBOL(drm_bo_clean_mm); - -/** - *Evict all buffers of a particular mem_type, but leave memory manager - *regions for NO_MOVE buffers intact. New buffers cannot be added at this - *point since we have the hardware lock. - */ - -static int drm_bo_lock_mm(struct drm_device *dev, unsigned mem_type) -{ - int ret; - struct drm_buffer_manager *bm = &dev->bm; - struct drm_mem_type_manager *man = &bm->man[mem_type]; - - if (mem_type == 0 || mem_type >= DRM_BO_MEM_TYPES) { - DRM_ERROR("Illegal memory manager memory type %u.\n", mem_type); - return -EINVAL; - } - - if (!man->has_type) { - DRM_ERROR("Memory type %u has not been initialized.\n", - mem_type); - return 0; - } - - ret = drm_bo_force_list_clean(dev, &man->lru, mem_type, 0, 1, 0); - if (ret) - return ret; - ret = drm_bo_force_list_clean(dev, &man->pinned, mem_type, 0, 1, 1); - - return ret; -} - -int drm_bo_init_mm(struct drm_device *dev, unsigned type, - unsigned long p_offset, unsigned long p_size, - int kern_init) -{ - struct drm_buffer_manager *bm = &dev->bm; - int ret = -EINVAL; - struct drm_mem_type_manager *man; - - if (type >= DRM_BO_MEM_TYPES) { - DRM_ERROR("Illegal memory type %d\n", type); - return ret; - } - - man = &bm->man[type]; - if (man->has_type) { - DRM_ERROR("Memory manager already initialized for type %d\n", - type); - return ret; - } - - ret = dev->driver->bo_driver->init_mem_type(dev, type, man); - if (ret) - return ret; - - ret = 0; - if (type != DRM_BO_MEM_LOCAL) { - if (!p_size) { - DRM_ERROR("Zero size memory manager type %d\n", type); - return ret; - } - ret = drm_mm_init(&man->manager, p_offset, p_size); - if (ret) - return ret; - } - man->has_type = 1; - man->use_type = 1; - man->kern_init_type = kern_init; - man->size = p_size; - - INIT_LIST_HEAD(&man->lru); - INIT_LIST_HEAD(&man->pinned); - - return 0; -} -EXPORT_SYMBOL(drm_bo_init_mm); - -/* - * This function is intended to be called on drm driver unload. - * If you decide to call it from lastclose, you must protect the call - * from a potentially racing drm_bo_driver_init in firstopen. - * (This may happen on X server restart). - */ - -int drm_bo_driver_finish(struct drm_device *dev) -{ - struct drm_buffer_manager *bm = &dev->bm; - int ret = 0; - unsigned i = DRM_BO_MEM_TYPES; - struct drm_mem_type_manager *man; - - mutex_lock(&dev->struct_mutex); - - if (!bm->initialized) - goto out; - bm->initialized = 0; - - while (i--) { - man = &bm->man[i]; - if (man->has_type) { - man->use_type = 0; - if ((i != DRM_BO_MEM_LOCAL) && drm_bo_clean_mm(dev, i, 1)) { - ret = -EBUSY; - DRM_ERROR("DRM memory manager type %d " - "is not clean.\n", i); - } - man->has_type = 0; - } - } - mutex_unlock(&dev->struct_mutex); - - if (!cancel_delayed_work(&bm->wq)) - flush_scheduled_work(); - - mutex_lock(&dev->struct_mutex); - drm_bo_delayed_delete(dev, 1); - if (list_empty(&bm->ddestroy)) - DRM_DEBUG("Delayed destroy list was clean\n"); - - if (list_empty(&bm->man[0].lru)) - DRM_DEBUG("Swap list was clean\n"); - - if (list_empty(&bm->man[0].pinned)) - DRM_DEBUG("NO_MOVE list was clean\n"); - - if (list_empty(&bm->unfenced)) - DRM_DEBUG("Unfenced list was clean\n"); - - __free_page(bm->dummy_read_page); - -out: - mutex_unlock(&dev->struct_mutex); - return ret; -} - -/* - * This function is intended to be called on drm driver load. - * If you decide to call it from firstopen, you must protect the call - * from a potentially racing drm_bo_driver_finish in lastclose. - * (This may happen on X server restart). - */ - -int drm_bo_driver_init(struct drm_device *dev) -{ - struct drm_bo_driver *driver = dev->driver->bo_driver; - struct drm_buffer_manager *bm = &dev->bm; - int ret = -EINVAL; - - bm->dummy_read_page = NULL; - drm_bo_init_lock(&bm->bm_lock); - mutex_lock(&dev->struct_mutex); - if (!driver) - goto out_unlock; - - bm->dummy_read_page = alloc_page(__GFP_ZERO | GFP_DMA32); - if (!bm->dummy_read_page) { - ret = -ENOMEM; - goto out_unlock; - } - - /* - * Initialize the system memory buffer type. - * Other types need to be driver / IOCTL initialized. - */ - ret = drm_bo_init_mm(dev, DRM_BO_MEM_LOCAL, 0, 0, 1); - if (ret) - goto out_unlock; - - INIT_DELAYED_WORK(&bm->wq, drm_bo_delayed_workqueue); - bm->initialized = 1; - bm->nice_mode = 1; - atomic_set(&bm->count, 0); - bm->cur_pages = 0; - INIT_LIST_HEAD(&bm->unfenced); - INIT_LIST_HEAD(&bm->ddestroy); -out_unlock: - mutex_unlock(&dev->struct_mutex); - return ret; -} -EXPORT_SYMBOL(drm_bo_driver_init); - -int drm_mm_init_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv) -{ - struct drm_mm_init_arg *arg = data; - struct drm_buffer_manager *bm = &dev->bm; - struct drm_bo_driver *driver = dev->driver->bo_driver; - int ret; - - if (!driver) { - DRM_ERROR("Buffer objects are not supported by this driver\n"); - return -EINVAL; - } - - ret = drm_bo_write_lock(&bm->bm_lock, 1, file_priv); - if (ret) - return ret; - - ret = -EINVAL; - if (arg->magic != DRM_BO_INIT_MAGIC) { - DRM_ERROR("You are using an old libdrm that is not compatible with\n" - "\tthe kernel DRM module. Please upgrade your libdrm.\n"); - return -EINVAL; - } - if (arg->major != DRM_BO_INIT_MAJOR) { - DRM_ERROR("libdrm and kernel DRM buffer object interface major\n" - "\tversion don't match. Got %d, expected %d.\n", - arg->major, DRM_BO_INIT_MAJOR); - return -EINVAL; - } - - mutex_lock(&dev->struct_mutex); - if (!bm->initialized) { - DRM_ERROR("DRM memory manager was not initialized.\n"); - goto out; - } - if (arg->mem_type == 0) { - DRM_ERROR("System memory buffers already initialized.\n"); - goto out; - } - ret = drm_bo_init_mm(dev, arg->mem_type, - arg->p_offset, arg->p_size, 0); - -out: - mutex_unlock(&dev->struct_mutex); - (void) drm_bo_write_unlock(&bm->bm_lock, file_priv); - - if (ret) - return ret; - - return 0; -} - -int drm_mm_takedown_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv) -{ - struct drm_mm_type_arg *arg = data; - struct drm_buffer_manager *bm = &dev->bm; - struct drm_bo_driver *driver = dev->driver->bo_driver; - int ret; - - if (!driver) { - DRM_ERROR("Buffer objects are not supported by this driver\n"); - return -EINVAL; - } - - ret = drm_bo_write_lock(&bm->bm_lock, 0, file_priv); - if (ret) - return ret; - - mutex_lock(&dev->struct_mutex); - ret = -EINVAL; - if (!bm->initialized) { - DRM_ERROR("DRM memory manager was not initialized\n"); - goto out; - } - if (arg->mem_type == 0) { - DRM_ERROR("No takedown for System memory buffers.\n"); - goto out; - } - ret = 0; - if ((ret = drm_bo_clean_mm(dev, arg->mem_type, 0))) { - if (ret == -EINVAL) - DRM_ERROR("Memory manager type %d not clean. " - "Delaying takedown\n", arg->mem_type); - ret = 0; - } -out: - mutex_unlock(&dev->struct_mutex); - (void) drm_bo_write_unlock(&bm->bm_lock, file_priv); - - if (ret) - return ret; - - return 0; -} - -int drm_mm_lock_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv) -{ - struct drm_mm_type_arg *arg = data; - struct drm_bo_driver *driver = dev->driver->bo_driver; - int ret; - - if (!driver) { - DRM_ERROR("Buffer objects are not supported by this driver\n"); - return -EINVAL; - } - - if (arg->lock_flags & DRM_BO_LOCK_IGNORE_NO_EVICT) { - DRM_ERROR("Lock flag DRM_BO_LOCK_IGNORE_NO_EVICT not supported yet.\n"); - return -EINVAL; - } - - if (arg->lock_flags & DRM_BO_LOCK_UNLOCK_BM) { - ret = drm_bo_write_lock(&dev->bm.bm_lock, 1, file_priv); - if (ret) - return ret; - } - - mutex_lock(&dev->struct_mutex); - ret = drm_bo_lock_mm(dev, arg->mem_type); - mutex_unlock(&dev->struct_mutex); - if (ret) { - (void) drm_bo_write_unlock(&dev->bm.bm_lock, file_priv); - return ret; - } - - return 0; -} - -int drm_mm_unlock_ioctl(struct drm_device *dev, - void *data, - struct drm_file *file_priv) -{ - struct drm_mm_type_arg *arg = data; - struct drm_bo_driver *driver = dev->driver->bo_driver; - int ret; - - if (!driver) { - DRM_ERROR("Buffer objects are not supported by this driver\n"); - return -EINVAL; - } - - if (arg->lock_flags & DRM_BO_LOCK_UNLOCK_BM) { - ret = drm_bo_write_unlock(&dev->bm.bm_lock, file_priv); - if (ret) - return ret; - } - - return 0; -} - -int drm_mm_info_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv) -{ - struct drm_mm_info_arg *arg = data; - struct drm_buffer_manager *bm = &dev->bm; - struct drm_bo_driver *driver = dev->driver->bo_driver; - struct drm_mem_type_manager *man; - int ret = 0; - int mem_type = arg->mem_type; - - if (!driver) { - DRM_ERROR("Buffer objects are not supported by this driver\n"); - return -EINVAL; - } - - if (mem_type >= DRM_BO_MEM_TYPES) { - DRM_ERROR("Illegal memory type %d\n", arg->mem_type); - return -EINVAL; - } - - mutex_lock(&dev->struct_mutex); - if (!bm->initialized) { - DRM_ERROR("DRM memory manager was not initialized\n"); - ret = -EINVAL; - goto out; - } - - - man = &bm->man[arg->mem_type]; - - arg->p_size = man->size; - -out: - mutex_unlock(&dev->struct_mutex); - - return ret; -} -/* - * buffer object vm functions. - */ - -int drm_mem_reg_is_pci(struct drm_device *dev, struct drm_bo_mem_reg *mem) -{ - struct drm_buffer_manager *bm = &dev->bm; - struct drm_mem_type_manager *man = &bm->man[mem->mem_type]; - - if (!(man->flags & _DRM_FLAG_MEMTYPE_FIXED)) { - if (mem->mem_type == DRM_BO_MEM_LOCAL) - return 0; - - if (man->flags & _DRM_FLAG_MEMTYPE_CMA) - return 0; - - if (mem->flags & DRM_BO_FLAG_CACHED) - return 0; - } - return 1; -} -EXPORT_SYMBOL(drm_mem_reg_is_pci); - -/** - * \c Get the PCI offset for the buffer object memory. - * - * \param bo The buffer object. - * \param bus_base On return the base of the PCI region - * \param bus_offset On return the byte offset into the PCI region - * \param bus_size On return the byte size of the buffer object or zero if - * the buffer object memory is not accessible through a PCI region. - * \return Failure indication. - * - * Returns -EINVAL if the buffer object is currently not mappable. - * Otherwise returns zero. - */ - -int drm_bo_pci_offset(struct drm_device *dev, - struct drm_bo_mem_reg *mem, - unsigned long *bus_base, - unsigned long *bus_offset, unsigned long *bus_size) -{ - struct drm_buffer_manager *bm = &dev->bm; - struct drm_mem_type_manager *man = &bm->man[mem->mem_type]; - - *bus_size = 0; - if (!(man->flags & _DRM_FLAG_MEMTYPE_MAPPABLE)) - return -EINVAL; - - if (drm_mem_reg_is_pci(dev, mem)) { - *bus_offset = mem->mm_node->start << PAGE_SHIFT; - *bus_size = mem->num_pages << PAGE_SHIFT; - *bus_base = man->io_offset; - } - - return 0; -} - -/** - * \c Kill all user-space virtual mappings of this buffer object. - * - * \param bo The buffer object. - * - * Call bo->mutex locked. - */ - -void drm_bo_unmap_virtual(struct drm_buffer_object *bo) -{ - struct drm_device *dev = bo->dev; - loff_t offset = ((loff_t) bo->map_list.hash.key) << PAGE_SHIFT; - loff_t holelen = ((loff_t) bo->mem.num_pages) << PAGE_SHIFT; - - if (!dev->dev_mapping) - return; - - unmap_mapping_range(dev->dev_mapping, offset, holelen, 1); -} - -/** - * drm_bo_takedown_vm_locked: - * - * @bo: the buffer object to remove any drm device mapping - * - * Remove any associated vm mapping on the drm device node that - * would have been created for a drm_bo_type_device buffer - */ -static void drm_bo_takedown_vm_locked(struct drm_buffer_object *bo) -{ - struct drm_map_list *list; - drm_local_map_t *map; - struct drm_device *dev = bo->dev; - - DRM_ASSERT_LOCKED(&dev->struct_mutex); - if (bo->type != drm_bo_type_device) - return; - - list = &bo->map_list; - if (list->user_token) { - drm_ht_remove_item(&dev->map_hash, &list->hash); - list->user_token = 0; - } - if (list->file_offset_node) { - drm_mm_put_block(list->file_offset_node); - list->file_offset_node = NULL; - } - - map = list->map; - if (!map) - return; - - drm_ctl_free(map, sizeof(*map), DRM_MEM_BUFOBJ); - list->map = NULL; - list->user_token = 0ULL; - drm_bo_usage_deref_locked(&bo); -} - -/** - * drm_bo_setup_vm_locked: - * - * @bo: the buffer to allocate address space for - * - * Allocate address space in the drm device so that applications - * can mmap the buffer and access the contents. This only - * applies to drm_bo_type_device objects as others are not - * placed in the drm device address space. - */ -static int drm_bo_setup_vm_locked(struct drm_buffer_object *bo) -{ - struct drm_map_list *list = &bo->map_list; - drm_local_map_t *map; - struct drm_device *dev = bo->dev; - - DRM_ASSERT_LOCKED(&dev->struct_mutex); - list->map = drm_ctl_calloc(1, sizeof(*map), DRM_MEM_BUFOBJ); - if (!list->map) - return -ENOMEM; - - map = list->map; - map->offset = 0; - map->type = _DRM_TTM; - map->flags = _DRM_REMOVABLE; - map->size = bo->mem.num_pages * PAGE_SIZE; - atomic_inc(&bo->usage); - map->handle = (void *)bo; - - list->file_offset_node = drm_mm_search_free(&dev->offset_manager, - bo->mem.num_pages, 0, 0); - - if (unlikely(!list->file_offset_node)) { - drm_bo_takedown_vm_locked(bo); - return -ENOMEM; - } - - list->file_offset_node = drm_mm_get_block(list->file_offset_node, - bo->mem.num_pages, 0); - - if (unlikely(!list->file_offset_node)) { - drm_bo_takedown_vm_locked(bo); - return -ENOMEM; - } - - list->hash.key = list->file_offset_node->start; - if (drm_ht_insert_item(&dev->map_hash, &list->hash)) { - drm_bo_takedown_vm_locked(bo); - return -ENOMEM; - } - - list->user_token = ((uint64_t) list->hash.key) << PAGE_SHIFT; - - return 0; -} - -int drm_bo_version_ioctl(struct drm_device *dev, void *data, - struct drm_file *file_priv) -{ - struct drm_bo_version_arg *arg = (struct drm_bo_version_arg *)data; - - arg->major = DRM_BO_INIT_MAJOR; - arg->minor = DRM_BO_INIT_MINOR; - arg->patchlevel = DRM_BO_INIT_PATCH; - - return 0; -} diff --git a/linux-core/drm_bo_lock.c b/linux-core/drm_bo_lock.c deleted file mode 100644 index 08b1c6be..00000000 --- a/linux-core/drm_bo_lock.c +++ /dev/null @@ -1,189 +0,0 @@ -/************************************************************************** - * - * Copyright (c) 2007 Tungsten Graphics, Inc., Cedar Park, TX., USA - * All Rights Reserved. - * - * Permission is hereby granted, free of charge, to any person obtaining a - * copy of this software and associated documentation files (the - * "Software"), to deal in the Software without restriction, including - * without limitation the rights to use, copy, modify, merge, publish, - * distribute, sub license, and/or sell copies of the Software, and to - * permit persons to whom the Software is furnished to do so, subject to - * the following conditions: - * - * The above copyright notice and this permission notice (including the - * next paragraph) shall be included in all copies or substantial portions - * of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL - * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, - * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR - * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE - * USE OR OTHER DEALINGS IN THE SOFTWARE. - * - **************************************************************************/ -/* - * Authors: Thomas Hellström <thomas-at-tungstengraphics-dot-com> - */ - -/* - * This file implements a simple replacement for the buffer manager use - * of the heavyweight hardware lock. - * The lock is a read-write lock. Taking it in read mode is fast, and - * intended for in-kernel use only. - * Taking it in write mode is slow. - * - * The write mode is used only when there is a need to block all - * user-space processes from allocating a - * new memory area. - * Typical use in write mode is X server VT switching, and it's allowed - * to leave kernel space with the write lock held. If a user-space process - * dies while having the write-lock, it will be released during the file - * descriptor release. - * - * The read lock is typically placed at the start of an IOCTL- or - * user-space callable function that may end up allocating a memory area. - * This includes setstatus, super-ioctls and no_pfn; the latter may move - * unmappable regions to mappable. It's a bug to leave kernel space with the - * read lock held. - * - * Both read- and write lock taking may be interruptible for low signal-delivery - * latency. The locking functions will return -EAGAIN if interrupted by a - * signal. - * - * Locking order: The lock should be taken BEFORE any kernel mutexes - * or spinlocks. - */ - -#include "drmP.h" - -void drm_bo_init_lock(struct drm_bo_lock *lock) -{ - DRM_INIT_WAITQUEUE(&lock->queue); - atomic_set(&lock->write_lock_pending, 0); - atomic_set(&lock->readers, 0); -} - -void drm_bo_read_unlock(struct drm_bo_lock *lock) -{ - if (atomic_dec_and_test(&lock->readers)) - wake_up_all(&lock->queue); -} -EXPORT_SYMBOL(drm_bo_read_unlock); - -int drm_bo_read_lock(struct drm_bo_lock *lock, int interruptible) -{ - while (unlikely(atomic_read(&lock->write_lock_pending) != 0)) { - int ret; - - if (!interruptible) { - wait_event(lock->queue, - atomic_read(&lock->write_lock_pending) == 0); - continue; - } - ret = wait_event_interruptible - (lock->queue, atomic_read(&lock->write_lock_pending) == 0); - if (ret) - return -EAGAIN; - } - - while (unlikely(!atomic_add_unless(&lock->readers, 1, -1))) { - int ret; - if (!interruptible) { - wait_event(lock->queue, - atomic_read(&lock->readers) != -1); - continue; - } - ret = wait_event_interruptible - (lock->queue, atomic_read(&lock->readers) != -1); - if (ret) - return -EAGAIN; - } - return 0; -} -EXPORT_SYMBOL(drm_bo_read_lock); - -static int __drm_bo_write_unlock(struct drm_bo_lock *lock) -{ - if (unlikely(atomic_cmpxchg(&lock->readers, -1, 0) != -1)) - return -EINVAL; - wake_up_all(&lock->queue); - return 0; -} - -static void drm_bo_write_lock_remove(struct drm_file *file_priv, - struct drm_user_object *item) -{ - struct drm_bo_lock *lock = container_of(item, struct drm_bo_lock, base); - int ret; - - ret = __drm_bo_write_unlock(lock); - BUG_ON(ret); -} - -int drm_bo_write_lock(struct drm_bo_lock *lock, int interruptible, - struct drm_file *file_priv) -{ - int ret = 0; - struct drm_device *dev; - - atomic_inc(&lock->write_lock_pending); - - while (unlikely(atomic_cmpxchg(&lock->readers, 0, -1) != 0)) { - if (!interruptible) { - wait_event(lock->queue, - atomic_read(&lock->readers) == 0); - continue; - } - ret = wait_event_interruptible - (lock->queue, atomic_read(&lock->readers) == 0); - - if (ret) { - atomic_dec(&lock->write_lock_pending); - wake_up_all(&lock->queue); - return -EAGAIN; - } - } - - /* - * Add a dummy user-object, the destructor of which will - * make sure the lock is released if the client dies - * while holding it. - */ - - if (atomic_dec_and_test(&lock->write_lock_pending)) - wake_up_all(&lock->queue); - dev = file_priv->minor->dev; - mutex_lock(&dev->struct_mutex); - ret = drm_add_user_object(file_priv, &lock->base, 0); - lock->base.remove = &drm_bo_write_lock_remove; - lock->base.type = drm_lock_type; - if (ret) - (void)__drm_bo_write_unlock(lock); - - mutex_unlock(&dev->struct_mutex); - - return ret; -} - -int drm_bo_write_unlock(struct drm_bo_lock *lock, struct drm_file *file_priv) -{ - struct drm_device *dev = file_priv->minor->dev; - struct drm_ref_object *ro; - - mutex_lock(&dev->struct_mutex); - - if (lock->base.owner != file_priv) { - mutex_unlock(&dev->struct_mutex); - return -EINVAL; - } - ro = drm_lookup_ref_object(file_priv, &lock->base, _DRM_REF_USE); - BUG_ON(!ro); - drm_remove_ref_object(file_priv, ro); - lock->base.owner = NULL; - - mutex_unlock(&dev->struct_mutex); - return 0; -} diff --git a/linux-core/drm_bo_move.c b/linux-core/drm_bo_move.c deleted file mode 100644 index d794e985..00000000 --- a/linux-core/drm_bo_move.c +++ /dev/null @@ -1,614 +0,0 @@ -/************************************************************************** - * - * Copyright (c) 2007 Tungsten Graphics, Inc., Cedar Park, TX., USA - * All Rights Reserved. - * - * Permission is hereby granted, free of charge, to any person obtaining a - * copy of this software and associated documentation files (the - * "Software"), to deal in the Software without restriction, including - * without limitation the rights to use, copy, modify, merge, publish, - * distribute, sub license, and/or sell copies of the Software, and to - * permit persons to whom the Software is furnished to do so, subject to - * the following conditions: - * - * The above copyright notice and this permission notice (including the - * next paragraph) shall be included in all copies or substantial portions - * of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL - * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, - * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR - * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE - * USE OR OTHER DEALINGS IN THE SOFTWARE. - * - **************************************************************************/ -/* - * Authors: Thomas Hellström <thomas-at-tungstengraphics-dot-com> - */ - -#include "drmP.h" - -/** - * Free the old memory node unless it's a pinned region and we - * have not been requested to free also pinned regions. - */ - -static void drm_bo_free_old_node(struct drm_buffer_object *bo) -{ - struct drm_bo_mem_reg *old_mem = &bo->mem; - - if (old_mem->mm_node && (old_mem->mm_node != bo->pinned_node)) { - mutex_lock(&bo->dev->struct_mutex); - drm_mm_put_block(old_mem->mm_node); - mutex_unlock(&bo->dev->struct_mutex); - } - old_mem->mm_node = NULL; -} - -int drm_bo_move_ttm(struct drm_buffer_object *bo, - int evict, int no_wait, struct drm_bo_mem_reg *new_mem) -{ - struct drm_ttm *ttm = bo->ttm; - struct drm_bo_mem_reg *old_mem = &bo->mem; - uint64_t save_flags = old_mem->flags; - uint64_t save_proposed_flags = old_mem->proposed_flags; - int ret; - - if (old_mem->mem_type != DRM_BO_MEM_LOCAL) { - if (evict) - drm_ttm_evict(ttm); - else - drm_ttm_unbind(ttm); - - drm_bo_free_old_node(bo); - DRM_FLAG_MASKED(old_mem->flags, - DRM_BO_FLAG_CACHED | DRM_BO_FLAG_MAPPABLE | - DRM_BO_FLAG_MEM_LOCAL, DRM_BO_MASK_MEMTYPE); - old_mem->mem_type = DRM_BO_MEM_LOCAL; - save_flags = old_mem->flags; - } - if (new_mem->mem_type != DRM_BO_MEM_LOCAL) { - ret = drm_ttm_bind(ttm, new_mem); - if (ret) - return ret; - } - - *old_mem = *new_mem; - new_mem->mm_node = NULL; - old_mem->proposed_flags = save_proposed_flags; - DRM_FLAG_MASKED(save_flags, new_mem->flags, DRM_BO_MASK_MEMTYPE); - return 0; -} -EXPORT_SYMBOL(drm_bo_move_ttm); - -/** - * \c Return a kernel virtual address to the buffer object PCI memory. - * - * \param bo The buffer object. - * \return Failure indication. - * - * Returns -EINVAL if the buffer object is currently not mappable. - * Returns -ENOMEM if the ioremap operation failed. - * Otherwise returns zero. - * - * After a successfull call, bo->iomap contains the virtual address, or NULL - * if the buffer object content is not accessible through PCI space. - * Call bo->mutex locked. - */ - -int drm_mem_reg_ioremap(struct drm_device *dev, struct drm_bo_mem_reg *mem, - void **virtual) -{ - struct drm_buffer_manager *bm = &dev->bm; - struct drm_mem_type_manager *man = &bm->man[mem->mem_type]; - unsigned long bus_offset; - unsigned long bus_size; - unsigned long bus_base; - int ret; - void *addr; - - *virtual = NULL; - ret = drm_bo_pci_offset(dev, mem, &bus_base, &bus_offset, &bus_size); - if (ret || bus_size == 0) - return ret; - - if (!(man->flags & _DRM_FLAG_NEEDS_IOREMAP)) - addr = (void *)(((u8 *) man->io_addr) + bus_offset); - else { - addr = ioremap_nocache(bus_base + bus_offset, bus_size); - if (!addr) - return -ENOMEM; - } - *virtual = addr; - return 0; -} -EXPORT_SYMBOL(drm_mem_reg_ioremap); - -/** - * \c Unmap mapping obtained using drm_bo_ioremap - * - * \param bo The buffer object. - * - * Call bo->mutex locked. - */ - -void drm_mem_reg_iounmap(struct drm_device *dev, struct drm_bo_mem_reg *mem, - void *virtual) -{ - struct drm_buffer_manager *bm; - struct drm_mem_type_manager *man; - - bm = &dev->bm; - man = &bm->man[mem->mem_type]; - - if (virtual && (man->flags & _DRM_FLAG_NEEDS_IOREMAP)) - iounmap(virtual); -} - -static int drm_copy_io_page(void *dst, void *src, unsigned long page) -{ - uint32_t *dstP = - (uint32_t *) ((unsigned long)dst + (page << PAGE_SHIFT)); - uint32_t *srcP = - (uint32_t *) ((unsigned long)src + (page << PAGE_SHIFT)); - - int i; - for (i = 0; i < PAGE_SIZE / sizeof(uint32_t); ++i) - iowrite32(ioread32(srcP++), dstP++); - return 0; -} - -static int drm_copy_io_ttm_page(struct drm_ttm *ttm, void *src, - unsigned long page) -{ - struct page *d = drm_ttm_get_page(ttm, page); - void *dst; - - if (!d) - return -ENOMEM; - - src = (void *)((unsigned long)src + (page << PAGE_SHIFT)); - dst = kmap(d); - if (!dst) - return -ENOMEM; - - memcpy_fromio(dst, src, PAGE_SIZE); - kunmap(d); - return 0; -} - -static int drm_copy_ttm_io_page(struct drm_ttm *ttm, void *dst, unsigned long page) -{ - struct page *s = drm_ttm_get_page(ttm, page); - void *src; - - if (!s) - return -ENOMEM; - - dst = (void *)((unsigned long)dst + (page << PAGE_SHIFT)); - src = kmap(s); - if (!src) - return -ENOMEM; - - memcpy_toio(dst, src, PAGE_SIZE); - kunmap(s); - return 0; -} - -int drm_bo_move_memcpy(struct drm_buffer_object *bo, - int evict, int no_wait, struct drm_bo_mem_reg *new_mem) -{ - struct drm_device *dev = bo->dev; - struct drm_mem_type_manager *man = &dev->bm.man[new_mem->mem_type]; - struct drm_ttm *ttm = bo->ttm; - struct drm_bo_mem_reg *old_mem = &bo->mem; - struct drm_bo_mem_reg old_copy = *old_mem; - void *old_iomap; - void *new_iomap; - int ret; - uint64_t save_flags = old_mem->flags; - uint64_t save_proposed_flags = old_mem->proposed_flags; - unsigned long i; - unsigned long page; - unsigned long add = 0; - int dir; - - ret = drm_mem_reg_ioremap(dev, old_mem, &old_iomap); - if (ret) - return ret; - ret = drm_mem_reg_ioremap(dev, new_mem, &new_iomap); - if (ret) - goto out; - - if (old_iomap == NULL && new_iomap == NULL) - goto out2; - if (old_iomap == NULL && ttm == NULL) - goto out2; - - add = 0; - dir = 1; - - if ((old_mem->mem_type == new_mem->mem_type) && - (new_mem->mm_node->start < - old_mem->mm_node->start + old_mem->mm_node->size)) { - dir = -1; - add = new_mem->num_pages - 1; - } - - for (i = 0; i < new_mem->num_pages; ++i) { - page = i * dir + add; - if (old_iomap == NULL) - ret = drm_copy_ttm_io_page(ttm, new_iomap, page); - else if (new_iomap == NULL) - ret = drm_copy_io_ttm_page(ttm, old_iomap, page); - else - ret = drm_copy_io_page(new_iomap, old_iomap, page); - if (ret) - goto out1; - } - mb(); -out2: - drm_bo_free_old_node(bo); - - *old_mem = *new_mem; - new_mem->mm_node = NULL; - old_mem->proposed_flags = save_proposed_flags; - DRM_FLAG_MASKED(save_flags, new_mem->flags, DRM_BO_MASK_MEMTYPE); - - if ((man->flags & _DRM_FLAG_MEMTYPE_FIXED) && (ttm != NULL)) { - drm_ttm_unbind(ttm); - drm_ttm_destroy(ttm); - bo->ttm = NULL; - } - -out1: - drm_mem_reg_iounmap(dev, new_mem, new_iomap); -out: - drm_mem_reg_iounmap(dev, &old_copy, old_iomap); - return ret; -} -EXPORT_SYMBOL(drm_bo_move_memcpy); - -/* - * Transfer a buffer object's memory and LRU status to a newly - * created object. User-space references remains with the old - * object. Call bo->mutex locked. - */ - -int drm_buffer_object_transfer(struct drm_buffer_object *bo, - struct drm_buffer_object **new_obj) -{ - struct drm_buffer_object *fbo; - struct drm_device *dev = bo->dev; - struct drm_buffer_manager *bm = &dev->bm; - - fbo = drm_ctl_calloc(1, sizeof(*fbo), DRM_MEM_BUFOBJ); - if (!fbo) - return -ENOMEM; - - *fbo = *bo; - mutex_init(&fbo->mutex); - mutex_lock(&fbo->mutex); - mutex_lock(&dev->struct_mutex); - - DRM_INIT_WAITQUEUE(&bo->event_queue); - INIT_LIST_HEAD(&fbo->ddestroy); - INIT_LIST_HEAD(&fbo->lru); - INIT_LIST_HEAD(&fbo->pinned_lru); - - fbo->fence = drm_fence_reference_locked(bo->fence); - fbo->pinned_node = NULL; - fbo->mem.mm_node->private = (void *)fbo; - atomic_set(&fbo->usage, 1); - atomic_inc(&bm->count); - mutex_unlock(&dev->struct_mutex); - mutex_unlock(&fbo->mutex); - - *new_obj = fbo; - return 0; -} - -/* - * Since move is underway, we need to block signals in this function. - * We cannot restart until it has finished. - */ - -int drm_bo_move_accel_cleanup(struct drm_buffer_object *bo, - int evict, int no_wait, uint32_t fence_class, - uint32_t fence_type, uint32_t fence_flags, - struct drm_bo_mem_reg *new_mem) -{ - struct drm_device *dev = bo->dev; - struct drm_mem_type_manager *man = &dev->bm.man[new_mem->mem_type]; - struct drm_bo_mem_reg *old_mem = &bo->mem; - int ret; - uint64_t save_flags = old_mem->flags; - uint64_t save_proposed_flags = old_mem->proposed_flags; - struct drm_buffer_object *old_obj; - - if (bo->fence) - drm_fence_usage_deref_unlocked(&bo->fence); - ret = drm_fence_object_create(dev, fence_class, fence_type, - fence_flags | DRM_FENCE_FLAG_EMIT, - &bo->fence); - bo->fence_type = fence_type; - if (ret) - return ret; - - if (evict || ((bo->mem.mm_node == bo->pinned_node) && - bo->mem.mm_node != NULL)) - { - if (bo->fence) { - (void) drm_fence_object_wait(bo->fence, 0, 1, - bo->fence_type); - drm_fence_usage_deref_unlocked(&bo->fence); - } - drm_bo_free_old_node(bo); - - if ((man->flags & _DRM_FLAG_MEMTYPE_FIXED) && (bo->ttm != NULL)) { - drm_ttm_unbind(bo->ttm); - drm_ttm_destroy(bo->ttm); - bo->ttm = NULL; - } - } else { - - /* This should help pipeline ordinary buffer moves. - * - * Hang old buffer memory on a new buffer object, - * and leave it to be released when the GPU - * operation has completed. - */ - - ret = drm_buffer_object_transfer(bo, &old_obj); - - if (ret) - return ret; - - if (!(man->flags & _DRM_FLAG_MEMTYPE_FIXED)) - old_obj->ttm = NULL; - else - bo->ttm = NULL; - - mutex_lock(&dev->struct_mutex); - list_del_init(&old_obj->lru); - DRM_FLAG_MASKED(bo->priv_flags, 0, _DRM_BO_FLAG_UNFENCED); - drm_bo_add_to_lru(old_obj); - - drm_bo_usage_deref_locked(&old_obj); - mutex_unlock(&dev->struct_mutex); - - } - - *old_mem = *new_mem; - new_mem->mm_node = NULL; - old_mem->proposed_flags = save_proposed_flags; - DRM_FLAG_MASKED(save_flags, new_mem->flags, DRM_BO_MASK_MEMTYPE); - return 0; -} -EXPORT_SYMBOL(drm_bo_move_accel_cleanup); - -int drm_bo_same_page(unsigned long offset, - unsigned long offset2) -{ - return (offset & PAGE_MASK) == (offset2 & PAGE_MASK); -} -EXPORT_SYMBOL(drm_bo_same_page); - -unsigned long drm_bo_offset_end(unsigned long offset, - unsigned long end) -{ - offset = (offset + PAGE_SIZE) & PAGE_MASK; - return (end < offset) ? end : offset; -} -EXPORT_SYMBOL(drm_bo_offset_end); - -static pgprot_t drm_kernel_io_prot(uint32_t map_type) -{ - pgprot_t tmp = PAGE_KERNEL; - -#if defined(__i386__) || defined(__x86_64__) -#ifdef USE_PAT_WC -#warning using pat - if (drm_use_pat() && map_type == _DRM_TTM) { - pgprot_val(tmp) |= _PAGE_PAT; - return tmp; - } -#endif - if (boot_cpu_data.x86 > 3 && map_type != _DRM_AGP) { - pgprot_val(tmp) |= _PAGE_PCD; - pgprot_val(tmp) &= ~_PAGE_PWT; - } -#elif defined(__powerpc__) - pgprot_val(tmp) |= _PAGE_NO_CACHE; - if (map_type == _DRM_REGISTERS) - pgprot_val(tmp) |= _PAGE_GUARDED; -#endif -#if defined(__ia64__) - if (map_type == _DRM_TTM) - tmp = pgprot_writecombine(tmp); - else - tmp = pgprot_noncached(tmp); -#endif - return tmp; -} - -static int drm_bo_ioremap(struct drm_buffer_object *bo, unsigned long bus_base, - unsigned long bus_offset, unsigned long bus_size, - struct drm_bo_kmap_obj *map) -{ - struct drm_device *dev = bo->dev; - struct drm_bo_mem_reg *mem = &bo->mem; - struct drm_mem_type_manager *man = &dev->bm.man[mem->mem_type]; - - if (!(man->flags & _DRM_FLAG_NEEDS_IOREMAP)) { - map->bo_kmap_type = bo_map_premapped; - map->virtual = (void *)(((u8 *) man->io_addr) + bus_offset); - } else { - map->bo_kmap_type = bo_map_iomap; - map->virtual = ioremap_nocache(bus_base + bus_offset, bus_size); - } - return (!map->virtual) ? -ENOMEM : 0; -} - -static int drm_bo_kmap_ttm(struct drm_buffer_object *bo, - unsigned long start_page, unsigned long num_pages, - struct drm_bo_kmap_obj *map) -{ - struct drm_device *dev = bo->dev; - struct drm_bo_mem_reg *mem = &bo->mem; - struct drm_mem_type_manager *man = &dev->bm.man[mem->mem_type]; - pgprot_t prot; - struct drm_ttm *ttm = bo->ttm; - struct page *d; - int i; - - BUG_ON(!ttm); - - if (num_pages == 1 && (mem->flags & DRM_BO_FLAG_CACHED)) { - - /* - * We're mapping a single page, and the desired - * page protection is consistent with the bo. - */ - - map->bo_kmap_type = bo_map_kmap; - map->page = drm_ttm_get_page(ttm, start_page); - map->virtual = kmap(map->page); - } else { - /* - * Populate the part we're mapping; - */ - - for (i = start_page; i < start_page + num_pages; ++i) { - d = drm_ttm_get_page(ttm, i); - if (!d) - return -ENOMEM; - } - - /* - * We need to use vmap to get the desired page protection - * or to make the buffer object look contigous. - */ - - prot = (mem->flags & DRM_BO_FLAG_CACHED) ? - PAGE_KERNEL : - drm_kernel_io_prot(man->drm_bus_maptype); - map->bo_kmap_type = bo_map_vmap; - map->virtual = vmap(ttm->pages + start_page, - num_pages, 0, prot); - } - return (!map->virtual) ? -ENOMEM : 0; -} - -/* - * This function is to be used for kernel mapping of buffer objects. - * It chooses the appropriate mapping method depending on the memory type - * and caching policy the buffer currently has. - * Mapping multiple pages or buffers that live in io memory is a bit slow and - * consumes vmalloc space. Be restrictive with such mappings. - * Mapping single pages usually returns the logical kernel address, - * (which is fast) - * BUG may use slower temporary mappings for high memory pages or - * uncached / write-combined pages. - * - * The function fills in a drm_bo_kmap_obj which can be used to return the - * kernel virtual address of the buffer. - * - * Code servicing a non-priviliged user request is only allowed to map one - * page at a time. We might need to implement a better scheme to stop such - * processes from consuming all vmalloc space. - */ - -int drm_bo_kmap(struct drm_buffer_object *bo, unsigned long start_page, - unsigned long num_pages, struct drm_bo_kmap_obj *map) -{ - int ret; - unsigned long bus_base; - unsigned long bus_offset; - unsigned long bus_size; - - map->virtual = NULL; - - if (num_pages > bo->num_pages) - return -EINVAL; - if (start_page > bo->num_pages) - return -EINVAL; -#if 0 - if (num_pages > 1 && !DRM_SUSER(DRM_CURPROC)) - return -EPERM; -#endif - ret = drm_bo_pci_offset(bo->dev, &bo->mem, &bus_base, - &bus_offset, &bus_size); - - if (ret) - return ret; - - if (bus_size == 0) { - return drm_bo_kmap_ttm(bo, start_page, num_pages, map); - } else { - bus_offset += start_page << PAGE_SHIFT; - bus_size = num_pages << PAGE_SHIFT; - return drm_bo_ioremap(bo, bus_base, bus_offset, bus_size, map); - } -} -EXPORT_SYMBOL(drm_bo_kmap); - -void drm_bo_kunmap(struct drm_bo_kmap_obj *map) -{ - if (!map->virtual) - return; - - switch (map->bo_kmap_type) { - case bo_map_iomap: - iounmap(map->virtual); - break; - case bo_map_vmap: - vunmap(map->virtual); - break; - case bo_map_kmap: - kunmap(map->page); - break; - case bo_map_premapped: - break; - default: - BUG(); - } - map->virtual = NULL; - map->page = NULL; -} -EXPORT_SYMBOL(drm_bo_kunmap); - -int drm_bo_pfn_prot(struct drm_buffer_object *bo, - unsigned long dst_offset, - unsigned long *pfn, - pgprot_t *prot) -{ - struct drm_bo_mem_reg *mem = &bo->mem; - struct drm_device *dev = bo->dev; - unsigned long bus_offset; - unsigned long bus_size; - unsigned long bus_base; - struct drm_mem_type_manager *man = &dev->bm.man[mem->mem_type]; - int ret; - - ret = drm_bo_pci_offset(dev, mem, &bus_base, &bus_offset, - &bus_size); - if (ret) - return -EINVAL; - - if (bus_size != 0) - *pfn = (bus_base + bus_offset + dst_offset) >> PAGE_SHIFT; - else if (!bo->ttm) - return -EINVAL; - else - *pfn = page_to_pfn(drm_ttm_get_page(bo->ttm, dst_offset >> PAGE_SHIFT)); - - *prot = (mem->flags & DRM_BO_FLAG_CACHED) ? - PAGE_KERNEL : drm_kernel_io_prot(man->drm_bus_maptype); - - return 0; -} -EXPORT_SYMBOL(drm_bo_pfn_prot); - diff --git a/linux-core/drm_compat.c b/linux-core/drm_compat.c index 0ccd2ab3..3bf9d100 100644 --- a/linux-core/drm_compat.c +++ b/linux-core/drm_compat.c @@ -151,102 +151,3 @@ void idr_remove_all(struct idr *idp) EXPORT_SYMBOL(idr_remove_all); #endif /* DRM_IDR_COMPAT_FN */ - - -#ifdef DRM_NO_FAULT -unsigned long drm_bo_vm_nopfn(struct vm_area_struct *vma, - unsigned long address) -{ - struct drm_buffer_object *bo = (struct drm_buffer_object *) vma->vm_private_data; - unsigned long page_offset; - struct page *page = NULL; - struct drm_ttm *ttm; - struct drm_device *dev; - unsigned long pfn; - int err; - unsigned long bus_base; - unsigned long bus_offset; - unsigned long bus_size; - unsigned long ret = NOPFN_REFAULT; - - if (address > vma->vm_end) - return NOPFN_SIGBUS; - - dev = bo->dev; - err = drm_bo_read_lock(&dev->bm.bm_lock, 1); - if (err) - return NOPFN_REFAULT; - - err = mutex_lock_interruptible(&bo->mutex); - if (err) { - drm_bo_read_unlock(&dev->bm.bm_lock); - return NOPFN_REFAULT; - } - - err = drm_bo_wait(bo, 0, 1, 0, 1); - if (err) { - ret = (err != -EAGAIN) ? NOPFN_SIGBUS : NOPFN_REFAULT; - bo->priv_flags &= ~_DRM_BO_FLAG_UNLOCKED; - goto out_unlock; - } - - bo->priv_flags &= ~_DRM_BO_FLAG_UNLOCKED; - - /* - * If buffer happens to be in a non-mappable location, - * move it to a mappable. - */ - - if (!(bo->mem.flags & DRM_BO_FLAG_MAPPABLE)) { - uint32_t new_flags = bo->mem.proposed_flags | - DRM_BO_FLAG_MAPPABLE | - DRM_BO_FLAG_FORCE_MAPPABLE; - err = drm_bo_move_buffer(bo, new_flags, 0, 0); - if (err) { - ret = (err != -EAGAIN) ? NOPFN_SIGBUS : NOPFN_REFAULT; - goto out_unlock; - } - } - - err = drm_bo_pci_offset(dev, &bo->mem, &bus_base, &bus_offset, - &bus_size); - - if (err) { - ret = NOPFN_SIGBUS; - goto out_unlock; - } - - page_offset = (address - vma->vm_start) >> PAGE_SHIFT; - - if (bus_size) { - struct drm_mem_type_manager *man = &dev->bm.man[bo->mem.mem_type]; - - pfn = ((bus_base + bus_offset) >> PAGE_SHIFT) + page_offset; - vma->vm_page_prot = drm_io_prot(man->drm_bus_maptype, vma); - } else { - ttm = bo->ttm; - - drm_ttm_fixup_caching(ttm); - page = drm_ttm_get_page(ttm, page_offset); - if (!page) { - ret = NOPFN_OOM; - goto out_unlock; - } - pfn = page_to_pfn(page); - vma->vm_page_prot = (bo->mem.flags & DRM_BO_FLAG_CACHED) ? - vm_get_page_prot(vma->vm_flags) : - drm_io_prot(_DRM_TTM, vma); - } - - err = vm_insert_pfn(vma, address, pfn); - if (err) { - ret = (err != -EAGAIN) ? NOPFN_OOM : NOPFN_REFAULT; - goto out_unlock; - } -out_unlock: - BUG_ON(bo->priv_flags & _DRM_BO_FLAG_UNLOCKED); - mutex_unlock(&bo->mutex); - drm_bo_read_unlock(&dev->bm.bm_lock); - return ret; -} -#endif diff --git a/linux-core/drm_drv.c b/linux-core/drm_drv.c index 72f0e98b..d3e2ca99 100644 --- a/linux-core/drm_drv.c +++ b/linux-core/drm_drv.c @@ -121,36 +121,6 @@ static struct drm_ioctl_desc drm_ioctls[] = { DRM_IOCTL_DEF(DRM_IOCTL_UPDATE_DRAW, drm_update_drawable_info, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY), - DRM_IOCTL_DEF(DRM_IOCTL_MM_INIT, drm_mm_init_ioctl, - DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY), - DRM_IOCTL_DEF(DRM_IOCTL_MM_TAKEDOWN, drm_mm_takedown_ioctl, - DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY), - DRM_IOCTL_DEF(DRM_IOCTL_MM_LOCK, drm_mm_lock_ioctl, - DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY), - DRM_IOCTL_DEF(DRM_IOCTL_MM_UNLOCK, drm_mm_unlock_ioctl, - DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY), - - DRM_IOCTL_DEF(DRM_IOCTL_FENCE_CREATE, drm_fence_create_ioctl, DRM_AUTH), - DRM_IOCTL_DEF(DRM_IOCTL_FENCE_REFERENCE, drm_fence_reference_ioctl, DRM_AUTH), - DRM_IOCTL_DEF(DRM_IOCTL_FENCE_UNREFERENCE, drm_fence_unreference_ioctl, DRM_AUTH), - DRM_IOCTL_DEF(DRM_IOCTL_FENCE_SIGNALED, drm_fence_signaled_ioctl, DRM_AUTH), - DRM_IOCTL_DEF(DRM_IOCTL_FENCE_FLUSH, drm_fence_flush_ioctl, DRM_AUTH), - DRM_IOCTL_DEF(DRM_IOCTL_FENCE_WAIT, drm_fence_wait_ioctl, DRM_AUTH), - DRM_IOCTL_DEF(DRM_IOCTL_FENCE_EMIT, drm_fence_emit_ioctl, DRM_AUTH), - DRM_IOCTL_DEF(DRM_IOCTL_FENCE_BUFFERS, drm_fence_buffers_ioctl, DRM_AUTH), - - DRM_IOCTL_DEF(DRM_IOCTL_BO_CREATE, drm_bo_create_ioctl, DRM_AUTH), - DRM_IOCTL_DEF(DRM_IOCTL_BO_MAP, drm_bo_map_ioctl, DRM_AUTH), - DRM_IOCTL_DEF(DRM_IOCTL_BO_UNMAP, drm_bo_unmap_ioctl, DRM_AUTH), - DRM_IOCTL_DEF(DRM_IOCTL_BO_REFERENCE, drm_bo_reference_ioctl, DRM_AUTH), - DRM_IOCTL_DEF(DRM_IOCTL_BO_UNREFERENCE, drm_bo_unreference_ioctl, DRM_AUTH), - DRM_IOCTL_DEF(DRM_IOCTL_BO_SETSTATUS, drm_bo_setstatus_ioctl, DRM_AUTH), - DRM_IOCTL_DEF(DRM_IOCTL_BO_INFO, drm_bo_info_ioctl, DRM_AUTH), - DRM_IOCTL_DEF(DRM_IOCTL_BO_WAIT_IDLE, drm_bo_wait_idle_ioctl, DRM_AUTH), - DRM_IOCTL_DEF(DRM_IOCTL_BO_VERSION, drm_bo_version_ioctl, 0), - - DRM_IOCTL_DEF(DRM_IOCTL_MM_INFO, drm_mm_info_ioctl, 0), - #if OS_HAS_GEM DRM_IOCTL_DEF(DRM_IOCTL_GEM_CLOSE, drm_gem_close_ioctl, 0), DRM_IOCTL_DEF(DRM_IOCTL_GEM_FLINK, drm_gem_flink_ioctl, DRM_AUTH), @@ -183,8 +153,6 @@ int drm_lastclose(struct drm_device * dev) * We can't do much about this function failing. */ - drm_bo_driver_finish(dev); - if (dev->driver->lastclose) dev->driver->lastclose(dev); DRM_DEBUG("driver lastclose completed\n"); @@ -283,7 +251,6 @@ int drm_lastclose(struct drm_device * dev) dev->lock.file_priv = NULL; wake_up_interruptible(&dev->lock.lock_queue); } - dev->dev_mapping = NULL; mutex_unlock(&dev->struct_mutex); DRM_DEBUG("lastclose completed\n"); @@ -398,7 +365,6 @@ static void drm_cleanup(struct drm_device * dev) } drm_lastclose(dev); - drm_fence_manager_takedown(dev); drm_vblank_cleanup(dev); @@ -423,8 +389,6 @@ static void drm_cleanup(struct drm_device * dev) drm_ctxbitmap_cleanup(dev); drm_ht_remove(&dev->map_hash); - drm_mm_takedown(&dev->offset_manager); - drm_ht_remove(&dev->object_hash); drm_put_minor(dev); if (drm_put_dev(dev)) diff --git a/linux-core/drm_fence.c b/linux-core/drm_fence.c deleted file mode 100644 index 7c78e09f..00000000 --- a/linux-core/drm_fence.c +++ /dev/null @@ -1,829 +0,0 @@ -/************************************************************************** - * - * Copyright (c) 2006-2007 Tungsten Graphics, Inc., Cedar Park, TX., USA - * All Rights Reserved. - * - * Permission is hereby granted, free of charge, to any person obtaining a - * copy of this software and associated documentation files (the - * "Software"), to deal in the Software without restriction, including - * without limitation the rights to use, copy, modify, merge, publish, - * distribute, sub license, and/or sell copies of the Software, and to - * permit persons to whom the Software is furnished to do so, subject to - * the following conditions: - * - * The above copyright notice and this permission notice (including the - * next paragraph) shall be included in all copies or substantial portions - * of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL - * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, - * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR - * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE - * USE OR OTHER DEALINGS IN THE SOFTWARE. - * - **************************************************************************/ -/* - * Authors: Thomas Hellström <thomas-at-tungstengraphics-dot-com> - */ - -#include "drmP.h" - - -/* - * Convenience function to be called by fence::wait methods that - * need polling. - */ - -int drm_fence_wait_polling(struct drm_fence_object *fence, int lazy, - int interruptible, uint32_t mask, - unsigned long end_jiffies) -{ - struct drm_device *dev = fence->dev; - struct drm_fence_manager *fm = &dev->fm; - struct drm_fence_class_manager *fc = &fm->fence_class[fence->fence_class]; - uint32_t count = 0; - int ret; - - DECLARE_WAITQUEUE(entry, current); - add_wait_queue(&fc->fence_queue, &entry); - - ret = 0; - - for (;;) { - __set_current_state((interruptible) ? - TASK_INTERRUPTIBLE : - TASK_UNINTERRUPTIBLE); - if (drm_fence_object_signaled(fence, mask)) - break; - if (time_after_eq(jiffies, end_jiffies)) { - ret = -EBUSY; - break; - } - if (lazy) - schedule_timeout(1); - else if ((++count & 0x0F) == 0){ - __set_current_state(TASK_RUNNING); - schedule(); - __set_current_state((interruptible) ? - TASK_INTERRUPTIBLE : - TASK_UNINTERRUPTIBLE); - } - if (interruptible && signal_pending(current)) { - ret = -EAGAIN; - break; - } - } - __set_current_state(TASK_RUNNING); - remove_wait_queue(&fc->fence_queue, &entry); - return ret; -} -EXPORT_SYMBOL(drm_fence_wait_polling); - -/* - * Typically called by the IRQ handler. - */ - -void drm_fence_handler(struct drm_device *dev, uint32_t fence_class, - uint32_t sequence, uint32_t type, uint32_t error) -{ - int wake = 0; - uint32_t diff; - uint32_t relevant_type; - uint32_t new_type; - struct drm_fence_manager *fm = &dev->fm; - struct drm_fence_class_manager *fc = &fm->fence_class[fence_class]; - struct drm_fence_driver *driver = dev->driver->fence_driver; - struct list_head *head; - struct drm_fence_object *fence, *next; - int found = 0; - - if (list_empty(&fc->ring)) - return; - - list_for_each_entry(fence, &fc->ring, ring) { - diff = (sequence - fence->sequence) & driver->sequence_mask; - if (diff > driver->wrap_diff) { - found = 1; - break; - } - } - - fc->waiting_types &= ~type; - head = (found) ? &fence->ring : &fc->ring; - - list_for_each_entry_safe_reverse(fence, next, head, ring) { - if (&fence->ring == &fc->ring) - break; - - if (error) { - fence->error = error; - fence->signaled_types = fence->type; - list_del_init(&fence->ring); - wake = 1; - break; - } - - if (type & DRM_FENCE_TYPE_EXE) - type |= fence->native_types; - - relevant_type = type & fence->type; - new_type = (fence->signaled_types | relevant_type) ^ - fence->signaled_types; - - if (new_type) { - fence->signaled_types |= new_type; - DRM_DEBUG("Fence 0x%08lx signaled 0x%08x\n", - fence->base.hash.key, fence->signaled_types); - - if (driver->needed_flush) - fc->pending_flush |= driver->needed_flush(fence); - - if (new_type & fence->waiting_types) - wake = 1; - } - - fc->waiting_types |= fence->waiting_types & ~fence->signaled_types; - - if (!(fence->type & ~fence->signaled_types)) { - DRM_DEBUG("Fence completely signaled 0x%08lx\n", - fence->base.hash.key); - list_del_init(&fence->ring); - } - } - - /* - * Reinstate lost waiting types. - */ - - if ((fc->waiting_types & type) != type) { - head = head->prev; - list_for_each_entry(fence, head, ring) { - if (&fence->ring == &fc->ring) - break; - diff = (fc->highest_waiting_sequence - fence->sequence) & - driver->sequence_mask; - if (diff > driver->wrap_diff) - break; - - fc->waiting_types |= fence->waiting_types & ~fence->signaled_types; - } - } - - if (wake) - wake_up_all(&fc->fence_queue); -} -EXPORT_SYMBOL(drm_fence_handler); - -static void drm_fence_unring(struct drm_device *dev, struct list_head *ring) -{ - struct drm_fence_manager *fm = &dev->fm; - unsigned long flags; - - write_lock_irqsave(&fm->lock, flags); - list_del_init(ring); - write_unlock_irqrestore(&fm->lock, flags); -} - -void drm_fence_usage_deref_locked(struct drm_fence_object **fence) -{ - struct drm_fence_object *tmp_fence = *fence; - struct drm_device *dev = tmp_fence->dev; - struct drm_fence_manager *fm = &dev->fm; - - DRM_ASSERT_LOCKED(&dev->struct_mutex); - *fence = NULL; - if (atomic_dec_and_test(&tmp_fence->usage)) { - drm_fence_unring(dev, &tmp_fence->ring); - DRM_DEBUG("Destroyed a fence object 0x%08lx\n", - tmp_fence->base.hash.key); - atomic_dec(&fm->count); - BUG_ON(!list_empty(&tmp_fence->base.list)); - drm_ctl_free(tmp_fence, sizeof(*tmp_fence), DRM_MEM_FENCE); - } -} -EXPORT_SYMBOL(drm_fence_usage_deref_locked); - -void drm_fence_usage_deref_unlocked(struct drm_fence_object **fence) -{ - struct drm_fence_object *tmp_fence = *fence; - struct drm_device *dev = tmp_fence->dev; - struct drm_fence_manager *fm = &dev->fm; - - *fence = NULL; - if (atomic_dec_and_test(&tmp_fence->usage)) { - mutex_lock(&dev->struct_mutex); - if (atomic_read(&tmp_fence->usage) == 0) { - drm_fence_unring(dev, &tmp_fence->ring); - atomic_dec(&fm->count); - BUG_ON(!list_empty(&tmp_fence->base.list)); - drm_ctl_free(tmp_fence, sizeof(*tmp_fence), DRM_MEM_FENCE); - } - mutex_unlock(&dev->struct_mutex); - } -} -EXPORT_SYMBOL(drm_fence_usage_deref_unlocked); - -struct drm_fence_object -*drm_fence_reference_locked(struct drm_fence_object *src) -{ - DRM_ASSERT_LOCKED(&src->dev->struct_mutex); - - atomic_inc(&src->usage); - return src; -} - -void drm_fence_reference_unlocked(struct drm_fence_object **dst, - struct drm_fence_object *src) -{ - mutex_lock(&src->dev->struct_mutex); - *dst = src; - atomic_inc(&src->usage); - mutex_unlock(&src->dev->struct_mutex); -} -EXPORT_SYMBOL(drm_fence_reference_unlocked); - -static void drm_fence_object_destroy(struct drm_file *priv, - struct drm_user_object *base) -{ - struct drm_fence_object *fence = - drm_user_object_entry(base, struct drm_fence_object, base); - - drm_fence_usage_deref_locked(&fence); -} - -int drm_fence_object_signaled(struct drm_fence_object *fence, uint32_t mask) -{ - unsigned long flags; - int signaled; - struct drm_device *dev = fence->dev; - struct drm_fence_manager *fm = &dev->fm; - struct drm_fence_driver *driver = dev->driver->fence_driver; - - mask &= fence->type; - read_lock_irqsave(&fm->lock, flags); - signaled = (mask & fence->signaled_types) == mask; - read_unlock_irqrestore(&fm->lock, flags); - if (!signaled && driver->poll) { - write_lock_irqsave(&fm->lock, flags); - driver->poll(dev, fence->fence_class, mask); - signaled = (mask & fence->signaled_types) == mask; - write_unlock_irqrestore(&fm->lock, flags); - } - return signaled; -} -EXPORT_SYMBOL(drm_fence_object_signaled); - - -int drm_fence_object_flush(struct drm_fence_object *fence, - uint32_t type) -{ - struct drm_device *dev = fence->dev; - struct drm_fence_manager *fm = &dev->fm; - struct drm_fence_class_manager *fc = &fm->fence_class[fence->fence_class]; - struct drm_fence_driver *driver = dev->driver->fence_driver; - unsigned long irq_flags; - uint32_t saved_pending_flush; - uint32_t diff; - int call_flush; - - if (type & ~fence->type) { - DRM_ERROR("Flush trying to extend fence type, " - "0x%x, 0x%x\n", type, fence->type); - return -EINVAL; - } - - write_lock_irqsave(&fm->lock, irq_flags); - fence->waiting_types |= type; - fc->waiting_types |= fence->waiting_types; - diff = (fence->sequence - fc->highest_waiting_sequence) & - driver->sequence_mask; - - if (diff < driver->wrap_diff) - fc->highest_waiting_sequence = fence->sequence; - - /* - * fence->waiting_types has changed. Determine whether - * we need to initiate some kind of flush as a result of this. - */ - - saved_pending_flush = fc->pending_flush; - if (driver->needed_flush) - fc->pending_flush |= driver->needed_flush(fence); - - if (driver->poll) - driver->poll(dev, fence->fence_class, fence->waiting_types); - - call_flush = fc->pending_flush; - write_unlock_irqrestore(&fm->lock, irq_flags); - - if (call_flush && driver->flush) - driver->flush(dev, fence->fence_class); - - return 0; -} -EXPORT_SYMBOL(drm_fence_object_flush); - -/* - * Make sure old fence objects are signaled before their fence sequences are - * wrapped around and reused. - */ - -void drm_fence_flush_old(struct drm_device *dev, uint32_t fence_class, - uint32_t sequence) -{ - struct drm_fence_manager *fm = &dev->fm; - struct drm_fence_class_manager *fc = &fm->fence_class[fence_class]; - struct drm_fence_object *fence; - unsigned long irq_flags; - struct drm_fence_driver *driver = dev->driver->fence_driver; - int call_flush; - - uint32_t diff; - - write_lock_irqsave(&fm->lock, irq_flags); - - list_for_each_entry_reverse(fence, &fc->ring, ring) { - diff = (sequence - fence->sequence) & driver->sequence_mask; - if (diff <= driver->flush_diff) - break; - - fence->waiting_types = fence->type; - fc->waiting_types |= fence->type; - - if (driver->needed_flush) - fc->pending_flush |= driver->needed_flush(fence); - } - - if (driver->poll) - driver->poll(dev, fence_class, fc->waiting_types); - - call_flush = fc->pending_flush; - write_unlock_irqrestore(&fm->lock, irq_flags); - - if (call_flush && driver->flush) - driver->flush(dev, fence->fence_class); - - /* - * FIXME: Shold we implement a wait here for really old fences? - */ - -} -EXPORT_SYMBOL(drm_fence_flush_old); - -int drm_fence_object_wait(struct drm_fence_object *fence, - int lazy, int ignore_signals, uint32_t mask) -{ - struct drm_device *dev = fence->dev; - struct drm_fence_driver *driver = dev->driver->fence_driver; - struct drm_fence_manager *fm = &dev->fm; - struct drm_fence_class_manager *fc = &fm->fence_class[fence->fence_class]; - int ret = 0; - unsigned long _end = 3 * DRM_HZ; - - if (mask & ~fence->type) { - DRM_ERROR("Wait trying to extend fence type" - " 0x%08x 0x%08x\n", mask, fence->type); - BUG(); - return -EINVAL; - } - - if (driver->wait) - return driver->wait(fence, lazy, !ignore_signals, mask); - - - drm_fence_object_flush(fence, mask); - if (driver->has_irq(dev, fence->fence_class, mask)) { - if (!ignore_signals) - ret = wait_event_interruptible_timeout - (fc->fence_queue, - drm_fence_object_signaled(fence, mask), - 3 * DRM_HZ); - else - ret = wait_event_timeout - (fc->fence_queue, - drm_fence_object_signaled(fence, mask), - 3 * DRM_HZ); - - if (unlikely(ret == -ERESTARTSYS)) - return -EAGAIN; - - if (unlikely(ret == 0)) - return -EBUSY; - - return 0; - } - - return drm_fence_wait_polling(fence, lazy, !ignore_signals, mask, - _end); -} -EXPORT_SYMBOL(drm_fence_object_wait); - - - -int drm_fence_object_emit(struct drm_fence_object *fence, uint32_t fence_flags, - uint32_t fence_class, uint32_t type) -{ - struct drm_device *dev = fence->dev; - struct drm_fence_manager *fm = &dev->fm; - struct drm_fence_driver *driver = dev->driver->fence_driver; - struct drm_fence_class_manager *fc = &fm->fence_class[fence->fence_class]; - unsigned long flags; - uint32_t sequence; - uint32_t native_types; - int ret; - - drm_fence_unring(dev, &fence->ring); - ret = driver->emit(dev, fence_class, fence_flags, &sequence, - &native_types); - if (ret) - return ret; - - write_lock_irqsave(&fm->lock, flags); - fence->fence_class = fence_class; - fence->type = type; - fence->waiting_types = 0; - fence->signaled_types = 0; - fence->error = 0; - fence->sequence = sequence; - fence->native_types = native_types; - if (list_empty(&fc->ring)) - fc->highest_waiting_sequence = sequence - 1; - list_add_tail(&fence->ring, &fc->ring); - fc->latest_queued_sequence = sequence; - write_unlock_irqrestore(&fm->lock, flags); - return 0; -} -EXPORT_SYMBOL(drm_fence_object_emit); - -static int drm_fence_object_init(struct drm_device *dev, uint32_t fence_class, - uint32_t type, - uint32_t fence_flags, - struct drm_fence_object *fence) -{ - int ret = 0; - unsigned long flags; - struct drm_fence_manager *fm = &dev->fm; - - mutex_lock(&dev->struct_mutex); - atomic_set(&fence->usage, 1); - mutex_unlock(&dev->struct_mutex); - - write_lock_irqsave(&fm->lock, flags); - INIT_LIST_HEAD(&fence->ring); - - /* - * Avoid hitting BUG() for kernel-only fence objects. - */ - - INIT_LIST_HEAD(&fence->base.list); - fence->fence_class = fence_class; - fence->type = type; - fence->signaled_types = 0; - fence->waiting_types = 0; - fence->sequence = 0; - fence->error = 0; - fence->dev = dev; - write_unlock_irqrestore(&fm->lock, flags); - if (fence_flags & DRM_FENCE_FLAG_EMIT) { - ret = drm_fence_object_emit(fence, fence_flags, - fence->fence_class, type); - } - return ret; -} - -int drm_fence_add_user_object(struct drm_file *priv, - struct drm_fence_object *fence, int shareable) -{ - struct drm_device *dev = priv->minor->dev; - int ret; - - mutex_lock(&dev->struct_mutex); - ret = drm_add_user_object(priv, &fence->base, shareable); - if (ret) - goto out; - atomic_inc(&fence->usage); - fence->base.type = drm_fence_type; - fence->base.remove = &drm_fence_object_destroy; - DRM_DEBUG("Fence 0x%08lx created\n", fence->base.hash.key); -out: - mutex_unlock(&dev->struct_mutex); - return ret; -} -EXPORT_SYMBOL(drm_fence_add_user_object); - -int drm_fence_object_create(struct drm_device *dev, uint32_t fence_class, - uint32_t type, unsigned flags, - struct drm_fence_object **c_fence) -{ - struct drm_fence_object *fence; - int ret; - struct drm_fence_manager *fm = &dev->fm; - - fence = drm_ctl_calloc(1, sizeof(*fence), DRM_MEM_FENCE); - if (!fence) { - DRM_ERROR("Out of memory creating fence object\n"); - return -ENOMEM; - } - ret = drm_fence_object_init(dev, fence_class, type, flags, fence); - if (ret) { - drm_fence_usage_deref_unlocked(&fence); - return ret; - } - *c_fence = fence; - atomic_inc(&fm->count); - - return 0; -} -EXPORT_SYMBOL(drm_fence_object_create); - -void drm_fence_manager_init(struct drm_device *dev) -{ - struct drm_fence_manager *fm = &dev->fm; - struct drm_fence_class_manager *fence_class; - struct drm_fence_driver *fed = dev->driver->fence_driver; - int i; - unsigned long flags; - - rwlock_init(&fm->lock); - write_lock_irqsave(&fm->lock, flags); - fm->initialized = 0; - if (!fed) - goto out_unlock; - - fm->initialized = 1; - fm->num_classes = fed->num_classes; - BUG_ON(fm->num_classes > _DRM_FENCE_CLASSES); - - for (i = 0; i < fm->num_classes; ++i) { - fence_class = &fm->fence_class[i]; - - memset(fence_class, 0, sizeof(*fence_class)); - INIT_LIST_HEAD(&fence_class->ring); - DRM_INIT_WAITQUEUE(&fence_class->fence_queue); - } - - atomic_set(&fm->count, 0); - out_unlock: - write_unlock_irqrestore(&fm->lock, flags); -} - -void drm_fence_fill_arg(struct drm_fence_object *fence, - struct drm_fence_arg *arg) -{ - struct drm_device *dev = fence->dev; - struct drm_fence_manager *fm = &dev->fm; - unsigned long irq_flags; - - read_lock_irqsave(&fm->lock, irq_flags); - arg->handle = fence->base.hash.key; - arg->fence_class = fence->fence_class; - arg->type = fence->type; - arg->signaled = fence->signaled_types; - arg->error = fence->error; - arg->sequence = fence->sequence; - read_unlock_irqrestore(&fm->lock, irq_flags); -} -EXPORT_SYMBOL(drm_fence_fill_arg); - -void drm_fence_manager_takedown(struct drm_device *dev) -{ -} - -struct drm_fence_object *drm_lookup_fence_object(struct drm_file *priv, - uint32_t handle) -{ - struct drm_device *dev = priv->minor->dev; - struct drm_user_object *uo; - struct drm_fence_object *fence; - - mutex_lock(&dev->struct_mutex); - uo = drm_lookup_user_object(priv, handle); - if (!uo || (uo->type != drm_fence_type)) { - mutex_unlock(&dev->struct_mutex); - return NULL; - } - fence = drm_fence_reference_locked(drm_user_object_entry(uo, struct drm_fence_object, base)); - mutex_unlock(&dev->struct_mutex); - return fence; -} - -int drm_fence_create_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv) -{ - int ret; - struct drm_fence_manager *fm = &dev->fm; - struct drm_fence_arg *arg = data; - struct drm_fence_object *fence; - ret = 0; - - if (!fm->initialized) { - DRM_ERROR("The DRM driver does not support fencing.\n"); - return -EINVAL; - } - - if (arg->flags & DRM_FENCE_FLAG_EMIT) - LOCK_TEST_WITH_RETURN(dev, file_priv); - ret = drm_fence_object_create(dev, arg->fence_class, - arg->type, arg->flags, &fence); - if (ret) - return ret; - ret = drm_fence_add_user_object(file_priv, fence, - arg->flags & - DRM_FENCE_FLAG_SHAREABLE); - if (ret) { - drm_fence_usage_deref_unlocked(&fence); - return ret; - } - - /* - * usage > 0. No need to lock dev->struct_mutex; - */ - - arg->handle = fence->base.hash.key; - - drm_fence_fill_arg(fence, arg); - drm_fence_usage_deref_unlocked(&fence); - - return ret; -} - -int drm_fence_reference_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv) -{ - int ret; - struct drm_fence_manager *fm = &dev->fm; - struct drm_fence_arg *arg = data; - struct drm_fence_object *fence; - struct drm_user_object *uo; - ret = 0; - - if (!fm->initialized) { - DRM_ERROR("The DRM driver does not support fencing.\n"); - return -EINVAL; - } - - ret = drm_user_object_ref(file_priv, arg->handle, drm_fence_type, &uo); - if (ret) - return ret; - fence = drm_lookup_fence_object(file_priv, arg->handle); - drm_fence_fill_arg(fence, arg); - drm_fence_usage_deref_unlocked(&fence); - - return ret; -} - - -int drm_fence_unreference_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv) -{ - int ret; - struct drm_fence_manager *fm = &dev->fm; - struct drm_fence_arg *arg = data; - ret = 0; - - if (!fm->initialized) { - DRM_ERROR("The DRM driver does not support fencing.\n"); - return -EINVAL; - } - - return drm_user_object_unref(file_priv, arg->handle, drm_fence_type); -} - -int drm_fence_signaled_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv) -{ - int ret; - struct drm_fence_manager *fm = &dev->fm; - struct drm_fence_arg *arg = data; - struct drm_fence_object *fence; - ret = 0; - - if (!fm->initialized) { - DRM_ERROR("The DRM driver does not support fencing.\n"); - return -EINVAL; - } - - fence = drm_lookup_fence_object(file_priv, arg->handle); - if (!fence) - return -EINVAL; - - drm_fence_fill_arg(fence, arg); - drm_fence_usage_deref_unlocked(&fence); - - return ret; -} - -int drm_fence_flush_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv) -{ - int ret; - struct drm_fence_manager *fm = &dev->fm; - struct drm_fence_arg *arg = data; - struct drm_fence_object *fence; - ret = 0; - - if (!fm->initialized) { - DRM_ERROR("The DRM driver does not support fencing.\n"); - return -EINVAL; - } - - fence = drm_lookup_fence_object(file_priv, arg->handle); - if (!fence) - return -EINVAL; - ret = drm_fence_object_flush(fence, arg->type); - - drm_fence_fill_arg(fence, arg); - drm_fence_usage_deref_unlocked(&fence); - - return ret; -} - - -int drm_fence_wait_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv) -{ - int ret; - struct drm_fence_manager *fm = &dev->fm; - struct drm_fence_arg *arg = data; - struct drm_fence_object *fence; - ret = 0; - - if (!fm->initialized) { - DRM_ERROR("The DRM driver does not support fencing.\n"); - return -EINVAL; - } - - fence = drm_lookup_fence_object(file_priv, arg->handle); - if (!fence) - return -EINVAL; - ret = drm_fence_object_wait(fence, - arg->flags & DRM_FENCE_FLAG_WAIT_LAZY, - 0, arg->type); - - drm_fence_fill_arg(fence, arg); - drm_fence_usage_deref_unlocked(&fence); - - return ret; -} - - -int drm_fence_emit_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv) -{ - int ret; - struct drm_fence_manager *fm = &dev->fm; - struct drm_fence_arg *arg = data; - struct drm_fence_object *fence; - ret = 0; - - if (!fm->initialized) { - DRM_ERROR("The DRM driver does not support fencing.\n"); - return -EINVAL; - } - - LOCK_TEST_WITH_RETURN(dev, file_priv); - fence = drm_lookup_fence_object(file_priv, arg->handle); - if (!fence) - return -EINVAL; - ret = drm_fence_object_emit(fence, arg->flags, arg->fence_class, - arg->type); - - drm_fence_fill_arg(fence, arg); - drm_fence_usage_deref_unlocked(&fence); - - return ret; -} - -int drm_fence_buffers_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv) -{ - int ret; - struct drm_fence_manager *fm = &dev->fm; - struct drm_fence_arg *arg = data; - struct drm_fence_object *fence; - ret = 0; - - if (!fm->initialized) { - DRM_ERROR("The DRM driver does not support fencing.\n"); - return -EINVAL; - } - - if (!dev->bm.initialized) { - DRM_ERROR("Buffer object manager is not initialized\n"); - return -EINVAL; - } - LOCK_TEST_WITH_RETURN(dev, file_priv); - ret = drm_fence_buffer_objects(dev, NULL, arg->flags, - NULL, &fence); - if (ret) - return ret; - - if (!(arg->flags & DRM_FENCE_FLAG_NO_USER)) { - ret = drm_fence_add_user_object(file_priv, fence, - arg->flags & - DRM_FENCE_FLAG_SHAREABLE); - if (ret) - return ret; - } - - arg->handle = fence->base.hash.key; - - drm_fence_fill_arg(fence, arg); - drm_fence_usage_deref_unlocked(&fence); - - return ret; -} diff --git a/linux-core/drm_fops.c b/linux-core/drm_fops.c index 837645ae..3e2691a8 100644 --- a/linux-core/drm_fops.c +++ b/linux-core/drm_fops.c @@ -152,13 +152,6 @@ int drm_open(struct inode *inode, struct file *filp) } out: - mutex_lock(&dev->struct_mutex); - BUG_ON((dev->dev_mapping != NULL) && - (dev->dev_mapping != inode->i_mapping)); - if (dev->dev_mapping == NULL) - dev->dev_mapping = inode->i_mapping; - mutex_unlock(&dev->struct_mutex); - return retcode; } EXPORT_SYMBOL(drm_open); @@ -332,33 +325,6 @@ int drm_fasync(int fd, struct file *filp, int on) } EXPORT_SYMBOL(drm_fasync); -static void drm_object_release(struct file *filp) -{ - struct drm_file *priv = filp->private_data; - struct list_head *head; - struct drm_ref_object *ref_object; - int i; - - /* - * Free leftover ref objects created by me. Note that we cannot use - * list_for_each() here, as the struct_mutex may be temporarily - * released by the remove_() functions, and thus the lists may be - * altered. - * Also, a drm_remove_ref_object() will not remove it - * from the list unless its refcount is 1. - */ - - head = &priv->refd_objects; - while (head->next != head) { - ref_object = list_entry(head->next, struct drm_ref_object, list); - drm_remove_ref_object(priv, ref_object); - head = &priv->refd_objects; - } - - for (i = 0; i < _DRM_NO_REF_TYPES; ++i) - drm_ht_remove(&priv->refd_object_hash[i]); -} - /** * Release file. * @@ -475,7 +441,6 @@ int drm_release(struct inode *inode, struct file *filp) mutex_unlock(&dev->ctxlist_mutex); mutex_lock(&dev->struct_mutex); - drm_object_release(filp); if (file_priv->remove_auth_on_close == 1) { struct drm_file *temp; diff --git a/linux-core/drm_object.c b/linux-core/drm_object.c deleted file mode 100644 index 2994b716..00000000 --- a/linux-core/drm_object.c +++ /dev/null @@ -1,294 +0,0 @@ -/************************************************************************** - * - * Copyright (c) 2006-2007 Tungsten Graphics, Inc., Cedar Park, TX., USA - * All Rights Reserved. - * - * Permission is hereby granted, free of charge, to any person obtaining a - * copy of this software and associated documentation files (the - * "Software"), to deal in the Software without restriction, including - * without limitation the rights to use, copy, modify, merge, publish, - * distribute, sub license, and/or sell copies of the Software, and to - * permit persons to whom the Software is furnished to do so, subject to - * the following conditions: - * - * The above copyright notice and this permission notice (including the - * next paragraph) shall be included in all copies or substantial portions - * of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL - * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, - * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR - * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE - * USE OR OTHER DEALINGS IN THE SOFTWARE. - * - **************************************************************************/ -/* - * Authors: Thomas Hellström <thomas-at-tungstengraphics-dot-com> - */ - -#include "drmP.h" - -int drm_add_user_object(struct drm_file *priv, struct drm_user_object *item, - int shareable) -{ - struct drm_device *dev = priv->minor->dev; - int ret; - - DRM_ASSERT_LOCKED(&dev->struct_mutex); - - /* The refcount will be bumped to 1 when we add the ref object below. */ - atomic_set(&item->refcount, 0); - item->shareable = shareable; - item->owner = priv; - - ret = drm_ht_just_insert_please(&dev->object_hash, &item->hash, - (unsigned long)item, 31, 0, 0); - if (ret) - return ret; - - ret = drm_add_ref_object(priv, item, _DRM_REF_USE); - if (ret) - ret = drm_ht_remove_item(&dev->object_hash, &item->hash); - - return ret; -} -EXPORT_SYMBOL(drm_add_user_object); - -struct drm_user_object *drm_lookup_user_object(struct drm_file *priv, uint32_t key) -{ - struct drm_device *dev = priv->minor->dev; - struct drm_hash_item *hash; - int ret; - struct drm_user_object *item; - - DRM_ASSERT_LOCKED(&dev->struct_mutex); - - ret = drm_ht_find_item(&dev->object_hash, key, &hash); - if (ret) - return NULL; - - item = drm_hash_entry(hash, struct drm_user_object, hash); - - if (priv != item->owner) { - struct drm_open_hash *ht = &priv->refd_object_hash[_DRM_REF_USE]; - ret = drm_ht_find_item(ht, (unsigned long)item, &hash); - if (ret) { - DRM_ERROR("Object not registered for usage\n"); - return NULL; - } - } - return item; -} -EXPORT_SYMBOL(drm_lookup_user_object); - -static void drm_deref_user_object(struct drm_file *priv, struct drm_user_object *item) -{ - struct drm_device *dev = priv->minor->dev; - int ret; - - if (atomic_dec_and_test(&item->refcount)) { - ret = drm_ht_remove_item(&dev->object_hash, &item->hash); - BUG_ON(ret); - item->remove(priv, item); - } -} - -static int drm_object_ref_action(struct drm_file *priv, struct drm_user_object *ro, - enum drm_ref_type action) -{ - int ret = 0; - - switch (action) { - case _DRM_REF_USE: - atomic_inc(&ro->refcount); - break; - default: - if (!ro->ref_struct_locked) { - break; - } else { - ro->ref_struct_locked(priv, ro, action); - } - } - return ret; -} - -int drm_add_ref_object(struct drm_file *priv, struct drm_user_object *referenced_object, - enum drm_ref_type ref_action) -{ - int ret = 0; - struct drm_ref_object *item; - struct drm_open_hash *ht = &priv->refd_object_hash[ref_action]; - - DRM_ASSERT_LOCKED(&priv->minor->dev->struct_mutex); - if (!referenced_object->shareable && priv != referenced_object->owner) { - DRM_ERROR("Not allowed to reference this object\n"); - return -EINVAL; - } - - /* - * If this is not a usage reference, Check that usage has been registered - * first. Otherwise strange things may happen on destruction. - */ - - if ((ref_action != _DRM_REF_USE) && priv != referenced_object->owner) { - item = - drm_lookup_ref_object(priv, referenced_object, - _DRM_REF_USE); - if (!item) { - DRM_ERROR - ("Object not registered for usage by this client\n"); - return -EINVAL; - } - } - - if (NULL != - (item = - drm_lookup_ref_object(priv, referenced_object, ref_action))) { - atomic_inc(&item->refcount); - return drm_object_ref_action(priv, referenced_object, - ref_action); - } - - item = drm_ctl_calloc(1, sizeof(*item), DRM_MEM_OBJECTS); - if (item == NULL) { - DRM_ERROR("Could not allocate reference object\n"); - return -ENOMEM; - } - - atomic_set(&item->refcount, 1); - item->hash.key = (unsigned long)referenced_object; - ret = drm_ht_insert_item(ht, &item->hash); - item->unref_action = ref_action; - - if (ret) - goto out; - - list_add(&item->list, &priv->refd_objects); - ret = drm_object_ref_action(priv, referenced_object, ref_action); -out: - return ret; -} - -struct drm_ref_object *drm_lookup_ref_object(struct drm_file *priv, - struct drm_user_object *referenced_object, - enum drm_ref_type ref_action) -{ - struct drm_hash_item *hash; - int ret; - - DRM_ASSERT_LOCKED(&priv->minor->dev->struct_mutex); - ret = drm_ht_find_item(&priv->refd_object_hash[ref_action], - (unsigned long)referenced_object, &hash); - if (ret) - return NULL; - - return drm_hash_entry(hash, struct drm_ref_object, hash); -} -EXPORT_SYMBOL(drm_lookup_ref_object); - -static void drm_remove_other_references(struct drm_file *priv, - struct drm_user_object *ro) -{ - int i; - struct drm_open_hash *ht; - struct drm_hash_item *hash; - struct drm_ref_object *item; - - for (i = _DRM_REF_USE + 1; i < _DRM_NO_REF_TYPES; ++i) { - ht = &priv->refd_object_hash[i]; - while (!drm_ht_find_item(ht, (unsigned long)ro, &hash)) { - item = drm_hash_entry(hash, struct drm_ref_object, hash); - drm_remove_ref_object(priv, item); - } - } -} - -void drm_remove_ref_object(struct drm_file *priv, struct drm_ref_object *item) -{ - int ret; - struct drm_user_object *user_object = (struct drm_user_object *) item->hash.key; - struct drm_open_hash *ht = &priv->refd_object_hash[item->unref_action]; - enum drm_ref_type unref_action; - - DRM_ASSERT_LOCKED(&priv->minor->dev->struct_mutex); - unref_action = item->unref_action; - if (atomic_dec_and_test(&item->refcount)) { - ret = drm_ht_remove_item(ht, &item->hash); - BUG_ON(ret); - list_del_init(&item->list); - if (unref_action == _DRM_REF_USE) - drm_remove_other_references(priv, user_object); - drm_ctl_free(item, sizeof(*item), DRM_MEM_OBJECTS); - } - - switch (unref_action) { - case _DRM_REF_USE: - drm_deref_user_object(priv, user_object); - break; - default: - BUG_ON(!user_object->unref); - user_object->unref(priv, user_object, unref_action); - break; - } - -} -EXPORT_SYMBOL(drm_remove_ref_object); - -int drm_user_object_ref(struct drm_file *priv, uint32_t user_token, - enum drm_object_type type, struct drm_user_object **object) -{ - struct drm_device *dev = priv->minor->dev; - struct drm_user_object *uo; - struct drm_hash_item *hash; - int ret; - - mutex_lock(&dev->struct_mutex); - ret = drm_ht_find_item(&dev->object_hash, user_token, &hash); - if (ret) { - DRM_ERROR("Could not find user object to reference.\n"); - goto out_err; - } - uo = drm_hash_entry(hash, struct drm_user_object, hash); - if (uo->type != type) { - ret = -EINVAL; - goto out_err; - } - ret = drm_add_ref_object(priv, uo, _DRM_REF_USE); - if (ret) - goto out_err; - mutex_unlock(&dev->struct_mutex); - *object = uo; - return 0; -out_err: - mutex_unlock(&dev->struct_mutex); - return ret; -} - -int drm_user_object_unref(struct drm_file *priv, uint32_t user_token, - enum drm_object_type type) -{ - struct drm_device *dev = priv->minor->dev; - struct drm_user_object *uo; - struct drm_ref_object *ro; - int ret; - - mutex_lock(&dev->struct_mutex); - uo = drm_lookup_user_object(priv, user_token); - if (!uo || (uo->type != type)) { - ret = -EINVAL; - goto out_err; - } - ro = drm_lookup_ref_object(priv, uo, _DRM_REF_USE); - if (!ro) { - ret = -EINVAL; - goto out_err; - } - drm_remove_ref_object(priv, ro); - mutex_unlock(&dev->struct_mutex); - return 0; -out_err: - mutex_unlock(&dev->struct_mutex); - return ret; -} diff --git a/linux-core/drm_objects.h b/linux-core/drm_objects.h deleted file mode 100644 index 136fdc8d..00000000 --- a/linux-core/drm_objects.h +++ /dev/null @@ -1,821 +0,0 @@ -/************************************************************************** - * - * Copyright (c) 2006-2007 Tungsten Graphics, Inc., Cedar Park, TX., USA - * All Rights Reserved. - * - * Permission is hereby granted, free of charge, to any person obtaining a - * copy of this software and associated documentation files (the - * "Software"), to deal in the Software without restriction, including - * without limitation the rights to use, copy, modify, merge, publish, - * distribute, sub license, and/or sell copies of the Software, and to - * permit persons to whom the Software is furnished to do so, subject to - * the following conditions: - * - * The above copyright notice and this permission notice (including the - * next paragraph) shall be included in all copies or substantial portions - * of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL - * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, - * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR - * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE - * USE OR OTHER DEALINGS IN THE SOFTWARE. - * - **************************************************************************/ -/* - * Authors: Thomas Hellström <thomas-at-tungstengraphics-dot-com> - */ - -#ifndef _DRM_OBJECTS_H -#define _DRM_OBJECTS_H - -struct drm_device; -struct drm_bo_mem_reg; - -/*************************************************** - * User space objects. (drm_object.c) - */ - -#define drm_user_object_entry(_ptr, _type, _member) container_of(_ptr, _type, _member) - -enum drm_object_type { - drm_fence_type, - drm_buffer_type, - drm_lock_type, - /* - * Add other user space object types here. - */ - drm_driver_type0 = 256, - drm_driver_type1, - drm_driver_type2, - drm_driver_type3, - drm_driver_type4 -}; - -/* - * A user object is a structure that helps the drm give out user handles - * to kernel internal objects and to keep track of these objects so that - * they can be destroyed, for example when the user space process exits. - * Designed to be accessible using a user space 32-bit handle. - */ - -struct drm_user_object { - struct drm_hash_item hash; - struct list_head list; - enum drm_object_type type; - atomic_t refcount; - int shareable; - struct drm_file *owner; - void (*ref_struct_locked) (struct drm_file *priv, - struct drm_user_object *obj, - enum drm_ref_type ref_action); - void (*unref) (struct drm_file *priv, struct drm_user_object *obj, - enum drm_ref_type unref_action); - void (*remove) (struct drm_file *priv, struct drm_user_object *obj); -}; - -/* - * A ref object is a structure which is used to - * keep track of references to user objects and to keep track of these - * references so that they can be destroyed for example when the user space - * process exits. Designed to be accessible using a pointer to the _user_ object. - */ - -struct drm_ref_object { - struct drm_hash_item hash; - struct list_head list; - atomic_t refcount; - enum drm_ref_type unref_action; -}; - -/** - * Must be called with the struct_mutex held. - */ - -extern int drm_add_user_object(struct drm_file *priv, struct drm_user_object *item, - int shareable); -/** - * Must be called with the struct_mutex held. - */ - -extern struct drm_user_object *drm_lookup_user_object(struct drm_file *priv, - uint32_t key); - -/* - * Must be called with the struct_mutex held. May temporarily release it. - */ - -extern int drm_add_ref_object(struct drm_file *priv, - struct drm_user_object *referenced_object, - enum drm_ref_type ref_action); - -/* - * Must be called with the struct_mutex held. - */ - -struct drm_ref_object *drm_lookup_ref_object(struct drm_file *priv, - struct drm_user_object *referenced_object, - enum drm_ref_type ref_action); -/* - * Must be called with the struct_mutex held. - * If "item" has been obtained by a call to drm_lookup_ref_object. You may not - * release the struct_mutex before calling drm_remove_ref_object. - * This function may temporarily release the struct_mutex. - */ - -extern void drm_remove_ref_object(struct drm_file *priv, struct drm_ref_object *item); -extern int drm_user_object_ref(struct drm_file *priv, uint32_t user_token, - enum drm_object_type type, - struct drm_user_object **object); -extern int drm_user_object_unref(struct drm_file *priv, uint32_t user_token, - enum drm_object_type type); - -/*************************************************** - * Fence objects. (drm_fence.c) - */ - -struct drm_fence_object { - struct drm_user_object base; - struct drm_device *dev; - atomic_t usage; - - /* - * The below three fields are protected by the fence manager spinlock. - */ - - struct list_head ring; - int fence_class; - uint32_t native_types; - uint32_t type; - uint32_t signaled_types; - uint32_t sequence; - uint32_t waiting_types; - uint32_t error; -}; - -#define _DRM_FENCE_CLASSES 8 -#define _DRM_FENCE_TYPE_EXE 0x00 - -struct drm_fence_class_manager { - struct list_head ring; - uint32_t pending_flush; - uint32_t waiting_types; - wait_queue_head_t fence_queue; - uint32_t highest_waiting_sequence; - uint32_t latest_queued_sequence; -}; - -struct drm_fence_manager { - int initialized; - rwlock_t lock; - struct drm_fence_class_manager fence_class[_DRM_FENCE_CLASSES]; - uint32_t num_classes; - atomic_t count; -}; - -struct drm_fence_driver { - unsigned long *waiting_jiffies; - uint32_t num_classes; - uint32_t wrap_diff; - uint32_t flush_diff; - uint32_t sequence_mask; - - /* - * Driver implemented functions: - * has_irq() : 1 if the hardware can update the indicated type_flags using an - * irq handler. 0 if polling is required. - * - * emit() : Emit a sequence number to the command stream. - * Return the sequence number. - * - * flush() : Make sure the flags indicated in fc->pending_flush will eventually - * signal for fc->highest_received_sequence and all preceding sequences. - * Acknowledge by clearing the flags fc->pending_flush. - * - * poll() : Call drm_fence_handler with any new information. - * - * needed_flush() : Given the current state of the fence->type flags and previusly - * executed or queued flushes, return the type_flags that need flushing. - * - * wait(): Wait for the "mask" flags to signal on a given fence, performing - * whatever's necessary to make this happen. - */ - - int (*has_irq) (struct drm_device *dev, uint32_t fence_class, - uint32_t flags); - int (*emit) (struct drm_device *dev, uint32_t fence_class, - uint32_t flags, uint32_t *breadcrumb, - uint32_t *native_type); - void (*flush) (struct drm_device *dev, uint32_t fence_class); - void (*poll) (struct drm_device *dev, uint32_t fence_class, - uint32_t types); - uint32_t (*needed_flush) (struct drm_fence_object *fence); - int (*wait) (struct drm_fence_object *fence, int lazy, - int interruptible, uint32_t mask); -}; - -extern int drm_fence_wait_polling(struct drm_fence_object *fence, int lazy, - int interruptible, uint32_t mask, - unsigned long end_jiffies); -extern void drm_fence_handler(struct drm_device *dev, uint32_t fence_class, - uint32_t sequence, uint32_t type, - uint32_t error); -extern void drm_fence_manager_init(struct drm_device *dev); -extern void drm_fence_manager_takedown(struct drm_device *dev); -extern void drm_fence_flush_old(struct drm_device *dev, uint32_t fence_class, - uint32_t sequence); -extern int drm_fence_object_flush(struct drm_fence_object *fence, - uint32_t type); -extern int drm_fence_object_signaled(struct drm_fence_object *fence, - uint32_t type); -extern void drm_fence_usage_deref_locked(struct drm_fence_object **fence); -extern void drm_fence_usage_deref_unlocked(struct drm_fence_object **fence); -extern struct drm_fence_object *drm_fence_reference_locked(struct drm_fence_object *src); -extern void drm_fence_reference_unlocked(struct drm_fence_object **dst, - struct drm_fence_object *src); -extern int drm_fence_object_wait(struct drm_fence_object *fence, - int lazy, int ignore_signals, uint32_t mask); -extern int drm_fence_object_create(struct drm_device *dev, uint32_t type, - uint32_t fence_flags, uint32_t fence_class, - struct drm_fence_object **c_fence); -extern int drm_fence_object_emit(struct drm_fence_object *fence, - uint32_t fence_flags, uint32_t class, - uint32_t type); -extern void drm_fence_fill_arg(struct drm_fence_object *fence, - struct drm_fence_arg *arg); - -extern int drm_fence_add_user_object(struct drm_file *priv, - struct drm_fence_object *fence, - int shareable); - -extern int drm_fence_create_ioctl(struct drm_device *dev, void *data, - struct drm_file *file_priv); -extern int drm_fence_destroy_ioctl(struct drm_device *dev, void *data, - struct drm_file *file_priv); -extern int drm_fence_reference_ioctl(struct drm_device *dev, void *data, - struct drm_file *file_priv); -extern int drm_fence_unreference_ioctl(struct drm_device *dev, void *data, - struct drm_file *file_priv); -extern int drm_fence_signaled_ioctl(struct drm_device *dev, void *data, - struct drm_file *file_priv); -extern int drm_fence_flush_ioctl(struct drm_device *dev, void *data, - struct drm_file *file_priv); -extern int drm_fence_wait_ioctl(struct drm_device *dev, void *data, - struct drm_file *file_priv); -extern int drm_fence_emit_ioctl(struct drm_device *dev, void *data, - struct drm_file *file_priv); -extern int drm_fence_buffers_ioctl(struct drm_device *dev, void *data, - struct drm_file *file_priv); -/************************************************** - *TTMs - */ - -/* - * The ttm backend GTT interface. (In our case AGP). - * Any similar type of device (PCIE?) - * needs only to implement these functions to be usable with the TTM interface. - * The AGP backend implementation lives in drm_agpsupport.c - * basically maps these calls to available functions in agpgart. - * Each drm device driver gets an - * additional function pointer that creates these types, - * so that the device can choose the correct aperture. - * (Multiple AGP apertures, etc.) - * Most device drivers will let this point to the standard AGP implementation. - */ - -#define DRM_BE_FLAG_NEEDS_FREE 0x00000001 -#define DRM_BE_FLAG_BOUND_CACHED 0x00000002 - -struct drm_ttm_backend; -struct drm_ttm_backend_func { - int (*needs_ub_cache_adjust) (struct drm_ttm_backend *backend); - int (*populate) (struct drm_ttm_backend *backend, - unsigned long num_pages, struct page **pages, - struct page *dummy_read_page); - void (*clear) (struct drm_ttm_backend *backend); - int (*bind) (struct drm_ttm_backend *backend, - struct drm_bo_mem_reg *bo_mem); - int (*unbind) (struct drm_ttm_backend *backend); - void (*destroy) (struct drm_ttm_backend *backend); -}; - -/** - * This structure associates a set of flags and methods with a drm_ttm - * object, and will also be subclassed by the particular backend. - * - * \sa #drm_agp_ttm_backend - */ -struct drm_ttm_backend { - struct drm_device *dev; - uint32_t flags; - struct drm_ttm_backend_func *func; -}; - -struct drm_ttm { - struct page *dummy_read_page; - struct page **pages; - long first_himem_page; - long last_lomem_page; - uint32_t page_flags; - unsigned long num_pages; - atomic_t vma_count; - struct drm_device *dev; - int destroy; - uint32_t mapping_offset; - struct drm_ttm_backend *be; - unsigned long highest_lomem_entry; - unsigned long lowest_himem_entry; - enum { - ttm_bound, - ttm_evicted, - ttm_unbound, - ttm_unpopulated, - } state; - -}; - -extern struct drm_ttm *drm_ttm_create(struct drm_device *dev, unsigned long size, - uint32_t page_flags, - struct page *dummy_read_page); -extern int drm_ttm_bind(struct drm_ttm *ttm, struct drm_bo_mem_reg *bo_mem); -extern void drm_ttm_unbind(struct drm_ttm *ttm); -extern void drm_ttm_evict(struct drm_ttm *ttm); -extern void drm_ttm_fixup_caching(struct drm_ttm *ttm); -extern struct page *drm_ttm_get_page(struct drm_ttm *ttm, int index); -extern void drm_ttm_cache_flush(struct page *pages[], unsigned long num_pages); -extern int drm_ttm_populate(struct drm_ttm *ttm); -extern int drm_ttm_set_user(struct drm_ttm *ttm, - struct task_struct *tsk, - unsigned long start, - unsigned long num_pages); - -/* - * Destroy a ttm. The user normally calls drmRmMap or a similar IOCTL to do - * this which calls this function iff there are no vmas referencing it anymore. - * Otherwise it is called when the last vma exits. - */ - -extern int drm_ttm_destroy(struct drm_ttm *ttm); - -#define DRM_FLAG_MASKED(_old, _new, _mask) {\ -(_old) ^= (((_old) ^ (_new)) & (_mask)); \ -} - -#define DRM_TTM_MASK_FLAGS ((1 << PAGE_SHIFT) - 1) -#define DRM_TTM_MASK_PFN (0xFFFFFFFFU - DRM_TTM_MASK_FLAGS) - -/* - * Page flags. - */ - -/* - * This ttm should not be cached by the CPU - */ -#define DRM_TTM_PAGE_UNCACHED (1 << 0) -/* - * This flat is not used at this time; I don't know what the - * intent was - */ -#define DRM_TTM_PAGE_USED (1 << 1) -/* - * This flat is not used at this time; I don't know what the - * intent was - */ -#define DRM_TTM_PAGE_BOUND (1 << 2) -/* - * This flat is not used at this time; I don't know what the - * intent was - */ -#define DRM_TTM_PAGE_PRESENT (1 << 3) -/* - * The array of page pointers was allocated with vmalloc - * instead of drm_calloc. - */ -#define DRM_TTM_PAGEDIR_VMALLOC (1 << 4) -/* - * This ttm is mapped from user space - */ -#define DRM_TTM_PAGE_USER (1 << 5) -/* - * This ttm will be written to by the GPU - */ -#define DRM_TTM_PAGE_WRITE (1 << 6) -/* - * This ttm was mapped to the GPU, and so the contents may have - * been modified - */ -#define DRM_TTM_PAGE_USER_DIRTY (1 << 7) -/* - * This flag is not used at this time; I don't know what the - * intent was. - */ -#define DRM_TTM_PAGE_USER_DMA (1 << 8) - -/*************************************************** - * Buffer objects. (drm_bo.c, drm_bo_move.c) - */ - -struct drm_bo_mem_reg { - struct drm_mm_node *mm_node; - unsigned long size; - unsigned long num_pages; - uint32_t page_alignment; - uint32_t mem_type; - /* - * Current buffer status flags, indicating - * where the buffer is located and which - * access modes are in effect - */ - uint64_t flags; - /** - * These are the flags proposed for - * a validate operation. If the - * validate succeeds, they'll get moved - * into the flags field - */ - uint64_t proposed_flags; - - uint32_t desired_tile_stride; - uint32_t hw_tile_stride; -}; - -enum drm_bo_type { - /* - * drm_bo_type_device are 'normal' drm allocations, - * pages are allocated from within the kernel automatically - * and the objects can be mmap'd from the drm device. Each - * drm_bo_type_device object has a unique name which can be - * used by other processes to share access to the underlying - * buffer. - */ - drm_bo_type_device, - /* - * drm_bo_type_user are buffers of pages that already exist - * in the process address space. They are more limited than - * drm_bo_type_device buffers in that they must always - * remain cached (as we assume the user pages are mapped cached), - * and they are not sharable to other processes through DRM - * (although, regular shared memory should still work fine). - */ - drm_bo_type_user, - /* - * drm_bo_type_kernel are buffers that exist solely for use - * within the kernel. The pages cannot be mapped into the - * process. One obvious use would be for the ring - * buffer where user access would not (ideally) be required. - */ - drm_bo_type_kernel, -}; - -struct drm_buffer_object { - struct drm_device *dev; - struct drm_user_object base; - - /* - * If there is a possibility that the usage variable is zero, - * then dev->struct_mutext should be locked before incrementing it. - */ - - atomic_t usage; - unsigned long buffer_start; - enum drm_bo_type type; - unsigned long offset; - atomic_t mapped; - struct drm_bo_mem_reg mem; - - struct list_head lru; - struct list_head ddestroy; - - uint32_t fence_type; - uint32_t fence_class; - uint32_t new_fence_type; - uint32_t new_fence_class; - struct drm_fence_object *fence; - uint32_t priv_flags; - wait_queue_head_t event_queue; - struct mutex mutex; - unsigned long num_pages; - - /* For pinned buffers */ - struct drm_mm_node *pinned_node; - uint32_t pinned_mem_type; - struct list_head pinned_lru; - - /* For vm */ - struct drm_ttm *ttm; - struct drm_map_list map_list; - uint32_t memory_type; - unsigned long bus_offset; - uint32_t vm_flags; - void *iomap; -}; - -#define _DRM_BO_FLAG_UNFENCED 0x00000001 -#define _DRM_BO_FLAG_EVICTED 0x00000002 - -/* - * This flag indicates that a flag called with bo->mutex held has - * temporarily released the buffer object mutex, (usually to wait for something). - * and thus any post-lock validation needs to be rerun. - */ - -#define _DRM_BO_FLAG_UNLOCKED 0x00000004 - -struct drm_mem_type_manager { - int has_type; - int use_type; - int kern_init_type; - struct drm_mm manager; - struct list_head lru; - struct list_head pinned; - uint32_t flags; - uint32_t drm_bus_maptype; - unsigned long gpu_offset; - unsigned long io_offset; - unsigned long io_size; - void *io_addr; - uint64_t size; /* size of managed area for reporting to userspace */ -}; - -struct drm_bo_lock { - struct drm_user_object base; - wait_queue_head_t queue; - atomic_t write_lock_pending; - atomic_t readers; -}; - -#define _DRM_FLAG_MEMTYPE_FIXED 0x00000001 /* Fixed (on-card) PCI memory */ -#define _DRM_FLAG_MEMTYPE_MAPPABLE 0x00000002 /* Memory mappable */ -#define _DRM_FLAG_MEMTYPE_CACHED 0x00000004 /* Cached binding */ -#define _DRM_FLAG_NEEDS_IOREMAP 0x00000008 /* Fixed memory needs ioremap - before kernel access. */ -#define _DRM_FLAG_MEMTYPE_CMA 0x00000010 /* Can't map aperture */ -#define _DRM_FLAG_MEMTYPE_CSELECT 0x00000020 /* Select caching */ - -struct drm_buffer_manager { - struct drm_bo_lock bm_lock; - struct mutex evict_mutex; - int nice_mode; - int initialized; - struct drm_file *last_to_validate; - struct drm_mem_type_manager man[DRM_BO_MEM_TYPES]; - struct list_head unfenced; - struct list_head ddestroy; - struct delayed_work wq; - uint32_t fence_type; - unsigned long cur_pages; - atomic_t count; - struct page *dummy_read_page; -}; - -struct drm_bo_driver { - const uint32_t *mem_type_prio; - const uint32_t *mem_busy_prio; - uint32_t num_mem_type_prio; - uint32_t num_mem_busy_prio; - struct drm_ttm_backend *(*create_ttm_backend_entry) - (struct drm_device *dev); - int (*fence_type) (struct drm_buffer_object *bo, uint32_t *fclass, - uint32_t *type); - int (*invalidate_caches) (struct drm_device *dev, uint64_t flags); - int (*init_mem_type) (struct drm_device *dev, uint32_t type, - struct drm_mem_type_manager *man); - /* - * evict_flags: - * - * @bo: the buffer object to be evicted - * - * Return the bo flags for a buffer which is not mapped to the hardware. - * These will be placed in proposed_flags so that when the move is - * finished, they'll end up in bo->mem.flags - */ - uint64_t(*evict_flags) (struct drm_buffer_object *bo); - /* - * move: - * - * @bo: the buffer to move - * - * @evict: whether this motion is evicting the buffer from - * the graphics address space - * - * @no_wait: whether this should give up and return -EBUSY - * if this move would require sleeping - * - * @new_mem: the new memory region receiving the buffer - * - * Move a buffer between two memory regions. - */ - int (*move) (struct drm_buffer_object *bo, - int evict, int no_wait, struct drm_bo_mem_reg *new_mem); - /* - * ttm_cache_flush - */ - void (*ttm_cache_flush)(struct drm_ttm *ttm); - - /* - * command_stream_barrier - * - * @dev: The drm device. - * - * @bo: The buffer object to validate. - * - * @new_fence_class: The new fence class for the buffer object. - * - * @new_fence_type: The new fence type for the buffer object. - * - * @no_wait: whether this should give up and return -EBUSY - * if this operation would require sleeping - * - * Insert a command stream barrier that makes sure that the - * buffer is idle once the commands associated with the - * current validation are starting to execute. If an error - * condition is returned, or the function pointer is NULL, - * the drm core will force buffer idle - * during validation. - */ - - int (*command_stream_barrier) (struct drm_buffer_object *bo, - uint32_t new_fence_class, - uint32_t new_fence_type, - int no_wait); -}; - -/* - * buffer objects (drm_bo.c) - */ - -extern int drm_bo_create_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv); -extern int drm_bo_destroy_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv); -extern int drm_bo_map_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv); -extern int drm_bo_unmap_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv); -extern int drm_bo_reference_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv); -extern int drm_bo_unreference_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv); -extern int drm_bo_wait_idle_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv); -extern int drm_bo_info_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv); -extern int drm_bo_setstatus_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv); -extern int drm_mm_init_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv); -extern int drm_mm_takedown_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv); -extern int drm_mm_lock_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv); -extern int drm_mm_unlock_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv); -extern int drm_mm_info_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv); -extern int drm_bo_version_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv); -extern int drm_bo_driver_finish(struct drm_device *dev); -extern int drm_bo_driver_init(struct drm_device *dev); -extern int drm_bo_pci_offset(struct drm_device *dev, - struct drm_bo_mem_reg *mem, - unsigned long *bus_base, - unsigned long *bus_offset, - unsigned long *bus_size); -extern int drm_mem_reg_is_pci(struct drm_device *dev, struct drm_bo_mem_reg *mem); - -extern void drm_bo_usage_deref_locked(struct drm_buffer_object **bo); -extern void drm_bo_usage_deref_unlocked(struct drm_buffer_object **bo); -extern void drm_putback_buffer_objects(struct drm_device *dev); -extern int drm_fence_buffer_objects(struct drm_device *dev, - struct list_head *list, - uint32_t fence_flags, - struct drm_fence_object *fence, - struct drm_fence_object **used_fence); -extern void drm_bo_add_to_lru(struct drm_buffer_object *bo); -extern int drm_buffer_object_create(struct drm_device *dev, unsigned long size, - enum drm_bo_type type, uint64_t flags, - uint32_t hint, uint32_t page_alignment, - unsigned long buffer_start, - struct drm_buffer_object **bo); -extern int drm_bo_wait(struct drm_buffer_object *bo, int lazy, int interruptible, - int no_wait, int check_unfenced); -extern int drm_bo_mem_space(struct drm_buffer_object *bo, - struct drm_bo_mem_reg *mem, int no_wait); -extern int drm_bo_move_buffer(struct drm_buffer_object *bo, - uint64_t new_mem_flags, - int no_wait, int move_unfenced); -extern int drm_bo_clean_mm(struct drm_device *dev, unsigned mem_type, int kern_clean); -extern int drm_bo_init_mm(struct drm_device *dev, unsigned type, - unsigned long p_offset, unsigned long p_size, - int kern_init); -extern int drm_bo_handle_validate(struct drm_file *file_priv, uint32_t handle, - uint64_t flags, uint64_t mask, uint32_t hint, - uint32_t fence_class, - struct drm_bo_info_rep *rep, - struct drm_buffer_object **bo_rep); -extern struct drm_buffer_object *drm_lookup_buffer_object(struct drm_file *file_priv, - uint32_t handle, - int check_owner); -extern int drm_bo_do_validate(struct drm_buffer_object *bo, - uint64_t flags, uint64_t mask, uint32_t hint, - uint32_t fence_class, - struct drm_bo_info_rep *rep); -extern int drm_bo_evict_cached(struct drm_buffer_object *bo); -/* - * Buffer object memory move- and map helpers. - * drm_bo_move.c - */ - -extern int drm_bo_move_ttm(struct drm_buffer_object *bo, - int evict, int no_wait, - struct drm_bo_mem_reg *new_mem); -extern int drm_bo_move_memcpy(struct drm_buffer_object *bo, - int evict, - int no_wait, struct drm_bo_mem_reg *new_mem); -extern int drm_bo_move_accel_cleanup(struct drm_buffer_object *bo, - int evict, int no_wait, - uint32_t fence_class, uint32_t fence_type, - uint32_t fence_flags, - struct drm_bo_mem_reg *new_mem); -extern int drm_bo_same_page(unsigned long offset, unsigned long offset2); -extern unsigned long drm_bo_offset_end(unsigned long offset, - unsigned long end); - -struct drm_bo_kmap_obj { - void *virtual; - struct page *page; - enum { - bo_map_iomap, - bo_map_vmap, - bo_map_kmap, - bo_map_premapped, - } bo_kmap_type; -}; - -static inline void *drm_bmo_virtual(struct drm_bo_kmap_obj *map, int *is_iomem) -{ - *is_iomem = (map->bo_kmap_type == bo_map_iomap || - map->bo_kmap_type == bo_map_premapped); - return map->virtual; -} -extern void drm_bo_kunmap(struct drm_bo_kmap_obj *map); -extern int drm_bo_kmap(struct drm_buffer_object *bo, unsigned long start_page, - unsigned long num_pages, struct drm_bo_kmap_obj *map); -extern int drm_bo_pfn_prot(struct drm_buffer_object *bo, - unsigned long dst_offset, - unsigned long *pfn, - pgprot_t *prot); -extern void drm_bo_fill_rep_arg(struct drm_buffer_object *bo, - struct drm_bo_info_rep *rep); - - -/* - * drm_regman.c - */ - -struct drm_reg { - struct list_head head; - struct drm_fence_object *fence; - uint32_t fence_type; - uint32_t new_fence_type; -}; - -struct drm_reg_manager { - struct list_head free; - struct list_head lru; - struct list_head unfenced; - - int (*reg_reusable)(const struct drm_reg *reg, const void *data); - void (*reg_destroy)(struct drm_reg *reg); -}; - -extern int drm_regs_alloc(struct drm_reg_manager *manager, - const void *data, - uint32_t fence_class, - uint32_t fence_type, - int interruptible, - int no_wait, - struct drm_reg **reg); - -extern void drm_regs_fence(struct drm_reg_manager *regs, - struct drm_fence_object *fence); - -extern void drm_regs_free(struct drm_reg_manager *manager); -extern void drm_regs_add(struct drm_reg_manager *manager, struct drm_reg *reg); -extern void drm_regs_init(struct drm_reg_manager *manager, - int (*reg_reusable)(const struct drm_reg *, - const void *), - void (*reg_destroy)(struct drm_reg *)); - -/* - * drm_bo_lock.c - * Simple replacement for the hardware lock on buffer manager init and clean. - */ - - -extern void drm_bo_init_lock(struct drm_bo_lock *lock); -extern void drm_bo_read_unlock(struct drm_bo_lock *lock); -extern int drm_bo_read_lock(struct drm_bo_lock *lock, - int interruptible); -extern int drm_bo_write_lock(struct drm_bo_lock *lock, - int interruptible, - struct drm_file *file_priv); - -extern int drm_bo_write_unlock(struct drm_bo_lock *lock, - struct drm_file *file_priv); - -#ifdef CONFIG_DEBUG_MUTEXES -#define DRM_ASSERT_LOCKED(_mutex) \ - BUG_ON(!mutex_is_locked(_mutex) || \ - ((_mutex)->owner != current_thread_info())) -#else -#define DRM_ASSERT_LOCKED(_mutex) -#endif -#endif diff --git a/linux-core/drm_proc.c b/linux-core/drm_proc.c index 15d8cb96..57c83278 100644 --- a/linux-core/drm_proc.c +++ b/linux-core/drm_proc.c @@ -49,8 +49,6 @@ static int drm_queues_info(char *buf, char **start, off_t offset, int request, int *eof, void *data); static int drm_bufs_info(char *buf, char **start, off_t offset, int request, int *eof, void *data); -static int drm_objects_info(char *buf, char **start, off_t offset, - int request, int *eof, void *data); static int drm_gem_name_info(char *buf, char **start, off_t offset, int request, int *eof, void *data); static int drm_gem_object_info(char *buf, char **start, off_t offset, @@ -73,7 +71,6 @@ static struct drm_proc_list { {"clients", drm_clients_info}, {"queues", drm_queues_info}, {"bufs", drm_bufs_info}, - {"objects", drm_objects_info}, {"gem_names", drm_gem_name_info}, {"gem_objects", drm_gem_object_info}, #if DRM_DEBUG_CODE @@ -432,105 +429,6 @@ static int drm_bufs_info(char *buf, char **start, off_t offset, int request, } /** - * Called when "/proc/dri/.../objects" is read. - * - * \param buf output buffer. - * \param start start of output data. - * \param offset requested start offset. - * \param request requested number of bytes. - * \param eof whether there is no more data to return. - * \param data private data. - * \return number of written bytes. - */ -static int drm__objects_info(char *buf, char **start, off_t offset, int request, - int *eof, void *data) -{ - struct drm_minor *minor = (struct drm_minor *) data; - struct drm_device *dev = minor->dev; - int len = 0; - struct drm_buffer_manager *bm = &dev->bm; - struct drm_fence_manager *fm = &dev->fm; - uint64_t used_mem; - uint64_t used_emer; - uint64_t low_mem; - uint64_t high_mem; - uint64_t emer_mem; - - if (offset > DRM_PROC_LIMIT) { - *eof = 1; - return 0; - } - - *start = &buf[offset]; - *eof = 0; - - DRM_PROC_PRINT("Object accounting:\n\n"); - if (fm->initialized) { - DRM_PROC_PRINT("Number of active fence objects: %d.\n", - atomic_read(&fm->count)); - } else { - DRM_PROC_PRINT("Fence objects are not supported by this driver\n"); - } - - if (bm->initialized) { - DRM_PROC_PRINT("Number of active buffer objects: %d.\n\n", - atomic_read(&bm->count)); - } - DRM_PROC_PRINT("Memory accounting:\n\n"); - if (bm->initialized) { - DRM_PROC_PRINT("Number of locked GATT pages: %lu.\n", bm->cur_pages); - } else { - DRM_PROC_PRINT("Buffer objects are not supported by this driver.\n"); - } - - drm_query_memctl(&used_mem, &used_emer, &low_mem, &high_mem, &emer_mem); - - if (used_mem > 16*PAGE_SIZE) { - DRM_PROC_PRINT("Used object memory is %lu pages.\n", - (unsigned long) (used_mem >> PAGE_SHIFT)); - } else { - DRM_PROC_PRINT("Used object memory is %lu bytes.\n", - (unsigned long) used_mem); - } - if (used_emer > 16*PAGE_SIZE) { - DRM_PROC_PRINT("Used emergency memory is %lu pages.\n", - (unsigned long) (used_emer >> PAGE_SHIFT)); - } else { - DRM_PROC_PRINT("Used emergency memory is %lu bytes.\n\n", - (unsigned long) used_emer); - } - DRM_PROC_PRINT("Soft object memory usage threshold is %lu pages.\n", - (unsigned long) (low_mem >> PAGE_SHIFT)); - DRM_PROC_PRINT("Hard object memory usage threshold is %lu pages.\n", - (unsigned long) (high_mem >> PAGE_SHIFT)); - DRM_PROC_PRINT("Emergency root only memory usage threshold is %lu pages.\n", - (unsigned long) (emer_mem >> PAGE_SHIFT)); - - DRM_PROC_PRINT("\n"); - - if (len > request + offset) - return request; - *eof = 1; - return len - offset; -} - -/** - * Simply calls _objects_info() while holding the drm_device::struct_mutex lock. - */ -static int drm_objects_info(char *buf, char **start, off_t offset, int request, - int *eof, void *data) -{ - struct drm_minor *minor = (struct drm_minor *) data; - struct drm_device *dev = minor->dev; - int ret; - - mutex_lock(&dev->struct_mutex); - ret = drm__objects_info(buf, start, offset, request, eof, data); - mutex_unlock(&dev->struct_mutex); - return ret; -} - -/** * Called when "/proc/dri/.../clients" is read. * * \param buf output buffer. diff --git a/linux-core/drm_stub.c b/linux-core/drm_stub.c index 1518bc6d..6e68f677 100644 --- a/linux-core/drm_stub.c +++ b/linux-core/drm_stub.c @@ -98,7 +98,6 @@ static int drm_fill_in_dev(struct drm_device * dev, struct pci_dev *pdev, init_timer(&dev->timer); mutex_init(&dev->struct_mutex); mutex_init(&dev->ctxlist_mutex); - mutex_init(&dev->bm.evict_mutex); idr_init(&dev->drw_idr); @@ -115,17 +114,6 @@ static int drm_fill_in_dev(struct drm_device * dev, struct pci_dev *pdev, if (drm_ht_create(&dev->map_hash, DRM_MAP_HASH_ORDER)) { return -ENOMEM; } - if (drm_mm_init(&dev->offset_manager, DRM_FILE_PAGE_OFFSET_START, - DRM_FILE_PAGE_OFFSET_SIZE)) { - drm_ht_remove(&dev->map_hash); - return -ENOMEM; - } - - if (drm_ht_create(&dev->object_hash, DRM_OBJECT_HASH_ORDER)) { - drm_ht_remove(&dev->map_hash); - drm_mm_takedown(&dev->offset_manager); - return -ENOMEM; - } /* the DRM has 6 counters */ dev->counters = 6; @@ -171,8 +159,6 @@ static int drm_fill_in_dev(struct drm_device * dev, struct pci_dev *pdev, } } - drm_fence_manager_init(dev); - return 0; error_out_unreg: diff --git a/linux-core/drm_ttm.c b/linux-core/drm_ttm.c deleted file mode 100644 index cb3e7505..00000000 --- a/linux-core/drm_ttm.c +++ /dev/null @@ -1,512 +0,0 @@ -/************************************************************************** - * - * Copyright (c) 2006-2007 Tungsten Graphics, Inc., Cedar Park, TX., USA - * All Rights Reserved. - * - * Permission is hereby granted, free of charge, to any person obtaining a - * copy of this software and associated documentation files (the - * "Software"), to deal in the Software without restriction, including - * without limitation the rights to use, copy, modify, merge, publish, - * distribute, sub license, and/or sell copies of the Software, and to - * permit persons to whom the Software is furnished to do so, subject to - * the following conditions: - * - * The above copyright notice and this permission notice (including the - * next paragraph) shall be included in all copies or substantial portions - * of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL - * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, - * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR - * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE - * USE OR OTHER DEALINGS IN THE SOFTWARE. - * - **************************************************************************/ -/* - * Authors: Thomas Hellström <thomas-at-tungstengraphics-dot-com> - */ - -#include "drmP.h" - -#if defined( CONFIG_X86 ) && (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24)) -static void drm_clflush_page(struct page *page) -{ - uint8_t *page_virtual; - unsigned int i; - - if (unlikely(page == NULL)) - return; - - page_virtual = kmap_atomic(page, KM_USER0); - - for (i=0; i < PAGE_SIZE; i += boot_cpu_data.x86_clflush_size) - clflush(page_virtual + i); - - kunmap_atomic(page_virtual, KM_USER0); -} - -static void drm_ttm_cache_flush_clflush(struct page *pages[], unsigned long num_pages) -{ - unsigned long i; - - mb(); - for (i=0; i < num_pages; ++i) - drm_clflush_page(*pages++); - mb(); -} -#endif - -static void drm_ttm_ipi_handler(void *null) -{ - flush_agp_cache(); -} - -void drm_ttm_cache_flush(struct page *pages[], unsigned long num_pages) -{ - -#if defined( CONFIG_X86 ) && (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24)) - if (cpu_has_clflush) { - drm_ttm_cache_flush_clflush(pages, num_pages); - return; - } -#endif -#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27)) - if (on_each_cpu(drm_ttm_ipi_handler, NULL, 1)) -#else - if (on_each_cpu(drm_ttm_ipi_handler, NULL, 1, 1) != 0) -#endif - DRM_ERROR("Timed out waiting for drm cache flush.\n"); -} -EXPORT_SYMBOL(drm_ttm_cache_flush); - -/** - * Allocates storage for pointers to the pages that back the ttm. - * - * Uses kmalloc if possible. Otherwise falls back to vmalloc. - */ -static void drm_ttm_alloc_page_directory(struct drm_ttm *ttm) -{ - unsigned long size = ttm->num_pages * sizeof(*ttm->pages); - ttm->pages = NULL; - - if (drm_alloc_memctl(size)) - return; - - if (size <= PAGE_SIZE) - ttm->pages = drm_calloc(1, size, DRM_MEM_TTM); - - if (!ttm->pages) { - ttm->pages = vmalloc_user(size); - if (ttm->pages) - ttm->page_flags |= DRM_TTM_PAGEDIR_VMALLOC; - } - if (!ttm->pages) - drm_free_memctl(size); -} - -static void drm_ttm_free_page_directory(struct drm_ttm *ttm) -{ - unsigned long size = ttm->num_pages * sizeof(*ttm->pages); - - if (ttm->page_flags & DRM_TTM_PAGEDIR_VMALLOC) { - vfree(ttm->pages); - ttm->page_flags &= ~DRM_TTM_PAGEDIR_VMALLOC; - } else { - drm_free(ttm->pages, size, DRM_MEM_TTM); - } - drm_free_memctl(size); - ttm->pages = NULL; -} - -static struct page *drm_ttm_alloc_page(void) -{ - struct page *page; - - if (drm_alloc_memctl(PAGE_SIZE)) - return NULL; - - page = alloc_page(GFP_KERNEL | __GFP_ZERO | GFP_DMA32); - if (!page) { - drm_free_memctl(PAGE_SIZE); - return NULL; - } - return page; -} - -/* - * Change caching policy for the linear kernel map - * for range of pages in a ttm. - */ - -static int drm_ttm_set_caching(struct drm_ttm *ttm, int noncached) -{ - int i; - struct page **cur_page; - int do_tlbflush = 0; - - if ((ttm->page_flags & DRM_TTM_PAGE_UNCACHED) == noncached) - return 0; - - if (noncached) - drm_ttm_cache_flush(ttm->pages, ttm->num_pages); - - for (i = 0; i < ttm->num_pages; ++i) { - cur_page = ttm->pages + i; - if (*cur_page) { - if (!PageHighMem(*cur_page)) { - if (noncached) { - map_page_into_agp(*cur_page); - } else { - unmap_page_from_agp(*cur_page); - } - do_tlbflush = 1; - } - } - } - if (do_tlbflush) - flush_agp_mappings(); - - DRM_FLAG_MASKED(ttm->page_flags, noncached, DRM_TTM_PAGE_UNCACHED); - - return 0; -} - - -static void drm_ttm_free_user_pages(struct drm_ttm *ttm) -{ - int write; - int dirty; - struct page *page; - int i; - - BUG_ON(!(ttm->page_flags & DRM_TTM_PAGE_USER)); - write = ((ttm->page_flags & DRM_TTM_PAGE_WRITE) != 0); - dirty = ((ttm->page_flags & DRM_TTM_PAGE_USER_DIRTY) != 0); - - for (i = 0; i < ttm->num_pages; ++i) { - page = ttm->pages[i]; - if (page == NULL) - continue; - - if (page == ttm->dummy_read_page) { - BUG_ON(write); - continue; - } - - if (write && dirty && !PageReserved(page)) - set_page_dirty_lock(page); - - ttm->pages[i] = NULL; - put_page(page); - } -} - -static void drm_ttm_free_alloced_pages(struct drm_ttm *ttm) -{ - int i; - struct drm_buffer_manager *bm = &ttm->dev->bm; - struct page **cur_page; - - for (i = 0; i < ttm->num_pages; ++i) { - cur_page = ttm->pages + i; - if (*cur_page) { - if (page_count(*cur_page) != 1) - DRM_ERROR("Erroneous page count. Leaking pages.\n"); - if (page_mapped(*cur_page)) - DRM_ERROR("Erroneous map count. Leaking page mappings.\n"); - __free_page(*cur_page); - drm_free_memctl(PAGE_SIZE); - --bm->cur_pages; - } - } -} - -/* - * Free all resources associated with a ttm. - */ - -int drm_ttm_destroy(struct drm_ttm *ttm) -{ - struct drm_ttm_backend *be; - - if (!ttm) - return 0; - - be = ttm->be; - if (be) { - be->func->destroy(be); - ttm->be = NULL; - } - - if (ttm->pages) { - if (ttm->page_flags & DRM_TTM_PAGE_UNCACHED) - drm_ttm_set_caching(ttm, 0); - - if (ttm->page_flags & DRM_TTM_PAGE_USER) - drm_ttm_free_user_pages(ttm); - else - drm_ttm_free_alloced_pages(ttm); - - drm_ttm_free_page_directory(ttm); - } - - drm_ctl_free(ttm, sizeof(*ttm), DRM_MEM_TTM); - return 0; -} - -struct page *drm_ttm_get_page(struct drm_ttm *ttm, int index) -{ - struct page *p; - struct drm_buffer_manager *bm = &ttm->dev->bm; - - while(NULL == (p = ttm->pages[index])) { - p = drm_ttm_alloc_page(); - if (!p) - return NULL; - - if (PageHighMem(p)) - ttm->pages[--ttm->first_himem_page] = p; - else - ttm->pages[++ttm->last_lomem_page] = p; - - ++bm->cur_pages; - } - return p; -} -EXPORT_SYMBOL(drm_ttm_get_page); - -/** - * drm_ttm_set_user: - * - * @ttm: the ttm to map pages to. This must always be - * a freshly created ttm. - * - * @tsk: a pointer to the address space from which to map - * pages. - * - * @write: a boolean indicating that write access is desired - * - * start: the starting address - * - * Map a range of user addresses to a new ttm object. This - * provides access to user memory from the graphics device. - */ -int drm_ttm_set_user(struct drm_ttm *ttm, - struct task_struct *tsk, - unsigned long start, - unsigned long num_pages) -{ - struct mm_struct *mm = tsk->mm; - int ret; - int write = (ttm->page_flags & DRM_TTM_PAGE_WRITE) != 0; - - BUG_ON(num_pages != ttm->num_pages); - BUG_ON((ttm->page_flags & DRM_TTM_PAGE_USER) == 0); - - down_read(&mm->mmap_sem); - ret = get_user_pages(tsk, mm, start, num_pages, - write, 0, ttm->pages, NULL); - up_read(&mm->mmap_sem); - - if (ret != num_pages && write) { - drm_ttm_free_user_pages(ttm); - return -ENOMEM; - } - - return 0; -} - -/** - * drm_ttm_populate: - * - * @ttm: the object to allocate pages for - * - * Allocate pages for all unset page entries, then - * call the backend to create the hardware mappings - */ -int drm_ttm_populate(struct drm_ttm *ttm) -{ - struct page *page; - unsigned long i; - struct drm_ttm_backend *be; - - if (ttm->state != ttm_unpopulated) - return 0; - - be = ttm->be; - - for (i = 0; i < ttm->num_pages; ++i) { - page = drm_ttm_get_page(ttm, i); - if (!page) - return -ENOMEM; - } - - be->func->populate(be, ttm->num_pages, ttm->pages, ttm->dummy_read_page); - ttm->state = ttm_unbound; - return 0; -} - -/** - * drm_ttm_create: - * - * @dev: the drm_device - * - * @size: The size (in bytes) of the desired object - * - * @page_flags: various DRM_TTM_PAGE_* flags. See drm_object.h. - * - * Allocate and initialize a ttm, leaving it unpopulated at this time - */ - -struct drm_ttm *drm_ttm_create(struct drm_device *dev, unsigned long size, - uint32_t page_flags, struct page *dummy_read_page) -{ - struct drm_bo_driver *bo_driver = dev->driver->bo_driver; - struct drm_ttm *ttm; - - if (!bo_driver) - return NULL; - - ttm = drm_ctl_calloc(1, sizeof(*ttm), DRM_MEM_TTM); - if (!ttm) - return NULL; - - ttm->dev = dev; - atomic_set(&ttm->vma_count, 0); - - ttm->destroy = 0; - ttm->num_pages = (size + PAGE_SIZE - 1) >> PAGE_SHIFT; - ttm->first_himem_page = ttm->num_pages; - ttm->last_lomem_page = -1; - - ttm->page_flags = page_flags; - - ttm->dummy_read_page = dummy_read_page; - - /* - * Account also for AGP module memory usage. - */ - - drm_ttm_alloc_page_directory(ttm); - if (!ttm->pages) { - drm_ttm_destroy(ttm); - DRM_ERROR("Failed allocating page table\n"); - return NULL; - } - ttm->be = bo_driver->create_ttm_backend_entry(dev); - if (!ttm->be) { - drm_ttm_destroy(ttm); - DRM_ERROR("Failed creating ttm backend entry\n"); - return NULL; - } - ttm->state = ttm_unpopulated; - return ttm; -} - -/** - * drm_ttm_evict: - * - * @ttm: the object to be unbound from the aperture. - * - * Transition a ttm from bound to evicted, where it - * isn't present in the aperture, but various caches may - * not be consistent. - */ -void drm_ttm_evict(struct drm_ttm *ttm) -{ - struct drm_ttm_backend *be = ttm->be; - int ret; - - if (ttm->state == ttm_bound) { - ret = be->func->unbind(be); - BUG_ON(ret); - } - - ttm->state = ttm_evicted; -} - -/** - * drm_ttm_fixup_caching: - * - * @ttm: the object to set unbound - * - * XXX this function is misnamed. Transition a ttm from evicted to - * unbound, flushing caches as appropriate. - */ -void drm_ttm_fixup_caching(struct drm_ttm *ttm) -{ - - if (ttm->state == ttm_evicted) { - struct drm_ttm_backend *be = ttm->be; - if (be->func->needs_ub_cache_adjust(be)) - drm_ttm_set_caching(ttm, 0); - ttm->state = ttm_unbound; - } -} - -/** - * drm_ttm_unbind: - * - * @ttm: the object to unbind from the graphics device - * - * Unbind an object from the aperture. This removes the mappings - * from the graphics device and flushes caches if necessary. - */ -void drm_ttm_unbind(struct drm_ttm *ttm) -{ - if (ttm->state == ttm_bound) - drm_ttm_evict(ttm); - - drm_ttm_fixup_caching(ttm); -} - -/** - * drm_ttm_bind: - * - * @ttm: the ttm object to bind to the graphics device - * - * @bo_mem: the aperture memory region which will hold the object - * - * Bind a ttm object to the aperture. This ensures that the necessary - * pages are allocated, flushes CPU caches as needed and marks the - * ttm as DRM_TTM_PAGE_USER_DIRTY to indicate that it may have been - * modified by the GPU - */ -int drm_ttm_bind(struct drm_ttm *ttm, struct drm_bo_mem_reg *bo_mem) -{ - struct drm_bo_driver *bo_driver = ttm->dev->driver->bo_driver; - int ret = 0; - struct drm_ttm_backend *be; - - if (!ttm) - return -EINVAL; - if (ttm->state == ttm_bound) - return 0; - - be = ttm->be; - - ret = drm_ttm_populate(ttm); - if (ret) - return ret; - - if (ttm->state == ttm_unbound && !(bo_mem->flags & DRM_BO_FLAG_CACHED)) - drm_ttm_set_caching(ttm, DRM_TTM_PAGE_UNCACHED); - else if ((bo_mem->flags & DRM_BO_FLAG_CACHED_MAPPED) && - bo_driver->ttm_cache_flush) - bo_driver->ttm_cache_flush(ttm); - - ret = be->func->bind(be, bo_mem); - if (ret) { - ttm->state = ttm_evicted; - DRM_ERROR("Couldn't bind backend.\n"); - return ret; - } - - ttm->state = ttm_bound; - if (ttm->page_flags & DRM_TTM_PAGE_USER) - ttm->page_flags |= DRM_TTM_PAGE_USER_DIRTY; - return 0; -} -EXPORT_SYMBOL(drm_ttm_bind); diff --git a/linux-core/drm_vm.c b/linux-core/drm_vm.c index b99c86d1..c6cee1a1 100644 --- a/linux-core/drm_vm.c +++ b/linux-core/drm_vm.c @@ -41,10 +41,6 @@ static void drm_vm_open(struct vm_area_struct *vma); static void drm_vm_close(struct vm_area_struct *vma); -static int drm_bo_mmap_locked(struct vm_area_struct *vma, - struct file *filp, - drm_local_map_t *map); - pgprot_t drm_io_prot(uint32_t map_type, struct vm_area_struct *vma) { @@ -651,8 +647,6 @@ static int drm_mmap_locked(struct file *filp, struct vm_area_struct *vma) vma->vm_flags |= VM_RESERVED; vma->vm_page_prot = drm_dma_prot(map->type, vma); break; - case _DRM_TTM: - return drm_bo_mmap_locked(vma, filp, map); default: return -EINVAL; /* This should never happen. */ } @@ -676,195 +670,3 @@ int drm_mmap(struct file *filp, struct vm_area_struct *vma) return ret; } EXPORT_SYMBOL(drm_mmap); - -/** - * buffer object vm functions. - */ - -/** - * \c Pagefault method for buffer objects. - * - * \param vma Virtual memory area. - * \param vmf vm fault data - * \return Error or VM_FAULT_NOPAGE:. The pfn is manually inserted. - * - * It's important that pfns are inserted while holding the bo->mutex lock. - * otherwise we might race with unmap_mapping_range() which is always - * called with the bo->mutex lock held. - * - * We're modifying the page attribute bits of the vma->vm_page_prot field, - * without holding the mmap_sem in write mode. Only in read mode. - * These bits are not used by the mm subsystem code, and we consider them - * protected by the bo->mutex lock. - */ - -#if !defined(DRM_NO_FAULT) -static int drm_bo_vm_fault(struct vm_area_struct *vma, - struct vm_fault *vmf) -{ - struct drm_buffer_object *bo = (struct drm_buffer_object *) vma->vm_private_data; - unsigned long page_offset; - struct page *page = NULL; - struct drm_ttm *ttm; - struct drm_device *dev; - unsigned long pfn; - int err; - unsigned long bus_base; - unsigned long bus_offset; - unsigned long bus_size; - unsigned long ret = VM_FAULT_NOPAGE; - - dev = bo->dev; - err = drm_bo_read_lock(&dev->bm.bm_lock, 1); - if (err) - return VM_FAULT_NOPAGE; - - err = mutex_lock_interruptible(&bo->mutex); - if (err) { - drm_bo_read_unlock(&dev->bm.bm_lock); - return VM_FAULT_NOPAGE; - } - - err = drm_bo_wait(bo, 0, 1, 0, 1); - if (err) { - ret = (err != -EAGAIN) ? VM_FAULT_SIGBUS : VM_FAULT_NOPAGE; - bo->priv_flags &= ~_DRM_BO_FLAG_UNLOCKED; - goto out_unlock; - } - - bo->priv_flags &= ~_DRM_BO_FLAG_UNLOCKED; - - /* - * If buffer happens to be in a non-mappable location, - * move it to a mappable. - */ - - if (!(bo->mem.flags & DRM_BO_FLAG_MAPPABLE)) { - uint32_t new_flags = bo->mem.proposed_flags | - DRM_BO_FLAG_MAPPABLE | - DRM_BO_FLAG_FORCE_MAPPABLE; - err = drm_bo_move_buffer(bo, new_flags, 0, 0); - if (err) { - ret = (err != -EAGAIN) ? VM_FAULT_SIGBUS : VM_FAULT_NOPAGE; - goto out_unlock; - } - } - - err = drm_bo_pci_offset(dev, &bo->mem, &bus_base, &bus_offset, - &bus_size); - - if (err) { - ret = VM_FAULT_SIGBUS; - goto out_unlock; - } - - page_offset = ((unsigned long)vmf->virtual_address - vma->vm_start) >> PAGE_SHIFT; - - if (bus_size) { - struct drm_mem_type_manager *man = &dev->bm.man[bo->mem.mem_type]; - - pfn = ((bus_base + bus_offset) >> PAGE_SHIFT) + page_offset; - vma->vm_page_prot = drm_io_prot(man->drm_bus_maptype, vma); - } else { - ttm = bo->ttm; - - drm_ttm_fixup_caching(ttm); - page = drm_ttm_get_page(ttm, page_offset); - if (!page) { - ret = VM_FAULT_OOM; - goto out_unlock; - } - pfn = page_to_pfn(page); - vma->vm_page_prot = (bo->mem.flags & DRM_BO_FLAG_CACHED) ? - vm_get_page_prot(vma->vm_flags) : - drm_io_prot(_DRM_TTM, vma); - } - - err = vm_insert_pfn(vma, (unsigned long)vmf->virtual_address, pfn); - if (err) { - ret = (err != -EAGAIN) ? VM_FAULT_OOM : VM_FAULT_NOPAGE; - goto out_unlock; - } -out_unlock: - BUG_ON(bo->priv_flags & _DRM_BO_FLAG_UNLOCKED); - mutex_unlock(&bo->mutex); - drm_bo_read_unlock(&dev->bm.bm_lock); - return ret; -} -#endif - -static void drm_bo_vm_open_locked(struct vm_area_struct *vma) -{ - struct drm_buffer_object *bo = (struct drm_buffer_object *) vma->vm_private_data; - - drm_vm_open_locked(vma); - atomic_inc(&bo->usage); -} - -/** - * \c vma open method for buffer objects. - * - * \param vma virtual memory area. - */ - -static void drm_bo_vm_open(struct vm_area_struct *vma) -{ - struct drm_buffer_object *bo = (struct drm_buffer_object *) vma->vm_private_data; - struct drm_device *dev = bo->dev; - - mutex_lock(&dev->struct_mutex); - drm_bo_vm_open_locked(vma); - mutex_unlock(&dev->struct_mutex); -} - -/** - * \c vma close method for buffer objects. - * - * \param vma virtual memory area. - */ - -static void drm_bo_vm_close(struct vm_area_struct *vma) -{ - struct drm_buffer_object *bo = (struct drm_buffer_object *) vma->vm_private_data; - struct drm_device *dev = bo->dev; - - drm_vm_close(vma); - if (bo) { - mutex_lock(&dev->struct_mutex); - drm_bo_usage_deref_locked((struct drm_buffer_object **) - &vma->vm_private_data); - mutex_unlock(&dev->struct_mutex); - } - return; -} - -static struct vm_operations_struct drm_bo_vm_ops = { -#ifdef DRM_NO_FAULT - .nopfn = drm_bo_vm_nopfn, -#else - .fault = drm_bo_vm_fault, -#endif - .open = drm_bo_vm_open, - .close = drm_bo_vm_close, -}; - -/** - * mmap buffer object memory. - * - * \param vma virtual memory area. - * \param file_priv DRM file private. - * \param map The buffer object drm map. - * \return zero on success or a negative number on failure. - */ -static int drm_bo_mmap_locked(struct vm_area_struct *vma, - struct file *filp, - drm_local_map_t *map) -{ - vma->vm_ops = &drm_bo_vm_ops; - vma->vm_private_data = map->handle; - vma->vm_file = filp; - vma->vm_flags |= VM_RESERVED | VM_IO; - vma->vm_flags |= VM_PFNMAP; - drm_bo_vm_open_locked(vma); - return 0; -} diff --git a/linux-core/via_buffer.c b/linux-core/via_buffer.c deleted file mode 100644 index 532fae6a..00000000 --- a/linux-core/via_buffer.c +++ /dev/null @@ -1,163 +0,0 @@ -/************************************************************************** - * - * Copyright (c) 2007 Tungsten Graphics, Inc., Cedar Park, TX., USA, - * All Rights Reserved. - * - * Permission is hereby granted, free of charge, to any person obtaining a - * copy of this software and associated documentation files (the - * "Software"), to deal in the Software without restriction, including - * without limitation the rights to use, copy, modify, merge, publish, - * distribute, sub license, and/or sell copies of the Software, and to - * permit persons to whom the Software is furnished to do so, subject to - * the following conditions: - * - * The above copyright notice and this permission notice (including the - * next paragraph) shall be included in all copies or substantial portions - * of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL - * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, - * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR - * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE - * USE OR OTHER DEALINGS IN THE SOFTWARE. - * - **************************************************************************/ -/* - * Authors: Thomas Hellström <thomas-at-tungstengraphics-dot-com> - */ - -#include "drmP.h" -#include "via_drm.h" -#include "via_drv.h" - -struct drm_ttm_backend *via_create_ttm_backend_entry(struct drm_device * dev) -{ - return drm_agp_init_ttm(dev); -} - -int via_fence_types(struct drm_buffer_object *bo, uint32_t * fclass, - uint32_t * type) -{ - *type = 3; - return 0; -} - -int via_invalidate_caches(struct drm_device * dev, uint64_t flags) -{ - /* - * FIXME: Invalidate texture caches here. - */ - - return 0; -} - - -static int via_vram_info(struct drm_device *dev, - unsigned long *offset, - unsigned long *size) -{ - struct pci_dev *pdev = dev->pdev; - unsigned long flags; - - int ret = -EINVAL; - int i; - for (i=0; i<6; ++i) { - flags = pci_resource_flags(pdev, i); - if ((flags & (IORESOURCE_MEM | IORESOURCE_PREFETCH)) == - (IORESOURCE_MEM | IORESOURCE_PREFETCH)) { - ret = 0; - break; - } - } - - if (ret) { - DRM_ERROR("Could not find VRAM PCI resource\n"); - return ret; - } - - *offset = pci_resource_start(pdev, i); - *size = pci_resource_end(pdev, i) - *offset + 1; - return 0; -} - -int via_init_mem_type(struct drm_device * dev, uint32_t type, - struct drm_mem_type_manager * man) -{ - switch (type) { - case DRM_BO_MEM_LOCAL: - /* System memory */ - - man->flags = _DRM_FLAG_MEMTYPE_MAPPABLE | - _DRM_FLAG_MEMTYPE_CACHED; - man->drm_bus_maptype = 0; - break; - - case DRM_BO_MEM_TT: - /* Dynamic agpgart memory */ - - if (!(drm_core_has_AGP(dev) && dev->agp)) { - DRM_ERROR("AGP is not enabled for memory type %u\n", - (unsigned)type); - return -EINVAL; - } - man->io_offset = dev->agp->agp_info.aper_base; - man->io_size = dev->agp->agp_info.aper_size * 1024 * 1024; - man->io_addr = NULL; - man->flags = _DRM_FLAG_MEMTYPE_MAPPABLE | _DRM_FLAG_NEEDS_IOREMAP; - - /* Only to get pte protection right. */ - - man->drm_bus_maptype = _DRM_AGP; - break; - - case DRM_BO_MEM_VRAM: - /* "On-card" video ram */ - - man->flags = _DRM_FLAG_MEMTYPE_MAPPABLE | _DRM_FLAG_NEEDS_IOREMAP; - man->drm_bus_maptype = _DRM_FRAME_BUFFER; - man->io_addr = NULL; - return via_vram_info(dev, &man->io_offset, &man->io_size); - break; - - case DRM_BO_MEM_PRIV0: - /* Pre-bound agpgart memory */ - - if (!(drm_core_has_AGP(dev) && dev->agp)) { - DRM_ERROR("AGP is not enabled for memory type %u\n", - (unsigned)type); - return -EINVAL; - } - man->io_offset = dev->agp->agp_info.aper_base; - man->io_size = dev->agp->agp_info.aper_size * 1024 * 1024; - man->io_addr = NULL; - man->flags = _DRM_FLAG_MEMTYPE_MAPPABLE | - _DRM_FLAG_MEMTYPE_FIXED | _DRM_FLAG_NEEDS_IOREMAP; - man->drm_bus_maptype = _DRM_AGP; - break; - - default: - DRM_ERROR("Unsupported memory type %u\n", (unsigned)type); - return -EINVAL; - } - return 0; -} - -uint64_t via_evict_flags(struct drm_buffer_object *bo) -{ - switch (bo->mem.mem_type) { - case DRM_BO_MEM_LOCAL: - case DRM_BO_MEM_TT: - return DRM_BO_FLAG_MEM_LOCAL; /* Evict TT to local */ - case DRM_BO_MEM_PRIV0: /* Evict pre-bound AGP to TT */ - return DRM_BO_MEM_TT; - case DRM_BO_MEM_VRAM: - if (bo->mem.num_pages > 128) - return DRM_BO_MEM_TT; - else - return DRM_BO_MEM_LOCAL; - default: - return DRM_BO_MEM_LOCAL; - } -} diff --git a/linux-core/via_fence.c b/linux-core/via_fence.c deleted file mode 100644 index 3a680a32..00000000 --- a/linux-core/via_fence.c +++ /dev/null @@ -1,169 +0,0 @@ -/************************************************************************** - * - * Copyright (c) 2007 Tungsten Graphics, Inc., Cedar Park, TX., USA, - * All Rights Reserved. - * - * Permission is hereby granted, free of charge, to any person obtaining a - * copy of this software and associated documentation files (the - * "Software"), to deal in the Software without restriction, including - * without limitation the rights to use, copy, modify, merge, publish, - * distribute, sub license, and/or sell copies of the Software, and to - * permit persons to whom the Software is furnished to do so, subject to - * the following conditions: - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL - * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, - * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR - * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE - * USE OR OTHER DEALINGS IN THE SOFTWARE. - * - * The above copyright notice and this permission notice (including the - * next paragraph) shall be included in all copies or substantial portions - * of the Software. - * - * - **************************************************************************/ -/* - * Authors: Thomas Hellström <thomas-at-tungstengraphics-dot-com> - */ - -#include "drmP.h" -#include "via_drm.h" -#include "via_drv.h" - -/* - * DRM_FENCE_TYPE_EXE guarantees that all command buffers can be evicted. - * DRM_VIA_FENCE_TYPE_ACCEL guarantees that all 2D & 3D rendering is complete. - */ - -static void via_fence_poll(struct drm_device *dev, uint32_t class, - uint32_t waiting_types) -{ - drm_via_private_t *dev_priv = (drm_via_private_t *) dev->dev_private; - uint32_t signaled_flush_types = 0; - uint32_t status; - - if (class != 0) - return; - - if (unlikely(!dev_priv)) - return; - - spin_lock(&dev_priv->fence_lock); - if (waiting_types) { - - /* - * Take the idlelock. This guarantees that the next time a client tries - * to grab the lock, it will stall until the idlelock is released. This - * guarantees that eventually, the GPU engines will be idle, but nothing - * else. It cannot be used to protect the hardware. - */ - - - if (!dev_priv->have_idlelock) { - drm_idlelock_take(&dev->lock); - dev_priv->have_idlelock = 1; - } - - /* - * Check if AGP command reader is idle. - */ - - if (waiting_types & DRM_FENCE_TYPE_EXE) - if (VIA_READ(0x41C) & 0x80000000) - signaled_flush_types |= DRM_FENCE_TYPE_EXE; - - /* - * Check VRAM command queue empty and 2D + 3D engines idle. - */ - - if (waiting_types & DRM_VIA_FENCE_TYPE_ACCEL) { - status = VIA_READ(VIA_REG_STATUS); - if ((status & VIA_VR_QUEUE_BUSY) && - !(status & (VIA_CMD_RGTR_BUSY | VIA_2D_ENG_BUSY | VIA_3D_ENG_BUSY))) - signaled_flush_types |= DRM_VIA_FENCE_TYPE_ACCEL; - } - - if (signaled_flush_types) { - waiting_types &= ~signaled_flush_types; - if (!waiting_types && dev_priv->have_idlelock) { - drm_idlelock_release(&dev->lock); - dev_priv->have_idlelock = 0; - } - drm_fence_handler(dev, 0, dev_priv->emit_0_sequence, - signaled_flush_types, 0); - } - } - - spin_unlock(&dev_priv->fence_lock); - - return; -} - - -/** - * Emit a fence sequence. - */ - -static int via_fence_emit_sequence(struct drm_device * dev, uint32_t class, uint32_t flags, - uint32_t * sequence, uint32_t * native_type) -{ - drm_via_private_t *dev_priv = (drm_via_private_t *) dev->dev_private; - int ret = 0; - - if (!dev_priv) - return -EINVAL; - - switch(class) { - case 0: /* AGP command stream */ - - /* - * The sequence number isn't really used by the hardware yet. - */ - - spin_lock(&dev_priv->fence_lock); - *sequence = ++dev_priv->emit_0_sequence; - spin_unlock(&dev_priv->fence_lock); - - /* - * When drm_fence_handler() is called with flush type 0x01, and a - * sequence number, That means that the EXE flag is expired. - * Nothing else. No implicit flushing or other engines idle. - */ - - *native_type = DRM_FENCE_TYPE_EXE; - break; - default: - ret = -EINVAL; - break; - } - return ret; -} - -/** - * No irq fence expirations implemented yet. - * Although both the HQV engines and PCI dmablit engines signal - * idle with an IRQ, we haven't implemented this yet. - * This means that the drm fence manager will always poll for engine idle, - * unless the caller wanting to wait for a fence object has indicated a lazy wait. - */ - -static int via_fence_has_irq(struct drm_device * dev, uint32_t class, - uint32_t flags) -{ - return 0; -} - -struct drm_fence_driver via_fence_driver = { - .num_classes = 1, - .wrap_diff = (1 << 30), - .flush_diff = (1 << 20), - .sequence_mask = 0xffffffffU, - .has_irq = via_fence_has_irq, - .emit = via_fence_emit_sequence, - .poll = via_fence_poll, - .needed_flush = NULL, - .wait = NULL -}; diff --git a/linux-core/xgi_cmdlist.c b/linux-core/xgi_cmdlist.c index 423208b0..dea9b518 100644 --- a/linux-core/xgi_cmdlist.c +++ b/linux-core/xgi_cmdlist.c @@ -148,9 +148,6 @@ int xgi_submit_cmdlist(struct drm_device * dev, void * data, } info->cmdring.last_ptr = xgi_find_pcie_virt(info, pCmdInfo->hw_addr); -#ifdef XGI_HAVE_FENCE - drm_fence_flush_old(info->dev, 0, info->next_sequence); -#endif /* XGI_HAVE_FENCE */ return 0; } diff --git a/linux-core/xgi_drv.c b/linux-core/xgi_drv.c index 51ace0ff..4d55f219 100644 --- a/linux-core/xgi_drv.c +++ b/linux-core/xgi_drv.c @@ -37,10 +37,6 @@ static struct pci_device_id pciidlist[] = { xgi_PCI_IDS }; -#ifdef XGI_HAVE_FENCE -extern struct drm_fence_driver xgi_fence_driver; -#endif /* XGI_HAVE_FENCE */ - int xgi_bootstrap(struct drm_device *, void *, struct drm_file *); static struct drm_ioctl_desc xgi_ioctls[] = { @@ -105,10 +101,6 @@ static struct drm_driver driver = { .remove = __devexit_p(drm_cleanup_pci), }, -#ifdef XGI_HAVE_FENCE - .fence_driver = &xgi_fence_driver, -#endif /* XGI_HAVE_FENCE */ - .name = DRIVER_NAME, .desc = DRIVER_DESC, .date = DRIVER_DATE, @@ -362,9 +354,6 @@ irqreturn_t xgi_kern_isr(DRM_IRQ_ARGS) DRM_WRITE32(info->mmio_map, 0x2800 + M2REG_AUTO_LINK_SETTING_ADDRESS, cpu_to_le32(M2REG_AUTO_LINK_SETTING_COMMAND | irq_bits)); -#ifdef XGI_HAVE_FENCE - xgi_fence_handler(dev); -#endif /* XGI_HAVE_FENCE */ DRM_WAKEUP(&info->fence_queue); return IRQ_HANDLED; } else { diff --git a/linux-core/xgi_drv.h b/linux-core/xgi_drv.h index 5ad3ddb3..a3ca7fb4 100644 --- a/linux-core/xgi_drv.h +++ b/linux-core/xgi_drv.h @@ -99,18 +99,6 @@ extern void xgi_disable_mmio(struct xgi_info * info); extern void xgi_enable_ge(struct xgi_info * info); extern void xgi_disable_ge(struct xgi_info * info); -/* TTM-style fences. - */ -#ifdef XGI_HAVE_FENCE -extern void xgi_poke_flush(struct drm_device * dev, uint32_t class); -extern int xgi_fence_emit_sequence(struct drm_device * dev, uint32_t class, - uint32_t flags, uint32_t * sequence, uint32_t * native_type); -extern void xgi_fence_handler(struct drm_device * dev); -extern int xgi_fence_has_irq(struct drm_device *dev, uint32_t class, - uint32_t flags); -#endif /* XGI_HAVE_FENCE */ - - /* Non-TTM-style fences. */ extern int xgi_set_fence_ioctl(struct drm_device * dev, void * data, diff --git a/linux-core/xgi_fence.c b/linux-core/xgi_fence.c index 38cf9e4f..7553177c 100644 --- a/linux-core/xgi_fence.c +++ b/linux-core/xgi_fence.c @@ -97,90 +97,3 @@ int xgi_wait_fence_ioctl(struct drm_device * dev, void * data, (void) filp; return xgi_low_level_fence_wait(dev, (u32 *) data); } - - -#ifdef XGI_HAVE_FENCE -static void xgi_fence_poll(struct drm_device * dev, uint32_t class, - uint32_t waiting_types) -{ - struct xgi_info * info = dev->dev_private; - uint32_t signaled_types = 0; - - - if ((info == NULL) || (class != 0)) - return; - - DRM_SPINLOCK(&info->fence_lock); - - if (waiting_types) { - if (waiting_types & DRM_FENCE_TYPE_EXE) { - const u32 begin_id = le32_to_cpu(DRM_READ32(info->mmio_map, - 0x2820)) - & BEGIN_BEGIN_IDENTIFICATION_MASK; - - if (begin_id != info->complete_sequence) { - info->complete_sequence = begin_id; - signaled_types |= DRM_FENCE_TYPE_EXE; - } - } - - if (signaled_types) { - drm_fence_handler(dev, 0, info->complete_sequence, - signaled_types, 0); - } - } - - DRM_SPINUNLOCK(&info->fence_lock); -} - - -int xgi_fence_emit_sequence(struct drm_device * dev, uint32_t class, - uint32_t flags, uint32_t * sequence, - uint32_t * native_type) -{ - int err; - - (void) flags; - - if (class != 0) - return -EINVAL; - - err = xgi_low_level_fence_emit(dev, sequence); - if (err) - return err; - - *native_type = DRM_FENCE_TYPE_EXE; - return 0; -} - - -void xgi_fence_handler(struct drm_device * dev) -{ - struct drm_fence_manager * fm = &dev->fm; - struct drm_fence_class_manager *fc = &fm->fence_class[0]; - - write_lock(&fm->lock); - xgi_fence_poll(dev, 0, fc->waiting_types); - write_unlock(&fm->lock); -} - - -int xgi_fence_has_irq(struct drm_device *dev, uint32_t class, uint32_t flags) -{ - return ((class == 0) && (flags == DRM_FENCE_TYPE_EXE)) ? 1 : 0; -} - -struct drm_fence_driver xgi_fence_driver = { - .num_classes = 1, - .wrap_diff = BEGIN_BEGIN_IDENTIFICATION_MASK, - .flush_diff = BEGIN_BEGIN_IDENTIFICATION_MASK - 1, - .sequence_mask = BEGIN_BEGIN_IDENTIFICATION_MASK, - .has_irq = xgi_fence_has_irq, - .emit = xgi_fence_emit_sequence, - .flush = NULL, - .poll = xgi_fence_poll, - .needed_flush = NULL, - .wait = NULL -}; - -#endif /* XGI_HAVE_FENCE */ diff --git a/shared-core/drm.h b/shared-core/drm.h index 97fab9a9..7758af41 100644 --- a/shared-core/drm.h +++ b/shared-core/drm.h @@ -648,324 +648,6 @@ struct drm_set_version { int drm_dd_minor; }; - -#define DRM_FENCE_FLAG_EMIT 0x00000001 -#define DRM_FENCE_FLAG_SHAREABLE 0x00000002 -/** - * On hardware with no interrupt events for operation completion, - * indicates that the kernel should sleep while waiting for any blocking - * operation to complete rather than spinning. - * - * Has no effect otherwise. - */ -#define DRM_FENCE_FLAG_WAIT_LAZY 0x00000004 -#define DRM_FENCE_FLAG_NO_USER 0x00000010 - -/* Reserved for driver use */ -#define DRM_FENCE_MASK_DRIVER 0xFF000000 - -#define DRM_FENCE_TYPE_EXE 0x00000001 - -struct drm_fence_arg { - unsigned int handle; - unsigned int fence_class; - unsigned int type; - unsigned int flags; - unsigned int signaled; - unsigned int error; - unsigned int sequence; - unsigned int pad64; - uint64_t expand_pad[2]; /*Future expansion */ -}; - -/* Buffer permissions, referring to how the GPU uses the buffers. - * these translate to fence types used for the buffers. - * Typically a texture buffer is read, A destination buffer is write and - * a command (batch-) buffer is exe. Can be or-ed together. - */ - -#define DRM_BO_FLAG_READ (1ULL << 0) -#define DRM_BO_FLAG_WRITE (1ULL << 1) -#define DRM_BO_FLAG_EXE (1ULL << 2) - -/* - * All of the bits related to access mode - */ -#define DRM_BO_MASK_ACCESS (DRM_BO_FLAG_READ | DRM_BO_FLAG_WRITE | DRM_BO_FLAG_EXE) -/* - * Status flags. Can be read to determine the actual state of a buffer. - * Can also be set in the buffer mask before validation. - */ - -/* - * Mask: Never evict this buffer. Not even with force. This type of buffer is only - * available to root and must be manually removed before buffer manager shutdown - * or lock. - * Flags: Acknowledge - */ -#define DRM_BO_FLAG_NO_EVICT (1ULL << 4) - -/* - * Mask: Require that the buffer is placed in mappable memory when validated. - * If not set the buffer may or may not be in mappable memory when validated. - * Flags: If set, the buffer is in mappable memory. - */ -#define DRM_BO_FLAG_MAPPABLE (1ULL << 5) - -/* Mask: The buffer should be shareable with other processes. - * Flags: The buffer is shareable with other processes. - */ -#define DRM_BO_FLAG_SHAREABLE (1ULL << 6) - -/* Mask: If set, place the buffer in cache-coherent memory if available. - * If clear, never place the buffer in cache coherent memory if validated. - * Flags: The buffer is currently in cache-coherent memory. - */ -#define DRM_BO_FLAG_CACHED (1ULL << 7) - -/* Mask: Make sure that every time this buffer is validated, - * it ends up on the same location provided that the memory mask is the same. - * The buffer will also not be evicted when claiming space for - * other buffers. Basically a pinned buffer but it may be thrown out as - * part of buffer manager shutdown or locking. - * Flags: Acknowledge. - */ -#define DRM_BO_FLAG_NO_MOVE (1ULL << 8) - -/* Mask: Make sure the buffer is in cached memory when mapped. In conjunction - * with DRM_BO_FLAG_CACHED it also allows the buffer to be bound into the GART - * with unsnooped PTEs instead of snooped, by using chipset-specific cache - * flushing at bind time. A better name might be DRM_BO_FLAG_TT_UNSNOOPED, - * as the eviction to local memory (TTM unbind) on map is just a side effect - * to prevent aggressive cache prefetch from the GPU disturbing the cache - * management that the DRM is doing. - * - * Flags: Acknowledge. - * Buffers allocated with this flag should not be used for suballocators - * This type may have issues on CPUs with over-aggressive caching - * http://marc.info/?l=linux-kernel&m=102376926732464&w=2 - */ -#define DRM_BO_FLAG_CACHED_MAPPED (1ULL << 19) - - -/* Mask: Force DRM_BO_FLAG_CACHED flag strictly also if it is set. - * Flags: Acknowledge. - */ -#define DRM_BO_FLAG_FORCE_CACHING (1ULL << 13) - -/* - * Mask: Force DRM_BO_FLAG_MAPPABLE flag strictly also if it is clear. - * Flags: Acknowledge. - */ -#define DRM_BO_FLAG_FORCE_MAPPABLE (1ULL << 14) -#define DRM_BO_FLAG_TILE (1ULL << 15) - -/* - * Memory type flags that can be or'ed together in the mask, but only - * one appears in flags. - */ - -/* System memory */ -#define DRM_BO_FLAG_MEM_LOCAL (1ULL << 24) -/* Translation table memory */ -#define DRM_BO_FLAG_MEM_TT (1ULL << 25) -/* Vram memory */ -#define DRM_BO_FLAG_MEM_VRAM (1ULL << 26) -/* Up to the driver to define. */ -#define DRM_BO_FLAG_MEM_PRIV0 (1ULL << 27) -#define DRM_BO_FLAG_MEM_PRIV1 (1ULL << 28) -#define DRM_BO_FLAG_MEM_PRIV2 (1ULL << 29) -#define DRM_BO_FLAG_MEM_PRIV3 (1ULL << 30) -#define DRM_BO_FLAG_MEM_PRIV4 (1ULL << 31) -/* We can add more of these now with a 64-bit flag type */ - -/* - * This is a mask covering all of the memory type flags; easier to just - * use a single constant than a bunch of | values. It covers - * DRM_BO_FLAG_MEM_LOCAL through DRM_BO_FLAG_MEM_PRIV4 - */ -#define DRM_BO_MASK_MEM 0x00000000FF000000ULL -/* - * This adds all of the CPU-mapping options in with the memory - * type to label all bits which change how the page gets mapped - */ -#define DRM_BO_MASK_MEMTYPE (DRM_BO_MASK_MEM | \ - DRM_BO_FLAG_CACHED_MAPPED | \ - DRM_BO_FLAG_CACHED | \ - DRM_BO_FLAG_MAPPABLE) - -/* Driver-private flags */ -#define DRM_BO_MASK_DRIVER 0xFFFF000000000000ULL - -/* - * Don't block on validate and map. Instead, return EBUSY. - */ -#define DRM_BO_HINT_DONT_BLOCK 0x00000002 -/* - * Don't place this buffer on the unfenced list. This means - * that the buffer will not end up having a fence associated - * with it as a result of this operation - */ -#define DRM_BO_HINT_DONT_FENCE 0x00000004 -/** - * On hardware with no interrupt events for operation completion, - * indicates that the kernel should sleep while waiting for any blocking - * operation to complete rather than spinning. - * - * Has no effect otherwise. - */ -#define DRM_BO_HINT_WAIT_LAZY 0x00000008 -/* - * The client has compute relocations refering to this buffer using the - * offset in the presumed_offset field. If that offset ends up matching - * where this buffer lands, the kernel is free to skip executing those - * relocations - */ -#define DRM_BO_HINT_PRESUMED_OFFSET 0x00000010 - -#define DRM_BO_INIT_MAGIC 0xfe769812 -#define DRM_BO_INIT_MAJOR 1 -#define DRM_BO_INIT_MINOR 0 -#define DRM_BO_INIT_PATCH 0 - - -struct drm_bo_info_req { - uint64_t mask; - uint64_t flags; - unsigned int handle; - unsigned int hint; - unsigned int fence_class; - unsigned int desired_tile_stride; - unsigned int tile_info; - unsigned int pad64; - uint64_t presumed_offset; -}; - -struct drm_bo_create_req { - uint64_t flags; - uint64_t size; - uint64_t buffer_start; - unsigned int hint; - unsigned int page_alignment; -}; - - -/* - * Reply flags - */ - -#define DRM_BO_REP_BUSY 0x00000001 - -struct drm_bo_info_rep { - uint64_t flags; - uint64_t proposed_flags; - uint64_t size; - uint64_t offset; - uint64_t arg_handle; - uint64_t buffer_start; - unsigned int handle; - unsigned int fence_flags; - unsigned int rep_flags; - unsigned int page_alignment; - unsigned int desired_tile_stride; - unsigned int hw_tile_stride; - unsigned int tile_info; - unsigned int pad64; - uint64_t expand_pad[4]; /*Future expansion */ -}; - -struct drm_bo_arg_rep { - struct drm_bo_info_rep bo_info; - int ret; - unsigned int pad64; -}; - -struct drm_bo_create_arg { - union { - struct drm_bo_create_req req; - struct drm_bo_info_rep rep; - } d; -}; - -struct drm_bo_handle_arg { - unsigned int handle; -}; - -struct drm_bo_reference_info_arg { - union { - struct drm_bo_handle_arg req; - struct drm_bo_info_rep rep; - } d; -}; - -struct drm_bo_map_wait_idle_arg { - union { - struct drm_bo_info_req req; - struct drm_bo_info_rep rep; - } d; -}; - -struct drm_bo_op_req { - enum { - drm_bo_validate, - drm_bo_fence, - drm_bo_ref_fence, - } op; - unsigned int arg_handle; - struct drm_bo_info_req bo_req; -}; - - -struct drm_bo_op_arg { - uint64_t next; - union { - struct drm_bo_op_req req; - struct drm_bo_arg_rep rep; - } d; - int handled; - unsigned int pad64; -}; - - -#define DRM_BO_MEM_LOCAL 0 -#define DRM_BO_MEM_TT 1 -#define DRM_BO_MEM_VRAM 2 -#define DRM_BO_MEM_PRIV0 3 -#define DRM_BO_MEM_PRIV1 4 -#define DRM_BO_MEM_PRIV2 5 -#define DRM_BO_MEM_PRIV3 6 -#define DRM_BO_MEM_PRIV4 7 - -#define DRM_BO_MEM_TYPES 8 /* For now. */ - -#define DRM_BO_LOCK_UNLOCK_BM (1 << 0) -#define DRM_BO_LOCK_IGNORE_NO_EVICT (1 << 1) - -struct drm_bo_version_arg { - uint32_t major; - uint32_t minor; - uint32_t patchlevel; -}; - -struct drm_mm_type_arg { - unsigned int mem_type; - unsigned int lock_flags; -}; - -struct drm_mm_init_arg { - unsigned int magic; - unsigned int major; - unsigned int minor; - unsigned int mem_type; - uint64_t p_offset; - uint64_t p_size; -}; - -struct drm_mm_info_arg { - unsigned int mem_type; - uint64_t p_size; -}; - struct drm_gem_close { /** Handle of the object to be closed. */ uint32_t handle; diff --git a/shared-core/via_drv.c b/shared-core/via_drv.c index dd632c3d..b96516f2 100644 --- a/shared-core/via_drv.c +++ b/shared-core/via_drv.c @@ -39,40 +39,6 @@ static struct pci_device_id pciidlist[] = { }; -#ifdef VIA_HAVE_FENCE -extern struct drm_fence_driver via_fence_driver; -#endif - -#ifdef VIA_HAVE_BUFFER - -/** - * If there's no thrashing. This is the preferred memory type order. - */ -static uint32_t via_mem_prios[] = {DRM_BO_MEM_PRIV0, DRM_BO_MEM_VRAM, DRM_BO_MEM_TT, DRM_BO_MEM_LOCAL}; - -/** - * If we have thrashing, most memory will be evicted to TT anyway, so we might as well - * just move the new buffer into TT from the start. - */ -static uint32_t via_busy_prios[] = {DRM_BO_MEM_TT, DRM_BO_MEM_PRIV0, DRM_BO_MEM_VRAM, DRM_BO_MEM_LOCAL}; - - -static struct drm_bo_driver via_bo_driver = { - .mem_type_prio = via_mem_prios, - .mem_busy_prio = via_busy_prios, - .num_mem_type_prio = ARRAY_SIZE(via_mem_prios), - .num_mem_busy_prio = ARRAY_SIZE(via_busy_prios), - .create_ttm_backend_entry = via_create_ttm_backend_entry, - .fence_type = via_fence_types, - .invalidate_caches = via_invalidate_caches, - .init_mem_type = via_init_mem_type, - .evict_flags = via_evict_flags, - .move = NULL, - .ttm_cache_flush = NULL, - .command_stream_barrier = NULL -}; -#endif - static int probe(struct pci_dev *pdev, const struct pci_device_id *ent); static struct drm_driver driver = { .driver_features = @@ -117,12 +83,6 @@ static struct drm_driver driver = { .probe = probe, .remove = __devexit_p(drm_cleanup_pci), }, -#ifdef VIA_HAVE_FENCE - .fence_driver = &via_fence_driver, -#endif -#ifdef VIA_HAVE_BUFFER - .bo_driver = &via_bo_driver, -#endif .name = DRIVER_NAME, .desc = DRIVER_DESC, .date = VIA_DRM_DRIVER_DATE, diff --git a/shared-core/via_drv.h b/shared-core/via_drv.h index 941a2d77..0c048ea2 100644 --- a/shared-core/via_drv.h +++ b/shared-core/via_drv.h @@ -62,8 +62,6 @@ */ #define VIA_HAVE_DMABLIT 1 #define VIA_HAVE_CORE_MM 1 -#define VIA_HAVE_FENCE 1 -#define VIA_HAVE_BUFFER 1 #endif #define VIA_PCI_BUF_SIZE 60000 @@ -196,16 +194,4 @@ extern void via_dmablit_handler(struct drm_device *dev, int engine, int from_irq extern void via_init_dmablit(struct drm_device *dev); #endif -#ifdef VIA_HAVE_BUFFER -extern struct drm_ttm_backend *via_create_ttm_backend_entry(struct drm_device *dev); -extern int via_fence_types(struct drm_buffer_object *bo, uint32_t *fclass, - uint32_t *type); -extern int via_invalidate_caches(struct drm_device *dev, uint64_t buffer_flags); -extern int via_init_mem_type(struct drm_device *dev, uint32_t type, - struct drm_mem_type_manager *man); -extern uint64_t via_evict_flags(struct drm_buffer_object *bo); -extern int via_move(struct drm_buffer_object *bo, int evict, - int no_wait, struct drm_bo_mem_reg *new_mem); -#endif - #endif diff --git a/shared-core/via_map.c b/shared-core/via_map.c index 5dee6a70..be7ca96b 100644 --- a/shared-core/via_map.c +++ b/shared-core/via_map.c @@ -65,17 +65,7 @@ static int via_do_init_map(struct drm_device * dev, drm_via_init_t * init) #ifdef VIA_HAVE_DMABLIT via_init_dmablit( dev ); #endif -#ifdef VIA_HAVE_FENCE - dev_priv->emit_0_sequence = 0; - dev_priv->have_idlelock = 0; - spin_lock_init(&dev_priv->fence_lock); -#endif /* VIA_HAVE_FENCE */ dev->dev_private = (void *)dev_priv; -#ifdef VIA_HAVE_BUFFER - ret = drm_bo_driver_init(dev); - if (ret) - DRM_ERROR("Could not initialize buffer object driver.\n"); -#endif return ret; } |