From 4c03030b12bae28dad50d69bd271de632c43ff13 Mon Sep 17 00:00:00 2001 From: Thomas Hellstrom Date: Fri, 25 Aug 2006 18:05:35 +0200 Subject: Checkpoint commit Buffer object code. --- linux-core/Makefile.kernel | 2 +- linux-core/drmP.h | 49 ++++++++ linux-core/drm_bo.c | 282 +++++++++++++++++++++++++++++++++++++++++++++ linux-core/drm_fence.c | 11 +- linux-core/drm_ttm.c | 12 +- linux-core/drm_vm.c | 2 - shared-core/drm.h | 17 +++ 7 files changed, 362 insertions(+), 13 deletions(-) create mode 100644 linux-core/drm_bo.c diff --git a/linux-core/Makefile.kernel b/linux-core/Makefile.kernel index e571f29e..fba57ddf 100644 --- a/linux-core/Makefile.kernel +++ b/linux-core/Makefile.kernel @@ -13,7 +13,7 @@ drm-objs := drm_auth.o drm_bufs.o drm_context.o drm_dma.o drm_drawable.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_fence.o drm_ttm.o drm_bo.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 diff --git a/linux-core/drmP.h b/linux-core/drmP.h index e42b5e55..3dd7e775 100644 --- a/linux-core/drmP.h +++ b/linux-core/drmP.h @@ -714,6 +714,18 @@ typedef struct drm_fence_manager{ uint32_t exe_flush_sequence; } drm_fence_manager_t; +typedef struct drm_buffer_manager{ + int initialized; + struct mutex bm_mutex; + drm_mm_t tt_manager; + struct list_head tt_lru; + drm_mm_t vram_manager; + struct list_head vram_lru; + struct list_head unfenced; + struct list_head ddestroy; +} drm_buffer_manager_t; + + /** * DRM device structure. This structure represent a complete card that @@ -848,6 +860,7 @@ typedef struct drm_device { drm_head_t primary; /**< primary screen head */ drm_fence_manager_t fm; + drm_buffer_manager_t bm; } drm_device_t; @@ -973,6 +986,29 @@ typedef struct drm_fence_object{ } drm_fence_object_t; +typedef struct drm_buffer_object{ + drm_device_t *dev; + drm_user_object_t base; + atomic_t usage; + drm_map_list_t *ttm_maplist; + drm_ttm_backend_list_t *ttm_region; + + atomic_t mapped; + + uint32_t flags; + uint32_t mask; + uint32_t mask_hint; + + drm_mm_node_t *vram; + drm_mm_node_t *tt; + struct list_head head; + struct list_head ddestroy; + + uint32_t fence_flags; + drm_fence_object_t *fence; + int unfenced; + wait_queue_head_t validate_queue; +} drm_buffer_object_t; @@ -1296,6 +1332,19 @@ extern void drm_fence_handler(drm_device_t *dev, uint32_t breadcrumb, uint32_t t extern void drm_fence_manager_init(drm_device_t *dev); extern void drm_fence_manager_takedown(drm_device_t *dev); extern void drm_fence_flush_old(drm_device_t *dev, uint32_t sequence); +extern int drm_fence_object_flush(drm_device_t * dev, + drm_fence_object_t * fence, uint32_t type); +extern int drm_fence_object_signaled(drm_fence_object_t * fence, uint32_t type); +extern void drm_fence_usage_deref_locked(drm_device_t * dev, + drm_fence_object_t * fence); +extern void drm_fence_usage_deref_unlocked(drm_device_t * dev, + drm_fence_object_t * fence); +extern int drm_fence_object_init(drm_device_t * dev, uint32_t type, int emit, + drm_fence_object_t * fence); +extern int drm_fence_object_wait(drm_device_t * dev, drm_fence_object_t * fence, + int lazy, int ignore_signals, uint32_t mask); + + extern int drm_fence_ioctl(DRM_IOCTL_ARGS); diff --git a/linux-core/drm_bo.c b/linux-core/drm_bo.c new file mode 100644 index 00000000..d87cd2a1 --- /dev/null +++ b/linux-core/drm_bo.c @@ -0,0 +1,282 @@ +/************************************************************************** + * + * Copyright 2006 Tungsten Graphics, Inc., Bismarck, ND., 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 + */ + +#include "drmP.h" + +int drm_fence_buffer_objects(drm_file_t *priv) +{ + drm_device_t *dev = priv->head->dev; + drm_buffer_manager_t *bm = &dev->bm; + + drm_buffer_object_t *entry, *next; + uint32_t fence_flags = 0; + int count = 0; + drm_fence_object_t *fence; + int ret; + + mutex_lock(&bm->bm_mutex); + + list_for_each_entry(entry, &bm->unfenced, head) { + BUG_ON(!entry->unfenced); + fence_flags |= entry->fence_flags; + count++; + } + + if (!count) { + mutex_unlock(&bm->bm_mutex); + return 0; + } + + fence = drm_calloc(1, sizeof(*fence), DRM_MEM_FENCE); + + if (!fence) { + mutex_unlock(&bm->bm_mutex); + return -ENOMEM; + } + + ret = drm_fence_object_init(dev, fence_flags, 1, fence); + if (ret) { + drm_free(fence, sizeof(*fence), DRM_MEM_FENCE); + mutex_unlock(&bm->bm_mutex); + return ret; + } + + list_for_each_entry_safe(entry, next, &bm->unfenced, head) { + BUG_ON(entry->fence); + entry->unfenced = 0; + entry->fence = fence; + list_del_init(&entry->head); + + if (!(entry->flags & DRM_BO_FLAG_NO_EVICT)) { + if (entry->flags & DRM_BO_FLAG_MEM_TT) { + list_add_tail(&entry->head, &bm->tt_lru); + } else if (entry->flags & DRM_BO_FLAG_MEM_VRAM) { + list_add_tail(&entry->head, &bm->vram_lru); + } + } + } + + mutex_lock(&dev->struct_mutex); + atomic_add(count - 1, &fence->usage); + mutex_unlock(&dev->struct_mutex); + mutex_unlock(&bm->bm_mutex); + return 0; +} + +/* + * bm locked, + * dev locked. + */ + + +static int drm_move_tt_to_local(drm_buffer_object_t *buf, int lazy) +{ + drm_device_t *dev = buf->dev; + drm_buffer_manager_t *bm = &dev->bm; + int ret = 0; + + BUG_ON(!buf->tt); + + if (buf->fence) { + ret = drm_fence_object_wait(dev, buf->fence, lazy, !lazy, + buf->fence_flags); + if (ret) + return ret; + drm_fence_usage_deref_unlocked(dev, buf->fence); + buf->fence = NULL; + } + + drm_unbind_ttm_region(buf->ttm_region); + drm_mm_put_block(&bm->tt_manager, buf->tt); + buf->tt = NULL; + buf->flags &= ~(DRM_BO_FLAG_MEM_TT | DRM_BO_FLAG_UNCACHED); + buf->flags |= DRM_BO_FLAG_MEM_LOCAL; + + return 0; +} + + +void destroy_buffer_object(drm_device_t *dev, drm_buffer_object_t *bo) +{ + + drm_buffer_manager_t *bm = &dev->bm; + + BUG_ON(bo->unfenced); + + if (bo->fence) { + if (!drm_fence_object_signaled(bo->fence, bo->fence_flags)) { + drm_fence_object_flush(dev, bo->fence, bo->fence_flags); + list_add_tail(&bo->ddestroy, &bm->ddestroy); + return; + } else { + drm_fence_usage_deref_locked(dev, bo->fence); + bo->fence = NULL; + } + } + + /* + * Take away from lru lists. + */ + + list_del_init(&bo->head); + + if (bo->tt) { + int ret; + ret = drm_move_tt_to_local(bo, 0); + BUG_ON(ret); + } + if (bo->vram) { + drm_mm_put_block(&bm->vram_manager, bo->vram); + bo->vram = NULL; + } + + /* + * FIXME: Destroy ttm. + */ + + drm_free(bo, sizeof(*bo), DRM_MEM_BUFOBJ); +} + +static int drm_bo_new_flags(uint32_t flags, uint32_t new_mask, uint32_t hint, + int init, uint32_t *n_flags) +{ + uint32_t new_flags; + uint32_t new_props; + + if (!(flags & new_mask & DRM_BO_MASK_MEM) || init) { + + /* + * We need to move memory. Default preferences are hard-coded + * here. + */ + + new_flags = new_mask & DRM_BO_MASK_MEM; + + if (!new_flags) { + DRM_ERROR("Invalid buffer object memory flags\n"); + return -EINVAL; + } + + if (new_flags & DRM_BO_FLAG_MEM_LOCAL) { + if ((hint & DRM_BO_HINT_AVOID_LOCAL) && + new_flags & (DRM_BO_FLAG_MEM_VRAM | DRM_BO_FLAG_MEM_TT)) { + new_flags &= ~DRM_BO_FLAG_MEM_LOCAL; + } else { + new_flags = DRM_BO_FLAG_MEM_LOCAL; + } + } + if (new_flags & DRM_BO_FLAG_MEM_TT) { + if ((hint & DRM_BO_HINT_PREFER_VRAM) && + new_flags & DRM_BO_FLAG_MEM_VRAM) { + new_flags = DRM_BO_FLAG_MEM_VRAM; + } else { + new_flags = DRM_BO_FLAG_MEM_TT; + } + } + } else { + new_flags = flags & DRM_BO_MASK_MEM; + } + + new_props = new_mask & (DRM_BO_FLAG_EXE | DRM_BO_FLAG_WRITE | + DRM_BO_FLAG_READ); + + if (!new_props) { + DRM_ERROR("Invalid buffer object rwx properties\n"); + return -EINVAL; + } + + new_flags |= new_mask & ~DRM_BO_MASK_MEM; + *n_flags = new_flags; + return 0; +} + + + +#if 0 + +static int drm_bo_evict(drm_device_t *dev, drm_buffer_object_t *buf, int tt); +{ + int ret; + if (tt) { + ret = drm_move_tt_to_local(buf); + } else { + ret = drm_move_vram_to_local(buf); + } + return ret; +} + +int drm_bo_alloc_space(drm_device_t *dev, int tt, drm_buffer_object_t *buf) +{ + drm_mm_node_t *node; + drm_buffer_manager_t *bm = &dev->bm; + drm_buffer_object_t *bo; + drm_mm_t *mm = (tt) ? &bm->tt_manager : &bm->vram_manager; + + lru = (tt) ? &bm->tt_lru : &bm->vram_lru; + + do { + node = drm_mm_search_free(mm, size, 0, 1); + if (node) + break; + + if (lru->next == lru) + break; + + if (tt) { + bo = list_entry(lru->next, drm_buffer_object_t, tt_lru); + } else { + bo = list_entry(lru->next, drm_buffer_object_t, vram_lru); + } + + drm_bo_evict(dev, bo, tt); + } while (1); + + if (!node) { + DRM_ERROR("Out of aperture space\n"); + return -ENOMEM; + } + + node = drm_mm_get_block(node, size, 0); + BUG_ON(!node); + node->private = (void *)buf; + + if (tt) { + buf->tt = node; + } else { + buf->vram = node; + } + return 0; +} +#endif + + + + diff --git a/linux-core/drm_fence.c b/linux-core/drm_fence.c index cfcda2b2..897f84c5 100644 --- a/linux-core/drm_fence.c +++ b/linux-core/drm_fence.c @@ -252,12 +252,17 @@ static void drm_fence_flush_exe(drm_fence_manager_t * fm, } } +int drm_fence_object_signaled(drm_fence_object_t * fence, uint32_t type) +{ + return ((fence->signaled & type) == type); +} + /* * Make sure old fence objects are signaled before their fence sequences are * wrapped around and reused. */ -static int drm_fence_object_flush(drm_device_t * dev, +int drm_fence_object_flush(drm_device_t * dev, drm_fence_object_t * fence, uint32_t type) { drm_fence_manager_t *fm = &dev->fm; @@ -317,8 +322,8 @@ void drm_fence_flush_old(drm_device_t * dev, uint32_t sequence) EXPORT_SYMBOL(drm_fence_flush_old); -static int drm_fence_object_wait(drm_device_t * dev, drm_fence_object_t * fence, - int lazy, int ignore_signals, uint32_t mask) +int drm_fence_object_wait(drm_device_t * dev, drm_fence_object_t * fence, + int lazy, int ignore_signals, uint32_t mask) { drm_fence_manager_t *fm = &dev->fm; drm_fence_driver_t *driver = dev->driver->fence_driver; diff --git a/linux-core/drm_ttm.c b/linux-core/drm_ttm.c index df4c312c..806c109b 100644 --- a/linux-core/drm_ttm.c +++ b/linux-core/drm_ttm.c @@ -398,10 +398,6 @@ static int drm_set_caching(drm_ttm_t * ttm, unsigned long page_offset, struct page **cur_page; pgprot_t attr = (noncached) ? PAGE_KERNEL_NOCACHE : PAGE_KERNEL; - drm_ttm_lock_mm(ttm, 0, 1); - unmap_vma_pages(ttm, page_offset, num_pages); - drm_ttm_unlock_mm(ttm, 0, 1); - for (i = 0; i < num_pages; ++i) { cur = page_offset + i; cur_page = ttm->pages + cur; @@ -446,7 +442,6 @@ int drm_evict_ttm_region(drm_ttm_backend_list_t * entry) drm_ttm_lock_mm(ttm, 0, 1); unmap_vma_pages(ttm, entry->page_offset, entry->num_pages); - global_flush_tlb(); drm_ttm_unlock_mm(ttm, 0, 1); } be->unbind(entry->be); @@ -489,6 +484,10 @@ void drm_destroy_ttm_region(drm_ttm_backend_list_t * entry) be->clear(entry->be); if (be->needs_cache_adjust(be)) { int ret = drm_ttm_lock_mmap_sem(ttm); + drm_ttm_lock_mm(ttm, 0, 1); + unmap_vma_pages(ttm, entry->page_offset, + entry->num_pages); + drm_ttm_unlock_mm(ttm, 0, 1); drm_set_caching(ttm, entry->page_offset, entry->num_pages, 0, 1); if (!ret) @@ -792,8 +791,7 @@ int drm_add_ttm(drm_device_t * dev, unsigned size, drm_map_list_t ** maplist) return -ENOMEM; } - list->user_token = - (list->hash.key << PAGE_SHIFT) + DRM_MAP_HASH_OFFSET; + list->user_token = list->hash.key; list->map = map; *maplist = list; diff --git a/linux-core/drm_vm.c b/linux-core/drm_vm.c index 85b39490..9c2fbe08 100644 --- a/linux-core/drm_vm.c +++ b/linux-core/drm_vm.c @@ -703,8 +703,6 @@ static void drm_vm_ttm_close(struct vm_area_struct *vma) (drm_ttm_vma_list_t *) vma->vm_private_data; drm_map_t *map; drm_ttm_t *ttm; - int found_maps; - struct list_head *list; drm_device_t *dev; int ret; diff --git a/shared-core/drm.h b/shared-core/drm.h index cd2b1907..bda565b3 100644 --- a/shared-core/drm.h +++ b/shared-core/drm.h @@ -655,6 +655,23 @@ typedef struct drm_fence_arg { } op; } drm_fence_arg_t; +#define DRM_BO_FLAG_READ 0x00000001 +#define DRM_BO_FLAG_WRITE 0x00000002 +#define DRM_BO_FLAG_EXE 0x00000004 +#define DRM_BO_FLAG_NO_MOVE 0x00000008 +#define DRM_BO_FLAG_NO_EVICT 0x00000010 +#define DRM_BO_FLAG_SHADOW_VRAM 0x00000020 +#define DRM_BO_FLAG_READ_LOCAL 0x00000040 +#define DRM_BO_FLAG_UNCACHED 0x00000080 + + +#define DRM_BO_FLAG_MEM_TT 0x01000000 +#define DRM_BO_FLAG_MEM_VRAM 0x02000000 +#define DRM_BO_FLAG_MEM_LOCAL 0x04000000 +#define DRM_BO_MASK_MEM 0xFFFFFFFF + +#define DRM_BO_HINT_PREFER_VRAM 0x00000001 +#define DRM_BO_HINT_AVOID_LOCAL 0x00000002 /** * \name Ioctls Definitions -- cgit v1.2.3