geemili
/
drm
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Checkpoint commit 

Buffer object code.
main
Thomas Hellstrom 2006-08-25 18:05:35 +02:00
parent 8fa43d4b2f
commit 4c03030b12
7 changed files with 362 additions and 13 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
linux-core/Makefile.kernel
View File

@ -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

49
linux-core/drmP.h
View File

@ -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);

282
linux-core/drm_bo.c Normal file
View File

@ -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

9
linux-core/drm_fence.c
View File

@ -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,7 +322,7 @@ 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 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;

12
linux-core/drm_ttm.c
View File

@ -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;

2
linux-core/drm_vm.c
View File

@ -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;

17
shared-core/drm.h
View File

@ -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