Menu
▾
▴
drm: Branch 'drm-ttm-0-2-branch' - 4 commits
|
From: <th...@ke...> - 2006-08-25 16:06:18
|
linux-core/Makefile.kernel | 2
linux-core/drmP.h | 49 +++++++
linux-core/drm_bo.c | 282 +++++++++++++++++++++++++++++++++++++++++++++
linux-core/drm_bufs.c | 14 +-
linux-core/drm_fence.c | 11 +
linux-core/drm_hashtab.c | 6
linux-core/drm_ttm.c | 12 -
linux-core/drm_vm.c | 2
shared-core/drm.h | 17 ++
9 files changed, 373 insertions(+), 22 deletions(-)
New commits:
diff-tree 4c03030b12bae28dad50d69bd271de632c43ff13 (from 8fa43d4b2ff4137bab743bfaf6282aa327f16830)
Author: Thomas Hellstrom <thomas-at-tungstengraphics-dot-com>
Date: Fri Aug 25 18:05:35 2006 +0200
Checkpoint commit
Buffer object code.
diff --git a/linux-core/Makefile.kernel b/linux-core/Makefile.kernel
index e571f29..fba57dd 100644
--- a/linux-core/Makefile.kernel
+++ b/linux-core/Makefile.kernel
@@ -13,7 +13,7 @@ drm-objs := drm_auth.o drm_bufs.o drm
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 e42b5e5..3dd7e77 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
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 0000000..d87cd2a
--- /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 <thomas-at-tungstengraphics-dot-com>
+ */
+
+#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 cfcda2b..897f84c 100644
--- a/linux-core/drm_fence.c
+++ b/linux-core/drm_fence.c
@@ -252,12 +252,17 @@ static void drm_fence_flush_exe(drm_fenc
}
}
+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 *
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 df4c312..806c109 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 * t
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
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_back
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, unsi
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 85b3949..9c2fbe0 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_a
(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 cd2b190..bda565b 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
diff-tree 8fa43d4b2ff4137bab743bfaf6282aa327f16830 (from parents)
Merge: e201511a0fbeb177a9ecd7f77d177fc88c1616fb 459b234d79daaa8a003da9ea48775a5587d5ba2a
Author: Thomas Hellstrom <thomas-at-tungstengraphics-dot-com>
Date: Wed Aug 23 13:31:45 2006 +0200
Merge branch 'master' of git+ssh://git.freedesktop.org/git/mesa/drm into drm-ttm-0-2-branch
diff-tree 459b234d79daaa8a003da9ea48775a5587d5ba2a (from 8dfe917cb26bbeddda0e1b52060d8dce188468f3)
Author: Thomas Hellstrom <thomas-at-tungstengraphics-dot-com>
Date: Wed Aug 23 11:31:10 2006 +0200
Allow multiple addMaps with the same 32-bit map offset.
(Reported by Dave Airlie)
diff --git a/linux-core/drm_bufs.c b/linux-core/drm_bufs.c
index 2eeb401..13b0b17 100644
--- a/linux-core/drm_bufs.c
+++ b/linux-core/drm_bufs.c
@@ -78,14 +78,16 @@ int drm_map_handle(drm_device_t *dev, dr
#error Unsupported long size. Neither 64 nor 32 bits.
#endif
- if (use_hashed_handle) {
- return drm_ht_just_insert_please(&dev->map_hash, hash,
- user_token, 32 - PAGE_SHIFT - 3,
- PAGE_SHIFT, DRM_MAP_HASH_OFFSET);
- } else {
+ if (!use_hashed_handle) {
+ int ret;
hash->key = user_token;
- return drm_ht_insert_item(&dev->map_hash, hash);
+ ret = drm_ht_insert_item(&dev->map_hash, hash);
+ if (!ret)
+ return 0;
}
+ return drm_ht_just_insert_please(&dev->map_hash, hash,
+ user_token, 32 - PAGE_SHIFT - 3,
+ PAGE_SHIFT, DRM_MAP_HASH_OFFSET);
}
/**
diff-tree 8dfe917cb26bbeddda0e1b52060d8dce188468f3 (from 0316f93d51abc52b816e936e0ece304ac47799c3)
Author: Thomas Hellstrom <thomas-at-tungstengraphics-dot-com>
Date: Wed Aug 23 11:21:33 2006 +0200
Fix hashtab implementation leaking illegal error codes to user space.
(Reported by Dave Airlie)
diff --git a/linux-core/drm_hashtab.c b/linux-core/drm_hashtab.c
index 4806113..a0b2d68 100644
--- a/linux-core/drm_hashtab.c
+++ b/linux-core/drm_hashtab.c
@@ -106,7 +106,7 @@ int drm_ht_insert_item(drm_open_hash_t *
hlist_for_each(list, h_list) {
entry = hlist_entry(list, drm_hash_item_t, head);
if (entry->key == key)
- return -1;
+ return -EINVAL;
if (entry->key > key)
break;
parent = list;
@@ -154,7 +154,7 @@ int drm_ht_find_item(drm_open_hash_t *ht
list = drm_ht_find_key(ht, key);
if (!list)
- return -1;
+ return -EINVAL;
*item = hlist_entry(list, drm_hash_item_t, head);
return 0;
@@ -170,7 +170,7 @@ int drm_ht_remove_key(drm_open_hash_t *h
ht->fill--;
return 0;
}
- return -1;
+ return -EINVAL;
}
int drm_ht_remove_item(drm_open_hash_t *ht, drm_hash_item_t *item)
|