diff options
Diffstat (limited to 'libdrm/intel')
| -rw-r--r-- | libdrm/intel/intel_bufmgr.c | 73 | ||||
| -rw-r--r-- | libdrm/intel/intel_bufmgr.h | 179 | ||||
| -rw-r--r-- | libdrm/intel/intel_bufmgr_fake.c | 369 | ||||
| -rw-r--r-- | libdrm/intel/intel_bufmgr_gem.c | 336 | ||||
| -rw-r--r-- | libdrm/intel/intel_bufmgr_priv.h | 65 |
5 files changed, 538 insertions, 484 deletions
diff --git a/libdrm/intel/intel_bufmgr.c b/libdrm/intel/intel_bufmgr.c index 92b60467..188eac22 100644 --- a/libdrm/intel/intel_bufmgr.c +++ b/libdrm/intel/intel_bufmgr.c @@ -39,26 +39,26 @@ #include "intel_bufmgr.h" #include "intel_bufmgr_priv.h" -/** @file dri_bufmgr.c +/** @file intel_bufmgr.c * * Convenience functions for buffer management methods. */ -dri_bo * -dri_bo_alloc(dri_bufmgr *bufmgr, const char *name, unsigned long size, - unsigned int alignment) +drm_intel_bo * +drm_intel_bo_alloc(drm_intel_bufmgr *bufmgr, const char *name, + unsigned long size, unsigned int alignment) { return bufmgr->bo_alloc(bufmgr, name, size, alignment); } void -dri_bo_reference(dri_bo *bo) +drm_intel_bo_reference(drm_intel_bo *bo) { bo->bufmgr->bo_reference(bo); } void -dri_bo_unreference(dri_bo *bo) +drm_intel_bo_unreference(drm_intel_bo *bo) { if (bo == NULL) return; @@ -67,38 +67,39 @@ dri_bo_unreference(dri_bo *bo) } int -dri_bo_map(dri_bo *buf, int write_enable) +drm_intel_bo_map(drm_intel_bo *buf, int write_enable) { return buf->bufmgr->bo_map(buf, write_enable); } int -dri_bo_unmap(dri_bo *buf) +drm_intel_bo_unmap(drm_intel_bo *buf) { return buf->bufmgr->bo_unmap(buf); } int -dri_bo_subdata(dri_bo *bo, unsigned long offset, - unsigned long size, const void *data) +drm_intel_bo_subdata(drm_intel_bo *bo, unsigned long offset, + unsigned long size, const void *data) { int ret; + if (bo->bufmgr->bo_subdata) return bo->bufmgr->bo_subdata(bo, offset, size, data); if (size == 0 || data == NULL) return 0; - ret = dri_bo_map(bo, 1); + ret = drm_intel_bo_map(bo, 1); if (ret) return ret; memcpy((unsigned char *)bo->virtual + offset, data, size); - dri_bo_unmap(bo); + drm_intel_bo_unmap(bo); return 0; } int -dri_bo_get_subdata(dri_bo *bo, unsigned long offset, - unsigned long size, void *data) +drm_intel_bo_get_subdata(drm_intel_bo *bo, unsigned long offset, + unsigned long size, void *data) { int ret; if (bo->bufmgr->bo_subdata) @@ -107,48 +108,48 @@ dri_bo_get_subdata(dri_bo *bo, unsigned long offset, if (size == 0 || data == NULL) return 0; - ret = dri_bo_map(bo, 0); + ret = drm_intel_bo_map(bo, 0); if (ret) return ret; memcpy(data, (unsigned char *)bo->virtual + offset, size); - dri_bo_unmap(bo); + drm_intel_bo_unmap(bo); return 0; } void -dri_bo_wait_rendering(dri_bo *bo) +drm_intel_bo_wait_rendering(drm_intel_bo *bo) { bo->bufmgr->bo_wait_rendering(bo); } void -dri_bufmgr_destroy(dri_bufmgr *bufmgr) +drm_intel_bufmgr_destroy(drm_intel_bufmgr *bufmgr) { bufmgr->destroy(bufmgr); } int -dri_bo_exec(dri_bo *bo, int used, - drm_clip_rect_t *cliprects, int num_cliprects, - int DR4) +drm_intel_bo_exec(drm_intel_bo *bo, int used, + drm_clip_rect_t *cliprects, int num_cliprects, + int DR4) { return bo->bufmgr->bo_exec(bo, used, cliprects, num_cliprects, DR4); } void -dri_bufmgr_set_debug(dri_bufmgr *bufmgr, int enable_debug) +drm_intel_bufmgr_set_debug(drm_intel_bufmgr *bufmgr, int enable_debug) { bufmgr->debug = enable_debug; } int -dri_bufmgr_check_aperture_space(dri_bo **bo_array, int count) +drm_intel_bufmgr_check_aperture_space(drm_intel_bo **bo_array, int count) { return bo_array[0]->bufmgr->check_aperture_space(bo_array, count); } int -dri_bo_flink(dri_bo *bo, uint32_t *name) +drm_intel_bo_flink(drm_intel_bo *bo, uint32_t *name) { if (bo->bufmgr->bo_flink) return bo->bufmgr->bo_flink(bo, name); @@ -157,17 +158,17 @@ dri_bo_flink(dri_bo *bo, uint32_t *name) } int -dri_bo_emit_reloc(dri_bo *reloc_buf, - uint32_t read_domains, uint32_t write_domain, - uint32_t delta, uint32_t offset, dri_bo *target_buf) +drm_intel_bo_emit_reloc(drm_intel_bo *bo, uint32_t offset, + drm_intel_bo *target_bo, uint32_t target_offset, + uint32_t read_domains, uint32_t write_domain) { - return reloc_buf->bufmgr->bo_emit_reloc(reloc_buf, - read_domains, write_domain, - delta, offset, target_buf); + return bo->bufmgr->bo_emit_reloc(bo, offset, + target_bo, target_offset, + read_domains, write_domain); } int -dri_bo_pin(dri_bo *bo, uint32_t alignment) +drm_intel_bo_pin(drm_intel_bo *bo, uint32_t alignment) { if (bo->bufmgr->bo_pin) return bo->bufmgr->bo_pin(bo, alignment); @@ -176,7 +177,7 @@ dri_bo_pin(dri_bo *bo, uint32_t alignment) } int -dri_bo_unpin(dri_bo *bo) +drm_intel_bo_unpin(drm_intel_bo *bo) { if (bo->bufmgr->bo_unpin) return bo->bufmgr->bo_unpin(bo); @@ -184,16 +185,18 @@ dri_bo_unpin(dri_bo *bo) return -ENODEV; } -int dri_bo_set_tiling(dri_bo *bo, uint32_t *tiling_mode) +int drm_intel_bo_set_tiling(drm_intel_bo *bo, uint32_t *tiling_mode, + uint32_t stride) { if (bo->bufmgr->bo_set_tiling) - return bo->bufmgr->bo_set_tiling(bo, tiling_mode); + return bo->bufmgr->bo_set_tiling(bo, tiling_mode, stride); *tiling_mode = I915_TILING_NONE; return 0; } -int dri_bo_get_tiling(dri_bo *bo, uint32_t *tiling_mode, uint32_t *swizzle_mode) +int drm_intel_bo_get_tiling(drm_intel_bo *bo, uint32_t *tiling_mode, + uint32_t *swizzle_mode) { if (bo->bufmgr->bo_get_tiling) return bo->bufmgr->bo_get_tiling(bo, tiling_mode, swizzle_mode); diff --git a/libdrm/intel/intel_bufmgr.h b/libdrm/intel/intel_bufmgr.h index 0c7b0e47..e3af886b 100644 --- a/libdrm/intel/intel_bufmgr.h +++ b/libdrm/intel/intel_bufmgr.h @@ -36,10 +36,10 @@ #include <stdint.h> -typedef struct _dri_bufmgr dri_bufmgr; -typedef struct _dri_bo dri_bo; +typedef struct _drm_intel_bufmgr drm_intel_bufmgr; +typedef struct _drm_intel_bo drm_intel_bo; -struct _dri_bo { +struct _drm_intel_bo { /** * Size in bytes of the buffer object. * @@ -58,72 +58,117 @@ struct _dri_bo { void *virtual; /** Buffer manager context associated with this buffer object */ - dri_bufmgr *bufmgr; + drm_intel_bufmgr *bufmgr; }; -dri_bo *dri_bo_alloc(dri_bufmgr *bufmgr, const char *name, unsigned long size, - unsigned int alignment); -void dri_bo_reference(dri_bo *bo); -void dri_bo_unreference(dri_bo *bo); -int dri_bo_map(dri_bo *buf, int write_enable); -int dri_bo_unmap(dri_bo *buf); - -int dri_bo_subdata(dri_bo *bo, unsigned long offset, - unsigned long size, const void *data); -int dri_bo_get_subdata(dri_bo *bo, unsigned long offset, - unsigned long size, void *data); -void dri_bo_wait_rendering(dri_bo *bo); - -void dri_bufmgr_set_debug(dri_bufmgr *bufmgr, int enable_debug); -void dri_bufmgr_destroy(dri_bufmgr *bufmgr); -int dri_bo_exec(dri_bo *bo, int used, - drm_clip_rect_t *cliprects, int num_cliprects, - int DR4); -int dri_bufmgr_check_aperture_space(dri_bo **bo_array, int count); - -int dri_bo_emit_reloc(dri_bo *reloc_buf, - uint32_t read_domains, uint32_t write_domain, - uint32_t delta, uint32_t offset, dri_bo *target_buf); -int dri_bo_pin(dri_bo *buf, uint32_t alignment); -int dri_bo_unpin(dri_bo *buf); -int dri_bo_set_tiling(dri_bo *buf, uint32_t *tiling_mode); -int dri_bo_get_tiling(dri_bo *buf, uint32_t *tiling_mode, - uint32_t *swizzle_mode); -int dri_bo_flink(dri_bo *buf, uint32_t *name); - -/* intel_bufmgr_gem.c */ -dri_bufmgr *intel_bufmgr_gem_init(int fd, int batch_size); -dri_bo *intel_bo_gem_create_from_name(dri_bufmgr *bufmgr, const char *name, - unsigned int handle); -void intel_bufmgr_gem_enable_reuse(dri_bufmgr *bufmgr); - -/* intel_bufmgr_fake.c */ -dri_bufmgr *intel_bufmgr_fake_init(int fd, - unsigned long low_offset, void *low_virtual, - unsigned long size, - volatile unsigned int *last_dispatch); -void intel_bufmgr_fake_set_last_dispatch(dri_bufmgr *bufmgr, - volatile unsigned int *last_dispatch); -void intel_bufmgr_fake_set_exec_callback(dri_bufmgr *bufmgr, - int (*exec)(dri_bo *bo, - unsigned int used, - void *priv), - void *priv); -void intel_bufmgr_fake_set_fence_callback(dri_bufmgr *bufmgr, - unsigned int (*emit)(void *priv), - void (*wait)(unsigned int fence, - void *priv), - void *priv); -dri_bo *intel_bo_fake_alloc_static(dri_bufmgr *bufmgr, const char *name, - unsigned long offset, unsigned long size, - void *virtual); -void intel_bo_fake_disable_backing_store(dri_bo *bo, - void (*invalidate_cb)(dri_bo *bo, - void *ptr), - void *ptr); - -void intel_bufmgr_fake_contended_lock_take(dri_bufmgr *bufmgr); -void intel_bufmgr_fake_evict_all(dri_bufmgr *bufmgr); +drm_intel_bo *drm_intel_bo_alloc(drm_intel_bufmgr *bufmgr, const char *name, + unsigned long size, unsigned int alignment); +void drm_intel_bo_reference(drm_intel_bo *bo); +void drm_intel_bo_unreference(drm_intel_bo *bo); +int drm_intel_bo_map(drm_intel_bo *bo, int write_enable); +int drm_intel_bo_unmap(drm_intel_bo *bo); + +int drm_intel_bo_subdata(drm_intel_bo *bo, unsigned long offset, + unsigned long size, const void *data); +int drm_intel_bo_get_subdata(drm_intel_bo *bo, unsigned long offset, + unsigned long size, void *data); +void drm_intel_bo_wait_rendering(drm_intel_bo *bo); + +void drm_intel_bufmgr_set_debug(drm_intel_bufmgr *bufmgr, int enable_debug); +void drm_intel_bufmgr_destroy(drm_intel_bufmgr *bufmgr); +int drm_intel_bo_exec(drm_intel_bo *bo, int used, + drm_clip_rect_t *cliprects, int num_cliprects, + int DR4); +int drm_intel_bufmgr_check_aperture_space(drm_intel_bo **bo_array, int count); + +int drm_intel_bo_emit_reloc(drm_intel_bo *bo, uint32_t offset, + drm_intel_bo *target_bo, uint32_t target_offset, + uint32_t read_domains, uint32_t write_domain); +int drm_intel_bo_pin(drm_intel_bo *bo, uint32_t alignment); +int drm_intel_bo_unpin(drm_intel_bo *bo); +int drm_intel_bo_set_tiling(drm_intel_bo *bo, uint32_t *tiling_mode, + uint32_t stride); +int drm_intel_bo_get_tiling(drm_intel_bo *bo, uint32_t *tiling_mode, + uint32_t *swizzle_mode); +int drm_intel_bo_flink(drm_intel_bo *bo, uint32_t *name); + +/* drm_intel_bufmgr_gem.c */ +drm_intel_bufmgr *drm_intel_bufmgr_gem_init(int fd, int batch_size); +drm_intel_bo *drm_intel_bo_gem_create_from_name(drm_intel_bufmgr *bufmgr, + const char *name, + unsigned int handle); +void drm_intel_bufmgr_gem_enable_reuse(drm_intel_bufmgr *bufmgr); + +/* drm_intel_bufmgr_fake.c */ +drm_intel_bufmgr *drm_intel_bufmgr_fake_init(int fd, + unsigned long low_offset, + void *low_virtual, + unsigned long size, + volatile unsigned int *last_dispatch); +void drm_intel_bufmgr_fake_set_last_dispatch(drm_intel_bufmgr *bufmgr, + volatile unsigned int *last_dispatch); +void drm_intel_bufmgr_fake_set_exec_callback(drm_intel_bufmgr *bufmgr, + int (*exec)(drm_intel_bo *bo, + unsigned int used, + void *priv), + void *priv); +void drm_intel_bufmgr_fake_set_fence_callback(drm_intel_bufmgr *bufmgr, + unsigned int (*emit)(void *priv), + void (*wait)(unsigned int fence, + void *priv), + void *priv); +drm_intel_bo *drm_intel_bo_fake_alloc_static(drm_intel_bufmgr *bufmgr, + const char *name, + unsigned long offset, unsigned long size, + void *virtual); +void drm_intel_bo_fake_disable_backing_store(drm_intel_bo *bo, + void (*invalidate_cb)(drm_intel_bo *bo, + void *ptr), + void *ptr); + +void drm_intel_bufmgr_fake_contended_lock_take(drm_intel_bufmgr *bufmgr); +void drm_intel_bufmgr_fake_evict_all(drm_intel_bufmgr *bufmgr); + +/** @{ Compatibility defines to keep old code building despite the symbol rename + * from dri_* to drm_intel_* + */ +#define dri_bo drm_intel_bo +#define dri_bufmgr drm_intel_bufmgr +#define dri_bo_alloc drm_intel_bo_alloc +#define dri_bo_reference drm_intel_bo_reference +#define dri_bo_unreference drm_intel_bo_unreference +#define dri_bo_map drm_intel_bo_map +#define dri_bo_unmap drm_intel_bo_unmap +#define dri_bo_subdata drm_intel_bo_subdata +#define dri_bo_get_subdata drm_intel_bo_get_subdata +#define dri_bo_wait_rendering drm_intel_bo_wait_rendering +#define dri_bufmgr_set_debug drm_intel_bufmgr_set_debug +#define dri_bufmgr_destroy drm_intel_bufmgr_destroy +#define dri_bo_exec drm_intel_bo_exec +#define dri_bufmgr_check_aperture_space drm_intel_bufmgr_check_aperture_space +#define dri_bo_emit_reloc(reloc_bo, read, write, target_offset, \ + reloc_offset, target_bo) \ + drm_intel_bo_emit_reloc(reloc_bo, reloc_offset, \ + target_bo, target_offset, \ + read, write); +#define dri_bo_pin drm_intel_bo_pin +#define dri_bo_unpin drm_intel_bo_unpin +#define dri_bo_get_tiling drm_intel_bo_get_tiling +#define dri_bo_set_tiling(bo, mode) drm_intel_bo_set_tiling(bo, mode, 0) +#define dri_bo_flink drm_intel_bo_flink +#define intel_bufmgr_gem_init drm_intel_bufmgr_gem_init +#define intel_bo_gem_create_from_name drm_intel_bo_gem_create_from_name +#define intel_bufmgr_gem_enable_reuse drm_intel_bufmgr_gem_enable_reuse +#define intel_bufmgr_fake_init drm_intel_bufmgr_fake_init +#define intel_bufmgr_fake_set_last_dispatch drm_intel_bufmgr_fake_set_last_dispatch +#define intel_bufmgr_fake_set_exec_callback drm_intel_bufmgr_fake_set_exec_callback +#define intel_bufmgr_fake_set_fence_callback drm_intel_bufmgr_fake_set_fence_callback +#define intel_bo_fake_alloc_static drm_intel_bo_fake_alloc_static +#define intel_bo_fake_disable_backing_store drm_intel_bo_fake_disable_backing_store +#define intel_bufmgr_fake_contended_lock_take drm_intel_bufmgr_fake_contended_lock_take +#define intel_bufmgr_fake_evict_all drm_intel_bufmgr_fake_evict_all + +/** @{ */ #endif /* INTEL_BUFMGR_H */ diff --git a/libdrm/intel/intel_bufmgr_fake.c b/libdrm/intel/intel_bufmgr_fake.c index c9545b35..6d8ee85a 100644 --- a/libdrm/intel/intel_bufmgr_fake.c +++ b/libdrm/intel/intel_bufmgr_fake.c @@ -75,7 +75,7 @@ struct fake_buffer_reloc { /** Buffer object that the relocation points at. */ - dri_bo *target_buf; + drm_intel_bo *target_buf; /** Offset of the relocation entry within reloc_buf. */ uint32_t offset; /** Cached value of the offset when we last performed this relocation. */ @@ -106,12 +106,12 @@ struct block { /** Fence cookie for the block. */ unsigned fence; /* Split to read_fence, write_fence */ - dri_bo *bo; + drm_intel_bo *bo; void *virtual; }; typedef struct _bufmgr_fake { - dri_bufmgr bufmgr; + drm_intel_bufmgr bufmgr; pthread_mutex_t lock; @@ -163,7 +163,7 @@ typedef struct _bufmgr_fake { * This allows the driver to hook in a replacement for the DRM usage in * bufmgr_fake. */ - int (*exec)(dri_bo *bo, unsigned int used, void *priv); + int (*exec)(drm_intel_bo *bo, unsigned int used, void *priv); void *exec_priv; /** Driver-supplied argument to driver callbacks */ @@ -176,10 +176,10 @@ typedef struct _bufmgr_fake { int debug; int performed_rendering; -} dri_bufmgr_fake; +} drm_intel_bufmgr_fake; -typedef struct _dri_bo_fake { - dri_bo bo; +typedef struct _drm_intel_bo_fake { + drm_intel_bo bo; unsigned id; /* debug only */ const char *name; @@ -214,11 +214,11 @@ typedef struct _dri_bo_fake { struct block *block; void *backing_store; - void (*invalidate_cb)(dri_bo *bo, void *ptr); + void (*invalidate_cb)(drm_intel_bo *bo, void *ptr); void *invalidate_ptr; -} dri_bo_fake; +} drm_intel_bo_fake; -static int clear_fenced(dri_bufmgr_fake *bufmgr_fake, +static int clear_fenced(drm_intel_bufmgr_fake *bufmgr_fake, unsigned int fence_cookie); #define MAXFENCE 0x7fffffff @@ -237,13 +237,13 @@ static int FENCE_LTE( unsigned a, unsigned b ) return 0; } -void intel_bufmgr_fake_set_fence_callback(dri_bufmgr *bufmgr, - unsigned int (*emit)(void *priv), - void (*wait)(unsigned int fence, - void *priv), - void *priv) +void drm_intel_bufmgr_fake_set_fence_callback(drm_intel_bufmgr *bufmgr, + unsigned int (*emit)(void *priv), + void (*wait)(unsigned int fence, + void *priv), + void *priv) { - dri_bufmgr_fake *bufmgr_fake = (dri_bufmgr_fake *)bufmgr; + drm_intel_bufmgr_fake *bufmgr_fake = (drm_intel_bufmgr_fake *)bufmgr; bufmgr_fake->fence_emit = emit; bufmgr_fake->fence_wait = wait; @@ -251,7 +251,7 @@ void intel_bufmgr_fake_set_fence_callback(dri_bufmgr *bufmgr, } static unsigned int -_fence_emit_internal(dri_bufmgr_fake *bufmgr_fake) +_fence_emit_internal(drm_intel_bufmgr_fake *bufmgr_fake) { struct drm_i915_irq_emit ie; int ret, seq = 1; @@ -274,7 +274,7 @@ _fence_emit_internal(dri_bufmgr_fake *bufmgr_fake) } static void -_fence_wait_internal(dri_bufmgr_fake *bufmgr_fake, int seq) +_fence_wait_internal(drm_intel_bufmgr_fake *bufmgr_fake, int seq) { struct drm_i915_irq_wait iw; int hw_seq, busy_count = 0; @@ -397,7 +397,7 @@ _fence_wait_internal(dri_bufmgr_fake *bufmgr_fake, int seq) } static int -_fence_test(dri_bufmgr_fake *bufmgr_fake, unsigned fence) +_fence_test(drm_intel_bufmgr_fake *bufmgr_fake, unsigned fence) { /* Slight problem with wrap-around: */ @@ -408,10 +408,10 @@ _fence_test(dri_bufmgr_fake *bufmgr_fake, unsigned fence) * Allocate a memory manager block for the buffer. */ static int -alloc_block(dri_bo *bo) +alloc_block(drm_intel_bo *bo) { - dri_bo_fake *bo_fake = (dri_bo_fake *)bo; - dri_bufmgr_fake *bufmgr_fake= (dri_bufmgr_fake *)bo->bufmgr; + drm_intel_bo_fake *bo_fake = (drm_intel_bo_fake *)bo; + drm_intel_bufmgr_fake *bufmgr_fake= (drm_intel_bufmgr_fake *)bo->bufmgr; struct block *block = (struct block *)calloc(sizeof *block, 1); unsigned int align_log2 = ffs(bo_fake->alignment) - 1; unsigned int sz; @@ -444,15 +444,15 @@ alloc_block(dri_bo *bo) /* Release the card storage associated with buf: */ -static void free_block(dri_bufmgr_fake *bufmgr_fake, struct block *block) +static void free_block(drm_intel_bufmgr_fake *bufmgr_fake, struct block *block) { - dri_bo_fake *bo_fake; + drm_intel_bo_fake *bo_fake; DBG("free block %p %08x %d %d\n", block, block->mem->ofs, block->on_hardware, block->fenced); if (!block) return; - bo_fake = (dri_bo_fake *)block->bo; + bo_fake = (drm_intel_bo_fake *)block->bo; if (!(bo_fake->flags & (BM_PINNED | BM_NO_BACKING_STORE)) && (bo_fake->card_dirty == 1)) { memcpy(bo_fake->backing_store, block->virtual, block->bo->size); bo_fake->card_dirty = 0; @@ -475,10 +475,10 @@ static void free_block(dri_bufmgr_fake *bufmgr_fake, struct block *block) } static void -alloc_backing_store(dri_bo *bo) +alloc_backing_store(drm_intel_bo *bo) { - dri_bufmgr_fake *bufmgr_fake = (dri_bufmgr_fake *)bo->bufmgr; - dri_bo_fake *bo_fake = (dri_bo_fake *)bo; + drm_intel_bufmgr_fake *bufmgr_fake = (drm_intel_bufmgr_fake *)bo->bufmgr; + drm_intel_bo_fake *bo_fake = (drm_intel_bo_fake *)bo; assert(!bo_fake->backing_store); assert(!(bo_fake->flags & (BM_PINNED|BM_NO_BACKING_STORE))); @@ -489,9 +489,9 @@ alloc_backing_store(dri_bo *bo) } static void -free_backing_store(dri_bo *bo) +free_backing_store(drm_intel_bo *bo) { - dri_bo_fake *bo_fake = (dri_bo_fake *)bo; + drm_intel_bo_fake *bo_fake = (drm_intel_bo_fake *)bo; if (bo_fake->backing_store) { assert(!(bo_fake->flags & (BM_PINNED|BM_NO_BACKING_STORE))); @@ -501,10 +501,10 @@ free_backing_store(dri_bo *bo) } static void -set_dirty(dri_bo *bo) +set_dirty(drm_intel_bo *bo) { - dri_bufmgr_fake *bufmgr_fake = (dri_bufmgr_fake *)bo->bufmgr; - dri_bo_fake *bo_fake = (dri_bo_fake *)bo; + drm_intel_bufmgr_fake *bufmgr_fake = (drm_intel_bufmgr_fake *)bo->bufmgr; + drm_intel_bo_fake *bo_fake = (drm_intel_bo_fake *)bo; if (bo_fake->flags & BM_NO_BACKING_STORE && bo_fake->invalidate_cb != NULL) bo_fake->invalidate_cb(bo, bo_fake->invalidate_ptr); @@ -516,14 +516,14 @@ set_dirty(dri_bo *bo) } static int -evict_lru(dri_bufmgr_fake *bufmgr_fake, unsigned int max_fence) +evict_lru(drm_intel_bufmgr_fake *bufmgr_fake, unsigned int max_fence) { struct block *block, *tmp; DBG("%s\n", __FUNCTION__); DRMLISTFOREACHSAFE(block, tmp, &bufmgr_fake->lru) { - dri_bo_fake *bo_fake = (dri_bo_fake *)block->bo; + drm_intel_bo_fake *bo_fake = (drm_intel_bo_fake *)block->bo; if (bo_fake != NULL && (bo_fake->flags & BM_NO_FENCE_SUBDATA)) continue; @@ -542,14 +542,14 @@ evict_lru(dri_bufmgr_fake *bufmgr_fake, unsigned int max_fence) } static int -evict_mru(dri_bufmgr_fake *bufmgr_fake) +evict_mru(drm_intel_bufmgr_fake *bufmgr_fake) { struct block *block, *tmp; DBG("%s\n", __FUNCTION__); DRMLISTFOREACHSAFEREVERSE(block, tmp, &bufmgr_fake->lru) { - dri_bo_fake *bo_fake = (dri_bo_fake *)block->bo; + drm_intel_bo_fake *bo_fake = (drm_intel_bo_fake *)block->bo; if (bo_fake && (bo_fake->flags & BM_NO_FENCE_SUBDATA)) continue; @@ -567,7 +567,7 @@ evict_mru(dri_bufmgr_fake *bufmgr_fake) /** * Removes all objects from the fenced list older than the given fence. */ -static int clear_fenced(dri_bufmgr_fake *bufmgr_fake, +static int clear_fenced(drm_intel_bufmgr_fake *bufmgr_fake, unsigned int fence_cookie) { struct block *block, *tmp; @@ -611,7 +611,7 @@ static int clear_fenced(dri_bufmgr_fake *bufmgr_fake, return ret; } -static void fence_blocks(dri_bufmgr_fake *bufmgr_fake, unsigned fence) +static void fence_blocks(drm_intel_bufmgr_fake *bufmgr_fake, unsigned fence) { struct block *block, *tmp; @@ -632,10 +632,10 @@ static void fence_blocks(dri_bufmgr_fake *bufmgr_fake, unsigned fence) assert(DRMLISTEMPTY(&bufmgr_fake->on_hardware)); } -static int evict_and_alloc_block(dri_bo *bo) +static int evict_and_alloc_block(drm_intel_bo *bo) { - dri_bufmgr_fake *bufmgr_fake = (dri_bufmgr_fake *)bo->bufmgr; - dri_bo_fake *bo_fake = (dri_bo_fake *)bo; + drm_intel_bufmgr_fake *bufmgr_fake = (drm_intel_bufmgr_fake *)bo->bufmgr; + drm_intel_bo_fake *bo_fake = (drm_intel_bo_fake *)bo; assert(bo_fake->block == NULL); @@ -702,7 +702,7 @@ static int evict_and_alloc_block(dri_bo *bo) * Wait for hardware idle by emitting a fence and waiting for it. */ static void -dri_bufmgr_fake_wait_idle(dri_bufmgr_fake *bufmgr_fake) +drm_intel_bufmgr_fake_wait_idle(drm_intel_bufmgr_fake *bufmgr_fake) { unsigned int cookie; @@ -717,10 +717,10 @@ dri_bufmgr_fake_wait_idle(dri_bufmgr_fake *bufmgr_fake) * the necessary flushing. */ static void -dri_fake_bo_wait_rendering_locked(dri_bo *bo) +drm_intel_fake_bo_wait_rendering_locked(drm_intel_bo *bo) { - dri_bufmgr_fake *bufmgr_fake = (dri_bufmgr_fake *)bo->bufmgr; - dri_bo_fake *bo_fake = (dri_bo_fake *)bo; + drm_intel_bufmgr_fake *bufmgr_fake = (drm_intel_bufmgr_fake *)bo->bufmgr; + drm_intel_bo_fake *bo_fake = (drm_intel_bo_fake *)bo; if (bo_fake->block == NULL || !bo_fake->block->fenced) return; @@ -729,12 +729,12 @@ dri_fake_bo_wait_rendering_locked(dri_bo *bo) } static void -dri_fake_bo_wait_rendering(dri_bo *bo) +drm_intel_fake_bo_wait_rendering(drm_intel_bo *bo) { - dri_bufmgr_fake *bufmgr_fake = (dri_bufmgr_fake *)bo->bufmgr; + drm_intel_bufmgr_fake *bufmgr_fake = (drm_intel_bufmgr_fake *)bo->bufmgr; pthread_mutex_lock(&bufmgr_fake->lock); - dri_fake_bo_wait_rendering_locked(bo); + drm_intel_fake_bo_wait_rendering_locked(bo); pthread_mutex_unlock(&bufmgr_fake->lock); } @@ -743,9 +743,9 @@ dri_fake_bo_wait_rendering(dri_bo *bo) * -- and wait for idle */ void -intel_bufmgr_fake_contended_lock_take(dri_bufmgr *bufmgr) +drm_intel_bufmgr_fake_contended_lock_take(drm_intel_bufmgr *bufmgr) { - dri_bufmgr_fake *bufmgr_fake = (dri_bufmgr_fake *)bufmgr; + drm_intel_bufmgr_fake *bufmgr_fake = (drm_intel_bufmgr_fake *)bufmgr; struct block *block, *tmp; pthread_mutex_lock(&bufmgr_fake->lock); @@ -757,7 +757,7 @@ intel_bufmgr_fake_contended_lock_take(dri_bufmgr *bufmgr) * happening, so we'll need to wait anyway before letting anything get * put on the card again. */ - dri_bufmgr_fake_wait_idle(bufmgr_fake); + drm_intel_bufmgr_fake_wait_idle(bufmgr_fake); /* Check that we hadn't released the lock without having fenced the last * set of buffers. @@ -773,14 +773,14 @@ intel_bufmgr_fake_contended_lock_take(dri_bufmgr *bufmgr) pthread_mutex_unlock(&bufmgr_fake->lock); } -static dri_bo * -dri_fake_bo_alloc(dri_bufmgr *bufmgr, const char *name, - unsigned long size, unsigned int alignment) +static drm_intel_bo * +drm_intel_fake_bo_alloc(drm_intel_bufmgr *bufmgr, const char *name, + unsigned long size, unsigned int alignment) { - dri_bufmgr_fake *bufmgr_fake; - dri_bo_fake *bo_fake; + drm_intel_bufmgr_fake *bufmgr_fake; + drm_intel_bo_fake *bo_fake; - bufmgr_fake = (dri_bufmgr_fake *)bufmgr; + bufmgr_fake = (drm_intel_bufmgr_fake *)bufmgr; assert(size != 0); @@ -810,15 +810,15 @@ dri_fake_bo_alloc(dri_bufmgr *bufmgr, const char *name, return &bo_fake->bo; } -dri_bo * -intel_bo_fake_alloc_static(dri_bufmgr *bufmgr, const char *name, - unsigned long offset, unsigned long size, - void *virtual) +drm_intel_bo * +drm_intel_bo_fake_alloc_static(drm_intel_bufmgr *bufmgr, const char *name, + unsigned long offset, unsigned long size, + void *virtual) { - dri_bufmgr_fake *bufmgr_fake; - dri_bo_fake *bo_fake; + drm_intel_bufmgr_fake *bufmgr_fake; + drm_intel_bo_fake *bo_fake; - bufmgr_fake = (dri_bufmgr_fake *)bufmgr; + bufmgr_fake = (drm_intel_bufmgr_fake *)bufmgr; assert(size != 0); @@ -843,10 +843,10 @@ intel_bo_fake_alloc_static(dri_bufmgr *bufmgr, const char *name, } static void -dri_fake_bo_reference(dri_bo *bo) +drm_intel_fake_bo_reference(drm_intel_bo *bo) { - dri_bufmgr_fake *bufmgr_fake = (dri_bufmgr_fake *)bo->bufmgr; - dri_bo_fake *bo_fake = (dri_bo_fake *)bo; + drm_intel_bufmgr_fake *bufmgr_fake = (drm_intel_bufmgr_fake *)bo->bufmgr; + drm_intel_bo_fake *bo_fake = (drm_intel_bo_fake *)bo; pthread_mutex_lock(&bufmgr_fake->lock); bo_fake->refcount++; @@ -854,18 +854,18 @@ dri_fake_bo_reference(dri_bo *bo) } static void -dri_fake_bo_reference_locked(dri_bo *bo) +drm_intel_fake_bo_reference_locked(drm_intel_bo *bo) { - dri_bo_fake *bo_fake = (dri_bo_fake *)bo; + drm_intel_bo_fake *bo_fake = (drm_intel_bo_fake *)bo; bo_fake->refcount++; } static void -dri_fake_bo_unreference_locked(dri_bo *bo) +drm_intel_fake_bo_unreference_locked(drm_intel_bo *bo) { - dri_bufmgr_fake *bufmgr_fake = (dri_bufmgr_fake *)bo->bufmgr; - dri_bo_fake *bo_fake = (dri_bo_fake *)bo; + drm_intel_bufmgr_fake *bufmgr_fake = (drm_intel_bufmgr_fake *)bo->bufmgr; + drm_intel_bo_fake *bo_fake = (drm_intel_bo_fake *)bo; int i; if (--bo_fake->refcount == 0) { @@ -876,7 +876,7 @@ dri_fake_bo_unreference_locked(dri_bo *bo) free_backing_store(bo); for (i = 0; i < bo_fake->nr_relocs; i++) - dri_fake_bo_unreference_locked(bo_fake->relocs[i].target_buf); + drm_intel_fake_bo_unreference_locked(bo_fake->relocs[i].target_buf); DBG("drm_bo_unreference: free buf %d %s\n", bo_fake->id, bo_fake->name); @@ -886,12 +886,12 @@ dri_fake_bo_unreference_locked(dri_bo *bo) } static void -dri_fake_bo_unreference(dri_bo *bo) +drm_intel_fake_bo_unreference(drm_intel_bo *bo) { - dri_bufmgr_fake *bufmgr_fake = (dri_bufmgr_fake *)bo->bufmgr; + drm_intel_bufmgr_fake *bufmgr_fake = (drm_intel_bufmgr_fake *)bo->bufmgr; pthread_mutex_lock(&bufmgr_fake->lock); - dri_fake_bo_unreference_locked(bo); + drm_intel_fake_bo_unreference_locked(bo); pthread_mutex_unlock(&bufmgr_fake->lock); } @@ -899,13 +899,13 @@ dri_fake_bo_unreference(dri_bo *bo) * Set the buffer as not requiring backing store, and instead get the callback * invoked whenever it would be set dirty. */ -void intel_bo_fake_disable_backing_store(dri_bo *bo, - void (*invalidate_cb)(dri_bo *bo, - void *ptr), - void *ptr) +void drm_intel_bo_fake_disable_backing_store(drm_intel_bo *bo, + void (*invalidate_cb)(drm_intel_bo *bo, + void *ptr), + void *ptr) { - dri_bufmgr_fake *bufmgr_fake = (dri_bufmgr_fake *)bo->bufmgr; - dri_bo_fake *bo_fake = (dri_bo_fake *)bo; + drm_intel_bufmgr_fake *bufmgr_fake = (drm_intel_bufmgr_fake *)bo->bufmgr; + drm_intel_bo_fake *bo_fake = (drm_intel_bo_fake *)bo; pthread_mutex_lock(&bufmgr_fake->lock); @@ -934,15 +934,15 @@ void intel_bo_fake_disable_backing_store(dri_bo *bo, * BM_NO_BACKING_STORE or BM_PINNED) or backing store, as necessary. */ static int -dri_fake_bo_map_locked(dri_bo *bo, int write_enable) +drm_intel_fake_bo_map_locked(drm_intel_bo *bo, int write_enable) { - dri_bufmgr_fake *bufmgr_fake = (dri_bufmgr_fake *)bo->bufmgr; - dri_bo_fake *bo_fake = (dri_bo_fake *)bo; + drm_intel_bufmgr_fake *bufmgr_fake = (drm_intel_bufmgr_fake *)bo->bufmgr; + drm_intel_bo_fake *bo_fake = (drm_intel_bo_fake *)bo; /* Static buffers are always mapped. */ if (bo_fake->is_static) { if (bo_fake->card_dirty) { - dri_bufmgr_fake_wait_idle(bufmgr_fake); + drm_intel_bufmgr_fake_wait_idle(bufmgr_fake); bo_fake->card_dirty = 0; } return 0; @@ -976,7 +976,7 @@ dri_fake_bo_map_locked(dri_bo *bo, int write_enable) if (!(bo_fake->flags & BM_NO_FENCE_SUBDATA) && bo_fake->block->fenced) { - dri_fake_bo_wait_rendering_locked(bo); + drm_intel_fake_bo_wait_rendering_locked(bo); } bo->virtual = bo_fake->block->virtual; @@ -991,7 +991,7 @@ dri_fake_bo_map_locked(dri_bo *bo, int write_enable) if ((bo_fake->card_dirty == 1) && bo_fake->block) { if (bo_fake->block->fenced) - dri_fake_bo_wait_rendering_locked(bo); + drm_intel_fake_bo_wait_rendering_locked(bo); memcpy(bo_fake->backing_store, bo_fake->block->virtual, bo_fake->block->bo->size); bo_fake->card_dirty = 0; @@ -1005,23 +1005,23 @@ dri_fake_bo_map_locked(dri_bo *bo, int write_enable) } static int -dri_fake_bo_map(dri_bo *bo, int write_enable) +drm_intel_fake_bo_map(drm_intel_bo *bo, int write_enable) { - dri_bufmgr_fake *bufmgr_fake = (dri_bufmgr_fake *)bo->bufmgr; + drm_intel_bufmgr_fake *bufmgr_fake = (drm_intel_bufmgr_fake *)bo->bufmgr; int ret; pthread_mutex_lock(&bufmgr_fake->lock); - ret = dri_fake_bo_map_locked(bo, write_enable); + ret = drm_intel_fake_bo_map_locked(bo, write_enable); pthread_mutex_unlock(&bufmgr_fake->lock); return ret; } static int -dri_fake_bo_unmap_locked(dri_bo *bo) +drm_intel_fake_bo_unmap_locked(drm_intel_bo *bo) { - dri_bufmgr_fake *bufmgr_fake = (dri_bufmgr_fake *)bo->bufmgr; - dri_bo_fake *bo_fake = (dri_bo_fake *)bo; + drm_intel_bufmgr_fake *bufmgr_fake = (drm_intel_bufmgr_fake *)bo->bufmgr; + drm_intel_bo_fake *bo_fake = (drm_intel_bo_fake *)bo; /* Static buffers are always mapped. */ if (bo_fake->is_static) @@ -1040,20 +1040,20 @@ dri_fake_bo_unmap_locked(dri_bo *bo) } static int -dri_fake_bo_unmap(dri_bo *bo) +drm_intel_fake_bo_unmap(drm_intel_bo *bo) { - dri_bufmgr_fake *bufmgr_fake = (dri_bufmgr_fake *)bo->bufmgr; + drm_intel_bufmgr_fake *bufmgr_fake = (drm_intel_bufmgr_fake *)bo->bufmgr; int ret; pthread_mutex_lock(&bufmgr_fake->lock); - ret = dri_fake_bo_unmap_locked(bo); + ret = drm_intel_fake_bo_unmap_locked(bo); pthread_mutex_unlock(&bufmgr_fake->lock); return ret; } static void -dri_fake_kick_all_locked(dri_bufmgr_fake *bufmgr_fake) +drm_intel_fake_kick_all_locked(drm_intel_bufmgr_fake *bufmgr_fake) { struct block *block, *tmp; @@ -1061,7 +1061,7 @@ dri_fake_kick_all_locked(dri_bufmgr_fake *bufmgr_fake) /* okay for ever BO that is on the HW kick it off. seriously not afraid of the POLICE right now */ DRMLISTFOREACHSAFE(block, tmp, &bufmgr_fake->on_hardware) { - dri_bo_fake *bo_fake = (dri_bo_fake *)block->bo; + drm_intel_bo_fake *bo_fake = (drm_intel_bo_fake *)block->bo; block->on_hardware = 0; free_block(bufmgr_fake, block); @@ -1074,12 +1074,12 @@ dri_fake_kick_all_locked(dri_bufmgr_fake *bufmgr_fake) } static int -dri_fake_bo_validate(dri_bo *bo) +drm_intel_fake_bo_validate(drm_intel_bo *bo) { - dri_bufmgr_fake *bufmgr_fake; - dri_bo_fake *bo_fake = (dri_bo_fake *)bo; + drm_intel_bufmgr_fake *bufmgr_fake; + drm_intel_bo_fake *bo_fake = (drm_intel_bo_fake *)bo; - bufmgr_fake = (dri_bufmgr_fake *)bo->bufmgr; + bufmgr_fake = (drm_intel_bufmgr_fake *)bo->bufmgr; DBG("drm_bo_validate: (buf %d: %s, %d kb)\n", bo_fake->id, bo_fake->name, bo_fake->bo.size / 1024); @@ -1120,7 +1120,7 @@ dri_fake_bo_validate(dri_bo *bo) * which we would be tracking when we free it. Waiting for idle is * a sufficiently large hammer for now. */ - dri_bufmgr_fake_wait_idle(bufmgr_fake); + drm_intel_bufmgr_fake_wait_idle(bufmgr_fake); /* we may never have mapped this BO so it might not have any backing * store if this happens it should be rare, but 0 the card memory @@ -1145,9 +1145,9 @@ dri_fake_bo_validate(dri_bo *bo) } static void -dri_fake_fence_validated(dri_bufmgr *bufmgr) +drm_intel_fake_fence_validated(drm_intel_bufmgr *bufmgr) { - dri_bufmgr_fake *bufmgr_fake = (dri_bufmgr_fake *)bufmgr; + drm_intel_bufmgr_fake *bufmgr_fake = (drm_intel_bufmgr_fake *)bufmgr; unsigned int cookie; cookie = _fence_emit_internal(bufmgr_fake); @@ -1157,9 +1157,9 @@ dri_fake_fence_validated(dri_bufmgr *bufmgr) } static void -dri_fake_destroy(dri_bufmgr *bufmgr) +drm_intel_fake_destroy(drm_intel_bufmgr *bufmgr) { - dri_bufmgr_fake *bufmgr_fake = (dri_bufmgr_fake *)bufmgr; + drm_intel_bufmgr_fake *bufmgr_fake = (drm_intel_bufmgr_fake *)bufmgr; pthread_mutex_destroy(&bufmgr_fake->lock); mmDestroy(bufmgr_fake->heap); @@ -1167,47 +1167,46 @@ dri_fake_destroy(dri_bufmgr *bufmgr) } static int -dri_fake_emit_reloc(dri_bo *reloc_buf, - uint32_t read_domains, uint32_t write_domain, - uint32_t delta, uint32_t offset, dri_bo *target_buf) +drm_intel_fake_emit_reloc(drm_intel_bo *bo, uint32_t offset, + drm_intel_bo *target_bo, uint32_t target_offset, + uint32_t read_domains, uint32_t write_domain) { - dri_bufmgr_fake *bufmgr_fake = (dri_bufmgr_fake *)reloc_buf->bufmgr; + drm_intel_bufmgr_fake *bufmgr_fake = (drm_intel_bufmgr_fake *)bo->bufmgr; struct fake_buffer_reloc *r; - dri_bo_fake *reloc_fake = (dri_bo_fake *)reloc_buf; - dri_bo_fake *target_fake = (dri_bo_fake *)target_buf; + drm_intel_bo_fake *bo_fake = (drm_intel_bo_fake *)bo; + drm_intel_bo_fake *target_fake = (drm_intel_bo_fake *)target_bo; int i; pthread_mutex_lock(&bufmgr_fake->lock); - assert(reloc_buf); - assert(target_buf); + assert(bo); + assert(target_bo); - if (reloc_fake->relocs == NULL) { - reloc_fake->relocs = malloc(sizeof(struct fake_buffer_reloc) * - MAX_RELOCS); + if (bo_fake->relocs == NULL) { + bo_fake->relocs = malloc(sizeof(struct fake_buffer_reloc) * MAX_RELOCS); } - r = &reloc_fake->relocs[reloc_fake->nr_relocs++]; + r = &bo_fake->relocs[bo_fake->nr_relocs++]; - assert(reloc_fake->nr_relocs <= MAX_RELOCS); + assert(bo_fake->nr_relocs <= MAX_RELOCS); - dri_fake_bo_reference_locked(target_buf); + drm_intel_fake_bo_reference_locked(target_bo); if (!target_fake->is_static) { - reloc_fake->child_size += ALIGN(target_buf->size, target_fake->alignment); - reloc_fake->child_size += target_fake->child_size; + bo_fake->child_size += ALIGN(target_bo->size, target_fake->alignment); + bo_fake->child_size += target_fake->child_size; } - r->target_buf = target_buf; + r->target_buf = target_bo; r->offset = offset; - r->last_target_offset = target_buf->offset; - r->delta = delta; + r->last_target_offset = target_bo->offset; + r->delta = target_offset; r->read_domains = read_domains; r->write_domain = write_domain; if (bufmgr_fake->debug) { /* Check that a conflicting relocation hasn't already been emitted. */ - for (i = 0; i < reloc_fake->nr_relocs - 1; i++) { - struct fake_buffer_reloc *r2 = &reloc_fake->relocs[i]; + for (i = 0; i < bo_fake->nr_relocs - 1; i++) { + struct fake_buffer_reloc *r2 = &bo_fake->relocs[i]; assert(r->offset != r2->offset); } @@ -1223,17 +1222,17 @@ dri_fake_emit_reloc(dri_bo *reloc_buf, * the combined validation flags for the buffer on this batchbuffer submission. */ static void -dri_fake_calculate_domains(dri_bo *bo) +drm_intel_fake_calculate_domains(drm_intel_bo *bo) { - dri_bo_fake *bo_fake = (dri_bo_fake *)bo; + drm_intel_bo_fake *bo_fake = (drm_intel_bo_fake *)bo; int i; for (i = 0; i < bo_fake->nr_relocs; i++) { struct fake_buffer_reloc *r = &bo_fake->relocs[i]; - dri_bo_fake *target_fake = (dri_bo_fake *)r->target_buf; + drm_intel_bo_fake *target_fake = (drm_intel_bo_fake *)r->target_buf; /* Do the same for the tree of buffers we depend on */ - dri_fake_calculate_domains(r->target_buf); + drm_intel_fake_calculate_domains(r->target_buf); target_fake->read_domains |= r->read_domains; target_fake->write_domain |= r->write_domain; @@ -1242,25 +1241,25 @@ dri_fake_calculate_domains(dri_bo *bo) static int -dri_fake_reloc_and_validate_buffer(dri_bo *bo) +drm_intel_fake_reloc_and_validate_buffer(drm_intel_bo *bo) { - dri_bufmgr_fake *bufmgr_fake = (dri_bufmgr_fake *)bo->bufmgr; - dri_bo_fake *bo_fake = (dri_bo_fake *)bo; + drm_intel_bufmgr_fake *bufmgr_fake = (drm_intel_bufmgr_fake *)bo->bufmgr; + drm_intel_bo_fake *bo_fake = (drm_intel_bo_fake *)bo; int i, ret; assert(bo_fake->map_count == 0); for (i = 0; i < bo_fake->nr_relocs; i++) { struct fake_buffer_reloc *r = &bo_fake->relocs[i]; - dri_bo_fake *target_fake = (dri_bo_fake *)r->target_buf; + drm_intel_bo_fake *target_fake = (drm_intel_bo_fake *)r->target_buf; uint32_t reloc_data; /* Validate the target buffer if that hasn't been done. */ if (!target_fake->validated) { - ret = dri_fake_reloc_and_validate_buffer(r->target_buf); + ret = drm_intel_fake_reloc_and_validate_buffer(r->target_buf); if (ret != 0) { if (bo->virtual != NULL) - dri_fake_bo_unmap_locked(bo); + drm_intel_fake_bo_unmap_locked(bo); return ret; } } @@ -1270,7 +1269,7 @@ dri_fake_reloc_and_validate_buffer(dri_bo *bo) reloc_data = r->target_buf->offset + r->delta; if (bo->virtual == NULL) - dri_fake_bo_map_locked(bo, 1); + drm_intel_fake_bo_map_locked(bo, 1); *(uint32_t *)((uint8_t *)bo->virtual + r->offset) = reloc_data; @@ -1279,7 +1278,7 @@ dri_fake_reloc_and_validate_buffer(dri_bo *bo) } if (bo->virtual != NULL) - dri_fake_bo_unmap_locked(bo); + drm_intel_fake_bo_unmap_locked(bo); if (bo_fake->write_domain != 0) { if (!(bo_fake->flags & (BM_NO_BACKING_STORE|BM_PINNED))) { @@ -1290,22 +1289,22 @@ dri_fake_reloc_and_validate_buffer(dri_bo *bo) bufmgr_fake->performed_rendering = 1; } - return dri_fake_bo_validate(bo); + return drm_intel_fake_bo_validate(bo); } static void -dri_bo_fake_post_submit(dri_bo *bo) +drm_intel_bo_fake_post_submit(drm_intel_bo *bo) { - dri_bufmgr_fake *bufmgr_fake = (dri_bufmgr_fake *)bo->bufmgr; - dri_bo_fake *bo_fake = (dri_bo_fake *)bo; + drm_intel_bufmgr_fake *bufmgr_fake = (drm_intel_bufmgr_fake *)bo->bufmgr; + drm_intel_bo_fake *bo_fake = (drm_intel_bo_fake *)bo; int i; for (i = 0; i < bo_fake->nr_relocs; i++) { struct fake_buffer_reloc *r = &bo_fake->relocs[i]; - dri_bo_fake *target_fake = (dri_bo_fake *)r->target_buf; + drm_intel_bo_fake *target_fake = (drm_intel_bo_fake *)r->target_buf; if (target_fake->validated) - dri_bo_fake_post_submit(r->target_buf); + drm_intel_bo_fake_post_submit(r->target_buf); DBG("%s@0x%08x + 0x%08x -> %s@0x%08x + 0x%08x\n", bo_fake->name, (uint32_t)bo->offset, r->offset, @@ -1319,25 +1318,25 @@ dri_bo_fake_post_submit(dri_bo *bo) } -void intel_bufmgr_fake_set_exec_callback(dri_bufmgr *bufmgr, - int (*exec)(dri_bo *bo, - unsigned int used, - void *priv), - void *priv) +void drm_intel_bufmgr_fake_set_exec_callback(drm_intel_bufmgr *bufmgr, + int (*exec)(drm_intel_bo *bo, + unsigned int used, + void *priv), + void *priv) { - dri_bufmgr_fake *bufmgr_fake = (dri_bufmgr_fake *)bufmgr; + drm_intel_bufmgr_fake *bufmgr_fake = (drm_intel_bufmgr_fake *)bufmgr; bufmgr_fake->exec = exec; bufmgr_fake->exec_priv = priv; } static int -dri_fake_bo_exec(dri_bo *bo, int used, - drm_clip_rect_t *cliprects, int num_cliprects, - int DR4) +drm_intel_fake_bo_exec(drm_intel_bo *bo, int used, + drm_clip_rect_t *cliprects, int num_cliprects, + int DR4) { - dri_bufmgr_fake *bufmgr_fake = (dri_bufmgr_fake *)bo->bufmgr; - dri_bo_fake *batch_fake = (dri_bo_fake *)bo; + drm_intel_bufmgr_fake *bufmgr_fake = (drm_intel_bufmgr_fake *)bo->bufmgr; + drm_intel_bo_fake *batch_fake = (drm_intel_bo_fake *)bo; struct drm_i915_batchbuffer batch; int ret; int retry_count = 0; @@ -1346,17 +1345,17 @@ dri_fake_bo_exec(dri_bo *bo, int used, bufmgr_fake->performed_rendering = 0; - dri_fake_calculate_domains(bo); + drm_intel_fake_calculate_domains(bo); batch_fake->read_domains = I915_GEM_DOMAIN_COMMAND; /* we've ran out of RAM so blow the whole lot away and retry */ restart: - ret = dri_fake_reloc_and_validate_buffer(bo); + ret = drm_intel_fake_reloc_and_validate_buffer(bo); if (bufmgr_fake->fail == 1) { if (retry_count == 0) { retry_count++; - dri_fake_kick_all_locked(bufmgr_fake); + drm_intel_fake_kick_all_locked(bufmgr_fake); bufmgr_fake->fail = 0; goto restart; } else /* dump out the memory here */ @@ -1387,9 +1386,9 @@ dri_fake_bo_exec(dri_bo *bo, int used, } } - dri_fake_fence_validated(bo->bufmgr); + drm_intel_fake_fence_validated(bo->bufmgr); - dri_bo_fake_post_submit(bo); + drm_intel_bo_fake_post_submit(bo); pthread_mutex_unlock(&bufmgr_fake->lock); @@ -1404,14 +1403,14 @@ dri_fake_bo_exec(dri_bo *bo, int used, * a set smaller than the aperture. */ static int -dri_fake_check_aperture_space(dri_bo **bo_array, int count) +drm_intel_fake_check_aperture_space(drm_intel_bo **bo_array, int count) { - dri_bufmgr_fake *bufmgr_fake = (dri_bufmgr_fake *)bo_array[0]->bufmgr; + drm_intel_bufmgr_fake *bufmgr_fake = (drm_intel_bufmgr_fake *)bo_array[0]->bufmgr; unsigned int sz = 0; int i; for (i = 0; i < count; i++) { - dri_bo_fake *bo_fake = (dri_bo_fake *)bo_array[i]; + drm_intel_bo_fake *bo_fake = (drm_intel_bo_fake *)bo_array[i]; if (bo_fake == NULL) continue; @@ -1440,9 +1439,9 @@ dri_fake_check_aperture_space(dri_bo **bo_array, int count) * own. */ void -intel_bufmgr_fake_evict_all(dri_bufmgr *bufmgr) +drm_intel_bufmgr_fake_evict_all(drm_intel_bufmgr *bufmgr) { - dri_bufmgr_fake *bufmgr_fake = (dri_bufmgr_fake *)bufmgr; + drm_intel_bufmgr_fake *bufmgr_fake = (drm_intel_bufmgr_fake *)bufmgr; struct block *block, *tmp; pthread_mutex_lock(&bufmgr_fake->lock); @@ -1454,7 +1453,7 @@ intel_bufmgr_fake_evict_all(dri_bufmgr *bufmgr) * happening, so we'll need to wait anyway before letting anything get * put on the card again. */ - dri_bufmgr_fake_wait_idle(bufmgr_fake); + drm_intel_bufmgr_fake_wait_idle(bufmgr_fake); /* Check that we hadn't released the lock without having fenced the last * set of buffers. @@ -1469,21 +1468,21 @@ intel_bufmgr_fake_evict_all(dri_bufmgr *bufmgr) pthread_mutex_unlock(&bufmgr_fake->lock); } -void intel_bufmgr_fake_set_last_dispatch(dri_bufmgr *bufmgr, +void drm_intel_bufmgr_fake_set_last_dispatch(drm_intel_bufmgr *bufmgr, volatile unsigned int *last_dispatch) { - dri_bufmgr_fake *bufmgr_fake = (dri_bufmgr_fake *)bufmgr; + drm_intel_bufmgr_fake *bufmgr_fake = (drm_intel_bufmgr_fake *)bufmgr; bufmgr_fake->last_dispatch = (volatile int *)last_dispatch; } -dri_bufmgr * -intel_bufmgr_fake_init(int fd, +drm_intel_bufmgr * +drm_intel_bufmgr_fake_init(int fd, unsigned long low_offset, void *low_virtual, unsigned long size, volatile unsigned int *last_dispatch) { - dri_bufmgr_fake *bufmgr_fake; + drm_intel_bufmgr_fake *bufmgr_fake; bufmgr_fake = calloc(1, sizeof(*bufmgr_fake)); @@ -1503,16 +1502,16 @@ intel_bufmgr_fake_init(int fd, bufmgr_fake->heap = mmInit(low_offset, size); /* Hook in methods */ - bufmgr_fake->bufmgr.bo_alloc = dri_fake_bo_alloc; - bufmgr_fake->bufmgr.bo_reference = dri_fake_bo_reference; - bufmgr_fake->bufmgr.bo_unreference = dri_fake_bo_unreference; - bufmgr_fake->bufmgr.bo_map = dri_fake_bo_map; - bufmgr_fake->bufmgr.bo_unmap = dri_fake_bo_unmap; - bufmgr_fake->bufmgr.bo_wait_rendering = dri_fake_bo_wait_rendering; - bufmgr_fake->bufmgr.bo_emit_reloc = dri_fake_emit_reloc; - bufmgr_fake->bufmgr.destroy = dri_fake_destroy; - bufmgr_fake->bufmgr.bo_exec = dri_fake_bo_exec; - bufmgr_fake->bufmgr.check_aperture_space = dri_fake_check_aperture_space; + bufmgr_fake->bufmgr.bo_alloc = drm_intel_fake_bo_alloc; + bufmgr_fake->bufmgr.bo_reference = drm_intel_fake_bo_reference; + bufmgr_fake->bufmgr.bo_unreference = drm_intel_fake_bo_unreference; + bufmgr_fake->bufmgr.bo_map = drm_intel_fake_bo_map; + bufmgr_fake->bufmgr.bo_unmap = drm_intel_fake_bo_unmap; + bufmgr_fake->bufmgr.bo_wait_rendering = drm_intel_fake_bo_wait_rendering; + bufmgr_fake->bufmgr.bo_emit_reloc = drm_intel_fake_emit_reloc; + bufmgr_fake->bufmgr.destroy = drm_intel_fake_destroy; + bufmgr_fake->bufmgr.bo_exec = drm_intel_fake_bo_exec; + bufmgr_fake->bufmgr.check_aperture_space = drm_intel_fake_check_aperture_space; bufmgr_fake->bufmgr.debug = 0; bufmgr_fake->fd = fd; diff --git a/libdrm/intel/intel_bufmgr_gem.c b/libdrm/intel/intel_bufmgr_gem.c index dd74659a..5eaf5f5a 100644 --- a/libdrm/intel/intel_bufmgr_gem.c +++ b/libdrm/intel/intel_bufmgr_gem.c @@ -60,10 +60,10 @@ fprintf(stderr, __VA_ARGS__); \ } while (0) -typedef struct _dri_bo_gem dri_bo_gem; +typedef struct _drm_intel_bo_gem drm_intel_bo_gem; -struct dri_gem_bo_bucket { - dri_bo_gem *head, **tail; +struct drm_intel_gem_bo_bucket { + drm_intel_bo_gem *head, **tail; /** * Limit on the number of entries in this bucket. * @@ -77,9 +77,9 @@ struct dri_gem_bo_bucket { /* Arbitrarily chosen, 16 means that the maximum size we'll cache for reuse * is 1 << 16 pages, or 256MB. */ -#define INTEL_GEM_BO_BUCKETS 16 -typedef struct _dri_bufmgr_gem { - dri_bufmgr bufmgr; +#define DRM_INTEL_GEM_BO_BUCKETS 16 +typedef struct _drm_intel_bufmgr_gem { + drm_intel_bufmgr bufmgr; int fd; @@ -88,18 +88,18 @@ typedef struct _dri_bufmgr_gem { pthread_mutex_t lock; struct drm_i915_gem_exec_object *exec_objects; - dri_bo **exec_bos; + drm_intel_bo **exec_bos; int exec_size; int exec_count; /** Array of lists of cached gem objects of power-of-two sizes */ - struct dri_gem_bo_bucket cache_bucket[INTEL_GEM_BO_BUCKETS]; + struct drm_intel_gem_bo_bucket cache_bucket[DRM_INTEL_GEM_BO_BUCKETS]; uint64_t gtt_size; -} dri_bufmgr_gem; +} drm_intel_bufmgr_gem; -struct _dri_bo_gem { - dri_bo bo; +struct _drm_intel_bo_gem { + drm_intel_bo bo; int refcount; /** Boolean whether the mmap ioctl has been called for this buffer yet. */ @@ -128,18 +128,18 @@ struct _dri_bo_gem { /** Array passed to the DRM containing relocation information. */ struct drm_i915_gem_relocation_entry *relocs; /** Array of bos corresponding to relocs[i].target_handle */ - dri_bo **reloc_target_bo; + drm_intel_bo **reloc_target_bo; /** Number of entries in relocs */ int reloc_count; /** Mapped address for the buffer */ void *virtual; /** free list */ - dri_bo_gem *next; + drm_intel_bo_gem *next; /** * Boolean of whether this BO and its children have been included in - * the current dri_bufmgr_check_aperture_space() total. + * the current drm_intel_bufmgr_check_aperture_space() total. */ char included_in_check_aperture; @@ -153,13 +153,13 @@ struct _dri_bo_gem { /** * Size in bytes of this buffer and its relocation descendents. * - * Used to avoid costly tree walking in dri_bufmgr_check_aperture in + * Used to avoid costly tree walking in drm_intel_bufmgr_check_aperture in * the common case. */ int reloc_tree_size; }; -static void dri_gem_bo_reference_locked(dri_bo *bo); +static void drm_intel_gem_bo_reference_locked(drm_intel_bo *bo); static int logbase2(int n) @@ -175,8 +175,9 @@ logbase2(int n) return log2; } -static struct dri_gem_bo_bucket * -dri_gem_bo_bucket_for_size(dri_bufmgr_gem *bufmgr_gem, unsigned long size) +static struct drm_intel_gem_bo_bucket * +drm_intel_gem_bo_bucket_for_size(drm_intel_bufmgr_gem *bufmgr_gem, + unsigned long size) { int i; @@ -189,20 +190,20 @@ dri_gem_bo_bucket_for_size(dri_bufmgr_gem *bufmgr_gem, unsigned long size) /* We always allocate in units of pages */ i = ffs(size / 4096) - 1; - if (i >= INTEL_GEM_BO_BUCKETS) + if (i >= DRM_INTEL_GEM_BO_BUCKETS) return NULL; return &bufmgr_gem->cache_bucket[i]; } -static void dri_gem_dump_validation_list(dri_bufmgr_gem *bufmgr_gem) +static void drm_intel_gem_dump_validation_list(drm_intel_bufmgr_gem *bufmgr_gem) { int i, j; for (i = 0; i < bufmgr_gem->exec_count; i++) { - dri_bo *bo = bufmgr_gem->exec_bos[i]; - dri_bo_gem *bo_gem = (dri_bo_gem *)bo; + drm_intel_bo *bo = bufmgr_gem->exec_bos[i]; + drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo; if (bo_gem->relocs == NULL) { DBG("%2d: %d (%s)\n", i, bo_gem->gem_handle, bo_gem->name); @@ -210,8 +211,8 @@ static void dri_gem_dump_validation_list(dri_bufmgr_gem *bufmgr_gem) } for (j = 0; j < bo_gem->reloc_count; j++) { - dri_bo *target_bo = bo_gem->reloc_target_bo[j]; - dri_bo_gem *target_gem = (dri_bo_gem *)target_bo; + drm_intel_bo *target_bo = bo_gem->reloc_target_bo[j]; + drm_intel_bo_gem *target_gem = (drm_intel_bo_gem *)target_bo; DBG("%2d: %d (%s)@0x%08llx -> %d (%s)@0x%08lx + 0x%08x\n", i, @@ -231,10 +232,10 @@ static void dri_gem_dump_validation_list(dri_bufmgr_gem *bufmgr_gem) * access flags. */ static void -intel_add_validate_buffer(dri_bo *bo) +drm_intel_add_validate_buffer(drm_intel_bo *bo) { - dri_bufmgr_gem *bufmgr_gem = (dri_bufmgr_gem *)bo->bufmgr; - dri_bo_gem *bo_gem = (dri_bo_gem *)bo; + drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bo->bufmgr; + drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo; int index; if (bo_gem->validate_index != -1) @@ -265,7 +266,7 @@ intel_add_validate_buffer(dri_bo *bo) bufmgr_gem->exec_objects[index].alignment = 0; bufmgr_gem->exec_objects[index].offset = 0; bufmgr_gem->exec_bos[index] = bo; - dri_gem_bo_reference_locked(bo); + drm_intel_gem_bo_reference_locked(bo); bufmgr_gem->exec_count++; } @@ -274,27 +275,28 @@ intel_add_validate_buffer(dri_bo *bo) sizeof(uint32_t)) static int -intel_setup_reloc_list(dri_bo *bo) +drm_intel_setup_reloc_list(drm_intel_bo *bo) { - dri_bo_gem *bo_gem = (dri_bo_gem *)bo; - dri_bufmgr_gem *bufmgr_gem = (dri_bufmgr_gem *)bo->bufmgr; + drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo; + drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bo->bufmgr; bo_gem->relocs = malloc(bufmgr_gem->max_relocs * sizeof(struct drm_i915_gem_relocation_entry)); - bo_gem->reloc_target_bo = malloc(bufmgr_gem->max_relocs * sizeof(dri_bo *)); + bo_gem->reloc_target_bo = malloc(bufmgr_gem->max_relocs * + sizeof(drm_intel_bo *)); return 0; } -static dri_bo * -dri_gem_bo_alloc(dri_bufmgr *bufmgr, const char *name, - unsigned long size, unsigned int alignment) +static drm_intel_bo * +drm_intel_gem_bo_alloc(drm_intel_bufmgr *bufmgr, const char *name, + unsigned long size, unsigned int alignment) { - dri_bufmgr_gem *bufmgr_gem = (dri_bufmgr_gem *)bufmgr; - dri_bo_gem *bo_gem; + drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bufmgr; + drm_intel_bo_gem *bo_gem; unsigned int page_size = getpagesize(); int ret; - struct dri_gem_bo_bucket *bucket; + struct drm_intel_gem_bo_bucket *bucket; int alloc_from_cache = 0; unsigned long bo_size; @@ -302,7 +304,7 @@ dri_gem_bo_alloc(dri_bufmgr *bufmgr, const char *name, bo_size = 1 << logbase2(size); if (bo_size < page_size) bo_size = page_size; - bucket = dri_gem_bo_bucket_for_size(bufmgr_gem, bo_size); + bucket = drm_intel_gem_bo_bucket_for_size(bufmgr_gem, bo_size); /* If we don't have caching at this size, don't actually round the * allocation up. @@ -366,17 +368,17 @@ dri_gem_bo_alloc(dri_bufmgr *bufmgr, const char *name, } /** - * Returns a dri_bo wrapping the given buffer object handle. + * Returns a drm_intel_bo wrapping the given buffer object handle. * * This can be used when one application needs to pass a buffer object * to another. */ -dri_bo * -intel_bo_gem_create_from_name(dri_bufmgr *bufmgr, const char *name, - unsigned int handle) +drm_intel_bo * +drm_intel_bo_gem_create_from_name(drm_intel_bufmgr *bufmgr, const char *name, + unsigned int handle) { - dri_bufmgr_gem *bufmgr_gem = (dri_bufmgr_gem *)bufmgr; - dri_bo_gem *bo_gem; + drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bufmgr; + drm_intel_bo_gem *bo_gem; int ret; struct drm_gem_open open_arg; @@ -409,10 +411,10 @@ intel_bo_gem_create_from_name(dri_bufmgr *bufmgr, const char *name, } static void -dri_gem_bo_reference(dri_bo *bo) +drm_intel_gem_bo_reference(drm_intel_bo *bo) { - dri_bufmgr_gem *bufmgr_gem = (dri_bufmgr_gem *)bo->bufmgr; - dri_bo_gem *bo_gem = (dri_bo_gem *)bo; + drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bo->bufmgr; + drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo; pthread_mutex_lock(&bufmgr_gem->lock); bo_gem->refcount++; @@ -420,18 +422,18 @@ dri_gem_bo_reference(dri_bo *bo) } static void -dri_gem_bo_reference_locked(dri_bo *bo) +drm_intel_gem_bo_reference_locked(drm_intel_bo *bo) { - dri_bo_gem *bo_gem = (dri_bo_gem *)bo; + drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo; bo_gem->refcount++; } static void -dri_gem_bo_free(dri_bo *bo) +drm_intel_gem_bo_free(drm_intel_bo *bo) { - dri_bufmgr_gem *bufmgr_gem = (dri_bufmgr_gem *)bo->bufmgr; - dri_bo_gem *bo_gem = (dri_bo_gem *)bo; + drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bo->bufmgr; + drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo; struct drm_gem_close close; int ret; @@ -450,20 +452,20 @@ dri_gem_bo_free(dri_bo *bo) } static void -dri_gem_bo_unreference_locked(dri_bo *bo) +drm_intel_gem_bo_unreference_locked(drm_intel_bo *bo) { - dri_bufmgr_gem *bufmgr_gem = (dri_bufmgr_gem *)bo->bufmgr; - dri_bo_gem *bo_gem = (dri_bo_gem *)bo; + drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bo->bufmgr; + drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo; if (--bo_gem->refcount == 0) { - struct dri_gem_bo_bucket *bucket; + struct drm_intel_gem_bo_bucket *bucket; if (bo_gem->relocs != NULL) { int i; /* Unreference all the target buffers */ for (i = 0; i < bo_gem->reloc_count; i++) - dri_gem_bo_unreference_locked(bo_gem->reloc_target_bo[i]); + drm_intel_gem_bo_unreference_locked(bo_gem->reloc_target_bo[i]); free(bo_gem->reloc_target_bo); free(bo_gem->relocs); } @@ -471,7 +473,7 @@ dri_gem_bo_unreference_locked(dri_bo *bo) DBG("bo_unreference final: %d (%s)\n", bo_gem->gem_handle, bo_gem->name); - bucket = dri_gem_bo_bucket_for_size(bufmgr_gem, bo->size); + bucket = drm_intel_gem_bo_bucket_for_size(bufmgr_gem, bo->size); /* Put the buffer into our internal cache for reuse if we can. */ if (bucket != NULL && (bucket->max_entries == -1 || @@ -489,26 +491,26 @@ dri_gem_bo_unreference_locked(dri_bo *bo) bucket->tail = &bo_gem->next; bucket->num_entries++; } else { - dri_gem_bo_free(bo); + drm_intel_gem_bo_free(bo); } } } static void -dri_gem_bo_unreference(dri_bo *bo) +drm_intel_gem_bo_unreference(drm_intel_bo *bo) { - dri_bufmgr_gem *bufmgr_gem = (dri_bufmgr_gem *)bo->bufmgr; + drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bo->bufmgr; pthread_mutex_lock(&bufmgr_gem->lock); - dri_gem_bo_unreference_locked(bo); + drm_intel_gem_bo_unreference_locked(bo); pthread_mutex_unlock(&bufmgr_gem->lock); } static int -dri_gem_bo_map(dri_bo *bo, int write_enable) +drm_intel_gem_bo_map(drm_intel_bo *bo, int write_enable) { - dri_bufmgr_gem *bufmgr_gem = (dri_bufmgr_gem *)bo->bufmgr; - dri_bo_gem *bo_gem = (dri_bo_gem *)bo; + drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bo->bufmgr; + drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo; struct drm_i915_gem_set_domain set_domain; int ret; @@ -568,10 +570,10 @@ dri_gem_bo_map(dri_bo *bo, int write_enable) } static int -dri_gem_bo_unmap(dri_bo *bo) +drm_intel_gem_bo_unmap(drm_intel_bo *bo) { - dri_bufmgr_gem *bufmgr_gem = (dri_bufmgr_gem *)bo->bufmgr; - dri_bo_gem *bo_gem = (dri_bo_gem *)bo; + drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bo->bufmgr; + drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo; struct drm_i915_gem_sw_finish sw_finish; int ret; @@ -594,11 +596,11 @@ dri_gem_bo_unmap(dri_bo *bo) } static int -dri_gem_bo_subdata (dri_bo *bo, unsigned long offset, - unsigned long size, const void *data) +drm_intel_gem_bo_subdata (drm_intel_bo *bo, unsigned long offset, + unsigned long size, const void *data) { - dri_bufmgr_gem *bufmgr_gem = (dri_bufmgr_gem *)bo->bufmgr; - dri_bo_gem *bo_gem = (dri_bo_gem *)bo; + drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bo->bufmgr; + drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo; struct drm_i915_gem_pwrite pwrite; int ret; @@ -620,11 +622,11 @@ dri_gem_bo_subdata (dri_bo *bo, unsigned long offset, } static int -dri_gem_bo_get_subdata (dri_bo *bo, unsigned long offset, - unsigned long size, void *data) +drm_intel_gem_bo_get_subdata (drm_intel_bo *bo, unsigned long offset, + unsigned long size, void *data) { - dri_bufmgr_gem *bufmgr_gem = (dri_bufmgr_gem *)bo->bufmgr; - dri_bo_gem *bo_gem = (dri_bo_gem *)bo; + drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bo->bufmgr; + drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo; struct drm_i915_gem_pread pread; int ret; @@ -646,10 +648,10 @@ dri_gem_bo_get_subdata (dri_bo *bo, unsigned long offset, } static void -dri_gem_bo_wait_rendering(dri_bo *bo) +drm_intel_gem_bo_wait_rendering(drm_intel_bo *bo) { - dri_bufmgr_gem *bufmgr_gem = (dri_bufmgr_gem *)bo->bufmgr; - dri_bo_gem *bo_gem = (dri_bo_gem *)bo; + drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bo->bufmgr; + drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo; struct drm_i915_gem_set_domain set_domain; int ret; @@ -666,9 +668,9 @@ dri_gem_bo_wait_rendering(dri_bo *bo) } static void -dri_bufmgr_gem_destroy(dri_bufmgr *bufmgr) +drm_intel_bufmgr_gem_destroy(drm_intel_bufmgr *bufmgr) { - dri_bufmgr_gem *bufmgr_gem = (dri_bufmgr_gem *)bufmgr; + drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bufmgr; int i; free(bufmgr_gem->exec_objects); @@ -677,9 +679,9 @@ dri_bufmgr_gem_destroy(dri_bufmgr *bufmgr) pthread_mutex_destroy(&bufmgr_gem->lock); /* Free any cached buffer objects we were going to reuse */ - for (i = 0; i < INTEL_GEM_BO_BUCKETS; i++) { - struct dri_gem_bo_bucket *bucket = &bufmgr_gem->cache_bucket[i]; - dri_bo_gem *bo_gem; + for (i = 0; i < DRM_INTEL_GEM_BO_BUCKETS; i++) { + struct drm_intel_gem_bo_bucket *bucket = &bufmgr_gem->cache_bucket[i]; + drm_intel_bo_gem *bo_gem; while ((bo_gem = bucket->head) != NULL) { bucket->head = bo_gem->next; @@ -687,7 +689,7 @@ dri_bufmgr_gem_destroy(dri_bufmgr *bufmgr) bucket->tail = &bucket->head; bucket->num_entries--; - dri_gem_bo_free(&bo_gem->bo); + drm_intel_gem_bo_free(&bo_gem->bo); } } @@ -704,18 +706,19 @@ dri_bufmgr_gem_destroy(dri_bufmgr *bufmgr) * last known offset in target_bo. */ static int -dri_gem_bo_emit_reloc(dri_bo *bo, uint32_t read_domains, uint32_t write_domain, - uint32_t delta, uint32_t offset, dri_bo *target_bo) +drm_intel_gem_bo_emit_reloc(drm_intel_bo *bo, uint32_t offset, + drm_intel_bo *target_bo, uint32_t target_offset, + uint32_t read_domains, uint32_t write_domain) { - dri_bufmgr_gem *bufmgr_gem = (dri_bufmgr_gem *)bo->bufmgr; - dri_bo_gem *bo_gem = (dri_bo_gem *)bo; - dri_bo_gem *target_bo_gem = (dri_bo_gem *)target_bo; + drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bo->bufmgr; + drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo; + drm_intel_bo_gem *target_bo_gem = (drm_intel_bo_gem *)target_bo; pthread_mutex_lock(&bufmgr_gem->lock); /* Create a new relocation list if needed */ if (bo_gem->relocs == NULL) - intel_setup_reloc_list(bo); + drm_intel_setup_reloc_list(bo); /* Check overflow */ assert(bo_gem->reloc_count < bufmgr_gem->max_relocs); @@ -734,7 +737,7 @@ dri_gem_bo_emit_reloc(dri_bo *bo, uint32_t read_domains, uint32_t write_domain, target_bo_gem->used_as_reloc_target = 1; bo_gem->relocs[bo_gem->reloc_count].offset = offset; - bo_gem->relocs[bo_gem->reloc_count].delta = delta; + bo_gem->relocs[bo_gem->reloc_count].delta = target_offset; bo_gem->relocs[bo_gem->reloc_count].target_handle = target_bo_gem->gem_handle; bo_gem->relocs[bo_gem->reloc_count].read_domains = read_domains; @@ -742,7 +745,7 @@ dri_gem_bo_emit_reloc(dri_bo *bo, uint32_t read_domains, uint32_t write_domain, bo_gem->relocs[bo_gem->reloc_count].presumed_offset = target_bo->offset; bo_gem->reloc_target_bo[bo_gem->reloc_count] = target_bo; - dri_gem_bo_reference_locked(target_bo); + drm_intel_gem_bo_reference_locked(target_bo); bo_gem->reloc_count++; @@ -757,33 +760,33 @@ dri_gem_bo_emit_reloc(dri_bo *bo, uint32_t read_domains, uint32_t write_domain, * index values into the validation list. */ static void -dri_gem_bo_process_reloc(dri_bo *bo) +drm_intel_gem_bo_process_reloc(drm_intel_bo *bo) { - dri_bo_gem *bo_gem = (dri_bo_gem *)bo; + drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo; int i; if (bo_gem->relocs == NULL) return; for (i = 0; i < bo_gem->reloc_count; i++) { - dri_bo *target_bo = bo_gem->reloc_target_bo[i]; + drm_intel_bo *target_bo = bo_gem->reloc_target_bo[i]; /* Continue walking the tree depth-first. */ - dri_gem_bo_process_reloc(target_bo); + drm_intel_gem_bo_process_reloc(target_bo); /* Add the target to the validate list */ - intel_add_validate_buffer(target_bo); + drm_intel_add_validate_buffer(target_bo); } } static void -intel_update_buffer_offsets (dri_bufmgr_gem *bufmgr_gem) +drm_intel_update_buffer_offsets (drm_intel_bufmgr_gem *bufmgr_gem) { int i; for (i = 0; i < bufmgr_gem->exec_count; i++) { - dri_bo *bo = bufmgr_gem->exec_bos[i]; - dri_bo_gem *bo_gem = (dri_bo_gem *)bo; + drm_intel_bo *bo = bufmgr_gem->exec_bos[i]; + drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo; /* Update the buffer offset */ if (bufmgr_gem->exec_objects[i].offset != bo->offset) { @@ -796,22 +799,22 @@ intel_update_buffer_offsets (dri_bufmgr_gem *bufmgr_gem) } static int -dri_gem_bo_exec(dri_bo *bo, int used, - drm_clip_rect_t *cliprects, int num_cliprects, - int DR4) +drm_intel_gem_bo_exec(drm_intel_bo *bo, int used, + drm_clip_rect_t *cliprects, int num_cliprects, + int DR4) { - dri_bufmgr_gem *bufmgr_gem = (dri_bufmgr_gem *)bo->bufmgr; + drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bo->bufmgr; struct drm_i915_gem_execbuffer execbuf; int ret, i; pthread_mutex_lock(&bufmgr_gem->lock); /* Update indices and set up the validate list. */ - dri_gem_bo_process_reloc(bo); + drm_intel_gem_bo_process_reloc(bo); /* Add the batch buffer to the validation list. There are no relocations * pointing to it. */ - intel_add_validate_buffer(bo); + drm_intel_add_validate_buffer(bo); execbuf.buffers_ptr = (uintptr_t)bufmgr_gem->exec_objects; execbuf.buffer_count = bufmgr_gem->exec_count; @@ -826,21 +829,21 @@ dri_gem_bo_exec(dri_bo *bo, int used, ret = ioctl(bufmgr_gem->fd, DRM_IOCTL_I915_GEM_EXECBUFFER, &execbuf); } while (ret != 0 && errno == EAGAIN); - intel_update_buffer_offsets (bufmgr_gem); + drm_intel_update_buffer_offsets (bufmgr_gem); if (bufmgr_gem->bufmgr.debug) - dri_gem_dump_validation_list(bufmgr_gem); + drm_intel_gem_dump_validation_list(bufmgr_gem); for (i = 0; i < bufmgr_gem->exec_count; i++) { - dri_bo *bo = bufmgr_gem->exec_bos[i]; - dri_bo_gem *bo_gem = (dri_bo_gem *)bo; + drm_intel_bo *bo = bufmgr_gem->exec_bos[i]; + drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo; /* Need to call swrast on next bo_map */ bo_gem->swrast = 0; /* Disconnect the buffer from the validate list */ bo_gem->validate_index = -1; - dri_gem_bo_unreference_locked(bo); + drm_intel_gem_bo_unreference_locked(bo); bufmgr_gem->exec_bos[i] = NULL; } bufmgr_gem->exec_count = 0; @@ -850,10 +853,10 @@ dri_gem_bo_exec(dri_bo *bo, int used, } static int -dri_gem_bo_pin(dri_bo *bo, uint32_t alignment) +drm_intel_gem_bo_pin(drm_intel_bo *bo, uint32_t alignment) { - dri_bufmgr_gem *bufmgr_gem = (dri_bufmgr_gem *)bo->bufmgr; - dri_bo_gem *bo_gem = (dri_bo_gem *)bo; + drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bo->bufmgr; + drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo; struct drm_i915_gem_pin pin; int ret; @@ -869,10 +872,10 @@ dri_gem_bo_pin(dri_bo *bo, uint32_t alignment) } static int -dri_gem_bo_unpin(dri_bo *bo) +drm_intel_gem_bo_unpin(drm_intel_bo *bo) { - dri_bufmgr_gem *bufmgr_gem = (dri_bufmgr_gem *)bo->bufmgr; - dri_bo_gem *bo_gem = (dri_bo_gem *)bo; + drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bo->bufmgr; + drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo; struct drm_i915_gem_unpin unpin; int ret; @@ -886,15 +889,17 @@ dri_gem_bo_unpin(dri_bo *bo) } static int -dri_gem_bo_set_tiling(dri_bo *bo, uint32_t *tiling_mode) +drm_intel_gem_bo_set_tiling(drm_intel_bo *bo, uint32_t *tiling_mode, + uint32_t stride) { - dri_bufmgr_gem *bufmgr_gem = (dri_bufmgr_gem *)bo->bufmgr; - dri_bo_gem *bo_gem = (dri_bo_gem *)bo; + drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bo->bufmgr; + drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo; struct drm_i915_gem_set_tiling set_tiling; int ret; set_tiling.handle = bo_gem->gem_handle; set_tiling.tiling_mode = *tiling_mode; + set_tiling.stride = stride; ret = ioctl(bufmgr_gem->fd, DRM_IOCTL_I915_GEM_SET_TILING, &set_tiling); if (ret != 0) { @@ -907,10 +912,11 @@ dri_gem_bo_set_tiling(dri_bo *bo, uint32_t *tiling_mode) } static int -dri_gem_bo_get_tiling(dri_bo *bo, uint32_t *tiling_mode, uint32_t *swizzle_mode) +drm_intel_gem_bo_get_tiling(drm_intel_bo *bo, uint32_t *tiling_mode, + uint32_t *swizzle_mode) { - dri_bufmgr_gem *bufmgr_gem = (dri_bufmgr_gem *)bo->bufmgr; - dri_bo_gem *bo_gem = (dri_bo_gem *)bo; + drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bo->bufmgr; + drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo; struct drm_i915_gem_get_tiling get_tiling; int ret; @@ -929,10 +935,10 @@ dri_gem_bo_get_tiling(dri_bo *bo, uint32_t *tiling_mode, uint32_t *swizzle_mode) } static int -dri_gem_bo_flink(dri_bo *bo, uint32_t *name) +drm_intel_gem_bo_flink(drm_intel_bo *bo, uint32_t *name) { - dri_bufmgr_gem *bufmgr_gem = (dri_bufmgr_gem *)bo->bufmgr; - dri_bo_gem *bo_gem = (dri_bo_gem *)bo; + drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bo->bufmgr; + drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo; struct drm_gem_flink flink; int ret; @@ -957,12 +963,12 @@ dri_gem_bo_flink(dri_bo *bo, uint32_t *name) * in flight at once. */ void -intel_bufmgr_gem_enable_reuse(dri_bufmgr *bufmgr) +drm_intel_bufmgr_gem_enable_reuse(drm_intel_bufmgr *bufmgr) { - dri_bufmgr_gem *bufmgr_gem = (dri_bufmgr_gem *)bufmgr; + drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bufmgr; int i; - for (i = 0; i < INTEL_GEM_BO_BUCKETS; i++) { + for (i = 0; i < DRM_INTEL_GEM_BO_BUCKETS; i++) { bufmgr_gem->cache_bucket[i].max_entries = -1; } } @@ -972,9 +978,9 @@ intel_bufmgr_gem_enable_reuse(dri_bufmgr *bufmgr) * rooted at bo. */ static int -dri_gem_bo_get_aperture_space(dri_bo *bo) +drm_intel_gem_bo_get_aperture_space(drm_intel_bo *bo) { - dri_bo_gem *bo_gem = (dri_bo_gem *)bo; + drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo; int i; int total = 0; @@ -985,19 +991,19 @@ dri_gem_bo_get_aperture_space(dri_bo *bo) bo_gem->included_in_check_aperture = 1; for (i = 0; i < bo_gem->reloc_count; i++) - total += dri_gem_bo_get_aperture_space(bo_gem->reloc_target_bo[i]); + total += drm_intel_gem_bo_get_aperture_space(bo_gem->reloc_target_bo[i]); return total; } /** - * Clear the flag set by dri_gem_bo_get_aperture_space() so we're ready for - * the next dri_bufmgr_check_aperture_space() call. + * Clear the flag set by drm_intel_gem_bo_get_aperture_space() so we're ready + * for the next drm_intel_bufmgr_check_aperture_space() call. */ static void -dri_gem_bo_clear_aperture_space_flag(dri_bo *bo) +drm_intel_gem_bo_clear_aperture_space_flag(drm_intel_bo *bo) { - dri_bo_gem *bo_gem = (dri_bo_gem *)bo; + drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo; int i; if (bo == NULL || !bo_gem->included_in_check_aperture) @@ -1006,7 +1012,7 @@ dri_gem_bo_clear_aperture_space_flag(dri_bo *bo) bo_gem->included_in_check_aperture = 0; for (i = 0; i < bo_gem->reloc_count; i++) - dri_gem_bo_clear_aperture_space_flag(bo_gem->reloc_target_bo[i]); + drm_intel_gem_bo_clear_aperture_space_flag(bo_gem->reloc_target_bo[i]); } /** @@ -1026,15 +1032,15 @@ dri_gem_bo_clear_aperture_space_flag(dri_bo *bo) * get better parallelism. */ static int -dri_gem_check_aperture_space(dri_bo **bo_array, int count) +drm_intel_gem_check_aperture_space(drm_intel_bo **bo_array, int count) { - dri_bufmgr_gem *bufmgr_gem = (dri_bufmgr_gem *)bo_array[0]->bufmgr; + drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bo_array[0]->bufmgr; unsigned int total = 0; unsigned int threshold = bufmgr_gem->gtt_size * 3 / 4; int i; for (i = 0; i < count; i++) { - dri_bo_gem *bo_gem = (dri_bo_gem *)bo_array[i]; + drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo_array[i]; if (bo_gem != NULL) total += bo_gem->reloc_tree_size; } @@ -1042,10 +1048,10 @@ dri_gem_check_aperture_space(dri_bo **bo_array, int count) if (total > threshold) { total = 0; for (i = 0; i < count; i++) - total += dri_gem_bo_get_aperture_space(bo_array[i]); + total += drm_intel_gem_bo_get_aperture_space(bo_array[i]); for (i = 0; i < count; i++) - dri_gem_bo_clear_aperture_space_flag(bo_array[i]); + drm_intel_gem_bo_clear_aperture_space_flag(bo_array[i]); } if (total > bufmgr_gem->gtt_size * 3 / 4) { @@ -1065,10 +1071,10 @@ dri_gem_check_aperture_space(dri_bo **bo_array, int count) * * \param fd File descriptor of the opened DRM device. */ -dri_bufmgr * -intel_bufmgr_gem_init(int fd, int batch_size) +drm_intel_bufmgr * +drm_intel_bufmgr_gem_init(int fd, int batch_size) { - dri_bufmgr_gem *bufmgr_gem; + drm_intel_bufmgr_gem *bufmgr_gem; struct drm_i915_gem_get_aperture aperture; int ret, i; @@ -1101,26 +1107,26 @@ intel_bufmgr_gem_init(int fd, int batch_size) */ bufmgr_gem->max_relocs = batch_size / sizeof(uint32_t) / 2 - 2; - bufmgr_gem->bufmgr.bo_alloc = dri_gem_bo_alloc; - bufmgr_gem->bufmgr.bo_reference = dri_gem_bo_reference; - bufmgr_gem->bufmgr.bo_unreference = dri_gem_bo_unreference; - bufmgr_gem->bufmgr.bo_map = dri_gem_bo_map; - bufmgr_gem->bufmgr.bo_unmap = dri_gem_bo_unmap; - bufmgr_gem->bufmgr.bo_subdata = dri_gem_bo_subdata; - bufmgr_gem->bufmgr.bo_get_subdata = dri_gem_bo_get_subdata; - bufmgr_gem->bufmgr.bo_wait_rendering = dri_gem_bo_wait_rendering; - bufmgr_gem->bufmgr.bo_emit_reloc = dri_gem_bo_emit_reloc; - bufmgr_gem->bufmgr.bo_pin = dri_gem_bo_pin; - bufmgr_gem->bufmgr.bo_unpin = dri_gem_bo_unpin; - bufmgr_gem->bufmgr.bo_get_tiling = dri_gem_bo_get_tiling; - bufmgr_gem->bufmgr.bo_set_tiling = dri_gem_bo_set_tiling; - bufmgr_gem->bufmgr.bo_flink = dri_gem_bo_flink; - bufmgr_gem->bufmgr.bo_exec = dri_gem_bo_exec; - bufmgr_gem->bufmgr.destroy = dri_bufmgr_gem_destroy; + bufmgr_gem->bufmgr.bo_alloc = drm_intel_gem_bo_alloc; + bufmgr_gem->bufmgr.bo_reference = drm_intel_gem_bo_reference; + bufmgr_gem->bufmgr.bo_unreference = drm_intel_gem_bo_unreference; + bufmgr_gem->bufmgr.bo_map = drm_intel_gem_bo_map; + bufmgr_gem->bufmgr.bo_unmap = drm_intel_gem_bo_unmap; + bufmgr_gem->bufmgr.bo_subdata = drm_intel_gem_bo_subdata; + bufmgr_gem->bufmgr.bo_get_subdata = drm_intel_gem_bo_get_subdata; + bufmgr_gem->bufmgr.bo_wait_rendering = drm_intel_gem_bo_wait_rendering; + bufmgr_gem->bufmgr.bo_emit_reloc = drm_intel_gem_bo_emit_reloc; + bufmgr_gem->bufmgr.bo_pin = drm_intel_gem_bo_pin; + bufmgr_gem->bufmgr.bo_unpin = drm_intel_gem_bo_unpin; + bufmgr_gem->bufmgr.bo_get_tiling = drm_intel_gem_bo_get_tiling; + bufmgr_gem->bufmgr.bo_set_tiling = drm_intel_gem_bo_set_tiling; + bufmgr_gem->bufmgr.bo_flink = drm_intel_gem_bo_flink; + bufmgr_gem->bufmgr.bo_exec = drm_intel_gem_bo_exec; + bufmgr_gem->bufmgr.destroy = drm_intel_bufmgr_gem_destroy; bufmgr_gem->bufmgr.debug = 0; - bufmgr_gem->bufmgr.check_aperture_space = dri_gem_check_aperture_space; + bufmgr_gem->bufmgr.check_aperture_space = drm_intel_gem_check_aperture_space; /* Initialize the linked lists for BO reuse cache. */ - for (i = 0; i < INTEL_GEM_BO_BUCKETS; i++) + for (i = 0; i < DRM_INTEL_GEM_BO_BUCKETS; i++) bufmgr_gem->cache_bucket[i].tail = &bufmgr_gem->cache_bucket[i].head; return &bufmgr_gem->bufmgr; diff --git a/libdrm/intel/intel_bufmgr_priv.h b/libdrm/intel/intel_bufmgr_priv.h index cbf3b311..76d31e47 100644 --- a/libdrm/intel/intel_bufmgr_priv.h +++ b/libdrm/intel/intel_bufmgr_priv.h @@ -39,7 +39,7 @@ * * Contains public methods followed by private storage for the buffer manager. */ -struct _dri_bufmgr { +struct _drm_intel_bufmgr { /** * Allocate a buffer object. * @@ -48,17 +48,17 @@ struct _dri_bufmgr { * bo_map() to be used by the CPU, and validated for use using bo_validate() * to be used from the graphics device. */ - dri_bo *(*bo_alloc)(dri_bufmgr *bufmgr_ctx, const char *name, - unsigned long size, unsigned int alignment); + drm_intel_bo *(*bo_alloc)(drm_intel_bufmgr *bufmgr, const char *name, + unsigned long size, unsigned int alignment); /** Takes a reference on a buffer object */ - void (*bo_reference)(dri_bo *bo); + void (*bo_reference)(drm_intel_bo *bo); /** * Releases a reference on a buffer object, freeing the data if * rerefences remain. */ - void (*bo_unreference)(dri_bo *bo); + void (*bo_unreference)(drm_intel_bo *bo); /** * Maps the buffer into userspace. @@ -67,28 +67,28 @@ struct _dri_bufmgr { * buffer to complete, first. The resulting mapping is available at * buf->virtual. */ - int (*bo_map)(dri_bo *buf, int write_enable); + int (*bo_map)(drm_intel_bo *bo, int write_enable); /** Reduces the refcount on the userspace mapping of the buffer object. */ - int (*bo_unmap)(dri_bo *buf); + int (*bo_unmap)(drm_intel_bo *bo); /** * Write data into an object. * * This is an optional function, if missing, - * dri_bo will map/memcpy/unmap. + * drm_intel_bo will map/memcpy/unmap. */ - int (*bo_subdata) (dri_bo *buf, unsigned long offset, - unsigned long size, const void *data); + int (*bo_subdata)(drm_intel_bo *bo, unsigned long offset, + unsigned long size, const void *data); /** * Read data from an object * * This is an optional function, if missing, - * dri_bo will map/memcpy/unmap. + * drm_intel_bo will map/memcpy/unmap. */ - int (*bo_get_subdata) (dri_bo *bo, unsigned long offset, - unsigned long size, void *data); + int (*bo_get_subdata)(drm_intel_bo *bo, unsigned long offset, + unsigned long size, void *data); /** * Waits for rendering to an object by the GPU to have completed. @@ -96,12 +96,12 @@ struct _dri_bufmgr { * This is not required for any access to the BO by bo_map, bo_subdata, etc. * It is merely a way for the driver to implement glFinish. */ - void (*bo_wait_rendering) (dri_bo *bo); + void (*bo_wait_rendering)(drm_intel_bo *bo); /** * Tears down the buffer manager instance. */ - void (*destroy)(dri_bufmgr *bufmgr); + void (*destroy)(drm_intel_bufmgr *bufmgr); /** * Add relocation entry in reloc_buf, which will be updated with the @@ -109,23 +109,23 @@ struct _dri_bufmgr { * * Relocations remain in place for the lifetime of the buffer object. * - * \param reloc_buf Buffer to write the relocation into. + * \param bo Buffer to write the relocation into. + * \param offset Byte offset within reloc_bo of the pointer to target_bo. + * \param target_bo Buffer whose offset should be written into the + * relocation entry. + * \param target_offset Constant value to be added to target_bo's offset in + * relocation entry. * \param read_domains GEM read domains which the buffer will be read into * by the command that this relocation is part of. * \param write_domains GEM read domains which the buffer will be dirtied * in by the command that this relocation is part of. - * \param delta Constant value to be added to the relocation target's - * offset. - * \param offset Byte offset within batch_buf of the relocated pointer. - * \param target Buffer whose offset should be written into the relocation - * entry. */ - int (*bo_emit_reloc)(dri_bo *reloc_buf, - uint32_t read_domains, uint32_t write_domain, - uint32_t delta, uint32_t offset, dri_bo *target); + int (*bo_emit_reloc)(drm_intel_bo *bo, uint32_t offset, + drm_intel_bo *target_bo, uint32_t target_offset, + uint32_t read_domains, uint32_t write_domain); /** Executes the command buffer pointed to by bo. */ - int (*bo_exec)(dri_bo *bo, int used, + int (*bo_exec)(drm_intel_bo *bo, int used, drm_clip_rect_t *cliprects, int num_cliprects, int DR4); @@ -135,20 +135,21 @@ struct _dri_bufmgr { * \param buf Buffer to pin * \param alignment Required alignment for aperture, in bytes */ - int (*bo_pin) (dri_bo *buf, uint32_t alignment); + int (*bo_pin)(drm_intel_bo *bo, uint32_t alignment); /** * Unpin a buffer from the aperture, allowing it to be removed * * \param buf Buffer to unpin */ - int (*bo_unpin) (dri_bo *buf); + int (*bo_unpin)(drm_intel_bo *bo); /** * Ask that the buffer be placed in tiling mode * * \param buf Buffer to set tiling mode for * \param tiling_mode desired, and returned tiling mode */ - int (*bo_set_tiling) (dri_bo *bo, uint32_t *tiling_mode); + int (*bo_set_tiling)(drm_intel_bo *bo, uint32_t *tiling_mode, + uint32_t stride); /** * Get the current tiling (and resulting swizzling) mode for the bo. * @@ -156,17 +157,17 @@ struct _dri_bufmgr { * \param tiling_mode returned tiling mode * \param swizzle_mode returned swizzling mode */ - int (*bo_get_tiling) (dri_bo *bo, uint32_t *tiling_mode, - uint32_t *swizzle_mode); + int (*bo_get_tiling)(drm_intel_bo *bo, uint32_t *tiling_mode, + uint32_t *swizzle_mode); /** * Create a visible name for a buffer which can be used by other apps * * \param buf Buffer to create a name for * \param name Returned name */ - int (*bo_flink) (dri_bo *buf, uint32_t *name); + int (*bo_flink)(drm_intel_bo *bo, uint32_t *name); - int (*check_aperture_space)(dri_bo **bo_array, int count); + int (*check_aperture_space)(drm_intel_bo **bo_array, int count); int debug; /**< Enables verbose debugging printouts */ }; |